{"signature": "def debug(user, message):", "body": "message_user(user, message, constants.DEBUG)<EOL>", "docstring": "Adds a message with the ``DEBUG`` level.\n\n:param user: User instance\n:param message: Message to show", "id": "f4:m0"}
{"signature": "def success(user, message):", "body": "message_user(user, message, constants.SUCCESS)<EOL>", "docstring": "Adds a message with the ``SUCCESS`` level.\n\n:param user: User instance\n:param message: Message to show", "id": "f4:m2"}
{"signature": "def process_response(self, request, response):", "body": "if hasattr(request, \"<STR_LIT>\") and hasattr(request, \"<STR_LIT:user>\") and request.user.is_authenticated():<EOL><INDENT>msgs = get_messages(request.user)<EOL>if msgs:<EOL><INDENT>for msg, level in msgs:<EOL><INDENT>messages.add_message(request, level, msg)<EOL><DEDENT><DEDENT><DEDENT>return response<EOL>", "docstring": "Check for messages for this user and, if it exists,\ncall the messages API with it", "id": "f5:c0:m0"}
{"signature": "def table(name, auth=None, eager=True):", "body": "auth = auth or []<EOL>dynamodb = boto.connect_dynamodb(*auth)<EOL>table = dynamodb.get_table(name)<EOL>return Table(table=table, eager=eager)<EOL>", "docstring": "Returns a given table for the given user.", "id": "f8:m0"}
{"signature": "def api_request(methods=None, require_token=True):", "body": "def decorator(view_func):<EOL><INDENT>@wraps(view_func, assigned=available_attrs(view_func))<EOL>def _wrapped_view(request, *args, **kwargs):<EOL><INDENT>ApiToken = apps.get_model('<STR_LIT>', '<STR_LIT>')<EOL>m = methods if methods is not None else DEFAULT_API_METHODS<EOL>if request.method not in m:<EOL><INDENT>response = ApiResponse(False, '<STR_LIT>', status=<NUM_LIT>)<EOL>response['<STR_LIT>'] = '<STR_LIT:U+002CU+0020>'.join(methods)<EOL>return response<EOL><DEDENT>try:<EOL><INDENT>data = json.loads(request.body.decode('<STR_LIT:utf-8>')) if request.body else {}<EOL>if require_token:<EOL><INDENT>token_string = request.GET['<STR_LIT>'] if request.method == '<STR_LIT:GET>' else data['<STR_LIT>']<EOL>try:<EOL><INDENT>token = ApiToken.objects.get(token=token_string)<EOL>token.save()  <EOL>data['<STR_LIT>'] = token<EOL><DEDENT>except ApiToken.DoesNotExist:<EOL><INDENT>logger.exception('<STR_LIT>'.format(token_string))<EOL>return ApiResponse(False, '<STR_LIT>', status=<NUM_LIT>)<EOL><DEDENT><DEDENT>return ApiResponse(data=view_func(request, data=data, *args, **kwargs))<EOL><DEDENT>except Exception as e:<EOL><INDENT>if e.__class__.__name__ == '<STR_LIT>':<EOL><INDENT>logger.exception('<STR_LIT>')<EOL>return ApiResponse(False, '<STR_LIT>'.format(e), status=<NUM_LIT>)<EOL><DEDENT>else:<EOL><INDENT>logger.exception('<STR_LIT>')<EOL>return ApiResponse(False, '<STR_LIT>'.format(e), status=<NUM_LIT>)<EOL><DEDENT><DEDENT><DEDENT>return _wrapped_view<EOL><DEDENT>return decorator<EOL>", "docstring": "View decorator that handles JSON based API requests and responses consistently.\n:param methods: A list of allowed methods\n:param require_token: Whether API token is checked automatically or not", "id": "f21:m0"}
{"signature": "def get_tweets(user, pages=<NUM_LIT>):", "body": "url = f'<STR_LIT>'<EOL>headers = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': f'<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT:yes>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'<EOL>}<EOL>def gen_tweets(pages):<EOL><INDENT>r = session.get(url, headers=headers)<EOL>while pages > <NUM_LIT:0>:<EOL><INDENT>try:<EOL><INDENT>html = HTML(html=r.json()['<STR_LIT>'],<EOL>url='<STR_LIT>', default_encoding='<STR_LIT:utf-8>')<EOL><DEDENT>except KeyError:<EOL><INDENT>raise ValueError(<EOL>f'<STR_LIT>')<EOL><DEDENT>comma = \"<STR_LIT:U+002C>\"<EOL>dot = \"<STR_LIT:.>\"<EOL>tweets = []<EOL>for tweet in html.find('<STR_LIT>'):<EOL><INDENT>try:<EOL><INDENT>text = tweet.find('<STR_LIT>')[<NUM_LIT:0>].full_text<EOL><DEDENT>except IndexError:  <EOL><INDENT>continue<EOL><DEDENT>tweet_id = tweet.find('<STR_LIT>')[<NUM_LIT:0>].attrs['<STR_LIT>']<EOL>time = datetime.fromtimestamp(int(tweet.find('<STR_LIT>')[<NUM_LIT:0>].attrs['<STR_LIT>']) / <NUM_LIT>)<EOL>interactions = [<EOL>x.text<EOL>for x in tweet.find('<STR_LIT>')<EOL>]<EOL>replies = int(<EOL>interactions[<NUM_LIT:0>].split('<STR_LIT:U+0020>')[<NUM_LIT:0>].replace(comma, '<STR_LIT>').replace(dot, '<STR_LIT>')<EOL>or interactions[<NUM_LIT:3>]<EOL>)<EOL>retweets = int(<EOL>interactions[<NUM_LIT:1>].split('<STR_LIT:U+0020>')[<NUM_LIT:0>].replace(comma, '<STR_LIT>').replace(dot, '<STR_LIT>')<EOL>or interactions[<NUM_LIT:4>]<EOL>or interactions[<NUM_LIT:5>]<EOL>)<EOL>likes = int(<EOL>interactions[<NUM_LIT:2>].split('<STR_LIT:U+0020>')[<NUM_LIT:0>].replace(comma, '<STR_LIT>').replace(dot, '<STR_LIT>')<EOL>or interactions[<NUM_LIT:6>]<EOL>or interactions[<NUM_LIT:7>]<EOL>)<EOL>hashtags = [<EOL>hashtag_node.full_text<EOL>for hashtag_node in tweet.find('<STR_LIT>')<EOL>]<EOL>urls = [<EOL>url_node.attrs['<STR_LIT>']<EOL>for url_node in tweet.find('<STR_LIT>')<EOL>]<EOL>photos = [<EOL>photo_node.attrs['<STR_LIT>']<EOL>for photo_node in tweet.find('<STR_LIT>')<EOL>]<EOL>videos = []<EOL>video_nodes = tweet.find(\"<STR_LIT>\")<EOL>for node in video_nodes:<EOL><INDENT>styles = node.attrs['<STR_LIT>'].split()<EOL>for style in styles:<EOL><INDENT>if style.startswith('<STR_LIT>'):<EOL><INDENT>tmp = style.split('<STR_LIT:/>')[-<NUM_LIT:1>]<EOL>video_id = tmp[:tmp.index('<STR_LIT>')]<EOL>videos.append({'<STR_LIT:id>': video_id})<EOL><DEDENT><DEDENT><DEDENT>tweets.append({<EOL>'<STR_LIT>': tweet_id,<EOL>'<STR_LIT:time>': time,<EOL>'<STR_LIT:text>': text,<EOL>'<STR_LIT>': replies,<EOL>'<STR_LIT>': retweets,<EOL>'<STR_LIT>': likes,<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': hashtags, '<STR_LIT>': urls,<EOL>'<STR_LIT>': photos, '<STR_LIT>': videos<EOL>}<EOL>})<EOL><DEDENT>last_tweet = html.find('<STR_LIT>')[-<NUM_LIT:1>].attrs['<STR_LIT>']<EOL>for tweet in tweets:<EOL><INDENT>if tweet:<EOL><INDENT>tweet['<STR_LIT:text>'] = re.sub('<STR_LIT:http>', '<STR_LIT>', tweet['<STR_LIT:text>'], <NUM_LIT:1>)<EOL>yield tweet<EOL><DEDENT><DEDENT>r = session.get(url, params={'<STR_LIT>': last_tweet}, headers=headers)<EOL>pages += -<NUM_LIT:1><EOL><DEDENT><DEDENT>yield from gen_tweets(pages)<EOL>", "docstring": "Gets tweets for a given user, via the Twitter frontend API.", "id": "f32:m0"}
{"signature": "def add_deformation(chn_names, data):", "body": "if \"<STR_LIT>\" not in chn_names:<EOL><INDENT>for ii, ch in enumerate(chn_names):<EOL><INDENT>if ch == \"<STR_LIT>\":<EOL><INDENT>chn_names.append(\"<STR_LIT>\")<EOL>data.append(<NUM_LIT:1>-data[ii])<EOL><DEDENT><DEDENT><DEDENT>return chn_names, data<EOL>", "docstring": "From circularity, compute the deformation\n\n    This method is useful for RT-DC data sets that contain\n    the circularity but not the deformation.", "id": "f44:m1"}
{"signature": "def get_leaves(self):", "body": "return [n for n in self.walk() if n.is_leaf]<EOL>", "docstring": "Get all the leaf nodes of the subtree descending from this node.\n\n:return: List of Nodes with no descendants.", "id": "f55:c0:m14"}
{"signature": "def get_node(self, label):", "body": "for n in self.walk():<EOL><INDENT>if n.name == label:<EOL><INDENT>return n<EOL><DEDENT><DEDENT>", "docstring": "Gets the specified node by name.\n\n:return: Node or None if name does not exist in tree", "id": "f55:c0:m15"}
{"signature": "def get_leaf_names(self):", "body": "return [n.name for n in self.get_leaves()]<EOL>", "docstring": "Get the names of all the leaf nodes of the subtree descending from\nthis node.\n\n:return: List of names of Nodes with no descendants.", "id": "f55:c0:m16"}
{"signature": "@classmethod<EOL><INDENT>def create(cls, name=None, length=None, descendants=None, **kw):<DEDENT>", "body": "node = cls(name=name, length=length, **kw)<EOL>for descendant in descendants or []:<EOL><INDENT>node.add_descendant(descendant)<EOL><DEDENT>return node<EOL>", "docstring": "Create a new `Node` object.\n\n:param name: Node label.\n:param length: Branch length from the new node to its parent.\n:param descendants: list of descendants or `None`.\n:param kw: Additonal keyword arguments are passed through to `Node.__init__`.\n:return: `Node` instance.", "id": "f55:c0:m4"}
{"signature": "@property<EOL><INDENT>def newick(self):<DEDENT>", "body": "label = self.name or '<STR_LIT>'<EOL>if self._length:<EOL><INDENT>label += '<STR_LIT::>' + self._length<EOL><DEDENT>descendants = '<STR_LIT:U+002C>'.join([n.newick for n in self.descendants])<EOL>if descendants:<EOL><INDENT>descendants = '<STR_LIT:(>' + descendants + '<STR_LIT:)>'<EOL><DEDENT>return descendants + label<EOL>", "docstring": "The representation of the Node in Newick format.", "id": "f55:c0:m6"}
{"signature": "def loads(s, strip_comments=False, **kw):", "body": "kw['<STR_LIT>'] = strip_comments<EOL>return [parse_node(ss.strip(), **kw) for ss in s.split('<STR_LIT:;>') if ss.strip()]<EOL>", "docstring": "Load a list of trees from a Newick formatted string.\n\n:param s: Newick formatted string.\n:param strip_comments: Flag signaling whether to strip comments enclosed in square \\\nbrackets.\n:param kw: Keyword arguments are passed through to `Node.create`.\n:return: List of Node objects.", "id": "f55:m2"}
{"signature": "def visit(self, visitor, predicate=None, **kw):", "body": "predicate = predicate or bool<EOL>for n in self.walk(**kw):<EOL><INDENT>if predicate(n):<EOL><INDENT>visitor(n)<EOL><DEDENT><DEDENT>", "docstring": "Apply a function to matching nodes in the (sub)tree rooted at self.\n\n:param visitor: A callable accepting a Node object as single argument..\n:param predicate: A callable accepting a Node object as single argument and \\\nreturning a boolean signaling whether Node matches; if `None` all nodes match.\n:param kw: Addtional keyword arguments are passed through to self.walk.", "id": "f55:c0:m12"}
{"signature": "def ascii_art(self, strict=False, show_internal=True):", "body": "cmap = {<EOL>'<STR_LIT>': '<STR_LIT:->',<EOL>'<STR_LIT>': '<STR_LIT:|>',<EOL>'<STR_LIT>': '<STR_LIT:/>',<EOL>'<STR_LIT>': '<STR_LIT:\\\\>',<EOL>'<STR_LIT>': '<STR_LIT:|>',<EOL>'<STR_LIT>': '<STR_LIT:|>',<EOL>'<STR_LIT>': '<STR_LIT:+>',<EOL>}<EOL>def normalize(line):<EOL><INDENT>m = re.compile('<STR_LIT>')<EOL>line = m.sub(lambda m: m.group('<STR_LIT:s>')[<NUM_LIT:1>:], line)<EOL>line = re.sub('<STR_LIT>', '<STR_LIT>', line)  <EOL>line = re.sub('<STR_LIT>', '<STR_LIT>', line)  <EOL>line = re.sub('<STR_LIT>', '<STR_LIT>', line)  <EOL>if strict:<EOL><INDENT>for u, a in cmap.items():<EOL><INDENT>line = line.replace(u, a)<EOL><DEDENT><DEDENT>return line<EOL><DEDENT>return '<STR_LIT:\\n>'.join(<EOL>normalize(l) for l in self._ascii_art(show_internal=show_internal)[<NUM_LIT:0>]<EOL>if set(l) != {'<STR_LIT:U+0020>', '<STR_LIT>'})<EOL>", "docstring": "Return a unicode string representing a tree in ASCII art fashion.\n\n:param strict: Use ASCII characters strictly (for the tree symbols).\n:param show_internal: Show labels of internal nodes.\n:return: unicode string\n\n>>> node = loads('((A,B)C,((D,E)F,G,H)I)J;')[0]\n>>> print(node.ascii_art(show_internal=False, strict=True))\n        /-A\n    /---|\n    |   \\-B\n----|       /-D\n    |   /---|\n    |   |   \\-E\n    \\---|\n        |-G\n        \\-H", "id": "f55:c0:m8"}
{"signature": "def close(self):", "body": "pass<EOL>", "docstring": "Close the socket.", "id": "f58:c0:m4"}
{"signature": "def settimeout(self, timeout):", "body": "pass<EOL>", "docstring": "Set a timeout.", "id": "f58:c0:m3"}
{"signature": "def recv(self, buffer_size):", "body": "return self.msg[<NUM_LIT:0>:buffer_size]<EOL>", "docstring": "Receive a message.", "id": "f58:c0:m1"}
{"signature": "async def read(self, buffer_size):", "body": "return self.msg[<NUM_LIT:0>:buffer_size]<EOL>", "docstring": "Read a message.", "id": "f60:c0:m1"}
{"signature": "def write(self, msg):", "body": "self.msg = msg<EOL>", "docstring": "Write a message.", "id": "f60:c0:m0"}
{"signature": "async def wait_for(self, cmd, value=None, timeout=<NUM_LIT>):", "body": "try:<EOL><INDENT>async with async_timeout(timeout * <NUM_LIT>):<EOL><INDENT>while True:<EOL><INDENT>msgs = await self.receive()<EOL>msg = check_messages(msgs, cmd, value=value)<EOL>if msg:<EOL><INDENT>return msg<EOL><DEDENT><DEDENT><DEDENT><DEDENT>except asyncio.TimeoutError:<EOL><INDENT>return OrderedDict()<EOL><DEDENT>", "docstring": "Hang until command is received.\n\n        If value is supplied, it will hang until ``cmd:value`` is received.\n\n        Parameters\n        ----------\n        cmd : string\n            Command to wait for in bytestring from microscope CAM interface. If\n            ``value`` is falsey, value of received command does not matter.\n        value : string\n            Wait until ``cmd:value`` is received.\n        timeout : int\n            Minutes to wait for command. If timeout is reached, an empty\n            OrderedDict will be returned.\n\n        Returns\n        -------\n        collections.OrderedDict\n            Last received messsage or empty message if timeout is reached.", "id": "f63:c0:m4"}
{"signature": "async def connect(self):", "body": "self.reader, self.writer = await asyncio.open_connection(<EOL>self.host, self.port, loop=self.loop)<EOL>self.welcome_msg = await self.reader.read(self.buffer_size)<EOL>", "docstring": "Connect to LASAF through a CAM-socket.", "id": "f63:c0:m1"}
{"signature": "async def send(self, commands):", "body": "msg = self._prepare_send(commands)<EOL>self.writer.write(msg)<EOL>await self.writer.drain()<EOL>", "docstring": "Send commands to LASAF through CAM-socket.\n\n        Parameters\n        ----------\n        commands : list of tuples or bytes string\n            Commands as a list of tuples or a bytes string. cam.prefix is\n            allways prepended before sending.\n\n        Returns\n        -------\n        int\n            Bytes sent.\n\n        Example\n        -------\n        ::\n\n            >>> # send list of tuples\n            >>> await cam.send([('cmd', 'enableall'), ('value', 'true')])\n\n            >>> # send bytes string\n            >>> await cam.send(b'/cmd:enableall /value:true')", "id": "f63:c0:m2"}
{"signature": "def close(self):", "body": "if self.writer.can_write_eof():<EOL><INDENT>self.writer.write_eof()<EOL><DEDENT>self.writer.close()<EOL>", "docstring": "Close stream.", "id": "f63:c0:m5"}
{"signature": "def logger(function):", "body": "@functools.wraps(function)<EOL>def wrapper(*args, **kwargs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>sep = kwargs.get('<STR_LIT>', '<STR_LIT:U+0020>')<EOL>end = kwargs.get('<STR_LIT:end>', '<STR_LIT>')  <EOL>out = sep.join([repr(x) for x in args])<EOL>out = out + end<EOL>_LOGGER.debug(out)<EOL>return function(*args, **kwargs)<EOL><DEDENT>return wrapper<EOL>", "docstring": "Decorate passed in function and log message to module logger.", "id": "f64:m0"}
{"signature": "def autofocus_scan(self):", "body": "cmd = [('<STR_LIT>', '<STR_LIT>')]<EOL>self.send(cmd)<EOL>return self.wait_for(*cmd[<NUM_LIT:0>])<EOL>", "docstring": "Start the autofocus job.", "id": "f64:c1:m9"}
{"signature": "def close(self):", "body": "self.socket.close()<EOL>", "docstring": "Close the socket.", "id": "f64:c1:m6"}
{"signature": "def give_another_quote(q):", "body": "for qc in QUOTES:<EOL><INDENT>if qc != q:<EOL><INDENT>return qc<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError(u'<STR_LIT>'.format(q))<EOL><DEDENT>", "docstring": "When you pass a quote character, returns you an another one if possible", "id": "f75:m0"}
{"signature": "def find_by(self, **params):", "body": "return self.filter(Q.from_dict(params))<EOL>", "docstring": "Searches in ManageIQ using the ``filter[]`` get parameter.\n\n        This method only supports logical AND so all key/value pairs are considered as equality\n        comparision and all are logically anded.", "id": "f76:c4:m8"}
{"signature": "def _get_entity_from_href(self, result):", "body": "href_result = result['<STR_LIT>']<EOL>if self.collection._href.startswith(href_result):<EOL><INDENT>return Entity(self.collection, result, incomplete=True)<EOL><DEDENT>href_match = re.match(r\"<STR_LIT>\", href_result)<EOL>if not href_match:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(href_result))<EOL><DEDENT>collection_name = href_match.group(<NUM_LIT:2>)<EOL>entry_point = href_match.group(<NUM_LIT:1>)<EOL>new_collection = Collection(<EOL>self.collection.api,<EOL>\"<STR_LIT>\".format(entry_point, collection_name),<EOL>collection_name<EOL>)<EOL>return Entity(new_collection, result, incomplete=True)<EOL>", "docstring": "Returns entity in correct collection.\n\n        If the \"href\" value in result doesn't match the current collection,\n        try to find the collection that the \"href\" refers to.", "id": "f76:c7:m4"}
{"signature": "def query_string(self, **params):", "body": "return SearchResult(self, self._api.get(self._href, **params))<EOL>", "docstring": "Specify query string to use with the collection.\n\n        Returns: :py:class:`SearchResult`", "id": "f76:c4:m5"}
{"signature": "@main.command('<STR_LIT>')<EOL>@click.argument('<STR_LIT>', cls=SectionArgument)<EOL>@click.argument('<STR_LIT:value>',<EOL>required=False)<EOL>@click.option('<STR_LIT>',<EOL>'<STR_LIT:-c>',<EOL>is_flag=True,<EOL>help='<STR_LIT>')<EOL>def set_variable(section, value, create):", "body": "if not value:<EOL><INDENT>value = section<EOL>section = None<EOL><DEDENT>try:<EOL><INDENT>logger.debug('<STR_LIT>')<EOL>settings = config.Settings(section=section)<EOL>conf = s3conf.S3Conf(settings=settings)<EOL>env_vars = conf.get_envfile()<EOL>env_vars.set(value, create=create)<EOL><DEDENT>except exceptions.EnvfilePathNotDefinedError:<EOL><INDENT>raise exceptions.EnvfilePathNotDefinedUsageError()<EOL><DEDENT>", "docstring": "Set value of a variable in an environment file for the given section.\nIf the variable is already defined, its value is replaced, otherwise, it is added to the end of the file.\nThe value is given as \"ENV_VAR_NAME=env_var_value\", e.g.:\n\ns3conf set test ENV_VAR_NAME=env_var_value", "id": "f82:m8"}
{"signature": "@main.command('<STR_LIT>')<EOL>@click.argument('<STR_LIT>',<EOL>required=False)<EOL>@click.option('<STR_LIT>',<EOL>'<STR_LIT>',<EOL>is_flag=True,<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>@click.option('<STR_LIT>',<EOL>is_flag=True,<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>@click.option('<STR_LIT>',<EOL>default='<STR_LIT>',<EOL>show_default=True,<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>',<EOL>'<STR_LIT>',<EOL>is_flag=True,<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>',<EOL>'<STR_LIT>',<EOL>is_flag=True)<EOL>@click.option('<STR_LIT>',<EOL>'<STR_LIT:-c>',<EOL>is_flag=True,<EOL>help='<STR_LIT>')<EOL>def env(section, map_files, phusion, phusion_path, quiet, edit, create):", "body": "try:<EOL><INDENT>logger.debug('<STR_LIT>')<EOL>settings = config.Settings(section=section)<EOL>storage = STORAGES['<STR_LIT>'](settings=settings)<EOL>conf = s3conf.S3Conf(storage=storage, settings=settings)<EOL>if edit:<EOL><INDENT>conf.edit(create=create)<EOL><DEDENT>else:<EOL><INDENT>env_vars = conf.get_envfile().as_dict()<EOL>if env_vars.get('<STR_LIT>') and map_files:<EOL><INDENT>conf.download_mapping(env_vars.get('<STR_LIT>'))<EOL><DEDENT>if not quiet:<EOL><INDENT>for var_name, var_value in sorted(env_vars.items(), key=lambda x: x[<NUM_LIT:0>]):<EOL><INDENT>click.echo('<STR_LIT>'.format(var_name, var_value))<EOL><DEDENT><DEDENT>if phusion:<EOL><INDENT>s3conf.phusion_dump(env_vars, phusion_path)<EOL><DEDENT><DEDENT><DEDENT>except exceptions.EnvfilePathNotDefinedError:<EOL><INDENT>raise exceptions.EnvfilePathNotDefinedUsageError()<EOL><DEDENT>except exceptions.FileDoesNotExist as e:<EOL><INDENT>raise UsageError('<STR_LIT>'.format(str(e)))<EOL><DEDENT>", "docstring": "Reads the file defined by the S3CONF variable and output its contents to stdout. Logs are printed to stderr.\nSee options for added functionality: editing file, mapping files, dumping in the phusion-baseimage format, etc.", "id": "f82:m1"}
{"signature": "@click.group(invoke_without_command=True)<EOL>@click.version_option(version=__version__)<EOL>@click.option('<STR_LIT>', '<STR_LIT>', is_flag=True)<EOL>@click.option('<STR_LIT>',<EOL>'<STR_LIT:-c>',<EOL>is_flag=True,<EOL>help='<STR_LIT>')<EOL>@click.pass_context<EOL>@click_log.simple_verbosity_option('<STR_LIT>')<EOL>def main(ctx, edit, create):", "body": "<EOL>try:<EOL><INDENT>click_log.basic_config('<STR_LIT>')<EOL>logger.debug('<STR_LIT>')<EOL>if edit:<EOL><INDENT>if ctx.invoked_subcommand is None:<EOL><INDENT>logger.debug('<STR_LIT>', config.LOCAL_CONFIG_FILE)<EOL>config.ConfigFileResolver(config.LOCAL_CONFIG_FILE).edit(create=create)<EOL>return<EOL><DEDENT>else:<EOL><INDENT>raise UsageError('<STR_LIT>')<EOL><DEDENT><DEDENT>if ctx.invoked_subcommand is None:<EOL><INDENT>click.echo(main.get_help(ctx))<EOL><DEDENT><DEDENT>except exceptions.FileDoesNotExist as e:<EOL><INDENT>raise UsageError('<STR_LIT>'.format(str(e)))<EOL><DEDENT>", "docstring": "Simple command line tool to help manage environment variables stored in a S3-like system. Facilitates editing text\nfiles remotely stored, as well as downloading and uploading files.", "id": "f82:m0"}
{"signature": "@main.command('<STR_LIT>')<EOL>@click.argument('<STR_LIT>')<EOL>@click.argument('<STR_LIT>')<EOL>def init(section, remote_file):", "body": "if not remote_file.startswith('<STR_LIT>'):<EOL><INDENT>raise UsageError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>logger.debug('<STR_LIT>')<EOL>config_file_path = os.path.join(os.getcwd(), '<STR_LIT>', '<STR_LIT>')<EOL>config_file = config.ConfigFileResolver(config_file_path, section=section)<EOL>config_file.set('<STR_LIT>', remote_file)<EOL>gitignore_file_path = os.path.join(os.getcwd(), '<STR_LIT>', '<STR_LIT>')<EOL>config_file.save()<EOL>open(gitignore_file_path, '<STR_LIT:w>').write('<STR_LIT>')<EOL>", "docstring": "Creates the .s3conf config folder and .s3conf/config config file\nwith the provided section name and configuration file. It is a very\nbasic config file. Manually edit it in order to add credentials. E.g.:\n\ns3conf init development s3://my-project/development.env", "id": "f82:m10"}
{"signature": "@register.simple_tag<EOL>def djfrontend_twbs_theme_css(version=None):", "body": "if version is None:<EOL><INDENT>if not getattr(settings, '<STR_LIT>', False):<EOL><INDENT>version = getattr(settings, '<STR_LIT>', DJFRONTEND_TWBS_VERSION_DEFAULT)<EOL><DEDENT>else:<EOL><INDENT>version = getattr(settings, '<STR_LIT>', DJFRONTEND_TWBS_VERSION_DEFAULT)<EOL><DEDENT><DEDENT>return format_html(<EOL>'<STR_LIT>',<EOL>static=_static_url, v=version, min=_min)<EOL>", "docstring": "Returns Twitter Bootstrap Theme CSS file.", "id": "f94:m14"}
{"signature": "@register.simple_tag<EOL>def djfrontend_jquery(version=None):", "body": "if version is None:<EOL><INDENT>version = getattr(settings, '<STR_LIT>', DJFRONTEND_JQUERY_DEFAULT)<EOL><DEDENT>if getattr(settings, '<STR_LIT>', False):<EOL><INDENT>template = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>template = (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>return format_html(template, static=_static_url, v=version)<EOL>", "docstring": "Returns jQuery JavaScript file according to version number.\nTEMPLATE_DEBUG returns full file, otherwise returns minified file from Google CDN with local fallback.\nIncluded in HTML5 Boilerplate.", "id": "f94:m5"}
{"signature": "@register.simple_tag<EOL>def djfrontend_twbs_js(version=None, files=None):", "body": "if version is None:<EOL><INDENT>if not getattr(settings, '<STR_LIT>', False):<EOL><INDENT>version = getattr(settings, '<STR_LIT>', DJFRONTEND_TWBS_VERSION_DEFAULT)<EOL><DEDENT>else:<EOL><INDENT>version = getattr(settings, '<STR_LIT>', DJFRONTEND_TWBS_VERSION_DEFAULT)<EOL><DEDENT><DEDENT>if files:<EOL><INDENT>if files != '<STR_LIT:all>':<EOL><INDENT>files = files.split('<STR_LIT:U+0020>')<EOL><DEDENT><DEDENT>elif getattr(settings, '<STR_LIT>', False) and settings.DJFRONTEND_TWBS_JS_FILES != '<STR_LIT:all>':<EOL><INDENT>files = settings.DJFRONTEND_TWBS_JS_FILES.split('<STR_LIT:U+0020>')<EOL><DEDENT>else:<EOL><INDENT>files = '<STR_LIT:all>'<EOL><DEDENT>if files == '<STR_LIT:all>':<EOL><INDENT>return format_html(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>v=version, static=_static_url)<EOL><DEDENT>else:<EOL><INDENT>if '<STR_LIT>' in files and '<STR_LIT>' not in files:<EOL><INDENT>files.append('<STR_LIT>')<EOL><DEDENT>for file in files:<EOL><INDENT>file = ['<STR_LIT>' %<EOL>(_static_url, version, file) for file in files]<EOL><DEDENT>return mark_safe('<STR_LIT:\\n>'.join(file))<EOL><DEDENT>", "docstring": "Returns Twitter Bootstrap JavaScript file(s).\nall returns concatenated file; full file for TEMPLATE_DEBUG, minified otherwise.\n\nOther choice are:\n    affix,\n    alert,\n    button,\n    carousel,\n    collapse,\n    dropdown,\n    modal,\n    popover (adds tooltip if not included),\n    scrollspy,\n    tab,\n    tooltip,\n    transition.\n\nIndividual files are not minified.", "id": "f94:m15"}
{"signature": "def search(self, **kwargs):", "body": "params = {}<EOL>available_params = [<EOL>\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT:q>\", \"<STR_LIT:start>\",<EOL>\"<STR_LIT:count>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]<EOL>for key in available_params:<EOL><INDENT>if key in kwargs:<EOL><INDENT>params[key] = kwargs[key]<EOL><DEDENT><DEDENT>results = self.api.get(\"<STR_LIT>\", params)<EOL>return results<EOL>", "docstring": ":param entity_id: location id\n:param entity_type: location type (city, subzone, zone, lanmark, metro , group)\n:param q: search keyword\n:param start: fetch results after offset\n:param count: max number of results to display\n:param lat: latitude\n:param lon: longitude\n:param radius: radius around (lat,lon); to define search area, defined in meters(M)\n:param cuisines: list of cuisine id's separated by comma\n:param establishment_type: estblishment id obtained from establishments call\n:param collection_id: collection id obtained from collections call\n:param category: category ids obtained from categories call\n:param sort: sort restaurants by (cost, rating, real_distance)\n:param order: used with 'sort' parameter to define ascending / descending\n:return: json response\nThe location input can be specified using Zomato location ID or coordinates. Cuisine / Establishment /\nCollection IDs can be obtained from respective api calls.\n\nPartner Access is required to access photos and reviews.\n\nExamples:\n- To search for 'Italian' restaurants in 'Manhattan, New York City',\nset cuisines = 55, entity_id = 94741 and entity_type = zone\n- To search for 'cafes' in 'Manhattan, New York City',\nset establishment_type = 1, entity_type = zone and entity_id = 94741\n- Get list of all restaurants in 'Trending this Week' collection in 'New York City' by using\nentity_id = 280, entity_type = city and collection_id = 1", "id": "f103:c0:m12"}
{"signature": "def getRestaurantDetails(self, restaurant_id):", "body": "params = {\"<STR_LIT>\": restaurant_id}<EOL>restaurant_details = self.api.get(\"<STR_LIT>\", params)<EOL>return restaurant_details<EOL>", "docstring": ":param restaurant_id: id of restaurant whose details are requested\n:return: json response\nGet detailed restaurant information using Zomato restaurant ID.\nPartner Access is required to access photos and reviews.", "id": "f103:c0:m10"}
{"signature": "def getEstablishments(self, city_id, **kwargs):", "body": "params = {\"<STR_LIT>\": city_id}<EOL>optional_params = [\"<STR_LIT>\", \"<STR_LIT>\"]<EOL>for key in optional_params:<EOL><INDENT>if key in kwargs:<EOL><INDENT>params[key] = kwargs[key]<EOL><DEDENT><DEDENT>establishments = self.api.get(\"<STR_LIT>\", params)<EOL>return establishments<EOL>", "docstring": ":param city_id: id of the city for which collections are needed\n:param lat: latitude\n:param lon: longitude\nGet a list of restaurant types in a city. The location/City input can be provided in the following ways\n- Using Zomato City ID\n- Using coordinates of any location within a city\nList of all restaurants categorized under a particular restaurant type can obtained using\n/Search API with Establishment ID and location details as inputs", "id": "f103:c0:m5"}
{"signature": "def parse(self):", "body": "nevents_wrong = <NUM_LIT:0><EOL>feed_json = json.loads(self.feed)<EOL>if '<STR_LIT>' not in feed_json['<STR_LIT>']:<EOL><INDENT>return<EOL><DEDENT>self.cells = feed_json['<STR_LIT>']['<STR_LIT>']<EOL>self.ncell = <NUM_LIT:0><EOL>event_fields = self.__get_event_fields()<EOL>while self.ncell < len(self.cells):<EOL><INDENT>event = self.__get_next_event(event_fields)<EOL>if event['<STR_LIT>'] is None or event['<STR_LIT>'] is None:<EOL><INDENT>logger.warning(\"<STR_LIT>\", event)<EOL>nevents_wrong += <NUM_LIT:1><EOL>continue<EOL><DEDENT>yield event<EOL><DEDENT>logger.info(\"<STR_LIT>\", nevents_wrong)<EOL>", "docstring": "Parse the MozillaClub spreadsheet feed cells json.", "id": "f116:c2:m1"}
{"signature": "def __get_event_fields(self):", "body": "event_fields = {}<EOL>while self.ncell < len(self.cells):<EOL><INDENT>cell = self.cells[self.ncell]<EOL>row = cell['<STR_LIT>']['<STR_LIT>']<EOL>if int(row) > <NUM_LIT:1>:<EOL><INDENT>break<EOL><DEDENT>ncol = int(cell['<STR_LIT>']['<STR_LIT>'])<EOL>name = cell['<STR_LIT:content>']['<STR_LIT>']<EOL>event_fields[ncol] = name<EOL>if ncol in EVENT_TEMPLATE:<EOL><INDENT>if event_fields[ncol] != EVENT_TEMPLATE[ncol]:<EOL><INDENT>logger.warning(\"<STR_LIT>\",<EOL>name, EVENT_TEMPLATE[ncol])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>logger.warning(\"<STR_LIT>\", name)<EOL><DEDENT>self.ncell += <NUM_LIT:1><EOL><DEDENT>return event_fields<EOL>", "docstring": "Get the events fields (columns) from the cells received.", "id": "f116:c2:m2"}
{"signature": "@classmethod<EOL><INDENT>def has_resuming(cls):<DEDENT>", "body": "return False<EOL>", "docstring": "Returns whether it supports to resume the fetch process.\n\n        :returns: this backend supports items resuming", "id": "f116:c0:m4"}
{"signature": "def get_items(self, category=CATEGORY_EVENT, offset=REMO_DEFAULT_OFFSET):", "body": "more = True  <EOL>next_uri = None  <EOL>page = ReMoClient.FIRST_PAGE<EOL>page += int(offset / ReMoClient.ITEMS_PER_PAGE)<EOL>if category == CATEGORY_EVENT:<EOL><INDENT>api = self.api_events_url<EOL><DEDENT>elif category == CATEGORY_ACTIVITY:<EOL><INDENT>api = self.api_activities_url<EOL><DEDENT>elif category == CATEGORY_USER:<EOL><INDENT>api = self.api_users_url<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(category + '<STR_LIT>')<EOL><DEDENT>while more:<EOL><INDENT>params = {<EOL>\"<STR_LIT>\": page,<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>}<EOL>logger.debug(\"<STR_LIT>\",<EOL>api, str(params))<EOL>raw_items = self.fetch(api, payload=params)<EOL>yield raw_items<EOL>items_data = json.loads(raw_items)<EOL>next_uri = items_data['<STR_LIT>']<EOL>if not next_uri:<EOL><INDENT>more = False<EOL><DEDENT>else:<EOL><INDENT>parsed_uri = urllib.parse.urlparse(next_uri)<EOL>parsed_params = urllib.parse.parse_qs(parsed_uri.query)<EOL>page = parsed_params['<STR_LIT>'][<NUM_LIT:0>]<EOL><DEDENT><DEDENT>", "docstring": "Retrieve all items for category using pagination", "id": "f117:c1:m1"}
{"signature": "def metadata(self, item, filter_classified=False):", "body": "item = super().metadata(item, filter_classified=filter_classified)<EOL>item['<STR_LIT>'] = item['<STR_LIT:data>'].pop('<STR_LIT>')<EOL>return item<EOL>", "docstring": "ReMo metadata.\n\n        This method takes items overrides `metadata` method to add extra\n        information related to Remo (offset of the item).\n\n        :param item: an item fetched by a backend\n        :param filter_classified: sets if classified fields were filtered", "id": "f117:c0:m3"}
{"signature": "@classmethod<EOL><INDENT>def has_archiving(cls):<DEDENT>", "body": "return True<EOL>", "docstring": "Returns whether it supports archiving items on the fetch process.\n\n        :returns: this backend supports items archive", "id": "f117:c0:m4"}
{"signature": "def fetch_items(self, category, **kwargs):", "body": "offset = kwargs['<STR_LIT>']<EOL>logger.info(\"<STR_LIT>\",<EOL>self.url, category, offset)<EOL>nitems = <NUM_LIT:0>  <EOL>titems = <NUM_LIT:0>  <EOL>page = int(offset / ReMoClient.ITEMS_PER_PAGE)<EOL>page_offset = page * ReMoClient.ITEMS_PER_PAGE<EOL>drop_items = offset - page_offset<EOL>logger.debug(\"<STR_LIT>\",<EOL>drop_items, offset, page, page_offset)<EOL>current_offset = offset<EOL>for raw_items in self.client.get_items(category, offset):<EOL><INDENT>items_data = json.loads(raw_items)<EOL>titems = items_data['<STR_LIT:count>']<EOL>logger.info(\"<STR_LIT>\",<EOL>titems - current_offset, current_offset)<EOL>items = items_data['<STR_LIT>']<EOL>for item in items:<EOL><INDENT>if drop_items > <NUM_LIT:0>:<EOL><INDENT>drop_items -= <NUM_LIT:1><EOL>continue<EOL><DEDENT>raw_item_details = self.client.fetch(item['<STR_LIT>'])<EOL>item_details = json.loads(raw_item_details)<EOL>item_details['<STR_LIT>'] = current_offset<EOL>current_offset += <NUM_LIT:1><EOL>yield item_details<EOL>nitems += <NUM_LIT:1><EOL><DEDENT><DEDENT>logger.info(\"<STR_LIT>\", nitems, titems, offset)<EOL>", "docstring": "Fetch items\n\n        :param category: the category of items to fetch\n        :param kwargs: backend arguments\n\n        :returns: a generator of items", "id": "f117:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def setup_cmd_parser(cls):<DEDENT>", "body": "parser = BackendCommandArgumentParser(cls.BACKEND.CATEGORIES,<EOL>offset=True,<EOL>archive=True)<EOL>parser.parser.add_argument('<STR_LIT:url>', nargs='<STR_LIT:?>',<EOL>default=\"<STR_LIT>\",<EOL>help=\"<STR_LIT>\")<EOL>return parser<EOL>", "docstring": "Returns the ReMo argument parser.", "id": "f117:c2:m0"}
{"signature": "def crates(self, from_page=<NUM_LIT:1>):", "body": "path = urijoin(CRATES_API_URL, CATEGORY_CRATES)<EOL>raw_crates = self.__fetch_items(path, from_page)<EOL>return raw_crates<EOL>", "docstring": "Get crates in alphabetical order", "id": "f118:c1:m2"}
{"signature": "@classmethod<EOL><INDENT>def has_resuming(cls):<DEDENT>", "body": "return False<EOL>", "docstring": "Returns whether it supports to resume the fetch process.\n\n        :returns: this backend supports items resuming", "id": "f118:c0:m4"}
{"signature": "def fetch(self, url, payload=None):", "body": "response = super().fetch(url, payload=payload)<EOL>return response.text<EOL>", "docstring": "Return the textual content associated to the Response object", "id": "f118:c1:m6"}
{"signature": "def __fetch_items(self, path, page=<NUM_LIT:1>):", "body": "fetch_data = True<EOL>parsed_crates = <NUM_LIT:0><EOL>total_crates = <NUM_LIT:0><EOL>while fetch_data:<EOL><INDENT>logger.debug(\"<STR_LIT>\", page)<EOL>try:<EOL><INDENT>payload = {'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': page}<EOL>raw_content = self.fetch(path, payload=payload)<EOL>content = json.loads(raw_content)<EOL>parsed_crates += len(content['<STR_LIT>'])<EOL>if not total_crates:<EOL><INDENT>total_crates = content['<STR_LIT>']['<STR_LIT>']<EOL><DEDENT><DEDENT>except requests.exceptions.HTTPError as e:<EOL><INDENT>logger.error(\"<STR_LIT>\", e.response.text)<EOL>raise e<EOL><DEDENT>yield raw_content<EOL>page += <NUM_LIT:1><EOL>if parsed_crates >= total_crates:<EOL><INDENT>fetch_data = False<EOL><DEDENT><DEDENT>", "docstring": "Return the items from Crates.io API using pagination", "id": "f118:c1:m5"}
{"signature": "def _init_client(self, from_archive=False):", "body": "return CratesClient(self.sleep_time, self.archive, from_archive)<EOL>", "docstring": "Init client", "id": "f118:c0:m8"}
{"signature": "@staticmethod<EOL><INDENT>def metadata_category(item):<DEDENT>", "body": "if '<STR_LIT>' in item:<EOL><INDENT>return CATEGORY_SUMMARY<EOL><DEDENT>else:<EOL><INDENT>return CATEGORY_CRATES<EOL><DEDENT>", "docstring": "Extracts the category from an item.\n\n        This backend generates two types of item: 'summary' and 'crate'.", "id": "f118:c0:m7"}
{"signature": "@classmethod<EOL><INDENT>def setup_cmd_parser(cls):<DEDENT>", "body": "parser = BackendCommandArgumentParser(cls.BACKEND.CATEGORIES,<EOL>from_date=True,<EOL>archive=True,<EOL>token_auth=True)<EOL>group = parser.parser.add_argument_group('<STR_LIT>')<EOL>group.add_argument('<STR_LIT>', dest='<STR_LIT>',<EOL>default=SLEEP_TIME, type=int,<EOL>help=\"<STR_LIT>\")<EOL>return parser<EOL>", "docstring": "Returns the Crates argument parser.", "id": "f118:c2:m0"}
{"signature": "def fetch(self, category=CATEGORY_CRATES, from_date=DEFAULT_DATETIME):", "body": "if not from_date:<EOL><INDENT>from_date = DEFAULT_DATETIME<EOL><DEDENT>from_date = datetime_to_utc(from_date)<EOL>kwargs = {\"<STR_LIT>\": from_date}<EOL>items = super().fetch(category, **kwargs)<EOL>return items<EOL>", "docstring": "Fetch package data.\n\n        The method retrieves packages and summary from Crates.io.\n\n        :param category: the category of items to fetch\n        :param from_date: obtain packages updated since this date\n\n        :returns: a summary and crate items", "id": "f118:c0:m1"}
{"signature": "def summary(self):", "body": "path = urijoin(CRATES_API_URL, CATEGORY_SUMMARY)<EOL>raw_content = self.fetch(path)<EOL>return raw_content<EOL>", "docstring": "Get Crates.io summary", "id": "f118:c1:m1"}
{"signature": "def get_question_answers(self, question_id):", "body": "page = KitsuneClient.FIRST_PAGE<EOL>while True:<EOL><INDENT>api_answers_url = urijoin(self.base_url, '<STR_LIT>') + '<STR_LIT:/>'<EOL>params = {<EOL>\"<STR_LIT>\": page,<EOL>\"<STR_LIT>\": question_id,<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>}<EOL>answers_raw = self.fetch(api_answers_url, params)<EOL>yield answers_raw<EOL>answers = json.loads(answers_raw)<EOL>if not answers['<STR_LIT>']:<EOL><INDENT>break<EOL><DEDENT>page += <NUM_LIT:1><EOL><DEDENT>", "docstring": "Retrieve all answers for a question from older to newer (updated)", "id": "f119:c1:m2"}
{"signature": "def get_questions(self, offset=None):", "body": "page = KitsuneClient.FIRST_PAGE<EOL>if offset:<EOL><INDENT>page += int(offset / KitsuneClient.ITEMS_PER_PAGE)<EOL><DEDENT>while True:<EOL><INDENT>api_questions_url = urijoin(self.base_url, '<STR_LIT>') + '<STR_LIT:/>'<EOL>params = {<EOL>\"<STR_LIT>\": page,<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>}<EOL>questions = self.fetch(api_questions_url, params)<EOL>yield questions<EOL>questions_json = json.loads(questions)<EOL>next_uri = questions_json['<STR_LIT>']<EOL>if not next_uri:<EOL><INDENT>break<EOL><DEDENT>page += <NUM_LIT:1><EOL><DEDENT>", "docstring": "Retrieve questions from older to newer updated starting offset", "id": "f119:c1:m1"}
{"signature": "def _init_client(self, from_archive=False):", "body": "return KitsuneClient(self.url, self.archive, from_archive)<EOL>", "docstring": "Init client", "id": "f119:c0:m9"}
{"signature": "def metadata(self, item, filter_classified=False):", "body": "item = super().metadata(item, filter_classified=filter_classified)<EOL>item['<STR_LIT>'] = item['<STR_LIT:data>'].pop('<STR_LIT>')<EOL>return item<EOL>", "docstring": "Kitsune metadata.\n\n        This method takes items overrides `metadata` method to add extra\n        information related to Kitsune (offset of the question).\n\n        :param item: an item fetched by a backend\n        :param filter_classified: sets if classified fields were filtered", "id": "f119:c0:m3"}
{"signature": "def get_token_from_post_data(self, data):", "body": "try:<EOL><INDENT>for x in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>if not data.get(x):<EOL><INDENT>raise TypeError(\"<STR_LIT>\".format(x))<EOL><DEDENT><DEDENT>if '<STR_LIT>' in data:<EOL><INDENT>return self.refresh_token(**data)<EOL><DEDENT>for x in ['<STR_LIT>', '<STR_LIT:code>']:<EOL><INDENT>if not data.get(x):<EOL><INDENT>raise TypeError(\"<STR_LIT>\".format(x))            <EOL><DEDENT><DEDENT>return self.get_token(**data)<EOL><DEDENT>except TypeError as exc:<EOL><INDENT>self._handle_exception(exc)<EOL>return self._make_json_error_response('<STR_LIT>')<EOL><DEDENT>except StandardError as exc:<EOL><INDENT>self._handle_exception(exc)<EOL>return self._make_json_error_response('<STR_LIT>')<EOL><DEDENT>", "docstring": "Get a token response from POST data.\n\n        :param data: POST data containing authorization information.\n        :type data: dict\n        :rtype: requests.Response", "id": "f126:c1:m10"}
{"signature": "def get_authorization_code_from_uri(self, uri):", "body": "params = utils.url_query_params(uri)<EOL>try:<EOL><INDENT>if '<STR_LIT>' not in params:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in params:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' not in params:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>return self.get_authorization_code(**params)<EOL><DEDENT>except TypeError as exc:<EOL><INDENT>self._handle_exception(exc)<EOL>err = '<STR_LIT>'<EOL>if '<STR_LIT>' in params:<EOL><INDENT>u = params['<STR_LIT>']<EOL>return self._make_redirect_error_response(u, err)<EOL><DEDENT>else:<EOL><INDENT>return self._invalid_redirect_uri_response()<EOL><DEDENT><DEDENT>except StandardError as exc:<EOL><INDENT>self._handle_exception(exc)<EOL>err = '<STR_LIT>'<EOL>u = params['<STR_LIT>']<EOL>return self._make_redirect_error_response(u, err)<EOL><DEDENT>", "docstring": "Get authorization code response from a URI. This method will\n        ignore the domain and path of the request, instead\n        automatically parsing the query string parameters.\n\n        :param uri: URI to parse for authorization information.\n        :type uri: str\n        :rtype: requests.Response", "id": "f126:c1:m9"}
{"signature": "def _invalid_redirect_uri_response(self):", "body": "return self._make_json_error_response('<STR_LIT>')<EOL>", "docstring": "What to return when the redirect_uri parameter is missing.\n\n        :rtype: requests.Response", "id": "f126:c0:m5"}
{"signature": "def get_token(self,<EOL>grant_type,<EOL>client_id,<EOL>client_secret,<EOL>redirect_uri,<EOL>code,<EOL>**params):", "body": "<EOL>if grant_type != '<STR_LIT>':<EOL><INDENT>return self._make_json_error_response('<STR_LIT>')<EOL><DEDENT>is_valid_client_id = self.validate_client_id(client_id)<EOL>is_valid_client_secret = self.validate_client_secret(client_id,<EOL>client_secret)<EOL>is_valid_redirect_uri = self.validate_redirect_uri(client_id,<EOL>redirect_uri)<EOL>scope = params.get('<STR_LIT>', '<STR_LIT>')<EOL>is_valid_scope = self.validate_scope(client_id, scope)<EOL>data = self.from_authorization_code(client_id, code, scope)<EOL>is_valid_grant = data is not None<EOL>if not (is_valid_client_id and is_valid_client_secret):<EOL><INDENT>return self._make_json_error_response('<STR_LIT>')<EOL><DEDENT>if not is_valid_grant or not is_valid_redirect_uri:<EOL><INDENT>return self._make_json_error_response('<STR_LIT>')<EOL><DEDENT>if not is_valid_scope:<EOL><INDENT>return self._make_json_error_response('<STR_LIT>')<EOL><DEDENT>self.discard_authorization_code(client_id, code)<EOL>access_token = self.generate_access_token()<EOL>token_type = self.token_type<EOL>expires_in = self.token_expires_in<EOL>refresh_token = self.generate_refresh_token()<EOL>self.persist_token_information(client_id=client_id,<EOL>scope=scope,<EOL>access_token=access_token,<EOL>token_type=token_type,<EOL>expires_in=expires_in,<EOL>refresh_token=refresh_token,<EOL>data=data)<EOL>return self._make_json_response({<EOL>'<STR_LIT>': access_token,<EOL>'<STR_LIT>': token_type,<EOL>'<STR_LIT>': expires_in,<EOL>'<STR_LIT>': refresh_token<EOL>})<EOL>", "docstring": "Generate access token HTTP response.\n\n        :param grant_type: Desired grant type. Must be \"authorization_code\".\n        :type grant_type: str\n        :param client_id: Client ID.\n        :type client_id: str\n        :param client_secret: Client secret.\n        :type client_secret: str\n        :param redirect_uri: Client redirect URI.\n        :type redirect_uri: str\n        :param code: Authorization code.\n        :type code: str\n        :rtype: requests.Response", "id": "f126:c1:m8"}
{"signature": "@property<EOL><INDENT>def token_length(self):<DEDENT>", "body": "return <NUM_LIT><EOL>", "docstring": "Property method to get the length used to generate tokens.\n\n        :rtype: int", "id": "f126:c1:m0"}
{"signature": "def _handle_exception(self, exc):", "body": "logger = logging.getLogger(__name__)<EOL>logger.exception(exc)<EOL>", "docstring": "Handle an internal exception that was caught and suppressed.\n\n        :param exc: Exception to process.\n        :type exc: Exception", "id": "f126:c0:m0"}
{"signature": "def get_token(self, code, **params):", "body": "params['<STR_LIT:code>'] = code<EOL>if '<STR_LIT>' not in params:<EOL><INDENT>params['<STR_LIT>'] = self.default_grant_type<EOL><DEDENT>params.update({'<STR_LIT>': self.client_id,<EOL>'<STR_LIT>': self.client_secret,<EOL>'<STR_LIT>': self.redirect_uri})<EOL>response = self.http_post(self.token_uri, params)<EOL>try:<EOL><INDENT>return response.json()<EOL><DEDENT>except TypeError:<EOL><INDENT>return response.json<EOL><DEDENT>", "docstring": "Get an access token from the provider token URI.\n\n        :param code: Authorization code.\n        :type code: str\n        :return: Dict containing access token, refresh token, etc.\n        :rtype: dict", "id": "f127:c0:m5"}
{"signature": "def url_query_params(url):", "body": "return dict(urlparse.parse_qsl(urlparse.urlparse(url).query, True))<EOL>", "docstring": "Return query parameters as a dict from the specified URL.\n\n    :param url: URL.\n    :type url: str\n    :rtype: dict", "id": "f128:m1"}
{"signature": "def setUp(self):", "body": "self.places = ctllib.Places(config='<STR_LIT>', messages='<STR_LIT>')<EOL>def _cleanup():<EOL><INDENT>for d in self.places:<EOL><INDENT>if os.path.exists(d):<EOL><INDENT>shutil.rmtree(d)<EOL><DEDENT><DEDENT><DEDENT>_cleanup()<EOL>self.addCleanup(_cleanup)<EOL>for d in self.places:<EOL><INDENT>os.mkdir(d)<EOL><DEDENT>", "docstring": "Set up configuration and build/cleanup directories", "id": "f133:c1:m0"}
{"signature": "def setUp(self):", "body": "self.parser = ctllib.PARSER<EOL>self.base = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>", "docstring": "Initialize the parser, required arguments", "id": "f133:c0:m0"}
{"signature": "def jsonFrom(fname):", "body": "with io.open(fname, \"<STR_LIT:r>\", encoding='<STR_LIT:utf-8>') as fp:<EOL><INDENT>return json.loads(fp.read())<EOL><DEDENT>", "docstring": "Load JSON from a file", "id": "f133:m0"}
{"signature": "def remove(self, name):", "body": "self.events.append(('<STR_LIT>', name))<EOL>", "docstring": "Get a remove event", "id": "f136:c0:m2"}
{"signature": "def setUp(self):", "body": "DirectoryBasedTest.setUp(self)<EOL>self.receiver = EventRecorder()<EOL>self.monitor = directory_monitor.checker(self.testDirectory,<EOL>self.receiver)<EOL>self.assertFalse(self.receiver.events)<EOL>", "docstring": "Set up the test", "id": "f136:c6:m0"}
{"signature": "def setUp(self):", "body": "def _cleanup(testDir):<EOL><INDENT>if os.path.exists(testDir):<EOL><INDENT>shutil.rmtree(testDir)<EOL><DEDENT><DEDENT>self.testDirs = {}<EOL>for subd in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>testDir = self.testDirs[subd] = os.path.join(os.getcwd(), subd)<EOL>self.addCleanup(_cleanup, testDir)<EOL>_cleanup(testDir)<EOL>os.makedirs(testDir)<EOL><DEDENT>self.my_reactor = test_procmon.DummyProcessReactor()<EOL>self.service = service.get(self.testDirs['<STR_LIT>'],<EOL>self.testDirs['<STR_LIT>'],<EOL><NUM_LIT:5>, reactor=self.my_reactor)<EOL>self._finishSetUp()<EOL>", "docstring": "Set up the test", "id": "f138:c2:m0"}
{"signature": "def setContent(self, content):", "body": "self.content = content<EOL>", "docstring": "Set file contents", "id": "f138:c0:m2"}
{"signature": "def request(self, method, url, headers, body):", "body": "d = defer.Deferred()<EOL>self.calls.append((method, url, headers, body))<EOL>self.pending[url].append(d)<EOL>return d<EOL>", "docstring": "Pretend to make a request", "id": "f142:c0:m1"}
{"signature": "def getArgs(self):", "body": "return '<STR_LIT:U+0020>'.join('<STR_LIT:U+0020>'.join('<STR_LIT>' % (key, vpart)<EOL>for vpart in value.split())<EOL>for key, value in six.iteritems(self.args)).split()<EOL>", "docstring": "Get the arguments as a list of strings", "id": "f144:c2:m1"}
{"signature": "def checker(location, receiver):", "body": "path = filepath.FilePath(location)<EOL>files = set()<EOL>filesContents = {}<EOL>def _check(path):<EOL><INDENT>currentFiles = set(fname for fname in os.listdir(location)<EOL>if not fname.endswith('<STR_LIT>'))<EOL>removed = files - currentFiles<EOL>added = currentFiles - files<EOL>for fname in added:<EOL><INDENT>contents = path.child(fname).getContent()<EOL>filesContents[fname] = contents<EOL>receiver.add(fname, contents)<EOL><DEDENT>for fname in removed:<EOL><INDENT>receiver.remove(fname)<EOL><DEDENT>same = currentFiles & files<EOL>for fname in same:<EOL><INDENT>newContents = path.child(fname).getContent()<EOL>oldContents = filesContents[fname]<EOL>if newContents == oldContents:<EOL><INDENT>continue<EOL><DEDENT>receiver.remove(fname)<EOL>filesContents[fname] = newContents<EOL>receiver.add(fname, newContents)<EOL><DEDENT>files.clear()<EOL>files.update(currentFiles)<EOL><DEDENT>return functools.partial(_check, path)<EOL>", "docstring": "Construct a function that checks a directory for process configuration\n\n    The function checks for additions or removals\n    of JSON process configuration files and calls the appropriate receiver\n    methods.\n\n    :param location: string, the directory to monitor\n    :param receiver: IEventReceiver\n    :returns: a function with no parameters", "id": "f145:m0"}
{"signature": "def messages(location, receiver):", "body": "path = filepath.FilePath(location)<EOL>def _check(path):<EOL><INDENT>messageFiles = path.globChildren('<STR_LIT:*>')<EOL>for message in messageFiles:<EOL><INDENT>if message.basename().endswith('<STR_LIT>'):<EOL><INDENT>continue<EOL><DEDENT>receiver.message(message.getContent())<EOL>message.remove()<EOL><DEDENT><DEDENT>return functools.partial(_check, path)<EOL>", "docstring": "Construct a function that checks a directory for messages\n\n    The function checks for new messages and\n    calls the appropriate method on the receiver. Sent messages are\n    deleted.\n\n    :param location: string, the directory to monitor\n    :param receiver: IEventReceiver\n    :returns: a function with no parameters", "id": "f145:m1"}
{"signature": "def check(self):", "body": "if self.closed:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self._maybeReset()<EOL>if self.url is None:<EOL><INDENT>return False<EOL><DEDENT>return self._maybeCheck()<EOL>", "docstring": "Check the state of HTTP", "id": "f146:c1:m4"}
{"signature": "def markBad(self, dummyValue):", "body": "self.bad += <NUM_LIT:1><EOL>", "docstring": "Note an unsuccessful check", "id": "f146:c0:m2"}
{"signature": "def markGood(self, dummyValue):", "body": "self.bad = <NUM_LIT:0><EOL>", "docstring": "Note a successful check", "id": "f146:c0:m3"}
{"signature": "def makeService(opt):", "body": "restarter, path = beatcheck.parseConfig(opt)<EOL>pool = client.HTTPConnectionPool(reactor)<EOL>agent = client.Agent(reactor=reactor, pool=pool)<EOL>settings = Settings(reactor=reactor, agent=agent)<EOL>states = {}<EOL>checker = functools.partial(check, settings, states, path)<EOL>httpcheck = tainternet.TimerService(opt['<STR_LIT>'], run, restarter, checker)<EOL>httpcheck.setName('<STR_LIT>')<EOL>return heart.wrapHeart(httpcheck)<EOL>", "docstring": "Make a service\n\n    :params opt: dictionary-like object with 'freq', 'config' and 'messages'\n    :returns: twisted.application.internet.TimerService that at opt['freq']\n              checks for stale processes in opt['config'], and sends\n              restart messages through opt['messages']", "id": "f146:m2"}
{"signature": "def run(restarter, checker):", "body": "for bad in checker():<EOL><INDENT>restarter(bad)<EOL><DEDENT>", "docstring": "Run restarter on the checker's output\n\n    :params restarter: something to run on the output of the checker\n    :params checker: a function expected to get one argument (current time)\n                     and return a list of stale names\n    :params timer: a function of zero arguments, intended to return current\n                   time\n    :returns: None", "id": "f146:m1"}
{"signature": "def runProcess(args, timeout, grace, reactor):", "body": "deferred = defer.Deferred()<EOL>protocol = ProcessProtocol(deferred)<EOL>process = reactor.spawnProcess(protocol, args[<NUM_LIT:0>], args, env=os.environ)<EOL>def _logEnded(err):<EOL><INDENT>err.trap(tierror.ProcessDone, tierror.ProcessTerminated)<EOL>print(err.value)<EOL><DEDENT>deferred.addErrback(_logEnded)<EOL>def _cancelTermination(dummy):<EOL><INDENT>for termination in terminations:<EOL><INDENT>if termination.active():<EOL><INDENT>termination.cancel()<EOL><DEDENT><DEDENT><DEDENT>deferred.addCallback(_cancelTermination)<EOL>terminations = []<EOL>terminations.append(reactor.callLater(timeout, process.signalProcess,<EOL>\"<STR_LIT>\"))<EOL>terminations.append(reactor.callLater(timeout+grace,<EOL>process.signalProcess, \"<STR_LIT>\"))<EOL>return deferred<EOL>", "docstring": "Run a process, return a deferred that fires when it is done\n\n    :params args: Process arguments\n    :params timeout: Time before terminating process\n    :params grace: Time before killing process after terminating it\n    :params reactor: IReactorProcess and IReactorTime\n    :returns: deferred that fires with success when the process ends,\n              or fails if there was a problem spawning/terminating\n              the process", "id": "f148:m0"}
{"signature": "def processExited(self, reason):", "body": "pass<EOL>", "docstring": "Ignore processExited", "id": "f148:c0:m3"}
{"signature": "def childConnectionLost(self, reason):", "body": "pass<EOL>", "docstring": "Ignore childConnectionLoss", "id": "f148:c0:m4"}
{"signature": "def replaceEnvironment(case, myEnv=None):", "body": "if myEnv is None:<EOL><INDENT>myEnv = buildEnv()<EOL><DEDENT>oldEnviron = os.environ<EOL>def _cleanup():<EOL><INDENT>os.environ = oldEnviron<EOL><DEDENT>case.addCleanup(_cleanup)<EOL>os.environ = myEnv<EOL>", "docstring": "Replace environment temporarily, restoring it at end of test\n\n    :params myEnv: a dict-like object", "id": "f149:m0"}
{"signature": "def maybeAddHeart(master):", "body": "heartSer = makeService()<EOL>if heartSer is None:<EOL><INDENT>return<EOL><DEDENT>heartSer.setName('<STR_LIT>')<EOL>heartSer.setServiceParent(master)<EOL>", "docstring": "Add a heart to a service collection\n\n    Add a heart to a service.IServiceCollector if\n    the heart is not None.\n\n    :params master: a service.IServiceCollector", "id": "f151:m1"}
{"signature": "def message(self, contents):", "body": "contents = json.loads(contents.decode('<STR_LIT:utf-8>'))<EOL>tp = contents['<STR_LIT:type>']<EOL>if tp == '<STR_LIT>':<EOL><INDENT>self.monitor.stopProcess(contents['<STR_LIT:name>'])<EOL>log.msg(\"<STR_LIT>\", contents['<STR_LIT:name>'])<EOL><DEDENT>elif tp == '<STR_LIT>':<EOL><INDENT>self.monitor.restartAll()<EOL>log.msg(\"<STR_LIT>\")<EOL><DEDENT>elif tp == '<STR_LIT>':<EOL><INDENT>log.msg(\"<STR_LIT>\", contents['<STR_LIT>'])<EOL>for name in self._groupToProcess[contents['<STR_LIT>']]:<EOL><INDENT>log.msg(\"<STR_LIT>\", name)<EOL>self.monitor.stopProcess(name)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>', contents)<EOL><DEDENT>", "docstring": "Respond to a restart or a restart-all message\n\n        :params contents: string, contents of message\n           parsed as JSON, and assumed to have a 'type'\n           key, with value either 'restart' or 'restart-all'.\n           If the value is 'restart', another key\n           ('value') should exist with a logical process\n           name.", "id": "f157:c0:m3"}
{"signature": "def remove(self, name):", "body": "self.monitor.removeProcess(name)<EOL>log.msg(\"<STR_LIT>\", name)<EOL>for group in self._processToGroups.pop(name):<EOL><INDENT>self._groupToProcess[group].remove(name)<EOL><DEDENT>", "docstring": "Remove a process\n\n        :params name: string, name of process", "id": "f157:c0:m2"}
{"signature": "@mainlib.COMMANDS.register(name='<STR_LIT>')<EOL>def main(argv):", "body": "ns = PARSER.parse_args(argv[<NUM_LIT:1>:])<EOL>call(ns)<EOL>", "docstring": "command-line entry point\n\n        --messages: messages directory\n\n        --config: configuration directory\n\n    subcommands:\n        add:\n            name (positional)\n\n            --cmd (required) -- executable\n\n            --arg -- add an argument\n\n            --env -- add an environment variable (VAR=value)\n\n            --uid -- set uid\n\n            --gid -- set gid\n\n            --extras -- a JSON file with more parameters\n\n            --env-inherit -- add an environment variable to inherit\n\n        remove:\n            name (positional)\n        restart:\n            name (positional)\n        restart-all:\n            no arguments", "id": "f158:m8"}
{"signature": "def restart(places, name):", "body": "content = _dumps(dict(type='<STR_LIT>', name=name))<EOL>_addMessage(places, content)<EOL>", "docstring": "Restart a process\n\n    :params places: a Places instance\n    :params name: string, the logical name of the process\n    :returns: None", "id": "f158:m4"}
{"signature": "def makeService(opt):", "body": "restarter, path = parseConfig(opt)<EOL>now = time.time()<EOL>checker = functools.partial(check, path, now)<EOL>beatcheck = tainternet.TimerService(opt['<STR_LIT>'], run, restarter,<EOL>checker, time.time)<EOL>beatcheck.setName('<STR_LIT>')<EOL>return heart.wrapHeart(beatcheck)<EOL>", "docstring": "Make a service\n\n    :params opt: dictionary-like object with 'freq', 'config' and 'messages'\n    :returns: twisted.application.internet.TimerService that at opt['freq']\n              checks for stale processes in opt['config'], and sends\n              restart messages through opt['messages']", "id": "f159:m4"}
{"signature": "def run(restarter, checker, timer):", "body": "for bad in checker(timer()):<EOL><INDENT>restarter(bad)<EOL><DEDENT>", "docstring": "Run restarter on the checker's output\n\n    :params restarter: something to run on the output of the checker\n    :params checker: a function expected to get one argument (current time)\n                     and return a list of stale names\n    :params timer: a function of zero arguments, intended to return current\n                   time\n    :returns: None", "id": "f159:m2"}
{"signature": "def parseConfig(opt):", "body": "places = ctllib.Places(config=opt['<STR_LIT>'], messages=opt['<STR_LIT>'])<EOL>restarter = functools.partial(ctllib.restart, places)<EOL>path = filepath.FilePath(opt['<STR_LIT>'])<EOL>return restarter, path<EOL>", "docstring": "Parse configuration\n\n    :params opt: dict-like object with config and messages keys\n    :returns: restarter, path", "id": "f159:m3"}
{"signature": "def hash_eth2(data: Union[bytes, bytearray]) -> Hash32:", "body": "return Hash32(keccak(data))<EOL>", "docstring": "Return Keccak-256 hashed result.\nNote: it's a placeholder and we aim to migrate to a S[T/N]ARK-friendly hash function in\na future Ethereum 2.0 deployment phase.", "id": "f178:m0"}
{"signature": "def create_access_request(pid_value, users, confirmed):", "body": "datastore = current_app.extensions['<STR_LIT>'].datastore<EOL>receiver = datastore.get_user(users['<STR_LIT>']['<STR_LIT:id>'])<EOL>sender = datastore.get_user(users['<STR_LIT>']['<STR_LIT:id>'])<EOL>return AccessRequest.create(<EOL>recid=pid_value,<EOL>receiver=receiver,<EOL>sender_full_name=\"<STR_LIT>\",<EOL>sender_email=\"<STR_LIT>\",<EOL>sender=sender if confirmed else None,<EOL>justification=\"<STR_LIT>\",<EOL>)<EOL>", "docstring": "Access Request.", "id": "f200:m0"}
{"signature": "@property<EOL><INDENT>def engine(self):<DEDENT>", "body": "if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>from cryptography.fernet import Fernet<EOL>from cryptography.hazmat.backends import default_backend<EOL>from cryptography.hazmat.primitives import hashes<EOL>digest = hashes.Hash(hashes.SHA256(), backend=default_backend())<EOL>digest.update(current_app.config['<STR_LIT>'].encode('<STR_LIT:utf8>'))<EOL>fernet_key = urlsafe_b64encode(digest.finalize())<EOL>self._engine = Fernet(fernet_key)<EOL><DEDENT>return self._engine<EOL>", "docstring": "Get cryptographic engine.", "id": "f208:c1:m0"}
{"signature": "def __init__(self, expires_at=None, **kwargs):", "body": "assert isinstance(expires_at, datetime) or expires_at is None<EOL>dt = expires_at - datetime.now() if expires_at else None<EOL>super(TimedSecretLinkSerializer, self).__init__(<EOL>current_app.config['<STR_LIT>'],<EOL>expires_in=int(dt.total_seconds()) if dt else None,<EOL>salt='<STR_LIT>',<EOL>**kwargs<EOL>)<EOL>", "docstring": "Initialize underlying TimedJSONWebSignatureSerializer.", "id": "f208:c4:m0"}
{"signature": "def validate_reject(form, field):", "body": "if field.data and form.accept.data:<EOL><INDENT>raise validators.ValidationError(<EOL>_(\"<STR_LIT>\")<EOL>)<EOL><DEDENT>", "docstring": "Validate that accept have not been set.", "id": "f211:c1:m1"}
{"signature": "def reverse(self, col):", "body": "if col in self.options:<EOL><INDENT>if self.is_selected(col):<EOL><INDENT>return col if not self.asc else '<STR_LIT>'.format(col)<EOL><DEDENT>else:<EOL><INDENT>return col<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Get reverse direction of ordering.", "id": "f213:c0:m1"}
{"signature": "def __init__(self, options, selected):", "body": "self.options = options<EOL>if selected in options:<EOL><INDENT>self._selected = selected<EOL>self.asc = True<EOL><DEDENT>elif selected and selected[<NUM_LIT:0>] == '<STR_LIT:->' and selected[<NUM_LIT:1>:] in options:<EOL><INDENT>self._selected = selected[<NUM_LIT:1>:]<EOL>self.asc = False<EOL><DEDENT>else:<EOL><INDENT>self._selected = None<EOL>self.asc = None<EOL><DEDENT>", "docstring": "Initialize ordering with possible options the selected option.\n\n        :param options: List of column options.\n        :param selected: Selected column. Prefix name with ``-`` to denote\n            descending ordering.", "id": "f213:c0:m0"}
{"signature": "def dir(self, col, asc='<STR_LIT>', desc='<STR_LIT>'):", "body": "if col == self._selected and self.asc is not None:<EOL><INDENT>return asc if self.asc else desc<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Get direction (ascending/descending) of ordering.", "id": "f213:c0:m2"}
{"signature": "def send_confirmed_notifications(request):", "body": "pid, record = get_record(request.recid)<EOL>if record is None:<EOL><INDENT>current_app.logger.error(\"<STR_LIT>\"<EOL>% request.recid)<EOL>return<EOL><DEDENT>title = _(\"<STR_LIT>\", record=record[\"<STR_LIT:title>\"])<EOL>_send_notification(<EOL>request.receiver.email,<EOL>title,<EOL>\"<STR_LIT>\",<EOL>request=request,<EOL>record=record,<EOL>pid=pid,<EOL>)<EOL>_send_notification(<EOL>request.sender_email,<EOL>title,<EOL>\"<STR_LIT>\",<EOL>request=request,<EOL>record=record,<EOL>pid=pid,<EOL>)<EOL>", "docstring": "Receiver for request-confirmed signal to send email notification.", "id": "f214:m3"}
{"signature": "def send_accept_notification(request, message=None, expires_at=None):", "body": "pid, record = get_record(request.recid)<EOL>_send_notification(<EOL>request.sender_email,<EOL>_(\"<STR_LIT>\"),<EOL>\"<STR_LIT>\",<EOL>request=request,<EOL>record=record,<EOL>pid=pid,<EOL>record_link=request.link.get_absolute_url('<STR_LIT>'),<EOL>message=message,<EOL>expires_at=expires_at,<EOL>)<EOL>", "docstring": "Receiver for request-accepted signal to send email notification.", "id": "f214:m2"}
{"signature": "def create_secret_link(request, message=None, expires_at=None):", "body": "pid, record = get_record(request.recid)<EOL>if not record:<EOL><INDENT>raise RecordNotFound(request.recid)<EOL><DEDENT>description = render_template(<EOL>\"<STR_LIT>\",<EOL>request=request,<EOL>record=record,<EOL>pid=pid,<EOL>expires_at=expires_at,<EOL>message=message,<EOL>)<EOL>request.create_secret_link(<EOL>record[\"<STR_LIT:title>\"],<EOL>description=description,<EOL>expires_at=expires_at<EOL>)<EOL>", "docstring": "Receiver for request-accepted signal.", "id": "f214:m1"}
{"signature": "def _send_notification(to, subject, template, **ctx):", "body": "msg = Message(<EOL>subject,<EOL>sender=current_app.config.get('<STR_LIT>'),<EOL>recipients=[to]<EOL>)<EOL>msg.body = render_template(template, **ctx)<EOL>send_email.delay(msg.__dict__)<EOL>", "docstring": "Render a template and send as email.", "id": "f214:m6"}
{"signature": "def __init__(self, icon=None):", "body": "self._icon = icon<EOL>", "docstring": "Initialize button.", "id": "f215:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def query_by_owner(cls, user):<DEDENT>", "body": "return cls.query.filter_by(<EOL>owner_user_id=user.id<EOL>)<EOL>", "docstring": "Get secret links by user.", "id": "f217:c1:m2"}
{"signature": "def is_valid(self):", "body": "return not(self.is_expired() or self.is_revoked())<EOL>", "docstring": "Determine if link is still valid.", "id": "f217:c1:m8"}
{"signature": "def secret_key():", "body": "return current_app.config['<STR_LIT>'].encode('<STR_LIT:utf-8>')<EOL>", "docstring": "Return secret key as bytearray.", "id": "f217:m0"}
{"signature": "def confirm_email(self):", "body": "with db.session.begin_nested():<EOL><INDENT>if self.status != RequestStatus.EMAIL_VALIDATION:<EOL><INDENT>raise InvalidRequestStateError(RequestStatus.EMAIL_VALIDATION)<EOL><DEDENT>self.status = RequestStatus.PENDING<EOL><DEDENT>request_confirmed.send(self)<EOL>", "docstring": "Confirm that senders email is valid.", "id": "f217:c2:m3"}
{"signature": "def confirm(pid, record, template, **kwargs):", "body": "recid = int(pid.pid_value)<EOL>token = request.view_args['<STR_LIT>']<EOL>data = EmailConfirmationSerializer.compat_validate_token(token)<EOL>if data is None:<EOL><INDENT>flash(_(\"<STR_LIT>\"), category='<STR_LIT>')<EOL>return redirect(url_for(\"<STR_LIT>\", pid_value=recid))<EOL><DEDENT>r = AccessRequest.query.get(data['<STR_LIT:id>'])<EOL>if not r:<EOL><INDENT>abort(<NUM_LIT>)<EOL><DEDENT>if r.status != RequestStatus.EMAIL_VALIDATION:<EOL><INDENT>abort(<NUM_LIT>)<EOL><DEDENT>r.confirm_email()<EOL>db.session.commit()<EOL>flash(_(\"<STR_LIT>\"), category='<STR_LIT:info>')<EOL>return redirect(url_for(\"<STR_LIT>\", pid_value=recid))<EOL>", "docstring": "Confirm email address.", "id": "f218:m4"}
{"signature": "@blueprint.app_template_filter()<EOL>@evalcontextfilter<EOL>def nl2br(eval_ctx, value):", "body": "result = u'<STR_LIT>'.join(u'<STR_LIT>' % p.replace('<STR_LIT:\\n>', '<STR_LIT>')<EOL>for p in _paragraph_re.split(escape(value)))<EOL>if eval_ctx.autoescape:<EOL><INDENT>result = Markup(result)<EOL><DEDENT>return result<EOL>", "docstring": "Template filter to convert newlines to <br>-tags.", "id": "f220:m0"}
{"signature": "def propagate_astrometry(self, phi, theta, parallax, muphistar, mutheta, vrad, t0, t1):", "body": "t = t1-t0<EOL>p0, q0, r0 = normalTriad(phi, theta)<EOL>pmra0 = muphistar*self.mastorad<EOL>pmdec0 = mutheta*self.mastorad<EOL>plx0 = parallax*self.mastorad<EOL>pmr0 = vrad*parallax/auKmYearPerSec*self.mastorad<EOL>pmtot0sqr = (muphistar**<NUM_LIT:2> + mutheta**<NUM_LIT:2>) * self.mastorad**<NUM_LIT:2><EOL>pmvec0 = pmra0*p0+pmdec0*q0<EOL>f = (<NUM_LIT:1> + <NUM_LIT:2>*pmr0*t + (pmtot0sqr+pmr0**<NUM_LIT:2>)*t**<NUM_LIT:2>)**(-<NUM_LIT:0.5>)<EOL>u = (r0*(<NUM_LIT:1>+pmr0*t) + pmvec0*t)*f<EOL>_, phi1, theta1 = cartesianToSpherical(u[<NUM_LIT:0>], u[<NUM_LIT:1>], u[<NUM_LIT:2>])<EOL>parallax1 = parallax*f<EOL>pmr1 = (pmr0+(pmtot0sqr + pmr0**<NUM_LIT:2>)*t)*f**<NUM_LIT:2><EOL>pmvec1 = (pmvec0*(<NUM_LIT:1>+pmr0*t) - r0*pmr0**<NUM_LIT:2>*t)*f**<NUM_LIT:3><EOL>p1, q1, r1 = normalTriad(phi1, theta1)<EOL>muphistar1 = sum(p1*pmvec1/self.mastorad, axis=<NUM_LIT:0>)<EOL>mutheta1 = sum(q1*pmvec1/self.mastorad, axis =<NUM_LIT:0>)<EOL>murad1 = pmr1/self.mastorad<EOL>return phi1, theta1, parallax1, muphistar1, mutheta1, murad1<EOL>", "docstring": "Propagate the position of a source from the reference epoch t0 to the new epoch t1.\n\nParameters\n----------\n\nphi : float\n    Longitude at reference epoch (radians).\ntheta : float\n    Latitude at reference epoch (radians).\nparallax : float\n    Parallax at the reference epoch (mas).\nmuphistar : float\n    Proper motion in longitude (including cos(latitude) term) at reference epoch (mas/yr).\nmutheta : float\n    Proper motion in latitude at reference epoch (mas/yr).\nvrad : float\n    Radial velocity at reference epoch (km/s).\nt0 : float\n    Reference epoch (Julian years).\nt1 : float\n    New epoch (Julian years).\n\nReturns\n-------\n\nAstrometric parameters, including the \"radial proper motion\" (NOT the radial velocity), at the new epoch.\nphi1, theta1, parallax1, muphistar1, mutheta1, mur1 = epoch_prop_pos(..., t0, t1)", "id": "f224:c1:m1"}
{"signature": "def propagate_astrometry_and_covariance_matrix(self, a0, c0, t0, t1):", "body": "zero, one, two, three = <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:3><EOL>tau = t1-t0<EOL>p0, q0, r0 = normalTriad(a0[<NUM_LIT:0>], a0[<NUM_LIT:1>])<EOL>par0 = a0[<NUM_LIT:2>]*self.mastorad<EOL>pma0 = a0[<NUM_LIT:3>]*self.mastorad<EOL>pmd0 = a0[<NUM_LIT:4>]*self.mastorad<EOL>pmr0 = a0[<NUM_LIT:5>]*a0[<NUM_LIT:2>]/auKmYearPerSec*self.mastorad<EOL>pmvec0 = pma0*p0+pmd0*q0<EOL>tau2 = tau*tau<EOL>pm02 = pma0**<NUM_LIT:2> + pmd0**<NUM_LIT:2><EOL>w = one + pmr0*tau<EOL>f2 = one/(one + two*pmr0*tau + (pm02+pmr0**<NUM_LIT:2>)*tau2)<EOL>f = sqrt(f2)<EOL>f3 = f2*f<EOL>f4 = f2*f2<EOL>u = (r0*w + pmvec0*tau)*f<EOL>_, ra, dec = cartesianToSpherical(u[<NUM_LIT:0>], u[<NUM_LIT:1>], u[<NUM_LIT:2>])<EOL>par = par0*f<EOL>pmvec = (pmvec0*(one+pmr0*tau) - r0*pmr0**<NUM_LIT:2>*tau)*f3<EOL>pmr = (pmr0+(pm02 + pmr0**<NUM_LIT:2>)*tau)*f2<EOL>p, q, r = normalTriad(ra, dec)<EOL>pma = sum(p*pmvec, axis=<NUM_LIT:0>)<EOL>pmd = sum(q*pmvec, axis =<NUM_LIT:0>)<EOL>a = zeros_like(a0)<EOL>a[<NUM_LIT:0>] = ra<EOL>a[<NUM_LIT:1>] = dec<EOL>a[<NUM_LIT:2>] = par/self.mastorad<EOL>a[<NUM_LIT:3>] = pma/self.mastorad<EOL>a[<NUM_LIT:4>] = pmd/self.mastorad<EOL>a[<NUM_LIT:5>] = pmr/self.mastorad<EOL>pmz = pmvec0*f - three*pmvec*w<EOL>pp0 = sum(p*p0, axis=<NUM_LIT:0>)<EOL>pq0 = sum(p*q0, axis=<NUM_LIT:0>)<EOL>pr0 = sum(p*r0, axis=<NUM_LIT:0>)<EOL>qp0 = sum(q*p0, axis=<NUM_LIT:0>)<EOL>qq0 = sum(q*q0, axis=<NUM_LIT:0>)<EOL>qr0 = sum(q*r0, axis=<NUM_LIT:0>)<EOL>ppmz = sum(p*pmz, axis=<NUM_LIT:0>)<EOL>qpmz = sum(q*pmz, axis=<NUM_LIT:0>)<EOL>J = zeros_like(c0)<EOL>if (c0.ndim==<NUM_LIT:2>):<EOL><INDENT>J = J[newaxis,:,:]<EOL><DEDENT>J[:,<NUM_LIT:0>,<NUM_LIT:0>] = pp0*w*f - pr0*pma0*tau*f<EOL>J[:,<NUM_LIT:0>,<NUM_LIT:1>] = pq0*w*f - pr0*pmd0*tau*f<EOL>J[:,<NUM_LIT:0>,<NUM_LIT:2>] = zero<EOL>J[:,<NUM_LIT:0>,<NUM_LIT:3>] = pp0*tau*f<EOL>J[:,<NUM_LIT:0>,<NUM_LIT:4>] = pq0*tau*f<EOL>J[:,<NUM_LIT:0>,<NUM_LIT:5>] = -pma*tau2<EOL>J[:,<NUM_LIT:1>,<NUM_LIT:0>] = qp0*w*f - qr0*pma0*tau*f<EOL>J[:,<NUM_LIT:1>,<NUM_LIT:1>] = qq0*w*f - qr0*pmd0*tau*f<EOL>J[:,<NUM_LIT:1>,<NUM_LIT:2>] = zero<EOL>J[:,<NUM_LIT:1>,<NUM_LIT:3>] = qp0*tau*f<EOL>J[:,<NUM_LIT:1>,<NUM_LIT:4>] = qq0*tau*f<EOL>J[:,<NUM_LIT:1>,<NUM_LIT:5>] = -pmd*tau2<EOL>J[:,<NUM_LIT:2>,<NUM_LIT:0>] = zero<EOL>J[:,<NUM_LIT:2>,<NUM_LIT:1>] = zero<EOL>J[:,<NUM_LIT:2>,<NUM_LIT:2>] = f<EOL>J[:,<NUM_LIT:2>,<NUM_LIT:3>] = -par*pma0*tau2*f2<EOL>J[:,<NUM_LIT:2>,<NUM_LIT:4>] = -par*pmd0*tau2*f2<EOL>J[:,<NUM_LIT:2>,<NUM_LIT:5>] = -par*w*tau*f2<EOL>J[:,<NUM_LIT:3>,<NUM_LIT:0>] = -pp0*pm02*tau*f3 - pr0*pma0*w*f3<EOL>J[:,<NUM_LIT:3>,<NUM_LIT:1>] = -pq0*pm02*tau*f3 - pr0*pmd0*w*f3<EOL>J[:,<NUM_LIT:3>,<NUM_LIT:2>] = zero<EOL>J[:,<NUM_LIT:3>,<NUM_LIT:3>] = pp0*w*f3 - two*pr0*pma0*tau*f3 - three*pma*pma0*tau2*f2<EOL>J[:,<NUM_LIT:3>,<NUM_LIT:4>] = pq0*w*f3 - two*pr0*pmd0*tau*f3 - three*pma*pmd0*tau2*f2<EOL>J[:,<NUM_LIT:3>,<NUM_LIT:5>] = ppmz*tau*f2<EOL>J[:,<NUM_LIT:4>,<NUM_LIT:0>] = -qp0*pm02*tau*f3 - qr0*pma0*w*f3<EOL>J[:,<NUM_LIT:4>,<NUM_LIT:1>] = -qq0*pm02*tau*f3 - qr0*pmd0*w*f3<EOL>J[:,<NUM_LIT:4>,<NUM_LIT:2>] = zero<EOL>J[:,<NUM_LIT:4>,<NUM_LIT:3>] = qp0*w*f3 - two*qr0*pma0*tau*f3 - three*pmd*pma0*tau2*f2<EOL>J[:,<NUM_LIT:4>,<NUM_LIT:4>] = qq0*w*f3 - two*qr0*pmd0*tau*f3 - three*pmd*pmd0*tau2*f2<EOL>J[:,<NUM_LIT:4>,<NUM_LIT:5>] = qpmz*tau*f2<EOL>J[:,<NUM_LIT:5>,<NUM_LIT:0>] = zero<EOL>J[:,<NUM_LIT:5>,<NUM_LIT:1>] = zero<EOL>J[:,<NUM_LIT:5>,<NUM_LIT:2>] = zero<EOL>J[:,<NUM_LIT:5>,<NUM_LIT:3>] = two*pma0*w*tau*f4<EOL>J[:,<NUM_LIT:5>,<NUM_LIT:4>] = two*pmd0*w*tau*f4<EOL>J[:,<NUM_LIT:5>,<NUM_LIT:5>] = (w**<NUM_LIT:2> - pm02*tau2)*f4<EOL>JT = zeros_like(J)<EOL>for i in range(J.shape[<NUM_LIT:0>]):<EOL><INDENT>JT[i] = J[i].T<EOL><DEDENT>if (c0.ndim==<NUM_LIT:2>):<EOL><INDENT>c = matmul(J,matmul(c0[newaxis,:,:],JT))<EOL><DEDENT>else:<EOL><INDENT>c = matmul(J,matmul(c0,JT))<EOL><DEDENT>return a, squeeze(c)<EOL>", "docstring": "Propagate the covariance matrix of the astrometric parameters and radial proper motion of a\nsource from epoch t0 to epoch t1.\n\nCode based on the Hipparcos Fortran implementation by Lennart Lindegren.\n\nParameters\n----------\n\na0 : array_like\n    6-element vector: (phi, theta, parallax, muphistar, mutheta, vrad) in units of (radians,\n    radians, mas, mas/yr, mas/yr, km/s). Shape of a should be (6,) or (6,N), with N the number of\n    sources for which the astrometric parameters are provided.\n\nc0 : array_like\n    Covariance matrix stored in a 6x6 element array. This can be constructed from the columns\n    listed in the Gaia catalogue. The units are [mas^2, mas^2/yr, mas^2/yr^2] for the various\n    elements. Note that the elements in the 6th row and column should be:\n    c[6,i]=c[i,6]=c[i,3]*vrad/auKmYearPerSec for i=1,..,5 and\n    c[6,6]=c[3,3]*(vrad^2+vrad_error^2)/auKmYearPerSec^2+(parallax*vrad_error/auKmYearPerSec)^2\n\n    Shape of c0 should be (6,6) or (N,6,6).\n\nt0 : float\n    Reference epoch (Julian years).\n\nt1 : float\n    New epoch (Julian years).\n\nReturns\n-------\n\nAstrometric parameters, including the \"radial proper motion\" (NOT the radial velocity), and\ncovariance matrix at the new epoch as a 2D matrix with the new variances on the diagional and the\ncovariance in the off-diagonal elements.", "id": "f224:c1:m3"}
{"signature": "def transformCartesianCoordinates(self, x, y, z):", "body": "xrot, yrot, zrot = dot(self.rotationMatrix,[x,y,z])<EOL>return xrot, yrot, zrot<EOL>", "docstring": "Rotates Cartesian coordinates from one reference system to another using the rotation matrix with\nwhich the class was initialized. The inputs  can be scalars or 1-dimensional numpy arrays.\n\nParameters\n----------\n\nx - Value of X-coordinate in original reference system\ny - Value of Y-coordinate in original reference system\nz - Value of Z-coordinate in original reference system\n\nReturns\n-------\n\nxrot - Value of X-coordinate after rotation\nyrot - Value of Y-coordinate after rotation\nzrot - Value of Z-coordinate after rotation", "id": "f224:c0:m1"}
{"signature": "def __init__(self, desiredTransformation):", "body": "self.rotationMatrix=_rotationMatrixMap[desiredTransformation]<EOL>self.transformationStrings=_transformationStringMap[desiredTransformation]<EOL>", "docstring": "Class constructor/initializer. Sets the type of transformation to be used.\n\nParameters\n----------\n\ndesiredTransformation - The kind of coordinate transformation that should be provided. For example\nTransformations.GAL2ECL", "id": "f224:c0:m0"}
{"signature": "def propagate_pos(self, phi, theta, parallax, muphistar, mutheta, vrad, t0, t1):", "body": "phi1, theta1, parallax1, muphistar1, mutheta1, vrad1 = self.epoch_prop_astrometry(phi, theta, parallax, muphistar, mutheta, vrad, t0, t1)<EOL>return phi1, theta1<EOL>", "docstring": "Propagate the position of a source from the reference epoch t0 to the new epoch t1.\n\nParameters\n----------\n\nphi : float\n    Longitude at reference epoch (radians).\ntheta : float\n    Latitude at reference epoch (radians).\nparallax : float\n    Parallax at the reference epoch (mas).\nmuphistar : float\n    Proper motion in longitude (including cos(latitude) term) at reference epoch (mas/yr).\nmutheta : float\n    Proper motion in latitude at reference epoch (mas/yr).\nvrad : float\n    Radial velocity at reference epoch (km/s).\nt0 : float\n    Reference epoch (Julian years).\nt1 : float\n    New epoch (Julian years).\n\nReturns\n-------\n\nCoordinates phi and theta at new epoch (in radians)", "id": "f224:c1:m2"}
{"signature": "def transformSkyCoordinateErrors(self, phi, theta, sigPhiStar, sigTheta, rhoPhiTheta=<NUM_LIT:0>):", "body": "if isscalar(rhoPhiTheta) and not isscalar(sigTheta):<EOL><INDENT>rhoPhiTheta=zeros_like(sigTheta)+rhoPhiTheta<EOL><DEDENT>c, s = self._getJacobian(phi,theta)<EOL>cSqr = c*c<EOL>sSqr = s*s<EOL>covar = sigPhiStar*sigTheta*rhoPhiTheta<EOL>varPhiStar = sigPhiStar*sigPhiStar<EOL>varTheta = sigTheta*sigTheta<EOL>varPhiStarRot = cSqr*varPhiStar+sSqr*varTheta+<NUM_LIT>*covar*c*s<EOL>varThetaRot = sSqr*varPhiStar+cSqr*varTheta-<NUM_LIT>*covar*c*s<EOL>covarRot = (cSqr-sSqr)*covar+c*s*(varTheta-varPhiStar)<EOL>return sqrt(varPhiStarRot), sqrt(varThetaRot), covarRot/sqrt(varPhiStarRot*varThetaRot)<EOL>", "docstring": "Converts the sky coordinate errors from one reference system to another, including the covariance\nterm. Equations (1.5.4) and (1.5.20) from section 1.5 in the Hipparcos Explanatory Volume 1 are used.\n\nParameters\n----------\n\nphi         - The longitude-like angle of the position of the source (radians).\ntheta       - The latitude-like angle of the position of the source (radians).\nsigPhiStar  - Standard error in the longitude-like angle of the position of the source (radians or\n              sexagesimal units, including cos(latitude) term)\nsigTheta    - Standard error in the latitude-like angle of the position of the source (radians or\n              sexagesimal units)\n\nKeywords (optional)\n-------------------\n\nrhoPhiTheta - Correlation coefficient of the position errors. Set to zero if this keyword is not\n              provided.\n\nRetuns\n------\n\nsigPhiRotStar  - The transformed standard error in the longitude-like angle (including\n                 cos(latitude) factor)\nsigThetaRot    - The transformed standard error in the latitude-like angle.\nrhoPhiThetaRot - The transformed correlation coefficient.", "id": "f224:c0:m4"}
{"signature": "def phaseSpaceToAstrometry(x, y, z, vx, vy, vz):", "body": "u, phi, theta = cartesianToSpherical(x, y, z)<EOL>parallax = _auMasParsec/u<EOL>p, q, r = normalTriad(phi, theta)<EOL>velocitiesArray=array([vx,vy,vz])<EOL>if  isscalar(u):<EOL><INDENT>muphistar=dot(p,velocitiesArray)*parallax/_auKmYearPerSec<EOL>mutheta=dot(q,velocitiesArray)*parallax/_auKmYearPerSec<EOL>vrad=dot(r,velocitiesArray)<EOL><DEDENT>else:<EOL><INDENT>muphistar=zeros_like(parallax)<EOL>mutheta=zeros_like(parallax)<EOL>vrad=zeros_like(parallax)<EOL>for i in range(parallax.size):<EOL><INDENT>muphistar[i]=dot(p[:,i],velocitiesArray[:,i])*parallax[i]/_auKmYearPerSec<EOL>mutheta[i]=dot(q[:,i],velocitiesArray[:,i])*parallax[i]/_auKmYearPerSec<EOL>vrad[i]=dot(r[:,i],velocitiesArray[:,i])<EOL><DEDENT><DEDENT>return phi, theta, parallax, muphistar, mutheta, vrad<EOL>", "docstring": "From the given phase space coordinates calculate the astrometric observables, including the radial\nvelocity, which here is seen as the sixth astrometric parameter. The phase space coordinates are\nassumed to represent barycentric (i.e. centred on the Sun) positions and velocities.\n\nThis function has no mechanism to deal with units. The velocity units are always assumed to be km/s,\nand the code is set up such that for positions in pc, the return units for the astrometry are radians,\nmilliarcsec, milliarcsec/year and km/s. For positions in kpc the return units are: radians,\nmicroarcsec, microarcsec/year, and km/s.\n\nNOTE that the doppler factor k=1/(1-vrad/c) is NOT used in the calculations. This is not a problem for\nsources moving at typical velocities of Galactic stars.\n\nParameters\n----------\n\nx - The x component of the barycentric position vector (in pc or kpc).\ny - The y component of the barycentric position vector (in pc or kpc).\nz - The z component of the barycentric position vector (in pc or kpc).\nvx - The x component of the barycentric velocity vector (in km/s).\nvy - The y component of the barycentric velocity vector (in km/s).\nvz - The z component of the barycentric velocity vector (in km/s).\n\nReturns\n-------\n\nphi       - The longitude-like angle of the position of the source (radians).\ntheta     - The latitude-like angle of the position of the source (radians).\nparallax  - The parallax of the source (in mas or muas, see above)\nmuphistar - The proper motion in the longitude-like angle, multiplied by cos(theta) (mas/yr or muas/yr,\nsee above)\nmutheta   - The proper motion in the latitude-like angle (mas/yr or muas/yr, see above)\nvrad      - The radial velocity (km/s)", "id": "f227:m4"}
{"signature": "def elementaryRotationMatrix(axis, rotationAngle):", "body": "if (axis==\"<STR_LIT:x>\" or axis==\"<STR_LIT:X>\"):<EOL><INDENT>return array([[<NUM_LIT:1.0>, <NUM_LIT:0.0>, <NUM_LIT:0.0>], [<NUM_LIT:0.0>, cos(rotationAngle), sin(rotationAngle)], [<NUM_LIT:0.0>,<EOL>-sin(rotationAngle), cos(rotationAngle)]])<EOL><DEDENT>elif (axis==\"<STR_LIT:y>\" or axis==\"<STR_LIT:Y>\"):<EOL><INDENT>return array([[cos(rotationAngle), <NUM_LIT:0.0>, -sin(rotationAngle)], [<NUM_LIT:0.0>, <NUM_LIT:1.0>, <NUM_LIT:0.0>], [sin(rotationAngle),<EOL><NUM_LIT:0.0>, cos(rotationAngle)]])<EOL><DEDENT>elif (axis==\"<STR_LIT:z>\" or axis==\"<STR_LIT>\"):<EOL><INDENT>return array([[cos(rotationAngle), sin(rotationAngle), <NUM_LIT:0.0>], [-sin(rotationAngle),<EOL>cos(rotationAngle), <NUM_LIT:0.0>], [<NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT:1.0>]])<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\"+axis+\"<STR_LIT:!>\")<EOL><DEDENT>", "docstring": "Construct an elementary rotation matrix describing a rotation around the x, y, or z-axis.\n\nParameters\n----------\n\naxis          - Axis around which to rotate (\"x\", \"y\", or \"z\")\nrotationAngle - the rotation angle in radians\n\nReturns\n-------\n\nThe rotation matrix\n\nExample usage\n-------------\n\nrotmat = elementaryRotationMatrix(\"y\", pi/6.0)", "id": "f227:m3"}
{"signature": "def sphericalToCartesian(r, phi, theta):", "body": "ctheta=cos(theta)<EOL>x=r*cos(phi)*ctheta<EOL>y=r*sin(phi)*ctheta<EOL>z=r*sin(theta)<EOL>return x, y, z<EOL>", "docstring": "Convert spherical to Cartesian coordinates. The input can be scalars or 1-dimensional numpy arrays.\nNote that the angle coordinates follow the astronomical convention of using elevation (declination,\nlatitude) rather than its complement (pi/2-elevation), where the latter is commonly used in the\nmathematical treatment of spherical coordinates.\n\nParameters\n----------\n\nr     - length of input Cartesian vector.\nphi   - longitude-like angle (e.g., right ascension, ecliptic longitude) in radians\ntheta - latitide-like angle (e.g., declination, ecliptic latitude) in radians\n\nReturns\n-------\n\nThe Cartesian vector components x, y, z", "id": "f227:m0"}
{"signature": "def _generateRandomCovarianceMatrices(self, num):", "body": "varDiag1 = rand(num)*<NUM_LIT>+<NUM_LIT:1.0><EOL>varDiag2 = rand(num)*<NUM_LIT>+<NUM_LIT:1.0><EOL>rotAngle = <NUM_LIT>*pi*rand(num)<EOL>sigma1 = zeros(num)<EOL>sigma2 = zeros(num)<EOL>rho12 = zeros(num)<EOL>for i in range(num): <EOL><INDENT>rotationMatrix=array([[cos(rotAngle[i]), sin(rotAngle[i])], [-sin(rotAngle[i]), cos(rotAngle[i])]])<EOL>covMatrix = dot(rotationMatrix,dot(diag([varDiag1[i],varDiag2[i]]),transpose(rotationMatrix)))<EOL>sigma1[i] = sqrt(covMatrix[<NUM_LIT:0>,<NUM_LIT:0>])<EOL>sigma2[i] = sqrt(covMatrix[<NUM_LIT:1>,<NUM_LIT:1>])<EOL>rho12[i] = covMatrix[<NUM_LIT:0>,<NUM_LIT:1>]/(sigma1[i]*sigma2[i])<EOL><DEDENT>return sigma1, sigma2, rho12<EOL>", "docstring": "Generate random covariance matrices through the transformation of diagonal positive definite\nmatrices.\n\nParameters\n----------\n\nnum - Number of matrices to generate.\n\nReturns\n-------\n\nsigma1 - Square root of variance of first variable.\nsigma2 - Square root of variance of second variable.\nrho12  - Correlation coefficient between errors on variables 1 and 2", "id": "f229:c0:m12"}
{"signature": "def _is_pos_def(self, A):", "body": "if allclose(A, A.T, rtol=<NUM_LIT>, atol=<NUM_LIT>):<EOL><INDENT>try:<EOL><INDENT>cholesky(A)<EOL>return True<EOL><DEDENT>except LinAlgError:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Check if matrix A is positive definite. Code from\nhttps://stackoverflow.com/questions/16266720/find-out-if-matrix-is-positive-definite-with-numpy", "id": "f229:c0:m13"}
{"signature": "def rpMagnitudeError(G, vmini):", "body": "z=calcZBpRp(G)<EOL>a = -<NUM_LIT>*power(vmini,<NUM_LIT:3>) + <NUM_LIT>*vmini*vmini - <NUM_LIT>*vmini + <NUM_LIT><EOL>b = -<NUM_LIT>*power(vmini,<NUM_LIT:3>) + <NUM_LIT>*vmini*vmini - <NUM_LIT>*vmini + <NUM_LIT><EOL>c = -<NUM_LIT>*power(vmini,<NUM_LIT:3>) + <NUM_LIT>*vmini*vmini - <NUM_LIT>*vmini - <NUM_LIT><EOL>return <NUM_LIT>*sqrt(power(<NUM_LIT>,a)*z*z+power(<NUM_LIT>,b)*z+power(<NUM_LIT>,c))<EOL>", "docstring": "Calculate the single-field-of-view-transit photometric standard error in the RP band as a function\nof G and (V-I). Note: this refers to the integrated flux from the RP spectrophotometer. A margin of 20%\nis included.\n\nParameters\n----------\n\nG     - Value(s) of G-band magnitude.\nvmini - Value(s) of (V-I) colour.\n\nReturns\n-------\n\nThe RP band photometric standard error in units of magnitude.", "id": "f235:m4"}
{"signature": "def calcZBpRp(G):", "body": "gatefloor=power(<NUM_LIT>,<NUM_LIT>*(<NUM_LIT>-<NUM_LIT>))<EOL>if isscalar(G):<EOL><INDENT>result=amax((gatefloor,power(<NUM_LIT>,<NUM_LIT>*(G-<NUM_LIT>))))<EOL><DEDENT>else :<EOL><INDENT>result=power(<NUM_LIT>,<NUM_LIT>*(G-<NUM_LIT>))<EOL>indices=(result<gatefloor)<EOL>result[indices]=gatefloor<EOL><DEDENT>return result<EOL>", "docstring": "Calculate the value for the parameter z in the formula for the BP and RP magnitude errors as a\nfunction of G and (V-I).\n\nParameters\n----------\n\nG - Value of G-band magnitude.\n\nReturns\n-------\n\nValue of z for BP/RP.", "id": "f237:m1"}
{"signature": "def vradErrorSkyAvg(vmag, spt):", "body": "return _vradCalibrationFloor + _vradErrorBCoeff[spt]*exp(_vradErrorACoeff[spt]*(vmag-_vradMagnitudeZeroPoint))<EOL>", "docstring": "Calculate radial velocity error from V and the spectral type. The value of the error is an average over\nthe sky.\n\nParameters\n----------\n\nvmag - Value of V-band magnitude.\nspt  - String representing the spectral type of the star.\n\nReturns\n-------\n\nThe radial velocity error in km/s.", "id": "f238:m0"}
{"signature": "def positionMinError(G, vmini, extension=<NUM_LIT:0.0>):", "body": "parallaxError = parallaxErrorSkyAvg(G, vmini, extension=extension)<EOL>return _astrometricErrorFactors['<STR_LIT>'].min()*parallaxError,_astrometricErrorFactors['<STR_LIT>'].min()*parallaxError<EOL>", "docstring": "Calculate the minimum position errors from G and (V-I). These correspond to the sky regions with the\nsmallest astrometric errors.\n\nNOTE! THE ERRORS ARE FOR SKY POSITIONS IN THE ICRS (I.E., RIGHT ASCENSION, DECLINATION). MAKE SURE YOUR\nSIMULATED ASTROMETRY IS ALSO ON THE ICRS.\n\nParameters\n----------\n\nG     - Value(s) of G-band magnitude.\nvmini - Value(s) of (V-I) colour.\n\nKeywords\n--------\n\nextension - Add this amount of years to the mission lifetime and scale the errors accordingly.\n\nReturns\n-------\n\nThe minimum error in alpha* and the error in delta, in that order, in micro-arcsecond.", "id": "f239:m8"}
{"signature": "def errorScalingMissionLength(extension, p):", "body": "return power((_nominalLifeTime+extension)/_nominalLifeTime, p)<EOL>", "docstring": "Calculate the factor by which to scale errors for a given Gaia mission extension.\n\nParameters\n----------\n\nextension - The mission extension in years (a negative extension can be used to make crude\nperformance predictions part-way through the mission lifetime).\np - The power by which the errors scale with time (error ~ t^p, p=-0.5 for parallax and celestial\nposition, and -1.5 for proper motion).\n\nReturns\n-------\n\nThe factor by which to scale the errors", "id": "f239:m1"}
{"signature": "def positionMaxError(G, vmini, extension=<NUM_LIT:0.0>):", "body": "parallaxError = parallaxErrorSkyAvg(G, vmini, extension)<EOL>return _astrometricErrorFactors['<STR_LIT>'].max()*parallaxError,_astrometricErrorFactors['<STR_LIT>'].max()*parallaxError<EOL>", "docstring": "Calculate the maximum position errors from G and (V-I). These correspond to the sky regions with the\nlargest astrometric errors.\n\nNOTE! THE ERRORS ARE FOR SKY POSITIONS IN THE ICRS (I.E., RIGHT ASCENSION, DECLINATION). MAKE SURE YOUR\nSIMULATED ASTROMETRY IS ALSO ON THE ICRS.\n\nParameters\n----------\n\nG     - Value(s) of G-band magnitude.\nvmini - Value(s) of (V-I) colour.\n\nKeywords\n--------\n\nextension - Add this amount of years to the mission lifetime and scale the errors accordingly.\n\nReturns\n-------\n\nThe maximum error in alpha* and the error in delta, in that order, in micro-arcsecond.", "id": "f239:m9"}
{"signature": "def parallaxMaxError(G, vmini, extension=<NUM_LIT:0.0>):", "body": "errors = _astrometricErrorFactors[\"<STR_LIT>\"].max()*parallaxErrorSkyAvg(G, vmini, extension=extension)<EOL>indices = (errors<_parallaxErrorMaxBright)<EOL>errors[indices]=_parallaxErrorMaxBright<EOL>return errors<EOL>", "docstring": "Calculate the maximum parallax error from G and (V-I). This correspond to the sky regions with the\nlargest astrometric errors.  At the bright end the parallax error is at least 14 muas due to the\ngating scheme.\n\nParameters\n----------\n\nG     - Value(s) of G-band magnitude.\nvmini - Value(s) of (V-I) colour.\n\nKeywords\n--------\n\nextension - Add this amount of years to the mission lifetime and scale the errors accordingly.\n\nReturns\n-------\n\nThe maximum parallax error in micro-arcseconds.", "id": "f239:m4"}
{"signature": "def parallaxMinError(G, vmini, extension=<NUM_LIT:0.0>):", "body": "return _astrometricErrorFactors[\"<STR_LIT>\"].min()*parallaxErrorSkyAvg(G, vmini, extension=extension)<EOL>", "docstring": "Calculate the minimum parallax error from G and (V-I). This correspond to the sky regions with the\nsmallest astrometric errors.  At the bright end the parallax error is at least 14 muas due to the\ngating scheme.\n\nParameters\n----------\n\nG     - Value(s) of G-band magnitude.\nvmini - Value(s) of (V-I) colour.\n\nKeywords\n--------\n\nextension - Add this amount of years to the mission lifetime and scale the errors accordingly.\n\nReturns\n-------\n\nThe minimum parallax error in micro-arcseconds.", "id": "f239:m3"}
{"signature": "def degreesToRadians(angle):", "body": "return angle/<NUM_LIT>*np.pi<EOL>", "docstring": "Convert from degrees to radians.\n\nParameters\n----------\n\nangle - angle in degrees\n\nReturns\n-------\n\nAngle in radians.", "id": "f240:m1"}
{"signature": "def parseCommandLineArguments():", "body": "parser = argparse.ArgumentParser(description=\"\"\"<STR_LIT>\"\"\")<EOL>parser.add_argument(\"<STR_LIT>\", action=\"<STR_LIT:store_true>\", dest=\"<STR_LIT>\", help=\"<STR_LIT>\")<EOL>parser.add_argument(\"<STR_LIT>\", action=\"<STR_LIT:store_true>\", dest=\"<STR_LIT>\", help=\"<STR_LIT>\")<EOL>args=vars(parser.parse_args())<EOL>return args<EOL>", "docstring": "Set up command line parsing.", "id": "f244:m1"}
{"signature": "def makePlot(pdf=False, png=False):", "body": "logdistancekpc = np.linspace(-<NUM_LIT:1>,np.log10(<NUM_LIT>),<NUM_LIT:100>)<EOL>sptVabsAndVmini=OrderedDict([('<STR_LIT>',(<NUM_LIT>,<NUM_LIT>)), ('<STR_LIT>',(<NUM_LIT>,<NUM_LIT>)), ('<STR_LIT>',(<NUM_LIT>,<NUM_LIT>)),<EOL>('<STR_LIT>',(<NUM_LIT>,<NUM_LIT>)), ('<STR_LIT>',(<NUM_LIT>,<NUM_LIT>)), ('<STR_LIT>',(<NUM_LIT>,<NUM_LIT:1.0>))])<EOL>lines={}<EOL>fig=plt.figure(figsize=(<NUM_LIT:10>,<NUM_LIT>))<EOL>currentAxis=plt.gca()<EOL>for spt in sptVabsAndVmini.keys():<EOL><INDENT>vmag=sptVabsAndVmini[spt][<NUM_LIT:0>]+<NUM_LIT>*logdistancekpc+<NUM_LIT><EOL>indices=(vmag><NUM_LIT>) & (vmag<<NUM_LIT:16>)<EOL>gmag=vmag+gminvFromVmini(sptVabsAndVmini[spt][<NUM_LIT:1>])<EOL>parerrors=parallaxErrorSkyAvg(gmag,sptVabsAndVmini[spt][<NUM_LIT:1>])<EOL>relparerrors=parerrors*<NUM_LIT:10>**logdistancekpc/<NUM_LIT><EOL>plt.loglog(<NUM_LIT:10>**logdistancekpc, relparerrors,'<STR_LIT>',lw=<NUM_LIT:1>)<EOL>plt.loglog(<NUM_LIT:10>**logdistancekpc[indices], relparerrors[indices],'<STR_LIT:->',label=spt)<EOL><DEDENT>plt.xlim(<NUM_LIT:0.1>,<NUM_LIT>)<EOL>plt.ylim(<NUM_LIT>,<NUM_LIT:0.5>)<EOL>plt.text(<NUM_LIT>, <NUM_LIT>,'<STR_LIT>',<EOL>horizontalalignment='<STR_LIT:right>',<EOL>verticalalignment='<STR_LIT>',<EOL>transform = currentAxis.transAxes)<EOL>plt.legend(loc=<NUM_LIT:2>)<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.grid(which='<STR_LIT>')<EOL>if (args['<STR_LIT>']):<EOL><INDENT>plt.savefig('<STR_LIT>')<EOL><DEDENT>elif (args['<STR_LIT>']):<EOL><INDENT>plt.savefig('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.show()<EOL><DEDENT>", "docstring": "Plot relative parallax errors as a function of distance for stars of a given spectral type.\n\nParameters\n----------\n\nargs - command line arguments", "id": "f244:m0"}
{"signature": "def parseCommandLineArguments():", "body": "parser = argparse.ArgumentParser(description=\"<STR_LIT>\")<EOL>parser.add_argument(\"<STR_LIT>\", dest=\"<STR_LIT>\", type=float, help=\"<STR_LIT>\", default=<NUM_LIT:0.0>)<EOL>parser.add_argument(\"<STR_LIT>\", action=\"<STR_LIT:store_true>\", dest=\"<STR_LIT>\", help=\"<STR_LIT>\")<EOL>parser.add_argument(\"<STR_LIT>\", action=\"<STR_LIT:store_true>\", dest=\"<STR_LIT>\", help=\"<STR_LIT>\")<EOL>args=vars(parser.parse_args())<EOL>return args<EOL>", "docstring": "Set up command line parsing.", "id": "f246:m1"}
{"signature": "def makePlot(args):", "body": "gmag=np.linspace(<NUM_LIT>,<NUM_LIT>,<NUM_LIT>)<EOL>vmini = args['<STR_LIT>']<EOL>vmag=gmag-gminvFromVmini(vmini)<EOL>if args['<STR_LIT>']:<EOL><INDENT>sigmaG = gMagnitudeErrorEoM(gmag)<EOL>sigmaGBp = bpMagnitudeErrorEoM(gmag, vmini)<EOL>sigmaGRp = rpMagnitudeErrorEoM(gmag, vmini)<EOL>yminmax = (<NUM_LIT:1.0>-<NUM_LIT:4>,<NUM_LIT:0.1>)<EOL><DEDENT>else:<EOL><INDENT>sigmaG = gMagnitudeError(gmag)<EOL>sigmaGBp = bpMagnitudeError(gmag, vmini)<EOL>sigmaGRp = rpMagnitudeError(gmag, vmini)<EOL>yminmax = (<NUM_LIT:1.0>-<NUM_LIT:4>,<NUM_LIT:1>)<EOL><DEDENT>fig=plt.figure(figsize=(<NUM_LIT:10>,<NUM_LIT>))<EOL>if (args['<STR_LIT>']):<EOL><INDENT>plt.semilogy(vmag, sigmaG, '<STR_LIT:k>', label='<STR_LIT>')<EOL>plt.semilogy(vmag, sigmaGBp, '<STR_LIT:b>', label='<STR_LIT>'+'<STR_LIT>'.format(vmini))<EOL>plt.semilogy(vmag, sigmaGRp, '<STR_LIT:r>', label='<STR_LIT>'+'<STR_LIT>'.format(vmini))<EOL>plt.xlim((<NUM_LIT:6>,<NUM_LIT:20>))<EOL>plt.legend(loc=<NUM_LIT:0>)<EOL>plt.xlabel('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>ax=fig.add_subplot(<NUM_LIT>)<EOL>plt.semilogy(gmag, sigmaG, '<STR_LIT:k>', label='<STR_LIT>')<EOL>plt.semilogy(gmag, sigmaGBp, '<STR_LIT:b>', label='<STR_LIT>'+'<STR_LIT>'.format(vmini))<EOL>plt.semilogy(gmag, sigmaGRp, '<STR_LIT:r>', label='<STR_LIT>'+'<STR_LIT>'.format(vmini))<EOL>plt.xlim((<NUM_LIT:6>,<NUM_LIT:20>))<EOL>plt.legend(loc=<NUM_LIT:0>)<EOL>plt.xlabel('<STR_LIT>')<EOL><DEDENT>plt.xticks(np.arange(<NUM_LIT:6>,<NUM_LIT:20>,<NUM_LIT:2>))<EOL>ax = plt.gca().yaxis <EOL>plt.grid(which='<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>if args['<STR_LIT>']:<EOL><INDENT>plt.title('<STR_LIT>'.format(vmini), fontsize=<NUM_LIT>)<EOL><DEDENT>else:<EOL><INDENT>plt.title('<STR_LIT>'.format(vmini), fontsize=<NUM_LIT>)<EOL><DEDENT>basename = '<STR_LIT>'<EOL>if (args['<STR_LIT>']):<EOL><INDENT>plt.savefig(basename+'<STR_LIT>')<EOL><DEDENT>elif (args['<STR_LIT>']):<EOL><INDENT>plt.savefig(basename+'<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.show()<EOL><DEDENT>", "docstring": "Make the plot with photometry performance predictions.\n\n:argument args: command line arguments", "id": "f248:m0"}
{"signature": "def makePlot(gmag, pdf=False, png=False, rvs=False):", "body": "vmini = np.linspace(-<NUM_LIT:0.5>,<NUM_LIT>,<NUM_LIT:100>)<EOL>if (rvs):<EOL><INDENT>gminv = -vminGrvsFromVmini(vmini)<EOL><DEDENT>else:<EOL><INDENT>gminv = gminvFromVmini(vmini)<EOL><DEDENT>mvlimit100pc = gmag-<NUM_LIT>*np.log10(<NUM_LIT>)+<NUM_LIT>-gminv<EOL>mvlimit1kpc = gmag-<NUM_LIT>*np.log10(<NUM_LIT>)+<NUM_LIT>-gminv<EOL>mvlimit10kpc = gmag-<NUM_LIT>*np.log10(<NUM_LIT>)+<NUM_LIT>-gminv<EOL>fig=plt.figure(figsize=(<NUM_LIT:8>,<NUM_LIT:8>))<EOL>plt.plot(vmini,mvlimit100pc,'<STR_LIT:b>')<EOL>plt.text(vmini[<NUM_LIT:50>]-<NUM_LIT>,mvlimit100pc[<NUM_LIT:50>],\"<STR_LIT>\", horizontalalignment='<STR_LIT:right>', va='<STR_LIT>')<EOL>plt.plot(vmini,mvlimit1kpc,'<STR_LIT:r>')<EOL>plt.text(vmini[<NUM_LIT:50>]-<NUM_LIT>,mvlimit1kpc[<NUM_LIT:50>],\"<STR_LIT>\", horizontalalignment='<STR_LIT:right>', va='<STR_LIT>')<EOL>plt.plot(vmini,mvlimit10kpc,'<STR_LIT:g>')<EOL>plt.text(vmini[<NUM_LIT:50>]-<NUM_LIT>,mvlimit10kpc[<NUM_LIT:50>],\"<STR_LIT>\", horizontalalignment='<STR_LIT:right>', va='<STR_LIT>')<EOL>ax=plt.gca()<EOL>ax.set_ylim(ax.get_ylim()[::-<NUM_LIT:1>])<EOL>plt.xlabel(\"<STR_LIT>\")<EOL>plt.ylabel(\"<STR_LIT>\")<EOL>if (rvs):<EOL><INDENT>plt.title(\"<STR_LIT>\"+\"<STR_LIT>\".format(gmag))<EOL><DEDENT>else:<EOL><INDENT>plt.title(\"<STR_LIT>\".format(gmag))<EOL><DEDENT>if (args['<STR_LIT>']):<EOL><INDENT>plt.savefig('<STR_LIT>')<EOL><DEDENT>elif (args['<STR_LIT>']):<EOL><INDENT>plt.savefig('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.show()<EOL><DEDENT>", "docstring": "Make a plot of a Mv vs (V-I) colour magnitude diagram containing lines of constant distance for stars\nat G=20. This will give an idea of the reach of Gaia.\n\nParameters\n----------\n\nargs - command line arguments", "id": "f249:m0"}
{"signature": "def parseCommandLineArguments():", "body": "parser = argparse.ArgumentParser(description=\"\"\"<STR_LIT>\"\"\")<EOL>parser.add_argument(\"<STR_LIT>\", help=\"<STR_LIT>\", type=float)<EOL>parser.add_argument(\"<STR_LIT>\", action=\"<STR_LIT:store_true>\", dest=\"<STR_LIT>\", help=\"<STR_LIT>\")<EOL>parser.add_argument(\"<STR_LIT>\", action=\"<STR_LIT:store_true>\", dest=\"<STR_LIT>\", help=\"<STR_LIT>\")<EOL>parser.add_argument(\"<STR_LIT>\", action=\"<STR_LIT:store_true>\", dest=\"<STR_LIT>\", help=\"<STR_LIT>\")<EOL>args=vars(parser.parse_args())<EOL>return args<EOL>", "docstring": "Set up command line parsing.", "id": "f249:m1"}
{"signature": "def makePlot(args):", "body": "gRvs=np.linspace(<NUM_LIT>,<NUM_LIT>,<NUM_LIT>)<EOL>spts=['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>fig=plt.figure(figsize=(<NUM_LIT:10>,<NUM_LIT>))<EOL>deltaHue = <NUM_LIT>/(len(spts)-<NUM_LIT:1>)<EOL>hsv=np.zeros((<NUM_LIT:1>,<NUM_LIT:1>,<NUM_LIT:3>))<EOL>hsv[<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:1>]=<NUM_LIT:1.0><EOL>hsv[<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:2>]=<NUM_LIT><EOL>count=<NUM_LIT:0><EOL>for spt in spts:<EOL><INDENT>hsv[<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>]=(<NUM_LIT>-count*deltaHue)/<NUM_LIT><EOL>vmag = vminGrvsFromVmini(vminiFromSpt(spt)) + gRvs<EOL>vradErrors = vradErrorSkyAvg(vmag, spt)<EOL>plt.plot(vmag, vradErrors, '<STR_LIT:->', label=spt, color=hsv_to_rgb(hsv)[<NUM_LIT:0>,<NUM_LIT:0>,:])<EOL>count+=<NUM_LIT:1><EOL><DEDENT>plt.grid(which='<STR_LIT>')<EOL>plt.xlim(<NUM_LIT:9>,<NUM_LIT>)<EOL>plt.ylim(<NUM_LIT:0>,<NUM_LIT:20>)<EOL>plt.xticks(np.arange(<NUM_LIT:9>,<NUM_LIT>,<NUM_LIT:1>))<EOL>plt.yticks(np.arange(<NUM_LIT:0>,<NUM_LIT>,<NUM_LIT:5>))<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>leg=plt.legend(loc=<NUM_LIT:0>,  handlelength=<NUM_LIT>, labelspacing=<NUM_LIT>)<EOL>for t in leg.get_texts():<EOL><INDENT>t.set_fontsize(<NUM_LIT:12>)<EOL><DEDENT>if (args['<STR_LIT>']):<EOL><INDENT>plt.savefig('<STR_LIT>')<EOL><DEDENT>elif (args['<STR_LIT>']):<EOL><INDENT>plt.savefig('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.show()<EOL><DEDENT>", "docstring": "Make the plot with radial velocity performance predictions.\n\n:argument args: command line arguments", "id": "f250:m0"}
{"signature": "def parseCommandLineArguments():", "body": "parser = argparse.ArgumentParser(description=\"<STR_LIT>\")<EOL>parser.add_argument(\"<STR_LIT>\", action=\"<STR_LIT:store_true>\", dest=\"<STR_LIT>\", help=\"<STR_LIT>\")<EOL>parser.add_argument(\"<STR_LIT>\", action=\"<STR_LIT:store_true>\", dest=\"<STR_LIT>\", help=\"<STR_LIT>\")<EOL>parser.add_argument(\"<STR_LIT>\", action=\"<STR_LIT:store_true>\", dest=\"<STR_LIT>\", help=\"<STR_LIT>\")<EOL>args=vars(parser.parse_args())<EOL>return args<EOL>", "docstring": "Set up command line parsing.", "id": "f250:m1"}
{"signature": "def makePlot(args):", "body": "gmag=np.linspace(<NUM_LIT>,<NUM_LIT>,<NUM_LIT>)<EOL>vminiB1V=vminiFromSpt('<STR_LIT>')<EOL>vminiG2V=vminiFromSpt('<STR_LIT>')<EOL>vminiM6V=vminiFromSpt('<STR_LIT>')<EOL>vmagB1V=gmag-gminvFromVmini(vminiB1V)<EOL>vmagG2V=gmag-gminvFromVmini(vminiG2V)<EOL>vmagM6V=gmag-gminvFromVmini(vminiM6V)<EOL>sigmualphaB1V, sigmudeltaB1V = properMotionErrorSkyAvg(gmag,vminiB1V)<EOL>sigmuB1V = np.sqrt(<NUM_LIT:0.5>*sigmualphaB1V**<NUM_LIT:2>+<NUM_LIT:0.5>*sigmudeltaB1V**<NUM_LIT:2>)<EOL>sigmualphaB1V, sigmudeltaB1V = properMotionMinError(gmag,vminiB1V)<EOL>sigmuB1Vmin = np.sqrt(<NUM_LIT:0.5>*sigmualphaB1V**<NUM_LIT:2>+<NUM_LIT:0.5>*sigmudeltaB1V**<NUM_LIT:2>)<EOL>sigmualphaB1V, sigmudeltaB1V = properMotionMaxError(gmag,vminiB1V)<EOL>sigmuB1Vmax = np.sqrt(<NUM_LIT:0.5>*sigmualphaB1V**<NUM_LIT:2>+<NUM_LIT:0.5>*sigmudeltaB1V**<NUM_LIT:2>)<EOL>sigmualphaG2V, sigmudeltaG2V = properMotionErrorSkyAvg(gmag,vminiG2V)<EOL>sigmuG2V = np.sqrt(<NUM_LIT:0.5>*sigmualphaG2V**<NUM_LIT:2>+<NUM_LIT:0.5>*sigmudeltaG2V**<NUM_LIT:2>)<EOL>sigmualphaG2V, sigmudeltaG2V = properMotionMinError(gmag,vminiG2V)<EOL>sigmuG2Vmin = np.sqrt(<NUM_LIT:0.5>*sigmualphaG2V**<NUM_LIT:2>+<NUM_LIT:0.5>*sigmudeltaG2V**<NUM_LIT:2>)<EOL>sigmualphaG2V, sigmudeltaG2V = properMotionMaxError(gmag,vminiG2V)<EOL>sigmuG2Vmax = np.sqrt(<NUM_LIT:0.5>*sigmualphaG2V**<NUM_LIT:2>+<NUM_LIT:0.5>*sigmudeltaG2V**<NUM_LIT:2>)<EOL>sigmualphaM6V, sigmudeltaM6V = properMotionErrorSkyAvg(gmag,vminiM6V)<EOL>sigmuM6V = np.sqrt(<NUM_LIT:0.5>*sigmualphaM6V**<NUM_LIT:2>+<NUM_LIT:0.5>*sigmudeltaM6V**<NUM_LIT:2>)<EOL>sigmualphaM6V, sigmudeltaM6V = properMotionMinError(gmag,vminiM6V)<EOL>sigmuM6Vmin = np.sqrt(<NUM_LIT:0.5>*sigmualphaM6V**<NUM_LIT:2>+<NUM_LIT:0.5>*sigmudeltaM6V**<NUM_LIT:2>)<EOL>sigmualphaM6V, sigmudeltaM6V = properMotionMaxError(gmag,vminiM6V)<EOL>sigmuM6Vmax = np.sqrt(<NUM_LIT:0.5>*sigmualphaM6V**<NUM_LIT:2>+<NUM_LIT:0.5>*sigmudeltaM6V**<NUM_LIT:2>)<EOL>fig=plt.figure(figsize=(<NUM_LIT:10>,<NUM_LIT>))<EOL>if (args['<STR_LIT>']):<EOL><INDENT>plt.semilogy(gmag, sigmuB1V, '<STR_LIT:b>', label='<STR_LIT>')<EOL>plt.semilogy(gmag, sigmuG2V, '<STR_LIT:g>', label='<STR_LIT>')<EOL>plt.semilogy(gmag, sigmuM6V, '<STR_LIT:r>', label='<STR_LIT>')<EOL>plt.xlim((<NUM_LIT:5>,<NUM_LIT:20>))<EOL>plt.ylim((<NUM_LIT:1>,<NUM_LIT>))<EOL>plt.legend(loc=<NUM_LIT:4>)<EOL><DEDENT>else:<EOL><INDENT>ax=fig.add_subplot(<NUM_LIT>)<EOL>plt.semilogy(vmagB1V, sigmuB1V, '<STR_LIT:b>', label='<STR_LIT>')<EOL>plt.semilogy(vmagM6V, sigmuM6V, '<STR_LIT:r>', label='<STR_LIT>')<EOL>plt.fill_between(vmagB1V, sigmuB1Vmin, sigmuB1Vmax, color='<STR_LIT:b>', alpha=<NUM_LIT>)<EOL>plt.fill_between(vmagM6V, sigmuM6Vmin, sigmuM6Vmax, color='<STR_LIT:r>', alpha=<NUM_LIT>)<EOL>plt.xlim((<NUM_LIT:5>,<NUM_LIT>))<EOL>plt.ylim((<NUM_LIT:1>,<NUM_LIT>))<EOL>plt.text(<NUM_LIT>,<NUM_LIT:100>,'<STR_LIT>',color='<STR_LIT:b>')<EOL>plt.text(<NUM_LIT>,<NUM_LIT:10>,'<STR_LIT>',color='<STR_LIT:r>')<EOL>plt.text(<NUM_LIT:7>,<NUM_LIT:11>,'<STR_LIT>', size=<NUM_LIT:12>, bbox=dict(boxstyle=\"<STR_LIT>\",<EOL>ec=(<NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>fc=(<NUM_LIT:1.0>, <NUM_LIT:1.0>, <NUM_LIT:1.0>),<EOL>))<EOL>plt.text(<NUM_LIT>,<NUM_LIT:50>,'<STR_LIT>', rotation=<NUM_LIT>, size=<NUM_LIT:12>, bbox=dict(boxstyle=\"<STR_LIT>\",<EOL>ec=(<NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT:0.0>),<EOL>fc=(<NUM_LIT:1.0>, <NUM_LIT:1.0>, <NUM_LIT:1.0>),<EOL>))<EOL>ax.annotate('<STR_LIT>', xy=(<NUM_LIT>, <NUM_LIT>),  xycoords='<STR_LIT:data>',<EOL>xytext=(<NUM_LIT>,<NUM_LIT:30>), textcoords='<STR_LIT:data>', ha='<STR_LIT>', size='<STR_LIT>',<EOL>bbox=dict(boxstyle=\"<STR_LIT>\",ec=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>),fc=(<NUM_LIT:1>,<NUM_LIT:1>,<NUM_LIT:1>)),<EOL>arrowprops=dict(facecolor='<STR_LIT>', shrink=<NUM_LIT>, width=<NUM_LIT:1>,<EOL>headwidth=<NUM_LIT:6>),<EOL>horizontalalignment='<STR_LIT:right>', verticalalignment='<STR_LIT>',<EOL>)<EOL>ax.annotate('<STR_LIT>', xy=(<NUM_LIT>, <NUM_LIT>),  xycoords='<STR_LIT:data>',<EOL>xytext=(<NUM_LIT>,<NUM_LIT>), textcoords='<STR_LIT:data>', ha='<STR_LIT>', size='<STR_LIT>',<EOL>arrowprops=dict(facecolor='<STR_LIT>', shrink=<NUM_LIT>, width=<NUM_LIT:1>,<EOL>headwidth=<NUM_LIT:6>),<EOL>horizontalalignment='<STR_LIT:right>', verticalalignment='<STR_LIT>',<EOL>)<EOL><DEDENT>plt.xticks(np.arange(<NUM_LIT:6>,<NUM_LIT>,<NUM_LIT:2>))<EOL>ax = plt.gca().yaxis <EOL>ax.set_major_formatter(matplotlib.ticker.ScalarFormatter())<EOL>plt.ticklabel_format(axis='<STR_LIT:y>',style='<STR_LIT>')<EOL>plt.grid(which='<STR_LIT>')<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>basename = '<STR_LIT>'<EOL>if (args['<STR_LIT>']):<EOL><INDENT>plt.savefig(basename+'<STR_LIT>')<EOL><DEDENT>elif (args['<STR_LIT>']):<EOL><INDENT>plt.savefig(basename+'<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>plt.show()<EOL><DEDENT>", "docstring": "Make the plot with proper motion performance predictions. The predictions are for the TOTAL proper\nmotion under the assumption of equal components mu_alpha* and mu_delta.\n\n:argument args: command line arguments", "id": "f251:m0"}
{"signature": "def parseCommandLineArguments():", "body": "parser = argparse.ArgumentParser(description=\"<STR_LIT>\")<EOL>parser.add_argument(\"<STR_LIT>\", help=\"<STR_LIT>\", type=float)<EOL>parser.add_argument(\"<STR_LIT>\", help=\"<STR_LIT>\", type=float)<EOL>args=vars(parser.parse_args())<EOL>return args<EOL>", "docstring": "Set up command line parsing.", "id": "f253:m1"}
{"signature": "@gen.coroutine<EOL><INDENT>@query_params('<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>def mlt(self, index, doc_type, id, body=None, params=None):<DEDENT>", "body": "_, data = yield self.transport.perform_request(<EOL>'<STR_LIT:GET>', _make_path(index, doc_type, id, '<STR_LIT>'),<EOL>params=params, body=body)<EOL>raise gen.Return(data)<EOL>", "docstring": "Get documents that are \"like\" a specified document.\n`<http://elasticsearch.org/guide/reference/api/more-like-this/>`_\n\n:arg index: The name of the index\n:arg doc_type: The type of the document (use `_all` to fetch the first\n    document matching the ID across all types)\n:arg id: The document ID\n:arg body: A specific search request definition\n:arg boost_terms: The boost factor\n:arg max_doc_freq: The word occurrence frequency as count: words with\n    higher occurrence in the corpus will be ignored\n:arg max_query_terms: The maximum query terms to be included in the\n    generated query\n:arg max_word_len: The minimum length of the word: longer words will\n    be ignored\n:arg min_doc_freq: The word occurrence frequency as count: words with\n    lower occurrence in the corpus will be ignored\n:arg min_term_freq: The term frequency as percent: terms with lower\n    occurrence in the source document will be ignored\n:arg min_word_len: The minimum length of the word: shorter words will\n    be ignored\n:arg mlt_fields: Specific fields to perform the query against\n:arg percent_terms_to_match: How many terms have to match in order to\n    consider the document a match (default: 0.3)\n:arg routing: Specific routing value\n:arg search_from: The offset from which to return results\n:arg search_indices: A comma-separated list of indices to perform the\n    query against (default: the index containing the document)\n:arg search_query_hint: The search query hint\n:arg search_scroll: A scroll search request definition\n:arg search_size: The number of documents to return (default: 10)\n:arg search_source: A specific search request definition (instead of\n    using the request body)\n:arg search_type: Specific search type (eg. `dfs_then_fetch`, `count`,\n    etc)\n:arg search_types: A comma-separated list of types to perform the query\n    against (default: the same type as the document)\n:arg stop_words: A list of stop words to be ignored", "id": "f255:c2:m24"}
{"signature": "@gen.coroutine<EOL><INDENT>@query_params('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT:source>')<EOL>def count(self, index=None, doc_type=None, body=None, params=None):<DEDENT>", "body": "_, data = yield self.transport.perform_request('<STR_LIT:POST>',<EOL>_make_path(index,<EOL>doc_type,<EOL>'<STR_LIT>'),<EOL>params=params, body=body)<EOL>raise gen.Return(data)<EOL>", "docstring": "Execute a query and get the number of matches for that query.\n`<http://elasticsearch.org/guide/reference/api/count/>`_\n\n:arg index: A comma-separated list of indices to restrict the results\n:arg doc_type: A comma-separated list of types to restrict the results\n:arg body: A query to restrict the results (optional)\n:arg ignore_indices: When performed on multiple indices, allows to\n    ignore `missing` ones (default: none)\n:arg min_score: Include only documents with a specific `_score` value\n    in the result\n:arg preference: Specify the node or shard the operation should be\n    performed on (default: random)\n:arg routing: Specific routing value\n:arg source: The URL-encoded query definition (instead of using the\n    request body)", "id": "f255:c2:m17"}
{"signature": "@gen.coroutine<EOL><INDENT>@query_params('<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT:q>', '<STR_LIT>', '<STR_LIT:source>')<EOL>def explain(self, index, doc_type, id, body=None, params=None):<DEDENT>", "body": "_, data = yield self.transport.perform_request('<STR_LIT:GET>',<EOL>_make_path(index,<EOL>doc_type, id,<EOL>'<STR_LIT>'),<EOL>params=params, body=body)<EOL>raise gen.Return(data)<EOL>", "docstring": "The explain api computes a score explanation for a query and a specific\ndocument. This can give useful feedback whether a document matches or\ndidn't match a specific query.\n`<http://elasticsearch.org/guide/reference/api/explain/>`_\n\n:arg index: The name of the index\n:arg doc_type: The type of the document\n:arg id: The document ID\n:arg body: The query definition using the Query DSL\n:arg _source: True or false to return the _source field or not, or a\n    list of fields to return\n:arg _source_exclude: A list of fields to exclude from the returned\n    _source field\n:arg _source_include: A list of fields to extract and return from the\n    _source field\n:arg analyze_wildcard: Specify whether wildcards and prefix queries in\n    the query string query should be analyzed (default: false)\n:arg analyzer: The analyzer for the query string query\n:arg default_operator: The default operator for query string query (AND\n    or OR), (default: OR)\n:arg df: The default field for query string query (default: _all)\n:arg fields: A comma-separated list of fields to return in the response\n:arg lenient: Specify whether format-based query failures (such as\n    providing text to a numeric field) should be ignored\n:arg lowercase_expanded_terms: Specify whether query terms should be\n    lowercased\n:arg parent: The ID of the parent document\n:arg preference: Specify the node or shard the operation should be\n    performed on (default: random)\n:arg q: Query in the Lucene query string syntax\n:arg routing: Specific routing value\n:arg source: The URL-encoded query definition (instead of using the\n    request body)", "id": "f255:c2:m13"}
{"signature": "@gen.coroutine<EOL><INDENT>@query_params()<EOL>def ping(self, params=None):<DEDENT>", "body": "try:<EOL><INDENT>self.transport.perform_request('<STR_LIT>', '<STR_LIT:/>', params=params)<EOL><DEDENT>except TransportError:<EOL><INDENT>raise gen.Return(False)<EOL><DEDENT>raise gen.Return(True)<EOL>", "docstring": "Returns True if the cluster is up, False otherwise.", "id": "f255:c2:m1"}
{"signature": "@gen.coroutine<EOL><INDENT>@query_params('<STR_LIT>')<EOL>def msearch(self, body, index=None, doc_type=None, params=None):<DEDENT>", "body": "_, data = yield self.transport.perform_request('<STR_LIT:GET>',<EOL>_make_path(index,<EOL>doc_type,<EOL>'<STR_LIT>'),<EOL>params=params,<EOL>body=self._bulk_body(body))<EOL>raise gen.Return(data)<EOL>", "docstring": "Execute several search requests within the same API.\n`<http://www.elasticsearch.org/guide/reference/api/multi-search/>`_\n\n:arg body: The request definitions (metadata-search request definition\n    pairs), separated by newlines\n:arg index: A comma-separated list of index names to use as default\n:arg doc_type: A comma-separated list of document types to use as default\n:arg search_type: Search operation type", "id": "f255:c2:m19"}
{"signature": "@gen.coroutine<EOL><INDENT>@query_params('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT:version>', '<STR_LIT>')<EOL>def index(self, index, doc_type, body, id=None, params=None):<DEDENT>", "body": "_, data = yield self.transport.perform_request(<EOL>'<STR_LIT>' if id else '<STR_LIT:POST>', _make_path(index, doc_type, id),<EOL>params=params, body=body)<EOL>raise gen.Return(data)<EOL>", "docstring": "Adds or updates a typed JSON document in a specific index, making it\nsearchable. `<http://elasticsearch.org/guide/reference/api/index_/>`_\n\n:arg index: The name of the index\n:arg doc_type: The type of the document\n:arg body: The document\n:arg id: Document ID\n:arg consistency: Explicit write consistency setting for the operation\n:arg op_type: Explicit operation type (default: index)\n:arg parent: ID of the parent document\n:arg percolate: Percolator queries to execute while indexing the doc\n:arg refresh: Refresh the index after performing the operation\n:arg replication: Specific replication type (default: sync)\n:arg routing: Specific routing value\n:arg timeout: Explicit operation timeout\n:arg timestamp: Explicit timestamp for the document\n:arg ttl: Expiration time for the document\n:arg version: Explicit version number for concurrency control\n:arg version_type: Specific version type", "id": "f255:c2:m5"}
{"signature": "@gen.coroutine<EOL><INDENT>@query_params('<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>def bulk(self, body, index=None, doc_type=None, params=None):<DEDENT>", "body": "_, data = yield self.transport.perform_request('<STR_LIT:POST>',<EOL>_make_path(index,<EOL>doc_type,<EOL>'<STR_LIT>'),<EOL>params=params,<EOL>body=self._bulk_body(body))<EOL>raise gen.Return(data)<EOL>", "docstring": "Perform many index/delete operations in a single API call.\n`<http://elasticsearch.org/guide/reference/api/bulk/>`_\n\nSee the :func:`~elasticsearch.helpers.bulk_index` for a more friendly\nAPI.\n\n:arg body: The operation definition and data (action-data pairs)\n:arg index: Default index for items which don't provide one\n:arg doc_type: Default document type for items which don't provide one\n:arg consistency: Explicit write consistency setting for the operation\n:arg refresh: Refresh the index after performing the operation\n:arg replication: Explicitly set the replication type (efault: sync)", "id": "f255:c2:m18"}
{"signature": "@gen.coroutine<EOL><INDENT>@query_params('<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>')<EOL>def get_mapping(self, index=None, doc_type=None, params=None):<DEDENT>", "body": "_, data = yield self.transport.perform_request('<STR_LIT:GET>',<EOL>_make_path(index,<EOL>'<STR_LIT>',<EOL>doc_type),<EOL>params=params)<EOL>raise gen.Return(data)<EOL>", "docstring": "Retrieve mapping definition of index or index/type.\n`<http://www.elastic.co/guide/en/elasticsearch/reference/current/indices-get-mapping.html>`_\n:arg index: A comma-separated list of index names\n:arg doc_type: A comma-separated list of document types\n:arg allow_no_indices: Whether to ignore if a wildcard indices\n    expression resolves into no concrete indices. (This includes `_all`\n    string or when no indices have been specified)\n:arg expand_wildcards: Whether to expand wildcard expression to concrete\n    indices that are open, closed or both., default 'open', valid\n    choices are: 'open', 'closed', 'none', 'all'\n:arg ignore_unavailable: Whether specified concrete indices should be\n    ignored when unavailable (missing or closed)\n:arg local: Return local information, do not retrieve the state from\n    master node (default: false)", "id": "f255:c2:m21"}
{"signature": "def recommendations(self, **kwargs):", "body": "path = self._get_id_path('<STR_LIT>')<EOL>response = self._GET(path, kwargs)<EOL>self._set_attrs_to_values(response)<EOL>return response<EOL>", "docstring": "Get the recommendations for TV series for a specific TV series id.\n\nArgs:\n    page: (optional) Minimum value of 1.  Expected value is an integer.\n    language: (optional) ISO 639-1 code.\n\nReturns:\n    A dict respresentation of the JSON returned from the API.", "id": "f272:c0:m9"}
{"signature": "def rating(self, **kwargs):", "body": "path = self._get_id_path('<STR_LIT>')<EOL>payload = {<EOL>'<STR_LIT:value>': kwargs.pop('<STR_LIT:value>', None),<EOL>}<EOL>response = self._POST(path, kwargs, payload)<EOL>self._set_attrs_to_values(response)<EOL>return response<EOL>", "docstring": "This method lets users rate a TV show. A valid session id or guest\nsession id is required.\n\nArgs:\n    session_id: see Authentication.\n    guest_session_id: see Authentication.\n    value: Rating value.\n\nReturns:\n    A dict respresentation of the JSON returned from the API.", "id": "f272:c0:m7"}
{"signature": "def credits(self, **kwargs):", "body": "path = self._get_series_id_season_number_path('<STR_LIT>')<EOL>response = self._GET(path, kwargs)<EOL>self._set_attrs_to_values(response)<EOL>return response<EOL>", "docstring": "Get the cast & crew credits for a TV season by season number.\n\nReturns:\n    A dict respresentation of the JSON returned from the API.", "id": "f272:c1:m2"}
{"signature": "def translations(self, **kwargs):", "body": "path = self._get_id_path('<STR_LIT>')<EOL>response = self._GET(path, kwargs)<EOL>self._set_attrs_to_values(response)<EOL>return response<EOL>", "docstring": "Get the list of translations that exist for a TV series. These\ntranslations cascade down to the episode level.\n\nReturns:\n    A dict respresentation of the JSON returned from the API.", "id": "f272:c0:m10"}
{"signature": "def images(self, **kwargs):", "body": "path = self._get_id_path('<STR_LIT>')<EOL>response = self._GET(path, kwargs)<EOL>self._set_attrs_to_values(response)<EOL>return response<EOL>", "docstring": "Get the images (posters and backdrops) for a TV series.\n\nArgs:\n    language: (optional) ISO 639 code.\n    include_image_language: (optional) Comma separated, a valid\n                            ISO 69-1.\n\nReturns:\n    A dict respresentation of the JSON returned from the API.", "id": "f272:c0:m6"}
{"signature": "def external_ids(self, **kwargs):", "body": "path = self._get_series_id_season_number_path('<STR_LIT>')<EOL>response = self._GET(path, kwargs)<EOL>self._set_attrs_to_values(response)<EOL>return response<EOL>", "docstring": "Get the external ids that we have stored for a TV season by season\nnumber.\n\nArgs:\n    language: (optional) ISO 639 code.\n\nReturns:\n    A dict respresentation of the JSON returned from the API.", "id": "f272:c1:m3"}
{"signature": "def airing_today(self, **kwargs):", "body": "path = self._get_path('<STR_LIT>')<EOL>response = self._GET(path, kwargs)<EOL>self._set_attrs_to_values(response)<EOL>return response<EOL>", "docstring": "Get the list of TV shows that air today. Without a specified timezone,\nthis query defaults to EST (Eastern Time UTC-05:00).\n\nArgs:\n    page: (optional) Minimum 1, maximum 1000.\n    language: (optional) ISO 639 code.\n    timezone: (optional) Valid value from the list of timezones.\n\nReturns:\n    A dict respresentation of the JSON returned from the API.", "id": "f272:c0:m14"}
{"signature": "def collection(self, **kwargs):", "body": "path = self._get_path('<STR_LIT>')<EOL>response = self._GET(path, kwargs)<EOL>self._set_attrs_to_values(response)<EOL>return response<EOL>", "docstring": "Search for collections by name.\n\nArgs:\n    query: CGI escpaed string.\n    page: (optional) Minimum value of 1. Expected value is an integer.\n    language: (optional) ISO 639-1 code.\n\nReturns:\n    A dict respresentation of the JSON returned from the API.", "id": "f275:c0:m1"}
{"signature": "def multi(self, **kwargs):", "body": "path = self._get_path('<STR_LIT>')<EOL>response = self._GET(path, kwargs)<EOL>self._set_attrs_to_values(response)<EOL>return response<EOL>", "docstring": "Search the movie, tv show and person collections with a single query.\n\nArgs:\n    query: CGI escpaed string.\n    page: (optional) Minimum value of 1. Expected value is an integer.\n    language: (optional) ISO 639-1 code.\n    include_adult: (optional) Toggle the inclusion of adult titles.\n                   Expected value is True or False.\n\nReturns:\n    A dict respresentation of the JSON returned from the API.", "id": "f275:c0:m6"}
{"signature": "def movie(self, **kwargs):", "body": "path = self._get_path('<STR_LIT>')<EOL>response = self._GET(path, kwargs)<EOL>self._set_attrs_to_values(response)<EOL>return response<EOL>", "docstring": "Search for movies by title.\n\nArgs:\n    query: CGI escpaed string.\n    page: (optional) Minimum value of 1. Expected value is an integer.\n    language: (optional) ISO 639-1 code.\n    include_adult: (optional) Toggle the inclusion of adult titles. \n                   Expected value is True or False.\n    year: (optional) Filter the results release dates to matches that \n          include this value.\n    primary_release_year: (optional) Filter the results so that only \n                          the primary release dates have this value.\n    search_type: (optional) By default, the search type is 'phrase'. \n                 This is almost guaranteed the option you will want. \n                 It's a great all purpose search type and by far the \n                 most tuned for every day querying. For those wanting \n                 more of an \"autocomplete\" type search, set this \n                 option to 'ngram'.\n\nReturns:\n    A dict respresentation of the JSON returned from the API.", "id": "f275:c0:m0"}
{"signature": "def keyword(self, **kwargs):", "body": "path = self._get_path('<STR_LIT>')<EOL>response = self._GET(path, kwargs)<EOL>self._set_attrs_to_values(response)<EOL>return response<EOL>", "docstring": "Search for keywords by name.\n\nArgs:\n    query: CGI escpaed string.\n    page: (optional) Minimum value of 1. Expected value is an integer.\n\nReturns:\n    A dict respresentation of the JSON returned from the API.", "id": "f275:c0:m5"}
{"signature": "def person(self, **kwargs):", "body": "path = self._get_path('<STR_LIT>')<EOL>response = self._GET(path, kwargs)<EOL>self._set_attrs_to_values(response)<EOL>return response<EOL>", "docstring": "Search for people by name.\n\nArgs:\n    query: CGI escpaed string.\n    page: (optional) Minimum value of 1. Expected value is an integer.\n    include_adult: (optional) Toggle the inclusion of adult titles. \n                   Expected value is True or False.\n    search_type: (optional) By default, the search type is 'phrase'. \n                 This is almost guaranteed the option you will want. \n                 It's a great all purpose search type and by far the \n                 most tuned for every day querying. For those wanting \n                 more of an \"autocomplete\" type search, set this \n                 option to 'ngram'.\n\nReturns:\n    A dict respresentation of the JSON returned from the API.", "id": "f275:c0:m3"}
{"signature": "def images(self, **kwargs):", "body": "path = self._get_id_path('<STR_LIT>')<EOL>response = self._GET(path, kwargs)<EOL>self._set_attrs_to_values(response)<EOL>return response<EOL>", "docstring": "Get all of the images for a particular collection by collection id.\n\nArgs:\n    language: (optional) ISO 639-1 code.\n    append_to_response: (optional) Comma separated, any movie method.\n    include_image_language: (optional) Comma separated, a valid\n    ISO 69-1.\n\nReturns:\n    A dict representation of the JSON returned from the API.", "id": "f276:c1:m2"}
{"signature": "def movies(self, **kwargs):", "body": "path = self._get_id_path('<STR_LIT>')<EOL>response = self._GET(path, kwargs)<EOL>self._set_attrs_to_values(response)<EOL>return response<EOL>", "docstring": "Get the list of movies associated with a particular company.\n\nArgs:\n    page: (optional) Minimum value of 1.  Expected value is an integer.\n    language: (optional) ISO 639-1 code.\n    append_to_response: (optional) Comma separated, any movie method.\n\nReturns:\n    A dict representation of the JSON returned from the API.", "id": "f276:c2:m2"}
{"signature": "def info(self, **kwargs):", "body": "path = self._get_id_path('<STR_LIT:info>')<EOL>response = self._GET(path, kwargs)<EOL>self._set_attrs_to_values(response)<EOL>return response<EOL>", "docstring": "Get the full details of a review by ID.\n\nReturns:\n    A dict representation of the JSON returned from the API.", "id": "f276:c4:m1"}
{"signature": "def now_playing(self, **kwargs):", "body": "path = self._get_path('<STR_LIT>')<EOL>response = self._GET(path, kwargs)<EOL>self._set_attrs_to_values(response)<EOL>return response<EOL>", "docstring": "Get the list of movies playing in theatres. This list refreshes\nevery day. The maximum number of items this list will include is 100.\n\nArgs:\n    page: (optional) Minimum value of 1.  Expected value is an integer.\n    language: (optional) ISO 639-1 code.\n\nReturns:\n    A dict representation of the JSON returned from the API.", "id": "f276:c0:m18"}
{"signature": "def info(self, **kwargs):", "body": "path = self._get_id_path('<STR_LIT:info>')<EOL>response = self._GET(path, kwargs)<EOL>self._set_attrs_to_values(response)<EOL>return response<EOL>", "docstring": "This method is used to retrieve all of the basic information about a\ncompany.\n\nArgs:\n    append_to_response: (optional) Comma separated, any movie method.\n\nReturns:\n    A dict representation of the JSON returned from the API.", "id": "f276:c2:m1"}
{"signature": "def alternative_titles(self, **kwargs):", "body": "path = self._get_id_path('<STR_LIT>')<EOL>response = self._GET(path, kwargs)<EOL>self._set_attrs_to_values(response)<EOL>return response<EOL>", "docstring": "Get the alternative titles for a specific movie id.\n\nArgs:\n    country: (optional) ISO 3166-1 code.\n    append_to_response: (optional) Comma separated, any movie method.\n\nReturns:\n    A dict representation of the JSON returned from the API.", "id": "f276:c0:m2"}
{"signature": "def rating(self, **kwargs):", "body": "path = self._get_id_path('<STR_LIT>')<EOL>payload = {<EOL>'<STR_LIT:value>': kwargs.pop('<STR_LIT:value>', None),<EOL>}<EOL>response = self._POST(path, kwargs, payload)<EOL>self._set_attrs_to_values(response)<EOL>return response<EOL>", "docstring": "This method lets users rate a movie. A valid session id or guest\nsession id is required.\n\nArgs:\n    session_id: see Authentication.\n    guest_session_id: see Authentication.\n    value: Rating value.\n\nReturns:\n    A dict representation of the JSON returned from the API.", "id": "f276:c0:m22"}
{"signature": "def popular(self, **kwargs):", "body": "path = self._get_path('<STR_LIT>')<EOL>response = self._GET(path, kwargs)<EOL>self._set_attrs_to_values(response)<EOL>return response<EOL>", "docstring": "Get the list of popular people on The Movie Database. This list \nrefreshes every day.\n\nArgs:\n    page: (optional) Minimum 1, maximum 1000.\n\nReturns:\n    A dict respresentation of the JSON returned from the API.", "id": "f277:c0:m8"}
{"signature": "def info(self, **kwargs):", "body": "path = self._get_credit_id_path('<STR_LIT:info>')<EOL>response = self._GET(path, kwargs)<EOL>self._set_attrs_to_values(response)<EOL>return response<EOL>", "docstring": "Get the detailed information about a particular credit record. This is \ncurrently only supported with the new credit model found in TV. These \nids can be found from any TV credit response as well as the tv_credits \nand combined_credits methods for people.\n\nThe episodes object returns a list of episodes and are generally going \nto be guest stars. The season array will return a list of season \nnumbers.  Season credits are credits that were marked with the \n\"add to every season\" option in the editing interface and are \nassumed to be \"season regulars\".\n\nArgs:\n    language: (optional) ISO 639-1 code.\n\nReturns:\n    A dict respresentation of the JSON returned from the API.", "id": "f277:c1:m1"}
{"signature": "def tv_credits(self, **kwargs):", "body": "path = self._get_id_path('<STR_LIT>')<EOL>response = self._GET(path, kwargs)<EOL>self._set_attrs_to_values(response)<EOL>return response<EOL>", "docstring": "Get the TV credits for a specific person id.\n\nArgs:\n    language: (optional) ISO 639-1 code.\n    append_to_response: (optional) Comma separated, any person method.\n\nReturns:\n    A dict respresentation of the JSON returned from the API.", "id": "f277:c0:m3"}
{"signature": "def list(self, **kwargs):", "body": "path = self._get_path('<STR_LIT:list>')<EOL>response = self._GET(path, kwargs)<EOL>self._set_attrs_to_values(response)<EOL>return response<EOL>", "docstring": "Get the list of supported timezones for the API methods that support\nthem.\n\nReturns:\n    A dict respresentation of the JSON returned from the API.", "id": "f279:c2:m0"}
{"signature": "def list(self, **kwargs):", "body": "path = self._get_path('<STR_LIT>')<EOL>response = self._GET(path, kwargs)<EOL>self._set_attrs_to_values(response)<EOL>return response<EOL>", "docstring": "Get the list of supported certifications for movies.\n\nReturns:\n    A dict respresentation of the JSON returned from the API.", "id": "f279:c1:m0"}
{"signature": "def favorite(self, **kwargs):", "body": "path = self._get_id_path('<STR_LIT>')<EOL>kwargs.update({'<STR_LIT>': self.session_id})<EOL>payload = {<EOL>'<STR_LIT>': kwargs.pop('<STR_LIT>', None), <EOL>'<STR_LIT>': kwargs.pop('<STR_LIT>', None), <EOL>'<STR_LIT>': kwargs.pop('<STR_LIT>', None),<EOL>}<EOL>response = self._POST(path, kwargs, payload)<EOL>self._set_attrs_to_values(response)<EOL>return response<EOL>", "docstring": "Add or remove a movie to an accounts favorite list.\n\nArgs:\n    media_type: 'movie' | 'tv'\n    media_id: The id of the media.\n    favorite: True (to add) | False (to remove).\n\nReturns:\n    A dict respresentation of the JSON returned from the API.", "id": "f281:c0:m5"}
{"signature": "def session_new(self, **kwargs):", "body": "path = self._get_path('<STR_LIT>')<EOL>response = self._GET(path, kwargs)<EOL>self._set_attrs_to_values(response)<EOL>return response<EOL>", "docstring": "Generate a session id for user based authentication.\n\nA session id is required in order to use any of the write methods.\n\nArgs:\n    request_token: The token you generated for the user to approve.\n                   The token needs to be approved before being\n                   used here.\n\nReturns:\n    A dict respresentation of the JSON returned from the API.", "id": "f281:c1:m2"}
{"signature": "def add_item(self, **kwargs):", "body": "path = self._get_id_path('<STR_LIT>')<EOL>kwargs.update({'<STR_LIT>': self.session_id})<EOL>payload = {<EOL>'<STR_LIT>': kwargs.pop('<STR_LIT>', None), <EOL>}<EOL>response = self._POST(path, kwargs, payload)<EOL>self._set_attrs_to_values(response)<EOL>return response<EOL>", "docstring": "Add new movies to a list that the user created.\n\nA valid session id is required.\n\nArgs:\n    media_id: A movie id.\n\nReturns:\n    A dict respresentation of the JSON returned from the API.", "id": "f281:c3:m4"}
{"signature": "def rated_movies(self, **kwargs):", "body": "path = self._get_id_path('<STR_LIT>')<EOL>kwargs.update({'<STR_LIT>': self.session_id})<EOL>response = self._GET(path, kwargs)<EOL>self._set_attrs_to_values(response)<EOL>return response<EOL>", "docstring": "Get the list of rated movies (and associated rating) for an account.\n\nArgs:\n    page: (optional) Minimum 1, maximum 1000.\n    sort_by: (optional) 'created_at.asc' | 'created_at.desc'\n    language: (optional) ISO 639-1 code.\n\nReturns:\n    A dict respresentation of the JSON returned from the API.", "id": "f281:c0:m6"}
{"signature": "def lists(self, **kwargs):", "body": "path = self._get_id_path('<STR_LIT>')<EOL>kwargs.update({'<STR_LIT>': self.session_id})<EOL>response = self._GET(path, kwargs)<EOL>self._set_attrs_to_values(response)<EOL>return response<EOL>", "docstring": "Get the lists that you have created and marked as a favorite.\n\nArgs:\n    page: (optional) Minimum 1, maximum 1000.\n    language: (optional) ISO 639-1 code.\n\nReturns:\n    A dict respresentation of the JSON returned from the API.", "id": "f281:c0:m2"}
{"signature": "def info(self, **kwargs):", "body": "path = self._get_id_path('<STR_LIT:info>')<EOL>response = self._GET(path, kwargs)<EOL>self._set_attrs_to_values(response)<EOL>return response<EOL>", "docstring": "Get a list by id.\n\nReturns:\n    A dict respresentation of the JSON returned from the API.", "id": "f281:c3:m1"}
{"signature": "def rated_movies(self, **kwargs):", "body": "path = self._get_guest_session_id_path('<STR_LIT>')<EOL>response = self._GET(path, kwargs)<EOL>self._set_attrs_to_values(response)<EOL>return response<EOL>", "docstring": "Get a list of rated moview for a specific guest session id.\n\nArgs:\n    page: (optional) Minimum 1, maximum 1000.\n    sort_by: (optional) 'created_at.asc' | 'created_at.desc'\n    language: (optional) ISO 639-1 code.\n\nReturns:\n    A dict respresentation of the JSON returned from the API.", "id": "f281:c2:m1"}
{"signature": "def movie(self, **kwargs):", "body": "path = self._get_path('<STR_LIT>')<EOL>response = self._GET(path, kwargs)<EOL>self._set_attrs_to_values(response)<EOL>return response<EOL>", "docstring": "Get a list of movie ids that have been edited.\n\nArgs:\n    page: (optional) Minimum 1, maximum 1000.\n    start_date: (optional) Expected format is 'YYYY-MM-DD'.\n    end_date: (optional) Expected format is 'YYYY-MM-DD'.\n\nReturns:\n    A dict respresentation of the JSON returned from the API.", "id": "f282:c0:m0"}
{"signature": "def send_json(self, ids=None):", "body": "items = ids or self._registration_id<EOL>values = {\"<STR_LIT>\": items}<EOL>if self._data is not None:<EOL><INDENT>values[\"<STR_LIT:data>\"] = self._data<EOL><DEDENT>for key, val in self._kwargs.items():<EOL><INDENT>if val:<EOL><INDENT>values[key] = val<EOL><DEDENT><DEDENT>data = json.dumps(values, separators=(\"<STR_LIT:U+002C>\", \"<STR_LIT::>\"), sort_keys=True).encode(<EOL>self.encoding)<EOL>result = json.loads(self._send(data, \"<STR_LIT:application/json>\"))<EOL>if (\"<STR_LIT>\" in result) and (result[\"<STR_LIT>\"]):<EOL><INDENT>unregistered = []<EOL>throw_error = False<EOL>for index, error in enumerate(result.get(\"<STR_LIT>\", [])):<EOL><INDENT>error = error.get(\"<STR_LIT:error>\", \"<STR_LIT>\")<EOL>if error in (\"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>unregistered.append(items[index])<EOL><DEDENT>elif error != \"<STR_LIT>\":<EOL><INDENT>throw_error = True<EOL><DEDENT><DEDENT>self.deactivate_unregistered_devices(unregistered)<EOL>if throw_error:<EOL><INDENT>raise GCMPushError(result)<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Sends a json GCM message", "id": "f293:c0:m4"}
{"signature": "def update_widget_data(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Implement this in your widget in order to update the widget's data.\n\nThis is the place where you would call some third party API, retrieve\nsome data and save it into your widget's model.", "id": "f307:c0:m9"}
{"signature": "def save_setting(self, setting_name, value):", "body": "setting = self.get_setting(setting_name)<EOL>if setting is None:<EOL><INDENT>setting = models.DashboardWidgetSettings.objects.create(<EOL>widget_name=self.get_name(),<EOL>setting_name=setting_name,<EOL>value=value)<EOL><DEDENT>setting.value = value<EOL>setting.save()<EOL>return setting<EOL>", "docstring": "Saves the setting value into the database.", "id": "f307:c0:m6"}
{"signature": "def get_last_update(self):", "body": "instance, created =models.DashboardWidgetLastUpdate.objects.get_or_create(<EOL>widget_name=self.get_name())<EOL>return instance<EOL>", "docstring": "Gets or creates the last update object for this widget.", "id": "f307:c0:m2"}
{"signature": "def get_context_data(self):", "body": "return {'<STR_LIT>': True, }<EOL>", "docstring": "Should return a dictionary of template context variables that are\nneeded to render this widget.", "id": "f307:c0:m1"}
{"signature": "def get_name(self):", "body": "if hasattr(self, '<STR_LIT>'):<EOL><INDENT>return self.widget_name<EOL><DEDENT>return self.__class__.__name__<EOL>", "docstring": "Returns the class name of this widget.\n\nBe careful when overriding this. If ``self.widget_name`` is set, you\nshould always return that in order to allow to register this widget\nclass several times with different names.", "id": "f307:c0:m3"}
{"signature": "def convert_context_to_json(self, context):", "body": "return json.dumps(context)<EOL>", "docstring": "Convert the context dictionary into a JSON object", "id": "f314:c0:m2"}
{"signature": "def render_to_response(self, context):", "body": "return self.get_json_response(self.convert_context_to_json(context))<EOL>", "docstring": "Returns a JSON response containing 'context' as payload", "id": "f314:c0:m0"}
{"signature": "def get_json_response(self, content, **httpresponse_kwargs):", "body": "return http.HttpResponse(content,<EOL>content_type='<STR_LIT:application/json>',<EOL>**httpresponse_kwargs)<EOL>", "docstring": "Construct an `HttpResponse` object.", "id": "f314:c0:m1"}
{"signature": "def permission_required(perm, login_url=None, raise_exception=False):", "body": "def check_perms(user):<EOL><INDENT>if not getattr(settings, '<STR_LIT>',<EOL>app_settings.REQUIRE_LOGIN):<EOL><INDENT>return True<EOL><DEDENT>if user.has_perm(perm):<EOL><INDENT>return True<EOL><DEDENT>if raise_exception:  <EOL><INDENT>raise PermissionDenied<EOL><DEDENT>return False<EOL><DEDENT>return user_passes_test(check_perms, login_url=login_url)<EOL>", "docstring": "Re-implementation of the permission_required decorator, honors settings.\n\nIf ``DASHBOARD_REQUIRE_LOGIN`` is False, this decorator will always return\n``True``, otherwise it will check for the permission as usual.", "id": "f316:m0"}
{"signature": "def unregister_widget(self, widget_cls):", "body": "if widget_cls.__name__ in self.widgets:<EOL><INDENT>del self.widgets[widget_cls().get_name()]<EOL><DEDENT>", "docstring": "Unregisters the given widget.", "id": "f317:c0:m7"}
{"signature": "def set_occupancy_modes(self, index, auto_away=None, follow_me=None):", "body": "body = {<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': self.thermostats[index]['<STR_LIT>']},<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': auto_away,<EOL>'<STR_LIT>': follow_me}}}<EOL>log_msg_action = '<STR_LIT>'<EOL>return self.make_request(body, log_msg_action)<EOL>", "docstring": "Enable/disable Smart Home/Away and Follow Me modes\n        Values: True, False", "id": "f322:c0:m20"}
{"signature": "def send_message(self, index, message=\"<STR_LIT>\"):", "body": "body = {\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": self.thermostats[index]['<STR_LIT>']},<EOL>\"<STR_LIT>\": [{\"<STR_LIT:type>\": \"<STR_LIT>\", \"<STR_LIT>\": {<EOL>\"<STR_LIT:text>\": message[<NUM_LIT:0>:<NUM_LIT>]<EOL>}}]}<EOL>log_msg_action = \"<STR_LIT>\"<EOL>return self.make_request(body, log_msg_action)<EOL>", "docstring": "Send a message to the thermostat", "id": "f322:c0:m17"}
{"signature": "def request_tokens(self):", "body": "url = '<STR_LIT>'<EOL>params = {'<STR_LIT>': '<STR_LIT>', '<STR_LIT:code>': self.authorization_code,<EOL>'<STR_LIT>': self.api_key}<EOL>try:<EOL><INDENT>request = requests.post(url, params=params)<EOL><DEDENT>except RequestException:<EOL><INDENT>logger.warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>return<EOL><DEDENT>if request.status_code == requests.codes.ok:<EOL><INDENT>self.access_token = request.json()['<STR_LIT>']<EOL>self.refresh_token = request.json()['<STR_LIT>']<EOL>self.write_tokens_to_file()<EOL>self.pin = None<EOL><DEDENT>else:<EOL><INDENT>logger.warn('<STR_LIT>'<EOL>'<STR_LIT>' + str(request.status_code))<EOL>return<EOL><DEDENT>", "docstring": "Method to request API tokens from ecobee", "id": "f322:c0:m2"}
{"signature": "def set_dst_mode(self, index, dst):", "body": "body = {<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': self.thermostats[index]['<STR_LIT>']},<EOL>'<STR_LIT>': {<EOL>'<STR_LIT:location>': {<EOL>'<STR_LIT>': dst}}}<EOL>log_msg_action = '<STR_LIT>'<EOL>return self.make_request(body, log_msg_action)<EOL>", "docstring": "Enable/disable daylight savings\n        Values: True, False", "id": "f322:c0:m21"}
{"signature": "def set_humidity(self, index, humidity):", "body": "body = {\"<STR_LIT>\": {\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": self.thermostats[index]['<STR_LIT>']},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": int(humidity)<EOL>}<EOL>}}<EOL>log_msg_action = \"<STR_LIT>\"<EOL>return self.make_request(body, log_msg_action)<EOL>", "docstring": "Set humidity level", "id": "f322:c0:m18"}
{"signature": "def delete_vacation(self, index, vacation):", "body": "body = {\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": self.thermostats[index]['<STR_LIT>']},<EOL>\"<STR_LIT>\": [{\"<STR_LIT:type>\": \"<STR_LIT>\", \"<STR_LIT>\": {<EOL>\"<STR_LIT:name>\": vacation<EOL>}}]}<EOL>log_msg_action = \"<STR_LIT>\"<EOL>return self.make_request(body, log_msg_action)<EOL>", "docstring": "Delete the vacation with name vacation", "id": "f322:c0:m15"}
{"signature": "def get_fake_model(fields=None, model_base=PostgresModel, meta_options={}):", "body": "model = define_fake_model(fields, model_base, meta_options)<EOL>class TestProject:<EOL><INDENT>def clone(self, *_args, **_kwargs):<EOL><INDENT>return self<EOL><DEDENT>@property<EOL>def apps(self):<EOL><INDENT>return self<EOL><DEDENT><DEDENT>class TestMigration(migrations.Migration):<EOL><INDENT>operations = [HStoreExtension()]<EOL><DEDENT>with connection.schema_editor() as schema_editor:<EOL><INDENT>migration_executor = MigrationExecutor(schema_editor.connection)<EOL>migration_executor.apply_migration(<EOL>TestProject(), TestMigration('<STR_LIT>', '<STR_LIT>'))<EOL>schema_editor.create_model(model)<EOL><DEDENT>return model<EOL>", "docstring": "Creates a fake model to use during unit tests.", "id": "f325:m1"}
{"signature": "@contextmanager<EOL>def add_field(field, filters: List[str]):", "body": "model = define_fake_model()<EOL>project = migrations.state.ProjectState.from_apps(apps)<EOL>with connection.schema_editor() as schema_editor:<EOL><INDENT>execute_migration(schema_editor, [<EOL>migrations.CreateModel(<EOL>model.__name__,<EOL>fields=[]<EOL>)<EOL>], project)<EOL><DEDENT>with filtered_schema_editor(*filters) as (schema_editor, calls):<EOL><INDENT>execute_migration(schema_editor, [<EOL>migrations.AddField(<EOL>model.__name__,<EOL>'<STR_LIT:title>',<EOL>field<EOL>)<EOL>], project)<EOL><DEDENT>yield calls<EOL>", "docstring": "Adds the specified field to a model.\n\n    Arguments:\n        field:\n            The field to add to a model.\n\n        filters:\n            List of strings to filter\n            SQL statements on.", "id": "f338:m4"}
{"signature": "@contextmanager<EOL>def create_drop_model(field, filters: List[str]):", "body": "model = define_fake_model({'<STR_LIT:title>': field})<EOL>with filtered_schema_editor(*filters) as (schema_editor, calls):<EOL><INDENT>execute_migration(schema_editor, [<EOL>migrations.CreateModel(<EOL>model.__name__,<EOL>fields=[<EOL>('<STR_LIT:title>', field.clone())<EOL>]<EOL>),<EOL>migrations.DeleteModel(<EOL>model.__name__,<EOL>)<EOL>])<EOL><DEDENT>yield calls<EOL>", "docstring": "Creates and drops a model with the specified field.\n\n    Arguments:\n        field:\n            The field to include on the\n            model to create and drop.\n\n        filters:\n            List of strings to filter\n            SQL statements on.", "id": "f338:m2"}
{"signature": "@contextmanager<EOL>def alter_field(old_field, new_field, filters: List[str]):", "body": "model = define_fake_model({'<STR_LIT:title>': old_field})<EOL>project = migrations.state.ProjectState.from_apps(apps)<EOL>with connection.schema_editor() as schema_editor:<EOL><INDENT>execute_migration(schema_editor, [<EOL>migrations.CreateModel(<EOL>model.__name__,<EOL>fields=[<EOL>('<STR_LIT:title>', old_field.clone())<EOL>]<EOL>)<EOL>], project)<EOL><DEDENT>with filtered_schema_editor(*filters) as (schema_editor, calls):<EOL><INDENT>execute_migration(schema_editor, [<EOL>migrations.AlterField(<EOL>model.__name__,<EOL>'<STR_LIT:title>',<EOL>new_field<EOL>)<EOL>], project)<EOL><DEDENT>yield calls<EOL>", "docstring": "Alters a field from one state to the other.\n\n    Arguments:\n        old_field:\n            The field before altering it.\n\n        new_field:\n            The field after altering it.\n\n        filters:\n            List of strings to filter\n            SQL statements on.", "id": "f338:m6"}
{"signature": "def _form_returning(self):", "body": "qn = self.connection.ops.quote_name<EOL>return '<STR_LIT>' % qn(self.query.model._meta.pk.attname)<EOL>", "docstring": "Builds the RETURNING part of the query.", "id": "f347:c0:m3"}
{"signature": "def _rewrite_insert(self, sql, params, return_id=False):", "body": "returning = self.qn(self.query.model._meta.pk.attname) if return_id else '<STR_LIT:*>'<EOL>if self.query.conflict_action.value == '<STR_LIT>':<EOL><INDENT>return self._rewrite_insert_update(sql, params, returning)<EOL><DEDENT>elif self.query.conflict_action.value == '<STR_LIT>':<EOL><INDENT>return self._rewrite_insert_nothing(sql, params, returning)<EOL><DEDENT>raise SuspiciousOperation((<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>) % str(self.query.conflict_action))<EOL>", "docstring": "Rewrites a formed SQL INSERT query to include\n        the ON CONFLICT clause.\n\n        Arguments:\n            sql:\n                The SQL INSERT query to rewrite.\n\n            params:\n                The parameters passed to the query.\n\n            returning:\n                What to put in the `RETURNING` clause\n                of the resulting query.\n\n        Returns:\n            A tuple of the rewritten SQL query and new params.", "id": "f347:c1:m3"}
{"signature": "def _get_model_field(self, name: str):", "body": "field_name = self._normalize_field_name(name)<EOL>if field_name == '<STR_LIT>' and self.query.model._meta.pk:<EOL><INDENT>return self.query.model._meta.pk<EOL><DEDENT>for field in self.query.model._meta.local_concrete_fields:<EOL><INDENT>if field.name == field_name or field.column == field_name:<EOL><INDENT>return field<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Gets the field on a model with the specified name.\n\n        Arguments:\n            name:\n                The name of the field to look for.\n\n                This can be both the actual field name, or\n                the name of the column, both will work :)\n\n        Returns:\n            The field with the specified name or None if\n            no such field exists.", "id": "f347:c1:m7"}
{"signature": "def __init__(self, value):", "body": "self.value = value<EOL>", "docstring": "Initializes a new instance.", "id": "f349:c0:m0"}
{"signature": "def __init__(self, name: str, key: str):", "body": "super().__init__(name)<EOL>self.key = key<EOL>", "docstring": "Initializes a new instance of :see:HStoreRef.\n\n        Arguments:\n            name:\n                The name of the column/field to resolve.\n\n            key:\n                The name of the HStore key to select.", "id": "f349:c2:m0"}
{"signature": "def resolve_expression(self, *args, **kwargs):", "body": "result = dict()<EOL>for key, value in self.value.items():<EOL><INDENT>if hasattr(value, '<STR_LIT>'):<EOL><INDENT>result[key] = value.resolve_expression(<EOL>*args, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>result[key] = value<EOL><DEDENT><DEDENT>return HStoreValue(result)<EOL>", "docstring": "Resolves expressions inside the dictionary.", "id": "f349:c0:m1"}
{"signature": "def __init__(self, alias, target, hstore_key):", "body": "super().__init__(alias, target, output_field=target)<EOL>self.alias, self.target, self.hstore_key = alias, target, hstore_key<EOL>", "docstring": "Initializes a new instance of :see:HStoreColumn.\n\n        Arguments:\n            alias:\n                The table name.\n\n            target:\n                The field instance.\n\n            hstore_key\n                The name of the hstore key to include\n                in the epxression.", "id": "f349:c1:m0"}
{"signature": "def __repr__(self):", "body": "return \"<STR_LIT>\".format(<EOL>self.__class__.__name__,<EOL>self.alias,<EOL>self.target,<EOL>self.hstore_key<EOL>)<EOL>", "docstring": "Gets a textual representation of this expresion.", "id": "f349:c1:m1"}
{"signature": "def insert(self, **fields):", "body": "if self.conflict_target or self.conflict_action:<EOL><INDENT>compiler = self._build_insert_compiler([fields])<EOL>rows = compiler.execute_sql(return_id=True)<EOL>pk_field_name = self.model._meta.pk.name<EOL>return rows[<NUM_LIT:0>][pk_field_name]<EOL><DEDENT>return super().create(**fields).pk<EOL>", "docstring": "Creates a new record in the database.\n\n        This allows specifying custom conflict behavior using .on_conflict().\n        If no special behavior was specified, this uses the normal Django create(..)\n\n        Arguments:\n            fields:\n                The fields of the row to create.\n\n        Returns:\n            The primary key of the record that was created.", "id": "f353:c0:m7"}
{"signature": "def join(self, **conditions):", "body": "self.query.add_join_conditions(conditions)<EOL>return self<EOL>", "docstring": "Adds extra conditions to existing joins.\n\n        WARNING: This is an extremely experimental feature.\n                 DO NOT USE unless you know what you're doing.", "id": "f353:c0:m3"}
{"signature": "def upsert(self, conflict_target: List, fields: Dict, index_predicate: str=None) -> int:", "body": "return self.get_queryset().upsert(conflict_target, fields, index_predicate)<EOL>", "docstring": "Creates a new record or updates the existing one\n        with the specified data.\n\n        Arguments:\n            conflict_target:\n                Fields to pass into the ON CONFLICT clause.\n\n            fields:\n                Fields to insert/update.\n\n            index_predicate:\n                The index predicate to satisfy an arbiter partial index.\n\n        Returns:\n            The primary key of the row that was created/updated.", "id": "f353:c1:m4"}
{"signature": "def bulk_upsert(self, conflict_target: List, rows: List[Dict], index_predicate: str=None):", "body": "return self.get_queryset().bulk_upsert(conflict_target, rows, index_predicate)<EOL>", "docstring": "Creates a set of new records or updates the existing\n        ones with the specified data.\n\n        Arguments:\n            conflict_target:\n                Fields to pass into the ON CONFLICT clause.\n\n            index_predicate:\n                The index predicate to satisfy an arbiter partial index.\n\n            rows:\n                Rows to upsert.", "id": "f353:c1:m6"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(PostgresManager, self).__init__(*args, **kwargs)<EOL>db_backend = settings.DATABASES['<STR_LIT:default>']['<STR_LIT>']<EOL>if '<STR_LIT>' not in db_backend:<EOL><INDENT>raise ImproperlyConfigured((<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>) % db_backend)<EOL><DEDENT>django.db.models.signals.post_save.connect(<EOL>self._on_model_save, sender=self.model, weak=False)<EOL>django.db.models.signals.pre_delete.connect(<EOL>self._on_model_delete, sender=self.model, weak=False)<EOL>self._signals_connected = True<EOL>", "docstring": "Initializes a new instance of :see:PostgresManager.", "id": "f353:c1:m0"}
{"signature": "def upsert(self, conflict_target: List, fields: Dict, index_predicate: str=None) -> int:", "body": "self.on_conflict(conflict_target, ConflictAction.UPDATE, index_predicate)<EOL>return self.insert(**fields)<EOL>", "docstring": "Creates a new record or updates the existing one\n        with the specified data.\n\n        Arguments:\n            conflict_target:\n                Fields to pass into the ON CONFLICT clause.\n\n            fields:\n                Fields to insert/update.\n\n            index_predicate:\n                The index predicate to satisfy an arbiter partial index (i.e. what partial index to use for checking\n                conflicts)\n\n        Returns:\n            The primary key of the row that was created/updated.", "id": "f353:c0:m9"}
{"signature": "def on_conflict(self, fields: List[Union[str, Tuple[str]]], action, index_predicate: str=None):", "body": "return self.get_queryset().on_conflict(fields, action, index_predicate)<EOL>", "docstring": "Sets the action to take when conflicts arise when attempting\n        to insert/create a new row.\n\n        Arguments:\n            fields:\n                The fields the conflicts can occur in.\n\n            action:\n                The action to take when the conflict occurs.\n\n            index_predicate:\n                The index predicate to satisfy an arbiter partial index.", "id": "f353:c1:m3"}
{"signature": "def upsert_and_get(self, conflict_target: List, fields: Dict, index_predicate: str=None):", "body": "self.on_conflict(conflict_target, ConflictAction.UPDATE, index_predicate)<EOL>return self.insert_and_get(**fields)<EOL>", "docstring": "Creates a new record or updates the existing one\n        with the specified data and then gets the row.\n\n        Arguments:\n            conflict_target:\n                Fields to pass into the ON CONFLICT clause.\n\n            fields:\n                Fields to insert/update.\n\n            index_predicate:\n                The index predicate to satisfy an arbiter partial index (i.e. what partial index to use for checking\n                conflicts)\n\n        Returns:\n            The model instance representing the row\n            that was created/updated.", "id": "f353:c0:m10"}
{"signature": "def insert_and_get(self, **fields):", "body": "if not self.conflict_target and not self.conflict_action:<EOL><INDENT>return super().create(**fields)<EOL><DEDENT>compiler = self._build_insert_compiler([fields])<EOL>rows = compiler.execute_sql(return_id=False)<EOL>columns = rows[<NUM_LIT:0>]<EOL>model_columns = {}<EOL>for field in self.model._meta.local_concrete_fields:<EOL><INDENT>model_columns[field.column] = field.attname<EOL><DEDENT>model_init_fields = {}<EOL>for column_name, column_value in columns.items():<EOL><INDENT>try:<EOL><INDENT>model_init_fields[model_columns[column_name]] = column_value<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return self.model(**model_init_fields)<EOL>", "docstring": "Creates a new record in the database and then gets\n        the entire row.\n\n        This allows specifying custom conflict behavior using .on_conflict().\n        If no special behavior was specified, this uses the normal Django create(..)\n\n        Arguments:\n            fields:\n                The fields of the row to create.\n\n        Returns:\n            The model instance representing the row that was created.", "id": "f353:c0:m8"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super().__init__(*args, **kwargs)<EOL>self.join_type = '<STR_LIT>'<EOL>self.extra_conditions = []<EOL>", "docstring": "Initializes a new instance of :see:ConditionalJoin.", "id": "f356:c0:m0"}
{"signature": "def __init__(self, condition: str, fields=[], name=None):", "body": "super().__init__(fields=fields, name=name)<EOL>self.condition = condition<EOL>", "docstring": "Initializes a new instance of :see:ConditionalUniqueIndex.", "id": "f359:c0:m0"}
{"signature": "def delete_model(self, model):", "body": "for field in model._meta.local_fields:<EOL><INDENT>if not isinstance(field, HStoreField):<EOL><INDENT>continue<EOL><DEDENT>self.remove_field(model, field)<EOL><DEDENT>", "docstring": "Ran when a model is being deleted.", "id": "f361:c0:m1"}
{"signature": "def alter_db_table(self, model, old_db_table, new_db_table):", "body": "for field in model._meta.local_fields:<EOL><INDENT>if not isinstance(field, HStoreField):<EOL><INDENT>continue<EOL><DEDENT>for key in self._iterate_required_keys(field):<EOL><INDENT>self._rename_hstore_required(<EOL>old_db_table,<EOL>new_db_table,<EOL>field,<EOL>field,<EOL>key<EOL>)<EOL><DEDENT><DEDENT>", "docstring": "Ran when the name of a model is changed.", "id": "f361:c0:m2"}
{"signature": "def alter_field(self, model, old_field, new_field, strict=False):", "body": "is_old_field_hstore = isinstance(old_field, HStoreField)<EOL>is_new_field_hstore = isinstance(new_field, HStoreField)<EOL>if not is_old_field_hstore and not is_new_field_hstore:<EOL><INDENT>return<EOL><DEDENT>old_uniqueness = getattr(old_field, '<STR_LIT>', []) or []<EOL>new_uniqueness = getattr(new_field, '<STR_LIT>', []) or []<EOL>if str(old_field.column) != str(new_field.column):<EOL><INDENT>for keys in self._iterate_uniqueness_keys(old_field):<EOL><INDENT>self._rename_hstore_unique(<EOL>model._meta.db_table,<EOL>model._meta.db_table,<EOL>old_field,<EOL>new_field,<EOL>keys<EOL>)<EOL><DEDENT><DEDENT>for keys in old_uniqueness:<EOL><INDENT>if keys not in new_uniqueness:<EOL><INDENT>self._drop_hstore_unique(<EOL>model,<EOL>old_field,<EOL>self._compose_keys(keys)<EOL>)<EOL><DEDENT><DEDENT>for keys in new_uniqueness:<EOL><INDENT>if keys not in old_uniqueness:<EOL><INDENT>self._create_hstore_unique(<EOL>model,<EOL>new_field,<EOL>self._compose_keys(keys)<EOL>)<EOL><DEDENT><DEDENT>", "docstring": "Ran when the configuration on a field changed.", "id": "f362:c0:m5"}
{"signature": "def alter_db_table(self, model, old_db_table, new_db_table):", "body": "for field in model._meta.local_fields:<EOL><INDENT>if not isinstance(field, HStoreField):<EOL><INDENT>continue<EOL><DEDENT>for keys in self._iterate_uniqueness_keys(field):<EOL><INDENT>self._rename_hstore_unique(<EOL>old_db_table,<EOL>new_db_table,<EOL>field,<EOL>field,<EOL>keys<EOL>)<EOL><DEDENT><DEDENT>", "docstring": "Ran when the name of a model is changed.", "id": "f362:c0:m2"}
{"signature": "def remove_field(self, model, field):", "body": "for keys in self._iterate_uniqueness_keys(field):<EOL><INDENT>self._drop_hstore_unique(<EOL>model,<EOL>field,<EOL>keys<EOL>)<EOL><DEDENT>", "docstring": "Ran when a field is removed from a model.", "id": "f362:c0:m4"}
{"signature": "@staticmethod<EOL><INDENT>def _unique_constraint_name(table: str, field, keys):<DEDENT>", "body": "postfix = '<STR_LIT:_>'.join(keys)<EOL>return '<STR_LIT>'.format(<EOL>table=table,<EOL>field=field.column,<EOL>postfix=postfix<EOL>)<EOL>", "docstring": "Gets the name for a UNIQUE INDEX that applies\n        to one or more keys in a hstore field.\n\n        Arguments:\n            table:\n                The name of the table the field is\n                a part of.\n\n            field:\n                The hstore field to create a\n                UNIQUE INDEX for.\n\n            key:\n                The name of the hstore key\n                to create the name for.\n\n                This can also be a tuple\n                of multiple names.\n\n        Returns:\n            The name for the UNIQUE index.", "id": "f362:c0:m9"}
{"signature": "def alter_db_table(self, model, old_db_table, new_db_table):", "body": "super(SchemaEditor, self).alter_db_table(<EOL>model, old_db_table, new_db_table<EOL>)<EOL>for mixin in self.post_processing_mixins:<EOL><INDENT>mixin.alter_db_table(<EOL>model,<EOL>old_db_table,<EOL>new_db_table<EOL>)<EOL><DEDENT>", "docstring": "Ran when the name of a model is changed.", "id": "f363:c0:m3"}
{"signature": "def add_field(self, model, field):", "body": "super(SchemaEditor, self).add_field(model, field)<EOL>for mixin in self.post_processing_mixins:<EOL><INDENT>mixin.add_field(model, field)<EOL><DEDENT>", "docstring": "Ran when a field is added to a model.", "id": "f363:c0:m4"}
{"signature": "def create_model(self, model):", "body": "super().create_model(model)<EOL>for mixin in self.post_processing_mixins:<EOL><INDENT>mixin.create_model(model)<EOL><DEDENT>", "docstring": "Ran when a new model is created.", "id": "f363:c0:m1"}
{"signature": "def alter_field(self, model, old_field, new_field, strict=False):", "body": "super(SchemaEditor, self).alter_field(<EOL>model, old_field, new_field, strict<EOL>)<EOL>for mixin in self.post_processing_mixins:<EOL><INDENT>mixin.alter_field(<EOL>model, old_field, new_field, strict<EOL>)<EOL><DEDENT>", "docstring": "Ran when the configuration on a field changed.", "id": "f363:c0:m6"}
{"signature": "def remove_field(self, model, field):", "body": "for mixin in self.post_processing_mixins:<EOL><INDENT>mixin.remove_field(model, field)<EOL><DEDENT>super(SchemaEditor, self).remove_field(model, field)<EOL>", "docstring": "Ran when a field is removed from a model.", "id": "f363:c0:m5"}
{"signature": "def _get_schema_editor_base():", "body": "return _get_backend_base().SchemaEditorClass<EOL>", "docstring": "Gets the base class for the schema editor.\n\n    We have to use the configured base back-end's\n    schema editor for this.", "id": "f363:m1"}
{"signature": "def unescape(value):", "body": "pattern = ESCAPE_FMT.replace('<STR_LIT>', '<STR_LIT>')<EOL>pattern_bytes = pattern.encode('<STR_LIT:ascii>')<EOL>re_esc = re.compile(pattern_bytes)<EOL>return re_esc.sub(_unescape_code, value.encode('<STR_LIT:ascii>')).decode('<STR_LIT:utf-8>')<EOL>", "docstring": "Inverse of escape.", "id": "f383:m3"}
{"signature": "def get_password(self, service, username):", "body": "assoc = self._generate_assoc(service, username)<EOL>service = escape_for_ini(service)<EOL>username = escape_for_ini(username)<EOL>config = configparser.RawConfigParser()<EOL>if os.path.exists(self.file_path):<EOL><INDENT>config.read(self.file_path)<EOL><DEDENT>try:<EOL><INDENT>password_base64 = config.get(service, username).encode()<EOL>password_encrypted = decodebytes(password_base64)<EOL>try:<EOL><INDENT>password = self.decrypt(password_encrypted, assoc).decode('<STR_LIT:utf-8>')<EOL><DEDENT>except ValueError:<EOL><INDENT>password = self.decrypt(password_encrypted).decode('<STR_LIT:utf-8>')<EOL><DEDENT><DEDENT>except (configparser.NoOptionError, configparser.NoSectionError):<EOL><INDENT>password = None<EOL><DEDENT>return password<EOL>", "docstring": "Read the password from the file.", "id": "f384:c1:m2"}
{"signature": "@properties.NonDataProperty<EOL><INDENT>def file_version(self):<DEDENT>", "body": "return None<EOL>", "docstring": "The encryption version used in file to store the passwords.", "id": "f384:c0:m4"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def encrypt(self, password, assoc = None):<DEDENT>", "body": "", "docstring": "Given a password (byte string) and assoc (byte string, optional),\nreturn an encrypted byte string.\n\nassoc provides associated data (typically: service and username)", "id": "f384:c1:m0"}
{"signature": "@abc.abstractproperty<EOL><INDENT>def scheme(self):<DEDENT>", "body": "return '<STR_LIT>'<EOL>", "docstring": "The encryption scheme used to store the passwords.", "id": "f384:c0:m2"}
{"signature": "@abc.abstractproperty<EOL><INDENT>def version(self):<DEDENT>", "body": "return None<EOL>", "docstring": "The encryption version used to store the passwords.", "id": "f384:c0:m3"}
{"signature": "def _check_version(self, config):", "body": "try:<EOL><INDENT>self.file_version = config.get(<EOL>escape_for_ini('<STR_LIT>'),<EOL>escape_for_ini('<STR_LIT:version>'),<EOL>)<EOL><DEDENT>except (configparser.NoSectionError, configparser.NoOptionError):<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "check for a valid version\nan existing scheme implies an existing version as well\n\nreturn True, if version is valid, and False otherwise", "id": "f386:c1:m4"}
{"signature": "@properties.ClassProperty<EOL><INDENT>@classmethod<EOL>def priority(self):<DEDENT>", "body": "try:<EOL><INDENT>__import__('<STR_LIT>')<EOL><DEDENT>except ImportError:     <EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>try:<EOL><INDENT>__import__('<STR_LIT>')<EOL><DEDENT>except ImportError:     <EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>if not json:            <EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>return <NUM_LIT><EOL>", "docstring": "Applicable for all platforms, where the schemes, that are integrated\nwith your environment, does not fit.", "id": "f386:c1:m0"}
{"signature": "def _check_scheme(self, config):", "body": "try:<EOL><INDENT>scheme = config.get(<EOL>escape_for_ini('<STR_LIT>'),<EOL>escape_for_ini('<STR_LIT>'),<EOL>)<EOL><DEDENT>except (configparser.NoSectionError, configparser.NoOptionError):<EOL><INDENT>raise AttributeError(\"<STR_LIT>\")<EOL><DEDENT>if scheme.startswith('<STR_LIT>'):<EOL><INDENT>scheme = scheme[<NUM_LIT:9>:]<EOL><DEDENT>if scheme != self.scheme:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (self.scheme, scheme))<EOL><DEDENT>", "docstring": "check for a valid scheme\n\nraise ValueError otherwise\nraise AttributeError if missing", "id": "f388:c2:m4"}
{"signature": "def _unlock(self):", "body": "self.keyring_key = getpass.getpass(<EOL>'<STR_LIT>')<EOL>try:<EOL><INDENT>ref_pw = self.get_password('<STR_LIT>', '<STR_LIT>')<EOL>assert ref_pw == '<STR_LIT>'<EOL><DEDENT>except AssertionError:<EOL><INDENT>self._lock()<EOL>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Unlock this keyring by getting the password for the keyring from the\nuser.", "id": "f388:c2:m6"}
{"signature": "def _migrate(self, keyring_password=None):", "body": "", "docstring": "Convert older keyrings to the current format.", "id": "f388:c2:m10"}
{"signature": "@staticmethod<EOL><INDENT>def str_to_num(str_value):<DEDENT>", "body": "str_value = str(str_value)<EOL>try:<EOL><INDENT>return int(str_value)<EOL><DEDENT>except ValueError:<EOL><INDENT>return float(str_value)<EOL><DEDENT>", "docstring": "Convert str_value to an int or a float, depending on the\n        numeric value represented by str_value.", "id": "f390:c4:m3"}
{"signature": "@staticmethod<EOL><INDENT>def is_convertible(value):<DEDENT>", "body": "try:<EOL><INDENT>float(value)<EOL>return True<EOL><DEDENT>except ValueError:<EOL><INDENT>return False<EOL><DEDENT>except TypeError:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Return True if value can be converted to a float.", "id": "f390:c4:m2"}
{"signature": "def set_assert(self, obj, val, attr=\"<STR_LIT:f>\"):", "body": "setattr(obj, attr, val)<EOL>self.assertEqual(getattr(obj, attr), val)<EOL>", "docstring": "Assert a valid assignment works.", "id": "f391:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def exc_thrown_by_descriptor():<DEDENT>", "body": "traceback = sys.exc_info()[<NUM_LIT:2>]<EOL>tb_locals = traceback.tb_frame.f_locals<EOL>if \"<STR_LIT>\" in tb_locals:<EOL><INDENT>if not isinstance(tb_locals[\"<STR_LIT>\"], Descriptor):<EOL><INDENT>return False<EOL><DEDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Return True if the last exception was thrown by a\n        Descriptor instance.", "id": "f400:c1:m10"}
{"signature": "def _infer_length(iterable):", "body": "try:<EOL><INDENT>return len(iterable)<EOL><DEDENT>except (AttributeError, TypeError):  <EOL><INDENT>try:<EOL><INDENT>get_hint = type(iterable).__length_hint__<EOL><DEDENT>except AttributeError:<EOL><INDENT>return None<EOL><DEDENT>try:<EOL><INDENT>hint = get_hint(iterable)<EOL><DEDENT>except TypeError:<EOL><INDENT>return None<EOL><DEDENT>if (hint is NotImplemented or<EOL>not isinstance(hint, int) or<EOL>hint < <NUM_LIT:0>):<EOL><INDENT>return None<EOL><DEDENT>return hint<EOL><DEDENT>", "docstring": "Try and infer the length using the PEP 424 length hint if available.\n\nadapted from click implementation", "id": "f404:m0"}
{"signature": "@classmethod<EOL><INDENT>def set_lock(cls, lock):<DEDENT>", "body": "pass<EOL>", "docstring": "tqdm api compatibility. does nothing", "id": "f404:c0:m10"}
{"signature": "def _update_measurements(self):", "body": "self._last_idx = self._now_idx<EOL>self._last_time  = self._now_time<EOL>self._now_idx = self._iter_idx<EOL>self._now_time = default_timer()<EOL>self._between_time = self._now_time - self._last_time<EOL>self._between_count = self._now_idx - self._last_idx<EOL>self._total_seconds = self._now_time - self._start_time<EOL>", "docstring": "update current measurements and estimated of time and progress", "id": "f404:c2:m12"}
{"signature": "def refresh(self, nolock=False):", "body": "if not self.started:<EOL><INDENT>self.begin()<EOL><DEDENT>self.display_message()<EOL>", "docstring": "tqdm api compatibility. redisplays message\n(can cause a message to print twice)", "id": "f404:c0:m8"}
{"signature": "def set_description(self, desc=None, refresh=True):", "body": "self.desc = desc<EOL>if refresh:<EOL><INDENT>self.refresh()<EOL><DEDENT>", "docstring": "tqdm api compatibility. Changes the description of progress", "id": "f404:c0:m1"}
{"signature": "def clear(self, nolock=False):", "body": "pass<EOL>", "docstring": "tqdm api compatibility. does nothing", "id": "f404:c0:m7"}
{"signature": "@classmethod<EOL><INDENT>def write(cls, s, file=None, end='<STR_LIT:\\n>', nolock=False):<DEDENT>", "body": "fp = file if file is not None else sys.stdout<EOL>fp.write(s)<EOL>fp.write(end)<EOL>", "docstring": "simply writes to stdout", "id": "f404:c0:m0"}
{"signature": "def set_extra(self, extra):", "body": "self.extra = extra<EOL>", "docstring": "specify a custom info appended to the end of the next message\n\nTODO:\n    - [ ] extra is a bad name; come up with something better and rename\n\nExample:\n    >>> import progiter\n    >>> prog = progiter.ProgIter(range(100, 300, 100), show_times=False, verbose=3)\n    >>> for n in prog:\n    >>>     prog.set_extra('processesing num {}'.format(n))\n    0/2...\n    1/2...processesing num 100\n    2/2...processesing num 200", "id": "f404:c2:m5"}
{"signature": "def __init__(self, iterable=None, desc=None, total=None, freq=<NUM_LIT:1>,<EOL>initial=<NUM_LIT:0>, eta_window=<NUM_LIT:64>, clearline=True, adjust=True,<EOL>time_thresh=<NUM_LIT>, show_times=True, enabled=True, verbose=None,<EOL>stream=None, chunksize=None, **kwargs):", "body": "if desc is None:<EOL><INDENT>desc = '<STR_LIT>'<EOL><DEDENT>if verbose is not None:<EOL><INDENT>if verbose <= <NUM_LIT:0>:  <EOL><INDENT>enabled = False<EOL><DEDENT>elif verbose == <NUM_LIT:1>:  <EOL><INDENT>enabled, clearline, adjust = <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1><EOL><DEDENT>elif verbose == <NUM_LIT:2>:  <EOL><INDENT>enabled, clearline, adjust = <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:1><EOL><DEDENT>elif verbose >= <NUM_LIT:3>:  <EOL><INDENT>enabled, clearline, adjust = <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0><EOL><DEDENT><DEDENT>self._microseconds = kwargs.pop('<STR_LIT>', False)<EOL>if kwargs:<EOL><INDENT>stream = kwargs.pop('<STR_LIT:file>', stream)<EOL>enabled = not kwargs.pop('<STR_LIT>', not enabled)<EOL>if kwargs.get('<STR_LIT>', None) is not None:<EOL><INDENT>adjust = False<EOL><DEDENT>freq = kwargs.pop('<STR_LIT>', freq)<EOL>kwargs.pop('<STR_LIT>', None)  <EOL>kwargs.pop('<STR_LIT>', None)  <EOL>kwargs.pop('<STR_LIT>', True)  <EOL>desc = kwargs.pop('<STR_LIT:label>', desc)<EOL>total = kwargs.pop('<STR_LIT>', total)<EOL>enabled = kwargs.pop('<STR_LIT>', enabled)<EOL>initial = kwargs.pop('<STR_LIT:start>', initial)<EOL><DEDENT>if kwargs:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(kwargs))<EOL><DEDENT>if stream is None:<EOL><INDENT>stream = sys.stdout<EOL><DEDENT>self.stream = stream<EOL>self.iterable = iterable<EOL>self.desc = desc<EOL>self.total = total<EOL>self.freq = freq<EOL>self.initial = initial<EOL>self.enabled = enabled<EOL>self.adjust = adjust<EOL>self.show_times = show_times<EOL>self.eta_window = eta_window<EOL>self.time_thresh = <NUM_LIT:1.0><EOL>self.clearline = clearline<EOL>self.chunksize = chunksize<EOL>self.extra = '<STR_LIT>'<EOL>self.started = False<EOL>self.finished = False<EOL>self._reset_internals()<EOL>", "docstring": "Notes:\n    See attributes for arg information\n    **kwargs accepts most of the tqdm api", "id": "f404:c2:m0"}
{"signature": "def close(self):", "body": "self.end()<EOL>", "docstring": "alias of `end` for tqdm compatibility", "id": "f404:c0:m4"}
{"signature": "def __enter__(self):", "body": "self.begin()<EOL>return self<EOL>", "docstring": "Example:\n    >>> # can be used as a context manager in iter mode\n    >>> n = 3\n    >>> with ProgIter(desc='manual', total=n, verbose=3) as prog:\n    ...     list(prog(range(n)))", "id": "f404:c2:m2"}
{"signature": "def parse_version(package):", "body": "from os.path import dirname, join<EOL>import ast<EOL>init_fpath = join(dirname(__file__), package, '<STR_LIT>')<EOL>with open(init_fpath) as file_:<EOL><INDENT>sourcecode = file_.read()<EOL><DEDENT>pt = ast.parse(sourcecode)<EOL>class VersionVisitor(ast.NodeVisitor):<EOL><INDENT>def visit_Assign(self, node):<EOL><INDENT>for target in node.targets:<EOL><INDENT>if target.id == '<STR_LIT>':<EOL><INDENT>self.version = node.value.s<EOL><DEDENT><DEDENT><DEDENT><DEDENT>visitor = VersionVisitor()<EOL>visitor.visit(pt)<EOL>return visitor.version<EOL>", "docstring": "Statically parse the version number from __init__.py\n\nCommandLine:\n    python -c \"import setup; print(setup.parse_version('progiter'))\"", "id": "f406:m0"}
{"signature": "def _list(api_list_class, arg_namespace, **extra):", "body": "if arg_namespace.starting_point:<EOL><INDENT>ordering_field = (arg_namespace.ordering or '<STR_LIT>').lstrip('<STR_LIT:->')<EOL>if ordering_field in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>arg_namespace.starting_point = parser.parse(<EOL>arg_namespace.starting_point)<EOL><DEDENT><DEDENT>items = api_list_class(<EOL>starting_point=arg_namespace.starting_point,<EOL>ordering=arg_namespace.ordering,<EOL>limit=arg_namespace.limit,<EOL>request_limit=arg_namespace.request_limit,<EOL>**extra<EOL>)<EOL>items.constructor = lambda x: x<EOL>try:<EOL><INDENT>pprint(list(items))<EOL><DEDENT>except ValueError as e:<EOL><INDENT>print(e)<EOL><DEDENT>", "docstring": "A common function for building methods of the \"list showing\".", "id": "f424:m0"}
{"signature": "def is_removed(self):", "body": "return self.info().get('<STR_LIT>') is not None<EOL>", "docstring": "Returns ``True`` if file is removed.\n\n        It might do API request once because it depends on ``info()``.", "id": "f427:c0:m17"}
{"signature": "@classmethod<EOL><INDENT>def upload(cls, file_obj, store=None):<DEDENT>", "body": "if store is None:<EOL><INDENT>store = '<STR_LIT>'<EOL><DEDENT>elif store:<EOL><INDENT>store = '<STR_LIT:1>'<EOL><DEDENT>else:<EOL><INDENT>store = '<STR_LIT:0>'<EOL><DEDENT>data = {<EOL>'<STR_LIT>': store,<EOL>}<EOL>files = uploading_request('<STR_LIT:POST>', '<STR_LIT>', data=data,<EOL>files={'<STR_LIT:file>': file_obj})<EOL>file_ = cls(files['<STR_LIT:file>'])<EOL>return file_<EOL>", "docstring": "Uploads a file and returns ``File`` instance.\n\n        Args:\n            - file_obj: file object to upload to\n            - store (Optional[bool]): Should the file be automatically stored\n                upon upload. Defaults to None.\n                - False - do not store file\n                - True - store file (can result in error if autostore\n                               is disabled for project)\n                - None - use project settings\n\n        Returns:\n            ``File`` instance", "id": "f427:c0:m28"}
{"signature": "@classmethod<EOL><INDENT>def create(cls, files):<DEDENT>", "body": "data = {}<EOL>for index, file_ in enumerate(files):<EOL><INDENT>if isinstance(file_, File):<EOL><INDENT>file_index = '<STR_LIT>'.format(index=index)<EOL>data[file_index] = six.text_type(file_)<EOL><DEDENT>else:<EOL><INDENT>raise InvalidParamError(<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT><DEDENT>if not data:<EOL><INDENT>raise InvalidParamError('<STR_LIT>')<EOL><DEDENT>group_info = uploading_request('<STR_LIT:POST>', '<STR_LIT>', data=data)<EOL>group = cls.construct_from(group_info)<EOL>return group<EOL>", "docstring": "Creates file group and returns ``FileGroup`` instance.\n\n        It expects iterable object that contains ``File`` instances, e.g.::\n\n            >>> file_1 = File('6c5e9526-b0fe-4739-8975-72e8d5ee6342')\n            >>> file_2 = File('a771f854-c2cb-408a-8c36-71af77811f3b')\n            >>> FileGroup.create((file_1, file_2))\n            <uploadcare.FileGroup 0513dda0-6666-447d-846f-096e5df9e2bb~2>", "id": "f427:c1:m16"}
{"signature": "def is_ready(self):", "body": "return self.info().get('<STR_LIT>')<EOL>", "docstring": "Returns ``True`` if the file is fully uploaded on S3.\n\n        It might do API request once because it depends on ``info()``.", "id": "f427:c0:m19"}
{"signature": "def __init__(self, seq):", "body": "if not isinstance(seq, Iterable):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>self._seq = seq<EOL>", "docstring": "Seq can be:\n        * list of UUIDs\n        * list of File's instances\n        * instance of FileList", "id": "f427:c4:m0"}
{"signature": "def uuids(self):", "body": "for f in self._seq:<EOL><INDENT>if isinstance(f, File):<EOL><INDENT>yield f.uuid<EOL><DEDENT>elif isinstance(f, six.string_types):<EOL><INDENT>yield f<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'.format(type(f)))<EOL><DEDENT><DEDENT>", "docstring": "Extract uuid from each item of specified ``seq``.", "id": "f427:c4:m4"}
{"signature": "@property<EOL><INDENT>def cdn_url(self):<DEDENT>", "body": "return '<STR_LIT>'.format(<EOL>cdn_base=conf.cdn_base,<EOL>group_id=self.id<EOL>)<EOL>", "docstring": "Returns group's CDN url.\n\n        Usage example::\n\n            >>> file_group = FileGroup('0513dda0-582f-447d-846f-096e5df9e2bb~2')\n            >>> file_group.cdn_url\n            https://ucarecdn.com/0513dda0-582f-447d-846f-096e5df9e2bb~2/", "id": "f427:c1:m7"}
{"signature": "@classmethod<EOL><INDENT>def construct_from(cls, file_info):<DEDENT>", "body": "file_ = cls(file_info['<STR_LIT>'])<EOL>file_.default_effects = file_info.get('<STR_LIT>')<EOL>file_._info_cache = file_info<EOL>return file_<EOL>", "docstring": "Constructs ``File`` instance from file information.\n\n        For example you have result of\n        ``/files/1921953c-5d94-4e47-ba36-c2e1dd165e1a/`` API request::\n\n            >>> file_info = {\n                    # ...\n                    'uuid': '1921953c-5d94-4e47-ba36-c2e1dd165e1a',\n                    # ...\n                }\n            >>> File.construct_from(file_info)\n            <uploadcare.File 1921953c-5d94-4e47-ba36-c2e1dd165e1a>", "id": "f427:c0:m27"}
{"signature": "def is_stored(self):", "body": "return self.info().get('<STR_LIT>') is not None<EOL>", "docstring": "Returns ``True`` if file is stored.\n\n        It might do API request once because it depends on ``info()``.", "id": "f427:c0:m16"}
{"signature": "def store(self):", "body": "return self._base_opration('<STR_LIT>')<EOL>", "docstring": "Store all specified files.", "id": "f427:c4:m1"}
{"signature": "def delete(self):", "body": "self._info_cache = rest_request('<STR_LIT>', self._api_uri)<EOL>", "docstring": "Deletes file by requesting Uploadcare API.", "id": "f427:c0:m26"}
{"signature": "def size(self):", "body": "return self.info().get('<STR_LIT:size>')<EOL>", "docstring": "Returns the file size in bytes.\n\n        It might do API request once because it depends on ``info()``.", "id": "f427:c0:m20"}
{"signature": "def nova_process(body, message):", "body": "event_type = body['<STR_LIT>']<EOL>process = nova_customer_process.get(event_type)<EOL>if process is not None:<EOL><INDENT>process(body, message)<EOL><DEDENT>else:<EOL><INDENT>matched = False<EOL>process_wildcard = None<EOL>for pattern in nova_customer_process_wildcard.keys():<EOL><INDENT>if pattern.match(event_type):<EOL><INDENT>process_wildcard = nova_customer_process_wildcard.get(pattern)<EOL>matched = True<EOL>break<EOL><DEDENT><DEDENT>if matched:<EOL><INDENT>process_wildcard(body, message)<EOL><DEDENT>else:<EOL><INDENT>default_process(body, message)<EOL><DEDENT><DEDENT>message.ack()<EOL>", "docstring": "This function deal with the nova notification.\n\nFirst, find process from customer_process that not include wildcard.\nif not find from customer_process, then find process from customer_process_wildcard.\nif not find from customer_process_wildcard, then use ternya default process.\n:param body: dict of openstack notification.\n:param message: kombu Message class\n:return:", "id": "f442:m0"}
{"signature": "def glance(*arg):", "body": "check_event_type(Openstack.Glance, *arg)<EOL>event_type = arg[<NUM_LIT:0>]<EOL>def decorator(func):<EOL><INDENT>if event_type.find(\"<STR_LIT:*>\") != -<NUM_LIT:1>:<EOL><INDENT>event_type_pattern = pre_compile(event_type)<EOL>glance_customer_process_wildcard[event_type_pattern] = func<EOL><DEDENT>else:<EOL><INDENT>glance_customer_process[event_type] = func<EOL><DEDENT>log.info(\"<STR_LIT>\".format(func.__name__, event_type))<EOL>@functools.wraps(func)<EOL>def wrapper(*args, **kwargs):<EOL><INDENT>func(*args, **kwargs)<EOL><DEDENT>return wrapper<EOL><DEDENT>return decorator<EOL>", "docstring": "Glance annotation for adding function to process glance notification.\n\nif event_type include wildcard, will put {pattern: function} into process_wildcard dict\nelse will put {event_type: function} into process dict\n\n:param arg: event_type of notification", "id": "f444:m3"}
{"signature": "def neutron(*arg):", "body": "check_event_type(Openstack.Neutron, *arg)<EOL>event_type = arg[<NUM_LIT:0>]<EOL>def decorator(func):<EOL><INDENT>if event_type.find(\"<STR_LIT:*>\") != -<NUM_LIT:1>:<EOL><INDENT>event_type_pattern = pre_compile(event_type)<EOL>neutron_customer_process_wildcard[event_type_pattern] = func<EOL><DEDENT>else:<EOL><INDENT>neutron_customer_process[event_type] = func<EOL><DEDENT>log.info(\"<STR_LIT>\".format(func.__name__, event_type))<EOL>@functools.wraps(func)<EOL>def wrapper(*args, **kwargs):<EOL><INDENT>func(*args, **kwargs)<EOL><DEDENT>return wrapper<EOL><DEDENT>return decorator<EOL>", "docstring": "Neutron annotation for adding function to process neutron notification.\n\nif event_type include wildcard, will put {pattern: function} into process_wildcard dict\nelse will put {event_type: function} into process dict\n\n:param arg: event_type of notification", "id": "f444:m2"}
{"signature": "def init_glance_consumer(self, mq):", "body": "if not self.enable_component_notification(Openstack.Glance):<EOL><INDENT>log.debug(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>for i in range(self.config.glance_mq_consumer_count):<EOL><INDENT>mq.create_consumer(self.config.glance_mq_exchange,<EOL>self.config.glance_mq_queue,<EOL>ProcessFactory.process(Openstack.Glance))<EOL><DEDENT>log.debug(\"<STR_LIT>\")<EOL>", "docstring": "Init openstack glance mq\n\n1. Check if enable listening glance notification\n2. Create consumer\n\n:param mq: class ternya.mq.MQ", "id": "f446:c0:m10"}
{"signature": "def init_nova_consumer(self, mq):", "body": "if not self.enable_component_notification(Openstack.Nova):<EOL><INDENT>log.debug(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>for i in range(self.config.nova_mq_consumer_count):<EOL><INDENT>mq.create_consumer(self.config.nova_mq_exchange,<EOL>self.config.nova_mq_queue,<EOL>ProcessFactory.process(Openstack.Nova))<EOL><DEDENT>log.debug(\"<STR_LIT>\")<EOL>", "docstring": "Init openstack nova mq\n\n1. Check if enable listening nova notification\n2. Create consumer\n\n:param mq: class ternya.mq.MQ", "id": "f446:c0:m7"}
{"signature": "def find_file_match(folder_path, regex='<STR_LIT>'):", "body": "outlist = []<EOL>for root, dirs, files in os.walk(folder_path):<EOL><INDENT>outlist.extend([os.path.join(root, f) for f in files<EOL>if re.match(regex, f)])<EOL><DEDENT>return outlist<EOL>", "docstring": "Returns absolute paths of files that match the regex within folder_path and\nall its children folders.\n\nNote: The regex matching is done using the match function\nof the re module.\n\nParameters\n----------\nfolder_path: string\n\nregex: string\n\nReturns\n-------\nA list of strings.", "id": "f456:m0"}
{"signature": "@classmethod<EOL><INDENT>def from_json_str(cls, json_str):<DEDENT>", "body": "dct = json_to_dict(json_str)<EOL>return cls(**dct)<EOL>", "docstring": "Convert json string representation into class instance.\n\n        Args:\n          json_str: json representation as string.\n\n        Returns:\n          New instance of the class with data loaded from json string.", "id": "f458:c0:m0"}
{"signature": "def change_xml_encoding(filepath, src_enc, dst_enc='<STR_LIT:utf-8>'):", "body": "enc_attr = \"<STR_LIT>\"<EOL>replace_file_content(filepath, enc_attr.format(src_enc), enc_attr.format(dst_enc), <NUM_LIT:1>)<EOL>", "docstring": "Modify the encoding entry in the XML file.\n\n    Parameters\n    ----------\n    filepath: str\n        Path to the file to be modified.\n\n    src_enc: str\n        Encoding that is written in the file\n\n    dst_enc: str\n        Encoding to be set in the file.", "id": "f461:m2"}
{"signature": "def write_to_file(file_path, content, encoding=None):", "body": "try:<EOL><INDENT>with open(file_path, \"<STR_LIT:wb>\") as f:<EOL><INDENT>f.write(content.encode(encoding))<EOL><DEDENT><DEDENT>except:<EOL><INDENT>log.exception('<STR_LIT>'.format(file_path))<EOL>raise<EOL><DEDENT>", "docstring": "Write `content` inside the file in `file_path` with the given encoding.\n    Parameters\n    ----------\n    file_path: str\n        Path to the output file. Will be overwritten if exists.\n\n    content: str\n        The content you want in the file.\n\n    encoding: str\n        The name of the encoding.", "id": "f464:m7"}
{"signature": "def get_extension(filepath, check_if_exists=False):", "body": "if check_if_exists:<EOL><INDENT>if not os.path.exists(filepath):<EOL><INDENT>err = '<STR_LIT>' + filepath<EOL>log.error(err)<EOL>raise IOError(err)<EOL><DEDENT><DEDENT>try:<EOL><INDENT>rest, ext = os.path.splitext(filepath)<EOL><DEDENT>except:<EOL><INDENT>raise<EOL><DEDENT>else:<EOL><INDENT>return ext<EOL><DEDENT>", "docstring": "Return the extension of fpath.\n\n    Parameters\n    ----------\n    fpath: string\n    File name or path\n\n    check_if_exists: bool\n\n    Returns\n    -------\n    str\n    The extension of the file name or path", "id": "f464:m0"}
{"signature": "def get_tempfile(suffix='<STR_LIT>', dirpath=None):", "body": "if dirpath is None:<EOL><INDENT>dirpath = get_temp_dir()<EOL><DEDENT>return tempfile.NamedTemporaryFile(suffix=suffix, dir=dirpath)<EOL>", "docstring": "Return a temporary file with the given suffix within dirpath.\n    If dirpath is None, will look for a temporary folder in your system.\n\n    Parameters\n    ----------\n    suffix: str\n        Temporary file name suffix\n\n    dirpath: str\n        Folder path where create the temporary file\n\n    Returns\n    -------\n    temp_filepath: str\n        The path to the temporary path", "id": "f464:m3"}
{"signature": "def fill(self, doc_contents):", "body": "for key, content in doc_contents.items():<EOL><INDENT>doc_contents[key] = replace_chars_for_svg_code(content)<EOL><DEDENT>return super(SVGDocument, self).fill(doc_contents=doc_contents)<EOL>", "docstring": "Fill the content of the document with the information in doc_contents.\n        This is different from the TextDocument fill function, because this will\n        check for symbools in the values of `doc_content` and replace them\n        to good XML codes before filling the template.\n\n        Parameters\n        ----------\n        doc_contents: dict\n            Set of values to set the template document.\n\n        Returns\n        -------\n        filled_doc: str\n            The content of the document with the template information filled.", "id": "f470:c1:m0"}
{"signature": "def _setup_template_file(self, template_file_path):", "body": "try:<EOL><INDENT>template_file = template_file_path<EOL>template_env = get_environment_for(template_file_path)<EOL>template = template_env.get_template(os.path.basename(template_file))<EOL><DEDENT>except:<EOL><INDENT>raise<EOL><DEDENT>else:<EOL><INDENT>self._template_file = template_file<EOL>self._template_env = template_env<EOL>self.template = template<EOL><DEDENT>", "docstring": "Setup self.template\n\n        Parameters\n        ----------\n        template_file_path: str\n            Document template file path.", "id": "f470:c0:m1"}
{"signature": "def render(self, file_path, **kwargs):", "body": "temp = get_tempfile(suffix='<STR_LIT>')<EOL>self.save_content(temp.name)<EOL>file_type = kwargs.get('<STR_LIT>', '<STR_LIT>')<EOL>dpi = kwargs.get('<STR_LIT>', <NUM_LIT>)<EOL>support_unicode = kwargs.get('<STR_LIT>', False)<EOL>try:<EOL><INDENT>if file_type == '<STR_LIT>':<EOL><INDENT>shutil.copyfile(temp.name, file_path)<EOL><DEDENT>elif file_type == '<STR_LIT>':<EOL><INDENT>svg2png(temp.name, file_path, dpi=dpi)<EOL><DEDENT>elif file_type == '<STR_LIT>':<EOL><INDENT>svg2pdf(temp.name, file_path, dpi=dpi, support_unicode=support_unicode)<EOL><DEDENT><DEDENT>except:<EOL><INDENT>log.exception(<EOL>'<STR_LIT>'.format(file_path, file_type)<EOL>)<EOL>raise<EOL><DEDENT>", "docstring": "Save the content of the .svg file in the chosen rendered format.\n\n        Parameters\n        ----------\n        file_path: str\n            Path to the output file.\n\n        Kwargs\n        ------\n        file_type: str\n            Choices: 'png', 'pdf', 'svg'\n            Default: 'pdf'\n\n        dpi: int\n            Dots-per-inch for the png and pdf.\n            Default: 150\n\n        support_unicode: bool\n            Whether to allow unicode to be encoded in the PDF.\n            Default: False", "id": "f470:c1:m1"}
{"signature": "def tex2pdf(tex_file, output_file=None, output_format='<STR_LIT>'):", "body": "if not os.path.exists(tex_file):<EOL><INDENT>raise IOError('<STR_LIT>'.format(tex_file))<EOL><DEDENT>if output_format != '<STR_LIT>' and output_format != '<STR_LIT>':<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(output_format))<EOL><DEDENT>cmd_name = '<STR_LIT>'<EOL>check_command(cmd_name)<EOL>args_strings = [cmd_name]<EOL>if output_file is not None:<EOL><INDENT>args_strings += ['<STR_LIT>'.format(os.path.abspath(os.path.dirname(output_file)))]<EOL><DEDENT>result_dir = os.path.dirname(output_file) if output_file else os.path.dirname(tex_file)<EOL>args_strings += ['<STR_LIT>'.format(output_format)]<EOL>args_strings += ['<STR_LIT:\">' + tex_file + '<STR_LIT:\">']<EOL>log.debug('<STR_LIT>'.format(cmd_name, args_strings))<EOL>ret = simple_call(args_strings)<EOL>result_file = os.path.join(result_dir, remove_ext(os.path.basename(tex_file)) + '<STR_LIT:.>' + output_format)<EOL>if os.path.exists(result_file):<EOL><INDENT>shutil.move(result_file, output_file)<EOL><DEDENT>else:<EOL><INDENT>raise IOError('<STR_LIT>')<EOL><DEDENT>log.debug('<STR_LIT>'.format(result_dir))<EOL>cleanup(result_dir, '<STR_LIT>')<EOL>cleanup(result_dir, '<STR_LIT>')<EOL>return ret<EOL>", "docstring": "Call PDFLatex to convert TeX files to PDF.\n\n    Parameters\n    ----------\n    tex_file: str\n        Path to the input LateX file.\n\n    output_file: str\n        Path to the output PDF file.\n        If None, will use the same output directory as the tex_file.\n\n    output_format: str\n        Output file format. Choices: 'pdf' or 'dvi'. Default: 'pdf'\n\n    Returns\n    -------\n    return_value\n        PDFLatex command call return value.", "id": "f471:m0"}
{"signature": "def __init__(self, thing):", "body": "self.thing = thing<EOL>", "docstring": "Initialize the container.\n\nthing -- the thing to store", "id": "f478:c0:m0"}
{"signature": "def set_default_headers(self, *args, **kwargs):", "body": "self.set_header('<STR_LIT>', '<STR_LIT:*>')<EOL>self.set_header('<STR_LIT>',<EOL>'<STR_LIT>')<EOL>self.set_header('<STR_LIT>',<EOL>'<STR_LIT>')<EOL>", "docstring": "Set the default headers for all requests.", "id": "f478:c4:m2"}
{"signature": "def get_thing(self, idx):", "body": "try:<EOL><INDENT>idx = int(idx)<EOL><DEDENT>except ValueError:<EOL><INDENT>return None<EOL><DEDENT>if idx < <NUM_LIT:0> or idx >= len(self.things):<EOL><INDENT>return None<EOL><DEDENT>return self.things[idx]<EOL>", "docstring": "Get the thing at the given index.\n\nidx -- the index", "id": "f478:c1:m1"}
{"signature": "def get(self):", "body": "self.set_header('<STR_LIT:Content-Type>', '<STR_LIT:application/json>')<EOL>ws_href = '<STR_LIT>'.format(<EOL>'<STR_LIT>' if self.request.protocol == '<STR_LIT>' else '<STR_LIT>',<EOL>self.request.headers.get('<STR_LIT>', '<STR_LIT>')<EOL>)<EOL>descriptions = []<EOL>for thing in self.things.get_things():<EOL><INDENT>description = thing.as_thing_description()<EOL>description['<STR_LIT>'].append({<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'.format(ws_href, thing.get_href()),<EOL>})<EOL>descriptions.append(description)<EOL><DEDENT>self.write(json.dumps(descriptions))<EOL>", "docstring": "Handle a GET request.\n\nproperty_name -- the name of the property from the URL path", "id": "f478:c3:m0"}
{"signature": "def get(self, thing_id='<STR_LIT:0>', property_name=None):", "body": "thing = self.get_thing(thing_id)<EOL>if thing is None:<EOL><INDENT>self.set_status(<NUM_LIT>)<EOL>return<EOL><DEDENT>if thing.has_property(property_name):<EOL><INDENT>self.set_header('<STR_LIT:Content-Type>', '<STR_LIT:application/json>')<EOL>self.write(json.dumps({<EOL>property_name: thing.get_property(property_name),<EOL>}))<EOL><DEDENT>else:<EOL><INDENT>self.set_status(<NUM_LIT>)<EOL><DEDENT>", "docstring": "Handle a GET request.\n\nthing_id -- ID of the thing this request is for\nproperty_name -- the name of the property from the URL path", "id": "f478:c6:m0"}
{"signature": "def delete(self, thing_id='<STR_LIT:0>', action_name=None, action_id=None):", "body": "thing = self.get_thing(thing_id)<EOL>if thing is None:<EOL><INDENT>self.set_status(<NUM_LIT>)<EOL>return<EOL><DEDENT>if thing.remove_action(action_name, action_id):<EOL><INDENT>self.set_status(<NUM_LIT>)<EOL><DEDENT>else:<EOL><INDENT>self.set_status(<NUM_LIT>)<EOL><DEDENT>", "docstring": "Handle a DELETE request.\n\nthing_id -- ID of the thing this request is for\naction_name -- name of the action from the URL path\naction_id -- the action ID from the URL path", "id": "f478:c9:m2"}
{"signature": "def open(self):", "body": "self.thing.add_subscriber(self)<EOL>", "docstring": "Handle a new connection.", "id": "f478:c4:m5"}
{"signature": "def get(self, thing_id='<STR_LIT:0>'):", "body": "thing = self.get_thing(thing_id)<EOL>if thing is None:<EOL><INDENT>self.set_status(<NUM_LIT>)<EOL>return<EOL><DEDENT>self.set_header('<STR_LIT:Content-Type>', '<STR_LIT:application/json>')<EOL>self.write(json.dumps(thing.get_properties()))<EOL>", "docstring": "Handle a GET request.\n\nthing_id -- ID of the thing this request is for", "id": "f478:c5:m0"}
{"signature": "def get(self, thing_id='<STR_LIT:0>'):", "body": "thing = self.get_thing(thing_id)<EOL>if thing is None:<EOL><INDENT>self.set_status(<NUM_LIT>)<EOL>return<EOL><DEDENT>self.set_header('<STR_LIT:Content-Type>', '<STR_LIT:application/json>')<EOL>self.write(json.dumps(thing.get_event_descriptions()))<EOL>", "docstring": "Handle a GET request.\n\nthing_id -- ID of the thing this request is for", "id": "f478:c10:m0"}
{"signature": "def on_close(self):", "body": "self.thing.remove_subscriber(self)<EOL>", "docstring": "Handle a close event on the socket.", "id": "f478:c4:m7"}
{"signature": "def get(self, thing_id='<STR_LIT:0>', event_name=None):", "body": "thing = self.get_thing(thing_id)<EOL>if thing is None:<EOL><INDENT>self.set_status(<NUM_LIT>)<EOL>return<EOL><DEDENT>self.set_header('<STR_LIT:Content-Type>', '<STR_LIT:application/json>')<EOL>self.write(json.dumps(thing.get_event_descriptions(<EOL>event_name=event_name)))<EOL>", "docstring": "Handle a GET request.\n\nthing_id -- ID of the thing this request is for\nevent_name -- name of the event from the URL path", "id": "f478:c11:m0"}
{"signature": "def initialize(self, things, hosts):", "body": "self.things = things<EOL>self.hosts = hosts<EOL>", "docstring": "Initialize the handler.\n\nthings -- list of Things managed by this server\nhosts -- list of allowed hostnames", "id": "f478:c4:m0"}
{"signature": "def __init__(self, things, name):", "body": "self.things = things<EOL>self.name = name<EOL>", "docstring": "Initialize the container.\n\nthings -- the things to store\nname -- the mDNS server name", "id": "f478:c1:m0"}
{"signature": "def get_things(self):", "body": "return self.things<EOL>", "docstring": "Get the list of things.", "id": "f478:c1:m2"}
{"signature": "def on_message(self, message):", "body": "try:<EOL><INDENT>message = json.loads(message)<EOL><DEDENT>except ValueError:<EOL><INDENT>try:<EOL><INDENT>self.write_message(json.dumps({<EOL>'<STR_LIT>': '<STR_LIT:error>',<EOL>'<STR_LIT:data>': {<EOL>'<STR_LIT:status>': '<STR_LIT>',<EOL>'<STR_LIT:message>': '<STR_LIT>',<EOL>},<EOL>}))<EOL><DEDENT>except tornado.websocket.WebSocketClosedError:<EOL><INDENT>pass<EOL><DEDENT>return<EOL><DEDENT>if '<STR_LIT>' not in message or '<STR_LIT:data>' not in message:<EOL><INDENT>try:<EOL><INDENT>self.write_message(json.dumps({<EOL>'<STR_LIT>': '<STR_LIT:error>',<EOL>'<STR_LIT:data>': {<EOL>'<STR_LIT:status>': '<STR_LIT>',<EOL>'<STR_LIT:message>': '<STR_LIT>',<EOL>},<EOL>}))<EOL><DEDENT>except tornado.websocket.WebSocketClosedError:<EOL><INDENT>pass<EOL><DEDENT>return<EOL><DEDENT>msg_type = message['<STR_LIT>']<EOL>if msg_type == '<STR_LIT>':<EOL><INDENT>for property_name, property_value in message['<STR_LIT:data>'].items():<EOL><INDENT>try:<EOL><INDENT>self.thing.set_property(property_name, property_value)<EOL><DEDENT>except PropertyError as e:<EOL><INDENT>self.write_message(json.dumps({<EOL>'<STR_LIT>': '<STR_LIT:error>',<EOL>'<STR_LIT:data>': {<EOL>'<STR_LIT:status>': '<STR_LIT>',<EOL>'<STR_LIT:message>': str(e),<EOL>},<EOL>}))<EOL><DEDENT><DEDENT><DEDENT>elif msg_type == '<STR_LIT>':<EOL><INDENT>for action_name, action_params in message['<STR_LIT:data>'].items():<EOL><INDENT>input_ = None<EOL>if '<STR_LIT:input>' in action_params:<EOL><INDENT>input_ = action_params['<STR_LIT:input>']<EOL><DEDENT>action = self.thing.perform_action(action_name, input_)<EOL>if action:<EOL><INDENT>tornado.ioloop.IOLoop.current().spawn_callback(<EOL>perform_action,<EOL>action,<EOL>)<EOL><DEDENT>else:<EOL><INDENT>self.write_message(json.dumps({<EOL>'<STR_LIT>': '<STR_LIT:error>',<EOL>'<STR_LIT:data>': {<EOL>'<STR_LIT:status>': '<STR_LIT>',<EOL>'<STR_LIT:message>': '<STR_LIT>',<EOL>'<STR_LIT>': message,<EOL>},<EOL>}))<EOL><DEDENT><DEDENT><DEDENT>elif msg_type == '<STR_LIT>':<EOL><INDENT>for event_name in message['<STR_LIT:data>'].keys():<EOL><INDENT>self.thing.add_event_subscriber(event_name, self)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>self.write_message(json.dumps({<EOL>'<STR_LIT>': '<STR_LIT:error>',<EOL>'<STR_LIT:data>': {<EOL>'<STR_LIT:status>': '<STR_LIT>',<EOL>'<STR_LIT:message>': '<STR_LIT>' + msg_type,<EOL>'<STR_LIT>': message,<EOL>},<EOL>}))<EOL><DEDENT>except tornado.websocket.WebSocketClosedError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>", "docstring": "Handle an incoming message.\n\nmessage -- message to handle", "id": "f478:c4:m6"}
{"signature": "def validate_value(self, value):", "body": "if '<STR_LIT>' in self.metadata and self.metadata['<STR_LIT>']:<EOL><INDENT>raise PropertyError('<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>validate(value, self.metadata)<EOL><DEDENT>except ValidationError:<EOL><INDENT>raise PropertyError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Validate new property value before setting it.\n\nvalue -- New value", "id": "f479:c0:m1"}
{"signature": "def get_name(self):", "body": "return self.name<EOL>", "docstring": "Get the name of this property.\n\nReturns the name.", "id": "f479:c0:m7"}
{"signature": "def __init__(self, thing, name, value, metadata=None):", "body": "self.thing = thing<EOL>self.name = name<EOL>self.value = value<EOL>self.href_prefix = '<STR_LIT>'<EOL>self.href = '<STR_LIT>'.format(self.name)<EOL>self.metadata = metadata if metadata is not None else {}<EOL>self.value.on('<STR_LIT>', lambda _: self.thing.property_notify(self))<EOL>", "docstring": "Initialize the object.\n\nthing -- the Thing this property belongs to\nname -- name of the property\nvalue -- Value object to hold the property value\nmetadata -- property metadata, i.e. type, description, unit, etc.,\n            as a dict", "id": "f479:c0:m0"}
{"signature": "def get_href(self):", "body": "return self.href_prefix + self.href<EOL>", "docstring": "Get the href of this property.\n\nReturns the href.", "id": "f479:c0:m4"}
{"signature": "def add_available_action(self, name, metadata, cls):", "body": "if metadata is None:<EOL><INDENT>metadata = {}<EOL><DEDENT>self.available_actions[name] = {<EOL>'<STR_LIT>': metadata,<EOL>'<STR_LIT:class>': cls,<EOL>}<EOL>self.actions[name] = []<EOL>", "docstring": "Add an available action.\n\nname -- name of the action\nmetadata -- action metadata, i.e. type, description, etc., as a dict\ncls -- class to instantiate for this action", "id": "f481:c0:m25"}
{"signature": "def remove_property(self, property_):", "body": "if property_.name in self.properties:<EOL><INDENT>del self.properties[property_.name]<EOL><DEDENT>", "docstring": "Remove a property from this thing.\n\nproperty_ -- property to remove", "id": "f481:c0:m14"}
{"signature": "def add_event(self, event):", "body": "self.events.append(event)<EOL>self.event_notify(event)<EOL>", "docstring": "Add a new event and notify subscribers.\n\nevent -- the event that occurred", "id": "f481:c0:m21"}
{"signature": "def as_thing_description(self):", "body": "thing = {<EOL>'<STR_LIT:name>': self.name,<EOL>'<STR_LIT>': self.href_prefix if self.href_prefix else '<STR_LIT:/>',<EOL>'<STR_LIT>': self.context,<EOL>'<STR_LIT>': self.type,<EOL>'<STR_LIT>': self.get_property_descriptions(),<EOL>'<STR_LIT>': {},<EOL>'<STR_LIT>': {},<EOL>'<STR_LIT>': [<EOL>{<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'.format(self.href_prefix),<EOL>},<EOL>{<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'.format(self.href_prefix),<EOL>},<EOL>{<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'.format(self.href_prefix),<EOL>},<EOL>],<EOL>}<EOL>for name, action in self.available_actions.items():<EOL><INDENT>thing['<STR_LIT>'][name] = action['<STR_LIT>']<EOL>thing['<STR_LIT>'][name]['<STR_LIT>'] = [<EOL>{<EOL>'<STR_LIT>': '<STR_LIT:action>',<EOL>'<STR_LIT>': '<STR_LIT>'.format(self.href_prefix, name),<EOL>},<EOL>]<EOL><DEDENT>for name, event in self.available_events.items():<EOL><INDENT>thing['<STR_LIT>'][name] = event['<STR_LIT>']<EOL>thing['<STR_LIT>'][name]['<STR_LIT>'] = [<EOL>{<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'.format(self.href_prefix, name),<EOL>},<EOL>]<EOL><DEDENT>if self.ui_href is not None:<EOL><INDENT>thing['<STR_LIT>'].append({<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': self.ui_href,<EOL>})<EOL><DEDENT>if self.description:<EOL><INDENT>thing['<STR_LIT:description>'] = self.description<EOL><DEDENT>return thing<EOL>", "docstring": "Return the thing state as a Thing Description.\n\nReturns the state as a dictionary.", "id": "f481:c0:m1"}
{"signature": "def get_action_descriptions(self, action_name=None):", "body": "descriptions = []<EOL>if action_name is None:<EOL><INDENT>for name in self.actions:<EOL><INDENT>for action in self.actions[name]:<EOL><INDENT>descriptions.append(action.as_action_description())<EOL><DEDENT><DEDENT><DEDENT>elif action_name in self.actions:<EOL><INDENT>for action in self.actions[action_name]:<EOL><INDENT>descriptions.append(action.as_action_description())<EOL><DEDENT><DEDENT>return descriptions<EOL>", "docstring": "Get the thing's actions as an array.\n\naction_name -- Optional action name to get descriptions for\n\nReturns the action descriptions.", "id": "f481:c0:m11"}
{"signature": "def get_event_descriptions(self, event_name=None):", "body": "if event_name is None:<EOL><INDENT>return [e.as_event_description() for e in self.events]<EOL><DEDENT>else:<EOL><INDENT>return [e.as_event_description()<EOL>for e in self.events if e.get_name() == event_name]<EOL><DEDENT>", "docstring": "Get the thing's events as an array.\n\nevent_name -- Optional event name to get descriptions for\n\nReturns the event descriptions.", "id": "f481:c0:m12"}
{"signature": "def get_ui_href(self):", "body": "return self.ui_href<EOL>", "docstring": "Get the UI href.", "id": "f481:c0:m3"}
{"signature": "def event_notify(self, event):", "body": "if event.name not in self.available_events:<EOL><INDENT>return<EOL><DEDENT>message = json.dumps({<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:data>': event.as_event_description(),<EOL>})<EOL>for subscriber in self.available_events[event.name]['<STR_LIT>']:<EOL><INDENT>try:<EOL><INDENT>subscriber.write_message(message)<EOL><DEDENT>except tornado.websocket.WebSocketClosedError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>", "docstring": "Notify all subscribers of an event.\n\nevent -- the event that occurred", "id": "f481:c0:m32"}
{"signature": "def perform_action(self, action_name, input_=None):", "body": "if action_name not in self.available_actions:<EOL><INDENT>return None<EOL><DEDENT>action_type = self.available_actions[action_name]<EOL>if '<STR_LIT:input>' in action_type['<STR_LIT>']:<EOL><INDENT>try:<EOL><INDENT>validate(input_, action_type['<STR_LIT>']['<STR_LIT:input>'])<EOL><DEDENT>except ValidationError:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>action = action_type['<STR_LIT:class>'](self, input_=input_)<EOL>action.set_href_prefix(self.href_prefix)<EOL>self.action_notify(action)<EOL>self.actions[action_name].append(action)<EOL>return action<EOL>", "docstring": "Perform an action on the thing.\n\naction_name -- name of the action\ninput_ -- any action inputs\n\nReturns the action that was created.", "id": "f481:c0:m23"}
{"signature": "def add_property(self, property_):", "body": "property_.set_href_prefix(self.href_prefix)<EOL>self.properties[property_.name] = property_<EOL>", "docstring": "Add a property to this thing.\n\nproperty_ -- property to add", "id": "f481:c0:m13"}
{"signature": "def get_action(self, action_name, action_id):", "body": "if action_name not in self.actions:<EOL><INDENT>return None<EOL><DEDENT>for action in self.actions[action_name]:<EOL><INDENT>if action.id == action_id:<EOL><INDENT>return action<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Get an action.\n\naction_name -- name of the action\naction_id -- ID of the action\n\nReturns the requested action if found, else None.", "id": "f481:c0:m20"}
{"signature": "def start(self):", "body": "self.status = '<STR_LIT>'<EOL>self.thing.action_notify(self)<EOL>self.perform_action()<EOL>self.finish()<EOL>", "docstring": "Start performing the action.", "id": "f482:c0:m11"}
{"signature": "def get_time_completed(self):", "body": "return self.time_completed<EOL>", "docstring": "Get the time the action was completed.", "id": "f482:c0:m9"}
{"signature": "def finish(self):", "body": "self.status = '<STR_LIT>'<EOL>self.time_completed = timestamp()<EOL>self.thing.action_notify(self)<EOL>", "docstring": "Finish performing the action.", "id": "f482:c0:m14"}
{"signature": "def as_event_description(self):", "body": "description = {<EOL>self.name: {<EOL>'<STR_LIT>': self.time,<EOL>},<EOL>}<EOL>if self.data is not None:<EOL><INDENT>description[self.name]['<STR_LIT:data>'] = self.data<EOL><DEDENT>return description<EOL>", "docstring": "Get the event description.\n\nReturns a dictionary describing the event.", "id": "f483:c0:m1"}
{"signature": "def __init__(self, thing, name, data=None):", "body": "self.thing = thing<EOL>self.name = name<EOL>self.data = data<EOL>self.time = timestamp()<EOL>", "docstring": "Initialize the object.\n\nthing -- Thing this event belongs to\nname -- name of the event\ndata -- data associated with the event", "id": "f483:c0:m0"}
{"signature": "def get_total_vat(self):", "body": "raise NotImplementedError()<EOL>", "docstring": "Return the total VAT amount.", "id": "f494:c1:m8"}
{"signature": "def get_ledger_code_to_guid_map(self, codes):", "body": "if codes:<EOL><INDENT>codes = set(str(i) for i in codes)<EOL>ledger_ids = self._api.ledgeraccounts.filter(code__in=codes)<EOL>ret = dict((str(i['<STR_LIT>']), i['<STR_LIT>']) for i in ledger_ids)<EOL>found = set(ret.keys())<EOL>missing = (codes - found)<EOL>if missing:<EOL><INDENT>raise UnknownLedgerCodes(missing)<EOL><DEDENT>return ret<EOL><DEDENT>return {}<EOL>", "docstring": "Convert set of human codes and to a dict of code to exactonline\nguid mappings.\n\nExample::\n\n    ret = inv.get_ledger_code_to_guid_map(['1234', '5555'])\n    ret == {'1234': '<guid1_from_exactonline_ledgeraccounts>',\n            '5555': '<guid2_from_exactonline_ledgeraccounts>'}", "id": "f494:c1:m4"}
{"signature": "def set_division(self, division):", "body": "try:<EOL><INDENT>division = int(division)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise V1DivisionError('<STR_LIT>' %<EOL>(division,))<EOL><DEDENT>urlbase = '<STR_LIT>' % (division,)<EOL>resource = urljoin(<EOL>urlbase,<EOL>\"<STR_LIT>\")<EOL>try:<EOL><INDENT>self.rest(GET(resource))<EOL><DEDENT>except AssertionError:<EOL><INDENT>raise V1DivisionError('<STR_LIT>' %<EOL>(division,))<EOL><DEDENT>self.storage.set_division(division)<EOL>", "docstring": "Select the \"current\" division that we'll be working on/with.", "id": "f500:c1:m2"}
{"signature": "def map_exact2foreign_invoice_numbers(self, exact_invoice_numbers=None):", "body": "<EOL>if exact_invoice_numbers is None:<EOL><INDENT>ret = self.filter(select='<STR_LIT>')<EOL>return dict((i['<STR_LIT>'], i['<STR_LIT>']) for i in ret)<EOL><DEDENT>exact_to_foreign_map = {}<EOL>exact_invoice_numbers = list(set(exact_invoice_numbers))  <EOL>for offset in range(<NUM_LIT:0>, len(exact_invoice_numbers), <NUM_LIT>):<EOL><INDENT>batch = exact_invoice_numbers[offset:(offset + <NUM_LIT>)]<EOL>filter_ = '<STR_LIT>'.join(<EOL>'<STR_LIT>' % (i,) for i in batch)<EOL>assert filter_  <EOL>ret = self.filter(filter=filter_, select='<STR_LIT>')<EOL>exact_to_foreign_map.update(<EOL>dict((i['<STR_LIT>'], i['<STR_LIT>']) for i in ret))<EOL><DEDENT>for exact_invoice_number in exact_invoice_numbers:<EOL><INDENT>if exact_invoice_number not in exact_to_foreign_map:<EOL><INDENT>exact_to_foreign_map[exact_invoice_number] = None<EOL><DEDENT><DEDENT>return exact_to_foreign_map<EOL>", "docstring": "Optionally supply a list of ExactOnline invoice numbers.\n\nReturns a dictionary of ExactOnline invoice numbers to foreign\n(YourRef) invoice numbers.", "id": "f505:c0:m2"}
{"signature": "def http_delete(url, opt=opt_default):", "body": "return _http_request(url, method='<STR_LIT>', opt=opt)<EOL>", "docstring": "Shortcut for urlopen (DELETE) + read. We'll probably want to add a\nnice timeout here later too.", "id": "f508:m1"}
{"signature": "def get(self, section, option, **kwargs):", "body": "try:<EOL><INDENT>ret = super(ExactOnlineConfig, self).get(section, option, **kwargs)<EOL><DEDENT>except (NoOptionError, NoSectionError):<EOL><INDENT>raise MissingSetting(option, section)<EOL><DEDENT>return ret<EOL>", "docstring": "Get method that raises MissingSetting if the value was unset.\n\nThis differs from the SafeConfigParser which may raise either a\nNoOptionError or a NoSectionError.\n\nWe take extra **kwargs because the Python 3.5 configparser extends the\nget method signature and it calls self with those parameters.\n\n    def get(self, section, option, *, raw=False, vars=None,\n            fallback=_UNSET):", "id": "f509:c0:m1"}
{"signature": "def get_or_set_default(self, section, option, value):", "body": "try:<EOL><INDENT>ret = self.get(section, option)<EOL><DEDENT>except MissingSetting:<EOL><INDENT>self.set(section, option, value)<EOL>ret = value<EOL><DEDENT>return ret<EOL>", "docstring": "Base method to fetch values and to set defaults in case they\ndon't exist.", "id": "f510:c1:m0"}
{"signature": "def _get_result():", "body": "result = ivoire.current_result<EOL>if result is None:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>return result<EOL>", "docstring": "Find the global result object.", "id": "f518:m0"}
{"signature": "def __call__(self, name):", "body": "example = self.Example(<EOL>name=name, group=self, before=self._before, after=self._after,<EOL>)<EOL>if self.failureException is not None:<EOL><INDENT>example.failureException = self.failureException<EOL><DEDENT>self.add_example(example)<EOL>return example<EOL>", "docstring": "Construct and return a new ``Example``.", "id": "f518:c2:m6"}
{"signature": "def skip_if(self, condition, reason):", "body": "if condition:<EOL><INDENT>raise SkipTest(reason)<EOL><DEDENT>", "docstring": "Skip the example if the condition is set, with the provided reason.", "id": "f518:c1:m7"}
{"signature": "def transform_describe(self, node, describes, context_variable):", "body": "body = self.transform_describe_body(node.body, context_variable)<EOL>return ast.ClassDef(<EOL>name=\"<STR_LIT>\" + describes.title(),<EOL>bases=[ast.Name(id=\"<STR_LIT>\", ctx=ast.Load())],<EOL>keywords=[],<EOL>starargs=None,<EOL>kwargs=None,<EOL>body=list(body),<EOL>decorator_list=[],<EOL>)<EOL>", "docstring": "Transform a describe node into a ``TestCase``.\n\n``node`` is the node object.\n``describes`` is the name of the object being described.\n``context_variable`` is the name bound in the context manager (usually\n\"it\").", "id": "f523:c0:m3"}
{"signature": "def parse(argv=None):", "body": "if argv is None:<EOL><INDENT>argv = sys.argv[<NUM_LIT:1>:]<EOL><DEDENT>if not argv or argv[<NUM_LIT:0>] not in {\"<STR_LIT>\", \"<STR_LIT>\"}:<EOL><INDENT>argv = [\"<STR_LIT>\"] + argv<EOL><DEDENT>arguments = _clean(_parser.parse_args(argv))<EOL>return arguments<EOL>", "docstring": "Parse some arguments using the parser.", "id": "f526:m1"}
{"signature": "def should_color(when):", "body": "if when == \"<STR_LIT>\":<EOL><INDENT>return sys.stderr.isatty()<EOL><DEDENT>return when == \"<STR_LIT>\"<EOL>", "docstring": "Decide whether to color output.", "id": "f526:m0"}
{"signature": "def skip(self, example, reason):", "body": "return \"<STR_LIT:S>\"<EOL>", "docstring": "A skip was encountered.", "id": "f536:c3:m10"}
{"signature": "def exit_context(self, depth):", "body": "return \"<STR_LIT>\"<EOL>", "docstring": "A context was exited.", "id": "f536:c3:m3"}
{"signature": "def failure(self, example, exc_info):", "body": "return \"<STR_LIT:F>\"<EOL>", "docstring": "A failure was encountered.", "id": "f536:c3:m9"}
{"signature": "def enter_group(self, group):", "body": "return \"<STR_LIT>\"<EOL>", "docstring": "A new example group was entered.", "id": "f536:c3:m4"}
{"signature": "def __getattr__(self, attr):", "body": "return getattr(self._formatter, attr)<EOL>", "docstring": "Delegate to the wrapped formatter.", "id": "f536:c2:m1"}
{"signature": "def success(self, example):", "body": "return \"<STR_LIT:.>\"<EOL>", "docstring": "A success was encountered.", "id": "f536:c3:m11"}
{"signature": "def enter_context(self, context, depth):", "body": "return \"<STR_LIT>\"<EOL>", "docstring": "A new context was entered.", "id": "f536:c3:m2"}
{"signature": "def load_from_path(path):", "body": "if os.path.isdir(path):<EOL><INDENT>paths = discover(path)<EOL><DEDENT>else:<EOL><INDENT>paths = [path]<EOL><DEDENT>for path in paths:<EOL><INDENT>name = os.path.basename(os.path.splitext(path)[<NUM_LIT:0>])<EOL>imp.load_source(name, path)<EOL><DEDENT>", "docstring": "Load a spec from a given path, discovering specs if a directory is given.", "id": "f537:m1"}
{"signature": "def load_by_name(name):", "body": "if os.path.exists(name):<EOL><INDENT>load_from_path(name)<EOL><DEDENT>else:<EOL><INDENT>__import__(name)<EOL><DEDENT>", "docstring": "Load a spec from either a file path or a fully qualified name.", "id": "f537:m0"}
{"signature": "def get_email_options(self):", "body": "return {}<EOL>", "docstring": "Override this method to change default e-mail options", "id": "f548:c4:m0"}
{"signature": "def dispose(json_str):", "body": "result_str = list(json_str)<EOL>escaped = False<EOL>normal = True<EOL>sl_comment = False<EOL>ml_comment = False<EOL>quoted = False<EOL>a_step_from_comment = False<EOL>a_step_from_comment_away = False<EOL>former_index = None<EOL>for index, char in enumerate(json_str):<EOL><INDENT>if escaped:  <EOL><INDENT>escaped = False<EOL>continue<EOL><DEDENT>if a_step_from_comment:  <EOL><INDENT>if char != '<STR_LIT:/>' and char != '<STR_LIT:*>':<EOL><INDENT>a_step_from_comment = False<EOL>normal = True<EOL>continue<EOL><DEDENT><DEDENT>if a_step_from_comment_away:  <EOL><INDENT>if char != '<STR_LIT:/>':<EOL><INDENT>a_step_from_comment_away = False<EOL><DEDENT><DEDENT>if char == '<STR_LIT:\">':<EOL><INDENT>if normal and not escaped:<EOL><INDENT>quoted = True<EOL>normal = False<EOL><DEDENT>elif quoted and not escaped:<EOL><INDENT>quoted = False<EOL>normal = True<EOL><DEDENT><DEDENT>elif char == '<STR_LIT:\\\\>':<EOL><INDENT>if normal or quoted:<EOL><INDENT>escaped = True<EOL><DEDENT><DEDENT>elif char == '<STR_LIT:/>':<EOL><INDENT>if a_step_from_comment:<EOL><INDENT>a_step_from_comment = False<EOL>sl_comment = True<EOL>normal = False<EOL>former_index = index - <NUM_LIT:1><EOL><DEDENT>elif a_step_from_comment_away:<EOL><INDENT>a_step_from_comment_away = False<EOL>normal = True<EOL>ml_comment = False<EOL>for i in range(former_index, index + <NUM_LIT:1>):<EOL><INDENT>result_str[i] = \"<STR_LIT>\"<EOL><DEDENT><DEDENT>elif normal:<EOL><INDENT>a_step_from_comment = True<EOL>normal = False<EOL><DEDENT><DEDENT>elif char == '<STR_LIT:*>':<EOL><INDENT>if a_step_from_comment:<EOL><INDENT>a_step_from_comment = False<EOL>ml_comment = True<EOL>normal = False<EOL>former_index = index - <NUM_LIT:1><EOL><DEDENT>elif ml_comment:<EOL><INDENT>a_step_from_comment_away = True<EOL><DEDENT><DEDENT>elif char == '<STR_LIT:\\n>':<EOL><INDENT>if sl_comment:<EOL><INDENT>sl_comment = False<EOL>normal = True<EOL>for i in range(former_index, index + <NUM_LIT:1>):<EOL><INDENT>result_str[i] = \"<STR_LIT>\"<EOL><DEDENT><DEDENT><DEDENT>elif char == '<STR_LIT:]>' or char == '<STR_LIT:}>':<EOL><INDENT>if normal:<EOL><INDENT>_remove_last_comma(result_str, index)<EOL><DEDENT><DEDENT><DEDENT>return (\"<STR_LIT>\" if isinstance(json_str, str) else u\"<STR_LIT>\").join(result_str)<EOL>", "docstring": "Clear all comments in json_str.\n\n    Clear JS-style comments like // and /**/ in json_str.\n    Accept a str or unicode as input.\n\n    Args:\n        json_str: A json string of str or unicode to clean up comment\n\n    Returns:\n        str: The str without comments (or unicode if you pass in unicode)", "id": "f573:m0"}
{"signature": "def job_set_done(self, js):", "body": "if self._closed:<EOL><INDENT>return<EOL><DEDENT>if self._active_js != js:<EOL><INDENT>return<EOL><DEDENT>try:<EOL><INDENT>while self._active_js.is_done():<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>self._active_js = self._js_queue.popleft()<EOL>logger.debug(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>except IndexError:<EOL><INDENT>self._active_js = None<EOL><DEDENT>else:<EOL><INDENT>self._distribute_jobs()<EOL><DEDENT>", "docstring": "Called when a job set has been completed or cancelled. If the job set\nwas active, the next incomplete job set is loaded from the job set\nqueue and is activated.", "id": "f576:c6:m6"}
{"signature": "async def wait_changed(self):", "body": "if not self.is_complete():<EOL><INDENT>waiter = self._loop.create_future()<EOL>self._waiters.append(waiter)<EOL>await waiter<EOL><DEDENT>", "docstring": "Waits until the result set changes. Possible changes can be a result\nbeing added or the result set becoming complete. If the result set is\nalready completed, this method returns immediately.", "id": "f576:c2:m8"}
{"signature": "def add_result(self, result):", "body": "if self._active_jobs == <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>self._results.add(result)<EOL>self._active_jobs -= <NUM_LIT:1><EOL>if self._active_jobs == <NUM_LIT:0>:<EOL><INDENT>self._done()<EOL><DEDENT>", "docstring": "Adds the result of a completed job to the result list, then decrements\nthe active job count. If the job set is already complete, the result is\nsimply discarded instead.", "id": "f576:c5:m7"}
{"signature": "def close(self):", "body": "if self._closed:<EOL><INDENT>return<EOL><DEDENT>self._closed = True<EOL>if self._active_js is not None:<EOL><INDENT>self._active_js.cancel()<EOL><DEDENT>for js in self._js_queue:<EOL><INDENT>js.cancel()<EOL><DEDENT>", "docstring": "Closes the job manager. No more jobs will be assigned, no more job sets\nwill be added, and any queued or active job sets will be cancelled.", "id": "f576:c6:m8"}
{"signature": "def aiter(self): ", "body": "return ResultsIterator(self)<EOL>", "docstring": "Returns an async iterator over the results.", "id": "f576:c2:m4"}
{"signature": "def return_job(self, job):", "body": "if self._closed:<EOL><INDENT>return<EOL><DEDENT>js = self._job_sources[job]<EOL>if len(self._ready_callbacks) > <NUM_LIT:0>:<EOL><INDENT>callback = self._ready_callbacks.popleft()<EOL>callback(job)<EOL><DEDENT>else:<EOL><INDENT>del self._job_sources[job]<EOL>js.return_job(job)<EOL><DEDENT>", "docstring": "Returns a job to its source job set to be run again later.", "id": "f576:c6:m4"}
{"signature": "def get_job(self, callback):", "body": "assert not self._closed<EOL>if self._active_js is None or not self._active_js.job_available():<EOL><INDENT>self._ready_callbacks.append(callback)<EOL><DEDENT>else:<EOL><INDENT>job = self._active_js.get_job()<EOL>self._job_sources[job] = self._active_js<EOL>callback(job)<EOL><DEDENT>", "docstring": "Calls the given callback function when a job becomes available.", "id": "f576:c6:m3"}
{"signature": "def add(self, result):", "body": "assert not self._complete<EOL>self._results.append(result)<EOL>self._change()<EOL>", "docstring": "Adds a new result.", "id": "f576:c2:m5"}
{"signature": "def add_result(self, job, result):", "body": "if self._closed:<EOL><INDENT>return<EOL><DEDENT>js = self._job_sources[job]<EOL>del self._job_sources[job]<EOL>js.add_result(result)<EOL>", "docstring": "Adds the result of a job to the results list of the job's source job\nset.", "id": "f576:c6:m5"}
{"signature": "def cancel(self):", "body": "self._js.cancel()<EOL>", "docstring": "Cancels the job set.", "id": "f576:c4:m3"}
{"signature": "async def start_master(host=\"<STR_LIT>\", port=<NUM_LIT>, *, loop=None):", "body": "loop = loop if loop is not None else asyncio.get_event_loop()<EOL>manager = jobs.JobManager(loop=loop)<EOL>workers = set()<EOL>server = await loop.create_server(<EOL>lambda: WorkerProtocol(manager, workers), host, port)<EOL>return Master(server, manager, workers, loop=loop)<EOL>", "docstring": "Starts a new HighFive master at the given host and port, and returns it.", "id": "f578:m0"}
{"signature": "def line_received(self, line):", "body": "response = json.loads(line.decode(\"<STR_LIT:utf-8>\"))<EOL>self._worker.response_received(response)<EOL>", "docstring": "Called when a complete line is found from the remote worker. Decodes\na response object from the line, then passes it to the worker object.", "id": "f578:c0:m3"}
{"signature": "def response_received(self, response):", "body": "if self._closed:<EOL><INDENT>return<EOL><DEDENT>assert self._job is not None<EOL>logger.debug(\"<STR_LIT>\".format(id(self)))<EOL>result = self._job.get_result(response)<EOL>self._manager.add_result(self._job, result)<EOL>self._load_job()<EOL>", "docstring": "Called when a response to a job RPC has been received. Decodes the\nresponse and finalizes the result, then reports the result to the\njob manager.", "id": "f578:c1:m3"}
{"signature": "def run_worker_pool(job_handler, host=\"<STR_LIT:localhost>\", port=<NUM_LIT>,<EOL>*, max_workers=None):", "body": "if max_workers is None:<EOL><INDENT>max_workers = multiprocessing.cpu_count()<EOL><DEDENT>processes = []<EOL>for _ in range(max_workers):<EOL><INDENT>p = multiprocessing.Process(target=worker_main,<EOL>args=(job_handler, host, port))<EOL>p.start()<EOL>processes.append(p)<EOL><DEDENT>logger.debug(\"<STR_LIT>\")<EOL>for p in processes:<EOL><INDENT>p.join()<EOL><DEDENT>logger.debug(\"<STR_LIT>\")<EOL>", "docstring": "Runs a pool of workers which connect to a remote HighFive master and begin\nexecuting calls.", "id": "f579:m2"}
{"signature": "async def handle_jobs(job_handler, host, port, *, loop):", "body": "try:<EOL><INDENT>try:<EOL><INDENT>reader, writer = await asyncio.open_connection(host, port, loop=loop)<EOL><DEDENT>except OSError:<EOL><INDENT>logging.error(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>while True:<EOL><INDENT>try:<EOL><INDENT>call_encoded = await reader.readuntil(b\"<STR_LIT:\\n>\")<EOL><DEDENT>except (asyncio.IncompleteReadError, ConnectionResetError):<EOL><INDENT>break<EOL><DEDENT>logging.debug(\"<STR_LIT>\")<EOL>call_json = call_encoded.decode(\"<STR_LIT:utf-8>\")<EOL>call = json.loads(call_json)<EOL>response = job_handler(call)<EOL>response_json = json.dumps(response) + \"<STR_LIT:\\n>\"<EOL>response_encoded = response_json.encode(\"<STR_LIT:utf-8>\")<EOL>writer.write(response_encoded)<EOL>logging.debug(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>except KeyboardInterrupt:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Connects to the remote master and continuously receives calls, executes\nthem, then returns a response until interrupted.", "id": "f579:m0"}
{"signature": "def setUp(self):", "body": "self.options = {<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': '<STR_LIT:U+002C>',<EOL>'<STR_LIT>': <NUM_LIT:0>,<EOL>'<STR_LIT>': '<STR_LIT:.>',<EOL>'<STR_LIT>': <NUM_LIT:3><EOL>}<EOL>}<EOL>self.accounting = Accounting(self.options)<EOL>", "docstring": "test up method.\n\nReturns:\n    none (NoneType): None", "id": "f583:c1:m0"}
{"signature": "@task<EOL>def push(msg):", "body": "clean()<EOL>local(\"<STR_LIT>\".format(msg))<EOL>local(\"<STR_LIT>\")<EOL>", "docstring": "Push to github.\n\n    Args:\n        msg (str, required): Description", "id": "f584:m2"}
{"signature": "@task<EOL>def publish(msg=\"<STR_LIT>\"):", "body": "test = check()<EOL>if test.succeeded:<EOL><INDENT>sdist = local(\"<STR_LIT>\")<EOL>if sdist.succeeded:<EOL><INDENT>build = local(<EOL>'<STR_LIT>')<EOL>if build.succeeded:<EOL><INDENT>upload = local(\"<STR_LIT>\")<EOL>if upload.succeeded:<EOL><INDENT>tag()<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Deploy the app to PYPI.\n\n    Args:\n        msg (str, optional): Description", "id": "f584:m3"}
{"signature": "@task<EOL>def check():", "body": "test = local(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL>", "docstring": "Test project.", "id": "f584:m4"}
{"signature": "def to_fixed(self, value, precision):", "body": "precision = self._change_precision(<EOL>precision, self.settings['<STR_LIT>']['<STR_LIT>'])<EOL>power = pow(<NUM_LIT:10>, precision)<EOL>power = round(self.parse(value) * power) / power<EOL>return '<STR_LIT>'.format(value, precision, precision)<EOL>", "docstring": "Implementation that treats floats more like decimals.\n\n        Fixes binary rounding issues (eg. (0.615).toFixed(2) === \"0.61\")\n        that present problems for accounting and finance-related software.", "id": "f585:c0:m4"}
{"signature": "def format(self, number, **kwargs):", "body": "<EOL>if check_type(number, '<STR_LIT:list>'):<EOL><INDENT>return map(lambda val: self.format(val, **kwargs))<EOL><DEDENT>number = self.parse(number)<EOL>if check_type(kwargs, '<STR_LIT>'):<EOL><INDENT>options = (self.settings['<STR_LIT>'].update(kwargs))<EOL><DEDENT>precision = self._change_precision(options['<STR_LIT>'])<EOL>negative = (lambda num: \"<STR_LIT:->\" if num < <NUM_LIT:0> else \"<STR_LIT>\")(number)<EOL>base = str(int(self.to_fixed(abs(number) or <NUM_LIT:0>, precision)), <NUM_LIT:10>)<EOL>mod = (lambda num: len(num) % <NUM_LIT:3> if len(num) > <NUM_LIT:3> else <NUM_LIT:0>)(base)<EOL>num = negative + (lambda num: base[<NUM_LIT:0>:num] if num else '<STR_LIT>')(mod)<EOL>num += re.sub('<STR_LIT>', '<STR_LIT>' +<EOL>options['<STR_LIT>'], base[mod:])<EOL>num += (lambda val: options[<EOL>'<STR_LIT>'] + self.to_fixed(abs(number), precision)<EOL>.split('<STR_LIT:.>')[<NUM_LIT:1>] if val else '<STR_LIT>')(precision)<EOL>return num<EOL>", "docstring": "Format a given number.\n\n        Format a number, with comma-separated thousands and\n        custom precision/decimal places\n\n        Localise by overriding the precision and thousand / decimal separators\n        2nd parameter `precision` can be an object matching `settings.number`\n\n        Args:\n            number (TYPE): Description\n            precision (TYPE): Description\n            thousand (TYPE): Description\n            decimal (TYPE): Description\n\n        Returns:\n            name (TYPE): Description", "id": "f585:c0:m5"}
{"signature": "def parse(self, value, decimal=None):", "body": "<EOL>value = value or <NUM_LIT:0><EOL>if check_type(value, '<STR_LIT:list>'):<EOL><INDENT>return map(lambda val: self.parse(val, decimal))<EOL><DEDENT>if check_type(value, '<STR_LIT:int>') or check_type(value, '<STR_LIT:float>'):<EOL><INDENT>return value<EOL><DEDENT>decimal = decimal or self.settings.number.decimal<EOL>regex = re.compile(\"<STR_LIT>\" + decimal + \"<STR_LIT:]>\")<EOL>unformatted = str(value)<EOL>unformatted = re.sub('<STR_LIT>', \"<STR_LIT>\", unformatted)<EOL>unformatted = re.sub(regex, '<STR_LIT>', unformatted)<EOL>unformatted = unformatted.replace('<STR_LIT:.>', decimal)<EOL>formatted = (lambda val: unformatted if val else <NUM_LIT:0>)(<EOL>is_num(unformatted))<EOL>return formatted<EOL>", "docstring": "Summary.\n\n Takes a string/array of strings, removes all formatting/cruft and\n returns the raw float value\n\n Decimal must be included in the regular expression to match floats\n  (defaults to Accounting.settings.number.decimal),\n  so if the number uses a non-standard decimal\n separator, provide it as the second argument.\n *\n Also matches bracketed negatives (eg. \"$ (1.99)\" => -1.99)\n\n Doesn't throw any errors (`None`s become 0) but this may change\n\nArgs:\n    value (TYPE): Description\n    decimal (TYPE): Description\n\nReturns:\n    name (TYPE): Description", "id": "f585:c0:m3"}
{"signature": "def _change_precision(self, val, base=<NUM_LIT:0>):", "body": "if not isinstance(val, int):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>val = round(abs(val))<EOL>val = (lambda num: base if is_num(num) else num)(val)<EOL>return val<EOL>", "docstring": "Check and normalise the value of precision (must be positive integer).\n\nArgs:\n    val (INT): must be positive integer\n    base (INT): Description\n\nReturns:\n    VAL (INT): Description", "id": "f585:c0:m2"}
{"signature": "def get_field_language(real_field):", "body": "return real_field.split('<STR_LIT:_>')[-<NUM_LIT:1>]<EOL>", "docstring": "return language for a field. i.e. returns \"en\" for \"name_en", "id": "f591:m2"}
{"signature": "def canonical_fieldname(db_field):", "body": "return getattr(db_field, '<STR_LIT>', db_field.name)<EOL>", "docstring": "all \"description_en\", \"description_fr\", etc. field names will return \"description", "id": "f591:m6"}
{"signature": "def get_table_fields(self, db_table):", "body": "db_table_desc = self.introspection.get_table_description(self.cursor, db_table)<EOL>return [t[<NUM_LIT:0>] for t in db_table_desc]<EOL>", "docstring": "get table fields from schema", "id": "f592:c0:m1"}
{"signature": "def get_sync_sql(self, field_name, db_change_langs, model, db_table_fields):", "body": "qn = connection.ops.quote_name<EOL>style = no_style()<EOL>sql_output = []<EOL>db_table = model._meta.db_table<EOL>was_translatable_before = self.was_translatable_before(field_name, db_table_fields)<EOL>default_f = self.get_default_field(field_name, model)<EOL>default_f_required = default_f and self.get_field_required_in_db(db_table,<EOL>default_f.name,<EOL>value_not_implemented=False)<EOL>for lang in db_change_langs:<EOL><INDENT>new_field = get_real_fieldname(field_name, lang)<EOL>try:<EOL><INDENT>f = model._meta.get_field(new_field)<EOL>col_type = self.get_type_of_db_field(field_name, model)<EOL>field_column = f.column<EOL><DEDENT>except FieldDoesNotExist:  <EOL><INDENT>field_column = new_field<EOL>col_type = self.get_type_of_db_field(field_name, model)<EOL><DEDENT>field_sql = [style.SQL_FIELD(qn(field_column)), style.SQL_COLTYPE(col_type)]<EOL>alter_colum_set = '<STR_LIT>' % qn(field_column)<EOL>if default_f:<EOL><INDENT>alter_colum_drop = '<STR_LIT>' % qn(field_column)<EOL><DEDENT>not_null = style.SQL_KEYWORD('<STR_LIT>')<EOL>if '<STR_LIT>' in backend.__name__:<EOL><INDENT>alter_colum_set = '<STR_LIT>' % (qn(field_column), col_type)<EOL>not_null = style.SQL_KEYWORD('<STR_LIT>')<EOL>if default_f:<EOL><INDENT>alter_colum_drop = '<STR_LIT>' % (qn(field_column), col_type)<EOL><DEDENT><DEDENT>if not new_field in db_table_fields:<EOL><INDENT>sql_output.append(\"<STR_LIT>\" % (qn(db_table), '<STR_LIT:U+0020>'.join(field_sql)))<EOL><DEDENT>if lang == self.default_lang and not was_translatable_before:<EOL><INDENT>sql_output.append(\"<STR_LIT>\" % (qn(db_table),qn(field_column), qn(field_name)))<EOL>if not f.null:<EOL><INDENT>sql_output.append(\"<STR_LIT>\" %(qn(db_table), alter_colum_set,style.SQL_KEYWORD('<STR_LIT>')))<EOL><DEDENT><DEDENT>elif default_f and not default_f.null:<EOL><INDENT>if lang == self.default_lang:<EOL><INDENT>f_required = self.get_field_required_in_db(db_table,<EOL>field_column,<EOL>value_not_implemented=False)<EOL>if default_f.name == new_field and default_f_required:<EOL><INDENT>continue<EOL><DEDENT>if not f_required:<EOL><INDENT>sql_output.append((\"<STR_LIT>\"<EOL>\"<STR_LIT>\" %  <EOL>{'<STR_LIT>': qn(db_table),<EOL>'<STR_LIT>': qn(field_column),<EOL>'<STR_LIT>': self.get_value_default(),<EOL>'<STR_LIT:null>': style.SQL_KEYWORD('<STR_LIT>'),<EOL>}))<EOL>sql_output.append(\"<STR_LIT>\" %(qn(db_table), alter_colum_set,style.SQL_KEYWORD('<STR_LIT>')))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>f_required = self.get_field_required_in_db(db_table,<EOL>field_column,<EOL>value_not_implemented=True)<EOL>if f_required:<EOL><INDENT>sql_output.append((\"<STR_LIT>\" % <EOL>(qn(db_table), alter_colum_drop, not_null)))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if not was_translatable_before:<EOL><INDENT>sql_output.append(\"<STR_LIT>\" % (qn(db_table), qn(field_name)))<EOL><DEDENT>return sql_output<EOL>", "docstring": "returns SQL needed for sync schema for a new translatable field", "id": "f592:c0:m8"}
{"signature": "def get_db_change_languages(self, field_name, db_table_fields):", "body": "for lang_code, lang_name in get_languages():<EOL><INDENT>if get_real_fieldname(field_name, lang_code) not in db_table_fields:<EOL><INDENT>yield lang_code<EOL><DEDENT><DEDENT>for db_table_field in db_table_fields:<EOL><INDENT>pattern = re.compile('<STR_LIT>' % field_name)<EOL>m = pattern.match(db_table_field)<EOL>if not m:<EOL><INDENT>continue<EOL><DEDENT>lang = m.group('<STR_LIT>')<EOL>yield lang<EOL><DEDENT>", "docstring": "get only db changes fields", "id": "f592:c0:m3"}
{"signature": "def count(self):", "body": "return self.conn.client.hlen(self.nodelist_key)<EOL>", "docstring": ":rtype: int\n:returns: The number of nodes in the nodelist", "id": "f597:c0:m8"}
{"signature": "def key(self, *args):", "body": "return \"<STR_LIT:.>\".join([str(a) for a in args])<EOL>", "docstring": "Concatenates a list of arguments to provide a (hopefully) unique key to set in the cache.\n\n:param args: A list of ordered, serializable, values.\n:return: A period-delimited string concatenation of the input arguments in order.", "id": "f599:c0:m0"}
{"signature": "def lock(self):", "body": "return phonon.lock.Lock(self.resource_key)<EOL>", "docstring": "Locks the resource managed by this reference.", "id": "f600:c0:m1"}
{"signature": "def mutable(obj):", "body": "base_cls = type(obj)<EOL>class Proxy(base_cls):<EOL><INDENT>def __getattribute__(self, name):<EOL><INDENT>try:<EOL><INDENT>return super().__getattribute__(name)<EOL><DEDENT>except AttributeError:<EOL><INDENT>return getattr(obj, name)<EOL><DEDENT><DEDENT><DEDENT>update_wrapper(Proxy, base_cls, updated = ())<EOL>return Proxy()<EOL>", "docstring": "return a mutable proxy for the `obj`.\n\nall modify on the proxy will not apply on origin object.", "id": "f633:m0"}
{"signature": "def prop(func=None, *,<EOL>field = _UNSET,<EOL>get: bool = True, set: bool = True, del_: bool = False,<EOL>default = _UNSET,<EOL>types: tuple = _UNSET):", "body": "def wrap(func):<EOL><INDENT>if not callable(func):<EOL><INDENT>raise TypeError<EOL><DEDENT>prop_name = func.__name__<EOL>key = field<EOL>if key is _UNSET:<EOL><INDENT>key = '<STR_LIT:_>' + prop_name<EOL><DEDENT>fget, fset, fdel = None, None, None<EOL>if get:<EOL><INDENT>def fget(self):<EOL><INDENT>try:<EOL><INDENT>return self.__dict__[key]<EOL><DEDENT>except KeyError:<EOL><INDENT>if default is not _UNSET:<EOL><INDENT>return default<EOL><DEDENT>raise AttributeError(f\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>if set:<EOL><INDENT>def fset(self, val):<EOL><INDENT>if types is not _UNSET and not isinstance(val, types):<EOL><INDENT>if isinstance(types, tuple):<EOL><INDENT>types_name = tuple(x.__name__ for x in types)<EOL><DEDENT>else:<EOL><INDENT>types_name = types.__name__<EOL><DEDENT>raise TypeError(f'<STR_LIT>'<EOL>f'<STR_LIT>')<EOL><DEDENT>self.__dict__[key] = val<EOL><DEDENT><DEDENT>if del_:<EOL><INDENT>def fdel(self):<EOL><INDENT>del self.__dict__[key]<EOL><DEDENT><DEDENT>return property(fget, fset, fdel, func.__doc__)<EOL><DEDENT>return wrap(func) if func else wrap<EOL>", "docstring": "`prop` is a sugar for `property`.\n\n``` py\n@prop\ndef value(self):\n    pass\n\n# equals:\n\n@property\ndef value(self):\n    return self._value\n\n@value.setter\ndef value(self, val):\n    self._value = val\n```", "id": "f634:m0"}
{"signature": "def get_only(field):", "body": "return property(lambda self: getattr(self, field))<EOL>", "docstring": "`get_only` is a sugar for `property`.\n\n``` py\nvalue = get_only('_value')\n\n# equals:\n\n@property\ndef value(self):\n    return getattr(self, '_value')\n```", "id": "f634:m1"}
{"signature": "def dispose_at_exit(exitable):", "body": "@atexit.register<EOL>def callback():<EOL><INDENT>exitable.__exit__(*sys.exc_info())<EOL><DEDENT>return exitable<EOL>", "docstring": "register `exitable.__exit__()` into `atexit` module.\n\nreturn the `exitable` itself.", "id": "f635:m0"}
{"signature": "def object_to_primitive(obj):", "body": "if obj is None:<EOL><INDENT>return obj<EOL><DEDENT>if isinstance(obj, (int, float, bool, str)):<EOL><INDENT>return obj<EOL><DEDENT>if isinstance(obj, (list, frozenset, set)):<EOL><INDENT>return [object_to_primitive(x) for x in obj]<EOL><DEDENT>if isinstance(obj, dict):<EOL><INDENT>return dict([(object_to_primitive(k), object_to_primitive(v)) for k, v in obj.items()])<EOL><DEDENT>data = vars(obj)<EOL>assert isinstance(data, dict)<EOL>return object_to_primitive(data)<EOL>", "docstring": "convert object to primitive type so we can serialize it to data format like python.\n\nall primitive types: dict, list, int, float, bool, str, None", "id": "f640:m0"}
{"signature": "def incr(self, value=<NUM_LIT:1>):", "body": "return self.do(lambda x: x + value)<EOL>", "docstring": "return new value.", "id": "f643:c1:m1"}
{"signature": "def semaphore(count: int, bounded: bool=False):", "body": "lock_type = threading.BoundedSemaphore if bounded else threading.Semaphore<EOL>lock_obj = lock_type(value=count)<EOL>return with_it(lock_obj)<EOL>", "docstring": "use `Semaphore` to keep func access thread-safety.\n\nexample:\n\n``` py\n@semaphore(3)\ndef func(): pass\n```", "id": "f644:m2"}
{"signature": "def unwrap(self):", "body": "return self._obj<EOL>", "docstring": "get the origin object.", "id": "f649:c1:m1"}
{"signature": "def __eq__(self, other):", "body": "return self._comparer.eq(self.get_cmpvalue(), other.get_cmpvalue())<EOL>", "docstring": "note: user should ensure other is instance of Wrap.", "id": "f649:c1:m4"}
{"signature": "def freeze(self):", "body": "setattr(self, Freezable.__FREEZABLE_FLAG, True)<EOL>", "docstring": "freeze object.", "id": "f651:c0:m0"}
{"signature": "def raise_if_freezed(self):", "body": "if self.is_freezed:<EOL><INDENT>name = type(self).__name__<EOL>raise InvalidOperationException('<STR_LIT>'.format(name=name))<EOL><DEDENT>", "docstring": "raise `InvalidOperationException` if is freezed.", "id": "f651:c0:m2"}
{"signature": "@property<EOL><INDENT>def has_value(self):<DEDENT>", "body": "return self._value is not None<EOL>", "docstring": "get whether has value or not.", "id": "f659:c0:m1"}
{"signature": "def cache(descriptor=None, *, store: IStore = None):", "body": "if descriptor is None:<EOL><INDENT>return functools.partial(cache, store=store)<EOL><DEDENT>hasattrs = {<EOL>'<STR_LIT>': hasattr(descriptor, '<STR_LIT>'),<EOL>'<STR_LIT>': hasattr(descriptor, '<STR_LIT>'),<EOL>'<STR_LIT>': hasattr(descriptor, '<STR_LIT>')<EOL>}<EOL>descriptor_name = get_descriptor_name(descriptor)<EOL>class CacheDescriptor(ICacheDescriptor):<EOL><INDENT>def __init__(self):<EOL><INDENT>if descriptor_name is not None:<EOL><INDENT>self.__name__ = descriptor_name<EOL><DEDENT><DEDENT><DEDENT>cache_descriptor = CacheDescriptor()<EOL>if store is None:<EOL><INDENT>store = FieldStore(cache_descriptor)<EOL><DEDENT>elif not isinstance(store, IStore):<EOL><INDENT>raise TypeError(f'<STR_LIT>')<EOL><DEDENT>if hasattrs['<STR_LIT>']:<EOL><INDENT>def get(self, obj, objtype):<EOL><INDENT>if obj is None:<EOL><INDENT>return descriptor.__get__(obj, objtype)<EOL><DEDENT>value = store.get(self, obj, defval=NOVALUE)<EOL>if value is NOVALUE:<EOL><INDENT>value = descriptor.__get__(obj, objtype)<EOL>store.set(self, obj, value)<EOL><DEDENT>return value<EOL><DEDENT>CacheDescriptor.__get__ = get<EOL><DEDENT>if hasattrs['<STR_LIT>']:<EOL><INDENT>def set(self, obj, value):<EOL><INDENT>store.pop(self, obj)<EOL>descriptor.__set__(obj, value)<EOL><DEDENT>CacheDescriptor.__set__ = set<EOL><DEDENT>if hasattrs['<STR_LIT>']:<EOL><INDENT>def delete(self, obj):<EOL><INDENT>store.pop(self, obj)<EOL>descriptor.__delete__(obj)<EOL><DEDENT>CacheDescriptor.__delete__ = delete<EOL><DEDENT>return cache_descriptor<EOL>", "docstring": "usage:\n\n``` py\n@cache\n@property\ndef name(self): pass\n```", "id": "f661:m1"}
{"signature": "@abstractmethod<EOL><INDENT>def get(self, descriptor, obj, *, defval=NOVALUE) -> object:<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "get value.", "id": "f662:c0:m1"}
{"signature": "def __init__(self, store_dict: dict=None):", "body": "if store_dict is None:<EOL><INDENT>store_dict = WeakKeyDictionary()<EOL><DEDENT>self._data = store_dict<EOL>", "docstring": "if `store_dict` is `None`, use default dict: `WeakKeyDictionary`.", "id": "f662:c2:m0"}
{"signature": "@property<EOL><INDENT>def name(self):<DEDENT>", "body": "return self._name<EOL>", "docstring": "The name of parameter. canbe null.", "id": "f663:c1:m1"}
{"signature": "@yielder<EOL>def flag_housenumber(token):", "body": "if token.is_first and token.isdigit():<EOL><INDENT>token.kind = '<STR_LIT>'<EOL><DEDENT>return token<EOL>", "docstring": "Very basic housenumber flagging. Make your own for your specific needs.\n    Eg. in addok-france:\n    https://github.com/addok/addok-france/blob/master/addok_france/utils.py#L106", "id": "f686:m13"}
{"signature": "def _tokenize(text):", "body": "return PATTERN.findall(text)<EOL>", "docstring": "Split text into a list of tokens.", "id": "f686:m0"}
{"signature": "def iter_pipe(pipe, processors):", "body": "if isinstance(pipe, str):<EOL><INDENT>pipe = [pipe]<EOL><DEDENT>for it in processors:<EOL><INDENT>pipe = it(pipe)<EOL><DEDENT>yield from pipe<EOL>", "docstring": "Allow for iterators to return either an item or an iterator of items.", "id": "f687:m3"}
{"signature": "def pair(cmd, word):", "body": "word = list(preprocess_query(word))[<NUM_LIT:0>]<EOL>key = pair_key(word)<EOL>tokens = [t.decode() for t in DB.smembers(key)]<EOL>tokens.sort()<EOL>print(white(tokens))<EOL>print(magenta('<STR_LIT>'.format(len(tokens))))<EOL>", "docstring": "See all token associated with a given token.\n    PAIR lilas", "id": "f699:m1"}
{"signature": "@spec<EOL>def register_command(subparsers):", "body": "", "docstring": "Register command for Addok CLI.", "id": "f700:m8"}
{"signature": "@spec<EOL>def configure(config):", "body": "", "docstring": "Configure addok by patching config object after user local config.", "id": "f700:m7"}
{"signature": "def do_STRDISTANCE(self, s):", "body": "s = s.split('<STR_LIT:|>')<EOL>if not len(s) == <NUM_LIT:2>:<EOL><INDENT>print(red('<STR_LIT>'))<EOL>return<EOL><DEDENT>one, two = s<EOL>print(white(compare_str(one, two)))<EOL>", "docstring": "Print the distance score between two strings. Use |\u00a0as separator.\n        STRDISTANCE rue des lilas|porte des lilas", "id": "f701:c0:m35"}
{"signature": "def do_GEOHASHTOGEOJSON(self, geoh):", "body": "geoh, with_neighbors = self._match_option('<STR_LIT>', geoh)<EOL>bbox = geohash.bbox(geoh)<EOL>try:<EOL><INDENT>with_neighbors = int(with_neighbors)<EOL><DEDENT>except TypeError:<EOL><INDENT>with_neighbors = <NUM_LIT:0><EOL><DEDENT>def expand(bbox, geoh, depth):<EOL><INDENT>neighbors = geohash.neighbors(geoh)<EOL>for neighbor in neighbors:<EOL><INDENT>other = geohash.bbox(neighbor)<EOL>if with_neighbors > depth:<EOL><INDENT>expand(bbox, neighbor, depth + <NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>if other['<STR_LIT:n>'] > bbox['<STR_LIT:n>']:<EOL><INDENT>bbox['<STR_LIT:n>'] = other['<STR_LIT:n>']<EOL><DEDENT>if other['<STR_LIT:s>'] < bbox['<STR_LIT:s>']:<EOL><INDENT>bbox['<STR_LIT:s>'] = other['<STR_LIT:s>']<EOL><DEDENT>if other['<STR_LIT:e>'] > bbox['<STR_LIT:e>']:<EOL><INDENT>bbox['<STR_LIT:e>'] = other['<STR_LIT:e>']<EOL><DEDENT>if other['<STR_LIT:w>'] < bbox['<STR_LIT:w>']:<EOL><INDENT>bbox['<STR_LIT:w>'] = other['<STR_LIT:w>']<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if with_neighbors > <NUM_LIT:0>:<EOL><INDENT>expand(bbox, geoh, <NUM_LIT:0>)<EOL><DEDENT>geojson = {<EOL>\"<STR_LIT:type>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": [[<EOL>[bbox['<STR_LIT:w>'], bbox['<STR_LIT:n>']],<EOL>[bbox['<STR_LIT:e>'], bbox['<STR_LIT:n>']],<EOL>[bbox['<STR_LIT:e>'], bbox['<STR_LIT:s>']],<EOL>[bbox['<STR_LIT:w>'], bbox['<STR_LIT:s>']],<EOL>[bbox['<STR_LIT:w>'], bbox['<STR_LIT:n>']]<EOL>]]<EOL>}<EOL>print(white(json.dumps(geojson)))<EOL>", "docstring": "Build GeoJSON corresponding to geohash given as parameter.\n        GEOHASHTOGEOJSON u09vej04 [NEIGHBORS 0|1|2]", "id": "f701:c0:m25"}
{"signature": "def do_GEOHASHMEMBERS(self, geoh):", "body": "geoh, with_neighbors = self._match_option('<STR_LIT>', geoh)<EOL>key = compute_geohash_key(geoh, with_neighbors != '<STR_LIT:0>')<EOL>if key:<EOL><INDENT>for id_ in DB.smembers(key):<EOL><INDENT>r = Result(id_)<EOL>print('<STR_LIT>'.format(white(r), blue(r._id)))<EOL><DEDENT><DEDENT>", "docstring": "Return members of a geohash and its neighbors.\n        GEOHASHMEMBERS u09vej04 [NEIGHBORS 0]", "id": "f701:c0:m27"}
{"signature": "def do_GEOHASH(self, latlon):", "body": "try:<EOL><INDENT>lat, lon = map(float, latlon.split())<EOL><DEDENT>except ValueError:<EOL><INDENT>print(red('<STR_LIT>'.format(latlon)))<EOL><DEDENT>else:<EOL><INDENT>print(white(geohash.encode(lat, lon, config.GEOHASH_PRECISION)))<EOL><DEDENT>", "docstring": "Compute a geohash from latitude and longitude.\n        GEOHASH 48.1234 2.9876", "id": "f701:c0:m26"}
{"signature": "def do_REVERSE(self, latlon):", "body": "lat, lon = latlon.split()<EOL>for r in reverse(float(lat), float(lon)):<EOL><INDENT>print('<STR_LIT>'.format(white(r), blue(r.score),<EOL>blue(r.distance), blue(r._id)))<EOL><DEDENT>", "docstring": "Do a reverse search. Args: lat lon.\n        REVERSE 48.1234 2.9876", "id": "f701:c0:m33"}
{"signature": "@classmethod<EOL><INDENT>def from_id(self, _id):<DEDENT>", "body": "return Result(dbkeys.document_key(_id))<EOL>", "docstring": "Return a result from it's document _id.", "id": "f705:c0:m13"}
{"signature": "def do_fuzzyindex(self, word):", "body": "word = list(preprocess_query(word))[<NUM_LIT:0>]<EOL>token = Token(word)<EOL>neighbors = make_fuzzy(token)<EOL>neighbors = [(n, DB.zcard(dbkeys.token_key(n))) for n in neighbors]<EOL>neighbors.sort(key=lambda n: n[<NUM_LIT:1>], reverse=True)<EOL>for token, freq in neighbors:<EOL><INDENT>if freq == <NUM_LIT:0>:<EOL><INDENT>break<EOL><DEDENT>print(white(token), blue(freq))<EOL><DEDENT>", "docstring": "Compute fuzzy extensions of word that exist in index.\n    FUZZYINDEX lilas", "id": "f707:m4"}
{"signature": "def contains_components(self, address, components):", "body": "expected = len(components)<EOL>got = <NUM_LIT:0><EOL>parsed = parse_address(address)<EOL>self.assertTrue(parsed)<EOL>for s, c in parsed:<EOL><INDENT>if components.get(c, None) == s:<EOL><INDENT>got += <NUM_LIT:1><EOL><DEDENT><DEDENT>self.assertEqual(expected, got)<EOL>", "docstring": "Test whether address parse contains specific components.", "id": "f714:c0:m0"}
{"signature": "def have_expansion_in_common(self, str1, str2, **kw):", "body": "expansions1 = expand_address(str1, **kw)<EOL>expansions2 = expand_address(str2, **kw)<EOL>self.assertTrue(set(expansions1) & set(expansions2))<EOL>", "docstring": "Test whether strings have at least one shared expansion.", "id": "f715:c0:m1"}
{"signature": "def validate_fragment(self, fragment=None, fragment_dict=None):", "body": "fragment_dict = fragment_dict if fragment_dict else fragment.to_dict()<EOL>assert fragment_dict['<STR_LIT:content>'] == TEST_HTML<EOL>assert fragment_dict['<STR_LIT>'] == TEST_JS_INIT_FN<EOL>assert fragment_dict['<STR_LIT>'] == EXPECTED_JS_INIT_VERSION<EOL>assert fragment_dict['<STR_LIT>'] == TEST_JSON_INIT_ARGS<EOL>assert fragment_dict['<STR_LIT>'] == EXPECTED_RESOURCES<EOL>", "docstring": "Validates that the fields of a fragment are all correct.", "id": "f721:c0:m2"}
{"signature": "@abstractmethod<EOL><INDENT>def render_to_fragment(self, request, **kwargs):  <DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "Render this view to a fragment.", "id": "f722:c0:m3"}
{"signature": "@staticmethod<EOL><INDENT>def resource_to_html(resource):<DEDENT>", "body": "if resource.mimetype == \"<STR_LIT>\":<EOL><INDENT>if resource.kind == \"<STR_LIT:text>\":<EOL><INDENT>return u\"<STR_LIT>\" % resource.data<EOL><DEDENT>elif resource.kind == \"<STR_LIT:url>\":<EOL><INDENT>return u\"<STR_LIT>\" % resource.data<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\" % resource.kind)<EOL><DEDENT><DEDENT>elif resource.mimetype == \"<STR_LIT>\":<EOL><INDENT>if resource.kind == \"<STR_LIT:text>\":<EOL><INDENT>return u\"<STR_LIT>\" % resource.data<EOL><DEDENT>elif resource.kind == \"<STR_LIT:url>\":<EOL><INDENT>return u\"<STR_LIT>\" % resource.data<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\" % resource.kind)<EOL><DEDENT><DEDENT>elif resource.mimetype == \"<STR_LIT>\":<EOL><INDENT>assert resource.kind == \"<STR_LIT:text>\"<EOL>return resource.data<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\" % resource.mimetype)<EOL><DEDENT>", "docstring": "Returns `resource` wrapped in the appropriate html tag for it's mimetype.", "id": "f723:c0:m19"}
{"signature": "def add_content(self, content):", "body": "assert isinstance(content, six.text_type)<EOL>self.content += content<EOL>", "docstring": "Add content to this fragment.\n\n`content` is a Unicode string, HTML to append to the body of the\nfragment.  It must not contain a ``<body>`` tag, or otherwise assume\nthat it is the only content on the page.", "id": "f723:c0:m4"}
{"signature": "def resources_to_html(self, placement):", "body": "<EOL>return '<STR_LIT:\\n>'.join(<EOL>self.resource_to_html(resource)<EOL>for resource in self.resources<EOL>if resource.placement == placement<EOL>)<EOL>", "docstring": "Get some resource HTML for this Fragment.\n\n`placement` is \"head\" or \"foot\".\n\nReturns a unicode string, the HTML for the head or foot of the page.", "id": "f723:c0:m18"}
{"signature": "def add_resources(self, fragments):", "body": "for fragment in fragments:<EOL><INDENT>self.add_fragment_resources(fragment)<EOL><DEDENT>", "docstring": "Add all the resources from `fragments` to my resources.\n\nThis is used to aggregate resources from a sequence of fragments that\nshould be considered part of the current fragment.\n\nThe content from the Fragments is ignored.  The caller must collect\ntogether the content into this Fragment's content.", "id": "f723:c0:m13"}
{"signature": "def to_dict(self):", "body": "return {<EOL>'<STR_LIT:content>': self.content,<EOL>'<STR_LIT>': [r._asdict() for r in self.resources],  <EOL>'<STR_LIT>': self.js_init_fn,<EOL>'<STR_LIT>': self.js_init_version,<EOL>'<STR_LIT>': self.json_init_args<EOL>}<EOL>", "docstring": "Returns the fragment in a dictionary representation.", "id": "f723:c0:m2"}
{"signature": "def WritingBloomFilter(num_elements, max_fp_prob, filename=None,<EOL>ignore_case=False, want_lock=False,<EOL>fdatasync_on_close=True):", "body": "new_filter = _hydra.BloomFilter.getFilter(<EOL>num_elements, max_fp_prob,<EOL>filename=filename, ignore_case=ignore_case,<EOL>read_only=False, want_lock=want_lock,<EOL>fdatasync_on_close=fdatasync_on_close)<EOL>if filename:<EOL><INDENT>with open('<STR_LIT>'.format(filename), '<STR_LIT:w>') as descriptor:<EOL><INDENT>descriptor.write(\"<STR_LIT>\".format(num_elements))<EOL>descriptor.write(\"<STR_LIT>\".format(max_fp_prob))<EOL>descriptor.write(\"<STR_LIT>\".format(ignore_case))<EOL><DEDENT><DEDENT>return new_filter<EOL>", "docstring": "Create a read/write bloom filter with an upperbound of\n(num_elements, max_fp_prob) as a specification and using filename\nas the backing datastore.", "id": "f753:m2"}
{"signature": "def getlist(self, section, option, *, raw=False, vars=None,<EOL>fallback=None):", "body": "val = self.get(section, option, raw=raw, vars=vars, fallback=fallback)<EOL>values = []<EOL>if val:<EOL><INDENT>for line in val.split(\"<STR_LIT:\\n>\"):<EOL><INDENT>values += [s.strip() for s in line.split(\"<STR_LIT:U+002C>\")]<EOL><DEDENT><DEDENT>return values<EOL>", "docstring": "Return the [section] option values as a list.\n        The list items must be delimited with commas and/or newlines.", "id": "f755:c0:m1"}
{"signature": "def copytree(src, dst, symlinks=True):", "body": "from shutil import copy2, Error, copystat<EOL>names = os.listdir(src)<EOL>if not Path(dst).exists():<EOL><INDENT>os.makedirs(dst)<EOL><DEDENT>errors = []<EOL>for name in names:<EOL><INDENT>srcname = os.path.join(src, name)<EOL>dstname = os.path.join(dst, name)<EOL>try:<EOL><INDENT>if symlinks and os.path.islink(srcname):<EOL><INDENT>linkto = os.readlink(srcname)<EOL>os.symlink(linkto, dstname)<EOL><DEDENT>elif os.path.isdir(srcname):<EOL><INDENT>copytree(srcname, dstname, symlinks)<EOL><DEDENT>else:<EOL><INDENT>copy2(srcname, dstname)<EOL><DEDENT><DEDENT>except OSError as why:<EOL><INDENT>errors.append((srcname, dstname, str(why)))<EOL><DEDENT>except Error as err:<EOL><INDENT>errors.extend(err.args[<NUM_LIT:0>])<EOL><DEDENT><DEDENT>try:<EOL><INDENT>copystat(src, dst)<EOL><DEDENT>except OSError as why:<EOL><INDENT>if why.winerror is None:<EOL><INDENT>errors.extend((src, dst, str(why)))<EOL><DEDENT><DEDENT>if errors:<EOL><INDENT>raise Error(errors)<EOL><DEDENT>", "docstring": "Modified from shutil.copytree docs code sample, merges files rather than\nrequiring dst to not exist.", "id": "f756:m1"}
{"signature": "def debugger():", "body": "e, m, tb = sys.exc_info()<EOL>if tb is not None:<EOL><INDENT>_debugger.post_mortem(tb)<EOL><DEDENT>else:<EOL><INDENT>_debugger.set_trace()<EOL><DEDENT>", "docstring": "If called in the context of an exception, calls post_mortem; otherwise\n    set_trace.\n    ``ipdb`` is preferred over ``pdb`` if installed.", "id": "f756:m3"}
{"signature": "@staticmethod<EOL><INDENT>def DEFAULT_LOGGING_CONFIG(level=logging.WARN, format=LOG_FORMAT):<DEDENT>", "body": "return {<EOL>\"<STR_LIT:version>\": <NUM_LIT:1>,<EOL>\"<STR_LIT>\": {\"<STR_LIT>\": {\"<STR_LIT>\": format},<EOL>\"<STR_LIT>\": {\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>},<EOL>\"<STR_LIT>\": {\"<STR_LIT>\": {\"<STR_LIT:class>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>\"<STR_LIT:root>\": {\"<STR_LIT>\": level,<EOL>\"<STR_LIT>\": [\"<STR_LIT>\"],<EOL>},<EOL>\"<STR_LIT>\": {},<EOL>}<EOL>", "docstring": "Returns a default logging config in dict format.\n\n         Compatible with logging.config.dictConfig(), this default set the root\n         logger to `level` with `sys.stdout` console handler using a formatter\n         initialized with `format`. A simple 'brief' formatter is defined that\n         shows only the message portion any log entries.", "id": "f770:c4:m0"}
{"signature": "def load_key(pubkey):", "body": "try:<EOL><INDENT>return load_pem_public_key(pubkey.encode(), default_backend())<EOL><DEDENT>except ValueError:<EOL><INDENT>pubkey = pubkey.replace('<STR_LIT>', '<STR_LIT>').replace('<STR_LIT>', '<STR_LIT>')<EOL>return load_pem_public_key(pubkey.encode(), default_backend())<EOL><DEDENT>", "docstring": "Load public RSA key, with work-around for keys using\n    incorrect header/footer format.\n\n    Read more about RSA encryption with cryptography:\n    https://cryptography.io/latest/hazmat/primitives/asymmetric/rsa/", "id": "f789:m0"}
{"signature": "def fibonacci(self):", "body": "return <NUM_LIT:5><EOL>", "docstring": "The fifth num in the fibonacci sequence.", "id": "f802:c0:m3"}
{"signature": "def famous_five(self):", "body": "return ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>", "docstring": "The Famous Five is the name of a series of children's\n        adventure novels by English author Enid Blyton.", "id": "f802:c0:m96"}
{"signature": "def flipside(self):", "body": "return '<STR_LIT>'<EOL>", "docstring": "A five on the flipside should be upside down.", "id": "f802:c0:m22"}
{"signature": "def item_turbo(self, item):", "body": "<EOL>return self.item_description(item)<EOL>", "docstring": "This can be overridden to set turbo contents.\n\n        :param item:\n\n        :rtype: str|unicode", "id": "f810:c1:m4"}
{"signature": "def configure_analytics_yandex(self, ident, params=None):", "body": "params = params or {}<EOL>data = {<EOL>'<STR_LIT:type>': '<STR_LIT>',<EOL>'<STR_LIT:id>': ident,<EOL>}<EOL>if params:<EOL><INDENT>data['<STR_LIT>'] = '<STR_LIT:%s>' % params<EOL><DEDENT>self.analytics.append(data)<EOL>", "docstring": "Configure Yandex Metrika analytics counter.\n\n        :param str|unicode ident: Metrika counter ID.\n\n        :param dict params: Additional params.", "id": "f810:c1:m2"}
{"signature": "def configure_ad_yandex(self, ident, turbo_id='<STR_LIT>'):", "body": "self.ads.append({<EOL>'<STR_LIT:type>': '<STR_LIT>',<EOL>'<STR_LIT:id>': ident,<EOL>'<STR_LIT>': turbo_id,<EOL>})<EOL>", "docstring": "Configure Yandex Advertisement Network.\n\n        :param str|unicode ident: Ad ID.\n\n        :param str|unicode turbo_id: ID of a place (figure) on Turbo page where to put an Ad block.", "id": "f810:c1:m1"}
{"signature": "def get_version():", "body": "contents = read_file(os.path.join('<STR_LIT>', '<STR_LIT>'))<EOL>version = re.search('<STR_LIT>', contents)<EOL>version = version.group(<NUM_LIT:1>).replace('<STR_LIT:U+002CU+0020>', '<STR_LIT:.>').strip()<EOL>return version<EOL>", "docstring": "Returns version number, without module import (which can lead to ImportError\n    if some dependencies are unavailable before install.", "id": "f811:m1"}
{"signature": "def get_task_patterns(self):", "body": "raise NotImplementedError<EOL>", "docstring": "\\\n        Like everything else, a bunch of two-tuples containing a regex to match\n        and a callback that takes arguments from the regex", "id": "f817:c0:m1"}
{"signature": "def worker_ping_handler(self, nick, message, channel):", "body": "return '<STR_LIT>' % platform.node()<EOL>", "docstring": "\\\n        Respond to pings sent periodically by the BotnetBot", "id": "f817:c0:m9"}
{"signature": "def register_with_boss(self):", "body": "gevent.sleep(<NUM_LIT:10>) <EOL>while not self.registered.is_set():<EOL><INDENT>self.respond('<STR_LIT>' % platform.node(), nick=self.boss)<EOL>gevent.sleep(<NUM_LIT:30>)<EOL><DEDENT>", "docstring": "\\\n        Register the worker with the boss", "id": "f817:c0:m2"}
{"signature": "def done(self, nick):", "body": "self.finished.add(nick)<EOL>", "docstring": "\\\n        Indicate that the worker with the given nick has finished this task", "id": "f819:c1:m2"}
{"signature": "def dispatch_patterns(self):", "body": "return (<EOL>(self.nick_re, self.new_nick),<EOL>(self.nick_change_re, self.handle_nick_change),<EOL>(self.ping_re, self.handle_ping),<EOL>(self.part_re, self.handle_part),<EOL>(self.join_re, self.handle_join),<EOL>(self.quit_re, self.handle_quit),<EOL>(self.chanmsg_re, self.handle_channel_message),<EOL>(self.privmsg_re, self.handle_private_message),<EOL>(self.registered_re, self.handle_registered),<EOL>)<EOL>", "docstring": "\\\n        Low-level dispatching of socket data based on regex matching, in general\n        handles\n\n        * In event a nickname is taken, registers under a different one\n        * Responds to periodic PING messages from server\n        * Dispatches to registered callbacks when\n            - any user leaves or enters a room currently connected to\n            - a channel message is observed\n            - a private message is received", "id": "f828:c0:m11"}
{"signature": "def send(self, data, force=False):", "body": "if self._registered or force:<EOL><INDENT>self._sock_file.write('<STR_LIT>' % data)<EOL>self._sock_file.flush()<EOL><DEDENT>else:<EOL><INDENT>self._out_buffer.append(data)<EOL><DEDENT>", "docstring": "\\\n        Send raw data over the wire if connection is registered. Otherewise,\n        save the data to an output buffer for transmission later on.\n        If the force flag is true, always send data, regardless of\n        registration status.", "id": "f828:c0:m2"}
{"signature": "def register_callbacks(self, callbacks):", "body": "self._callbacks.extend(callbacks)<EOL>", "docstring": "\\\n        Hook for registering custom callbacks for dispatch patterns", "id": "f828:c0:m12"}
{"signature": "def respond(self, message, channel=None, nick=None):", "body": "self.conn.respond(message, channel, nick)<EOL>", "docstring": "\\\n        Wraps the connection object's respond() method", "id": "f828:c1:m7"}
{"signature": "def run_bot(bot_class, host, port, nick, channels=None, ssl=None):", "body": "conn = IRCConnection(host, port, nick, ssl)<EOL>bot_instance = bot_class(conn)<EOL>while <NUM_LIT:1>:<EOL><INDENT>if not conn.connect():<EOL><INDENT>break<EOL><DEDENT>channels = channels or []<EOL>for channel in channels:<EOL><INDENT>conn.join(channel)<EOL><DEDENT>conn.enter_event_loop()<EOL><DEDENT>", "docstring": "\\\n    Convenience function to start a bot on the given network, optionally joining\n    some channels", "id": "f828:m0"}
{"signature": "def enter_event_loop(self):", "body": "patterns = self.dispatch_patterns()<EOL>self.logger.debug('<STR_LIT>')<EOL>while <NUM_LIT:1>:<EOL><INDENT>try:<EOL><INDENT>data = self._sock_file.readline()<EOL><DEDENT>except socket.error:<EOL><INDENT>data = None<EOL><DEDENT>if not data:<EOL><INDENT>self.logger.info('<STR_LIT>')<EOL>self.close()<EOL>return True<EOL><DEDENT>data = data.rstrip()<EOL>for pattern, callback in patterns:<EOL><INDENT>match = pattern.match(data)<EOL>if match:<EOL><INDENT>callback(**match.groupdict())<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "\\\n        Main loop of the IRCConnection - reads from the socket and dispatches\n        based on regex matching", "id": "f828:c0:m23"}
{"signature": "def register_callbacks(self):", "body": "self.conn.register_callbacks((<EOL>(re.compile(pattern), callback)for pattern, callback in self.command_patterns()<EOL>))<EOL>", "docstring": "\\\n        Hook for registering callbacks with connection -- handled by __init__()", "id": "f828:c1:m1"}
{"signature": "def identify_unit_framework(target_unit):", "body": "if HAS_ASTROPY:<EOL><INDENT>from astropy.units import UnitBase<EOL>if isinstance(target_unit, UnitBase):<EOL><INDENT>return ASTROPY<EOL><DEDENT><DEDENT>if HAS_PINT:<EOL><INDENT>from pint.unit import UnitsContainer<EOL>if hasattr(target_unit, '<STR_LIT>') and isinstance(target_unit.dimensionality, UnitsContainer):<EOL><INDENT>return PINT<EOL><DEDENT><DEDENT>if HAS_QUANTITIES:<EOL><INDENT>from quantities.unitquantity import IrreducibleUnit<EOL>from quantities import Quantity<EOL>if isinstance(target_unit, IrreducibleUnit) or isinstance(target_unit, Quantity):<EOL><INDENT>return QUANTITIES<EOL><DEDENT><DEDENT>raise TraitError(\"<STR_LIT>\".format(type(target_unit).__name__))<EOL>", "docstring": "Identify whether the user is requesting unit validation against\nastropy.units, pint, or quantities.", "id": "f832:m0"}
{"signature": "@stellar.command()<EOL>@click.argument('<STR_LIT>')<EOL>@click.argument('<STR_LIT>')<EOL>def rename(old_name, new_name):", "body": "app = get_app()<EOL>snapshot = app.get_snapshot(old_name)<EOL>if not snapshot:<EOL><INDENT>click.echo(\"<STR_LIT>\" % old_name)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>new_snapshot = app.get_snapshot(new_name)<EOL>if new_snapshot:<EOL><INDENT>click.echo(\"<STR_LIT>\" % new_name)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>app.rename_snapshot(snapshot, new_name)<EOL>click.echo(\"<STR_LIT>\" % (old_name, new_name))<EOL>", "docstring": "Renames a snapshot", "id": "f841:m9"}
{"signature": "@stellar.command()<EOL>def version():", "body": "click.echo(\"<STR_LIT>\" % __version__)<EOL>", "docstring": "Shows version number", "id": "f841:m3"}
{"signature": "@status_logger<EOL><INDENT>def write_indexes(self, table):<DEDENT>", "body": "index_sql = super(PostgresDbWriter, self).write_indexes(table)<EOL>for sql in index_sql:<EOL><INDENT>self.execute(sql)<EOL><DEDENT>", "docstring": "Send DDL to create the specified `table` indexes\n\n        :Parameters:\n          - `table`: an instance of a :py:class:`mysql2pgsql.lib.mysql_reader.MysqlReader.Table` object that represents the table to read/write.\n\n        Returns None", "id": "f858:c0:m9"}
{"signature": "def close(self):", "body": "self.conn.close()<EOL>", "docstring": "Closes connection to the PostgreSQL server", "id": "f858:c0:m5"}
{"signature": "@status_logger<EOL><INDENT>def write_table(self, table):<DEDENT>", "body": "table_sql, serial_key_sql = super(PostgresDbWriter, self).write_table(table)<EOL>for sql in serial_key_sql + table_sql:<EOL><INDENT>self.execute(sql)<EOL><DEDENT>", "docstring": "Send DDL to create the specified `table`\n\n        :Parameters:\n          - `table`: an instance of a :py:class:`mysql2pgsql.lib.mysql_reader.MysqlReader.Table` object that represents the table to read/write.\n\n        Returns None", "id": "f858:c0:m8"}
{"signature": "def get_search_results(self, request, queryset, search_term):", "body": "search_term = search_term.replace('<STR_LIT:->', '<STR_LIT>')<EOL>return super().get_search_results(request, queryset, search_term)<EOL>", "docstring": "Allow searching by hyphenated uuid.", "id": "f876:c3:m0"}
{"signature": "def parse_notification_xml(xml: str) -> Union[AliasRegistration, Payment]:", "body": "body = fromstring(xml).find('<STR_LIT:body>')<EOL>transaction = body.find('<STR_LIT>')<EOL>_user_parameters = transaction.find('<STR_LIT>')<EOL>def get_named_parameter(name):<EOL><INDENT>return _user_parameters.find(\"<STR_LIT>\" + name + \"<STR_LIT>\")<EOL><DEDENT>def success():<EOL><INDENT>return transaction.get('<STR_LIT:status>') == '<STR_LIT:success>'<EOL><DEDENT>def parse_success():<EOL><INDENT>computed_signature = sign_web(body.get('<STR_LIT>'), transaction.find('<STR_LIT>').text,<EOL>transaction.find('<STR_LIT>').text,<EOL>transaction.find('<STR_LIT>').text)<EOL>sign2 = get_named_parameter('<STR_LIT>').text<EOL>if computed_signature != sign2:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>success = transaction.find('<STR_LIT:success>')<EOL>d = dict(<EOL>response_code=success.find('<STR_LIT>').text,<EOL>response_message=success.find('<STR_LIT>').text,<EOL>authorization_code=success.find('<STR_LIT>').text,<EOL>acquirer_authorization_code=success.find('<STR_LIT>').text,<EOL>)<EOL>return {k: v for k, v in d.items() if v is not None}<EOL><DEDENT>def parse_error():<EOL><INDENT>error = transaction.find('<STR_LIT:error>')<EOL>d = dict(<EOL>error_code=error.find('<STR_LIT>').text,<EOL>error_message=error.find('<STR_LIT>').text,<EOL>error_detail=error.find('<STR_LIT>').text)<EOL>acquirer_error_code = get_named_parameter('<STR_LIT>')<EOL>if acquirer_error_code is not None:<EOL><INDENT>d['<STR_LIT>'] = acquirer_error_code.text<EOL><DEDENT>return {k: v for k, v in d.items() if v is not None}<EOL><DEDENT>def parse_common_attributes():<EOL><INDENT>d = dict(<EOL>transaction_id=transaction.find('<STR_LIT>').text,<EOL>merchant_id=body.get('<STR_LIT>'),<EOL>client_ref=transaction.get('<STR_LIT>'),<EOL>amount=parse_money(transaction))<EOL>payment_method = transaction.find('<STR_LIT>')<EOL>if payment_method is not None:<EOL><INDENT>d['<STR_LIT>'] = payment_method.text<EOL><DEDENT>request_type = transaction.find('<STR_LIT>')<EOL>if request_type is not None:<EOL><INDENT>d['<STR_LIT>'] = request_type.text<EOL><DEDENT>credit_card_country = get_named_parameter('<STR_LIT>')<EOL>if credit_card_country is not None:<EOL><INDENT>d['<STR_LIT>'] = credit_card_country.text<EOL><DEDENT>expiry_month = get_named_parameter('<STR_LIT>')<EOL>if expiry_month is not None:<EOL><INDENT>d['<STR_LIT>'] = int(expiry_month.text)<EOL><DEDENT>expiry_year = get_named_parameter('<STR_LIT>')<EOL>if expiry_year is not None:<EOL><INDENT>d['<STR_LIT>'] = int(expiry_year.text)<EOL><DEDENT>return d<EOL><DEDENT>use_alias_parameter = get_named_parameter('<STR_LIT>')<EOL>if use_alias_parameter is not None and use_alias_parameter.text == '<STR_LIT:true>':<EOL><INDENT>d = dict(parse_common_attributes())<EOL>masked_card_number = get_named_parameter('<STR_LIT>')<EOL>if masked_card_number is not None:<EOL><INDENT>d['<STR_LIT>'] = masked_card_number.text<EOL><DEDENT>card_alias = get_named_parameter('<STR_LIT>')<EOL>if card_alias is not None:<EOL><INDENT>d['<STR_LIT>'] = card_alias.text<EOL><DEDENT>if success():<EOL><INDENT>d['<STR_LIT:success>'] = True<EOL>d.update(parse_success())<EOL><DEDENT>else:<EOL><INDENT>d['<STR_LIT:success>'] = False<EOL>d.update(parse_error())<EOL><DEDENT>return AliasRegistration(**d)<EOL><DEDENT>else:<EOL><INDENT>if success():<EOL><INDENT>d = dict(success=True)<EOL>cardno = get_named_parameter('<STR_LIT>')<EOL>if cardno is not None:<EOL><INDENT>d['<STR_LIT>'] = cardno.text<EOL><DEDENT>d.update(parse_common_attributes())<EOL>d.update(parse_success())<EOL>return Payment(**d)<EOL><DEDENT>else:<EOL><INDENT>d = dict(success=False)<EOL>d.update(parse_common_attributes())<EOL>d.update(parse_error())<EOL>return Payment(**d)<EOL><DEDENT><DEDENT>", "docstring": "Both alias registration and payments are received here.\nWe can differentiate them by looking at the use-alias user-parameter (and verifying the amount is o).", "id": "f878:m1"}
{"signature": "def write(self, fp, options=None):", "body": "output = self.render(options)<EOL>if hasattr(output, '<STR_LIT>'):<EOL><INDENT>output.save(fp, format=self.writer.format)<EOL><DEDENT>else:<EOL><INDENT>fp.write(output)<EOL><DEDENT>", "docstring": "Renders the barcode and writes it to the file like object\n        `fp`.\n\n        :parameters:\n            fp : File like object\n                Object to write the raw data in.\n            options : Dict\n                The same as in `self.render`.", "id": "f911:c0:m5"}
{"signature": "def set_options(self, options):", "body": "for key, val in options.items():<EOL><INDENT>key = key.lstrip('<STR_LIT:_>')<EOL>if hasattr(self, key):<EOL><INDENT>setattr(self, key, val)<EOL><DEDENT><DEDENT>", "docstring": "Sets the given options as instance attributes (only\n        if they are known).\n\n        :parameters:\n            options : Dict\n                All known instance attributes and more if the childclass\n                has defined them before this call.\n\n        :rtype: None", "id": "f919:c0:m4"}
{"signature": "def to_ascii(self):", "body": "code = self.build()<EOL>for i, line in enumerate(code):<EOL><INDENT>code[i] = line.replace('<STR_LIT:1>', '<STR_LIT:|>').replace('<STR_LIT:0>', '<STR_LIT:U+0020>')<EOL><DEDENT>return '<STR_LIT:\\n>'.join(code)<EOL>", "docstring": "Returns an ascii representation of the barcode.\n\n        :rtype: String", "id": "f920:c0:m5"}
{"signature": "@abc.abstractmethod<EOL><INDENT>@asyncio.coroutine<EOL>def abort(self):<DEDENT>", "body": "", "docstring": "Abort the authentication. The result is either the failure tuple\n(``(SASLState.FAILURE, None)``) or a :class:`SASLFailure` exception if\nthe response from the peer did not indicate abortion (e.g. another\nerror was returned by the peer or the peer indicated success).", "id": "f929:c4:m2"}
{"signature": "@abc.abstractmethod<EOL><INDENT>@asyncio.coroutine<EOL>def initiate(self, mechanism, payload=None):<DEDENT>", "body": "", "docstring": "Send a SASL initiation request for the given `mechanism`. Depending on\nthe `mechanism`, an initial `payload` *may* be given. The `payload` is\nthen a :class:`bytes` object which needs to be passed as initial\npayload during the initiation request.\n\nWait for a reply by the peer and return the reply as a next-state tuple\nin the format documented at :class:`SASLInterface`.", "id": "f929:c4:m0"}
{"signature": "@asyncio.coroutine<EOL><INDENT>@abc.abstractmethod<EOL>def authenticate(self, sm, token):<DEDENT>", "body": "", "docstring": "Execute the mechanism identified by `token` (the non-:data:`None` value\nwhich has been returned by :meth:`any_supported` before) using the\ngiven :class:`SASLStateMachine` `sm`.\n\nIf authentication fails, an appropriate exception is raised\n(:class:`AuthenticationFailure`). If the authentication fails for a\nreason unrelated to credentials, :class:`SASLFailure` is raised.", "id": "f929:c6:m1"}
{"signature": "def check_bidi(chars):", "body": "<EOL>if not chars:<EOL><INDENT>return<EOL><DEDENT>has_RandALCat = any(is_RandALCat(c) for c in chars)<EOL>if not has_RandALCat:<EOL><INDENT>return<EOL><DEDENT>has_LCat = any(is_LCat(c) for c in chars)<EOL>if has_LCat:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>if not is_RandALCat(chars[<NUM_LIT:0>]) or not is_RandALCat(chars[-<NUM_LIT:1>]):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Check proper bidirectionality as per stringprep. Operates on a list of\nunicode characters provided in `chars`.", "id": "f930:m4"}
{"signature": "def saslprep(string, allow_unassigned=False):", "body": "chars = list(string)<EOL>_saslprep_do_mapping(chars)<EOL>do_normalization(chars)<EOL>check_prohibited_output(<EOL>chars,<EOL>(<EOL>stringprep.in_table_c12,<EOL>stringprep.in_table_c21,<EOL>stringprep.in_table_c22,<EOL>stringprep.in_table_c3,<EOL>stringprep.in_table_c4,<EOL>stringprep.in_table_c5,<EOL>stringprep.in_table_c6,<EOL>stringprep.in_table_c7,<EOL>stringprep.in_table_c8,<EOL>stringprep.in_table_c9<EOL>)<EOL>)<EOL>check_bidi(chars)<EOL>if not allow_unassigned:<EOL><INDENT>check_unassigned(<EOL>chars,<EOL>(<EOL>stringprep.in_table_a1,<EOL>)<EOL>)<EOL><DEDENT>return \"<STR_LIT>\".join(chars)<EOL>", "docstring": "Process the given `string` using the SASLprep profile. In the error cases\ndefined in `RFC 3454`_ (stringprep), a :class:`ValueError` is raised.", "id": "f930:m8"}
{"signature": "def check_prohibited_output(chars, bad_tables):", "body": "violator = check_against_tables(chars, bad_tables)<EOL>if violator is not None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(ord(violator)))<EOL><DEDENT>", "docstring": "Check against prohibited output, by checking whether any of the characters\nfrom `chars` are in any of the `bad_tables`.\n\nOperates in-place on a list of code points from `chars`.", "id": "f930:m5"}
{"signature": "def trace(string):", "body": "check_prohibited_output(<EOL>string,<EOL>(<EOL>stringprep.in_table_c21,<EOL>stringprep.in_table_c22,<EOL>stringprep.in_table_c3,<EOL>stringprep.in_table_c4,<EOL>stringprep.in_table_c5,<EOL>stringprep.in_table_c6,<EOL>stringprep.in_table_c8,<EOL>stringprep.in_table_c9,<EOL>)<EOL>)<EOL>check_bidi(string)<EOL>return string<EOL>", "docstring": "Implement the ``trace`` profile specified in :rfc:`4505`.", "id": "f930:m9"}
{"signature": "def check_against_tables(chars, tables):", "body": "for c in chars:<EOL><INDENT>if any(in_table(c) for in_table in tables):<EOL><INDENT>return c<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Perform a check against the table predicates in `tables`. `tables` must be\na reusable iterable containing characteristic functions of character sets,\nthat is, functions which return :data:`True` if the character is in the\ntable.\n\nThe function returns the first character occuring in any of the tables or\n:data:`None` if no character matches.", "id": "f930:m2"}
{"signature": "def _saslprep_do_mapping(chars):", "body": "i = <NUM_LIT:0><EOL>while i < len(chars):<EOL><INDENT>c = chars[i]<EOL>if stringprep.in_table_c12(c):<EOL><INDENT>chars[i] = \"<STR_LIT>\"<EOL><DEDENT>elif stringprep.in_table_b1(c):<EOL><INDENT>del chars[i]<EOL>continue<EOL><DEDENT>i += <NUM_LIT:1><EOL><DEDENT>", "docstring": "Perform the stringprep mapping step of SASLprep. Operates in-place on a\nlist of unicode characters provided in `chars`.", "id": "f930:m7"}
{"signature": "def check_unassigned(chars, bad_tables):", "body": "bad_tables = (<EOL>stringprep.in_table_a1,)<EOL>violator = check_against_tables(chars, bad_tables)<EOL>if violator is not None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(ord(violator)))<EOL><DEDENT>", "docstring": "Check that `chars` does not contain any unassigned code points as per\nthe given list of `bad_tables`.\n\nOperates on a list of unicode code points provided in `chars`.", "id": "f930:m6"}
{"signature": "def __init__(self, geometry_string, options={}, *args, **kwargs):", "body": "<EOL>self.geometry_string = geometry_string<EOL>self.options = options<EOL>super(HyperlinkedSorlImageField, self).__init__(*args, **kwargs)<EOL>", "docstring": "Create an instance of the HyperlinkedSorlImageField image serializer.\n\nArgs:\n    geometry_string (str): The size of your cropped image.\n    options (Optional[dict]): A dict of sorl options.\n    *args: (Optional) Default serializers.ImageField arguments.\n    **kwargs: (Optional) Default serializers.ImageField keyword\n    arguments.\n\nFor a description of sorl geometry strings and additional sorl options,\nplease see https://sorl-thumbnail.readthedocs.org/en/latest/examples.html?highlight=geometry#low-level-api-examples", "id": "f945:c0:m0"}
{"signature": "def is_bare_exception(self, node):", "body": "return isinstance(node, Name) and node.id in self.current_except_names<EOL>", "docstring": "Checks if the node is a bare exception name from an except block.", "id": "f947:c0:m16"}
{"signature": "def visit_JoinedStr(self, node):", "body": "if version_info >= (<NUM_LIT:3>, <NUM_LIT:6>):<EOL><INDENT>if self.within_logging_statement():<EOL><INDENT>if any(isinstance(i, FormattedValue) for i in node.values):<EOL><INDENT>if self.within_logging_argument():<EOL><INDENT>self.violations.append((node, FSTRING_VIOLATION))<EOL>super(LoggingVisitor, self).generic_visit(node)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Process f-string arguments.", "id": "f947:c0:m7"}
{"signature": "def visit_keyword(self, node):", "body": "if self.should_check_whitelist(node):<EOL><INDENT>if node.arg not in self.whitelist and not node.arg.startswith(\"<STR_LIT>\"):<EOL><INDENT>self.violations.append((self.current_logging_call, WHITELIST_VIOLATION.format(node.arg)))<EOL><DEDENT><DEDENT>if self.should_check_extra_exception(node):<EOL><INDENT>self.check_exception_arg(node.value)<EOL><DEDENT>super(LoggingVisitor, self).generic_visit(node)<EOL>", "docstring": "Process keyword arguments.", "id": "f947:c0:m8"}
{"signature": "def visit_Dict(self, node):", "body": "if self.should_check_whitelist(node):<EOL><INDENT>for key in node.keys:<EOL><INDENT>if key.s in self.whitelist or key.s.startswith(\"<STR_LIT>\"):<EOL><INDENT>continue<EOL><DEDENT>self.violations.append((self.current_logging_call, WHITELIST_VIOLATION.format(key.s)))<EOL><DEDENT><DEDENT>if self.should_check_extra_exception(node):<EOL><INDENT>for value in node.values:<EOL><INDENT>self.check_exception_arg(value)<EOL><DEDENT><DEDENT>super(LoggingVisitor, self).generic_visit(node)<EOL>", "docstring": "Process dict arguments.", "id": "f947:c0:m6"}
{"signature": "def check_exc_info(self, node):", "body": "if self.current_logging_level not in ('<STR_LIT:error>', '<STR_LIT>'):<EOL><INDENT>return<EOL><DEDENT>for kw in node.keywords:<EOL><INDENT>if kw.arg == '<STR_LIT>':<EOL><INDENT>if self.current_logging_level == '<STR_LIT:error>':<EOL><INDENT>violation = ERROR_EXC_INFO_VIOLATION<EOL><DEDENT>else:<EOL><INDENT>violation = REDUNDANT_EXC_INFO_VIOLATION<EOL><DEDENT>self.violations.append((node, violation))<EOL><DEDENT><DEDENT>", "docstring": "Reports a violation if exc_info keyword is used with logging.error or logging.exception.", "id": "f947:c0:m19"}
{"signature": "def visit_Call(self, node):", "body": "<EOL>if self.within_logging_statement():<EOL><INDENT>if self.within_logging_argument() and self.is_format_call(node):<EOL><INDENT>self.violations.append((node, STRING_FORMAT_VIOLATION))<EOL>super(LoggingVisitor, self).generic_visit(node)<EOL>return<EOL><DEDENT><DEDENT>logging_level = self.detect_logging_level(node)<EOL>if logging_level and self.current_logging_level is None:<EOL><INDENT>self.current_logging_level = logging_level<EOL><DEDENT>if logging_level is None:<EOL><INDENT>super(LoggingVisitor, self).generic_visit(node)<EOL>return<EOL><DEDENT>self.current_logging_call = node<EOL>if logging_level == \"<STR_LIT>\":<EOL><INDENT>self.violations.append((node, WARN_VIOLATION))<EOL><DEDENT>self.check_exc_info(node)<EOL>for index, child in enumerate(iter_child_nodes(node)):<EOL><INDENT>if index == <NUM_LIT:1>:<EOL><INDENT>self.current_logging_argument = child<EOL><DEDENT>if index >= <NUM_LIT:1>:<EOL><INDENT>self.check_exception_arg(child)<EOL><DEDENT>if index > <NUM_LIT:1> and isinstance(child, keyword) and child.arg == \"<STR_LIT>\":<EOL><INDENT>self.current_extra_keyword = child<EOL><DEDENT>super(LoggingVisitor, self).visit(child)<EOL>self.current_logging_argument = None<EOL>self.current_extra_keyword = None<EOL><DEDENT>self.current_logging_call = None<EOL>self.current_logging_level = None<EOL>", "docstring": "Visit a function call.\n\nWe expect every logging statement and string format to be a function call.", "id": "f947:c0:m4"}
{"signature": "def is_str_exception(self, node):", "body": "return (<EOL>isinstance(node, Call)<EOL>and isinstance(node.func, Name)<EOL>and node.func.id in ('<STR_LIT:str>', '<STR_LIT>')<EOL>and node.args<EOL>and self.is_bare_exception(node.args[<NUM_LIT:0>])<EOL>)<EOL>", "docstring": "Checks if the node is the expression str(e) or unicode(e), where e is an exception name from an except block", "id": "f947:c0:m17"}
{"signature": "def detect_logging_level(self, node):", "body": "try:<EOL><INDENT>if self.get_id_attr(node.func.value) == \"<STR_LIT>\":<EOL><INDENT>return None<EOL><DEDENT>if node.func.attr in LOGGING_LEVELS:<EOL><INDENT>return node.func.attr<EOL><DEDENT><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT>return None<EOL>", "docstring": "Heuristic to decide whether an AST Call is a logging call.", "id": "f947:c0:m10"}
{"signature": "def getplan(self, size=\"<STR_LIT>\", axes=None, padding=None):", "body": "from numpy import dtype as gettype<EOL>plan = self.vshape<EOL>if axes is None:<EOL><INDENT>if isinstance(size, str):<EOL><INDENT>axes = arange(len(self.vshape))<EOL><DEDENT>else:<EOL><INDENT>axes = arange(len(size))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>axes = asarray(axes, '<STR_LIT:int>')<EOL><DEDENT>pad = array(len(self.vshape)*[<NUM_LIT:0>, ])<EOL>if padding is not None:<EOL><INDENT>pad[axes] = padding<EOL><DEDENT>if isinstance(size, tuple):<EOL><INDENT>plan[axes] = size<EOL><DEDENT>elif isinstance(size, str):<EOL><INDENT>size = <NUM_LIT> * float(size)<EOL>elsize = gettype(self.dtype).itemsize<EOL>nelements = prod(self.vshape)<EOL>dims = self.vshape[self.vmask(axes)]<EOL>if size <= elsize:<EOL><INDENT>s = ones(len(axes))<EOL><DEDENT>else:<EOL><INDENT>remsize = <NUM_LIT:1.0> * nelements * elsize<EOL>s = []<EOL>for (i, d) in enumerate(dims):<EOL><INDENT>minsize = remsize/d<EOL>if minsize >= size:<EOL><INDENT>s.append(<NUM_LIT:1>)<EOL>remsize = minsize<EOL>continue<EOL><DEDENT>else:<EOL><INDENT>s.append(min(d, floor(size/minsize)))<EOL>s[i+<NUM_LIT:1>:] = plan[i+<NUM_LIT:1>:]<EOL>break<EOL><DEDENT><DEDENT><DEDENT>plan[axes] = s<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return plan, pad<EOL>", "docstring": "Identify a plan for chunking values along each dimension.\n\nGenerates an ndarray with the size (in number of elements) of chunks\nin each dimension. If provided, will estimate chunks for only a\nsubset of axes, leaving all others to the full size of the axis.\n\nParameters\n----------\nsize : string or tuple\n     If str, the average size (in KB) of the chunks in all value dimensions.\n     If int/tuple, an explicit specification of the number chunks in\n     each moving value dimension.\n\naxes : tuple, optional, default=None\n      One or more axes to estimate chunks for, if provided any\n      other axes will use one chunk.\n\npadding : tuple or int, option, default=None\n    Size over overlapping padding between chunks in each dimension.\n    If tuple, specifies padding along each chunked dimension; if int,\n    all dimensions use same padding; if None, no padding", "id": "f979:c0:m20"}
{"signature": "def cache(self):", "body": "self._rdd.cache()<EOL>", "docstring": "Cache the underlying RDD in memory.", "id": "f979:c0:m26"}
{"signature": "def unpersist(self):", "body": "self._rdd.unpersist()<EOL>", "docstring": "Remove the underlying RDD from memory.", "id": "f979:c0:m27"}
{"signature": "def map_generic(self, func):", "body": "def process_record(val):<EOL><INDENT>newval = empty(<NUM_LIT:1>, dtype=\"<STR_LIT:object>\")<EOL>newval[<NUM_LIT:0>]  = func(val)<EOL>return newval<EOL><DEDENT>rdd = self._rdd.mapValues(process_record)<EOL>nchunks = self.getnumber(self.plan, self.vshape)<EOL>newshape = tuple([int(s) for s in r_[self.kshape, nchunks]])<EOL>newsplit = len(self.shape)<EOL>return BoltArraySpark(rdd, shape=newshape, split=newsplit, ordered=self._ordered, dtype=\"<STR_LIT:object>\")<EOL>", "docstring": "Apply a generic array -> object to each subarray\n\nThe resulting object is a BoltArraySpark of dtype object where the\nblocked dimensions are replaced with indices indication block ID.", "id": "f979:c0:m19"}
{"signature": "@staticmethod<EOL><INDENT>def ones(shape, context=None, axis=(<NUM_LIT:0>,), dtype=float64, npartitions=None):<DEDENT>", "body": "from numpy import ones<EOL>return ConstructSpark._wrap(ones, shape, context, axis, dtype, npartitions)<EOL>", "docstring": "Create a spark bolt array of ones.\n\nParameters\n----------\nshape : tuple\n    The desired shape of the array.\n\ncontext : SparkContext\n    A context running Spark. (see pyspark)\n\naxis : tuple, optional, default=(0,)\n    Which axes to distribute the array along. The resulting\n    distributed object will use keys to represent these axes,\n    with the remaining axes represented by values.\n\ndtype : data-type, optional, default=float64\n    The desired data-type for the array. If None, will\n    be determined from the data. (see numpy)\n\nnpartitions : int\n    Number of partitions for parallization.\n\nReturns\n-------\nBoltArraySpark", "id": "f980:c0:m1"}
{"signature": "def _reshapebasic(self, shape):", "body": "new = tupleize(shape)<EOL>old_key_size = prod(self.keys.shape)<EOL>old_value_size = prod(self.values.shape)<EOL>for i in range(len(new)):<EOL><INDENT>new_key_size = prod(new[:i])<EOL>new_value_size = prod(new[i:])<EOL>if new_key_size == old_key_size and new_value_size == old_value_size:<EOL><INDENT>return i<EOL><DEDENT><DEDENT>return -<NUM_LIT:1><EOL>", "docstring": "Check if the requested reshape can be broken into independant reshapes\non the keys and values. If it can, returns the index in the new shape\nseparating keys from values, otherwise returns -1", "id": "f985:c0:m30"}
{"signature": "def chunk(self, size=\"<STR_LIT>\", axis=None, padding=None):", "body": "if type(size) is not str:<EOL><INDENT>size = tupleize((size))<EOL><DEDENT>axis = tupleize((axis))<EOL>padding = tupleize((padding))<EOL>from bolt.spark.chunk import ChunkedArray<EOL>chnk = ChunkedArray(rdd=self._rdd, shape=self._shape, split=self._split, dtype=self._dtype)<EOL>return chnk._chunk(size, axis, padding)<EOL>", "docstring": "Chunks records of a distributed array.\n\nChunking breaks arrays into subarrays, using an specified\nsize of chunks along each value dimension. Can alternatively\nspecify an average chunk byte size (in kilobytes) and the size of\nchunks (as ints) will be computed automatically.\n\nParameters\n----------\nsize : tuple, int, or str, optional, default = \"150\"\n    A string giving the size in kilobytes, or a tuple with the size\n    of chunks along each dimension.\n\naxis : int or tuple, optional, default = None\n    One or more axis to chunk array along, if None\n    will use all axes,\n\npadding: tuple or int, default = None\n    Number of elements per dimension that will overlap with the adjacent chunk.\n    If a tuple, specifies padding along each chunked dimension; if a int, same\n    padding will be applied to all chunked dimensions.\n\nReturns\n-------\nChunkedArray", "id": "f985:c0:m24"}
{"signature": "def max(self, axis=None, keepdims=False):", "body": "from numpy import maximum<EOL>return self._stat(axis, func=maximum, keepdims=keepdims)<EOL>", "docstring": "Return the maximum of the array over the given axis.\n\nParameters\n----------\naxis : tuple or int, optional, default=None\n    Axis to compute statistic over, if None\n    will compute over all axes\n\nkeepdims : boolean, optional, default=False\n    Keep axis remaining after operation with size 1.", "id": "f985:c0:m17"}
{"signature": "def std(self, axis=None, keepdims=False):", "body": "return self._stat(axis, name='<STR_LIT>', keepdims=keepdims)<EOL>", "docstring": "Return the standard deviation of the array over the given axis.\n\nParameters\n----------\naxis : tuple or int, optional, default=None\n    Axis to compute statistic over, if None\n    will compute over all axes\n\nkeepdims : boolean, optional, default=False\n    Keep axis remaining after operation with size 1.", "id": "f985:c0:m15"}
{"signature": "def transpose(self, *axes):", "body": "if len(axes) == <NUM_LIT:0>:<EOL><INDENT>p = arange(self.ndim-<NUM_LIT:1>, -<NUM_LIT:1>, -<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>p = asarray(argpack(axes))<EOL><DEDENT>istransposeable(p, range(self.ndim))<EOL>split = self.split<EOL>new_keys, new_values = p[:split], p[split:]<EOL>swapping_keys = sort(new_values[new_values < split])<EOL>swapping_values = sort(new_keys[new_keys >= split])<EOL>stationary_keys = sort(new_keys[new_keys < split])<EOL>stationary_values = sort(new_values[new_values >= split])<EOL>p_swap = r_[stationary_keys, swapping_values, swapping_keys, stationary_values]<EOL>p_swap_inv = argsort(p_swap)<EOL>p_x = p_swap_inv[p]<EOL>p_keys, p_values = p_x[:split], p_x[split:]-split<EOL>arr = self.swap(swapping_keys, swapping_values-split)<EOL>arr = arr.keys.transpose(tuple(p_keys.tolist()))<EOL>arr = arr.values.transpose(tuple(p_values.tolist()))<EOL>return arr<EOL>", "docstring": "Return an array with the axes transposed.\n\nThis operation will incur a swap unless the\ndesiured permutation can be obtained\nonly by transpoing the keys or the values.\n\nParameters\n----------\naxes : None, tuple of ints, or n ints\n    If None, will reverse axis order.", "id": "f985:c0:m26"}
{"signature": "def _getbasic(self, index):", "body": "key_slices = index[<NUM_LIT:0>:self.split]<EOL>value_slices = index[self.split:]<EOL>def key_check(key):<EOL><INDENT>def inrange(k, s):<EOL><INDENT>if s.step > <NUM_LIT:0>:<EOL><INDENT>return s.start <= k < s.stop<EOL><DEDENT>else:<EOL><INDENT>return s.stop < k <= s.start<EOL><DEDENT><DEDENT>def check(k, s):<EOL><INDENT>return inrange(k, s) and mod(k - s.start, s.step) == <NUM_LIT:0><EOL><DEDENT>out = [check(k, s) for k, s in zip(key, key_slices)]<EOL>return all(out)<EOL><DEDENT>def key_func(key):<EOL><INDENT>return tuple([(k - s.start)/s.step for k, s in zip(key, key_slices)])<EOL><DEDENT>filtered = self._rdd.filter(lambda kv: key_check(kv[<NUM_LIT:0>]))<EOL>if self._split == self.ndim:<EOL><INDENT>rdd = filtered.map(lambda kv: (key_func(kv[<NUM_LIT:0>]), kv[<NUM_LIT:1>]))<EOL><DEDENT>else:<EOL><INDENT>value_slices = [s if s.stop != -<NUM_LIT:1> else slice(s.start, None, s.step) for s in value_slices]<EOL>rdd = filtered.map(lambda kv: (key_func(kv[<NUM_LIT:0>]), kv[<NUM_LIT:1>][value_slices]))<EOL><DEDENT>shape = tuple([int(ceil((s.stop - s.start) / float(s.step))) for s in index])<EOL>split = self.split<EOL>return rdd, shape, split<EOL>", "docstring": "Basic indexing (for slices or ints).", "id": "f985:c0:m20"}
{"signature": "def squeeze(self, axis=None):", "body": "if not any([d == <NUM_LIT:1> for d in self.shape]):<EOL><INDENT>return self<EOL><DEDENT>if axis is None:<EOL><INDENT>drop = where(asarray(self.shape) == <NUM_LIT:1>)[<NUM_LIT:0>]<EOL><DEDENT>elif isinstance(axis, int):<EOL><INDENT>drop = asarray((axis,))<EOL><DEDENT>elif isinstance(axis, tuple):<EOL><INDENT>drop = asarray(axis)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if any([self.shape[i] > <NUM_LIT:1> for i in drop]):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if any(asarray(drop) < self.split):<EOL><INDENT>kmask = set([d for d in drop if d < self.split])<EOL>kfunc = lambda k: tuple([kk for ii, kk in enumerate(k) if ii not in kmask])<EOL><DEDENT>else:<EOL><INDENT>kfunc = lambda k: k<EOL><DEDENT>if any(asarray(drop) >= self.split):<EOL><INDENT>vmask = tuple([d - self.split for d in drop if d >= self.split])<EOL>vfunc = lambda v: v.squeeze(vmask)<EOL><DEDENT>else:<EOL><INDENT>vfunc = lambda v: v<EOL><DEDENT>rdd = self._rdd.map(lambda kv: (kfunc(kv[<NUM_LIT:0>]), vfunc(kv[<NUM_LIT:1>])))<EOL>shape = tuple([ss for ii, ss in enumerate(self.shape) if ii not in drop])<EOL>split = len([d for d in range(self.keys.ndim) if d not in drop])<EOL>return self._constructor(rdd, shape=shape, split=split).__finalize__(self)<EOL>", "docstring": "Remove one or more single-dimensional axes from the array.\n\nParameters\n----------\naxis : tuple or int\n    One or more singleton axes to remove.", "id": "f985:c0:m31"}
{"signature": "def tordd(self):", "body": "return self._rdd<EOL>", "docstring": "Return the underlying RDD of the bolt array.", "id": "f985:c0:m44"}
{"signature": "def _align(self, axis):", "body": "<EOL>inshape(self.shape, axis)<EOL>tokeys = [(a - self.split) for a in axis if a >= self.split]<EOL>tovalues = [a for a in range(self.split) if a not in axis]<EOL>if tokeys or tovalues:<EOL><INDENT>return self.swap(tovalues, tokeys)<EOL><DEDENT>else:<EOL><INDENT>return self<EOL><DEDENT>", "docstring": "Align spark bolt array so that axes for iteration are in the keys.\n\nThis operation is applied before most functional operators.\nIt ensures that the specified axes are valid, and swaps\nkey/value axes so that functional operators can be applied\nover the correct records.\n\nParameters\n----------\naxis: tuple[int]\n    One or more axes that wil be iterated over by a functional operator\n\nReturns\n-------\nBoltArraySpark", "id": "f985:c0:m7"}
{"signature": "@property<EOL><INDENT>def split(self):<DEDENT>", "body": "return self._split<EOL>", "docstring": "Axis at which the array is split into keys/values.", "id": "f985:c0:m37"}
{"signature": "def cache(self):", "body": "self._rdd.cache()<EOL>", "docstring": "Cache the underlying RDD in memory.", "id": "f985:c0:m3"}
{"signature": "def swapaxes(self, axis1, axis2):", "body": "raise NotImplementedError<EOL>", "docstring": "Return an array with two axes interchanged.", "id": "f986:c0:m18"}
{"signature": "@property<EOL><INDENT>def ndim(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Number of dimensions.", "id": "f986:c0:m4"}
{"signature": "def min(self, axis):", "body": "raise NotImplementedError<EOL>", "docstring": "Return the minimum of the array elements over the given axis or axes.", "id": "f986:c0:m11"}
{"signature": "@property<EOL><INDENT>def size(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Total number of elements.", "id": "f986:c0:m3"}
{"signature": "def max(self, axis):", "body": "raise NotImplementedError<EOL>", "docstring": "Return the maximum of the array elements over the given axis or axes.", "id": "f986:c0:m12"}
{"signature": "@property<EOL><INDENT>def T(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Transpose by reversing the order of the axes.", "id": "f986:c0:m15"}
{"signature": "@staticmethod<EOL><INDENT>def concatenate(arrays, axis=<NUM_LIT:0>):<DEDENT>", "body": "if not isinstance(arrays, tuple):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>arrays = tuple([asarray(a) for a in arrays])<EOL>from numpy import concatenate<EOL>return BoltArrayLocal(concatenate(arrays, axis))<EOL>", "docstring": "Join a sequence of arrays together.\n\nParameters\n----------\narrays : tuple\n    A sequence of array-like e.g. (a1, a2, ...)\n\naxis : int, optional, default=0\n    The axis along which the arrays will be joined.\n\nReturns\n-------\nBoltArrayLocal", "id": "f987:c0:m4"}
{"signature": "def toscalar(self):", "body": "if self.shape == ():<EOL><INDENT>return self.toarray().reshape(<NUM_LIT:1>)[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>return self<EOL><DEDENT>", "docstring": "Returns the single scalar element contained in an array of shape (), if\nthe array has that shape. Returns self otherwise.", "id": "f988:c0:m10"}
{"signature": "def map(self, func, axis=(<NUM_LIT:0>,)):", "body": "axes = sorted(tupleize(axis))<EOL>key_shape = [self.shape[axis] for axis in axes]<EOL>reshaped = self._align(axes, key_shape=key_shape)<EOL>mapped = asarray(list(map(func, reshaped)))<EOL>elem_shape = mapped[<NUM_LIT:0>].shape<EOL>linearized_shape_inv = key_shape + list(elem_shape)<EOL>reordered = mapped.reshape(*linearized_shape_inv)<EOL>return self._constructor(reordered)<EOL>", "docstring": "Apply a function across an axis.\n\nArray will be aligned so that the desired set of axes\nare in the keys, which may require a transpose/reshape.\n\nParameters\n----------\nfunc : function\n    Function of a single array to apply\n\naxis : tuple or int, optional, default=(0,)\n    Axis or multiple axes to apply function along.\n\nReturns\n-------\nBoltArrayLocal", "id": "f988:c0:m6"}
{"signature": "def reduce(self, func, axis=<NUM_LIT:0>):", "body": "axes = sorted(tupleize(axis))<EOL>if isinstance(func, ufunc):<EOL><INDENT>inshape(self.shape, axes)<EOL>reduced = func.reduce(self, axis=tuple(axes))<EOL><DEDENT>else:<EOL><INDENT>reshaped = self._align(axes)<EOL>reduced = reduce(func, reshaped)<EOL><DEDENT>new_array = self._constructor(reduced)<EOL>expected_shape = [self.shape[i] for i in range(len(self.shape)) if i not in axes]<EOL>if new_array.shape != tuple(expected_shape):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return new_array<EOL>", "docstring": "Reduce an array along an axis.\n\nApplies an associative/commutative function of two arguments\ncumulatively to all arrays along an axis. Array will be aligned\nso that the desired set of axes are in the keys, which may\nrequire a transpose/reshape.\n\nParameters\n----------\nfunc : function\n    Function of two arrays that returns a single array\n\naxis : tuple or int, optional, default=(0,)\n    Axis or multiple axes to reduce along.\n\nReturns\n-------\nBoltArrayLocal", "id": "f988:c0:m7"}
{"signature": "def tospark(self, sc, axis=<NUM_LIT:0>):", "body": "from bolt import array<EOL>return array(self.toarray(), sc, axis=axis)<EOL>", "docstring": "Converts a BoltArrayLocal into a BoltArraySpark\n\nParameters\n----------\nsc : SparkContext\n    The SparkContext which will be used to create the BoltArraySpark\n\naxis : tuple or int, optional, default=0\n    The axis (or axes) across which this array will be parallelized\n\nReturns\n-------\nBoltArraySpark", "id": "f988:c0:m11"}
{"signature": "def tordd(self, sc, axis=<NUM_LIT:0>):", "body": "from bolt import array<EOL>return array(self.toarray(), sc, axis=axis).tordd()<EOL>", "docstring": "Converts a BoltArrayLocal into an RDD\n\nParameters\n----------\nsc : SparkContext\n    The SparkContext which will be used to create the BoltArraySpark\n\naxis : tuple or int, optional, default=0\n    The axis (or axes) across which this array will be parallelized\n\nReturns\n-------\nRDD[(tuple, ndarray)]", "id": "f988:c0:m12"}
{"signature": "def iterexpand(arry, extra):", "body": "for d in range(arry.ndim, arry.ndim+extra):<EOL><INDENT>arry = expand_dims(arry, axis=d)<EOL><DEDENT>return arry<EOL>", "docstring": "Expand dimensions by iteratively append empty axes.\n\nParameters\n----------\narry : ndarray\n    The original array\n\nextra : int\n    The number of empty axes to append", "id": "f990:m10"}
{"signature": "def allstack(vals, depth=<NUM_LIT:0>):", "body": "if type(vals[<NUM_LIT:0>]) is ndarray:<EOL><INDENT>return concatenate(vals, axis=depth)<EOL><DEDENT>else:<EOL><INDENT>return concatenate([allstack(x, depth+<NUM_LIT:1>) for x in vals], axis=depth)<EOL><DEDENT>", "docstring": "If an ndarray has been split into multiple chunks by splitting it along\neach axis at a number of locations, this function rebuilds the\noriginal array from chunks.\n\nParameters\n----------\nvals : nested lists of ndarrays\n    each level of nesting of the lists representing a dimension of\n    the original array.", "id": "f990:m9"}
{"signature": "def isreshapeable(new, old):", "body": "new, old = tupleize(new), tupleize(old)<EOL>if not prod(new) == prod(old):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Check to see if a proposed tuple of axes is a valid reshaping of\nthe old axes by ensuring that they can be factored.\n\nParameters\n----------\nnew : tuple\n    tuple of proposed axes\n\nold : tuple\n    tuple of old axes", "id": "f990:m8"}
{"signature": "@wrapped<EOL>def zeros(*args, **kwargs):", "body": "return lookup(*args, **kwargs).dispatch('<STR_LIT>', *args, **kwargs)<EOL>", "docstring": "Create a bolt array of zeros.", "id": "f991:m4"}
{"signature": "@wrapped<EOL>def array(*args, **kwargs):", "body": "return lookup(*args, **kwargs).dispatch('<STR_LIT>', *args, **kwargs)<EOL>", "docstring": "Create a bolt array.", "id": "f991:m2"}
{"signature": "def filter_suite(arr, b):", "body": "import random<EOL>random.seed(<NUM_LIT>)<EOL>filtered = b.filter(lambda x: False)<EOL>res = filtered.toarray()<EOL>assert res.shape == (<NUM_LIT:0>,)<EOL>filtered = b.filter(lambda x: True)<EOL>res = filtered.toarray()<EOL>assert res.shape == b.shape<EOL>def filter_half(x):<EOL><INDENT>random.seed(x.tostring())<EOL>return random.random()<EOL><DEDENT>filtered = b.filter(lambda x: filter_half(x) < <NUM_LIT:0.5>)<EOL>res = filtered.toarray()<EOL>assert res.shape[<NUM_LIT:1>:] == b.shape[<NUM_LIT:1>:]<EOL>assert res.shape[<NUM_LIT:0>] <= b.shape[<NUM_LIT:0>]<EOL>if not b.mode == \"<STR_LIT>\":<EOL><INDENT>filtered = b.filter(lambda x: filter_half(x) < <NUM_LIT:0.5>, sort=True)<EOL>res = filtered.toarray()<EOL>assert res.shape[<NUM_LIT:1>:] == b.shape[<NUM_LIT:1>:]<EOL>assert res.shape[<NUM_LIT:0>] <= b.shape[<NUM_LIT:0>]<EOL><DEDENT>filtered = b.filter(lambda x: filter_half(x) < <NUM_LIT:0.5>, axis=<NUM_LIT:1>)<EOL>res = filtered.toarray()<EOL>assert res.shape[<NUM_LIT:0>] <= b.shape[<NUM_LIT:1>]<EOL>assert res.shape[<NUM_LIT:1>] == b.shape[<NUM_LIT:0>]<EOL>assert res.shape[<NUM_LIT:2>] == b.shape[<NUM_LIT:2>]<EOL>filtered = b.filter(lambda x: filter_half(x) < <NUM_LIT:0.5>, axis=<NUM_LIT:2>)<EOL>res = filtered.toarray()<EOL>assert res.shape[<NUM_LIT:0>] <= b.shape[<NUM_LIT:2>]<EOL>assert res.shape[<NUM_LIT:1>] == b.shape[<NUM_LIT:0>]<EOL>assert res.shape[<NUM_LIT:2>] == b.shape[<NUM_LIT:1>]<EOL>filtered = b.filter(lambda x: False, axis=(<NUM_LIT:0>, <NUM_LIT:1>))<EOL>res = filtered.toarray()<EOL>assert res.shape == (<NUM_LIT:0>,)<EOL>filtered = b.filter(lambda x: True)<EOL>res = filtered.toarray()<EOL>assert res.shape == b.shape<EOL>filtered = b.filter(lambda x: filter_half(x) < <NUM_LIT:0.5>, axis=(<NUM_LIT:0>, <NUM_LIT:1>))<EOL>res = filtered.toarray()<EOL>assert res.shape[<NUM_LIT:0>] <= b.shape[<NUM_LIT:0>]*b.shape[<NUM_LIT:1>]<EOL>assert res.shape[<NUM_LIT:1>] == b.shape[<NUM_LIT:2>]<EOL>", "docstring": "A set of tests for the filter operator\n\nParameters\n----------\narr: `ndarray`\n    A 3D ndarray used in the construction of `b` (used to check results)\nb: `BoltArray`\n    The BoltArray to be used for testing", "id": "f992:m2"}
{"signature": "def apply_argument_parser(argumentsParser, options=None):", "body": "if options is not None:<EOL><INDENT>args = argumentsParser.parse_args(options)<EOL><DEDENT>else:<EOL><INDENT>args = argumentsParser.parse_args()<EOL><DEDENT>return args<EOL>", "docstring": "Apply the argument parser.", "id": "f1013:m3"}
{"signature": "def chunks(l, n):", "body": "for i in range(<NUM_LIT:0>, len(l), n):<EOL><INDENT>yield l[i:i + n]<EOL><DEDENT>", "docstring": "Yield successive n-sized chunks from l.", "id": "f1015:m0"}
{"signature": "@_convert_f_to_seqs(<NUM_LIT:2>)<EOL>def floyd(seqs, f=None, start=None, key=lambda x: x):", "body": "tortise, hare = seqs<EOL>yield hare.next()<EOL>tortise_value = tortise.next()<EOL>hare_value = hare.next()<EOL>while hare_value != tortise_value:<EOL><INDENT>yield hare_value<EOL>yield hare.next()<EOL>hare_value = hare.next()<EOL>tortise_value = tortise.next()<EOL><DEDENT>if f is None:<EOL><INDENT>raise CycleDetected()<EOL><DEDENT>hare_value = f(hare_value)<EOL>first = <NUM_LIT:0><EOL>tortise_value = start<EOL>while key(tortise_value) != key(hare_value):<EOL><INDENT>tortise_value = f(tortise_value)<EOL>hare_value = f(hare_value)<EOL>first += <NUM_LIT:1><EOL><DEDENT>period = <NUM_LIT:1><EOL>hare_value = f(tortise_value)<EOL>while key(tortise_value) != key(hare_value):<EOL><INDENT>hare_value = f(hare_value)<EOL>period += <NUM_LIT:1><EOL><DEDENT>raise CycleDetected(period=period, first=first)<EOL>", "docstring": "Floyd's Cycle Detector.\n\n    See help(cycle_detector) for more context.\n\n    Args:\n\n      *args: Two iterators issueing the exact same sequence:\n      -or-\n      f, start: Function and starting state for finite state machine\n\n    Yields: \n\n      Values yielded by sequence_a if it terminates, undefined if a\n      cycle is found.\n\n    Raises:\n\n      CycleFound if exception is found; if called with f and `start`,\n      the parametres `first` and `period` will be defined indicating\n      the offset of start of the cycle and the cycle's period.", "id": "f1019:m3"}
{"signature": "@classmethod<EOL><INDENT>def start(cls, now, number, firstweekday=calendar.SATURDAY, **options):<DEDENT>", "body": "week = cls.mask(now, firstweekday=firstweekday, **options)<EOL>days = (number - <NUM_LIT:1>) * cls.DAYS_IN_WEEK<EOL>return week - timedelta(days=days)<EOL>", "docstring": "Return the starting datetime: ``number`` of weeks before ``now``.\n\n``firstweekday`` determines when the week starts. It defaults\nto Saturday.", "id": "f1026:c6:m0"}
{"signature": "@classmethod<EOL><INDENT>def mask(cls, dt, **options):<DEDENT>", "body": "return dt.replace(minute=<NUM_LIT:0>, second=<NUM_LIT:0>, microsecond=<NUM_LIT:0>)<EOL>", "docstring": "Return a datetime with the same value as ``dt``, to a\nresolution of hours.", "id": "f1026:c4:m0"}
{"signature": "@classmethod<EOL><INDENT>def mask(cls, dt, **options):<DEDENT>", "body": "return dt.replace(month=<NUM_LIT:1>, day=<NUM_LIT:1>,<EOL>hour=<NUM_LIT:0>, minute=<NUM_LIT:0>, second=<NUM_LIT:0>, microsecond=<NUM_LIT:0>)<EOL>", "docstring": "Return a datetime with the same value as ``dt``, to a\nresolution of years.", "id": "f1026:c8:m1"}
{"signature": "@classmethod<EOL><INDENT>def mask(cls, dt, **options):<DEDENT>", "body": "return dt.replace(hour=<NUM_LIT:0>, minute=<NUM_LIT:0>, second=<NUM_LIT:0>, microsecond=<NUM_LIT:0>)<EOL>", "docstring": "Return a datetime with the same value as ``dt``, to a\nresolution of days.", "id": "f1026:c5:m0"}
{"signature": "@classmethod<EOL><INDENT>def mask(cls, dt, **options):<DEDENT>", "body": "raise NotImplemented<EOL>", "docstring": "Return a datetime with the same value as ``dt``, keeping only\nsignificant values.", "id": "f1026:c1:m0"}
{"signature": "def dates_to_keep(dates,<EOL>years=<NUM_LIT:0>, months=<NUM_LIT:0>, weeks=<NUM_LIT:0>, days=<NUM_LIT:0>, firstweekday=SATURDAY,<EOL>now=None):", "body": "datetimes = to_keep((datetime.combine(d, time()) for d in dates),<EOL>years=years, months=months, weeks=weeks, days=days,<EOL>hours=<NUM_LIT:0>, minutes=<NUM_LIT:0>, seconds=<NUM_LIT:0>,<EOL>firstweekday=firstweekday, now=now)<EOL>return set(dt.date() for dt in datetimes)<EOL>", "docstring": "Return a set of dates that should be kept, out of ``dates``.\n\nSee ``to_keep`` for a description of arguments.", "id": "f1027:m2"}
{"signature": "def _w_long(x: int) -> bytes:", "body": "return (int(x) & <NUM_LIT>).to_bytes(<NUM_LIT:4>, \"<STR_LIT>\")<EOL>", "docstring": "Convert a 32-bit integer to little-endian.", "id": "f1055:m1"}
{"signature": "def _exec_module(<EOL>self,<EOL>fullname: str,<EOL>loader_state: Mapping[str, str],<EOL>path_stats: Mapping[str, int],<EOL>module: types.ModuleType,<EOL>):", "body": "filename = loader_state[\"<STR_LIT:filename>\"]<EOL>cache_filename = loader_state[\"<STR_LIT>\"]<EOL>with timed(<EOL>lambda duration: logger.debug(<EOL>f\"<STR_LIT>\"<EOL>)<EOL>):<EOL><INDENT>all_bytecode = []<EOL>def add_bytecode(bytecode: types.CodeType):<EOL><INDENT>all_bytecode.append(bytecode)<EOL><DEDENT>logger.debug(f\"<STR_LIT>\")<EOL>forms = reader.read_file(filename, resolver=runtime.resolve_alias)<EOL>compiler.compile_module(  <EOL>forms,<EOL>compiler.CompilerContext(filename=filename),<EOL>module,<EOL>collect_bytecode=add_bytecode,<EOL>)<EOL><DEDENT>cache_file_bytes = _basilisp_bytecode(<EOL>path_stats[\"<STR_LIT>\"], path_stats[\"<STR_LIT:size>\"], all_bytecode<EOL>)<EOL>self._cache_bytecode(filename, cache_filename, cache_file_bytes)<EOL>", "docstring": "Load and execute a non-cached Basilisp module.", "id": "f1055:c0:m10"}
{"signature": "def _r_long(int_bytes: bytes) -> int:", "body": "return int.from_bytes(int_bytes, \"<STR_LIT>\")<EOL>", "docstring": "Convert 4 bytes in little-endian to an integer.", "id": "f1055:m0"}
{"signature": "def genname(prefix: str) -> str:", "body": "i = next_name_id()<EOL>return f\"<STR_LIT>\"<EOL>", "docstring": "Generate a unique function name with the given prefix.", "id": "f1056:m4"}
{"signature": "def munge(s: str, allow_builtins: bool = False) -> str:", "body": "new_str = []<EOL>for c in s:<EOL><INDENT>new_str.append(_MUNGE_REPLACEMENTS.get(c, c))<EOL><DEDENT>new_s = \"<STR_LIT>\".join(new_str)<EOL>if keyword.iskeyword(new_s):<EOL><INDENT>return f\"<STR_LIT>\"<EOL><DEDENT>if not allow_builtins and new_s in builtins.__dict__:<EOL><INDENT>return f\"<STR_LIT>\"<EOL><DEDENT>return new_s<EOL>", "docstring": "Replace characters which are not valid in Python symbols\n    with valid replacement strings.", "id": "f1056:m1"}
{"signature": "def next_(o) -> Optional[ISeq]:", "body": "s = rest(o)<EOL>if not s:<EOL><INDENT>return None<EOL><DEDENT>return s<EOL>", "docstring": "Calls rest on o. If o returns an empty sequence or None, returns None.\n    Otherwise, returns the elements after the first in o.", "id": "f1057:m4"}
{"signature": "def _with_attrs(**kwargs):", "body": "def decorator(f):<EOL><INDENT>for k, v in kwargs.items():<EOL><INDENT>setattr(f, k, v)<EOL><DEDENT>return f<EOL><DEDENT>return decorator<EOL>", "docstring": "Decorator to set attributes on a function. Returns the original\n    function after setting the attributes named by the keyword arguments.", "id": "f1057:m43"}
{"signature": "@classmethod<EOL><INDENT>def __refer_all(cls, refers: lmap.Map, other_ns_interns: lmap.Map) -> lmap.Map:<DEDENT>", "body": "final_refers = refers<EOL>for entry in other_ns_interns:<EOL><INDENT>s: sym.Symbol = entry.key<EOL>var: Var = entry.value<EOL>if not var.is_private:<EOL><INDENT>final_refers = final_refers.assoc(s, var)<EOL><DEDENT><DEDENT>return final_refers<EOL>", "docstring": "Refer all _public_ interns from another namespace.", "id": "f1057:c2:m21"}
{"signature": "def deref(o, timeout_s=None, timeout_val=None):", "body": "if isinstance(o, IDeref):<EOL><INDENT>return o.deref()<EOL><DEDENT>elif isinstance(o, IBlockingDeref):<EOL><INDENT>return o.deref(timeout_s, timeout_val)<EOL><DEDENT>raise TypeError(f\"<STR_LIT>\")<EOL>", "docstring": "Dereference a Deref object and return its contents.\n\n    If o is an object implementing IBlockingDeref and timeout_s and\n    timeout_val are supplied, deref will wait at most timeout_s seconds,\n    returning timeout_val if timeout_s seconds elapse and o has not\n    returned.", "id": "f1057:m17"}
{"signature": "def add_alias(self, alias: sym.Symbol, namespace: \"<STR_LIT>\") -> None:", "body": "self._aliases.swap(lambda m: m.assoc(alias, namespace))<EOL>", "docstring": "Add a Symbol alias for the given Namespace.", "id": "f1057:c2:m12"}
{"signature": "@staticmethod<EOL><INDENT>def intern_unbound(<EOL>ns: sym.Symbol, name: sym.Symbol, dynamic: bool = False, meta=None<EOL>) -> \"<STR_LIT>\":<DEDENT>", "body": "var_ns = Namespace.get_or_create(ns)<EOL>return var_ns.intern(name, Var(var_ns, name, dynamic=dynamic, meta=meta))<EOL>", "docstring": "Create a new unbound `Var` instance to the symbol `name` in namespace `ns`.", "id": "f1057:c1:m17"}
{"signature": "@classmethod<EOL><INDENT>def remove(cls, name: sym.Symbol) -> Optional[\"<STR_LIT>\"]:<DEDENT>", "body": "while True:<EOL><INDENT>oldval: lmap.Map = cls._NAMESPACES.deref()<EOL>ns: Optional[Namespace] = oldval.entry(name, None)<EOL>newval = oldval<EOL>if ns is not None:<EOL><INDENT>newval = oldval.dissoc(name)<EOL><DEDENT>if cls._NAMESPACES.compare_and_set(oldval, newval):<EOL><INDENT>return ns<EOL><DEDENT><DEDENT>", "docstring": "Remove the namespace bound to the symbol `name` in the global\n        namespace cache and return that namespace.\n        Return None if the namespace did not exist in the cache.", "id": "f1057:c2:m27"}
{"signature": "def add_import(<EOL>self, sym: sym.Symbol, module: types.ModuleType, *aliases: sym.Symbol<EOL>) -> None:", "body": "self._imports.swap(lambda m: m.assoc(sym, module))<EOL>if aliases:<EOL><INDENT>self._import_aliases.swap(<EOL>lambda m: m.assoc(<EOL>*itertools.chain.from_iterable([(alias, sym) for alias in aliases])<EOL>)<EOL>)<EOL><DEDENT>", "docstring": "Add the Symbol as an imported Symbol in this Namespace. If aliases are given,\n        the aliases will be applied to the", "id": "f1057:c2:m17"}
{"signature": "@staticmethod<EOL><INDENT>def find_in_ns(ns_sym: sym.Symbol, name_sym: sym.Symbol) -> \"<STR_LIT>\":<DEDENT>", "body": "ns = Namespace.get(ns_sym)<EOL>if ns:<EOL><INDENT>return ns.find(name_sym)<EOL><DEDENT>return None<EOL>", "docstring": "Return the value current bound to the name `name_sym` in the namespace\n        specified by `ns_sym`.", "id": "f1057:c1:m18"}
{"signature": "def _collect_args(args) -> ISeq:", "body": "if isinstance(args, tuple):<EOL><INDENT>return llist.list(args)<EOL><DEDENT>raise TypeError(\"<STR_LIT>\")<EOL>", "docstring": "Collect Python starred arguments into a Basilisp list.", "id": "f1057:m41"}
{"signature": "def rest(o) -> Optional[ISeq]:", "body": "if o is None:<EOL><INDENT>return None<EOL><DEDENT>if isinstance(o, ISeq):<EOL><INDENT>s = o.rest<EOL>if s is None:<EOL><INDENT>return lseq.EMPTY<EOL><DEDENT>return s<EOL><DEDENT>n = to_seq(o)<EOL>if n is None:<EOL><INDENT>return lseq.EMPTY<EOL><DEDENT>return n.rest<EOL>", "docstring": "If o is a ISeq, return the elements after the first in o. If o is None,\n    returns an empty seq. Otherwise, coerces o to a seq and returns the rest.", "id": "f1057:m2"}
{"signature": "@property<EOL><INDENT>def interns(self) -> VarMap:<DEDENT>", "body": "return self._interns.deref()<EOL>", "docstring": "A mapping between a symbolic name and a Var. The Var may point to\n        code, data, or nothing, if it is unbound. Vars in `interns` are\n        interned in _this_ namespace.", "id": "f1057:c2:m8"}
{"signature": "def set_current_ns(<EOL>ns_name: str,<EOL>module: types.ModuleType = None,<EOL>ns_var_name: str = NS_VAR_NAME,<EOL>ns_var_ns: str = NS_VAR_NS,<EOL>) -> Var:", "body": "symbol = sym.Symbol(ns_name)<EOL>ns = Namespace.get_or_create(symbol, module=module)<EOL>ns_var_sym = sym.Symbol(ns_var_name, ns=ns_var_ns)<EOL>ns_var = Maybe(Var.find(ns_var_sym)).or_else_raise(<EOL>lambda: RuntimeException(<EOL>f\"<STR_LIT>\"<EOL>)<EOL>)<EOL>ns_var.push_bindings(ns)<EOL>logger.debug(f\"<STR_LIT>\")<EOL>return ns_var<EOL>", "docstring": "Set the value of the dynamic variable `*ns*` in the current thread.", "id": "f1057:m47"}
{"signature": "@staticmethod<EOL><INDENT>def __get_or_create(<EOL>ns_cache: NamespaceMap,<EOL>name: sym.Symbol,<EOL>module: types.ModuleType = None,<EOL>core_ns_name=CORE_NS,<EOL>) -> lmap.Map:<DEDENT>", "body": "ns = ns_cache.entry(name, None)<EOL>if ns is not None:<EOL><INDENT>return ns_cache<EOL><DEDENT>new_ns = Namespace(name, module=module)<EOL>if name.name != core_ns_name:<EOL><INDENT>core_ns = ns_cache.entry(sym.symbol(core_ns_name), None)<EOL>assert core_ns is not None, \"<STR_LIT>\"<EOL>new_ns.refer_all(core_ns)<EOL><DEDENT>return ns_cache.assoc(name, new_ns)<EOL>", "docstring": "Private swap function used by `get_or_create` to atomically swap\n        the new namespace map into the global cache.", "id": "f1057:c2:m24"}
{"signature": "@staticmethod<EOL><INDENT>def __completion_matcher(text: str) -> CompletionMatcher:<DEDENT>", "body": "def is_match(entry: Tuple[sym.Symbol, Any]) -> bool:<EOL><INDENT>return entry[<NUM_LIT:0>].name.startswith(text)<EOL><DEDENT>return is_match<EOL>", "docstring": "Return a function which matches any symbol keys from map entries\n        against the given text.", "id": "f1057:c2:m28"}
{"signature": "def partial(f, *args):", "body": "@functools.wraps(f)<EOL>def partial_f(*inner_args):<EOL><INDENT>return f(*itertools.chain(args, inner_args))<EOL><DEDENT>return partial_f<EOL>", "docstring": "Return a function which is the partial application of f with args.", "id": "f1057:m16"}
{"signature": "@property<EOL><INDENT>def aliases(self) -> NamespaceMap:<DEDENT>", "body": "return self._aliases.deref()<EOL>", "docstring": "A mapping between a symbolic alias and another Namespace. The\n        fully qualified name of a namespace is also an alias for itself.", "id": "f1057:c2:m5"}
{"signature": "def first(o):", "body": "if o is None:<EOL><INDENT>return None<EOL><DEDENT>if isinstance(o, ISeq):<EOL><INDENT>return o.first<EOL><DEDENT>s = to_seq(o)<EOL>if s is None:<EOL><INDENT>return None<EOL><DEDENT>return s.first<EOL>", "docstring": "If o is a ISeq, return the first element from o. If o is None, return\n    None. Otherwise, coerces o to a Seq and returns the first.", "id": "f1057:m1"}
{"signature": "def resolve_var(s: sym.Symbol, ns: Optional[Namespace] = None) -> Optional[Var]:", "body": "return Var.find(resolve_alias(s, ns))<EOL>", "docstring": "Resolve the aliased symbol to a Var from the specified\n    namespace, or the current namespace if none is specified.", "id": "f1057:m52"}
{"signature": "@functools.singledispatch<EOL>def to_lisp(o, keywordize_keys: bool = True):", "body": "if not isinstance(o, (dict, frozenset, list, set, tuple)):<EOL><INDENT>return o<EOL><DEDENT>else:  <EOL><INDENT>return _to_lisp_backup(o, keywordize_keys=keywordize_keys)<EOL><DEDENT>", "docstring": "Recursively convert Python collections into Lisp collections.", "id": "f1057:m26"}
{"signature": "def get_import(self, sym: sym.Symbol) -> Optional[types.ModuleType]:", "body": "mod = self.imports.entry(sym, None)<EOL>if mod is None:<EOL><INDENT>alias = self.import_aliases.get(sym, None)<EOL>if alias is None:<EOL><INDENT>return None<EOL><DEDENT>return self.imports.entry(alias, None)<EOL><DEDENT>return mod<EOL>", "docstring": "Return the module if a moduled named by sym has been imported into\n        this Namespace, None otherwise.\n\n        First try to resolve a module directly with the given name. If no module\n        can be resolved, attempt to resolve the module using import aliases.", "id": "f1057:c2:m18"}
{"signature": "@staticmethod<EOL><INDENT>def find_safe(ns_qualified_sym: sym.Symbol) -> \"<STR_LIT>\":<DEDENT>", "body": "v = Var.find(ns_qualified_sym)<EOL>if v is None:<EOL><INDENT>raise RuntimeException(<EOL>f\"<STR_LIT>\"<EOL>)<EOL><DEDENT>return v<EOL>", "docstring": "Return the Var currently bound to the name in the namespace specified\n        by `ns_qualified_sym`. If no Var is bound to that name, raise an exception.\n\n        This is a utility method to return useful debugging information when code\n        refers to an invalid symbol at runtime.", "id": "f1057:c1:m20"}
{"signature": "def contains(coll, k):", "body": "if isinstance(coll, IAssociative):<EOL><INDENT>return coll.contains(k)<EOL><DEDENT>return k in coll<EOL>", "docstring": "Return true if o contains the key k.", "id": "f1057:m23"}
{"signature": "def update(m, k, f, *args):", "body": "if m is None:<EOL><INDENT>return lmap.Map.empty().assoc(k, f(None, *args))<EOL><DEDENT>if isinstance(m, IAssociative):<EOL><INDENT>old_v = m.entry(k)<EOL>new_v = f(old_v, *args)<EOL>return m.assoc(k, new_v)<EOL><DEDENT>raise TypeError(<EOL>f\"<STR_LIT>\"<EOL>)<EOL>", "docstring": "Updates the value for key k in associative data structure m with the return value from\n    calling f(old_v, *args). If m is None, use an empty map. If k is not in m, old_v will be\n    None.", "id": "f1057:m14"}
{"signature": "def get_alias(self, alias: sym.Symbol) -> \"<STR_LIT>\":", "body": "return self.aliases.entry(alias, None)<EOL>", "docstring": "Get the Namespace aliased by Symbol or None if it does not exist.", "id": "f1057:c2:m13"}
{"signature": "def sequence(s: Iterable) -> ISeq[Any]:", "body": "try:<EOL><INDENT>i = iter(s)<EOL>return _Sequence(i, next(i))<EOL><DEDENT>except StopIteration:<EOL><INDENT>return EMPTY<EOL><DEDENT>", "docstring": "Create a Sequence from Iterable s.", "id": "f1060:m0"}
{"signature": "def multifn(dispatch: DispatchFunction, default=None) -> MultiFunction[T]:", "body": "name = sym.symbol(dispatch.__qualname__, ns=dispatch.__module__)<EOL>return MultiFunction(name, dispatch, default)<EOL>", "docstring": "Decorator function which can be used to make Python multi functions.", "id": "f1061:m0"}
{"signature": "@property<EOL><INDENT>@abstractmethod<EOL>def is_assignable(self) -> bool:<DEDENT>", "body": "", "docstring": "True if this Node can be assigned in a set! form, False otherwise.", "id": "f1062:c2:m0"}
{"signature": "@property<EOL><INDENT>@abstractmethod<EOL>def op(self) -> NodeOp:<DEDENT>", "body": "", "docstring": "Enumerated keyword uniquely identifying this type of Node.\n\n        The type and NodeOp should always be in sync.\n\n        Having a simple enum value in addition to the type allows us to use\n        switch-like syntax with Python dictionaries in compiler code, which\n        is much faster than performing isinstance checks.", "id": "f1062:c1:m0"}
{"signature": "def visit_Expr(self, node: ast.Expr) -> Optional[ast.Expr]:", "body": "if isinstance(<EOL>node.value,<EOL>(<EOL>ast.Constant,  <EOL>ast.Name,<EOL>ast.NameConstant,<EOL>ast.Num,<EOL>ast.Str,<EOL>),<EOL>):<EOL><INDENT>return None<EOL><DEDENT>return node<EOL>", "docstring": "Eliminate no-op constant expressions which are in the tree\n        as standalone statements.", "id": "f1063:c0:m1"}
{"signature": "def visit_While(self, node: ast.While) -> Optional[ast.AST]:", "body": "new_node = self.generic_visit(node)<EOL>assert isinstance(new_node, ast.While)<EOL>return ast.copy_location(<EOL>ast.While(<EOL>test=new_node.test,<EOL>body=_filter_dead_code(new_node.body),<EOL>orelse=_filter_dead_code(new_node.orelse),<EOL>),<EOL>new_node,<EOL>)<EOL>", "docstring": "Eliminate dead code from while bodies.", "id": "f1063:c0:m4"}
{"signature": "def _with_loc(f: ParseFunction):", "body": "@wraps(f)<EOL>def _parse_form(ctx: ParserContext, form: Union[LispForm, ISeq]) -> Node:<EOL><INDENT>form_loc = _loc(form)<EOL>if form_loc is None:<EOL><INDENT>return f(ctx, form)<EOL><DEDENT>else:<EOL><INDENT>return f(ctx, form).fix_missing_locations(form_loc)<EOL><DEDENT><DEDENT>return _parse_form<EOL>", "docstring": "Attach any available location information from the input form to\n    the node environment returned from the parsing function.", "id": "f1064:m3"}
{"signature": "def _assert_recur_is_tail(node: Node) -> None:  ", "body": "if node.op == NodeOp.DO:<EOL><INDENT>assert isinstance(node, Do)<EOL>for child in node.statements:<EOL><INDENT>_assert_no_recur(child)<EOL><DEDENT>_assert_recur_is_tail(node.ret)<EOL><DEDENT>elif node.op in {NodeOp.FN, NodeOp.FN_METHOD, NodeOp.METHOD}:<EOL><INDENT>assert isinstance(node, (Fn, FnMethod, Method))<EOL>node.visit(_assert_recur_is_tail)<EOL><DEDENT>elif node.op == NodeOp.IF:<EOL><INDENT>assert isinstance(node, If)<EOL>_assert_no_recur(node.test)<EOL>_assert_recur_is_tail(node.then)<EOL>_assert_recur_is_tail(node.else_)<EOL><DEDENT>elif node.op in {NodeOp.LET, NodeOp.LETFN}:<EOL><INDENT>assert isinstance(node, (Let, LetFn))<EOL>for binding in node.bindings:<EOL><INDENT>assert binding.init is not None<EOL>_assert_no_recur(binding.init)<EOL><DEDENT>_assert_recur_is_tail(node.body)<EOL><DEDENT>elif node.op == NodeOp.LOOP:<EOL><INDENT>assert isinstance(node, Loop)<EOL>for binding in node.bindings:<EOL><INDENT>assert binding.init is not None<EOL>_assert_no_recur(binding.init)<EOL><DEDENT><DEDENT>elif node.op == NodeOp.RECUR:<EOL><INDENT>pass<EOL><DEDENT>elif node.op == NodeOp.TRY:<EOL><INDENT>assert isinstance(node, Try)<EOL>_assert_recur_is_tail(node.body)<EOL>for catch in node.catches:<EOL><INDENT>_assert_recur_is_tail(catch)<EOL><DEDENT>if node.finally_:<EOL><INDENT>_assert_no_recur(node.finally_)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>node.visit(_assert_no_recur)<EOL><DEDENT>", "docstring": "Assert that `recur` forms only appear in the tail position of this\n    or child AST nodes.\n\n    `recur` forms may only appear in `do` nodes (both literal and synthetic\n    `do` nodes) and in either the :then or :else expression of an `if` node.", "id": "f1064:m25"}
{"signature": "def parse_ast(ctx: ParserContext, form: ReaderForm) -> Node:", "body": "return _parse_ast(ctx, form).assoc(top_level=True)<EOL>", "docstring": "Take a Lisp form as an argument and produce a Basilisp syntax\n    tree matching the clojure.tools.analyzer AST spec.", "id": "f1064:m46"}
{"signature": "def put_new_symbol(  <EOL>self,<EOL>s: sym.Symbol,<EOL>binding: Binding,<EOL>warn_on_shadowed_name: bool = True,<EOL>warn_on_shadowed_var: bool = True,<EOL>warn_if_unused: bool = True,<EOL>):", "body": "st = self.symbol_table<EOL>if warn_on_shadowed_name and self.warn_on_shadowed_name:<EOL><INDENT>if st.find_symbol(s) is not None:<EOL><INDENT>logger.warning(f\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if (<EOL>warn_on_shadowed_name or warn_on_shadowed_var<EOL>) and self.warn_on_shadowed_var:<EOL><INDENT>if self.current_ns.find(s) is not None:<EOL><INDENT>logger.warning(f\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if s.meta is not None and s.meta.entry(SYM_NO_WARN_WHEN_UNUSED_META_KEY, None):<EOL><INDENT>warn_if_unused = False<EOL><DEDENT>st.new_symbol(s, binding, warn_if_unused=warn_if_unused)<EOL>", "docstring": "Add a new symbol to the symbol table.\n\n        This function allows individual warnings to be disabled for one run\n        by supplying keyword arguments temporarily disabling those warnings.\n        In certain cases, we do not want to issue warnings again for a\n        previously checked case, so this is a simple way of disabling these\n        warnings for those cases.\n\n        If WARN_ON_SHADOWED_NAME compiler option is active and the\n        warn_on_shadowed_name keyword argument is True, then a warning will be\n        emitted if a local name is shadowed by another local name. Note that\n        WARN_ON_SHADOWED_NAME implies WARN_ON_SHADOWED_VAR.\n\n        If WARN_ON_SHADOWED_VAR compiler option is active and the\n        warn_on_shadowed_var keyword argument is True, then a warning will be\n        emitted if a named var is shadowed by a local name.", "id": "f1064:c3:m13"}
{"signature": "def _with_meta(gen_node):", "body": "@wraps(gen_node)<EOL>def with_meta(<EOL>ctx: ParserContext,<EOL>form: Union[llist.List, lmap.Map, ISeq, lset.Set, vec.Vector],<EOL>) -> Node:<EOL><INDENT>assert not ctx.is_quoted, \"<STR_LIT>\"<EOL>descriptor = gen_node(ctx, form)<EOL>if isinstance(form, IMeta):<EOL><INDENT>assert isinstance(form.meta, (lmap.Map, type(None)))<EOL>form_meta = _clean_meta(form.meta)<EOL>if form_meta is not None:<EOL><INDENT>meta_ast = _parse_ast(ctx, form_meta)<EOL>assert isinstance(meta_ast, MapNode) or (<EOL>isinstance(meta_ast, Const) and meta_ast.type == ConstType.MAP<EOL>)<EOL>return WithMeta(<EOL>form=form, meta=meta_ast, expr=descriptor, env=ctx.get_node_env()<EOL>)<EOL><DEDENT><DEDENT>return descriptor<EOL><DEDENT>return with_meta<EOL>", "docstring": "Wraps the node generated by gen_node in a :with-meta AST node if the\n    original form has meta.\n\n    :with-meta AST nodes are used for non-quoted collection literals and for\n    function expressions.", "id": "f1064:m5"}
{"signature": "def _is_macro(v: Var) -> bool:", "body": "return (<EOL>Maybe(v.meta)<EOL>.map(lambda m: m.entry(SYM_MACRO_META_KEY, None))  <EOL>.or_else_get(False)<EOL>)<EOL>", "docstring": "Return True if the Var holds a macro function.", "id": "f1064:m1"}
{"signature": "def compile_module(<EOL>forms: Iterable[ReaderForm],<EOL>ctx: CompilerContext,<EOL>module: types.ModuleType,<EOL>collect_bytecode: Optional[BytecodeCollector] = None,<EOL>) -> None:", "body": "_bootstrap_module(ctx.generator_context, ctx.py_ast_optimizer, module)<EOL>for form in forms:<EOL><INDENT>nodes = gen_py_ast(ctx.generator_context, parse_ast(ctx.parser_context, form))<EOL>_incremental_compile_module(<EOL>ctx.py_ast_optimizer,<EOL>nodes,<EOL>module,<EOL>source_filename=ctx.filename,<EOL>collect_bytecode=collect_bytecode,<EOL>)<EOL><DEDENT>", "docstring": "Compile an entire Basilisp module into Python bytecode which can be\n    executed as a Python module.\n\n    This function is designed to generate bytecode which can be used for the\n    Basilisp import machinery, to allow callers to import Basilisp modules from\n    Python code.", "id": "f1066:m5"}
{"signature": "def gen_py_ast(ctx: GeneratorContext, lisp_ast: Node) -> GeneratedPyAST:", "body": "op: NodeOp = lisp_ast.op<EOL>assert op is not None, \"<STR_LIT>\"<EOL>handle_node = _NODE_HANDLERS.get(op)<EOL>assert (<EOL>handle_node is not None<EOL>), f\"<STR_LIT>\"<EOL>return handle_node(ctx, lisp_ast)<EOL>", "docstring": "Take a Lisp AST node as an argument and produce zero or more Python\n    AST nodes.\n\n    This is the primary entrypoint for generating AST nodes from Lisp\n    syntax. It may be called recursively to compile child forms.", "id": "f1067:m80"}
{"signature": "@_with_ast_loc<EOL>def _quote_to_py_ast(ctx: GeneratorContext, node: Quote) -> GeneratedPyAST:", "body": "assert node.op == NodeOp.QUOTE<EOL>return _const_node_to_py_ast(ctx, node.expr)<EOL>", "docstring": "Return a Python AST Node for a `quote` expression.", "id": "f1067:m34"}
{"signature": "def __fn_name(s: Optional[str]) -> str:", "body": "return genname(\"<STR_LIT>\" + munge(Maybe(s).or_else_get(_FN_PREFIX)))<EOL>", "docstring": "Generate a safe Python function name from a function name symbol.\n    If no symbol is provided, generate a name with a default prefix.", "id": "f1067:m19"}
{"signature": "@property<EOL><INDENT>def use_var_indirection(self) -> bool:<DEDENT>", "body": "return self._opts.entry(USE_VAR_INDIRECTION, False)<EOL>", "docstring": "If True, compile all variable references using Var.find indirection.", "id": "f1067:c4:m3"}
{"signature": "@_with_ast_loc<EOL>def _local_sym_to_py_ast(<EOL>ctx: GeneratorContext, node: Local, is_assigning: bool = False<EOL>) -> GeneratedPyAST:", "body": "assert node.op == NodeOp.LOCAL<EOL>sym_entry = ctx.symbol_table.find_symbol(sym.symbol(node.name))<EOL>assert sym_entry is not None<EOL>if node.local == LocalType.FIELD:<EOL><INDENT>this_entry = ctx.symbol_table.find_symbol(ctx.current_this)<EOL>assert this_entry is not None, \"<STR_LIT>\"<EOL>return GeneratedPyAST(<EOL>node=_load_attr(<EOL>f\"<STR_LIT>\",<EOL>ctx=ast.Store() if is_assigning else ast.Load(),<EOL>)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>return GeneratedPyAST(<EOL>node=ast.Name(<EOL>id=sym_entry.munged, ctx=ast.Store() if is_assigning else ast.Load()<EOL>)<EOL>)<EOL><DEDENT>", "docstring": "Generate a Python AST node for accessing a locally defined Python variable.", "id": "f1067:m43"}
{"signature": "def statementize(e: ast.AST) -> ast.AST:", "body": "<EOL>if isinstance(<EOL>e,<EOL>(<EOL>ast.Assign,<EOL>ast.AnnAssign,<EOL>ast.AugAssign,<EOL>ast.Expr,<EOL>ast.Raise,<EOL>ast.Assert,<EOL>ast.Pass,<EOL>ast.Import,<EOL>ast.ImportFrom,<EOL>ast.If,<EOL>ast.For,<EOL>ast.While,<EOL>ast.Continue,<EOL>ast.Break,<EOL>ast.Try,<EOL>ast.ExceptHandler,<EOL>ast.With,<EOL>ast.FunctionDef,<EOL>ast.Return,<EOL>ast.Yield,<EOL>ast.YieldFrom,<EOL>ast.Global,<EOL>ast.ClassDef,<EOL>ast.AsyncFunctionDef,<EOL>ast.AsyncFor,<EOL>ast.AsyncWith,<EOL>),<EOL>):<EOL><INDENT>return e<EOL><DEDENT>return ast.Expr(value=e)<EOL>", "docstring": "Transform non-statements into ast.Expr nodes so they can\n    stand alone as statements.", "id": "f1067:m10"}
{"signature": "@_with_ast_loc_deps<EOL>def _if_to_py_ast(ctx: GeneratorContext, node: If) -> GeneratedPyAST:", "body": "assert node.op == NodeOp.IF<EOL>test_ast = gen_py_ast(ctx, node.test)<EOL>result_name = genname(_IF_RESULT_PREFIX)<EOL>then_ast = __if_body_to_py_ast(ctx, node.then, result_name)<EOL>else_ast = __if_body_to_py_ast(ctx, node.else_, result_name)<EOL>test_name = genname(_IF_TEST_PREFIX)<EOL>test_assign = ast.Assign(<EOL>targets=[ast.Name(id=test_name, ctx=ast.Store())], value=test_ast.node<EOL>)<EOL>ifstmt = ast.If(<EOL>test=ast.BoolOp(<EOL>op=ast.Or(),<EOL>values=[<EOL>ast.Compare(<EOL>left=ast.NameConstant(None),<EOL>ops=[ast.Is()],<EOL>comparators=[ast.Name(id=test_name, ctx=ast.Load())],<EOL>),<EOL>ast.Compare(<EOL>left=ast.NameConstant(False),<EOL>ops=[ast.Is()],<EOL>comparators=[ast.Name(id=test_name, ctx=ast.Load())],<EOL>),<EOL>],<EOL>),<EOL>values=[],<EOL>body=list(map(statementize, chain(else_ast.dependencies, [else_ast.node]))),<EOL>orelse=list(map(statementize, chain(then_ast.dependencies, [then_ast.node]))),<EOL>)<EOL>return GeneratedPyAST(<EOL>node=ast.Name(id=result_name, ctx=ast.Load()),<EOL>dependencies=list(chain(test_ast.dependencies, [test_assign, ifstmt])),<EOL>)<EOL>", "docstring": "Generate an intermediate if statement which assigns to a temporary\n    variable, which is returned as the expression value at the end of\n    evaluation.\n\n    Every expression in Basilisp is true if it is not the literal values nil\n    or false. This function compiles direct checks for the test value against\n    the Python values None and False to accommodate this behavior.\n\n    Note that the if and else bodies are switched in compilation so that we\n    can perform a short-circuit or comparison, rather than exhaustively checking\n    for both false and nil each time.", "id": "f1067:m29"}
{"signature": "@_with_ast_loc_deps<EOL>def __multi_arity_fn_to_py_ast(  <EOL>ctx: GeneratorContext,<EOL>node: Fn,<EOL>methods: Collection[FnMethod],<EOL>def_name: Optional[str] = None,<EOL>meta_node: Optional[MetaNode] = None,<EOL>) -> GeneratedPyAST:", "body": "assert node.op == NodeOp.FN<EOL>assert all([method.op == NodeOp.FN_METHOD for method in methods])<EOL>lisp_fn_name = node.local.name if node.local is not None else None<EOL>py_fn_name = __fn_name(lisp_fn_name) if def_name is None else munge(def_name)<EOL>py_fn_node = ast.AsyncFunctionDef if node.is_async else ast.FunctionDef<EOL>arity_to_name = {}<EOL>rest_arity_name: Optional[str] = None<EOL>fn_defs = []<EOL>for method in methods:<EOL><INDENT>arity_name = f\"<STR_LIT>\"<EOL>if method.is_variadic:<EOL><INDENT>rest_arity_name = arity_name<EOL><DEDENT>else:<EOL><INDENT>arity_to_name[method.fixed_arity] = arity_name<EOL><DEDENT>with ctx.new_symbol_table(arity_name), ctx.new_recur_point(<EOL>method.loop_id, RecurType.FN, is_variadic=node.is_variadic<EOL>):<EOL><INDENT>if lisp_fn_name is not None:<EOL><INDENT>ctx.symbol_table.new_symbol(<EOL>sym.symbol(lisp_fn_name), py_fn_name, LocalType.FN<EOL>)<EOL><DEDENT>fn_args, varg, fn_body_ast = __fn_args_to_py_ast(<EOL>ctx, method.params, method.body<EOL>)<EOL>fn_defs.append(<EOL>py_fn_node(<EOL>name=arity_name,<EOL>args=ast.arguments(<EOL>args=fn_args,<EOL>kwarg=None,<EOL>vararg=varg,<EOL>kwonlyargs=[],<EOL>defaults=[],<EOL>kw_defaults=[],<EOL>),<EOL>body=fn_body_ast,<EOL>decorator_list=[_TRAMPOLINE_FN_NAME]<EOL>if ctx.recur_point.has_recur<EOL>else [],<EOL>returns=None,<EOL>)<EOL>)<EOL><DEDENT><DEDENT>dispatch_fn_ast = __multi_arity_dispatch_fn(<EOL>ctx,<EOL>py_fn_name,<EOL>arity_to_name,<EOL>default_name=rest_arity_name,<EOL>max_fixed_arity=node.max_fixed_arity,<EOL>meta_node=meta_node,<EOL>is_async=node.is_async,<EOL>)<EOL>return GeneratedPyAST(<EOL>node=dispatch_fn_ast.node,<EOL>dependencies=list(chain(fn_defs, dispatch_fn_ast.dependencies)),<EOL>)<EOL>", "docstring": "Return a Python AST node for a function with multiple arities.", "id": "f1067:m26"}
{"signature": "@property<EOL><INDENT>def warn_on_var_indirection(self) -> bool:<DEDENT>", "body": "return not self.use_var_indirection and self._opts.entry(<EOL>WARN_ON_VAR_INDIRECTION, True<EOL>)<EOL>", "docstring": "If True, warn when a Var reference cannot be direct linked (iff\n        use_var_indirection is False)..", "id": "f1067:c4:m4"}
{"signature": "def __var_find_to_py_ast(<EOL>var_name: str, ns_name: str, py_var_ctx: ast.AST<EOL>) -> GeneratedPyAST:", "body": "return GeneratedPyAST(<EOL>node=ast.Attribute(<EOL>value=ast.Call(<EOL>func=_FIND_VAR_FN_NAME,<EOL>args=[<EOL>ast.Call(<EOL>func=_NEW_SYM_FN_NAME,<EOL>args=[ast.Str(var_name)],<EOL>keywords=[ast.keyword(arg=\"<STR_LIT>\", value=ast.Str(ns_name))],<EOL>)<EOL>],<EOL>keywords=[],<EOL>),<EOL>attr=\"<STR_LIT:value>\",<EOL>ctx=py_var_ctx,<EOL>)<EOL>)<EOL>", "docstring": "Generate Var.find calls for the named symbol.", "id": "f1067:m44"}
{"signature": "def _is_redefable(v: Var) -> bool:", "body": "return (<EOL>Maybe(v.meta)<EOL>.map(lambda m: m.get(SYM_REDEF_META_KEY, None))  <EOL>.or_else_get(False)<EOL>)<EOL>", "docstring": "Return True if the Var can be redefined.", "id": "f1067:m9"}
{"signature": "def _load_attr(name: str, ctx: ast.AST = ast.Load()) -> ast.Attribute:", "body": "attrs = name.split(\"<STR_LIT:.>\")<EOL>def attr_node(node, idx):<EOL><INDENT>if idx >= len(attrs):<EOL><INDENT>node.ctx = ctx<EOL>return node<EOL><DEDENT>return attr_node(<EOL>ast.Attribute(value=node, attr=attrs[idx], ctx=ast.Load()), idx + <NUM_LIT:1><EOL>)<EOL><DEDENT>return attr_node(ast.Name(id=attrs[<NUM_LIT:0>], ctx=ast.Load()), <NUM_LIT:1>)<EOL>", "docstring": "Generate recursive Python Attribute AST nodes for resolving nested\n    names.", "id": "f1067:m1"}
{"signature": "def py_module_preamble(ctx: GeneratorContext,) -> GeneratedPyAST:", "body": "preamble: List[ast.AST] = []<EOL>preamble.extend(_module_imports(ctx))<EOL>preamble.append(_from_module_import())<EOL>preamble.append(_ns_var())<EOL>return GeneratedPyAST(node=ast.NameConstant(None), dependencies=preamble)<EOL>", "docstring": "Bootstrap a new module with imports and other boilerplate.", "id": "f1067:m84"}
{"signature": "@_with_ast_loc<EOL>def _maybe_host_form_to_py_ast(<EOL>_: GeneratorContext, node: MaybeHostForm<EOL>) -> GeneratedPyAST:", "body": "assert node.op == NodeOp.MAYBE_HOST_FORM<EOL>return GeneratedPyAST(<EOL>node=_load_attr(<EOL>f\"<STR_LIT>\"<EOL>)<EOL>)<EOL>", "docstring": "Generate a Python AST node for accessing a potential Python module\n    variable name with a namespace.", "id": "f1067:m49"}
{"signature": "def _with_meta_to_py_ast(<EOL>ctx: GeneratorContext, node: WithMeta, **kwargs<EOL>) -> GeneratedPyAST:", "body": "assert node.op == NodeOp.WITH_META<EOL>handle_expr = _WITH_META_EXPR_HANDLER.get(node.expr.op)<EOL>assert (<EOL>handle_expr is not None<EOL>), \"<STR_LIT>\"<EOL>return handle_expr(ctx, node.expr, meta_node=node.meta, **kwargs)<EOL>", "docstring": "Generate a Python AST node for Python interop method calls.", "id": "f1067:m57"}
{"signature": "@_with_ast_loc<EOL>def _set_bang_to_py_ast(ctx: GeneratorContext, node: SetBang) -> GeneratedPyAST:", "body": "assert node.op == NodeOp.SET_BANG<EOL>val_temp_name = genname(\"<STR_LIT>\")<EOL>val_ast = gen_py_ast(ctx, node.val)<EOL>target = node.target<EOL>assert isinstance(<EOL>target, (HostField, Local, VarRef)<EOL>), f\"<STR_LIT>\"<EOL>if isinstance(target, HostField):<EOL><INDENT>target_ast = _interop_prop_to_py_ast(ctx, target, is_assigning=True)<EOL><DEDENT>elif isinstance(target, VarRef):<EOL><INDENT>target_ast = _var_sym_to_py_ast(ctx, target, is_assigning=True)<EOL><DEDENT>elif isinstance(target, Local):<EOL><INDENT>target_ast = _local_sym_to_py_ast(ctx, target, is_assigning=True)<EOL><DEDENT>else:  <EOL><INDENT>raise GeneratorException(<EOL>f\"<STR_LIT>\", lisp_ast=target<EOL>)<EOL><DEDENT>return GeneratedPyAST(<EOL>node=ast.Name(id=val_temp_name, ctx=ast.Load()),<EOL>dependencies=list(<EOL>chain(<EOL>val_ast.dependencies,<EOL>[<EOL>ast.Assign(<EOL>targets=[ast.Name(id=val_temp_name, ctx=ast.Store())],<EOL>value=val_ast.node,<EOL>)<EOL>],<EOL>target_ast.dependencies,<EOL>[ast.Assign(targets=[target_ast.node], value=val_ast.node)],<EOL>)<EOL>),<EOL>)<EOL>", "docstring": "Return a Python AST Node for a `set!` expression.", "id": "f1067:m39"}
{"signature": "@_with_ast_loc_deps<EOL>def _import_to_py_ast(ctx: GeneratorContext, node: Import) -> GeneratedPyAST:", "body": "assert node.op == NodeOp.IMPORT<EOL>last = None<EOL>deps: List[ast.AST] = []<EOL>for alias in node.aliases:<EOL><INDENT>safe_name = munge(alias.name)<EOL>try:<EOL><INDENT>module = importlib.import_module(safe_name)<EOL>if alias.alias is not None:<EOL><INDENT>ctx.add_import(sym.symbol(alias.name), module, sym.symbol(alias.alias))<EOL><DEDENT>else:<EOL><INDENT>ctx.add_import(sym.symbol(alias.name), module)<EOL><DEDENT><DEDENT>except ModuleNotFoundError as e:<EOL><INDENT>raise ImportError(<EOL>f\"<STR_LIT>\", node.form, node<EOL>) from e<EOL><DEDENT>py_import_alias = (<EOL>munge(alias.alias)<EOL>if alias.alias is not None<EOL>else safe_name.split(\"<STR_LIT:.>\", maxsplit=<NUM_LIT:1>)[<NUM_LIT:0>]<EOL>)<EOL>deps.append(<EOL>ast.Assign(<EOL>targets=[ast.Name(id=py_import_alias, ctx=ast.Store())],<EOL>value=ast.Call(<EOL>func=_load_attr(\"<STR_LIT>\"),<EOL>args=[ast.Str(safe_name)],<EOL>keywords=[],<EOL>),<EOL>)<EOL>)<EOL>last = ast.Name(id=py_import_alias, ctx=ast.Load())<EOL>deps.append(<EOL>ast.Call(<EOL>func=_load_attr(f\"<STR_LIT>\"),<EOL>args=[<EOL>ast.Call(<EOL>func=_NEW_SYM_FN_NAME, args=[ast.Str(safe_name)], keywords=[]<EOL>),<EOL>last,<EOL>],<EOL>keywords=[],<EOL>)<EOL>)<EOL><DEDENT>assert last is not None, \"<STR_LIT>\"<EOL>return GeneratedPyAST(node=last, dependencies=deps)<EOL>", "docstring": "Return a Python AST node for a Basilisp `import*` expression.", "id": "f1067:m30"}
{"signature": "def map(kvs: Mapping[K, V], meta=None) -> Map[K, V]:  ", "body": "return Map(pmap(initial=kvs), meta=meta)<EOL>", "docstring": "Creates a new map.", "id": "f1072:m0"}
{"signature": "def m(**kvs) -> Map[str, V]:", "body": "return Map(pmap(initial=kvs))<EOL>", "docstring": "Creates a new map from keyword arguments.", "id": "f1072:m1"}
{"signature": "def _read_meta(ctx: ReaderContext) -> IMeta:", "body": "start = ctx.reader.advance()<EOL>assert start == \"<STR_LIT>\"<EOL>meta = _read_next_consuming_comment(ctx)<EOL>meta_map: Optional[lmap.Map[LispForm, LispForm]] = None<EOL>if isinstance(meta, symbol.Symbol):<EOL><INDENT>meta_map = lmap.map({keyword.keyword(\"<STR_LIT>\"): meta})<EOL><DEDENT>elif isinstance(meta, keyword.Keyword):<EOL><INDENT>meta_map = lmap.map({meta: True})<EOL><DEDENT>elif isinstance(meta, lmap.Map):<EOL><INDENT>meta_map = meta<EOL><DEDENT>else:<EOL><INDENT>raise SyntaxError(<EOL>f\"<STR_LIT>\"<EOL>)<EOL><DEDENT>obj_with_meta = _read_next_consuming_comment(ctx)<EOL>try:<EOL><INDENT>return obj_with_meta.with_meta(meta_map)  <EOL><DEDENT>except AttributeError:<EOL><INDENT>raise SyntaxError(<EOL>f\"<STR_LIT>\"<EOL>)<EOL><DEDENT>", "docstring": "Read metadata and apply that to the next object in the\n    input stream.", "id": "f1073:m19"}
{"signature": "def _read_reader_macro(ctx: ReaderContext) -> LispReaderForm:", "body": "start = ctx.reader.advance()<EOL>assert start == \"<STR_LIT:#>\"<EOL>token = ctx.reader.peek()<EOL>if token == \"<STR_LIT:{>\":<EOL><INDENT>return _read_set(ctx)<EOL><DEDENT>elif token == \"<STR_LIT:(>\":<EOL><INDENT>return _read_function(ctx)<EOL><DEDENT>elif token == \"<STR_LIT:'>\":<EOL><INDENT>ctx.reader.advance()<EOL>s = _read_sym(ctx)<EOL>return llist.l(_VAR, s)<EOL><DEDENT>elif token == '<STR_LIT:\">':<EOL><INDENT>return _read_regex(ctx)<EOL><DEDENT>elif token == \"<STR_LIT:_>\":<EOL><INDENT>ctx.reader.advance()<EOL>_read_next(ctx)  <EOL>return COMMENT<EOL><DEDENT>elif ns_name_chars.match(token):<EOL><INDENT>s = _read_sym(ctx)<EOL>assert isinstance(s, symbol.Symbol)<EOL>v = _read_next_consuming_comment(ctx)<EOL>if s in ctx.data_readers:<EOL><INDENT>f = ctx.data_readers[s]<EOL>return f(v)<EOL><DEDENT>else:<EOL><INDENT>raise SyntaxError(f\"<STR_LIT>\")<EOL><DEDENT><DEDENT>raise SyntaxError(f\"<STR_LIT>\")<EOL>", "docstring": "Return a data structure evaluated as a reader\n    macro from the input stream.", "id": "f1073:m31"}
{"signature": "@_with_loc<EOL>def _read_map(ctx: ReaderContext) -> lmap.Map:", "body": "reader = ctx.reader<EOL>start = reader.advance()<EOL>assert start == \"<STR_LIT:{>\"<EOL>d: MutableMapping[Any, Any] = {}<EOL>while True:<EOL><INDENT>if reader.peek() == \"<STR_LIT:}>\":<EOL><INDENT>reader.next_token()<EOL>break<EOL><DEDENT>k = _read_next(ctx)<EOL>if k is COMMENT:<EOL><INDENT>continue<EOL><DEDENT>while True:<EOL><INDENT>if reader.peek() == \"<STR_LIT:}>\":<EOL><INDENT>raise SyntaxError(\"<STR_LIT>\")<EOL><DEDENT>v = _read_next(ctx)<EOL>if v is COMMENT:<EOL><INDENT>continue<EOL><DEDENT>if k in d:<EOL><INDENT>raise SyntaxError(f\"<STR_LIT>\")<EOL><DEDENT>break<EOL><DEDENT>d[k] = v<EOL><DEDENT>return lmap.map(d)<EOL>", "docstring": "Return a map from the input stream.", "id": "f1073:m14"}
{"signature": "def _read_regex(ctx: ReaderContext) -> Pattern:", "body": "s = _read_str(ctx, allow_arbitrary_escapes=True)<EOL>try:<EOL><INDENT>return langutil.regex_from_str(s)<EOL><DEDENT>except re.error:<EOL><INDENT>raise SyntaxError(f\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Read a regex reader macro from the input stream.", "id": "f1073:m30"}
{"signature": "def peek(self) -> str:", "body": "return self._buffer[self._idx]<EOL>", "docstring": "Peek at the next character in the stream.", "id": "f1073:c2:m5"}
{"signature": "def _read_namespaced(<EOL>ctx: ReaderContext, allowed_suffix: Optional[str] = None<EOL>) -> Tuple[Optional[str], str]:", "body": "ns: List[str] = []<EOL>name: List[str] = []<EOL>reader = ctx.reader<EOL>has_ns = False<EOL>while True:<EOL><INDENT>token = reader.peek()<EOL>if token == \"<STR_LIT:/>\":<EOL><INDENT>reader.next_token()<EOL>if has_ns:<EOL><INDENT>raise SyntaxError(\"<STR_LIT>\")<EOL><DEDENT>elif len(name) == <NUM_LIT:0>:<EOL><INDENT>name.append(\"<STR_LIT:/>\")<EOL><DEDENT>else:<EOL><INDENT>if \"<STR_LIT:/>\" in name:<EOL><INDENT>raise SyntaxError(\"<STR_LIT>\")<EOL><DEDENT>has_ns = True<EOL>ns = name<EOL>name = []<EOL><DEDENT><DEDENT>elif ns_name_chars.match(token):<EOL><INDENT>reader.next_token()<EOL>name.append(token)<EOL><DEDENT>elif allowed_suffix is not None and token == allowed_suffix:<EOL><INDENT>reader.next_token()<EOL>name.append(token)<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>ns_str = None if not has_ns else \"<STR_LIT>\".join(ns)<EOL>name_str = \"<STR_LIT>\".join(name)<EOL>if ns_str is None:<EOL><INDENT>if \"<STR_LIT:/>\" in name_str and name_str != \"<STR_LIT:/>\":<EOL><INDENT>raise SyntaxError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>assert ns_str is None or len(ns_str) > <NUM_LIT:0><EOL>return ns_str, name_str<EOL>", "docstring": "Read a namespaced token from the input stream.", "id": "f1073:m8"}
{"signature": "def _is_unquote(form: ReaderForm) -> bool:", "body": "try:<EOL><INDENT>return form.first == _UNQUOTE  <EOL><DEDENT>except AttributeError:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Return True if this form is unquote.", "id": "f1073:m22"}
{"signature": "def _update_loc(self, c):", "body": "if newline_chars.match(c):<EOL><INDENT>self._col.append(<NUM_LIT:0>)<EOL>self._line.append(self._line[-<NUM_LIT:1>] + <NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>self._col.append(self._col[-<NUM_LIT:1>] + <NUM_LIT:1>)<EOL>self._line.append(self._line[-<NUM_LIT:1>])<EOL><DEDENT>", "docstring": "Update the internal line and column buffers after a new character\n        is added.\n\n        The column number is set to 0, so the first character on the next line\n        is column number 1.", "id": "f1073:c2:m4"}
{"signature": "def _read_coll(<EOL>ctx: ReaderContext,<EOL>f: Callable[[Collection[Any]], Union[llist.List, lset.Set, vector.Vector]],<EOL>end_token: str,<EOL>coll_name: str,<EOL>):", "body": "coll: List = []<EOL>reader = ctx.reader<EOL>while True:<EOL><INDENT>token = reader.peek()<EOL>if token == \"<STR_LIT>\":<EOL><INDENT>raise SyntaxError(f\"<STR_LIT>\")<EOL><DEDENT>if whitespace_chars.match(token):<EOL><INDENT>reader.advance()<EOL>continue<EOL><DEDENT>if token == end_token:<EOL><INDENT>reader.next_token()<EOL>return f(coll)<EOL><DEDENT>elem = _read_next(ctx)<EOL>if elem is COMMENT:<EOL><INDENT>continue<EOL><DEDENT>coll.append(elem)<EOL><DEDENT>", "docstring": "Read a collection from the input stream and create the\n    collection using f.", "id": "f1073:m9"}
{"signature": "def symbol(name: str, ns: Optional[str] = None, meta=None) -> Symbol:", "body": "return Symbol(name, ns=ns, meta=meta)<EOL>", "docstring": "Create a new symbol.", "id": "f1074:m0"}
{"signature": "def v(*members: T, meta: Optional[IPersistentMap] = None) -> Vector[T]:", "body": "return Vector(pvector(members), meta=meta)<EOL>", "docstring": "Creates a new vector from members.", "id": "f1075:m1"}
{"signature": "def _dec_print_level(lvl: PrintCountSetting):", "body": "if isinstance(lvl, int):<EOL><INDENT>return lvl - <NUM_LIT:1><EOL><DEDENT>return lvl<EOL>", "docstring": "Decrement the print level if it is numeric.", "id": "f1076:m0"}
{"signature": "@abstractmethod<EOL><INDENT>def _lrepr(self, **kwargs) -> str:<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "Private Lisp representation method. Callers (including object\n        internal callers) should not call this method directly, but instead\n        should use the module function .lrepr().", "id": "f1076:c0:m2"}
{"signature": "def _process_kwargs(**kwargs):", "body": "return dict(kwargs, print_level=_dec_print_level(kwargs[\"<STR_LIT>\"]))<EOL>", "docstring": "Process keyword arguments, decreasing the print-level. Should be called\n    after examining the print level for the current level.", "id": "f1076:m1"}
{"signature": "def _lrepr_fallback(  <EOL>o: Any,<EOL>human_readable: bool = False,<EOL>print_dup: bool = PRINT_DUP,<EOL>print_length: PrintCountSetting = PRINT_LENGTH,<EOL>print_level: PrintCountSetting = PRINT_LEVEL,<EOL>print_meta: bool = PRINT_META,<EOL>print_readably: bool = PRINT_READABLY,<EOL>) -> str:  ", "body": "kwargs = {<EOL>\"<STR_LIT>\": human_readable,<EOL>\"<STR_LIT>\": print_dup,<EOL>\"<STR_LIT>\": print_length,<EOL>\"<STR_LIT>\": print_level,<EOL>\"<STR_LIT>\": print_meta,<EOL>\"<STR_LIT>\": print_readably,<EOL>}<EOL>if isinstance(o, bool):<EOL><INDENT>return _lrepr_bool(o)<EOL><DEDENT>elif o is None:<EOL><INDENT>return _lrepr_nil(o)<EOL><DEDENT>elif isinstance(o, str):<EOL><INDENT>return _lrepr_str(<EOL>o, human_readable=human_readable, print_readably=print_readably<EOL>)<EOL><DEDENT>elif isinstance(o, dict):<EOL><INDENT>return _lrepr_py_dict(o, **kwargs)<EOL><DEDENT>elif isinstance(o, list):<EOL><INDENT>return _lrepr_py_list(o, **kwargs)<EOL><DEDENT>elif isinstance(o, set):<EOL><INDENT>return _lrepr_py_set(o, **kwargs)<EOL><DEDENT>elif isinstance(o, tuple):<EOL><INDENT>return _lrepr_py_tuple(o, **kwargs)<EOL><DEDENT>elif isinstance(o, complex):<EOL><INDENT>return _lrepr_complex(o)<EOL><DEDENT>elif isinstance(o, datetime.datetime):<EOL><INDENT>return _lrepr_datetime(o)<EOL><DEDENT>elif isinstance(o, Decimal):<EOL><INDENT>return _lrepr_decimal(o, print_dup=print_dup)<EOL><DEDENT>elif isinstance(o, Fraction):<EOL><INDENT>return _lrepr_fraction(o)<EOL><DEDENT>elif isinstance(o, Pattern):<EOL><INDENT>return _lrepr_pattern(o)<EOL><DEDENT>elif isinstance(o, uuid.UUID):<EOL><INDENT>return _lrepr_uuid(o)<EOL><DEDENT>else:<EOL><INDENT>return repr(o)<EOL><DEDENT>", "docstring": "Fallback function for lrepr for subclasses of standard types.\n\n    The singledispatch used for standard lrepr dispatches using an exact\n    type match on the first argument, so we will only hit this function\n    for subclasses of common Python types like strings or lists.", "id": "f1076:m5"}
{"signature": "def s(*members: T, meta=None) -> Set[T]:", "body": "return Set(pset(members), meta=meta)<EOL>", "docstring": "Creates a new set from members.", "id": "f1079:m1"}
{"signature": "def eval_stream(stream, ctx: compiler.CompilerContext, module: types.ModuleType):", "body": "last = None<EOL>for form in reader.read(stream, resolver=runtime.resolve_alias):<EOL><INDENT>last = compiler.compile_and_exec_form(form, ctx, module)<EOL><DEDENT>return last<EOL>", "docstring": "Evaluate the forms in stdin into a Python module AST node.", "id": "f1080:m2"}
{"signature": "def eval_str(s: str, ctx: compiler.CompilerContext, module: types.ModuleType, eof: Any):", "body": "last = eof<EOL>for form in reader.read_str(s, resolver=runtime.resolve_alias, eof=eof):<EOL><INDENT>last = compiler.compile_and_exec_form(form, ctx, module)<EOL><DEDENT>return last<EOL>", "docstring": "Evaluate the forms in a string into a Python module AST node.", "id": "f1080:m3"}
{"signature": "def init():", "body": "runtime.init_ns_var()<EOL>runtime.bootstrap()<EOL>importer.hook_imports()<EOL>importlib.import_module(\"<STR_LIT>\")<EOL>", "docstring": "Initialize the runtime environment for evaluation.", "id": "f1082:m0"}
{"signature": "def collect(self):", "body": "_reset_collected_tests()<EOL>filename = self.fspath.basename<EOL>self.fspath.pyimport()<EOL>ns = _current_ns()<EOL>tests = _collected_tests()<EOL>assert tests is not None, \"<STR_LIT>\"<EOL>for test in tests:<EOL><INDENT>f: TestFunction = test.value<EOL>yield BasilispTestItem(test.name.name, self, f, ns, filename)<EOL><DEDENT>", "docstring": "Collect all of the tests in the namespace (module) given.\n\n        Basilisp's test runner imports the namespace which will (as a side\n        effect) collect all of the test functions in a namespace (represented\n        by `deftest` forms in Basilisp) into an atom in `basilisp.test`.\n        BasilispFile.collect fetches those test functions and generates\n        BasilispTestItems for PyTest to run the tests.", "id": "f1083:c1:m0"}
{"signature": "def _current_ns() -> str:", "body": "var = Maybe(runtime.Var.find(_CURRENT_NS_SYM)).or_else_raise(<EOL>lambda: runtime.RuntimeException(f\"<STR_LIT>\")<EOL>)<EOL>ns = var.value.deref()<EOL>return ns.name<EOL>", "docstring": "Fetch the current namespace from basilisp.test/current-ns.", "id": "f1083:m2"}
{"signature": "def repr_failure(self, excinfo):", "body": "if isinstance(excinfo.value, TestFailuresInfo):<EOL><INDENT>exc = excinfo.value<EOL>failures = exc.data.entry(_FAILURES_KW)<EOL>messages = []<EOL>for details in failures:<EOL><INDENT>type_ = details.entry(_TYPE_KW)<EOL>if type_ == _FAILURE_KW:<EOL><INDENT>messages.append(self._failure_msg(details))<EOL><DEDENT>elif type_ == _ERROR_KW:<EOL><INDENT>exc = details.entry(_ACTUAL_KW)<EOL>line = details.entry(_LINE_KW)<EOL>messages.append(self._error_msg(exc, line=line))<EOL><DEDENT>else:<EOL><INDENT>assert False, \"<STR_LIT>\"<EOL><DEDENT><DEDENT>return \"<STR_LIT>\".join(messages)<EOL><DEDENT>elif isinstance(excinfo.value, Exception):<EOL><INDENT>return self._error_msg(excinfo.value)<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Representation function called when self.runtest() raises an\n        exception.", "id": "f1083:c2:m2"}
{"signature": "@staticmethod<EOL><INDENT>def status(s):<DEDENT>", "body": "print(\"<STR_LIT>\".format(s))<EOL>", "docstring": "Prints things in bold.", "id": "f1086:c0:m0"}
{"signature": "def get_interaction_energy(ampal_objs, ff=None, assign_ff=True):", "body": "if ff is None:<EOL><INDENT>ff = FORCE_FIELDS['<STR_LIT>']<EOL><DEDENT>if assign_ff:<EOL><INDENT>for ampal_obj in ampal_objs:<EOL><INDENT>assign_force_field(ampal_obj, ff)<EOL><DEDENT><DEDENT>interactions = find_inter_ampal(ampal_objs, ff.distance_cutoff)<EOL>buff_score = score_interactions(interactions, ff)<EOL>return buff_score<EOL>", "docstring": "Calculates the interaction energy between AMPAL objects.\n\n    Parameters\n    ----------\n    ampal_objs: [AMPAL Object]\n        A list of any AMPAL objects with `get_atoms` methods.\n    ff: BuffForceField, optional\n        The force field to be used for scoring. If no force field is\n        provided then the most current version of the BUDE force field\n        will be used.\n    assign_ff: bool, optional\n        If true, then force field assignment on the AMPAL object will be\n        will be updated.\n\n    Returns\n    -------\n    BUFF_score: BUFFScore\n        A BUFFScore object with information about each of the interactions and\n        the atoms involved.", "id": "f1089:m0"}
{"signature": "def find_max_rad_npnp(self):", "body": "max_rad = <NUM_LIT:0><EOL>max_npnp = <NUM_LIT:0><EOL>for res, _ in self.items():<EOL><INDENT>if res != '<STR_LIT>':<EOL><INDENT>for _, ff_params in self[res].items():<EOL><INDENT>if max_rad < ff_params[<NUM_LIT:1>]:<EOL><INDENT>max_rad = ff_params[<NUM_LIT:1>]<EOL><DEDENT>if max_npnp < ff_params[<NUM_LIT:4>]:<EOL><INDENT>max_npnp = ff_params[<NUM_LIT:4>]<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return max_rad, max_npnp<EOL>", "docstring": "Finds the maximum radius and npnp in the force field.\n\n        Returns\n        -------\n        (max_rad, max_npnp): (float, float)\n            Maximum radius and npnp distance in the loaded force field.", "id": "f1090:c2:m6"}
{"signature": "def assign_force_field(ampal_obj, ff):", "body": "if hasattr(ampal_obj, '<STR_LIT>'):<EOL><INDENT>atoms = ampal_obj.get_atoms(ligands=True, inc_alt_states=True)<EOL><DEDENT>else:<EOL><INDENT>atoms = ampal_obj.get_atoms(inc_alt_states=True)<EOL><DEDENT>for atom in atoms:<EOL><INDENT>w_str = None<EOL>a_ff_id = None<EOL>if atom.element == '<STR_LIT:H>':<EOL><INDENT>continue<EOL><DEDENT>elif atom.parent.mol_code.upper() in ff:<EOL><INDENT>if atom.res_label.upper() in ff[atom.parent.mol_code]:<EOL><INDENT>a_ff_id = (atom.parent.mol_code.upper(),<EOL>atom.res_label.upper())<EOL><DEDENT>elif atom.res_label.upper() in ff['<STR_LIT>']:<EOL><INDENT>a_ff_id = ('<STR_LIT>', atom.res_label.upper())<EOL><DEDENT>else:<EOL><INDENT>w_str = ('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>').format(<EOL>atom.res_label, atom.parent.mol_code)<EOL><DEDENT><DEDENT>elif atom.res_label.upper() in ff['<STR_LIT>']:<EOL><INDENT>a_ff_id = ('<STR_LIT>', atom.res_label.upper())<EOL><DEDENT>else:<EOL><INDENT>w_str = ('<STR_LIT>'<EOL>'<STR_LIT>').format(<EOL>atom.res_label, atom.parent.mol_code)<EOL><DEDENT>if w_str:<EOL><INDENT>warnings.warn(w_str, NotParameterisedWarning)<EOL><DEDENT>atom.tags['<STR_LIT>'] = a_ff_id<EOL><DEDENT>return<EOL>", "docstring": "Assigns force field parameters to Atoms in the AMPAL object.\n\n    Parameters\n    ----------\n    ampal_obj : AMPAL Object\n        Any AMPAL object with a `get_atoms` method.\n    ff: BuffForceField\n        The force field to be used for scoring.", "id": "f1090:m0"}
{"signature": "def get_method_owner(meth):", "body": "if inspect.ismethod(meth):<EOL><INDENT>if sys.version_info < (<NUM_LIT:3>,<NUM_LIT:0>):<EOL><INDENT>return meth.im_class if meth.im_self is None else meth.im_self<EOL><DEDENT>else:<EOL><INDENT>return meth.__self__<EOL><DEDENT><DEDENT>", "docstring": "Returns the instance owning the supplied instancemethod or\nthe class owning the supplied classmethod.", "id": "f1093:m2"}
{"signature": "def named_objs(objlist):", "body": "objs = []<EOL>for k, obj in objlist:<EOL><INDENT>if hasattr(k, '<STR_LIT>'):<EOL><INDENT>k = k.__name__<EOL><DEDENT>else:<EOL><INDENT>k = as_unicode(k)<EOL><DEDENT>objs.append((k, obj))<EOL><DEDENT>return objs<EOL>", "docstring": "Given a list of objects, returns a dictionary mapping from\nstring name for the object to the object itself.", "id": "f1093:m1"}
{"signature": "def notebook_show(obj, doc, comm):", "body": "target = obj.ref['<STR_LIT:id>']<EOL>load_mime = '<STR_LIT>'<EOL>exec_mime = '<STR_LIT>'<EOL>bokeh_script, bokeh_div, _ = bokeh.embed.notebook.notebook_content(obj, comm.id)<EOL>publish_display_data(data={'<STR_LIT>': encode_utf8(bokeh_div)})<EOL>JS = '<STR_LIT:\\n>'.join([PYVIZ_PROXY, JupyterCommManager.js_manager])<EOL>publish_display_data(data={load_mime: JS, '<STR_LIT>': JS})<EOL>msg_handler = bokeh_msg_handler.format(plot_id=target)<EOL>comm_js = comm.js_template.format(plot_id=target, comm_id=comm.id, msg_handler=msg_handler)<EOL>bokeh_js = '<STR_LIT:\\n>'.join([comm_js, bokeh_script])<EOL>publish_display_data(data={exec_mime: '<STR_LIT>', '<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': bokeh_js},<EOL>metadata={exec_mime: {'<STR_LIT:id>': target}})<EOL>", "docstring": "Displays bokeh output inside a notebook.", "id": "f1096:m0"}
{"signature": "def copy(self, obj_id, folder_id, move=False):", "body": "if folder_id.startswith('<STR_LIT>'):<EOL><INDENT>log.info( '<STR_LIT>'<EOL>'<STR_LIT>' )<EOL>folder_id = self.info(folder_id)['<STR_LIT:id>']<EOL><DEDENT>return super(OneDriveAPI, self).copy(obj_id, folder_id, move=move)<EOL>", "docstring": "Copy specified file (object) to a folder.\n                Note that folders cannot be copied, this is an API limitation.", "id": "f1114:c11:m3"}
{"signature": "def put( self, path_or_tuple, folder_id='<STR_LIT>',<EOL>overwrite=None, downsize=None, bits_api_fallback=True ):", "body": "api_overwrite = self._translate_api_flag(overwrite, '<STR_LIT>', ['<STR_LIT>'])<EOL>api_downsize = self._translate_api_flag(downsize, '<STR_LIT>')<EOL>name, src = self._process_upload_source(path_or_tuple)<EOL>if not isinstance(bits_api_fallback, (int, float, long)):<EOL><INDENT>bits_api_fallback = bool(bits_api_fallback)<EOL><DEDENT>if bits_api_fallback is not False:<EOL><INDENT>if bits_api_fallback is True: bits_api_fallback = self.api_put_max_bytes<EOL>src.seek(<NUM_LIT:0>, os.SEEK_END)<EOL>if src.tell() >= bits_api_fallback:<EOL><INDENT>if bits_api_fallback > <NUM_LIT:0>: <EOL><INDENT>log.info(<EOL>'<STR_LIT>',<EOL>*((float(v) / <NUM_LIT:2>**<NUM_LIT:20>) for v in [src.tell(), bits_api_fallback]) )<EOL><DEDENT>if overwrite is not None and api_overwrite != '<STR_LIT:true>':<EOL><INDENT>raise NoAPISupportError( '<STR_LIT>'<EOL>'<STR_LIT>'.format(overwrite) )<EOL><DEDENT>if downsize is not None:<EOL><INDENT>log.info( '<STR_LIT>'<EOL>'<STR_LIT>', downsize )<EOL><DEDENT>file_id = self.put_bits(path_or_tuple, folder_id=folder_id) <EOL>return self.info(file_id)<EOL><DEDENT><DEDENT>return self( self._api_url_join(folder_id, '<STR_LIT>', name),<EOL>dict(overwrite=api_overwrite, downsize_photo_uploads=api_downsize),<EOL>data=src, method='<STR_LIT>', auth_header=True )<EOL>", "docstring": "Upload a file (object), possibly overwriting (default behavior)\n                        a file with the same \"name\" attribute, if it exists.\n\n                First argument can be either path to a local file or tuple\n                        of \"(name, file)\", where \"file\" can be either a file-like object\n                        or just a string of bytes.\n\n                overwrite option can be set to False to allow two identically-named\n                        files or \"ChooseNewName\" to let OneDrive derive some similar\n                        unique name. Behavior of this option mimics underlying API.\n\n                downsize is a true/false API flag, similar to overwrite.\n\n                bits_api_fallback can be either True/False or an integer (number of\n                        bytes), and determines whether method will fall back to using BITS API\n                        (as implemented by \"put_bits\" method) for large files. Default \"True\"\n                        (bool) value will use non-BITS file size limit (api_put_max_bytes, ~100 MiB)\n                        as a fallback threshold, passing False will force using single-request uploads.", "id": "f1114:c10:m11"}
{"signature": "def get_quota(self):", "body": "return op.itemgetter('<STR_LIT>', '<STR_LIT>')(super(OneDriveAPI, self).get_quota())<EOL>", "docstring": "Return tuple of (bytes_available, bytes_quota).", "id": "f1114:c11:m1"}
{"signature": "def auth_user_process_url(self, url):", "body": "url = urlparse.urlparse(url)<EOL>url_qs = dict(it.chain.from_iterable(<EOL>urlparse.parse_qsl(v) for v in [url.query, url.fragment] ))<EOL>if url_qs.get('<STR_LIT:error>'):<EOL><INDENT>raise APIAuthError(<EOL>'<STR_LIT>'.format(url_qs['<STR_LIT:error>'], url_qs.get('<STR_LIT>')) )<EOL><DEDENT>self.auth_code = url_qs['<STR_LIT:code>']<EOL>return self.auth_code<EOL>", "docstring": "Process tokens and errors from redirect_uri.", "id": "f1114:c9:m2"}
{"signature": "def info(self, obj_id='<STR_LIT>'):", "body": "return self(obj_id)<EOL>", "docstring": "Return metadata of a specified object.\n                See http://msdn.microsoft.com/en-us/library/live/hh243648.aspx\n                        for the list and description of metadata keys for each object type.", "id": "f1114:c10:m9"}
{"signature": "def info_update(self, obj_id, data):", "body": "return self(obj_id, method='<STR_LIT>', data=data, auth_header=True)<EOL>", "docstring": "Update metadata with of a specified object.\n                See http://msdn.microsoft.com/en-us/library/live/hh243648.aspx\n                        for the list of RW keys for each object type.", "id": "f1114:c10:m15"}
{"signature": "@classmethod<EOL><INDENT>def from_conf(cls, path=None, **overrides):<DEDENT>", "body": "from onedrive import portalocker<EOL>import yaml<EOL>if path is None:<EOL><INDENT>path = cls.conf_path_default<EOL>log.debug('<STR_LIT>', path)<EOL><DEDENT>path = os.path.expanduser(path)<EOL>with open(path, '<STR_LIT:rb>') as src:<EOL><INDENT>portalocker.lock(src, portalocker.LOCK_SH)<EOL>yaml_str = src.read()<EOL>portalocker.unlock(src)<EOL><DEDENT>conf = yaml.safe_load(yaml_str)<EOL>conf.setdefault('<STR_LIT>', path)<EOL>conf_cls = dict()<EOL>for ns, keys in cls.conf_update_keys.viewitems():<EOL><INDENT>for k in keys:<EOL><INDENT>try:<EOL><INDENT>v = conf.get(ns, dict()).get(k)<EOL><DEDENT>except AttributeError:<EOL><INDENT>if not cls.conf_raise_structure_errors: raise<EOL>raise KeyError((<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' ).format(ns=ns, k=k, path=path))<EOL><DEDENT>if v is not None: conf_cls['<STR_LIT>'.format(ns, k)] = conf[ns][k]<EOL><DEDENT><DEDENT>conf_cls.update(overrides)<EOL>if isinstance(conf.get('<STR_LIT>', dict()).get('<STR_LIT:id>'), (int, long)):<EOL><INDENT>log.warn( '<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>', path )<EOL>cid = conf['<STR_LIT>']['<STR_LIT:id>']<EOL>if not re.search(r'<STR_LIT>'.format(cid), yaml_str)and re.search(r'<STR_LIT>'.format(cid), yaml_str):<EOL><INDENT>cid = int('<STR_LIT>'.format(cid))<EOL><DEDENT>conf['<STR_LIT>']['<STR_LIT:id>'] = '<STR_LIT>'.format(cid)<EOL><DEDENT>self = cls(**conf_cls)<EOL>self.conf_save = conf['<STR_LIT>']<EOL>return self<EOL>", "docstring": "Initialize instance from YAML configuration file,\n                writing updates (only to keys, specified by \"conf_update_keys\") back to it.", "id": "f1117:c0:m1"}
{"signature": "def update_session_headers(session):", "body": "session.headers.update({<EOL>'<STR_LIT:Content-Type>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'<EOL>})<EOL>return session<EOL>", "docstring": "Add content type header to the session.\n\n:param: requests.sessions.Session session: A session.\n:return: A session with modified headers.\n:rtype: requests.sessions.Session", "id": "f1126:m2"}
{"signature": "def set_delivery_system(self, store, postcode, fulfilment_method=FULFILMENT_METHOD.DELIVERY):", "body": "method = '<STR_LIT>' if fulfilment_method == FULFILMENT_METHOD.DELIVERY else '<STR_LIT>'<EOL>params = {<EOL>'<STR_LIT>': method,<EOL>'<STR_LIT>': postcode,<EOL>'<STR_LIT>': store.store_id<EOL>}<EOL>return self.__post('<STR_LIT>', json=params)<EOL>", "docstring": "Set local cookies by initialising the delivery system on the remote.\nRequires a store ID and a delivery postcode.\n\n:param Store store: Store id.\n:param string postcode: A postcode.\n:return: A response having initialised the delivery system.\n:rtype: requests.Response", "id": "f1129:c0:m5"}
{"signature": "def get_nearest_store(self, postcode):", "body": "return self.get_stores(postcode).local_store<EOL>", "docstring": "Search for domino pizza stores using a postcode. This will only search\nfor local stores indicating delivery status and payment details.\n\n:param string postcode: A postcode.\n:return: A response containing stores matching the postcode.\n:rtype: requests.Response", "id": "f1129:c0:m4"}
{"signature": "def get_basket(self):", "body": "response = self.__get('<STR_LIT>')<EOL>return Basket(response.json())<EOL>", "docstring": "Retrieve the basket for the current session.\n\n:return: A response containing the basket for the current session.\n:rtype: requests.Response", "id": "f1129:c0:m7"}
{"signature": "def add_pizza_to_basket(self, item, variant=VARIANT.MEDIUM, quantity=<NUM_LIT:1>):", "body": "item_variant = item[variant]<EOL>ingredients = item_variant['<STR_LIT>'].update([<NUM_LIT>, <NUM_LIT>])<EOL>params = {<EOL>'<STR_LIT>': <NUM_LIT:0>,<EOL>'<STR_LIT>': quantity,<EOL>'<STR_LIT>': variant,<EOL>'<STR_LIT>': item.item_id,<EOL>'<STR_LIT>': ingredients,<EOL>'<STR_LIT>': <NUM_LIT:0>,<EOL>'<STR_LIT>': [],<EOL>'<STR_LIT>': <NUM_LIT:0><EOL>}<EOL>return self.__post('<STR_LIT>', json=params)<EOL>", "docstring": "Add a pizza to the current basket.\n\n:param Item item: Item from menu.\n:param int variant: Item SKU id. Some defaults are defined in the VARIANT enum.\n:param int quantity: The quantity of pizza to be added.\n:return: A response having added a pizza to the current basket.\n:rtype: requests.Response", "id": "f1129:c0:m9"}
{"signature": "def readme():", "body": "with open('<STR_LIT>') as infile:<EOL><INDENT>return infile.read()<EOL><DEDENT>", "docstring": "Read README file", "id": "f1130:m0"}
{"signature": "def seek(self, offset, whence=<NUM_LIT:0>):", "body": "if self.closed:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if whence == SEEK_SET:<EOL><INDENT>pos = offset<EOL><DEDENT>elif whence == SEEK_CUR:<EOL><INDENT>pos = self.pos + offset<EOL><DEDENT>elif whence == SEEK_END:<EOL><INDENT>pos = self.size + offset<EOL><DEDENT>if not <NUM_LIT:0> <= pos <= self.size:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(pos, self.size))<EOL><DEDENT>self.pos = pos<EOL>return self.pos<EOL>", "docstring": "Same as `file.seek()` but for the slice. Returns a value between\n`self.start` and `self.size` inclusive.\n\nraises:\n    ValueError if the new seek position is not between 0 and\n    `self.size`.", "id": "f1132:c1:m3"}
{"signature": "@property<EOL><INDENT>def end(self):<DEDENT>", "body": "return self.start + self.size - <NUM_LIT:1><EOL>", "docstring": "The end position of the slice. The slice will not read or write if the\nnew position is ahead of this value.", "id": "f1132:c1:m1"}
{"signature": "def __exit__(self, exc_type, exc_value, exc_tb):", "body": "<EOL>if self._debug >= <NUM_LIT:1> and exc_type is not None:<EOL><INDENT>traceback.print_exception(exc_type, exc_value, exc_tb,<EOL>file=sys.stderr)<EOL>sys.exit('<STR_LIT>' %<EOL>(self.method, self.ext_cls.__module__,<EOL>self.ext_cls.__name__))<EOL>return False<EOL><DEDENT>self.ext_cls = None<EOL>return exc_type and issubclass(exc_type, Exception)<EOL>", "docstring": "Called upon exit from the context manager.  Implements the\ndebugging output.\n\n:param exc_type: The exception type.  If no exception was\n                 generated, will be ``None``.\n:param exc_value: The exception value.  If no exception was\n                  generated, will be ``None``.\n:param exc_tb: The exception traceback.  If no exception was\n               generated, will be ``None``.\n\n:returns: A ``True`` value if any exception should be ignored,\n          ``False`` otherwise.  Will return ``True`` for all\n          ``Exception`` subclasses unless debugging is\n          enabled.", "id": "f1144:c1:m2"}
{"signature": "@classmethod<EOL><INDENT>def _get_extension_classes(cls):<DEDENT>", "body": "if cls._extension_classes is None:<EOL><INDENT>exts = {}<EOL>for ext in entry.points[NAMESPACE_EXTENSIONS]:<EOL><INDENT>exts.setdefault(ext.priority, [])<EOL>exts[ext.priority].append(ext)<EOL><DEDENT>cls._extension_classes = list(utils.iter_prio_dict(exts))<EOL><DEDENT>return cls._extension_classes<EOL>", "docstring": "Retrieve the extension classes in priority order.\n\n:returns: A list of extension classes, in proper priority\n          order.", "id": "f1144:c2:m0"}
{"signature": "def post_step(self, ctxt, step, idx, result):", "body": "debugger = ExtensionDebugger('<STR_LIT>')<EOL>for ext in self.exts:<EOL><INDENT>with debugger(ext):<EOL><INDENT>ext.post_step(ctxt, step, idx, result)<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Called after executing a step.\n\n:param ctxt: An instance of ``timid.context.Context``.\n:param step: An instance of ``timid.steps.Step`` describing\n             the step that was executed.\n:param idx: The index of the step in the list of steps.\n:param result: An instance of ``timid.steps.StepResult``\n               describing the result of executing the step.\n               May be altered by the extension, e.g., to set\n               the ``ignore`` attribute.\n\n:returns: The ``result`` parameter, for convenience.", "id": "f1144:c2:m6"}
{"signature": "def read_steps(self, ctxt, steps):", "body": "pass<EOL>", "docstring": "Called after reading steps, prior to adding them to the list of\ntest steps.  This allows an extension to alter the list (in\nplace).\n\n:param ctxt: An instance of ``timid.context.Context``.\n:param steps: A list of ``timid.steps.Step`` instances.", "id": "f1144:c0:m2"}
{"signature": "def __init__(self, method):", "body": "<EOL>self.method = method<EOL>self.ext_cls = None<EOL>debug = os.environ.get('<STR_LIT>')<EOL>if debug is None:<EOL><INDENT>self._debug = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>self._debug = max(<NUM_LIT:0>, int(debug))<EOL><DEDENT>except ValueError:<EOL><INDENT>self._debug = <NUM_LIT:1><EOL><DEDENT><DEDENT>self.debug(<NUM_LIT:2>, '<STR_LIT>' % self.method)<EOL>", "docstring": "Initialize an ``ExtensionDebugger`` instance.\n\n:param where: A string indicating the name of the extension\n              method that will be called.", "id": "f1144:c1:m0"}
{"signature": "@abc.abstractproperty<EOL><INDENT>def priority(self):<DEDENT>", "body": "pass<EOL>", "docstring": "An integer value.  This provides a primitive means of controlling\nthe order in which extensions will be called.  The higher the\nnumber, the later the modifier will be applied.\n\nThis must be a class attribute, not a property.", "id": "f1144:c0:m6"}
{"signature": "def pre_step(self, ctxt, step, idx):", "body": "return None<EOL>", "docstring": "Called prior to executing a step.\n\n:param ctxt: An instance of ``timid.context.Context``.\n:param step: An instance of ``timid.steps.Step`` describing\n             the step to be executed.\n:param idx: The index of the step in the list of steps.\n\n:returns: A ``True`` value if the step is to be skipped.  Any\n          ``False`` value (including ``None``) will result in\n          the step being executed as normal.", "id": "f1144:c0:m3"}
{"signature": "def read_steps(self, ctxt, steps):", "body": "debugger = ExtensionDebugger('<STR_LIT>')<EOL>for ext in self.exts:<EOL><INDENT>with debugger(ext):<EOL><INDENT>ext.read_steps(ctxt, steps)<EOL><DEDENT><DEDENT>return steps<EOL>", "docstring": "Called after reading steps, prior to adding them to the list of\ntest steps.  Extensions are able to alter the list (in place).\n\n:param ctxt: An instance of ``timid.context.Context``.\n:param steps: A list of ``timid.steps.Step`` instances.\n\n:returns: The ``steps`` parameter, for convenience.", "id": "f1144:c2:m4"}
{"signature": "def __init__(self, step_addr, action, modifiers=None, name=None,<EOL>description=None):", "body": "self.step_addr = step_addr<EOL>self.action = action<EOL>self.modifiers = modifiers or []<EOL>self.name = name or action.__class__.__name__<EOL>self.description = description<EOL>", "docstring": "Initialize a ``Step`` instance.\n\n:param step_addr: The address of the step in the test\n                  configuration.\n:param action: An ``Action`` instance.\n:param modifiers: A list of ``Modifier`` instances, in the\n                  order in which processing should be\n                  performed.  Optional.\n:param name: A name for the step.  Optional.\n:param description: A description of the step.  Optional.", "id": "f1145:c6:m2"}
{"signature": "def action_conf(self, ctxt, action_class, action_name, config, step_addr):", "body": "return config<EOL>", "docstring": "A modifier hook function.  This is called in priority order prior\nto initializing the ``Action`` for the step.  This allows a\nmodifier to alter the configuration to be fed to the action.\n\n:param ctxt: The context object.\n:param action_class: The ``Action`` subclass the modifier is\n                     modifying.  This method should not\n                     attempt to initialize the action.\n:param action_name: The name of the action.\n:param config: The configuration for the action.  This may be\n               a scalar value (e.g., \"run: command\"), a list,\n               or a dictionary.  If the configuration provided\n               is invalid for the action, a ``ConfigError``\n               should be raised.\n:param step_addr: The address of the step in the test\n                  configuration.  Should be passed to the\n                  ``ConfigError``.\n\n:returns: The configuration for the action, optionally\n          modified.  If the configuration is not modified,\n          ``config`` must be returned unchanged.  The default\n          implementation of this method does so.", "id": "f1145:c4:m0"}
{"signature": "@property<EOL><INDENT>def ignore(self):<DEDENT>", "body": "return self._ignore or False<EOL>", "docstring": "Determine whether an error result should be ignored.", "id": "f1145:c7:m2"}
{"signature": "def post_call(self, ctxt, result, action, post_mod, pre_mod):", "body": "return result<EOL>", "docstring": "A modifier hook function.  This is called in reverse-priority\norder after invoking the ``Action`` for the step.  This allows\na modifier to inspect or alter the result of the step.\n\n:param ctxt: The context object.\n:param result: The result of the action.  This will be a\n               ``StepResult`` object.\n:param action: The action that was performed.\n:param post_mod: A list of modifiers following this modifier\n                 in the list of modifiers that is applicable\n                 to the action.  This list is in priority\n                 order.\n:param pre_mod: A list of modifiers preceding this modifier in\n                the list of modifiers that is applicable to\n                the action.  This list is in priority order.\n\n:returns: The result for the action, optionally modified.  If\n          the result is not modified, ``result`` must be\n          returned unchanged.  The default implementation of\n          this method does so.", "id": "f1145:c4:m2"}
{"signature": "@abc.abstractproperty<EOL><INDENT>def priority(self):<DEDENT>", "body": "pass<EOL>", "docstring": "An integer value.  This provides a primitive means of controlling\nthe order of application of modifiers.  The higher the number,\nthe later the modifier will be applied.  The action has a\npriority equivalent to positive infinity.\n\nThis must be a class attribute, not a property.", "id": "f1145:c4:m3"}
{"signature": "def __init__(self, fname, idx, key=None):", "body": "self.fname = fname<EOL>self.idx = idx<EOL>self.key = key<EOL>self._str = None<EOL>", "docstring": "Initialize a ``StepAddress`` instance.\n\n:param fname: The file name of the YAML file.\n:param idx: The index of the step within the file, or within\n            the designated key of the file.\n:param key: A key within the file.  If the file consists of a\n            single list, this should be ``None`` (the\n            default).", "id": "f1145:c1:m0"}
{"signature": "def __init__(self, ctxt, name, config, step_addr):", "body": "<EOL>self.validate_conf(name, config, step_addr)<EOL>self.name = name<EOL>self.config = config<EOL>self.step_addr = step_addr<EOL>", "docstring": "Initialize the action or modifier.  This should process and store\nthe configuration provided.\n\n:param ctxt: The context object.\n:param name: The name.\n:param config: The configuration.  This may be a scalar value\n               (e.g., \"run: command\"), a list, or a\n               dictionary.  If the configuration provided is\n               invalid, a ``ConfigError`` should be raised.\n:param step_addr: The address of the step in the test\n                  configuration.  Should be passed to the\n                  ``ConfigError``.", "id": "f1145:c2:m0"}
{"signature": "def __init__(self, ctxt, name, config, step_addr):", "body": "<EOL>super(SensitiveDictAction, self).__init__(<EOL>ctxt, name, config, step_addr)<EOL>self.set_vars = {}<EOL>for key, value in config.get('<STR_LIT>', {}).items():<EOL><INDENT>self.set_vars[key] = ctxt.template(value)<EOL><DEDENT>self.unset_vars = set(config.get('<STR_LIT>', []))<EOL>self.sensitive_vars = set(config.get('<STR_LIT>', []))<EOL>self.files = [ctxt.template(fn) for fn in config.get('<STR_LIT>', [])]<EOL>self.dirname = os.path.dirname(step_addr.fname) or os.curdir<EOL>", "docstring": "Initialize a ``SensitiveDictAction`` instance.\n\n:param ctxt: The context object.\n:param name: The name of the action.\n:param config: The configuration for the action.  This may be\n               a scalar value (e.g., \"run: command\"), a list,\n               or a dictionary.  If the configuration provided\n               is invalid for the action, a ``ConfigError``\n               should be raised.\n:param step_addr: The address of the step in the test\n                  configuration.  Should be passed to the\n                  ``ConfigError``.", "id": "f1145:c8:m0"}
{"signature": "def init(self, ctxt, step_addr):", "body": "return self.cls(ctxt, self.name, self.conf, step_addr)<EOL>", "docstring": "Initialize the item.  This calls the class constructor with the\nappropriate arguments and returns the initialized object.\n\n:param ctxt: The context object.\n:param step_addr: The address of the step in the test\n                  configuration.", "id": "f1145:c5:m1"}
{"signature": "def __init__(self):", "body": "self._namespaces = {}<EOL>", "docstring": "Initialize an ``EntrypointCache``.", "id": "f1146:c1:m0"}
{"signature": "def __init__(self, namespace):", "body": "<EOL>self.namespace = namespace<EOL>self._entrypoints = {}<EOL>for ep in pkg_resources.iter_entry_points(namespace):<EOL><INDENT>self._entrypoints.setdefault(ep.name, [])<EOL>self._entrypoints[ep.name].append(ep)<EOL><DEDENT>self._epcache = {}<EOL>self._eplist = None<EOL>", "docstring": "Initialize a ``NamespaceCache``.\n\n:param namespace: The namespace to cache.", "id": "f1146:c0:m0"}
{"signature": "def __getitem__(self, name):", "body": "<EOL>if (name not in self._entrypoints or<EOL>self._epcache.get(name) is _unavailable):<EOL><INDENT>raise KeyError(name)<EOL><DEDENT>if name not in self._epcache:<EOL><INDENT>error = None<EOL>for ep in self._entrypoints[name]:<EOL><INDENT>try:<EOL><INDENT>self._epcache[name] = ep.load()<EOL><DEDENT>except (ImportError, AttributeError,<EOL>pkg_resources.UnknownExtra):<EOL><INDENT>if error is None:<EOL><INDENT>error = sys.exc_info()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self._epcache[name] = _unavailable<EOL>if error is None:<EOL><INDENT>raise KeyError(name)<EOL><DEDENT>six.reraise(*error)<EOL><DEDENT><DEDENT>return self._epcache[name]<EOL>", "docstring": "Retrieve the designated entrypoint object.\n\n:param name: The name of the entrypoint.\n\n:returns: The loaded object referenced by the entrypoint.", "id": "f1146:c0:m3"}
{"signature": "def __init__(self, verbose=<NUM_LIT:1>, debug=False, cwd=None):", "body": "<EOL>self.verbose = verbose<EOL>self.debug = debug<EOL>self.variables = utils.SensitiveDict()<EOL>self.environment = environment.Environment(cwd=cwd)<EOL>self.steps = []<EOL>self._jinja = jinja2.Environment()<EOL>self._jinja.globals['<STR_LIT>'] = self.environment<EOL>", "docstring": "Initialize a new ``Context`` instance.", "id": "f1147:c0:m0"}
{"signature": "def emit(self, msg, level=<NUM_LIT:1>, debug=False):", "body": "<EOL>if debug:<EOL><INDENT>if not self.debug:<EOL><INDENT>return<EOL><DEDENT>stream = sys.stderr<EOL><DEDENT>else:<EOL><INDENT>if self.verbose < level:<EOL><INDENT>return<EOL><DEDENT>stream = sys.stdout<EOL><DEDENT>print(msg, file=stream)<EOL>stream.flush()<EOL>", "docstring": "Emit a message to the user.\n\n:param msg: The message to emit.  If ``debug`` is ``True``,\n            the message will be emitted to ``stderr`` only if\n            the ``debug`` attribute is ``True``.  If ``debug``\n            is ``False``, the message will be emitted to\n            ``stdout`` under the control of the ``verbose``\n            attribute.\n:param level: Ignored if ``debug`` is ``True``.  The message\n              will only be emitted if the ``verbose``\n              attribute is greater than or equal to the value\n              of this parameter.  Defaults to 1.\n:param debug: If ``True``, marks the message as a debugging\n              message.  The message will only be emitted if\n              the ``debug`` attribute is ``True``.", "id": "f1147:c0:m1"}
{"signature": "def expression(self, string):", "body": "<EOL>if not isinstance(string, six.string_types):<EOL><INDENT>return lambda ctxt: string<EOL><DEDENT>expr = self._jinja.compile_expression(string)<EOL>return lambda ctxt: expr(ctxt.variables)<EOL>", "docstring": "Interpret an expression string.  This returns a callable taking\none argument--this context--and returning the result of\nevaluating the expression.\n\n:param string: The expression.\n\n:returns: A callable of one argument that will return the\n          desired expression.", "id": "f1147:c0:m3"}
{"signature": "def post_call(self, ctxt, result, action, post_mod, pre_mod):", "body": "<EOL>result.ignore = self.config<EOL>return result<EOL>", "docstring": "A modifier hook function.  This is called in reverse-priority\norder after invoking the ``Action`` for the step.  This allows\na modifier to inspect or alter the result of the step.\n\n:param ctxt: The context object.\n:param result: The result of the action.  This will be a\n               ``StepResult`` object.\n:param action: The action that was performed.\n:param post_mod: A list of modifiers following this modifier\n                 in the list of modifiers that is applicable\n                 to the action.  This list is in priority\n                 order.\n:param pre_mod: A list of modifiers preceding this modifier in\n                the list of modifiers that is applicable to\n                the action.  This list is in priority order.\n\n:returns: The result for the action, optionally modified.  If\n          the result is not modified, ``result`` must be\n          returned unchanged.  This implementation alters the\n          ``ignore`` property of the ``result`` object to\n          match the configured value.", "id": "f1148:c1:m0"}
{"signature": "def __init__(self, option_strings, dest, **kwargs):", "body": "<EOL>allow_type = kwargs.pop('<STR_LIT>', False)<EOL>super(DictAction, self).__init__(option_strings, dest, **kwargs)<EOL>self.allow_type = allow_type<EOL>", "docstring": "Initialize a ``DictAction`` object.\n\n:param option_strings: A list of option strings.\n:param dest: The target attribute to store the option values\n             in.\n:param allow_type: A boolean indicating whether the value type\n                   may be designated.  If ``False``, the value\n                   type is always treated as a string.", "id": "f1149:c0:m0"}
{"signature": "def add(self, item):", "body": "self._value.add(item)<EOL>self._rebuild()<EOL>", "docstring": "Add a new item to the ``SetVariable`` instance.\n\n:param item: The item to add.", "id": "f1150:c2:m2"}
{"signature": "@abc.abstractproperty<EOL><INDENT>def _type(self):<DEDENT>", "body": "pass<EOL>", "docstring": "The abstract type the value should be represented as, e.g.,\n``collections.Set`` or ``collections.Sequence``.", "id": "f1150:c0:m6"}
{"signature": "def declare_set(self, name, sep=os.pathsep):", "body": "self._declare_special(name, sep, SetVariable)<EOL>", "docstring": "Declare an environment variable as a set-like special variable.\nThis can be used even if the environment variable is not\npresent.\n\n:param name: The name of the environment variable that should\n             be considered set-like.\n:param sep: The separator to be used.  Defaults to the value\n            of ``os.pathsep``.", "id": "f1150:c3:m7"}
{"signature": "def _update(self, value):", "body": "if not value:<EOL><INDENT>value = self._coerce()<EOL><DEDENT>elif isinstance(value, six.string_types):<EOL><INDENT>value = self._coerce(value.split(self._sep))<EOL><DEDENT>else:<EOL><INDENT>value = self._coerce(value)<EOL><DEDENT>self._value = value<EOL>", "docstring": "Alert method used when the variable's value in an ``Environment``\ninstance has been altered.\n\n:param value: The new value to set the value to.", "id": "f1150:c0:m5"}
{"signature": "def __getitem__(self, name):", "body": "<EOL>if name not in self._data:<EOL><INDENT>raise KeyError(name)<EOL><DEDENT>if name in self._special:<EOL><INDENT>return self._special[name]<EOL><DEDENT>return self._data[name]<EOL>", "docstring": "Retrieve the value of a variable from the environment.  If the\nvariable has been declared as a list-like variable, the return\nvalue will be a list of strings; otherwise, it will be a\nstring.\n\n:param name: The name of the variable to retrieve.\n\n:returns: The value of the designated variable.", "id": "f1150:c3:m1"}
{"signature": "def __str__(self):", "body": "return self._env._data.get(self._var) or '<STR_LIT>'<EOL>", "docstring": "Obtain a string form of the ``EnvListVariable`` instance.\n\n:returns: The string form of the variable.", "id": "f1150:c0:m1"}
{"signature": "def __len__(self):", "body": "return len(self._value)<EOL>", "docstring": "Obtain the length of an ``EnvListVariable`` instance.\n\n:returns: The number of elements in the variable.", "id": "f1150:c0:m3"}
{"signature": "def __setitem__(self, idx, value):", "body": "self._value[idx] = value<EOL>self._rebuild()<EOL>", "docstring": "Set an item on the ``ListVariable`` instance.\n\n:param idx: The index or index-like object (e.g., slice) to\n            set.\n:param value: The value to set it to.", "id": "f1150:c1:m1"}
{"signature": "def __getitem__(self, idx):", "body": "return self._value[idx]<EOL>", "docstring": "Retrieve an item from a ``ListVariable`` instance.\n\n:param idx: The index or index-like object (e.g., slice) to\n            retrieve.\n\n:returns: The value at the designated index.", "id": "f1150:c1:m0"}
{"signature": "def __delitem__(self, idx):", "body": "del self._value[idx]<EOL>self._rebuild()<EOL>", "docstring": "Delete an item from the ``ListVariable`` instance.\n\n:param idx: The index or index-like object (e.g., slice) to\n            delete.", "id": "f1150:c1:m2"}
{"signature": "def __len__(self):", "body": "return len(self._parent)<EOL>", "docstring": "Obtain the length of a ``MaskedDict`` instance.\n\n:returns: The number of keys in the dictionary.", "id": "f1152:c1:m4"}
{"signature": "@property<EOL><INDENT>def sensitive(self):<DEDENT>", "body": "return frozenset(self._sensitive)<EOL>", "docstring": "Retrieve a set of the \"sensitive\" keys, keys for which the data\nshould be treated as sensitive.  This will be a copy;\nmodifications will not affect the set.", "id": "f1152:c0:m9"}
{"signature": "def copy(self):", "body": "return self.__class__(self._data.copy(), self._sensitive.copy())<EOL>", "docstring": "Retrieve a copy of the sensitive dictionary.  Note that this is a\nshallow copy.", "id": "f1152:c0:m7"}
{"signature": "def schema_validate(instance, schema, exc_class, *prefix, **kwargs):", "body": "try:<EOL><INDENT>jsonschema.validate(instance, schema)<EOL><DEDENT>except jsonschema.ValidationError as exc:<EOL><INDENT>path = '<STR_LIT:/>'.join((a if isinstance(a, six.string_types) else '<STR_LIT>' % a)<EOL>for a in itertools.chain(prefix, exc.path))<EOL>message = '<STR_LIT>' % (path, exc.message)<EOL>raise exc_class(message, **kwargs)<EOL><DEDENT>", "docstring": "Schema validation helper.  Performs JSONSchema validation.  If a\nschema validation error is encountered, an exception of the\ndesignated class is raised with the validation error message\nappropriately simplified and passed as the sole positional\nargument.\n\n:param instance: The object to schema validate.\n:param schema: The schema to use for validation.\n:param exc_class: The exception class to raise instead of the\n                  ``jsonschema.ValidationError`` exception.\n:param prefix: Positional arguments are interpreted as a list of\n               keys to prefix to the path contained in the\n               validation error.\n:param kwargs: Keyword arguments to pass to the exception\n               constructor.", "id": "f1152:m1"}
{"signature": "def canonicalize_path(cwd, path):", "body": "if not os.path.isabs(path):<EOL><INDENT>path = os.path.join(cwd, path)<EOL><DEDENT>return os.path.abspath(path)<EOL>", "docstring": "Canonicalizes a path relative to a given working directory.  That\nis, the path, if not absolute, is interpreted relative to the\nworking directory, then converted to absolute form.\n\n:param cwd: The working directory.\n:param path: The path to canonicalize.\n\n:returns: The absolute path.", "id": "f1152:m0"}
{"signature": "@property<EOL><INDENT>def sensitive(self):<DEDENT>", "body": "return self._parent.sensitive<EOL>", "docstring": "Retrieve a set of the \"sensitive\" keys, keys for which the data\nshould be treated as sensitive.  This will be a copy;\nmodifications will not affect the set.", "id": "f1152:c1:m7"}
{"signature": "def __str__(self):", "body": "return six.text_type(dict(self))<EOL>", "docstring": "Obtain a string form of a ``MaskedDict`` instance.\n\n:returns: The string form of the ``MaskedDict`` instance.", "id": "f1152:c1:m3"}
{"signature": "def assert_connected(self, conn, client):", "body": "self.assertIsInstance(conn.client_protocol, DummyClientProtocol)<EOL>self.assertEqual(conn.client_protocol.side, \"<STR_LIT>\")<EOL>self.assertEqual(conn.client_protocol.connected, True)<EOL>self.assertEqual(conn.client_protocol.disconnected_reason, None)<EOL>self.assertIsInstance(conn.server_protocol, DummyServerProtocol)<EOL>self.assertEqual(conn.server_protocol.side, \"<STR_LIT>\")<EOL>self.assertEqual(conn.server_protocol.connected, True)<EOL>self.assertEqual(conn.server_protocol.disconnected_reason, None)<EOL>self.assertEqual(conn.connected, True)<EOL>self.assertEqual(conn.pending, False)<EOL>self.successResultOf(conn._accept_d)<EOL>self.successResultOf(conn._connected_d)<EOL>self.assertNoResult(conn._finished_d)<EOL>self.assertEqual(conn.client_protocol, client)<EOL>", "docstring": "Assert that a connection is connected to a client.", "id": "f1155:c2:m3"}
{"signature": "def patch_transport_abortConnection(transport, protocol):", "body": "def abortConnection():<EOL><INDENT>protocol._fake_connection_aborted = True<EOL>transport.loseConnection()<EOL><DEDENT>patch_if_missing(transport, '<STR_LIT>', abortConnection)<EOL>", "docstring": "Patch abortConnection() onto the transport if it doesn't already have it.\n(`Agent` assumes its transport has this.)", "id": "f1156:m4"}
{"signature": "def wait0(r=None):", "body": "from twisted.internet import reactor<EOL>return deferLater(reactor, <NUM_LIT:0>, lambda: r)<EOL>", "docstring": "Wait zero seconds to give the reactor a chance to work.\n\nReturns its (optional) argument, so it's useful as a callback.", "id": "f1156:m0"}
{"signature": "@property<EOL><INDENT>def endpoint(self):<DEDENT>", "body": "return FakeServerEndpoint(self)<EOL>", "docstring": "Get an endpoint that connects clients to this server.", "id": "f1156:c1:m2"}
{"signature": "def reject_connection(self, reason=None):", "body": "assert self.pending, \"<STR_LIT>\"<EOL>if reason is None:<EOL><INDENT>reason = ConnectionRefusedError()<EOL><DEDENT>self._accept_d.errback(reason)<EOL>", "docstring": "Reject a pending connection.", "id": "f1156:c2:m5"}
{"signature": "def await_finished(self):", "body": "return self._finished_d<EOL>", "docstring": "Wait for the both sides of the connection to close.", "id": "f1156:c2:m6"}
{"signature": "def row_to_dict(self, row, allele, alternate_alleles):", "body": "def _variant_sbid(**kwargs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return '<STR_LIT>'.format(**kwargs).upper()<EOL><DEDENT>if allele == '<STR_LIT:.>':<EOL><INDENT>allele = row.REF or allele<EOL><DEDENT>genomic_coordinates = {<EOL>'<STR_LIT>': self.genome_build,<EOL>'<STR_LIT>': row.CHROM,<EOL>'<STR_LIT:start>': row.POS,<EOL>'<STR_LIT>': row.POS + len(row.REF) - <NUM_LIT:1><EOL>}<EOL>variant_sbid = _variant_sbid(allele=allele,<EOL>**genomic_coordinates)<EOL>return {<EOL>'<STR_LIT>': genomic_coordinates,<EOL>'<STR_LIT>': variant_sbid,<EOL>'<STR_LIT>': allele,<EOL>'<STR_LIT>': row.ID,<EOL>'<STR_LIT>': row.REF,<EOL>'<STR_LIT>': alternate_alleles,<EOL>'<STR_LIT:info>': self._parse_info(row.INFO),<EOL>'<STR_LIT>': row.QUAL,<EOL>'<STR_LIT>': row.FILTER<EOL>}<EOL>", "docstring": "Return a parsed dictionary for JSON.", "id": "f1158:c1:m10"}
{"signature": "def next(self):", "body": "def _alt(alt):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if not alt:<EOL><INDENT>return '<STR_LIT:.>'<EOL><DEDENT>else:<EOL><INDENT>return str(alt)<EOL><DEDENT><DEDENT>if not self._next:<EOL><INDENT>row = next(self.reader)<EOL>alternate_alleles = list(map(_alt, row.ALT))<EOL>for allele in alternate_alleles:<EOL><INDENT>self._next.append(<EOL>self.row_to_dict(<EOL>row,<EOL>allele=allele,<EOL>alternate_alleles=alternate_alleles))<EOL><DEDENT>self._line_number += <NUM_LIT:1><EOL><DEDENT>return self._next.pop()<EOL>", "docstring": "Expands multiple alleles into one record each\nusing an internal buffer (_next).", "id": "f1158:c1:m9"}
{"signature": "@app.callback(<EOL>dash.dependencies.Output('<STR_LIT>', '<STR_LIT>'),<EOL>[dash.dependencies.Input('<STR_LIT:url>', '<STR_LIT>')])<EOL>def display_page(pathname):", "body": "return layout()<EOL>", "docstring": "Render the layout depending on the pathname.", "id": "f1166:m2"}
{"signature": "def logout(self):", "body": "if self._oauth_client_secret:<EOL><INDENT>try:<EOL><INDENT>oauth_token = flask.request.cookies[self.TOKEN_COOKIE_NAME]<EOL>requests.post(<EOL>urljoin(self._api_host, self.OAUTH2_REVOKE_TOKEN_PATH),<EOL>data={<EOL>'<STR_LIT>': self._oauth_client_id,<EOL>'<STR_LIT>': self._oauth_client_secret,<EOL>'<STR_LIT>': oauth_token<EOL>})<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>response = flask.redirect('<STR_LIT:/>')<EOL>self.clear_cookies(response)<EOL>return response<EOL>", "docstring": "Revoke the token and remove the cookie.", "id": "f1167:c0:m5"}
{"signature": "def get(self, url, params, **kwargs):", "body": "kwargs['<STR_LIT>'] = params<EOL>return self.request('<STR_LIT:GET>', url, **kwargs)<EOL>", "docstring": "Issues an HTTP GET across the wire via the Python requests\n        library. See *request()* for information on keyword args.", "id": "f1170:c1:m4"}
{"signature": "def delete(self, url, data, **kwargs):", "body": "kwargs['<STR_LIT:data>'] = data<EOL>return self.request('<STR_LIT>', url, **kwargs)<EOL>", "docstring": "Issues an HTTP DELETE across the wire via the Python requests\n        library. See *request* for information on keyword args.", "id": "f1170:c1:m6"}
{"signature": "def _mediawiki_cell_attrs(row, colaligns):", "body": "alignment = {\"<STR_LIT:left>\": '<STR_LIT>',<EOL>\"<STR_LIT:right>\": '<STR_LIT>',<EOL>\"<STR_LIT>\": '<STR_LIT>',<EOL>\"<STR_LIT>\": '<STR_LIT>'}<EOL>row2 = [alignment[a] + c for c, a in zip(row, colaligns)]<EOL>return row2<EOL>", "docstring": "Prefix every cell in a row with an HTML alignment attribute.", "id": "f1197:m19"}
{"signature": "def _column_type(strings, has_invisible=True):", "body": "types = [_type(s, has_invisible) for s in strings]<EOL>return reduce(_more_generic, types, int)<EOL>", "docstring": "The least generic type all column values are convertible to.\n\n>>> _column_type([\"1\", \"2\"]) is _int_type\nTrue\n>>> _column_type([\"1\", \"2.3\"]) is _float_type\nTrue\n>>> _column_type([\"1\", \"2.3\", \"four\"]) is _text_type\nTrue\n>>> _column_type([\"four\", '\\u043f\\u044f\\u0442\\u044c']) is _text_type\nTrue\n>>> _column_type([None, \"brux\"]) is _text_type\nTrue\n>>> _column_type([1, 2, None]) is _int_type\nTrue", "id": "f1197:m13"}
{"signature": "def _format(val, valtype, floatfmt, missingval=\"<STR_LIT>\"):", "body": "if val is None:<EOL><INDENT>return missingval<EOL><DEDENT>if valtype in [int, _binary_type, _text_type]:<EOL><INDENT>return \"<STR_LIT>\".format(val)<EOL><DEDENT>elif valtype is float:<EOL><INDENT>return format(float(val), floatfmt)<EOL><DEDENT>else:<EOL><INDENT>return \"<STR_LIT>\".format(val)<EOL><DEDENT>", "docstring": "Format a value accoding to its type.\n\nUnicode is supported:\n\n>>> hrow = ['\\u0431\\u0443\\u043a\\u0432\\u0430', \\\n            '\\u0446\\u0438\\u0444\\u0440\\u0430'] ; \\\n    tbl = [['\\u0430\\u0437', 2], ['\\u0431\\u0443\\u043a\\u0438', 4]] ; \\\n    good_result = '\\\\u0431\\\\u0443\\\\u043a\\\\u0432\\\\u0430      \\\n                    \\\\u0446\\\\u0438\\\\u0444\\\\u0440\\\\u0430\\\\n-------\\\n                      -------\\\\n\\\\u0430\\\\u0437             \\\n                      2\\\\n\\\\u0431\\\\u0443\\\\u043a\\\\u0438           4' ; \\\n    tabulate(tbl, headers=hrow) == good_result\nTrue", "id": "f1197:m14"}
{"signature": "def _normalize_tabular_data(tabular_data, headers, sort=True):", "body": "if hasattr(tabular_data, \"<STR_LIT>\") and hasattr(tabular_data, \"<STR_LIT>\"):<EOL><INDENT>if hasattr(tabular_data.values, \"<STR_LIT>\"):<EOL><INDENT>keys = list(tabular_data.keys())<EOL>rows = list(izip_longest(*list(tabular_data.values())))<EOL><DEDENT>elif hasattr(tabular_data, \"<STR_LIT:index>\"):<EOL><INDENT>keys = list(tabular_data.keys())<EOL>vals = tabular_data.values<EOL>names = tabular_data.index<EOL>rows = [[v] + list(row) for v, row in zip(names, vals)]<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>if headers == \"<STR_LIT>\":<EOL><INDENT>headers = list(map(_text_type, keys))  <EOL><DEDENT><DEDENT>else:  <EOL><INDENT>rows = list(tabular_data)<EOL>if headers == \"<STR_LIT>\" and len(rows) > <NUM_LIT:0>:  <EOL><INDENT>headers = list(map(_text_type, list(range(len(rows[<NUM_LIT:0>])))))<EOL><DEDENT><DEDENT>if headers == \"<STR_LIT>\" and len(rows) > <NUM_LIT:0>:<EOL><INDENT>headers = list(map(_text_type, rows[<NUM_LIT:0>]))  <EOL>rows = rows[<NUM_LIT:1>:]<EOL><DEDENT>headers = list(headers)<EOL>rows = list(map(list, rows))<EOL>if sort and len(rows) > <NUM_LIT:1>:<EOL><INDENT>rows = sorted(rows, key=lambda x: x[<NUM_LIT:0>])<EOL><DEDENT>if headers and len(rows) > <NUM_LIT:0>:<EOL><INDENT>nhs = len(headers)<EOL>ncols = len(rows[<NUM_LIT:0>])<EOL>if nhs < ncols:<EOL><INDENT>headers = [\"<STR_LIT>\"] * (ncols - nhs) + headers<EOL><DEDENT><DEDENT>return rows, headers<EOL>", "docstring": "Transform a supported data type to a list of lists, and a list of headers.\n\nSupported tabular data types:\n\n* list-of-lists or another iterable of iterables\n\n* 2D NumPy arrays\n\n* dict of iterables (usually used with headers=\"keys\")\n\n* pandas.DataFrame (usually used with headers=\"keys\")\n\nThe first row can be used as headers if headers=\"firstrow\",\ncolumn indices can be used as headers if headers=\"keys\".", "id": "f1197:m16"}
{"signature": "def _padleft(width, s, has_invisible=True):", "body": "iwidth = width + len(s) - len(_strip_invisible(s))if has_invisible else width<EOL>fmt = \"<STR_LIT>\" % iwidth<EOL>return fmt.format(s)<EOL>", "docstring": "Flush right.\n\n>>> _padleft(6, '\\u044f\\u0439\\u0446\\u0430') \\\n    == '  \\u044f\\u0439\\u0446\\u0430'\nTrue", "id": "f1197:m6"}
{"signature": "def _line_segment_with_colons(linefmt, align, colwidth):", "body": "fill = linefmt.hline<EOL>w = colwidth<EOL>if align in [\"<STR_LIT:right>\", \"<STR_LIT>\"]:<EOL><INDENT>return (fill[<NUM_LIT:0>] * (w - <NUM_LIT:1>)) + \"<STR_LIT::>\"<EOL><DEDENT>elif align == \"<STR_LIT>\":<EOL><INDENT>return \"<STR_LIT::>\" + (fill[<NUM_LIT:0>] * (w - <NUM_LIT:2>)) + \"<STR_LIT::>\"<EOL><DEDENT>elif align == \"<STR_LIT:left>\":<EOL><INDENT>return \"<STR_LIT::>\" + (fill[<NUM_LIT:0>] * (w - <NUM_LIT:1>))<EOL><DEDENT>else:<EOL><INDENT>return fill[<NUM_LIT:0>] * w<EOL><DEDENT>", "docstring": "Return a segment of a horizontal line with optional colons which\n    indicate column's alignment (as in `pipe` output format).", "id": "f1197:m20"}
{"signature": "def _type(string, has_invisible=True):", "body": "if has_invisible and(isinstance(string, _text_type) or isinstance(string, _binary_type)):<EOL><INDENT>string = _strip_invisible(string)<EOL><DEDENT>if string is None:<EOL><INDENT>return _none_type<EOL><DEDENT>elif _isint(string):<EOL><INDENT>return _int_type<EOL><DEDENT>elif _isnumber(string):<EOL><INDENT>return float<EOL><DEDENT>elif isinstance(string, _binary_type):<EOL><INDENT>return _binary_type<EOL><DEDENT>else:<EOL><INDENT>return _text_type<EOL><DEDENT>", "docstring": "The least generic type (type(None), int, float, str, unicode).\n\n>>> _type(None) is type(None)\nTrue\n>>> _type(\"foo\") is type(\"\")\nTrue\n>>> _type(\"1\") is type(1)\nTrue\n>>> _type('\\x1b[31m42\\x1b[0m') is type(42)\nTrue\n>>> _type('\\x1b[31m42\\x1b[0m') is type(42)\nTrue", "id": "f1197:m4"}
{"signature": "def _build_line(colwidths, padding, begin, fill, sep, end):", "body": "cells = [fill * (w + <NUM_LIT:2> * padding) for w in colwidths]<EOL>return _build_row(cells, <NUM_LIT:0>, begin, sep, end)<EOL>", "docstring": "Return a string which represents a horizontal line.", "id": "f1197:m18"}
{"signature": "def naturalsize(value, binary=False, gnu=False, format='<STR_LIT>'):", "body": "if gnu:<EOL><INDENT>suffix = suffixes['<STR_LIT>']<EOL><DEDENT>elif binary:<EOL><INDENT>suffix = suffixes['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>suffix = suffixes['<STR_LIT>']<EOL><DEDENT>base = <NUM_LIT> if (gnu or binary) else <NUM_LIT:1000><EOL>bytes = float(value)<EOL>if bytes == <NUM_LIT:1> and not gnu:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>elif bytes < base and not gnu:<EOL><INDENT>return '<STR_LIT>' % bytes<EOL><DEDENT>elif bytes < base and gnu:<EOL><INDENT>return '<STR_LIT>' % bytes<EOL><DEDENT>for i, s in enumerate(suffix):<EOL><INDENT>unit = base ** (i + <NUM_LIT:2>)<EOL>if bytes < unit and not gnu:<EOL><INDENT>return (format + '<STR_LIT>') % ((base * bytes / unit), s)<EOL><DEDENT>elif bytes < unit and gnu:<EOL><INDENT>return (format + '<STR_LIT:%s>') % ((base * bytes / unit), s)<EOL><DEDENT><DEDENT>if gnu:<EOL><INDENT>return (format + '<STR_LIT:%s>') % ((base * bytes / unit), s)<EOL><DEDENT>return (format + '<STR_LIT>') % ((base * bytes / unit), s)<EOL>", "docstring": "Format a number of byteslike a human readable filesize (eg. 10 kB).  By\n    default, decimal suffixes (kB, MB) are used.  Passing binary=true will use\n    binary suffixes (KiB, MiB) are used and the base will be 2**10 instead of\n    10**3.  If ``gnu`` is True, the binary argument is ignored and GNU-style\n    (ls -sh style) prefixes are used (K, M) with the 2**10 definition.\n    Non-gnu modes are compatible with jinja2's ``filesizeformat`` filter.", "id": "f1200:m0"}
{"signature": "def evaluate(self, data=None, data_type='<STR_LIT:string>', is_list=False):", "body": "payload = {<EOL>'<STR_LIT:data>': data,<EOL>'<STR_LIT>': self.expr,<EOL>'<STR_LIT>': data_type,<EOL>'<STR_LIT>': is_list<EOL>}<EOL>res = self._client.post('<STR_LIT>', payload)<EOL>return res['<STR_LIT:result>']<EOL>", "docstring": "Evaluates the expression with the provided context and format.", "id": "f1201:c1:m1"}
{"signature": "def _combine(self, other, conn='<STR_LIT>'):", "body": "f = Filter()<EOL>f.deepcopy = self.deepcopy and other.filters<EOL>if f.deepcopy:<EOL><INDENT>self_filters = copy.deepcopy(self.filters)<EOL>other_filters = copy.deepcopy(other.filters)<EOL><DEDENT>else:<EOL><INDENT>self_filters = self.filters<EOL>other_filters = other.filters<EOL><DEDENT>if not self.filters:<EOL><INDENT>f.filters = other_filters<EOL><DEDENT>elif not other.filters:<EOL><INDENT>f.filters = self_filters<EOL><DEDENT>elif conn in self.filters[<NUM_LIT:0>]:<EOL><INDENT>f.filters = self_filters<EOL>f.filters[<NUM_LIT:0>][conn].extend(other_filters)<EOL><DEDENT>elif conn in other.filters[<NUM_LIT:0>]:<EOL><INDENT>f.filters = other_filters<EOL>f.filters[<NUM_LIT:0>][conn].extend(self_filters)<EOL><DEDENT>else:<EOL><INDENT>f.filters = [{conn: self_filters + other_filters}]<EOL><DEDENT>return f<EOL>", "docstring": "OR and AND will create a new Filter, with the filters from both Filter\nobjects combined with the connector `conn`.", "id": "f1202:c0:m2"}
{"signature": "def next(self):", "body": "if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>self.__iter__()<EOL><DEDENT>if self._cursor == len(self):<EOL><INDENT>raise StopIteration()<EOL><DEDENT>if self._buffer_idx == len(self._buffer):<EOL><INDENT>self.execute(self._page_offset + self._buffer_idx)<EOL>self._buffer_idx = <NUM_LIT:0><EOL><DEDENT>self._cursor += <NUM_LIT:1><EOL>self._buffer_idx += <NUM_LIT:1><EOL>return self._buffer[self._buffer_idx - <NUM_LIT:1>]<EOL>", "docstring": "Allows the Query object to be an iterable.\n\nThis method will iterate through a cached result set\nand fetch successive pages as required.\n\nA `StopIteration` exception will be raised when there aren't\nany more results available or when the requested result\nslice range or limit has been fetched.\n\nReturns: The next result.", "id": "f1202:c2:m19"}
{"signature": "def __init__(<EOL>self,<EOL>dataset_id,<EOL>query=None,<EOL>genome_build=None,<EOL>filters=None,<EOL>fields=None,<EOL>exclude_fields=None,<EOL>entities=None,<EOL>ordering=None,<EOL>limit=float('<STR_LIT>'),<EOL>page_size=DEFAULT_PAGE_SIZE,<EOL>result_class=dict,<EOL>debug=False,<EOL>error=None,<EOL>**kwargs):", "body": "self._dataset_id = dataset_id<EOL>self._data_url = '<STR_LIT>'.format(dataset_id)<EOL>self._query = query<EOL>self._genome_build = genome_build<EOL>self._result_class = result_class<EOL>self._fields = fields<EOL>self._exclude_fields = exclude_fields<EOL>self._entities = entities<EOL>self._ordering = ordering<EOL>self._debug = debug<EOL>self._error = error<EOL>if filters:<EOL><INDENT>if isinstance(filters, Filter):<EOL><INDENT>filters = [filters]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>filters = []<EOL><DEDENT>self._filters = filters<EOL>self._response = None<EOL>self._limit = limit<EOL>self._page_size = int(page_size)<EOL>self._page_offset = None<EOL>self._slice = None<EOL>if self._limit < <NUM_LIT:0>:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>if self._page_size <= <NUM_LIT:0>:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>self._client = kwargs.get('<STR_LIT>') or self._client or client<EOL>", "docstring": "Creates a new Query object.\n\n:Parameters:\n  - `dataset_id`: Unique ID of dataset to query.\n  - `query` (optional): An optional query string.\n  - `genome_build`: The genome build to use for the query.\n  - `result_class` (optional): Class of object returned by query.\n  - `fields` (optional): List of specific fields to retrieve.\n  - `exclude_fields` (optional): List of specific fields to exclude.\n  - `entities` (optional): List of entity tuples to filter on.\n  - `ordering` (optional): List of fields to order the results by.\n  - `filters` (optional): Filter or List of filter objects.\n  - `limit` (optional): Maximum number of query results to return.\n  - `page_size` (optional): Number of results to fetch per query page.\n  - `debug` (optional): Sends debug information to the API.", "id": "f1202:c2:m0"}
{"signature": "def count(self):", "body": "<EOL>return self.total<EOL>", "docstring": "Returns the total number of results returned by a query.\nThe count is dependent on the filters, but independent of any limit.\nIt is like SQL:\n   SELECT COUNT(*) FROM <table> [WHERE condition].\nSee also __len__ for a function that is dependent on limit.", "id": "f1202:c2:m6"}
{"signature": "@classmethod<EOL><INDENT>def _process_filters(cls, filters):<DEDENT>", "body": "data = []<EOL>for f in filters:<EOL><INDENT>if isinstance(f, Filter):<EOL><INDENT>if f.filters:<EOL><INDENT>data.extend(cls._process_filters(f.filters))<EOL><DEDENT><DEDENT>elif isinstance(f, dict):<EOL><INDENT>key = list(f.keys())[<NUM_LIT:0>]<EOL>val = f[key]<EOL>if isinstance(val, dict):<EOL><INDENT>filter_filters = cls._process_filters([val])<EOL>if len(filter_filters) == <NUM_LIT:1>:<EOL><INDENT>filter_filters = filter_filters[<NUM_LIT:0>]<EOL><DEDENT>data.append({key: filter_filters})<EOL><DEDENT>else:<EOL><INDENT>data.append({key: cls._process_filters(val)})<EOL><DEDENT><DEDENT>else:<EOL><INDENT>data.extend((f,))<EOL><DEDENT><DEDENT>return data<EOL>", "docstring": "Takes a list of filters and returns JSON\n\n        :Parameters:\n        - `filters`: List of Filters, (key, val) tuples, or dicts\n\n        Returns: List of JSON API filters", "id": "f1202:c2:m11"}
{"signature": "def migrate(self, target, follow=True, **kwargs):", "body": "from solvebio import Dataset<EOL>from solvebio import DatasetMigration<EOL>if isinstance(target, Dataset):<EOL><INDENT>target_id = target.id<EOL><DEDENT>else:<EOL><INDENT>target_id = target<EOL><DEDENT>limit = kwargs.pop('<STR_LIT>', None)<EOL>if not limit and self._limit < float('<STR_LIT>'):<EOL><INDENT>limit = self._limit<EOL><DEDENT>params = self._build_query(limit=limit)<EOL>params.pop('<STR_LIT>', None)<EOL>params.pop('<STR_LIT>', None)<EOL>migration = DatasetMigration.create(<EOL>source_id=self._dataset_id,<EOL>target_id=target_id,<EOL>source_params=params,<EOL>client=self._client,<EOL>**kwargs)<EOL>if follow:<EOL><INDENT>migration.follow()<EOL><DEDENT>return migration<EOL>", "docstring": "Migrate the data from the Query to a target dataset.\n\nValid optional kwargs include:\n\n* target_fields\n* include_errors\n* validation_params\n* metadata\n* commit_mode", "id": "f1202:c2:m23"}
{"signature": "def filter(self, *filters, **kwargs):", "body": "f = list(filters)<EOL>if kwargs:<EOL><INDENT>f += [Filter(**kwargs)]<EOL><DEDENT>return self._clone(filters=f)<EOL>", "docstring": "Returns this Query instance with the query args combined with\nexisting set with AND.\n\nkwargs are simply passed to a new Filter object and combined to any\nother filters with AND.\n\nBy default, everything is combined using AND. If you provide\nmultiple filters in a single filter call, those are ANDed\ntogether. If you provide multiple filters in multiple filter\ncalls, those are ANDed together.\n\nIf you want something different, use the F class which supports\n``&`` (and), ``|`` (or) and ``~`` (not) operators. Then call\nfilter once with the resulting Filter instance.", "id": "f1202:c2:m3"}
{"signature": "def __init__(self, queries, **kwargs):", "body": "if not isinstance(queries, list):<EOL><INDENT>queries = [queries]<EOL><DEDENT>self._queries = queries<EOL>self._client = kwargs.get('<STR_LIT>') or self._client or client<EOL>", "docstring": "Expects a list of Query objects.", "id": "f1202:c3:m0"}
{"signature": "def logout(*args):", "body": "if get_credentials():<EOL><INDENT>delete_credentials()<EOL>_print_msg('<STR_LIT>')<EOL><DEDENT>_print_msg('<STR_LIT>')<EOL>", "docstring": "Delete's the user's locally-stored credentials.", "id": "f1207:m4"}
{"signature": "def print_user(user):", "body": "email = user['<STR_LIT:email>']<EOL>domain = user['<STR_LIT>']['<STR_LIT>']<EOL>role = user['<STR_LIT>']<EOL>print('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>.format(domain, email, role))<EOL>", "docstring": "Prints information about the current user.", "id": "f1207:m6"}
{"signature": "def launch_ipython_shell(args):  ", "body": "try:<EOL><INDENT>import IPython  <EOL><DEDENT>except ImportError:<EOL><INDENT>_print(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>return False<EOL><DEDENT>if hasattr(IPython, \"<STR_LIT>\"):<EOL><INDENT>if IPython.version_info > (<NUM_LIT:5>, <NUM_LIT:0>, <NUM_LIT:0>, '<STR_LIT>'):<EOL><INDENT>return launch_ipython_5_shell(args)<EOL><DEDENT><DEDENT>_print(\"<STR_LIT>\"<EOL>.format(IPython.__version__))<EOL>return launch_ipython_legacy_shell(args)<EOL>", "docstring": "Open the SolveBio shell (IPython wrapper)", "id": "f1209:m1"}
{"signature": "def all(self, **params):", "body": "return self.request('<STR_LIT>', self['<STR_LIT:url>'], params=params)<EOL>", "docstring": "Lists all items in a class that you have access to", "id": "f1223:c1:m0"}
{"signature": "def get_by_natural_key(self, email_pgp_pub_field):", "body": "return self.get(email_pgp_pub_field=email_pgp_pub_field)<EOL>", "docstring": "Get by natual key of email pub field.", "id": "f1241:c1:m0"}
{"signature": "def db_for_write(self, model, **hints):", "body": "if model._meta.app_label == '<STR_LIT>':<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>return '<STR_LIT:default>'<EOL>", "docstring": "Write to diff_keys.", "id": "f1243:c0:m1"}
{"signature": "def as_sql(self, compiler, connection):", "body": "sql, params = super(DecryptedCol, self).as_sql(compiler, connection)<EOL>sql = self.target.get_decrypt_sql(connection) % (sql, self.target.get_cast_sql())<EOL>return sql, params<EOL>", "docstring": "Build SQL with decryption and casting.", "id": "f1244:c0:m1"}
{"signature": "def db_type(self, connection=None):", "body": "return '<STR_LIT>'<EOL>", "docstring": "Value stored in the database is hexadecimal.", "id": "f1244:c2:m1"}
{"signature": "def get_col(self, alias, output_field=None):", "body": "if output_field is None:<EOL><INDENT>output_field = self<EOL><DEDENT>if alias != self.model._meta.db_table or output_field != self:<EOL><INDENT>return DecryptedCol(<EOL>alias,<EOL>self,<EOL>output_field<EOL>)<EOL><DEDENT>else:<EOL><INDENT>return self.cached_col<EOL><DEDENT>", "docstring": "Get the decryption for col.", "id": "f1244:c2:m5"}
{"signature": "def pre_save(self, model_instance, add):", "body": "if self.original:<EOL><INDENT>original_value = getattr(model_instance, self.original)<EOL>setattr(model_instance, self.attname, original_value)<EOL><DEDENT>return super(HashMixin, self).pre_save(model_instance, add)<EOL>", "docstring": "Save the original_value.", "id": "f1244:c1:m1"}
{"signature": "def get_placeholder(self, value=None, compiler=None, connection=None):", "body": "return self.encrypt_sql.format(get_setting(connection, '<STR_LIT>'))<EOL>", "docstring": "Tell postgres to encrypt this field using PGP.", "id": "f1244:c3:m0"}
{"signature": "def get_placeholder(self, value, compiler, connection):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Tell postgres to encrypt this field using PGP.", "id": "f1244:c2:m2"}
{"signature": "def as_sql(self, qn, connection):", "body": "lhs, lhs_params = self.process_lhs(qn, connection)<EOL>rhs, rhs_params = self.process_rhs(qn, connection)<EOL>params = lhs_params + rhs_params<EOL>rhs = self.lhs.field.encrypt_sql % rhs<EOL>return ('<STR_LIT>'.format(lhs, rhs)), params<EOL>", "docstring": "Responsible for creating the lookup with the digest SQL.\n\n        Modify the right hand side expression to compare the value passed\n        to a hash.", "id": "f1246:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def epgm(cls):<DEDENT>", "body": "return '<STR_LIT:e>' + cls.pgm()<EOL>", "docstring": "Generates available Encapsulated PGM address.", "id": "f1251:c0:m4"}
{"signature": "@classmethod<EOL><INDENT>def inproc(cls):<DEDENT>", "body": "return '<STR_LIT>'.format(rand_str())<EOL>", "docstring": "Generates random in-process address.", "id": "f1251:c0:m0"}
{"signature": "def rpc(f=None, **kwargs):", "body": "if f is not None:<EOL><INDENT>if isinstance(f, six.string_types):<EOL><INDENT>if '<STR_LIT:name>' in kwargs:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>kwargs['<STR_LIT:name>'] = f<EOL><DEDENT>else:<EOL><INDENT>return rpc(**kwargs)(f)<EOL><DEDENT><DEDENT>return functools.partial(_rpc, **kwargs)<EOL>", "docstring": "Marks a method as RPC.", "id": "f1254:m2"}
{"signature": "def class_name(obj):", "body": "return type(obj).__name__<EOL>", "docstring": "Returns the class name of the object.", "id": "f1256:m0"}
{"signature": "def make_repr(obj, params=None, keywords=None, data=None, name=None,<EOL>reprs=None):", "body": "opts = []<EOL>if params is not None:<EOL><INDENT>opts.append('<STR_LIT:U+002CU+0020>'.join(<EOL>_repr_attr(obj, attr, data, reprs) for attr in params))<EOL><DEDENT>if keywords is not None:<EOL><INDENT>opts.append('<STR_LIT:U+002CU+0020>'.join(<EOL>'<STR_LIT>' % (attr, _repr_attr(obj, attr, data, reprs))<EOL>for attr in keywords))<EOL><DEDENT>if name is None:<EOL><INDENT>name = class_name(obj)<EOL><DEDENT>return '<STR_LIT>' % (name, '<STR_LIT:U+002CU+0020>'.join(opts))<EOL>", "docstring": "Generates a string of object initialization code style.  It is useful\n    for custom __repr__ methods::\n\n       class Example(object):\n\n           def __init__(self, param, keyword=None):\n               self.param = param\n               self.keyword = keyword\n\n           def __repr__(self):\n               return make_repr(self, ['param'], ['keyword'])\n\n    See the representation of example object::\n\n       >>> Example('hello', keyword='world')\n       Example('hello', keyword='world')", "id": "f1256:m2"}
{"signature": "def work(self, socket, call, args, kwargs, topics=()):", "body": "task_id = uuid4_bytes()<EOL>reply_socket, topics = self.replier(socket, topics, call.reply_to)<EOL>if reply_socket:<EOL><INDENT>channel = (call.call_id, task_id, topics)<EOL><DEDENT>else:<EOL><INDENT>channel = (None, None, None)<EOL><DEDENT>f, rpc_spec = self.find_call_target(call)<EOL>if rpc_spec.reject_if.__get__(self.app)(call, topics):<EOL><INDENT>reply_socket and self.reject(reply_socket, call.call_id, topics)<EOL>return<EOL><DEDENT>reply_socket and self.accept(reply_socket, channel)<EOL>success = False<EOL>with self.catch_exceptions():<EOL><INDENT>try:<EOL><INDENT>val = self.call(call, args, kwargs, f, rpc_spec)<EOL><DEDENT>except:<EOL><INDENT>exc_info = sys.exc_info()<EOL>self.raise_(reply_socket, channel, exc_info)<EOL>reraise(*exc_info)<EOL><DEDENT>success = True<EOL><DEDENT>if not success:<EOL><INDENT>return<EOL><DEDENT>if isinstance(val, Iterator):<EOL><INDENT>vals = val<EOL>with self.catch_exceptions():<EOL><INDENT>try:<EOL><INDENT>try:<EOL><INDENT>val = next(vals)<EOL><DEDENT>except StopIteration:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>self.send_reply(reply_socket, YIELD, val, *channel)<EOL>for val in vals:<EOL><INDENT>self.send_reply(reply_socket, YIELD, val, *channel)<EOL><DEDENT><DEDENT>self.send_reply(reply_socket, BREAK, None, *channel)<EOL><DEDENT>except:<EOL><INDENT>exc_info = sys.exc_info()<EOL>self.raise_(reply_socket, channel, exc_info)<EOL>reraise(*exc_info)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>self.send_reply(reply_socket, RETURN, val, *channel)<EOL><DEDENT>", "docstring": "Calls a function and send results to the collector.  It supports\n        all of function actions.  A function could return, yield, raise any\n        packable objects.", "id": "f1257:c1:m6"}
{"signature": "def dispatch_reply(self, reply, value):", "body": "method = reply.method<EOL>call_id = reply.call_id<EOL>task_id = reply.task_id<EOL>if method & ACK:<EOL><INDENT>try:<EOL><INDENT>result_queue = self.result_queues[call_id]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if method == ACCEPT:<EOL><INDENT>worker_info = value<EOL>result = RemoteResult(self, call_id, task_id, worker_info)<EOL>self.results[call_id][task_id] = result<EOL>result_queue.put_nowait(result)<EOL><DEDENT>elif method == REJECT:<EOL><INDENT>result_queue.put_nowait(None)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>result = self.results[call_id][task_id]<EOL>result.set_reply(reply.method, value)<EOL><DEDENT>", "docstring": "Dispatches the reply to the proper queue.", "id": "f1257:c5:m4"}
{"signature": "def __call__(self):", "body": "poller = zmq.Poller()<EOL>for socket in self.sockets:<EOL><INDENT>poller.register(socket, zmq.POLLIN)<EOL><DEDENT>group = self.greenlet_group<EOL>msgs = []<EOL>capture = msgs.extend<EOL>def accept(socket, call, args, kwargs, topics):<EOL><INDENT>group.spawn(self.work, socket, call, args, kwargs, topics)<EOL>group.join(<NUM_LIT:0>)<EOL><DEDENT>def reject(socket, call, topics):<EOL><INDENT>__, call_id, reply_to, __, __ = call<EOL>reply_socket, topics = self.replier(socket, topics, reply_to)<EOL>self.reject(reply_socket, call_id, topics)<EOL><DEDENT>def reject_if(call, topics):<EOL><INDENT>if self.reject_if(call, topics):<EOL><INDENT>return True<EOL><DEDENT>try:<EOL><INDENT>__, rpc_spec = self.find_call_target(call)<EOL><DEDENT>except KeyError:<EOL><INDENT>return True<EOL><DEDENT>return rpc_spec.reject_if.__get__(self.app)(call, topics)<EOL><DEDENT>try:<EOL><INDENT>while True:<EOL><INDENT>for socket, event in safe(poller.poll):<EOL><INDENT>assert event & zmq.POLLIN<EOL>del msgs[:]<EOL>try:<EOL><INDENT>header, payload, topics = recv(socket, capture=capture)<EOL>call = parse_call(header)<EOL>if group.full() or reject_if(call, topics):<EOL><INDENT>reject(socket, call, topics)<EOL>continue<EOL><DEDENT>args, kwargs = self.unpack(payload)<EOL><DEDENT>except:<EOL><INDENT>handle = self.malformed_message_handler<EOL>if handle is not None:<EOL><INDENT>exc_info = sys.exc_info()<EOL>handle(self, exc_info, msgs[:])<EOL><DEDENT>del handle<EOL>continue<EOL><DEDENT>accept(socket, call, args, kwargs, topics)<EOL><DEDENT>try:<EOL><INDENT>del header, payload, topics<EOL>del call<EOL>del args, kwargs<EOL><DEDENT>except UnboundLocalError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>finally:<EOL><INDENT>group.kill()<EOL><DEDENT>", "docstring": "Runs the worker.  While running, an RPC service is online.", "id": "f1257:c1:m5"}
{"signature": "def reject(self, reply_socket, call_id, topics=()):", "body": "info = self.info or b'<STR_LIT>'<EOL>self.send_raw(reply_socket, REJECT, info, call_id, b'<STR_LIT>', topics)<EOL>", "docstring": "Sends REJECT reply.", "id": "f1257:c1:m10"}
{"signature": "def default_exception_handler(worker, exc_info):", "body": "reraise(*exc_info)<EOL>", "docstring": "The default exception handler for :class:`Worker`.  It just raises\n    the given ``exc_info``.", "id": "f1257:m0"}
{"signature": "def hBool(pyVal):", "body": "return BOOL.fromPy(pyVal)<EOL>", "docstring": "create hdl bool value (for example bool value in vhdl)", "id": "f1262:m1"}
{"signature": "def areValues(*items):", "body": "for i in items:<EOL><INDENT>if not isinstance(i, Value):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": ":return: True if all arguments are instances of Value class else False", "id": "f1263:m0"}
{"signature": "def _reinterpret_cast(self, toT):", "body": "return self._dtype.reinterpret_cast(self, toT)<EOL>", "docstring": "type cast to type of same size", "id": "f1263:c0:m3"}
{"signature": "def __init__(self, val, dtype, vldMask, updateTime=-<NUM_LIT:1>):", "body": "self.val = val<EOL>self._dtype = dtype<EOL>self.vldMask = vldMask<EOL>self.updateTime = updateTime<EOL>", "docstring": ":param val: pythonic value representing this value\n:param dtype: data type object from which this value was derived from\n:param vldMask: validity mask for value\n:param updateTime: simulation time when this value vas created", "id": "f1263:c0:m0"}
{"signature": "@internal<EOL>def reinterpret_bits_to_hstruct(sigOrVal, hStructT):", "body": "container = hStructT.fromPy(None)<EOL>offset = <NUM_LIT:0><EOL>for f in hStructT.fields:<EOL><INDENT>t = f.dtype<EOL>width = t.bit_length()<EOL>if f.name is not None:<EOL><INDENT>s = sigOrVal[(width + offset):offset]<EOL>s = s._reinterpret_cast(t)<EOL>setattr(container, f.name, s)<EOL><DEDENT>offset += width<EOL><DEDENT>return container<EOL>", "docstring": "Reinterpret signal of type Bits to signal of type HStruct", "id": "f1268:m2"}
{"signature": "def __setitem__(self, index, value):", "body": "if isinstance(index, int):<EOL><INDENT>index = INT.fromPy(index)<EOL><DEDENT>else:<EOL><INDENT>assert isinstance(self, Value)<EOL>assert index._dtype == INT, index._dtype<EOL><DEDENT>if not isinstance(value, Value):<EOL><INDENT>value = self._dtype.elmType.fromPy(value)<EOL><DEDENT>else:<EOL><INDENT>assert value._dtype == self._dtype.elmType, (<EOL>value._dtype, self._dtype.elmType)<EOL><DEDENT>return self._setitem__val(index, value)<EOL>", "docstring": "Only syntax sugar for user, not used inside HWT\n\n* In HW design is not used (__getitem__ returns \"reference\"\n    and it is used)\n\n* In simulator is used _setitem__val directly", "id": "f1269:c0:m7"}
{"signature": "@internal<EOL><INDENT>def _getitem__val(self, key):<DEDENT>", "body": "try:<EOL><INDENT>kv = key.val<EOL>if not key._isFullVld():<EOL><INDENT>raise KeyError()<EOL><DEDENT>else:<EOL><INDENT>if kv >= self._dtype.size:<EOL><INDENT>raise KeyError()<EOL><DEDENT><DEDENT>return self.val[kv].clone()<EOL><DEDENT>except KeyError:<EOL><INDENT>return self._dtype.elmType.fromPy(None)<EOL><DEDENT>", "docstring": ":atention: this will clone item from array, iterate over .val\n    if you need to modify items", "id": "f1269:c0:m4"}
{"signature": "def walkFlattenFields(sigOrVal, skipPadding=True):", "body": "t = sigOrVal._dtype<EOL>if isinstance(t, Bits):<EOL><INDENT>yield sigOrVal<EOL><DEDENT>elif isinstance(t, HUnion):<EOL><INDENT>yield from walkFlattenFields(sigOrVal._val, skipPadding=skipPadding)<EOL><DEDENT>elif isinstance(t, HStruct):<EOL><INDENT>for f in t.fields:<EOL><INDENT>isPadding = f.name is None<EOL>if not isPadding or not skipPadding:<EOL><INDENT>if isPadding:<EOL><INDENT>v = f.dtype.fromPy(None)<EOL><DEDENT>else:<EOL><INDENT>v = getattr(sigOrVal, f.name)<EOL><DEDENT>yield from walkFlattenFields(v)<EOL><DEDENT><DEDENT><DEDENT>elif isinstance(t, HArray):<EOL><INDENT>for item in sigOrVal:<EOL><INDENT>yield from walkFlattenFields(item)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise NotImplementedError(t)<EOL><DEDENT>", "docstring": "Walk all simple values in HStruct or HArray", "id": "f1270:m1"}
{"signature": "@internal<EOL>def slice_to_SLICE(sliceVals, width):", "body": "if sliceVals.step is not None:<EOL><INDENT>raise NotImplementedError()<EOL><DEDENT>start = sliceVals.start<EOL>stop = sliceVals.stop<EOL>if sliceVals.start is None:<EOL><INDENT>start = INT.fromPy(width)<EOL><DEDENT>else:<EOL><INDENT>start = toHVal(sliceVals.start)<EOL><DEDENT>if sliceVals.stop is None:<EOL><INDENT>stop = INT.fromPy(<NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>stop = toHVal(sliceVals.stop)<EOL><DEDENT>startIsVal = isinstance(start, Value)<EOL>stopIsVal = isinstance(stop, Value)<EOL>indexesAreValues = startIsVal and stopIsVal<EOL>if indexesAreValues:<EOL><INDENT>updateTime = max(start.updateTime, stop.updateTime)<EOL><DEDENT>else:<EOL><INDENT>updateTime = -<NUM_LIT:1><EOL><DEDENT>return Slice.getValueCls()((start, stop), SLICE, <NUM_LIT:1>, updateTime)<EOL>", "docstring": "convert python slice to value of SLICE hdl type", "id": "f1271:m0"}
{"signature": "def _size(self):", "body": "assert isinstance(self, Value)<EOL>return int(self.val[<NUM_LIT:0>]) - int(self.val[<NUM_LIT:1>])<EOL>", "docstring": ":return: how many bits is this slice selecting", "id": "f1273:c0:m2"}
{"signature": "def toPy(self):", "body": "return slice(int(self.val[<NUM_LIT:0>]), int(self.val[<NUM_LIT:1>]))<EOL>", "docstring": "Convert to python slice object", "id": "f1273:c0:m1"}
{"signature": "def __init__(self, name, valueNames):", "body": "super(HEnum, self).__init__()<EOL>self.name = name<EOL>self._allValues = tuple(valueNames)<EOL>for name in valueNames:<EOL><INDENT>v = self.fromPy(name)<EOL>assert not hasattr(self, name)<EOL>setattr(self, name, v)<EOL><DEDENT>", "docstring": ":param name: name for this type\n:param valueNames: sequence of string which will be used as names\n    for enum members", "id": "f1275:c0:m0"}
{"signature": "@internal<EOL><INDENT>def domain_size(self):<DEDENT>", "body": "return int(<NUM_LIT:2> ** self.bit_length())<EOL>", "docstring": ":return: how many values can have specified type", "id": "f1275:c0:m3"}
{"signature": "@classmethod<EOL><INDENT>def fromPy(cls, val, typeObj, vldMask=None):<DEDENT>", "body": "vld = int(val is not None)<EOL>if not vld:<EOL><INDENT>assert vldMask is None or vldMask == <NUM_LIT:0><EOL>val = False<EOL><DEDENT>else:<EOL><INDENT>if vldMask == <NUM_LIT:0>:<EOL><INDENT>val = False<EOL>vld = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>val = bool(val)<EOL><DEDENT><DEDENT>return cls(val, typeObj, vld)<EOL>", "docstring": ":param val: value of python type bool or None\n:param typeObj: instance of HdlType\n:param vldMask: None vldMask is resolved from val,\n    if is 0 value is invalidated\n    if is 1 value has to be valid", "id": "f1278:c0:m1"}
{"signature": "@internal<EOL><INDENT>def domain_size(self):<DEDENT>", "body": "return <NUM_LIT:1> << <NUM_LIT:32><EOL>", "docstring": ":return: how many values can have specified type", "id": "f1279:c0:m3"}
{"signature": "@classmethod<EOL><INDENT>def fromPy(cls, val, typeObj, vldMask=None):<DEDENT>", "body": "if vldMask == <NUM_LIT:0>:<EOL><INDENT>val = None<EOL><DEDENT>return cls(val, typeObj)<EOL>", "docstring": ":param val: None or dict {field name: field value}\n:param typeObj: instance of String HdlType\n:param vldMask: if is None validity is resolved from val\n    if is 0 value is invalidated\n    if is 1 value has to be valid", "id": "f1286:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def fromPy(cls, val, typeObj, vldMask=None):<DEDENT>", "body": "assert isinstance(val, str) or val is None<EOL>vld = <NUM_LIT:0> if val is None else <NUM_LIT:1><EOL>if not vld:<EOL><INDENT>assert vldMask is None or vldMask == <NUM_LIT:0><EOL>val = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>if vldMask == <NUM_LIT:0>:<EOL><INDENT>val = \"<STR_LIT>\"<EOL>vld = <NUM_LIT:0><EOL><DEDENT><DEDENT>return cls(val, typeObj, vld)<EOL>", "docstring": ":param val: python string or None\n:param typeObj: instance of String HdlType\n:param vldMask: if is None validity is resolved from val\n    if is 0 value is invalidated\n    if is 1 value has to be valid", "id": "f1289:c0:m0"}
{"signature": "def bit_length(self):", "body": "try:<EOL><INDENT>itemSize = self.elmType.bit_length<EOL><DEDENT>except AttributeError:<EOL><INDENT>itemSize = None<EOL><DEDENT>if itemSize is None:<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>s = self.size<EOL>if isinstance(s, RtlSignalBase):<EOL><INDENT>s = int(s.staticEval())<EOL><DEDENT>return s * itemSize()<EOL>", "docstring": ":return: bit width for this type", "id": "f1293:c0:m3"}
{"signature": "def __getitem__(self, key):", "body": "assert int(key) > <NUM_LIT:0>, key  <EOL>from hwt.hdl.types.array import HArray<EOL>return HArray(self, key)<EOL>", "docstring": "[] operator to create an array of this type.", "id": "f1296:c0:m6"}
{"signature": "@internal<EOL><INDENT>@classmethod<EOL>def getValueCls(cls):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": ":attention: Overrode in implementation of concrete HdlType.\n\n:return: class for value derived from this type", "id": "f1296:c0:m5"}
{"signature": "def statementsAreSame(statements: List[HdlStatement]) -> bool:", "body": "iterator = iter(statements)<EOL>try:<EOL><INDENT>first = next(iterator)<EOL><DEDENT>except StopIteration:<EOL><INDENT>return True<EOL><DEDENT>return all(first.isSame(rest) for rest in iterator)<EOL>", "docstring": ":return: True if all statements are same", "id": "f1300:m4"}
{"signature": "@internal<EOL><INDENT>def _destroy(self):<DEDENT>", "body": "ctx = self._get_rtl_context()<EOL>for i in self._inputs:<EOL><INDENT>i.endpoints.discard(self)<EOL><DEDENT>for o in self._outputs:<EOL><INDENT>o.drivers.remove(self)<EOL><DEDENT>ctx.statements.remove(self)<EOL>", "docstring": "Disconnect this statement from signals and delete it from RtlNetlist context\n\n:attention: signal endpoints/drivers will be altered\n    that means they can not be used for iteration", "id": "f1300:c2:m24"}
{"signature": "@internal<EOL><INDENT>def _discover_enclosure(self) -> None:<DEDENT>", "body": "raise NotImplementedError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\", self.__class__, self)<EOL>", "docstring": "Discover all outputs for which is this steement enclosed _enclosed_for property\n(has driver in all code branches)", "id": "f1300:c2:m4"}
{"signature": "@internal<EOL><INDENT>def _on_merge(self, other):<DEDENT>", "body": "self._inputs.extend(other._inputs)<EOL>self._outputs.extend(other._outputs)<EOL>if self._sensitivity is not None:<EOL><INDENT>self._sensitivity.extend(other._sensitivity)<EOL><DEDENT>else:<EOL><INDENT>assert other._sensitivity is None<EOL><DEDENT>if self._enclosed_for is not None:<EOL><INDENT>self._enclosed_for.update(other._enclosed_for)<EOL><DEDENT>else:<EOL><INDENT>assert other._enclosed_for is None<EOL><DEDENT>other_was_top = other.parentStm is None<EOL>if other_was_top:<EOL><INDENT>other._get_rtl_context().statements.remove(other)<EOL>for s in other._inputs:<EOL><INDENT>s.endpoints.discard(other)<EOL>s.endpoints.append(self)<EOL><DEDENT>for s in other._outputs:<EOL><INDENT>s.drivers.discard(other)<EOL>s.drivers.append(self)<EOL><DEDENT><DEDENT>", "docstring": "After merging statements update IO, sensitivity and context\n\n:attention: rank is not updated", "id": "f1300:c2:m12"}
{"signature": "@internal<EOL><INDENT>@staticmethod<EOL>def _merge_statement_lists(stmsA: List[\"<STR_LIT>\"], stmsB: List[\"<STR_LIT>\"])-> List[\"<STR_LIT>\"]:<DEDENT>", "body": "if stmsA is None and stmsB is None:<EOL><INDENT>return None<EOL><DEDENT>tmp = []<EOL>a_it = iter(stmsA)<EOL>b_it = iter(stmsB)<EOL>a = None<EOL>b = None<EOL>a_empty = False<EOL>b_empty = False<EOL>while not a_empty and not b_empty:<EOL><INDENT>while not a_empty:<EOL><INDENT>a = next(a_it, None)<EOL>if a is None:<EOL><INDENT>a_empty = True<EOL>break<EOL><DEDENT>elif a.rank == <NUM_LIT:0>:<EOL><INDENT>tmp.append(a)<EOL>a = None<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>while not b_empty:<EOL><INDENT>b = next(b_it, None)<EOL>if b is None:<EOL><INDENT>b_empty = True<EOL>break<EOL><DEDENT>elif b.rank == <NUM_LIT:0>:<EOL><INDENT>tmp.append(b)<EOL>b = None<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if a is not None or b is not None:<EOL><INDENT>a._merge_with_other_stm(b)<EOL>tmp.append(a)<EOL>a = None<EOL>b = None<EOL><DEDENT><DEDENT>return tmp<EOL>", "docstring": "Merge two lists of statements into one\n\n:return: list of merged statements", "id": "f1300:c2:m18"}
{"signature": "@internal<EOL><INDENT>def _on_parent_event_dependent(self):<DEDENT>", "body": "if not self._is_completly_event_dependent:<EOL><INDENT>self._is_completly_event_dependent = True<EOL>for stm in self._iter_stms():<EOL><INDENT>stm._on_parent_event_dependent()<EOL><DEDENT><DEDENT>", "docstring": "After parrent statement become event dependent\npropagate event dependency flag to child statements", "id": "f1300:c2:m20"}
{"signature": "def isSameStatementList(stmListA: List[HdlStatement],<EOL>stmListB: List[HdlStatement]) -> bool:", "body": "if stmListA is stmListB:<EOL><INDENT>return True<EOL><DEDENT>if stmListA is None or stmListB is None:<EOL><INDENT>return False<EOL><DEDENT>for a, b in zip(stmListA, stmListB):<EOL><INDENT>if not a.isSame(b):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": ":return: True if two lists of HdlStatement instances are same", "id": "f1300:m3"}
{"signature": "def __init__(self, name, dtype, defVal=None, virtualOnly=False):", "body": "self.name = name<EOL>self._dtype = dtype<EOL>self.virtualOnly = virtualOnly<EOL>if defVal is None:<EOL><INDENT>defVal = dtype.fromPy(None)<EOL><DEDENT>self.defVal = defVal<EOL>self._setDefValue()<EOL>", "docstring": ":param name: name for better orientation in netlists\n    (used only in serialization)\n:param dtype: data type of this signal\n:param defVal: value for initialization\n:param virtualOnly: flag indicates that this assignments is only\n    virtual and should not be added into\n    netlist, because it is only for internal notation", "id": "f1301:c0:m0"}
{"signature": "@internal<EOL><INDENT>def _discover_enclosure(self):<DEDENT>", "body": "outputs = self._outputs<EOL>self._ifTrue_enclosed_for = self._discover_enclosure_for_statements(<EOL>self.ifTrue, outputs)<EOL>elif_encls = self._elIfs_enclosed_for = []<EOL>for _, stms in self.elIfs:<EOL><INDENT>e = self._discover_enclosure_for_statements(<EOL>stms, outputs)<EOL>elif_encls.append(e)<EOL><DEDENT>self._ifFalse_enclosed_for = self._discover_enclosure_for_statements(<EOL>self.ifFalse, outputs)<EOL>assert self._enclosed_for is None<EOL>encl = self._enclosed_for = set()<EOL>for s in self._ifTrue_enclosed_for:<EOL><INDENT>enclosed = True<EOL>for elif_e in elif_encls:<EOL><INDENT>if s not in elif_e:<EOL><INDENT>enclosed = False<EOL>break<EOL><DEDENT><DEDENT>if enclosed and s in self._ifFalse_enclosed_for:<EOL><INDENT>encl.add(s)<EOL><DEDENT><DEDENT>", "docstring": "Doc on parent class :meth:`HdlStatement._discover_enclosure`", "id": "f1305:c0:m4"}
{"signature": "@internal<EOL><INDENT>def _merge_with_other_stm(self, other: \"<STR_LIT>\") -> None:<DEDENT>", "body": "merge = self._merge_statement_lists<EOL>self.ifTrue = merge(self.ifTrue, other.ifTrue)<EOL>new_elifs = []<EOL>for ((c, elifA), (_, elifB)) in zip(self.elIfs, other.elIfs):<EOL><INDENT>new_elifs.append((c,  merge(elifA, elifB)))<EOL><DEDENT>self.elIfs = new_elifs<EOL>self.ifFalse = merge(self.ifFalse, other.ifFalse)<EOL>other.ifTrue = []<EOL>other.elIfs = []<EOL>other.ifFalse = None<EOL>self._on_merge(other)<EOL>", "docstring": ":attention: statements has to be mergable (to check use _is_mergable method)", "id": "f1305:c0:m11"}
{"signature": "@internal<EOL><INDENT>def _fill_enclosure(self, enclosure: Dict[RtlSignalBase, HdlStatement]):<DEDENT>", "body": "pass<EOL>", "docstring": "Enclosure is never requiered", "id": "f1309:c0:m4"}
{"signature": "def __init__(self, src, dst, indexes=None, virtualOnly=False,<EOL>parentStm=None,<EOL>sensitivity=None,<EOL>is_completly_event_dependent=False):", "body": "super(Assignment, self).__init__(<EOL>parentStm,<EOL>sensitivity,<EOL>is_completly_event_dependent)<EOL>self.src = src<EOL>isReal = not virtualOnly<EOL>if not isinstance(src, Value):<EOL><INDENT>self._inputs.append(src)<EOL>if isReal:<EOL><INDENT>src.endpoints.append(self)<EOL><DEDENT><DEDENT>self.dst = dst<EOL>if not isinstance(dst, Value):<EOL><INDENT>self._outputs.append(dst)<EOL>if isReal:<EOL><INDENT>dst.drivers.append(self)<EOL><DEDENT><DEDENT>self.indexes = indexes<EOL>if indexes:<EOL><INDENT>for i in indexes:<EOL><INDENT>if not isinstance(i, Value):<EOL><INDENT>self._inputs.append(i)<EOL>if isReal:<EOL><INDENT>i.endpoints.append(self)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>self._instId = Assignment._nextInstId()<EOL>if not virtualOnly:<EOL><INDENT>dst.ctx.statements.add(self)<EOL><DEDENT>", "docstring": ":param dst: destination to assign to\n:param src: source which is assigned from\n:param indexes: description of index selector on dst\n    (list of Index/Slice objects) (f.e. [[0], [1]] means  dst[0][1])\n:param virtualOnly: flag indicates that this assignments\n    is only virtual and should not be added into\n    netlist, because it is only for internal notation", "id": "f1309:c0:m0"}
{"signature": "@internal<EOL><INDENT>def _on_parent_event_dependent(self):<DEDENT>", "body": "if not self._is_completly_event_dependent:<EOL><INDENT>self._is_completly_event_dependent = True<EOL><DEDENT>", "docstring": "After parrent statement become event dependent", "id": "f1309:c0:m6"}
{"signature": "@internal<EOL><INDENT>def seqEval(self):<DEDENT>", "body": "self.dst._val = self.src.staticEval()<EOL>", "docstring": "Sequentially evaluate this assignment", "id": "f1309:c0:m11"}
{"signature": "@internal<EOL><INDENT>def _loadFromHStream(self, dtype: HStream, bitAddr: int) -> int:<DEDENT>", "body": "ch = TransTmpl(dtype.elmType, <NUM_LIT:0>, parent=self, origin=self.origin)<EOL>self.children.append(ch)<EOL>return bitAddr + dtype.elmType.bit_length()<EOL>", "docstring": "Parse HUnion type to this transaction template instance\n\n:return: address of it's end", "id": "f1310:c2:m5"}
{"signature": "def __exit__(self, exc_type, exc_val, exc_tb):", "body": "self.actual = self.parents.pop()<EOL>self.onParentNames.pop()<EOL>", "docstring": "Move back to parent", "id": "f1310:c1:m3"}
{"signature": "def _loadFromHType(self, dtype: HdlType, bitAddr: int) -> None:", "body": "self.bitAddr = bitAddr<EOL>childrenAreChoice = False<EOL>if isinstance(dtype, Bits):<EOL><INDENT>ld = self._loadFromBits<EOL><DEDENT>elif isinstance(dtype, HStruct):<EOL><INDENT>ld = self._loadFromHStruct<EOL><DEDENT>elif isinstance(dtype, HArray):<EOL><INDENT>ld = self._loadFromArray<EOL><DEDENT>elif isinstance(dtype, HStream):<EOL><INDENT>ld = self._loadFromHStream<EOL><DEDENT>elif isinstance(dtype, HUnion):<EOL><INDENT>ld = self._loadFromUnion<EOL>childrenAreChoice = True<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\", dtype)<EOL><DEDENT>self.bitAddrEnd = ld(dtype, bitAddr)<EOL>self.childrenAreChoice = childrenAreChoice<EOL>", "docstring": "Parse any HDL type to this transaction template instance", "id": "f1310:c2:m6"}
{"signature": "@internal<EOL><INDENT>def _loadFromUnion(self, dtype: HdlType, bitAddr: int) -> int:<DEDENT>", "body": "for field in dtype.fields.values():<EOL><INDENT>ch = TransTmpl(field.dtype, <NUM_LIT:0>, parent=self, origin=field)<EOL>self.children.append(ch)<EOL><DEDENT>return bitAddr + dtype.bit_length()<EOL>", "docstring": "Parse HUnion type to this transaction template instance\n\n:return: address of it's end", "id": "f1310:c2:m4"}
{"signature": "@internal<EOL><INDENT>def _loadFromBits(self, dtype: HdlType, bitAddr: int):<DEDENT>", "body": "return bitAddr + dtype.bit_length()<EOL>", "docstring": "Parse Bits type to this transaction template instance\n\n:return: address of it's end", "id": "f1310:c2:m2"}
{"signature": "def walkFlatten(self, offset: int=<NUM_LIT:0>,<EOL>shouldEnterFn=_default_shouldEnterFn,<EOL>otherObjItCtx: ObjIteratorCtx =_DummyIteratorCtx()<EOL>) -> Generator[<EOL>Union[Tuple[Tuple[int, int], '<STR_LIT>'], '<STR_LIT>'],<EOL>None, None]:", "body": "t = self.dtype<EOL>base = self.bitAddr + offset<EOL>end = self.bitAddrEnd + offset<EOL>shouldEnter, shouldYield = shouldEnterFn(self)<EOL>if shouldYield:<EOL><INDENT>yield ((base, end), self)<EOL><DEDENT>if shouldEnter:<EOL><INDENT>if isinstance(t, Bits):<EOL><INDENT>pass<EOL><DEDENT>elif isinstance(t, HStruct):<EOL><INDENT>for ch in self.children:<EOL><INDENT>with otherObjItCtx(ch.origin.name):<EOL><INDENT>yield from ch.walkFlatten(<EOL>offset,<EOL>shouldEnterFn,<EOL>otherObjItCtx)<EOL><DEDENT><DEDENT><DEDENT>elif isinstance(t, HArray):<EOL><INDENT>itemSize = (self.bitAddrEnd - self.bitAddr) // self.itemCnt<EOL>for i in range(self.itemCnt):<EOL><INDENT>with otherObjItCtx(i):<EOL><INDENT>yield from self.children.walkFlatten(<EOL>base + i * itemSize,<EOL>shouldEnterFn,<EOL>otherObjItCtx)<EOL><DEDENT><DEDENT><DEDENT>elif isinstance(t, HUnion):<EOL><INDENT>yield OneOfTransaction(self, offset, shouldEnterFn,<EOL>self.children)<EOL><DEDENT>elif isinstance(t, HStream):<EOL><INDENT>assert len(self.children) == <NUM_LIT:1><EOL>yield StreamTransaction(self, offset, shouldEnterFn,<EOL>self.children[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(t)<EOL><DEDENT><DEDENT>", "docstring": "Walk fields in instance of TransTmpl\n\n:param offset: optional offset for all children in this TransTmpl\n:param shouldEnterFn: function (transTmpl) which returns True\n    when field should be split on it's children\n:param shouldEnterFn: function(transTmpl) which should return\n    (shouldEnter, shouldUse) where shouldEnter is flag that means\n    iterator should look inside of this actual object\n    and shouldUse flag means that this field should be used\n    (=generator should yield it)\n:return: generator of tuples ((startBitAddress, endBitAddress),\n    TransTmpl instance)", "id": "f1310:c2:m9"}
{"signature": "def _iter_stms(self):", "body": "for _, stms in self.cases:<EOL><INDENT>yield from stms<EOL><DEDENT>if self.default is not None:<EOL><INDENT>yield from self.default<EOL><DEDENT>", "docstring": "Doc on parent class :meth:`HdlStatement._iter_stms`", "id": "f1311:c0:m6"}
{"signature": "@internal<EOL><INDENT>def _try_reduce(self) -> Tuple[List[\"<STR_LIT>\"], bool]:<DEDENT>", "body": "io_change = False<EOL>new_cases = []<EOL>for val, statements in self.cases:<EOL><INDENT>_statements, rank_decrease, _io_change = self._try_reduce_list(<EOL>statements)<EOL>io_change |= _io_change<EOL>self.rank -= rank_decrease<EOL>new_cases.append((val, _statements))<EOL><DEDENT>self.cases = new_cases<EOL>if self.default is not None:<EOL><INDENT>self.default, rank_decrease, _io_change = self._try_reduce_list(<EOL>self.default)<EOL>self.rank -= rank_decrease<EOL>io_change |= _io_change<EOL><DEDENT>reduce_self = not self._condHasEffect()<EOL>if reduce_self:<EOL><INDENT>if self.cases:<EOL><INDENT>res = self.cases[<NUM_LIT:0>][<NUM_LIT:1>]<EOL><DEDENT>elif self.default is not None:<EOL><INDENT>res = self.default<EOL><DEDENT>else:<EOL><INDENT>res = []<EOL><DEDENT><DEDENT>else:<EOL><INDENT>res = [self, ]<EOL><DEDENT>self._on_reduce(reduce_self, io_change, res)<EOL>if not self.default:<EOL><INDENT>t = self.switchOn._dtype<EOL>if isinstance(t, HEnum):<EOL><INDENT>dom_size = t.domain_size()<EOL>val_cnt = len(t._allValues)<EOL>if len(self.cases) == val_cnt and val_cnt < dom_size:<EOL><INDENT>_, stms = self.cases.pop()<EOL>self.default = stms<EOL><DEDENT><DEDENT><DEDENT>return res, io_change<EOL>", "docstring": "Doc on parent class :meth:`HdlStatement._try_reduce`", "id": "f1311:c0:m9"}
{"signature": "def getBusWordBitRange(self) -> Tuple[int, int]:", "body": "offset = self.startOfPart % self.parent.wordWidth<EOL>return (offset + self.bit_length(), offset)<EOL>", "docstring": ":return: bit range which contains data of this part on bus data signal", "id": "f1312:c0:m2"}
{"signature": "def bit_length(self) -> int:", "body": "return self.endOfPart - self.startOfPart<EOL>", "docstring": ":return: bit length of this part", "id": "f1312:c0:m1"}
{"signature": "def getFieldBitRange(self) -> Tuple[int, int]:", "body": "offset = self.inFieldOffset<EOL>return (self.bit_length() + offset, offset)<EOL>", "docstring": ":return: bit range which contains data of this part on interface\n    of field", "id": "f1312:c0:m3"}
{"signature": "@internal<EOL><INDENT>def _wordIndx(self, addr: int):<DEDENT>", "body": "return floor(addr / self.wordWidth)<EOL>", "docstring": "convert bit address to index of word where this address is", "id": "f1313:c0:m2"}
{"signature": "def __init__(self, origin, wordWidth, startBitAddr, endBitAddr,<EOL>transParts):", "body": "self.origin = origin<EOL>self.wordWidth = wordWidth<EOL>assert startBitAddr <= endBitAddr<EOL>self.startBitAddr = startBitAddr<EOL>self.endBitAddr = endBitAddr<EOL>self.parts = transParts<EOL>self._fieldToTPart = None<EOL>for p in self.parts:<EOL><INDENT>p.parent = self<EOL>assert p.startOfPart >= startBitAddr, (p, startBitAddr)<EOL>assert p.endOfPart <= endBitAddr, (p, endBitAddr)<EOL><DEDENT>", "docstring": ":param origin: instance of HType (usually HStruct)\n    from which this FrameTmpl was generated from\n:param wordWidth: width of word on interface\n    where this template should be used\n:param startBitAddr: bit offset where this frame starts\n:param endBitAddr: bit offset where this frame ends\n    (bit index of first bit behind this frame)\n:param transParts: instances of TransPart which are parts of this frame", "id": "f1313:c0:m0"}
{"signature": "def fullWordCnt(self, start: int, end: int):", "body": "assert end >= start, (start, end)<EOL>gap = max(<NUM_LIT:0>, (end - start) - (start % self.wordWidth))<EOL>return gap // self.wordWidth<EOL>", "docstring": "Count of complete words between two addresses", "id": "f1315:c4:m1"}
{"signature": "@internal<EOL>def iterSort(iterators, cmpFn):", "body": "actual = []<EOL>_iterators = []<EOL>for i, it in enumerate(iterators):<EOL><INDENT>try:<EOL><INDENT>a = next(it)<EOL>_iterators.append((i, it))<EOL>actual.append(a)<EOL><DEDENT>except StopIteration:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>while True:<EOL><INDENT>if not _iterators:<EOL><INDENT>return<EOL><DEDENT>elif len(_iterators) == <NUM_LIT:1>:<EOL><INDENT>originIndex, it = _iterators[<NUM_LIT:0>]<EOL>yield originIndex, actual[<NUM_LIT:0>]<EOL>for item in it:<EOL><INDENT>yield originIndex, item<EOL><DEDENT>return<EOL><DEDENT>minimum = None<EOL>minimumIndex = None<EOL>secondMin = None<EOL>for i, val in enumerate(actual):<EOL><INDENT>skipSecMinCheck = False<EOL>if minimum is None:<EOL><INDENT>minimum = val<EOL>minimumIndex = i<EOL><DEDENT>elif cmpFn(val, minimum):<EOL><INDENT>secondMin = minimum<EOL>minimum = val<EOL>minimumIndex = i<EOL>skipSecMinCheck = True<EOL><DEDENT>elif not skipSecMinCheck and (<EOL>secondMin is None or cmpFn(val, secondMin)):<EOL><INDENT>secondMin = val<EOL><DEDENT><DEDENT>actualI, actualIt = _iterators[minimumIndex]<EOL>while not cmpFn(secondMin, minimum):<EOL><INDENT>yield (actualI, minimum)<EOL>try:<EOL><INDENT>minimum = next(actualIt)<EOL><DEDENT>except StopIteration:<EOL><INDENT>minimum = None<EOL>break<EOL><DEDENT><DEDENT>if minimum is None:<EOL><INDENT>del _iterators[minimumIndex]<EOL>del actual[minimumIndex]<EOL><DEDENT>else:<EOL><INDENT>actual[minimumIndex] = minimum<EOL><DEDENT><DEDENT>", "docstring": "Sort items from iterators(generators) by alwas selecting item\nwith lowest value (min first)\n\n:return: generator of tuples (origin index, item) where origin index\n    is index of iterator in \"iterators\" from where item commes from", "id": "f1315:m0"}
{"signature": "def groupIntoChoices(splitsOnWord, wordWidth: int, origin: OneOfTransaction):", "body": "def cmpWordIndex(a, b):<EOL><INDENT>return a.startOfPart // wordWidth < b.startOfPart // wordWidth<EOL><DEDENT>actual = None<EOL>itCnt = len(splitsOnWord)<EOL>for i, item in iterSort(splitsOnWord, cmpWordIndex):<EOL><INDENT>_actualW = item.startOfPart // wordWidth<EOL>if actual is None:<EOL><INDENT>actual = ChoicesOfFrameParts(item.startOfPart, origin)<EOL>actual.extend(<EOL>ChoiceOfFrameParts(actual,<EOL>origin.possibleTransactions[_i])<EOL>for _i in range(itCnt))<EOL>actualW = _actualW<EOL><DEDENT>elif _actualW > actualW:<EOL><INDENT>actual.resolveEnd()<EOL>yield actual<EOL>actual = ChoicesOfFrameParts(item.startOfPart, origin)<EOL>actual.extend(<EOL>ChoiceOfFrameParts(actual,<EOL>origin.possibleTransactions[_i])<EOL>for _i in range(itCnt))<EOL>actualW = _actualW<EOL><DEDENT>actual[i].append(item)<EOL><DEDENT>if actual is not None:<EOL><INDENT>actual.setIsLast(True)<EOL>actual.resolveEnd()<EOL>yield actual<EOL><DEDENT>", "docstring": ":param splitsOnWord: list of lists of parts (fields splited on word\n    boundaries)\n:return: generators of ChoicesOfFrameParts for each word\n    which are not crossing word boundaries", "id": "f1315:m1"}
{"signature": "def getBusWordBitRange(self) -> Tuple[int, int]:", "body": "offset = self.startOfPart % self.parent.wordWidth<EOL>return (offset + self.bit_length(), offset)<EOL>", "docstring": ":return: bit range which contains data of this part on bus data signal", "id": "f1315:c0:m2"}
{"signature": "@internal<EOL><INDENT>def staticEval(self):<DEDENT>", "body": "for o in self.operands:<EOL><INDENT>o.staticEval()<EOL><DEDENT>self.result._val = self.evalFn()<EOL>", "docstring": "Recursively statistically evaluate result of this operator", "id": "f1316:c0:m2"}
{"signature": "def eval(self, operator, simulator=None):", "body": "def getVal(v):<EOL><INDENT>while not isinstance(v, Value):<EOL><INDENT>v = v._val<EOL><DEDENT>return v<EOL><DEDENT>operands = list(map(getVal, operator.operands))<EOL>if isEventDependentOp(operator.operator):<EOL><INDENT>operands.append(simulator.now)<EOL><DEDENT>elif operator.operator == AllOps.IntToBits:<EOL><INDENT>operands.append(operator.result._dtype)<EOL><DEDENT>return self._evalFn(*operands)<EOL>", "docstring": "Load all operands and process them by self._evalFn", "id": "f1317:c0:m3"}
{"signature": "def sensitivityByOp(op):", "body": "if op == AllOps.RISING_EDGE:<EOL><INDENT>return SENSITIVITY.RISING<EOL><DEDENT>elif op == AllOps.FALLING_EDGE:<EOL><INDENT>return SENSITIVITY.FALLING<EOL><DEDENT>else:<EOL><INDENT>raise TypeError()<EOL><DEDENT>", "docstring": "get sensitivity type for operator", "id": "f1317:m16"}
{"signature": "def arr_any(iterable, fn):", "body": "for item in iterable:<EOL><INDENT>if fn(item):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": ":return: True if fn(item) for any item else False", "id": "f1320:m2"}
{"signature": "def find_files(directory, pattern, recursive=True):", "body": "if not os.path.isdir(directory):<EOL><INDENT>if os.path.exists(directory):<EOL><INDENT>raise IOError(directory + '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>raise IOError(directory + \"<STR_LIT>\")<EOL><DEDENT><DEDENT>if recursive:<EOL><INDENT>for root, _, files in os.walk(directory):<EOL><INDENT>for basename in files:<EOL><INDENT>if fnmatch.fnmatch(basename, pattern):<EOL><INDENT>filename = os.path.join(root, basename)<EOL>yield filename<EOL><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>root = directory<EOL>for basename in os.listdir(root):<EOL><INDENT>if fnmatch.fnmatch(basename, pattern):<EOL><INDENT>filename = os.path.join(root, basename)<EOL>if os.path.isfile(filename):<EOL><INDENT>yield filename<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Find files by pattern in directory", "id": "f1322:m0"}
{"signature": "def __init__(self, sigOrVal: Union[RtlSignal, Value],<EOL>skipPadding: bool=True,<EOL>fillup: bool=False):", "body": "self.it = walkFlattenFields(sigOrVal, skipPadding=skipPadding)<EOL>self.fillup = fillup<EOL>self.actuallyHave = <NUM_LIT:0><EOL>self.actual = None<EOL>self.actualOffset = <NUM_LIT:0><EOL>", "docstring": ":param skipPadding: if true padding is skipped in dense types", "id": "f1325:c2:m0"}
{"signature": "def iterBits(sigOrVal: Union[RtlSignal, Value], bitsInOne: int=<NUM_LIT:1>,<EOL>skipPadding: bool=True, fillup: bool=False):", "body": "bw = BitWalker(sigOrVal, skipPadding, fillup)<EOL>for _ in range(ceil(sigOrVal._dtype.bit_length() / bitsInOne)):<EOL><INDENT>yield bw.get(bitsInOne)<EOL><DEDENT>bw.assertIsOnEnd()<EOL>", "docstring": "Iterate over bits in vector\n\n:param sigOrVal: signal or value to iterate over\n:param bitsInOne: number of bits in one part\n:param skipPadding: if true padding is skipped in dense types", "id": "f1325:m2"}
{"signature": "@internal<EOL><INDENT>def _loadDeclarations(self):<DEDENT>", "body": "if not hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._interfaces = []<EOL><DEDENT>if not hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._private_interfaces = []<EOL><DEDENT>if not hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._units = []<EOL><DEDENT>self._setAttrListener = self._declrCollector<EOL>self._declr()<EOL>self._setAttrListener = None<EOL>for i in self._interfaces:<EOL><INDENT>self._loadInterface(i, True)<EOL><DEDENT>for u in self._units:<EOL><INDENT>u._loadDeclarations()<EOL><DEDENT>for p in self._params:<EOL><INDENT>p.setReadOnly()<EOL><DEDENT>", "docstring": "Load all declarations from _decl() method, recursively\nfor all interfaces/units.", "id": "f1327:c0:m5"}
{"signature": "@internal<EOL><INDENT>@classmethod<EOL>def _nextInstId(cls):<DEDENT>", "body": "i = cls.__instCntr<EOL>cls.__instCntr += <NUM_LIT:1><EOL>return i<EOL>", "docstring": "Get next instance id", "id": "f1328:c0:m1"}
{"signature": "@internal<EOL>def statements_to_HWProcesses(statements: List[HdlStatement])-> Generator[HWProcess, None, None]:", "body": "<EOL>statements = copy(statements)<EOL>processes = []<EOL>while statements:<EOL><INDENT>stm = statements.pop()<EOL>proc_statements = [stm, ]<EOL>ps = _statements_to_HWProcesses(proc_statements, True)<EOL>processes.extend(ps)<EOL><DEDENT>yield from reduceProcesses(processes)<EOL>", "docstring": "Pack statements into HWProcess instances,\n* for each out signal resolve it's drivers and collect them\n* split statements if there is and combinational loop\n* merge statements if it is possible\n* resolve sensitivitilists\n* wrap into HWProcess instance\n* for every IO of process generate name if signal has not any", "id": "f1329:m3"}
{"signature": "def _eq(self, other):", "body": "return self.naryOp(AllOps.EQ, tv(self)._eq, other)<EOL>", "docstring": "__eq__ is not overloaded because it will destroy hashability of object", "id": "f1334:c0:m14"}
{"signature": "@internal<EOL>def tryToMerge(procA: HWProcess, procB: HWProcess):", "body": "if (checkIfIsTooSimple(procA) or<EOL>checkIfIsTooSimple(procB) or<EOL>areSetsIntersets(procA.outputs, procB.sensitivityList) or<EOL>areSetsIntersets(procB.outputs, procA.sensitivityList) or<EOL>not HdlStatement._is_mergable_statement_list(procA.statements, procB.statements)):<EOL><INDENT>raise IncompatibleStructure()<EOL><DEDENT>procA.statements = HdlStatement._merge_statement_lists(<EOL>procA.statements, procB.statements)<EOL>procA.outputs.extend(procB.outputs)<EOL>procA.inputs.extend(procB.inputs)<EOL>procA.sensitivityList.extend(procB.sensitivityList)<EOL>return procA<EOL>", "docstring": "Try merge procB into procA\n\n:raise IncompatibleStructure: if merge is not possible\n:attention: procA is now result if merge has succeed\n:return: procA which is now result of merge", "id": "f1336:m2"}
{"signature": "@internal<EOL><INDENT>def _registerArray(self, name, items):<DEDENT>", "body": "items._parent = self<EOL>items._name = name<EOL>for i, item in enumerate(items):<EOL><INDENT>setattr(self, \"<STR_LIT>\" % (name, i), item)<EOL><DEDENT>", "docstring": "Register array of items on interface level object", "id": "f1339:c2:m13"}
{"signature": "@internal<EOL><INDENT>def _registerParameter(self, pName, parameter) -> None:<DEDENT>", "body": "nameAvailabilityCheck(self, pName, parameter)<EOL>try:<EOL><INDENT>hasName = parameter._name is not None<EOL><DEDENT>except AttributeError:<EOL><INDENT>hasName = False<EOL><DEDENT>if not hasName:<EOL><INDENT>parameter._name = pName<EOL><DEDENT>parameter._registerScope(pName, self)<EOL>if parameter.hasGenericName:<EOL><INDENT>parameter.name = pName<EOL><DEDENT>if parameter._parent is None:<EOL><INDENT>parameter._parent = self<EOL><DEDENT>self._params.append(parameter)<EOL>", "docstring": "Register Param object on interface level object", "id": "f1339:c2:m5"}
{"signature": "@internal<EOL>def nameAvailabilityCheck(obj, propName, prop):", "body": "if getattr(obj, propName, None) is not None:<EOL><INDENT>raise IntfLvlConfErr(\"<STR_LIT>\" % <EOL>(obj, propName, repr(getattr(obj, propName)), prop))<EOL><DEDENT>", "docstring": "Check if not redefining property on obj", "id": "f1339:m0"}
{"signature": "def _paramsShared(self, exclude=None, prefix=\"<STR_LIT>\") -> MakeParamsShared:", "body": "return MakeParamsShared(self, exclude=exclude, prefix=prefix)<EOL>", "docstring": "Auto-propagate params by name to child components and interfaces\nUsage:\n\n.. code-block:: python\n\n    with self._paramsShared():\n        # your interfaces and unit which should share all params with \"self\" there\n\n:param exclude: params which should not be shared\n:param prefix: prefix which should be added to name of child parameters\n    before parameter name matching", "id": "f1339:c2:m6"}
{"signature": "def walkParams(intf, discovered):", "body": "for si in intf._interfaces:<EOL><INDENT>yield from walkParams(si, discovered)<EOL><DEDENT>for p in intf._params:<EOL><INDENT>if p not in discovered:<EOL><INDENT>discovered.add(p)<EOL>yield p<EOL><DEDENT><DEDENT>", "docstring": "walk parameter instances on this interface", "id": "f1342:m1"}
{"signature": "@internal<EOL><INDENT>def _cleanAsSubunit(self):<DEDENT>", "body": "for pi in self._entity.ports:<EOL><INDENT>pi.connectInternSig()<EOL><DEDENT>for i in chain(self._interfaces, self._private_interfaces):<EOL><INDENT>i._clean()<EOL><DEDENT>", "docstring": "Disconnect internal signals so unit can be reused by parent unit", "id": "f1346:c0:m2"}
{"signature": "def _updateParamsFrom(self, otherObj, updater=_default_param_updater,<EOL>exclude=None, prefix=\"<STR_LIT>\"):", "body": "PropDeclrCollector._updateParamsFrom(self, otherObj, updater, exclude, prefix)<EOL>", "docstring": ":note: doc in :func:`~hwt.synthesizer.interfaceLevel.propDeclCollector._updateParamsFrom`", "id": "f1348:c0:m10"}
{"signature": "def _bit_length(self):", "body": "try:<EOL><INDENT>interfaces = self._interfaces<EOL><DEDENT>except AttributeError:<EOL><INDENT>interfaces = None<EOL><DEDENT>if interfaces is None:<EOL><INDENT>_intf = self._clone()<EOL>_intf._loadDeclarations()<EOL>interfaces = _intf._interfaces<EOL><DEDENT>if interfaces:<EOL><INDENT>w = <NUM_LIT:0><EOL>for i in interfaces:<EOL><INDENT>w += i._bit_length()<EOL><DEDENT>return w<EOL><DEDENT>else:<EOL><INDENT>return self._dtype.bit_length()<EOL><DEDENT>", "docstring": "Sum of all width of interfaces in this interface", "id": "f1348:c0:m11"}
{"signature": "def _getPhysicalName(self):", "body": "if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>return self._boundedEntityPort.name<EOL><DEDENT>else:<EOL><INDENT>return self._getFullName().replace('<STR_LIT:.>', self._NAME_SEPARATOR)<EOL><DEDENT>", "docstring": "Get name in HDL", "id": "f1348:c0:m7"}
{"signature": "def __init__(self, masterDir=DIRECTION.OUT,<EOL>loadConfig=True):", "body": "self._setAttrListener = None<EOL>self._associatedClk = None<EOL>self._associatedRst = None<EOL>self._parent = None<EOL>super().__init__()<EOL>self._masterDir = masterDir<EOL>self._direction = INTF_DIRECTION.UNKNOWN<EOL>self._ctx = None<EOL>if loadConfig:<EOL><INDENT>self._loadConfig()<EOL><DEDENT>self._isExtern = False<EOL>self._isAccessible = True<EOL>self._ag = None<EOL>", "docstring": "This constructor is called when constructing new interface,\nit is usually done manually while creating Unit or\nautomatically while extracting interfaces from UnitWithSoure\n\n:param masterDir: direction which this interface should have for master\n:param multiplyedBy: this can be instance of integer or Param,\n    this mean the interface is array of the interfaces\n    where multiplyedBy is the size\n:param loadConfig: do load config in __init__", "id": "f1348:c0:m0"}
{"signature": "def _getFullName(self):", "body": "return HObjList._getFullName(self)<EOL>", "docstring": "get all name hierarchy separated by '.", "id": "f1348:c0:m8"}
{"signature": "def _make_association(self, *args, **kwargs):", "body": "for o in self:<EOL><INDENT>o._make_association(*args, **kwargs)<EOL><DEDENT>", "docstring": "Delegate _make_association on items\n\n:note: doc in :func:`~hwt.synthesizer.interfaceLevel.propDeclCollector._make_association`", "id": "f1349:c0:m3"}
{"signature": "@internal<EOL>def _mkOp(fn):", "body": "def op(*operands, key=None) -> RtlSignalBase:<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>assert operands, operands<EOL>top = None<EOL>if key is not None:<EOL><INDENT>operands = map(key, operands)<EOL><DEDENT>for s in operands:<EOL><INDENT>if top is None:<EOL><INDENT>top = s<EOL><DEDENT>else:<EOL><INDENT>top = fn(top, s)<EOL><DEDENT><DEDENT>return top<EOL><DEDENT>return op<EOL>", "docstring": "Function to create variadic operator function\n\n:param fn: function to perform binary operation", "id": "f1352:m2"}
{"signature": "def __le__(self, other):", "body": "return self._sig.__le__(other)<EOL>", "docstring": "<=", "id": "f1353:c0:m10"}
{"signature": "def __ge__(self, other):", "body": "return self._sig.__ge__(other)<EOL>", "docstring": ">=", "id": "f1353:c0:m9"}
{"signature": "def __call__(self, source):", "body": "assert self._isAccessible<EOL>return self._sig(source)<EOL>", "docstring": "connect this signal to driver\n\n:attention: it is not call of function it is operator of assignment\n:return: list of assignments", "id": "f1353:c0:m23"}
{"signature": "def __and__(self, other):", "body": "return self._sig.__and__(other)<EOL>", "docstring": "& operator - logical 'and' for one bit signals and hBool\nbitwise and for wider signals", "id": "f1353:c0:m12"}
{"signature": "def onTWriteCallback__init(self, sim):", "body": "yield from self.onTWriteCallback(sim)<EOL>self.intf.t._sigInside.registerWriteCallback(<EOL>self.onTWriteCallback,<EOL>self.getEnable)<EOL>self.intf.o._sigInside.registerWriteCallback(<EOL>self.onTWriteCallback,<EOL>self.getEnable)<EOL>", "docstring": "Process for injecting of this callback loop into simulator", "id": "f1359:c1:m5"}
{"signature": "def getVld(self):", "body": "return self.intf.vld._sigInside<EOL>", "docstring": "get \"valid\" signal", "id": "f1368:c0:m6"}
{"signature": "def getRd(self):", "body": "return self.intf.rd._sigInside<EOL>", "docstring": "get \"ready\" signal", "id": "f1368:c0:m3"}
{"signature": "def driver(self, sim):", "body": "r = sim.read<EOL>if self.actualData is NOP and self.data:<EOL><INDENT>self.actualData = self.data.popleft()<EOL><DEDENT>doSend = self.actualData is not NOP<EOL>if self.actualData is not self._lastWritten:<EOL><INDENT>if doSend:<EOL><INDENT>self.doWrite(sim, self.actualData)<EOL><DEDENT>else:<EOL><INDENT>self.doWrite(sim, None)<EOL><DEDENT>self._lastWritten = self.actualData<EOL><DEDENT>en = self.notReset(sim)<EOL>vld = int(en and doSend)<EOL>if self._lastVld is not vld:<EOL><INDENT>self.wrVld(sim.write, vld)<EOL>self._lastVld = vld<EOL><DEDENT>if not self._enabled:<EOL><INDENT>sim.add_process(self.checkIfRdWillBeValid(sim))<EOL>return<EOL><DEDENT>yield sim.waitOnCombUpdate()<EOL>rd = self.isRd(r)<EOL>assert rd.vldMask, (sim.now, self.intf,<EOL>\"<STR_LIT>\")<EOL>if not vld:<EOL><INDENT>return<EOL><DEDENT>if rd.val:<EOL><INDENT>if self._debugOutput is not None:<EOL><INDENT>self._debugOutput.write(\"<STR_LIT>\" % (<EOL>self.intf._getFullName(),<EOL>sim.now,<EOL>self.actualData))<EOL><DEDENT>a = self.actualData<EOL>if self.data:<EOL><INDENT>self.actualData = self.data.popleft()<EOL><DEDENT>else:<EOL><INDENT>self.actualData = NOP<EOL><DEDENT>onDriverWriteAck = getattr(self, \"<STR_LIT>\", None)<EOL>if onDriverWriteAck is not None:<EOL><INDENT>onDriverWriteAck(sim)<EOL><DEDENT>onDone = getattr(a, \"<STR_LIT>\", None)<EOL>if onDone is not None:<EOL><INDENT>onDone(sim)<EOL><DEDENT><DEDENT>", "docstring": "Push data to interface\n\nset vld high and wait on rd in high then pass new data", "id": "f1368:c0:m13"}
{"signature": "def pullUpAfter(sig, initDelay=<NUM_LIT:6> * Time.ns):", "body": "def _pullDownAfter(s):<EOL><INDENT>s.write(False, sig)<EOL>yield s.wait(initDelay)<EOL>s.write(True, sig)<EOL><DEDENT>return _pullDownAfter<EOL>", "docstring": ":return: Simulation driver which keeps signal value low for initDelay then\n    it sets value to 1", "id": "f1369:m1"}
{"signature": "def propagateClkRst(obj):", "body": "clk = obj.clk<EOL>rst = obj.rst<EOL>for u in obj._units:<EOL><INDENT>_tryConnect(clk, u, '<STR_LIT>')<EOL>_tryConnect(~rst, u, '<STR_LIT>')<EOL>_tryConnect(rst, u, '<STR_LIT>')<EOL><DEDENT>", "docstring": "Propagate \"clk\" clock and reset \"rst\" signal to all subcomponents", "id": "f1372:m5"}
{"signature": "def propagateRstn(obj):", "body": "rst_n = obj.rst_n<EOL>for u in obj._units:<EOL><INDENT>_tryConnect(rst_n, u, '<STR_LIT>')<EOL>_tryConnect(~rst_n, u, '<STR_LIT>')<EOL><DEDENT>", "docstring": "Propagate negative reset \"rst_n\" signal\nto all subcomponents", "id": "f1372:m6"}
{"signature": "def propagateClk(obj):", "body": "clk = obj.clk<EOL>for u in obj._units:<EOL><INDENT>_tryConnect(clk, u, '<STR_LIT>')<EOL><DEDENT>", "docstring": "Propagate \"clk\" clock signal to all subcomponents", "id": "f1372:m3"}
{"signature": "@internal<EOL>def _serializeParamsUniq_eval(parentUnit, obj, isDeclaration, priv):", "body": "params = paramsToValTuple(parentUnit)<EOL>if priv is None:<EOL><INDENT>priv = {}<EOL><DEDENT>if isDeclaration:<EOL><INDENT>try:<EOL><INDENT>prevUnit = priv[params]<EOL><DEDENT>except KeyError:<EOL><INDENT>priv[params] = parentUnit<EOL>return True, priv<EOL><DEDENT>prepareEntity(obj, prevUnit._entity.name, prevUnit)<EOL>return False, priv<EOL><DEDENT>return priv[params] is parentUnit, priv<EOL>", "docstring": "Decide to serialize only objs with uniq parameters and class\n\n:param priv: private data for this function\n    ({frozen_params: obj})\n\n:return: tuple (do serialize this object, next priv)", "id": "f1374:m8"}
{"signature": "def registerMUX(self, stm: Union[HdlStatement, Operator], sig: RtlSignal,<EOL>inputs_cnt: int):", "body": "assert inputs_cnt > <NUM_LIT:1><EOL>res = self.resources<EOL>w = sig._dtype.bit_length()<EOL>k = (ResourceMUX, w, inputs_cnt)<EOL>res[k] = res.get(k, <NUM_LIT:0>) + <NUM_LIT:1><EOL>self.resource_for_object[(stm, sig)] = k<EOL>", "docstring": "mux record is in format (self.MUX, n, m)\nwhere n is number of bits of this mux\nand m is number of possible inputs", "id": "f1385:c0:m2"}
{"signature": "@internal<EOL><INDENT>def serialzeValueToTCL(self, val, do_eval=False) -> Tuple[str, str, bool]:<DEDENT>", "body": "if isinstance(val, int):<EOL><INDENT>val = hInt(val)<EOL><DEDENT>if do_eval:<EOL><INDENT>val = val.staticEval()<EOL><DEDENT>if isinstance(val, RtlSignalBase):<EOL><INDENT>ctx = VivadoTclExpressionSerializer.getBaseContext()<EOL>tclVal = VivadoTclExpressionSerializer.asHdl(val, ctx)<EOL>tclValVal = VivadoTclExpressionSerializer.asHdl(<EOL>val.staticEval())<EOL>return tclVal, tclValVal, False<EOL><DEDENT>else:<EOL><INDENT>tclVal = VivadoTclExpressionSerializer.asHdl(val, None)<EOL>return tclVal, tclVal, True<EOL><DEDENT>", "docstring": ":see: doc of method on parent class", "id": "f1386:c1:m16"}
{"signature": "@internal<EOL><INDENT>def getTypeWidth(self, dtype: HdlType, do_eval=False) -> Tuple[int, Union[int, RtlSignal], bool]:<DEDENT>", "body": "width = dtype.width<EOL>if isinstance(width, int):<EOL><INDENT>widthStr = str(width)<EOL><DEDENT>else:<EOL><INDENT>widthStr = self.getExprVal(width, do_eval=do_eval)<EOL><DEDENT>return width, widthStr, False<EOL>", "docstring": ":see: doc of method on parent class", "id": "f1386:c1:m14"}
{"signature": "@classmethod<EOL><INDENT>def HWProcess(cls, proc, ctx):<DEDENT>", "body": "body = proc.statements<EOL>extraVars = []<EOL>extraVarsSerialized = []<EOL>hasToBeVhdlProcess = extraVars orarr_any(body,<EOL>lambda x: isinstance(x,<EOL>(IfContainer,<EOL>SwitchContainer,<EOL>WhileContainer,<EOL>WaitStm)) or<EOL>(isinstance(x, Assignment) and<EOL>x.indexes))<EOL>anyIsEventDependnt = arr_any(<EOL>proc.sensitivityList, lambda s: isinstance(s, Operator))<EOL>sensitivityList = sorted(<EOL>map(lambda s: cls.sensitivityListItem(s, ctx,<EOL>anyIsEventDependnt),<EOL>proc.sensitivityList))<EOL>if hasToBeVhdlProcess:<EOL><INDENT>childCtx = ctx.withIndent()<EOL><DEDENT>else:<EOL><INDENT>childCtx = ctx<EOL><DEDENT>def createTmpVarFn(suggestedName, dtype):<EOL><INDENT>s = SignalItem(None, dtype, virtualOnly=True)<EOL>s.name = childCtx.scope.checkedName(suggestedName, s)<EOL>s.hidden = False<EOL>serializedS = cls.SignalItem(s, childCtx, declaration=True)<EOL>extraVars.append(s)<EOL>extraVarsSerialized.append(serializedS)<EOL>return s<EOL><DEDENT>childCtx.createTmpVarFn = createTmpVarFn<EOL>statemets = [cls.asHdl(s, childCtx) for s in body]<EOL>if hasToBeVhdlProcess:<EOL><INDENT>proc.name = ctx.scope.checkedName(proc.name, proc)<EOL><DEDENT>extraVarsInit = []<EOL>for s in extraVars:<EOL><INDENT>a = Assignment(s.defVal, s, virtualOnly=True)<EOL>extraVarsInit.append(cls.Assignment(a, childCtx))<EOL><DEDENT>return cls.processTmpl.render(<EOL>indent=getIndent(ctx.indent),<EOL>name=proc.name,<EOL>hasToBeVhdlProcess=hasToBeVhdlProcess,<EOL>extraVars=extraVarsSerialized,<EOL>sensitivityList=\"<STR_LIT>\".join(sensitivityList),<EOL>statements=extraVarsInit + statemets<EOL>)<EOL>", "docstring": "Serialize HWProcess objects", "id": "f1400:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def hardcodeRomIntoProcess(cls, rom):<DEDENT>", "body": "processes = []<EOL>signals = []<EOL>for e in rom.endpoints:<EOL><INDENT>assert isinstance(e, Operator) and e.operator == AllOps.INDEX, e<EOL>me, index = e.operands<EOL>assert me is rom<EOL>romValSig = rom.ctx.sig(rom.name, dtype=e.result._dtype)<EOL>signals.append(romValSig)<EOL>romValSig.hidden = False<EOL>cases = [(toHVal(i), [romValSig(v), ])<EOL>for i, v in enumerate(rom.defVal.val)]<EOL>statements = [SwitchContainer(index, cases), ]<EOL>for (_, (stm, )) in cases:<EOL><INDENT>stm.parentStm = statements[<NUM_LIT:0>] <EOL><DEDENT>p = HWProcess(rom.name, statements, {index, },<EOL>{index, }, {romValSig, })<EOL>processes.append(p)<EOL>def replaceOrigRomIndexExpr(x):<EOL><INDENT>if x is e.result:<EOL><INDENT>return romValSig<EOL><DEDENT>else:<EOL><INDENT>return x<EOL><DEDENT><DEDENT>for _e in e.result.endpoints:<EOL><INDENT>_e.operands = tuple(map(replaceOrigRomIndexExpr, _e.operands))<EOL>e.result = romValSig<EOL><DEDENT><DEDENT>return processes, signals<EOL>", "docstring": "Due to verilog restrictions it is not posible to use array constants\nand rom memories has to be hardcoded as process", "id": "f1404:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def Value(cls, val, ctx: SerializerCtx):<DEDENT>", "body": "t = val._dtype<EOL>if isinstance(val, RtlSignalBase):<EOL><INDENT>return cls.SignalItem(val, ctx)<EOL><DEDENT>c = cls.Value_try_extract_as_const(val, ctx)<EOL>if c:<EOL><INDENT>return c<EOL><DEDENT>if isinstance(t, Slice):<EOL><INDENT>return cls.Slice_valAsHdl(t, val, ctx)<EOL><DEDENT>elif isinstance(t, HArray):<EOL><INDENT>return cls.HArrayValAsHdl(t, val, ctx)<EOL><DEDENT>elif isinstance(t, Bits):<EOL><INDENT>return cls.Bits_valAsHdl(t, val, ctx)<EOL><DEDENT>elif isinstance(t, HBool):<EOL><INDENT>return cls.Bool_valAsHdl(t, val, ctx)<EOL><DEDENT>elif isinstance(t, HEnum):<EOL><INDENT>return cls.HEnumValAsHdl(t, val, ctx)<EOL><DEDENT>elif isinstance(t, Integer):<EOL><INDENT>return cls.Integer_valAsHdl(t, val, ctx)<EOL><DEDENT>elif isinstance(t, String):<EOL><INDENT>return cls.String_valAsHdl(t, val, ctx)<EOL><DEDENT>else:<EOL><INDENT>raise SerializerException(<EOL>\"<STR_LIT>\"<EOL>% (val))<EOL><DEDENT>", "docstring": ":param dst: is signal connected with value\n:param val: value object, can be instance of Signal or Value", "id": "f1414:c0:m0"}
{"signature": "def getIndent(indentNum):", "body": "try:<EOL><INDENT>return _indentCache[indentNum]<EOL><DEDENT>except KeyError:<EOL><INDENT>i = \"<STR_LIT>\".join([_indent for _ in range(indentNum)])<EOL>_indentCache[indentNum] = i<EOL>return i<EOL><DEDENT>", "docstring": "Cached indent getter function", "id": "f1420:m0"}
{"signature": "@classmethod<EOL><INDENT>def serializationDecision(cls, obj, serializedClasses,<EOL>serializedConfiguredUnits):<DEDENT>", "body": "isDeclaration = isinstance(obj, Entity)<EOL>isDefinition = isinstance(obj, Architecture)<EOL>if isDeclaration:<EOL><INDENT>unit = obj.origin<EOL><DEDENT>elif isDefinition:<EOL><INDENT>unit = obj.entity.origin<EOL><DEDENT>else:<EOL><INDENT>return True<EOL><DEDENT>assert isinstance(unit, Unit)<EOL>sd = unit._serializeDecision<EOL>if sd is None:<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>prevPriv = serializedClasses.get(unit.__class__, None)<EOL>seriazlize, nextPriv = sd(unit, obj, isDeclaration, prevPriv)<EOL>serializedClasses[unit.__class__] = nextPriv<EOL>return seriazlize<EOL><DEDENT>", "docstring": "Decide if this unit should be serialized or not eventually fix name\nto fit same already serialized unit\n\n:param obj: object to serialize\n:param serializedClasses: dict {unitCls : unitobj}\n:param serializedConfiguredUnits: (unitCls, paramsValues) : unitObj\n    where paramsValues are named tuple name:value", "id": "f1421:c1:m6"}
{"signature": "@internal<EOL>def ternaryOpsToIf(statements):", "body": "stms = []<EOL>for st in statements:<EOL><INDENT>if isinstance(st, Assignment):<EOL><INDENT>try:<EOL><INDENT>if not isinstance(st.src, RtlSignalBase):<EOL><INDENT>raise DoesNotContainsTernary()<EOL><DEDENT>d = st.src.singleDriver()<EOL>if not isinstance(d, Operator) or d.operator != AllOps.TERNARY:<EOL><INDENT>raise DoesNotContainsTernary()<EOL><DEDENT>else:<EOL><INDENT>ops = d.operands<EOL>ifc = IfContainer(ops[<NUM_LIT:0>],<EOL>[Assignment(ops[<NUM_LIT:1>], st.dst)],<EOL>[Assignment(ops[<NUM_LIT:2>], st.dst)]<EOL>)<EOL>stms.append(ifc)<EOL>continue<EOL><DEDENT><DEDENT>except (MultipleDriversErr, DoesNotContainsTernary):<EOL><INDENT>pass<EOL><DEDENT>except NoDriverErr:<EOL><INDENT>assert (hasattr(st.src, \"<STR_LIT>\")<EOL>and st.src._interface is not None)or st.src.defVal.vldMask, st.src<EOL><DEDENT><DEDENT>stms.append(st)<EOL><DEDENT>return stms<EOL>", "docstring": "Convert all ternary operators to IfContainers", "id": "f1426:m0"}
{"signature": "@classmethod<EOL><INDENT>def HWProcess(cls, proc, ctx):<DEDENT>", "body": "body = proc.statements<EOL>extraVars = []<EOL>extraVarsSerialized = []<EOL>hasToBeVhdlProcess = arr_any(body,<EOL>lambda x: isinstance(x,<EOL>(IfContainer,<EOL>SwitchContainer,<EOL>WhileContainer,<EOL>WaitStm)))<EOL>sensitivityList = sorted(<EOL>map(lambda s: cls.sensitivityListItem(s, ctx),<EOL>proc.sensitivityList))<EOL>if hasToBeVhdlProcess:<EOL><INDENT>childCtx = ctx.withIndent()<EOL><DEDENT>else:<EOL><INDENT>childCtx = copy(ctx)<EOL><DEDENT>def createTmpVarFn(suggestedName, dtype):<EOL><INDENT>s = RtlSignal(None, None, dtype, virtualOnly=True)<EOL>s.name = ctx.scope.checkedName(suggestedName, s)<EOL>s.hidden = False<EOL>serializedS = cls.SignalItem(s, childCtx, declaration=True)<EOL>extraVars.append(s)<EOL>extraVarsSerialized.append(serializedS)<EOL>return s<EOL><DEDENT>childCtx.createTmpVarFn = createTmpVarFn<EOL>statemets = [cls.asHdl(s, childCtx) for s in body]<EOL>proc.name = ctx.scope.checkedName(proc.name, proc)<EOL>extraVarsInit = []<EOL>for s in extraVars:<EOL><INDENT>if isinstance(s.defVal, RtlSignalBase) or s.defVal.vldMask:<EOL><INDENT>a = Assignment(s.defVal, s, virtualOnly=True)<EOL>extraVarsInit.append(cls.Assignment(a, childCtx))<EOL><DEDENT>else:<EOL><INDENT>assert s.drivers, s<EOL><DEDENT>for d in s.drivers:<EOL><INDENT>extraVarsInit.append(cls.asHdl(d, childCtx))<EOL><DEDENT><DEDENT>_hasToBeVhdlProcess = hasToBeVhdlProcess<EOL>hasToBeVhdlProcess = extraVars or hasToBeVhdlProcess<EOL>if hasToBeVhdlProcess and not _hasToBeVhdlProcess:<EOL><INDENT>oneIndent = getIndent(<NUM_LIT:1>)<EOL>statemets = list(map(lambda x: oneIndent + x, statemets))<EOL><DEDENT>return cls.processTmpl.render(<EOL>indent=getIndent(ctx.indent),<EOL>name=proc.name,<EOL>hasToBeVhdlProcess=hasToBeVhdlProcess,<EOL>extraVars=extraVarsSerialized,<EOL>sensitivityList=\"<STR_LIT:U+002CU+0020>\".join(sensitivityList),<EOL>statements=extraVarsInit + statemets<EOL>)<EOL>", "docstring": "Serialize HWProcess objects as VHDL\n\n:param scope: name scope to prevent name collisions", "id": "f1426:c1:m1"}
{"signature": "def logChange(self, nowTime, sig, nextVal):", "body": "try:<EOL><INDENT>hwProc = self.registered[sig]<EOL><DEDENT>except KeyError:<EOL><INDENT>return<EOL><DEDENT>if hwProc.actualTime < nowTime:<EOL><INDENT>a = hwProc.actualTime<EOL>if a < <NUM_LIT:0>:<EOL><INDENT>a = <NUM_LIT:0><EOL><DEDENT>delay = int(nowTime - a)<EOL>if delay > <NUM_LIT:0>:<EOL><INDENT>hwProc.statements.append(<EOL>WaitStm(int(delay) // <NUM_LIT:1000>)<EOL>)<EOL>hwProc.actualTime = nowTime<EOL><DEDENT><DEDENT>try:<EOL><INDENT>nextVal._dtype.forceVector = hwProc.driverFor._dtype.forceVector<EOL><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT>hwProc.statements.extend(<EOL>connect(nextVal, hwProc.driverFor)<EOL>)<EOL>", "docstring": "This method is called for every value change of any signal.", "id": "f1434:c0:m2"}
{"signature": "def logApplyingValues(self, simulator, values):", "body": "", "docstring": "Log simulator value quantum applied", "id": "f1435:c0:m4"}
{"signature": "@internal<EOL>def mkArrayUpdater(nextItemVal: Value, indexes: Tuple[Value],<EOL>invalidate: bool):", "body": "def updater(currentVal):<EOL><INDENT>if len(indexes) > <NUM_LIT:1>:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\")<EOL><DEDENT>_nextItemVal = nextItemVal.clone()<EOL>if invalidate:<EOL><INDENT>_nextItemVal.vldMask = <NUM_LIT:0><EOL><DEDENT>index = indexes[<NUM_LIT:0>]<EOL>change = valueHasChanged(currentVal._getitem__val(index), _nextItemVal)<EOL>currentVal._setitem__val(index, _nextItemVal)<EOL>return (change, currentVal)<EOL><DEDENT>return updater<EOL>", "docstring": "Create value updater for simulation for value of array type\n\n:param nextVal: instance of Value which will be asssiggned to signal\n:param indexes: tuple on indexes where value should be updated\n    in target array\n\n:return: function(value) -> tuple(valueHasChangedFlag, nextVal)", "id": "f1436:m4"}
{"signature": "@internal<EOL>def sensitivity(proc: HWProcess, *sensitiveTo):", "body": "for s in sensitiveTo:<EOL><INDENT>if isinstance(s, tuple):<EOL><INDENT>sen, s = s<EOL>if sen == SENSITIVITY.ANY:<EOL><INDENT>s.simSensProcs.add(proc)<EOL><DEDENT>elif sen == SENSITIVITY.RISING:<EOL><INDENT>s.simRisingSensProcs.add(proc)<EOL><DEDENT>elif sen == SENSITIVITY.FALLING:<EOL><INDENT>s.simFallingSensProcs.add(proc)<EOL><DEDENT>else:<EOL><INDENT>raise AssertionError(sen)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>s.simSensProcs.add(proc)<EOL><DEDENT><DEDENT>", "docstring": "register sensitivity for process", "id": "f1436:m0"}
{"signature": "def assertValSequenceEqual(self, seq1, seq2, msg=None, seq_type=None):", "body": "seq1 = allValuesToInts(seq1)<EOL>self.assertSequenceEqual(seq1, seq2, msg, seq_type)<EOL>", "docstring": "An equality assertion for ordered sequences (like lists and tuples).\nFor the purposes of this function, a valid ordered sequence type is one\nwhich can be indexed, has a length, and has an equality operator.\n\nArgs:\n\n:param seq1: can contain instance of values or nested list of them\n:param seq2: items are not converted\n:param seq_type: The expected datatype of the sequences, or None if no\n    datatype should be enforced.\n:param msg: Optional message to use on failure instead of a list of\n    differences.", "id": "f1437:c0:m6"}
{"signature": "def registerWriteCallback(self, callback, getEnFn) -> int:", "body": "index = len(self._writeCallbacks)<EOL>self._writeCallbacks.append(None)<EOL>self._writeCallbacksToEn.append((index, callback, getEnFn))<EOL>return index<EOL>", "docstring": "Register writeCallback for signal.\nRegistration is evaluated at the end of deltastep of simulator.\n\n:param callback: simulation process represented by function(simulator)\n    which should be called after update of this signal\n:param getEnFn: function() to get initial value for enable of callback", "id": "f1443:c0:m1"}
{"signature": "def simUpdateVal(self, simulator, valUpdater):", "body": "dirtyFlag, newVal = valUpdater(self._oldVal)<EOL>if dirtyFlag:<EOL><INDENT>self._val = newVal<EOL>newVal.updateTime = simulator.now<EOL>log = simulator.config.logChange<EOL>if log:<EOL><INDENT>log(simulator.now, self, newVal)<EOL><DEDENT>self.simPropagateChanges(simulator)<EOL><DEDENT>", "docstring": "Method called by simulator to update new value for this object", "id": "f1443:c0:m4"}
{"signature": "@internal<EOL><INDENT>def _runSeqProcesses(self) -> Generator[None, None, None]:<DEDENT>", "body": "updates = []<EOL>for proc in self._seqProcsToRun:<EOL><INDENT>try:<EOL><INDENT>outContainer = self._outputContainers[proc]<EOL><DEDENT>except KeyError:<EOL><INDENT>outContainer = None<EOL><DEDENT>proc(self, outContainer)<EOL>if outContainer is not None:<EOL><INDENT>updates.append(outContainer)<EOL><DEDENT><DEDENT>self._seqProcsToRun = UniqList()<EOL>self._runSeqProcessesPlaned = False<EOL>for cont in updates:<EOL><INDENT>for sigName, sig in cont._all_signals:<EOL><INDENT>newVal = getattr(cont, sigName)<EOL>if newVal is not None:<EOL><INDENT>v = self._conflictResolveStrategy(newVal)<EOL>updater, _ = v<EOL>sig.simUpdateVal(self, updater)<EOL>setattr(cont, sigName, None)<EOL><DEDENT><DEDENT><DEDENT>return<EOL>yield<EOL>", "docstring": "Delta step for event dependent processes", "id": "f1445:c6:m10"}
{"signature": "def __init__(self, dstSignalsTuples):", "body": "self._all_signals = []<EOL>for name, s in dstSignalsTuples:<EOL><INDENT>setattr(self, name, None)<EOL>self._all_signals.append([name, s])<EOL><DEDENT>", "docstring": ":param dstSignalsTuples: tuples (name, signal)", "id": "f1445:c0:m0"}
{"signature": "def add_process(self, proc) -> None:", "body": "self._events.push(self.now, PRIORITY_NORMAL, proc)<EOL>", "docstring": "Add process to events with default priority on current time", "id": "f1445:c6:m15"}
{"signature": "def waitOnCombUpdate(self) -> Event:", "body": "if not self._combUpdateDonePlaned:<EOL><INDENT>return self._scheduleCombUpdateDoneEv()<EOL><DEDENT>else:<EOL><INDENT>return self.combUpdateDoneEv<EOL><DEDENT>", "docstring": "Sim processes can wait on combUpdateDone by:\nyield sim.waitOnCombUpdate()\n\nSim process is then woken up when all combinational updates\nare done in this delta step", "id": "f1445:c6:m2"}
{"signature": "@internal<EOL><INDENT>def _applyValues(self) -> Generator[None, None, None]:<DEDENT>", "body": "va = self._valuesToApply<EOL>self._applyValPlaned = False<EOL>lav = self.config.logApplyingValues<EOL>if va and lav:<EOL><INDENT>lav(self, va)<EOL><DEDENT>self._valuesToApply = []<EOL>addSp = self._seqProcsToRun.append<EOL>for s, vUpdater, isEventDependent, comesFrom in va:<EOL><INDENT>if isEventDependent:<EOL><INDENT>addSp(comesFrom)<EOL><DEDENT>else:<EOL><INDENT>s.simUpdateVal(self, vUpdater)<EOL><DEDENT><DEDENT>self._runCombProcesses()<EOL>if self._valuesToApply and not self._applyValPlaned:<EOL><INDENT>self._scheduleApplyValues()<EOL><DEDENT>return<EOL>yield<EOL>", "docstring": "Perform delta step by writing stacked values to signals", "id": "f1445:c6:m11"}
{"signature": "@internal<EOL>def raise_StopSimulation(sim):", "body": "raise StopSimumulation()<EOL>return<EOL>yield<EOL>", "docstring": "Simulation process used to stop simulation", "id": "f1445:m1"}
{"signature": "@internal<EOL><INDENT>def _scheduleApplyValues(self) -> None:<DEDENT>", "body": "assert not self._applyValPlaned, self.now<EOL>self._add_process(self._applyValues(), PRIORITY_APPLY_COMB)<EOL>self._applyValPlaned = True<EOL>if self._runSeqProcessesPlaned:<EOL><INDENT>return<EOL><DEDENT>assert not self._seqProcsToRun and not self._runSeqProcessesPlaned, self.now<EOL>self._add_process(self._runSeqProcesses(), PRIORITY_APPLY_SEQ)<EOL>self._runSeqProcessesPlaned = True<EOL>", "docstring": "Apply stashed values to signals", "id": "f1445:c6:m7"}
{"signature": "def getDrivers(self):", "body": "return [self.driver]<EOL>", "docstring": "Called before simulation to collect all drivers of interfaces\nfrom this agent", "id": "f1446:c0:m4"}
{"signature": "@internal<EOL>def reconnectUnitSignalsToModel(synthesisedUnitOrIntf, modelCls):", "body": "obj = synthesisedUnitOrIntf<EOL>subInterfaces = obj._interfaces<EOL>if subInterfaces:<EOL><INDENT>for intf in subInterfaces:<EOL><INDENT>reconnectUnitSignalsToModel(intf, modelCls)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>s = synthesisedUnitOrIntf<EOL>s._sigInside = getattr(modelCls, s._sigInside.name)<EOL><DEDENT>", "docstring": "Reconnect model signals to unit to run simulation with simulation model\nbut use original unit interfaces for communication\n\n:param synthesisedUnitOrIntf: interface where should be signals\n    replaced from signals from modelCls\n:param modelCls: simulation model form where signals\n    for synthesisedUnitOrIntf should be taken", "id": "f1449:m2"}
{"signature": "def __init__(self, sig: SimSignal, fn, shouldBeEnabledFn):", "body": "assert not isinstance(fn, CallbackLoop)<EOL>self.fn = fn<EOL>self.isGenerator = inspect.isgeneratorfunction(fn)<EOL>self.shouldBeEnabledFn = shouldBeEnabledFn<EOL>self._callbackIndex = None<EOL>try:<EOL><INDENT>self.sig = sig._sigInside<EOL><DEDENT>except AttributeError:<EOL><INDENT>self.sig = sig<EOL><DEDENT>", "docstring": ":param sig: signal on which write callback should be used\n:attention: if condFn is None callback function is always executed\n\n:ivra fn: function/generator which is callback which should be executed\n:ivar isGenerator: flag if callback function is generator\n    or normal function\n:ivar _callbackIndex: index of callback in write callbacks on sig,\n    if is None callback was not registered yet\n:ivar shouldBeEnabledFn: function() -> bool, which returns True if this\n    callback loop should be enabled", "id": "f1449:c0:m0"}
{"signature": "@internal<EOL>def _simUnitVcd(simModel, stimulFunctions, outputFile, until):", "body": "sim = HdlSimulator()<EOL>sim.config = VcdHdlSimConfig(outputFile)<EOL>sim.simUnit(simModel, until=until, extraProcesses=stimulFunctions)<EOL>return sim<EOL>", "docstring": ":param unit: interface level unit to simulate\n:param stimulFunctions: iterable of function(env)\n    (simpy environment) which are driving the simulation\n:param outputFile: file where vcd will be dumped\n:param time: endtime of simulation, time units are defined in HdlSimulator\n:return: hdl simulator object", "id": "f1449:m4"}
{"signature": "def selectBit(val, bitNo):", "body": "return (val >> bitNo) & <NUM_LIT:1><EOL>", "docstring": "select bit from integer", "id": "f1450:m2"}
{"signature": "def Default(self, *statements):", "body": "assert self.parentStm is None<EOL>self.rank += <NUM_LIT:1><EOL>self.default = []<EOL>self._register_stements(statements, self.default)<EOL>return self<EOL>", "docstring": "c-like default of switch statement", "id": "f1451:c1:m4"}
{"signature": "def rol(sig, howMany) -> RtlSignalBase:", "body": "width = sig._dtype.bit_length()<EOL>return sig[(width - howMany):]._concat(sig[:(width - howMany)])<EOL>", "docstring": "Rotate left", "id": "f1451:m6"}
{"signature": "def connect(src, *destinations, exclude: set=None, fit=False):", "body": "assignemnts = []<EOL>if isinstance(src, HObjList):<EOL><INDENT>for dst in destinations:<EOL><INDENT>assert len(src) == len(dst), (src, dst)<EOL><DEDENT>_destinations = [iter(d) for d in destinations]<EOL>for _src in src:<EOL><INDENT>dsts = [next(d) for d in _destinations]<EOL>assignemnts.append(connect(_src, *dsts, exclude=exclude, fit=fit))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for dst in destinations:<EOL><INDENT>assignemnts.append(_connect(src, dst, exclude, fit))<EOL><DEDENT><DEDENT>return assignemnts<EOL>", "docstring": "Connect src (signals/interfaces/values) to all destinations\n\n:param exclude: interfaces on any level on src or destinations\n    which should be excluded from connection process\n:param fit: auto fit source width to destination width", "id": "f1451:m3"}
{"signature": "def addCases(self, tupesValStmnts):", "body": "s = self<EOL>for val, statements in tupesValStmnts:<EOL><INDENT>s = s.Case(val, statements)<EOL><DEDENT>return s<EOL>", "docstring": "Add multiple case statements from iterable of tuleles\n(caseVal, statements)", "id": "f1451:c1:m2"}
{"signature": "def __init__(self, parent, stateT, stateRegName=\"<STR_LIT>\"):", "body": "if isinstance(stateT, HEnum):<EOL><INDENT>beginVal = stateT.fromPy(stateT._allValues[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>beginVal = <NUM_LIT:0><EOL><DEDENT>self.stateReg = parent._reg(stateRegName, stateT, beginVal)<EOL>Switch.__init__(self, self.stateReg)<EOL>", "docstring": ":param parent: parent unit where fsm should be builded\n:param stateT: enum type of state\n:param stateRegName: name of register where sate is stored", "id": "f1451:c2:m0"}
{"signature": "def sll(sig, howMany) -> RtlSignalBase:", "body": "width = sig._dtype.bit_length()<EOL>return sig[(width - howMany):]._concat(vec(<NUM_LIT:0>, howMany))<EOL>", "docstring": "Logical shift left", "id": "f1451:m7"}
{"signature": "def log2ceil(x):", "body": "if not isinstance(x, (int, float)):<EOL><INDENT>x = int(x)<EOL><DEDENT>if x == <NUM_LIT:0> or x == <NUM_LIT:1>:<EOL><INDENT>res = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>res = math.ceil(math.log2(x))<EOL><DEDENT>return hInt(res)<EOL>", "docstring": "Returns no of bits required to store x-1\nfor example x=8 returns 3", "id": "f1451:m9"}
{"signature": "@property<EOL><INDENT>def texts(self):<DEDENT>", "body": "return [subpod.plaintext for subpod in self.subpod]<EOL>", "docstring": "The text from each subpod in this pod as a list.", "id": "f1458:c7:m2"}
{"signature": "def gen_keywords(*args: Union[ANSIColors, ANSIStyles], **kwargs: Union[ANSIColors, ANSIStyles]) -> tuple:", "body": "fields: tuple = tuple()<EOL>values: tuple = tuple()<EOL>for tpl in args:<EOL><INDENT>fields += tpl._fields<EOL>values += tpl<EOL><DEDENT>for prefix, tpl in kwargs.items():<EOL><INDENT>fields += tuple(map(lambda x: '<STR_LIT:_>'.join([prefix, x]), tpl._fields))<EOL>values += tpl<EOL><DEDENT>return namedtuple('<STR_LIT>', fields)(*values)<EOL>", "docstring": "generate single escape sequence mapping.", "id": "f1503:m0"}
{"signature": "def fold_map(self, fa: F[A], z: B, f: Callable[[A], B], g: Callable[[Z, B], Z]=operator.add) -> Z:", "body": "mapped = Functor.fatal(type(fa)).map(fa, f)<EOL>return self.fold_left(mapped)(z)(g)<EOL>", "docstring": "map `f` over the traversable, then fold over the result\n        using the supplied initial element `z` and operation `g`,\n        defaulting to addition for the latter.", "id": "f1547:c1:m7"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def ap(self, fa: F, f: F) -> F:<DEDENT>", "body": "...<EOL>", "docstring": "f should be an F[Callable[[A], B]]", "id": "f1556:c0:m0"}
{"signature": "def set_log_level(log_level):", "body": "if not LOGBOOK_INSTALLED:<EOL><INDENT>return<EOL><DEDENT>logbook.get_level_name(log_level)<EOL>if log_level == logger.level:<EOL><INDENT>return<EOL><DEDENT>if log_level == logbook.NOTSET:<EOL><INDENT>set_logger(is_enable=False)<EOL><DEDENT>else:<EOL><INDENT>set_logger(is_enable=True)<EOL><DEDENT>logger.level = log_level<EOL>try:<EOL><INDENT>import pytablewriter<EOL>pytablewriter.set_log_level(log_level)<EOL><DEDENT>except ImportError:<EOL><INDENT>pass<EOL><DEDENT>tabledata.set_log_level(log_level)<EOL>", "docstring": "Set logging level of this module. Using\n`logbook <https://logbook.readthedocs.io/en/stable/>`__ module for logging.\n\n:param int log_level:\n    One of the log level of\n    `logbook <https://logbook.readthedocs.io/en/stable/api/base.html>`__.\n    Disabled logging if ``log_level`` is ``logbook.NOTSET``.\n:raises LookupError: If ``log_level`` is an invalid value.", "id": "f1604:m1"}
{"signature": "@register.filter<EOL>def user_can_edit(obj, user):", "body": "return obj.user_can_edit(user) if hasattr(obj, \"<STR_LIT>\") else None<EOL>", "docstring": "If a model implements the user_can_edit method,\nthis filter returns the result of the method.", "id": "f1609:m12"}
{"signature": "@register.simple_tag<EOL>def jsfile(url):", "body": "if not url.startswith('<STR_LIT>') and not url[:<NUM_LIT:1>] == '<STR_LIT:/>':<EOL><INDENT>url = settings.STATIC_URL + url<EOL><DEDENT>return '<STR_LIT>'.format(<EOL>src=url)<EOL>", "docstring": "Output a script tag to a js file.", "id": "f1609:m2"}
{"signature": "@register.simple_tag<EOL>def table(rows):", "body": "output = '<STR_LIT>'<EOL>for row in rows:<EOL><INDENT>output += '<STR_LIT>'<EOL>for column in row:<EOL><INDENT>output += '<STR_LIT>'.format(s=column)<EOL><DEDENT>output += '<STR_LIT>'<EOL><DEDENT>output += '<STR_LIT>'<EOL>return output<EOL>", "docstring": "Output a simple table with several columns.", "id": "f1609:m0"}
{"signature": "@register.filter<EOL>def model_verbose(obj, capitalize=True):", "body": "if isinstance(obj, ModelForm):<EOL><INDENT>name = obj._meta.model._meta.verbose_name<EOL><DEDENT>elif isinstance(obj, Model):<EOL><INDENT>name = obj._meta.verbose_name<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>' + type(obj))<EOL><DEDENT>return name.capitalize() if capitalize else name<EOL>", "docstring": "Return the verbose name of a model.\nThe obj argument can be either a Model instance, or a ModelForm instance.\nThis allows to retrieve the verbose name of the model of a ModelForm\neasily, without adding extra context vars.", "id": "f1609:m11"}
{"signature": "def pre_save(self, instance):", "body": "pass<EOL>", "docstring": "Hook for editing the instance.", "id": "f1611:c11:m3"}
{"signature": "def post_delete(self, object):", "body": "", "docstring": "Hook for alterations after delete.", "id": "f1611:c3:m3"}
{"signature": "def get_config(key, default=None):", "body": "return getattr(settings, key, default)<EOL>", "docstring": "Get settings from django.conf if exists,\nreturn default value otherwise\n\nexample:\n\nADMIN_EMAIL = get_config('ADMIN_EMAIL', 'default@email.com')", "id": "f1613:m1"}
{"signature": "def resolve_class(class_path):", "body": "modulepath, classname = class_path.rsplit('<STR_LIT:.>', <NUM_LIT:1>)<EOL>module = __import__(modulepath, fromlist=[classname])<EOL>return getattr(module, classname)<EOL>", "docstring": "Load a class by a fully qualified class_path,\neg. myapp.models.ModelName", "id": "f1613:m4"}
{"signature": "def get_object_or_none(qs, *args, **kwargs):", "body": "try:<EOL><INDENT>return qs.get(*args, **kwargs)<EOL><DEDENT>except models.ObjectDoesNotExist:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Try to retrieve a model, and return None if\nit is not found.\nUseful if you do not want to bother with the try/except block.", "id": "f1617:m0"}
{"signature": "@cli.command('<STR_LIT>')<EOL>@click.argument('<STR_LIT:url>', type=str)<EOL>@click.pass_context<EOL>def scrape(ctx, url):", "body": "data = load_feed(url)<EOL>feed = data['<STR_LIT>']<EOL>entries = data['<STR_LIT>']<EOL>_type = '<STR_LIT>'<EOL>country = '<STR_LIT>'<EOL>for entry in entries:<EOL><INDENT>_id = sluggify(entry['<STR_LIT:id>'])<EOL>city = entry['<STR_LIT>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>landing = entry['<STR_LIT>']<EOL>start_time = dt_normalize(entry['<STR_LIT>'], local_tz=True)<EOL>title = entry['<STR_LIT:title>']<EOL>summary = entry['<STR_LIT>']<EOL>link = entry['<STR_LIT>']<EOL>ipdb.set_trace()<EOL><DEDENT>", "docstring": "Rip the events from a given rss feed, normalize the data and store.", "id": "f1622:m2"}
{"signature": "def get_token(client_id, client_secret, client_access_token, page=None):", "body": "payload = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': client_id,<EOL>'<STR_LIT>': client_secret,<EOL>}<EOL>if client_access_token:<EOL><INDENT>payload['<STR_LIT>'] = '<STR_LIT>'<EOL>payload['<STR_LIT>'] = client_access_token<EOL><DEDENT>response = requests.post(<EOL>'<STR_LIT>',<EOL>params=payload)<EOL>access_token = response.json()['<STR_LIT>']<EOL>return access_token<EOL>", "docstring": "See: http://nodotcom.org/python-facebook-tutorial.html", "id": "f1625:m0"}
{"signature": "def _create_msg(self, to, subject, msgHtml, msgPlain, attachments=None):", "body": "sender = self.sender<EOL>if attachments and isinstance(attachments, str):<EOL><INDENT>attachments = [attachments]<EOL><DEDENT>else:<EOL><INDENT>attachments = list(attachments or [])<EOL><DEDENT>msg = MIMEMultipart('<STR_LIT>')<EOL>msg['<STR_LIT>'] = subject<EOL>msg['<STR_LIT>'] = sender<EOL>msg['<STR_LIT>'] = to<EOL>msg.attach(MIMEText(msgPlain, '<STR_LIT>'))<EOL>msg.attach(MIMEText(msgHtml, '<STR_LIT:html>'))<EOL>for path in attachments:<EOL><INDENT>_attachment = self._prep_attachment(path)<EOL>msg.attach(_attachment)<EOL><DEDENT>raw = base64.urlsafe_b64encode(msg.as_bytes()).decode()<EOL>body = {'<STR_LIT>': raw}<EOL>return body<EOL>", "docstring": "attachments should be a list of paths", "id": "f1630:c0:m5"}
{"signature": "def emit(self, record):", "body": "if getattr(this, '<STR_LIT>', {}).get(LOGS_NAME, False):<EOL><INDENT>self.format(record)<EOL>this.send({<EOL>'<STR_LIT>': ADDED,<EOL>'<STR_LIT>': LOGS_NAME,<EOL>'<STR_LIT:id>': meteor_random_id('<STR_LIT>' % LOGS_NAME),<EOL>'<STR_LIT>': {<EOL>attr: {<EOL>'<STR_LIT:args>': lambda args: [repr(arg) for arg in args],<EOL>'<STR_LIT>': datetime.datetime.fromtimestamp,<EOL>'<STR_LIT>': stacklines_or_none,<EOL>}.get(<EOL>attr,<EOL>lambda val: val  <EOL>)(getattr(record, attr, None))<EOL>for attr in (<EOL>'<STR_LIT:args>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT:filename>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT:message>',<EOL>'<STR_LIT:name>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>)<EOL>},<EOL>})<EOL><DEDENT>", "docstring": "Emit a formatted log record via DDP.", "id": "f1635:c0:m0"}
{"signature": "def database_backwards(self, app_label, schema_editor, from_state, to_state):", "body": "self.truncate(app_label, schema_editor, self.truncate_backwards)<EOL>", "docstring": "Use schema_editor to apply any reverse changes.", "id": "f1642:c0:m4"}
{"signature": "def truncate(self, app_label, schema_editor, models):", "body": "for model_name in models:<EOL><INDENT>model = '<STR_LIT>' % (app_label, model_name)<EOL>schema_editor.execute(<EOL>'<STR_LIT>' % (<EOL>model.lower(),<EOL>),<EOL>)<EOL><DEDENT>", "docstring": "Truncate tables.", "id": "f1642:c0:m1"}
{"signature": "def ddpp_sockjs_info(environ, start_response):", "body": "import random<EOL>import ejson<EOL>start_response(<EOL>'<STR_LIT>',<EOL>[<EOL>('<STR_LIT:Content-Type>', '<STR_LIT>'),<EOL>] + common_headers(environ),<EOL>)<EOL>yield ejson.dumps(collections.OrderedDict([<EOL>('<STR_LIT>', True),<EOL>('<STR_LIT>', [<EOL>'<STR_LIT>',<EOL>]),<EOL>('<STR_LIT>', False),<EOL>('<STR_LIT>', random.getrandbits(<NUM_LIT:32>)),<EOL>]))<EOL>", "docstring": "Inform client that WebSocket service is available.", "id": "f1649:m2"}
{"signature": "def run(self):", "body": "self.logger.debug('<STR_LIT>')<EOL>self.start()<EOL>self._stop_event.wait()<EOL>gevent.joinall(self.threads + [DDPLauncher.pgworker])<EOL>self.threads = []<EOL>", "docstring": "Run DDP greenlets.", "id": "f1649:c0:m7"}
{"signature": "def add_web_servers(self, listen_addrs, debug=False, **ssl_args):", "body": "self.servers.extend(<EOL>self.get_web_server(listen_addr, debug=debug, **ssl_args)<EOL>for listen_addr in listen_addrs<EOL>)<EOL>", "docstring": "Add WebSocketServer for each (host, port) in listen_addrs.", "id": "f1649:c0:m2"}
{"signature": "def get_auth_hash(user, purpose):", "body": "return iter_auth_hashes(user, purpose, minutes_valid=<NUM_LIT:1>).next()<EOL>", "docstring": "Generate a user hash for a particular purpose.", "id": "f1651:m1"}
{"signature": "def do_login(self, user):", "body": "this.user_id = user.pk<EOL>this.user_ddp_id = get_meteor_id(user)<EOL>this.user_sub_id = meteor_random_id()<EOL>API.do_sub(this.user_sub_id, '<STR_LIT>', silent=True)<EOL>self.update_subs(user.pk)<EOL>user_logged_in.send(<EOL>sender=user.__class__, request=this.request, user=user,<EOL>)<EOL>", "docstring": "Login a user.", "id": "f1651:c4:m9"}
{"signature": "@api_endpoint<EOL><INDENT>def update(self, selector, update, options=None):<DEDENT>", "body": "<EOL>del options<EOL>user = get_object(<EOL>self.model, selector['<STR_LIT>'],<EOL>pk=this.user_id,<EOL>)<EOL>profile_update = self.deserialize_profile(<EOL>update['<STR_LIT>'], key_prefix='<STR_LIT>', pop=True,<EOL>)<EOL>if len(update['<STR_LIT>']) != <NUM_LIT:0>:<EOL><INDENT>raise MeteorError(<NUM_LIT>, '<STR_LIT>')<EOL><DEDENT>for key, val in profile_update.items():<EOL><INDENT>setattr(user, key, val)<EOL><DEDENT>user.save()<EOL>", "docstring": "Update user data.", "id": "f1651:c1:m2"}
{"signature": "@api_endpoint('<STR_LIT>')<EOL><INDENT>def forgot_password(self, params):<DEDENT>", "body": "username = self.get_username(params)<EOL>try:<EOL><INDENT>user = self.user_model.objects.get(**{<EOL>self.user_model.USERNAME_FIELD: username,<EOL>})<EOL><DEDENT>except self.user_model.DoesNotExist:<EOL><INDENT>self.auth_failed()<EOL><DEDENT>minutes_valid = HASH_MINUTES_VALID[HashPurpose.PASSWORD_RESET]<EOL>token = get_user_token(<EOL>user=user, purpose=HashPurpose.PASSWORD_RESET,<EOL>minutes_valid=minutes_valid,<EOL>)<EOL>forgot_password.send(<EOL>sender=__name__,<EOL>user=user,<EOL>token=token,<EOL>request=this.request,<EOL>expiry_date=calc_expiry_time(minutes_valid),<EOL>)<EOL>", "docstring": "Request password reset email.", "id": "f1651:c4:m16"}
{"signature": "def iter_auth_hashes(user, purpose, minutes_valid):", "body": "now = timezone.now().replace(microsecond=<NUM_LIT:0>, second=<NUM_LIT:0>)<EOL>for minute in range(minutes_valid + <NUM_LIT:1>):<EOL><INDENT>yield hashlib.sha1(<EOL>'<STR_LIT>' % (<EOL>now - datetime.timedelta(minutes=minute),<EOL>user.password,<EOL>purpose,<EOL>user.pk,<EOL>settings.SECRET_KEY,<EOL>),<EOL>).hexdigest()<EOL><DEDENT>", "docstring": "Generate auth tokens tied to user and specified purpose.\n\nThe hash expires at midnight on the minute of now + minutes_valid, such\nthat when minutes_valid=1 you get *at least* 1 minute to use the token.", "id": "f1651:m0"}
{"signature": "def ready(self):", "body": "THREAD_LOCAL_FACTORIES['<STR_LIT:user>'] = self.user_factory<EOL>", "docstring": "Called after AppConfig.ready().", "id": "f1651:c4:m1"}
{"signature": "@staticmethod<EOL><INDENT>def check_secure():<DEDENT>", "body": "if this.request.is_secure():<EOL><INDENT>return True  <EOL><DEDENT>elif this.request.META['<STR_LIT>'] in [<EOL>'<STR_LIT:localhost>',<EOL>'<STR_LIT:127.0.0.1>',<EOL>]:<EOL><INDENT>return True  <EOL><DEDENT>raise MeteorError(<NUM_LIT>, '<STR_LIT>')<EOL>", "docstring": "Check request, return False if using SSL or local connection.", "id": "f1651:c4:m5"}
{"signature": "def set_seed(self, val):", "body": "self._streams = {}<EOL>self._seed = val<EOL>", "docstring": "Set current PRNG seed.", "id": "f1653:c3:m2"}
{"signature": "def __init__(self):", "body": "if self._init_done:<EOL><INDENT>raise SystemError('<STR_LIT>')<EOL><DEDENT>self._init_done = True<EOL>", "docstring": "Create new thread storage instance.", "id": "f1653:c2:m0"}
{"signature": "def __init__(self):", "body": "self.n = <NUM_LIT><EOL>", "docstring": "Initialise state.", "id": "f1654:c0:m0"}
{"signature": "def __init__(self, *args):", "body": "self.seed(args)<EOL>", "docstring": "Initialise Alea state from seeds (args).", "id": "f1654:c1:m0"}
{"signature": "def get_meteor_ids(model, object_ids):", "body": "<EOL>meta = model._meta<EOL>result = collections.OrderedDict(<EOL>(str(obj_pk), None)<EOL>for obj_pk<EOL>in object_ids<EOL>)<EOL>if isinstance(meta.pk, AleaIdField):<EOL><INDENT>return collections.OrderedDict(<EOL>(obj_pk, obj_pk) for obj_pk in object_ids<EOL>)<EOL><DEDENT>alea_unique_fields = [<EOL>field<EOL>for field in meta.local_fields<EOL>if isinstance(field, AleaIdField) and field.unique and not field.null<EOL>]<EOL>if len(alea_unique_fields) == <NUM_LIT:1>:<EOL><INDENT>aid = alea_unique_fields[<NUM_LIT:0>].name<EOL>query = model.objects.filter(<EOL>pk__in=object_ids,<EOL>).values_list('<STR_LIT>', aid)<EOL><DEDENT>else:<EOL><INDENT>content_type = ContentType.objects.get_for_model(model)<EOL>query = ObjectMapping.objects.filter(<EOL>content_type=content_type,<EOL>object_id__in=list(result)<EOL>).values_list('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>for obj_pk, meteor_id in query:<EOL><INDENT>result[str(obj_pk)] = meteor_id<EOL><DEDENT>for obj_pk, meteor_id in result.items():<EOL><INDENT>if meteor_id is None:<EOL><INDENT>result[obj_pk] = get_meteor_id(model, obj_pk)<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Return Alea ID mapping for all given ids of specified model.", "id": "f1655:m1"}
{"signature": "def get_object_id(model, meteor_id):", "body": "if meteor_id is None:<EOL><INDENT>return None<EOL><DEDENT>meta = model._meta<EOL>if model is ObjectMapping:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if isinstance(meta.pk, AleaIdField):<EOL><INDENT>return meteor_id<EOL><DEDENT>alea_unique_fields = [<EOL>field<EOL>for field in meta.local_fields<EOL>if isinstance(field, AleaIdField) and field.unique<EOL>]<EOL>if len(alea_unique_fields) == <NUM_LIT:1>:<EOL><INDENT>val = model.objects.values_list(<EOL>'<STR_LIT>', flat=True,<EOL>).get(**{<EOL>alea_unique_fields[<NUM_LIT:0>].attname: meteor_id,<EOL>})<EOL>if val:<EOL><INDENT>return val<EOL><DEDENT><DEDENT>content_type = ContentType.objects.get_for_model(model)<EOL>return ObjectMapping.objects.filter(<EOL>content_type=content_type,<EOL>meteor_id=meteor_id,<EOL>).values_list('<STR_LIT>', flat=True).get()<EOL>", "docstring": "Return an object ID for the given meteor_id.", "id": "f1655:m2"}
{"signature": "def set_params(self, vals):", "body": "self.params_ejson = ejson.dumps(vals or {})<EOL>", "docstring": "Set params dict.", "id": "f1655:c4:m2"}
{"signature": "def __str__(self):", "body": "return '<STR_LIT>' % (<EOL>self.meteor_id, self.content_type, self.object_id,<EOL>)<EOL>", "docstring": "Text representation of a mapping.", "id": "f1655:c2:m0"}
{"signature": "def get_params(self):", "body": "return ejson.loads(self.params_ejson or '<STR_LIT:{}>')<EOL>", "docstring": "Get params dict.", "id": "f1655:c4:m1"}
{"signature": "def get_object_ids(model, meteor_ids):", "body": "if model is ObjectMapping:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>meta = model._meta<EOL>alea_unique_fields = [<EOL>field<EOL>for field in meta.local_fields<EOL>if isinstance(field, AleaIdField) and field.unique and not field.null<EOL>]<EOL>result = collections.OrderedDict(<EOL>(str(meteor_id), None)<EOL>for meteor_id<EOL>in meteor_ids<EOL>)<EOL>if len(alea_unique_fields) == <NUM_LIT:1>:<EOL><INDENT>aid = alea_unique_fields[<NUM_LIT:0>].name<EOL>query = model.objects.filter(**{<EOL>'<STR_LIT>' % aid: meteor_ids,<EOL>}).values_list(aid, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>content_type = ContentType.objects.get_for_model(model)<EOL>query = ObjectMapping.objects.filter(<EOL>content_type=content_type,<EOL>meteor_id__in=meteor_ids,<EOL>).values_list('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>for meteor_id, object_id in query:<EOL><INDENT>result[meteor_id] = object_id<EOL><DEDENT>return result<EOL>", "docstring": "Return all object IDs for the given meteor_ids.", "id": "f1655:m3"}
{"signature": "def url(self, path):", "body": "return urljoin(<EOL>'<STR_LIT>' % (self.scheme, self.server_addr, self.server_port),<EOL>path,<EOL>)<EOL>", "docstring": "Return full URL for given path.", "id": "f1656:c2:m4"}
{"signature": "def next_id(self):", "body": "self.call_seq += <NUM_LIT:1><EOL>return self.call_seq<EOL>", "docstring": "Return next `id` from sequence.", "id": "f1656:c0:m8"}
{"signature": "def close(self):", "body": "self.websocket.close()<EOL>", "docstring": "Close the connection.", "id": "f1656:c0:m4"}
{"signature": "def unsub(self, sub_id):", "body": "self.send(msg='<STR_LIT>', id=sub_id)<EOL>", "docstring": "Unsubscribe from a publication by sub_id.", "id": "f1656:c0:m13"}
{"signature": "def send(self, **msg):", "body": "self.websocket.send(ejson.dumps([ejson.dumps(msg)]))<EOL>", "docstring": "Send a SockJS wrapped msg.", "id": "f1656:c1:m0"}
{"signature": "def ping(self, id_=None):", "body": "if id_:<EOL><INDENT>self.send(msg='<STR_LIT>', id=id_)<EOL><DEDENT>else:<EOL><INDENT>self.send(msg='<STR_LIT>')<EOL><DEDENT>", "docstring": "Ping with optional id.", "id": "f1656:c0:m10"}
{"signature": "def tearDown(self):", "body": "if self._server is not None:<EOL><INDENT>self._server.stop()<EOL><DEDENT>self._server = None<EOL>from django.db import connection, close_old_connections<EOL>close_old_connections()<EOL>cur = connection.cursor()<EOL>cur.execute('<STR_LIT>')<EOL>cur.fetchall()<EOL>cur.close()<EOL>connection.close()<EOL>gevent.sleep()<EOL>super(DDPServerTestCase, self).tearDown()<EOL>", "docstring": "Stop the DDP server, and reliably close any open DB transactions.", "id": "f1656:c3:m1"}
{"signature": "def sockjs(self, url, *args, **kwargs):", "body": "return SockJSClient(<EOL>self.url(url).replace('<STR_LIT:http>', '<STR_LIT>'), *args, **kwargs<EOL>)<EOL>", "docstring": "Return a SockJSClient for the given URL.", "id": "f1656:c2:m3"}
{"signature": "def on_m2m_changed(self, sender, **kwargs):", "body": "if self._in_migration:<EOL><INDENT>return<EOL><DEDENT>if kwargs['<STR_LIT>'] is False:<EOL><INDENT>objs = [kwargs['<STR_LIT>']]<EOL>model = objs[<NUM_LIT:0>].__class__<EOL><DEDENT>else:<EOL><INDENT>model = kwargs['<STR_LIT>']<EOL>objs = model.objects.filter(pk__in=kwargs['<STR_LIT>'])<EOL><DEDENT>mod_name = model_name(model)<EOL>if mod_name.split('<STR_LIT:.>', <NUM_LIT:1>)[<NUM_LIT:0>] in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>return  <EOL><DEDENT>if kwargs['<STR_LIT:action>'] in (<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>):<EOL><INDENT>for obj in objs:<EOL><INDENT>self.on_pre_change(<EOL>sender=model, instance=obj, using=kwargs['<STR_LIT>'],<EOL>)<EOL><DEDENT><DEDENT>elif kwargs['<STR_LIT:action>'] in (<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>):<EOL><INDENT>for obj in objs:<EOL><INDENT>self.send_notify(<EOL>model=model,<EOL>obj=obj,<EOL>msg=CHANGED,<EOL>using=kwargs['<STR_LIT>'],<EOL>)<EOL><DEDENT><DEDENT>", "docstring": "M2M-changed signal handler.", "id": "f1657:c6:m18"}
{"signature": "def api_endpoints(obj):", "body": "for name in dir(obj):<EOL><INDENT>attr = getattr(obj, name)<EOL>api_path = getattr(attr, '<STR_LIT>', None)<EOL>if api_path:<EOL><INDENT>yield (<EOL>'<STR_LIT>' % (obj.api_path_prefix, api_path),<EOL>attr,<EOL>)<EOL><DEDENT><DEDENT>for api_provider in obj.api_providers:<EOL><INDENT>for api_path, attr in api_endpoints(api_provider):<EOL><INDENT>yield (api_path, attr)<EOL><DEDENT><DEDENT>", "docstring": "Iterator over all API endpoint names and callbacks.", "id": "f1657:m1"}
{"signature": "def ready(self):", "body": "pass<EOL>", "docstring": "Initialisation (setup lookups and signal handlers).", "id": "f1657:c1:m3"}
{"signature": "def objects_for_user(self, user, qs=None, xmin__lte=None):", "body": "qs = self.get_queryset(qs)<EOL>user_rels = self.user_rel<EOL>if user_rels:<EOL><INDENT>if user is None:<EOL><INDENT>return qs.none()  <EOL><DEDENT>if isinstance(user_rels, basestring):<EOL><INDENT>user_rels = [user_rels]<EOL><DEDENT>user_filter = None<EOL>meta = self.model._meta<EOL>for user_rel in user_rels:<EOL><INDENT>name, rel = (user_rel.split('<STR_LIT>', <NUM_LIT:1>) + [None])[:<NUM_LIT:2>]<EOL>field = meta.pk if name == '<STR_LIT>' else meta.get_field(name)<EOL>if field.related_model is not None:<EOL><INDENT>filter_obj = Q(**{<EOL>'<STR_LIT>' % name: field.related_model.objects.filter(<EOL>**{rel or '<STR_LIT>': user}<EOL>).values('<STR_LIT>'),<EOL>})<EOL><DEDENT>else:<EOL><INDENT>filter_obj = Q(**{str(user_rel): user})<EOL><DEDENT>if user_filter is None:<EOL><INDENT>user_filter = filter_obj<EOL><DEDENT>else:<EOL><INDENT>user_filter |= filter_obj<EOL><DEDENT><DEDENT>qs = qs.filter(user_filter).distinct()<EOL><DEDENT>if xmin__lte is not None:<EOL><INDENT>qs = qs.extra(<EOL>where=[\"<STR_LIT>\"],<EOL>params=[xmin__lte],<EOL>)<EOL><DEDENT>return qs<EOL>", "docstring": "Find objects in queryset related to specified user.", "id": "f1657:c3:m2"}
{"signature": "def __new__(mcs, name, bases, attrs):", "body": "attrs.update(<EOL>api_path_prefix_format=COLLECTION_PATH_FORMAT,<EOL>)<EOL>model = attrs.get('<STR_LIT>', None)<EOL>if attrs.get('<STR_LIT:name>', None) is None and model is not None:<EOL><INDENT>attrs.update(<EOL>name=model_name(model),<EOL>)<EOL><DEDENT>return super(CollectionMeta, mcs).__new__(mcs, name, bases, attrs)<EOL>", "docstring": "Create a new Collection class.", "id": "f1657:c2:m0"}
{"signature": "def on_post_migrate(self, sender, **kwargs):", "body": "self._in_migration = False<EOL>try:<EOL><INDENT>Connection.objects.all().delete()<EOL><DEDENT>except DatabaseError:  <EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Post-migrate signal handler.", "id": "f1657:c6:m16"}
{"signature": "def clear_api_path_map_cache(self):", "body": "self._api_path_cache = None<EOL>for api_provider in self.api_providers:<EOL><INDENT>if six.get_method_self(<EOL>api_provider.clear_api_path_map_cache,<EOL>) is not None:<EOL><INDENT>api_provider.clear_api_path_map_cache()<EOL><DEDENT><DEDENT>", "docstring": "Clear out cache for api_path_map.", "id": "f1657:c1:m1"}
{"signature": "@api_endpoint<EOL><INDENT>def collections(self, *params):<DEDENT>", "body": "return sorted(<EOL>set(<EOL>hasattr(qs, '<STR_LIT>') and model_name(qs.model) or qs[<NUM_LIT:1>]<EOL>for qs<EOL>in self.get_queries(False, *params)<EOL>)<EOL>)<EOL>", "docstring": "Return list of collections for this publication.", "id": "f1657:c5:m1"}
{"signature": "def model_name(model):", "body": "<EOL>return force_text(model._meta)<EOL>", "docstring": "Return model name given model class.", "id": "f1657:m2"}
{"signature": "def do_unsub(self, id_, silent):", "body": "sub = Subscription.objects.get(<EOL>connection=this.ws.connection, sub_id=id_,<EOL>)<EOL>for col, qs in self.sub_unique_objects(sub):<EOL><INDENT>if isinstance(col.model._meta.pk, AleaIdField):<EOL><INDENT>meteor_ids = None<EOL><DEDENT>else:<EOL><INDENT>meteor_ids = get_meteor_ids(<EOL>qs.model, qs.values_list('<STR_LIT>', flat=True),<EOL>)<EOL><DEDENT>for obj in qs:<EOL><INDENT>payload = col.obj_change_as_msg(obj, REMOVED, meteor_ids)<EOL>this.send(payload)<EOL><DEDENT><DEDENT>this.subs[sub.publication].remove(sub.pk)<EOL>sub.delete()<EOL>if not silent:<EOL><INDENT>this.send({'<STR_LIT>': '<STR_LIT>', '<STR_LIT:id>': id_})<EOL><DEDENT>", "docstring": "Unsubscribe the current thread from the specified subscription id.", "id": "f1657:c6:m10"}
{"signature": "@api_endpoint(decorate=False)<EOL><INDENT>def method(self, method, params, id_):<DEDENT>", "body": "try:<EOL><INDENT>handler = self.api_path_map()[method]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise MeteorError(<NUM_LIT>, '<STR_LIT>', method)<EOL><DEDENT>try:<EOL><INDENT>inspect.getcallargs(handler, *params)<EOL><DEDENT>except TypeError as err:<EOL><INDENT>raise MeteorError(<NUM_LIT>, '<STR_LIT:%s>' % err)<EOL><DEDENT>result = handler(*params)<EOL>msg = {'<STR_LIT>': '<STR_LIT:result>', '<STR_LIT:id>': id_}<EOL>if result is not None:<EOL><INDENT>msg['<STR_LIT:result>'] = result<EOL><DEDENT>this.send(msg)<EOL>", "docstring": "Invoke a method.", "id": "f1657:c6:m11"}
{"signature": "def valid_subscribers(self, model, obj, using):", "body": "col_user_ids = {}<EOL>col_connection_ids = collections.defaultdict(set)<EOL>for sub in Subscription.objects.filter(<EOL>collections__model_name=model_name(model),<EOL>).prefetch_related('<STR_LIT>'):<EOL><INDENT>pub = self.get_pub_by_name(sub.publication)<EOL>try:<EOL><INDENT>queries = list(pub.user_queries(sub.user, *sub.params))<EOL><DEDENT>except Exception:<EOL><INDENT>queries = []<EOL><DEDENT>for qs, col in (<EOL>self.qs_and_collection(qs)<EOL>for qs<EOL>in queries<EOL>):<EOL><INDENT>if qs.model is not model:<EOL><INDENT>continue  <EOL><DEDENT>if not qs.filter(pk=obj.pk).exists():<EOL><INDENT>continue  <EOL><DEDENT>try:<EOL><INDENT>user_ids = col_user_ids[col.__class__]<EOL><DEDENT>except KeyError:<EOL><INDENT>user_ids = col_user_ids[col.__class__] =col.user_ids_for_object(obj)<EOL><DEDENT>if user_ids is None:<EOL><INDENT>pass  <EOL><DEDENT>elif sub.user_id not in user_ids:<EOL><INDENT>continue  <EOL><DEDENT>col_connection_ids[col].add(sub.connection_id)<EOL><DEDENT><DEDENT>return col_connection_ids<EOL>", "docstring": "Calculate valid subscribers (connections) for obj.", "id": "f1657:c6:m21"}
{"signature": "def on_post_save(self, sender, **kwargs):", "body": "if self._in_migration:<EOL><INDENT>return<EOL><DEDENT>self.send_notify(<EOL>model=sender,<EOL>obj=kwargs['<STR_LIT>'],<EOL>msg=kwargs['<STR_LIT>'] and ADDED or CHANGED,<EOL>using=kwargs['<STR_LIT>'],<EOL>)<EOL>", "docstring": "Post-save signal handler.", "id": "f1657:c6:m19"}
{"signature": "def __init__(self):", "body": "self._registry = {}<EOL>self._ddp_subscribers = {}<EOL>", "docstring": "DDP API init.", "id": "f1657:c6:m0"}
{"signature": "def __new__(cls, name, bases, attrs):", "body": "attrs['<STR_LIT:name>'] = attrs.pop('<STR_LIT:name>', None) or name<EOL>name_format = attrs.get('<STR_LIT>', None)<EOL>if name_format:<EOL><INDENT>attrs['<STR_LIT:name>'] = name_format.format(**attrs)<EOL><DEDENT>api_path_prefix_format = attrs.get('<STR_LIT>', None)<EOL>if attrs.get('<STR_LIT>', None) is not None:<EOL><INDENT>pass<EOL><DEDENT>elif api_path_prefix_format is not None:<EOL><INDENT>attrs['<STR_LIT>'] = api_path_prefix_format.format(**attrs)<EOL><DEDENT>return super(APIMeta, cls).__new__(cls, name, bases, attrs)<EOL>", "docstring": "Create a new APIMixin class.", "id": "f1657:c0:m0"}
{"signature": "def recv_unsub(self, id_=None):", "body": "if id_:<EOL><INDENT>self.api.unsub(id_)<EOL><DEDENT>else:<EOL><INDENT>self.reply('<STR_LIT>')<EOL><DEDENT>", "docstring": "DDP unsub handler.", "id": "f1658:c0:m13"}
{"signature": "def get_tx_id(self):", "body": "return next(self._tx_buffer_id_gen)<EOL>", "docstring": "Get the next TX msg ID.", "id": "f1658:c0:m0"}
{"signature": "def safe_call(func, *args, **kwargs):", "body": "try:<EOL><INDENT>return None, func(*args, **kwargs)<EOL><DEDENT>except Exception:  <EOL><INDENT>return traceback.format_exc(), None<EOL><DEDENT>", "docstring": "Call `func(*args, **kwargs)` but NEVER raise an exception.\n\nUseful in situations such as inside exception handlers where calls to\n`logging.error` try to send email, but the SMTP server isn't always\navailalbe and you don't want your exception handler blowing up.", "id": "f1658:m0"}
{"signature": "def __str__(self):", "body": "return self.remote_addr<EOL>", "docstring": "Show remote address that connected to us.", "id": "f1658:c0:m2"}
{"signature": "def on_close(self, *args, **kwargs):", "body": "if self.connection is not None:<EOL><INDENT>del self.pgworker.connections[self.connection.pk]<EOL>self.connection.delete()<EOL>self.connection = None<EOL><DEDENT>signals.request_finished.send(sender=self.__class__)<EOL>safe_call(self.logger.info, '<STR_LIT>', self, args or '<STR_LIT>')<EOL>", "docstring": "Handle closing of websocket connection.", "id": "f1658:c0:m3"}
{"signature": "def validate_kwargs(func, kwargs):", "body": "func_name = func.__name__<EOL>argspec = inspect.getargspec(func)<EOL>all_args = argspec.args[:]<EOL>defaults = list(argspec.defaults or [])<EOL>if inspect.ismethod(func) and all_args[:<NUM_LIT:1>] == ['<STR_LIT>']:<EOL><INDENT>all_args[:<NUM_LIT:1>] = []<EOL><DEDENT>if defaults:<EOL><INDENT>required = all_args[:-len(defaults)]<EOL><DEDENT>else:<EOL><INDENT>required = all_args[:]<EOL><DEDENT>trans = {<EOL>arg: arg.endswith('<STR_LIT:_>') and arg[:-<NUM_LIT:1>] or arg<EOL>for arg<EOL>in all_args<EOL>}<EOL>for key in list(kwargs):<EOL><INDENT>key_adj = '<STR_LIT>' % key<EOL>if key_adj in all_args:<EOL><INDENT>kwargs[key_adj] = kwargs.pop(key)<EOL><DEDENT><DEDENT>supplied = sorted(kwargs)<EOL>missing = [<EOL>trans.get(arg, arg) for arg in required<EOL>if arg not in supplied<EOL>]<EOL>if missing:<EOL><INDENT>raise MeteorError(<EOL><NUM_LIT>,<EOL>func.err,<EOL>'<STR_LIT>' % (<EOL>func_name,<EOL>'<STR_LIT:U+0020>'.join(missing),<EOL>),<EOL>)<EOL><DEDENT>extra = [<EOL>arg for arg in supplied<EOL>if arg not in all_args<EOL>]<EOL>if extra:<EOL><INDENT>raise MeteorError(<EOL><NUM_LIT>,<EOL>func.err,<EOL>'<STR_LIT>' % (func_name, '<STR_LIT:U+0020>'.join(extra)),<EOL>)<EOL><DEDENT>", "docstring": "Validate arguments to be supplied to func.", "id": "f1658:m2"}
{"signature": "def recv_ping(self, id_=None):", "body": "if id_ is None:<EOL><INDENT>self.reply('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>self.reply('<STR_LIT>', id=id_)<EOL><DEDENT>", "docstring": "DDP ping handler.", "id": "f1658:c0:m11"}
{"signature": "def recv_method(self, method, params, id_, randomSeed=None):", "body": "if randomSeed is not None:<EOL><INDENT>this.random_streams.random_seed = randomSeed<EOL>this.alea_random = alea.Alea(randomSeed)<EOL><DEDENT>self.api.method(method, params, id_)<EOL>self.reply('<STR_LIT>', methods=[id_])<EOL>", "docstring": "DDP method handler.", "id": "f1658:c0:m14"}
{"signature": "def send(self, data, tx_id=None):", "body": "<EOL>if tx_id is None:<EOL><INDENT>tx_id = self.get_tx_id()<EOL><DEDENT>self._tx_buffer[tx_id] = data<EOL>while self._tx_next_id in self._tx_buffer:<EOL><INDENT>data = self._tx_buffer.pop(self._tx_next_id)<EOL>if self._tx_buffer:<EOL><INDENT>safe_call(self.logger.debug, '<STR_LIT>', self._tx_next_id)<EOL><DEDENT>self._tx_next_id = next(self._tx_next_id_gen)<EOL>if not isinstance(data, basestring):<EOL><INDENT>msg = data.get('<STR_LIT>', None)<EOL>if msg in (ADDED, CHANGED, REMOVED):<EOL><INDENT>ids = self.remote_ids[data['<STR_LIT>']]<EOL>meteor_id = data['<STR_LIT:id>']<EOL>if msg == ADDED:<EOL><INDENT>if meteor_id in ids:<EOL><INDENT>msg = data['<STR_LIT>'] = CHANGED<EOL><DEDENT>else:<EOL><INDENT>ids.add(meteor_id)<EOL><DEDENT><DEDENT>elif msg == CHANGED:<EOL><INDENT>if meteor_id not in ids:<EOL><INDENT>msg = data['<STR_LIT>'] = ADDED<EOL>ids.add(meteor_id)<EOL><DEDENT><DEDENT>elif msg == REMOVED:<EOL><INDENT>try:<EOL><INDENT>ids.remove(meteor_id)<EOL><DEDENT>except KeyError:<EOL><INDENT>continue  <EOL><DEDENT><DEDENT><DEDENT>data = '<STR_LIT>' % ejson.dumps([ejson.dumps(data)])<EOL><DEDENT>safe_call(self.logger.debug, '<STR_LIT>', self, data)<EOL>try:<EOL><INDENT>self.ws.send(data)<EOL><DEDENT>except geventwebsocket.WebSocketError:<EOL><INDENT>self.ws.close()<EOL>self._tx_buffer.clear()<EOL>break<EOL><DEDENT><DEDENT>num_waiting = len(self._tx_buffer)<EOL>if num_waiting > <NUM_LIT:10>:<EOL><INDENT>safe_call(<EOL>self.logger.warn,<EOL>'<STR_LIT>',<EOL>tx_id, self._tx_next_id, num_waiting, self._tx_buffer,<EOL>)<EOL><DEDENT>", "docstring": "Send `data` (raw string or EJSON payload) to WebSocket client.", "id": "f1658:c0:m8"}
{"signature": "@staticmethod<EOL><INDENT>def path_to_dir(*path_args):<DEDENT>", "body": "return os.path.join(<EOL>*list(path_args[:-<NUM_LIT:1>]) + path_args[-<NUM_LIT:1>].split(posixpath.sep)<EOL>)<EOL>", "docstring": "Convert a UNIX-style path into platform specific directory spec.", "id": "f1669:c0:m5"}
{"signature": "def finalize_options(self):", "body": "<EOL>self.set_undefined_options(<EOL>'<STR_LIT>',<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>)<EOL>self.set_undefined_options(<EOL>'<STR_LIT>',<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>)<EOL>setuptools.command.build_py.build_py.finalize_options(self)<EOL>", "docstring": "Update command options.", "id": "f1669:c0:m1"}
{"signature": "def __init__(self, **settings):", "body": "super(FileSession, self).__init__(**settings)<EOL>self.host = settings.get(\"<STR_LIT:host>\", self.DEFAULT_SESSION_POSITION)<EOL>self._prefix = settings.get(\"<STR_LIT>\", '<STR_LIT:default>')<EOL>if not exists(self.host):<EOL><INDENT>os.makedirs(self.host, <NUM_LIT>)  <EOL><DEDENT>if not isdir(self.host):<EOL><INDENT>raise SessionConfigurationError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Initialize File Session Driver.\nsettings section 'host' is recommended, the option 'prefix' is an optional.\nif prefix is not given, 'default' is the default.\nhost: where to save session object file, this is a directory path.\nprefix: session file name's prefix. session file like: prefix@session_id", "id": "f1676:c0:m0"}
{"signature": "def get(self, session_id):", "body": "if session_id not in self._data_handler:<EOL><INDENT>return {}<EOL><DEDENT>session_obj = self._data_handler[session_id]<EOL>now = datetime.utcnow()<EOL>expires = session_obj.get('<STR_LIT>', now)<EOL>if expires > now:<EOL><INDENT>return session_obj<EOL><DEDENT>return {}<EOL>", "docstring": "get session object from host.", "id": "f1677:c0:m1"}
{"signature": "def __init_session_driver(self):", "body": "driver = self.settings.get(\"<STR_LIT>\")<EOL>if not driver:<EOL><INDENT>raise SessionConfigurationError('<STR_LIT>')<EOL><DEDENT>driver_settings = self.settings.get(\"<STR_LIT>\", {})<EOL>if not driver_settings:<EOL><INDENT>raise SessionConfigurationError('<STR_LIT>')<EOL><DEDENT>cache_driver = self.settings.get(\"<STR_LIT>\", True)<EOL>if cache_driver:<EOL><INDENT>cache_name = '<STR_LIT>'<EOL>cache_handler = self.handler.application<EOL>if not hasattr(cache_handler, cache_name):<EOL><INDENT>setattr(<EOL>cache_handler,<EOL>cache_name,<EOL>SessionDriverFactory.create_driver(driver, **driver_settings))<EOL><DEDENT>session_driver = getattr(cache_handler, cache_name)<EOL><DEDENT>else:<EOL><INDENT>session_driver = SessionDriverFactory.create_driver(driver, **driver_settings)<EOL><DEDENT>self.driver = session_driver(**driver_settings)<EOL>", "docstring": "setup session driver.", "id": "f1679:c0:m2"}
{"signature": "def _get_session_object_from_driver(self, session_id):", "body": "return self.driver.get(session_id)<EOL>", "docstring": "Get session data from driver.", "id": "f1679:c0:m5"}
{"signature": "def run(self):", "body": "return self.cdb.db.query(\"<STR_LIT>\", self.query)<EOL>", "docstring": "Runs the dataset query, and returns the result", "id": "f1689:c0:m2"}
{"signature": "def ping(self):", "body": "return self.db.ping()<EOL>", "docstring": "Pings the ConnectorDB server. Useful for checking if the connection is valid", "id": "f1691:c0:m10"}
{"signature": "def count_users(self):", "body": "return int(self.db.get(\"<STR_LIT>\", {\"<STR_LIT:q>\": \"<STR_LIT>\"}).text)<EOL>", "docstring": "Gets the total number of users registered with the database. Only available to administrator.", "id": "f1691:c0:m4"}
{"signature": "def setauth(self,basic_auth):", "body": "self.headers = []<EOL>if basic_auth is not None:<EOL><INDENT>class auth_extractor():<EOL><INDENT>def __init__(self):<EOL><INDENT>self.headers = {}<EOL><DEDENT><DEDENT>extractor = auth_extractor()<EOL>basic_auth(extractor)<EOL>for header in extractor.headers:<EOL><INDENT>self.headers.append(\"<STR_LIT>\" % (header, extractor.headers[header]))<EOL><DEDENT><DEDENT>", "docstring": "setauth can be used during runtime to make sure that authentication is reset.\n        it can be used when changing passwords/apikeys to make sure reconnects succeed", "id": "f1692:c0:m1"}
{"signature": "def __on_message(self, ws, msg):", "body": "msg = json.loads(msg)<EOL>logging.debug(\"<STR_LIT>\", msg[\"<STR_LIT>\"])<EOL>stream_key = msg[\"<STR_LIT>\"] + \"<STR_LIT::>\"<EOL>if \"<STR_LIT>\" in msg:<EOL><INDENT>stream_key += msg[\"<STR_LIT>\"]<EOL><DEDENT>self.subscription_lock.acquire()<EOL>if stream_key in self.subscriptions:<EOL><INDENT>subscription_function = self.subscriptions[stream_key]<EOL>self.subscription_lock.release()<EOL>fresult = subscription_function(msg[\"<STR_LIT>\"], msg[\"<STR_LIT:data>\"])<EOL>if fresult is True:<EOL><INDENT>fresult = msg[\"<STR_LIT:data>\"]<EOL><DEDENT>if fresult is not False and fresult is not None and msg[\"<STR_LIT>\"].endswith(<EOL>\"<STR_LIT>\") and msg[\"<STR_LIT>\"].count(\"<STR_LIT:/>\") == <NUM_LIT:3>:<EOL><INDENT>self.insert(msg[\"<STR_LIT>\"][:-<NUM_LIT:9>], fresult)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.subscription_lock.release()<EOL>logging.warn(<EOL>\"<STR_LIT>\",<EOL>msg[\"<STR_LIT>\"], list(self.subscriptions.keys()))<EOL><DEDENT>", "docstring": "This function is called whenever there is a message received from the server", "id": "f1692:c0:m16"}
{"signature": "def unsubscribe(self, stream, transform=\"<STR_LIT>\"):", "body": "if self.status is not \"<STR_LIT>\":<EOL><INDENT>return False<EOL><DEDENT>logging.debug(\"<STR_LIT>\", stream)<EOL>self.send(<EOL>{\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": stream,<EOL>\"<STR_LIT>\": transform})<EOL>self.subscription_lock.acquire()<EOL>del self.subscriptions[stream + \"<STR_LIT::>\" + transform]<EOL>if len(self.subscriptions) is <NUM_LIT:0>:<EOL><INDENT>self.subscription_lock.release()<EOL>self.disconnect()<EOL><DEDENT>else:<EOL><INDENT>self.subscription_lock.release()<EOL><DEDENT>", "docstring": "Unsubscribe from the given stream (with the optional transform)", "id": "f1692:c0:m7"}
{"signature": "def __reconnect_fnc(self):", "body": "if self.connect():<EOL><INDENT>self.__resubscribe()<EOL><DEDENT>else:<EOL><INDENT>self.__reconnect()<EOL><DEDENT>", "docstring": "This function is called by reconnect after the time delay", "id": "f1692:c0:m11"}
{"signature": "def __del__(self):", "body": "self.disconnect()<EOL>", "docstring": "Make sure that all threads shut down when needed", "id": "f1692:c0:m19"}
{"signature": "def connect(self):", "body": "<EOL>self.ws_openlock.acquire()<EOL>self.ws_openlock.release()<EOL>if self.status == \"<STR_LIT>\":<EOL><INDENT>return True  <EOL><DEDENT>if self.status == \"<STR_LIT>\":<EOL><INDENT>time.sleep(<NUM_LIT:0.1>)<EOL>return self.connect()<EOL><DEDENT>if self.status == \"<STR_LIT>\" or self.status == \"<STR_LIT>\":<EOL><INDENT>self.ws = websocket.WebSocketApp(self.ws_url,<EOL>header=self.headers,<EOL>on_message=self.__on_message,<EOL>on_ping=self.__on_ping,<EOL>on_open=self.__on_open,<EOL>on_close=self.__on_close,<EOL>on_error=self.__on_error)<EOL>self.ws_thread = threading.Thread(target=self.ws.run_forever)<EOL>self.ws_thread.daemon = True<EOL>self.status = \"<STR_LIT>\"<EOL>self.ws_openlock.acquire()<EOL>self.ws_thread.start()<EOL><DEDENT>self.ws_openlock.acquire()<EOL>self.ws_openlock.release()<EOL>return self.status == \"<STR_LIT>\"<EOL>", "docstring": "Attempt to connect to the websocket - and returns either True or False depending on if\n        the connection was successful or not", "id": "f1692:c0:m8"}
{"signature": "def subscribe(self, stream, callback, transform=\"<STR_LIT>\"):", "body": "if self.status == \"<STR_LIT>\" or self.status == \"<STR_LIT>\" or self.status == \"<STR_LIT>\":<EOL><INDENT>self.connect()<EOL><DEDENT>if self.status is not \"<STR_LIT>\":<EOL><INDENT>return False<EOL><DEDENT>logging.debug(\"<STR_LIT>\", stream)<EOL>self.send({\"<STR_LIT>\": \"<STR_LIT>\", \"<STR_LIT>\": stream, \"<STR_LIT>\": transform})<EOL>with self.subscription_lock:<EOL><INDENT>self.subscriptions[stream + \"<STR_LIT::>\" + transform] = callback<EOL><DEDENT>return True<EOL>", "docstring": "Given a stream, a callback and an optional transform, sets up the subscription", "id": "f1692:c0:m6"}
{"signature": "def delete(self):", "body": "self.db.delete(self.path)<EOL>", "docstring": "Deletes the user/device/stream", "id": "f1693:c0:m3"}
{"signature": "@property<EOL><INDENT>def name(self):<DEDENT>", "body": "return self.data[\"<STR_LIT:name>\"]<EOL>", "docstring": "Returns the object's name. Object names are immutable (unless logged in is a database admin)", "id": "f1693:c0:m6"}
{"signature": "@property<EOL><INDENT>def description(self):<DEDENT>", "body": "if \"<STR_LIT:description>\" in self.data:<EOL><INDENT>return self.data[\"<STR_LIT:description>\"]<EOL><DEDENT>return None<EOL>", "docstring": "Allows to directly set the object's description. Use as a property", "id": "f1693:c0:m9"}
{"signature": "def set(self, property_dict):", "body": "self.metadata = self.db.update(self.path, property_dict).json()<EOL>", "docstring": "Attempts to set the given properties of the object.\n        An example of this is setting the nickname of the object::\n\n            cdb.set({\"nickname\": \"My new nickname\"})\n\n        note that there is a convenience property `cdb.nickname` that allows you to get/set the nickname directly.", "id": "f1693:c0:m5"}
{"signature": "def refresh(self):", "body": "self.metadata = self.db.read(self.path).json()<EOL>", "docstring": "Refresh reloads data from the server. It raises an error if it fails to get the object's metadata", "id": "f1693:c0:m1"}
{"signature": "@property<EOL><INDENT>def public(self):<DEDENT>", "body": "if \"<STR_LIT>\" in self.data:<EOL><INDENT>return self.data[\"<STR_LIT>\"]<EOL><DEDENT>return None<EOL>", "docstring": "gets whether the device is public\n        (this means different things based on connectordb permissions setup - connectordb.com\n        has this be whether the device is publically visible. Devices are individually public/private.)", "id": "f1694:c0:m8"}
{"signature": "def streams(self):", "body": "result = self.db.read(self.path, {\"<STR_LIT:q>\": \"<STR_LIT>\"})<EOL>if result is None or result.json() is None:<EOL><INDENT>return []<EOL><DEDENT>streams = []<EOL>for s in result.json():<EOL><INDENT>strm = self[s[\"<STR_LIT:name>\"]]<EOL>strm.metadata = s<EOL>streams.append(strm)<EOL><DEDENT>return streams<EOL>", "docstring": "Returns the list of streams that belong to the device", "id": "f1694:c0:m1"}
{"signature": "def import_stream(self, directory):", "body": "<EOL>with open(os.path.join(directory, \"<STR_LIT>\"), \"<STR_LIT:r>\") as f:<EOL><INDENT>sdata = json.load(f)<EOL><DEDENT>s = self[sdata[\"<STR_LIT:name>\"]]<EOL>if s.exists():<EOL><INDENT>raise ValueError(\"<STR_LIT>\" + s.name + \"<STR_LIT>\")<EOL><DEDENT>s.create()<EOL>ddb = DatabaseConnection(self.apikey, url=self.db.baseurl)<EOL>d = Device(ddb, self.path)<EOL>sown = d[s.name]<EOL>sown.insert_array(DatapointArray().loadExport(directory))<EOL>if (sdata[\"<STR_LIT>\"] and self.db.path != self.path):<EOL><INDENT>s.downlink = True<EOL>with open(os.path.join(directory, \"<STR_LIT>\"), \"<STR_LIT:r>\") as f:<EOL><INDENT>s.insert_array(json.load(f))<EOL><DEDENT><DEDENT>del sdata[\"<STR_LIT:name>\"]<EOL>s.set(sdata)<EOL>", "docstring": "Imports a stream from the given directory. You export the Stream\n        by using stream.export()", "id": "f1694:c0:m5"}
{"signature": "@property<EOL><INDENT>def role(self):<DEDENT>", "body": "if \"<STR_LIT>\" in self.data:<EOL><INDENT>return self.data[\"<STR_LIT>\"]<EOL><DEDENT>return None<EOL>", "docstring": "Gets the role of the device. This is the permissions level that the device has. It might\n        not be accessible depending on the permissions setup of ConnectorDB. Returns None if not accessible", "id": "f1694:c0:m10"}
{"signature": "def close(self):", "body": "self.r.close()<EOL>", "docstring": "Closes the active connections to ConnectorDB", "id": "f1695:c2:m2"}
{"signature": "def unsubscribe(self, stream, transform=\"<STR_LIT>\"):", "body": "return self.ws.unsubscribe(stream, transform)<EOL>", "docstring": "Unsubscribe from the given stream", "id": "f1695:c2:m12"}
{"signature": "def get(self, path, params=None):", "body": "return self.handleresult(self.r.get(urljoin(self.url, path),<EOL>params=params))<EOL>", "docstring": "Sends a get request to the given path in the database and with optional URL parameters", "id": "f1695:c2:m10"}
{"signature": "def read(self, path, params=None):", "body": "return self.handleresult(self.r.get(urljoin(self.url + CRUD_PATH,<EOL>path),<EOL>params=params))<EOL>", "docstring": "Read the result at the given path (GET) from the CRUD API, using the optional params dictionary\n        as url parameters.", "id": "f1695:c2:m7"}
{"signature": "def setauth(self, user_or_apikey=None, user_password=None):", "body": "auth = None<EOL>if user_or_apikey is not None:<EOL><INDENT>if user_password is None:<EOL><INDENT>user_password = user_or_apikey<EOL>user_or_apikey = \"<STR_LIT>\"<EOL><DEDENT>auth = HTTPBasicAuth(user_or_apikey, user_password)<EOL>self.r.auth = auth<EOL><DEDENT>self.ws.setauth(auth)<EOL>", "docstring": "setauth sets the authentication header for use in the session.\n        It is for use when apikey is updated or something of the sort, such that\n        there is a seamless experience.", "id": "f1695:c2:m1"}
{"signature": "@property<EOL><INDENT>def sschema(self):<DEDENT>", "body": "if \"<STR_LIT>\" in self.data:<EOL><INDENT>return self.data[\"<STR_LIT>\"]<EOL><DEDENT>return None<EOL>", "docstring": "Returns the JSON schema of the stream as a string", "id": "f1697:c0:m19"}
{"signature": "def __getitem__(self, getrange):", "body": "if not isinstance(getrange, slice):<EOL><INDENT>return self(i1=getrange, i2=getrange + <NUM_LIT:1>)[<NUM_LIT:0>]<EOL><DEDENT>return self(i1=getrange.start, i2=getrange.stop)<EOL>", "docstring": "Allows accessing the stream just as if it were just one big python array.\n        An example::\n\n            #Returns the most recent 5 datapoints from the stream\n            stream[-5:]\n\n            #Returns all the data the stream holds.\n            stream[:]\n\n        In order to perform transforms on the stream and to aggreagate data, look at __call__,\n        which allows getting index ranges along with a transform.", "id": "f1697:c0:m7"}
{"signature": "@property<EOL><INDENT>def schema(self):<DEDENT>", "body": "if \"<STR_LIT>\" in self.data:<EOL><INDENT>return json.loads(self.data[\"<STR_LIT>\"])<EOL><DEDENT>return None<EOL>", "docstring": "Returns the JSON schema of the stream as a python dict.", "id": "f1697:c0:m18"}
{"signature": "@schema.setter<EOL><INDENT>def schema(self, schema):<DEDENT>", "body": "if isinstance(schema, basestring):<EOL><INDENT>strschema = schema<EOL>schema = json.loads(schema)<EOL><DEDENT>else:<EOL><INDENT>strschema = json.dumps(schema)<EOL><DEDENT>Draft4Validator.check_schema(schema)<EOL>self.set({\"<STR_LIT>\": strschema})<EOL>", "docstring": "sets the stream's schema. An empty schema is \"{}\". The schemas allow you to set a specific data type. \n        Both python dicts and strings are accepted.", "id": "f1697:c0:m20"}
{"signature": "def append(self, data):", "body": "self.insert(data)<EOL>", "docstring": "Same as insert, using the pythonic array name", "id": "f1697:c0:m3"}
{"signature": "def import_device(self, directory):", "body": "<EOL>with open(os.path.join(directory, \"<STR_LIT>\"), \"<STR_LIT:r>\") as f:<EOL><INDENT>ddata = json.load(f)<EOL><DEDENT>d = self[ddata[\"<STR_LIT:name>\"]]<EOL>dname = ddata[\"<STR_LIT:name>\"]<EOL>del ddata[\"<STR_LIT:name>\"]<EOL>if dname == \"<STR_LIT>\":<EOL><INDENT>return<EOL><DEDENT>elif dname == \"<STR_LIT:user>\":<EOL><INDENT>d.set(ddata)<EOL><DEDENT>elif d.exists():<EOL><INDENT>raise ValueError(\"<STR_LIT>\" + d.name + \"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>d.create(**ddata)<EOL><DEDENT>for name in os.listdir(directory):<EOL><INDENT>sdir = os.path.join(directory, name)<EOL>if os.path.isdir(sdir):<EOL><INDENT>d.import_stream(sdir)<EOL><DEDENT><DEDENT>", "docstring": "Imports a device from the given directory. You export the device\n        by using device.export()\n\n        There are two special cases: user and meta devices.\n        If the device name is meta, import_device will not do anything.\n        If the device name is \"user\", import_device will overwrite the user device\n        even if it exists already.", "id": "f1698:c0:m7"}
{"signature": "def streams(self, public=False, downlink=False, visible=True):", "body": "result = self.db.read(self.path, {\"<STR_LIT:q>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": str(public).lower(),<EOL>\"<STR_LIT>\": str(downlink).lower(),<EOL>\"<STR_LIT>\": str(visible).lower()})<EOL>if result is None or result.json() is None:<EOL><INDENT>return []<EOL><DEDENT>streams = []<EOL>for d in result.json():<EOL><INDENT>s = self[d[\"<STR_LIT>\"]][d[\"<STR_LIT:name>\"]]<EOL>s.metadata = d<EOL>streams.append(s)<EOL><DEDENT>return streams<EOL>", "docstring": "Returns the list of streams that belong to the user.\n        The list can optionally be filtered in 3 ways:\n            - public: when True, returns only streams belonging to public devices\n            - downlink: If True, returns only downlink streams\n            - visible: If True (default), returns only streams of visible devices", "id": "f1698:c0:m3"}
{"signature": "@role.setter<EOL><INDENT>def role(self, new_role):<DEDENT>", "body": "self.set({\"<STR_LIT>\": new_role})<EOL>", "docstring": "Attempts to set the user's role", "id": "f1698:c0:m13"}
{"signature": "def export(self, directory):", "body": "exportInfoFile = os.path.join(directory, \"<STR_LIT>\")<EOL>if os.path.exists(directory):<EOL><INDENT>if not os.path.exists(exportInfoFile):<EOL><INDENT>raise FileExistsError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>with open(exportInfoFile) as f:<EOL><INDENT>exportInfo = json.load(f)<EOL><DEDENT>if exportInfo[\"<STR_LIT>\"] != <NUM_LIT:1>:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>os.mkdir(directory)<EOL>with open(exportInfoFile, \"<STR_LIT:w>\") as f:<EOL><INDENT>json.dump(<EOL>{\"<STR_LIT>\": <NUM_LIT:1>, \"<STR_LIT>\": self.db.get(\"<STR_LIT>\").text}, f)<EOL><DEDENT><DEDENT>udir = os.path.join(directory, self.name)<EOL>os.mkdir(udir)<EOL>with open(os.path.join(udir, \"<STR_LIT>\"), \"<STR_LIT:w>\") as f:<EOL><INDENT>json.dump(self.data, f)<EOL><DEDENT>for d in self.devices():<EOL><INDENT>d.export(os.path.join(udir, d.name))<EOL><DEDENT>", "docstring": "Exports the ConnectorDB user into the given directory.\n        The resulting export can be imported by using the import command(cdb.import(directory)),\n\n        Note that Python cannot export passwords, since the REST API does\n        not expose password hashes. Therefore, the imported user will have\n        password same as username.\n\n        The user export function is different than device and stream exports because\n        it outputs a format compatible directly with connectorDB's import functionality:\n\n            connectordb import < mydatabase > <directory >\n\n        This also means that you can export multiple users into the same directory without issue", "id": "f1698:c0:m6"}
{"signature": "def __repr__(self):", "body": "return \"<STR_LIT>\" % (self.path, )<EOL>", "docstring": "Returns a string representation of the user", "id": "f1698:c0:m5"}
{"signature": "def sum(self):", "body": "raw = self.raw()<EOL>s = <NUM_LIT:0><EOL>for i in range(len(raw)):<EOL><INDENT>s += raw[i][\"<STR_LIT:d>\"]<EOL><DEDENT>return s<EOL>", "docstring": "Gets the sum of the data portions of all datapoints within", "id": "f1699:c0:m13"}
{"signature": "def t(self):", "body": "return list(map(lambda x: datetime.datetime.fromtimestamp(x[\"<STR_LIT:t>\"]), self.raw()))<EOL>", "docstring": "Returns just the timestamp portion of the datapoints as a list.\n        The timestamps are in python datetime's date format.", "id": "f1699:c0:m6"}
{"signature": "def mean(self):", "body": "return self.sum() / float(len(self))<EOL>", "docstring": "Gets the mean of the data portions of all datapoints within", "id": "f1699:c0:m14"}
{"signature": "def stop(self):", "body": "with self.synclock:<EOL><INDENT>if self.syncthread is not None:<EOL><INDENT>self.syncthread.cancel()<EOL>self.syncthread = None<EOL><DEDENT><DEDENT>", "docstring": "Stops the background synchronization thread", "id": "f1700:c0:m13"}
{"signature": "def __init__(self, database_file_path, on_create=None, apikey=None, onsync=None, onsyncfail=None, syncraise=False):", "body": "self.database = apsw.Connection(database_file_path)<EOL>c = self.database.cursor()<EOL>c.execute(<EOL>\"<STR_LIT>\")<EOL>c.execute(<EOL>\"<STR_LIT>\")<EOL>c.execute(<EOL>\"<STR_LIT>\")<EOL>c.execute(\"<STR_LIT>\")<EOL>row_number = next(c)[<NUM_LIT:0>]<EOL>if row_number == <NUM_LIT:0>:<EOL><INDENT>logging.debug(\"<STR_LIT>\")<EOL>c.execute(\"<STR_LIT>\",<EOL>(CONNECTORDB_URL, ))<EOL><DEDENT>c.execute(<EOL>\"<STR_LIT>\")<EOL>self.__apikey, self.__serverurl, self.__lastsync, self.__syncperiod = next(<EOL>c)<EOL>c.execute(\"<STR_LIT>\")<EOL>self.streams = {}<EOL>for row in c.fetchall():<EOL><INDENT>self.streams[row[<NUM_LIT:0>]] = json.loads(row[<NUM_LIT:1>])<EOL><DEDENT>if apikey is not None:<EOL><INDENT>self.apikey = apikey<EOL><DEDENT>self.synclock = threading.Lock()<EOL>self.syncthread = None<EOL>self.__cdb = None<EOL>self.onsync = onsync<EOL>self.onsyncfail = onsyncfail<EOL>self.syncraise = syncraise<EOL>if on_create is not None and row_number == <NUM_LIT:0>:<EOL><INDENT>try:<EOL><INDENT>if False == on_create(self):<EOL><INDENT>raise Exception(<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT>except:<EOL><INDENT>self.database.close()<EOL>os.remove(database_file_path)<EOL>raise<EOL><DEDENT><DEDENT>", "docstring": "Logger is started by passing its database file, and an optional callback which is run if the database\n        is not initialized, allowing setup code to be only run once.\n\n        The on_create callback can optionally be used to initialize the necessary api keys and such.\n        If on_create returns False or raises an error, the uninitialized database file will be removed.", "id": "f1700:c0:m0"}
{"signature": "def start(self):", "body": "with self.synclock:<EOL><INDENT>if self.syncthread is not None:<EOL><INDENT>logging.warn(<EOL>\"<STR_LIT>\")<EOL>return<EOL><DEDENT><DEDENT>self.sync()  <EOL>self.__setsync()<EOL>", "docstring": "Start the logger background synchronization service. This allows you to not need to\n        worry about syncing with ConnectorDB - you just insert into the Logger, and the Logger\n        will by synced every syncperiod.", "id": "f1700:c0:m12"}
{"signature": "def insert(self, streamname, value):", "body": "if streamname not in self.streams:<EOL><INDENT>raise Exception(\"<STR_LIT>\" % (streamname, ))<EOL><DEDENT>validate(value, self.streams[streamname])<EOL>value = json.dumps(value)<EOL>logging.debug(\"<STR_LIT>\" % (streamname, value))<EOL>c = self.database.cursor()<EOL>c.execute(\"<STR_LIT>\",<EOL>(streamname, time.time(), value))<EOL>", "docstring": "Insert the datapoint into the logger for the given stream name. The logger caches the datapoint\n        and eventually synchronizes it with ConnectorDB", "id": "f1700:c0:m7"}
{"signature": "def close(self):", "body": "self.stop()<EOL>with self.synclock:<EOL><INDENT>self.database.close()<EOL><DEDENT>", "docstring": "Closes the database connections and stops all synchronization.", "id": "f1700:c0:m4"}
{"signature": "@property<EOL><INDENT>def connectordb(self):<DEDENT>", "body": "if self.__cdb is None:<EOL><INDENT>logging.debug(\"<STR_LIT>\" + self.serverurl)<EOL>self.__cdb = ConnectorDB(self.apikey, url=self.serverurl)<EOL><DEDENT>return self.__cdb<EOL>", "docstring": "Returns the ConnectorDB object that the logger uses. Raises an error if Logger isn't able to connect", "id": "f1700:c0:m1"}
{"signature": "@property<EOL><INDENT>def data(self):<DEDENT>", "body": "c = self.database.cursor()<EOL>c.execute(\"<STR_LIT>\")<EOL>return json.loads(next(c)[<NUM_LIT:0>])<EOL>", "docstring": "The data property allows the user to save settings/data in the database, so that\n        there does not need to be extra code messing around with settings.\n\n        Use this property to save things that can be converted to JSON inside the logger database,\n        so that you don't have to mess with configuration files or saving setting otherwise::\n\n            from connectordb.logger import Logger\n\n            l = Logger(\"log.db\")\n\n            l.data = {\"hi\": 56}\n\n            # prints the data dictionary\n            print l.data", "id": "f1700:c0:m24"}
{"signature": "@register.filter<EOL>def timestamp(value):", "body": "return timedelta(<NUM_LIT:0>, int(value))<EOL>", "docstring": "Timestamp to elapsed time format.", "id": "f1705:m1"}
{"signature": "@register.filter<EOL>def human_bytes(value):", "body": "value = float(value)<EOL>if value >= <NUM_LIT>:<EOL><INDENT>gigabytes = value / <NUM_LIT><EOL>size = '<STR_LIT>' % gigabytes<EOL><DEDENT>elif value >= <NUM_LIT>:<EOL><INDENT>megabytes = value / <NUM_LIT><EOL>size = '<STR_LIT>' % megabytes<EOL><DEDENT>elif value >= <NUM_LIT>:<EOL><INDENT>kilobytes = value / <NUM_LIT><EOL>size = '<STR_LIT>' % kilobytes<EOL><DEDENT>else:<EOL><INDENT>size = '<STR_LIT>' % value<EOL><DEDENT>return size<EOL>", "docstring": "Convert a byte value into a human-readable format.", "id": "f1705:m0"}
{"signature": "def _context_data(data, request=None):", "body": "try:<EOL><INDENT>return dict(site.each_context(request).items() + data.items())<EOL><DEDENT>except AttributeError:<EOL><INDENT>return data<EOL><DEDENT>", "docstring": "Add admin global context, for compatibility with Django 1.7", "id": "f1706:m3"}
{"signature": "def flush(request):", "body": "mc_client.flush_all()<EOL>messages.success(request, _('<STR_LIT>'))<EOL>return redirect('<STR_LIT>')<EOL>", "docstring": "Flush servers.", "id": "f1706:m8"}
{"signature": "def parse(src, encoding=None):", "body": "def safe_is_file(filename):<EOL><INDENT>try:<EOL><INDENT>return os.path.isfile(src)<EOL><DEDENT>except ValueError:  <EOL><INDENT>return False<EOL><DEDENT><DEDENT>if hasattr(src, '<STR_LIT>'):  <EOL><INDENT>data = src.read()<EOL><DEDENT>elif safe_is_file(src):<EOL><INDENT>with open(src, '<STR_LIT:rb>') as fh:<EOL><INDENT>data = fh.read()<EOL><DEDENT><DEDENT>else:  <EOL><INDENT>data = src<EOL><DEDENT>if hasattr(data, '<STR_LIT>'):  <EOL><INDENT>exception = None<EOL>encodings = [encoding, '<STR_LIT:utf-8>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>for encoding in encodings:  <EOL><INDENT>if not encoding:<EOL><INDENT>continue<EOL><DEDENT>try:<EOL><INDENT>data = data.decode(encoding)<EOL>break<EOL><DEDENT>except UnicodeDecodeError as e:<EOL><INDENT>exception = e<EOL><DEDENT>except UnicodeEncodeError:<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise exception  <EOL><DEDENT><DEDENT>transactions = mt940.models.Transactions()<EOL>transactions.parse(data)<EOL>return transactions<EOL>", "docstring": "Parses mt940 data and returns transactions object\n\n:param src: file handler to read, filename to read or raw data as string\n:return: Collection of transactions\n:rtype: Transactions", "id": "f1712:m0"}
{"signature": "def mBank_set_tnr(transactions, tag, tag_dict, *args):", "body": "matches = tnr_re.search(tag_dict[tag.slug])<EOL>if matches:  <EOL><INDENT>tag_dict['<STR_LIT>'] = matches.groupdict()['<STR_LIT>']<EOL><DEDENT>return tag_dict<EOL>", "docstring": "mBank Collect states TNR in transaction details as unique id for\ntransactions, that may be used to identify the same transactions in\ndifferent statement files eg. partial mt942 and full mt940\nInformation about tnr uniqueness has been obtained from mBank support,\nit lacks in mt940 mBank specification.", "id": "f1716:m5"}
{"signature": "def date_fixup_pre_processor(transactions, tag, tag_dict, *args):", "body": "if tag_dict['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>year = int(tag_dict['<STR_LIT>'], <NUM_LIT:10>)<EOL>_, max_month_day = calendar.monthrange(year, <NUM_LIT:2>)<EOL>if int(tag_dict['<STR_LIT>'], <NUM_LIT:10>) > max_month_day:<EOL><INDENT>tag_dict['<STR_LIT>'] = str(max_month_day)<EOL><DEDENT><DEDENT>return tag_dict<EOL>", "docstring": "Replace illegal February 29, 30 dates with the last day of February.\n\nGerman banks use a variant of the 30/360 interest rate calculation,\nwhere each month has always 30 days even February. Python's datetime\nmodule won't accept such dates.", "id": "f1716:m1"}
{"signature": "def coalesce(*args):", "body": "for arg in args:<EOL><INDENT>if arg is not None:<EOL><INDENT>return arg<EOL><DEDENT><DEDENT>", "docstring": "Return the first non-None argument\n\n>>> coalesce()\n\n>>> coalesce(0, 1)\n0\n>>> coalesce(None, 0)\n0", "id": "f1718:m0"}
{"signature": "def frombytes(data, size, bandtype=gdal.GDT_Byte):", "body": "r = ImageDriver('<STR_LIT>').raster('<STR_LIT>', size, bandtype)<EOL>r.frombytes(data)<EOL>return r<EOL>", "docstring": "Returns an in-memory raster initialized from a pixel buffer.\n\n    Arguments:\n    data -- byte buffer of raw pixel data\n    size -- two or three-tuple of (xsize, ysize, bandcount)\n    bandtype -- band data type", "id": "f1741:m7"}
{"signature": "def driver_for_path(path, drivers=None):", "body": "ext = (os.path.splitext(path)[<NUM_LIT:1>][<NUM_LIT:1>:] or path).lower()<EOL>drivers = drivers or ImageDriver.registry if ext else {}<EOL>for name, meta in drivers.items():<EOL><INDENT>if ext == meta.get('<STR_LIT>', '<STR_LIT>').lower():<EOL><INDENT>return ImageDriver(name)<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Returns the gdal.Driver for a path or None based on the file extension.\n\n    Arguments:\n    path -- file path as str with a GDAL supported file extension", "id": "f1741:m1"}
{"signature": "def masked_array(self, geometry=None):", "body": "if geometry is None:<EOL><INDENT>return self._masked_array()<EOL><DEDENT>geom = transform(geometry, self.sref)<EOL>env = Envelope.from_geom(geom).intersect(self.envelope)<EOL>arr = self._masked_array(env)<EOL>if geom.GetGeometryType() != ogr.wkbPoint:<EOL><INDENT>dims = self.get_offset(env)[<NUM_LIT:2>:]<EOL>affine = AffineTransform(*tuple(self.affine))<EOL>affine.origin = env.ul<EOL>mask = ~np.ma.make_mask(geom_to_array(geom, dims, affine))<EOL>arr.mask = arr.mask | mask<EOL><DEDENT>return arr<EOL>", "docstring": "Returns a MaskedArray using nodata values.\n\n        Keyword args:\n        geometry -- any geometry, envelope, or coordinate extent tuple", "id": "f1741:c2:m22"}
{"signature": "def rasterize(layer, rast):", "body": "driver = ImageDriver('<STR_LIT>')<EOL>r2 = driver.raster(driver.ShortName, rast.size)<EOL>r2.affine = rast.affine<EOL>sref = rast.sref<EOL>if not sref.srid:<EOL><INDENT>sref = SpatialReference(<NUM_LIT>)<EOL><DEDENT>r2.sref = sref<EOL>ml = MemoryLayer(sref, layer.GetGeomType())<EOL>ml.load(layer)<EOL>status = gdal.RasterizeLayer(<EOL>r2.ds, (<NUM_LIT:1>,), ml.layer, options=['<STR_LIT>' % ml.id])<EOL>ml.close()<EOL>return r2<EOL>", "docstring": "Returns a Raster from layer features.\n\n    Arguments:\n    layer -- Layer to rasterize\n    rast -- Raster with target affine, size, and sref", "id": "f1741:m4"}
{"signature": "@property<EOL><INDENT>def info(self):<DEDENT>", "body": "return self._driver.GetMetadata()<EOL>", "docstring": "Returns a dict of gdal.Driver metadata.", "id": "f1741:c1:m11"}
{"signature": "def raster(self, path, size, bandtype=gdal.GDT_Byte):", "body": "path = getattr(path, '<STR_LIT:name>', path)<EOL>try:<EOL><INDENT>is_multiband = len(size) > <NUM_LIT:2><EOL>nx, ny, nbands = size if is_multiband else size + (<NUM_LIT:1>,)<EOL><DEDENT>except (TypeError, ValueError) as exc:<EOL><INDENT>exc.args = ('<STR_LIT>',)<EOL>raise<EOL><DEDENT>if nx < <NUM_LIT:1> or ny < <NUM_LIT:1>:<EOL><INDENT>raise ValueError('<STR_LIT>' % (size,))<EOL><DEDENT>if not self._is_empty(path):<EOL><INDENT>raise IOError('<STR_LIT>' % path)<EOL><DEDENT>ds = self.Create(path, nx, ny, nbands, bandtype)<EOL>if not ds:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>' % (path, str(self)))<EOL><DEDENT>return Raster(ds)<EOL>", "docstring": "Returns a new Raster instance.\n\n        gdal.Driver.Create() does not support all formats.\n\n        Arguments:\n        path -- file object or path as str\n        size -- two or three-tuple of (xsize, ysize, bandcount)\n        bandtype -- GDAL pixel data type", "id": "f1741:c1:m10"}
{"signature": "def project(self, coords):", "body": "geotransform = self.tuple<EOL>for x, y in coords:<EOL><INDENT>geo_x = geotransform[<NUM_LIT:0>] + geotransform[<NUM_LIT:1>] * x + geotransform[<NUM_LIT:2>] * y<EOL>geo_y = geotransform[<NUM_LIT:3>] + geotransform[<NUM_LIT:4>] * x + geotransform[<NUM_LIT:5>] * y<EOL>geo_x += geotransform[<NUM_LIT:1>] / <NUM_LIT><EOL>geo_y += geotransform[<NUM_LIT:5>] / <NUM_LIT><EOL>yield geo_x, geo_y<EOL><DEDENT>", "docstring": "Convert image pixel/line coordinates to georeferenced x/y, return a\n        generator of two-tuples.\n\n        Arguments:\n        coords -- input coordinates as iterable containing two-tuples/lists\n        such as ((0, 0), (10, 10))", "id": "f1741:c0:m5"}
{"signature": "@property<EOL><INDENT>def polygon(self):<DEDENT>", "body": "ring = ogr.Geometry(ogr.wkbLinearRing)<EOL>for coord in self.ll, self.lr, self.ur, self.ul, self.ll:<EOL><INDENT>ring.AddPoint_2D(*coord)<EOL><DEDENT>polyg = ogr.Geometry(ogr.wkbPolygon)<EOL>polyg.AddGeometryDirectly(ring)<EOL>return polyg<EOL>", "docstring": "Returns an OGR Geometry for this envelope.", "id": "f1742:c0:m21"}
{"signature": "@property<EOL><INDENT>def centroid(self):<DEDENT>", "body": "return self.min_x + self.width * <NUM_LIT:0.5>, self.min_y + self.height * <NUM_LIT:0.5><EOL>", "docstring": "Returns the envelope centroid as a (x, y) tuple.", "id": "f1742:c0:m9"}
{"signature": "def Geometry(*args, **kwargs):", "body": "<EOL>arg = kwargs.pop('<STR_LIT>', None) or len(args) and args[<NUM_LIT:0>]<EOL>try:<EOL><INDENT>srs = kwargs.pop('<STR_LIT>', None) or arg.srs.wkt<EOL><DEDENT>except AttributeError:<EOL><INDENT>srs = SpatialReference(<NUM_LIT>)<EOL><DEDENT>if hasattr(arg, '<STR_LIT>'):<EOL><INDENT>geom = ogr.CreateGeometryFromJson(json.dumps(arg))<EOL><DEDENT>elif hasattr(arg, '<STR_LIT>'):<EOL><INDENT>char = arg[<NUM_LIT:0>] if arg else '<STR_LIT:U+0020>'<EOL>i = char if isinstance(char, int) else ord(char)<EOL>if i in (<NUM_LIT:0>, <NUM_LIT:1>):<EOL><INDENT>geom = ogr.CreateGeometryFromWkb(arg)<EOL><DEDENT>elif arg.startswith('<STR_LIT:{>'):<EOL><INDENT>geom = ogr.CreateGeometryFromJson(arg)<EOL><DEDENT>elif arg.startswith('<STR_LIT>'):<EOL><INDENT>geom = ogr.CreateGeometryFromGML(arg)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' % arg)<EOL><DEDENT><DEDENT>elif hasattr(arg, '<STR_LIT>'):<EOL><INDENT>geom = ogr.CreateGeometryFromWkb(bytes(arg.wkb))<EOL><DEDENT>else:<EOL><INDENT>geom = ogr.Geometry(*args, **kwargs)<EOL><DEDENT>if geom:<EOL><INDENT>if not isinstance(srs, SpatialReference):<EOL><INDENT>srs = SpatialReference(srs)<EOL><DEDENT>geom.AssignSpatialReference(srs)<EOL><DEDENT>return geom<EOL>", "docstring": "Returns an ogr.Geometry instance optionally created from a geojson str\n    or dict. The spatial reference may also be provided.", "id": "f1742:m2"}
{"signature": "@property<EOL><INDENT>def lr(self):<DEDENT>", "body": "return self.max_x, self.min_y<EOL>", "docstring": "Returns the lower right coordinate.", "id": "f1742:c0:m18"}
{"signature": "@property<EOL><INDENT>def ll(self):<DEDENT>", "body": "return self.min_x, self.min_y<EOL>", "docstring": "Returns the lower left coordinate.", "id": "f1742:c0:m16"}
{"signature": "def __init__(self, *args):", "body": "if len(args) == <NUM_LIT:1>:<EOL><INDENT>args = args[<NUM_LIT:0>]<EOL><DEDENT>try:<EOL><INDENT>extent = list(map(float, args))<EOL><DEDENT>except (TypeError, ValueError) as exc:<EOL><INDENT>exc.args = ('<STR_LIT>' % repr(args),)<EOL>raise<EOL><DEDENT>try:<EOL><INDENT>self.min_x, self.max_x = sorted(extent[::<NUM_LIT:2>])<EOL>self.min_y, self.max_y = sorted(extent[<NUM_LIT:1>::<NUM_LIT:2>])<EOL><DEDENT>except ValueError as exc:<EOL><INDENT>exc.args = ('<STR_LIT>' % len(args),)<EOL>raise<EOL><DEDENT>", "docstring": "Creates an envelope from lower-left and upper-right coordinates.\n\n        Arguments:\n        args -- min_x, min_y, max_x, max_y or a four-tuple", "id": "f1742:c0:m0"}
{"signature": "@property<EOL><INDENT>def srid(self):<DEDENT>", "body": "epsg_id = (self.GetAuthorityCode('<STR_LIT>') or<EOL>self.GetAuthorityCode('<STR_LIT>'))<EOL>try:<EOL><INDENT>return int(epsg_id)<EOL><DEDENT>except TypeError:<EOL><INDENT>return<EOL><DEDENT>", "docstring": "Returns the EPSG ID as int if it exists.", "id": "f1745:c0:m5"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def move_image(self, dx, dy):<DEDENT>", "body": "return<EOL>", "docstring": "Move the image the annotation is according to by some pixels.\n\n:param dx: The amount of pixels the origin of the image is moved to the right.\n:param dy: The amount of pixels the origin of the image is moved to the bottom.\n:return:", "id": "f1764:c1:m5"}
{"signature": "def crop_image(img, start_y, start_x, h, w):", "body": "return img[start_y:start_y + h, start_x:start_x + w, :].copy()<EOL>", "docstring": "Crop an image given the top left corner.\n:param img: The image\n:param start_y: The top left corner y coord\n:param start_x: The top left corner x coord\n:param h: The result height\n:param w: The result width\n:return: The cropped image.", "id": "f1764:m8"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def iou(self, other):<DEDENT>", "body": "return <NUM_LIT:0.0><EOL>", "docstring": "Calculates the iou between two detections.\n:param other: The other detection that is used to compute the iou.\n:return: The intersection over union value.", "id": "f1764:c1:m2"}
{"signature": "def augment_detections(hyper_params, feature, label):", "body": "<EOL>if hyper_params.problem.get(\"<STR_LIT>\", None) is None:<EOL><INDENT>return feature, label<EOL><DEDENT>img_h, img_w, img_c = feature[\"<STR_LIT:image>\"].shape<EOL>augmented_feature = {}<EOL>augmented_label = {}<EOL>augmented_feature[\"<STR_LIT:image>\"] = feature[\"<STR_LIT:image>\"].copy()<EOL>if \"<STR_LIT>\" in feature:<EOL><INDENT>augmented_feature[\"<STR_LIT>\"] = feature[\"<STR_LIT>\"].copy()<EOL><DEDENT>if \"<STR_LIT>\" in feature:<EOL><INDENT>augmented_feature[\"<STR_LIT>\"] = feature[\"<STR_LIT>\"]<EOL><DEDENT>augmented_feature[\"<STR_LIT>\"] = np.array([<NUM_LIT:0>], dtype=np.uint8)<EOL>augmented_feature[\"<STR_LIT>\"] = np.array([<NUM_LIT:0>, <NUM_LIT:0>], dtype=np.int8)<EOL>for k in label.keys():<EOL><INDENT>augmented_label[k] = [detection.copy() for detection in label[k]]<EOL><DEDENT>if hyper_params.problem.augmentation.get(\"<STR_LIT>\", False):<EOL><INDENT>if random.random() < <NUM_LIT:0.5>:<EOL><INDENT>img_h, img_w, img_c = augmented_feature[\"<STR_LIT:image>\"].shape<EOL>augmented_feature[\"<STR_LIT:image>\"] = np.fliplr(augmented_feature[\"<STR_LIT:image>\"])<EOL>if \"<STR_LIT>\" in feature:<EOL><INDENT>augmented_feature[\"<STR_LIT>\"] = np.fliplr(augmented_feature[\"<STR_LIT>\"])<EOL><DEDENT>augmented_feature[\"<STR_LIT>\"][<NUM_LIT:0>] = <NUM_LIT:1><EOL>hflip_detections(augmented_label, img_w)<EOL><DEDENT><DEDENT>if hyper_params.problem.augmentation.get(\"<STR_LIT>\", False):<EOL><INDENT>img_h, img_w, img_c = augmented_feature[\"<STR_LIT:image>\"].shape<EOL>dx = int(random.random() * <NUM_LIT:3>)<EOL>dy = int(random.random() * <NUM_LIT:3>)<EOL>augmented_feature[\"<STR_LIT:image>\"] = crop_image(augmented_feature[\"<STR_LIT:image>\"], dy, dx, img_h - dy, img_w - dx)<EOL>if \"<STR_LIT>\" in feature:<EOL><INDENT>augmented_feature[\"<STR_LIT>\"] = crop_image(augmented_feature[\"<STR_LIT>\"], dy, dx, img_h - dy, img_w - dx)<EOL><DEDENT>augmented_feature[\"<STR_LIT>\"][<NUM_LIT:0>] += dy<EOL>augmented_feature[\"<STR_LIT>\"][<NUM_LIT:1>] += dx<EOL>move_detections(augmented_label, -dy, -dx)<EOL><DEDENT>if hyper_params.problem.augmentation.get(\"<STR_LIT>\", None) is not None:<EOL><INDENT>img_h, img_w, img_c = augmented_feature[\"<STR_LIT:image>\"].shape<EOL>target_w = hyper_params.problem.augmentation.random_crop.shape.width<EOL>target_h = hyper_params.problem.augmentation.random_crop.shape.height<EOL>delta_x = max(int(math.ceil((target_w + <NUM_LIT:1> - img_w) / <NUM_LIT:2>)), <NUM_LIT:0>)<EOL>delta_y = max(int(math.ceil((target_h + <NUM_LIT:1> - img_h) / <NUM_LIT:2>)), <NUM_LIT:0>)<EOL>move_detections(augmented_label, delta_y, delta_x)<EOL>augmented_feature[\"<STR_LIT:image>\"] = cv2.copyMakeBorder(augmented_feature[\"<STR_LIT:image>\"],<EOL>delta_y, delta_y, delta_x, delta_x,<EOL>cv2.BORDER_CONSTANT)<EOL>img_h, img_w, img_c = augmented_feature[\"<STR_LIT:image>\"].shape<EOL>start_x = <NUM_LIT:0><EOL>start_y = <NUM_LIT:0><EOL>if len(augmented_label[\"<STR_LIT>\"]) != <NUM_LIT:0>:<EOL><INDENT>idx = random.randint(<NUM_LIT:0>, len(augmented_label[\"<STR_LIT>\"]) - <NUM_LIT:1>)<EOL>detection = augmented_label[\"<STR_LIT>\"][idx]<EOL>start_x = int(detection.cx - random.random() * (target_w - <NUM_LIT:20>) / <NUM_LIT> - <NUM_LIT:10>)<EOL>start_y = int(detection.cy - random.random() * (target_h - <NUM_LIT:20>) / <NUM_LIT> - <NUM_LIT:10>)<EOL><DEDENT>else:<EOL><INDENT>start_x = int(img_w * random.random())<EOL>start_y = int(img_h * random.random())<EOL><DEDENT>if start_x < <NUM_LIT:0>:<EOL><INDENT>start_x = <NUM_LIT:0><EOL><DEDENT>if start_y < <NUM_LIT:0>:<EOL><INDENT>start_y = <NUM_LIT:0><EOL><DEDENT>if start_x >= img_w - target_w:<EOL><INDENT>start_x = img_w - target_w - <NUM_LIT:1><EOL><DEDENT>if start_y >= img_h - target_h:<EOL><INDENT>start_y = img_h - target_h - <NUM_LIT:1><EOL><DEDENT>augmented_feature[\"<STR_LIT:image>\"] = crop_image(augmented_feature[\"<STR_LIT:image>\"], start_y, start_x, target_h, target_w)<EOL>if \"<STR_LIT>\" in feature:<EOL><INDENT>augmented_feature[\"<STR_LIT>\"] = crop_image(augmented_feature[\"<STR_LIT>\"], start_y, start_x, target_h, target_w)<EOL><DEDENT>augmented_feature[\"<STR_LIT>\"][<NUM_LIT:0>] += start_y<EOL>augmented_feature[\"<STR_LIT>\"][<NUM_LIT:1>] += start_x<EOL>move_detections(augmented_label, -start_y, -start_x)<EOL><DEDENT>if hyper_params.problem.augmentation.get(\"<STR_LIT>\", False):<EOL><INDENT>if random.random() < <NUM_LIT:0.5>:<EOL><INDENT>augmented_feature[\"<STR_LIT:image>\"] = full_texture_augmentation(augmented_feature[\"<STR_LIT:image>\"])<EOL><DEDENT><DEDENT>return augmented_feature, augmented_label<EOL>", "docstring": "Augment the detection dataset.\n\nIn your hyper_parameters.problem.augmentation add configurations to enable features.\nSupports \"enable_horizontal_flip\", \"enable_micro_translation\", \"random_crop\" : {\"shape\": { \"width\", \"height\" }}\nand \"enable_texture_augmentation\". Make sure to also set the \"steps\" otherwise this method will not be used properly.\n\nRandom crop ensures at least one detection is in the crop region.\n\nSample configuration\n\"problem\": {\n    \"augmentation\": {\n        \"steps\": 40,\n        \"enable_texture_augmentation\": true,\n        \"enable_micro_translation\": true,\n        \"enable_horizontal_flip\": true,\n        \"random_crop\": {\n            \"shape\": {\n                \"width\": 256,\n                \"height\": 256\n            }\n        }\n    }\n}\n\n:param hyper_params: The hyper parameters object\n:param feature: A dict containing all features, must be in the style created by detection datasets.\n:param label: A label dict in the detection dataset style.\n:return: Modified feature and label dict (copied & modified).", "id": "f1764:m11"}
{"signature": "def to_currency(self, val, currency='<STR_LIT>', cents=True, separator='<STR_LIT:U+002C>',<EOL>adjective=False):", "body": "left, right, is_negative = parse_currency_parts(val)<EOL>try:<EOL><INDENT>cr1, cr2 = self.CURRENCY_FORMS[currency]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise NotImplementedError(<EOL>'<STR_LIT>' %<EOL>(currency, self.__class__.__name__))<EOL><DEDENT>if adjective and currency in self.CURRENCY_ADJECTIVES:<EOL><INDENT>cr1 = prefix_currency(<EOL>self.CURRENCY_ADJECTIVES[currency],<EOL>cr1<EOL>)<EOL><DEDENT>minus_str = \"<STR_LIT>\" % self.negword if is_negative else \"<STR_LIT>\"<EOL>cents_str = self._cents_verbose(right, currency)if cents else self._cents_terse(right, currency)<EOL>return u'<STR_LIT>' % (<EOL>minus_str,<EOL>self.to_cardinal(left, feminine=cr1[-<NUM_LIT:1>]),<EOL>self.pluralize(left, cr1),<EOL>separator,<EOL>cents_str,<EOL>self.pluralize(right, cr2)<EOL>)<EOL>", "docstring": "Args:\n    val: Numeric value\n    currency (str): Currency code\n    cents (bool): Verbose cents\n    separator (str): Cent separator\n    adjective (bool): Prefix currency name with adjective\nReturns:\n    str: Formatted string", "id": "f1770:c0:m6"}
{"signature": "def split_by_3(self, number):", "body": "blocks = ()<EOL>length = len(number)<EOL>if length < <NUM_LIT:3>:<EOL><INDENT>blocks += ((number,),)<EOL><DEDENT>else:<EOL><INDENT>len_of_first_block = length % <NUM_LIT:3><EOL>if len_of_first_block > <NUM_LIT:0>:<EOL><INDENT>first_block = number[<NUM_LIT:0>:len_of_first_block],<EOL>blocks += first_block,<EOL><DEDENT>for i in range(len_of_first_block, length, <NUM_LIT:3>):<EOL><INDENT>next_block = (number[i:i + <NUM_LIT:3>],),<EOL>blocks += next_block<EOL><DEDENT><DEDENT>return blocks<EOL>", "docstring": "starting here, it groups the number by three from the tail\n'1234567' -> (('1',),('234',),('567',))\n:param number:str\n:rtype:tuple", "id": "f1801:c0:m1"}
{"signature": "async def parse_character_results(soup):", "body": "soup = list(soup.find_all('<STR_LIT>', class_='<STR_LIT>')[<NUM_LIT:0>].children)[<NUM_LIT:1>:]<EOL>characters = []<EOL>for item in soup:<EOL><INDENT>temp_c = {'<STR_LIT>': None, '<STR_LIT:name>': None, '<STR_LIT>': {}}<EOL>temp_c['<STR_LIT>'] = item.abbr.get('<STR_LIT:title>')<EOL>temp_c['<STR_LIT:name>'] = list(item.children)[<NUM_LIT:1>].a.string<EOL>temp_c['<STR_LIT>'] = []<EOL>for game in list(list(list(item.children)[<NUM_LIT:1>].children)[<NUM_LIT:1>].children):<EOL><INDENT>if isinstance(game, NavigableString):<EOL><INDENT>continue<EOL><DEDENT>temp_c['<STR_LIT>'].append({'<STR_LIT:name>': game.string, '<STR_LIT:id>': game.get('<STR_LIT>').split('<STR_LIT:/>')[<NUM_LIT:1>]})<EOL><DEDENT>characters.append(temp_c)<EOL>del temp_c<EOL><DEDENT>return characters<EOL>", "docstring": "Parse a page of character results.\n\n:param soup: The BS4 class object\n:return: Returns a list of dictionaries containing a name, gender and list of dictionaries containing a game name/id pair\n         for games they appeared in.", "id": "f1846:m3"}
{"signature": "async def parse_release_results(soup):", "body": "soup = list(soup.find_all('<STR_LIT>', class_='<STR_LIT>')[<NUM_LIT:0>].children)[<NUM_LIT:1>:]<EOL>releases = []<EOL>for item in soup:<EOL><INDENT>child = list(item.children)<EOL>temp_rel = {'<STR_LIT:date>': None, '<STR_LIT>': None, '<STR_LIT>': None, '<STR_LIT:name>': None}<EOL>temp_rel['<STR_LIT:date>'] = child[<NUM_LIT:0>].string<EOL>temp_rel['<STR_LIT>'] = child[<NUM_LIT:1>].string<EOL>temp_rel['<STR_LIT>'] = child[<NUM_LIT:2>].abbr.get('<STR_LIT:title>')<EOL>temp_rel['<STR_LIT:name>'] = child[<NUM_LIT:3>].a.string<EOL>releases.append(temp_rel)<EOL>del temp_rel<EOL><DEDENT>return releases<EOL>", "docstring": "Parse Releases search pages.\n\n:param soup: The BS4 class object\n:return: A list of dictionaries containing a release dictionary. This is the same as the one returned in get_novel.\n         It contains a Date released, Platform, Ages group and Name.", "id": "f1846:m1"}
{"signature": "async def parse_prod_staff_results(soup):", "body": "soup = soup.find_all('<STR_LIT>')<EOL>producers = []<EOL>for item in soup:<EOL><INDENT>producers.append({'<STR_LIT>': item.abbr.get('<STR_LIT:title>'), '<STR_LIT:name>': item.a.string})<EOL><DEDENT>return producers<EOL>", "docstring": "Parse a page of producer or staff results\n\n:param soup: The BS4 class object\n:return: A list of dictionaries containing a name and nationality.", "id": "f1846:m2"}
{"signature": "async def parse_vn_results(soup):", "body": "soup = soup.find_all('<STR_LIT>', class_='<STR_LIT>')<EOL>vns = []<EOL>for item in soup[<NUM_LIT:1>:]:<EOL><INDENT>vns.append({'<STR_LIT:name>': item.string, '<STR_LIT:id>': item.a.get('<STR_LIT>')[<NUM_LIT:1>:]})<EOL><DEDENT>return vns<EOL>", "docstring": "Parse Visual Novel search pages.\n\n:param soup: The BS4 class object\n:return:  A list of dictionaries containing a name and id.", "id": "f1846:m0"}
{"signature": "async def parse_search(self, stype, soup):", "body": "if stype == '<STR_LIT:v>':<EOL><INDENT>return await parse_vn_results(soup)<EOL><DEDENT>elif stype == '<STR_LIT:r>':<EOL><INDENT>return await parse_release_results(soup)<EOL><DEDENT>elif stype == '<STR_LIT:p>':<EOL><INDENT>return await parse_prod_staff_results(soup)<EOL><DEDENT>elif stype == '<STR_LIT:s>':<EOL><INDENT>return await parse_prod_staff_results(soup)<EOL><DEDENT>elif stype == '<STR_LIT:c>':<EOL><INDENT>return await parse_character_results(soup)<EOL><DEDENT>elif stype == '<STR_LIT:g>':<EOL><INDENT>return await parse_tag_results(soup)<EOL><DEDENT>elif stype == '<STR_LIT:i>':<EOL><INDENT>return await parse_tag_results(soup)<EOL><DEDENT>elif stype == '<STR_LIT:u>':<EOL><INDENT>return await parse_user_results(soup)<EOL><DEDENT>", "docstring": "This is our parsing dispatcher\n\n:param stype: Search type category\n:param soup: The beautifulsoup object that contains the parsed html", "id": "f1848:c0:m3"}
{"signature": "def __setattr__(self, key, value):", "body": "if self.__isfrozen and not hasattr(self, key):<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % self)<EOL><DEDENT>object.__setattr__(self, key, value)<EOL>", "docstring": "protect users from abusing properties", "id": "f1854:c3:m11"}
{"signature": "def _modify_service_config(self):", "body": "<EOL>self.project.get_service('<STR_LIT>').options['<STR_LIT>'] = [\"<STR_LIT>\"]<EOL>bootstrap = self.project.get_service('<STR_LIT>')<EOL>bootstrap.options['<STR_LIT>'] = [p.replace(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>for p in bootstrap.options['<STR_LIT>']]<EOL>for service in self.project.services:<EOL><INDENT>container_name = service.options.get('<STR_LIT>')<EOL>if container_name:<EOL><INDENT>service.options['<STR_LIT>'] = container_name.replace(\"<STR_LIT>\",<EOL>PROJECT_NAME)<EOL><DEDENT><DEDENT>", "docstring": "Modify the services configurations to allow testing.", "id": "f1859:c0:m1"}
{"signature": "def initialize(ctx, a='<STR_LIT>', c='<STR_LIT:bool>', d='<STR_LIT>'):", "body": "", "docstring": "Constructor (can a constructor return anything?)", "id": "f1862:c1:m0"}
{"signature": "def on_receive_transactions(self, proto, transactions):", "body": "log.debug('<STR_LIT>')<EOL>log.debug('<STR_LIT>', count=len(transactions), remote_id=proto)<EOL>def _add_txs():<EOL><INDENT>for tx in transactions:<EOL><INDENT>self.add_transaction(tx, origin=proto)<EOL><DEDENT><DEDENT>gevent.spawn(_add_txs)<EOL>", "docstring": "receives rlp.decoded serialized", "id": "f1868:c2:m18"}
{"signature": "def transfer(ctx, _to='<STR_LIT:address>', _value='<STR_LIT>', returns=STATUS):", "body": "log.DEV('<STR_LIT>')<EOL>if ctx.accounts[ctx.msg_sender] >= _value:<EOL><INDENT>ctx.accounts[ctx.msg_sender] -= _value<EOL>ctx.accounts[_to] += _value<EOL>ctx.Transfer(ctx.msg_sender, _to, _value)<EOL>return OK<EOL><DEDENT>else:<EOL><INDENT>return INSUFFICIENTFUNDS<EOL><DEDENT>", "docstring": "Standardized Contract API:\n        function transfer(address _to, uint256 _value) returns (bool _success)", "id": "f1870:c2:m1"}
{"signature": "def approve(ctx, _spender='<STR_LIT:address>', _value='<STR_LIT>', returns=STATUS):", "body": "ctx.allowances[ctx.msg_sender][_spender] += _value<EOL>ctx.Approval(ctx.msg_sender, _spender, _value)<EOL>return OK<EOL>", "docstring": "Standardized Contract API:\n        function approve(address _spender, uint256 _value) returns (bool success)", "id": "f1870:c2:m5"}
{"signature": "@property<EOL><INDENT>def last_valid_lockset(self):<DEDENT>", "body": "for r in self.rounds:<EOL><INDENT>ls = self.rounds[r].lockset<EOL>if ls.is_valid:<EOL><INDENT>return ls<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "highest valid lockset on height", "id": "f1875:c9:m4"}
{"signature": "def check(self):", "body": "if not self.is_valid:<EOL><INDENT>return True<EOL><DEDENT>test = (self.has_quorum, self.has_quorum_possible, self.has_noquorum)<EOL>assert <NUM_LIT:1> == len([x for x in test if x is not None])<EOL>return True<EOL>", "docstring": "either invalid or one of quorum, noquorum, quorumpossible", "id": "f1876:c9:m14"}
{"signature": "def sign(self, privkey):", "body": "if self.v:<EOL><INDENT>raise InvalidSignature(\"<STR_LIT>\")<EOL><DEDENT>if privkey in (<NUM_LIT:0>, '<STR_LIT>', '<STR_LIT:\\x00>' * <NUM_LIT:32>):<EOL><INDENT>raise InvalidSignature(\"<STR_LIT>\")<EOL><DEDENT>rawhash = sha3(rlp.encode(self, self.__class__.exclude(['<STR_LIT:v>', '<STR_LIT:r>', '<STR_LIT:s>'])))<EOL>if len(privkey) == <NUM_LIT:64>:<EOL><INDENT>privkey = encode_privkey(privkey, '<STR_LIT>')<EOL><DEDENT>pk = PrivateKey(privkey, raw=True)<EOL>signature = pk.ecdsa_recoverable_serialize(pk.ecdsa_sign_recoverable(rawhash, raw=True))<EOL>signature = signature[<NUM_LIT:0>] + chr(signature[<NUM_LIT:1>])<EOL>self.v = ord(signature[<NUM_LIT:64>]) + <NUM_LIT><EOL>self.r = big_endian_to_int(signature[<NUM_LIT:0>:<NUM_LIT:32>])<EOL>self.s = big_endian_to_int(signature[<NUM_LIT:32>:<NUM_LIT:64>])<EOL>self._sender = None<EOL>return self<EOL>", "docstring": "Sign this with a private key", "id": "f1876:c3:m1"}
{"signature": "def mk_privkeys(num):", "body": "privkeys = []<EOL>assert num <= num_colors<EOL>for i in range(num):<EOL><INDENT>j = <NUM_LIT:0><EOL>while True:<EOL><INDENT>k = sha3(str(j))<EOL>a = privtoaddr(k)<EOL>an = big_endian_to_int(a)<EOL>if an % num_colors == i:<EOL><INDENT>break<EOL><DEDENT>j += <NUM_LIT:1><EOL><DEDENT>privkeys.append(k)<EOL><DEDENT>return privkeys<EOL>", "docstring": "make privkeys that support coloring, see utils.cstr", "id": "f1877:m0"}
{"signature": "def delay(self, sender, receiver, packet, add_delay=<NUM_LIT:0>):", "body": "bw = min(sender.ul_bandwidth, receiver.dl_bandwidth)<EOL>delay = sender.base_latency + receiver.base_latency<EOL>delay += len(packet) / bw<EOL>delay += add_delay<EOL>return delay<EOL>", "docstring": "bandwidths are inaccurate, as we don't account for parallel transfers here", "id": "f1877:c0:m1"}
{"signature": "def on_proposal(self, proposal, proto):", "body": "assert isinstance(proto, HDCProtocol)<EOL>assert isinstance(proposal, Proposal)<EOL>if proposal.height >= self.cm.height:<EOL><INDENT>assert proposal.lockset.is_valid<EOL>self.last_active_protocol = proto<EOL><DEDENT>", "docstring": "called to inform about synced peers", "id": "f1879:c0:m5"}
{"signature": "def iter_attribute(iterable_name) -> Union[Iterable, Callable]:", "body": "def create_new_class(decorated_class) -> Union[Iterable, Callable]:<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>assert inspect.isclass(decorated_class), '<STR_LIT>'<EOL>assert isinstance(iterable_name, str), '<STR_LIT>'<EOL>decorated_class.iterator_attr_index = <NUM_LIT:0><EOL>def __iter__(instance) -> Iterable:<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return instance<EOL><DEDENT>def __next__(instance) -> Any:<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>assert hasattr(instance, iterable_name),'<STR_LIT>'.format(iterable_name)<EOL>assert isinstance(getattr(instance, iterable_name), collections.Iterable),'<STR_LIT>'.format(iterable_name, instance.__class__.__name__)<EOL>ind = instance.iterator_attr_index<EOL>while ind < len(getattr(instance, iterable_name)):<EOL><INDENT>val = getattr(instance, iterable_name)[ind]<EOL>instance.iterator_attr_index += <NUM_LIT:1><EOL>return val<EOL><DEDENT>instance.iterator_attr_index = <NUM_LIT:0><EOL>raise StopIteration<EOL><DEDENT>dct = dict(decorated_class.__dict__)<EOL>dct['<STR_LIT>'] = __iter__<EOL>dct['<STR_LIT>'] = __next__<EOL>dct['<STR_LIT>'] = decorated_class.iterator_attr_index<EOL>return type(decorated_class.__name__, (collections.Iterable,), dct)<EOL><DEDENT>return create_new_class<EOL>", "docstring": "Decorator implementing Iterator interface with nicer manner.\n\n    Example\n    -------\n\n    @iter_attribute('my_attr'):\n    class DecoratedClass:\n        ...\n\n    Warning:\n    ========\n\n    When using PyCharm or MYPY you'll probably see issues with decorated class not being recognized as Iterator.\n    That's an issue which I could not overcome yet, it's probably due to the fact that interpretation of object\n    is being done statically rather than dynamically. MYPY checks for definition of methods in class code which\n    changes at runtime. Since __iter__ and __next__ are added dynamically MYPY cannot find those\n    defined in objects before object of a class is created. Possible workarounds for this issue are:\n\n        1. Define ``dummy`` __iter__ class like:\n\n            @iter_attribute('attr')\n            class Test:\n                def __init__(self) -> None:\n                    self.attr = [1, 2, 3]\n\n                def __iter__(self):\n                    pass\n\n        2. After creating object use cast or assert function denoting that particular instance inherits\n            from collections.Iterator:\n\n            assert isinstance(my_object, collections.Iterator)\n\n\n    :param iterable_name: string representing attribute name which has to be iterated\n    :return: DecoratedClass with implemented '__iter__' and '__next__' methods.", "id": "f1885:m0"}
{"signature": "def __init__(self, buffer_or_path):", "body": "self._path = None<EOL>self._path, buffer = to_buffer(buffer_or_path)<EOL>with buffer as f:<EOL><INDENT>self._raw_environments, self._raw_variables_info, self._dfs = parse_eso(f)<EOL><DEDENT>self._start_year = None<EOL>", "docstring": "Parameters\n----------\nbuffer_or_path\n\nInitially, standard_output will have tuple instants (using 'year', 'month', 'day', 'hour', 'minute' columns,\n    depending on given frequency). It is possible to change to datetime mode later.", "id": "f1902:c0:m0"}
{"signature": "def get_data(self, environment_title_or_num=-<NUM_LIT:1>, frequency=None):", "body": "<EOL>if isinstance(environment_title_or_num, int):<EOL><INDENT>environment_title = tuple(self._raw_environments.keys())[environment_title_or_num]<EOL><DEDENT>else:<EOL><INDENT>environment_title = environment_title_or_num<EOL><DEDENT>if environment_title not in self._dfs:<EOL><INDENT>raise ValueError(f\"<STR_LIT>\")<EOL><DEDENT>environment_dfs = self._dfs[environment_title]<EOL>if frequency is None:<EOL><INDENT>for frequency in FREQUENCIES:<EOL><INDENT>if environment_dfs[frequency] is not None:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>if frequency not in FREQUENCIES:<EOL><INDENT>raise ValueError(f\"<STR_LIT>\")<EOL><DEDENT>return self._dfs[environment_title][frequency]<EOL>", "docstring": "Parameters\n----------\nenvironment_title_or_num\nfrequency: 'str', default None\n    'timestep', 'hourly', 'daily', 'monthly', 'annual', 'run_period'\n    If None, will look for the smallest frequency of environment.", "id": "f1902:c0:m3"}
{"signature": "@property<EOL><INDENT>def dir_path(self):<DEDENT>", "body": "return self._dir_path<EOL>", "docstring": "Returns\n-------\nsimulation directory path", "id": "f1904:c1:m7"}
{"signature": "@property<EOL><INDENT>def _file_refs(self):<DEDENT>", "body": "if self._prepared_file_refs is None:<EOL><INDENT>self._prepared_file_refs = {<EOL>FILE_REFS.idf: FileInfo(<EOL>constructor=lambda path: self._epm_cls.from_idf(path, idd_or_buffer_or_path=self._idd),<EOL>get_path=lambda: get_input_file_path(self.dir_path, FILE_REFS.idf)<EOL>),<EOL>FILE_REFS.epw: FileInfo(<EOL>constructor=lambda path: self._weather_data_cls.from_epw(path),<EOL>get_path=lambda: get_input_file_path(self.dir_path, FILE_REFS.epw)<EOL>),<EOL>FILE_REFS.eio: FileInfo(<EOL>constructor=lambda path: self._eio_cls(path),<EOL>get_path=lambda: get_output_file_path(self.dir_path, FILE_REFS.eio)<EOL>),<EOL>FILE_REFS.eso: FileInfo(<EOL>constructor=lambda path: self._standard_output_cls(path),<EOL>get_path=lambda: get_output_file_path(<EOL>self.dir_path,<EOL>FILE_REFS.eso<EOL>)<EOL>),<EOL>FILE_REFS.mtr: FileInfo(<EOL>constructor=lambda path: self._standard_output_cls(path),<EOL>get_path=lambda: get_output_file_path(self.dir_path, FILE_REFS.mtr)<EOL>),<EOL>FILE_REFS.mtd: FileInfo(<EOL>constructor=lambda path: self._mtd_cls(path),<EOL>get_path=lambda: get_output_file_path(self.dir_path, FILE_REFS.mtd)<EOL>),<EOL>FILE_REFS.mdd: FileInfo(<EOL>constructor=lambda path: open(path).read(),<EOL>get_path=lambda: get_output_file_path(self.dir_path, FILE_REFS.mdd)<EOL>),<EOL>FILE_REFS.err: FileInfo(<EOL>constructor=lambda path: self._err_cls(path),<EOL>get_path=lambda: get_output_file_path(self.dir_path, FILE_REFS.err)<EOL>),<EOL>FILE_REFS.summary_table: FileInfo(<EOL>constructor=lambda path: self._summary_table_cls(path),<EOL>get_path=lambda: get_output_file_path(self.dir_path, FILE_REFS.summary_table)<EOL>)<EOL>}<EOL><DEDENT>return self._prepared_file_refs<EOL>", "docstring": "Defined here so that we can use the class variables, in order to subclass in oplusplus", "id": "f1904:c1:m4"}
{"signature": "def get_bounds(self):", "body": "start, end = None, None<EOL>if len(self._weather_series) == <NUM_LIT:0>:<EOL><INDENT>return start, end<EOL><DEDENT>for i in (<NUM_LIT:0>, -<NUM_LIT:1>):<EOL><INDENT>if self.has_tuple_instants:<EOL><INDENT>row = self._weather_series.iloc[i, :]<EOL>instant = dt.datetime(row[\"<STR_LIT>\"], row[\"<STR_LIT>\"], row[\"<STR_LIT>\"], row[\"<STR_LIT>\"], row[\"<STR_LIT>\"])<EOL><DEDENT>else:<EOL><INDENT>instant = self._weather_series.index[i].to_pydatetime()<EOL><DEDENT>if i == <NUM_LIT:0>:<EOL><INDENT>start = instant<EOL><DEDENT>else:<EOL><INDENT>end = instant<EOL><DEDENT><DEDENT>return start, end<EOL>", "docstring": "Returns\n-------\n(start, end)\n\nDatetime instants of beginning and end of data. If no data, will be: (None, None).", "id": "f1910:c0:m8"}
{"signature": "def _check_and_sanitize_datetime_instants(df):", "body": "<EOL>if df is None or len(df) == <NUM_LIT:0>:<EOL><INDENT>return df<EOL><DEDENT>if not isinstance(df.index, pd.DatetimeIndex):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if df.index.freq != \"<STR_LIT:H>\":<EOL><INDENT>forced_df = df.asfreq(\"<STR_LIT:H>\")<EOL>try:<EOL><INDENT>assert_index_equal(df.index, forced_df.index)<EOL><DEDENT>except AssertionError:<EOL><INDENT>raise ValueError(<EOL>f\"<STR_LIT>\"<EOL>f\"<STR_LIT>\"<EOL>) from None<EOL><DEDENT>df = forced_df<EOL><DEDENT>if df.index[<NUM_LIT:0>].minute != <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return df<EOL>", "docstring": "Parameters\n----------\ndf\n\nReturns\n-------\nsanitized df", "id": "f1910:m2"}
{"signature": "def get_data(self, simulation_step=None, error_category=None):", "body": "if simulation_step is None and error_category is None:<EOL><INDENT>return self._df.dropna(axis=\"<STR_LIT>\", how=\"<STR_LIT:all>\")<EOL><DEDENT>if simulation_step is not None:<EOL><INDENT>if simulation_step not in self._simulation_step_list:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\" % simulation_step)<EOL><DEDENT>if error_category is not None:<EOL><INDENT>if error_category not in self.CATEGORIES:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\" % error_category)<EOL><DEDENT>iterables = [simulation_step, error_category]<EOL>columns = pd.MultiIndex.from_product(iterables)<EOL>series = self._df[simulation_step][error_category].dropna(axis=\"<STR_LIT>\", how=\"<STR_LIT:all>\")<EOL>df = pd.DataFrame(index=series.index, columns=columns)<EOL>df[simulation_step] = series<EOL>return df<EOL><DEDENT>return self._df[simulation_step].dropna(axis=\"<STR_LIT>\", how=\"<STR_LIT:all>\")<EOL><DEDENT>if error_category is not None:<EOL><INDENT>if error_category not in self.CATEGORIES:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\" % error_category)<EOL><DEDENT>df = self._df.copy()<EOL>df.columns = df.columns.swaplevel(<NUM_LIT:0>, <NUM_LIT:1>)<EOL>return df[error_category].dropna(axis=\"<STR_LIT>\", how=\"<STR_LIT:all>\")<EOL><DEDENT>", "docstring": "Parameters\n----------\nsimulation_step: if not given, returns a raw report\nerror_category: if only one argument is specified, swaps dataframe report", "id": "f1921:c0:m3"}
{"signature": "def delete(self):", "body": "self.select().delete()<EOL>", "docstring": "Deletes all records of table.", "id": "f1924:c0:m15"}
{"signature": "def __getitem__(self, item):", "body": "if isinstance(item, str):<EOL><INDENT>if self._dev_auto_pk:<EOL><INDENT>raise KeyError(f\"<STR_LIT>\")<EOL><DEDENT>try:<EOL><INDENT>return self._records[item]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise KeyError(f\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if isinstance(item, int):<EOL><INDENT>return self.select()[item]  <EOL><DEDENT>raise KeyError(\"<STR_LIT>\")<EOL>", "docstring": "Parameters\n----------\nitem: str or int\n    if str: value of record name. If table does not have a name field, raises a KeyError\n    if int: record position (records are ordered by their content, not by creation order)\n\nReturns\n-------\nRecord instance", "id": "f1924:c0:m6"}
{"signature": "def get_pointing_records(self):", "body": "return self.get_epm()._dev_relations_manager.get_pointing_on(self)<EOL>", "docstring": "Returns\n-------\nMultiTableQueryset of all records pointed by record.", "id": "f1925:c0:m27"}
{"signature": "def clear_extensible_fields(self):", "body": "if not self.is_extensible():<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>cycle_start, cycle_len, patterns = self.get_extensible_info()<EOL>return [self.get_serialized_value(i) for i in range(cycle_start, len(self))]<EOL>", "docstring": "Returns\n-------\nlist of cleared fields (serialized)", "id": "f1925:c0:m35"}
{"signature": "def __init__(self, table, data=None):", "body": "self._table = table  <EOL>self._data = {}<EOL>self._initialized = True<EOL>if data is not None:<EOL><INDENT>self._update_inert(data)<EOL><DEDENT>", "docstring": "Parameters\n----------\ntable\ndata: dict, default {}\n    key: index_or_ref, value: raw value or value", "id": "f1925:c0:m0"}
{"signature": "def __getattr__(self, item):", "body": "index = self._table._dev_descriptor.get_field_index(item)<EOL>return self[index]<EOL>", "docstring": "Parameters\n----------\nitem: field name", "id": "f1925:c0:m16"}
{"signature": "def get_pk(self):", "body": "return id(self) if self._table._dev_auto_pk else self[<NUM_LIT:0>]<EOL>", "docstring": "Returns\n-------\nIf record has a name, returns its name, else returns record's python id.", "id": "f1925:c0:m24"}
{"signature": "def _update_value_inert(self, index, value):", "body": "<EOL>field_descriptor = self._table._dev_descriptor.get_field_descriptor(index)<EOL>value = field_descriptor.deserialize(value, index)<EOL>if isinstance(value, Link):<EOL><INDENT>current_link = self._data.get(index)<EOL>if current_link is not None:<EOL><INDENT>current_link.unregister()<EOL><DEDENT><DEDENT>if isinstance(value, RecordHook):<EOL><INDENT>current_record_hook = self._data.get(index)<EOL>if current_record_hook is not None:<EOL><INDENT>current_record_hook.unregister()<EOL><DEDENT><DEDENT>if isinstance(value, ExternalFile):<EOL><INDENT>current_external_file = self._data.get(index)<EOL>if current_external_file is not None:<EOL><INDENT>current_external_file._dev_unregister()<EOL><DEDENT><DEDENT>if value in (None, NONE_RECORD_HOOK, NONE_LINK, NONE_EXTERNAL_FILE):<EOL><INDENT>self._dev_set_none_without_unregistering(index, check_not_required=False)<EOL>return<EOL><DEDENT>old_hook = None<EOL>if index == <NUM_LIT:0> and not self._table._dev_auto_pk:<EOL><INDENT>old_hook = self._data.get(<NUM_LIT:0>)  <EOL><DEDENT>self._data[index] = value<EOL>if old_hook is not None:<EOL><INDENT>self._table._dev_record_pk_was_updated(old_hook.target_value)<EOL><DEDENT>", "docstring": "is only called by _update_inert", "id": "f1925:c0:m3"}
{"signature": "def __getitem__(self, item):", "body": "<EOL>item = self._field_key_to_index(item)<EOL>if item > len(self):<EOL><INDENT>raise IndexError(\"<STR_LIT>\")<EOL><DEDENT>value = self._data.get(item)<EOL>if isinstance(value, RecordHook):<EOL><INDENT>return value.target_value<EOL><DEDENT>if isinstance(value, Link):<EOL><INDENT>return value.target_record<EOL><DEDENT>return value<EOL>", "docstring": "Parameters\n----------\nitem: field lowercase name or index\n\nReturns\n-------\nField value", "id": "f1925:c0:m14"}
{"signature": "def parse_idf(file_like):", "body": "tables_data = {}<EOL>head_comment = \"<STR_LIT>\"<EOL>record_data = None<EOL>make_new_record = True<EOL>copyright_list = get_multi_line_copyright_message().split(\"<STR_LIT:\\n>\")<EOL>for i, raw_line in enumerate(file_like):<EOL><INDENT>try:<EOL><INDENT>copyright_line = copyright_list[i]<EOL>if raw_line.strip() == copyright_line:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>except IndexError:<EOL><INDENT>pass<EOL><DEDENT>split_line = raw_line.split(\"<STR_LIT:!>\")<EOL>if len(split_line) == <NUM_LIT:1>:<EOL><INDENT>if len(split_line[<NUM_LIT:0>].strip()) == <NUM_LIT:0>:<EOL><INDENT>content, comment = None, None<EOL><DEDENT>else:<EOL><INDENT>content, comment = split_line[<NUM_LIT:0>].strip(), None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if len(split_line[<NUM_LIT:0>].strip()) == <NUM_LIT:0>:<EOL><INDENT>content, comment = None, \"<STR_LIT:!>\".join(split_line[<NUM_LIT:1>:])<EOL><DEDENT>else:<EOL><INDENT>content, comment = split_line[<NUM_LIT:0>].strip(), \"<STR_LIT:!>\".join(split_line[<NUM_LIT:1>:])<EOL><DEDENT><DEDENT>if (content, comment) == (None, None):<EOL><INDENT>continue<EOL><DEDENT>if not content:<EOL><INDENT>if record_data is None:  <EOL><INDENT>head_comment += comment.strip() + \"<STR_LIT:\\n>\"<EOL><DEDENT>continue<EOL><DEDENT>record_end = content[-<NUM_LIT:1>] == \"<STR_LIT:;>\"<EOL>content = content[:-<NUM_LIT:1>]  <EOL>content_l = [text.strip() for text in content.split(\"<STR_LIT:U+002C>\")]<EOL>if make_new_record:<EOL><INDENT>table_ref = table_name_to_ref(content_l[<NUM_LIT:0>].strip())<EOL>if table_ref.lower() in (<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\"<EOL>):<EOL><INDENT>continue<EOL><DEDENT>if table_ref not in tables_data:<EOL><INDENT>tables_data[table_ref] = []<EOL><DEDENT>record_data = dict()<EOL>tables_data[table_ref].append(record_data)<EOL>content_l = content_l[<NUM_LIT:1>:]<EOL>make_new_record = False<EOL><DEDENT>for value_s in content_l:<EOL><INDENT>field_index = len(record_data)<EOL>record_data[field_index] = value_s<EOL><DEDENT>if record_end:<EOL><INDENT>make_new_record = True<EOL><DEDENT><DEDENT>tables_data[\"<STR_LIT>\"] = head_comment<EOL>return tables_data<EOL>", "docstring": "Records are created from string.\nThey are not attached to idf yet.\nin idf: header comment, chapter comments, records\nin record: head comment, field comments, tail comment", "id": "f1926:m0"}
{"signature": "def to_json(self, buffer_or_path=None, indent=<NUM_LIT:2>):", "body": "<EOL>return json_data_to_json(<EOL>self.to_json_data(),<EOL>buffer_or_path=buffer_or_path,<EOL>indent=indent<EOL>)<EOL>", "docstring": "Parameters\n----------\nbuffer_or_path: buffer or path, default None\n    output to write into. If None, will return a json string.\nindent: int, default 2\n    Defines the indentation of the json\n\nReturns\n-------\nNone, or a json string (if buffer_or_path is None).", "id": "f1929:c0:m19"}
{"signature": "def dump_external_files(self, target_dir_path=None):", "body": "self._dev_external_files_manager.dump_external_files(target_dir_path=target_dir_path)<EOL>", "docstring": "Parameters\n----------\ntarget_dir_path", "id": "f1929:c0:m14"}
{"signature": "def _dev_populate_from_json_data(self, json_data):", "body": "<EOL>comment = json_data.pop(\"<STR_LIT>\", None)<EOL>if comment is not None:<EOL><INDENT>self._comment = comment<EOL><DEDENT>external_files_data = json_data.pop(\"<STR_LIT>\", dict())<EOL>self._dev_external_files_manager.populate_from_json_data(external_files_data)<EOL>added_records = []<EOL>for table_ref, json_data_records in json_data.items():<EOL><INDENT>table = getattr(self, table_ref)<EOL>records = table._dev_add_inert(json_data_records)<EOL>added_records.extend(records)<EOL><DEDENT>for r in added_records:<EOL><INDENT>r._dev_activate_hooks()<EOL><DEDENT>for r in added_records:<EOL><INDENT>r._dev_activate_links()<EOL>r._dev_activate_external_files()<EOL><DEDENT>", "docstring": "!! Must only be called once, when empty !!", "id": "f1929:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def from_json(cls, buffer_or_path, check_required=True, idd_or_buffer_or_path=None):<DEDENT>", "body": "return cls._create_from_buffer_or_path(<EOL>json.load,<EOL>buffer_or_path,<EOL>idd_or_buffer_or_path=idd_or_buffer_or_path,<EOL>check_required=check_required<EOL>)<EOL>", "docstring": "Parameters\n----------\nbuffer_or_path: json buffer or path\ncheck_required: boolean, default True\n    If True, will raise an exception if a required field is missing. If False, not not perform any checks.\nidd_or_buffer_or_path: (expert) to load using a custom idd\n\nReturns\n-------\nAn Epm instance.", "id": "f1929:c0:m17"}
{"signature": "def register_link(self, link):", "body": "keys = tuple((ref, link.initial_hook_value) for ref in link.hook_references)<EOL>for k in keys:<EOL><INDENT>if k in self._record_hooks:<EOL><INDENT>link.set_target(target_record=self._record_hooks[k].target_record)<EOL>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for k in keys:<EOL><INDENT>if k in self._table_hooks:<EOL><INDENT>link.set_target(target_table=self._table_hooks[k])<EOL>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>field_descriptor = link.source_record.get_field_descriptor(link.source_index)<EOL>raise FieldValidationError(<EOL>f\"<STR_LIT>\"<EOL>f\"<STR_LIT>\"<EOL>)<EOL><DEDENT><DEDENT>if link.source_record not in self._links_by_source:<EOL><INDENT>self._links_by_source[link.source_record] = set()<EOL><DEDENT>self._links_by_source[link.source_record].add(link)<EOL>if link.target not in self._links_by_target:<EOL><INDENT>self._links_by_target[link.target] = set()<EOL><DEDENT>self._links_by_target[link.target].add(link)<EOL>", "docstring": "source record and index must have been set", "id": "f1930:c0:m3"}
{"signature": "@property<EOL><INDENT>def detailed_type(self):<DEDENT>", "body": "if self._detailed_type is None:<EOL><INDENT>if (\"<STR_LIT>\" in self.tags) or (\"<STR_LIT>\" in self.tags):<EOL><INDENT>self._detailed_type = \"<STR_LIT>\"<EOL><DEDENT>elif \"<STR_LIT:type>\" in self.tags:<EOL><INDENT>self._detailed_type = self.tags[\"<STR_LIT:type>\"][<NUM_LIT:0>].lower()  <EOL><DEDENT>elif \"<STR_LIT:key>\" in self.tags:<EOL><INDENT>self._detailed_type = \"<STR_LIT>\"<EOL><DEDENT>elif \"<STR_LIT>\" in self.tags:<EOL><INDENT>self._detailed_type = \"<STR_LIT>\"<EOL><DEDENT>elif \"<STR_LIT>\" in self.tags:<EOL><INDENT>self._detailed_type = \"<STR_LIT>\"<EOL><DEDENT>elif self.basic_type == \"<STR_LIT:A>\":<EOL><INDENT>self._detailed_type = \"<STR_LIT>\"<EOL><DEDENT>elif self.basic_type == \"<STR_LIT:N>\":<EOL><INDENT>self._detailed_type = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>return self._detailed_type<EOL>", "docstring": "Uses EPlus double approach of type ('type' tag, and/or 'key', 'object-list', 'external-list', 'reference' tags)\nto determine detailed type.\n\nReturns\n-------\n\"integer\", \"real\", \"alpha\", \"choice\", \"reference\", \"object-list\", \"external-list\", \"node\"", "id": "f1931:c0:m7"}
{"signature": "def select(self, filter_by=None):", "body": "iterator = self._records if filter_by is None else filter(filter_by, self._records)<EOL>return Queryset(self._table, iterator)<EOL>", "docstring": "Parameters\n----------\nfilter_by: callable, default None\n    Callable must take one argument (a record of queryset), and return True to keep record, or False to skip it.\n    Example : .select(lambda x: x.name == \"my_name\").\n    If None, records are not filtered.\n\nReturns\n-------\nQueryset instance, containing all selected records.", "id": "f1935:c0:m9"}
{"signature": "def one(self, filter_by=None):", "body": "<EOL>qs = self if filter_by is None else self.select(filter_by=filter_by)<EOL>if len(qs) == <NUM_LIT:0>:<EOL><INDENT>raise RecordDoesNotExistError(\"<STR_LIT>\")<EOL><DEDENT>if len(qs) > <NUM_LIT:1>:<EOL><INDENT>raise MultipleRecordsReturnedError(\"<STR_LIT>\")<EOL><DEDENT>return qs[<NUM_LIT:0>]<EOL>", "docstring": "Parameters\n----------\nfilter_by: callable, default None\n    Callable must take one argument (a record of table), and return True to keep record, or False to skip it.\n    Example : .one(lambda x: x.name == \"my_name\").\n    If None, records are not filtered.\n\nReturns\n-------\nRecord instance if one and only one record is found. Else raises.\n\nRaises\n------\nRecordDoesNotExistError if no record is found\nMultipleRecordsReturnedError if multiple records are found", "id": "f1935:c0:m10"}
{"signature": "def delete(self):", "body": "<EOL>for r in self:<EOL><INDENT>r.delete()<EOL><DEDENT>self._records = ()<EOL>", "docstring": "Deletes all records of queryset.", "id": "f1935:c0:m11"}
{"signature": "def __init__(self, references, index, value):", "body": "self.references = references<EOL>self.target_index = index<EOL>self.target_value = value<EOL>self.target_record = None<EOL>", "docstring": "target_value must always be relevant : !! don't forget to deactivate hook if field of record changes !!", "id": "f1936:c0:m0"}
{"signature": "def __init__(self, category):", "body": "self.category = category<EOL>self.text = \"<STR_LIT>\"<EOL>", "docstring": "Parameters\n----------\ncategory: str,\n    code, markdown", "id": "f1953:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def load_from_file_like(cls, flo, format=None):<DEDENT>", "body": "format = self.format if format is None else format<EOL>load = getattr(cls, \"<STR_LIT>\" % format, None)<EOL>if load is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % format)<EOL><DEDENT>return load(flo)<EOL>", "docstring": "Load the object to a given file like object with the given\n            protocol.", "id": "f1957:c0:m1"}
{"signature": "def windows(iterable, length=<NUM_LIT:2>, overlap=<NUM_LIT:0>, padding=True):", "body": "it = iter(iterable)<EOL>results = list(itertools.islice(it, length))<EOL>while len(results) == length:<EOL><INDENT>yield results<EOL>results = results[length-overlap:]<EOL>results.extend(itertools.islice(it, length-overlap))<EOL><DEDENT>if padding and results:<EOL><INDENT>results.extend(itertools.repeat(None, length-len(results)))<EOL>yield results<EOL><DEDENT>", "docstring": "Code snippet from Python Cookbook, 2nd Edition by David Ascher,\n    Alex Martelli and Anna Ravenscroft; O'Reilly 2005\n\n    Problem: You have an iterable s and need to make another iterable whose\n    items are sublists (i.e., sliding windows), each of the same given length,\n    over s' items, with successive windows overlapping by a specified amount.", "id": "f1958:m2"}
{"signature": "def _vp_default(self):", "body": "vp = Viewport(component=self.component)<EOL>vp.enable_zoom=True<EOL>vp.view_position = [-<NUM_LIT:5>, -<NUM_LIT:5>]<EOL>vp.tools.append(ViewportPanTool(vp))<EOL>return vp<EOL>", "docstring": "Trait initialiser.", "id": "f1959:c0:m9"}
{"signature": "def _default_edge_default(self):", "body": "return Edge(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>", "docstring": "Trait initialiser.", "id": "f1959:c0:m5"}
{"signature": "def create(self, prog=None, format=None):", "body": "prog = self.program if prog is None else prog<EOL>format = self.format if format is None else format<EOL>tmp_fd, tmp_name = tempfile.mkstemp()<EOL>os.close( tmp_fd )<EOL>dot_fd = file( tmp_name, \"<STR_LIT>\" )<EOL>self.save_dot( dot_fd )<EOL>dot_fd.close()<EOL>tmp_dir = os.path.dirname( tmp_name )<EOL>p = subprocess.Popen(<EOL>( self.programs[ prog ], '<STR_LIT>'+format, tmp_name ),<EOL>cwd=tmp_dir,<EOL>stderr=subprocess.PIPE, stdout=subprocess.PIPE)<EOL>stderr = p.stderr<EOL>stdout = p.stdout<EOL>stdout_output = list()<EOL>while True:<EOL><INDENT>data = stdout.read()<EOL>if not data:<EOL><INDENT>break<EOL><DEDENT>stdout_output.append(data)<EOL><DEDENT>stdout.close()<EOL>if stdout_output:<EOL><INDENT>stdout_output = '<STR_LIT>'.join(stdout_output)<EOL><DEDENT>if not stderr.closed:<EOL><INDENT>stderr_output = list()<EOL>while True:<EOL><INDENT>data = stderr.read()<EOL>if not data:<EOL><INDENT>break<EOL><DEDENT>stderr_output.append(data)<EOL><DEDENT>stderr.close()<EOL>if stderr_output:<EOL><INDENT>stderr_output = '<STR_LIT>'.join(stderr_output)<EOL><DEDENT><DEDENT>status = p.wait()<EOL>if status != <NUM_LIT:0> :<EOL><INDENT>logger.error(\"<STR_LIT>\"\"<STR_LIT>\" % ( status, stderr_output ) )<EOL><DEDENT>elif stderr_output:<EOL><INDENT>logger.error( \"<STR_LIT:%s>\", stderr_output )<EOL><DEDENT>os.unlink(tmp_name)<EOL>return stdout_output<EOL>", "docstring": "Creates and returns a representation of the graph using the\n            Graphviz layout program given by 'prog', according to the given\n            format.\n\n            Writes the graph to a temporary dot file and processes it with\n            the program given by 'prog' (which defaults to 'dot'), reading\n            the output and returning it as a string if the operation is\n            successful. On failure None is returned.", "id": "f1959:c0:m15"}
{"signature": "def __iter__(self):", "body": "for each in self.nodes:<EOL><INDENT>yield each<EOL><DEDENT>", "docstring": "Return a iterator passing through all nodes in the graph.\n\n            @rtype:  iterator\n            @return: Iterator passing through all nodes in the graph.", "id": "f1959:c0:m1"}
{"signature": "def _component_default(self):", "body": "return Container(draw_axes=True, fit_window=False, auto_size=True)<EOL>", "docstring": "Trait initialiser.", "id": "f1959:c0:m8"}
{"signature": "def save_as(self):", "body": "pass<EOL>", "docstring": "Saves the editor content to a new file name.", "id": "f1962:c0:m5"}
{"signature": "def _action_sets_default(self):", "body": "from action import GodotWorkbenchActionSet<EOL>return [GodotWorkbenchActionSet]<EOL>", "docstring": "Trait initialiser.", "id": "f1963:c0:m2"}
{"signature": "def _editor_input_default(self):", "body": "return self.obj<EOL>", "docstring": "Trait initialiser.", "id": "f1965:c0:m2"}
{"signature": "def _name_default(self):", "body": "<EOL>self.obj.on_trait_change(self.on_path, \"<STR_LIT:path>\")<EOL>return basename(self.obj.path)<EOL>", "docstring": "Trait initialiser.", "id": "f1965:c0:m0"}
{"signature": "def normal_left_down(self, event):", "body": "print(\"<STR_LIT>\" % (event.x, event.y))<EOL>", "docstring": "Handles left mouse button clicks in 'normal' mode", "id": "f1968:c0:m3"}
{"signature": "def _draw_mainlayer(self, gc, view_bounds=None, mode=\"<STR_LIT:default>\"):", "body": "x_origin = self.x_origin<EOL>y_origin = self.y_origin<EOL>gc.save_state()<EOL>try:<EOL><INDENT>self._draw_bounds(gc)<EOL>", "docstring": "Draws the component", "id": "f1968:c0:m0"}
{"signature": "def is_in(self, point_x, point_y):", "body": "x = self.x_origin<EOL>y = self.y_origin<EOL>a = self.e_width<EOL>b = self.e_height<EOL>return ((point_x-x)**<NUM_LIT:2>/(a**<NUM_LIT:2>)) + ((point_y-y)**<NUM_LIT:2>/(b**<NUM_LIT:2>)) < <NUM_LIT:1.0><EOL>", "docstring": "Test if the point is within this ellipse", "id": "f1968:c0:m1"}
{"signature": "def _anytrait_changed_for_component(self, new):", "body": "self.canvas.request_redraw()<EOL>", "docstring": "Handles redrawing of the canvas.", "id": "f1972:c0:m3"}
{"signature": "def cbrt(x):", "body": "if x >= <NUM_LIT:0>:<EOL><INDENT>return pow(x, <NUM_LIT:1.0>/<NUM_LIT>)<EOL><DEDENT>else:<EOL><INDENT>return -pow(abs(x), <NUM_LIT:1.0>/<NUM_LIT>)<EOL><DEDENT>", "docstring": "cbrt(x) = x^{1/3},  if x &gt;= 0\n                = -|x|^{1/3},  if x &lt; 0", "id": "f1975:m0"}
{"signature": "def cubic(a, b, c, d=None):", "body": "if d: <EOL><INDENT>a, b, c = b / float(a), c / float(a), d / float(a)<EOL><DEDENT>t = a / <NUM_LIT><EOL>p, q = b - <NUM_LIT:3> * t**<NUM_LIT:2>, c - b * t + <NUM_LIT:2> * t**<NUM_LIT:3><EOL>u, v = quadratic(q, -(p/<NUM_LIT>)**<NUM_LIT:3>)<EOL>if type(u) == type(<NUM_LIT>): <EOL><INDENT>r, w = polar(u.real, u.imag)<EOL>y1 = <NUM_LIT:2> * cbrt(r) * cos(w / <NUM_LIT>)<EOL><DEDENT>else: <EOL><INDENT>y1 = cbrt(u) + cbrt(v)<EOL><DEDENT>y2, y3 = quadratic(y1, p + y1**<NUM_LIT:2>)<EOL>return y1 - t, y2 - t, y3 - t<EOL>", "docstring": "x^3 + ax^2 + bx + c = 0  (or ax^3 + bx^2 + cx + d = 0)\n    With substitution x = y-t and t = a/3, the cubic equation reduces to\n        y^3 + py + q = 0,\n    where p = b-3t^2 and q = c-bt+2t^3.  Then, one real root y1 = u+v can\n    be determined by solving\n        w^2 + qw - (p/3)^3 = 0\n    where w = u^3, v^3.  From Vieta's theorem,\n        y1 + y2 + y3 = 0\n        y1 y2 + y1 y3 + y2 y3 = p\n        y1 y2 y3 = -q,\n    the other two (real or complex) roots can be obtained by solving\n        y^2 + (y1)y + (p+y1^2) = 0", "id": "f1975:m3"}
{"signature": "def polar(x, y, deg=<NUM_LIT:0>):        ", "body": "if deg:<EOL><INDENT>return hypot(x, y), <NUM_LIT> * atan2(y, x) / pi<EOL><DEDENT>else:<EOL><INDENT>return hypot(x, y), atan2(y, x)<EOL><DEDENT>", "docstring": "Convert from rectangular (x,y) to polar (r,w)\n        r = sqrt(x^2 + y^2)\n        w = arctan(y/x) = [-\\pi,\\pi] = [-180,180]", "id": "f1975:m1"}
{"signature": "def _parse_xdot_directive(self, name, new):", "body": "parser = XdotAttrParser()<EOL>components = parser.parse_xdot_data(new)<EOL>x1 = min( [c.x for c in components] )<EOL>y1 = min( [c.y for c in components] )<EOL>print(\"<STR_LIT>\", name, x1, y1)<EOL><INDENT>move_to_origin( components )<EOL><DEDENT>for c in components:<EOL><INDENT>if isinstance(c, Ellipse):<EOL><INDENT>component.x_origin -= x1<EOL>component.y_origin -= y1<EOL><INDENT>c.position = [ c.x - x1, c.y - y1 ]<EOL><DEDENT><DEDENT>elif isinstance(c, (Polygon, BSpline)):<EOL><INDENT>print(\"<STR_LIT>\", c.points)<EOL>c.points = [ (t[<NUM_LIT:0>] - x1, t[<NUM_LIT:1>] - y1) for t in c.points ]<EOL>print(\"<STR_LIT>\", c.points)<EOL><DEDENT>elif isinstance(c, Text):<EOL><INDENT>font = str_to_font( str(c.pen.font) )<EOL>", "docstring": "Handles parsing Xdot drawing directives.", "id": "f1976:c0:m6"}
{"signature": "def __str__(self):", "body": "attrs = []<EOL>for trait_name, trait in self.traits(graphviz=True).items():<EOL><INDENT>value = getattr(self, trait_name)<EOL>if (value != trait.default) and (trait.default is not None):<EOL><INDENT>if isinstance( value, str ):<EOL><INDENT>valstr = '<STR_LIT>' % value<EOL><DEDENT>else:<EOL><INDENT>valstr = str( value )<EOL><DEDENT>attrs.append('<STR_LIT>' % (trait_name, valstr))<EOL><DEDENT><DEDENT>if attrs:<EOL><INDENT>attrstr = \"<STR_LIT>\" % \"<STR_LIT:U+002CU+0020>\".join(attrs)<EOL><DEDENT>else:<EOL><INDENT>attrstr = \"<STR_LIT>\"<EOL><DEDENT>edge_str = \"<STR_LIT>\" % ( self.tail_node.ID, self.tailport,<EOL>self.conn,<EOL>self.head_node.ID, self.headport,<EOL>attrstr )<EOL>return edge_str<EOL>", "docstring": "Returns a string representation of the edge.", "id": "f1976:c0:m1"}
{"signature": "@on_trait_change(\"<STR_LIT>\")<EOL><INDENT>def arrange_all(self):<DEDENT>", "body": "<EOL>import godot.dot_data_parser<EOL>import godot.graph<EOL>graph = godot.graph.Graph( ID=\"<STR_LIT:g>\", directed=True )<EOL>self.conn = \"<STR_LIT>\"<EOL>graph.edges.append( self )<EOL>xdot_data = graph.create( format=\"<STR_LIT>\" )<EOL><INDENT>print \"<STR_LIT>\", xdot_data<EOL><DEDENT>parser = godot.dot_data_parser.GodotDataParser()<EOL>ndata = xdot_data.replace('<STR_LIT>','<STR_LIT>')<EOL>tokens = parser.dotparser.parseString(ndata)[<NUM_LIT:0>]<EOL>for element in tokens[<NUM_LIT:3>]:<EOL><INDENT>cmd = element[<NUM_LIT:0>]<EOL>if cmd == \"<STR_LIT>\":<EOL><INDENT>cmd, src, dest, opts = element<EOL>self.set( **opts )<EOL><DEDENT><DEDENT>", "docstring": "Arrange the components of the node using Graphviz.", "id": "f1976:c0:m5"}
{"signature": "def _vp_default(self):", "body": "vp = Viewport( component=self.component )<EOL>vp.enable_zoom=True<EOL>vp.tools.append( ViewportPanTool(vp) )<EOL>return vp<EOL>", "docstring": "Trait initialiser.", "id": "f1976:c0:m3"}
{"signature": "def setUp(self):", "body": "node1 = DomainNode(name=\"<STR_LIT>\")<EOL>node2 = DomainNode(name=\"<STR_LIT>\")<EOL>edge1 = DomainEdge(source=node1, target=node2)<EOL>model = DomainModel(nodes=[node1, node2], edges=[edge1])<EOL>self.view_model = DomainViewModel(model=model)<EOL>", "docstring": "Prepares the test fixture before each test method is called.", "id": "f1978:c6:m0"}
{"signature": "def setUp(self):", "body": "self.mapping = Mapping(<EOL>nodes=[<EOL>NodeMapping(<EOL>containment_trait=\"<STR_LIT>\", element=DomainNode,<EOL>dot_node=DotGraphNode(shape=NODE_SHAPE),<EOL>tools=[MoveTool, ElementTool]<EOL>),<EOL>NodeMapping(<EOL>containment_trait=\"<STR_LIT>\", element=OtherNode,<EOL>dot_node=DotGraphNode(shape=OTHER_NODE_SHAPE),<EOL>tools=[MoveTool, ElementTool]<EOL>)<EOL>]<EOL>)<EOL>node1 = DomainNode(name=\"<STR_LIT>\")<EOL>node2 = DomainNode(name=\"<STR_LIT>\")<EOL>self.model = DomainModel(<EOL>nodes=[node1, node2],<EOL>edges=[DomainEdge(source=node1, target=node2)]<EOL>)<EOL>return<EOL>", "docstring": "Prepares the test fixture before each test method is called.", "id": "f1981:c5:m0"}
{"signature": "def build_graph(self, graph, tokens):", "body": "subgraph = None<EOL>for element in tokens:<EOL><INDENT>cmd = element[<NUM_LIT:0>]<EOL>if cmd == ADD_NODE:<EOL><INDENT>cmd, nodename, opts = element<EOL>graph.add_node(nodename, **opts)<EOL><DEDENT>elif cmd == ADD_EDGE:<EOL><INDENT>cmd, src, dest, opts = element<EOL>srcport = destport = \"<STR_LIT>\"<EOL>if isinstance(src,tuple):<EOL><INDENT>srcport = src[<NUM_LIT:1>]<EOL>src = src[<NUM_LIT:0>]<EOL><DEDENT>if isinstance(dest,tuple):<EOL><INDENT>destport = dest[<NUM_LIT:1>]<EOL>dest = dest[<NUM_LIT:0>]<EOL><DEDENT>graph.add_edge(src, dest, tailport=srcport, headport=destport,<EOL>**opts)<EOL><DEDENT>elif cmd in [ADD_GRAPH_TO_NODE_EDGE,<EOL>ADD_GRAPH_TO_GRAPH_EDGE,<EOL>ADD_NODE_TO_GRAPH_EDGE]:<EOL><INDENT>cmd, src, dest, opts = element<EOL>srcport = destport = \"<STR_LIT>\"<EOL>if isinstance(src,tuple):<EOL><INDENT>srcport = src[<NUM_LIT:1>]<EOL><DEDENT>if isinstance(dest,tuple):<EOL><INDENT>destport = dest[<NUM_LIT:1>]<EOL><DEDENT>if not (cmd == ADD_NODE_TO_GRAPH_EDGE):<EOL><INDENT>if cmd == ADD_GRAPH_TO_NODE_EDGE:<EOL><INDENT>src = subgraph<EOL><DEDENT>else:<EOL><INDENT>src = prev_subgraph<EOL>dest = subgraph<EOL><DEDENT><DEDENT>else:<EOL><INDENT>dest = subgraph<EOL><DEDENT>src_is_graph = isinstance(src, (Subgraph, Cluster))<EOL>dst_is_graph = isinstance(dst, (Subgraph, Cluster))<EOL>if src_is_graph:<EOL><INDENT>src_nodes = src.nodes<EOL><DEDENT>else:<EOL><INDENT>src_nodes = [src]<EOL><DEDENT>if dst_is_graph:<EOL><INDENT>dst_nodes = dst.nodes<EOL><DEDENT>else:<EOL><INDENT>dst_nodes = [dst]<EOL><DEDENT>for src_node in src_nodes:<EOL><INDENT>for dst_node in dst_nodes:<EOL><INDENT>graph.add_edge(from_node=src_node, to_node=dst_node,<EOL>tailport=srcport, headport=destport,<EOL>**kwds)<EOL><DEDENT><DEDENT><DEDENT>elif cmd == SET_GRAPH_ATTR:<EOL><INDENT>graph.set( **element[<NUM_LIT:1>] )<EOL><DEDENT>elif cmd == SET_DEF_NODE_ATTR:<EOL><INDENT>graph.default_node.set( **element[<NUM_LIT:1>] )<EOL><DEDENT>elif cmd == SET_DEF_EDGE_ATTR:<EOL><INDENT>graph.default_edge.set( **element[<NUM_LIT:1>] )<EOL><DEDENT>elif cmd == SET_DEF_GRAPH_ATTR:<EOL><INDENT>graph.default_graph.set( **element[<NUM_LIT:1>] )<EOL><DEDENT>elif cmd == ADD_SUBGRAPH:<EOL><INDENT>cmd, name, elements = element<EOL>if subgraph:<EOL><INDENT>prev_subgraph = subgraph<EOL><DEDENT>if name.startswith(\"<STR_LIT>\"):<EOL><INDENT>cluster = Cluster(ID=name)<EOL>cluster = self.build_graph(cluster, elements)<EOL>graph.add_cluster(cluster)<EOL><DEDENT>else:<EOL><INDENT>subgraph = Subgraph(ID=name)<EOL>subgraph = self.build_graph(subgraph, elements)<EOL>graph.add_subgraph(subgraph)<EOL><DEDENT><DEDENT><DEDENT>return graph<EOL>", "docstring": "Builds a Godot graph.", "id": "f1983:c0:m4"}
{"signature": "def save_as(self, info):", "body": "if not info.initialized:<EOL><INDENT>return<EOL>", "docstring": "Handles saving the current model to file.", "id": "f1988:c0:m6"}
{"signature": "def configure_edges(self, info):", "body": "if info.initialized:<EOL><INDENT>self.model.edit_traits(parent=info.ui.control,<EOL>kind=\"<STR_LIT>\", view=edges_view)<EOL><DEDENT>", "docstring": "Handles display of the edges editor.", "id": "f1988:c0:m9"}
{"signature": "def save(self, info):", "body": "save_file = self.save_file<EOL>if not isfile(save_file):<EOL><INDENT>self.save_as(info)<EOL><DEDENT>else:<EOL><INDENT>fd = None<EOL>try:<EOL><INDENT>fd = open(save_file, \"<STR_LIT:wb>\")<EOL>dot_code = str(self.model)<EOL>fd.write(dot_code)<EOL><DEDENT>finally:<EOL><INDENT>if fd is not None:<EOL><INDENT>fd.close()<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Handles saving the current model to the last file.", "id": "f1988:c0:m5"}
{"signature": "def on_exit(self, info):", "body": "if self.prompt_on_exit:<EOL><INDENT>retval = confirm(parent  = info.ui.control,<EOL>message = \"<STR_LIT>\",<EOL>title   = \"<STR_LIT>\",<EOL>default = YES)<EOL>if retval == YES:<EOL><INDENT>self._on_close( info )<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self._on_close( info )<EOL><DEDENT>", "docstring": "Handles the user attempting to exit Godot.", "id": "f1988:c0:m19"}
{"signature": "def add_subgraph(self, info):", "body": "if not info.initialized:<EOL><INDENT>return<EOL><DEDENT>graph = self._request_graph(info.ui.control)<EOL>if graph is not None:<EOL><INDENT>subgraph = Subgraph()<EOL>retval = subgraph.edit_traits(parent = info.ui.control,<EOL>kind   = \"<STR_LIT>\")<EOL>if retval.result:<EOL><INDENT>graph.subgraphs.append(subgraph)<EOL><DEDENT><DEDENT>", "docstring": "Handles adding a Subgraph to the main graph.", "id": "f1988:c0:m13"}
{"signature": "def _edges_replaced(self, object, name, old, new):", "body": "self._delete_edges(old)<EOL>self._add_edges(new)<EOL>", "docstring": "Handles a list of edges being set.", "id": "f1989:c3:m9"}
{"signature": "def _delete_nodes(self, features):", "body": "graph = self._graph<EOL>if graph is not None:<EOL><INDENT>for feature in features:<EOL><INDENT>graph.delete_node( id(feature) )<EOL><DEDENT><DEDENT>graph.arrange_all()<EOL>", "docstring": "Removes the node corresponding to each item in 'features'.", "id": "f1989:c3:m8"}
{"signature": "def get_label ( self, object ):", "body": "label = self.label<EOL>if label[:<NUM_LIT:1>] == '<STR_LIT:=>':<EOL><INDENT>return label[<NUM_LIT:1>:]<EOL><DEDENT>label = xgetattr( object, label, '<STR_LIT>' )<EOL>if self.formatter is None:<EOL><INDENT>return label<EOL><DEDENT>return self.formatter( object, label )<EOL>", "docstring": "Gets the label to display for a specified object.", "id": "f1989:c1:m0"}
{"signature": "def _nodes_replaced(self, object, name, old, new):", "body": "self._delete_nodes(old)<EOL>self._add_nodes(new)<EOL>", "docstring": "Handles a list of nodes being set.", "id": "f1989:c3:m5"}
{"signature": "def _edges_changed(self, object, name, undefined, event):", "body": "self._delete_edges(event.removed)<EOL>self._add_edges(event.added)<EOL>", "docstring": "Handles addition and removal of edges.", "id": "f1989:c3:m10"}
{"signature": "def delete_child ( self, object, index ):", "body": "if isinstance( child, Subgraph ):<EOL><INDENT>object.subgraphs.pop(index)<EOL><DEDENT>elif isinstance( child, Cluster ):<EOL><INDENT>object.clusters.pop( index )<EOL><DEDENT>elif isinstance( child, Node ):<EOL><INDENT>object.nodes.pop( index )<EOL><DEDENT>elif isinstance( child, Edge ):<EOL><INDENT>object.edges.pop( index )<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Deletes a child at a specified index from the object's children.", "id": "f1991:c0:m4"}
{"signature": "def allows_children ( self, object ):", "body": "return True<EOL>", "docstring": "Returns whether this object can have children.", "id": "f1991:c0:m0"}
{"signature": "def get_node(self, ID):", "body": "node = super(Graph, self).get_node(ID)<EOL>if node is not None:<EOL><INDENT>return node<EOL><DEDENT>for graph in self.all_graphs:<EOL><INDENT>for each_node in graph.nodes:<EOL><INDENT>if each_node.ID == ID:<EOL><INDENT>return each_node<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Returns a node given an ID or None if no such node exists.", "id": "f1992:c0:m4"}
{"signature": "def _maxiter_default(self):", "body": "mode = self.mode<EOL>if mode == \"<STR_LIT>\":<EOL><INDENT>return <NUM_LIT:100> * len(self.nodes)<EOL><DEDENT>elif mode == \"<STR_LIT>\":<EOL><INDENT>return <NUM_LIT:200><EOL><DEDENT>else:<EOL><INDENT>return <NUM_LIT><EOL><DEDENT>", "docstring": "Trait initialiser.", "id": "f1992:c0:m7"}
{"signature": "@on_trait_change(\"<STR_LIT>\")<EOL><INDENT>def redraw_canvas(self):<DEDENT>", "body": "from xdot_parser import XdotAttrParser<EOL>xdot_parser = XdotAttrParser()<EOL>canvas = self._component_default()<EOL>for node in self.nodes:<EOL><INDENT>components = xdot_parser.parse_xdot_data( node._draw_ )<EOL>canvas.add( *components )<EOL>components = xdot_parser.parse_xdot_data( node._ldraw_ )<EOL>canvas.add( *components )<EOL><DEDENT>for edge in self.edges:<EOL><INDENT>components = xdot_parser.parse_xdot_data( edge._draw_ )<EOL>canvas.add( *components )<EOL>components = xdot_parser.parse_xdot_data( edge._ldraw_ )<EOL>canvas.add( *components )<EOL>components = xdot_parser.parse_xdot_data( edge._hdraw_ )<EOL>canvas.add( *components )<EOL>components = xdot_parser.parse_xdot_data( edge._tdraw_ )<EOL>canvas.add( *components )<EOL>components = xdot_parser.parse_xdot_data( edge._hldraw_ )<EOL>canvas.add( *components )<EOL>components = xdot_parser.parse_xdot_data( edge._tldraw_ )<EOL>canvas.add( *components )<EOL><DEDENT>self.component = canvas<EOL>self.vp.request_redraw()<EOL>", "docstring": "Parses the Xdot attributes of all graph components and adds\n            the components to a new canvas.", "id": "f1992:c0:m3"}
{"signature": "def _on_edges(self, object, name, old, new):", "body": "if name == \"<STR_LIT>\":<EOL><INDENT>edges = new.added<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>edges = new<EOL><DEDENT>else:<EOL><INDENT>edges = []<EOL><DEDENT>all_nodes = [n for g in self.all_graphs for n in g.nodes]<EOL>for each_edge in edges:<EOL><INDENT>if each_edge.tail_node not in all_nodes:<EOL><INDENT>object.nodes.append( each_edge.tail_node )<EOL><DEDENT>if each_edge.head_node not in all_nodes:<EOL><INDENT>object.nodes.append( each_edge.head_node )<EOL><DEDENT>each_edge._nodes = all_nodes<EOL><DEDENT>", "docstring": "Handles the list of edges for any graph changing.", "id": "f1992:c0:m11"}
{"signature": "def _directed_changed(self, new):", "body": "if new:<EOL><INDENT>conn = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>conn = \"<STR_LIT>\"<EOL><DEDENT>for edge in [e for g in self.all_graphs for e in g.edges]:<EOL><INDENT>edge.conn = conn<EOL><DEDENT>", "docstring": "Sets the connection string for all edges.", "id": "f1992:c0:m9"}
{"signature": "def proc_filled_ellipse(self, tokens):", "body": "return self._proc_ellipse(tokens, filled=True)<EOL>", "docstring": "Returns the components of a filled ellipse.", "id": "f1994:c0:m8"}
{"signature": "def _proc_color(self, tokens):", "body": "keys = list(tokens.keys())<EOL>if \"<STR_LIT>\" in keys: <EOL><INDENT>rr, gg, bb = tokens[\"<STR_LIT>\"], tokens[\"<STR_LIT>\"], tokens[\"<STR_LIT>\"]<EOL>hex2int = lambda h: int(h, <NUM_LIT:16>)<EOL>if \"<STR_LIT>\" in keys:<EOL><INDENT>a = tokens[\"<STR_LIT>\"]<EOL>c = str((hex2int(rr), hex2int(gg), hex2int(bb), hex2int(a)))<EOL><DEDENT>else:<EOL><INDENT>c = str((hex2int(rr), hex2int(gg), hex2int(bb)))<EOL><DEDENT><DEDENT>elif \"<STR_LIT>\" in keys: <EOL><INDENT>r, g, b = hsv_to_rgb(tokens[\"<STR_LIT>\"],<EOL>tokens[\"<STR_LIT>\"],<EOL>tokens[\"<STR_LIT:value>\"])<EOL>c = str((int(r*<NUM_LIT:255>), int(g*<NUM_LIT:255>), int(b*<NUM_LIT:255>)))<EOL><DEDENT>else:<EOL><INDENT>c = tokens[\"<STR_LIT>\"]<EOL><DEDENT>return c<EOL>", "docstring": "The color traits of a Pen instance must be a string of the form\n        (r,g,b) or (r,g,b,a) where r, g, b, and a are integers from 0 to 255,\n        a wx.Colour instance, an integer which in hex is of the form 0xRRGGBB,\n        where RR is red, GG is green, and BB is blue or a valid color name.", "id": "f1994:c0:m5"}
{"signature": "def proc_stroke_color(self, tokens):", "body": "self.pen.color = self._proc_color(tokens)<EOL>return []<EOL>", "docstring": "Sets the pen stroke color.", "id": "f1994:c0:m4"}
{"signature": "def parse_xdot_data(self, data):", "body": "parser = self.parser<EOL><INDENT>if pyparsing_version >= \"<STR_LIT>\":<EOL><INDENT>parser.parseWithTabs()<EOL><DEDENT><DEDENT>if data:<EOL><INDENT>return parser.parseString(data)<EOL><DEDENT>else:<EOL><INDENT>return []<EOL><DEDENT>", "docstring": "Parses xdot data and returns the associated components.", "id": "f1994:c0:m1"}
{"signature": "def proc_unfilled_polygon(self, tokens):", "body": "return self._proc_polygon(tokens, filled=False)<EOL>", "docstring": "Returns the components of an unfilled polygon.", "id": "f1994:c0:m12"}
{"signature": "def __str__(self):", "body": "attrs = []<EOL>for trait_name, trait in self.traits(graphviz=True).items():<EOL><INDENT>value = getattr(self, trait_name)<EOL>if value != trait.default:<EOL><INDENT>trait = self.trait( trait_name )<EOL>if trait.is_trait_type( Tuple ):<EOL><INDENT>valstr  = '<STR_LIT>' % \"<STR_LIT:U+002C>\".join( [str(d) for d in value] )<EOL><DEDENT>elif isinstance( value, str ):<EOL><INDENT>valstr = '<STR_LIT>' % value<EOL><DEDENT>else:<EOL><INDENT>valstr = str( value )<EOL><DEDENT>attrs.append('<STR_LIT>' % (trait_name, valstr))<EOL><DEDENT><DEDENT>if attrs:<EOL><INDENT>attrstr = \"<STR_LIT>\" % \"<STR_LIT:U+002CU+0020>\".join(attrs)<EOL>return \"<STR_LIT>\" % (self.ID, attrstr)<EOL><DEDENT>else:<EOL><INDENT>return \"<STR_LIT:%s>\" % self.ID<EOL><DEDENT>", "docstring": "Returns a string representation of the node.", "id": "f1995:c0:m1"}
{"signature": "def parse_xdot_drawing_directive(self, new):", "body": "components = XdotAttrParser().parse_xdot_data(new)<EOL>max_x = max( [c.bounds[<NUM_LIT:0>] for c in components] + [<NUM_LIT:1>] )<EOL>max_y = max( [c.bounds[<NUM_LIT:1>] for c in components] + [<NUM_LIT:1>] )<EOL>pos_x = min( [c.x for c in components] )<EOL>pos_y = min( [c.y for c in components] )<EOL>move_to_origin(components)<EOL>container = Container(auto_size=True,<EOL>position=[pos_x-self.pos[<NUM_LIT:0>], pos_y-self.pos[<NUM_LIT:1>]],<EOL>bgcolor=\"<STR_LIT>\")<EOL><INDENT>self.bounds = bounds=[max_x, max_y]<EOL>container = Container(fit_window=False, auto_size=True, bgcolor=\"<STR_LIT>\")<EOL><DEDENT>container.add( *components )<EOL>self.drawing = container<EOL>", "docstring": "Parses the drawing directive, updating the node components.", "id": "f1995:c0:m7"}
{"signature": "def __hash__(self):", "body": "return hash(self.ID)<EOL>", "docstring": "objects which compare equal have the same hash value.", "id": "f1995:c0:m2"}
{"signature": "def _label_drawing_changed(self, old, new):", "body": "if old is not None:<EOL><INDENT>self.component.remove(old)<EOL><DEDENT>if new is not None:<EOL><INDENT>self.component.add(new)<EOL><DEDENT>w, h = self.component.bounds<EOL>self.component.position = [ self.pos[<NUM_LIT:0>] - (w/<NUM_LIT:2>), self.pos[<NUM_LIT:1>] - (h/<NUM_LIT:2>) ]<EOL><INDENT>self.component.position = list( self.pos )<EOL><DEDENT>self.component.request_redraw()<EOL>", "docstring": "Handles the container of label components changing.", "id": "f1995:c0:m10"}
{"signature": "def map_element(self, obj, name, event):", "body": "canvas = self.diagram.diagram_canvas<EOL>parser = XDotParser()<EOL>for element in event.added:<EOL><INDENT>logger.debug(\"<STR_LIT>\" % element)<EOL>for node_mapping in self.nodes:<EOL><INDENT>ct = name[:-<NUM_LIT:6>] <EOL>if node_mapping.containment_trait == ct:<EOL><INDENT>dot_attrs = node_mapping.dot_node<EOL>dot = Dot()<EOL>graph_node = Node(str(id(element)))<EOL>self._style_node(graph_node, dot_attrs)<EOL>dot.add_node(graph_node)<EOL>xdot = graph_from_dot_data(dot.create(self.program,\"<STR_LIT>\"))<EOL>diagram_nodes = parser.parse_nodes(xdot)<EOL>for dn in diagram_nodes:<EOL><INDENT>if dn is not None:<EOL><INDENT>dn.element = element<EOL>for tool in node_mapping.tools:<EOL><INDENT>dn.tools.append(tool(dn))<EOL><DEDENT>canvas.add(dn)<EOL>canvas.request_redraw()<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>for element in event.removed:<EOL><INDENT>logger.debug(\"<STR_LIT>\" % element)<EOL>for component in canvas.components:<EOL><INDENT>if element == component.element:<EOL><INDENT>canvas.remove(component)<EOL>canvas.request_redraw()<EOL>break<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Handles mapping elements to diagram components", "id": "f1996:c4:m4"}
{"signature": "def clear_canvas(self):", "body": "logger.debug(\"<STR_LIT>\")<EOL>old_canvas = self.diagram_canvas<EOL><INDENT>logger.debug(\"<STR_LIT>\" % canvas.components)<EOL>for component in canvas.components:<EOL><INDENT>canvas.remove(component)<EOL><DEDENT>logger.debug(\"<STR_LIT>\" % canvas.components)<EOL>for component in canvas.components:<EOL><INDENT>canvas.remove(component)<EOL><DEDENT>logger.debug(\"<STR_LIT>\" % canvas.components)<EOL>canvas.request_redraw()<EOL><DEDENT>new_canvas = Canvas()<EOL>new_canvas.copy_traits(old_canvas, [\"<STR_LIT>\", \"<STR_LIT>\"])<EOL>self.diagram_canvas = new_canvas<EOL>self.viewport.component=new_canvas<EOL>self.viewport.request_redraw()<EOL>return<EOL>", "docstring": "Removes all components from the canvas", "id": "f1996:c0:m3"}
{"signature": "def _viewport_default(self):", "body": "vp = Viewport(component=self.diagram_canvas, enable_zoom=True)<EOL>vp.view_position = [<NUM_LIT:0>,<NUM_LIT:0>]<EOL>vp.tools.append(ViewportPanTool(vp))<EOL>return vp<EOL>", "docstring": "Trait initialiser", "id": "f1996:c0:m1"}
{"signature": "def _diagram_canvas_default(self):", "body": "canvas = Canvas()<EOL>for tool in self.tools:<EOL><INDENT>canvas.tools.append(tool(canvas))<EOL><DEDENT>return canvas<EOL>", "docstring": "Trait initialiser", "id": "f1996:c0:m0"}
{"signature": "@on_trait_change(\"<STR_LIT>\")<EOL><INDENT>def _diagram_canvas_changed(self, new):<DEDENT>", "body": "logger.debug(\"<STR_LIT>\")<EOL>canvas = self.diagram_canvas<EOL>for tool in self.tools:<EOL><INDENT>if canvas is not None:<EOL><INDENT>print(\"<STR_LIT>\" % tool)<EOL>canvas.tools.append(tool(canvas))<EOL><DEDENT><DEDENT>", "docstring": "Handles the diagram canvas being set", "id": "f1996:c0:m2"}
{"signature": "def __str__(self):", "body": "s = \"<STR_LIT>\"<EOL>return \"<STR_LIT>\" % ( s, super(Cluster, self).__str__() )<EOL>", "docstring": "Returns a string representation of the cluster in dot language.", "id": "f1997:c0:m0"}
{"signature": "def _labelloc_default(self):", "body": "return \"<STR_LIT>\"<EOL>", "docstring": "Trait initialiser.", "id": "f1997:c0:m1"}
{"signature": "def normal_left_dclick(self, event):", "body": "x = event.x<EOL>y = event.y<EOL><INDENT>candidates = []<EOL><DEDENT>component = self.component<EOL><INDENT>if isinstance(component, Container):<EOL><INDENT>candidates = get_nested_components(self.component)<EOL><DEDENT>else:<EOL><INDENT>return<EOL><DEDENT>item = None<EOL>for candidate, offset in candidates:<EOL><INDENT>if candidate.is_in(x-offset[<NUM_LIT:0>], y-offset[<NUM_LIT:1>]):<EOL><INDENT>item = candidate<EOL>break<EOL><DEDENT><DEDENT><DEDENT>if hasattr(component, \"<STR_LIT>\"):<EOL><INDENT>if component.element is not None:<EOL><INDENT>component.active_tool = self<EOL>component.element.edit_traits(kind=\"<STR_LIT>\")<EOL>event.handled = True<EOL>component.active_tool = None<EOL>component.request_redraw()<EOL><DEDENT><DEDENT>return<EOL>", "docstring": "Handles the left mouse button being double-clicked when the tool\n        is in the 'normal' state.\n\n        If the event occurred on this tool's component (or any contained\n        component of that component), the method opens a Traits UI view on the\n        object referenced by the 'element' trait of the component that was\n        double-clicked, setting the tool as the active tool for the duration\n        of the view.", "id": "f1998:c0:m0"}
{"signature": "def normal_right_down(self, event):", "body": "x = event.x<EOL>y = event.y<EOL><INDENT>candidates = []<EOL><DEDENT>component = self.component<EOL><INDENT>if isinstance(component, Container):<EOL><INDENT>candidates = get_nested_components(self.component)<EOL><DEDENT>else:<EOL><INDENT>return<EOL><DEDENT>item = None<EOL>for candidate, offset in candidates:<EOL><INDENT>if candidate.is_in(x-offset[<NUM_LIT:0>], y-offset[<NUM_LIT:1>]):<EOL><INDENT>item = candidate<EOL>break<EOL><DEDENT><DEDENT><DEDENT>for tool in component.tools:<EOL><INDENT>component.active_tool = self<EOL>event.handled = True<EOL>component.active_tool = None<EOL>component.request_redraw()<EOL><DEDENT>return<EOL>", "docstring": "Handles the right mouse button being clicked when the tool is in\n        the 'normal' state.\n\n        If the event occurred on this tool's component (or any contained\n        component of that component), the method opens a context menu with\n        menu items from any tool of the parent component that implements\n        MenuItemTool interface i.e. has a get_item() method.", "id": "f2000:c1:m0"}
{"signature": "def setUp(self):", "body": "self.subcommand = Workspace()<EOL>self.subcommand_str = \"<STR_LIT>\"<EOL>super(TestSubcommandWorkspace, self).setUp()<EOL>config_data = {<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT:path>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>}<EOL>}<EOL>}<EOL>}<EOL>self.config.update(config_data)<EOL>", "docstring": "Setup test suite.", "id": "f2006:c0:m0"}
{"signature": "def setUp(self):", "body": "self.subcommand = Jump()<EOL>self.subcommand_str = \"<STR_LIT>\"<EOL>super(TestSubcommandJump, self).setUp()<EOL>", "docstring": "Setup test suite.", "id": "f2008:c0:m0"}
{"signature": "def setUp(self):", "body": "super(TestSvn, self).setUp(Svn)<EOL>", "docstring": "Set up svn adapter and sandbox.", "id": "f2014:c0:m0"}
{"signature": "def mkdir(self, directory):", "body": "os.mkdir(os.path.join(self.path, directory))<EOL>", "docstring": "Create directory in sandbox..", "id": "f2016:c0:m1"}
{"signature": "def __init__(self, path=None):", "body": "if path is None:<EOL><INDENT>path = os.path.dirname(os.path.realpath(__file__)) + \"<STR_LIT>\"<EOL><DEDENT>self.path = path<EOL>if os.path.exists(path):<EOL><INDENT>self.destroy()<EOL><DEDENT>os.mkdir(path)<EOL>", "docstring": "Init sandbox environment.", "id": "f2016:c0:m0"}
{"signature": "def setUp(self, adapter):", "body": "super(AdapterTestHelper, self).setUp()<EOL>self.sandbox.mkdir(\"<STR_LIT>\")<EOL>self.adapter = adapter(<EOL>os.path.join(self.sandbox.path, \"<STR_LIT>\"))<EOL>self.adapter.execute = Mock(return_value=None)<EOL>", "docstring": "Generic setup for adapter test cases.", "id": "f2016:c3:m0"}
{"signature": "def assert_config_file_contains(self, config_file, expected):", "body": "file = open(config_file)<EOL>config = yaml.safe_load(file.read())<EOL>file.close()<EOL>self.assertEqual(config, expected)<EOL>", "docstring": "Custom assert to check content of config_file.", "id": "f2016:c1:m2"}
{"signature": "def assert_executed_command(self, expected_cmd, with_path=True):", "body": "if not with_path:<EOL><INDENT>self.adapter.execute.assert_called_once_with(expected_cmd)<EOL><DEDENT>else:<EOL><INDENT>self.adapter.execute.assert_called_once_with(<EOL>expected_cmd,<EOL>os.path.join(self.sandbox.path, \"<STR_LIT>\"))<EOL><DEDENT>", "docstring": "Assert that adapter has executed expected command.", "id": "f2016:c3:m2"}
{"signature": "def assert_subcommand_parsing_raises_error(self, commands, error_expected):", "body": "self.subcommand.parse()<EOL>self.assertRaises(<EOL>error_expected,<EOL>self.parser.parse_args, commands<EOL>)<EOL>", "docstring": "This method provides a way to assert subcommand parsing.", "id": "f2016:c2:m3"}
{"signature": "def touch(self, file):", "body": "full_path = os.path.join(self.path, file)<EOL>with open(full_path, '<STR_LIT:w>'):<EOL><INDENT>os.utime(full_path, None)<EOL><DEDENT>", "docstring": "Create file  into sandbox.", "id": "f2016:c0:m2"}
{"signature": "def setUp(self):", "body": "super(SubcommandTestHelper, self).setUp()<EOL>self.parser = argparse.ArgumentParser(prog=\"<STR_LIT>\")<EOL>self.subparser = self.parser.add_subparsers(dest=\"<STR_LIT>\")<EOL>self.config = Config(self.sandbox.path + \"<STR_LIT>\")<EOL>if self.subcommand is not None and self.subcommand_str is not None:<EOL><INDENT>self.subcommand.setup(<EOL>self.subcommand_str, self.config, self.subparser)<EOL><DEDENT>", "docstring": "Setup test suite.", "id": "f2016:c2:m0"}
{"signature": "def write(self):", "body": "file = open(self.config_file, \"<STR_LIT>\")<EOL>file.write(yaml.dump(dict(self), default_flow_style=False))<EOL>file.close()<EOL>", "docstring": "Write config in configuration file.\nData must me a dict.", "id": "f2020:c0:m4"}
{"signature": "def __init__(self, config_file, *args, **kwargs):", "body": "self.config_file = config_file<EOL>super(Config, self).__init__(*args, **kwargs)<EOL>if not os.path.exists(config_file) or config_file is None:<EOL><INDENT>self.update({\"<STR_LIT>\": {}})<EOL>self.write()<EOL><DEDENT>else:<EOL><INDENT>file = open(self.config_file)<EOL>config = yaml.safe_load(file.read())<EOL>file.close()<EOL>if config is not None:<EOL><INDENT>self.update(config)<EOL><DEDENT><DEDENT>", "docstring": "Workspace object initialization.", "id": "f2020:c0:m0"}
{"signature": "def execute(self, args):", "body": "if args.name is not None:<EOL><INDENT>self.print_workspace(args.name)<EOL><DEDENT>elif args.all is not None:<EOL><INDENT>self.print_all()<EOL><DEDENT>", "docstring": "Execute update subcommand.", "id": "f2023:c0:m2"}
{"signature": "def parse(self):", "body": "parser = self.subparser.add_parser(<EOL>\"<STR_LIT>\",<EOL>help=\"<STR_LIT>\",<EOL>description=\"<STR_LIT>\")<EOL>group = parser.add_mutually_exclusive_group(required=True)<EOL>group.add_argument('<STR_LIT>', action='<STR_LIT:store_true>', help=\"<STR_LIT>\")<EOL>group.add_argument('<STR_LIT:name>', type=str, help=\"<STR_LIT>\", nargs='<STR_LIT:?>')<EOL>", "docstring": "Parse update subcommand.", "id": "f2023:c0:m1"}
{"signature": "def print_workspace(self, name):", "body": "path_list = find_path(name, self.config)<EOL>if len(path_list) == <NUM_LIT:0>:<EOL><INDENT>self.logger.error(\"<STR_LIT>\" % name)<EOL>return False<EOL><DEDENT>for name, path in path_list.items():<EOL><INDENT>self.print_update(name, path)<EOL><DEDENT>", "docstring": "Print workspace update.", "id": "f2023:c0:m4"}
{"signature": "def __init__(self, name, subparser, config):", "body": "self.name = name<EOL>self.parser = subparser.add_parser(<EOL>name,<EOL>description=\"<STR_LIT>\" % name)<EOL>self.config = config<EOL>", "docstring": "Initialize workspace name.", "id": "f2025:c1:m0"}
{"signature": "def show_all(self):", "body": "for ws in self.workspace.list().keys():<EOL><INDENT>self.show_workspace(ws)<EOL>print(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Show details for all workspaces.", "id": "f2026:c0:m4"}
{"signature": "def parse(self):", "body": "parser = self.subparser.add_parser(<EOL>\"<STR_LIT>\",<EOL>help=\"<STR_LIT>\",<EOL>description=\"<STR_LIT>\")<EOL>group = parser.add_mutually_exclusive_group(required=True)<EOL>group.add_argument('<STR_LIT>', action='<STR_LIT:store_true>', help=\"<STR_LIT>\")<EOL>group.add_argument('<STR_LIT:name>', type=str, help=\"<STR_LIT>\", nargs='<STR_LIT:?>')<EOL>", "docstring": "Parse show subcommand.", "id": "f2026:c0:m1"}
{"signature": "def print_workspace(self, name):", "body": "path_list = find_path(name, self.config)<EOL>if len(path_list) == <NUM_LIT:0>:<EOL><INDENT>self.logger.error(\"<STR_LIT>\" % name)<EOL>return False<EOL><DEDENT>for name, path in path_list.items():<EOL><INDENT>self.print_status(name, path)<EOL><DEDENT>", "docstring": "Print workspace status.", "id": "f2027:c0:m4"}
{"signature": "def get_version():", "body": "requirement = pkg_resources.Requirement.parse(\"<STR_LIT>\")<EOL>provider = pkg_resources.get_provider(requirement)<EOL>return provider.version<EOL>", "docstring": "Get version from package resources.", "id": "f2028:m0"}
{"signature": "def clone(self, url):", "body": "return self.execute(\"<STR_LIT>\" % (self.executable,<EOL>url, self.path))<EOL>", "docstring": "Clone repository from url.", "id": "f2030:c0:m2"}
{"signature": "def clone(self, url):", "body": "return self.execute(\"<STR_LIT>\" % (url, self.path))<EOL>", "docstring": "Clone repository from url.", "id": "f2031:c0:m1"}
{"signature": "def clone(self, url):", "body": "return self.execute(\"<STR_LIT>\" % (self.executable,<EOL>url, self.path))<EOL>", "docstring": "Clone repository from url.", "id": "f2032:c0:m2"}
{"signature": "def update(self):", "body": "return self.exec_on_path(\"<STR_LIT>\" % self.executable)<EOL>", "docstring": "Update repository.", "id": "f2032:c0:m1"}
{"signature": "def clone(self, url):", "body": "return self.execute(\"<STR_LIT>\" % (url, self.path))<EOL>", "docstring": "Checkout repository from url.", "id": "f2035:c0:m1"}
{"signature": "def get(self, name):", "body": "ws_list = self.list()<EOL>return ws_list[name] if name in ws_list else None<EOL>", "docstring": "Get workspace infos from name.\nReturn None if workspace doesn't exists.", "id": "f2038:c0:m4"}
{"signature": "def simple_func1():", "body": "pass<EOL>", "docstring": "Example:\n    >>> pass", "id": "f2045:m0"}
{"signature": "@classmethod<EOL><INDENT>def method1(cls):<DEDENT>", "body": "pass<EOL>", "docstring": "Example:\n    >>> pass", "id": "f2045:c1:m1"}
{"signature": "def multiple_eval_for_loops_v2():", "body": "", "docstring": "However, xdoctest can handle this as long as you print to stdout\n\n>>> for i in range(2):\n...     print('%s' % i)\n...\n0\n1", "id": "f2056:m5"}
{"signature": "def multiline_madness():", "body": "pass<EOL>", "docstring": ">>> if True:\n>>>     print('doctest requires a special ... prefix')\ndoctest requires a special ... prefix", "id": "f2056:m0"}
{"signature": "def embeded_triple_quotes():", "body": "pass<EOL>", "docstring": ">>> x = '''\n    xdoctest is good at dealing with triple quoted strings\n    you don't even need to have the >>> prefix, because the\n    AST knows you are in a string context\n    '''\n>>> print(x)\nxdoctest is good at dealing with triple quoted strings\nyou don't even need to have the >>> prefix, because the\nAST knows you are in a string context", "id": "f2056:m1"}
{"signature": "def demo2():", "body": "pass<EOL>", "docstring": "CommandLine:\n    xdoctest -m ~/code/xdoctest/dev/demo_errors.py demo2\n\nExample:\n    >>> print('error on different line')\n    >>> raise Exception('demo2')", "id": "f2058:m1"}
{"signature": "def modify_conf():", "body": "import redbaron<EOL>import ubelt as ub<EOL>conf_path = '<STR_LIT>'<EOL>source = ub.readfrom(conf_path)<EOL>red = redbaron.RedBaron(source)<EOL>extra_extensions = [<EOL>'<STR_LIT>'<EOL>]<EOL>ext_node = red.find('<STR_LIT:name>', value='<STR_LIT>').parent<EOL>ext_node.value.value.extend(extra_extensions)<EOL>theme_node = red.find('<STR_LIT:name>', value='<STR_LIT>').parent<EOL>theme_node.value.value = '<STR_LIT>'<EOL>ub.writeto(conf_path, red.dumps())<EOL>", "docstring": "pip install redbaron", "id": "f2059:m1"}
{"signature": "def get_stack_frame(n=<NUM_LIT:0>, strict=True):", "body": "frame_cur = inspect.currentframe()<EOL>for ix in range(n + <NUM_LIT:1>):<EOL><INDENT>frame_next = frame_cur.f_back<EOL>if frame_next is None:  <EOL><INDENT>if strict:<EOL><INDENT>raise AssertionError('<STR_LIT>' % ix)<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>frame_cur = frame_next<EOL><DEDENT>return frame_cur<EOL>", "docstring": "Gets the current stack frame or any of its ancestors dynamically\n\nArgs:\n    n (int): n=0 means the frame you called this function in.\n             n=1 is the parent frame.\n    strict (bool): (default = True)\n\nReturns:\n    frame: frame_cur\n\nExample:\n    >>> frame_cur = get_stack_frame(n=0)\n    >>> print('frame_cur = %r' % (frame_cur,))\n    >>> assert frame_cur.f_globals['frame_cur'] is frame_cur", "id": "f2060:m1"}
{"signature": "def parse_dynamic_calldefs(modpath=None):", "body": "from xdoctest import static_analysis as static<EOL>from xdoctest import utils  <EOL>module = utils.import_module_from_path(modpath)<EOL>calldefs = {}<EOL>if getattr(module, '<STR_LIT>'):<EOL><INDENT>calldefs['<STR_LIT>'] = static.CallDefNode(<EOL>callname='<STR_LIT>',<EOL>docstr=module.__doc__,<EOL>lineno=<NUM_LIT:0>,<EOL>doclineno=<NUM_LIT:1>,<EOL>doclineno_end=<NUM_LIT:1>,<EOL>args=None<EOL>)<EOL><DEDENT>for key, val in iter_module_doctestables(module):<EOL><INDENT>if hasattr(val, '<STR_LIT>') and hasattr(val, '<STR_LIT>'):<EOL><INDENT>calldefs[key] = static.CallDefNode(<EOL>callname=val.__name__,<EOL>docstr=val.__doc__,<EOL>lineno=<NUM_LIT:0>,<EOL>doclineno=<NUM_LIT:1>,<EOL>doclineno_end=<NUM_LIT:1>,<EOL>args=None<EOL>)<EOL><DEDENT><DEDENT>return calldefs<EOL>", "docstring": "Dynamic parsing of module doctestable items.\n\nWhile this does execute module code it is needed for testing extension\nlibraries.\n\nCommandLine:\n    python -m xdoctest.dynamic_analysis parse_dynamic_calldefs\n\nExample:\n    >>> from xdoctest import dynamic_analysis\n    >>> module = dynamic_analysis\n    >>> calldefs = parse_dynamic_calldefs(module.__file__)\n    >>> for key, calldef in sorted(calldefs.items()):\n    ...     print('key = {!r}'.format(key))\n    ...     print(' * calldef.callname = {}'.format(calldef.callname))\n    ...     if calldef.docstr is None:\n    ...         print(' * len(calldef.docstr) = {}'.format(calldef.docstr))\n    ...     else:\n    ...         print(' * len(calldef.docstr) = {}'.format(len(calldef.docstr)))", "id": "f2060:m0"}
{"signature": "def is_defined_by_module(item, module):", "body": "from xdoctest import static_analysis as static<EOL>target_modname = module.__name__<EOL>flag = False<EOL>if isinstance(item, types.ModuleType):<EOL><INDENT>if not hasattr(item, '<STR_LIT>'):<EOL><INDENT>try:<EOL><INDENT>name = static.modpath_to_modname(module.__file__)<EOL>flag = name in str(item)<EOL><DEDENT>except:<EOL><INDENT>flag = False<EOL><DEDENT><DEDENT>else:<EOL><INDENT>item_modpath = os.path.realpath(os.path.dirname(item.__file__))<EOL>mod_fpath = module.__file__.replace('<STR_LIT>', '<STR_LIT>')<EOL>if not mod_fpath.endswith('<STR_LIT>'):<EOL><INDENT>flag = False<EOL><DEDENT>else:<EOL><INDENT>modpath = os.path.realpath(os.path.dirname(mod_fpath))<EOL>modpath = modpath.replace('<STR_LIT>', '<STR_LIT>')<EOL>flag = item_modpath.startswith(modpath)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if isinstance(item, property):<EOL><INDENT>item = item.fget<EOL><DEDENT>if isinstance(item, staticmethod):<EOL><INDENT>item = item.__func__<EOL><DEDENT>if isinstance(item, classmethod):<EOL><INDENT>item = item.__func__<EOL><DEDENT>if getattr(item, '<STR_LIT>', None) == target_modname:<EOL><INDENT>flag = True<EOL><DEDENT>elif hasattr(item, '<STR_LIT>'):<EOL><INDENT>parent = item.__objclass__<EOL>if getattr(parent, '<STR_LIT>', None) == target_modname:<EOL><INDENT>flag = True<EOL><DEDENT><DEDENT>if not flag:<EOL><INDENT>try:<EOL><INDENT>item_modname = _func_globals(item)['<STR_LIT>']<EOL>if item_modname == target_modname:<EOL><INDENT>flag = True<EOL><DEDENT><DEDENT>except  AttributeError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>return flag<EOL>", "docstring": "Check if item is directly defined by a module.\n\nThis check may not always work, especially for decorated functions.\n\nExample:\n    >>> from xdoctest import dynamic_analysis\n    >>> item = dynamic_analysis.is_defined_by_module\n    >>> module = dynamic_analysis\n    >>> assert is_defined_by_module(item, module)\n    >>> item = dynamic_analysis.six\n    >>> assert not is_defined_by_module(item, module)\n    >>> item = dynamic_analysis.six.print_\n    >>> assert not is_defined_by_module(item, module)\n    >>> assert not is_defined_by_module(print, module)\n    >>> import _ctypes\n    >>> item = _ctypes.Array\n    >>> module = _ctypes\n    >>> assert is_defined_by_module(item, module)\n    >>> item = _ctypes.CFuncPtr.restype\n    >>> module = _ctypes\n    >>> assert is_defined_by_module(item, module)", "id": "f2060:m5"}
{"signature": "def check_got_vs_want(want, got_stdout, got_eval=constants.NOT_EVALED,<EOL>runstate=None):", "body": "<EOL>if got_eval is constants.NOT_EVALED:<EOL><INDENT>got = got_stdout<EOL>flag = check_output(got, want, runstate)<EOL><DEDENT>else:<EOL><INDENT>if not got_stdout:<EOL><INDENT>got = repr(got_eval)<EOL>flag = check_output(got, want, runstate)<EOL><DEDENT>else:<EOL><INDENT>got = got_stdout<EOL>flag = check_output(got, want, runstate)<EOL>if not flag:<EOL><INDENT>got = repr(got_eval)<EOL>flag = check_output(got, want, runstate)<EOL>if not flag:<EOL><INDENT>got = got_stdout<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if not flag:<EOL><INDENT>msg = '<STR_LIT>'<EOL>ex = GotWantException(msg, got, want)<EOL>raise ex<EOL><DEDENT>return flag<EOL>", "docstring": "Determines to check against either got_stdout or got_eval, and then does\nthe comparison.\n\nIf both stdout and eval \"got\" outputs are specified, then the \"want\"\ntarget may match either value.\n\nArgs:\n    want (str): target to match against\n    got_stdout (str): output from stdout\n    got_eval (str): output from an eval statement.\n\nRaises:\n    GotWantException - If the \"got\" differs from this parts want.", "id": "f2061:m0"}
{"signature": "def output_repr_difference(self, runstate=None):", "body": "minimal_got = self.got.rstrip()<EOL>minimal_want = self.want.rstrip()<EOL>if runstate is None:<EOL><INDENT>runstate = directive.RuntimeState()<EOL><DEDENT>runstate_ = runstate.to_dict()<EOL>if not runstate_['<STR_LIT>']:<EOL><INDENT>minimal_want = remove_blankline_marker(minimal_want)<EOL><DEDENT>lines = [<EOL>('<STR_LIT>'),<EOL>('<STR_LIT>'.format(minimal_got)),<EOL>('<STR_LIT>'.format(minimal_want)),<EOL>]<EOL>return '<STR_LIT:\\n>'.join(lines)<EOL>", "docstring": "Constructs a repr difference with minimal normalization.", "id": "f2061:c0:m3"}
{"signature": "def _label_docsrc_lines(self, string):", "body": "def _complete_source(line, state_indent, line_iter):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>norm_line = line[state_indent:]  <EOL>prefix = norm_line[:<NUM_LIT:4>]<EOL>suffix = norm_line[<NUM_LIT:4>:]<EOL>assert prefix.strip() in {'<STR_LIT>', '<STR_LIT>'}, '<STR_LIT:{}>'.format(prefix)<EOL>yield line<EOL>source_parts = [suffix]<EOL>HACK_TRIPLE_QUOTE_FIX = True<EOL>try:<EOL><INDENT>while not static.is_balanced_statement(source_parts, only_tokens=True):<EOL><INDENT>line_idx, next_line = next(line_iter)<EOL>norm_line = next_line[state_indent:]<EOL>prefix = norm_line[:<NUM_LIT:4>]<EOL>suffix = norm_line[<NUM_LIT:4>:]<EOL>if prefix.strip() not in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'}:  <EOL><INDENT>error = True<EOL>if HACK_TRIPLE_QUOTE_FIX:<EOL><INDENT>if any(\"<STR_LIT>\" in s or '<STR_LIT>' in s for s in source_parts):<EOL><INDENT>next_line = next_line[:state_indent] + '<STR_LIT>' + norm_line<EOL>norm_line = '<STR_LIT>' + norm_line<EOL>prefix = '<STR_LIT>'<EOL>suffix = norm_line<EOL>error = False<EOL><DEDENT><DEDENT>if error:<EOL><INDENT>if DEBUG:<EOL><INDENT>print('<STR_LIT>')<EOL>print('<STR_LIT>'.format(source_parts))<EOL>print('<STR_LIT>'.format(prefix))<EOL>print('<STR_LIT>'.format(norm_line))<EOL>print('<STR_LIT>')<EOL><DEDENT>raise SyntaxError(<EOL>'<STR_LIT>'.format(<EOL>line_idx, next_line))<EOL><DEDENT><DEDENT>source_parts.append(suffix)<EOL>yield next_line<EOL><DEDENT><DEDENT>except StopIteration:<EOL><INDENT>if DEBUG:<EOL><INDENT>import ubelt as ub<EOL>print('<STR_LIT>')<EOL>import traceback<EOL>tb_text = traceback.format_exc()<EOL>tb_text = ub.highlight_code(tb_text)<EOL>tb_text = ub.indent(tb_text)<EOL>print(tb_text)<EOL>print('<STR_LIT>'.format(line_iter))<EOL>print('<STR_LIT>'.format(state_indent))<EOL>print('<STR_LIT>'.format(line))<EOL>print('<STR_LIT>')<EOL>print('<STR_LIT>'.format(ub.repr2(source_parts, nl=<NUM_LIT:2>)))<EOL>print(ub.codeblock(<EOL>r'''<STR_LIT>'''))<EOL>print('<STR_LIT>')<EOL><DEDENT>raise IncompleteParseError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>if DEBUG > <NUM_LIT:1>:<EOL><INDENT>import ubelt as ub<EOL>print('<STR_LIT>')<EOL>print('<STR_LIT>'.format(line_iter))<EOL>print('<STR_LIT>'.format(ub.repr2(source_parts, nl=<NUM_LIT:2>)))<EOL>print('<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>labeled_lines = []<EOL>state_indent = <NUM_LIT:0><EOL>TEXT = '<STR_LIT:text>'<EOL>DSRC = '<STR_LIT>'<EOL>WANT = '<STR_LIT>'<EOL>prev_state = TEXT<EOL>curr_state = None<EOL>line_iter = enumerate(string.splitlines())<EOL>def hasprefix(line, prefixes):<EOL><INDENT>if not isinstance(prefixes, tuple):<EOL><INDENT>prefixes = [prefixes]<EOL><DEDENT>return any(line == p or line.startswith(p + '<STR_LIT:U+0020>') for p in prefixes)<EOL><DEDENT>for line_idx, line in line_iter:<EOL><INDENT>match = INDENT_RE.search(line)<EOL>line_indent = <NUM_LIT:0> if match is None else (match.end() - match.start())<EOL>norm_line = line[state_indent:]  <EOL>strip_line = line.strip()<EOL>if prev_state == TEXT:<EOL><INDENT>if hasprefix(strip_line, '<STR_LIT>'):<EOL><INDENT>curr_state = DSRC<EOL><DEDENT>else:<EOL><INDENT>curr_state = TEXT<EOL><DEDENT><DEDENT>elif prev_state == WANT:<EOL><INDENT>if len(strip_line) == <NUM_LIT:0>:<EOL><INDENT>curr_state = TEXT<EOL><DEDENT>elif hasprefix(line.strip(), '<STR_LIT>'):<EOL><INDENT>curr_state = DSRC<EOL><DEDENT>elif line_indent < state_indent:<EOL><INDENT>curr_state = TEXT<EOL><DEDENT>else:<EOL><INDENT>curr_state = WANT<EOL><DEDENT><DEDENT>elif prev_state == DSRC:  <EOL><INDENT>if len(strip_line) == <NUM_LIT:0> or line_indent < state_indent:<EOL><INDENT>curr_state = TEXT<EOL><DEDENT>elif hasprefix(norm_line, ('<STR_LIT>', '<STR_LIT>')):<EOL><INDENT>if strip_line == '<STR_LIT>':<EOL><INDENT>curr_state = WANT<EOL><DEDENT>else:<EOL><INDENT>curr_state = DSRC<EOL><DEDENT><DEDENT>else:<EOL><INDENT>curr_state = WANT<EOL><DEDENT><DEDENT>else:  <EOL><INDENT>raise AssertionError('<STR_LIT>'.format(<EOL>prev_state))<EOL><DEDENT>if prev_state != curr_state:<EOL><INDENT>if curr_state == TEXT:<EOL><INDENT>state_indent = <NUM_LIT:0><EOL><DEDENT>if curr_state == DSRC:<EOL><INDENT>state_indent = line_indent<EOL>norm_line = line[state_indent:]<EOL><DEDENT><DEDENT>if curr_state == DSRC:<EOL><INDENT>try:<EOL><INDENT>for part in _complete_source(line, state_indent, line_iter):<EOL><INDENT>labeled_lines.append((DSRC, part))<EOL><DEDENT><DEDENT>except IncompleteParseError as orig_ex:<EOL><INDENT>raise<EOL><DEDENT>except SyntaxError as orig_ex:<EOL><INDENT>if DEBUG:<EOL><INDENT>print('<STR_LIT>')<EOL>print('<STR_LIT>'.format(line_iter))<EOL>print('<STR_LIT>'.format(state_indent))<EOL>print('<STR_LIT>'.format(line))<EOL>print('<STR_LIT>')<EOL>print('<STR_LIT>')<EOL>for line in labeled_lines:<EOL><INDENT>print(line)<EOL><DEDENT>print('<STR_LIT>')<EOL>print('<STR_LIT>')<EOL><DEDENT>raise<EOL><DEDENT><DEDENT>elif curr_state == WANT:<EOL><INDENT>labeled_lines.append((WANT, line))<EOL><DEDENT>elif curr_state == TEXT:<EOL><INDENT>labeled_lines.append((TEXT, line))<EOL><DEDENT>prev_state = curr_state<EOL><DEDENT>if DEBUG > <NUM_LIT:1>:<EOL><INDENT>import ubelt as ub<EOL>print('<STR_LIT>')<EOL>print('<STR_LIT>'.format(ub.repr2(labeled_lines, nl=<NUM_LIT:1>)))<EOL>print('<STR_LIT>')<EOL><DEDENT>return labeled_lines<EOL>", "docstring": "Example:\n    >>> from xdoctest.parser import *\n    >>> # Having multiline strings in doctests can be nice\n    >>> string = utils.codeblock(\n            '''\n            text\n            >>> items = ['also', 'nice', 'to', 'not', 'worry',\n            >>>          'about', '...', 'vs', '>>>']\n            ... print('but its still allowed')\n            but its still allowed\n\n            more text\n            ''')\n    >>> self = DoctestParser()\n    >>> labeled = self._label_docsrc_lines(string)\n    >>> expected = [\n    >>>     ('text', 'text'),\n    >>>     ('dsrc', \">>> items = ['also', 'nice', 'to', 'not', 'worry',\"),\n    >>>     ('dsrc', \">>>          'about', '...', 'vs', '>>>']\"),\n    >>>     ('dsrc', \"... print('but its still allowed')\"),\n    >>>     ('want', 'but its still allowed'),\n    >>>     ('text', ''),\n    >>>     ('text', 'more text')\n    >>> ]\n    >>> assert labeled == expected", "id": "f2062:c1:m7"}
{"signature": "def _package_chunk(self, raw_source_lines, raw_want_lines, lineno=<NUM_LIT:0>):", "body": "if DEBUG > <NUM_LIT:1>:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>match = INDENT_RE.search(raw_source_lines[<NUM_LIT:0>])<EOL>line_indent = <NUM_LIT:0> if match is None else (match.end() - match.start())<EOL>source_lines = [p[line_indent:] for p in raw_source_lines]<EOL>want_lines = [p[line_indent:] for p in raw_want_lines]<EOL>exec_source_lines = [p[<NUM_LIT:4>:] for p in source_lines]<EOL>if DEBUG > <NUM_LIT:1>:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>ps1_linenos, eval_final = self._locate_ps1_linenos(source_lines)<EOL>if DEBUG > <NUM_LIT:1>:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>break_linenos = []<EOL>ps1_to_directive = {}<EOL>for s1, s2 in zip(ps1_linenos, ps1_linenos[<NUM_LIT:1>:] + [None]):<EOL><INDENT>lines = exec_source_lines[s1:s2]<EOL>directives = list(directive.Directive.extract('<STR_LIT:\\n>'.join(lines)))<EOL>if directives:<EOL><INDENT>ps1_to_directive[s1] = directives<EOL>break_linenos.append(s1)<EOL>if directives[<NUM_LIT:0>].inline:<EOL><INDENT>if s2 is not None:<EOL><INDENT>break_linenos.append(s2)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>def slice_example(s1, s2, want_lines=None):<EOL><INDENT>exec_lines = exec_source_lines[s1:s2]<EOL>orig_lines = source_lines[s1:s2]<EOL>directives = ps1_to_directive.get(s1, None)<EOL>example = doctest_part.DoctestPart(exec_lines,<EOL>want_lines=want_lines,<EOL>orig_lines=orig_lines,<EOL>line_offset=lineno + s1,<EOL>directives=directives)<EOL>return example<EOL><DEDENT>s1 = <NUM_LIT:0><EOL>s2 = <NUM_LIT:0><EOL>if self.simulate_repl:<EOL><INDENT>for s1, s2 in zip(ps1_linenos, ps1_linenos[<NUM_LIT:1>:]):<EOL><INDENT>example = slice_example(s1, s2)<EOL>yield example<EOL><DEDENT>s1 = s2<EOL><DEDENT>else:<EOL><INDENT>if break_linenos:<EOL><INDENT>break_linenos = sorted(set([<NUM_LIT:0>] + break_linenos))<EOL>for s1, s2 in zip(break_linenos, break_linenos[<NUM_LIT:1>:]):<EOL><INDENT>example = slice_example(s1, s2)<EOL>yield example<EOL><DEDENT>s1 = s2<EOL><DEDENT>if want_lines and eval_final:<EOL><INDENT>s2 = ps1_linenos[-<NUM_LIT:1>]<EOL>if s2 != s1:  <EOL><INDENT>example = slice_example(s1, s2)<EOL>yield example<EOL>s1 = s2<EOL><DEDENT><DEDENT><DEDENT>s2 = None<EOL>example = slice_example(s1, s2, want_lines)<EOL>example.use_eval = bool(want_lines) and eval_final<EOL>if DEBUG > <NUM_LIT:1>:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>yield example<EOL>", "docstring": "if `self.simulate_repl` is True, then each statement is broken into its\nown part.  Otherwise, statements are grouped by the closest `want`\nstatement.\n\nExample:\n    >>> from xdoctest.parser import *\n    >>> raw_source_lines = ['>>> \"string\"']\n    >>> raw_want_lines = ['string']\n    >>> self = DoctestParser()\n    >>> part, = self._package_chunk(raw_source_lines, raw_want_lines)\n    >>> part.source\n    '\"string\"'\n    >>> part.want\n    'string'", "id": "f2062:c1:m3"}
{"signature": "def parse(self, string, info=None):", "body": "if DEBUG > <NUM_LIT:1>:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>if sys.version_info.major == <NUM_LIT:2>:  <EOL><INDENT>string = utils.ensure_unicode(string)<EOL><DEDENT>if not isinstance(string, six.string_types):<EOL><INDENT>raise TypeError('<STR_LIT>'.format(string))<EOL><DEDENT>string = string.expandtabs()<EOL>min_indent = min_indentation(string)<EOL>if min_indent > <NUM_LIT:0>:<EOL><INDENT>string = '<STR_LIT:\\n>'.join([l[min_indent:] for l in string.splitlines()])<EOL><DEDENT>labeled_lines = None<EOL>grouped_lines = None<EOL>all_parts = None<EOL>try:<EOL><INDENT>labeled_lines = self._label_docsrc_lines(string)<EOL>grouped_lines = self._group_labeled_lines(labeled_lines)<EOL>all_parts = list(self._package_groups(grouped_lines))<EOL><DEDENT>except Exception as orig_ex:<EOL><INDENT>if labeled_lines is None:<EOL><INDENT>failpoint = '<STR_LIT>'<EOL><DEDENT>elif grouped_lines is None:<EOL><INDENT>failpoint = '<STR_LIT>'<EOL><DEDENT>elif all_parts is None:<EOL><INDENT>failpoint = '<STR_LIT>'<EOL><DEDENT>if DEBUG:<EOL><INDENT>print('<STR_LIT>')<EOL>print('<STR_LIT>')<EOL>print('<STR_LIT>'.format(failpoint))<EOL>import ubelt as ub<EOL>import traceback<EOL>tb_text = traceback.format_exc()<EOL>tb_text = ub.highlight_code(tb_text)<EOL>tb_text = ub.indent(tb_text)<EOL>print(tb_text)<EOL>print('<STR_LIT>')<EOL>print(string)<EOL>print('<STR_LIT>')<EOL>print('<STR_LIT>'.format(ub.repr2(info)))<EOL>print('<STR_LIT>')<EOL>print('<STR_LIT>'.format(orig_ex))<EOL>print('<STR_LIT>'.format(ub.repr2(labeled_lines)))<EOL>print('<STR_LIT>'.format(ub.repr2(grouped_lines, nl=<NUM_LIT:3>)))<EOL>print('<STR_LIT>'.format(ub.repr2(all_parts)))<EOL>print('<STR_LIT>')<EOL><DEDENT>raise exceptions.DoctestParseError(<EOL>'<STR_LIT>'.format(failpoint),<EOL>string=string, info=info, orig_ex=orig_ex)<EOL><DEDENT>if DEBUG > <NUM_LIT:1>:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>return all_parts<EOL>", "docstring": "Divide the given string into examples and interleaving text.\n\nArgs:\n    string (str): string representing the doctest\n    info (dict): info about where the string came from in case of an\n        error\n\nReturns:\n    list : a list of `DoctestPart` objects\n\nCommandLine:\n    python -m xdoctest.parser DoctestParser.parse\n\nExample:\n    >>> s = 'I am a dummy example with two parts'\n    >>> x = 10\n    >>> print(s)\n    I am a dummy example with two parts\n    >>> s = 'My purpose it so demonstrate how wants work here'\n    >>> print('The new want applies ONLY to stdout')\n    >>> print('given before the last want')\n    >>> '''\n        this wont hurt the test at all\n        even though its multiline '''\n    >>> y = 20\n    The new want applies ONLY to stdout\n    given before the last want\n    >>> # Parts from previous examples are executed in the same context\n    >>> print(x + y)\n    30\n\n    this is simply text, and doesnt apply to the previous doctest the\n    <BLANKLINE> directive is still in effect.\n\nExample:\n    >>> from xdoctest import parser\n    >>> from xdoctest.docstr import docscrape_google\n    >>> from xdoctest import core\n    >>> self = parser.DoctestParser()\n    >>> docstr = self.parse.__doc__\n    >>> blocks = docscrape_google.split_google_docblocks(docstr)\n    >>> doclineno = self.parse.__func__.__code__.co_firstlineno\n    >>> key, (string, offset) = blocks[-2]\n    >>> self._label_docsrc_lines(string)\n    >>> doctest_parts = self.parse(string)\n    >>> # each part with a want-string needs to be broken in two\n    >>> assert len(doctest_parts) == 6", "id": "f2062:c1:m1"}
{"signature": "def parse_google_returns(docstr, return_annot=None):", "body": "blocks = split_google_docblocks(docstr)<EOL>for key, block in blocks:<EOL><INDENT>lines = block[<NUM_LIT:0>]<EOL>if key == '<STR_LIT>':<EOL><INDENT>for retdict in parse_google_retblock(lines, return_annot):<EOL><INDENT>yield retdict<EOL><DEDENT><DEDENT>if key == '<STR_LIT>':<EOL><INDENT>for retdict in parse_google_retblock(lines, return_annot):<EOL><INDENT>yield retdict<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "r\"\"\"\n    Generates dictionaries of possible return hints based on a google docstring\n\n    Args:\n        docstr (str): a google-style docstring\n        return_annot (str): the return type annotation (if one exists)\n\n    Yields:\n        Dict[str, str]: dictionaries of return value hints\n\n    Example:\n        >>> docstr = parse_google_returns.__doc__\n        >>> retdict_list = list(parse_google_returns(docstr))\n        >>> print([sorted(d.items()) for d in retdict_list])\n        [[('desc', 'dictionaries of return value hints'), ('type', 'Dict[str, str]')]]\n\n    Example:\n        >>> docstr = split_google_docblocks.__doc__\n        >>> retdict_list = list(parse_google_returns(docstr))\n        >>> print([sorted(d.items())[1] for d in retdict_list])\n        [('type', 'List[Tuple]')]", "id": "f2063:m1"}
{"signature": "def parse_google_args(docstr):", "body": "blocks = split_google_docblocks(docstr)<EOL>for key, block in blocks:<EOL><INDENT>lines = block[<NUM_LIT:0>]<EOL>if key == '<STR_LIT>':<EOL><INDENT>for argdict in parse_google_argblock(lines):<EOL><INDENT>yield argdict<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "r\"\"\"\n    Generates dictionaries of argument hints based on a google docstring\n\n    Args:\n        docstr (str): a google-style docstring\n\n    Yields:\n        Dict[str, str]: dictionaries of parameter hints\n\n    Example:\n        >>> docstr = parse_google_args.__doc__\n        >>> argdict_list = list(parse_google_args(docstr))\n        >>> print([sorted(d.items()) for d in argdict_list])\n        [[('desc', 'a google-style docstring'), ('name', 'docstr'), ('type', 'str')]]", "id": "f2063:m0"}
{"signature": "@property<EOL><INDENT>def directives(self):<DEDENT>", "body": "if self._directives is None:<EOL><INDENT>self._directives = list(directive.Directive.extract(self.source))<EOL><DEDENT>return self._directives<EOL>", "docstring": "CommandLine:\n    python -m xdoctest.parser DoctestPart.directives\n\nExample:\n    >>> self = DoctestPart(['# doctest: +SKIP'], None, 0)\n    >>> print(', '.join(list(map(str, self.directives))))\n    <Directive(+SKIP)>", "id": "f2065:c0:m5"}
{"signature": "@property<EOL><INDENT>def node(self):<DEDENT>", "body": "return self.modpath + '<STR_LIT>' + self.callname + '<STR_LIT::>' + str(self.num)<EOL>", "docstring": "this pytest node", "id": "f2066:c1:m6"}
{"signature": "def _color(self, text, color, enabled=None):", "body": "colored = self.config.getvalue('<STR_LIT>', enabled)<EOL>if colored:<EOL><INDENT>text = utils.color_text(text, color)<EOL><DEDENT>return text<EOL>", "docstring": "conditionally color text based on config and flags", "id": "f2066:c1:m24"}
{"signature": "def format_src(self, linenos=True, colored=None, want=True,<EOL>offset_linenos=None, prefix=True):", "body": "formated_parts = list(self.format_parts(linenos=linenos,<EOL>colored=colored, want=want,<EOL>offset_linenos=offset_linenos,<EOL>prefix=prefix))<EOL>full_source = '<STR_LIT:\\n>'.join(formated_parts)<EOL>return full_source<EOL>", "docstring": "Adds prefix and line numbers to a doctest\n\nArgs:\n    linenos (bool): if True, adds line numbers to output\n\n    colored (bool): if True highlight text with ansi colors. Default\n        is specified in the config.\n\n    want (bool): if True includes \"want\" lines (default False).\n\n    offset_linenos (bool): if True offset line numbers to agree with\n        their position in the source text file (default False).\n\n    prefix (bool): if False, exclude the doctest `>>> ` prefix\n\nExample:\n    >>> from xdoctest.core import *\n    >>> from xdoctest import core\n    >>> testables = parse_doctestables(core.__file__)\n    >>> self = next(testables)\n    >>> self._parse()\n    >>> print(self.format_src())\n    >>> print(self.format_src(linenos=False, colored=False))\n    >>> assert not self.is_disabled()", "id": "f2066:c1:m10"}
{"signature": "def _pkgutil_submodule_names(modpath, with_pkg=False, with_mod=True):", "body": "package_name = modpath_to_modname(modpath)<EOL>if isfile(modpath):<EOL><INDENT>yield package_name<EOL><DEDENT>else:<EOL><INDENT>import pkgutil<EOL>prefix = package_name + '<STR_LIT:.>'<EOL>walker = pkgutil.walk_packages([modpath], prefix=prefix,<EOL>onerror=lambda x: None)  <EOL>for importer, modname, ispkg in walker:<EOL><INDENT>if not ispkg and with_mod:<EOL><INDENT>yield modname<EOL><DEDENT>elif ispkg and with_pkg:<EOL><INDENT>yield modname<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Ignore:\n    x = sorted(submodule_paths(modname_to_modpath('ubelt')))\n    y = sorted(_pkgutil_submodule_names(modname_to_modpath('ubelt')))\n    x = [modpath_to_modname(p, hide_init=False, hide_main=False) for p in x]\n    print('x = {!r}'.format(x))\n    print('y = {!r}'.format(y))\n\nNotes:\n    this will take into account pyc files, we choose not to.", "id": "f2068:m0"}
{"signature": "def highlight_code(text, lexer_name='<STR_LIT>', **kwargs):", "body": "<EOL>lexer_name = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:h>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:c>': '<STR_LIT>',<EOL>}.get(lexer_name.replace('<STR_LIT:.>', '<STR_LIT>'), lexer_name)<EOL>try:<EOL><INDENT>import pygments<EOL>import pygments.lexers<EOL>import pygments.formatters<EOL>import pygments.formatters.terminal<EOL>formater = pygments.formatters.terminal.TerminalFormatter(bg='<STR_LIT>')<EOL>lexer = pygments.lexers.get_lexer_by_name(lexer_name, ensurenl=False, **kwargs)<EOL>new_text = pygments.highlight(text, lexer, formater)<EOL><DEDENT>except ImportError:  <EOL><INDENT>new_text = text<EOL><DEDENT>return new_text<EOL>", "docstring": "Highlights a block of text using ansi tags based on language syntax.\n\nArgs:\n    text (str): plain text to highlight\n    lexer_name (str): name of language\n    **kwargs: passed to pygments.lexers.get_lexer_by_name\n\nReturns:\n    str: text : highlighted text\n        If pygments is not installed, the plain text is returned.\n\nCommandLine:\n    python -c \"import pygments.formatters; print(list(pygments.formatters.get_all_formatters()))\"\n\nExample:\n    >>> text = 'import xdoctest as xdoc; print(xdoc)'\n    >>> new_text = highlight_code(text)\n    >>> print(new_text)", "id": "f2070:m4"}
{"signature": "def codeblock(block_str):", "body": "return textwrap.dedent(block_str).strip('<STR_LIT:\\n>')<EOL>", "docstring": "Wraps multiline string blocks and returns unindented code.\nUseful for templated code defined in indented parts of code.\n\nArgs:\n    block_str (str): typically in the form of a multiline string\n\nReturns:\n    str: the unindented string\n\nExample:\n    >>> # Simulate an indented part of code\n    >>> if True:\n    ...     # notice the indentation on this will be normal\n    ...     codeblock_version = codeblock(\n    ...             '''\n    ...             def foo():\n    ...                 return 'bar'\n    ...             '''\n    ...         )\n    ...     # notice the indentation and newlines on this will be odd\n    ...     normal_version = ('''\n    ...         def foo():\n    ...             return 'bar'\n    ...     ''')\n    >>> assert normal_version != codeblock_version\n    >>> print('Without codeblock')\n    >>> print(normal_version)\n    >>> print('With codeblock')\n    >>> print(codeblock_version)", "id": "f2070:m6"}
{"signature": "def add_line_numbers(source, start=<NUM_LIT:1>, n_digits=None):", "body": "was_string = isinstance(source, six.string_types)<EOL>part_lines = source.splitlines() if was_string else source<EOL>if n_digits is None:<EOL><INDENT>endline = start + len(part_lines)<EOL>n_digits = math.log(max(<NUM_LIT:1>, endline), <NUM_LIT:10>)<EOL>n_digits = int(math.ceil(n_digits))<EOL><DEDENT>src_fmt = '<STR_LIT>'<EOL>part_lines = [<EOL>src_fmt.format(n_digits=n_digits, count=count, line=line)<EOL>for count, line in enumerate(part_lines, start=start)<EOL>]<EOL>if was_string:<EOL><INDENT>return '<STR_LIT:\\n>'.join(part_lines)<EOL><DEDENT>else:<EOL><INDENT>return part_lines<EOL><DEDENT>", "docstring": "Prefixes code with line numbers\n\nExample:\n    >>> print(chr(10).join(add_line_numbers(['a', 'b', 'c'])))\n    1 a\n    2 b\n    3 c\n    >>> print(add_line_numbers(chr(10).join(['a', 'b', 'c'])))\n    1 a\n    2 b\n    3 c", "id": "f2070:m5"}
{"signature": "def ensuredir(dpath, mode=<NUM_LIT>):", "body": "if isinstance(dpath, (list, tuple)):  <EOL><INDENT>dpath = join(*dpath)<EOL><DEDENT>if not exists(dpath):<EOL><INDENT>try:<EOL><INDENT>os.makedirs(normpath(dpath), mode=mode)<EOL><DEDENT>except OSError:  <EOL><INDENT>raise<EOL><DEDENT><DEDENT>return dpath<EOL>", "docstring": "Ensures that directory will exist. creates new dir with sticky bits by\ndefault\n\nArgs:\n    dpath (str): dir to ensure. Can also be a tuple to send to join\n    mode (int): octal mode of directory (default 0o1777)\n\nReturns:\n    str: path - the ensured directory", "id": "f2074:m0"}
{"signature": "def parse_freeform_docstr_examples(docstr, callname=None, modpath=None,<EOL>lineno=<NUM_LIT:1>, fpath=None, asone=True):", "body": "def doctest_from_parts(parts, num, curr_offset):<EOL><INDENT>nested = [<EOL>p.orig_lines<EOL>if p.want is None else<EOL>p.orig_lines + p.want.splitlines()<EOL>for p in parts<EOL>]<EOL>docsrc = '<STR_LIT:\\n>'.join(list(it.chain.from_iterable(nested)))<EOL>docsrc = textwrap.dedent(docsrc)<EOL>example = doctest_example.DocTest(docsrc, modpath=modpath,<EOL>callname=callname, num=num,<EOL>lineno=lineno + curr_offset,<EOL>fpath=fpath)<EOL>unoffset = parts[<NUM_LIT:0>].line_offset<EOL>for p in parts:<EOL><INDENT>p.line_offset -= unoffset<EOL><DEDENT>example._parts = parts<EOL>return example<EOL><DEDENT>if DEBUG:<EOL><INDENT>print('<STR_LIT>'.format(<EOL>callname, modpath))<EOL><DEDENT>respect_google_headers = True<EOL>if respect_google_headers:  <EOL><INDENT>special_skip_patterns = [<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>]<EOL><DEDENT>else:<EOL><INDENT>special_skip_patterns = []  <EOL><DEDENT>special_skip_patterns_ = tuple([<EOL>p.lower() for p in special_skip_patterns<EOL>])<EOL>def _start_ignoring(prev):<EOL><INDENT>return (special_skip_patterns_ and<EOL>isinstance(prev, six.string_types) and<EOL>prev.strip().lower().endswith(special_skip_patterns_))<EOL><DEDENT>info = dict(callname=callname, modpath=modpath, lineno=lineno, fpath=fpath)<EOL>all_parts = list(parser.DoctestParser().parse(docstr, info))<EOL>curr_parts = []<EOL>curr_offset = <NUM_LIT:0><EOL>num = <NUM_LIT:0><EOL>prev_part = None<EOL>ignoring = False<EOL>for part in all_parts:<EOL><INDENT>if isinstance(part, six.string_types):<EOL><INDENT>if asone:<EOL><INDENT>if not curr_parts:<EOL><INDENT>curr_offset += part.count('<STR_LIT:\\n>') + <NUM_LIT:1><EOL><DEDENT><DEDENT>else:  <EOL><INDENT>if curr_parts:<EOL><INDENT>example = doctest_from_parts(curr_parts, num, curr_offset)<EOL>yield example<EOL>curr_offset += sum(p.n_lines for p in curr_parts)<EOL>num += <NUM_LIT:1><EOL>curr_parts = []<EOL><DEDENT>curr_offset += part.count('<STR_LIT:\\n>') + <NUM_LIT:1><EOL><DEDENT>ignoring = False<EOL><DEDENT>else:<EOL><INDENT>if ignoring or _start_ignoring(prev_part):<EOL><INDENT>ignoring = True<EOL>if asone:<EOL><INDENT>if not curr_parts:<EOL><INDENT>curr_offset += part.n_lines<EOL><DEDENT><DEDENT>else:<EOL><INDENT>curr_offset += part.n_lines<EOL><DEDENT><DEDENT>else:<EOL><INDENT>curr_parts.append(part)<EOL><DEDENT><DEDENT>prev_part = part<EOL><DEDENT>if curr_parts:<EOL><INDENT>example = doctest_from_parts(curr_parts, num, curr_offset)<EOL>yield example<EOL><DEDENT>", "docstring": "Finds free-form doctests in a docstring. This is similar to the original\ndoctests because these tests do not requires a google/numpy style header.\n\nSome care is taken to avoid enabling tests that look like disabled google\ndoctests / scripts.\n\nArgs:\n    asone (bool): if False doctests are broken into multiple examples\n       based on spacing. (default True)\n\n    lineno (int): the line number (starting from 1) of the docstring.\n        (i.e. if you were to go to this line number in the source file\n         the starting quotes of the docstr would be on this line).\n\nRaises:\n    xdoctest.exceptions.DoctestParseError: if an error occurs in parsing\n\nCommandLine:\n    python -m xdoctest.core parse_freeform_docstr_examples\n\nExample:\n    >>> from xdoctest import core\n    >>> from xdoctest import utils\n    >>> docstr = utils.codeblock(\n        '''\n        freeform\n        >>> doctest\n        >>> hasmultilines\n        whoppie\n        >>> 'butthis is the same doctest'\n\n        >>> secondone\n\n        Script:\n            >>> 'special case, dont parse me'\n\n        DisableDoctest:\n            >>> 'special case, dont parse me'\n            want\n\n        AnythingElse:\n            >>> 'general case, parse me'\n            want\n        ''')\n    >>> examples = list(parse_freeform_docstr_examples(docstr, asone=True))\n    >>> assert len(examples) == 1\n    >>> examples = list(parse_freeform_docstr_examples(docstr, asone=False))\n    >>> assert len(examples) == 3", "id": "f2078:m0"}
{"signature": "def _workaround_func_lineno(self, node):", "body": "<EOL>if node.decorator_list:<EOL><INDENT>linex = node.lineno - <NUM_LIT:1><EOL>pattern = r'<STR_LIT>' + node.name<EOL>while not re.match(pattern, self.sourcelines[linex]):<EOL><INDENT>linex += <NUM_LIT:1><EOL><DEDENT>lineno = linex + <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>lineno = node.lineno<EOL><DEDENT>return lineno<EOL>", "docstring": "Example:\n    >>> source = utils.codeblock(\n        '''\n        @bar\n        @baz\n        def foo():\n            'docstr'\n        ''')\n    >>> self = TopLevelVisitor(source)\n    >>> node = self.syntax_tree().body[0]\n    >>> self._workaround_func_lineno(node)\n    3", "id": "f2083:c1:m13"}
{"signature": "def package_modpaths(pkgpath, with_pkg=False, with_mod=True, followlinks=True,<EOL>recursive=True, with_libs=False, check=True):", "body": "if isfile(pkgpath):<EOL><INDENT>yield pkgpath<EOL><DEDENT>else:<EOL><INDENT>if with_pkg:<EOL><INDENT>root_path = join(pkgpath, '<STR_LIT>')<EOL>if not check or exists(root_path):<EOL><INDENT>yield root_path<EOL><DEDENT><DEDENT>valid_exts = ['<STR_LIT>']<EOL>if with_libs:<EOL><INDENT>valid_exts += _platform_pylib_exts()<EOL><DEDENT>for dpath, dnames, fnames in os.walk(pkgpath, followlinks=followlinks):<EOL><INDENT>ispkg = exists(join(dpath, '<STR_LIT>'))<EOL>if ispkg or not check:<EOL><INDENT>check = True  <EOL>if with_mod:<EOL><INDENT>for fname in fnames:<EOL><INDENT>if splitext(fname)[<NUM_LIT:1>] in valid_exts:<EOL><INDENT>if fname != '<STR_LIT>':<EOL><INDENT>path = join(dpath, fname)<EOL>yield path<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if with_pkg:<EOL><INDENT>for dname in dnames:<EOL><INDENT>path = join(dpath, dname, '<STR_LIT>')<EOL>if exists(path):<EOL><INDENT>yield path<EOL><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>del dnames[:]<EOL><DEDENT>if not recursive:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "r\"\"\"\n    Finds sub-packages and sub-modules belonging to a package.\n\n    Args:\n        pkgpath (str): path to a module or package\n        with_pkg (bool): if True includes package __init__ files (default =\n            False)\n        with_mod (bool): if True includes module files (default = True)\n        exclude (list): ignores any module that matches any of these patterns\n        recursive (bool): if False, then only child modules are included\n        with_libs (bool): if True then compiled shared libs will be returned as well\n        check (bool): if False, then then pkgpath is considered a module even\n            if it does not contain an __init__ file.\n\n    Yields:\n        str: module names belonging to the package\n\n    References:\n        http://stackoverflow.com/questions/1707709/list-modules-in-py-package\n\n    Example:\n        >>> from xdoctest.static_analysis import *\n        >>> pkgpath = modname_to_modpath('xdoctest')\n        >>> paths = list(package_modpaths(pkgpath))\n        >>> print('\\n'.join(paths))\n        >>> names = list(map(modpath_to_modname, paths))\n        >>> assert 'xdoctest.core' in names\n        >>> assert 'xdoctest.__main__' in names\n        >>> assert 'xdoctest' not in names\n        >>> print('\\n'.join(names))", "id": "f2083:m6"}
{"signature": "def _pkgutil_modname_to_modpath(modname):  ", "body": "import pkgutil<EOL>loader = pkgutil.find_loader(modname)<EOL>if loader is None:<EOL><INDENT>raise Exception('<STR_LIT>'.format(modname))<EOL><DEDENT>modpath = loader.get_filename().replace('<STR_LIT>', '<STR_LIT>')<EOL>return modpath<EOL>", "docstring": "faster version of `_syspath_modname_to_modpath` using builtin python\nmechanisms, but unfortunately it doesn't play nice with pytest.\n\nExample:\n    >>> # xdoctest: +SKIP\n    >>> modname = 'xdoctest.static_analysis'\n    >>> _pkgutil_modname_to_modpath(modname)\n    ...static_analysis.py\n    >>> _pkgutil_modname_to_modpath('_ctypes')\n    ..._ctypes...\n\nIgnore:\n    >>> _pkgutil_modname_to_modpath('cv2')", "id": "f2083:m10"}
{"signature": "def normalize_modpath(modpath, hide_init=True, hide_main=False):", "body": "if six.PY2:<EOL><INDENT>if modpath.endswith('<STR_LIT>'):<EOL><INDENT>modpath = modpath[:-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>if hide_init:<EOL><INDENT>if basename(modpath) == '<STR_LIT>':<EOL><INDENT>modpath = dirname(modpath)<EOL>hide_main = True<EOL><DEDENT><DEDENT>else:<EOL><INDENT>modpath_with_init = join(modpath, '<STR_LIT>')<EOL>if exists(modpath_with_init):<EOL><INDENT>modpath = modpath_with_init<EOL><DEDENT><DEDENT>if hide_main:<EOL><INDENT>if basename(modpath) == '<STR_LIT>':<EOL><INDENT>parallel_init = join(dirname(modpath), '<STR_LIT>')<EOL>if exists(parallel_init):<EOL><INDENT>modpath = dirname(modpath)<EOL><DEDENT><DEDENT><DEDENT>return modpath<EOL>", "docstring": "Normalizes __init__ and __main__ paths.\n\nNotes:\n    Adds __init__ if reasonable, but only removes __main__ by default\n\nArgs:\n    hide_init (bool): if True, always return package modules\n       as __init__.py files otherwise always return the dpath.\n    hide_init (bool): if True, always strip away main files otherwise\n       ignore __main__.py.\n\nCommandLine:\n    xdoctest -m xdoctest.static_analysis normalize_modpath\n\nExample:\n    >>> import xdoctest.static_analysis as static\n    >>> modpath = static.__file__\n    >>> assert static.normalize_modpath(modpath) == modpath.replace('.pyc', '.py')\n    >>> dpath = dirname(modpath)\n    >>> res0 = static.normalize_modpath(dpath, hide_init=0, hide_main=0)\n    >>> res1 = static.normalize_modpath(dpath, hide_init=0, hide_main=1)\n    >>> res2 = static.normalize_modpath(dpath, hide_init=1, hide_main=0)\n    >>> res3 = static.normalize_modpath(dpath, hide_init=1, hide_main=1)\n    >>> assert res0.endswith('__init__.py')\n    >>> assert res1.endswith('__init__.py')\n    >>> assert not res2.endswith('.py')\n    >>> assert not res3.endswith('.py')", "id": "f2083:m5"}
{"signature": "def modpath_to_modname(modpath, hide_init=True, hide_main=False, check=True,<EOL>relativeto=None):", "body": "if check and relativeto is None:<EOL><INDENT>if not exists(modpath):<EOL><INDENT>raise ValueError('<STR_LIT>'.format(modpath))<EOL><DEDENT><DEDENT>modpath_ = abspath(expanduser(modpath))<EOL>modpath_ = normalize_modpath(modpath_, hide_init=hide_init,<EOL>hide_main=hide_main)<EOL>if relativeto:<EOL><INDENT>dpath = dirname(abspath(expanduser(relativeto)))<EOL>rel_modpath = relpath(modpath_, dpath)<EOL><DEDENT>else:<EOL><INDENT>dpath, rel_modpath = split_modpath(modpath_, check=check)<EOL><DEDENT>modname = splitext(rel_modpath)[<NUM_LIT:0>]<EOL>if '<STR_LIT:.>' in modname:<EOL><INDENT>modname, abi_tag = modname.split('<STR_LIT:.>')<EOL><DEDENT>modname = modname.replace('<STR_LIT:/>', '<STR_LIT:.>')<EOL>modname = modname.replace('<STR_LIT:\\\\>', '<STR_LIT:.>')<EOL>return modname<EOL>", "docstring": "Determines importable name from file path\n\nConverts the path to a module (__file__) to the importable python name\n(__name__) without importing the module.\n\nThe filename is converted to a module name, and parent directories are\nrecursively included until a directory without an __init__.py file is\nencountered.\n\nArgs:\n    modpath (str): module filepath\n    hide_init (bool): removes the __init__ suffix (default True)\n    hide_main (bool): removes the __main__ suffix (default False)\n    check (bool): if False, does not raise an error if modpath is a dir\n        and does not contain an __init__ file.\n    relativeto (str, optional): if specified, all checks are ignored and\n        this is considered the path to the root module.\n\nReturns:\n    str: modname\n\nRaises:\n    ValueError: if check is True and the path does not exist\n\nCommandLine:\n    xdoctest -m xdoctest.static_analysis modpath_to_modname\n\nExample:\n    >>> from xdoctest import static_analysis\n    >>> modpath = static_analysis.__file__.replace('.pyc', '.py')\n    >>> modpath = modpath.replace('.pyc', '.py')\n    >>> modname = modpath_to_modname(modpath)\n    >>> assert modname == 'xdoctest.static_analysis'\n\nExample:\n    >>> import xdoctest\n    >>> assert modpath_to_modname(xdoctest.__file__.replace('.pyc', '.py')) == 'xdoctest'\n    >>> assert modpath_to_modname(dirname(xdoctest.__file__.replace('.pyc', '.py'))) == 'xdoctest'\n\nExample:\n    >>> modpath = modname_to_modpath('_ctypes')\n    >>> modname = modpath_to_modname(modpath)\n    >>> assert modname == '_ctypes'", "id": "f2083:m8"}
{"signature": "def parse_description():", "body": "from os.path import dirname, join, exists<EOL>readme_fpath = join(dirname(__file__), '<STR_LIT>')<EOL>if exists(readme_fpath):<EOL><INDENT>with open(readme_fpath, '<STR_LIT:r>') as f:<EOL><INDENT>text = f.read()<EOL><DEDENT>return text<EOL><DEDENT>return '<STR_LIT>'<EOL>", "docstring": "Parse the description in the README file\n\nCommandLine:\n    pandoc --from=markdown --to=rst --output=README.rst README.md\n    python -c \"import setup; print(setup.parse_description())\"", "id": "f2084:m2"}
{"signature": "def error(msg, exit_code):", "body": "sys.stderr.write(\"<STR_LIT>\" % msg)<EOL>sys.stderr.flush()<EOL>exit(exit_code)<EOL>", "docstring": "Print `msg` error and exit with status `exit_code`", "id": "f2092:m1"}
{"signature": "def load_fixture(filename):", "body": "path = os.path.join(os.path.dirname(__file__), '<STR_LIT>', filename)<EOL>with open(path) as fptr:<EOL><INDENT>return fptr.read()<EOL><DEDENT>", "docstring": "Load a fixture.", "id": "f2093:m0"}
{"signature": "def update(self):", "body": "cameras = self._api.camera_list()<EOL>self._cameras_by_id = {v.camera_id: v for i, v in enumerate(cameras)}<EOL>motion_settings = []<EOL>for camera_id in self._cameras_by_id.keys():<EOL><INDENT>motion_setting = self._api.camera_event_motion_enum(camera_id)<EOL>motion_settings.append(motion_setting)<EOL><DEDENT>self._motion_settings_by_id = {<EOL>v.camera_id: v for i, v in enumerate(motion_settings)}<EOL>", "docstring": "Update cameras and motion settings with latest from API.", "id": "f2094:c0:m1"}
{"signature": "def enable_camera(self, camera_id):", "body": "return self._api.camera_enable(camera_id)<EOL>", "docstring": "Enable camera(s) - multiple ID or single ex 1 or 1,2,3.", "id": "f2094:c0:m6"}
{"signature": "def get_all_cameras(self):", "body": "return self._cameras_by_id.values()<EOL>", "docstring": "Return a list of cameras.", "id": "f2094:c0:m2"}
{"signature": "def get_camera(self, camera_id):", "body": "return self._cameras_by_id[camera_id]<EOL>", "docstring": "Return camera matching camera_id.", "id": "f2094:c0:m3"}
{"signature": "def __init__(self, camera_id, data):", "body": "self._camera_id = camera_id<EOL>self._source = data['<STR_LIT:source>']<EOL>", "docstring": "Initialize a Surveillance Station motion setting.", "id": "f2096:c2:m0"}
{"signature": "@property<EOL><INDENT>def camera_id(self):<DEDENT>", "body": "return self._camera_id<EOL>", "docstring": "Return id of the camera.", "id": "f2096:c2:m1"}
{"signature": "def __init__(self, url, username, password, timeout=<NUM_LIT:10>, verify_ssl=True):", "body": "self._base_url = url + '<STR_LIT>'<EOL>self._username = username<EOL>self._password = password<EOL>self._timeout = timeout<EOL>self._verify_ssl = verify_ssl<EOL>self._api_info = None<EOL>self._sid = None<EOL>self._initialize_api_info()<EOL>self._initialize_api_sid()<EOL>", "docstring": "Initialize a Synology Surveillance API.", "id": "f2096:c0:m0"}
{"signature": "def read_config_(self, cfile):", "body": "if not cfile.exists():<EOL><INDENT>return {}<EOL><DEDENT>try:<EOL><INDENT>conf_dict = toml.load(str(cfile))<EOL><DEDENT>except toml.TomlDecodeError:<EOL><INDENT>return None<EOL><DEDENT>self.update_(conf_dict)<EOL>return conf_dict<EOL>", "docstring": "Read a config file and set config values accordingly.\n\n        Returns:\n            dict: content of config file.", "id": "f2102:c2:m17"}
{"signature": "def options_(self):", "body": "return iter(self)<EOL>", "docstring": "Iterator over configuration option names.\n\n        Yields:\n            option names.", "id": "f2102:c1:m9"}
{"signature": "def defaults_(self):", "body": "return self.def_.items()<EOL>", "docstring": "Iterator over option names, and option metadata.\n\n        Yields:\n            tuples with option names, and :class:`Conf` instances holding\n            option metadata.", "id": "f2102:c1:m11"}
{"signature": "def create_config_(self, index=<NUM_LIT:0>, update=False):", "body": "if not self.config_files_[index:]:<EOL><INDENT>return<EOL><DEDENT>path = self.config_files_[index]<EOL>if not path.parent.exists():<EOL><INDENT>path.parent.mkdir(parents=True)<EOL><DEDENT>conf_dict = {}<EOL>for section in self.sections_():<EOL><INDENT>conf_opts = [o for o, m in self[section].defaults_() if m.conf_arg]<EOL>if not conf_opts:<EOL><INDENT>continue<EOL><DEDENT>conf_dict[section] = {}<EOL>for opt in conf_opts:<EOL><INDENT>conf_dict[section][opt] = (self[section][opt] if update else<EOL>self[section].def_[opt].default)<EOL><DEDENT><DEDENT>with path.open('<STR_LIT:w>') as cfile:<EOL><INDENT>toml.dump(conf_dict, cfile)<EOL><DEDENT>", "docstring": "Create config file.\n\n        Create config file in :attr:`config_files_[index]`.\n\n        Parameters:\n            index(int): index of config file.\n            update (bool): if set to True and :attr:`config_files_` already\n                exists, its content is read and all the options it sets are\n                kept in the produced config file.", "id": "f2102:c2:m15"}
{"signature": "def reset_(self):", "body": "for sct, opt, meta in self.defaults_():<EOL><INDENT>self[sct][opt] = meta.default<EOL><DEDENT>", "docstring": "Restore default values of all options.", "id": "f2102:c2:m14"}
{"signature": "@classmethod<EOL><INDENT>def from_dict_(cls, conf_dict):<DEDENT>", "body": "return cls(**{name: Section(**opts)<EOL>for name, opts in conf_dict.items()})<EOL>", "docstring": "Use a dictionary to create a :class:`ConfigurationManager`.\n\n        Args:\n            conf_dict (dict of dict of :class:`ConfOpt`): the first level of\n                keys should be the section names. The second level should be\n                the option names. The values are the options metadata.\n\n        Returns:\n            :class:`ConfigurationManager`: a configuration manager with the\n            requested sections and options.", "id": "f2102:c2:m1"}
{"signature": "def _cmd_opts_solver(self, cmd_name):", "body": "sections = self.sections_list(cmd_name)<EOL>cmd_dict = self._opt_cmds[cmd_name] if cmd_name else self._opt_bare<EOL>for sct in reversed(sections):<EOL><INDENT>for opt, opt_meta in self._conf[sct].def_.items():<EOL><INDENT>if not opt_meta.cmd_arg:<EOL><INDENT>continue<EOL><DEDENT>if opt not in cmd_dict:<EOL><INDENT>cmd_dict[opt] = sct<EOL><DEDENT>else:<EOL><INDENT>warnings.warn(<EOL>'<STR_LIT>'.format(<EOL>cmd_name, sct, opt, cmd_dict[opt]),<EOL>error.LoamWarning, stacklevel=<NUM_LIT:4>)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Scan options related to one command and enrich _opt_cmds.", "id": "f2103:c1:m5"}
{"signature": "def _build_parser(self):", "body": "main_parser = argparse.ArgumentParser(description=self.common.help,<EOL>prefix_chars='<STR_LIT>')<EOL>self._add_options_to_parser(self._opt_bare, main_parser)<EOL>main_parser.set_defaults(**self.common.defaults)<EOL>if self.bare is not None:<EOL><INDENT>main_parser.set_defaults(**self.bare.defaults)<EOL><DEDENT>subparsers = main_parser.add_subparsers(dest='<STR_LIT>')<EOL>for cmd_name, meta in self.subcmds.items():<EOL><INDENT>kwargs = {'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': meta.help}<EOL>dummy_parser = subparsers.add_parser(cmd_name, **kwargs)<EOL>self._add_options_to_parser(self._opt_cmds[cmd_name], dummy_parser)<EOL>dummy_parser.set_defaults(**meta.defaults)<EOL><DEDENT>return main_parser<EOL>", "docstring": "Build command line argument parser.\n\n        Returns:\n            :class:`argparse.ArgumentParser`: the command line argument parser.\n            You probably won't need to use it directly. To parse command line\n            arguments and update the :class:`ConfigurationManager` instance\n            accordingly, use the :meth:`parse_args` method.", "id": "f2103:c1:m7"}
{"signature": "def _zsh_comp_command(self, zcf, cmd, grouping, add_help=True):", "body": "if add_help:<EOL><INDENT>if grouping:<EOL><INDENT>print(\"<STR_LIT>\", end=BLK, file=zcf)<EOL><DEDENT>print(\"<STR_LIT>\", end=BLK, file=zcf)<EOL>print(\"<STR_LIT>\", end=BLK, file=zcf)<EOL><DEDENT>no_comp = ('<STR_LIT:store_true>', '<STR_LIT>')<EOL>cmd_dict = self._opt_cmds[cmd] if cmd else self._opt_bare<EOL>for opt, sct in cmd_dict.items():<EOL><INDENT>meta = self._conf[sct].def_[opt]<EOL>if meta.cmd_kwargs.get('<STR_LIT:action>') == '<STR_LIT>':<EOL><INDENT>grpfmt, optfmt = \"<STR_LIT>\", \"<STR_LIT>\"<EOL>if meta.comprule is None:<EOL><INDENT>meta.comprule = '<STR_LIT>'<EOL><DEDENT><DEDENT>else:<EOL><INDENT>grpfmt, optfmt = \"<STR_LIT>\", \"<STR_LIT>\"<EOL><DEDENT>if meta.cmd_kwargs.get('<STR_LIT:action>') in no_compor meta.cmd_kwargs.get('<STR_LIT>') == <NUM_LIT:0>:<EOL><INDENT>meta.comprule = None<EOL><DEDENT>if meta.comprule is None:<EOL><INDENT>compstr = '<STR_LIT>'<EOL><DEDENT>elif meta.comprule == '<STR_LIT>':<EOL><INDENT>optfmt = optfmt.split('<STR_LIT:[>')<EOL>optfmt = optfmt[<NUM_LIT:0>] + '<STR_LIT>' + optfmt[<NUM_LIT:1>]<EOL>compstr = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>optfmt = optfmt.split('<STR_LIT:[>')<EOL>optfmt = optfmt[<NUM_LIT:0>] + '<STR_LIT>' + optfmt[<NUM_LIT:1>]<EOL>compstr = '<STR_LIT>'.format(meta.comprule)<EOL><DEDENT>if grouping:<EOL><INDENT>print(grpfmt.format(opt), end=BLK, file=zcf)<EOL><DEDENT>for name in _names(self._conf[sct], opt):<EOL><INDENT>print(optfmt.format(name, meta.help.replace(\"<STR_LIT:'>\", \"<STR_LIT>\"),<EOL>compstr), end=BLK, file=zcf)<EOL><DEDENT><DEDENT>", "docstring": "Write zsh _arguments compdef for a given command.\n\n        Args:\n            zcf (file): zsh compdef file.\n            cmd (str): command name, set to None or '' for bare command.\n            grouping (bool): group options (zsh>=5.4).\n            add_help (bool): add an help option.", "id": "f2103:c1:m9"}
{"signature": "def config_conf_section():", "body": "config_dict = OrderedDict((<EOL>('<STR_LIT>',<EOL>ConfOpt(None, True, None, {'<STR_LIT:action>': '<STR_LIT:store_true>'},<EOL>False, '<STR_LIT>')),<EOL>('<STR_LIT>',<EOL>ConfOpt(None, True, None, {'<STR_LIT:action>': '<STR_LIT:store_true>'},<EOL>False, '<STR_LIT>')),<EOL>('<STR_LIT>',<EOL>ConfOpt(None, True, None, {'<STR_LIT:action>': '<STR_LIT:store_true>'},<EOL>False, '<STR_LIT>')),<EOL>('<STR_LIT>',<EOL>ConfOpt(None, True, None, {'<STR_LIT:action>': '<STR_LIT:store_true>'},<EOL>False, '<STR_LIT>')),<EOL>('<STR_LIT>',<EOL>ConfOpt('<STR_LIT>', False, None, {}, True, '<STR_LIT>')),<EOL>))<EOL>return config_dict<EOL>", "docstring": "Define a configuration section handling config file.\n\n    Returns:\n        dict of ConfOpt: it defines the 'create', 'update', 'edit' and 'editor'\n        configuration options.", "id": "f2106:m1"}
{"signature": "def set_conf_opt(shortname=None):", "body": "return ConfOpt(None, True, shortname,<EOL>dict(action='<STR_LIT>', metavar='<STR_LIT>'),<EOL>False, '<STR_LIT>')<EOL>", "docstring": "Define a Confopt to set a config option.\n\n    You can feed the value of this option to :func:`set_conf_str`.\n\n    Args:\n        shortname (str): shortname for the option if relevant.\n\n    Returns:\n        :class:`~loam.manager.ConfOpt`: the option definition.", "id": "f2106:m2"}
{"signature": "def __init__(self, option):", "body": "self.option = option<EOL>super().__init__('<STR_LIT>'.format(option))<EOL>", "docstring": "Initialization of instances:\n\n        Args:\n            option (str): invalid subcommand name.\n\n        Attributes:\n            option (str): invalid subcommand name.", "id": "f2107:c4:m0"}
{"signature": "def with_temp_dir(f):", "body": "@wraps(f)<EOL>def wrapped(*args, **kwargs):<EOL><INDENT>with TemporaryDirectory() as temp_dir:<EOL><INDENT>return f(*args, temp_dir=temp_dir, **kwargs)<EOL><DEDENT><DEDENT>return wrapped<EOL>", "docstring": "A wrapper that creates and deletes a temporary directory.", "id": "f2120:m0"}
{"signature": "def apply_options(self, cmd, options=()):", "body": "for option in (self.default_cmd_options + options):<EOL><INDENT>cmd = self.apply_option(cmd, option,<EOL>active=getattr(self, option, False))<EOL><DEDENT>return cmd<EOL>", "docstring": "Apply command-line options.", "id": "f2122:c0:m5"}
{"signature": "def initialize_options(self):", "body": "self.all = False<EOL>self.coverage = False<EOL>super(test, self).initialize_options()<EOL>", "docstring": "Set the default options.", "id": "f2122:c2:m0"}
{"signature": "def initialize_options(self):", "body": "self.branch = '<STR_LIT>'<EOL>self.fix = False<EOL>super(lint, self).initialize_options()<EOL>", "docstring": "Set the default options.", "id": "f2122:c1:m0"}
{"signature": "def finalize_options(self):", "body": "<EOL>self.verbose = bool(self.verbose)<EOL>", "docstring": "Override the distutils abstract method.", "id": "f2122:c0:m2"}
{"signature": "def open_file(filename):", "body": "with open(filename) as f:<EOL><INDENT>return f.read()<EOL><DEDENT>", "docstring": "Open and read the file *filename*.", "id": "f2123:m0"}
{"signature": "def get_system_config_dirs(app_name, app_author, force_xdg=True):", "body": "if WIN:<EOL><INDENT>folder = os.environ.get('<STR_LIT>')<EOL>return [os.path.join(folder, app_author, app_name)]<EOL><DEDENT>if MAC and not force_xdg:<EOL><INDENT>return [os.path.join('<STR_LIT>', app_name)]<EOL><DEDENT>dirs = os.environ.get('<STR_LIT>', '<STR_LIT>')<EOL>paths = [os.path.expanduser(x) for x in dirs.split(os.pathsep)]<EOL>return [os.path.join(d, _pathify(app_name)) for d in paths]<EOL>", "docstring": "r\"\"\"Returns a list of system-wide config folders for the application.\n\n    For an example application called ``\"My App\"`` by ``\"Acme\"``,\n    something like the following folders could be returned:\n\n    macOS (non-XDG):\n      ``['/Library/Application Support/My App']``\n    Mac OS X (XDG):\n      ``['/etc/xdg/my-app']``\n    Unix:\n      ``['/etc/xdg/my-app']``\n    Windows 7:\n      ``['C:\\ProgramData\\Acme\\My App']``\n\n    :param app_name: the application name. This should be properly capitalized\n                     and can contain whitespace.\n    :param app_author: The app author's name (or company). This should be\n                       properly capitalized and can contain whitespace.\n    :param force_xdg: if this is set to `True`, then on macOS the XDG Base\n                      Directory Specification will be followed. Has no effect\n                      on non-macOS systems.", "id": "f2124:m1"}
{"signature": "def additional_files(self):", "body": "return [os.path.join(f, self.filename) for f in self.additional_dirs]<EOL>", "docstring": "Get a list of absolute paths to the additional config files.", "id": "f2124:c2:m5"}
{"signature": "def get_user_config_dir(app_name, app_author, roaming=True, force_xdg=True):", "body": "if WIN:<EOL><INDENT>key = '<STR_LIT>' if roaming else '<STR_LIT>'<EOL>folder = os.path.expanduser(os.environ.get(key, '<STR_LIT>'))<EOL>return os.path.join(folder, app_author, app_name)<EOL><DEDENT>if MAC and not force_xdg:<EOL><INDENT>return os.path.join(os.path.expanduser(<EOL>'<STR_LIT>'), app_name)<EOL><DEDENT>return os.path.join(<EOL>os.path.expanduser(os.environ.get('<STR_LIT>', '<STR_LIT>')),<EOL>_pathify(app_name))<EOL>", "docstring": "Returns the config folder for the application.  The default behavior\n    is to return whatever is most appropriate for the operating system.\n\n    For an example application called ``\"My App\"`` by ``\"Acme\"``,\n    something like the following folders could be returned:\n\n    macOS (non-XDG):\n      ``~/Library/Application Support/My App``\n    Mac OS X (XDG):\n      ``~/.config/my-app``\n    Unix:\n      ``~/.config/my-app``\n    Windows 7 (roaming):\n      ``C:\\\\Users\\<user>\\AppData\\Roaming\\Acme\\My App``\n    Windows 7 (not roaming):\n      ``C:\\\\Users\\<user>\\AppData\\Local\\Acme\\My App``\n\n    :param app_name: the application name. This should be properly capitalized\n                     and can contain whitespace.\n    :param app_author: The app author's name (or company). This should be\n                       properly capitalized and can contain whitespace.\n    :param roaming: controls if the folder should be roaming or not on Windows.\n                    Has no effect on non-Windows systems.\n    :param force_xdg: if this is set to `True`, then on macOS the XDG Base\n                      Directory Specification will be followed. Has no effect\n                      on non-macOS systems.", "id": "f2124:m0"}
{"signature": "def format_output(self, data, headers, format_name=None,<EOL>preprocessors=(), column_types=None, **kwargs):", "body": "format_name = format_name or self._format_name<EOL>if format_name not in self.supported_formats:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(format_name))<EOL><DEDENT>(_, _preprocessors, formatter,<EOL>fkwargs) = self._output_formats[format_name]<EOL>fkwargs.update(kwargs)<EOL>if column_types is None:<EOL><INDENT>data = list(data)<EOL>column_types = self._get_column_types(data)<EOL><DEDENT>for f in unique_items(preprocessors + _preprocessors):<EOL><INDENT>data, headers = f(data, headers, column_types=column_types,<EOL>**fkwargs)<EOL><DEDENT>return formatter(list(data), headers, column_types=column_types, **fkwargs)<EOL>", "docstring": "Format the headers and data using a specific formatter.\n\n        *format_name* must be a supported formatter (see\n        :attr:`supported_formats`).\n\n        :param iterable data: An :term:`iterable` (e.g. list) of rows.\n        :param iterable headers: The column headers.\n        :param str format_name: The display format to use (optional, if the\n            :class:`TabularOutputFormatter` object has a default format set).\n        :param tuple preprocessors: Additional preprocessors to call before\n                                    any formatter preprocessors.\n        :param \\*\\*kwargs: Optional arguments for the formatter.\n        :return: The formatted data.\n        :rtype: str\n        :raises ValueError: If the *format_name* is not recognized.", "id": "f2126:c0:m5"}
{"signature": "def _get_type(self, value):", "body": "if value is None:<EOL><INDENT>return type(None)<EOL><DEDENT>elif type(value) in int_types:<EOL><INDENT>return int<EOL><DEDENT>elif type(value) in float_types:<EOL><INDENT>return float<EOL><DEDENT>elif isinstance(value, binary_type):<EOL><INDENT>return binary_type<EOL><DEDENT>else:<EOL><INDENT>return text_type<EOL><DEDENT>", "docstring": "Get the data type for *value*.", "id": "f2126:c0:m8"}
{"signature": "def style_output(data, headers, style=None,<EOL>header_token='<STR_LIT>',<EOL>odd_row_token='<STR_LIT>',<EOL>even_row_token='<STR_LIT>', **_):", "body": "if style and HAS_PYGMENTS:<EOL><INDENT>formatter = Terminal256Formatter(style=style)<EOL>def style_field(token, field):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>s = StringIO()<EOL>formatter.format(((token, field),), s)<EOL>return s.getvalue()<EOL><DEDENT>headers = [style_field(header_token, header) for header in headers]<EOL>data = ([style_field(odd_row_token if i % <NUM_LIT:2> else even_row_token, f)<EOL>for f in r] for i, r in enumerate(data, <NUM_LIT:1>))<EOL><DEDENT>return iter(data), headers<EOL>", "docstring": "Style the *data* and *headers* (e.g. bold, italic, and colors)\n\n    .. NOTE::\n        This requires the `Pygments <http://pygments.org/>`_ library to\n        be installed. You can install it with CLI Helpers as an extra::\n            $ pip install cli_helpers[styles]\n\n    Example usage::\n\n        from cli_helpers.tabular_output.preprocessors import style_output\n        from pygments.style import Style\n        from pygments.token import Token\n\n        class YourStyle(Style):\n            default_style = \"\"\n            styles = {\n                Token.Output.Header: 'bold #ansired',\n                Token.Output.OddRow: 'bg:#eee #111',\n                Token.Output.EvenRow: '#0f0'\n            }\n\n        headers = ('First Name', 'Last Name')\n        data = [['Fred', 'Roberts'], ['George', 'Smith']]\n\n        data, headers = style_output(data, headers, style=YourStyle)\n\n    :param iterable data: An :term:`iterable` (e.g. list) of rows.\n    :param iterable headers: The column headers.\n    :param str/pygments.style.Style style: A Pygments style. You can `create\n        your own styles <http://pygments.org/docs/styles/#creating-own-styles>`_.\n    :param str header_token: The token type to be used for the headers.\n    :param str odd_row_token: The token type to be used for odd rows.\n    :param str even_row_token: The token type to be used for even rows.\n    :return: The styled data and headers.\n    :rtype: tuple", "id": "f2131:m7"}
{"signature": "def convert_to_string(data, headers, **_):", "body": "return (([utils.to_string(v) for v in row] for row in data),<EOL>[utils.to_string(h) for h in headers])<EOL>", "docstring": "Convert all *data* and *headers* to strings.\n\n    Binary data that cannot be decoded is converted to a hexadecimal\n    representation via :func:`binascii.hexlify`.\n\n    :param iterable data: An :term:`iterable` (e.g. list) of rows.\n    :param iterable headers: The column headers.\n    :return: The processed data and headers.\n    :rtype: tuple", "id": "f2131:m1"}
{"signature": "def override_missing_value(data, headers, missing_value='<STR_LIT>', **_):", "body": "return (([missing_value if v is None else v for v in row] for row in data),<EOL>headers)<EOL>", "docstring": "Override missing values in the *data* with *missing_value*.\n\n    A missing value is any value that is :data:`None`.\n\n    :param iterable data: An :term:`iterable` (e.g. list) of rows.\n    :param iterable headers: The column headers.\n    :param missing_value: The default value to use for missing data.\n    :return: The processed data and headers.\n    :rtype: tuple", "id": "f2131:m2"}
{"signature": "def bytes_to_string(data, headers, **_):", "body": "return (([utils.bytes_to_string(v) for v in row] for row in data),<EOL>[utils.bytes_to_string(h) for h in headers])<EOL>", "docstring": "Convert all *data* and *headers* bytes to strings.\n\n    Binary data that cannot be decoded is converted to a hexadecimal\n    representation via :func:`binascii.hexlify`.\n\n    :param iterable data: An :term:`iterable` (e.g. list) of rows.\n    :param iterable headers: The column headers.\n    :return: The processed data and headers.\n    :rtype: tuple", "id": "f2131:m4"}
{"signature": "def _get_separator(num, sep_title, sep_character, sep_length):", "body": "left_divider_length = right_divider_length = sep_length<EOL>if isinstance(sep_length, tuple):<EOL><INDENT>left_divider_length, right_divider_length = sep_length<EOL><DEDENT>left_divider = sep_character * left_divider_length<EOL>right_divider = sep_character * right_divider_length<EOL>title = sep_title.format(n=num + <NUM_LIT:1>)<EOL>return \"<STR_LIT>\".format(<EOL>left_divider=left_divider, right_divider=right_divider, title=title)<EOL>", "docstring": "Get a row separator for row *num*.", "id": "f2133:m0"}
{"signature": "def adapter(data, headers, **kwargs):", "body": "keys = ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>return vertical_table(data, headers, **filter_dict_by_key(kwargs, keys))<EOL>", "docstring": "Wrap vertical table in a function for TabularOutputFormatter.", "id": "f2133:m3"}
{"signature": "def intlen(n):", "body": "pos = n.find('<STR_LIT:.>')<EOL>return len(n) if pos < <NUM_LIT:0> else pos<EOL>", "docstring": "Find the length of the integer part of a number *n*.", "id": "f2135:m3"}
{"signature": "def to_string(value):", "body": "if isinstance(value, binary_type):<EOL><INDENT>return bytes_to_string(value)<EOL><DEDENT>else:<EOL><INDENT>return text_type(value)<EOL><DEDENT>", "docstring": "Convert *value* to a string.", "id": "f2135:m1"}
{"signature": "def replace(s, replace):", "body": "for r in replace:<EOL><INDENT>s = s.replace(*r)<EOL><DEDENT>return s<EOL>", "docstring": "Replace multiple values in a string", "id": "f2135:m7"}
{"signature": "def delete_bytes(fobj, size, offset, BUFFER_SIZE=<NUM_LIT:2>**<NUM_LIT:16>):", "body": "locked = False<EOL>assert <NUM_LIT:0> < size<EOL>assert <NUM_LIT:0> <= offset<EOL>fobj.seek(<NUM_LIT:0>, <NUM_LIT:2>)<EOL>filesize = fobj.tell()<EOL>movesize = filesize - offset - size<EOL>assert <NUM_LIT:0> <= movesize<EOL>try:<EOL><INDENT>if movesize > <NUM_LIT:0>:<EOL><INDENT>fobj.flush()<EOL>try:<EOL><INDENT>import mmap<EOL>file_map = mmap.mmap(fobj.fileno(), filesize)<EOL>try:<EOL><INDENT>file_map.move(offset, offset + size, movesize)<EOL><DEDENT>finally:<EOL><INDENT>file_map.close()<EOL><DEDENT><DEDENT>except (ValueError, EnvironmentError, ImportError):<EOL><INDENT>locked = lock(fobj)<EOL>fobj.seek(offset + size)<EOL>buf = fobj.read(BUFFER_SIZE)<EOL>while buf:<EOL><INDENT>fobj.seek(offset)<EOL>fobj.write(buf)<EOL>offset += len(buf)<EOL>fobj.seek(offset + size)<EOL>buf = fobj.read(BUFFER_SIZE)<EOL><DEDENT><DEDENT><DEDENT>fobj.truncate(filesize - size)<EOL>fobj.flush()<EOL><DEDENT>finally:<EOL><INDENT>if locked:<EOL><INDENT>unlock(fobj)<EOL><DEDENT><DEDENT>", "docstring": "Delete size bytes of empty space starting at offset.\n\n    fobj must be an open file object, open rb+ or\n    equivalent. Mutagen tries to use mmap to resize the file, but\n    falls back to a significantly slower method if mmap fails.", "id": "f2171:m4"}
{"signature": "def insert_bytes(fobj, size, offset, BUFFER_SIZE=<NUM_LIT:2>**<NUM_LIT:16>):", "body": "assert <NUM_LIT:0> < size<EOL>assert <NUM_LIT:0> <= offset<EOL>locked = False<EOL>fobj.seek(<NUM_LIT:0>, <NUM_LIT:2>)<EOL>filesize = fobj.tell()<EOL>movesize = filesize - offset<EOL>fobj.write(b'<STR_LIT:\\x00>' * size)<EOL>fobj.flush()<EOL>try:<EOL><INDENT>try:<EOL><INDENT>import mmap<EOL>file_map = mmap.mmap(fobj.fileno(), filesize + size)<EOL>try:<EOL><INDENT>file_map.move(offset + size, offset, movesize)<EOL><DEDENT>finally:<EOL><INDENT>file_map.close()<EOL><DEDENT><DEDENT>except (ValueError, EnvironmentError, ImportError):<EOL><INDENT>locked = lock(fobj)<EOL>fobj.truncate(filesize)<EOL>fobj.seek(<NUM_LIT:0>, <NUM_LIT:2>)<EOL>padsize = size<EOL>while padsize:<EOL><INDENT>addsize = min(BUFFER_SIZE, padsize)<EOL>fobj.write(b\"<STR_LIT:\\x00>\" * addsize)<EOL>padsize -= addsize<EOL><DEDENT>fobj.seek(filesize, <NUM_LIT:0>)<EOL>while movesize:<EOL><INDENT>thismove = min(BUFFER_SIZE, movesize)<EOL>fobj.seek(-thismove, <NUM_LIT:1>)<EOL>nextpos = fobj.tell()<EOL>data = fobj.read(thismove)<EOL>fobj.seek(-thismove + size, <NUM_LIT:1>)<EOL>fobj.write(data)<EOL>fobj.seek(nextpos)<EOL>movesize -= thismove<EOL><DEDENT>fobj.flush()<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>if locked:<EOL><INDENT>unlock(fobj)<EOL><DEDENT><DEDENT>", "docstring": "Insert size bytes of empty space starting at offset.\n\n    fobj must be an open file object, open rb+ or\n    equivalent. Mutagen tries to use mmap to resize the file, but\n    falls back to a significantly slower method if mmap fails.", "id": "f2171:m3"}
{"signature": "def delete(filename):", "body": "OggSpeex(filename).delete()<EOL>", "docstring": "Remove tags from a file.", "id": "f2172:m0"}
{"signature": "def as_dict(self):", "body": "d = {}<EOL>for key, value in self._internal:<EOL><INDENT>d.setdefault(key, []).append(value)<EOL><DEDENT>return d<EOL>", "docstring": "Return a copy of the comment data in a real dict.", "id": "f2173:c4:m8"}
{"signature": "def __getitem__(self, key):", "body": "values = [value for (k, value) in self._internal if k == key]<EOL>if not values:<EOL><INDENT>raise KeyError(key)<EOL><DEDENT>else:<EOL><INDENT>return values<EOL><DEDENT>", "docstring": "A list of values for the key.\n\n        This is a copy, so comment['title'].append('a title') will not\n        work.", "id": "f2173:c4:m3"}
{"signature": "@classmethod<EOL><INDENT>def RegisterTXXXKey(cls, key, desc):<DEDENT>", "body": "frameid = \"<STR_LIT>\" + desc<EOL>def getter(id3, key):<EOL><INDENT>return list(id3[frameid])<EOL><DEDENT>def setter(id3, key, value):<EOL><INDENT>try:<EOL><INDENT>frame = id3[frameid]<EOL><DEDENT>except KeyError:<EOL><INDENT>enc = <NUM_LIT:0><EOL>try:<EOL><INDENT>for v in value:<EOL><INDENT>v.encode('<STR_LIT>')<EOL><DEDENT><DEDENT>except UnicodeError:<EOL><INDENT>enc = <NUM_LIT:3><EOL><DEDENT>id3.add(mutagen.id3.TXXX(encoding=enc, text=value, desc=desc))<EOL><DEDENT>else:<EOL><INDENT>frame.text = value<EOL><DEDENT><DEDENT>def deleter(id3, key):<EOL><INDENT>del(id3[frameid])<EOL><DEDENT>cls.RegisterKey(key, getter, setter, deleter)<EOL>", "docstring": "Register a user-defined text frame key.\n\n        Some ID3 tags are stored in TXXX frames, which allow a\n        freeform 'description' which acts as a subkey,\n        e.g. TXXX:BARCODE.::\n\n            EasyID3.RegisterTXXXKey('barcode', 'BARCODE').", "id": "f2175:c1:m2"}
{"signature": "@property<EOL><INDENT>def FrameID(self):<DEDENT>", "body": "return type(self).__name__<EOL>", "docstring": "ID3v2 three or four character frame ID", "id": "f2176:c0:m3"}
{"signature": "def _get_v23_frame(self, **kwargs):", "body": "new_kwargs = {}<EOL>for checker in self._framespec:<EOL><INDENT>name = checker.name<EOL>value = getattr(self, name)<EOL>new_kwargs[name] = checker._validate23(self, value, **kwargs)<EOL><DEDENT>return type(self)(**new_kwargs)<EOL>", "docstring": "Returns a frame copy which is suitable for writing into a v2.3 tag.\n\n        kwargs get passed to the specs.", "id": "f2176:c0:m1"}
{"signature": "def clear_pictures(self):", "body": "blocks = [b for b in self.metadata_blocks if b.code != Picture.code]<EOL>self.metadata_blocks = blocks<EOL>", "docstring": "Delete all pictures from the file.", "id": "f2177:c14:m7"}
{"signature": "def load(self, filename):", "body": "self.metadata_blocks = []<EOL>self.tags = None<EOL>self.cuesheet = None<EOL>self.seektable = None<EOL>self.filename = filename<EOL>fileobj = StrictFileObject(open(filename, \"<STR_LIT:rb>\"))<EOL>try:<EOL><INDENT>self.__check_header(fileobj)<EOL>while self.__read_metadata_block(fileobj):<EOL><INDENT>pass<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>fileobj.close()<EOL><DEDENT>try:<EOL><INDENT>self.metadata_blocks[<NUM_LIT:0>].length<EOL><DEDENT>except (AttributeError, IndexError):<EOL><INDENT>raise FLACNoHeaderError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Load file information from a filename.", "id": "f2177:c14:m4"}
{"signature": "def add_tags(self):", "body": "if self.tags is None:<EOL><INDENT>self.tags = VCFLACDict()<EOL>self.metadata_blocks.append(self.tags)<EOL><DEDENT>else:<EOL><INDENT>raise FLACVorbisError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Add a Vorbis comment block to the file.", "id": "f2177:c14:m2"}
{"signature": "def __iter__(self):", "body": "return iter(text_type(self).split(u\"<STR_LIT>\"))<EOL>", "docstring": "Iterate over the strings of the value (not the characters)", "id": "f2180:c8:m0"}
{"signature": "def delete(filename):", "body": "try:<EOL><INDENT>APEv2(filename).delete()<EOL><DEDENT>except APENoHeaderError:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Remove tags from a file.", "id": "f2180:m1"}
{"signature": "def APEValue(value, kind):", "body": "if kind in (TEXT, EXTERNAL):<EOL><INDENT>if not isinstance(value, text_type):<EOL><INDENT>if PY3:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>value = value.encode(\"<STR_LIT:utf-8>\")<EOL><DEDENT><DEDENT>if kind == TEXT:<EOL><INDENT>return APETextValue(value, kind)<EOL><DEDENT>elif kind == BINARY:<EOL><INDENT>return APEBinaryValue(value, kind)<EOL><DEDENT>elif kind == EXTERNAL:<EOL><INDENT>return APEExtValue(value, kind)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "APEv2 tag value factory.\n\n    Use this if you need to specify the value's type manually.  Binary\n    and text data are automatically detected by APEv2.__setitem__.", "id": "f2180:m2"}
{"signature": "def save(self, filename=None):", "body": "raise NotImplementedError<EOL>", "docstring": "Save changes to a file.", "id": "f2183:c0:m2"}
{"signature": "def pprint(self):", "body": "stream = \"<STR_LIT>\" % (self.info.pprint(), self.mime[<NUM_LIT:0>])<EOL>try:<EOL><INDENT>tags = self.tags.pprint()<EOL><DEDENT>except AttributeError:<EOL><INDENT>return stream<EOL><DEDENT>else:<EOL><INDENT>return stream + ((tags and \"<STR_LIT:\\n>\" + tags) or \"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Print stream information and comment key=value pairs.", "id": "f2183:c1:m9"}
{"signature": "def update_to_v24(self):", "body": "self.__update_common()<EOL>if self.__unknown_version == self._V23:<EOL><INDENT>converted = []<EOL>for frame in self.unknown_frames:<EOL><INDENT>try:<EOL><INDENT>name, size, flags = unpack('<STR_LIT>', frame[:<NUM_LIT:10>])<EOL>frame = BinaryFrame.fromData(self, flags, frame[<NUM_LIT:10>:])<EOL><DEDENT>except (struct.error, error):<EOL><INDENT>continue<EOL><DEDENT>name = name.decode('<STR_LIT:ascii>')<EOL>converted.append(self.__save_frame(frame, name=name))<EOL><DEDENT>self.unknown_frames[:] = converted<EOL>self.__unknown_version = self._V24<EOL><DEDENT>try:<EOL><INDENT>date = text_type(self.get(\"<STR_LIT>\", \"<STR_LIT>\"))<EOL>if date.strip(u\"<STR_LIT:\\x00>\"):<EOL><INDENT>self.pop(\"<STR_LIT>\")<EOL>dat = text_type(self.get(\"<STR_LIT>\", \"<STR_LIT>\"))<EOL>if dat.strip(\"<STR_LIT:\\x00>\"):<EOL><INDENT>self.pop(\"<STR_LIT>\")<EOL>date = \"<STR_LIT>\" % (date, dat[<NUM_LIT:2>:], dat[:<NUM_LIT:2>])<EOL>time = text_type(self.get(\"<STR_LIT>\", \"<STR_LIT>\"))<EOL>if time.strip(\"<STR_LIT:\\x00>\"):<EOL><INDENT>self.pop(\"<STR_LIT>\")<EOL>date += \"<STR_LIT>\" % (time[:<NUM_LIT:2>], time[<NUM_LIT:2>:])<EOL><DEDENT><DEDENT>if \"<STR_LIT>\" not in self:<EOL><INDENT>self.add(TDRC(encoding=<NUM_LIT:0>, text=date))<EOL><DEDENT><DEDENT><DEDENT>except UnicodeDecodeError:<EOL><INDENT>pass<EOL><DEDENT>if \"<STR_LIT>\" in self:<EOL><INDENT>f = self.pop(\"<STR_LIT>\")<EOL>if \"<STR_LIT>\" not in self:<EOL><INDENT>try:<EOL><INDENT>self.add(TDOR(encoding=<NUM_LIT:0>, text=str(f)))<EOL><DEDENT>except UnicodeDecodeError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>if \"<STR_LIT>\" in self:<EOL><INDENT>f = self.pop(\"<STR_LIT>\")<EOL>if \"<STR_LIT>\" not in self:<EOL><INDENT>self.add(TIPL(encoding=f.encoding, people=f.people))<EOL><DEDENT><DEDENT>for key in [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>if key in self:<EOL><INDENT>del(self[key])<EOL><DEDENT><DEDENT>", "docstring": "Convert older tags into an ID3v2.4 tag.\n\n        This updates old ID3v2 frames to ID3v2.4 ones (e.g. TYER to\n        TDRC). If you intend to save tags, you must call this function\n        at some point; it is called by default when loading the tag.", "id": "f2184:c0:m19"}
{"signature": "def load(self, filename, ID3=None, **kwargs):", "body": "if ID3 is None:<EOL><INDENT>ID3 = self.ID3<EOL><DEDENT>else:<EOL><INDENT>self.ID3 = ID3<EOL><DEDENT>self.filename = filename<EOL>try:<EOL><INDENT>self.tags = ID3(filename, **kwargs)<EOL><DEDENT>except error:<EOL><INDENT>self.tags = None<EOL><DEDENT>if self.tags is not None:<EOL><INDENT>try:<EOL><INDENT>offset = self.tags.size<EOL><DEDENT>except AttributeError:<EOL><INDENT>offset = None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>offset = None<EOL><DEDENT>try:<EOL><INDENT>fileobj = open(filename, \"<STR_LIT:rb>\")<EOL>self.info = self._Info(fileobj, offset)<EOL><DEDENT>finally:<EOL><INDENT>fileobj.close()<EOL><DEDENT>", "docstring": "Load stream and tag information from a file.\n\n        A custom tag reader may be used in instead of the default\n        mutagen.id3.ID3 object, e.g. an EasyID3 reader.", "id": "f2184:c1:m2"}
{"signature": "def add(self, frame):", "body": "return self.loaded_frame(frame)<EOL>", "docstring": "Add a frame to the tag.", "id": "f2184:c0:m8"}
{"signature": "def __update_common(self):", "body": "if \"<STR_LIT>\" in self:<EOL><INDENT>self[\"<STR_LIT>\"].genres = self[\"<STR_LIT>\"].genres<EOL><DEDENT>if self.version < self._V23:<EOL><INDENT>pics = self.getall(\"<STR_LIT>\")<EOL>mimes = {\"<STR_LIT>\": \"<STR_LIT>\", \"<STR_LIT>\": \"<STR_LIT>\"}<EOL>self.delall(\"<STR_LIT>\")<EOL>for pic in pics:<EOL><INDENT>newpic = APIC(<EOL>encoding=pic.encoding, mime=mimes.get(pic.mime, pic.mime),<EOL>type=pic.type, desc=pic.desc, data=pic.data)<EOL>self.add(newpic)<EOL><DEDENT>self.delall(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Updates done by both v23 and v24 update", "id": "f2184:c0:m18"}
{"signature": "def setall(self, key, values):", "body": "self.delall(key)<EOL>for tag in values:<EOL><INDENT>self[tag.HashKey] = tag<EOL><DEDENT>", "docstring": "Delete frames of the given type and add frames in 'values'.", "id": "f2184:c0:m5"}
{"signature": "def pprint(self):", "body": "frames = sorted(Frame.pprint(s) for s in self.values())<EOL>return '<STR_LIT:\\n>'.join(frames)<EOL>", "docstring": "Return tags in a human-readable format.\n\n        \"Human-readable\" is used loosely here. The format is intended\n        to mirror that used for Vorbis or APEv2 output, e.g.\n\n            ``TIT2=My Title``\n\n        However, ID3 frames can have multiple keys:\n\n            ``POPM=user@example.org=3 128/255``", "id": "f2184:c0:m6"}
{"signature": "def delall(self, key):", "body": "if key in self:<EOL><INDENT>del(self[key])<EOL><DEDENT>else:<EOL><INDENT>key = key + \"<STR_LIT::>\"<EOL>for k in self.keys():<EOL><INDENT>if k.startswith(key):<EOL><INDENT>del(self[k])<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Delete all tags of a given kind; see getall.", "id": "f2184:c0:m4"}
{"signature": "def load(self, filename, known_frames=None, translate=True, v2_version=<NUM_LIT:4>):", "body": "if not v2_version in (<NUM_LIT:3>, <NUM_LIT:4>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>from os.path import getsize<EOL>self.filename = filename<EOL>self.__known_frames = known_frames<EOL>self._fileobj = open(filename, '<STR_LIT:rb>')<EOL>self.__filesize = getsize(filename)<EOL>try:<EOL><INDENT>try:<EOL><INDENT>self._load_header()<EOL><DEDENT>except EOFError:<EOL><INDENT>self.size = <NUM_LIT:0><EOL>raise ID3NoHeaderError(\"<STR_LIT>\" % (<EOL>filename, self.__filesize))<EOL><DEDENT>except (ID3NoHeaderError, ID3UnsupportedVersionError) as err:<EOL><INDENT>self.size = <NUM_LIT:0><EOL>import sys<EOL>stack = sys.exc_info()[<NUM_LIT:2>]<EOL>try:<EOL><INDENT>self._fileobj.seek(-<NUM_LIT>, <NUM_LIT:2>)<EOL><DEDENT>except EnvironmentError:<EOL><INDENT>reraise(err, None, stack)<EOL><DEDENT>else:<EOL><INDENT>frames = ParseID3v1(self._fileobj.read(<NUM_LIT>))<EOL>if frames is not None:<EOL><INDENT>self.version = self._V11<EOL>for v in frames.values():<EOL><INDENT>self.add(v)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>reraise(err, None, stack)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>frames = self.__known_frames<EOL>if frames is None:<EOL><INDENT>if self._V23 <= self.version:<EOL><INDENT>frames = Frames<EOL><DEDENT>elif self._V22 <= self.version:<EOL><INDENT>frames = Frames_2_2<EOL><DEDENT><DEDENT>data = self.__fullread(self.size - <NUM_LIT:10>)<EOL>for frame in self.__read_frames(data, frames=frames):<EOL><INDENT>if isinstance(frame, Frame):<EOL><INDENT>self.add(frame)<EOL><DEDENT>else:<EOL><INDENT>self.unknown_frames.append(frame)<EOL><DEDENT><DEDENT>self.__unknown_version = self.version<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>self._fileobj.close()<EOL>del self._fileobj<EOL>del self.__filesize<EOL>if translate:<EOL><INDENT>if v2_version == <NUM_LIT:3>:<EOL><INDENT>self.update_to_v23()<EOL><DEDENT>else:<EOL><INDENT>self.update_to_v24()<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Load tags from a filename.\n\n        Keyword arguments:\n\n        * filename -- filename to load tag data from\n        * known_frames -- dict mapping frame IDs to Frame objects\n        * translate -- Update all tags to ID3v2.3/4 internally. If you\n                       intend to save, this must be true or you have to\n                       call update_to_v23() / update_to_v24() manually.\n        * v2_version -- if update_to_v23 or update_to_v24 get called (3 or 4)\n\n        Example of loading a custom frame::\n\n            my_frames = dict(mutagen.id3.Frames)\n            class XMYF(Frame): ...\n            my_frames[\"XMYF\"] = XMYF\n            mutagen.id3.ID3(filename, known_frames=my_frames)", "id": "f2184:c0:m2"}
{"signature": "def delete(self, filename=None):", "body": "if filename is None:<EOL><INDENT>filename = self.filename<EOL><DEDENT>self.tags.clear()<EOL>fileobj = open(filename, \"<STR_LIT>\")<EOL>try:<EOL><INDENT>try:<EOL><INDENT>self.tags._inject(fileobj)<EOL><DEDENT>except error as e:<EOL><INDENT>reraise(self._Error, e, sys.exc_info()[<NUM_LIT:2>])<EOL><DEDENT>except EOFError:<EOL><INDENT>raise self._Error(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>fileobj.close()<EOL><DEDENT>", "docstring": "Remove tags from a file.\n\n        If no filename is given, the one most recently loaded is used.", "id": "f2186:c2:m1"}
{"signature": "def load(self, filename):", "body": "self.filename = filename<EOL>fileobj = open(filename, \"<STR_LIT:rb>\")<EOL>try:<EOL><INDENT>try:<EOL><INDENT>self.info = self._Info(fileobj)<EOL>self.tags = self._Tags(fileobj, self.info)<EOL>self.info._post_tags(fileobj)<EOL><DEDENT>except error as e:<EOL><INDENT>reraise(self._Error, e, sys.exc_info()[<NUM_LIT:2>])<EOL><DEDENT>except EOFError:<EOL><INDENT>raise self._Error(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>fileobj.close()<EOL><DEDENT>", "docstring": "Load file information from a filename.", "id": "f2186:c2:m0"}
{"signature": "def __eq__(self, other):", "body": "try:<EOL><INDENT>return (self.write() == other.write())<EOL><DEDENT>except AttributeError:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Two Ogg pages are the same if they write the same data.", "id": "f2186:c1:m1"}
{"signature": "@staticmethod<EOL><INDENT>def to_packets(pages, strict=False):<DEDENT>", "body": "serial = pages[<NUM_LIT:0>].serial<EOL>sequence = pages[<NUM_LIT:0>].sequence<EOL>packets = []<EOL>if strict:<EOL><INDENT>if pages[<NUM_LIT:0>].continued:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not pages[-<NUM_LIT:1>].complete:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>elif pages and pages[<NUM_LIT:0>].continued:<EOL><INDENT>packets.append([b\"<STR_LIT>\"])<EOL><DEDENT>for page in pages:<EOL><INDENT>if serial != page.serial:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % page)<EOL><DEDENT>elif sequence != page.sequence:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % page)<EOL><DEDENT>else:<EOL><INDENT>sequence += <NUM_LIT:1><EOL><DEDENT>if page.continued:<EOL><INDENT>packets[-<NUM_LIT:1>].append(page.packets[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>packets.append([page.packets[<NUM_LIT:0>]])<EOL><DEDENT>packets.extend([p] for p in page.packets[<NUM_LIT:1>:])<EOL><DEDENT>return [b\"<STR_LIT>\".join(p) for p in packets]<EOL>", "docstring": "Construct a list of packet data from a list of Ogg pages.\n\n        If strict is true, the first page must start a new packet,\n        and the last page must end the last packet.", "id": "f2186:c1:m7"}
{"signature": "def save(self, filename=None):", "body": "if filename is None:<EOL><INDENT>filename = self.filename<EOL><DEDENT>fileobj = open(filename, \"<STR_LIT>\")<EOL>try:<EOL><INDENT>try:<EOL><INDENT>self.tags._inject(fileobj)<EOL><DEDENT>except error as e:<EOL><INDENT>reraise(self._Error, e, sys.exc_info()[<NUM_LIT:2>])<EOL><DEDENT>except EOFError:<EOL><INDENT>raise self._Error(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>fileobj.close()<EOL><DEDENT>", "docstring": "Save a tag to a file.\n\n        If no filename is given, the one most recently loaded is used.", "id": "f2186:c2:m2"}
{"signature": "def delete(filename):", "body": "OggOpus(filename).delete()<EOL>", "docstring": "Remove tags from a file.", "id": "f2191:m0"}
{"signature": "def as_dict(self):", "body": "d = {}<EOL>for key, value in self._internal:<EOL><INDENT>d.setdefault(key.lower(), []).append(value)<EOL><DEDENT>return d<EOL>", "docstring": "Return a copy of the comment data in a real dict.", "id": "f2192:c4:m9"}
{"signature": "def __update_parents(self, fileobj, path, delta):", "body": "for atom in path:<EOL><INDENT>fileobj.seek(atom.offset)<EOL>size = cdata.uint_be(fileobj.read(<NUM_LIT:4>))<EOL>if size == <NUM_LIT:1>:  <EOL><INDENT>size = cdata.ulonglong_be(fileobj.read(<NUM_LIT:12>)[<NUM_LIT:4>:])<EOL>fileobj.seek(atom.offset + <NUM_LIT:8>)<EOL>fileobj.write(cdata.to_ulonglong_be(size + delta))<EOL><DEDENT>else:  <EOL><INDENT>fileobj.seek(atom.offset)<EOL>fileobj.write(cdata.to_uint_be(size + delta))<EOL><DEDENT><DEDENT>", "docstring": "Update all parent atoms with the new size.", "id": "f2193:c8:m7"}
{"signature": "def path(self, *names):", "body": "path = [self]<EOL>for name in names:<EOL><INDENT>path.append(path[-<NUM_LIT:1>][name, ])<EOL><DEDENT>return path[<NUM_LIT:1>:]<EOL>", "docstring": "Look up and return the complete path of an atom.\n\n        For example, atoms.path('moov', 'udta', 'meta') will return a\n        list of three atoms, corresponding to the moov, udta, and meta\n        atoms.", "id": "f2193:c7:m1"}
{"signature": "def findall(self, name, recursive=False):", "body": "if self.children is not None:<EOL><INDENT>for child in self.children:<EOL><INDENT>if child.name == name:<EOL><INDENT>yield child<EOL><DEDENT>if recursive:<EOL><INDENT>for atom in child.findall(name, True):<EOL><INDENT>yield atom<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Recursively find all child atoms by specified name.", "id": "f2193:c6:m2"}
{"signature": "@lru_cache(maxsize=<NUM_LIT:200>)<EOL><INDENT>def selectPolicy(self, origin, request_method=None):<DEDENT>", "body": "ret_origin = None<EOL>policyname = None<EOL>if self.matchstrategy in (\"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>for pol in self.activepolicies:<EOL><INDENT>policy=self.policies[pol]<EOL>ret_origin = None<EOL>policyname = policy.name<EOL>if policyname == \"<STR_LIT>\":<EOL><INDENT>break<EOL><DEDENT>if self.matchstrategy == \"<STR_LIT>\":<EOL><INDENT>if policy.methods != \"<STR_LIT:*>\" and not CORS.matchlist(request_method, policy.methods, case_sensitive=True):<EOL><INDENT>continue<EOL><DEDENT><DEDENT>if origin and policy.match:<EOL><INDENT>if CORS.matchlist(origin, policy.match):<EOL><INDENT>ret_origin = origin<EOL><DEDENT><DEDENT>elif policy.origin == \"<STR_LIT>\":<EOL><INDENT>ret_origin = origin<EOL><DEDENT>elif policy.origin:<EOL><INDENT>ret_origin = policy.origin<EOL><DEDENT>if ret_origin:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>return policyname, ret_origin<EOL>", "docstring": "Based on the matching strategy and the origin and optionally the requested method a tuple of policyname and origin to pass back is returned.", "id": "f2201:c0:m3"}
{"signature": "def non_preflight_are_not_answered(corsed, hdr):", "body": "req = prepRequest(hdr)<EOL>res = req.get_response(corsed)<EOL>assert res.body.decode(\"<STR_LIT:utf-8>\") == \"<STR_LIT>\", \"<STR_LIT>\" % res.body<EOL>", "docstring": "requests that don't match preflight criteria are ignored", "id": "f2203:m4"}
{"signature": "def post_process(func):", "body": "@wraps(func)<EOL>def wrapper(*args, **kwargs):<EOL><INDENT>res = func(*args, **kwargs)<EOL>project_command = args[<NUM_LIT:0>]<EOL>project_handler = project_command.vcp.project_handler<EOL>if not project_handler:<EOL><INDENT>return res<EOL><DEDENT>kwargs['<STR_LIT>'] = res<EOL>getattr(project_handler, func.__name__)(**kwargs)<EOL>return res<EOL><DEDENT>return wrapper<EOL>", "docstring": "Calls the project handler same named function\n\n    Note: the project handler may add some extra arguments to the command,\n          so when use this decorator, add **kwargs to the end of the arguments", "id": "f2213:m0"}
{"signature": "@abstractmethod<EOL><INDENT>def install_to(self, project, env):<DEDENT>", "body": "pass<EOL>", "docstring": "Install current (self.project) project to the argument one.\n\n        Args:\n            project (Project): the target project\n            env (EnvironmentBase): the target environment\n\n        Returns:\n            True if the install is succeeded, else False", "id": "f2217:c1:m2"}
{"signature": "def publish(self):", "body": "with open( self.file_name, '<STR_LIT:w>') as fh:<EOL><INDENT>for k,v in self.args.iteritems():<EOL><INDENT>buf = StringIO.StringIO()<EOL>buf.write(k)<EOL>self._append_vals(buf,v)<EOL>fh.write(buf.getvalue() + '<STR_LIT:\\n>')<EOL>buf.close()<EOL><DEDENT><DEDENT>", "docstring": "Write output file.", "id": "f2233:c0:m3"}
{"signature": "def _post_unpack(self,items):", "body": "return items<EOL>", "docstring": "perform data modification of any values, after unpacking from a buffer.", "id": "f2234:c0:m3"}
{"signature": "@staticmethod<EOL><INDENT>def verify(data):<DEDENT>", "body": "if len(data) == <NUM_LIT:0>:<EOL><INDENT>return False<EOL><DEDENT>crc = VProCRC.get(data)<EOL>if crc:<EOL><INDENT>log.info(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>log.debug(\"<STR_LIT>\")<EOL><DEDENT>return not crc<EOL>", "docstring": "perform CRC check on raw serial data, return true if valid.\na valid CRC == 0.", "id": "f2236:c1:m1"}
{"signature": "@staticmethod<EOL><INDENT>def _unpack_storm_date(date):<DEDENT>", "body": "year = (date & <NUM_LIT>) + <NUM_LIT>  <EOL>day = (date >> <NUM_LIT:7>) & <NUM_LIT>  <EOL>month = (date >> <NUM_LIT:12>) & <NUM_LIT>  <EOL>return \"<STR_LIT>\" % (year, month, day)<EOL>", "docstring": "given a packed storm date field, unpack and return 'YYYY-MM-DD' string.", "id": "f2236:c2:m3"}
{"signature": "@staticmethod<EOL><INDENT>def _unpack_time(val):<DEDENT>", "body": "<EOL>return \"<STR_LIT>\" % divmod(val, <NUM_LIT:100>)<EOL>", "docstring": "given a packed time field, unpack and return \"HH:MM\" string.", "id": "f2236:c2:m2"}
{"signature": "def __del__(self):", "body": "self.port.close()<EOL>", "docstring": "close serial port when object is deleted.", "id": "f2236:c6:m3"}
{"signature": "def _calc_derived_fields(self, fields):", "body": "<EOL>temp = fields['<STR_LIT>']<EOL>hum = fields['<STR_LIT>']<EOL>wind = fields['<STR_LIT>']<EOL>wind10min = fields['<STR_LIT>']<EOL>fields['<STR_LIT>'] = calc_heat_index(temp, hum)<EOL>fields['<STR_LIT>'] = calc_wind_chill(temp, wind, wind10min)<EOL>fields['<STR_LIT>'] = calc_dewpoint(temp, hum)<EOL>now = time.localtime()<EOL>fields['<STR_LIT>'] = time.strftime(\"<STR_LIT>\", now)<EOL>fields['<STR_LIT>'] = now[<NUM_LIT:0>]<EOL>fields['<STR_LIT>'] = str(now[<NUM_LIT:1>]).zfill(<NUM_LIT:2>)<EOL>now = time.gmtime()<EOL>fields['<STR_LIT>'] = time.strftime(\"<STR_LIT>\", now)<EOL>fields['<STR_LIT>'] = now[<NUM_LIT:0>]<EOL>fields['<STR_LIT>'] = str(now[<NUM_LIT:1>]).zfill(<NUM_LIT:2>)<EOL>", "docstring": "calculates the derived fields (those fields that are calculated)", "id": "f2236:c6:m11"}
{"signature": "def m_sec_to_mph(m):", "body": "return m * <NUM_LIT><EOL>", "docstring": "Meters/second (m/s) to miles/hour (mph)", "id": "f2242:m20"}
{"signature": "def knots_to_mph(kts):", "body": "return kts * <NUM_LIT><EOL>", "docstring": "Knots (kt) to miles/hour (mph)", "id": "f2242:m3"}
{"signature": "def km_hr_to_knots(km):", "body": "return km * <NUM_LIT><EOL>", "docstring": "Kilometers/hour (kph) to knots (kt)", "id": "f2242:m6"}
{"signature": "def nmph_to_knots(mph):", "body": "return mph<EOL>", "docstring": "Nautical miles/hour (nmph) to knots (kt)", "id": "f2242:m9"}
{"signature": "def knots_to_nmph(kts):", "body": "return kts<EOL>", "docstring": "Knots (kt) to nautical miles/hour (nmph)", "id": "f2242:m4"}
{"signature": "def mph_to_knots(mph):", "body": "return mph * <NUM_LIT><EOL>", "docstring": "Miles/hour (mph) to knots (kt)", "id": "f2242:m8"}
{"signature": "def mb_to_atm(mb):", "body": "return mb * <NUM_LIT><EOL>", "docstring": "Millibars (mb) to atmospheres (atm)", "id": "f2246:m11"}
{"signature": "def in60_to_lbs(inches):", "body": "return inches * <NUM_LIT><EOL>", "docstring": "Inches of mercury @60F (inHg60) to pounds/square inch (lb/in**2)", "id": "f2246:m10"}
{"signature": "def lb_sqin_to_mb(lbs):", "body": "return lbs * <NUM_LIT><EOL>", "docstring": "Pounds/square inch (lb/in**2) to millibars (mb)", "id": "f2246:m33"}
{"signature": "def mb_to_n_sqm(mb):", "body": "return mb * <NUM_LIT:100><EOL>", "docstring": "Millibars (mb) to newtons/square meter (N/m**2)", "id": "f2246:m18"}
{"signature": "def mb_to_hpa(mb):", "body": "return mb<EOL>", "docstring": "Millibars (mb) to hectopascals (hPa)", "id": "f2246:m12"}
{"signature": "def atm_to_mb(atm):", "body": "return atm * <NUM_LIT><EOL>", "docstring": "Atmospheres (atm) to millibars (mb)", "id": "f2246:m2"}
{"signature": "def lb_sqft_to_mb(lbs):", "body": "return lbs * <NUM_LIT><EOL>", "docstring": "Pounds/square foot (lb/ft**2) to millibars (mb)", "id": "f2246:m29"}
{"signature": "def kelvin_to_rankine(k):", "body": "return k * <NUM_LIT><EOL>", "docstring": "Degrees Kelvin (K) to degrees Rankine (R)", "id": "f2247:m8"}
{"signature": "def fahrenheit_to_rankine(f):", "body": "return f + <NUM_LIT><EOL>", "docstring": "Degrees Fahrenheit (F) to degrees Rankine (R)", "id": "f2247:m5"}
{"signature": "def kelvin_to_celsius(k):", "body": "return k - <NUM_LIT><EOL>", "docstring": "Degrees Kelvin (K) to degrees Celsius (C)", "id": "f2247:m6"}
{"signature": "def get_pub_services(opts):", "body": "sites = []<EOL>for p_key in vars(opts).keys():<EOL><INDENT>args = getattr(opts,p_key)<EOL>if p_key in PUB_SERVICES and args:<EOL><INDENT>if isinstance(args,tuple):<EOL><INDENT>ps = PUB_SERVICES[p_key](*args)<EOL><DEDENT>else:<EOL><INDENT>ps = PUB_SERVICES[p_key](args)<EOL><DEDENT>sites.append( ps )<EOL><DEDENT><DEDENT>return sites<EOL>", "docstring": "use values in opts data to generate instances of publication services.", "id": "f2249:m2"}
{"signature": "def get( self, station, interval ):", "body": "rec = station.fields['<STR_LIT>']<EOL>if rec:<EOL><INDENT>threshold = station.fields['<STR_LIT>'] + GUST_MPH_MIN<EOL>if rec['<STR_LIT>'] >= threshold:<EOL><INDENT>self.value = (rec['<STR_LIT>'],rec['<STR_LIT>'])<EOL>self.count = GUST_TTL * <NUM_LIT> / interval<EOL><DEDENT>else:<EOL><INDENT>self.value = self.NO_VALUE<EOL><DEDENT><DEDENT>if self.count:<EOL><INDENT>self.count -= <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>self.value = self.NO_VALUE<EOL><DEDENT>log.debug('<STR_LIT>'.format(*self.value))<EOL>return self.value<EOL>", "docstring": "return gust data, if above threshold value and current time is inside\nreporting window period", "id": "f2249:c1:m1"}
{"signature": "def compress(string, mode=MODE_GENERIC, quality=<NUM_LIT:11>, lgwin=<NUM_LIT>, lgblock=<NUM_LIT:0>):", "body": "compressor = Compressor(mode=mode, quality=quality, lgwin=lgwin,<EOL>lgblock=lgblock)<EOL>return compressor.process(string) + compressor.finish()<EOL>", "docstring": "Compress a byte string.\n\n    Args:\n      string (bytes): The input data.\n      mode (int, optional): The compression mode can be MODE_GENERIC (default),\n        MODE_TEXT (for UTF-8 format text input) or MODE_FONT (for WOFF 2.0).\n      quality (int, optional): Controls the compression-speed vs compression-\n        density tradeoff. The higher the quality, the slower the compression.\n        Range is 0 to 11. Defaults to 11.\n      lgwin (int, optional): Base 2 logarithm of the sliding window size. Range\n        is 10 to 24. Defaults to 22.\n      lgblock (int, optional): Base 2 logarithm of the maximum input block size.\n        Range is 16 to 24. If set to 0, the value will be set based on the\n        quality. Defaults to 0.\n\n    Returns:\n      The compressed byte string.\n\n    Raises:\n      brotli.error: If arguments are invalid, or compressor fails.", "id": "f2256:m0"}
{"signature": "def __repr__(self):", "body": "return \"<STR_LIT>\".format(self.pos>><NUM_LIT:3>, self.pos&<NUM_LIT:7>)<EOL>", "docstring": "Representation\n        >>> olleke\n        BitStream(pos=0:0)", "id": "f2258:c1:m1"}
{"signature": "def span(self, index):", "body": "lower = self.value0+sum(<NUM_LIT:1><<x for x in self.extraTable[:index])<EOL>upper = lower+(<NUM_LIT:1><<self.extraTable[index])<EOL>return lower, upper-<NUM_LIT:1><EOL>", "docstring": "Give the range of possible values in a tuple\n        Useful for mnemonic and explanation", "id": "f2258:c8:m4"}
{"signature": "def value(self, dcode, dextra):", "body": "if dcode<<NUM_LIT:16>:<EOL><INDENT>return [(<NUM_LIT:1>,<NUM_LIT:0>),(<NUM_LIT:2>,<NUM_LIT:0>),(<NUM_LIT:3>,<NUM_LIT:0>),(<NUM_LIT:4>,<NUM_LIT:0>),<EOL>(<NUM_LIT:1>,-<NUM_LIT:1>),(<NUM_LIT:1>,+<NUM_LIT:1>),(<NUM_LIT:1>,-<NUM_LIT:2>),(<NUM_LIT:1>,+<NUM_LIT:2>),(<NUM_LIT:1>,-<NUM_LIT:3>),(<NUM_LIT:1>,+<NUM_LIT:3>),<EOL>(<NUM_LIT:2>,-<NUM_LIT:1>),(<NUM_LIT:2>,+<NUM_LIT:1>),(<NUM_LIT:2>,-<NUM_LIT:2>),(<NUM_LIT:2>,+<NUM_LIT:2>),(<NUM_LIT:2>,-<NUM_LIT:3>),(<NUM_LIT:2>,+<NUM_LIT:3>)<EOL>][dcode]<EOL><DEDENT>if dcode<<NUM_LIT:16>+self.NDIRECT:<EOL><INDENT>return (<NUM_LIT:0>,dcode-<NUM_LIT:16>)<EOL><DEDENT>POSTFIX_MASK = (<NUM_LIT:1> << self.NPOSTFIX) - <NUM_LIT:1><EOL>ndistbits = <NUM_LIT:1> + ((dcode - self.NDIRECT - <NUM_LIT:16>) >> (self.NPOSTFIX + <NUM_LIT:1>))<EOL>hcode = (dcode - self.NDIRECT - <NUM_LIT:16>) >> self.NPOSTFIX<EOL>lcode = (dcode - self.NDIRECT - <NUM_LIT:16>) & POSTFIX_MASK<EOL>offset = ((<NUM_LIT:2> + (hcode & <NUM_LIT:1>)) << ndistbits) - <NUM_LIT:4><EOL>distance = ((offset + dextra) << self.NPOSTFIX) + lcode + self.NDIRECT + <NUM_LIT:1><EOL>return (<NUM_LIT:0>,distance)<EOL>", "docstring": "Decode value of symbol together with the extra bits.\n        >>> d = DistanceAlphabet('D', NPOSTFIX=2, NDIRECT=10)\n        >>> d[34].value(2)\n        (0, 35)", "id": "f2258:c29:m2"}
{"signature": "def __getitem__(self, index):", "body": "if index>=len(self.extraTable):<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(<EOL>self.__class__.__name__, index))<EOL><DEDENT>return Symbol(self, index)<EOL>", "docstring": "Faster than PrefixDecoder", "id": "f2258:c8:m2"}
{"signature": "def makeHexData(self, pos):", "body": "firstAddress = pos+<NUM_LIT:7>>><NUM_LIT:3><EOL>lastAddress = self.stream.pos+<NUM_LIT:7>>><NUM_LIT:3><EOL>return '<STR_LIT>'.join(map('<STR_LIT>'.format,<EOL>self.stream.data[firstAddress:lastAddress]))<EOL>", "docstring": "Produce hex dump of all data containing the bits\n        from pos to stream.pos", "id": "f2258:c32:m1"}
{"signature": "def explanation(self, index, extra=None):", "body": "extraBits = <NUM_LIT:0> if extra is None else self.extraBits(index)<EOL>if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>formatString = '<STR_LIT>'<EOL>lo = hi = value = self.value(index, extra)<EOL><DEDENT>elif extraBits==<NUM_LIT:0>:<EOL><INDENT>formatString = '<STR_LIT>'<EOL>lo, hi = self.span(index)<EOL>value = lo<EOL><DEDENT>else:<EOL><INDENT>formatString = '<STR_LIT>'<EOL>lo, hi = self.span(index)<EOL>value = lo+extra<EOL><DEDENT>return formatString.format(<EOL>self.description and self.description+'<STR_LIT>',<EOL>'<STR_LIT:x>'*extraBits,<EOL>self.bitPattern(index),<EOL>lo, hi,<EOL>extra,<EOL>value,<EOL>)<EOL>", "docstring": "Expanded version of Code.explanation supporting extra bits.\n        If you don't supply extra, it is not mentioned.", "id": "f2258:c6:m3"}
{"signature": "def setDecode(self, decodeTable):", "body": "self.decodeTable = decodeTable<EOL>todo = set(decodeTable)<EOL>maskLength = <NUM_LIT:0><EOL>lengthTable = {}<EOL>while todo:<EOL><INDENT>mask = (<NUM_LIT:1><<maskLength)-<NUM_LIT:1><EOL>splitSymbols = defaultdict(list)<EOL>for s in todo: splitSymbols[s&mask].append(s)<EOL>for s,subset in splitSymbols.items():<EOL><INDENT>if len(subset)==<NUM_LIT:1>:<EOL><INDENT>lengthTable[self.decodeTable[s]] = maskLength<EOL>todo.remove(s)<EOL><DEDENT><DEDENT>maskLength +=<NUM_LIT:1><EOL><DEDENT>self.lengthTable = lengthTable<EOL>self.minLength = min(lengthTable.values())<EOL>self.maxLength = max(lengthTable.values())<EOL>self.switchToPrefix()<EOL>", "docstring": "Store decodeTable,\n        and compute lengthTable, minLength, maxLength from encodings.", "id": "f2258:c4:m7"}
{"signature": "def peek(self, n):", "body": "<EOL>return int.from_bytes(<EOL>self.data[self.pos>><NUM_LIT:3>:self.pos+n+<NUM_LIT:7>>><NUM_LIT:3>],<EOL>'<STR_LIT>')>>(self.pos&<NUM_LIT:7>) & (<NUM_LIT:1><<n)-<NUM_LIT:1><EOL>", "docstring": "Peek an n bit integer from the stream without updating the pointer.\n        It is not an error to read beyond the end of the stream.\n        >>> olleke.data[:2]==b'\\x1b\\x2e' and 0x2e1b==11803\n        True\n        >>> olleke.peek(15)\n        11803\n        >>> hex(olleke.peek(32))\n        '0x2e1b'", "id": "f2258:c1:m3"}
{"signature": "def doAction(self, w, action):", "body": "<EOL>U = self.upperCase1<EOL>return eval(self.actionList[action], locals())<EOL>", "docstring": "Perform the proper action", "id": "f2258:c31:m4"}
{"signature": "def outputFormatter(s):", "body": "result = '<STR_LIT>'<EOL>def formatSubString(s):<EOL><INDENT>for c in s:<EOL><INDENT>if c==<NUM_LIT:32>: yield '<STR_LIT:U+0020>'<EOL>else: yield outputCharFormatter(c)<EOL><DEDENT><DEDENT>if len(result)<<NUM_LIT:200>: return '<STR_LIT>'.join(formatSubString(s))<EOL>else:<EOL><INDENT>return '<STR_LIT>'.join(formatSubString(s[:<NUM_LIT:100>]))+'<STR_LIT>'+'<STR_LIT>'.join(formatSubString(s[-<NUM_LIT:100>:]))<EOL><DEDENT>", "docstring": "Show string or char.", "id": "f2258:m1"}
{"signature": "def readLiteralContextModes(self):", "body": "print('<STR_LIT>'.center(<NUM_LIT>, '<STR_LIT:->'))<EOL>self.literalContextModes = []<EOL>for i in range(self.numberOfBlockTypes[L]):<EOL><INDENT>self.literalContextModes.append(<EOL>self.verboseRead(LiteralContextMode(number=i)))<EOL><DEDENT>", "docstring": "Read literal context modes.\n        LSB6: lower 6 bits of last char\n        MSB6: upper 6 bits of last char\n        UTF8: rougly dependent on categories:\n            upper 4 bits depend on category of last char:\n                control/whitespace/space/ punctuation/quote/%/open/close/\n                comma/period/=/digits/ VOWEL/CONSONANT/vowel/consonant\n            lower 2 bits depend on category of 2nd last char:\n                space/punctuation/digit or upper/lowercase\n        signed: hamming weight of last 2 chars", "id": "f2258:c32:m10"}
{"signature": "def mnemonic(self, index):", "body": "return str(self.value(index))<EOL>", "docstring": "Give mnemonic of symbol.\n        Override where needed.", "id": "f2258:c5:m9"}
{"signature": "def switchToPrefix(self):", "body": "self.mode = PrefixDecoder<EOL>", "docstring": "This routine makes sure the prefix decoder is activated.", "id": "f2258:c4:m9"}
{"signature": "def __iter__(self):", "body": "return map(partial(Symbol, self), range(len(self)))<EOL>", "docstring": "Produce all symbols.", "id": "f2258:c3:m2"}
{"signature": "def readTupleAndExtra(self, stream):", "body": "length, symbol = self.decodePeek(stream.peek(self.maxLength))<EOL>stream.pos += length<EOL>extraBits = self.extraBits(symbol.index)<EOL>return length, symbol, extraBits, stream.read(extraBits)<EOL>", "docstring": "Read symbol and extrabits from stream.\n        Returns symbol length, symbol, extraBits, extra\n        >>> olleke.pos = 6\n        >>> MetablockLengthAlphabet().readTupleAndExtra(olleke)\n        (2, Symbol(MLEN, 4), 16, 46)", "id": "f2258:c6:m2"}
{"signature": "def splitSymbol(self, index):", "body": "<EOL>row = [<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:1>,<NUM_LIT:1>,<NUM_LIT:2>,<NUM_LIT:2>,<NUM_LIT:1>,<NUM_LIT:3>,<NUM_LIT:2>,<NUM_LIT:3>,<NUM_LIT:3>][index>><NUM_LIT:6>]<EOL>col = [<NUM_LIT:0>,<NUM_LIT:1>,<NUM_LIT:0>,<NUM_LIT:1>,<NUM_LIT:0>,<NUM_LIT:1>,<NUM_LIT:2>,<NUM_LIT:0>,<NUM_LIT:2>,<NUM_LIT:1>,<NUM_LIT:2>][index>><NUM_LIT:6>]<EOL>insertLengthCode = row<<<NUM_LIT:3> | index>><NUM_LIT:3>&<NUM_LIT:7><EOL>if row: insertLengthCode -= <NUM_LIT:8><EOL>copyLengthCode = col<<<NUM_LIT:3> | index&<NUM_LIT:7><EOL>return (<EOL>Symbol(self.insertLengthAlphabet, insertLengthCode),<EOL>Symbol(self.copyLengthAlphabet, copyLengthCode),<EOL>row==<NUM_LIT:0><EOL>)<EOL>", "docstring": "Give relevant values for computations:\n        (insertSymbol, copySymbol, dist0flag)", "id": "f2258:c28:m3"}
{"signature": "def value(self, index, extra):", "body": "if extra><NUM_LIT:15>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return index, extra<<index<EOL>", "docstring": "Returns NPOSTFIX and NDIRECT<<NPOSTFIX", "id": "f2258:c21:m2"}
{"signature": "def readPrefixArray(self, kind, numberOfTrees):", "body": "prefixes = []<EOL>for i in range(numberOfTrees):<EOL><INDENT>if kind==L: alphabet = LiteralAlphabet(i)<EOL>elif kind==I: alphabet = InsertAndCopyAlphabet(i)<EOL>elif kind==D: alphabet = DistanceAlphabet(<EOL>i, NPOSTFIX=self.NPOSTFIX, NDIRECT=self.NDIRECT)<EOL>self.readPrefixCode(alphabet)<EOL>prefixes.append(alphabet)<EOL><DEDENT>self.prefixCodes[kind] = prefixes<EOL>", "docstring": "Read prefix code array", "id": "f2258:c32:m13"}
{"signature": "def value(self, index, extra=None):", "body": "if extra is not None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return index<EOL>", "docstring": "Get value of symbol for computations.\n        Override where needed.", "id": "f2258:c5:m8"}
{"signature": "def value(self, index, extra):", "body": "lower, upper = self.span(index)<EOL>value = lower+(extra or <NUM_LIT:0>)<EOL>if value>upper:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return value<EOL>", "docstring": "Override if you don't define value0 and extraTable", "id": "f2258:c8:m3"}
{"signature": "def value(self, index, extra):", "body": "index = index<EOL>if index==<NUM_LIT:0>: return <NUM_LIT:1>, <NUM_LIT:0><EOL>if index<=self.RLEMAX: return (<NUM_LIT:1><<index)+extra, <NUM_LIT:0><EOL>return <NUM_LIT:1>, index-self.RLEMAX<EOL>", "docstring": "Give count and value.", "id": "f2258:c24:m3"}
{"signature": "def get_argument_key(kwargs, argument_key, index):", "body": "if isinstance(argument_key, (list, tuple)):<EOL><INDENT>return_string = '<STR_LIT>'<EOL>for element in argument_key:<EOL><INDENT>return_val = kwargs.get(element)[index]<EOL>if return_val is None:<EOL><INDENT>return_val = '<STR_LIT>'<EOL><DEDENT>return_string += str(return_val)<EOL>if len(argument_key) > <NUM_LIT:1>:<EOL><INDENT>return_string += '<STR_LIT:_>'<EOL><DEDENT><DEDENT>return return_string<EOL><DEDENT>return str(kwargs.get(argument_key)[index] or '<STR_LIT>')<EOL>", "docstring": ":param kwargs: keyword arguments used to kickoff the multiget\n:param argument_key: Name or set of names of keyword arguments to read from\n:param index: which set of arguments are considered\n:return:", "id": "f2267:m4"}
{"signature": "def map_arguments_to_objects(kwargs, objects, object_key, object_tuple_key, argument_key, result_value, default_result):", "body": "<EOL>map_ = map_objects_to_result(objects, object_key, object_tuple_key, result_value, default_result)<EOL>element_count = get_request_count(kwargs)<EOL>return [map_[get_argument_key(kwargs, argument_key, index)] for index in range(<NUM_LIT:0>, element_count)]<EOL>", "docstring": ":param kwargs: kwargs used to call the multiget function\n:param objects: objects returned from the inner function\n:param object_key: field or set of fields that map to the kwargs provided\n:param object_tuple_key: A temporary shortcut until we allow dot.path traversal for object_key.\nWill call getattr(getattr(result, join_table_name), object_key)\n:param argument_key: field or set of fields that map to the objects provided\n:param result_value: Limit the fields returned to this field or set of fields (none = whole object)\n:param default_result: If the inner function returned none for a set of parameters, default to this\n:return:", "id": "f2267:m7"}
{"signature": "@abstractmethod<EOL><INDENT>def get(self, k, d=None):<DEDENT>", "body": "pass<EOL>", "docstring": "D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.", "id": "f2268:c0:m0"}
{"signature": "@abstractmethod<EOL><INDENT>def __getitem__(self, y):<DEDENT>", "body": "pass<EOL>", "docstring": "x.__getitem__(y) <==> x[y]", "id": "f2268:c0:m1"}
{"signature": "@abstractmethod<EOL><INDENT>def __contains__(self, *args, **kwargs):<DEDENT>", "body": "pass<EOL>", "docstring": "True if D has a key k, else False.", "id": "f2268:c0:m6"}
{"signature": "def delete(self, *args):", "body": "cache = get_cache()<EOL>key = self.get_cache_key(*args)<EOL>if key in cache:<EOL><INDENT>del cache[key]<EOL><DEDENT>", "docstring": "Remove the key from the request cache and from memcache.", "id": "f2269:c0:m4"}
{"signature": "def __call__(self, *args, **kwargs):", "body": "key = self.get_cache_key(*args, **kwargs)<EOL>cache = get_cache()<EOL>if key in cache:<EOL><INDENT>return cache[key]<EOL><DEDENT>else:<EOL><INDENT>self.prime(*args, **kwargs)<EOL>self._issue_gets_for_primes()<EOL>return cache[key]<EOL><DEDENT>", "docstring": "Pull the return value from the request cache if possible. If not,\npull the value from calling inner_f, then set the value in request cache", "id": "f2270:c0:m1"}
{"signature": "def tag_list(self, tags):", "body": "return [<EOL>(tag.name, \"<STR_LIT>\" if tag.name in tags else \"<STR_LIT>\")<EOL>for tag in self.model.objects.all()<EOL>]<EOL>", "docstring": "Generates a list of tags identifying those previously selected.\n\nReturns a list of tuples of the form (<tag name>, <CSS class name>).\n\nUses the string names rather than the tags themselves in order to work\nwith tag lists built from forms not fully submitted.", "id": "f2278:c0:m2"}
{"signature": "def encode_datetime(obj):", "body": "<EOL>zone = '<STR_LIT>' if getattr(obj, '<STR_LIT>', True) else '<STR_LIT>'<EOL>return obj.isoformat() + zone<EOL>", "docstring": "Encode a datetime.datetime or datetime.date object as an ISO 8601 format string.", "id": "f2282:m6"}
{"signature": "def decode_date(self, val):", "body": "if isinstance(val, basestring) and val.count('<STR_LIT:->') == <NUM_LIT:2> and len(val) > <NUM_LIT:9>:<EOL><INDENT>try:<EOL><INDENT>dt = dateutil.parser.parse(val)<EOL>if val.endswith(('<STR_LIT>', '<STR_LIT>', '<STR_LIT>')):<EOL><INDENT>dt = dt.replace(tzinfo=None)<EOL><DEDENT>return dt<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return val<EOL>", "docstring": "Tries to decode strings that look like dates into datetime objects.", "id": "f2282:c0:m2"}
{"signature": "def encode_key_as_entity(obj):", "body": "<EOL>return obj.get_async()<EOL>", "docstring": "Get the Entity from the ndb.Key for further encoding.", "id": "f2282:m2"}
{"signature": "def is_staging(version=None):", "body": "return is_host_google() and not is_default_version(version)<EOL>", "docstring": "True if the app is hosted by Google (appspot.com) but the version is not the default.", "id": "f2284:m6"}
{"signature": "def get_dot_target_name_safe(version=None, module=None):", "body": "version = version or get_current_version_name_safe()<EOL>module = module or get_current_module_name_safe()<EOL>if version and module:<EOL><INDENT>return '<STR_LIT>'.join((version, module))<EOL><DEDENT>return None<EOL>", "docstring": "Returns the current version/module in -dot- notation which is used by `target:` parameters.\nIf there is no current version or module then None is returned.", "id": "f2284:m11"}
{"signature": "def get_dot_target_name(version=None, module=None):", "body": "version = version or get_current_version_name()<EOL>module = module or get_current_module_name()<EOL>return '<STR_LIT>'.join((version, module))<EOL>", "docstring": "Returns the current version/module in -dot- notation which is used by `target:` parameters.", "id": "f2284:m10"}
{"signature": "def get_environ_dict():", "body": "return {<EOL>'<STR_LIT>': _get_os_environ_dict((<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>)),<EOL>'<STR_LIT>': _get_app_identity_dict((<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>)),<EOL>'<STR_LIT>': _get_modules_dict((<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>)),<EOL>'<STR_LIT>': _get_namespace_manager_dict((<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>)),<EOL>}<EOL>", "docstring": "Return a dictionary of all environment keys/values.", "id": "f2284:m16"}
{"signature": "def _get_modules_dict(keys):", "body": "return {k: getattr(modules, k)() for k in keys}<EOL>", "docstring": "Return a dictionary of key/values from the modules module functions.", "id": "f2284:m14"}
{"signature": "@abstractmethod<EOL><INDENT>def upload(self, file_name):<DEDENT>", "body": "", "docstring": "Uploads a file to the storage.", "id": "f2299:c1:m1"}
{"signature": "def connect(self):", "body": "if self.music_folder is None:<EOL><INDENT>music_folder = os.path.join(os.path.expanduser('<STR_LIT>'), '<STR_LIT>')<EOL>if not os.path.exists(music_folder):<EOL><INDENT>os.makedirs(music_folder)<EOL><DEDENT>self.music_folder = music_folder<EOL><DEDENT>", "docstring": "Initializes the connection attribute with the path to the user home folder's Music folder, and creates it if it doesn't exist.", "id": "f2299:c5:m1"}
{"signature": "def download(self, url):", "body": "try:<EOL><INDENT>track = self.client.get('<STR_LIT>', url=url)<EOL><DEDENT>except HTTPError:<EOL><INDENT>log.error(f\"<STR_LIT>\")<EOL>return<EOL><DEDENT>r = requests.get(self.client.get(track.stream_url, allow_redirects=False).location, stream=True)<EOL>total_size = int(r.headers['<STR_LIT>'])<EOL>chunk_size = <NUM_LIT><EOL>file_name = track.title + '<STR_LIT>'<EOL>with open(file_name, '<STR_LIT:wb>') as f:<EOL><INDENT>for data in tqdm(r.iter_content(chunk_size), desc=track.title, total=total_size / chunk_size, unit='<STR_LIT>', file=sys.stdout):<EOL><INDENT>f.write(data)<EOL><DEDENT><DEDENT>return file_name<EOL>", "docstring": "Downloads a MP3 file that is associated with the track at the URL passed.\n\n:param str url: URL of the track to be downloaded", "id": "f2299:c3:m1"}
{"signature": "def connect(self):", "body": "SCOPES = '<STR_LIT>'<EOL>store = file.Storage('<STR_LIT>')<EOL>creds = store.get()<EOL>if not creds or creds.invalid:<EOL><INDENT>try:<EOL><INDENT>flow = client.flow_from_clientsecrets('<STR_LIT>', SCOPES)<EOL><DEDENT>except InvalidClientSecretsError:<EOL><INDENT>log.error('<STR_LIT>')<EOL>return<EOL><DEDENT>creds = tools.run_flow(flow, store)<EOL><DEDENT>self.connection = build('<STR_LIT>', '<STR_LIT>', http=creds.authorize(Http()))<EOL>response = self.connection.files().list(q=\"<STR_LIT>\").execute()<EOL>try:<EOL><INDENT>folder_id = response.get('<STR_LIT>', [])[<NUM_LIT:0>]['<STR_LIT:id>']<EOL><DEDENT>except IndexError:<EOL><INDENT>log.warning('<STR_LIT>')<EOL>folder_metadata = {'<STR_LIT:name>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>'}<EOL>folder = self.connection.files().create(body=folder_metadata, fields='<STR_LIT:id>').execute()<EOL><DEDENT>", "docstring": "Creates connection to the Google Drive API, sets the connection attribute to make requests, and creates the Music folder if it doesn't exist.", "id": "f2299:c4:m1"}
{"signature": "def cost(self, t_node, branch_length, multiplicity=<NUM_LIT>):", "body": "merger_time = t_node+branch_length<EOL>return self.integral_merger_rate(merger_time) - self.integral_merger_rate(t_node)- np.log(self.total_merger_rate(merger_time))*(multiplicity-<NUM_LIT:1.0>)/multiplicity<EOL>", "docstring": "returns the cost associated with a branch starting at t_node\nt_node is time before present, the branch goes back in time\n\nArgs:\n    - t_node:           time of the node\n    - branch_length:    branch length, determines when this branch merges with sister\n    - multiplicity:     2 if merger is binary, higher if this is a polytomy", "id": "f2306:c0:m6"}
{"signature": "def attach_to_tree(self):", "body": "for clade in self.tree.find_clades():<EOL><INDENT>if clade.up is not None:<EOL><INDENT>clade.branch_length_interpolator.merger_cost = self.cost<EOL><DEDENT><DEDENT>", "docstring": "attaches the the merger cost to each branch length interpolator in the tree.", "id": "f2306:c0:m7"}
{"signature": "def calc_branch_count(self):", "body": "<EOL>self.tree_events = np.array(sorted([(n.time_before_present, len(n.clades)-<NUM_LIT:1>)<EOL>for n in self.tree.find_clades() if not n.bad_branch],<EOL>key=lambda x:-x[<NUM_LIT:0>]))<EOL>from collections import defaultdict<EOL>dn_branch = defaultdict(int)<EOL>for (t, dn) in self.tree_events:<EOL><INDENT>dn_branch[t]+=dn<EOL><DEDENT>unique_mergers = np.array(sorted(dn_branch.items(), key = lambda x:-x[<NUM_LIT:0>]))<EOL>nbranches = [[ttconf.BIG_NUMBER, <NUM_LIT:1>], [unique_mergers[<NUM_LIT:0>,<NUM_LIT:0>]+ttconf.TINY_NUMBER, <NUM_LIT:1>]]<EOL>for ti, (t, dn) in enumerate(unique_mergers[:-<NUM_LIT:1>]):<EOL><INDENT>new_n = nbranches[-<NUM_LIT:1>][<NUM_LIT:1>]+dn<EOL>next_t = unique_mergers[ti+<NUM_LIT:1>,<NUM_LIT:0>]+ttconf.TINY_NUMBER<EOL>nbranches.append([t, new_n])<EOL>nbranches.append([next_t, new_n])<EOL><DEDENT>new_n += unique_mergers[-<NUM_LIT:1>,<NUM_LIT:1>]<EOL>nbranches.append([next_t, new_n])<EOL>nbranches.append([-ttconf.BIG_NUMBER, new_n])<EOL>nbranches=np.array(nbranches)<EOL>self.nbranches = interp1d(nbranches[:,<NUM_LIT:0>], nbranches[:,<NUM_LIT:1>], kind='<STR_LIT>')<EOL>", "docstring": "calculates an interpolation object that maps time to the number of\nconcurrent branches in the tree. The result is stored in self.nbranches", "id": "f2306:c0:m2"}
{"signature": "def mugration(params):", "body": "<EOL>if os.path.isfile(params.states):<EOL><INDENT>states = pd.read_csv(params.states, sep='<STR_LIT:\\t>' if params.states[-<NUM_LIT:3>:]=='<STR_LIT>' else '<STR_LIT:U+002C>',<EOL>skipinitialspace=True)<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return <NUM_LIT:1><EOL><DEDENT>outdir = get_outdir(params, '<STR_LIT>')<EOL>taxon_name = '<STR_LIT:name>' if '<STR_LIT:name>' in states.columns else states.columns[<NUM_LIT:0>]<EOL>if params.attribute:<EOL><INDENT>if params.attribute in states.columns:<EOL><INDENT>attr = params.attribute<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\"+params.states, file=sys.stderr)<EOL>print(\"<STR_LIT>\"+\"<STR_LIT:U+002CU+0020>\".join(states.columns), file=sys.stderr)<EOL>return <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>attr = states.columns[<NUM_LIT:1>]<EOL>print(\"<STR_LIT>\"+attr, file=sys.stderr)<EOL><DEDENT>leaf_to_attr = {x[taxon_name]:x[attr] for xi, x in states.iterrows()<EOL>if x[attr]!=params.missing_data}<EOL>unique_states = sorted(set(leaf_to_attr.values()))<EOL>nc = len(unique_states)<EOL>if nc><NUM_LIT>:<EOL><INDENT>print(\"<STR_LIT>\", file=sys.stderr)<EOL>return <NUM_LIT:1><EOL><DEDENT>elif nc<<NUM_LIT:2>:<EOL><INDENT>print(\"<STR_LIT>\", file=sys.stderr)<EOL>return <NUM_LIT:1><EOL><DEDENT>alphabet = [chr(<NUM_LIT>+i) for i,state in enumerate(unique_states)]<EOL>missing_char = chr(<NUM_LIT>+nc)<EOL>letter_to_state = {a:unique_states[i] for i,a in enumerate(alphabet)}<EOL>letter_to_state[missing_char]=params.missing_data<EOL>reverse_alphabet = {v:k for k,v in letter_to_state.items()}<EOL>if params.weights:<EOL><INDENT>params.infer_gtr = True<EOL>tmp_weights = pd.read_csv(params.weights, sep='<STR_LIT:\\t>' if params.states[-<NUM_LIT:3>:]=='<STR_LIT>' else '<STR_LIT:U+002C>',<EOL>skipinitialspace=True)<EOL>weights = {row[<NUM_LIT:0>]:row[<NUM_LIT:1>] for ri,row in tmp_weights.iterrows()}<EOL>mean_weight = np.mean(list(weights.values()))<EOL>weights = np.array([weights[c] if c in weights else mean_weight for c in unique_states], dtype=float)<EOL>weights/=weights.sum()<EOL><DEDENT>else:<EOL><INDENT>weights = np.ones(nc, dtype=float)/nc<EOL><DEDENT>W = np.ones((nc,nc), dtype=float)<EOL>mugration_GTR = GTR.custom(pi = weights, W=W, alphabet = np.array(alphabet))<EOL>mugration_GTR.profile_map[missing_char] = np.ones(nc)<EOL>mugration_GTR.ambiguous=missing_char<EOL>treeanc = TreeAnc(params.tree, gtr=mugration_GTR, verbose=params.verbose,<EOL>convert_upper=False, one_mutation=<NUM_LIT>)<EOL>pseudo_seqs = [SeqRecord(id=n.name,name=n.name,<EOL>seq=Seq(reverse_alphabet[leaf_to_attr[n.name]]<EOL>if n.name in leaf_to_attr else missing_char))<EOL>for n in treeanc.tree.get_terminals()]<EOL>treeanc.aln = MultipleSeqAlignment(pseudo_seqs)<EOL>ndiff = treeanc.infer_ancestral_sequences(method='<STR_LIT>', infer_gtr=True,<EOL>store_compressed=False, pc=params.pc, marginal=True, normalized_rate=False,<EOL>fixed_pi=weights if params.weights else None)<EOL>if ndiff==ttconf.ERROR: <EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>print(\"<STR_LIT>\"%attr,params.tree)<EOL>basename = get_basename(params, outdir)<EOL>gtr_name = basename + '<STR_LIT>'<EOL>with open(gtr_name, '<STR_LIT:w>') as ofile:<EOL><INDENT>ofile.write('<STR_LIT>')<EOL>for state in unique_states:<EOL><INDENT>ofile.write('<STR_LIT>'%(reverse_alphabet[state], state))<EOL><DEDENT>ofile.write('<STR_LIT>'+str(treeanc.gtr)+'<STR_LIT:\\n>')<EOL>print(\"<STR_LIT>\", gtr_name)<EOL><DEDENT>terminal_count = <NUM_LIT:0><EOL>for n in treeanc.tree.find_clades():<EOL><INDENT>if n.up is None:<EOL><INDENT>continue<EOL><DEDENT>n.confidence=None<EOL>if n.is_terminal() and len(n.name)><NUM_LIT> and bioversion<\"<STR_LIT>\":<EOL><INDENT>n.name = n.name[:<NUM_LIT>]+'<STR_LIT>'%terminal_count<EOL>terminal_count+=<NUM_LIT:1><EOL><DEDENT>n.comment= '<STR_LIT>'%attr + letter_to_state[n.sequence[<NUM_LIT:0>]] +'<STR_LIT:\">'<EOL><DEDENT>if params.confidence:<EOL><INDENT>conf_name = basename+'<STR_LIT>'<EOL>with open(conf_name, '<STR_LIT:w>') as ofile:<EOL><INDENT>ofile.write('<STR_LIT>'+'<STR_LIT:U+002CU+0020>'.join(unique_states)+'<STR_LIT:\\n>')<EOL>for n in treeanc.tree.find_clades():<EOL><INDENT>ofile.write(n.name + '<STR_LIT:U+002CU+0020>'+'<STR_LIT:U+002CU+0020>'.join([str(x) for x in n.marginal_profile[<NUM_LIT:0>]])+'<STR_LIT:\\n>')<EOL><DEDENT><DEDENT>print(\"<STR_LIT>\", conf_name)<EOL><DEDENT>outtree_name = basename+'<STR_LIT>'<EOL>Phylo.write(treeanc.tree, outtree_name, '<STR_LIT>')<EOL>print(\"<STR_LIT>\",outtree_name)<EOL>return <NUM_LIT:0><EOL>", "docstring": "implementing treetime mugration", "id": "f2307:m12"}
{"signature": "def create_gtr(params):", "body": "model = params.gtr<EOL>gtr_params = params.gtr_params<EOL>if model == '<STR_LIT>':<EOL><INDENT>gtr = GTR.standard('<STR_LIT>', alphabet='<STR_LIT>' if params.aa else '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>kwargs = {}<EOL>if gtr_params is not None:<EOL><INDENT>for param in gtr_params:<EOL><INDENT>keyval = param.split('<STR_LIT:=>')<EOL>if len(keyval)!=<NUM_LIT:2>: continue<EOL>if keyval[<NUM_LIT:0>] in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>keyval[<NUM_LIT:0>] = '<STR_LIT>'<EOL>keyval[<NUM_LIT:1>] = list(map(float, keyval[<NUM_LIT:1>].split('<STR_LIT:U+002C>')))<EOL><DEDENT>elif keyval[<NUM_LIT:0>] not in ['<STR_LIT>']:<EOL><INDENT>keyval[<NUM_LIT:1>] = float(keyval[<NUM_LIT:1>])<EOL><DEDENT>kwargs[keyval[<NUM_LIT:0>]] = keyval[<NUM_LIT:1>]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>print (\"<STR_LIT>\")<EOL><DEDENT>gtr = GTR.standard(model, **kwargs)<EOL>infer_gtr = False<EOL><DEDENT>except:<EOL><INDENT>print (\"<STR_LIT>\")<EOL>gtr = GTR.standard('<STR_LIT>', alphabet='<STR_LIT>' if params.aa else '<STR_LIT>')<EOL>infer_gtr = False<EOL><DEDENT><DEDENT>return gtr<EOL>", "docstring": "parse the arguments referring to the GTR model and return a GTR structure", "id": "f2307:m1"}
{"signature": "@classmethod<EOL><INDENT>def custom(cls, mu=<NUM_LIT:1.0>, pi=None, W=None, **kwargs):<DEDENT>", "body": "gtr = cls(**kwargs)<EOL>gtr.assign_rates(mu=mu, pi=pi, W=W)<EOL>return gtr<EOL>", "docstring": "Create a GTR model by specifying the matrix explicitly\n\nParameters\n----------\n\n mu : float\n    Substitution rate\n\n W : nxn matrix\n    Substitution matrix\n\n pi : n vector\n    Equilibrium frequencies\n\n **kwargs:\n    Key word arguments to be passed\n\nKeyword Args\n------------\n\n alphabet : str\n    Specify alphabet when applicable. If the alphabet specification is\n    required, but no alphabet is specified, the nucleotide alphabet will be used as\n    default.", "id": "f2309:c0:m4"}
{"signature": "@staticmethod<EOL><INDENT>def calc_fwhm(distribution, is_neg_log=True):<DEDENT>", "body": "if isinstance(distribution, interp1d):<EOL><INDENT>if is_neg_log:<EOL><INDENT>ymin = distribution.y.min()<EOL>log_prob = distribution.y-ymin<EOL><DEDENT>else:<EOL><INDENT>log_prob = -np.log(distribution.y)<EOL>log_prob -= log_prob.min()<EOL><DEDENT>xvals = distribution.x<EOL><DEDENT>elif isinstance(distribution, Distribution):<EOL><INDENT>xvals = distribution._func.x<EOL>log_prob = distribution._func.y<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\");<EOL><DEDENT>L = xvals.shape[<NUM_LIT:0>]<EOL>tmp = np.where(log_prob < <NUM_LIT>)[<NUM_LIT:0>]<EOL>x_l, x_u = tmp[<NUM_LIT:0>], tmp[-<NUM_LIT:1>]<EOL>if L < <NUM_LIT:2>:<EOL><INDENT>print (\"<STR_LIT>\")<EOL>return min(TINY_NUMBER, distribution.xmax - distribution.xmin)<EOL><DEDENT>else:<EOL><INDENT>return max(TINY_NUMBER, xvals[min(x_u+<NUM_LIT:1>,L-<NUM_LIT:1>)] - xvals[max(<NUM_LIT:0>,x_l-<NUM_LIT:1>)])<EOL><DEDENT>", "docstring": "Assess the width of the probability distribution. This returns\nfull-width-half-max", "id": "f2312:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def delta_function(cls, x_pos, weight=<NUM_LIT:1.>, min_width=MIN_INTEGRATION_PEAK):<DEDENT>", "body": "distribution = cls(x_pos,<NUM_LIT:0.>,is_log=True, min_width=min_width)<EOL>distribution.weight  = weight<EOL>return distribution<EOL>", "docstring": "Create delta function distribution.", "id": "f2312:c0:m1"}
{"signature": "def prepare_tree(self):", "body": "self.tree.root.branch_length = <NUM_LIT><EOL>self.tree.root.mutation_length = self.tree.root.branch_length<EOL>self.tree.root.mutations = []<EOL>self.tree.ladderize()<EOL>self._prepare_nodes()<EOL>self._leaves_lookup = {node.name:node for node in self.tree.get_terminals()}<EOL>", "docstring": "Set link to parent and calculate distance to root for all tree nodes.\nShould be run once the tree is read and after every rerooting,\ntopology change or branch length optimizations.", "id": "f2313:c0:m21"}
{"signature": "def optimize_branch_length(self, mode='<STR_LIT>', **kwargs):", "body": "self.logger(\"<STR_LIT>\"%mode,<NUM_LIT:1>)<EOL>if (self.tree is None) or (self.aln is None):<EOL><INDENT>self.logger(\"<STR_LIT>\", <NUM_LIT:0>)<EOL>return ttconf.ERROR<EOL><DEDENT>store_old_dist = False<EOL>if '<STR_LIT>' in kwargs:<EOL><INDENT>store_old_dist = kwargs['<STR_LIT>']<EOL><DEDENT>if mode=='<STR_LIT>':<EOL><INDENT>if not hasattr(self.tree.root, \"<STR_LIT>\"):<EOL><INDENT>self.infer_ancestral_sequences(marginal=True)<EOL><DEDENT><DEDENT>max_bl = <NUM_LIT:0><EOL>for node in self.tree.find_clades(order='<STR_LIT>'):<EOL><INDENT>if node.up is None: continue <EOL>if store_old_dist:<EOL><INDENT>node._old_length = node.branch_length<EOL><DEDENT>if mode=='<STR_LIT>':<EOL><INDENT>new_len = self.optimal_marginal_branch_length(node)<EOL><DEDENT>elif mode=='<STR_LIT>':<EOL><INDENT>new_len = self.optimal_branch_length(node)<EOL><DEDENT>else:<EOL><INDENT>self.logger(\"<STR_LIT>\",<NUM_LIT:4>, warn=True)<EOL>new_len = node.branch_length<EOL><DEDENT>if new_len < <NUM_LIT:0>:<EOL><INDENT>continue<EOL><DEDENT>self.logger(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"%(node.branch_length, new_len, len(node.mutations)*self.one_mutation), <NUM_LIT:5>)<EOL>node.branch_length = new_len<EOL>node.mutation_length=new_len<EOL>max_bl = max(max_bl, new_len)<EOL><DEDENT>self.tree.root.up = None<EOL>self.tree.root.dist2root = <NUM_LIT:0.0><EOL>if max_bl><NUM_LIT> and mode=='<STR_LIT>':<EOL><INDENT>self.logger(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\", <NUM_LIT:0>, warn=True)<EOL><DEDENT>self._prepare_nodes()<EOL>return ttconf.SUCCESS<EOL>", "docstring": "Perform optimization for the branch lengths of the entire tree.\nThis method only does a single path and needs to be iterated.\n\n**Note** this method assumes that each node stores information\nabout its sequence as numpy.array object (node.sequence attribute).\nTherefore, before calling this method, sequence reconstruction with\neither of the available models must be performed.\n\nParameters\n----------\n\n mode : str\n    Optimize branch length assuming the joint ML sequence assignment\n    of both ends of the branch (:code:`joint`), or trace over all possible sequence\n    assignments on both ends of the branch (:code:`marginal`) (slower, experimental).\n\n **kwargs :\n    Keyword arguments\n\nKeyword Args\n------------\n\n verbose : int\n    Output level\n\n store_old : bool\n    If True, the old lengths will be saved in :code:`node._old_dist` attribute.\n    Useful for testing, and special post-processing.", "id": "f2313:c0:m43"}
{"signature": "def process_alignment_dict(self):", "body": "<EOL>nseq = len(self.aln)<EOL>inv_map = defaultdict(list)<EOL>for k,v in self.aln.items():<EOL><INDENT>for pos, bs in v.items():<EOL><INDENT>inv_map[pos].append(bs)<EOL><DEDENT><DEDENT>self.nonref_positions = np.sort(list(inv_map.keys()))<EOL>self.inferred_const_sites = []<EOL>ambiguous_char = self.gtr.ambiguous<EOL>nonref_const = []<EOL>nonref_alleles = []<EOL>ambiguous_const = []<EOL>variable_pos = []<EOL>for pos, bs in inv_map.items(): <EOL><INDENT>bases = \"<STR_LIT>\".join(np.unique(bs))<EOL>if len(bs) == nseq:<EOL><INDENT>if (len(bases)<=<NUM_LIT:2> and ambiguous_char in bases) or len(bases)==<NUM_LIT:1>:<EOL><INDENT>nonref_const.append(pos)<EOL>nonref_alleles.append(bases.replace(ambiguous_char, '<STR_LIT>'))<EOL>if ambiguous_char in bases: <EOL><INDENT>self.inferred_const_sites.append(pos)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>variable_pos.append(pos)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if bases==ambiguous_char:<EOL><INDENT>ambiguous_const.append(pos)<EOL>self.inferred_const_sites.append(pos) <EOL><DEDENT>else:<EOL><INDENT>variable_pos.append(pos)<EOL><DEDENT><DEDENT><DEDENT>refMod = np.array(list(self.ref))<EOL>refMod[nonref_const] = nonref_alleles<EOL>states = self.gtr.alphabet<EOL>refMod[variable_pos] = '<STR_LIT:.>'<EOL>reduced_alignment_const = []<EOL>alignment_patterns_const = {}<EOL>for base in states:<EOL><INDENT>p = base*nseq<EOL>pos = list(np.where(refMod==base)[<NUM_LIT:0>])<EOL>if len(pos):<EOL><INDENT>alignment_patterns_const[p] = [len(reduced_alignment_const), pos]<EOL>reduced_alignment_const.append(list(p))<EOL><DEDENT><DEDENT>return reduced_alignment_const, alignment_patterns_const, variable_pos<EOL>", "docstring": "prepare the dictionary specifying differences from a reference sequence\nto construct the reduced alignment with variable sites only. NOTE:\n    - sites can be constant but different from the reference\n    - sites can be constant plus a ambiguous sites\n\nassigns\n-------\n- self.nonref_positions: at least one sequence is different from ref\n\nReturns\n-------\nreduced_alignment_const\n    reduced alignment accounting for non-variable postitions\n\nalignment_patterns_const\n    dict pattern -> (pos in reduced alignment, list of pos in full alignment)\n\nariable_positions\n    list of variable positions needed to construct remaining", "id": "f2313:c0:m20"}
{"signature": "def _fitch_state(self, node, pos):", "body": "state = self._fitch_intersect([k.state[pos] for k in node.clades])<EOL>if len(state) == <NUM_LIT:0>:<EOL><INDENT>state = np.concatenate([k.state[pos] for k in node.clades])<EOL><DEDENT>return state<EOL>", "docstring": "Determine the Fitch profile for a single character of the node's sequence.\nThe profile is essentially the intersection between the children's\nprofiles or, if the former is empty, the union of the profiles.\n\nParameters\n----------\n\n node : PhyloTree.Clade:\n    Internal node which the profiles are to be determined\n\n pos : int\n    Position in the node's sequence which the profiles should\n    be determinedf for.\n\nReturns\n-------\n state : numpy.array\n    Fitch profile for the character at position pos of the given node.", "id": "f2313:c0:m33"}
{"signature": "@property<EOL><INDENT>def leaves_lookup(self):<DEDENT>", "body": "return self._leaves_lookup<EOL>", "docstring": "The :code:`{leaf-name:leaf-node}` dictionary. It enables fast\nsearch of a tree leaf object by its name.", "id": "f2313:c0:m2"}
{"signature": "def _fitch_intersect(self, arrays):", "body": "def pairwise_intersect(arr1, arr2):<EOL><INDENT>s2 = set(arr2)<EOL>b3 = [val for val in arr1 if val in s2]<EOL>return b3<EOL><DEDENT>arrays = list(arrays) <EOL>N = len(arrays)<EOL>while N > <NUM_LIT:1>:<EOL><INDENT>arr1 = arrays.pop()<EOL>arr2 = arrays.pop()<EOL>arr = pairwise_intersect(arr1, arr2)<EOL>arrays.append(arr)<EOL>N = len(arrays)<EOL><DEDENT>return arrays[<NUM_LIT:0>]<EOL>", "docstring": "Find the intersection of any number of 1D arrays.\nReturn the sorted, unique values that are in all of the input arrays.\nAdapted from numpy.lib.arraysetops.intersect1d", "id": "f2313:c0:m34"}
{"signature": "def dict_sequence(self, node, keep_var_ambigs=False):", "body": "seq = {}<EOL>node_seq = node.cseq<EOL>if keep_var_ambigs and hasattr(node, \"<STR_LIT>\") and node.is_terminal():<EOL><INDENT>node_seq = node.original_cseq<EOL><DEDENT>for pos in self.nonref_positions:<EOL><INDENT>cseqLoc = self.full_to_reduced_sequence_map[pos]<EOL>base = node_seq[cseqLoc]<EOL>if self.ref[pos] != base:<EOL><INDENT>seq[pos] = base<EOL><DEDENT><DEDENT>return seq<EOL>", "docstring": "For VCF-based TreeAnc objects, we do not want to store the entire\nsequence on every node, as they could be large. Instead, this returns the dict\nof variants & their positions for this sequence. This is used in place of\n:py:meth:`treetime.TreeAnc.expanded_sequence` for VCF-based objects throughout TreeAnc. However, users can still\ncall :py:meth:`expanded_sequence` if they require the full sequence.\n\nParameters\n----------\n node  : PhyloTree.Clade\n    Tree node\n\nReturns\n-------\n seq : dict\n    dict where keys are the basepair position (numbering from 0) and value is the variant call", "id": "f2313:c0:m31"}
{"signature": "@property<EOL><INDENT>def gtr(self):<DEDENT>", "body": "return self._gtr<EOL>", "docstring": "The current GTR object.\n\n:setter: Sets the GTR object passed in\n:getter: Returns the current GTR object", "id": "f2313:c0:m3"}
{"signature": "@property<EOL><INDENT>def ref(self):<DEDENT>", "body": "return self._ref<EOL>", "docstring": "Get the str reference nucleotide sequence currently used by TreeAnc.\nWhen having read alignment in from a VCF, this is what variants map to.\n\n:setter: Sets the string reference sequence\n:getter: Returns the string reference sequence", "id": "f2313:c0:m14"}
{"signature": "def _store_compressed_sequence_pairs(self):", "body": "self.logger(\"<STR_LIT>\",<NUM_LIT:2>)<EOL>for node in self.tree.find_clades():<EOL><INDENT>if node.up is None:<EOL><INDENT>continue<EOL><DEDENT>self._store_compressed_sequence_to_node(node)<EOL><DEDENT>self.logger(\"<STR_LIT>\",<NUM_LIT:3>)<EOL>", "docstring": "Traverse the tree, and for each node store the compressed sequence pair.\n**Note** sequence reconstruction should be performed prior to calling\nthis method.", "id": "f2313:c0:m41"}
{"signature": "def prune_short_branches(self):", "body": "self.logger(\"<STR_LIT>\", <NUM_LIT:1>)<EOL>for node in self.tree.find_clades():<EOL><INDENT>if node.up is None or node.is_terminal():<EOL><INDENT>continue<EOL><DEDENT>if self.gtr.prob_t(node.up.cseq, node.cseq, <NUM_LIT:0.0>,<EOL>pattern_multiplicity=self.multiplicity) > <NUM_LIT:0.1>:<EOL><INDENT>node.up.clades = [k for k in node.up.clades if k != node] + node.clades<EOL>for clade in node.clades:<EOL><INDENT>clade.up = node.up<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "If the branch length is less than the minimal value, remove the branch\nfrom the tree. **Requires** ancestral sequence reconstruction", "id": "f2313:c0:m48"}
{"signature": "def expanded_sequence(self, node, include_additional_constant_sites=False):", "body": "if include_additional_constant_sites:<EOL><INDENT>L = self.seq_len<EOL><DEDENT>else:<EOL><INDENT>L = self.seq_len - self.additional_constant_sites<EOL><DEDENT>return node.cseq[self.full_to_reduced_sequence_map[:L]]<EOL>", "docstring": "Expand a nodes compressed sequence into the real sequence\n\nParameters\n----------\nnode : PhyloTree.Clade\n   Tree node\n\nReturns\n-------\nseq : np.array\n   Sequence as np.array of chars", "id": "f2313:c0:m30"}
{"signature": "def date_uncertainty_due_to_rate(self, node, interval=(<NUM_LIT>, <NUM_LIT>)):", "body": "if hasattr(node, \"<STR_LIT>\"):<EOL><INDENT>from scipy.special import erfinv<EOL>nsig = [np.sqrt(<NUM_LIT>)*erfinv(-<NUM_LIT:1.0> + <NUM_LIT>*x) if x*(<NUM_LIT:1.0>-x) else <NUM_LIT:0><EOL>for x in interval]<EOL>l,c,u = [x[<NUM_LIT:1>] for x in node.numdate_rate_variation]<EOL>return np.array([c + x*np.abs(y-c) for x,y in zip(nsig, (l,u))])<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "use previously calculated variation of the rate to estimate\n        the uncertainty in a particular numdate due to rate variation.\n\n        Parameters\n        ----------\n        node : PhyloTree.Clade\n            node for which the confidence interval is to be calculated\n        interval : tuple, optional\n            Array of length two, or tuple, defining the bounds of the confidence interval", "id": "f2314:c0:m15"}
{"signature": "def timetree_likelihood(self):", "body": "LH = <NUM_LIT:0><EOL>for node in self.tree.find_clades(order='<STR_LIT>'):  <EOL><INDENT>if node.up is None: <EOL><INDENT>continue<EOL><DEDENT>LH -= node.branch_length_interpolator(node.branch_length)<EOL><DEDENT>if self.aln:<EOL><INDENT>LH += self.gtr.sequence_logLH(self.tree.root.cseq, pattern_multiplicity=self.multiplicity)<EOL><DEDENT>return LH<EOL>", "docstring": "Return the likelihood of the data given the current branch length in the tree", "id": "f2314:c0:m10"}
{"signature": "def get_confidence_interval(self, node, interval = (<NUM_LIT>, <NUM_LIT>)):", "body": "rate_contribution = self.date_uncertainty_due_to_rate(node, interval)<EOL>if hasattr(node, \"<STR_LIT>\"):<EOL><INDENT>min_date, max_date = [self.date2dist.to_numdate(x) for x in<EOL>(node.marginal_pos_LH.xmax, node.marginal_pos_LH.xmin)]<EOL>if node.marginal_inverse_cdf==\"<STR_LIT>\":<EOL><INDENT>return np.array([node.numdate, node.numdate])<EOL><DEDENT>else:<EOL><INDENT>mutation_contribution = self.date2dist.to_numdate(node.marginal_inverse_cdf(np.array(interval))[::-<NUM_LIT:1>])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>min_date, max_date = [-np.inf, np.inf]<EOL><DEDENT>return self.combine_confidence(node.numdate, (min_date, max_date),<EOL>c1=rate_contribution, c2=mutation_contribution)<EOL>", "docstring": "If temporal reconstruction was done using the marginal ML mode, the entire distribution of\ntimes is available. This function determines the 90% (or other) confidence interval, defined as the\nrange where 5% of probability is below and above. Note that this does not necessarily contain\nthe highest probability position.\nIn absense of marginal reconstruction, it will return uncertainty based on rate\nvariation. If both are present, the wider interval will be returned.\n\nParameters\n----------\n\n node : PhyloTree.Clade\n    The node for which the confidence interval is to be calculated\n\n interval : tuple, list\n    Array of length two, or tuple, defining the bounds of the confidence interval\n\nReturns\n-------\n\n confidence_interval : numpy array\n    Array with two numerical dates delineating the confidence interval", "id": "f2314:c0:m17"}
{"signature": "def _assign_dates(self):", "body": "if self.tree is None:<EOL><INDENT>self.logger(\"<STR_LIT>\", <NUM_LIT:0>)<EOL>return ttconf.ERROR<EOL><DEDENT>bad_branch_counter = <NUM_LIT:0><EOL>for node in self.tree.find_clades(order='<STR_LIT>'):<EOL><INDENT>if node.name in self.date_dict:<EOL><INDENT>tmp_date = self.date_dict[node.name]<EOL>if np.isscalar(tmp_date) and np.isnan(tmp_date):<EOL><INDENT>self.logger(\"<STR_LIT>\"%(node.name, str(tmp_date)), <NUM_LIT:2>, warn=True)<EOL>node.raw_date_constraint = None<EOL>node.bad_branch = True<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>tmp = np.mean(tmp_date)<EOL>node.raw_date_constraint = tmp_date<EOL>node.bad_branch = False<EOL><DEDENT>except:<EOL><INDENT>self.logger(\"<STR_LIT>\"%(node.name, str(tmp_date)), <NUM_LIT:2>, warn=True)<EOL>node.raw_date_constraint = None<EOL>node.bad_branch = True<EOL><DEDENT><DEDENT><DEDENT>else: <EOL><INDENT>node.raw_date_constraint = None<EOL>if node.is_terminal():<EOL><INDENT>node.bad_branch = True<EOL><DEDENT>else:<EOL><INDENT>node.bad_branch = np.all([x.bad_branch for x in node])<EOL><DEDENT><DEDENT>if node.is_terminal() and node.bad_branch:<EOL><INDENT>bad_branch_counter += <NUM_LIT:1><EOL><DEDENT><DEDENT>if bad_branch_counter>self.tree.count_terminals()-<NUM_LIT:3>:<EOL><INDENT>self.logger(\"<STR_LIT>\", <NUM_LIT:1>, warn=True)<EOL>return ttconf.ERROR<EOL><DEDENT>return ttconf.SUCCESS<EOL>", "docstring": "assign dates to nodes\n\n        Returns\n        -------\n        str\n            success/error code", "id": "f2314:c0:m1"}
{"signature": "def explained_variance(self):", "body": "self.tree.root._v=<NUM_LIT:0><EOL>for n in self.tree.get_nonterminals(order='<STR_LIT>'):<EOL><INDENT>for c in n:<EOL><INDENT>c._v = n._v + self.branch_value(c)<EOL><DEDENT><DEDENT>raw = np.array([(self.tip_value(n), n._v) for n in self.tree.get_terminals()<EOL>if self.tip_value(n) is not None])<EOL>return np.corrcoef(raw.T)[<NUM_LIT:0>,<NUM_LIT:1>]<EOL>", "docstring": "calculate standard explained variance\n\n        Returns\n        -------\n        float\n            r-value of the root-to-tip distance and time.\n            independent of regression model, but dependent on root choice", "id": "f2315:c0:m6"}
{"signature": "def recurse(self, full_matrix=False):", "body": "for n in self.tree.get_nonterminals(order='<STR_LIT>'):<EOL><INDENT>n_leaves = len(n._ii)<EOL>if full_matrix: M = np.zeros((n_leaves, n_leaves), dtype=float)<EOL>r = np.zeros(n_leaves, dtype=float)<EOL>c_count = <NUM_LIT:0><EOL>for c in n:<EOL><INDENT>ssq = self.branch_variance(c)<EOL>nc = len(c._ii)<EOL>if c.is_terminal():<EOL><INDENT>if full_matrix:<EOL><INDENT>M[c_count, c_count] = <NUM_LIT:1.0>/ssq<EOL><DEDENT>r[c_count] = <NUM_LIT:1.0>/ssq<EOL><DEDENT>else:<EOL><INDENT>if full_matrix:<EOL><INDENT>M[c_count:c_count+nc, c_count:c_count+nc] = c.cinv - ssq*np.outer(c.r,c.r)/(<NUM_LIT:1>+ssq*c.s)<EOL><DEDENT>r[c_count:c_count+nc] = c.r/(<NUM_LIT:1>+ssq*c.s)<EOL><DEDENT>c_count += nc<EOL><DEDENT>if full_matrix: n.cinv = M<EOL>n.r = r <EOL>n.s = n.r.sum()<EOL><DEDENT>", "docstring": "recursion to calculate inverse covariance matrix\n\nParameters\n----------\nfull_matrix : bool, optional\n    if True, the entire inverse matrix is calculated. otherwise, only the weighing vector.", "id": "f2315:c0:m3"}
{"signature": "def __init__(self, tree_in, tip_value = None,<EOL>branch_value = None, branch_variance = None):", "body": "super(TreeRegression, self).__init__()<EOL>self.tree = tree_in<EOL>for li, l in enumerate(self.tree.get_terminals()):<EOL><INDENT>l._ii = np.array([li])<EOL><DEDENT>total_bl = <NUM_LIT:0><EOL>for n in self.tree.get_nonterminals(order='<STR_LIT>'):<EOL><INDENT>n._ii = np.concatenate([c._ii for c in n])<EOL>n._ii.sort()<EOL>for c in n:<EOL><INDENT>c.up=n<EOL>total_bl+=c.branch_length<EOL><DEDENT><DEDENT>self.tree.root.up=None<EOL>self.N = self.tree.root._ii.shape[<NUM_LIT:0>]<EOL>if tip_value is None:<EOL><INDENT>self.tip_value = lambda x:np.mean(x.numdate) if x.is_terminal() else None<EOL><DEDENT>else:<EOL><INDENT>self.tip_value = tip_value<EOL><DEDENT>if branch_value is None:<EOL><INDENT>self.branch_value = lambda x:x.branch_length<EOL><DEDENT>else:<EOL><INDENT>self.branch_value = branch_value<EOL><DEDENT>if branch_variance is None:<EOL><INDENT>self.branch_variance = lambda x:x.branch_length + <NUM_LIT>*total_bl/self.N<EOL><DEDENT>else:<EOL><INDENT>self.branch_variance = branch_variance<EOL><DEDENT>", "docstring": "Parameters\n----------\n T : (Bio.Phylo.tree)\n    Tree for which the covariances and regression\n    are to be calculated.\n\n tip_value : (callable)\n    function that for each tip returns the value to\n    be used in the regression.\n\n branch_value : (callable)\n    function that for each node of the tree returns\n    the contribution of this branch to the value of\n    the subtending tips.\n\n variance_function : (callable)\n    function that for each node of the tree returns\n    the accumulated variance", "id": "f2315:c0:m0"}
{"signature": "def optimal_reroot(self, force_positive=True, slope=None):", "body": "best_root = self.find_best_root(force_positive=force_positive, slope=slope)<EOL>best_node = best_root[\"<STR_LIT>\"]<EOL>x = best_root[\"<STR_LIT>\"]<EOL>if x<<NUM_LIT>:<EOL><INDENT>new_node = best_node<EOL><DEDENT>elif x><NUM_LIT:1.0>-<NUM_LIT>:<EOL><INDENT>new_node = best_node.up<EOL><DEDENT>else:<EOL><INDENT>new_node = Phylo.BaseTree.Clade()<EOL>new_node.branch_length = best_node.branch_length*(<NUM_LIT:1>-x)<EOL>new_node.up = best_node.up<EOL>new_node.clades = [best_node]<EOL>new_node.up.clades = [k if k!=best_node else new_node<EOL>for k in best_node.up.clades]<EOL>best_node.branch_length *= x<EOL>best_node.up = new_node<EOL><DEDENT>new_node.rtt_regression = best_root<EOL>self.tree.root_with_outgroup(new_node)<EOL>self.tree.ladderize()<EOL>for n in self.tree.get_nonterminals(order='<STR_LIT>'):<EOL><INDENT>for c in n:<EOL><INDENT>c.up=n<EOL><DEDENT><DEDENT>return best_root<EOL>", "docstring": "determine the best root and reroot the tree to this value.\nNote that this can change the parent child relations of the tree\nand values associated with branches rather than nodes\n(e.g. confidence) might need to be re-evaluated afterwards\n\nParameters\n----------\nforce_positive : bool, optional\n    if True, the search for a root will only consider positive rate estimates\n\nslope : float, optional\n    if given, it will find the optimal root given a fixed rate. If slope==0, this\n    corresponds to minimal root-to-tip variance rooting (min_dev)\n\nReturns\n-------\ndict\n    regression parameters", "id": "f2315:c0:m10"}
{"signature": "def Cov(self):", "body": "<EOL>M = np.zeros((self.N, self.N))<EOL>for n in self.tree.find_clades():<EOL><INDENT>if n == self.tree.root:<EOL><INDENT>continue<EOL><DEDENT>M[np.meshgrid(n._ii, n._ii)] += self.branch_variance(n)<EOL><DEDENT>return M<EOL>", "docstring": "calculate the covariance matrix of the tips assuming variance\nhas accumulated along branches of the tree accoriding to the\nthe provided\nReturns\n-------\n\n M : (np.array)\n    covariance matrix with tips arranged standard transersal order.", "id": "f2315:c0:m1"}
{"signature": "def CovInv(self):", "body": "self.recurse(full_matrix=True)<EOL>return self.tree.root.cinv<EOL>", "docstring": "Inverse of the covariance matrix\n\nReturns\n-------\n\n H : (np.array)\n    inverse of the covariance matrix.", "id": "f2315:c0:m2"}
{"signature": "def regression(self, slope=None):", "body": "self._calculate_averages()<EOL>clock_model = base_regression(self.tree.root.Q, slope)<EOL>clock_model['<STR_LIT>'] = self.explained_variance()<EOL>return clock_model<EOL>", "docstring": "regress tip values against branch values\n\n        Parameters\n        ----------\n        slope : None, optional\n            if given, the slope isn't optimized\n\n        Returns\n        -------\n        dict\n            regression parameters", "id": "f2315:c0:m7"}
{"signature": "def numdate_from_dist2root(self, d2r):", "body": "return (d2r-self.intercept)/self.clock_rate<EOL>", "docstring": "estimate the numerical date based on the distance to root.\n-> crude dating of internal nodes", "id": "f2316:c0:m7"}
{"signature": "def to_years(self, abs_t):", "body": "return abs_t / abs(self.clock_rate)<EOL>", "docstring": "Convert the time before present measured in branch length units to years", "id": "f2316:c0:m5"}
{"signature": "def get_time_before_present(self, numdate):", "body": "return (numeric_date() - numdate) * abs(self.clock_rate)<EOL>", "docstring": "Convert the numeric date to the branch-len scale", "id": "f2316:c0:m4"}
{"signature": "def F81(mu=<NUM_LIT:1.0>, pi=None, alphabet=\"<STR_LIT>\", **kwargs):", "body": "if pi is None:<EOL><INDENT>pi=<NUM_LIT>*np.ones(<NUM_LIT:4>, dtype=float)<EOL><DEDENT>num_chars = len(alphabets[alphabet])<EOL>pi = np.array(pi, dtype=float)<EOL>if num_chars != len(pi) :<EOL><INDENT>pi = np.ones((num_chars, ), dtype=float)<EOL>print (\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>W = np.ones((num_chars,num_chars))<EOL>pi /= (<NUM_LIT:1.0> * np.sum(pi))<EOL>gtr = GTR(alphabet=alphabets[alphabet])<EOL>gtr.assign_rates(mu=mu, pi=pi, W=W)<EOL>return gtr<EOL>", "docstring": "Felsenstein 1981 model. Assumes non-equal concentrations across nucleotides,\nbut the transition rate between all states is assumed to be equal. See\nFelsenstein (1981), J. Mol. Evol. 17  (6): 368\u2013376. doi:10.1007/BF01734359\nfor details.\n\nCurrent implementation of the model does not account for the gaps (treatment of\ngaps as characters is possible if specify alphabet='nuc_gap').\n\nParameters\n-----------\n\n\n mu : float\n    Substitution rate\n\n pi : numpy.array\n    Nucleotide concentrations\n\n alphabet : str\n    Alphabet to use. POsiible values are: ['nuc', 'nuc_gap'] Default 'nuc', which discounts al gaps.\n    'nuc_gap' alphabet enables treatmen of gaps as characters.", "id": "f2317:m2"}
{"signature": "def K80(mu=<NUM_LIT:1.>, kappa=<NUM_LIT:0.1>, **kwargs):", "body": "num_chars = len(alphabets['<STR_LIT>'])<EOL>pi = np.ones(len(alphabets['<STR_LIT>']), dtype=float)/len(alphabets['<STR_LIT>'])<EOL>W = _create_transversion_transition_W(kappa)<EOL>gtr = GTR(alphabet=alphabets['<STR_LIT>'])<EOL>gtr.assign_rates(mu=mu, pi=pi, W=W)<EOL>return gtr<EOL>", "docstring": "Kimura 1980 model. Assumes equal concentrations across nucleotides, but\nallows different rates between transitions and transversions. The ratio\nof the transversion/transition rates is given by kappa parameter.\nFor more info, see\nKimura (1980),  J. Mol. Evol. 16 (2): 111\u2013120. doi:10.1007/BF01731581.\n\nCurrent implementation of the model does not account for the gaps.\n\nParameters\n-----------\n\n mu : float\n    Overall substitution rate\n\n kappa : float\n    Ratio of transversion/transition rates", "id": "f2317:m1"}
{"signature": "def HKY85(mu=<NUM_LIT:1.0>, pi=None, kappa=<NUM_LIT:0.1>, **kwargs):", "body": "if pi is None:<EOL><INDENT>pi=<NUM_LIT>*np.ones(<NUM_LIT:4>, dtype=float)<EOL><DEDENT>num_chars = len(alphabets['<STR_LIT>'])<EOL>if num_chars != pi.shape[<NUM_LIT:0>] :<EOL><INDENT>pi = np.ones((num_chars, ), dtype=float)<EOL>print (\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>W = _create_transversion_transition_W(kappa)<EOL>pi /= pi.sum()<EOL>gtr = GTR(alphabet=alphabets['<STR_LIT>'])<EOL>gtr.assign_rates(mu=mu, pi=pi, W=W)<EOL>return gtr<EOL>", "docstring": "Hasegawa, Kishino and Yano 1985 model. Allows different concentrations of the\nnucleotides (as in F81) + distinguishes between transition/transversionsubstitutions\n(similar to K80). Link:\nHasegawa, Kishino, Yano (1985), J. Mol. Evol. 22 (2): 160\u2013174. doi:10.1007/BF02101694\n\nCurrent implementation of the model does not account for the gaps\n\nParameters\n-----------\n\n\n mu : float\n    Substitution rate\n\n pi : numpy.array\n    Nucleotide concentrations\n\n kappa : float\n    Ratio of transversion/transition substitution rates", "id": "f2317:m3"}
{"signature": "def optimal_t(self, seq_p, seq_ch, pattern_multiplicity=None, ignore_gaps=False):", "body": "seq_pair, multiplicity = self.compress_sequence_pair(seq_p, seq_ch,<EOL>pattern_multiplicity = pattern_multiplicity,<EOL>ignore_gaps=ignore_gaps)<EOL>return self.optimal_t_compressed(seq_pair, multiplicity)<EOL>", "docstring": "Find the optimal distance between the two sequences\n\nParameters\n----------\n\n seq_p : character array\n    Parent sequence\n\n seq_c : character array\n    Child sequence\n\n pattern_multiplicity : numpy array\n    If sequences are reduced by combining identical alignment patterns,\n    these multplicities need to be accounted for when counting the number\n    of mutations across a branch. If None, all pattern are assumed to\n    occur exactly once.\n\n ignore_gaps : bool\n    If True, ignore gaps in distance calculations", "id": "f2318:c0:m15"}
{"signature": "def _eig_sym(self):", "body": "<EOL>tmpp = np.sqrt(self.Pi)<EOL>symQ = self.W*np.outer(tmpp, tmpp)<EOL>eigvals, eigvecs = np.linalg.eigh(symQ)<EOL>tmp_v = eigvecs.T*tmpp<EOL>one_norm = np.sum(np.abs(tmp_v), axis=<NUM_LIT:1>)<EOL>self.v = tmp_v.T/one_norm<EOL>self.v_inv = (eigvecs*one_norm).T/tmpp<EOL>self.eigenvals = eigvals<EOL>", "docstring": "Perform eigendecompositon of the rate matrix and stores the left- and right-\nmatrices to convert the sequence profiles to the GTR matrix eigenspace\nand hence to speed-up the computations.", "id": "f2318:c0:m11"}
{"signature": "def prob_t_compressed(self, seq_pair, multiplicity, t, return_log=False):", "body": "if t<<NUM_LIT:0>:<EOL><INDENT>logP = -ttconf.BIG_NUMBER<EOL><DEDENT>else:<EOL><INDENT>tmp_eQT = self.expQt(t)<EOL>bad_indices=(tmp_eQT==<NUM_LIT:0>)<EOL>logQt = np.log(tmp_eQT + ttconf.TINY_NUMBER*(bad_indices))<EOL>logQt[np.isnan(logQt) | np.isinf(logQt) | bad_indices] = -ttconf.BIG_NUMBER<EOL>logP = np.sum(logQt[seq_pair[:,<NUM_LIT:1>], seq_pair[:,<NUM_LIT:0>]]*multiplicity)<EOL><DEDENT>return logP if return_log else np.exp(logP)<EOL>", "docstring": "Calculate the probability of observing a sequence pair at a distance t,\nfor compressed sequences\n\nParameters\n----------\n\n  seq_pair : numpy array\n    :code:`np.array([(0,1), (2,2), ()..])` as indicies of\n    pairs of aligned positions. (e.g. 'A'==0, 'C'==1 etc).\n    This only lists all occuring parent-child state pairs, order is irrelevant\n\n  multiplicity : numpy array\n    The number of times a parent-child state pair is observed.\n    This allows compression of the sequence representation\n\n  t : float\n    Length of the branch separating parent and child\n\n  return_log : bool\n    Whether or not to exponentiate the result", "id": "f2318:c0:m13"}
{"signature": "def __str__(self):", "body": "multi_site = len(self.Pi.shape)==<NUM_LIT:2><EOL>if multi_site:<EOL><INDENT>eq_freq_str = \"<STR_LIT>\"+str(np.round(self.average_rate,<NUM_LIT:6>))+'<STR_LIT:\\n>'<EOL><DEDENT>else:<EOL><INDENT>eq_freq_str = \"<STR_LIT>\"+str(np.round(self.mu,<NUM_LIT:6>))+'<STR_LIT:\\n>'<EOL><DEDENT>if not multi_site:<EOL><INDENT>eq_freq_str += \"<STR_LIT>\"<EOL>for a,p in zip(self.alphabet, self.Pi):<EOL><INDENT>eq_freq_str+='<STR_LIT:U+0020>'+str(a)+'<STR_LIT>'+str(np.round(p,<NUM_LIT:4>))+'<STR_LIT:\\n>'<EOL><DEDENT><DEDENT>W_str = \"<STR_LIT>\"<EOL>W_str+='<STR_LIT:\\t>'+'<STR_LIT:\\t>'.join(map(str, self.alphabet))+'<STR_LIT:\\n>'<EOL>for a,Wi in zip(self.alphabet, self.W):<EOL><INDENT>W_str+= '<STR_LIT:U+0020>'+str(a)+'<STR_LIT:\\t>'+'<STR_LIT:\\t>'.join([str(np.round(max(<NUM_LIT:0>,p),<NUM_LIT:4>)) for p in Wi])+'<STR_LIT:\\n>'<EOL><DEDENT>if not multi_site:<EOL><INDENT>Q_str = \"<STR_LIT>\"<EOL>Q_str+='<STR_LIT:\\t>'+'<STR_LIT:\\t>'.join(map(str, self.alphabet))+'<STR_LIT:\\n>'<EOL>for a,Qi in zip(self.alphabet, self.Q):<EOL><INDENT>Q_str+= '<STR_LIT:U+0020>'+str(a)+'<STR_LIT:\\t>'+'<STR_LIT:\\t>'.join([str(np.round(max(<NUM_LIT:0>,p),<NUM_LIT:4>)) for p in Qi])+'<STR_LIT:\\n>'<EOL><DEDENT><DEDENT>return eq_freq_str + W_str + Q_str<EOL>", "docstring": "String representation of the GTR model for pretty printing", "id": "f2318:c0:m3"}
{"signature": "def _check_fix_Q(self, fixed_mu=False):", "body": "<EOL>self.Pi /= self.Pi.sum() <EOL>self.W += self.break_degen + self.break_degen.T<EOL>np.fill_diagonal(self.W, <NUM_LIT:0>)<EOL>Wdiag = -(self.Q).sum(axis=<NUM_LIT:0>)/self.Pi<EOL>np.fill_diagonal(self.W, Wdiag)<EOL>scale_factor = -np.sum(np.diagonal(self.Q)*self.Pi)<EOL>self.W /= scale_factor<EOL>if not fixed_mu:<EOL><INDENT>self.mu *= scale_factor<EOL><DEDENT>if (self.Q.sum(axis=<NUM_LIT:0>) < <NUM_LIT>).sum() <  self.alphabet.shape[<NUM_LIT:0>]: <EOL><INDENT>print (\"<STR_LIT>\", self.Q.sum(axis=<NUM_LIT:0>))<EOL>import ipdb; ipdb.set_trace()<EOL>raise ArithmeticError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Check the main diagonal of Q and fix it in case it does not corresond\nthe definition of the rate matrix. Should be run every time when creating\ncustom GTR model.", "id": "f2318:c0:m9"}
{"signature": "def prob_t(self, seq_p, seq_ch, t, pattern_multiplicity = None,<EOL>return_log=False, ignore_gaps=True):", "body": "seq_pair, multiplicity = self.compress_sequence_pair(seq_p, seq_ch,<EOL>pattern_multiplicity=pattern_multiplicity, ignore_gaps=ignore_gaps)<EOL>return self.prob_t_compressed(seq_pair, multiplicity, t, return_log=return_log)<EOL>", "docstring": "Compute the probability to observe seq_ch (child sequence) after time t starting from seq_p\n(parent sequence).\n\nParameters\n----------\n\n seq_p : character array\n    Parent sequence\n\n seq_c : character array\n    Child sequence\n\n t : double\n    Time (branch len) separating the profiles.\n\n pattern_multiplicity : numpy array\n    If sequences are reduced by combining identical alignment patterns,\n    these multplicities need to be accounted for when counting the number\n    of mutations across a branch. If None, all pattern are assumed to\n    occur exactly once.\n\n return_log : bool\n    It True, return log-probability.\n\nReturns\n-------\n prob : np.array\n    Resulting probability", "id": "f2318:c0:m14"}
{"signature": "def expQt(self, t):", "body": "eLambdaT = np.diag(self._exp_lt(t)) <EOL>Qs = self.v.dot(eLambdaT.dot(self.v_inv))   <EOL>return np.maximum(<NUM_LIT:0>,Qs)<EOL>", "docstring": "Parameters\n----------\n\n t : float\n    Time to propagate\n\nReturns\n--------\n\n expQt : numpy.array\n    Matrix exponential of exo(Qt)", "id": "f2318:c0:m21"}
{"signature": "def run(self, root=None, infer_gtr=True, relaxed_clock=None, n_iqd = None,<EOL>resolve_polytomies=True, max_iter=<NUM_LIT:0>, Tc=None, fixed_clock_rate=None,<EOL>time_marginal=False, sequence_marginal=False, branch_length_mode='<STR_LIT>',<EOL>vary_rate=False, use_covariation=False, **kwargs):", "body": "<EOL>self.use_covariation = use_covariation<EOL>if (self.tree is None) or (self.aln is None and self.seq_len is None):<EOL><INDENT>self.logger(\"<STR_LIT>\", <NUM_LIT:0>)<EOL>return ttconf.ERROR<EOL><DEDENT>if (self.aln is None):<EOL><INDENT>branch_length_mode='<STR_LIT:input>'<EOL><DEDENT>self._set_branch_length_mode(branch_length_mode)<EOL>seq_kwargs = {\"<STR_LIT>\":sequence_marginal or (self.branch_length_mode=='<STR_LIT>'),<EOL>\"<STR_LIT>\":\"<STR_LIT:root>\"}<EOL>tt_kwargs = {'<STR_LIT>':fixed_clock_rate, '<STR_LIT>':False}<EOL>tt_kwargs.update(kwargs)<EOL>seq_LH = <NUM_LIT:0><EOL>if \"<STR_LIT>\" in kwargs:<EOL><INDENT>seq_kwargs[\"<STR_LIT>\"] = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>if \"<STR_LIT>\" in kwargs:<EOL><INDENT>time_marginal=kwargs[\"<STR_LIT>\"]<EOL><DEDENT>if self.branch_length_mode=='<STR_LIT:input>':<EOL><INDENT>if self.aln:<EOL><INDENT>self.infer_ancestral_sequences(infer_gtr=infer_gtr, **seq_kwargs)<EOL>self.prune_short_branches()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.optimize_sequences_and_branch_length(infer_gtr=infer_gtr,<EOL>max_iter=<NUM_LIT:1>, prune_short=True, **seq_kwargs)<EOL><DEDENT>avg_root_to_tip = np.mean([x.dist2root for x in self.tree.get_terminals()])<EOL>if n_iqd or root=='<STR_LIT>':<EOL><INDENT>if \"<STR_LIT>\" in kwargs and kwargs[\"<STR_LIT>\"]:<EOL><INDENT>plot_rtt=True<EOL><DEDENT>else:<EOL><INDENT>plot_rtt=False<EOL><DEDENT>reroot_mechanism = '<STR_LIT>' if root=='<STR_LIT>' else root<EOL>if self.clock_filter(reroot=reroot_mechanism, n_iqd=n_iqd, plot=plot_rtt)==ttconf.ERROR:<EOL><INDENT>return ttconf.ERROR<EOL><DEDENT><DEDENT>elif root is not None:<EOL><INDENT>if self.reroot(root=root)==ttconf.ERROR:<EOL><INDENT>return ttconf.ERROR<EOL><DEDENT><DEDENT>if self.branch_length_mode=='<STR_LIT:input>':<EOL><INDENT>if self.aln:<EOL><INDENT>self.infer_ancestral_sequences(**seq_kwargs)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.optimize_sequences_and_branch_length(max_iter=<NUM_LIT:1>, prune_short=False,<EOL>**seq_kwargs)<EOL><DEDENT>self.logger(\"<STR_LIT>\",<NUM_LIT:0>)<EOL>self.make_time_tree(**tt_kwargs)<EOL>if self.aln:<EOL><INDENT>seq_LH = self.tree.sequence_marginal_LH if seq_kwargs['<STR_LIT>'] else self.tree.sequence_joint_LH<EOL><DEDENT>self.LH =[[seq_LH, self.tree.positional_joint_LH, <NUM_LIT:0>]]<EOL>if root is not None and max_iter:<EOL><INDENT>if self.reroot(root='<STR_LIT>' if root=='<STR_LIT>' else root)==ttconf.ERROR:<EOL><INDENT>return ttconf.ERROR<EOL><DEDENT><DEDENT>niter = <NUM_LIT:0><EOL>ndiff = <NUM_LIT:0><EOL>need_new_time_tree=False<EOL>while niter < max_iter:<EOL><INDENT>self.logger(\"<STR_LIT>\"%(niter+<NUM_LIT:1>,max_iter),<NUM_LIT:0>)<EOL>if Tc:<EOL><INDENT>if Tc=='<STR_LIT>' and niter<max_iter-<NUM_LIT:1>:<EOL><INDENT>tmpTc='<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>tmpTc=Tc<EOL><DEDENT>self.add_coalescent_model(tmpTc, **kwargs)<EOL>need_new_time_tree = True<EOL><DEDENT>if relaxed_clock:<EOL><INDENT>print(\"<STR_LIT>\", relaxed_clock)<EOL>self.relaxed_clock(**relaxed_clock)<EOL>need_new_time_tree = True<EOL><DEDENT>n_resolved=<NUM_LIT:0><EOL>if resolve_polytomies:<EOL><INDENT>n_resolved = self.resolve_polytomies()<EOL>if n_resolved:<EOL><INDENT>self.prepare_tree()<EOL>if self.branch_length_mode!='<STR_LIT:input>': <EOL><INDENT>self.optimize_sequences_and_branch_length(prune_short=False,<EOL>max_iter=<NUM_LIT:0>, **seq_kwargs)<EOL><DEDENT>need_new_time_tree = True<EOL><DEDENT><DEDENT>if need_new_time_tree:<EOL><INDENT>self.make_time_tree(**tt_kwargs)<EOL>if self.aln:<EOL><INDENT>ndiff = self.infer_ancestral_sequences('<STR_LIT>',**seq_kwargs)<EOL><DEDENT><DEDENT>else: <EOL><INDENT>if self.aln:<EOL><INDENT>ndiff = self.infer_ancestral_sequences('<STR_LIT>',**seq_kwargs)<EOL><DEDENT>self.make_time_tree(**tt_kwargs)<EOL><DEDENT>self.tree.coalescent_joint_LH = self.merger_model.total_LH() if Tc else <NUM_LIT:0.0><EOL>if self.aln:<EOL><INDENT>seq_LH = self.tree.sequence_marginal_LH if seq_kwargs['<STR_LIT>'] else self.tree.sequence_joint_LH<EOL><DEDENT>self.LH.append([seq_LH, self.tree.positional_joint_LH, self.tree.coalescent_joint_LH])<EOL>niter+=<NUM_LIT:1><EOL>if ndiff==<NUM_LIT:0> and n_resolved==<NUM_LIT:0> and Tc!='<STR_LIT>':<EOL><INDENT>self.logger(\"<STR_LIT>\",<NUM_LIT:0>)<EOL>break<EOL><DEDENT><DEDENT>if vary_rate:<EOL><INDENT>if type(vary_rate)==float:<EOL><INDENT>res = self.calc_rate_susceptibility(rate_std=vary_rate, params=tt_kwargs)<EOL><DEDENT>elif self.clock_model['<STR_LIT>']:<EOL><INDENT>res = self.calc_rate_susceptibility(params=tt_kwargs)<EOL><DEDENT>else:<EOL><INDENT>res = ttconf.ERROR<EOL><DEDENT>if res==ttconf.ERROR:<EOL><INDENT>self.logger(\"<STR_LIT>\", <NUM_LIT:1>, warn=True)<EOL><DEDENT><DEDENT>if time_marginal:<EOL><INDENT>self.logger(\"<STR_LIT>\", <NUM_LIT:0>)<EOL>tt_kwargs['<STR_LIT>']=time_marginal<EOL>self.make_time_tree(**tt_kwargs)<EOL><DEDENT>bad_branches =[n for n in self.tree.get_terminals()<EOL>if n.bad_branch and n.raw_date_constraint]<EOL>if bad_branches:<EOL><INDENT>self.logger(\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<NUM_LIT:0>,warn=True)<EOL>for n in bad_branches:<EOL><INDENT>self.logger(\"<STR_LIT>\"%(n.name, str(n.raw_date_constraint), n.numdate),<NUM_LIT:0>,warn=True)<EOL><DEDENT><DEDENT>return ttconf.SUCCESS<EOL>", "docstring": "Run TreeTime reconstruction. Based on the input parameters, it divides\nthe analysis into semi-independent jobs and conquers them one-by-one,\ngradually optimizing the tree given the temporal constarints and leaf\nnode sequences.\n\nParameters\n----------\nroot : str\n   Try to find better root position on a given tree. If string is passed,\n   the root will be searched according to the specified method. If none,\n   use tree as-is.\n\n   See :py:meth:`treetime.TreeTime.reroot` for available rooting methods.\n\ninfer_gtr : bool\n   If True, infer GTR model\n\nrelaxed_clock : dic\n   If not None, use autocorrelated molecular clock model. Specify the\n   clock parameters as :code:`{slack:<slack>, coupling:<coupling>}` dictionary.\n\nn_iqd : int\n   If not None, filter tree nodes which do not obey the molecular clock\n   for the particular tree. The nodes, which deviate more than\n   :code:`n_iqd` interquantile intervals from the molecular clock\n   regression will be marked as 'BAD' and not used in the TreeTime\n   analysis\n\nresolve_polytomies : bool\n   If True, attempt to resolve multiple mergers\n\nmax_iter : int\n   Maximum number of iterations to optimize the tree\n\nTc : float, str\n   If not None, use coalescent model to correct the branch lengths by\n   introducing merger costs.\n\n   If Tc is float, it is interpreted as the coalescence time scale\n\n   If Tc is str, it should be one of (:code:`opt`, :code:`const`, :code:`skyline`)\n\nfixed_clock_rate : float\n   Fixed clock rate to be used. If None, infer clock rate from the molecular clock.\n\ntime_marginal : bool\n   If True, perform a final round of marginal reconstruction of the node's positions.\n\nsequence_marginal : bool, optional\n    use marginal reconstruction for ancestral sequences\n\nbranch_length_mode : str\n   Should be one of: :code:`joint`, :code:`marginal`, :code:`input`.\n\n   If 'input', rely on the branch lengths in the input tree and skip directly\n   to the maximum-likelihood ancestral sequence reconstruction.\n   Otherwise, perform preliminary sequence reconstruction using parsimony\n   algorithm and do branch length optimization\n\nvary_rate : bool or float, optional\n    redo the time tree estimation for rates +/- one standard deviation.\n    if a float is passed, it is interpreted as standard deviation,\n    otherwise this standard deviation is estimated from the root-to-tip regression\n\nuse_covariation : bool, optional\n    default False, if False, rate estimates will be performed using simple\n    regression ignoring phylogenetic covaration between nodes.\n\n**kwargs\n   Keyword arguments needed by the downstream functions\n\n\nReturns\n-------\nTreeTime error/succces code : str\n    return value depending on success or error", "id": "f2319:c0:m1"}
{"signature": "def _find_best_root(self, covariation=True, force_positive=True, slope=<NUM_LIT:0>, **kwarks):", "body": "for n in self.tree.find_clades():<EOL><INDENT>n.branch_length=n.mutation_length<EOL><DEDENT>self.logger(\"<STR_LIT>\",<NUM_LIT:2>)<EOL>Treg = self.setup_TreeRegression(covariation=covariation)<EOL>return Treg.optimal_reroot(force_positive=force_positive, slope=slope)['<STR_LIT>']<EOL>", "docstring": "Determine the node that, when the tree is rooted on this node, results\nin the best regression of temporal constraints and root to tip distances.\n\nParameters\n----------\n\n infer_gtr : bool\n    If True, infer new GTR model after re-root\n\n covariation : bool\n    account for covariation structure when rerooting the tree\n\n force_positive : bool\n    only accept positive evolutionary rate estimates when rerooting the tree", "id": "f2319:c0:m11"}
{"signature": "def plot_vs_years(tt, step = None, ax=None, confidence=None, ticks=True, **kwargs):", "body": "import matplotlib.pyplot as plt<EOL>tt.branch_length_to_years()<EOL>nleafs = tt.tree.count_terminals()<EOL>if ax is None:<EOL><INDENT>fig = plt.figure(figsize=(<NUM_LIT:12>,<NUM_LIT:10>))<EOL>ax = plt.subplot(<NUM_LIT>)<EOL><DEDENT>else:<EOL><INDENT>fig = None<EOL><DEDENT>if \"<STR_LIT>\" not in kwargs:<EOL><INDENT>kwargs[\"<STR_LIT>\"] = lambda x:x.name if (x.is_terminal() and nleafs<<NUM_LIT:30>) else \"<STR_LIT>\"<EOL><DEDENT>Phylo.draw(tt.tree, axes=ax, **kwargs)<EOL>offset = tt.tree.root.numdate - tt.tree.root.branch_length<EOL>date_range = np.max([n.numdate for n in tt.tree.get_terminals()])-offset<EOL>if step is None or (step><NUM_LIT:0> and date_range/step><NUM_LIT:100>):<EOL><INDENT>step = <NUM_LIT:10>**np.floor(np.log10(date_range))<EOL>if date_range/step<<NUM_LIT:2>:<EOL><INDENT>step/=<NUM_LIT:5><EOL><DEDENT>elif date_range/step<<NUM_LIT:5>:<EOL><INDENT>step/=<NUM_LIT:2><EOL><DEDENT>step = max(<NUM_LIT:1.0>/<NUM_LIT:12>,step)<EOL><DEDENT>if step:<EOL><INDENT>dtick = step<EOL>min_tick = step*(offset//step)<EOL>extra = dtick if dtick<date_range else dtick<EOL>tick_vals = np.arange(min_tick, min_tick+date_range+extra, dtick)<EOL>xticks = tick_vals - offset<EOL><DEDENT>else:<EOL><INDENT>xticks = ax.get_xticks()<EOL>dtick = xticks[<NUM_LIT:1>]-xticks[<NUM_LIT:0>]<EOL>shift = offset - dtick*(offset//dtick)<EOL>xticks -= shift<EOL>tick_vals = [x+offset-shift for x in xticks]<EOL><DEDENT>ax.set_xticks(xticks)<EOL>ax.set_xticklabels(map(str, tick_vals))<EOL>ax.set_xlabel('<STR_LIT>')<EOL>ax.set_ylabel('<STR_LIT>')<EOL>ax.set_xlim((<NUM_LIT:0>,date_range))<EOL>if step:<EOL><INDENT>ylim = ax.get_ylim()<EOL>xlim = ax.get_xlim()<EOL>from matplotlib.patches import Rectangle<EOL>for yi,year in enumerate(np.arange(np.floor(tick_vals[<NUM_LIT:0>]), tick_vals[-<NUM_LIT:1>]+<NUM_LIT>, step)):<EOL><INDENT>pos = year - offset<EOL>r = Rectangle((pos, ylim[<NUM_LIT:1>]-<NUM_LIT:5>),<EOL>step, ylim[<NUM_LIT:0>]-ylim[<NUM_LIT:1>]+<NUM_LIT:10>,<EOL>facecolor=[<NUM_LIT>+<NUM_LIT:0.1>*(<NUM_LIT:1>+yi%<NUM_LIT:2>)] * <NUM_LIT:3>,<EOL>edgecolor=[<NUM_LIT:1>,<NUM_LIT:1>,<NUM_LIT:1>])<EOL>ax.add_patch(r)<EOL>if year in tick_vals and pos>=xlim[<NUM_LIT:0>] and pos<=xlim[<NUM_LIT:1>] and ticks:<EOL><INDENT>label_str = str(step*(year//step)) if step<<NUM_LIT:1> else  str(int(year))<EOL>ax.text(pos,ylim[<NUM_LIT:0>]-<NUM_LIT>*(ylim[<NUM_LIT:1>]-ylim[<NUM_LIT:0>]), label_str,<EOL>horizontalalignment='<STR_LIT>')<EOL><DEDENT><DEDENT>ax.set_axis_off()<EOL><DEDENT>if confidence:<EOL><INDENT>tree_layout(tt.tree)<EOL>if not hasattr(tt.tree.root, \"<STR_LIT>\"):<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return ttconf.ERROR<EOL><DEDENT>elif type(confidence) is float:<EOL><INDENT>cfunc = tt.get_max_posterior_region<EOL><DEDENT>elif len(confidence)==<NUM_LIT:2>:<EOL><INDENT>cfunc = tt.get_confidence_interval<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return ttconf.ERROR<EOL><DEDENT>for n in tt.tree.find_clades():<EOL><INDENT>pos = cfunc(n, confidence)<EOL>ax.plot(pos-offset, np.ones(len(pos))*n.ypos, lw=<NUM_LIT:3>, c=(<NUM_LIT:0.5>,<NUM_LIT:0.5>,<NUM_LIT:0.5>))<EOL><DEDENT><DEDENT>return fig, ax<EOL>", "docstring": "Converts branch length to years and plots the time tree on a time axis.\n\nParameters\n----------\n tt : TreeTime object\n    A TreeTime instance after a time tree is inferred\n\n step : int\n    Width of shaded boxes indicating blocks of years. Will be inferred if not specified.\n    To switch off drawing of boxes, set to 0\n\n ax : matplotlib axes\n    Axes to be used to plot, will create new axis if None\n\n confidence : tuple, float\n    Draw confidence intervals. This assumes that marginal time tree inference was run.\n    Confidence intervals are either specified as an interval of the posterior distribution\n    like (0.05, 0.95) or as the weight of the maximal posterior region , e.g. 0.9\n\n **kwargs : dict\n    Key word arguments that are passed down to Phylo.draw", "id": "f2319:m0"}
{"signature": "def _set_branch_length_mode(self, branch_length_mode):", "body": "if branch_length_mode in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT:input>']:<EOL><INDENT>self.branch_length_mode = branch_length_mode<EOL><DEDENT>elif self.aln:<EOL><INDENT>bl_dis = [n.branch_length for n in self.tree.find_clades() if n.up]<EOL>max_bl = np.max(bl_dis)<EOL>if max_bl><NUM_LIT:0.1>:<EOL><INDENT>bl_mode = '<STR_LIT:input>'<EOL><DEDENT>else:<EOL><INDENT>bl_mode = '<STR_LIT>'<EOL><DEDENT>self.logger(\"<STR_LIT>\"%(max_bl, bl_mode),<NUM_LIT:1>)<EOL>self.branch_length_mode = bl_mode<EOL><DEDENT>else:<EOL><INDENT>self.branch_length_mode = '<STR_LIT:input>'<EOL><DEDENT>", "docstring": "if branch_length mode is not explicitly set, set according to\nempirical branch length distribution in input tree\n\nParameters\n----------\n\n branch_length_mode : str, 'input', 'joint', 'marginal'\n    if the maximal branch length in the tree is longer than 0.05, this will\n    default to 'input'. Otherwise set to 'joint'", "id": "f2319:c0:m2"}
{"signature": "def setMaxDemandResetNow(self, password=\"<STR_LIT>\"):", "body": "result = False<EOL>self.setContext(\"<STR_LIT>\")<EOL>try:<EOL><INDENT>if len(password) != <NUM_LIT:8>:<EOL><INDENT>self.writeCmdMsg(\"<STR_LIT>\")<EOL>self.setContext(\"<STR_LIT>\")<EOL>return result<EOL><DEDENT>if not self.request(False):<EOL><INDENT>self.writeCmdMsg(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>if not self.serialCmdPwdAuth(password):<EOL><INDENT>self.writeCmdMsg(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>req_str = \"<STR_LIT>\" + binascii.hexlify(str(<NUM_LIT:0>).zfill(<NUM_LIT:6>)) + \"<STR_LIT>\"<EOL>req_str += self.calc_crc16(req_str[<NUM_LIT:2>:].decode(\"<STR_LIT>\"))<EOL>self.m_serial_port.write(req_str.decode(\"<STR_LIT>\"))<EOL>if self.m_serial_port.getResponse(self.getContext()).encode(\"<STR_LIT>\") == \"<STR_LIT>\":<EOL><INDENT>self.writeCmdMsg(\"<STR_LIT>\")<EOL>result = True<EOL><DEDENT><DEDENT><DEDENT>self.serialPostEnd()<EOL><DEDENT>except:<EOL><INDENT>ekm_log(traceback.format_exc(sys.exc_info()))<EOL><DEDENT>self.setContext(\"<STR_LIT>\")<EOL>return result<EOL>", "docstring": "Serial call zero max demand (Dash Now button)\n\n        Args:\n            password (str): Optional password\n\n        Returns:\n            bool: True on completion with ACK.", "id": "f2325:c29:m28"}
{"signature": "def extractHolidayWeekendSchedules(self):", "body": "result = namedtuple(\"<STR_LIT:result>\", [\"<STR_LIT>\", \"<STR_LIT>\"])<EOL>result.Weekend = self.m_hldy[\"<STR_LIT>\"][MeterData.StringValue]<EOL>result.Holiday = self.m_hldy[\"<STR_LIT>\"][MeterData.StringValue]<EOL>return result<EOL>", "docstring": "extract holiday and weekend :class:`~ekmmeters.Schedule` from meter object buffer.\n\n        Returns:\n            tuple: Holiday and weekend :class:`~ekmmeters.Schedule` values, as strings.\n\n            ======= ======================================\n            Holiday :class:`~ekmmeters.Schedule` as string\n            Weekend :class:`~ekmmeters.Schedule` as string\n            ======= ======================================", "id": "f2325:c29:m44"}
{"signature": "def initPort(self):", "body": "try:<EOL><INDENT>self.m_ser = serial.Serial(port=self.m_ttyport,<EOL>baudrate=self.m_baudrate,<EOL>timeout=<NUM_LIT:0>,<EOL>parity=serial.PARITY_EVEN,<EOL>stopbits=serial.STOPBITS_ONE,<EOL>bytesize=serial.SEVENBITS,<EOL>rtscts=False)<EOL>ekm_log(\"<STR_LIT>\" + serial.VERSION)<EOL>ekm_log(\"<STR_LIT>\" + self.m_ttyport)<EOL>ekm_log(\"<STR_LIT>\" + str(self.m_baudrate))<EOL>time.sleep(self.m_init_wait)<EOL>return True<EOL><DEDENT>except:<EOL><INDENT>ekm_log(traceback.format_exc(sys.exc_info()))<EOL><DEDENT>return False<EOL>", "docstring": "Required initialization call, wraps pyserial constructor.", "id": "f2325:c26:m1"}
{"signature": "def setConnectString(self, connection_string):", "body": "self.m_connection_string = connection_string<EOL>pass<EOL>", "docstring": "Setter for connection string.\n        Args:\n            connection_string (str): Connection string.", "id": "f2325:c27:m1"}
{"signature": "def getReadBuffer(self):", "body": "ekm_log(\"<STR_LIT>\")<EOL>empty  = SerialBlock()<EOL>return empty<EOL>", "docstring": "Required override to fetch the read serial block.\n\n        Returns:\n            SerialBlock: Every supported field (A or A+B, includes all fields)", "id": "f2325:c29:m2"}
{"signature": "def dict_factory(self, cursor, row):", "body": "d = {}<EOL>for idx, col in enumerate(cursor.description):<EOL><INDENT>val = row[idx]<EOL>name = col[<NUM_LIT:0>]<EOL>if name == Field.Time_Stamp:<EOL><INDENT>d[col[<NUM_LIT:0>]] = str(val)<EOL>continue<EOL><DEDENT>if name == \"<STR_LIT>\" or name == \"<STR_LIT>\":  <EOL><INDENT>continue<EOL><DEDENT>if name not in self.m_all_fields:<EOL><INDENT>continue<EOL><DEDENT>if (str(val) != \"<STR_LIT:None>\") and ((val > <NUM_LIT:0>) or (val < <NUM_LIT:0>)):<EOL><INDENT>d[name] = str(val)<EOL><DEDENT><DEDENT>return d<EOL>", "docstring": "Sqlite callback accepting the cursor and the original row as a tuple.\n\n        Simple return of JSON safe types.\n\n        Args:\n            cursor (sqlite cursor):  Original cursory\n            row (sqlite row tuple): Original row.\n\n        Returns:\n            dict: modified row.", "id": "f2325:c28:m2"}
{"signature": "def extractMonthTariff(self, month):", "body": "ret = namedtuple(\"<STR_LIT>\", [\"<STR_LIT>\", Field.kWh_Tariff_1, Field.kWh_Tariff_2, Field.kWh_Tariff_3,<EOL>Field.kWh_Tariff_4, Field.kWh_Tot, Field.Rev_kWh_Tariff_1,<EOL>Field.Rev_kWh_Tariff_2, Field.Rev_kWh_Tariff_3,<EOL>Field.Rev_kWh_Tariff_4, Field.Rev_kWh_Tot])<EOL>month += <NUM_LIT:1><EOL>ret.Month = str(month)<EOL>if (month < <NUM_LIT:1>) or (month > Extents.Months):<EOL><INDENT>ret.kWh_Tariff_1 = ret.kWh_Tariff_2 = ret.kWh_Tariff_3 = ret.kWh_Tariff_4 = str(<NUM_LIT:0>)<EOL>ret.Rev_kWh_Tariff_1 = ret.Rev_kWh_Tariff_2 = ret.Rev_kWh_Tariff_3 = ret.Rev_kWh_Tariff_4 = str(<NUM_LIT:0>)<EOL>ret.kWh_Tot = ret.Rev_kWh_Tot = str(<NUM_LIT:0>)<EOL>ekm_log(\"<STR_LIT>\" + str(month))<EOL>return ret<EOL><DEDENT>base_str = \"<STR_LIT>\" + str(month) + \"<STR_LIT:_>\"<EOL>ret.kWh_Tariff_1 = self.m_mons[base_str + \"<STR_LIT>\"][MeterData.StringValue]<EOL>ret.kWh_Tariff_2 = self.m_mons[base_str + \"<STR_LIT>\"][MeterData.StringValue]<EOL>ret.kWh_Tariff_3 = self.m_mons[base_str + \"<STR_LIT>\"][MeterData.StringValue]<EOL>ret.kWh_Tariff_4 = self.m_mons[base_str + \"<STR_LIT>\"][MeterData.StringValue]<EOL>ret.kWh_Tot = self.m_mons[base_str + \"<STR_LIT>\"][MeterData.StringValue]<EOL>ret.Rev_kWh_Tariff_1 = self.m_rev_mons[base_str + \"<STR_LIT>\"][MeterData.StringValue]<EOL>ret.Rev_kWh_Tariff_2 = self.m_rev_mons[base_str + \"<STR_LIT>\"][MeterData.StringValue]<EOL>ret.Rev_kWh_Tariff_3 = self.m_rev_mons[base_str + \"<STR_LIT>\"][MeterData.StringValue]<EOL>ret.Rev_kWh_Tariff_4 = self.m_rev_mons[base_str + \"<STR_LIT>\"][MeterData.StringValue]<EOL>ret.Rev_kWh_Tot = self.m_rev_mons[base_str + \"<STR_LIT>\"][MeterData.StringValue]<EOL>return ret<EOL>", "docstring": "Extract the tariff for a single month from the meter object buffer.\n\n        Args:\n            month (int):  A :class:`~ekmmeters.Months` value or range(Extents.Months).\n\n        Returns:\n            tuple: The eight tariff period totals for month. The return tuple breaks out as follows:\n\n            ================= ======================================\n            kWh_Tariff_1      kWh for tariff period 1 over month.\n            kWh_Tariff_2      kWh for tariff period 2 over month\n            kWh_Tariff_3      kWh for tariff period 3 over month\n            kWh_Tariff_4      kWh for tariff period 4 over month\n            kWh_Tot           Total kWh over requested month\n            Rev_kWh_Tariff_1  Rev kWh for tariff period 1 over month\n            Rev_kWh_Tariff_3  Rev kWh for tariff period 2 over month\n            Rev_kWh_Tariff_3  Rev kWh for tariff period 3 over month\n            Rev_kWh_Tariff_4  Rev kWh for tariff period 4 over month\n            Rev_kWh_Tot       Total Rev kWh over requested month\n            ================= ======================================", "id": "f2325:c29:m41"}
{"signature": "def getMeterAddress(self):", "body": "return self.m_meter_address<EOL>", "docstring": "Getter for meter object 12 character address.\n\n        Returns:\n            str: 12 character address on front of meter", "id": "f2325:c29:m17"}
{"signature": "def getField(self, fld_name):", "body": "result = \"<STR_LIT>\"<EOL>if fld_name in self.m_req:<EOL><INDENT>result = self.m_req[fld_name][MeterData.StringValue]<EOL><DEDENT>else:<EOL><INDENT>ekm_log(\"<STR_LIT>\" + fld_name)<EOL><DEDENT>return result<EOL>", "docstring": "Return :class:`~ekmmeters.Field` content, scaled and formatted.\n\n        Args:\n            fld_name (str): A `:class:~ekmmeters.Field` value which is on your meter.\n\n        Returns:\n            str: String value (scaled if numeric) for the field.", "id": "f2325:c33:m10"}
{"signature": "def insert(self, meter_db):", "body": "if meter_db:<EOL><INDENT>meter_db.dbInsert(self.m_req, self.m_raw_read_a, self.m_raw_read_b)<EOL><DEDENT>else:<EOL><INDENT>ekm_log(\"<STR_LIT>\")<EOL><DEDENT>pass<EOL>", "docstring": "Insert to :class:`~ekmmeters.MeterDB`  subclass.\n\n        Please note MeterDB subclassing is only for simplest-case.\n\n        Args:\n            meter_db (MeterDB): Instance of subclass of MeterDB.", "id": "f2325:c32:m6"}
{"signature": "def requestB(self):", "body": "work_context = self.getContext()<EOL>self.setContext(\"<STR_LIT>\")<EOL>self.m_serial_port.write(\"<STR_LIT>\".decode(\"<STR_LIT>\") + self.m_meter_address + \"<STR_LIT>\".decode(\"<STR_LIT>\"))<EOL>self.m_raw_read_b = self.m_serial_port.getResponse(self.getContext())<EOL>unpacked_read_b = self.unpackStruct(self.m_raw_read_b, self.m_blk_b)<EOL>self.convertData(unpacked_read_b, self.m_blk_b, self.m_kwh_precision)<EOL>self.m_b_crc = self.crcMeterRead(self.m_raw_read_b, self.m_blk_b)<EOL>self.setContext(work_context)<EOL>return self.m_b_crc<EOL>", "docstring": "Issue a B read on V4 meter.\n\n        Returns:\n            bool: True if CRC match at end of call.", "id": "f2325:c33:m7"}
{"signature": "def writeCmdMsg(self, msg):", "body": "ekm_log(\"<STR_LIT>\" + self.getContext() + \"<STR_LIT>\" + msg)<EOL>self.m_command_msg = msg<EOL>", "docstring": "Internal method to set the command result string.\n\n        Args:\n            msg (str): Message built during command.", "id": "f2325:c29:m46"}
{"signature": "def fillCreate(self, qry_str):", "body": "count = <NUM_LIT:0><EOL>for fld in self.m_all_fields:<EOL><INDENT>fld_type = self.m_all_fields[fld][MeterData.TypeValue]<EOL>fld_len = self.m_all_fields[fld][MeterData.SizeValue]<EOL>qry_spec = self.mapTypeToSql(fld_type, fld_len)<EOL>if count > <NUM_LIT:0>:<EOL><INDENT>qry_str += \"<STR_LIT>\"<EOL><DEDENT>qry_str = qry_str + '<STR_LIT:U+0020>' + fld + '<STR_LIT:U+0020>' + qry_spec<EOL>count += <NUM_LIT:1><EOL><DEDENT>qry_str += (\"<STR_LIT>\" + Field.Time_Stamp + \"<STR_LIT>\" +<EOL>\"<STR_LIT>\" +<EOL>\"<STR_LIT>\")<EOL>return qry_str<EOL>", "docstring": "Return query portion below CREATE.\n        Args:\n            qry_str (str): String as built.\n\n        Returns:\n            string: Passed string with fields appended.", "id": "f2325:c27:m4"}
{"signature": "def registerObserver(self, observer):", "body": "self.m_observers.append(observer)<EOL>pass<EOL>", "docstring": "Place an observer in the meter update() chain.\n\n        Args:\n            observer (MeterObserver): Subclassed MeterObserver.", "id": "f2325:c29:m18"}
{"signature": "def getName(self):", "body": "return self.m_ttyport<EOL>", "docstring": "Getter for serial port name\n\n        Returns:\n            string: name of serial port (ex: 'COM3', '/dev/ttyS0')", "id": "f2325:c26:m2"}
{"signature": "def getSchedulesBuffer(self, period_group):", "body": "empty_return = SerialBlock()<EOL>if period_group == ReadSchedules.Schedules_1_To_4:<EOL><INDENT>return self.m_schd_1_to_4<EOL><DEDENT>elif period_group == ReadSchedules.Schedules_5_To_6:<EOL><INDENT>return self.m_schd_5_to_6<EOL><DEDENT>else:<EOL><INDENT>return empty_return<EOL><DEDENT>", "docstring": "Return the requested tariff schedule :class:`~ekmmeters.SerialBlock` for meter.\n\n        Args:\n            period_group (int):  A :class:`~ekmmeters.ReadSchedules` value.\n\n        Returns:\n            SerialBlock: The requested tariff schedules for meter.", "id": "f2325:c29:m22"}
{"signature": "def setContext(self, context_str):", "body": "if (len(self.m_context) == <NUM_LIT:0>) and (len(context_str) >= <NUM_LIT:7>):<EOL><INDENT>if context_str[<NUM_LIT:0>:<NUM_LIT:7>] != \"<STR_LIT>\":<EOL><INDENT>ekm_log(\"<STR_LIT>\" + context_str)<EOL><DEDENT><DEDENT>self.m_context = context_str<EOL>", "docstring": "Set context string for serial command.  Private setter.\n\n        Args:\n            context_str (str): Command specific string.", "id": "f2325:c29:m5"}
{"signature": "def serialCmdPwdAuth(self, password_str):", "body": "result = False<EOL>try:<EOL><INDENT>req_start = \"<STR_LIT>\" + binascii.hexlify(password_str) + \"<STR_LIT>\"<EOL>req_crc = self.calc_crc16(req_start[<NUM_LIT:2>:].decode(\"<STR_LIT>\"))<EOL>req_str = req_start + req_crc<EOL>self.m_serial_port.write(req_str.decode(\"<STR_LIT>\"))<EOL>if self.m_serial_port.getResponse(self.getContext()).encode(\"<STR_LIT>\") == \"<STR_LIT>\":<EOL><INDENT>ekm_log(\"<STR_LIT>\" + self.getContext() + \"<STR_LIT:)>\")<EOL>result = True<EOL><DEDENT>else:<EOL><INDENT>ekm_log(\"<STR_LIT>\" + self.getContext() + \"<STR_LIT:)>\")<EOL><DEDENT><DEDENT>except:<EOL><INDENT>ekm_log(\"<STR_LIT>\" + self.getContext() + \"<STR_LIT:)>\")<EOL>ekm_log(traceback.format_exc(sys.exc_info()))<EOL><DEDENT>return result<EOL>", "docstring": "Password step of set commands\n\n        This method is normally called within another serial command, so it\n        does not issue a termination string.  Any default password is set\n        in the caller parameter list, never here.\n\n        Args:\n            password_str (str): Required password.\n\n        Returns:\n            bool: True on completion and ACK.", "id": "f2325:c29:m49"}
{"signature": "def attachPort(self, serial_port):", "body": "self.m_serial_port = serial_port<EOL>pass<EOL>", "docstring": "Attach required :class:`~ekmmeters.SerialPort`.\n\n        Args:\n            serial_port (SerialPort): Serial port object, does not need to be initialized.", "id": "f2325:c32:m1"}
{"signature": "def setZeroResettableKWH(self, password=\"<STR_LIT>\"):", "body": "result = False<EOL>self.setContext(\"<STR_LIT>\")<EOL>try:<EOL><INDENT>if not self.requestA():<EOL><INDENT>self.writeCmdMsg(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>if not self.serialCmdPwdAuth(password):<EOL><INDENT>self.writeCmdMsg(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>req_str = \"<STR_LIT>\"<EOL>req_str += self.calc_crc16(req_str[<NUM_LIT:2>:].decode(\"<STR_LIT>\"))<EOL>self.m_serial_port.write(req_str.decode(\"<STR_LIT>\"))<EOL>if self.m_serial_port.getResponse(self.getContext()).encode(\"<STR_LIT>\") == \"<STR_LIT>\":<EOL><INDENT>self.writeCmdMsg(\"<STR_LIT>\")<EOL>result = True<EOL><DEDENT><DEDENT><DEDENT>self.serialPostEnd()<EOL><DEDENT>except:<EOL><INDENT>ekm_log(traceback.format_exc(sys.exc_info()))<EOL><DEDENT>self.setContext(\"<STR_LIT>\")<EOL>return result<EOL>", "docstring": "Serial call to zero resettable kWh registers.\n\n        Args:\n            password (str): Optional password.\n\n        Returns:\n            bool: True on completion and ACK.", "id": "f2325:c33:m19"}
{"signature": "def write(self, output):", "body": "view_str = output.encode('<STR_LIT:ascii>', '<STR_LIT:ignore>')<EOL>if (len(view_str) > <NUM_LIT:0>):<EOL><INDENT>self.m_ser.write(view_str)<EOL>self.m_ser.flush()<EOL>self.m_ser.reset_input_buffer()<EOL>time.sleep(self.m_force_wait)<EOL><DEDENT>pass<EOL>", "docstring": "Passthrough for pyserial Serial.write().\n\n        Args:\n            output (str): Block to write to port", "id": "f2325:c26:m4"}
{"signature": "def attachPort(self, serial_port):", "body": "self.m_serial_port = serial_port<EOL>pass<EOL>", "docstring": "Required override to attach the port to the meter.\n\n        Args:\n            serial_port (SerialPort): Declared serial port.  Does not need to be initialized.", "id": "f2325:c33:m1"}
{"signature": "def __init__(self, interval):", "body": "super(IntervalObserver, self).__init__()<EOL>self.m_interval = interval<EOL>self.m_summary = SerialBlock()<EOL>pass<EOL>", "docstring": "Args:\n    interval (int): Interval to summarize", "id": "f2325:c31:m0"}
{"signature": "def __init__(self, ttyport, baudrate=<NUM_LIT>, force_wait = <NUM_LIT:0.1>):", "body": "self.m_ttyport = ttyport<EOL>self.m_baudrate = baudrate<EOL>self.m_ser = None<EOL>self.m_fd = None<EOL>self.m_max_waits = <NUM_LIT:100><EOL>self.m_wait_sleep = <NUM_LIT><EOL>self.m_force_wait = force_wait<EOL>self.m_init_wait = <NUM_LIT><EOL>pass<EOL>", "docstring": "Args:\n    ttyport (str): port name, ex 'COM3' '/dev/ttyUSB0'\n    baudrate (int): optional, 9600 default and recommended\n    force_wait(float) : optional post commnd sleep, if required", "id": "f2325:c26:m0"}
{"signature": "def serialPostEnd(self):", "body": "ekm_log(\"<STR_LIT>\" + self.m_context + \"<STR_LIT:)>\")<EOL>self.m_serial_port.write(\"<STR_LIT>\".decode(\"<STR_LIT>\"))<EOL>pass<EOL>", "docstring": "Post termination code to implicitly current meter.", "id": "f2325:c32:m10"}
{"signature": "def __init__(self, connection_string):", "body": "self.m_connection_string = connection_string<EOL>self.m_all_fields = SerialBlock()<EOL>self.combineAB()<EOL>pass<EOL>", "docstring": "Args:\n    connection_string (str): database appropriate connection string", "id": "f2325:c27:m0"}
{"signature": "def initWorkFormat(self):", "body": "self.m_blk_a[\"<STR_LIT>\"] = [<NUM_LIT:1>, FieldType.Hex, ScaleType.No, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_blk_a[Field.Model] = [<NUM_LIT:2>, FieldType.Hex, ScaleType.No, \"<STR_LIT>\", <NUM_LIT:0>, False, True]<EOL>self.m_blk_a[Field.Firmware] = [<NUM_LIT:1>, FieldType.Hex, ScaleType.No, \"<STR_LIT>\", <NUM_LIT:0>, False, True]<EOL>self.m_blk_a[Field.Meter_Address] = [<NUM_LIT:12>, FieldType.String, ScaleType.No, \"<STR_LIT>\", <NUM_LIT:0>, False, True]<EOL>self.m_blk_a[Field.kWh_Tot] = [<NUM_LIT:8>, FieldType.Float, ScaleType.KWH, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_blk_a[Field.kWh_Tariff_1] = [<NUM_LIT:8>, FieldType.Float, ScaleType.KWH, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_blk_a[Field.kWh_Tariff_2] = [<NUM_LIT:8>, FieldType.Float, ScaleType.KWH, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_blk_a[Field.kWh_Tariff_3] = [<NUM_LIT:8>, FieldType.Float, ScaleType.KWH, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_blk_a[Field.kWh_Tariff_4] = [<NUM_LIT:8>, FieldType.Float, ScaleType.KWH, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_blk_a[Field.Rev_kWh_Tot] = [<NUM_LIT:8>, FieldType.Float, ScaleType.KWH, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_blk_a[Field.Rev_kWh_Tariff_1] = [<NUM_LIT:8>, FieldType.Float, ScaleType.KWH, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_blk_a[Field.Rev_kWh_Tariff_2] = [<NUM_LIT:8>, FieldType.Float, ScaleType.KWH, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_blk_a[Field.Rev_kWh_Tariff_3] = [<NUM_LIT:8>, FieldType.Float, ScaleType.KWH, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_blk_a[Field.Rev_kWh_Tariff_4] = [<NUM_LIT:8>, FieldType.Float, ScaleType.KWH, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_blk_a[Field.RMS_Volts_Ln_1] = [<NUM_LIT:4>, FieldType.Float, ScaleType.Div10, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_blk_a[Field.RMS_Volts_Ln_2] = [<NUM_LIT:4>, FieldType.Float, ScaleType.Div10, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_blk_a[Field.RMS_Volts_Ln_3] = [<NUM_LIT:4>, FieldType.Float, ScaleType.Div10, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_blk_a[Field.Amps_Ln_1] = [<NUM_LIT:5>, FieldType.Float, ScaleType.Div10, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_blk_a[Field.Amps_Ln_2] = [<NUM_LIT:5>, FieldType.Float, ScaleType.Div10, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_blk_a[Field.Amps_Ln_3] = [<NUM_LIT:5>, FieldType.Float, ScaleType.Div10, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_blk_a[Field.RMS_Watts_Ln_1] = [<NUM_LIT:7>, FieldType.Int, ScaleType.No, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_blk_a[Field.RMS_Watts_Ln_2] = [<NUM_LIT:7>, FieldType.Int, ScaleType.No, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_blk_a[Field.RMS_Watts_Ln_3] = [<NUM_LIT:7>, FieldType.Int, ScaleType.No, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_blk_a[Field.RMS_Watts_Tot] = [<NUM_LIT:7>, FieldType.Int, ScaleType.No, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_blk_a[Field.Cos_Theta_Ln_1] = [<NUM_LIT:4>, FieldType.PowerFactor, ScaleType.No, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_blk_a[Field.Cos_Theta_Ln_2] = [<NUM_LIT:4>, FieldType.PowerFactor, ScaleType.No, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_blk_a[Field.Cos_Theta_Ln_3] = [<NUM_LIT:4>, FieldType.PowerFactor, ScaleType.No, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_blk_a[Field.Max_Demand] = [<NUM_LIT:8>, FieldType.Float, ScaleType.KWH, \"<STR_LIT>\", <NUM_LIT:0>, False, True]<EOL>self.m_blk_a[Field.Max_Demand_Period] = [<NUM_LIT:1>, FieldType.Int, ScaleType.No, \"<STR_LIT>\", <NUM_LIT:0>, False, True]<EOL>self.m_blk_a[Field.Meter_Time] = [<NUM_LIT>, FieldType.String, ScaleType.No, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_blk_a[Field.CT_Ratio] = [<NUM_LIT:4>, FieldType.Int, ScaleType.No, \"<STR_LIT>\", <NUM_LIT:0>, False, True]<EOL>self.m_blk_a[Field.Pulse_Cnt_1] = [<NUM_LIT:8>, FieldType.Int, ScaleType.No, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_blk_a[Field.Pulse_Cnt_2] = [<NUM_LIT:8>, FieldType.Int, ScaleType.No, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_blk_a[Field.Pulse_Cnt_3] = [<NUM_LIT:8>, FieldType.Int, ScaleType.No, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_blk_a[Field.Pulse_Ratio_1] = [<NUM_LIT:4>, FieldType.Int, ScaleType.No, \"<STR_LIT>\", <NUM_LIT:0>, False, True]<EOL>self.m_blk_a[Field.Pulse_Ratio_2] = [<NUM_LIT:4>, FieldType.Int, ScaleType.No, \"<STR_LIT>\", <NUM_LIT:0>, False, True]<EOL>self.m_blk_a[Field.Pulse_Ratio_3] = [<NUM_LIT:4>, FieldType.Int, ScaleType.No, \"<STR_LIT>\", <NUM_LIT:0>, False, True]<EOL>self.m_blk_a[Field.State_Inputs] = [<NUM_LIT:3>, FieldType.Int, ScaleType.No, \"<STR_LIT>\", <NUM_LIT:0>, False, True]<EOL>self.m_blk_a[\"<STR_LIT>\"] = [<NUM_LIT>, FieldType.Hex, ScaleType.No, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_blk_a[Field.Status_A] = [<NUM_LIT:1>, FieldType.Hex, ScaleType.No, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_blk_a[\"<STR_LIT>\"] = [<NUM_LIT:4>, FieldType.Hex, ScaleType.No, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_blk_a[\"<STR_LIT>\"] = [<NUM_LIT:2>, FieldType.Hex, ScaleType.No, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_blk_a[Field.Power_Factor_Ln_1] = [<NUM_LIT:4>, FieldType.Int, ScaleType.No, \"<STR_LIT:0>\", <NUM_LIT:0>, True, False]<EOL>self.m_blk_a[Field.Power_Factor_Ln_2] = [<NUM_LIT:4>, FieldType.Int, ScaleType.No, \"<STR_LIT:0>\", <NUM_LIT:0>, True, False]<EOL>self.m_blk_a[Field.Power_Factor_Ln_3] = [<NUM_LIT:4>, FieldType.Int, ScaleType.No, \"<STR_LIT:0>\", <NUM_LIT:0>, True, False]<EOL>", "docstring": "Initialize :class:`~ekmmeters.SerialBlock` for V3 read.", "id": "f2325:c32:m2"}
{"signature": "def initRevMons(self):", "body": "self.m_rev_mons[\"<STR_LIT>\"] = [<NUM_LIT:6>, FieldType.Hex, ScaleType.No, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_rev_mons[\"<STR_LIT>\"] = [<NUM_LIT:8>, FieldType.Float, ScaleType.KWH, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_rev_mons[\"<STR_LIT>\"] = [<NUM_LIT:8>, FieldType.Float, ScaleType.KWH, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_rev_mons[\"<STR_LIT>\"] = [<NUM_LIT:8>, FieldType.Float, ScaleType.KWH, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_rev_mons[\"<STR_LIT>\"] = [<NUM_LIT:8>, FieldType.Float, ScaleType.KWH, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_rev_mons[\"<STR_LIT>\"] = [<NUM_LIT:8>, FieldType.Float, ScaleType.KWH, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_rev_mons[\"<STR_LIT>\"] = [<NUM_LIT:8>, FieldType.Float, ScaleType.KWH, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_rev_mons[\"<STR_LIT>\"] = [<NUM_LIT:8>, FieldType.Float, ScaleType.KWH, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_rev_mons[\"<STR_LIT>\"] = [<NUM_LIT:8>, FieldType.Float, ScaleType.KWH, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_rev_mons[\"<STR_LIT>\"] = [<NUM_LIT:8>, FieldType.Float, ScaleType.KWH, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_rev_mons[\"<STR_LIT>\"] = [<NUM_LIT:8>, FieldType.Float, ScaleType.KWH, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_rev_mons[\"<STR_LIT>\"] = [<NUM_LIT:8>, FieldType.Float, ScaleType.KWH, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_rev_mons[\"<STR_LIT>\"] = [<NUM_LIT:8>, FieldType.Float, ScaleType.KWH, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_rev_mons[\"<STR_LIT>\"] = [<NUM_LIT:8>, FieldType.Float, ScaleType.KWH, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_rev_mons[\"<STR_LIT>\"] = [<NUM_LIT:8>, FieldType.Float, ScaleType.KWH, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_rev_mons[\"<STR_LIT>\"] = [<NUM_LIT:8>, FieldType.Float, ScaleType.KWH, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_rev_mons[\"<STR_LIT>\"] = [<NUM_LIT:8>, FieldType.Float, ScaleType.KWH, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_rev_mons[\"<STR_LIT>\"] = [<NUM_LIT:8>, FieldType.Float, ScaleType.KWH, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_rev_mons[\"<STR_LIT>\"] = [<NUM_LIT:8>, FieldType.Float, ScaleType.KWH, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_rev_mons[\"<STR_LIT>\"] = [<NUM_LIT:8>, FieldType.Float, ScaleType.KWH, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_rev_mons[\"<STR_LIT>\"] = [<NUM_LIT:8>, FieldType.Float, ScaleType.KWH, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_rev_mons[\"<STR_LIT>\"] = [<NUM_LIT:8>, FieldType.Float, ScaleType.KWH, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_rev_mons[\"<STR_LIT>\"] = [<NUM_LIT:8>, FieldType.Float, ScaleType.KWH, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_rev_mons[\"<STR_LIT>\"] = [<NUM_LIT:8>, FieldType.Float, ScaleType.KWH, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_rev_mons[\"<STR_LIT>\"] = [<NUM_LIT:8>, FieldType.Float, ScaleType.KWH, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_rev_mons[\"<STR_LIT>\"] = [<NUM_LIT:8>, FieldType.Float, ScaleType.KWH, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_rev_mons[\"<STR_LIT>\"] = [<NUM_LIT:8>, FieldType.Float, ScaleType.KWH, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_rev_mons[\"<STR_LIT>\"] = [<NUM_LIT:8>, FieldType.Float, ScaleType.KWH, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_rev_mons[\"<STR_LIT>\"] = [<NUM_LIT:8>, FieldType.Float, ScaleType.KWH, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_rev_mons[\"<STR_LIT>\"] = [<NUM_LIT:8>, FieldType.Float, ScaleType.KWH, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_rev_mons[\"<STR_LIT>\"] = [<NUM_LIT:8>, FieldType.Float, ScaleType.KWH, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_rev_mons[\"<STR_LIT>\"] = [<NUM_LIT:7>, FieldType.Hex, ScaleType.No, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>self.m_rev_mons[\"<STR_LIT>\"] = [<NUM_LIT:2>, FieldType.Hex, ScaleType.No, \"<STR_LIT>\", <NUM_LIT:0>, False, False]<EOL>pass<EOL>", "docstring": "Initialize second (and last) month tarifff :class:`~ekmmeters.SerialBlock` for meter.", "id": "f2325:c29:m26"}
{"signature": "def jsonRender(self, def_buf):", "body": "try:<EOL><INDENT>ret_dict = SerialBlock()<EOL>ret_dict[Field.Meter_Address] = self.getMeterAddress()<EOL>for fld in def_buf:<EOL><INDENT>compare_fld = fld.upper()<EOL>if not \"<STR_LIT>\" in compare_fld and not \"<STR_LIT>\" in compare_fld:<EOL><INDENT>ret_dict[str(fld)] = def_buf[fld][MeterData.StringValue]<EOL><DEDENT><DEDENT><DEDENT>except:<EOL><INDENT>ekm_log(traceback.format_exc(sys.exc_info()))<EOL>return \"<STR_LIT>\"<EOL><DEDENT>return json.dumps(ret_dict, indent=<NUM_LIT:4>)<EOL>", "docstring": "Translate the passed serial block into string only JSON.\n\n        Args:\n            def_buf (SerialBlock): Any :class:`~ekmmeters.SerialBlock` object.\n\n        Returns:\n            str: JSON rendering of meter record.", "id": "f2325:c29:m14"}
{"signature": "def assignSeasonSchedule(self, season, month, day, schedule):", "body": "season += <NUM_LIT:1><EOL>schedule += <NUM_LIT:1><EOL>if ((season < <NUM_LIT:1>) or (season > Extents.Seasons) or (schedule < <NUM_LIT:1>) or<EOL>(schedule > Extents.Schedules) or (month > <NUM_LIT:12>) or (month < <NUM_LIT:0>) or<EOL>(day < <NUM_LIT:0>) or (day > <NUM_LIT>)):<EOL><INDENT>ekm_log(\"<STR_LIT>\" + str(month) + \"<STR_LIT>\" + str(day) +<EOL>\"<STR_LIT>\" + str(schedule) + \"<STR_LIT>\" + str(season))<EOL>return False<EOL><DEDENT>idx_mon = \"<STR_LIT>\" + str(season) + \"<STR_LIT>\"<EOL>idx_day = \"<STR_LIT>\" + str(season) + \"<STR_LIT>\"<EOL>idx_schedule = \"<STR_LIT>\" + str(season) + \"<STR_LIT>\"<EOL>if idx_mon not in self.m_seasons_sched_params:<EOL><INDENT>ekm_log(\"<STR_LIT>\" + idx_mon)<EOL>return False<EOL><DEDENT>if idx_day not in self.m_seasons_sched_params:<EOL><INDENT>ekm_log(\"<STR_LIT>\" + idx_day)<EOL>return False<EOL><DEDENT>if idx_schedule not in self.m_seasons_sched_params:<EOL><INDENT>ekm_log(\"<STR_LIT>\" + idx_schedule)<EOL>return False<EOL><DEDENT>self.m_seasons_sched_params[idx_mon] = month<EOL>self.m_seasons_sched_params[idx_day] = day<EOL>self.m_seasons_sched_params[idx_schedule] = schedule<EOL>return True<EOL>", "docstring": "Define a single season and assign a schedule\n\n        Args:\n            season (int): A :class:`~ekmmeters.Seasons` value or in range(Extent.Seasons).\n            month (int): Month 1-12.\n            day (int):  Day 1-31.\n            schedule (int): A :class:`~ekmmeters.LCDItems` value or in range(Extent.Schedules).\n\n        Returns:\n            bool: True on completion and ACK.", "id": "f2325:c29:m33"}
{"signature": "def readSchedules(self, tableset):", "body": "self.setContext(\"<STR_LIT>\")<EOL>try:<EOL><INDENT>req_table = binascii.hexlify(str(tableset).zfill(<NUM_LIT:1>))<EOL>req_str = \"<STR_LIT>\" + req_table + \"<STR_LIT>\"<EOL>self.request(False)<EOL>req_crc = self.calc_crc16(req_str[<NUM_LIT:2>:].decode(\"<STR_LIT>\"))<EOL>req_str += req_crc<EOL>self.m_serial_port.write(req_str.decode(\"<STR_LIT>\"))<EOL>raw_ret = self.m_serial_port.getResponse(self.getContext())<EOL>self.serialPostEnd()<EOL>return_crc = self.calc_crc16(raw_ret[<NUM_LIT:1>:-<NUM_LIT:2>])<EOL>if tableset == ReadSchedules.Schedules_1_To_4:<EOL><INDENT>unpacked_read = self.unpackStruct(raw_ret, self.m_schd_1_to_4)<EOL>self.convertData(unpacked_read, self.m_schd_1_to_4, self.m_kwh_precision)<EOL>if str(return_crc) == str(self.m_schd_1_to_4[\"<STR_LIT>\"][MeterData.StringValue]):<EOL><INDENT>ekm_log(\"<STR_LIT>\")<EOL>self.setContext(\"<STR_LIT>\")<EOL>return True<EOL><DEDENT><DEDENT>elif tableset == ReadSchedules.Schedules_5_To_6:<EOL><INDENT>unpacked_read = self.unpackStruct(raw_ret, self.m_schd_5_to_6)<EOL>self.convertData(unpacked_read, self.m_schd_5_to_6, self.m_kwh_precision)<EOL>if str(return_crc) == str(self.m_schd_5_to_6[\"<STR_LIT>\"][MeterData.StringValue]):<EOL><INDENT>ekm_log(\"<STR_LIT>\")<EOL>self.setContext(\"<STR_LIT>\")<EOL>return True<EOL><DEDENT><DEDENT><DEDENT>except:<EOL><INDENT>ekm_log(traceback.format_exc(sys.exc_info()))<EOL><DEDENT>self.setContext(\"<STR_LIT>\")<EOL>return False<EOL>", "docstring": "Serial call to read schedule tariffs buffer\n\n        Args:\n            tableset (int): :class:`~ekmmeters.ReadSchedules` buffer to return.\n\n        Returns:\n            bool: True on completion and ACK.", "id": "f2325:c29:m38"}
{"signature": "def getReadBuffer(self):", "body": "return self.m_req<EOL>", "docstring": "Return :class:`~ekmmeters.SerialBlock` for last read.\n\n        Appropriate for conversion to JSON or other extraction.\n\n        Returns:\n            SerialBlock: A read.", "id": "f2325:c32:m5"}
{"signature": "def setPulseInputRatio(self, line_in, new_cnst, password=\"<STR_LIT>\"):", "body": "result = False<EOL>self.setContext(\"<STR_LIT>\")<EOL>try:<EOL><INDENT>if not self.requestA():<EOL><INDENT>self.writeCmdMsg(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>if not self.serialCmdPwdAuth(password):<EOL><INDENT>self.writeCmdMsg(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>req_const = binascii.hexlify(str(new_cnst).zfill(<NUM_LIT:4>))<EOL>line_const = binascii.hexlify(str(line_in - <NUM_LIT:1>))<EOL>req_str = \"<STR_LIT>\" + line_const + \"<STR_LIT>\" + req_const + \"<STR_LIT>\"<EOL>req_str += self.calc_crc16(req_str[<NUM_LIT:2>:].decode(\"<STR_LIT>\"))<EOL>self.m_serial_port.write(req_str.decode(\"<STR_LIT>\"))<EOL>if self.m_serial_port.getResponse(self.getContext()).encode(\"<STR_LIT>\") == \"<STR_LIT>\":<EOL><INDENT>self.writeCmdMsg(\"<STR_LIT>\")<EOL>result = True<EOL><DEDENT><DEDENT><DEDENT>self.serialPostEnd()<EOL><DEDENT>except:<EOL><INDENT>ekm_log(traceback.format_exc(sys.exc_info()))<EOL><DEDENT>self.setContext(\"<STR_LIT>\")<EOL>return result<EOL>", "docstring": "Serial call to set pulse input ratio on a line.\n\n        Args:\n            line_in (int): Member of :class:`~ekmmeters.Pulse`\n            new_cnst (int): New pulse input ratio\n            password (str): Optional password\n\n        Returns:", "id": "f2325:c33:m18"}
{"signature": "def readMonthTariffs(self, months_type):", "body": "self.setContext(\"<STR_LIT>\")<EOL>try:<EOL><INDENT>req_type = binascii.hexlify(str(months_type).zfill(<NUM_LIT:1>))<EOL>req_str = \"<STR_LIT>\" + req_type + \"<STR_LIT>\"<EOL>work_table = self.m_mons<EOL>if months_type == ReadMonths.kWhReverse:<EOL><INDENT>work_table = self.m_rev_mons<EOL><DEDENT>self.request(False)<EOL>req_crc = self.calc_crc16(req_str[<NUM_LIT:2>:].decode(\"<STR_LIT>\"))<EOL>req_str += req_crc<EOL>self.m_serial_port.write(req_str.decode(\"<STR_LIT>\"))<EOL>raw_ret = self.m_serial_port.getResponse(self.getContext())<EOL>self.serialPostEnd()<EOL>unpacked_read = self.unpackStruct(raw_ret, work_table)<EOL>self.convertData(unpacked_read, work_table, self.m_kwh_precision)<EOL>return_crc = self.calc_crc16(raw_ret[<NUM_LIT:1>:-<NUM_LIT:2>])<EOL>if str(return_crc) == str(work_table[\"<STR_LIT>\"][MeterData.StringValue]):<EOL><INDENT>ekm_log(\"<STR_LIT>\" + str(req_type))<EOL>self.setContext(\"<STR_LIT>\")<EOL>return True<EOL><DEDENT><DEDENT>except:<EOL><INDENT>ekm_log(traceback.format_exc(sys.exc_info()))<EOL><DEDENT>self.setContext(\"<STR_LIT>\")<EOL>return False<EOL>", "docstring": "Serial call to read month tariffs block into meter object buffer.\n\n        Args:\n            months_type (int): A :class:`~ekmmeters.ReadMonths` value.\n\n        Returns:\n            bool: True on completion.", "id": "f2325:c29:m40"}
{"signature": "def makeReturnFormat(self):", "body": "for fld in self.m_blk_a:<EOL><INDENT>compare_fld = fld.upper()<EOL>if not \"<STR_LIT>\" in compare_fld and not \"<STR_LIT>\" in compare_fld:<EOL><INDENT>self.m_req[fld] = self.m_blk_a[fld]<EOL><DEDENT><DEDENT>pass<EOL>", "docstring": "Strip reserved and CRC for m_req :class:`~ekmmeters.SerialBlock`.", "id": "f2325:c32:m4"}
{"signature": "def setRelay(self, seconds, relay, status, password=\"<STR_LIT>\"):", "body": "result = False<EOL>self.setContext(\"<STR_LIT>\")<EOL>try:<EOL><INDENT>self.clearCmdMsg()<EOL>if len(password) != <NUM_LIT:8>:<EOL><INDENT>self.writeCmdMsg(\"<STR_LIT>\")<EOL>self.setContext(\"<STR_LIT>\")<EOL>return result<EOL><DEDENT>if seconds < <NUM_LIT:0> or seconds > <NUM_LIT>:<EOL><INDENT>self.writeCmdMsg(\"<STR_LIT>\")<EOL>self.setContext(\"<STR_LIT>\")<EOL>return result<EOL><DEDENT>if not self.requestA():<EOL><INDENT>self.writeCmdMsg(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>if not self.serialCmdPwdAuth(password):<EOL><INDENT>self.writeCmdMsg(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>req_str = \"<STR_LIT>\"<EOL>req_str = (\"<STR_LIT>\" +<EOL>binascii.hexlify(str(relay)).zfill(<NUM_LIT:2>) +<EOL>\"<STR_LIT>\" +<EOL>binascii.hexlify(str(status)).zfill(<NUM_LIT:2>) +<EOL>binascii.hexlify(str(seconds).zfill(<NUM_LIT:4>)) + \"<STR_LIT>\")<EOL>req_str += self.calc_crc16(req_str[<NUM_LIT:2>:].decode(\"<STR_LIT>\"))<EOL>self.m_serial_port.write(req_str.decode(\"<STR_LIT>\"))<EOL>if self.m_serial_port.getResponse(self.getContext()).encode(\"<STR_LIT>\") == \"<STR_LIT>\":<EOL><INDENT>self.writeCmdMsg(\"<STR_LIT>\")<EOL>result = True<EOL><DEDENT><DEDENT><DEDENT>self.serialPostEnd()<EOL><DEDENT>except:<EOL><INDENT>ekm_log(traceback.format_exc(sys.exc_info()))<EOL><DEDENT>self.setContext(\"<STR_LIT>\")<EOL>return result<EOL>", "docstring": "Serial call to set relay.\n\n        Args:\n            seconds (int): Seconds to hold, ero is hold forever. See :class:`~ekmmeters.RelayInterval`.\n            relay (int): Selected relay, see :class:`~ekmmeters.Relay`.\n            status (int): Status to set, see :class:`~ekmmeters.RelayState`\n            password (str): Optional password\n\n        Returns:\n            bool: True on completion and ACK.", "id": "f2325:c33:m16"}
{"signature": "def setMeterPassword(self, new_pwd, pwd=\"<STR_LIT>\"):", "body": "result = False<EOL>self.setContext(\"<STR_LIT>\")<EOL>try:<EOL><INDENT>if len(new_pwd) != <NUM_LIT:8> or len(pwd) != <NUM_LIT:8>:<EOL><INDENT>self.writeCmdMsg(\"<STR_LIT>\")<EOL>self.setContext(\"<STR_LIT>\")<EOL>return result<EOL><DEDENT>if not self.request(False):<EOL><INDENT>self.writeCmdMsg(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>if not self.serialCmdPwdAuth(pwd):<EOL><INDENT>self.writeCmdMsg(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>req_pwd = binascii.hexlify(new_pwd.zfill(<NUM_LIT:8>))<EOL>req_str = \"<STR_LIT>\" + req_pwd + \"<STR_LIT>\"<EOL>req_str += self.calc_crc16(req_str[<NUM_LIT:2>:].decode(\"<STR_LIT>\"))<EOL>self.m_serial_port.write(req_str.decode(\"<STR_LIT>\"))<EOL>if self.m_serial_port.getResponse(self.getContext()).encode(\"<STR_LIT>\") == \"<STR_LIT>\":<EOL><INDENT>self.writeCmdMsg(\"<STR_LIT>\")<EOL>result = True<EOL><DEDENT><DEDENT><DEDENT>self.serialPostEnd()<EOL><DEDENT>except:<EOL><INDENT>ekm_log(traceback.format_exc(sys.exc_info()))<EOL><DEDENT>self.setContext(\"<STR_LIT>\")<EOL>return result<EOL>", "docstring": "Serial Call to set meter password.  USE WITH CAUTION.\n\n        Args:\n            new_pwd (str): 8 digit numeric password to set\n            pwd (str): Old 8 digit numeric password.\n\n        Returns:\n            bool: True on completion with ACK.", "id": "f2325:c29:m11"}
{"signature": "def addLcdItem(self, lcd_item_no):", "body": "self.m_lcd_items.append(lcd_item_no)<EOL>pass<EOL>", "docstring": "Simple append to internal buffer.\n\nUsed with :func:`~ekmmeters.V4Meter.setLcd` and :func:`~ekmmeters.V4Meter.initLcd`\n\nArgs:\n    lcd_item_no (int): Member of :class:`~ekmmeters.LCDItems`", "id": "f2325:c33:m22"}
{"signature": "@staticmethod<EOL><INDENT>def _insert_img(qr_img, icon_img=None, factor=<NUM_LIT:4>, icon_box=None, static_dir=None):<DEDENT>", "body": "img_w, img_h = qr_img.size<EOL>size_w = int(img_w) / int(factor)<EOL>size_h = int(img_h) / int(factor)<EOL>try:<EOL><INDENT>icon_fp = os.path.join(icon_img)<EOL>if static_dir:<EOL><INDENT>icon_fp = os.path.join(static_dir, icon_img)<EOL><DEDENT>if icon_img.split(\"<STR_LIT>\")[<NUM_LIT:0>] in [\"<STR_LIT:http>\", \"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>icon_fp = BytesIO(urlopen(icon_img).read())  <EOL><DEDENT>icon = Image.open(icon_fp)<EOL><DEDENT>except:<EOL><INDENT>return qr_img<EOL><DEDENT>icon_w, icon_h = icon.size<EOL>icon_w = size_w if icon_w > size_w else icon_w<EOL>icon_h = size_h if icon_h > size_h else icon_h<EOL>icon = icon.resize((int(icon_w), int(icon_h)), Image.ANTIALIAS)<EOL>icon = icon.convert(\"<STR_LIT>\")<EOL>left = int((img_w - icon_w) / <NUM_LIT:2>)<EOL>top = int((img_h - icon_h) / <NUM_LIT:2>)<EOL>icon_box = (int(icon_box[<NUM_LIT:0>]), int(icon_box[<NUM_LIT:1>])) if icon_box else (left, top)<EOL>qr_img.paste(im=icon, box=icon_box, mask=icon)<EOL>return qr_img<EOL>", "docstring": "Inserts a small icon to QR Code image", "id": "f2352:c0:m5"}
{"signature": "def upload(tags, file_path, username=None, api_key=GIPHY_PUBLIC_KEY,<EOL>strict=False):", "body": "return Giphy(api_key=api_key, strict=strict).upload(<EOL>tags, file_path, username)<EOL>", "docstring": "Shorthand for creating a Giphy api wrapper with the given api key\nand then calling the upload method.", "id": "f2356:m7"}
{"signature": "def trending_list(limit=DEFAULT_SEARCH_LIMIT, api_key=GIPHY_PUBLIC_KEY,<EOL>strict=False, rating=None):", "body": "return Giphy(api_key=api_key, strict=strict).trending_list(<EOL>limit=limit, rating=rating)<EOL>", "docstring": "Shorthand for creating a Giphy api wrapper with the given api key\nand then calling the trending_list method.", "id": "f2356:m4"}
{"signature": "def translate(self, term=None, phrase=None, strict=False, rating=None):", "body": "assert any((term, phrase)), '<STR_LIT>'<EOL>if phrase:<EOL><INDENT>phrase = phrase.replace('<STR_LIT:U+0020>', '<STR_LIT:->')<EOL><DEDENT>params = {'<STR_LIT:s>': (term or phrase)}<EOL>if rating:<EOL><INDENT>params.update({'<STR_LIT>': rating})<EOL><DEDENT>resp = self._fetch('<STR_LIT>', **params)<EOL>if resp['<STR_LIT:data>']:<EOL><INDENT>return GiphyImage(resp['<STR_LIT:data>'])<EOL><DEDENT>elif strict or self.strict:<EOL><INDENT>raise GiphyApiException(<EOL>\"<STR_LIT>\" %<EOL>(term or phrase))<EOL><DEDENT>", "docstring": "Retrieve a single image that represents a transalation of a term or\nphrase into an animated gif. Punctuation is ignored. By default, this\nwill perform a `term` translation. If you want to translate by phrase,\nuse the `phrase` keyword argument.\n\n:param term: Search term or terms\n:type term: string\n:param phrase: Search phrase\n:type phrase: string\n:param strict: Whether an exception should be raised when no results\n:type strict: boolean\n:param rating: limit results to those rated (y,g, pg, pg-13 or r).\n:type rating: string", "id": "f2356:c3:m6"}
{"signature": "@property<EOL><INDENT>def media_url(self):<DEDENT>", "body": "return self.original.url<EOL>", "docstring": "The media URL of the gif at its original size", "id": "f2356:c2:m4"}
{"signature": "def float_range(start=<NUM_LIT:0>, stop=None, step=<NUM_LIT:1>):", "body": "start = float(start)<EOL>while start < stop:<EOL><INDENT>yield start<EOL>start += step<EOL><DEDENT>", "docstring": "Much like the built-in function range, but accepts floats\n\n>>> tuple(float_range(0, 9, 1.5))\n(0.0, 1.5, 3.0, 4.5, 6.0, 7.5)", "id": "f2365:m2"}
{"signature": "def flatten_mapping(mapping):", "body": "return {<EOL>key: value<EOL>for keys, value in mapping.items()<EOL>for key in always_iterable(keys)<EOL>}<EOL>", "docstring": "For every key that has an __iter__ method, assign the values\nto a key for each.\n\n>>> flatten_mapping({'ab': 3, ('c','d'): 4}) == {'ab': 3, 'c': 4, 'd': 4}\nTrue", "id": "f2365:m1"}
{"signature": "@classmethod<EOL><INDENT>def lookup_relativedelta_parameter(cls, unit_string):<DEDENT>", "body": "try:<EOL><INDENT>return cls._rdp_map()[unit_string.lower()]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": ">>> lrp = Schedule.lookup_relativedelta_parameter\n>>> lrp('Years')\n'years'\n>>> lrp('yr')\n'years'\n>>> lrp('s')\n'seconds'", "id": "f2370:c1:m14"}
{"signature": "def parse_css(self):", "body": "<EOL>cssutils.ser.prefs.useMinified()<EOL>pairs = (<EOL>(r.selectorText, r.style.cssText)<EOL>for r in self.get_stylesheet()<EOL>if not isinstance(r, cssutils.css.CSSComment)<EOL>)<EOL>return dict(pairs)<EOL>", "docstring": "Take a .css file (classes only please) and parse it into a dictionary\nof class/style pairs.", "id": "f2371:c0:m37"}
{"signature": "def draw_titles(self):", "body": "if self.show_graph_title:<EOL><INDENT>self.draw_graph_title()<EOL><DEDENT>if self.show_graph_subtitle:<EOL><INDENT>self.draw_graph_subtitle()<EOL><DEDENT>if self.show_x_title:<EOL><INDENT>self.draw_x_title()<EOL><DEDENT>if self.show_y_title:<EOL><INDENT>self.draw_y_title()<EOL><DEDENT>", "docstring": "Draws the graph title and subtitle", "id": "f2371:c0:m28"}
{"signature": "def draw_y_labels(self):", "body": "if not self.show_y_labels:<EOL><INDENT>return<EOL><DEDENT>labels = self.get_y_labels()<EOL>count = len(labels)<EOL>labels = enumerate(iter(labels))<EOL>start = int(not self.step_include_first_y_label)<EOL>labels = itertools.islice(labels, start, None, self.step_y_labels)<EOL>list(map(self.draw_y_label, labels))<EOL>self.draw_y_guidelines(self.field_height(), count)<EOL>", "docstring": "Draw the Y axis labels", "id": "f2371:c0:m23"}
{"signature": "def draw_x_guidelines(self, label_height, count):", "body": "if not self.show_x_guidelines:<EOL><INDENT>return<EOL><DEDENT>for count in range(<NUM_LIT:1>, count):<EOL><INDENT>move = '<STR_LIT>'.format(<EOL>start=label_height * count,<EOL>stop=self.graph_height,<EOL>)<EOL>path = {'<STR_LIT:d>': move, '<STR_LIT:class>': '<STR_LIT>'}<EOL>etree.SubElement(self.graph, '<STR_LIT:path>', path)<EOL><DEDENT>", "docstring": "Draw the X-axis guidelines", "id": "f2371:c0:m26"}
{"signature": "def make_datapoint_text(self, x, y, value, style=None):", "body": "if not self.show_data_values:<EOL><INDENT>return<EOL><DEDENT>e = etree.SubElement(self.foreground, '<STR_LIT:text>', {<EOL>'<STR_LIT:x>': str(x),<EOL>'<STR_LIT:y>': str(y),<EOL>'<STR_LIT:class>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>' % vars(),<EOL>})<EOL>e.text = str(value)<EOL>e = etree.SubElement(self.foreground, '<STR_LIT:text>', {<EOL>'<STR_LIT:x>': str(x),<EOL>'<STR_LIT:y>': str(y),<EOL>'<STR_LIT:class>': '<STR_LIT>'})<EOL>e.text = str(value)<EOL>if style:<EOL><INDENT>e.set('<STR_LIT>', style)<EOL><DEDENT>", "docstring": "Add text for a datapoint", "id": "f2371:c0:m17"}
{"signature": "def draw_graph(self):", "body": "transform = '<STR_LIT>' % (self.border_left, self.border_top)<EOL>self.graph = etree.SubElement(self.root, '<STR_LIT:g>', transform=transform)<EOL>etree.SubElement(self.graph, '<STR_LIT>', {<EOL>'<STR_LIT:x>': '<STR_LIT:0>',<EOL>'<STR_LIT:y>': '<STR_LIT:0>',<EOL>'<STR_LIT:width>': str(self.graph_width),<EOL>'<STR_LIT>': str(self.graph_height),<EOL>'<STR_LIT:class>': '<STR_LIT>'<EOL>})<EOL>etree.SubElement(self.graph, '<STR_LIT:path>', {<EOL>'<STR_LIT:d>': '<STR_LIT>' % self.graph_height,<EOL>'<STR_LIT:class>': '<STR_LIT>',<EOL>'<STR_LIT:id>': '<STR_LIT>'<EOL>})<EOL>etree.SubElement(self.graph, '<STR_LIT:path>', {<EOL>'<STR_LIT:d>': '<STR_LIT>' % (self.graph_height, self.graph_width),<EOL>'<STR_LIT:class>': '<STR_LIT>',<EOL>'<STR_LIT:id>': '<STR_LIT>'<EOL>})<EOL>self.draw_x_labels()<EOL>self.draw_y_labels()<EOL>", "docstring": "The central logic for drawing the graph.\n\nSets self.graph (the 'g' element in the SVG root)", "id": "f2371:c0:m15"}
{"signature": "def max_y_label_width_px(self):", "body": "if self.rotate_y_labels:<EOL><INDENT>return self.font_size<EOL><DEDENT>", "docstring": "Calculate the width of the widest Y label.  This will be the\ncharacter height if the Y labels are rotated.", "id": "f2371:c0:m9"}
{"signature": "def x_label_offset(self, width):", "body": "<EOL>return <NUM_LIT:0><EOL>", "docstring": "Return an offset for drawing the x label. Currently returns 0.", "id": "f2371:c0:m16"}
{"signature": "def y_label_offset(self, height):", "body": "<EOL>return <NUM_LIT:0><EOL>", "docstring": "Return an offset for drawing the y label. Currently returns 0.", "id": "f2371:c0:m20"}
{"signature": "def start_svg(self):", "body": "SVG_NAMESPACE = '<STR_LIT>'<EOL>SVG = '<STR_LIT>' % SVG_NAMESPACE<EOL>NSMAP = {<EOL>None: SVG_NAMESPACE,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>}<EOL>root_attrs = self._get_root_attributes()<EOL>self.root = etree.Element(SVG + \"<STR_LIT>\", attrib=root_attrs, nsmap=NSMAP)<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>pi = etree.ProcessingInstruction(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % self.style_sheet_href<EOL>)<EOL>self.root.addprevious(pi)<EOL><DEDENT>comment_strings = (<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT:U+0020>' + '<STR_LIT:/>' * <NUM_LIT>,<EOL>)<EOL>list(map(self.root.append, map(etree.Comment, comment_strings)))<EOL>defs = etree.SubElement(self.root, '<STR_LIT>')<EOL>self.add_defs(defs)<EOL>if not hasattr(self, '<STR_LIT>') and not self.css_inline:<EOL><INDENT>self.root.append(etree.Comment(<EOL>'<STR_LIT>'))<EOL>style = etree.SubElement(defs, '<STR_LIT>', type='<STR_LIT>')<EOL>style.text = self.get_stylesheet().cssText<EOL><DEDENT>self.root.append(etree.Comment('<STR_LIT>'))<EOL>etree.SubElement(self.root, '<STR_LIT>', {<EOL>'<STR_LIT:width>': str(self.width),<EOL>'<STR_LIT>': str(self.height),<EOL>'<STR_LIT:x>': '<STR_LIT:0>',<EOL>'<STR_LIT:y>': '<STR_LIT:0>',<EOL>'<STR_LIT:class>': '<STR_LIT>'})<EOL>", "docstring": "Base SVG Document Creation", "id": "f2371:c0:m40"}
{"signature": "def calculate_bottom_margin(self):", "body": "bb = <NUM_LIT:7><EOL>if self.key and self.key_position == '<STR_LIT>':<EOL><INDENT>bb += len(self.data) * (self.font_size + <NUM_LIT:5>)<EOL>bb += <NUM_LIT:10><EOL><DEDENT>if self.show_x_labels:<EOL><INDENT>max_x_label_height_px = self.x_label_font_size<EOL>if self.rotate_x_labels:<EOL><INDENT>label_lengths = map(len, self.get_x_labels())<EOL>max_x_label_len = functools.reduce(max, label_lengths)<EOL>max_x_label_height_px *= <NUM_LIT> * max_x_label_len<EOL><DEDENT>bb += max_x_label_height_px<EOL>if self.stagger_x_labels:<EOL><INDENT>bb += max_x_label_height_px + <NUM_LIT:10><EOL><DEDENT><DEDENT>if self.show_x_title:<EOL><INDENT>bb += self.x_title_font_size + <NUM_LIT:5><EOL><DEDENT>self.border_bottom = bb<EOL>", "docstring": "Calculate the margin in pixels below the plot area, setting\nborder_bottom.", "id": "f2371:c0:m14"}
{"signature": "def add_data(self, data):", "body": "super(Plot, self).add_data(data)<EOL>", "docstring": "Add data to the plot::\n\n        # A data set with 1 point: (\"12:30\", 2)\n        d1 = [\"12:30\", 2]\n\n        # A data set with 2 points: (\"01:00\", 2) and\n        #                           (\"14:20\", 6)\n        d2 = [\"01:00\", 2, \"14:20\", 6]\n\n        graph.add_data(\n                data = d1,\n                title = 'One',\n        )\n        graph.add_data(\n                data = d2,\n                title = 'Two',\n        )\n\nNote that the data must be in (time, value) pairs, and\nthe date format\nmay be any date that is parseable by dateutil.", "id": "f2372:c0:m0"}
{"signature": "def process_module(self, node):", "body": "if self.config.file_header:<EOL><INDENT>if sys.version_info[<NUM_LIT:0>] < <NUM_LIT:3>:<EOL><INDENT>pattern = re.compile(<EOL>'<STR_LIT>' + self.config.file_header, re.LOCALE | re.MULTILINE)<EOL><DEDENT>else:<EOL><INDENT>pattern = re.compile(<EOL>'<STR_LIT>' + self.config.file_header, re.MULTILINE)<EOL><DEDENT>content = None<EOL>with node.stream() as stream:<EOL><INDENT>content = stream.read().decode('<STR_LIT:utf-8>')<EOL><DEDENT>matches = pattern.findall(content)<EOL>if len(matches) != <NUM_LIT:1>:<EOL><INDENT>self.add_message('<STR_LIT>', <NUM_LIT:1>,<EOL>args=self.config.file_header)<EOL><DEDENT><DEDENT>", "docstring": "Process the astroid node stream.", "id": "f2378:c0:m0"}
{"signature": "def format_expected(self, expected, webasset):", "body": "from pyramid.path import AssetResolver<EOL>if '<STR_LIT:%>' not in expected:<EOL><INDENT>return expected<EOL><DEDENT>if '<STR_LIT::>' in webasset:<EOL><INDENT>name = AssetResolver(None).resolve(webasset).abspath()<EOL><DEDENT>else:<EOL><INDENT>name = self.temp.tempdir + '<STR_LIT>' + webasset<EOL><DEDENT>if webassets_version > (<NUM_LIT:0>, <NUM_LIT:9>):<EOL><INDENT>hashed_filename = hashlib.md5(name.encode(\"<STR_LIT:utf-8>\")).hexdigest()<EOL><DEDENT>else:<EOL><INDENT>hashed_filename = hash(name) & ((<NUM_LIT:1> << <NUM_LIT:64>) - <NUM_LIT:1>)<EOL><DEDENT>external = '<STR_LIT>' % hashed_filename<EOL>return expected % {'<STR_LIT>': external}<EOL>", "docstring": "Formats the expected url when the webasset is external", "id": "f2382:c3:m3"}
{"signature": "def maybebool(value):", "body": "if isinstance(value, six.string_types) and value.lower() in booly:<EOL><INDENT>return asbool(value)  <EOL><DEDENT>return value<EOL>", "docstring": "If `value` is a string type, attempts to convert it to a boolean\nif it looks like it might be one, otherwise returns the value\nunchanged. The difference between this and\n:func:`pyramid.settings.asbool` is how non-bools are handled: this\nreturns the original value, whereas `asbool` returns False.", "id": "f2383:m0"}
{"signature": "def get_webassets_env_from_request(request):", "body": "return request.registry.queryUtility(IWebAssetsEnvironment)<EOL>", "docstring": "Get the webassets environment in the registry from the request.", "id": "f2383:m5"}
{"signature": "def get_rand_bytes(encoding='<STR_LIT>', l=<NUM_LIT:64>, avoid=[]):", "body": "return encode(<EOL>get_rand_str(encoding=encoding, l=l, avoid=avoid),<EOL>encoding=encoding<EOL>)<EOL>", "docstring": "encoding-->str: one of ENCODINGS\nl-->int: length of unicode str\navoid-->list of int: to void (unprintable chars etc)\nReturns-->bytes representing unicode str of the requested encoding", "id": "f2385:m15"}
{"signature": "def toBytes(x):", "body": "if isinstance(x, bytes):<EOL><INDENT>return x<EOL><DEDENT>elif isinstance(x, bytearray):<EOL><INDENT>return bytes(x)<EOL><DEDENT>elif isinstance(x, unicode):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>return x  <EOL><DEDENT>return encode(x, DEF_ENCODING)<EOL>", "docstring": "x-->unicode string | bytearray | bytes\nReturns-->bytes\nIf x is unicode, MUST have encoding=latin1", "id": "f2385:m6"}
{"signature": "def inputToBytes(func, *args, **kwargs):", "body": "return _convInputs(func, toBytes, *args, **kwargs)<EOL>", "docstring": "Decorator that converts all arguments to bytes", "id": "f2385:m10"}
{"signature": "def inputFromBytes(func, *args, **kwargs):", "body": "return _convInputs(func, fromBytes, *args, **kwargs)<EOL>", "docstring": "Decorator that converts all arguments to latin1-encoded unicode", "id": "f2385:m9"}
{"signature": "def load(self):", "body": "try:<EOL><INDENT>self.__openlib()<EOL>return self.lib is not None<EOL><DEDENT>except OSError:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Returns-->boolean: whether library could be loaded\nWhen this is called, the library would have been loaded if possible\nIf this is not called, the first invocation of a method in lib\nCAN raise OSError if shared library cannot be loaded", "id": "f2386:c0:m1"}
{"signature": "def get_buffer(self, *args):", "body": "res = tuple([<EOL>self.buffer(x) for x in args<EOL>])<EOL>if len(res) == <NUM_LIT:0>:<EOL><INDENT>return None<EOL><DEDENT>elif len(res) == <NUM_LIT:1>:<EOL><INDENT>return res[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>return res<EOL><DEDENT>", "docstring": "all args-->_cffi_backend.CDataOwn\nMust be a pointer or an array\nReturns-->buffer (if a SINGLE argument was provided)\n          LIST of buffer (if a args was a tuple or list)", "id": "f2387:c0:m1"}
{"signature": "def get_bytes(self, *args):", "body": "res = tuple([<EOL>bytes(self.buffer(x)) for x in args<EOL>])<EOL>if len(res) == <NUM_LIT:0>:<EOL><INDENT>return None<EOL><DEDENT>elif len(res) == <NUM_LIT:1>:<EOL><INDENT>return res[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>return res<EOL><DEDENT>", "docstring": "all args-->_cffi_backend.CDataOwn\nMust be a pointer or an array\nReturns-->bytes (if a SINGLE argument was provided)\n          LIST of bytes (if a args was a tuple or list)", "id": "f2387:c0:m2"}
{"signature": "@click.command()<EOL>@click.argument('<STR_LIT>', nargs=-<NUM_LIT:1>)<EOL>def list(pattern=()):", "body": "<EOL>globs = ['<STR_LIT>'.format(p) for p in pattern] + ['<STR_LIT:*>']<EOL>matches = []<EOL>offset = len(PROJ_ARCHIVE) + <NUM_LIT:1><EOL>for suffix in globs:<EOL><INDENT>glob_pattern = os.path.join(PROJ_ARCHIVE, '<STR_LIT:*>', '<STR_LIT:*>', suffix)<EOL>matches.append(set(<EOL>f[offset:] for f in glob.glob(glob_pattern)<EOL>))<EOL><DEDENT>matches = reduce(lambda x, y: x.intersection(y),<EOL>matches)<EOL>for m in sorted(matches):<EOL><INDENT>print(m)<EOL><DEDENT>", "docstring": "List the contents of the archive directory.", "id": "f2390:m9"}
{"signature": "def _mkdir(p):", "body": "isdir = os.path.isdir<EOL>stack = [os.path.abspath(p)]<EOL>while not isdir(stack[-<NUM_LIT:1>]):<EOL><INDENT>parent_dir = os.path.dirname(stack[-<NUM_LIT:1>])<EOL>stack.append(parent_dir)<EOL><DEDENT>while stack:<EOL><INDENT>p = stack.pop()<EOL>if not isdir(p):<EOL><INDENT>os.mkdir(p)<EOL><DEDENT><DEDENT>", "docstring": "The equivalent of 'mkdir -p' in shell.", "id": "f2390:m8"}
{"signature": "def prettyprint_xml(element):", "body": "return etree.tostring(element, pretty_print=True).decode('<STR_LIT:utf-8>')<EOL>", "docstring": "A rough and dirty way to prettyprint an Element with indention.\n\n:param lxml.etree._Element element: The Element or ElementTree to format.\n:rtype: str\n:returns: A prettyprinted representation of the element.", "id": "f2398:m1"}
{"signature": "def _change_resource_record_sets(self, change_set, comment=None):", "body": "body = xml_generators.change_resource_record_set_writer(<EOL>connection=self,<EOL>change_set=change_set,<EOL>comment=comment<EOL>)<EOL>root = self._send_request(<EOL>path='<STR_LIT>' % change_set.hosted_zone_id,<EOL>data=body,<EOL>method='<STR_LIT:POST>',<EOL>)<EOL>e_change_info = root.find('<STR_LIT>')<EOL>if e_change_info is None:<EOL><INDENT>error = root.find('<STR_LIT>').find('<STR_LIT>').text<EOL>raise Route53Error(error)<EOL><DEDENT>return parse_change_info(e_change_info)<EOL>", "docstring": "Given a ChangeSet, POST it to the Route53 API.\n\n.. note:: You probably shouldn't be using this method directly,\n    as there are convenience methods on the ResourceRecordSet\n    sub-classes.\n\n:param change_set.ChangeSet change_set: The ChangeSet object to create\n    the XML doc from.\n:keyword str comment: An optional comment to go along with the request.\n:rtype: dict\n:returns: A dict of change info, which contains some details about\n    the request.", "id": "f2399:c0:m8"}
{"signature": "def _do_autopaginating_api_call(self, path, params, method, parser_func,<EOL>next_marker_xpath, next_marker_param_name,<EOL>next_type_xpath=None, parser_kwargs=None):", "body": "if not parser_kwargs:<EOL><INDENT>parser_kwargs = {}<EOL><DEDENT>while True:<EOL><INDENT>root = self._send_request(path, params, method)<EOL>for record in parser_func(root, connection=self, **parser_kwargs):<EOL><INDENT>yield record<EOL><DEDENT>next_marker = root.find(next_marker_xpath)<EOL>if next_marker is None:<EOL><INDENT>break<EOL><DEDENT>params[next_marker_param_name] = next_marker.text<EOL>if next_type_xpath:<EOL><INDENT>next_type = root.find(next_type_xpath)<EOL>params['<STR_LIT:type>'] = next_type.text<EOL><DEDENT><DEDENT>", "docstring": "Given an API method, the arguments passed to it, and a function to\nhand parsing off to, loop through the record sets in the API call\nuntil all records have been yielded.\n\n\n:param str method: The API method on the endpoint.\n:param dict params: The kwargs from the top-level API method.\n:param callable parser_func: A callable that is used for parsing the\n    output from the API call.\n:param str next_marker_param_name: The XPath to the marker tag that\n    will determine whether we continue paginating.\n:param str next_marker_param_name: The parameter name to manipulate\n    in the request data to bring up the next page on the next\n    request loop.\n:keyword str next_type_xpath: For the\n    py:meth:`list_resource_record_sets_by_zone_id` method, there's\n    an additional paginator token. Specifying this XPath looks for it.\n:keyword dict parser_kwargs: Optional dict of additional kwargs to pass\n    on to the parser function.\n:rtype: generator\n:returns: Returns a generator that may be returned by the top-level\n    API method.", "id": "f2399:c0:m2"}
{"signature": "def list_hosted_zones(self, page_chunks=<NUM_LIT:100>):", "body": "return  self._do_autopaginating_api_call(<EOL>path='<STR_LIT>',<EOL>params={'<STR_LIT>': page_chunks},<EOL>method='<STR_LIT:GET>',<EOL>parser_func=xml_parsers.list_hosted_zones_parser,<EOL>next_marker_xpath=\"<STR_LIT>\",<EOL>next_marker_param_name=\"<STR_LIT>\",<EOL>)<EOL>", "docstring": "List all hosted zones associated with this connection's account. Since\nthis method returns a generator, you can pull as many or as few\nentries as you'd like, without having to query and receive every\nhosted zone you may have.\n\n:keyword int page_chunks: This API call is \"paginated\" behind-the-scenes\n    in order to break up large result sets. This number determines\n    the maximum number of\n    :py:class:`HostedZone <route53.hosted_zone.HostedZone>`\n    instances to retrieve per request. The default is fine for almost\n    everyone.\n\n:rtype: generator\n:returns: A generator of :py:class:`HostedZone <route53.hosted_zone.HostedZone>`\n    instances.", "id": "f2399:c0:m3"}
{"signature": "def is_alias_record_set(self):", "body": "<EOL>return False<EOL>", "docstring": "Checks whether this is an A record in Alias mode.\n\n:rtype: bool\n:returns: ``True`` if this is an A record in Alias mode, and\n    ``False`` otherwise.", "id": "f2401:c0:m6"}
{"signature": "def is_alias_record_set(self):", "body": "return self.alias_hosted_zone_id or self.alias_dns_name<EOL>", "docstring": "Checks whether this is an A record in Alias mode.\n\n:rtype: bool\n:returns: ``True`` if this is an A record in Alias mode, and\n    ``False`` otherwise.", "id": "f2401:c3:m1"}
{"signature": "def __init__(self, alias_hosted_zone_id=None, alias_dns_name=None, *args, **kwargs):", "body": "super(CNAMEResourceRecordSet, self).__init__(*args, **kwargs)<EOL>self.alias_hosted_zone_id = alias_hosted_zone_id<EOL>self.alias_dns_name = alias_dns_name<EOL>self._initial_vals.update(<EOL>dict(<EOL>alias_hosted_zone_id=alias_hosted_zone_id,<EOL>alias_dns_name=alias_dns_name,<EOL>)<EOL>)<EOL>", "docstring": ":keyword str alias_hosted_zone_id: Alias CNAME records have this specified.\n    It appears to be the hosted zone ID for the ELB the Alias points at.\n:keyword str alias_dns_name: Alias CNAME records have this specified. It is\n    the DNS name for the ELB that the Alias points to.", "id": "f2401:c3:m0"}
{"signature": "def __init__(self, alias_hosted_zone_id=None, alias_dns_name=None, *args, **kwargs):", "body": "super(AResourceRecordSet, self).__init__(*args, **kwargs)<EOL>self.alias_hosted_zone_id = alias_hosted_zone_id<EOL>self.alias_dns_name = alias_dns_name<EOL>self._initial_vals.update(<EOL>dict(<EOL>alias_hosted_zone_id=alias_hosted_zone_id,<EOL>alias_dns_name=alias_dns_name,<EOL>)<EOL>)<EOL>", "docstring": ":keyword str alias_hosted_zone_id: Alias A records have this specified.\n    It appears to be the hosted zone ID for the ELB the Alias points at.\n:keyword str alias_dns_name: Alias A records have this specified. It is\n    the DNS name for the ELB that the Alias points to.", "id": "f2401:c1:m0"}
{"signature": "def create_hosted_zone_writer(connection, name, caller_reference, comment):", "body": "if not caller_reference:<EOL><INDENT>caller_reference = str(uuid.uuid4())<EOL><DEDENT>e_root = etree.Element(<EOL>\"<STR_LIT>\",<EOL>xmlns=connection._xml_namespace<EOL>)<EOL>e_name = etree.SubElement(e_root, \"<STR_LIT:Name>\")<EOL>e_name.text = name<EOL>e_caller_reference = etree.SubElement(e_root, \"<STR_LIT>\")<EOL>e_caller_reference.text = caller_reference<EOL>if comment:<EOL><INDENT>e_config = etree.SubElement(e_root, \"<STR_LIT>\")<EOL>e_comment = etree.SubElement(e_config, \"<STR_LIT>\")<EOL>e_comment.text = comment<EOL><DEDENT>e_tree = etree.ElementTree(element=e_root)<EOL>fobj = BytesIO()<EOL>e_tree.write(fobj, xml_declaration=True, encoding='<STR_LIT:utf-8>', method=\"<STR_LIT>\")<EOL>return fobj.getvalue().decode('<STR_LIT:utf-8>')<EOL>", "docstring": "Forms an XML string that we'll send to Route53 in order to create\na new hosted zone.\n\n:param Route53Connection connection: The connection instance used to\n    query the API.\n:param str name: The name of the hosted zone to create.", "id": "f2402:m0"}
{"signature": "def write_change(change):", "body": "action, rrset = change<EOL>change_vals = get_change_values(change)<EOL>e_change = etree.Element(\"<STR_LIT>\")<EOL>e_action = etree.SubElement(e_change, \"<STR_LIT>\")<EOL>e_action.text = action<EOL>e_rrset = etree.SubElement(e_change, \"<STR_LIT>\")<EOL>e_name = etree.SubElement(e_rrset, \"<STR_LIT:Name>\")<EOL>e_name.text = change_vals['<STR_LIT:name>']<EOL>e_type = etree.SubElement(e_rrset, \"<STR_LIT>\")<EOL>e_type.text = rrset.rrset_type<EOL>if change_vals.get('<STR_LIT>'):<EOL><INDENT>e_set_id = etree.SubElement(e_rrset, \"<STR_LIT>\")<EOL>e_set_id.text = change_vals['<STR_LIT>']<EOL><DEDENT>if change_vals.get('<STR_LIT>'):<EOL><INDENT>e_weight = etree.SubElement(e_rrset, \"<STR_LIT>\")<EOL>e_weight.text = change_vals['<STR_LIT>']<EOL><DEDENT>if change_vals.get('<STR_LIT>') or change_vals.get('<STR_LIT>'):<EOL><INDENT>e_alias_target = etree.SubElement(e_rrset, \"<STR_LIT>\")<EOL>e_hosted_zone_id = etree.SubElement(e_alias_target, \"<STR_LIT>\")<EOL>e_hosted_zone_id.text = change_vals['<STR_LIT>']<EOL>e_dns_name = etree.SubElement(e_alias_target, \"<STR_LIT>\")<EOL>e_dns_name.text = change_vals['<STR_LIT>']<EOL><DEDENT>if change_vals.get('<STR_LIT>'):<EOL><INDENT>e_weight = etree.SubElement(e_rrset, \"<STR_LIT>\")<EOL>e_weight.text = change_vals['<STR_LIT>']<EOL><DEDENT>e_ttl = etree.SubElement(e_rrset, \"<STR_LIT>\")<EOL>e_ttl.text = str(change_vals['<STR_LIT>'])<EOL>if rrset.is_alias_record_set():<EOL><INDENT>return e_change<EOL><DEDENT>e_resource_records = etree.SubElement(e_rrset, \"<STR_LIT>\")<EOL>for value in change_vals['<STR_LIT>']:<EOL><INDENT>e_resource_record = etree.SubElement(e_resource_records, \"<STR_LIT>\")<EOL>e_value = etree.SubElement(e_resource_record, \"<STR_LIT>\")<EOL>e_value.text = value<EOL><DEDENT>return e_change<EOL>", "docstring": "Creates an XML element for the change.\n\n:param tuple change: A change tuple from a ChangeSet. Comes in the form\n    of ``(action, rrset)``.\n:rtype: lxml.etree._Element\n:returns: A fully baked Change tag.", "id": "f2403:m1"}
{"signature": "def create_a_record(self, name, values, ttl=<NUM_LIT>, weight=None, region=None,<EOL>set_identifier=None, alias_hosted_zone_id=None,<EOL>alias_dns_name=None):", "body": "self._halt_if_already_deleted()<EOL>values = locals()<EOL>del values['<STR_LIT>']<EOL>return self._add_record(AResourceRecordSet, **values)<EOL>", "docstring": "Creates and returns an A record attached to this hosted zone.\n\n:param str name: The fully qualified name of the record to add.\n:param list values: A list of value strings for the record.\n:keyword int ttl: The time-to-live of the record (in seconds).\n:keyword int weight: *For weighted record sets only*. Among resource record\n    sets that have the same combination of DNS name and type, a value\n    that determines what portion of traffic for the current resource\n    record set is routed to the associated location. Ranges from 0-255.\n:keyword str region: *For latency-based record sets*. The Amazon EC2 region\n    where the resource that is specified in this resource record set\n    resides.\n:keyword str set_identifier: *For weighted and latency resource record\n    sets only*. An identifier that differentiates among multiple\n    resource record sets that have the same combination of DNS name\n    and type. 1-128 chars.\n:keyword str alias_hosted_zone_id: Alias A records have this specified.\n    It appears to be the hosted zone ID for the ELB the Alias points at.\n:keyword str alias_dns_name: Alias A records have this specified. It is\n    the DNS name for the ELB that the Alias points to.\n:rtype: tuple\n:returns: A tuple in the form of ``(rrset, change_info)``, where\n    ``rrset`` is the newly created\n    :py:class:`AResourceRecordSet <route53.resource_record_set.AResourceRecordSet>`\n    instance.", "id": "f2405:c0:m7"}
{"signature": "def create_spf_record(self, name, values, ttl=<NUM_LIT>):", "body": "self._halt_if_already_deleted()<EOL>values = locals()<EOL>del values['<STR_LIT>']<EOL>return self._add_record(SPFResourceRecordSet, **values)<EOL>", "docstring": "Creates a SPF record attached to this hosted zone.\n\n:param str name: The fully qualified name of the record to add.\n:param list values: A list of value strings for the record.\n:keyword int ttl: The time-to-live of the record (in seconds).\n:rtype: tuple\n:returns: A tuple in the form of ``(rrset, change_info)``, where\n    ``rrset`` is the newly created SPFResourceRecordSet instance.", "id": "f2405:c0:m13"}
{"signature": "def _halt_if_already_deleted(self):", "body": "if self._is_deleted:<EOL><INDENT>raise AlreadyDeletedError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Convenience method used to raise an AlreadyDeletedError exception if\nthis HostedZone has been deleted.\n\n:raises: AlreadyDeletedError", "id": "f2405:c0:m5"}
{"signature": "def _add_record(self, record_set_class, name, values, ttl=<NUM_LIT>, weight=None,<EOL>region=None,set_identifier=None, alias_hosted_zone_id=None,<EOL>alias_dns_name=None):", "body": "self._halt_if_already_deleted()<EOL>rrset_kwargs = dict(<EOL>connection=self.connection,<EOL>zone_id=self.id,<EOL>name=name,<EOL>ttl=ttl,<EOL>records=values,<EOL>weight=weight,<EOL>region=region,<EOL>set_identifier=set_identifier,<EOL>)<EOL>if alias_hosted_zone_id or alias_dns_name:<EOL><INDENT>rrset_kwargs.update(dict(<EOL>alias_hosted_zone_id=alias_hosted_zone_id,<EOL>alias_dns_name=alias_dns_name<EOL>))<EOL><DEDENT>rrset = record_set_class(**rrset_kwargs)<EOL>cset = ChangeSet(connection=self.connection, hosted_zone_id=self.id)<EOL>cset.add_change('<STR_LIT>', rrset)<EOL>change_info = self.connection._change_resource_record_sets(cset)<EOL>return rrset, change_info<EOL>", "docstring": "Convenience method for creating ResourceRecordSets. Most of the calls\nare basically the same, this saves on repetition.\n\n:rtype: tuple\n:returns: A tuple in the form of ``(rrset, change_info)``, where\n    ``rrset`` is the newly created ResourceRecordSet sub-class\n     instance.", "id": "f2405:c0:m6"}
{"signature": "def connect(aws_access_key_id=None, aws_secret_access_key=None, **kwargs):", "body": "from route53.connection import Route53Connection<EOL>return Route53Connection(<EOL>aws_access_key_id,<EOL>aws_secret_access_key,<EOL>**kwargs<EOL>)<EOL>", "docstring": "Instantiates and returns a :py:class:`route53.connection.Route53Connection`\ninstance, which is how you'll start your interactions with the Route 53\nAPI.\n\n:keyword str aws_access_key_id: Your AWS Access Key ID\n:keyword str aws_secret_access_key: Your AWS Secret Access Key\n\n:rtype: :py:class:`route53.connection.Route53Connection`\n:return: A connection to Amazon's Route 53", "id": "f2406:m0"}
{"signature": "def _send_post_request(self, path, data, headers):", "body": "raise NotImplementedError<EOL>", "docstring": "Transport sub-classes need to override this.\n\nSends the POST request to the Route53 endpoint.\n\n:param str path: The path to tack on to the endpoint URL for\n    the query.\n:param data: Either a dict, or bytes.\n:type data: dict or bytes\n:param dict headers: A dict of headers to send with the request.\n:rtype: str\n:returns: The body of the response.", "id": "f2407:c0:m6"}
{"signature": "@property<EOL><INDENT>def endpoint(self):<DEDENT>", "body": "return self.connection._endpoint<EOL>", "docstring": ":rtype: str\n:returns: The Route53 API endpoint to query against.", "id": "f2407:c0:m1"}
{"signature": "def parse_rrset(e_rrset, connection, zone_id):", "body": "<EOL>kwargs = {<EOL>'<STR_LIT>': connection,<EOL>'<STR_LIT>': zone_id,<EOL>}<EOL>rrset_type = None<EOL>for e_field in e_rrset:<EOL><INDENT>tag_name = e_field.tag.split('<STR_LIT:}>')[<NUM_LIT:1>]<EOL>field_text = e_field.text<EOL>if tag_name == '<STR_LIT>':<EOL><INDENT>rrset_type = field_text<EOL>continue<EOL><DEDENT>elif tag_name == '<STR_LIT>':<EOL><INDENT>alias_hosted_zone_id, alias_dns_name = parse_rrset_alias(e_field)<EOL>kwargs['<STR_LIT>'] = alias_hosted_zone_id<EOL>kwargs['<STR_LIT>'] = alias_dns_name<EOL>kwargs['<STR_LIT>'] = None<EOL>continue<EOL><DEDENT>elif tag_name == '<STR_LIT>':<EOL><INDENT>kwargs['<STR_LIT>'] = parse_rrset_record_values(e_field)<EOL>continue<EOL><DEDENT>kw_name = RRSET_TAG_TO_KWARG_MAP[tag_name]<EOL>kwargs[kw_name] = field_text<EOL><DEDENT>if not rrset_type:<EOL><INDENT>raise Route53Error(\"<STR_LIT>\")<EOL><DEDENT>if '<STR_LIT>' not in kwargs:<EOL><INDENT>kwargs['<STR_LIT>'] = []<EOL><DEDENT>RRSetSubclass = RRSET_TYPE_TO_RSET_SUBCLASS_MAP[rrset_type]<EOL>return RRSetSubclass(**kwargs)<EOL>", "docstring": "This a parser that allows the passing of any valid ResourceRecordSet\ntag. It will spit out the appropriate ResourceRecordSet object for the tag.\n\n:param lxml.etree._Element e_rrset: The root node of the etree parsed\n    response from the API.\n:param Route53Connection connection: The connection instance used to\n    query the API.\n:param str zone_id: The zone ID of the HostedZone these rrsets belong to.\n:rtype: ResourceRecordSet\n:returns: An instantiated ResourceRecordSet object.", "id": "f2408:m2"}
{"signature": "def list_hosted_zones_parser(root, connection):", "body": "<EOL>zones = root.find('<STR_LIT>')<EOL>for zone in zones:<EOL><INDENT>yield parse_hosted_zone(zone, connection)<EOL><DEDENT>", "docstring": "Parses the API responses for the\n:py:meth:`route53.connection.Route53Connection.list_hosted_zones` method.\n\n:param lxml.etree._Element root: The root node of the etree parsed\n    response from the API.\n:param Route53Connection connection: The connection instance used to\n    query the API.\n:rtype: HostedZone\n:returns: A generator of fully formed HostedZone instances.", "id": "f2414:m0"}
{"signature": "def parse_hosted_zone(e_zone, connection):", "body": "<EOL>kwargs = {}<EOL>for e_field in e_zone:<EOL><INDENT>tag_name = e_field.tag.split('<STR_LIT:}>')[<NUM_LIT:1>]<EOL>field_text = e_field.text<EOL>if tag_name == '<STR_LIT>':<EOL><INDENT>e_comment = e_field.find('<STR_LIT>')<EOL>kwargs['<STR_LIT>'] = e_comment.text if e_comment is not None else None<EOL>continue<EOL><DEDENT>elif tag_name == '<STR_LIT>':<EOL><INDENT>field_text = field_text.strip('<STR_LIT>')<EOL><DEDENT>kw_name = HOSTED_ZONE_TAG_TO_KWARG_MAP[tag_name]<EOL>kwargs[kw_name] = field_text<EOL><DEDENT>return HostedZone(connection, **kwargs)<EOL>", "docstring": "This a common parser that allows the passing of any valid HostedZone\ntag. It will spit out the appropriate HostedZone object for the tag.\n\n:param lxml.etree._Element e_zone: The root node of the etree parsed\n    response from the API.\n:param Route53Connection connection: The connection instance used to\n    query the API.\n:rtype: HostedZone\n:returns: An instantiated HostedZone object.", "id": "f2415:m0"}
{"signature": "def read_logfile(log_file):", "body": "dirname = os.path.dirname(log_file) + '<STR_LIT:/>'<EOL>with open(log_file, '<STR_LIT:r>') as f:<EOL><INDENT>rlog = f.readlines()<EOL><DEDENT>hashind = [i for i, n in enumerate(rlog) if '<STR_LIT:#>' in n]<EOL>pathread = re.compile('<STR_LIT>')<EOL>paths = (pathread.match(l).groups() for l in rlog[hashind[<NUM_LIT:0>] + <NUM_LIT:1>:hashind[-<NUM_LIT:1>]] if pathread.match(l))<EOL>paths = {k: os.path.join(dirname, v) for k, v in paths}<EOL>logread = re.compile('<STR_LIT>')<EOL>runargs = []<EOL>for line in rlog[hashind[<NUM_LIT:1>] + <NUM_LIT:1>:]:<EOL><INDENT>fname, args, kwargs = (logread.match(line).groups())<EOL>runargs.append((fname ,{'<STR_LIT:args>': eval(args), '<STR_LIT>': eval(kwargs)}))<EOL>if fname == '<STR_LIT>':<EOL><INDENT>runargs[-<NUM_LIT:1>][-<NUM_LIT:1>]['<STR_LIT>']['<STR_LIT>'] = '<STR_LIT>'<EOL>runargs[-<NUM_LIT:1>][-<NUM_LIT:1>]['<STR_LIT>']['<STR_LIT>'] = None<EOL>runargs[-<NUM_LIT:1>][-<NUM_LIT:1>]['<STR_LIT>']['<STR_LIT>'] = paths['<STR_LIT>']<EOL>if '<STR_LIT>' in paths:<EOL><INDENT>runargs[-<NUM_LIT:1>][-<NUM_LIT:1>]['<STR_LIT>']['<STR_LIT>'] = paths['<STR_LIT>']<EOL><DEDENT><DEDENT><DEDENT>return runargs, paths<EOL>", "docstring": "Reads an latools analysis.log file, and returns dicts of arguments.\n\nParameters\n----------\nlog_file : str\n    Path to an analysis.log file produced by latools.\n\nReturns\n-------\nrunargs, paths : tuple\n    Two dictionaries. runargs contains all the arguments required to run each step\n    of analysis in the form (function_name, {'args': (), 'kwargs': {}}). paths contains\n    the locations of the data directory and the SRM database used for analysis.", "id": "f2424:m2"}
{"signature": "def to_mass_fraction(molar_ratio, massfrac_denominator, numerator_mass, denominator_mass):", "body": "return molar_ratio * massfrac_denominator * numerator_mass / denominator_mass<EOL>", "docstring": "Converts per-mass concentrations to molar elemental ratios.\n\nBe careful with units.\n\nParameters\n----------\nmolar_ratio : float or array-like\n    The molar ratio of elements.\nmassfrac_denominator : float or array-like\n    The mass fraction of the denominator element\nnumerator_mass, denominator_mass : float or array-like\n    The atomic mass of the numerator and denominator.\n\nReturns\n-------\nfloat or array-like : The mass fraction of the numerator element.", "id": "f2425:m3"}
{"signature": "def elements(all_isotopes=True):", "body": "el = pd.read_pickle(pkgrs.resource_filename('<STR_LIT>', '<STR_LIT>'))<EOL>if all_isotopes:<EOL><INDENT>return el.set_index('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>def wmean(g):<EOL><INDENT>return (g.atomic_weight * g.percent).sum() / <NUM_LIT:100><EOL><DEDENT>iel = el.groupby('<STR_LIT>').apply(wmean)<EOL>iel.name = '<STR_LIT>'<EOL>return iel<EOL><DEDENT>", "docstring": "Loads a DataFrame of all elements and isotopes.\n\nScraped from https://www.webelements.com/\n\nReturns\n-------\npandas DataFrame with columns (element, atomic_number, isotope, atomic_weight, percent)", "id": "f2425:m0"}
{"signature": "def to_molar_ratio(massfrac_numerator, massfrac_denominator, numerator_mass, denominator_mass):", "body": "return (massfrac_numerator / numerator_mass) / (massfrac_denominator / denominator_mass)<EOL>", "docstring": "Converts per-mass concentrations to molar elemental ratios.\n\nBe careful with units.\n\nParameters\n----------\nnumerator_mass, denominator_mass : float or array-like\n    The atomic mass of the numerator and denominator.\nmassfrac_numerator, massfrac_denominator : float or array-like\n    The per-mass fraction of the numnerator and denominator.\n\nReturns\n-------\nfloat or array-like : The molar ratio of elements in the material", "id": "f2425:m2"}
{"signature": "def autorange_plot(t, sig, gwin=<NUM_LIT:7>, swin=None, win=<NUM_LIT:30>,<EOL>on_mult=(<NUM_LIT>, <NUM_LIT:1.>), off_mult=(<NUM_LIT:1.>, <NUM_LIT>),<EOL>nbin=<NUM_LIT:10>, thresh=None):", "body": "if swin is None:<EOL><INDENT>swin = gwin // <NUM_LIT:2><EOL><DEDENT>sigs = fastsmooth(sig, swin)<EOL>bins = sig.size // nbin<EOL>kde_x = np.linspace(sig.min(), sig.max(), bins)<EOL>kde = gaussian_kde(sigs)<EOL>yd = kde.pdf(kde_x)<EOL>mins = findmins(kde_x, yd)  <EOL>if thresh is not None:<EOL><INDENT>mins = [thresh]<EOL><DEDENT>if len(mins) > <NUM_LIT:0>:<EOL><INDENT>bkg = sigs < (mins[<NUM_LIT:0>])  <EOL><DEDENT>else:<EOL><INDENT>bkg = np.ones(sig.size, dtype=bool)<EOL><DEDENT>fbkg = bkg<EOL>fsig = ~bkg<EOL>g = abs(fastgrad(sigs, gwin))  <EOL>zeros = bool_2_indices(fsig)<EOL>if zeros is not None:<EOL><INDENT>zeros = zeros.flatten()<EOL>lohi = []<EOL>pgs = []<EOL>excl = []<EOL>tps = []<EOL>failed = []<EOL>for z in zeros:  <EOL><INDENT>if z - win < <NUM_LIT:0>:<EOL><INDENT>lo = gwin // <NUM_LIT:2><EOL>hi = int(z + win)<EOL><DEDENT>elif z + win > (len(sig) - gwin // <NUM_LIT:2>):<EOL><INDENT>lo = int(z - win)<EOL>hi = len(sig) - gwin // <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>lo = int(z - win)<EOL>hi = int(z + win)<EOL><DEDENT>xs = t[lo:hi]<EOL>ys = g[lo:hi]<EOL>lohi.append([lo, hi])<EOL>mid = (hi + lo) // <NUM_LIT:2><EOL>tp = sigs[mid + <NUM_LIT:3>] > sigs[mid - <NUM_LIT:3>]  <EOL>tps.append(tp)<EOL>c = t[z]  <EOL>width = (t[<NUM_LIT:1>] - t[<NUM_LIT:0>]) * <NUM_LIT:2>  <EOL>try:<EOL><INDENT>pg, _ = curve_fit(gauss, xs, ys,<EOL>p0=(np.nanmax(ys),<EOL>c,<EOL>width),<EOL>sigma=(xs - c)**<NUM_LIT:2> + <NUM_LIT>)<EOL>pgs.append(pg)<EOL>fwhm = abs(<NUM_LIT:2> * pg[-<NUM_LIT:1>] * np.sqrt(<NUM_LIT:2> * np.log(<NUM_LIT:2>)))<EOL>if tp:<EOL><INDENT>lim = np.array([-fwhm, fwhm]) * on_mult + pg[<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>lim = np.array([-fwhm, fwhm]) * off_mult + pg[<NUM_LIT:1>]<EOL><DEDENT>excl.append(lim)<EOL>fbkg[(t > lim[<NUM_LIT:0>]) & (t < lim[<NUM_LIT:1>])] = False<EOL>fsig[(t > lim[<NUM_LIT:0>]) & (t < lim[<NUM_LIT:1>])] = False<EOL>failed.append(False)<EOL><DEDENT>except RuntimeError:<EOL><INDENT>failed.append(True)<EOL>lohi.append([np.nan, np.nan])<EOL>pgs.append([np.nan, np.nan, np.nan])<EOL>excl.append([np.nan, np.nan])<EOL>tps.append(tp)<EOL>pass<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>zeros = []<EOL><DEDENT>nrows = <NUM_LIT:2> + len(zeros) // <NUM_LIT:2> + len(zeros) % <NUM_LIT:2><EOL>fig, axs = plt.subplots(nrows, <NUM_LIT:2>, figsize=(<NUM_LIT:6>, <NUM_LIT:4> + <NUM_LIT> * nrows))<EOL>ax1, ax2, ax3, ax4 = axs.flat[:<NUM_LIT:4>]<EOL>ax4.set_visible(False)<EOL>for ax in [ax1, ax3]:<EOL><INDENT>p = ax.axes.get_position()<EOL>p2 = [p.x0, p.y0, p.width * <NUM_LIT>, p.height]<EOL>ax.axes.set_position(p2)<EOL><DEDENT>p = ax3.axes.get_position()<EOL>p2 = [p.x0, p.y0 + <NUM_LIT> * p.height, p.width, p.height]<EOL>ax3.axes.set_position(p2)<EOL>p = ax2.axes.get_position()<EOL>p2 = [p.x0 + p.width * <NUM_LIT>, p.y0, p.width * <NUM_LIT>, p.height]<EOL>ax2.axes.set_position(p2)<EOL>ax1.plot(t, sig, color='<STR_LIT:k>', lw=<NUM_LIT:1>)<EOL>ax1.set_xticklabels([])<EOL>ax1.set_ylabel('<STR_LIT>')<EOL>ax3.plot(t, g, color='<STR_LIT:k>', lw=<NUM_LIT:1>)<EOL>ax3.set_xlabel('<STR_LIT>')<EOL>ax3.set_ylabel('<STR_LIT>')<EOL>ax2.fill_betweenx(kde_x, yd, color=(<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT>))<EOL>ax2.plot(yd, kde_x, color='<STR_LIT:k>')<EOL>ax2.set_ylim(ax1.get_ylim())<EOL>ax2.set_yticklabels([])<EOL>ax2.set_xlabel('<STR_LIT>')<EOL>for ax in [ax1, ax2]:<EOL><INDENT>ax.axhline(mins[<NUM_LIT:0>], color='<STR_LIT:k>', ls='<STR_LIT>', alpha=<NUM_LIT>)<EOL><DEDENT>if len(zeros) > <NUM_LIT:0>:<EOL><INDENT>for z in zeros:<EOL><INDENT>ax1.axvline(t[z], color='<STR_LIT:r>', alpha=<NUM_LIT:0.5>)<EOL>ax3.axvline(t[z], color='<STR_LIT:r>', alpha=<NUM_LIT:0.5>)<EOL><DEDENT>n = <NUM_LIT:1><EOL>for (lo, hi), lim, tp, pg, fail, ax in zip(lohi, excl, tps, pgs, failed, axs.flat[<NUM_LIT:4>:]):<EOL><INDENT>ax3.axvspan(t[lo], t[hi], color='<STR_LIT:r>', alpha=<NUM_LIT:0.1>, zorder=-<NUM_LIT:2>)<EOL>x = t[lo:hi]<EOL>y = g[lo:hi]<EOL>ys = sig[lo:hi]<EOL>ax.scatter(x, y, color='<STR_LIT:k>', marker='<STR_LIT:x>', zorder=-<NUM_LIT:1>, s=<NUM_LIT:10>)<EOL>ax.set_yticklabels([])<EOL>ax.set_ylim(rangecalc(y))<EOL>tax = ax.twinx()<EOL>tax.plot(x, ys, color='<STR_LIT:k>', alpha=<NUM_LIT>, zorder=-<NUM_LIT:5>)<EOL>tax.set_yticklabels([])<EOL>tax.set_ylim(rangecalc(ys))<EOL>xn = np.linspace(x.min(), x.max(), <NUM_LIT:100>)<EOL>ax.plot(xn, gauss(xn, *pg), color='<STR_LIT:r>', alpha=<NUM_LIT:0.5>)<EOL>ax.axvline(pg[<NUM_LIT:1>], color='<STR_LIT:b>', alpha=<NUM_LIT:0.5>)<EOL>ax.axvspan(*lim, color='<STR_LIT:b>', alpha=<NUM_LIT:0.1>, zorder=-<NUM_LIT:2>)<EOL>ax1.axvspan(*lim, color='<STR_LIT:b>', alpha=<NUM_LIT:0.1>, zorder=-<NUM_LIT:2>)<EOL>if tp:<EOL><INDENT>ax.text(<NUM_LIT>, <NUM_LIT>, '<STR_LIT>'.format(n), ha='<STR_LIT:left>',<EOL>va='<STR_LIT>', transform=ax.transAxes)<EOL><DEDENT>else:<EOL><INDENT>ax.text(<NUM_LIT>, <NUM_LIT>, '<STR_LIT>'.format(n), ha='<STR_LIT:right>',<EOL>va='<STR_LIT>', transform=ax.transAxes)<EOL><DEDENT>if ax.is_last_row():<EOL><INDENT>ax.set_xlabel('<STR_LIT>')<EOL><DEDENT>if ax.is_first_col():<EOL><INDENT>ax.set_ylabel('<STR_LIT>')<EOL><DEDENT>if ax.is_last_col():<EOL><INDENT>tax.set_ylabel('<STR_LIT>')<EOL><DEDENT>if fail:<EOL><INDENT>ax.axes.set_facecolor((<NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT>))<EOL>ax.text(<NUM_LIT>, <NUM_LIT>, '<STR_LIT>', ha='<STR_LIT>', va='<STR_LIT>',<EOL>fontsize=<NUM_LIT:16>, color=(<NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0.5>), transform=ax.transAxes)<EOL><DEDENT>n += <NUM_LIT:1><EOL><DEDENT>if len(zeros) % <NUM_LIT:2> == <NUM_LIT:1>:<EOL><INDENT>axs.flat[-<NUM_LIT:1>].set_visible = False<EOL><DEDENT><DEDENT>return fig, axs<EOL>", "docstring": "Function for visualising the autorange mechanism.\n\nParameters\n----------\nt : array-like\n    Independent variable (usually time).\nsig : array-like\n    Dependent signal, with distinctive 'on' and 'off' regions.\ngwin : int\n    The window used for calculating first derivative.\n    Defaults to 7.\nswin : int\n    The window ised for signal smoothing. If None, gwin // 2.\nwin : int\n    The width (c +/- win) of the transition data subsets.\n    Defaults to 20.\non_mult and off_mult : tuple, len=2\n    Control the width of the excluded transition regions, which is defined\n    relative to the peak full-width-half-maximum (FWHM) of the transition\n    gradient. The region n * FHWM below the transition, and m * FWHM above\n    the tranision will be excluded, where (n, m) are specified in `on_mult`\n    and `off_mult`.\n    `on_mult` and `off_mult` apply to the off-on and on-off transitions,\n    respectively.\n    Defaults to (1.5, 1) and (1, 1.5).\nnbin : ind\n    Used to calculate the number of bins in the data histogram.\n    bins = len(sig) // nbin\n\nReturns\n-------\nfig, axes", "id": "f2426:m5"}
{"signature": "def crossplot(dat, keys=None, lognorm=True, bins=<NUM_LIT>, figsize=(<NUM_LIT:12>, <NUM_LIT:12>),<EOL>colourful=True, focus_stage=None, denominator=None,<EOL>mode='<STR_LIT>', cmap=None, **kwargs):", "body": "if keys is None:<EOL><INDENT>keys = list(dat.keys())<EOL><DEDENT>numvar = len(keys)<EOL>if figsize[<NUM_LIT:0>] < <NUM_LIT> * numvar:<EOL><INDENT>figsize = [<NUM_LIT> * numvar] * <NUM_LIT:2><EOL><DEDENT>fig, axes = plt.subplots(nrows=numvar, ncols=numvar,<EOL>figsize=(<NUM_LIT:12>, <NUM_LIT:12>))<EOL>fig.subplots_adjust(hspace=<NUM_LIT>, wspace=<NUM_LIT>)<EOL>for ax in axes.flat:<EOL><INDENT>ax.xaxis.set_visible(False)<EOL>ax.yaxis.set_visible(False)<EOL>if ax.is_first_col():<EOL><INDENT>ax.yaxis.set_ticks_position('<STR_LIT:left>')<EOL><DEDENT>if ax.is_last_col():<EOL><INDENT>ax.yaxis.set_ticks_position('<STR_LIT:right>')<EOL><DEDENT>if ax.is_first_row():<EOL><INDENT>ax.xaxis.set_ticks_position('<STR_LIT>')<EOL><DEDENT>if ax.is_last_row():<EOL><INDENT>ax.xaxis.set_ticks_position('<STR_LIT>')<EOL><DEDENT><DEDENT>if colourful:<EOL><INDENT>cmlist = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>cmlist = ['<STR_LIT>']<EOL><DEDENT>if cmap is None and mode == '<STR_LIT>':<EOL><INDENT>cmap = {k: '<STR_LIT:k>' for k in dat.keys()}<EOL><DEDENT>while len(cmlist) < len(keys):<EOL><INDENT>cmlist *= <NUM_LIT:2><EOL><DEDENT>focus = {k: nominal_values(dat[k]) for k in keys}<EOL>udict = {a: unitpicker(np.nanmean(focus[a]),<EOL>focus_stage=focus_stage,<EOL>denominator=denominator) for a in keys}<EOL>rdict = {a: (np.nanmin(focus[a] * udict[a][<NUM_LIT:0>]),<EOL>np.nanmax(focus[a] * udict[a][<NUM_LIT:0>])) for a in keys}<EOL>for i, j in tqdm(zip(*np.triu_indices_from(axes, k=<NUM_LIT:1>)), desc='<STR_LIT>',<EOL>total=sum(range(len(keys)))):<EOL><INDENT>ai = keys[i]<EOL>aj = keys[j]<EOL>pi = focus[ai] * udict[ai][<NUM_LIT:0>]<EOL>pj = focus[aj] * udict[aj][<NUM_LIT:0>]<EOL>if lognorm:<EOL><INDENT>norm = mpl.colors.LogNorm()<EOL><DEDENT>else:<EOL><INDENT>norm = None<EOL><DEDENT>if mode == '<STR_LIT>':<EOL><INDENT>pi = pi[~np.isnan(pi)]<EOL>pj = pj[~np.isnan(pj)]<EOL>axes[i, j].hist2d(pj, pi, bins,<EOL>norm=norm,<EOL>cmap=plt.get_cmap(cmlist[i]))<EOL>axes[j, i].hist2d(pi, pj, bins,<EOL>norm=norm,<EOL>cmap=plt.get_cmap(cmlist[j]))<EOL><DEDENT>elif mode == '<STR_LIT>':<EOL><INDENT>axes[i, j].scatter(pj, pi, s=<NUM_LIT:10>,<EOL>color=cmap[ai], lw=<NUM_LIT:0.5>, edgecolor='<STR_LIT:k>',<EOL>alpha=<NUM_LIT>)<EOL>axes[j, i].scatter(pi, pj, s=<NUM_LIT:10>,<EOL>color=cmap[aj], lw=<NUM_LIT:0.5>, edgecolor='<STR_LIT:k>',<EOL>alpha=<NUM_LIT>)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>axes[i, j].set_ylim(*rdict[ai])<EOL>axes[i, j].set_xlim(*rdict[aj])<EOL>axes[j, i].set_ylim(*rdict[aj])<EOL>axes[j, i].set_xlim(*rdict[ai])<EOL><DEDENT>for a, n in zip(keys, np.arange(len(keys))):<EOL><INDENT>axes[n, n].annotate(a + '<STR_LIT:\\n>' + udict[a][<NUM_LIT:1>], (<NUM_LIT:0.5>, <NUM_LIT:0.5>),<EOL>xycoords='<STR_LIT>',<EOL>ha='<STR_LIT>', va='<STR_LIT>', fontsize=<NUM_LIT:8>)<EOL>axes[n, n].set_xlim(*rdict[a])<EOL>axes[n, n].set_ylim(*rdict[a])<EOL><DEDENT>for i, j in zip(range(numvar), itertools.cycle((-<NUM_LIT:1>, <NUM_LIT:0>))):<EOL><INDENT>axes[j, i].xaxis.set_visible(True)<EOL>for label in axes[j, i].get_xticklabels():<EOL><INDENT>label.set_rotation(<NUM_LIT>)<EOL><DEDENT>axes[i, j].yaxis.set_visible(True)<EOL><DEDENT>return fig, axes<EOL>", "docstring": "Plot analytes against each other.\n\nThe number of plots is n**2 - n, where n = len(keys).\n\nParameters\n----------\ndat : dict\n    A dictionary of key: data pairs, where data is the same\n    length in each entry.\nkeys : optional, array_like or str\n    The keys of dat to plot. Defaults to all keys.\nlognorm : bool\n    Whether or not to log normalise the colour scale\n    of the 2D histogram.\nbins : int\n    The number of bins in the 2D histogram.\nfigsize : tuple\ncolourful : bool\n\nReturns\n-------\n(fig, axes)", "id": "f2426:m3"}
{"signature": "def histograms(dat, keys=None, bins=<NUM_LIT>, logy=False, cmap=None, ncol=<NUM_LIT:4>):", "body": "if keys is None:<EOL><INDENT>keys = dat.keys()<EOL><DEDENT>ncol = int(ncol)<EOL>nrow = calc_nrow(len(keys), ncol)<EOL>fig, axs = plt.subplots(nrow, <NUM_LIT:4>, figsize=[ncol * <NUM_LIT:2>, nrow * <NUM_LIT:2>])<EOL>pn = <NUM_LIT:0><EOL>for k, ax in zip(keys, axs.flat):<EOL><INDENT>tmp = nominal_values(dat[k])<EOL>x = tmp[~np.isnan(tmp)]<EOL>if cmap is not None:<EOL><INDENT>c = cmap[k]<EOL><DEDENT>else:<EOL><INDENT>c = (<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0.5>)<EOL><DEDENT>ax.hist(x, bins=bins, color=c)<EOL>if logy:<EOL><INDENT>ax.set_yscale('<STR_LIT>')<EOL>ylab = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>ylab = '<STR_LIT:n>'<EOL><DEDENT>ax.set_ylim(<NUM_LIT:1>, ax.get_ylim()[<NUM_LIT:1>])<EOL>if ax.is_first_col():<EOL><INDENT>ax.set_ylabel(ylab)<EOL><DEDENT>ax.set_yticklabels([])<EOL>ax.text(<NUM_LIT>, <NUM_LIT>, k, ha='<STR_LIT:right>', va='<STR_LIT>', transform=ax.transAxes)<EOL>pn += <NUM_LIT:1><EOL><DEDENT>for ax in axs.flat[pn:]:<EOL><INDENT>ax.set_visible(False)<EOL><DEDENT>fig.tight_layout()<EOL>return fig, axs<EOL>", "docstring": "Plot histograms of all items in dat.\n\nParameters\n----------\ndat : dict\n    Data in {key: array} pairs.\nkeys : arra-like\n    The keys in dat that you want to plot. If None,\n    all are plotted.\nbins : int\n    The number of bins in each histogram (default = 25)\nlogy : bool\n    If true, y axis is a log scale.\ncmap : dict\n    The colours that the different items should be. If None,\n    all are grey.\n\nReturns\n-------\nfig, axes", "id": "f2426:m4"}
{"signature": "def unitpicker(a, llim=<NUM_LIT:0.1>, denominator=None, focus_stage=None):", "body": "if not isinstance(a, (int, float)):<EOL><INDENT>a = nominal_values(a)<EOL>a = np.percentile(a[~np.isnan(a)], <NUM_LIT>)<EOL><DEDENT>if denominator is not None:<EOL><INDENT>pd = pretty_element(denominator)<EOL><DEDENT>else:<EOL><INDENT>pd = '<STR_LIT>'<EOL><DEDENT>if focus_stage == '<STR_LIT>':<EOL><INDENT>udict = {<NUM_LIT:0>: '<STR_LIT>' + pd,<EOL><NUM_LIT:1>: '<STR_LIT>' + pd,<EOL><NUM_LIT:2>: '<STR_LIT>' + pd,<EOL><NUM_LIT:3>: '<STR_LIT>' + pd,<EOL><NUM_LIT:4>: '<STR_LIT>' + pd,<EOL><NUM_LIT:5>: '<STR_LIT>' + pd}<EOL><DEDENT>elif focus_stage == '<STR_LIT>':<EOL><INDENT>udict = {<NUM_LIT:0>: '<STR_LIT>' + pd,<EOL><NUM_LIT:1>: '<STR_LIT>' + pd,<EOL><NUM_LIT:2>: '<STR_LIT>' + pd,<EOL><NUM_LIT:3>: '<STR_LIT>' + pd,<EOL><NUM_LIT:4>: '<STR_LIT>' + pd,<EOL><NUM_LIT:5>: '<STR_LIT>' + pd}<EOL><DEDENT>elif focus_stage in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>udict = udict = {<NUM_LIT:0>: '<STR_LIT>',<EOL><NUM_LIT:1>: '<STR_LIT>',<EOL><NUM_LIT:2>: '<STR_LIT>',<EOL><NUM_LIT:3>: '<STR_LIT>',<EOL><NUM_LIT:4>: '<STR_LIT>',<EOL><NUM_LIT:5>: '<STR_LIT>'}<EOL><DEDENT>else:<EOL><INDENT>udict = {<NUM_LIT:0>: '<STR_LIT>', <NUM_LIT:1>: '<STR_LIT>', <NUM_LIT:2>: '<STR_LIT>', <NUM_LIT:3>: '<STR_LIT>', <NUM_LIT:4>: '<STR_LIT>', <NUM_LIT:5>: '<STR_LIT>'}<EOL><DEDENT>a = abs(a)<EOL>n = <NUM_LIT:0><EOL>if a < llim:<EOL><INDENT>while a < llim:<EOL><INDENT>a *= <NUM_LIT:1000><EOL>n += <NUM_LIT:1><EOL><DEDENT><DEDENT>return float(<NUM_LIT:1000>**n), udict[n]<EOL>", "docstring": "Determines the most appropriate plotting unit for data.\n\nParameters\n----------\na : float or array-like\n    number to optimise. If array like, the 25% quantile is optimised.\nllim : float\n    minimum allowable value in scaled data.\n\nReturns\n-------\n(float, str)\n    (multiplier, unit)", "id": "f2428:m4"}
{"signature": "def get_total_time_span(d):", "body": "tmax = <NUM_LIT:0><EOL>for di in d.values():<EOL><INDENT>if di.uTime.max() > tmax:<EOL><INDENT>tmax = di.uTime.max()<EOL><DEDENT><DEDENT>return tmax<EOL>", "docstring": "Returns total length of analysis.", "id": "f2428:m3"}
{"signature": "def fastgrad(a, win=<NUM_LIT:11>):", "body": "<EOL>if win % <NUM_LIT:2> == <NUM_LIT:0>:<EOL><INDENT>win += <NUM_LIT:1>  <EOL><DEDENT>wins = rolling_window(a, win, '<STR_LIT>')<EOL>a = map(lambda x: np.polyfit(np.arange(win), x, <NUM_LIT:1>)[<NUM_LIT:0>], wins)<EOL>return np.array(list(a))<EOL>", "docstring": "Returns rolling - window gradient of a.\n\nFunction to efficiently calculate the rolling gradient of a numpy\narray using 'stride_tricks' to split up a 1D array into an ndarray of\nsub - sections of the original array, of dimensions [len(a) - win, win].\n\nParameters\n----------\na : array_like\n    The 1D array to calculate the rolling gradient of.\nwin : int\n    The width of the rolling window.\n\nReturns\n-------\narray_like\n    Gradient of a, assuming as constant integer x - scale.", "id": "f2428:m16"}
{"signature": "def get_date(datetime, time_format=None):", "body": "if time_format is None:<EOL><INDENT>t = du.parser.parse(datetime)<EOL><DEDENT>else:<EOL><INDENT>t = dt.datetime.strftime(datetime, time_format)<EOL><DEDENT>return t<EOL>", "docstring": "Return a datetime oject from a string, with optional time format.\n\nParameters\n----------\ndatetime : str\n    Date-time as string in any sensible format.\ntime_format : datetime str (optional)\n    String describing the datetime format. If missing uses\n    dateutil.parser to guess time format.", "id": "f2428:m1"}
{"signature": "def get_total_n_points(d):", "body": "n = <NUM_LIT:0><EOL>for di in d.values():<EOL><INDENT>n += len(di)<EOL><DEDENT>return n<EOL>", "docstring": "Returns the total number of data points in values of dict.\n\nParamters\n---------\nd : dict", "id": "f2428:m2"}
{"signature": "def gauss_weighted_stats(x, yarray, x_new, fwhm):", "body": "sigma = fwhm / (<NUM_LIT:2> * np.sqrt(<NUM_LIT:2> * np.log(<NUM_LIT:2>)))<EOL>mask = np.zeros((x.size, yarray.shape[<NUM_LIT:1>], x_new.size))<EOL>for i, xni in enumerate(x_new):<EOL><INDENT>mask[:, :, i] = gauss(x[:, np.newaxis], <NUM_LIT:1>, xni, sigma)<EOL><DEDENT>nmask = mask / mask.sum(<NUM_LIT:0>)  <EOL>av = (nmask * yarray[:, :, np.newaxis]).sum(<NUM_LIT:0>)  <EOL>diff = np.power(av - yarray[:, :, np.newaxis], <NUM_LIT:2>)<EOL>std = np.sqrt((diff * nmask).sum(<NUM_LIT:0>))<EOL>se = std / np.sqrt(mask.sum(<NUM_LIT:0>))<EOL>return av, std, se<EOL>", "docstring": "Calculate gaussian weigted moving mean, SD and SE.\n\nParameters\n----------\nx : array-like\n    The independent variable\nyarray : (n,m) array\n    Where n = x.size, and m is the number of\n    dependent variables to smooth.\nx_new : array-like\n    The new x-scale to interpolate the data\nfwhm : int\n    FWHM of the gaussian kernel.\n\nReturns\n-------\n(mean, std, se) : tuple", "id": "f2431:m5"}
{"signature": "def gauss(x, *p):", "body": "A, mu, sigma = p<EOL>return A * np.exp(-<NUM_LIT:0.5> * (-mu + x)**<NUM_LIT:2> / sigma**<NUM_LIT:2>)<EOL>", "docstring": "Gaussian function.\n\n    Parameters\n    ----------\n    x : array_like\n        Independent variable.\n    *p : parameters unpacked to A, mu, sigma\n        A = amplitude, mu = centre, sigma = width\n\n    Return\n    ------\n    array_like\n        gaussian descriped by *p.", "id": "f2431:m6"}
{"signature": "def calc_window_mean_std(s, min_points, ind=None):", "body": "max_points = np.sum(~np.isnan(s))<EOL>n_points = max_points - min_points<EOL>mean = np.full((n_points, s.size), np.nan)<EOL>std = np.full((n_points, s.size), np.nan)<EOL>if ind is None:<EOL><INDENT>ind = ~np.isnan(s)<EOL><DEDENT>else:<EOL><INDENT>ind = ind & ~np.isnan(s)<EOL><DEDENT>s = s[ind]<EOL>for i, w in enumerate(range(min_points, s.size)):<EOL><INDENT>r = rolling_window(s, w, pad=np.nan)<EOL>mean[i, ind] = r.sum(<NUM_LIT:1>) / w<EOL>std[i, ind] = (((r - mean[i, ind][:, np.newaxis])**<NUM_LIT:2>).sum(<NUM_LIT:1>) / (w - <NUM_LIT:1>))**<NUM_LIT:0.5><EOL><DEDENT>return mean, std<EOL>", "docstring": "Apply fn to all contiguous regions in s that have at least min_points.", "id": "f2432:m1"}
{"signature": "def threshold(values, threshold):", "body": "values = nominal_values(values)<EOL>return (values < threshold, values >= threshold)<EOL>", "docstring": "Return boolean arrays where a >= and < threshold.\n\nParameters\n----------\nvalues : array-like\n    Array of real values.\nthreshold : float\n    Threshold value\n\nReturns\n-------\n(below, above) : tuple or boolean arrays", "id": "f2433:m0"}
{"signature": "def defrag(filt, threshold=<NUM_LIT:3>, mode='<STR_LIT>'):", "body": "if bool_2_indices(filt) is None:<EOL><INDENT>return filt<EOL><DEDENT>if mode == '<STR_LIT>':<EOL><INDENT>inds = bool_2_indices(~filt) + <NUM_LIT:1><EOL>rep = True<EOL><DEDENT>if mode == '<STR_LIT>':<EOL><INDENT>inds = bool_2_indices(filt) + <NUM_LIT:1><EOL>rep = False<EOL><DEDENT>rem = (np.diff(inds) <= threshold)[:, <NUM_LIT:0>]<EOL>cfilt = filt.copy()<EOL>if any(rem):<EOL><INDENT>for lo, hi in inds[rem]:<EOL><INDENT>cfilt[lo:hi] = rep<EOL><DEDENT><DEDENT>return cfilt<EOL>", "docstring": "'Defragment' a filter.\n\nParameters\n----------\nfilt : boolean array\n    A filter\nthreshold : int\n    Consecutive values equal to or below this threshold\n    length are considered fragments, and will be removed.\nmode : str\n    Wheter to change False fragments to True ('include')\n    or True fragments to False ('exclude')\n\nReturns\n-------\ndefragmented filter : boolean array", "id": "f2433:m2"}
{"signature": "def fuzzmatch(self, fuzzkey, multi=False):", "body": "keys, ratios = np.array([(f, seqm(None, fuzzkey, f).ratio()) for f in self.components.keys()]).T<EOL>mratio = max(ratios)<EOL>if multi:<EOL><INDENT>return keys[ratios == mratio]<EOL><DEDENT>else:<EOL><INDENT>if sum(ratios == mratio) == <NUM_LIT:1>:<EOL><INDENT>return keys[ratios == mratio][<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(fuzzkey) + '<STR_LIT:U+002CU+0020>'.join(keys[ratios == mratio]) + \"<STR_LIT>\")<EOL><DEDENT><DEDENT>", "docstring": "Identify a filter by fuzzy string matching.\n\nPartial ('fuzzy') matching performed by `fuzzywuzzy.fuzzy.ratio`\n\nParameters\n----------\nfuzzkey : str\n    A string that partially matches one filter name more than the others.\n\nReturns\n-------\nThe name of the most closely matched filter. : str", "id": "f2434:c0:m9"}
{"signature": "def off(self, analyte=None, filt=None):", "body": "if isinstance(analyte, str):<EOL><INDENT>analyte = [analyte]<EOL><DEDENT>if isinstance(filt, (int, float)):<EOL><INDENT>filt = [filt]<EOL><DEDENT>elif isinstance(filt, str):<EOL><INDENT>filt = self.fuzzmatch(filt, multi=True)<EOL><DEDENT>if analyte is None:<EOL><INDENT>analyte = self.analytes<EOL><DEDENT>if filt is None:<EOL><INDENT>filt = list(self.index.values())<EOL><DEDENT>for a in analyte:<EOL><INDENT>for f in filt:<EOL><INDENT>if isinstance(f, int):<EOL><INDENT>f = self.index[f]<EOL><DEDENT>try:<EOL><INDENT>self.switches[a][f] = False<EOL><DEDENT>except KeyError:<EOL><INDENT>f = self.fuzzmatch(f, multi=False)<EOL>self.switches[a][f] = False<EOL><DEDENT><DEDENT><DEDENT>return<EOL>", "docstring": "Turn off specified filter(s) for specified analyte(s).\n\nParameters\n----------\nanalyte : optional, str or array_like\n    Name or list of names of analytes.\n    Defaults to all analytes.\nfilt : optional. int, list of int or str\n    Number(s) or partial string that corresponds to filter name(s).\n\nReturns\n-------\nNone", "id": "f2434:c0:m7"}
{"signature": "def clean(self):", "body": "for f in sorted(self.components.keys()):<EOL><INDENT>unused = not any(self.switches[a][f] for a in self.analytes)<EOL>if unused:<EOL><INDENT>self.remove(f)<EOL><DEDENT><DEDENT>", "docstring": "Remove unused filters.", "id": "f2434:c0:m5"}
{"signature": "def grab_filt(self, filt, analyte=None):", "body": "if isinstance(filt, str):<EOL><INDENT>if filt in self.components:<EOL><INDENT>if analyte is None:<EOL><INDENT>return self.components[filt]<EOL><DEDENT>else:<EOL><INDENT>if self.switches[analyte][filt]:<EOL><INDENT>return self.components[filt]<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>ind = self.make_fromkey(filt)<EOL><DEDENT>except KeyError:<EOL><INDENT>print((\"<STR_LIT>\"<EOL>\"<STR_LIT>\"))<EOL><DEDENT><DEDENT><DEDENT>elif isinstance(filt, dict):<EOL><INDENT>try:<EOL><INDENT>ind = self.make_fromkey(filt[analyte])<EOL><DEDENT>except ValueError:<EOL><INDENT>print((\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"))<EOL><DEDENT><DEDENT>elif filt:<EOL><INDENT>ind = self.make(analyte)<EOL><DEDENT>else:<EOL><INDENT>ind = ~np.zeros(self.size, dtype=bool)<EOL><DEDENT>return ind<EOL>", "docstring": "Flexible access to specific filter using any key format.\n\nParameters\n----------\nf : str, dict or bool\n    either logical filter expression, dict of expressions,\n    or a boolean\nanalyte : str\n    name of analyte the filter is for.\n\nReturns\n-------\narray_like\n    boolean filter", "id": "f2434:c0:m12"}
{"signature": "def on(self, analyte=None, filt=None):", "body": "if isinstance(analyte, str):<EOL><INDENT>analyte = [analyte]<EOL><DEDENT>if isinstance(filt, (int, float)):<EOL><INDENT>filt = [filt]<EOL><DEDENT>elif isinstance(filt, str):<EOL><INDENT>filt = self.fuzzmatch(filt, multi=True)<EOL><DEDENT>if analyte is None:<EOL><INDENT>analyte = self.analytes<EOL><DEDENT>if filt is None:<EOL><INDENT>filt = list(self.index.values())<EOL><DEDENT>for a in analyte:<EOL><INDENT>for f in filt:<EOL><INDENT>if isinstance(f, (int, float)):<EOL><INDENT>f = self.index[int(f)]<EOL><DEDENT>try:<EOL><INDENT>self.switches[a][f] = True<EOL><DEDENT>except KeyError:<EOL><INDENT>f = self.fuzzmatch(f, multi=False)<EOL>self.switches[a][f] = True<EOL><DEDENT><DEDENT><DEDENT>return<EOL>", "docstring": "Turn on specified filter(s) for specified analyte(s).\n\nParameters\n----------\nanalyte : optional, str or array_like\n    Name or list of names of analytes.\n    Defaults to all analytes.\nfilt : optional. int, str or array_like\n    Name/number or iterable names/numbers of filters.\n\nReturns\n-------\nNone", "id": "f2434:c0:m6"}
{"signature": "def cluster_meanshift(data, bandwidth=None, bin_seeding=False, **kwargs):", "body": "if bandwidth is None:<EOL><INDENT>bandwidth = cl.estimate_bandwidth(data)<EOL><DEDENT>ms = cl.MeanShift(bandwidth=bandwidth, bin_seeding=bin_seeding, **kwargs)<EOL>ms.fit(data)<EOL>labels = ms.labels_<EOL>return labels, [np.nan]<EOL>", "docstring": "Identify clusters using Meanshift algorithm.\n\nParameters\n----------\ndata : array_like\n    array of size [n_samples, n_features].\nbandwidth : float or None\n    If None, bandwidth is estimated automatically using\n    sklean.cluster.estimate_bandwidth\nbin_seeding : bool\n    Setting this option to True will speed up the algorithm.\n    See sklearn documentation for full description.\n\nReturns\n-------\ndict\n    boolean array for each identified cluster.", "id": "f2435:m0"}
{"signature": "def cluster_DBSCAN(data, eps=None, min_samples=None,<EOL>n_clusters=None, maxiter=<NUM_LIT:200>, **kwargs):", "body": "if n_clusters is None:<EOL><INDENT>if eps is None:<EOL><INDENT>eps = <NUM_LIT><EOL><DEDENT>db = cl.DBSCAN(eps=eps, min_samples=min_samples, **kwargs).fit(data)<EOL><DEDENT>else:<EOL><INDENT>clusters = <NUM_LIT:0><EOL>eps_temp = <NUM_LIT:1> / <NUM_LIT><EOL>niter = <NUM_LIT:0><EOL>while clusters < n_clusters:<EOL><INDENT>clusters_last = clusters<EOL>eps_temp *= <NUM_LIT><EOL>db = cl.DBSCAN(eps=eps_temp, min_samples=min_samples, **kwargs).fit(data)<EOL>clusters = (len(set(db.labels_)) -<EOL>(<NUM_LIT:1> if -<NUM_LIT:1> in db.labels_ else <NUM_LIT:0>))<EOL>if clusters < clusters_last:<EOL><INDENT>eps_temp *= <NUM_LIT:1> / <NUM_LIT><EOL>db = cl.DBSCAN(eps=eps_temp, min_samples=min_samples, **kwargs).fit(data)<EOL>clusters = (len(set(db.labels_)) -<EOL>(<NUM_LIT:1> if -<NUM_LIT:1> in db.labels_ else <NUM_LIT:0>))<EOL>warnings.warn(('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>').format(n_clusters, clusters, eps_temp))<EOL>break<EOL><DEDENT>niter += <NUM_LIT:1><EOL>if niter == maxiter:<EOL><INDENT>warnings.warn(('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>').format(maxiter, n_clusters))<EOL>break<EOL><DEDENT><DEDENT><DEDENT>labels = db.labels_<EOL>core_samples_mask = np.zeros_like(labels)<EOL>core_samples_mask[db.core_sample_indices_] = True<EOL>return labels, core_samples_mask<EOL>", "docstring": "Identify clusters using DBSCAN algorithm.\n\nParameters\n----------\ndata : array_like\n    array of size [n_samples, n_features].\neps : float\n    The minimum 'distance' points must be apart for them to be in the\n    same cluster. Defaults to 0.3. Note: If the data are normalised\n    (they should be for DBSCAN) this is in terms of total sample\n    variance.  Normalised data have a mean of 0 and a variance of 1.\nmin_samples : int\n    The minimum number of samples within distance `eps` required\n    to be considered as an independent cluster.\nn_clusters : int\n    The number of clusters expected. If specified, `eps` will be\n    incrementally reduced until the expected number of clusters is\n    found.\nmaxiter : int\n    The maximum number of iterations DBSCAN will run.\n\nReturns\n-------\ndict\n    boolean array for each identified cluster and core samples.", "id": "f2435:m2"}
{"signature": "def pca_plot(pca, dt, xlabs=None, mode='<STR_LIT>', lognorm=True):", "body": "nc = pca.n_components<EOL>f = np.arange(pca.n_features_)<EOL>cs = list(itertools.combinations(range(nc), <NUM_LIT:2>))<EOL>ind = ~np.apply_along_axis(any, <NUM_LIT:1>, np.isnan(dt))<EOL>cylim = (pca.components_.min(), pca.components_.max())<EOL>yd = cylim[<NUM_LIT:1>] - cylim[<NUM_LIT:0>]<EOL>fig, axs = plt.subplots(nc, nc, figsize=[<NUM_LIT:3> * nc, nc * <NUM_LIT:3>], tight_layout=True)<EOL>for x, y in zip(*np.triu_indices(nc)):<EOL><INDENT>if x == y:<EOL><INDENT>tax = axs[x, y]<EOL>tax.bar(f, pca.components_[x], <NUM_LIT>)<EOL>tax.set_xticks([])<EOL>tax.axhline(<NUM_LIT:0>, zorder=-<NUM_LIT:1>, c=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT>))<EOL>tax.set_ylim(cylim[<NUM_LIT:0>] - <NUM_LIT> * yd,<EOL>cylim[<NUM_LIT:1>] + <NUM_LIT> * yd)<EOL>for xi, yi, lab in zip(f, pca.components_[x], xlabs):<EOL><INDENT>if yi > <NUM_LIT:0>:<EOL><INDENT>yo = yd * <NUM_LIT><EOL>va = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>yo = yd * -<NUM_LIT><EOL>va = '<STR_LIT>'<EOL><DEDENT>tax.text(xi, yi + yo, lab, ha='<STR_LIT>', va=va, rotation=<NUM_LIT>, fontsize=<NUM_LIT:8>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>xv = dt[ind, x]<EOL>yv = dt[ind, y]<EOL>if mode == '<STR_LIT>':<EOL><INDENT>axs[x, y].scatter(xv, yv, alpha=<NUM_LIT>)<EOL>axs[y, x].scatter(yv, xv, alpha=<NUM_LIT>)<EOL><DEDENT>if mode == '<STR_LIT>':<EOL><INDENT>if lognorm:<EOL><INDENT>norm = mpl.colors.LogNorm()<EOL><DEDENT>else:<EOL><INDENT>norm = None<EOL><DEDENT>axs[x, y].hist2d(xv, yv, <NUM_LIT:50>, cmap=plt.cm.Blues, norm=norm)<EOL>axs[y, x].hist2d(yv, xv, <NUM_LIT:50>, cmap=plt.cm.Blues, norm=norm)<EOL><DEDENT><DEDENT>if x == <NUM_LIT:0>:<EOL><INDENT>axs[y, x].set_ylabel('<STR_LIT>'.format(y + <NUM_LIT:1>))<EOL><DEDENT>if y == nc - <NUM_LIT:1>:<EOL><INDENT>axs[y, x].set_xlabel('<STR_LIT>'.format(x + <NUM_LIT:1>))<EOL><DEDENT><DEDENT>return fig, axs, xv, yv<EOL>", "docstring": "Plot a fitted PCA, and all components.", "id": "f2437:m1"}
{"signature": "def read_data(data_file, dataformat, name_mode):", "body": "with open(data_file) as f:<EOL><INDENT>lines = f.readlines()<EOL><DEDENT>if '<STR_LIT>' in dataformat.keys():<EOL><INDENT>meta = Bunch()<EOL>for k, v in dataformat['<STR_LIT>'].items():<EOL><INDENT>try:<EOL><INDENT>out = re.search(v[-<NUM_LIT:1>], lines[int(k)]).groups()<EOL><DEDENT>except:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(v[-<NUM_LIT:1>], lines[int(k)]))<EOL><DEDENT>for i in np.arange(len(v[<NUM_LIT:0>])):<EOL><INDENT>meta[v[<NUM_LIT:0>][i]] = out[i]<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>meta = {}<EOL><DEDENT>if name_mode == '<STR_LIT>':<EOL><INDENT>sample = os.path.basename(data_file).split('<STR_LIT:.>')[<NUM_LIT:0>]<EOL><DEDENT>elif name_mode == '<STR_LIT>':<EOL><INDENT>sample = meta['<STR_LIT:name>']<EOL><DEDENT>else:<EOL><INDENT>sample = name_mode<EOL><DEDENT>columns = np.array(lines[dataformat['<STR_LIT>']['<STR_LIT>']].strip().split(<EOL>dataformat['<STR_LIT>']['<STR_LIT>']))<EOL>if '<STR_LIT>' in dataformat['<STR_LIT>'].keys():<EOL><INDENT>pr = re.compile(dataformat['<STR_LIT>']['<STR_LIT>'])<EOL>analytes = [pr.match(c).groups()[<NUM_LIT:0>] for c in columns if pr.match(c)]<EOL><DEDENT>if '<STR_LIT>' in dataformat.keys():<EOL><INDENT>with open(data_file) as f:<EOL><INDENT>fbuffer = f.read()<EOL><DEDENT>for k, v in dataformat['<STR_LIT>'].items():<EOL><INDENT>fbuffer = re.sub(k, v, fbuffer)<EOL><DEDENT>read_data = np.genfromtxt(BytesIO(fbuffer.encode()),<EOL>**dataformat['<STR_LIT>']).T<EOL><DEDENT>else:<EOL><INDENT>read_data = np.genfromtxt(data_file,<EOL>**dataformat['<STR_LIT>']).T<EOL><DEDENT>dind = np.zeros(read_data.shape[<NUM_LIT:0>], dtype=bool)<EOL>for a in analytes:<EOL><INDENT>dind[columns == a] = True<EOL><DEDENT>data = Bunch()<EOL>data['<STR_LIT>'] = read_data[dataformat['<STR_LIT>']['<STR_LIT>']]<EOL>if '<STR_LIT>' in dataformat['<STR_LIT>']:<EOL><INDENT>if isinstance(dataformat['<STR_LIT>']['<STR_LIT>'], (float, int)):<EOL><INDENT>time_mult = dataformat['<STR_LIT>']['<STR_LIT>']<EOL><DEDENT>elif isinstance(dataformat['<STR_LIT>']['<STR_LIT>'], str):<EOL><INDENT>unit_multipliers = {'<STR_LIT>': <NUM_LIT:1>/<NUM_LIT:1000>,<EOL>'<STR_LIT>': <NUM_LIT>/<NUM_LIT:1>,<EOL>'<STR_LIT:s>': <NUM_LIT:1>}<EOL>try:<EOL><INDENT>time_mult = unit_multipliers[dataformat['<STR_LIT>']['<STR_LIT>']]<EOL><DEDENT>except:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>data['<STR_LIT>'] *= time_mult<EOL><DEDENT>data['<STR_LIT>'] = Bunch(zip(analytes, read_data[dind]))<EOL>data['<STR_LIT>'] = np.nansum(read_data[dind], <NUM_LIT:0>)<EOL>return sample, analytes, data, meta<EOL>", "docstring": "Load data_file described by a dataformat dict.\n\nParameters\n----------\ndata_file : str\n    Path to data file, including extension.\ndataformat : dict\n    A dataformat dict, see example below.\nname_mode : str\n    How to identyfy sample names. If 'file_names' uses the\n    input name of the file, stripped of the extension. If\n    'metadata_names' uses the 'name' attribute of the 'meta'\n    sub-dictionary in dataformat. If any other str, uses this\n    str as the sample name.\n\nExample\n-------\n>>>\n{'genfromtext_args': {'delimiter': ',',\n                      'skip_header': 4},  # passed directly to np.genfromtxt\n 'column_id': {'name_row': 3,  # which row contains the column names\n               'delimiter': ',',  # delimeter between column names\n               'timecolumn': 0,  # which column contains the 'time' variable\n               'pattern': '([A-z]{1,2}[0-9]{1,3})'},  # a regex pattern which captures the column names\n 'meta_regex': {  # a dict of (line_no: ([descriptors], [regexs])) pairs\n                0: (['path'], '(.*)'),\n                2: (['date', 'method'],  # MUST include date\n                 '([A-Z][a-z]+ [0-9]+ [0-9]{4}[ ]+[0-9:]+ [amp]+).* ([A-z0-9]+\\.m)')\n               }\n}\n\nReturns\n-------\nsample, analytes, data, meta : tuple", "id": "f2439:m0"}
{"signature": "def autorange(t, sig, gwin=<NUM_LIT:7>, swin=None, win=<NUM_LIT:30>,<EOL>on_mult=(<NUM_LIT>, <NUM_LIT:1.>), off_mult=(<NUM_LIT:1.>, <NUM_LIT>),<EOL>nbin=<NUM_LIT:10>, transform='<STR_LIT>', thresh=None):", "body": "failed = []<EOL>if swin is not None:<EOL><INDENT>sigs = fastsmooth(sig, swin)<EOL><DEDENT>else:<EOL><INDENT>sigs = sig<EOL><DEDENT>if transform == '<STR_LIT>':<EOL><INDENT>tsigs = np.log10(sigs)<EOL><DEDENT>else:<EOL><INDENT>tsigs = sigs<EOL><DEDENT>if thresh is None:<EOL><INDENT>bins = <NUM_LIT:50><EOL>kde_x = np.linspace(tsigs.min(), tsigs.max(), bins)<EOL>kde = gaussian_kde(tsigs)<EOL>yd = kde.pdf(kde_x)<EOL>mins = findmins(kde_x, yd)  <EOL>if len(mins) > <NUM_LIT:0>:<EOL><INDENT>bkg = tsigs < (mins[<NUM_LIT:0>])  <EOL><DEDENT>else:<EOL><INDENT>bkg = np.ones(tsigs.size, dtype=bool)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>bkg = tsigs < thresh<EOL><DEDENT>fbkg = bkg<EOL>fsig = ~bkg<EOL>zeros = bool_2_indices(fsig)<EOL>g = abs(fastgrad(sigs, gwin))  <EOL>if zeros is not None:<EOL><INDENT>zeros = zeros.flatten()<EOL>for z in zeros:  <EOL><INDENT>if z - win < <NUM_LIT:0>:<EOL><INDENT>lo = gwin // <NUM_LIT:2><EOL>hi = int(z + win)<EOL><DEDENT>elif z + win > (len(sig) - gwin // <NUM_LIT:2>):<EOL><INDENT>lo = int(z - win)<EOL>hi = len(sig) - gwin // <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>lo = int(z - win)<EOL>hi = int(z + win)<EOL><DEDENT>xs = t[lo:hi]<EOL>ys = g[lo:hi]<EOL>mid = (hi + lo) // <NUM_LIT:2><EOL>tp = sigs[mid + <NUM_LIT:3>] > sigs[mid - <NUM_LIT:3>]  <EOL>c = t[z]  <EOL>width = (t[<NUM_LIT:1>] - t[<NUM_LIT:0>]) * <NUM_LIT:2><EOL>try:<EOL><INDENT>pg, _ = curve_fit(gauss, xs, ys,<EOL>p0=(np.nanmax(ys),<EOL>c,<EOL>width),<EOL>sigma=(xs - c)**<NUM_LIT:2> + <NUM_LIT>)<EOL>fwhm = abs(<NUM_LIT:2> * pg[-<NUM_LIT:1>] * np.sqrt(<NUM_LIT:2> * np.log(<NUM_LIT:2>)))<EOL>if tp:<EOL><INDENT>lim = np.array([-fwhm, fwhm]) * on_mult + pg[<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>lim = np.array([-fwhm, fwhm]) * off_mult + pg[<NUM_LIT:1>]<EOL><DEDENT>fbkg[(t > lim[<NUM_LIT:0>]) & (t < lim[<NUM_LIT:1>])] = False<EOL>fsig[(t > lim[<NUM_LIT:0>]) & (t < lim[<NUM_LIT:1>])] = False<EOL><DEDENT>except RuntimeError:<EOL><INDENT>failed.append([c, tp])<EOL>pass<EOL><DEDENT><DEDENT><DEDENT>ftrn = ~fbkg & ~fsig<EOL>if len(failed) > <NUM_LIT:0>:<EOL><INDENT>trns = t[bool_2_indices(ftrn)]<EOL>tr_mean = (trns[:, <NUM_LIT:1>] - trns[:, <NUM_LIT:0>]).mean() / <NUM_LIT:2><EOL>for f, tp in failed:<EOL><INDENT>if tp:<EOL><INDENT>ind = (t >= f - tr_mean *<EOL>on_mult[<NUM_LIT:0>]) & (t <= f + tr_mean * on_mult[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>ind = (t >= f - tr_mean *<EOL>off_mult[<NUM_LIT:0>]) & (t <= f + tr_mean * off_mult[<NUM_LIT:0>])<EOL><DEDENT>fsig[ind] = False<EOL>fbkg[ind] = False<EOL>ftrn[ind] = False<EOL><DEDENT><DEDENT>return fbkg, fsig, ftrn, [f[<NUM_LIT:0>] for f in failed]<EOL>", "docstring": "Automatically separates signal and background in an on/off data stream.\n\n**Step 1: Thresholding.**\nThe background signal is determined using a gaussian kernel density\nestimator (kde) of all the data. Under normal circumstances, this\nkde should find two distinct data distributions, corresponding to\n'signal' and 'background'. The minima between these two distributions\nis taken as a rough threshold to identify signal and background\nregions. Any point where the trace crosses this thrshold is identified\nas a 'transition'.\n\n**Step 2: Transition Removal.**\nThe width of the transition regions between signal and background are\nthen determined, and the transitions are excluded from analysis. The\nwidth of the transitions is determined by fitting a gaussian to the\nsmoothed first derivative of the analyte trace, and determining its\nwidth at a point where the gaussian intensity is at at `conf` time the\ngaussian maximum. These gaussians are fit to subsets of the data\ncentered around the transitions regions determined in Step 1, +/- `win`\ndata points. The peak is further isolated by finding the minima and\nmaxima of a second derivative within this window, and the gaussian is\nfit to the isolated peak.\n\nParameters\n----------\nt : array-like\n    Independent variable (usually time).\nsig : array-like\n    Dependent signal, with distinctive 'on' and 'off' regions.\ngwin : int\n    The window used for calculating first derivative.\n    Defaults to 7.\nswin : int\n    The window used for signal smoothing. If None, ``gwin // 2``.\nwin : int\n    The width (c +/- win) of the transition data subsets.\n    Defaults to 20.\non_mult and off_mult : tuple, len=2\n    Control the width of the excluded transition regions, which is defined\n    relative to the peak full-width-half-maximum (FWHM) of the transition\n    gradient. The region n * FHWM below the transition, and m * FWHM above\n    the tranision will be excluded, where (n, m) are specified in `on_mult`\n    and `off_mult`.\n    `on_mult` and `off_mult` apply to the off-on and on-off transitions,\n    respectively.\n    Defaults to (1.5, 1) and (1, 1.5).\ntransform : str\n    How to transform the data. Default is 'log'.\n\nReturns\n-------\nfbkg, fsig, ftrn, failed : tuple\n    where fbkg, fsig and ftrn are boolean arrays the same length as sig,\n    that are True where sig is background, signal and transition, respecively.\n    failed contains a list of transition positions where gaussian fitting\n    has failed.", "id": "f2440:m0"}
{"signature": "def autorange_components(t, sig, transform='<STR_LIT>', gwin=<NUM_LIT:7>, swin=None,<EOL>win=<NUM_LIT:30>, on_mult=(<NUM_LIT>, <NUM_LIT:1.>), off_mult=(<NUM_LIT:1.>, <NUM_LIT>),<EOL>thresh=None):", "body": "failed = []<EOL>if swin is not None:<EOL><INDENT>sigs = fastsmooth(sig, swin)<EOL><DEDENT>else:<EOL><INDENT>sigs = sig<EOL><DEDENT>if transform == '<STR_LIT>':<EOL><INDENT>tsigs = np.log10(sigs)<EOL>tsig = np.log10(sig)<EOL><DEDENT>else:<EOL><INDENT>tsigs = sigs<EOL>tsig = sig<EOL><DEDENT>if thresh is None:<EOL><INDENT>bins = <NUM_LIT:50><EOL>kde_x = np.linspace(tsigs.min(), tsigs.max(), bins)<EOL>kde = gaussian_kde(tsigs)<EOL>yd = kde.pdf(kde_x)<EOL>mins = findmins(kde_x, yd)  <EOL>if len(mins) > <NUM_LIT:0>:<EOL><INDENT>bkg = tsigs < (mins[<NUM_LIT:0>])  <EOL>thresh = mins[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>bkg = np.ones(tsigs.size, dtype=bool)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>bkg = tsigs < thresh<EOL><DEDENT>fbkg = bkg<EOL>fsig = ~bkg<EOL>zeros = bool_2_indices(fsig)<EOL>g = abs(fastgrad(sigs, gwin))  <EOL>if zeros is not None:<EOL><INDENT>zeros = zeros.flatten()<EOL>trans = dict(zeros=zeros.flatten(),<EOL>lohi=[],<EOL>pgs=[],<EOL>excl=[],<EOL>tps=[],<EOL>failed=[],<EOL>xs=[],<EOL>ys=[])<EOL>for z in zeros:  <EOL><INDENT>if z - win < <NUM_LIT:0>:<EOL><INDENT>lo = gwin // <NUM_LIT:2><EOL>hi = int(z + win)<EOL><DEDENT>elif z + win > (len(sig) - gwin // <NUM_LIT:2>):<EOL><INDENT>lo = int(z - win)<EOL>hi = len(sig) - gwin // <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>lo = int(z - win)<EOL>hi = int(z + win)<EOL><DEDENT>xs = t[lo:hi]<EOL>ys = g[lo:hi]<EOL>trans['<STR_LIT>'].append(xs)<EOL>trans['<STR_LIT>'].append(ys)<EOL>trans['<STR_LIT>'].append([lo, hi])<EOL>mid = (hi + lo) // <NUM_LIT:2><EOL>tp = sigs[mid + <NUM_LIT:3>] > sigs[mid - <NUM_LIT:3>]  <EOL>trans['<STR_LIT>'].append(tp)<EOL>c = t[z]  <EOL>width = (t[<NUM_LIT:1>] - t[<NUM_LIT:0>]) * <NUM_LIT:2>  <EOL>try:<EOL><INDENT>pg, _ = curve_fit(gauss, xs, ys,<EOL>p0=(np.nanmax(ys),<EOL>c,<EOL>width),<EOL>sigma=(xs - c)**<NUM_LIT:2> + <NUM_LIT>)<EOL>trans['<STR_LIT>'].append(pg)<EOL>fwhm = abs(<NUM_LIT:2> * pg[-<NUM_LIT:1>] * np.sqrt(<NUM_LIT:2> * np.log(<NUM_LIT:2>)))<EOL>if tp:<EOL><INDENT>lim = np.array([-fwhm, fwhm]) * on_mult + pg[<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>lim = np.array([-fwhm, fwhm]) * off_mult + pg[<NUM_LIT:1>]<EOL><DEDENT>trans['<STR_LIT>'].append(lim)<EOL>fbkg[(t > lim[<NUM_LIT:0>]) & (t < lim[<NUM_LIT:1>])] = False<EOL>fsig[(t > lim[<NUM_LIT:0>]) & (t < lim[<NUM_LIT:1>])] = False<EOL>failed.append(False)<EOL><DEDENT>except RuntimeError:<EOL><INDENT>failed.append(True)<EOL>trans['<STR_LIT>'].append([np.nan, np.nan])<EOL>trans['<STR_LIT>'].append([np.nan, np.nan, np.nan])<EOL>trans['<STR_LIT>'].append([np.nan, np.nan])<EOL>trans['<STR_LIT>'].append(tp)<EOL>pass<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>zeros = []<EOL><DEDENT>return t, sig, sigs, tsig, tsigs, kde_x, yd, g, trans, thresh<EOL>", "docstring": "Returns the components underlying the autorange algorithm.\n\nReturns\n-------\nt : array-like\n    Time axis (independent variable)\nsig : array-like\n    Raw signal (dependent variable)\nsigs : array-like\n    Smoothed signal (swin)\ntsig : array-like\n    Transformed raw signal (transform)\ntsigs : array-like\n    Transformed smoothed signal (transform, swin)\nkde_x : array-like\n    kernel density estimate of smoothed signal.\nyd : array-like\n    bins of kernel density estimator.\ng : array-like\n    gradient of smoothed signal (swin, gwin)\ntrans : dict\n    per-transition data.\nthresh : float\n    threshold identified from kernel density plot", "id": "f2440:m1"}
{"signature": "@_log<EOL><INDENT>def filter_gradient_threshold(self, analyte, win, threshold, recalc=True):<DEDENT>", "body": "params = locals()<EOL>del(params['<STR_LIT>'])<EOL>if recalc or not self.grads_calced:<EOL><INDENT>self.grads = calc_grads(self.Time, self.focus,<EOL>[analyte], win)<EOL>self.grads_calced = True<EOL><DEDENT>below, above = filters.threshold(abs(self.grads[analyte]), threshold)<EOL>setn = self.filt.maxset + <NUM_LIT:1><EOL>self.filt.add(analyte + '<STR_LIT>',<EOL>below,<EOL>'<STR_LIT>'.format(threshold) + analyte,<EOL>params, setn=setn)<EOL>self.filt.add(analyte + '<STR_LIT>',<EOL>above,<EOL>'<STR_LIT>'.format(threshold) + analyte,<EOL>params, setn=setn)<EOL>", "docstring": "Apply gradient threshold filter.\n\nGenerates threshold filters for the given analytes above and below\nthe specified threshold.\n\nTwo filters are created with prefixes '_above' and '_below'.\n    '_above' keeps all the data above the threshold.\n    '_below' keeps all the data below the threshold.\n\ni.e. to select data below the threshold value, you should turn the\n'_above' filter off.\n\nParameters\n----------\nanalyte : str\n    Description of `analyte`.\nthreshold : float\n    Description of `threshold`.\nwin : int\n    Window used to calculate gradients (n points)\nrecalc : bool\n    Whether or not to re-calculate the gradients.\n\nReturns\n-------\nNone", "id": "f2443:c0:m13"}
{"signature": "def mkrngs(self):", "body": "bbool = bool_2_indices(self.bkg)<EOL>if bbool is not None:<EOL><INDENT>self.bkgrng = self.Time[bbool]<EOL><DEDENT>else:<EOL><INDENT>self.bkgrng = [[np.nan, np.nan]]<EOL><DEDENT>sbool = bool_2_indices(self.sig)<EOL>if sbool is not None:<EOL><INDENT>self.sigrng = self.Time[sbool]<EOL><DEDENT>else:<EOL><INDENT>self.sigrng = [[np.nan, np.nan]]<EOL><DEDENT>tbool = bool_2_indices(self.trn)<EOL>if tbool is not None:<EOL><INDENT>self.trnrng = self.Time[tbool]<EOL><DEDENT>else:<EOL><INDENT>self.trnrng = [[np.nan, np.nan]]<EOL><DEDENT>self.ns = np.zeros(self.Time.size)<EOL>n = <NUM_LIT:1><EOL>for i in range(len(self.sig) - <NUM_LIT:1>):<EOL><INDENT>if self.sig[i]:<EOL><INDENT>self.ns[i] = n<EOL><DEDENT>if self.sig[i] and ~self.sig[i + <NUM_LIT:1>]:<EOL><INDENT>n += <NUM_LIT:1><EOL><DEDENT><DEDENT>self.n = int(max(self.ns))  <EOL>return<EOL>", "docstring": "Transform boolean arrays into list of limit pairs.\n\nGets Time limits of signal/background boolean arrays and stores them as\nsigrng and bkgrng arrays. These arrays can be saved by 'save_ranges' in\nthe analyse object.", "id": "f2443:c0:m5"}
{"signature": "def get_params(self):", "body": "outputs = ['<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>']<EOL>out = {}<EOL>for o in outputs:<EOL><INDENT>out[o] = getattr(self, o)<EOL><DEDENT>out['<STR_LIT>'] = self.filt.params<EOL>out['<STR_LIT>'] = self.filt.sequence<EOL>out['<STR_LIT>'] = self.filt.make_keydict()<EOL>return out<EOL>", "docstring": "Returns paramters used to process data.\n\nReturns\n-------\ndict\n    dict of analysis parameters", "id": "f2443:c0:m29"}
{"signature": "@_log<EOL><INDENT>def filter_trim(self, start=<NUM_LIT:1>, end=<NUM_LIT:1>, filt=True):<DEDENT>", "body": "params = locals()<EOL>del(params['<STR_LIT>'])<EOL>f = self.filt.grab_filt(filt)<EOL>nf = filters.trim(f, start, end)<EOL>self.filt.add('<STR_LIT>',<EOL>nf,<EOL>'<STR_LIT>'.format(start, end),<EOL>params, setn=self.filt.maxset + <NUM_LIT:1>)<EOL>", "docstring": "Remove points from the start and end of filter regions.\n\nParameters\n----------\nstart, end : int\n    The number of points to remove from the start and end of\n    the specified filter.\nfilt : valid filter string or bool\n    Which filter to trim. If True, applies to currently active\n    filters.", "id": "f2443:c0:m19"}
{"signature": "@_log<EOL><INDENT>def ablation_times(self):<DEDENT>", "body": "ats = {}<EOL>for n in np.arange(self.n) + <NUM_LIT:1>:<EOL><INDENT>t = self.Time[self.ns == n]<EOL>ats[n - <NUM_LIT:1>] = t.max() - t.min()<EOL><DEDENT>return ats<EOL>", "docstring": "Function for calculating the ablation time for each\nablation.\n\nReturns\n-------\n    dict of times for each ablation.", "id": "f2443:c0:m11"}
{"signature": "@_log<EOL><INDENT>def tplot(self, analytes=None, figsize=[<NUM_LIT:10>, <NUM_LIT:4>], scale='<STR_LIT>', filt=None,<EOL>ranges=False, stats=False, stat='<STR_LIT>', err='<STR_LIT>',<EOL>focus_stage=None, err_envelope=False, ax=None):<DEDENT>", "body": "return plot.tplot(self=self, analytes=analytes, figsize=figsize, scale=scale, filt=filt,<EOL>ranges=ranges, stats=stats, stat=stat, err=err,<EOL>focus_stage=focus_stage, err_envelope=err_envelope, ax=ax)<EOL>", "docstring": "Plot analytes as a function of Time.\n\nParameters\n----------\nanalytes : array_like\n    list of strings containing names of analytes to plot.\n    None = all analytes.\nfigsize : tuple\n    size of final figure.\nscale : str or None\n   'log' = plot data on log scale\nfilt : bool, str or dict\n    False: plot unfiltered data.\n    True: plot filtered data over unfiltered data.\n    str: apply filter key to all analytes\n    dict: apply key to each analyte in dict. Must contain all\n    analytes plotted. Can use self.filt.keydict.\nranges : bool\n    show signal/background regions.\nstats : bool\n    plot average and error of each trace, as specified by `stat` and\n    `err`.\nstat : str\n    average statistic to plot.\nerr : str\n    error statistic to plot.\n\nReturns\n-------\nfigure, axis", "id": "f2443:c0:m23"}
{"signature": "@_log<EOL><INDENT>def filter_exclude_downhole(self, threshold, filt=True):<DEDENT>", "body": "f = self.filt.grab_filt(filt)<EOL>if self.n == <NUM_LIT:1>:<EOL><INDENT>nfilt = filters.exclude_downhole(f, threshold)<EOL><DEDENT>else:<EOL><INDENT>nfilt = []<EOL>for i in range(self.n):<EOL><INDENT>nf = self.ns == i + <NUM_LIT:1><EOL>nfilt.append(filters.exclude_downhole(f & nf, threshold))<EOL><DEDENT>nfilt = np.apply_along_axis(any, <NUM_LIT:0>, nfilt)<EOL><DEDENT>self.filt.add(name='<STR_LIT>'.format(threshold),<EOL>filt=nfilt,<EOL>info='<STR_LIT>'.format(threshold),<EOL>params=(threshold, filt))<EOL>", "docstring": "Exclude all points down-hole (after) the first excluded data.\n\nParameters\n----------\nthrehold : int\n    The minimum number of contiguous excluded data points\n    that must exist before downhole exclusion occurs.\nfile : valid filter string or bool\n    Which filter to consider. If True, applies to currently active\n    filters.", "id": "f2443:c0:m20"}
{"signature": "@_log<EOL><INDENT>def filter_threshold(self, analyte, threshold):<DEDENT>", "body": "params = locals()<EOL>del(params['<STR_LIT>'])<EOL>below, above = filters.threshold(self.focus[analyte], threshold)<EOL>setn = self.filt.maxset + <NUM_LIT:1><EOL>self.filt.add(analyte + '<STR_LIT>',<EOL>below,<EOL>'<STR_LIT>'.format(threshold) + analyte,<EOL>params, setn=setn)<EOL>self.filt.add(analyte + '<STR_LIT>',<EOL>above,<EOL>'<STR_LIT>'.format(threshold) + analyte,<EOL>params, setn=setn)<EOL>", "docstring": "Apply threshold filter.\n\nGenerates threshold filters for the given analytes above and below\nthe specified threshold.\n\nTwo filters are created with prefixes '_above' and '_below'.\n    '_above' keeps all the data above the threshold.\n    '_below' keeps all the data below the threshold.\n\ni.e. to select data below the threshold value, you should turn the\n'_above' filter off.\n\nParameters\n----------\nanalyte : TYPE\n    Description of `analyte`.\nthreshold : TYPE\n    Description of `threshold`.\n\nReturns\n-------\nNone", "id": "f2443:c0:m12"}
{"signature": "@_log<EOL><INDENT>def gradient_crossplot(self, analytes=None, win=<NUM_LIT:15>, lognorm=True,<EOL>bins=<NUM_LIT>, filt=False, samples=None,<EOL>subset=None, figsize=(<NUM_LIT:12>, <NUM_LIT:12>), save=False,<EOL>colourful=True, mode='<STR_LIT>', recalc=True, **kwargs):<DEDENT>", "body": "if analytes is None:<EOL><INDENT>analytes = self.analytes<EOL><DEDENT>if self.focus_stage in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>analytes = [a for a in analytes if self.internal_standard not in a]<EOL><DEDENT>try:<EOL><INDENT>analytes = sorted(analytes, key=lambda x: float(re.findall('<STR_LIT>', x)[<NUM_LIT:0>]))<EOL><DEDENT>except IndexError:<EOL><INDENT>analytes = sorted(analytes)<EOL><DEDENT>samples = self._get_samples(subset)<EOL>self.get_gradients(analytes=analytes, win=win, filt=filt, subset=subset, recalc=recalc)<EOL>fig, axes = plot.crossplot(dat=self.gradients, keys=analytes, lognorm=lognorm,<EOL>bins=bins, figsize=figsize, colourful=colourful,<EOL>focus_stage=self.focus_stage, cmap=self.cmaps,<EOL>denominator=self.internal_standard, mode=mode)<EOL>if save:<EOL><INDENT>fig.savefig(self.report_dir + '<STR_LIT>', dpi=<NUM_LIT:200>)<EOL><DEDENT>return fig, axes<EOL>", "docstring": "Plot analyte gradients against each other.\n\nParameters\n----------\nanalytes : optional, array_like or str\n    The analyte(s) to plot. Defaults to all analytes.\nlognorm : bool\n    Whether or not to log normalise the colour scale\n    of the 2D histogram.\nbins : int\n    The number of bins in the 2D histogram.\nfilt : str, dict or bool\n    Either logical filter expression contained in a str,\n    a dict of expressions specifying the filter string to\n    use for each analyte or a boolean. Passed to `grab_filt`.\nfigsize : tuple\n    Figure size (width, height) in inches.\nsave : bool or str\n    If True, plot is saves as 'crossplot.png', if str plot is\n    saves as str.\ncolourful : bool\n    Whether or not the plot should be colourful :).\nmode : str\n    'hist2d' (default) or 'scatter'\nrecalc : bool\n    Whether to re-calculate the gradients, or use existing gradients.\n\nReturns\n-------\n(fig, axes)", "id": "f2444:c0:m46"}
{"signature": "@_log<EOL><INDENT>def ratio(self, internal_standard=None):<DEDENT>", "body": "if '<STR_LIT>' not in self.stages_complete:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>if internal_standard is not None:<EOL><INDENT>self.internal_standard = internal_standard<EOL>self.minimal_analytes.update([internal_standard])<EOL><DEDENT>with self.pbar.set(total=len(self.data), desc='<STR_LIT>') as prog:<EOL><INDENT>for s in self.data.values():<EOL><INDENT>s.ratio(internal_standard=self.internal_standard)<EOL>prog.update()<EOL><DEDENT><DEDENT>self.stages_complete.update(['<STR_LIT>'])<EOL>self.focus_stage = '<STR_LIT>'<EOL>return<EOL>", "docstring": "Calculates the ratio of all analytes to a single analyte.\n\nParameters\n----------\ninternal_standard : str\n    The name of the analyte to divide all other analytes\n    by.\n\nReturns\n-------\nNone", "id": "f2444:c0:m13"}
{"signature": "def get_focus(self, filt=False, samples=None, subset=None, nominal=False):", "body": "if samples is not None:<EOL><INDENT>subset = self.make_subset(samples)<EOL><DEDENT>samples = self._get_samples(subset)<EOL>focus = {'<STR_LIT>': []}<EOL>focus.update({a: [] for a in self.analytes})<EOL>for sa in samples:<EOL><INDENT>s = self.data[sa]<EOL>focus['<STR_LIT>'].append(s.uTime)<EOL>ind = s.filt.grab_filt(filt)<EOL>for a in self.analytes:<EOL><INDENT>tmp = s.focus[a].copy()<EOL>tmp[~ind] = np.nan<EOL>focus[a].append(tmp)<EOL><DEDENT><DEDENT>if nominal:<EOL><INDENT>self.focus.update({k: nominal_values(np.concatenate(v)) for k, v, in focus.items()})<EOL><DEDENT>else:<EOL><INDENT>self.focus.update({k: np.concatenate(v) for k, v, in focus.items()})<EOL><DEDENT>return<EOL>", "docstring": "Collect all data from all samples into a single array.\nData from standards is not collected.\n\nParameters\n----------\nfilt : str, dict or bool\n    Either logical filter expression contained in a str,\n    a dict of expressions specifying the filter string to\n    use for each analyte or a boolean. Passed to `grab_filt`.\nsamples : str or list\n    which samples to get\nsubset : str or int\n    which subset to get\n\nReturns\n-------\nNone", "id": "f2444:c0:m42"}
{"signature": "@_log<EOL><INDENT>def bkg_calc_weightedmean(self, analytes=None, weight_fwhm=None,<EOL>n_min=<NUM_LIT:20>, n_max=None, cstep=None,<EOL>bkg_filter=False, f_win=<NUM_LIT:7>, f_n_lim=<NUM_LIT:3>, focus_stage='<STR_LIT>'):<DEDENT>", "body": "if analytes is None:<EOL><INDENT>analytes = self.analytes<EOL>self.bkg = Bunch()<EOL><DEDENT>elif isinstance(analytes, str):<EOL><INDENT>analytes = [analytes]<EOL><DEDENT>if weight_fwhm is None:<EOL><INDENT>weight_fwhm = <NUM_LIT>  <EOL><DEDENT>self.get_background(n_min=n_min, n_max=n_max,<EOL>bkg_filter=bkg_filter,<EOL>f_win=f_win, f_n_lim=f_n_lim, focus_stage=focus_stage)<EOL>if '<STR_LIT>' not in self.bkg.keys():<EOL><INDENT>if cstep is None:<EOL><INDENT>cstep = weight_fwhm / <NUM_LIT:20><EOL><DEDENT>elif cstep > weight_fwhm:<EOL><INDENT>warnings.warn(\"<STR_LIT>\" +<EOL>\"<STR_LIT>\")<EOL><DEDENT>bkg_t = np.linspace(<NUM_LIT:0>,<EOL>self.max_time,<EOL>self.max_time // cstep)<EOL>self.bkg['<STR_LIT>'] = Bunch()<EOL>self.bkg['<STR_LIT>']['<STR_LIT>'] = bkg_t<EOL><DEDENT>mean, std, stderr = gauss_weighted_stats(self.bkg['<STR_LIT>'].uTime,<EOL>self.bkg['<STR_LIT>'].loc[:, analytes].values,<EOL>self.bkg['<STR_LIT>']['<STR_LIT>'],<EOL>fwhm=weight_fwhm)<EOL>for i, a in enumerate(analytes):<EOL><INDENT>self.bkg['<STR_LIT>'][a] = {'<STR_LIT>': mean[i],<EOL>'<STR_LIT>': std[i],<EOL>'<STR_LIT>': stderr[i]}<EOL><DEDENT>", "docstring": "Background calculation using a gaussian weighted mean.\n\nParameters\n----------\nanalytes : str or iterable\n    Which analyte or analytes to calculate.\nweight_fwhm : float\n    The full-width-at-half-maximum of the gaussian used\n    to calculate the weighted average.\nn_min : int\n    Background regions with fewer than n_min points\n    will not be included in the fit.\ncstep : float or None\n    The interval between calculated background points.\nfilter : bool\n    If true, apply a rolling filter to the isolated background regions\n    to exclude regions with anomalously high values. If True, two parameters\n    alter the filter's behaviour:\nf_win : int\n    The size of the rolling window\nf_n_lim : float\n    The number of standard deviations above the rolling mean\n    to set the threshold.\nfocus_stage : str\n    Which stage of analysis to apply processing to. \n    Defaults to 'despiked' if present, or 'rawdata' if not. \n    Can be one of:\n    * 'rawdata': raw data, loaded from csv file.\n    * 'despiked': despiked data.\n    * 'signal'/'background': isolated signal and background data.\n      Created by self.separate, after signal and background\n      regions have been identified by self.autorange.\n    * 'bkgsub': background subtracted data, created by \n      self.bkg_correct\n    * 'ratios': element ratio data, created by self.ratio.\n    * 'calibrated': ratio data calibrated to standards, created by self.calibrate.", "id": "f2444:c0:m8"}
{"signature": "def minimal_export(self, target_analytes=None, path=None):", "body": "if target_analytes is None:<EOL><INDENT>target_analytes = self.analytes<EOL><DEDENT>if isinstance(target_analytes, str):<EOL><INDENT>target_analytes = [target_analytes]<EOL><DEDENT>self.minimal_analytes.update(target_analytes)<EOL>zip_archive = False<EOL>if path is None:<EOL><INDENT>path = self.export_dir + '<STR_LIT>'<EOL><DEDENT>if path.endswith('<STR_LIT>'):<EOL><INDENT>path = path.replace('<STR_LIT>', '<STR_LIT>')<EOL>zip_archive = True<EOL><DEDENT>if not os.path.isdir(path):<EOL><INDENT>os.mkdir(path)<EOL><DEDENT>self._minimal_export_traces(path + '<STR_LIT>', analytes=self.minimal_analytes)<EOL>log_header = ['<STR_LIT>' %<EOL>(time.strftime('<STR_LIT>')),<EOL>'<STR_LIT>']<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>log_header.append('<STR_LIT>')<EOL>els = np.unique([re.sub('<STR_LIT>', '<STR_LIT>', a) for a in self.minimal_analytes])<EOL>srmdat = []<EOL>for e in els:<EOL><INDENT>srmdat.append(self.srmdat.loc[self.srmdat.element == e, :])<EOL><DEDENT>srmdat = pd.concat(srmdat)<EOL>with open(path + '<STR_LIT>', '<STR_LIT:w>') as f:<EOL><INDENT>f.write(srmdat.to_csv())<EOL><DEDENT><DEDENT>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>with open(path + '<STR_LIT>', '<STR_LIT:w>') as f:<EOL><INDENT>f.write(self.custom_stat_functions)<EOL><DEDENT>log_header.append('<STR_LIT>')<EOL><DEDENT>log_header.append('<STR_LIT>')<EOL>lss = [(i, l) for i, l in enumerate(self.log) if '<STR_LIT>' in l]<EOL>rep = re.compile(\"<STR_LIT>\")<EOL>for i, l in lss:<EOL><INDENT>self.log[i] = rep.sub(r'<STR_LIT>' + str(self.stats_calced) + r'<STR_LIT>', l)<EOL><DEDENT>self.save_log(path, '<STR_LIT>', header=log_header)<EOL>if zip_archive:<EOL><INDENT>utils.zipdir(directory=path, delete=True)<EOL><DEDENT>return<EOL>", "docstring": "Exports a analysis parameters, standard info and a minimal dataset,\nwhich can be imported by another user.\n\nParameters\n----------\ntarget_analytes : str or iterable\n    Which analytes to include in the export. If specified, the export\n    will contain these analytes, and all other analytes used during\n    data processing (e.g. during filtering). If not specified, \n    all analytes are exported.\npath : str\n    Where to save the minimal export. \n    If it ends with .zip, a zip file is created.\n    If it's a folder, all data are exported to a folder.", "id": "f2444:c0:m60"}
{"signature": "@_log<EOL><INDENT>def calibrate(self, analytes=None, drift_correct=True,<EOL>srms_used=['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'],<EOL>zero_intercept=True, n_min=<NUM_LIT:10>, reload_srm_database=False):<DEDENT>", "body": "if analytes is None:<EOL><INDENT>analytes = self.analytes[self.analytes != self.internal_standard]<EOL><DEDENT>elif isinstance(analytes, str):<EOL><INDENT>analytes = [analytes]<EOL><DEDENT>if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>self.srm_id_auto(srms_used=srms_used, n_min=n_min, reload_srm_database=reload_srm_database)<EOL><DEDENT>if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>gTime = self.stdtab.gTime.unique()<EOL>self.calib_params = pd.DataFrame(columns=pd.MultiIndex.from_product([analytes, ['<STR_LIT:m>']]),<EOL>index=gTime)<EOL><DEDENT>calib_analytes = self.srmtabs.index.get_level_values(<NUM_LIT:0>).unique()<EOL>if zero_intercept:<EOL><INDENT>fn  = lambda x, m: x * m<EOL><DEDENT>else:<EOL><INDENT>fn = lambda x, m, c: x * m + c<EOL><DEDENT>for a in calib_analytes:<EOL><INDENT>if zero_intercept:<EOL><INDENT>if (a, '<STR_LIT:c>') in self.calib_params:<EOL><INDENT>self.calib_params.drop((a, '<STR_LIT:c>'), <NUM_LIT:1>, inplace=True)<EOL><DEDENT><DEDENT>if drift_correct:<EOL><INDENT>for g in self.stdtab.gTime.unique():<EOL><INDENT>ind = idx[a, :, :, g]<EOL>if self.srmtabs.loc[ind].size == <NUM_LIT:0>:<EOL><INDENT>continue<EOL><DEDENT>meas = self.srmtabs.loc[ind, '<STR_LIT>']<EOL>srm = self.srmtabs.loc[ind, '<STR_LIT>']<EOL>merr = self.srmtabs.loc[ind, '<STR_LIT>']<EOL>serr = self.srmtabs.loc[ind, '<STR_LIT>']<EOL>sigma = np.sqrt(merr**<NUM_LIT:2> + serr**<NUM_LIT:2>)<EOL>if len(meas) > <NUM_LIT:1>:<EOL><INDENT>p, cov = curve_fit(fn, meas, srm, sigma=sigma)<EOL>pe = unc.correlated_values(p, cov)                <EOL>self.calib_params.loc[g, (a, '<STR_LIT:m>')] = pe[<NUM_LIT:0>]<EOL>if not zero_intercept:<EOL><INDENT>self.calib_params.loc[g, (a, '<STR_LIT:c>')] = pe[<NUM_LIT:1>]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.calib_params.loc[g, (a, '<STR_LIT:m>')] = (un.uarray(srm, serr) / <EOL>un.uarray(meas, merr))[<NUM_LIT:0>]<EOL>if not zero_intercept:<EOL><INDENT>self.calib_params.loc[g, (a, '<STR_LIT:c>')] = <NUM_LIT:0><EOL><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>ind = idx[a, :, :, :]<EOL>meas = self.srmtabs.loc[ind, '<STR_LIT>']<EOL>srm = self.srmtabs.loc[ind, '<STR_LIT>']<EOL>merr = self.srmtabs.loc[ind, '<STR_LIT>']<EOL>serr = self.srmtabs.loc[ind, '<STR_LIT>']<EOL>sigma = np.sqrt(merr**<NUM_LIT:2> + serr**<NUM_LIT:2>)<EOL>if len(meas) > <NUM_LIT:1>:<EOL><INDENT>p, cov = curve_fit(fn, meas, srm, sigma=sigma)<EOL>pe = unc.correlated_values(p, cov)                <EOL>self.calib_params.loc[:, (a, '<STR_LIT:m>')] = pe[<NUM_LIT:0>]<EOL>if not zero_intercept:<EOL><INDENT>self.calib_params.loc[:, (a, '<STR_LIT:c>')] = pe[<NUM_LIT:1>]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.calib_params.loc[:, (a, '<STR_LIT:m>')] = (un.uarray(srm, serr) / <EOL>un.uarray(meas, merr))[<NUM_LIT:0>]<EOL>if not zero_intercept:<EOL><INDENT>self.calib_params.loc[:, (a, '<STR_LIT:c>')] = <NUM_LIT:0><EOL><DEDENT><DEDENT><DEDENT><DEDENT>if self.calib_params.index.min() == <NUM_LIT:0>:<EOL><INDENT>self.calib_params.drop(<NUM_LIT:0>, inplace=True)<EOL>self.calib_params.drop(self.calib_params.index.max(), inplace=True)<EOL><DEDENT>self.calib_params.loc[<NUM_LIT:0>, :] = self.calib_params.loc[self.calib_params.index.min(), :]<EOL>maxuT = np.max([d.uTime.max() for d in self.data.values()])  <EOL>self.calib_params.loc[maxuT, :] = self.calib_params.loc[self.calib_params.index.max(), :]<EOL>self.calib_params.sort_index(<NUM_LIT:1>, inplace=True)<EOL>self.calib_params.sort_index(<NUM_LIT:0>, inplace=True)<EOL>self.calib_ps = Bunch()<EOL>for a in analytes:<EOL><INDENT>self.calib_ps[a] = {'<STR_LIT:m>': un_interp1d(self.calib_params.index.values,<EOL>self.calib_params.loc[:, (a, '<STR_LIT:m>')].values)}<EOL>if not zero_intercept:<EOL><INDENT>self.calib_ps[a]['<STR_LIT:c>'] = un_interp1d(self.calib_params.index.values,<EOL>self.calib_params.loc[:, (a, '<STR_LIT:c>')].values)<EOL><DEDENT><DEDENT>with self.pbar.set(total=len(self.data), desc='<STR_LIT>') as prog:<EOL><INDENT>for d in self.data.values():<EOL><INDENT>d.calibrate(self.calib_ps, analytes)<EOL>prog.update()<EOL><DEDENT><DEDENT>markers = '<STR_LIT>'  <EOL>if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>self.srms_used = set(srms_used)<EOL><DEDENT>else:<EOL><INDENT>self.srms_used.update(srms_used)<EOL><DEDENT>self.srm_mdict = {k: markers[i] for i, k in enumerate(self.srms_used)}<EOL>self.stages_complete.update(['<STR_LIT>'])<EOL>self.focus_stage = '<STR_LIT>'<EOL>return<EOL>", "docstring": "Calibrates the data to measured SRM values.\n\nAssumes that y intercept is zero.\n\nParameters\n----------  \nanalytes : str or iterable\n    Which analytes you'd like to calibrate. Defaults to all.\ndrift_correct : bool\n    Whether to pool all SRM measurements into a single calibration,\n    or vary the calibration through the run, interpolating\n    coefficients between measured SRMs.\nsrms_used : str or iterable\n    Which SRMs have been measured. Must match names given in\n    SRM data file *exactly*.\nn_min : int\n    The minimum number of data points an SRM measurement\n    must have to be included.\n\nReturns\n-------\nNone", "id": "f2444:c0:m18"}
{"signature": "@_log<EOL><INDENT>def trace_plots(self, analytes=None, samples=None, ranges=False,<EOL>focus=None, outdir=None, filt=None, scale='<STR_LIT>',<EOL>figsize=[<NUM_LIT:10>, <NUM_LIT:4>], stats=False, stat='<STR_LIT>',<EOL>err='<STR_LIT>', subset='<STR_LIT>'):<DEDENT>", "body": "if focus is None:<EOL><INDENT>focus = self.focus_stage<EOL><DEDENT>if outdir is None:<EOL><INDENT>outdir = self.report_dir + '<STR_LIT:/>' + focus<EOL><DEDENT>if not os.path.isdir(outdir):<EOL><INDENT>os.mkdir(outdir)<EOL><DEDENT>if subset is not None:<EOL><INDENT>samples = self._get_samples(subset)<EOL><DEDENT>elif samples is None:<EOL><INDENT>samples = self.subsets['<STR_LIT>']<EOL><DEDENT>elif isinstance(samples, str):<EOL><INDENT>samples = [samples]<EOL><DEDENT>with self.pbar.set(total=len(samples), desc='<STR_LIT>') as prog:<EOL><INDENT>for s in samples:<EOL><INDENT>f, a = self.data[s].tplot(analytes=analytes, figsize=figsize,<EOL>scale=scale, filt=filt,<EOL>ranges=ranges, stats=stats,<EOL>stat=stat, err=err, focus_stage=focus)<EOL>f.savefig(outdir + '<STR_LIT:/>' + s + '<STR_LIT>')<EOL>plt.close(f)<EOL>prog.update()<EOL><DEDENT><DEDENT>return<EOL>", "docstring": "Plot analytes as a function of time.\n\nParameters\n----------\nanalytes : optional, array_like or str\n    The analyte(s) to plot. Defaults to all analytes.\nsamples: optional, array_like or str\n    The sample(s) to plot. Defaults to all samples.\nranges : bool\n    Whether or not to show the signal/backgroudn regions\n    identified by 'autorange'.\nfocus : str\n    The focus 'stage' of the analysis to plot. Can be\n    'rawdata', 'despiked':, 'signal', 'background',\n    'bkgsub', 'ratios' or 'calibrated'.\noutdir : str\n    Path to a directory where you'd like the plots to be\n    saved. Defaults to 'reports/[focus]' in your data directory.\nfilt : str, dict or bool\n    Either logical filter expression contained in a str,\n    a dict of expressions specifying the filter string to\n    use for each analyte or a boolean. Passed to `grab_filt`.\nscale : str\n    If 'log', plots the data on a log scale.\nfigsize : array_like\n    Array of length 2 specifying figure [width, height] in\n    inches.\nstats : bool\n    Whether or not to overlay the mean and standard deviations\n    for each trace.\nstat, err: str\n    The names of the statistic and error components to plot.\n    Deafaults to 'nanmean' and 'nanstd'.\n\n\nReturns\n-------\nNone", "id": "f2444:c0:m50"}
{"signature": "def filter_nremoved(self, filt=True, quiet=False):", "body": "rminfo = {}<EOL>for n in self.subsets['<STR_LIT>']:<EOL><INDENT>s = self.data[n]<EOL>rminfo[n] = s.filt_nremoved(filt)<EOL><DEDENT>if not quiet:<EOL><INDENT>maxL = max([len(s) for s in rminfo.keys()])<EOL>print('<STR_LIT>'.format(string='<STR_LIT>', number=maxL + <NUM_LIT:3>) +<EOL>'<STR_LIT>'.format(total='<STR_LIT>') +<EOL>'<STR_LIT>'.format(removed='<STR_LIT>') +<EOL>'<STR_LIT>'.format(percent='<STR_LIT>'))<EOL>for k, (ntot, nfilt, pcrm) in rminfo.items():<EOL><INDENT>print('<STR_LIT>'.format(string=k, number=maxL + <NUM_LIT:3>) +<EOL>'<STR_LIT>'.format(total=ntot) +<EOL>'<STR_LIT>'.format(removed=nfilt) +<EOL>'<STR_LIT>'.format(percent=pcrm))<EOL><DEDENT><DEDENT>return rminfo<EOL>", "docstring": "Report how many data are removed by the active filters.", "id": "f2444:c0:m37"}
{"signature": "@_log<EOL><INDENT>def crossplot(self, analytes=None, lognorm=True,<EOL>bins=<NUM_LIT>, filt=False, samples=None,<EOL>subset=None, figsize=(<NUM_LIT:12>, <NUM_LIT:12>), save=False,<EOL>colourful=True, mode='<STR_LIT>', **kwargs):<DEDENT>", "body": "if analytes is None:<EOL><INDENT>analytes = self.analytes<EOL><DEDENT>if self.focus_stage in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>analytes = [a for a in analytes if self.internal_standard not in a]<EOL><DEDENT>try:<EOL><INDENT>analytes = sorted(analytes, key=lambda x: float(re.findall('<STR_LIT>', x)[<NUM_LIT:0>]))<EOL><DEDENT>except IndexError:<EOL><INDENT>analytes = sorted(analytes)<EOL><DEDENT>self.get_focus(filt=filt, samples=samples, subset=subset)<EOL>fig, axes = plot.crossplot(dat=self.focus, keys=analytes, lognorm=lognorm,<EOL>bins=bins, figsize=figsize, colourful=colourful,<EOL>focus_stage=self.focus_stage, cmap=self.cmaps,<EOL>denominator=self.internal_standard, mode=mode)<EOL>if save or isinstance(save, str):<EOL><INDENT>if isinstance(save, str):<EOL><INDENT>fig.savefig(self.report_dir + '<STR_LIT:/>' + save, dpi=<NUM_LIT:200>)            <EOL><DEDENT>else:<EOL><INDENT>fig.savefig(self.report_dir + '<STR_LIT>', dpi=<NUM_LIT:200>)<EOL><DEDENT><DEDENT>return fig, axes<EOL>", "docstring": "Plot analytes against each other.\n\nParameters\n----------\nanalytes : optional, array_like or str\n    The analyte(s) to plot. Defaults to all analytes.\nlognorm : bool\n    Whether or not to log normalise the colour scale\n    of the 2D histogram.\nbins : int\n    The number of bins in the 2D histogram.\nfilt : str, dict or bool\n    Either logical filter expression contained in a str,\n    a dict of expressions specifying the filter string to\n    use for each analyte or a boolean. Passed to `grab_filt`.\nfigsize : tuple\n    Figure size (width, height) in inches.\nsave : bool or str\n    If True, plot is saves as 'crossplot.png', if str plot is\n    saves as str.\ncolourful : bool\n    Whether or not the plot should be colourful :).\nmode : str\n    'hist2d' (default) or 'scatter'\n\nReturns\n-------\n(fig, axes)", "id": "f2444:c0:m45"}
{"signature": "def find_expcoef(self, nsd_below=<NUM_LIT:0.>, plot=False,<EOL>trimlim=None, autorange_kwargs={}):", "body": "print('<STR_LIT>')<EOL>def findtrim(tr, lim=None):<EOL><INDENT>trr = np.roll(tr, -<NUM_LIT:1>)<EOL>trr[-<NUM_LIT:1>] = <NUM_LIT:0><EOL>if lim is None:<EOL><INDENT>lim = <NUM_LIT:0.5> * np.nanmax(tr - trr)<EOL><DEDENT>ind = (tr - trr) >= lim<EOL>return np.arange(len(ind))[ind ^ np.roll(ind, -<NUM_LIT:1>)][<NUM_LIT:0>]<EOL><DEDENT>if not hasattr(self.stds[<NUM_LIT:0>], '<STR_LIT>'):<EOL><INDENT>for s in self.stds:<EOL><INDENT>s.autorange(**autorange_kwargs, ploterrs=False)<EOL><DEDENT><DEDENT>trans = []<EOL>times = []<EOL>for v in self.stds:<EOL><INDENT>for trnrng in v.trnrng[-<NUM_LIT:1>::-<NUM_LIT:2>]:<EOL><INDENT>tr = minmax_scale(v.data['<STR_LIT>'][(v.Time > trnrng[<NUM_LIT:0>]) & (v.Time < trnrng[<NUM_LIT:1>])])<EOL>sm = np.apply_along_axis(np.nanmean, <NUM_LIT:1>,<EOL>rolling_window(tr, <NUM_LIT:3>, pad=<NUM_LIT:0>))<EOL>sm[<NUM_LIT:0>] = sm[<NUM_LIT:1>]<EOL>trim = findtrim(sm, trimlim) + <NUM_LIT:2><EOL>trans.append(minmax_scale(tr[trim:]))<EOL>times.append(np.arange(tr[trim:].size) *<EOL>np.diff(v.Time[<NUM_LIT:1>:<NUM_LIT:3>]))<EOL><DEDENT><DEDENT>times = np.concatenate(times)<EOL>times = np.round(times, <NUM_LIT:2>)<EOL>trans = np.concatenate(trans)<EOL>ti = []<EOL>tr = []<EOL>for t in np.unique(times):<EOL><INDENT>ti.append(t)<EOL>tr.append(np.nanmin(trans[times == t]))<EOL><DEDENT>def expfit(x, e):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return np.exp(e * x)<EOL><DEDENT>ep, ecov = curve_fit(expfit, ti, tr, p0=(-<NUM_LIT:1.>))<EOL>eeR2 = R2calc(trans, expfit(times, ep))<EOL>if plot:<EOL><INDENT>fig, ax = plt.subplots(<NUM_LIT:1>, <NUM_LIT:1>, figsize=[<NUM_LIT:6>, <NUM_LIT:4>])<EOL>ax.scatter(times, trans, alpha=<NUM_LIT>, color='<STR_LIT:k>', marker='<STR_LIT:x>', zorder=-<NUM_LIT:2>)<EOL>ax.scatter(ti, tr, alpha=<NUM_LIT:1>, color='<STR_LIT:k>', marker='<STR_LIT:o>')<EOL>fitx = np.linspace(<NUM_LIT:0>, max(ti))<EOL>ax.plot(fitx, expfit(fitx, ep), color='<STR_LIT:r>', label='<STR_LIT>')<EOL>ax.plot(fitx, expfit(fitx, ep - nsd_below * np.diag(ecov)**<NUM_LIT>, ),<EOL>color='<STR_LIT:b>', label='<STR_LIT>')<EOL>ax.text(<NUM_LIT>, <NUM_LIT>,<EOL>('<STR_LIT>'<EOL>'<STR_LIT>') % (ep,<EOL>np.diag(ecov)**<NUM_LIT>,<EOL>eeR2,<EOL>ep - nsd_below * np.diag(ecov)**<NUM_LIT>),<EOL>transform=ax.transAxes, ha='<STR_LIT:right>', va='<STR_LIT>', size=<NUM_LIT:12>)<EOL>ax.set_xlim(<NUM_LIT:0>, ax.get_xlim()[-<NUM_LIT:1>])<EOL>ax.set_xlabel('<STR_LIT>')<EOL>ax.set_ylim(-<NUM_LIT>, <NUM_LIT>)<EOL>ax.set_ylabel('<STR_LIT>')<EOL>plt.legend()<EOL>if isinstance(plot, str):<EOL><INDENT>fig.savefig(plot)<EOL><DEDENT><DEDENT>self.expdecay_coef = ep - nsd_below * np.diag(ecov)**<NUM_LIT><EOL>print('<STR_LIT>'.format(self.expdecay_coef[<NUM_LIT:0>]))<EOL>return<EOL>", "docstring": "Determines exponential decay coefficient for despike filter.\n\nFits an exponential decay function to the washout phase of standards\nto determine the washout time of your laser cell. The exponential\ncoefficient reported is `nsd_below` standard deviations below the\nfitted exponent, to ensure that no real data is removed.\n\nTotal counts are used in fitting, rather than a specific analyte.\n\nParameters\n----------\nnsd_below : float\n    The number of standard deviations to subtract from the fitted\n    coefficient when calculating the filter exponent.\nplot : bool or str\n    If True, creates a plot of the fit, if str the plot is to the\n    location specified in str.\ntrimlim : float\n    A threshold limit used in determining the start of the\n    exponential decay region of the washout. Defaults to half\n    the increase in signal over background. If the data in\n    the plot don't fall on an exponential decay line, change\n    this number. Normally you'll need to increase it.\n\nReturns\n-------\nNone", "id": "f2444:c0:m5"}
{"signature": "@_log<EOL><INDENT>def gradient_plots(self, analytes=None, win=<NUM_LIT:15>, samples=None, ranges=False,<EOL>focus=None, outdir=None,<EOL>figsize=[<NUM_LIT:10>, <NUM_LIT:4>], subset='<STR_LIT>'):<DEDENT>", "body": "if focus is None:<EOL><INDENT>focus = self.focus_stage<EOL><DEDENT>if outdir is None:<EOL><INDENT>outdir = self.report_dir + '<STR_LIT:/>' + focus + '<STR_LIT>'<EOL><DEDENT>if not os.path.isdir(outdir):<EOL><INDENT>os.mkdir(outdir)<EOL><DEDENT>if subset is not None:<EOL><INDENT>samples = self._get_samples(subset)<EOL><DEDENT>elif samples is None:<EOL><INDENT>samples = self.subsets['<STR_LIT>']<EOL><DEDENT>elif isinstance(samples, str):<EOL><INDENT>samples = [samples]<EOL><DEDENT>with self.pbar.set(total=len(samples), desc='<STR_LIT>') as prog:<EOL><INDENT>for s in samples:<EOL><INDENT>f, a = self.data[s].gplot(analytes=analytes, win=win, figsize=figsize,<EOL>ranges=ranges, focus_stage=focus)<EOL>f.savefig(outdir + '<STR_LIT:/>' + s + '<STR_LIT>')<EOL>plt.close(f)<EOL>prog.update()<EOL><DEDENT><DEDENT>return<EOL>", "docstring": "Plot analyte gradients as a function of time.\n\nParameters\n----------\nanalytes : optional, array_like or str\n    The analyte(s) to plot. Defaults to all analytes.\nsamples: optional, array_like or str\n    The sample(s) to plot. Defaults to all samples.\nranges : bool\n    Whether or not to show the signal/backgroudn regions\n    identified by 'autorange'.\nfocus : str\n    The focus 'stage' of the analysis to plot. Can be\n    'rawdata', 'despiked':, 'signal', 'background',\n    'bkgsub', 'ratios' or 'calibrated'.\noutdir : str\n    Path to a directory where you'd like the plots to be\n    saved. Defaults to 'reports/[focus]' in your data directory.\nfilt : str, dict or bool\n    Either logical filter expression contained in a str,\n    a dict of expressions specifying the filter string to\n    use for each analyte or a boolean. Passed to `grab_filt`.\nscale : str\n    If 'log', plots the data on a log scale.\nfigsize : array_like\n    Array of length 2 specifying figure [width, height] in\n    inches.\nstats : bool\n    Whether or not to overlay the mean and standard deviations\n    for each trace.\nstat, err: str\n    The names of the statistic and error components to plot.\n    Deafaults to 'nanmean' and 'nanstd'.\n\n\nReturns\n-------\nNone", "id": "f2444:c0:m51"}
{"signature": "def crossplot_filters(self, filter_string, analytes=None,<EOL>samples=None, subset=None, filt=None):", "body": "if analytes is None:<EOL><INDENT>analytes = [a for a in self.analytes if self.internal_standard not in a]<EOL><DEDENT>if samples is None:<EOL><INDENT>samples = self._get_samples(subset)<EOL><DEDENT>filts = self.data[samples[<NUM_LIT:0>]].filt.components.keys()<EOL>cfilts = [f for f in filts if filter_string in f]<EOL>flab = re.compile('<STR_LIT>')  <EOL>self.get_focus(subset=subset, filt=filt)<EOL>numvars = len(analytes)<EOL>fig, axes = plt.subplots(nrows=numvars, ncols=numvars,<EOL>figsize=(<NUM_LIT:12>, <NUM_LIT:12>))<EOL>fig.subplots_adjust(hspace=<NUM_LIT>, wspace=<NUM_LIT>)<EOL>for ax in axes.flat:<EOL><INDENT>ax.xaxis.set_visible(False)<EOL>ax.yaxis.set_visible(False)<EOL>if ax.is_first_col():<EOL><INDENT>ax.yaxis.set_ticks_position('<STR_LIT:left>')<EOL><DEDENT>if ax.is_last_col():<EOL><INDENT>ax.yaxis.set_ticks_position('<STR_LIT:right>')<EOL><DEDENT>if ax.is_first_row():<EOL><INDENT>ax.xaxis.set_ticks_position('<STR_LIT>')<EOL><DEDENT>if ax.is_last_row():<EOL><INDENT>ax.xaxis.set_ticks_position('<STR_LIT>')<EOL><DEDENT><DEDENT>cmlist = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>focus = {k: nominal_values(v) for k, v in self.focus.items()}<EOL>udict = {a: unitpicker(np.nanmean(focus[a]),<EOL>focus_stage=self.focus_stage,<EOL>denominator=self.internal_standard) for a in analytes}<EOL>rdict = {a: (np.nanmin(focus[a] * udict[a][<NUM_LIT:0>]),<EOL>np.nanmax(focus[a] * udict[a][<NUM_LIT:0>])) for a in analytes}<EOL>for f in cfilts:<EOL><INDENT>self.get_focus(f, subset=subset)<EOL>focus = {k: nominal_values(v) for k, v in self.focus.items()}<EOL>lab = flab.match(f).groups()[<NUM_LIT:0>]<EOL>axes[<NUM_LIT:0>, <NUM_LIT:0>].scatter([], [], s=<NUM_LIT:10>, label=lab)<EOL>for i, j in zip(*np.triu_indices_from(axes, k=<NUM_LIT:1>)):<EOL><INDENT>ai = analytes[i]<EOL>aj = analytes[j]<EOL>pi = focus[ai][~np.isnan(focus[ai])] * udict[ai][<NUM_LIT:0>]<EOL>pj = focus[aj][~np.isnan(focus[aj])] * udict[aj][<NUM_LIT:0>]<EOL>axes[i, j].scatter(pj, pi, alpha=<NUM_LIT>, s=<NUM_LIT:10>, lw=<NUM_LIT:0.5>, edgecolor='<STR_LIT:k>')<EOL>axes[j, i].scatter(pi, pj, alpha=<NUM_LIT>, s=<NUM_LIT:10>, lw=<NUM_LIT:0.5>, edgecolor='<STR_LIT:k>')<EOL>axes[i, j].set_ylim(*rdict[ai])<EOL>axes[i, j].set_xlim(*rdict[aj])<EOL>axes[j, i].set_ylim(*rdict[aj])<EOL>axes[j, i].set_xlim(*rdict[ai])<EOL><DEDENT><DEDENT>for a, n in zip(analytes, np.arange(len(analytes))):<EOL><INDENT>axes[n, n].annotate(a + '<STR_LIT:\\n>' + udict[a][<NUM_LIT:1>], (<NUM_LIT:0.5>, <NUM_LIT:0.5>),<EOL>xycoords='<STR_LIT>',<EOL>ha='<STR_LIT>', va='<STR_LIT>')<EOL>axes[n, n].set_xlim(*rdict[a])<EOL>axes[n, n].set_ylim(*rdict[a])<EOL><DEDENT>axes[<NUM_LIT:0>, <NUM_LIT:0>].legend(loc='<STR_LIT>', title=filter_string)<EOL>for i, j in zip(range(numvars), itertools.cycle((-<NUM_LIT:1>, <NUM_LIT:0>))):<EOL><INDENT>axes[j, i].xaxis.set_visible(True)<EOL>for label in axes[j, i].get_xticklabels():<EOL><INDENT>label.set_rotation(<NUM_LIT>)<EOL><DEDENT>axes[i, j].yaxis.set_visible(True)<EOL><DEDENT>return fig, axes<EOL>", "docstring": "Plot the results of a group of filters in a crossplot.\n\nParameters\n----------\nfilter_string : str\n    A string that identifies a group of filters.\n    e.g. 'test' would plot all filters with 'test' in the\n    name.\nanalytes : optional, array_like or str\n    The analyte(s) to plot. Defaults to all analytes.\n\nReturns\n-------\nfig, axes objects", "id": "f2444:c0:m49"}
{"signature": "@_log<EOL><INDENT>def make_subset(self, samples=None, name=None):<DEDENT>", "body": "<EOL>for k, v in self.subsets.items():<EOL><INDENT>if set(v) == set(samples) and k != '<STR_LIT>':<EOL><INDENT>return k<EOL><DEDENT><DEDENT>if isinstance(samples, str):<EOL><INDENT>samples = [samples]<EOL><DEDENT>not_exists = [s for s in samples if s not in self.subsets['<STR_LIT>']]<EOL>if len(not_exists) > <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT:U+002CU+0020>'.join(not_exists) + '<STR_LIT>')<EOL><DEDENT>if name is None:<EOL><INDENT>name = max([-<NUM_LIT:1>] + [x for x in self.subsets.keys() if isinstance(x, int)]) + <NUM_LIT:1><EOL><DEDENT>self._subset_names.append(name)<EOL>if samples is not None:<EOL><INDENT>self.subsets[name] = samples<EOL>for s in samples:<EOL><INDENT>try:<EOL><INDENT>self.subsets['<STR_LIT>'].remove(s)<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>self._has_subsets = True<EOL>return name<EOL>", "docstring": "Creates a subset of samples, which can be treated independently.\n\nParameters\n----------\nsamples : str or array - like\n    Name of sample, or list of sample names.\nname : (optional) str or number\n    The name of the sample group. Defaults to n + 1, where n is\n    the highest existing group number", "id": "f2444:c0:m19"}
{"signature": "@_log<EOL><INDENT>def filter_gradient_threshold_percentile(self, analyte, percentiles, level='<STR_LIT>', win=<NUM_LIT:15>, filt=False,<EOL>samples=None, subset=None):<DEDENT>", "body": "params = locals()<EOL>del(params['<STR_LIT>'])<EOL>if samples is not None:<EOL><INDENT>subset = self.make_subset(samples)<EOL><DEDENT>samples = self._get_samples(subset)<EOL>self.minimal_analytes.update([analyte])<EOL>self.get_gradients(analytes=[analyte], win=win, filt=filt, subset=subset)<EOL>grad = self.gradients[analyte][~np.isnan(self.gradients[analyte])]<EOL>if isinstance(percentiles, (int, float)):<EOL><INDENT>percentiles = [percentiles]<EOL><DEDENT>if level == '<STR_LIT>':<EOL><INDENT>lims = np.percentile(grad, percentiles)<EOL><DEDENT>with self.pbar.set(total=len(samples), desc='<STR_LIT>') as prog:<EOL><INDENT>for s in samples:<EOL><INDENT>d = self.data[s]<EOL>setn = d.filt.maxset + <NUM_LIT:1><EOL>g = calc_grads(d.Time, d.focus, [analyte], win)[analyte]<EOL>if level == '<STR_LIT>':<EOL><INDENT>gt = nominal_values(g)<EOL>lims = np.percentile(gt[~np.isnan(gt)], percentiles)<EOL><DEDENT>if len(lims) == <NUM_LIT:1>:<EOL><INDENT>above = g >= lims[<NUM_LIT:0>]<EOL>below = g < lims[<NUM_LIT:0>]<EOL>d.filt.add(analyte + '<STR_LIT>'.format(percentiles[<NUM_LIT:0>]),<EOL>below,<EOL>'<STR_LIT>'.format(percentiles[<NUM_LIT:0>], analyte, lims[<NUM_LIT:0>]),<EOL>params, setn=setn)<EOL>d.filt.add(analyte + '<STR_LIT>'.format(percentiles[<NUM_LIT:0>]),<EOL>above,<EOL>'<STR_LIT>'.format(percentiles[<NUM_LIT:0>], analyte, lims[<NUM_LIT:0>]),<EOL>params, setn=setn)<EOL><DEDENT>elif len(lims) == <NUM_LIT:2>:<EOL><INDENT>inside = (g >= min(lims)) & (g <= max(lims))<EOL>outside = (g < min(lims)) | (g > max(lims))<EOL>lpc = '<STR_LIT:->'.join(['<STR_LIT>'.format(p) for p in percentiles])<EOL>d.filt.add(analyte + '<STR_LIT:_>' + lpc + '<STR_LIT>',<EOL>inside,<EOL>'<STR_LIT>' + lpc + '<STR_LIT:U+0020>' + analyte + '<STR_LIT>',<EOL>params, setn=setn)<EOL>d.filt.add(analyte + '<STR_LIT:_>' + lpc + '<STR_LIT>',<EOL>outside,<EOL>'<STR_LIT>' + lpc + '<STR_LIT:U+0020>' + analyte + '<STR_LIT>',<EOL>params, setn=setn)<EOL><DEDENT>prog.update()<EOL><DEDENT><DEDENT>return<EOL>", "docstring": "Calculate a gradient threshold filter to the data.\n\nGenerates two filters above and below the threshold value for a\ngiven analyte.\n\nParameters\n----------\nanalyte : str\n    The analyte that the filter applies to.\nwin : int\n    The window over which to calculate the moving gradient\npercentiles : float or iterable of len=2\n    The percentile values.\nfilt : bool\n    Whether or not to apply existing filters to the data before\n    calculating this filter.\nsamples : array_like or None\n    Which samples to apply this filter to. If None, applies to all\n    samples.\nsubset : str or number\n    The subset of samples (defined by make_subset) you want to apply\n    the filter to.\n\nReturns\n-------\nNone", "id": "f2444:c0:m24"}
{"signature": "@_log<EOL><INDENT>def zeroscreen(self, focus_stage=None):<DEDENT>", "body": "if focus_stage is None:<EOL><INDENT>focus_stage = self.focus_stage<EOL><DEDENT>for s in self.data.values():<EOL><INDENT>ind = np.ones(len(s.Time), dtype=bool)<EOL>for v in s.data[focus_stage].values():<EOL><INDENT>ind = ind & (nominal_values(v) > <NUM_LIT:0>)<EOL><DEDENT>for k in s.data[focus_stage].keys():<EOL><INDENT>s.data[focus_stage][k][~ind] = unc.ufloat(np.nan, np.nan)<EOL><DEDENT><DEDENT>self.set_focus(focus_stage)<EOL>return<EOL>", "docstring": "Remove all points containing data below zero (which are impossible!)", "id": "f2444:c0:m20"}
{"signature": "def get_background(self, n_min=<NUM_LIT:10>, n_max=None, focus_stage='<STR_LIT>', bkg_filter=False, f_win=<NUM_LIT:5>, f_n_lim=<NUM_LIT:3>):", "body": "allbkgs = {'<STR_LIT>': [],<EOL>'<STR_LIT>': []}<EOL>if focus_stage == '<STR_LIT>':<EOL><INDENT>if '<STR_LIT>' not in self.stages_complete:<EOL><INDENT>focus_stage = '<STR_LIT>'<EOL><DEDENT><DEDENT>for a in self.analytes:<EOL><INDENT>allbkgs[a] = []<EOL><DEDENT>n0 = <NUM_LIT:0><EOL>for s in self.data.values():<EOL><INDENT>if sum(s.bkg) > <NUM_LIT:0>:<EOL><INDENT>allbkgs['<STR_LIT>'].append(s.uTime[s.bkg])<EOL>allbkgs['<STR_LIT>'].append(enumerate_bool(s.bkg, n0)[s.bkg])<EOL>n0 = allbkgs['<STR_LIT>'][-<NUM_LIT:1>][-<NUM_LIT:1>]<EOL>for a in self.analytes:<EOL><INDENT>allbkgs[a].append(s.data[focus_stage][a][s.bkg])<EOL><DEDENT><DEDENT><DEDENT>allbkgs.update((k, np.concatenate(v)) for k, v in allbkgs.items())<EOL>bkgs = pd.DataFrame(allbkgs)  <EOL>self.bkg = Bunch()<EOL>if n_max is None:<EOL><INDENT>self.bkg['<STR_LIT>'] = bkgs.groupby('<STR_LIT>').filter(lambda x: len(x) > n_min)<EOL><DEDENT>else:<EOL><INDENT>self.bkg['<STR_LIT>'] = bkgs.groupby('<STR_LIT>').filter(lambda x: (len(x) > n_min) & (len(x) < n_max))<EOL><DEDENT>self.bkg['<STR_LIT>'] = self.bkg['<STR_LIT>'].groupby('<STR_LIT>').aggregate([np.mean, np.std, stderr])<EOL>self.bkg['<STR_LIT>'].sort_values(('<STR_LIT>', '<STR_LIT>'), inplace=True)<EOL>if bkg_filter:<EOL><INDENT>t = self.bkg['<STR_LIT>'].loc[:, idx[:, '<STR_LIT>']]<EOL>r = t.rolling(f_win).aggregate([np.nanmean, np.nanstd])<EOL>upper = r.loc[:, idx[:, :, '<STR_LIT>']] + f_n_lim * r.loc[:, idx[:, :, '<STR_LIT>']].values<EOL>over = r.loc[:, idx[:, :, '<STR_LIT>']] > np.roll(upper.values, <NUM_LIT:1>, <NUM_LIT:0>)<EOL>ns_drop = over.loc[over.apply(any, <NUM_LIT:1>), :].index.values<EOL>self.bkg['<STR_LIT>'].drop(ns_drop, inplace=True)<EOL>ind = np.ones(self.bkg['<STR_LIT>'].shape[<NUM_LIT:0>], dtype=bool)<EOL>for ns in ns_drop:<EOL><INDENT>ind = ind & (self.bkg['<STR_LIT>'].loc[:, '<STR_LIT>'] != ns)<EOL><DEDENT>self.bkg['<STR_LIT>'] = self.bkg['<STR_LIT>'].loc[ind, :]<EOL><DEDENT>return<EOL>", "docstring": "Extract all background data from all samples on universal time scale.\nUsed by both 'polynomial' and 'weightedmean' methods.\n\nParameters\n----------\nn_min : int\n    The minimum number of points a background region must\n    have to be included in calculation.\nn_max : int\n    The maximum number of points a background region must\n    have to be included in calculation.\nfilter : bool\n    If true, apply a rolling filter to the isolated background regions\n    to exclude regions with anomalously high values. If True, two parameters\n    alter the filter's behaviour:\nf_win : int\n    The size of the rolling window\nf_n_lim : float\n    The number of standard deviations above the rolling mean\n    to set the threshold.\nfocus_stage : str\n    Which stage of analysis to apply processing to. \n    Defaults to 'despiked' if present, or 'rawdata' if not. \n    Can be one of:\n    * 'rawdata': raw data, loaded from csv file.\n    * 'despiked': despiked data.\n    * 'signal'/'background': isolated signal and background data.\n      Created by self.separate, after signal and background\n      regions have been identified by self.autorange.\n    * 'bkgsub': background subtracted data, created by \n      self.bkg_correct\n    * 'ratios': element ratio data, created by self.ratio.\n    * 'calibrated': ratio data calibrated to standards, created by self.calibrate.\n\nReturns\n-------\npandas.DataFrame object containing background data.", "id": "f2444:c0:m7"}
{"signature": "@_log<EOL><INDENT>def fit_classifier(self, name, analytes, method, samples=None,<EOL>subset=None, filt=True, sort_by=<NUM_LIT:0>, **kwargs):<DEDENT>", "body": "<EOL>if samples is not None:<EOL><INDENT>subset = self.make_subset(samples)<EOL><DEDENT>self.get_focus(subset=subset, filt=filt)<EOL>c = classifier(analytes,<EOL>sort_by)<EOL>c.fit(data=self.focus,<EOL>method=method,<EOL>**kwargs)<EOL>self.classifiers[name] = c<EOL>return name<EOL>", "docstring": "Create a clustering classifier based on all samples, or a subset.\n\nParameters\n----------\nname : str\n    The name of the classifier.\nanalytes : str or iterable\n    Which analytes the clustering algorithm should consider.\nmethod : str\n    Which clustering algorithm to use. Can be:\n\n    'meanshift'\n        The `sklearn.cluster.MeanShift` algorithm.\n        Automatically determines number of clusters\n        in data based on the `bandwidth` of expected\n        variation.\n    'kmeans'\n        The `sklearn.cluster.KMeans` algorithm. Determines\n        the characteristics of a known number of clusters\n        within the data. Must provide `n_clusters` to specify\n        the expected number of clusters.\nsamples : iterable\n    list of samples to consider. Overrides 'subset'.\nsubset : str\n    The subset of samples used to fit the classifier. Ignored if\n    'samples' is specified.\nsort_by : int\n    Which analyte the resulting clusters should be sorted\n    by - defaults to 0, which is the first analyte.\n**kwargs :\n    method-specific keyword parameters - see below.\nMeanshift Parameters\n    bandwidth : str or float\n        The bandwith (float) or bandwidth method ('scott' or 'silverman')\n        used to estimate the data bandwidth.\n    bin_seeding : bool\n        Modifies the behaviour of the meanshift algorithm. Refer to\n        sklearn.cluster.meanshift documentation.\nK - Means Parameters\n    n_clusters : int\n        The number of clusters expected in the data.\n\nReturns\n-------\nname : str", "id": "f2444:c0:m26"}
{"signature": "@_log<EOL><INDENT>def bkg_subtract(self, analytes=None, errtype='<STR_LIT>', focus_stage='<STR_LIT>'):<DEDENT>", "body": "if analytes is None:<EOL><INDENT>analytes = self.analytes<EOL><DEDENT>elif isinstance(analytes, str):<EOL><INDENT>analytes = [analytes]<EOL><DEDENT>if focus_stage == '<STR_LIT>':<EOL><INDENT>if '<STR_LIT>' not in self.stages_complete:<EOL><INDENT>focus_stage = '<STR_LIT>'<EOL><DEDENT><DEDENT>bkg_interps = {}<EOL>for a in analytes:<EOL><INDENT>bkg_interps[a] = un_interp1d(x=self.bkg['<STR_LIT>']['<STR_LIT>'],<EOL>y=un.uarray(self.bkg['<STR_LIT>'][a]['<STR_LIT>'],<EOL>self.bkg['<STR_LIT>'][a][errtype]))<EOL><DEDENT>self.bkg_interps = bkg_interps<EOL>with self.pbar.set(total=len(self.data), desc='<STR_LIT>') as prog:<EOL><INDENT>for d in self.data.values():<EOL><INDENT>[d.bkg_subtract(a, bkg_interps[a].new(d.uTime), ~d.sig, focus_stage=focus_stage) for a in analytes]<EOL>d.setfocus('<STR_LIT>')<EOL>prog.update()<EOL><DEDENT><DEDENT>self.stages_complete.update(['<STR_LIT>'])<EOL>self.focus_stage = '<STR_LIT>'<EOL>return<EOL>", "docstring": "Subtract calculated background from data.\n\nMust run bkg_calc first!\n\nParameters\n----------\nanalytes : str or iterable\n    Which analyte(s) to subtract.\nerrtype : str\n    Which type of error to propagate. default is 'stderr'.\nfocus_stage : str\n    Which stage of analysis to apply processing to. \n    Defaults to 'despiked' if present, or 'rawdata' if not. \n    Can be one of:\n    * 'rawdata': raw data, loaded from csv file.\n    * 'despiked': despiked data.\n    * 'signal'/'background': isolated signal and background data.\n      Created by self.separate, after signal and background\n      regions have been identified by self.autorange.\n    * 'bkgsub': background subtracted data, created by \n      self.bkg_correct\n    * 'ratios': element ratio data, created by self.ratio.\n    * 'calibrated': ratio data calibrated to standards, created by self.calibrate.", "id": "f2444:c0:m10"}
{"signature": "@_log<EOL><INDENT>def correlation_plots(self, x_analyte, y_analyte, window=<NUM_LIT:15>, filt=True, recalc=False, samples=None, subset=None, outdir=None):<DEDENT>", "body": "if outdir is None:<EOL><INDENT>outdir = self.report_dir + '<STR_LIT>'<EOL><DEDENT>if not os.path.isdir(outdir):<EOL><INDENT>os.mkdir(outdir)<EOL><DEDENT>if subset is not None:<EOL><INDENT>samples = self._get_samples(subset)<EOL><DEDENT>elif samples is None:<EOL><INDENT>samples = self.subsets['<STR_LIT>']<EOL><DEDENT>elif isinstance(samples, str):<EOL><INDENT>samples = [samples]<EOL><DEDENT>with self.pbar.set(total=len(samples), desc='<STR_LIT>') as prog:<EOL><INDENT>for s in samples:<EOL><INDENT>f, a = self.data[s].correlation_plot(x_analyte=x_analyte, y_analyte=y_analyte,<EOL>window=window, filt=filt, recalc=recalc)<EOL>f.savefig('<STR_LIT>'.format(outdir, s, x_analyte, y_analyte))<EOL>plt.close(f)<EOL>prog.update()<EOL><DEDENT><DEDENT>return<EOL>", "docstring": "Plot the local correlation between two analytes.\n\nParameters\n----------\nx_analyte, y_analyte : str\n    The names of the x and y analytes to correlate.\nwindow : int, None\n    The rolling window used when calculating the correlation.\nfilt : bool\n    Whether or not to apply existing filters to the data before\n    calculating this filter.\nrecalc : bool\n    If True, the correlation is re-calculated, even if it is already present.\n\nReturns\n-------\nNone", "id": "f2444:c0:m29"}
{"signature": "@_log<EOL><INDENT>def filter_defragment(self, threshold, mode='<STR_LIT>', filt=True, samples=None, subset=None):<DEDENT>", "body": "if samples is not None:<EOL><INDENT>subset = self.make_subset(samples)<EOL><DEDENT>samples = self._get_samples(subset)<EOL>for s in samples:<EOL><INDENT>f = self.data[s].filt.grab_filt(filt)<EOL>self.data[s].filt.add(name='<STR_LIT>'.format(mode, threshold),<EOL>filt=filters.defrag(f, threshold, mode),<EOL>info='<STR_LIT>'.format(mode, threshold),<EOL>params=(threshold, mode, filt, samples, subset))<EOL><DEDENT>", "docstring": "Remove 'fragments' from the calculated filter\n\nParameters\n----------\nthreshold : int\n    Contiguous data regions that contain this number\n    or fewer points are considered 'fragments'\nmode : str\n    Specifies wither to 'include' or 'exclude' the identified\n    fragments.\nfilt : bool or filt string\n    Which filter to apply the defragmenter to. Defaults to True\nsamples : array_like or None\n    Which samples to apply this filter to. If None, applies to all\n    samples.\nsubset : str or number\n    The subset of samples (defined by make_subset) you want to apply\n    the filter to.\n\nReturns\n-------\nNone", "id": "f2444:c0:m34"}
{"signature": "def long_file(data_file, dataformat, sample_list, savedir=None, srm_id=None, **autorange_args):", "body": "if isinstance(sample_list, str):<EOL><INDENT>if os.path.exists(sample_list):<EOL><INDENT>sample_list = np.genfromtxt(sample_list, dtype=str)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>elif not isinstance(sample_list, (list, np.ndarray)):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if srm_id is not None:<EOL><INDENT>srm_replace = []<EOL>for s in sample_list:<EOL><INDENT>if srm_id in s:<EOL><INDENT>s = srm_id<EOL><DEDENT>srm_replace.append(s)<EOL><DEDENT>sample_list = srm_replace<EOL><DEDENT>_, _, dat, meta = read_data(data_file, dataformat=dataformat, name_mode='<STR_LIT:file>')<EOL>if '<STR_LIT:date>' in meta:<EOL><INDENT>d = dateutil.parser.parse(meta['<STR_LIT:date>'])<EOL><DEDENT>else:<EOL><INDENT>d = datetime.datetime.now()<EOL><DEDENT>bkg, sig, trn, _ = autorange(dat['<STR_LIT>'], dat['<STR_LIT>'], **autorange_args)<EOL>ns = np.zeros(sig.size)<EOL>ns[sig] = np.cumsum((sig ^ np.roll(sig, <NUM_LIT:1>)) & sig)[sig]<EOL>n = int(max(ns))<EOL>if len(sample_list) != n:<EOL><INDENT>warn('<STR_LIT>' + <EOL>'<STR_LIT>')<EOL><DEDENT>bounds = []<EOL>lower = <NUM_LIT:0><EOL>sn = <NUM_LIT:0><EOL>next_sample = '<STR_LIT>'<EOL>for ni in range(n-<NUM_LIT:1>):<EOL><INDENT>sample = sample_list[sn]<EOL>next_sample = sample_list[sn + <NUM_LIT:1>]<EOL>if sample != next_sample:<EOL><INDENT>current_end = np.argwhere(dat['<STR_LIT>'] == dat['<STR_LIT>'][ns == ni + <NUM_LIT:1>].max())[<NUM_LIT:0>]<EOL>next_start = np.argwhere(dat['<STR_LIT>'] == dat['<STR_LIT>'][ns == ni + <NUM_LIT:2>].min())[<NUM_LIT:0>]<EOL>upper = (current_end + next_start) // <NUM_LIT:2><EOL>bounds.append((sample, (int(lower), int(upper))))<EOL>lower = upper + <NUM_LIT:1><EOL><DEDENT>sn += <NUM_LIT:1><EOL><DEDENT>bounds.append((sample_list[-<NUM_LIT:1>], (int(upper) + <NUM_LIT:1>, len(ns))))<EOL>sections = {}<EOL>seen = {}<EOL>for s, (lo, hi) in bounds:<EOL><INDENT>if s not in seen:<EOL><INDENT>seen[s] = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>seen[s] += <NUM_LIT:1><EOL>s += '<STR_LIT>'.format(seen[s])<EOL><DEDENT>sections[s] = {'<STR_LIT>': dat['<STR_LIT>'][lo:hi]}<EOL>sections[s]['<STR_LIT>'] = sections[s]['<STR_LIT>'] - np.nanmin(sections[s]['<STR_LIT>'])<EOL>sections[s]['<STR_LIT>'] = {}<EOL>for k, v in dat['<STR_LIT>'].items():<EOL><INDENT>sections[s]['<STR_LIT>'][k] = v[lo:hi]<EOL><DEDENT>sections[s]['<STR_LIT>'] = d + datetime.timedelta(seconds=np.nanmin(sections[s]['<STR_LIT>']))<EOL><DEDENT>if savedir is None:<EOL><INDENT>savedir = os.path.join(os.path.dirname(os.path.abspath(data_file)), os.path.splitext(os.path.basename(data_file))[<NUM_LIT:0>] + '<STR_LIT>')<EOL><DEDENT>if not os.path.isdir(savedir):<EOL><INDENT>os.makedirs(savedir)<EOL><DEDENT>header = ['<STR_LIT>'.format(datetime.datetime.now().strftime('<STR_LIT>'))]<EOL>if '<STR_LIT:date>' not in meta:<EOL><INDENT>header.append('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>header.append('<STR_LIT>')<EOL>header.append('<STR_LIT>')<EOL>header.append('<STR_LIT>')<EOL><DEDENT>flist = [savedir]<EOL>for s, dat in sections.items():<EOL><INDENT>iheader = header.copy()<EOL>iheader.append('<STR_LIT>'.format(s))<EOL>iheader.append('<STR_LIT>'.format(dat['<STR_LIT>'].strftime('<STR_LIT>')))<EOL>iheader = '<STR_LIT:\\n>'.join(iheader) + '<STR_LIT:\\n>'<EOL>out = pd.DataFrame({analyte_2_namemass(k): v for k, v in dat['<STR_LIT>'].items()}, index=dat['<STR_LIT>'])<EOL>out.index.name = '<STR_LIT>'<EOL>csv = out.to_csv()<EOL>with open('<STR_LIT>'.format(savedir, s), '<STR_LIT:w>') as f:<EOL><INDENT>f.write(iheader)<EOL>f.write(csv)<EOL><DEDENT>flist.append('<STR_LIT>'.format(s))<EOL><DEDENT>print(\"<STR_LIT>\".format(n, '<STR_LIT:\\n>'.join(flist)))<EOL>return None<EOL>", "docstring": "TODO: Check for existing files in savedir, don't overwrite?", "id": "f2446:m1"}
{"signature": "def residual_plots(df, rep_stats=None, els=['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:B>']):", "body": "<EOL>As = []<EOL>Rs = []<EOL>analytes = [c for c in df.columns if ('<STR_LIT:/>' not in c)]<EOL>ratios = [c for c in df.columns if ('<STR_LIT:/>' in c)]<EOL>for e in els:<EOL><INDENT>if e == '<STR_LIT>':<EOL><INDENT>As.append('<STR_LIT>')<EOL><DEDENT>elif e == '<STR_LIT>':<EOL><INDENT>As.append('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>As.append([a for a in analytes if e in a][<NUM_LIT:0>])<EOL><DEDENT>Rs.append([r for r in ratios if e in r][<NUM_LIT:0>])<EOL><DEDENT>fig, axs = plt.subplots(len(els), <NUM_LIT:2>, figsize=(<NUM_LIT:5>, len(els) * <NUM_LIT:2>))<EOL>for i, (e, a) in enumerate(zip(Rs, As)):<EOL><INDENT>lax, hax = axs[i]<EOL>x = df.loc[:, e].values<EOL>yl = df.loc[:, a].values<EOL>c = element_colour(fmt_el(a))<EOL>u = '<STR_LIT>'<EOL>rl = yl - x<EOL>lax.scatter(x, rl, c=c, s=<NUM_LIT:15>, lw=<NUM_LIT:0.5>, edgecolor='<STR_LIT:k>', alpha=<NUM_LIT:0.5>)<EOL>rl = rl[~np.isnan(rl)]<EOL>lims = np.percentile(rl, [<NUM_LIT>, <NUM_LIT:1>])<EOL>lims += lims.ptp() * np.array((-<NUM_LIT>, <NUM_LIT>))<EOL>bins = np.linspace(*lims, <NUM_LIT:100>)<EOL>kdl = stats.gaussian_kde(rl, <NUM_LIT>)<EOL>hax.fill_betweenx(bins, kdl(bins), facecolor=c, alpha=<NUM_LIT>, edgecolor='<STR_LIT:k>', lw=<NUM_LIT:0.5>, label='<STR_LIT>')<EOL>hax.set_xlim([<NUM_LIT:0>, hax.get_xlim()[-<NUM_LIT:1>]])<EOL>lax.set_ylabel(e + '<STR_LIT>'+ u + '<STR_LIT:)>')<EOL>lax.text(<NUM_LIT>,<NUM_LIT>,fmt_RSS(rl), fontsize=<NUM_LIT:8>,<EOL>ha='<STR_LIT:left>', va='<STR_LIT>', transform=lax.transAxes)<EOL>xlim = np.percentile(x[~np.isnan(x)], [<NUM_LIT:0>, <NUM_LIT>])<EOL>lax.set_xlim(xlim)<EOL>for ax in axs[i]:<EOL><INDENT>ax.set_ylim(lims)<EOL>ax.axhline(<NUM_LIT:0>, c='<STR_LIT:k>', ls='<STR_LIT>', alpha=<NUM_LIT>)<EOL>if rep_stats is not None:<EOL><INDENT>ax.axhspan(-rep_stats[e][<NUM_LIT:0>] * <NUM_LIT:2>, rep_stats[e][<NUM_LIT:0>] * <NUM_LIT:2>, color=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT>), zorder=-<NUM_LIT:1>)<EOL><DEDENT>if not ax.is_first_col():<EOL><INDENT>ax.set_yticklabels([])<EOL><DEDENT>if ax.is_last_row():<EOL><INDENT>hax.set_xlabel('<STR_LIT>')<EOL>lax.set_xlabel('<STR_LIT>')<EOL><DEDENT>if ax.is_first_row():<EOL><INDENT>lax.set_title('<STR_LIT>', loc='<STR_LIT:left>')<EOL><DEDENT><DEDENT><DEDENT>fig.tight_layout()<EOL>return fig, axs<EOL>", "docstring": "Function for plotting Test User and LAtools data comparison.\n\nParameters\n----------\ndf : pandas.DataFrame\n    A dataframe containing reference ('X/Ca_r'), test user \n    ('X/Ca_t') and LAtools ('X123') data.\nrep_stats : dict\n    Reproducibility stats of the reference data produced by\n    `pairwise_reproducibility`\nels : list\n    list of elements (names only) to plot.", "id": "f2447:m2"}
{"signature": "def summary_stats(x, y, nm=None):", "body": "<EOL>if isinstance(nm, str):<EOL><INDENT>nm = [nm]<EOL>", "docstring": "Compute summary statistics for paired x, y data.\n\nTests\n-----\n\nParameters\n----------\nx, y : array-like\n    Data to compare\nnm : str (optional)\n    Index value of created dataframe.\n\nReturns\n-------\npandas dataframe of statistics.", "id": "f2450:m3"}
{"signature": "def comparison_plots(df, els=['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']):", "body": "<EOL>As = []<EOL>Rs = []<EOL>analytes = [c for c in df.columns if ('<STR_LIT>' not in c) and ('<STR_LIT>' not in c)]<EOL>ratios = [c for c in df.columns if ('<STR_LIT>' in c)]<EOL>for e in els:<EOL><INDENT>if e == '<STR_LIT>':<EOL><INDENT>As.append('<STR_LIT>')<EOL><DEDENT>elif e == '<STR_LIT>':<EOL><INDENT>As.append('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>As.append([a for a in analytes if e in a][<NUM_LIT:0>])<EOL><DEDENT>Rs.append([r for r in ratios if e in r][<NUM_LIT:0>][:-<NUM_LIT:2>])<EOL><DEDENT>fig, axs = plt.subplots(len(els), <NUM_LIT:3>, figsize=(<NUM_LIT>, len(els) * <NUM_LIT:2>))<EOL>for i, (e, a) in enumerate(zip(Rs, As)):<EOL><INDENT>if a == '<STR_LIT>':<EOL><INDENT>m = <NUM_LIT><EOL>u = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>m = <NUM_LIT:1><EOL>u = '<STR_LIT>'<EOL><DEDENT>c = element_colour(a)<EOL>tax, lax, hax = axs[i]<EOL>x = df.loc[:, e + '<STR_LIT>'].values * m<EOL>yt = df.loc[:, e + '<STR_LIT>'].values * m<EOL>yl = df.loc[:, a].values * m<EOL>rt = yt - x<EOL>rl = yl - x<EOL>tax.scatter(x, yt, c=c, s=<NUM_LIT:15>, lw=<NUM_LIT:0.5>, edgecolor='<STR_LIT:k>', alpha=<NUM_LIT:0.5>)<EOL>lax.scatter(x, yl, c=c, s=<NUM_LIT:15>, lw=<NUM_LIT:0.5>, edgecolor='<STR_LIT:k>', alpha=<NUM_LIT:0.5>)<EOL>rt = rt[~np.isnan(rt)]<EOL>rl = rl[~np.isnan(rl)]<EOL>lims = np.percentile(np.hstack([rt, rl]), [<NUM_LIT>, <NUM_LIT:1>])<EOL>lims += lims.ptp() * np.array((-<NUM_LIT>, <NUM_LIT>))<EOL>bins = np.linspace(*lims, <NUM_LIT:100>)<EOL>kdt = stats.gaussian_kde(rt, <NUM_LIT>)<EOL>kdl = stats.gaussian_kde(rl, <NUM_LIT>)<EOL>hax.fill_between(bins, kdl(bins), facecolor=c, alpha=<NUM_LIT>, edgecolor='<STR_LIT:k>', lw=<NUM_LIT:0.5>, label='<STR_LIT>')<EOL>hax.fill_between(bins, kdt(bins), facecolor=c, alpha=<NUM_LIT>, edgecolor='<STR_LIT:k>', lw=<NUM_LIT:0.5>, label='<STR_LIT>')<EOL>hax.set_ylim([<NUM_LIT:0>, hax.get_ylim()[-<NUM_LIT:1>]])<EOL>hax.set_xlim(lims)<EOL>hax.axvline(<NUM_LIT:0>, c='<STR_LIT:k>', ls='<STR_LIT>', alpha=<NUM_LIT>)<EOL>hax.set_ylabel('<STR_LIT>')<EOL>tax.set_ylabel(e + '<STR_LIT>'+ u + '<STR_LIT:)>')<EOL>tax.text(<NUM_LIT>,<NUM_LIT>,fmt_RSS(rt), fontsize=<NUM_LIT:8>,<EOL>ha='<STR_LIT:left>', va='<STR_LIT>', transform=tax.transAxes)<EOL>lax.text(<NUM_LIT>,<NUM_LIT>,fmt_RSS(rl), fontsize=<NUM_LIT:8>,<EOL>ha='<STR_LIT:left>', va='<STR_LIT>', transform=lax.transAxes)<EOL>xlim = np.percentile(x[~np.isnan(x)], [<NUM_LIT:0>, <NUM_LIT>])<EOL>for ax in [tax, lax]:<EOL><INDENT>ax.set_xlim(xlim)<EOL>ax.set_ylim(xlim)<EOL>ax.plot(xlim, xlim, c='<STR_LIT:k>', ls='<STR_LIT>', alpha=<NUM_LIT>)<EOL><DEDENT>for ax in axs[i]:<EOL><INDENT>if ax.is_last_row():<EOL><INDENT>hax.set_xlabel('<STR_LIT>')<EOL>tax.set_xlabel('<STR_LIT>')<EOL>lax.set_xlabel('<STR_LIT>')<EOL>hax.legend(fontsize=<NUM_LIT:8>)<EOL><DEDENT>if ax.is_first_row():<EOL><INDENT>tax.set_title('<STR_LIT>', loc='<STR_LIT:left>')<EOL>lax.set_title('<STR_LIT>', loc='<STR_LIT:left>')<EOL><DEDENT><DEDENT><DEDENT>fig.tight_layout()<EOL>return fig, axs<EOL>", "docstring": "Function for plotting Test User and LAtools data comparison.\n\nParameters\n----------\ndf : pandas.DataFrame\n    A dataframe containing reference ('X/Ca_r'), test user \n    ('X/Ca_t') and LAtools ('X123') data.\nels : list\n    list of elements (names only) to plot.", "id": "f2452:m4"}
{"signature": "def rangecalcx(x, pad=<NUM_LIT>):", "body": "mn = np.nanmin(x)<EOL>mx = np.nanmax(x)<EOL>rn = mx - mn<EOL>return (mn - pad * rn, mx + pad * rn)<EOL>", "docstring": "Calculate padded range limits for axes.", "id": "f2452:m2"}
{"signature": "def residual_plots(df, rep_stats=None, els=['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']):", "body": "<EOL>As = []<EOL>Rs = []<EOL>analytes = [c for c in df.columns if ('<STR_LIT>' not in c) and ('<STR_LIT>' not in c)]<EOL>ratios = [c for c in df.columns if ('<STR_LIT>' in c)]<EOL>for e in els:<EOL><INDENT>if e == '<STR_LIT>':<EOL><INDENT>As.append('<STR_LIT>')<EOL><DEDENT>elif e == '<STR_LIT>':<EOL><INDENT>As.append('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>As.append([a for a in analytes if e in a][<NUM_LIT:0>])<EOL><DEDENT>Rs.append([r for r in ratios if e in r][<NUM_LIT:0>][:-<NUM_LIT:2>])<EOL><DEDENT>fig, axs = plt.subplots(len(els), <NUM_LIT:3>, figsize=(<NUM_LIT>, len(els) * <NUM_LIT:2>))<EOL>for i, (e, a) in enumerate(zip(Rs, As)):<EOL><INDENT>if a == '<STR_LIT>':<EOL><INDENT>m = <NUM_LIT><EOL>u = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>m = <NUM_LIT:1><EOL>u = '<STR_LIT>'<EOL><DEDENT>tax, lax, hax = axs[i]<EOL>x = df.loc[:, e + '<STR_LIT>'].values * m<EOL>yt = df.loc[:, e + '<STR_LIT>'].values * m<EOL>yl = df.loc[:, a].values * m<EOL>rt = yt - x<EOL>rl = yl - x<EOL>tax.scatter(x, rt, c=element_colour(a), s=<NUM_LIT:15>, lw=<NUM_LIT:0.5>, edgecolor='<STR_LIT:k>', alpha=<NUM_LIT:0.5>)<EOL>lax.scatter(x, rl, c=element_colour(a), s=<NUM_LIT:15>, lw=<NUM_LIT:0.5>, edgecolor='<STR_LIT:k>', alpha=<NUM_LIT:0.5>)<EOL>rt = rt[~np.isnan(rt)]<EOL>rl = rl[~np.isnan(rl)]<EOL>lims = np.percentile(np.hstack([rt, rl]), [<NUM_LIT>, <NUM_LIT:1>])<EOL>lims += lims.ptp() * np.array((-<NUM_LIT>, <NUM_LIT>))<EOL>bins = np.linspace(*lims, <NUM_LIT:100>)<EOL>kdt = stats.gaussian_kde(rt, <NUM_LIT>)<EOL>kdl = stats.gaussian_kde(rl, <NUM_LIT>)<EOL>hax.fill_betweenx(bins, kdl(bins), facecolor=element_colour(a), alpha=<NUM_LIT>, edgecolor='<STR_LIT:k>', lw=<NUM_LIT:0.5>, label='<STR_LIT>')<EOL>hax.fill_betweenx(bins, kdt(bins), facecolor=element_colour(a), alpha=<NUM_LIT>, edgecolor='<STR_LIT:k>', lw=<NUM_LIT:0.5>, label='<STR_LIT>')<EOL>hax.set_xlim([<NUM_LIT:0>, hax.get_xlim()[-<NUM_LIT:1>]])<EOL>tax.set_ylabel(e + '<STR_LIT>'+ u + '<STR_LIT:)>')<EOL>tax.text(<NUM_LIT>,<NUM_LIT>,fmt_RSS(rt), fontsize=<NUM_LIT:8>,<EOL>ha='<STR_LIT:left>', va='<STR_LIT>', transform=tax.transAxes)<EOL>lax.text(<NUM_LIT>,<NUM_LIT>,fmt_RSS(rl), fontsize=<NUM_LIT:8>,<EOL>ha='<STR_LIT:left>', va='<STR_LIT>', transform=lax.transAxes)<EOL>xlim = np.percentile(x[~np.isnan(x)], [<NUM_LIT:0>, <NUM_LIT>])<EOL>for ax in [tax, lax]:<EOL><INDENT>ax.set_xlim(xlim)<EOL><DEDENT>for ax in axs[i]:<EOL><INDENT>ax.set_ylim(lims)<EOL>ax.axhline(<NUM_LIT:0>, c='<STR_LIT:k>', ls='<STR_LIT>', alpha=<NUM_LIT>)<EOL>if rep_stats is not None:<EOL><INDENT>ax.axhspan(-rep_stats[e][<NUM_LIT:0>] * <NUM_LIT:2>, rep_stats[e][<NUM_LIT:0>] * <NUM_LIT:2>, color=(<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT>), zorder=-<NUM_LIT:1>)<EOL><DEDENT>if not ax.is_first_col():<EOL><INDENT>ax.set_yticklabels([])<EOL><DEDENT>if ax.is_last_row():<EOL><INDENT>hax.set_xlabel('<STR_LIT>')<EOL>tax.set_xlabel('<STR_LIT>')<EOL>lax.set_xlabel('<STR_LIT>')<EOL><DEDENT>if ax.is_first_row():<EOL><INDENT>tax.set_title('<STR_LIT>', loc='<STR_LIT:left>')<EOL>lax.set_title('<STR_LIT>', loc='<STR_LIT:left>')<EOL><DEDENT><DEDENT><DEDENT>fig.tight_layout()<EOL>return fig, axs<EOL>", "docstring": "Function for plotting Test User and LAtools data comparison.\n\nParameters\n----------\ndf : pandas.DataFrame\n    A dataframe containing reference ('X/Ca_r'), test user \n    ('X/Ca_t') and LAtools ('X123') data.\nrep_stats : dict\n    Reproducibility stats of the reference data produced by\n    `pairwise_reproducibility`\nels : list\n    list of elements (names only) to plot.", "id": "f2452:m5"}
{"signature": "def read_codeml_output(<EOL>filename,<EOL>df,<EOL>altall_cutoff=<NUM_LIT>,<EOL>):", "body": "<EOL>with open(filename, '<STR_LIT:r>') as f:<EOL><INDENT>data = f.read()<EOL><DEDENT>regex = re.compile('<STR_LIT>')<EOL>trees = regex.findall(data)<EOL>anc_tree = trees[<NUM_LIT:2>]<EOL>tip_tree = dendropy.Tree.get(data=trees[<NUM_LIT:0>], schema='<STR_LIT>')<EOL>anc_tree = dendropy.Tree.get(data=trees[<NUM_LIT:2>], schema='<STR_LIT>')<EOL>tree = tip_tree<EOL>ancestors = anc_tree.internal_nodes()<EOL>for i, node in enumerate(tree.internal_nodes()):<EOL><INDENT>node.label = ancestors[i].label<EOL><DEDENT>df['<STR_LIT>'] = None<EOL>for node in tree.postorder_node_iter():<EOL><INDENT>if node.parent_node is None:<EOL><INDENT>pass<EOL><DEDENT>elif node.is_leaf():<EOL><INDENT>node_label = node.taxon.label<EOL>parent_label = node.parent_node.label<EOL>df.loc[df.uid == node_label, '<STR_LIT>'] = node_label<EOL>parent_id = df.loc[df.uid == node_label, '<STR_LIT>'].values[<NUM_LIT:0>]<EOL>df.loc[df.id == parent_id, '<STR_LIT>'] = node.parent_node.label<EOL><DEDENT>elif node.is_internal():<EOL><INDENT>label = node.label<EOL>parent_id = df.loc[df.reconstruct_label == label, '<STR_LIT>'].values[<NUM_LIT:0>]<EOL>df.loc[df.id == parent_id, '<STR_LIT>'] = node.parent_node.label<EOL><DEDENT><DEDENT>node_regex = re.compile(\"\"\"<STR_LIT>\"\"\")<EOL>node_num_regex = re.compile(\"<STR_LIT>\")<EOL>df['<STR_LIT>'] = None<EOL>df['<STR_LIT>'] = None<EOL>df['<STR_LIT>'] = None<EOL>df['<STR_LIT>'] = None<EOL>for node in node_regex.findall(data):<EOL><INDENT>node_label = node_num_regex.search(node).group(<NUM_LIT:0>)<EOL>site_regex = re.compile(\"<STR_LIT>\")<EOL>ml_sequence, ml_posterior, alt_sequence, alt_posterior = [], [], [], []<EOL>for site in site_regex.findall(node):<EOL><INDENT>scores = [float(site[i+<NUM_LIT:2>:i+<NUM_LIT:7>]) for i in range(<NUM_LIT:0>,len(site), <NUM_LIT:9>)]<EOL>residues = [site[i] for i in range(<NUM_LIT:0>, len(site), <NUM_LIT:9>)]<EOL>sorted_score_index = [i[<NUM_LIT:0>] for i in sorted(<EOL>enumerate(scores),<EOL>key=lambda x:x[<NUM_LIT:1>],<EOL>reverse=True)]<EOL>ml_idx = sorted_score_index[<NUM_LIT:0>]<EOL>alt_idx = sorted_score_index[<NUM_LIT:1>]<EOL>ml_sequence.append(residues[ml_idx])<EOL>ml_posterior.append(scores[ml_idx])<EOL>if scores[alt_idx] < altall_cutoff:<EOL><INDENT>alt_idx = ml_idx<EOL><DEDENT>alt_sequence.append(residues[alt_idx])<EOL>alt_posterior.append(scores[alt_idx])<EOL><DEDENT>keys = [<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\"<EOL>]<EOL>vals = [<EOL>\"<STR_LIT>\".join(ml_sequence),<EOL>sum(ml_posterior) / len(ml_posterior),<EOL>\"<STR_LIT>\".join(alt_sequence),<EOL>sum(alt_posterior) / len(alt_posterior),<EOL>]<EOL>df.loc[df.reconstruct_label == node_label, keys] = vals<EOL><DEDENT>return df<EOL>", "docstring": "Read codeml file.", "id": "f2459:m0"}
{"signature": "@staticmethod<EOL><INDENT>def status(s):<DEDENT>", "body": "print('<STR_LIT>'.format(s))<EOL>", "docstring": "Prints things in bold.", "id": "f2460:c0:m0"}
{"signature": "def is_applicable(self, date_string, strip_timezone=False, settings=None):", "body": "if strip_timezone:<EOL><INDENT>date_string, _ = pop_tz_offset_from_string(date_string, as_offset=False)<EOL><DEDENT>date_string = self._translate_numerals(date_string)<EOL>if settings.NORMALIZE:<EOL><INDENT>date_string = normalize_unicode(date_string)<EOL><DEDENT>date_string = self._simplify(date_string, settings=settings)<EOL>dictionary = self._get_dictionary(settings)<EOL>date_tokens = dictionary.split(date_string)<EOL>return dictionary.are_tokens_valid(date_tokens)<EOL>", "docstring": "Check if the locale is applicable to translate date string.\n\n:param date_string:\n    A string representing date and/or time in a recognizably valid format.\n:type date_string: str|unicode\n\n:param strip_timezone:\n    If True, timezone is stripped from date string.\n:type strip_timezone: bool\n\n:return: boolean value representing if the locale is applicable for the date string or not.", "id": "f2485:c0:m1"}
{"signature": "def get_locale_map(self, languages=None, locales=None, region=None,<EOL>use_given_order=False, allow_conflicting_locales=False):", "body": "return OrderedDict(self._load_data(<EOL>languages=languages, locales=locales, region=region, use_given_order=use_given_order,<EOL>allow_conflicting_locales=allow_conflicting_locales))<EOL>", "docstring": "Get an ordered mapping with locale codes as keys\nand corresponding locale instances as values.\n\n:param languages:\n    A list of language codes, e.g. ['en', 'es', 'zh-Hant'].\n    If locales are not given, languages and region are\n    used to construct locales to load.\n:type languages: list\n\n:param locales:\n    A list of codes of locales which are to be loaded,\n    e.g. ['fr-PF', 'qu-EC', 'af-NA']\n:type locales: list\n\n:param region:\n    A region code, e.g. 'IN', '001', 'NE'.\n    If locales are not given, languages and region are\n    used to construct locales to load.\n:type region: str|unicode\n\n:param use_given_order:\n    If True, the returned mapping is ordered in the order locales are given.\n:type allow_redetect_language: bool\n\n:param allow_conflicting_locales:\n    if True, locales with same language and different region can be loaded.\n:type allow_conflicting_locales: bool\n\n:return: ordered locale code to locale instance mapping", "id": "f2488:c0:m0"}
{"signature": "def search_dates(text, languages=None, settings=None, add_detected_language=False):", "body": "result = _search_with_detection.search_dates(<EOL>text=text, languages=languages, settings=settings<EOL>)<EOL>language, dates = result.get('<STR_LIT>'), result.get('<STR_LIT>')<EOL>if dates:<EOL><INDENT>if add_detected_language:<EOL><INDENT>dates = [date + (language, ) for date in dates]<EOL><DEDENT>return dates<EOL><DEDENT>", "docstring": "Find all substrings of the given string which represent date and/or time and parse them.\n\n        :param text:\n            A string in a natural language which may contain date and/or time expressions.\n        :type text: str|unicode\n\n        :param languages:\n            A list of two letters language codes.e.g. ['en', 'es']. If languages are given, it will\n            not attempt to detect the language.\n        :type languages: list\n\n        :param settings:\n               Configure customized behavior using settings defined in :mod:`dateparser.conf.Settings`.\n        :type settings: dict\n\n        :param add_detected_language:\n               Indicates if we want the detected language returned in the tuple.\n        :type add_detected_language: bool\n\n        :return: Returns list of tuples containing:\n                 substrings representing date and/or time, corresponding :mod:`datetime.datetime`\n                 object and detected language if *add_detected_language* is True.\n                 Returns None if no dates that can be parsed are found.\n        :rtype: list\n        :raises: ValueError - Unknown Language\n\n        >>> from dateparser.search import search_dates\n        >>> search_dates('The first artificial Earth satellite was launched on 4 October 1957.')\n        [('on 4 October 1957', datetime.datetime(1957, 10, 4, 0, 0))]\n\n        >>> search_dates('The first artificial Earth satellite was launched on 4 October 1957.', add_detected_language=True)\n        [('on 4 October 1957', datetime.datetime(1957, 10, 4, 0, 0), 'en')]\n\n        >>> search_dates(\"The client arrived to the office for the first time in March 3rd, 2004 and got serviced, after a couple of months, on May 6th 2004, the customer returned indicating a defect on the part\")\n        [('in March 3rd, 2004 and', datetime.datetime(2004, 3, 3, 0, 0)),\n         ('on May 6th 2004', datetime.datetime(2004, 5, 6, 0, 0))]", "id": "f2781:m0"}
{"signature": "def _parse_time(self, date_string, settings):", "body": "date_string = PATTERN.sub('<STR_LIT>', date_string)<EOL>date_string = re.sub(r'<STR_LIT>', '<STR_LIT>', date_string)<EOL>try:<EOL><INDENT>return time_parser(date_string)<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Attemps to parse time part of date strings like '1 day ago, 2 PM", "id": "f2782:c0:m2"}
{"signature": "def register_resources(self, **resources):", "body": "for key, resource in resources.items():<EOL><INDENT>if key in self._resources:<EOL><INDENT>raise AlreadyExistsException('<STR_LIT>'.format(key))<EOL><DEDENT>self._init_resource(key, resource)<EOL><DEDENT>", "docstring": "Register resources with the ResourceManager.", "id": "f2792:c1:m1"}
{"signature": "def __call__(self, context):", "body": "yield None<EOL>", "docstring": "Called by DataAccessContext when a resource is first\nrequested within a particular context. This generator\nshould yield one value that represents the resource\nfor `context`. It could open a new connection, or just\nreturn the current resource. After yielding, close\nthe resource if it is no longer needed.\n\nExample::\n\n    connection = self.new_connection()\n    try:\n        yield connection\n    except:\n        connection.rollback()\n        connection.close()\n    else:\n        # No errors\n        connection.commit()\n        connection.close()", "id": "f2792:c0:m1"}
{"signature": "def replace_resource(self, key, resource):", "body": "return self._init_resource(key, resource)<EOL>", "docstring": "Replace a Resource with another. Usually this is a bad\nidea but is often done in testing to replace a Resource\nwith a mock version. It's also used for practical\nreasons if you need to swap out resources for different\nframework implementations (ex: Greenlet version vs\nthreaded)\n\n:param key: Name of resource\n:param resource: Resource", "id": "f2792:c1:m2"}
{"signature": "def __getattr__(self, name):", "body": "if self._state not in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>if name not in self._resources:<EOL><INDENT>if self._state not in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>resource = self.data_manager.get_resource(name)<EOL>if resource:<EOL><INDENT>self._resource_generators[name] = resource(self)<EOL>try:<EOL><INDENT>self._resources[name] = next(self._resource_generators[name])<EOL><DEDENT>except StopIteration:<EOL><INDENT>raise ResourceSetupException('<STR_LIT>'.format(resource))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise AttributeError('<STR_LIT>'.format(name))<EOL><DEDENT><DEDENT>return self._resources[name]<EOL>", "docstring": "Gets a Resource from the DataManager and initializes\nit for the request.", "id": "f2794:c1:m6"}
{"signature": "def _setup_hook(self):", "body": "pass<EOL>", "docstring": "Handle any thing that needs to happen before start of the context.", "id": "f2794:c1:m9"}
{"signature": "def __exit__(self, exc_type=None, exc_value=None, traceback=None):", "body": "assert self._state in ('<STR_LIT>', '<STR_LIT>'), '<STR_LIT>'<EOL>self._state = '<STR_LIT>'<EOL>if exc_type is not None and exc_value is None:<EOL><INDENT>exc_value = exc_type()<EOL><DEDENT>generators, self._middleware_generators = self._middleware_generators, None<EOL>while generators:<EOL><INDENT>__, generator = generators.pop()<EOL>try:<EOL><INDENT>if self._exit(generator, exc_type, exc_value, traceback):<EOL><INDENT>exc_type, exc_value, traceback = (None, None, None)<EOL><DEDENT><DEDENT>except:<EOL><INDENT>exc_type, exc_value, traceback = sys.exc_info()<EOL>exc_value = exc_value or exc_type()<EOL><DEDENT><DEDENT>try:<EOL><INDENT>self._teardown_hook(exc_value)<EOL><DEDENT>except:<EOL><INDENT>self._resource_exit_errors.append(sys.exc_info())<EOL><DEDENT>finally:<EOL><INDENT>resources, self._resource_generators = self._resource_generators, None<EOL>while resources:<EOL><INDENT>__, resource_generator = resources.popitem()<EOL>try:<EOL><INDENT>self._exit(resource_generator, exc_type, exc_value, traceback)<EOL><DEDENT>except:<EOL><INDENT>self._resource_exit_errors.append(sys.exc_info())<EOL><DEDENT><DEDENT>try:<EOL><INDENT>if exc_type:<EOL><INDENT>raise exc_type(exc_value).with_traceback(traceback)<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>try:<EOL><INDENT>self._final_hook(exc_value)<EOL><DEDENT>finally:<EOL><INDENT>self.data_manager.ctx_stack.pop()<EOL>self._state = '<STR_LIT>'<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Close all open resources, middleware and\nremove context from stack\n\nIn-context exceptions (exceptions raised between ``__enter__``\nand ``__exit__``) are propagated to Middleware, Resources, and\neventually raised outside the ``DataAccessContext``. Resources\nare created in-context so if a Resource raises an exception\nduring setup, it treated the same as all in-context exceptions.\n\nMiddleware may suppress or replace the in-context exception. If\nthere is an unhandled exception raised in-context or by middleware\nit is guaranteed to be raised outside the ``DataAccessContext``.\n\nIf a Resource raises an exception, it is collected and all\nother Resource will still close. Resource exit exceptions do not\npropagate. The Resource will only see the in-context/middleware\nexception. To access Resource exit exceptions, use\n``DataAccessContext.get_resource_exit_errors()``.", "id": "f2794:c1:m4"}
{"signature": "def __getattr__(self, key):", "body": "return self.get(key)<EOL>", "docstring": "Returns meta value for key. Returns ``None`` if the\nkey has not been set.", "id": "f2794:c0:m2"}
{"signature": "def register_resources(self, **resources):", "body": "self._resource_manager.register_resources(**resources)<EOL>", "docstring": "Register Resources with the ResourceManager.", "id": "f2797:c1:m3"}
{"signature": "def replace_service(self, key, service):", "body": "return self._init_service(key, service)<EOL>", "docstring": "Replace a Service with another. Usually this is a bad\nidea but is often done in testing to replace a Service\nwith a mock version. It's also used for practical\nreasons if you need to swap out services for different\nframework implementations (ex: Greenlet version vs\nthreaded)\n\n:param key: Name of service\n:param service: Service", "id": "f2797:c0:m2"}
{"signature": "def register_context_middleware(self, *middleware):", "body": "for m in middleware:<EOL><INDENT>if not is_generator(m):<EOL><INDENT>raise Exception('<STR_LIT>'.format(m))<EOL><DEDENT><DEDENT>self._middleware.extend(middleware)<EOL>", "docstring": ":param middleware: Middleware in order of execution", "id": "f2797:c1:m1"}
{"signature": "def encrypt(pubkey, password):", "body": "key = load_key(pubkey)<EOL>encrypted_password = key.encrypt(password, PKCS1v15())<EOL>return base64.b64encode(encrypted_password)<EOL>", "docstring": "Encrypt password using given RSA public key and encode it with base64.\n\n    The encrypted password can only be decrypted by someone with the\n    private key (in this case, only Travis).", "id": "f2810:m1"}
{"signature": "def update_travis_deploy_password(encrypted_password):", "body": "config = load_yaml_config(TRAVIS_CONFIG_FILE)<EOL>config['<STR_LIT>']['<STR_LIT:password>'] = dict(secure=encrypted_password)<EOL>save_yaml_config(TRAVIS_CONFIG_FILE, config)<EOL>line = ('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>prepend_line(TRAVIS_CONFIG_FILE, line)<EOL>", "docstring": "Put `encrypted_password` into the deploy section of .travis.yml.", "id": "f2810:m6"}
{"signature": "def load_yaml_config(filepath):", "body": "with open(filepath) as f:<EOL><INDENT>return yaml.load(f)<EOL><DEDENT>", "docstring": "Load yaml config file at the given path.", "id": "f2810:m4"}
{"signature": "def read(self):", "body": "try:<EOL><INDENT>data = load(open(self.file), Loader)<EOL><DEDENT>except (UnicodeDecodeError, YAMLError) as e:<EOL><INDENT>raise InvalidConfig(self.file, '<STR_LIT:{}>'.format(e))<EOL><DEDENT>try:<EOL><INDENT>validate(data, SCHEMA)<EOL><DEDENT>except ValidationError as e:<EOL><INDENT>raise InvalidConfig(self.file, e)<EOL><DEDENT>self.update(data)<EOL>", "docstring": "Parse and validate the config file. The read data is accessible as a dictionary in this instance\n\n        :return: None", "id": "f2811:c0:m1"}
{"signature": "def get_file_group(file):", "body": "try:<EOL><INDENT>return getgrgid(os.stat(file).st_uid)[<NUM_LIT:0>]<EOL><DEDENT>except KeyError:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>", "docstring": "Get file group id\n\n    :param file: Path to file\n    :return: group id\n    :rtype: int", "id": "f2811:m1"}
{"signature": "def __init__(self, file, ignore_perms=False, **kwargs):", "body": "super(Config, self).__init__(**kwargs)<EOL>if not os.path.lexists(file):<EOL><INDENT>raise ConfigFileNotFoundError(file)<EOL><DEDENT>if not ignore_perms and ((not os.getuid() and not only_root_write(file)) or oth_w_perm(file)):<EOL><INDENT>file = os.path.abspath(file)<EOL>raise SecurityException(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>file=file, user=get_file_owner(file),<EOL>group=get_file_group(file), perms=os.stat(file).st_mode & <NUM_LIT>,<EOL>msg='<STR_LIT>' if os.getuid()<EOL>else '<STR_LIT>'))<EOL><DEDENT>self.file = file<EOL>self.read()<EOL>", "docstring": "Set the config file and validate file permissions\n\n        :param str file: path to file\n        :param kwargs: default values in dict", "id": "f2811:c0:m0"}
{"signature": "def discovery_print(pkt):", "body": "if pkt.src in mac_id_list:<EOL><INDENT>return<EOL><DEDENT>mac_id_list.append(pkt.src)<EOL>text = pkt_text(pkt)<EOL>click.secho(text, fg='<STR_LIT>') if '<STR_LIT>' in text else click.echo(text)<EOL>", "docstring": "Scandevice callback. Register src mac to avoid src repetition.\n    Print device on screen.\n\n    :param scapy.packet.Packet pkt: Scapy Packet\n    :return: None", "id": "f2813:m1"}
{"signature": "def get_method(self):", "body": "return self.default_method<EOL>", "docstring": "Get HTTP method. By default default_method\n\n        :return: HTTP method\n        :rtype: str", "id": "f2823:c3:m2"}
{"signature": "def get_body(self):", "body": "if self.default_body:<EOL><INDENT>return self.default_body<EOL><DEDENT>data = self.data.get('<STR_LIT:data>')<EOL>if isinstance(data, dict):<EOL><INDENT>return json.dumps(data)<EOL><DEDENT>return data<EOL>", "docstring": "Return \"data\" value on self.data\n\n        :return: data to send\n        :rtype: str", "id": "f2823:c4:m1"}
{"signature": "def validate(self):", "body": "if (self.data.get('<STR_LIT>') or self.data.get('<STR_LIT:body>')) andself.data.get('<STR_LIT>', '<STR_LIT>').lower() not in CONTENT_TYPE_METHODS:<EOL><INDENT>raise InvalidConfig(<EOL>extra_body='<STR_LIT>'<EOL>'<STR_LIT>'.format('<STR_LIT:U+002CU+0020>'.join(CONTENT_TYPE_METHODS), self.name)<EOL>)<EOL><DEDENT>self.data['<STR_LIT>'] = CONTENT_TYPE_ALIASES.get(self.data.get('<STR_LIT>'),<EOL>self.data.get('<STR_LIT>'))<EOL>form_type = CONTENT_TYPE_ALIASES['<STR_LIT>']<EOL>if self.data.get('<STR_LIT:body>') and (self.data.get('<STR_LIT>') or form_type) == form_type:<EOL><INDENT>try:<EOL><INDENT>self.data['<STR_LIT:body>'] = json.loads(self.data['<STR_LIT:body>'])<EOL><DEDENT>except JSONDecodeError:<EOL><INDENT>raise InvalidConfig(<EOL>extra_body='<STR_LIT>'.format(self.name)<EOL>)<EOL><DEDENT><DEDENT>", "docstring": "Check self.data. Raise InvalidConfig on error\n\n        :return: None", "id": "f2823:c2:m0"}
{"signature": "def get_url(self):", "body": "if not self.data[self.execute_name]:<EOL><INDENT>raise InvalidConfig(extra_body='<STR_LIT>'<EOL>'<STR_LIT>'.format(self.name))<EOL><DEDENT>if not self.data.get('<STR_LIT>'):<EOL><INDENT>raise InvalidConfig(extra_body='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(self.name))<EOL><DEDENT>url = self.url_pattern.format(event=self.data['<STR_LIT>'], key=self.data[self.execute_name])<EOL>return url<EOL>", "docstring": "IFTTT Webhook url\n\n        :return: url\n        :rtype: str", "id": "f2823:c7:m0"}
{"signature": "def get_headers(self):", "body": "headers = copy.copy(self.default_headers or {})<EOL>headers.update(self.data.get('<STR_LIT>') or {})<EOL>return headers<EOL>", "docstring": "Get HTTP Headers to send. By default default_headers\n\n        :return: HTTP Headers\n        :rtype: dict", "id": "f2823:c3:m4"}
{"signature": "def execute(self, root_allowed=False):", "body": "raise NotImplementedError<EOL>", "docstring": "Execute using self.data\n\n        :param bool root_allowed: Only used for ExecuteCmd\n        :return:", "id": "f2823:c0:m2"}
{"signature": "def run_as_cmd(cmd, user, shell='<STR_LIT>'):", "body": "to_execute = get_shell(shell) + [EXECUTE_SHELL_PARAM, cmd]<EOL>if user == '<STR_LIT:root>':<EOL><INDENT>return to_execute<EOL><DEDENT>return ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', user] + to_execute<EOL>", "docstring": "Get the arguments to execute a command as a user\n\n    :param str cmd: command to execute\n    :param user: User for use\n    :param shell: Bash, zsh, etc.\n    :return: arguments\n    :rtype: list", "id": "f2823:m1"}
{"signature": "def get_url(self):", "body": "url = super(ExecuteHomeAssistant, self).get_url()<EOL>if not self.data.get('<STR_LIT>'):<EOL><INDENT>raise InvalidConfig(extra_body='<STR_LIT>'.format(self.name))<EOL><DEDENT>url += '<STR_LIT>'.format(self.data['<STR_LIT>'])<EOL>return url<EOL>", "docstring": "Home assistant url\n\n        :return: url\n        :rtype: str", "id": "f2823:c5:m0"}
{"signature": "def execute_cmd(cmd, cwd=None, timeout=<NUM_LIT:5>):", "body": "p = subprocess.Popen(cmd, cwd=cwd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)<EOL>try:<EOL><INDENT>p.wait(timeout=timeout)<EOL><DEDENT>except subprocess.TimeoutExpired:<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>stdout, stderr = p.stdout.read(), p.stderr.read()<EOL>if sys.version_info >= (<NUM_LIT:3>,):<EOL><INDENT>stdout, stderr = stdout.decode('<STR_LIT:utf-8>', errors='<STR_LIT:ignore>'), stderr.decode('<STR_LIT:utf-8>', errors='<STR_LIT:ignore>')<EOL><DEDENT>if p.returncode:<EOL><INDENT>raise ExecuteError('<STR_LIT>'.format(<EOL>'<STR_LIT:U+0020>'.join(cmd), p.returncode, stderr<EOL>))<EOL><DEDENT>else:<EOL><INDENT>return stdout, stderr<EOL><DEDENT><DEDENT>", "docstring": "Excecute command on thread\n\n    :param cmd: Command to execute\n    :param cwd: current working directory\n    :return: None", "id": "f2823:m2"}
{"signature": "def get_content_type(self):", "body": "return self.default_content_type<EOL>", "docstring": "Get HTTP content type to send. By default default_content_type\n\n        :return: HTTP content type\n        :rtype: str", "id": "f2823:c3:m3"}
{"signature": "def send_confirmation(self, message, success=True):", "body": "message = message.strip()<EOL>if not self.confirmation:<EOL><INDENT>return<EOL><DEDENT>try:<EOL><INDENT>self.confirmation.send(message, success)<EOL><DEDENT>except Exception as e:<EOL><INDENT>logger.warning('<STR_LIT>'.format(self.name, e))<EOL><DEDENT>", "docstring": "Send success or error message to configured confirmation\n\n        :param str message: Body message to send\n        :param bool success: Device executed successfully to personalize message\n        :return: None", "id": "f2825:c0:m3"}
{"signature": "def on_push(self, device):", "body": "src = device.src.lower()<EOL>if last_execution[src] + self.settings.get('<STR_LIT>', DEFAULT_DELAY) > time.time():<EOL><INDENT>return<EOL><DEDENT>last_execution[src] = time.time()<EOL>self.execute(device)<EOL>", "docstring": "Press button. Check DEFAULT_DELAY.\n\n        :param scapy.packet.Packet device: Scapy packet\n        :return: None", "id": "f2825:c1:m1"}
{"signature": "def __init__(self, config_path, ignore_perms=False):", "body": "self.config = Config(config_path, ignore_perms)<EOL>self.settings = self.config.get('<STR_LIT>', {})<EOL>self.devices = {key.lower(): Device(key, value, self.config)<EOL>for key, value in self.config['<STR_LIT>'].items()}<EOL>assert len(self.devices) == len(self.config['<STR_LIT>']), \"<STR_LIT>\"<EOL>", "docstring": ":param str config_path: Path to config file", "id": "f2825:c1:m0"}
{"signature": "def create_logger(name, level=logging.INFO):", "body": "<EOL>logger = logging.getLogger(name)<EOL>logger.setLevel(level)<EOL>ch = logging.StreamHandler()<EOL>ch.setLevel(level)<EOL>formatter = logging.Formatter('<STR_LIT>')<EOL>ch.setFormatter(formatter)<EOL>logger.addHandler(ch)<EOL>", "docstring": "Create a Logger and set handler and formatter\n\n    :param name: logger name\n    :param level: logging level\n    :return: None", "id": "f2830:m0"}
{"signature": "def __init__(self, file=None, extra_body='<STR_LIT>'):", "body": "body = '<STR_LIT>'<EOL>if file:<EOL><INDENT>file = os.path.abspath(file)<EOL>body += '<STR_LIT>'.format(file)<EOL><DEDENT>body += '<STR_LIT>'.format(file)<EOL>if extra_body:<EOL><INDENT>body += '<STR_LIT>'.format(extra_body)<EOL><DEDENT>super(InvalidConfig, self).__init__(body)<EOL>", "docstring": ":param str file: Path to config file\n:param extra_body: complementary message", "id": "f2831:c3:m0"}
{"signature": "def find(ellipsname, crstype, strict=False):", "body": "if not strict:<EOL><INDENT>ellipsname = ellipsname.lower().replace(\"<STR_LIT:U+0020>\",\"<STR_LIT:_>\")<EOL><DEDENT>for itemname,item in globals().items():<EOL><INDENT>if itemname.startswith(\"<STR_LIT:_>\") or itemname == '<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>try:<EOL><INDENT>if hasattr(item.name, crstype):<EOL><INDENT>itemname = getattr(item.name, crstype)<EOL>if not strict:<EOL><INDENT>itemname = itemname.lower().replace(\"<STR_LIT:U+0020>\",\"<STR_LIT:_>\")<EOL><DEDENT>if ellipsname == itemname:<EOL><INDENT>return item<EOL><DEDENT><DEDENT><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Search for a ellipsoid name located in this module.\n\nArguments:\n\n- **ellipsname**: The ellipsoid name to search for.\n- **crstype**: Which CRS naming convention to search (different\n    CRS formats have different names for the same ellipsoid).\n- **strict** (optional): If False, ignores minor name mismatches\n    such as underscore or character casing, otherwise must be exact\n    match (defaults to False).", "id": "f2841:m0"}
{"signature": "def to_ogc_wkt(self):", "body": "return '<STR_LIT>' % (self.name, self.datum.to_ogc_wkt(), self.prime_mer.to_ogc_wkt(), self.angunit.to_ogc_wkt(), self.twin_ax[<NUM_LIT:0>].ogc_wkt, self.twin_ax[<NUM_LIT:1>].ogc_wkt )<EOL>", "docstring": "Returns the CS as a OGC WKT formatted string.", "id": "f2844:c1:m2"}
{"signature": "def to_proj4(self, as_dict=False):", "body": "string = \"<STR_LIT:%s>\" % self.proj.to_proj4()<EOL>string += \"<STR_LIT>\" % self.geogcs.to_proj4(toplevel=False)<EOL>string += \"<STR_LIT:U+0020>\" + \"<STR_LIT:U+0020>\".join(param.to_proj4() for param in self.params)<EOL>string += \"<STR_LIT>\" % self.unit.to_proj4()<EOL>string += \"<STR_LIT>\" + self.twin_ax[<NUM_LIT:0>].proj4 + self.twin_ax[<NUM_LIT:1>].proj4 + \"<STR_LIT:u>\" <EOL>string += \"<STR_LIT>\"<EOL>if as_dict:<EOL><INDENT>return dict([<EOL>entry.lstrip('<STR_LIT:+>').split('<STR_LIT:=>')<EOL>for entry in string.split()<EOL>if entry != \"<STR_LIT>\"<EOL>])<EOL><DEDENT>else:<EOL><INDENT>return string<EOL><DEDENT>", "docstring": "Returns the CS as a proj4 formatted string or dict.\n\nArguments:\n\n- **as_dict** (optional): If True, returns the proj4 string as a dict (defaults to False).", "id": "f2844:c2:m1"}
{"signature": "def to_ogc_wkt(self):", "body": "string = '<STR_LIT>' % (self.name, self.geogcs.to_ogc_wkt(), self.proj.to_ogc_wkt() )<EOL>string += \"<STR_LIT:U+002CU+0020>\".join(param.to_ogc_wkt() for param in self.params)<EOL>string += '<STR_LIT>' % self.unit.to_ogc_wkt()<EOL>string += '<STR_LIT>' % (self.twin_ax[<NUM_LIT:0>].ogc_wkt, self.twin_ax[<NUM_LIT:1>].ogc_wkt )<EOL>return string<EOL>", "docstring": "Returns the CS as a OGC WKT formatted string.", "id": "f2844:c2:m2"}
{"signature": "def to_proj4(self, as_dict=False, toplevel=True):", "body": "<EOL>if toplevel:<EOL><INDENT>string = \"<STR_LIT>\" % (self.datum.to_proj4(), self.prime_mer.to_proj4())<EOL><DEDENT>else:<EOL><INDENT>string = \"<STR_LIT>\" % (self.datum.to_proj4(), self.prime_mer.to_proj4())<EOL><DEDENT>if as_dict:<EOL><INDENT>return dict([<EOL>entry.lstrip('<STR_LIT:+>').split('<STR_LIT:=>')<EOL>for entry in string.split()<EOL>if entry != \"<STR_LIT>\"<EOL>])<EOL><DEDENT>else:<EOL><INDENT>return string<EOL><DEDENT>", "docstring": "Returns the CS as a proj4 formatted string or dict.\n\nArguments:\n\n- **as_dict** (optional): If True, returns the proj4 string as a dict (defaults to False).\n- **toplevel** (optional): If True, treats this CS as the final toplevel CS and adds the necessary proj4 elements (defaults to True).", "id": "f2844:c1:m1"}
{"signature": "def to_esri_wkt(self):", "body": "string = '<STR_LIT>' % (self.name, self.geogcs.to_esri_wkt(), self.proj.to_esri_wkt() )<EOL>string += \"<STR_LIT:U+002CU+0020>\".join(param.to_esri_wkt() for param in self.params)<EOL>string += '<STR_LIT>' % self.unit.to_esri_wkt()<EOL>string += '<STR_LIT>' % (self.twin_ax[<NUM_LIT:0>].esri_wkt, self.twin_ax[<NUM_LIT:1>].esri_wkt )<EOL>return string<EOL>", "docstring": "Returns the CS as a ESRI WKT formatted string.", "id": "f2844:c2:m3"}
{"signature": "def from_unknown_wkt(string, strict=False):", "body": "<EOL>return _from_wkt(string, None, strict)<EOL>", "docstring": "Given an unknown wkt string, detect if uses ogc or esri flavor, and parse the crs accordingly.\n\nArguments:\n\n- *string*: The unknown WKT representation as a string.\n- *strict* (optional): When True, the parser is strict about names having to match\n    exactly with upper and lowercases. Default is not strict (False).\n\nReturns:\n- A CS instance of the indicated type.", "id": "f2849:m5"}
{"signature": "def from_esri_wkt(string, strict=False):", "body": "<EOL>return _from_wkt(string, \"<STR_LIT>\", strict)<EOL>", "docstring": "Parse crs as esri wkt formatted string and return the resulting crs object.\n\nArguments:\n\n- *string*: The ESRI WKT representation as a string.\n- *strict* (optional): When True, the parser is strict about names having to match\n    exactly with upper and lowercases. Default is not strict (False).\n\nReturns:\n\n- A CS instance of the indicated type.", "id": "f2849:m4"}
{"signature": "def from_esri_code(code):", "body": "<EOL>code = str(code)<EOL>proj4 = utils.crscode_to_string(\"<STR_LIT>\", code, \"<STR_LIT>\")<EOL>crs = from_proj4(proj4)<EOL>return crs<EOL>", "docstring": "Load crs object from esri code, via spatialreference.org.\nParses based on the proj4 representation.\n\nArguments:\n\n- *code*: The ESRI code as an integer.\n\nReturns:\n\n- A CS instance of the indicated type.", "id": "f2849:m1"}
{"signature": "def dumps(obj):", "body": "if not isinstance(obj, dict):<EOL><INDENT>raise TypeError('<STR_LIT>' + type(obj).__name__)<EOL><DEDENT>return '<STR_LIT:\\n>'.join(_dumps(obj, level=<NUM_LIT:0>)) + '<STR_LIT:\\n>'<EOL>", "docstring": "Serializes a dictionary into ACF data.\n:param obj: A dictionary to serialize.\n:return: ACF data.", "id": "f2856:m2"}
{"signature": "def load(fp, wrapper=dict):", "body": "return loads(fp.read(), wrapper=wrapper)<EOL>", "docstring": "Loads the contents of an Appinfo file into a Python object.\n:param fp: A file object.\n:param wrapper: A wrapping object for key-value pairs.\n:return: An Ordered Dictionary with Appinfo data.", "id": "f2857:m0"}
{"signature": "def dump(obj, fp):", "body": "fp.write(dumps(obj))<EOL>", "docstring": "Serializes a dictionary into Appinfo data and writes it to a file.\n:param obj: A dictionary to serialize.\n:param fp: A file object.", "id": "f2857:m2"}
{"signature": "def load(fp, wrapper=dict):", "body": "return loads(fp.read(), wrapper=wrapper)<EOL>", "docstring": "Loads the contents of a Manifest file into a Python object.\n:param fp: A file object.\n:param wrapper: A wrapping object for key-value pairs.\n:return: A dictionary with Manifest data.", "id": "f2858:m0"}
{"signature": "def dump(obj, fp):", "body": "fp.write(dumps(obj))<EOL>", "docstring": "Serializes a dictionary into Manifest data and writes it to a file.\n:param obj: A dictionary to serialize.\n:param fp: A file object.", "id": "f2858:m2"}
{"signature": "def get_item_abspath(self, identifier):", "body": "admin_metadata = self.get_admin_metadata()<EOL>uuid = admin_metadata[\"<STR_LIT>\"]<EOL>dataset_cache_abspath = os.path.join(self._s3_cache_abspath, uuid)<EOL>mkdir_parents(dataset_cache_abspath)<EOL>bucket_fpath = self.data_key_prefix + identifier<EOL>obj = self.s3resource.Object(self.bucket, bucket_fpath)<EOL>relpath = obj.get()['<STR_LIT>']['<STR_LIT>']<EOL>_, ext = os.path.splitext(relpath)<EOL>local_item_abspath = os.path.join(<EOL>dataset_cache_abspath,<EOL>identifier + ext<EOL>)<EOL>if not os.path.isfile(local_item_abspath):<EOL><INDENT>tmp_local_item_abspath = local_item_abspath + \"<STR_LIT>\"<EOL>self.s3resource.Bucket(self.bucket).download_file(<EOL>bucket_fpath,<EOL>tmp_local_item_abspath<EOL>)<EOL>os.rename(tmp_local_item_abspath, local_item_abspath)<EOL><DEDENT>return local_item_abspath<EOL>", "docstring": "Return absolute path at which item content can be accessed.\n\n        :param identifier: item identifier\n        :returns: absolute path from which the item content can be accessed", "id": "f2867:c0:m24"}
{"signature": "def loop_options(options):", "body": "def ch(option, parsed_option):<EOL><INDENT>return lambda self: self.check_valid_option(option, parsed_option)<EOL><DEDENT>for i, items in enumerate(options):<EOL><INDENT>prefix_tmp = \"<STR_LIT>\" % (items[<NUM_LIT:0>], i)<EOL>setattr(TestOptions, \"<STR_LIT>\" % prefix_tmp, ch(items[<NUM_LIT:1>], items[<NUM_LIT:2>]))<EOL><DEDENT>", "docstring": "Loop over list of options and dynamically create tests", "id": "f2874:m0"}
{"signature": "def _process_ssh_rsa(self, data):", "body": "current_position, raw_e = self._unpack_by_int(data, <NUM_LIT:0>)<EOL>current_position, raw_n = self._unpack_by_int(data, current_position)<EOL>unpacked_e = self._parse_long(raw_e)<EOL>unpacked_n = self._parse_long(raw_n)<EOL>self.rsa = RSAPublicNumbers(unpacked_e, unpacked_n).public_key(default_backend())<EOL>self.bits = self.rsa.key_size<EOL>if self.strict_mode:<EOL><INDENT>min_length = self.RSA_MIN_LENGTH_STRICT<EOL>max_length = self.RSA_MAX_LENGTH_STRICT<EOL><DEDENT>else:<EOL><INDENT>min_length = self.RSA_MIN_LENGTH_LOOSE<EOL>max_length = self.RSA_MAX_LENGTH_LOOSE<EOL><DEDENT>if self.bits < min_length:<EOL><INDENT>raise TooShortKeyError(<EOL>\"<STR_LIT>\" % (self.key_type, min_length, self.bits)<EOL>)<EOL><DEDENT>if self.bits > max_length:<EOL><INDENT>raise TooLongKeyError(<EOL>\"<STR_LIT>\" % (self.key_type, max_length, self.bits)<EOL>)<EOL><DEDENT>return current_position<EOL>", "docstring": "Parses ssh-rsa public keys.", "id": "f2878:c1:m13"}
{"signature": "def _unpack_by_int(self, data, current_position):", "body": "<EOL>try:<EOL><INDENT>requested_data_length = struct.unpack('<STR_LIT>', data[current_position:current_position + self.INT_LEN])[<NUM_LIT:0>]<EOL><DEDENT>except struct.error:<EOL><INDENT>raise MalformedDataError(\"<STR_LIT>\" % self.INT_LEN)<EOL><DEDENT>current_position += self.INT_LEN<EOL>remaining_data_length = len(data[current_position:])<EOL>if remaining_data_length < requested_data_length:<EOL><INDENT>raise MalformedDataError(<EOL>\"<STR_LIT>\" % (requested_data_length, remaining_data_length)<EOL>)<EOL><DEDENT>next_data = data[current_position:current_position + requested_data_length]<EOL>current_position += requested_data_length<EOL>return current_position, next_data<EOL>", "docstring": "Returns a tuple with (location of next data field, contents of requested data field).", "id": "f2878:c1:m7"}
{"signature": "def parse(self, keydata=None):", "body": "if keydata is None:<EOL><INDENT>if self.keydata is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>keydata = self.keydata<EOL><DEDENT>else:<EOL><INDENT>self.reset()<EOL>self.keydata = keydata<EOL><DEDENT>if keydata.startswith(\"<STR_LIT>\"):<EOL><INDENT>key_type = None  <EOL>pubkey_content = \"<STR_LIT>\".join([line for line in keydata.split(\"<STR_LIT:\\n>\") if \"<STR_LIT::>\" not in line and \"<STR_LIT>\" not in line])<EOL><DEDENT>else:<EOL><INDENT>key_parts = self._split_key(keydata)<EOL>key_type = key_parts[<NUM_LIT:0>]<EOL>pubkey_content = key_parts[<NUM_LIT:1>]<EOL><DEDENT>self._decoded_key = self.decode_key(pubkey_content)<EOL>current_position, unpacked_key_type = self._unpack_by_int(self._decoded_key, <NUM_LIT:0>)<EOL>if key_type is not None and key_type != unpacked_key_type.decode():<EOL><INDENT>raise InvalidTypeError(\"<STR_LIT>\" % (key_type, unpacked_key_type))<EOL><DEDENT>self.key_type = unpacked_key_type<EOL>key_data_length = self._process_key(self._decoded_key[current_position:])<EOL>current_position = current_position + key_data_length<EOL>if current_position != len(self._decoded_key):<EOL><INDENT>raise MalformedDataError(\"<STR_LIT>\" % (len(self._decoded_key) - current_position))<EOL><DEDENT>if self.disallow_options and self.options:<EOL><INDENT>raise InvalidOptionsError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Validates SSH public key.\n\n        Throws exception for invalid keys. Otherwise returns None.\n\n        Populates key_type, bits and bits fields.\n\n        For rsa keys, see field \"rsa\" for raw public key data.\n        For dsa keys, see field \"dsa\".\n        For ecdsa keys, see field \"ecdsa\".", "id": "f2878:c1:m18"}
{"signature": "@classmethod<EOL><INDENT>def decode_key(cls, pubkey_content):<DEDENT>", "body": "try:<EOL><INDENT>decoded_key = base64.b64decode(pubkey_content.encode(\"<STR_LIT:ascii>\"))<EOL><DEDENT>except (TypeError, binascii.Error):<EOL><INDENT>raise MalformedDataError(\"<STR_LIT>\")<EOL><DEDENT>return decoded_key<EOL>", "docstring": "Decode base64 coded part of the key.", "id": "f2878:c1:m10"}
{"signature": "def write_output(filepath, pack, filename, content):", "body": "if (filepath and filepath != '<STR_LIT:.>'<EOL>and not os.path.exists(os.path.join(filepath, pack))):<EOL><INDENT>os.makedirs(os.path.join(filepath, pack))<EOL><DEDENT>destination = os.path.join(filepath, pack, filename)<EOL>with io.open(destination, '<STR_LIT:w>', encoding='<STR_LIT:utf-8>') as f:<EOL><INDENT>f.write(content)<EOL><DEDENT>return destination<EOL>", "docstring": "Write content to filepath+pack+filename, create filepath if it does not\nallready exists.\n\nThis an helper to automatically rewrite HTML outputs when needed during\ndevelopment.\n\nBeware, using this will lose every templating instructions previously\nwritten in output attempts.", "id": "f2895:m0"}
{"signature": "def _extract_version(package_name):", "body": "try:<EOL><INDENT>return pkg_resources.get_distribution(package_name).version<EOL><DEDENT>except pkg_resources.DistributionNotFound:<EOL><INDENT>_conf = read_configuration(os.path.join(PROJECT_DIR, \"<STR_LIT>\"))<EOL><DEDENT>return _conf[\"<STR_LIT>\"][\"<STR_LIT:version>\"]<EOL>", "docstring": "Get package version from installed distribution or configuration file if not\ninstalled", "id": "f2911:m0"}
{"signature": "def available_sources(self):", "body": "return list(self.SOURCES.keys())<EOL>", "docstring": "Return a list of available sources.", "id": "f2924:c1:m9"}
{"signature": "def tuner_am_preset(self, operator, value=None):", "body": "return self.exec_command('<STR_LIT>', '<STR_LIT>', operator, value)<EOL>", "docstring": "Execute Tuner.AM.Preset.", "id": "f2924:c0:m12"}
{"signature": "def status(self):", "body": "nad_reply = self._send(self.POLL_VOLUME +<EOL>self.POLL_POWER +<EOL>self.POLL_MUTED +<EOL>self.POLL_SOURCE, read_reply=True)<EOL>if nad_reply is None:<EOL><INDENT>return<EOL><DEDENT>num_chars = <NUM_LIT:10><EOL>nad_status = [nad_reply[i:i + num_chars]<EOL>for i in range(<NUM_LIT:0>, len(nad_reply), num_chars)]<EOL>return {'<STR_LIT>': int(nad_status[<NUM_LIT:0>][-<NUM_LIT:2>:], <NUM_LIT:16>),<EOL>'<STR_LIT>': nad_status[<NUM_LIT:1>][-<NUM_LIT:2>:] == '<STR_LIT>',<EOL>'<STR_LIT>': nad_status[<NUM_LIT:2>][-<NUM_LIT:2>:] == '<STR_LIT>',<EOL>'<STR_LIT:source>': self.SOURCES_REVERSED[nad_status[<NUM_LIT:3>][-<NUM_LIT:2>:]]}<EOL>", "docstring": "Return the status of the device.\n\nReturns a dictionary with keys 'volume' (int 0-200) , 'power' (bool),\n 'muted' (bool) and 'source' (str).", "id": "f2924:c1:m2"}
{"signature": "def select_source(self, source):", "body": "status = self.status()<EOL>if status['<STR_LIT>']:  <EOL><INDENT>if status['<STR_LIT:source>'] != source:  <EOL><INDENT>if source in self.SOURCES:<EOL><INDENT>self._send(self.CMD_SOURCE + self.SOURCES[source], read_reply=True)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Select a source from the list of sources.", "id": "f2924:c1:m8"}
{"signature": "def set_volume(self, volume):", "body": "if <NUM_LIT:0> <= volume <= <NUM_LIT:200>:<EOL><INDENT>volume = format(volume, \"<STR_LIT>\")  <EOL>self._send(self.CMD_VOLUME + volume)<EOL><DEDENT>", "docstring": "Set volume level of the device. Accepts integer values 0-200.", "id": "f2924:c1:m5"}
{"signature": "def power_on(self):", "body": "status = self.status()<EOL>if not status['<STR_LIT>']:<EOL><INDENT>self._send(self.CMD_ON, read_reply=True)<EOL>sleep(<NUM_LIT:0.5>)<EOL><DEDENT>", "docstring": "Power the device on.", "id": "f2924:c1:m4"}
{"signature": "def get_setup_version():", "body": "ver = '<STR_LIT:.>'.join(map(str, VERSION[:<NUM_LIT:3>]))<EOL>if not VERSION[<NUM_LIT:3>]:<EOL><INDENT>return ver<EOL><DEDENT>hyphen = '<STR_LIT>'<EOL>suffix = hyphen.join(map(str, VERSION[-<NUM_LIT:2>:]))<EOL>if VERSION[<NUM_LIT:3>] in [VERSION_SUFFIX_DEV, VERSION_SUFFIX_POST]:<EOL><INDENT>hyphen = '<STR_LIT:.>'<EOL><DEDENT>ver = hyphen.join([ver, suffix])<EOL>return ver<EOL>", "docstring": "\u83b7\u53d6\u6253\u5305\u4f7f\u7528\u7684\u7248\u672c\u53f7\uff0c\u7b26\u5408 PYPI \u5b98\u65b9\u63a8\u8350\u7684\u7248\u672c\u53f7\u65b9\u6848\n\n:return: PYPI \u6253\u5305\u7248\u672c\u53f7\n:rtype: str", "id": "f2926:m0"}
{"signature": "def _register(func):", "body": "hand[func.__name__] = func<EOL>return func<EOL>", "docstring": "\u5c06\u88ab\u88c5\u9970\u51fd\u6570\u6ce8\u518c\u5230 hand \u5355\u4f8b\u5b57\u5178\u4e2d\n\n:param object func: \u88ab\u88c5\u9970\u51fd\u6570\n:return: \u88ab\u88c5\u9970\u7684\u51fd\u6570\u672c\u8eab\uff08\u4e0d\u8fdb\u884c\u5c01\u88c5\uff09\n:rtype: function", "id": "f2927:m0"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def version(self):<DEDENT>", "body": "", "docstring": "\u7248\u672c\u4fe1\u606f\n\n:return: \u8fd4\u56de\u5305\u540d\uff0c\u7248\u672c\u53f7\u5143\u7ec4\n:rtype: (str, str)", "id": "f2928:c0:m1"}
{"signature": "def __new__(mcs, *args, **kwargs):", "body": "class_name, super_cls, dict_ = args<EOL>dict_['<STR_LIT>'] = None<EOL>cls_ = super(Singleton, mcs).__new__(<EOL>mcs, class_name, super_cls, dict_, **kwargs)<EOL>return cls_<EOL>", "docstring": "\u5143\u7c7bmsc\u901a\u8fc7__new__\u7ec4\u5efa\u7c7b\u5bf9\u8c61\uff0c\u5176\u4e2dmsc\u6307Singleton\n\n:param list args: \u53ef\u4ee5\u5305\u542b\u7c7b\u6784\u5efa\u6240\u9700\u8981\u4e09\u5143\u7d20\uff0c ``\u7c7b\u540d`` \uff0c ``\u7236\u7c7b`` \uff0c\n    ``\u547d\u540d\u7a7a\u95f4``, \u5176\u4e2d\u547d\u540d\u7a7a\u95f4\u4e2d __qualname__ \u548c\u51fd\u6570\u7684 __qualname__\n    \u5747\u542b\u6709 classname \u505a\u4e3a\u524d\u7f00\uff0c\u5728\u8fd9\u91cc\uff0c\u5982\u679c\u60f3\u66ff\u6362\u7c7b\u540d\uff0c\u9700\u8981\u628a\u4ee5\u4e0a\u5168\u90e8\u66ff\u6362\u624d\u53ef\u4ee5\u3002\n:param dict kwargs: \u53ef\u4ee5\u81ea\u5b9a\u4e49\u4f20\u9012\u4e00\u4e9b\u53c2\u6570\n:return: \u8fd4\u56de\u7c7b\u5bf9\u8c61,\u901a\u8fc7super(Singleton, mcs).__new__\u6b64\u65f6\u5df2\u7ecf\u7ec4\u88c5\u597d\u4e86\u7c7b\n:rtype: class", "id": "f2932:c1:m0"}
{"signature": "def get_commands_from_module(imported):", "body": "<EOL>imported_vars = vars(imported)<EOL>if \"<STR_LIT>\" in imported_vars:<EOL><INDENT>imported_vars = [<EOL>(name, imported_vars[name]) for name in<EOL>imported_vars if name in imported_vars[\"<STR_LIT>\"]]<EOL><DEDENT>else:<EOL><INDENT>imported_vars = imported_vars.items()<EOL><DEDENT>cmd_dict = extract_commands(imported_vars)<EOL>return imported.__doc__, cmd_dict<EOL>", "docstring": "\u4ece\u4f20\u5165\u7684 ``imported`` \u4e2d\u83b7\u53d6\u6240\u6709 ``click.core.Command``\n\n:param module imported: \u5bfc\u5165\u7684Python\u5305\n:return: \u5305\u63cf\u8ff0\u6587\u6863\uff0c\u4ec5\u542b\u7ec8\u7aef\u547d\u4ee4\u51fd\u6570\u7684\u5bf9\u8c61\u5b57\u5178\n:rtype: (str, dict(str, object))", "id": "f2934:m2"}
{"signature": "@property<EOL><INDENT>def xml(self) -> str:<DEDENT>", "body": "return self._xml<EOL>", "docstring": ":return: The XML representation of the beacon, as a string", "id": "f2951:c0:m14"}
{"signature": "@property<EOL><INDENT>def timestamp(self) -> int:<DEDENT>", "body": "return self._timestamp<EOL>", "docstring": ":return:\n    The time the seed value was generated as the number of\n    seconds since January 1, 1970", "id": "f2951:c0:m11"}
{"signature": "def __init__(<EOL>self,<EOL>key_name: str,<EOL>file_path: str,<EOL>magic_line: str,<EOL>strip_end_chars: int = <NUM_LIT:0>,<EOL>):", "body": "self.key_name = key_name<EOL>self.file_path = file_path<EOL>self.magic_line = magic_line<EOL>self.strip_end_chars = strip_end_chars<EOL>", "docstring": "A simple python object that is used to extract and\n(eventually) update version values across the project\n\nThe 'magic_line' is the first part of a file line that\nis before the version number. So for example, if the version\nis stored on a line such as '__version__=1' your magic line\nwill be '__version__='. If you need to remove any extra characters\nat the end of the version line, increase the 'strip_end_chars'\nproperty on this object.\n\n:param key_name: The key name, or reference name, for this file\n:param file_path: The path to the file\n:param magic_line: The \"magic line\" to search for\n:param strip_end_chars: The number of characters to strip off the end", "id": "f2956:c0:m0"}
{"signature": "def copy_dir(bucket_name, src_path, dest_path,<EOL>aws_access_key_id=None, aws_secret_access_key=None,<EOL>aws_profile=None,<EOL>surrogate_key=None, cache_control=None,<EOL>surrogate_control=None,<EOL>create_directory_redirect_object=True):", "body": "if not src_path.endswith('<STR_LIT:/>'):<EOL><INDENT>src_path += '<STR_LIT:/>'<EOL><DEDENT>if not dest_path.endswith('<STR_LIT:/>'):<EOL><INDENT>dest_path += '<STR_LIT:/>'<EOL><DEDENT>common_prefix = os.path.commonprefix([src_path, dest_path])<EOL>if common_prefix == src_path:<EOL><INDENT>msg = '<STR_LIT>'.format(<EOL>common_prefix, src_path)<EOL>raise RuntimeError(msg)<EOL><DEDENT>if common_prefix == dest_path:<EOL><INDENT>msg = '<STR_LIT>'.format(<EOL>common_prefix, dest_path)<EOL>raise RuntimeError(msg)<EOL><DEDENT>delete_dir(bucket_name, dest_path,<EOL>aws_access_key_id, aws_secret_access_key)<EOL>session = boto3.session.Session(<EOL>aws_access_key_id=aws_access_key_id,<EOL>aws_secret_access_key=aws_secret_access_key,<EOL>profile_name=aws_profile)<EOL>s3 = session.resource('<STR_LIT>')<EOL>bucket = s3.Bucket(bucket_name)<EOL>for src_obj in bucket.objects.filter(Prefix=src_path):<EOL><INDENT>src_rel_path = os.path.relpath(src_obj.key, start=src_path)<EOL>dest_key_path = os.path.join(dest_path, src_rel_path)<EOL>head = s3.meta.client.head_object(Bucket=bucket_name,<EOL>Key=src_obj.key)<EOL>metadata = head['<STR_LIT>']<EOL>content_type = head['<STR_LIT>']<EOL>if cache_control is None and '<STR_LIT>' in head:<EOL><INDENT>cache_control = head['<STR_LIT>']<EOL><DEDENT>if surrogate_control is not None:<EOL><INDENT>metadata['<STR_LIT>'] = surrogate_control<EOL><DEDENT>if surrogate_key is not None:<EOL><INDENT>metadata['<STR_LIT>'] = surrogate_key<EOL><DEDENT>s3.meta.client.copy_object(<EOL>Bucket=bucket_name,<EOL>Key=dest_key_path,<EOL>CopySource={'<STR_LIT>': bucket_name, '<STR_LIT>': src_obj.key},<EOL>MetadataDirective='<STR_LIT>',<EOL>Metadata=metadata,<EOL>ACL='<STR_LIT>',<EOL>CacheControl=cache_control,<EOL>ContentType=content_type)<EOL><DEDENT>if create_directory_redirect_object:<EOL><INDENT>dest_dirname = dest_path.rstrip('<STR_LIT:/>')<EOL>obj = bucket.Object(dest_dirname)<EOL>metadata = {'<STR_LIT>': '<STR_LIT:true>'}<EOL>obj.put(Body='<STR_LIT>',<EOL>ACL='<STR_LIT>',<EOL>Metadata=metadata,<EOL>CacheControl=cache_control)<EOL><DEDENT>", "docstring": "Copy objects from one directory in a bucket to another directory in\n    the same bucket.\n\n    Object metadata is preserved while copying, with the following exceptions:\n\n    - If a new surrogate key is provided it will replace the original one.\n    - If ``cache_control`` and ``surrogate_control`` values are provided they\n      will replace the old one.\n\n    Parameters\n    ----------\n    bucket_name : `str`\n        Name of an S3 bucket.\n    src_path : `str`\n        Source directory in the S3 bucket. The ``src_path`` should ideally end\n        in a trailing `'/'`. E.g. `'dir/dir2/'`.\n    dest_path : `str`\n        Destination directory in the S3 bucket. The ``dest_path`` should\n        ideally end in a trailing `'/'`. E.g. `'dir/dir2/'`. The destination\n        path cannot contain the source path.\n    aws_access_key_id : `str`\n        The access key for your AWS account. Also set\n        ``aws_secret_access_key``.\n    aws_secret_access_key : `str`\n        The secret key for your AWS account.\n    aws_profile : `str`, optional\n        Name of AWS profile in :file:`~/.aws/credentials`. Use this instead\n        of ``aws_access_key_id`` and ``aws_secret_access_key`` for file-based\n        credentials.\n    surrogate_key : `str`, optional\n        The surrogate key to insert in the header of all objects in the\n        ``x-amz-meta-surrogate-key`` field. This key is used to purge\n        builds from the Fastly CDN when Editions change.\n        If `None` then no header will be set.\n        If the object already has a ``x-amz-meta-surrogate-key`` header then\n        it will be replaced.\n    cache_control : `str`, optional\n        This sets (and overrides) the ``Cache-Control`` header on the copied\n        files. The ``Cache-Control`` header specifically dictates how content\n        is cached by the browser (if ``surrogate_control`` is also set).\n    surrogate_control : `str`, optional\n        This sets (and overrides) the ``x-amz-meta-surrogate-control`` header\n        on the copied files. The ``Surrogate-Control``\n        or ``x-amz-meta-surrogate-control`` header is used in priority by\n        Fastly to givern it's caching. This caching policy is *not* passed\n        to the browser.\n    create_directory_redirect_object : `bool`, optional\n        Create a directory redirect object for the root directory. The\n        directory redirect object is an empty S3 object named after the\n        directory (without a trailing slash) that contains a\n        ``x-amz-meta-dir-redirect=true`` HTTP header. LSST the Docs' Fastly\n        VCL is configured to redirect requests for a directory path to the\n        directory's ``index.html`` (known as *courtesy redirects*).\n\n    Raises\n    ------\n    ltdconveyor.s3.S3Error\n        Thrown by any unexpected faults from the S3 API.\n    RuntimeError\n        Thrown when the source and destination directories are the same.", "id": "f2965:m0"}
{"signature": "def ensure_login(ctx):", "body": "logger = logging.getLogger(__name__)<EOL>logger.info('<STR_LIT>', __name__)<EOL>if ctx.obj['<STR_LIT>'] is None:<EOL><INDENT>if ctx.obj['<STR_LIT:username>'] is None or ctx.obj['<STR_LIT:password>'] is None:<EOL><INDENT>raise click.UsageError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>logger.debug(<EOL>'<STR_LIT>',<EOL>ctx.obj['<STR_LIT:username>'],<EOL>ctx.obj['<STR_LIT>'])<EOL>token = get_keeper_token(<EOL>ctx.obj['<STR_LIT>'],<EOL>ctx.obj['<STR_LIT:username>'],<EOL>ctx.obj['<STR_LIT:password>'])<EOL>ctx.obj['<STR_LIT>'] = token<EOL>logger.debug(<EOL>'<STR_LIT>',<EOL>ctx.obj['<STR_LIT:username>'],<EOL>ctx.obj['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>logger.debug(<EOL>'<STR_LIT>')<EOL><DEDENT>", "docstring": "Ensure a token is in the Click context object or authenticate and obtain\n    the token from LTD Keeper.\n\n    Parameters\n    ----------\n    ctx : `click.Context`\n        The Click context. ``ctx.obj`` must be a `dict` that contains keys:\n        ``keeper_hostname``, ``username``, ``password``, ``token``. This\n        context object is prepared by the main Click group,\n        `ltdconveyor.cli.main.main`.", "id": "f2972:m0"}
{"signature": "def confirm_build(build_url, keeper_token):", "body": "data = {<EOL>'<STR_LIT>': True<EOL>}<EOL>r = requests.patch(<EOL>build_url,<EOL>auth=(keeper_token, '<STR_LIT>'),<EOL>json=data)<EOL>if r.status_code != <NUM_LIT:200>:<EOL><INDENT>raise KeeperError(r)<EOL><DEDENT>", "docstring": "Confirm a build upload is complete.\n\n    Wraps ``PATCH /builds/{build}``.\n\n    Parameters\n    ----------\n    build_url : `str`\n        URL of the build resource. Given a build resource, this URL is\n        available from the ``self_url`` field.\n    keeper_token : `str`\n        Auth token (`ltdconveyor.keeper.get_keeper_token`).\n\n    Raises\n    ------\n    ltdconveyor.keeper.KeeperError\n        Raised if there is an error communicating with the LTD Keeper API.", "id": "f2973:m1"}
{"signature": "def get_value(self, item, source_name):", "body": "val = item.get(source_name.encode('<STR_LIT:utf-8>'), None)<EOL>if val is not None:<EOL><INDENT>val = convert_string(val)<EOL><DEDENT>return val<EOL>", "docstring": "This method receives an item from the source and a source name,\nand returns the text content for the `source_name` node.", "id": "f2980:c0:m3"}
{"signature": "def get_value(self, item, source_name):", "body": "return force_text(smart_str(item.findtext(source_name))).strip()<EOL>", "docstring": "This method receives an item from the source and a source name,\nand returns the text content for the `source_name` node.", "id": "f2982:c0:m2"}
{"signature": "def download_file(url, dest):", "body": "<EOL>request = urllib2.Request(url)<EOL>request.add_header('<STR_LIT>', '<STR_LIT>')<EOL>opener = urllib2.build_opener()<EOL>response = opener.open(request)<EOL>data = response.read()<EOL>if response.headers.get('<STR_LIT>', '<STR_LIT>') == '<STR_LIT>':<EOL><INDENT>stream = StringIO.StringIO(data)<EOL>gzipper = gzip.GzipFile(fileobj=stream)<EOL>data = gzipper.read()<EOL><DEDENT>f = open(dest, '<STR_LIT:wb>')<EOL>f.write(data)<EOL>f.close()<EOL>", "docstring": "Downloads a HTTP resource from `url` and save to `dest`.\n\nCapable of dealing with Gzip compressed content.", "id": "f2985:m0"}
{"signature": "@staticmethod<EOL><INDENT>def build(data_path: str) -> Path:<DEDENT>", "body": "return Path(data_path)<EOL>", "docstring": "Base method that interprets ``data_path`` argument.\n\n        Args:\n            data_path: path to the tsv-file containing erroneous and corrected words\n\n        Returns:\n            the same path as a :class:`~pathlib.Path` object", "id": "f3002:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def read(data_path: str, *args, **kwargs) -> Dict[str, List[Tuple[str, str]]]:<DEDENT>", "body": "fname = TyposKartaslov.build(data_path)<EOL>with open(str(fname), newline='<STR_LIT>', encoding='<STR_LIT:utf8>') as csvfile:<EOL><INDENT>reader = csv.reader(csvfile, delimiter='<STR_LIT:;>')<EOL>next(reader)<EOL>res = [(mistake, correct) for correct, mistake, weight in reader]<EOL><DEDENT>return {'<STR_LIT:train>': res}<EOL>", "docstring": "Read train data for spelling corrections algorithms\n\n        Args:\n            data_path: path that needs to be interpreted with :meth:`~deeppavlov.dataset_readers.typos_reader.TyposKartaslov.build`\n\n        Returns:\n            train data to pass to a :class:`~deeppavlov.dataset_iterators.typos_iterator.TyposDatasetIterator`", "id": "f3002:c2:m2"}
{"signature": "@classmethod<EOL><INDENT>@overrides<EOL>def read(self, data_path: str, dialogs: bool = False) -> Dict[str, List]:<DEDENT>", "body": "required_files = (self._data_fname(dt) for dt in ('<STR_LIT:train>', '<STR_LIT>', '<STR_LIT:test>'))<EOL>if not all(Path(data_path, f).exists() for f in required_files):<EOL><INDENT>log.info('<STR_LIT>'.format(self.url, data_path))<EOL>download_decompress(self.url, data_path)<EOL>mark_done(data_path)<EOL><DEDENT>data = {<EOL>'<STR_LIT:train>': self._read_from_file(<EOL>Path(data_path, self._data_fname('<STR_LIT:train>')), dialogs),<EOL>'<STR_LIT>': self._read_from_file(<EOL>Path(data_path, self._data_fname('<STR_LIT>')), dialogs),<EOL>'<STR_LIT:test>': self._read_from_file(<EOL>Path(data_path, self._data_fname('<STR_LIT:test>')), dialogs)<EOL>}<EOL>return data<EOL>", "docstring": "Downloads ``'kvrest_public.tar.gz'``, decompresses, saves files to ``data_path``.\n\nParameters:\n    data_path: path to save data\n    dialogs: flag indices whether to output list of turns or list of dialogs\n\nReturns:\n    dictionary with ``'train'`` containing dialogs from ``'kvret_train_public.json'``, ``'valid'`` containing dialogs from ``'kvret_valid_public.json'``, ``'test'`` containing dialogs from ``'kvret_test_public.json'``. Each fields is a list of tuples ``(x_i, y_i)``.", "id": "f3006:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>@overrides<EOL>def read(self, data_path: str, dialogs: bool = False) -> Dict[str, List]:<DEDENT>", "body": "required_files = (self._data_fname(dt) for dt in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'))<EOL>if not all(Path(data_path, f).exists() for f in required_files):<EOL><INDENT>log.info('<STR_LIT>'.format(self.url, data_path))<EOL>download_decompress(self.url, data_path)<EOL>mark_done(data_path)<EOL><DEDENT>data = {<EOL>'<STR_LIT:train>': self._read_from_file(<EOL>Path(data_path, self._data_fname('<STR_LIT>')), dialogs),<EOL>'<STR_LIT>': self._read_from_file(<EOL>Path(data_path, self._data_fname('<STR_LIT>')), dialogs),<EOL>'<STR_LIT:test>': self._read_from_file(<EOL>Path(data_path, self._data_fname('<STR_LIT>')), dialogs)<EOL>}<EOL>return data<EOL>", "docstring": "Downloads ``'dstc2_v2.tar.gz'`` archive from ipavlov internal server,\ndecompresses and saves files to ``data_path``.\n\nParameters:\n    data_path: path to save DSTC2 dataset\n    dialogs: flag which indicates whether to output list of turns or\n     list of dialogs\n\nReturns:\n    dictionary that contains ``'train'`` field with dialogs from\n    ``'dstc2-trn.jsonlist'``, ``'valid'`` field with dialogs from\n    ``'dstc2-val.jsonlist'`` and ``'test'`` field with dialogs from\n    ``'dstc2-tst.jsonlist'``. Each field is a list of tuples ``(x_i, y_i)``.", "id": "f3008:c0:m1"}
{"signature": "def read(self, dir_path: str, dataset: Optional[str] = '<STR_LIT>', url: Optional[str] = None, *args, **kwargs)-> Dict[str, Dict[str, Any]]:", "body": "if url is not None:<EOL><INDENT>self.url = url<EOL><DEDENT>elif dataset == '<STR_LIT>':<EOL><INDENT>self.url = self.url_squad<EOL><DEDENT>elif dataset == '<STR_LIT>':<EOL><INDENT>self.url = self.url_sber_squad<EOL><DEDENT>elif dataset == '<STR_LIT>':<EOL><INDENT>self.url = self.url_multi_squad<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>'.format(dataset))<EOL><DEDENT>dir_path = Path(dir_path)<EOL>required_files = ['<STR_LIT>'.format(dt) for dt in ['<STR_LIT:train>', '<STR_LIT>']]<EOL>if not dir_path.exists():<EOL><INDENT>dir_path.mkdir()<EOL><DEDENT>if not all((dir_path / f).exists() for f in required_files):<EOL><INDENT>download_decompress(self.url, dir_path)<EOL><DEDENT>dataset = {}<EOL>for f in required_files:<EOL><INDENT>with dir_path.joinpath(f).open('<STR_LIT:r>', encoding='<STR_LIT:utf8>') as fp:<EOL><INDENT>data = json.load(fp)<EOL><DEDENT>if f == '<STR_LIT>':<EOL><INDENT>dataset['<STR_LIT>'] = data<EOL><DEDENT>else:<EOL><INDENT>dataset['<STR_LIT:train>'] = data<EOL><DEDENT><DEDENT>return dataset<EOL>", "docstring": "Args:\n    dir_path: path to save data\n    dataset: default dataset names: ``'SQuAD'``, ``'SberSQuAD'`` or ``'MultiSQuAD'``\n    url: link to archive with dataset, use url argument if non-default dataset is used\n\nReturns:\n    dataset split on train/valid\n\nRaises:\n    RuntimeError: if `dataset` is not one of these: ``'SQuAD'``, ``'SberSQuAD'``, ``'MultiSQuAD'``.", "id": "f3016:c0:m0"}
{"signature": "def read(self, dir_path: str, dataset: Optional[str] = '<STR_LIT>', url: Optional[str] = None, *args,<EOL>**kwargs) -> Dict[str, Dict[str, Any]]:", "body": "if url is not None:<EOL><INDENT>self.url = url<EOL><DEDENT>elif dataset == '<STR_LIT>':<EOL><INDENT>self.url = self.url_multi_squad_retr<EOL><DEDENT>elif dataset == '<STR_LIT>':<EOL><INDENT>self.url = self.url_multi_squad_ru_retr<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>'.format(dataset))<EOL><DEDENT>dir_path = Path(dir_path)<EOL>required_files = ['<STR_LIT>'.format(dt) for dt in ['<STR_LIT:train>', '<STR_LIT>']]<EOL>if not dir_path.exists():<EOL><INDENT>dir_path.mkdir(parents=True)<EOL><DEDENT>if not all((dir_path / f).exists() for f in required_files):<EOL><INDENT>download_decompress(self.url, dir_path)<EOL><DEDENT>dataset = {}<EOL>for f in required_files:<EOL><INDENT>if '<STR_LIT>' in f:<EOL><INDENT>dataset['<STR_LIT>'] = dir_path.joinpath(f)<EOL><DEDENT>else:<EOL><INDENT>dataset['<STR_LIT:train>'] = dir_path.joinpath(f)<EOL><DEDENT><DEDENT>return dataset<EOL>", "docstring": "Args:\n    dir_path: path to save data\n    dataset: default dataset names: ``'MultiSQuADRetr'``, ``'MultiSQuADRuRetr'``\n    url: link to archive with dataset, use url argument if non-default dataset is used\n\nReturns:\n    dataset split on train/valid\n\nRaises:\n    RuntimeError: if `dataset` is not one of these: ``'MultiSQuADRetr'``, ``'MultiSQuADRuRetr'``.", "id": "f3016:c1:m0"}
{"signature": "def read(self, data_path: Union[Path, str], db_url: Optional[str] = None, *args,<EOL>**kwargs) -> None:", "body": "logger.info('<STR_LIT>')<EOL>try:<EOL><INDENT>save_path = expand_path(kwargs['<STR_LIT>'])<EOL><DEDENT>except KeyError:<EOL><INDENT>raise ConfigError(<EOL>f'<STR_LIT>')<EOL><DEDENT>if save_path.exists() and save_path.with_suffix(f'<STR_LIT>').exists():<EOL><INDENT>return<EOL><DEDENT>try:<EOL><INDENT>dataset_format = kwargs['<STR_LIT>']<EOL><DEDENT>except KeyError:<EOL><INDENT>raise ConfigError(<EOL>f'<STR_LIT>')<EOL><DEDENT>save_path.parent.mkdir(parents=True, exist_ok=True)<EOL>if db_url:<EOL><INDENT>download_dir = save_path.parent<EOL>logger.info(f'<STR_LIT>')<EOL>download(download_dir, db_url, force_download=False)<EOL>return<EOL><DEDENT>self._build_db(save_path, dataset_format, expand_path(data_path))<EOL>", "docstring": "Build a SQLite database from provided files, download SQLite database from a provided URL,\n         or do nothing.\n\n        Args:\n            data_path: a directory/file with texts to create a database from\n            db_url: path to a database url\n            kwargs:\n                save_path: a path where a database should be saved to, or path to a ready database\n                dataset_format: initial data format; should be selected from ['txt', 'wiki', 'json']\n\n        Returns:\n            None", "id": "f3017:c0:m0"}
{"signature": "@register_metric('<STR_LIT>')<EOL>def round_f1_weighted(y_true, y_predicted):", "body": "try:<EOL><INDENT>predictions = [np.round(x) for x in y_predicted]<EOL><DEDENT>except TypeError:<EOL><INDENT>predictions = y_predicted<EOL><DEDENT>return f1_score(np.array(y_true), np.array(predictions), average=\"<STR_LIT>\")<EOL>", "docstring": "Calculates F1 weighted measure.\n\nArgs:\n    y_true: list of true values\n    y_predicted: list of predicted values\n\nReturns:\n    F1 score", "id": "f3023:m3"}
{"signature": "def compute_bleu(reference_corpus, translation_corpus, max_order=<NUM_LIT:4>,<EOL>smooth=False):", "body": "matches_by_order = [<NUM_LIT:0>] * max_order<EOL>possible_matches_by_order = [<NUM_LIT:0>] * max_order<EOL>reference_length = <NUM_LIT:0><EOL>translation_length = <NUM_LIT:0><EOL>for (references, translation) in zip(reference_corpus,<EOL>translation_corpus):<EOL><INDENT>reference_length += min(len(r) for r in references)<EOL>translation_length += len(translation)<EOL>merged_ref_ngram_counts = collections.Counter()<EOL>for reference in references:<EOL><INDENT>merged_ref_ngram_counts |= _get_ngrams(reference, max_order)<EOL><DEDENT>translation_ngram_counts = _get_ngrams(translation, max_order)<EOL>overlap = translation_ngram_counts & merged_ref_ngram_counts<EOL>for ngram in overlap:<EOL><INDENT>matches_by_order[len(ngram)-<NUM_LIT:1>] += overlap[ngram]<EOL><DEDENT>for order in range(<NUM_LIT:1>, max_order+<NUM_LIT:1>):<EOL><INDENT>possible_matches = len(translation) - order + <NUM_LIT:1><EOL>if possible_matches > <NUM_LIT:0>:<EOL><INDENT>possible_matches_by_order[order-<NUM_LIT:1>] += possible_matches<EOL><DEDENT><DEDENT><DEDENT>precisions = [<NUM_LIT:0>] * max_order<EOL>for i in range(<NUM_LIT:0>, max_order):<EOL><INDENT>if smooth:<EOL><INDENT>precisions[i] = ((matches_by_order[i] + <NUM_LIT:1.>) /<EOL>(possible_matches_by_order[i] + <NUM_LIT:1.>))<EOL><DEDENT>else:<EOL><INDENT>if possible_matches_by_order[i] > <NUM_LIT:0>:<EOL><INDENT>precisions[i] = (float(matches_by_order[i]) /<EOL>possible_matches_by_order[i])<EOL><DEDENT>else:<EOL><INDENT>precisions[i] = <NUM_LIT:0.0><EOL><DEDENT><DEDENT><DEDENT>if min(precisions) > <NUM_LIT:0>:<EOL><INDENT>p_log_sum = sum((<NUM_LIT:1.> / max_order) * math.log(p) for p in precisions)<EOL>geo_mean = math.exp(p_log_sum)<EOL><DEDENT>else:<EOL><INDENT>geo_mean = <NUM_LIT:0><EOL><DEDENT>ratio = float(translation_length) / reference_length<EOL>if ratio > <NUM_LIT:1.0>:<EOL><INDENT>bp = <NUM_LIT:1.><EOL><DEDENT>else:<EOL><INDENT>bp = math.exp(<NUM_LIT:1> - <NUM_LIT:1.> / ratio)<EOL><DEDENT>bleu = geo_mean * bp<EOL>return (bleu, precisions, bp, ratio, translation_length, reference_length)<EOL>", "docstring": "Computes BLEU score of translated segments against one or more references.\n\n    Args:\n      reference_corpus: list of lists of references for each translation. Each\n          reference should be tokenized into a list of tokens.\n      translation_corpus: list of translations to score. Each translation\n          should be tokenized into a list of tokens.\n      max_order: Maximum n-gram order to use when computing BLEU score.\n      smooth: Whether or not to apply Lin et al. 2004 smoothing.\n\n    Returns:\n      3-Tuple with the BLEU score, n-gram precisions, geometric mean of n-gram\n      precisions and brevity penalty.", "id": "f3030:m1"}
{"signature": "def _get_ngrams(segment, max_order):", "body": "ngram_counts = collections.Counter()<EOL>for order in range(<NUM_LIT:1>, max_order + <NUM_LIT:1>):<EOL><INDENT>for i in range(<NUM_LIT:0>, len(segment) - order + <NUM_LIT:1>):<EOL><INDENT>ngram = tuple(segment[i:i+order])<EOL>ngram_counts[ngram] += <NUM_LIT:1><EOL><DEDENT><DEDENT>return ngram_counts<EOL>", "docstring": "Extracts all n-grams upto a given maximum order from an input segment.\n\n    Args:\n      segment: text segment from which n-grams will be extracted.\n      max_order: maximum length in tokens of the n-grams returned by this\n          methods.\n\n    Returns:\n      The Counter containing all n-grams upto max_order in segment\n      with a count of how many times each n-gram occurred.", "id": "f3030:m0"}
{"signature": "@register_metric('<STR_LIT>')<EOL>def squad_v2_f1(y_true: List[List[str]], y_predicted: List[str]) -> float:", "body": "f1_total = <NUM_LIT:0.0><EOL>for ground_truth, prediction in zip(y_true, y_predicted):<EOL><INDENT>prediction_tokens = normalize_answer(prediction).split()<EOL>f1s = []<EOL>for gt in ground_truth:<EOL><INDENT>gt_tokens = normalize_answer(gt).split()<EOL>if len(gt_tokens) == <NUM_LIT:0> or len(prediction_tokens) == <NUM_LIT:0>:<EOL><INDENT>f1s.append(float(gt_tokens == prediction_tokens))<EOL>continue<EOL><DEDENT>common = Counter(prediction_tokens) & Counter(gt_tokens)<EOL>num_same = sum(common.values())<EOL>if num_same == <NUM_LIT:0>:<EOL><INDENT>f1s.append(<NUM_LIT:0.0>)<EOL>continue<EOL><DEDENT>precision = <NUM_LIT:1.0> * num_same / len(prediction_tokens)<EOL>recall = <NUM_LIT:1.0> * num_same / len(gt_tokens)<EOL>f1 = (<NUM_LIT:2> * precision * recall) / (precision + recall)<EOL>f1s.append(f1)<EOL><DEDENT>f1_total += max(f1s)<EOL><DEDENT>return <NUM_LIT:100> * f1_total / len(y_true) if len(y_true) > <NUM_LIT:0> else <NUM_LIT:0><EOL>", "docstring": "Calculates F-1 score between y_true and y_predicted\n        F-1 score uses the best matching y_true answer\n\n    The same as in SQuAD-v2.0\n\n    Args:\n        y_true: list of correct answers (correct answers are represented by list of strings)\n        y_predicted: list of predicted answers\n\n    Returns:\n        F-1 score : float", "id": "f3031:m2"}
{"signature": "def fit(self, data: List[Dict[Any, Any]]) -> None:", "body": "log.info(f\"<STR_LIT>\")<EOL>self.ec_data = [dict(item, **{<EOL>'<STR_LIT>': self.preprocess.spacy2dict(self.preprocess.analyze(item['<STR_LIT>'])),<EOL>'<STR_LIT>': self.preprocess.spacy2dict(self.preprocess.analyze(item['<STR_LIT>']+'<STR_LIT>'+item['<STR_LIT>']))<EOL>}) for item in data]<EOL>log.info('<STR_LIT>')<EOL>", "docstring": "Preprocess items `title` and `description` from the `data`\n\n        Parameters:\n            data: list of catalog items\n\n        Returns:\n            None", "id": "f3034:c0:m1"}
{"signature": "def load(self, **kwargs) -> None:", "body": "log.info(f\"<STR_LIT>\")<EOL>for path in self.load_path:<EOL><INDENT>if Path.is_file(path):<EOL><INDENT>self.ec_data += load_pickle(path)<EOL><DEDENT>else:<EOL><INDENT>raise FileNotFoundError<EOL><DEDENT><DEDENT>log.info(f\"<STR_LIT>\")<EOL>", "docstring": "Load classifier parameters", "id": "f3034:c0:m3"}
{"signature": "def load(self) -> None:", "body": "log.info(\"<STR_LIT>\".format(self.load_path))<EOL>self.ec_data, self.x_train_features = load_pickle(<EOL>expand_path(self.load_path))<EOL>", "docstring": "Load classifier parameters", "id": "f3035:c0:m3"}
{"signature": "def save(self) -> None:", "body": "log.info(\"<STR_LIT>\".format(self.save_path))<EOL>path = expand_path(self.save_path)<EOL>save_pickle((self.ec_data, self.x_train_features), path)<EOL>", "docstring": "Save classifier parameters", "id": "f3035:c0:m2"}
{"signature": "def __call__(self, utterances_batch: list, history_batch: list,<EOL>states_batch: Optional[list]=None) -> Tuple[list, list, list]:", "body": "batch_len = len(utterances_batch)<EOL>confidence_batch = [<NUM_LIT:1.0>] * batch_len<EOL>response_batch: List[Optional[str]] = [None] * batch_len<EOL>infer_indexes = []<EOL>if not states_batch:<EOL><INDENT>states_batch: List[Optional[dict]] = [None] * batch_len<EOL><DEDENT>for utt_i, utterance in enumerate(utterances_batch):<EOL><INDENT>if not states_batch[utt_i]:<EOL><INDENT>states_batch[utt_i] = {'<STR_LIT>': list(self.model.in_x), '<STR_LIT>': []}<EOL><DEDENT>if utterance:<EOL><INDENT>states_batch[utt_i]['<STR_LIT>'].pop(<NUM_LIT:0>)<EOL>states_batch[utt_i]['<STR_LIT>'].append(utterance)<EOL><DEDENT>if states_batch[utt_i]['<STR_LIT>']:<EOL><INDENT>response = self.proposal.format(states_batch[utt_i]['<STR_LIT>'][<NUM_LIT:0>])<EOL>response_batch[utt_i] = response<EOL><DEDENT>else:<EOL><INDENT>infer_indexes.append(utt_i)<EOL><DEDENT><DEDENT>if infer_indexes:<EOL><INDENT>infer_utterances = zip(*[tuple(states_batch[i]['<STR_LIT>']) for i in infer_indexes])<EOL>infer_results = self.model(*infer_utterances)<EOL>if len(self.model.out_params) > <NUM_LIT:1>:<EOL><INDENT>infer_results = ['<STR_LIT>'.join([str(out_y) for out_y in result]) for result in zip(*infer_results)]<EOL><DEDENT>for infer_i, infer_result in zip(infer_indexes, infer_results):<EOL><INDENT>response_batch[infer_i] = infer_result<EOL>states_batch[infer_i] = None<EOL><DEDENT><DEDENT>return response_batch, confidence_batch, states_batch<EOL>", "docstring": "Returns skill inference result.\n\n        Returns batches of skill inference results, estimated confidence\n            levels and up to date states corresponding to incoming utterance\n            batch. Also handles interaction with multiargument models using\n            skill states.\n\n        Args:\n            utterances_batch: A batch of utterances of any type.\n            history_batch: Not used. A batch of list typed histories for each\n                utterance.\n            states_batch: A batch of states for each utterance.\n\n        Returns:\n            response: A batch of arbitrary typed skill inference results.\n            confidence: A batch of float typed confidence levels for each of\n                skill inference result.\n            states: Optional. A batch of states for each response.", "id": "f3036:c0:m1"}
{"signature": "def to_one_hot(x, k):", "body": "unit = np.eye(k, dtype=int)<EOL>return unit[x]<EOL>", "docstring": "Takes an array of integers and transforms it\nto an array of one-hot encoded vectors", "id": "f3044:m0"}
{"signature": "@property<EOL><INDENT>def tags_number_(self) -> int:<DEDENT>", "body": "return len(self.tags)<EOL>", "docstring": "Tag vocabulary size", "id": "f3048:c0:m3"}
{"signature": "def next_generation(self, generation: List[dict], scores: List[float], iteration: int) -> List[dict]:", "body": "next_population = self.selection_of_best_with_weights(generation, scores)<EOL>log.info(\"<STR_LIT>\".format(self.n_saved_best_pretrained))<EOL>offsprings = self.crossover(generation, scores)<EOL>changable_next = self.mutation(offsprings)<EOL>next_population.extend(changable_next)<EOL>for i in range(self.n_saved_best_pretrained):<EOL><INDENT>if self.train_partition != <NUM_LIT:1>:<EOL><INDENT>file_ext = str(Path(next_population[i][\"<STR_LIT>\"][\"<STR_LIT:train>\"]).suffix)<EOL>next_population[i][\"<STR_LIT>\"][\"<STR_LIT:train>\"] = \"<STR_LIT:_>\".join(<EOL>Path(next_population[i][\"<STR_LIT>\"][\"<STR_LIT:train>\"]).stem.split(\"<STR_LIT:_>\")[:-<NUM_LIT:1>]<EOL>) + \"<STR_LIT:_>\" + str(iteration % self.train_partition) + file_ext<EOL><DEDENT>if self.elitism_with_weights:<EOL><INDENT>self.insert_value_or_dict_into_config(<EOL>next_population[i], self.path_to_models_load_path,<EOL>self.get_value_from_config(next_population[i], self.path_to_models_save_path))<EOL><DEDENT>else:<EOL><INDENT>self.insert_value_or_dict_into_config(<EOL>next_population[i], self.path_to_models_load_path,<EOL>str(self.models_path / f\"<STR_LIT>\" / f\"<STR_LIT>\"))<EOL><DEDENT>self.insert_value_or_dict_into_config(<EOL>next_population[i], self.path_to_models_save_path,<EOL>str(self.models_path / f\"<STR_LIT>\" / f\"<STR_LIT>\"))<EOL><DEDENT>for i in range(self.n_saved_best_pretrained, self.population_size):<EOL><INDENT>if self.train_partition != <NUM_LIT:1>:<EOL><INDENT>file_ext = str(Path(next_population[i][\"<STR_LIT>\"][\"<STR_LIT:train>\"]).suffix)<EOL>next_population[i][\"<STR_LIT>\"][\"<STR_LIT:train>\"] = \"<STR_LIT:_>\".join(<EOL>[str(p) for p in Path(next_population[i][\"<STR_LIT>\"][\"<STR_LIT:train>\"]).stem.split(\"<STR_LIT:_>\")[:-<NUM_LIT:1>]])+ \"<STR_LIT:_>\" + str(iteration % self.train_partition) + file_ext<EOL><DEDENT>self.insert_value_or_dict_into_config(<EOL>next_population[i], self.path_to_models_save_path,<EOL>str(self.models_path / f\"<STR_LIT>\" / f\"<STR_LIT>\"))<EOL>self.insert_value_or_dict_into_config(<EOL>next_population[i], self.path_to_models_load_path,<EOL>str(self.models_path / f\"<STR_LIT>\" / f\"<STR_LIT>\"))<EOL>next_population[i][\"<STR_LIT>\"] = self.evolution_model_id<EOL>self.evolution_model_id += <NUM_LIT:1><EOL><DEDENT>return next_population<EOL>", "docstring": "Provide replacement\n\nArgs:\n    generation: current generation (set of self.population_size configs\n    scores: corresponding scores that should be maximized\n    iteration: iteration number\n\nReturns:\n    the next generation according to the given scores of current generation", "id": "f3049:c0:m2"}
{"signature": "def crossover(self, population: List[dict], scores: List[float]) -> List[dict]:", "body": "offsprings = []<EOL>ranges = self.range_scores(scores)<EOL>a = <NUM_LIT:1.> / (<NUM_LIT:1.> - self.population_size)<EOL>b = self.population_size / (self.population_size - <NUM_LIT:1.>)<EOL>probas_to_be_parent = (a * ranges + b) / np.sum(a * ranges + b)<EOL>intervals = np.array([np.sum(probas_to_be_parent[:i]) for i in range(self.population_size)])<EOL>for i in range(self.population_size - self.n_saved_best_pretrained):<EOL><INDENT>rs = np.random.random(<NUM_LIT:2>)<EOL>parents = population[np.where(rs[<NUM_LIT:0>] > intervals)[<NUM_LIT:0>][-<NUM_LIT:1>]], population[np.where(rs[<NUM_LIT:1>] > intervals)[<NUM_LIT:0>][-<NUM_LIT:1>]]<EOL>if self.decision(self.p_crossover):<EOL><INDENT>params_perm = np.random.permutation(self.n_params)<EOL>curr_offsprings = [deepcopy(parents[<NUM_LIT:0>]),<EOL>deepcopy(parents[<NUM_LIT:1>])]<EOL>part = int(self.crossover_power * self.n_params)<EOL>for j in range(self.n_params - part, self.n_params):<EOL><INDENT>self.insert_value_or_dict_into_config(curr_offsprings[<NUM_LIT:0>],<EOL>self.paths_to_params[<EOL>params_perm[j]],<EOL>self.get_value_from_config(<EOL>parents[<NUM_LIT:1>],<EOL>self.paths_to_params[<EOL>params_perm[j]]))<EOL>self.insert_value_or_dict_into_config(curr_offsprings[<NUM_LIT:1>],<EOL>self.paths_to_params[<EOL>params_perm[j]],<EOL>self.get_value_from_config(<EOL>parents[<NUM_LIT:0>],<EOL>self.paths_to_params[<EOL>params_perm[j]]))<EOL><DEDENT>offsprings.append(deepcopy(curr_offsprings[<NUM_LIT:0>]))<EOL><DEDENT>else:<EOL><INDENT>offsprings.append(deepcopy(parents[<NUM_LIT:0>]))<EOL><DEDENT><DEDENT>return offsprings<EOL>", "docstring": "Recombine randomly population in pairs and cross over them with given probability.\nCross over from two parents produces two offsprings\neach of which contains crossover_power portion of the parameter values from one parent,\n and the other (1 - crossover_power portion) from the other parent\n\nArgs:\n    population: self.population_size individuums\n    scores: list of corresponding scores\n\nReturns:\n    (self.population_size - self.n_saved_best_pretained) offsprings", "id": "f3049:c0:m5"}
{"signature": "def __init__(self, load_path: str, wiki_filename: str, entities_filename: str, inverted_index_filename: str,<EOL>id_to_name_file: str, lemmatize: bool = True, debug: bool = False, rule_filter_entities: bool = True,<EOL>use_inverted_index: bool = True, language: str = '<STR_LIT>', *args, **kwargs) -> None:", "body": "super().__init__(save_path=None, load_path=load_path)<EOL>self.morph = pymorphy2.MorphAnalyzer()<EOL>self.lemmatize = lemmatize<EOL>self.debug = debug<EOL>self.rule_filter_entities = rule_filter_entities<EOL>self.use_inverted_index = use_inverted_index<EOL>self._language = language<EOL>if language not in self.LANGUAGES:<EOL><INDENT>log.warning(f'<STR_LIT>')<EOL><DEDENT>self._wiki_filename = wiki_filename<EOL>self._entities_filename = entities_filename<EOL>self.inverted_index_filename = inverted_index_filename<EOL>self.id_to_name_file = id_to_name_file<EOL>self.name_to_q: Optional[Dict[str, List[Tuple[str]]]] = None<EOL>self.wikidata: Optional[Dict[str, List[List[str]]]] = None<EOL>self.inverted_index: Optional[Dict[str, List[Tuple[str]]]] = None<EOL>self.id_to_name: Optional[Dict[str, Dict[List[str]]]] = None<EOL>self.load()<EOL>if self.use_inverted_index:<EOL><INDENT>alphabet = \"<STR_LIT>\"<EOL>dictionary_words = list(self.inverted_index.keys())<EOL>self.searcher = LevenshteinSearcher(alphabet, dictionary_words)<EOL><DEDENT>", "docstring": "Args:\n    load_path: path to folder with wikidata files\n    wiki_filename: file with Wikidata triplets\n    entities_filename: file with dict of entity titles (keys) and entity ids (values)\n    inverted_index_filename: file with dict of words (keys) and entities containing these words (values)\n    id_to_name_file: file with dict of entity ids (keys) and entities names and aliases (values)\n    lemmatize: whether to lemmatize tokens of extracted entity\n    debug: whether to print entities extracted from Wikidata\n    rule_filter_entities: whether to filter entities which do not fit the question\n    use_inverted_index: whether to use inverted index for entity linking\n    language - the language of the linker (used for filtration of some questions to improve overall performance)\n    *args:\n    **kwargs:", "id": "f3051:c0:m0"}
{"signature": "def __call__(self, batch: List[List[List[Tuple[float, str]]]]) -> List[List[str]]:", "body": "return [self._infer_instance(candidates) for candidates in batch]<EOL>", "docstring": "Choose the best candidate for every token\n\n        Args:\n            batch: batch of probabilities and string values of candidates for every token in a sentence\n\n        Returns:\n            batch of corrected tokenized sentences", "id": "f3053:c0:m1"}
{"signature": "def transduce(self, first, second, threshold):", "body": "add_pred = (lambda x, y: x <= threshold)<EOL>clear_pred =(lambda x, y: False)<EOL>update_func = (lambda x, y: min(x, y))<EOL>costs, backtraces = self._fill_levenshtein_table(first, second,<EOL>update_func, add_pred, clear_pred,<EOL>threshold=threshold)<EOL>result = self._backtraces_to_transductions(first, second,<EOL>backtraces, threshold, return_cost=True)<EOL>return result<EOL>", "docstring": "\u0412\u043e\u0437\u0432\u0440\u0430\u0449\u0430\u0435\u0442 \u0432\u0441\u0435 \u0442\u0440\u0430\u043d\u0441\u0434\u0443\u043a\u0446\u0438\u0438, \u043f\u0435\u0440\u0435\u0432\u043e\u0434\u044f\u0449\u0438\u0435 first \u0432 second,\n\u0447\u044c\u044f \u0441\u0442\u043e\u0438\u043c\u043e\u0441\u0442\u044c \u043d\u0435 \u043f\u0440\u0435\u0432\u044b\u0448\u0430\u0435\u0442 threshold\n\n\u0412\u043e\u0437\u0432\u0440\u0430\u0449\u0430\u0435\u0442:\n----------\nresult : list\n    \u0441\u043f\u0438\u0441\u043e\u043a \u0432\u0438\u0434\u0430 [(\u0442\u0440\u0430\u043d\u0441\u0434\u0443\u043a\u0446\u0438\u044f, \u0441\u0442\u043e\u0438\u043c\u043e\u0441\u0442\u044c)]", "id": "f3056:c1:m4"}
{"signature": "def lower_transductions(self, word, max_cost, return_cost=True):", "body": "prefixes = [[] for i in range(len(word) + <NUM_LIT:1>)]<EOL>prefixes[<NUM_LIT:0>].append(((), <NUM_LIT:0.0>))<EOL>for pos in range(len(prefixes)):<EOL><INDENT>prefixes[pos] = self._perform_insertions(prefixes[pos], max_cost)<EOL>max_upperside_length = min(len(word) - pos, self.max_up_length)<EOL>for upperside_length in range(<NUM_LIT:1>, max_upperside_length + <NUM_LIT:1>):<EOL><INDENT>up = word[pos: pos + upperside_length]<EOL>for low, low_cost in self.operation_costs.get(up, dict()).items():<EOL><INDENT>for transduction, cost in prefixes[pos]:<EOL><INDENT>new_cost = cost + low_cost<EOL>if new_cost <= max_cost:<EOL><INDENT>new_transduction = transduction +(up, low)<EOL>prefixes[pos + upperside_length].append((new_transduction, new_cost))<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>answer = sorted(prefixes[-<NUM_LIT:1>], key=(lambda x: x[<NUM_LIT:0>]))<EOL>if return_cost:<EOL><INDENT>return answer<EOL><DEDENT>else:<EOL><INDENT>return [elem[<NUM_LIT:0>] for elem in answer]<EOL><DEDENT>", "docstring": "\u0412\u043e\u0437\u0432\u0440\u0430\u0449\u0430\u0435\u0442 \u0432\u0441\u0435 \u0442\u0440\u0430\u043d\u0441\u0434\u0443\u043a\u0446\u0438\u0438 \u0441 \u0432\u0435\u0440\u0445\u043d\u0438\u043c \u044d\u043b\u0435\u043c\u0435\u043d\u0442\u043e\u043c word,\n    \u0447\u044c\u044f \u0441\u0442\u043e\u0438\u043c\u043e\u0441\u0442\u044c \u043d\u0435 \u043f\u0440\u0435\u0432\u044b\u0448\u0430\u0435\u0442 max_cost\n\n`   \u0412\u043e\u0437\u0432\u0440\u0430\u0449\u0430\u0435\u0442:\n    ----------\n    result : list\n        \u0441\u043f\u0438\u0441\u043e\u043a \u0432\u0438\u0434\u0430 [(\u0442\u0440\u0430\u043d\u0441\u0434\u0443\u043a\u0446\u0438\u044f, \u0441\u0442\u043e\u0438\u043c\u043e\u0441\u0442\u044c)], \u0435\u0441\u043b\u0438 return_cost=True\n        \u0441\u043f\u0438\u0441\u043e\u043a \u0442\u0440\u0430\u043d\u0441\u0434\u0443\u043a\u0446\u0438\u0439, \u0435\u0441\u043b\u0438 return_cost=False\n        \u0441\u043f\u0438\u0441\u043e\u043a \u043e\u0442\u0441\u043e\u0440\u0442\u0438\u0440\u043e\u0432\u0430\u043d \u0432 \u043f\u043e\u0440\u044f\u0434\u043a\u0435 \u0432\u043e\u0437\u0440\u0430\u0441\u0442\u0430\u043d\u0438\u044f \u0441\u0442\u043e\u0438\u043c\u043e\u0441\u0442\u0438 \u0442\u0440\u0430\u043d\u0441\u0434\u0443\u043a\u0446\u0438\u0438", "id": "f3056:c1:m5"}
{"signature": "def _descend_cashed(self, curr, s):", "body": "if s == \"<STR_LIT>\":<EOL><INDENT>return curr<EOL><DEDENT>curr_cash = self._descendance_cash[curr]<EOL>answer = curr_cash.get(s, None)<EOL>if answer is not None:<EOL><INDENT>return answer<EOL><DEDENT>res = curr<EOL>for a in s:<EOL><INDENT>res = self.graph[res][self.alphabet_codes[a]]<EOL>if res == Trie.NO_NODE:<EOL><INDENT>break<EOL><DEDENT><DEDENT>curr_cash[s] = res<EOL>return res<EOL>", "docstring": "\u0421\u043f\u0443\u0441\u043a \u0438\u0437 \u0432\u0435\u0440\u0448\u0438\u043d\u044b curr \u043f\u043e \u0441\u0442\u0440\u043e\u043a\u0435 s \u0441 \u043a\u044d\u0448\u0438\u0440\u043e\u0432\u0430\u043d\u0438\u0435\u043c", "id": "f3058:c0:m18"}
{"signature": "def find_partitions(self, s, max_count=<NUM_LIT:1>):", "body": "curr_agenda = [(self.root, [], <NUM_LIT:0>)]<EOL>for i, a in enumerate(s):<EOL><INDENT>next_agenda = []<EOL>for curr, borders, cost in curr_agenda:<EOL><INDENT>if cost >= max_count:<EOL><INDENT>continue<EOL><DEDENT>child = self.graph[curr][self.alphabet_codes[a]]<EOL>if child == Trie.NO_NODE:<EOL><INDENT>continue<EOL><DEDENT>next_agenda.append((child, borders, cost))<EOL>if self.is_final(child):<EOL><INDENT>next_agenda.append((self.root, borders + [i+<NUM_LIT:1>], cost+<NUM_LIT:1>))<EOL><DEDENT><DEDENT>curr_agenda = next_agenda<EOL><DEDENT>answer = []<EOL>for curr, borders, cost in curr_agenda:<EOL><INDENT>if curr == self.root:<EOL><INDENT>borders = [<NUM_LIT:0>] + borders<EOL>answer.append([s[left:borders[i+<NUM_LIT:1>]] for i, left in enumerate(borders[:-<NUM_LIT:1>])])<EOL><DEDENT><DEDENT>return answer<EOL>", "docstring": "\u041d\u0430\u0445\u043e\u0434\u0438\u0442 \u0432\u0441\u0435 \u0440\u0430\u0437\u0431\u0438\u0435\u043d\u0438\u044f s = s_1 ... s_m \u043d\u0430 \u0441\u043b\u043e\u0432\u0430\u0440\u043d\u044b\u0435 \u0441\u043b\u043e\u0432\u0430 s_1, ..., s_m\n\u0434\u043b\u044f m <= max_count", "id": "f3058:c0:m12"}
{"signature": "def add(self, s):", "body": "if self.is_terminated:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if s == \"<STR_LIT>\":<EOL><INDENT>self._set_final(self.root)<EOL>return<EOL><DEDENT>curr = self.root<EOL>for i, a in enumerate(s):<EOL><INDENT>code = self.alphabet_codes[a]<EOL>next = self.graph[curr][code]<EOL>if next == Trie.NO_NODE:<EOL><INDENT>curr = self._add_descendant(curr, s[i:])<EOL>break<EOL><DEDENT>else:<EOL><INDENT>curr = next<EOL><DEDENT><DEDENT>self._set_final(curr)<EOL>return self<EOL>", "docstring": "\u0414\u043e\u0431\u0430\u0432\u043b\u0435\u043d\u0438\u0435 \u0441\u0442\u0440\u043e\u043a\u0438 s \u0432 \u043f\u0440\u0435\u0444\u0438\u043a\u0441\u043d\u044b\u0439 \u0431\u043e\u0440", "id": "f3058:c0:m6"}
{"signature": "def _set_final(self, curr):", "body": "self.final[curr] = True<EOL>", "docstring": "\u0414\u0435\u043b\u0430\u0435\u0442 \u0441\u043e\u0441\u0442\u043e\u044f\u043d\u0438\u0435 curr \u0437\u0430\u0432\u0435\u0440\u0448\u0430\u044e\u0449\u0438\u043c", "id": "f3058:c0:m19"}
{"signature": "def words(self):", "body": "branch, word, indexes = [self.root], [], [<NUM_LIT:0>]<EOL>letters_with_children = [self._get_children_and_letters(self.root)]<EOL>while len(branch) > <NUM_LIT:0>:<EOL><INDENT>if self.is_final(branch[-<NUM_LIT:1>]):<EOL><INDENT>yield \"<STR_LIT>\".join(word)<EOL><DEDENT>while indexes[-<NUM_LIT:1>] == len(letters_with_children[-<NUM_LIT:1>]):<EOL><INDENT>indexes.pop()<EOL>letters_with_children.pop()<EOL>branch.pop()<EOL>if len(indexes) == <NUM_LIT:0>:<EOL><INDENT>raise StopIteration()<EOL><DEDENT>word.pop()<EOL><DEDENT>next_letter, next_child = letters_with_children[-<NUM_LIT:1>][indexes[-<NUM_LIT:1>]]<EOL>indexes[-<NUM_LIT:1>] += <NUM_LIT:1><EOL>indexes.append(<NUM_LIT:0>)<EOL>word.append(next_letter)<EOL>branch.append(next_child)<EOL>letters_with_children.append(self._get_children_and_letters(branch[-<NUM_LIT:1>]))<EOL><DEDENT>", "docstring": "\u0412\u043e\u0437\u0432\u0440\u0430\u0449\u0430\u0435\u0442 \u0438\u0442\u0435\u0440\u0430\u0442\u043e\u0440 \u043f\u043e \u0441\u043b\u043e\u0432\u0430\u043c, \u0441\u043e\u0434\u0435\u0440\u0436\u0430\u0449\u0438\u043c\u0441\u044f \u0432 \u0431\u043e\u0440\u0435", "id": "f3058:c0:m10"}
{"signature": "def process_word(word: str, to_lower: bool = False,<EOL>append_case: Optional[str] = None) -> Tuple[str]:", "body": "if all(x.isupper() for x in word) and len(word) > <NUM_LIT:1>:<EOL><INDENT>uppercase = \"<STR_LIT>\"<EOL><DEDENT>elif word[<NUM_LIT:0>].isupper():<EOL><INDENT>uppercase = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>uppercase = None<EOL><DEDENT>if to_lower:<EOL><INDENT>word = word.lower()<EOL><DEDENT>if word.isdigit():<EOL><INDENT>answer = [\"<STR_LIT>\"]<EOL><DEDENT>elif word.startswith(\"<STR_LIT>\") or word.startswith(\"<STR_LIT>\"):<EOL><INDENT>answer = [\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>answer = list(word)<EOL><DEDENT>if to_lower and uppercase is not None:<EOL><INDENT>if append_case == \"<STR_LIT>\":<EOL><INDENT>answer = [uppercase] + answer<EOL><DEDENT>elif append_case == \"<STR_LIT>\":<EOL><INDENT>answer = answer + [uppercase]<EOL><DEDENT><DEDENT>return tuple(answer)<EOL>", "docstring": "Converts word to a tuple of symbols, optionally converts it to lowercase\n    and adds capitalization label.\n\n    Args:\n        word: input word\n        to_lower: whether to lowercase\n        append_case: whether to add case mark\n            ('<FIRST_UPPER>' for first capital and '<ALL_UPPER>' for all caps)\n\n    Returns:\n        a preprocessed word", "id": "f3061:m0"}
{"signature": "def _get_idx(self, el: str) -> int:", "body": "for e in (el, el.lower(), el.capitalize(), el.upper()):<EOL><INDENT>if e in self.token2idx_dict:<EOL><INDENT>return self.token2idx_dict[e]<EOL><DEDENT><DEDENT>return <NUM_LIT:1><EOL>", "docstring": "Returns idx for el (token or char).\n\n        Args:\n            el: token or character\n\n        Returns:\n            idx in vocabulary", "id": "f3063:c2:m7"}
{"signature": "def __call__(self, contexts_raw: Tuple[str, ...], questions_raw: Tuple[str, ...],<EOL>**kwargs) -> Tuple[<EOL>List[str], List[List[str]], List[List[List[str]]],<EOL>List[List[int]], List[List[int]],<EOL>List[str], List[List[str]], List[List[List[str]]],<EOL>List[List[Tuple[int, int]]]<EOL>]:", "body": "contexts = []<EOL>contexts_tokens = []<EOL>contexts_chars = []<EOL>contexts_r2p = []<EOL>contexts_p2r = []<EOL>questions = []<EOL>questions_tokens = []<EOL>questions_chars = []<EOL>spans = []<EOL>for c_raw, q_raw in zip(contexts_raw, questions_raw):<EOL><INDENT>c, r2p, p2r = SquadPreprocessor.preprocess_str(c_raw, return_mapping=True)<EOL>c_tokens = [token.replace(\"<STR_LIT>\", '<STR_LIT:\">').replace(\"<STR_LIT>\", '<STR_LIT:\">') for token in word_tokenize(c)][:self.context_limit]<EOL>c_chars = [list(token)[:self.char_limit] for token in c_tokens]<EOL>q = SquadPreprocessor.preprocess_str(q_raw)<EOL>q_tokens = [token.replace(\"<STR_LIT>\", '<STR_LIT:\">').replace(\"<STR_LIT>\", '<STR_LIT:\">') for token in word_tokenize(q)][:self.question_limit]<EOL>q_chars = [list(token)[:self.char_limit] for token in q_tokens]<EOL>contexts.append(c)<EOL>contexts_tokens.append(c_tokens)<EOL>contexts_chars.append(c_chars)<EOL>contexts_r2p.append(r2p)<EOL>contexts_p2r.append(p2r)<EOL>questions.append(q)<EOL>questions_tokens.append(q_tokens)<EOL>questions_chars.append(q_chars)<EOL>spans.append(SquadPreprocessor.convert_idx(c, c_tokens))<EOL><DEDENT>return contexts, contexts_tokens, contexts_chars, contexts_r2p, contexts_p2r,questions, questions_tokens, questions_chars, spans<EOL>", "docstring": "Performs preprocessing of context and question\n        Args:\n            contexts_raw: batch of contexts to preprocess\n            questions_raw: batch of questions to preprocess\n\n        Returns:\n            context: batch of processed contexts\n            contexts_tokens: batch of tokenized contexts\n            contexts_chars: batch of tokenized and split on chars contexts\n            contexts_r2p: batch of mappings from raw context to processed context\n            contexts_p2r: batch of mappings from procesesd context to raw context\n            questions: batch of processed questions\n            questions_tokens: batch of tokenized questions\n            questions_chars: batch of tokenized and split on chars questions\n            spans: batch of mapping tokens to position in context", "id": "f3063:c0:m1"}
{"signature": "def __call__(self, batch_docs: List[Union[str, List[str]]]) ->List[Union[List[str], List[List[str]]]]:", "body": "result = []<EOL>for docs in batch_docs:<EOL><INDENT>batch_chunks = []<EOL>if isinstance(docs, str):<EOL><INDENT>docs = [docs]<EOL><DEDENT>for doc in docs:<EOL><INDENT>if self.paragraphs:<EOL><INDENT>split_doc = doc.split('<STR_LIT>')<EOL>split_doc = [sd.strip() for sd in split_doc]<EOL>split_doc = list(filter(lambda x: len(x) > <NUM_LIT>, split_doc))<EOL>batch_chunks.append(split_doc)<EOL><DEDENT>else:<EOL><INDENT>doc_chunks = []<EOL>if self.keep_sentences:<EOL><INDENT>sentences = sent_tokenize(doc)<EOL>n_tokens = <NUM_LIT:0><EOL>keep = []<EOL>for s in sentences:<EOL><INDENT>n_tokens += len(s.split())<EOL>if n_tokens > self.tokens_limit:<EOL><INDENT>if keep:<EOL><INDENT>doc_chunks.append('<STR_LIT:U+0020>'.join(keep))<EOL>n_tokens = <NUM_LIT:0><EOL>keep.clear()<EOL><DEDENT><DEDENT>keep.append(s)<EOL><DEDENT>if keep:<EOL><INDENT>doc_chunks.append('<STR_LIT:U+0020>'.join(keep))<EOL><DEDENT>batch_chunks.append(doc_chunks)<EOL><DEDENT>else:<EOL><INDENT>split_doc = doc.split()<EOL>doc_chunks = [split_doc[i:i + self.tokens_limit] for i in<EOL>range(<NUM_LIT:0>, len(split_doc), self.tokens_limit)]<EOL>batch_chunks.append(doc_chunks)<EOL><DEDENT><DEDENT><DEDENT>result.append(batch_chunks)<EOL><DEDENT>if self.flatten_result:<EOL><INDENT>if isinstance(result[<NUM_LIT:0>][<NUM_LIT:0>], list):<EOL><INDENT>for i in range(len(result)):<EOL><INDENT>flattened = list(chain.from_iterable(result[i]))<EOL>result[i] = flattened<EOL><DEDENT><DEDENT><DEDENT>return result<EOL>", "docstring": "Make chunks from a batch of documents. There can be several documents in each batch.\n        Args:\n            batch_docs: a batch of documents / a batch of lists of documents\n        Returns:\n            chunks of docs, flattened or not", "id": "f3066:c0:m1"}
{"signature": "def __call__(self, texts_a: List[str], texts_b: Optional[List[str]] = None) -> List[InputFeatures]:", "body": "if texts_b is None:<EOL><INDENT>texts_b = [None] * len(texts_a)<EOL><DEDENT>examples = [InputExample(unique_id=<NUM_LIT:0>, text_a=text_a, text_b=text_b)<EOL>for text_a, text_b in zip(texts_a, texts_b)]<EOL>return convert_examples_to_features(examples, self.max_seq_length, self.tokenizer)<EOL>", "docstring": "Call Bert convert_examples_to_features function to tokenize and create masks.\n\n        texts_a and texts_b are separated by [SEP] token\n\n        Args:\n            texts_a: list of texts,\n            texts_b: list of texts, it could be None, e.g. single sentence classification task\n\n        Returns:\n            batch of InputFeatures with subtokens, subtoken ids, subtoken mask, segment mask.", "id": "f3067:c0:m1"}
{"signature": "def __call__(self, tokens_batch, **kwargs):", "body": "lemma_batch = []<EOL>for utterance in tokens_batch:<EOL><INDENT>lemma_utterance = []<EOL>for token in utterance:<EOL><INDENT>p = self.lemmatizer.parse(token)[<NUM_LIT:0>]<EOL>lemma_utterance.append(p.normal_form)<EOL><DEDENT>lemma_batch.append(lemma_utterance)<EOL><DEDENT>return lemma_batch<EOL>", "docstring": "Takes batch of tokens and returns the lemmatized tokens.", "id": "f3070:c0:m1"}
{"signature": "def parse_input(self, inp: str) -> Dict[Any, Any]:", "body": "state: List = []<EOL>for i in range(len(inp.split()) // <NUM_LIT:2>, <NUM_LIT:0>, -<NUM_LIT:1>):<EOL><INDENT>state.append([inp.split(None, <NUM_LIT:1>)[<NUM_LIT:0>], inp.split(None, <NUM_LIT:1>)[<NUM_LIT:1>].split()[<NUM_LIT:0>]])<EOL>if i > <NUM_LIT:1>:<EOL><INDENT>inp = inp.split(None, <NUM_LIT:2>)[<NUM_LIT:2>]<EOL><DEDENT><DEDENT>return dict(state)<EOL>", "docstring": "Convert space-delimited string into dialog state", "id": "f3074:c0:m9"}
{"signature": "def spacy2dict(self, doc: spacy.tokens.Doc, fields: List[str] = None) -> List[Dict[Any, Any]]:", "body": "if fields is None:<EOL><INDENT>fields = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:text>']<EOL><DEDENT>return [{field: getattr(token, field) for field in fields} for token in doc]<EOL>", "docstring": "Convert SpaCy doc into list of tokens with `fields` properties only", "id": "f3074:c0:m4"}
{"signature": "def load(self, fname: str = None) -> None:", "body": "if fname is None:<EOL><INDENT>fname = self.load_path<EOL><DEDENT>fname = Path(fname).with_suffix('<STR_LIT>')<EOL>if fname.exists():<EOL><INDENT>log.info(\"<STR_LIT>\".format(self.model_class, str(fname)))<EOL>with open(fname, \"<STR_LIT:rb>\") as f:<EOL><INDENT>self.model = pickle.load(f)<EOL><DEDENT>warm_start = self.model_params.get(\"<STR_LIT>\", None)<EOL>self.model_params = {param: getattr(self.model, param) for param in self.get_class_attributes(self.model)}<EOL>self.model_class = self.model.__module__ + self.model.__class__.__name__<EOL>log.info(\"<STR_LIT>\".format(self.model_class))<EOL>if warm_start and \"<STR_LIT>\" in self.model_params.keys():<EOL><INDENT>self.model_params[\"<STR_LIT>\"] = True<EOL>log.info(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>log.warning(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>log.warning(\"<STR_LIT>\".format(str(fname)))<EOL>self.init_from_scratch()<EOL><DEDENT>return<EOL>", "docstring": "Initialize ``self.model`` as some sklearn model from saved re-initializing ``self.model_params`` parameters. \\\n    If in new given parameters ``warm_start`` is set to True and given model admits ``warm_start`` parameter, \\\n    model will be initilized from saved with opportunity to continue fitting.\n\nArgs:\n    fname: string name of path to model to load from\n\nReturns:\n    None", "id": "f3077:c0:m4"}
{"signature": "@staticmethod<EOL><INDENT>def compose_input_data(x: List[Union[Tuple[Union[np.ndarray, list, spmatrix, str]],<EOL>List[Union[np.ndarray, list, spmatrix, str]],<EOL>np.ndarray, spmatrix]]) -> Union[spmatrix, np.ndarray]:<DEDENT>", "body": "x_features = []<EOL>for i in range(len(x)):<EOL><INDENT>if ((isinstance(x[i], tuple) or isinstance(x[i], list) or isinstance(x[i], np.ndarray) and len(x[i]))<EOL>or (issparse(x[i]) and x[i].shape[<NUM_LIT:0>])):<EOL><INDENT>if issparse(x[i][<NUM_LIT:0>]):<EOL><INDENT>x_features.append(vstack(list(x[i])))<EOL><DEDENT>elif isinstance(x[i][<NUM_LIT:0>], np.ndarray) or isinstance(x[i][<NUM_LIT:0>], list):<EOL><INDENT>x_features.append(np.vstack(list(x[i])))<EOL><DEDENT>elif isinstance(x[i][<NUM_LIT:0>], str):<EOL><INDENT>x_features.append(np.array(x[i]))<EOL><DEDENT>else:<EOL><INDENT>raise ConfigError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ConfigError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>sparse = False<EOL>for inp in x_features:<EOL><INDENT>if issparse(inp):<EOL><INDENT>sparse = True<EOL><DEDENT><DEDENT>if sparse:<EOL><INDENT>x_features = hstack(list(x_features))<EOL><DEDENT>else:<EOL><INDENT>x_features = np.hstack(list(x_features))<EOL><DEDENT>return x_features<EOL>", "docstring": "Stack given list of different types of inputs to the one matrix. If one of the inputs is a sparse matrix, \\\n    then output will be also a sparse matrix\n\nArgs:\n    x: list of data elements\n\nReturns:\n    sparse or dense array of stacked data", "id": "f3077:c0:m6"}
{"signature": "def __call__(self, *args):", "body": "x_features = self.compose_input_data(args)<EOL>try:<EOL><INDENT>predictions = self.infer_method(x_features)<EOL><DEDENT>except TypeError or ValueError:<EOL><INDENT>if issparse(x_features):<EOL><INDENT>log.info(\"<STR_LIT>\".format(self.model_class))<EOL>predictions = self.infer_method(x_features.todense())<EOL><DEDENT>else:<EOL><INDENT>log.info(\"<STR_LIT>\".format(self.model_class))<EOL>predictions = self.infer_method(csr_matrix(x_features))<EOL><DEDENT><DEDENT>if isinstance(predictions, list):<EOL><INDENT>predictions_ = [[predictions[j][i][<NUM_LIT:1>] for j in range(len(predictions))] for i in range(x_features.shape[<NUM_LIT:0>])]<EOL>predictions = np.array(predictions_)<EOL><DEDENT>if self.ensure_list_output and len(predictions.shape) == <NUM_LIT:1>:<EOL><INDENT>predictions = predictions.reshape(-<NUM_LIT:1>, <NUM_LIT:1>)<EOL><DEDENT>if issparse(predictions):<EOL><INDENT>return predictions<EOL><DEDENT>else:<EOL><INDENT>return predictions.tolist()<EOL><DEDENT>", "docstring": "Infer on the given data according to given in the config infer method, \\\n    e.g. ``\"predict\", \"predict_proba\", \"transform\"``\n\nArgs:\n    *args: list of inputs\n\nReturns:\n    predictions, e.g. list of labels, array of probability distribution, sparse array of vectorized samples", "id": "f3077:c0:m2"}
{"signature": "@overrides<EOL><INDENT>def save(self, epoch: Optional[int] = None) -> None:<DEDENT>", "body": "path = self.save_path<EOL>if epoch is not None:<EOL><INDENT>path = path.parent / self.epoch_save_path / str(epoch) / path.parts[-<NUM_LIT:1>]<EOL>path.resolve()<EOL>log.info(f'<STR_LIT>')<EOL><DEDENT>path.parent.mkdir(parents=True, exist_ok=True)<EOL>path = str(path)<EOL>log.info(f'<STR_LIT>')<EOL>with self.graph.as_default():<EOL><INDENT>saver = tf.train.Saver()<EOL>saver.save(self.sess, path)<EOL><DEDENT>", "docstring": "Save model parameters to self.save_path", "id": "f3082:c0:m10"}
{"signature": "def destroy(self) -> None:", "body": "if hasattr(self, '<STR_LIT>'):<EOL><INDENT>for k in list(self.sess.graph.get_all_collection_keys()):<EOL><INDENT>self.sess.graph.clear_collection(k)<EOL><DEDENT><DEDENT>super().destroy()<EOL>", "docstring": "Delete model from memory\n\nReturns:\n    None", "id": "f3082:c0:m15"}
{"signature": "def _deduplicate_indexed_slices(values, indices):", "body": "unique_indices, new_index_positions = tf.unique(indices)<EOL>summed_values = tf.unsorted_segment_sum(values,<EOL>new_index_positions,<EOL>tf.shape(unique_indices)[<NUM_LIT:0>])<EOL>return (summed_values, unique_indices)<EOL>", "docstring": "Sums `values` associated with any non-unique `indices`.\n    Args:\n      values: A `Tensor` with rank >= 1.\n      indices: A one-dimensional integer `Tensor`, indexing into the first\n      dimension of `values` (as in an IndexedSlices object).\n    Returns:\n      A tuple of (`summed_values`, `unique_indices`) where `unique_indices` is a\n      de-duplicated version of `indices` and `summed_values` contains the sum of\n      `values` slices associated with each unique index.", "id": "f3083:m2"}
{"signature": "def make_module_spec(options, weight_file):", "body": "def module_fn():<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>_bos_id = <NUM_LIT><EOL>_eos_id = <NUM_LIT><EOL>_bow_id = <NUM_LIT><EOL>_eow_id = <NUM_LIT><EOL>_pad_id = <NUM_LIT><EOL>_max_word_length = <NUM_LIT:50><EOL>_parallel_iterations = <NUM_LIT:10><EOL>_max_batch_size = <NUM_LIT><EOL>id_dtype = tf.int32<EOL>id_nptype = np.int32<EOL>max_word_length = tf.constant(_max_word_length, dtype=id_dtype, name='<STR_LIT>')<EOL>version = tf.constant('<STR_LIT>', dtype=tf.string, name='<STR_LIT:version>')<EOL>def _make_bos_eos(c):<EOL><INDENT>r = np.zeros([_max_word_length], dtype=id_nptype)<EOL>r[:] = _pad_id<EOL>r[<NUM_LIT:0>] = _bow_id<EOL>r[<NUM_LIT:1>] = c<EOL>r[<NUM_LIT:2>] = _eow_id<EOL>return tf.constant(r, dtype=id_dtype)<EOL><DEDENT>bos_ids = _make_bos_eos(_bos_id)<EOL>eos_ids = _make_bos_eos(_eos_id)<EOL>def token2ids(token):<EOL><INDENT>with tf.name_scope(\"<STR_LIT>\"):<EOL><INDENT>char_ids = tf.decode_raw(token, tf.uint8, name='<STR_LIT>')<EOL>char_ids = tf.cast(char_ids, tf.int32, name='<STR_LIT>')<EOL>char_ids = tf.strided_slice(char_ids, [<NUM_LIT:0>], [max_word_length - <NUM_LIT:2>],<EOL>[<NUM_LIT:1>], name='<STR_LIT>')<EOL>ids_num = tf.shape(char_ids)[<NUM_LIT:0>]<EOL>fill_ids_num = (_max_word_length - <NUM_LIT:2>) - ids_num<EOL>pads = tf.fill([fill_ids_num], _pad_id)<EOL>bow_token_eow_pads = tf.concat([[_bow_id], char_ids, [_eow_id], pads],<EOL><NUM_LIT:0>, name='<STR_LIT>')<EOL>return bow_token_eow_pads<EOL><DEDENT><DEDENT>def sentence_tagging_and_padding(sen_dim):<EOL><INDENT>with tf.name_scope(\"<STR_LIT>\"):<EOL><INDENT>sen = sen_dim[<NUM_LIT:0>]<EOL>dim = sen_dim[<NUM_LIT:1>]<EOL>extra_dim = tf.shape(sen)[<NUM_LIT:0>] - dim<EOL>sen = tf.slice(sen, [<NUM_LIT:0>, <NUM_LIT:0>], [dim, max_word_length], name='<STR_LIT>')<EOL>bos_sen_eos = tf.concat([[bos_ids], sen, [eos_ids]], <NUM_LIT:0>, name='<STR_LIT>')<EOL>bos_sen_eos_plus_one = bos_sen_eos + <NUM_LIT:1><EOL>bos_sen_eos_pads = tf.pad(bos_sen_eos_plus_one, [[<NUM_LIT:0>, extra_dim], [<NUM_LIT:0>, <NUM_LIT:0>]],<EOL>\"<STR_LIT>\", name='<STR_LIT>')<EOL>return bos_sen_eos_pads<EOL><DEDENT><DEDENT>tokens = tf.placeholder(shape=(None, None), dtype=tf.string, name='<STR_LIT>')<EOL>sequence_len = tf.placeholder(shape=(None, ), dtype=tf.int32, name='<STR_LIT>')<EOL>tok_shape = tf.shape(tokens)<EOL>line_tokens = tf.reshape(tokens, shape=[-<NUM_LIT:1>], name='<STR_LIT>')<EOL>with tf.device('<STR_LIT>'):<EOL><INDENT>tok_ids = tf.map_fn(<EOL>token2ids,<EOL>line_tokens,<EOL>dtype=tf.int32, back_prop=False, parallel_iterations=_parallel_iterations,<EOL>name='<STR_LIT>')<EOL><DEDENT>tok_ids = tf.reshape(tok_ids, [tok_shape[<NUM_LIT:0>], tok_shape[<NUM_LIT:1>], -<NUM_LIT:1>], name='<STR_LIT>')<EOL>with tf.device('<STR_LIT>'):<EOL><INDENT>sen_ids = tf.map_fn(<EOL>sentence_tagging_and_padding,<EOL>(tok_ids, sequence_len),<EOL>dtype=tf.int32, back_prop=False, parallel_iterations=_parallel_iterations,<EOL>name='<STR_LIT>')<EOL><DEDENT>bilm = BidirectionalLanguageModel(options, str(weight_file),<EOL>max_batch_size=_max_batch_size)<EOL>embeddings_op = bilm(sen_ids)<EOL>elmo_output = weight_layers('<STR_LIT>', embeddings_op, l2_coef=<NUM_LIT:0.0>)<EOL>weighted_op = elmo_output['<STR_LIT>']<EOL>mean_op = elmo_output['<STR_LIT>']<EOL>word_emb = elmo_output['<STR_LIT>']<EOL>lstm_outputs1 = elmo_output['<STR_LIT>']<EOL>lstm_outputs2 = elmo_output['<STR_LIT>']<EOL>hub.add_signature(\"<STR_LIT>\", {\"<STR_LIT>\": tokens, \"<STR_LIT>\": sequence_len},<EOL>{\"<STR_LIT>\": weighted_op,<EOL>\"<STR_LIT:default>\": mean_op,<EOL>\"<STR_LIT>\": word_emb,<EOL>\"<STR_LIT>\": lstm_outputs1,<EOL>\"<STR_LIT>\": lstm_outputs2,<EOL>\"<STR_LIT:version>\": version})<EOL>def_strings = tf.placeholder(shape=(None), dtype=tf.string)<EOL>def_tokens_sparse = tf.string_split(def_strings)<EOL>def_tokens_dense = tf.sparse_to_dense(sparse_indices=def_tokens_sparse.indices,<EOL>output_shape=def_tokens_sparse.dense_shape,<EOL>sparse_values=def_tokens_sparse.values,<EOL>default_value='<STR_LIT>'<EOL>)<EOL>def_mask = tf.not_equal(def_tokens_dense, '<STR_LIT>')<EOL>def_int_mask = tf.cast(def_mask, dtype=tf.int32)<EOL>def_sequence_len = tf.reduce_sum(def_int_mask, axis=-<NUM_LIT:1>)<EOL>def_tok_shape = tf.shape(def_tokens_dense)<EOL>def_line_tokens = tf.reshape(def_tokens_dense, shape=[-<NUM_LIT:1>], name='<STR_LIT>')<EOL>with tf.device('<STR_LIT>'):<EOL><INDENT>def_tok_ids = tf.map_fn(<EOL>token2ids,<EOL>def_line_tokens,<EOL>dtype=tf.int32, back_prop=False, parallel_iterations=_parallel_iterations,<EOL>name='<STR_LIT>')<EOL><DEDENT>def_tok_ids = tf.reshape(def_tok_ids, [def_tok_shape[<NUM_LIT:0>], def_tok_shape[<NUM_LIT:1>], -<NUM_LIT:1>], name='<STR_LIT>')<EOL>with tf.device('<STR_LIT>'):<EOL><INDENT>def_sen_ids = tf.map_fn(<EOL>sentence_tagging_and_padding,<EOL>(def_tok_ids, def_sequence_len),<EOL>dtype=tf.int32, back_prop=False, parallel_iterations=_parallel_iterations,<EOL>name='<STR_LIT>')<EOL><DEDENT>def_embeddings_op = bilm(def_sen_ids)<EOL>def_elmo_output = weight_layers('<STR_LIT>', def_embeddings_op, l2_coef=<NUM_LIT:0.0>, reuse=True)<EOL>def_weighted_op = def_elmo_output['<STR_LIT>']<EOL>def_mean_op = def_elmo_output['<STR_LIT>']<EOL>def_word_emb = def_elmo_output['<STR_LIT>']<EOL>def_lstm_outputs1 = def_elmo_output['<STR_LIT>']<EOL>def_lstm_outputs2 = def_elmo_output['<STR_LIT>']<EOL>hub.add_signature(\"<STR_LIT:default>\", {\"<STR_LIT>\": def_strings},<EOL>{\"<STR_LIT>\": def_weighted_op,<EOL>\"<STR_LIT:default>\": def_mean_op,<EOL>\"<STR_LIT>\": def_word_emb,<EOL>\"<STR_LIT>\": def_lstm_outputs1,<EOL>\"<STR_LIT>\": def_lstm_outputs2,<EOL>\"<STR_LIT:version>\": version})<EOL><DEDENT>return hub.create_module_spec(module_fn)<EOL>", "docstring": "Makes a module spec.\n\n    Args:\n      options: LM hyperparameters.\n      weight_file: location of the hdf5 file with LM weights.\n\n    Returns:\n      A module spec object used for constructing a TF-Hub module.", "id": "f3085:m0"}
{"signature": "def __init__(<EOL>self,<EOL>options: dict,<EOL>weight_file: str,<EOL>use_character_inputs=True,<EOL>embedding_weight_file=None,<EOL>max_batch_size=<NUM_LIT>):", "body": "if not use_character_inputs:<EOL><INDENT>if embedding_weight_file is None:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT><DEDENT>self._options = options<EOL>self._weight_file = weight_file<EOL>self._embedding_weight_file = embedding_weight_file<EOL>self._use_character_inputs = use_character_inputs<EOL>self._max_batch_size = max_batch_size<EOL>self._ops = {}<EOL>self._graphs = {}<EOL>", "docstring": "Creates the language model computational graph and loads weights\n\nTwo options for input type:\n    (1) To use character inputs (paired with Batcher)\n        pass use_character_inputs=True, and ids_placeholder\n        of shape (None, None, max_characters_per_token)\n        to __call__\n    (2) To use token ids as input (paired with TokenBatcher),\n        pass use_character_inputs=False and ids_placeholder\n        of shape (None, None) to __call__.\n        In this case, embedding_weight_file is also required input\n\noptions_file: location of the json formatted file with\n              LM hyperparameters\nweight_file: location of the hdf5 file with LM weights\nuse_character_inputs: if True, then use character ids as input,\n    otherwise use token ids\nmax_batch_size: the maximum allowable batch size", "id": "f3086:c0:m0"}
{"signature": "def get_counts(self, docs: List[str], doc_ids: List[Any])-> Generator[Tuple[KeysView, ValuesView, List[int]], Any, None]:", "body": "logger.info(\"<STR_LIT>\")<EOL>batch_ngrams = list(self.tokenizer(docs))<EOL>logger.info(\"<STR_LIT>\")<EOL>doc_id = iter(doc_ids)<EOL>for ngrams in batch_ngrams:<EOL><INDENT>counts = Counter([hash_(gram, self.hash_size) for gram in ngrams])<EOL>hashes = counts.keys()<EOL>values = counts.values()<EOL>_id = self.doc_index[next(doc_id)]<EOL>if values:<EOL><INDENT>col_id = [_id] * len(values)<EOL><DEDENT>else:<EOL><INDENT>col_id = []<EOL><DEDENT>yield hashes, values, col_id<EOL><DEDENT>", "docstring": "Get term counts for a list of documents.\n\n        Args:\n            docs: a list of input documents\n            doc_ids: a list of document ids corresponding to input documents\n\n        Yields:\n            a tuple of term hashes, count values and column ids\n\n        Returns:\n            None", "id": "f3087:c0:m3"}
{"signature": "def load(self) -> None:", "body": "if not isinstance(self.load_path, list):<EOL><INDENT>self.load_path = [self.load_path]<EOL><DEDENT>for i, path in enumerate(self.load_path):<EOL><INDENT>if isinstance(path, str):<EOL><INDENT>self.load_path[i] = pathlib.Path(path)<EOL><DEDENT><DEDENT>labels_by_words = defaultdict(set)<EOL>for infile in self.load_path:<EOL><INDENT>with infile.open(\"<STR_LIT:r>\", encoding=\"<STR_LIT:utf8>\") as fin:<EOL><INDENT>for line in fin:<EOL><INDENT>line = line.strip()<EOL>if line.count(\"<STR_LIT:\\t>\") != <NUM_LIT:1>:<EOL><INDENT>continue<EOL><DEDENT>word, labels = line.split(\"<STR_LIT:\\t>\")<EOL>labels_by_words[word].update(labels.split())<EOL><DEDENT><DEDENT><DEDENT>self._initialize(labels_by_words)<EOL>", "docstring": "Loads the dictionary from self.load_path", "id": "f3088:c1:m3"}
{"signature": "def __call__(self, data: List) -> np.ndarray:", "body": "<EOL>max_length = max(len(x) for x in data)<EOL>answer = np.zeros(shape=(len(data), max_length, self.dim), dtype=int)<EOL>for i, sent in enumerate(data):<EOL><INDENT>for j, word in enumerate(sent):<EOL><INDENT>answer[i, j][self._get_word_indexes(word)] = <NUM_LIT:1><EOL><DEDENT><DEDENT>return answer<EOL>", "docstring": "Transforms words to one-hot encoding according to the dictionary.\n\nArgs:\n    data: the batch of words\n\nReturns:\n    a 3D array. answer[i][j][k] = 1 iff data[i][j] is the k-th word in the dictionary.", "id": "f3088:c0:m3"}
{"signature": "def __call__(self, input_doc_ids: List[List[Any]], input_doc_scores: List[List[float]]) ->Tuple[List[List], List[List]]:", "body": "batch_ids = []<EOL>batch_scores = []<EOL>for instance_ids, instance_scores in zip(input_doc_ids, input_doc_scores):<EOL><INDENT>instance_probas = []<EOL>for idx, score in zip(instance_ids, instance_scores):<EOL><INDENT>pop = self.pop_dict.get(idx, self.mean_pop)<EOL>features = [score, pop, score * pop]<EOL>prob = self.clf.predict_proba([features])<EOL>instance_probas.append(prob[<NUM_LIT:0>][<NUM_LIT:1>])<EOL><DEDENT>sort = sorted(enumerate(instance_probas), key=itemgetter(<NUM_LIT:1>), reverse=True)<EOL>sorted_probas = [item[<NUM_LIT:1>] for item in sort]<EOL>sorted_ids = [instance_ids[item[<NUM_LIT:0>]] for item in sort]<EOL>if self.active:<EOL><INDENT>sorted_ids = sorted_ids[:self.top_n]<EOL>sorted_probas = sorted_probas[:self.top_n]<EOL><DEDENT>batch_ids.append(sorted_ids)<EOL>batch_scores.append(sorted_probas)<EOL><DEDENT>return batch_ids, batch_scores<EOL>", "docstring": "Get tfidf scores and tfidf ids, re-rank them by applying logistic regression classifier,\n        output pop ranker ids and pop ranker scores.\n\n         Args:\n            input_doc_ids: top input doc ids of tfidf ranker\n            input_doc_scores: top input doc scores of tfidf ranker corresponding to doc ids\n\n        Returns:\n            top doc ids of pop ranker and their corresponding scores", "id": "f3093:c0:m1"}
{"signature": "def __getitem__(self, key):", "body": "if isinstance(key, str):<EOL><INDENT>return self.act2templ[key]<EOL><DEDENT>elif isinstance(key, Template):<EOL><INDENT>return self.templ2act[key]<EOL><DEDENT>", "docstring": "If key is an str, returns corresponding template.\n        If key is a Template, return corresponding action.\n        If does not exist, return None.", "id": "f3094:c3:m2"}
{"signature": "def __hash__(self):", "body": "return hash(self.text)<EOL>", "docstring": "Override the default hash behavior (that returns the id)", "id": "f3094:c1:m5"}
{"signature": "@abstractmethod<EOL><INDENT>def get_features(self) -> np.ndarray:<DEDENT>", "body": "pass<EOL>", "docstring": "Returns:\n    np.ndarray[float]: numpy array with calculates state features.", "id": "f3095:c0:m3"}
{"signature": "def cnn_model_max_and_aver_pool(self, kernel_sizes_cnn: List[int], filters_cnn: int, dense_size: int,<EOL>coef_reg_cnn: float = <NUM_LIT:0.>, coef_reg_den: float = <NUM_LIT:0.>, dropout_rate: float = <NUM_LIT:0.>,<EOL>input_projection_size: Optional[int] = None, **kwargs) -> Model:", "body": "inp = Input(shape=(self.opt['<STR_LIT>'], self.opt['<STR_LIT>']))<EOL>output = inp<EOL>if input_projection_size is not None:<EOL><INDENT>output = Dense(input_projection_size, activation='<STR_LIT:relu>')(output)<EOL><DEDENT>outputs = []<EOL>for i in range(len(kernel_sizes_cnn)):<EOL><INDENT>output_i = Conv1D(filters_cnn, kernel_size=kernel_sizes_cnn[i],<EOL>activation=None,<EOL>kernel_regularizer=l2(coef_reg_cnn),<EOL>padding='<STR_LIT>')(output)<EOL>output_i = BatchNormalization()(output_i)<EOL>output_i = Activation('<STR_LIT:relu>')(output_i)<EOL>output_i_0 = GlobalMaxPooling1D()(output_i)<EOL>output_i_1 = GlobalAveragePooling1D()(output_i)<EOL>output_i = Concatenate()([output_i_0, output_i_1])<EOL>outputs.append(output_i)<EOL><DEDENT>output = concatenate(outputs, axis=<NUM_LIT:1>)<EOL>output = Dropout(rate=dropout_rate)(output)<EOL>output = Dense(dense_size, activation=None,<EOL>kernel_regularizer=l2(coef_reg_den))(output)<EOL>output = BatchNormalization()(output)<EOL>output = Activation('<STR_LIT:relu>')(output)<EOL>output = Dropout(rate=dropout_rate)(output)<EOL>output = Dense(self.n_classes, activation=None,<EOL>kernel_regularizer=l2(coef_reg_den))(output)<EOL>output = BatchNormalization()(output)<EOL>act_output = Activation(self.opt.get(\"<STR_LIT>\", \"<STR_LIT>\"))(output)<EOL>model = Model(inputs=inp, outputs=act_output)<EOL>return model<EOL>", "docstring": "Build un-compiled model of shallow-and-wide CNN where average pooling after convolutions is replaced with\nconcatenation of average and max poolings.\n\nArgs:\n    kernel_sizes_cnn: list of kernel sizes of convolutions.\n    filters_cnn: number of filters for convolutions.\n    dense_size: number of units for dense layer.\n    coef_reg_cnn: l2-regularization coefficient for convolutions. Default: ``0.0``.\n    coef_reg_den: l2-regularization coefficient for dense layers. Default: ``0.0``.\n    dropout_rate: dropout rate used after convolutions and between dense layers. Default: ``0.0``.\n    input_projection_size: if not None, adds Dense layer (with ``relu`` activation)\n                           right after input layer to the size ``input_projection_size``.\n                           Useful for input dimentionaliry recuction. Default: ``None``.\n    kwargs: other non-used parameters\n\nReturns:\n    keras.models.Model: uncompiled instance of Keras Model", "id": "f3104:c0:m14"}
{"signature": "def pad_texts(self, sentences: List[List[np.ndarray]]) -> Union[np.ndarray, Tuple[np.ndarray, np.ndarray]]:", "body": "pad = np.zeros(self.opt['<STR_LIT>'])<EOL>cutted_batch = [sen[:self.opt['<STR_LIT>']] for sen in sentences]<EOL>if self.opt[\"<STR_LIT>\"] == \"<STR_LIT>\":<EOL><INDENT>cutted_batch = [[pad] * (self.opt['<STR_LIT>'] - len(tokens)) + list(tokens) for tokens in cutted_batch]<EOL><DEDENT>elif self.opt[\"<STR_LIT>\"] == \"<STR_LIT>\":<EOL><INDENT>cutted_batch = [list(tokens) + [pad] * (self.opt['<STR_LIT>'] - len(tokens)) for tokens in cutted_batch]<EOL><DEDENT>else:<EOL><INDENT>raise ConfigError(\"<STR_LIT>\".format(self.opt['<STR_LIT>']))<EOL><DEDENT>return np.asarray(cutted_batch)<EOL>", "docstring": "Cut and pad tokenized texts to self.opt[\"text_size\"] tokens\n\nArgs:\n    sentences: list of lists of tokens\n\nReturns:\n    array of embedded texts", "id": "f3104:c0:m2"}
{"signature": "def train_on_batch(self, texts: List[List[np.ndarray]], labels: list) -> Union[float, List[float]]:", "body": "features = self.check_input(texts)<EOL>metrics_values = self.model.train_on_batch(features, np.squeeze(np.array(labels)))<EOL>return metrics_values<EOL>", "docstring": "Train the model on the given batch\n\nArgs:\n    texts: list of tokenized embedded text samples\n    labels: list of labels\n\nReturns:\n    metrics values on the given batch", "id": "f3104:c0:m4"}
{"signature": "def check_input(self, texts: List[List[np.ndarray]]) -> np.ndarray:", "body": "if self.opt[\"<STR_LIT>\"] is not None:<EOL><INDENT>features = self.pad_texts(texts)<EOL><DEDENT>else:<EOL><INDENT>if len(texts[<NUM_LIT:0>]):<EOL><INDENT>features = np.array(texts)<EOL><DEDENT>else:<EOL><INDENT>features = np.zeros((<NUM_LIT:1>, <NUM_LIT:1>, self.opt[\"<STR_LIT>\"]))<EOL><DEDENT><DEDENT>return features<EOL>", "docstring": "Check and convert input to array of tokenized embedded samples\n\nArgs:\n    texts: list of tokenized embedded text samples\n\nReturns:\n    array of tokenized embedded texts samples that are cut and padded", "id": "f3104:c0:m3"}
{"signature": "def __call__(self, data: Union[np.ndarray, List[List[float]], List[List[int]]],<EOL>*args, **kwargs) -> Union[List[List[str]], List[str]]:", "body": "if self.confident_threshold:<EOL><INDENT>return [list(np.where(np.array(d) > self.confident_threshold)[<NUM_LIT:0>])<EOL>for d in data]<EOL><DEDENT>elif self.max_proba:<EOL><INDENT>return [[np.argmax(d)] for d in data]<EOL><DEDENT>elif self.top_n:<EOL><INDENT>return [np.argsort(d)[::-<NUM_LIT:1>][:self.top_n] for d in data]<EOL><DEDENT>else:<EOL><INDENT>raise ConfigError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Process probabilities to labels\n\nArgs:\n    data: list of vectors with probability distribution\n    *args:\n    **kwargs:\n\nReturns:\n    list of labels (only label classification) or list of lists of labels (multi-label classification)", "id": "f3105:c0:m1"}
{"signature": "def train_on_batch(self, c_tokens: np.ndarray, c_chars: np.ndarray, q_tokens: np.ndarray, q_chars: np.ndarray,<EOL>y1s: Tuple[List[int], ...], y2s: Tuple[List[int], ...]) -> float:", "body": "<EOL>y1s = np.array([x[<NUM_LIT:0>] for x in y1s])<EOL>y2s = np.array([x[<NUM_LIT:0>] for x in y2s])<EOL>if self.noans_token:<EOL><INDENT>noans_mask = ((y1s != -<NUM_LIT:1>) * (y2s != -<NUM_LIT:1>))<EOL>y1s = (y1s + <NUM_LIT:1>) * noans_mask<EOL>y2s = (y2s + <NUM_LIT:1>) * noans_mask<EOL><DEDENT>feed_dict = self._build_feed_dict(c_tokens, c_chars, q_tokens, q_chars, y1s, y2s)<EOL>loss, _, lear_rate = self.sess.run([self.loss, self.train_op, self.lear_rate_ph],<EOL>feed_dict=feed_dict)<EOL>report = {'<STR_LIT>': loss, '<STR_LIT>': float(lear_rate), '<STR_LIT>': self.get_momentum()}<EOL>return report<EOL>", "docstring": "This method is called by trainer to make one training step on one batch.\n\nArgs:\n    c_tokens: batch of tokenized contexts\n    c_chars: batch of tokenized contexts, each token split on chars\n    q_tokens: batch of tokenized questions\n    q_chars: batch of tokenized questions, each token split on chars\n    y1s: batch of ground truth answer start positions\n    y2s: batch of ground truth answer end positions\n\nReturns:\n    value of loss function on batch", "id": "f3108:c0:m5"}
{"signature": "def attention(inputs, state, att_size, mask, scope=\"<STR_LIT>\"):", "body": "with tf.variable_scope(scope):<EOL><INDENT>u = tf.concat([tf.tile(tf.expand_dims(state, axis=<NUM_LIT:1>), [<NUM_LIT:1>, tf.shape(inputs)[<NUM_LIT:1>], <NUM_LIT:1>]), inputs], axis=<NUM_LIT:2>)<EOL>logits = tf.layers.dense(tf.layers.dense(u, att_size, activation=tf.nn.tanh), <NUM_LIT:1>, use_bias=False)<EOL>logits = softmax_mask(tf.squeeze(logits, [<NUM_LIT:2>]), mask)<EOL>att_weights = tf.expand_dims(tf.nn.softmax(logits), axis=<NUM_LIT:2>)<EOL>res = tf.reduce_sum(att_weights * inputs, axis=<NUM_LIT:1>)<EOL>return res, logits<EOL><DEDENT>", "docstring": "Computes weighted sum of inputs conditioned on state", "id": "f3109:m2"}
{"signature": "def dot_attention(inputs, memory, mask, att_size, keep_prob=<NUM_LIT:1.0>, scope=\"<STR_LIT>\"):", "body": "with tf.variable_scope(scope):<EOL><INDENT>BS, IL, IH = tf.unstack(tf.shape(inputs))<EOL>BS, ML, MH = tf.unstack(tf.shape(memory))<EOL>d_inputs = tf.nn.dropout(inputs, keep_prob=keep_prob, noise_shape=[BS, <NUM_LIT:1>, IH])<EOL>d_memory = tf.nn.dropout(memory, keep_prob=keep_prob, noise_shape=[BS, <NUM_LIT:1>, MH])<EOL>with tf.variable_scope(\"<STR_LIT>\"):<EOL><INDENT>inputs_att = tf.layers.dense(d_inputs, att_size, use_bias=False, activation=tf.nn.relu)<EOL>memory_att = tf.layers.dense(d_memory, att_size, use_bias=False, activation=tf.nn.relu)<EOL>logits = tf.matmul(inputs_att, tf.transpose(memory_att, [<NUM_LIT:0>, <NUM_LIT:2>, <NUM_LIT:1>])) / (att_size ** <NUM_LIT:0.5>)<EOL>mask = tf.tile(tf.expand_dims(mask, axis=<NUM_LIT:1>), [<NUM_LIT:1>, IL, <NUM_LIT:1>])<EOL>att_weights = tf.nn.softmax(softmax_mask(logits, mask))<EOL>outputs = tf.matmul(att_weights, memory)<EOL>res = tf.concat([inputs, outputs], axis=<NUM_LIT:2>)<EOL><DEDENT>with tf.variable_scope(\"<STR_LIT>\"):<EOL><INDENT>dim = res.get_shape().as_list()[-<NUM_LIT:1>]<EOL>d_res = tf.nn.dropout(res, keep_prob=keep_prob, noise_shape=[BS, <NUM_LIT:1>, IH + MH])<EOL>gate = tf.layers.dense(d_res, dim, use_bias=False, activation=tf.nn.sigmoid)<EOL>return res * gate<EOL><DEDENT><DEDENT>", "docstring": "Computes attention vector for each item in inputs:\n       attention vector is a weighted sum of memory items.\n       Dot product between input and memory vector is used as similarity measure.\n\n       Gate mechanism is applied to attention vectors to produce output.\n\n    Args:\n        inputs: Tensor [batch_size x input_len x feature_size]\n        memory: Tensor [batch_size x memory_len x feature_size]\n        mask: inputs mask\n        att_size: hidden size of attention\n        keep_prob: dropout keep_prob\n        scope:\n\n    Returns:\n        attention vectors [batch_size x input_len x (feature_size + feature_size)]", "id": "f3109:m0"}
{"signature": "@overrides<EOL><INDENT>def __call__(self, batch: List[List[str]],<EOL>*args, **kwargs) -> Union[List[np.ndarray], np.ndarray]:<DEDENT>", "body": "if len(batch) > self.mini_batch_size:<EOL><INDENT>batch_gen = chunk_generator(batch, self.mini_batch_size)<EOL>elmo_output_values = []<EOL>for mini_batch in batch_gen:<EOL><INDENT>mini_batch_out = self._mini_batch_fit(mini_batch, *args, **kwargs)<EOL>elmo_output_values.extend(mini_batch_out)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>elmo_output_values = self._mini_batch_fit(batch, *args, **kwargs)<EOL><DEDENT>if self.pad_zero:<EOL><INDENT>elmo_output_values = zero_pad(elmo_output_values)<EOL><DEDENT>return elmo_output_values<EOL>", "docstring": "Embed sentences from a batch.\n\nArgs:\n    batch: A list of tokenized text samples.\n\nReturns:\n    A batch of ELMo embeddings.", "id": "f3113:c0:m5"}
{"signature": "def _tags_encode(self, tokens: List[str], tags: List[str], mean: bool) -> Union[List[np.ndarray], np.ndarray]:", "body": "embedded_tokens = np.array(self.embedder([tokens]))[<NUM_LIT:0>, :, :]<EOL>tags_weights = np.array([self.tags_vocab.get(tag, <NUM_LIT:1.0>) for tag in tags])<EOL>detokenized_sample = self.tokenizer([tokens])[<NUM_LIT:0>]  <EOL>vectorized_sample = self.vectorizer([detokenized_sample])  <EOL>if self.vectorizer:<EOL><INDENT>weights = np.array([vectorized_sample[<NUM_LIT:0>, np.where(self.vocabulary == token)[<NUM_LIT:0>][<NUM_LIT:0>]]<EOL>if len(np.where(self.vocabulary == token)[<NUM_LIT:0>]) else <NUM_LIT:0.><EOL>for token in tokens])<EOL><DEDENT>else:<EOL><INDENT>weights = np.array([self.get_weight(max(self.counter_vocab.get(token, <NUM_LIT:0>), self.idf_base_count))<EOL>for token in tokens])<EOL><DEDENT>weights = np.multiply(weights, tags_weights)<EOL>if sum(weights) == <NUM_LIT:0>:<EOL><INDENT>weights = np.ones(len(tokens))<EOL><DEDENT>if mean is None:<EOL><INDENT>mean = self.mean<EOL><DEDENT>if mean:<EOL><INDENT>embedded_tokens = np.average(embedded_tokens, weights=weights, axis=<NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>embedded_tokens = np.array([weights[i] * embedded_tokens[i] for i in range(len(tokens))])<EOL><DEDENT>return embedded_tokens<EOL>", "docstring": "Embed one text sample\n\nArgs:\n    tokens: tokenized text sample\n    tags: tokenized tags sample\n    mean: whether to return mean token embedding (does not depend on self.mean)\n\nReturns:\n    list of embedded tokens or array of mean values", "id": "f3114:c0:m7"}
{"signature": "@overrides<EOL><INDENT>def __call__(self, batch: List[List[str]], tags_batch: Optional[List[List[str]]] = None, mean: bool = None,<EOL>*args, **kwargs) -> List[Union[list, np.ndarray]]:<DEDENT>", "body": "if self.tags_vocab:<EOL><INDENT>if tags_batch is None:<EOL><INDENT>raise ConfigError(\"<STR_LIT>\")<EOL><DEDENT>batch = [self._tags_encode(sample, tags_sample, mean=mean) for sample, tags_sample in zip(batch, tags_batch)]<EOL><DEDENT>else:<EOL><INDENT>if tags_batch:<EOL><INDENT>raise ConfigError(\"<STR_LIT>\")<EOL><DEDENT>batch = [self._encode(sample, mean=mean) for sample in batch]<EOL><DEDENT>if self.pad_zero:<EOL><INDENT>batch = zero_pad(batch)<EOL><DEDENT>return batch<EOL>", "docstring": "Infer on the given data\n\nArgs:\n    batch: tokenized text samples\n    tags_batch: optional batch of corresponding tags\n    mean: whether to return mean token embedding (does not depend on self.mean)\n    *args: additional arguments\n    **kwargs: additional arguments\n\nReturns:", "id": "f3114:c0:m4"}
{"signature": "@staticmethod<EOL><INDENT>def space_detokenizer(batch: List[List[str]]) -> List[str]:<DEDENT>", "body": "return [\"<STR_LIT:U+0020>\".join(tokens) for tokens in batch]<EOL>", "docstring": "Detokenizer by default. Linking tokens by space symbol\n\nArgs:\n    batch: batch of tokenized texts\n\nReturns:\n    batch of detokenized texts", "id": "f3114:c0:m3"}
{"signature": "def _encode(self, tokens: List[str], mean: bool) -> Union[List[np.ndarray], np.ndarray]:", "body": "if self.vectorizer:<EOL><INDENT>detokenized_sample = self.tokenizer([tokens])[<NUM_LIT:0>]  <EOL>vectorized_sample = self.vectorizer([detokenized_sample])  <EOL>weights = np.array([vectorized_sample[<NUM_LIT:0>, np.where(self.vocabulary == token)[<NUM_LIT:0>][<NUM_LIT:0>]]<EOL>if len(np.where(self.vocabulary == token)[<NUM_LIT:0>]) else <NUM_LIT:0.><EOL>for token in tokens])<EOL><DEDENT>else:<EOL><INDENT>weights = np.array([self.get_weight(max(self.counter_vocab.get(token, <NUM_LIT:0>), self.idf_base_count))<EOL>for token in tokens])<EOL><DEDENT>if sum(weights) == <NUM_LIT:0>:<EOL><INDENT>weights = np.ones(len(tokens))<EOL><DEDENT>embedded_tokens = np.array(self.embedder([tokens]))[<NUM_LIT:0>, :, :]<EOL>if mean is None:<EOL><INDENT>mean = self.mean<EOL><DEDENT>if mean:<EOL><INDENT>embedded_tokens = np.average(embedded_tokens, weights=weights, axis=<NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>embedded_tokens = np.array([weights[i] * embedded_tokens[i] for i in range(len(tokens))])<EOL><DEDENT>return embedded_tokens<EOL>", "docstring": "Embed one text sample\n\nArgs:\n    tokens: tokenized text sample\n    mean: whether to return mean token embedding (does not depend on self.mean)\n\nReturns:\n    list of embedded tokens or array of mean values", "id": "f3114:c0:m5"}
{"signature": "def load(self) -> None:", "body": "log.info(f\"<STR_LIT>\")<EOL>if not self.load_path.exists():<EOL><INDENT>log.warning(f'<STR_LIT>')<EOL>return<EOL><DEDENT>self.model = KeyedVectors.load_word2vec_format(str(self.load_path))<EOL>self.dim = self.model.vector_size<EOL>", "docstring": "Load dict of embeddings from given file", "id": "f3115:c0:m1"}
{"signature": "def __call__(self, batch: List[str]) -> List[List[str]]:", "body": "if isinstance(batch, (list, tuple)):<EOL><INDENT>return [sample.split() for sample in batch]<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>", "docstring": "Tokenize given batch\n\nArgs:\n    batch: list of texts to tokenize\n\nReturns:\n    tokenized batch", "id": "f3121:c0:m1"}
{"signature": "def __call__(self, batch: List[Union[str, List[str]]]) -> List[Union[List[str], str]]:", "body": "if isinstance(batch[<NUM_LIT:0>], str):<EOL><INDENT>return [self.tokenizer.tokenize(line, escape=self.escape) for line in batch]<EOL><DEDENT>else:<EOL><INDENT>return [self.detokenizer.detokenize(line, return_str=True, unescape=self.escape)<EOL>for line in batch]<EOL><DEDENT>", "docstring": "Tokenize given batch of strings or detokenize given batch of lists of tokens\n\n        Args:\n            batch: list of text samples or list of lists of tokens\n\n        Returns:\n            list of lists of tokens or list of text samples", "id": "f3124:c0:m1"}
{"signature": "def detokenize(tokens):", "body": "text = '<STR_LIT:U+0020>'.join(tokens)<EOL>step0 = text.replace('<STR_LIT>', '<STR_LIT>')<EOL>step1 = step0.replace(\"<STR_LIT>\", '<STR_LIT:\">').replace(\"<STR_LIT>\", '<STR_LIT:\">')<EOL>step2 = step1.replace(\"<STR_LIT>\", \"<STR_LIT>\").replace(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>step3 = re.sub(r'<STR_LIT>', r\"<STR_LIT>\", step2)<EOL>step4 = re.sub(r'<STR_LIT>', r\"<STR_LIT>\", step3)<EOL>step5 = step4.replace(\"<STR_LIT>\", \"<STR_LIT:'>\").replace(\"<STR_LIT>\", \"<STR_LIT>\").replace(\"<STR_LIT>\", \"<STR_LIT>\").replace(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>step6 = step5.replace(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>return step6.strip()<EOL>", "docstring": "Detokenizing a text undoes the tokenizing operation, restores\npunctuation and spaces to the places that people expect them to be.\nIdeally, `detokenize(tokenize(text))` should be identical to `text`,\nexcept for line breaks.", "id": "f3126:m0"}
{"signature": "def main():", "body": "args = parser.parse_args()<EOL>run_ms_bot_framework_server(agent_generator=make_agent,<EOL>app_id=args.ms_id,<EOL>app_secret=args.ms_secret,<EOL>stateful=True)<EOL>", "docstring": "Parse parameters and run ms bot framework", "id": "f3132:m4"}
{"signature": "def show_details(item_data: Dict[Any, Any]) -> str:", "body": "txt = \"<STR_LIT>\"<EOL>for key, value in item_data.items():<EOL><INDENT>txt += \"<STR_LIT>\" + str(key) + \"<STR_LIT>\" + '<STR_LIT>' + str(value) + \"<STR_LIT>\"<EOL><DEDENT>return txt<EOL>", "docstring": "Format catalog item output\n\n    Parameters:\n        item_data: item's attributes values\n\n    Returns:\n        [rich_message]: list of formatted rich message", "id": "f3132:m2"}
{"signature": "def json(self) -> dict:", "body": "self.control_json['<STR_LIT:content>'] = self.content<EOL>return self.control_json<EOL>", "docstring": "Returns json compatible state of the PlainText instance.\n\n        Returns:\n            control_json: Json representation of PlainText state.", "id": "f3136:c0:m2"}
{"signature": "def get_chainer(self) -> Chainer:", "body": "self._load()<EOL>return self._chainer<EOL>", "docstring": "Return a :class:`~deeppavlov.core.common.chainer.Chainer` built from ``self.chainer_config`` for inference", "id": "f3141:c0:m3"}
{"signature": "def add_control(self, control: RichControl):", "body": "self.controls.append(control)<EOL>", "docstring": "Adds RichControl instance to RichMessage.\n\n        Args:\n            control: RichControl instance.", "id": "f3143:c2:m2"}
{"signature": "def telegram(self):", "body": "return None<EOL>", "docstring": "Returns Telegram compatible state of the control instance\n        including its nested controls.\n\n        Returns:\n            control: Telegram representation of control state.", "id": "f3143:c0:m2"}
{"signature": "def alexa(self) -> list:", "body": "alexa_controls = [control.alexa() for control in self.controls]<EOL>return alexa_controls<EOL>", "docstring": "Returns list of Amazon Alexa compatible states of the RichMessage\n        instance nested controls.\n\n        Returns:\n            alexa_controls: Amazon Alexa representation of RichMessage instance nested\n                controls.", "id": "f3143:c2:m6"}
{"signature": "@abstractmethod<EOL><INDENT>def json(self) -> Union[list, dict]:<DEDENT>", "body": "pass<EOL>", "docstring": "Returns json compatible state of the control instance including\n        its nested controls.\n\n        Returns:\n            control: Json representation of control state.", "id": "f3143:c0:m0"}
{"signature": "def json(self) -> list:", "body": "json_controls = [control.json() for control in self.controls]<EOL>return json_controls<EOL>", "docstring": "Returns list of json compatible states of the RichMessage instance\n        nested controls.\n\n        Returns:\n            json_controls: Json representation of RichMessage instance\n                nested controls.", "id": "f3143:c2:m3"}
{"signature": "def _log(self, utterance: Any, direction: str, dialog_id: Optional[Hashable]=None):", "body": "if isinstance(utterance, str):<EOL><INDENT>pass<EOL><DEDENT>elif isinstance(utterance, RichMessage):<EOL><INDENT>utterance = utterance.json()<EOL><DEDENT>elif isinstance(utterance, (list, dict)):<EOL><INDENT>utterance = jsonify_data(utterance)<EOL><DEDENT>else:<EOL><INDENT>utterance = str(utterance)<EOL><DEDENT>dialog_id = str(dialog_id) if not isinstance(dialog_id, str) else dialog_id<EOL>if self.log_file.tell() >= self.log_max_size * <NUM_LIT>:<EOL><INDENT>self.log_file.close()<EOL>self.log_file = self._get_log_file()<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>log_msg = {}<EOL>log_msg['<STR_LIT>'] = self._get_timestamp_utc_str()<EOL>log_msg['<STR_LIT>'] = dialog_id<EOL>log_msg['<STR_LIT>'] = direction<EOL>log_msg['<STR_LIT:message>'] = utterance<EOL>log_str = json.dumps(log_msg, ensure_ascii=self.config['<STR_LIT>'])<EOL>self.log_file.write(f'<STR_LIT>')<EOL><DEDENT>except IOError:<EOL><INDENT>log.error('<STR_LIT>')<EOL><DEDENT><DEDENT>", "docstring": "Logs single dialog utterance to current dialog log file.\n\n        Args:\n            utterance: Dialog utterance.\n            direction: 'in' or 'out' utterance direction.\n            dialog_id: Dialog ID.", "id": "f3144:c0:m3"}
{"signature": "def log_in(self, utterance: Any, dialog_id: Optional[Hashable] = None) -> None:", "body": "if self.enabled:<EOL><INDENT>self._log(utterance, '<STR_LIT>', dialog_id)<EOL><DEDENT>", "docstring": "Wraps _log method for all input utterances.\n        Args:\n            utterance: Dialog utterance.\n            dialog_id: Dialog ID.", "id": "f3144:c0:m4"}
{"signature": "@abstractmethod<EOL><INDENT>def _call(self, utterances_batch: list, utterances_ids: Optional[list] = None) -> list:<DEDENT>", "body": "pass<EOL>", "docstring": "Processes batch of utterances and returns corresponding responses batch.\n\n        Each call of Agent processes incoming utterances and returns response\n        for each utterance Batch of dialog IDs can be provided, in other case\n        utterances indexes in incoming batch are used as dialog IDs.\n\n        Args:\n            utterances_batch: Batch of incoming utterances.\n            utterances_ids: Batch of dialog IDs corresponding to incoming utterances.\n\n        Returns:\n            responses: A batch of responses corresponding to the\n                utterance batch received by agent.", "id": "f3145:c0:m2"}
{"signature": "@staticmethod<EOL><INDENT>def print_number_of_parameters():<DEDENT>", "body": "log.info('<STR_LIT>')<EOL>variables = tf.trainable_variables()<EOL>blocks = defaultdict(int)<EOL>for var in variables:<EOL><INDENT>block_name = var.name.split('<STR_LIT:/>')[<NUM_LIT:0>]<EOL>number_of_parameters = np.prod(var.get_shape().as_list())<EOL>blocks[block_name] += number_of_parameters<EOL><DEDENT>for block_name, cnt in blocks.items():<EOL><INDENT>log.info(\"<STR_LIT>\".format(block_name, cnt))<EOL><DEDENT>total_num_parameters = np.sum(list(blocks.values()))<EOL>log.info('<STR_LIT>'.format(total_num_parameters))<EOL>", "docstring": "Print number of *trainable* parameters in the network", "id": "f3150:c0:m8"}
{"signature": "def get_train_op(self,<EOL>loss,<EOL>learning_rate,<EOL>optimizer=None,<EOL>clip_norm=None,<EOL>learnable_scopes=None,<EOL>optimizer_scope_name=None,<EOL>**kwargs):", "body": "if optimizer_scope_name is None:<EOL><INDENT>opt_scope = tf.variable_scope('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>opt_scope = tf.variable_scope(optimizer_scope_name)<EOL><DEDENT>with opt_scope:<EOL><INDENT>if learnable_scopes is None:<EOL><INDENT>variables_to_train = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES)<EOL><DEDENT>else:<EOL><INDENT>variables_to_train = []<EOL>for scope_name in learnable_scopes:<EOL><INDENT>variables_to_train.extend(tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope=scope_name))<EOL><DEDENT><DEDENT>if optimizer is None:<EOL><INDENT>optimizer = tf.train.AdamOptimizer<EOL><DEDENT>extra_update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)<EOL>with tf.control_dependencies(extra_update_ops):<EOL><INDENT>def clip_if_not_none(grad):<EOL><INDENT>if grad is not None:<EOL><INDENT>return tf.clip_by_norm(grad, clip_norm)<EOL><DEDENT><DEDENT>opt = optimizer(learning_rate, **kwargs)<EOL>grads_and_vars = opt.compute_gradients(loss, var_list=variables_to_train)<EOL>if clip_norm is not None:<EOL><INDENT>grads_and_vars = [(clip_if_not_none(grad), var)<EOL>for grad, var in grads_and_vars]<EOL><DEDENT>train_op = opt.apply_gradients(grads_and_vars)<EOL><DEDENT><DEDENT>return train_op<EOL>", "docstring": "Get train operation for given loss\n\nArgs:\n    loss: loss, tf tensor or scalar\n    learning_rate: scalar or placeholder.\n    clip_norm: clip gradients norm by clip_norm.\n    learnable_scopes: which scopes are trainable (None for all).\n    optimizer: instance of tf.train.Optimizer, default Adam.\n    **kwargs: parameters passed to tf.train.Optimizer object\n       (scalars or placeholders).\n\nReturns:\n    train_op", "id": "f3150:c0:m7"}
{"signature": "def load(self) -> None:", "body": "<EOL>if self.load_path.exists():<EOL><INDENT>path = str(self.load_path.resolve())<EOL>log.info('<STR_LIT>'.format(path))<EOL>self._net.load(path)<EOL><DEDENT>", "docstring": "Checks existence of the model file, loads the model if the file exists", "id": "f3152:c1:m1"}
{"signature": "@abstractmethod<EOL><INDENT>def get_optimizer(self):<DEDENT>", "body": "pass<EOL>", "docstring": "Return instance of keras optimizer\n\nArgs:\n    None", "id": "f3152:c2:m1"}
{"signature": "def __call__(self, *x_batch, **kwargs) -> Union[List, np.ndarray]:", "body": "with self.graph.as_default():<EOL><INDENT>K.set_session(self.sess)<EOL>return self._net.predict_on_batch(x_batch, **kwargs)<EOL><DEDENT>", "docstring": "Predicts answers on batch elements.\n\nArgs:\n    instance: a batch to predict answers on", "id": "f3152:c1:m4"}
{"signature": "def process_event(self, event_name: str, data: dict):", "body": "if (isinstance(self.opt.get(\"<STR_LIT>\", None), float) and<EOL>isinstance(self.opt.get(\"<STR_LIT>\", None), float)):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>if event_name == '<STR_LIT>':<EOL><INDENT>if (self.get_learning_rate_variable() is not None) and ('<STR_LIT>' not in data):<EOL><INDENT>data['<STR_LIT>'] = float(K.get_value(self.get_learning_rate_variable()))<EOL><DEDENT>if (self.get_momentum_variable() is not None) and ('<STR_LIT>' not in data):<EOL><INDENT>data['<STR_LIT>'] = float(K.get_value(self.get_momentum_variable()))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>super().process_event(event_name, data)<EOL><DEDENT><DEDENT>", "docstring": "Process event after epoch\nArgs:\n    event_name: whether event is send after epoch or batch.\n            Set of values: ``\"after_epoch\", \"after_batch\"``\n    data: event data (dictionary)\n\nReturns:\n    None", "id": "f3152:c2:m7"}
{"signature": "def save(self) -> None:", "body": "path = str(self.save_path.absolute())<EOL>log.info('<STR_LIT>'.format(path))<EOL>self._net.save(path)<EOL>", "docstring": "Saves model to the save_path, provided in config. The directory is\n        already created by super().__init__, which is called in __init__ of this class", "id": "f3152:c1:m2"}
{"signature": "def get_learning_rate_variable(self):", "body": "return self._lr_var<EOL>", "docstring": "Return current learning rate variable\n\nReturns:\n    learning rate variable", "id": "f3155:c2:m5"}
{"signature": "def __init__(self,<EOL>learning_rate: Union[None, float, Tuple[float, float]] = None,<EOL>learning_rate_decay: Union[DType, Tuple[DType, float]] = DecayType.NO,<EOL>learning_rate_decay_epochs: int = <NUM_LIT:0>,<EOL>learning_rate_decay_batches: int = <NUM_LIT:0>,<EOL>learning_rate_drop_div: float = <NUM_LIT>,<EOL>learning_rate_drop_patience: Optional[int] = None,<EOL>momentum: Union[None, float, Tuple[float, float]] = None,<EOL>momentum_decay: Union[DType, Tuple[DType, float]] = DecayType.NO,<EOL>momentum_decay_epochs: int = <NUM_LIT:0>,<EOL>momentum_decay_batches: int = <NUM_LIT:0>,<EOL>fit_batch_size: Union[None, int, str] = None,<EOL>fit_learning_rate: Tuple[float, float] = (<NUM_LIT>, <NUM_LIT:100>),<EOL>fit_learning_rate_div: float = <NUM_LIT>,<EOL>fit_beta: float = <NUM_LIT>,<EOL>fit_min_batches: int = <NUM_LIT:10>,<EOL>fit_max_batches: Optional[int] = None,<EOL>*args, **kwargs) -> None:", "body": "if learning_rate_decay_epochs and learning_rate_decay_batches:<EOL><INDENT>raise ConfigError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>if momentum_decay_epochs and momentum_decay_batches:<EOL><INDENT>raise ConfigError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>start_val, end_val = learning_rate, None<EOL>if isinstance(learning_rate, (tuple, list)):<EOL><INDENT>start_val, end_val = learning_rate<EOL><DEDENT>dec_type, extra = learning_rate_decay, None<EOL>if isinstance(learning_rate_decay, (tuple, list)):<EOL><INDENT>dec_type, extra = learning_rate_decay<EOL><DEDENT>self._lr = start_val<EOL>num_it, self._lr_update_on_batch = learning_rate_decay_epochs, False<EOL>if learning_rate_decay_batches > <NUM_LIT:0>:<EOL><INDENT>num_it, self._lr_update_on_batch = learning_rate_decay_batches, True<EOL><DEDENT>self._lr_schedule = DecayScheduler(start_val=start_val, end_val=end_val,<EOL>num_it=num_it, dec_type=dec_type, extra=extra)<EOL>self._lr_var = self._init_learning_rate_variable()<EOL>start_val, end_val = momentum, None<EOL>if isinstance(momentum, (tuple, list)):<EOL><INDENT>start_val, end_val = momentum<EOL><DEDENT>dec_type, extra = momentum_decay, None<EOL>if isinstance(momentum_decay, (tuple, list)):<EOL><INDENT>dec_type, extra = momentum_decay<EOL><DEDENT>self._mom = start_val<EOL>num_it, self._mom_update_on_batch = momentum_decay_epochs, False<EOL>self._mom_update_on_batch = momentum_decay_batches > <NUM_LIT:0><EOL>num_it = momentum_decay_epochs if self._mom_update_on_batch else momentum_decay_batches<EOL>self._mom_schedule = DecayScheduler(start_val=start_val, end_val=end_val,<EOL>num_it=num_it, dec_type=dec_type,<EOL>extra=extra)<EOL>self._mom_var = self._init_momentum_variable()<EOL>self._learning_rate_drop_patience = learning_rate_drop_patience<EOL>self._learning_rate_drop_div = learning_rate_drop_div<EOL>self._learning_rate_cur_impatience = <NUM_LIT:0.><EOL>self._learning_rate_last_impatience = <NUM_LIT:0.><EOL>self._learning_rate_cur_div = <NUM_LIT:1.><EOL>self._fit_batch_size = fit_batch_size<EOL>self._fit_learning_rate = fit_learning_rate<EOL>self._fit_learning_rate_div = fit_learning_rate_div<EOL>self._fit_beta = fit_beta<EOL>self._fit_min_batches = fit_min_batches<EOL>self._fit_max_batches = fit_max_batches<EOL>", "docstring": "Initialize learning rate scheduler", "id": "f3155:c2:m3"}
{"signature": "def get_momentum_variable(self):", "body": "return self._mom_var<EOL>", "docstring": "Return current momentum variable\n\nReturns:\n    momentum variable", "id": "f3155:c2:m7"}
{"signature": "@staticmethod<EOL><INDENT>def _get_best(values: List[float], losses: List[float],<EOL>max_loss_div: float = <NUM_LIT>, min_val_div: float = <NUM_LIT>) -> float:<DEDENT>", "body": "assert len(values) == len(losses), \"<STR_LIT>\"<EOL>min_ind = np.argmin(losses)<EOL>for i in range(min_ind - <NUM_LIT:1>, <NUM_LIT:0>, -<NUM_LIT:1>):<EOL><INDENT>if (losses[i] * max_loss_div > losses[min_ind]) or(values[i] * min_val_div < values[min_ind]):<EOL><INDENT>return values[i + <NUM_LIT:1>]<EOL><DEDENT><DEDENT>return values[min_ind] / min_val_div<EOL>", "docstring": "Find the best value according to given losses\n\nArgs:\n    values: list of considered values\n    losses: list of obtained loss values corresponding to `values`\n    max_loss_div: maximal divergence of loss to be considered significant\n    min_val_div: minimum divergence of loss to be considered significant\n\nReturns:\n    best value divided by `min_val_div`", "id": "f3155:c2:m9"}
{"signature": "def stacked_cnn(units: tf.Tensor,<EOL>n_hidden_list: List,<EOL>filter_width=<NUM_LIT:3>,<EOL>use_batch_norm=False,<EOL>use_dilation=False,<EOL>training_ph=None,<EOL>add_l2_losses=False):", "body": "l2_reg = tf.nn.l2_loss if add_l2_losses else None<EOL>for n_layer, n_hidden in enumerate(n_hidden_list):<EOL><INDENT>if use_dilation:<EOL><INDENT>dilation_rate = <NUM_LIT:2> ** n_layer<EOL><DEDENT>else:<EOL><INDENT>dilation_rate = <NUM_LIT:1><EOL><DEDENT>units = tf.layers.conv1d(units,<EOL>n_hidden,<EOL>filter_width,<EOL>padding='<STR_LIT>',<EOL>dilation_rate=dilation_rate,<EOL>kernel_initializer=INITIALIZER(),<EOL>kernel_regularizer=l2_reg)<EOL>if use_batch_norm:<EOL><INDENT>assert training_ph is not None<EOL>units = tf.layers.batch_normalization(units, training=training_ph)<EOL><DEDENT>units = tf.nn.relu(units)<EOL><DEDENT>return units<EOL>", "docstring": "Number of convolutional layers stacked on top of each other\n\n    Args:\n        units: a tensorflow tensor with dimensionality [None, n_tokens, n_features]\n        n_hidden_list: list with number of hidden units at the ouput of each layer\n        filter_width: width of the kernel in tokens\n        use_batch_norm: whether to use batch normalization between layers\n        use_dilation: use power of 2 dilation scheme [1, 2, 4, 8 .. ] for layers 1, 2, 3, 4 ...\n        training_ph: boolean placeholder determining whether is training phase now or not.\n            It is used only for batch normalization to determine whether to use\n            current batch average (std) or memory stored average (std)\n        add_l2_losses: whether to add l2 losses on network kernels to\n                tf.GraphKeys.REGULARIZATION_LOSSES or not\n\n    Returns:\n        units: tensor at the output of the last convolutional layer", "id": "f3157:m0"}
{"signature": "def stacked_bi_rnn(units: tf.Tensor,<EOL>n_hidden_list: List,<EOL>cell_type='<STR_LIT>',<EOL>seq_lengths=None,<EOL>use_peepholes=False,<EOL>name='<STR_LIT>'):", "body": "for n, n_hidden in enumerate(n_hidden_list):<EOL><INDENT>with tf.variable_scope(name + '<STR_LIT:_>' + str(n)):<EOL><INDENT>if cell_type == '<STR_LIT>':<EOL><INDENT>forward_cell = tf.nn.rnn_cell.GRUCell(n_hidden)<EOL>backward_cell = tf.nn.rnn_cell.GRUCell(n_hidden)<EOL><DEDENT>elif cell_type == '<STR_LIT>':<EOL><INDENT>forward_cell = tf.nn.rnn_cell.LSTMCell(n_hidden, use_peepholes=use_peepholes)<EOL>backward_cell = tf.nn.rnn_cell.LSTMCell(n_hidden, use_peepholes=use_peepholes)<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>(rnn_output_fw, rnn_output_bw), (fw, bw) =tf.nn.bidirectional_dynamic_rnn(forward_cell,<EOL>backward_cell,<EOL>units,<EOL>dtype=tf.float32,<EOL>sequence_length=seq_lengths)<EOL>units = tf.concat([rnn_output_fw, rnn_output_bw], axis=<NUM_LIT:2>)<EOL>if cell_type == '<STR_LIT>':<EOL><INDENT>last_units = tf.concat([fw, bw], axis=<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>(c_fw, h_fw), (c_bw, h_bw) = fw, bw<EOL>c = tf.concat([c_fw, c_bw], axis=<NUM_LIT:1>)<EOL>h = tf.concat([h_fw, h_bw], axis=<NUM_LIT:1>)<EOL>last_units = (h, c)<EOL><DEDENT><DEDENT><DEDENT>return units, last_units<EOL>", "docstring": "Stackted recurrent neural networks GRU or LSTM\n\n        Args:\n            units: a tensorflow tensor with dimensionality [None, n_tokens, n_features]\n            n_hidden_list: list with number of hidden units at the ouput of each layer\n            seq_lengths: length of sequences for different length sequences in batch\n                can be None for maximum length as a length for every sample in the batch\n            cell_type: 'lstm' or 'gru'\n            use_peepholes: whether to use peephole connections (only 'lstm' case affected)\n            name: what variable_scope to use for the network parameters\n        Returns:\n            units: tensor at the output of the last recurrent layer\n                with dimensionality [None, n_tokens, n_hidden_list[-1]]\n            last_units: tensor of last hidden states for GRU and tuple\n                of last hidden stated and last cell states for LSTM\n                dimensionality of cell states and hidden states are\n                similar and equal to [B x 2 * H], where B - batch\n                size and H is number of hidden units", "id": "f3157:m3"}
{"signature": "def multiplicative_self_attention(units, n_hidden=None, n_output_features=None, activation=None):", "body": "n_input_features = units.get_shape().as_list()[<NUM_LIT:2>]<EOL>if n_hidden is None:<EOL><INDENT>n_hidden = n_input_features<EOL><DEDENT>if n_output_features is None:<EOL><INDENT>n_output_features = n_input_features<EOL><DEDENT>queries = tf.layers.dense(expand_tile(units, <NUM_LIT:1>), n_hidden, kernel_initializer=INITIALIZER())<EOL>keys = tf.layers.dense(expand_tile(units, <NUM_LIT:2>), n_hidden, kernel_initializer=INITIALIZER())<EOL>scores = tf.reduce_sum(queries * keys, axis=<NUM_LIT:3>, keep_dims=True)<EOL>attention = tf.nn.softmax(scores, dim=<NUM_LIT:2>)<EOL>attended_units = tf.reduce_sum(attention * expand_tile(units, <NUM_LIT:1>), axis=<NUM_LIT:2>)<EOL>output = tf.layers.dense(attended_units, n_output_features, activation, kernel_initializer=INITIALIZER())<EOL>return output<EOL>", "docstring": "Computes multiplicative self attention for time series of vectors (with batch dimension)\n        the formula: score(h_i, h_j) = <W_1 h_i,  W_2 h_j>,  W_1 and W_2 are learnable matrices\n        with dimensionality [n_hidden, n_input_features], where <a, b> stands for a and b\n        dot product\n\n    Args:\n        units: tf tensor with dimensionality [batch_size, time_steps, n_input_features]\n        n_hidden: number of units in hidden representation of similarity measure\n        n_output_features: number of features in output dense layer\n        activation: activation at the output\n\n    Returns:\n        output: self attended tensor with dimensionality [batch_size, time_steps, n_output_features]", "id": "f3157:m10"}
{"signature": "def bi_rnn(units: tf.Tensor,<EOL>n_hidden: List,<EOL>cell_type='<STR_LIT>',<EOL>seq_lengths=None,<EOL>trainable_initial_states=False,<EOL>use_peepholes=False,<EOL>name='<STR_LIT>'):", "body": "with tf.variable_scope(name + '<STR_LIT:_>' + cell_type.upper()):<EOL><INDENT>if cell_type == '<STR_LIT>':<EOL><INDENT>forward_cell = tf.nn.rnn_cell.GRUCell(n_hidden, kernel_initializer=INITIALIZER())<EOL>backward_cell = tf.nn.rnn_cell.GRUCell(n_hidden, kernel_initializer=INITIALIZER())<EOL>if trainable_initial_states:<EOL><INDENT>initial_state_fw = tf.tile(tf.get_variable('<STR_LIT>', [<NUM_LIT:1>, n_hidden]), (tf.shape(units)[<NUM_LIT:0>], <NUM_LIT:1>))<EOL>initial_state_bw = tf.tile(tf.get_variable('<STR_LIT>', [<NUM_LIT:1>, n_hidden]), (tf.shape(units)[<NUM_LIT:0>], <NUM_LIT:1>))<EOL><DEDENT>else:<EOL><INDENT>initial_state_fw = initial_state_bw = None<EOL><DEDENT><DEDENT>elif cell_type == '<STR_LIT>':<EOL><INDENT>forward_cell = tf.nn.rnn_cell.LSTMCell(n_hidden, use_peepholes=use_peepholes, initializer=INITIALIZER())<EOL>backward_cell = tf.nn.rnn_cell.LSTMCell(n_hidden, use_peepholes=use_peepholes, initializer=INITIALIZER())<EOL>if trainable_initial_states:<EOL><INDENT>initial_state_fw = tf.nn.rnn_cell.LSTMStateTuple(<EOL>tf.tile(tf.get_variable('<STR_LIT>', [<NUM_LIT:1>, n_hidden]), (tf.shape(units)[<NUM_LIT:0>], <NUM_LIT:1>)),<EOL>tf.tile(tf.get_variable('<STR_LIT>', [<NUM_LIT:1>, n_hidden]), (tf.shape(units)[<NUM_LIT:0>], <NUM_LIT:1>)))<EOL>initial_state_bw = tf.nn.rnn_cell.LSTMStateTuple(<EOL>tf.tile(tf.get_variable('<STR_LIT>', [<NUM_LIT:1>, n_hidden]), (tf.shape(units)[<NUM_LIT:0>], <NUM_LIT:1>)),<EOL>tf.tile(tf.get_variable('<STR_LIT>', [<NUM_LIT:1>, n_hidden]), (tf.shape(units)[<NUM_LIT:0>], <NUM_LIT:1>)))<EOL><DEDENT>else:<EOL><INDENT>initial_state_fw = initial_state_bw = None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>(rnn_output_fw, rnn_output_bw), (fw, bw) =tf.nn.bidirectional_dynamic_rnn(forward_cell,<EOL>backward_cell,<EOL>units,<EOL>dtype=tf.float32,<EOL>sequence_length=seq_lengths,<EOL>initial_state_fw=initial_state_fw,<EOL>initial_state_bw=initial_state_bw)<EOL><DEDENT>kernels = [var for var in forward_cell.trainable_variables +<EOL>backward_cell.trainable_variables if '<STR_LIT>' in var.name]<EOL>for kernel in kernels:<EOL><INDENT>tf.add_to_collection(tf.GraphKeys.REGULARIZATION_LOSSES, tf.nn.l2_loss(kernel))<EOL><DEDENT>return (rnn_output_fw, rnn_output_bw), (fw, bw)<EOL>", "docstring": "Bi directional recurrent neural network. GRU or LSTM\n\n        Args:\n            units: a tensorflow tensor with dimensionality [None, n_tokens, n_features]\n            n_hidden: list with number of hidden units at the ouput of each layer\n            seq_lengths: length of sequences for different length sequences in batch\n                can be None for maximum length as a length for every sample in the batch\n            cell_type: 'lstm' or 'gru'\n            trainable_initial_states: whether to create a special trainable variable\n                to initialize the hidden states of the network or use just zeros\n            use_peepholes: whether to use peephole connections (only 'lstm' case affected)\n            name: what variable_scope to use for the network parameters\n\n        Returns:\n            units: tensor at the output of the last recurrent layer\n                with dimensionality [None, n_tokens, n_hidden_list[-1]]\n            last_units: tensor of last hidden states for GRU and tuple\n                of last hidden stated and last cell states for LSTM\n                dimensionality of cell states and hidden states are\n                similar and equal to [B x 2 * H], where B - batch\n                size and H is number of hidden units", "id": "f3157:m2"}
{"signature": "def u_shape(units: tf.Tensor,<EOL>n_hidden_list: List,<EOL>filter_width=<NUM_LIT:7>,<EOL>use_batch_norm=False,<EOL>training_ph=None):", "body": "<EOL>units_for_skip_conn = []<EOL>conv_net_params = {'<STR_LIT>': filter_width,<EOL>'<STR_LIT>': use_batch_norm,<EOL>'<STR_LIT>': training_ph}<EOL>for n_hidden in n_hidden_list:<EOL><INDENT>units = stacked_cnn(units, [n_hidden], **conv_net_params)<EOL>units_for_skip_conn.append(units)<EOL>units = tf.layers.max_pooling1d(units, pool_size=<NUM_LIT:2>, strides=<NUM_LIT:2>, padding='<STR_LIT>')<EOL><DEDENT>units = stacked_cnn(units, [n_hidden], **conv_net_params)<EOL>for down_step, n_hidden in enumerate(n_hidden_list[::-<NUM_LIT:1>]):<EOL><INDENT>units = tf.expand_dims(units, axis=<NUM_LIT:2>)<EOL>units = tf.layers.conv2d_transpose(units, n_hidden, filter_width, strides=(<NUM_LIT:2>, <NUM_LIT:1>), padding='<STR_LIT>')<EOL>units = tf.squeeze(units, axis=<NUM_LIT:2>)<EOL>skip_units = units_for_skip_conn[-(down_step + <NUM_LIT:1>)]<EOL>if skip_units.get_shape().as_list()[-<NUM_LIT:1>] != n_hidden:<EOL><INDENT>skip_units = tf.layers.dense(skip_units, n_hidden)<EOL><DEDENT>units = skip_units + units<EOL>units = stacked_cnn(units, [n_hidden], **conv_net_params)<EOL><DEDENT>return units<EOL>", "docstring": "Network architecture inspired by One Hundred layer Tiramisu.\n        https://arxiv.org/abs/1611.09326. U-Net like.\n\n        Args:\n            units: a tensorflow tensor with dimensionality [None, n_tokens, n_features]\n            n_hidden_list: list with number of hidden units at the ouput of each layer\n            filter_width: width of the kernel in tokens\n            use_batch_norm: whether to use batch normalization between layers\n            training_ph: boolean placeholder determining whether is training phase now or not.\n                It is used only for batch normalization to determine whether to use\n                current batch average (std) or memory stored average (std)\n        Returns:\n            units: tensor at the output of the last convolutional layer\n                    with dimensionality [None, n_tokens, n_hidden_list[-1]]", "id": "f3157:m4"}
{"signature": "def variational_dropout(units, keep_prob, fixed_mask_dims=(<NUM_LIT:1>,)):", "body": "units_shape = tf.shape(units)<EOL>noise_shape = [units_shape[n] for n in range(len(units.shape))]<EOL>for dim in fixed_mask_dims:<EOL><INDENT>noise_shape[dim] = <NUM_LIT:1><EOL><DEDENT>return tf.nn.dropout(units, keep_prob, noise_shape)<EOL>", "docstring": "Dropout with the same drop mask for all fixed_mask_dims\n\n    Args:\n        units: a tensor, usually with shapes [B x T x F], where\n            B - batch size\n            T - tokens dimension\n            F - feature dimension\n        keep_prob: keep probability\n        fixed_mask_dims: in these dimensions the mask will be the same\n\n    Returns:\n        dropped units tensor", "id": "f3157:m20"}
{"signature": "def expand_tile(units, axis):", "body": "assert axis in (<NUM_LIT:1>, <NUM_LIT:2>)<EOL>n_time_steps = tf.shape(units)[<NUM_LIT:1>]<EOL>repetitions = [<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>]<EOL>repetitions[axis] = n_time_steps<EOL>return tf.tile(tf.expand_dims(units, axis), repetitions)<EOL>", "docstring": "Expand and tile tensor along given axis\n    Args:\n        units: tf tensor with dimensions [batch_size, time_steps, n_input_features]\n        axis: axis along which expand and tile. Must be 1 or 2", "id": "f3157:m8"}
{"signature": "def attention_gen_block(hidden_for_sketch, hidden_for_attn_alignment, key, attention_depth):", "body": "with tf.name_scope('<STR_LIT>'):<EOL><INDENT>sketch_dims = tf.shape(hidden_for_sketch)<EOL>batch_size = sketch_dims[<NUM_LIT:0>]<EOL>num_tokens = sketch_dims[<NUM_LIT:1>]<EOL>hidden_size = sketch_dims[<NUM_LIT:2>]<EOL>attn_alignment_dims = tf.shape(hidden_for_attn_alignment)<EOL>attn_alignment_hidden_size = attn_alignment_dims[<NUM_LIT:2>]<EOL>sketches = [tf.zeros(shape=[batch_size, hidden_size], dtype=tf.float32)]<EOL>aligned_hiddens = []<EOL>cum_att = tf.zeros(shape=[batch_size, num_tokens])  <EOL>for i in range(attention_depth):<EOL><INDENT>sketch, cum_att_, aligned_hidden = attention_gen_step(hidden_for_sketch, hidden_for_attn_alignment, sketches[-<NUM_LIT:1>], key, cum_att)<EOL>sketches.append(sketch) <EOL>aligned_hiddens.append(aligned_hidden) <EOL>cum_att += cum_att_<EOL><DEDENT>final_aligned_hiddens = tf.reshape(tf.transpose(tf.stack(aligned_hiddens), [<NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:2>]),[<NUM_LIT:1>, attention_depth, attn_alignment_hidden_size])<EOL><DEDENT>return final_aligned_hiddens<EOL>", "docstring": "It is a implementation of the Luong et al. attention mechanism with general score and the constrained softmax (csoftmax).\n        Based on the papers:\n        https://arxiv.org/abs/1508.04025 \"Effective Approaches to Attention-based Neural Machine Translation\"\n        https://andre-martins.github.io/docs/emnlp2017_final.pdf \"Learning What's Easy: Fully Differentiable Neural Easy-First Taggers\"\n    Args:\n        hidden_for_sketch: A tensorflow tensor for a sketch computing. This tensor have dimensionality [None, max_num_tokens, sketch_hidden_size]\n        hidden_for_attn_alignment: A tensorflow tensor is aligned for output during a performing. This tensor have dimensionality [None, max_num_tokens, hidden_size_for_attn_alignment]\n        key: A tensorflow tensor with dimensionality [None, None, key_size]\n        attention_depth: Number of usage csoftmax\n    Returns:\n        final_aligned_hiddens: Tensor at the output with dimensionality [1, attention_depth, hidden_size_for_attn_alignment]", "id": "f3158:m3"}
{"signature": "def csoftmax(tensor, inv_cumulative_att):", "body": "shape_ten = tensor.shape<EOL>shape_cum = inv_cumulative_att.shape<EOL>merge_tensor = [tensor, inv_cumulative_att]<EOL>cs, _ = tf.map_fn(csoftmax_for_slice, merge_tensor, dtype=[tf.float32, tf.float32])  <EOL>return cs<EOL>", "docstring": "It is a implementation of the constrained softmax (csoftmax).\n        Based on the paper:\n        https://andre-martins.github.io/docs/emnlp2017_final.pdf \"Learning What's Easy: Fully Differentiable Neural Easy-First Taggers\"\n    Args:\n        tensor: A tensorflow tensor is score. This tensor have dimensionality [None, n_tokens]\n        inv_cumulative_att: A inverse cumulative attention tensor with dimensionality [None, n_tokens]\n    Returns:\n        cs: Tensor at the output with dimensionality [None, n_tokens]", "id": "f3158:m1"}
{"signature": "def bahdanau_attention(key, context, hidden_size, projected_align=False):", "body": "if hidden_size % <NUM_LIT:2> != <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>batch_size = tf.shape(context)[<NUM_LIT:0>]<EOL>max_num_tokens, token_size = context.get_shape().as_list()[-<NUM_LIT:2>:]<EOL>r_context = tf.reshape(context, shape=[-<NUM_LIT:1>, max_num_tokens, token_size])<EOL>projected_key = tf.layers.dense(key, hidden_size, kernel_initializer=xav())<EOL>r_projected_key =tf.tile(tf.reshape(projected_key, shape=[-<NUM_LIT:1>, <NUM_LIT:1>, hidden_size]),<EOL>[<NUM_LIT:1>, max_num_tokens, <NUM_LIT:1>])<EOL>lstm_fw_cell = tf.nn.rnn_cell.LSTMCell(hidden_size//<NUM_LIT:2>)<EOL>lstm_bw_cell = tf.nn.rnn_cell.LSTMCell(hidden_size//<NUM_LIT:2>)<EOL>(output_fw, output_bw), states =tf.nn.bidirectional_dynamic_rnn(cell_fw=lstm_fw_cell,<EOL>cell_bw=lstm_bw_cell,<EOL>inputs=r_context,<EOL>dtype=tf.float32)<EOL>bilstm_output = tf.concat([output_fw, output_bw], -<NUM_LIT:1>)<EOL>concat_h_state = tf.concat([r_projected_key, output_fw, output_bw], -<NUM_LIT:1>)<EOL>projected_state =tf.layers.dense(concat_h_state, hidden_size, use_bias=False,<EOL>kernel_initializer=xav())<EOL>score =tf.layers.dense(tf.tanh(projected_state), units=<NUM_LIT:1>, use_bias=False,<EOL>kernel_initializer=xav())<EOL>attn = tf.nn.softmax(score, dim=<NUM_LIT:1>)<EOL>if projected_align:<EOL><INDENT>log.info(\"<STR_LIT>\")<EOL>t_context = tf.transpose(bilstm_output, [<NUM_LIT:0>, <NUM_LIT:2>, <NUM_LIT:1>])<EOL>output = tf.reshape(tf.matmul(t_context, attn),<EOL>shape=[batch_size, -<NUM_LIT:1>, hidden_size])<EOL><DEDENT>else:<EOL><INDENT>log.info(\"<STR_LIT>\")<EOL>t_context = tf.transpose(r_context, [<NUM_LIT:0>, <NUM_LIT:2>, <NUM_LIT:1>])<EOL>output = tf.reshape(tf.matmul(t_context, attn),<EOL>shape=[batch_size, -<NUM_LIT:1>, token_size])<EOL><DEDENT>return output<EOL>", "docstring": "It is a implementation of the Bahdanau et al. attention mechanism. Based on the paper:\n        https://arxiv.org/abs/1409.0473 \"Neural Machine Translation by Jointly Learning to Align and Translate\"\n    Args:\n        key: A tensorflow tensor with dimensionality [None, None, key_size]\n        context: A tensorflow tensor with dimensionality [None, None, max_num_tokens, token_size]\n        hidden_size: Number of units in hidden representation\n        projected_align: Using bidirectional lstm for hidden representation of context.\n        If true, beetween input and attention mechanism insert layer of bidirectional lstm with dimensionality [hidden_size].\n        If false, bidirectional lstm is not used.\n    Returns:\n        output: Tensor at the output with dimensionality [None, None, hidden_size]", "id": "f3159:m3"}
{"signature": "def multiplicative_self_attention(units, n_hidden=None, n_output_features=None, activation=None):", "body": "n_input_features = K.int_shape(units)[<NUM_LIT:2>]<EOL>if n_hidden is None:<EOL><INDENT>n_hidden = n_input_features<EOL><DEDENT>if n_output_features is None:<EOL><INDENT>n_output_features = n_input_features<EOL><DEDENT>exp1 = Lambda(lambda x: expand_tile(x, axis=<NUM_LIT:1>))(units)<EOL>exp2 = Lambda(lambda x: expand_tile(x, axis=<NUM_LIT:2>))(units)<EOL>queries = Dense(n_hidden)(exp1)<EOL>keys = Dense(n_hidden)(exp2)<EOL>scores = Lambda(lambda x: K.sum(queries * x, axis=<NUM_LIT:3>, keepdims=True))(keys)<EOL>attention = Lambda(lambda x: softmax(x, axis=<NUM_LIT:2>))(scores)<EOL>mult = Multiply()([attention, exp1])<EOL>attended_units = Lambda(lambda x: K.sum(x, axis=<NUM_LIT:2>))(mult)<EOL>output = Dense(n_output_features, activation=activation)(attended_units)<EOL>return output<EOL>", "docstring": "Compute multiplicative self attention for time series of vectors (with batch dimension)\nthe formula: score(h_i, h_j) = <W_1 h_i,  W_2 h_j>,  W_1 and W_2 are learnable matrices\nwith dimensionality [n_hidden, n_input_features]\n\nArgs:\n    units: tf tensor with dimensionality [batch_size, time_steps, n_input_features]\n    n_hidden: number of units in hidden representation of similarity measure\n    n_output_features: number of features in output dense layer\n    activation: activation at the output\n\nReturns:\n    output: self attended tensor with dimensionality [batch_size, time_steps, n_output_features]", "id": "f3160:m2"}
{"signature": "def additive_self_attention(units, n_hidden=None, n_output_features=None, activation=None):", "body": "n_input_features = K.int_shape(units)[<NUM_LIT:2>]<EOL>if n_hidden is None:<EOL><INDENT>n_hidden = n_input_features<EOL><DEDENT>if n_output_features is None:<EOL><INDENT>n_output_features = n_input_features<EOL><DEDENT>exp1 = Lambda(lambda x: expand_tile(x, axis=<NUM_LIT:1>))(units)<EOL>exp2 = Lambda(lambda x: expand_tile(x, axis=<NUM_LIT:2>))(units)<EOL>units_pairs = Concatenate(axis=<NUM_LIT:3>)([exp1, exp2])<EOL>query = Dense(n_hidden, activation=\"<STR_LIT>\")(units_pairs)<EOL>attention = Dense(<NUM_LIT:1>, activation=lambda x: softmax(x, axis=<NUM_LIT:2>))(query)<EOL>attended_units = Lambda(lambda x: K.sum(attention * x, axis=<NUM_LIT:2>))(exp1)<EOL>output = Dense(n_output_features, activation=activation)(attended_units)<EOL>return output<EOL>", "docstring": "Compute additive self attention for time series of vectors (with batch dimension)\n        the formula: score(h_i, h_j) = <v, tanh(W_1 h_i + W_2 h_j)>\n        v is a learnable vector of n_hidden dimensionality,\n        W_1 and W_2 are learnable [n_hidden, n_input_features] matrices\n\nArgs:\n    units: tf tensor with dimensionality [batch_size, time_steps, n_input_features]\n    n_hidden: number of2784131 units in hidden representation of similarity measure\n    n_output_features: number of features in output dense layer\n    activation: activation at the output\n\nReturns:\n    output: self attended tensor with dimensionality [batch_size, time_steps, n_output_features]", "id": "f3160:m1"}
{"signature": "def interact_model(config: Union[str, Path, dict]) -> None:", "body": "model = build_model(config)<EOL>while True:<EOL><INDENT>args = []<EOL>for in_x in model.in_x:<EOL><INDENT>args.append((input('<STR_LIT>'.format(in_x)),))<EOL>if args[-<NUM_LIT:1>][<NUM_LIT:0>] in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:q>'}:<EOL><INDENT>return<EOL><DEDENT><DEDENT>pred = model(*args)<EOL>if len(model.out_params) > <NUM_LIT:1>:<EOL><INDENT>pred = zip(*pred)<EOL><DEDENT>print('<STR_LIT>', *pred)<EOL><DEDENT>", "docstring": "Start interaction with the model described in corresponding configuration file.", "id": "f3162:m1"}
{"signature": "def initialize_params_in_config(self, basic_config: dict, paths: List[list]) -> dict:", "body": "config = deepcopy(basic_config)<EOL>for path_ in paths:<EOL><INDENT>param_name = path_[-<NUM_LIT:1>]<EOL>value = self.get_value_from_config(basic_config, path_)<EOL>if isinstance(value, dict):<EOL><INDENT>if (value.get(self.prefix + \"<STR_LIT>\") or<EOL>value.get(self.prefix + \"<STR_LIT>\") or<EOL>value.get(self.prefix + \"<STR_LIT>\")):<EOL><INDENT>self.insert_value_or_dict_into_config(<EOL>config, path_,<EOL>self.sample_params(**{param_name: deepcopy(value)})[param_name])<EOL><DEDENT><DEDENT><DEDENT>return config<EOL>", "docstring": "Randomly initialize all the changable parameters in config\n\nArgs:\n    basic_config: config where changable parameters are dictionaries with keys\n        ``prefix`_range`, ``prefix`_bool`, ``prefix`_choice`\n    paths: list of paths to changable parameters\n\nReturns:\n    config", "id": "f3168:c0:m5"}
{"signature": "def sample_params(self, **params) -> dict:", "body": "if not params:<EOL><INDENT>return {}<EOL><DEDENT>else:<EOL><INDENT>params_copy = deepcopy(params)<EOL><DEDENT>params_sample = dict()<EOL>for param, param_val in params_copy.items():<EOL><INDENT>if isinstance(param_val, dict):<EOL><INDENT>if self.prefix + '<STR_LIT>' in param_val and param_val[self.prefix + '<STR_LIT>']:<EOL><INDENT>sample = bool(random.choice([True, False]))<EOL><DEDENT>elif self.prefix + '<STR_LIT>' in param_val:<EOL><INDENT>sample = self._sample_from_ranges(param_val)<EOL><DEDENT>elif self.prefix + '<STR_LIT>' in param_val:<EOL><INDENT>sample = random.choice(param_val[self.prefix + '<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>sample = param_val<EOL><DEDENT>params_sample[param] = sample<EOL><DEDENT>else:<EOL><INDENT>params_sample[param] = params_copy[param]<EOL><DEDENT><DEDENT>return params_sample<EOL>", "docstring": "Sample parameters according to the given possible values\n\nArgs:\n    **params: dictionary like {\"param_0\": {\"`prefix`_range\": [0, 10]},\n                               \"param_1\": {\"`prefix`_range\": [0, 10], \"discrete\": true},\n                               \"param_2\": {\"`prefix`_range\": [0, 1], \"scale\": \"log\"},\n                               \"param_3\": {\"`prefix`_bool\": true},\n                               \"param_4\": {\"`prefix`_choice\": [0, 1, 2, 3]}}\n\nReturns:\n    dictionary with randomly sampled parameters", "id": "f3168:c0:m6"}
{"signature": "def get_metric_by_name(name: str) -> Callable[..., Any]:", "body": "if name not in _REGISTRY:<EOL><INDENT>raise ConfigError(f'<STR_LIT>')<EOL><DEDENT>return fn_from_str(_REGISTRY[name])<EOL>", "docstring": "Returns a metric callable with a corresponding name.", "id": "f3170:m2"}
{"signature": "def read(self, data_path: str, *args, **kwargs) -> Dict[str, List[Tuple[Any, Any]]]:", "body": "raise NotImplementedError<EOL>", "docstring": "Reads a file from a path and returns data as a list of tuples of inputs and correct outputs\n         for every data type in ``train``, ``valid`` and ``test``.", "id": "f3176:c0:m0"}
{"signature": "def path_set_md5(url):", "body": "scheme, netloc, path, query_string, fragment = urlsplit(url)<EOL>path += '<STR_LIT>'<EOL>return urlunsplit((scheme, netloc, path, query_string, fragment))<EOL>", "docstring": "Given a file URL, return a md5 query of the file\n\n    Args:\n        url: a given URL\n    Returns:\n        URL of the md5 file", "id": "f3180:m24"}
{"signature": "def set_query_parameter(url, param_name, param_value):", "body": "scheme, netloc, path, query_string, fragment = urlsplit(url)<EOL>query_params = parse_qs(query_string)<EOL>query_params[param_name] = [param_value]<EOL>new_query_string = urlencode(query_params, doseq=True)<EOL>return urlunsplit((scheme, netloc, path, new_query_string, fragment))<EOL>", "docstring": "Given a URL, set or replace a query parameter and return the modified URL.\n\n    Args:\n        url: a given  URL\n        param_name: the parameter name to add\n        param_value: the parameter value\n    Returns:\n        URL with the added parameter", "id": "f3180:m25"}
{"signature": "def _init_agent(self) -> DefaultAgent:", "body": "<EOL>agent = self.agent_generator()<EOL>return agent<EOL>", "docstring": "Initiates Alexa skill agent from agent generator", "id": "f3193:c0:m3"}
{"signature": "def verify_cert(signature_chain_url: str) -> Optional[crypto.X509]:", "body": "try:<EOL><INDENT>certs_chain_get = requests.get(signature_chain_url)<EOL><DEDENT>except requests.exceptions.ConnectionError as e:<EOL><INDENT>log.error(f'<STR_LIT>')<EOL>return None<EOL><DEDENT>certs_chain_txt = certs_chain_get.text<EOL>certs_chain = extract_certs(certs_chain_txt)<EOL>amazon_cert: crypto.X509 = certs_chain.pop(<NUM_LIT:0>)<EOL>sc_url_verification = verify_sc_url(signature_chain_url)<EOL>if not sc_url_verification:<EOL><INDENT>log.error(f'<STR_LIT>')<EOL><DEDENT>expired_verification = not amazon_cert.has_expired()<EOL>if not expired_verification:<EOL><INDENT>log.error(f'<STR_LIT>')<EOL><DEDENT>sans_verification = verify_sans(amazon_cert)<EOL>if not sans_verification:<EOL><INDENT>log.error(f'<STR_LIT>')<EOL><DEDENT>chain_verification = verify_certs_chain(certs_chain, amazon_cert)<EOL>if not chain_verification:<EOL><INDENT>log.error(f'<STR_LIT>')<EOL><DEDENT>result = (sc_url_verification and expired_verification and sans_verification and chain_verification)<EOL>return amazon_cert if result else None<EOL>", "docstring": "Conducts series of Alexa SSL certificate verifications against Amazon Alexa requirements.\n\n    Args:\n        signature_chain_url: Signature certificate URL from SignatureCertChainUrl HTTP header.\n    Returns:\n        result: Amazon certificate if verification was successful, None if not.", "id": "f3194:m5"}
{"signature": "def verify_sans(amazon_cert: crypto.X509) -> bool:", "body": "cert_extentions = [amazon_cert.get_extension(i) for i in range(amazon_cert.get_extension_count())]<EOL>subject_alt_names = '<STR_LIT>'<EOL>for extention in cert_extentions:<EOL><INDENT>if '<STR_LIT>' in str(extention.get_short_name()):<EOL><INDENT>subject_alt_names = extention.__str__()<EOL>break<EOL><DEDENT><DEDENT>result = '<STR_LIT>' in subject_alt_names<EOL>return result<EOL>", "docstring": "Verifies Subject Alternative Names (SANs) for Amazon certificate.\n\n    Args:\n        amazon_cert: Pycrypto X509 Amazon certificate.\n\n    Returns:\n        result: True if verification was successful, False if not.", "id": "f3194:m2"}
{"signature": "def handle_request(self, request: dict) -> dict:", "body": "request_type = request['<STR_LIT>']['<STR_LIT:type>']<EOL>request_id = request['<STR_LIT>']['<STR_LIT>']<EOL>log.debug(f'<STR_LIT>')<EOL>if request_type in self.handled_requests.keys():<EOL><INDENT>response: dict = self.handled_requests[request_type](request)<EOL><DEDENT>else:<EOL><INDENT>response: dict = self.handled_requests['<STR_LIT>'](request)<EOL>log.warning(f'<STR_LIT>')<EOL><DEDENT>self._rearm_self_destruct()<EOL>return response<EOL>", "docstring": "Routes Alexa requests to appropriate handlers.\n\n        Args:\n            request: Alexa request.\n        Returns:\n            response: Response conforming Alexa response specification.", "id": "f3195:c0:m3"}
{"signature": "def _start_timer(self) -> None:", "body": "self.timer = Timer(self.config['<STR_LIT>'], self.self_destruct_callback)<EOL>self.timer.start()<EOL>", "docstring": "Initiates self-destruct timer.", "id": "f3195:c0:m1"}
{"signature": "@overrides<EOL><INDENT>def gen_batches(self, batch_size: int, shuffle: bool = None)-> Generator[Tuple[List[str], List[int]], Any, None]:<DEDENT>", "body": "if shuffle is None:<EOL><INDENT>shuffle = self.shuffle<EOL><DEDENT>if shuffle:<EOL><INDENT>_doc_ids = self.random.sample(self.doc_ids, len(self.doc_ids))<EOL><DEDENT>else:<EOL><INDENT>_doc_ids = self.doc_ids<EOL><DEDENT>if batch_size > <NUM_LIT:0>:<EOL><INDENT>batches = [_doc_ids[i:i + batch_size] for i in<EOL>range(<NUM_LIT:0>, len(_doc_ids), batch_size)]<EOL><DEDENT>else:<EOL><INDENT>batches = [_doc_ids]<EOL><DEDENT>for i, doc_ids in enumerate(batches):<EOL><INDENT>docs = [self.get_doc_content(doc_id) for doc_id in doc_ids]<EOL>doc_nums = [self.doc2index[doc_id] for doc_id in doc_ids]<EOL>yield docs, zip(doc_ids, doc_nums)<EOL><DEDENT>", "docstring": "Gen batches of documents.\n\n        Args:\n            batch_size: a number of samples in a single batch\n            shuffle: whether to shuffle data during batching\n\n        Yields:\n            generated tuple of documents and their ids", "id": "f3203:c0:m5"}
{"signature": "def get_db_name(self) -> str:", "body": "cursor = self.connect.cursor()<EOL>cursor.execute(\"<STR_LIT>\")<EOL>assert cursor.arraysize == <NUM_LIT:1><EOL>name = cursor.fetchone()[<NUM_LIT:0>]<EOL>cursor.close()<EOL>return name<EOL>", "docstring": "Get DB name.\n\n        Returns:\n            DB name", "id": "f3203:c0:m2"}
{"signature": "def map_doc2idx(self) -> Dict[int, Any]:", "body": "doc2idx = {doc_id: i for i, doc_id in enumerate(self.doc_ids)}<EOL>logger.info(<EOL>\"<STR_LIT>\".format(len(doc2idx)))<EOL>return doc2idx<EOL>", "docstring": "Map DB ids to integer ids.\n\n        Returns:\n            a dictionary of document titles and correspondent integer indices", "id": "f3203:c0:m3"}
{"signature": "@overrides<EOL><INDENT>def get_doc_ids(self) -> List[Any]:<DEDENT>", "body": "cursor = self.connect.cursor()<EOL>cursor.execute('<STR_LIT>'.format(self.db_name))<EOL>ids = [ids[<NUM_LIT:0>] for ids in cursor.fetchall()]<EOL>cursor.close()<EOL>return ids<EOL>", "docstring": "Get document ids.\n\n        Returns:\n            document ids", "id": "f3203:c0:m1"}
{"signature": "def get_instances(self):", "body": "doc_ids = list(self.doc_ids)<EOL>docs = [self.get_doc_content(doc_id) for doc_id in doc_ids]<EOL>doc_nums = [self.doc2index[doc_id] for doc_id in doc_ids]<EOL>return docs, zip(doc_ids, doc_nums)<EOL>", "docstring": "Get all data", "id": "f3203:c0:m6"}
{"signature": "@overrides<EOL><INDENT>def get_doc_content(self, doc_id: Any) -> Optional[str]:<DEDENT>", "body": "cursor = self.connect.cursor()<EOL>cursor.execute(<EOL>\"<STR_LIT>\".format(self.db_name),<EOL>(doc_id,)<EOL>)<EOL>result = cursor.fetchone()<EOL>cursor.close()<EOL>return result if result is None else result[<NUM_LIT:0>]<EOL>", "docstring": "Get document content by id.\n\n        Args:\n            doc_id: a document id\n\n        Returns:\n            document content if success, else raise Exception", "id": "f3203:c0:m4"}
{"signature": "@staticmethod<EOL><INDENT>def _extract_cqas(data: Dict[str, Any]) -> List[Tuple[Tuple[str, str], Tuple[List[str], List[int]]]]:<DEDENT>", "body": "cqas = []<EOL>if data:<EOL><INDENT>for article in data['<STR_LIT:data>']:<EOL><INDENT>for par in article['<STR_LIT>']:<EOL><INDENT>context = par['<STR_LIT>']<EOL>for qa in par['<STR_LIT>']:<EOL><INDENT>q = qa['<STR_LIT>']<EOL>ans_text = []<EOL>ans_start = []<EOL>for answer in qa['<STR_LIT>']:<EOL><INDENT>ans_text.append(answer['<STR_LIT:text>'])<EOL>ans_start.append(answer['<STR_LIT>'])<EOL><DEDENT>cqas.append(((context, q), (ans_text, ans_start)))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return cqas<EOL>", "docstring": "Extracts context, question, answer, answer_start from SQuAD data\n\n        Args:\n            data: data in squad format\n\n        Returns:\n            list of (context, question), (answer_text, answer_start)\n            answer text and answer_start are lists", "id": "f3205:c0:m1"}
{"signature": "def gen_batches(self, batch_size: int, data_type: str = '<STR_LIT:train>',<EOL>shuffle: bool = None, return_indexes: bool = False) -> Iterator[tuple]:", "body": "if shuffle is None:<EOL><INDENT>shuffle = self.shuffle<EOL><DEDENT>data = self.data[data_type]<EOL>if shuffle:<EOL><INDENT>random.shuffle(data)<EOL><DEDENT>lengths = [len(x[<NUM_LIT:0>]) for x in data]<EOL>indexes = np.argsort(lengths)<EOL>L = len(data)<EOL>if batch_size < <NUM_LIT:0>:<EOL><INDENT>batch_size = L<EOL><DEDENT>for start in range(<NUM_LIT:0>, L, batch_size):<EOL><INDENT>indexes_to_yield = indexes[start:start+batch_size]<EOL>data_to_yield = tuple(list(x) for x in zip(*([data[i] for i in indexes_to_yield])))<EOL>if return_indexes:<EOL><INDENT>yield indexes_to_yield, data_to_yield<EOL><DEDENT>else:<EOL><INDENT>yield data_to_yield<EOL><DEDENT><DEDENT>", "docstring": "Generate batches of inputs and expected output to train neural networks\n\n        Args:\n            batch_size: number of samples in batch\n            data_type: can be either 'train', 'test', or 'valid'\n            shuffle: whether to shuffle dataset before batching\n            return_indexes: whether to return indexes of batch elements in initial dataset\n\n        Yields:\n            a tuple of a batch of inputs and a batch of expected outputs.\n            If `return_indexes` is True, also yields indexes of batch elements.", "id": "f3206:c0:m2"}
{"signature": "def main():", "body": "args = parser.parse_args()<EOL>path = get_settings_path()<EOL>if args.default:<EOL><INDENT>if populate_settings_dir(force=True):<EOL><INDENT>print(f'<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>print(f'<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>print(f'<STR_LIT>')<EOL><DEDENT>", "docstring": "DeepPavlov console configuration utility.", "id": "f3214:m0"}
{"signature": "def read_requirements():", "body": "reqs_path = os.path.join(__location__, '<STR_LIT>')<EOL>with open(reqs_path, encoding='<STR_LIT:utf8>') as f:<EOL><INDENT>reqs = [line.strip() for line in f if not line.strip().startswith('<STR_LIT:#>')]<EOL><DEDENT>names = []<EOL>links = []<EOL>for req in reqs:<EOL><INDENT>if '<STR_LIT>' in req:<EOL><INDENT>links.append(req)<EOL><DEDENT>else:<EOL><INDENT>names.append(req)<EOL><DEDENT><DEDENT>return {'<STR_LIT>': names, '<STR_LIT>': links}<EOL>", "docstring": "parses requirements from requirements.txt", "id": "f3217:m0"}
{"signature": "def is_effective_member(self, group_id, netid):", "body": "self._valid_group_id(group_id)<EOL>netid = re.sub('<STR_LIT>', '<STR_LIT>', netid)<EOL>url = \"<STR_LIT>\".format(self.API,<EOL>group_id,<EOL>netid)<EOL>try:<EOL><INDENT>data = self._get_resource(url)<EOL>return True  <EOL><DEDENT>except DataFailureException as ex:<EOL><INDENT>if ex.status == <NUM_LIT>:<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>", "docstring": "Returns True if the netid is in the group, False otherwise.", "id": "f3223:c0:m10"}
{"signature": "def get_group_by_id(self, group_id):", "body": "self._valid_group_id(group_id)<EOL>url = \"<STR_LIT>\".format(self.API, group_id)<EOL>data = self._get_resource(url)<EOL>return self._group_from_json(data.get(\"<STR_LIT:data>\"))<EOL>", "docstring": "Returns a restclients.Group object for the group identified by the\npassed group ID.", "id": "f3223:c0:m2"}
{"signature": "def emit(self, record):", "body": "msg = self.format(record)<EOL>if not isinstance(msg, dict):<EOL><INDENT>msg = json.loads(msg)<EOL><DEDENT>self.collection.insert(msg)<EOL>", "docstring": "pymongo expects a dict", "id": "f3230:c0:m1"}
{"signature": "def avail_archs(self):", "body": "return {<EOL>ARM32:   (KS_ARCH_ARM,     KS_MODE_ARM),<EOL>ARM64:   (KS_ARCH_ARM64,   KS_MODE_LITTLE_ENDIAN),<EOL>ARM_TB:  (KS_ARCH_ARM,     KS_MODE_THUMB),<EOL>HEXAGON: (KS_ARCH_HEXAGON, KS_MODE_BIG_ENDIAN),<EOL>MIPS32:  (KS_ARCH_MIPS,    KS_MODE_MIPS32),<EOL>MIPS64:  (KS_ARCH_MIPS,    KS_MODE_MIPS64),<EOL>PPC32:   (KS_ARCH_PPC,     KS_MODE_PPC32),<EOL>PPC64:   (KS_ARCH_PPC,     KS_MODE_PPC64),<EOL>SPARC32: (KS_ARCH_SPARC,   KS_MODE_SPARC32),<EOL>SPARC64: (KS_ARCH_SPARC,   KS_MODE_SPARC64),<EOL>SYSTEMZ: (KS_ARCH_SYSTEMZ, KS_MODE_BIG_ENDIAN),<EOL>X86_16:  (KS_ARCH_X86,     KS_MODE_16),<EOL>X86_32:  (KS_ARCH_X86,     KS_MODE_32),<EOL>X86_64:  (KS_ARCH_X86,     KS_MODE_64),<EOL>}<EOL>", "docstring": "Initialize the dictionary of architectures for assembling via keystone", "id": "f3245:c0:m2"}
{"signature": "def _ensure_log_handler(self):", "body": "if log.handlers:<EOL><INDENT>return<EOL><DEDENT>handler = logging.StreamHandler()<EOL>formatter = logging.Formatter(<EOL>'<STR_LIT>')<EOL>handler.setFormatter(formatter)<EOL>log.addHandler(handler)<EOL>", "docstring": "If there's no log configuration, set up a default handler.", "id": "f3255:c0:m1"}
{"signature": "def _add_request_data(data, request):", "body": "try:<EOL><INDENT>request_data = _build_request_data(request)<EOL><DEDENT>except Exception as e:<EOL><INDENT>log.exception(\"<STR_LIT>\", e)<EOL><DEDENT>else:<EOL><INDENT>if request_data:<EOL><INDENT>_filter_ip(request_data, SETTINGS['<STR_LIT>'])<EOL>data['<STR_LIT>'] = request_data<EOL><DEDENT><DEDENT>", "docstring": "Attempts to build request data; if successful, sets the 'request' key on `data`.", "id": "f3284:m30"}
{"signature": "def _build_payload(data):", "body": "for k, v in iteritems(data):<EOL><INDENT>data[k] = _transform(v, key=(k,))<EOL><DEDENT>payload = {<EOL>'<STR_LIT>': SETTINGS['<STR_LIT>'],<EOL>'<STR_LIT:data>': data<EOL>}<EOL>return payload<EOL>", "docstring": "Returns the full payload as a string.", "id": "f3284:m46"}
{"signature": "def init(access_token, environment='<STR_LIT>', scrub_fields=None, url_fields=None, **kw):", "body": "global SETTINGS, agent_log, _initialized, _transforms, _serialize_transform, _threads<EOL>if scrub_fields is not None:<EOL><INDENT>SETTINGS['<STR_LIT>'] = list(scrub_fields)<EOL><DEDENT>if url_fields is not None:<EOL><INDENT>SETTINGS['<STR_LIT>'] = list(url_fields)<EOL><DEDENT>SETTINGS = dict_merge(SETTINGS, kw)<EOL>if _initialized:<EOL><INDENT>if not SETTINGS.get('<STR_LIT>'):<EOL><INDENT>log.warning('<STR_LIT>')<EOL><DEDENT>return<EOL><DEDENT>SETTINGS['<STR_LIT>'] = access_token<EOL>SETTINGS['<STR_LIT>'] = environment<EOL>if SETTINGS.get('<STR_LIT>'):<EOL><INDENT>logging.basicConfig()<EOL><DEDENT>if SETTINGS.get('<STR_LIT>') == '<STR_LIT>':<EOL><INDENT>agent_log = _create_agent_log()<EOL><DEDENT>_serialize_transform = SerializableTransform(safe_repr=SETTINGS['<STR_LIT>']['<STR_LIT>'],<EOL>whitelist_types=SETTINGS['<STR_LIT>']['<STR_LIT>'])<EOL>_transforms = [<EOL>ScrubRedactTransform(),<EOL>_serialize_transform,<EOL>ScrubTransform(suffixes=[(field,) for field in SETTINGS['<STR_LIT>']], redact_char='<STR_LIT:*>'),<EOL>ScrubUrlTransform(suffixes=[(field,) for field in SETTINGS['<STR_LIT>']], params_to_scrub=SETTINGS['<STR_LIT>'])<EOL>]<EOL>shortener_keys = [<EOL>('<STR_LIT>', '<STR_LIT:POST>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT:body>', '<STR_LIT>', '<STR_LIT:POST>'),<EOL>('<STR_LIT:body>', '<STR_LIT>', '<STR_LIT>'),<EOL>]<EOL>if SETTINGS['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>shortener_keys.append(('<STR_LIT:body>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:*>', '<STR_LIT:code>'))<EOL>shortener_keys.append(('<STR_LIT:body>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:*>', '<STR_LIT:args>', '<STR_LIT:*>'))<EOL>shortener_keys.append(('<STR_LIT:body>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:*>', '<STR_LIT>', '<STR_LIT:*>'))<EOL>shortener_keys.append(('<STR_LIT:body>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:*>', '<STR_LIT>', '<STR_LIT:*>'))<EOL><DEDENT>shortener_keys.extend(SETTINGS['<STR_LIT>'])<EOL>shortener = ShortenerTransform(safe_repr=SETTINGS['<STR_LIT>']['<STR_LIT>'],<EOL>keys=shortener_keys,<EOL>**SETTINGS['<STR_LIT>']['<STR_LIT>'])<EOL>_transforms.append(shortener)<EOL>_threads = queue.Queue()<EOL>events.reset()<EOL>filters.add_builtin_filters(SETTINGS)<EOL>_initialized = True<EOL>", "docstring": "Saves configuration variables in this module's SETTINGS.\n\naccess_token: project access token. Get this from the Rollbar UI:\n              - click \"Settings\" in the top nav\n              - click \"Projects\" in the left nav\n              - copy-paste the appropriate token.\nenvironment: environment name. Can be any string; suggestions: 'production', 'development',\n             'staging', 'yourname'\n**kw: provided keyword arguments will override keys in SETTINGS.", "id": "f3284:m6"}
{"signature": "def _report_message(message, level, request, extra_data, payload_data):", "body": "if not _check_config():<EOL><INDENT>return<EOL><DEDENT>filtered_message = events.on_message(message,<EOL>request=request,<EOL>extra_data=extra_data,<EOL>payload_data=payload_data,<EOL>level=level)<EOL>if filtered_message is False:<EOL><INDENT>return<EOL><DEDENT>data = _build_base_data(request, level=level)<EOL>data['<STR_LIT:body>'] = {<EOL>'<STR_LIT:message>': {<EOL>'<STR_LIT:body>': filtered_message<EOL>}<EOL>}<EOL>if extra_data:<EOL><INDENT>extra_data = extra_data<EOL>data['<STR_LIT:body>']['<STR_LIT:message>'].update(extra_data)<EOL><DEDENT>request = _get_actual_request(request)<EOL>_add_request_data(data, request)<EOL>_add_person_data(data, request)<EOL>_add_lambda_context_data(data)<EOL>data['<STR_LIT>'] = _build_server_data()<EOL>if payload_data:<EOL><INDENT>data = dict_merge(data, payload_data)<EOL><DEDENT>payload = _build_payload(data)<EOL>send_payload(payload, payload.get('<STR_LIT>'))<EOL>return data['<STR_LIT>']<EOL>", "docstring": "Called by report_message() wrapper", "id": "f3284:m20"}
{"signature": "def _create_agent_log():", "body": "log_file = SETTINGS['<STR_LIT>']<EOL>if not log_file.endswith('<STR_LIT>'):<EOL><INDENT>log.error(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>log_file = DEFAULTS['<STR_LIT>']<EOL><DEDENT>retval = logging.getLogger('<STR_LIT>')<EOL>handler = logging.FileHandler(log_file, '<STR_LIT:a>', '<STR_LIT:utf-8>')<EOL>formatter = logging.Formatter('<STR_LIT>')<EOL>handler.setFormatter(formatter)<EOL>retval.addHandler(handler)<EOL>retval.setLevel(logging.WARNING)<EOL>return retval<EOL>", "docstring": "Creates .rollbar log file for use with rollbar-agent", "id": "f3284:m16"}
{"signature": "def search_items(title, return_fields=None, access_token=None, endpoint=None, **search_fields):", "body": "if not title:<EOL><INDENT>return []<EOL><DEDENT>if return_fields is not None:<EOL><INDENT>return_fields = '<STR_LIT:U+002C>'.join(return_fields)<EOL><DEDENT>return _get_api('<STR_LIT>',<EOL>title=title,<EOL>fields=return_fields,<EOL>access_token=access_token,<EOL>endpoint=endpoint,<EOL>**search_fields)<EOL>", "docstring": "Searches a project for items that match the input criteria.\n\ntitle: all or part of the item's title to search for.\nreturn_fields: the fields that should be returned for each item.\n        e.g. ['id', 'project_id', 'status'] will return a dict containing\n             only those fields for each item.\naccess_token: a project access token. If this is not provided,\n              the one provided to init() will be used instead.\nsearch_fields: additional fields to include in the search.\n        currently supported: status, level, environment", "id": "f3284:m11"}
{"signature": "def setLevel(self, level):", "body": "self.notify_level = _checkLevel(level)<EOL>", "docstring": "Override so we set the effective level for which\nlog records we notify Rollbar about instead of which\nrecords we save to the history.", "id": "f3297:c0:m1"}
{"signature": "def scale_image(self, in_fname, out_fname, max_width, max_height):", "body": "<EOL>try:<EOL><INDENT>from PIL import Image<EOL><DEDENT>except ImportError:<EOL><INDENT>import Image<EOL><DEDENT>img = Image.open(in_fname)<EOL>width_in, height_in = img.size<EOL>scale_w = max_width / float(width_in)<EOL>scale_h = max_height / float(height_in)<EOL>if height_in * scale_w <= max_height:<EOL><INDENT>scale = scale_w<EOL><DEDENT>else:<EOL><INDENT>scale = scale_h<EOL><DEDENT>if scale >= <NUM_LIT:1.0> and in_fname == out_fname:<EOL><INDENT>return<EOL><DEDENT>width_sc = int(round(scale * width_in))<EOL>height_sc = int(round(scale * height_in))<EOL>img.thumbnail((width_sc, height_sc), Image.ANTIALIAS)<EOL>thumb = Image.new('<STR_LIT>', (max_width, max_height), (<NUM_LIT:255>, <NUM_LIT:255>, <NUM_LIT:255>))<EOL>pos_insert = (<EOL>(max_width - width_sc) // <NUM_LIT:2>, (max_height - height_sc) // <NUM_LIT:2>)<EOL>thumb.paste(img, pos_insert)<EOL>thumb.save(out_fname)<EOL>", "docstring": "Scales an image with the same aspect ratio centered in an\n           image with a given max_width and max_height\n           if in_fname == out_fname the image can only be scaled down", "id": "f3301:c0:m16"}
{"signature": "@property<EOL><INDENT>def code_div(self):<DEDENT>", "body": "code_example = self.code_example<EOL>if code_example is None:<EOL><INDENT>return None<EOL><DEDENT>return self.CODE_TEMPLATE.format(<EOL>snippet=self.get_description()[<NUM_LIT:1>], code=code_example,<EOL>ref_name=self.reference)<EOL>", "docstring": "The string for creating a code example for the gallery", "id": "f3301:c0:m1"}
{"signature": "def copy_thumbnail_figure(self):", "body": "ret = None<EOL>if self._thumbnail_figure is not None:<EOL><INDENT>if not isstring(self._thumbnail_figure):<EOL><INDENT>ret = self._thumbnail_figure<EOL><DEDENT>else:<EOL><INDENT>ret = osp.join(osp.dirname(self.outfile),<EOL>osp.basename(self._thumbnail_figure))<EOL>copyfile(self._thumbnail_figure, ret)<EOL>return ret<EOL><DEDENT><DEDENT>elif hasattr(self.nb.metadata, '<STR_LIT>'):<EOL><INDENT>if not isstring(self.nb.metadata.thumbnail_figure):<EOL><INDENT>ret = self.nb.metadata.thumbnail_figure<EOL><DEDENT>else:<EOL><INDENT>ret = osp.join(osp.dirname(self.outfile), '<STR_LIT>',<EOL>osp.basename(self.nb.metadata.thumbnail_figure))<EOL>copyfile(osp.join(osp.dirname(self.infile),<EOL>self.nb.metadata.thumbnail_figure),<EOL>ret)<EOL><DEDENT><DEDENT>return ret<EOL>", "docstring": "The integer of the thumbnail figure", "id": "f3301:c0:m19"}
{"signature": "def __init__(self, infile, outfile, disable_warnings=True,<EOL>preprocess=True, clear=True, code_example=None,<EOL>supplementary_files=None, other_supplementary_files=None,<EOL>thumbnail_figure=None, url=None, insert_bokeh=False,<EOL>insert_bokeh_widgets=False, tag_options={}):", "body": "self.infile = infile<EOL>self.outfile = outfile<EOL>self.preprocess = preprocess<EOL>self.clear = clear<EOL>self._code_example = code_example<EOL>self._supplementary_files = supplementary_files<EOL>self._other_supplementary_files = other_supplementary_files<EOL>self._thumbnail_figure = thumbnail_figure<EOL>self._url = url<EOL>self.insert_bokeh = insert_bokeh<EOL>self.insert_bokeh_widgets = insert_bokeh_widgets<EOL>self.tag_options = tag_options<EOL>self.process_notebook(disable_warnings)<EOL>self.create_thumb()<EOL>", "docstring": "Parameters\n----------\ninfile: str\n    path to the existing notebook\noutfile: str\n    path to the new notebook\ndisable_warnings: bool\n    Boolean to control whether warnings shall be included in the rst\n    file or not\npreprocess: bool\n    If True, the notebook is processed when generating the rst file\nclear: bool\n    If True, the output in the download notebook is cleared\ncode_example: str\n    A python code sample that shall be used instead of a thumbnail\n    figure in the gallery. Note that you can also include a\n    ``'code_example'`` key in the metadata of the notebook\nsupplementary_files: list of str\n    Supplementary data files that shall be copied to the output\n    directory and inserted in the rst file for download\nother_supplementary_files: list of str\n    Other supplementary data files that shall be copied but not\n    inserted for download\nthumbnail_figure: int\n    The number of the figure that shall be used for download or a path\n    to a file\nurl: str\n    The url where to download the notebook\ninsert_bokeh: False or str\n    The version string for bokeh to use for the style sheet\ninsert_bokeh_widgets: bool or str\n    The version string for bokeh to use for the widgets style sheet\ntag_options: dict\n    A dictionary with traitlets for the\n    :class:`nbconvert.preprocessors.TagRemovePreprocessor`", "id": "f3301:c0:m8"}
{"signature": "def create_rst(self, nb, in_dir, odir):", "body": "raw_rst, resources = nbconvert.export_by_name('<STR_LIT>', nb)<EOL>rst_content = '<STR_LIT>'<EOL>i0 = <NUM_LIT:0><EOL>m = None<EOL>bokeh_str = '<STR_LIT>'<EOL>if '<STR_LIT>' in raw_rst and self.insert_bokeh:<EOL><INDENT>bokeh_str += self.BOKEH_TEMPLATE.format(<EOL>version=self.insert_bokeh)<EOL><DEDENT>if '<STR_LIT>' in raw_rst and self.insert_bokeh_widgets:<EOL><INDENT>bokeh_str += self.BOKEH_WIDGETS_TEMPLATE.format(<EOL>version=self.insert_bokeh_widgets)<EOL><DEDENT>for m in code_blocks.finditer(raw_rst):<EOL><INDENT>lines = m.group().splitlines(True)<EOL>header, content = lines[<NUM_LIT:0>], '<STR_LIT>'.join(lines[<NUM_LIT:1>:])<EOL>no_magics = magic_patt.sub('<STR_LIT>', content)<EOL>if no_magics.strip():<EOL><INDENT>rst_content += (<EOL>raw_rst[i0:m.start()] + bokeh_str + header + no_magics)<EOL>bokeh_str = '<STR_LIT>'<EOL>i0 = m.end()<EOL><DEDENT>else:<EOL><INDENT>rst_content += raw_rst[i0:m.start()]<EOL>i0 = m.end()<EOL><DEDENT><DEDENT>if m is not None:<EOL><INDENT>rst_content += bokeh_str + raw_rst[m.end():]<EOL><DEDENT>else:<EOL><INDENT>rst_content = raw_rst<EOL><DEDENT>rst_content = '<STR_LIT>' % self.reference +rst_content<EOL>url = self.url<EOL>if url is not None:<EOL><INDENT>rst_content += self.CODE_DOWNLOAD_NBVIEWER.format(<EOL>pyfile=os.path.basename(self.py_file),<EOL>nbfile=os.path.basename(self.outfile),<EOL>url=url)<EOL><DEDENT>else:<EOL><INDENT>rst_content += self.CODE_DOWNLOAD.format(<EOL>pyfile=os.path.basename(self.py_file),<EOL>nbfile=os.path.basename(self.outfile))<EOL><DEDENT>supplementary_files = self.supplementary_files<EOL>other_supplementary_files = self.other_supplementary_files<EOL>if supplementary_files or other_supplementary_files:<EOL><INDENT>for f in (supplementary_files or []) + (<EOL>other_supplementary_files or []):<EOL><INDENT>if not os.path.exists(os.path.join(odir, f)):<EOL><INDENT>copyfile(os.path.join(in_dir, f), os.path.join(odir, f))<EOL><DEDENT><DEDENT><DEDENT>if supplementary_files:<EOL><INDENT>rst_content += self.data_download(supplementary_files)<EOL><DEDENT>rst_file = self.get_out_file()<EOL>outputs = sorted(resources['<STR_LIT>'], key=rst_content.find)<EOL>base = os.path.join('<STR_LIT>', os.path.splitext(<EOL>os.path.basename(self.infile))[<NUM_LIT:0>] + '<STR_LIT>')<EOL>out_map = {os.path.basename(original): base % i<EOL>for i, original in enumerate(outputs)}<EOL>for original, final in six.iteritems(out_map):<EOL><INDENT>rst_content = rst_content.replace(original, final)<EOL><DEDENT>with open(rst_file, '<STR_LIT:w>')as f:<EOL><INDENT>f.write(rst_content.rstrip() + '<STR_LIT:\\n>')<EOL><DEDENT>pictures = []<EOL>for original in outputs:<EOL><INDENT>fname = os.path.join(odir, out_map[os.path.basename(original)])<EOL>pictures.append(fname)<EOL>if six.PY3:<EOL><INDENT>f = open(fname, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>f = open(fname, '<STR_LIT:w>')<EOL><DEDENT>f.write(resources['<STR_LIT>'][original])<EOL>f.close()<EOL><DEDENT>self.pictures = pictures<EOL>", "docstring": "Create the rst file from the notebook node", "id": "f3301:c0:m11"}
{"signature": "def nbviewer_link(url):", "body": "if six.PY2:<EOL><INDENT>from urlparse import urlparse as urlsplit<EOL><DEDENT>else:<EOL><INDENT>from urllib.parse import urlsplit<EOL><DEDENT>info = urlsplit(url)<EOL>domain = info.netloc<EOL>url_type = '<STR_LIT>' if domain == '<STR_LIT>' else '<STR_LIT:url>'<EOL>return '<STR_LIT>' % (url_type, info.path)<EOL>", "docstring": "Return the link to the Jupyter nbviewer for the given notebook url", "id": "f3301:m2"}
{"signature": "@property<EOL><INDENT>def code_example(self):<DEDENT>", "body": "if self._code_example is not None:<EOL><INDENT>return self._code_example<EOL><DEDENT>return getattr(self.nb.metadata, '<STR_LIT>', None)<EOL>", "docstring": "The code example out of the notebook metadata", "id": "f3301:c0:m2"}
{"signature": "@property<EOL><INDENT>def url(self):<DEDENT>", "body": "if self._url is not None:<EOL><INDENT>url = self._url<EOL><DEDENT>else:<EOL><INDENT>url = getattr(self.nb.metadata, '<STR_LIT:url>', None)<EOL><DEDENT>if url is not None:<EOL><INDENT>return nbviewer_link(url)<EOL><DEDENT>", "docstring": "The url on jupyter nbviewer for this notebook or None if unknown", "id": "f3301:c0:m6"}
{"signature": "def get_description(self):", "body": "def split_header(s, get_header=True):<EOL><INDENT>s = s.lstrip().rstrip()<EOL>parts = s.splitlines()<EOL>if parts[<NUM_LIT:0>].startswith('<STR_LIT:#>'):<EOL><INDENT>if get_header:<EOL><INDENT>header = re.sub('<STR_LIT>', '<STR_LIT>', parts.pop(<NUM_LIT:0>))<EOL>if not parts:<EOL><INDENT>return header, '<STR_LIT>'<EOL><DEDENT><DEDENT>else:<EOL><INDENT>header = '<STR_LIT>'<EOL><DEDENT>rest = '<STR_LIT:\\n>'.join(parts).lstrip().split('<STR_LIT>')<EOL>desc = rest[<NUM_LIT:0>].replace('<STR_LIT:\\n>', '<STR_LIT:U+0020>')<EOL>return header, desc<EOL><DEDENT>else:<EOL><INDENT>if get_header:<EOL><INDENT>if parts[<NUM_LIT:0>].startswith(('<STR_LIT:=>', '<STR_LIT:->')):<EOL><INDENT>parts = parts[<NUM_LIT:1>:]<EOL><DEDENT>header = parts.pop(<NUM_LIT:0>)<EOL>if parts and parts[<NUM_LIT:0>].startswith(('<STR_LIT:=>', '<STR_LIT:->')):<EOL><INDENT>parts.pop(<NUM_LIT:0>)<EOL><DEDENT>if not parts:<EOL><INDENT>return header, '<STR_LIT>'<EOL><DEDENT><DEDENT>else:<EOL><INDENT>header = '<STR_LIT>'<EOL><DEDENT>rest = '<STR_LIT:\\n>'.join(parts).lstrip().split('<STR_LIT>')<EOL>desc = rest[<NUM_LIT:0>].replace('<STR_LIT:\\n>', '<STR_LIT:U+0020>')<EOL>return header, desc<EOL><DEDENT><DEDENT>first_cell = self.nb['<STR_LIT>'][<NUM_LIT:0>]<EOL>if not first_cell['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>return '<STR_LIT>', '<STR_LIT>'<EOL><DEDENT>header, desc = split_header(first_cell['<STR_LIT:source>'])<EOL>if not desc and len(self.nb['<STR_LIT>']) > <NUM_LIT:1>:<EOL><INDENT>second_cell = self.nb['<STR_LIT>'][<NUM_LIT:1>]<EOL>if second_cell['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>_, desc = split_header(second_cell['<STR_LIT:source>'], False)<EOL><DEDENT><DEDENT>return header, desc<EOL>", "docstring": "Get summary and description of this notebook", "id": "f3301:c0:m15"}
{"signature": "def run_fastqc(job, r1_id, r2_id):", "body": "work_dir = job.fileStore.getLocalTempDir()<EOL>job.fileStore.readGlobalFile(r1_id, os.path.join(work_dir, '<STR_LIT>'))<EOL>parameters = ['<STR_LIT>']<EOL>output_names = ['<STR_LIT>', '<STR_LIT>']<EOL>if r2_id:<EOL><INDENT>job.fileStore.readGlobalFile(r2_id, os.path.join(work_dir, '<STR_LIT>'))<EOL>parameters.extend(['<STR_LIT>', '<STR_LIT:2>', '<STR_LIT>'])<EOL>output_names.extend(['<STR_LIT>', '<STR_LIT>'])<EOL><DEDENT>dockerCall(job=job, tool='<STR_LIT>',<EOL>workDir=work_dir, parameters=parameters)<EOL>output_files = [os.path.join(work_dir, x) for x in output_names]<EOL>tarball_files(tar_name='<STR_LIT>', file_paths=output_files, output_dir=work_dir)<EOL>return job.fileStore.writeGlobalFile(os.path.join(work_dir, '<STR_LIT>'))<EOL>", "docstring": "Run Fastqc on the input reads\n\n:param JobFunctionWrappingJob job: passed automatically by Toil\n:param str r1_id: FileStoreID of fastq read 1\n:param str r2_id: FileStoreID of fastq read 2\n:return: FileStoreID of fastQC output (tarball)\n:rtype: str", "id": "f3305:m0"}
{"signature": "def run_gatk_preprocessing(job, bam, bai, ref, ref_dict, fai, g1k, mills, dbsnp, realign=False, unsafe=False):", "body": "<EOL>mdups_disk = PromisedRequirement(lambda bam_, bai_: <NUM_LIT:2> * (bam_.size + bai_.size), bam, bai)<EOL>mdups = job.wrapJobFn(picard_mark_duplicates,<EOL>bam,<EOL>bai,<EOL>cores=job.cores,<EOL>disk=mdups_disk,<EOL>memory=job.memory)<EOL>bqsr_input_bam = mdups.rv(<NUM_LIT:0>)<EOL>bqsr_input_bai = mdups.rv(<NUM_LIT:1>)<EOL>genome_ref_size = ref.size + ref_dict.size + fai.size<EOL>if realign:<EOL><INDENT>indel_ref_size = mills.size + g1k.size + genome_ref_size<EOL>realigner_target_disk = PromisedRequirement(lambda bam_, bai_, ref_size:<EOL>bam_.size + bai_.size + <NUM_LIT:2> * ref_size,<EOL>mdups.rv(<NUM_LIT:0>),<EOL>mdups.rv(<NUM_LIT:1>),<EOL>indel_ref_size)<EOL>realigner_target = job.wrapJobFn(run_realigner_target_creator,<EOL>mdups.rv(<NUM_LIT:0>),<EOL>mdups.rv(<NUM_LIT:1>),<EOL>ref, ref_dict, fai,<EOL>g1k, mills,<EOL>unsafe=unsafe,<EOL>cores=<NUM_LIT:1>,  <EOL>disk=realigner_target_disk,<EOL>memory=job.memory)<EOL>indel_realign_disk = PromisedRequirement(lambda bam_, bai_, intervals, ref_size:<EOL><NUM_LIT:2> * (bam_.size + bai_.size) + intervals.size + ref_size,<EOL>mdups.rv(<NUM_LIT:0>),<EOL>mdups.rv(<NUM_LIT:1>),<EOL>realigner_target.rv(),<EOL>indel_ref_size)<EOL>indel_realign = job.wrapJobFn(run_indel_realignment,<EOL>realigner_target.rv(),<EOL>mdups.rv(<NUM_LIT:0>),<EOL>mdups.rv(<NUM_LIT:1>),<EOL>ref, ref_dict, fai,<EOL>g1k, mills,<EOL>unsafe=unsafe,<EOL>cores=<NUM_LIT:1>,  <EOL>disk=indel_realign_disk,<EOL>memory=job.memory)<EOL>mdups.addChild(realigner_target)<EOL>realigner_target.addChild(indel_realign)<EOL>bqsr_input_bam = indel_realign.rv(<NUM_LIT:0>)<EOL>bqsr_input_bai = indel_realign.rv(<NUM_LIT:1>)<EOL><DEDENT>bqsr_ref_size = dbsnp.size + mills.size + genome_ref_size<EOL>base_recal_disk = PromisedRequirement(lambda bam_, bai_, ref_size:<EOL>bam_.size + bai_.size + <NUM_LIT:2> * ref_size,<EOL>bqsr_input_bam,<EOL>bqsr_input_bai,<EOL>bqsr_ref_size)<EOL>base_recal = job.wrapJobFn(run_base_recalibration,<EOL>bqsr_input_bam,<EOL>bqsr_input_bai,<EOL>ref, ref_dict, fai,<EOL>dbsnp, mills,<EOL>unsafe=unsafe,<EOL>cores=job.cores,<EOL>disk=base_recal_disk,<EOL>memory=job.memory)<EOL>recalibrate_reads_disk = PromisedRequirement(lambda bam_, bai_, recal, ref_size:<EOL><NUM_LIT:2> * (bam_.size + bai_.size) + recal.size + ref_size,<EOL>bqsr_input_bam,<EOL>bqsr_input_bai,<EOL>base_recal.rv(),<EOL>genome_ref_size)<EOL>recalibrate_reads = job.wrapJobFn(apply_bqsr_recalibration,<EOL>base_recal.rv(),<EOL>bqsr_input_bam,<EOL>bqsr_input_bai,<EOL>ref, ref_dict, fai,<EOL>unsafe=unsafe,<EOL>cores=job.cores,<EOL>disk=recalibrate_reads_disk,<EOL>memory=job.memory)<EOL>job.addChild(mdups)<EOL>mdups.addFollowOn(base_recal)<EOL>base_recal.addChild(recalibrate_reads)<EOL>return recalibrate_reads.rv(<NUM_LIT:0>), recalibrate_reads.rv(<NUM_LIT:1>)<EOL>", "docstring": "GATK Preprocessing Pipeline\n0: Mark duplicates\n1: Create INDEL realignment intervals\n2: Realign INDELs\n3: Recalibrate base quality scores\n4: Apply base score recalibration\n\n:param JobFunctionWrappingJob job: passed automatically by Toil\n:param str bam: FileStoreID for BAM file\n:param str bai: FileStoreID for BAM index file\n:param str ref: FileStoreID for reference genome fasta file\n:param str ref_dict: FileStoreID for reference sequence dictionary file\n:param str fai: FileStoreID for reference fasta index file\n:param str g1k: FileStoreID for 1000 Genomes VCF file\n:param str mills: FileStoreID for Mills VCF file\n:param str dbsnp: FileStoreID for dbSNP VCF file\n:param bool realign: If True, then runs GATK INDEL realignment\"\n:param bool unsafe: If True, runs GATK tools in UNSAFE mode: \"-U ALLOW_SEQ_DICT_INCOMPATIBILITY\"\n:return: FileStoreIDs for BAM and BAI files\n:rtype: tuple(str, str)", "id": "f3306:m14"}
{"signature": "def run_cutadapt(job, r1_id, r2_id, fwd_3pr_adapter, rev_3pr_adapter):", "body": "work_dir = job.fileStore.getLocalTempDir()<EOL>if r2_id:<EOL><INDENT>require(rev_3pr_adapter, \"<STR_LIT>\")<EOL><DEDENT>parameters = ['<STR_LIT>', fwd_3pr_adapter,<EOL>'<STR_LIT>', '<STR_LIT>']<EOL>if r1_id and r2_id:<EOL><INDENT>job.fileStore.readGlobalFile(r1_id, os.path.join(work_dir, '<STR_LIT>'))<EOL>job.fileStore.readGlobalFile(r2_id, os.path.join(work_dir, '<STR_LIT>'))<EOL>parameters.extend(['<STR_LIT>', rev_3pr_adapter,<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>job.fileStore.readGlobalFile(r1_id, os.path.join(work_dir, '<STR_LIT>'))<EOL>parameters.extend(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL><DEDENT>dockerCall(job=job, tool='<STR_LIT>',<EOL>workDir=work_dir, parameters=parameters)<EOL>if r1_id and r2_id:<EOL><INDENT>r1_cut_id = job.fileStore.writeGlobalFile(os.path.join(work_dir, '<STR_LIT>'))<EOL>r2_cut_id = job.fileStore.writeGlobalFile(os.path.join(work_dir, '<STR_LIT>'))<EOL><DEDENT>else:<EOL><INDENT>r1_cut_id = job.fileStore.writeGlobalFile(os.path.join(work_dir, '<STR_LIT>'))<EOL>r2_cut_id = None<EOL><DEDENT>return r1_cut_id, r2_cut_id<EOL>", "docstring": "Adapter trimming for RNA-seq data\n\n:param JobFunctionWrappingJob job: passed automatically by Toil\n:param str r1_id: FileStoreID of fastq read 1\n:param str r2_id: FileStoreID of fastq read 2 (if paired data)\n:param str fwd_3pr_adapter: Adapter sequence for the forward 3' adapter\n:param str rev_3pr_adapter: Adapter sequence for the reverse 3' adapter (second fastq pair)\n:return: R1 and R2 FileStoreIDs\n:rtype: tuple", "id": "f3306:m0"}
{"signature": "def run_samblaster(job, sam):", "body": "work_dir = job.fileStore.getLocalTempDir()<EOL>job.fileStore.readGlobalFile(sam, os.path.join(work_dir, '<STR_LIT>'))<EOL>command = ['<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>']<EOL>start_time = time.time()<EOL>dockerCall(job=job, workDir=work_dir,<EOL>parameters=command,<EOL>tool='<STR_LIT>')<EOL>end_time = time.time()<EOL>_log_runtime(job, start_time, end_time, \"<STR_LIT>\")<EOL>return job.fileStore.writeGlobalFile(os.path.join(work_dir, '<STR_LIT>'))<EOL>", "docstring": "Marks reads as PCR duplicates using SAMBLASTER\n\n:param JobFunctionWrappingJob job: passed automatically by Toil\n:param str sam: FileStoreID for SAM file\n:return: FileStoreID for deduped SAM file\n:rtype: str", "id": "f3306:m10"}
{"signature": "def run_indel_realignment(job, intervals, bam, bai, ref, ref_dict, fai, g1k, mills, unsafe=False):", "body": "inputs = {'<STR_LIT>': ref,<EOL>'<STR_LIT>': fai,<EOL>'<STR_LIT>': ref_dict,<EOL>'<STR_LIT>': bam,<EOL>'<STR_LIT>': bai,<EOL>'<STR_LIT>': intervals,<EOL>'<STR_LIT>': g1k,<EOL>'<STR_LIT>': mills}<EOL>work_dir = job.fileStore.getLocalTempDir()<EOL>for name, file_store_id in inputs.iteritems():<EOL><INDENT>job.fileStore.readGlobalFile(file_store_id, os.path.join(work_dir, name))<EOL><DEDENT>parameters = ['<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', str(<NUM_LIT>),  <EOL>'<STR_LIT>', str(<NUM_LIT>),  <EOL>'<STR_LIT>', '<STR_LIT>']<EOL>if unsafe:<EOL><INDENT>parameters.extend(['<STR_LIT>', '<STR_LIT>'])<EOL><DEDENT>docker_parameters = ['<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT:none>',<EOL>'<STR_LIT>', '<STR_LIT>'.format(job.memory),<EOL>'<STR_LIT>', '<STR_LIT>'.format(work_dir)]<EOL>start_time = time.time()<EOL>dockerCall(job=job, tool='<STR_LIT>',<EOL>workDir=work_dir,<EOL>parameters=parameters,<EOL>dockerParameters=docker_parameters)<EOL>end_time = time.time()<EOL>_log_runtime(job, start_time, end_time, \"<STR_LIT>\")<EOL>indel_bam = job.fileStore.writeGlobalFile(os.path.join(work_dir, '<STR_LIT>'))<EOL>indel_bai = job.fileStore.writeGlobalFile(os.path.join(work_dir, '<STR_LIT>'))<EOL>return indel_bam, indel_bai<EOL>", "docstring": "Realigns BAM file at realignment target intervals\n\n:param JobFunctionWrappingJob job: passed automatically by Toil\n:param str intervals: FileStoreID for INDEL realignment intervals file\n:param str bam: FileStoreID for BAM file\n:param str bai: FileStoreID for BAM index file\n:param str ref: FileStoreID for reference genome fasta file\n:param str ref_dict: FileStoreID for reference sequence dictionary file\n:param str fai: FileStoreID for reference fasta index file\n:param str g1k: FileStoreID for 1000 Genomes VCF file\n:param str mills: FileStoreID for Mills VCF file\n:param bool unsafe: If True, runs GATK in UNSAFE mode: \"-U ALLOW_SEQ_DICT_INCOMPATIBILITY\"\n:return: FileStoreIDs for realigned BAM and BAI files\n:rtype: tuple(str, str)", "id": "f3306:m16"}
{"signature": "def picard_mark_duplicates(job, bam, bai, validation_stringency='<STR_LIT>'):", "body": "work_dir = job.fileStore.getLocalTempDir()<EOL>job.fileStore.readGlobalFile(bam, os.path.join(work_dir, '<STR_LIT>'))<EOL>job.fileStore.readGlobalFile(bai, os.path.join(work_dir, '<STR_LIT>'))<EOL>command = ['<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % validation_stringency.upper()]<EOL>docker_parameters = ['<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT:none>',<EOL>'<STR_LIT>', '<STR_LIT>'.format(job.memory),<EOL>'<STR_LIT>', '<STR_LIT>'.format(work_dir)]<EOL>start_time = time.time()<EOL>dockerCall(job=job, workDir=work_dir,<EOL>parameters=command,<EOL>tool='<STR_LIT>',<EOL>dockerParameters=docker_parameters)<EOL>end_time = time.time()<EOL>_log_runtime(job, start_time, end_time, \"<STR_LIT>\")<EOL>bam = job.fileStore.writeGlobalFile(os.path.join(work_dir, '<STR_LIT>'))<EOL>bai = job.fileStore.writeGlobalFile(os.path.join(work_dir, '<STR_LIT>'))<EOL>return bam, bai<EOL>", "docstring": "Runs Picard MarkDuplicates on a BAM file. Requires that the BAM file be coordinate sorted.\n\n:param JobFunctionWrappingJob job: passed automatically by Toil\n:param str bam: FileStoreID for BAM file\n:param str bai: FileStoreID for BAM index file\n:param str validation_stringency: BAM file validation stringency, default is LENIENT\n:return: FileStoreIDs for BAM and BAI files\n:rtype: tuple", "id": "f3306:m12"}
{"signature": "def run_rsem_postprocess(job, rsem_gene_id, rsem_isoform_id):", "body": "work_dir = job.fileStore.getLocalTempDir()<EOL>genes = job.fileStore.readGlobalFile(rsem_gene_id, os.path.join(work_dir, '<STR_LIT>'))<EOL>iso = job.fileStore.readGlobalFile(rsem_isoform_id, os.path.join(work_dir, '<STR_LIT>'))<EOL>command = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>dockerCall(job=job, tool='<STR_LIT>',<EOL>parameters=command, workDir=work_dir)<EOL>hugo_files = [os.path.join(work_dir, x) for x in ['<STR_LIT>', '<STR_LIT>']]<EOL>tarball_files('<STR_LIT>', file_paths=[os.path.join(work_dir, x) for x in [genes, iso]], output_dir=work_dir)<EOL>tarball_files('<STR_LIT>', file_paths=[os.path.join(work_dir, x) for x in hugo_files], output_dir=work_dir)<EOL>rsem_id = job.fileStore.writeGlobalFile(os.path.join(work_dir, '<STR_LIT>'))<EOL>hugo_id = job.fileStore.writeGlobalFile(os.path.join(work_dir, '<STR_LIT>'))<EOL>return rsem_id, hugo_id<EOL>", "docstring": "Parses RSEMs output to produce the separate .tab files (TPM, FPKM, counts) for both gene and isoform.\nThese are two-column files: Genes and Quantifications.\nHUGO files are also provided that have been mapped from Gencode/ENSEMBLE names.\n\n:param JobFunctionWrappingJob job: passed automatically by Toil\n:param str rsem_gene_id: FileStoreID of rsem_gene_ids\n:param str rsem_isoform_id: FileStoreID of rsem_isoform_ids\n:return: FileStoreID from RSEM post process tarball\n:rytpe: str", "id": "f3308:m2"}
{"signature": "def run_rsem(job, bam_id, rsem_ref_url, paired=True):", "body": "work_dir = job.fileStore.getLocalTempDir()<EOL>download_url(job, url=rsem_ref_url, name='<STR_LIT>', work_dir=work_dir)<EOL>subprocess.check_call(['<STR_LIT>', '<STR_LIT>', os.path.join(work_dir, '<STR_LIT>'), '<STR_LIT>', work_dir])<EOL>os.remove(os.path.join(work_dir, '<STR_LIT>'))<EOL>rsem_files = []<EOL>for root, directories, files in os.walk(work_dir):<EOL><INDENT>rsem_files.extend([os.path.join(root, x) for x in files])<EOL><DEDENT>ref_prefix = [os.path.basename(os.path.splitext(x)[<NUM_LIT:0>]) for x in rsem_files if '<STR_LIT>' in x][<NUM_LIT:0>]<EOL>ref_folder = os.path.join('<STR_LIT>', os.listdir(work_dir)[<NUM_LIT:0>]) if len(os.listdir(work_dir)) == <NUM_LIT:1> else '<STR_LIT>'<EOL>job.fileStore.readGlobalFile(bam_id, os.path.join(work_dir, '<STR_LIT>'))<EOL>output_prefix = '<STR_LIT>'<EOL>parameters = ['<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>', str(job.cores),<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>os.path.join(ref_folder, ref_prefix),<EOL>output_prefix]<EOL>if paired:<EOL><INDENT>parameters = ['<STR_LIT>'] + parameters<EOL><DEDENT>dockerCall(job=job, tool='<STR_LIT>',<EOL>parameters=parameters, workDir=work_dir)<EOL>gene_id = job.fileStore.writeGlobalFile(os.path.join(work_dir, output_prefix + '<STR_LIT>'))<EOL>isoform_id = job.fileStore.writeGlobalFile(os.path.join(work_dir, output_prefix + '<STR_LIT>'))<EOL>return gene_id, isoform_id<EOL>", "docstring": "RNA quantification with RSEM\n\n:param JobFunctionWrappingJob job: Passed automatically by Toil\n:param str bam_id: FileStoreID of transcriptome bam for quantification\n:param str rsem_ref_url: URL of RSEM reference (tarball)\n:param bool paired: If True, uses parameters for paired end data\n:return: FileStoreIDs for RSEM's gene and isoform output\n:rtype: str", "id": "f3308:m1"}
{"signature": "def run_mutect(job, normal_bam, normal_bai, tumor_bam, tumor_bai, ref, ref_dict, fai, cosmic, dbsnp):", "body": "work_dir = job.fileStore.getLocalTempDir()<EOL>file_ids = [normal_bam, normal_bai, tumor_bam, tumor_bai, ref, fai, ref_dict, cosmic, dbsnp]<EOL>file_names = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>for file_store_id, name in zip(file_ids, file_names):<EOL><INDENT>job.fileStore.readGlobalFile(file_store_id, os.path.join(work_dir, name))<EOL><DEDENT>parameters = ['<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', str(<NUM_LIT:10>),  <EOL>'<STR_LIT>', str(<NUM_LIT>),  <EOL>'<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>']<EOL>dockerCall(job=job, workDir=work_dir, parameters=parameters,<EOL>tool='<STR_LIT>')<EOL>output_file_names = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>output_file_paths = [os.path.join(work_dir, x) for x in output_file_names]<EOL>tarball_files('<STR_LIT>', file_paths=output_file_paths, output_dir=work_dir)<EOL>return job.fileStore.writeGlobalFile(os.path.join(work_dir, '<STR_LIT>'))<EOL>", "docstring": "Calls MuTect to perform variant analysis\n\n:param JobFunctionWrappingJob job: passed automatically by Toil\n:param str normal_bam: Normal BAM FileStoreID\n:param str normal_bai: Normal BAM index FileStoreID\n:param str tumor_bam: Tumor BAM FileStoreID\n:param str tumor_bai: Tumor BAM Index FileStoreID\n:param str ref: Reference genome FileStoreID\n:param str ref_dict: Reference dictionary FileStoreID\n:param str fai: Reference index FileStoreID\n:param str cosmic: Cosmic VCF FileStoreID\n:param str dbsnp: DBSNP VCF FileStoreID\n:return: MuTect output (tarball) FileStoreID\n:rtype: str", "id": "f3312:m0"}
{"signature": "def gatk_combine_variants(job, vcfs, ref_fasta, ref_fai, ref_dict, merge_option='<STR_LIT>'):", "body": "job.fileStore.logToMaster('<STR_LIT>')<EOL>inputs = {'<STR_LIT>': ref_fasta,<EOL>'<STR_LIT>': ref_fai,<EOL>'<STR_LIT>': ref_dict}<EOL>inputs.update(vcfs)<EOL>work_dir = job.fileStore.getLocalTempDir()<EOL>for name, file_store_id in inputs.iteritems():<EOL><INDENT>job.fileStore.readGlobalFile(file_store_id, os.path.join(work_dir, name))<EOL><DEDENT>command = ['<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', merge_option]<EOL>for uuid, vcf_id in vcfs.iteritems():<EOL><INDENT>command.extend(['<STR_LIT>', os.path.join('<STR_LIT>', uuid)])<EOL><DEDENT>docker_parameters = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT:none>',<EOL>'<STR_LIT>', '<STR_LIT>'.format(job.memory)]<EOL>dockerCall(job=job, workDir=work_dir,<EOL>parameters=command,<EOL>tool='<STR_LIT>',<EOL>dockerParameters=docker_parameters)<EOL>return job.fileStore.writeGlobalFile(os.path.join(work_dir, '<STR_LIT>'))<EOL>", "docstring": "Merges VCF files using GATK CombineVariants\n\n:param JobFunctionWrappingJob job: Toil Job instance\n:param dict vcfs: Dictionary of VCF FileStoreIDs {sample identifier: FileStoreID}\n:param str ref_fasta: FileStoreID for reference genome fasta\n:param str ref_fai: FileStoreID for reference genome index file\n:param str ref_dict: FileStoreID for reference genome sequence dictionary file\n:param str merge_option: Value for --genotypemergeoption flag (Default: 'UNIQUIFY')\n                        'UNIQUIFY': Multiple variants at a single site are merged into a\n                                    single variant record.\n                        'UNSORTED': Used to merge VCFs from the same sample\n:return: FileStoreID for merged VCF file\n:rtype: str", "id": "f3313:m4"}
{"signature": "def run_oncotator(job, vcf_id, oncotator_db):", "body": "job.fileStore.logToMaster('<STR_LIT>')<EOL>inputs = {'<STR_LIT>': vcf_id,<EOL>'<STR_LIT>': oncotator_db}<EOL>work_dir = job.fileStore.getLocalTempDir()<EOL>for name, file_store_id in inputs.iteritems():<EOL><INDENT>inputs[name] = job.fileStore.readGlobalFile(file_store_id, os.path.join(work_dir, name))<EOL><DEDENT>if tarfile.is_tarfile(inputs['<STR_LIT>']):<EOL><INDENT>tar = tarfile.open(inputs['<STR_LIT>'])<EOL>tar.extractall(path=work_dir)<EOL>inputs['<STR_LIT>'] = tar.getmembers()[<NUM_LIT:0>].name<EOL>tar.close()<EOL><DEDENT>command = ['<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', inputs['<STR_LIT>'],<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>']  <EOL>docker_parameters = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT:none>',<EOL>'<STR_LIT>', '<STR_LIT>'.format(job.memory)]<EOL>dockerCall(job=job, workDir=work_dir,<EOL>parameters=command,<EOL>tool='<STR_LIT>',<EOL>dockerParameters=docker_parameters)<EOL>return job.fileStore.writeGlobalFile(os.path.join(work_dir, '<STR_LIT>'))<EOL>", "docstring": "Uses Oncotator to add cancer relevant variant annotations to a VCF file. Oncotator can accept\nother genome builds, but the output VCF is based on hg19.\n\n:param JobFunctionWrappingJob job: passed automatically by Toil\n:param str vcf_id: FileStoreID for VCF file\n:param str oncotator_db: FileStoreID for Oncotator database\n:return: Annotated VCF FileStoreID\n:rtype: str", "id": "f3314:m1"}
{"signature": "def copy_files(file_paths, output_dir):", "body": "__forall_files(file_paths, output_dir, shutil.copy)<EOL>", "docstring": "Moves files from the working directory to the output directory.\n\n:param str output_dir: Output directory\n:param list[str] file_paths: Absolute file paths to move", "id": "f3315:m4"}
{"signature": "def __start_datanode(self, job):", "body": "self.hdfsContainerID = dockerCheckOutput(job=job,<EOL>defer=STOP,<EOL>workDir=os.getcwd(),<EOL>tool=\"<STR_LIT>\",<EOL>dockerParameters=[\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\"],<EOL>parameters=[self.masterIP])[:-<NUM_LIT:1>]<EOL>", "docstring": "Launches the Hadoop datanode.\n\n:param job: The underlying job.", "id": "f3325:c1:m2"}
{"signature": "def flatten(x):", "body": "result = []<EOL>for el in x:<EOL><INDENT>if hasattr(el, \"<STR_LIT>\") and not isinstance(el, basestring):<EOL><INDENT>result.extend(flatten(el))<EOL><DEDENT>else:<EOL><INDENT>result.append(el)<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Flattens a nested array into a single list\n\n:param list x: The nested list/tuple to be flattened.", "id": "f3326:m0"}
{"signature": "def required_length(nmin, nmax):", "body": "class RequiredLength(argparse.Action):<EOL><INDENT>def __call__(self, parser, args, values, option_string=None):<EOL><INDENT>if not nmin <= len(values) <= nmax:<EOL><INDENT>msg = '<STR_LIT>'.format(<EOL>f=self.dest, nmin=nmin, nmax=nmax)<EOL>raise argparse.ArgumentTypeError(msg)<EOL><DEDENT>setattr(args, self.dest, values)<EOL><DEDENT><DEDENT>return RequiredLength<EOL>", "docstring": "For use with argparse's action argument. Allows setting a range for nargs.\nExample: nargs='+', action=required_length(2, 3)\n\n:param int nmin: Minimum number of arguments\n:param int nmax: Maximum number of arguments\n:return: RequiredLength object", "id": "f3326:m3"}
{"signature": "def partitions(l, partition_size):", "body": "for i in xrange(<NUM_LIT:0>, len(l), partition_size):<EOL><INDENT>yield l[i:i + partition_size]<EOL><DEDENT>", "docstring": ">>> list(partitions([], 10))\n[]\n>>> list(partitions([1,2,3,4,5], 1))\n[[1], [2], [3], [4], [5]]\n>>> list(partitions([1,2,3,4,5], 2))\n[[1, 2], [3, 4], [5]]\n>>> list(partitions([1,2,3,4,5], 5))\n[[1, 2, 3, 4, 5]]\n\n:param list l: List to be partitioned\n:param int partition_size: Size of partitions", "id": "f3326:m1"}
{"signature": "def download_url(job, url, work_dir='<STR_LIT:.>', name=None, s3_key_path=None, cghub_key_path=None):", "body": "file_path = os.path.join(work_dir, name) if name else os.path.join(work_dir, os.path.basename(url))<EOL>if cghub_key_path:<EOL><INDENT>_download_with_genetorrent(job, url, file_path, cghub_key_path)<EOL><DEDENT>elif urlparse(url).scheme == '<STR_LIT>':<EOL><INDENT>_s3am_with_retry(job, num_cores=<NUM_LIT:1>, file_path=file_path, s3_url=url, mode='<STR_LIT>', s3_key_path=s3_key_path)<EOL><DEDENT>elif urlparse(url).scheme == '<STR_LIT:file>':<EOL><INDENT>shutil.copy(urlparse(url).path, file_path)<EOL><DEDENT>else:<EOL><INDENT>subprocess.check_call(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:5>', '<STR_LIT>', url, '<STR_LIT>', file_path])<EOL><DEDENT>assert os.path.exists(file_path)<EOL>return file_path<EOL>", "docstring": "Downloads URL, can pass in file://, http://, s3://, or ftp://, gnos://cghub/analysisID, or gnos:///analysisID\nIf downloading S3 URLs, the S3AM binary must be on the PATH\n\n:param toil.job.Job job: Toil job that is calling this function\n:param str url: URL to download from\n:param str work_dir: Directory to download file to\n:param str name: Name of output file, if None, basename of URL is used\n:param str s3_key_path: Path to 32-byte encryption key if url points to S3 file that uses SSE-C\n:param str cghub_key_path: Path to cghub key used to download from CGHub.\n:return: Path to the downloaded file\n:rtype: str", "id": "f3327:m0"}
{"signature": "def _get_config_path(self):", "body": "return '<STR_LIT>' % (os.getcwd(), self._name)<EOL>", "docstring": "Returns the path of a pipeline config file, without regard for its existence.", "id": "f3328:c0:m5"}
{"signature": "def _create_pipeline_command(self, args, workdir_path, config_path):", "body": "return ([self._name, '<STR_LIT>', os.path.join(workdir_path, '<STR_LIT>'),<EOL>'<STR_LIT>', config_path,<EOL>'<STR_LIT>', workdir_path, '<STR_LIT>', '<STR_LIT:1>']<EOL>+ (['<STR_LIT>'] if args.restart else []))<EOL>", "docstring": "Creates and returns a list that represents a command for running the pipeline.", "id": "f3328:c0:m9"}
{"signature": "def _add_option(self, arg_parser, name, *args, **kwargs):", "body": "arg_parser.add_argument('<STR_LIT>' + name, *args, **kwargs)<EOL>", "docstring": "Add an argument to the given arg_parser with the given name.\n\n:param argparse.ArgumentParser arg_parser:\n:param str name: The name of the option.", "id": "f3328:c0:m7"}
{"signature": "def __new__(cls, ctx):", "body": "return cls.__run(cls, ctx)<EOL>", "docstring": "Return on call class", "id": "f3335:c0:m0"}
{"signature": "def __init__(self, x=<NUM_LIT:0>, y=<NUM_LIT:0>, z=<NUM_LIT:0>):", "body": "self.x = x<EOL>self.y = y<EOL>self.z = z<EOL>", "docstring": "Create a new Vertex representing the position (x, y, z).", "id": "f3342:c0:m0"}
{"signature": "def sensible_axes(self):", "body": "<EOL>axes = [<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>]<EOL>if self.v0.x == self.v1.x == self.v2.x:<EOL><INDENT>axes[<NUM_LIT:0>] = <NUM_LIT:0><EOL><DEDENT>if self.v0.y == self.v1.y == self.v2.y:<EOL><INDENT>axes[<NUM_LIT:1>] = <NUM_LIT:0><EOL><DEDENT>if self.v0.z == self.v1.z == self.v2.z:<EOL><INDENT>axes[<NUM_LIT:2>] = <NUM_LIT:0><EOL><DEDENT>u = [<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>]<EOL>for i in range(<NUM_LIT:3>):<EOL><INDENT>if axes[i] == <NUM_LIT:1>:<EOL><INDENT>u[i] = <NUM_LIT:1><EOL>axes[i] = <NUM_LIT:0><EOL>break<EOL><DEDENT><DEDENT>v = [<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>]<EOL>for i in range(<NUM_LIT:3>):<EOL><INDENT>if axes[i] == <NUM_LIT:1>:<EOL><INDENT>v[i] = -<NUM_LIT:1><EOL>break<EOL><DEDENT><DEDENT>uaxis = Axis(u[<NUM_LIT:0>], u[<NUM_LIT:1>], u[<NUM_LIT:2>])<EOL>vaxis = Axis(v[<NUM_LIT:0>], v[<NUM_LIT:1>], v[<NUM_LIT:2>])<EOL>return (uaxis, vaxis)<EOL>", "docstring": "Returns a sensible uaxis and vaxis for this plane.", "id": "f3342:c5:m2"}
{"signature": "def top(self):", "body": "return self.brush.children[<NUM_LIT:0>]<EOL>", "docstring": "Returns the top Side of the Block.", "id": "f3345:c0:m4"}
{"signature": "def render(self, template, **kwargs):", "body": "return Template(template).render(RequestContext({}, kwargs)).strip()<EOL>", "docstring": "Return the rendering of a given template", "id": "f3352:c0:m4"}
{"signature": "def add_direction(value, arg=u\"<STR_LIT>\"):", "body": "if arg == u'<STR_LIT>':<EOL><INDENT>directions = (u'<STR_LIT>', u'<STR_LIT>')<EOL><DEDENT>elif arg == u'<STR_LIT>':<EOL><INDENT>directions = (u'<STR_LIT>', u'<STR_LIT>')<EOL><DEDENT>elif arg == u'<STR_LIT>':<EOL><INDENT>directions = (u'<STR_LIT>', u'<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>raise template.TemplateSyntaxError('<STR_LIT>')<EOL><DEDENT>parts = value.rsplit('<STR_LIT:.>', <NUM_LIT:1>)<EOL>if not len(parts):<EOL><INDENT>return value<EOL><DEDENT>elif len(parts) == <NUM_LIT:1>:<EOL><INDENT>return value + directions[translation.get_language_bidi()]<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT:.>'.join((parts[<NUM_LIT:0>]+directions[translation.get_language_bidi()],parts[<NUM_LIT:1>]))<EOL><DEDENT>", "docstring": "Adds direction to the element\n\n    :arguments:\n        arg\n            * rtl_only: Add the direction only in case of a\n              right-to-left language (default)\n            * both: add the direction in both case\n            * ltr_only: Add the direction only in case of a\n              left-to-right language\n\n    {{image_name|add_direction}} when image_name is 'start_arrow.png'\n    results in 'start_arrow_rtl.png' in case of RTL language, and\n    'start_arrow.png' or 'start_arrow_ltr.png' depends on `arg` value.", "id": "f3354:m0"}
{"signature": "def accuracy(output, target, topk=(<NUM_LIT:1>,)):", "body": "with torch.no_grad():<EOL><INDENT>maxk = max(topk)<EOL>batch_size = target.size(<NUM_LIT:0>)<EOL>_, pred = output.topk(maxk, <NUM_LIT:1>, True, True)<EOL>pred = pred.t()<EOL>correct = pred.eq(target[None])<EOL>res = []<EOL>for k in topk:<EOL><INDENT>correct_k = correct[:k].flatten().sum(dtype=torch.float32)<EOL>res.append(correct_k * (<NUM_LIT> / batch_size))<EOL><DEDENT>return res<EOL><DEDENT>", "docstring": "Computes the accuracy over the k top predictions for the specified values of k", "id": "f3361:m0"}
{"signature": "def __call__(self, img):", "body": "i, j, h, w = self.get_params(img, self.scale, self.ratio)<EOL>return F.resized_crop(img, i, j, h, w, self.size, self.interpolation)<EOL>", "docstring": "Args:\n    img (PIL Image): Image to be cropped and resized.\n\nReturns:\n    PIL Image: Randomly cropped and resized image.", "id": "f3371:c17:m2"}
{"signature": "@staticmethod<EOL><INDENT>def get_params(degrees):<DEDENT>", "body": "angle = random.uniform(degrees[<NUM_LIT:0>], degrees[<NUM_LIT:1>])<EOL>return angle<EOL>", "docstring": "Get parameters for ``rotate`` for a random rotation.\n\n        Returns:\n            sequence: params to be passed to ``rotate`` for random rotation.", "id": "f3371:c23:m1"}
{"signature": "def __call__(self, img):", "body": "return F.to_grayscale(img, num_output_channels=self.num_output_channels)<EOL>", "docstring": "Args:\n    img (PIL Image): Image to be converted to grayscale.\n\nReturns:\n    PIL Image: Randomly grayscaled image.", "id": "f3371:c25:m1"}
{"signature": "def __call__(self, pic):", "body": "return F.to_pil_image(pic, self.mode)<EOL>", "docstring": "Args:\n    pic (Tensor or numpy.ndarray): Image to be converted to PIL Image.\n\nReturns:\n    PIL Image: Image converted to PIL Image.", "id": "f3371:c2:m1"}
{"signature": "def __call__(self, img):", "body": "if random.random() < self.p:<EOL><INDENT>return F.hflip(img)<EOL><DEDENT>return img<EOL>", "docstring": "Args:\n    img (PIL Image): Image to be flipped.\n\nReturns:\n    PIL Image: Randomly flipped image.", "id": "f3371:c14:m1"}
{"signature": "@staticmethod<EOL><INDENT>def get_params(width, height, distortion_scale):<DEDENT>", "body": "half_height = int(height / <NUM_LIT:2>)<EOL>half_width = int(width / <NUM_LIT:2>)<EOL>topleft = (random.randint(<NUM_LIT:0>, int(distortion_scale * half_width)),<EOL>random.randint(<NUM_LIT:0>, int(distortion_scale * half_height)))<EOL>topright = (random.randint(width - int(distortion_scale * half_width) - <NUM_LIT:1>, width - <NUM_LIT:1>),<EOL>random.randint(<NUM_LIT:0>, int(distortion_scale * half_height)))<EOL>botright = (random.randint(width - int(distortion_scale * half_width) - <NUM_LIT:1>, width - <NUM_LIT:1>),<EOL>random.randint(height - int(distortion_scale * half_height) - <NUM_LIT:1>, height - <NUM_LIT:1>))<EOL>botleft = (random.randint(<NUM_LIT:0>, int(distortion_scale * half_width)),<EOL>random.randint(height - int(distortion_scale * half_height) - <NUM_LIT:1>, height - <NUM_LIT:1>))<EOL>startpoints = [(<NUM_LIT:0>, <NUM_LIT:0>), (width - <NUM_LIT:1>, <NUM_LIT:0>), (width - <NUM_LIT:1>, height - <NUM_LIT:1>), (<NUM_LIT:0>, height - <NUM_LIT:1>)]<EOL>endpoints = [topleft, topright, botright, botleft]<EOL>return startpoints, endpoints<EOL>", "docstring": "Get parameters for ``perspective`` for a random perspective transform.\n\n        Args:\n            width : width of the image.\n            height : height of the image.\n\n        Returns:\n            List containing [top-left, top-right, bottom-right, bottom-left] of the orignal image,\n            List containing [top-left, top-right, bottom-right, bottom-left] of the transformed image.", "id": "f3371:c16:m2"}
{"signature": "@staticmethod<EOL><INDENT>def get_params(brightness, contrast, saturation, hue):<DEDENT>", "body": "transforms = []<EOL>if brightness is not None:<EOL><INDENT>brightness_factor = random.uniform(brightness[<NUM_LIT:0>], brightness[<NUM_LIT:1>])<EOL>transforms.append(Lambda(lambda img: F.adjust_brightness(img, brightness_factor)))<EOL><DEDENT>if contrast is not None:<EOL><INDENT>contrast_factor = random.uniform(contrast[<NUM_LIT:0>], contrast[<NUM_LIT:1>])<EOL>transforms.append(Lambda(lambda img: F.adjust_contrast(img, contrast_factor)))<EOL><DEDENT>if saturation is not None:<EOL><INDENT>saturation_factor = random.uniform(saturation[<NUM_LIT:0>], saturation[<NUM_LIT:1>])<EOL>transforms.append(Lambda(lambda img: F.adjust_saturation(img, saturation_factor)))<EOL><DEDENT>if hue is not None:<EOL><INDENT>hue_factor = random.uniform(hue[<NUM_LIT:0>], hue[<NUM_LIT:1>])<EOL>transforms.append(Lambda(lambda img: F.adjust_hue(img, hue_factor)))<EOL><DEDENT>random.shuffle(transforms)<EOL>transform = Compose(transforms)<EOL>return transform<EOL>", "docstring": "Get a randomized transform to be applied on image.\n\n        Arguments are same as that of __init__.\n\n        Returns:\n            Transform which randomly adjusts brightness, contrast and\n            saturation in a random order.", "id": "f3371:c22:m2"}
{"signature": "def resize(img, size, interpolation=Image.BILINEAR):", "body": "if not _is_pil_image(img):<EOL><INDENT>raise TypeError('<STR_LIT>'.format(type(img)))<EOL><DEDENT>if not (isinstance(size, int) or (isinstance(size, Iterable) and len(size) == <NUM_LIT:2>)):<EOL><INDENT>raise TypeError('<STR_LIT>'.format(size))<EOL><DEDENT>if isinstance(size, int):<EOL><INDENT>w, h = img.size<EOL>if (w <= h and w == size) or (h <= w and h == size):<EOL><INDENT>return img<EOL><DEDENT>if w < h:<EOL><INDENT>ow = size<EOL>oh = int(size * h / w)<EOL>return img.resize((ow, oh), interpolation)<EOL><DEDENT>else:<EOL><INDENT>oh = size<EOL>ow = int(size * w / h)<EOL>return img.resize((ow, oh), interpolation)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return img.resize(size[::-<NUM_LIT:1>], interpolation)<EOL><DEDENT>", "docstring": "r\"\"\"Resize the input PIL Image to the given size.\n\n    Args:\n        img (PIL Image): Image to be resized.\n        size (sequence or int): Desired output size. If size is a sequence like\n            (h, w), the output size will be matched to this. If size is an int,\n            the smaller edge of the image will be matched to this number maintaing\n            the aspect ratio. i.e, if height > width, then image will be rescaled to\n            :math:`\\left(\\text{size} \\times \\frac{\\text{height}}{\\text{width}}, \\text{size}\\right)`\n        interpolation (int, optional): Desired interpolation. Default is\n            ``PIL.Image.BILINEAR``\n\n    Returns:\n        PIL Image: Resized image.", "id": "f3373:m6"}
{"signature": "def pad(img, padding, fill=<NUM_LIT:0>, padding_mode='<STR_LIT>'):", "body": "if not _is_pil_image(img):<EOL><INDENT>raise TypeError('<STR_LIT>'.format(type(img)))<EOL><DEDENT>if not isinstance(padding, (numbers.Number, tuple)):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if not isinstance(fill, (numbers.Number, str, tuple)):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if not isinstance(padding_mode, str):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if isinstance(padding, Sequence) and len(padding) not in [<NUM_LIT:2>, <NUM_LIT:4>]:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" +<EOL>\"<STR_LIT>\".format(len(padding)))<EOL><DEDENT>assert padding_mode in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'],'<STR_LIT>'<EOL>if padding_mode == '<STR_LIT>':<EOL><INDENT>if img.mode == '<STR_LIT:P>':<EOL><INDENT>palette = img.getpalette()<EOL>image = ImageOps.expand(img, border=padding, fill=fill)<EOL>image.putpalette(palette)<EOL>return image<EOL><DEDENT>return ImageOps.expand(img, border=padding, fill=fill)<EOL><DEDENT>else:<EOL><INDENT>if isinstance(padding, int):<EOL><INDENT>pad_left = pad_right = pad_top = pad_bottom = padding<EOL><DEDENT>if isinstance(padding, Sequence) and len(padding) == <NUM_LIT:2>:<EOL><INDENT>pad_left = pad_right = padding[<NUM_LIT:0>]<EOL>pad_top = pad_bottom = padding[<NUM_LIT:1>]<EOL><DEDENT>if isinstance(padding, Sequence) and len(padding) == <NUM_LIT:4>:<EOL><INDENT>pad_left = padding[<NUM_LIT:0>]<EOL>pad_top = padding[<NUM_LIT:1>]<EOL>pad_right = padding[<NUM_LIT:2>]<EOL>pad_bottom = padding[<NUM_LIT:3>]<EOL><DEDENT>if img.mode == '<STR_LIT:P>':<EOL><INDENT>palette = img.getpalette()<EOL>img = np.asarray(img)<EOL>img = np.pad(img, ((pad_top, pad_bottom), (pad_left, pad_right)), padding_mode)<EOL>img = Image.fromarray(img)<EOL>img.putpalette(palette)<EOL>return img<EOL><DEDENT>img = np.asarray(img)<EOL>if len(img.shape) == <NUM_LIT:3>:<EOL><INDENT>img = np.pad(img, ((pad_top, pad_bottom), (pad_left, pad_right), (<NUM_LIT:0>, <NUM_LIT:0>)), padding_mode)<EOL><DEDENT>if len(img.shape) == <NUM_LIT:2>:<EOL><INDENT>img = np.pad(img, ((pad_top, pad_bottom), (pad_left, pad_right)), padding_mode)<EOL><DEDENT>return Image.fromarray(img)<EOL><DEDENT>", "docstring": "r\"\"\"Pad the given PIL Image on all sides with specified padding mode and fill value.\n\n    Args:\n        img (PIL Image): Image to be padded.\n        padding (int or tuple): Padding on each border. If a single int is provided this\n            is used to pad all borders. If tuple of length 2 is provided this is the padding\n            on left/right and top/bottom respectively. If a tuple of length 4 is provided\n            this is the padding for the left, top, right and bottom borders\n            respectively.\n        fill: Pixel fill value for constant fill. Default is 0. If a tuple of\n            length 3, it is used to fill R, G, B channels respectively.\n            This value is only used when the padding_mode is constant\n        padding_mode: Type of padding. Should be: constant, edge, reflect or symmetric. Default is constant.\n\n            - constant: pads with a constant value, this value is specified with fill\n\n            - edge: pads with the last value on the edge of the image\n\n            - reflect: pads with reflection of image (without repeating the last value on the edge)\n\n                       padding [1, 2, 3, 4] with 2 elements on both sides in reflect mode\n                       will result in [3, 2, 1, 2, 3, 4, 3, 2]\n\n            - symmetric: pads with reflection of image (repeating the last value on the edge)\n\n                         padding [1, 2, 3, 4] with 2 elements on both sides in symmetric mode\n                         will result in [2, 1, 1, 2, 3, 4, 4, 3]\n\n    Returns:\n        PIL Image: Padded image.", "id": "f3373:m8"}
{"signature": "def five_crop(img, size):", "body": "if isinstance(size, numbers.Number):<EOL><INDENT>size = (int(size), int(size))<EOL><DEDENT>else:<EOL><INDENT>assert len(size) == <NUM_LIT:2>, \"<STR_LIT>\"<EOL><DEDENT>w, h = img.size<EOL>crop_h, crop_w = size<EOL>if crop_w > w or crop_h > h:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(size,<EOL>(h, w)))<EOL><DEDENT>tl = img.crop((<NUM_LIT:0>, <NUM_LIT:0>, crop_w, crop_h))<EOL>tr = img.crop((w - crop_w, <NUM_LIT:0>, w, crop_h))<EOL>bl = img.crop((<NUM_LIT:0>, h - crop_h, crop_w, h))<EOL>br = img.crop((w - crop_w, h - crop_h, w, h))<EOL>center = center_crop(img, (crop_h, crop_w))<EOL>return (tl, tr, bl, br, center)<EOL>", "docstring": "Crop the given PIL Image into four corners and the central crop.\n\n    .. Note::\n        This transform returns a tuple of images and there may be a\n        mismatch in the number of inputs and targets your ``Dataset`` returns.\n\n    Args:\n       size (sequence or int): Desired output size of the crop. If size is an\n           int instead of sequence like (h, w), a square crop (size, size) is\n           made.\n\n    Returns:\n       tuple: tuple (tl, tr, bl, br, center)\n                Corresponding top left, top right, bottom left, bottom right and center crop.", "id": "f3373:m16"}
{"signature": "def resized_crop(img, i, j, h, w, size, interpolation=Image.BILINEAR):", "body": "assert _is_pil_image(img), '<STR_LIT>'<EOL>img = crop(img, i, j, h, w)<EOL>img = resize(img, size, interpolation)<EOL>return img<EOL>", "docstring": "Crop the given PIL Image and resize it to desired size.\n\n    Notably used in :class:`~torchvision.transforms.RandomResizedCrop`.\n\n    Args:\n        img (PIL Image): Image to be cropped.\n        i (int): i in (i,j) i.e coordinates of the upper left corner\n        j (int): j in (i,j) i.e coordinates of the upper left corner\n        h (int): Height of the cropped image.\n        w (int): Width of the cropped image.\n        size (sequence or int): Desired output size. Same semantics as ``resize``.\n        interpolation (int, optional): Desired interpolation. Default is\n            ``PIL.Image.BILINEAR``.\n    Returns:\n        PIL Image: Cropped image.", "id": "f3373:m11"}
{"signature": "def adjust_saturation(img, saturation_factor):", "body": "if not _is_pil_image(img):<EOL><INDENT>raise TypeError('<STR_LIT>'.format(type(img)))<EOL><DEDENT>enhancer = ImageEnhance.Color(img)<EOL>img = enhancer.enhance(saturation_factor)<EOL>return img<EOL>", "docstring": "Adjust color saturation of an image.\n\n    Args:\n        img (PIL Image): PIL Image to be adjusted.\n        saturation_factor (float):  How much to adjust the saturation. 0 will\n            give a black and white image, 1 will give the original image while\n            2 will enhance the saturation by a factor of 2.\n\n    Returns:\n        PIL Image: Saturation adjusted image.", "id": "f3373:m20"}
{"signature": "def to_pil_image(pic, mode=None):", "body": "if not(isinstance(pic, torch.Tensor) or isinstance(pic, np.ndarray)):<EOL><INDENT>raise TypeError('<STR_LIT>'.format(type(pic)))<EOL><DEDENT>elif isinstance(pic, torch.Tensor):<EOL><INDENT>if pic.ndimension() not in {<NUM_LIT:2>, <NUM_LIT:3>}:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(pic.ndimension()))<EOL><DEDENT>elif pic.ndimension() == <NUM_LIT:2>:<EOL><INDENT>pic = pic.unsqueeze(<NUM_LIT:0>)<EOL><DEDENT><DEDENT>elif isinstance(pic, np.ndarray):<EOL><INDENT>if pic.ndim not in {<NUM_LIT:2>, <NUM_LIT:3>}:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(pic.ndim))<EOL><DEDENT>elif pic.ndim == <NUM_LIT:2>:<EOL><INDENT>pic = np.expand_dims(pic, <NUM_LIT:2>)<EOL><DEDENT><DEDENT>npimg = pic<EOL>if isinstance(pic, torch.FloatTensor):<EOL><INDENT>pic = pic.mul(<NUM_LIT:255>).byte()<EOL><DEDENT>if isinstance(pic, torch.Tensor):<EOL><INDENT>npimg = np.transpose(pic.numpy(), (<NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:0>))<EOL><DEDENT>if not isinstance(npimg, np.ndarray):<EOL><INDENT>raise TypeError('<STR_LIT>' +<EOL>'<STR_LIT>'.format(type(npimg)))<EOL><DEDENT>if npimg.shape[<NUM_LIT:2>] == <NUM_LIT:1>:<EOL><INDENT>expected_mode = None<EOL>npimg = npimg[:, :, <NUM_LIT:0>]<EOL>if npimg.dtype == np.uint8:<EOL><INDENT>expected_mode = '<STR_LIT:L>'<EOL><DEDENT>elif npimg.dtype == np.int16:<EOL><INDENT>expected_mode = '<STR_LIT>'<EOL><DEDENT>elif npimg.dtype == np.int32:<EOL><INDENT>expected_mode = '<STR_LIT:I>'<EOL><DEDENT>elif npimg.dtype == np.float32:<EOL><INDENT>expected_mode = '<STR_LIT:F>'<EOL><DEDENT>if mode is not None and mode != expected_mode:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>.format(mode, np.dtype, expected_mode))<EOL><DEDENT>mode = expected_mode<EOL><DEDENT>elif npimg.shape[<NUM_LIT:2>] == <NUM_LIT:2>:<EOL><INDENT>permitted_2_channel_modes = ['<STR_LIT>']<EOL>if mode is not None and mode not in permitted_2_channel_modes:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(permitted_2_channel_modes))<EOL><DEDENT>if mode is None and npimg.dtype == np.uint8:<EOL><INDENT>mode = '<STR_LIT>'<EOL><DEDENT><DEDENT>elif npimg.shape[<NUM_LIT:2>] == <NUM_LIT:4>:<EOL><INDENT>permitted_4_channel_modes = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>if mode is not None and mode not in permitted_4_channel_modes:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(permitted_4_channel_modes))<EOL><DEDENT>if mode is None and npimg.dtype == np.uint8:<EOL><INDENT>mode = '<STR_LIT>'<EOL><DEDENT><DEDENT>else:<EOL><INDENT>permitted_3_channel_modes = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>if mode is not None and mode not in permitted_3_channel_modes:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(permitted_3_channel_modes))<EOL><DEDENT>if mode is None and npimg.dtype == np.uint8:<EOL><INDENT>mode = '<STR_LIT>'<EOL><DEDENT><DEDENT>if mode is None:<EOL><INDENT>raise TypeError('<STR_LIT>'.format(npimg.dtype))<EOL><DEDENT>return Image.fromarray(npimg, mode=mode)<EOL>", "docstring": "Convert a tensor or an ndarray to PIL Image.\n\n    See :class:`~torchvision.transforms.ToPILImage` for more details.\n\n    Args:\n        pic (Tensor or numpy.ndarray): Image to be converted to PIL Image.\n        mode (`PIL.Image mode`_): color space and pixel depth of input data (optional).\n\n    .. _PIL.Image mode: https://pillow.readthedocs.io/en/latest/handbook/concepts.html#concept-modes\n\n    Returns:\n        PIL Image: Image converted to PIL Image.", "id": "f3373:m4"}
{"signature": "def to_grayscale(img, num_output_channels=<NUM_LIT:1>):", "body": "if not _is_pil_image(img):<EOL><INDENT>raise TypeError('<STR_LIT>'.format(type(img)))<EOL><DEDENT>if num_output_channels == <NUM_LIT:1>:<EOL><INDENT>img = img.convert('<STR_LIT:L>')<EOL><DEDENT>elif num_output_channels == <NUM_LIT:3>:<EOL><INDENT>img = img.convert('<STR_LIT:L>')<EOL>np_img = np.array(img, dtype=np.uint8)<EOL>np_img = np.dstack([np_img, np_img, np_img])<EOL>img = Image.fromarray(np_img, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return img<EOL>", "docstring": "Convert image to grayscale version of image.\n\n    Args:\n        img (PIL Image): Image to be converted to grayscale.\n\n    Returns:\n        PIL Image: Grayscale version of the image.\n            if num_output_channels = 1 : returned image is single channel\n\n            if num_output_channels = 3 : returned image is 3 channel with r = g = b", "id": "f3373:m26"}
{"signature": "def conv3x3(in_planes, out_planes, stride=<NUM_LIT:1>, groups=<NUM_LIT:1>, dilation=<NUM_LIT:1>):", "body": "return nn.Conv2d(in_planes, out_planes, kernel_size=<NUM_LIT:3>, stride=stride,<EOL>padding=dilation, groups=groups, bias=False, dilation=dilation)<EOL>", "docstring": "3x3 convolution with padding", "id": "f3378:m0"}
{"signature": "def alexnet(pretrained=False, **kwargs):", "body": "model = AlexNet(**kwargs)<EOL>if pretrained:<EOL><INDENT>model.load_state_dict(model_zoo.load_url(model_urls['<STR_LIT>']))<EOL><DEDENT>return model<EOL>", "docstring": "r\"\"\"AlexNet model architecture from the\n    `\"One weird trick...\" <https://arxiv.org/abs/1404.5997>`_ paper.\n\n    Args:\n        pretrained (bool): If True, returns a model pre-trained on ImageNet", "id": "f3380:m0"}
{"signature": "def vgg16(pretrained=False, **kwargs):", "body": "if pretrained:<EOL><INDENT>kwargs['<STR_LIT>'] = False<EOL><DEDENT>model = VGG(make_layers(cfg['<STR_LIT:D>']), **kwargs)<EOL>if pretrained:<EOL><INDENT>model.load_state_dict(model_zoo.load_url(model_urls['<STR_LIT>']))<EOL><DEDENT>return model<EOL>", "docstring": "VGG 16-layer model (configuration \"D\")\n\n    Args:\n        pretrained (bool): If True, returns a model pre-trained on ImageNet", "id": "f3381:m5"}
{"signature": "def vgg13_bn(pretrained=False, **kwargs):", "body": "if pretrained:<EOL><INDENT>kwargs['<STR_LIT>'] = False<EOL><DEDENT>model = VGG(make_layers(cfg['<STR_LIT:B>'], batch_norm=True), **kwargs)<EOL>if pretrained:<EOL><INDENT>model.load_state_dict(model_zoo.load_url(model_urls['<STR_LIT>']))<EOL><DEDENT>return model<EOL>", "docstring": "VGG 13-layer model (configuration \"B\") with batch normalization\n\n    Args:\n        pretrained (bool): If True, returns a model pre-trained on ImageNet", "id": "f3381:m4"}
{"signature": "def vgg13(pretrained=False, **kwargs):", "body": "if pretrained:<EOL><INDENT>kwargs['<STR_LIT>'] = False<EOL><DEDENT>model = VGG(make_layers(cfg['<STR_LIT:B>']), **kwargs)<EOL>if pretrained:<EOL><INDENT>model.load_state_dict(model_zoo.load_url(model_urls['<STR_LIT>']))<EOL><DEDENT>return model<EOL>", "docstring": "VGG 13-layer model (configuration \"B\")\n\n    Args:\n        pretrained (bool): If True, returns a model pre-trained on ImageNet", "id": "f3381:m3"}
{"signature": "def densenet161(pretrained=False, **kwargs):", "body": "model = DenseNet(num_init_features=<NUM_LIT>, growth_rate=<NUM_LIT>, block_config=(<NUM_LIT:6>, <NUM_LIT:12>, <NUM_LIT>, <NUM_LIT>),<EOL>**kwargs)<EOL>if pretrained:<EOL><INDENT>_load_state_dict(model, model_urls['<STR_LIT>'])<EOL><DEDENT>return model<EOL>", "docstring": "r\"\"\"Densenet-161 model from\n    `\"Densely Connected Convolutional Networks\" <https://arxiv.org/pdf/1608.06993.pdf>`_\n\n    Args:\n        pretrained (bool): If True, returns a model pre-trained on ImageNet", "id": "f3382:m4"}
{"signature": "def read_matches_files(data_dir, matches_file):", "body": "matches = []<EOL>with open(os.path.join(data_dir, matches_file), '<STR_LIT:r>') as f:<EOL><INDENT>for line in f:<EOL><INDENT>line_split = line.split()<EOL>matches.append([int(line_split[<NUM_LIT:0>]), int(line_split[<NUM_LIT:3>]),<EOL>int(line_split[<NUM_LIT:1>] == line_split[<NUM_LIT:4>])])<EOL><DEDENT><DEDENT>return torch.LongTensor(matches)<EOL>", "docstring": "Return a Tensor containing the ground truth matches\n       Read the file and keep only 3D point ID.\n       Matches are represented with a 1, non matches with a 0.", "id": "f3391:m2"}
{"signature": "def __getitem__(self, index):", "body": "if self.train:<EOL><INDENT>data = self.data[index]<EOL>if self.transform is not None:<EOL><INDENT>data = self.transform(data)<EOL><DEDENT>return data<EOL><DEDENT>m = self.matches[index]<EOL>data1, data2 = self.data[m[<NUM_LIT:0>]], self.data[m[<NUM_LIT:1>]]<EOL>if self.transform is not None:<EOL><INDENT>data1 = self.transform(data1)<EOL>data2 = self.transform(data2)<EOL><DEDENT>return data1, data2, m[<NUM_LIT:2>]<EOL>", "docstring": "Args:\n    index (int): Index\n\nReturns:\n    tuple: (data1, data2, matches)", "id": "f3391:c0:m1"}
{"signature": "def read_info_file(data_dir, info_file):", "body": "labels = []<EOL>with open(os.path.join(data_dir, info_file), '<STR_LIT:r>') as f:<EOL><INDENT>labels = [int(line.split()[<NUM_LIT:0>]) for line in f]<EOL><DEDENT>return torch.LongTensor(labels)<EOL>", "docstring": "Return a Tensor containing the list of labels\n       Read the file and keep only the ID of the 3D point.", "id": "f3391:m1"}
{"signature": "def __getitem__(self, index):", "body": "if self.labels is not None:<EOL><INDENT>img, target = self.data[index], int(self.labels[index])<EOL><DEDENT>else:<EOL><INDENT>img, target = self.data[index], None<EOL><DEDENT>img = Image.fromarray(np.transpose(img, (<NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:0>)))<EOL>if self.transform is not None:<EOL><INDENT>img = self.transform(img)<EOL><DEDENT>if self.target_transform is not None:<EOL><INDENT>target = self.target_transform(target)<EOL><DEDENT>return img, target<EOL>", "docstring": "Args:\n    index (int): Index\n\nReturns:\n    tuple: (image, target) where target is index of the target class.", "id": "f3393:c0:m1"}
{"signature": "def _check_integrity(self):", "body": "root = self.root<EOL>fpath = os.path.join(root, self.filename)<EOL>if not check_integrity(fpath, self.md5_checksum):<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "Check the md5 checksum of the downloaded tarball.", "id": "f3399:c0:m3"}
{"signature": "def __len__(self):", "body": "return len(self.photos)<EOL>", "docstring": "The number of photos in the dataset.", "id": "f3399:c0:m2"}
{"signature": "def download(self):", "body": "import tarfile<EOL>if self._check_integrity():<EOL><INDENT>print('<STR_LIT>')<EOL>return<EOL><DEDENT>download_url(self.url, self.root, self.filename, self.md5_checksum)<EOL>with tarfile.open(os.path.join(self.root, self.filename), '<STR_LIT>') as tar:<EOL><INDENT>tar.extractall(path=self.root)<EOL><DEDENT>with open(os.path.join(self.root, '<STR_LIT>', '<STR_LIT>')) as fh:<EOL><INDENT>for line in fh:<EOL><INDENT>url = line.rstrip()<EOL>try:<EOL><INDENT>download_url(url, os.path.join(self.root, '<STR_LIT>'))<EOL><DEDENT>except OSError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Download and extract the tarball, and download each individual photo.", "id": "f3399:c0:m4"}
{"signature": "def list_files(root, suffix, prefix=False):", "body": "root = os.path.expanduser(root)<EOL>files = list(<EOL>filter(<EOL>lambda p: os.path.isfile(os.path.join(root, p)) and p.endswith(suffix),<EOL>os.listdir(root)<EOL>)<EOL>)<EOL>if prefix is True:<EOL><INDENT>files = [os.path.join(root, d) for d in files]<EOL><DEDENT>return files<EOL>", "docstring": "List all files ending with a suffix at a given root\n\n    Args:\n        root (str): Path to directory whose folders need to be listed\n        suffix (str or tuple): Suffix of the files to match, e.g. '.png' or ('.jpg', '.png').\n            It uses the Python \"str.endswith\" method and is passed directly\n        prefix (bool, optional): If true, prepends the path to each result, otherwise\n            only returns the name of the files found", "id": "f3400:m7"}
{"signature": "def list_dir(root, prefix=False):", "body": "root = os.path.expanduser(root)<EOL>directories = list(<EOL>filter(<EOL>lambda p: os.path.isdir(os.path.join(root, p)),<EOL>os.listdir(root)<EOL>)<EOL>)<EOL>if prefix is True:<EOL><INDENT>directories = [os.path.join(root, d) for d in directories]<EOL><DEDENT>return directories<EOL>", "docstring": "List all directories at a given root\n\n    Args:\n        root (str): Path to directory whose folders need to be listed\n        prefix (bool, optional): If true, prepends the path to each result, otherwise\n            only returns the name of the directories found", "id": "f3400:m6"}
{"signature": "def download_file_from_google_drive(file_id, root, filename=None, md5=None):", "body": "<EOL>import requests<EOL>url = \"<STR_LIT>\"<EOL>root = os.path.expanduser(root)<EOL>if not filename:<EOL><INDENT>filename = file_id<EOL><DEDENT>fpath = os.path.join(root, filename)<EOL>makedir_exist_ok(root)<EOL>if os.path.isfile(fpath) and check_integrity(fpath, md5):<EOL><INDENT>print('<STR_LIT>' + fpath)<EOL><DEDENT>else:<EOL><INDENT>session = requests.Session()<EOL>response = session.get(url, params={'<STR_LIT:id>': file_id}, stream=True)<EOL>token = _get_confirm_token(response)<EOL>if token:<EOL><INDENT>params = {'<STR_LIT:id>': file_id, '<STR_LIT>': token}<EOL>response = session.get(url, params=params, stream=True)<EOL><DEDENT>_save_response_content(response, fpath)<EOL><DEDENT>", "docstring": "Download a Google Drive file from  and place it in root.\n\n    Args:\n        file_id (str): id of file to be downloaded\n        root (str): Directory to place downloaded file in\n        filename (str, optional): Name to save the file under. If None, use the id of the file.\n        md5 (str, optional): MD5 checksum of the download. If None, do not check", "id": "f3400:m8"}
{"signature": "def download_url(url, root, filename=None, md5=None):", "body": "from six.moves import urllib<EOL>root = os.path.expanduser(root)<EOL>if not filename:<EOL><INDENT>filename = os.path.basename(url)<EOL><DEDENT>fpath = os.path.join(root, filename)<EOL>makedir_exist_ok(root)<EOL>if os.path.isfile(fpath) and check_integrity(fpath, md5):<EOL><INDENT>print('<STR_LIT>' + fpath)<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>print('<STR_LIT>' + url + '<STR_LIT>' + fpath)<EOL>urllib.request.urlretrieve(<EOL>url, fpath,<EOL>reporthook=gen_bar_updater()<EOL>)<EOL><DEDENT>except OSError:<EOL><INDENT>if url[:<NUM_LIT:5>] == '<STR_LIT>':<EOL><INDENT>url = url.replace('<STR_LIT>', '<STR_LIT>')<EOL>print('<STR_LIT>'<EOL>'<STR_LIT>' + url + '<STR_LIT>' + fpath)<EOL>urllib.request.urlretrieve(<EOL>url, fpath,<EOL>reporthook=gen_bar_updater()<EOL>)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Download a file from a url and place it in root.\n\n    Args:\n        url (str): URL to download file from\n        root (str): Directory to place downloaded file in\n        filename (str, optional): Name to save the file under. If None, use the basename of the URL\n        md5 (str, optional): MD5 checksum of the download. If None, do not check", "id": "f3400:m5"}
{"signature": "def __getitem__(self, index):", "body": "path, target = self.samples[index]<EOL>sample = self.loader(path)<EOL>if self.transform is not None:<EOL><INDENT>sample = self.transform(sample)<EOL><DEDENT>if self.target_transform is not None:<EOL><INDENT>target = self.target_transform(target)<EOL><DEDENT>return sample, target<EOL>", "docstring": "Args:\n    index (int): Index\n\nReturns:\n    tuple: (sample, target) where target is class_index of the target class.", "id": "f3402:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def from_str(cls, human_readable_str, decimal=False, bits=False):<DEDENT>", "body": "divisor = <NUM_LIT:1000> if decimal else <NUM_LIT><EOL>num = []<EOL>c = \"<STR_LIT>\"<EOL>for c in human_readable_str:<EOL><INDENT>if c not in cls.digits:<EOL><INDENT>break<EOL><DEDENT>num.append(c)<EOL><DEDENT>num = \"<STR_LIT>\".join(num)<EOL>try:<EOL><INDENT>num = int(num)<EOL><DEDENT>except ValueError:<EOL><INDENT>num = float(num)<EOL><DEDENT>if bits:<EOL><INDENT>num /= <NUM_LIT:8><EOL><DEDENT>return cls(round(num * divisor ** cls.key[c.lower()]))<EOL>", "docstring": "attempt to parse a size in bytes from a human-readable string.", "id": "f3408:c2:m3"}
{"signature": "def deepupdate(<EOL>mapping: abc.MutableMapping, other: abc.Mapping, listextend=False<EOL>):", "body": "def inner(other, previouskeys):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>for key, value in other.items():<EOL><INDENT>if isinstance(value, abc.Mapping):<EOL><INDENT>inner(value, (*previouskeys, key))<EOL><DEDENT>else:<EOL><INDENT>node = mapping<EOL>for previouskey in previouskeys:<EOL><INDENT>node = node.setdefault(previouskey, {})<EOL><DEDENT>target = node.get(key)<EOL>if (<EOL>listextend<EOL>and isinstance(target, abc.MutableSequence)<EOL>and isinstance(value, abc.Sequence)<EOL>):<EOL><INDENT>target.extend(value)<EOL><DEDENT>else:<EOL><INDENT>node[key] = value<EOL><DEDENT><DEDENT><DEDENT><DEDENT>inner(other, ())<EOL>", "docstring": "update one dictionary from another recursively. Only individual\n    values will be overwritten--not entire branches of nested\n    dictionaries.", "id": "f3408:m6"}
{"signature": "@register.simple_tag<EOL>@silence_without_namespace<EOL>def project_home_url(*args):", "body": "url = home_url()<EOL>if url:<EOL><INDENT>return url<EOL><DEDENT>", "docstring": "A template tag to return the project's home URL.\n\n    PROJECT_HOME_NAMESPACE must be defined in settings.\n    For example:\n        PROJECT_HOME_NAMESPACE = 'project_name:index_view'\n\n    Usage Example:\n        {% load project_home_tags %}\n\n        <a href=\"{% project_home_url %}\">Home</a>", "id": "f3411:m2"}
{"signature": "def _refresh_access_token(self):", "body": "resource = \"<STR_LIT>\"<EOL>fields = dict(grant_type=\"<STR_LIT>\", refresh_token=self.refresh_token,<EOL>client_id=self.auth.client_id, client_secret=self.auth.client_secret,<EOL>format=\"<STR_LIT>\")<EOL>status, data = self._handle_response(\"<STR_LIT:POST>\", resource, fields=fields, <EOL>refresh_access_token=False)<EOL>if \"<STR_LIT>\" in data:<EOL><INDENT>self.access_token = data[\"<STR_LIT>\"]<EOL>if callable(self.access_token_refreshed_callback):<EOL><INDENT>self.access_token_refreshed_callback(self.access_token)<EOL><DEDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "If the client application has a refresh token, it can use it to send a request for a new access token. \n\nTo ask for a new access token, the client application should send a POST request to https://login.instance_name/services/oauth2/token with the following query parameters:\n\n    grant_type:     Value must be refresh_token for this flow.\n    refresh_token:  The refresh token the client application already received. \n    client_id:      Consumer key from the remote access application definition.\n    client_secret:  Consumer secret from the remote access application definition.\n    format:         Expected return format. This parameter is optional. The default is json. Values are:\n\n        * urlencoded\n        * json\n        * xml\n\ne.g.\n\n    $ curl -i --form grant_type=refresh_token \\\n        --form refresh_token=<refresh_token> \\\n        --form client_id=<client_id> \\\n        --form client_secret=<client_secret> \\\n        --form format=json \\\n        https://na1.salesforce.com/services/oauth2/token", "id": "f3414:c1:m6"}
{"signature": "def _put_information(self):", "body": "self.session._add_object()<EOL>self.session._out('<STR_LIT>')<EOL>self.session._out('<STR_LIT>' + self._text_to_string(<EOL>'<STR_LIT>'))<EOL>if self.title:<EOL><INDENT>self.session._out('<STR_LIT>' + self._text_to_string(self.title))<EOL><DEDENT>if self.subject:<EOL><INDENT>self.session._out('<STR_LIT>' + self._text_to_string(self.subject))<EOL><DEDENT>if self.author:<EOL><INDENT>self.session._out('<STR_LIT>' + self._text_to_string(self.author))<EOL><DEDENT>if self.keywords:<EOL><INDENT>self.session._out('<STR_LIT>' +<EOL>self._text_to_string(self.keywords))<EOL><DEDENT>if self.creator:<EOL><INDENT>self.session._out('<STR_LIT>' + self._text_to_string(self.creator))<EOL><DEDENT>self.session._out('<STR_LIT>' + self._text_to_string(<EOL>'<STR_LIT>' + datetime.now().strftime('<STR_LIT>')))<EOL>self.session._out('<STR_LIT>')<EOL>self.session._out('<STR_LIT>')<EOL>", "docstring": "PDF Information object.", "id": "f3453:c0:m12"}
{"signature": "def _put_trailer(self):", "body": "startxref = len(self.session.buffer)<EOL>self._put_cross_reference()<EOL>md5 = hashlib.md5()<EOL>md5.update(datetime.now().strftime('<STR_LIT>'))<EOL>try:<EOL><INDENT>md5.update(self.filepath)<EOL><DEDENT>except TypeError:<EOL><INDENT>pass<EOL><DEDENT>if self.title:<EOL><INDENT>md5.update(self.title)<EOL><DEDENT>if self.subject:<EOL><INDENT>md5.update(self.subject)<EOL><DEDENT>if self.author:<EOL><INDENT>md5.update(self.author)<EOL><DEDENT>if self.keywords:<EOL><INDENT>md5.update(self.keywords)<EOL><DEDENT>if self.creator:<EOL><INDENT>md5.update(self.creator)<EOL><DEDENT>objnum = len(self.session.objects)<EOL>self.session._out('<STR_LIT>')<EOL>self.session._out('<STR_LIT>')<EOL>self.session._out('<STR_LIT>' % objnum)<EOL>self.session._out('<STR_LIT>' % (objnum - <NUM_LIT:1>))<EOL>self.session._out('<STR_LIT>' % (objnum - <NUM_LIT:2>))<EOL>self.session._out('<STR_LIT>' % (md5.hexdigest(),md5.hexdigest()))<EOL>self.session._out('<STR_LIT>')<EOL>self.session._out('<STR_LIT>')<EOL>self.session._out(startxref)<EOL>self.session._out('<STR_LIT>')<EOL>", "docstring": "Final Trailer calculations, and end-of-file\n            reference.", "id": "f3453:c0:m15"}
{"signature": "def _put_resource_dict(self):", "body": "self.session._add_object(<NUM_LIT:2>)<EOL>self.session._out('<STR_LIT>')<EOL>self.session._out('<STR_LIT>')<EOL>self.session._out('<STR_LIT>')<EOL>for font in self.document.fonts:<EOL><INDENT>self.session._out('<STR_LIT>' % (font.index, font.number))<EOL><DEDENT>self.session._out('<STR_LIT>')<EOL>if self.document.images:<EOL><INDENT>self.session._out('<STR_LIT>')<EOL>for image in self.document.images:<EOL><INDENT>self.session._out('<STR_LIT>' % (image.index, image.number))<EOL><DEDENT>self.session._out('<STR_LIT>')<EOL><DEDENT>self.session._out('<STR_LIT>')<EOL>self.session._out('<STR_LIT>')<EOL>", "docstring": "Creates PDF reference to resource objects.", "id": "f3453:c0:m11"}
{"signature": "def set_display_mode(self, zoom='<STR_LIT>', layout='<STR_LIT>'):", "body": "self.zoom_options = [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT:default>\"]<EOL>self.layout_options = [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT:default>\"]<EOL>if zoom in self.zoom_options or (isinstance(zoom, int) and <NUM_LIT:0> < zoom <= <NUM_LIT:100>):<EOL><INDENT>self.zoom_mode = zoom<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>' + zoom)<EOL><DEDENT>if layout in self.layout_options:<EOL><INDENT>self.layout_mode = layout<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>' + layout)<EOL><DEDENT>", "docstring": "Set the default viewing options.", "id": "f3453:c0:m4"}
{"signature": "def add_page(self, page=None):", "body": "if page is None:<EOL><INDENT>self.page = PDFPage(self.orientation_default, self.layout_default, self.margins)<EOL><DEDENT>else:<EOL><INDENT>self.page = page<EOL><DEDENT>self.page._set_index(len(self.pages))<EOL>self.pages.append(self.page)<EOL>currentfont = self.font<EOL>self.set_font(font=currentfont)<EOL>self.session._reset_colors()<EOL>", "docstring": "May generate and add a PDFPage separately, or use this to generate\n            a default page.", "id": "f3454:c0:m8"}
{"signature": "def get_page(self):", "body": "return self.page<EOL>", "docstring": "Returns reference to current page object.", "id": "f3454:c0:m9"}
{"signature": "def _get_orientation_changes(self):", "body": "self.orientation_changes = []<EOL>for page in self.pages:<EOL><INDENT>if page.orientation_change is True:<EOL><INDENT>self.orientation_changes.append(page.index)<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return self.orientation_changes<EOL>", "docstring": "Returns a list of the pages that have\n            orientation changes.", "id": "f3454:c0:m64"}
{"signature": "def _set_index(self, index=<NUM_LIT:1>):", "body": "self.index = index<EOL>", "docstring": "Image number", "id": "f3463:c0:m2"}
{"signature": "@property<EOL><INDENT>def x_left(self):<DEDENT>", "body": "return self.xmax - self.x<EOL>", "docstring": "Space remaining on line.", "id": "f3467:c0:m11"}
{"signature": "def __init__(self, x=<NUM_LIT:20>, y=<NUM_LIT:20>, boundary_flag=False):", "body": "self._x = <NUM_LIT:0><EOL>self._y = <NUM_LIT:0><EOL>if boundary_flag is True:<EOL><INDENT>self.set_bounds(xmin=x, ymin=y)<EOL><DEDENT>else:<EOL><INDENT>self.set_bounds()<EOL><DEDENT>self.set_deltas()<EOL>self.x = x<EOL>self.y = y<EOL>", "docstring": "Cursor object. Initialize with placement of cursor.\n            This cursor places the origin (0,) at the upper left hand\n            side of the page. X increases horizontally, and y increases\n            vertically down the page. Note: This is different from the way\n            Adobe sets the origin. They place the origin at the lower\n            left hand corner, and y increases from the bottom to the\n            top of the page. I feel that their way required more explanation,\n            and was less intuitive. Therefore, I have provided the y_prime\n            property for use in outputting the cursor data at document\n            generation.", "id": "f3467:c0:m0"}
{"signature": "def _set_style(self, style=None):", "body": "if style is None:<EOL><INDENT>self.style = '<STR_LIT>'<EOL>self.underline = False<EOL><DEDENT>elif self.family == ('<STR_LIT>' or '<STR_LIT>'):<EOL><INDENT>self.style = '<STR_LIT>'<EOL>self.underline = False<EOL><DEDENT>self.style = style.upper()<EOL>if '<STR_LIT>' in self.style or self.style == '<STR_LIT>':<EOL><INDENT>self.underline = True<EOL><DEDENT>else:<EOL><INDENT>self.underline = False<EOL><DEDENT>", "docstring": "Style should be a string, containing the letters 'B' for bold,\n        'U' for underline, or 'I' for italic, or should be '', for no style.\n        Symbol will not be underlined. The underline style can further be\n        modified by specifying the underline thickness and position.", "id": "f3469:c0:m4"}
{"signature": "def set_page_size(self, layout):", "body": "self.layout = layout.lower()<EOL>if self.layout in self.layout_dict:<EOL><INDENT>self.page_size = self.layout_dict[self.layout]<EOL><DEDENT>else:<EOL><INDENT>dimensions = self.layout.split('<STR_LIT:x>')<EOL>if len(dimensions) == <NUM_LIT:2>:<EOL><INDENT>self.page_size = (float(dimensions[<NUM_LIT:0>]) * <NUM_LIT>, float(dimensions[<NUM_LIT:1>]) * <NUM_LIT>)<EOL><DEDENT>else:<EOL><INDENT>raise IndexError(\"<STR_LIT>\" % len(dimensions))<EOL><DEDENT><DEDENT>", "docstring": "Valid choices: 'a3, 'a4', 'a5', 'letter', 'legal', '11x17'.", "id": "f3476:c0:m2"}
{"signature": "def _compress(self):", "body": "self.buffer = compress(self.buffer)<EOL>", "docstring": "Uses zlib to compress page buffers. Compression\n            option is enabled through PDFLite object's\n            setCompression method.", "id": "f3476:c0:m5"}
{"signature": "def __init__(self, session, page):", "body": "self.session = session<EOL>self.page = page<EOL>self._currentMatrix = (<NUM_LIT:1.>, <NUM_LIT:0.>, <NUM_LIT:0.>, <NUM_LIT:1.>, <NUM_LIT:0.>, <NUM_LIT:0.>)<EOL>self._textMatrix = (<NUM_LIT:1.>, <NUM_LIT:0.>, <NUM_LIT:0.>, <NUM_LIT:1.>, <NUM_LIT:0.>, <NUM_LIT:0.>)<EOL>", "docstring": "Constructor", "id": "f3485:c0:m0"}
{"signature": "def _draw(self):", "body": "self._compile()<EOL>self.rows[<NUM_LIT:0>]._advance_first_row()<EOL>self._set_borders()<EOL>self._draw_fill()<EOL>self._draw_borders()<EOL>self._draw_text()<EOL>self._set_final_cursor()<EOL>", "docstring": "Don't use this, use document.draw_table", "id": "f3489:c0:m10"}
{"signature": "def gzip(filename):", "body": "<EOL>retcode, output = sh('<STR_LIT>' % filename)<EOL>new_filename = filename+'<STR_LIT>'<EOL>return (retcode, output, new_filename)<EOL>", "docstring": "Gzip a file\n    returns a 3-tuple with returncode (integer), terminal output (string)\n    and the new filename.", "id": "f3493:m2"}
{"signature": "def chmod(path, mode, recursive=True):", "body": "if recursive:<EOL><INDENT>cmd = '<STR_LIT>' % (mode, path)<EOL><DEDENT>else:<EOL><INDENT>cmd = '<STR_LIT>' % (mode, path)<EOL><DEDENT>return sh(cmd)<EOL>", "docstring": "alternative to os.", "id": "f3493:m5"}
{"signature": "def db_list(username=None, password=None, host=None, port=None):", "body": "conn = _connection(username=username, password=password, host=host, port=port)<EOL>cur = conn.cursor()<EOL>cur.execute('<STR_LIT>')<EOL>rows = cur.fetchall()<EOL>conn.close()<EOL>result = []<EOL>for row in rows:<EOL><INDENT>result.append(row[<NUM_LIT:0>])<EOL><DEDENT>return result<EOL>", "docstring": "returns a list of all databases on this server", "id": "f3494:m2"}
{"signature": "def get_policy(self, id):", "body": "return self.request(\"<STR_LIT>\", id, method=\"<STR_LIT>\").json()<EOL>", "docstring": "Get a spacific policy.\n\n            https://www.nomadproject.io/api/sentinel-policies.html\n\n            returns: dict\n\n            raises:\n              - nomad.api.exceptions.BaseNomadException\n              - nomad.api.exceptions.URLNotFoundNomadException", "id": "f3524:c0:m6"}
{"signature": "def plan_job(self, id, job, diff=False, policy_override=False):", "body": "json_dict = {}<EOL>json_dict.update(job)<EOL>json_dict.setdefault('<STR_LIT>', diff)<EOL>json_dict.setdefault('<STR_LIT>', policy_override)<EOL>return self.request(id, \"<STR_LIT>\", json=json_dict, method=\"<STR_LIT>\").json()<EOL>", "docstring": "Invoke a dry-run of the scheduler for the job.\n\n           https://www.nomadproject.io/docs/http/job.html\n\n            arguments:\n              - id\n              - job, dict\n              - diff, boolean\n              - policy_override, boolean\n            returns: dict\n            raises:\n              - nomad.api.exceptions.BaseNomadException\n              - nomad.api.exceptions.URLNotFoundNomadException", "id": "f3528:c0:m15"}
{"signature": "def get_allocations(self, id):", "body": "return self.request(id, \"<STR_LIT>\", method=\"<STR_LIT>\").json()<EOL>", "docstring": "Query the allocations belonging to a single job.\n\n           https://www.nomadproject.io/docs/http/job.html\n\n            arguments:\n              - id\n            returns: list\n            raises:\n              - nomad.api.exceptions.BaseNomadException\n              - nomad.api.exceptions.URLNotFoundNomadException", "id": "f3528:c0:m8"}
{"signature": "def get_summary(self, id):", "body": "return self.request(id, \"<STR_LIT>\", method=\"<STR_LIT>\").json()<EOL>", "docstring": "Query the summary of a job.\n\n           https://www.nomadproject.io/docs/http/job.html\n\n            arguments:\n              - id\n            returns: dict\n            raises:\n              - nomad.api.exceptions.BaseNomadException\n              - nomad.api.exceptions.URLNotFoundNomadException", "id": "f3528:c0:m12"}
{"signature": "def periodic_job(self, id):", "body": "return self.request(id, \"<STR_LIT>\", \"<STR_LIT>\", method=\"<STR_LIT>\").json()<EOL>", "docstring": "Forces a new instance of the periodic job. A new instance will be\n            created even if it violates the job's prohibit_overlap settings.\n            As such, this should be only used to immediately\n            run a periodic job.\n\n           https://www.nomadproject.io/docs/http/job.html\n\n            arguments:\n              - id\n            returns: dict\n            raises:\n              - nomad.api.exceptions.BaseNomadException\n              - nomad.api.exceptions.URLNotFoundNomadException", "id": "f3528:c0:m16"}
{"signature": "def get_versions(self, id):", "body": "return self.request(id, \"<STR_LIT>\", method=\"<STR_LIT>\").json()<EOL>", "docstring": "This endpoint reads information about all versions of a job.\n\n           https://www.nomadproject.io/docs/http/job.html\n\n            arguments:\n              - id\n            returns: list of dicts\n            raises:\n              - nomad.api.exceptions.BaseNomadException\n              - nomad.api.exceptions.URLNotFoundNomadException", "id": "f3528:c0:m7"}
{"signature": "def stable_job(self, id, version, stable):", "body": "revert_json = {\"<STR_LIT>\": id,<EOL>\"<STR_LIT>\": version,<EOL>\"<STR_LIT>\": stable}<EOL>return self.request(id, \"<STR_LIT>\", json=revert_json, method=\"<STR_LIT>\").json()<EOL>", "docstring": "This endpoint sets the job's stability.\n\n           https://www.nomadproject.io/docs/http/job.html\n\n            arguments:\n              - id\n              - version, Specifies the job version to revert to.\n              - stable, Specifies whether the job should be marked as stable or not.\n            returns: dict\n            raises:\n              - nomad.api.exceptions.BaseNomadException\n              - nomad.api.exceptions.URLNotFoundNomadException", "id": "f3528:c0:m19"}
{"signature": "def stream(self, id, offset, origin, path=\"<STR_LIT:/>\"):", "body": "params = {<EOL>\"<STR_LIT:path>\": path,<EOL>\"<STR_LIT>\": offset,<EOL>\"<STR_LIT>\": origin<EOL>}<EOL>return self.request(id, params=params, method=\"<STR_LIT>\").text<EOL>", "docstring": "This endpoint streams the contents of a file in an allocation directory.\n\n            https://www.nomadproject.io/api/client.html#stream-file\n\n            arguments:\n              - id: (str) allocation_id required\n              - offset: (int) required\n              - origin: (str) either start|end\n              - path: (str) optional\n            returns: (str) text\n            raises:\n              - nomad.api.exceptions.BaseNomadException\n              - nomad.api.exceptions.BadRequestNomadException", "id": "f3529:c4:m1"}
{"signature": "def read_file(self, id=None, path=\"<STR_LIT:/>\"):", "body": "if id:<EOL><INDENT>return self.request(id, params={\"<STR_LIT:path>\": path}, method=\"<STR_LIT>\").text<EOL><DEDENT>else:<EOL><INDENT>return self.request(params={\"<STR_LIT:path>\": path}, method=\"<STR_LIT>\").text<EOL><DEDENT>", "docstring": "Read contents of a file in an allocation directory.\n\n           https://www.nomadproject.io/docs/http/client-fs-cat.html\n\n            arguments:\n              - id\n              - path\n            returns: (str) text\n            raises:\n              - nomad.api.exceptions.BaseNomadException\n              - nomad.api.exceptions.URLNotFoundNomadException", "id": "f3529:c2:m1"}
{"signature": "def stream(self, id, task, type, follow=False, offset=<NUM_LIT:0>, origin=\"<STR_LIT:start>\", plain=False):", "body": "params = {<EOL>\"<STR_LIT>\": task,<EOL>\"<STR_LIT:type>\": type,<EOL>\"<STR_LIT>\": follow,<EOL>\"<STR_LIT>\": offset,<EOL>\"<STR_LIT>\": origin,<EOL>\"<STR_LIT>\": plain<EOL>}<EOL>return self.request(id, params=params, method=\"<STR_LIT>\").text<EOL>", "docstring": "This endpoint streams a task's stderr/stdout logs.\n\n            https://www.nomadproject.io/api/client.html#stream-logs\n\n            arguments:\n              - id: (str) allocation_id required\n              - task: (str) name of the task inside the allocation to stream logs from\n              - type: (str) Specifies the stream to stream. Either \"stderr|stdout\"\n              - follow: (bool) default false\n              - offset: (int) default 0\n              - origin: (str) either start|end, default \"start\"\n              - plain: (bool) Return just the plain text without framing. default False\n            returns: (str) text\n            raises:\n              - nomad.api.exceptions.BaseNomadException\n              - nomad.api.exceptions.BadRequestNomadException", "id": "f3529:c5:m1"}
{"signature": "def read_allocation_stats(self, id):", "body": "return self.request(id, \"<STR_LIT>\", method=\"<STR_LIT>\").json()<EOL>", "docstring": "Query the actual resources consumed by an allocation.\n\n            https://www.nomadproject.io/api/client.html#read-allocation\n\n            arguments:\n            returns: dict\n            raises:\n              - nomad.api.exceptions.BaseNomadException\n              - nomad.api.exceptions.URLNotFoundNomadException", "id": "f3529:c8:m1"}
{"signature": "def garbage_collect(self, node_id=None):", "body": "self.request(params={\"<STR_LIT>\": node_id}, method=\"<STR_LIT>\")<EOL>", "docstring": "This endpoint forces a garbage collection of all stopped allocations on a node.\n\n            https://www.nomadproject.io/api/client.html#gc-all-allocation\n\n            arguments:\n              - node_id: (str) full allocation_id\n            raises:\n              - nomad.api.exceptions.BaseNomadException", "id": "f3529:c10:m1"}
{"signature": "def list_files(self, id=None, path=\"<STR_LIT:/>\"):", "body": "if id:<EOL><INDENT>return self.request(id, params={\"<STR_LIT:path>\": path}, method=\"<STR_LIT>\").json()<EOL><DEDENT>else:<EOL><INDENT>return self.request(params={\"<STR_LIT:path>\": path}, method=\"<STR_LIT>\").json()<EOL><DEDENT>", "docstring": "List files in an allocation directory.\n\n           https://www.nomadproject.io/docs/http/client-fs-ls.html\n\n            arguments:\n              - id\n              - path          \n            returns: list\n            raises:\n              - nomad.api.exceptions.BaseNomadException\n              - nomad.api.exceptions.URLNotFoundNomadException", "id": "f3529:c1:m1"}
{"signature": "def read_file_offset(self, id, offset, limit, path=\"<STR_LIT:/>\"):", "body": "params = {<EOL>\"<STR_LIT:path>\": path,<EOL>\"<STR_LIT>\": offset,<EOL>\"<STR_LIT>\": limit<EOL>}<EOL>return self.request(id, params=params, method=\"<STR_LIT>\").text<EOL>", "docstring": "Read contents of a file in an allocation directory.\n\n           https://www.nomadproject.io/docs/http/client-fs-cat.html\n\n            arguments:\n              - id: (str) allocation_id required\n              - offset: (int) required\n              - limit: (int) required\n              - path: (str) optional\n            returns: (str) text\n            raises:\n              - nomad.api.exceptions.BaseNomadException\n              - nomad.api.exceptions.BadRequestNomadException", "id": "f3529:c3:m1"}
{"signature": "def get_deployment_allocations(self, id):", "body": "return self.request(\"<STR_LIT>\", id, method=\"<STR_LIT>\").json()<EOL>", "docstring": "This endpoint lists the allocations created or modified for the given deployment.\n\n           https://www.nomadproject.io/docs/http/deployments.html\n\n            arguments:\n              - id\n            returns: list of dicts\n            raises:\n              - nomad.api.exceptions.BaseNomadException\n              - nomad.api.exceptions.URLNotFoundNomadException", "id": "f3531:c0:m7"}
{"signature": "def get_deployment(self, id):", "body": "return self.request(id, method=\"<STR_LIT>\").json()<EOL>", "docstring": "This endpoint reads information about a specific deployment by ID.\n\n           https://www.nomadproject.io/docs/http/deployments.html\n\n            arguments:\n              - id\n            returns: dict\n            raises:\n              - nomad.api.exceptions.BaseNomadException\n              - nomad.api.exceptions.URLNotFoundNomadException", "id": "f3531:c0:m6"}
{"signature": "def deployment_allocation_health(self, id, healthy_allocations=list(), unhealthy_allocations=list()):", "body": "allocations = {\"<STR_LIT>\": healthy_allocations,<EOL>\"<STR_LIT>\": unhealthy_allocations,<EOL>\"<STR_LIT>\": id}<EOL>return self.request(\"<STR_LIT>\", id, json=allocations, method=\"<STR_LIT>\").json()<EOL>", "docstring": "This endpoint is used to set the health of an allocation that is in the deployment manually. In some use\n            cases, automatic detection of allocation health may not be desired. As such those task groups can be marked\n            with an upgrade policy that uses health_check = \"manual\". Those allocations must have their health marked\n            manually using this endpoint. Marking an allocation as healthy will allow the rolling upgrade to proceed.\n            Marking it as failed will cause the deployment to fail.\n\n           https://www.nomadproject.io/docs/http/deployments.html\n\n            arguments:\n              - id\n              - healthy_allocations, Specifies the set of allocation that should be marked as healthy.\n              - unhealthy_allocations,  Specifies the set of allocation that should be marked as unhealthy.\n            returns: dict\n            raises:\n              - nomad.api.exceptions.BaseNomadException\n              - nomad.api.exceptions.URLNotFoundNomadException", "id": "f3531:c0:m12"}
{"signature": "def register_job(self, job):", "body": "return self.request(json=job, method=\"<STR_LIT>\").json()<EOL>", "docstring": "Register a job with Nomad.\n\n           https://www.nomadproject.io/docs/http/jobs.html\n\n            returns: dict\n            raises:\n              - nomad.api.exceptions.BaseNomadException\n              - nomad.api.exceptions.URLNotFoundNomadException", "id": "f3532:c0:m9"}
{"signature": "def get_self_token(self):", "body": "return self.request(\"<STR_LIT>\", \"<STR_LIT>\", method=\"<STR_LIT>\").json()<EOL>", "docstring": "Retrieve self token used for auth.\n\n            https://www.nomadproject.io/api/acl-tokens.html\n\n            returns: dict\n\n            raises:\n              - nomad.api.exceptions.BaseNomadException\n              - nomad.api.exceptions.URLNotFoundNomadException", "id": "f3538:c0:m7"}
{"signature": "def get_tokens(self):", "body": "return self.request(\"<STR_LIT>\", method=\"<STR_LIT>\").json()<EOL>", "docstring": "Get a list of tokens.\n\n            https://www.nomadproject.io/api/acl-tokens.html\n\n            returns: list\n\n            raises:\n              - nomad.api.exceptions.BaseNomadException\n              - nomad.api.exceptions.URLNotFoundNomadException", "id": "f3538:c0:m5"}
{"signature": "def get_token(self, id):", "body": "return self.request(\"<STR_LIT>\", id, method=\"<STR_LIT>\").json()<EOL>", "docstring": "Retrieve specific token.\n\n            https://www.nomadproject.io/api/acl-tokens.html\n\n            returns: dict\n\n            raises:\n              - nomad.api.exceptions.BaseNomadException\n              - nomad.api.exceptions.URLNotFoundNomadException", "id": "f3538:c0:m6"}
{"signature": "def create_token(self, token):", "body": "return self.request(\"<STR_LIT>\", json=token, method=\"<STR_LIT>\").json()<EOL>", "docstring": "Create token.\n\n            https://www.nomadproject.io/api/acl-tokens.html\n\n            arguments:\n                token\n            returns: dict\n\n            raises:\n              - nomad.api.exceptions.BaseNomadException\n              - nomad.api.exceptions.URLNotFoundNomadException", "id": "f3538:c0:m8"}
{"signature": "def get_allocations(self, prefix=None):", "body": "params = {\"<STR_LIT>\": prefix}<EOL>return self.request(method=\"<STR_LIT>\", params=params).json()<EOL>", "docstring": "Lists all the allocations.\n\n           https://www.nomadproject.io/docs/http/allocs.html\n            arguments:\n              - prefix :(str) optional, specifies a string to filter allocations on based on an prefix.\n                        This is specified as a querystring parameter.\n            returns: list\n            raises:\n              - nomad.api.exceptions.BaseNomadException\n              - nomad.api.exceptions.URLNotFoundNomadException", "id": "f3539:c0:m6"}
{"signature": "def get_evaluation(self, id):", "body": "return self.request(id, method=\"<STR_LIT>\").json()<EOL>", "docstring": "Query a specific evaluation.\n\n           https://www.nomadproject.io/docs/http/eval.html\n\n            arguments:\n              - id\n            returns: dict\n            raises:\n              - nomad.api.exceptions.BaseNomadException\n              - nomad.api.exceptions.URLNotFoundNomadException", "id": "f3543:c0:m6"}
{"signature": "def __init__(self, <EOL>host='<STR_LIT:127.0.0.1>', <EOL>secure=False, <EOL>port=<NUM_LIT>,<EOL>address=os.getenv('<STR_LIT>', None),<EOL>namespace=os.getenv('<STR_LIT>', None),<EOL>token=os.getenv('<STR_LIT>', None), <EOL>timeout=<NUM_LIT:5>, <EOL>region=os.getenv('<STR_LIT>', None), <EOL>version='<STR_LIT>', <EOL>verify=False, <EOL>cert=()):", "body": "self.host = host<EOL>self.secure = secure<EOL>self.port = port<EOL>self.address = address<EOL>self.region = region<EOL>self.timeout = timeout<EOL>self.version = version<EOL>self.token = token<EOL>self.verify = verify<EOL>self.cert = cert<EOL>self.__namespace = namespace<EOL>self.requester_settings = {<EOL>\"<STR_LIT:address>\": self.address,<EOL>\"<STR_LIT>\": self.get_uri(),<EOL>\"<STR_LIT:port>\": self.port,<EOL>\"<STR_LIT>\": self.__namespace,<EOL>\"<STR_LIT>\": self.token,<EOL>\"<STR_LIT>\": self.timeout,<EOL>\"<STR_LIT:version>\": self.version,<EOL>\"<STR_LIT>\": self.verify,<EOL>\"<STR_LIT>\": self.cert,<EOL>\"<STR_LIT>\": self.region<EOL>}<EOL>self._jobs = api.Jobs(**self.requester_settings)<EOL>self._job = api.Job(**self.requester_settings)<EOL>self._nodes = api.Nodes(**self.requester_settings)<EOL>self._node = api.Node(**self.requester_settings)<EOL>self._allocations = api.Allocations(**self.requester_settings)<EOL>self._allocation = api.Allocation(**self.requester_settings)<EOL>self._evaluations = api.Evaluations(**self.requester_settings)<EOL>self._evaluation = api.Evaluation(**self.requester_settings)<EOL>self._agent = api.Agent(**self.requester_settings)<EOL>self._client = api.Client(**self.requester_settings)<EOL>self._deployments = api.Deployments(**self.requester_settings)<EOL>self._deployment = api.Deployment(**self.requester_settings)<EOL>self._regions = api.Regions(**self.requester_settings)<EOL>self._status = api.Status(**self.requester_settings)<EOL>self._system = api.System(**self.requester_settings)<EOL>self._operator = api.Operator(**self.requester_settings)<EOL>self._validate = api.Validate(**self.requester_settings)<EOL>self._namespaces = api.Namespaces(**self.requester_settings)<EOL>self._namespace = api.Namespace(**self.requester_settings)<EOL>self._acl = api.Acl(**self.requester_settings)<EOL>self._sentinel = api.Sentinel(**self.requester_settings)<EOL>self._metrics = api.Metrics(**self.requester_settings)<EOL>", "docstring": "Nomad api client\n\n          https://github.com/jrxFive/python-nomad/\n\n           optional arguments:\n            - host (defaults 127.0.0.1), string ip or name of the nomad api server/agent that will be used.\n            - port (defaults 4646), integer port that will be used to connect.\n            - secure (defaults False), define if the protocol is secured or not (https or http)\n            - version (defaults v1), vesion of the api of nomad.\n            - verify (defaults False), verify the certificate when tls/ssl is enabled\n                                at nomad.\n            - cert (defaults empty), cert, or key and cert file to validate the certificate\n                                configured at nomad.\n            - region (defaults None), version of the region to use. It will be used then\n                                regions of the current agent of the connection.\n            - namespace (defaults to None), Specifies the enterpise namespace that will\n                                be use to deploy or to ask info to nomad.\n            - token (defaults to None), Specifies to append ACL token to the headers to\n                                make authentication on secured based nomad environemnts.\n           returns: Nomad api client object\n\n           raises:\n             - nomad.api.exceptions.BaseNomadException\n             - nomad.api.exceptions.URLNotFoundNomadException\n             - nomad.api.exceptions.URLNotAuthorizedNomadException", "id": "f3548:c0:m0"}
{"signature": "def query_yes_quit(question, default=\"<STR_LIT>\"):", "body": "valid = {\"<STR_LIT:yes>\": Answers.YES,   \"<STR_LIT:y>\": Answers.YES,  \"<STR_LIT>\": Answers.YES,<EOL>\"<STR_LIT>\": Answers.QUIT, \"<STR_LIT:q>\": Answers.QUIT}<EOL>if default is None:<EOL><INDENT>prompt = \"<STR_LIT>\"<EOL><DEDENT>elif default == \"<STR_LIT:yes>\":<EOL><INDENT>prompt = \"<STR_LIT>\"<EOL><DEDENT>elif default == \"<STR_LIT>\":<EOL><INDENT>prompt = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % default)<EOL><DEDENT>while True:<EOL><INDENT>sys.stdout.write(question + prompt)<EOL>choice = input().lower()<EOL>if default is not None and choice == '<STR_LIT>':<EOL><INDENT>return valid[default]<EOL><DEDENT>elif choice in valid:<EOL><INDENT>return valid[choice]<EOL><DEDENT>else:<EOL><INDENT>sys.stdout.write(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT>", "docstring": "Ask a yes/quit question via raw_input() and return their answer.\n\n    \"question\" is a string that is presented to the user.\n    \"default\" is the presumed answer if the user just hits <Enter>.\n        It must be \"yes\" (the default), \"quit\" or None (meaning\n        an answer is required of the user).\n\n    The \"answer\" return value is one of \"yes\" or \"quit\".\n\n    Modified from\n    http://stackoverflow.com/questions/3041986/python-command-line-yes-no-input", "id": "f3561:m6"}
{"signature": "def get_terminal_size():", "body": "try:<EOL><INDENT>try:<EOL><INDENT>from shutil import get_terminal_size as _get_terminal_size  <EOL><DEDENT>except ImportError:<EOL><INDENT>from backports.shutil_get_terminal_size import get_terminal_size as _get_terminal_size  <EOL><DEDENT>sz = _get_terminal_size()<EOL><DEDENT>except ValueError:<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>terminal_size = namedtuple('<STR_LIT>', '<STR_LIT>')<EOL>sz = terminal_size(<NUM_LIT>, <NUM_LIT>)<EOL><DEDENT>return sz<EOL>", "docstring": "Returns terminal dimensions\n    :return: Returns ``(width, height)``.  If there's no terminal\n             to be found, we'll just return ``(80, 24)``.", "id": "f3561:m12"}
{"signature": "def query_yes_no(question, default=\"<STR_LIT:yes>\"):", "body": "valid = {\"<STR_LIT:yes>\": Answers.YES, \"<STR_LIT:y>\": Answers.YES,  \"<STR_LIT>\": Answers.YES,<EOL>\"<STR_LIT>\": Answers.NO,   \"<STR_LIT:n>\": Answers.NO}<EOL>if default is None:<EOL><INDENT>prompt = \"<STR_LIT>\"<EOL><DEDENT>elif default == \"<STR_LIT:yes>\":<EOL><INDENT>prompt = \"<STR_LIT>\"<EOL><DEDENT>elif default == \"<STR_LIT>\":<EOL><INDENT>prompt = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % default)<EOL><DEDENT>while True:<EOL><INDENT>sys.stdout.write(question + prompt)<EOL>choice = input().lower()<EOL>if default is not None and choice == '<STR_LIT>':<EOL><INDENT>return valid[default]<EOL><DEDENT>elif choice in valid:<EOL><INDENT>return valid[choice]<EOL><DEDENT>else:<EOL><INDENT>sys.stdout.write(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT>", "docstring": "Ask a yes/no question via raw_input() and return their answer.\n\n    \"question\" is a string that is presented to the user.\n    \"default\" is the presumed answer if the user just hits <Enter>.\n        It must be \"yes\" (the default), \"no\" or None (meaning\n        an answer is required of the user).\n\n    The return value is one of Answers.YES or Answers.NO.\n\n    Copied (and modified) from\n    http://stackoverflow.com/questions/3041986/python-command-line-yes-no-input", "id": "f3561:m3"}
{"signature": "def find_meta(*meta_file_parts, meta_key):", "body": "meta_file = read(*meta_file_parts)<EOL>meta_match = re.search(r\"<STR_LIT>\".format(meta_key),<EOL>meta_file, re.M)<EOL>if meta_match:<EOL><INDENT>return meta_match.group(<NUM_LIT:1>)<EOL><DEDENT>raise RuntimeError(\"<STR_LIT>\".format(meta_key))<EOL>", "docstring": "Extract __*meta*__ from meta_file", "id": "f3566:m1"}
{"signature": "def write_inp(self):", "body": "template = self.get_template()<EOL>return template.substitute({\"<STR_LIT:class>\": self.__class__.__name__,<EOL>\"<STR_LIT:label>\": self.label}).strip()<EOL>", "docstring": "Returns the material definition as a string in Abaqus INP format.", "id": "f3628:c0:m2"}
{"signature": "def nvert(self):", "body": "return self.elements.type.argiope.map(<EOL>lambda t: ELEMENTS[t].nvert)<EOL>", "docstring": "Returns the number of vertices of eache element according to its type/", "id": "f3648:c5:m8"}
{"signature": "def write_inp(mesh, path = None, maxwidth = <NUM_LIT>, sections = \"<STR_LIT>\"):", "body": "def set_to_inp(sets, keyword):<EOL><INDENT>ss = \"<STR_LIT>\"<EOL>for sk in sets.keys():<EOL><INDENT>labels = sets[sk].loc[sets[sk]].index.values<EOL>labels = list(labels)<EOL>labels.sort()<EOL>if len(labels)!= <NUM_LIT:0>:<EOL><INDENT>ss += \"<STR_LIT>\".format(keyword, sk)<EOL>ss += argiope.utils.list_to_string(labels) + \"<STR_LIT:\\n>\"<EOL><DEDENT><DEDENT>return ss.strip()           <EOL><DEDENT>mesh = mesh.copy()<EOL>nodes_output = (mesh.nodes.coords.to_csv(header = False).split())<EOL>nodes_output = (\"<STR_LIT:\\n>\".join([\"<STR_LIT:U+0020>\" + s.replace(\"<STR_LIT:U+002C>\", \"<STR_LIT:U+002CU+0020>\") for s in nodes_output]))<EOL>if \"<STR_LIT>\" in mesh.nodes.columns.levels[<NUM_LIT:0>]: <EOL><INDENT>nsets = set_to_inp(mesh.nodes.sets, \"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>nsets = \"<STR_LIT>\"<EOL><DEDENT>surf_output = []<EOL>if \"<STR_LIT>\" in mesh.elements.keys():<EOL><INDENT>sk = mesh.elements.surfaces.keys()<EOL>for sindex in  np.unique(sk.labels[<NUM_LIT:0>]):<EOL><INDENT>slabel = sk.levels[<NUM_LIT:0>][sindex]<EOL>surface = mesh.elements.surfaces[slabel]<EOL>if surface.values.sum() != <NUM_LIT:0>:<EOL><INDENT>mesh.surface_to_element_sets(slabel)<EOL>surf_output.append( \"<STR_LIT>\".format(slabel))<EOL>for findex in surface.keys():<EOL><INDENT>if surface[findex].sum() != <NUM_LIT:0>:<EOL><INDENT>surf_output.append(\"<STR_LIT>\".format(slabel, <EOL>findex[<NUM_LIT:1>:])) <EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>surf_output.append(\"<STR_LIT>\")<EOL><DEDENT>elements_output = \"<STR_LIT>\"<EOL>for etype, group in mesh.elements.groupby(((\"<STR_LIT:type>\", \"<STR_LIT>\", \"<STR_LIT>\"),)):<EOL><INDENT>els = group.conn.replace(<NUM_LIT:0>, np.nan).to_csv(header = False, <EOL>float_format='<STR_LIT>').split()<EOL>elements_output += \"<STR_LIT>\".format(etype)<EOL>elements_output += (\"<STR_LIT:\\n>\".join([\"<STR_LIT:U+0020>\" + s.strip().strip(\"<STR_LIT:U+002C>\").<EOL>replace(\"<STR_LIT:U+002C>\", \"<STR_LIT:U+002CU+0020>\") for s in els]))<EOL>elements_output += \"<STR_LIT:\\n>\"<EOL><DEDENT>elements_output = elements_output.strip() <EOL>el_sets = {} <EOL>section_output = \"<STR_LIT>\"<EOL>for material, group in mesh.elements.groupby(\"<STR_LIT>\"):<EOL><INDENT>slabel = \"<STR_LIT>\".format(material)<EOL>section_output += \"<STR_LIT>\".format(<EOL>material,<EOL>argiope.utils.list_to_string(group.index.values))<EOL>if sections == \"<STR_LIT>\":<EOL><INDENT>section_output += \"<STR_LIT>\".format(<EOL>material)<EOL><DEDENT><DEDENT>if \"<STR_LIT>\" in mesh.elements.columns.levels[<NUM_LIT:0>]: <EOL><INDENT>esets = set_to_inp(mesh.elements.sets.swaplevel(<NUM_LIT:1>,<NUM_LIT:0>, axis = <NUM_LIT:1>)[\"<STR_LIT>\"],\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>esets = \"<STR_LIT>\"<EOL><DEDENT>", "docstring": "Exports the mesh to the INP format.", "id": "f3648:m4"}
{"signature": "def to_triangulation(self):", "body": "from matplotlib.tri import Triangulation<EOL>conn = self.split(\"<STR_LIT>\").unstack()<EOL>coords = self.nodes.coords.copy()<EOL>node_map  = pd.Series(data = np.arange(len(coords)), index = coords.index)<EOL>conn = node_map.loc[conn.values.flatten()].values.reshape(*conn.shape)<EOL>return Triangulation(coords.x.values, coords.y.values, conn)<EOL>", "docstring": "Returns the mesh as a matplotlib.tri.Triangulation instance. (2D only)", "id": "f3648:c5:m18"}
{"signature": "def set_elements(self, elabels = None, <EOL>types = None, <EOL>stypes = \"<STR_LIT>\", <EOL>conn = None, <EOL>esets = {}, <EOL>surfaces = {}, <EOL>materials = \"<STR_LIT>\",<EOL>**kwargs):", "body": "<EOL>if elabels is None:<EOL><INDENT>warnings.warn(<EOL>\"<STR_LIT>\", <EOL>Warning)<EOL>self.elements = None<EOL><DEDENT>else:   <EOL><INDENT>columns = pd.MultiIndex.from_tuples([(\"<STR_LIT:type>\", \"<STR_LIT>\", \"<STR_LIT>\")])<EOL>self.elements = pd.DataFrame(data = types,<EOL>columns = columns,<EOL>index = elabels)<EOL>self.elements.index.name = \"<STR_LIT>\"<EOL>self.elements.loc[:, (\"<STR_LIT:type>\", \"<STR_LIT>\", \"<STR_LIT>\")] = stypes<EOL>c = pd.DataFrame(conn, index = elabels)<EOL>c.fillna(<NUM_LIT:0>, inplace = True)<EOL>c[:] = c.values.astype(np.int32)<EOL>c.columns = pd.MultiIndex.from_product([[\"<STR_LIT>\"], <EOL>[\"<STR_LIT>\".format(n) for <EOL>n in np.arange(c.shape[<NUM_LIT:1>])], <EOL>[\"<STR_LIT>\"]])<EOL>self.elements = self.elements.join(c)<EOL>for k, v in esets.items(): self.elements[(\"<STR_LIT>\", k, \"<STR_LIT>\")] = v<EOL>self.elements[\"<STR_LIT>\", \"<STR_LIT:all>\", \"<STR_LIT>\"] = True  <EOL>for k, v in surfaces.items():<EOL><INDENT>for fk, vv in v.items():<EOL><INDENT>self.elements[(\"<STR_LIT>\", k, \"<STR_LIT>\".format(fk))] = vv<EOL><DEDENT><DEDENT>self.elements[(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\") ] = materials<EOL>self.elements.sort_index(axis = <NUM_LIT:1>, inplace = True)<EOL><DEDENT>", "docstring": "Sets the element data.\n\n:arg elabels: element labels. Items be strictly positive and int typed \n              in 1D array-like with shape :math:`(N_e)`.\n:type elabels: 1D uint typed array-like\n:arg types: element types chosen among argiope specific element types. \n:type types: str typed array-like \n:arg stypes: element types chosen in solver (depends on the chosen solver) specific element types. \n:type stypes: str typed array-like \n:arg conn: connectivity table. In order to deal with non rectangular tables, :math:`0` can be used to fill missing data. \n:type conn: uint typed array-like\n:arg esets: element sets. Contains boolean array-like of shape :math:`(N_e)`.\n:type esets: dict  \n:arg surfaces: surfaces. Contains boolean array-like of shape :math:`(N_e, N_s )` with :math:`N_s` being the maximum number of faces on a single element. \n:type surfaces: dict   \n:arg materials: material keys. Any number a of materials can be used.\n:type materials: str typed array-like", "id": "f3648:c5:m3"}
{"signature": "def stats(self):", "body": "cv = self.centroids_and_volumes()<EOL>angles  = self.angles()<EOL>edges = self.edges()<EOL>return pd.concat([cv , angles[[\"<STR_LIT>\"]], edges[[\"<STR_LIT>\"]] ], <EOL>axis = <NUM_LIT:1>).sort_index(axis = <NUM_LIT:1>)<EOL>", "docstring": "Returns mesh quality and geometric stats.", "id": "f3648:c5:m13"}
{"signature": "@numba.jit<EOL>def _make_conn(shape):", "body": "shape = np.array(shape)<EOL>Ne = shape.prod()<EOL>if len(shape) == <NUM_LIT:2>:<EOL><INDENT>nx, ny = np.array(shape) +<NUM_LIT:1> <EOL>conn = np.zeros((Ne, <NUM_LIT:4>), dtype = np.int32)<EOL>counter = <NUM_LIT:0><EOL>pattern = np.array([<NUM_LIT:0>,<NUM_LIT:1>,<NUM_LIT:1>+nx,nx])<EOL>for j in range(shape[<NUM_LIT:1>]):<EOL><INDENT>for i in range(shape[<NUM_LIT:0>]):<EOL><INDENT>conn[counter] = pattern + <NUM_LIT:1> + i + j*nx<EOL>counter += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>if len(shape) == <NUM_LIT:3>:<EOL><INDENT>nx, ny, nz  = np.array(shape) +<NUM_LIT:1> <EOL>conn = np.zeros((Ne, <NUM_LIT:8>), dtype = np.int32)<EOL>counter = <NUM_LIT:0><EOL>pattern = np.array([<NUM_LIT:0>,<NUM_LIT:1>,<NUM_LIT:1>+nx,nx,nx*ny,<NUM_LIT:1>+nx*ny,<NUM_LIT:1>+(nx+<NUM_LIT:1>)*ny,(nx+<NUM_LIT:1>)*ny])<EOL>for k in range(shape[<NUM_LIT:2>]):<EOL><INDENT>for j in range(shape[<NUM_LIT:1>]):<EOL><INDENT>for i in range(shape[<NUM_LIT:0>]):<EOL><INDENT>conn[counter] = pattern + <NUM_LIT:1> + i + j*nx+ k*nx*ny<EOL>counter += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT><DEDENT>return conn<EOL>", "docstring": "Connectivity builder using Numba for speed boost.", "id": "f3648:m5"}
{"signature": "def node_set_to_surface(self, tag):", "body": "<EOL>nodes = self.nodes.copy()<EOL>dummy = nodes.iloc[<NUM_LIT:0>].copy()<EOL>dummy[\"<STR_LIT>\"] *= np.nan<EOL>dummy[\"<STR_LIT>\"] = True<EOL>nodes.loc[<NUM_LIT:0>] = dummy<EOL>element_surfaces= self.split(\"<STR_LIT>\").unstack()<EOL>surf = pd.DataFrame(<EOL>nodes.sets[tag].loc[element_surfaces.values.flatten()]<EOL>.values.reshape(element_surfaces.shape)<EOL>.prod(axis = <NUM_LIT:1>)<EOL>.astype(np.bool),<EOL>index = element_surfaces.index).unstack().fillna(False)<EOL>for k in surf.keys():<EOL><INDENT>self.elements[\"<STR_LIT>\", tag, \"<STR_LIT>\".format(k[<NUM_LIT:1>]+<NUM_LIT:1>) ] = surf.loc[:, k]<EOL><DEDENT>", "docstring": "Converts a node set to surface.", "id": "f3648:c5:m15"}
{"signature": "def space(self):", "body": "return self.elements.type.argiope.map(<EOL>lambda t: ELEMENTS[t].space)<EOL>", "docstring": "Returns the dimension of the embedded space of each element.", "id": "f3648:c5:m7"}
{"signature": "def to_polycollection(self, *args, **kwargs):", "body": "from matplotlib import collections<EOL>nodes, elements = self.nodes, self.elements.reset_index()<EOL>verts = []<EOL>index = []<EOL>for etype, group in elements.groupby([(\"<STR_LIT:type>\", \"<STR_LIT>\", \"<STR_LIT>\")]):<EOL><INDENT>index += list(group.index)<EOL>nvert = ELEMENTS[etype].nvert<EOL>conn = group.conn.values[:, :nvert].flatten()<EOL>coords = nodes.coords[[\"<STR_LIT:x>\", \"<STR_LIT:y>\"]].loc[conn].values.reshape(<EOL>len(group), nvert, <NUM_LIT:2>)<EOL>verts += list(coords)<EOL><DEDENT>verts = np.array(verts)<EOL>verts= verts[np.argsort(index)]<EOL>return collections.PolyCollection(verts, *args,**kwargs )<EOL>", "docstring": "Returns the mesh as matplotlib polygon collection. (tested only for 2D meshes)", "id": "f3648:c5:m17"}
{"signature": "def copy(self):", "body": "return copy.deepcopy(self)<EOL>", "docstring": "Returns a copy of self.", "id": "f3650:c0:m1"}
{"signature": "def list_to_string(l = range(<NUM_LIT:200>), width = <NUM_LIT>, indent = \"<STR_LIT:U+0020>\"):", "body": "l = [str(v) + \"<STR_LIT:U+002C>\" for v in l]<EOL>counter = <NUM_LIT:0><EOL>out = \"<STR_LIT>\" + indent<EOL>for w in l:<EOL><INDENT>s = len(w)<EOL>if counter + s > width: <EOL><INDENT>out += \"<STR_LIT:\\n>\" + indent<EOL>counter = <NUM_LIT:0><EOL><DEDENT>out += w<EOL>counter += s<EOL><DEDENT>return out.strip(\"<STR_LIT:U+002C>\")<EOL>", "docstring": "Converts a list-like to string with given line width.", "id": "f3650:m2"}
{"signature": "def load(path):", "body": "return pickle.load(gzip.open(path))<EOL>", "docstring": "Loads a file.", "id": "f3650:m0"}
{"signature": "def save(self, path):", "body": "pickle.dump(self, gzip.open(path, \"<STR_LIT:w>\"), <NUM_LIT:3>)<EOL>", "docstring": "Saves the instance into a compressed serialized file.", "id": "f3650:c0:m0"}
{"signature": "def run_simulation(self):", "body": "self.make_directories()<EOL>t0 = time.time()<EOL>if self.verbose: <EOL><INDENT>print('<STR_LIT>'.format(self.label, <EOL>self.solver.upper() ))  <EOL><DEDENT>if self.solver == \"<STR_LIT>\":<EOL><INDENT>command = '<STR_LIT>'.format(<EOL>self.solver_path, <EOL>self.label) <EOL>process = subprocess.Popen(command, <EOL>cwd    = self.workdir, <EOL>shell  = True, <EOL>stdout = subprocess.PIPE,<EOL>stderr = subprocess.STDOUT)<EOL>for line in iter(process.stdout.readline, b'<STR_LIT>'):<EOL><INDENT>line = line.rstrip().decode('<STR_LIT:utf8>')<EOL>print(\"<STR_LIT:U+0020>\", line)<EOL><DEDENT><DEDENT>t1 = time.time()<EOL>if self.verbose: <EOL><INDENT>print('<STR_LIT>'.format(self.label, t1 - t0))<EOL><DEDENT>", "docstring": "Runs the simulation.", "id": "f3651:c0:m2"}
{"signature": "def get_steps(odb):", "body": "return odb.steps.keys()<EOL>", "docstring": "Retrieves the steps keys in an odb object", "id": "f3654:m0"}
{"signature": "def _path_to_dir_key(self, path):", "body": "_path = relpath(normpath(path))<EOL>_key = (<EOL>forcedir(\"<STR_LIT>\".format(self._prefix, _path))<EOL>.lstrip(\"<STR_LIT:/>\")<EOL>.replace(\"<STR_LIT:/>\", self.delimiter)<EOL>)<EOL>return _key<EOL>", "docstring": "Converts an fs path to a s3 key.", "id": "f3662:c1:m4"}
{"signature": "@classmethod<EOL><INDENT>def factory(cls, filename, mode, on_close):<DEDENT>", "body": "_temp_file = tempfile.TemporaryFile()<EOL>proxy = cls(_temp_file, filename, mode, on_close=on_close)<EOL>return proxy<EOL>", "docstring": "Create a S3File backed with a temporary file.", "id": "f3662:c0:m0"}
{"signature": "def run_cmake(arg=\"<STR_LIT>\"):", "body": "if ds.find_executable('<STR_LIT>') is None:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>sys.exit(-<NUM_LIT:1>)<EOL><DEDENT>print(\"<STR_LIT>\")<EOL>cmake_args = arg<EOL>try:<EOL><INDENT>build_dir = op.join(op.split(__file__)[<NUM_LIT:0>], '<STR_LIT>')<EOL>dd.mkpath(build_dir)<EOL>os.chdir(\"<STR_LIT>\")<EOL>ds.spawn(['<STR_LIT>', '<STR_LIT:..>'] + cmake_args.split())<EOL>ds.spawn(['<STR_LIT>', '<STR_LIT>'])<EOL>ds.spawn(['<STR_LIT>'])<EOL>os.chdir(\"<STR_LIT:..>\")<EOL><DEDENT>except ds.DistutilsExecError:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>sys.exit(-<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Forcing to run cmake", "id": "f3669:m0"}
{"signature": "def delete_queue(self, name):", "body": "content = {\"<STR_LIT>\": {\"<STR_LIT>\": self.object_name},<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": {\"<STR_LIT:type>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:name>\": name,<EOL>\"<STR_LIT>\": dict()}}  <EOL>logger.debug(\"<STR_LIT>\".format(content))<EOL>return content, self.method_properties<EOL>", "docstring": "Create message content and properties to delete queue with QMFv2\n\n        :param name: Name of queue to delete\n        :type name: str\n\n        :returns: Tuple containing content and method properties", "id": "f3678:c0:m4"}
{"signature": "def close(self):", "body": "if self.pinger:<EOL><INDENT>self.pinger.cancel()<EOL>self.pinger = None<EOL><DEDENT>if getattr(self, '<STR_LIT>', None):<EOL><INDENT>self.protocol.close()<EOL><DEDENT>", "docstring": "Close the connection", "id": "f3696:c0:m11"}
{"signature": "def send_agi_command(self, channel, command, as_list=False):", "body": "action = actions.Command({'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': channel,<EOL>'<STR_LIT>': command},<EOL>as_list=as_list)<EOL>return self.send_action(action)<EOL>", "docstring": "Send a :class:`~panoramisk.actions.Command` to the server:\n\n        :param channel: Channel name where to launch command.\n               Ex: 'SIP/000000-00000a53'\n        :type channel: String\n        :param command: command to launch. Ex: 'GET VARIABLE async_agi_server'\n        :type command: String\n        :param as_list: If True, the action Future will retrieve all responses\n        :type as_list: boolean\n        :return: a Future that will receive the response\n        :rtype: asyncio.Future\n\n        :Example:\n\n        ::\n\n            manager = Manager()\n            resp = manager.send_agi_command('SIP/000000-00000a53',\n                                            'GET VARIABLE async_agi_server')\n\n\n        Return a response :class:`~panoramisk.message.Message`.\n        See https://wiki.asterisk.org/wiki/display/AST/Asterisk+11+ManagerAction_AGI", "id": "f3696:c0:m7"}
{"signature": "def del_route(self, path):", "body": "if path not in self._route:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>del(self._route[path])<EOL>", "docstring": "Delete a route for FastAGI requests:\n\n        :param path: URI to answer. Ex: 'calls/start'\n        :type path: String\n\n        :Example:\n\n        ::\n\n            @asyncio.coroutine\n            def start(request):\n                print('Receive a FastAGI request')\n                print(['AGI variables:', request.headers])\n\n            fa_app = Application()\n            fa_app.add_route('calls/start', start)\n            fa_app.del_route('calls/start')", "id": "f3703:c1:m2"}
{"signature": "def parse_agi_result(line):", "body": "<EOL>if line == '<STR_LIT>':<EOL><INDENT>return {'<STR_LIT:error>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'}<EOL><DEDENT>kwargs = dict(code=<NUM_LIT:0>, response=\"<STR_LIT>\", line=line)<EOL>m = re_code.search(line)<EOL>try:<EOL><INDENT>kwargs.update(m.groupdict())<EOL><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT>return agi_code_check(**kwargs)<EOL>", "docstring": "Parse AGI results using Regular expression.\n\n    AGI Result examples::\n\n        100 result=0 Trying...\n\n        200 result=0\n\n        200 result=-1\n\n        200 result=132456\n\n        200 result= (timeout)\n\n        510 Invalid or unknown command\n\n        520-Invalid command syntax. Proper usage follows:\n        int() argument must be a string, a bytes-like object or a number, not\n        'NoneType'\n\n        HANGUP", "id": "f3704:m0"}
{"signature": "def get_tree_item_url_name(page, with_namespace=False):", "body": "return get_model_url_name(get_app_n_model('<STR_LIT>'), page, with_namespace)<EOL>", "docstring": "Returns a URL for a given Tree Item admin page type.", "id": "f3725:m2"}
{"signature": "def item_move(self, request, tree_id, item_id, direction):", "body": "current_item = MODEL_TREE_ITEM_CLASS._default_manager.get(pk=item_id)<EOL>if direction == '<STR_LIT>':<EOL><INDENT>sort_order = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>sort_order = '<STR_LIT>'<EOL><DEDENT>siblings = MODEL_TREE_ITEM_CLASS._default_manager.filter(<EOL>parent=current_item.parent,<EOL>tree=current_item.tree<EOL>).order_by(sort_order)<EOL>previous_item = None<EOL>for item in siblings:<EOL><INDENT>if item != current_item:<EOL><INDENT>previous_item = item<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if previous_item is not None:<EOL><INDENT>current_item_sort_order = current_item.sort_order<EOL>previous_item_sort_order = previous_item.sort_order<EOL>current_item.sort_order = previous_item_sort_order<EOL>previous_item.sort_order = current_item_sort_order<EOL>current_item.save()<EOL>previous_item.save()<EOL><DEDENT>return HttpResponseRedirect('<STR_LIT>')<EOL>", "docstring": "Moves item up or down by swapping 'sort_order' field values of neighboring items.", "id": "f3725:c0:m11"}
{"signature": "def get_form(self, request, obj=None, **kwargs):", "body": "if obj is not None and obj.parent is not None:<EOL><INDENT>self.previous_parent = obj.parent<EOL>previous_parent_id = self.previous_parent.id<EOL><DEDENT>else:<EOL><INDENT>previous_parent_id = None<EOL><DEDENT>my_choice_field = TreeItemChoiceField(self.tree, initial=previous_parent_id)<EOL>form = super(TreeItemAdmin, self).get_form(request, obj, **kwargs)<EOL>my_choice_field.label = form.base_fields['<STR_LIT>'].label<EOL>my_choice_field.help_text = form.base_fields['<STR_LIT>'].help_text<EOL>my_choice_field.widget = form.base_fields['<STR_LIT>'].widget<EOL>form.base_fields['<STR_LIT>'] = my_choice_field<EOL>if not getattr(self, '<STR_LIT>', False):<EOL><INDENT>self.known_url_names = []<EOL>self.known_url_rules = []<EOL>resolver = get_resolver(get_urlconf())<EOL>for ns, (url_prefix, ns_resolver) in resolver.namespace_dict.items():<EOL><INDENT>if ns != '<STR_LIT>':<EOL><INDENT>self._stack_known_urls(ns_resolver.reverse_dict, ns)<EOL><DEDENT><DEDENT>self._stack_known_urls(resolver.reverse_dict)<EOL>self.known_url_rules = sorted(self.known_url_rules)<EOL><DEDENT>form.known_url_names_hint = _(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>form.known_url_names = self.known_url_names<EOL>form.known_url_rules = self.known_url_rules<EOL>return form<EOL>", "docstring": "Returns modified form for TreeItem model.\n        'Parent' field choices are built by sitetree itself.", "id": "f3725:c0:m4"}
{"signature": "def get_urls(self):", "body": "urls = super(TreeAdmin, self).get_urls()<EOL>prefix_change = '<STR_LIT>' if DJANGO_POST_19 else '<STR_LIT>'<EOL>sitetree_urls = [<EOL>url(r'<STR_LIT>', redirects_handler, name=get_tree_item_url_name('<STR_LIT>')),<EOL>url(r'<STR_LIT>' % prefix_change,<EOL>self.admin_site.admin_view(self.tree_admin.item_add), name=get_tree_item_url_name('<STR_LIT>')),<EOL>url(r'<STR_LIT>' % prefix_change,<EOL>self.admin_site.admin_view(self.tree_admin.item_edit), name=get_tree_item_url_name('<STR_LIT>')),<EOL>url(r'<STR_LIT>' % prefix_change,<EOL>self.admin_site.admin_view(self.tree_admin.item_edit), name=get_tree_item_url_name('<STR_LIT>')),<EOL>url(r'<STR_LIT>' % prefix_change,<EOL>self.admin_site.admin_view(self.tree_admin.item_delete), name=get_tree_item_url_name('<STR_LIT>')),<EOL>url(r'<STR_LIT>' % prefix_change,<EOL>self.admin_site.admin_view(self.tree_admin.item_history), name=get_tree_item_url_name('<STR_LIT>')),<EOL>url(r'<STR_LIT>' % prefix_change,<EOL>self.admin_site.admin_view(self.tree_admin.item_move), name=get_tree_item_url_name('<STR_LIT>')),<EOL>]<EOL>if not DJANGO_POST_19:<EOL><INDENT>sitetree_urls = patterns_func('<STR_LIT>', *sitetree_urls)<EOL><DEDENT>if SMUGGLER_INSTALLED:<EOL><INDENT>sitetree_urls += (url(r'<STR_LIT>', self.admin_site.admin_view(self.dump_view), name='<STR_LIT>'),)<EOL><DEDENT>return sitetree_urls + urls<EOL>", "docstring": "Manages not only TreeAdmin URLs but also TreeItemAdmin URLs.", "id": "f3725:c1:m2"}
{"signature": "def response_add(self, request, obj, post_url_continue=None, **kwargs):", "body": "if post_url_continue is None:<EOL><INDENT>post_url_continue = '<STR_LIT>' % obj.pk<EOL><DEDENT>return self._redirect(request, super(TreeItemAdmin, self).response_add(request, obj, post_url_continue))<EOL>", "docstring": "Redirects to the appropriate items' 'continue' page on item add.\n\n        As we administer tree items within tree itself, we\n        should make some changes to redirection process.", "id": "f3725:c0:m2"}
{"signature": "def _redirect(self, request, response):", "body": "if '<STR_LIT>' in request.POST:<EOL><INDENT>return HttpResponseRedirect('<STR_LIT>')<EOL><DEDENT>elif '<STR_LIT>' in request.POST:<EOL><INDENT>return HttpResponseRedirect('<STR_LIT>')<EOL><DEDENT>elif '<STR_LIT>' in request.POST:<EOL><INDENT>return response<EOL><DEDENT>return HttpResponseRedirect('<STR_LIT>')<EOL>", "docstring": "Generic redirect for item editor.", "id": "f3725:c0:m1"}
{"signature": "def get_tree_url_name(page, with_namespace=False):", "body": "return get_model_url_name(get_app_n_model('<STR_LIT>'), page, with_namespace)<EOL>", "docstring": "Returns a URL for a given Tree admin page type.", "id": "f3725:m1"}
{"signature": "@classmethod<EOL><INDENT>def get_as_var(cls, tokens):<DEDENT>", "body": "as_var = None<EOL>if tokens[-<NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>as_var = tokens[-<NUM_LIT:1>]<EOL>tokens[-<NUM_LIT:2>:] = []<EOL><DEDENT>return as_var<EOL>", "docstring": "Returns context variable from `as` template tag clause if any.\n\n         Modifies tokens inplace.\n\n        :param tokens:\n        :rtype: None|str", "id": "f3739:c4:m1"}
{"signature": "@register.tag<EOL>def sitetree_page_description(parser, token):", "body": "return sitetree_page_descriptionNode.for_tag(parser, token, '<STR_LIT>', '<STR_LIT>')<EOL>", "docstring": "Renders a description for the current page, resolved against sitetree item representing current URL.", "id": "f3739:m6"}
{"signature": "def render(context, tree_items, use_template):", "body": "context.push()<EOL>context['<STR_LIT>'] = tree_items<EOL>if isinstance(use_template, FilterExpression):<EOL><INDENT>use_template = use_template.resolve(context)<EOL><DEDENT>content = get_template(use_template).render(context.flatten() if _CONTEXT_FLATTEN else context)<EOL>context.pop()<EOL>return content<EOL>", "docstring": "Render helper is used by template node functions\n    to render given template with given tree items in context.", "id": "f3739:m9"}
{"signature": "@classmethod<EOL><INDENT>def for_tag(cls, parser, token, preposition, error_hint):<DEDENT>", "body": "tokens = token.split_contents()<EOL>if len(tokens) >= <NUM_LIT:3> and tokens[<NUM_LIT:1>] == preposition:<EOL><INDENT>as_var = cls.get_as_var(tokens)<EOL>tree_alias = parser.compile_filter(tokens[<NUM_LIT:2>])<EOL>return cls(tree_alias, as_var)<EOL><DEDENT>raise template.TemplateSyntaxError(<EOL>'<STR_LIT>' % (tokens[<NUM_LIT:0>], error_hint))<EOL>", "docstring": "Node constructor to be used in tags.", "id": "f3739:c4:m0"}
{"signature": "def get_value(self, context):", "body": "", "docstring": "Should return a computed value to be used in render().", "id": "f3739:c4:m3"}
{"signature": "def detect_clause(parser, clause_name, tokens):", "body": "if clause_name in tokens:<EOL><INDENT>t_index = tokens.index(clause_name)<EOL>clause_value = parser.compile_filter(tokens[t_index + <NUM_LIT:1>])<EOL>del tokens[t_index:t_index + <NUM_LIT:2>]<EOL><DEDENT>else:<EOL><INDENT>clause_value = None<EOL><DEDENT>return clause_value<EOL>", "docstring": "Helper function detects a certain clause in tag tokens list.\n    Returns its value.", "id": "f3739:m8"}
{"signature": "def options_getter(command_options):", "body": "def get_options(option_func=None):<EOL><INDENT>from optparse import make_option<EOL>from django.core.management.base import BaseCommand<EOL>func = option_func or make_option<EOL>options = tuple([func(*option.args, **option.kwargs) for option in command_options])<EOL>if option_func is None:<EOL><INDENT>if VERSION < (<NUM_LIT:1>, <NUM_LIT:8>):<EOL><INDENT>result = BaseCommand.option_list + options<EOL><DEDENT>else:<EOL><INDENT>result = []<EOL><DEDENT><DEDENT>else:<EOL><INDENT>result = options<EOL><DEDENT>return result<EOL><DEDENT>return get_options<EOL>", "docstring": "Compatibility function to get rid of optparse in management commands after Django 1.10.\n\n    :param tuple command_options: tuple with `CommandOption` objects.", "id": "f3741:m0"}
{"signature": "def tree_climber(self, tree_alias, base_item):", "body": "if base_item is not None:<EOL><INDENT>base_item.in_current_branch = True<EOL>if hasattr(base_item, '<STR_LIT>') and base_item.parent is not None:<EOL><INDENT>self.tree_climber(tree_alias, self.get_item_by_id(tree_alias, base_item.parent.id))<EOL><DEDENT><DEDENT>", "docstring": "Climbs up the site tree to mark items of current branch.\n\n        :param str|unicode tree_alias:\n        :param TreeItemBase base_item:", "id": "f3745:c2:m24"}
{"signature": "def get_sitetree():", "body": "sitetree = getattr(_THREAD_LOCAL, _THREAD_SITETREE, None)<EOL>if sitetree is None:<EOL><INDENT>sitetree = SiteTree()<EOL>setattr(_THREAD_LOCAL, _THREAD_SITETREE, sitetree)<EOL><DEDENT>return sitetree<EOL>", "docstring": "Returns SiteTree (thread-singleton) object, implementing utility methods.\n\n    :rtype: SiteTree", "id": "f3745:m0"}
{"signature": "def tree(self, tree_alias, context):", "body": "tree_alias, sitetree_items = self.init_tree(tree_alias, context)<EOL>if not sitetree_items:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>tree_items = self.filter_items(self.get_children(tree_alias, None), '<STR_LIT>')<EOL>tree_items = self.apply_hook(tree_items, '<STR_LIT>')<EOL>self.update_has_children(tree_alias, tree_items, '<STR_LIT>')<EOL>return tree_items<EOL>", "docstring": "Builds and returns tree structure for 'sitetree_tree' tag.\n\n        :param str|unicode tree_alias:\n        :param Context context:\n        :rtype: list|str", "id": "f3745:c2:m18"}
{"signature": "def filter_items(self, items, navigation_type=None):", "body": "if self.current_app_is_admin():<EOL><INDENT>return items<EOL><DEDENT>items_filtered = []<EOL>context = self.current_page_context<EOL>check_access = self.check_access<EOL>for item in items:<EOL><INDENT>if item.hidden:<EOL><INDENT>continue<EOL><DEDENT>if not check_access(item, context):<EOL><INDENT>continue<EOL><DEDENT>if not getattr(item, '<STR_LIT>' % navigation_type, True):  <EOL><INDENT>continue<EOL><DEDENT>items_filtered.append(item)<EOL><DEDENT>return items_filtered<EOL>", "docstring": "Filters sitetree item's children if hidden and by navigation type.\n\n        NB: We do not apply any filters to sitetree in admin app.\n\n        :param list items:\n        :param str|unicode navigation_type: sitetree, breadcrumbs, menu\n        :rtype: list", "id": "f3745:c2:m22"}
{"signature": "def set_entry(self, entry_name, key, value):", "body": "self.cache[entry_name][key] = value<EOL>", "docstring": "Replaces entire cache entry parameter data by its name with new data.\n\n        :param str|unicode entry_name:\n        :param key:\n        :param value:", "id": "f3745:c1:m7"}
{"signature": "def get_sitetree(self, alias):", "body": "cache_ = self.cache<EOL>get_cache_entry = cache_.get_entry<EOL>set_cache_entry = cache_.set_entry<EOL>caching_required = False<EOL>if not self.current_app_is_admin():<EOL><INDENT>alias = self.resolve_tree_i18n_alias(alias)<EOL><DEDENT>sitetree = get_cache_entry('<STR_LIT>', alias)<EOL>if not sitetree:<EOL><INDENT>if DYNAMIC_ONLY:<EOL><INDENT>sitetree = []<EOL><DEDENT>else:<EOL><INDENT>sitetree = (<EOL>MODEL_TREE_ITEM_CLASS.objects.<EOL>select_related('<STR_LIT>', '<STR_LIT>').<EOL>prefetch_related('<STR_LIT>').<EOL>filter(tree__alias__exact=alias).<EOL>order_by('<STR_LIT>', '<STR_LIT>'))<EOL><DEDENT>sitetree = self.attach_dynamic_tree_items(alias, sitetree)<EOL>set_cache_entry('<STR_LIT>', alias, sitetree)<EOL>caching_required = True<EOL><DEDENT>parents = get_cache_entry('<STR_LIT>', alias)<EOL>if not parents:<EOL><INDENT>parents = defaultdict(list)<EOL>for item in sitetree:<EOL><INDENT>parent = getattr(item, '<STR_LIT>')<EOL>parents[parent].append(item)<EOL><DEDENT>set_cache_entry('<STR_LIT>', alias, parents)<EOL><DEDENT>if caching_required:<EOL><INDENT>cache_update = cache_.update_entry_value<EOL>for item in sitetree:<EOL><INDENT>cache_update('<STR_LIT>', alias, {item.id: item})<EOL><DEDENT><DEDENT>url = self.url<EOL>calculate_item_depth = self.calculate_item_depth<EOL>for item in sitetree:<EOL><INDENT>if caching_required:<EOL><INDENT>item.has_children = False<EOL>if not hasattr(item, '<STR_LIT>'):<EOL><INDENT>item.depth = calculate_item_depth(alias, item.id)<EOL><DEDENT>item.depth_range = range(item.depth)<EOL>if item.access_restricted:<EOL><INDENT>permissions_src = (<EOL>item.permissions if getattr(item, '<STR_LIT>', False)<EOL>else item.access_permissions.all())<EOL>item.perms = set(<EOL>['<STR_LIT>' % (perm.content_type.app_label, perm.codename) for perm in permissions_src])<EOL><DEDENT><DEDENT>item.url_resolved = url(item)<EOL>item.title_resolved = LazyTitle(item.title) if VARIABLE_TAG_START in item.title else item.title<EOL>item.is_current = False<EOL>item.in_current_branch = False<EOL><DEDENT>self.get_tree_current_item(alias)<EOL>if caching_required:<EOL><INDENT>cache_.save()<EOL><DEDENT>return alias, sitetree<EOL>", "docstring": "Gets site tree items from the given site tree.\n        Caches result to dictionary.\n        Returns (tree alias, tree items) tuple.\n\n        :param str|unicode alias:\n        :rtype: tuple", "id": "f3745:c2:m5"}
{"signature": "def get_current_page_attr(self, attr_name, tree_alias, context):", "body": "tree_alias, sitetree_items = self.init_tree(tree_alias, context)<EOL>current_item = self.get_tree_current_item(tree_alias)<EOL>if current_item is None:<EOL><INDENT>if settings.DEBUG and RAISE_ITEMS_ERRORS_ON_DEBUG:<EOL><INDENT>raise SiteTreeError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % attr_name)<EOL><DEDENT>return '<STR_LIT>'<EOL><DEDENT>return getattr(current_item, attr_name, '<STR_LIT>')<EOL>", "docstring": "Returns an arbitrary attribute of a sitetree item resolved as current for current page.\n\n        :param str|unicode attr_name:\n        :param str|unicode tree_alias:\n        :param Context context:\n        :rtype: str|unicode", "id": "f3745:c2:m12"}
{"signature": "def calculate_item_depth(self, tree_alias, item_id, depth=<NUM_LIT:0>):", "body": "item = self.get_item_by_id(tree_alias, item_id)<EOL>if hasattr(item, '<STR_LIT>'):<EOL><INDENT>depth = item.depth + depth<EOL><DEDENT>else:<EOL><INDENT>if item.parent is not None:<EOL><INDENT>depth = self.calculate_item_depth(tree_alias, item.parent.id, depth + <NUM_LIT:1>)<EOL><DEDENT><DEDENT>return depth<EOL>", "docstring": "Calculates depth of the item in the tree.\n\n        :param str|unicode tree_alias:\n        :param int item_id:\n        :param int depth:\n        :rtype: int", "id": "f3745:c2:m6"}
{"signature": "def compose_dynamic_tree(src, target_tree_alias=None, parent_tree_item_alias=None, include_trees=None):", "body": "def result(sitetrees=src):<EOL><INDENT>if include_trees is not None:<EOL><INDENT>sitetrees = [tree for tree in sitetrees if tree.alias in include_trees]<EOL><DEDENT>return {<EOL>'<STR_LIT>': src,<EOL>'<STR_LIT>': sitetrees,<EOL>'<STR_LIT>': target_tree_alias,<EOL>'<STR_LIT>': parent_tree_item_alias}<EOL><DEDENT>if isinstance(src, six.string_types):<EOL><INDENT>try:<EOL><INDENT>module = import_app_sitetree_module(src)<EOL>return None if module is None else result(getattr(module, '<STR_LIT>', None))<EOL><DEDENT>except ImportError as e:<EOL><INDENT>if settings.DEBUG:<EOL><INDENT>warnings.warn('<STR_LIT>' % (src, e))<EOL><DEDENT>return None<EOL><DEDENT><DEDENT>return result()<EOL>", "docstring": "Returns a structure describing a dynamic sitetree.utils\n    The structure can be built from various sources,\n\n    :param str|iterable src: If a string is passed to `src`, it'll be treated as the name of an app,\n        from where one want to import sitetrees definitions. `src` can be an iterable\n        of tree definitions (see `sitetree.toolbox.tree()` and `item()` functions).\n\n    :param str|unicode target_tree_alias: Static tree alias to attach items from dynamic trees to.\n\n    :param str|unicode parent_tree_item_alias: Tree item alias from a static tree to attach items from dynamic trees to.\n\n    :param list include_trees: Sitetree aliases to filter `src`.\n\n    :rtype: dict", "id": "f3745:m5"}
{"signature": "def register_items_hook(func):", "body": "global _ITEMS_PROCESSOR<EOL>global _ITEMS_PROCESSOR_ARGS_LEN<EOL>_ITEMS_PROCESSOR = func<EOL>if func:<EOL><INDENT>args_len = len(getargspec(func).args)<EOL>if args_len not in {<NUM_LIT:2>, <NUM_LIT:3>}:<EOL><INDENT>raise SiteTreeError('<STR_LIT>')<EOL><DEDENT>_ITEMS_PROCESSOR_ARGS_LEN = args_len<EOL><DEDENT>", "docstring": "Registers a hook callable to process tree items right before they are passed to templates.\n\n    Callable should be able to:\n\n        a) handle ``tree_items`` and ``tree_sender`` key params.\n            ``tree_items`` will contain a list of extended TreeItem objects ready to pass to template.\n            ``tree_sender`` will contain navigation type identifier\n                (e.g.: `menu`, `sitetree`, `breadcrumbs`, `menu.children`, `sitetree.children`)\n\n        b) return a list of extended TreeItems objects to pass to template.\n\n\n    Example::\n\n        # Put the following code somewhere where it'd be triggered as expected. E.g. in app view.py.\n\n        # First import the register function.\n        from sitetree.sitetreeapp import register_items_hook\n\n        # The following function will be used as items processor.\n        def my_items_processor(tree_items, tree_sender):\n            # Suppose we want to process only menu child items.\n            if tree_sender == 'menu.children':\n                # Lets add 'Hooked: ' to resolved titles of every item.\n                for item in tree_items:\n                    item.title_resolved = 'Hooked: %s' % item.title_resolved\n            # Return items list mutated or not.\n            return tree_items\n\n        # And we register items processor.\n        register_items_hook(my_items_processor)\n\n    :param func:", "id": "f3745:m1"}
{"signature": "def current_app_is_admin(self):", "body": "is_admin = self._current_app_is_admin<EOL>if is_admin is None:<EOL><INDENT>context = self.current_page_context<EOL>current_app = getattr(<EOL>getattr(context.get('<STR_LIT>', None), '<STR_LIT>', None), '<STR_LIT>',<EOL>getattr(context, '<STR_LIT>', None))<EOL>if current_app is None:  <EOL><INDENT>current_app = context.get('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>is_admin = current_app == ADMIN_APP_NAME<EOL>self._current_app_is_admin = is_admin<EOL><DEDENT>return is_admin<EOL>", "docstring": "Returns boolean whether current application is Admin contrib.\n\n        :rtype: bool", "id": "f3745:c2:m4"}
{"signature": "def get_tree_current_item(self, tree_alias):", "body": "current_item = self._current_items.get(tree_alias, _UNSET)<EOL>if current_item is not _UNSET:<EOL><INDENT>if current_item is not None:<EOL><INDENT>current_item.is_current = True  <EOL><DEDENT>return current_item<EOL><DEDENT>current_item = None<EOL>if self.current_app_is_admin():<EOL><INDENT>self._current_items[tree_alias] = current_item<EOL>return None<EOL><DEDENT>current_url = self.current_request.path<EOL>if isinstance(current_url, str):<EOL><INDENT>current_url = current_url.encode('<STR_LIT>')<EOL><DEDENT>if current_url:<EOL><INDENT>current_url = urlquote(current_url)<EOL><DEDENT>for url_item, url in self._items_urls.items():<EOL><INDENT>if url != current_url:<EOL><INDENT>continue<EOL><DEDENT>url_item.is_current = True<EOL>if url_item.tree.alias == tree_alias:<EOL><INDENT>current_item = url_item<EOL><DEDENT><DEDENT>if current_item is not None:<EOL><INDENT>self._current_items[tree_alias] = current_item<EOL><DEDENT>return current_item<EOL>", "docstring": "Resolves current tree item of 'tree_alias' tree matching current\n        request path against URL of given tree item.\n\n        :param str|unicode tree_alias:\n        :rtype: TreeItemBase", "id": "f3745:c2:m8"}
{"signature": "def breadcrumbs(self, tree_alias, context):", "body": "tree_alias, sitetree_items = self.init_tree(tree_alias, context)<EOL>if not sitetree_items:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>current_item = self.get_tree_current_item(tree_alias)<EOL>breadcrumbs = []<EOL>if current_item is not None:<EOL><INDENT>context_ = self.current_page_context<EOL>check_access = self.check_access<EOL>get_item_by_id = self.get_item_by_id<EOL>def climb(base_item):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if base_item.inbreadcrumbs and not base_item.hidden and check_access(base_item, context_):<EOL><INDENT>breadcrumbs.append(base_item)<EOL><DEDENT>if hasattr(base_item, '<STR_LIT>') and base_item.parent is not None:<EOL><INDENT>climb(get_item_by_id(tree_alias, base_item.parent.id))<EOL><DEDENT><DEDENT>climb(current_item)<EOL>breadcrumbs.reverse()<EOL><DEDENT>items = self.apply_hook(breadcrumbs, '<STR_LIT>')<EOL>self.update_has_children(tree_alias, items, '<STR_LIT>')<EOL>return items<EOL>", "docstring": "Builds and returns breadcrumb trail structure for 'sitetree_breadcrumbs' tag.\n\n        :param str|unicode tree_alias:\n        :param Context context:\n        :rtype: list|str", "id": "f3745:c2:m17"}
{"signature": "@classmethod<EOL><INDENT>def reset(cls):<DEDENT>", "body": "cache.set('<STR_LIT>', True)<EOL>", "docstring": "Instructs sitetree to drop and recreate cache.\n\n        Could be used to show up tree changes made in a different process.", "id": "f3745:c1:m1"}
{"signature": "def get_dynamic_trees():", "body": "return _DYNAMIC_TREES<EOL>", "docstring": "Returns a dictionary with currently registered dynamic trees.", "id": "f3745:m4"}
{"signature": "def get_tree_model():", "body": "return get_model_class('<STR_LIT>')<EOL>", "docstring": "Returns the Tree model, set for the project.\n\n    :rtype: TreeBase", "id": "f3750:m7"}
{"signature": "def save(self, force_insert=False, force_update=False, **kwargs):", "body": "<EOL>if self.parent == self:<EOL><INDENT>self.parent = None<EOL><DEDENT>id_ = self.id<EOL>if id_ and self.sort_order == <NUM_LIT:0>:<EOL><INDENT>self.sort_order = id_<EOL><DEDENT>super(TreeItemBase, self).save(force_insert, force_update, **kwargs)<EOL>if self.sort_order == <NUM_LIT:0>:<EOL><INDENT>self.sort_order = self.id<EOL>self.save()<EOL><DEDENT>", "docstring": "Ensure that item is not its own parent and set proper sort order.", "id": "f3751:c2:m0"}
{"signature": "def twisted_app(port):", "body": "from twisted.web import server<EOL>from twisted.web.resource import Resource<EOL>from twisted.web.static import File<EOL>from web.apps.twisted_app import TwistedApplication<EOL>class Main(Resource):<EOL><INDENT>def getChild(self, name, request):<EOL><INDENT>name = name.decode()<EOL>if name == '<STR_LIT>':<EOL><INDENT>return self<EOL><DEDENT>return self.children[name]<EOL><DEDENT>def render_GET(self, request):<EOL><INDENT>return HELLO_WORLD.encode()<EOL><DEDENT><DEDENT>class Landing(Resource):<EOL><INDENT>isLeaf = True<EOL>def render_GET(self, request):<EOL><INDENT>return LANDING_PAGE.encode()<EOL><DEDENT><DEDENT>root = Main()<EOL>root.putChild('<STR_LIT>', Landing())<EOL>root.putChild('<STR_LIT>', File(STATIC_PATH))<EOL>site = server.Site(root)<EOL>app = TwistedApplication(port=port, site=site)<EOL>app.timed_call(<NUM_LIT>, app.stop)<EOL>app.start()<EOL>", "docstring": "With logging\n\n    Running 30s test @ http://127.0.0.1:8888/\n      12 threads and 400 connections\n      Thread Stats   Avg      Stdev     Max   +/- Stdev\n        Latency   124.17ms   24.74ms 492.40ms   85.64%\n        Req/Sec   245.94     80.01     0.86k    66.42%\n      87585 requests in 30.05s, 11.78MB read\n    Requests/sec:   2914.22\n    Transfer/sec:    401.27KB", "id": "f3757:m5"}
{"signature": "def tornado_app(port):", "body": "import tornado.web<EOL>from web.apps.tornado_app import TornadoApplication<EOL>from tornado.log import enable_pretty_logging<EOL>enable_pretty_logging()<EOL>app = TornadoApplication()<EOL>class Home(Handler):<EOL><INDENT>def get(self, req, resp):<EOL><INDENT>resp.write(HELLO_WORLD)<EOL>resp.finish()<EOL><DEDENT><DEDENT>class Landing(Handler):<EOL><INDENT>def get(self, req, resp):<EOL><INDENT>resp.write(LANDING_PAGE)<EOL>resp.finish()<EOL><DEDENT><DEDENT>app.add_route('<STR_LIT:/>', Home())<EOL>app.add_route('<STR_LIT>', Landing())<EOL>app.add_static_route('<STR_LIT>', STATIC_PATH)<EOL>app.timed_call(<NUM_LIT>, app.stop)<EOL>app.start(port=port)<EOL>", "docstring": "Even without logging it's slower!\n\n    Running 30s test @ http://127.0.0.1:8888/\n      12 threads and 400 connections\n      Thread Stats   Avg      Stdev     Max   +/- Stdev\n        Latency   179.14ms   26.19ms 464.63ms   92.60%\n        Req/Sec   184.55    107.47   560.00     57.59%\n      64871 requests in 30.10s, 12.87MB read\n    Requests/sec:   2155.42\n    Transfer/sec:    437.82KB\n\n    with logging\n\n    Running 30s test @ http://127.0.0.1:8888/\n      12 threads and 400 connections\n      Thread Stats   Avg      Stdev     Max   +/- Stdev\n        Latency   209.77ms   28.48ms 320.47ms   91.43%\n        Req/Sec   156.14     79.60   500.00     63.72%\n      55415 requests in 30.10s, 10.99MB read\n    Requests/sec:   1841.04\n    Transfer/sec:    373.96KB", "id": "f3757:m4"}
{"signature": "def falcon_app(port):", "body": "from web.apps.falcon_app import FalconApplication<EOL>app = FalconApplication()<EOL>class Home(Handler):<EOL><INDENT>def get(self, req, resp):<EOL><INDENT>resp.body = HELLO_WORLD<EOL><DEDENT><DEDENT>class Landing(Handler):<EOL><INDENT>def get(self, req, resp):<EOL><INDENT>resp.body = LANDING_PAGE<EOL><DEDENT><DEDENT>app.add_route('<STR_LIT:/>', Home())<EOL>app.add_route('<STR_LIT>', Landing())<EOL>app.add_static_route('<STR_LIT>', STATIC_PATH)<EOL>app.start(port=port)<EOL>", "docstring": "With logging\n\n    Running 30s test @ http://127.0.0.1:8888/\n      12 threads and 400 connections\n      Thread Stats   Avg      Stdev     Max   +/- Stdev\n        Latency    62.65ms   10.04ms 189.96ms   87.87%\n        Req/Sec   526.93    159.98     1.00k    64.25%\n      188860 requests in 30.06s, 23.41MB read\n    Requests/sec:   6283.35\n    Transfer/sec:    797.69KB", "id": "f3757:m2"}
{"signature": "def on_message(self, message):", "body": "change = json.loads(message)<EOL>log.debug(f'<STR_LIT>')<EOL>ref = change.get('<STR_LIT>')<EOL>if not ref:<EOL><INDENT>return<EOL><DEDENT>nodes = self.viewer.xpath('<STR_LIT>', ref=ref)<EOL>if not nodes:<EOL><INDENT>return  <EOL><DEDENT>node = nodes[<NUM_LIT:0>]<EOL>if change.get('<STR_LIT:type>') and change.get('<STR_LIT:name>'):<EOL><INDENT>if change['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>trigger = getattr(node, change['<STR_LIT:name>'])<EOL>trigger()<EOL><DEDENT>elif change['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>setattr(node, change['<STR_LIT:name>'], change['<STR_LIT:value>'])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>log.warning(f\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "When we get an event from js, lookup the node and invoke the\n        action on the enaml node.", "id": "f3762:c1:m1"}
{"signature": "@observe('<STR_LIT>','<STR_LIT>','<STR_LIT>')<EOL><INDENT>def _update_menus(self,change):<DEDENT>", "body": "menus = {}<EOL>links = [p.link for p in self.pages if p.link] + self.links <EOL>for link in links:<EOL><INDENT>for menu in link.menus:<EOL><INDENT>if menu not in menus:<EOL><INDENT>menus[menu] = []<EOL><DEDENT>menus[menu].append(link)<EOL><DEDENT><DEDENT>for name,menu in menus.items():<EOL><INDENT>k = '<STR_LIT>'.format(name)<EOL>if hasattr(self,k):<EOL><INDENT>setattr(self,k,menu)<EOL><DEDENT><DEDENT>", "docstring": "When pages change, update the menus", "id": "f3767:c0:m0"}
{"signature": "def prepare(self):", "body": "if self.__class__.view:<EOL><INDENT>return<EOL><DEDENT>with enaml.imports():<EOL><INDENT>View = pydoc.locate(self.page.view)<EOL><DEDENT>assert View, \"<STR_LIT>\".format(self.page.view)<EOL>self.__class__.view = View(<EOL>site=self.site,<EOL>page=self.page,<EOL>request=self.request,<EOL>)<EOL>", "docstring": "Load the view on first load", "id": "f3769:c0:m0"}
{"signature": "def prepare(self, **kwargs):", "body": "for k, v in kwargs.items():<EOL><INDENT>setattr(self, k, v)<EOL><DEDENT>if not self.is_initialized:<EOL><INDENT>self.initialize()<EOL><DEDENT>if not self.proxy_is_active:<EOL><INDENT>self.activate_proxy()<EOL><DEDENT>", "docstring": "Prepare for rendering", "id": "f3777:c1:m7"}
{"signature": "def xpath(self, query, **kwargs):", "body": "nodes = self.proxy.find(query, **kwargs)<EOL>return [n.declaration for n in nodes]<EOL>", "docstring": "Find nodes matching the given xpath query", "id": "f3777:c1:m6"}
{"signature": "@observe('<STR_LIT>', '<STR_LIT>')<EOL><INDENT>def _update_proxy(self, change):<DEDENT>", "body": "super(Code, self)._update_proxy(change)<EOL>", "docstring": "The superclass implementation is sufficient.", "id": "f3779:c1:m0"}
{"signature": "def render(self):", "body": "return tostring(self.widget, pretty_print=True,<EOL>encoding='<STR_LIT:utf-8>', method='<STR_LIT:html>')<EOL>", "docstring": "Render the widget tree into a string", "id": "f3784:c0:m9"}
{"signature": "def child_added(self, child):", "body": "super(WebComponent, self).child_added(child)<EOL>if child.widget is not None:<EOL><INDENT>for i, c in enumerate(self.children()):<EOL><INDENT>if c == child:<EOL><INDENT>self.widget.insert(i, child.widget)<EOL>break<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Handle the child added event from the declaration.\n\n        This handler will insert the child toolkit widget in the correct.\n        position. Subclasses which need more control should reimplement this\n        method.", "id": "f3784:c0:m7"}
{"signature": "def set_draggable(self, draggable):", "body": "self.widget.set('<STR_LIT>', '<STR_LIT:true>' if draggable else '<STR_LIT:false>')<EOL>", "docstring": "The draggable attr must be explicitly set to true or false", "id": "f3784:c0:m20"}
{"signature": "def child_removed(self, child):", "body": "super(WebComponent, self).child_removed(child)<EOL>if child.widget is not None:<EOL><INDENT>for i, c in enumerate(self.children()):<EOL><INDENT>if c == child:<EOL><INDENT>del self.widget[i]<EOL>break<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Handle the child removed event from the declaration.\n\n        This handler will unparent the child toolkit widget. Subclasses\n        which need more control should reimplement this method.", "id": "f3784:c0:m8"}
{"signature": "def init_events(self):", "body": "pass<EOL>", "docstring": "Initialize the event handlers of the toolkit widget.\n\n        This method is called during the bottom-up pass. This method\n        should initialize the event handlers for the widget. The child widgets\n        will be fully initialized and layed out when this is called.", "id": "f3784:c0:m3"}
{"signature": "def init_layout(self):", "body": "pass<EOL>", "docstring": "Initialize the layout of the toolkit widget.\n\n        This method is called during the bottom-up pass. This method\n        should initialize the layout of the widget. The child widgets\n        will be fully initialized and layed out when this is called.", "id": "f3784:c0:m2"}
{"signature": "def assertImageEqual(self, image1, image2):", "body": "h1 = image1.histogram()<EOL>h2 = image2.histogram()<EOL>rms = math.sqrt(<EOL>reduce(<EOL>operator.add,<EOL>map(lambda a, b: (a - b) ** <NUM_LIT:2>, h1, h2)<EOL>) // len(h1)<EOL>)<EOL>self.assertEqual(rms, <NUM_LIT:0.0>)<EOL>", "docstring": "Assert that `image1` & `image2` are identical images.", "id": "f3798:c1:m2"}
{"signature": "def get_filtered_root_folder(self):", "body": "folder, filename = os.path.split(self.name)<EOL>return os.path.join(folder, VERSATILEIMAGEFIELD_FILTERED_DIRNAME, '<STR_LIT>')<EOL>", "docstring": "Return the location where filtered images are stored.", "id": "f3800:c0:m7"}
{"signature": "@property<EOL><INDENT>def ppoi(self):<DEDENT>", "body": "return self._ppoi_value<EOL>", "docstring": "Primary Point of Interest (ppoi) getter.", "id": "f3800:c0:m4"}
{"signature": "def get_filtered_sized_root_folder(self):", "body": "sized_root_folder = self.get_sized_root_folder()<EOL>return os.path.join(<EOL>sized_root_folder,<EOL>VERSATILEIMAGEFIELD_FILTERED_DIRNAME<EOL>)<EOL>", "docstring": "Return the location where filtered + sized images are stored.", "id": "f3800:c0:m9"}
{"signature": "def delete_all_created_images(self):", "body": "self.delete_filtered_images()<EOL>self.delete_sized_images()<EOL>self.delete_filtered_sized_images()<EOL>", "docstring": "Delete all images created from `self.name`.", "id": "f3800:c0:m14"}
{"signature": "def __init__(self, instance_or_queryset,<EOL>rendition_key_set, image_attr, verbose=False):", "body": "if isinstance(instance_or_queryset, Model):<EOL><INDENT>queryset = instance_or_queryset.__class__._default_manager.filter(<EOL>pk=instance_or_queryset.pk<EOL>)<EOL><DEDENT>elif isinstance(instance_or_queryset, QuerySet):<EOL><INDENT>queryset = instance_or_queryset<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT:{}>\".format(self.__class__.__name__)<EOL>)<EOL><DEDENT>self.queryset = queryset<EOL>if isinstance(rendition_key_set, six.string_types):<EOL><INDENT>rendition_key_set = get_rendition_key_set(rendition_key_set)<EOL><DEDENT>self.size_key_list = [<EOL>size_key<EOL>for key, size_key in validate_versatileimagefield_sizekey_list(<EOL>rendition_key_set<EOL>)<EOL>]<EOL>self.image_attr = image_attr<EOL>self.verbose = verbose<EOL>", "docstring": "Arguments:\n`instance_or_queryset`: A django model instance or QuerySet\n`rendition_key_set`: Either a string that corresponds to a key on\n                settings.VERSATILEIMAGEFIELD_RENDITION_KEY_SETS\n                or an iterable\n                of 2-tuples, both strings:\n    [0]: The 'name' of the image size.\n    [1]: A VersatileImageField 'size_key'.\n    Example: [\n        ('large', 'url'),\n        ('medium', 'crop__400x400'),\n        ('small', 'thumbnail__100x100')\n    ]\n`image_attr`: A dot-notated path to a VersatileImageField on\n              `instance_or_queryset`\n`verbose`: bool signifying whether a progress bar should be printed\n           to sys.stdout", "id": "f3804:c0:m0"}
{"signature": "def warm(self):", "body": "num_images_pre_warmed = <NUM_LIT:0><EOL>failed_to_create_image_path_list = []<EOL>total = self.queryset.count() * len(self.size_key_list)<EOL>for a, instance in enumerate(self.queryset, start=<NUM_LIT:1>):<EOL><INDENT>for b, size_key in enumerate(self.size_key_list, start=<NUM_LIT:1>):<EOL><INDENT>success, url_or_filepath = self._prewarm_versatileimagefield(<EOL>size_key,<EOL>reduce(getattr, self.image_attr.split(\"<STR_LIT:.>\"), instance)<EOL>)<EOL>if success is True:<EOL><INDENT>num_images_pre_warmed += <NUM_LIT:1><EOL>if self.verbose:<EOL><INDENT>cli_progress_bar(num_images_pre_warmed, total)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>failed_to_create_image_path_list.append(url_or_filepath)<EOL><DEDENT>if a * b == total:<EOL><INDENT>stdout.write('<STR_LIT:\\n>')<EOL><DEDENT><DEDENT><DEDENT>stdout.flush()<EOL>return (num_images_pre_warmed, failed_to_create_image_path_list)<EOL>", "docstring": "Returns a 2-tuple:\n[0]: Number of images successfully pre-warmed\n[1]: A list of paths on the storage class associated with the\n     VersatileImageField field being processed by `self` of\n     files that could not be successfully seeded.", "id": "f3804:c0:m2"}
{"signature": "def md5(image_key):", "body": "return hashlib.md5(image_key.encode('<STR_LIT:utf-8>')).hexdigest()<EOL>", "docstring": "Return the md5 hash of image_key.", "id": "f3806:m0"}
{"signature": "def md5_16(image_key):", "body": "return md5(image_key)[:<NUM_LIT:16>]<EOL>", "docstring": "Return the first 16 characters of the md5 hash of image_key.", "id": "f3806:m1"}
{"signature": "def process_placeholder_image(self):", "body": "if self.placeholder_image_name:<EOL><INDENT>return<EOL><DEDENT>placeholder_image_name = None<EOL>placeholder_image = self.placeholder_image<EOL>if placeholder_image:<EOL><INDENT>if isinstance(placeholder_image, OnStoragePlaceholderImage):<EOL><INDENT>name = placeholder_image.path<EOL><DEDENT>else:<EOL><INDENT>name = placeholder_image.image_data.name<EOL><DEDENT>placeholder_image_name = os.path.join(<EOL>VERSATILEIMAGEFIELD_PLACEHOLDER_DIRNAME, name<EOL>)<EOL>if not self.storage.exists(placeholder_image_name):<EOL><INDENT>self.storage.save(<EOL>placeholder_image_name,<EOL>placeholder_image.image_data<EOL>)<EOL><DEDENT><DEDENT>self.placeholder_image_name = placeholder_image_name<EOL>", "docstring": "Process the field's placeholder image.\n\nEnsures the placeholder image has been saved to the same storage class\nas the field in a top level folder with a name specified by\nsettings.VERSATILEIMAGEFIELD_SETTINGS['placeholder_directory_name']\n\nThis should be called by the VersatileImageFileDescriptor __get__.\nIf self.placeholder_image_name is already set it just returns right away.", "id": "f3809:c1:m1"}
{"signature": "def __init__(self, path):", "body": "self.path = path<EOL>", "docstring": "`path` - An absolute path to an on-disc image.", "id": "f3811:c1:m0"}
{"signature": "def get_ppoi_id(self, name):", "body": "return name + '<STR_LIT>'<EOL>", "docstring": "Given the name of the primary point of interest tag, return the HTML id for it.", "id": "f3813:c0:m2"}
{"signature": "def get_context(self, name, value, attrs):", "body": "if self.has_template_widget_rendering:<EOL><INDENT>context = super(ClearableFileInputWithImagePreview, self).get_context(name, value, attrs)<EOL><DEDENT>else:<EOL><INDENT>context = {}<EOL>context['<STR_LIT>'] = {<EOL>'<STR_LIT:name>': name,<EOL>'<STR_LIT>': self.is_hidden,<EOL>'<STR_LIT>': self.is_required,<EOL>'<STR_LIT:value>': self._format_value(value),<EOL>'<STR_LIT>': self.build_attrs(self.attrs, attrs),<EOL>'<STR_LIT>': self.template_name,<EOL>'<STR_LIT:type>': self.input_type,<EOL>}<EOL><DEDENT>checkbox_name = self.clear_checkbox_name(name)<EOL>checkbox_id = self.clear_checkbox_id(checkbox_name)<EOL>context['<STR_LIT>'].update({<EOL>'<STR_LIT>': checkbox_name,<EOL>'<STR_LIT>': checkbox_id,<EOL>'<STR_LIT>': self.is_initial(value),<EOL>'<STR_LIT>': self.input_text,<EOL>'<STR_LIT>': self.initial_text,<EOL>'<STR_LIT>': self.clear_checkbox_label,<EOL>})<EOL>if value and hasattr(value, \"<STR_LIT:url>\"):<EOL><INDENT>context['<STR_LIT>'].update({<EOL>'<STR_LIT>': self.get_hidden_field_id(name),<EOL>'<STR_LIT>': self.get_point_stage_id(name),<EOL>'<STR_LIT>': self.get_ppoi_id(name),<EOL>'<STR_LIT>': self.get_sized_url(value),<EOL>'<STR_LIT>': self.image_preview_id(name),<EOL>})<EOL><DEDENT>return context<EOL>", "docstring": "Get the context to render this widget with.", "id": "f3813:c0:m6"}
{"signature": "def build_attrs(self, base_attrs, extra_attrs=None):", "body": "attrs = base_attrs.copy()<EOL>if extra_attrs is not None:<EOL><INDENT>attrs.update(extra_attrs)<EOL><DEDENT>return attrs<EOL>", "docstring": "Build an attribute dictionary.", "id": "f3813:c0:m7"}
{"signature": "def register_sizer(self, attr_name, sizedimage_cls):", "body": "if attr_name.startswith(<EOL>'<STR_LIT:_>'<EOL>) or attr_name in self.unallowed_sizer_names:<EOL><INDENT>raise UnallowedSizerName(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (<EOL>attr_name,<EOL>'<STR_LIT:U+002CU+0020>'.join([<EOL>name<EOL>for name in self.unallowed_sizer_names<EOL>])<EOL>)<EOL>)<EOL><DEDENT>if not issubclass(sizedimage_cls, SizedImage):<EOL><INDENT>raise InvalidSizedImageSubclass(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>if attr_name in self._sizedimage_registry:<EOL><INDENT>raise AlreadyRegistered(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % attr_name<EOL>)<EOL><DEDENT>else:<EOL><INDENT>self._sizedimage_registry[attr_name] = sizedimage_cls<EOL><DEDENT>", "docstring": "Register a new SizedImage subclass (`sizedimage_cls`).\n\nTo be used via the attribute (`attr_name`).", "id": "f3814:c6:m1"}
{"signature": "def unregister_sizer(self, attr_name):", "body": "if attr_name not in self._sizedimage_registry:<EOL><INDENT>raise NotRegistered(<EOL>'<STR_LIT>' % attr_name<EOL>)<EOL><DEDENT>else:<EOL><INDENT>del self._sizedimage_registry[attr_name]<EOL><DEDENT>", "docstring": "Unregister the SizedImage subclass currently assigned to `attr_name`.\n\nIf a SizedImage subclass isn't already registered to `attr_name`\nNotRegistered will raise.", "id": "f3814:c6:m2"}
{"signature": "def autodiscover():", "body": "from importlib import import_module<EOL>from django.apps import apps<EOL>from django.utils.module_loading import module_has_submodule<EOL>for app_config in apps.get_app_configs():<EOL><INDENT>try:<EOL><INDENT>before_import_sizedimage_registry = copy.copy(<EOL>versatileimagefield_registry._sizedimage_registry<EOL>)<EOL>before_import_filter_registry = copy.copy(<EOL>versatileimagefield_registry._filter_registry<EOL>)<EOL>import_module('<STR_LIT>' % app_config.name)<EOL><DEDENT>except Exception:<EOL><INDENT>versatileimagefield_registry._sizedimage_registry =before_import_sizedimage_registry<EOL>versatileimagefield_registry._filter_registry =before_import_filter_registry<EOL>if module_has_submodule(app_config.module, '<STR_LIT>'):<EOL><INDENT>raise<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Discover versatileimagefield.py modules.\n\nIterate over django.apps.get_app_configs() and discover\nversatileimagefield.py modules.", "id": "f3814:m0"}
{"signature": "def unregister_filter(self, attr_name):", "body": "if attr_name not in self._filter_registry:<EOL><INDENT>raise NotRegistered(<EOL>'<STR_LIT>' % attr_name<EOL>)<EOL><DEDENT>else:<EOL><INDENT>del self._filter_registry[attr_name]<EOL><DEDENT>", "docstring": "Unregister the FilteredImage subclass currently assigned to attr_name.\n\nIf a FilteredImage subclass isn't already registered to filters.\n`attr_name` NotRegistered will raise.", "id": "f3814:c6:m4"}
{"signature": "def get_filtered_filename(filename, filename_key):", "body": "try:<EOL><INDENT>image_name, ext = filename.rsplit('<STR_LIT:.>', <NUM_LIT:1>)<EOL><DEDENT>except ValueError:<EOL><INDENT>image_name = filename<EOL>ext = '<STR_LIT>'<EOL><DEDENT>return \"<STR_LIT>\" % ({<EOL>'<STR_LIT>': image_name,<EOL>'<STR_LIT>': filename_key,<EOL>'<STR_LIT>': ext<EOL>})<EOL>", "docstring": "Return the 'filtered filename' (according to `filename_key`)\nin the following format:\n`filename`__`filename_key`__.ext", "id": "f3815:m3"}
{"signature": "def build_versatileimagefield_url_set(image_instance, size_set, request=None):", "body": "size_set = validate_versatileimagefield_sizekey_list(size_set)<EOL>to_return = {}<EOL>if image_instance or image_instance.field.placeholder_image:<EOL><INDENT>for key, image_key in size_set:<EOL><INDENT>img_url = get_url_from_image_key(image_instance, image_key)<EOL>if request is not None:<EOL><INDENT>img_url = request.build_absolute_uri(img_url)<EOL><DEDENT>to_return[key] = img_url<EOL><DEDENT><DEDENT>return to_return<EOL>", "docstring": "Return a dictionary of urls corresponding to size_set\n- `image_instance`: A VersatileImageFieldFile\n- `size_set`: An iterable of 2-tuples, both strings. Example:\n    [\n        ('large', 'url'),\n        ('medium', 'crop__400x400'),\n        ('small', 'thumbnail__100x100')\n    ]\n\n    The above would lead to the following response:\n    {\n        'large': 'http://some.url/image.jpg',\n        'medium': 'http://some.url/__sized__/image-crop-400x400.jpg',\n        'small': 'http://some.url/__sized__/image-thumbnail-100x100.jpg',\n    }\n- `request`:", "id": "f3815:m8"}
{"signature": "def get_resized_path(path_to_image, width, height,<EOL>filename_key, storage):", "body": "containing_folder, filename = os.path.split(path_to_image)<EOL>resized_filename = get_resized_filename(<EOL>filename,<EOL>width,<EOL>height,<EOL>filename_key<EOL>)<EOL>joined_path = os.path.join(*[<EOL>VERSATILEIMAGEFIELD_SIZED_DIRNAME,<EOL>containing_folder,<EOL>resized_filename<EOL>]).replace('<STR_LIT:U+0020>', '<STR_LIT>')  <EOL>return joined_path<EOL>", "docstring": "Return a `path_to_image` location on `storage` as dictated by `width`, `height`\nand `filename_key`", "id": "f3815:m2"}
{"signature": "def get_filtered_path(path_to_image, filename_key, storage):", "body": "containing_folder, filename = os.path.split(path_to_image)<EOL>filtered_filename = get_filtered_filename(filename, filename_key)<EOL>path_to_return = os.path.join(*[<EOL>containing_folder,<EOL>VERSATILEIMAGEFIELD_FILTERED_DIRNAME,<EOL>filtered_filename<EOL>])<EOL>path_to_return = path_to_return.replace('<STR_LIT:U+0020>', '<STR_LIT>')<EOL>return path_to_return<EOL>", "docstring": "Return the 'filtered path'", "id": "f3815:m4"}
{"signature": "def process_image(self, image, image_format, **kwargs):", "body": "raise NotImplementedError(<EOL>'<STR_LIT>'<EOL>)<EOL>", "docstring": "Ensure NotImplemented is raised if not overloaded by subclasses.\n\nArguments:\n    * `image`: a PIL Image instance\n    * `image_format`: str, a valid PIL format (i.e. 'JPEG' or 'GIF')\n\nReturns a BytesIO representation of the resized image.\n\nSubclasses MUST implement this method.", "id": "f3817:c0:m1"}
{"signature": "def create_filtered_image(self, path_to_image, save_path_on_storage):", "body": "image, file_ext, image_format, mime_type = self.retrieve_image(<EOL>path_to_image<EOL>)<EOL>image, save_kwargs = self.preprocess(image, image_format)<EOL>imagefile = self.process_image(image, image_format, save_kwargs)<EOL>self.save_image(imagefile, save_path_on_storage, file_ext, mime_type)<EOL>", "docstring": "Creates a filtered image.\n`path_to_image`: The path to the image with the media directory\n                 to resize.\n`save_path_on_storage`: Where on self.storage to save the filtered\n                        image", "id": "f3819:c1:m1"}
{"signature": "def __getitem__(self, key):", "body": "try:<EOL><INDENT>width, height = [int(i) for i in key.split('<STR_LIT:x>')]<EOL><DEDENT>except (KeyError, ValueError):<EOL><INDENT>raise MalformedSizedImageKey(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % self.__class__.__name__<EOL>)<EOL><DEDENT>if not self.path_to_image and getattr(<EOL>settings, '<STR_LIT>', False<EOL>):<EOL><INDENT>resized_url = \"<STR_LIT>\" % (width, height)<EOL>resized_storage_path = resized_url<EOL><DEDENT>else:<EOL><INDENT>resized_storage_path = get_resized_path(<EOL>path_to_image=self.path_to_image,<EOL>width=width,<EOL>height=height,<EOL>filename_key=self.get_filename_key(),<EOL>storage=self.storage<EOL>)<EOL>try:<EOL><INDENT>resized_url = self.storage.url(resized_storage_path)<EOL><DEDENT>except Exception:<EOL><INDENT>resized_url = None<EOL><DEDENT>if self.create_on_demand is True:<EOL><INDENT>if cache.get(resized_url) and resized_url is not None:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>if resized_storage_path and not self.storage.exists(<EOL>resized_storage_path<EOL>):<EOL><INDENT>self.create_resized_image(<EOL>path_to_image=self.path_to_image,<EOL>save_path_on_storage=resized_storage_path,<EOL>width=width,<EOL>height=height<EOL>)<EOL>resized_url = self.storage.url(resized_storage_path)<EOL><DEDENT>cache.set(resized_url, <NUM_LIT:1>, VERSATILEIMAGEFIELD_CACHE_LENGTH)<EOL><DEDENT><DEDENT><DEDENT>return SizedImageInstance(<EOL>name=resized_storage_path,<EOL>url=resized_url,<EOL>storage=self.storage<EOL>)<EOL>", "docstring": "Return a URL to an image sized according to key.\n\nArguments:\n    * `key`: A string in the following format\n             '[width-in-pixels]x[height-in-pixels]'\n             Example: '400x400'", "id": "f3820:c2:m5"}
{"signature": "def ppoi_as_str(self):", "body": "return \"<STR_LIT>\" % (<EOL>str(self.ppoi[<NUM_LIT:0>]).replace('<STR_LIT:.>', '<STR_LIT:->'),<EOL>str(self.ppoi[<NUM_LIT:1>]).replace('<STR_LIT:.>', '<STR_LIT:->')<EOL>)<EOL>", "docstring": "Return PPOI value as a string.", "id": "f3820:c2:m1"}
{"signature": "def process_image(self, image, image_format, save_kwargs={}):", "body": "imagefile = BytesIO()<EOL>inv_image = ImageOps.invert(image)<EOL>inv_image.save(<EOL>imagefile,<EOL>**save_kwargs<EOL>)<EOL>return imagefile<EOL>", "docstring": "Return a BytesIO instance of `image` with inverted colors.", "id": "f3821:c2:m0"}
{"signature": "def get_filename_key(self):", "body": "return \"<STR_LIT>\".format(<EOL>key=self.filename_key,<EOL>ppoi=self.ppoi_as_str()<EOL>)<EOL>", "docstring": "Return the filename key for cropped images.", "id": "f3821:c0:m0"}
{"signature": "def get_usage(self, subcommand):", "body": "return self.usage or '<STR_LIT>'.format(subcommand=subcommand)<EOL>", "docstring": "Return a brief description of how to use this command, by\ndefault from the attribute ``self.help``.", "id": "f3830:c0:m1"}
{"signature": "def __init__(self, app, client):", "body": "self.app = app<EOL>self.client = client<EOL>", "docstring": ":param app: WSGI application object\n:param client: Instance of StackSentinel", "id": "f3838:c2:m0"}
{"signature": "@staticmethod<EOL><INDENT>def _serialize_object(obj):<DEDENT>", "body": "try:<EOL><INDENT>return repr(obj)<EOL><DEDENT>except:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>", "docstring": "When the state of an exception includes something that we can't pickle, show something useful instead.", "id": "f3838:c1:m1"}
{"signature": "def handle_exception(self, exc_info=None, state=None, tags=None, return_feedback_urls=False,<EOL>dry_run=False):", "body": "if not exc_info:<EOL><INDENT>exc_info = sys.exc_info()<EOL><DEDENT>if exc_info is None:<EOL><INDENT>raise StackSentinelError(\"<STR_LIT>\")<EOL><DEDENT>(etype, value, tb) = exc_info<EOL>try:<EOL><INDENT>msg = value.args[<NUM_LIT:0>]<EOL><DEDENT>except:<EOL><INDENT>msg = repr(value)<EOL><DEDENT>if not isinstance(tags, list):<EOL><INDENT>tags = [tags]<EOL><DEDENT>limit = None<EOL>new_tb = []<EOL>n = <NUM_LIT:0><EOL>while tb is not None and (limit is None or n < limit):<EOL><INDENT>f = tb.tb_frame<EOL>lineno = tb.tb_lineno<EOL>co = f.f_code<EOL>filename = co.co_filename<EOL>name = co.co_name<EOL>tb = tb.tb_next<EOL>n = n + <NUM_LIT:1><EOL>new_tb.append({'<STR_LIT>': lineno, '<STR_LIT>': filename, '<STR_LIT>': name})<EOL><DEDENT>if state is None:<EOL><INDENT>state = {}<EOL><DEDENT>if '<STR_LIT>' not in state:<EOL><INDENT>try:<EOL><INDENT>state['<STR_LIT>'] = self._get_sys_info()<EOL><DEDENT>except Exception as e:<EOL><INDENT>state['<STR_LIT>'] = '<STR_LIT>' % e<EOL><DEDENT><DEDENT>if '<STR_LIT>' not in state:<EOL><INDENT>try:<EOL><INDENT>state['<STR_LIT>'] = self._get_machine_info()<EOL><DEDENT>except Exception as e:<EOL><INDENT>state['<STR_LIT>'] = '<STR_LIT>' % e<EOL><DEDENT><DEDENT>if tags is None:<EOL><INDENT>tags = []<EOL><DEDENT>if sys.version_info.major > <NUM_LIT:2>:<EOL><INDENT>error_type = str(etype.__name__)<EOL>error_message = str(value)<EOL><DEDENT>else:<EOL><INDENT>error_type = unicode(etype.__name__)<EOL>error_message = unicode(value)<EOL><DEDENT>send_error_args = dict(error_type=error_type,<EOL>error_message=error_message,<EOL>traceback=new_tb,<EOL>environment=self.environment,<EOL>state=state,<EOL>tags=self.tags + tags,<EOL>return_feedback_urls=return_feedback_urls)<EOL>if dry_run:<EOL><INDENT>return send_error_args<EOL><DEDENT>else:<EOL><INDENT>return self.send_error(**send_error_args)<EOL><DEDENT>", "docstring": "Call this method from within a try/except clause to generate a call to Stack Sentinel.\n\n:param exc_info: Return value of sys.exc_info(). If you pass None, handle_exception will call sys.exc_info() itself\n:param state: Dictionary of state information associated with the error. This could be form data, cookie data, whatnot. NOTE: sys and machine are added to this dictionary if they are not already included.\n:param tags: Any string tags you want associated with the exception report.\n:param return_feedback_urls: If True, Stack Sentinel will return feedback URLs you can present to the user for extra debugging information.\n:param dry_run: If True, method will not actively send in error information to API. Instead, it will return a request object and payload. Used in unittests.", "id": "f3838:c1:m2"}
{"signature": "def __init__(self, account_token, project_token, environment, tags=None,<EOL>endpoint=\"<STR_LIT>\"):", "body": "self.account_token = account_token<EOL>self.project_token = project_token<EOL>self.endpoint = endpoint<EOL>self.environment = environment<EOL>if tags:<EOL><INDENT>self.tags = tags<EOL><DEDENT>else:<EOL><INDENT>self.tags = []<EOL><DEDENT>", "docstring": ":param account_token: Your account token, as supplied by StackSentinel\n:param project_token: Your project token, as supplied by StackSentinel\n:param environment: The environment of the project (eg, \"production\", \"devel\", etc)\n:param tags: Any tags you want associated with *all* errors sent using this client.\n:param endpoint: API endpoint. Defaults to StackSentinel backend.", "id": "f3838:c1:m0"}
{"signature": "def as_string(self, default_from=None):", "body": "encoding = self.charset or '<STR_LIT:utf-8>'<EOL>attachments = self.attachments or []<EOL>if len(attachments) == <NUM_LIT:0> and not self.html:<EOL><INDENT>msg = self._mimetext(self.body)<EOL><DEDENT>elif len(attachments) > <NUM_LIT:0> and not self.html:<EOL><INDENT>msg = MIMEMultipart()<EOL>msg.attach(self._mimetext(self.body))<EOL><DEDENT>else:<EOL><INDENT>msg = MIMEMultipart()<EOL>alternative = MIMEMultipart('<STR_LIT>')<EOL>alternative.attach(self._mimetext(self.body, '<STR_LIT>'))<EOL>alternative.attach(self._mimetext(self.html, '<STR_LIT:html>'))<EOL>msg.attach(alternative)<EOL><DEDENT>if self.charset:<EOL><INDENT>msg['<STR_LIT>'] = Header(self.subject, encoding)<EOL><DEDENT>else:<EOL><INDENT>msg['<STR_LIT>'] = self.subject<EOL><DEDENT>sender = self.sender or default_from<EOL>if sender is not None:<EOL><INDENT>msg['<STR_LIT>'] = sanitize_address(sender, encoding)<EOL><DEDENT>msg['<STR_LIT>'] = '<STR_LIT:U+002CU+0020>'.join(list(set(sanitize_addresses(self.recipients, encoding))))<EOL>msg['<STR_LIT>'] = formatdate(self.date, localtime=True)<EOL>msg['<STR_LIT>'] = self.msgId<EOL>if self.cc:<EOL><INDENT>msg['<STR_LIT>'] = '<STR_LIT:U+002CU+0020>'.join(list(set(sanitize_addresses(self.cc, encoding))))<EOL><DEDENT>if self.reply_to:<EOL><INDENT>msg['<STR_LIT>'] = sanitize_address(self.reply_to, encoding)<EOL><DEDENT>if self.extra_headers:<EOL><INDENT>for k, v in self.extra_headers.items():<EOL><INDENT>msg[k] = v<EOL><DEDENT><DEDENT>for attachment in attachments:<EOL><INDENT>f = MIMEBase(*attachment.content_type.split('<STR_LIT:/>'))<EOL>f.set_payload(attachment.data)<EOL>encode_base64(f)<EOL>try:<EOL><INDENT>attachment.filename and attachment.filename.encode('<STR_LIT:ascii>')<EOL><DEDENT>except UnicodeEncodeError:<EOL><INDENT>filename = attachment.filename<EOL>if not PY3:<EOL><INDENT>filename = filename.encode('<STR_LIT:utf8>')<EOL><DEDENT>f.add_header('<STR_LIT>', attachment.disposition,<EOL>filename=('<STR_LIT>', '<STR_LIT>', filename))<EOL><DEDENT>else:<EOL><INDENT>f.add_header('<STR_LIT>', '<STR_LIT>' %<EOL>(attachment.disposition, attachment.filename))<EOL><DEDENT>for key, value in attachment.headers:<EOL><INDENT>f.add_header(key, value)<EOL><DEDENT>msg.attach(f)<EOL><DEDENT>return msg.as_string()<EOL>", "docstring": "Creates the email", "id": "f3840:c4:m3"}
{"signature": "def send(self, message):", "body": "with self.connect() as connection:<EOL><INDENT>message.send(connection)<EOL><DEDENT>", "docstring": "Sends a single message instance. If TESTING is True the message will\n        not actually be sent.\n\n        :param message: a Message instance.", "id": "f3840:c5:m6"}
{"signature": "def send(self, connection):", "body": "connection.send(self)<EOL>", "docstring": "Verifies and sends the message.", "id": "f3840:c4:m7"}
{"signature": "def attach(self,<EOL>filename=None,<EOL>content_type=None,<EOL>data=None,<EOL>disposition=None,<EOL>headers=None):", "body": "self.attachments.append(<EOL>Attachment(filename, content_type, data, disposition, headers))<EOL>", "docstring": "Adds an attachment to the message.\n\n        :param filename: filename of attachment\n        :param content_type: file mimetype\n        :param data: the raw file data\n        :param disposition: content-disposition (if any)", "id": "f3840:c4:m9"}
{"signature": "def shortDescription(self):", "body": "doc = self.id()[self.id().rfind('<STR_LIT:.>')+<NUM_LIT:1>:]<EOL>return \"<STR_LIT>\" % (self.__class__.__name__, doc)<EOL>", "docstring": "Get's the one liner description to be displayed.\nSource:\nhttp://erikzaadi.com/2012/09/13/inheritance-within-python-unit-tests/", "id": "f3845:c0:m0"}
{"signature": "def iter_verbs(self, c):", "body": "for verb in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>yield getattr(c, verb)<EOL><DEDENT>", "docstring": "A simple helper method to iterate through a range of\n            HTTP Verbs and return the test_client bound instance,\n            keeping writing our tests as DRY as possible.", "id": "f3845:c0:m1"}
{"signature": "@app.route(\"<STR_LIT>\", methods=['<STR_LIT:GET>', '<STR_LIT>'])<EOL>def list_users(request):", "body": "return json({\"<STR_LIT:user>\": \"<STR_LIT>\"})<EOL>", "docstring": "Since the path matches the regular expression r'/api/*', this resource\nautomatically has CORS headers set. The expected result is as follows:\n\n$ curl --include -X GET http://127.0.0.1:5000/api/v1/users/ \\\n    --header Origin:www.examplesite.com\nHTTP/1.0 200 OK\nAccess-Control-Allow-Headers: Content-Type\nAccess-Control-Allow-Origin: *\nContent-Length: 21\nContent-Type: application/json\nDate: Sat, 09 Aug 2014 00:26:41 GMT\nServer: Werkzeug/0.9.4 Python/2.7.8\n\n{\n    \"success\": true\n}", "id": "f3863:m1"}
{"signature": "def cross_origin(app, *args, **kwargs):", "body": "_options = kwargs<EOL>_real_decorator = cors.decorate(app, *args, run_middleware=False, with_context=False, **kwargs)<EOL>def wrapped_decorator(f):<EOL><INDENT>spf = SanicPluginsFramework(app)  <EOL>try:<EOL><INDENT>plugin = spf.register_plugin(cors, skip_reg=True)<EOL><DEDENT>except ValueError as e:<EOL><INDENT>assert e.args and len(e.args) > <NUM_LIT:1><EOL>plugin = e.args[<NUM_LIT:1>]<EOL><DEDENT>context = cors.get_context_from_spf(spf)<EOL>log = context.log<EOL>log(logging.DEBUG, \"<STR_LIT>\".format(str(f), str(_options)))<EOL>return _real_decorator(f)<EOL><DEDENT>return wrapped_decorator<EOL>", "docstring": "This function is the decorator which is used to wrap a Sanic route with.\nIn the simplest case, simply use the default parameters to allow all\norigins in what is the most permissive configuration. If this method\nmodifies state or performs authentication which may be brute-forced, you\nshould add some degree of protection, such as Cross Site Forgery\nRequest protection.\n\n:param origins:\n    The origin, or list of origins to allow requests from.\n    The origin(s) may be regular expressions, case-sensitive strings,\n    or else an asterisk\n\n    Default : '*'\n:type origins: list, string or regex\n\n:param methods:\n    The method or list of methods which the allowed origins are allowed to\n    access for non-simple requests.\n\n    Default : [GET, HEAD, POST, OPTIONS, PUT, PATCH, DELETE]\n:type methods: list or string\n\n:param expose_headers:\n    The header or list which are safe to expose to the API of a CORS API\n    specification.\n\n    Default : None\n:type expose_headers: list or string\n\n:param allow_headers:\n    The header or list of header field names which can be used when this\n    resource is accessed by allowed origins. The header(s) may be regular\n    expressions, case-sensitive strings, or else an asterisk.\n\n    Default : '*', allow all headers\n:type allow_headers: list, string or regex\n\n:param supports_credentials:\n    Allows users to make authenticated requests. If true, injects the\n    `Access-Control-Allow-Credentials` header in responses. This allows\n    cookies and credentials to be submitted across domains.\n\n    :note: This option cannot be used in conjuction with a '*' origin\n\n    Default : False\n:type supports_credentials: bool\n\n:param max_age:\n    The maximum time for which this CORS request maybe cached. This value\n    is set as the `Access-Control-Max-Age` header.\n\n    Default : None\n:type max_age: timedelta, integer, string or None\n\n:param send_wildcard: If True, and the origins parameter is `*`, a wildcard\n    `Access-Control-Allow-Origin` header is sent, rather than the\n    request's `Origin` header.\n\n    Default : False\n:type send_wildcard: bool\n\n:param vary_header:\n    If True, the header Vary: Origin will be returned as per the W3\n    implementation guidelines.\n\n    Setting this header when the `Access-Control-Allow-Origin` is\n    dynamically generated (e.g. when there is more than one allowed\n    origin, and an Origin than '*' is returned) informs CDNs and other\n    caches that the CORS headers are dynamic, and cannot be cached.\n\n    If False, the Vary header will never be injected or altered.\n\n    Default : True\n:type vary_header: bool\n\n:param automatic_options:\n    Only applies to the `cross_origin` decorator. If True, Sanic-CORS will\n    override Sanic's default OPTIONS handling to return CORS headers for\n    OPTIONS requests.\n\n    Default : True\n:type automatic_options: bool", "id": "f3866:m0"}
{"signature": "def serialize_options(opts):", "body": "options = (opts or {}).copy()<EOL>for key in opts.keys():<EOL><INDENT>if key not in DEFAULT_OPTIONS:<EOL><INDENT>LOG.warning(\"<STR_LIT>\", key)<EOL><DEDENT><DEDENT>options['<STR_LIT>'] = sanitize_regex_param(options.get('<STR_LIT>'))<EOL>options['<STR_LIT>'] = sanitize_regex_param(options.get('<STR_LIT>'))<EOL>if r'<STR_LIT>' in options['<STR_LIT>'] and options['<STR_LIT>'] and options['<STR_LIT>']:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>serialize_option(options, '<STR_LIT>')<EOL>serialize_option(options, '<STR_LIT>', upper=True)<EOL>if isinstance(options.get('<STR_LIT>'), timedelta):<EOL><INDENT>options['<STR_LIT>'] = str(int(options['<STR_LIT>'].total_seconds()))<EOL><DEDENT>return options<EOL>", "docstring": "A helper method to serialize and processes the options dictionary.", "id": "f3868:m16"}
{"signature": "def set_cors_headers(req, resp, context, options):", "body": "try:<EOL><INDENT>request_context = context.request[id(req)]<EOL><DEDENT>except AttributeError:<EOL><INDENT>LOG.debug(\"<STR_LIT>\")<EOL>return resp<EOL><DEDENT>evaluated = request_context.get(SANIC_CORS_EVALUATED, False)<EOL>if evaluated:<EOL><INDENT>LOG.debug('<STR_LIT>')<EOL>return resp<EOL><DEDENT>if resp is None:<EOL><INDENT>return None<EOL><DEDENT>if resp.headers is None:<EOL><INDENT>resp.headers = CIMultiDict()<EOL><DEDENT>headers_to_set = get_cors_headers(options, req.headers, req.method)<EOL>LOG.debug('<STR_LIT>', str(headers_to_set))<EOL>try:<EOL><INDENT>resp.headers.extend(headers_to_set)<EOL><DEDENT>except Exception as e1:<EOL><INDENT>for k, v in headers_to_set.items():<EOL><INDENT>try:<EOL><INDENT>resp.headers.add(k, v)<EOL><DEDENT>except Exception as e2:<EOL><INDENT>resp.headers[k] = v<EOL><DEDENT><DEDENT>return resp<EOL><DEDENT>", "docstring": "Performs the actual evaluation of Sanic-CORS options and actually\nmodifies the response object.\n\nThis function is used both in the decorator and the after_request\ncallback\n:param sanic.request.Request req:", "id": "f3868:m5"}
{"signature": "def make_osm_query(query):", "body": "osm_url = '<STR_LIT>'<EOL>req = requests.get(osm_url, params={'<STR_LIT:data>': query})<EOL>req.raise_for_status()<EOL>return req.json()<EOL>", "docstring": "Make a request to OSM and return the parsed JSON.\n\nParameters\n----------\nquery : str\n    A string in the Overpass QL format.\n\nReturns\n-------\ndata : dict", "id": "f3881:m2"}
{"signature": "def pdna_network_from_bbox(<EOL>lat_min=None, lng_min=None, lat_max=None, lng_max=None, bbox=None,<EOL>network_type='<STR_LIT>', two_way=True,<EOL>timeout=<NUM_LIT>, memory=None, max_query_area_size=<NUM_LIT:50> * <NUM_LIT:1000> * <NUM_LIT:50> * <NUM_LIT:1000>):", "body": "nodes, edges = network_from_bbox(lat_min=lat_min, lng_min=lng_min,<EOL>lat_max=lat_max, lng_max=lng_max,<EOL>bbox=bbox, network_type=network_type,<EOL>two_way=two_way, timeout=timeout,<EOL>memory=memory,<EOL>max_query_area_size=max_query_area_size)<EOL>return Network(<EOL>nodes['<STR_LIT:x>'], nodes['<STR_LIT:y>'],<EOL>edges['<STR_LIT>'], edges['<STR_LIT:to>'], edges[['<STR_LIT>']])<EOL>", "docstring": "Make a Pandana network from a bounding lat/lon box\nrequest to the Overpass API. Distance will be in the default units meters.\n\nParameters\n----------\nlat_min, lng_min, lat_max, lng_max : float\nbbox : tuple\n    Bounding box formatted as a 4 element tuple:\n    (lng_max, lat_min, lng_min, lat_max)\nnetwork_type : {'walk', 'drive'}, optional\n    Specify whether the network will be used for walking or driving.\n    A value of 'walk' attempts to exclude things like freeways,\n    while a value of 'drive' attempts to exclude things like\n    bike and walking paths.\ntwo_way : bool, optional\n    Whether the routes are two-way. If True, node pairs will only\n    occur once.\ntimeout : int, optional\n    the timeout interval for requests and to pass to Overpass API\nmemory : int, optional\n    server memory allocation size for the query, in bytes.\n    If none, server will use its default allocation size\nmax_query_area_size : float, optional\n    max area for any part of the geometry, in the units the geometry is in\n\nReturns\n-------\nnetwork : pandana.Network", "id": "f3881:m0"}
{"signature": "@classmethod<EOL><INDENT>def from_hdf5(cls, filename):<DEDENT>", "body": "return ph5.network_from_pandas_hdf5(cls, filename)<EOL>", "docstring": "Load a previously saved Network from a Pandas HDF5 file.\n\nParameters\n----------\nfilename : str\n\nReturns\n-------\nnetwork : pandana.Network", "id": "f3884:c0:m1"}
{"signature": "def save_hdf5(self, filename, rm_nodes=None):", "body": "ph5.network_to_pandas_hdf5(self, filename, rm_nodes)<EOL>", "docstring": "Save network data to a Pandas HDF5 file.\n\nOnly the nodes and edges of the actual network are saved,\npoints-of-interest and data attached to nodes are not saved.\n\nParameters\n----------\nfilename : str\nrm_nodes : array_like\n    A list, array, Index, or Series of node IDs that should *not*\n    be saved as part of the Network.", "id": "f3884:c0:m2"}
{"signature": "def get_node_ids(self, x_col, y_col, mapping_distance=None):", "body": "xys = pd.DataFrame({'<STR_LIT:x>': x_col, '<STR_LIT:y>': y_col})<EOL>distances, indexes = self.kdtree.query(xys.as_matrix())<EOL>indexes = np.transpose(indexes)[<NUM_LIT:0>]<EOL>distances = np.transpose(distances)[<NUM_LIT:0>]<EOL>node_ids = self.nodes_df.iloc[indexes].index<EOL>df = pd.DataFrame({\"<STR_LIT>\": node_ids, \"<STR_LIT>\": distances},<EOL>index=xys.index)<EOL>if mapping_distance is not None:<EOL><INDENT>df = df[df.distance <= mapping_distance]<EOL><DEDENT>return df.node_id<EOL>", "docstring": "Assign node_ids to data specified by x_col and y_col\n\nParameters\n----------\nx_col : Pandas series (float)\n    A Pandas Series where values specify the x (e.g. longitude)\n    location of dataset.\ny_col : Pandas series (float)\n    A Pandas Series where values specify the y (e.g. latitude)\n    location of dataset.  x_col and y_col should use the same index.\nmapping_distance : float, optional\n    The maximum distance that will be considered a match between the\n    x, y data and the nearest node in the network.  This will usually\n    be a distance unit in meters however if you have customized the\n    impedance this could be in other units such as utility or time\n    etc. If not specified, every x, y coordinate will be mapped to\n    the nearest node.\n\nReturns\n-------\nnode_ids : Pandas series (int)\n    Returns a Pandas Series of node_ids for each x, y in the\n    input data. The index is the same as the indexes of the\n    x, y input data, and the values are the mapped node_ids.\n    If mapping distance is not passed and if there are no nans in the\n    x, y data, this will be the same length as the x, y data.\n    If the mapping is imperfect, this function returns all the\n    input x, y's that were successfully mapped to node_ids.", "id": "f3884:c0:m13"}
{"signature": "def low_connectivity_nodes(self, impedance, count, imp_name=None):", "body": "<EOL>self.set(self.node_ids.to_series(), name='<STR_LIT>')<EOL>agg = self.aggregate(<EOL>impedance, type='<STR_LIT:count>', imp_name=imp_name, name='<STR_LIT>')<EOL>return np.array(agg[agg < count].index)<EOL>", "docstring": "Identify nodes that are connected to fewer than some threshold\nof other nodes within a given distance.\n\nParameters\n----------\nimpedance : float\n    Distance within which to search for other connected nodes. This\n    will usually be a distance unit in meters however if you have\n    customized the impedance this could be in other units such as\n    utility or time etc.\ncount : int\n    Threshold for connectivity. If a node is connected to fewer\n    than this many nodes within `impedance` it will be identified\n    as \"low connectivity\".\nimp_name : string, optional\n    The impedance name to use for the aggregation on this network.\n    Must be one of the impedance names passed in the constructor of\n    this object.  If not specified, there must be only one impedance\n    passed in the constructor, which will be used.\n\nReturns\n-------\nnode_ids : array\n    List of \"low connectivity\" node IDs.", "id": "f3884:c0:m17"}
{"signature": "def accuracy(conf_matrix):", "body": "total, correct = <NUM_LIT:0.0>, <NUM_LIT:0.0><EOL>for true_response, guess_dict in list(conf_matrix.items()):<EOL><INDENT>for guess, count in list(guess_dict.items()):<EOL><INDENT>if true_response == guess:<EOL><INDENT>correct += count<EOL><DEDENT>total += count<EOL><DEDENT><DEDENT>return correct/total<EOL>", "docstring": "Given a confusion matrix, returns the accuracy.\nAccuracy Definition: http://research.ics.aalto.fi/events/eyechallenge2005/evaluation.shtml", "id": "f3889:m0"}
{"signature": "def list_to_tf_input(data, response_index, num_outcomes):", "body": "matrix = np.matrix([row[:response_index] + row[response_index+<NUM_LIT:1>:] for row in data])<EOL>outcomes = np.asarray([row[response_index] for row in data], dtype=np.uint8)<EOL>return matrix, outcomes<EOL>", "docstring": "Separates the outcome feature from the data.", "id": "f3905:m0"}
{"signature": "def expand_and_standardize_dataset(response_index, response_header, data_set, col_vals, headers, standardizers, feats_to_ignore, columns_to_expand, outcome_trans_dict):", "body": "<EOL>modified_set = []<EOL>for row_index, row in enumerate(data_set):<EOL><INDENT>new_row = []<EOL>for col_index, val in enumerate(row):<EOL><INDENT>header = headers[col_index]<EOL>if col_index == response_index:<EOL><INDENT>new_outcome = outcome_trans_dict[val]<EOL>new_row.append(new_outcome)<EOL><DEDENT>elif header in feats_to_ignore:<EOL><INDENT>pass<EOL><DEDENT>elif header in columns_to_expand:<EOL><INDENT>for poss_val in col_vals[header]:<EOL><INDENT>if val == poss_val:<EOL><INDENT>new_cat_val = <NUM_LIT:1.0><EOL><DEDENT>else:<EOL><INDENT>new_cat_val = -<NUM_LIT:1.0><EOL><DEDENT>new_row.append(new_cat_val)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>new_cont_val = float((val - standardizers[header]['<STR_LIT>']) / standardizers[header]['<STR_LIT>'])<EOL>new_row.append(new_cont_val)<EOL><DEDENT><DEDENT>modified_set.append(new_row)<EOL><DEDENT>expanded_headers = []<EOL>for header in headers:<EOL><INDENT>if header in feats_to_ignore:<EOL><INDENT>pass<EOL><DEDENT>elif (header in columns_to_expand) and (header is not response_header):<EOL><INDENT>for poss_val in col_vals[header]:<EOL><INDENT>new_header = '<STR_LIT>'.format(header,poss_val)<EOL>expanded_headers.append(new_header)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>expanded_headers.append(header)<EOL><DEDENT><DEDENT>return modified_set, expanded_headers<EOL>", "docstring": "Standardizes continuous features and expands categorical features.", "id": "f3908:m1"}
{"signature": "def list_to_tf_input(data, response_index, num_outcomes):", "body": "matrix = np.matrix([row[:response_index] + row[response_index+<NUM_LIT:1>:] for row in data])<EOL>outcomes = np.asarray([row[response_index] for row in data], dtype=np.uint8)<EOL>outcomes_onehot = (np.arange(num_outcomes) == outcomes[:, None]).astype(np.float32)<EOL>return matrix, outcomes_onehot<EOL>", "docstring": "Separates the outcome feature from the data and creates the onehot vector for each row.", "id": "f3911:m0"}
{"signature": "def __init__(self, all_data, feature_to_repair, repair_level, kdd, features_to_ignore=[]):", "body": "self.all_data = all_data<EOL>self.feature_to_repair = feature_to_repair<EOL>self.repair_level = repair_level<EOL>self.kdd = kdd<EOL>self.features_to_ignore = features_to_ignore<EOL>", "docstring": "all_data should be a list of rows (ie, a list of lists) composing the entire\ntest and training dataset. Headers should not be included in data sets.\n\nfeature_to_repair should be the index of the feature to repair. (ie, 0 to k)\nwhere k is the number of features in the dataset.\n\nrepair_level should be a float between [0,1] representing the level of repair.\n\nfeatures_to_ignore should be a list of feature indexes that should be ignored.", "id": "f3941:c0:m0"}
{"signature": "@abstractmethod<EOL><INDENT>def repair(self, data_to_repair):<DEDENT>", "body": "pass<EOL>", "docstring": "data_to_repair is the list of rows that actually should be repaired.", "id": "f3941:c0:m1"}
{"signature": "def get_median(values, kdd):", "body": "if not values:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>sorted_values = deepcopy(values)<EOL>sorted_values.sort() <EOL>if kdd:<EOL><INDENT>return sorted_values[len(values)/<NUM_LIT:2>]<EOL><DEDENT>else:<EOL><INDENT>if len(values) % <NUM_LIT:2> == <NUM_LIT:0>:<EOL><INDENT>return sorted_values[len(values)/<NUM_LIT:2>-<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>return sorted_values[len(values)/<NUM_LIT:2>]<EOL><DEDENT><DEDENT>", "docstring": "Given an unsorted list of numeric values, return median value (as a float).\nNote that in the case of even-length lists of values, we apply the value to\nthe left of the center to be the median (such that the median can only be\na value from the list of values).\nEg: get_median([1,2,3,4]) == 2, not 2.5.", "id": "f3945:m0"}
{"signature": "def _blame_line(self, traceback):", "body": "key = None<EOL>blamed_entry = None<EOL>email_recipients = []<EOL>for stack_line in traceback:<EOL><INDENT>line_type = self._get_line_type(stack_line)<EOL>if line_type == api_ttypes.LineType.THIRDPARTY_WHITELIST:<EOL><INDENT>return None, None, None, True<EOL><DEDENT>elif line_type in [api_ttypes.LineType.DEFAULT, api_ttypes.LineType.KNOWN_ERROR]:<EOL><INDENT>filepath = self._get_basepath(stack_line.filename)<EOL>entry = api_ttypes.CodeIdentifier(filepath, stack_line.function_name, stack_line.text)<EOL>blamed_entry = entry<EOL>key = api_ttypes.ErrorKey(filepath, stack_line.line_number, stack_line.function_name, stack_line.text)<EOL>if filepath in self.watch_all_errors:<EOL><INDENT>email_recipients.extend(self.watch_all_errors[filepath])<EOL><DEDENT><DEDENT><DEDENT>return (key, blamed_entry, email_recipients, False)<EOL>", "docstring": "Figures out which line in traceback is to blame for the error.\n        Returns a 3-tuple of (ErrorKey, StackTraceEntry, [email recipients])", "id": "f3985:c0:m8"}
{"signature": "def migrate_thrift_obj(self, obj):", "body": "if not hasattr(obj, \"<STR_LIT>\"):<EOL><INDENT>return<EOL><DEDENT>obj_key_set = set(obj.__dict__.keys())<EOL>thrift_field_map = {t[<NUM_LIT:2>]: t[<NUM_LIT:4>] for t in obj.thrift_spec if t}<EOL>obj.__dict__.update({f: copy.copy(thrift_field_map[f]) for f in set(thrift_field_map.keys()) - obj_key_set})<EOL>for value in obj.__dict__.values():<EOL><INDENT>self.migrate_thrift_obj(value)<EOL><DEDENT>", "docstring": "Helper function that can be called when serializing/deserializing thrift objects whose definitions\n        have changed, we need to make sure we initialize the new attributes to their default value", "id": "f3996:c0:m4"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def iteritems(self):<DEDENT>", "body": "pass<EOL>", "docstring": "Should return iterator of tuples (key, value) for all entries for the given self.partition", "id": "f3996:c0:m5"}
{"signature": "def open(self):", "body": "pass<EOL>", "docstring": "Called to create connection to storage", "id": "f3996:c0:m1"}
{"signature": "@property<EOL><INDENT>def detail(self):<DEDENT>", "body": "if hasattr(self, '<STR_LIT>'):<EOL><INDENT>return self._detail<EOL><DEDENT>else:<EOL><INDENT>self.get_detail()<EOL>return self._detail<EOL><DEDENT>", "docstring": "\u4e2a\u4eba\u4fe1\u606f,\u5982\u679c\u672a\u8c03\u7528\u8fc7``get_detail()``\u4f1a\u81ea\u52a8\u8c03\u7528\n\n:return: information of student\n:rtype: dict", "id": "f4089:c1:m9"}
{"signature": "@property<EOL><INDENT>def _echo(self):<DEDENT>", "body": "return random.randint(<NUM_LIT:1>, <NUM_LIT:9>)<EOL>", "docstring": "\u751f\u6210\u4e00\u4e2a\u968f\u673a\u6570,\u7528\u6765\u505a\u6570\u636e\u6821\u9a8c\n\n:return:\n:rtype: int", "id": "f4089:c1:m4"}
{"signature": "def get_comment_lesson_info(self):  ", "body": "echo = self._echo<EOL>response = self._post('<STR_LIT>',<EOL>data=self._aodata(echo, ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']), )<EOL>if self._check_response(response, echo=echo):<EOL><INDENT>return response['<STR_LIT:object>']['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>self._unexpected(response)<EOL><DEDENT>", "docstring": "\u83b7\u53d6\u6559\u5b66\u8bc4\u4f30\u5185\u6240\u6709\u9700\u8981\u8bfe\u7a0b\n\n:return: \u8fd4\u56de\u6240\u4ee5\u6709\u9700\u8981\u8fdb\u884c\u6559\u5b66\u8bc4\u4f30\u7684\u8bfe\u7a0b\n:rtype: list", "id": "f4089:c1:m22"}
{"signature": "def login(self):", "body": "if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>self.last_connect = time.time()<EOL>s = requests.session()<EOL>s.get('<STR_LIT>')<EOL>data = {<EOL>'<STR_LIT>': self.student_id,<EOL>'<STR_LIT>': self.password_md5<EOL>}<EOL>r6 = s.post('<STR_LIT>', headers={<EOL>'<STR_LIT>': self._ua},<EOL>data=data)<EOL>if r6.text == '<STR_LIT>':<EOL><INDENT>return s<EOL><DEDENT>else:<EOL><INDENT>s.close()<EOL>raise AuthFailure(r6.text)<EOL><DEDENT><DEDENT>", "docstring": "\u767b\u9646\u7cfb\u7edf,\u8fd4\u56de\u4e00\u4e2arequests\u7684session\u5bf9\u8c61\n\n:return: session with login cookies\n:rtype: requests.sessions.Session", "id": "f4089:c1:m5"}
{"signature": "def __init__(self, student_id, password, user_agent=None):", "body": "self.student_id = student_id<EOL>self.password = password<EOL>self.password_md5 = hashlib.md5(self.password.encode('<STR_LIT:utf-8>')).hexdigest()<EOL>self.post_headers = {'<STR_LIT:Content-Type>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'}<EOL>self._ua = '<STR_LIT>''<STR_LIT>'<EOL>if user_agent:<EOL><INDENT>self._ua = user_agent<EOL><DEDENT>self.session = self.login()<EOL>", "docstring": ":param student_id: student_id of jw system\n:type student_id: str\n:param password: password\n:type password: str\n:param user_agent: User-agent you want to use when requesting the website, default ua is chrome 60.0.3112.113\n:type user_agent: str", "id": "f4089:c1:m0"}
{"signature": "def get_raw_now_score(self):", "body": "echo = self._echo<EOL>response = self._post(\"<STR_LIT>\",<EOL>data=self._aodata(echo,<EOL>columns=[\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\"]))<EOL>if self._check_response(response, echo):<EOL><INDENT>self._raw_now_score = response<EOL>return self._raw_now_score<EOL><DEDENT>else:<EOL><INDENT>self._unexpected(response)<EOL><DEDENT>", "docstring": ":rtype: dict\n:return: list[dict]", "id": "f4089:c1:m13"}
{"signature": "@classmethod<EOL><INDENT>def from_yaml(cls, defaults, **kwargs):<DEDENT>", "body": "<EOL>if \"<STR_LIT>\" not in defaults:<EOL><INDENT>kwargs[\"<STR_LIT>\"] = None<EOL><DEDENT>defaults = copy.deepcopy(defaults)<EOL>return cls(<EOL>defaults=defaults,<EOL>token=kwargs.pop(\"<STR_LIT>\"),<EOL>directory=kwargs.pop(\"<STR_LIT>\"),<EOL>**kwargs<EOL>)<EOL>", "docstring": "Creates a new instance of a rule by merging two dictionaries.\n\n        This allows for independant configuration files to be merged\n        into the defaults.", "id": "f4091:c2:m0"}
{"signature": "def execute_actions(self, cwd):", "body": "self._execute_globals(cwd)<EOL>for action in self.actions:<EOL><INDENT>logger.info(\"<STR_LIT>\".format(action))<EOL>p = subprocess.Popen(action, shell=True, cwd=cwd)<EOL>p.wait()<EOL><DEDENT>", "docstring": "Iterates over the actions and executes them in order.", "id": "f4091:c1:m4"}
{"signature": "def main():", "body": "<EOL>parser = create_parser()<EOL>args = parser.parse_args()<EOL>check_arguments(args, parser)<EOL>run(parser, args)<EOL>", "docstring": "Initialize and run command line interface.", "id": "f4106:m7"}
{"signature": "def clean_code(code, comments=True, macros=False, pragmas=False):", "body": "if macros or pragmas:<EOL><INDENT>lines = code.split('<STR_LIT:\\n>')<EOL>in_macro = False<EOL>in_pragma = False<EOL>for i in range(len(lines)):<EOL><INDENT>l = lines[i].strip()<EOL>if macros and (l.startswith('<STR_LIT:#>') and not l.startswith('<STR_LIT>') or in_macro):<EOL><INDENT>lines[i] = '<STR_LIT>'<EOL>in_macro = l.endswith('<STR_LIT:\\\\>')<EOL><DEDENT>if pragmas and (l.startswith('<STR_LIT>') or in_pragma):<EOL><INDENT>lines[i] = '<STR_LIT>'<EOL>in_pragma = l.endswith('<STR_LIT:\\\\>')<EOL><DEDENT><DEDENT>code = '<STR_LIT:\\n>'.join(lines)<EOL><DEDENT>if comments:<EOL><INDENT>idx = <NUM_LIT:0><EOL>comment_start = None<EOL>while idx < len(code) - <NUM_LIT:1>:<EOL><INDENT>if comment_start is None and code[idx:idx + <NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>end_idx = code.find('<STR_LIT:\\n>', idx)<EOL>code = code[:idx] + code[end_idx:]<EOL>idx -= end_idx - idx<EOL><DEDENT>elif comment_start is None and code[idx:idx + <NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>comment_start = idx<EOL><DEDENT>elif comment_start is not None and code[idx:idx + <NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>code = (code[:comment_start] +<EOL>'<STR_LIT:\\n>' * code[comment_start:idx].count('<STR_LIT:\\n>') +<EOL>code[idx + <NUM_LIT:2>:])<EOL>idx -= idx - comment_start<EOL>comment_start = None<EOL><DEDENT>idx += <NUM_LIT:1><EOL><DEDENT><DEDENT>return code<EOL>", "docstring": "Naive comment and macro striping from source code\n\n:param comments: If True, all comments are stripped from code\n:param macros: If True, all macros are stripped from code\n:param pragmas: If True, all pragmas are stripped from code\n\n:return: cleaned code. Line numbers are preserved with blank lines,\nand multiline comments and macros are supported. BUT comment-like\nstrings are (wrongfully) treated as comments.", "id": "f4107:m0"}
{"signature": "def report(self, output_file=sys.stdout):", "body": "if self.verbose > <NUM_LIT:2>:<EOL><INDENT>print(\"<STR_LIT>\", file=output_file)<EOL>print(self.results['<STR_LIT>'], file=output_file)<EOL>print('<STR_LIT>', file=output_file)<EOL><DEDENT>if self.verbose > <NUM_LIT:1>:<EOL><INDENT>print('<STR_LIT>'.format(self.results['<STR_LIT>']),<EOL>file=output_file)<EOL>print('<STR_LIT>'.format(<EOL>self.results['<STR_LIT>']), file=output_file)<EOL>print('<STR_LIT>', str(self.results['<STR_LIT>']), file=output_file)<EOL>print('<STR_LIT>', str(self.results['<STR_LIT>']), file=output_file)<EOL>print('<STR_LIT>'.format(self.results['<STR_LIT>'][self._args.unit]),<EOL>file=output_file)<EOL><DEDENT>print('<STR_LIT>'.format(self.results['<STR_LIT>']), file=output_file)<EOL>print('<STR_LIT>'.format(self.results['<STR_LIT>']), file=output_file)<EOL>", "docstring": "Print generated model data in human readable format.", "id": "f4108:c1:m4"}
{"signature": "def report(self, output_file=sys.stdout):", "body": "report = '<STR_LIT>'<EOL>if self.verbose > <NUM_LIT:1>:<EOL><INDENT>self._CPU.report()<EOL>self._data.report()<EOL><DEDENT>report += '<STR_LIT>'.format(<EOL>self.results['<STR_LIT>'],<EOL>self.results['<STR_LIT>'],<EOL>'<STR_LIT>'.join(['<STR_LIT>'.format(i[<NUM_LIT:1>]) for i in self.results['<STR_LIT>']]))<EOL>if self._args.cores > <NUM_LIT:1>:<EOL><INDENT>report += \"<STR_LIT>\"<EOL><DEDENT>report += '<STR_LIT>'.format(self.results['<STR_LIT>'][self._args.unit])<EOL>report += '<STR_LIT>'.format(<EOL>max(self.results['<STR_LIT>'], self.results['<STR_LIT>']),<EOL>'<STR_LIT>'.join(['<STR_LIT>'.format(max(sum([x[<NUM_LIT:1>] for x in self.results['<STR_LIT>'][:i+<NUM_LIT:1>]]) +<EOL>self.results['<STR_LIT>'], self.results['<STR_LIT>']))<EOL>for i in range(len(self.results['<STR_LIT>']))]))<EOL>if self._args.cores > <NUM_LIT:1>:<EOL><INDENT>report += \"<STR_LIT>\"<EOL><DEDENT>report += '<STR_LIT>'.format(self.results['<STR_LIT>'])<EOL>if self.results['<STR_LIT>']:<EOL><INDENT>report += \"<STR_LIT>\".format(self.results['<STR_LIT>']['<STR_LIT>']) +\"<STR_LIT>\"<EOL>report += \"<STR_LIT>\".format(<EOL>self.results['<STR_LIT>']['<STR_LIT>'][self._args.unit],<EOL>'<STR_LIT:U+002CU+0020>'.join(self.results['<STR_LIT>']['<STR_LIT>']))<EOL><DEDENT>if self.results['<STR_LIT>']:<EOL><INDENT>report += \"<STR_LIT>\"\"<STR_LIT>\"<EOL>if self.machine['<STR_LIT>'] > self.machine['<STR_LIT>']:<EOL><INDENT>report += \"<STR_LIT>\" + (len(self._args.unit) - <NUM_LIT:4>) * '<STR_LIT:U+0020>' + '<STR_LIT>' +'<STR_LIT>' * (self.machine['<STR_LIT>']-<NUM_LIT:1>) + '<STR_LIT>'<EOL><DEDENT>report +=  \"<STR_LIT>\" + (len(self._args.unit)+<NUM_LIT:2>)*'<STR_LIT:U+0020>' + \"<STR_LIT>\" + '<STR_LIT>'.join(<EOL>['<STR_LIT>'.format(s['<STR_LIT>']) for s in self.results['<STR_LIT>']]) + '<STR_LIT:\\n>'<EOL>report +=  \"<STR_LIT>\".format(self._args.unit) + '<STR_LIT>'.join(<EOL>['<STR_LIT>'.format(float(s['<STR_LIT>'][self._args.unit]))<EOL>for s in self.results['<STR_LIT>']]) + '<STR_LIT:\\n>'<EOL><DEDENT>print(report, file=output_file)<EOL>if self._args and self._args.ecm_plot:<EOL><INDENT>assert plot_support, \"<STR_LIT>\"<EOL>fig = plt.figure(frameon=False)<EOL>self.plot(fig)<EOL><DEDENT>", "docstring": "Print generated model data in human readable format.", "id": "f4108:c2:m3"}
{"signature": "def plot(self, fig=None):", "body": "if not fig:<EOL><INDENT>fig = plt.gcf()<EOL><DEDENT>fig.subplots_adjust(left=<NUM_LIT:0.1>, right=<NUM_LIT>, top=<NUM_LIT>, bottom=<NUM_LIT>)<EOL>ax = fig.add_subplot(<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>)<EOL>sorted_overlapping_ports = sorted(<EOL>[(p, self.results['<STR_LIT>'][p]) for p in self.machine['<STR_LIT>']],<EOL>key=lambda x: x[<NUM_LIT:1>])<EOL>yticks_labels = []<EOL>yticks = []<EOL>xticks_labels = []<EOL>xticks = []<EOL>height = <NUM_LIT><EOL>i = <NUM_LIT:0><EOL>colors = ([(<NUM_LIT> / <NUM_LIT:255>, <NUM_LIT> / <NUM_LIT>, <NUM_LIT> / <NUM_LIT>)] +<EOL>[(<NUM_LIT> / <NUM_LIT>, <NUM_LIT> / <NUM_LIT>, <NUM_LIT> / <NUM_LIT>)] * (len(sorted_overlapping_ports) - <NUM_LIT:1>))<EOL>for p, c in sorted_overlapping_ports:<EOL><INDENT>ax.barh(i, c, height, align='<STR_LIT>', color=colors.pop(),<EOL>edgecolor=(<NUM_LIT:0.5>, <NUM_LIT:0.5>, <NUM_LIT:0.5>), linestyle='<STR_LIT>')<EOL>if i == len(sorted_overlapping_ports) - <NUM_LIT:1>:<EOL><INDENT>ax.text(c / <NUM_LIT>, i, '<STR_LIT>', ha='<STR_LIT>', va='<STR_LIT>')<EOL><DEDENT>yticks_labels.append(p)<EOL>yticks.append(i)<EOL>i += <NUM_LIT:1><EOL><DEDENT>xticks.append(sorted_overlapping_ports[-<NUM_LIT:1>][<NUM_LIT:1>])<EOL>xticks_labels.append('<STR_LIT>'.format(sorted_overlapping_ports[-<NUM_LIT:1>][<NUM_LIT:1>]))<EOL>y = <NUM_LIT:0><EOL>colors = [(<NUM_LIT> / <NUM_LIT>, <NUM_LIT:255> / <NUM_LIT>, <NUM_LIT> / <NUM_LIT>)] * (len(self.results['<STR_LIT>'])) +[(<NUM_LIT> / <NUM_LIT:255>, <NUM_LIT> / <NUM_LIT>, <NUM_LIT> / <NUM_LIT>)]<EOL>for k, v in [('<STR_LIT>', self.results['<STR_LIT>'])] + self.results['<STR_LIT>']:<EOL><INDENT>ax.barh(i, v, height, y, align='<STR_LIT>', color=colors.pop())<EOL>ax.text(y + v / <NUM_LIT>, i, '<STR_LIT>' + k + '<STR_LIT>', ha='<STR_LIT>', va='<STR_LIT>')<EOL>xticks.append(y + v)<EOL>xticks_labels.append('<STR_LIT>'.format(y + v))<EOL>y += v<EOL><DEDENT>yticks_labels.append('<STR_LIT>')<EOL>yticks.append(i)<EOL>ax.tick_params(axis='<STR_LIT:y>', which='<STR_LIT>', left='<STR_LIT>', right='<STR_LIT>')<EOL>ax.tick_params(axis='<STR_LIT:x>', which='<STR_LIT>', top='<STR_LIT>')<EOL>ax.set_xlabel('<STR_LIT>')<EOL>ax.set_ylabel('<STR_LIT>')<EOL>ax.set_yticks(yticks)<EOL>ax.set_yticklabels(yticks_labels)<EOL>ax.set_xticks(xticks)<EOL>ax.set_xticklabels(xticks_labels, rotation='<STR_LIT>')<EOL>ax.xaxis.grid(alpha=<NUM_LIT>, linestyle='<STR_LIT>')<EOL>fig.savefig(self._args.ecm_plot)<EOL>", "docstring": "Plot visualization of model prediction.", "id": "f4108:c2:m4"}
{"signature": "def analyze(self):", "body": "self.calculate_cache_access()<EOL>self.calculate_cycles()<EOL>self.results['<STR_LIT>'] = sum(self.kernel._flops.values())<EOL>return self.results<EOL>", "docstring": "Run complete anaylysis and return results.", "id": "f4108:c0:m3"}
{"signature": "def __init__(self, kernel, machine, args=None, parser=None, asm_block='<STR_LIT>',<EOL>pointer_increment='<STR_LIT>', verbose=<NUM_LIT:0>):", "body": "self.kernel = kernel<EOL>self.machine = machine<EOL>self._args = args<EOL>self._parser = parser<EOL>self.results = {}<EOL>if args:<EOL><INDENT>self.asm_block = self._args.asm_block<EOL>self.pointer_increment = self._args.pointer_increment<EOL>self.verbose = self._args.verbose<EOL><DEDENT>else:<EOL><INDENT>self.asm_block = asm_block<EOL>self.pointer_increment = pointer_increment<EOL>self.verbose = verbose<EOL><DEDENT>if self.asm_block not in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>try:<EOL><INDENT>self.asm_block = int(args.asm_block)<EOL><DEDENT>except ValueError:<EOL><INDENT>parser.error('<STR_LIT>')<EOL><DEDENT><DEDENT>if self.pointer_increment not in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>try:<EOL><INDENT>self.pointer_increment = int(args.pointer_increment)<EOL><DEDENT>except ValueError:<EOL><INDENT>parser.error('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>", "docstring": "Create Execution-Cache-Memory model from kernel and machine objects.\n\n*kernel* is a Kernel object\n*machine* describes the machine (cpu, cache and memory) characteristics\n*args* (optional) are the parsed arguments from the comand line\nif *args* is given also *parser* has to be provided\n\nIf *args* is None, *asm_block*, *pointer_increment* and *verbose* will be used, otherwise\n*args* takes precedence.", "id": "f4108:c1:m1"}
{"signature": "def blocking(indices, block_size, initial_boundary=<NUM_LIT:0>):", "body": "blocks = []<EOL>for idx in indices:<EOL><INDENT>bl_idx = (idx-initial_boundary)//float(block_size)<EOL>if bl_idx not in blocks:<EOL><INDENT>blocks.append(bl_idx)<EOL><DEDENT><DEDENT>blocks.sort()<EOL>return blocks<EOL>", "docstring": "Split list of integers into blocks of block_size and return block indices.\n\nFirst block element will be located at initial_boundary (default 0).\n\n>>> blocking([0, -1, -2, -3, -4, -5, -6, -7, -8, -9], 8)\n[0,-1]\n>>> blocking([0], 8)\n[0]\n>>> blocking([0], 8, initial_boundary=32)\n[-4]", "id": "f4108:m1"}
{"signature": "@classmethod<EOL><INDENT>def configure_arggroup(cls, parser):<DEDENT>", "body": "<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>", "docstring": "Configure argument parser.", "id": "f4108:c2:m0"}
{"signature": "def conv_cy(self, cy_cl):", "body": "if not isinstance(cy_cl, PrefixedUnit):<EOL><INDENT>cy_cl = PrefixedUnit(cy_cl, '<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>clock = self.machine['<STR_LIT>']<EOL>element_size = self.kernel.datatypes_size[self.kernel.datatype]<EOL>elements_per_cacheline = int(self.machine['<STR_LIT>']) // element_size<EOL>it_s = clock/cy_cl*elements_per_cacheline<EOL>it_s.unit = '<STR_LIT>'<EOL>flops_per_it = sum(self.kernel._flops.values())<EOL>performance = it_s*flops_per_it<EOL>performance.unit = '<STR_LIT>'<EOL>cy_it = cy_cl*elements_per_cacheline<EOL>cy_it.unit = '<STR_LIT>'<EOL>return {'<STR_LIT>': it_s,<EOL>'<STR_LIT>': cy_cl,<EOL>'<STR_LIT>': cy_it,<EOL>'<STR_LIT>': performance}<EOL>", "docstring": "Convert cycles (cy/CL) to other units, such as FLOP/s or It/s.", "id": "f4108:c1:m3"}
{"signature": "def analyze(self):", "body": "try:<EOL><INDENT>incore_analysis, asm_block =  self.kernel.iaca_analysis(<EOL>micro_architecture=self.machine['<STR_LIT>'],<EOL>asm_block=self.asm_block,<EOL>pointer_increment=self.pointer_increment,<EOL>verbose=self.verbose > <NUM_LIT:2>)<EOL><DEDENT>except RuntimeError as e:<EOL><INDENT>print(\"<STR_LIT>\" + str(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>block_throughput = incore_analysis['<STR_LIT>']<EOL>port_cycles = incore_analysis['<STR_LIT>']<EOL>uops = incore_analysis['<STR_LIT>']<EOL>elements_per_block = abs(asm_block['<STR_LIT>']<EOL>// self.kernel.datatypes_size[self.kernel.datatype])<EOL>block_size = elements_per_block*self.kernel.datatypes_size[self.kernel.datatype]<EOL>try:<EOL><INDENT>block_to_cl_ratio = float(self.machine['<STR_LIT>'])/block_size<EOL><DEDENT>except ZeroDivisionError as e:<EOL><INDENT>print(\"<STR_LIT>\", e, file=sys.stderr)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>port_cycles = dict([(i[<NUM_LIT:0>], i[<NUM_LIT:1>]*block_to_cl_ratio) for i in list(port_cycles.items())])<EOL>uops = uops*block_to_cl_ratio<EOL>cl_throughput = block_throughput*block_to_cl_ratio<EOL>T_OL = max([v for k, v in list(port_cycles.items())<EOL>if k in self.machine['<STR_LIT>']['<STR_LIT>']])<EOL>T_nOL = max([v for k, v in list(port_cycles.items())<EOL>if k in self.machine['<STR_LIT>']['<STR_LIT>']])<EOL>if T_nOL < cl_throughput:<EOL><INDENT>T_OL = cl_throughput<EOL><DEDENT>self.results = {<EOL>'<STR_LIT>': port_cycles,<EOL>'<STR_LIT>': self.conv_cy(cl_throughput),<EOL>'<STR_LIT>': uops,<EOL>'<STR_LIT>': T_nOL,<EOL>'<STR_LIT>': T_OL,<EOL>'<STR_LIT>': incore_analysis['<STR_LIT>'],<EOL>'<STR_LIT>': elements_per_block,<EOL>'<STR_LIT>': asm_block['<STR_LIT>'],<EOL>'<STR_LIT>': sum(self.kernel._flops.values())}<EOL>return self.results<EOL>", "docstring": "Run complete analysis and return results.", "id": "f4108:c1:m2"}
{"signature": "def calculate_cache_access(self):", "body": "self.results.update({<EOL>'<STR_LIT>': [],  <EOL>'<STR_LIT>': self.predictor.get_misses(),<EOL>'<STR_LIT>': self.predictor.get_hits(),<EOL>'<STR_LIT>': self.predictor.get_evicts(),<EOL>'<STR_LIT>': self.predictor.get_infos()})<EOL>", "docstring": "Dispatch to cache predictor to get cache stats.", "id": "f4108:c0:m1"}
{"signature": "def calculate_cache_access(self):", "body": "<EOL>element_size = self.kernel.datatypes_size[self.kernel.datatype]<EOL>results = {'<STR_LIT>': {}}<EOL>def sympy_compare(a, b):<EOL><INDENT>c = <NUM_LIT:0><EOL>for i in range(min(len(a), len(b))):<EOL><INDENT>s = a[i] - b[i]<EOL>if sympy.simplify(s > <NUM_LIT:0>):<EOL><INDENT>c = -<NUM_LIT:1><EOL><DEDENT>elif sympy.simplify(s == <NUM_LIT:0>):<EOL><INDENT>c = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>c = <NUM_LIT:1><EOL><DEDENT>if c != <NUM_LIT:0>:<EOL><INDENT>break<EOL><DEDENT><DEDENT>return c<EOL><DEDENT>accesses = defaultdict(list)<EOL>sympy_accesses = defaultdict(list)<EOL>for var_name in self.kernel.variables:<EOL><INDENT>for r in self.kernel.sources.get(var_name, []):<EOL><INDENT>if r is None:<EOL><INDENT>continue<EOL><DEDENT>accesses[var_name].append(r)<EOL>sympy_accesses[var_name].append(self.kernel.access_to_sympy(var_name, r))<EOL><DEDENT>for w in self.kernel.destinations.get(var_name, []):<EOL><INDENT>if w is None:<EOL><INDENT>continue<EOL><DEDENT>accesses[var_name].append(w)<EOL>sympy_accesses[var_name].append(self.kernel.access_to_sympy(var_name, w))<EOL><DEDENT>accesses[var_name].sort(key=cmp_to_key(sympy_compare), reverse=True)<EOL><DEDENT>results['<STR_LIT>'] = accesses<EOL>results['<STR_LIT>'] = sympy_accesses<EOL>for dimension in range(<NUM_LIT:1>, len(list(self.kernel.get_loop_stack()))+<NUM_LIT:1>):<EOL><INDENT>results['<STR_LIT>'][dimension] = {}<EOL>slices = defaultdict(list)<EOL>slices_accesses = defaultdict(list)<EOL>for var_name in accesses:<EOL><INDENT>for a in accesses[var_name]:<EOL><INDENT>slice_id = tuple([var_name, tuple(a[:-dimension])])<EOL>slices[slice_id].append(a)<EOL>slices_accesses[slice_id].append(self.kernel.access_to_sympy(var_name, a))<EOL><DEDENT><DEDENT>results['<STR_LIT>'][dimension]['<STR_LIT>'] = slices<EOL>results['<STR_LIT>'][dimension]['<STR_LIT>'] = slices_accesses<EOL>slices_distances = defaultdict(list)<EOL>for k, v in slices_accesses.items():<EOL><INDENT>for i in range(<NUM_LIT:1>, len(v)):<EOL><INDENT>slices_distances[k].append((v[i] - v[i-<NUM_LIT:1>]).simplify())<EOL><DEDENT><DEDENT>results['<STR_LIT>'][dimension]['<STR_LIT>'] = slices_distances<EOL>for dist in chain(*slices_distances.values()):<EOL><INDENT>if any([s not in self.kernel.constants.keys() for s in dist.free_symbols]):<EOL><INDENT>raise ValueError(\"<STR_LIT>\"+str(dist))<EOL><DEDENT><DEDENT>slices_sum = sum([sum(dists) for dists in slices_distances.values()])<EOL>results['<STR_LIT>'][dimension]['<STR_LIT>'] = slices_sum<EOL>def FuckedUpMax(*args):<EOL><INDENT>if len(args) == <NUM_LIT:1>:<EOL><INDENT>return args[<NUM_LIT:0>]<EOL><DEDENT>args = [a.expand() for a in args]<EOL>max_symbols = max([len(a.free_symbols) for a in args])<EOL>args = list(filter(lambda a: len(a.free_symbols) == max_symbols, args))<EOL>if max_symbols == <NUM_LIT:0>:<EOL><INDENT>return sympy.Max(*args)<EOL><DEDENT>max_coeffs = <NUM_LIT:0><EOL>for a in args:<EOL><INDENT>for s in a.free_symbols:<EOL><INDENT>max_coeffs = max(max_coeffs, len(sympy.Poly(a, s).all_coeffs()))<EOL><DEDENT><DEDENT>def coeff_filter(a):<EOL><INDENT>return max(<EOL><NUM_LIT:0>, <NUM_LIT:0>,<EOL>*[len(sympy.Poly(a, s).all_coeffs()) for s in a.free_symbols]) == max_coeffs<EOL><DEDENT>args = list(filter(coeff_filter, args))<EOL>m = sympy.Max(*args)<EOL>return m<EOL><DEDENT>slices_max = FuckedUpMax(sympy.Integer(<NUM_LIT:0>),<EOL>*[FuckedUpMax(*dists) for dists in slices_distances.values()])<EOL>results['<STR_LIT>'][dimension]['<STR_LIT>'] = slices_max<EOL>slices_count = len(slices_accesses)<EOL>results['<STR_LIT>'][dimension]['<STR_LIT>'] = slices_count<EOL>cache_requirement_bytes = (slices_sum + slices_max*slices_count)*element_size<EOL>results['<STR_LIT>'][dimension]['<STR_LIT>'] = cache_requirement_bytes<EOL>csim = self.machine.get_cachesim(self._args.cores)<EOL>results['<STR_LIT>'][dimension]['<STR_LIT>'] = {}<EOL>for cl in csim.levels(with_mem=False):<EOL><INDENT>cache_equation = sympy.Eq(cache_requirement_bytes, cl.size())<EOL>if len(self.kernel.constants.keys()) <= <NUM_LIT:1>:<EOL><INDENT>inequality = sympy.solve(sympy.LessThan(cache_requirement_bytes, cl.size()),<EOL>*self.kernel.constants.keys())<EOL><DEDENT>else:<EOL><INDENT>inequality = sympy.LessThan(cache_requirement_bytes, cl.size())<EOL><DEDENT>try:<EOL><INDENT>eq = sympy.solve(inequality, *self.kernel.constants.keys(), dict=True)<EOL><DEDENT>except NotImplementedError:<EOL><INDENT>eq = None<EOL><DEDENT>results['<STR_LIT>'][dimension]['<STR_LIT>'][cl.name] = {<EOL>'<STR_LIT>': cl.size(),<EOL>'<STR_LIT>': cache_equation,<EOL>'<STR_LIT>': inequality,<EOL>'<STR_LIT>': eq<EOL>}<EOL><DEDENT><DEDENT>return results<EOL>", "docstring": "Apply layer condition model to calculate cache accesses.", "id": "f4111:c0:m2"}
{"signature": "def analyze(self):", "body": "<EOL>loop_stack = list(self.kernel.get_loop_stack())<EOL>if any([l['<STR_LIT>'] != <NUM_LIT:1> for l in loop_stack]):<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>for aref in list(self.kernel.index_order()):<EOL><INDENT>while aref and len(aref[<NUM_LIT:0>]) == <NUM_LIT:0>:<EOL><INDENT>aref.pop(<NUM_LIT:0>)<EOL><DEDENT>for i, idx_names in enumerate(aref):<EOL><INDENT>if i >= len(loop_stack) orany([loop_stack[i]['<STR_LIT:index>'] != idx.name for idx in idx_names]):<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>for arefs in chain(chain(*self.kernel.sources.values()),<EOL>chain(*self.kernel.destinations.values())):<EOL><INDENT>if not arefs:<EOL><INDENT>continue<EOL><DEDENT>while arefs and not arefs[<NUM_LIT:0>].free_symbols:<EOL><INDENT>arefs = arefs[<NUM_LIT:1>:]<EOL><DEDENT>for i, expr in enumerate(arefs):<EOL><INDENT>diff = sympy.diff(expr, sympy.Symbol(loop_stack[i]['<STR_LIT:index>']))<EOL>if diff != <NUM_LIT:0> and diff != <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>self.results = self.calculate_cache_access()<EOL>", "docstring": "Run complete analysis.", "id": "f4111:c0:m3"}
{"signature": "def __init__(self, kernel, machine, args=None, parser=None):", "body": "self.kernel = kernel<EOL>self.machine = machine<EOL>self._args = args<EOL>self._parser = parser<EOL>self.results = None<EOL>if args:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Create layer condition model from kernel and machine objects.\n\n*kernel* is a Kernel object\n*machine* describes the machine (cpu, cache and memory) characteristics\n*args* (optional) are the parsed arguments from the comand line", "id": "f4111:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def configure_arggroup(cls, parser):<DEDENT>", "body": "pass<EOL>", "docstring": "Configure arugment parser", "id": "f4111:c0:m0"}
{"signature": "def report(self, output_file=sys.stdout):", "body": "max_perf = self.results['<STR_LIT>']<EOL>if self._args and self._args.verbose >= <NUM_LIT:3>:<EOL><INDENT>print('<STR_LIT:{}>'.format(pformat(self.results)), file=output_file)<EOL><DEDENT>if self._args and self._args.verbose >= <NUM_LIT:1>:<EOL><INDENT>print('<STR_LIT:{}>'.format(pformat(self.results['<STR_LIT>'])), file=output_file)<EOL>print('<STR_LIT>', file=output_file)<EOL>print('<STR_LIT>',<EOL>file=output_file)<EOL>print('<STR_LIT>',<EOL>file=output_file)<EOL>print('<STR_LIT>'.format(<EOL>max_perf[self._args.unit]),<EOL>file=output_file)<EOL>for b in self.results['<STR_LIT>']:<EOL><INDENT>print('<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>b['<STR_LIT>'][self._args.unit], **b),<EOL>file=output_file)<EOL><DEDENT>print('<STR_LIT>', file=output_file)<EOL><DEDENT>if self.results['<STR_LIT>']['<STR_LIT>'] > max_perf['<STR_LIT>']:<EOL><INDENT>print('<STR_LIT>'.format(max_perf), file=output_file)<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>', file=output_file)<EOL>bottleneck = self.results['<STR_LIT>'][self.results['<STR_LIT>']]<EOL>print('<STR_LIT>'.format(<EOL>bottleneck['<STR_LIT>'][self._args.unit],<EOL>bottleneck['<STR_LIT>'],<EOL>bottleneck['<STR_LIT>']),<EOL>file=output_file)<EOL>print('<STR_LIT>'.format(bottleneck['<STR_LIT>']),<EOL>file=output_file)<EOL><DEDENT>", "docstring": "Report analysis outcome in human readable form.", "id": "f4112:c0:m5"}
{"signature": "@classmethod<EOL><INDENT>def configure_arggroup(cls, parser):<DEDENT>", "body": "pass<EOL>", "docstring": "Configure argument parser.", "id": "f4112:c0:m0"}
{"signature": "def analyze(self):", "body": "self.results = self.calculate_cache_access()<EOL>try:<EOL><INDENT>iaca_analysis, asm_block = self.kernel.iaca_analysis(<EOL>micro_architecture=self.machine['<STR_LIT>'],<EOL>asm_block=self.asm_block,<EOL>pointer_increment=self.pointer_increment,<EOL>verbose=self.verbose > <NUM_LIT:2>)<EOL><DEDENT>except RuntimeError as e:<EOL><INDENT>print(\"<STR_LIT>\" + str(e))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>block_throughput = iaca_analysis['<STR_LIT>']<EOL>uops = iaca_analysis['<STR_LIT>']<EOL>iaca_output = iaca_analysis['<STR_LIT>']<EOL>port_cycles = iaca_analysis['<STR_LIT>']<EOL>elements_per_block = abs(asm_block['<STR_LIT>']<EOL>/ self.kernel.datatypes_size[self.kernel.datatype])<EOL>block_size = elements_per_block*self.kernel.datatypes_size[self.kernel.datatype]<EOL>try:<EOL><INDENT>block_to_cl_ratio = float(self.machine['<STR_LIT>'])/block_size<EOL><DEDENT>except ZeroDivisionError as e:<EOL><INDENT>print(\"<STR_LIT>\", e, file=sys.stderr)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>port_cycles = dict([(i[<NUM_LIT:0>], i[<NUM_LIT:1>]*block_to_cl_ratio) for i in list(port_cycles.items())])<EOL>uops = uops*block_to_cl_ratio<EOL>cl_throughput = block_throughput*block_to_cl_ratio<EOL>flops_per_element = sum(self.kernel._flops.values())<EOL>self.results['<STR_LIT>'][<NUM_LIT:0>] = None<EOL>self.results['<STR_LIT>'] = self.conv_perf(PrefixedUnit(float('<STR_LIT>'), '<STR_LIT>'))<EOL>self.results['<STR_LIT>'] = None<EOL>for level, bottleneck in enumerate(self.results['<STR_LIT>']):<EOL><INDENT>if level == <NUM_LIT:0>:<EOL><INDENT>continue<EOL><DEDENT>if bottleneck['<STR_LIT>']['<STR_LIT>'] < self.results['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>self.results['<STR_LIT>'] = level<EOL>self.results['<STR_LIT>'] = bottleneck['<STR_LIT>']<EOL><DEDENT><DEDENT>self.results.update({<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': port_cycles,<EOL>'<STR_LIT>': cl_throughput,<EOL>'<STR_LIT>': uops,<EOL>'<STR_LIT>': self.conv_perf(PrefixedUnit(<EOL>self.machine['<STR_LIT>']/block_throughput*elements_per_block*flops_per_element<EOL>* self.cores, \"<STR_LIT>\")),<EOL>'<STR_LIT>': iaca_output}})<EOL>", "docstring": "Run complete analysis.", "id": "f4112:c1:m2"}
{"signature": "def perfctr(self, cmd, group='<STR_LIT>', code_markers=True):", "body": "<EOL>if find_executable('<STR_LIT>') is None:<EOL><INDENT>print(\"<STR_LIT>\",<EOL>file=sys.stderr)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>perf_cmd = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', group]<EOL>cpu = '<STR_LIT>'<EOL>if self._args.cores > <NUM_LIT:1>:<EOL><INDENT>cpu += '<STR_LIT:->'+str(self._args.cores-<NUM_LIT:1>)<EOL><DEDENT>perf_cmd += ['<STR_LIT>', cpu]<EOL>perf_cmd.append('<STR_LIT>')<EOL>perf_cmd += cmd<EOL>if self.verbose > <NUM_LIT:1>:<EOL><INDENT>print('<STR_LIT:U+0020>'.join(perf_cmd))<EOL><DEDENT>try:<EOL><INDENT>with fix_env_variable('<STR_LIT>', None):<EOL><INDENT>output = subprocess.check_output(perf_cmd).decode('<STR_LIT:utf-8>').split('<STR_LIT:\\n>')<EOL><DEDENT><DEDENT>except subprocess.CalledProcessError as e:<EOL><INDENT>print(\"<STR_LIT>\".format(e), file=sys.stderr)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>results = {}<EOL>for line in output:<EOL><INDENT>line = line.split('<STR_LIT:U+002C>')<EOL>try:<EOL><INDENT>results[line[<NUM_LIT:0>]] = float(line[<NUM_LIT:1>])<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT>except IndexError:<EOL><INDENT>continue<EOL><DEDENT>try:<EOL><INDENT>if line[<NUM_LIT:2>] == '<STR_LIT:->' or line[<NUM_LIT:2>] == '<STR_LIT>':<EOL><INDENT>counter_value = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>counter_value = int(line[<NUM_LIT:2>])<EOL><DEDENT>if re.fullmatch(r'<STR_LIT>', line[<NUM_LIT:0>]) and re.fullmatch(r'<STR_LIT>', line[<NUM_LIT:1>]):<EOL><INDENT>results.setdefault(line[<NUM_LIT:0>], {})<EOL>results[line[<NUM_LIT:0>]][line[<NUM_LIT:1>]] = counter_value<EOL><DEDENT><DEDENT>except (IndexError, ValueError):<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return results<EOL>", "docstring": "Run *cmd* with likwid-perfctr and returns result as dict.\n\n*group* may be a performance group known to likwid-perfctr or an event string.\n\nif CLI argument cores > 1, running with multi-core, otherwise single-core", "id": "f4113:c1:m2"}
{"signature": "def report(self, output_file=sys.stdout):", "body": "if self.verbose > <NUM_LIT:1>:<EOL><INDENT>with pprint_nosort():<EOL><INDENT>pprint.pprint(self.results)<EOL><DEDENT><DEDENT>if self.verbose > <NUM_LIT:0>:<EOL><INDENT>print('<STR_LIT>'.format(<EOL>self.results['<STR_LIT>']),<EOL>file=output_file)<EOL><DEDENT>if self.verbose > <NUM_LIT:0>:<EOL><INDENT>print('<STR_LIT>'.format(<EOL>self.results['<STR_LIT>']),<EOL>file=output_file)<EOL><DEDENT>print('<STR_LIT>'.format(<EOL>self.results['<STR_LIT>']),<EOL>file=output_file)<EOL>print('<STR_LIT>'.format(<EOL>self.results['<STR_LIT>']),<EOL>file=output_file)<EOL>print('<STR_LIT>'.format(self.results['<STR_LIT>']),<EOL>file=output_file)<EOL>print('<STR_LIT>'.format(self.results['<STR_LIT>']),<EOL>file=output_file)<EOL>print('<STR_LIT>'.format(self.results['<STR_LIT>']),<EOL>file=output_file)<EOL>if self.verbose > <NUM_LIT:0>:<EOL><INDENT>print('<STR_LIT>'.format(self.results['<STR_LIT>']),<EOL>file=output_file)<EOL><DEDENT>print('<STR_LIT>', file=output_file)<EOL>if not self.no_phenoecm:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\".format(\"<STR_LIT>\"), end='<STR_LIT>')<EOL>for metrics in self.results['<STR_LIT>'].values():<EOL><INDENT>for metric_name in sorted(metrics):<EOL><INDENT>print(\"<STR_LIT>\".format(metric_name), end='<STR_LIT>')<EOL><DEDENT>print()<EOL>break<EOL><DEDENT>for cache, metrics in sorted(self.results['<STR_LIT>'].items()):<EOL><INDENT>print(\"<STR_LIT>\".format(cache), end='<STR_LIT>')<EOL>for k, v in sorted(metrics.items()):<EOL><INDENT>print(\"<STR_LIT>\".format(v), end='<STR_LIT>')<EOL><DEDENT>print()<EOL><DEDENT>print()<EOL>print('<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>**{k: float(v) for k, v in self.results['<STR_LIT>'].items()}),<EOL>file=output_file)<EOL>print('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>file=output_file)<EOL><DEDENT>", "docstring": "Report gathered analysis data in human readable form.", "id": "f4113:c1:m4"}
{"signature": "def group_iterator(group):", "body": "ordered_chars = string.ascii_letters + string.digits<EOL>tokenizer = ('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>for m in re.finditer(tokenizer, group):<EOL><INDENT>if m.group('<STR_LIT>'):<EOL><INDENT>start, sep, end = m.group('<STR_LIT>')<EOL>for i in range(ordered_chars.index(start), ordered_chars.index(end) + <NUM_LIT:1>):<EOL><INDENT>yield ordered_chars[i]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>yield m.group('<STR_LIT>')<EOL><DEDENT><DEDENT>", "docstring": "Iterate over simple regex-like groups.\n\nThe only special character is a dash (-), which take the preceding and the following chars to\ncompute a range. If the range is non-sensical (e.g., b-a) it will be empty\n\nExample:\n>>> list(group_iterator('a-f'))\n['a', 'b', 'c', 'd', 'e', 'f']\n>>> list(group_iterator('148'))\n['1', '4', '8']\n>>> list(group_iterator('7-9ab'))\n['7', '8', '9', 'a', 'b']\n>>> list(group_iterator('0B-A1'))\n['0', '1']", "id": "f4113:m2"}
{"signature": "def get_infos(self):", "body": "first_dim_factor = self.first_dim_factor<EOL>infos = {'<STR_LIT>': [], '<STR_LIT>': self.stats,<EOL>'<STR_LIT>': first_dim_factor}<EOL>for cache_level, cache_info in list(enumerate(self.machine['<STR_LIT>'])):<EOL><INDENT>infos['<STR_LIT>'].append({<EOL>'<STR_LIT:index>': len(infos['<STR_LIT>']),<EOL>'<STR_LIT>': '<STR_LIT:{}>'.format(cache_info['<STR_LIT>']),<EOL>'<STR_LIT>': self.stats[cache_level]['<STR_LIT>']/first_dim_factor,<EOL>'<STR_LIT>': self.stats[cache_level]['<STR_LIT>']/first_dim_factor,<EOL>'<STR_LIT>': self.stats[cache_level]['<STR_LIT>']/first_dim_factor,<EOL>'<STR_LIT>': self.stats[cache_level]['<STR_LIT>']/first_dim_factor,<EOL>'<STR_LIT>': self.stats[cache_level]['<STR_LIT>']/first_dim_factor,<EOL>'<STR_LIT>': self.stats[cache_level]['<STR_LIT>']/first_dim_factor,<EOL>'<STR_LIT>': self.stats[cache_level]['<STR_LIT>']/first_dim_factor,<EOL>'<STR_LIT>': self.stats[cache_level]['<STR_LIT>']/first_dim_factor,<EOL>'<STR_LIT>': self.stats[cache_level]['<STR_LIT>']/first_dim_factor,<EOL>'<STR_LIT>': self.stats[cache_level]['<STR_LIT>']/first_dim_factor,<EOL>'<STR_LIT>': None})<EOL><DEDENT>return infos<EOL>", "docstring": "Return verbose information about the predictor.", "id": "f4114:c2:m8"}
{"signature": "def get_misses(self):", "body": "<EOL>return [c['<STR_LIT>'] for c in self.results['<STR_LIT>']]+[<NUM_LIT:0>]<EOL>", "docstring": "Return a list with number of missed cache lines per memory hierarchy level.", "id": "f4114:c1:m3"}
{"signature": "def get_evicts(self):", "body": "<EOL>return [c['<STR_LIT>'] for c in self.results['<STR_LIT>']]+[<NUM_LIT:0>]<EOL>", "docstring": "Return a list with number of evicted cache lines per memory hierarchy level.", "id": "f4114:c1:m5"}
{"signature": "def get_evicts(self):", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "Return a list with number of evicted cache lines per memory hierarchy level.", "id": "f4114:c0:m5"}
{"signature": "def get_evicts(self):", "body": "return [self.stats[cache_level]['<STR_LIT>']/self.first_dim_factor<EOL>for cache_level in range(len(self.machine['<STR_LIT>']))]<EOL>", "docstring": "Return a list with number of evicted cache lines per memory hierarchy level.", "id": "f4114:c2:m7"}
{"signature": "def __init__(self, kernel, machine, cores=<NUM_LIT:1>):", "body": "CachePredictor.__init__(self, kernel, machine, cores=cores)<EOL>loop_stack = list(self.kernel.get_loop_stack())<EOL>if any([l['<STR_LIT>'] != <NUM_LIT:1> for l in loop_stack]):<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>index_order = [symbol_pos_int(l['<STR_LIT:index>']) for l in loop_stack]<EOL>for var_name, arefs in chain(self.kernel.sources.items(), self.kernel.destinations.items()):<EOL><INDENT>if next(iter(arefs)) is None:<EOL><INDENT>continue<EOL><DEDENT>for a in [self.kernel.access_to_sympy(var_name, a) for a in arefs]:<EOL><INDENT>for t in a.expand().as_ordered_terms():<EOL><INDENT>idx = t.free_symbols.intersection(index_order)<EOL>if not idx:<EOL><INDENT>continue<EOL><DEDENT>if len(idx) != <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(t))<EOL><DEDENT>else:  <EOL><INDENT>idx = idx.pop()<EOL>pow_dict = {k: v for k, v in t.as_powers_dict().items()<EOL>if k != idx}<EOL>stride_dim = sum(pow_dict.values())<EOL>error = False<EOL>try:<EOL><INDENT>if loop_stack[-stride_dim-<NUM_LIT:1>]['<STR_LIT:index>'] != idx.name:<EOL><INDENT>error = True<EOL><DEDENT><DEDENT>except IndexError:<EOL><INDENT>error = True<EOL><DEDENT>if error:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(t))<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>inner_index = symbol_pos_int(loop_stack[-<NUM_LIT:1>]['<STR_LIT:index>'])<EOL>inner_increment = loop_stack[-<NUM_LIT:1>]['<STR_LIT>']<EOL>for arefs in chain(chain(*self.kernel.sources.values()),<EOL>chain(*self.kernel.destinations.values())):<EOL><INDENT>if arefs is None:<EOL><INDENT>continue<EOL><DEDENT>for expr in arefs:<EOL><INDENT>diff = expr.subs(inner_index, <NUM_LIT:1>+inner_increment) - expr.subs(inner_index, <NUM_LIT:1>)<EOL>if diff != <NUM_LIT:0> and diff != <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>element_size = self.kernel.datatypes_size[self.kernel.datatype]<EOL>accesses = {}<EOL>destinations = set()<EOL>distances = []<EOL>for var_name in self.kernel.variables:<EOL><INDENT>accesses[var_name] = self.kernel.sources.get(var_name, set()).union(<EOL>self.kernel.destinations.get(var_name, set()))<EOL>if not any(accesses[var_name]) or not any(<EOL>[a == inner_index or a.coeff(inner_index) != <NUM_LIT:0><EOL>for a in chain.from_iterable(accesses[var_name])]):<EOL><INDENT>continue<EOL><DEDENT>destinations.update(<EOL>[(var_name, tuple(r)) for r in self.kernel.destinations.get(var_name, [])])<EOL>acs = accesses[var_name]<EOL>acs = [self.kernel.access_to_sympy(var_name, r) for r in acs]<EOL>acs = [self.kernel.subs_consts(e) for e in acs]<EOL>acs.sort(reverse=True)<EOL>distances += [(acs[i-<NUM_LIT:1>]-acs[i]).simplify() for i in range(<NUM_LIT:1>, len(acs))]<EOL>distances.append(sympy.oo)<EOL><DEDENT>distances.sort(reverse=True)<EOL>distances_bytes = [d*element_size for d in distances]<EOL>results = {'<STR_LIT>': {k: list(v) for k,v in accesses.items()},<EOL>'<STR_LIT>': distances,<EOL>'<STR_LIT>': destinations,<EOL>'<STR_LIT>': distances_bytes,<EOL>'<STR_LIT>': []}<EOL>sum_array_sizes = sum(self.kernel.array_sizes(in_bytes=True, subs_consts=True).values())<EOL>for c in self.machine.get_cachesim(self.cores).levels(with_mem=False):<EOL><INDENT>hits = <NUM_LIT:0><EOL>misses = len(distances_bytes)<EOL>cache_requirement = <NUM_LIT:0><EOL>tail = <NUM_LIT:0><EOL>if c.size() > sum_array_sizes:<EOL><INDENT>hits = misses<EOL>misses = <NUM_LIT:0><EOL>cache_requirement = sum_array_sizes<EOL><DEDENT>else:<EOL><INDENT>for tail in sorted(set(distances_bytes), reverse=True):<EOL><INDENT>if tail is sympy.oo:<EOL><INDENT>continue<EOL><DEDENT>cache_requirement = (<EOL>sum([d for d in distances_bytes if d <= tail]) +<EOL>tail*len([d for d in distances_bytes if d > tail]))<EOL>if cache_requirement <= c.size():<EOL><INDENT>hits = len([d for d in distances_bytes if d <= tail])<EOL>misses = len([d for d in distances_bytes if d > tail])<EOL>break<EOL><DEDENT><DEDENT><DEDENT>results['<STR_LIT>'].append({<EOL>'<STR_LIT:name>': c.name,<EOL>'<STR_LIT>': hits,<EOL>'<STR_LIT>': misses,<EOL>'<STR_LIT>': len(destinations) if c.size() < sum_array_sizes else <NUM_LIT:0>,<EOL>'<STR_LIT>': cache_requirement,<EOL>'<STR_LIT>': tail})<EOL><DEDENT>self.results = results<EOL>", "docstring": "Initialize layer condition based predictor from kernel and machine object.", "id": "f4114:c1:m0"}
{"signature": "def good_prefix(self, max_error=<NUM_LIT>, round_length=<NUM_LIT:2>, min_prefix='<STR_LIT>', max_prefix=None):", "body": "good_prefix = min_prefix<EOL>base_value = self.base_value()<EOL>for k, v in list(self.PREFIXES.items()):<EOL><INDENT>if max_prefix is not None and v > self.PREFIXES[max_prefix]:<EOL><INDENT>continue<EOL><DEDENT>if abs(round(base_value/v, round_length)*v - base_value) > base_value*max_error:<EOL><INDENT>continue<EOL><DEDENT>if abs(round(base_value/v, round_length)) < <NUM_LIT>:<EOL><INDENT>continue<EOL><DEDENT>if v < self.PREFIXES[good_prefix]:<EOL><INDENT>continue<EOL><DEDENT>good_prefix = k<EOL><DEDENT>return good_prefix<EOL>", "docstring": "returns the largest prefix where the relative error is bellow *max_error* although rounded\nby *round_length*\n\nif *max_prefix* is found in PrefixedUnit.PREFIXES, returned value will not exceed this\nprefix.\nif *min_prefix* is given, returned value will atleast be of that prefix (no matter the\nerror)", "id": "f4115:c0:m5"}
{"signature": "def base_value(self):", "body": "return self.value*self.PREFIXES[self.prefix]<EOL>", "docstring": "gives value without prefix", "id": "f4115:c0:m3"}
{"signature": "def print_variables_info(self, output_file=sys.stdout):", "body": "table = ('<STR_LIT>' +<EOL>'<STR_LIT>')<EOL>for name, var_info in list(self.variables.items()):<EOL><INDENT>table += '<STR_LIT>'.format(name, var_info[<NUM_LIT:0>], var_info[<NUM_LIT:1>])<EOL><DEDENT>print(prefix_indent('<STR_LIT>', table), file=output_file)<EOL>", "docstring": "Print variables information in human readble format.", "id": "f4116:c0:m22"}
{"signature": "def get_index_type(self, loop_nest=None):", "body": "if loop_nest is None:<EOL><INDENT>loop_nest = self.get_kernel_loop_nest()<EOL><DEDENT>if type(loop_nest) is c_ast.For:<EOL><INDENT>loop_nest = [loop_nest]<EOL><DEDENT>index_types = (None, None)<EOL>for s in loop_nest:<EOL><INDENT>if type(s) is c_ast.For:<EOL><INDENT>if type(s.stmt) in [c_ast.For, c_ast.Compound]:<EOL><INDENT>other = self.get_index_type(loop_nest=s.stmt)<EOL><DEDENT>else:<EOL><INDENT>other = None<EOL><DEDENT>index_types = (s.init.decls[<NUM_LIT:0>].type.type.names, other)<EOL>break<EOL><DEDENT><DEDENT>if index_types[<NUM_LIT:0>] == index_types[<NUM_LIT:1>] or index_types[<NUM_LIT:1>] is None:<EOL><INDENT>return index_types[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(index_types))<EOL><DEDENT>", "docstring": "Return index type used in loop nest.\n\nIf index type between loops differ, an exception is raised.", "id": "f4116:c1:m13"}
{"signature": "def _remove_duplicate_accesses(self):", "body": "self.destinations = {var_name: set(acs) for var_name, acs in self.destinations.items()}<EOL>self.sources = {var_name: set(acs) for var_name, acs in self.sources.items()}<EOL>", "docstring": "Remove duplicate source and destination accesses", "id": "f4116:c0:m8"}
{"signature": "def get_kernel_loop_nest(self):", "body": "loop_nest = [s for s in self.kernel_ast.block_items<EOL>if type(s) in [c_ast.For, c_ast.Pragma, c_ast.FuncCall]]<EOL>assert len(loop_nest) >= <NUM_LIT:1>, \"<STR_LIT>\"<EOL>return loop_nest<EOL>", "docstring": "Return kernel loop nest including any preceding pragmas and following swaps.", "id": "f4116:c1:m16"}
{"signature": "def build_executable(self, *args, **kwargs):", "body": "raise NotImplementedError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>", "docstring": "Compile and build binary.", "id": "f4116:c0:m25"}
{"signature": "def get_kernel_code(self, openmp=False, as_filename=False, name='<STR_LIT>'):", "body": "assert self.kernel_ast is not None, \"<STR_LIT>\"\"<STR_LIT>\"<EOL>file_name = '<STR_LIT>'<EOL>if openmp:<EOL><INDENT>file_name += '<STR_LIT>'<EOL><DEDENT>file_name += '<STR_LIT>'<EOL>fp, already_available = self._get_intermediate_file(<EOL>file_name, machine_and_compiler_dependent=False)<EOL>if already_available:<EOL><INDENT>code = fp.read()<EOL><DEDENT>else:<EOL><INDENT>array_declarations, array_dimensions = self._build_array_declarations()<EOL>if openmp:<EOL><INDENT>kernel = deepcopy(self.get_kernel_loop_nest())<EOL>for aref in find_node_type(kernel, c_ast.ArrayRef):<EOL><INDENT>transform_multidim_to_1d_ref(aref, array_dimensions)<EOL><DEDENT>omp_pragmas = [p for p in find_node_type(kernel, c_ast.Pragma)<EOL>if '<STR_LIT>' in p.string]<EOL>if not omp_pragmas:<EOL><INDENT>kernel.insert(<NUM_LIT:0>, c_ast.Pragma(\"<STR_LIT>\"))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>kernel = deepcopy(self.get_kernel_loop_nest())<EOL>for aref in find_node_type(kernel, c_ast.ArrayRef):<EOL><INDENT>transform_multidim_to_1d_ref(aref, array_dimensions)<EOL><DEDENT><DEDENT>function_ast = c_ast.FuncDef(decl=c_ast.Decl(<EOL>name=name, type=self._build_kernel_function_declaration(name=name), quals=[],<EOL>storage=[], funcspec=[], init=None, bitsize=None),<EOL>body=c_ast.Compound(block_items=kernel),<EOL>param_decls=None)<EOL>code = CGenerator().visit(function_ast)<EOL>code = '<STR_LIT>' + code<EOL>fp.write(code)<EOL><DEDENT>fp.close()<EOL>if as_filename:<EOL><INDENT>return fp.name<EOL><DEDENT>else:<EOL><INDENT>return code<EOL><DEDENT>", "docstring": "Generate and return compilable source code with kernel function from AST.\n\n:param openmp: if true, OpenMP code will be generated\n:param as_filename: if true, will save to file and return filename\n:param name: name of kernel function", "id": "f4116:c1:m23"}
{"signature": "def access_to_sympy(self, var_name, access):", "body": "base_sizes = self.variables[var_name][<NUM_LIT:1>]<EOL>expr = sympy.Number(<NUM_LIT:0>)<EOL>for dimension, a in enumerate(access):<EOL><INDENT>base_size = reduce(operator.mul, base_sizes[dimension+<NUM_LIT:1>:], sympy.Integer(<NUM_LIT:1>))<EOL>expr += base_size*a<EOL><DEDENT>return expr<EOL>", "docstring": "Transform a (multidimensional) variable access to a flattend sympy expression.\n\nAlso works with flat array accesses.", "id": "f4116:c0:m9"}
{"signature": "@lru_cache(<NUM_LIT>)<EOL><INDENT>def subs_consts(self, expr):<DEDENT>", "body": "if isinstance(expr, numbers.Number):<EOL><INDENT>return expr<EOL><DEDENT>else:<EOL><INDENT>return expr.subs(self.constants)<EOL><DEDENT>", "docstring": "Substitute constants in expression unless it is already a number.", "id": "f4116:c0:m5"}
{"signature": "def transform_multidim_to_1d_ref(aref, dimension_dict):", "body": "dims = []<EOL>name = aref<EOL>while type(name) is c_ast.ArrayRef:<EOL><INDENT>dims.append(name.subscript)<EOL>name = name.name<EOL><DEDENT>subscript_list = []<EOL>for i, d in enumerate(dims):<EOL><INDENT>if i == <NUM_LIT:0>:<EOL><INDENT>subscript_list.append(d)<EOL><DEDENT>else:<EOL><INDENT>subscript_list.append(c_ast.BinaryOp('<STR_LIT:*>', d, reduce(<EOL>lambda l, r: c_ast.BinaryOp('<STR_LIT:*>', l, r),<EOL>dimension_dict[name.name][-<NUM_LIT:1>:-i-<NUM_LIT:1>:-<NUM_LIT:1>])))<EOL><DEDENT><DEDENT>aref.subscript = reduce(<EOL>lambda l, r: c_ast.BinaryOp('<STR_LIT:+>', l, r), subscript_list)<EOL>aref.name = name<EOL>", "docstring": "Transform ast of multidimensional reference to a single dimension reference.\n\nIn-place operation!", "id": "f4116:m3"}
{"signature": "def prefix_indent(prefix, textblock, later_prefix='<STR_LIT:U+0020>'):", "body": "textblock = textblock.split('<STR_LIT:\\n>')<EOL>line = prefix + textblock[<NUM_LIT:0>] + '<STR_LIT:\\n>'<EOL>if len(later_prefix) == <NUM_LIT:1>:<EOL><INDENT>later_prefix = '<STR_LIT:U+0020>'*len(prefix)<EOL><DEDENT>line = line + '<STR_LIT:\\n>'.join([later_prefix + x for x in textblock[<NUM_LIT:1>:]])<EOL>if line[-<NUM_LIT:1>] != '<STR_LIT:\\n>':<EOL><INDENT>return line + '<STR_LIT:\\n>'<EOL><DEDENT>else:<EOL><INDENT>return line<EOL><DEDENT>", "docstring": "Prefix and indent all lines in *textblock*.\n\n*prefix* is a prefix string\n*later_prefix* is used on all but the first line, if it is a single character\n               it will be repeated to match length of *prefix*", "id": "f4116:m1"}
{"signature": "def iaca_analysis(self, micro_architecture, asm_block='<STR_LIT>',<EOL>pointer_increment='<STR_LIT>', verbose=False):", "body": "asm_filename = self.compile_kernel(assembly=True, verbose=verbose)<EOL>asm_marked_filename = os.path.splitext(asm_filename)[<NUM_LIT:0>]+'<STR_LIT>'<EOL>with open(asm_filename, '<STR_LIT:r>') as in_file, open(asm_marked_filename, '<STR_LIT:w>') as out_file:<EOL><INDENT>self.asm_block = iaca.iaca_instrumentation(<EOL>in_file, out_file,<EOL>block_selection=asm_block,<EOL>pointer_increment=pointer_increment)<EOL><DEDENT>obj_name = self.assemble_to_object(asm_marked_filename, verbose=verbose)<EOL>return iaca.iaca_analyse_instrumented_binary(obj_name, micro_architecture), self.asm_block<EOL>", "docstring": "Run an IACA analysis and return its outcome.\n\n*asm_block* controls how the to-be-marked block is chosen. \"auto\" (default) results in\nthe largest block, \"manual\" results in interactive and a number in the according block.\n\n*pointer_increment* is the number of bytes the pointer is incremented after the loop or\n   - 'auto': automatic detection, RuntimeError is raised in case of failure\n   - 'auto_with_manual_fallback': automatic detection, fallback to manual input\n   - 'manual': prompt user", "id": "f4116:c1:m28"}
{"signature": "def _build_const_declartions(self, with_init=True):", "body": "decls = []<EOL>index_type = self.get_index_type()<EOL>i = <NUM_LIT:2>  <EOL>for k in self.constants:<EOL><INDENT>type_decl = c_ast.TypeDecl(k.name, ['<STR_LIT>'], c_ast.IdentifierType(index_type))<EOL>init = None<EOL>if with_init:<EOL><INDENT>init = c_ast.FuncCall(<EOL>c_ast.ID('<STR_LIT>'),<EOL>c_ast.ExprList([c_ast.ArrayRef(c_ast.ID('<STR_LIT>'),<EOL>c_ast.Constant('<STR_LIT:int>', str(i)))]))<EOL><DEDENT>i += <NUM_LIT:1><EOL>decls.append(c_ast.Decl(<EOL>k.name, ['<STR_LIT>'], [], [],<EOL>type_decl, init, None))<EOL><DEDENT>return decls<EOL>", "docstring": "Generate constants declarations\n\n:return: list of declarations", "id": "f4116:c1:m14"}
{"signature": "def _build_scalar_declarations(self, with_init=True):", "body": "<EOL>scalar_declarations = [deepcopy(d) for d in self.kernel_ast.block_items<EOL>if type(d) is c_ast.Decl and type(d.type) is c_ast.TypeDecl]<EOL>if with_init:<EOL><INDENT>random.seed(<NUM_LIT>)  <EOL>for d in scalar_declarations:<EOL><INDENT>if d.type.type.names[<NUM_LIT:0>] in ['<STR_LIT>', '<STR_LIT:float>']:<EOL><INDENT>d.init = c_ast.Constant('<STR_LIT:float>', str(random.uniform(<NUM_LIT:1.0>, <NUM_LIT:0.1>)))<EOL><DEDENT>elif d.type.type.names[<NUM_LIT:0>] in ['<STR_LIT:int>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>d.init = c_ast.Constant('<STR_LIT:int>', <NUM_LIT:2>)<EOL><DEDENT><DEDENT><DEDENT>return scalar_declarations<EOL>", "docstring": "Build and return scalar variable declarations", "id": "f4116:c1:m22"}
{"signature": "def assemble_to_object(self, in_filename, verbose=False):", "body": "<EOL>file_base_name = os.path.splitext(os.path.basename(in_filename))[<NUM_LIT:0>]<EOL>out_filename, already_exists = self._get_intermediate_file(file_base_name + '<STR_LIT>',<EOL>binary=True,<EOL>fp=False)<EOL>if already_exists:<EOL><INDENT>pass<EOL><DEDENT>compiler, compiler_args = self._machine.get_compiler()<EOL>compiler_args.append('<STR_LIT:-c>')<EOL>cmd = [compiler] + [<EOL>in_filename] +compiler_args + ['<STR_LIT>', out_filename]<EOL>if verbose:<EOL><INDENT>print('<STR_LIT>', '<STR_LIT:U+0020>'.join(cmd))<EOL><DEDENT>try:<EOL><INDENT>subprocess.check_output(cmd)<EOL><DEDENT>except subprocess.CalledProcessError as e:<EOL><INDENT>print(\"<STR_LIT>\", e, file=sys.stderr)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>return out_filename<EOL>", "docstring": "Assemble *in_filename* assembly into *out_filename* object.\n\nIf *iaca_marked* is set to true, markers are inserted around the block with most packed\ninstructions or (if no packed instr. were found) the largest block and modified file is\nsaved to *in_file*.\n\n*asm_block* controls how the to-be-marked block is chosen. \"auto\" (default) results in\nthe largest block, \"manual\" results in interactive and a number in the according block.\n\n*pointer_increment* is the number of bytes the pointer is incremented after the loop or\n   - 'auto': automatic detection, RuntimeError is raised in case of failure\n   - 'auto_with_manual_fallback': automatic detection, fallback to manual input\n   - 'manual': prompt user\n\nReturns two-tuple (filepointer, filename) to temp binary file.", "id": "f4116:c1:m26"}
{"signature": "def iaca_analysis(self, *args, **kwargs):", "body": "raise NotImplementedError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>", "docstring": "Run IACA analysis.", "id": "f4116:c0:m24"}
{"signature": "def simulate(kernel, model, define_dict, blocking_constant, blocking_length):", "body": "kernel.clear_state()<EOL>for k, v in define_dict.items():<EOL><INDENT>kernel.set_constant(k, v)<EOL><DEDENT>kernel.set_constant(blocking_constant, blocking_length)<EOL>model.analyze()<EOL>return sum([cy for dscr, cy in model.results['<STR_LIT>']])<EOL>", "docstring": "Setup and execute model with given blocking length", "id": "f4118:m1"}
{"signature": "def measure_bw(type_, total_size, threads_per_core, max_threads_per_core, cores_per_socket,<EOL>sockets):", "body": "groups = []<EOL>for s in range(sockets):<EOL><INDENT>groups += [<EOL>'<STR_LIT>',<EOL>'<STR_LIT:S>' + str(s) + '<STR_LIT::>' + str(total_size) + '<STR_LIT>' +<EOL>str(threads_per_core * cores_per_socket) +<EOL>'<STR_LIT>' + str(int(max_threads_per_core / threads_per_core))]<EOL><DEDENT>cmd = ['<STR_LIT>', '<STR_LIT>', type_] + groups<EOL>sys.stderr.write('<STR_LIT:U+0020>'.join(cmd))<EOL>output = subprocess.Popen(cmd, stdout=subprocess.PIPE).communicate()[<NUM_LIT:0>].decode('<STR_LIT:utf-8>')<EOL>if not output:<EOL><INDENT>print('<STR_LIT:U+0020>'.join(cmd) + '<STR_LIT>'<EOL>'<STR_LIT>', file=sys.stderr)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>bw = float(get_match_or_break(r'<STR_LIT>', output)[<NUM_LIT:0>])<EOL>print('<STR_LIT:U+0020>', PrefixedUnit(bw, '<STR_LIT>'), file=sys.stderr)<EOL>return PrefixedUnit(bw, '<STR_LIT>')<EOL>", "docstring": "*size* is given in kilo bytes", "id": "f4120:m4"}
{"signature": "def select_best_block(blocks):", "body": "<EOL>if not blocks:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>best_block = max(blocks, key=lambda b: b[<NUM_LIT:1>]['<STR_LIT>'])<EOL>if best_block[<NUM_LIT:1>]['<STR_LIT>'] == <NUM_LIT:0>:<EOL><INDENT>best_block = max(blocks,<EOL>key=lambda b: (b[<NUM_LIT:1>]['<STR_LIT>'] + b[<NUM_LIT:1>]['<STR_LIT>'] + b[<NUM_LIT:1>]['<STR_LIT>'],<EOL>b[<NUM_LIT:1>]['<STR_LIT>'], b[<NUM_LIT:1>]['<STR_LIT>'], b[<NUM_LIT:1>]['<STR_LIT>']))<EOL><DEDENT>return best_block[<NUM_LIT:0>]<EOL>", "docstring": "Return best block selected based on simple heuristic.", "id": "f4122:m4"}
{"signature": "@staticmethod<EOL><INDENT>def parse_perfctr_event(perfctr):<DEDENT>", "body": "split_perfctr = perfctr.split('<STR_LIT::>')<EOL>assert len(split_perfctr) >= <NUM_LIT:2>, \"<STR_LIT>\"<EOL>event_tuple = split_perfctr[:<NUM_LIT:2>]<EOL>parameters = {}<EOL>for p in split_perfctr[<NUM_LIT:2>:]:<EOL><INDENT>if '<STR_LIT:=>' in p:<EOL><INDENT>k, v = p.split('<STR_LIT:=>')<EOL>if v.startswith('<STR_LIT>'):<EOL><INDENT>parameters[k] = int(v, <NUM_LIT:16>)<EOL><DEDENT>else:<EOL><INDENT>parameters[k] = int(v)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>parameters[p] = None<EOL><DEDENT><DEDENT>event_tuple.append(parameters)<EOL>return tuple(event_tuple)<EOL>", "docstring": "Parse events in machine description to tuple representation used in Benchmark module.\n\nExamples:\n>>> parse_perfctr_event('PERF_EVENT:REG[0-3]')\n('PERF_EVENT', 'REG[0-3]')\n>>> parse_perfctr_event('PERF_EVENT:REG[0-3]:STAY:FOO=23:BAR=0x23')\n('PERF_EVENT', 'REG[0-3]', {'STAY': None, 'FOO': 23, 'BAR': 35})", "id": "f4123:c0:m8"}
{"signature": "def get_compiler(self, compiler=None, flags=None):", "body": "if self._args:<EOL><INDENT>compiler = compiler or self._args.compiler<EOL>flags = flags or self._args.compiler_flags<EOL><DEDENT>if compiler is None:<EOL><INDENT>for c in self['<STR_LIT>'].keys():<EOL><INDENT>if find_executable(c) is not None:<EOL><INDENT>compiler = c<EOL>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(list(self['<STR_LIT>'].keys())))<EOL><DEDENT><DEDENT>if flags is None:<EOL><INDENT>flags = self['<STR_LIT>'].get(compiler, '<STR_LIT>')<EOL><DEDENT>return compiler, flags.split('<STR_LIT:U+0020>')<EOL>", "docstring": "Return tuple of compiler and compiler flags.\n\nSelects compiler and flags from machine description file, commandline arguments or call\narguements.", "id": "f4123:c0:m7"}
{"signature": "def sanitize_symbolname(name):", "body": "return re.subn('<STR_LIT>', '<STR_LIT:_>', name)[<NUM_LIT:0>]<EOL>", "docstring": "Sanitize all characters not matched to a symbol by sympy's parse_expr.\n\nBased on same rules as used for python variables.", "id": "f4123:m0"}
{"signature": "def __repr__(self):", "body": "return '<STR_LIT>'.format(<EOL>self.__class__.__name__,<EOL>repr(self._path or self._data['<STR_LIT>']),<EOL>)<EOL>", "docstring": "Return object representation.", "id": "f4123:c0:m2"}
{"signature": "@staticmethod<EOL><INDENT>def parse_perfmetric(metric):<DEDENT>", "body": "<EOL>perfcounters = re.findall(r'<STR_LIT>', metric)<EOL>temp_metric = metric<EOL>temp_pc_names = {\"<STR_LIT>\".format(re.sub(\"<STR_LIT>\", \"<STR_LIT:_>\", pc)): pc<EOL>for i, pc in enumerate(perfcounters)}<EOL>for var_name, pc in temp_pc_names.items():<EOL><INDENT>temp_metric = temp_metric.replace(pc, var_name)<EOL><DEDENT>expr = parse_expr(temp_metric)<EOL>for s in expr.free_symbols:<EOL><INDENT>if s.name in temp_pc_names:<EOL><INDENT>s.name = temp_pc_names[str(s)]<EOL><DEDENT><DEDENT>events = {s: MachineModel.parse_perfctr_event(s.name) for s in expr.free_symbols<EOL>if s.name in perfcounters}<EOL>return expr, events<EOL>", "docstring": "Return (sympy expressions, event names and symbols dict) from performance metric str.", "id": "f4123:c0:m9"}
{"signature": "def __and__(self, other):", "body": "return Intervals(*(self.data+other.data))<EOL>", "docstring": "Combine two intervals, under the assumption that they are sane.", "id": "f4125:c0:m3"}
{"signature": "def __len__(self):", "body": "return int(sum(upper-lower for (lower, upper) in self.data))<EOL>", "docstring": "Return sum of range lengths.", "id": "f4125:c0:m4"}
{"signature": "def build_minimal_runs(events):", "body": "<EOL>events = [e for i, e in enumerate(events) if events.index(e) == i]<EOL>scheduled_runs = {}<EOL>scheduled_events = []<EOL>cur_run = <NUM_LIT:0><EOL>while len(scheduled_events) != len(events):<EOL><INDENT>for event_tpl in events:<EOL><INDENT>event, registers, parameters = event_tpl<EOL>if event_tpl in scheduled_events:<EOL><INDENT>continue<EOL><DEDENT>for possible_reg in register_options(registers):<EOL><INDENT>s = scheduled_runs.setdefault(cur_run, {})<EOL>if possible_reg not in s:<EOL><INDENT>s[possible_reg] = (event, possible_reg, parameters)<EOL>scheduled_events.append(event_tpl)<EOL>break<EOL><DEDENT><DEDENT><DEDENT>cur_run += <NUM_LIT:1><EOL><DEDENT>runs = [list(v.values()) for v in scheduled_runs.values()]<EOL>return runs<EOL>", "docstring": "Compile list of minimal runs for given events.", "id": "f4127:m3"}
{"signature": "def receiver_blueprint_for(self, name):", "body": "<EOL>provider = self.get_provider(name)<EOL>bp = provider.make_receiver_blueprint()<EOL>from flask.globals import g  <EOL>@bp.before_request<EOL>def init_g():<EOL><INDENT>g.provider = provider<EOL><DEDENT>return bp<EOL>", "docstring": "Get a Flask blueprint for the named provider that handles incoming messages & status reports\n\n            Note: this requires Flask microframework.\n\n            :rtype: flask.blueprints.Blueprint\n            :returns: Flask Blueprint, fully functional\n            :raises KeyError: provider not found\n            :raises NotImplementedError: Provider does not implement a receiver", "id": "f4134:c0:m7"}
{"signature": "@property<EOL><INDENT>def default_provider(self):<DEDENT>", "body": "return self._default_provider<EOL>", "docstring": "Default provider name\n\n            :rtype: str | None", "id": "f4134:c0:m2"}
{"signature": "def add_provider(self, name, Provider, **config):", "body": "assert issubclass(Provider, IProvider), '<STR_LIT>'<EOL>assert isinstance(name, str), '<STR_LIT>'<EOL>provider = Provider(self, name, **config)<EOL>assert name not in self._providers, '<STR_LIT>'<EOL>self._providers[name] = provider<EOL>if self.default_provider is None:<EOL><INDENT>self.default_provider = name<EOL><DEDENT>return provider<EOL>", "docstring": "Register a provider on the gateway\n\n            The first provider defined becomes the default one: used in case the routing function has no better idea.\n\n            :type name: str\n            :param name: Provider name that will be used to uniquely identify it\n            :type Provider: type\n            :param Provider: Provider class that inherits from `smsframework.IProvider`\n            :param config: Provider configuration. Please refer to the Provider documentation.\n            :rtype: IProvider\n            :returns: The created provider", "id": "f4134:c0:m1"}
{"signature": "def send(self, message):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Send a message\n\n            Providers are required to:\n            * Populate `message.msgid` and `message.meta` on completion\n            * Expect that `message.src` can be empty\n            * Support both ASCII and Unicode messages\n            * Use `message.params` for provider-dependent configuration\n            * Raise exceptions from `exc.py` for errors\n\n            :type message: data.OutgoingMessage\n            :param message: The message to send\n            :rtype: OutgoingMessage\n            :returns: The sent message with populated fields\n            :raises MessageSendError: sending errors", "id": "f4139:c0:m1"}
{"signature": "def _receive_status(self, status):", "body": "<EOL>status.provider = self.name<EOL>self.gateway.onStatus(status)<EOL>return status<EOL>", "docstring": "Incoming status callback\n\n            Calls Gateway.onStatus event hook\n\n            Providers are required to:\n            * Cast phone numbers to digits-only\n            * Use proper MessageStatus subclasses\n            * Populate `status.msgid` and `status.meta` fields\n            * If this method fails with an exception, the provider is required to respond with an error to the service\n\n            :type status: MessageStatus\n            :param status: The received status\n            :rtype: MessageStatus", "id": "f4139:c0:m4"}
{"signature": "def make_receiver_blueprint(self):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Get a Blueprint for the HTTP receiver\n\n            :rtype: flask.Blueprint\n            :returns: configured Flask Blueprint receiver\n            :raises NotImplementedError: Provider does not support message reception", "id": "f4139:c0:m2"}
{"signature": "@bp.route('<STR_LIT>', methods=['<STR_LIT:POST>'])<EOL>@jsonex_api<EOL>def status():", "body": "req = jsonex_loads(request.get_data())<EOL>status = g.provider._receive_status(req['<STR_LIT:status>'])<EOL>return {'<STR_LIT:status>': status}<EOL>", "docstring": "Incoming status handler: forwarded by ForwardServerProvider", "id": "f4140:m1"}
{"signature": "def make_receiver_blueprint(self):", "body": "from .receiver_client import bp<EOL>return bp<EOL>", "docstring": "Create the receiver so server can send messages to us\n        :rtype: flask.Blueprint", "id": "f4141:c0:m2"}
{"signature": "def forward(self, obj):", "body": "assert isinstance(obj, (IncomingMessage, MessageStatus)), '<STR_LIT>'.format(obj)<EOL>clients = self.choose_clients(obj)<EOL>if Parallel:<EOL><INDENT>pll = Parallel(self._forward_object_to_client)<EOL>for client in clients:<EOL><INDENT>pll(client, obj)<EOL><DEDENT>results, errors = pll.join()<EOL>if errors:<EOL><INDENT>raise errors[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for client in clients:<EOL><INDENT>self._forward_object_to_client(client, obj)<EOL><DEDENT><DEDENT>", "docstring": "Forward an object to clients.\n\n        :param obj: The object to be forwarded\n        :type obj: smsframework.data.IncomingMessage|smsframework.data.MessageStatus\n        :raises Exception: if any of the clients failed", "id": "f4141:c1:m3"}
{"signature": "def jsonex_request(url, data, headers=None):", "body": "<EOL>url, headers = _parse_authentication(url)<EOL>headers['<STR_LIT:Content-Type>'] = '<STR_LIT:application/json>'<EOL>try:<EOL><INDENT>req = Request(url, headers=headers)<EOL>response = urlopen(req, jsonex_dumps(data))<EOL>res_str = response.read()<EOL>res = jsonex_loads(res_str)<EOL><DEDENT>except HTTPError as e:<EOL><INDENT>if '<STR_LIT:Content-Type>' in e.headers and e.headers['<STR_LIT:Content-Type>'] == '<STR_LIT:application/json>':<EOL><INDENT>res = jsonex_loads(e.read())<EOL><DEDENT>else:<EOL><INDENT>raise exc.ServerError('<STR_LIT>'.format(url, e))<EOL><DEDENT><DEDENT>except URLError as e:<EOL><INDENT>raise exc.ConnectionError('<STR_LIT>'.format(url, e))<EOL><DEDENT>if '<STR_LIT:error>' in res:  <EOL><INDENT>raise res['<STR_LIT:error>']  <EOL><DEDENT>return res<EOL>", "docstring": "Make a request with JsonEx\n    :param url: URL\n    :type url: str\n    :param data: Data to POST\n    :type data: dict\n    :return: Response\n    :rtype: dict\n    :raises exc.ConnectionError: Connection error\n    :raises exc.ServerError: Remote server error (unknown)\n    :raises exc.ProviderError: any errors reported by the remote", "id": "f4141:m4"}
{"signature": "def choose_clients(self, obj):", "body": "return self.clients<EOL>", "docstring": "Given a message, decides which clients will receive it.\n\n        Override to have custom routing. Default: send to all clients\n\n        :param obj: The object to be forwarded\n        :type obj: smsframework.data.IncomingMessage|smsframework.data.MessageStatus\n        :return: List of client URLs to forward the message to\n        :rtype: list[str]", "id": "f4141:c1:m1"}
{"signature": "def jsonex_api(f):", "body": "@wraps(f)<EOL>def wrapper(*args, **kwargs):<EOL><INDENT>try:<EOL><INDENT>code, res = <NUM_LIT:200>, f(*args, **kwargs)<EOL><DEDENT>except HTTPException as e:<EOL><INDENT>code, res = e.code, {'<STR_LIT:error>': e}<EOL><DEDENT>except Exception as e:<EOL><INDENT>code, res = <NUM_LIT>, {'<STR_LIT:error>': e}<EOL>logger.exception('<STR_LIT>')<EOL><DEDENT>response = make_response(jsonex_dumps(res), code)<EOL>response.headers['<STR_LIT:Content-Type>'] = '<STR_LIT:application/json>'<EOL>return response<EOL><DEDENT>return wrapper<EOL>", "docstring": "View wrapper for JsonEx responses. Catches exceptions as well", "id": "f4141:m2"}
{"signature": "def _parse_authentication(url):", "body": "u = url<EOL>h = {}  <EOL>if url in _parse_authentication._memoize:<EOL><INDENT>u, h = _parse_authentication._memoize[url]<EOL><DEDENT>else:<EOL><INDENT>p = urlsplit(url, '<STR_LIT:http>')<EOL>if p.username and p.password:<EOL><INDENT>h['<STR_LIT>'] = b'<STR_LIT>' + base64.b64encode(p.username.encode() + b'<STR_LIT::>' + p.password.encode())<EOL>u = urlunsplit((p.scheme, p.netloc.split('<STR_LIT:@>', <NUM_LIT:1>)[<NUM_LIT:1>], p.path, p.query, p.fragment))<EOL><DEDENT>_parse_authentication._memoize[url] = (u, h)<EOL><DEDENT>return u, h<EOL>", "docstring": "Parse authentication data from the URL and put it in the `headers` dict. With caching behavior\n    :param url: URL\n    :type url: str\n    :return: (URL without authentication info, headers dict)\n    :rtype: str, dict", "id": "f4141:m3"}
{"signature": "def __init__(self, gateway, name, server_url):", "body": "self.server_url = server_url.rstrip('<STR_LIT:/>') + '<STR_LIT:/>'  <EOL>super(ForwardClientProvider, self).__init__(gateway, name)<EOL>", "docstring": "Init the forwarding client\n        :param server_url: Server URL.\n            The URL should point to ForwardServerProvider registered on the server\n        :type server_url: str", "id": "f4141:c0:m0"}
{"signature": "def received(self, src, body):", "body": "<EOL>self._msgid += <NUM_LIT:1><EOL>message = IncomingMessage(src, body, self._msgid)<EOL>self._traffic.append(message)<EOL>self._receive_message(message)<EOL>return message<EOL>", "docstring": "Simulate an incoming message\n\n            :type src: str\n            :param src: Message source\n            :type boby: str | unicode\n            :param body: Message body\n            :rtype: IncomingMessage", "id": "f4147:c0:m2"}
{"signature": "def subscribe(self, number, callback):", "body": "self._subscribers[digits_only(number)] = callback<EOL>return self<EOL>", "docstring": "Register a virtual subscriber which receives messages to the matching number.\n\n            :type number: str\n            :param number: Subscriber phone number\n            :type callback: callable\n            :param callback: A callback(OutgoingMessage) which handles the messages directed to the subscriber.\n                The message object is augmented with the .reply(str) method which allows to send a reply easily!\n            :rtype: LoopbackProvider", "id": "f4147:c0:m3"}
{"signature": "def multiply(traj):", "body": "z = traj.x * traj.y<EOL>traj.f_add_result('<STR_LIT:z>', z, comment='<STR_LIT>')<EOL>", "docstring": "Example of a sophisticated numerical experiment\n    that involves multiplying two integer values.\n\n    :param traj:\n        Trajectory containing the parameters in a particular\n        combination, it also serves as a container for results.", "id": "f4154:m0"}
{"signature": "def no_op_wraps(func):", "body": "def wrapper(decorator):<EOL><INDENT>return func<EOL><DEDENT>return wrapper<EOL>", "docstring": "Replaces functools.wraps in order to undo wrapping.\n\n    Can be used to preserve the decorated function's signature\n    in the documentation generated by Sphinx.", "id": "f4155:m0"}
{"signature": "@staticmethod<EOL><INDENT>def _apply_fast_access(data, fast_access):<DEDENT>", "body": "if fast_access and data.f_supports_fast_access():<EOL><INDENT>return data.f_get()<EOL><DEDENT>else:<EOL><INDENT>return data<EOL><DEDENT>", "docstring": "Method that checks if fast access is possible and applies it if desired", "id": "f4156:c6:m26"}
{"signature": "@property<EOL><INDENT>def v_full_name(self):<DEDENT>", "body": "return self._full_name<EOL>", "docstring": "The full name, relative to the root node.\n\n        The full name of a trajectory or single run is the empty string since it is root.", "id": "f4156:c3:m10"}
{"signature": "def _remove_node_or_leaf(self, instance, recursive=False):", "body": "full_name = instance.v_full_name<EOL>split_name = deque(full_name.split('<STR_LIT:.>'))<EOL>self._remove_along_branch(self._root_instance, split_name, recursive)<EOL>", "docstring": "Removes a single node from the tree.\n\n        Only from RAM not from hdf5 file!\n\n        :param instance: The node to be deleted\n\n        :param recursive: If group nodes with children should be deleted", "id": "f4156:c6:m10"}
{"signature": "@property<EOL><INDENT>def vars(self):<DEDENT>", "body": "if self._vars is None:<EOL><INDENT>self._vars = NNTreeNodeVars(self)<EOL><DEDENT>return self._vars<EOL>", "docstring": "Alternative naming, you can use `node.vars.name` instead of `node.v_name`", "id": "f4156:c3:m1"}
{"signature": "def _create_any_param_or_result(self, parent_node, name, type_name, instance, constructor,<EOL>args, kwargs):", "body": "root = self._root_instance<EOL>full_name = self._make_full_name(parent_node.v_full_name, name)<EOL>if instance is None:<EOL><INDENT>if constructor is None:<EOL><INDENT>if type_name == RESULT:<EOL><INDENT>constructor = root._standard_result<EOL><DEDENT>elif type_name in [PARAMETER, CONFIG, DERIVED_PARAMETER]:<EOL><INDENT>constructor = root._standard_parameter<EOL><DEDENT>else:<EOL><INDENT>constructor = root._standard_leaf<EOL><DEDENT><DEDENT>instance = root._construct_instance(constructor, full_name, *args, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>instance._rename(full_name)<EOL><DEDENT>self._set_details_tree_node(parent_node, name, instance)<EOL>where_dict = self._map_type_to_dict(type_name)<EOL>full_name = instance._full_name<EOL>if full_name in where_dict:<EOL><INDENT>raise AttributeError(full_name + '<STR_LIT>')<EOL><DEDENT>if type_name != RESULT and full_name in root._changed_default_parameters:<EOL><INDENT>self._logger.info(<EOL>'<STR_LIT>' %<EOL>full_name)<EOL>change_args, change_kwargs = root._changed_default_parameters.pop(full_name)<EOL>instance.f_set(*change_args, **change_kwargs)<EOL><DEDENT>where_dict[full_name] = instance<EOL>self._add_to_nodes_and_leaves(instance)<EOL>parent_node._children[name] = instance<EOL>parent_node._leaves[name] = instance<EOL>if full_name in self._root_instance._explored_parameters:<EOL><INDENT>instance._explored = True  <EOL>self._root_instance._explored_parameters[full_name] = instance<EOL><DEDENT>self._logger.debug('<STR_LIT>' % full_name)<EOL>return instance<EOL>", "docstring": "Generically creates a novel parameter or result instance inferring from the `type_name`.\n\n        If the instance is already supplied it is NOT constructed new.\n\n        :param parent_node:\n\n            Parent trajectory node\n\n        :param name:\n\n            Name of the new result or parameter. Here the name no longer contains colons.\n\n        :param type_name:\n\n            Whether it is a parameter below parameters, config, derived parameters or whether\n            it is a result.\n\n        :param instance:\n\n            The instance if it has been constructed somewhere else, otherwise None.\n\n        :param constructor:\n\n            A constructor used if instance needs to be constructed. If None the current standard\n            constructor is chosen.\n\n        :param args:\n\n            Additional arguments passed to the constructor\n\n        :param kwargs:\n\n            Additional keyword arguments passed to the constructor\n\n        :return: The new instance", "id": "f4156:c6:m23"}
{"signature": "def _create_link(self, act_node, name, instance):", "body": "act_node._links[name] = instance<EOL>act_node._children[name] = instance<EOL>full_name = instance.v_full_name<EOL>if full_name not in self._root_instance._linked_by:<EOL><INDENT>self._root_instance._linked_by[full_name] = {}<EOL><DEDENT>linking = self._root_instance._linked_by[full_name]<EOL>if act_node.v_full_name not in linking:<EOL><INDENT>linking[act_node.v_full_name] = (act_node, set())<EOL><DEDENT>linking[act_node.v_full_name][<NUM_LIT:1>].add(name)<EOL>if name not in self._links_count:<EOL><INDENT>self._links_count[name] = <NUM_LIT:0><EOL><DEDENT>self._links_count[name] = self._links_count[name] + <NUM_LIT:1><EOL>self._logger.debug('<STR_LIT>'<EOL>'<STR_LIT>' % (name, act_node.v_full_name,<EOL>instance.v_full_name))<EOL>return instance<EOL>", "docstring": "Creates a link and checks if names are appropriate", "id": "f4156:c6:m20"}
{"signature": "def f_add_result_group(self, *args, **kwargs):", "body": "return self._nn_interface._add_generic(self, type_name=RESULT_GROUP,<EOL>group_type_name=RESULT_GROUP,<EOL>args=args, kwargs=kwargs)<EOL>", "docstring": "Adds an empty result group under the current node.\n\n        Adds the full name of the current node as prefix to the name of the group.\n        If current node is a single run (root) adds the prefix `'results.runs.run_08%d%'` to the\n        full name where `'08%d'` is replaced by the index of the current run.\n\n        The `name` can also contain subgroups separated via colons, for example:\n        `name=subgroup1.subgroup2.subgroup3`. These other parent groups will be automatically\n        be created.", "id": "f4156:c9:m0"}
{"signature": "def _get_all(self, node, name, max_depth, shortcuts):", "body": "if max_depth is None:<EOL><INDENT>max_depth = float('<STR_LIT>')<EOL><DEDENT>if isinstance(name, list):<EOL><INDENT>split_name = name<EOL><DEDENT>elif isinstance(name, tuple):<EOL><INDENT>split_name = list(name)<EOL><DEDENT>elif isinstance(name, int):<EOL><INDENT>split_name = [name]<EOL><DEDENT>else:<EOL><INDENT>split_name = name.split('<STR_LIT:.>')<EOL><DEDENT>for idx, key in enumerate(split_name):<EOL><INDENT>_, key = self._translate_shortcut(key)<EOL>_, key = self._replace_wildcards(key)<EOL>split_name[idx] = key<EOL><DEDENT>return self._backwards_search(node, split_name, max_depth, shortcuts)<EOL>", "docstring": "Searches for all occurrences of `name` under `node`.\n\n        :param node:\n\n            Start node\n\n        :param name:\n\n            Name what to look for can be longer and separated by colons, i.e.\n            `mygroupA.mygroupB.myparam`.\n\n        :param max_depth:\n\n            Maximum depth to search for relative to start node.\n\n        :param shortcuts:\n\n            If shortcuts are allowed\n\n        :return:\n\n            List of nodes that match the name, empty list if nothing was found.", "id": "f4156:c6:m35"}
{"signature": "def f_add_leaf(self, *args, **kwargs):", "body": "return self._nn_interface._add_generic(self, type_name=LEAF,<EOL>group_type_name=GROUP,<EOL>args=args, kwargs=kwargs,<EOL>add_prefix=False)<EOL>", "docstring": "Adds an empty generic leaf under the current node.\n\n        You can add to a generic leaves anywhere you want. So you are free to build\n        your trajectory tree with any structure. You do not necessarily have to follow the\n        four subtrees `config`, `parameters`, `derived_parameters`, `results`.\n\n        If you are operating within these subtrees this simply calls the corresponding adding\n        function.\n\n        Be aware that if you are within a single run and you add items not below a group\n        `run_XXXXXXXX` that you have to manually\n        save the items. Otherwise they will be lost after the single run is completed.", "id": "f4156:c7:m21"}
{"signature": "def f_add_result(self, *args, **kwargs):", "body": "return self._nn_interface._add_generic(self, type_name=RESULT,<EOL>group_type_name=RESULT_GROUP,<EOL>args=args, kwargs=kwargs)<EOL>", "docstring": "Adds a result under the current node.\n\n        There are two ways to add a new result either by adding a result instance:\n\n        >>> new_result = Result('group1.group2.myresult', 1666, x=3, y=4, comment='Example!')\n        >>> traj.f_add_result(new_result)\n\n        Or by passing the values directly to the function, with the name being the first\n        (non-keyword!) argument:\n\n        >>> traj.f_add_result('group1.group2.myresult', 1666, x=3, y=3,comment='Example!')\n\n\n        If you want to create a different result than the standard result, you can\n        give the constructor as the first (non-keyword!) argument followed by the name\n        (non-keyword!):\n\n        >>> traj.f_add_result(PickleResult,'group1.group2.myresult', 1666, x=3, y=3, comment='Example!')\n\n        Additional arguments (here `1666`) or keyword arguments (here `x=3, y=3`) are passed\n        onto the constructor of the result.\n\n\n        Adds the full name of the current node as prefix to the name of the result.\n        If current node is a single run (root) adds the prefix `'results.runs.run_08%d%'` to the\n        full name where `'08%d'` is replaced by the index of the current run.", "id": "f4156:c9:m1"}
{"signature": "@property<EOL><INDENT>def v_branch(self):<DEDENT>", "body": "return self._branch<EOL>", "docstring": "The name of the branch/subtree, i.e. the first node below the root.\n\n        The empty string in case of root itself.", "id": "f4156:c3:m14"}
{"signature": "@staticmethod<EOL><INDENT>def _determine_types(start_node, first_name, add_leaf, add_link):<DEDENT>", "body": "if start_node.v_is_root:<EOL><INDENT>where = first_name<EOL><DEDENT>else:<EOL><INDENT>where = start_node._branch<EOL><DEDENT>if where in SUBTREE_MAPPING:<EOL><INDENT>type_tuple = SUBTREE_MAPPING[where]<EOL><DEDENT>else:<EOL><INDENT>type_tuple = (GROUP, LEAF)<EOL><DEDENT>if add_link:<EOL><INDENT>return type_tuple[<NUM_LIT:0>], LINK<EOL><DEDENT>if add_leaf:<EOL><INDENT>return type_tuple<EOL><DEDENT>else:<EOL><INDENT>return type_tuple[<NUM_LIT:0>], type_tuple[<NUM_LIT:0>]<EOL><DEDENT>", "docstring": "Determines types for generic additions", "id": "f4156:c6:m14"}
{"signature": "def f_get_all(self, name, max_depth=None, shortcuts=True):", "body": "return self._nn_interface._get_all(self, name, max_depth=max_depth, shortcuts=shortcuts)<EOL>", "docstring": "Searches for all occurrences of `name` under `node`.\n\n        Links are NOT considered since nodes are searched bottom up in the tree.\n\n        :param node:\n\n            Start node\n\n        :param name:\n\n            Name of what to look for, can be separated by colons, i.e.\n            ``'mygroupA.mygroupB.myparam'``.\n\n        :param max_depth:\n\n            Maximum search depth relative to start node.\n            `None` for no limit.\n\n        :param shortcuts:\n\n            If shortcuts are allowed, otherwise the stated name defines a\n            consecutive name.For instance. ``'mygroupA.mygroupB.myparam'`` would\n            also find ``mygroupA.mygroupX.mygroupB.mygroupY.myparam`` if shortcuts\n            are allowed, otherwise not.\n\n        :return:\n\n            List of nodes that match the name, empty list if nothing was found.", "id": "f4156:c7:m41"}
{"signature": "def _very_fast_search(self, node, key, max_depth, with_links, crun):", "body": "if key in self._links_count:<EOL><INDENT>return<EOL><DEDENT>parent_full_name = node.v_full_name<EOL>starting_depth = node.v_depth<EOL>candidate_dict = self._get_candidate_dict(key, crun)<EOL>if with_links:<EOL><INDENT>upper_bound = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>upper_bound = FAST_UPPER_BOUND<EOL><DEDENT>if len(candidate_dict) > upper_bound:<EOL><INDENT>raise pex.TooManyGroupsError('<STR_LIT>')<EOL><DEDENT>result_node = None<EOL>for goal_name in candidate_dict:<EOL><INDENT>if goal_name.startswith(parent_full_name):<EOL><INDENT>candidate = candidate_dict[goal_name]<EOL>if candidate.v_depth - starting_depth <= max_depth:<EOL><INDENT>if result_node is not None:<EOL><INDENT>raise pex.NotUniqueNodeError('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>% (key, goal_name, result_node.v_full_name))<EOL><DEDENT>result_node = candidate<EOL><DEDENT><DEDENT><DEDENT>if result_node is not None:<EOL><INDENT>return result_node, result_node.v_depth<EOL><DEDENT>", "docstring": "Fast search for a node in the tree.\n\n        The tree is not traversed but the reference dictionaries are searched.\n\n        :param node:\n\n            Parent node to start from\n\n        :param key:\n\n            Name of node to find\n\n        :param max_depth:\n\n            Maximum depth.\n\n        :param with_links:\n\n            If we work with links than we can only be sure to found the node in case we\n            have a single match. Otherwise the other match might have been linked as well.\n\n        :param crun:\n\n            If given only nodes belonging to this particular run are searched and the rest\n            is blinded out.\n\n        :return: The found node and its depth\n\n        :raises:\n\n            TooManyGroupsError:\n\n                If search cannot performed fast enough, an alternative search method is needed.\n\n            NotUniqueNodeError:\n\n                If several nodes match the key criterion", "id": "f4156:c6:m32"}
{"signature": "def f_add_parameter_group(self, *args, **kwargs):", "body": "return self._nn_interface._add_generic(self, type_name=PARAMETER_GROUP,<EOL>group_type_name=PARAMETER_GROUP,<EOL>args=args, kwargs=kwargs)<EOL>", "docstring": "Adds an empty parameter group under the current node.\n\n        Can be called with ``f_add_parameter_group('MyName', 'this is an informative comment')``\n        or ``f_add_parameter_group(name='MyName', comment='This is an informative comment')``\n        or with a given new group instance:\n        ``f_add_parameter_group(ParameterGroup('MyName', comment='This is a comment'))``.\n\n        Adds the full name of the current node as prefix to the name of the group.\n        If current node is the trajectory (root), the prefix `'parameters'`\n        is added to the full name.\n\n        The `name` can also contain subgroups separated via colons, for example:\n        `name=subgroup1.subgroup2.subgroup3`. These other parent groups will be automatically\n        created.", "id": "f4156:c8:m0"}
{"signature": "def _get(self, node, name, fast_access,<EOL>shortcuts, max_depth, auto_load, with_links):", "body": "if auto_load and not with_links:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if isinstance(name, list):<EOL><INDENT>split_name = name<EOL><DEDENT>elif isinstance(name, tuple):<EOL><INDENT>split_name = list(name)<EOL><DEDENT>elif isinstance(name, int):<EOL><INDENT>split_name = [name]<EOL><DEDENT>else:<EOL><INDENT>split_name = name.split('<STR_LIT:.>')<EOL><DEDENT>if node.v_is_root:<EOL><INDENT>if len(split_name) == <NUM_LIT:1> and split_name[<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>return node<EOL><DEDENT>key = split_name[<NUM_LIT:0>]<EOL>_, key = self._translate_shortcut(key)<EOL>if key in SUBTREE_MAPPING and key not in node._children:<EOL><INDENT>node.f_add_group(key)<EOL><DEDENT><DEDENT>if max_depth is None:<EOL><INDENT>max_depth = float('<STR_LIT>')<EOL><DEDENT>if len(split_name) > max_depth and shortcuts:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>' %<EOL>(str(name), max_depth))<EOL><DEDENT>try_auto_load_directly1 = False<EOL>try_auto_load_directly2 = False<EOL>wildcard_positions = []<EOL>root = self._root_instance<EOL>for idx, key in enumerate(split_name):<EOL><INDENT>translated_shortcut, key = self._translate_shortcut(key)<EOL>if translated_shortcut:<EOL><INDENT>split_name[idx] = key<EOL><DEDENT>if key[<NUM_LIT:0>] == '<STR_LIT:_>':<EOL><INDENT>raise AttributeError('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % key)<EOL><DEDENT>is_wildcard = self._root_instance.f_is_wildcard(key)<EOL>if (not is_wildcard and key not in self._nodes_and_leaves and<EOL>key not in self._links_count):<EOL><INDENT>try_auto_load_directly1 = True<EOL>try_auto_load_directly2 = True<EOL><DEDENT>if is_wildcard:<EOL><INDENT>wildcard_positions.append((idx, key))<EOL>if root.f_wildcard(key) not in self._nodes_and_leaves:<EOL><INDENT>try_auto_load_directly1 = True<EOL><DEDENT>if root.f_wildcard(key, -<NUM_LIT:1>) not in self._nodes_and_leaves:<EOL><INDENT>try_auto_load_directly2 = True<EOL><DEDENT><DEDENT><DEDENT>run_idx = root.v_idx<EOL>wildcard_exception = None <EOL>if try_auto_load_directly1 and try_auto_load_directly2 and not auto_load:<EOL><INDENT>for wildcard_pos, wildcard in wildcard_positions:<EOL><INDENT>split_name[wildcard_pos] = root.f_wildcard(wildcard, run_idx)<EOL><DEDENT>raise AttributeError('<STR_LIT>' %<EOL>str('<STR_LIT:.>'.join(split_name)))<EOL><DEDENT>if run_idx > -<NUM_LIT:1>:<EOL><INDENT>with self._disable_logging:<EOL><INDENT>try:<EOL><INDENT>for wildcard_pos, wildcard in wildcard_positions:<EOL><INDENT>split_name[wildcard_pos] = root.f_wildcard(wildcard, run_idx)<EOL><DEDENT>result = self._perform_get(node, split_name, fast_access,<EOL>shortcuts, max_depth, auto_load, with_links,<EOL>try_auto_load_directly1)<EOL>return result<EOL><DEDENT>except (pex.DataNotInStorageError, AttributeError) as exc:<EOL><INDENT>wildcard_exception = exc<EOL><DEDENT><DEDENT><DEDENT>if wildcard_positions:<EOL><INDENT>for wildcard_pos, wildcard in wildcard_positions:<EOL><INDENT>split_name[wildcard_pos] = root.f_wildcard(wildcard, -<NUM_LIT:1>)<EOL><DEDENT><DEDENT>try:<EOL><INDENT>return self._perform_get(node, split_name, fast_access,<EOL>shortcuts, max_depth, auto_load, with_links,<EOL>try_auto_load_directly2)<EOL><DEDENT>except (pex.DataNotInStorageError, AttributeError):<EOL><INDENT>if wildcard_exception is not None:<EOL><INDENT>raise wildcard_exception<EOL><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>", "docstring": "Searches for an item (parameter/result/group node) with the given `name`.\n\n        :param node: The node below which the search is performed\n\n        :param name: Name of the item (full name or parts of the full name)\n\n        :param fast_access: If the result is a parameter, whether fast access should be applied.\n\n        :param max_depth:\n\n            Maximum search depth relative to start node.\n\n        :param auto_load:\n\n            If data should be automatically loaded\n\n        :param with_links\n\n            If links should be considered\n\n        :return:\n\n            The found instance (result/parameter/group node) or if fast access is True and you\n            found a parameter or result that supports fast access, the contained value is returned.\n\n        :raises:\n\n            AttributeError if no node with the given name can be found.\n            Raises errors that are raised by the storage service if `auto_load=True` and\n            item cannot be found.", "id": "f4156:c6:m37"}
{"signature": "def _add_group_from_storage(self, args, kwargs):", "body": "return self._nn_interface._add_generic(self,<EOL>type_name=GROUP,<EOL>group_type_name=GROUP,<EOL>args=args,<EOL>kwargs=kwargs,<EOL>add_prefix=False,<EOL>check_naming=False)<EOL>", "docstring": "Can be called from storage service to create a new group to bypass name checking", "id": "f4156:c7:m10"}
{"signature": "def _iter_nodes(self, node, recursive=False, max_depth=float('<STR_LIT>'),<EOL>with_links=True, in_search=False, predicate=None):", "body": "def _run_predicate(x, run_name_set):<EOL><INDENT>branch = x.v_run_branch<EOL>return branch == '<STR_LIT>' or branch in run_name_set<EOL><DEDENT>if max_depth is None:<EOL><INDENT>max_depth = float('<STR_LIT>')<EOL><DEDENT>if predicate is None:<EOL><INDENT>predicate = lambda x: True<EOL><DEDENT>elif isinstance(predicate, (tuple, list)):<EOL><INDENT>run_list = predicate<EOL>run_name_set = set()<EOL>for item in run_list:<EOL><INDENT>if item == -<NUM_LIT:1>:<EOL><INDENT>run_name_set.add(self._root_instance.f_wildcard('<STR_LIT:$>', -<NUM_LIT:1>))<EOL><DEDENT>elif isinstance(item, int):<EOL><INDENT>run_name_set.add(self._root_instance.f_idx_to_run(item))<EOL><DEDENT>else:<EOL><INDENT>run_name_set.add(item)<EOL><DEDENT><DEDENT>predicate = lambda x: _run_predicate(x, run_name_set)<EOL><DEDENT>if recursive:<EOL><INDENT>return NaturalNamingInterface._recursive_traversal_bfs(node,<EOL>self._root_instance._linked_by,<EOL>max_depth, with_links,<EOL>in_search, predicate)<EOL><DEDENT>else:<EOL><INDENT>iterator = (x for x in self._make_child_iterator(node, with_links) if<EOL>predicate(x[<NUM_LIT:2>]))<EOL>if in_search:<EOL><INDENT>return iterator <EOL><DEDENT>else:<EOL><INDENT>return (x[<NUM_LIT:2>] for x in iterator)<EOL><DEDENT><DEDENT>", "docstring": "Returns an iterator over nodes hanging below a given start node.\n\n        :param node:\n\n            Start node\n\n        :param recursive:\n\n            Whether recursively also iterate over the children of the start node's children\n\n        :param max_depth:\n\n            Maximum depth to search for\n\n        :param in_search:\n\n            if it is used during get search and if detailed info should be returned\n\n        :param with_links:\n\n            If links should be considered\n\n        :param predicate:\n\n            A predicate to filter nodes\n\n        :return: Iterator", "id": "f4156:c6:m27"}
{"signature": "def f_debug(self):", "body": "return self._debug()<EOL>", "docstring": "Creates a dummy object containing the whole tree to make unfolding easier.\n\n        This method is only useful for debugging purposes.\n        If you use an IDE and want to unfold the trajectory tree, you always need to\n        open the private attribute `_children`. Use to this function to create a new\n        object that contains the tree structure in its attributes.\n\n        Manipulating the returned object does not change the original tree!", "id": "f4156:c7:m15"}
{"signature": "def f_has_leaves(self):", "body": "return len(self._leaves) != <NUM_LIT:0><EOL>", "docstring": "Checks if node has leaves or not", "id": "f4156:c7:m27"}
{"signature": "def __dir__(self):", "body": "result = super(NNGroupNode, self).__dir__()<EOL>if not is_debug():<EOL><INDENT>result.extend(self.f_dir_data())<EOL><DEDENT>return result<EOL>", "docstring": "Adds all children to auto-completion", "id": "f4156:c7:m13"}
{"signature": "def f_has_links(self):", "body": "return len(self._links) != <NUM_LIT:0><EOL>", "docstring": "Checks if node has children or not", "id": "f4156:c7:m23"}
{"signature": "def _add_leaf_from_storage(self, args, kwargs):", "body": "return self._nn_interface._add_generic(self,<EOL>type_name=LEAF,<EOL>group_type_name=GROUP,<EOL>args=args, kwargs=kwargs,<EOL>add_prefix=False,<EOL>check_naming=False)<EOL>", "docstring": "Can be called from storage service to create a new leaf to bypass name checking", "id": "f4156:c7:m11"}
{"signature": "def f_add_link(self, name_or_item, full_name_or_item=None):", "body": "if isinstance(name_or_item, str):<EOL><INDENT>name = name_or_item<EOL>if isinstance(full_name_or_item, str):<EOL><INDENT>instance = self.v_root.f_get(full_name_or_item)<EOL><DEDENT>else:<EOL><INDENT>instance =  full_name_or_item<EOL><DEDENT><DEDENT>else:<EOL><INDENT>instance = name_or_item<EOL>name = instance.v_name<EOL><DEDENT>return self._nn_interface._add_generic(self, type_name=LINK,<EOL>group_type_name=GROUP, args=(name, instance),<EOL>kwargs={},<EOL>add_prefix=False)<EOL>", "docstring": "Adds a link to an existing node.\n\n        Can be called as ``node.f_add_link(other_node)`` this will add a link the `other_node`\n        with the link name as the name of the node.\n\n        Or can be called as ``node.f_add_link(name, other_node)`` to add a link to the\n        `other_node` and the given `name` of the link.\n\n        In contrast to addition of groups and leaves,  colon separated names\n        are **not** allowed, i.e. ``node.f_add_link('mygroup.mylink', other_node)``\n        does not work.", "id": "f4156:c7:m19"}
{"signature": "def __getitem__(self, item):", "body": "return self._nn_interface._get(self, item,<EOL>fast_access=self.v_root.v_fast_access,<EOL>shortcuts=self.v_root.v_shortcuts,<EOL>max_depth=self.v_root.v_max_depth,<EOL>auto_load=self.v_root.v_auto_load,<EOL>with_links=self.v_root.v_with_links)<EOL>", "docstring": "Equivalent to calling `__getattr__`.\n\n        Per default the item is returned and fast access is applied.", "id": "f4156:c7:m36"}
{"signature": "def f_add_derived_parameter_group(self, *args, **kwargs):", "body": "return self._nn_interface._add_generic(self, type_name=DERIVED_PARAMETER_GROUP,<EOL>group_type_name=DERIVED_PARAMETER_GROUP,<EOL>args=args, kwargs=kwargs)<EOL>", "docstring": "Adds an empty derived parameter group under the current node.\n\n        Adds the full name of the current node as prefix to the name of the group.\n        If current node is a single run (root) adds the prefix `'derived_parameters.runs.run_08%d%'`\n        to the full name where `'08%d'` is replaced by the index of the current run.\n\n        The `name` can also contain subgroups separated via colons, for example:\n        `name=subgroup1.subgroup2.subgroup3`. These other parent groups will be automatically\n        be created.", "id": "f4156:c10:m0"}
{"signature": "def execute_network_pre_run(self, traj, network, network_dict, component_list, analyser_list):", "body": "self._execute_network_run(traj, network, network_dict, component_list, analyser_list,<EOL>pre_run=True)<EOL>", "docstring": "Runs a network before the actual experiment.\n\n        Called by a :class:`~pypet.brian2.network.NetworkManager`.\n        Similar to :func:`~pypet.brian2.network.NetworkRunner.run_network`.\n\n        Subruns and their durations are extracted from the trajectory. All\n        :class:`~pypet.brian2.parameter.Brian2Parameter` instances found under\n        `traj.parameters.simulation.pre_durations` (default, you can change the\n        name of the group where to search for durations at runner initialisation).\n        The order is determined from\n        the `v_annotations.order` attributes. There must be at least one subrun in the trajectory,\n        otherwise an AttributeError is thrown. If two subruns equal in their order\n        property a RuntimeError is thrown.\n\n        :param traj: Trajectory container\n\n        :param network: BRIAN2 network\n\n        :param network_dict: Dictionary of items shared among all components\n\n        :param component_list: List of :class:`~pypet.brian2.network.NetworkComponent` objects\n\n        :param analyser_list: List of :class:`~pypet.brian2.network.NetworkAnalyser` objects", "id": "f4158:c2:m1"}
{"signature": "def _extract_subruns(self, traj, pre_run=False):", "body": "if pre_run:<EOL><INDENT>durations_list = traj.f_get_all(self._pre_durations_group_name)<EOL><DEDENT>else:<EOL><INDENT>durations_list = traj.f_get_all(self._durations_group_name)<EOL><DEDENT>subruns = {}<EOL>orders = []<EOL>for durations in durations_list:<EOL><INDENT>for duration_param in durations.f_iter_leaves(with_links=False):<EOL><INDENT>if '<STR_LIT>' in duration_param.v_annotations:<EOL><INDENT>order = duration_param.v_annotations.order<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>duration_param.v_full_name)<EOL><DEDENT>if order in subruns:<EOL><INDENT>raise RuntimeError('<STR_LIT>'<EOL>'<STR_LIT>' % order)<EOL><DEDENT>else:<EOL><INDENT>subruns[order] = duration_param<EOL>orders.append(order)<EOL><DEDENT><DEDENT><DEDENT>return [subruns[order] for order in sorted(orders)]<EOL>", "docstring": "Extracts subruns from the trajectory.\n\n        :param traj: Trajectory container\n\n        :param pre_run: Boolean whether current run is regular or a pre-run\n\n        :raises: RuntimeError if orders are duplicates or even missing", "id": "f4158:c2:m3"}
{"signature": "def add_parameters(self, traj):", "body": "pass<EOL>", "docstring": "Adds parameters to `traj`.\n\n        Function called from the :class:`~pypet.brian2.network.NetworkManager` to\n        define and add parameters to the trajectory container.", "id": "f4158:c0:m0"}
{"signature": "def add_to_network(self, traj, network, current_subrun, subrun_list, network_dict):", "body": "pass<EOL>", "docstring": "Can add network objects before a specific `subrun`.\n\n        Called by a :class:`~pypet.brian2.network.NetworkRunner` before a the\n        given `subrun`.\n\n        Potentially one wants to add some BRIAN2 objects later to the network than\n        at the very beginning of an experimental run. For example, a monitor might\n        be added at the second subrun after an initial phase that is not supposed\n        to be recorded.\n\n        :param traj: Trajectoy container\n\n        :param network:\n\n            BRIAN2 network where elements could be added via `add(...)`.\n\n        :param current_subrun:\n\n            :class:`~pypet.brian2.parameter.Brian2Parameter` specifying the very next\n            subrun to be simulated.\n\n        :param subrun_list:\n\n            List of :class:`~pypet.brian2.parameter.Brian2Parameter` objects that are to\n            be run after the current subrun.\n\n        :param network_dict:\n\n            Dictionary of items shared by all components.", "id": "f4158:c0:m3"}
{"signature": "def pre_build(self, traj):", "body": "self._logger.info('<STR_LIT>')<EOL>for component in self.components:<EOL><INDENT>component.pre_build(traj, self._brian_list, self._network_dict)<EOL><DEDENT>if self.analysers:<EOL><INDENT>self._logger.info('<STR_LIT>')<EOL>for analyser in self.analysers:<EOL><INDENT>analyser.pre_build(traj, self._brian_list, self._network_dict)<EOL><DEDENT><DEDENT>self._logger.info('<STR_LIT>')<EOL>self.network_runner.pre_build(traj, self._brian_list, self._network_dict)<EOL>self._pre_built = True<EOL>", "docstring": "Pre-builds network components.\n\n        Calls :func:`~pypet.brian2.network.NetworkComponent.pre_build` for all components,\n        analysers, and the network runner.\n\n        `pre_build` is not automatically called but either needs to be executed manually\n        by the user, either calling it directly or by using\n        :func:`~pypet.brian2.network.NetworkManager.pre_run`.\n\n        This function does not create a `BRIAN2 network`, but only it's components.\n\n        :param traj: Trajectory container", "id": "f4158:c3:m2"}
{"signature": "def add_parameters(self, traj):", "body": "self._logger.info('<STR_LIT>')<EOL>for component in self.components:<EOL><INDENT>component.add_parameters(traj)<EOL><DEDENT>if self.analysers:<EOL><INDENT>self._logger.info('<STR_LIT>')<EOL>for analyser in self.analysers:<EOL><INDENT>analyser.add_parameters(traj)<EOL><DEDENT><DEDENT>self._logger.info('<STR_LIT>')<EOL>self.network_runner.add_parameters(traj)<EOL>", "docstring": "Adds parameters for a network simulation.\n\n        Calls :func:`~pypet.brian2.network.NetworkComponent.add_parameters` for all components,\n        analyser, and the network runner (in this order).\n\n        :param traj:  Trajectory container", "id": "f4158:c3:m1"}
{"signature": "def f_set_single(self, name, item):", "body": "if type(item) in [SpikeMonitor, StateMonitor, PopulationRateMonitor]:<EOL><INDENT>if self.v_stored:<EOL><INDENT>self._logger.warning('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>self._extract_monitor_data(item)<EOL><DEDENT>else:<EOL><INDENT>super(Brian2MonitorResult, self).f_set_single(name, item)<EOL><DEDENT>", "docstring": "To add a monitor use `f_set_single('monitor', brian_monitor)`.\n\n        Otherwise `f_set_single` works similar to :func:`~pypet.parameter.Result.f_set_single`.", "id": "f4159:c2:m4"}
{"signature": "def _supports(self, data):", "body": "if isinstance(data, Quantity):<EOL><INDENT>return True<EOL><DEDENT>elif super(Brian2Result, self)._supports(data):<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Simply checks if data is supported", "id": "f4159:c1:m2"}
{"signature": "@property<EOL><INDENT>def v_monitor_type(self):<DEDENT>", "body": "return self._monitor_type<EOL>", "docstring": "The type of the stored monitor. Each MonitorResult can only manage a single Monitor.", "id": "f4159:c2:m3"}
{"signature": "def get_random_port_url():", "body": "url = port_to_tcp()<EOL>errwrite('<STR_LIT>' % url)<EOL>return url<EOL>", "docstring": "Determines the local server url with a random port", "id": "f4160:m4"}
{"signature": "def get_log_path(traj, process_name=None):", "body": "return rename_log_file(generic_log_folder, trajectory=traj, process_name=process_name)<EOL>", "docstring": "Returns the path to the log files based on trajectory name etc.", "id": "f4160:m3"}
{"signature": "def prepare_log_config():", "body": "conf = testParams['<STR_LIT>']<EOL>pypet_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '<STR_LIT>'))<EOL>init_path = os.path.join(pypet_path, '<STR_LIT>')<EOL>if conf == '<STR_LIT:test>':<EOL><INDENT>conf_file = os.path.join(init_path, '<STR_LIT>')<EOL>conf_parser = handle_config_file(conf_file)<EOL>conf = conf_parser<EOL><DEDENT>elif conf == '<STR_LIT>':<EOL><INDENT>conf_file = os.path.join(init_path, '<STR_LIT>')<EOL>conf_parser = handle_config_file(conf_file)<EOL>conf = conf_parser<EOL><DEDENT>testParams['<STR_LIT>'] = conf<EOL>", "docstring": "Prepares the test logging init files and creates parsers.", "id": "f4160:m5"}
{"signature": "def remove_data():", "body": "global testParams<EOL>if testParams['<STR_LIT>']:<EOL><INDENT>get_root_logger().log(<NUM_LIT>, '<STR_LIT>')<EOL>shutil.rmtree(testParams['<STR_LIT>'], True)<EOL><DEDENT>", "docstring": "Removes all data from temporary folder", "id": "f4160:m12"}
{"signature": "def create_param_dict(param_dict):", "body": "param_dict['<STR_LIT>'] = {}<EOL>param_dict['<STR_LIT>'] = {}<EOL>param_dict['<STR_LIT>'] ={}<EOL>param_dict['<STR_LIT>'] = {}<EOL>param_dict['<STR_LIT>'] = {}<EOL>param_dict['<STR_LIT>'] ={}<EOL>param_dict['<STR_LIT>'] ={}<EOL>param_dict['<STR_LIT>']={}<EOL>normal_dict = param_dict['<STR_LIT>']<EOL>normal_dict['<STR_LIT:string>'] = '<STR_LIT>'<EOL>normal_dict['<STR_LIT:int>'] = <NUM_LIT><EOL>normal_dict['<STR_LIT>'] = <NUM_LIT><EOL>normal_dict['<STR_LIT>'] = <NUM_LIT><EOL>normal_dict['<STR_LIT:bool>'] =True<EOL>normal_dict['<STR_LIT>'] = <NUM_LIT:0><EOL>numpy_dict=param_dict['<STR_LIT>']<EOL>numpy_dict['<STR_LIT:string>'] = np.array(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>numpy_dict['<STR_LIT:int>'] = np.array([<NUM_LIT:1>,<NUM_LIT:2>,<NUM_LIT:3>,<NUM_LIT:4>])<EOL>numpy_dict['<STR_LIT>'] = np.array([<NUM_LIT:1.0>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT>])<EOL>numpy_dict['<STR_LIT:bool>'] = np.array([True, False, True])<EOL>param_dict['<STR_LIT>']['<STR_LIT>'] = np.matrix([[<NUM_LIT:1.0>,<NUM_LIT>],[<NUM_LIT>,<NUM_LIT>]])<EOL>param_dict['<STR_LIT>']['<STR_LIT>'] = np.array([[[<NUM_LIT:1.0>,<NUM_LIT>],[<NUM_LIT>,<NUM_LIT>]],[[<NUM_LIT>,-<NUM_LIT>],[<NUM_LIT>,<NUM_LIT>]]])<EOL>spsparse_csc = spsp.lil_matrix((<NUM_LIT>,<NUM_LIT>))<EOL>spsparse_csc[<NUM_LIT:1>,<NUM_LIT:2>] = <NUM_LIT><EOL>spsparse_csc[<NUM_LIT:1>,<NUM_LIT:9>] = <NUM_LIT><EOL>spsparse_csc = spsparse_csc.tocsc()<EOL>spsparse_csr = spsp.lil_matrix((<NUM_LIT>,<NUM_LIT>))<EOL>spsparse_csr[<NUM_LIT:1>,<NUM_LIT:3>] = <NUM_LIT><EOL>spsparse_csr[<NUM_LIT>,<NUM_LIT>] = <NUM_LIT><EOL>spsparse_csr = spsparse_csr.tocsr()<EOL>spsparse_bsr = spsp.bsr_matrix(np.matrix([[<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:2>, <NUM_LIT:2>],<EOL>[<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:2>, <NUM_LIT:2>],<EOL>[<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:3>, <NUM_LIT:3>],<EOL>[<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:3>, <NUM_LIT:3>],<EOL>[<NUM_LIT:4>, <NUM_LIT:4>, <NUM_LIT:5>, <NUM_LIT:5>, <NUM_LIT:6>, <NUM_LIT:6>],<EOL>[<NUM_LIT:4>, <NUM_LIT:4>, <NUM_LIT:5>, <NUM_LIT:5>, <NUM_LIT:6>, <NUM_LIT:6>]]))<EOL>spsparse_dia = spsp.dia_matrix(np.matrix([[<NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:3>, <NUM_LIT:0>],<EOL>[<NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:0>, <NUM_LIT:4>],<EOL>[<NUM_LIT:0>, <NUM_LIT:2>, <NUM_LIT:3>, <NUM_LIT:0>],<EOL>[<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:3>, <NUM_LIT:4>]]))<EOL>param_dict['<STR_LIT>']['<STR_LIT>'] = spsparse_bsr<EOL>param_dict['<STR_LIT>']['<STR_LIT>'] = spsparse_csc<EOL>param_dict['<STR_LIT>']['<STR_LIT>'] = spsparse_csr<EOL>param_dict['<STR_LIT>']['<STR_LIT>'] = spsparse_dia<EOL>param_dict['<STR_LIT>']['<STR_LIT>'] = ()<EOL>param_dict['<STR_LIT>']['<STR_LIT:int>'] = (<NUM_LIT:1>,<NUM_LIT:2>,<NUM_LIT:3>)<EOL>param_dict['<STR_LIT>']['<STR_LIT:float>'] = (<NUM_LIT>,<NUM_LIT>,<NUM_LIT>)<EOL>param_dict['<STR_LIT>']['<STR_LIT:str>'] = ('<STR_LIT:1>','<STR_LIT>','<STR_LIT>')<EOL>param_dict['<STR_LIT>']['<STR_LIT>'] = []<EOL>param_dict['<STR_LIT>']['<STR_LIT>'] = [<NUM_LIT:1>,<NUM_LIT:2>,<NUM_LIT:3>]<EOL>param_dict['<STR_LIT>']['<STR_LIT>'] = [<NUM_LIT>,<NUM_LIT>,<NUM_LIT>]<EOL>param_dict['<STR_LIT>']['<STR_LIT>'] = ['<STR_LIT:1>','<STR_LIT>','<STR_LIT>']<EOL>param_dict['<STR_LIT>']['<STR_LIT:list>']= ['<STR_LIT:b>','<STR_LIT:h>', <NUM_LIT>, (), <NUM_LIT:0>]<EOL>param_dict['<STR_LIT>']['<STR_LIT:list>']= ['<STR_LIT:b>','<STR_LIT:h>', <NUM_LIT>, (), <NUM_LIT:1>]<EOL>param_dict['<STR_LIT>']['<STR_LIT:list>']= ['<STR_LIT:b>',[<NUM_LIT>,<NUM_LIT>], <NUM_LIT>, (),<NUM_LIT:2>]<EOL>", "docstring": "Fills a dictionary with some parameters that can be put into a trajectory.", "id": "f4161:m0"}
{"signature": "def clear_handlers(self):", "body": "root = logging.getLogger()<EOL>for logger in list(root.manager.loggerDict.values()) + [root]:<EOL><INDENT>if hasattr(logger, '<STR_LIT>'):<EOL><INDENT>handlers = logger.handlers<EOL>for handler in handlers:<EOL><INDENT>if hasattr(handler, '<STR_LIT>'):<EOL><INDENT>handler.flush()<EOL><DEDENT>if hasattr(handler, '<STR_LIT>'):<EOL><INDENT>handler.close()<EOL><DEDENT><DEDENT>logger.handlers = []<EOL><DEDENT><DEDENT>sys.stdout = sys.__stdout__<EOL>sys.stderr = sys.__stderr__<EOL>", "docstring": "Deletes all handlers and closes all log-files", "id": "f4161:c0:m1"}
{"signature": "def execute_example(filename):", "body": "<EOL>new_filename = None<EOL>try:<EOL><INDENT>new_filename = prepend_mpl_import(filename)<EOL>retcode = subprocess.call(sys.executable + '<STR_LIT:U+0020>' + new_filename, shell=True)<EOL>if retcode != <NUM_LIT:0>:<EOL><INDENT>print('<STR_LIT>' % filename)<EOL>sys.exit(retcode)<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>if new_filename is not None:<EOL><INDENT>os.remove(new_filename)<EOL><DEDENT><DEDENT>", "docstring": "Executes a file as script.\n\n    First prepends matplotlib import", "id": "f4163:m2"}
{"signature": "def _prm_add_meta_info(self, instance, group, overwrite=False):", "body": "if overwrite:<EOL><INDENT>flags = ()<EOL><DEDENT>else:<EOL><INDENT>flags = (HDF5StorageService.ADD_ROW,)<EOL><DEDENT>definitely_store_comment = True<EOL>try:<EOL><INDENT>definitely_store_comment = self._prm_meta_add_summary(instance)<EOL>try:<EOL><INDENT>table_name = instance.v_branch + '<STR_LIT>'<EOL>table = getattr(self._overview_group, table_name)<EOL>if len(table) < pypetconstants.HDF5_MAX_OVERVIEW_TABLE_LENGTH:<EOL><INDENT>self._all_store_param_or_result_table_entry(instance, table,<EOL>flags=flags)<EOL><DEDENT><DEDENT>except pt.NoSuchNodeError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>except Exception as exc:<EOL><INDENT>self._logger.error('<STR_LIT>' % repr(exc))<EOL><DEDENT>if ((not self._purge_duplicate_comments or definitely_store_comment) and<EOL>instance.v_comment != '<STR_LIT>'):<EOL><INDENT>setattr(group._v_attrs, HDF5StorageService.COMMENT, instance.v_comment)<EOL><DEDENT>setattr(group._v_attrs, HDF5StorageService.CLASS_NAME, instance.f_get_class_name())<EOL>setattr(group._v_attrs, HDF5StorageService.LEAF, True)<EOL>if instance.v_is_parameter and instance.v_explored:<EOL><INDENT>try:<EOL><INDENT>tablename = '<STR_LIT>'<EOL>table = getattr(self._overview_group, tablename)<EOL>if len(table) < pypetconstants.HDF5_MAX_OVERVIEW_TABLE_LENGTH:<EOL><INDENT>self._all_store_param_or_result_table_entry(instance, table,<EOL>flags=flags)<EOL><DEDENT><DEDENT>except pt.NoSuchNodeError:<EOL><INDENT>pass<EOL><DEDENT>except Exception as exc:<EOL><INDENT>self._logger.error('<STR_LIT>'<EOL>'<STR_LIT>' % repr(exc))<EOL><DEDENT><DEDENT>", "docstring": "Adds information to overview tables and meta information to\n        the `instance`s hdf5 `group`.\n\n        :param instance: Instance to store meta info about\n        :param group: HDF5 group of instance\n        :param overwrite: If data should be explicitly overwritten", "id": "f4214:c5:m74"}
{"signature": "def _prm_write_into_other_array(self, key, data, group, fullname,<EOL>flag, **kwargs):", "body": "try:<EOL><INDENT>if flag == HDF5StorageService.CARRAY:<EOL><INDENT>factory = self._hdf5file.create_carray<EOL><DEDENT>elif flag == HDF5StorageService.EARRAY:<EOL><INDENT>factory = self._hdf5file.create_earray<EOL><DEDENT>elif flag == HDF5StorageService.VLARRAY:<EOL><INDENT>factory = self._hdf5file.create_vlarray<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>if key in group:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' in kwargs:<EOL><INDENT>filters = kwargs.pop('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>filters = self._all_get_filters(kwargs)<EOL><DEDENT>try:<EOL><INDENT>other_array = factory(where=group, name=key, obj=data,<EOL>filters=filters, **kwargs)<EOL><DEDENT>except (ValueError, TypeError) as exc:<EOL><INDENT>try:<EOL><INDENT>conv_data = data[:]<EOL>conv_data = np.core.defchararray.encode(conv_data, self.encoding)<EOL>other_array = factory(where=group, name=key,<EOL>obj=conv_data,<EOL>filters=filters, **kwargs)<EOL><DEDENT>except Exception:<EOL><INDENT>raise exc<EOL><DEDENT><DEDENT>if data is not None:<EOL><INDENT>self._all_set_attributes_to_recall_natives(data, other_array,<EOL>HDF5StorageService.DATA_PREFIX)<EOL><DEDENT>setattr(other_array._v_attrs, HDF5StorageService.STORAGE_TYPE, flag)<EOL>self._hdf5file.flush()<EOL><DEDENT>except:<EOL><INDENT>self._logger.error('<STR_LIT>' % (flag, key, fullname))<EOL>raise<EOL><DEDENT>", "docstring": "Stores data as carray, earray or vlarray depending on `flag`.\n\n        :param key:\n\n            Name of data item to store\n\n        :param data:\n\n            Data to store\n\n        :param group:\n\n            Group node where to store data in hdf5 file\n\n        :param fullname:\n\n            Full name of the `data_to_store`s original container, only needed for throwing errors.\n\n        :param recall:\n\n            If container type and data type for perfect recall should be stored\n\n        :param flag:\n\n            How to store:\n                CARRAY, EARRAY, VLARRAY", "id": "f4214:c5:m83"}
{"signature": "def _lnk_delete_link(self, link_name):", "body": "translated_name = '<STR_LIT:/>' + self._trajectory_name + '<STR_LIT:/>' + link_name.replace('<STR_LIT:.>','<STR_LIT:/>')<EOL>link = self._hdf5file.get_node(where=translated_name)<EOL>link._f_remove()<EOL>", "docstring": "Removes a link from disk", "id": "f4214:c5:m85"}
{"signature": "def _ann_store_annotations(self, item_with_annotations, node, overwrite=False):", "body": "<EOL>if overwrite is True or overwrite == '<STR_LIT>':<EOL><INDENT>annotated = self._all_get_from_attrs(node, HDF5StorageService.ANNOTATED)<EOL>if annotated:<EOL><INDENT>current_attrs = node._v_attrs<EOL>for attr_name in current_attrs._v_attrnames:<EOL><INDENT>if attr_name.startswith(HDF5StorageService.ANNOTATION_PREFIX):<EOL><INDENT>delattr(current_attrs, attr_name)<EOL><DEDENT><DEDENT>delattr(current_attrs, HDF5StorageService.ANNOTATED)<EOL>self._hdf5file.flush()<EOL><DEDENT><DEDENT>if not item_with_annotations.v_annotations.f_is_empty():<EOL><INDENT>anno_dict = item_with_annotations.v_annotations._dict<EOL>current_attrs = node._v_attrs<EOL>changed = False<EOL>for field_name in anno_dict:<EOL><INDENT>val = anno_dict[field_name]<EOL>field_name_with_prefix = HDF5StorageService.ANNOTATION_PREFIX + field_name<EOL>if field_name_with_prefix not in current_attrs:<EOL><INDENT>setattr(current_attrs, field_name_with_prefix, val)<EOL>changed = True<EOL><DEDENT><DEDENT>if changed:<EOL><INDENT>setattr(current_attrs, HDF5StorageService.ANNOTATED, True)<EOL>self._hdf5file.flush()<EOL><DEDENT><DEDENT>", "docstring": "Stores annotations into an hdf5 file.", "id": "f4214:c5:m67"}
{"signature": "@staticmethod<EOL><INDENT>def _prm_get_longest_stringsize(string_list):<DEDENT>", "body": "maxlength = <NUM_LIT:1><EOL>for stringar in string_list:<EOL><INDENT>if isinstance(stringar, np.ndarray):<EOL><INDENT>if stringar.ndim > <NUM_LIT:0>:<EOL><INDENT>for string in stringar.ravel():<EOL><INDENT>maxlength = max(len(string), maxlength)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>maxlength = max(len(stringar.tolist()), maxlength)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>maxlength = max(len(stringar), maxlength)<EOL><DEDENT><DEDENT>return int(maxlength * <NUM_LIT>)<EOL>", "docstring": "Returns the longest string size for a string entry across data.", "id": "f4214:c5:m90"}
{"signature": "def _prm_write_pandas_data(self, key, data, group, fullname, flag, **kwargs):", "body": "try:<EOL><INDENT>if '<STR_LIT>' not in kwargs:<EOL><INDENT>filters = self._all_get_filters(kwargs)<EOL>kwargs['<STR_LIT>'] = filters<EOL><DEDENT>if '<STR_LIT>' not in kwargs:<EOL><INDENT>kwargs['<STR_LIT>'] = self.pandas_format<EOL><DEDENT>if '<STR_LIT>' not in kwargs:<EOL><INDENT>kwargs['<STR_LIT>'] = self.encoding<EOL><DEDENT>overwrite = kwargs.pop('<STR_LIT>', False)<EOL>if key in group and not (overwrite or kwargs.get('<STR_LIT>', False)):<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % (key, fullname))<EOL><DEDENT>else:<EOL><INDENT>self._logger.debug('<STR_LIT>' % (key, fullname))<EOL><DEDENT>if data is not None and (kwargs['<STR_LIT>'] == '<STR_LIT:f>' or kwargs['<STR_LIT>'] == '<STR_LIT>'):<EOL><INDENT>kwargs['<STR_LIT>'] = data.shape[<NUM_LIT:0>]<EOL><DEDENT>name = group._v_pathname + '<STR_LIT:/>' + key<EOL>self._hdf5store.put(name, data, **kwargs)<EOL>self._hdf5store.flush()<EOL>self._hdf5file.flush()<EOL>frame_group = group._f_get_child(key)<EOL>setattr(frame_group._v_attrs, HDF5StorageService.STORAGE_TYPE, flag)<EOL>self._hdf5file.flush()<EOL><DEDENT>except:<EOL><INDENT>self._logger.error('<STR_LIT>' % (key, fullname))<EOL>raise<EOL><DEDENT>", "docstring": "Stores a pandas DataFrame into hdf5.\n\n        :param key:\n\n            Name of data item to store\n\n        :param data:\n\n            Pandas Data to Store\n\n        :param group:\n\n            Group node where to store data in hdf5 file\n\n        :param fullname:\n\n            Full name of the `data_to_store`s original container, only needed for throwing errors.\n\n        :param flag:\n\n            If it is a series, frame or panel", "id": "f4214:c5:m82"}
{"signature": "def _trj_merge_trajectories(self, other_trajectory_name, rename_dict, move_nodes=False,<EOL>delete_trajectory=False, other_filename=None):", "body": "if other_filename is None or other_filename == self.filename:<EOL><INDENT>other_filename = self.filename<EOL>other_file = self._hdf5file<EOL>other_is_different = False<EOL><DEDENT>else:<EOL><INDENT>other_file = pt.open_file(filename=other_filename, mode='<STR_LIT>')<EOL>other_is_different = True<EOL><DEDENT>try:<EOL><INDENT>if not '<STR_LIT:/>' + other_trajectory_name in other_file:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>' % (self._trajectory_name,<EOL>other_trajectory_name,<EOL>other_filename))<EOL><DEDENT>for old_name in rename_dict:<EOL><INDENT>new_name = rename_dict[old_name]<EOL>split_name = old_name.split('<STR_LIT:.>')<EOL>old_location = '<STR_LIT:/>' + other_trajectory_name + '<STR_LIT:/>' + '<STR_LIT:/>'.join(split_name)<EOL>split_name = new_name.split('<STR_LIT:.>')<EOL>new_parent_location = '<STR_LIT:/>' + self._trajectory_name + '<STR_LIT:/>' + '<STR_LIT:/>'.join(split_name[:-<NUM_LIT:1>])<EOL>new_short_name = split_name[-<NUM_LIT:1>]<EOL>old_node = other_file.get_node(old_location)<EOL>if move_nodes:<EOL><INDENT>self._hdf5file.move_node( where=old_node, newparent=new_parent_location,<EOL>newname=new_short_name, createparents=True)<EOL><DEDENT>else:<EOL><INDENT>if other_is_different:<EOL><INDENT>new_parent_dot_location = '<STR_LIT:.>'.join(split_name[:-<NUM_LIT:1>])<EOL>new_parent_or_loc, _ = self._all_create_or_get_groups(<EOL>new_parent_dot_location)<EOL>create_parents = False<EOL><DEDENT>else:<EOL><INDENT>new_parent_or_loc = new_parent_location<EOL>create_parents = True<EOL><DEDENT>self._hdf5file.copy_node(where=old_node, newparent=new_parent_or_loc,<EOL>newname=new_short_name, createparents=create_parents,<EOL>recursive=True)<EOL><DEDENT><DEDENT>if delete_trajectory:<EOL><INDENT>other_file.remove_node(where='<STR_LIT:/>', name=other_trajectory_name, recursive=True)<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>if other_is_different:<EOL><INDENT>other_file.flush()<EOL>other_file.close()<EOL><DEDENT><DEDENT>", "docstring": "Merges another trajectory into the current trajectory (as in self._trajectory_name).\n\n        :param other_trajectory_name: Name of other trajectory\n        :param rename_dict: Dictionary with old names (keys) and new names (values).\n        :param move_nodes: Whether to move hdf5 nodes or copy them\n        :param delete_trajectory: Whether to delete the other trajectory", "id": "f4214:c5:m32"}
{"signature": "def _all_add_or_modify_row(self, item_name, insert_dict, table, index=None, condition=None,<EOL>condvars=None,<EOL>flags=(ADD_ROW, MODIFY_ROW,)):", "body": "if len(flags) == <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>if index is not None and condition is not None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>elif condition is not None:<EOL><INDENT>row_iterator = table.where(condition, condvars=condvars)<EOL><DEDENT>elif index is not None:<EOL><INDENT>row_iterator = table.iterrows(index, index + <NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>row_iterator = None<EOL><DEDENT>try:<EOL><INDENT>row = next(row_iterator)<EOL><DEDENT>except TypeError:<EOL><INDENT>row = None<EOL><DEDENT>except StopIteration:<EOL><INDENT>row = None<EOL><DEDENT>if ((HDF5StorageService.MODIFY_ROW in flags or HDF5StorageService.ADD_ROW in flags) and<EOL>HDF5StorageService.REMOVE_ROW in flags):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if row is None and HDF5StorageService.ADD_ROW in flags:<EOL><INDENT>row = table.row<EOL>self._all_insert_into_row(row, insert_dict)<EOL>row.append()<EOL><DEDENT>elif row is not None and HDF5StorageService.MODIFY_ROW in flags:<EOL><INDENT>self._all_insert_into_row(row, insert_dict)<EOL>row.update()<EOL><DEDENT>elif HDF5StorageService.REMOVE_ROW in flags:<EOL><INDENT>if row is not None:<EOL><INDENT>row_number = row.nrow<EOL>try:<EOL><INDENT>table.remove_rows(start=row_number, stop=row_number+<NUM_LIT:1>)<EOL><DEDENT>except NotImplementedError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>self._all_kill_iterator(row_iterator)<EOL>table.flush()<EOL>if HDF5StorageService.REMOVE_ROW not in flags and row is None:<EOL><INDENT>raise RuntimeError('<STR_LIT>'<EOL>'<STR_LIT>' % (item_name, table._v_name))<EOL><DEDENT>", "docstring": "Adds or changes a row in a pytable.\n\n        :param item_name: Name of item, the row is about, only important for throwing errors.\n\n        :param insert_dict:\n\n            Dictionary of data that is about to be inserted into the pytables row.\n\n        :param table:\n\n            The table to insert or modify a row in\n\n        :param index:\n\n            Index of row to be modified. Instead of an index a search condition can be\n            used as well, see below.\n\n        :param condition:\n\n            Condition to search for in the table\n\n        :param condvars:\n\n            Variables for the search condition\n\n        :param flags:\n\n            Flags whether to add, modify, or remove a row in the table", "id": "f4214:c5:m61"}
{"signature": "def _prm_load_parameter_or_result(self, instance,<EOL>load_data=pypetconstants.LOAD_DATA,<EOL>load_only=None,<EOL>load_except=None,<EOL>load_flags=None,<EOL>with_links=False,<EOL>recursive=False,<EOL>max_depth=None,<EOL>_hdf5_group=None,):", "body": "if load_data == pypetconstants.LOAD_NOTHING:<EOL><INDENT>return<EOL><DEDENT>if _hdf5_group is None:<EOL><INDENT>_hdf5_group = self._all_get_node_by_name(instance.v_full_name)<EOL><DEDENT>if load_data == pypetconstants.OVERWRITE_DATA:<EOL><INDENT>if instance.v_is_parameter and instance.v_locked:<EOL><INDENT>self._logger.debug('<STR_LIT>' %<EOL>instance.v_full_name)<EOL>return<EOL><DEDENT>instance.f_empty()<EOL>instance.v_annotations.f_empty()<EOL>instance.v_comment = '<STR_LIT>'<EOL><DEDENT>self._all_load_skeleton(instance, _hdf5_group)<EOL>instance._stored = True<EOL>if isinstance(load_only, str):<EOL><INDENT>load_only = [load_only]<EOL><DEDENT>if isinstance(load_except, str):<EOL><INDENT>load_except = [load_except]<EOL><DEDENT>if load_data == pypetconstants.LOAD_SKELETON:<EOL><INDENT>self._node_processing_timer.signal_update()<EOL>return<EOL><DEDENT>elif load_only is not None:<EOL><INDENT>if load_except is not None:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>elif instance.v_is_parameter and instance.v_locked:<EOL><INDENT>raise pex.ParameterLockedException('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>instance.v_full_name)<EOL><DEDENT>self._logger.debug('<STR_LIT>' %<EOL>str(load_only))<EOL>load_only = set(load_only)<EOL><DEDENT>elif load_except is not None:<EOL><INDENT>if instance.v_is_parameter and instance.v_locked:<EOL><INDENT>raise pex.ParameterLockedException('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>instance.v_full_name)<EOL><DEDENT>self._logger.debug('<STR_LIT>' %<EOL>str(load_except))<EOL>load_except = set(load_except)<EOL><DEDENT>elif not instance.f_is_empty():<EOL><INDENT>self._node_processing_timer.signal_update()<EOL>return<EOL><DEDENT>full_name = instance.v_full_name<EOL>self._logger.debug('<STR_LIT>' % full_name)<EOL>load_dict = {}  <EOL>if load_flags is None:<EOL><INDENT>load_flags = {}<EOL><DEDENT>try:<EOL><INDENT>instance_flags = instance._load_flags().copy() <EOL><DEDENT>except AttributeError:<EOL><INDENT>instance_flags = {}<EOL><DEDENT>instance_flags.update(load_flags)<EOL>load_flags = instance_flags<EOL>self._prm_load_into_dict(full_name=full_name,<EOL>load_dict=load_dict,<EOL>hdf5_group=_hdf5_group,<EOL>instance=instance,<EOL>load_only=load_only,<EOL>load_except=load_except,<EOL>load_flags=load_flags)<EOL>if load_only is not None:<EOL><INDENT>if len(load_only) > <NUM_LIT:0>:<EOL><INDENT>self._logger.warning('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(str(load_only), full_name))<EOL><DEDENT><DEDENT>elif load_except is not None:<EOL><INDENT>if len(load_except) > <NUM_LIT:0>:<EOL><INDENT>self._logger.warning(('<STR_LIT>'<EOL>'<STR_LIT>' % (str(load_except), full_name)))<EOL><DEDENT><DEDENT>if load_dict:<EOL><INDENT>try:<EOL><INDENT>instance._load(load_dict)<EOL>if instance.v_is_parameter:<EOL><INDENT>instance.f_lock()<EOL><DEDENT><DEDENT>except:<EOL><INDENT>self._logger.error(<EOL>'<STR_LIT>' % full_name)<EOL>raise<EOL><DEDENT><DEDENT>self._node_processing_timer.signal_update()<EOL>", "docstring": "Loads a parameter or result from disk.\n\n        :param instance:\n\n            Empty parameter or result instance\n\n        :param load_data:\n\n            How to load stuff\n\n        :param load_only:\n\n            List of data keys if only parts of a result should be loaded\n\n        :param load_except:\n\n            List of data key that should NOT be loaded.\n\n        :param load_flags:\n\n            Dictionary to determine how something is loaded\n\n        :param with_links:\n\n            Placeholder, because leaves have no links\n\n        :param recursive:\n\n            Dummy variable, no-op because leaves have no children\n\n        :param max_depth:\n\n            Dummy variable, no-op because leaves have no children\n\n        :param _hdf5_group:\n\n            The corresponding hdf5 group of the instance", "id": "f4214:c5:m92"}
{"signature": "def _all_get_or_create_table(self, where, tablename, description, expectedrows=None):", "body": "where_node = self._hdf5file.get_node(where)<EOL>if not tablename in where_node:<EOL><INDENT>if not expectedrows is None:<EOL><INDENT>table = self._hdf5file.create_table(where=where_node, name=tablename,<EOL>description=description, title=tablename,<EOL>expectedrows=expectedrows,<EOL>filters=self._all_get_filters())<EOL><DEDENT>else:<EOL><INDENT>table = self._hdf5file.create_table(where=where_node, name=tablename,<EOL>description=description, title=tablename,<EOL>filters=self._all_get_filters())<EOL><DEDENT><DEDENT>else:<EOL><INDENT>table = where_node._f_get_child(tablename)<EOL><DEDENT>return table<EOL>", "docstring": "Creates a new table, or if the table already exists, returns it.", "id": "f4214:c5:m54"}
{"signature": "@property<EOL><INDENT>def fletcher32(self):<DEDENT>", "body": "return self._fletcher32<EOL>", "docstring": "Whether fletcher 32 should be used", "id": "f4214:c5:m11"}
{"signature": "def _srvc_load_several_items(self, iterable, *args, **kwargs):", "body": "for input_tuple in iterable:<EOL><INDENT>msg = input_tuple[<NUM_LIT:0>]<EOL>item = input_tuple[<NUM_LIT:1>]<EOL>if len(input_tuple) > <NUM_LIT:2>:<EOL><INDENT>args = input_tuple[<NUM_LIT:2>]<EOL><DEDENT>if len(input_tuple) > <NUM_LIT:3>:<EOL><INDENT>kwargs = input_tuple[<NUM_LIT:3>]<EOL><DEDENT>if len(input_tuple) > <NUM_LIT:4>:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>self.load(msg, item, *args, **kwargs)<EOL><DEDENT>", "docstring": "Loads several items from an iterable\n\n        Iterables are supposed to be of a format like `[(msg, item, args, kwarg),...]`\n        If `args` and `kwargs` are not part of a tuple, they are taken from the\n        current `args` and `kwargs` provided to this function.", "id": "f4214:c5:m24"}
{"signature": "def _all_load_skeleton(self, traj_node, hdf5_group):", "body": "if traj_node.v_annotations.f_is_empty():<EOL><INDENT>self._ann_load_annotations(traj_node, hdf5_group)<EOL><DEDENT>if traj_node.v_comment == '<STR_LIT>':<EOL><INDENT>comment = self._all_get_from_attrs(hdf5_group, HDF5StorageService.COMMENT)<EOL>if comment is None:<EOL><INDENT>comment = '<STR_LIT>'<EOL><DEDENT>traj_node.v_comment = comment<EOL><DEDENT>", "docstring": "Reloads skeleton data of a tree node", "id": "f4214:c5:m71"}
{"signature": "def _tree_create_leaf(self, name, trajectory, hdf5_group):", "body": "class_name = self._all_get_from_attrs(hdf5_group, HDF5StorageService.CLASS_NAME)<EOL>class_constructor = trajectory._create_class(class_name)<EOL>instance = trajectory._construct_instance(class_constructor, name)<EOL>return instance<EOL>", "docstring": "Creates a new pypet leaf instance.\n\n        Returns the leaf and if it is an explored parameter the length of the range.", "id": "f4214:c5:m46"}
{"signature": "@property<EOL><INDENT>def complib(self):<DEDENT>", "body": "return self._complib<EOL>", "docstring": "Compression library used", "id": "f4214:c5:m7"}
{"signature": "def _all_get_node_by_name(self, name):", "body": "path_name = name.replace('<STR_LIT:.>', '<STR_LIT:/>')<EOL>where = '<STR_LIT>' % (self._trajectory_name, path_name)<EOL>return self._hdf5file.get_node(where=where)<EOL>", "docstring": "Returns an HDF5 node by the path specified in `name`", "id": "f4214:c5:m55"}
{"signature": "def _all_get_filters(self, kwargs=None):", "body": "if kwargs is None:<EOL><INDENT>kwargs = {}<EOL><DEDENT>complib = kwargs.pop('<STR_LIT>', None)<EOL>complevel = kwargs.pop('<STR_LIT>', None)<EOL>shuffle = kwargs.pop('<STR_LIT>', None)<EOL>fletcher32 = kwargs.pop('<STR_LIT>', None)<EOL>if complib is not None:<EOL><INDENT>self._filters = None<EOL><DEDENT>else:<EOL><INDENT>complib = self._complib<EOL><DEDENT>if complevel is not None:<EOL><INDENT>self._filters = None<EOL><DEDENT>else:<EOL><INDENT>complevel = self._complevel<EOL><DEDENT>if shuffle is not None:<EOL><INDENT>self._filters = None<EOL><DEDENT>else:<EOL><INDENT>shuffle = self._shuffle<EOL><DEDENT>if fletcher32 is not None:<EOL><INDENT>self._filters = None<EOL><DEDENT>else:<EOL><INDENT>fletcher32 = self._fletcher32<EOL><DEDENT>if self._filters is None:<EOL><INDENT>self._filters = pt.Filters(complib=complib, complevel=complevel,<EOL>shuffle=shuffle, fletcher32=fletcher32)<EOL>self._hdf5file.filters = self._filters<EOL>self._hdf5store._filters = self._filters<EOL>self._hdf5store._complevel = complevel<EOL>self._hdf5store._complib = complib<EOL>self._hdf5store._fletcher32 = fletcher32<EOL><DEDENT>return self._filters<EOL>", "docstring": "Makes filters\n\n        Pops filter arguments from `kwargs` such that they are not passed\n        on to other functions also using kwargs.", "id": "f4214:c5:m20"}
{"signature": "def _tree_load_link(self, new_traj_node, load_data, traj, as_new, hdf5_soft_link):", "body": "try:<EOL><INDENT>linked_group = hdf5_soft_link()<EOL>link_name = hdf5_soft_link._v_name<EOL>if (not link_name in new_traj_node._links or<EOL>load_data==pypetconstants.OVERWRITE_DATA):<EOL><INDENT>link_location = linked_group._v_pathname<EOL>full_name = '<STR_LIT:.>'.join(link_location.split('<STR_LIT:/>')[<NUM_LIT:2>:])<EOL>if not full_name in traj:<EOL><INDENT>self._tree_load_sub_branch(traj, full_name,<EOL>load_data=pypetconstants.LOAD_SKELETON,<EOL>with_links=False, recursive=False, _trajectory=traj,<EOL>_as_new=as_new, _hdf5_group=self._trajectory_group)<EOL><DEDENT>if (load_data == pypetconstants.OVERWRITE_DATA and<EOL>link_name in new_traj_node._links):<EOL><INDENT>new_traj_node.f_remove_link(link_name)<EOL><DEDENT>if not link_name in new_traj_node._links:<EOL><INDENT>new_traj_node._nn_interface._add_generic(new_traj_node,<EOL>type_name=nn.LINK,<EOL>group_type_name=nn.GROUP,<EOL>args=(link_name,<EOL>traj.f_get(full_name)),<EOL>kwargs={},<EOL>add_prefix=False,<EOL>check_naming=False)<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>except pt.NoSuchNodeError:<EOL><INDENT>self._logger.error('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(hdf5_soft_link._v_name, new_traj_node.v_full_name))<EOL><DEDENT>", "docstring": "Loads a link\n\n        :param new_traj_node: Node in traj containing link \n        :param load_data: How to load data in the linked node\n        :param traj: The trajectory\n        :param as_new: If data in linked node should be loaded as new\n        :param hdf5_soft_link: The hdf5 soft link", "id": "f4214:c5:m48"}
{"signature": "def _trj_load_trajectory(self, traj, as_new, load_parameters, load_derived_parameters,<EOL>load_results, load_other_data, recursive, max_depth,<EOL>with_run_information, with_meta_data, force):", "body": "<EOL>if (as_new and (load_derived_parameters != pypetconstants.LOAD_NOTHING or<EOL>load_results != pypetconstants.LOAD_NOTHING or<EOL>load_other_data != pypetconstants.LOAD_NOTHING)):<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>if as_new and load_parameters != pypetconstants.LOAD_DATA:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>loadconstants = (pypetconstants.LOAD_NOTHING, pypetconstants.LOAD_SKELETON,<EOL>pypetconstants.LOAD_DATA, pypetconstants.OVERWRITE_DATA)<EOL>if not (load_parameters in loadconstants and load_derived_parameters in loadconstants and<EOL>load_results in loadconstants and load_other_data in loadconstants):<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % str(loadconstants))<EOL><DEDENT>traj._stored = not as_new<EOL>load_data = max(load_parameters, load_derived_parameters, load_results, load_other_data)<EOL>if with_meta_data:<EOL><INDENT>self._trj_load_meta_data(traj, load_data, as_new, with_run_information, force)<EOL><DEDENT>if (load_parameters != pypetconstants.LOAD_NOTHING or<EOL>load_derived_parameters != pypetconstants.LOAD_NOTHING or<EOL>load_results != pypetconstants.LOAD_NOTHING or<EOL>load_other_data != pypetconstants.LOAD_NOTHING):<EOL><INDENT>self._logger.info('<STR_LIT>' % traj.v_name)<EOL><DEDENT>else:<EOL><INDENT>self._logger.info('<STR_LIT>' % traj.v_name)<EOL>return<EOL><DEDENT>maximum_display_other = <NUM_LIT:10><EOL>counter = <NUM_LIT:0><EOL>for children in [self._trajectory_group._v_groups, self._trajectory_group._v_links]:<EOL><INDENT>for hdf5_group_name in children:<EOL><INDENT>hdf5_group = children[hdf5_group_name]<EOL>child_name = hdf5_group._v_name<EOL>load_subbranch = True<EOL>if child_name == '<STR_LIT>':<EOL><INDENT>if as_new:<EOL><INDENT>loading = pypetconstants.LOAD_NOTHING<EOL><DEDENT>else:<EOL><INDENT>loading = load_parameters<EOL><DEDENT><DEDENT>elif child_name == '<STR_LIT>':<EOL><INDENT>loading = load_parameters<EOL><DEDENT>elif child_name == '<STR_LIT>':<EOL><INDENT>loading = load_results<EOL><DEDENT>elif child_name == '<STR_LIT>':<EOL><INDENT>loading = load_derived_parameters<EOL><DEDENT>elif child_name == '<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>else:<EOL><INDENT>loading = load_other_data<EOL>load_subbranch = False<EOL><DEDENT>if loading == pypetconstants.LOAD_NOTHING:<EOL><INDENT>continue<EOL><DEDENT>if load_subbranch:<EOL><INDENT>self._logger.info('<STR_LIT>' %<EOL>(child_name, str(loading)))<EOL><DEDENT>else:<EOL><INDENT>if counter < maximum_display_other:<EOL><INDENT>self._logger.info(<EOL>'<STR_LIT>' % (child_name, str(loading)))<EOL><DEDENT>elif counter == maximum_display_other:<EOL><INDENT>self._logger.info('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>counter += <NUM_LIT:1><EOL><DEDENT>self._tree_load_sub_branch(traj, child_name, load_data=loading, with_links=True,<EOL>recursive=recursive,<EOL>max_depth=max_depth,<EOL>_trajectory=traj, _as_new=as_new,<EOL>_hdf5_group=self._trajectory_group)<EOL><DEDENT><DEDENT>", "docstring": "Loads a single trajectory from a given file.\n\n\n        :param traj: The trajectory\n\n        :param as_new: Whether to load trajectory as new\n\n        :param load_parameters: How to load parameters and config\n\n        :param load_derived_parameters: How to load derived parameters\n\n        :param load_results: How to load results\n\n        :param load_other_data: How to load anything not within the four subbranches\n\n        :param recursive: If data should be loaded recursively\n\n        :param max_depth: Maximum depth of loading\n\n        :param with_run_information:\n\n            If run information should be loaded\n\n        :param with_meta_data:\n\n            If meta data infor should be loaded\n\n        :param force: Force load in case there is a pypet version mismatch\n\n        You can specify how to load the parameters, derived parameters and results\n        as follows:\n\n        :const:`pypet.pypetconstants.LOAD_NOTHING`: (0)\n\n            Nothing is loaded\n\n        :const:`pypet.pypetconstants.LOAD_SKELETON`: (1)\n\n            The skeleton including annotations are loaded, i.e. the items are empty.\n            Non-empty items in RAM are left untouched.\n\n        :const:`pypet.pypetconstants.LOAD_DATA`: (2)\n\n            The whole data is loaded.\n            Only empty or in RAM non-existing instance are filled with the\n            data found on disk.\n\n        :const:`pypet.pypetconstants.OVERWRITE_DATA`: (3)\n\n            The whole data is loaded.\n            If items that are to be loaded are already in RAM and not empty,\n            they are emptied and new data is loaded from disk.\n\n\n        If `as_new=True` the old trajectory is loaded into the new one, only parameters can be\n        loaded. If `as_new=False` the current trajectory is completely replaced by the one\n        on disk, i.e. the name from disk, the timestamp, etc. are assigned to `traj`.", "id": "f4214:c5:m34"}
{"signature": "def _srvc_make_overview_tables(self, tables_to_make, traj=None):", "body": "for table_name in tables_to_make:<EOL><INDENT>paramdescriptiondict = {}<EOL>expectedrows = <NUM_LIT:0><EOL>paramdescriptiondict['<STR_LIT:location>'] = pt.StringCol(<EOL>pypetconstants.HDF5_STRCOL_MAX_LOCATION_LENGTH,<EOL>pos=<NUM_LIT:0>)<EOL>paramdescriptiondict['<STR_LIT:name>'] = pt.StringCol(pypetconstants.HDF5_STRCOL_MAX_NAME_LENGTH,<EOL>pos=<NUM_LIT:1>)<EOL>paramdescriptiondict['<STR_LIT>'] = pt.StringCol(<EOL>pypetconstants.HDF5_STRCOL_MAX_COMMENT_LENGTH)<EOL>paramdescriptiondict['<STR_LIT:value>'] = pt.StringCol(<EOL>pypetconstants.HDF5_STRCOL_MAX_VALUE_LENGTH, pos=<NUM_LIT:2>)<EOL>if table_name == '<STR_LIT>':<EOL><INDENT>if traj is not None:<EOL><INDENT>expectedrows = len(traj._config)<EOL><DEDENT><DEDENT>if table_name == '<STR_LIT>':<EOL><INDENT>if traj is not None:<EOL><INDENT>expectedrows = len(traj._parameters)<EOL><DEDENT><DEDENT>if table_name == '<STR_LIT>':<EOL><INDENT>paramdescriptiondict['<STR_LIT>'] = pt.StringCol(<EOL>pypetconstants.HDF5_STRCOL_MAX_RANGE_LENGTH)<EOL>paramdescriptiondict['<STR_LIT>'] = pt.IntCol()<EOL>if traj is not None:<EOL><INDENT>expectedrows = len(traj._explored_parameters)<EOL><DEDENT><DEDENT>if table_name.endswith('<STR_LIT>'):<EOL><INDENT>paramdescriptiondict['<STR_LIT>'] = pt.StringCol(<NUM_LIT:64>, pos=<NUM_LIT:10>)<EOL><DEDENT>if table_name == '<STR_LIT>':<EOL><INDENT>expectedrows = self._derived_parameters_per_run<EOL>if traj is not None:<EOL><INDENT>expectedrows *= len(traj)<EOL>expectedrows += len(traj._derived_parameters)<EOL><DEDENT><DEDENT>if table_name == '<STR_LIT>':<EOL><INDENT>expectedrows = self._results_per_run<EOL>if traj is not None:<EOL><INDENT>expectedrows *= len(traj)<EOL>expectedrows += len(traj._results)<EOL><DEDENT><DEDENT>if expectedrows > <NUM_LIT:0>:<EOL><INDENT>paramtable = self._all_get_or_create_table(where=self._overview_group,<EOL>tablename=table_name,<EOL>description=paramdescriptiondict,<EOL>expectedrows=expectedrows)<EOL><DEDENT>else:<EOL><INDENT>paramtable = self._all_get_or_create_table(where=self._overview_group,<EOL>tablename=table_name,<EOL>description=paramdescriptiondict)<EOL><DEDENT>paramtable.flush()<EOL><DEDENT>", "docstring": "Creates the overview tables in overview group", "id": "f4214:c5:m43"}
{"signature": "def _grp_store_group(self, traj_group, store_data=pypetconstants.STORE_DATA,<EOL>with_links=True, recursive=False, max_depth=None,<EOL>_hdf5_group=None, _newly_created=False):", "body": "if store_data == pypetconstants.STORE_NOTHING:<EOL><INDENT>return<EOL><DEDENT>elif store_data == pypetconstants.STORE_DATA_SKIPPING and traj_group._stored:<EOL><INDENT>self._logger.debug('<STR_LIT>' %<EOL>traj_group.v_full_name)<EOL><DEDENT>elif not recursive:<EOL><INDENT>if _hdf5_group is None:<EOL><INDENT>_hdf5_group, _newly_created = self._all_create_or_get_groups(traj_group.v_full_name)<EOL><DEDENT>overwrite = store_data == pypetconstants.OVERWRITE_DATA<EOL>if (traj_group.v_comment != '<STR_LIT>' and<EOL>(HDF5StorageService.COMMENT not in _hdf5_group._v_attrs or overwrite)):<EOL><INDENT>setattr(_hdf5_group._v_attrs, HDF5StorageService.COMMENT, traj_group.v_comment)<EOL><DEDENT>if ((_newly_created or overwrite) and<EOL>type(traj_group) not in (nn.NNGroupNode, nn.ConfigGroup, nn.ParameterGroup,<EOL>nn.DerivedParameterGroup, nn.ResultGroup)):<EOL><INDENT>setattr(_hdf5_group._v_attrs, HDF5StorageService.CLASS_NAME,<EOL>traj_group.f_get_class_name())<EOL><DEDENT>self._ann_store_annotations(traj_group, _hdf5_group, overwrite=overwrite)<EOL>self._hdf5file.flush()<EOL>traj_group._stored = True<EOL>self._node_processing_timer.signal_update()<EOL><DEDENT>if recursive:<EOL><INDENT>parent_traj_group = traj_group.f_get_parent()<EOL>parent_hdf5_group = self._all_create_or_get_groups(parent_traj_group.v_full_name)[<NUM_LIT:0>]<EOL>self._tree_store_nodes_dfs(parent_traj_group, traj_group.v_name, store_data=store_data,<EOL>with_links=with_links, recursive=recursive,<EOL>max_depth=max_depth, current_depth=<NUM_LIT:0>,<EOL>parent_hdf5_group=parent_hdf5_group)<EOL><DEDENT>", "docstring": "Stores a group node.\n\n        For group nodes only annotations and comments need to be stored.", "id": "f4214:c5:m69"}
{"signature": "def _trj_check_version(self, version, python, force):", "body": "curr_python = pypetconstants.python_version_string<EOL>if (version != VERSION or curr_python != python) and not force:<EOL><INDENT>raise pex.VersionMismatchError('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(VERSION, curr_python, version, python))<EOL><DEDENT>elif version != VERSION or curr_python != python:<EOL><INDENT>self._logger.warning('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(VERSION, curr_python, version, python))<EOL><DEDENT>", "docstring": "Checks for version mismatch\n\n        Raises a VersionMismatchError if version of loaded trajectory and current pypet version\n        do not match. In case of `force=True` error is not raised only a warning is emitted.", "id": "f4214:c5:m38"}
{"signature": "def _srvc_check_hdf_properties(self, traj):", "body": "for attr_name in HDF5StorageService.ATTR_LIST:<EOL><INDENT>try:<EOL><INDENT>config = traj.f_get('<STR_LIT>' + attr_name).f_get()<EOL>setattr(self, attr_name, config)<EOL><DEDENT>except AttributeError:<EOL><INDENT>self._logger.debug('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(attr_name, str(getattr(self, attr_name))))<EOL><DEDENT><DEDENT>for attr_name, table_name in HDF5StorageService.NAME_TABLE_MAPPING.items():<EOL><INDENT>try:<EOL><INDENT>if table_name in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>table_name += '<STR_LIT>'<EOL><DEDENT>config = traj.f_get('<STR_LIT>' + table_name).f_get()<EOL>setattr(self, attr_name, config)<EOL><DEDENT>except AttributeError:<EOL><INDENT>self._logger.debug('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(table_name, str(getattr(self, attr_name))))<EOL><DEDENT><DEDENT>for attr_name, name in HDF5StorageService.PR_ATTR_NAME_MAPPING.items():<EOL><INDENT>try:<EOL><INDENT>config = traj.f_get('<STR_LIT>' + name).f_get()<EOL>setattr(self, attr_name, config)<EOL><DEDENT>except AttributeError:<EOL><INDENT>self._logger.debug('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(name, str(getattr(self, attr_name))))<EOL><DEDENT><DEDENT>if ((not self._overview_results_summary or<EOL>not self._overview_derived_parameters_summary) and<EOL>self._purge_duplicate_comments):<EOL><INDENT>raise RuntimeError('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>self._filters = None<EOL>", "docstring": "Reads out the properties for storing new data into the hdf5file\n\n        :param traj:\n\n            The trajectory", "id": "f4214:c5:m25"}
{"signature": "def _prm_read_array(self, array, full_name):", "body": "try:<EOL><INDENT>result = self._svrc_read_array(array)<EOL>result, dummy = self._all_recall_native_type(result, array,<EOL>HDF5StorageService.DATA_PREFIX)<EOL>return result<EOL><DEDENT>except:<EOL><INDENT>self._logger.error('<STR_LIT>' % (array._v_name, full_name))<EOL>raise<EOL><DEDENT>", "docstring": "Reads data from an array or carray\n\n        :param array:\n\n            PyTables array or carray to read from\n\n        :param full_name:\n\n            Full name of the parameter or result whose data is to be loaded\n\n        :return:\n\n            Data to load", "id": "f4214:c5:m98"}
{"signature": "def get_data_node(self):", "body": "if not self._storage_service.is_open:<EOL><INDENT>warnings.warn('<STR_LIT>'<EOL>'<STR_LIT>',<EOL>category=RuntimeWarning)<EOL><DEDENT>return self._request_data('<STR_LIT>')<EOL>", "docstring": "Returns the actula node of the underlying data.\n\n        In case one uses HDF5 this will be the HDF5 leaf node.", "id": "f4215:c1:m5"}
{"signature": "def open_store(self):", "body": "service = self._traj.v_storage_service<EOL>if service.is_open:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>service.store(pypetconstants.OPEN_FILE, None,<EOL>trajectory_name=self._traj.v_name)<EOL>", "docstring": "Opens store manually not needed if used with `with`", "id": "f4215:c0:m4"}
{"signature": "def create_shared_data(self, **kwargs):", "body": "if '<STR_LIT>' not in kwargs:<EOL><INDENT>kwargs['<STR_LIT>'] = self.FLAG<EOL><DEDENT>if '<STR_LIT:data>' in kwargs:<EOL><INDENT>kwargs['<STR_LIT>'] = kwargs.pop('<STR_LIT:data>')<EOL><DEDENT>if '<STR_LIT>' in kwargs:<EOL><INDENT>self.traj = kwargs.pop('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' in kwargs:<EOL><INDENT>self.traj = kwargs.pop('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT:name>' in kwargs:<EOL><INDENT>self.name = kwargs.pop['<STR_LIT:name>']<EOL><DEDENT>if '<STR_LIT>' in kwargs:<EOL><INDENT>self.parent = kwargs.pop('<STR_LIT>')<EOL>if self.name is not None:<EOL><INDENT>self.parent[self.name] = self<EOL><DEDENT><DEDENT>return self._request_data('<STR_LIT>', kwargs=kwargs)<EOL>", "docstring": "Creates shared data on disk with a StorageService on disk.\n\n        Needs to be called before shared data can be used later on.\n\n        Actual arguments of ``kwargs`` depend on the type of data to be\n        created. For instance, creating an array one can use the keyword\n        ``obj`` to pass a numpy array (``obj=np.zeros((10,20,30))``).\n        Whereas for a PyTables table may need a description dictionary\n        (``description={'column_1': pt.StringCol(2, pos=0),'column_2': pt.FloatCol( pos=1)}``)\n        Refer to the PyTables documentation on how to create tables.", "id": "f4215:c1:m3"}
{"signature": "def close_store(self):", "body": "service = self._traj.v_storage_service<EOL>if not service.is_open:<EOL><INDENT>raise RuntimeError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>service.store(pypetconstants.CLOSE_FILE, None)<EOL>", "docstring": "Closes store manually not needed if used with `with`", "id": "f4215:c0:m3"}
{"signature": "def create_shared_data(self, name=None, **kwargs):", "body": "if name is None:<EOL><INDENT>item = self.f_get()<EOL><DEDENT>else:<EOL><INDENT>item = self.f_get(name)<EOL><DEDENT>return item.create_shared_data(**kwargs)<EOL>", "docstring": "Calls the corresponding function of the shared data item", "id": "f4215:c8:m6"}
{"signature": "@property<EOL><INDENT>def is_open(self):<DEDENT>", "body": "return self._storage_service.is_open<EOL>", "docstring": "Normally the file is opened and closed after each insertion.\n\n        However, the storage service may provide the option to keep the store open and signals\n        this via this property.", "id": "f4217:c18:m3"}
{"signature": "def load(self, *args, **kwargs):", "body": "raise NotImplementedError('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>", "docstring": "Not implemented", "id": "f4217:c19:m2"}
{"signature": "def finalize(self):", "body": "if self._context is not None:<EOL><INDENT>if self._socket is not None:<EOL><INDENT>self._close_socket(confused=False)<EOL><DEDENT>self._context.term()<EOL>self._context = None<EOL>self._poll = None<EOL><DEDENT>", "docstring": "Closes socket and terminates context\n\n        NO-OP if already closed.", "id": "f4217:c4:m4"}
{"signature": "def store(self, msg, stuff_to_store, *args, **kwargs):", "body": "trajectory_name = kwargs['<STR_LIT>']<EOL>if trajectory_name not in self.references:<EOL><INDENT>self.references[trajectory_name] = []<EOL><DEDENT>self.references[trajectory_name].append((msg, cp.copy(stuff_to_store), args, kwargs))<EOL>", "docstring": "Simply keeps a reference to the stored data", "id": "f4217:c19:m1"}
{"signature": "def load(self, *args, **kwargs):", "body": "try:<EOL><INDENT>self.acquire_lock()<EOL>return self._storage_service.load(*args, **kwargs)<EOL><DEDENT>finally:<EOL><INDENT>if self.lock is not None:<EOL><INDENT>try:<EOL><INDENT>self.release_lock()<EOL><DEDENT>except RuntimeError:<EOL><INDENT>self._logger.error('<STR_LIT>' % str(self.lock))<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Acquires a lock before loading and releases it afterwards.", "id": "f4217:c18:m7"}
{"signature": "@retry(<NUM_LIT:9>, Exception, <NUM_LIT>, '<STR_LIT>')<EOL><INDENT>def _put_on_pipe(self, to_put):<DEDENT>", "body": "self.acquire_lock()<EOL>self._send_chunks(to_put)<EOL>self.release_lock()<EOL>", "docstring": "Puts data on queue", "id": "f4217:c14:m3"}
{"signature": "@property<EOL><INDENT>def multiproc_safe(self):<DEDENT>", "body": "return True<EOL>", "docstring": "This wrapper guarantees multiprocessing safety", "id": "f4217:c0:m1"}
{"signature": "@property<EOL><INDENT>def multiproc_safe(self):<DEDENT>", "body": "return True<EOL>", "docstring": "Usually storage services are not supposed to be multiprocessing safe", "id": "f4217:c18:m4"}
{"signature": "def _unlock(self, name, client_id, request_id):", "body": "if name in self._locks:<EOL><INDENT>other_client_id, other_request_id, lock_time = self._locks[name]<EOL>if other_client_id != client_id:<EOL><INDENT>response = (self.RELEASE_ERROR + self.DELIMITER +<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % (name,<EOL>other_client_id,<EOL>other_request_id,<EOL>client_id,<EOL>request_id))<EOL>self._logger.error(response)<EOL>return response<EOL><DEDENT>else:<EOL><INDENT>del self._locks[name]<EOL>return self.RELEASED<EOL><DEDENT><DEDENT>elif (name, client_id) in self._timeout_locks:<EOL><INDENT>other_request_id, lock_time = self._timeout_locks[(name, client_id)]<EOL>timeout = time.time() - lock_time - self._timeout<EOL>response = (self.RELEASE_ERROR + self.DELIMITER +<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % (name, timeout, client_id, other_request_id))<EOL>return response<EOL><DEDENT>else:<EOL><INDENT>response = (self.RELEASE_ERROR + self.DELIMITER +<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % (name, client_id, request_id))<EOL>self._logger.warning(response)<EOL>return response<EOL><DEDENT>", "docstring": "Handles unlocking", "id": "f4217:c3:m2"}
{"signature": "def __call__(self, index, total, percentage_step=<NUM_LIT:5>, logger='<STR_LIT>', log_level=logging.INFO,<EOL>reprint=False, time=True, length=<NUM_LIT:20>, fmt_string=None,  reset=False):", "body": "reset = (reset or<EOL>index <= self._current_index or<EOL>total != self._total)<EOL>if reset:<EOL><INDENT>self._reset(index, total, percentage_step, length)<EOL><DEDENT>statement = None<EOL>indexp1 = index + <NUM_LIT:1.0><EOL>next_interval = int(indexp1 / self._norm_factor)<EOL>ending = index >= self._total_minus_one<EOL>if next_interval > self._current_interval or ending or reset:<EOL><INDENT>if time:<EOL><INDENT>remaining_str = self._get_remaining(index)<EOL><DEDENT>else:<EOL><INDENT>remaining_str = '<STR_LIT>'<EOL><DEDENT>if ending:<EOL><INDENT>statement = '<STR_LIT:[>' + '<STR_LIT:=>' * self._length +'<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>bars = int((indexp1 / self._total) * self._length)<EOL>spaces = self._length - bars<EOL>percentage = indexp1 / self._total * <NUM_LIT><EOL>if reset:<EOL><INDENT>statement = ('<STR_LIT:[>' + '<STR_LIT:=>' * bars +<EOL>'<STR_LIT:U+0020>' * spaces + '<STR_LIT:]>' + '<STR_LIT>' % percentage + '<STR_LIT:%>')<EOL><DEDENT>else:<EOL><INDENT>statement = ('<STR_LIT:[>' + '<STR_LIT:=>' * bars +<EOL>'<STR_LIT:U+0020>' * spaces + '<STR_LIT:]>' + '<STR_LIT>' % percentage + '<STR_LIT:%>' +<EOL>remaining_str)<EOL><DEDENT><DEDENT>if fmt_string:<EOL><INDENT>statement = fmt_string % statement<EOL><DEDENT>if logger == '<STR_LIT>':<EOL><INDENT>if reprint:<EOL><INDENT>print('<STR_LIT:\\r>' + statement, end='<STR_LIT>', flush=True)<EOL><DEDENT>else:<EOL><INDENT>print(statement)<EOL><DEDENT><DEDENT>elif logger is not None:<EOL><INDENT>if isinstance(logger, str):<EOL><INDENT>logger = logging.getLogger(logger)<EOL><DEDENT>logger.log(msg=statement, level=log_level)<EOL><DEDENT><DEDENT>self._current_interval = next_interval<EOL>self._current_index = index<EOL>return statement<EOL>", "docstring": "Plots a progress bar to the given `logger` for large for loops.\n\n        To be used inside a for-loop at the end of the loop.\n\n        :param index: Current index of for-loop\n        :param total: Total size of for-loop\n        :param percentage_step: Percentage step with which the bar should be updated\n        :param logger:\n\n            Logger to write to, if string 'print' is given, the print statement is\n            used. Use None if you don't want to print or log the progressbar statement.\n\n        :param log_level: Log level with which to log.\n        :param reprint:\n\n            If no new line should be plotted but carriage return (works only for printing)\n\n        :param time: If the remaining time should be calculated and displayed\n        :param length: Length of the bar in `=` signs.\n        :param fmt_string:\n\n            A string which contains exactly one `%s` in order to incorporate the progressbar.\n            If such a string is given, ``fmt_string % progressbar`` is printed/logged.\n\n        :param reset:\n\n            If the progressbar should be restarted. If progressbar is called with a lower\n            index than the one before, the progressbar is automatically restarted.\n\n        :return:\n\n            The progressbar string or None if the string has not been updated.", "id": "f4218:c0:m3"}
{"signature": "def progressbar(index, total, percentage_step=<NUM_LIT:10>, logger='<STR_LIT>', log_level=logging.INFO,<EOL>reprint=True, time=True, length=<NUM_LIT:20>, fmt_string=None, reset=False):", "body": "return _progressbar(index=index, total=total, percentage_step=percentage_step,<EOL>logger=logger, log_level=log_level, reprint=reprint,<EOL>time=time, length=length, fmt_string=fmt_string, reset=reset)<EOL>", "docstring": "Plots a progress bar to the given `logger` for large for loops.\n\n    To be used inside a for-loop at the end of the loop:\n\n    .. code-block:: python\n\n        for irun in range(42):\n            my_costly_job() # Your expensive function\n            progressbar(index=irun, total=42, reprint=True) # shows a growing progressbar\n\n\n    There is no initialisation of the progressbar necessary before the for-loop.\n    The progressbar will be reset automatically if used in another for-loop.\n\n    :param index: Current index of for-loop\n    :param total: Total size of for-loop\n    :param percentage_step: Steps with which the bar should be plotted\n    :param logger:\n\n        Logger to write to - with level INFO. If string 'print' is given, the print statement is\n        used. Use ``None`` if you don't want to print or log the progressbar statement.\n\n    :param log_level: Log level with which to log.\n    :param reprint:\n\n        If no new line should be plotted but carriage return (works only for printing)\n\n    :param time: If the remaining time should be estimated and displayed\n    :param length: Length of the bar in `=` signs.\n    :param fmt_string:\n\n        A string which contains exactly one `%s` in order to incorporate the progressbar.\n        If such a string is given, ``fmt_string % progressbar`` is printed/logged.\n\n    :param reset:\n\n        If the progressbar should be restarted. If progressbar is called with a lower\n        index than the one before, the progressbar is automatically restarted.\n\n    :return:\n\n        The progressbar string or `None` if the string has not been updated.", "id": "f4218:m3"}
{"signature": "def _get_argspec(func):", "body": "if inspect.isclass(func):<EOL><INDENT>func = func.__init__<EOL><DEDENT>if not inspect.isfunction(func):<EOL><INDENT>return [], False<EOL><DEDENT>parameters = inspect.signature(func).parameters<EOL>args = []<EOL>uses_starstar = False<EOL>for par in parameters.values():<EOL><INDENT>if (par.kind == inspect.Parameter.POSITIONAL_OR_KEYWORD or<EOL>par.kind == inspect.Parameter.KEYWORD_ONLY):<EOL><INDENT>args.append(par.name)<EOL><DEDENT>elif par.kind == inspect.Parameter.VAR_KEYWORD:<EOL><INDENT>uses_starstar = True<EOL><DEDENT><DEDENT>return args, uses_starstar<EOL>", "docstring": "Helper function to support both Python versions", "id": "f4218:m4"}
{"signature": "def port_to_tcp(port=None):", "body": "<EOL>domain_name = socket.getfqdn()<EOL>try:<EOL><INDENT>addr_list = socket.getaddrinfo(domain_name, None)<EOL><DEDENT>except Exception:<EOL><INDENT>addr_list = socket.getaddrinfo('<STR_LIT:127.0.0.1>', None)<EOL><DEDENT>family, socktype, proto, canonname, sockaddr = addr_list[<NUM_LIT:0>]<EOL>host = convert_ipv6(sockaddr[<NUM_LIT:0>])<EOL>address =  '<STR_LIT>' + host<EOL>if port is None:<EOL><INDENT>port = ()<EOL><DEDENT>if not isinstance(port, int):<EOL><INDENT>context = zmq.Context()<EOL>try:<EOL><INDENT>socket_ = context.socket(zmq.REP)<EOL>socket_.ipv6 = is_ipv6(address)<EOL>port = socket_.bind_to_random_port(address, *port)<EOL><DEDENT>except Exception:<EOL><INDENT>print('<STR_LIT>'.format(address, addr_list))<EOL>pypet_root_logger = logging.getLogger('<STR_LIT>')<EOL>pypet_root_logger.exception('<STR_LIT>'.format(address))<EOL>raise<EOL><DEDENT>socket_.close()<EOL>context.term()<EOL><DEDENT>return address + '<STR_LIT::>' + str(port)<EOL>", "docstring": "Returns local tcp address for a given `port`, automatic port if `None`", "id": "f4218:m10"}
{"signature": "def merge_all_in_folder(folder, ext='<STR_LIT>',<EOL>dynamic_imports=None,<EOL>storage_service=None,<EOL>force=False,<EOL>ignore_data=(),<EOL>move_data=False,<EOL>delete_other_files=False,<EOL>keep_info=True,<EOL>keep_other_trajectory_info=True,<EOL>merge_config=True,<EOL>backup=True):", "body": "in_dir = os.listdir(folder)<EOL>all_files = []<EOL>for file in in_dir:<EOL><INDENT>full_file = os.path.join(folder, file)<EOL>if os.path.isfile(full_file):<EOL><INDENT>_, extension = os.path.splitext(full_file)<EOL>if extension == ext:<EOL><INDENT>all_files.append(full_file)<EOL><DEDENT><DEDENT><DEDENT>all_files = sorted(all_files)<EOL>trajs = []<EOL>for full_file in all_files:<EOL><INDENT>traj = load_trajectory(index=-<NUM_LIT:1>,<EOL>storage_service=storage_service,<EOL>filename=full_file,<EOL>load_data=<NUM_LIT:0>,<EOL>force=force,<EOL>dynamic_imports=dynamic_imports)<EOL>trajs.append(traj)<EOL><DEDENT>first_traj = trajs.pop(<NUM_LIT:0>)<EOL>first_traj.f_merge_many(trajs,<EOL>ignore_data=ignore_data,<EOL>move_data=move_data,<EOL>delete_other_trajectory=False,<EOL>keep_info=keep_info,<EOL>keep_other_trajectory_info=keep_other_trajectory_info,<EOL>merge_config=merge_config,<EOL>backup=backup)<EOL>if delete_other_files:<EOL><INDENT>for file in all_files[<NUM_LIT:1>:]:<EOL><INDENT>os.remove(file)<EOL><DEDENT><DEDENT>return first_traj<EOL>", "docstring": "Merges all files in a given folder.\n\n    IMPORTANT: Does not check if there are more than 1 trajectory in a file. Always\n    uses the last trajectory in file and ignores the other ones.\n\n    Trajectories are merged according to the alphabetical order of the files,\n    i.e. the resulting merged trajectory is found in the first file\n    (according to lexicographic ordering).\n\n    :param folder: folder (not recursive) where to look for files\n    :param ext: only files with the given extension are used\n    :param dynamic_imports: Dynamic imports for loading\n    :param storage_service: storage service to use, leave `None` to use the default one\n    :param force: If loading should be forced.\n    :param delete_other_files: Deletes files of merged trajectories\n\n    All other parameters as in `f_merge_many` of the trajectory.\n\n    :return: The merged traj", "id": "f4219:m0"}
{"signature": "def next(self):", "body": "while True:<EOL><INDENT>try:<EOL><INDENT>return next(self._current)<EOL><DEDENT>except StopIteration:<EOL><INDENT>try:<EOL><INDENT>self._current = iter(self._chain.popleft())<EOL><DEDENT>except IndexError:<EOL><INDENT>raise StopIteration('<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Returns next element from chain.\n\n        More precisely, it returns the next element of the\n        foremost iterator. If this iterator is empty it moves iteratively\n        along the chain of available iterators to pick the new foremost one.\n\n        Raises StopIteration if there are no elements left.", "id": "f4222:c1:m2"}
{"signature": "def __init__(self, ndarray):", "body": "self._ndarray = ndarray<EOL>", "docstring": "Creates a new hashable object encapsulating an ndarray.\n\n            :param ndarray: The wrapped ndarray.", "id": "f4222:c3:m0"}
{"signature": "def nested_equal(a, b):", "body": "if a is b:<EOL><INDENT>return True<EOL><DEDENT>if a is None or b is None:<EOL><INDENT>return False<EOL><DEDENT>a_sparse = spsp.isspmatrix(a)<EOL>b_sparse = spsp.isspmatrix(b)<EOL>if a_sparse != b_sparse:<EOL><INDENT>return False<EOL><DEDENT>if a_sparse:<EOL><INDENT>if a.nnz == <NUM_LIT:0>:<EOL><INDENT>return b.nnz == <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>return not np.any((a != b).data)<EOL><DEDENT><DEDENT>a_series = isinstance(a, pd.Series)<EOL>b_series = isinstance(b, pd.Series)<EOL>if a_series != b_series:<EOL><INDENT>return False<EOL><DEDENT>if a_series:<EOL><INDENT>try:<EOL><INDENT>eq = (a == b).all()<EOL>return eq<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>if not len(a) == len(b):<EOL><INDENT>return False<EOL><DEDENT>for idx, itema in enumerate(a):<EOL><INDENT>itemb = b[idx]<EOL>if not nested_equal(itema, itemb):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL><DEDENT><DEDENT>a_frame = isinstance(a, pd.DataFrame)<EOL>b_frame = isinstance(b, pd.DataFrame)<EOL>if a_frame != b_frame:<EOL><INDENT>return False<EOL><DEDENT>if a_frame:<EOL><INDENT>try:<EOL><INDENT>if a.empty and b.empty:<EOL><INDENT>return True<EOL><DEDENT>new_frame = a == b<EOL>new_frame = new_frame | (pd.isnull(a) & pd.isnull(b))<EOL>if isinstance(new_frame, pd.DataFrame):<EOL><INDENT>return np.all(new_frame.as_matrix())<EOL><DEDENT><DEDENT>except (ValueError, TypeError):<EOL><INDENT>for name in a:<EOL><INDENT>cola = a[name]<EOL>if not name in b:<EOL><INDENT>return False<EOL><DEDENT>colb = b[name]<EOL>if not len(cola) == len(colb):<EOL><INDENT>return False<EOL><DEDENT>for idx, itema in enumerate(cola):<EOL><INDENT>itemb = colb[idx]<EOL>if not nested_equal(itema, itemb):<EOL><INDENT>return False<EOL><DEDENT><DEDENT><DEDENT>return True<EOL><DEDENT><DEDENT>a_array = isinstance(a, np.ndarray)<EOL>b_array = isinstance(b, np.ndarray)<EOL>if a_array != b_array:<EOL><INDENT>return False<EOL><DEDENT>if a_array:<EOL><INDENT>if a.shape != b.shape:<EOL><INDENT>return False<EOL><DEDENT>return np.all(a == b)<EOL><DEDENT>a_list = isinstance(a, (Sequence, list, tuple))<EOL>b_list = isinstance(b, (Sequence, list, tuple))<EOL>if a_list != b_list:<EOL><INDENT>return False<EOL><DEDENT>if a_list:<EOL><INDENT>return all(nested_equal(x, y) for x, y in zip(a, b))<EOL><DEDENT>a_mapping = isinstance(a, (Mapping, dict))<EOL>b_mapping = isinstance(b, (Mapping, dict))<EOL>if a_mapping != b_mapping:<EOL><INDENT>return False<EOL><DEDENT>if a_mapping:<EOL><INDENT>keys_a = a.keys()<EOL>if set(keys_a) != set(b.keys()):<EOL><INDENT>return False<EOL><DEDENT>return all(nested_equal(a[k], b[k]) for k in keys_a)<EOL><DEDENT>equality = NotImplemented<EOL>try:<EOL><INDENT>equality = a.__eq__(b)<EOL><DEDENT>except (AttributeError, NotImplementedError, TypeError, ValueError):<EOL><INDENT>pass<EOL><DEDENT>if equality is NotImplemented:<EOL><INDENT>try:<EOL><INDENT>equality = b.__eq__(a)<EOL><DEDENT>except (AttributeError, NotImplementedError, TypeError, ValueError):<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if equality is NotImplemented:<EOL><INDENT>try:<EOL><INDENT>cmp = a.__cmp__(b)<EOL>if cmp is not NotImplemented:<EOL><INDENT>equality = cmp == <NUM_LIT:0><EOL><DEDENT><DEDENT>except (AttributeError, NotImplementedError, TypeError, ValueError):<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if equality is NotImplemented:<EOL><INDENT>try:<EOL><INDENT>cmp = b.__cmp__(a)<EOL>if cmp is not NotImplemented:<EOL><INDENT>equality = cmp == <NUM_LIT:0><EOL><DEDENT><DEDENT>except (AttributeError, NotImplementedError, TypeError, ValueError):<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if equality is not NotImplemented:<EOL><INDENT>try:<EOL><INDENT>return bool(equality)<EOL><DEDENT>except (AttributeError, NotImplementedError, TypeError, ValueError):<EOL><INDENT>pass<EOL><DEDENT><DEDENT>attributes_a = get_all_attributes(a)<EOL>attributes_b = get_all_attributes(b)<EOL>if len(attributes_a) != len(attributes_b):<EOL><INDENT>return False<EOL><DEDENT>if len(attributes_a) > <NUM_LIT:0>:<EOL><INDENT>keys_a = list(attributes_a.keys())<EOL>if set(keys_a) != set(attributes_b.keys()):<EOL><INDENT>return False<EOL><DEDENT>return all(nested_equal(attributes_a[k], attributes_b[k]) for k in keys_a)<EOL><DEDENT>return False<EOL>", "docstring": "Compares two objects recursively by their elements.\n\n    Also handles numpy arrays, pandas data and sparse matrices.\n\n    First checks if the data falls into the above categories.\n    If not, it is checked if a or b are some type of sequence or mapping and\n    the contained elements are compared.\n    If this is not the case, it is checked if a or b do provide a custom `__eq__` that\n    evaluates to a single boolean value.\n    If this is not the case, the attributes of a and b are compared.\n    If this does not help either, normal `==` is used.\n\n    Assumes hashable items are not mutable in a way that affects equality.\n    Based on the suggestion from HERE_, thanks again Lauritz V. Thaulow :-)\n\n    .. _HERE: http://stackoverflow.com/questions/18376935/best-practice-for-equality-in-python", "id": "f4224:m3"}
{"signature": "def _collect_section(self, section):", "body": "kwargs = {}<EOL>try:<EOL><INDENT>if self.parser.has_section(section):<EOL><INDENT>options = self.parser.options(section)<EOL>for option in options:<EOL><INDENT>str_val = self.parser.get(section, option)<EOL>val = ast.literal_eval(str_val)<EOL>kwargs[option] = val<EOL><DEDENT><DEDENT>return kwargs<EOL><DEDENT>except:<EOL><INDENT>raise<EOL><DEDENT>", "docstring": "Collects all settings within a section", "id": "f4226:c0:m1"}
{"signature": "def load_class(full_class_string):", "body": "class_data = full_class_string.split(\"<STR_LIT:.>\")<EOL>module_path = \"<STR_LIT:.>\".join(class_data[:-<NUM_LIT:1>])<EOL>class_str = class_data[-<NUM_LIT:1>]<EOL>module = importlib.import_module(module_path)<EOL>return getattr(module, class_str)<EOL>", "docstring": "Loads a class from a string naming the module and class name.\n\n    For example:\n    >>> load_class(full_class_string = 'pypet.brian.parameter.BrianParameter')\n    <BrianParameter>", "id": "f4227:m0"}
{"signature": "def _prfx_getattr_(obj, item):", "body": "if item.startswith('<STR_LIT>') or item.startswith('<STR_LIT>'):<EOL><INDENT>return getattr(obj, item[<NUM_LIT:2>:])<EOL><DEDENT>raise AttributeError('<STR_LIT>' % (obj.__class__.__name__, item))<EOL>", "docstring": "Replacement of __getattr__", "id": "f4228:m8"}
{"signature": "def _prfx_setattr_(obj, item, value):", "body": "if item.startswith('<STR_LIT>'):<EOL><INDENT>return setattr(obj, item[<NUM_LIT:2>:], value)<EOL><DEDENT>else:<EOL><INDENT>return super(obj.__class__, obj).__setattr__(item, value)<EOL><DEDENT>", "docstring": "Replacement of __setattr__", "id": "f4228:m9"}
{"signature": "def deprecated(msg='<STR_LIT>'):", "body": "def wrapper(func):<EOL><INDENT>@functools.wraps(func)<EOL>def new_func(*args, **kwargs):<EOL><INDENT>warning_string = \"<STR_LIT>\" % func.__name__<EOL>warning_string = warning_string + '<STR_LIT:U+0020>' + msg<EOL>warnings.warn(<EOL>warning_string,<EOL>category=DeprecationWarning,<EOL>)<EOL>return func(*args, **kwargs)<EOL><DEDENT>return new_func<EOL><DEDENT>return wrapper<EOL>", "docstring": "This is a decorator which can be used to mark functions\n    as deprecated. It will result in a warning being emitted\n    when the function is used.\n\n    :param msg:\n\n        Additional message added to the warning.", "id": "f4228:m1"}
{"signature": "def pipeline(self, pipeline):", "body": "self._user_pipeline = True<EOL>self._map_arguments = False<EOL>return self._execute_runs(pipeline)<EOL>", "docstring": "You can make *pypet* supervise your whole experiment by defining a pipeline.\n\n        `pipeline` is a function that defines the entire experiment. From pre-processing\n        including setting up the trajectory over defining the actual simulation runs to\n        post processing.\n\n        The `pipeline` function needs to return TWO tuples with a maximum of three entries each.\n\n        For example:\n\n        ::\n\n            return (runfunc, args, kwargs), (postproc, postproc_args, postproc_kwargs)\n\n        Where `runfunc` is the actual simulation function thet gets passed the trajectory\n        container and potentially additional arguments `args` and keyword arguments `kwargs`.\n        This will be run by your environment with all parameter combinations.\n\n        `postproc` is a post processing function that handles your computed results.\n        The function must accept as arguments the trajectory container, a list of\n        results (list of tuples (run idx, result) ) and potentially\n        additional arguments `postproc_args` and keyword arguments `postproc_kwargs`.\n\n        As for :func:`~pypet.environment.Environment.f_add_postproc`, this function can\n        potentially extend the trajectory.\n\n        If you don't want to apply post-processing, your pipeline function can also simply\n        return the run function and the arguments:\n\n        ::\n\n            return runfunc, args, kwargs\n\n        Or\n\n        ::\n\n            return runfunc, args\n\n        Or\n\n        ::\n\n            return runfunc\n\n        ``return runfunc, kwargs`` does NOT work, if you don't want to pass `args` do\n        ``return runfunc, (), kwargs``.\n\n        Analogously combinations like\n\n        ::\n\n            return (runfunc, args), (postproc,)\n\n        work as well.\n\n        :param pipeline:\n\n            The pipleine function, taking only a single argument `traj`.\n            And returning all functions necessary for your experiment.\n\n        :return:\n\n            List of the individual results returned by `runfunc`.\n\n            Returns a LIST OF TUPLES, where first entry is the run idx and second entry\n            is the actual result. In case of multiprocessing these are not necessarily\n            ordered according to their run index, but ordered according to their finishing time.\n\n            Does not contain results stored in the trajectory!\n            In order to access these simply interact with the trajectory object,\n            potentially after calling :func:`~pypet.trajectory.Trajectory.f_update_skeleton`\n            and loading all results at once with :func:`~pypet.trajectory.f_load`\n            or loading manually with :func:`~pypet.trajectory.f_load_items`.\n\n            Even if you use multiprocessing without a pool the results returned by\n            `runfunc` still need to be pickled.\n\n            Results computed from `postproc` are not returned. `postproc` should not\n            return any results except dictionaries if the trajectory should be expanded.", "id": "f4231:c0:m16"}
{"signature": "def _add_wildcard_config(self):", "body": "for idx, pair in enumerate(self._traj._wildcard_functions.items()):<EOL><INDENT>wildcards, wc_function = pair<EOL>for jdx, wildcard in enumerate(wildcards):<EOL><INDENT>config_name = ('<STR_LIT>' %<EOL>(self.name, idx, jdx))<EOL>if not self._traj.f_contains('<STR_LIT>' + config_name):<EOL><INDENT>self._traj.f_add_config(Parameter, config_name, wildcard,<EOL>comment='<STR_LIT>').f_lock()<EOL><DEDENT><DEDENT>if hasattr(wc_function, '<STR_LIT>'):<EOL><INDENT>config_name = ('<STR_LIT>' %<EOL>(self.name, idx))<EOL>if not self._traj.f_contains('<STR_LIT>' + config_name):<EOL><INDENT>self._traj.f_add_config(Parameter, config_name, wc_function.__name__,<EOL>comment='<STR_LIT>').f_lock()<EOL><DEDENT><DEDENT>if wc_function.__doc__:<EOL><INDENT>config_name = ('<STR_LIT>' %<EOL>(self.name, idx))<EOL>if not self._traj.f_contains('<STR_LIT>' + config_name):<EOL><INDENT>self._traj.f_add_config(Parameter, config_name, wc_function.__doc__,<EOL>comment='<STR_LIT>').f_lock()<EOL><DEDENT><DEDENT>try:<EOL><INDENT>source = inspect.getsource(wc_function)<EOL>config_name = ('<STR_LIT>' %<EOL>(self.name, idx))<EOL>if not self._traj.f_contains('<STR_LIT>' + config_name):<EOL><INDENT>self._traj.f_add_config(Parameter, config_name, source,<EOL>comment='<STR_LIT>').f_lock()<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>", "docstring": "Adds config data about the wildcard functions", "id": "f4231:c0:m33"}
{"signature": "def _single_run(kwargs):", "body": "pypet_root_logger = logging.getLogger('<STR_LIT>')<EOL>traj = kwargs['<STR_LIT>']<EOL>runfunc = kwargs['<STR_LIT>']<EOL>runargs = kwargs['<STR_LIT>']<EOL>kwrunparams = kwargs['<STR_LIT>']<EOL>clean_up_after_run = kwargs['<STR_LIT>']<EOL>automatic_storing = kwargs['<STR_LIT>']<EOL>wrap_mode = kwargs['<STR_LIT>']<EOL>idx = traj.v_idx<EOL>total_runs = len(traj)<EOL>pypet_root_logger.info('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % (idx, total_runs))<EOL>traj.f_start_run(turn_into_run=True)<EOL>result = runfunc(traj, *runargs, **kwrunparams)<EOL>if automatic_storing:<EOL><INDENT>traj.f_store()<EOL><DEDENT>if wrap_mode == pypetconstants.WRAP_MODE_LOCAL:<EOL><INDENT>result = ((traj.v_idx, result),<EOL>traj.f_get_run_information(traj.v_idx, copy=False),<EOL>traj.v_storage_service.references)<EOL>traj.v_storage_service.free_references()<EOL><DEDENT>else:<EOL><INDENT>result = ((traj.v_idx, result),<EOL>traj.f_get_run_information(traj.v_idx, copy=False))<EOL><DEDENT>traj.f_finalize_run(store_meta_data=False,<EOL>clean_up=clean_up_after_run)<EOL>pypet_root_logger.info('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % (idx, total_runs))<EOL>return result<EOL>", "docstring": "Performs a single run of the experiment.\n\n    :param kwargs: Dict of arguments\n\n        traj: The trajectory containing all parameters set to the corresponding run index.\n\n        runfunc: The user's job function\n\n        runargs: The arguments handed to the user's job function (as *args)\n\n        runkwargs: The keyword arguments handed to the user's job function (as **kwargs)\n\n        clean_up_after_run: Whether to clean up after the run\n\n        automatic_storing: Whether or not the data should be automatically stored\n\n        result_queue: A queue object to store results into in case a pool is used, otherwise None\n\n    :return:\n\n        Results computed by the user's job function which are not stored into the trajectory.\n        Returns a nested tuple of run index and result and run information:\n        ``((traj.v_idx, result), run_information_dict)``", "id": "f4231:m11"}
{"signature": "def _configure_frozen_scoop(kwargs):", "body": "def _delete_old_scoop_rev_data(old_scoop_rev):<EOL><INDENT>if old_scoop_rev is not None:<EOL><INDENT>try:<EOL><INDENT>elements = shared.elements<EOL>for key in elements:<EOL><INDENT>var_dict = elements[key]<EOL>if old_scoop_rev in var_dict:<EOL><INDENT>del var_dict[old_scoop_rev]<EOL><DEDENT><DEDENT>logging.getLogger('<STR_LIT>').debug('<STR_LIT>'<EOL>'<STR_LIT>' % old_scoop_rev)<EOL><DEDENT>except AttributeError:<EOL><INDENT>logging.getLogger('<STR_LIT>').error('<STR_LIT>'<EOL>'<STR_LIT>' % old_scoop_rev)<EOL><DEDENT><DEDENT><DEDENT>scoop_rev = kwargs.pop('<STR_LIT>')<EOL>try:<EOL><INDENT>old_scoop_rev = _frozen_scoop_single_run.kwargs['<STR_LIT>']<EOL>configured = old_scoop_rev == scoop_rev<EOL><DEDENT>except (AttributeError, KeyError):<EOL><INDENT>old_scoop_rev = None<EOL>configured = False<EOL><DEDENT>if not configured:<EOL><INDENT>_frozen_scoop_single_run.kwargs = shared.getConst(scoop_rev, timeout=<NUM_LIT>)<EOL>frozen_kwargs = _frozen_scoop_single_run.kwargs<EOL>frozen_kwargs['<STR_LIT>'] = scoop_rev<EOL>frozen_kwargs['<STR_LIT>'].v_full_copy = frozen_kwargs['<STR_LIT>']<EOL>if not scoop.IS_ORIGIN:<EOL><INDENT>_configure_niceness(frozen_kwargs)<EOL>_configure_logging(frozen_kwargs, extract=False)<EOL><DEDENT>_delete_old_scoop_rev_data(old_scoop_rev)<EOL>logging.getLogger('<STR_LIT>').info('<STR_LIT>' % str(scoop.worker))<EOL><DEDENT>", "docstring": "Wrapper function that configures a frozen SCOOP set up.\n\n    Deletes of data if necessary.", "id": "f4231:m5"}
{"signature": "def _configure_pool(kwargs):", "body": "_pool_single_run.storage_service = kwargs['<STR_LIT>']<EOL>_configure_niceness(kwargs)<EOL>_configure_logging(kwargs, extract=False)<EOL>", "docstring": "Configures the pool and keeps the storage service", "id": "f4231:m2"}
{"signature": "def _get_results_from_queue(self, result_queue, results, n, total_runs):", "body": "<EOL>while not result_queue.empty():<EOL><INDENT>result = result_queue.get()<EOL>n = self._check_result_and_store_references(result, results, n, total_runs)<EOL><DEDENT>return n<EOL>", "docstring": "Extract all available results from the queue and returns the increased n", "id": "f4231:c0:m35"}
{"signature": "def _check_result_and_store_references(self, result, results, n, total_runs):", "body": "if result[<NUM_LIT:0>] == sigint_handling.SIGINT:<EOL><INDENT>self._stop_iteration = True<EOL>result = result[<NUM_LIT:1>]  <EOL><DEDENT>if result is not None:<EOL><INDENT>if self._wrap_mode == pypetconstants.WRAP_MODE_LOCAL:<EOL><INDENT>self._multiproc_wrapper.store_references(result[<NUM_LIT:2>])<EOL><DEDENT>self._traj._update_run_information(result[<NUM_LIT:1>])<EOL>results.append(result[<NUM_LIT:0>])<EOL>if self._resumable:<EOL><INDENT>self._trigger_result_snapshot(result[<NUM_LIT:0>:<NUM_LIT:2>])<EOL><DEDENT><DEDENT>self._show_progress(n, total_runs)<EOL>n += <NUM_LIT:1><EOL>return n<EOL>", "docstring": "Checks for SIGINT and if reference wrapping and stores references.", "id": "f4231:c0:m36"}
{"signature": "def _prepare_queue(self):", "body": "if self._queue is None:<EOL><INDENT>if self._use_manager:<EOL><INDENT>if self._manager is None:<EOL><INDENT>self._manager = multip.Manager()<EOL><DEDENT>self._queue = self._manager.Queue(maxsize=self._queue_maxsize)<EOL><DEDENT>else:<EOL><INDENT>self._queue = multip.Queue(maxsize=self._queue_maxsize)<EOL><DEDENT><DEDENT>self._logger.info('<STR_LIT>')<EOL>queue_handler = QueueStorageServiceWriter(self._storage_service, self._queue,<EOL>self._gc_interval)<EOL>self._queue_process = multip.Process(name='<STR_LIT>', target=_wrap_handling,<EOL>args=(dict(handler=queue_handler,<EOL>logging_manager=self._logging_manager,<EOL>graceful_exit=self._graceful_exit),))<EOL>self._queue_process.start()<EOL>self._queue_wrapper = QueueStorageServiceSender(self._queue)<EOL>self._traj.v_storage_service = self._queue_wrapper<EOL>", "docstring": "Replaces the trajectory's service with a queue sender and starts the queue process.", "id": "f4231:c1:m17"}
{"signature": "def __repr__(self):", "body": "repr_string = '<STR_LIT>' % (self.__class__.__name__, self.name,<EOL>self.trajectory.v_name)<EOL>return repr_string<EOL>", "docstring": "String representation of environment", "id": "f4231:c0:m2"}
{"signature": "def _trigger_result_snapshot(self, result):", "body": "timestamp = result[<NUM_LIT:1>]['<STR_LIT>']<EOL>timestamp_str = repr(timestamp).replace('<STR_LIT:.>', '<STR_LIT:_>')<EOL>filename = '<STR_LIT>' % timestamp_str<EOL>extension = '<STR_LIT>'<EOL>dump_filename = os.path.join(self._resume_path, filename + extension)<EOL>dump_file = open(dump_filename, '<STR_LIT:wb>')<EOL>dill.dump(result, dump_file, protocol=<NUM_LIT:2>)<EOL>dump_file.flush()<EOL>dump_file.close()<EOL>extension = '<STR_LIT>'<EOL>rename_filename = os.path.join(self._resume_path, filename + extension)<EOL>shutil.move(dump_filename, rename_filename)<EOL>", "docstring": "Triggers a snapshot of the results for continuing\n\n        :param result: Currently computed result", "id": "f4231:c0:m37"}
{"signature": "@property<EOL><INDENT>def current_idx(self):<DEDENT>", "body": "return self._current_idx<EOL>", "docstring": "The current run index that is the next one to be executed.\n\n        Can be set manually to make the environment consider old non-completed ones.", "id": "f4231:c0:m9"}
{"signature": "def _configure_logging(kwargs, extract=True):", "body": "try:<EOL><INDENT>logging_manager = kwargs['<STR_LIT>']<EOL>if extract:<EOL><INDENT>logging_manager.extract_replacements(kwargs['<STR_LIT>'])<EOL><DEDENT>logging_manager.make_logging_handlers_and_tools(multiproc=True)<EOL><DEDENT>except Exception as exc:<EOL><INDENT>sys.stderr.write('<STR_LIT>' % repr(exc))<EOL>traceback.print_exc()<EOL><DEDENT>", "docstring": "Requests the logging manager to configure logging.\n\n    :param extract:\n\n        If naming data should be extracted from the trajectory", "id": "f4231:m8"}
{"signature": "def _prepare_sumatra(self):", "body": "reason = self._sumatra_reason<EOL>if reason:<EOL><INDENT>reason += '<STR_LIT>'<EOL><DEDENT>if self._traj.v_comment:<EOL><INDENT>commentstr = '<STR_LIT>' % self._traj.v_comment<EOL><DEDENT>else:<EOL><INDENT>commentstr = '<STR_LIT>'<EOL><DEDENT>reason += '<STR_LIT>' %(self._traj.v_name,<EOL>commentstr,<EOL>str(list(self._traj._explored_parameters.keys())))<EOL>self._logger.info('<STR_LIT>' % reason)<EOL>self._sumatra_reason = reason<EOL>self._loaded_sumatatra_project = load_project(self._sumatra_project)<EOL>if self._traj.f_contains('<STR_LIT>', shortcuts=False):<EOL><INDENT>param_dict = self._traj.parameters.f_to_dict(fast_access=False)<EOL>for param_name in list(param_dict.keys()):<EOL><INDENT>param = param_dict[param_name]<EOL>if param.f_has_range():<EOL><INDENT>param_dict[param_name] = param.f_get_range()<EOL><DEDENT>else:<EOL><INDENT>param_dict[param_name] = param.f_get()<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>param_dict = {}<EOL><DEDENT>relpath = os.path.relpath(sys.modules['<STR_LIT:__main__>'].__file__, self._sumatra_project)<EOL>executable = PythonExecutable(path=sys.executable)<EOL>self._sumatra_record = self._loaded_sumatatra_project.new_record(<EOL>parameters=param_dict,<EOL>main_file=relpath,<EOL>executable=executable,<EOL>label=self._sumatra_label,<EOL>reason=reason)<EOL>", "docstring": "Prepares a sumatra record", "id": "f4231:c0:m21"}
{"signature": "@property<EOL><INDENT>def traj(self):<DEDENT>", "body": "return self.trajectory<EOL>", "docstring": "Equivalent to env.trajectory", "id": "f4231:c0:m8"}
{"signature": "def _finish_sumatra(self):", "body": "finish_time = self._start_timestamp - self._finish_timestamp<EOL>self._sumatra_record.duration = finish_time<EOL>self._sumatra_record.output_data = self._sumatra_record.datastore.find_new_data(<EOL>self._sumatra_record.timestamp)<EOL>self._loaded_sumatatra_project.add_record(self._sumatra_record)<EOL>self._loaded_sumatatra_project.save()<EOL>sumatra_label = self._sumatra_record.label<EOL>config_name = '<STR_LIT>' % str(sumatra_label)<EOL>conf_list = []<EOL>if not self._traj.f_contains('<STR_LIT>' + config_name):<EOL><INDENT>conf1 = self._traj.f_add_config(Parameter, config_name, str(sumatra_label),<EOL>comment='<STR_LIT>')<EOL>conf_list.append(conf1)<EOL><DEDENT>if self._sumatra_reason:<EOL><INDENT>config_name = '<STR_LIT>' % str(sumatra_label)<EOL>if not self._traj.f_contains('<STR_LIT>' + config_name):<EOL><INDENT>conf2 = self._traj.f_add_config(Parameter, config_name,<EOL>str(self._sumatra_reason),<EOL>comment='<STR_LIT>')<EOL>conf_list.append(conf2)<EOL><DEDENT><DEDENT>if self._automatic_storing and conf_list:<EOL><INDENT>self._traj.f_store_items(conf_list)<EOL><DEDENT>self._logger.info('<STR_LIT>'<EOL>'<STR_LIT:%s>' % str(self._sumatra_reason))<EOL>", "docstring": "Saves a sumatra record", "id": "f4231:c0:m22"}
{"signature": "def _execute_runs(self, pipeline):", "body": "if self._start_timestamp is None:<EOL><INDENT>self._start_timestamp = time.time()<EOL><DEDENT>if self._map_arguments and self._resumable:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>if self._sumatra_project is not None:<EOL><INDENT>self._prepare_sumatra()<EOL><DEDENT>if pipeline is not None:<EOL><INDENT>results = []<EOL>self._prepare_runs(pipeline)<EOL><DEDENT>else:<EOL><INDENT>results = self._prepare_resume()<EOL><DEDENT>if self._runfunc is not None:<EOL><INDENT>self._traj._run_by_environment = True<EOL>if self._graceful_exit:<EOL><INDENT>sigint_handling.start()<EOL><DEDENT>try:<EOL><INDENT>self._inner_run_loop(results)<EOL><DEDENT>finally:<EOL><INDENT>self._traj._run_by_environment = False<EOL>self._stop_iteration = False<EOL>if self._graceful_exit:<EOL><INDENT>sigint_handling.finalize()<EOL><DEDENT><DEDENT><DEDENT>self._add_wildcard_config()<EOL>if self._automatic_storing:<EOL><INDENT>self._logger.info('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>self._traj.v_name)<EOL>self._traj.f_store()<EOL>self._logger.info('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>self._traj.v_name)<EOL><DEDENT>self._finish_timestamp = time.time()<EOL>findatetime = datetime.datetime.fromtimestamp(self._finish_timestamp)<EOL>startdatetime = datetime.datetime.fromtimestamp(self._start_timestamp)<EOL>self._runtime = str(findatetime - startdatetime)<EOL>conf_list = []<EOL>config_name = '<STR_LIT>' % self.name<EOL>if not self._traj.f_contains('<STR_LIT>' + config_name):<EOL><INDENT>conf1 = self._traj.f_add_config(Parameter, config_name, self._start_timestamp,<EOL>comment='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>conf_list.append(conf1)<EOL><DEDENT>config_name = '<STR_LIT>' % self.name<EOL>if not self._traj.f_contains('<STR_LIT>' + config_name):<EOL><INDENT>conf2 = self._traj.f_add_config(Parameter, config_name, self._finish_timestamp,<EOL>comment='<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>conf2 = self._traj.f_get('<STR_LIT>' + config_name)<EOL>conf2.f_unlock()<EOL>conf2.f_set(self._finish_timestamp)<EOL><DEDENT>conf_list.append(conf2)<EOL>config_name = '<STR_LIT>' % self.name<EOL>if not self._traj.f_contains('<STR_LIT>' + config_name):<EOL><INDENT>conf3 = self._traj.f_add_config(Parameter, config_name, self._runtime,<EOL>comment='<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>conf3 = self._traj.f_get('<STR_LIT>' + config_name)<EOL>conf3.f_unlock()<EOL>conf3.f_set(self._runtime)<EOL><DEDENT>conf_list.append(conf3)<EOL>if self._automatic_storing:<EOL><INDENT>self._traj.f_store_items(conf_list, store_data=pypetconstants.OVERWRITE_DATA)<EOL><DEDENT>if hasattr(self._traj.v_storage_service, '<STR_LIT>'):<EOL><INDENT>self._traj.v_storage_service.finalize()<EOL><DEDENT>incomplete = []<EOL>for run_name in self._traj.f_get_run_names():<EOL><INDENT>if not self._traj._is_completed(run_name):<EOL><INDENT>incomplete.append(run_name)<EOL><DEDENT><DEDENT>if len(incomplete) > <NUM_LIT:0>:<EOL><INDENT>self._logger.error('<STR_LIT>'<EOL>'<STR_LIT>' % (self._traj.v_name,<EOL>'<STR_LIT:U+002CU+0020>'.join(incomplete)))<EOL><DEDENT>else:<EOL><INDENT>self._logger.info('<STR_LIT>' %<EOL>self._traj.v_name)<EOL><DEDENT>if self._sumatra_project is not None:<EOL><INDENT>self._finish_sumatra()<EOL><DEDENT>return results<EOL>", "docstring": "Starts the individual single runs.\n\n        Starts runs sequentially or initiates multiprocessing.\n\n        :param pipeline:\n\n            A pipeline function producing the run function the corresponding arguments\n            and postprocessing function and arguments\n\n        :return:\n\n            List of tuples, where each tuple contains the run idx and the result.", "id": "f4231:c0:m32"}
{"signature": "def _frozen_pool_single_run(kwargs):", "body": "idx = kwargs.pop('<STR_LIT>')<EOL>frozen_kwargs = _frozen_pool_single_run.kwargs<EOL>frozen_kwargs.update(kwargs)  <EOL>traj = frozen_kwargs['<STR_LIT>']<EOL>traj.f_set_crun(idx)<EOL>return _sigint_handling_single_run(frozen_kwargs)<EOL>", "docstring": "Single run wrapper for the frozen pool, makes a single run and passes kwargs", "id": "f4231:m1"}
{"signature": "def __dir__(self):", "body": "result = set()<EOL>result.update(dir(self.__class__), self.__all_slots__)<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>result.update(self.__dict__.keys())<EOL><DEDENT>return list(result)<EOL>", "docstring": "Includes all slots in the `dir` method", "id": "f4233:c1:m2"}
{"signature": "def __setitem__(self, key, value):", "body": "self.f_set(**{key: value})<EOL>", "docstring": "Almost equivalent to calling __setattr__.\n\n        Treats integer values as `f_get`.", "id": "f4236:c0:m4"}
{"signature": "def f_is_empty(self):", "body": "return len(self._dict) == <NUM_LIT:0><EOL>", "docstring": "Checks if annotations are empty", "id": "f4236:c0:m7"}
{"signature": "def __getitem__(self, item):", "body": "return self.f_get(item)<EOL>", "docstring": "Equivalent to calling f_get()", "id": "f4236:c0:m3"}
{"signature": "def f_get(self, *args):", "body": "if len(args) == <NUM_LIT:0>:<EOL><INDENT>if len(self._dict) == <NUM_LIT:1>:<EOL><INDENT>return self._dict[list(self._dict.keys())[<NUM_LIT:0>]]<EOL><DEDENT>elif len(self._dict) > <NUM_LIT:1>:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(str(list(self._dict.keys()))))<EOL><DEDENT>else:<EOL><INDENT>raise AttributeError('<STR_LIT>')<EOL><DEDENT><DEDENT>result_list = []<EOL>for name in args:<EOL><INDENT>name = self._translate_key(name)<EOL>try:<EOL><INDENT>result_list.append(self._dict[name])<EOL><DEDENT>except KeyError:<EOL><INDENT>raise AttributeError('<STR_LIT>' % name)<EOL><DEDENT><DEDENT>if len(args) == <NUM_LIT:1>:<EOL><INDENT>return result_list[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>return tuple(result_list)<EOL><DEDENT>", "docstring": "Returns annotations\n\n        If len(args)>1, then returns a list of annotations.\n\n        `f_get(X)` with *X* integer will return the annotation with name `annotation_X`.\n\n        If the annotation contains only a single entry you can call `f_get()` without arguments.\n        If you call `f_get()` and the annotation contains more than one element a ValueError is\n        thrown.", "id": "f4236:c0:m13"}
{"signature": "@property<EOL><INDENT>def v_annotations(self):<DEDENT>", "body": "return self._annotations<EOL>", "docstring": "Annotation feature of a trajectory node.\n\n        Store some short additional information about your nodes here.\n        If you use the standard HDF5 storage service, they will be stored as hdf5 node\n        attributes_.\n\n        .. _attributes: http://pytables.github.io/usersguide/libref/declarative_classes.html#the-attributeset-class", "id": "f4236:c1:m1"}
{"signature": "def check_log_config(self):", "body": "if self.report_progress:<EOL><INDENT>if self.report_progress is True:<EOL><INDENT>self.report_progress = (<NUM_LIT:5>, '<STR_LIT>', logging.INFO)<EOL><DEDENT>elif isinstance(self.report_progress, (int, float)):<EOL><INDENT>self.report_progress = (self.report_progress, '<STR_LIT>', logging.INFO)<EOL><DEDENT>elif isinstance(self.report_progress, str):<EOL><INDENT>self.report_progress = (<NUM_LIT:5>, self.report_progress, logging.INFO)<EOL><DEDENT>elif len(self.report_progress) == <NUM_LIT:2>:<EOL><INDENT>self.report_progress = (self.report_progress[<NUM_LIT:0>], self.report_progress[<NUM_LIT:1>],<EOL>logging.INFO)<EOL><DEDENT><DEDENT>if self.log_config:<EOL><INDENT>if self.log_config == pypetconstants.DEFAULT_LOGGING:<EOL><INDENT>pypet_path = os.path.abspath(os.path.dirname(__file__))<EOL>init_path = os.path.join(pypet_path, '<STR_LIT>')<EOL>self.log_config = os.path.join(init_path, '<STR_LIT>')<EOL><DEDENT>if isinstance(self.log_config, str):<EOL><INDENT>if not os.path.isfile(self.log_config):<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>' % self.log_config)<EOL><DEDENT>parser = NoInterpolationParser()<EOL>parser.read(self.log_config)<EOL><DEDENT>elif isinstance(self.log_config, cp.RawConfigParser):<EOL><INDENT>parser = self.log_config<EOL><DEDENT>else:<EOL><INDENT>parser = None<EOL><DEDENT>if parser is not None:<EOL><INDENT>self._sp_config = self._parser_to_string_io(parser)<EOL>self._mp_config = self._find_multiproc_options(parser)<EOL>if self._mp_config is not None:<EOL><INDENT>self._mp_config = self._parser_to_string_io(self._mp_config)<EOL><DEDENT><DEDENT>elif isinstance(self.log_config, dict):<EOL><INDENT>self._sp_config = self.log_config<EOL>self._mp_config = self._find_multiproc_dict(self._sp_config)<EOL><DEDENT><DEDENT>if self.log_stdout:<EOL><INDENT>if self.log_stdout is True:<EOL><INDENT>self.log_stdout = ('<STR_LIT>', logging.INFO)<EOL><DEDENT>if isinstance(self.log_stdout, str):<EOL><INDENT>self.log_stdout = (self.log_stdout, logging.INFO)<EOL><DEDENT>if isinstance(self.log_stdout, int):<EOL><INDENT>self.log_stdout = ('<STR_LIT>', self.log_stdout)<EOL><DEDENT><DEDENT>", "docstring": "Checks and converts all settings if necessary passed to the Manager.\n\n        Searches for multiprocessing options as well.", "id": "f4237:c1:m11"}
{"signature": "def make_logging_handlers_and_tools(self, multiproc=False):", "body": "log_stdout = self.log_stdout<EOL>if sys.stdout is self._stdout_to_logger:<EOL><INDENT>log_stdout = False<EOL><DEDENT>if self.log_config:<EOL><INDENT>if multiproc:<EOL><INDENT>proc_log_config = self._mp_config<EOL><DEDENT>else:<EOL><INDENT>proc_log_config = self._sp_config<EOL><DEDENT>if proc_log_config:<EOL><INDENT>if isinstance(proc_log_config, dict):<EOL><INDENT>new_dict = self._handle_dict_config(proc_log_config)<EOL>dictConfig(new_dict)<EOL><DEDENT>else:<EOL><INDENT>parser = self._handle_config_parsing(proc_log_config)<EOL>memory_file = self._parser_to_string_io(parser)<EOL>fileConfig(memory_file, disable_existing_loggers=False)<EOL><DEDENT><DEDENT><DEDENT>if log_stdout:<EOL><INDENT>std_name, std_level = self.log_stdout<EOL>stdout = StdoutToLogger(std_name, log_level=std_level)<EOL>stdout.start()<EOL>self._tools.append(stdout)<EOL><DEDENT>", "docstring": "Creates logging handlers and redirects stdout.", "id": "f4237:c1:m14"}
{"signature": "def _change_logging_kwargs(kwargs):", "body": "log_levels = kwargs.pop('<STR_LIT>', None)<EOL>log_folder = kwargs.pop('<STR_LIT>', '<STR_LIT>')<EOL>logger_names = kwargs.pop('<STR_LIT>', '<STR_LIT>')<EOL>if log_levels is None:<EOL><INDENT>log_levels = kwargs.pop('<STR_LIT>', logging.INFO)<EOL><DEDENT>log_multiproc = kwargs.pop('<STR_LIT>', True)<EOL>if not isinstance(logger_names, (tuple, list)):<EOL><INDENT>logger_names = [logger_names]<EOL><DEDENT>if not isinstance(log_levels, (tuple, list)):<EOL><INDENT>log_levels = [log_levels]<EOL><DEDENT>if len(log_levels) == <NUM_LIT:1>:<EOL><INDENT>log_levels = [log_levels[<NUM_LIT:0>] for _ in logger_names]<EOL><DEDENT>dictionary = copy.deepcopy(LOGGING_DICT)<EOL>prefixes = ['<STR_LIT>']<EOL>if not log_multiproc:<EOL><INDENT>for key in list(dictionary.keys()):<EOL><INDENT>if key.startswith('<STR_LIT>'):<EOL><INDENT>del dictionary[key]<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>prefixes.append('<STR_LIT>')<EOL><DEDENT>for prefix in prefixes:<EOL><INDENT>for handler_dict in dictionary[prefix + '<STR_LIT>'].values():<EOL><INDENT>if '<STR_LIT:filename>' in handler_dict:<EOL><INDENT>filename = os.path.join(log_folder, handler_dict['<STR_LIT:filename>'])<EOL>filename = os.path.normpath(filename)<EOL>handler_dict['<STR_LIT:filename>'] = filename<EOL><DEDENT><DEDENT>dictionary[prefix + '<STR_LIT>'] = {}<EOL>logger_dict = dictionary[prefix + '<STR_LIT>']<EOL>for idx, logger_name in enumerate(logger_names):<EOL><INDENT>logger_dict[logger_name] = {<EOL>'<STR_LIT>': log_levels[idx],<EOL>'<STR_LIT>': list(dictionary[prefix + '<STR_LIT>'].keys())<EOL>}<EOL><DEDENT><DEDENT>kwargs['<STR_LIT>'] = dictionary<EOL>", "docstring": "Helper function to turn the simple logging kwargs into a `log_config`.", "id": "f4237:m0"}
{"signature": "def flush(self):", "body": "pass<EOL>", "docstring": "No-op to fulfil API", "id": "f4237:c4:m4"}
{"signature": "def finalize(self):", "body": "if self._original_steam is not None and self._redirection:<EOL><INDENT>sys.stdout = self._original_steam<EOL>print('<STR_LIT>')<EOL>self._redirection = False<EOL>self._original_steam = None<EOL><DEDENT>", "docstring": "Disables redirection", "id": "f4237:c4:m5"}
{"signature": "def simple_logging_config(func):", "body": "@functools.wraps(func)<EOL>def new_func(self, *args, **kwargs):<EOL><INDENT>if use_simple_logging(kwargs):<EOL><INDENT>if '<STR_LIT>' in kwargs:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>_change_logging_kwargs(kwargs)<EOL><DEDENT>return func(self, *args, **kwargs)<EOL><DEDENT>return new_func<EOL>", "docstring": "Decorator to allow a simple logging configuration.\n\n    This encompasses giving a `log_folder`, `logger_names` as well as `log_levels`.", "id": "f4237:m2"}
{"signature": "def show_progress(self, n, total_runs):", "body": "if self.report_progress:<EOL><INDENT>percentage, logger_name, log_level = self.report_progress<EOL>if logger_name == '<STR_LIT>':<EOL><INDENT>logger = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>logger = logging.getLogger(logger_name)<EOL><DEDENT>if n == -<NUM_LIT:1>:<EOL><INDENT>digits = int(math.log10(total_runs + <NUM_LIT:0.1>)) + <NUM_LIT:1><EOL>self._format_string = '<STR_LIT>' + '<STR_LIT>' % digits + '<STR_LIT>'<EOL><DEDENT>fmt_string = self._format_string % (n + <NUM_LIT:1>, total_runs) + '<STR_LIT:%s>'<EOL>reprint = log_level == <NUM_LIT:0><EOL>progressbar(n, total_runs, percentage_step=percentage,<EOL>logger=logger, log_level=log_level,<EOL>fmt_string=fmt_string, reprint=reprint)<EOL><DEDENT>", "docstring": "Displays a progressbar", "id": "f4237:c1:m3"}
{"signature": "@staticmethod<EOL><INDENT>def _parser_to_string_io(parser):<DEDENT>", "body": "memory_file = StringIO()<EOL>parser.write(memory_file)<EOL>memory_file.flush()<EOL>memory_file.seek(<NUM_LIT:0>)<EOL>return memory_file<EOL>", "docstring": "Turns a ConfigParser into a StringIO stream.", "id": "f4237:c1:m8"}
{"signature": "@property<EOL><INDENT>def v_standard_result(self):<DEDENT>", "body": "return self._standard_result<EOL>", "docstring": "The standard result class used for result creation", "id": "f4238:c0:m92"}
{"signature": "@v_idx.setter<EOL><INDENT>@not_in_run<EOL>def v_idx(self, idx):<DEDENT>", "body": "self.f_set_crun(idx)<EOL>", "docstring": "Changes the index to make the trajectory behave as a single run", "id": "f4238:c0:m15"}
{"signature": "@property<EOL><INDENT>def v_with_links(self):<DEDENT>", "body": "return self._with_links<EOL>", "docstring": "Whether links should be considered in case using natural naming\n        or squared bracket indexing", "id": "f4238:c0:m21"}
{"signature": "def _merge_links(self, other_trajectory, used_runs, allowed_translations, ignore_data):", "body": "linked_items = other_trajectory._linked_by<EOL>run_name_dummys = set([f(-<NUM_LIT:1>) for f in other_trajectory._wildcard_functions.values()])<EOL>if len(linked_items) > <NUM_LIT:0>:<EOL><INDENT>self._logger.info('<STR_LIT>')<EOL>for old_linked_name in other_trajectory._linked_by:<EOL><INDENT>if old_linked_name in ignore_data:<EOL><INDENT>continue<EOL><DEDENT>split_name = old_linked_name.split('<STR_LIT:.>')<EOL>if any(x in run_name_dummys for x in split_name):<EOL><INDENT>self._logger.warning('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(old_linked_name, str(run_name_dummys)))<EOL>continue<EOL><DEDENT>old_link_dict = other_trajectory._linked_by[old_linked_name]<EOL>split_name = old_linked_name.split('<STR_LIT:.>')<EOL>if all(x in allowed_translations for x in split_name):<EOL><INDENT>new_linked_full_name = self._rename_full_name(old_linked_name,<EOL>other_trajectory,<EOL>used_runs=used_runs)<EOL><DEDENT>else:<EOL><INDENT>new_linked_full_name = old_linked_name<EOL><DEDENT>for linking_node, link_set in old_link_dict.values():<EOL><INDENT>linking_full_name = linking_node.v_full_name<EOL>split_name = linking_full_name .split('<STR_LIT:.>')<EOL>if any(x in run_name_dummys for x in split_name):<EOL><INDENT>self._logger.warning('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(linking_full_name, str(run_name_dummys)))<EOL><DEDENT>split_name = linking_full_name .split('<STR_LIT:.>')<EOL>if any(x in allowed_translations for x in split_name):<EOL><INDENT>new_linking_full_name = self._rename_full_name(linking_full_name,<EOL>other_trajectory,<EOL>used_runs=used_runs)<EOL><DEDENT>else:<EOL><INDENT>new_linking_full_name = linking_full_name<EOL><DEDENT>for link in link_set:<EOL><INDENT>if (linking_full_name + '<STR_LIT:.>' + link) in ignore_data:<EOL><INDENT>continue<EOL><DEDENT>if link in run_name_dummys:<EOL><INDENT>self._logger.warning('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(link,<EOL>linking_full_name,<EOL>str(run_name_dummys)))<EOL>continue<EOL><DEDENT>try:<EOL><INDENT>new_linked_item = self.f_get(new_linked_full_name,<EOL>shortcuts=False)<EOL>if self.f_contains(new_linking_full_name):<EOL><INDENT>new_linking_item = self.f_get(new_linking_full_name,<EOL>shortcuts=False)<EOL><DEDENT>else:<EOL><INDENT>new_linking_item =  self.f_add_group(new_linking_full_name)<EOL><DEDENT>if link in allowed_translations:<EOL><INDENT>run_indices, wildcards = other_trajectory._reversed_wildcards[link]<EOL>link = self.f_wildcard(wildcards[<NUM_LIT:0>], used_runs[run_indices[<NUM_LIT:0>]])<EOL><DEDENT>if not link in new_linking_item._links:<EOL><INDENT>new_linking_item.f_add_link(link, new_linked_item)<EOL><DEDENT>else:<EOL><INDENT>self._logger.debug('<STR_LIT>' %<EOL>(link, new_linked_item.v_full_name))<EOL><DEDENT><DEDENT>except (AttributeError, ValueError) as exc:<EOL><INDENT>self._logger.error('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(link, linking_full_name, old_linked_name,<EOL>repr(exc)))<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Merges all links", "id": "f4238:c0:m58"}
{"signature": "@property<EOL><INDENT>def v_comment(self):<DEDENT>", "body": "return self._comment<EOL>", "docstring": "Should be a nice descriptive comment", "id": "f4238:c0:m9"}
{"signature": "def _preset(self, name, args, kwargs):", "body": "if self.f_contains(name, shortcuts=False):<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>' % name)<EOL><DEDENT>else:<EOL><INDENT>self._changed_default_parameters[name] = (args, kwargs)<EOL><DEDENT>", "docstring": "Generic preset function, marks a parameter or config for presetting.", "id": "f4238:c0:m28"}
{"signature": "def __copy__(self):", "body": "return self.f_copy(copy_leaves=True,<EOL>with_links=True)<EOL>", "docstring": "Returns a shallow copy", "id": "f4238:c0:m39"}
{"signature": "@v_comment.setter<EOL><INDENT>@not_in_run<EOL>def v_comment(self, comment):<DEDENT>", "body": "comment = str(comment)<EOL>self._comment = comment<EOL>", "docstring": "Sets the comment", "id": "f4238:c0:m10"}
{"signature": "def _check_if_both_have_same_parameters(self, other_trajectory,<EOL>ignore_data, consecutive_merge):", "body": "if not isinstance(other_trajectory, Trajectory):<EOL><INDENT>raise TypeError('<STR_LIT>'<EOL>'<STR_LIT>' % str(type(other_trajectory)))<EOL><DEDENT>if self._stored and not consecutive_merge:<EOL><INDENT>self.f_load_skeleton()<EOL><DEDENT>if other_trajectory._stored:<EOL><INDENT>other_trajectory.f_load_skeleton()<EOL><DEDENT>other_wildcard_set = set(x[<NUM_LIT:1>] for x in other_trajectory._wildcard_functions.keys())<EOL>wildcard_set = set(x[<NUM_LIT:1>] for x in self._wildcard_functions.keys())<EOL>diff = wildcard_set.symmetric_difference(other_wildcard_set)<EOL>if diff:<EOL><INDENT>raise TypeError('<STR_LIT>' %<EOL>(str(wildcard_set), str(other_wildcard_set)))<EOL><DEDENT>if self._stored:<EOL><INDENT>with self._nn_interface._disable_logging:<EOL><INDENT>self.f_load_items(self._parameters.keys(), only_empties=True)<EOL><DEDENT><DEDENT>if other_trajectory._stored:<EOL><INDENT>with self._nn_interface._disable_logging:<EOL><INDENT>other_trajectory.f_load_items(other_trajectory._parameters.keys(),<EOL>only_empties=True)<EOL><DEDENT><DEDENT>self.f_restore_default()<EOL>other_trajectory.f_restore_default()<EOL>allmyparams = self._parameters.copy()<EOL>allotherparams = other_trajectory._parameters.copy()<EOL>if '<STR_LIT>' in self:<EOL><INDENT>my_traj_dpars = self._derived_parameters<EOL>if self._stored:<EOL><INDENT>with self._nn_interface._disable_logging:<EOL><INDENT>self.f_load_items(my_traj_dpars.keys(), only_empties=True)<EOL><DEDENT><DEDENT>allmyparams.update(my_traj_dpars)<EOL>other_traj_dpars = other_trajectory._derived_parameters<EOL>if other_trajectory._stored:<EOL><INDENT>with self._nn_interface._disable_logging:<EOL><INDENT>other_trajectory.f_load_items(other_traj_dpars.keys(), only_empties=True)<EOL><DEDENT><DEDENT>allotherparams.update(other_traj_dpars)<EOL><DEDENT>my_keyset = set(allmyparams.keys())<EOL>other_keyset = set(allotherparams.keys())<EOL>diff = my_keyset.symmetric_difference(other_keyset) - ignore_data<EOL>run_dummys = (self.f_wildcard('<STR_LIT:$>', -<NUM_LIT:1>), other_trajectory.f_wildcard('<STR_LIT:$>', -<NUM_LIT:1>))<EOL>if diff:<EOL><INDENT>run_difference_can_be_resolved = True<EOL>for full_name in diff:<EOL><INDENT>split_name = full_name.split('<STR_LIT:.>')<EOL>if not any(x in self._run_information or<EOL>x in other_trajectory._run_information or<EOL>x in run_dummys<EOL>for x in split_name):<EOL><INDENT>run_difference_can_be_resolved = False<EOL>break<EOL><DEDENT>elif full_name in allotherparams:<EOL><INDENT>del allotherparams[full_name]<EOL><DEDENT><DEDENT>if not run_difference_can_be_resolved:<EOL><INDENT>raise TypeError('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % str(diff))<EOL><DEDENT><DEDENT>for key, other_param in allotherparams.items():<EOL><INDENT>if key in ignore_data:<EOL><INDENT>continue<EOL><DEDENT>my_param = self.f_get(key)<EOL>split_key = key.split('<STR_LIT:.>')<EOL>if any(x in self._run_information or<EOL>x in other_trajectory._run_information<EOL>for x in split_key):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>if not my_param._values_of_same_type(my_param.f_get(), other_param.f_get()):<EOL><INDENT>raise TypeError('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(key, str(type(my_param.f_get())),<EOL>str(type(other_param.f_get()))))<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Checks if two trajectories live in the same space and can be merged.", "id": "f4238:c0:m50"}
{"signature": "def f_get_wildcards(self):", "body": "return list(self._wildcard_keys.keys())<EOL>", "docstring": "Returns a list of all defined wildcards", "id": "f4238:c0:m1"}
{"signature": "@not_in_run<EOL><INDENT>def f_restore_default(self):<DEDENT>", "body": "self._idx = -<NUM_LIT:1><EOL>self._crun = None<EOL>for param in self._explored_parameters.values():<EOL><INDENT>if param is not None:<EOL><INDENT>param._restore_default()<EOL><DEDENT><DEDENT>", "docstring": "Restores the default value in all explored parameters and sets the\n        v_idx property back to -1 and v_crun to None.", "id": "f4238:c0:m66"}
{"signature": "@not_in_run<EOL><INDENT>def f_shrink(self, force=False):<DEDENT>", "body": "if self._stored and not force:<EOL><INDENT>raise TypeError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>for param in self._explored_parameters.values():<EOL><INDENT>param.f_unlock()<EOL>try:<EOL><INDENT>param._shrink()<EOL><DEDENT>except Exception as exc:<EOL><INDENT>self._logger.error('<STR_LIT>' %<EOL>(param.v_full_name, repr(exc)))<EOL><DEDENT><DEDENT>self._explored_parameters = {}<EOL>self._run_information = {}<EOL>self._single_run_ids = {}<EOL>self._add_run_info(<NUM_LIT:0>)<EOL>self._test_run_addition(<NUM_LIT:1>)<EOL>", "docstring": "Shrinks the trajectory and removes all exploration ranges from the parameters.\n        Only possible if the trajectory has not been stored to disk before or was loaded as new.\n\n        :param force:\n\n            Usually you cannot shrink the trajectory if it has been stored to disk,\n            because there's no guarantee that it is actually shrunk if there\n            still exist explored parameters on disk. In case you are certain that\n            you did not store explored parameters to disk set or you deleted all\n            of them from disk set `force=True`.\n\n        :raises: TypeError if the trajectory was stored before.", "id": "f4238:c0:m27"}
{"signature": "def f_delete_link(self, link, remove_from_trajectory=False):", "body": "self.f_delete_links((link,), remove_from_trajectory)<EOL>", "docstring": "Deletes a single link see :func:`~pypet.trajectory.Trajectory.f_delete_links`", "id": "f4238:c0:m118"}
{"signature": "def _merge_parameters(self, other_trajectory, remove_duplicates=False,<EOL>trial_parameter_name=None,<EOL>ignore_data=()):", "body": "if trial_parameter_name:<EOL><INDENT>if remove_duplicates:<EOL><INDENT>self._logger.warning('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>remove_duplicates = False<EOL><DEDENT><DEDENT>params_to_change = {}<EOL>if trial_parameter_name:<EOL><INDENT>my_trial_parameter = self.f_get(trial_parameter_name)<EOL>other_trial_parameter = other_trajectory.f_get(trial_parameter_name)<EOL>if not isinstance(my_trial_parameter, BaseParameter):<EOL><INDENT>raise TypeError('<STR_LIT>'<EOL>'<STR_LIT>' % trial_parameter_name)<EOL><DEDENT>if my_trial_parameter.f_has_range():<EOL><INDENT>my_trial_list = my_trial_parameter.f_get_range(copy=False)<EOL><DEDENT>else:<EOL><INDENT>my_trial_list = [my_trial_parameter.f_get()]<EOL><DEDENT>if other_trial_parameter.f_has_range():<EOL><INDENT>other_trial_list = other_trial_parameter.f_get_range(copy=False)<EOL><DEDENT>else:<EOL><INDENT>other_trial_list = [other_trial_parameter.f_get()]<EOL><DEDENT>mytrialset = set(my_trial_list)<EOL>mymaxtrial_T1 = max(mytrialset)  <EOL>if mytrialset != set(range(mymaxtrial_T1 + <NUM_LIT:1>)):<EOL><INDENT>raise TypeError('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % (mymaxtrial_T1, str(mytrialset)))<EOL><DEDENT>othertrialset = set(other_trial_list)<EOL>othermaxtrial_T2 = max(othertrialset)  <EOL>if othertrialset != set(range(othermaxtrial_T2 + <NUM_LIT:1>)):<EOL><INDENT>raise TypeError('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(othermaxtrial_T2, str(othertrialset)))<EOL><DEDENT>trial_parameter_name = my_trial_parameter.v_full_name<EOL>if not trial_parameter_name in self._explored_parameters:<EOL><INDENT>self._explored_parameters[trial_parameter_name] = my_trial_parameter<EOL><DEDENT>params_to_change[trial_parameter_name] = (my_trial_parameter, other_trial_parameter)<EOL><DEDENT>params_to_merge = other_trajectory._parameters.copy()<EOL>params_to_merge.update(other_trajectory._derived_parameters)<EOL>for ignore in ignore_data:<EOL><INDENT>if ignore in params_to_merge:<EOL><INDENT>del params_to_merge[ignore]<EOL><DEDENT><DEDENT>run_name_dummys = set([f(-<NUM_LIT:1>) for f in other_trajectory._wildcard_functions.values()])<EOL>for key in params_to_merge:<EOL><INDENT>other_param = params_to_merge[key]<EOL>split_key = key.split('<STR_LIT:.>')<EOL>if any(x in other_trajectory._reversed_wildcards for x in split_key):<EOL><INDENT>continue<EOL><DEDENT>my_param = self.f_get(key)<EOL>if not my_param._values_of_same_type(my_param.f_get(), other_param.f_get()):<EOL><INDENT>raise TypeError('<STR_LIT>'<EOL>'<STR_LIT>' % key)<EOL><DEDENT>if my_param.v_full_name == trial_parameter_name:<EOL><INDENT>continue<EOL><DEDENT>if (my_param.f_has_range() or<EOL>other_param.f_has_range() or<EOL>not my_param._equal_values(my_param.f_get(), other_param.f_get())):<EOL><INDENT>params_to_change[key] = (my_param, other_param)<EOL>if not my_param.f_has_range() and not other_param.f_has_range():<EOL><INDENT>remove_duplicates = False<EOL><DEDENT><DEDENT><DEDENT>used_runs = {}<EOL>for idx in range(len(other_trajectory)):<EOL><INDENT>used_runs[idx] = idx<EOL><DEDENT>if remove_duplicates:<EOL><INDENT>for irun in range(len(other_trajectory)):<EOL><INDENT>for jrun in range(len(self)):<EOL><INDENT>change = True<EOL>for my_param, other_param in params_to_change.values():<EOL><INDENT>if other_param.f_has_range():<EOL><INDENT>other_param._set_parameter_access(irun)<EOL><DEDENT>if my_param.f_has_range():<EOL><INDENT>my_param._set_parameter_access(jrun)<EOL><DEDENT>val1 = my_param.f_get()<EOL>val2 = other_param.f_get()<EOL>if not my_param._equal_values(val1, val2):<EOL><INDENT>change = False<EOL>break<EOL><DEDENT><DEDENT>if change:<EOL><INDENT>del used_runs[irun]<EOL>break<EOL><DEDENT><DEDENT><DEDENT>for my_param, other_param in params_to_change.values():<EOL><INDENT>other_param._restore_default()<EOL>my_param._restore_default()<EOL><DEDENT><DEDENT>adding_length = len(used_runs)<EOL>starting_length = len(self)<EOL>if adding_length == <NUM_LIT:0>:<EOL><INDENT>return used_runs, []<EOL><DEDENT>count = <NUM_LIT:0><EOL>for key in sorted(used_runs.keys()):<EOL><INDENT>used_runs[key] = starting_length + count<EOL>count += <NUM_LIT:1><EOL><DEDENT>for my_param, other_param in params_to_change.values():<EOL><INDENT>fullname = my_param.v_full_name<EOL>if fullname == trial_parameter_name:<EOL><INDENT>other_range = [x + mymaxtrial_T1 + <NUM_LIT:1> for x in other_trial_list]<EOL><DEDENT>else:<EOL><INDENT>if other_param.f_has_range():<EOL><INDENT>other_range = (x for jdx, x in enumerate(other_param.f_get_range(copy=False))<EOL>if jdx in used_runs)<EOL><DEDENT>else:<EOL><INDENT>other_range = (other_param.f_get() for _ in range(adding_length))<EOL><DEDENT><DEDENT>if not my_param.f_has_range():<EOL><INDENT>my_param.f_unlock()<EOL>my_param._explore((my_param.f_get() for _ in  range(len(self))))<EOL><DEDENT>my_param.f_unlock()<EOL>my_param._expand(other_range)<EOL>if not fullname in self._explored_parameters:<EOL><INDENT>self._explored_parameters[fullname] = my_param<EOL><DEDENT><DEDENT>return used_runs, list(params_to_change.keys())<EOL>", "docstring": "Merges parameters from the other trajectory into the current one.\n\n        The explored parameters in the current trajectory are directly enlarged (in RAM),\n        no storage service is needed here. Later on in `f_merge` the storage service\n        will be requested to store the enlarge parameters to disk.\n\n        Note explored parameters are always enlarged. Unexplored parameters might become\n        new explored parameters if they differ in their default values\n        in the current and the other trajectory, respectively.\n\n        :return: A tuple with two elements:\n\n            1.\n\n                Dictionary of run index mappings from old trajectroy to the new one.\n\n            2.\n\n                List of names of parameters that were altered.", "id": "f4238:c0:m62"}
{"signature": "def f_store_items(self, iterator, *args, **kwargs):", "body": "if not self._stored:<EOL><INDENT>raise TypeError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>fetched_items = self._nn_interface._fetch_items(STORE, iterator, args, kwargs)<EOL>if fetched_items:<EOL><INDENT>self._storage_service.store(pypetconstants.LIST, fetched_items,<EOL>trajectory_name=self.v_name)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>", "docstring": "Stores individual items to disk.\n\n        This function is useful if you calculated very large results (or large derived parameters)\n        during runtime and you want to write these to disk immediately and empty them afterwards\n        to free some memory.\n\n        Instead of storing individual parameters or results you can also store whole subtrees with\n        :func:`~pypet.naturalnaming.NNGroupNode.f_store_child`.\n\n\n        You can pass the following arguments to `f_store_items`:\n\n        :param iterator:\n\n            An iterable containing the parameters or results to store, either their\n            names or the instances. You can also pass group instances or names here\n            to store the annotations of the groups.\n\n        :param non_empties:\n\n            Optional keyword argument (boolean),\n            if `True` will only store the subset of provided items that are not empty.\n            Empty parameters or results found in `iterator` are simply ignored.\n\n        :param args: Additional arguments passed to the storage service\n\n        :param kwargs:\n\n            If you use the standard hdf5 storage service, you can pass the following additional\n            keyword argument:\n\n            :param overwrite:\n\n                List names of parts of your item that should\n                be erased and overwritten by the new data in your leaf.\n                You can also set `overwrite=True`\n                to overwrite all parts.\n\n                For instance:\n\n                    >>> traj.f_add_result('mygroup.myresult', partA=42, partB=44, partC=46)\n                    >>> traj.f_store()\n                    >>> traj.mygroup.myresult.partA = 333\n                    >>> traj.mygroup.myresult.partB = 'I am going to change to a string'\n                    >>> traj.f_store_item('mygroup.myresult', overwrite=['partA', 'partB'])\n\n                Will store `'mygroup.myresult'` to disk again and overwrite the parts\n                `'partA'` and `'partB'` with the new values `333` and\n                `'I am going to change to a string'`.\n                The data stored as `partC` is not changed.\n\n                Be aware that you need to specify the names of parts as they were stored\n                to HDF5. Depending on how your leaf construction works, this may differ\n                from the names the data might have in your leaf in the trajectory container.\n\n                Note that massive overwriting will fragment and blow up your HDF5 file.\n                Try to avoid changing data on disk whenever you can.\n\n        :raises:\n\n            TypeError:\n\n                If the (parent) trajectory has never been stored to disk. In this case\n                use :func:`pypet.trajectory.f_store` first.\n\n            ValueError: If no item could be found to be stored.\n\n        Note if you use the standard hdf5 storage service, there are no additional arguments\n        or keyword arguments to pass!", "id": "f4238:c0:m113"}
{"signature": "@property<EOL><INDENT>def v_storage_service(self):<DEDENT>", "body": "return self._storage_service<EOL>", "docstring": "The service that can store the trajectory to disk or wherever.\n\n        Default is None or if a filename was provided on construction\n        the :class:`~pypet.storageservice.HDF5StorageService`.", "id": "f4238:c0:m11"}
{"signature": "@property<EOL><INDENT>def v_standard_parameter(self):<DEDENT>", "body": "return self._standard_parameter<EOL>", "docstring": "The standard parameter used for parameter creation", "id": "f4238:c0:m90"}
{"signature": "def f_add_wildcard_functions(self, func_dict):", "body": "for wildcards, function in func_dict.items():<EOL><INDENT>if not isinstance(wildcards, tuple):<EOL><INDENT>wildcards = (wildcards,)<EOL><DEDENT>for wildcard in wildcards:<EOL><INDENT>if wildcard in self._wildcard_keys:<EOL><INDENT>raise ValueError('<STR_LIT>' % wildcard)<EOL><DEDENT>self._wildcard_keys[wildcard] = wildcards<EOL><DEDENT>self._wildcard_functions[wildcards] = function<EOL>self._logger.debug('<STR_LIT>' % str(wildcards))<EOL><DEDENT>", "docstring": "TODO", "id": "f4238:c0:m3"}
{"signature": "def _make_reversed_wildcards(self, old_length=-<NUM_LIT:1>):", "body": "if len(self._reversed_wildcards) > <NUM_LIT:0>:<EOL><INDENT>start = old_length<EOL><DEDENT>else:<EOL><INDENT>start = -<NUM_LIT:1><EOL><DEDENT>for wildcards, func in self._wildcard_functions.items():<EOL><INDENT>for irun in range(start, len(self)):<EOL><INDENT>translated_name = func(irun)<EOL>if not translated_name in self._reversed_wildcards:<EOL><INDENT>self._reversed_wildcards[translated_name] = ([], wildcards)<EOL><DEDENT>self._reversed_wildcards[translated_name][<NUM_LIT:0>].append(irun)<EOL><DEDENT><DEDENT>", "docstring": "Creates a full mapping from all wildcard translations to the corresponding wildcards", "id": "f4238:c0:m52"}
{"signature": "def _set_start(self):", "body": "init_time = time.time()<EOL>formatted_time = datetime.datetime.fromtimestamp(init_time).strftime('<STR_LIT>')<EOL>run_info_dict = self._run_information[self.v_crun]<EOL>run_info_dict['<STR_LIT>'] = init_time<EOL>run_info_dict['<STR_LIT:time>'] = formatted_time<EOL>if self._environment_hexsha is not None:<EOL><INDENT>run_info_dict['<STR_LIT>'] = self._environment_hexsha[<NUM_LIT:0>:<NUM_LIT:7>]<EOL><DEDENT>", "docstring": "Sets the start timestamp and formatted time to the current time.", "id": "f4238:c0:m75"}
{"signature": "@not_in_run<EOL><INDENT>def f_explore(self, build_dict):<DEDENT>", "body": "for run_idx in range(len(self)):<EOL><INDENT>if self.f_is_completed(run_idx):<EOL><INDENT>raise TypeError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>added_explored_parameters = []<EOL>try:<EOL><INDENT>length = len(self)<EOL>for key, builditerable in build_dict.items():<EOL><INDENT>act_param = self.f_get(key)<EOL>if not act_param.v_is_leaf or not act_param.v_is_parameter:<EOL><INDENT>raise ValueError('<STR_LIT>' % key)<EOL><DEDENT>act_param.f_unlock()<EOL>act_param._explore(builditerable)<EOL>added_explored_parameters.append(act_param)<EOL>full_name = act_param.v_full_name<EOL>self._explored_parameters[full_name] = act_param<EOL>act_param._explored = True<EOL>if len(self._explored_parameters) == <NUM_LIT:1>:<EOL><INDENT>length = act_param.f_get_range_length()<EOL><DEDENT>elif not length == act_param.f_get_range_length():<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>for irun in range(length):<EOL><INDENT>self._add_run_info(irun)<EOL><DEDENT>self._test_run_addition(length)<EOL><DEDENT>except Exception:<EOL><INDENT>for param in added_explored_parameters:<EOL><INDENT>param.f_unlock()<EOL>param._shrink()<EOL>param._explored = False<EOL>full_name = param.v_full_name<EOL>del self._explored_parameters[full_name]<EOL><DEDENT>if len(self._explored_parameters) == <NUM_LIT:0>:<EOL><INDENT>self.f_shrink(force=True)<EOL><DEDENT>raise<EOL><DEDENT>", "docstring": "Prepares the trajectory to explore the parameter space.\n\n\n        To explore the parameter space you need to provide a dictionary with the names of the\n        parameters to explore as keys and iterables specifying the exploration ranges as values.\n\n        All iterables need to have the same length otherwise a ValueError is raised.\n        A ValueError is also raised if the names from the dictionary map to groups or results\n        and not parameters.\n\n        If your trajectory is already explored but not stored yet and your parameters are\n        not locked you can add new explored parameters to the current ones if their\n        iterables match the current length of the trajectory.\n\n        Raises an AttributeError if the names from the dictionary are not found at all in\n        the trajectory and NotUniqueNodeError if the keys not unambiguously map\n        to single parameters.\n\n        Raises a TypeError if the trajectory has been stored already, please use\n        :func:`~pypet.trajectory.Trajectory.f_expand` then instead.\n\n        Example usage:\n\n        >>> traj.f_explore({'groupA.param1' : [1,2,3,4,5], 'groupA.param2':['a','b','c','d','e']})\n\n        Could also be called consecutively:\n\n        >>> traj.f_explore({'groupA.param1' : [1,2,3,4,5]})\n        >>> traj.f_explore({'groupA.param2':['a','b','c','d','e']})\n\n        NOTE:\n\n        Since parameters are very conservative regarding the data they accept\n        (see :ref:`type_conservation`), you sometimes won't be able to use Numpy arrays\n        for exploration as iterables.\n\n        For instance, the following code snippet won't work:\n\n        ::\n\n            import numpy a np\n            from pypet.trajectory import Trajectory\n            traj = Trajectory()\n            traj.f_add_parameter('my_float_parameter', 42.4,\n                                 comment='My value is a standard python float')\n\n            traj.f_explore( { 'my_float_parameter': np.arange(42.0, 44.876, 0.23) } )\n\n\n        This will result in a `TypeError` because your exploration iterable\n        `np.arange(42.0, 44.876, 0.23)` contains `numpy.float64` values\n        whereas you parameter is supposed to use standard python floats.\n\n        Yet, you can use Numpys `tolist()` function to overcome this problem:\n\n        ::\n\n            traj.f_explore( { 'my_float_parameter': np.arange(42.0, 44.876, 0.23).tolist() } )\n\n\n        Or you could specify your parameter directly as a numpy float:\n\n        ::\n\n            traj.f_add_parameter('my_float_parameter', np.float64(42.4),\n                                   comment='My value is a numpy 64 bit float')", "id": "f4238:c0:m42"}
{"signature": "def f_find_idx(self, name_list, predicate):", "body": "if self._is_run and not self.v_full_copy:<EOL><INDENT>raise TypeError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>if isinstance(name_list, str):<EOL><INDENT>name_list = [name_list]<EOL><DEDENT>iter_list = []<EOL>for name in name_list:<EOL><INDENT>param = self.f_get(name)<EOL>if not param.v_is_parameter:<EOL><INDENT>raise TypeError('<STR_LIT>' %<EOL>(name, str(type(param))))<EOL><DEDENT>if param.f_has_range():<EOL><INDENT>iter_list.append(iter(param.f_get_range(copy=False)))<EOL><DEDENT>else:<EOL><INDENT>iter_list.append(itools.repeat(param.f_get(), len(self)))<EOL><DEDENT><DEDENT>logic_iter = map(predicate, *iter_list)<EOL>for idx, item in enumerate(logic_iter):<EOL><INDENT>if item:<EOL><INDENT>yield idx<EOL><DEDENT><DEDENT>", "docstring": "Finds a single run index given a particular condition on parameters.\n\n        ONLY useful for a single run if ``v_full_copy` was set to ``True``.\n        Otherwise a TypeError is thrown.\n\n        :param name_list:\n\n            A list of parameter names the predicate applies to, if you have only a single\n            parameter name you can omit the list brackets.\n\n        :param predicate:\n\n            A lambda predicate for filtering that evaluates to either ``True`` or  ``False``\n\n        :return: A generator yielding the matching single run indices\n\n        Example:\n\n        >>> predicate = lambda param1, param2: param1==4 and param2 in [1.0, 2.0]\n        >>> iterator = traj.f_find_idx(['groupA.param1', 'groupA.param2'], predicate)\n        >>> [x for x in iterator]\n        [0, 2, 17, 36]", "id": "f4238:c0:m71"}
{"signature": "@property<EOL><INDENT>def v_timestamp(self):<DEDENT>", "body": "return self._timestamp<EOL>", "docstring": "Float timestamp of creation time", "id": "f4238:c0:m88"}
{"signature": "@v_no_clobber.setter<EOL><INDENT>def v_no_clobber(self, value):<DEDENT>", "body": "self._no_clobber = bool(value)<EOL>", "docstring": "Sets no_clobber", "id": "f4238:c0:m97"}
{"signature": "@kwargs_api_change('<STR_LIT>')<EOL><INDENT>@kwargs_api_change('<STR_LIT>')<EOL>@kwargs_mutual_exclusive('<STR_LIT>', '<STR_LIT>', lambda x: not x)<EOL>def f_store(self, only_init=False, store_data=pypetconstants.STORE_DATA,<EOL>max_depth=None):<DEDENT>", "body": "if self._is_run:<EOL><INDENT>if self._new_nodes or self._new_links:<EOL><INDENT>self._storage_service.store(pypetconstants.SINGLE_RUN, self,<EOL>trajectory_name=self.v_name,<EOL>recursive=not only_init,<EOL>store_data=store_data,<EOL>max_depth=max_depth)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self._storage_service.store(pypetconstants.TRAJECTORY, self,<EOL>trajectory_name=self.v_name,<EOL>only_init=only_init,<EOL>store_data=store_data,<EOL>max_depth=max_depth)<EOL>self._stored = True<EOL><DEDENT>", "docstring": "Stores the trajectory to disk and recursively all data in the tree.\n\n        :param only_init:\n\n            If you just want to initialise the store. If yes, only meta information about\n            the trajectory is stored and none of the groups/leaves within the trajectory.\n            Alternatively, you can pass `recursive=False`.\n\n        :param store_data:\n\n            Only considered if ``only_init=False``. Choose of the following:\n\n                * :const:`pypet.pypetconstants.STORE_NOTHING`: (0)\n\n                    Nothing is store.\n\n                * :const:`pypet.pypetconstants.STORE_DATA_SKIPPING`: (1)\n\n                    Speedy version of normal ``STORE_DATA`` will entirely skip groups\n                    (but not their children) and leaves if they have been stored before.\n                    No new data is added in this case.\n\n                * :const:`pypet.pypetconstants.STORE_DATA`: (2)\n\n                    Stores every group and leave node. If they contain data that is not yet stored\n                    to disk it is added.\n\n                * :const:`pypet.pypetconstants.OVERWRITE_DATA`: (3)\n\n                    Stores all groups and leave nodes and will delete all data on disk\n                    and overwrite it with the current data in RAM.\n\n                    **NOT RECOMMENDED**! Overwriting data on disk fragments the HDF5 file and\n                    yields badly compressed large files. Better stick to the concept\n                    write once and read many!\n\n\n        If you use the HDF5 Storage Service usually (STORE_DATA (2)) only novel data\n        is stored to disk.\n        If you have results that have been stored to disk before only new data items are added and\n        already present data is NOT overwritten.\n\n        Overwriting (OVERWRITE_DATA (3)) existing data with the HDF5 storage service\n        is not recommended due to fragmentation of the HDF5 file. Better stick to the concept\n        write once, but read often.\n\n        If you want to store individual parameters or results, you might want to\n        take a look at :func:`~pypet.Trajectory.f_store_items`.\n        To store whole subtrees of your trajectory check out\n        :func:`~pypet.naturalnaming.NNGroupNode.f_store_child`.\n        Note both functions require that your trajectory was stored to disk with `f_store`\n        at least once before.\n\n\n        **ATTENTION**: Calling `f_store` during a single run the behavior is different.\n\n        To avoid re-storing the full trajectory in every single run, which is redundant,\n        only sub-trees of the trajectory are really stored.\n\n        The storage serivce looks for new data that is added below groups called `run_XXXXXXXXXX`\n        and stores it where `XXXXXXXXX` is the index of this run. The `only_init` parameter is\n        ignored in this case. You can avoid this behavior by using the argument from below.\n\n        :param max_depth:\n\n            Maximum depth to store tree (inclusive). During single runs `max_depth` is also counted\n            from root.", "id": "f4238:c0:m64"}
{"signature": "@not_in_run<EOL><INDENT>@kwargs_api_change('<STR_LIT>', '<STR_LIT>')<EOL>@kwargs_api_change('<STR_LIT>', '<STR_LIT>')<EOL>@kwargs_api_change('<STR_LIT>')<EOL>@kwargs_api_change('<STR_LIT>')<EOL>def f_merge(self, other_trajectory, trial_parameter=None, remove_duplicates=False,<EOL>ignore_data=(),<EOL>backup=True,<EOL>move_data=False,<EOL>delete_other_trajectory=False,<EOL>keep_info=True,<EOL>keep_other_trajectory_info=True,<EOL>merge_config=True,<EOL>consecutive_merge=False,<EOL>slow_merge=False):<DEDENT>", "body": "if consecutive_merge and trial_parameter is not None:<EOL><INDENT>self._logger.warning('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>if consecutive_merge and backup:<EOL><INDENT>self._logger.warning('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>timestamp = time.time()<EOL>original_ignore_data = set(ignore_data)<EOL>ignore_data = original_ignore_data.copy()<EOL>old_len = len(self)<EOL>self._check_if_both_have_same_parameters(other_trajectory, ignore_data, consecutive_merge)<EOL>self._make_reversed_wildcards(old_length=old_len)<EOL>other_trajectory._make_reversed_wildcards()<EOL>if backup:<EOL><INDENT>other_trajectory.f_backup()<EOL>self.f_backup()<EOL><DEDENT>self._logger.info('<STR_LIT>')<EOL>used_runs, changed_parameters = self._merge_parameters(<EOL>other_trajectory,<EOL>remove_duplicates,<EOL>trial_parameter,<EOL>ignore_data)<EOL>ignore_data.update(set(changed_parameters))<EOL>if len(used_runs) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>rename_dict = {}<EOL>self._logger.info('<STR_LIT>')<EOL>allowed_translations = set([translation for translation, pair in<EOL>other_trajectory._reversed_wildcards.items() if<EOL>any(x in used_runs for x in pair[<NUM_LIT:0>])])<EOL>self._merge_single_runs(other_trajectory, used_runs)<EOL>self._logger.info('<STR_LIT>')<EOL>self._merge_derived_parameters(other_trajectory=other_trajectory,<EOL>used_runs=used_runs,<EOL>rename_dict=rename_dict,<EOL>allowed_translations=allowed_translations,<EOL>ignore_data=ignore_data)<EOL>self._merge_results(other_trajectory=other_trajectory,<EOL>used_runs=used_runs,<EOL>rename_dict=rename_dict,<EOL>allowed_translations=allowed_translations,<EOL>ignore_data=ignore_data)<EOL>self._logger.info('<STR_LIT>')<EOL>self._logger.info('<STR_LIT>')<EOL>self._storage_service.store(pypetconstants.PREPARE_MERGE, self,<EOL>trajectory_name=self.v_name,<EOL>changed_parameters=changed_parameters,<EOL>old_length=old_len)<EOL>if not slow_merge:<EOL><INDENT>try:<EOL><INDENT>try:<EOL><INDENT>other_filename = other_trajectory.v_storage_service.filename<EOL><DEDENT>except AttributeError:<EOL><INDENT>self._logger.warning('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>other_filename = None<EOL><DEDENT>self._storage_service.store(pypetconstants.MERGE, '<STR_LIT>', trajectory_name=self.v_name,<EOL>other_trajectory_name=other_trajectory.v_name,<EOL>rename_dict=rename_dict, move_nodes=move_data,<EOL>delete_trajectory=delete_other_trajectory,<EOL>other_filename=other_filename)<EOL><DEDENT>except pex.NoSuchServiceError as exc:<EOL><INDENT>self._logger.exception('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>slow_merge = True<EOL><DEDENT>except ValueError as exc:<EOL><INDENT>self._logger.exception('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>slow_merge = True<EOL><DEDENT><DEDENT>if slow_merge:<EOL><INDENT>self._merge_slowly(other_trajectory, rename_dict)<EOL><DEDENT>if merge_config:<EOL><INDENT>self._merge_config(other_trajectory)<EOL><DEDENT>self._merge_links(other_trajectory=other_trajectory,<EOL>used_runs=used_runs,<EOL>allowed_translations=allowed_translations,<EOL>ignore_data=original_ignore_data)<EOL>self._logger.info('<STR_LIT>')<EOL>formatted_time = datetime.datetime.fromtimestamp(timestamp).strftime('<STR_LIT>')<EOL>hexsha = hashlib.sha1((self.v_name +<EOL>str(self.v_timestamp) +<EOL>other_trajectory.v_name +<EOL>str(other_trajectory.v_timestamp) +<EOL>VERSION).encode('<STR_LIT:utf-8>')).hexdigest()<EOL>short_hexsha = hexsha[<NUM_LIT:0>:<NUM_LIT:7>]<EOL>if keep_info:<EOL><INDENT>merge_name = '<STR_LIT>' % (short_hexsha, formatted_time)<EOL>config_name = '<STR_LIT>' % merge_name<EOL>self.f_add_config(config_name, len(used_runs),<EOL>comment='<STR_LIT>')<EOL>config_name = '<STR_LIT>' % merge_name<EOL>self.f_add_config(config_name, timestamp,<EOL>comment='<STR_LIT>')<EOL>config_name = '<STR_LIT>' % merge_name<EOL>self.f_add_config(config_name, hexsha,<EOL>comment='<STR_LIT>')<EOL>config_name = '<STR_LIT>' % merge_name<EOL>self.f_add_config(config_name, remove_duplicates,<EOL>comment='<STR_LIT>')<EOL>if original_ignore_data:<EOL><INDENT>config_name = '<STR_LIT>' % merge_name<EOL>self.f_add_config(config_name, tuple(original_ignore_data),<EOL>comment='<STR_LIT>')<EOL><DEDENT>config_name = '<STR_LIT>' % merge_name<EOL>self.f_add_config(config_name, len(self),<EOL>comment='<STR_LIT>')<EOL>self.config.merge.v_comment = '<STR_LIT>'<EOL>if self.v_version != VERSION:<EOL><INDENT>config_name = '<STR_LIT>' % merge_name<EOL>self.f_add_config(config_name, self.v_version,<EOL>comment='<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>if trial_parameter is not None:<EOL><INDENT>config_name = '<STR_LIT>' % merge_name<EOL>self.f_add_config(config_name, len(other_trajectory),<EOL>comment='<STR_LIT>')<EOL><DEDENT>if keep_other_trajectory_info:<EOL><INDENT>if other_trajectory.v_version != self.v_version:<EOL><INDENT>config_name = '<STR_LIT>' % merge_name<EOL>self.f_add_config(config_name, other_trajectory.v_version,<EOL>comment='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>config_name = '<STR_LIT>' % merge_name<EOL>self.f_add_config(config_name, other_trajectory.v_name,<EOL>comment='<STR_LIT>')<EOL>config_name = '<STR_LIT>' % merge_name<EOL>self.f_add_config(config_name, other_trajectory.v_timestamp,<EOL>comment='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>config_name = '<STR_LIT>' % merge_name<EOL>self.f_add_config(config_name, len(other_trajectory),<EOL>comment='<STR_LIT>')<EOL>if other_trajectory.v_comment:<EOL><INDENT>config_name = '<STR_LIT>' % merge_name<EOL>self.f_add_config(config_name, other_trajectory.v_comment,<EOL>comment='<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>if not consecutive_merge:<EOL><INDENT>self._logger.info('<STR_LIT>')<EOL>self.f_store(store_data=pypetconstants.STORE_DATA)<EOL>self._reversed_wildcards = {}<EOL><DEDENT>other_trajectory._reversed_wildcards = {}<EOL>self._logger.info('<STR_LIT>')<EOL>", "docstring": "Merges another trajectory into the current trajectory.\n\n        Both trajectories must live in the same space. This means both need to have the same\n        parameters with similar types of values.\n\n        Note that links are also merged. There are exceptions: Links found under\n        a generic run group called `run_ALL` or links linking to a node under such a\n        group are NOT merged and simply skipped, because there is no straightforward\n        way to resolve the link.\n\n        :param other_trajectory: Other trajectory instance to merge into the current one.\n\n        :param trial_parameter:\n\n            If you have a particular parameter that specifies only the trial\n            number, i.e. an integer parameter running form 0 to T1 and\n            0 to T2, the parameter is modified such that after merging it will\n            cover the range 0 to T1+T2+1. T1 is the number of individual trials in the current\n            trajectory and T2 number of trials in the other trajectory.\n\n        :param remove_duplicates:\n\n            Whether you want to remove duplicate parameter points.\n            Requires N1 * N2 (quadratic complexity in single runs).\n            A ValueError is raised if no runs would be merged.\n\n        :param ignore_data:\n\n            List of full names of data that should be ignored and not merged.\n\n        :param backup:\n\n            If ``True``, backs up both trajectories into files chosen automatically\n            by the storage services. If you want to customize your backup use\n            the `f_backup` function instead.\n\n        :param move_data:\n\n           Tells the storage service to move data from one trajectory to the other\n           instead of copying it.\n\n           If you use the HDF5 storage service and both trajectories are\n           stored in the same file, merging is performed fast directly within\n           the file. You can choose if you want to copy nodes ('move_nodes=False`)\n           from the other trajectory to the current one, or if you want to move them.\n           Accordingly, the stored data is no longer accessible in the other trajectory.\n\n        :param delete_other_trajectory:\n\n            If you want to delete the other trajectory after merging.\n\n        :param keep_info:\n\n            If `True`, information about the merge is added to the trajectory `config` tree under\n            `config.merge`.\n\n        :param merge_config:\n\n            Whether or not to merge all config parameters under `.config.git`,\n            `.config.environment`, and `.config.merge` of the other trajectory\n            into the current one.\n\n        :param keep_other_trajectory_info:\n\n            Whether to keep information like length, name, etc. of the other trajectory\n            in case you want to keep all the information. Setting of `keep_other_trajectory_info`\n            is irrelevant in case `keep_info=False`.\n\n        :param consecutive_merge:\n            Can be set to `True` if you are about to merge several trajectories into the current\n            one within a loop to avoid quadratic complexity.\n            But remember to store your trajectory manually after\n            all merges. Also make sure that all parameters and derived parameters are available\n            in your current trajectory and load them before the consecutive merging.\n            Also avoid specifying a `trial_parameter` and set `backup=False`\n            to avoid quadratic complexity in case of consecutive merges.\n\n        :param slow_merge:\n            Enforces a slow merging. This means all data is loaded one after the other to\n            memory and stored to disk. Otherwise it is tried to directly copy the data\n            from one file into another without explicitly loading the data.\n\n        If you cannot directly merge trajectories within one HDF5 file, a slow merging process\n        is used. Results are loaded, stored, and emptied again one after the other. Might take\n        some time!\n\n        Annotations of parameters and derived parameters under `.derived_parameters.trajectory`\n        are NOT merged. If you wish to extract the annotations of these parameters you have to\n        do that manually before merging. Note that annotations of results and derived parameters\n        of single runs are copied, so you don't have to worry about these.", "id": "f4238:c0:m54"}
{"signature": "@property<EOL><INDENT>def v_crun_(self):<DEDENT>", "body": "return self.v_crun if self.v_crun is not None else self.f_wildcard('<STR_LIT:$>', -<NUM_LIT:1>)<EOL>", "docstring": "Similar to ``v_crun`` but returns ``'run_ALL'`` if ``v_crun`` is ``None``.", "id": "f4238:c0:m16"}
{"signature": "def _remove_exploration(self):", "body": "for param in self._explored_parameters.values():<EOL><INDENT>if param._stored:<EOL><INDENT>try:<EOL><INDENT>self.f_delete_item(param)<EOL><DEDENT>except Exception:<EOL><INDENT>self._logger.exception('<STR_LIT>'<EOL>'<STR_LIT>' % param.v_full_name)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Called if trajectory is expanded, deletes all explored parameters from disk", "id": "f4238:c0:m38"}
{"signature": "@not_in_run<EOL><INDENT>def f_preset_parameter(self, param_name, *args, **kwargs):<DEDENT>", "body": "if not param_name.startswith('<STR_LIT>'):<EOL><INDENT>param_name = '<STR_LIT>' + param_name<EOL><DEDENT>self._preset(param_name, args, kwargs)<EOL>", "docstring": "Presets parameter value before a parameter is added.\n\n        Can be called before parameters are added to the Trajectory in order to change the\n        values that are stored into the parameter on creation.\n\n        After creation of a parameter, the instance of the parameter is called\n        with `param.f_set(*args,**kwargs)` with `*args`, and `**kwargs` provided by the user\n        with `f_preset_parameter`.\n\n        Before an experiment is carried out it is checked if all parameters that were\n        marked were also preset.\n\n        :param param_name:\n\n            The full name (!) of the parameter that is to be changed after its creation.\n\n        :param args:\n\n            Arguments that will be used for changing the parameter's data\n\n        :param kwargs:\n\n            Keyword arguments that will be used for changing the parameter's data\n\n        Example:\n\n        >>> traj.f_preset_parameter('groupA.param1', data=44)\n        >>> traj.f_add_parameter('groupA.param1', data=11)\n        >>> traj.parameters.groupA.param1\n        44", "id": "f4238:c0:m30"}
{"signature": "def _merge_derived_parameters(self,<EOL>other_trajectory,<EOL>used_runs,<EOL>rename_dict,<EOL>allowed_translations,<EOL>ignore_data):", "body": "other_derived_parameters = other_trajectory._derived_parameters.copy()<EOL>new_first_run_idx = min(used_runs.values())<EOL>run_name_dummy = other_trajectory.f_wildcard('<STR_LIT:$>', -<NUM_LIT:1>)<EOL>for param_name in other_derived_parameters:<EOL><INDENT>if param_name in ignore_data:<EOL><INDENT>continue<EOL><DEDENT>split_name = param_name.split('<STR_LIT:.>')<EOL>if not any(x in run_name_dummy for x in split_name):<EOL><INDENT>continue<EOL><DEDENT>ignore_data.add(param_name)<EOL>param = other_derived_parameters[param_name]<EOL>new_param_name = self._rename_full_name(param_name, other_trajectory,<EOL>used_runs=used_runs)<EOL>if new_param_name in self:<EOL><INDENT>my_param = self.f_get(new_param_name, fast_access=False)<EOL>if (my_param._equal_values(my_param.f_get(), param.f_get()) and<EOL>not (my_param.f_has_range() or param.f_has_range())):<EOL><INDENT>continue<EOL><DEDENT><DEDENT>first_new_param_name = self._rename_full_name(param_name,<EOL>other_trajectory,<EOL>new_run_idx=new_first_run_idx)<EOL>rename_dict[param_name] = first_new_param_name<EOL>comment = param.v_comment<EOL>param_type = param.f_get_class_name()<EOL>param_type = self._create_class(param_type)<EOL>first_param = self.f_add_leaf(param_type,<EOL>first_new_param_name,<EOL>comment=comment)<EOL>for run_idx in used_runs.values():<EOL><INDENT>if run_idx == new_first_run_idx:<EOL><INDENT>continue<EOL><DEDENT>next_name = self._rename_full_name(param_name, other_trajectory,<EOL>new_run_idx=run_idx)<EOL>split_name = next_name.split('<STR_LIT:.>')<EOL>link_name = split_name.pop()<EOL>location_name = '<STR_LIT:.>'.join(split_name)<EOL>if not self.f_contains(location_name, shortcuts=False):<EOL><INDENT>the_group = self.f_add_group(location_name)<EOL><DEDENT>else:<EOL><INDENT>the_group = self.f_get(location_name)<EOL><DEDENT>the_group.f_add_link(link_name, first_param)<EOL><DEDENT><DEDENT>for param_name in other_derived_parameters:<EOL><INDENT>if param_name in ignore_data:<EOL><INDENT>continue<EOL><DEDENT>split_name = param_name.split('<STR_LIT:.>')<EOL>ignore_data.add(param_name)<EOL>if any(x in other_trajectory._reversed_wildcards and x not in allowed_translations<EOL>for x in split_name):<EOL><INDENT>continue<EOL><DEDENT>new_name = self._rename_full_name(param_name, other_trajectory,<EOL>used_runs=used_runs)<EOL>if self.f_contains(new_name):<EOL><INDENT>my_param = self.f_get(new_name, fast_access=False)<EOL>param = other_derived_parameters[param_name]<EOL>if (my_param._equal_values(my_param.f_get(), param.f_get()) and<EOL>not (my_param.f_has_range() or param.f_has_range())):<EOL><INDENT>continue<EOL><DEDENT>else:<EOL><INDENT>self._logger.error('<STR_LIT>'<EOL>'<STR_LIT>' % new_name)<EOL><DEDENT><DEDENT>rename_dict[param_name] = new_name<EOL><DEDENT>", "docstring": "Merges derived parameters that have the `run_ALL` in a name.\n\n        Creates a new parameter with the name of the first new run and links to this\n        parameter to avoid copying in all other runs.", "id": "f4238:c0:m57"}
{"signature": "@v_crun.setter<EOL><INDENT>@not_in_run<EOL>def v_crun(self, run_name):<DEDENT>", "body": "self.f_set_crun(run_name)<EOL>", "docstring": "Changes the run name to make the trajectory behave as during a single run", "id": "f4238:c0:m18"}
{"signature": "@property<EOL><INDENT>def v_python(self):<DEDENT>", "body": "return self._python<EOL>", "docstring": "The version of python as a string that was used to create the trajectory", "id": "f4238:c0:m8"}
{"signature": "@not_in_run<EOL><INDENT>def f_iter_runs(self, start=<NUM_LIT:0>, stop=None, step=<NUM_LIT:1>, yields='<STR_LIT:name>'):<DEDENT>", "body": "if stop is None:<EOL><INDENT>stop =len(self)<EOL><DEDENT>elif stop > len(self):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>yields = yields.lower()<EOL>if yields == '<STR_LIT:name>':<EOL><INDENT>yield_func = lambda x: self.f_idx_to_run(x)<EOL><DEDENT>elif yields == '<STR_LIT>':<EOL><INDENT>yield_func = lambda x: x<EOL><DEDENT>elif yields == '<STR_LIT>':<EOL><INDENT>yield_func = lambda x: self<EOL><DEDENT>elif yields == '<STR_LIT>':<EOL><INDENT>yield_func = lambda x: self.__copy__()<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>for idx in range(start, stop, step):<EOL><INDENT>self.f_set_crun(idx)<EOL>yield yield_func(idx)<EOL><DEDENT>self.f_set_crun(None)<EOL>", "docstring": "Makes the trajectory iterate over all runs.\n\n        :param start: Start index of run\n\n        :param stop: Stop index, leave ``None`` for length of trajectory\n\n        :param step: Stepsize\n\n        :param yields:\n\n            What should be yielded: ``'name'`` of run, ``idx`` of run\n            or ``'self'`` to simply return the trajectory container.\n\n            You can also pick ``'copy'`` to get **shallow** copies (ie the tree is copied but\n            no leave nodes except explored ones.) of your trajectory,\n            might lead to some of overhead.\n\n        Note that after a full iteration, the trajectory is set back to normal.\n\n        Thus, the following code snippet\n\n        ::\n\n            for run_name in traj.f_iter_runs():\n\n                 # Do some stuff here...\n\n\n        is equivalent to\n\n        ::\n\n            for run_name in traj.f_get_run_names(sort=True):\n                traj.f_set_crun(run_name)\n\n                # Do some stuff here...\n\n            traj.f_set_crun(None)\n\n\n        :return:\n\n            Iterator over runs. The iterator itself will return the run names but modify\n            the trajectory in each iteration and set it back do normal in the end.", "id": "f4238:c0:m26"}
{"signature": "def f_start_run(self, run_name_or_idx=None, turn_into_run=True):", "body": "if self._run_started:<EOL><INDENT>return self<EOL><DEDENT>if run_name_or_idx is None:<EOL><INDENT>if self.v_idx == -<NUM_LIT:1>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.f_set_crun(run_name_or_idx)<EOL><DEDENT>self._run_started = True<EOL>if turn_into_run:<EOL><INDENT>self._make_single_run()<EOL><DEDENT>self._set_start()<EOL>return self<EOL>", "docstring": "Can be used to manually allow running of an experiment without using an environment.\n\n        :param run_name_or_idx:\n\n            Can manually set a trajectory to a particular run. If `None` the current run\n            the trajectory is set to is used.\n\n        :param turn_into_run:\n\n            Turns the trajectory into a run, i.e. reduces functionality but makes storing\n            more efficient.", "id": "f4238:c0:m73"}
{"signature": "def _update_run_information(self, run_information_dict):", "body": "idx = run_information_dict['<STR_LIT>']<EOL>name = run_information_dict['<STR_LIT:name>']<EOL>self._run_information[name] = run_information_dict<EOL>self._updated_run_information.add(idx)<EOL>", "docstring": "Overwrites the run information of a particular run", "id": "f4238:c0:m43"}
{"signature": "def _merge_slowly(self, other_trajectory, rename_dict):", "body": "for other_key in rename_dict:<EOL><INDENT>new_key = rename_dict[other_key]<EOL>other_instance = other_trajectory.f_get(other_key)<EOL>if other_instance.f_is_empty():<EOL><INDENT>with self._nn_interface._disable_logging:<EOL><INDENT>other_trajectory.f_load_item(other_instance)<EOL><DEDENT><DEDENT>if not self.f_contains(new_key):<EOL><INDENT>class_name = other_instance.f_get_class_name()<EOL>class_ = self._create_class(class_name)<EOL>my_instance = self.f_add_leaf(class_, new_key)<EOL><DEDENT>else:<EOL><INDENT>my_instance = self.f_get(new_key, shortcuts=False)<EOL><DEDENT>if not my_instance.f_is_empty():<EOL><INDENT>raise RuntimeError('<STR_LIT>' % new_key)<EOL><DEDENT>load_dict = other_instance._store()<EOL>my_instance._load(load_dict)<EOL>my_instance.f_set_annotations(**other_instance.v_annotations.f_to_dict(copy=False))<EOL>my_instance.v_comment = other_instance.v_comment<EOL>self.f_store_item(my_instance)<EOL>if other_instance.v_is_parameter:<EOL><INDENT>other_instance.f_unlock()<EOL>my_instance.f_unlock()<EOL><DEDENT>other_instance.f_empty()<EOL>my_instance.f_empty()<EOL><DEDENT>", "docstring": "Merges trajectories by loading iteratively items of the other trajectory and\n        store it into the current trajectory.\n\n        :param rename_dict:\n\n            Dictionary containing mappings from the old result names in the `other_trajectory`\n            to the new names in the current trajectory.", "id": "f4238:c0:m60"}
{"signature": "def __dir__(self):", "body": "result = super(Trajectory, self).__dir__()<EOL>if self._is_run:<EOL><INDENT>result = [x for x in result if not x.startswith('<STR_LIT>') or<EOL>not getattr(getattr(self, x), '<STR_LIT>', False)]<EOL><DEDENT>if not is_debug():<EOL><INDENT>result.extend(self._children.keys())<EOL><DEDENT>return result<EOL>", "docstring": "Adds all children to auto-completion\n\n        In case of a single run it spares all non-available functions", "id": "f4238:c0:m127"}
{"signature": "@v_standard_leaf.setter<EOL><INDENT>def v_standard_leaf(self, leaf):<DEDENT>", "body": "self._standard_leaf = leaf<EOL>", "docstring": "Sets standard result", "id": "f4238:c0:m95"}
{"signature": "def f_idx_to_run(self, name_or_idx):", "body": "return self._single_run_ids[name_or_idx]<EOL>", "docstring": "Converts an integer idx to the corresponding single run name and vice versa.\n\n        Note during a single run ONLY useful if ``v_full_copy`` was set to True.\n\n        :param name_or_idx: Name of a single run or an integer index\n\n        :return: The corresponding idx or name of the single run\n\n        Example usage:\n\n        >>> traj.f_idx_to_run(4)\n        'run_00000004'\n        >>> traj.f_idx_to_run('run_00000000')\n        0", "id": "f4238:c0:m72"}
{"signature": "@property<EOL><INDENT>def v_standard_leaf(self):<DEDENT>", "body": "return self._standard_leaf<EOL>", "docstring": "The standard constructor used if you add a generic leaf.\n\n        The constructor is only used if you do not add items under the usual four subtrees\n        (`parameters`, `derived_parameters`, `config`, `results`).", "id": "f4238:c0:m94"}
{"signature": "def _store(self):", "body": "if self._data is not None:<EOL><INDENT>store_dict = {'<STR_LIT:data>': ObjectTable(data={'<STR_LIT:data>': [self._data]})}<EOL><DEDENT>if self.f_has_range():<EOL><INDENT>store_dict['<STR_LIT>'] = ObjectTable(data={'<STR_LIT:data>': self._explored_range})<EOL><DEDENT>self._locked = True<EOL>return store_dict<EOL>", "docstring": "Returns a dictionary of formatted data understood by the storage service.\n\n        The data is put into an :class:`~pypet.parameter.ObjectTable` named 'data'.\n        If the parameter is explored, the exploration range is also put into another table\n        named 'explored_data'.\n\n        :return: Dictionary containing the data and optionally the exploration range.", "id": "f4239:c2:m17"}
{"signature": "def _build_names_old(self, name_idx, is_dia):", "body": "name_list = self._get_name_list(is_dia)<EOL>return tuple(['<STR_LIT>' % (SparseParameter.IDENTIFIER, name,<EOL>SparseParameter.IDENTIFIER, name_idx)<EOL>for name in name_list])<EOL>", "docstring": "ONLY for backwards compatibility", "id": "f4239:c4:m8"}
{"signature": "def f_supports(self, data):", "body": "dtype = type(data)<EOL>if dtype is tuple or dtype is list and len(data) == <NUM_LIT:0>:<EOL><INDENT>return True  <EOL><DEDENT>elif dtype is np.ndarray and data.size == <NUM_LIT:0> and data.ndim == <NUM_LIT:1>:<EOL><INDENT>return True  <EOL><DEDENT>else:<EOL><INDENT>return super(ArrayParameter, self).f_supports(data)<EOL><DEDENT>", "docstring": "Checks if input data is supported by the parameter.", "id": "f4239:c3:m4"}
{"signature": "def f_supports(self, data):", "body": "dtype = type(data)<EOL>if dtype is tuple or dtype is list:<EOL><INDENT>if len(data) == <NUM_LIT:0>:<EOL><INDENT>return False<EOL><DEDENT>old_type = None<EOL>for item in data:<EOL><INDENT>if not type(item) in pypetconstants.PARAMETER_SUPPORTED_DATA:<EOL><INDENT>return False<EOL><DEDENT>if not old_type is None and old_type != type(item):<EOL><INDENT>return False<EOL><DEDENT>old_type = type(item)<EOL><DEDENT>return True<EOL><DEDENT>elif dtype is np.ndarray or dtype is np.matrix:<EOL><INDENT>if data.size == <NUM_LIT:0>:<EOL><INDENT>return False <EOL><DEDENT>dtype = data.dtype<EOL>if np.issubdtype(dtype, np.str):<EOL><INDENT>dtype = np.str<EOL><DEDENT><DEDENT>return dtype in pypetconstants.PARAMETER_SUPPORTED_DATA<EOL>", "docstring": "Checks if input data is supported by the parameter.", "id": "f4239:c2:m9"}
{"signature": "def f_supports(self, data):", "body": "return type(data) in pypetconstants.PARAMETER_SUPPORTED_DATA<EOL>", "docstring": "Checks whether the data is supported by the parameter.", "id": "f4239:c1:m1"}
{"signature": "def f_set(self, *args, **kwargs):", "body": "if args and self.v_name is None:<EOL><INDENT>raise AttributeError('<STR_LIT>')<EOL><DEDENT>for idx, arg in enumerate(args):<EOL><INDENT>valstr = self.f_translate_key(idx)<EOL>self.f_set_single(valstr, arg)<EOL><DEDENT>for key, arg in kwargs.items():<EOL><INDENT>self.f_set_single(key, arg)<EOL><DEDENT>", "docstring": "Method to put data into the result.\n\n        :param args:\n\n            The first positional argument is stored with the name of the result.\n            Following arguments are stored with `name_X` where `X` is the position\n            of the argument.\n\n        :param kwargs: Arguments are stored with the key as name.\n\n        :raises: TypeError if outer data structure is not understood.\n\n        Example usage:\n\n        >>> res = Result('supergroup.subgroup.myresult', comment='I am a neat example!')\n        >>> res.f_set(333,42.0, mystring='String!')\n        >>> res.f_get('myresult')\n        333\n        >>> res.f_get('myresult_1')\n        42.0\n        >>> res.f_get(1)\n        42.0\n        >>> res.f_get('mystring')\n        'String!'", "id": "f4239:c7:m11"}
{"signature": "def _load(self, load_dict):", "body": "for key in list(load_dict.keys()):<EOL><INDENT>if key in load_dict:<EOL><INDENT>if SparseResult.IDENTIFIER in key:<EOL><INDENT>new_key = key.split(SparseResult.IDENTIFIER)[<NUM_LIT:0>]<EOL>is_dia = load_dict.pop(new_key + SparseResult.IDENTIFIER + '<STR_LIT>')<EOL>name_list = SparseParameter._get_name_list(is_dia)<EOL>rename_list = ['<STR_LIT>' % (new_key, SparseResult.IDENTIFIER, name)<EOL>for name in name_list]<EOL>data_list = [load_dict.pop(name) for name in rename_list]<EOL>matrix = SparseParameter._reconstruct_matrix(data_list)<EOL>self._data[new_key] = matrix<EOL><DEDENT>else:<EOL><INDENT>self._data[key] = load_dict[key]<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Loads data from `load_dict`\n\n        Reconstruction of sparse matrices similar to the :class:`~pypet.parameter.SparseParameter`.", "id": "f4239:c8:m3"}
{"signature": "def _load(self, load_dict):", "body": "if self.v_locked:<EOL><INDENT>raise pex.ParameterLockedException('<STR_LIT>' % self.v_full_name)<EOL><DEDENT>if '<STR_LIT:data>' in load_dict:<EOL><INDENT>dump = load_dict['<STR_LIT:data>']<EOL>self._data = pickle.loads(dump)<EOL><DEDENT>else:<EOL><INDENT>self._logger.warning('<STR_LIT>'<EOL>'<STR_LIT>' % self.v_full_name)<EOL><DEDENT>try:<EOL><INDENT>self.v_protocol = load_dict[PickleParameter.PROTOCOL]<EOL><DEDENT>except KeyError:<EOL><INDENT>self.v_protocol = PickleParameter._get_protocol(dump)<EOL><DEDENT>if '<STR_LIT>' in load_dict:<EOL><INDENT>explore_table = load_dict['<STR_LIT>']<EOL>name_col = explore_table['<STR_LIT>']<EOL>explore_list = []<EOL>for name_id in name_col:<EOL><INDENT>arrayname = self._build_name(name_id)<EOL>loaded = pickle.loads(load_dict[arrayname])<EOL>explore_list.append(loaded)<EOL><DEDENT>self._explored_range = explore_list<EOL>self._explored = True<EOL><DEDENT>self._default = self._data<EOL>self._locked = True<EOL>", "docstring": "Reconstructs objects from the pickle dumps in `load_dict`.\n\n        The 'explored_data' entry in `load_dict` is used to reconstruct\n        the exploration range in the correct order.\n\n        Sets the `v_protocol` property to the protocol used to store 'data'.", "id": "f4239:c5:m7"}
{"signature": "def _restore_default(self):", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "Restores original data if changed due to exploration.\n\n        If a Parameter is explored, the actual data is changed over the course of different\n        simulations. This method restores the original data assigned before exploration.\n\n        ABSTRACT: Needs to be defined in subclass", "id": "f4239:c1:m8"}
{"signature": "def f_supports_fast_access(self):", "body": "return not self.f_is_empty()<EOL>", "docstring": "Checks if parameter supports fast access.\n\n        A parameter supports fast access if it is NOT empty!", "id": "f4239:c1:m3"}
{"signature": "@v_protocol.setter<EOL><INDENT>def v_protocol(self, value):<DEDENT>", "body": "self._protocol = value<EOL>", "docstring": "Sets the protocol", "id": "f4239:c9:m2"}
{"signature": "def f_unlock(self):", "body": "self._locked = False<EOL>", "docstring": "Unlocks the locked parameter.\n\n        Please use it very carefully, or best do not use this function at all.\n        There should better be no reason to unlock a locked parameter!\n        The only exception I can think of is to unlock a large derived parameter\n        after usage to subsequently call :func:`~pypet.parameter.BaseParameter.f_empty`\n        to clear memory.", "id": "f4239:c1:m15"}
{"signature": "def _expand(self, iterable):", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "Similar to :func:`~pypet.parameter.BaseParameter._explore` but appends to\n        the exploration range.\n\n        :param iterable: An iterable specifying the exploration range.\n\n        :raises:\n\n            ParameterLockedException: If the parameter is locked\n\n            TypeError: If the parameter did not have a range before\n\n        Example usage:\n\n        >>> param = Parameter('groupA.groupB.myparam', data=3.13, comment='I am a neat example')\n        >>> param._explore([3.0,2.0,1.0])\n        >>> param._expand([42.0,43.0])\n        >>> param.f_get_range()\n        (3.0,2.0,1.0,42.0,43.0)\n\n        ABSTRACT: Needs to be defined in subclass", "id": "f4239:c1:m23"}
{"signature": "def f_has_range(self):", "body": "return len(self._explored_range) > <NUM_LIT:0><EOL>", "docstring": "If the parameter has a range.\n\n        Does not have to be `True` if the parameter is explored.\n        The range might be removed during pickling to save memory.\n        Accordingly, `v_explored` remains `True` whereas `f_has_range` is `False`.", "id": "f4239:c2:m4"}
{"signature": "def __dir__(self):", "body": "result = super(Result, self).__dir__()<EOL>if self._data_ is not None:<EOL><INDENT>result.extend(self._data.keys())<EOL><DEDENT>return result<EOL>", "docstring": "Adds all data to auto-completion", "id": "f4239:c7:m2"}
{"signature": "@v_protocol.setter<EOL><INDENT>def v_protocol(self, value):<DEDENT>", "body": "self._protocol = value<EOL>", "docstring": "Sets the protocol", "id": "f4239:c5:m2"}
{"signature": "def _data_sanity_checks(self, explore_iterable):", "body": "data_list = []<EOL>for val in explore_iterable:<EOL><INDENT>if not self.f_supports(val):<EOL><INDENT>raise TypeError('<STR_LIT>' % (repr(val), str(type(val))))<EOL><DEDENT>if not self._values_of_same_type(val, self._default):<EOL><INDENT>raise TypeError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(self.v_full_name, str(type(val)), str(type(self._default))))<EOL><DEDENT>data_list.append(val)<EOL><DEDENT>if len(data_list) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return data_list<EOL>", "docstring": "Checks if data values are  valid.\n\n        Checks if the data values are supported by the parameter and if the values are of the same\n        type as the default value.", "id": "f4239:c2:m16"}
{"signature": "def __iter__(self):", "body": "return self._data.__iter__()<EOL>", "docstring": "Equivalent to iterating over the keys of the data dictionary.", "id": "f4239:c7:m14"}
{"signature": "@property<EOL><INDENT>def v_locked(self):<DEDENT>", "body": "return self._locked<EOL>", "docstring": "Whether or not the parameter is locked and prevents further modification", "id": "f4239:c1:m2"}
{"signature": "def _explore(self, explore_iterable):", "body": "if self.v_locked:<EOL><INDENT>raise pex.ParameterLockedException('<STR_LIT>' % self.v_full_name)<EOL><DEDENT>if self.f_has_range():<EOL><INDENT>raise TypeError('<STR_LIT>'<EOL>'<STR_LIT>' % self._name)<EOL><DEDENT>if self._data is None:<EOL><INDENT>raise TypeError('<STR_LIT>'<EOL>'<STR_LIT>' % self.v_full_name)<EOL><DEDENT>data_list = self._data_sanity_checks(explore_iterable)<EOL>self._explored_range = data_list<EOL>self._explored = True<EOL>self.f_lock()<EOL>", "docstring": "Explores the parameter according to the iterable.\n\n        Raises ParameterLockedException if the parameter is locked.\n        Raises TypeError if the parameter does not support the data,\n        the types of the data in the iterable are not the same as the type of the default value,\n        or the parameter has already an exploration range.\n\n        Note that the parameter will iterate over the whole iterable once and store\n        the individual data values into a tuple. Thus, the whole exploration range is\n        explicitly stored in memory.\n\n        :param explore_iterable: An iterable specifying the exploration range\n\n        For example:\n\n        >>> param._explore([3.0,2.0,1.0])\n        >>> param.f_get_range()\n        (3.0, 2.0, 1.0)\n\n        :raises TypeError,ParameterLockedException", "id": "f4239:c2:m14"}
{"signature": "def _values_of_same_type(self, val1, val2):", "body": "if self.f_supports(val1) != self.f_supports(val2):<EOL><INDENT>return False<EOL><DEDENT>if not self.f_supports(val1) and not self.f_supports(val2):<EOL><INDENT>raise TypeError('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>str(type(val1)), str(type(val2)))<EOL><DEDENT>return type(val1) is type(val2)<EOL>", "docstring": "Checks if two values agree in type.\n\n        For example, two 32 bit integers would be of same type, but not a string and an integer,\n        nor a 64 bit and a 32 bit integer.\n\n        This is important for exploration. You are only allowed to explore data that\n        is of the same type as the default value.\n\n        One could always come up with a trivial solution of `type(val1) is type(val2)`.\n        But sometimes your parameter does want even more strict equality or\n        less type equality.\n\n        For example, the :class:`~pypet.parameter.Parameter` has a stricter sense of\n        type equality regarding numpy arrays. In order to have two numpy arrays of the same type,\n        they must also agree in shape. However, the :class:`~pypet.parameter.ArrayParameter`,\n        considers all numpy arrays as of being of same type regardless of their shape.\n\n        Moreover, the :class:`~pypet.parameter.SparseParameter` considers all supported\n        sparse matrices (csc, csr, bsr, dia) as being of the same type. You can make\n        explorations using all these four types at once.\n\n        The difference in how strict types are treated arises from the way parameter data\n        is stored to disk and how the parameters hand over their data to the storage service\n        (see :func:`pypet.parameter.BaseParameter._store`).\n\n        The :class:`~pypet.parameter.Parameter` puts all it's data in an\n        :class:`~pypet.parameter.ObjectTable` which\n        has strict constraints on the column sizes. This means that numpy array columns only\n        accept numpy arrays with a particular size. In contrast, the array and sparse\n        parameter hand over their data as individual items which yield individual entries\n        in the hdf5 node. In order to see what I mean simply run an experiment with all 3\n        parameters, explore all of them, and take a look at the resulting hdf5 file!\n\n        However, this BaseParameter class implements the straightforward version of\n        `type(val1) is type(val2)` to consider data to be of the same type.\n\n        :raises: TypeError: if both values are not supported by the parameter.", "id": "f4239:c1:m12"}
{"signature": "def f_empty(self):", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "Erases all data in the parameter.\n\n        Does not erase data from disk. So if the parameter has\n        been stored with a service to disk and is emptied,\n        it can be restored by loading from disk.\n\n        :raises: ParameterLockedException: If the parameter is locked.\n\n        ABSTRACT: Needs to be defined in subclass", "id": "f4239:c1:m28"}
{"signature": "@staticmethod<EOL><INDENT>def _is_supported_matrix(data):<DEDENT>", "body": "return (spsp.isspmatrix_csc(data) or<EOL>spsp.isspmatrix_csr(data) or<EOL>spsp.isspmatrix_bsr(data) or<EOL>spsp.isspmatrix_dia(data))<EOL>", "docstring": "Checks if a data is csr, csc, bsr, or dia Scipy sparse matrix", "id": "f4239:c4:m2"}
{"signature": "def __getattr__(self, item):", "body": "if item == '<STR_LIT:data>':<EOL><INDENT>return self.f_get()<EOL><DEDENT>elif item == '<STR_LIT:default>':<EOL><INDENT>return self.f_get_default()<EOL><DEDENT>else:<EOL><INDENT>raise AttributeError('<STR_LIT>' % (self.f_get_class_name(),<EOL>item))<EOL><DEDENT>", "docstring": "Allows to query for `.data` as an attribute", "id": "f4239:c2:m6"}
{"signature": "def f_get_range(self, copy=True):", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "Returns an iterable to iterate over the values of the exploration range.\n\n        Note that the returned values should be either a copy of the exploration range\n        unless explicetly requested otherwise.\n\n        :param copy:\n\n            If range should be copied to avoid tempering with data.\n\n        :return: Iterable\n\n        :raises: TypeError if the parameter is not explored\n\n        Example usage:\n\n        >>> param = Parameter('groupA.groupB.myparam',data=22, comment='I am a neat example')\n        >>> param._explore([42,43,43])\n        >>> param.f_get_range()\n        (42,43,44)\n\n        ABSTRACT: Needs to be defined in subclass", "id": "f4239:c1:m21"}
{"signature": "@property<EOL><INDENT>def v_protocol(self):<DEDENT>", "body": "return self._protocol<EOL>", "docstring": "The protocol used to pickle data, default is 0.\n\n        See pickle_ documentation for the protocols.\n\n        .. _pickle: http://docs.python.org/2/library/pickle.html", "id": "f4239:c5:m1"}
{"signature": "def euler_scheme(traj, diff_func):", "body": "steps = traj.steps<EOL>initial_conditions = traj.initial_conditions<EOL>dimension = len(initial_conditions)<EOL>result_array = np.zeros((steps,dimension))<EOL>func_params_dict = traj.func_params.f_to_dict(short_names=True, fast_access=True)<EOL>result_array[<NUM_LIT:0>] = initial_conditions<EOL>for idx in range(<NUM_LIT:1>,steps):<EOL><INDENT>result_array[idx] = diff_func(result_array[idx-<NUM_LIT:1>], **func_params_dict) * traj.dt +result_array[idx-<NUM_LIT:1>]<EOL><DEDENT>traj.f_add_result('<STR_LIT>', data=result_array, comment='<STR_LIT>')<EOL>", "docstring": "Simulation function for Euler integration.\n\n    :param traj:\n\n        Container for parameters and results\n\n    :param diff_func:\n\n        The differential equation we want to integrate", "id": "f4243:m0"}
{"signature": "def diff_lorenz(value_array, sigma, beta, rho):", "body": "diff_array = np.zeros(<NUM_LIT:3>)<EOL>diff_array[<NUM_LIT:0>] = sigma * (value_array[<NUM_LIT:1>]-value_array[<NUM_LIT:0>])<EOL>diff_array[<NUM_LIT:1>] = value_array[<NUM_LIT:0>] * (rho - value_array[<NUM_LIT:2>]) - value_array[<NUM_LIT:1>]<EOL>diff_array[<NUM_LIT:2>] = value_array[<NUM_LIT:0>] * value_array[<NUM_LIT:1>] - beta * value_array[<NUM_LIT:2>]<EOL>return diff_array<EOL>", "docstring": "The Lorenz attractor differential equation\n\n    :param value_array: 3d array containing the x,y, and z component values.\n    :param sigma: Constant attractor parameter\n    :param beta: FConstant attractor parameter\n    :param rho: Constant attractor parameter\n\n    :return: 3d array of the Lorenz system evaluated at `value_array`", "id": "f4243:m2"}
{"signature": "def manipulate_multiproc_safe(traj):", "body": "<EOL>traj.last_process_name = mp.current_process().name<EOL>traj.results.f_store(store_data=<NUM_LIT:3>)<EOL>", "docstring": "Target function that manipulates the trajectory.\n\n    Stores the current name of the process into the trajectory and\n    **overwrites** previous settings.\n\n    :param traj:\n\n        Trajectory container with multiprocessing safe storage service", "id": "f4245:m0"}
{"signature": "def _make_folder(self, traj):", "body": "print_folder = os.path.join(traj.analysis.plot_folder,<EOL>traj.v_name, traj.v_crun)<EOL>print_folder = os.path.abspath(print_folder)<EOL>if not os.path.isdir(print_folder):<EOL><INDENT>os.makedirs(print_folder)<EOL><DEDENT>return print_folder<EOL>", "docstring": "Makes a subfolder for plots.\n\n        :return: Path name to print folder", "id": "f4249:c4:m3"}
{"signature": "def _add_monitors(self, traj,  network, network_dict):", "body": "neurons_e = network_dict['<STR_LIT>']<EOL>monitor_list = []<EOL>self.spike_monitor = SpikeMonitor(neurons_e)<EOL>monitor_list.append(self.spike_monitor)<EOL>self.V_monitor = StateMonitor(neurons_e,'<STR_LIT>',<EOL>record=list(traj.neuron_records))<EOL>monitor_list.append(self.V_monitor)<EOL>self.I_syn_e_monitor = StateMonitor(neurons_e, '<STR_LIT>',<EOL>record=list(traj.neuron_records))<EOL>monitor_list.append(self.I_syn_e_monitor)<EOL>self.I_syn_i_monitor = StateMonitor(neurons_e, '<STR_LIT>',<EOL>record=list(traj.neuron_records))<EOL>monitor_list.append(self.I_syn_i_monitor)<EOL>network.add(*monitor_list)<EOL>network_dict['<STR_LIT>'] = monitor_list<EOL>", "docstring": "Adds monitors to the network", "id": "f4249:c4:m2"}
{"signature": "def analyse(self, traj, network, current_subrun, subrun_list, network_dict):", "body": "<EOL>if len(subrun_list)==<NUM_LIT:0>:<EOL><INDENT>spikes_e = traj.results.monitors.spikes_e<EOL>time_window = traj.parameters.analysis.statistics.time_window<EOL>start_time = traj.parameters.simulation.durations.initial_run<EOL>end_time = start_time+traj.parameters.simulation.durations.measurement_run<EOL>neuron_ids = traj.parameters.analysis.statistics.neuron_ids<EOL>mean_ff = self._compute_mean_fano_factor(<EOL>neuron_ids, spikes_e, time_window, start_time, end_time)<EOL>traj.f_add_result('<STR_LIT>', mean_ff, comment='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>print('<STR_LIT>' % (traj.R_ee, mean_ff))<EOL><DEDENT>", "docstring": "Calculates average Fano Factor of a network.\n\n        :param traj:\n\n            Trajectory container\n\n            Expects:\n\n            `results.monitors.spikes_e`: Data from SpikeMonitor for excitatory neurons\n\n            Adds:\n\n            `results.statistics.mean_fano_factor`: Average Fano Factor\n\n        :param network:\n\n            The BRIAN network\n\n        :param current_subrun:\n\n            BrianParameter\n\n        :param subrun_list:\n\n            Upcoming subruns, analysis is only performed if subruns is empty,\n            aka the final subrun has finished.\n\n        :param network_dict:\n\n            Dictionary of items shared among componetns", "id": "f4249:c3:m3"}
{"signature": "@staticmethod<EOL><INDENT>def _build_model_eqs(traj):<DEDENT>", "body": "model_eqs = traj.model.eqs<EOL>post_eqs={}<EOL>for name_post in ['<STR_LIT:i>','<STR_LIT:e>']:<EOL><INDENT>variables_dict ={}<EOL>new_model_eqs=model_eqs.replace('<STR_LIT:POST>', name_post)<EOL>for name_pre in ['<STR_LIT:i>', '<STR_LIT:e>']:<EOL><INDENT>conn_eqs = traj.model.synaptic.eqs<EOL>new_conn_eqs = conn_eqs.replace('<STR_LIT>', name_pre)<EOL>new_model_eqs += new_conn_eqs<EOL>tau1 = traj.model.synaptic['<STR_LIT>']<EOL>tau2 = traj.model.synaptic['<STR_LIT>'+name_pre]<EOL>normalization = (tau1-tau2) / tau2<EOL>invtau1=<NUM_LIT:1.0>/tau1<EOL>invtau2 = <NUM_LIT:1.0>/tau2<EOL>variables_dict['<STR_LIT>'+name_pre] = invtau1<EOL>variables_dict['<STR_LIT>'+name_pre] = invtau2<EOL>variables_dict['<STR_LIT>'+name_pre] = normalization<EOL>variables_dict['<STR_LIT>'+name_pre] = tau1<EOL>variables_dict['<STR_LIT>'+name_pre] = tau2<EOL><DEDENT>variables_dict['<STR_LIT>'+name_post] = traj.model['<STR_LIT>'+name_post]<EOL>post_eqs[name_post] = Equations(new_model_eqs, **variables_dict)<EOL><DEDENT>return post_eqs<EOL>", "docstring": "Computes model equations for the excitatory and inhibitory population.\n\n        Equation objects are created by fusing `model.eqs` and `model.synaptic.eqs`\n        and replacing `PRE` by `i` (for inhibitory) or `e` (for excitatory) depending\n        on the type of population.\n\n        :return: Dictionary with 'i' equation object for inhibitory neurons and 'e' for excitatory", "id": "f4249:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def _compute_fano_factor(spike_res, neuron_id, time_window, start_time, end_time):<DEDENT>", "body": "assert(end_time >= start_time+time_window)<EOL>bins = (end_time-start_time)/time_window<EOL>bins = int(np.floor(bins))<EOL>binned_spikes = np.zeros(bins)<EOL>spike_array_neuron = spike_res.t[spike_res.i==neuron_id]<EOL>for bin in range(bins):<EOL><INDENT>lower_time = start_time+time_window*bin<EOL>upper_time = start_time+time_window*(bin+<NUM_LIT:1>)<EOL>spike_array_interval = spike_array_neuron[spike_array_neuron >= lower_time]<EOL>spike_array_interval = spike_array_interval[spike_array_interval < upper_time]<EOL>spikes = len(spike_array_interval)<EOL>binned_spikes[bin]=spikes<EOL><DEDENT>var = np.var(binned_spikes)<EOL>avg = np.mean(binned_spikes)<EOL>if avg > <NUM_LIT:0>:<EOL><INDENT>return var/float(avg)<EOL><DEDENT>else:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>", "docstring": "Computes Fano Factor for one neuron.\n\n        :param spike_res:\n\n            Result containing the spiketimes of all neurons\n\n        :param neuron_id:\n\n            Index of neuron for which FF is computed\n\n        :param time_window:\n\n            Length of the consecutive time windows to compute the FF\n\n        :param start_time:\n\n            Start time of measurement to consider\n\n        :param end_time:\n\n            End time of measurement to consider\n\n        :return:\n\n            Fano Factor (float) or\n            returns 0 if mean firing activity is 0.", "id": "f4249:c3:m1"}
{"signature": "def _build_connections(self, traj, brian_list, network_dict):", "body": "connections = traj.connections<EOL>neurons_i = network_dict['<STR_LIT>']<EOL>neurons_e = network_dict['<STR_LIT>']<EOL>print('<STR_LIT>')<EOL>self.conn_ii = Synapses(neurons_i,neurons_i, on_pre='<STR_LIT>' % connections.J_ii)<EOL>self.conn_ii.connect('<STR_LIT>', p=connections.p_ii)<EOL>print('<STR_LIT>')<EOL>self.conn_ei = Synapses(neurons_i,neurons_e, on_pre='<STR_LIT>' % connections.J_ei)<EOL>self.conn_ei.connect('<STR_LIT>', p=connections.p_ei)<EOL>print('<STR_LIT>')<EOL>self.conn_ie = Synapses(neurons_e,neurons_i, on_pre='<STR_LIT>' % connections.J_ie)<EOL>self.conn_ie.connect('<STR_LIT>', p=connections.p_ie)<EOL>conns_list = [self.conn_ii, self.conn_ei, self.conn_ie]<EOL>if connections.R_ee > <NUM_LIT:1.0>:<EOL><INDENT>cluster_list=[]<EOL>cluster_conns_list=[]<EOL>model=traj.model<EOL>clusters = int(model.N_e/connections.clustersize_e)<EOL>traj.f_add_derived_parameter('<STR_LIT>', clusters, comment='<STR_LIT>')<EOL>p_out = (connections.p_ee*model.N_e) /(connections.R_ee*connections.clustersize_e+model.N_e- connections.clustersize_e)<EOL>p_in = p_out * connections.R_ee<EOL>traj.f_add_derived_parameter('<STR_LIT>', p_in ,<EOL>comment='<STR_LIT>')<EOL>traj.f_add_derived_parameter('<STR_LIT>', p_out ,<EOL>comment='<STR_LIT>')<EOL>low_index = <NUM_LIT:0><EOL>high_index = connections.clustersize_e<EOL>for irun in range(clusters):<EOL><INDENT>cluster = neurons_e[low_index:high_index]<EOL>print('<STR_LIT>' % (irun, clusters))<EOL>conn = Synapses(cluster,cluster,<EOL>on_pre='<STR_LIT>' % (connections.J_ee*connections.strength_factor))<EOL>conn.connect('<STR_LIT>', p=p_in)<EOL>cluster_conns_list.append(conn)<EOL>if low_index > <NUM_LIT:0>:<EOL><INDENT>rest_low = neurons_e[<NUM_LIT:0>:low_index]<EOL>print('<STR_LIT>')<EOL>low_conn = Synapses(cluster,rest_low,<EOL>on_pre='<STR_LIT>' % connections.J_ee)<EOL>low_conn.connect('<STR_LIT>', p=p_out)<EOL>cluster_conns_list.append(low_conn)<EOL><DEDENT>if high_index < model.N_e:<EOL><INDENT>rest_high = neurons_e[high_index:model.N_e]<EOL>print('<STR_LIT>')<EOL>high_conn = Synapses(cluster,rest_high,<EOL>on_pre='<STR_LIT>' % connections.J_ee)<EOL>high_conn.connect('<STR_LIT>', p=p_out)<EOL>cluster_conns_list.append(high_conn)<EOL><DEDENT>low_index=high_index<EOL>high_index+=connections.clustersize_e<EOL><DEDENT>self.cluster_conns=cluster_conns_list<EOL>conns_list+=cluster_conns_list<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>')<EOL>self.conn_ee = Synapses(neurons_e,neurons_e,<EOL>on_pre='<STR_LIT>' % connections.J_ee)<EOL>self.conn_ee.connect('<STR_LIT>', p=connections.p_ee)<EOL>conns_list.append(self.conn_ee)<EOL><DEDENT>brian_list.extend(conns_list)<EOL>network_dict['<STR_LIT>'] = conns_list<EOL>", "docstring": "Connects neuron groups `neurons_i` and `neurons_e`.\n\n        Adds all connections to `brian_list` and adds a list of connections\n        with the key 'connections' to the `network_dict`.", "id": "f4249:c1:m3"}
{"signature": "def multiply(traj):", "body": "z=traj.x*traj.y<EOL>traj.f_add_result('<STR_LIT:z>',z=z, comment='<STR_LIT>')<EOL>", "docstring": "Sophisticated simulation of multiplication", "id": "f4250:m0"}
{"signature": "def multiply(traj):", "body": "z=traj.x*traj.y<EOL>traj.f_add_result('<STR_LIT:z>',z, comment='<STR_LIT>')<EOL>", "docstring": "Sophisticated simulation of multiplication", "id": "f4251:m0"}
{"signature": "def make_filename(traj):", "body": "explored_parameters = traj.f_get_explored_parameters()<EOL>filename = '<STR_LIT>'<EOL>for param in explored_parameters.values():<EOL><INDENT>short_name = param.v_name<EOL>val = param.f_get()<EOL>filename += '<STR_LIT>' % (short_name, str(val))<EOL><DEDENT>return filename[:-<NUM_LIT:2>] + '<STR_LIT>'<EOL>", "docstring": "Function to create generic filenames based on what has been explored", "id": "f4253:m0"}
{"signature": "def main():", "body": "<EOL>logger = logging.getLogger()<EOL>folder = os.path.join(os.getcwd(), '<STR_LIT>', '<STR_LIT>')<EOL>if not os.path.isdir(folder):<EOL><INDENT>os.makedirs(folder)<EOL><DEDENT>filename = os.path.join(folder, '<STR_LIT>')<EOL>env = Environment(trajectory='<STR_LIT>',<EOL>multiproc=True,<EOL>ncores=<NUM_LIT:4>,<EOL>wrap_mode='<STR_LIT>',<EOL>filename=filename,<EOL>overwrite_file=True)<EOL>traj = env.traj<EOL>traj.par.ncells = Parameter('<STR_LIT>', <NUM_LIT>, '<STR_LIT>')<EOL>traj.par.steps = Parameter('<STR_LIT>', <NUM_LIT>, '<STR_LIT>')<EOL>traj.par.rule_number = Parameter('<STR_LIT>', <NUM_LIT:30>, '<STR_LIT>')<EOL>traj.par.initial_name = Parameter('<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>traj.par.seed = Parameter('<STR_LIT>', <NUM_LIT>, '<STR_LIT>')<EOL>exp_dict = {'<STR_LIT>' : [<NUM_LIT:10>, <NUM_LIT:30>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>],<EOL>'<STR_LIT>' : ['<STR_LIT>', '<STR_LIT>'],}<EOL>exp_dict = cartesian_product(exp_dict)<EOL>traj.f_explore(exp_dict)<EOL>logger.info('<STR_LIT>')<EOL>env.run(wrap_automaton)<EOL>traj.f_load(load_data=<NUM_LIT:2>)<EOL>logger.info('<STR_LIT>')<EOL>for idx, run_name in enumerate(traj.f_iter_runs()):<EOL><INDENT>filename = os.path.join(folder, make_filename(traj))<EOL>plot_pattern(traj.crun.pattern, traj.rule_number, filename)<EOL>progressbar(idx, len(traj), logger=logger)<EOL><DEDENT>env.disable_logging()<EOL>", "docstring": "Main *boilerplate* function to start simulation", "id": "f4253:m2"}
{"signature": "def eval_wrapper(the_tuple):", "body": "return eval_one_max(*the_tuple)<EOL>", "docstring": "Wrapper function that unpacks a single tuple as arguments to the fitness function.\n\n    The pool's map function only allows a single iterable so we need to zip it first\n    and then unpack it here.", "id": "f4256:m1"}
{"signature": "@manual_run(store_meta_data=True)   <EOL>def eval_one_max(traj, individual):", "body": "traj.f_add_result('<STR_LIT>', list(individual))<EOL>fitness = sum(individual)<EOL>traj.f_add_result('<STR_LIT>', fitness)<EOL>traj.f_store()<EOL>return (fitness,)<EOL>", "docstring": "The fitness function", "id": "f4256:m0"}
{"signature": "def add_parameters(traj):", "body": "print('<STR_LIT>')<EOL>traj.f_add_parameter('<STR_LIT>', <NUM_LIT:0.0>,<EOL>comment='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>traj.f_add_parameter('<STR_LIT>', <NUM_LIT:0.0>,<EOL>comment='<STR_LIT>')<EOL>traj.f_add_parameter('<STR_LIT>', <NUM_LIT>,<EOL>comment='<STR_LIT>')<EOL>traj.f_add_parameter('<STR_LIT>', <NUM_LIT>,<EOL>comment='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>traj.f_add_parameter('<STR_LIT>', <NUM_LIT>,<EOL>comment='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>traj.f_add_parameter('<STR_LIT>', <NUM_LIT:0.1>,<EOL>comment='<STR_LIT>')<EOL>", "docstring": "Adds all parameters to `traj`", "id": "f4259:m2"}
{"signature": "def mypipeline(traj):", "body": "add_parameters(traj)<EOL>add_exploration(traj)<EOL>return (run_neuron,(),{}), (neuron_postproc,(),{})<EOL>", "docstring": "A pipeline function that defines the entire experiment\n\n    :param traj:\n\n        Container for results and parameters\n\n    :return:\n\n        Two tuples. First tuple contains the actual run function plus additional\n        arguments (yet we have none). Second tuple contains the\n        postprocessing function including additional arguments.", "id": "f4260:m0"}
{"signature": "def multiply(traj):", "body": "z=traj.x * traj.y<EOL>traj.f_add_result('<STR_LIT:z>', z, comment='<STR_LIT>')<EOL>", "docstring": "Sophisticated simulation of multiplication", "id": "f4264:m0"}
{"signature": "def multiply(traj):", "body": "z = traj.x * traj.y<EOL>traj.f_add_result('<STR_LIT:z>', z, comment='<STR_LIT>')<EOL>", "docstring": "Example of a sophisticated simulation that involves multiplying two values.\n\n    :param traj:\n\n        Trajectory containing\n        the parameters in a particular combination,\n        it also serves as a container for results.", "id": "f4265:m0"}
{"signature": "def multiply(traj):", "body": "z=traj.x*traj.y<EOL>traj.f_add_result('<STR_LIT:z>',z=z, comment='<STR_LIT>',)<EOL>", "docstring": "Sophisticated simulation of multiplication", "id": "f4268:m0"}
{"signature": "def eval_one_max(traj):", "body": "fitness = sum(traj.individual)<EOL>return (fitness,)<EOL>", "docstring": "The fitness function", "id": "f4270:m0"}
{"signature": "def video(request, video_id):", "body": "<EOL>api = Api()<EOL>api.authenticate()<EOL>availability = api.check_upload_status(video_id)<EOL>if availability is not True:<EOL><INDENT>video = Video.objects.filter(video_id=video_id).get()<EOL>state = availability[\"<STR_LIT>\"]<EOL>if state == \"<STR_LIT>\" or state == \"<STR_LIT>\":<EOL><INDENT>return render_to_response(<EOL>\"<STR_LIT>\",<EOL>{\"<STR_LIT>\": video, \"<STR_LIT>\": video_id, \"<STR_LIT:message>\":<EOL>_(\"<STR_LIT>\"), \"<STR_LIT>\": availability},<EOL>context_instance=RequestContext(request)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>return render_to_response(<EOL>\"<STR_LIT>\",<EOL>{\"<STR_LIT>\": video, \"<STR_LIT>\": video_id,<EOL>\"<STR_LIT:message>\": _(\"<STR_LIT>\"), \"<STR_LIT>\": availability},<EOL>context_instance=RequestContext(request)<EOL>)<EOL><DEDENT><DEDENT>video_params = _video_params(request, video_id)<EOL>return render_to_response(<EOL>\"<STR_LIT>\",<EOL>video_params,<EOL>context_instance=RequestContext(request)<EOL>)<EOL>", "docstring": "Displays a video in an embed player", "id": "f4273:m2"}
{"signature": "def get_absolute_url(self):", "body": "return self.swf_url<EOL>", "docstring": "Returns the swf url", "id": "f4276:c0:m1"}
{"signature": "def _access_control(self, access_control, my_media_group=None):", "body": "<EOL>extension = None<EOL>if access_control is AccessControl.Private:<EOL><INDENT>if my_media_group:<EOL><INDENT>my_media_group.private = gdata.media.Private()<EOL><DEDENT><DEDENT>elif access_control is AccessControl.Unlisted:<EOL><INDENT>from gdata.media import YOUTUBE_NAMESPACE<EOL>from atom import ExtensionElement<EOL>kwargs = {<EOL>\"<STR_LIT>\": YOUTUBE_NAMESPACE,<EOL>\"<STR_LIT>\": {'<STR_LIT:action>': '<STR_LIT:list>', '<STR_LIT>': '<STR_LIT>'},<EOL>}<EOL>extension = ([ExtensionElement('<STR_LIT>', **kwargs)])<EOL><DEDENT>return extension<EOL>", "docstring": "Prepares the extension element for access control\nExtension element is the optional parameter for the YouTubeVideoEntry\nWe use extension element to modify access control settings\n\nReturns:\n    tuple of extension elements", "id": "f4278:c3:m1"}
{"signature": "def fetch_video(self, video_id):", "body": "return Api.yt_service.GetYouTubeVideoEntry('<STR_LIT>' % video_id)<EOL>", "docstring": "Retrieve a specific video entry and return it\n@see http://gdata-python-client.googlecode.com/hg/pydocs/gdata.youtube.html#YouTubeVideoEntry", "id": "f4278:c3:m2"}
{"signature": "def check_upload_status(self, video_id):", "body": "<EOL>if not self.authenticated:<EOL><INDENT>raise ApiError(_(\"<STR_LIT>\"))<EOL><DEDENT>entry = self.fetch_video(video_id)<EOL>upload_status = Api.yt_service.CheckUploadStatus(entry)<EOL>if upload_status is not None:<EOL><INDENT>video_upload_state = upload_status[<NUM_LIT:0>]<EOL>detailed_message = upload_status[<NUM_LIT:1>]<EOL>return {\"<STR_LIT>\": video_upload_state, \"<STR_LIT>\": detailed_message}<EOL><DEDENT>else:<EOL><INDENT>return True<EOL><DEDENT>", "docstring": "Checks the video upload status\nNewly uploaded videos may be in the processing state\n\nAuthentication is required\n\nReturns:\n    True if video is available\n    otherwise a dict containes upload_state and detailed message\n    i.e. {\"upload_state\": \"processing\", \"detailed_message\": \"\"}", "id": "f4278:c3:m7"}
{"signature": "def home(request):", "body": "return render_to_response('<STR_LIT>', {}, context_instance=RequestContext(request))<EOL>", "docstring": "home page", "id": "f4279:m0"}
{"signature": "def _load_config(path: str) -> dict:", "body": "__, ext = os.path.splitext(path)<EOL>if ext in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>import ruamel.yaml<EOL>loader = ruamel.yaml.safe_load<EOL><DEDENT>else:<EOL><INDENT>loader = json.load<EOL><DEDENT>with open(path) as f:<EOL><INDENT>config = loader(f)<EOL><DEDENT>return config<EOL>", "docstring": "Given a file path, parse it based on its extension (YAML or JSON)\nand return the values as a Python dictionary. JSON is the default if an\nextension can't be determined.", "id": "f4295:m0"}
{"signature": "def __init__(self,<EOL>file_env_var: str = None,<EOL>default_files: List[str] = None,<EOL>load: bool = False):", "body": "self.file_env_var = file_env_var<EOL>self.config_file = None<EOL>self.default_files = default_files or []<EOL>if load:<EOL><INDENT>self.load()<EOL><DEDENT>", "docstring": ":param file_env_var: the name of an environment variable which can be\n                     used for the name of the configuration file to\n                     load\n:param default_files: if no file is given, try to load a configuration\n                      from these files in order\n:param load: load config file on instantiation [default: False].\n\nA docstring defined on the class should be a plain-text description\nused as a header when generating a configuration file.", "id": "f4295:c0:m0"}
{"signature": "def wait(self):", "body": "with self.cvar:<EOL><INDENT>self.count.value += <NUM_LIT:1><EOL>self.cvar.notify_all()<EOL>while self.count.value < self.n_procs:<EOL><INDENT>self.cvar.wait()<EOL><DEDENT><DEDENT>", "docstring": "Wait until all processes have reached the barrier.", "id": "f4299:c1:m1"}
{"signature": "def reset(self):", "body": "with self.cvar:<EOL><INDENT>self.count.value = <NUM_LIT:0><EOL><DEDENT>", "docstring": "Re-set the barrier so that it can be used again.", "id": "f4299:c1:m2"}
{"signature": "def get_queue(self, path, n_procs=<NUM_LIT:4>, read_ahead=None, cyclic=False, block_size=None, ordered=False):", "body": "<EOL>example = self.__get_batch(path, block_size)<EOL>block_size = example.shape[<NUM_LIT:0>]<EOL>if read_ahead is None:<EOL><INDENT>read_ahead = <NUM_LIT:2>*n_procs + <NUM_LIT:1><EOL><DEDENT>cbuf = SharedCircBuf(read_ahead, example)<EOL>stop = multiprocessing.Event()<EOL>barrier = Barrier(n_procs)<EOL>sync = GuardSynchronizer() if ordered else None<EOL>procs = []<EOL>for i in range(n_procs):<EOL><INDENT>process = multiprocessing.Process(target=_Streamer__read_process, args=(<EOL>self, path, block_size, cbuf, stop, barrier, cyclic,<EOL>i * block_size, n_procs * block_size, sync<EOL>))<EOL>process.daemon = True<EOL>process.start()<EOL>procs.append(process)<EOL><DEDENT>if not cyclic:<EOL><INDENT>def monitor():<EOL><INDENT>for p in procs:<EOL><INDENT>p.join()<EOL><DEDENT>cbuf.close()<EOL><DEDENT>monitor_thread = threading.Thread(target=monitor)<EOL>monitor_thread.daemon = True<EOL>monitor_thread.start()<EOL><DEDENT>return Streamer.Queue(cbuf, stop, block_size)<EOL>", "docstring": "Get a queue that allows direct access to the internal buffer. If the dataset to be read is chunked, the\nblock_size should be a multiple of the chunk size to maximise performance. In this case it is best to leave it\nto the default. When cyclic=False, and block_size does not divide the dataset evenly, the remainder elements\nwill not be returned by the queue. When cyclic=True, the remainder elements will be part of a block that wraps\naround the end and includes element from the beginning of the dataset. By default, blocks are returned in the\norder in which they become available. The ordered option will force blocks to be returned in on-disk order.\n\n:param path: The HDF5 path to the dataset that should be read.\n:param n_procs: The number of background processes used to read the datset in parallel.\n:param read_ahead: The number of blocks to allocate in the internal buffer.\n:param cyclic: True if the queue should wrap at the end of the dataset.\n:param block_size: The size along the outer dimension of the blocks to be read. Defaults to a multiple of\n    the chunk size, or to a 128KB sized block if the dataset is not chunked.\n:param ordered: Force the reader return data in on-disk order. May result in performance penalty.\n:return: A queue object that allows access to the internal buffer.", "id": "f4299:c7:m3"}
{"signature": "def __get_batch(self, path, length, last=False):", "body": "import tables<EOL>h5_file = tables.open_file(self.filename, '<STR_LIT:r>')<EOL>h5_node = h5_file.get_node(path)<EOL>if len(h5_node) == <NUM_LIT:0>:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>if length is None:<EOL><INDENT>chunkshape = h5_node.chunkshape<EOL>if chunkshape is None:<EOL><INDENT>default_length = <NUM_LIT>*<NUM_LIT:2>**<NUM_LIT:10>//h5_node[<NUM_LIT:0>].nbytes  <EOL>length = min(h5_node.shape[<NUM_LIT:0>], default_length)<EOL><DEDENT>else:<EOL><INDENT>length = chunkshape[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>if last:<EOL><INDENT>example = h5_node[length*(len(h5_node)//length):].copy()<EOL><DEDENT>else:<EOL><INDENT>example = h5_node[:length].copy()<EOL><DEDENT>h5_file.close()<EOL>return example<EOL>", "docstring": "Get a block of data from the node at path.\n\n:param path: The path to the node to read from.\n:param length: The length along the outer dimension to read.\n:param last: True if the remainder elements should be read.\n:return: A copy of the requested block of data as a numpy array.", "id": "f4299:c7:m1"}
{"signature": "def wait(self):", "body": "self.barrier_A.wait()<EOL>self.barrier_A, self.barrier_B = self.barrier_B, self.barrier_A<EOL>self.barrier_A.reset()<EOL>", "docstring": "Wait until all processes have reached the barrier.", "id": "f4299:c2:m1"}
{"signature": "def error(self, status=None):", "body": "def decorator(callback):<EOL><INDENT>self._error_handlers[status] = callback<EOL>return callback<EOL><DEDENT>return decorator<EOL>", "docstring": "Decorator to add a callback that generates error page.\n\n        The *status* parameter specifies the HTTP response status code\n        for which the decorated callback should be invoked. If the\n        *status* argument is not specified, then the decorated callable\n        is considered to be a fallback callback.\n\n        A fallback callback, when defined, is invoked to generate the\n        error page for any HTTP response representing an error when\n        there is no error handler defined explicitly for the response\n        code of the HTTP response.\n\n        Arguments:\n          status(int, optional): HTTP response status code.\n\n        Returns:\n          function: Decorator function to add error handler.", "id": "f4315:c0:m7"}
{"signature": "def __init__(self, pattern, callback):", "body": "self._re = []<EOL>self._wildcards = []<EOL>for token in WildcardRoute.tokens(pattern):<EOL><INDENT>if token and token.startswith('<STR_LIT:<>') and token.endswith('<STR_LIT:>>'):<EOL><INDENT>w = Wildcard(token)<EOL>self._wildcards.append(w)<EOL>self._re.append(w.regex())<EOL><DEDENT>else:<EOL><INDENT>self._re.append(re.escape(token))<EOL><DEDENT><DEDENT>self._re = re.compile('<STR_LIT>' + '<STR_LIT>'.join(self._re) + '<STR_LIT:$>')<EOL>self._callback = callback<EOL>", "docstring": "Initialize wildcard route.\n\n        Arguments:\n          pattern (str): Pattern associated with the route.\n          callback (callable): Route handler.", "id": "f4315:c2:m0"}
{"signature": "def __init__(self, start_response_callable):", "body": "self.start = start_response_callable<EOL>self.status = <NUM_LIT:200><EOL>self.media_type = '<STR_LIT>'<EOL>self.charset = '<STR_LIT>'<EOL>self._headers = []<EOL>self.body = None<EOL>self.state = {}<EOL>", "docstring": "Initialize the current response object.\n\n        Arguments:\n          start_response_callable (callable): Callable that starts response.", "id": "f4315:c6:m0"}
{"signature": "def get(self, pattern):", "body": "return self.route('<STR_LIT:GET>', pattern)<EOL>", "docstring": "Decorator to add route for an HTTP GET request.\n\n        Arguments:\n          pattern (str): Routing pattern the path must match.\n\n        Returns:\n          function: Decorator to add route for HTTP GET request.", "id": "f4315:c0:m4"}
{"signature": "@staticmethod<EOL><INDENT>def like(pattern):<DEDENT>", "body": "return RegexRoute._group_re.search(pattern) is not None<EOL>", "docstring": "Determine if a pattern looks like a regular expression.\n\n        Arguments:\n          pattern (str): Any route pattern.\n\n        Returns:\n          ``True`` if the specified pattern looks like a regex,\n          ``False`` otherwise.", "id": "f4315:c4:m2"}
{"signature": "def _get_error_page_callback(self):", "body": "if self.response.status in self._error_handlers:<EOL><INDENT>return self._error_handlers[self.response.status]<EOL><DEDENT>elif None in self._error_handlers:<EOL><INDENT>return self._error_handlers[None]<EOL><DEDENT>else:<EOL><INDENT>self.response.media_type = '<STR_LIT>'<EOL>return lambda: self.response.status_line<EOL><DEDENT>", "docstring": "Return an error page for the current response status.", "id": "f4315:c0:m11"}
{"signature": "def __init__(self, pattern, callback):", "body": "self._re = re.compile(pattern)<EOL>self._callback = callback<EOL>", "docstring": "Initialize regular expression route.\n\n        Arguments:\n          pattern (str): Pattern associated with the route.\n          callback (callable): Route handler.", "id": "f4315:c4:m0"}
{"signature": "def __init__(self, environ):", "body": "self.environ = environ<EOL>self.method = environ.get('<STR_LIT>', '<STR_LIT:GET>')<EOL>self.path = environ.get('<STR_LIT>', '<STR_LIT:/>')<EOL>if not self.path:<EOL><INDENT>self.path = '<STR_LIT:/>'<EOL><DEDENT>self.query = MultiDict()<EOL>self.form = MultiDict()<EOL>self.cookies = MultiDict()<EOL>if '<STR_LIT>' in environ:<EOL><INDENT>for k, v in urllib.parse.parse_qsl(environ['<STR_LIT>']):<EOL><INDENT>self.query[k] = v<EOL><DEDENT><DEDENT>if '<STR_LIT>' in environ:<EOL><INDENT>fs = cgi.FieldStorage(fp=environ['<STR_LIT>'],<EOL>environ=environ)<EOL>for k in fs:<EOL><INDENT>for v in fs.getlist(k):<EOL><INDENT>self.form[k] = v<EOL><DEDENT><DEDENT><DEDENT>if '<STR_LIT>' in environ:<EOL><INDENT>cookies = http.cookies.SimpleCookie(environ['<STR_LIT>'])<EOL>for c in cookies.values():<EOL><INDENT>self.cookies[c.key] = c.value<EOL><DEDENT><DEDENT>", "docstring": "Initialize the current request object.\n\n        Arguments:\n          environ (dict): Dictionary of environment variables.", "id": "f4315:c5:m0"}
{"signature": "def resolve(self, method, path):", "body": "if method in self._literal and path in self._literal[method]:<EOL><INDENT>return self._literal[method][path], [], {}<EOL><DEDENT>else:<EOL><INDENT>return self._resolve_non_literal_route(method, path)<EOL><DEDENT>", "docstring": "Resolve a request to a route handler.\n\n        Arguments:\n          method (str): HTTP method, e.g. GET, POST, etc. (type: str)\n          path (str): Request path\n\n        Returns:\n          tuple or None: A tuple of three items:\n\n            1. Route handler (callable)\n            2. Positional arguments (list)\n            3. Keyword arguments (dict)\n\n          ``None`` if no route matches the request.", "id": "f4315:c1:m3"}
{"signature": "def parse(text, encoding='<STR_LIT:utf-8>', handler=None, **defaults):", "body": "<EOL>text = u(text, encoding).strip()<EOL>metadata = defaults.copy()<EOL>handler = handler or detect_format(text, handlers)<EOL>if handler is None:<EOL><INDENT>return metadata, text<EOL><DEDENT>try:<EOL><INDENT>fm, content = handler.split(text)<EOL><DEDENT>except ValueError:<EOL><INDENT>return metadata, text<EOL><DEDENT>fm = handler.load(fm)<EOL>if isinstance(fm, dict):<EOL><INDENT>metadata.update(fm)<EOL><DEDENT>return metadata, content.strip()<EOL>", "docstring": "Parse text with frontmatter, return metadata and content.\nPass in optional metadata defaults as keyword args.\n\nIf frontmatter is not found, returns an empty metadata dictionary\n(or defaults) and original text content.\n\n::\n\n    >>> with open('tests/hello-world.markdown') as f:\n    ...     metadata, content = frontmatter.parse(f.read())\n    >>> print(metadata['title'])\n    Hello, world!", "id": "f4320:m1"}
{"signature": "def load(fd, encoding='<STR_LIT:utf-8>', handler=None, **defaults):", "body": "if hasattr(fd, '<STR_LIT>'):<EOL><INDENT>text = fd.read()<EOL><DEDENT>else:<EOL><INDENT>with codecs.open(fd, '<STR_LIT:r>', encoding) as f:<EOL><INDENT>text = f.read()<EOL><DEDENT><DEDENT>handler = handler or detect_format(text, handlers)<EOL>return loads(text, encoding, handler, **defaults)<EOL>", "docstring": "Load and parse a file-like object or filename, \nreturn a :py:class:`post <frontmatter.Post>`.\n\n::\n\n    >>> post = frontmatter.load('tests/hello-world.markdown')\n    >>> with open('tests/hello-world.markdown') as f:\n    ...     post = frontmatter.load(f)", "id": "f4320:m2"}
{"signature": "def __setitem__(self, name, value):", "body": "self.metadata[name] = value<EOL>", "docstring": "Set a metadata key", "id": "f4320:c0:m3"}
{"signature": "def load(self, fm):", "body": "raise NotImplementedError<EOL>", "docstring": "Parse frontmatter and return a dict", "id": "f4321:c0:m3"}
{"signature": "def detect(self, text):", "body": "if self.FM_BOUNDARY.match(text):<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Decide whether this handler can parse the given ``text``,\nand return True or False.\n\nNote that this is *not* called when passing a handler instance to \n:py:func:`frontmatter.load <frontmatter.load>` or :py:func:`loads <frontmatter.loads>`.", "id": "f4321:c0:m1"}
{"signature": "def load(self, fm, **kwargs):", "body": "kwargs.setdefault('<STR_LIT>', SafeLoader)<EOL>return yaml.load(fm, **kwargs)<EOL>", "docstring": "Parse YAML front matter. This uses yaml.SafeLoader by default.", "id": "f4321:c1:m0"}
{"signature": "def export(self, metadata, **kwargs):", "body": "raise NotImplementedError<EOL>", "docstring": "Turn metadata back into text", "id": "f4321:c0:m4"}
{"signature": "def setup_mock_redmine_server(max_failures=<NUM_LIT:0>):", "body": "http_requests = []<EOL>failures = max_failures<EOL>issues_body = read_file('<STR_LIT>', '<STR_LIT:rb>')<EOL>issues_next_body = read_file('<STR_LIT>', '<STR_LIT:rb>')<EOL>issues_empty_body = read_file('<STR_LIT>', '<STR_LIT:rb>')<EOL>issue_2_body = read_file('<STR_LIT>', '<STR_LIT:rb>')<EOL>issue_5_body = read_file('<STR_LIT>', '<STR_LIT:rb>')<EOL>issue_9_body = read_file('<STR_LIT>', '<STR_LIT:rb>')<EOL>issue_7311_body = read_file('<STR_LIT>', '<STR_LIT:rb>')<EOL>user_3_body = read_file('<STR_LIT>', '<STR_LIT:rb>')<EOL>user_4_body = read_file('<STR_LIT>', '<STR_LIT:rb>')<EOL>user_24_body = read_file('<STR_LIT>', '<STR_LIT:rb>')<EOL>user_25_body = read_file('<STR_LIT>', '<STR_LIT:rb>')<EOL>def request_callback(method, uri, headers):<EOL><INDENT>nonlocal failures<EOL>status = <NUM_LIT:200><EOL>last_request = httpretty.last_request()<EOL>params = last_request.querystring<EOL>if uri.startswith(REDMINE_ISSUES_URL):<EOL><INDENT>updated_on = params['<STR_LIT>'][<NUM_LIT:0>]<EOL>offset = params['<STR_LIT>'][<NUM_LIT:0>]<EOL>if (updated_on == '<STR_LIT>' and offset == '<STR_LIT:0>'):<EOL><INDENT>body = issues_body<EOL><DEDENT>elif (updated_on == '<STR_LIT>' and offset == '<STR_LIT:3>'):<EOL><INDENT>body = issues_next_body<EOL><DEDENT>elif (updated_on == '<STR_LIT>' and offset == '<STR_LIT:0>'):<EOL><INDENT>body = issues_next_body<EOL><DEDENT>elif (updated_on == '<STR_LIT>' and offset == '<STR_LIT:0>'):<EOL><INDENT>body = issues_next_body<EOL><DEDENT>else:<EOL><INDENT>body = issues_empty_body<EOL><DEDENT><DEDENT>elif uri.startswith(REDMINE_ISSUE_2_URL):<EOL><INDENT>body = issue_2_body<EOL><DEDENT>elif uri.startswith(REDMINE_ISSUE_5_URL):<EOL><INDENT>body = issue_5_body<EOL><DEDENT>elif uri.startswith(REDMINE_ISSUE_9_URL):<EOL><INDENT>body = issue_9_body<EOL><DEDENT>elif uri.startswith(REDMINE_ISSUE_7311_URL):<EOL><INDENT>if failures > <NUM_LIT:0>:<EOL><INDENT>status = <NUM_LIT><EOL>body = \"<STR_LIT>\"<EOL>failures -= <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>body = issue_7311_body<EOL><DEDENT><DEDENT>elif uri.startswith(REDMINE_USER_3_URL):<EOL><INDENT>body = user_3_body<EOL><DEDENT>elif uri.startswith(REDMINE_USER_4_URL):<EOL><INDENT>body = user_4_body<EOL><DEDENT>elif uri.startswith(REDMINE_USER_24_URL):<EOL><INDENT>body = user_24_body<EOL><DEDENT>elif uri.startswith(REDMINE_USER_25_URL):<EOL><INDENT>body = user_25_body<EOL><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT>http_requests.append(last_request)<EOL>return (status, headers, body)<EOL><DEDENT>for url in REDMINE_URL_LIST:<EOL><INDENT>httpretty.register_uri(httpretty.GET,<EOL>url,<EOL>responses=[<EOL>httpretty.Response(body=request_callback)<EOL>])<EOL><DEDENT>return http_requests<EOL>", "docstring": "Setup a mock Redmine HTTP server", "id": "f4328:m2"}
{"signature": "@staticmethod<EOL><INDENT>def _build_job_arguments(task):<DEDENT>", "body": "job_args = {}<EOL>job_args['<STR_LIT>'] = Q_STORAGE_ITEMS<EOL>job_args['<STR_LIT>'] = task.task_id<EOL>job_args['<STR_LIT>'] = task.backend<EOL>backend_args = copy.deepcopy(task.backend_args)<EOL>if '<STR_LIT>' in backend_args:<EOL><INDENT>backend_args['<STR_LIT>'] = backend_args.pop('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT>' in backend_args:<EOL><INDENT>backend_args['<STR_LIT>'] = backend_args.pop('<STR_LIT>')<EOL><DEDENT>job_args['<STR_LIT>'] = backend_args<EOL>job_args['<STR_LIT>'] = task.category<EOL>archiving_cfg = task.archiving_cfg<EOL>job_args['<STR_LIT>'] = archiving_cfg.to_dict() if archiving_cfg else None<EOL>sched_cfg = task.scheduling_cfg<EOL>job_args['<STR_LIT>'] = sched_cfg.max_retries if sched_cfg else MAX_JOB_RETRIES<EOL>return job_args<EOL>", "docstring": "Build the set of arguments required for running a job", "id": "f4335:c2:m6"}
{"signature": "def run(self):", "body": "try:<EOL><INDENT>self.listen()<EOL><DEDENT>except Exception as e:<EOL><INDENT>logger.critical(\"<STR_LIT>\", str(e))<EOL>logger.critical(traceback.format_exc())<EOL><DEDENT>", "docstring": "Run thread to listen for jobs and reschedule successful ones.", "id": "f4335:c1:m1"}
{"signature": "def cancel_task(self, task_id):", "body": "self.registry.remove(task_id)<EOL>self._scheduler.cancel_job_task(task_id)<EOL>logger.info(\"<STR_LIT>\", task_id)<EOL>", "docstring": "Cancel or 'un-schedule' a task.\n\n        :param task_id: identifier of the task to cancel\n\n        :raises NotFoundError: raised when the requested task is not\n            found in the registry", "id": "f4335:c2:m3"}
{"signature": "def listen(self):", "body": "pubsub = self.conn.pubsub()<EOL>pubsub.subscribe(self.pubsub_channel)<EOL>logger.debug(\"<STR_LIT>\", self.pubsub_channel)<EOL>for msg in pubsub.listen():<EOL><INDENT>logger.debug(\"<STR_LIT>\", str(msg['<STR_LIT:type>']))<EOL>if msg['<STR_LIT:type>'] != '<STR_LIT:message>':<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>continue<EOL><DEDENT>data = pickle.loads(msg['<STR_LIT:data>'])<EOL>job_id = data['<STR_LIT>']<EOL>job = rq.job.Job.fetch(job_id, connection=self.conn)<EOL>if data['<STR_LIT:status>'] == '<STR_LIT>':<EOL><INDENT>logging.debug(\"<STR_LIT>\", job_id)<EOL>handler = self.result_handler<EOL><DEDENT>elif data['<STR_LIT:status>'] == '<STR_LIT>':<EOL><INDENT>logging.debug(\"<STR_LIT>\", job_id)<EOL>handler = self.result_handler_err<EOL><DEDENT>else:<EOL><INDENT>continue<EOL><DEDENT>if handler:<EOL><INDENT>logging.debug(\"<STR_LIT>\", job_id)<EOL>handler(job)<EOL><DEDENT><DEDENT>", "docstring": "Listen for completed jobs and reschedule successful ones.", "id": "f4335:c1:m2"}
{"signature": "def initialize_archive_manager(self, archive_path):", "body": "if archive_path == \"<STR_LIT>\":<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if archive_path:<EOL><INDENT>self.archive_manager = perceval.archive.ArchiveManager(archive_path)<EOL><DEDENT>", "docstring": "Initialize the archive manager.\n\n        :param archive_path: path where the archive manager is located", "id": "f4337:c1:m2"}
{"signature": "@cherrypy.expose<EOL><INDENT>@cherrypy.tools.json_in()<EOL>@cherrypy.tools.json_out(handler=json_encoder)<EOL>def remove(self):<DEDENT>", "body": "payload = cherrypy.request.json<EOL>logger.debug(\"<STR_LIT>\")<EOL>task_ids = {}<EOL>for task_data in payload['<STR_LIT>']:<EOL><INDENT>task_id = task_data['<STR_LIT>']<EOL>removed = super().remove_task(task_id)<EOL>task_ids[task_id] = removed<EOL><DEDENT>result = {'<STR_LIT>': task_ids}<EOL>return result<EOL>", "docstring": "Remove tasks", "id": "f4338:c0:m4"}
{"signature": "@cherrypy.expose<EOL><INDENT>@cherrypy.tools.json_in()<EOL>def add(self):<DEDENT>", "body": "payload = cherrypy.request.json<EOL>logger.debug(\"<STR_LIT>\")<EOL>for task_data in payload['<STR_LIT>']:<EOL><INDENT>try:<EOL><INDENT>category = task_data['<STR_LIT>']<EOL>backend_args = task_data['<STR_LIT>']<EOL>archive_args = task_data.get('<STR_LIT>', None)<EOL>sched_args = task_data.get('<STR_LIT>', None)<EOL><DEDENT>except KeyError as ex:<EOL><INDENT>logger.error(\"<STR_LIT>\")<EOL>raise ex<EOL><DEDENT>from_date = backend_args.get('<STR_LIT>', None)<EOL>if from_date:<EOL><INDENT>backend_args['<STR_LIT>'] = str_to_datetime(from_date)<EOL><DEDENT>super().add_task(task_data['<STR_LIT>'],<EOL>task_data['<STR_LIT>'],<EOL>category,<EOL>backend_args,<EOL>archive_args=archive_args,<EOL>sched_args=sched_args)<EOL><DEDENT>logger.debug(\"<STR_LIT>\")<EOL>return \"<STR_LIT>\"<EOL>", "docstring": "Add tasks", "id": "f4338:c0:m3"}
{"signature": "def remove(self, task_id):", "body": "try:<EOL><INDENT>self._rwlock.writer_acquire()<EOL>del self._tasks[task_id]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise NotFoundError(element=str(task_id))<EOL><DEDENT>finally:<EOL><INDENT>self._rwlock.writer_release()<EOL><DEDENT>logger.debug(\"<STR_LIT>\", str(task_id))<EOL>", "docstring": "Remove a task from the registry.\n\n        To remove it, pass its identifier with `taks_id` parameter.\n        When the identifier is not found, a `NotFoundError` exception\n        is raised.\n\n        :param task_id: identifier of the task to remove\n\n        :raises NotFoundError: raised when the given task identifier\n            is not found on the registry", "id": "f4341:c1:m2"}
{"signature": "def __parse_schedule_args(self, sched_args):", "body": "if not sched_args:<EOL><INDENT>return None<EOL><DEDENT>return SchedulingTaskConfig.from_dict(sched_args)<EOL>", "docstring": "Parse the schedule arguments of a task", "id": "f4342:c0:m7"}
{"signature": "def writer_acquire(self):", "body": "self._order_mutex.acquire()<EOL>self._access_mutex.acquire()<EOL>self._order_mutex.release()<EOL>", "docstring": "Acquire the lock to write", "id": "f4343:c0:m3"}
{"signature": "def __init__(self, api_key, endpoint, domain, start_month, end_month,<EOL>time_granularity=\"<STR_LIT>\", main_domain_only=False):", "body": "if endpoint not in [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>raise InvalidEndpointException(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>self.endpoint = endpoint<EOL>self.domain = utils.domain_from_url(domain)<EOL>self.start_month = start_month<EOL>self.end_month = end_month<EOL>self.time_granularity = time_granularity<EOL>self.main_domain_only = main_domain_only<EOL>super(EngagementAPI, self).__init__(api_key)<EOL>", "docstring": "Parameters\n----------\napi_key: string\n    SimilarWeb API key\n\nendpoint: string\n    Endpoint to use. Can be: pageviews, visitduration, bouncerate\n\ndomain: string\n    Domain to query.\n\nstart_month: string\n    Start Month in (M-YYYY) format\n\nend_month: string\n    End Month in (M-YYYY) format\n\ntime_granularity: string\n    Time granularity of report. Can be: Daily, Weekly, Monthly\n\nmain_domain_only: boolean\n    Get metrics on the Main Domain only (i.e. not including subdomains)", "id": "f4346:c3:m0"}
{"signature": "def __init__(self, api_key, domain, start_month, end_month,<EOL>main_domain_only=False, results_page=None):", "body": "self.domain = utils.domain_from_url(domain)<EOL>self.start_month = start_month<EOL>self.end_month = end_month<EOL>self.main_domain_only = main_domain_only<EOL>self.results_page = results_page<EOL>super(ReferralsAPI, self).__init__(api_key)<EOL>", "docstring": "Parameters\n----------\napi_key: string\n    SimilarWeb API key\n\ndomain: string\n    Domain to query.\n\nstart_month: string\n    Start Month in (M-YYYY) format\n\nend_month: string\n    End Month in (M-YYYY) format\n\nmain_domain_only: boolean\n    Get metrics on the Main Domain only (i.e. not including subdomains)\n\nresults_page: integer\n    Enter for more than 10 results", "id": "f4346:c13:m0"}
{"signature": "def __init__(self, api_key, domain, start_month, end_month,<EOL>time_granularity=\"<STR_LIT>\", main_domain_only=False):", "body": "self.domain = utils.domain_from_url(domain)<EOL>self.start_month = start_month<EOL>self.end_month = end_month<EOL>self.time_granularity = time_granularity<EOL>self.main_domain_only = main_domain_only<EOL>super(TrafficAPI, self).__init__(api_key)<EOL>", "docstring": "Parameters\n----------\napi_key: string\n    SimilarWeb API key\n\ndomain: string\n    Domain to query.\n\nstart_month: string\n    Start Month in (M-YYYY) format\n\nend_month: string\n    End Month in (M-YYYY) format\n\ntime_granularity: string\n    Time granularity of report. Can be: Daily, Weekly, Monthly\n\nmain_domain_only: boolean\n    Get metrics on the Main Domain only (i.e. not including subdomains)", "id": "f4346:c1:m0"}
{"signature": "def __init__(self, api_key, category=None, country=None):", "body": "self.category = category<EOL>self.country = country<EOL>super(TopSitesAPI, self).__init__(api_key)<EOL>", "docstring": "Parameters\n----------\napi_key: string\n    SimilarWeb API key\n\ncategory: string\n    If left blank, `All Categories` will be requested.\n    Use `http://api.similarweb.com/v1/TopSites/categories` to get a list of available categories.\n\ncountry: string\n    If left blank, `Worldwide` will be requested.\n    Use `http://api.similarweb.com/v1/TopSites/countries` to get a list of available categories.", "id": "f4346:c9:m0"}
{"signature": "def __init__(self, api_key, endpoint, domain, start_month, end_month,<EOL>main_domain_only=False, results_page=None):", "body": "if endpoint not in [\"<STR_LIT>\", \"<STR_LIT>\", ]:<EOL><INDENT>raise InvalidEndpointException(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>self.domain = utils.domain_from_url(domain)<EOL>self.endpoint = endpoint<EOL>self.start_month = start_month<EOL>self.end_month = end_month<EOL>self.main_domain_only = main_domain_only<EOL>self.results_page = results_page<EOL>super(SearchKeywordsAPI, self).__init__(api_key)<EOL>", "docstring": "Parameters\n----------\napi_key: string\n    SimilarWeb API key\n\nendpoint: string\n    Endpoint to use. Can be: orgsearch, paidsearch\n\ndomain: string\n    Domain to query.\n\nstart_month: string\n    Start Month in (M-YYYY) format\n\nend_month: string\n    End Month in (M-YYYY) format\n\nmain_domain_only: boolean\n    Get metrics on the Main Domain only (i.e. not including subdomains)\n\nresults_page: integer\n    Enter for more than 10 results", "id": "f4346:c11:m0"}
{"signature": "def __init__(self, api_key, domain):", "body": "self.domain = utils.domain_from_url(domain)<EOL>super(DestinationsAPI, self).__init__(api_key)<EOL>", "docstring": "Parameters\n----------\napi_key: string\n    SimilarWeb API key\n\ndomain: string\n    Domain to query.", "id": "f4346:c12:m0"}
{"signature": "def __init__(self, api_key, domain):", "body": "self.domain = utils.domain_from_url(domain)<EOL>super(AlsoVisitedAPI, self).__init__(api_key)<EOL>", "docstring": "Parameters\n----------\napi_key: string\n    SimilarWeb API key\n\ndomain: string\n    Domain to query.", "id": "f4346:c5:m0"}
{"signature": "def __init__(self, api_key, domain):", "body": "self.domain = utils.domain_from_url(domain)<EOL>super(WebsiteTagsAPI, self).__init__(api_key)<EOL>", "docstring": "Parameters\n----------\napi_key: string\n    SimilarWeb API key\n\ndomain: string\n    Domain to query.", "id": "f4346:c6:m0"}
{"signature": "def domain_from_url(url):", "body": "ext = tldextract.extract(url)<EOL>if not ext.suffix:<EOL><INDENT>raise InvalidURLException()<EOL><DEDENT>new_url = ext.domain + \"<STR_LIT:.>\" + ext.suffix<EOL>return new_url<EOL>", "docstring": "Get root domain from url.\nWill prune away query strings, url paths, protocol prefix and sub-domains\nExceptions will be raised on invalid urls", "id": "f4348:m0"}
{"signature": "@staticmethod<EOL><INDENT>def _parse_yaml(yaml='<STR_LIT>'):<DEDENT>", "body": "<EOL>return CarddavObject.from_user_input(<EOL>address_book=mock.Mock(path='<STR_LIT>'), user_input=yaml,<EOL>supported_private_objects=[], version='<STR_LIT>',<EOL>localize_dates=False)<EOL>", "docstring": "Parse some yaml string into a CarddavObject\n\n        :param yaml: the yaml input string to parse\n        :type yaml: str\n        :returns: the parsed CarddavObject\n        :rtype: CarddavObject", "id": "f4362:c0:m0"}
{"signature": "def phone_subcommand(search_terms, vcard_list, parsable):", "body": "all_phone_numbers_list = []<EOL>matching_phone_number_list = []<EOL>for vcard in vcard_list:<EOL><INDENT>for type, number_list in sorted(vcard.get_phone_numbers().items(),<EOL>key=lambda k: k[<NUM_LIT:0>].lower()):<EOL><INDENT>for number in sorted(number_list):<EOL><INDENT>if config.display_by_name() == \"<STR_LIT>\":<EOL><INDENT>name = vcard.get_first_name_last_name()<EOL><DEDENT>else:<EOL><INDENT>name = vcard.get_last_name_first_name()<EOL><DEDENT>line_formatted = \"<STR_LIT:\\t>\".join([name, type, number])<EOL>line_parsable = \"<STR_LIT:\\t>\".join([number, name, type])<EOL>if parsable:<EOL><INDENT>phone_number_line = line_parsable<EOL><DEDENT>else:<EOL><INDENT>phone_number_line = line_formatted<EOL><DEDENT>if re.search(search_terms,<EOL>\"<STR_LIT>\" % (line_formatted, line_parsable),<EOL>re.IGNORECASE | re.DOTALL):<EOL><INDENT>matching_phone_number_list.append(phone_number_line)<EOL><DEDENT>elif len(re.sub(\"<STR_LIT>\", \"<STR_LIT>\", search_terms)) >= <NUM_LIT:3>:<EOL><INDENT>if re.search(re.sub(\"<STR_LIT>\", \"<STR_LIT>\", search_terms),<EOL>re.sub(\"<STR_LIT>\", \"<STR_LIT>\", number), re.IGNORECASE):<EOL><INDENT>matching_phone_number_list.append(phone_number_line)<EOL><DEDENT><DEDENT>all_phone_numbers_list.append(phone_number_line)<EOL><DEDENT><DEDENT><DEDENT>if matching_phone_number_list:<EOL><INDENT>if parsable:<EOL><INDENT>print('<STR_LIT:\\n>'.join(matching_phone_number_list))<EOL><DEDENT>else:<EOL><INDENT>list_phone_numbers(matching_phone_number_list)<EOL><DEDENT><DEDENT>elif all_phone_numbers_list:<EOL><INDENT>if parsable:<EOL><INDENT>print('<STR_LIT:\\n>'.join(all_phone_numbers_list))<EOL><DEDENT>else:<EOL><INDENT>list_phone_numbers(all_phone_numbers_list)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if not parsable:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Print a phone application friendly contact table.\n\n    :param search_terms: used as search term to filter the contacts before\n        printing\n    :type search_terms: str\n    :param vcard_list: the vcards to search for matching entries which should\n        be printed\n    :type vcard_list: list of carddav_object.CarddavObject\n    :param parsable: machine readable output: columns devided by tabulator (\\t)\n    :type parsable: bool\n    :returns: None\n    :rtype: None", "id": "f4369:m22"}
{"signature": "def copy_or_move_subcommand(action, vcard_list, target_address_book_list):", "body": "<EOL>source_vcard = choose_vcard_from_list(<EOL>\"<STR_LIT>\" % action.title(), vcard_list)<EOL>if source_vcard is None:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\"<EOL>% (action.title(), source_vcard, source_vcard.address_book))<EOL><DEDENT>if len(target_address_book_list) == <NUM_LIT:1>and target_address_book_list[<NUM_LIT:0>] == source_vcard.address_book:<EOL><INDENT>print(\"<STR_LIT>\"<EOL>% (target_address_book_list[<NUM_LIT:0>], source_vcard))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>available_address_books = [abook for abook in target_address_book_list<EOL>if abook != source_vcard.address_book]<EOL>selected_target_address_book = choose_address_book_from_list(<EOL>\"<STR_LIT>\", available_address_books)<EOL>if selected_target_address_book is None:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>target_vcard = choose_vcard_from_list(<EOL>\"<STR_LIT>\",<EOL>get_contact_list_by_user_selection([selected_target_address_book],<EOL>source_vcard.get_full_name(), True))<EOL>if target_vcard is None:<EOL><INDENT>copy_contact(source_vcard, selected_target_address_book,<EOL>action == \"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>if source_vcard == target_vcard:<EOL><INDENT>print(\"<STR_LIT>\" % target_vcard)<EOL>if action == \"<STR_LIT>\":<EOL><INDENT>copy_contact(source_vcard, selected_target_address_book, True)<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (<EOL>target_vcard.address_book, source_vcard,<EOL>source_vcard.print_vcard(), target_vcard.print_vcard(),<EOL>\"<STR_LIT>\" if action == \"<STR_LIT>\" else \"<STR_LIT>\"))<EOL>while True:<EOL><INDENT>input_string = input(\"<STR_LIT>\")<EOL>if input_string.lower() == \"<STR_LIT:a>\":<EOL><INDENT>copy_contact(source_vcard, selected_target_address_book,<EOL>action == \"<STR_LIT>\")<EOL>break<EOL><DEDENT>if input_string.lower() == \"<STR_LIT:o>\":<EOL><INDENT>copy_contact(source_vcard, selected_target_address_book,<EOL>action == \"<STR_LIT>\")<EOL>target_vcard.delete_vcard_file()<EOL>break<EOL><DEDENT>if input_string.lower() == \"<STR_LIT:m>\":<EOL><INDENT>merge_existing_contacts(source_vcard, target_vcard,<EOL>action == \"<STR_LIT>\")<EOL>break<EOL><DEDENT>if input_string.lower() in [\"<STR_LIT>\", \"<STR_LIT:q>\"]:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Copy or move a contact to a different address book.\n\n    :action: the string \"copy\" or \"move\" to indicate what to do\n    :type action: str\n    :param vcard_list: the contact list from which to select one for the action\n    :type vcard_list: list of carddav_object.CarddavObject\n    :param target_address_book_list: the list of target address books\n    :type target_address_book_list: list(addressbook.AddressBook)\n    :returns: None\n    :rtype: None", "id": "f4369:m30"}
{"signature": "def get_last_name_first_name(self):", "body": "last_names = []<EOL>if self._get_last_names():<EOL><INDENT>last_names += self._get_last_names()<EOL><DEDENT>first_and_additional_names = []<EOL>if self._get_first_names():<EOL><INDENT>first_and_additional_names += self._get_first_names()<EOL><DEDENT>if self._get_additional_names():<EOL><INDENT>first_and_additional_names += self._get_additional_names()<EOL><DEDENT>if last_names and first_and_additional_names:<EOL><INDENT>return \"<STR_LIT>\".format(<EOL>helpers.list_to_string(last_names, \"<STR_LIT:U+0020>\"),<EOL>helpers.list_to_string(first_and_additional_names, \"<STR_LIT:U+0020>\"))<EOL><DEDENT>elif last_names:<EOL><INDENT>return helpers.list_to_string(last_names, \"<STR_LIT:U+0020>\")<EOL><DEDENT>elif first_and_additional_names:<EOL><INDENT>return helpers.list_to_string(first_and_additional_names, \"<STR_LIT:U+0020>\")<EOL><DEDENT>else:<EOL><INDENT>return self.get_full_name()<EOL><DEDENT>", "docstring": ":rtype: str", "id": "f4370:c0:m23"}
{"signature": "def get_anniversary(self):", "body": "<EOL>try:<EOL><INDENT>if self.vcard.anniversary.params.get(\"<STR_LIT>\")[<NUM_LIT:0>] == \"<STR_LIT:text>\":<EOL><INDENT>return self.vcard.anniversary.value<EOL><DEDENT><DEDENT>except (AttributeError, IndexError, TypeError):<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>return helpers.string_to_date(self.vcard.anniversary.value)<EOL><DEDENT>except (AttributeError, ValueError):<EOL><INDENT>try:<EOL><INDENT>return helpers.string_to_date(self.vcard.x_anniversary.value)<EOL><DEDENT>except (AttributeError, ValueError):<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": ":returns: contacts anniversary or None if not available\n            :rtype: datetime.datetime or str", "id": "f4370:c0:m48"}
{"signature": "@classmethod<EOL><INDENT>def from_file(cls, address_book, filename, supported_private_objects,<EOL>localize_dates):<DEDENT>", "body": "return cls(address_book, filename, supported_private_objects, None,<EOL>localize_dates)<EOL>", "docstring": "Use this if you want to create a new contact from an existing .vcf\nfile.", "id": "f4370:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def new_contact(cls, address_book, supported_private_objects, version,<EOL>localize_dates):<DEDENT>", "body": "return cls(address_book, None, supported_private_objects, version,<EOL>localize_dates)<EOL>", "docstring": "Use this to create a new and empty contact.", "id": "f4370:c0:m1"}
{"signature": "def get_nicknames(self):", "body": "nicknames = []<EOL>for child in self.vcard.getChildren():<EOL><INDENT>if child.name == \"<STR_LIT>\":<EOL><INDENT>nicknames.append(child.value)<EOL><DEDENT><DEDENT>return sorted(nicknames)<EOL>", "docstring": ":rtype: list(list(str))", "id": "f4370:c0:m40"}
{"signature": "def get_post_addresses(self):", "body": "post_adr_dict = {}<EOL>for child in self.vcard.getChildren():<EOL><INDENT>if child.name == \"<STR_LIT>\":<EOL><INDENT>type = helpers.list_to_string(<EOL>self._get_types_for_vcard_object(child, \"<STR_LIT>\"), \"<STR_LIT:U+002CU+0020>\")<EOL>if type not in post_adr_dict:<EOL><INDENT>post_adr_dict[type] = []<EOL><DEDENT>post_adr_dict[type].append(<EOL>{<EOL>\"<STR_LIT>\": child.value.box,<EOL>\"<STR_LIT>\": child.value.extended,<EOL>\"<STR_LIT>\": child.value.street,<EOL>\"<STR_LIT:code>\": child.value.code,<EOL>\"<STR_LIT>\": child.value.city,<EOL>\"<STR_LIT>\": child.value.region,<EOL>\"<STR_LIT>\": child.value.country<EOL>})<EOL><DEDENT><DEDENT>for post_adr_list in post_adr_dict.values():<EOL><INDENT>post_adr_list.sort(key=lambda x: (<EOL>helpers.list_to_string(x['<STR_LIT>'], \"<STR_LIT:U+0020>\").lower(),<EOL>helpers.list_to_string(x['<STR_LIT>'], \"<STR_LIT:U+0020>\").lower()))<EOL><DEDENT>return post_adr_dict<EOL>", "docstring": ": returns: dict of type and post address list\n:rtype: dict(str, list(dict(str,list|str)))", "id": "f4370:c0:m35"}
{"signature": "def get_phone_numbers(self):", "body": "phone_dict = {}<EOL>for child in self.vcard.getChildren():<EOL><INDENT>if child.name == \"<STR_LIT>\":<EOL><INDENT>type = helpers.list_to_string(<EOL>self._get_types_for_vcard_object(child, \"<STR_LIT>\"), \"<STR_LIT:U+002CU+0020>\")<EOL>if type not in phone_dict:<EOL><INDENT>phone_dict[type] = []<EOL><DEDENT>if child.value.lower().startswith(\"<STR_LIT>\"):<EOL><INDENT>phone_dict[type].append(child.value[<NUM_LIT:4>:])<EOL><DEDENT>else:<EOL><INDENT>phone_dict[type].append(child.value)<EOL><DEDENT><DEDENT><DEDENT>for number_list in phone_dict.values():<EOL><INDENT>number_list.sort()<EOL><DEDENT>return phone_dict<EOL>", "docstring": ": returns: dict of type and phone number list\n:rtype: dict(str, list(str))", "id": "f4370:c0:m31"}
{"signature": "def _get_webpages(self):", "body": "urls = []<EOL>for child in self.vcard.getChildren():<EOL><INDENT>if child.name == \"<STR_LIT>\":<EOL><INDENT>urls.append(child.value)<EOL><DEDENT><DEDENT>return sorted(urls)<EOL>", "docstring": ":rtype: list(list(str))", "id": "f4370:c0:m46"}
{"signature": "@classmethod<EOL><INDENT>def from_user_input(cls, address_book, user_input,<EOL>supported_private_objects, version, localize_dates):<DEDENT>", "body": "contact = cls(address_book, None, supported_private_objects, version,<EOL>localize_dates)<EOL>contact._process_user_input(user_input)<EOL>return contact<EOL>", "docstring": "Use this if you want to create a new contact from user input.", "id": "f4370:c0:m3"}
{"signature": "@staticmethod<EOL><INDENT>def _compare_uids(uid1, uid2):<DEDENT>", "body": "sum = <NUM_LIT:0><EOL>for char1, char2 in zip(uid1, uid2):<EOL><INDENT>if char1 == char2:<EOL><INDENT>sum += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>return sum<EOL>", "docstring": "Calculate the minimum length of initial substrings of uid1 and uid2\n        for them to be different.\n\n        :param uid1: first uid to compare\n        :type uid1: str\n        :param uid2: second uid to compare\n        :type uid2: str\n        :returns: the length of the shortes unequal initial substrings\n        :rtype: int", "id": "f4373:c1:m4"}
{"signature": "def __init__(self, name, private_objects=tuple(), localize_dates=True,<EOL>skip=False):", "body": "self._loaded = False<EOL>self.contacts = {}<EOL>self._short_uids = None<EOL>self.name = name<EOL>self._private_objects = private_objects<EOL>self._localize_dates = localize_dates<EOL>self._skip = skip<EOL>", "docstring": ":param name: the name to identify the address book\n:type name: str\n:param private_objects: the names of private vCard extension fields to\n    load\n:type private_objects: iterable(str)\n:param localize_dates: wheater to display dates in the local format\n:type localize_dates: bool\n:param skip: skip unparsable vCard files\n:type skip: bool", "id": "f4373:c1:m0"}
{"signature": "def __init__(self, name, abooks, **kwargs):", "body": "super().__init__(name, **kwargs)<EOL>self._abooks = abooks<EOL>", "docstring": ":param name: the name to identify the address book\n:type name: str\n:param abooks: a list of address books to combine in this collection\n:type abooks: list(AddressBook)\n:param **kwargs: further arguments for the parent constructor", "id": "f4373:c3:m0"}
{"signature": "def _search_names(self, query):", "body": "regexp = re.compile(query, re.IGNORECASE | re.DOTALL)<EOL>for contact in self.contacts.values():<EOL><INDENT>if regexp.search(contact.get_full_name()) is not None:<EOL><INDENT>yield contact<EOL><DEDENT><DEDENT>", "docstring": "Search in the name filed for contacts matching query.\n\n        :param query: the query to search for\n        :type query: str\n        :yields: all found contacts\n        :rtype: generator(carddav_object.CarddavObject)", "id": "f4373:c1:m6"}
{"signature": "def search(self, query, method=\"<STR_LIT:all>\"):", "body": "logging.debug('<STR_LIT>', self.name, query)<EOL>if not self._loaded:<EOL><INDENT>self.load(query)<EOL><DEDENT>if method == \"<STR_LIT:all>\":<EOL><INDENT>search_function = self._search_all<EOL><DEDENT>elif method == \"<STR_LIT:name>\":<EOL><INDENT>search_function = self._search_names<EOL><DEDENT>elif method == \"<STR_LIT>\":<EOL><INDENT>search_function = self._search_uid<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>return list(search_function(query))<EOL>", "docstring": "Search this address book for contacts matching the query.\n\n        The method can be one of \"all\", \"name\" and \"uid\".  The backend for this\n        address book migth be load()ed if needed.\n\n        :param query: the query to search for\n        :type query: str\n        :param method: the type of fileds to use when seaching\n        :type method: str\n        :returns: all found contacts\n        :rtype: list(carddav_object.CarddavObject)", "id": "f4373:c1:m8"}
{"signature": "def _search_uid(self, query):", "body": "try:<EOL><INDENT>yield self.contacts[query]<EOL><DEDENT>except KeyError:<EOL><INDENT>for uid in self.contacts:<EOL><INDENT>if uid.startswith(query):<EOL><INDENT>yield self.contacts[uid]<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Search for contacts with a matching uid.\n\n        :param query: the query to search for\n        :type query: str\n        :yields: all found contacts\n        :rtype: generator(carddav_object.CarddavObject)", "id": "f4373:c1:m7"}
{"signature": "def convert_to_vcard(name, value, allowed_object_type):", "body": "if isinstance(value, str):<EOL><INDENT>if allowed_object_type == ObjectType.list_with_strings:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\" + name + \"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>return value.strip()<EOL><DEDENT><DEDENT>elif isinstance(value, list):<EOL><INDENT>if allowed_object_type == ObjectType.string:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\" + name + \"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>for entry in value:<EOL><INDENT>if not isinstance(entry, str):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\" + name + \"<STR_LIT>\")<EOL><DEDENT><DEDENT>return [x.strip() for x in value if x]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if allowed_object_type == ObjectType.string:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\" + name + \"<STR_LIT>\")<EOL><DEDENT>elif allowed_object_type == ObjectType.list_with_strings:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\" + name + \"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\" + name + \"<STR_LIT>\")<EOL><DEDENT><DEDENT>", "docstring": "converts user input into vcard compatible data structures\n    :param name: object name, only required for error messages\n    :type name: str\n    :param value: user input\n    :type value: str or list(str)\n    :param allowed_object_type: set the accepted return type for vcard\n        attribute\n    :type allowed_object_type: enum of type ObjectType\n    :returns: cleaned user input, ready for vcard or a ValueError\n    :rtype: str or list(str)", "id": "f4374:m7"}
{"signature": "def string_to_date(input):", "body": "<EOL>for format_string in (\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>try:<EOL><INDENT>return datetime.strptime(input, format_string)<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>for format_string in (\"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>try:<EOL><INDENT>return datetime.strptime('<STR_LIT>'.join(input.rsplit(\"<STR_LIT::>\", <NUM_LIT:1>)),<EOL>format_string)<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>raise ValueError<EOL>", "docstring": "Convert string to date object.\n\n    :param input: the date string to parse\n    :type input: str\n    :returns: the parsed datetime object\n    :rtype: datetime.datetime", "id": "f4374:m3"}
{"signature": "def convert_to_yaml(<EOL>name, value, indentation, indexOfColon, show_multi_line_character):", "body": "strings = []<EOL>if isinstance(value, list):<EOL><INDENT>if len(value) == <NUM_LIT:1>and isinstance(value[<NUM_LIT:0>], str):<EOL><INDENT>value = value[<NUM_LIT:0>]<EOL><DEDENT>elif len(value) == <NUM_LIT:1>and isinstance(value[<NUM_LIT:0>], list)and len(value[<NUM_LIT:0>]) == <NUM_LIT:1>and isinstance(value[<NUM_LIT:0>][<NUM_LIT:0>], str):<EOL><INDENT>value = value[<NUM_LIT:0>][<NUM_LIT:0>]<EOL><DEDENT><DEDENT>if isinstance(value, str):<EOL><INDENT>strings.append(\"<STR_LIT>\" % (<EOL>'<STR_LIT:U+0020>' * indentation, name, '<STR_LIT:U+0020>' * (indexOfColon-len(name)),<EOL>indent_multiline_string(value, indentation+<NUM_LIT:4>,<EOL>show_multi_line_character)))<EOL><DEDENT>elif isinstance(value, list):<EOL><INDENT>strings.append(\"<STR_LIT>\" % (<EOL>'<STR_LIT:U+0020>' * indentation, name, '<STR_LIT:U+0020>' * (indexOfColon-len(name))))<EOL>for outer in value:<EOL><INDENT>if isinstance(outer, list)and len(outer) == <NUM_LIT:1>and isinstance(outer[<NUM_LIT:0>], str):<EOL><INDENT>outer = outer[<NUM_LIT:0>]<EOL><DEDENT>if isinstance(outer, str):<EOL><INDENT>strings.append(\"<STR_LIT>\" % (<EOL>'<STR_LIT:U+0020>' * (indentation+<NUM_LIT:4>), indent_multiline_string(<EOL>outer, indentation+<NUM_LIT:8>, show_multi_line_character)))<EOL><DEDENT>elif isinstance(outer, list):<EOL><INDENT>strings.append(\"<STR_LIT>\" % ('<STR_LIT:U+0020>' * (indentation+<NUM_LIT:4>)))<EOL>for inner in outer:<EOL><INDENT>if isinstance(inner, str):<EOL><INDENT>strings.append(\"<STR_LIT>\" % (<EOL>'<STR_LIT:U+0020>' * (indentation+<NUM_LIT:8>), indent_multiline_string(<EOL>inner, indentation+<NUM_LIT:12>,<EOL>show_multi_line_character)))<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>return strings<EOL>", "docstring": "converts a value list into yaml syntax\n    :param name: name of object (example: phone)\n    :type name: str\n    :param value: object contents\n    :type value: str, list(str), list(list(str))\n    :param indentation: indent all by number of spaces\n    :type indentation: int\n    :param indexOfColon: use to position : at the name string (-1 for no space)\n    :type indexOfColon: int\n    :param show_multi_line_character: option to hide \"|\"\n    :type show_multi_line_character: boolean\n    :returns: yaml formatted string array of name, value pair\n    :rtype: list(str)", "id": "f4374:m6"}
{"signature": "def list_to_string(input, delimiter):", "body": "if isinstance(input, list):<EOL><INDENT>return delimiter.join(<EOL>list_to_string(item, delimiter) for item in input)<EOL><DEDENT>return input<EOL>", "docstring": "converts list to string recursively so that nested lists are supported\n\n    :param input: a list of strings and lists of strings (and so on recursive)\n    :type input: list\n    :param delimiter: the deimiter to use when joining the items\n    :type delimiter: str\n    :returns: the recursively joined list\n    :rtype: str", "id": "f4374:m1"}
{"signature": "@classmethod<EOL><INDENT>def get_action(cls, alias):<DEDENT>", "body": "for action, alias_list in cls.action_map.items():<EOL><INDENT>if alias in alias_list:<EOL><INDENT>return action<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Find the name of the action for the supplied alias.  If no action is\n        asociated with the given alias, None is returned.\n\n        :param alias: the alias to look up\n        :type alias: str\n        :rturns: the name of the corresponding action or None\n        :rtype: str or NoneType", "id": "f4375:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def get_actions(cls):<DEDENT>", "body": "return cls.action_map.keys()<EOL>", "docstring": "Find the names of all defined actions.\n\n        :returns: all action names\n        :rtype: iterable(str)", "id": "f4375:c0:m2"}
{"signature": "def invalid_dict_pickle_keys(self, msg_dict):", "body": "no_pickle_keys = list()<EOL>for key, val in msg_dict.items():<EOL><INDENT>try:<EOL><INDENT>pickle.dumps(key)<EOL>pickle.dumps(val)<EOL><DEDENT>except TypeError:<EOL><INDENT>no_pickle_keys.append(key)  <EOL><DEDENT>except pickle.PicklingError:<EOL><INDENT>no_pickle_keys.append(key)  <EOL><DEDENT>except pickle.UnpickleableError:<EOL><INDENT>no_pickle_keys.append(key)  <EOL><DEDENT><DEDENT>return no_pickle_keys<EOL>", "docstring": "Return a list of keys that can't be pickled.  Return [] if \n        there are no pickling problems with the values associated with the\n        keys.  Return the list of keys, if there are problems.", "id": "f4376:c2:m11"}
{"signature": "def respawn_dead_workers(self):", "body": "for w_id, p in self.workers.items():<EOL><INDENT>if not p.is_alive():<EOL><INDENT>if self.log_level >= <NUM_LIT:2>:<EOL><INDENT>self.log.info(\"<STR_LIT>\".format(w_id))<EOL><DEDENT>task = self.worker_assignments.get(w_id, {})<EOL>if self.log_level >= <NUM_LIT:2> and task != {}:<EOL><INDENT>self.log.info(<EOL>\"<STR_LIT>\".format(<EOL>w_id, task<EOL>)<EOL>)<EOL><DEDENT>error_suffix = \"<STR_LIT>\"<EOL>if task != {}:<EOL><INDENT>del self.worker_assignments[w_id]<EOL>if self.resubmit_on_error or self.hot_loop:<EOL><INDENT>self.work_todo.append(task)<EOL>self.queue_task(task)<EOL>if self.log_level >= <NUM_LIT:2>:<EOL><INDENT>self.log.info(\"<STR_LIT>\".format(task))<EOL><DEDENT>error_suffix = \"<STR_LIT>\".format(task)<EOL><DEDENT><DEDENT>if self.log_level >= <NUM_LIT:1>:<EOL><INDENT>self.log.debug(<EOL>\"<STR_LIT>\".format(len(self.work_todo))<EOL>)<EOL><DEDENT>if self.log_level >= <NUM_LIT:2>:<EOL><INDENT>self.log.info(<EOL>\"<STR_LIT>\".format(w_id, error_suffix)<EOL>)<EOL><DEDENT>self.workers[w_id] = Process(<EOL>target=Worker,<EOL>args=(w_id, self.t_q, self.r_q, self.worker_cycle_sleep),<EOL>)<EOL>self.workers[w_id].daemon = True<EOL>self.workers[w_id].start()<EOL><DEDENT><DEDENT>", "docstring": "Respawn workers / tasks upon crash", "id": "f4376:c2:m8"}
{"signature": "def message_loop(self, t_q, r_q):", "body": "t_msg = {}<EOL>while t_msg.get(\"<STR_LIT:state>\", \"<STR_LIT>\") != \"<STR_LIT>\":<EOL><INDENT>try:<EOL><INDENT>t_msg = t_q.get(True, self.cycle_sleep)  <EOL>self.task = t_msg.get(\"<STR_LIT>\", \"<STR_LIT>\")  <EOL>if self.task != \"<STR_LIT>\":<EOL><INDENT>self.task.task_start = time.time()  <EOL>self.r_q_send(<EOL>{\"<STR_LIT>\": self.w_id, \"<STR_LIT>\": self.task, \"<STR_LIT:state>\": \"<STR_LIT>\"}<EOL>)<EOL>self.cycle_sleep = self.task.worker_loop_delay<EOL>self.task.result = self.task.run()<EOL>self.task.task_stop = time.time()  <EOL>self.r_q_send(<EOL>{\"<STR_LIT>\": self.w_id, \"<STR_LIT>\": self.task, \"<STR_LIT:state>\": \"<STR_LIT>\"}<EOL>)  <EOL>self.task = None<EOL><DEDENT><DEDENT>except Empty:<EOL><INDENT>pass<EOL><DEDENT>except Full:<EOL><INDENT>time.sleep(<NUM_LIT:0.1>)<EOL><DEDENT>except:<EOL><INDENT>if self.task is not None:<EOL><INDENT>self.task.task_stop = time.time()  <EOL><DEDENT>tb_str = \"<STR_LIT>\".join(tb.format_exception(*(sys.exc_info())))<EOL>self.r_q_send(<EOL>{<EOL>\"<STR_LIT>\": self.w_id,<EOL>\"<STR_LIT>\": self.task,<EOL>\"<STR_LIT:error>\": tb_str,<EOL>\"<STR_LIT:state>\": \"<STR_LIT>\",<EOL>}<EOL>)<EOL><DEDENT><DEDENT>return<EOL>", "docstring": "Loop through messages and execute tasks", "id": "f4376:c0:m4"}
{"signature": "@property<EOL><INDENT>def log_message(self):<DEDENT>", "body": "time_delta = deepcopy(self.time_delta)<EOL>total_work_time = self.worker_count * time_delta<EOL>time_worked = sum(self.exec_times)<EOL>pct_busy = time_worked / total_work_time * <NUM_LIT><EOL>min_task_time = min(self.exec_times)<EOL>avg_task_time = sum(self.exec_times) / len(self.exec_times)<EOL>max_task_time = max(self.exec_times)<EOL>min_queue_time = min(self.queue_times)<EOL>avg_queue_time = sum(self.queue_times) / len(self.queue_times)<EOL>max_queue_time = max(self.queue_times)<EOL>time_delta = self.time_delta<EOL>total_tasks = len(self.exec_times)<EOL>avg_task_rate = total_tasks / time_delta<EOL>self.reset()<EOL>task_msg = \"\"\"<STR_LIT>\"\"\".format(<EOL>total_tasks, round(avg_task_rate, <NUM_LIT:1>), self.worker_count, round(pct_busy, <NUM_LIT:1>)<EOL>)<EOL>task_mam = \"\"\"<STR_LIT>\"\"\".format(<EOL>round(min_task_time, <NUM_LIT:3>), round(avg_task_time, <NUM_LIT:3>), round(max_task_time, <NUM_LIT:3>)<EOL>)<EOL>queue_mam = \"\"\"<STR_LIT>\"\"\".format(<EOL>round(min_queue_time, <NUM_LIT:6>), round(avg_queue_time, <NUM_LIT:6>), round(max_queue_time, <NUM_LIT:6>)<EOL>)<EOL>return \"\"\"<STR_LIT>\"\"\".format(task_msg, task_mam, queue_mam)<EOL>", "docstring": "Build a log message and reset the stats", "id": "f4376:c1:m5"}
{"signature": "@abstractmethod<EOL><INDENT>def run(self):<DEDENT>", "body": "pass<EOL>", "docstring": "Define what should be done", "id": "f4377:c0:m3"}
{"signature": "def main():", "body": "args = get_args()<EOL>ret_code = args.target(args)<EOL>_logger.debug('<STR_LIT>', ret_code)<EOL>sys.exit(ret_code)<EOL>", "docstring": "Main entry point for the CLI.", "id": "f4382:m0"}
{"signature": "def _encode_long(self, val):", "body": "return '<STR_LIT>'.join([<EOL>self.alphabet[(val//len(self.alphabet)**i) % len(self.alphabet)]<EOL>for i in reversed(range(self.chunklen[<NUM_LIT:1>]))<EOL>])<EOL>", "docstring": "encodes an integer of 8*self.chunklen[0] bits using the specified\nalphabet", "id": "f4385:c0:m3"}
{"signature": "def _get_chunk(self, data, index):", "body": "return data[index*self.chunklen[<NUM_LIT:0>]:(index+<NUM_LIT:1>)*self.chunklen[<NUM_LIT:0>]]<EOL>", "docstring": "partition the data into chunks and retrieve the chunk at the given index", "id": "f4385:c0:m5"}
{"signature": "@_uses_db<EOL><INDENT>def get_domain(self, domain_name):<DEDENT>", "body": "protocol = self.database_uri.split('<STR_LIT::>', <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>if protocol in ('<STR_LIT>', '<STR_LIT:http>'):<EOL><INDENT>return self._get_domain_from_rest_api(domain_name)<EOL><DEDENT>else:<EOL><INDENT>domain = self._get_domain_from_db(domain_name)<EOL>if domain:<EOL><INDENT>return domain<EOL><DEDENT>else:<EOL><INDENT>raise NoSuchDomainException<EOL><DEDENT><DEDENT>", "docstring": "Get the :class:`Domain <pwm.Domain>` object from a name.\n\n        :param domain_name: The domain name to fetch the object for.\n        :returns: The :class:`Domain <pwm.core.Domain>` class with this domain_name if found, else\n            None.", "id": "f4386:c1:m3"}
{"signature": "@_uses_db<EOL><INDENT>def search(self, query):<DEDENT>", "body": "results = self.session.query(Domain).filter(Domain.name.ilike('<STR_LIT>' % query)).all()<EOL>return results<EOL>", "docstring": "Search the database for the given query. Will find partial matches.", "id": "f4386:c1:m2"}
{"signature": "def create_domain(self, domain_name, username=None, alphabet=Domain.DEFAULT_ALPHABET,<EOL>length=Domain.DEFAULT_KEY_LENGTH):", "body": "<EOL>try:<EOL><INDENT>return self._create_domain(domain_name, username, alphabet, length)<EOL><DEDENT>except Exception as ex:<EOL><INDENT>_logger.warn(\"<STR_LIT>\", ex)<EOL>raise DuplicateDomainException<EOL><DEDENT>", "docstring": "Create a new domain entry in the database.\n\n        :param username: The username to associate with this domain.\n        :param alphabet: A character set restriction to impose on keys generated for this domain.\n        :param length: The length of the generated key, in case of restrictions on the site.", "id": "f4386:c1:m7"}
{"signature": "@_uses_db<EOL><INDENT>def modify_domain(self, domain_name, new_salt=False, username=None):<DEDENT>", "body": "domain = self._get_domain_from_db(domain_name)<EOL>if domain is None:<EOL><INDENT>raise NoSuchDomainException<EOL><DEDENT>if new_salt:<EOL><INDENT>_logger.info(\"<STR_LIT>\")<EOL>domain.new_salt()<EOL><DEDENT>if username is not None:<EOL><INDENT>domain.username = username<EOL><DEDENT>return domain<EOL>", "docstring": "Modify an existing domain.\n\n        :param domain_name: The name of the domain to modify.\n        :param new_salt: Whether to generate a new salt for the domain.\n        :param username: If given, change domain username to this value.\n        :returns: The modified :class:`Domain <pwm.core.Domain>` object.", "id": "f4386:c1:m6"}
{"signature": "def bootstrap(self, path_or_uri):", "body": "_logger.debug(\"<STR_LIT>\", path_or_uri)<EOL>self.database_uri = _urify_db(path_or_uri)<EOL>db = sa.create_engine(self.database_uri)<EOL>Base.metadata.create_all(db)<EOL>", "docstring": "Initialize a database.\n\n        :param database_path: The absolute path to the database to initialize.", "id": "f4386:c1:m1"}
{"signature": "def get_key(self):", "body": "master_password = getpass.getpass('<STR_LIT>')<EOL>return self.derive_key(master_password)<EOL>", "docstring": "Fetches the key for the domain. Prompts the user for password.\n\n        Thin wrapper around :func:`Domain.derive_key <pwm.core.Domain.derive_key>`.", "id": "f4386:c0:m4"}
{"signature": "def create_dsmr_protocol(dsmr_version, telegram_callback, loop=None):", "body": "if dsmr_version == '<STR_LIT>':<EOL><INDENT>specification = telegram_specifications.V2_2<EOL>serial_settings = SERIAL_SETTINGS_V2_2<EOL><DEDENT>elif dsmr_version == '<STR_LIT:4>':<EOL><INDENT>specification = telegram_specifications.V4<EOL>serial_settings = SERIAL_SETTINGS_V4<EOL><DEDENT>elif dsmr_version == '<STR_LIT:5>':<EOL><INDENT>specification = telegram_specifications.V5<EOL>serial_settings = SERIAL_SETTINGS_V5<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\",<EOL>dsmr_version)<EOL><DEDENT>protocol = partial(DSMRProtocol, loop, TelegramParser(specification),<EOL>telegram_callback=telegram_callback)<EOL>return protocol, serial_settings<EOL>", "docstring": "Creates a DSMR asyncio protocol.", "id": "f4402:m0"}
{"signature": "def create_tcp_dsmr_reader(host, port, dsmr_version,<EOL>telegram_callback, loop=None):", "body": "protocol, _ = create_dsmr_protocol(<EOL>dsmr_version, telegram_callback, loop=None)<EOL>conn = loop.create_connection(protocol, host, port)<EOL>return conn<EOL>", "docstring": "Creates a DSMR asyncio protocol coroutine using TCP connection.", "id": "f4402:m2"}
{"signature": "def connection_lost(self, exc):", "body": "if exc:<EOL><INDENT>self.log.exception('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>self.log.info('<STR_LIT>')<EOL><DEDENT>self._closed.set()<EOL>", "docstring": "Stop when connection is lost.", "id": "f4402:c0:m3"}
{"signature": "def _find_telegrams(self):", "body": "<EOL>return re.findall(<EOL>r'<STR_LIT>',<EOL>self._buffer,<EOL>re.DOTALL<EOL>)<EOL>", "docstring": "Find complete telegrams in buffer from  start ('/') till ending\nchecksum ('!AB12\\r\\n').\n:rtype: list", "id": "f4403:c0:m4"}
{"signature": "def get_all(self):", "body": "for telegram in self._find_telegrams():<EOL><INDENT>self._remove(telegram)<EOL>yield telegram<EOL><DEDENT>", "docstring": "Remove complete telegrams from buffer and yield them.\n:rtype generator:", "id": "f4403:c0:m1"}
{"signature": "def __init__(self, telegram_specification, apply_checksum_validation=True):", "body": "self.telegram_specification = telegram_specification<EOL>self.apply_checksum_validation = apply_checksum_validation<EOL>", "docstring": ":param telegram_specification: determines how the telegram is parsed\n:param apply_checksum_validation: validate checksum if applicable for\n    telegram DSMR version (v4 and up).\n:type telegram_specification: dict", "id": "f4404:c0:m0"}
{"signature": "def mutex(func):", "body": "def wrapper(*args, **kwargs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>lock = args[<NUM_LIT:0>].lock<EOL>lock.acquire(True)<EOL>try:<EOL><INDENT>return func(*args, **kwargs)<EOL><DEDENT>except:<EOL><INDENT>raise<EOL><DEDENT>finally:<EOL><INDENT>lock.release()<EOL><DEDENT><DEDENT>return wrapper<EOL>", "docstring": "use a thread lock on current method, if self.lock is defined", "id": "f4414:m2"}
{"signature": "def login_required(function=None, redirect_field_name=REDIRECT_FIELD_NAME,<EOL>login_url=None):", "body": "actual_decorator = request_passes_test(<EOL>lambda r: r.session.get('<STR_LIT>'),<EOL>login_url=login_url,<EOL>redirect_field_name=redirect_field_name<EOL>)<EOL>if function:<EOL><INDENT>return actual_decorator(function)<EOL><DEDENT>return actual_decorator<EOL>", "docstring": "Decorator for views that checks that the user is logged in, redirecting\nto the log-in page if necessary.", "id": "f4421:m5"}
{"signature": "def get_page_of_iterator(iterator, page_size, page_number):", "body": "try:<EOL><INDENT>page_number = validate_page_number(page_number)<EOL><DEDENT>except (PageNotAnInteger, EmptyPage):<EOL><INDENT>page_number = <NUM_LIT:1><EOL><DEDENT>start = (page_number - <NUM_LIT:1>) * page_size<EOL>end = (page_number * page_size) + <NUM_LIT:1><EOL>skipped_items = list(islice(iterator, start))<EOL>items = list(islice(iterator, end))<EOL>if len(items) == <NUM_LIT:0> and page_number != <NUM_LIT:1>:<EOL><INDENT>items = skipped_items<EOL>page_number = <NUM_LIT:1><EOL><DEDENT>has_next = len(items) > page_size<EOL>items = items[:page_size]<EOL>return NoCountPage(items, page_number, page_size, has_next)<EOL>", "docstring": "Get a page from an interator, handling invalid input from the page number\nby defaulting to the first page.", "id": "f4426:m7"}
{"signature": "def get_last_value_from_timeseries(timeseries):", "body": "if not timeseries:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>for metric, points in timeseries.items():<EOL><INDENT>return next((p['<STR_LIT:y>'] for p in reversed(points) if p['<STR_LIT:y>'] > <NUM_LIT:0>), <NUM_LIT:0>)<EOL><DEDENT>", "docstring": "Gets the most recent non-zero value for a .last metric or zero\n    for empty data.", "id": "f4426:m1"}
{"signature": "def get_timestamp(dt):", "body": "return time.mktime(dt.timetuple()) * <NUM_LIT:1000><EOL>", "docstring": "Returns a Unix timestamp in microseconds for a given datetime.", "id": "f4426:m2"}
{"signature": "def new_junction_reparse_buffer(path=None):", "body": "if path is None:<EOL><INDENT>substnamebufferchars = <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>substnamebufferchars = len(path) + <NUM_LIT:1><EOL><DEDENT>class REPARSE_DATA_BUFFER(ctypes.Structure):<EOL><INDENT>_fields_ = [(\"<STR_LIT>\", ctypes.c_ulong),<EOL>(\"<STR_LIT>\", ctypes.c_ushort),<EOL>(\"<STR_LIT>\", ctypes.c_ushort),<EOL>(\"<STR_LIT>\", ctypes.c_ushort),<EOL>(\"<STR_LIT>\", ctypes.c_ushort),<EOL>(\"<STR_LIT>\", ctypes.c_ushort),<EOL>(\"<STR_LIT>\", ctypes.c_ushort),<EOL>(\"<STR_LIT>\", ctypes.c_wchar * substnamebufferchars),<EOL>(\"<STR_LIT>\", ctypes.c_wchar * <NUM_LIT:1>)]<EOL><DEDENT>numpathbytes = (substnamebufferchars - <NUM_LIT:1>) * sizeof(ctypes.c_wchar)<EOL>buffersize = (numpathbytes + (sizeof(ctypes.c_wchar) * <NUM_LIT:2>) + <EOL>(sizeof(ctypes.c_ushort) * <NUM_LIT:4>))<EOL>if path is None:<EOL><INDENT>buffer = REPARSE_DATA_BUFFER()<EOL>buffer.ReparseTag = IO_REPARSE_TAG_MOUNT_POINT<EOL><DEDENT>else:<EOL><INDENT>buffer = REPARSE_DATA_BUFFER(<EOL>IO_REPARSE_TAG_MOUNT_POINT,<EOL>buffersize,<EOL><NUM_LIT:0>,<EOL><NUM_LIT:0>, numpathbytes,<EOL>numpathbytes + <NUM_LIT:2>, <NUM_LIT:0>,<EOL>path,<EOL>\"<STR_LIT>\")<EOL><DEDENT>return (buffer, buffersize + REPARSE_DATA_BUFFER.SubstituteNameOffset.offset)<EOL>", "docstring": "Given a path, return a pair containing a new REPARSE_DATA_BUFFER and the\nlength of the buffer (not necessarily the same as sizeof due to packing\nissues).\nIf no path is provided, the maximum length is assumed.", "id": "f4442:m0"}
{"signature": "def getdirinfo(path):", "body": "return _getfileinfo(path, FILE_FLAG_BACKUP_SEMANTICS)<EOL>", "docstring": "Return information for the directory at the given path. This is going to be a\nstruct of type BY_HANDLE_FILE_INFORMATION.", "id": "f4444:m1"}
{"signature": "def read_cnf(path):", "body": "clauses = []<EOL>for line in open(path):<EOL><INDENT>parts = line.split()<EOL>if not parts or parts[<NUM_LIT:0>] == '<STR_LIT:c>':<EOL><INDENT>continue<EOL><DEDENT>if parts[<NUM_LIT:0>] == '<STR_LIT:p>':<EOL><INDENT>assert len(parts) == <NUM_LIT:4><EOL>assert parts[<NUM_LIT:1>] == '<STR_LIT>'<EOL>n_vars, n_clauses = [int(n) for n in parts[<NUM_LIT:2>:<NUM_LIT:4>]]<EOL>continue<EOL><DEDENT>if parts[<NUM_LIT:0>] == '<STR_LIT:%>':<EOL><INDENT>break<EOL><DEDENT>assert parts[-<NUM_LIT:1>] == '<STR_LIT:0>'<EOL>clauses.append([int(lit) for lit in parts[:-<NUM_LIT:1>]])<EOL><DEDENT>assert len(clauses) == n_clauses<EOL>return clauses, n_vars<EOL>", "docstring": "read a DIMACS cnf formatted file from `path`, and return the clauses\nand number of variables", "id": "f4446:m0"}
{"signature": "def evaluate(clauses, sol):", "body": "sol_vars = {} <EOL>for i in sol:<EOL><INDENT>sol_vars[abs(i)] = bool(i > <NUM_LIT:0>)<EOL><DEDENT>return all(any(sol_vars[abs(i)] ^ bool(i < <NUM_LIT:0>) for i in clause)<EOL>for clause in clauses)<EOL>", "docstring": "evaluate the clauses with the solution", "id": "f4446:m1"}
{"signature": "def assert_frame_equal_noindex(left, right):", "body": "assert_frame_equal(left.reset_index(drop=True), right.reset_index(drop=True))<EOL>", "docstring": "compare dataframes but ignore index values.\n\n    This is useful to compare filtered out dataframes with a manually\n    built one.", "id": "f4481:m1"}
{"signature": "def default_zip_file(df, df2):<EOL>", "body": "with io.BytesIO() as memory_file:<EOL><INDENT>with zipfile.ZipFile(memory_file, mode='<STR_LIT:w>') as zfile:<EOL><INDENT>tmp = tempfile.NamedTemporaryFile()<EOL>with open(tmp.name, mode='<STR_LIT:wb>'):<EOL><INDENT>joblib.dump(df, tmp.name)<EOL><DEDENT>with open(tmp.name, mode='<STR_LIT:rb>') as f:<EOL><INDENT>content = f.read()<EOL>zfile.writestr('<STR_LIT>', content)<EOL><DEDENT>tmp.close()<EOL>tmp2 = tempfile.NamedTemporaryFile()<EOL>with open(tmp2.name, mode='<STR_LIT:wb>'):<EOL><INDENT>joblib.dump(df2, tmp2.name)<EOL><DEDENT>with open(tmp2.name, mode='<STR_LIT:rb>') as f:<EOL><INDENT>content = f.read()<EOL>zfile.writestr('<STR_LIT>', content)<EOL><DEDENT>tmp2.close()<EOL><DEDENT>memory_file.seek(<NUM_LIT:0>)<EOL>return memory_file.getvalue()<EOL><DEDENT>", "docstring": "Return zip file with two DF saved using joblib.", "id": "f4485:m0"}
{"signature": "def get_orig_function(f):", "body": "try:<EOL><INDENT>while True:<EOL><INDENT>f = f.__wrapped__<EOL><DEDENT><DEDENT>except AttributeError:<EOL><INDENT>return f<EOL><DEDENT>", "docstring": "Make use of the __wrapped__ attribute to find the original function\n        of a decorated function.", "id": "f4489:m0"}
{"signature": "def compute_ffill_by_group(<EOL>df,<EOL>id_cols: List[str],<EOL>reference_cols: List[str],<EOL>value_col: str<EOL>):", "body": "check_params_columns_duplicate(id_cols + reference_cols + [value_col])<EOL>df = df.sort_values(by=id_cols + reference_cols)<EOL>df = df.set_index(id_cols)<EOL>df['<STR_LIT>'] = <NUM_LIT:1> - df[value_col].isnull().astype(int)<EOL>df['<STR_LIT>'] = df.groupby(<EOL>level=list(range(<NUM_LIT:0>, len(id_cols) - <NUM_LIT:1>))<EOL>)['<STR_LIT>'].cumsum()<EOL>df[value_col] = df[value_col].ffill()<EOL>df.loc[df['<STR_LIT>'] == <NUM_LIT:0>, value_col] = None<EOL>del df['<STR_LIT>']<EOL>return df.reset_index()<EOL>", "docstring": "Compute `ffill` with `groupby`\nDedicated method as there is a performance issue with a simple groupby/fillna (2017/07)\nThe method `ffill` propagates last valid value forward to next values.\n\n---\n\n### Parameters\n\n*mandatory :*\n- `id_cols` (*list of str*): names of columns used to create each group.\n- `reference_cols` (*list of str*): names of columns used to sort.\n- `value_col` (*str*): name of the columns to fill.\n\n---\n\n### Example\n\n**Input**\n\nname | rank | value\n:------:|:--------------:|:--------:\nA | 1 | 2\nA | 2 | 5\nA | 3 | null\nB | 1 | null\nB | 2 | 7\n\n```cson\ncompute_ffill_by_group:\n  id_cols: ['name']\n  reference_cols: ['rank']\n  value_col: 'value'\n```\n\n**Ouput**\n\nname | rank | value\n:------:|:--------------:|:--------:\nA | 1 | 2\nA | 2 | 5\nA | 3 | 5\nB | 1 | null\nB | 2 | 7", "id": "f4492:m0"}
{"signature": "def compute_evolution_by_criteria(<EOL>df,<EOL>id_cols: List[str],<EOL>value_col: str,<EOL>compare_to: str,<EOL>method: str = '<STR_LIT>',<EOL>format: str = '<STR_LIT>',<EOL>offseted_suffix: str = '<STR_LIT>',<EOL>evolution_col_name: str = '<STR_LIT>',<EOL>raise_duplicate_error: bool = True<EOL>):", "body": "return __compute_evolution(**locals())<EOL>", "docstring": "This function answers the question: how has a value changed compare to a specific value ?\n\n---\n\n### Parameters\n\n*mandatory :*\n- `id_cols` (*list*): columns used to create each group\n- `value_col` (*str*): name of the column containing the value to compare\n- `compare_to` (*str*): the query identifying a specific set of values for comparison.\n\n*optional :*\n- `method` (*str*): either `\"abs\"` for absolute values or `\"pct\"` for the evolution in percentage of previous value.\n- `offseted_suffix` (*str*): suffix of the offseted column. By default, `\"_offseted\"`.\n- `evolution_col_name` (*str*): name given to the evolution column. By default, `\"evolution_computed\"`.\n- `raise_duplicate_error` (*boolean*): raise an error when the dataset has duplicated values with the given `id_cols`.\n- `format` (*str*): `'df'` # Do not change it !!!\n\n---\n\n### Example\n\n**Input**\n\n|   id_cols |    value_col |    month|\n|:---------:|:------------:|:-------:|\n|         A |          100 |        1|\n|           |          250 |       12|\n|         B |          300 |        1|\n|           |          200 |       12|\n\n```cson\ncompute_evolution_by_criteria:\n  id_cols: \"id_cols\"\n  value_col: \"value_col\"\n  compare_to: \"month==12\"\n```\n\n**Output**\n\n|   id_cols |    value_col |    month|\tvalue_offseted\t| evolution_computed|\n|:---------:|:------------:|:-------:|:----------------:|:-----------------:|\n|         A |          100 |        1|               250|               -150|\n|           |          250 |       12|               250|                  0|\n|         B |          300 |        1|               200|                100|\n|           |          200 |       12|               200|                  0|", "id": "f4494:m1"}
{"signature": "def compute_cumsum(<EOL>df,<EOL>id_cols: List[str],<EOL>reference_cols: List[str],<EOL>value_cols: List[str],<EOL>new_value_cols: List[str] = None,<EOL>cols_to_keep: List[str] = None<EOL>):", "body": "if cols_to_keep is None:<EOL><INDENT>cols_to_keep = []<EOL><DEDENT>if new_value_cols is None:<EOL><INDENT>new_value_cols = value_cols<EOL><DEDENT>if len(value_cols) != len(new_value_cols):<EOL><INDENT>raise ParamsValueError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>check_params_columns_duplicate(id_cols + reference_cols + cols_to_keep + value_cols)<EOL>levels = list(range(<NUM_LIT:0>, len(id_cols)))<EOL>df = df.groupby(id_cols + reference_cols + cols_to_keep).sum()<EOL>df[new_value_cols] = df.groupby(level=levels)[value_cols].cumsum()<EOL>return df.reset_index()<EOL>", "docstring": "Compute cumsum for a group of columns.\n\n---\n\n### Parameters\n\n*mandatory :*\n- `id_cols` (*list*): the columns id to create each group\n- `reference_cols` (*list*): the columns to order the cumsum\n- `value_cols` (*list*): the columns to cumsum\n\n*optional :*\n- `new_value_cols` (*list*): the new columns with the result cumsum\n- `cols_to_keep` (*list*): other columns to keep in the dataset.\n  This option can be used if there is only one row by group [id_cols + reference_cols]\n\n---\n\n### Example\n\n**Input**\n\nMONTH | DAY | NAME | VALUE | X\n:---:|:---:|:--:|:---:|:---:\n 1   |   1 |   A  |  1 | lo\n 2   |   1 |   A  |  1 | lo\n 2   |  15 |   A  |  1 | la\n 1   |  15 |   B  |  1 | la\n\n```cson\ncompute_cumsum:\n  id_cols: ['NAME']\n  reference_cols: ['MONTH', 'DAY']\n  cumsum_cols: ['VALUE']\n  cols_to_keep: ['X']\n```\n\n**Output**\n\nNAME | MONTH | DAY | X | VALUE\n:---:|:---:|:--:|:---:|:---:\n A  |   1  |    1 | lo  |    1\n A  |   2  |    1 | la  |    2\n A  |   2  |   15 | lo  |    3\n B  |   1  |   15 | la  |    1", "id": "f4497:m0"}
{"signature": "def log(logger=None, start_message='<STR_LIT>', end_message='<STR_LIT>'):", "body": "def actual_log(f, real_logger=logger):<EOL><INDENT>logger = real_logger or _logger<EOL>@wraps(f)<EOL>def timed(*args, **kwargs):<EOL><INDENT>logger.info(f'<STR_LIT>')<EOL>start = time.time()<EOL>res = f(*args, **kwargs)<EOL>end = time.time()<EOL>logger.info(f'<STR_LIT>')<EOL>return res<EOL><DEDENT>return timed<EOL><DEDENT>if callable(logger):<EOL><INDENT>return actual_log(logger, real_logger=None)<EOL><DEDENT>return actual_log<EOL>", "docstring": "Basic log decorator\nCan be used as :\n- @log (with default logger)\n- @log(mylogger)\n- @log(start_message='Hello !\", logger=mylogger, end_message='Bye !')", "id": "f4500:m9"}
{"signature": "def percentage(<EOL>df,<EOL>column: str,<EOL>group_cols: Union[str, List[str]] = None,<EOL>new_column: str = None<EOL>):", "body": "new_column = new_column or column<EOL>if group_cols is None:<EOL><INDENT>df[new_column] = <NUM_LIT> * df[column] / sum(df[column])<EOL><DEDENT>else:<EOL><INDENT>df[new_column] = <NUM_LIT> * df[column] / df.groupby(group_cols)[column].transform(sum)<EOL><DEDENT>return df<EOL>", "docstring": "Add a column to the dataframe according to the groupby logic on group_cols\n\n---\n\n### Parameters\n\n*mandatory :*\n- `column` (*str*): name of the desired column you need percentage on\n\n*optional :*\n- `group_cols` (*list*): names of columns for the groupby logic\n- `new_column` (*str*): name of the output column. By default `column` will be overwritten.\n\n---\n\n**Input**\n\n| gender |    sport   | number |\n|:------:|:----------:|:------:|\n|  male  |   bicycle  |   17   |\n| female | basketball |   17   |\n|  male  | basketball |    3   |\n| female |  football  |    7   |\n| female |   running  |   30   |\n|  male  |   running  |   20   |\n|  male  |  football  |   21   |\n| female |   bicycle  |   17   |\n\n```cson\npercentage:\n  new_column: 'number_percentage'\n  column: 'number'\n  group_cols: ['sport']\n```\n\n**Output**\n\n| gender |    sport   | number | number_percentage |\n|:------:|:----------:|:------:|:-----------------:|\n|  male  |   bicycle  |   17   |        50.0       |\n| female | basketball |   17   |        85.0       |\n|  male  | basketball |    3   |        15.0       |\n| female |  football  |    7   |        25.0       |\n| female |   running  |   30   |        60.0       |\n|  male  |   running  |   20   |        40.0       |\n|  male  |  football  |   21   |        75.0       |\n| female |   bicycle  |   17   |        50.0       |", "id": "f4502:m0"}
{"signature": "def add_months(dateobj, nb_months: int):", "body": "nb_years, nb_months = divmod(nb_months, <NUM_LIT:12>)<EOL>month = dateobj.month + nb_months<EOL>if month > <NUM_LIT:12>:<EOL><INDENT>nb_years += <NUM_LIT:1><EOL>month -= <NUM_LIT:12><EOL><DEDENT>year = dateobj.year + nb_years<EOL>lastday = monthrange(year, month)[<NUM_LIT:1>]<EOL>return dateobj.replace(year=year, month=month, day=min(lastday, dateobj.day))<EOL>", "docstring": "return `dateobj` + `nb_months`\n\n    If landing date doesn't exist (e.g. february, 30th), return the last\n    day of the landing month.\n\n    >>> add_months(date(2018, 1, 1), 1)\n    datetime.date(2018, 1, 1)\n    >>> add_months(date(2018, 1, 1), -1)\n    datetime.date(2017, 12, 1)\n    >>> add_months(date(2018, 1, 1), 25)\n    datetime.date(2020, 2, 1)\n    >>> add_months(date(2018, 1, 1), -25)\n    datetime.date(2015, 12, 1)\n    >>> add_months(date(2018, 1, 31), 1)\n    datetime.date(2018, 2, 28)", "id": "f4503:m2"}
{"signature": "def subtract(df, new_column, column_1, column_2):", "body": "return _basic_math_operation(df, new_column, column_1, column_2, op='<STR_LIT>')<EOL>", "docstring": "DEPRECATED -  use `formula` instead", "id": "f4504:m2"}
{"signature": "def absolute_values(df, *, column: str, new_column: str = None):", "body": "new_column = new_column or column<EOL>df[new_column] = abs(df[column])<EOL>return df<EOL>", "docstring": "Get the absolute numeric value of each element of a column\n\n---\n\n### Parameters\n\n*mandatory :*\n- `column` (*str*): name of the column\n\n*optional :*\n- `new_column` (*str*): name of the column containing the result.\n  By default, no new column will be created and `column` will be replaced.\n\n---\n\n### Example\n\n**Input**\n\n| ENTITY | VALUE_1 | VALUE_2 |\n|:------:|:-------:|:-------:|\n| A      | -1.512  | -1.504  |\n| A      | 0.432   | 0.14    |\n\n```cson\nabsolute_values:\n  column: 'VALUE_1'\n  new_column: 'Pika'\n```\n\n**Output**\n\n| ENTITY | VALUE_1 | VALUE_2 | Pika  |\n|:------:|:-------:|:-------:|:-----:|\n| A      | -1.512  | -1.504  | 1.512 |\n| A      | 0.432   | 0.14    | 0.432 |", "id": "f4504:m9"}
{"signature": "def _basic_math_operation(df, new_column, column_1, column_2, op):", "body": "if not isinstance(column_1, (str, int, float)):<EOL><INDENT>raise TypeError(f'<STR_LIT>')<EOL><DEDENT>if not isinstance(column_2, (str, int, float)):<EOL><INDENT>raise TypeError(f'<STR_LIT>')<EOL><DEDENT>if isinstance(column_1, str):<EOL><INDENT>column_1 = df[column_1]<EOL><DEDENT>if isinstance(column_2, str):<EOL><INDENT>column_2 = df[column_2]<EOL><DEDENT>operator = getattr(_operator, op)<EOL>df[new_column] = operator(column_1, column_2)<EOL>return df<EOL>", "docstring": "Basic mathematical operation to apply operator on `column_1` and `column_2`\nBoth can be either a number or the name of a column of `df`\nWill create a new column named `new_column`", "id": "f4504:m0"}
{"signature": "def multiply(df, new_column, column_1, column_2):", "body": "return _basic_math_operation(df, new_column, column_1, column_2, op='<STR_LIT>')<EOL>", "docstring": "DEPRECATED -  use `formula` instead", "id": "f4504:m3"}
{"signature": "def cumsum(df, new_column: str, column: str, index: list, date_column: str, date_format: str):", "body": "logging.getLogger(__name__).warning(f\"<STR_LIT>\")<EOL>date_temp = '<STR_LIT>'<EOL>if isinstance(index, str):<EOL><INDENT>index = [index]<EOL><DEDENT>levels = list(range(<NUM_LIT:0>, len(index)))<EOL>df[date_temp] = pd.to_datetime(df[date_column], format=date_format)<EOL>reference_cols = [date_temp, date_column]<EOL>df = df.groupby(index + reference_cols).sum()<EOL>df[new_column] = df.groupby(level=levels)[column].cumsum()<EOL>df.reset_index(inplace=True)<EOL>del df[date_temp]<EOL>return df<EOL>", "docstring": "DEPRECATED - please use `compute_cumsum` instead", "id": "f4507:m0"}
{"signature": "def fillna(df, column: str, value=None,  column_value=None):", "body": "if column not in df.columns:<EOL><INDENT>df[column] = nan<EOL><DEDENT>if value is not None and column_value is not None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if value is not None:<EOL><INDENT>df[column] = df[column].fillna(value)<EOL><DEDENT>if column_value is not None:<EOL><INDENT>if column_value not in df.columns:<EOL><INDENT>raise ValueError(f'<STR_LIT>')<EOL><DEDENT>df[column] = df[column].fillna(df[column_value])<EOL><DEDENT>return df<EOL>", "docstring": "Can fill NaN values from a column with a given value or a column\n\n---\n\n### Parameters\n\n- `column` (*str*): name of column you want to fill\n- `value`: NaN will be replaced by this value\n- `column_value`: NaN will be replaced by value from this column\n\n*NOTE*: You must set either the 'value' parameter or the 'column_value' parameter\n\n---\n\n### Example\n\n**Input**\n\n| variable |   wave  |  year    | my_value |\n|:--------:|:-------:|:--------:|:--------:|\n|   toto   |  wave 1 |  2014    |  300     |\n|   toto   |  wave 1 |  2015    |          |\n|   toto   |  wave 1 |  2016    |  450     |\n\n```cson\nfillna:\n  column: 'my_value'\n  value: 0\n```\n\n**Output**\n\n| variable |   wave  |  year    | my_value |\n|:--------:|:-------:|:--------:|:--------:|\n|   toto   |  wave 1 |  2014    |  300     |\n|   toto   |  wave 1 |  2015    |    0     |\n|   toto   |  wave 1 |  2016    |  450     |", "id": "f4508:m0"}
{"signature": "def concat(<EOL>df,<EOL>*,<EOL>columns: List[str],<EOL>new_column: str,<EOL>sep: str = None<EOL>):", "body": "if len(columns) < <NUM_LIT:2>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>first_col, *other_cols = columns<EOL>df.loc[:, new_column] = df[first_col].astype(str).str.cat(df[other_cols].astype(str), sep=sep)<EOL>return df<EOL>", "docstring": "Concatenate `columns` element-wise\nSee [pandas doc](\nhttps://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.Series.str.cat.html) for more information\n\n---\n\n### Parameters\n\n*mandatory :*\n- `columns` (*list*): list of columns to concatenate (at least 2 columns)\n- `new_column` (*str*): the destination column\n\n*optional :*\n- `sep` (*str*): the separator", "id": "f4510:m7"}
{"signature": "def replace_pattern(<EOL>df,<EOL>column: str,<EOL>*,<EOL>pat: str,<EOL>repl: str,<EOL>new_column: str = None,<EOL>case: bool = True,<EOL>regex: bool = True<EOL>):", "body": "new_column = new_column or column<EOL>df.loc[:, new_column] = df[column].str.replace(pat, repl, case=case, regex=regex)<EOL>return df<EOL>", "docstring": "Replace occurrences of pattern/regex in `column` with some other string\nSee [pandas doc](\nhttps://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.Series.str.replace.html) for more information\n\n---\n\n### Parameters\n\n*mandatory :*\n- `column` (*str*): the column\n- `pat` (*str*): character sequence or regular expression\n- `repl` (*str*): replacement string\n\n*optional :*\n- `new_column` (*str*): the destination column (if not set, `column` will be used)\n- `case` (*boolean*): if true, case sensitive.\n- `regex` (*boolean*): default true", "id": "f4510:m10"}
{"signature": "def contains(<EOL>df,<EOL>column: str,<EOL>*,<EOL>pat: str,<EOL>new_column: str = None,<EOL>case: bool = True,<EOL>na: Any = None,<EOL>regex: bool = True<EOL>):", "body": "new_column = new_column or column<EOL>df.loc[:, new_column] = df[column].str.contains(pat, case=case, na=na, regex=regex)<EOL>return df<EOL>", "docstring": "Test if pattern or regex is contained within strings of `column`\nSee [pandas doc](\nhttps://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.Series.str.contains.html) for more information\n\n---\n\n### Parameters\n\n*mandatory :*\n- `column` (*str*): the column\n- `pat` (*str*): character sequence or regular expression.\n\n*optional :*\n- `new_column` (*str*): the destination column (if not set, `column` will be used)\n- `case` (*boolean*): if true, case sensitive.\n- `na`: fill value for missing values.\n- `regex` (*boolean*): default true", "id": "f4510:m8"}
{"signature": "def repeat(<EOL>df,<EOL>column: str,<EOL>*,<EOL>times: int,<EOL>new_column: str = None<EOL>):", "body": "new_column = new_column or column<EOL>df.loc[:, new_column] = df[column].str.repeat(times)<EOL>return df<EOL>", "docstring": "Duplicate each string in `column` by indicated number of time\nSee [pandas doc](\nhttps://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.Series.str.repeat.html) for more information\n\n---\n\n### Parameters\n\n*mandatory :*\n- `column` (*str*): the column\n- `times` (*int*): times to repeat the string\n\n*optional :*\n- `new_column` (*str*): the destination column (if not set, `column` will be used)", "id": "f4510:m9"}
{"signature": "def _compute_start_end(df, start, end):", "body": "result = {}<EOL>time_dict = {'<STR_LIT:start>': start, '<STR_LIT:end>': end}<EOL>totals = df.groupby('<STR_LIT:date>').agg({'<STR_LIT:value>': sum}).reset_index()<EOL>for time_name, time in time_dict.items():<EOL><INDENT>if not totals[totals['<STR_LIT:date>'] == time['<STR_LIT:id>']].empty:<EOL><INDENT>value = totals.loc[<EOL>totals['<STR_LIT:date>'] == time['<STR_LIT:id>'], '<STR_LIT:value>'<EOL>].values[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>value = <NUM_LIT:0><EOL><DEDENT>result[time_name] = pd.DataFrame([{<EOL>'<STR_LIT:value>': value,<EOL>'<STR_LIT:label>': time['<STR_LIT:label>'],<EOL>'<STR_LIT>': time['<STR_LIT:label>']<EOL>}])<EOL><DEDENT>return result['<STR_LIT:start>'], result['<STR_LIT:end>']<EOL>", "docstring": "Compute two dataframes with value for start and end\nArgs:\n    totals(dataframe):\n\nReturns: Dataframe, Dataframe", "id": "f4511:m2"}
{"signature": "def _compute_inside_group(df):", "body": "inside_group = df.copy()<EOL>inside_group['<STR_LIT:type>'] = '<STR_LIT>'<EOL>inside_group['<STR_LIT>'] = inside_group['<STR_LIT:value>'] / inside_group[<EOL>'<STR_LIT>']<EOL>inside_group.drop(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'],<EOL>axis=<NUM_LIT:1>, inplace=True)<EOL>inside_group.rename(columns={'<STR_LIT>': '<STR_LIT:label>'},<EOL>inplace=True)<EOL>return inside_group<EOL>", "docstring": "Compute inside Group\nArgs:\n    df(dataframe):\n\nReturns: Dataframe", "id": "f4511:m4"}
{"signature": "def melt(<EOL>df,<EOL>id: List[str],<EOL>value: List[str],<EOL>dropna=False<EOL>):", "body": "df = df[(id + value)]<EOL>df = pd.melt(df, id_vars=id, value_vars=value)<EOL>if dropna:<EOL><INDENT>df = df.dropna(subset=['<STR_LIT:value>'])<EOL><DEDENT>return df<EOL>", "docstring": "A melt will transform a dataset by creating a column \"variable\" and a column \"value\".\nThis function is useful to transform a dataset into a format where one or more columns\nare identifier variables, while all other columns, considered measured\nvariables (value_vars), are \u201cunpivoted\u201d to the row axis, leaving just two\nnon-identifier columns, `\"variable\"` and `\"value\"`.\n\n---\n\n### Parameters\n\n*mandatory :*\n- `id` (*list of str*): names of the columns that must be kept in column.\n- `value` (*list of str*): names of the columns that will be transformed in long format (in rows).\n\n*optional :*\n- `dropna` (*boolean*): It allows you to drop missing values.\n\n---\n\n### Example\n\n**Input**\n\n| my_label | my_value | my_column_1 | my_column_2 | info_1 | info_2 | info_3 |\n|:--------:|:--------:|:-----------:|:-----------:|:------:|:------:|:------:|\n|   toto   |    10    |     S45     |    Lalaland |   10   |   20   |  None  |\n\n```cson\nmelt:\n  id: ['my_label', 'my_value' 'my_column_1', 'my_colum_2']\n    value: ['info_1', 'info_2', 'info_3']\n    dropna: true\n```\n\n**Ouput**\n\n| my_label | my_value | my_column_1 | my_column_2 | variable | value  |\n|:--------:|:--------:|:-----------:|:-----------:|:--------:|:------:|\n|   toto   |    10    |     S45     |    Lalaland |  info_1  |   10   |\n|   toto   |    10    |     S45     |    Lalaland |  info_2  |   20   |", "id": "f4512:m0"}
{"signature": "def argmin(df, column: str, groups: Union[str, List[str]] = None):", "body": "if groups is None:<EOL><INDENT>df = df[df[column] == df[column].min()].reset_index(drop=True)<EOL><DEDENT>else:<EOL><INDENT>group_min = df.groupby(groups)[column].transform('<STR_LIT>')<EOL>df = (df<EOL>.loc[df[column] == group_min, :]<EOL>.drop_duplicates()<EOL>.reset_index(drop=True)<EOL>)<EOL><DEDENT>return df<EOL>", "docstring": "Keep the row of the data corresponding to the minimal value in a column\n\n---\n\n### Parameters\n\n*mandatory :*\n- `column` (str): name of the column containing the value you want to keep the minimum\n\n*optional :*\n- `groups` (*str or list(str)*): name of the column(s) used for 'groupby' logic\n(the function will return the argmax by group)\n---\n\n### Example\n\n**Input**\n\n| variable |   wave  |  year    | value |\n|:--------:|:-------:|:--------:|:-----:|\n|   toto   |  wave 1 |  2014    |  300  |\n|   toto   |  wave 1 |  2015    |  250  |\n|   toto   |  wave 1 |  2016    |  450  |\n\n```cson\nargmin:\n  column: 'year'\n]\n```\n\n**Output**\n\n| variable |   wave  |  year    | value |\n|:--------:|:-------:|:--------:|:-----:|\n|   toto   |  wave 1 |  2015    |  250  |", "id": "f4515:m1"}
{"signature": "def cast(df, column: str, type: str, new_column=None):", "body": "new_column = new_column or column<EOL>df[new_column] = df[column].astype(type)<EOL>return df<EOL>", "docstring": "Convert column's type into type\n\n---\n\n### Parameters\n\n*mandatory :*\n- `column` (*str*): name of the column to convert\n- `type` (*str*): output type. It can be :\n    - `\"int\"` : integer type\n    - `\"float\"` : general number type\n    - `\"str\"` : text type\n\n*optional :*\n- `new_column` (*str*): name of the output column.\n   By default the `column` arguments is modified.\n\n---\n\n### Example\n\n**Input**\n\n| Column 1 |  Column 2   |  Column 3  |\n|:-------:|:--------:|:--------:|\n|  'one'  |  '2014'  |   30.0   |\n|  'two'  |  2015.0  |    '1'   |\n|   3.1   |   2016   |    450   |\n\n```cson\npostprocess: [\n  cast:\n    column: 'Column 1'\n    type: 'str'\n  cast:\n    column: 'Column 2'\n    type: 'int'\n  cast:\n    column: 'Column 3'\n    type: 'float'\n]\n```\n\n**Output**\n\n| Column 1 |  Column 2  |  Column 3  |\n|:-------:|:------:|:--------:|\n|  'one'  |  2014  |   30.0   |\n|  'two'  |  2015  |    1.0   |\n|  '3.1'  |  2016  |  450.0   |", "id": "f4519:m3"}
{"signature": "def sort(df, columns: Union[str, List[str]], order: Union[str, List[str]] = '<STR_LIT>'):", "body": "if isinstance(columns, str):<EOL><INDENT>columns = [columns]<EOL><DEDENT>if isinstance(order, str):<EOL><INDENT>assert order in ['<STR_LIT>', '<STR_LIT>']<EOL>orders = [order == '<STR_LIT>'] * len(columns)<EOL><DEDENT>else:<EOL><INDENT>assert len(order) == len(columns), \"<STR_LIT>\"\"<STR_LIT>\"<EOL>orders = []<EOL>for ord in order:<EOL><INDENT>assert ord in ['<STR_LIT>', '<STR_LIT>'], f\"<STR_LIT>\"\"<STR_LIT>\"<EOL>orders.append(ord == '<STR_LIT>')<EOL><DEDENT><DEDENT>return df.sort_values(columns, ascending=orders)<EOL>", "docstring": "Sort the data by the value in specified columns\n\n---\n\n### Parameters\n\n*mandatory :*\n- `columns` (*str* or *list(str)*): list of columns to order\n\n*optional :*\n- `order` (*str* or *list(str)*): the ordering condition ('asc' for\nascending or 'desc' for descending). If not specified, 'asc' by default.\nIf a list of columns has been specified for the `columns` parameter,\nthe `order` parameter, if explicitly specified, must be a list of same\nlength as the `columns` list (if a string is specified, it will be\nreplicated in a list of same length of the `columns` list)\n\n---\n\n### Example\n\n**Input**\n\n| variable | value |\n|:--------:|:-----:|\n|     A    |  220  |\n|     B    |  200  |\n|     C    |  300  |\n|     D    |  100  |\n\n```cson\nsort:\n  columns: 'value'\n```\n\n**Output**\n\n| variable | value |\n|:--------:|:-----:|\n|     D    |  100  |\n|     B    |  200  |\n|     A    |  220  |\n|     C    |  300  |", "id": "f4520:m0"}
{"signature": "def read_entry(self, file_name):", "body": "file_path = os.path.join(self.EXTRACTION_CACHE_PATH, file_name)<EOL>logger.info(f'<STR_LIT>')<EOL>return joblib.load(file_path)<EOL>", "docstring": "Args:\n    file_name (str):\n\nReturns:\n    pd.DataFrame:", "id": "f4522:c0:m10"}
{"signature": "def write(self, dfs):", "body": "if not os.path.exists(self.EXTRACTION_CACHE_PATH):<EOL><INDENT>os.makedirs(self.EXTRACTION_CACHE_PATH)<EOL><DEDENT>for name, df in dfs.items():<EOL><INDENT>file_path = os.path.join(self.EXTRACTION_CACHE_PATH, name)<EOL>joblib.dump(df, filename=file_path)<EOL>logger.info(f'<STR_LIT>')<EOL><DEDENT>", "docstring": "Args:\n    data (str | byte):\n\nReturns:\n    dict: Dict[str, DataFrame]", "id": "f4522:c0:m11"}
{"signature": "def extract(data):", "body": "_, tmp_file_path = tempfile.mkstemp()<EOL>try:<EOL><INDENT>with open(tmp_file_path, '<STR_LIT:wb>') as tmp_file:<EOL><INDENT>tmp_file.write(data)<EOL><DEDENT>if zipfile.is_zipfile(tmp_file_path):<EOL><INDENT>return extract_zip(tmp_file_path)<EOL><DEDENT>else:<EOL><INDENT>raise DataSdkError('<STR_LIT>')<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>shutil.rmtree(tmp_file_path, ignore_errors=True)<EOL><DEDENT>", "docstring": "Args:\n    data (str | byte):\n\nReturns:\n    dict: Dict[str, DataFrame]", "id": "f4522:m1"}
{"signature": "def __init__(self,  namespace: str):", "body": "assert check_argument_types()<EOL>super().__init__()<EOL>self.namespace =  namespace<EOL>", "docstring": "You must specify an entry point namespace.", "id": "f4533:c0:m0"}
{"signature": "def __missing__(self,  key):", "body": "self[key] = load(key, self.namespace)<EOL>return self[key]<EOL>", "docstring": "If not already loaded, attempt to load the reference.", "id": "f4533:c0:m1"}
{"signature": "def __getattr__(self, name):", "body": "return self[name]<EOL>", "docstring": "Proxy attribute access through to the dictionary.", "id": "f4533:c0:m2"}
{"signature": "def strongly_connected_components(graph: Graph) -> List:", "body": "assert check_argument_types()<EOL>result = []<EOL>stack = []<EOL>low = {}<EOL>def visit(node: str):<EOL><INDENT>if node in low: return<EOL>num = len(low)<EOL>low[node] = num<EOL>stack_pos = len(stack)<EOL>stack.append(node)<EOL>for successor in graph[node]:<EOL><INDENT>visit(successor)<EOL>low[node] = min(low[node], low[successor])<EOL><DEDENT>if num == low[node]:<EOL><INDENT>component = tuple(stack[stack_pos:])<EOL>del stack[stack_pos:]<EOL>result.append(component)<EOL>for item in component:<EOL><INDENT>low[item] = len(graph)<EOL><DEDENT><DEDENT><DEDENT>for node in graph:<EOL><INDENT>visit(node)<EOL><DEDENT>return result<EOL>", "docstring": "Find the strongly connected components in a graph using Tarjan's algorithm.\n\n    The `graph` argument should be a dictionary mapping node names to sequences of successor nodes.", "id": "f4535:m0"}
{"signature": "def robust_topological_sort(graph: Graph) -> list:", "body": "assert check_argument_types()<EOL>components = strongly_connected_components(graph)<EOL>node_component = {}<EOL>for component in components:<EOL><INDENT>for node in component:<EOL><INDENT>node_component[node] = component<EOL><DEDENT><DEDENT>component_graph = {}<EOL>for component in components:<EOL><INDENT>component_graph[component] = []<EOL><DEDENT>for node in graph:<EOL><INDENT>node_c = node_component[node]<EOL>for successor in graph[node]:<EOL><INDENT>successor_c = node_component[successor]<EOL>if node_c != successor_c:<EOL><INDENT>component_graph[node_c].append(successor_c) <EOL><DEDENT><DEDENT><DEDENT>return topological_sort(component_graph)<EOL>", "docstring": "Identify strongly connected components then perform a topological sort of those components.", "id": "f4535:m2"}
{"signature": "def lazyload(reference: str, *args, **kw):", "body": "assert check_argument_types()<EOL>def lazily_load_reference(self):<EOL><INDENT>ref = reference<EOL>if ref.startswith('<STR_LIT:.>'):<EOL><INDENT>ref = traverse(self, ref[<NUM_LIT:1>:])<EOL><DEDENT>return load(ref, *args, **kw)<EOL><DEDENT>return lazy(lazily_load_reference)<EOL>", "docstring": "Lazily load and cache an object reference upon dereferencing.\n\n    Assign the result of calling this function with either an object reference passed in positionally:\n\n            class MyClass:\n                    debug = lazyload('logging:debug')\n\n    Or the attribute path to traverse (using `marrow.package.loader:traverse`) prefixed by a period.\n\n            class AnotherClass:\n                    target = 'logging:info'\n                    log = lazyload('.target')\n\n    Additional arguments are passed to the eventual call to `load()`.", "id": "f4538:m0"}
{"signature": "@abstractmethod<EOL><INDENT>def get_code(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Returns current content of the tree.", "id": "f4557:c1:m3"}
{"signature": "@staticmethod<EOL><INDENT>def select_python_parser(parser=None):<DEDENT>", "body": "if parser == '<STR_LIT>' or os.environ.get('<STR_LIT>'):<EOL><INDENT>PythonFile.Class = RedbaronPythonFile<EOL><DEDENT>else:<EOL><INDENT>PythonFile.Class = ParsoPythonFile<EOL><DEDENT>", "docstring": "Select default parser for loading and refactoring steps. Passing `redbaron` as argument\nwill select the old paring engine from v0.3.3\n\nReplacing the redbaron parser was necessary to support Python 3 syntax. We have tried our\nbest to make sure there is no user impact on users. However, there may be regressions with\nnew parser backend.\n\nTo revert to the old parser implementation, add `GETGAUGE_USE_0_3_3_PARSER=true` property\nto the `python.properties` file in the `<PROJECT_DIR>/env/default directory.\n\nThis property along with the redbaron parser will be removed in future releases.", "id": "f4557:c0:m1"}
{"signature": "def refactor_step(self, old_text, new_text, move_param_from_idx):", "body": "diffs = []<EOL>step, func = self._find_step_node(old_text)<EOL>if step is None:<EOL><INDENT>return diffs<EOL><DEDENT>step_diff = self._refactor_step_text(step, old_text, new_text)<EOL>diffs.append(step_diff)<EOL>params_list_node = func.children[<NUM_LIT:2>]<EOL>moved_params = self._move_param_nodes(<EOL>params_list_node.children, move_param_from_idx)<EOL>if params_list_node.children is not moved_params:<EOL><INDENT>params_span = self._span_from_pos(<EOL>params_list_node.children[<NUM_LIT:0>].end_pos,<EOL>params_list_node.children[-<NUM_LIT:1>].start_pos)<EOL>params_list_node.children = moved_params<EOL>param_code = '<STR_LIT>'.join(p.get_code() for p in moved_params[<NUM_LIT:1>:-<NUM_LIT:1>])<EOL>diffs.append((params_span, param_code))<EOL><DEDENT>return diffs<EOL>", "docstring": "Find the step with old_text and change it to new_text.The step function\nparameters are also changed according to move_param_from_idx.\nEach entry in this list should specify parameter position from old.", "id": "f4563:c0:m10"}
{"signature": "@staticmethod<EOL><INDENT>def parse(file_path, content=None):<DEDENT>", "body": "try:<EOL><INDENT>if content is None:<EOL><INDENT>with open(file_path) as f:<EOL><INDENT>content = f.read()<EOL><DEDENT><DEDENT>py_tree = _parser.parse(<EOL>content, path=file_path, error_recovery=False)<EOL>return ParsoPythonFile(file_path, py_tree)<EOL><DEDENT>except parso.parser.ParserSyntaxError as ex:<EOL><INDENT>logging.error(\"<STR_LIT>\", file_path,<EOL>ex.error_leaf.line, ex.error_leaf.get_code())<EOL><DEDENT>", "docstring": "Create a PythonFile object with specified file_path and content.\nIf content is None then, it is loaded from the file_path method.\nOtherwise, file_path is only used for reporting errors.", "id": "f4563:c0:m0"}
{"signature": "def __init__(self, channel):", "body": "self.GetStepNames = channel.unary_unary(<EOL>'<STR_LIT>',<EOL>request_serializer=messages__pb2.StepNamesRequest.SerializeToString,<EOL>response_deserializer=messages__pb2.StepNamesResponse.FromString,<EOL>)<EOL>self.CacheFile = channel.unary_unary(<EOL>'<STR_LIT>',<EOL>request_serializer=messages__pb2.CacheFileRequest.SerializeToString,<EOL>response_deserializer=lsp__pb2.Empty.FromString,<EOL>)<EOL>self.GetStepPositions = channel.unary_unary(<EOL>'<STR_LIT>',<EOL>request_serializer=messages__pb2.StepPositionsRequest.SerializeToString,<EOL>response_deserializer=messages__pb2.StepPositionsResponse.FromString,<EOL>)<EOL>self.GetImplementationFiles = channel.unary_unary(<EOL>'<STR_LIT>',<EOL>request_serializer=lsp__pb2.Empty.SerializeToString,<EOL>response_deserializer=messages__pb2.ImplementationFileListResponse.FromString,<EOL>)<EOL>self.ImplementStub = channel.unary_unary(<EOL>'<STR_LIT>',<EOL>request_serializer=messages__pb2.StubImplementationCodeRequest.SerializeToString,<EOL>response_deserializer=messages__pb2.FileDiff.FromString,<EOL>)<EOL>self.ValidateStep = channel.unary_unary(<EOL>'<STR_LIT>',<EOL>request_serializer=messages__pb2.StepValidateRequest.SerializeToString,<EOL>response_deserializer=messages__pb2.StepValidateResponse.FromString,<EOL>)<EOL>self.Refactor = channel.unary_unary(<EOL>'<STR_LIT>',<EOL>request_serializer=messages__pb2.RefactorRequest.SerializeToString,<EOL>response_deserializer=messages__pb2.RefactorResponse.FromString,<EOL>)<EOL>self.GetStepName = channel.unary_unary(<EOL>'<STR_LIT>',<EOL>request_serializer=messages__pb2.StepNameRequest.SerializeToString,<EOL>response_deserializer=messages__pb2.StepNameResponse.FromString,<EOL>)<EOL>self.GetGlobPatterns = channel.unary_unary(<EOL>'<STR_LIT>',<EOL>request_serializer=lsp__pb2.Empty.SerializeToString,<EOL>response_deserializer=messages__pb2.ImplementationFileGlobPatternResponse.FromString,<EOL>)<EOL>self.KillProcess = channel.unary_unary(<EOL>'<STR_LIT>',<EOL>request_serializer=messages__pb2.KillProcessRequest.SerializeToString,<EOL>response_deserializer=lsp__pb2.Empty.FromString,<EOL>)<EOL>", "docstring": "Constructor.\n\n        Args:\n          channel: A grpc.Channel.", "id": "f4566:c0:m0"}
{"signature": "def _iter_step_func_decorators(self):", "body": "for node in self.py_tree.find_all('<STR_LIT>'):<EOL><INDENT>for decorator in node.decorators:<EOL><INDENT>if decorator.name.value == '<STR_LIT>':<EOL><INDENT>yield node, decorator<EOL>break<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Find functions with step decorator in parsed file.", "id": "f4573:c0:m3"}
{"signature": "@staticmethod<EOL><INDENT>def parse(file_path, content=None):<DEDENT>", "body": "try:<EOL><INDENT>if content is None:<EOL><INDENT>with open(file_path) as f:<EOL><INDENT>content = f.read()<EOL><DEDENT><DEDENT>py_tree = RedBaron(content)<EOL>return RedbaronPythonFile(file_path, py_tree)<EOL><DEDENT>except Exception as ex:<EOL><INDENT>msg = str(ex)<EOL>marker = \"<STR_LIT>\"<EOL>marker_pos = msg.find(marker)<EOL>if marker_pos > <NUM_LIT:0>:<EOL><INDENT>msg = msg[:marker_pos + len(marker)]<EOL><DEDENT>logging.error(\"<STR_LIT>\".format(file_path, msg))<EOL><DEDENT>", "docstring": "Create a PythonFile object with specified file_path and content.\nIf content is None then, it is loaded from the file_path method.\nOtherwise, file_path is only used for reporting errors.", "id": "f4573:c0:m0"}
{"signature": "def alphanum_vld(value):", "body": "if not re.match(alphanum_pattern, value):<EOL><INDENT>raise ValidationError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Check if value contains anything but alphanumerical chars\n\n    :param value: the value to check\n    :type value: str\n    :returns: None\n    :rtype: None\n    :raises: ValidationError", "id": "f4582:m1"}
{"signature": "def add_userrnd_shot(project):", "body": "rndseq = project.sequence_set.get(name=RNDSEQ_NAME)<EOL>users = [u for u in project.users.all()]<EOL>for user in users:<EOL><INDENT>shot, created = Shot.objects.get_or_create(name=user.username,<EOL>project=project,<EOL>sequence=rndseq,<EOL>defaults={'<STR_LIT:description>': '<STR_LIT>' % user.username})<EOL>for t in shot.tasks.all():<EOL><INDENT>t.users.add(user)<EOL>t.full_clean()<EOL>t.save()<EOL><DEDENT><DEDENT>", "docstring": "Add a rnd shot for every user in the project\n\n    :param project: the project that needs its rnd shots updated\n    :type project: :class:`muke.models.Project`\n    :returns: None\n    :rtype: None\n    :raises: None", "id": "f4584:m3"}
{"signature": "@property<EOL><INDENT>def globalseq(self):<DEDENT>", "body": "return self.sequence_set.get(name='<STR_LIT>')<EOL>", "docstring": "Return the global sequence\n\n        :returns: the global sequence of the project\n        :rtype: :class:`muke.models.Sequence`\n        :raises: None", "id": "f4584:c0:m2"}
{"signature": "def add_default_sequences(project):", "body": "<EOL>seqs = [(GLOBAL_NAME, '<STR_LIT>' % project.name),<EOL>(RNDSEQ_NAME, '<STR_LIT>' % project.name)]<EOL>for name, desc in seqs:<EOL><INDENT>seq, created = Sequence.objects.get_or_create(name=name, project=project, defaults={'<STR_LIT:description>': desc})<EOL><DEDENT>", "docstring": "Add or create the default sequences for the given project\n\n    :param project: the project that needs default sequences\n    :type project: :class:`muke.models.Project`\n    :returns: None\n    :rtype: None\n    :raises: None", "id": "f4584:m2"}
{"signature": "def add_default_deps(project):", "body": "<EOL>for name, short, order, af in DEFAULT_DEPARTMENTS:<EOL><INDENT>dep, created = Department.objects.get_or_create(name=name, short=short, ordervalue=order, assetflag=af)<EOL>dep.projects.add(project)<EOL>dep.full_clean()<EOL>dep.save()<EOL><DEDENT>", "docstring": "Add or create the default departments for the given project\n\n    :param project: the project that needs default departments\n    :type project: :class:`muke.models.Project`\n    :returns: None\n    :rtype: None\n    :raises: None", "id": "f4584:m0"}
{"signature": "@property<EOL><INDENT>def short(self):<DEDENT>", "body": "return self.department.short<EOL>", "docstring": "Return department short\n\n        :returns: short of the department\n        :rtype: str\n        :raises: None", "id": "f4584:c4:m1"}
{"signature": "def add_default_atypes(project):", "body": "<EOL>for name, desc in DEFAULT_ASSETTYPES:<EOL><INDENT>at, created = Atype.objects.get_or_create(name=name, defaults={'<STR_LIT:description>': desc})<EOL>at.projects.add(project)<EOL>at.full_clean()<EOL>at.save()<EOL><DEDENT>", "docstring": "Add or create the default assettypes for the given project\n\n    :param project: the project that needs default assettypes\n    :type project: :class:`muke.models.Project`\n    :returns: None\n    :rtype: None\n    :raises: None", "id": "f4584:m1"}
{"signature": "def normalize_excludes(rootpath, excludes):", "body": "return [path.normpath(path.abspath(exclude)) for exclude in excludes]<EOL>", "docstring": "Normalize the excluded directory list.", "id": "f4586:m9"}
{"signature": "def write_file(name, text, opts):", "body": "fname = path.join(opts.destdir, '<STR_LIT>' % (name, opts.suffix))<EOL>if opts.dryrun:<EOL><INDENT>print('<STR_LIT>' % fname)<EOL>return<EOL><DEDENT>if not opts.force and path.isfile(fname):<EOL><INDENT>print('<STR_LIT>' % fname)<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>' % fname)<EOL>f = open(fname, '<STR_LIT:w>')<EOL>try:<EOL><INDENT>f.write(text)<EOL><DEDENT>finally:<EOL><INDENT>f.close()<EOL><DEDENT><DEDENT>", "docstring": "Write the output file for module/package <name>.", "id": "f4586:m1"}
{"signature": "def recurse_tree(rootpath, excludes, opts):", "body": "<EOL>if INITPY in os.listdir(rootpath):<EOL><INDENT>root_package = rootpath.split(path.sep)[-<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>root_package = None<EOL><DEDENT>toplevels = []<EOL>followlinks = getattr(opts, '<STR_LIT>', False)<EOL>includeprivate = getattr(opts, '<STR_LIT>', False)<EOL>for root, subs, files in walk(rootpath, followlinks=followlinks):<EOL><INDENT>py_files = sorted(f for f in files<EOL>if path.splitext(f)[<NUM_LIT:1>] in PY_SUFFIXES and<EOL>not is_excluded(path.join(root, f), excludes))<EOL>is_pkg = INITPY in py_files<EOL>if is_pkg:<EOL><INDENT>py_files.remove(INITPY)<EOL>py_files.insert(<NUM_LIT:0>, INITPY)<EOL><DEDENT>elif root != rootpath:<EOL><INDENT>del subs[:]<EOL>continue<EOL><DEDENT>if includeprivate:<EOL><INDENT>exclude_prefixes = ('<STR_LIT:.>',)<EOL><DEDENT>else:<EOL><INDENT>exclude_prefixes = ('<STR_LIT:.>', '<STR_LIT:_>')<EOL><DEDENT>subs[:] = sorted(sub for sub in subs if not sub.startswith(exclude_prefixes)<EOL>and not is_excluded(path.join(root, sub), excludes))<EOL>if is_pkg:<EOL><INDENT>if subs or len(py_files) > <NUM_LIT:1> or notshall_skip(path.join(root, INITPY), opts):<EOL><INDENT>subpackage = root[len(rootpath):].lstrip(path.sep).replace(path.sep, '<STR_LIT:.>')<EOL>create_package_file(root, root_package, subpackage,<EOL>py_files, opts, subs)<EOL>toplevels.append(makename(root_package, subpackage))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>assert root == rootpath and root_package is None<EOL>for py_file in py_files:<EOL><INDENT>if not shall_skip(path.join(rootpath, py_file), opts):<EOL><INDENT>module = path.splitext(py_file)[<NUM_LIT:0>]<EOL>create_module_file(root_package, module, opts)<EOL>toplevels.append(module)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return toplevels<EOL>", "docstring": "Look for every file in the directory tree and create the corresponding\nReST files.", "id": "f4586:m8"}
{"signature": "def setup_parser():", "body": "parser = optparse.OptionParser(<EOL>usage=\"\"\"<STR_LIT>\"\"\")<EOL>parser.add_option('<STR_LIT>', '<STR_LIT>', action='<STR_LIT:store>', dest='<STR_LIT>',<EOL>help='<STR_LIT>', default='<STR_LIT>')<EOL>parser.add_option('<STR_LIT>', '<STR_LIT>', action='<STR_LIT:store>', dest='<STR_LIT>',<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>', type='<STR_LIT:int>', default=<NUM_LIT:4>)<EOL>parser.add_option('<STR_LIT>', '<STR_LIT>', action='<STR_LIT:store_true>', dest='<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>parser.add_option('<STR_LIT>', '<STR_LIT>', action='<STR_LIT:store_true>',<EOL>dest='<STR_LIT>', default=False,<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>parser.add_option('<STR_LIT>', '<STR_LIT>', action='<STR_LIT:store_true>', dest='<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>parser.add_option('<STR_LIT>', '<STR_LIT>', action='<STR_LIT:store_true>',<EOL>dest='<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>parser.add_option('<STR_LIT>', '<STR_LIT>', action='<STR_LIT:store_true>',<EOL>dest='<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>parser.add_option('<STR_LIT>', '<STR_LIT>', action='<STR_LIT:store_true>', dest='<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>parser.add_option('<STR_LIT>', '<STR_LIT>', action='<STR_LIT:store_true>',<EOL>dest='<STR_LIT>',<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>parser.add_option('<STR_LIT>', '<STR_LIT>', action='<STR_LIT:store>', dest='<STR_LIT>',<EOL>help='<STR_LIT>', default='<STR_LIT>')<EOL>parser.add_option('<STR_LIT>', '<STR_LIT>', action='<STR_LIT:store_true>', dest='<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>parser.add_option('<STR_LIT>', '<STR_LIT>', action='<STR_LIT:store>', dest='<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>parser.add_option('<STR_LIT>', '<STR_LIT>', action='<STR_LIT:store>', dest='<STR_LIT>',<EOL>type='<STR_LIT:str>',<EOL>help='<STR_LIT>')<EOL>parser.add_option('<STR_LIT>', '<STR_LIT>', action='<STR_LIT:store>', dest='<STR_LIT:version>',<EOL>help='<STR_LIT>')<EOL>parser.add_option('<STR_LIT>', '<STR_LIT>', action='<STR_LIT:store>', dest='<STR_LIT>',<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>return parser<EOL>", "docstring": "Sets up the argument parser and returns it\n\n    :returns: the parser\n    :rtype: :class:`optparse.OptionParser`\n    :raises: None", "id": "f4586:m11"}
{"signature": "def shall_skip(module, opts):", "body": "<EOL>if path.getsize(module) <= <NUM_LIT:2>:<EOL><INDENT>return True<EOL><DEDENT>filename = path.basename(module)<EOL>if filename != '<STR_LIT>' and filename.startswith('<STR_LIT:_>') andnot opts.includeprivate:<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Check if we want to skip this module.", "id": "f4586:m7"}
{"signature": "def format_heading(level, text):", "body": "underlining = ['<STR_LIT:=>', '<STR_LIT:->', '<STR_LIT:+>', '<STR_LIT>'][level - <NUM_LIT:1>] * len(text)<EOL>return '<STR_LIT>' % (text, underlining)<EOL>", "docstring": "Create a heading of <level> [1, 2 or 3 supported].", "id": "f4586:m2"}
{"signature": "def main(argv=sys.argv[<NUM_LIT:1>:]):", "body": "parser = setup_argparse()<EOL>args = parser.parse_args(argv)<EOL>if args.gendochelp:<EOL><INDENT>sys.argv[<NUM_LIT:0>] = '<STR_LIT>'<EOL>genparser = gendoc.setup_parser()<EOL>genparser.print_help()<EOL>sys.exit(<NUM_LIT:0>)<EOL><DEDENT>print('<STR_LIT>')<EOL>print('<STR_LIT:=>'*<NUM_LIT>)<EOL>for odir in args.output:<EOL><INDENT>prepare_dir(odir, not args.nodelete)<EOL><DEDENT>print('<STR_LIT>')<EOL>print('<STR_LIT:=>'*<NUM_LIT>)<EOL>for i, idir in enumerate(args.input):<EOL><INDENT>if i >= len(args.output):<EOL><INDENT>odir = args.output[-<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>odir = args.output[i]<EOL><DEDENT>run_gendoc(idir, odir, args.gendocargs)<EOL><DEDENT>", "docstring": "Parse commandline arguments and run the tool\n\n    :param argv: the commandline arguments.\n    :type argv: list\n    :returns: None\n    :rtype: None\n    :raises: None", "id": "f4588:m3"}
{"signature": "def prepare_dir(directory, delete=True):", "body": "if os.path.exists(directory):<EOL><INDENT>if delete:<EOL><INDENT>assert directory != thisdir, '<STR_LIT>'<EOL>print('<STR_LIT>' % directory)<EOL>shutil.rmtree(directory)<EOL>print('<STR_LIT>' % directory)<EOL>os.mkdir(directory)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>print('<STR_LIT>' % directory)<EOL>os.mkdir(directory)<EOL><DEDENT>", "docstring": "Create apidoc dir, delete contents if delete is True.\n\n    :param directory: the apidoc directory. you can use relative paths here\n    :type directory: str\n    :param delete: if True, deletes the contents of apidoc. This acts like an override switch.\n    :type delete: bool\n    :returns: None\n    :rtype: None\n    :raises: None", "id": "f4588:m1"}
{"signature": "def way(self, w):", "body": "if w.id not in self.way_ids:<EOL><INDENT>return<EOL><DEDENT>way_points = []<EOL>for n in w.nodes:<EOL><INDENT>try:<EOL><INDENT>way_points.append(Point(n.location.lon, n.location.lat))<EOL><DEDENT>except o.InvalidLocationError:<EOL><INDENT>logging.debug('<STR_LIT>', w.id, n.ref)<EOL><DEDENT><DEDENT>self.ways[w.id] = Way(w.id, way_points)<EOL>", "docstring": "Process each way.", "id": "f4594:c0:m1"}
{"signature": "@property<EOL><INDENT>def transit_route_types(self):<DEDENT>", "body": "return ['<STR_LIT>', '<STR_LIT>',        <EOL>'<STR_LIT>', '<STR_LIT>',   <EOL>'<STR_LIT>',               <EOL>'<STR_LIT>', '<STR_LIT>']<EOL>", "docstring": "A list of default OSM route types.\n\n        Mainly train and bus types.", "id": "f4595:c0:m1"}
{"signature": "def create_route_short_name(relation):", "body": "return relation.tags.get('<STR_LIT>') or '<STR_LIT>'<EOL>", "docstring": "Create a meaningful route short name.", "id": "f4599:m2"}
{"signature": "def haversine(lon1, lat1, lon2, lat2):", "body": "<EOL>lon1, lat1, lon2, lat2 = map(radians, [lon1, lat1, lon2, lat2])<EOL>dlon = lon2 - lon1<EOL>dlat = lat2 - lat1<EOL>a = sin(dlat / <NUM_LIT:2>)**<NUM_LIT:2> + cos(lat1) * cos(lat2) * sin(dlon / <NUM_LIT:2>)**<NUM_LIT:2><EOL>c = <NUM_LIT:2> * asin(sqrt(a))<EOL>r = <NUM_LIT>  <EOL>return c * r<EOL>", "docstring": "Calculate the great circle distance between two\npoints on the earth (specified in decimal degrees)", "id": "f4606:m7"}
{"signature": "def is_consistent_type(theType, name, *constructionArgs):", "body": "assert theType.__name__ == name<EOL>assert isinstance(theType, type)<EOL>instance = theType(*constructionArgs)<EOL>assert type(instance) is theType<EOL>return True<EOL>", "docstring": "Perform various assertions about *theType* to ensure that it is a\nwell-defined type.  This is useful for extension types, where it's\npretty easy to do something wacky.  If something about the type is\nunusual, an exception will be raised.\n\n:param theType: The type object about which to make assertions.\n:param name: A string giving the name of the type.\n:param constructionArgs: Positional arguments to use with\n    *theType* to create an instance of it.", "id": "f4610:m0"}
{"signature": "def anotherInstance(self):", "body": "raise NotImplementedError()<EOL>", "docstring": "Return an instance of the class under test.  Each call to this method\nmust return a different object.  The objects must not be equal to the\nobjects returned by C{anInstance}.  They may or may not be equal to\neach other (they will not be compared against each other).", "id": "f4610:c0:m1"}
{"signature": "def anInstance(self):", "body": "raise NotImplementedError()<EOL>", "docstring": "Return an instance of the class under test.  Each call to this method\nmust return a different object.  All objects returned must be equal to\neach other.", "id": "f4610:c0:m0"}
{"signature": "def interact_in_memory(client_conn, server_conn):", "body": "wrote = True<EOL>while wrote:<EOL><INDENT>wrote = False<EOL>for (read, write) in [(client_conn, server_conn),<EOL>(server_conn, client_conn)]:<EOL><INDENT>try:<EOL><INDENT>data = read.recv(<NUM_LIT:2> ** <NUM_LIT:16>)<EOL><DEDENT>except WantReadError:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>return (read, data)<EOL><DEDENT>while True:<EOL><INDENT>try:<EOL><INDENT>dirty = read.bio_read(<NUM_LIT>)<EOL><DEDENT>except WantReadError:<EOL><INDENT>break<EOL><DEDENT>else:<EOL><INDENT>wrote = True<EOL>write.bio_write(dirty)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Try to read application bytes from each of the two `Connection` objects.\nCopy bytes back and forth between their send/receive buffers for as long\nas there is anything to copy.  When there is nothing more to copy,\nreturn `None`.  If one of them actually manages to deliver some application\nbytes, return a two-tuple of the connection from which the bytes were read\nand the bytes themselves.", "id": "f4612:m10"}
{"signature": "def _server_connection(self, callback, data):", "body": "ctx = Context(SSLv23_METHOD)<EOL>ctx.use_privatekey(load_privatekey(FILETYPE_PEM, server_key_pem))<EOL>ctx.use_certificate(load_certificate(FILETYPE_PEM, server_cert_pem))<EOL>ctx.set_ocsp_server_callback(callback, data)<EOL>server = Connection(ctx)<EOL>server.set_accept_state()<EOL>return server<EOL>", "docstring": "Builds a server connection suitable for using OCSP.\n\n:param callback: The callback to register for OCSP.\n:param data: The opaque data object that will be handed to the\n    OCSP callback.", "id": "f4612:c18:m1"}
{"signature": "def join_bytes_or_unicode(prefix, suffix):", "body": "<EOL>if type(prefix) == type(suffix):<EOL><INDENT>return join(prefix, suffix)<EOL><DEDENT>if isinstance(prefix, text_type):<EOL><INDENT>return join(prefix, suffix.decode(getfilesystemencoding()))<EOL><DEDENT>else:<EOL><INDENT>return join(prefix, suffix.encode(getfilesystemencoding()))<EOL><DEDENT>", "docstring": "Join two path components of either ``bytes`` or ``unicode``.\n\nThe return type is the same as the type of ``prefix``.", "id": "f4612:m2"}
{"signature": "def loopback(server_factory=None, client_factory=None):", "body": "if server_factory is None:<EOL><INDENT>server_factory = loopback_server_factory<EOL><DEDENT>if client_factory is None:<EOL><INDENT>client_factory = loopback_client_factory<EOL><DEDENT>(server, client) = socket_pair()<EOL>server = server_factory(server)<EOL>client = client_factory(client)<EOL>handshake(client, server)<EOL>server.setblocking(True)<EOL>client.setblocking(True)<EOL>return server, client<EOL>", "docstring": "Create a connected socket pair and force two connected SSL sockets\nto talk to each other via memory BIOs.", "id": "f4612:m9"}
{"signature": "def check_recovery(self, p12_str, key=None, cert=None, ca=None, passwd=b\"<STR_LIT>\",<EOL>extra=()):", "body": "if key:<EOL><INDENT>recovered_key = _runopenssl(<EOL>p12_str, b\"<STR_LIT>\", b\"<STR_LIT>\", b\"<STR_LIT>\", b\"<STR_LIT>\",<EOL>b\"<STR_LIT>\" + passwd, *extra)<EOL>assert recovered_key[-len(key):] == key<EOL><DEDENT>if cert:<EOL><INDENT>recovered_cert = _runopenssl(<EOL>p12_str, b\"<STR_LIT>\", b\"<STR_LIT>\", b\"<STR_LIT>\", b\"<STR_LIT>\",<EOL>b\"<STR_LIT>\" + passwd, b\"<STR_LIT>\", *extra)<EOL>assert recovered_cert[-len(cert):] == cert<EOL><DEDENT>if ca:<EOL><INDENT>recovered_cert = _runopenssl(<EOL>p12_str, b\"<STR_LIT>\", b\"<STR_LIT>\", b\"<STR_LIT>\", b\"<STR_LIT>\",<EOL>b\"<STR_LIT>\" + passwd, b\"<STR_LIT>\", *extra)<EOL>assert recovered_cert[-len(ca):] == ca<EOL><DEDENT>", "docstring": "Use openssl program to confirm three components are recoverable from a\nPKCS12 string.", "id": "f4617:c7:m6"}
{"signature": "def _setBoundTest(self, which):", "body": "certificate = X509()<EOL>set = getattr(certificate, '<STR_LIT>' + which)<EOL>get = getattr(certificate, '<STR_LIT>' + which)<EOL>assert get() is None<EOL>when = b\"<STR_LIT>\"<EOL>set(when)<EOL>assert get() == when<EOL>when = b\"<STR_LIT>\"<EOL>set(when)<EOL>assert get() == when<EOL>when = b\"<STR_LIT>\"<EOL>set(when)<EOL>assert get() == when<EOL>with pytest.raises(ValueError):<EOL><INDENT>set(b\"<STR_LIT>\")<EOL><DEDENT>with pytest.raises(TypeError):<EOL><INDENT>set()<EOL><DEDENT>with pytest.raises(TypeError):<EOL><INDENT>set(b\"<STR_LIT>\", b\"<STR_LIT>\")<EOL><DEDENT>with pytest.raises(TypeError):<EOL><INDENT>get(b\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "`X509.set_notBefore` takes a string in the format of an\nASN1 GENERALIZEDTIME and sets the beginning of the certificate's\nvalidity period to it.", "id": "f4617:c5:m6"}
{"signature": "def signable(self):", "body": "return X509Req()<EOL>", "docstring": "Create and return a new `X509Req`.", "id": "f4617:c4:m0"}
{"signature": "def signable(self):", "body": "raise NotImplementedError()<EOL>", "docstring": "Return something with a `set_pubkey`, `set_pubkey`, and `sign` method.", "id": "f4617:c3:m0"}
{"signature": "def gen_pkcs12(self, cert_pem=None, key_pem=None, ca_pem=None,<EOL>friendly_name=None):", "body": "p12 = PKCS12()<EOL>if cert_pem:<EOL><INDENT>ret = p12.set_certificate(load_certificate(FILETYPE_PEM, cert_pem))<EOL>assert ret is None<EOL><DEDENT>if key_pem:<EOL><INDENT>ret = p12.set_privatekey(load_privatekey(FILETYPE_PEM, key_pem))<EOL>assert ret is None<EOL><DEDENT>if ca_pem:<EOL><INDENT>ret = p12.set_ca_certificates(<EOL>(load_certificate(FILETYPE_PEM, ca_pem),)<EOL>)<EOL>assert ret is None<EOL><DEDENT>if friendly_name:<EOL><INDENT>ret = p12.set_friendlyname(friendly_name)<EOL>assert ret is None<EOL><DEDENT>return p12<EOL>", "docstring": "Generate a PKCS12 object with components from PEM.  Verify that the set\nfunctions return None.", "id": "f4617:c7:m5"}
{"signature": "def read_file(*parts):", "body": "with codecs.open(os.path.join(HERE, *parts), \"<STR_LIT:rb>\", \"<STR_LIT:ascii>\") as f:<EOL><INDENT>return f.read()<EOL><DEDENT>", "docstring": "Build an absolute path from *parts* and return the contents of the\nresulting file.  Assume UTF-8 encoding.", "id": "f4619:m0"}
{"signature": "def main():", "body": "port = socket()<EOL>port.setsockopt(SOL_SOCKET, SO_REUSEADDR, <NUM_LIT:1>)<EOL>port.bind(('<STR_LIT>', <NUM_LIT>))<EOL>port.listen(<NUM_LIT:3>)<EOL>print('<STR_LIT>', end=\"<STR_LIT>\")<EOL>stdout.flush()<EOL>server, addr = port.accept()<EOL>print('<STR_LIT>', addr)<EOL>server_context = Context(TLSv1_METHOD)<EOL>server_context.set_tlsext_servername_callback(pick_certificate)<EOL>server_ssl = Connection(server_context, server)<EOL>server_ssl.set_accept_state()<EOL>server_ssl.do_handshake()<EOL>server.close()<EOL>", "docstring": "Run an SNI-enabled server which selects between a few certificates in a\nC{dict} based on the handshake request it receives from a client.", "id": "f4622:m1"}
{"signature": "def createKeyPair(type, bits):", "body": "pkey = crypto.PKey()<EOL>pkey.generate_key(type, bits)<EOL>return pkey<EOL>", "docstring": "Create a public/private key pair.\n\nArguments: type - Key type, must be one of TYPE_RSA and TYPE_DSA\n           bits - Number of bits to use in the key\nReturns:   The public/private key pair in a PKey object", "id": "f4624:m0"}
{"signature": "def createCertificate(req, issuerCertKey, serial, validityPeriod,<EOL>digest=\"<STR_LIT>\"):", "body": "issuerCert, issuerKey = issuerCertKey<EOL>notBefore, notAfter = validityPeriod<EOL>cert = crypto.X509()<EOL>cert.set_serial_number(serial)<EOL>cert.gmtime_adj_notBefore(notBefore)<EOL>cert.gmtime_adj_notAfter(notAfter)<EOL>cert.set_issuer(issuerCert.get_subject())<EOL>cert.set_subject(req.get_subject())<EOL>cert.set_pubkey(req.get_pubkey())<EOL>cert.sign(issuerKey, digest)<EOL>return cert<EOL>", "docstring": "Generate a certificate given a certificate request.\n\nArguments: req        - Certificate request to use\n           issuerCert - The certificate of the issuer\n           issuerKey  - The private key of the issuer\n           serial     - Serial number for the certificate\n           notBefore  - Timestamp (relative to now) when the certificate\n                        starts being valid\n           notAfter   - Timestamp (relative to now) when the certificate\n                        stops being valid\n           digest     - Digest method to use for signing, default is sha256\nReturns:   The signed certificate in an X509 object", "id": "f4624:m2"}
{"signature": "def createCertRequest(pkey, digest=\"<STR_LIT>\", **name):", "body": "req = crypto.X509Req()<EOL>subj = req.get_subject()<EOL>for key, value in name.items():<EOL><INDENT>setattr(subj, key, value)<EOL><DEDENT>req.set_pubkey(pkey)<EOL>req.sign(pkey, digest)<EOL>return req<EOL>", "docstring": "Create a certificate request.\n\nArguments: pkey   - The key to associate with the request\n           digest - Digestion method to use for signing, default is sha256\n           **name - The name of the subject of the request, possible\n                    arguments are:\n                      C     - Country name\n                      ST    - State or province name\n                      L     - Locality name\n                      O     - Organization name\n                      OU    - Organizational unit name\n                      CN    - Common name\n                      emailAddress - E-mail address\nReturns:   The certificate request in an X509Req object", "id": "f4624:m1"}
{"signature": "def accept(self):", "body": "c, a = self.__dict__[\"<STR_LIT>\"].accept()<EOL>return (SSLWrapper(c), a)<EOL>", "docstring": "This is the other part of the shutdown() workaround.\nSince servers create new sockets, we have to infect\nthem with our magic. :)", "id": "f4627:c0:m4"}
{"signature": "def __init__(self, addr,<EOL>requestHandler=SecureXMLRPCRequestHandler,<EOL>logRequests=<NUM_LIT:1>):", "body": "self.funcs = {}<EOL>self.logRequests = logRequests<EOL>self.instance = None<EOL>SecureTCPServer.__init__(self, addr, requestHandler)<EOL>", "docstring": "This is the exact same code as SimpleXMLRPCServer.__init__\nexcept it calls SecureTCPServer.__init__ instead of plain\nold TCPServer.__init__", "id": "f4627:c3:m0"}
{"signature": "def setup(self):", "body": "self.connection = self.request  <EOL>self.rfile = socket._fileobject(self.request, \"<STR_LIT:rb>\", self.rbufsize)<EOL>self.wfile = socket._fileobject(self.request, \"<STR_LIT:wb>\", self.wbufsize)<EOL>", "docstring": "We need to use socket._fileobject Because SSL.Connection\ndoesn't have a 'dup'. Not exactly sure WHY this is, but\nthis is backed up by comments in socket.py and SSL/connection.c", "id": "f4627:c2:m0"}
{"signature": "def check_success(self):", "body": "small = range(<NUM_LIT:3>)<EOL>for i in range(self.iterations):<EOL><INDENT>key = PKey()<EOL>key.generate_key(TYPE_DSA, <NUM_LIT>)<EOL>for i in small:<EOL><INDENT>cert = X509()<EOL>cert.set_pubkey(key)<EOL>for i in small:<EOL><INDENT>cert.get_pubkey()<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Call the method repeatedly such that it will return a PKey object.", "id": "f4628:c1:m1"}
{"signature": "def check_load_privatekey_callback_wrong_type(self):", "body": "for i in range(self.iterations * <NUM_LIT:10>):<EOL><INDENT>try:<EOL><INDENT>load_privatekey(<EOL>FILETYPE_PEM, self.ENCRYPTED_PEM,<EOL>lambda *args: {})<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>", "docstring": "Call the function with an encrypted PEM and a passphrase callback which\nreturns a non-string.", "id": "f4628:c2:m2"}
{"signature": "def check_load_privatekey_callback(self):", "body": "for i in range(self.iterations * <NUM_LIT:10>):<EOL><INDENT>load_privatekey(<EOL>FILETYPE_PEM, self.ENCRYPTED_PEM, lambda *args: \"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Call the function with an encrypted PEM and a passphrase callback.", "id": "f4628:c2:m0"}
{"signature": "def make_assert(error):", "body": "def openssl_assert(ok):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if ok is not True:<EOL><INDENT>exception_from_error_queue(error)<EOL><DEDENT><DEDENT>return openssl_assert<EOL>", "docstring": "Create an assert function that uses :func:`exception_from_error_queue` to\nraise an exception wrapped by *error*.", "id": "f4635:m2"}
{"signature": "def path_string(s):", "body": "if isinstance(s, binary_type):<EOL><INDENT>return s<EOL><DEDENT>elif isinstance(s, text_type):<EOL><INDENT>return s.encode(sys.getfilesystemencoding())<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Convert a Python string to a :py:class:`bytes` string identifying the same\npath and which can be passed into an OpenSSL API accepting a filename.\n\n:param s: An instance of :py:class:`bytes` or :py:class:`unicode`.\n\n:return: An instance of :py:class:`bytes`.", "id": "f4635:m4"}
{"signature": "def set_tlsext_host_name(self, name):", "body": "if not isinstance(name, bytes):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>elif b\"<STR_LIT>\" in name:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>_lib.SSL_set_tlsext_host_name(self._ssl, name)<EOL>", "docstring": "Set the value of the servername extension to send in the client hello.\n\n:param name: A byte string giving the name.\n\n.. versionadded:: 0.13", "id": "f4636:c15:m6"}
{"signature": "def get_cipher_version(self):", "body": "cipher = _lib.SSL_get_current_cipher(self._ssl)<EOL>if cipher == _ffi.NULL:<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>version = _ffi.string(_lib.SSL_CIPHER_get_version(cipher))<EOL>return version.decode(\"<STR_LIT:utf-8>\")<EOL><DEDENT>", "docstring": "Obtain the protocol version of the currently used cipher.\n\n:returns: The protocol name of the currently used cipher\n    or :obj:`None` if no connection has been established.\n:rtype: :class:`unicode` or :class:`NoneType`\n\n.. versionadded:: 0.15", "id": "f4636:c15:m51"}
{"signature": "def bio_write(self, buf):", "body": "buf = _text_to_bytes_and_warn(\"<STR_LIT>\", buf)<EOL>if self._into_ssl is None:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>result = _lib.BIO_write(self._into_ssl, buf, len(buf))<EOL>if result <= <NUM_LIT:0>:<EOL><INDENT>self._handle_bio_errors(self._into_ssl, result)<EOL><DEDENT>return result<EOL>", "docstring": "If the Connection was created with a memory BIO, this method can be\nused to add bytes to the read end of that memory BIO.  The Connection\ncan then read the bytes (for example, in response to a call to\n:meth:`recv`).\n\n:param buf: The string to put into the memory BIO.\n:return: The number of bytes written", "id": "f4636:c15:m14"}
{"signature": "def set_tlsext_use_srtp(self, profiles):", "body": "if not isinstance(profiles, bytes):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>_openssl_assert(<EOL>_lib.SSL_CTX_set_tlsext_use_srtp(self._context, profiles) == <NUM_LIT:0><EOL>)<EOL>", "docstring": "Enable support for negotiating SRTP keying material.\n\n:param bytes profiles: A colon delimited list of protection profile\n    names, like ``b'SRTP_AES128_CM_SHA1_80:SRTP_AES128_CM_SHA1_32'``.\n:return: None", "id": "f4636:c14:m37"}
{"signature": "def export_keying_material(self, label, olen, context=None):", "body": "outp = _no_zero_allocator(\"<STR_LIT>\", olen)<EOL>context_buf = _ffi.NULL<EOL>context_len = <NUM_LIT:0><EOL>use_context = <NUM_LIT:0><EOL>if context is not None:<EOL><INDENT>context_buf = context<EOL>context_len = len(context)<EOL>use_context = <NUM_LIT:1><EOL><DEDENT>success = _lib.SSL_export_keying_material(self._ssl, outp, olen,<EOL>label, len(label),<EOL>context_buf, context_len,<EOL>use_context)<EOL>_openssl_assert(success == <NUM_LIT:1>)<EOL>return _ffi.buffer(outp, olen)[:]<EOL>", "docstring": "Obtain keying material for application use.\n\n:param: label - a disambiguating label string as described in RFC 5705\n:param: olen - the length of the exported key material in bytes\n:param: context - a per-association context value\n:return: the exported key material bytes or None", "id": "f4636:c15:m35"}
{"signature": "def set_shutdown(self, state):", "body": "if not isinstance(state, integer_types):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>_lib.SSL_set_shutdown(self._ssl, state)<EOL>", "docstring": "Set the shutdown state of the Connection.\n\n:param state: bitvector of SENT_SHUTDOWN, RECEIVED_SHUTDOWN.\n:return: None", "id": "f4636:c15:m30"}
{"signature": "def get_cert_store(self):", "body": "store = _lib.SSL_CTX_get_cert_store(self._context)<EOL>if store == _ffi.NULL:<EOL><INDENT>return None<EOL><DEDENT>pystore = X509Store.__new__(X509Store)<EOL>pystore._store = store<EOL>return pystore<EOL>", "docstring": "Get the certificate store for the context.  This can be used to add\n\"trusted\" certificates without using the\n:meth:`load_verify_locations` method.\n\n:return: A X509Store object or None if it does not have one.", "id": "f4636:c14:m33"}
{"signature": "def raise_if_problem(self):", "body": "if self._problems:<EOL><INDENT>try:<EOL><INDENT>_raise_current_error()<EOL><DEDENT>except Error:<EOL><INDENT>pass<EOL><DEDENT>raise self._problems.pop(<NUM_LIT:0>)<EOL><DEDENT>", "docstring": "Raise an exception from the OpenSSL error queue or that was previously\ncaptured whe running a callback.", "id": "f4636:c6:m1"}
{"signature": "def client_random(self):", "body": "session = _lib.SSL_get_session(self._ssl)<EOL>if session == _ffi.NULL:<EOL><INDENT>return None<EOL><DEDENT>length = _lib.SSL_get_client_random(self._ssl, _ffi.NULL, <NUM_LIT:0>)<EOL>assert length > <NUM_LIT:0><EOL>outp = _no_zero_allocator(\"<STR_LIT>\", length)<EOL>_lib.SSL_get_client_random(self._ssl, outp, length)<EOL>return _ffi.buffer(outp, length)[:]<EOL>", "docstring": "Retrieve the random value used with the client hello message.\n\n:return: A string representing the state", "id": "f4636:c15:m33"}
{"signature": "def get_cipher_list(self):", "body": "ciphers = []<EOL>for i in count():<EOL><INDENT>result = _lib.SSL_get_cipher_list(self._ssl, i)<EOL>if result == _ffi.NULL:<EOL><INDENT>break<EOL><DEDENT>ciphers.append(_native(_ffi.string(result)))<EOL><DEDENT>return ciphers<EOL>", "docstring": "Retrieve the list of ciphers used by the Connection object.\n\n:return: A list of native cipher strings.", "id": "f4636:c15:m24"}
{"signature": "def total_renegotiations(self):", "body": "return _lib.SSL_total_renegotiations(self._ssl)<EOL>", "docstring": "Find out the total number of renegotiations.\n\n:return: The number of renegotiations.\n:rtype: int", "id": "f4636:c15:m18"}
{"signature": "def makefile(self, *args, **kwargs):", "body": "raise NotImplementedError(<EOL>\"<STR_LIT>\")<EOL>", "docstring": "The makefile() method is not implemented, since there is no dup\nsemantics for SSL connections\n\n:raise: NotImplementedError", "id": "f4636:c15:m26"}
{"signature": "def bio_read(self, bufsiz):", "body": "if self._from_ssl is None:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if not isinstance(bufsiz, integer_types):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>buf = _no_zero_allocator(\"<STR_LIT>\", bufsiz)<EOL>result = _lib.BIO_read(self._from_ssl, buf, bufsiz)<EOL>if result <= <NUM_LIT:0>:<EOL><INDENT>self._handle_bio_errors(self._from_ssl, result)<EOL><DEDENT>return _ffi.buffer(buf, result)[:]<EOL>", "docstring": "If the Connection was created with a memory BIO, this method can be\nused to read bytes from the write end of that memory BIO.  Many\nConnection methods will add bytes which must be read in this manner or\nthe buffer will eventually fill up and the Connection will be able to\ntake no further actions.\n\n:param bufsiz: The maximum number of bytes to read\n:return: The string read.", "id": "f4636:c15:m13"}
{"signature": "def __getattr__(self, name):", "body": "if self._socket is None:<EOL><INDENT>raise AttributeError(\"<STR_LIT>\" % (<EOL>self.__class__.__name__, name<EOL>))<EOL><DEDENT>else:<EOL><INDENT>return getattr(self._socket, name)<EOL><DEDENT>", "docstring": "Look up attributes on the wrapped socket object if they are not found\non the Connection object.", "id": "f4636:c15:m1"}
{"signature": "def get_context(self):", "body": "return self._context<EOL>", "docstring": "Retrieve the :class:`Context` object associated with this\n:class:`Connection`.", "id": "f4636:c15:m3"}
{"signature": "def renegotiate(self):", "body": "if not self.renegotiate_pending():<EOL><INDENT>_openssl_assert(_lib.SSL_renegotiate(self._ssl) == <NUM_LIT:1>)<EOL>return True<EOL><DEDENT>return False<EOL>", "docstring": "Renegotiate the session.\n\n:return: True if the renegotiation can be started, False otherwise\n:rtype: bool", "id": "f4636:c15:m15"}
{"signature": "def request_ocsp(self):", "body": "rc = _lib.SSL_set_tlsext_status_type(<EOL>self._ssl, _lib.TLSEXT_STATUSTYPE_ocsp<EOL>)<EOL>_openssl_assert(rc == <NUM_LIT:1>)<EOL>", "docstring": "Called to request that the server sends stapled OCSP data, if\navailable. If this is not called on the client side then the server\nwill not send OCSP data. Should be used in conjunction with\n:meth:`Context.set_ocsp_client_callback`.", "id": "f4636:c15:m57"}
{"signature": "def get_verify_depth(self):", "body": "return _lib.SSL_CTX_get_verify_depth(self._context)<EOL>", "docstring": "Retrieve the Context object's verify depth, as set by\n:meth:`set_verify_depth`.\n\n:return: The verify depth", "id": "f4636:c14:m22"}
{"signature": "def _make_requires(flag, error):", "body": "def _requires_decorator(func):<EOL><INDENT>if not flag:<EOL><INDENT>@wraps(func)<EOL>def explode(*args, **kwargs):<EOL><INDENT>raise NotImplementedError(error)<EOL><DEDENT>return explode<EOL><DEDENT>else:<EOL><INDENT>return func<EOL><DEDENT><DEDENT>return _requires_decorator<EOL>", "docstring": "Builds a decorator that ensures that functions that rely on OpenSSL\nfunctions that are not present in this build raise NotImplementedError,\nrather than AttributeError coming out of cryptography.\n\n:param flag: A cryptography flag that guards the functions, e.g.\n    ``Cryptography_HAS_NEXTPROTONEG``.\n:param error: The string to be used in the exception if the flag is false.", "id": "f4636:m3"}
{"signature": "def get_app_data(self):", "body": "return self._app_data<EOL>", "docstring": "Get the application data (supplied via :meth:`set_app_data()`)\n\n:return: The application data", "id": "f4636:c14:m31"}
{"signature": "def b64_encode(self):", "body": "encoded = _lib.NETSCAPE_SPKI_b64_encode(self._spki)<EOL>result = _ffi.string(encoded)<EOL>_lib.OPENSSL_free(encoded)<EOL>return result<EOL>", "docstring": "Generate a base64 encoded representation of this SPKI object.\n\n:return: The base64 encoded string.\n:rtype: :py:class:`bytes`", "id": "f4638:c16:m3"}
{"signature": "def load_certificate(type, buffer):", "body": "if isinstance(buffer, _text_type):<EOL><INDENT>buffer = buffer.encode(\"<STR_LIT:ascii>\")<EOL><DEDENT>bio = _new_mem_buf(buffer)<EOL>if type == FILETYPE_PEM:<EOL><INDENT>x509 = _lib.PEM_read_bio_X509(bio, _ffi.NULL, _ffi.NULL, _ffi.NULL)<EOL><DEDENT>elif type == FILETYPE_ASN1:<EOL><INDENT>x509 = _lib.d2i_X509_bio(bio, _ffi.NULL)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>if x509 == _ffi.NULL:<EOL><INDENT>_raise_current_error()<EOL><DEDENT>return X509._from_raw_x509_ptr(x509)<EOL>", "docstring": "Load a certificate (X509) from the string *buffer* encoded with the\ntype *type*.\n\n:param type: The file type (one of FILETYPE_PEM, FILETYPE_ASN1)\n\n:param bytes buffer: The buffer the certificate is stored in\n\n:return: The X509 object", "id": "f4638:m8"}
{"signature": "def get_notBefore(self):", "body": "return self._get_boundary_time(_lib.X509_get_notBefore)<EOL>", "docstring": "Get the timestamp at which the certificate starts being valid.\n\nThe timestamp is formatted as an ASN.1 TIME::\n\n    YYYYMMDDhhmmssZ\n\n:return: A timestamp string, or ``None`` if there is none.\n:rtype: bytes or NoneType", "id": "f4638:c7:m18"}
{"signature": "def get_elliptic_curves():", "body": "return _EllipticCurve._get_elliptic_curves(_lib)<EOL>", "docstring": "Return a set of objects representing the elliptic curves supported in the\nOpenSSL build in use.\n\nThe curve objects have a :py:class:`unicode` ``name`` attribute by which\nthey identify themselves.\n\nThe curve objects are useful as values for the argument accepted by\n:py:meth:`Context.set_tmp_ecdh` to specify which elliptical curve should be\nused for ECDHE key exchange.", "id": "f4638:m6"}
{"signature": "def add_cert(self, cert):", "body": "if not isinstance(cert, X509):<EOL><INDENT>raise TypeError()<EOL><DEDENT>if _lib.X509_STORE_add_cert(self._store, cert._x509) == <NUM_LIT:0>:<EOL><INDENT>code = _lib.ERR_peek_error()<EOL>err_reason = _lib.ERR_GET_REASON(code)<EOL>_openssl_assert(<EOL>err_reason == _lib.X509_R_CERT_ALREADY_IN_HASH_TABLE<EOL>)<EOL>_lib.ERR_clear_error()<EOL><DEDENT>", "docstring": "Adds a trusted certificate to this store.\n\nAdding a certificate with this method adds this certificate as a\n*trusted* certificate.\n\n:param X509 cert: The certificate to add to this store.\n\n:raises TypeError: If the certificate is not an :class:`X509`.\n\n:raises OpenSSL.crypto.Error: If OpenSSL was unhappy with your\n    certificate.\n\n:return: ``None`` if the certificate was added successfully.", "id": "f4638:c9:m1"}
{"signature": "def get_data(self):", "body": "octet_result = _lib.X509_EXTENSION_get_data(self._extension)<EOL>string_result = _ffi.cast('<STR_LIT>', octet_result)<EOL>char_result = _lib.ASN1_STRING_data(string_result)<EOL>result_length = _lib.ASN1_STRING_length(string_result)<EOL>return _ffi.buffer(char_result, result_length)[:]<EOL>", "docstring": "Returns the data of the X509 extension, encoded as ASN.1.\n\n:return: The ASN.1 encoded data of this X509 extension.\n:rtype: :py:data:`bytes`\n\n.. versionadded:: 0.12", "id": "f4638:c5:m6"}
{"signature": "def get_components(self):", "body": "result = []<EOL>for i in range(_lib.X509_NAME_entry_count(self._name)):<EOL><INDENT>ent = _lib.X509_NAME_get_entry(self._name, i)<EOL>fname = _lib.X509_NAME_ENTRY_get_object(ent)<EOL>fval = _lib.X509_NAME_ENTRY_get_data(ent)<EOL>nid = _lib.OBJ_obj2nid(fname)<EOL>name = _lib.OBJ_nid2sn(nid)<EOL>value = _ffi.buffer(_lib.ASN1_STRING_data(fval),<EOL>_lib.ASN1_STRING_length(fval))[:]<EOL>result.append((_ffi.string(name), value))<EOL><DEDENT>return result<EOL>", "docstring": "Returns the components of this name, as a sequence of 2-tuples.\n\n:return: The components of this name.\n:rtype: :py:class:`list` of ``name, value`` tuples.", "id": "f4638:c4:m7"}
{"signature": "def has_expired(self):", "body": "time_string = _native(self.get_notAfter())<EOL>not_after = datetime.datetime.strptime(time_string, \"<STR_LIT>\")<EOL>return not_after < datetime.datetime.utcnow()<EOL>", "docstring": "Check whether the certificate has expired.\n\n:return: ``True`` if the certificate has expired, ``False`` otherwise.\n:rtype: bool", "id": "f4638:c7:m16"}
{"signature": "def _exception_from_context(self):", "body": "errors = [<EOL>_lib.X509_STORE_CTX_get_error(self._store_ctx),<EOL>_lib.X509_STORE_CTX_get_error_depth(self._store_ctx),<EOL>_native(_ffi.string(_lib.X509_verify_cert_error_string(<EOL>_lib.X509_STORE_CTX_get_error(self._store_ctx)))),<EOL>]<EOL>_x509 = _lib.X509_STORE_CTX_get_current_cert(self._store_ctx)<EOL>_cert = _lib.X509_dup(_x509)<EOL>pycert = X509._from_raw_x509_ptr(_cert)<EOL>return X509StoreContextError(errors, pycert)<EOL>", "docstring": "Convert an OpenSSL native context error failure into a Python\nexception.\n\nWhen a call to native OpenSSL X509_verify_cert fails, additional\ninformation about the failure can be obtained from the store context.", "id": "f4638:c11:m3"}
{"signature": "@classmethod<EOL><INDENT>def from_cryptography(cls, crypto_cert):<DEDENT>", "body": "if not isinstance(crypto_cert, x509.Certificate):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>cert = cls()<EOL>cert._x509 = crypto_cert._x509<EOL>return cert<EOL>", "docstring": "Construct based on a ``cryptography`` *crypto_cert*.\n\n:param crypto_key: A ``cryptography`` X.509 certificate.\n:type crypto_key: ``cryptography.x509.Certificate``\n\n:rtype: X509\n\n.. versionadded:: 17.1.0", "id": "f4638:c7:m3"}
{"signature": "def bits(self):", "body": "return _lib.EVP_PKEY_bits(self._pkey)<EOL>", "docstring": "Returns the number of bits of the key\n\n:return: The number of bits of the key.", "id": "f4638:c2:m6"}
{"signature": "def load_privatekey(type, buffer, passphrase=None):", "body": "if isinstance(buffer, _text_type):<EOL><INDENT>buffer = buffer.encode(\"<STR_LIT:ascii>\")<EOL><DEDENT>bio = _new_mem_buf(buffer)<EOL>helper = _PassphraseHelper(type, passphrase)<EOL>if type == FILETYPE_PEM:<EOL><INDENT>evp_pkey = _lib.PEM_read_bio_PrivateKey(<EOL>bio, _ffi.NULL, helper.callback, helper.callback_args)<EOL>helper.raise_if_problem()<EOL><DEDENT>elif type == FILETYPE_ASN1:<EOL><INDENT>evp_pkey = _lib.d2i_PrivateKey_bio(bio, _ffi.NULL)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if evp_pkey == _ffi.NULL:<EOL><INDENT>_raise_current_error()<EOL><DEDENT>pkey = PKey.__new__(PKey)<EOL>pkey._pkey = _ffi.gc(evp_pkey, _lib.EVP_PKEY_free)<EOL>return pkey<EOL>", "docstring": "Load a private key (PKey) from the string *buffer* encoded with the type\n*type*.\n\n:param type: The file type (one of FILETYPE_PEM, FILETYPE_ASN1)\n:param buffer: The buffer the key is stored in\n:param passphrase: (optional) if encrypted PEM format, this can be\n                   either the passphrase to use, or a callback for\n                   providing the passphrase.\n\n:return: The PKey object", "id": "f4638:m13"}
{"signature": "def get_extension(self, index):", "body": "ext = X509Extension.__new__(X509Extension)<EOL>ext._extension = _lib.X509_get_ext(self._x509, index)<EOL>if ext._extension == _ffi.NULL:<EOL><INDENT>raise IndexError(\"<STR_LIT>\")<EOL><DEDENT>extension = _lib.X509_EXTENSION_dup(ext._extension)<EOL>ext._extension = _ffi.gc(extension, _lib.X509_EXTENSION_free)<EOL>return ext<EOL>", "docstring": "Get a specific extension of the certificate by index.\n\nExtensions on a certificate are kept in order. The index\nparameter selects which extension will be returned.\n\n:param int index: The index of the extension to retrieve.\n:return: The extension at the specified index.\n:rtype: :py:class:`X509Extension`\n:raises IndexError: If the extension index was out of bounds.\n\n.. versionadded:: 0.12", "id": "f4638:c7:m31"}
{"signature": "def get_privatekey(self):", "body": "return self._pkey<EOL>", "docstring": "Get the private key in the PKCS #12 structure.\n\n:return: The private key, or :py:const:`None` if there is none.\n:rtype: :py:class:`PKey`", "id": "f4638:c15:m3"}
{"signature": "def type_is_signedAndEnveloped(self):", "body": "return bool(_lib.PKCS7_type_is_signedAndEnveloped(self._pkcs7))<EOL>", "docstring": "Check if this NID_pkcs7_signedAndEnveloped object\n\n:returns: True if the PKCS7 is of type signedAndEnveloped", "id": "f4638:c14:m2"}
{"signature": "def set_nextUpdate(self, when):", "body": "return self._set_boundary_time(_lib.X509_CRL_get_nextUpdate, when)<EOL>", "docstring": "Set when the CRL will next be udpated.\n\nThe timestamp is formatted as an ASN.1 TIME::\n\n    YYYYMMDDhhmmssZ\n\n.. versionadded:: 16.1.0\n\n:param bytes when: A timestamp string.\n:return: ``None``", "id": "f4638:c13:m9"}
{"signature": "def get_issuer(self):", "body": "_issuer = _lib.X509_NAME_dup(_lib.X509_CRL_get_issuer(self._crl))<EOL>_openssl_assert(_issuer != _ffi.NULL)<EOL>_issuer = _ffi.gc(_issuer, _lib.X509_NAME_free)<EOL>issuer = X509Name.__new__(X509Name)<EOL>issuer._name = _issuer<EOL>return issuer<EOL>", "docstring": "Get the CRL's issuer.\n\n.. versionadded:: 16.1.0\n\n:rtype: X509Name", "id": "f4638:c13:m5"}
{"signature": "def gmtime_adj_notAfter(self, amount):", "body": "if not isinstance(amount, int):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>notAfter = _lib.X509_get_notAfter(self._x509)<EOL>_lib.X509_gmtime_adj(notAfter, amount)<EOL>", "docstring": "Adjust the time stamp on which the certificate stops being valid.\n\n:param int amount: The number of seconds by which to adjust the\n    timestamp.\n:return: ``None``", "id": "f4638:c7:m14"}
{"signature": "def set_reason(self, reason):", "body": "if reason is None:<EOL><INDENT>self._delete_reason()<EOL><DEDENT>elif not isinstance(reason, bytes):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>reason = reason.lower().replace(b'<STR_LIT:U+0020>', b'<STR_LIT>')<EOL>reason_code = [r.lower() for r in self._crl_reasons].index(reason)<EOL>new_reason_ext = _lib.ASN1_ENUMERATED_new()<EOL>_openssl_assert(new_reason_ext != _ffi.NULL)<EOL>new_reason_ext = _ffi.gc(new_reason_ext, _lib.ASN1_ENUMERATED_free)<EOL>set_result = _lib.ASN1_ENUMERATED_set(new_reason_ext, reason_code)<EOL>_openssl_assert(set_result != _ffi.NULL)<EOL>self._delete_reason()<EOL>add_result = _lib.X509_REVOKED_add1_ext_i2d(<EOL>self._revoked, _lib.NID_crl_reason, new_reason_ext, <NUM_LIT:0>, <NUM_LIT:0>)<EOL>_openssl_assert(add_result == <NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Set the reason of this revocation.\n\nIf :data:`reason` is ``None``, delete the reason instead.\n\n:param reason: The reason string.\n:type reason: :class:`bytes` or :class:`NoneType`\n\n:return: ``None``\n\n.. seealso::\n\n    :meth:`all_reasons`, which gives you a list of all supported\n    reasons which you might pass to this method.", "id": "f4638:c12:m4"}
{"signature": "def get_notAfter(self):", "body": "return self._get_boundary_time(_lib.X509_get_notAfter)<EOL>", "docstring": "Get the timestamp at which the certificate stops being valid.\n\nThe timestamp is formatted as an ASN.1 TIME::\n\n    YYYYMMDDhhmmssZ\n\n:return: A timestamp string, or ``None`` if there is none.\n:rtype: bytes or NoneType", "id": "f4638:c7:m21"}
{"signature": "def get_pubkey(self):", "body": "pkey = PKey.__new__(PKey)<EOL>pkey._pkey = _lib.X509_REQ_get_pubkey(self._req)<EOL>_openssl_assert(pkey._pkey != _ffi.NULL)<EOL>pkey._pkey = _ffi.gc(pkey._pkey, _lib.EVP_PKEY_free)<EOL>pkey._only_public = True<EOL>return pkey<EOL>", "docstring": "Get the public key of the certificate signing request.\n\n:return: The public key.\n:rtype: :py:class:`PKey`", "id": "f4638:c6:m4"}
{"signature": "def set_pubkey(self, pkey):", "body": "set_result = _lib.X509_REQ_set_pubkey(self._req, pkey._pkey)<EOL>_openssl_assert(set_result == <NUM_LIT:1>)<EOL>", "docstring": "Set the public key of the certificate signing request.\n\n:param pkey: The public key to use.\n:type pkey: :py:class:`PKey`\n\n:return: ``None``", "id": "f4638:c6:m3"}
{"signature": "def all_reasons(self):", "body": "return self._crl_reasons[:]<EOL>", "docstring": "Return a list of all the supported reason strings.\n\nThis list is a copy; modifying it does not change the supported reason\nstrings.\n\n:return: A list of reason strings.\n:rtype: :class:`list` of :class:`bytes`", "id": "f4638:c12:m6"}
{"signature": "def get_ca_certificates(self):", "body": "if self._cacerts is not None:<EOL><INDENT>return tuple(self._cacerts)<EOL><DEDENT>", "docstring": "Get the CA certificates in the PKCS #12 structure.\n\n:return: A tuple with the CA certificates in the chain, or\n    :py:const:`None` if there are none.\n:rtype: :py:class:`tuple` of :py:class:`X509` or :py:const:`None`", "id": "f4638:c15:m5"}
{"signature": "@classmethod<EOL><INDENT>def from_nid(cls, lib, nid):<DEDENT>", "body": "return cls(lib, nid, _ffi.string(lib.OBJ_nid2sn(nid)).decode(\"<STR_LIT:ascii>\"))<EOL>", "docstring": "Instantiate a new :py:class:`_EllipticCurve` associated with the given\nOpenSSL NID.\n\n:param lib: The OpenSSL library binding object.\n\n:param nid: The OpenSSL NID the resulting curve object will represent.\n    This must be a curve NID (and not, for example, a hash NID) or\n    subsequent operations will fail in unpredictable ways.\n:type nid: :py:class:`int`\n\n:return: The curve object.", "id": "f4638:c3:m2"}
{"signature": "def get_critical(self):", "body": "return _lib.X509_EXTENSION_get_critical(self._extension)<EOL>", "docstring": "Returns the critical field of this X.509 extension.\n\n:return: The critical field.", "id": "f4638:c5:m4"}
{"signature": "def get_serial_number(self):", "body": "asn1_serial = _lib.X509_get_serialNumber(self._x509)<EOL>bignum_serial = _lib.ASN1_INTEGER_to_BN(asn1_serial, _ffi.NULL)<EOL>try:<EOL><INDENT>hex_serial = _lib.BN_bn2hex(bignum_serial)<EOL>try:<EOL><INDENT>hexstring_serial = _ffi.string(hex_serial)<EOL>serial = int(hexstring_serial, <NUM_LIT:16>)<EOL>return serial<EOL><DEDENT>finally:<EOL><INDENT>_lib.OPENSSL_free(hex_serial)<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>_lib.BN_free(bignum_serial)<EOL><DEDENT>", "docstring": "Return the serial number of this certificate.\n\n:return: The serial number.\n:rtype: int", "id": "f4638:c7:m13"}
{"signature": "def to_cryptography(self):", "body": "from cryptography.hazmat.backends.openssl.x509 import (<EOL>_CertificateRevocationList<EOL>)<EOL>backend = _get_backend()<EOL>return _CertificateRevocationList(backend, self._crl)<EOL>", "docstring": "Export as a ``cryptography`` CRL.\n\n:rtype: ``cryptography.x509.CertificateRevocationList``\n\n.. versionadded:: 17.1.0", "id": "f4638:c13:m1"}
{"signature": "def set_friendlyname(self, name):", "body": "if name is None:<EOL><INDENT>self._friendlyname = None<EOL><DEDENT>elif not isinstance(name, bytes):<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\" % (name,)<EOL>)<EOL><DEDENT>self._friendlyname = name<EOL>", "docstring": "Set the friendly name in the PKCS #12 structure.\n\n:param name: The new friendly name, or :py:const:`None` to unset.\n:type name: :py:class:`bytes` or :py:const:`None`\n\n:return: ``None``", "id": "f4638:c15:m7"}
{"signature": "def add(buffer, entropy):", "body": "if not isinstance(buffer, bytes):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if not isinstance(entropy, int):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>_lib.RAND_add(buffer, len(buffer), entropy)<EOL>", "docstring": "Mix bytes from *string* into the PRNG state.\n\nThe *entropy* argument is (the lower bound of) an estimate of how much\nrandomness is contained in *string*, measured in bytes.\n\nFor more information, see e.g. :rfc:`1750`.\n\nThis function is only relevant if you are forking Python processes and\nneed to reseed the CSPRNG after fork.\n\n:param buffer: Buffer with random data.\n:param entropy: The entropy (in bytes) measurement of the buffer.\n\n:return: :obj:`None`", "id": "f4639:m0"}
{"signature": "def transform(self, X):", "body": "return X[:, self.get_support()]<EOL>", "docstring": "Transform to select not k best feature\n:param X: np.matrix", "id": "f4645:c0:m2"}
{"signature": "def to_csv(self, X, y):", "body": "<EOL>raise NotImplementedError<EOL>", "docstring": "Writes dataset to csv.", "id": "f4648:c0:m2"}
{"signature": "def from_csv(self, label_column='<STR_LIT>'):", "body": "df = pd.read_csv(self.path, header=<NUM_LIT:0>)<EOL>X = df.loc[:, df.columns != label_column].to_dict('<STR_LIT>')<EOL>X = map_dict_list(X, if_func=lambda k, v: v and math.isfinite(v))<EOL>y = list(df[label_column].values)<EOL>return X, y<EOL>", "docstring": "Read dataset from csv.", "id": "f4648:c0:m1"}
{"signature": "def feature_importance_report(X,<EOL>y,<EOL>threshold=<NUM_LIT>,<EOL>correcting_multiple_hypotesis=True,<EOL>method='<STR_LIT>',<EOL>alpha=<NUM_LIT:0.1>,<EOL>sort_by='<STR_LIT>'):", "body": "df = variance_threshold_on_df(<EOL>pd.DataFrame.from_records(X), threshold=threshold)<EOL>F, pvals = f_classif(df.values, y)<EOL>if correcting_multiple_hypotesis:<EOL><INDENT>_, pvals, _, _ = multipletests(pvals, alpha=alpha, method=method)<EOL><DEDENT>df['<STR_LIT>'] = y<EOL>df_mean = df.groupby('<STR_LIT>').mean().T<EOL>df_mean['<STR_LIT:F>'] = F<EOL>df_mean['<STR_LIT>'] = pvals<EOL>return df_mean.sort_values(sort_by, ascending=True)<EOL>", "docstring": "Provide signifance for features in dataset with anova using multiple hypostesis testing\n\n:param X: List of dict with key as feature names and values as features\n:param y: Labels\n:param threshold: Low-variens threshold to eliminate low varience features\n:param correcting_multiple_hypotesis: corrects p-val with multiple hypotesis testing\n:param method: method of multiple hypotesis testing\n:param alpha: alpha of multiple hypotesis testing\n:param sort_by: sorts output dataframe by pval or F\n:return: DataFrame with F and pval for each feature with their average values", "id": "f4651:m6"}
{"signature": "def average_by_label(X, y, ref_label):", "body": "<EOL>return defaultdict(float,<EOL>pd.DataFrame.from_records(<EOL>filter_by_label(X, y, ref_label)[<NUM_LIT:0>]<EOL>).mean().to_dict())<EOL>", "docstring": "Calculates average dictinary from list of dictionary for give label\n\n:param List[Dict] X: dataset\n:param list y: labels\n:param ref_label: reference label", "id": "f4651:m1"}
{"signature": "def __init__(self, names, case_sensetive=False):", "body": "self.names = names if case_sensetive else map_dict(<EOL>names, key_func=lambda k, v: k.lower())<EOL>", "docstring": ":names: dict which contain old feature names as key and new names as value.  \n:case_insensetive: performs mactching case sensetive", "id": "f4656:c0:m0"}
{"signature": "def __init__(self, reference_label):", "body": "super().__init__()<EOL>self.reference_label = reference_label<EOL>", "docstring": ":reference_label: the label scaling will be performed by.", "id": "f4660:c0:m0"}
{"signature": "def partial_fit(self, X, y):", "body": "X, y = filter_by_label(X, y, self.reference_label)<EOL>super().partial_fit(X, y)<EOL>return self<EOL>", "docstring": ":X: {array-like, sparse matrix}, shape [n_samples, n_features]\n    The data used to compute the mean and standard deviation\n    used for later scaling along the features axis.\n:y: Healthy 'h' or 'sick_name'", "id": "f4660:c0:m1"}
{"signature": "def get_status(options):", "body": "payload = {  <EOL>\"<STR_LIT:username>\": options.username,<EOL>\"<STR_LIT:password>\": options.password,<EOL>\"<STR_LIT>\": options.server,<EOL>\"<STR_LIT:port>\": options.port,<EOL>}<EOL>try:<EOL><INDENT>if options.server.startswith(\"<STR_LIT:/>\") and stat.S_ISSOCK(os.stat(options.server).st_mode):  <EOL><INDENT>try:<EOL><INDENT>import supervisor.xmlrpc<EOL><DEDENT>except ImportError as error:<EOL><INDENT>sys.stderr.write(\"<STR_LIT>\".format(error=error))<EOL>sys.stderr.write(\"<STR_LIT>\")<EOL>sys.exit(-<NUM_LIT:1>)<EOL><DEDENT>if all([options.username, options.password, ]):  <EOL><INDENT>connection = xmlrpclib.ServerProxy(\"<STR_LIT>\", transport=supervisor.xmlrpc.SupervisorTransport(options.username, options.password, serverurl=URI[URI_TPL_SOCKET].format(**payload)))<EOL><DEDENT>else:<EOL><INDENT>connection = xmlrpclib.ServerProxy(\"<STR_LIT>\", transport=supervisor.xmlrpc.SupervisorTransport(None, None, serverurl=URI[URI_TPL_SOCKET].format(**payload)))<EOL><DEDENT><DEDENT>else:  <EOL><INDENT>if all([options.username, options.password, ]):  <EOL><INDENT>connection = xmlrpclib.Server(URI[URI_TPL_HTTP_AUTH].format(**payload))<EOL><DEDENT>else:<EOL><INDENT>connection = xmlrpclib.Server(URI[URI_TPL_HTTP].format(**payload))<EOL><DEDENT><DEDENT>return connection.supervisor.getAllProcessInfo()<EOL><DEDENT>except Exception as error:<EOL><INDENT>if not options.quiet:<EOL><INDENT>sys.stdout.write(\"<STR_LIT>\".format(error=error))<EOL><DEDENT>sys.exit(EXIT_CODES.get(options.network_errors_exit_code, EXIT_CODE_UNKNOWN))<EOL><DEDENT>", "docstring": "Get programs statuses.\n\n:param options: parsed commandline arguments.\n:type options: optparse.Values.\n:return: supervisord XML-RPC call result.\n:rtype: dict.", "id": "f4668:m1"}
{"signature": "def main():", "body": "options = parse_options()<EOL>output, code = create_output(get_status(options), options)<EOL>sys.stdout.write(output)<EOL>sys.exit(code)<EOL>", "docstring": "Program main.", "id": "f4668:m3"}
{"signature": "def only_module(*modules):", "body": "modules = (modules and isinstance(modules[<NUM_LIT:0>], list)) andmodules[<NUM_LIT:0>] or modules<EOL>for module in modules:<EOL><INDENT>if not module in ONLY_MODULES:<EOL><INDENT>ONLY_MODULES.append(module)<EOL><DEDENT><DEDENT>traceback.extract_tb = _new_extract_tb<EOL>", "docstring": "This will exclude all modules from the traceback except these \"modules\"\n:param modules: list of modules to report in traceback\n:return:        None", "id": "f4672:m1"}
{"signature": "def add_handler(log_handler_level, handler, formatter=None, log_filter=None):", "body": "handler.setLevel(log_handler_level)<EOL>if formatter is not None:<EOL><INDENT>handler.setFormatter(formatter)<EOL><DEDENT>if log_filter is not None:<EOL><INDENT>handler.addFilter(log_filter)<EOL><DEDENT>log.addHandler(handler)<EOL>", "docstring": ":param log_handler_level:   str of the level to set for the handler\n:param handler:             logging.Handler handler to add\n:param formatter:           logging.Formatter instance to use\n:param log_filter:          logging.filter instance to add to handler\n:return:                    None", "id": "f4673:m5"}
{"signature": "def setup_file_logging(log_filename, log_file_level=\"<STR_LIT>\", str_format=None,<EOL>date_format=None, log_restart=False, log_history=False,<EOL>formatter=None, silence_modules=None, log_filter=None):", "body": "from seaborn_timestamp.timestamp import datetime_to_str<EOL>if os.path.exists(log_filename) and log_restart:<EOL><INDENT>os.remove(log_filename)<EOL><DEDENT>add_file_handler(log_file_level, log_filename, str_format=str_format,<EOL>date_format=date_format, formatter=formatter,<EOL>log_filter=log_filter)<EOL>if log_history:<EOL><INDENT>base_name = os.path.basename(log_filename).split('<STR_LIT:.>')[<NUM_LIT:0>] +'<STR_LIT>' % datetime_to_str(str_format='<STR_LIT>')<EOL>history_log = os.path.join(os.path.dirname(log_filename),<EOL>'<STR_LIT>', base_name + '<STR_LIT>')<EOL>add_file_handler(log_file_level, history_log, str_format=str_format,<EOL>date_format=date_format, log_filter=log_filter)<EOL><DEDENT>silence_module_logging(silence_modules)<EOL>", "docstring": "This will setup logging for a single file but can be called more than once\nLOG LEVELS are \"CRITICAL\", \"ERROR\", \"INFO\", \"DEBUG\"\n:param log_filename:    str of the file location\n:param log_file_level   str of the log level to use on this file\n:param str_format:      str of the logging format\n:param date_format:     str of the date format\n:param log_restart:     bool if True the log file will be deleted first\n:param log_history:     bool if True will save another log file in a folder\n                        called history with the datetime\n:param formatter:       logging.Format instance to use\n:param log_filter:      logging.filter instance to add to handler\n:param silence_modules  list of str of modules to silence\n:return:                None", "id": "f4673:m3"}
{"signature": "def _prune_dict_null_str(dictionary):", "body": "for key, value in list(dictionary.items()):<EOL><INDENT>if value is None or str(value) == '<STR_LIT>':<EOL><INDENT>del dictionary[key]<EOL><DEDENT>if isinstance(value, dict):<EOL><INDENT>dictionary[key] = _prune_dict_null_str(dictionary[key])<EOL><DEDENT><DEDENT>return dictionary<EOL>", "docstring": "Prune the \"None\" or emptry string values from dictionary items", "id": "f4682:m5"}
{"signature": "def create_tfs_git_client(url, token=None):", "body": "if token is None:<EOL><INDENT>token = os.environ.get('<STR_LIT>', None)<EOL><DEDENT>tfs_connection = create_tfs_connection(url, token)<EOL>tfs_git_client = tfs_connection.get_client('<STR_LIT>')<EOL>if tfs_git_client is None:<EOL><INDENT>msg = '<STR_LIT>'<EOL>raise RuntimeError(msg, url)<EOL><DEDENT>return tfs_git_client<EOL>", "docstring": "Creates a TFS Git Client to pull Git repo info", "id": "f4684:m4"}
{"signature": "def process_url(url, key):", "body": "logger.debug('<STR_LIT>', url)<EOL>if key is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>response = requests.get(url, headers={\"<STR_LIT>\": \"<STR_LIT>\" + key})<EOL>doecode_json = response.json()<EOL>for record in doecode_json['<STR_LIT>']:<EOL><INDENT>yield record<EOL><DEDENT>", "docstring": "Yields DOE CODE records from a DOE CODE .json URL response\nConverts a DOE CODE API .json URL response into DOE CODE projects", "id": "f4687:m1"}
{"signature": "def process_json(filename):", "body": "logger.debug('<STR_LIT>', filename)<EOL>doecode_json = json.load(open(filename))<EOL>for record in doecode_json['<STR_LIT>']:<EOL><INDENT>yield record<EOL><DEDENT>", "docstring": "Converts a DOE CODE .json file into DOE CODE projects\nYields DOE CODE records from a DOE CODE .json file", "id": "f4687:m0"}
{"signature": "@classmethod<EOL><INDENT>def from_stashy(klass, repository, labor_hours=True):<DEDENT>", "body": "<EOL>if not isinstance(repository, dict):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>project = klass()<EOL>logger.debug(<EOL>'<STR_LIT>',<EOL>repository['<STR_LIT:name>'],<EOL>repository['<STR_LIT>']['<STR_LIT:key>'],<EOL>)<EOL>project['<STR_LIT:name>'] = repository['<STR_LIT:name>']<EOL>clone_urls = [clone['<STR_LIT>'] for clone in repository['<STR_LIT>']['<STR_LIT>']]<EOL>for url in clone_urls:<EOL><INDENT>if url.startswith('<STR_LIT>'):<EOL><INDENT>project['<STR_LIT>'] = url<EOL>break<EOL><DEDENT><DEDENT>description = repository['<STR_LIT>'].get('<STR_LIT:description>', '<STR_LIT>')<EOL>if description:<EOL><INDENT>project['<STR_LIT:description>'] = '<STR_LIT>' % description<EOL><DEDENT>project['<STR_LIT>']['<STR_LIT>'] = None<EOL>web_url = repository['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>public_server = web_url.startswith('<STR_LIT>')<EOL>if repository['<STR_LIT>'] and public_server:<EOL><INDENT>project['<STR_LIT>']['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>if labor_hours:<EOL><INDENT>project['<STR_LIT>'] = labor_hours_from_url(project['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>project['<STR_LIT>'] = <NUM_LIT:0><EOL><DEDENT>project['<STR_LIT>'] = ['<STR_LIT>']<EOL>project['<STR_LIT>']['<STR_LIT:email>'] = '<STR_LIT>'<EOL>project['<STR_LIT>']['<STR_LIT>'] = repository['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>project['<STR_LIT:status>'] = '<STR_LIT>'<EOL>project['<STR_LIT>'] = repository['<STR_LIT>']<EOL>project['<STR_LIT>'] = repository['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>_prune_dict_null_str(project)<EOL>return project<EOL>", "docstring": "Handles crafting Code.gov Project for Bitbucket Server repositories", "id": "f4689:c1:m3"}
{"signature": "@classmethod<EOL><INDENT>def from_doecode(klass, record):<DEDENT>", "body": "if not isinstance(record, dict):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>project = klass()<EOL>project['<STR_LIT:name>'] = record['<STR_LIT>']<EOL>logger.debug('<STR_LIT>', record['<STR_LIT>'])<EOL>link = record.get('<STR_LIT>', '<STR_LIT>')<EOL>if not link:<EOL><INDENT>link = record.get('<STR_LIT>')<EOL>logger.warning('<STR_LIT>', link)<EOL><DEDENT>project['<STR_LIT>'] = link<EOL>project['<STR_LIT:description>'] = record['<STR_LIT:description>']<EOL>licenses = set(record['<STR_LIT>'])<EOL>licenses.discard(None)<EOL>logger.debug('<STR_LIT>', licenses)<EOL>license_objects = []<EOL>if '<STR_LIT>' in licenses:<EOL><INDENT>licenses.remove('<STR_LIT>')<EOL>license_objects = [{<EOL>'<STR_LIT:name>': '<STR_LIT>',<EOL>'<STR_LIT>': record['<STR_LIT>']<EOL>}]<EOL><DEDENT>if licenses:<EOL><INDENT>license_objects.extend([_license_obj(license) for license in licenses])<EOL><DEDENT>project['<STR_LIT>']['<STR_LIT>'] = license_objects<EOL>if record['<STR_LIT>']:<EOL><INDENT>usage_type = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>usage_type = '<STR_LIT>'<EOL>project['<STR_LIT>']['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>project['<STR_LIT>']['<STR_LIT>'] = usage_type<EOL>project['<STR_LIT>'] = <NUM_LIT:0><EOL>project['<STR_LIT>'] = ['<STR_LIT>']<EOL>lab_name = record.get('<STR_LIT>')<EOL>if lab_name is not None:<EOL><INDENT>project['<STR_LIT>'].append(lab_name)<EOL><DEDENT>project['<STR_LIT>']['<STR_LIT:email>'] = record['<STR_LIT>']<EOL>if '<STR_LIT>' in record and record['<STR_LIT>']:<EOL><INDENT>project['<STR_LIT:version>'] = record['<STR_LIT>']<EOL><DEDENT>if lab_name is not None:<EOL><INDENT>project['<STR_LIT>'] = lab_name<EOL><DEDENT>status = record.get('<STR_LIT>')<EOL>if status is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>elif status:<EOL><INDENT>status = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>status = '<STR_LIT>'<EOL><DEDENT>project['<STR_LIT:status>'] = status<EOL>vcs = None<EOL>link = project['<STR_LIT>']<EOL>if '<STR_LIT>' in link:<EOL><INDENT>vcs = '<STR_LIT>'<EOL><DEDENT>if vcs is None:<EOL><INDENT>logger.debug('<STR_LIT>', project['<STR_LIT:name>'], link)<EOL>vcs = '<STR_LIT>'<EOL><DEDENT>if vcs:<EOL><INDENT>project['<STR_LIT>'] = vcs<EOL><DEDENT>url = record.get('<STR_LIT>', '<STR_LIT>')<EOL>if url:<EOL><INDENT>project['<STR_LIT>'] = url<EOL><DEDENT>if '<STR_LIT>' in record:<EOL><INDENT>project['<STR_LIT>'] = record['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in record and '<STR_LIT>' in record:<EOL><INDENT>project['<STR_LIT:date>'] = {<EOL>'<STR_LIT>': record['<STR_LIT>'],<EOL>'<STR_LIT>': record['<STR_LIT>']<EOL>}<EOL><DEDENT>return project<EOL>", "docstring": "Create CodeGovProject object from DOE CODE record\n\nHandles crafting Code.gov Project", "id": "f4689:c1:m4"}
{"signature": "@classmethod<EOL><INDENT>def from_gitlab(klass, repository, labor_hours=True):<DEDENT>", "body": "if not isinstance(repository, gitlab.v4.objects.Project):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>project = klass()<EOL>logger.debug(<EOL>'<STR_LIT>',<EOL>repository.id,<EOL>repository.path_with_namespace,<EOL>)<EOL>project['<STR_LIT:name>'] = repository.name<EOL>project['<STR_LIT>'] = repository.http_url_to_repo<EOL>project['<STR_LIT:description>'] = repository.description<EOL>project['<STR_LIT>']['<STR_LIT>'] = None<EOL>web_url = repository.web_url<EOL>public_server = web_url.startswith('<STR_LIT>')<EOL>if repository.visibility in ('<STR_LIT>') and public_server:<EOL><INDENT>project['<STR_LIT>']['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>elif date_parse(repository.created_at) < POLICY_START_DATE:<EOL><INDENT>project['<STR_LIT>']['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>if labor_hours:<EOL><INDENT>project['<STR_LIT>'] = labor_hours_from_url(project['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>project['<STR_LIT>'] = <NUM_LIT:0><EOL><DEDENT>project['<STR_LIT>'] = ['<STR_LIT>'] + repository.tag_list<EOL>project['<STR_LIT>'] = {<EOL>'<STR_LIT:email>': '<STR_LIT>',<EOL>'<STR_LIT>': web_url,<EOL>}<EOL>project['<STR_LIT>'] = repository.namespace['<STR_LIT:name>']<EOL>project['<STR_LIT:status>'] = '<STR_LIT>'<EOL>project['<STR_LIT>'] = '<STR_LIT>'<EOL>project['<STR_LIT>'] = repository.web_url<EOL>api_url = repository.manager.gitlab._url<EOL>archive_suffix = '<STR_LIT>' % repository.get_id()<EOL>project['<STR_LIT>'] = api_url + archive_suffix<EOL>project['<STR_LIT:date>'] = {<EOL>'<STR_LIT>': date_parse(repository.created_at).date().isoformat(),<EOL>'<STR_LIT>': date_parse(repository.last_activity_at).date().isoformat(),<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>}<EOL>_prune_dict_null_str(project)<EOL>return project<EOL>", "docstring": "Create CodeGovProject object from GitLab Repository", "id": "f4689:c1:m2"}
{"signature": "def _license_obj(license):", "body": "obj = None<EOL>if license in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>obj = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:name>': '<STR_LIT>'<EOL>}<EOL><DEDENT>elif license in ('<STR_LIT>'):<EOL><INDENT>obj = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:name>': '<STR_LIT>'<EOL>}<EOL><DEDENT>elif license in ('<STR_LIT>'):<EOL><INDENT>obj = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:name>': '<STR_LIT>'<EOL>}<EOL><DEDENT>elif license in ('<STR_LIT>'):<EOL><INDENT>obj = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:name>': '<STR_LIT>'<EOL>}<EOL><DEDENT>elif license in ('<STR_LIT>'):<EOL><INDENT>obj = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:name>': '<STR_LIT>'<EOL>}<EOL><DEDENT>elif license in ('<STR_LIT>'):<EOL><INDENT>obj = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:name>': '<STR_LIT>'<EOL>}<EOL><DEDENT>elif license in ('<STR_LIT>'):<EOL><INDENT>obj = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:name>': '<STR_LIT>'<EOL>}<EOL><DEDENT>elif license in ('<STR_LIT>'):<EOL><INDENT>obj = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:name>': '<STR_LIT>'<EOL>}<EOL><DEDENT>elif license in ('<STR_LIT>'):<EOL><INDENT>obj = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:name>': '<STR_LIT>'<EOL>}<EOL><DEDENT>elif license in ('<STR_LIT>'):<EOL><INDENT>obj = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:name>': '<STR_LIT>',<EOL>}<EOL><DEDENT>elif license in ('<STR_LIT>'):<EOL><INDENT>obj = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:name>': '<STR_LIT>',<EOL>}<EOL><DEDENT>elif license in ('<STR_LIT>'):<EOL><INDENT>obj = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:name>': '<STR_LIT>',<EOL>}<EOL><DEDENT>elif license in ('<STR_LIT>'):<EOL><INDENT>obj = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:name>': '<STR_LIT>',<EOL>}<EOL><DEDENT>elif license in ('<STR_LIT>'):<EOL><INDENT>obj = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:name>': '<STR_LIT>',<EOL>}<EOL><DEDENT>if obj is None:<EOL><INDENT>logger.warn('<STR_LIT>', license)<EOL>raise ValueError('<STR_LIT>')<EOL><DEDENT>return obj<EOL>", "docstring": "A helper function to look up license object information\n\nUse names from: https://api.github.com/licenses", "id": "f4690:m0"}
{"signature": "def queryGitHub(self, gitquery, gitvars={}, verbosity=<NUM_LIT:0>, paginate=False, cursorVar=None, keysToList=[], rest=False, requestCount=<NUM_LIT:0>, pageNum=<NUM_LIT:0>):", "body": "requestCount += <NUM_LIT:1><EOL>if pageNum < <NUM_LIT:0>:  <EOL><INDENT>pageNum = <NUM_LIT:0><EOL><DEDENT>pageNum += <NUM_LIT:1><EOL>if paginate:<EOL><INDENT>_vPrint((verbosity >= <NUM_LIT:0>), \"<STR_LIT>\" % (pageNum))<EOL><DEDENT>_vPrint((verbosity >= <NUM_LIT:0>), \"<STR_LIT>\" % (\"<STR_LIT>\" if rest else \"<STR_LIT>\"))<EOL>response = self._submitQuery(gitquery, gitvars=gitvars, verbose=(verbosity > <NUM_LIT:0>), rest=rest)<EOL>_vPrint((verbosity >= <NUM_LIT:0>), \"<STR_LIT>\")<EOL>_vPrint((verbosity >= <NUM_LIT:0>), response[\"<STR_LIT>\"][\"<STR_LIT:http>\"])<EOL>statusNum = response[\"<STR_LIT>\"]<EOL>pageNum -= <NUM_LIT:1><EOL>try:<EOL><INDENT>apiStatus = {<EOL>\"<STR_LIT>\": int(response[\"<STR_LIT>\"][\"<STR_LIT>\"]),<EOL>\"<STR_LIT>\": int(response[\"<STR_LIT>\"][\"<STR_LIT>\"]),<EOL>\"<STR_LIT>\": int(response[\"<STR_LIT>\"][\"<STR_LIT>\"])<EOL>}<EOL>_vPrint((verbosity >= <NUM_LIT:0>), \"<STR_LIT>\" % (json.dumps(apiStatus)))<EOL>if not apiStatus[\"<STR_LIT>\"] > <NUM_LIT:0>:<EOL><INDENT>_vPrint((verbosity >= <NUM_LIT:0>), \"<STR_LIT>\")<EOL>self._awaitReset(apiStatus[\"<STR_LIT>\"])<EOL>_vPrint((verbosity >= <NUM_LIT:0>), \"<STR_LIT>\")<EOL>return self.queryGitHub(gitquery, gitvars=gitvars, verbosity=verbosity, paginate=paginate, cursorVar=cursorVar, keysToList=keysToList, rest=rest, requestCount=(requestCount - <NUM_LIT:1>), pageNum=pageNum)<EOL><DEDENT><DEDENT>except KeyError:<EOL><INDENT>_vPrint((verbosity >= <NUM_LIT:0>), \"<STR_LIT>\")<EOL><DEDENT>if statusNum == <NUM_LIT>:<EOL><INDENT>if requestCount >= self.maxRetry:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\" % (self.maxRetry, response[\"<STR_LIT>\"][\"<STR_LIT:http>\"], response[\"<STR_LIT:result>\"]))<EOL><DEDENT>else:<EOL><INDENT>self._countdown(self.__retryDelay, printString=\"<STR_LIT>\", verbose=(verbosity >= <NUM_LIT:0>))<EOL>return self.queryGitHub(gitquery, gitvars=gitvars, verbosity=verbosity, paginate=paginate, cursorVar=cursorVar, keysToList=keysToList, rest=rest, requestCount=requestCount, pageNum=pageNum)<EOL><DEDENT><DEDENT>if statusNum == <NUM_LIT> or statusNum == <NUM_LIT>:<EOL><INDENT>if requestCount >= self.maxRetry:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\" % (self.maxRetry, response[\"<STR_LIT>\"][\"<STR_LIT:http>\"], response[\"<STR_LIT:result>\"]))<EOL><DEDENT>else:<EOL><INDENT>self._countdown(self.__retryDelay, printString=\"<STR_LIT>\", verbose=(verbosity >= <NUM_LIT:0>))<EOL>return self.queryGitHub(gitquery, gitvars=gitvars, verbosity=verbosity, paginate=paginate, cursorVar=cursorVar, keysToList=keysToList, rest=rest, requestCount=requestCount, pageNum=pageNum)<EOL><DEDENT><DEDENT>if statusNum >= <NUM_LIT> or statusNum == <NUM_LIT>:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\" % (response[\"<STR_LIT>\"][\"<STR_LIT:http>\"], response[\"<STR_LIT:result>\"]))<EOL><DEDENT>_vPrint((verbosity >= <NUM_LIT:0>), \"<STR_LIT>\")<EOL>outObj = json.loads(response[\"<STR_LIT:result>\"])<EOL>if not rest and \"<STR_LIT>\" in outObj:<EOL><INDENT>if requestCount >= self.maxRetry:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\" % (self.maxRetry, response[\"<STR_LIT>\"][\"<STR_LIT:http>\"], response[\"<STR_LIT:result>\"]))<EOL><DEDENT>elif len(outObj[\"<STR_LIT>\"]) == <NUM_LIT:1> and len(outObj[\"<STR_LIT>\"][<NUM_LIT:0>]) == <NUM_LIT:1>:<EOL><INDENT>_vPrint((verbosity >= <NUM_LIT:0>), \"<STR_LIT>\" % (json.dumps(outObj[\"<STR_LIT>\"])))<EOL>self._countdown(self.__retryDelay, printString=\"<STR_LIT>\", verbose=(verbosity >= <NUM_LIT:0>))<EOL>return self.queryGitHub(gitquery, gitvars=gitvars, verbosity=verbosity, paginate=paginate, cursorVar=cursorVar, keysToList=keysToList, rest=rest, requestCount=requestCount, pageNum=pageNum)<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\" % (json.dumps(outObj[\"<STR_LIT>\"])))<EOL><DEDENT><DEDENT>pageNum += <NUM_LIT:1><EOL>if paginate:<EOL><INDENT>if rest and response[\"<STR_LIT>\"]:<EOL><INDENT>if \"<STR_LIT>\" in response[\"<STR_LIT>\"]:<EOL><INDENT>nextObj = self.queryGitHub(response[\"<STR_LIT>\"][\"<STR_LIT>\"], gitvars=gitvars, verbosity=verbosity, paginate=paginate, cursorVar=cursorVar, keysToList=keysToList, rest=rest, requestCount=<NUM_LIT:0>, pageNum=pageNum)<EOL>outObj.extend(nextObj)<EOL><DEDENT><DEDENT>elif not rest:<EOL><INDENT>if not cursorVar:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not len(keysToList) > <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>aPage = outObj<EOL>for key in keysToList[<NUM_LIT:0>:-<NUM_LIT:1>]:<EOL><INDENT>aPage = aPage[key]<EOL><DEDENT>gitvars[cursorVar] = aPage[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>if aPage[\"<STR_LIT>\"][\"<STR_LIT>\"]:<EOL><INDENT>nextObj = self.queryGitHub(gitquery, gitvars=gitvars, verbosity=verbosity, paginate=paginate, cursorVar=cursorVar, keysToList=keysToList, rest=rest, requestCount=<NUM_LIT:0>, pageNum=pageNum)<EOL>newPage = nextObj<EOL>for key in keysToList[<NUM_LIT:0>:-<NUM_LIT:1>]:<EOL><INDENT>newPage = newPage[key]<EOL><DEDENT>aPage[keysToList[-<NUM_LIT:1>]].extend(newPage[keysToList[-<NUM_LIT:1>]])<EOL><DEDENT>aPage.pop(\"<STR_LIT>\", None)<EOL><DEDENT><DEDENT>return outObj<EOL>", "docstring": "Submit a GitHub query.\n\n        Args:\n            gitquery (str): The query or endpoint itself.\n                Examples:\n                       query: 'query { viewer { login } }'\n                    endpoint: '/user'\n            gitvars (Optional[Dict]): All query variables.\n                Defaults to empty.\n                GraphQL Only.\n            verbosity (Optional[int]): Changes output verbosity levels.\n                If < 0, all extra printouts are suppressed.\n                If == 0, normal print statements are displayed.\n                If > 0, additional status print statements are displayed.\n                Defaults to 0.\n            paginate (Optional[bool]): Pagination will be completed\n                automatically if True. Defaults to False.\n            cursorVar (Optional[str]): Key in 'gitvars' that represents the\n                pagination cursor. Defaults to None.\n                GraphQL Only.\n            keysToList (Optional[List[str]]): Ordered list of keys needed to\n                retrieve the list in the query results to be extended by\n                pagination. Defaults to empty.\n                Example:\n                    ['data', 'viewer', 'repositories', 'nodes']\n                GraphQL Only.\n            rest (Optional[bool]): If True, uses the REST API instead\n                of GraphQL. Defaults to False.\n            requestCount (Optional[int]): Counter for repeated requests.\n            pageNum (Optional[int]): Counter for pagination.\n                For user readable log messages only, does not affect data.\n\n        Returns:\n            Dict: A JSON style dictionary.", "id": "f4691:c0:m5"}
{"signature": "def __init__(self, filePath=None, loadData=False):", "body": "self.data = {}<EOL>\"\"\"<STR_LIT>\"\"\"<EOL>self.filePath = filePath<EOL>if loadData:<EOL><INDENT>self.fileLoad(updatePath=False)<EOL><DEDENT>", "docstring": "Initialize the DataManager object.\n        Args:\n            filePath (Optional[str]): Relative or absolute path to a JSON\n                data file. Defaults to None.\n            loadData (Optional[bool]): Loads data from the given file path\n                if True. Defaults to False.", "id": "f4691:c1:m0"}
{"signature": "def __init__(self, apiToken=None, maxRetry=<NUM_LIT:10>):", "body": "<EOL>if apiToken:<EOL><INDENT>self.__githubApiToken = apiToken<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>self.__githubApiToken = os.environ['<STR_LIT>']<EOL><DEDENT>except KeyError as error:<EOL><INDENT>raise TypeError(\"<STR_LIT>\") from error<EOL><DEDENT><DEDENT>print(\"<STR_LIT>\", end=\"<STR_LIT>\", flush=True)<EOL>basicCheck = self._submitQuery('<STR_LIT>')<EOL>if basicCheck[\"<STR_LIT>\"] == <NUM_LIT>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>raise ValueError(\"<STR_LIT>\" + basicCheck[\"<STR_LIT>\"][\"<STR_LIT:http>\"] + \"<STR_LIT:U+0020>\" + basicCheck[\"<STR_LIT:result>\"])<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>self.__retryDelay = <NUM_LIT:3>  <EOL>self.__query = None  <EOL>self.__queryPath = None  <EOL>self.__queryTimestamp = None  <EOL>self.maxRetry = maxRetry<EOL>self.data = {}<EOL>\"\"\"<STR_LIT>\"\"\"<EOL>", "docstring": "Initialize the GitHubQueryManager object.\n\n        Note:\n            If no apiToken argument is provided,\n            the environment variable 'GITHUB_API_TOKEN' must be set.\n\n        Args:\n            apiToken (Optional[str]): A string representing a GitHub API\n                token. Defaults to None.\n            maxRetry (Optional[int]): A limit on how many times to\n                automatically retry requests. Defaults to 10.\n\n        Raises:\n            TypeError: If no GitHub API token is provided either via\n            argument or environment variable 'GITHUB_API_TOKEN'.", "id": "f4691:c0:m0"}
{"signature": "@property<EOL><INDENT>def maxRetry(self):<DEDENT>", "body": "return self.__maxRetry<EOL>", "docstring": "int: A limit on how many times to automatically retry requests.\n\n        Must be a whole integer greater than 0.", "id": "f4691:c0:m1"}
{"signature": "def create_session(token=None):", "body": "if token is None:<EOL><INDENT>token = os.environ.get('<STR_LIT>', None)<EOL><DEDENT>gh_session = github3.login(token=token)<EOL>if gh_session is None:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>return gh_session<EOL>", "docstring": "Create a github3.py session connected to GitHub.com\n\nIf token is not provided, will attempt to use the GITHUB_API_TOKEN\nenvironment variable if present.", "id": "f4692:m1"}
{"signature": "def connect(url='<STR_LIT>', token=None):", "body": "gh_session = None<EOL>if url == '<STR_LIT>':<EOL><INDENT>gh_session = create_session(token)<EOL><DEDENT>else:<EOL><INDENT>gh_session = create_enterprise_session(url, token)<EOL><DEDENT>if gh_session is None:<EOL><INDENT>msg = '<STR_LIT>'<EOL>raise RuntimeError(msg, url)<EOL><DEDENT>logger.info('<STR_LIT>', url)<EOL>return gh_session<EOL>", "docstring": "Create a GitHub session for making requests", "id": "f4692:m5"}
{"signature": "def connect(url, username, password):", "body": "bb_session = stashy.connect(url, username, password)<EOL>logger.info('<STR_LIT>', url, username)<EOL>return bb_session<EOL>", "docstring": "Return a connected Bitbucket session", "id": "f4693:m0"}
{"signature": "def all_repos(bb_session):", "body": "for repo in bb_session.repos.all():<EOL><INDENT>yield repo<EOL><DEDENT>", "docstring": "Yields Stashy repo objects for all projects in Bitbucket", "id": "f4693:m1"}
{"signature": "def prompt_2fa(self):", "body": "code = '<STR_LIT>'<EOL>while not code:<EOL><INDENT>code = input('<STR_LIT>')<EOL><DEDENT>return code<EOL>", "docstring": "Taken from\nhttp://github3py.readthedocs.io/en/master/examples/two_factor_auth.html\nPrompts a user for their 2FA code and returns it.", "id": "f4696:c0:m3"}
{"signature": "def write_repo_json(self, date=(datetime.date.today()),<EOL>organization='<STR_LIT>', dict_to_write={}, path_ending_type='<STR_LIT>',<EOL>is_list=False, is_dict=False):", "body": "for repo in dict_to_write:<EOL><INDENT>path = ('<STR_LIT>' + organization + '<STR_LIT:/>' + repo + '<STR_LIT:/>' +<EOL>path_ending_type + '<STR_LIT:/>' + str(date) + '<STR_LIT>')<EOL>self.checkDir(path)<EOL>with open(path, '<STR_LIT:w>') as out:<EOL><INDENT>if is_list:<EOL><INDENT>out.write('<STR_LIT:[>')<EOL>for value in dict_to_write[repo]:<EOL><INDENT>if is_dict:<EOL><INDENT>for inner_dict in value:<EOL><INDENT>out.write(json.dumps(inner_dict, sort_keys=True,<EOL>indent=<NUM_LIT:4>, separators=('<STR_LIT:U+002C>', '<STR_LIT>')) + '<STR_LIT:U+002C>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>out.write(json.dumps(value, sort_keys=True,<EOL>indent=<NUM_LIT:4>, separators=('<STR_LIT:U+002C>', '<STR_LIT>')) + '<STR_LIT:U+002C>')<EOL><DEDENT><DEDENT>out.seek(-<NUM_LIT:1>, os.SEEK_END)<EOL>out.truncate()<EOL>out.write('<STR_LIT:]>')<EOL><DEDENT>else:<EOL><INDENT>out.write(json.dumps(dict_to_write[repo], sort_keys=True,<EOL>indent=<NUM_LIT:4>, separators=('<STR_LIT:U+002C>', '<STR_LIT>')))<EOL><DEDENT><DEDENT>out.close()<EOL><DEDENT>", "docstring": "#Writes repo specific data to JSON.", "id": "f4697:c0:m16"}
{"signature": "def get_languages(self, repo, temp_repo):", "body": "try:<EOL><INDENT>self.languages[repo.language] += <NUM_LIT:1><EOL><DEDENT>except KeyError:<EOL><INDENT>count = self.languages[repo.language] = <NUM_LIT:1><EOL><DEDENT>for repo_languages in repo.iter_languages():<EOL><INDENT>self.languages_json[repo.name][repo_languages[<NUM_LIT:0>]] = repo_languages[<NUM_LIT:1>]<EOL>for language in repo_languages:<EOL><INDENT>if isinstance(language, str):<EOL><INDENT>temp_repo.languages.append(language)<EOL>self.previous_language = language<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>self.languages_size[self.previous_language] +=language<EOL><DEDENT>except KeyError:<EOL><INDENT>size = self.languages_size[self.previous_language]= language<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Retrieves the languages used in the repo and increments the respective\ncounts of those languages. Only increments languages that have names.\nAnything else is not incremented (i.e. numbers).", "id": "f4697:c0:m11"}
{"signature": "def get_mems_of_org(self):", "body": "print('<STR_LIT>')<EOL>counter = <NUM_LIT:0><EOL>for member in self.org_retrieved.iter_members():<EOL><INDENT>self.members_json[member.id] = member.to_json()<EOL>counter += <NUM_LIT:1><EOL><DEDENT>return counter<EOL>", "docstring": "Retrieves the number of members of the organization.", "id": "f4697:c0:m5"}
{"signature": "def get_total_contributors(self, repo):", "body": "repo_contributors = <NUM_LIT:0><EOL>for contributor in repo.iter_contributors():<EOL><INDENT>repo_contributors += <NUM_LIT:1><EOL>self.unique_contributors[contributor.id].append(repo.name)<EOL>self.contributors_json[repo.name].append(contributor.to_json())<EOL><DEDENT>return repo_contributors<EOL>", "docstring": "Retrieves the number of contributors to a repo in the organization.\nAlso adds to unique contributor list.", "id": "f4697:c0:m8"}
{"signature": "def get_readme(self, repo):", "body": "readme_contents = repo.readme()<EOL>if readme_contents is not None:<EOL><INDENT>self.total_readmes += <NUM_LIT:1><EOL>return '<STR_LIT>'<EOL><DEDENT>if self.search_limit >= <NUM_LIT>:<EOL><INDENT>print('<STR_LIT>')<EOL>time.sleep(<NUM_LIT>)<EOL>self.search_limit = <NUM_LIT:0><EOL><DEDENT>self.search_limit += <NUM_LIT:1><EOL>search_results = self.logged_in_gh.search_code('<STR_LIT>'<EOL>+ '<STR_LIT>' + repo.full_name)<EOL>try:<EOL><INDENT>for result in search_results:<EOL><INDENT>path = result.path[<NUM_LIT:1>:]<EOL>if '<STR_LIT:/>' not in path and '<STR_LIT>' in path.lower():<EOL><INDENT>self.total_readmes += <NUM_LIT:1><EOL>return path<EOL><DEDENT><DEDENT>return '<STR_LIT>'<EOL><DEDENT>except (github3.models.GitHubError, StopIteration) as e:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>", "docstring": "Checks to see if the given repo has a ReadMe. MD means it has a correct\nReadme recognized by GitHub.", "id": "f4697:c0:m12"}
{"signature": "def write_languages(self, file_path='<STR_LIT>',date=str(datetime.date.today())):", "body": "self.remove_date(file_path=file_path, date=date)<EOL>languages_exists = os.path.isfile(file_path)<EOL>with open(file_path, '<STR_LIT:a>') as out_languages:<EOL><INDENT>if not languages_exists:<EOL><INDENT>out_languages.write('<STR_LIT>')<EOL><DEDENT>languages_sorted = sorted(self.languages_size)<EOL>for language in languages_sorted:<EOL><INDENT>try:<EOL><INDENT>out_languages.write(date + '<STR_LIT:U+002C>' + language + '<STR_LIT:U+002C>'<EOL>+ str(self.languages[language]) + '<STR_LIT:U+002C>'<EOL>+ str(self.languages_size[language]) + '<STR_LIT:U+002C>'<EOL>+ str(math.log10(int(self.languages_size[language])))<EOL>+ '<STR_LIT:\\n>')<EOL><DEDENT>except (TypeError, KeyError) as e:<EOL><INDENT>out_languages.write(date + '<STR_LIT:U+002C>' + language + '<STR_LIT:U+002C>'<EOL>+ str(<NUM_LIT:0>) + '<STR_LIT:U+002C>'<EOL>+ str(self.languages_size[language]) + '<STR_LIT:U+002C>'<EOL>+ str(math.log10(int(self.languages_size[language])))<EOL>+ '<STR_LIT:\\n>')<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Updates languages.csv file with current data.", "id": "f4697:c0:m19"}
{"signature": "def get_commits(self, repo, organization='<STR_LIT>'):", "body": "<EOL>path = ('<STR_LIT>' + organization + '<STR_LIT:/>' + repo.name + '<STR_LIT>')<EOL>is_only_today = False<EOL>if not os.path.exists(path): <EOL><INDENT>all_commits = repo.iter_commits()<EOL>is_only_today = True<EOL><DEDENT>else:<EOL><INDENT>files = os.listdir(path)<EOL>date = str(files[-<NUM_LIT:1>][:-<NUM_LIT:5>])<EOL>if date == str(datetime.date.today()):<EOL><INDENT>if len(files) > <NUM_LIT:2>:<EOL><INDENT>date = str(files[-<NUM_LIT:2>][:-<NUM_LIT:5>])<EOL><DEDENT>else:<EOL><INDENT>all_commits = repo.iter_commits()<EOL>is_only_today = True<EOL><DEDENT><DEDENT>if not is_only_today:<EOL><INDENT>all_commits = repo.iter_commits(since=date)<EOL><DEDENT><DEDENT>for commit in all_commits:<EOL><INDENT>self.commits_json[repo.name].append(commit.to_json())<EOL><DEDENT>count = <NUM_LIT:0><EOL>for commit in repo.iter_commits():<EOL><INDENT>count += <NUM_LIT:1><EOL><DEDENT>return count<EOL>", "docstring": "Retrieves the number of commits to a repo in the organization. If it is\nthe first time getting commits for a repo, it will get all commits and\nsave them to JSON. If there are previous commits saved, it will only get\ncommits that have not been saved to disk since the last date of commits.", "id": "f4697:c0:m14"}
{"signature": "def get_org(self, organization_name='<STR_LIT>'):", "body": "self.organization_name = organization_name<EOL>if(organization_name == '<STR_LIT>'):<EOL><INDENT>self.organization_name = input('<STR_LIT>')<EOL><DEDENT>print('<STR_LIT>')<EOL>self.org_retrieved = self.logged_in_gh.organization(organization_name)<EOL>", "docstring": "Retrieves an organization via given org name. If given\nempty string, prompts user for an org name.", "id": "f4698:c0:m4"}
{"signature": "def write_json(self, date=(datetime.date.today()),<EOL>organization='<STR_LIT>',dict_to_write={}, path_ending_type='<STR_LIT>'):", "body": "for repo in dict_to_write:<EOL><INDENT>if len(dict_to_write[repo]) != <NUM_LIT:0>:<EOL><INDENT>path = ('<STR_LIT>' + organization + '<STR_LIT:/>' + repo + '<STR_LIT:/>' +<EOL>path_ending_type + '<STR_LIT:/>' + str(date) + '<STR_LIT>')<EOL>self.checkDir(path)<EOL>with open(path, '<STR_LIT:w>') as out:<EOL><INDENT>out.write(json.dumps(dict_to_write[repo], sort_keys=True,<EOL>indent=<NUM_LIT:4>, separators=('<STR_LIT:U+002C>', '<STR_LIT>')))<EOL><DEDENT>out.close()<EOL><DEDENT><DEDENT>", "docstring": "Writes all traffic data to file in JSON form.", "id": "f4698:c0:m10"}
{"signature": "def check_data_redundancy(self, file_path='<STR_LIT>', dict_to_check={}):", "body": "count = <NUM_LIT:0><EOL>exists = os.path.isfile(file_path)<EOL>previous_dates = {}<EOL>if exists:<EOL><INDENT>with open(file_path, '<STR_LIT:r>') as input:<EOL><INDENT>input.readline()<EOL>for row in csv.reader(input):<EOL><INDENT>timestamp = calendar.timegm(time.strptime(row[<NUM_LIT:0>],<EOL>'<STR_LIT>'))<EOL>if timestamp in dict_to_check:<EOL><INDENT>del dict_to_check[timestamp]<EOL><DEDENT>count += <NUM_LIT:1><EOL><DEDENT><DEDENT>input.close()<EOL><DEDENT>return count<EOL>", "docstring": "Checks the given csv file against the json data scraped for the given\ndict. It will remove all data retrieved that has already been recorded\nso we don't write redundant data to file. Returns count of rows from\nfile.", "id": "f4698:c0:m12"}
{"signature": "def get_year_commits(self, username='<STR_LIT>', password='<STR_LIT>', organization='<STR_LIT>', force=True):", "body": "date = str(datetime.date.today())<EOL>file_path =  ('<STR_LIT>')<EOL>if force or not os.path.isfile(file_path):<EOL><INDENT>my_github.login(username, password)<EOL>calls_beginning = self.logged_in_gh.ratelimit_remaining + <NUM_LIT:1><EOL>print('<STR_LIT>' + str(calls_beginning))<EOL>my_github.get_org(organization)<EOL>my_github.repos(building_stats=True)<EOL>print(\"<STR_LIT>\")<EOL>time.sleep(<NUM_LIT:30>)<EOL>print(\"<STR_LIT>\")<EOL>my_github.repos(building_stats=False)<EOL>my_github.calc_total_commits(starting_commits=<NUM_LIT>)<EOL>my_github.write_to_file()<EOL>calls_remaining = self.logged_in_gh.ratelimit_remaining<EOL>calls_used = calls_beginning - calls_remaining<EOL>print(('<STR_LIT>' + str(calls_remaining) + '<STR_LIT>'<EOL>+ str(calls_used) + '<STR_LIT>'))<EOL><DEDENT>", "docstring": "Does setup such as login, printing API info, and waiting for GitHub to\nbuild the commit statistics. Then gets the last year of commits and\nprints them to file.", "id": "f4699:c0:m1"}
{"signature": "def repos(self, building_stats=False):", "body": "print('<STR_LIT>')<EOL>for repo in self.org_retrieved.iter_repos():<EOL><INDENT>for activity in repo.iter_commit_activity():<EOL><INDENT>if not building_stats:<EOL><INDENT>self.commits_dict_list.append(activity)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Retrieves the last year of commits for the organization and stores them\nin weeks (UNIX time) associated with number of commits that week.", "id": "f4699:c0:m5"}
{"signature": "def get_org(self, organization_name='<STR_LIT>'):", "body": "if(organization_name == '<STR_LIT>'):<EOL><INDENT>organization_name = input('<STR_LIT>')<EOL><DEDENT>print('<STR_LIT>')<EOL>self.org_retrieved = self.logged_in_gh.organization(organization_name)<EOL>", "docstring": "Retrieves an organization via given org name. If given\nempty string, prompts user for an org name.", "id": "f4699:c0:m4"}
{"signature": "def get_stargazers(self, url, headers={}):", "body": "url = url + '<STR_LIT>'<EOL>page = <NUM_LIT:1><EOL>gazers = []<EOL>json_data = requests.get(url % page, headers=headers).json()<EOL>while json_data:<EOL><INDENT>gazers.extend(json_data)<EOL>page += <NUM_LIT:1><EOL>json_data = requests.get(url % page, headers=headers).json()<EOL><DEDENT>return gazers<EOL>", "docstring": "Return a list of the stargazers of a GitHub repo\n\nIncludes both the 'starred_at' and 'user' data.\n\nparam: url\n    url is the 'stargazers_url' of the form:\n        https://api.github.com/repos/LLNL/spack/stargazers", "id": "f4702:c0:m6"}
{"signature": "def setup_module(module):", "body": "logger.debug('<STR_LIT>')<EOL>pass<EOL>", "docstring": "Setup for the owc test module", "id": "f4708:m2"}
{"signature": "def scratch_file(filename):", "body": "return os.path.join(scratch_directory(), filename)<EOL>", "docstring": "Helper function to return file path in the tests scratch directory", "id": "f4736:m4"}
{"signature": "def cast_tuple_int_list(tup):", "body": "return [int(a) for a in tup]<EOL>", "docstring": "Set tuple float values to int for more predictable test results", "id": "f4736:m7"}
{"signature": "def cleanup_namespaces(element):", "body": "if etree.__name__ == '<STR_LIT>':<EOL><INDENT>etree.cleanup_namespaces(element)<EOL>return element<EOL><DEDENT>else:<EOL><INDENT>return etree.fromstring(etree.tostring(element))<EOL><DEDENT>", "docstring": "Remove unused namespaces from an element", "id": "f4746:m5"}
{"signature": "def xmlvalid(xml, xsd):", "body": "xsd1 = etree.parse(xsd)<EOL>xsd2 = etree.XMLSchema(xsd1)<EOL>doc = etree.parse(StringIO(xml))<EOL>return xsd2.validate(doc)<EOL>", "docstring": "Test whether an XML document is valid\n\nParameters\n----------\n\n- xml: XML content\n- xsd: pointer to XML Schema (local file path or URL)", "id": "f4746:m13"}
{"signature": "def xml2string(xml):", "body": "warnings.warn(\"<STR_LIT>\")<EOL>return '<STR_LIT>' + xml<EOL>", "docstring": "Return a string of XML object\n\nParameters\n----------\n\n- xml: xml string", "id": "f4746:m12"}
{"signature": "def build_get_url(base_url, params, overwrite=False):", "body": "qs_base = []<EOL>if base_url.find('<STR_LIT:?>') != -<NUM_LIT:1>:<EOL><INDENT>qs_base = cgi.parse_qsl(base_url.split('<STR_LIT:?>')[<NUM_LIT:1>])<EOL><DEDENT>qs_params = []<EOL>for key, value in six.iteritems(params):<EOL><INDENT>qs_params.append((key, value))<EOL><DEDENT>qs = qs_add = []<EOL>if overwrite is True:<EOL><INDENT>qs = qs_params<EOL>qs_add = qs_base<EOL><DEDENT>else:<EOL><INDENT>qs = qs_base<EOL>qs_add = qs_params<EOL><DEDENT>pars = [x[<NUM_LIT:0>] for x in qs]<EOL>for key, value in qs_add:<EOL><INDENT>if key not in pars:<EOL><INDENT>qs.append((key, value))<EOL><DEDENT><DEDENT>urlqs = urlencode(tuple(qs))<EOL>return base_url.split('<STR_LIT:?>')[<NUM_LIT:0>] + '<STR_LIT:?>' + urlqs<EOL>", "docstring": "Utility function to build a full HTTP GET URL from the service base URL and a dictionary of HTTP parameters.\n\n    TODO: handle parameters case-insensitive?\n\n    @param overwrite: boolean flag to allow overwrite of parameters of the base_url (default: False)", "id": "f4746:m16"}
{"signature": "def getTypedValue(data_type, value):", "body": "if data_type == '<STR_LIT>':<EOL><INDENT>return True if value.lower() == '<STR_LIT:true>' else False<EOL><DEDENT>elif data_type == '<STR_LIT>':<EOL><INDENT>return int(value)<EOL><DEDENT>elif data_type == '<STR_LIT:float>':<EOL><INDENT>return float(value)<EOL><DEDENT>elif data_type == '<STR_LIT:string>':<EOL><INDENT>return str(value)<EOL><DEDENT>else:<EOL><INDENT>return value<EOL><DEDENT>", "docstring": "Utility function to cast a string value to the appropriate XSD type.", "id": "f4746:m18"}
{"signature": "def extract_xml_list(elements):", "body": "keywords = (re.split(r'<STR_LIT>',f.text) for f in elements if f.text)<EOL>flattened = (item.strip() for sublist in keywords for item in sublist)<EOL>remove_blank = [_f for _f in flattened if _f]<EOL>return remove_blank<EOL>", "docstring": "Some people don't have seperate tags for their keywords and seperate them with\na newline. This will extract out all of the keywords correctly.", "id": "f4746:m20"}
{"signature": "def encode_string(text):", "body": "if six.PY3:<EOL><INDENT>return text<EOL><DEDENT>if isinstance(text, str):<EOL><INDENT>return text.decode('<STR_LIT:utf-8>').encode('<STR_LIT:utf-8>', '<STR_LIT:ignore>')<EOL><DEDENT>return text.encode('<STR_LIT:utf-8>', '<STR_LIT:ignore>')<EOL>", "docstring": "On Python 3 this method does nothing and returns the ``text`` string itself.\nOn Python 2 this method returns the ``text`` string encoded with UTF-8.\n\nSee:\n* https://pythonhosted.org/six/#six.python_2_unicode_compatible\n* https://www.azavea.com/blog/2014/03/24/solving-unicode-problems-in-python-2-7/", "id": "f4746:m29"}
{"signature": "def datetime_from_ansi(ansi):", "body": "datumOrigin = datetime(<NUM_LIT>,<NUM_LIT:12>,<NUM_LIT>,<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:0>)<EOL>return datumOrigin + timedelta(ansi)<EOL>", "docstring": "Converts an ansiDate (expressed as a number = the nuber of days since the datum origin of ansi) to a python datetime object.", "id": "f4746:m27"}
{"signature": "def which_etree():", "body": "which_etree = None<EOL>if '<STR_LIT>' in etree.__file__:<EOL><INDENT>which_etree = '<STR_LIT>'<EOL><DEDENT>elif '<STR_LIT>' in etree.__file__:<EOL><INDENT>which_etree = '<STR_LIT>'<EOL><DEDENT>elif '<STR_LIT>' in etree.__file__:<EOL><INDENT>which_etree = '<STR_LIT>'<EOL><DEDENT>return which_etree<EOL>", "docstring": "decipher which etree library is being used by OWSLib", "id": "f4746:m24"}
{"signature": "def getService_urls(self, service_string=None):", "body": "urls=[]<EOL>for key,rec in six.iteritems(self.records):<EOL><INDENT>url = next((d['<STR_LIT:url>'] for d in rec.references if d['<STR_LIT>'] == service_string), None)<EOL>if url is not None:<EOL><INDENT>urls.append(url)<EOL><DEDENT><DEDENT>return urls<EOL>", "docstring": "Return easily identifiable URLs for all service types\n\nParameters\n----------\n\n- service_string: a URI to lookup", "id": "f4748:c0:m9"}
{"signature": "def getrecords(self, qtype=None, keywords=[], typenames='<STR_LIT>', propertyname='<STR_LIT>', bbox=None, esn='<STR_LIT>', sortby=None, outputschema=namespaces['<STR_LIT>'], format=outputformat, startposition=<NUM_LIT:0>, maxrecords=<NUM_LIT:10>, cql=None, xml=None, resulttype='<STR_LIT>'):", "body": "warnings.warn(\"\"\"<STR_LIT>\"\"\")<EOL>if xml is not None:<EOL><INDENT>self.request = etree.fromstring(xml)<EOL>val = self.request.find(util.nspath_eval('<STR_LIT>', namespaces))<EOL>if val is not None:<EOL><INDENT>esn = util.testXMLValue(val)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>node0 = self._setrootelement('<STR_LIT>')<EOL>if etree.__name__ != '<STR_LIT>':  <EOL><INDENT>node0.set('<STR_LIT>', namespaces['<STR_LIT>'])<EOL>node0.set('<STR_LIT>', namespaces['<STR_LIT>'])<EOL>node0.set('<STR_LIT>', namespaces['<STR_LIT>'])<EOL>node0.set('<STR_LIT>', namespaces['<STR_LIT>'])<EOL><DEDENT>node0.set('<STR_LIT>', outputschema)<EOL>node0.set('<STR_LIT>', format)<EOL>node0.set('<STR_LIT:version>', self.version)<EOL>node0.set('<STR_LIT>', resulttype)<EOL>node0.set('<STR_LIT>', self.service)<EOL>if startposition > <NUM_LIT:0>:<EOL><INDENT>node0.set('<STR_LIT>', str(startposition))<EOL><DEDENT>node0.set('<STR_LIT>', str(maxrecords))<EOL>node0.set(util.nspath_eval('<STR_LIT>', namespaces), schema_location)<EOL>node1 = etree.SubElement(node0, util.nspath_eval('<STR_LIT>', namespaces))<EOL>node1.set('<STR_LIT>', typenames)<EOL>etree.SubElement(node1, util.nspath_eval('<STR_LIT>', namespaces)).text = esn<EOL>self._setconstraint(node1, qtype, propertyname, keywords, bbox, cql, None)<EOL>if sortby is not None:<EOL><INDENT>fes.setsortby(node1, sortby)<EOL><DEDENT>self.request = node0<EOL><DEDENT>self._invoke()<EOL>if self.exceptionreport is None:<EOL><INDENT>self.results = {}<EOL>val = self._exml.find(util.nspath_eval('<STR_LIT>', namespaces)).attrib.get('<STR_LIT>')<EOL>self.results['<STR_LIT>'] = int(util.testXMLValue(val, True))<EOL>val = self._exml.find(util.nspath_eval('<STR_LIT>', namespaces)).attrib.get('<STR_LIT>')<EOL>self.results['<STR_LIT>'] = int(util.testXMLValue(val, True))<EOL>val = self._exml.find(util.nspath_eval('<STR_LIT>', namespaces)).attrib.get('<STR_LIT>')<EOL>self.results['<STR_LIT>'] = int(util.testXMLValue(val, True))<EOL>self.records = OrderedDict()<EOL>self._parserecords(outputschema, esn)<EOL><DEDENT>", "docstring": "Construct and process a  GetRecords request\n\nParameters\n----------\n\n- qtype: type of resource to query (i.e. service, dataset)\n- keywords: list of keywords\n- typenames: the typeNames to query against (default is csw:Record)\n- propertyname: the PropertyName to Filter against \n- bbox: the bounding box of the spatial query in the form [minx,miny,maxx,maxy]\n- esn: the ElementSetName 'full', 'brief' or 'summary' (default is 'summary')\n- sortby: property to sort results on\n- outputschema: the outputSchema (default is 'http://www.opengis.net/cat/csw/2.0.2')\n- format: the outputFormat (default is 'application/xml')\n- startposition: requests a slice of the result set, starting at this position (default is 0)\n- maxrecords: the maximum number of records to return. No records are returned if 0 (default is 10)\n- cql: common query language text.  Note this overrides bbox, qtype, keywords\n- xml: raw XML request.  Note this overrides all other options\n- resulttype: the resultType 'hits', 'results', 'validate' (default is 'results')", "id": "f4748:c0:m3"}
{"signature": "def getrecordbyid(self, id=[], esn='<STR_LIT>', outputschema=namespaces['<STR_LIT>'], format=outputformat):", "body": "<EOL>data = {<EOL>'<STR_LIT>': self.service,<EOL>'<STR_LIT:version>': self.version,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': format,<EOL>'<STR_LIT>': outputschema,<EOL>'<STR_LIT>': esn,<EOL>'<STR_LIT:id>': '<STR_LIT:U+002C>'.join(id),<EOL>}<EOL>self.request = urlencode(data)<EOL>self._invoke()<EOL>if self.exceptionreport is None:<EOL><INDENT>self.results = {}<EOL>self.records = OrderedDict()<EOL>self._parserecords(outputschema, esn)<EOL><DEDENT>", "docstring": "Construct and process a GetRecordById request\n\nParameters\n----------\n\n- id: the list of Ids\n- esn: the ElementSetName 'full', 'brief' or 'summary' (default is 'full')\n- outputschema: the outputSchema (default is 'http://www.opengis.net/cat/csw/2.0.2')\n- format: the outputFormat (default is 'application/xml')", "id": "f4748:c0:m4"}
{"signature": "def get_operation_by_name(self, name):", "body": "for item in self.operations:<EOL><INDENT>if item.name.lower() == name.lower():<EOL><INDENT>return item<EOL><DEDENT><DEDENT>raise KeyError(\"<STR_LIT>\" % name)<EOL>", "docstring": "Return a named operation", "id": "f4748:c0:m8"}
{"signature": "def __init__(self, md):", "body": "_GenericObject.__init__(self, md)<EOL>self.level = util.testXMLValue(md.find(util.nspath_eval('<STR_LIT>', namespaces)))<EOL>val = md.find(util.nspath_eval('<STR_LIT>', namespaces))<EOL>self.data_quality = _GenericObjectProperty(val)<EOL>", "docstring": "constructor", "id": "f4750:c18:m0"}
{"signature": "def __init__(self, md):", "body": "Core.__init__(self, md)<EOL>", "docstring": "constructor", "id": "f4750:c50:m0"}
{"signature": "def __init__(self, md):", "body": "_GenericObject.__init__(self, md)<EOL>self.number = util.testXMLValue(md.find(util.nspath_eval('<STR_LIT>', namespaces)))<EOL>self.number_type = util.testXMLValue(md.find(util.nspath_eval('<STR_LIT>', namespaces)))<EOL>val = md.find(util.nspath_eval('<STR_LIT>', namespaces))<EOL>self.responsible_party = _GenericObjectProperty(val)<EOL>", "docstring": "constructor", "id": "f4750:c17:m0"}
{"signature": "def __init__(self, md):", "body": "_GenericObject.__init__(self, md)<EOL>val = md.find(util.nspath_eval('<STR_LIT>', namespaces))<EOL>self.point_of_contact = _GenericObjectProperty(val)<EOL>val = md.find(util.nspath_eval('<STR_LIT>', namespaces))<EOL>self.identification = _GenericObjectProperty(val)<EOL>val = md.find(util.nspath_eval('<STR_LIT>', namespaces))<EOL>if val is not None:<EOL><INDENT>self.role = util.testXMLValue(val.find(util.nspath_eval('<STR_LIT>', namespaces)))<EOL><DEDENT>", "docstring": "constructor", "id": "f4750:c47:m0"}
{"signature": "def __init__(self, md):", "body": "_GenericObject.__init__(self, md)<EOL>val = md.find(util.nspath_eval('<STR_LIT>', namespaces))<EOL>self.distribution = _GenericObjectProperty(val)<EOL>", "docstring": "constructor", "id": "f4750:c12:m0"}
{"signature": "def __init__(self, md):", "body": "_GenericObject.__init__(self, md)<EOL>val = md.find(util.nspath_eval('<STR_LIT>', namespaces))<EOL>if val is not None:<EOL><INDENT>self.title = PT_FreeText(val)<EOL><DEDENT>val = md.find(util.nspath_eval('<STR_LIT>', namespaces))<EOL>self.authority = _GenericObjectProperty(val)<EOL>", "docstring": "constructor", "id": "f4750:c31:m0"}
{"signature": "def __init__(self, md):", "body": "_GenericObject.__init__(self, md)<EOL>self.extent_type_code = util.testXMLValue(md.find(util.nspath_eval('<STR_LIT>', namespaces)))<EOL>boundaries = []<EOL>for boundary in md.findall(util.nspath_eval('<STR_LIT>', namespaces)):<EOL><INDENT>polylines = []<EOL>for polyline in boundary.findall(util.nspath_eval('<STR_LIT>', namespaces)):<EOL><INDENT>coords = []<EOL>arcs = []<EOL>for coord in polyline.findall(util.nspath_eval('<STR_LIT>', namespaces)):<EOL><INDENT>c1 = util.testXMLValue(coord.find(util.nspath_eval('<STR_LIT>', namespaces)))<EOL>c2 = util.testXMLValue(coord.find(util.nspath_eval('<STR_LIT>', namespaces)))<EOL>c3 = util.testXMLValue(coord.find(util.nspath_eval('<STR_LIT>', namespaces)))<EOL>coordvalue = {'<STR_LIT>': c1, '<STR_LIT>': c2, '<STR_LIT>': c3}<EOL>coords.append(coordvalue)<EOL><DEDENT>for arc in polyline.findall(util.nspath_eval('<STR_LIT>', namespaces)):<EOL><INDENT>c1 = util.testXMLValue(coord.find(util.nspath_eval('<STR_LIT>', namespaces)))<EOL>c2 = util.testXMLValue(coord.find(util.nspath_eval('<STR_LIT>', namespaces)))<EOL>c3 = util.testXMLValue(coord.find(util.nspath_eval('<STR_LIT>', namespaces)))<EOL>a1 = util.testXMLValue(coord.find(util.nspath_eval('<STR_LIT>', namespaces)))<EOL>a2 = util.testXMLValue(coord.find(util.nspath_eval('<STR_LIT>', namespaces)))<EOL>r = util.testXMLValue(coord.find(util.nspath_eval('<STR_LIT>', namespaces)))<EOL>arcpoint = {'<STR_LIT>': c1, '<STR_LIT>': c2, '<STR_LIT>': c3, '<STR_LIT>': a1, '<STR_LIT>': a2, '<STR_LIT:r>': r}<EOL>arcs.append(arcpoint)<EOL><DEDENT>polylines.append(coords)<EOL>polylines.append(arcs)<EOL><DEDENT>boundaries.append(polylines)<EOL><DEDENT>self.boundary = boundaries<EOL>", "docstring": "constructor", "id": "f4750:c25:m0"}
{"signature": "def __init__(self, md):", "body": "_GenericObject.__init__(self, md)<EOL>", "docstring": "constructor", "id": "f4750:c10:m0"}
{"signature": "def __init__(self, md):", "body": "EX_TemporalExtent.__init__(self, md)<EOL>", "docstring": "constructor", "id": "f4750:c36:m0"}
{"signature": "def __init__(self, md):", "body": "_GenericObject.__init__(self, md)<EOL>self.minimum_value = util.testXMLValue(md.find(util.nspath_eval('<STR_LIT>', namespaces)))<EOL>self.maximum_value = util.testXMLValue(md.find(util.nspath_eval('<STR_LIT>', namespaces)))<EOL>self.unit_of_measure = util.testXMLValue(md.find(util.nspath_eval('<STR_LIT>', namespaces)))<EOL>val = md.find(util.nspath_eval('<STR_LIT>', namespaces))<EOL>self.vertical_datum = _GenericObjectProperty(val)<EOL>", "docstring": "constructor", "id": "f4750:c19:m0"}
{"signature": "def __init__(self, md):", "body": "_GenericObject.__init__(self, md)<EOL>val = md.find(util.nspath_eval('<STR_LIT>', namespaces))<EOL>if val is not None:<EOL><INDENT>self.status = util.testXMLValue(val.find(util.nspath_eval('<STR_LIT>', namespaces)))<EOL><DEDENT>val = md.find(util.nspath_eval('<STR_LIT>', namespaces))<EOL>if val is not None:<EOL><INDENT>self.abstract = PT_FreeText(val)<EOL><DEDENT>val = md.find(util.nspath_eval('<STR_LIT>', namespaces))<EOL>if val is not None:<EOL><INDENT>self.purpose = PT_FreeText(val)<EOL><DEDENT>val = md.find(util.nspath_eval('<STR_LIT>', namespaces))<EOL>self.metadata = _GenericObjectProperty(val)<EOL>val = md.find(util.nspath_eval('<STR_LIT>', namespaces))<EOL>self.citation = _GenericObjectProperty(val)<EOL>val = md.find(util.nspath_eval('<STR_LIT>', namespaces))<EOL>if val is not None:<EOL><INDENT>self.spatial_representation_type = util.testXMLValue(val.find(util.nspath_eval('<STR_LIT>', namespaces)))<EOL><DEDENT>val = md.find(util.nspath_eval('<STR_LIT>', namespaces))<EOL>if val is not None:<EOL><INDENT>self.language = util.testXMLValue(val.find(util.nspath_eval('<STR_LIT>', namespaces)))<EOL><DEDENT>val = md.find(util.nspath_eval('<STR_LIT>', namespaces))<EOL>if val is not None:<EOL><INDENT>self.character_set = util.testXMLValue(val.find(util.nspath_eval('<STR_LIT>', namespaces)))<EOL><DEDENT>val = md.find(util.nspath_eval('<STR_LIT>', namespaces))<EOL>if val is not None:<EOL><INDENT>self.topic_category = util.testXMLValue(val.find(util.nspath_eval('<STR_LIT>', namespaces)))<EOL><DEDENT>", "docstring": "constructor", "id": "f4750:c40:m0"}
{"signature": "def __init__(self, md):", "body": "_GenericObject.__init__(self, md)<EOL>self.hours_of_service = util.testXMLValue(md.find(util.nspath_eval('<STR_LIT>', namespaces)))<EOL>val = md.find(util.nspath_eval('<STR_LIT>', namespaces))<EOL>if val is not None:<EOL><INDENT>self.contact_instructions = PT_FreeText(val)<EOL><DEDENT>", "docstring": "constructor", "id": "f4750:c32:m0"}
{"signature": "def __init__(self, md):", "body": "self.tid = None<EOL>if md is not None:<EOL><INDENT>self.tid = md.attrib.get('<STR_LIT>')<EOL><DEDENT>", "docstring": "constructor", "id": "f4750:c0:m0"}
{"signature": "def getfeatureinfo(**kw):", "body": "", "docstring": "Make a request to the WMS, returns data.", "id": "f4753:c6:m2"}
{"signature": "def getcapabilities(**kw):", "body": "", "docstring": "Makes a GetCapabilities request to the remote WPS server,\nreturns an XML document wrapped in a python file-like object.", "id": "f4753:c10:m0"}
{"signature": "def axml_context(d):", "body": "xml = etree.Element(\"<STR_LIT>\", nsmap=ns)<EOL>etree.SubElement(xml, \"<STR_LIT:id>\").text = d['<STR_LIT:id>']<EOL>spec_reference = [axml_link(do) for do in<EOL>extract_p('<STR_LIT>', d, [])]<EOL>[xml.append(el) for el in spec_reference if el is not None]<EOL>area_of_interest = extract_p('<STR_LIT>', d, None)<EOL>if area_of_interest is not None:<EOL><INDENT>try:<EOL><INDENT>gml = etree.fromstring(area_of_interest)<EOL>georss = etree.SubElement(xml, ns_elem(\"<STR_LIT>\", \"<STR_LIT>\"))<EOL>georss.append(gml)<EOL><DEDENT>except Exception as ex:<EOL><INDENT>log.warn('<STR_LIT>', ex)<EOL>pass<EOL><DEDENT><DEDENT>context_metadata = [axml_link(do) for do in<EOL>extract_p('<STR_LIT>', d, [])]<EOL>[xml.append(el) for el in context_metadata if el is not None]<EOL>language = extract_p('<STR_LIT>', d, None)<EOL>if language is not None: xml.set(ns_elem(\"<STR_LIT>\", \"<STR_LIT>\"), language)<EOL>title = extract_p('<STR_LIT>', d, None)<EOL>if title is not None: etree.SubElement(xml, \"<STR_LIT:title>\").text = title<EOL>subtitle = extract_p('<STR_LIT>', d, None)<EOL>if subtitle is not None: etree.SubElement(xml, \"<STR_LIT>\").text = subtitle<EOL>update_date = extract_p('<STR_LIT>', d, None)<EOL>if update_date is not None: etree.SubElement(xml, \"<STR_LIT>\").text = update_date<EOL>authors = [axml_author(do) for do in extract_p('<STR_LIT>', d, [])]<EOL>[xml.append(el) for el in authors if el is not None]<EOL>publisher = extract_p('<STR_LIT>', d, None)<EOL>if publisher is not None: etree.SubElement(xml, ns_elem(\"<STR_LIT>\", \"<STR_LIT>\")).text = publisher<EOL>creator_application = axml_creator_app(extract_p('<STR_LIT>', d, None))<EOL>if creator_application is not None and not is_empty(creator_application): xml.append(creator_application)<EOL>creator_display = axml_display(extract_p('<STR_LIT>', d, None))<EOL>if creator_display is not None: xml.append(creator_display)<EOL>rights = extract_p('<STR_LIT>', d, None)<EOL>if rights is not None: etree.SubElement(xml, \"<STR_LIT>\").text = rights<EOL>time_interval_of_interest = extract_p('<STR_LIT>', d, None)<EOL>if time_interval_of_interest is not None: etree.SubElement(xml,<EOL>ns_elem(\"<STR_LIT>\", \"<STR_LIT:date>\")).text = time_interval_of_interest<EOL>keywords = [axml_category(do) for do in<EOL>extract_p('<STR_LIT>', d, [])]<EOL>[xml.append(el) for el in keywords if el is not None]<EOL>resources = [axml_resource(do) for do in<EOL>extract_p('<STR_LIT>', d, [])]<EOL>[xml.append(el) for el in resources if el is not None]<EOL>return xml<EOL>", "docstring": "encodes base OwcContext as dict to atom xml tree\n:param d:\n:return:", "id": "f4754:m7"}
{"signature": "def __init__(self,<EOL>pixel_width,<EOL>pixel_height=None,<EOL>mm_per_pixel=None,<EOL>):", "body": "self.pixel_width = pixel_width<EOL>self.pixel_height = pixel_height<EOL>self.mm_per_pixel = mm_per_pixel<EOL>", "docstring": "constructor:\n\n:param pixel_width: Double\n:param pixel_height: Double\n:param mm_per_pixel: Double", "id": "f4757:c4:m0"}
{"signature": "@classmethod<EOL><INDENT>def from_atomxml(cls, xml_bytes):<DEDENT>", "body": "<EOL>d = decode_atomxml(xml_bytes)<EOL>return cls.from_dict(d)<EOL>", "docstring": "lets see if we can reuse the dict structure builder from geojson\n:param xmlstring:\n:return: OwcContext", "id": "f4757:c0:m7"}
{"signature": "def __init__(self,<EOL>name=None,<EOL>email=None,<EOL>uri=None<EOL>):", "body": "self.name = name<EOL>self.email = email<EOL>self.uri = uri<EOL>", "docstring": "constructor:\n\n:param name: String\n:param email: String (EmailAddress)\n:param uri: URL", "id": "f4757:c7:m0"}
{"signature": "def __init__(self,<EOL>offering_code,<EOL>operations=[],<EOL>contents=[],<EOL>styles=[]<EOL>):", "body": "self.offering_code = offering_code<EOL>self.operations = operations<EOL>self.contents = contents<EOL>self.styles = styles<EOL>", "docstring": "constructor:\n\n:param offering_code: URL\n:param operations: List[OwcOperation]\n:param contents: List[OwcContent]\n:param styles: List[OwcStyleSet]", "id": "f4757:c8:m0"}
{"signature": "def __init__(self,<EOL>id,<EOL>title,<EOL>update_date,<EOL>subtitle=None,<EOL>authors=[],<EOL>publisher=None,<EOL>rights=None,<EOL>geospatial_extent=None,<EOL>temporal_extent=None,<EOL>content_description=[],<EOL>preview=[],<EOL>content_by_ref=[],<EOL>offerings=[],<EOL>active=False,<EOL>resource_metadata=[],<EOL>keywords=[],<EOL>min_scale_denominator=None,<EOL>max_scale_denominator=None,<EOL>folder=None<EOL>):", "body": "<EOL>self.id = id<EOL>self.title = title<EOL>self.subtitle = subtitle<EOL>self.update_date = update_date<EOL>self.authors = authors<EOL>self.publisher = publisher<EOL>self.rights = rights<EOL>self.geospatial_extent = geospatial_extent<EOL>self.temporal_extent = temporal_extent<EOL>self.content_description = content_description<EOL>self.preview = preview<EOL>self.content_by_ref = content_by_ref<EOL>self.offerings = offerings<EOL>self.active = active<EOL>self.resource_metadata = resource_metadata<EOL>self.keywords = keywords<EOL>self.min_scale_denominator = min_scale_denominator<EOL>self.max_scale_denominator = max_scale_denominator<EOL>self.folder = folder<EOL>", "docstring": "constructor:\n\n:param id: URL\n:param title: String\n:param update_date: datetime\n:param subtitle: String\n:param authors: List[OwcAuthor]\n:param publisher: String\n:param rights: String\n:param geospatial_extent: currently GeoJSON Polygon String\n:param temporal_extent: str\n:param content_description: OwcLink[] links.alternates, rel=alternate\n:param preview: OwcLink[] aka links.previews[] and rel=icon (atom)\n:param content_by_ref: OwcLink[], links.data, rel=enclosure (atom)\n:param offerings: OwcOffering[]\n:param active: Boolean\n:param resource_metadata: OwcLink[] aka links.via[] & rel=via\n:param keywords: OwcCategory[]\n:param min_scale_denominator: Double\n:param max_scale_denominator: Double\n:param folder: String", "id": "f4757:c1:m0"}
{"signature": "def _readFromUrl(self, url, data, timeout, method='<STR_LIT>', username=None, password=None,<EOL>headers=None, verify=True, cert=None):", "body": "if method == '<STR_LIT>':<EOL><INDENT>request_url = build_get_url(url, data, overwrite=True)<EOL>log.debug(request_url)<EOL>spliturl = request_url.split('<STR_LIT:?>')<EOL>u = openURL(spliturl[<NUM_LIT:0>], spliturl[<EOL><NUM_LIT:1>], method='<STR_LIT>', username=username, password=password,<EOL>headers=headers, verify=verify, cert=cert, timeout=self.timeout)<EOL>return etree.fromstring(u.read())<EOL><DEDENT>elif method == '<STR_LIT>':<EOL><INDENT>u = openURL(url, data, method='<STR_LIT>',<EOL>username=username, password=password,<EOL>headers=headers, verify=verify, cert=cert, timeout=timeout)<EOL>return etree.fromstring(u.read())<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\" % method)<EOL><DEDENT>", "docstring": "Method to get and parse a WPS document, returning an elementtree instance.\n:param str url: WPS service base url.\n:param str data: GET: dictionary of HTTP (key, value) parameter pairs, POST: XML document to post\n:param str username: optional user credentials\n:param str password: optional user credentials", "id": "f4759:c2:m1"}
{"signature": "def _parseComplexData(self, element, complexDataElementName):", "body": "<EOL>complex_data_element = element.find(complexDataElementName)<EOL>if complex_data_element is not None:<EOL><INDENT>self.dataType = \"<STR_LIT>\"<EOL>for supported_comlexdata_element incomplex_data_element.findall('<STR_LIT>'):<EOL><INDENT>self.supportedValues.append(<EOL>ComplexData(<EOL>mimeType=testXMLValue(<EOL>supported_comlexdata_element.find('<STR_LIT>')),<EOL>encoding=testXMLValue(<EOL>supported_comlexdata_element.find('<STR_LIT>')),<EOL>schema=testXMLValue(<EOL>supported_comlexdata_element.find('<STR_LIT>'))<EOL>)<EOL>)<EOL><DEDENT>for format_element incomplex_data_element.findall('<STR_LIT>'):<EOL><INDENT>self.supportedValues.append(<EOL>ComplexData(<EOL>mimeType=testXMLValue(format_element.find('<STR_LIT>')),<EOL>encoding=testXMLValue(format_element.find('<STR_LIT>')),<EOL>schema=testXMLValue(format_element.find('<STR_LIT>'))<EOL>)<EOL>)<EOL><DEDENT>default_format_element = complex_data_element.find('<STR_LIT>')<EOL>if default_format_element is not None:<EOL><INDENT>self.defaultValue = ComplexData(<EOL>mimeType=testXMLValue(<EOL>default_format_element.find('<STR_LIT>')),<EOL>encoding=testXMLValue(<EOL>default_format_element.find('<STR_LIT>')),<EOL>schema=testXMLValue(default_format_element.find('<STR_LIT>'))<EOL>)<EOL><DEDENT><DEDENT>", "docstring": "Method to parse a ComplexData or ComplexOutput element.", "id": "f4759:c8:m3"}
{"signature": "def retrieveData(self, username=None, password=None, headers=None, verify=True, cert=None):", "body": "url = self.reference<EOL>if url is None:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>log.info('<STR_LIT>' % url)<EOL>if '<STR_LIT:?>' in url:<EOL><INDENT>spliturl = url.split('<STR_LIT:?>')<EOL>u = openURL(spliturl[<NUM_LIT:0>], spliturl[<EOL><NUM_LIT:1>], method='<STR_LIT>', username=username, password=password,<EOL>headers=headers, verify=verify, cert=cert)<EOL>self.fileName = spliturl[<NUM_LIT:1>].split('<STR_LIT:=>')[<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>u = openURL(<EOL>url, '<STR_LIT>', method='<STR_LIT>', username=username, password=password,<EOL>headers=headers, verify=verify, cert=cert)<EOL>self.fileName = url.split('<STR_LIT:/>')[-<NUM_LIT:1>]<EOL><DEDENT>return u.read()<EOL>", "docstring": "Method to retrieve data from server-side reference:\nreturns \"\" if the reference is not known.\n\n:param username: credentials to access the remote WPS server\n:param password: credentials to access the remote WPS server", "id": "f4759:c10:m1"}
{"signature": "def __init__(self, url, version=WPS_DEFAULT_VERSION, username=None, password=None, verbose=False, skip_caps=False,<EOL>headers=None, verify=True, cert=None, timeout=None):", "body": "<EOL>self.url = clean_ows_url(url)<EOL>self.username = username<EOL>self.password = password<EOL>self.version = version<EOL>self.verbose = verbose<EOL>self.headers = headers<EOL>self.verify = verify<EOL>self.cert = cert<EOL>self.timeout = timeout<EOL>self._capabilities = None<EOL>self.identification = None<EOL>self.provider = None<EOL>self.operations = []<EOL>self.processes = []<EOL>if not skip_caps:<EOL><INDENT>self.getcapabilities()<EOL><DEDENT>", "docstring": "Initialization method resets the object status.\nBy default it will execute a GetCapabilities invocation to the remote service,\nwhich can be skipped by using skip_caps=True.", "id": "f4759:c1:m0"}
{"signature": "def _parseExceptionReport(self, root):", "body": "<EOL>if self.status is None:<EOL><INDENT>self.status = \"<STR_LIT>\"<EOL><DEDENT>for exceptionEl in root.findall(nspath('<STR_LIT>', ns=namespaces['<STR_LIT>'])):<EOL><INDENT>self.errors.append(WPSException(exceptionEl))<EOL><DEDENT>", "docstring": "Method to parse a WPS ExceptionReport document and populate this object's metadata.", "id": "f4759:c6:m11"}
{"signature": "def readFromUrl(self, url, username=None, password=None,<EOL>headers=None, verify=True, cert=None):", "body": "return self._readFromUrl(url,<EOL>{'<STR_LIT>': '<STR_LIT>', '<STR_LIT>':<EOL>'<STR_LIT>', '<STR_LIT:version>': self.version},<EOL>self.timeout,<EOL>username=username, password=password,<EOL>headers=headers, verify=verify, cert=cert)<EOL>", "docstring": "Method to get and parse a WPS capabilities document, returning an elementtree instance.\n\n:param str url: WPS service base url, to which is appended the HTTP parameters: service, version, and request.\n:param str username: optional user credentials\n:param str password: optional user credentials", "id": "f4759:c3:m1"}
{"signature": "def execute(self, identifier, inputs, output=None, mode=ASYNC, lineage=False, request=None, response=None):", "body": "<EOL>log.info('<STR_LIT>')<EOL>execution = WPSExecution(version=self.version, url=self.url,<EOL>username=self.username, password=self.password, verbose=self.verbose,<EOL>headers=self.headers, verify=self.verify, cert=self.cert, timeout=self.timeout)<EOL>if request is None:<EOL><INDENT>requestElement = execution.buildRequest(identifier, inputs, output, mode=mode, lineage=lineage)<EOL>request = etree.tostring(requestElement)<EOL>execution.request = request<EOL><DEDENT>log.debug(request)<EOL>if response is None:<EOL><INDENT>response = execution.submitRequest(request)<EOL><DEDENT>else:<EOL><INDENT>response = etree.fromstring(response)<EOL><DEDENT>log.debug(etree.tostring(response))<EOL>execution.parseResponse(response)<EOL>return execution<EOL>", "docstring": "Submits a WPS process execution request.\nReturns a WPSExecution object, which can be used to monitor the status of the job, and ultimately\nretrieve the result.\n\n:param str identifier: the requested process identifier\n:param inputs: list of process inputs as (input_identifier, value) tuples (where value is either a string\n        for LiteralData, or an object for ComplexData).\n:param output: optional list of process outputs as tuples (output_identifier, as_ref, mime_type).\n        `as_ref` can be True (as reference),\n        False (embedded in response) or None (use service default).\n        `mime_type` should be text or None (use service default)\n:param mode: execution mode: SYNC, ASYNC or AUTO. Default: ASYNC\n:param lineage: if lineage is \"true\", the Execute operation response shall include the DataInputs and\n         OutputDefinitions elements.\n:param request: optional pre-built XML request document, prevents building of request from other arguments\n:param response: optional pre-built XML response document, prevents submission of request to live WPS server", "id": "f4759:c1:m3"}
{"signature": "def readFromUrl(self, url, identifier, username=None, password=None,<EOL>headers=None, verify=True, cert=None):", "body": "return self._readFromUrl(url,<EOL>{'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:version>': self.version, '<STR_LIT>': identifier},<EOL>self.timeout,<EOL>username=username, password=password,<EOL>headers=headers, verify=verify, cert=cert)<EOL>", "docstring": "Reads a WPS DescribeProcess document from a remote service and returns the XML etree object\n\n:param str url: WPS service base url, to which is appended the HTTP parameters: 'service', 'version',\n    'request', and 'identifier'.", "id": "f4759:c4:m1"}
{"signature": "def _parseBoundingBoxData(self, element, bboxElementName):", "body": "<EOL>bbox_data_element = element.find(bboxElementName)<EOL>if bbox_data_element is not None:<EOL><INDENT>self.dataType = '<STR_LIT>'<EOL>for bbox_element in bbox_data_element.findall('<STR_LIT>'):<EOL><INDENT>self.supportedValues.append(bbox_element.text)<EOL><DEDENT>default_bbox_element = bbox_data_element.find('<STR_LIT>')<EOL>if default_bbox_element is not None:<EOL><INDENT>self.defaultValue = default_bbox_element.text<EOL><DEDENT><DEDENT>", "docstring": "Method to parse the BoundingBoxData element.", "id": "f4759:c8:m4"}
{"signature": "def items(self, srs=None, profile=None):", "body": "items=[]<EOL>if not srs and not profile:<EOL><INDENT>for item in self.contents:<EOL><INDENT>items.append((item,self.contents[item]))<EOL><DEDENT><DEDENT>elif srs and profile:<EOL><INDENT>for item in self.contents:<EOL><INDENT>if (self.contents[item].srs == srs and<EOL>self.contents[item].profile == profile):<EOL><INDENT>items.append((item,self.contents[item]))<EOL><DEDENT><DEDENT><DEDENT>elif srs:<EOL><INDENT>for item in self.contents:<EOL><INDENT>if self.contents[item].srs == srs:<EOL><INDENT>items.append((item,self.contents[item]))<EOL><DEDENT><DEDENT><DEDENT>elif profile:<EOL><INDENT>for item in self.contents:<EOL><INDENT>if self.contents[item].profile == profile:<EOL><INDENT>items.append((item,self.contents[item]))<EOL><DEDENT><DEDENT><DEDENT>return items<EOL>", "docstring": "supports dict-like items() access", "id": "f4760:c0:m4"}
{"signature": "def __init__(self, url, version='<STR_LIT>', xml=None, username=None, password=None, parse_remote_metadata=False, timeout=<NUM_LIT:30>):", "body": "self.url = url<EOL>self.username = username<EOL>self.password = password<EOL>self.version = version<EOL>self.timeout = timeout<EOL>self.services = None<EOL>self._capabilities = None<EOL>self.contents={}<EOL>reader = TMSCapabilitiesReader(<EOL>self.version, url=self.url, un=self.username, pw=self.password<EOL>)<EOL>if xml:  <EOL><INDENT>self._capabilities = reader.readString(xml)<EOL><DEDENT>else:  <EOL><INDENT>self._capabilities = reader.read(self.url, timeout=self.timeout)<EOL><DEDENT>self._buildMetadata(parse_remote_metadata)<EOL>", "docstring": "Initialize.", "id": "f4760:c0:m0"}
{"signature": "def WebCoverageService(url, version=None, xml=None, cookies=None, timeout=<NUM_LIT:30>):", "body": "if version is None:<EOL><INDENT>if xml is None:<EOL><INDENT>reader = wcsBase.WCSCapabilitiesReader()<EOL>request = reader.capabilities_url(url)<EOL>xml = openURL(request, cookies=cookies, timeout=timeout).read()<EOL><DEDENT>capabilities = etree.etree.fromstring(xml)<EOL>version = capabilities.get('<STR_LIT:version>')<EOL>del capabilities<EOL><DEDENT>clean_url = clean_ows_url(url)<EOL>if version == '<STR_LIT>':<EOL><INDENT>return wcs100.WebCoverageService_1_0_0.__new__(wcs100.WebCoverageService_1_0_0, clean_url, xml, cookies)<EOL><DEDENT>elif version == '<STR_LIT>':<EOL><INDENT>return wcs110.WebCoverageService_1_1_0.__new__(wcs110.WebCoverageService_1_1_0, url, xml, cookies)<EOL><DEDENT>elif version == '<STR_LIT>':<EOL><INDENT>return wcs111.WebCoverageService_1_1_1.__new__(wcs111.WebCoverageService_1_1_1, url, xml, cookies)<EOL><DEDENT>elif version == '<STR_LIT>':<EOL><INDENT>return wcs200.WebCoverageService_2_0_0.__new__(wcs200.WebCoverageService_2_0_0, url, xml, cookies)<EOL><DEDENT>elif version == '<STR_LIT>':<EOL><INDENT>return wcs201.WebCoverageService_2_0_1.__new__(wcs201.WebCoverageService_2_0_1, url, xml, cookies)<EOL><DEDENT>", "docstring": "wcs factory function, returns a version specific WebCoverageService object", "id": "f4761:m0"}
{"signature": "def items(self):", "body": "items = []<EOL>for item in self.contents:<EOL><INDENT>items.append((item, self.contents[item]))<EOL><DEDENT>return items<EOL>", "docstring": "supports dict-like items() access", "id": "f4763:c0:m3"}
{"signature": "def __getitem__(self, name):", "body": "if name in self.__getattribute__('<STR_LIT>'):<EOL><INDENT>return self.__getattribute__('<STR_LIT>')[name]<EOL><DEDENT>else:<EOL><INDENT>raise KeyError(\"<STR_LIT>\" % name)<EOL><DEDENT>", "docstring": "check contents dictionary to allow dict\n        like access to service layers", "id": "f4763:c0:m0"}
{"signature": "def read(self, service_url, timeout=<NUM_LIT:30>):", "body": "self.request = self.capabilities_url(service_url)<EOL>spliturl = self.request.split('<STR_LIT:?>')<EOL>u = openURL(spliturl[<NUM_LIT:0>], spliturl[<NUM_LIT:1>], method='<STR_LIT>',<EOL>username=self.username,<EOL>password=self.password,<EOL>timeout=timeout,<EOL>headers=self.headers)<EOL>raw_text = strip_bom(u.read())<EOL>return etree.fromstring(raw_text)<EOL>", "docstring": "Get and parse a WMS capabilities document, returning an\n        elementtree instance\n\n        service_url is the base url, to which is appended the service,\n        version, and request parameters", "id": "f4764:c0:m2"}
{"signature": "def readString(self, st):", "body": "if not isinstance(st, str) and not isinstance(st, bytes):<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % type(st))<EOL><DEDENT>raw_text = strip_bom(st)<EOL>return etree.fromstring(raw_text)<EOL>", "docstring": "Parse a WMS capabilities document, returning an elementtree instance.\n\n        string should be an XML capabilities document", "id": "f4764:c0:m3"}
{"signature": "def getmap(self, layers=None, styles=None, srs=None, bbox=None,<EOL>format=None, size=None, time=None, transparent=False,<EOL>bgcolor='<STR_LIT>',<EOL>exceptions='<STR_LIT>',<EOL>method='<STR_LIT>',<EOL>timeout=None,<EOL>**kwargs<EOL>):", "body": "try:<EOL><INDENT>base_url = next((m.get('<STR_LIT:url>') for m in self.getOperationByName('<STR_LIT>').methods if m.get('<STR_LIT:type>').lower() == method.lower()))<EOL><DEDENT>except StopIteration:<EOL><INDENT>base_url = self.url<EOL><DEDENT>request = {'<STR_LIT:version>': self.version, '<STR_LIT>': '<STR_LIT>'}<EOL>request = self.__build_getmap_request(<EOL>layers=layers,<EOL>styles=styles,<EOL>srs=srs,<EOL>bbox=bbox,<EOL>format=format,<EOL>size=size,<EOL>time=time,<EOL>transparent=transparent,<EOL>bgcolor=bgcolor,<EOL>exceptions=exceptions,<EOL>**kwargs)<EOL>data = urlencode(request)<EOL>self.request = bind_url(base_url) + data<EOL>u = openURL(base_url, data, method, username=self.username, password=self.password, timeout=timeout or self.timeout)<EOL>if u.info().get('<STR_LIT:Content-Type>', '<STR_LIT>').split('<STR_LIT:;>')[<NUM_LIT:0>] in ['<STR_LIT>']:<EOL><INDENT>se_xml = u.read()<EOL>se_tree = etree.fromstring(se_xml)<EOL>err_message = six.text_type(se_tree.find('<STR_LIT>').text).strip()<EOL>raise ServiceException(err_message)<EOL><DEDENT>return u<EOL>", "docstring": "Request and return an image from the WMS as a file-like object.\n\n        Parameters\n        ----------\n        layers : list\n            List of content layer names.\n        styles : list\n            Optional list of named styles, must be the same length as the\n            layers list.\n        srs : string\n            A spatial reference system identifier.\n        bbox : tuple\n            (left, bottom, right, top) in srs units.\n        format : string\n            Output image format such as 'image/jpeg'.\n        size : tuple\n            (width, height) in pixels.\n        transparent : bool\n            Optional. Transparent background if True.\n        bgcolor : string\n            Optional. Image background color.\n        method : string\n            Optional. HTTP DCP method name: Get or Post.\n        **kwargs : extra arguments\n            anything else e.g. vendor specific parameters\n\n        Example\n        -------\n            wms = WebMapService('http://giswebservices.massgis.state.ma.us/geoserver/wms', version='1.1.1')\n            img = wms.getmap(layers=['massgis:GISDATA.SHORELINES_ARC'],\\\n                                 styles=[''],\\\n                                 srs='EPSG:4326',\\\n                                 bbox=(-70.8, 42, -70, 42.8),\\\n                                 size=(300, 300),\\\n                                 format='image/jpeg',\\\n                                 transparent=True)\n            out = open('example.jpg', 'wb')\n            bytes_written = out.write(img.read())\n            out.close()", "id": "f4766:c1:m6"}
{"signature": "def __getitem__(self, name):", "body": "if name in self.__getattribute__('<STR_LIT>'):<EOL><INDENT>return self.__getattribute__('<STR_LIT>')[name]<EOL><DEDENT>else:<EOL><INDENT>raise KeyError(\"<STR_LIT>\" % name)<EOL><DEDENT>", "docstring": "check contents dictionary to allow dict\n        like access to service layers", "id": "f4766:c1:m0"}
{"signature": "def __init__(self, url, version='<STR_LIT>', xml=None,<EOL>username=None,<EOL>password=None,<EOL>parse_remote_metadata=False,<EOL>headers=None,<EOL>timeout=<NUM_LIT:30>):", "body": "self.url = url<EOL>self.username = username<EOL>self.password = password<EOL>self.version = version<EOL>self.timeout = timeout<EOL>self.headers = headers<EOL>self._capabilities = None<EOL>reader = WMSCapabilitiesReader(self.version, url=self.url,<EOL>un=self.username, pw=self.password,<EOL>headers=headers)<EOL>if xml:  <EOL><INDENT>self._capabilities = reader.readString(xml)<EOL><DEDENT>else:  <EOL><INDENT>self._capabilities = reader.read(self.url, timeout=self.timeout)<EOL><DEDENT>self.request = reader.request<EOL>se = self._capabilities.find('<STR_LIT>')<EOL>if se is not None:<EOL><INDENT>err_message = str(se.text).strip()<EOL>raise ServiceException(err_message)<EOL><DEDENT>self._buildMetadata(parse_remote_metadata)<EOL>", "docstring": "Initialize.", "id": "f4766:c1:m1"}
{"signature": "def items(self):", "body": "items = []<EOL>for item in self.contents:<EOL><INDENT>items.append((item, self.contents[item]))<EOL><DEDENT>return items<EOL>", "docstring": "supports dict-like items() access", "id": "f4766:c1:m3"}
{"signature": "def getOperationByName(self, name):", "body": "for item in self.operations:<EOL><INDENT>if item.name == name:<EOL><INDENT>return item<EOL><DEDENT><DEDENT>raise KeyError(\"<STR_LIT>\" % name)<EOL>", "docstring": "Return a named content item.", "id": "f4767:c2:m11"}
{"signature": "def gettile(self, base_url=None, layer=None, style=None, format=None,<EOL>tilematrixset=None, tilematrix=None, row=None, column=None,<EOL>**kwargs):", "body": "vendor_kwargs = self.vendor_kwargs or {}<EOL>vendor_kwargs.update(kwargs)<EOL>if self.restonly:<EOL><INDENT>resurl = self.buildTileResource(<EOL>layer, style, format, tilematrixset, tilematrix,<EOL>row, column, **vendor_kwargs)<EOL>u = openURL(resurl, username=self.username, password=self.password)<EOL>return u<EOL><DEDENT>data = self.buildTileRequest(layer, style, format, tilematrixset,<EOL>tilematrix, row, column, **vendor_kwargs)<EOL>if base_url is None:<EOL><INDENT>base_url = self.url<EOL>try:<EOL><INDENT>methods = self.getOperationByName('<STR_LIT>').methods<EOL>get_verbs = [x for x in methods<EOL>if x.get('<STR_LIT:type>').lower() == '<STR_LIT>']<EOL>if len(get_verbs) > <NUM_LIT:1>:<EOL><INDENT>base_url = next(<EOL>x for x in filter(<EOL>list,<EOL>([pv.get('<STR_LIT:url>')<EOL>for const in pv.get('<STR_LIT>')<EOL>if '<STR_LIT>' in [x.lower() for x in const.values]]<EOL>for pv in get_verbs if pv.get('<STR_LIT>'))))[<NUM_LIT:0>]<EOL><DEDENT>elif len(get_verbs) == <NUM_LIT:1>:<EOL><INDENT>base_url = get_verbs[<NUM_LIT:0>].get('<STR_LIT:url>')<EOL><DEDENT><DEDENT>except StopIteration:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>u = openURL(base_url, data, username=self.username,<EOL>password=self.password)<EOL>if u.info()['<STR_LIT:Content-Type>'] == '<STR_LIT>':<EOL><INDENT>se_xml = u.read()<EOL>se_tree = etree.fromstring(se_xml)<EOL>err_message = six.text_type(se_tree.find('<STR_LIT>').text)<EOL>raise ServiceException(err_message.strip(), se_xml)<EOL><DEDENT>return u<EOL>", "docstring": "Return a tile from the WMTS.\n\n        Returns the tile image as a file-like object.\n\n        Parameters\n        ----------\n        base_url : string\n            Optional URL for request submission. Defaults to the URL of\n            the GetTile operation as declared in the GetCapabilities\n            response.\n        layer : string\n            Content layer name.\n        style : string\n            Optional style name. Defaults to the first style defined for\n            the relevant layer in the GetCapabilities response.\n        format : string\n            Optional output image format,  such as 'image/jpeg'.\n            Defaults to the first format defined for the relevant layer\n            in the GetCapabilities response.\n        tilematrixset : string\n            Optional name of tile matrix set to use.\n            Defaults to the first tile matrix set defined for the\n            relevant layer in the GetCapabilities response.\n        tilematrix : string\n            Name of the tile matrix to use.\n        row : integer\n            Row index of tile to request.\n        column : integer\n            Column index of tile to request.\n        **kwargs : extra arguments\n            anything else e.g. vendor specific parameters\n\n        Example\n        -------\n            >>> url = 'http://map1c.vis.earthdata.nasa.gov/wmts-geo/wmts.cgi'\n            >>> wmts = WebMapTileService(url)\n            >>> img = wmts.gettile(layer='VIIRS_CityLights_2012',\\\n                                   tilematrixset='EPSG4326_500m',\\\n                                   tilematrix='6',\\\n                                   row=4, column=4)\n            >>> out = open('tile.jpg', 'wb')\n            >>> bytes_written = out.write(img.read())\n            >>> out.close()", "id": "f4767:c2:m8"}
{"signature": "def _buildMetadata(self, parse_remote_metadata=False):", "body": "self.updateSequence = self._capabilities.attrib.get('<STR_LIT>')<EOL>serviceident = self._capabilities.find(_SERVICE_IDENTIFICATION_TAG)<EOL>self.identification = ServiceIdentification(serviceident)<EOL>serviceprov = self._capabilities.find(_SERVICE_PROVIDER_TAG)<EOL>if serviceprov is not None:<EOL><INDENT>self.provider = ServiceProvider(serviceprov)<EOL><DEDENT>self.operations = []<EOL>serviceop = self._capabilities.find(_OPERATIONS_METADATA_TAG)<EOL>if serviceop is not None:<EOL><INDENT>for elem in serviceop[:]:<EOL><INDENT>self.operations.append(OperationsMetadata(elem))<EOL><DEDENT><DEDENT>self.contents = {}<EOL>caps = self._capabilities.find(_CONTENTS_TAG)<EOL>def gather_layers(parent_elem, parent_metadata):<EOL><INDENT>for index, elem in enumerate(parent_elem.findall(_LAYER_TAG)):<EOL><INDENT>cm = ContentMetadata(<EOL>elem, parent=parent_metadata, index=index + <NUM_LIT:1>,<EOL>parse_remote_metadata=parse_remote_metadata)<EOL>if cm.id:<EOL><INDENT>if cm.id in self.contents:<EOL><INDENT>raise KeyError('<STR_LIT>'<EOL>'<STR_LIT>' % cm.id)<EOL><DEDENT>self.contents[cm.id] = cm<EOL><DEDENT>gather_layers(elem, cm)<EOL><DEDENT><DEDENT>gather_layers(caps, None)<EOL>self.tilematrixsets = {}<EOL>for elem in caps.findall(_TILE_MATRIX_SET_TAG):<EOL><INDENT>tms = TileMatrixSet(elem)<EOL>if tms.identifier:<EOL><INDENT>if tms.identifier in self.tilematrixsets:<EOL><INDENT>raise KeyError('<STR_LIT>'<EOL>'<STR_LIT>' % tms.identifier)<EOL><DEDENT>self.tilematrixsets[tms.identifier] = tms<EOL><DEDENT><DEDENT>self.themes = {}<EOL>for elem in self._capabilities.findall(_THEMES_TAG + '<STR_LIT:/>' + _THEME_TAG):<EOL><INDENT>theme = Theme(elem)<EOL>if theme.identifier:<EOL><INDENT>if theme.identifier in self.themes:<EOL><INDENT>raise KeyError('<STR_LIT>'<EOL>% theme.identifier)<EOL><DEDENT>self.themes[theme.identifier] = theme<EOL><DEDENT><DEDENT>serviceMetadataURL = self._capabilities.find(_SERVICE_METADATA_URL_TAG)<EOL>if serviceMetadataURL is not None:<EOL><INDENT>self.serviceMetadataURL = serviceMetadataURL.attrib[_HREF_TAG]<EOL><DEDENT>else:<EOL><INDENT>self.serviceMetadataURL = None<EOL><DEDENT>", "docstring": "set up capabilities metadata objects", "id": "f4767:c2:m3"}
{"signature": "def read(self, service_url, vendor_kwargs=None):", "body": "getcaprequest = self.capabilities_url(service_url, vendor_kwargs)<EOL>spliturl = getcaprequest.split('<STR_LIT:?>')<EOL>u = openURL(spliturl[<NUM_LIT:0>], spliturl[<NUM_LIT:1>], method='<STR_LIT>',<EOL>username=self.username, password=self.password)<EOL>return etree.fromstring(u.read())<EOL>", "docstring": "Get and parse a WMTS capabilities document, returning an\n        elementtree instance\n\n        service_url is the base url, to which is appended the service,\n        version, and request parameters. Optional vendor-specific\n        parameters can also be supplied as a dict.", "id": "f4767:c9:m2"}
{"signature": "@staticmethod<EOL><INDENT>def from_elements(link_elements):<DEDENT>", "body": "<EOL>links = []<EOL>for link_element in link_elements:<EOL><INDENT>matrix_set_elements = link_element.findall(_TILE_MATRIX_SET_TAG)<EOL>if len(matrix_set_elements) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>' % link_element)<EOL><DEDENT>elif len(matrix_set_elements) > <NUM_LIT:1>:<EOL><INDENT>set_limits_elements = link_element.findall(<EOL>_TILE_MATRIX_SET_LIMITS_TAG)<EOL>if set_limits_elements:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>link_element)<EOL><DEDENT>for matrix_set_element in matrix_set_elements:<EOL><INDENT>uri = matrix_set_element.text.strip()<EOL>links.append(TileMatrixSetLink(uri))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>uri = matrix_set_elements[<NUM_LIT:0>].text.strip()<EOL>tilematrixlimits = {}<EOL>path = '<STR_LIT>' % (_TILE_MATRIX_SET_LIMITS_TAG,<EOL>_TILE_MATRIX_LIMITS_TAG)<EOL>for limits_element in link_element.findall(path):<EOL><INDENT>tml = TileMatrixLimits(limits_element)<EOL>if tml.tilematrix:<EOL><INDENT>if tml.tilematrix in tilematrixlimits:<EOL><INDENT>msg = ('<STR_LIT>'<EOL>'<STR_LIT>' % tml.tilematrix)<EOL>raise KeyError(msg)<EOL><DEDENT>tilematrixlimits[tml.tilematrix] = tml<EOL><DEDENT><DEDENT>links.append(TileMatrixSetLink(uri, tilematrixlimits))<EOL><DEDENT><DEDENT>return links<EOL>", "docstring": "Return a list of TileMatrixSetLink instances derived from the\ngiven list of <TileMatrixSetLink> XML elements.", "id": "f4767:c7:m0"}
{"signature": "def capabilities_url(self, service_url, vendor_kwargs=None):", "body": "<EOL>pieces = urlparse(service_url)<EOL>args = parse_qs(pieces.query)<EOL>if '<STR_LIT>' not in args:<EOL><INDENT>args['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>if '<STR_LIT>' not in args:<EOL><INDENT>args['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>if '<STR_LIT:version>' not in args:<EOL><INDENT>args['<STR_LIT:version>'] = self.version<EOL><DEDENT>if vendor_kwargs:<EOL><INDENT>args.update(vendor_kwargs)<EOL><DEDENT>query = urlencode(args, doseq=True)<EOL>pieces = ParseResult(pieces.scheme, pieces.netloc,<EOL>pieces.path, pieces.params,<EOL>query, pieces.fragment)<EOL>return urlunparse(pieces)<EOL>", "docstring": "Return a capabilities url", "id": "f4767:c9:m1"}
{"signature": "def setConstraintList(self, constraints, tostring=False):", "body": "ors = []<EOL>if len(constraints) == <NUM_LIT:1>:<EOL><INDENT>if isinstance(constraints[<NUM_LIT:0>], OgcExpression):<EOL><INDENT>flt = self.setConstraint(constraints[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>self._root.append(And(operations=constraints[<NUM_LIT:0>]).toXML())<EOL>flt = self._root<EOL><DEDENT>if tostring:<EOL><INDENT>return util.element_to_string(flt, xml_declaration=False)<EOL><DEDENT>else:<EOL><INDENT>return flt<EOL><DEDENT><DEDENT>for c in constraints:<EOL><INDENT>if isinstance(c, OgcExpression):<EOL><INDENT>ors.append(c)<EOL><DEDENT>elif isinstance(c, list) or isinstance(c, tuple):<EOL><INDENT>if len(c) == <NUM_LIT:1>:<EOL><INDENT>ors.append(c[<NUM_LIT:0>])<EOL><DEDENT>elif len(c) >= <NUM_LIT:2>:<EOL><INDENT>ands = []<EOL>for sub in c:<EOL><INDENT>if isinstance(sub, OgcExpression):<EOL><INDENT>ands.append(sub)<EOL><DEDENT><DEDENT>ors.append(And(operations=ands))<EOL><DEDENT><DEDENT><DEDENT>self._root.append(Or(operations=ors).toXML())<EOL>if tostring:<EOL><INDENT>return util.element_to_string(self._root, xml_declaration=False)<EOL><DEDENT>return self._root<EOL>", "docstring": "Construct and process a  GetRecords request\n\nParameters\n----------\n\n- constraints: A list of OgcExpression objects\n               The list is interpretted like so:\n\n               [a,b,c]\n               a || b || c\n\n               [[a,b,c]]\n               a && b && c\n\n               [[a,b],[c],[d],[e]] or [[a,b],c,d,e]\n               (a && b) || c || d || e\n- tostring (optional): return as string", "id": "f4768:c0:m3"}
{"signature": "def WMCElement(tag):", "body": "return etree.Element(\"<STR_LIT>\"%context_ns_uri + tag)<EOL>", "docstring": "WMC based element", "id": "f4774:m0"}
{"signature": "def __new__(self,url, version, xml, parse_remote_metadata=False, timeout=<NUM_LIT:30>,<EOL>username=None, password=None):", "body": "obj=object.__new__(self)<EOL>obj.__init__(url, version, xml, parse_remote_metadata, timeout,<EOL>username=username, password=password)<EOL>return obj<EOL>", "docstring": "overridden __new__ method\n\n        @type url: string\n        @param url: url of WFS capabilities document\n        @type xml: string\n        @param xml: elementtree object\n        @type parse_remote_metadata: boolean\n        @param parse_remote_metadata: whether to fully process MetadataURL elements\n        @param timeout: time (in seconds) after which requests should timeout\n        @param username: service authentication username\n        @param password: service authentication password\n        @return: initialized WebFeatureService_1_1_0 object", "id": "f4776:c0:m0"}
{"signature": "def __getitem__(self,name):", "body": "if name in self.__getattribute__('<STR_LIT>').keys():<EOL><INDENT>return self.__getattribute__('<STR_LIT>')[name]<EOL><DEDENT>else:<EOL><INDENT>raise KeyError(\"<STR_LIT>\" % name)<EOL><DEDENT>", "docstring": "check contents dictionary to allow dict like access to service layers", "id": "f4776:c0:m1"}
{"signature": "def _buildMetadata(self, parse_remote_metadata=False):", "body": "self.updateSequence = self._capabilities.attrib.get('<STR_LIT>')<EOL>val = self._capabilities.find(util.nspath_eval('<STR_LIT>', namespaces))<EOL>if val is not None:<EOL><INDENT>self.identification=ServiceIdentification(val,self.owscommon.namespace)<EOL><DEDENT>val = self._capabilities.find(util.nspath_eval('<STR_LIT>', namespaces))<EOL>if val is not None:<EOL><INDENT>self.provider=ServiceProvider(val,self.owscommon.namespace)<EOL><DEDENT>self.operations=[]<EOL>for elem in self._capabilities.findall(util.nspath_eval('<STR_LIT>', namespaces)):<EOL><INDENT>self.operations.append(OperationsMetadata(elem, self.owscommon.namespace))<EOL><DEDENT>self.constraints = {}<EOL>for elem in self._capabilities.findall(util.nspath_eval('<STR_LIT>', namespaces)):<EOL><INDENT>self.constraints[elem.attrib['<STR_LIT:name>']] = Constraint(elem, self.owscommon.namespace)<EOL><DEDENT>self.parameters = {}<EOL>for elem in self._capabilities.findall(util.nspath_eval('<STR_LIT>', namespaces)):<EOL><INDENT>self.parameters[elem.attrib['<STR_LIT:name>']] = Parameter(elem, self.owscommon.namespace)<EOL><DEDENT>val = self._capabilities.find(util.nspath_eval('<STR_LIT>', namespaces))<EOL>self.filters=FilterCapabilities(val)<EOL>self.contents={}<EOL>features = self._capabilities.findall(nspath_eval('<STR_LIT>', namespaces))<EOL>for feature in features:<EOL><INDENT>cm=ContentMetadata(feature, parse_remote_metadata)<EOL>self.contents[cm.id]=cm<EOL><DEDENT>self.exceptions = [f.text for fin self._capabilities.findall('<STR_LIT>')]<EOL>", "docstring": "set up capabilities metadata objects:", "id": "f4776:c0:m3"}
{"signature": "def _makeStringIO(self, strval):", "body": "if PY2:<EOL><INDENT>return StringIO(strval)<EOL><DEDENT>return StringIO(strval.decode())<EOL>", "docstring": "Helper method to make sure the StringIO being returned will work.\n\nDifferences between Python 2.7/3.x mean we have a lot of cases to handle.", "id": "f4778:c1:m6"}
{"signature": "def collections(self):", "body": "url = self._build_url('<STR_LIT>')<EOL>LOGGER.debug('<STR_LIT>'.format(url))<EOL>response = requests.get(url, headers=REQUEST_HEADERS).json()<EOL>return response['<STR_LIT>']<EOL>", "docstring": "implements Requirement 9 (/req/core/collections-op)\n\n@returns: collections object", "id": "f4779:c0:m2"}
{"signature": "def collection_item(self, collection_name, identifier):", "body": "path = '<STR_LIT>'.format(collection_name, identifier)<EOL>url = self._build_url(path)<EOL>LOGGER.debug('<STR_LIT>'.format(url))<EOL>response = requests.get(url, headers=REQUEST_HEADERS).json()<EOL>return response<EOL>", "docstring": "implements Requirement 30 (/req/core/f-op)\n\n@type collection_name: string\n@param collection_name: name of collection\n@type identifier: string\n@param identifier: feature identifier\n\n@returns: single feature result", "id": "f4779:c0:m5"}
{"signature": "def _makeStringIO(self, strval):", "body": "if PY2:<EOL><INDENT>return StringIO(strval)<EOL><DEDENT>return StringIO(strval.decode())<EOL>", "docstring": "Helper method to make sure the StringIO being returned will work.\n\nDifferences between Python 2.7/3.x mean we have a lot of cases to handle.", "id": "f4780:c0:m6"}
{"signature": "def nspath(path, ns=WFS_NAMESPACE):", "body": "components = []<EOL>for component in path.split(\"<STR_LIT:/>\"):<EOL><INDENT>if component != '<STR_LIT:*>':<EOL><INDENT>component = \"<STR_LIT>\" % (ns, component)<EOL><DEDENT>components.append(component)<EOL><DEDENT>return \"<STR_LIT:/>\".join(components)<EOL>", "docstring": "Prefix the given path with the given namespace identifier.\n\nParameters\n----------\npath : string\n    ElementTree API Compatible path expression\n\nns : string\n    The XML namespace. Defaults to WFS namespace.", "id": "f4780:m0"}
{"signature": "def readString(self, st):", "body": "if not isinstance(st, str) and not isinstance(st, bytes):<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % type(st))<EOL><DEDENT>return etree.fromstring(st)<EOL>", "docstring": "Parse a WFS capabilities document, returning an\n        instance of WFSCapabilitiesInfoset\n\n        string should be an XML capabilities document", "id": "f4781:c0:m3"}
{"signature": "def __init__(self, version='<STR_LIT:1.0>', username=None, password=None):", "body": "self.version = version<EOL>self.username = username<EOL>self.password = password<EOL>self._infoset = None<EOL>", "docstring": "Initialize", "id": "f4781:c0:m0"}
{"signature": "def getSRS(self, srsname, typename):", "body": "if not isinstance(srsname, Crs):<EOL><INDENT>srs = Crs(srsname)<EOL><DEDENT>else:<EOL><INDENT>srs = srsname<EOL><DEDENT>try:<EOL><INDENT>index = self.contents[typename].crsOptions.index(srs)<EOL>return self.contents[typename].crsOptions[index]<EOL><DEDENT>except ValueError:<EOL><INDENT>options = \"<STR_LIT:U+002CU+0020>\".join(map(lambda crs: crs.id,<EOL>self.contents[typename].crsOptions))<EOL>log.warning(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\", srs.getcode(), typename, options)<EOL>return None<EOL><DEDENT>", "docstring": "Returns None or Crs object for given name\n\n        @param typename:  feature name \n        @type typename: String", "id": "f4782:c0:m1"}
{"signature": "def getGETGetFeatureRequest(self, typename=None, filter=None, bbox=None, featureid=None,<EOL>featureversion=None, propertyname=None, maxfeatures=None,storedQueryID=None, storedQueryParams=None,<EOL>outputFormat=None, method='<STR_LIT>', startindex=None, sortby=None):", "body": "storedQueryParams = storedQueryParams or {}<EOL>base_url = next((m.get('<STR_LIT:url>') for m in self.getOperationByName('<STR_LIT>').methods if m.get('<STR_LIT:type>').lower() == method.lower()))<EOL>base_url = base_url if base_url.endswith(\"<STR_LIT:?>\") else base_url+\"<STR_LIT:?>\"<EOL>request = {'<STR_LIT>': '<STR_LIT>', '<STR_LIT:version>': self.version, '<STR_LIT>': '<STR_LIT>'}<EOL>if featureid:<EOL><INDENT>request['<STR_LIT>'] = '<STR_LIT:U+002C>'.join(featureid)<EOL><DEDENT>elif bbox:<EOL><INDENT>request['<STR_LIT>'] = self.getBBOXKVP(bbox,typename)<EOL><DEDENT>elif filter:<EOL><INDENT>request['<STR_LIT>'] = str(filter)<EOL><DEDENT>if typename:<EOL><INDENT>typename = [typename] if type(typename) == type(\"<STR_LIT>\") else typename<EOL>if int(self.version.split('<STR_LIT:.>')[<NUM_LIT:0>]) >= <NUM_LIT:2>:<EOL><INDENT>request['<STR_LIT>'] = '<STR_LIT:U+002C>'.join(typename)<EOL><DEDENT>else:<EOL><INDENT>request['<STR_LIT>'] = '<STR_LIT:U+002C>'.join(typename)<EOL><DEDENT><DEDENT>if propertyname: <EOL><INDENT>request['<STR_LIT>'] = '<STR_LIT:U+002C>'.join(propertyname)<EOL><DEDENT>if sortby:<EOL><INDENT>request['<STR_LIT>'] = '<STR_LIT:U+002C>'.join(sortby)<EOL><DEDENT>if featureversion: <EOL><INDENT>request['<STR_LIT>'] = str(featureversion)<EOL><DEDENT>if maxfeatures: <EOL><INDENT>if int(self.version.split('<STR_LIT:.>')[<NUM_LIT:0>]) >= <NUM_LIT:2>:<EOL><INDENT>request['<STR_LIT:count>'] = str(maxfeatures)<EOL><DEDENT>else:<EOL><INDENT>request['<STR_LIT>'] = str(maxfeatures)<EOL><DEDENT><DEDENT>if startindex:<EOL><INDENT>request['<STR_LIT>'] = str(startindex)<EOL><DEDENT>if storedQueryID: <EOL><INDENT>request['<STR_LIT>']=str(storedQueryID)<EOL>for param in storedQueryParams:<EOL><INDENT>request[param]=storedQueryParams[param]<EOL><DEDENT><DEDENT>if outputFormat is not None:<EOL><INDENT>request[\"<STR_LIT>\"] = outputFormat<EOL><DEDENT>data = urlencode(request, doseq=True)<EOL>return base_url+data<EOL>", "docstring": "Formulate proper GetFeature request using KVP encoding\n        ----------\n        typename : list\n            List of typenames (string)\n        filter : string \n            XML-encoded OGC filter expression.\n        bbox : tuple\n            (left, bottom, right, top) in the feature type's coordinates == (minx, miny, maxx, maxy)\n        featureid : list\n            List of unique feature ids (string)\n        featureversion : string\n            Default is most recent feature version.\n        propertyname : list\n            List of feature property names. '*' matches all.\n        maxfeatures : int\n            Maximum number of features to be returned.\n        method : string\n            Qualified name of the HTTP DCP method to use.\n        outputFormat: string (optional)\n            Requested response format of the request.\n        startindex: int (optional)\n            Start position to return feature set (paging in combination with maxfeatures)\n        sortby: list (optional)\n            List of property names whose values should be used to order\n            (upon presentation) the set of feature instances that\n            satify the query.\n\n        There are 3 different modes of use\n\n        1) typename and bbox (simple spatial query)\n        2) typename and filter (==query) (more expressive)\n        3) featureid (direct access to known features)", "id": "f4782:c0:m2"}
{"signature": "def __init__(self, u):", "body": "self.u=u<EOL>self._getType()<EOL>", "docstring": "initiate with a urllib  url object.", "id": "f4785:c0:m0"}
{"signature": "def descCov_url(self, service_url):", "body": "qs = []<EOL>if service_url.find('<STR_LIT:?>') != -<NUM_LIT:1>:<EOL><INDENT>qs = cgi.parse_qsl(service_url.split('<STR_LIT:?>')[<NUM_LIT:1>])<EOL><DEDENT>params = [x[<NUM_LIT:0>] for x in qs]<EOL>if '<STR_LIT>' not in params:<EOL><INDENT>qs.append(('<STR_LIT>', '<STR_LIT>'))<EOL><DEDENT>if '<STR_LIT>' not in params:<EOL><INDENT>qs.append(('<STR_LIT>', '<STR_LIT>'))<EOL><DEDENT>if '<STR_LIT:version>' not in params:<EOL><INDENT>qs.append(('<STR_LIT:version>', self.version))<EOL><DEDENT>if self.version == '<STR_LIT>':<EOL><INDENT>if '<STR_LIT>' not in params:<EOL><INDENT>qs.append(('<STR_LIT>', self.identifier))<EOL><DEDENT><DEDENT>elif self.version == '<STR_LIT>':<EOL><INDENT>if '<STR_LIT>' not in params:<EOL><INDENT>qs.append(('<STR_LIT>', self.identifier))<EOL><DEDENT><DEDENT>elif self.version == '<STR_LIT>':<EOL><INDENT>if '<STR_LIT>' not in params:<EOL><INDENT>qs.append(('<STR_LIT>', self.identifier))<EOL><DEDENT><DEDENT>elif self.version == '<STR_LIT>' or self.version == '<STR_LIT>':<EOL><INDENT>if '<STR_LIT>' not in params:<EOL><INDENT>qs.append(('<STR_LIT>', self.identifier))<EOL><DEDENT>if '<STR_LIT>' not in params:<EOL><INDENT>qs.append(('<STR_LIT>', self.identifier))<EOL>qs.append(('<STR_LIT>', '<STR_LIT>'))<EOL><DEDENT><DEDENT>urlqs = urlencode(tuple(qs))<EOL>return service_url.split('<STR_LIT:?>')[<NUM_LIT:0>] + '<STR_LIT:?>' + urlqs<EOL>", "docstring": "Return a describe coverage url\n        @type service_url: string\n        @param service_url: base url of WCS service\n        @rtype: string\n        @return: getCapabilities URL", "id": "f4787:c3:m1"}
{"signature": "def read(self, service_url, timeout=<NUM_LIT:30>):", "body": "request = self.descCov_url(service_url)<EOL>u = openURL(request, cookies=self.cookies, timeout=timeout)<EOL>return etree.fromstring(u.read())<EOL>", "docstring": "Get and parse a Describe Coverage document, returning an\n        elementtree tree\n\n        @type service_url: string\n        @param service_url: The base url, to which is appended the service,\n        version, and request parameters\n        @rtype: elementtree tree\n        @return: An elementtree tree representation of the capabilities document", "id": "f4787:c3:m2"}
{"signature": "def __new__(self,url, xml, cookies):", "body": "obj=object.__new__(self)<EOL>obj.__init__(url, xml, cookies)<EOL>self.cookies=cookies<EOL>self._describeCoverage = {} <EOL>return obj<EOL>", "docstring": "overridden __new__ method \n\n        @type url: string\n        @param url: url of WCS capabilities document\n        @type xml: string\n        @param xml: elementtree object\n        @return: inititalised WCSBase object", "id": "f4787:c1:m0"}
{"signature": "def __init__(self, version=None, cookies = None):", "body": "self.version = version<EOL>self._infoset = None<EOL>self.cookies = cookies<EOL>", "docstring": "Initialize\n        @type version: string\n        @param version: WCS Version parameter e.g '1.0.0'", "id": "f4787:c2:m0"}
{"signature": "def items(self):", "body": "items=[]<EOL>for item in self.contents:<EOL><INDENT>items.append((item,self.contents[item]))<EOL><DEDENT>return items<EOL>", "docstring": "supports dict-like items() access", "id": "f4788:c1:m2"}
{"signature": "def _checkChildAndParent(self, path):", "body": "try:<EOL><INDENT>value = self._elem.find(path).text<EOL><DEDENT>except:<EOL><INDENT>try:<EOL><INDENT>value = self._parent.find(path).text<EOL><DEDENT>except:<EOL><INDENT>value = None<EOL><DEDENT><DEDENT>return value<EOL>", "docstring": "checks child coverage  summary, and if item not found checks higher level coverage summary", "id": "f4788:c6:m4"}
{"signature": "def is_number(self,s):", "body": "try:<EOL><INDENT>float(s)<EOL>return True<EOL><DEDENT>except ValueError:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "simple helper to test if value is number as requests with numbers dont\n        need quote marks", "id": "f4789:c0:m5"}
{"signature": "def __init__(self, elem, service):", "body": "<EOL>self._elem=elem<EOL>self._service=service<EOL>self.id=elem.find(nsWCS2('<STR_LIT>')).text<EOL>self.title = testXMLValue(elem.find(ns('<STR_LIT:label>')))<EOL>self.abstract= testXMLValue(elem.find(ns('<STR_LIT:description>')))<EOL>self.keywords = [f.text for f in elem.findall(ns('<STR_LIT>')+'<STR_LIT:/>'+ns('<STR_LIT>'))]<EOL>self.boundingBox=None <EOL>self.boundingBoxWGS84 = None<EOL>b = elem.find(ns('<STR_LIT>'))<EOL>if b is not None:<EOL><INDENT>gmlpositions=b.findall('<STR_LIT>')<EOL>lc=gmlpositions[<NUM_LIT:0>].text<EOL>uc=gmlpositions[<NUM_LIT:1>].text<EOL>self.boundingBoxWGS84 = (<EOL>float(lc.split()[<NUM_LIT:0>]),float(lc.split()[<NUM_LIT:1>]),<EOL>float(uc.split()[<NUM_LIT:0>]), float(uc.split()[<NUM_LIT:1>]),<EOL>)<EOL><DEDENT>self.styles=None<EOL>self.crsOptions=None<EOL>self.defaulttimeposition=None<EOL>", "docstring": "Initialize. service is required so that describeCoverage requests may be made", "id": "f4789:c1:m0"}
{"signature": "def items(self):", "body": "items=[]<EOL>for item in self.contents:<EOL><INDENT>items.append((item,self.contents[item]))<EOL><DEDENT>return items<EOL>", "docstring": "supports dict-like items() access", "id": "f4789:c0:m2"}
{"signature": "def getCoverage(self, identifier=None, bbox=None, time=None, format = None,  subsets=None,crs=None, width=None, height=None, resx=None, resy=None, resz=None,parameter=None,method='<STR_LIT>',**kwargs):", "body": "if log.isEnabledFor(logging.DEBUG):<EOL><INDENT>log.debug('<STR_LIT>'%(identifier, bbox, time, format, crs, width, height, resx, resy, resz, parameter, method, str(kwargs)))<EOL><DEDENT>try:<EOL><INDENT>base_url = next((m.get('<STR_LIT:url>') for m in self.getOperationByName('<STR_LIT>').methods if m.get('<STR_LIT:type>').lower() == method.lower()))<EOL><DEDENT>except StopIteration:<EOL><INDENT>base_url = self.url<EOL><DEDENT>if log.isEnabledFor(logging.DEBUG):<EOL><INDENT>log.debug('<STR_LIT>'%base_url)<EOL><DEDENT>request = {'<STR_LIT:version>': self.version, '<STR_LIT>': '<STR_LIT>', '<STR_LIT>':'<STR_LIT>'}<EOL>assert len(identifier) > <NUM_LIT:0><EOL>request['<STR_LIT>']=identifier[<NUM_LIT:0>]<EOL>if crs:<EOL><INDENT>request['<STR_LIT>']=crs<EOL><DEDENT>request['<STR_LIT>']=format<EOL>if width:<EOL><INDENT>request['<STR_LIT:width>']=width<EOL><DEDENT>if height:<EOL><INDENT>request['<STR_LIT>']=height<EOL><DEDENT>if kwargs:<EOL><INDENT>for kw in kwargs:<EOL><INDENT>request[kw]=kwargs[kw]<EOL><DEDENT><DEDENT>data = urlencode(request)<EOL>if subsets:<EOL><INDENT>for subset in subsets:<EOL><INDENT>if len(subset) > <NUM_LIT:2>:<EOL><INDENT>if not self.is_number(subset[<NUM_LIT:1>]):<EOL><INDENT>data = data + \"<STR_LIT:&>\"+ urlencode({\"<STR_LIT>\":subset[<NUM_LIT:0>]+'<STR_LIT>'+self.__makeString(subset[<NUM_LIT:1>])+'<STR_LIT>'+self.__makeString(subset[<NUM_LIT:2>])+'<STR_LIT>'})<EOL><DEDENT>else:<EOL><INDENT>data = data + \"<STR_LIT:&>\"+ urlencode({\"<STR_LIT>\":subset[<NUM_LIT:0>]+'<STR_LIT:(>'+self.__makeString(subset[<NUM_LIT:1>])+'<STR_LIT:U+002C>'+self.__makeString(subset[<NUM_LIT:2>])+'<STR_LIT:)>'})<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if not self.is_number(subset[<NUM_LIT:1>]):<EOL><INDENT>data = data + \"<STR_LIT:&>\"+ urlencode({\"<STR_LIT>\":subset[<NUM_LIT:0>]+'<STR_LIT>'+self.__makeString(subset[<NUM_LIT:1>])+'<STR_LIT>'})<EOL><DEDENT>else:<EOL><INDENT>data = data + \"<STR_LIT:&>\"+ urlencode({\"<STR_LIT>\":subset[<NUM_LIT:0>]+'<STR_LIT:(>'+self.__makeString(subset[<NUM_LIT:1>])+'<STR_LIT:)>'})<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if log.isEnabledFor(logging.DEBUG):<EOL><INDENT>log.debug('<STR_LIT>'%data)<EOL><DEDENT>u=openURL(base_url, data, method, self.cookies)<EOL>return u<EOL>", "docstring": "Request and return a coverage from the WCS as a file-like object\n        note: additional **kwargs helps with multi-version implementation\n        core keyword arguments should be supported cross version\n        example:\n        cvg=wcs.getCoverage(identifier=['TuMYrRQ4'], timeSequence=['2792-06-01T00:00:00.0'], bbox=(-112,36,-106,41),format='cf-netcdf')\n\n        is equivalent to:\n        http://myhost/mywcs?SERVICE=WCS&REQUEST=GetCoverage&IDENTIFIER=TuMYrRQ4&VERSION=1.1.0&BOUNDINGBOX=-180,-90,180,90&TIME=2792-06-01T00:00:00.0&FORMAT=cf-netcdf\n\n        example 2.0.1 URL\n        http://earthserver.pml.ac.uk/rasdaman/ows?&SERVICE=WCS&VERSION=2.0.1&REQUEST=GetCoverage\n        &COVERAGEID=V2_monthly_CCI_chlor_a_insitu_test&SUBSET=Lat(40,50)&SUBSET=Long(-10,0)&SUBSET=ansi(144883,145000)&FORMAT=application/netcdf\n\n        cvg=wcs.getCoverage(identifier=['myID'], format='application/netcdf', subsets=[('axisName',min,max),('axisName',min,max),('axisName',min,max)])", "id": "f4789:c0:m4"}
{"signature": "def getCoverage(self, identifier=None, bbox=None, time=None, format = None,  crs=None, width=None, height=None, resx=None, resy=None, resz=None,parameter=None,method='<STR_LIT>',**kwargs):", "body": "if log.isEnabledFor(logging.DEBUG):<EOL><INDENT>log.debug('<STR_LIT>'%(identifier, bbox, time, format, crs, width, height, resx, resy, resz, parameter, method, str(kwargs)))<EOL><DEDENT>try:<EOL><INDENT>base_url = next((m.get('<STR_LIT:url>') for m in self.getOperationByName('<STR_LIT>').methods if m.get('<STR_LIT:type>').lower() == method.lower()))<EOL><DEDENT>except StopIteration:<EOL><INDENT>base_url = self.url<EOL><DEDENT>if log.isEnabledFor(logging.DEBUG):<EOL><INDENT>log.debug('<STR_LIT>'%base_url)<EOL><DEDENT>request = {'<STR_LIT:version>': self.version, '<STR_LIT>': '<STR_LIT>', '<STR_LIT>':'<STR_LIT>'}<EOL>assert len(identifier) > <NUM_LIT:0><EOL>request['<STR_LIT>']=identifier<EOL>if bbox:<EOL><INDENT>request['<STR_LIT>']='<STR_LIT:U+002C>'.join([self.__makeString(x) for x in bbox])<EOL><DEDENT>else:<EOL><INDENT>request['<STR_LIT>']=None<EOL><DEDENT>if time:<EOL><INDENT>request['<STR_LIT:time>']='<STR_LIT:U+002C>'.join(time)<EOL><DEDENT>if crs:<EOL><INDENT>request['<STR_LIT>']=crs<EOL><DEDENT>request['<STR_LIT>']=format<EOL>if width:<EOL><INDENT>request['<STR_LIT:width>']=width<EOL><DEDENT>if height:<EOL><INDENT>request['<STR_LIT>']=height<EOL><DEDENT>if resx:<EOL><INDENT>request['<STR_LIT>']=resx<EOL><DEDENT>if resy:<EOL><INDENT>request['<STR_LIT>']=resy<EOL><DEDENT>if resz:<EOL><INDENT>request['<STR_LIT>']=resz<EOL><DEDENT>if kwargs:<EOL><INDENT>for kw in kwargs:<EOL><INDENT>request[kw]=kwargs[kw]<EOL><DEDENT><DEDENT>data = urlencode(request)<EOL>if log.isEnabledFor(logging.DEBUG):<EOL><INDENT>log.debug('<STR_LIT>'%data)<EOL><DEDENT>u=openURL(base_url, data, method, self.cookies)<EOL>return u<EOL>", "docstring": "Request and return a coverage from the WCS as a file-like object\n        note: additional **kwargs helps with multi-version implementation\n        core keyword arguments should be supported cross version\n        example:\n        cvg=wcs.getCoverage(identifier=['TuMYrRQ4'], timeSequence=['2792-06-01T00:00:00.0'], bbox=(-112,36,-106,41),format='cf-netcdf')\n\n        is equivalent to:\n        http://myhost/mywcs?SERVICE=WCS&REQUEST=GetCoverage&IDENTIFIER=TuMYrRQ4&VERSION=1.1.0&BOUNDINGBOX=-180,-90,180,90&TIME=2792-06-01T00:00:00.0&FORMAT=cf-netcdf", "id": "f4790:c0:m4"}
{"signature": "def __init__(self, elem, service):", "body": "<EOL>self._elem=elem<EOL>self._service=service<EOL>self.id=elem.find(ns('<STR_LIT:name>')).text<EOL>self.title = testXMLValue(elem.find(ns('<STR_LIT:label>')))<EOL>self.abstract= testXMLValue(elem.find(ns('<STR_LIT:description>')))<EOL>self.keywords = [f.text for f in elem.findall(ns('<STR_LIT>')+'<STR_LIT:/>'+ns('<STR_LIT>'))]        <EOL>self.boundingBox=None <EOL>self.boundingBoxWGS84 = None        <EOL>b = elem.find(ns('<STR_LIT>')) <EOL>if b is not None:<EOL><INDENT>gmlpositions=b.findall('<STR_LIT>')<EOL>lc=gmlpositions[<NUM_LIT:0>].text<EOL>uc=gmlpositions[<NUM_LIT:1>].text<EOL>self.boundingBoxWGS84 = (<EOL>float(lc.split()[<NUM_LIT:0>]),float(lc.split()[<NUM_LIT:1>]),<EOL>float(uc.split()[<NUM_LIT:0>]), float(uc.split()[<NUM_LIT:1>]),<EOL>)<EOL><DEDENT>self.styles=None<EOL>self.crsOptions=None<EOL>self.defaulttimeposition=None<EOL>", "docstring": "Initialize. service is required so that describeCoverage requests may be made", "id": "f4790:c5:m0"}
{"signature": "def __getitem__(self,name):", "body": "if name in self.__getattribute__('<STR_LIT>').keys():<EOL><INDENT>return self.__getattribute__('<STR_LIT>')[name]<EOL><DEDENT>else:<EOL><INDENT>raise KeyError(\"<STR_LIT>\" % name)<EOL><DEDENT>", "docstring": "check contents dictionary to allow dict like access to service layers", "id": "f4790:c0:m0"}
{"signature": "def __init__(self, elem):", "body": "self.name = elem.tag.split('<STR_LIT:}>')[<NUM_LIT:1>]          <EOL>self.methods = []<EOL>for resource in elem.findall(ns('<STR_LIT>')+ns('<STR_LIT>')+ns('<STR_LIT>')+ns('<STR_LIT>')):<EOL><INDENT>url = resource.attrib['<STR_LIT>']<EOL>self.methods.append({'<STR_LIT:type>': '<STR_LIT>', '<STR_LIT:url>': url})<EOL><DEDENT>for resource in elem.findall(ns('<STR_LIT>')+ns('<STR_LIT>')+ns('<STR_LIT>')+ns('<STR_LIT>')):<EOL><INDENT>url = resource.attrib['<STR_LIT>']<EOL>self.methods.append({'<STR_LIT:type>': '<STR_LIT>', '<STR_LIT:url>': url})<EOL><DEDENT>", "docstring": ".", "id": "f4790:c1:m0"}
{"signature": "def read_string(self, st):", "body": "if not isinstance(st, bytes):<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % type(st))<EOL><DEDENT>return etree.fromstring(st)<EOL>", "docstring": "Parse a SOS capabilities document, returning an elementtree instance\n\nst should be an XML capabilities document", "id": "f4791:c2:m3"}
{"signature": "def capabilities_url(self, service_url):", "body": "qs = []<EOL>if service_url.find('<STR_LIT:?>') != -<NUM_LIT:1>:<EOL><INDENT>qs = cgi.parse_qsl(service_url.split('<STR_LIT:?>')[<NUM_LIT:1>])<EOL><DEDENT>params = [x[<NUM_LIT:0>] for x in qs]<EOL>if '<STR_LIT>' not in params:<EOL><INDENT>qs.append(('<STR_LIT>', '<STR_LIT>'))<EOL><DEDENT>if '<STR_LIT>' not in params:<EOL><INDENT>qs.append(('<STR_LIT>', '<STR_LIT>'))<EOL><DEDENT>if '<STR_LIT>' not in params:<EOL><INDENT>qs.append(('<STR_LIT>', self.version))<EOL><DEDENT>urlqs = urlencode(tuple(qs))<EOL>return service_url.split('<STR_LIT:?>')[<NUM_LIT:0>] + '<STR_LIT:?>' + urlqs<EOL>", "docstring": "Return a capabilities url", "id": "f4792:c2:m1"}
{"signature": "def _parse_metadata(self, element):", "body": "pass<EOL>", "docstring": "Parse metadata elements relating to timeseries:\n            TS: baseTime, spacing, commentBlock, parameter\n            MTS: startAnchor, endAnchor, cumulative, accAnchor/Length, maxGap", "id": "f4794:c2:m3"}
{"signature": "def _parse_result(self):", "body": "if self.result is not None:<EOL><INDENT>result = self.result.find(nspv(<EOL>\"<STR_LIT>\"))<EOL>self.result = MeasurementTimeseries(result)<EOL><DEDENT>", "docstring": "Parse the result element of the observation type", "id": "f4794:c0:m1"}
{"signature": "def __init__(self, element):", "body": "self.quality = testXMLAttribute(element.find(nspv(<EOL>\"<STR_LIT>\")), nspv(\"<STR_LIT>\"))<EOL>self.nilReason = testXMLAttribute(element.find(nspv(<EOL>\"<STR_LIT>\")), nspv(\"<STR_LIT>\"))<EOL>self.comment = testXMLValue(element.find(nspv(<EOL>\"<STR_LIT>\")))<EOL>self.qualifier = testXMLAttribute(element.find(nspv(<EOL>\"<STR_LIT>\")), nspv(\"<STR_LIT>\"))<EOL>self.processing = testXMLValue(element.find(nspv(<EOL>\"<STR_LIT>\")), nspv(\"<STR_LIT>\"))<EOL>self.source = testXMLValue(element.find(nspv(<EOL>\"<STR_LIT>\")), nspv(\"<STR_LIT>\"))<EOL>", "docstring": "Base time-value pair metadata. Still to do:\n            - relatedObservation", "id": "f4794:c4:m0"}
{"signature": "def complex_input_with_content():", "body": "print(\"<STR_LIT>\")<EOL>wps = WebProcessingService('<STR_LIT>', verbose=verbose)<EOL>processid = '<STR_LIT>'<EOL>textdoc = ComplexDataInput(\"<STR_LIT>\")   <EOL>inputs = [(\"<STR_LIT:text>\", textdoc)]<EOL>outputs = [(\"<STR_LIT>\",True,'<STR_LIT>')]<EOL>execution = wps.execute(processid, inputs, output=outputs)<EOL>monitorExecution(execution)<EOL>print('<STR_LIT>', execution.percentCompleted)<EOL>print('<STR_LIT>', execution.statusMessage)<EOL>for output in execution.processOutputs:<EOL><INDENT>print('<STR_LIT>' % (output.identifier, output.dataType, output.data, output.reference))<EOL><DEDENT>", "docstring": "use ComplexDataInput with a direct content", "id": "f4801:m2"}
{"signature": "def reload(self):", "body": "self.settings = self.read()<EOL>", "docstring": "Re-open and read settings from file.", "id": "f4828:c0:m9"}
{"signature": "def unset_value(self, key):", "body": "if key.endswith(\"<STR_LIT:.>\"):<EOL><INDENT>key = key[:-<NUM_LIT:1>]<EOL><DEDENT>path = key.split(\"<STR_LIT:.>\")<EOL>curr = self.settings<EOL>for p in path[:-<NUM_LIT:1>]:<EOL><INDENT>if p not in curr:<EOL><INDENT>raise ConfigurationError(\"<STR_LIT>\".format(key, p))<EOL><DEDENT>curr = curr[p]<EOL><DEDENT>if not isinstance(curr, dict):<EOL><INDENT>raise ConfigurationError(\"<STR_LIT>\".format(path[-<NUM_LIT:1>], key))<EOL><DEDENT>if path[-<NUM_LIT:1>] not in curr:<EOL><INDENT>raise ConfigurationError(\"<STR_LIT>\".format(key, path[-<NUM_LIT:1>]))<EOL><DEDENT>del curr[path[-<NUM_LIT:1>]]<EOL>", "docstring": "Remove a value at the given key -- and any nested values --\nfrom the configuration.\n*Note*: In order to write changes to the file, ensure that\n:meth:`~giraffez.config.Config.write` is called prior to exit.\n\n:param str key: A path to the value destination, with nested levels joined by '.'\n:raises `giraffez.errors.ConfigurationError`: if the key specifies an invalid path, or does not exist", "id": "f4828:c0:m12"}
{"signature": "def create_key_file(path):", "body": "iv = \"<STR_LIT>\".format(os.urandom(<NUM_LIT:32>), time.time())<EOL>new_key = generate_key(ensure_bytes(iv))<EOL>with open(path, \"<STR_LIT:wb>\") as f:<EOL><INDENT>f.write(base64.b64encode(new_key))<EOL><DEDENT>os.chmod(path, <NUM_LIT>)<EOL>", "docstring": "Creates a new encryption key in the path provided and sets the file\npermissions.  Setting the file permissions currently does not work\non Windows platforms because of the differences in how file\npermissions are read and modified.", "id": "f4834:m0"}
{"signature": "def to_archive(self, writer):", "body": "if '<STR_LIT:b>' not in writer.mode:<EOL><INDENT>raise GiraffeError(\"<STR_LIT>\")<EOL><DEDENT>writer.write(GIRAFFE_MAGIC)<EOL>writer.write(self.columns.serialize())<EOL>i = <NUM_LIT:0><EOL>for n, chunk in enumerate(self._fetchall(ROW_ENCODING_RAW), <NUM_LIT:1>):<EOL><INDENT>writer.write(chunk)<EOL>yield TeradataEncoder.count(chunk)<EOL><DEDENT>", "docstring": "Writes export archive files in the Giraffez archive format.\nThis takes a `giraffez.io.Writer` and writes archive chunks to\nfile until all rows for a given statement have been exhausted.\n\n.. code-block:: python\n\n    with giraffez.BulkExport(\"database.table_name\") as export:\n        with giraffez.Writer(\"database.table_name.tar.gz\", 'wb', use_gzip=True) as out:\n            for n in export.to_archive(out):\n                print(\"Rows: {}\".format(n))\n\n:param `giraffez.io.Writer` writer: A writer handling the archive output\n\n:rtype: iterator (yields ``int``)", "id": "f4837:c0:m4"}
{"signature": "def to_dict(self):", "body": "return self._fetchall(ROW_ENCODING_DICT)<EOL>", "docstring": "Sets the current encoder output to Python `dict` and returns\na row iterator.\n\n:rtype: iterator (yields ``dict``)", "id": "f4837:c0:m5"}
{"signature": "def do_horse(self, line):", "body": "log.write(ascii_giraffe)<EOL>", "docstring": "It totally prints a horse.", "id": "f4839:c1:m6"}
{"signature": "@classmethod<EOL><INDENT>def deserialize(cls, data):<DEDENT>", "body": "column_list = cls()<EOL>while data:<EOL><INDENT>tup, data = data[:<NUM_LIT:10>], data[<NUM_LIT:10>:]<EOL>column_type, length, prec, scale, title_len = struct.unpack(\"<STR_LIT>\", tup)<EOL>title, data = data[:title_len], data[title_len:]<EOL>try:<EOL><INDENT>column_list.append((title, column_type, length, prec, scale))<EOL><DEDENT>except GiraffeTypeError as error:<EOL><INDENT>raise GiraffeEncodeError(error)<EOL><DEDENT><DEDENT>return column_list<EOL>", "docstring": "Deserializes giraffez Archive header. See\n:meth:`~giraffez.types.Columns.serialize` for more information.\n\n:param str data: data in giraffez Archive format, to be deserialized\n:return: :class:`~giraffez.types.Columns` object decoded from data", "id": "f4840:c1:m15"}
{"signature": "def set_filter(self, names=None):", "body": "_names = []<EOL>if names:<EOL><INDENT>for name in names:<EOL><INDENT>_safe_name = safe_name(name)<EOL>if _safe_name not in self._column_map:<EOL><INDENT>raise GiraffeTypeError(\"<STR_LIT>\".format(name))<EOL><DEDENT>if _safe_name in _names:<EOL><INDENT>continue<EOL><DEDENT>_names.append(_safe_name)<EOL><DEDENT><DEDENT>self._filtered_columns = _names<EOL>", "docstring": "Set the names of columns to be used when iterating through the list,\nretrieving names, etc.\n\n:param list names: A list of names to be used, or :code:`None` for all", "id": "f4840:c1:m6"}
{"signature": "def readall(self):", "body": "n = <NUM_LIT:0><EOL>for row in self:<EOL><INDENT>n += <NUM_LIT:1><EOL><DEDENT>return n<EOL>", "docstring": "Exhausts the current connection by iterating over all rows and\nreturning the total.\n\n.. code-block:: python\n\n    with giraffez.Cmd() as cmd:\n        results = cmd.execute(\"select * from dbc.dbcinfo\")\n        print(results.readall())", "id": "f4845:c0:m4"}
{"signature": "def register_graceful_shutdown_signal():", "body": "from ._teradata import register_graceful_shutdown_signal as _register<EOL>_register()<EOL>", "docstring": "Registers graceful shutdown handler using C signals. The first\nSIGINT will attempt to close the Teradata connections before\nexiting, and the second will shutdown whether the connections\nhave been closed or not.", "id": "f4846:m8"}
{"signature": "def checkpoint(self):", "body": "return self.mload.checkpoint()<EOL>", "docstring": "Execute a checkpoint while loading rows. Called automatically\nwhen loading from a file. Updates the exit code of the driver to\nreflect errors.", "id": "f4848:c0:m1"}
{"signature": "@property<EOL><INDENT>def columns(self):<DEDENT>", "body": "return self._columns<EOL>", "docstring": "The list of columns in use.\n\n:getter: Return the list of columns in use.\n:setter: Set the columns to be loaded into, as well as their order. If\n    loading from a file, these will be determined from the file header.\n    Not necessary if you are loading into all columns, in the original\n    order. The value must be a :code:`list` of names in the order that\n    the fields of data will be presented in each row.\n\n    Raises :class:`~giraffez.errors.GiraffeError` if :code:`field_names`\n    is not a :code:`list`.\n\n    Raises :class:`~giraffez.errors.GiraffeError` if the target table\n    has not been set.\n:type: :class:`~giraffez.types.Columns`", "id": "f4848:c0:m3"}
{"signature": "def put(self, items, panic=True):", "body": "if not self.initiated:<EOL><INDENT>self._initiate()<EOL><DEDENT>try:<EOL><INDENT>row_status = self.mload.put_row(self.preprocessor(items))<EOL>self.applied_count += <NUM_LIT:1><EOL><DEDENT>except (TeradataPTError, EncoderError) as error:<EOL><INDENT>self.error_count += <NUM_LIT:1><EOL>if panic:<EOL><INDENT>raise error<EOL><DEDENT>log.info(\"<STR_LIT>\", error)<EOL><DEDENT>", "docstring": "Load a single row into the target table.\n\n:param list items: A list of values in the row corresponding to the\n    fields specified by :code:`self.columns`\n:param bool panic: If :code:`True`, when an error is encountered it will be\n    raised. Otherwise, the error will be logged and :code:`self.error_count`\n    is incremented.\n:raises `giraffez.errors.GiraffeEncodeError`: if :code:`panic` is :code:`True` and there\n    are format errors in the row values.\n:raises `giraffez.errors.GiraffeError`: if table name is not set.\n:raises `giraffez.TeradataPTError`: if there is a problem\n    connecting to Teradata.", "id": "f4848:c0:m7"}
{"signature": "def find_teradata_home():", "body": "if platform.system() == '<STR_LIT>':<EOL><INDENT>if is_64bit():<EOL><INDENT>return latest_teradata_version(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>return latest_teradata_version(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>elif platform.system() == '<STR_LIT>':<EOL><INDENT>return latest_teradata_version(\"<STR_LIT>\")<EOL><DEDENT>elif platform.system() == '<STR_LIT>':<EOL><INDENT>return latest_teradata_version(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>return latest_teradata_version(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Attempts to find the Teradata install directory with the defaults\nfor a given platform.  Should always return `None` when the defaults\nare not present and the TERADATA_HOME environment variable wasn't\nexplicitly set to the correct install location.", "id": "f4851:m2"}
{"signature": "def fix_compile(remove_flags):", "body": "import distutils.ccompiler<EOL>def _fix_compile(self, sources, output_dir=None, macros=None, include_dirs=None, debug=<NUM_LIT:0>,<EOL>extra_preargs=None, extra_postargs=None, depends=None):<EOL><INDENT>for flag in remove_flags:<EOL><INDENT>if flag in self.compiler_so:<EOL><INDENT>self.compiler_so.remove(flag)<EOL><DEDENT><DEDENT>macros, objects, extra_postargs, pp_opts, build = self._setup_compile(output_dir, macros,<EOL>include_dirs, sources, depends, extra_postargs)<EOL>cc_args = self._get_cc_args(pp_opts, debug, extra_preargs)<EOL>for obj in objects:<EOL><INDENT>try:<EOL><INDENT>src, ext = build[obj]<EOL><DEDENT>except KeyError:<EOL><INDENT>continue<EOL><DEDENT>self._compile(obj, src, ext, cc_args, extra_postargs, pp_opts)<EOL><DEDENT>return objects<EOL><DEDENT>distutils.ccompiler.CCompiler.compile = _fix_compile<EOL>", "docstring": "Monkey-patch compiler to allow for removal of default compiler flags.", "id": "f4851:m0"}
{"signature": "def go():  ", "body": "searcher = Searcher(source=\"<STR_LIT>\")<EOL>searcher.go()<EOL>", "docstring": "Default scenario", "id": "f4857:m0"}
{"signature": "def execute_get_text(command):  ", "body": "try:<EOL><INDENT>completed = subprocess.run(<EOL>command,<EOL>check=True,<EOL>shell=True,<EOL>stdout=subprocess.PIPE,<EOL>stderr=subprocess.PIPE<EOL>)<EOL><DEDENT>except subprocess.CalledProcessError as err:<EOL><INDENT>raise<EOL><DEDENT>else:<EOL><INDENT>print(completed.stdout.decode('<STR_LIT:utf-8>') + str(\"<STR_LIT::>\") + completed.stderr.decode(\"<STR_LIT:utf-8>\"))<EOL>return completed.stdout.decode('<STR_LIT:utf-8>')  + completed.stderr.decode(\"<STR_LIT:utf-8>\")<EOL><DEDENT>", "docstring": "Execute shell command and return stdout txt\n:param command:\n:return:", "id": "f4862:m5"}
{"signature": "def connection_remote_closed(self, connection, pn_condition):", "body": "assert len(self.receivers) == <NUM_LIT:0><EOL>self.connection.close()<EOL>", "docstring": "All senders have finished and closed, test over.", "id": "f4865:c2:m2"}
{"signature": "def setup(self):", "body": "super(CyrusTest, self).setup()<EOL>if not CyrusTest.CONF_DIR:<EOL><INDENT>raise common.Skipped(\"<STR_LIT>\")<EOL><DEDENT>self.container1 = pyngus.Container(\"<STR_LIT>\")<EOL>self.container2 = pyngus.Container(\"<STR_LIT>\")<EOL>", "docstring": "Create a simple SASL configuration. This assumes saslpasswd2 is in\n        the OS path, otherwise the test will be skipped.", "id": "f4866:c1:m0"}
{"signature": "def _setup_receiver_sync(self):", "body": "rl_handler = common.ReceiverCallback()<EOL>receiver = self.conn2.create_receiver(\"<STR_LIT>\", \"<STR_LIT:src>\", rl_handler)<EOL>receiver.user_context = rl_handler<EOL>receiver.open()<EOL>self.process_connections()<EOL>assert self.conn1_handler.sender_requested_ct == <NUM_LIT:1><EOL>args = self.conn1_handler.sender_requested_args[<NUM_LIT:0>]<EOL>sl_handler = common.SenderCallback()<EOL>sender = self.conn1.accept_sender(args.link_handle,<EOL>event_handler=sl_handler)<EOL>sender.user_context = sl_handler<EOL>sender.open()<EOL>self.process_connections()<EOL>assert sender.active and sl_handler.active_ct > <NUM_LIT:0><EOL>assert receiver.active and rl_handler.active_ct > <NUM_LIT:0><EOL>return (sender, receiver)<EOL>", "docstring": "Create links, initiated by receiver.", "id": "f4867:c0:m4"}
{"signature": "def send_output(self):", "body": "try:<EOL><INDENT>pyngus.write_socket_output(self.connection,<EOL>self.socket)<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOG.error(\"<STR_LIT>\", str(e))<EOL>self.connection.close_output()<EOL>self.connection.close()<EOL><DEDENT>self.connection.process(time.time())<EOL>", "docstring": "Called when socket is write-ready", "id": "f4871:c0:m4"}
{"signature": "def send_output(self):", "body": "try:<EOL><INDENT>pyngus.write_socket_output(self.connection,<EOL>self.socket)<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOG.error(\"<STR_LIT>\", str(e))<EOL>self.connection.close_output()<EOL>self.connection.close()<EOL><DEDENT>self.connection.process(time.time())<EOL>", "docstring": "Called when socket is write-ready", "id": "f4872:c0:m5"}
{"signature": "def process_input(self):", "body": "try:<EOL><INDENT>pyngus.read_socket_input(self.connection, self.socket)<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOG.error(\"<STR_LIT>\", str(e))<EOL>self.connection.close_input()<EOL>self.connection.close()<EOL><DEDENT>self.connection.process(time.time())<EOL>", "docstring": "Called when socket is read-ready", "id": "f4872:c0:m4"}
{"signature": "def __init__(self, container, socket_, name, properties):", "body": "self.socket = socket_<EOL>self.connection = container.create_connection(name,<EOL>self,  <EOL>properties)<EOL>self.connection.user_context = self<EOL>self.connection.open()<EOL>self.sender_links = set()<EOL>self.receiver_links = set()<EOL>", "docstring": "Create a Connection using socket_.", "id": "f4872:c0:m0"}
{"signature": "def server_socket(host, port, backlog=<NUM_LIT:10>):", "body": "addr = socket.getaddrinfo(host, port, socket.AF_INET, socket.SOCK_STREAM)<EOL>if not addr:<EOL><INDENT>raise Exception(\"<STR_LIT>\"<EOL>% (host, str(port)))<EOL><DEDENT>my_socket = socket.socket(addr[<NUM_LIT:0>][<NUM_LIT:0>], addr[<NUM_LIT:0>][<NUM_LIT:1>], addr[<NUM_LIT:0>][<NUM_LIT:2>])<EOL>my_socket.setblocking(<NUM_LIT:0>)  <EOL>try:<EOL><INDENT>my_socket.bind(addr[<NUM_LIT:0>][<NUM_LIT:4>])<EOL>my_socket.listen(backlog)<EOL><DEDENT>except socket.error as e:<EOL><INDENT>if e.errno != errno.EINPROGRESS:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>return my_socket<EOL>", "docstring": "Create a TCP listening socket for a server.", "id": "f4873:m2"}
{"signature": "def connect_socket(host, port, blocking=True):", "body": "addr = socket.getaddrinfo(host, port, socket.AF_INET, socket.SOCK_STREAM)<EOL>if not addr:<EOL><INDENT>raise Exception(\"<STR_LIT>\"<EOL>% (host, str(port)))<EOL><DEDENT>my_socket = socket.socket(addr[<NUM_LIT:0>][<NUM_LIT:0>], addr[<NUM_LIT:0>][<NUM_LIT:1>], addr[<NUM_LIT:0>][<NUM_LIT:2>])<EOL>if not blocking:<EOL><INDENT>my_socket.setblocking(<NUM_LIT:0>)<EOL><DEDENT>try:<EOL><INDENT>my_socket.connect(addr[<NUM_LIT:0>][<NUM_LIT:4>])<EOL><DEDENT>except socket.error as e:<EOL><INDENT>if e.errno != errno.EINPROGRESS:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>return my_socket<EOL>", "docstring": "Create a TCP connection to the server.", "id": "f4873:m1"}
{"signature": "def sender_failed(self, sender_link, error):", "body": "LOG.debug(\"<STR_LIT>\", error)<EOL>sender_link.close()<EOL>", "docstring": "Protocol error occurred.", "id": "f4874:c1:m5"}
{"signature": "def connection_remote_closed(self, connection, pn_condition):", "body": "LOG.debug(\"<STR_LIT>\", pn_condition)<EOL>connection.close()<EOL>", "docstring": "Peer has closed its end of the connection.", "id": "f4876:c0:m1"}
{"signature": "def sender_failed(self, sender_link, error):", "body": "LOG.debug(\"<STR_LIT>\", error)<EOL>sender_link.close()<EOL>", "docstring": "Protocol error occurred.", "id": "f4876:c1:m1"}
{"signature": "def _ep_error(self, error):", "body": "LOG.error(\"<STR_LIT>\",<EOL>self._name, error)<EOL>", "docstring": "Unanticipated/illegal state change.", "id": "f4878:c0:m7"}
{"signature": "def _ep_need_close(self):", "body": "LOG.debug(\"<STR_LIT>\")<EOL>", "docstring": "The remote has closed its end of the endpoint.", "id": "f4878:c0:m5"}
{"signature": "@property<EOL><INDENT>def _endpoint_state(self):<DEDENT>", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "Returns the current endpoint state.", "id": "f4878:c0:m2"}
{"signature": "def connection_remote_closed(self, connection, pn_condition):", "body": "LOG.debug(\"<STR_LIT>\")<EOL>", "docstring": "Peer has closed its end of the connection.", "id": "f4879:c1:m2"}
{"signature": "def _ep_active(self):", "body": "LOG.debug(\"<STR_LIT>\")<EOL>if self._handler:<EOL><INDENT>with self._callback_lock:<EOL><INDENT>self._handler.connection_active(self)<EOL><DEDENT><DEDENT>", "docstring": "Both ends of the Endpoint have become active.", "id": "f4879:c2:m42"}
{"signature": "def create_sender(self, source_address, target_address=None,<EOL>event_handler=None, name=None, properties=None):", "body": "ident = name or str(source_address)<EOL>if ident in self._sender_links:<EOL><INDENT>raise KeyError(\"<STR_LIT>\" % ident)<EOL><DEDENT>session = _SessionProxy(\"<STR_LIT>\" % ident, self)<EOL>session.open()<EOL>sl = session.new_sender(ident)<EOL>sl.configure(target_address, source_address, event_handler, properties)<EOL>self._sender_links[ident] = sl<EOL>return sl<EOL>", "docstring": "Factory method for Sender links.", "id": "f4879:c2:m28"}
{"signature": "def _not_reentrant(func):", "body": "def wrap(self, *args, **kws):<EOL><INDENT>if self._callback_lock and self._callback_lock.in_callback:<EOL><INDENT>m = \"<STR_LIT>\" % func<EOL>raise RuntimeError(m)<EOL><DEDENT>return func(self, *args, **kws)<EOL><DEDENT>return wrap<EOL>", "docstring": "Decorator that prevents callbacks from calling into methods that are\n        not reentrant", "id": "f4879:c2:m0"}
{"signature": "def reject_sender(self, link_handle, pn_condition=None):", "body": "link = self._sender_links.get(link_handle)<EOL>if not link:<EOL><INDENT>raise Exception(\"<STR_LIT>\" % link_handle)<EOL><DEDENT>link.reject(pn_condition)<EOL>link.destroy()<EOL>", "docstring": "Rejects the SenderLink, and destroys the handle.", "id": "f4879:c2:m30"}
{"signature": "def sasl_done(self, connection, pn_sasl, result):", "body": "LOG.debug(\"<STR_LIT>\")<EOL>", "docstring": "SASL exchange complete.", "id": "f4879:c1:m7"}
{"signature": "def create_receiver(self, target_address, source_address=None,<EOL>event_handler=None, name=None, properties=None):", "body": "ident = name or str(target_address)<EOL>if ident in self._receiver_links:<EOL><INDENT>raise KeyError(\"<STR_LIT>\" % ident)<EOL><DEDENT>session = _SessionProxy(\"<STR_LIT>\" % ident, self)<EOL>session.open()<EOL>rl = session.new_receiver(ident)<EOL>rl.configure(target_address, source_address, event_handler, properties)<EOL>self._receiver_links[ident] = rl<EOL>return rl<EOL>", "docstring": "Factory method for creating Receive links.", "id": "f4879:c2:m31"}
{"signature": "@property<EOL><INDENT>def remote_container(self):<DEDENT>", "body": "return self._pn_connection.remote_container<EOL>", "docstring": "Return the name of the remote container. Should be present once the\n        connection is active.", "id": "f4879:c2:m6"}
{"signature": "def sasl_step(self, connection, pn_sasl):", "body": "LOG.debug(\"<STR_LIT>\")<EOL>", "docstring": "DEPRECATED", "id": "f4879:c1:m6"}
{"signature": "@property<EOL><INDENT>def deadline(self):<DEDENT>", "body": "return self._next_deadline<EOL>", "docstring": "Must invoke process() on or before this timestamp.", "id": "f4879:c2:m20"}
{"signature": "def _ep_closed(self):", "body": "LOG.debug(\"<STR_LIT>\", self._name)<EOL>", "docstring": "Both ends of the endpoint have closed.", "id": "f4880:c6:m11"}
{"signature": "def new_receiver(self, name):", "body": "pn_link = self._pn_session.receiver(name)<EOL>return self.request_receiver(pn_link)<EOL>", "docstring": "Create a new receiver link.", "id": "f4880:c6:m4"}
{"signature": "def link_destroyed(self, link):", "body": "self._links.discard(link)<EOL>if not self._links:<EOL><INDENT>LOG.debug(\"<STR_LIT>\")<EOL>self._pn_session.close()<EOL>self._pn_session.free()<EOL>self._pn_session = None<EOL>self._connection = None<EOL><DEDENT>", "docstring": "Link has been destroyed.", "id": "f4880:c6:m6"}
{"signature": "@property<EOL><INDENT>def source_address(self):<DEDENT>", "body": "<EOL>if self._pn_link.is_sender:<EOL><INDENT>return self._pn_link.source.address<EOL><DEDENT>else:<EOL><INDENT>return self._pn_link.remote_source.address<EOL><DEDENT>", "docstring": "Return the authorative source of the link.", "id": "f4880:c1:m7"}
{"signature": "def _ep_active(self):", "body": "LOG.debug(\"<STR_LIT>\", self._name)<EOL>", "docstring": "Both ends of the Endpoint have become active.", "id": "f4880:c6:m9"}
{"signature": "def configure(self, target_address, source_address, handler, properties):", "body": "self._handler = handler<EOL>self._properties = properties<EOL>dynamic_props = None<EOL>if properties:<EOL><INDENT>dynamic_props = properties.get(\"<STR_LIT>\")<EOL>mode = _dist_modes.get(properties.get(\"<STR_LIT>\"))<EOL>if mode is not None:<EOL><INDENT>self._pn_link.source.distribution_mode = mode<EOL><DEDENT>mode = _snd_settle_modes.get(properties.get(\"<STR_LIT>\"))<EOL>if mode is not None:<EOL><INDENT>self._pn_link.snd_settle_mode = mode<EOL><DEDENT>mode = _rcv_settle_modes.get(properties.get(\"<STR_LIT>\"))<EOL>if mode is not None:<EOL><INDENT>self._pn_link.rcv_settle_mode = mode<EOL><DEDENT><DEDENT>if target_address is None:<EOL><INDENT>if not self._pn_link.is_sender:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>self._pn_link.target.dynamic = True<EOL>if dynamic_props:<EOL><INDENT>self._pn_link.target.properties.clear()<EOL>self._pn_link.target.properties.put_dict(dynamic_props)<EOL><DEDENT><DEDENT>elif target_address:<EOL><INDENT>self._pn_link.target.address = target_address<EOL><DEDENT>if source_address is None:<EOL><INDENT>if not self._pn_link.is_receiver:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>self._pn_link.source.dynamic = True<EOL>if dynamic_props:<EOL><INDENT>self._pn_link.source.properties.clear()<EOL>self._pn_link.source.properties.put_dict(dynamic_props)<EOL><DEDENT><DEDENT>elif source_address:<EOL><INDENT>self._pn_link.source.address = source_address<EOL><DEDENT>", "docstring": "Assign addresses, properties, etc.", "id": "f4880:c1:m1"}
{"signature": "def download_setuptools(version=DEFAULT_VERSION, download_base=DEFAULT_URL,<EOL>to_dir=os.curdir, delay=<NUM_LIT:15>):", "body": "<EOL>to_dir = os.path.abspath(to_dir)<EOL>try:<EOL><INDENT>from urllib.request import urlopen<EOL><DEDENT>except ImportError:<EOL><INDENT>from urllib2 import urlopen<EOL><DEDENT>tgz_name = \"<STR_LIT>\" % version<EOL>url = download_base + tgz_name<EOL>saveto = os.path.join(to_dir, tgz_name)<EOL>src = dst = None<EOL>if not os.path.exists(saveto):  <EOL><INDENT>try:<EOL><INDENT>log.warn(\"<STR_LIT>\", url)<EOL>src = urlopen(url)<EOL>data = src.read()<EOL>dst = open(saveto, \"<STR_LIT:wb>\")<EOL>dst.write(data)<EOL><DEDENT>finally:<EOL><INDENT>if src:<EOL><INDENT>src.close()<EOL><DEDENT>if dst:<EOL><INDENT>dst.close()<EOL><DEDENT><DEDENT><DEDENT>return os.path.realpath(saveto)<EOL>", "docstring": "Download distribute from a specified location and return its filename\n\n    `version` should be a valid distribute version number that is available\n    as an egg for download under the `download_base` URL (which should end\n    with a '/'). `to_dir` is the directory where the egg will be downloaded.\n    `delay` is the number of seconds to pause before an actual download\n    attempt.", "id": "f4888:m4"}
{"signature": "def main(argv, version=DEFAULT_VERSION):", "body": "tarball = download_setuptools()<EOL>_install(tarball)<EOL>", "docstring": "Install or upgrade setuptools and EasyInstall", "id": "f4888:m17"}
{"signature": "def _extractall(self, path=\"<STR_LIT:.>\", members=None):", "body": "import copy<EOL>import operator<EOL>from tarfile import ExtractError<EOL>directories = []<EOL>if members is None:<EOL><INDENT>members = self<EOL><DEDENT>for tarinfo in members:<EOL><INDENT>if tarinfo.isdir():<EOL><INDENT>directories.append(tarinfo)<EOL>tarinfo = copy.copy(tarinfo)<EOL>tarinfo.mode = <NUM_LIT> <EOL><DEDENT>self.extract(tarinfo, path)<EOL><DEDENT>if sys.version_info < (<NUM_LIT:2>, <NUM_LIT:4>):<EOL><INDENT>def sorter(dir1, dir2):<EOL><INDENT>return cmp(dir1.name, dir2.name)<EOL><DEDENT>directories.sort(sorter)<EOL>directories.reverse()<EOL><DEDENT>else:<EOL><INDENT>directories.sort(key=operator.attrgetter('<STR_LIT:name>'), reverse=True)<EOL><DEDENT>for tarinfo in directories:<EOL><INDENT>dirpath = os.path.join(path, tarinfo.name)<EOL>try:<EOL><INDENT>self.chown(tarinfo, dirpath)<EOL>self.utime(tarinfo, dirpath)<EOL>self.chmod(tarinfo, dirpath)<EOL><DEDENT>except ExtractError:<EOL><INDENT>e = sys.exc_info()[<NUM_LIT:1>]<EOL>if self.errorlevel > <NUM_LIT:1>:<EOL><INDENT>raise<EOL><DEDENT>else:<EOL><INDENT>self._dbg(<NUM_LIT:1>, \"<STR_LIT>\" % e)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Extract all members from the archive to the current working\n       directory and set owner, modification time and permissions on\n       directories afterwards. `path' specifies a different directory\n       to extract to. `members' is optional and must be a subset of the\n       list returned by getmembers().", "id": "f4888:m16"}
{"signature": "def __eq__(self, oth) -> bool:", "body": "<EOL>return self.name == oth<EOL>", "docstring": "Use by all __contains__ call when we do some 'in' test", "id": "f4921:c9:m2"}
{"signature": "def unify(self, oth_type_def: TypeExprComponent, blhs, brhs) -> TypeExprComponent:", "body": "print(\"<STR_LIT>\" % (self, oth_type_def))<EOL>if self.type_def is not None:<EOL><INDENT>if type(oth_type_def) is UnknownName:<EOL><INDENT>if oth_type_def is None:<EOL><INDENT>oth_type_def.type_def = self.type_def<EOL>return self.type_def<EOL><DEDENT><DEDENT>return self.type_def.unify(oth_type_def, blhs, brhs)<EOL><DEDENT>if self.type_def is None:<EOL><INDENT>self.type_def = Overload()<EOL><DEDENT>if oth_type_def not in self.type_def:<EOL><INDENT>self.type_def.append(oth_type_def)<EOL><DEDENT>return oth_type_def<EOL>", "docstring": "When we unify an Unknown Name vs another type def we always match", "id": "f4921:c2:m1"}
{"signature": "def unify(self, oth_type_def: TypeExprComponent, blhs, brhs) -> TypeExprComponent:", "body": "print(\"<STR_LIT>\" % (self, oth_type_def))<EOL>if type(oth_type_def) is not Fun:<EOL><INDENT>if type(oth_type_def) is T:<EOL><INDENT>return self[<NUM_LIT:0>].unify(oth_type_def, blhs, brhs)<EOL><DEDENT>raise \"<STR_LIT>\"<EOL><DEDENT>diff_len = len(self) - len(oth_type_def)<EOL>if diff_len < <NUM_LIT:0>: <EOL><INDENT>return None<EOL><DEDENT>for a, b in zip(reversed(self), reversed(oth_type_def)):<EOL><INDENT>if not a.unify(b, blhs, brhs):<EOL><INDENT>return None<EOL><DEDENT><DEDENT>return Fun(*self[:diff_len])<EOL>", "docstring": "When we unify a function vs another type def we match each term and we return the rest.\n\nt1 -> t2 -> t3 ?? t1 -> t2 match and we return t3\nt1 -> t2 ?? t1 -> t2 -> t3 didn't match\n\nNote: the first element is the return type", "id": "f4921:c5:m0"}
{"signature": "@meta.rule(parsing.Parser, \"<STR_LIT>\")<EOL>def ignore_cxx(self) -> bool:", "body": "self._stream.save_context()<EOL>while not self.read_eof():<EOL><INDENT>idxref = self._stream.index<EOL>if self._stream.peek_char in \"<STR_LIT>\":<EOL><INDENT>while (not self.read_eof()<EOL>and self._stream.peek_char in \"<STR_LIT>\"):<EOL><INDENT>self._stream.incpos()<EOL><DEDENT><DEDENT>if self.peek_text(\"<STR_LIT>\"):<EOL><INDENT>while not self.read_eof() and not self.peek_char(\"<STR_LIT:\\n>\"):<EOL><INDENT>self._stream.incpos()<EOL><DEDENT>if not self.read_char(\"<STR_LIT:\\n>\") and self.read_eof():<EOL><INDENT>return self._stream.validate_context()<EOL><DEDENT><DEDENT>if self.peek_text(\"<STR_LIT>\"):<EOL><INDENT>while not self.read_eof() and not self.peek_text(\"<STR_LIT>\"):<EOL><INDENT>self._stream.incpos()<EOL><DEDENT>if not self.read_text(\"<STR_LIT>\") and self.read_eof():<EOL><INDENT>return self._stream.restore_context()<EOL><DEDENT><DEDENT>if idxref == self._stream.index:<EOL><INDENT>break<EOL><DEDENT><DEDENT>return self._stream.validate_context()<EOL>", "docstring": "Consume comments and whitespace characters.", "id": "f4927:m0"}
{"signature": "def catend(dst: str, src: str, indent) -> str:", "body": "res = dst<EOL>txtsrc = src<EOL>if not isinstance(src, str):<EOL><INDENT>txtsrc = str(src)<EOL><DEDENT>for c in list(txtsrc):<EOL><INDENT>if len(res) > <NUM_LIT:0> and res[-<NUM_LIT:1>] == '<STR_LIT:\\n>':<EOL><INDENT>res += (indentable.char_indent * indentable.num_indent) *(indent - <NUM_LIT:1>) + c<EOL><DEDENT>else:<EOL><INDENT>res += c<EOL><DEDENT><DEDENT>return res<EOL>", "docstring": "cat two strings but handle \\n for tabulation", "id": "f4930:m0"}
{"signature": "def list_set_indent(lst: list, indent: int=<NUM_LIT:1>):", "body": "for i in lst:<EOL><INDENT>if isinstance(i, indentable):<EOL><INDENT>i.set_indent(indent)<EOL><DEDENT>if isinstance(i, list):<EOL><INDENT>list_set_indent(i, indent)<EOL><DEDENT><DEDENT>", "docstring": "recurs into list for indentation", "id": "f4930:m1"}
{"signature": "def populate_from_sequence(seq: list, r: ref(Edge), sr: state.StateRegister):", "body": "base_state = r<EOL>idxlast = len(seq) - <NUM_LIT:1><EOL>idx = <NUM_LIT:0><EOL>for m in seq:<EOL><INDENT>if isinstance(m, list):<EOL><INDENT>for item in m:<EOL><INDENT>populate_from_sequence(item, r, sr)<EOL><DEDENT><DEDENT>elif isinstance(m, MatchExpr):<EOL><INDENT>eX = r().get_next_edge(m)<EOL>if eX is None:<EOL><INDENT>sX = None<EOL>if idx != idxlast:<EOL><INDENT>sX = state.State(sr)<EOL>sX.matchDefault(base_state().s)<EOL><DEDENT>else:<EOL><INDENT>sX = base_state().s<EOL><DEDENT>eX = Edge(sX)<EOL>r().next_edge[id(sX)] = eX<EOL>m.attach(r().s, sX, sr)<EOL><DEDENT>r = ref(eX)<EOL><DEDENT>idx += <NUM_LIT:1><EOL><DEDENT>", "docstring": "function that connect each other one sequence of MatchExpr.", "id": "f4931:m0"}
{"signature": "def populate_state_register(all_seq: [list], sr: state.StateRegister) -> Edge:", "body": "<EOL>s0 = state.State(sr)<EOL>s0.matchDefault(s0)<EOL>sr.set_default_state(s0)<EOL>e0 = Edge(s0)<EOL>for seq in all_seq:<EOL><INDENT>r = ref(e0)<EOL>populate_from_sequence(seq, r, sr)<EOL><DEDENT>return e0<EOL>", "docstring": "function that create a state for all instance\n        of MatchExpr in the given list and connect each others.", "id": "f4931:m1"}
{"signature": "def to_png_file(self, fname: str):", "body": "cmd = pipes.Template()<EOL>cmd.append('<STR_LIT>' % fname, '<STR_LIT>')<EOL>with cmd.open('<STR_LIT>', '<STR_LIT:w>') as f:<EOL><INDENT>f.write(self.to_dot())<EOL><DEDENT>", "docstring": "write a '.png' file.", "id": "f4933:c1:m9"}
{"signature": "def resetLivingState(self):", "body": "<EOL>must_delete = []<EOL>l = len(self.ls)<EOL>for idx, ls in zip(range(l), self.ls):<EOL><INDENT>ids = id(ls[<NUM_LIT:1>].thestate())<EOL>if ids == id(ls[<NUM_LIT:0>]) and (ls[<NUM_LIT:1>].have_finish or not ls[<NUM_LIT:1>].alive):<EOL><INDENT>must_delete.append(idx)<EOL><DEDENT>elif ls[<NUM_LIT:1>].alive:<EOL><INDENT>ls[<NUM_LIT:1>].alive = False<EOL><DEDENT><DEDENT>for delete in reversed(must_delete):<EOL><INDENT>self.ls.pop(delete)<EOL><DEDENT>self.init_all()<EOL>", "docstring": "Only one Living State on the S0 of each StateRegister", "id": "f4933:c15:m15"}
{"signature": "@meta.hook(EBNF, \"<STR_LIT>\")<EOL>def add_optional(self, repeat):", "body": "repeat.functor = parsing.RepOptional<EOL>return True<EOL>", "docstring": "Create a tree.RepOptional", "id": "f4934:m13"}
{"signature": "def get_rules(self) -> parsing.Node:", "body": "res = None<EOL>try:<EOL><INDENT>res = self.eval_rule('<STR_LIT>')<EOL>if not res:<EOL><INDENT>self.diagnostic.notify(<EOL>error.Severity.ERROR,<EOL>\"<STR_LIT>\" % self._lastRule,<EOL>error.LocationInfo.from_maxstream(self._stream)<EOL>)<EOL>raise self.diagnostic<EOL><DEDENT><DEDENT>except error.Diagnostic as d:<EOL><INDENT>d.notify(<EOL>error.Severity.ERROR,<EOL>\"<STR_LIT>\" % self._lastRule<EOL>)<EOL>raise d<EOL><DEDENT>return res<EOL>", "docstring": "Parse the DSL and provide a dictionnaries of all resulting rules.\nCall by the MetaGrammar class.\n\nTODO: could be done in the rules property of parsing.BasicParser???", "id": "f4934:c0:m0"}
{"signature": "@meta.hook(EBNF, \"<STR_LIT>\")<EOL>def param_num(self, param, n):", "body": "param.pair = (int(self.value(n)), int)<EOL>return True<EOL>", "docstring": "Parse a int in parameter list", "id": "f4934:m17"}
{"signature": "@meta.hook(EBNF, \"<STR_LIT>\")<EOL>def add_rpt(self, sequence, mod, pt):", "body": "modstr = self.value(mod)<EOL>if modstr == '<STR_LIT>':<EOL><INDENT>self._stream.restore_context()<EOL>self.diagnostic.notify(<EOL>error.Severity.ERROR,<EOL>\"<STR_LIT>\",<EOL>error.LocationInfo.from_stream(self._stream, is_error=True)<EOL>)<EOL>raise self.diagnostic<EOL><DEDENT>if modstr == '<STR_LIT:!>':<EOL><INDENT>self._stream.restore_context()<EOL>self.diagnostic.notify(<EOL>error.Severity.ERROR,<EOL>\"<STR_LIT>\",<EOL>error.LocationInfo.from_stream(self._stream, is_error=True)<EOL>)<EOL>raise self.diagnostic<EOL><DEDENT>oldnode = sequence<EOL>sequence.parser_tree = pt.functor(oldnode.parser_tree)<EOL>return True<EOL>", "docstring": "Add a repeater to the previous sequence", "id": "f4934:m9"}
{"signature": "@meta.hook(EBNF, \"<STR_LIT>\")<EOL>def param_str(self, param, s):", "body": "param.pair = (self.value(s).strip('<STR_LIT:\">'), str)<EOL>return True<EOL>", "docstring": "Parse a str in parameter list", "id": "f4934:m18"}
{"signature": "@meta.hook(EBNF, \"<STR_LIT>\")<EOL>def add_mod(self, seq, mod):", "body": "modstr = self.value(mod)<EOL>if modstr == '<STR_LIT>':<EOL><INDENT>seq.parser_tree = parsing.Complement(seq.parser_tree)<EOL><DEDENT>elif modstr == '<STR_LIT>':<EOL><INDENT>seq.parser_tree = parsing.LookAhead(seq.parser_tree)<EOL><DEDENT>elif modstr == '<STR_LIT:!>':<EOL><INDENT>seq.parser_tree = parsing.Neg(seq.parser_tree)<EOL><DEDENT>elif modstr == '<STR_LIT>':<EOL><INDENT>seq.parser_tree = parsing.Until(seq.parser_tree)<EOL><DEDENT>return True<EOL>", "docstring": "Create a tree.{Complement, LookAhead, Neg, Until}", "id": "f4934:m0"}
{"signature": "def set_one(chainmap, thing_name, callobject):", "body": "namespaces = reversed(thing_name.split(\"<STR_LIT:.>\"))<EOL>lstname = []<EOL>for name in namespaces:<EOL><INDENT>lstname.insert(<NUM_LIT:0>, name)<EOL>strname = '<STR_LIT:.>'.join(lstname)<EOL>chainmap[strname] = callobject<EOL><DEDENT>", "docstring": "Add a mapping with key thing_name for callobject in chainmap with\n        namespace handling.", "id": "f4935:m2"}
{"signature": "def directive(directname=None):", "body": "global _directives<EOL>class_dir_list = _directives<EOL>def wrapper(f):<EOL><INDENT>nonlocal directname<EOL>if directname is None:<EOL><INDENT>directname = f.__name__<EOL><DEDENT>f.ns_name = directname<EOL>set_one(class_dir_list, directname, f)<EOL>return f<EOL><DEDENT>return wrapper<EOL>", "docstring": "Attach a class to a parsing class and register it as a parser directive.\n\n        The class is registered with its name unless directname is provided.", "id": "f4935:m7"}
{"signature": "@meta.rule(Parser, \"<STR_LIT>\")<EOL>def read_integer(self) -> bool:", "body": "if self.read_eof():<EOL><INDENT>return False<EOL><DEDENT>self._stream.save_context()<EOL>c = self._stream.peek_char<EOL>if c.isdigit():<EOL><INDENT>self._stream.incpos()<EOL>while not self.read_eof():<EOL><INDENT>c = self._stream.peek_char<EOL>if not c.isdigit():<EOL><INDENT>break<EOL><DEDENT>self._stream.incpos()<EOL><DEDENT>return self._stream.validate_context()<EOL><DEDENT>return self._stream.restore_context()<EOL>", "docstring": "read a number\nRead following BNF rule else return False::\n\n    readInteger = [\n        ['0'..'9']+\n    ]", "id": "f4936:m6"}
{"signature": "def get_tag(self, name: str) -> Tag:", "body": "return self.tag_cache[name]<EOL>", "docstring": "Extract the string previously saved.", "id": "f4936:c1:m12"}
{"signature": "def pop_ignore(self) -> bool:", "body": "self._ignores.pop()<EOL>return True<EOL>", "docstring": "Remove the last ignore convention", "id": "f4936:c1:m30"}
{"signature": "def pop_stream(self):", "body": "s = self._streams.pop()<EOL>self.clean_tmp(s)<EOL>", "docstring": "Pop the last Stream pushed on to the parser stack.", "id": "f4936:c1:m9"}
{"signature": "def begin_tag(self, name: str) -> Node:", "body": "<EOL>self.tag_cache[name] = Tag(self._stream, self._stream.index)<EOL>return True<EOL>", "docstring": "Save the current index under the given name.", "id": "f4936:c1:m10"}
{"signature": "@meta.rule(Parser, \"<STR_LIT>\")<EOL>def read_hex_integer(self) -> bool:", "body": "if self.read_eof():<EOL><INDENT>return False<EOL><DEDENT>self._stream.save_context()<EOL>c = self._stream.peek_char<EOL>if c.isdigit() or ('<STR_LIT:a>' <= c.lower() and c.lower() <= '<STR_LIT:f>'):<EOL><INDENT>self._stream.incpos()<EOL>while not self.read_eof():<EOL><INDENT>c = self._stream.peek_char<EOL>if not (c.isdigit() or ('<STR_LIT:a>' <= c.lower() and c.lower() <= '<STR_LIT:f>')):<EOL><INDENT>break<EOL><DEDENT>self._stream.incpos()<EOL><DEDENT>return self._stream.validate_context()<EOL><DEDENT>return self._stream.restore_context()<EOL>", "docstring": "read a hexadecimal number\nRead the following BNF rule else return False::\n\n    readHexInteger = [\n        [ '0'..'9' | 'a'..'f' | 'A'..'F' ]+\n    ]", "id": "f4936:m4"}
{"signature": "def read_char(self, c: str) -> bool:", "body": "if self.read_eof():<EOL><INDENT>return False<EOL><DEDENT>self._stream.save_context()<EOL>if c == self._stream.peek_char:<EOL><INDENT>self._stream.incpos()<EOL>return self._stream.validate_context()<EOL><DEDENT>return self._stream.restore_context()<EOL>", "docstring": "Consume the c head byte, increment current index and return True\nelse return False. It use peekchar and it's the same as '' in BNF.", "id": "f4936:c1:m22"}
{"signature": "@classmethod<EOL><INDENT>def set_directives(cls, directives: dict) -> bool:<DEDENT>", "body": "meta._directives = meta._directives.new_child()<EOL>for dir_name, dir_pt in directives.items():<EOL><INDENT>meta.set_one(meta._directives, dir_name, dir_pt)<EOL>dir_pt.ns_name = dir_name<EOL><DEDENT>return True<EOL>", "docstring": "Merge internal directives set with the given directives.\nFor working directives, attach it only in the dsl.Parser class", "id": "f4936:c1:m16"}
{"signature": "@classmethod<EOL><INDENT>def set_rules(cls, rules: dict) -> bool:<DEDENT>", "body": "cls._rules = cls._rules.new_child()<EOL>for rule_name, rule_pt in rules.items():<EOL><INDENT>if '<STR_LIT:.>' not in rule_name:<EOL><INDENT>rule_name = cls.__module__+ '<STR_LIT:.>' + cls.__name__+ '<STR_LIT:.>' + rule_name<EOL><DEDENT>meta.set_one(cls._rules, rule_name, rule_pt)<EOL><DEDENT>return True<EOL>", "docstring": "Merge internal rules set with the given rules", "id": "f4936:c1:m14"}
{"signature": "@property<EOL><INDENT>def nstream(self) -> int:<DEDENT>", "body": "return len(self._streams)<EOL>", "docstring": "Return the number of opened stream", "id": "f4936:c1:m3"}
{"signature": "def ignore_blanks(self) -> bool:", "body": "self._stream.save_context()<EOL>if not self.read_eof() and self._stream.peek_char in \"<STR_LIT>\":<EOL><INDENT>while (not self.read_eof()<EOL>and self._stream.peek_char in \"<STR_LIT>\"):<EOL><INDENT>self._stream.incpos()<EOL><DEDENT>return self._stream.validate_context()<EOL><DEDENT>return self._stream.validate_context()<EOL>", "docstring": "Consume whitespace characters.", "id": "f4936:c1:m28"}
{"signature": "def eval_hook(self, name: str, ctx: list) -> Node:", "body": "if name not in self.__class__._hooks:<EOL><INDENT>self.diagnostic.notify(<EOL>error.Severity.ERROR,<EOL>\"<STR_LIT>\" % name,<EOL>error.LocationInfo.from_stream(self._stream, is_error=True)<EOL>)<EOL>raise self.diagnostic<EOL><DEDENT>self._lastRule = '<STR_LIT:#>' + name<EOL>res = self.__class__._hooks[name](self, *ctx)<EOL>if type(res) is not bool:<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % name)<EOL><DEDENT>return res<EOL>", "docstring": "Evaluate the hook by its name", "id": "f4936:c1:m18"}
{"signature": "def read_until_eof(self) -> bool:", "body": "if self.read_eof():<EOL><INDENT>return True<EOL><DEDENT>self._stream.save_context()<EOL>while not self.read_eof():<EOL><INDENT>self._stream.incpos()<EOL><DEDENT>return self._stream.validate_context()<EOL>", "docstring": "Consume all the stream. Same as EOF in BNF.", "id": "f4936:c1:m24"}
{"signature": "@meta.rule(BasicParser, \"<STR_LIT>\")<EOL>def read_eof(self) -> bool:", "body": "<EOL>return self._stream.index == self._stream.eos_index<EOL>", "docstring": "Returns true if reached end of the stream.", "id": "f4936:m2"}
{"signature": "def peek_text(self, text: str) -> bool:", "body": "start = self._stream.index<EOL>stop = start + len(text)<EOL>if stop > self._stream.eos_index:<EOL><INDENT>return False<EOL><DEDENT>return self._stream[self._stream.index:stop] == text<EOL>", "docstring": "Same as readText but doesn't consume the stream.", "id": "f4936:c1:m20"}
{"signature": "@property<EOL><INDENT>def max_readed_position(self) -> Position:<DEDENT>", "body": "return Position(self._maxindex, self._maxline, self._maxcol)<EOL>", "docstring": "The index of the deepest character readed.", "id": "f4939:c0:m6"}
{"signature": "@property<EOL><INDENT>def eos_index(self) -> int:<DEDENT>", "body": "return self._len<EOL>", "docstring": "End Of Stream index.", "id": "f4939:c2:m4"}
{"signature": "def validate_context(self) -> bool:", "body": "del self._contexts[-<NUM_LIT:1>]<EOL>return True<EOL>", "docstring": "Discard previous saved position.", "id": "f4939:c2:m14"}
{"signature": "def restore_context(self) -> bool:", "body": "self._cursor.position = self._contexts.pop()<EOL>return False<EOL>", "docstring": "Rollback to previous saved position.", "id": "f4939:c2:m13"}
{"signature": "@property<EOL><INDENT>def last_readed_line(self) -> str:<DEDENT>", "body": "mpos = self._cursor.max_readed_position<EOL>mindex = mpos.index<EOL>prevline = mindex - <NUM_LIT:1> if mindex == self.eos_index else mindex<EOL>while prevline >= <NUM_LIT:0> and self._content[prevline] != '<STR_LIT:\\n>':<EOL><INDENT>prevline -= <NUM_LIT:1><EOL><DEDENT>nextline = mindex<EOL>while nextline < self.eos_index and self._content[nextline] != '<STR_LIT:\\n>':<EOL><INDENT>nextline += <NUM_LIT:1><EOL><DEDENT>last_line = self._content[prevline + <NUM_LIT:1>:nextline]<EOL>return last_line<EOL>", "docstring": "Usefull string to compute error message.", "id": "f4939:c2:m9"}
{"signature": "def step_prev_line(self):", "body": "<EOL>if len(self._eol) > <NUM_LIT:0>:<EOL><INDENT>self.position = self._eol.pop()<EOL><DEDENT>", "docstring": "Sets cursor as end of previous line.", "id": "f4939:c0:m10"}
{"signature": "@property<EOL><INDENT>def position(self) -> Position:<DEDENT>", "body": "return Position(self._index, self._lineno, self._col_offset)<EOL>", "docstring": "The current position of the cursor.", "id": "f4939:c0:m4"}
{"signature": "def check(self, ndict: dict, info=\"<STR_LIT>\") -> bool:", "body": "def iscycle(thing, ndict: dict, info: str) -> bool:<EOL><INDENT>idthing = id(thing)<EOL>ndict[info] = idthing<EOL>if idthing not in ndict:<EOL><INDENT>ndict[idthing] = \"<STR_LIT>\" % (type(thing), info)<EOL>return False<EOL><DEDENT>else:<EOL><INDENT>ndict[idthing] += \"<STR_LIT>\" % (type(thing), info)<EOL>return True<EOL><DEDENT><DEDENT>def recurs(thing, ndict: dict, info: str) -> bool:<EOL><INDENT>if not iscycle(thing, ndict, info):<EOL><INDENT>res = False<EOL>if isinstance(thing, list):<EOL><INDENT>idx = <NUM_LIT:0><EOL>for i in thing:<EOL><INDENT>res |= recurs(i, ndict, \"<STR_LIT>\" % (info, idx))<EOL>idx += <NUM_LIT:1><EOL><DEDENT><DEDENT>elif isinstance(thing, Node):<EOL><INDENT>res |= thing.check(ndict, info)<EOL><DEDENT>elif isinstance(thing, dict):<EOL><INDENT>for k, v in thing.items():<EOL><INDENT>res |= recurs(v, ndict, \"<STR_LIT>\" % (info, k))<EOL><DEDENT><DEDENT>return res<EOL><DEDENT>return True<EOL><DEDENT>if len(ndict) == <NUM_LIT:0>:<EOL><INDENT>ndict['<STR_LIT>'] = id(self)<EOL>info = '<STR_LIT>'<EOL><DEDENT>if not iscycle(self, ndict, info):<EOL><INDENT>res = False<EOL>if len(self) > <NUM_LIT:0>:<EOL><INDENT>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>keys = list(self.keys())<EOL>for k in keys:<EOL><INDENT>ndict[\"<STR_LIT:[>\" + repr(k) + \"<STR_LIT:]>\"] = id(self[k])<EOL>res |= recurs(self[k], ndict, \"<STR_LIT>\" % (info, k))<EOL><DEDENT><DEDENT><DEDENT>keys = list(vars(self).keys())<EOL>for k in keys:<EOL><INDENT>ndict[\"<STR_LIT:.>\" + k] = id(getattr(self, k))<EOL>res |= recurs(getattr(self, k), ndict, \"<STR_LIT>\" % (info, k))<EOL><DEDENT>return res<EOL><DEDENT>return True<EOL>", "docstring": "Debug method, help detect cycle and/or\nother incoherence in a tree of Node", "id": "f4941:c0:m2"}
{"signature": "def values(self):", "body": "tmp = self<EOL>while tmp is not None:<EOL><INDENT>yield tmp.data<EOL>tmp = tmp.next<EOL><DEDENT>", "docstring": "in order", "id": "f4941:c6:m13"}
{"signature": "def after_parse(self, node: parsing.Node) -> parsing.Node:", "body": "return node<EOL>", "docstring": "If you want to do some stuff after parsing, overload this...", "id": "f4942:c1:m0"}
{"signature": "@meta.hook(BasicParser, \"<STR_LIT>\")<EOL>def pred_neq(self, n, val):", "body": "v1 = n.value<EOL>v2 = val<EOL>if hasattr(val, '<STR_LIT:value>'):<EOL><INDENT>v2 = val.value<EOL><DEDENT>if isinstance(v1, int) and not isinstance(v2, int):<EOL><INDENT>return v1 != int(v2)<EOL><DEDENT>return v1 != v2<EOL>", "docstring": "Test if a node set with setint or setstr not equal a certain value\n\nexample::\n\n    R = [\n        __scope__:n\n        ['a' #setint(n, 12) | 'b' #setint(n, 14)]\n        C\n        [#neq(n, 12) D]\n    ]", "id": "f4943:m3"}
{"signature": "@meta.hook(BasicParser, \"<STR_LIT>\")<EOL>def dump_nodes(self):", "body": "print(\"<STR_LIT>\")<EOL>try:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>for k, v in self.id_cache.items():<EOL><INDENT>print(\"<STR_LIT>\" % (k, v))<EOL><DEDENT>print(\"<STR_LIT>\")<EOL>for k, v in self.tag_cache.items():<EOL><INDENT>print(\"<STR_LIT>\" % (k, v))<EOL><DEDENT>print(\"<STR_LIT>\")<EOL>for k, v in self.rule_nodes.items():<EOL><INDENT>txt = \"<STR_LIT>\" % (k, id(v))<EOL>if k in self.tag_cache:<EOL><INDENT>tag = self.tag_cache[k]<EOL>txt += \"<STR_LIT>\" % tag<EOL>k = \"<STR_LIT>\" % (tag._begin, tag._end)<EOL>if k in self._stream.value_cache:<EOL><INDENT>txt += \"<STR_LIT>\" % self._stream.value_cache[k]<EOL><DEDENT><DEDENT>print(txt)<EOL><DEDENT><DEDENT>except Exception as err:<EOL><INDENT>print(\"<STR_LIT>\" % err)<EOL><DEDENT>import sys<EOL>sys.stdout.flush()<EOL>return True<EOL>", "docstring": "Dump tag,rule,id and value cache. For debug.\n\nexample::\n\n    R = [\n        #dump_nodes\n    ]", "id": "f4946:m0"}
{"signature": "@meta.hook(BasicParser, \"<STR_LIT>\")<EOL>def set_node_as_int(self, dst, src):", "body": "dst.value = self.value(src)<EOL>return True<EOL>", "docstring": "Set a node to a value captured from another node\n\nexample::\n\n    R = [\n        In : node #setcapture(_, node)\n    ]", "id": "f4947:m1"}
{"signature": "@meta.hook(BasicParser, \"<STR_LIT>\")<EOL>def get_subnode(self, dst, ast, expr):", "body": "dst.value = eval('<STR_LIT>' + expr)<EOL>return True<EOL>", "docstring": "get the value of subnode\n\nexample::\n\n    R = [\n        __scope__:big  getsomethingbig:>big\n        #get(_, big, '.val') // copy big.val into _\n    ]", "id": "f4947:m4"}
{"signature": "@meta.add_method(functors.SkipIgnore)<EOL>def to_cython(self, genstate) -> fmt.indentable:", "body": "return '<STR_LIT:\\n>'<EOL>", "docstring": "TODO: A quite important part of C transform... rethink directive/decoration/etc...", "id": "f4948:m3"}
{"signature": "@meta.add_method(Translator)<EOL>def to_fmt(self, with_from=False) -> fmt.indentable:", "body": "txt = fmt.sep(\"<STR_LIT:\\n>\", [<EOL>fmt.sep(<EOL>\"<STR_LIT:U+0020>\",<EOL>[<EOL>self._type_source,<EOL>\"<STR_LIT:to>\",<EOL>self._type_target,<EOL>'<STR_LIT:=>',<EOL>self._fun.to_fmt()<EOL>]<EOL>),<EOL>self._notify.get_content(with_from)<EOL>])<EOL>return txt<EOL>", "docstring": "Return a Fmt representation of Translator for pretty-printing", "id": "f4952:m3"}
{"signature": "def get_resolved_names(self, type_name: TypeName) -> list:", "body": "if not isinstance(type_name, TypeName):<EOL><INDENT>raise Exception(\"<STR_LIT>\"<EOL>% type(type_name))<EOL><DEDENT>rnames = []<EOL>for name in type_name.components:<EOL><INDENT>if name not in self.resolution:<EOL><INDENT>raise Exception(\"<STR_LIT>\" % name)<EOL><DEDENT>rname = self.resolution[name]<EOL>if rname is not None:<EOL><INDENT>rname = rname().show_name()<EOL><DEDENT>else:<EOL><INDENT>rname = name<EOL><DEDENT>rnames.append(rname)<EOL><DEDENT>return rnames<EOL>", "docstring": "Use self.resolution to subsitute type_name.\nAllow to instanciate polymorphic type ?1, ?toto", "id": "f4956:c0:m20"}
{"signature": "def set_parent(self, parent) -> object:", "body": "ret = self<EOL>if parent is not None:<EOL><INDENT>ret = self._sig.set_parent(parent)<EOL>self.resolve()<EOL><DEDENT>elif not hasattr(self, '<STR_LIT>'):<EOL><INDENT>self.parent = None<EOL><DEDENT>return ret<EOL>", "docstring": "When we add a parent (from Symbol), don't forget to resolve.", "id": "f4956:c0:m16"}
{"signature": "def use_variadic_types(self, list_type: [TypeName]):", "body": "self._variadic_types = list_type<EOL>self.resolve()<EOL>", "docstring": "Attach a list of types for extra variadic argument of a call", "id": "f4956:c0:m18"}
{"signature": "def set_parent(self, parent) -> object:", "body": "return self._sig.set_parent(parent)<EOL>", "docstring": "Forward to intern Signature", "id": "f4956:c0:m12"}
{"signature": "def internal_name(self):", "body": "unq = super().internal_name()<EOL>if self.tret is not None:<EOL><INDENT>unq += \"<STR_LIT:_>\" + self.tret<EOL><DEDENT>return unq<EOL>", "docstring": "Return the unique internal name", "id": "f4957:c0:m1"}
{"signature": "def __getstate__(self):", "body": "state = self.__dict__.copy()<EOL>del state['<STR_LIT>']<EOL>return state<EOL>", "docstring": "For pickle don't handle weakrefs...", "id": "f4959:c0:m1"}
{"signature": "def get_scope_list(self) -> list:", "body": "<EOL>lstparent = [self]<EOL>p = self.get_parent()<EOL>while p is not None:<EOL><INDENT>lstparent.append(p)<EOL>p = p.get_parent()<EOL><DEDENT>return lstparent<EOL>", "docstring": "Return the list of all contained scope from global to local", "id": "f4959:c0:m4"}
{"signature": "def internal_name(self) -> str:", "body": "unq = \"<STR_LIT:_>\".join(self.get_scope_names())<EOL>return unq<EOL>", "docstring": "Returns the namespace's internal_name.", "id": "f4959:c0:m7"}
{"signature": "def infer_block(self, body, diagnostic=None):", "body": "<EOL>for e in body:<EOL><INDENT>e.infer_node = InferNode(parent=self.infer_node)<EOL>e.infer_type(diagnostic=diagnostic)<EOL><DEDENT>", "docstring": "Infer type on block is to type each of is sub-element", "id": "f4960:c1:m3"}
{"signature": "def infer_subexpr(self, expr, diagnostic=None):", "body": "expr.infer_node = InferNode(parent=self.infer_node)<EOL>expr.infer_type(diagnostic=diagnostic)<EOL>", "docstring": "Infer type on the subexpr", "id": "f4960:c1:m4"}
{"signature": "def type_algos(self) -> ('<STR_LIT>',<EOL>'<STR_LIT>', ['<STR_LIT:args>']):", "body": "raise Exception((\"<STR_LIT>\" +<EOL>\"<STR_LIT>\" +<EOL>\"<STR_LIT>\") % type(self).__name__)<EOL>", "docstring": "Sub class must return a Tuple of 3 elements:\n    - the method to use to infer type.\n    - the list of params to used when infer a type.\n    - the method to use when feedback a type.\n\nThis is useful to connect AST members to generic algo or\nto overload some specific semantic for your language.", "id": "f4960:c1:m0"}
{"signature": "def __isub__(self, sig: Scope) -> Scope:", "body": "return self.difference_update(sig)<EOL>", "docstring": "-= operator", "id": "f4964:c1:m19"}
{"signature": "def symmetric_difference_update(self, oset: Scope) -> Scope:", "body": "skey = set()<EOL>keys = list(self._hsig.keys())<EOL>for k in keys:<EOL><INDENT>if k in oset:<EOL><INDENT>skey.add(k)<EOL><DEDENT><DEDENT>for k in oset._hsig.keys():<EOL><INDENT>if k not in skey:<EOL><INDENT>self._hsig[k] = oset.get(k)<EOL><DEDENT><DEDENT>for k in skey:<EOL><INDENT>del self._hsig[k]<EOL><DEDENT>return self<EOL>", "docstring": "Remove common values\n            and Update specific values from another Set", "id": "f4964:c1:m24"}
{"signature": "def union(self, sig: Scope) -> Scope:", "body": "new = Scope(sig=self._hsig.values(), state=self.state)<EOL>new |= sig<EOL>return new<EOL>", "docstring": "Create a new Set produce by the union of 2 Set", "id": "f4964:c1:m14"}
{"signature": "def __init__(self, name: str=None, sig: [Signature]=None,<EOL>state=StateScope.FREE, is_namespace=True):", "body": "if name is not None and not isinstance(name, str):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>super().__init__(name)<EOL>self.need_feedback = False<EOL>self.state = state<EOL>self.is_namespace = is_namespace<EOL>self.mapTypeTranslate = MapSourceTranslate()<EOL>self.astTranslatorInjector = None<EOL>self._ntypes = <NUM_LIT:0><EOL>self._nvars = <NUM_LIT:0><EOL>self._nfuns = <NUM_LIT:0><EOL>self._hsig = {}<EOL>if sig is not None:<EOL><INDENT>if isinstance(sig, Signature) or isinstance(sig, Scope):<EOL><INDENT>self.add(sig)<EOL><DEDENT>elif len(sig) > <NUM_LIT:0>:<EOL><INDENT>self.update(sig)<EOL><DEDENT><DEDENT>", "docstring": "Unnamed scope for global scope\n\n        A Scope have basically 3 possibles states:\n\n            FREE: it's a standalone Scope, generally the global Scope\n            LINKED: the Scope is related to another Scope for type resolution,\n                like compound statement\n            EMBEDDED: the Scope was added into another Scope,\n                it forwards all 'in' calls...like namespacing\n\n        A Scope could or couldn't act like a namespace.\n        All Signature added into a 'namespaced' Scope was prefixed\n        by the Scope name.", "id": "f4964:c1:m1"}
{"signature": "def __xor__(self, sig: Scope) -> Scope:", "body": "return self.symmetric_difference(sig)<EOL>", "docstring": "^ operator", "id": "f4964:c1:m25"}
{"signature": "def __repr__(self) -> str:", "body": "return repr(self._hsig)<EOL>", "docstring": "Internal representation", "id": "f4964:c1:m8"}
{"signature": "def values(self) -> [Signature]:", "body": "if self.state == StateScope.EMBEDDED and self.parent is not None:<EOL><INDENT>return list(self._hsig.values()) + list(self.parent().values())<EOL><DEDENT>else:<EOL><INDENT>return self._hsig.values()<EOL><DEDENT>", "docstring": "Retrieve all values", "id": "f4964:c1:m33"}
{"signature": "def get_all_polymorphic_return(self) -> bool:", "body": "lst = []<EOL>for s in self.values():<EOL><INDENT>if hasattr(s, '<STR_LIT>') and s.tret.is_polymorphic:<EOL><INDENT>lst.append(EvalCtx.from_sig(s))<EOL><DEDENT><DEDENT>rscope = Scope(sig=lst, state=StateScope.LINKED, is_namespace=False)<EOL>rscope.set_parent(self)<EOL>return rscope<EOL>", "docstring": "For now, polymorphic return type are handle by symbol artefact.\n\n        --> possible multi-polymorphic but with different constraint attached!", "id": "f4964:c1:m41"}
{"signature": "def __and__(self, sig: Scope) -> Scope:", "body": "return self.intersection(sig)<EOL>", "docstring": "& operator", "id": "f4964:c1:m17"}
{"signature": "def remove(self, it: Signature) -> bool:", "body": "txt = it.internal_name()<EOL>if txt not in self._hsig:<EOL><INDENT>raise KeyError(it.show_name() + '<STR_LIT>')<EOL><DEDENT>sig = self._hsig[txt]<EOL>if isinstance(sig, Scope):<EOL><INDENT>sig.state = StateScope.LINKED<EOL><DEDENT>del self._hsig[txt]<EOL>return True<EOL>", "docstring": "Remove it but raise KeyError if not found", "id": "f4964:c1:m28"}
{"signature": "def __contains__(self, s: Signature) -> bool:", "body": "<EOL>from pyrser.type_system.type import Type<EOL>found = False<EOL>txt = \"<STR_LIT>\"<EOL>if isinstance(s, Signature):<EOL><INDENT>txt = s.internal_name()<EOL><DEDENT>elif isinstance(s, Type):<EOL><INDENT>txt = s.type_name<EOL><DEDENT>elif isinstance(s, str):<EOL><INDENT>txt = s<EOL><DEDENT>found = (txt in self._hsig)<EOL>if not found and self.parent is not None:<EOL><INDENT>if self.state != StateScope.FREE and isinstance(s, Type):<EOL><INDENT>found = (s.type_name in self.parent())<EOL><DEDENT>if self.state == StateScope.EMBEDDED:<EOL><INDENT>found = (txt in self.parent())<EOL><DEDENT><DEDENT>return found<EOL>", "docstring": "check if a Signature or a Type is declared in a Scope", "id": "f4964:c1:m10"}
{"signature": "def add(self, it: Signature) -> bool:", "body": "if isinstance(it, Scope):<EOL><INDENT>it.state = StateScope.EMBEDDED<EOL><DEDENT>txt = it.internal_name()<EOL>it.set_parent(self)<EOL>if self.is_namespace:<EOL><INDENT>txt = it.internal_name()<EOL><DEDENT>if txt == \"<STR_LIT>\":<EOL><INDENT>txt = '<STR_LIT:_>' + str(len(self._hsig))<EOL><DEDENT>if txt in self._hsig:<EOL><INDENT>raise KeyError(\"<STR_LIT>\" % txt)<EOL><DEDENT>self._hsig[txt] = it<EOL>self.__update_count()<EOL>return True<EOL>", "docstring": "Add it to the Set", "id": "f4964:c1:m27"}
{"signature": "def __update_count(self):", "body": "self._ntypes = self.count_types()<EOL>self._nvars = self.count_vars()<EOL>self._nfuns = self.count_funs()<EOL>", "docstring": "Update internal counters", "id": "f4964:c1:m7"}
{"signature": "@meta.add_method(node.Node)<EOL>def to_yml(self):", "body": "pp = fmt.tab([])<EOL>to_yml_item(self, pp.lsdata, \"<STR_LIT>\")<EOL>return str(pp)<EOL>", "docstring": "Allow to get the YML string representation of a Node.::\n\n    from pyrser.passes import to_yml\n\n    t = Node()\n    ...\n    print(str(t.to_yml()))", "id": "f4967:m0"}
{"signature": "def visit_Seq(self, node: parsing.Seq) -> [ast.stmt] or ast.expr:", "body": "exprs, stmts = [], []<EOL>for clause in node.ptlist:<EOL><INDENT>clause_ast = self.visit(clause)<EOL>if isinstance(clause_ast, ast.expr):<EOL><INDENT>exprs.append(clause_ast)<EOL><DEDENT>else:<EOL><INDENT>if exprs:<EOL><INDENT>stmts.extend(self.combine_exprs_for_clauses(exprs))<EOL>exprs = []<EOL><DEDENT>stmts.extend(self._clause(clause_ast))<EOL><DEDENT><DEDENT>if not stmts:<EOL><INDENT>return ast.BoolOp(ast.And(), exprs)<EOL><DEDENT>if exprs:<EOL><INDENT>stmts.extend(self.combine_exprs_for_clauses(exprs))<EOL><DEDENT>return stmts<EOL>", "docstring": "Generates python code for clauses.\n\n        #Continuous clauses which can can be inlined are combined with and\n        clause and clause\n\n        if not clause:\n            return False\n        if not clause:\n            return False", "id": "f4969:c0:m12"}
{"signature": "def __exit_scope(self) -> ast.stmt:", "body": "if self.in_optional:<EOL><INDENT>return ast.Pass()<EOL><DEDENT>if self.in_try:<EOL><INDENT>return ast.Raise(<EOL>ast.Call(ast.Name('<STR_LIT>', ast.Load()), [], [], None, None),<EOL>None)<EOL><DEDENT>if self.in_loop:<EOL><INDENT>return ast.Break()<EOL><DEDENT>return ast.Return(ast.Name('<STR_LIT:False>', ast.Load()))<EOL>", "docstring": "Create the appropriate scope exiting statement.\n\n        The documentation only shows one level and always uses\n        'return False' in examples.\n\n        'raise AltFalse()' within a try.\n        'break' within a loop.\n        'return False' otherwise.", "id": "f4969:c0:m2"}
{"signature": "def visit_CallTrue(self, node: parsing.CallTrue) -> ast.expr:", "body": "return ast.Lambda(<EOL>ast.arguments([], None, None, [], None, None, [], []),<EOL>ast.BoolOp(<EOL>ast.Or(),<EOL>[<EOL>self.visit_Call(node),<EOL>ast.Name('<STR_LIT:True>', ast.Load())]))<EOL>", "docstring": "Generates python code calling the function and returning True.\n\n        lambda: fn(*args) or True", "id": "f4969:c0:m5"}
{"signature": "def visit_Call(self, node: parsing.Call) -> ast.expr:", "body": "return ast.Call(<EOL>ast.Attribute(<EOL>ast.Name('<STR_LIT>', ast.Load),<EOL>node.callObject.__name__,<EOL>ast.Load()),<EOL>[ast.Str(param) for param in node.params],<EOL>[],<EOL>None,<EOL>None)<EOL>", "docstring": "Generates python code calling the function.\n\n        fn(*args)", "id": "f4969:c0:m4"}
{"signature": "def visit_Rule(self, node: parsing.Rule) -> ast.expr:", "body": "return ast.Call(<EOL>ast.Attribute(ast.Name('<STR_LIT>', ast.Load()),<EOL>'<STR_LIT>', ast.Load()),<EOL>[ast.Str(node.name)], [], None, None)<EOL>", "docstring": "Generates python code calling a rule.\n\n        self.evalRule('rulename')", "id": "f4969:c0:m7"}
{"signature": "def visit_Rep1N(self, node: parsing.Rep0N) -> [ast.stmt]:", "body": "clause = self.visit(node.pt)<EOL>if isinstance(clause, ast.expr):<EOL><INDENT>return (self._clause(clause) + self.visit_Rep0N(node))<EOL><DEDENT>self.in_loop += <NUM_LIT:1><EOL>clause = self._clause(self.visit(node.pt))<EOL>self.in_loop -= <NUM_LIT:1><EOL>return self._clause(self.visit(node.pt)) + [<EOL>ast.While(ast.Name('<STR_LIT:True>', ast.Load()), clause, [])]<EOL>", "docstring": "Generates python code for a clause repeated 1 or more times.\n\n        <code for the clause>\n        while True:\n            <code for the clause>", "id": "f4969:c0:m15"}
{"signature": "def parse_attrs(self, tag):", "body": "if tag.name in ATTR_WHITELIST.keys():<EOL><INDENT>attrs = copy(tag.attrs)<EOL>for attr, value in attrs.items():<EOL><INDENT>if attr in ATTR_WHITELIST[tag.name]:<EOL><INDENT>tag.attrs[attr] = self._parse_attr(tag.name, attr, value)<EOL><DEDENT>else:<EOL><INDENT>del tag.attrs[attr]<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>tag.attrs = {}<EOL><DEDENT>", "docstring": "Reject attributes not defined in ATTR_WHITELIST.", "id": "f4980:c0:m9"}
{"signature": "def remove_comments(self, tag):", "body": "if tag.get('<STR_LIT:id>', '<STR_LIT>').startswith('<STR_LIT>'):<EOL><INDENT>tag.parent.extract()<EOL><DEDENT>", "docstring": "Remove comments.", "id": "f4980:c0:m2"}
{"signature": "def unwrap_span(self, tag):", "body": "tag.unwrap()<EOL>", "docstring": "Remove span tags while preserving contents.", "id": "f4980:c0:m8"}
{"signature": "def create_italic(self, tag):", "body": "style = tag.get('<STR_LIT>')<EOL>if style and '<STR_LIT>' in style:<EOL><INDENT>tag.wrap(self.soup.new_tag('<STR_LIT>'))<EOL><DEDENT>", "docstring": "See if span tag has italic style and wrap with em tag.", "id": "f4980:c0:m5"}
{"signature": "def _parse_attr(self, tagname, attr, value):", "body": "if tagname == '<STR_LIT:a>' and attr == '<STR_LIT>':<EOL><INDENT>return self._parse_href(value)<EOL><DEDENT>else:<EOL><INDENT>return value<EOL><DEDENT>", "docstring": "Parse attribute. Delegate to href parser for hrefs, otherwise return\nvalue.", "id": "f4980:c0:m15"}
{"signature": "@injector_pointer<EOL>def zprTYSyMkLEC():", "body": "pkg = Package(\"<STR_LIT>\")<EOL>class Container(Injector):<EOL><INDENT>foo = pkg.injected.Container.foo<EOL>bar = pkg.injected.Container.bar<EOL>baz = <NUM_LIT:2><EOL><DEDENT>return Container<EOL>", "docstring": "Attribute access submodule.", "id": "f5017:m9"}
{"signature": "@package_definitions<EOL>def uHSfYcZjGSJQ():", "body": "pkg = Package(\"<STR_LIT>\")<EOL>sub = Package(\"<STR_LIT>\")<EOL>class Container(Injector):<EOL><INDENT>itself = pkg<EOL>submodule = sub<EOL>instance = sub.Bar<EOL>instance_method = sub.Bar.do<EOL>function = sub.function<EOL>variable = sub.variable<EOL>keep_class = sub.Bar<EOL>a = -<NUM_LIT:1><EOL>b = <NUM_LIT:2><EOL><DEDENT>return Container<EOL>", "docstring": "Constructor argument submodule.", "id": "f5017:m7"}
{"signature": "@injector_pointer<EOL>def dqXJgFoftQja():", "body": "injected = Package(\"<STR_LIT>\")<EOL>class Container(Injector):<EOL><INDENT>foo = injected.Container.foo<EOL>bar = injected.Container.bar<EOL>baz = <NUM_LIT:2><EOL><DEDENT>return Container<EOL>", "docstring": "Constructor argument submodule.", "id": "f5017:m10"}
{"signature": "@item_access<EOL>def dc4fedcd09d8():", "body": "class Container(Injector):<EOL><INDENT>foo = {(\"<STR_LIT:x>\", <NUM_LIT:1>): <NUM_LIT:1>}<EOL>bar = this.foo[(\"<STR_LIT:x>\", <NUM_LIT:1>)]<EOL><DEDENT>result = Container.bar<EOL>return result<EOL>", "docstring": "Get items from dict with tuple keys.", "id": "f5019:m9"}
{"signature": "@too_many<EOL>def rN3suiVzhqMM():", "body": "Injector.let(SubContainer=Injector.let(foo=(this << <NUM_LIT:2>).bar)).SubContainer.foo<EOL>", "docstring": "Let notation with nested layer.", "id": "f5019:m29"}
{"signature": "@too_many<EOL>def ww6xNI4YrNr6():", "body": "Injector.let(foo=(this << <NUM_LIT:1>).bar).foo<EOL>", "docstring": "Let notation.", "id": "f5019:m28"}
{"signature": "@call.xfail<EOL>def zVaXyVseCxYS():", "body": "class Container(Injector):<EOL><INDENT>foo = this.bar()<EOL>bar = lambda: <NUM_LIT:1>  <EOL><DEDENT>return Container<EOL>", "docstring": "Attribute call.", "id": "f5019:m11"}
{"signature": "@item_access<EOL>def ab4cdbf60b2f():", "body": "class Container(Injector):<EOL><INDENT>foo = {\"<STR_LIT:bar>\": {\"<STR_LIT>\": <NUM_LIT:1>}}<EOL>class SubContainer(Injector):<EOL><INDENT>class SubSubContainer(Injector):<EOL><INDENT>spam = (this << <NUM_LIT:2>).foo[\"<STR_LIT:bar>\"][\"<STR_LIT>\"]<EOL><DEDENT><DEDENT><DEDENT>result = Container.SubContainer.SubSubContainer.spam<EOL>return result<EOL>", "docstring": "Get item from the outer container of any depth level.", "id": "f5019:m6"}
{"signature": "@attribute_error<EOL>def t1jn9RI9v42t():", "body": "class Container(Injector):<EOL><INDENT>foo = this.bar<EOL><DEDENT>Container.foo<EOL>", "docstring": "Declarative Injector.", "id": "f5019:m31"}
{"signature": "@negative_integers<EOL>def nvm3ybp98vGm():", "body": "this << <NUM_LIT:0><EOL>", "docstring": "Zero.", "id": "f5019:m24"}
{"signature": "@containers<EOL>def xPa7isagt3Lq(app):", "body": "@contrib.shared_task<EOL>class Container(Injector):<EOL><INDENT>name = \"<STR_LIT>\"<EOL>run = Run<EOL><DEDENT>return Container<EOL>", "docstring": "Shared task decorator.", "id": "f5020:m2"}
{"signature": "@make_signature<EOL>def u4kZae2NSFhE(container):", "body": "class NewContainer(container):<EOL><INDENT>options = {\"<STR_LIT>\": <NUM_LIT:10>}<EOL><DEDENT>sign = NewContainer.si(<NUM_LIT:2>, <NUM_LIT:2>, debug=True)<EOL>return sign<EOL>", "docstring": "Immutable shortcut signature.", "id": "f5020:m13"}
{"signature": "@make_signature<EOL>def cgTE4xh2ZSVI(container):", "body": "sign = container.signature((<NUM_LIT:2>, <NUM_LIT:2>), {\"<STR_LIT>\": True}, immutable=True, countdown=<NUM_LIT:10>)<EOL>return sign<EOL>", "docstring": "Verbose signature.", "id": "f5020:m8"}
{"signature": "@lowest_container<EOL>def heSHjuBBFVLp():", "body": "return Injector.let(bar=(this << <NUM_LIT:2>).foo)<EOL>", "docstring": "Let notation.", "id": "f5022:m12"}
{"signature": "@subcontainer<EOL>def iGphUpthTooT():", "body": "class SubContainer(Injector):<EOL><INDENT>bar = (this << <NUM_LIT:1>).foo<EOL><DEDENT>return SubContainer<EOL>", "docstring": "Declarative injector.", "id": "f5022:m3"}
{"signature": "@attribute_assignment<EOL>def pHfF0rbEjCsV():", "body": "Container = Injector.let()<EOL>Container.foo = <NUM_LIT:1><EOL>", "docstring": "Let notation.", "id": "f5023:m25"}
{"signature": "@attribute_error<EOL>def e2f16596a652():", "body": "class Foo(Injector):<EOL><INDENT>pass<EOL><DEDENT>Foo.let().test<EOL>", "docstring": "Let notation from subclass.", "id": "f5023:m50"}
{"signature": "@inheritance_order<EOL>def aa10c7747a1f(Container1, Container2, Container3):", "body": "class Foo(Container1, Container2, Container3):<EOL><INDENT>pass<EOL><DEDENT>assert Foo.x == <NUM_LIT:1><EOL>", "docstring": "Inheritance.", "id": "f5023:m38"}
{"signature": "@deny_kwargs<EOL>def e281099be65d(Foo):", "body": "class Summator(Injector):<EOL><INDENT>foo = Foo<EOL>kwargs = {\"<STR_LIT:start>\": <NUM_LIT:5>}<EOL><DEDENT>", "docstring": "Declarative injector.", "id": "f5023:m61"}
{"signature": "@deny_varargs<EOL>def f7ef2aa82c18(Foo):", "body": "Injector.let(foo=Foo, args=(<NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:3>))<EOL>", "docstring": "Let notation.", "id": "f5023:m59"}
{"signature": "@has_attribute<EOL>def zlZoLka31ndk():", "body": "return Injector.let(foo=<NUM_LIT:1>)<EOL>", "docstring": "Let notation.", "id": "f5023:m56"}
{"signature": "@attribute_error<EOL>def f9c50c81e8c9():", "body": "Foo = Injector.let()<EOL>Foo.test<EOL>", "docstring": "Let notation.", "id": "f5023:m49"}
{"signature": "@attribute_assignment<EOL>def tQeRzD5ZsyTm():", "body": "del Injector.let<EOL>", "docstring": "Delete attribute from `Injector` directly.", "id": "f5023:m28"}
{"signature": "@deny_varargs_kwargs<EOL>def c4362558f312(Foo):", "body": "Injector.let(foo=Foo, args=(<NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:3>), kwargs={\"<STR_LIT:start>\": <NUM_LIT:5>})<EOL>", "docstring": "Let notation.", "id": "f5023:m65"}
{"signature": "@multiple_inheritance<EOL>def efdc426cd096(Foo, FooContainer, BarContainer, BazContainer):", "body": "assert isinstance((FooContainer & BarContainer & BazContainer).baz.bar.foo, Foo)<EOL>", "docstring": "Inplace creation.", "id": "f5023:m36"}
{"signature": "@incomplete_dependencies<EOL>def c4e7ecf75167():", "body": "class Bar(object):<EOL><INDENT>def __init__(self, test, two=<NUM_LIT:2>):<EOL><INDENT>self.test = test<EOL>self.two = two<EOL><DEDENT><DEDENT>class Foo(Injector):<EOL><INDENT>bar = Bar<EOL><DEDENT>Foo.bar<EOL>", "docstring": "Keyword arguments in the constructor.", "id": "f5023:m52"}
{"signature": "@cls_named_arguments<EOL>def dad79637580d(Foo, Bar):", "body": "class Container(Injector):<EOL><INDENT>bar = Bar<EOL><DEDENT>", "docstring": "Declarative injector.", "id": "f5023:m75"}
{"signature": "@deny_call<EOL>def a95940f44400():", "body": "class Foo(Injector):<EOL><INDENT>pass<EOL><DEDENT>Foo()<EOL>", "docstring": "Subclass call.", "id": "f5023:m71"}
{"signature": "@deny_call<EOL>def ce52d740af31():", "body": "Injector()<EOL>", "docstring": "Direct call.", "id": "f5023:m70"}
{"signature": "@long_lowest_container<EOL>def qRcNcKzedWaI():", "body": "class SubSubContainer(Injector):<EOL><INDENT>bar = (this << <NUM_LIT:2>).foo<EOL><DEDENT>return SubSubContainer<EOL>", "docstring": "Declarative injector.", "id": "f5024:m26"}
{"signature": "@long_two_levels<EOL>def eHyErh9kExHG(middle):", "body": "class Container(Injector):<EOL><INDENT>foo = this.SubContainer.baz<EOL>SubContainer = middle<EOL><DEDENT>Container.foo<EOL>", "docstring": "Declarative injector.", "id": "f5024:m22"}
{"signature": "@flat_injector<EOL>def n8NHZqiZN43Q():", "body": "Injector.let(foo=this.foo).foo<EOL>", "docstring": "Let notation.  Link to self.", "id": "f5024:m2"}
{"signature": "@subcontainer<EOL>def nFibPCOxGsrX():", "body": "return Injector.let(bar=(this << <NUM_LIT:1>).foo)<EOL>", "docstring": "Let notation.", "id": "f5024:m11"}
{"signature": "@complex_two_levels<EOL>def bCw8LPUeVK6J(middle):", "body": "Injector.let(foo=this.SubContainer.SubSubContainer.bar, SubContainer=middle).foo<EOL>", "docstring": "Let notation.", "id": "f5024:m15"}
{"signature": "@items.xfail  <EOL>def t41yMywZuPhA():", "body": "SubContainer = Injector.let(foo=(this << <NUM_LIT:1>).bar[\"<STR_LIT>\"].foo)<EOL>Injector.let(SubContainer=SubContainer, bar={\"<STR_LIT>\": SubContainer}).SubContainer.foo<EOL>", "docstring": "Let notation.", "id": "f5024:m40"}
{"signature": "@subcontainer2<EOL>def rRsNsCaBSxke():", "body": "return Injector.let(baz=(this << <NUM_LIT:1>).SubContainer1.bar)<EOL>", "docstring": "Let notation.", "id": "f5024:m36"}
{"signature": "@complex_lowest_container<EOL>def epoadTufdhne():", "body": "pkg = Package(\"<STR_LIT>\")<EOL>return pkg.injected.SubSubContainer<EOL>", "docstring": "Package link.", "id": "f5024:m20"}
{"signature": "@flat_injector<EOL>def ySnRrxW6M79T():", "body": "Injector.let(foo=this.bar, bar=this.foo).foo<EOL>", "docstring": "Let notation.  Complex loop.", "id": "f5024:m4"}
{"signature": "@deny_kwargs<EOL>def puELUDZLxkDG(arg):", "body": "class Container(Injector):<EOL><INDENT>func = arg<EOL><DEDENT>", "docstring": "Declarative injector.", "id": "f5026:m7"}
{"signature": "@complex_circle_deps<EOL>def d9c4e136c92c(Foo, Bar):", "body": "class First(Injector):<EOL><INDENT>foo = Foo<EOL><DEDENT>class Second(First):<EOL><INDENT>bar = Bar<EOL><DEDENT>Second.foo<EOL>", "docstring": "Declarative injector with inheritance.", "id": "f5028:m11"}
{"signature": "@circle_defs<EOL>def kHqAxHovWKtI():", "body": "@value<EOL>def Foo(foo):<EOL><INDENT>pass<EOL><DEDENT>return Foo<EOL>", "docstring": "Value.", "id": "f5028:m5"}
{"signature": "@complex_circle_deps<EOL>def b54832f696e9(Foo, Bar):", "body": "Summator = Injector.let(foo=Foo, bar=Bar)<EOL>Summator.foo<EOL>", "docstring": "Let notation.", "id": "f5028:m12"}
{"signature": "@long_circle_defs_baz<EOL>def uaOWixpAMVma():", "body": "class Baz(object):<EOL><INDENT>def __init__(self, foo):<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return Baz<EOL>", "docstring": "Class.", "id": "f5028:m43"}
{"signature": "@long_circle_defs_bar<EOL>def hpRbxUtEWyGJ():", "body": "@operation<EOL>def Bar(baz):<EOL><INDENT>pass<EOL><DEDENT>return Bar<EOL>", "docstring": "Operation.", "id": "f5028:m38"}
{"signature": "@long_circle_defs_baz<EOL>def fvMICnYvGZlw():", "body": "@operation<EOL>def Baz(foo):<EOL><INDENT>pass<EOL><DEDENT>return Baz<EOL>", "docstring": "Operation.", "id": "f5028:m44"}
{"signature": "@complex_circle_defs_foo<EOL>def fkedDYYeueXo():", "body": "pkg = Package(\"<STR_LIT>\")<EOL>return pkg.circles.complex_value.Foo<EOL>", "docstring": "Package link to value.", "id": "f5028:m19"}
{"signature": "@circle_defs<EOL>def xoGkuXokhXpZ():", "body": "pkg = Package(\"<STR_LIT>\")<EOL>return pkg.circles.simple_class.Foo<EOL>", "docstring": "Package link to class.", "id": "f5028:m6"}
{"signature": "@circle_deps<EOL>def e4b38a38de7e(Foo):", "body": "Summator = Injector.let(foo=Foo)<EOL>Summator.foo<EOL>", "docstring": "Let notation.", "id": "f5028:m2"}
{"signature": "@complex_circle_defs_bar<EOL>def uEevbDxHVHfN():", "body": "class Bar(object):<EOL><INDENT>def __init__(self, foo):<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return Bar<EOL>", "docstring": "Class.", "id": "f5028:m20"}
{"signature": "@complex_circle_defs_bar<EOL>def trvcvfPoOBEv():", "body": "pkg = Package(\"<STR_LIT>\")<EOL>return pkg.circles.complex_class.Bar<EOL>", "docstring": "Package link to class.", "id": "f5028:m23"}
{"signature": "@long_circle_defs_bar<EOL>def mLsXYSzlYPRO():", "body": "@value<EOL>def Bar(baz):<EOL><INDENT>pass<EOL><DEDENT>return Bar<EOL>", "docstring": "Value.", "id": "f5028:m39"}
{"signature": "@circle_defs<EOL>def gjhRaqkLmRmy():", "body": "@operation<EOL>def Foo(foo):<EOL><INDENT>pass<EOL><DEDENT>return Foo<EOL>", "docstring": "Operation.", "id": "f5028:m4"}
{"signature": "@long_circle_deps<EOL>def fc13db5b9fda(Foo, Bar, Baz):", "body": "class First(Injector):<EOL><INDENT>foo = Foo<EOL><DEDENT>class Second(First):<EOL><INDENT>bar = Bar<EOL>baz = Baz<EOL><DEDENT>Second.foo<EOL>", "docstring": "Declarative injector with inheritance.", "id": "f5028:m28"}
{"signature": "@deny_kwargs<EOL>def jbfjlQveNjrZ(arg):", "body": "Injector.let(func=arg)<EOL>", "docstring": "Let notation.", "id": "f5029:m8"}
{"signature": "def register(injector):", "body": "if \"<STR_LIT>\" not in injector:<EOL><INDENT>injector.fixture<EOL><DEDENT>options = {\"<STR_LIT:name>\": injector.name}<EOL>for option in [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>if option in injector:<EOL><INDENT>options[option] = getattr(injector, option)<EOL><DEDENT><DEDENT>@pytest.fixture(**options)<EOL>def __fixture(request):<EOL><INDENT>return injector.let(request=request).fixture<EOL><DEDENT>__fixture.injector = injector<EOL>return __fixture<EOL>", "docstring": "Register Py.test fixture performing injection in it's scope.", "id": "f5031:m0"}
{"signature": "def api_view(injector):", "body": "handler = create_handler(APIView, injector)<EOL>apply_http_methods(handler, injector)<EOL>apply_api_view_methods(handler, injector)<EOL>return injector.let(as_view=handler.as_view)<EOL>", "docstring": "Create DRF class-based API view from injector class.", "id": "f5038:m0"}
{"signature": "def model_view_set(injector):", "body": "handler = create_handler(ModelViewSet, injector)<EOL>apply_api_view_methods(handler, injector)<EOL>apply_generic_api_view_methods(handler, injector)<EOL>apply_model_view_set_methods(handler, injector)<EOL>return injector.let(as_viewset=lambda: handler)<EOL>", "docstring": "Create DRF model view set from injector class.", "id": "f5038:m2"}
{"signature": "@classmethod<EOL>def let(cls, **kwargs):", "body": "return type(cls.__name__, (cls,), kwargs)<EOL>", "docstring": "Produce new Injector with some dependencies overwritten.", "id": "f5054:m1"}
{"signature": "def _get_ngrams(n, text):", "body": "ngram_set = set()<EOL>text_length = len(text)<EOL>max_index_ngram_start = text_length - n<EOL>for i in range(max_index_ngram_start + <NUM_LIT:1>):<EOL><INDENT>ngram_set.add(tuple(text[i:i + n]))<EOL><DEDENT>return ngram_set<EOL>", "docstring": "Calcualtes n-grams.\n\n    Args:\n      n: which n-grams to calculate\n      text: An array of tokens\n\n    Returns:\n      A set of n-grams", "id": "f5065:m0"}
{"signature": "def rouge_l_summary_level(evaluated_sentences, reference_sentences):", "body": "if len(evaluated_sentences) <= <NUM_LIT:0> or len(reference_sentences) <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>m = len(set(_split_into_words(reference_sentences)))<EOL>n = len(set(_split_into_words(evaluated_sentences)))<EOL>union_lcs_sum_across_all_references = <NUM_LIT:0><EOL>union = set()<EOL>for ref_s in reference_sentences:<EOL><INDENT>lcs_count, union = _union_lcs(evaluated_sentences,<EOL>ref_s,<EOL>prev_union=union)<EOL>union_lcs_sum_across_all_references += lcs_count<EOL><DEDENT>llcs = union_lcs_sum_across_all_references<EOL>r_lcs = llcs / m<EOL>p_lcs = llcs / n<EOL>beta = p_lcs / (r_lcs + <NUM_LIT>)<EOL>num = (<NUM_LIT:1> + (beta**<NUM_LIT:2>)) * r_lcs * p_lcs<EOL>denom = r_lcs + ((beta**<NUM_LIT:2>) * p_lcs)<EOL>f_lcs = num / (denom + <NUM_LIT>)<EOL>return {\"<STR_LIT:f>\": f_lcs, \"<STR_LIT:p>\": p_lcs, \"<STR_LIT:r>\": r_lcs}<EOL>", "docstring": "Computes ROUGE-L (summary level) of two text collections of sentences.\nhttp://research.microsoft.com/en-us/um/people/cyl/download/papers/\nrouge-working-note-v1.3.1.pdf\n\nCalculated according to:\nR_lcs = SUM(1, u)[LCS<union>(r_i,C)]/m\nP_lcs = SUM(1, u)[LCS<union>(r_i,C)]/n\nF_lcs = ((1 + beta^2)*R_lcs*P_lcs) / (R_lcs + (beta^2) * P_lcs)\n\nwhere:\nSUM(i,u) = SUM from i through u\nu = number of sentences in reference summary\nC = Candidate summary made up of v sentences\nm = number of words in reference summary\nn = number of words in candidate summary\n\nArgs:\n  evaluated_sentences: The sentences that have been picked by the\n                       summarizer\n  reference_sentence: One of the sentences in the reference summaries\n\nReturns:\n  A float: F_lcs\n\nRaises:\n  ValueError: raises exception if a param has len <= 0", "id": "f5065:m10"}
{"signature": "def _union_lcs(evaluated_sentences, reference_sentence, prev_union=None):", "body": "if prev_union is None:<EOL><INDENT>prev_union = set()<EOL><DEDENT>if len(evaluated_sentences) <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>lcs_union = prev_union<EOL>prev_count = len(prev_union)<EOL>reference_words = _split_into_words([reference_sentence])<EOL>combined_lcs_length = <NUM_LIT:0><EOL>for eval_s in evaluated_sentences:<EOL><INDENT>evaluated_words = _split_into_words([eval_s])<EOL>lcs = set(_recon_lcs(reference_words, evaluated_words))<EOL>combined_lcs_length += len(lcs)<EOL>lcs_union = lcs_union.union(lcs)<EOL><DEDENT>new_lcs_count = len(lcs_union) - prev_count<EOL>return new_lcs_count, lcs_union<EOL>", "docstring": "Returns LCS_u(r_i, C) which is the LCS score of the union longest common\nsubsequence between reference sentence ri and candidate summary C.\nFor example:\nif r_i= w1 w2 w3 w4 w5, and C contains two sentences: c1 = w1 w2 w6 w7 w8\nand c2 = w1 w3 w8 w9 w5, then the longest common subsequence of r_i and c1\nis \"w1 w2\" and the longest common subsequence of r_i and c2 is \"w1 w3 w5\".\nThe union longest common subsequence of r_i, c1, and c2 is \"w1 w2 w3 w5\"\nand LCS_u(r_i, C) = 4/5.\n\nArgs:\n  evaluated_sentences: The sentences that have been picked by the\n                       summarizer\n  reference_sentence: One of the sentences in the reference summaries\n\nReturns:\n  float: LCS_u(r_i, C)\n\nValueError:\n  Raises exception if a param has len <= 0", "id": "f5065:m9"}
{"signature": "def add_path(self, path):", "body": "if path not in self.paths:<EOL><INDENT>self.paths.append(path)<EOL><DEDENT>", "docstring": "Adds a path to search through when attempting to look up a module.\n\n:param path: the path the add to the list of searchable paths", "id": "f5080:c2:m1"}
{"signature": "def load_module(self, module_name):", "body": "if module_name != self.module_name:<EOL><INDENT>raise LoaderError(<EOL>'<STR_LIT>')<EOL><DEDENT>if module_name in sys.modules:<EOL><INDENT>return sys.modules[module_name]<EOL><DEDENT>module = self.load_module_py_path(module_name, self.load_target)<EOL>if self.is_pkg:<EOL><INDENT>module.__path__ = [self.module_path]<EOL>module.__package__ = module_name<EOL><DEDENT>else:<EOL><INDENT>module.__package__ = module_name.rpartition('<STR_LIT:.>')[<NUM_LIT:0>]<EOL><DEDENT>sys.modules[module_name] = module<EOL>return module<EOL>", "docstring": "Loads a module's code and sets the module's expected hidden\nvariables. For more information on these variables and what they\nare for, please see PEP302.\n\n:param module_name: the full name of the module to load", "id": "f5080:c1:m2"}
{"signature": "def rlist_modules(mname):", "body": "module = import_module(mname)<EOL>if not module:<EOL><INDENT>raise ImportError('<STR_LIT>'.format(mname))<EOL><DEDENT>found = list()<EOL>if _should_use_module_path(module):<EOL><INDENT>mpath = module.__path__[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>mpaths = sys.path<EOL>mpath = _scan_paths_for(mname, mpaths)<EOL><DEDENT>if mpath:<EOL><INDENT>for pmname in _search_for_modules(mpath, recursive=True):<EOL><INDENT>found_mod = MODULE_PATH_SEP.join((mname, pmname))<EOL>found.append(found_mod)<EOL><DEDENT><DEDENT>return found<EOL>", "docstring": "Attempts to the submodules under a module recursively. This function\nworks for modules located in the default path as well as extended paths\nvia the sys.meta_path hooks.\n\nThis function carries the expectation that the hidden module variable\n'__path__' has been set correctly.\n\n:param mname: the module name to descend into", "id": "f5084:m8"}
{"signature": "def rlist_classes(module, cls_filter=None):", "body": "found = list()<EOL>mnames = rlist_modules(module)<EOL>for mname in mnames:<EOL><INDENT>[found.append(c) for c in list_classes(mname, cls_filter)]<EOL><DEDENT>return found<EOL>", "docstring": "Attempts to list all of the classes within a given module namespace.\nThis method, unlike list_classes, will recurse into discovered\nsubmodules.\n\nIf a type filter is set, it will be called with each class as its\nparameter. This filter's return value must be interpretable as a\nboolean. Results that evaluate as True will include the type in the\nlist of returned classes. Results that evaluate as False will exclude\nthe type in the list of returned classes.\n\n:param mname: of the module to descend into\n:param cls_filter: a function to call to determine what classes should be\n            included.", "id": "f5084:m10"}
{"signature": "def rdiscover_modules(directory):", "body": "found = list()<EOL>if os.path.isdir(directory):<EOL><INDENT>for entry in os.listdir(directory):<EOL><INDENT>next_dir = os.path.join(directory, entry)<EOL>if os.path.isfile(os.path.join(next_dir, MODULE_INIT_FILE)):<EOL><INDENT>modules = _search_for_modules(next_dir, True, entry)<EOL>found.extend(modules)<EOL><DEDENT><DEDENT><DEDENT>return found<EOL>", "docstring": "Attempts to list all of the modules and submodules found within a given\ndirectory tree. This function recursively searches the directory tree\nfor potential python modules and returns a list of candidate names.\n\n**Note:** This function returns a list of strings representing\ndiscovered module names, not the actual, loaded modules.\n\n:param directory: the directory to search for modules.", "id": "f5084:m6"}
{"signature": "def mapk(actual, predicted, k=<NUM_LIT:10>):", "body": "return np.mean([apk(a,p,k) for a,p in zip(actual, predicted)])<EOL>", "docstring": "Computes the mean average precision at k.\n\nThis function computes the mean average prescision at k between two lists\nof lists of items.\n\nParameters\n----------\nactual : list\n         A list of lists of elements that are to be predicted \n         (order doesn't matter in the lists)\npredicted : list\n            A list of lists of predicted elements\n            (order matters in the lists)\nk : int, optional\n    The maximum number of predicted elements\n\nReturns\n-------\nscore : double\n        The mean average precision at k over the input lists", "id": "f5091:m1"}
{"signature": "def clear(self):", "body": "self.reg = np.zeros((self.m,), dtype=np.int8)<EOL>", "docstring": "Reset the current HyperLogLog to empty.", "id": "f5103:c0:m8"}
{"signature": "def is_empty(self):", "body": "if np.any(self.reg):<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "Returns:\n    bool: True if the current HyperLogLog is empty - at the state of just\n    initialized.", "id": "f5103:c0:m7"}
{"signature": "def __eq__(self, other):", "body": "return type(self) is type(other) andself.seed == other.seed andnp.array_equal(self.hashvalues, other.hashvalues)<EOL>", "docstring": "Returns:\n    bool: If their seeds and hash values are both equal then two\n    are equivalent.", "id": "f5104:c0:m5"}
{"signature": "def copy(self):", "body": "return WeightedMinHash(self.seed, self.digest())<EOL>", "docstring": "Returns:\n    datasketch.WeightedMinHash: A copy of this weighted MinHash by exporting \n    its state.", "id": "f5104:c0:m3"}
{"signature": "def jaccard(self, other):", "body": "if other.seed != self.seed:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if len(self) != len(other):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>intersection = <NUM_LIT:0><EOL>for this, that in zip(self.hashvalues, other.hashvalues):<EOL><INDENT>if np.array_equal(this, that):<EOL><INDENT>intersection += <NUM_LIT:1><EOL><DEDENT><DEDENT>return float(intersection) / float(len(self))<EOL>", "docstring": "Estimate the `weighted Jaccard similarity`_ between the\n        multi-sets represented by this weighted MinHash and the other.\n\n        Args:\n            other (datasketch.WeightedMinHash): The other weighted MinHash.\n\n        Returns:\n            float: The weighted Jaccard similarity between 0.0 and 1.0.\n\n        .. _`weighted Jaccard similarity`: http://mathoverflow.net/questions/123339/weighted-jaccard-similarity", "id": "f5104:c0:m1"}
{"signature": "def remove(self, key):", "body": "if self.prepickle:<EOL><INDENT>key = pickle.dumps(key)<EOL><DEDENT>if key not in self.keys:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>for H, hashtable in zip(self.keys[key], self.hashtables):<EOL><INDENT>hashtable.remove_val(H, key)<EOL>if not hashtable.get(H):<EOL><INDENT>hashtable.remove(H)<EOL><DEDENT><DEDENT>self.keys.remove(key)<EOL>", "docstring": "Remove the key from the index.\n\nArgs:\n    key (hashable): The unique identifier of a set.", "id": "f5105:c0:m8"}
{"signature": "def get_counts(self):", "body": "counts = [<EOL>hashtable.itemcounts() for hashtable in self.hashtables]<EOL>return counts<EOL>", "docstring": "Returns a list of length ``self.b`` with elements representing the\nnumber of keys stored under each bucket for the given permutation.", "id": "f5105:c0:m12"}
{"signature": "async def get_subset_counts(self, *keys):", "body": "key_set = list(set(keys))<EOL>hashtables = [unordered_storage({'<STR_LIT:type>': '<STR_LIT>'}) for _ in range(self.b)]<EOL>Hss = await self.keys.getmany(*key_set)<EOL>for key, Hs in zip(key_set, Hss):<EOL><INDENT>for H, hashtable in zip(Hs, hashtables):<EOL><INDENT>hashtable.insert(H, key)<EOL><DEDENT><DEDENT>return [hashtable.itemcounts() for hashtable in hashtables]<EOL>", "docstring": "see :class:`datasketch.MinHashLSH`.", "id": "f5107:c0:m24"}
{"signature": "async def remove(self, key):", "body": "await self._remove(key, buffer=False)<EOL>", "docstring": "see :class:`datasketch.MinHashLSH`.", "id": "f5107:c0:m18"}
{"signature": "def _compute_nfp_real(l, u, counts, sizes):", "body": "if l > u:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return np.sum((float(sizes[u])-sizes[l:u+<NUM_LIT:1>])/float(sizes[u])*counts[l:u+<NUM_LIT:1>])<EOL>", "docstring": "Computes the expected number of false positives caused by using\n    u to approximate set sizes in the interval [l, u], using the real\n    set size distribution.\n\n    Args:\n        l: the lower bound on set sizes.\n        u: the upper bound on set sizes.\n        counts: the complete distribution of set sizes.\n        sizes: the complete domain of set sizes.\n\n    Return (float): the expected number of false positives.", "id": "f5110:m2"}
{"signature": "def _compute_nfps_uniform(cum_counts, sizes):", "body": "nfps = np.zeros((len(sizes), len(sizes)))<EOL>for l in range(len(sizes)):<EOL><INDENT>for u in range(l, len(sizes)):<EOL><INDENT>nfps[l, u] = _compute_nfp_uniform(l, u, cum_counts, sizes)<EOL><DEDENT><DEDENT>return nfps<EOL>", "docstring": "Computes the matrix of expected false positives for all possible\n    sub-intervals of the complete domain of set sizes, assuming uniform\n    distribution of set_sizes within each sub-intervals.\n\n    Args:\n        cum_counts: the complete cummulative distribution of set sizes.\n        sizes: the complete domain of set sizes.\n\n    Return (np.array): the 2-D array of expected number of false positives\n        for every pair of [l, u] interval, where l is axis-0 and u is\n        axis-1.", "id": "f5110:m1"}
{"signature": "@abstractmethod<EOL><INDENT>def remove(self, *keys):<DEDENT>", "body": "pass<EOL>", "docstring": "Remove `keys` from storage", "id": "f5111:c0:m9"}
{"signature": "@abstractmethod<EOL><INDENT>def has_key(self, key):<DEDENT>", "body": "pass<EOL>", "docstring": "Determines whether the key is in the storage or not", "id": "f5111:c0:m13"}
{"signature": "def query(self, minhash, size):", "body": "for i, index in enumerate(self.indexes):<EOL><INDENT>u = self.uppers[i]<EOL>if u is None:<EOL><INDENT>continue<EOL><DEDENT>b, r = self._get_optimal_param(u, size)<EOL>for key in index[r]._query_b(minhash, b):<EOL><INDENT>yield key<EOL><DEDENT><DEDENT>", "docstring": "Giving the MinHash and size of the query set, retrieve\nkeys that references sets with containment with respect to\nthe query set greater than the threshold.\n\nArgs:\n    minhash (datasketch.MinHash): The MinHash of the query set.\n    size (int): The size (number of unique items) of the query set.\n\nReturns:\n    `iterator` of keys.", "id": "f5112:c0:m4"}
{"signature": "def update(self, b):", "body": "hv = self.hashfunc(b)<EOL>a, b = self.permutations<EOL>phv = np.bitwise_and((a * hv + b) % _mersenne_prime, np.uint64(_max_hash))<EOL>self.hashvalues = np.minimum(phv, self.hashvalues)<EOL>", "docstring": "Update this MinHash with a new value.\n        The value will be hashed using the hash function specified by\n        the `hashfunc` argument in the constructor.\n\n        Args:\n            b: The value to be hashed using the hash function specified.\n\n        Example:\n            To update with a new string value (using the default SHA1 hash\n            function, which requires bytes as input):\n\n            .. code-block:: python\n\n                minhash = Minhash()\n                minhash.update(\"new value\".encode('utf-8'))\n\n            We can also use a different hash function, for example, `pyfarmhash`:\n\n            .. code-block:: python\n\n                import farmhash\n                def _hash_32(b):\n                    return farmhash.hash32(b)\n                minhash = MinHash(hashfunc=_hash_32)\n                minhash.update(\"new value\")", "id": "f5114:c0:m3"}
{"signature": "def copy(self):", "body": "return MinHash(seed=self.seed, hashfunc=self.hashfunc,<EOL>hashvalues=self.digest(),<EOL>permutations=self.permutations)<EOL>", "docstring": ":returns: datasketch.MinHash -- A copy of this MinHash by exporting its state.", "id": "f5114:c0:m10"}
{"signature": "def digest(self):", "body": "return copy.copy(self.hashvalues)<EOL>", "docstring": "Export the hash values, which is the internal state of the\n        MinHash.\n\n        Returns:\n            numpy.array: The hash values which is a Numpy array.", "id": "f5114:c0:m7"}
{"signature": "def __len__(self):", "body": "return len(self.hashvalues)<EOL>", "docstring": ":returns: int -- The number of hash values.", "id": "f5114:c0:m11"}
{"signature": "def bytesize(self, byteorder='<STR_LIT:@>'):", "body": "<EOL>seed_size = struct.calcsize(byteorder+'<STR_LIT:q>')<EOL>length_size = struct.calcsize(byteorder+'<STR_LIT:i>')<EOL>hashvalue_size = struct.calcsize(byteorder+'<STR_LIT:I>')<EOL>return seed_size + length_size + len(self) * hashvalue_size<EOL>", "docstring": "Compute the byte size after serialization.\n\n        Args:\n            byteorder (str, optional): This is byte order of the serialized data. Use one\n                of the `byte order characters\n                <https://docs.python.org/3/library/struct.html#byte-order-size-and-alignment>`_:\n                ``@``, ``=``, ``<``, ``>``, and ``!``.\n                Default is ``@`` -- the native order.\n\n        Returns:\n            int: Size in number of bytes after serialization.", "id": "f5115:c0:m4"}
{"signature": "def _calc_a(self, r, b):", "body": "if r == <NUM_LIT:0.0>:<EOL><INDENT>return <NUM_LIT:1.0> / (<NUM_LIT:1> << b)<EOL><DEDENT>return r * (<NUM_LIT:1> - r) ** (<NUM_LIT:2> ** b - <NUM_LIT:1>) / (<NUM_LIT:1> - (<NUM_LIT:1> - r) ** (<NUM_LIT:2> * b))<EOL>", "docstring": "Compute the function A(r, b)", "id": "f5116:c0:m6"}
{"signature": "def jaccard(self, other):", "body": "if self.b != other.b:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if self.seed != other.seed:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>intersection = np.count_nonzero(self.hashvalues==other.hashvalues)<EOL>raw_est = float(intersection) / float(self.hashvalues.size)<EOL>a1 = self._calc_a(self.r, self.b)<EOL>a2 = self._calc_a(other.r, other.b)<EOL>c1, c2 = self._calc_c(a1, a2, self.r, other.r)<EOL>return (raw_est - c1) / (<NUM_LIT:1> - c2)<EOL>", "docstring": "Estimate the Jaccard similarity (resemblance) between this b-bit\nMinHash and the other.", "id": "f5116:c0:m2"}
{"signature": "def index(self):", "body": "for i, hashtable in enumerate(self.hashtables):<EOL><INDENT>self.sorted_hashtables[i] = [H for H in hashtable.keys()]<EOL>self.sorted_hashtables[i].sort()<EOL><DEDENT>", "docstring": "Index all the keys added so far and make them searchable.", "id": "f5117:c0:m2"}
{"signature": "def unwrap_self_for_multiprocessing(arg):", "body": "(inst, method_name, args) = arg<EOL>return getattr(inst, method_name)(*args)<EOL>", "docstring": "You can not call methods with multiprocessing, but free functions,\n        If you want to call  inst.method(arg0, arg1),\n\n            unwrap_self_for_multiprocessing(inst, \"method\", (arg0, arg1))\n\n        does the trick.", "id": "f5149:m1"}
{"signature": "@cli.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', required=True, type=click.Path(exists=True), help='<STR_LIT>')<EOL>@click.option('<STR_LIT>','<STR_LIT>', type=click.Path(exists=False), help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', required=True, type=click.Path(exists=True), help='<STR_LIT>')<EOL>def backpropagate(infile, outfile, apply_scores):", "body": "if outfile is None:<EOL><INDENT>outfile = infile<EOL><DEDENT>else:<EOL><INDENT>outfile = outfile<EOL><DEDENT>backpropagate_oswr(infile, outfile, apply_scores)<EOL>", "docstring": "Backpropagate multi-run peptide and protein scores to single files", "id": "f5154:m8"}
{"signature": "@cli.command()<EOL>@click.argument('<STR_LIT>', nargs=-<NUM_LIT:1>, type=click.Path(exists=True))<EOL>@click.option('<STR_LIT>', '<STR_LIT>', required=True, type=click.Path(exists=True), help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', default=<NUM_LIT>, show_default=True, type=float, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', default=<NUM_LIT>, show_default=True, type=float, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', default=<NUM_LIT>, show_default=True, type=float, help='<STR_LIT>')<EOL>def filter(sqmassfiles, infile, max_precursor_pep, max_peakgroup_pep, max_transition_pep):", "body": "filter_sqmass(sqmassfiles, infile, max_precursor_pep, max_peakgroup_pep, max_transition_pep)<EOL>", "docstring": "Filter sqMass files", "id": "f5154:m11"}
{"signature": "@cli.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', required=True, type=click.Path(exists=True), help='<STR_LIT>')<EOL>@click.option('<STR_LIT>','<STR_LIT>', type=click.Path(exists=False), help='<STR_LIT>')<EOL>def reduce(infile, outfile):", "body": "if outfile is None:<EOL><INDENT>outfile = infile<EOL><DEDENT>else:<EOL><INDENT>outfile = outfile<EOL><DEDENT>reduce_osw(infile, outfile)<EOL>", "docstring": "Reduce scored PyProphet file to minimum for global scoring", "id": "f5154:m6"}
{"signature": "@click.group(chain=True)<EOL>@click.version_option()<EOL>def cli():", "body": "", "docstring": "PyProphet: Semi-supervised learning and scoring of OpenSWATH results.\n\nVisit http://openswath.org for usage instructions and help.", "id": "f5154:m0"}
{"signature": "@cli.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', required=True, type=click.Path(exists=True), help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=click.Path(exists=False), help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', default='<STR_LIT>', show_default=True, type=click.Choice(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>','<STR_LIT>']), help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', default=False, show_default=True, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', default=True, show_default=True, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', default=<NUM_LIT>, show_default=True, type=float, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', default='<STR_LIT>', show_default=True, type=click.Choice(['<STR_LIT>','<STR_LIT>','<STR_LIT>']), help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', default=<NUM_LIT>, show_default=True, type=float, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', default=<NUM_LIT>, show_default=True, type=float, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', default=True, show_default=True, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', default=<NUM_LIT>, show_default=True, type=float, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', default=True, show_default=True, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', default=<NUM_LIT>, show_default=True, type=float, help='<STR_LIT>')<EOL>def export(infile, outfile, format, outcsv, transition_quantification, max_transition_pep, ipf, ipf_max_peptidoform_pep, max_rs_peakgroup_qvalue, peptide, max_global_peptide_qvalue, protein, max_global_protein_qvalue):", "body": "if format == \"<STR_LIT>\":<EOL><INDENT>export_score_plots(infile)<EOL><DEDENT>else:<EOL><INDENT>if outfile is None:<EOL><INDENT>if outcsv:<EOL><INDENT>outfile = infile.split(\"<STR_LIT>\")[<NUM_LIT:0>] + \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>outfile = infile.split(\"<STR_LIT>\")[<NUM_LIT:0>] + \"<STR_LIT>\"<EOL><DEDENT><DEDENT>else:<EOL><INDENT>outfile = outfile<EOL><DEDENT>export_tsv(infile, outfile, format, outcsv, transition_quantification, max_transition_pep, ipf, ipf_max_peptidoform_pep, max_rs_peakgroup_qvalue, peptide, max_global_peptide_qvalue, protein, max_global_protein_qvalue)<EOL><DEDENT>", "docstring": "Export TSV/CSV tables", "id": "f5154:m9"}
{"signature": "@cli.command()<EOL>@click.argument('<STR_LIT>', nargs=-<NUM_LIT:1>, type=click.Path(exists=True))<EOL>@click.option('<STR_LIT>','<STR_LIT>', required=True, type=click.Path(exists=False), help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', default=False, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>','<STR_LIT>', required=True, type=click.Path(exists=False), help='<STR_LIT>')<EOL>def merge(infiles, outfile, same_run, templatefile):", "body": "if len(infiles) < <NUM_LIT:1>:<EOL><INDENT>raise click.ClickException(\"<STR_LIT>\")<EOL><DEDENT>merge_osw(infiles, outfile, templatefile, same_run)<EOL>", "docstring": "Merge multiple OSW files and (for large experiments, it is recommended to subsample first).", "id": "f5154:m7"}
{"signature": "@cli.command()<EOL>@click.option('<STR_LIT>', '<STR_LIT>', required=True, type=click.Path(exists=True), help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=click.Path(exists=False), help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', default=True, show_default=True, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', default=True, show_default=True, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', default=True, show_default=True, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', default=False, show_default=True, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', default=<NUM_LIT>, show_default=True, type=float, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', default=<NUM_LIT>, show_default=True, type=float, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', default=<NUM_LIT>, show_default=True, type=float, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', default=<NUM_LIT>, show_default=True, type=float, help='<STR_LIT>')<EOL>def ipf(infile, outfile, ipf_ms1_scoring, ipf_ms2_scoring, ipf_h0, ipf_grouped_fdr, ipf_max_precursor_pep, ipf_max_peakgroup_pep, ipf_max_precursor_peakgroup_pep, ipf_max_transition_pep):", "body": "if outfile is None:<EOL><INDENT>outfile = infile<EOL><DEDENT>else:<EOL><INDENT>outfile = outfile<EOL><DEDENT>infer_peptidoforms(infile, outfile, ipf_ms1_scoring, ipf_ms2_scoring, ipf_h0, ipf_grouped_fdr, ipf_max_precursor_pep, ipf_max_peakgroup_pep, ipf_max_precursor_peakgroup_pep, ipf_max_transition_pep)<EOL>", "docstring": "Infer peptidoforms after scoring of MS1, MS2 and transition-level data.", "id": "f5154:m2"}
{"signature": "@profile<EOL>def lfdr(p_values, pi0, trunc = True, monotone = True, transf = \"<STR_LIT>\", adj = <NUM_LIT>, eps = np.power(<NUM_LIT>,-<NUM_LIT:8>)):", "body": "p = np.array(p_values)<EOL>lfdr_out = p<EOL>rm_na = np.isfinite(p)<EOL>p = p[rm_na]<EOL>if (min(p) < <NUM_LIT:0> or max(p) > <NUM_LIT:1>):<EOL><INDENT>raise click.ClickException(\"<STR_LIT>\")<EOL><DEDENT>elif (pi0 < <NUM_LIT:0> or pi0 > <NUM_LIT:1>):<EOL><INDENT>raise click.ClickException(\"<STR_LIT>\")<EOL><DEDENT>if (transf == \"<STR_LIT>\"):<EOL><INDENT>p = np.maximum(p, eps)<EOL>p = np.minimum(p, <NUM_LIT:1>-eps)<EOL>x = scipy.stats.norm.ppf(p, loc=<NUM_LIT:0>, scale=<NUM_LIT:1>)<EOL>bw = bw_nrd0(x)<EOL>myd = KDEUnivariate(x)<EOL>myd.fit(bw=adj*bw, gridsize = <NUM_LIT>)<EOL>splinefit = sp.interpolate.splrep(myd.support, myd.density)<EOL>y = sp.interpolate.splev(x, splinefit)<EOL>lfdr = pi0 * scipy.stats.norm.pdf(x) / y<EOL><DEDENT>elif (transf == \"<STR_LIT>\"):<EOL><INDENT>x = np.log((p + eps) / (<NUM_LIT:1> - p + eps))<EOL>bw = bw_nrd0(x)<EOL>myd = KDEUnivariate(x)<EOL>myd.fit(bw=adj*bw, gridsize = <NUM_LIT>)<EOL>splinefit = sp.interpolate.splrep(myd.support, myd.density)<EOL>y = sp.interpolate.splev(x, splinefit)<EOL>dx = np.exp(x) / np.power((<NUM_LIT:1> + np.exp(x)),<NUM_LIT:2>)<EOL>lfdr = (pi0 * dx) / y<EOL><DEDENT>else:<EOL><INDENT>raise click.ClickException(\"<STR_LIT>\")<EOL><DEDENT>if (trunc):<EOL><INDENT>lfdr[lfdr > <NUM_LIT:1>] = <NUM_LIT:1><EOL><DEDENT>if (monotone):<EOL><INDENT>lfdr = lfdr[p.ravel().argsort()]<EOL>for i in range(<NUM_LIT:1>,len(x)):<EOL><INDENT>if (lfdr[i] < lfdr[i - <NUM_LIT:1>]):<EOL><INDENT>lfdr[i] = lfdr[i - <NUM_LIT:1>]<EOL><DEDENT><DEDENT>lfdr = lfdr[scipy.stats.rankdata(p,\"<STR_LIT>\")-<NUM_LIT:1>]<EOL><DEDENT>lfdr_out[rm_na] = lfdr<EOL>return lfdr_out<EOL>", "docstring": "Estimate local FDR / posterior error probability from p-values according to bioconductor/qvalue", "id": "f5157:m11"}
{"signature": "@profile<EOL>def error_statistics(target_scores, decoy_scores, parametric, pfdr, pi0_lambda, pi0_method = \"<STR_LIT>\", pi0_smooth_df = <NUM_LIT:3>, pi0_smooth_log_pi0 = False, compute_lfdr = False, lfdr_trunc = True, lfdr_monotone = True, lfdr_transf = \"<STR_LIT>\", lfdr_adj = <NUM_LIT>, lfdr_eps = np.power(<NUM_LIT>,-<NUM_LIT:8>)):", "body": "target_scores = to_one_dim_array(target_scores)<EOL>target_scores = np.sort(target_scores[~np.isnan(target_scores)])<EOL>decoy_scores = to_one_dim_array(decoy_scores)<EOL>decoy_scores = np.sort(decoy_scores[~np.isnan(decoy_scores)])<EOL>if parametric:<EOL><INDENT>target_pvalues = pnorm(target_scores, decoy_scores)<EOL><DEDENT>else:<EOL><INDENT>target_pvalues = pemp(target_scores, decoy_scores)<EOL><DEDENT>pi0 = pi0est(target_pvalues, pi0_lambda, pi0_method, pi0_smooth_df, pi0_smooth_log_pi0)<EOL>target_qvalues = qvalue(target_pvalues, pi0['<STR_LIT>'], pfdr)<EOL>metrics = stat_metrics(target_pvalues, pi0['<STR_LIT>'], pfdr)<EOL>error_stat = pd.DataFrame({'<STR_LIT>': target_scores, '<STR_LIT>': target_pvalues, '<STR_LIT>': target_qvalues, '<STR_LIT>': metrics['<STR_LIT>'], '<STR_LIT>': metrics['<STR_LIT>'], '<STR_LIT>': metrics['<STR_LIT>'], '<STR_LIT>': metrics['<STR_LIT>'], '<STR_LIT>': metrics['<STR_LIT>'], '<STR_LIT>': metrics['<STR_LIT>'], '<STR_LIT>': metrics['<STR_LIT>'], '<STR_LIT>': metrics['<STR_LIT>']})<EOL>if compute_lfdr:<EOL><INDENT>error_stat['<STR_LIT>'] = lfdr(target_pvalues, pi0['<STR_LIT>'], lfdr_trunc, lfdr_monotone, lfdr_transf, lfdr_adj, lfdr_eps)<EOL><DEDENT>return error_stat, pi0<EOL>", "docstring": "Takes list of decoy and target scores and creates error statistics for target values", "id": "f5157:m15"}
{"signature": "def pnorm(stat, stat0):", "body": "mu, sigma = mean_and_std_dev(stat0)<EOL>stat = to_one_dim_array(stat, np.float64)<EOL>args = (stat - mu) / sigma<EOL>return <NUM_LIT:1>-(<NUM_LIT:0.5> * (<NUM_LIT:1.0> + scipy.special.erf(args / np.sqrt(<NUM_LIT>))))<EOL>", "docstring": "[P(X>pi, mu, sigma) for pi in pvalues] for normal distributed stat with\n    expectation value mu and std deviation sigma", "id": "f5157:m6"}
{"signature": "@profile<EOL>def summary_err_table(df, qvalues=[<NUM_LIT:0>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT:0.1>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT:0.5>]):", "body": "qvalues = to_one_dim_array(qvalues)<EOL>ix = find_nearest_matches(np.float32(df.qvalue.values), qvalues)<EOL>df_sub = df.iloc[ix].copy()<EOL>for i_sub, (i0, i1) in enumerate(zip(ix, ix[<NUM_LIT:1>:])):<EOL><INDENT>if i1 == i0:<EOL><INDENT>df_sub.iloc[i_sub + <NUM_LIT:1>, :] = None<EOL><DEDENT><DEDENT>df_sub.qvalue = qvalues<EOL>df_sub.reset_index(inplace=True, drop=True)<EOL>return df_sub[['<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>']]<EOL>", "docstring": "Summary error table for some typical q-values", "id": "f5157:m14"}
{"signature": "def find_cutoff(tt_scores, td_scores, cutoff_fdr, parametric, pfdr, pi0_lambda, pi0_method, pi0_smooth_df, pi0_smooth_log_pi0):", "body": "error_stat, pi0 = error_statistics(tt_scores, td_scores, parametric, pfdr, pi0_lambda, pi0_method, pi0_smooth_df, pi0_smooth_log_pi0, False)<EOL>if not len(error_stat):<EOL><INDENT>raise click.ClickException(\"<STR_LIT>\")<EOL><DEDENT>i0 = (error_stat.qvalue - cutoff_fdr).abs().idxmin()<EOL>cutoff = error_stat.iloc[i0][\"<STR_LIT>\"]<EOL>return cutoff<EOL>", "docstring": "Finds cut off target score for specified false discovery rate fdr", "id": "f5157:m16"}
{"signature": "@register.filter<EOL>def obfuscate(value, juice=None):", "body": "if not settings.UNFRIENDLY_ENABLE_FILTER:<EOL><INDENT>return value<EOL><DEDENT>kwargs = {<EOL>'<STR_LIT:key>': encrypt(value,<EOL>settings.UNFRIENDLY_SECRET,<EOL>settings.UNFRIENDLY_IV,<EOL>checksum=settings.UNFRIENDLY_ENFORCE_CHECKSUM),<EOL>}<EOL>if juice:<EOL><INDENT>kwargs['<STR_LIT>'] = slugify(juice)<EOL><DEDENT>return reverse('<STR_LIT>', kwargs=kwargs)<EOL>", "docstring": "Template filter that obfuscates whatever text it is applied to. The text is\nsupposed to be a URL, but it will obfuscate anything.\n\nUsage:\n    Extremely unfriendly URL:\n    {{ \"/my-secret-path/\"|obfuscate }}\n\n    Include some SEO juice:\n    {{ \"/my-secret-path/\"|obfuscate:\"some SEO friendly text\" }}", "id": "f5169:m0"}
{"signature": "def decrypt(ciphertext, secret, inital_vector, checksum=True, lazy=True):", "body": "secret = _lazysecret(secret) if lazy else secret<EOL>encobj = AES.new(secret, AES.MODE_CFB, inital_vector)<EOL>try:<EOL><INDENT>padded = ciphertext + ('<STR_LIT:=>' * (len(ciphertext) % <NUM_LIT:4>))<EOL>decoded = base64.urlsafe_b64decode(str(padded))<EOL>plaintext = encobj.decrypt(decoded)<EOL><DEDENT>except (TypeError, binascii.Error):<EOL><INDENT>raise InvalidKeyError(\"<STR_LIT>\")<EOL><DEDENT>if checksum:<EOL><INDENT>try:<EOL><INDENT>crc, plaintext = (base64.urlsafe_b64decode(<EOL>plaintext[-<NUM_LIT:8>:]), plaintext[:-<NUM_LIT:8>])<EOL><DEDENT>except (TypeError, binascii.Error):<EOL><INDENT>raise CheckSumError(\"<STR_LIT>\")<EOL><DEDENT>if not crc == _pack_crc(plaintext):<EOL><INDENT>raise CheckSumError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>return plaintext<EOL>", "docstring": "Decrypts ciphertext with secret\n    ciphertext     - encrypted content to decrypt\n    secret         - secret to decrypt ciphertext\n    inital_vector  - initial vector\n    lazy           - pad secret if less than legal blocksize (default: True)\n    checksum       - verify crc32 byte encoded checksum (default: True)\n    returns plaintext", "id": "f5174:m4"}
{"signature": "def _crc(plaintext):", "body": "if not isinstance(plaintext, six.binary_type):<EOL><INDENT>plaintext = six.b(plaintext)<EOL><DEDENT>return (zlib.crc32(plaintext) % <NUM_LIT>) & <NUM_LIT><EOL>", "docstring": "Generates crc32. Modulo keep the value within int range.", "id": "f5174:m1"}
{"signature": "@njit()<EOL>def _cluster_hits(hits, clusters, assigned_hit_array, cluster_hit_indices, column_cluster_distance, row_cluster_distance, frame_cluster_distance, min_hit_charge, max_hit_charge, ignore_same_hits, noisy_pixels, disabled_pixels):", "body": "total_hits = hits.shape[<NUM_LIT:0>]<EOL>if total_hits == <NUM_LIT:0>:<EOL><INDENT>return <NUM_LIT:0>  <EOL><DEDENT>max_cluster_hits = cluster_hit_indices.shape[<NUM_LIT:0>]<EOL>if total_hits != clusters.shape[<NUM_LIT:0>]:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if total_hits != assigned_hit_array.shape[<NUM_LIT:0>]:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if min_hit_charge == <NUM_LIT:0>:<EOL><INDENT>charge_correction = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>charge_correction = <NUM_LIT:0><EOL><DEDENT>start_event_hit_index = <NUM_LIT:0><EOL>start_event_cluster_index = <NUM_LIT:0><EOL>cluster_size = <NUM_LIT:0><EOL>event_number = hits[<NUM_LIT:0>]['<STR_LIT>']<EOL>event_cluster_index = <NUM_LIT:0><EOL>for i in range(total_hits):<EOL><INDENT>if _new_event(hits[i]['<STR_LIT>'], event_number):<EOL><INDENT>_finish_event(<EOL>hits=hits,<EOL>clusters=clusters,<EOL>start_event_hit_index=start_event_hit_index,<EOL>stop_event_hit_index=i,<EOL>start_event_cluster_index=start_event_cluster_index,<EOL>stop_event_cluster_index=start_event_cluster_index + event_cluster_index)<EOL>start_event_hit_index = i<EOL>start_event_cluster_index = start_event_cluster_index + event_cluster_index<EOL>event_number = hits[i]['<STR_LIT>']<EOL>event_cluster_index = <NUM_LIT:0><EOL><DEDENT>if assigned_hit_array[i] > <NUM_LIT:0>:  <EOL><INDENT>continue<EOL><DEDENT>if not _hit_ok(<EOL>hit=hits[i],<EOL>min_hit_charge=min_hit_charge,<EOL>max_hit_charge=max_hit_charge) or (disabled_pixels.shape[<NUM_LIT:0>] != <NUM_LIT:0> and _pixel_masked(hits[i], disabled_pixels)):<EOL><INDENT>_set_hit_invalid(hit=hits[i], cluster_id=-<NUM_LIT:1>)<EOL>assigned_hit_array[i] = <NUM_LIT:1><EOL>continue<EOL><DEDENT>_set_1d_array(cluster_hit_indices, -<NUM_LIT:1>, cluster_size)<EOL>cluster_hit_indices[<NUM_LIT:0>] = i<EOL>assigned_hit_array[i] = <NUM_LIT:1><EOL>cluster_size = <NUM_LIT:1>  <EOL>for j in cluster_hit_indices:  <EOL><INDENT>if j < <NUM_LIT:0>:  <EOL><INDENT>break<EOL><DEDENT>for k in range(cluster_hit_indices[<NUM_LIT:0>] + <NUM_LIT:1>, total_hits):<EOL><INDENT>if _new_event(hits[k]['<STR_LIT>'], event_number):<EOL><INDENT>break<EOL><DEDENT>if assigned_hit_array[k] > <NUM_LIT:0>:<EOL><INDENT>continue<EOL><DEDENT>if not _hit_ok(<EOL>hit=hits[k],<EOL>min_hit_charge=min_hit_charge,<EOL>max_hit_charge=max_hit_charge) or (disabled_pixels.shape[<NUM_LIT:0>] != <NUM_LIT:0> and _pixel_masked(hits[k], disabled_pixels)):<EOL><INDENT>_set_hit_invalid(hit=hits[k], cluster_id=-<NUM_LIT:1>)<EOL>assigned_hit_array[k] = <NUM_LIT:1><EOL>continue<EOL><DEDENT>if _is_in_max_difference(hits[j]['<STR_LIT>'], hits[k]['<STR_LIT>'], column_cluster_distance) and _is_in_max_difference(hits[j]['<STR_LIT>'], hits[k]['<STR_LIT>'], row_cluster_distance) and _is_in_max_difference(hits[j]['<STR_LIT>'], hits[k]['<STR_LIT>'], frame_cluster_distance):<EOL><INDENT>if not ignore_same_hits or hits[j]['<STR_LIT>'] != hits[k]['<STR_LIT>'] or hits[j]['<STR_LIT>'] != hits[k]['<STR_LIT>']:<EOL><INDENT>cluster_size += <NUM_LIT:1><EOL>if cluster_size > max_cluster_hits:<EOL><INDENT>raise IndexError('<STR_LIT>')<EOL><DEDENT>cluster_hit_indices[cluster_size - <NUM_LIT:1>] = k<EOL>assigned_hit_array[k] = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>_set_hit_invalid(hit=hits[k], cluster_id=-<NUM_LIT:2>)<EOL>assigned_hit_array[k] = <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT><DEDENT>if cluster_size == <NUM_LIT:1> and noisy_pixels.shape[<NUM_LIT:0>] != <NUM_LIT:0> and _pixel_masked(hits[cluster_hit_indices[<NUM_LIT:0>]], noisy_pixels):<EOL><INDENT>_set_hit_invalid(hit=hits[cluster_hit_indices[<NUM_LIT:0>]], cluster_id=-<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>_finish_cluster(<EOL>hits=hits,<EOL>clusters=clusters,<EOL>cluster_size=cluster_size,<EOL>cluster_hit_indices=cluster_hit_indices,<EOL>cluster_index=start_event_cluster_index + event_cluster_index,<EOL>cluster_id=event_cluster_index,<EOL>charge_correction=charge_correction,<EOL>noisy_pixels=noisy_pixels,<EOL>disabled_pixels=disabled_pixels)<EOL>event_cluster_index += <NUM_LIT:1><EOL><DEDENT><DEDENT>_finish_event(<EOL>hits=hits,<EOL>clusters=clusters,<EOL>start_event_hit_index=start_event_hit_index,<EOL>stop_event_hit_index=total_hits,<EOL>start_event_cluster_index=start_event_cluster_index,<EOL>stop_event_cluster_index=start_event_cluster_index + event_cluster_index)<EOL>total_clusters = start_event_cluster_index + event_cluster_index<EOL>return total_clusters<EOL>", "docstring": "Main precompiled function that loopes over the hits and clusters them", "id": "f5184:m8"}
{"signature": "@njit()<EOL>def _is_in_max_difference(value_1, value_2, max_difference):", "body": "if value_1 <= value_2:<EOL><INDENT>return value_2 - value_1 <= max_difference<EOL><DEDENT>return value_1 - value_2 <= max_difference<EOL>", "docstring": "Helper function to determine the difference of two values that can be np.uints. Works in python and numba mode.\n    Circumvents numba bug #1653", "id": "f5184:m7"}
{"signature": "def set_hit_dtype(self, hit_dtype):", "body": "if not hit_dtype:<EOL><INDENT>hit_dtype = np.dtype([])<EOL><DEDENT>else:<EOL><INDENT>hit_dtype = np.dtype(hit_dtype)<EOL><DEDENT>cluster_hits_descr = hit_dtype.descr<EOL>for dtype_name, dtype in self._default_cluster_hits_descr:<EOL><INDENT>if self._hit_fields_mapping[dtype_name] not in hit_dtype.fields:<EOL><INDENT>cluster_hits_descr.append((dtype_name, dtype))<EOL><DEDENT><DEDENT>self._cluster_hits_descr = cluster_hits_descr<EOL>self._init_arrays(size=<NUM_LIT:0>)<EOL>", "docstring": "Set the data type of the hits.\n\n        Fields that are not mentioned here are NOT copied into the clustered hits array.\n        Clusterizer has to know the hit data type to produce the clustered hit result with the same data types.\n\n        Parameters:\n        -----------\n        hit_dtype : numpy.dtype or equivalent\n            Defines the dtype of the hit array.\n\n        Example:\n        --------\n        hit_dtype = [(\"column\", np.uint16), (\"row\", np.uint16)], where\n        \"column\", \"row\" is the field name of the input hit array.", "id": "f5185:c0:m6"}
{"signature": "def set_end_of_cluster_function(self, function):", "body": "self.cluster_functions._end_of_cluster_function = self._jitted(function)<EOL>self._end_of_cluster_function = function<EOL>", "docstring": "Adding function to module.\n        This is maybe the only way to make the clusterizer to work with multiprocessing.", "id": "f5185:c0:m9"}
{"signature": "def ignore_same_hits(self, value):", "body": "self._ignore_same_hits = value<EOL>", "docstring": "Whether a duplicate hit in the event with the same column and row is ignored or not.", "id": "f5185:c0:m16"}
{"signature": "def threshold_img(data, threshold, mask=None, mask_out='<STR_LIT>'):", "body": "if mask is not None:<EOL><INDENT>mask = threshold_img(mask, threshold, mask_out=mask_out)<EOL>return data * mask.astype(bool)<EOL><DEDENT>if mask_out.startswith('<STR_LIT:b>'):<EOL><INDENT>data[data < threshold] = <NUM_LIT:0><EOL><DEDENT>elif mask_out.startswith('<STR_LIT:a>'):<EOL><INDENT>data[data > threshold] = <NUM_LIT:0><EOL><DEDENT>return data<EOL>", "docstring": "Threshold data, setting all values in the array above/below threshold\n    to zero.\n    Args:\n        data (ndarray): The image data to threshold.\n        threshold (float): Numeric threshold to apply to image.\n        mask (ndarray): Optional 1D-array with the same length as the data. If\n            passed, the threshold is first applied to the mask, and the\n            resulting indices are used to threshold the data. This is primarily\n            useful when, e.g., applying a statistical threshold to a z-value\n            image based on a p-value threshold.\n        mask_out (str): Thresholding direction. Can be 'below' the threshold\n            (default) or 'above' the threshold. Note: use 'above' when masking\n            based on p values.", "id": "f5201:m4"}
{"signature": "def get_sphere(coords, r=<NUM_LIT:4>, vox_dims=(<NUM_LIT:2>, <NUM_LIT:2>, <NUM_LIT:2>), dims=(<NUM_LIT>, <NUM_LIT>, <NUM_LIT>)):", "body": "r = float(r)<EOL>xx, yy, zz = [slice(-r / vox_dims[i], r / vox_dims[<EOL>i] + <NUM_LIT>, <NUM_LIT:1>) for i in range(len(coords))]<EOL>cube = np.vstack([row.ravel() for row in np.mgrid[xx, yy, zz]])<EOL>sphere = cube[:, np.sum(np.dot(np.diag(<EOL>vox_dims), cube) ** <NUM_LIT:2>, <NUM_LIT:0>) ** <NUM_LIT> <= r]<EOL>sphere = np.round(sphere.T + coords)<EOL>return sphere[(np.min(sphere, <NUM_LIT:1>) >= <NUM_LIT:0>) &<EOL>(np.max(np.subtract(sphere, dims), <NUM_LIT:1>) <= -<NUM_LIT:1>), :].astype(int)<EOL>", "docstring": "Return all points within r mm of coordinates. Generates a cube\n   and then discards all points outside sphere. Only returns values that\n   fall within the dimensions of the image.", "id": "f5201:m0"}
{"signature": "def add(self, layers, above=None, below=None):", "body": "def add_named_layer(name, image):<EOL><INDENT>image = self.get_image(image, output='<STR_LIT>')<EOL>if above is not None:<EOL><INDENT>image[image < above] = <NUM_LIT:0.><EOL><DEDENT>if below is not None:<EOL><INDENT>image[image > below] = <NUM_LIT:0.><EOL><DEDENT>self.layers[name] = image<EOL>self.stack.append(name)<EOL><DEDENT>if isinstance(layers, dict):<EOL><INDENT>for (name, image) in layers.items():<EOL><INDENT>add_named_layer(name, image)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if not isinstance(layers, list):<EOL><INDENT>layers = [layers]<EOL><DEDENT>for image in layers:<EOL><INDENT>name = '<STR_LIT>' % len(self.stack)<EOL>add_named_layer(name, image)<EOL><DEDENT><DEDENT>self.set_mask()<EOL>", "docstring": "Add one or more layers to the stack of masking layers.\n        Args:\n            layers: A string, NiBabel image, list, or dict. If anything other\n                than a dict is passed, assigns sequential layer names based on\n                the current position in stack; if a dict, uses key as the name\n                and value as the mask image.", "id": "f5202:c0:m2"}
{"signature": "def reset(self):", "body": "self.layers = {}<EOL>self.stack = []<EOL>self.set_mask()<EOL>self.n_vox_in_vol = len(np.where(self.current_mask)[<NUM_LIT:0>])<EOL>", "docstring": "Reset/remove all layers, keeping only the initial volume.", "id": "f5202:c0:m1"}
{"signature": "def get_image(self, image, output='<STR_LIT>'):", "body": "if isinstance(image, string_types):<EOL><INDENT>image = nb.load(image)<EOL><DEDENT>if type(image).__module__.startswith('<STR_LIT>'):<EOL><INDENT>if output == '<STR_LIT:image>':<EOL><INDENT>return image<EOL><DEDENT>image = image.get_data()<EOL><DEDENT>if not type(image).__module__.startswith('<STR_LIT>'):<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>if image.shape[:<NUM_LIT:3>] == self.volume.shape:<EOL><INDENT>if output == '<STR_LIT:image>':<EOL><INDENT>return nb.nifti1.Nifti1Image(image, None, self.get_header())<EOL><DEDENT>elif output == '<STR_LIT>':<EOL><INDENT>return image<EOL><DEDENT>else:<EOL><INDENT>image = image.ravel()<EOL><DEDENT><DEDENT>if output == '<STR_LIT>':<EOL><INDENT>return image.ravel()<EOL><DEDENT>image = np.reshape(image, self.volume.shape)<EOL>if output == '<STR_LIT>':<EOL><INDENT>return image<EOL><DEDENT>return nb.nifti1.Nifti1Image(image, None, self.get_header())<EOL>", "docstring": "A flexible method for transforming between different\n        representations of image data.\n        Args:\n            image: The input image. Can be a string (filename of image),\n                NiBabel image, N-dimensional array (must have same shape as\n                self.volume), or vectorized image data (must have same length\n                as current conjunction mask).\n            output: The format of the returned image representation. Must be\n                one of:\n                    'vector': A 1D vectorized array\n                    'array': An N-dimensional array, with\n                        shape = self.volume.shape\n                    'image': A NiBabel image\n        Returns: An object containing image data; see output options above.", "id": "f5202:c0:m4"}
{"signature": "def mask(self, image, nan_to_num=True, layers=None, in_global_mask=False):", "body": "self.set_mask(layers)<EOL>image = self.get_image(image, output='<STR_LIT>')<EOL>if in_global_mask:<EOL><INDENT>masked_data = image[self.global_mask]<EOL>masked_data[~self.get_mask(in_global_mask=True)] = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>masked_data = image[self.current_mask]<EOL><DEDENT>if nan_to_num:<EOL><INDENT>masked_data = np.nan_to_num(masked_data)<EOL><DEDENT>return masked_data<EOL>", "docstring": "Vectorize an image and mask out all invalid voxels.\n\n        Args:\n            images: The image to vectorize and mask. Input can be any object\n                handled by get_image().\n            layers: Which mask layers to use (specified as int, string, or\n                list of ints and strings). When None, applies the conjunction\n                of all layers.\n            nan_to_num: boolean indicating whether to convert NaNs to 0.\n            in_global_mask: Whether to return the resulting masked vector in\n                the globally masked space (i.e., n_voxels =\n                len(self.global_mask)). If False (default), returns in the full\n                image space (i.e., n_voxels = len(self.volume)).\n        Returns:\n          A 1D NumPy array of in-mask voxels.", "id": "f5202:c0:m5"}
{"signature": "def __init__(self, dataset):", "body": "self.dataset = dataset<EOL>self.data = pd.DataFrame()<EOL>", "docstring": "Initialize a new FeatureTable. Takes as input a parent DataSet\n        instance and feature data (if provided).", "id": "f5203:c2:m0"}
{"signature": "def get_feature_counts(self, threshold=<NUM_LIT>):", "body": "counts = np.sum(self.get_feature_data() >= threshold, <NUM_LIT:0>)<EOL>return dict(zip(self.get_feature_names(), list(counts)))<EOL>", "docstring": "Returns a dictionary, where the keys are the feature names\n        and the values are the number of studies tagged with the feature.", "id": "f5203:c0:m8"}
{"signature": "def search_features(self, search):", "body": "if isinstance(search, string_types):<EOL><INDENT>search = [search]<EOL><DEDENT>search = [s.replace('<STR_LIT:*>', '<STR_LIT>') for s in search]<EOL>cols = list(self.data.columns)<EOL>results = []<EOL>for s in search:<EOL><INDENT>results.extend([f for f in cols if re.match(s + '<STR_LIT:$>', f)])<EOL><DEDENT>return list(set(results))<EOL>", "docstring": "Returns all features that match any of the elements in the input\n        list.\n\n        Args:\n            search (str, list): A string or list of strings defining the query.\n\n        Returns:\n            A list of matching feature names.", "id": "f5203:c2:m6"}
{"signature": "def _sdf_to_csr(self):", "body": "data = self.data.to_dense()<EOL>self.data = {<EOL>'<STR_LIT>': list(data.columns),<EOL>'<STR_LIT:index>': list(data.index),<EOL>'<STR_LIT>': sparse.csr_matrix(data.values)<EOL>}<EOL>", "docstring": "Convert FeatureTable to SciPy CSR matrix.", "id": "f5203:c2:m9"}
{"signature": "def add_features(self, features, append=True, merge='<STR_LIT>',<EOL>duplicates='<STR_LIT:ignore>', min_studies=<NUM_LIT:0.0>, threshold=<NUM_LIT>):", "body": "if (not append) or not hasattr(self, '<STR_LIT>'):<EOL><INDENT>self.feature_table = FeatureTable(self)<EOL><DEDENT>self.feature_table.add_features(features, merge=merge,<EOL>duplicates=duplicates,<EOL>min_studies=min_studies,<EOL>threshold=threshold)<EOL>", "docstring": "Construct a new FeatureTable from file.\n\n        Args:\n            features: Feature data to add. Can be:\n                (a) A text file containing the feature data, where each row is\n                a study in the database, with features in columns. The first\n                column must contain the IDs of the studies to match up with the\n                image data.\n                (b) A pandas DataFrame, where studies are in rows, features are\n                in columns, and the index provides the study IDs.\n            append (bool): If True, adds new features to existing ones\n                incrementally. If False, replaces old features.\n            merge, duplicates, min_studies, threshold: Additional arguments\n                passed to FeatureTable.add_features().", "id": "f5203:c0:m4"}
{"signature": "def create_image_table(self, r=None):", "body": "logger.info(\"<STR_LIT>\")<EOL>if r is not None:<EOL><INDENT>self.r = r<EOL><DEDENT>self.image_table = ImageTable(self)<EOL>", "docstring": "Create and store a new ImageTable instance based on the current\n        Dataset. Will generally be called privately, but may be useful as a\n        convenience method in cases where the user wants to re-generate the\n        table with a new smoothing kernel of different radius.\n\n        Args:\n            r (int): An optional integer indicating the radius of the smoothing\n                kernel. By default, this is None, which will keep whatever\n                value is currently set in the Dataset instance.", "id": "f5203:c0:m2"}
{"signature": "def get_image_data(self, ids=None, voxels=None, dense=True):", "body": "if dense and ids is None and voxels is None:<EOL><INDENT>logger.warning(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>result = self.data<EOL>if ids is not None:<EOL><INDENT>idxs = np.where(np.in1d(np.array(self.ids), np.array(ids)))[<NUM_LIT:0>]<EOL>result = result[:, idxs]<EOL><DEDENT>if voxels is not None:<EOL><INDENT>result = result[voxels, :]<EOL><DEDENT>return result.toarray() if dense else result<EOL>", "docstring": "Slices and returns a subset of image data.\n\n        Args:\n            ids (list, array): A list or 1D numpy array of study ids to\n                return. If None, returns data for all studies.\n            voxels (list, array): A list or 1D numpy array of voxel indices\n                (i.e., rows) to return. If None, returns data for all voxels.\n            dense (bool): Optional boolean. When True (default), convert the\n                result to a dense array before returning. When False, keep as\n                sparse matrix.\n\n        Returns:\n          A 2D numpy array with voxels in rows and studies in columns.", "id": "f5203:c1:m1"}
{"signature": "def get_feature_data(self, ids=None, features=None, dense=True):", "body": "result = self.data<EOL>if ids is not None:<EOL><INDENT>result = result.ix[ids]<EOL><DEDENT>if features is not None:<EOL><INDENT>result = result.ix[:, features]<EOL><DEDENT>return result.to_dense() if dense else result<EOL>", "docstring": "Slices and returns a subset of feature data.\n\n        Args:\n            ids (list, array): A list or 1D numpy array of study ids to\n                return rows for. If None, returns data for all studies\n                (i.e., all rows in array).\n            features (list, array): A list or 1D numpy array of named features\n                to return. If None, returns data for all features (i.e., all\n                columns in array).\n            dense (bool): Optional boolean. When True (default), convert the\n                result to a dense array before returning. When False, keep as\n                sparse matrix. Note that if ids is not None, the returned array\n                will always be dense.\n        Returns:\n          A pandas DataFrame with study IDs in rows and features incolumns.", "id": "f5203:c2:m3"}
{"signature": "def save_images_to_file(self, ids, outroot='<STR_LIT>'):", "body": "pass<EOL>", "docstring": "Reconstructs vectorized images corresponding to the specified\n        study ids and saves them to file, prepending with the outroot\n        (default: current directory).", "id": "f5203:c1:m3"}
{"signature": "def _load_activations(self, filename):", "body": "logger.info(\"<STR_LIT>\" % filename)<EOL>activations = pd.read_csv(filename, sep='<STR_LIT:\\t>')<EOL>activations.columns = [col.lower()<EOL>for col in list(activations.columns)]<EOL>mc = ['<STR_LIT:x>', '<STR_LIT:y>', '<STR_LIT:z>', '<STR_LIT:id>', '<STR_LIT>']<EOL>if (set(mc) - set(list(activations.columns))):<EOL><INDENT>logger.error(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>return<EOL><DEDENT>spaces = activations['<STR_LIT>'].unique()<EOL>xyz = activations[['<STR_LIT:x>', '<STR_LIT:y>', '<STR_LIT:z>']].values<EOL>for s in spaces:<EOL><INDENT>if s != self.transformer.target:<EOL><INDENT>inds = activations['<STR_LIT>'] == s<EOL>xyz[inds] = self.transformer.apply(s, xyz[inds])<EOL><DEDENT><DEDENT>activations[['<STR_LIT:x>', '<STR_LIT:y>', '<STR_LIT:z>']] = xyz<EOL>ijk = pd.DataFrame(<EOL>transformations.xyz_to_mat(xyz), columns=['<STR_LIT:i>', '<STR_LIT>', '<STR_LIT:k>'])<EOL>activations = pd.concat([activations, ijk], axis=<NUM_LIT:1>)<EOL>return activations<EOL>", "docstring": "Load activation data from a text file.\n\n        Args:\n            filename (str): a string pointing to the location of the txt file\n                to read from.", "id": "f5203:c0:m1"}
{"signature": "def t88_to_mni():", "body": "return np.array([[<NUM_LIT>, <NUM_LIT>, -<NUM_LIT>, -<NUM_LIT>],<EOL>[-<NUM_LIT>, <NUM_LIT>, -<NUM_LIT>, -<NUM_LIT>],<EOL>[<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>],<EOL>[<NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT:1.0>]]).T<EOL>", "docstring": "Convert Talairach to MNI coordinates using the Lancaster transform.\n    Adapted from BrainMap scripts; see http://brainmap.org/icbm2tal/\n    Details are described in Lancaster et al. (2007)\n    (http://brainmap.org/new/pubs/LancasterHBM07.pdf).", "id": "f5205:m3"}
{"signature": "def mat_to_xyz(foci, mat_dims=None, xyz_dims=None):", "body": "foci = np.hstack((foci, np.ones((foci.shape[<NUM_LIT:0>], <NUM_LIT:1>))))<EOL>mat = np.array([[-<NUM_LIT:2>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT>], [<NUM_LIT:0>, <NUM_LIT:2>, <NUM_LIT:0>, -<NUM_LIT>], [<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:2>, -<NUM_LIT>]]).T<EOL>result = np.dot(foci, mat)[:, ::-<NUM_LIT:1>]  <EOL>return np.round_(result).astype(int)<EOL>", "docstring": "Convert an N x 3 array of matrix indices to XYZ coordinates.", "id": "f5205:m2"}
{"signature": "def classify_regions(dataset, masks, method='<STR_LIT>', threshold=<NUM_LIT>,<EOL>remove_overlap=True, regularization='<STR_LIT>',<EOL>output='<STR_LIT>', studies=None, features=None,<EOL>class_weight='<STR_LIT>', classifier=None,<EOL>cross_val='<STR_LIT>', param_grid=None, scoring='<STR_LIT>'):", "body": "(X, y) = get_studies_by_regions(dataset, masks, threshold, remove_overlap,<EOL>studies, features,<EOL>regularization=regularization)<EOL>return classify(X, y, method, classifier, output, cross_val,<EOL>class_weight, scoring=scoring, param_grid=param_grid)<EOL>", "docstring": "Perform classification on specified regions\n\n        Given a set of masks, this function retrieves studies associated with\n        each mask at the specified threshold, optionally removes overlap and\n        filters by studies and features. Then it trains an algorithm to\n        classify studies based on features and tests performance.\n\n        Args:\n            dataset: a Neurosynth dataset\n            maks: a list of paths to Nifti masks\n            method: a string indicating which method to used.\n                'SVM': Support Vector Classifier with rbf kernel\n                'ERF': Extremely Randomized Forest classifier\n                'Dummy': A dummy classifier using stratified classes as\n                    predictor\n            threshold: percentage of voxels active within the mask for study\n                to be included\n            remove_overlap: A boolean indicating if studies studies that\n                appear in more than one mask should be excluded\n            regularization: A string indicating type of regularization to use.\n                If None, performs no regularization.\n                'scale': Unit scale without demeaning\n            output: A string indicating output type\n                'summary': Dictionary with summary statistics including score\n                    and n\n                'summary_clf': Same as above but also includes classifier\n                'clf': Only returns classifier\n                Warning: using cv without grid will return an untrained\n                classifier\n            studies: An optional list of study names used to constrain the set\n                used in classification. If None, will use all features in the\n                dataset.\n            features: An optional list of feature names used to constrain the\n                set used in classification. If None, will use all features in\n                the dataset.\n            class_weight: Parameter to pass to classifier determining how to\n                weight classes\n            classifier: An optional sci-kit learn classifier to use instead of\n                pre-set up classifiers set up using 'method'\n            cross_val: A string indicating type of cross validation to use.\n                Can also pass a scikit_classifier\n            param_grid: A dictionary indicating which parameters to optimize\n                using GridSearchCV. If None, no GridSearch will be used\n\n        Returns:\n            A tuple (X, y) of np arrays.\n            X is a feature by studies matrix and y is a vector of class labels", "id": "f5208:m6"}
{"signature": "def get_feature_order(dataset, features):", "body": "all_features = dataset.get_feature_names()<EOL>i = [all_features.index(f) for f in features]<EOL>return i<EOL>", "docstring": "Returns a list with the order that features requested appear in\n    dataset", "id": "f5208:m5"}
{"signature": "def _pearson_correlation(self, imgs_to_decode):", "body": "x, y = imgs_to_decode.astype(float), self.feature_images.astype(float)<EOL>return self._xy_corr(x, y)<EOL>", "docstring": "Decode images using Pearson's r.\n\n        Computes the correlation between each input image and each feature\n        image across voxels.\n\n        Args:\n            imgs_to_decode: An ndarray of images to decode, with voxels in rows\n                and images in columns.\n\n        Returns:\n            An n_features x n_images 2D array, with each cell representing the\n            pearson correlation between the i'th feature and the j'th image\n            across all voxels.", "id": "f5212:c0:m8"}
{"signature": "def load_features(self, features, image_type=None, from_array=False,<EOL>threshold=<NUM_LIT>):", "body": "if from_array:<EOL><INDENT>if isinstance(features, list):<EOL><INDENT>features = features[<NUM_LIT:0>]<EOL><DEDENT>self._load_features_from_array(features)<EOL><DEDENT>elif path.exists(features[<NUM_LIT:0>]):<EOL><INDENT>self._load_features_from_images(features)<EOL><DEDENT>else:<EOL><INDENT>self._load_features_from_dataset(<EOL>features, image_type=image_type, threshold=threshold)<EOL><DEDENT>", "docstring": "Load features from current Dataset instance or a list of files.\n        Args:\n            features: List containing paths to, or names of, features to\n                extract. Each element in the list must be a string containing\n                either a path to an image, or the name of a feature (as named\n                in the current Dataset). Mixing of paths and feature names\n                within the list is not allowed.\n            image_type: Optional suffix indicating which kind of image to use\n                for analysis. Only used if features are taken from the Dataset;\n                if features is a list of filenames, image_type is ignored.\n            from_array: If True, the features argument is interpreted as a\n                string pointing to the location of a 2D ndarray on disk\n                containing feature data, where rows are voxels and columns are\n                individual features.\n            threshold: If features are taken from the dataset, this is the\n                threshold passed to the meta-analysis module to generate fresh\n                images.", "id": "f5212:c0:m3"}
{"signature": "def decode(self, images, save=None, round=<NUM_LIT:4>, names=None, **kwargs):", "body": "if isinstance(images, string_types):<EOL><INDENT>images = [images]<EOL><DEDENT>if isinstance(images, list):<EOL><INDENT>imgs_to_decode = imageutils.load_imgs(images, self.masker)<EOL><DEDENT>else:<EOL><INDENT>imgs_to_decode = images<EOL><DEDENT>methods = {<EOL>'<STR_LIT>': self._pearson_correlation,<EOL>'<STR_LIT>': self._dot_product,<EOL>'<STR_LIT>': self._roi_association<EOL>}<EOL>result = np.around(<EOL>methods[self.method](imgs_to_decode, **kwargs), round)<EOL>if names is None:<EOL><INDENT>if type(images).__module__ == np.__name__:<EOL><INDENT>names = ['<STR_LIT>' % i for i in range(images.shape[<NUM_LIT:1>])]<EOL><DEDENT>elif self.method == '<STR_LIT>':<EOL><INDENT>names = ['<STR_LIT>' % i for i in range(result.shape[<NUM_LIT:1>])]<EOL><DEDENT>else:<EOL><INDENT>names = images<EOL><DEDENT><DEDENT>result = pd.DataFrame(result, columns=names, index=self.feature_names)<EOL>if save is not None:<EOL><INDENT>result.to_csv(save, index_label='<STR_LIT>')<EOL><DEDENT>return result<EOL>", "docstring": "Decodes a set of images.\n\n        Args:\n          images: The images to decode. Can be:\n            - A single String specifying the filename of the image to decode\n            - A list of filenames\n            - A single NumPy array containing the image data\n          save: Optional filename to save results to. If None (default), returns\n            all results as an array.\n          round: Optional integer indicating number of decimals to round result\n            to. Defaults to 4.\n          names: Optional list of names corresponding to the images in filenames.\n            If passed, must be of same length and in same order as filenames.\n            By default, the columns in the output will be named using the image\n            filenames.\n\n        Returns:\n          An n_features x n_files numpy array, where each feature is a row and\n          each image is a column. The meaning of the values depends on the\n          decoding method used.", "id": "f5212:c0:m1"}
{"signature": "def _load_features_from_dataset(self, features=None, image_type=None,<EOL>threshold=<NUM_LIT>):", "body": "self.feature_names = self.dataset.feature_table.feature_names<EOL>if features is not None:<EOL><INDENT>self.feature_names = [f for f in features<EOL>if f in self.feature_names]<EOL><DEDENT>from neurosynth.analysis import meta<EOL>self.feature_images = meta.analyze_features(<EOL>self.dataset, self.feature_names, image_type=image_type,<EOL>threshold=threshold)<EOL>if self.masker.layers:<EOL><INDENT>in_mask = self.masker.get_mask(in_global_mask=True)<EOL>self.feature_images = self.feature_images[in_mask, :]<EOL><DEDENT>", "docstring": "Load feature image data from the current Dataset instance. See\n        load_features() for documentation.", "id": "f5212:c0:m5"}
{"signature": "def two_way(cells):", "body": "<EOL>warnings.simplefilter(\"<STR_LIT:ignore>\", RuntimeWarning)<EOL>cells = cells.astype('<STR_LIT>')  <EOL>total = np.apply_over_axes(np.sum, cells, [<NUM_LIT:1>, <NUM_LIT:2>]).ravel()<EOL>chi_sq = np.zeros(cells.shape, dtype='<STR_LIT>')<EOL>for i in range(<NUM_LIT:2>):<EOL><INDENT>for j in range(<NUM_LIT:2>):<EOL><INDENT>exp = np.sum(cells[:, i, :], <NUM_LIT:1>).ravel() *np.sum(cells[:, :, j], <NUM_LIT:1>).ravel() / total<EOL>bad_vox = np.where(exp == <NUM_LIT:0>)[<NUM_LIT:0>]<EOL>chi_sq[:, i, j] = (cells[:, i, j] - exp) ** <NUM_LIT:2> / exp<EOL>chi_sq[bad_vox, i, j] = <NUM_LIT:1.0>  <EOL><DEDENT><DEDENT>chi_sq = np.apply_over_axes(np.sum, chi_sq, [<NUM_LIT:1>, <NUM_LIT:2>]).ravel()<EOL>return special.chdtrc(<NUM_LIT:1>, chi_sq)<EOL>", "docstring": "Two-way chi-square test of independence.\n    Takes a 3D array as input: N(voxels) x 2 x 2, where the last two dimensions\n    are the contingency table for each of N voxels. Returns an array of\n    p-values.", "id": "f5213:m1"}
{"signature": "def account_info(self):", "body": "return self._get('<STR_LIT>')<EOL>", "docstring": "Requests everything account related (total used storage, reward, ...).\n\n        Returns:\n            dict: dictionary containing account related info. ::\n\n                      {\n                        \"extid\": \"extuserid\",\n                        \"email\": \"jeff@openload.io\",\n                        \"signup_at\": \"2015-01-09 23:59:54\",\n                        \"storage_left\": -1,\n                        \"storage_used\": \"32922117680\",\n                        \"traffic\": {\n                          \"left\": -1,\n                          \"used_24h\": 0\n                        },\n                        \"balance\": 0\n                      }", "id": "f5237:c0:m4"}
{"signature": "def _get(self, url, params=None):", "body": "if not params:<EOL><INDENT>params = {}<EOL><DEDENT>params.update({'<STR_LIT>': self.login, '<STR_LIT:key>': self.key})<EOL>response_json = requests.get(self.api_url + url, params).json()<EOL>return self._process_response(response_json)<EOL>", "docstring": "Used by every other method, it makes a GET request with the given params.\n\n        Args:\n            url (str): relative path of a specific service (account_info, ...).\n            params (:obj:`dict`, optional): contains parameters to be sent in the GET request.\n\n        Returns:\n            dict: results of the response of the GET request.", "id": "f5237:c0:m3"}
{"signature": "def get_download_link(self, file_id, ticket, captcha_response=None):", "body": "params = {'<STR_LIT>': ticket, '<STR_LIT:file>': file_id}<EOL>if captcha_response:<EOL><INDENT>params['<STR_LIT>'] = captcha_response<EOL><DEDENT>return self._get('<STR_LIT>', params)<EOL>", "docstring": "Requests direct download link for requested file,\n        this method makes use of the response of prepare_download, prepare_download must be called first.\n\n        Args:\n            file_id (str): id of the file to be downloaded.\n\n            ticket (str): preparation ticket is found in prepare_download response,\\\n                          this is why we need to call prepare_download before get_download_link.\n\n            captcha_response (:obj:`str`, optional): sometimes prepare_download will have captcha url to be solved, \\\n                                                     first, this is the solution of the captcha.\n\n        Returns:\n            dict: dictionary containing (file info, download url, ...). ::\n\n                  {\n                    \"name\": \"The quick brown fox.txt\",\n                    \"size\": 12345,\n                    \"sha1\": \"2fd4e1c67a2d28fced849ee1bb76e7391b93eb12\",\n                    \"content_type\": \"plain/text\",\n                    \"upload_at\": \"2011-01-26 13:33:37\",\n                    \"url\": \"https://abvzps.example.com/dl/l/4spxX_-cSO4/The+quick+brown+fox.txt\",\n                    \"token\": \"4spxX_-cSO4\"\n                  }", "id": "f5237:c0:m6"}
{"signature": "@classmethod<EOL><INDENT>def _check_status(cls, response_json):<DEDENT>", "body": "status = response_json['<STR_LIT:status>']<EOL>msg = response_json['<STR_LIT>']<EOL>if status == <NUM_LIT>:<EOL><INDENT>raise BadRequestException(msg)<EOL><DEDENT>elif status == <NUM_LIT>:<EOL><INDENT>raise PermissionDeniedException(msg)<EOL><DEDENT>elif status == <NUM_LIT>:<EOL><INDENT>raise FileNotFoundException(msg)<EOL><DEDENT>elif status == <NUM_LIT>:<EOL><INDENT>raise UnavailableForLegalReasonsException(msg)<EOL><DEDENT>elif status == <NUM_LIT>:<EOL><INDENT>raise BandwidthUsageExceeded(msg)<EOL><DEDENT>elif status >= <NUM_LIT>:<EOL><INDENT>raise ServerErrorException(msg)<EOL><DEDENT>", "docstring": "Check the status of the incoming response, raise exception if status is not 200.\n\n        Args:\n            response_json (dict): results of the response of the GET request.\n\n        Returns:\n           None", "id": "f5237:c0:m1"}
{"signature": "def rename_file(self, file_id, name):", "body": "return self._get('<STR_LIT>', params={'<STR_LIT:file>': file_id, '<STR_LIT:name>': name})<EOL>", "docstring": "Sets a new name for a file\n\n        Args:\n            file_id (str): id of the file to be renamed.\n            name (str): new name for the provided file.\n\n        Returns:\n            bool: True if file is renamed, otherwise False.", "id": "f5237:c0:m14"}
{"signature": "def file_info(self, file_id):", "body": "return self._get('<STR_LIT>', params={'<STR_LIT:file>': file_id})<EOL>", "docstring": "Used to request info for a specific file, info like size, name, .....\n\n        Args:\n            file_id (str): File-ID(s), single file or comma-separated (max. 50)\n\n        Returns:\n            dict: dictionary containing file(s) info, each key represents a file_id. ::\n\n                  {\n                     \"72fA-_Lq8Ak3\": {\n                        \"id\": \"72fA-_Lq8Ak3\",\n                        \"status\": 200,\n                        \"name\": \"The quick brown fox.txt\",\n                        \"size\": 123456789012,\n                        \"sha1\": \"2fd4e1c67a2d28fced849ee1bb76e7391b93eb12\",\n                        \"content_type\": \"plain/text\",\n                     },\n                     \"72fA-_Lq8Ak4\": {\n                        \"id\": \"72fA-_Lq8Ak4\",\n                        \"status\": 500,\n                        \"name\": \"The quick brown fox.txt\",\n                        \"size\": false,\n                        \"sha1\": \"2fd4e1c67a2d28fced849ee1bb76e7391b93eb12\",\n                        \"content_type\": \"plain/text\",\n                     },\n                     ...\n                   }", "id": "f5237:c0:m7"}
{"signature": "def delete_file(self, file_id):", "body": "return self._get('<STR_LIT>', params={'<STR_LIT:file>': file_id})<EOL>", "docstring": "Removes one of your files\n\n        Args:\n            file_id (str): id of the file to be deleted.\n\n        Returns:\n            bool: True if file is deleted, otherwise False.", "id": "f5237:c0:m15"}
{"signature": "def splash_image(self, file_id):", "body": "return self._get('<STR_LIT>', params={'<STR_LIT:file>': file_id})<EOL>", "docstring": "Shows the video splash image (thumbnail)\n\n        Args:\n            file_id (str): id of the target file.\n\n        Returns:\n            str: url for the splash image.", "id": "f5237:c0:m19"}
{"signature": "def parse_commits(data):", "body": "raw_commits = RE_COMMIT.finditer(data)<EOL>for rc in raw_commits:<EOL><INDENT>full_commit = rc.groups()[<NUM_LIT:0>]<EOL>parts = RE_COMMIT.match(full_commit).groupdict()<EOL>parsed_commit = parse_commit(parts)<EOL>yield parsed_commit<EOL><DEDENT>", "docstring": "Accept a string and parse it into many commits.\n    Parse and yield each commit-dictionary.\n    This function is a generator.", "id": "f5245:m0"}
{"signature": "def get_ext(name):", "body": "other, sep, ext = name.partition('<STR_LIT:.>')<EOL>return ext<EOL>", "docstring": "Return the extension only for a name (like a filename)\n\n>>> get_ext('foo.bar')\n'bar'\n>>> get_ext('.only')\n'only'\n>>> get_ext('')\n''\n>>> get_ext('noext')\n''\n>>> get_ext('emptyext.')\n''\n\nNote that for any non-empty string, the result will never be the\nsame as the input. This is a useful property for basepack.", "id": "f5249:m2"}
{"signature": "def save(self, target=None):", "body": "target = target or getattr(self, '<STR_LIT:filename>', None)<EOL>if isinstance(target, six.string_types):<EOL><INDENT>self.filename = target<EOL>target = open(target, '<STR_LIT:wb>')<EOL><DEDENT>if target is None:<EOL><INDENT>msg = (<EOL>\"<STR_LIT>\"<EOL>% self.__class__.__name__<EOL>)<EOL>raise ValueError(msg)<EOL><DEDENT>self._store(target)<EOL>", "docstring": "Save this package to target, which should be a filename or open\nfile stream. If target is not supplied, and this package has a\nfilename attribute (such as when this package was created from\nan existing file), it will be used.", "id": "f5251:c0:m3"}
{"signature": "def __getitem__(self, name):", "body": "return self.parts[name]<EOL>", "docstring": "Returns a part from the given URL.", "id": "f5255:c1:m2"}
{"signature": "def related(self, reltype):", "body": "parts = []<EOL>package = getattr(self, '<STR_LIT>', None) or self<EOL>for rel in self.relationships.types.get(reltype, []):<EOL><INDENT>parts.append(package[posixpath.join(self.base, rel.target)])<EOL><DEDENT>return parts<EOL>", "docstring": "Return a list of parts related to this one via reltype.", "id": "f5255:c0:m1"}
{"signature": "def __new__(mcs, name, bases, attrs):", "body": "<EOL>cls = type.__new__(mcs, name, bases, attrs)<EOL>if not hasattr(cls, '<STR_LIT>'):<EOL><INDENT>cls.classes_by_rel_type = defaultdict(lambda: cls)<EOL><DEDENT>rt = attrs.get('<STR_LIT>', None)<EOL>if rt:<EOL><INDENT>cls.classes_by_rel_type[rt] = cls<EOL><DEDENT>return cls<EOL>", "docstring": "This is called when a new class is created of this type", "id": "f5255:c3:m0"}
{"signature": "def find_for(self, name):", "body": "map = self.items<EOL>return map.get(name, None) or map.get(get_ext(name) or None, None)<EOL>", "docstring": "Get the correct content type for a given name", "id": "f5255:c7:m7"}
{"signature": "def _load_content_types(self, source):", "body": "self.content_types.update(ContentTypes.load(source))<EOL>", "docstring": "Load up the content_types object with value from source XML.", "id": "f5255:c1:m11"}
{"signature": "def derived(self, name, relative_coords, formula):", "body": "relZ, relN = relative_coords<EOL>daughter_idx = [(x[<NUM_LIT:0>] + relZ, x[<NUM_LIT:1>] + relN) for x in self.df.index]<EOL>values = formula(self.df.values, self.df.loc[daughter_idx].values)<EOL>return Table(df=pd.Series(values, index=self.df.index, name=name + '<STR_LIT:(>' + self.name + '<STR_LIT:)>'))<EOL>", "docstring": "Helper function for derived quantities", "id": "f5263:c0:m38"}
{"signature": "@property<EOL><INDENT>@memoize<EOL>def s1p(self):<DEDENT>", "body": "M_P = <NUM_LIT>         <EOL>f = lambda parent, daugther: -parent + daugther + M_P<EOL>return self.derived('<STR_LIT>', (-<NUM_LIT:1>, <NUM_LIT:0>), f)<EOL>", "docstring": "Return 1 proton separation energy", "id": "f5263:c0:m37"}
{"signature": "@property<EOL><INDENT>@memoize<EOL>def s1n(self):<DEDENT>", "body": "M_N = <NUM_LIT>         <EOL>f = lambda parent, daugther: -parent + daugther + M_N<EOL>return self.derived('<STR_LIT>', (<NUM_LIT:0>, -<NUM_LIT:1>), f)<EOL>", "docstring": "Return 1 neutron separation energy", "id": "f5263:c0:m35"}
{"signature": "@property<EOL><INDENT>def A(self):<DEDENT>", "body": "return self.Z + self.N<EOL>", "docstring": "Return the mass number A for all nuclei in the table as a numpy array.", "id": "f5263:c0:m9"}
{"signature": "def select(self, condition, name='<STR_LIT>'):", "body": "if condition.__code__.co_argcount == <NUM_LIT:1>:<EOL><INDENT>idx = [(Z, N) for (Z, N), M in self if condition(M)]<EOL><DEDENT>if condition.__code__.co_argcount == <NUM_LIT:2>:<EOL><INDENT>idx = [(Z, N) for (Z, N) in self.index if condition(Z, N)]<EOL><DEDENT>if condition.__code__.co_argcount == <NUM_LIT:3>:<EOL><INDENT>idx = [(Z, N) for (Z, N), M in self if condition(Z, N, M)]<EOL><DEDENT>index = pd.MultiIndex.from_tuples(idx, names=['<STR_LIT>', '<STR_LIT:N>'])<EOL>return Table(df=self.df.ix[index], name=name)<EOL>", "docstring": "Selects nuclei according to a condition on Z,N or M\n\nParameters\n----------\ncondition : function,\n    Can have one of the signatures f(M), f(Z,N) or f(Z, N, M)\n    must return a boolean value\nname: string, optional name for the resulting Table\n\nExample:\n--------\nSelect all nuclei with A > 160:\n\n>>> A_gt_160 = lambda Z,N: Z + N > 160\n>>> Table('AME2003').select(A_gt_160)", "id": "f5263:c0:m18"}
{"signature": "@classmethod<EOL><INDENT>def from_name(cls, name):<DEDENT>", "body": "filename = os.path.join(package_dir, '<STR_LIT:data>', name + '<STR_LIT>')<EOL>return cls.from_file(filename, name)<EOL>", "docstring": "Imports a mass table from a file", "id": "f5263:c0:m2"}
{"signature": "@property<EOL><INDENT>def Z(self):<DEDENT>", "body": "return self.df.index.get_level_values('<STR_LIT>').values<EOL>", "docstring": "Return the proton number Z for all nuclei in the table as a numpy array.", "id": "f5263:c0:m7"}
{"signature": "@property<EOL><INDENT>@memoize<EOL>def even_odd(self):<DEDENT>", "body": "return self.select(lambda Z, N: not(Z % <NUM_LIT:2>) and (N % <NUM_LIT:2>), name=self.name)<EOL>", "docstring": "Selects even-odd nuclei from the table", "id": "f5263:c0:m27"}
{"signature": "@property<EOL><INDENT>@memoize<EOL>def odd_odd(self):<DEDENT>", "body": "return self.select(lambda Z, N: (Z % <NUM_LIT:2>) and (N % <NUM_LIT:2>), name=self.name)<EOL>", "docstring": "Selects odd-odd nuclei from the table:\n\n        >>> Table('FRDM95').odd_odd\n        Out[13]:\n        Z   N\n        9   9       1.21\n            11      0.10\n            13      3.08\n            15      9.32\n        ...", "id": "f5263:c0:m25"}
{"signature": "def __init__(self, name='<STR_LIT>', df=None):", "body": "if df is not None:  <EOL><INDENT>self.df = df<EOL>self.name = name<EOL><DEDENT>elif name in self._names:  <EOL><INDENT>self.name = name<EOL>self.df = self.from_name(name).df<EOL><DEDENT>else:<EOL><INDENT>print ('<STR_LIT>')<EOL>print(('<STR_LIT:U+0020>'.join(Table.names)))<EOL>return None<EOL><DEDENT>", "docstring": "Init from a Series/Dataframe (df) of a file (name)", "id": "f5263:c0:m0"}
{"signature": "@property<EOL><INDENT>def count(self):<DEDENT>", "body": "return len(self.df)<EOL>", "docstring": "Return the total number of nuclei in the table:\n\n        >>> Table('AME2012').count\n        2438\n\n        It is also possible to do:\n\n        >>> len(Table('AME2012'))\n        2438", "id": "f5263:c0:m22"}
{"signature": "def error(self, relative_to='<STR_LIT>'):", "body": "df = self.df - Table(relative_to).df<EOL>return Table(df=df)<EOL>", "docstring": "Calculate error difference\n\nParameters\n----------\nrelative_to : string,\n    a valid mass table name.\n\nExample:\n----------\n>>> Table('DUZU').error(relative_to='AME2003')", "id": "f5263:c0:m29"}
{"signature": "@property<EOL><INDENT>@memoize<EOL>def s2p(self):<DEDENT>", "body": "M_P = <NUM_LIT>         <EOL>f = lambda parent, daugther: -parent + daugther + <NUM_LIT:2> * M_P<EOL>return self.derived('<STR_LIT>', (-<NUM_LIT:2>, <NUM_LIT:0>), f)<EOL>", "docstring": "Return 2 proton separation energy", "id": "f5263:c0:m36"}
{"signature": "@classmethod<EOL><INDENT>def from_file(cls, filename, name='<STR_LIT>'):<DEDENT>", "body": "df = pd.read_csv(filename, header=<NUM_LIT:0>, delim_whitespace=True, index_col=[<NUM_LIT:0>, <NUM_LIT:1>])['<STR_LIT:M>']<EOL>df.name = name<EOL>return cls(df=df, name=name)<EOL>", "docstring": "Imports a mass table from a file", "id": "f5263:c0:m3"}
{"signature": "@property<EOL><INDENT>@memoize<EOL>def q_alpha(self):<DEDENT>", "body": "M_ALPHA = <NUM_LIT>         <EOL>f = lambda parent, daugther: parent - daugther - M_ALPHA<EOL>return self.derived('<STR_LIT>', (-<NUM_LIT:2>, -<NUM_LIT:2>), f)<EOL>", "docstring": "Return Q_alpha", "id": "f5263:c0:m32"}
{"signature": "def chart_plot(self, ax=None, cmap='<STR_LIT>',<EOL>xlabel='<STR_LIT:N>', ylabel='<STR_LIT>', grid_on=True, colorbar=True):", "body": "from matplotlib.mlab import griddata<EOL>from numpy import linspace, meshgrid<EOL>import matplotlib.pyplot as plt<EOL>x = self.dropna().N<EOL>y = self.dropna().Z<EOL>z = self.dropna().values<EOL>xi = linspace(min(x), max(x), max(x) - min(x) + <NUM_LIT:1>)<EOL>yi = linspace(min(y), max(y), max(y) - min(y) + <NUM_LIT:1>)<EOL>Z = griddata(x, y, z, xi, yi)<EOL>X, Y = meshgrid(xi, yi)<EOL>if ax is None:<EOL><INDENT>ax = plt.gca()<EOL><DEDENT>chart = ax.pcolormesh(X, Y, Z, cmap=cmap)<EOL>ax.set_xlabel(xlabel)<EOL>ax.set_ylabel(ylabel)<EOL>ax.grid(grid_on)<EOL>ax.set_aspect('<STR_LIT>')<EOL>if colorbar:<EOL><INDENT>plt.colorbar(chart)<EOL><DEDENT>return ax<EOL>", "docstring": "Plot a nuclear chart with (N,Z) as axis and the values\n        of the Table as a color scale\n\n        Parameters\n        ----------\n        ax: optional matplotlib axes\n                defaults to current axes\n        cmap: a matplotlib colormap\n                default: 'RdBu'\n        xlabel: string representing the label of the x axis\n            default: 'N'\n        ylabel: string, default: 'Z'\n            the label of the x axis\n        grid_on: boolean, default: True,\n            whether to draw the axes grid or not\n        colorbar: boolean, default: True\n            whether to draw a colorbar or not\n\n        Returns\n        -------\n        ax: a matplotlib axes object\n\n        Example\n        -------\n        Plot the theoretical deviation for the M\u00f6ller's model::\n\n        >>> Table('FRDM95').error().chart_plot()", "id": "f5263:c0:m44"}
{"signature": "def _add_ones_dim(arr):", "body": "arr = arr[..., np.newaxis]<EOL>return np.concatenate((arr, np.ones_like(arr)), axis=-<NUM_LIT:1>)<EOL>", "docstring": "Adds a dimensions with ones to array.", "id": "f5268:m2"}
{"signature": "@command(aliases='<STR_LIT>')<EOL>def fm(client, event, channel, nick, rest):", "body": "if rest:<EOL><INDENT>rest = rest.strip()<EOL>Karma.store.change(rest, <NUM_LIT:2>)<EOL>rcpt = rest<EOL><DEDENT>else:<EOL><INDENT>rcpt = channel<EOL><DEDENT>return f'<STR_LIT>'<EOL>", "docstring": "pmxbot parle fran\u00e7ais", "id": "f5280:m2"}
{"signature": "def op_and(self, *elements):", "body": "expression = self.add_operator(Operator('<STR_LIT:;>'))<EOL>for element in elements:<EOL><INDENT>expression.add_element(element)<EOL><DEDENT>return expression<EOL>", "docstring": "Update the ``Expression`` by joining the specified additional\n        ``elements`` using an \"AND\" ``Operator``\n\n        Args:\n            *elements (BaseExpression): The ``Expression`` and/or\n                ``Constraint`` elements which the \"AND\" ``Operator`` applies\n                to.\n\n        Returns:\n            Expression: ``self`` or related ``Expression``.", "id": "f5318:c1:m5"}
{"signature": "def __init__(self):", "body": "self.parent = None<EOL>", "docstring": "Initialize instance of ``BaseExpression``.", "id": "f5318:c0:m0"}
{"signature": "def create_nested_expression(self):", "body": "sub = Expression()<EOL>self.add_element(sub)<EOL>return sub<EOL>", "docstring": "Create a nested ``Expression``, add it as an element to this\n        ``Expression``, and return it.\n\n        Returns:\n            Expression: The newly created nested ``Expression``.", "id": "f5318:c1:m4"}
{"signature": "def __init__(self):", "body": "super(Expression, self).__init__()<EOL>self.elements = []<EOL>self.operator = None<EOL>self._working_fragment = self<EOL>self._last_element = None<EOL>", "docstring": "Initialize instance of ``Expression``.", "id": "f5318:c1:m0"}
{"signature": "def to_python(self):", "body": "if len(self.elements) == <NUM_LIT:0>:<EOL><INDENT>return None<EOL><DEDENT>if len(self.elements) == <NUM_LIT:1>:<EOL><INDENT>return self.elements[<NUM_LIT:0>].to_python()<EOL><DEDENT>operator = self.operator or Operator('<STR_LIT:;>')<EOL>return [operator.to_python()] +[elem.to_python() for elem in self.elements]<EOL>", "docstring": "Deconstruct the ``Expression`` instance to a list or tuple\n        (If ``Expression`` contains only one ``Constraint``).\n\n        Returns:\n            list or tuple: The deconstructed ``Expression``.", "id": "f5318:c1:m7"}
{"signature": "def add_operator(self, operator):", "body": "if not isinstance(operator, Operator):<EOL><INDENT>raise FiqlObjectException(\"<STR_LIT>\" % (<EOL>operator.__class__))<EOL><DEDENT>if not self._working_fragment.operator:<EOL><INDENT>self._working_fragment.operator = operator<EOL><DEDENT>elif operator > self._working_fragment.operator:<EOL><INDENT>last_constraint = self._working_fragment.elements.pop()<EOL>self._working_fragment = self._working_fragment.create_nested_expression()<EOL>self._working_fragment.add_element(last_constraint)<EOL>self._working_fragment.add_operator(operator)<EOL><DEDENT>elif operator < self._working_fragment.operator:<EOL><INDENT>if self._working_fragment.parent:<EOL><INDENT>return self._working_fragment.parent.add_operator(operator)<EOL><DEDENT>else:<EOL><INDENT>return Expression().add_element(self._working_fragment).add_operator(operator)<EOL><DEDENT><DEDENT>return self<EOL>", "docstring": "Add an ``Operator`` to the ``Expression``.\n\n        The ``Operator`` may result in a new ``Expression`` if an ``Operator``\n        already exists and is of a different precedence.\n\n        There are three possibilities when adding an ``Operator`` to an\n        ``Expression`` depending on whether or not an ``Operator`` already\n        exists:\n\n          - No ``Operator`` on the working ``Expression``; Simply set the\n            ``Operator`` and return ``self``.\n          - ``Operator`` already exists and is higher in precedence; The\n            ``Operator`` and last ``Constraint`` belong in a sub-expression of\n            the working ``Expression``.\n          - ``Operator`` already exists and is lower in precedence; The\n            ``Operator`` belongs to the parent of the working ``Expression``\n            whether one currently exists or not. To remain in the context of\n            the top ``Expression``, this method will return the parent here\n            rather than ``self``.\n\n        Args:\n            operator (Operator): What we are adding.\n\n        Returns:\n            Expression: ``self`` or related ``Expression``.\n\n        Raises:\n            FiqlObjectExpression: Operator is not a valid ``Operator``.", "id": "f5318:c1:m2"}
{"signature": "def __eq__(self, other):", "body": "return OPERATOR_MAP[self.value][<NUM_LIT:1>] == OPERATOR_MAP[other.value][<NUM_LIT:1>]<EOL>", "docstring": "Of equal precendence.\n\n        Args:\n            other (Operator): The ``Operator`` we are comparing precedence\n                against.\n\n        Returns:\n            boolean: ``True`` if of equal precendence of ``other``.", "id": "f5320:c0:m4"}
{"signature": "def render_login_result(framework_name, result):", "body": "reload_module(sys)<EOL>if six.PY2:<EOL><INDENT>sys.setdefaultencoding('<STR_LIT:utf-8>')<EOL><DEDENT>response = None<EOL>original_credentials = {}<EOL>refreshed_credentials = {}<EOL>if result:<EOL><INDENT>if result.user:<EOL><INDENT>result.user.update()<EOL>if result.user.credentials:<EOL><INDENT>original_credentials.update(result.user.credentials.__dict__)<EOL>time.sleep(<NUM_LIT:2>)<EOL>response = result.user.credentials.refresh(force=True)<EOL>refreshed_credentials.update(result.user.credentials.__dict__)<EOL><DEDENT><DEDENT>user_properties = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:email>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT:id>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT:location>', '<STR_LIT:name>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:username>']<EOL>access_token_content = None<EOL>if hasattr(result.provider, '<STR_LIT>'):<EOL><INDENT>access_token_content = result.provider.access_token_response.content  <EOL><DEDENT>template = env.get_template('<STR_LIT>')<EOL>return template.render(result=result,<EOL>providers=ASSEMBLED_CONFIG.values(),<EOL>oauth2_providers=OAUTH2_PROVIDERS,<EOL>oauth1_providers=OAUTH1_PROVIDERS,<EOL>openid_providers=OPENID_PROVIDERS,<EOL>user_properties=user_properties,<EOL>error=result.error,<EOL>credentials_response=response,<EOL>original_credentials=original_credentials,<EOL>refreshed_credentials=refreshed_credentials,<EOL>framework_name=framework_name,<EOL>access_token_content=access_token_content,<EOL>birth_date_format=BIRTH_DATE_FORMAT)<EOL><DEDENT>", "docstring": "Renders the login handler.\n\n:param result:\n\n    The :class:`.authomatic.core.LoginResult` returned by the\n    :meth:`.authomatic.Authomatic.login` method.", "id": "f5358:m1"}
{"signature": "def with_metaclass(meta, *bases):", "body": "<EOL>class metaclass(meta):<EOL><INDENT>def __new__(cls, name, this_bases, d):<EOL><INDENT>return meta(name, bases, d)<EOL><DEDENT><DEDENT>return type.__new__(metaclass, '<STR_LIT>', (), {})<EOL>", "docstring": "Create a base class with a metaclass.", "id": "f5359:m7"}
{"signature": "def _import_module(name):", "body": "__import__(name)<EOL>return sys.modules[name]<EOL>", "docstring": "Import module, returning the module after the last dot.", "id": "f5359:m1"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def write(self, value):<DEDENT>", "body": "", "docstring": "Must write specified value to response.\n\n:param str value:\n    String to be written to response.", "id": "f5360:c0:m3"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def values(self):<DEDENT>", "body": "", "docstring": "Same as :meth:`dict.values`.", "id": "f5362:c1:m1"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def save(self):<DEDENT>", "body": "", "docstring": "Called only once per request.\n\nShould implement a mechanism for setting the the session\n**cookie** and saving the session **data** to storage.", "id": "f5362:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def initialize(cls):<DEDENT>", "body": "if not len(cls.query().fetch()):<EOL><INDENT>example = cls.get_or_insert('<STR_LIT>')<EOL>example.class_ = '<STR_LIT>' +'<STR_LIT>'<EOL>example.provider_name = '<STR_LIT>'<EOL>example.consumer_key = '<STR_LIT>'<EOL>example.consumer_secret = '<STR_LIT>'<EOL>example.provider_id = <NUM_LIT:1><EOL>example.scope = '<STR_LIT>'<EOL>example.identifier_param = '<STR_LIT>' +'<STR_LIT>'<EOL>example.put()<EOL>raise GAEError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>", "docstring": "Creates an **\"Example\"** entity of kind **\"NDBConfig\"** in the\ndatastore if the model is empty and raises and error to inform you that\nyou should populate the model with data.\n\n.. note::\n\n    The *Datastore Viewer* in the ``_ah/admin/`` won't let you add\n    properties to a model if there is not an entity with that\n    property already. Therefore it is a good idea to keep the\n    **\"Example\"** entity (which has all possible properties set) in\n    the datastore.", "id": "f5364:c2:m2"}
{"signature": "@classmethod<EOL><INDENT>def values(cls):<DEDENT>", "body": "<EOL>results = cls.query().fetch()<EOL>return [result.to_dict() for result in results]<EOL>", "docstring": "Resembles the :meth:`dict.values` method.", "id": "f5364:c2:m1"}
{"signature": "def backend(self, adapter):", "body": "AUTHOMATIC_HEADER = '<STR_LIT>'<EOL>request_type = adapter.params.get('<STR_LIT:type>', '<STR_LIT>')<EOL>json_input = adapter.params.get('<STR_LIT>')<EOL>credentials = adapter.params.get('<STR_LIT>')<EOL>url = adapter.params.get('<STR_LIT:url>')<EOL>method = adapter.params.get('<STR_LIT>', '<STR_LIT:GET>')<EOL>body = adapter.params.get('<STR_LIT:body>', '<STR_LIT>')<EOL>params = adapter.params.get('<STR_LIT>')<EOL>params = json.loads(params) if params else {}<EOL>headers = adapter.params.get('<STR_LIT>')<EOL>headers = json.loads(headers) if headers else {}<EOL>ProviderClass = Credentials.deserialize(<EOL>self.config, credentials).provider_class<EOL>if request_type == '<STR_LIT>':<EOL><INDENT>jsonp = params.get('<STR_LIT>')<EOL>if ProviderClass.supports_jsonp and method is '<STR_LIT:GET>':<EOL><INDENT>request_type = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>if jsonp:<EOL><INDENT>params.pop('<STR_LIT>')<EOL><DEDENT>request_type = '<STR_LIT>'<EOL><DEDENT><DEDENT>if request_type == '<STR_LIT>':<EOL><INDENT>response = self.access(<EOL>credentials, url, params, method, headers, body)<EOL>result = response.content<EOL>adapter.status = str(response.status) + '<STR_LIT:U+0020>' + str(response.reason)<EOL>for k, v in response.getheaders():<EOL><INDENT>logging.info('<STR_LIT>'.format(k, v))<EOL>adapter.set_header(k, v)<EOL><DEDENT><DEDENT>elif request_type == '<STR_LIT>':<EOL><INDENT>if json_input:<EOL><INDENT>result = self.request_elements(<EOL>json_input=json_input, return_json=True)<EOL><DEDENT>else:<EOL><INDENT>result = self.request_elements(credentials=credentials,<EOL>url=url,<EOL>method=method,<EOL>params=params,<EOL>headers=headers,<EOL>body=body,<EOL>return_json=True)<EOL><DEDENT>adapter.set_header('<STR_LIT:Content-Type>', '<STR_LIT:application/json>')<EOL><DEDENT>else:<EOL><INDENT>result = '<STR_LIT>'<EOL><DEDENT>adapter.set_header(AUTHOMATIC_HEADER, request_type)<EOL>adapter.write(result)<EOL>", "docstring": "Converts a *request handler* to a JSON backend which you can use with\n:ref:`authomatic.js <js>`.\n\nJust call it inside a *request handler* like this:\n\n::\n\n    class JSONHandler(webapp2.RequestHandler):\n        def get(self):\n            authomatic.backend(Webapp2Adapter(self))\n\n:param adapter:\n    The only argument is an :doc:`adapter <adapters>`.\n\nThe *request handler* will now accept these request parameters:\n\n:param str type:\n    Type of the request. Either ``auto``, ``fetch`` or ``elements``.\n    Default is ``auto``.\n\n:param str credentials:\n    Serialized :class:`.Credentials`.\n\n:param str url:\n    URL of the **protected resource** request.\n\n:param str method:\n    HTTP method of the **protected resource** request.\n\n:param str body:\n    HTTP body of the **protected resource** request.\n\n:param JSON params:\n    HTTP params of the **protected resource** request as a JSON object.\n\n:param JSON headers:\n    HTTP headers of the **protected resource** request as a\n    JSON object.\n\n:param JSON json:\n    You can pass all of the aforementioned params except ``type``\n    in a JSON object.\n\n    .. code-block:: javascript\n\n        {\n            \"credentials\": \"######\",\n            \"url\": \"https://example.com\",\n            \"method\": \"POST\",\n            \"params\": {\"foo\": \"bar\"},\n            \"headers\": {\"baz\": \"bing\"},\n            \"body\": \"the body of the request\"\n        }\n\nDepending on the ``type`` param, the handler will either write\na JSON object with *request elements* to the response,\nand add an ``Authomatic-Response-To: elements`` response header, ...\n\n.. code-block:: javascript\n\n    {\n        \"url\": \"https://example.com/api\",\n        \"method\": \"POST\",\n        \"params\": {\n            \"access_token\": \"###\",\n            \"foo\": \"bar\"\n        },\n        \"headers\": {\n            \"baz\": \"bing\",\n            \"Authorization\": \"Bearer ###\"\n        }\n    }\n\n... or make a fetch to the **protected resource** and forward\nit's response content, status and headers with an additional\n``Authomatic-Response-To: fetch`` header to the response.\n\n.. warning::\n\n    The backend will not work if you write anything to the\n    response in the handler!", "id": "f5366:c11:m6"}
{"signature": "def popup_js(self, callback_name=None, indent=None,<EOL>custom=None, stay_open=False):", "body": "custom_callback = \"\"\"<STR_LIT>\"\"\".format(cb=callback_name) if callback_name else '<STR_LIT>'<EOL>return \"\"\"<STR_LIT>\"\"\".format(result=self.to_json(indent),<EOL>custom=json.dumps(custom),<EOL>custom_callback=custom_callback,<EOL>stay_open='<STR_LIT>' if stay_open else '<STR_LIT>')<EOL>", "docstring": "Returns JavaScript that:\n\n#.  Triggers the ``options.onLoginComplete(result, closer)``\n    handler set with the :ref:`authomatic.setup() <js_setup>`\n    function of :ref:`javascript.js <js>`.\n#.  Calls the JavasScript callback specified by :data:`callback_name`\n    on the opener of the *login handler popup* and passes it the\n    *login result* JSON object as first argument and the `closer`\n    function which you should call in your callback to close the popup.\n\n:param str callback_name:\n    The name of the javascript callback e.g ``foo.bar.loginCallback``\n    will result in ``window.opener.foo.bar.loginCallback(result);``\n    in the HTML.\n\n:param int indent:\n    The number of spaces to indent the JSON result object.\n    If ``0`` or negative, only newlines are added.\n    If ``None``, no newlines are added.\n\n:param custom:\n    Any JSON serializable object that will be passed to the\n    ``result.custom`` attribute.\n\n:param str stay_open:\n    If ``True``, the popup will stay open.\n\n:returns:\n    :class:`str` with JavaScript.", "id": "f5366:c7:m1"}
{"signature": "def __init__(self, adapter, secret, name='<STR_LIT>', max_age=<NUM_LIT>,<EOL>secure=False):", "body": "self.adapter = adapter<EOL>self.name = name<EOL>self.secret = secret<EOL>self.max_age = max_age<EOL>self.secure = secure<EOL>self._data = {}<EOL>", "docstring": ":param str secret:\n    Session secret used to sign the session cookie.\n:param str name:\n    Session cookie name.\n:param int max_age:\n    Maximum allowed age of session cookie nonce in seconds.\n:param bool secure:\n    If ``True`` the session cookie will be saved with ``Secure``\n    attribute.", "id": "f5366:c3:m0"}
{"signature": "def __init__(<EOL>self, config, secret, session_max_age=<NUM_LIT>, secure_cookie=False,<EOL>session=None, session_save_method=None, report_errors=True,<EOL>debug=False, logging_level=logging.INFO, prefix='<STR_LIT>',<EOL>logger=None<EOL>):", "body": "self.config = config<EOL>self.secret = secret<EOL>self.session_max_age = session_max_age<EOL>self.secure_cookie = secure_cookie<EOL>self.session = session<EOL>self.session_save_method = session_save_method<EOL>self.report_errors = report_errors<EOL>self.debug = debug<EOL>self.logging_level = logging_level<EOL>self.prefix = prefix<EOL>self._logger = logger or logging.getLogger(str(id(self)))<EOL>if logger is None:<EOL><INDENT>self._logger.setLevel(logging_level)<EOL><DEDENT>", "docstring": "Encapsulates all the functionality of this package.\n\n:param dict config:\n    :doc:`config`\n\n:param str secret:\n    A secret string that will be used as the key for signing\n    :class:`.Session` cookie and as a salt by *CSRF* token generation.\n\n:param session_max_age:\n    Maximum allowed age of :class:`.Session` cookie nonce in seconds.\n\n:param bool secure_cookie:\n    If ``True`` the :class:`.Session` cookie will be saved wit\n    ``Secure`` attribute.\n\n:param session:\n    Custom dictionary-like session implementation.\n\n:param callable session_save_method:\n    A method of the supplied session or any mechanism that saves the\n    session data and cookie.\n\n:param bool report_errors:\n    If ``True`` exceptions encountered during the **login procedure**\n    will be caught and reported in the :attr:`.LoginResult.error`\n    attribute.\n    Default is ``True``.\n\n:param bool debug:\n    If ``True`` traceback of exceptions will be written to response.\n    Default is ``False``.\n\n:param int logging_level:\n    The logging level threshold for the default logger as specified in\n    the standard Python\n    `logging library <http://docs.python.org/2/library/logging.html>`_.\n    This setting is ignored when :data:`logger` is set.\n    Default is ``logging.INFO``.\n\n:param str prefix:\n    Prefix used as the :class:`.Session` cookie name.\n\n:param logger:\n    A :class:`logging.logger` instance.", "id": "f5366:c11:m0"}
{"signature": "@property<EOL><INDENT>def params(self):<DEDENT>", "body": "return self[<NUM_LIT:2>]<EOL>", "docstring": "Dictionary of request parameters.", "id": "f5366:c10:m3"}
{"signature": "def getheaders(self):", "body": "return self.httplib_response.getheaders()<EOL>", "docstring": "Same as :meth:`httplib.HTTPResponse.getheaders`.", "id": "f5366:c8:m4"}
{"signature": "@property<EOL><INDENT>def full_url(self):<DEDENT>", "body": "return self.url + '<STR_LIT:?>' + self.query_string<EOL>", "docstring": "URL with query string.", "id": "f5366:c10:m7"}
{"signature": "def normalize_dict(dict_):", "body": "return dict([(k, v[<NUM_LIT:0>] if not isinstance(v, str) and len(v) == <NUM_LIT:1> else v)<EOL>for k, v in list(dict_.items())])<EOL>", "docstring": "Replaces all values that are single-item iterables with the value of its\nindex 0.\n\n:param dict dict_:\n    Dictionary to normalize.\n\n:returns:\n    Normalized dictionary.", "id": "f5366:m0"}
{"signature": "def create_cookie(self, delete=None):", "body": "value = '<STR_LIT>' if delete else self._serialize(self.data)<EOL>split_url = parse.urlsplit(self.adapter.url)<EOL>domain = split_url.netloc.split('<STR_LIT::>')[<NUM_LIT:0>]<EOL>if '<STR_LIT:.>' not in domain:<EOL><INDENT>template = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>template = ('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>return template.format(<EOL>name=self.name,<EOL>value=value,<EOL>domain=domain,<EOL>path=split_url.path,<EOL>secure='<STR_LIT>' if self.secure else '<STR_LIT>',<EOL>expires='<STR_LIT>' if delete else '<STR_LIT>'<EOL>)<EOL>", "docstring": "Creates the value for ``Set-Cookie`` HTTP header.\n\n:param bool delete:\n    If ``True`` the cookie value will be ``deleted`` and the\n    Expires value will be ``Thu, 01-Jan-1970 00:00:01 GMT``.", "id": "f5366:c3:m1"}
{"signature": "@property<EOL><INDENT>def valid(self):<DEDENT>", "body": "if self.expiration_time:<EOL><INDENT>return self.expiration_time > int(time.time())<EOL><DEDENT>else:<EOL><INDENT>return True<EOL><DEDENT>", "docstring": "``True`` if credentials are valid, ``False`` if expired.", "id": "f5366:c6:m6"}
{"signature": "def async_update(self):", "body": "return Future(self.update)<EOL>", "docstring": "Same as :meth:`.update` but runs asynchronously in a separate thread.\n\n.. warning::\n\n    |async|\n\n:returns:\n    :class:`.Future` instance representing the separate thread.", "id": "f5366:c4:m2"}
{"signature": "def login(self, adapter, provider_name, callback=None,<EOL>session=None, session_saver=None, **kwargs):", "body": "if provider_name:<EOL><INDENT>provider_settings = self.config.get(provider_name)<EOL>if not provider_settings:<EOL><INDENT>raise ConfigError('<STR_LIT>'<EOL>.format(provider_name))<EOL><DEDENT>if not (session is None or session_saver is None):<EOL><INDENT>session = session<EOL>session_saver = session_saver<EOL><DEDENT>else:<EOL><INDENT>session = Session(adapter=adapter,<EOL>secret=self.secret,<EOL>max_age=self.session_max_age,<EOL>name=self.prefix,<EOL>secure=self.secure_cookie)<EOL>session_saver = session.save<EOL><DEDENT>class_ = provider_settings.get('<STR_LIT>')<EOL>if not class_:<EOL><INDENT>raise ConfigError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(provider_name))<EOL><DEDENT>ProviderClass = resolve_provider_class(class_)<EOL>ProviderClass._logger = self._logger<EOL>provider = ProviderClass(self,<EOL>adapter=adapter,<EOL>provider_name=provider_name,<EOL>callback=callback,<EOL>session=session,<EOL>session_saver=session_saver,<EOL>**kwargs)<EOL>return provider.login()<EOL><DEDENT>else:<EOL><INDENT>self.backend(adapter)<EOL><DEDENT>", "docstring": "If :data:`provider_name` specified, launches the login procedure for\ncorresponding :doc:`provider </reference/providers>` and returns\n:class:`.LoginResult`.\n\nIf :data:`provider_name` is empty, acts like\n:meth:`.Authomatic.backend`.\n\n.. warning::\n\n    The method redirects the **user** to the **provider** which in\n    turn redirects **him/her** back to the *request handler* where\n    it has been called.\n\n:param str provider_name:\n    Name of the provider as specified in the keys of the :doc:`config`.\n\n:param callable callback:\n    If specified the method will call the callback with\n    :class:`.LoginResult` passed as argument and will return nothing.\n\n:param bool report_errors:\n\n.. note::\n\n    Accepts additional keyword arguments that will be passed to\n    :doc:`provider <providers>` constructor.\n\n:returns:\n    :class:`.LoginResult`", "id": "f5366:c11:m1"}
{"signature": "@expire_in.setter<EOL><INDENT>def expire_in(self, value):<DEDENT>", "body": "<EOL>if value:<EOL><INDENT>self._expiration_time = int(time.time()) + int(value)<EOL>self._expire_in = value<EOL><DEDENT>", "docstring": "Computes :attr:`.expiration_time` when the value is set.", "id": "f5366:c6:m2"}
{"signature": "def _deserialize(self, value):", "body": "<EOL>encoded, timestamp, signature = value.split('<STR_LIT:|>')<EOL>if not signature == self._signature(self.name, encoded, timestamp):<EOL><INDENT>raise SessionError('<STR_LIT>'.format(signature))<EOL><DEDENT>if int(timestamp) < int(time.time()) - self.max_age:<EOL><INDENT>return None<EOL><DEDENT>decoded = parse.unquote(encoded)<EOL>deserialized = pickle.loads(decoded.encode('<STR_LIT>'))<EOL>return deserialized<EOL>", "docstring": "Deserializes and verifies the value created by :meth:`._serialize`.\n\n:param str value:\n    The serialized value.\n\n:returns:\n    Deserialized object.", "id": "f5366:c3:m8"}
{"signature": "def refresh(self, force=False, soon=<NUM_LIT>):", "body": "if hasattr(self.provider_class, '<STR_LIT>'):<EOL><INDENT>if force or self.expire_soon(soon):<EOL><INDENT>logging.info('<STR_LIT>'.format(self.provider_name))<EOL>return self.provider_class(<EOL>self, None, self.provider_name).refresh_credentials(self)<EOL><DEDENT><DEDENT>", "docstring": "Refreshes the credentials only if the **provider** supports it and if\nit will expire in less than one day. It does nothing in other cases.\n\n.. note::\n\n    The credentials will be refreshed only if it gives sense\n    i.e. only |oauth2|_ has the notion of credentials\n    *refreshment/extension*.\n    And there are also differences across providers e.g. Google\n    supports refreshment only if there is a ``refresh_token`` in\n    the credentials and that in turn is present only if the\n    ``access_type`` parameter was set to ``offline`` in the\n    **user authorization request**.\n\n:param bool force:\n    If ``True`` the credentials will be refreshed even if they\n    won't expire soon.\n\n:param int soon:\n    Number of seconds specifying what means *soon*.", "id": "f5366:c6:m8"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(OAuth2, self).__init__(*args, **kwargs)<EOL>self.scope = self._kwarg(kwargs, '<STR_LIT>', [])<EOL>self.offline = self._kwarg(kwargs, '<STR_LIT>', False)<EOL>", "docstring": "Accepts additional keyword arguments:\n\n:param list scope:\n    List of strings specifying requested permissions as described\n    in the\n    `OAuth 2.0 spec <http://tools.ietf.org/html/rfc6749#section-3.3>`_.\n\n:param bool offline:\n    If ``True`` the **provider** will be set up to request an\n    *offline access token*.\n    Default is ``False``.\n\nAs well as those inherited from :class:`.AuthorizationProvider`\nconstructor.", "id": "f5369:c0:m0"}
{"signature": "def _x_scope_parser(self, scope):", "body": "return '<STR_LIT:U+0020>'.join(scope)<EOL>", "docstring": "Google has space-separated scopes.", "id": "f5369:c10:m3"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "super(AuthorizationProvider, self).__init__(*args, **kwargs)<EOL>self.consumer_key = self._kwarg(kwargs, '<STR_LIT>')<EOL>self.consumer_secret = self._kwarg(kwargs, '<STR_LIT>')<EOL>self.user_authorization_params = self._kwarg(<EOL>kwargs, '<STR_LIT>', {})<EOL>self.access_token_headers = self._kwarg(<EOL>kwargs, '<STR_LIT>', {})<EOL>self.access_token_params = self._kwarg(<EOL>kwargs, '<STR_LIT>', {})<EOL>self.id = self._kwarg(kwargs, '<STR_LIT:id>')<EOL>self.access_headers = self._kwarg(kwargs, '<STR_LIT>', {})<EOL>self.access_params = self._kwarg(kwargs, '<STR_LIT>', {})<EOL>self.credentials = authomatic.core.Credentials(<EOL>self.settings.config, provider=self)<EOL>self.access_token_response = None<EOL>", "docstring": "Accepts additional keyword arguments:\n\n:arg str consumer_key:\n    The *key* assigned to our application (**consumer**) by the\n    **provider**.\n\n:arg str consumer_secret:\n    The *secret* assigned to our application (**consumer**) by the\n    **provider**.\n\n:arg int id:\n    A unique numeric ID used to serialize :class:`.Credentials`.\n\n:arg dict user_authorization_params:\n    A dictionary of additional request parameters for\n    **user authorization request**.\n\n:arg dict access_token_params:\n    A dictionary of additional request parameters for\n    **access_with_credentials token request**.\n\n:arg dict access_headers:\n    A dictionary of default HTTP headers that will be used when\n    accessing **user's** protected resources.\n    Applied by :meth:`.access()`, :meth:`.update_user()` and\n    :meth:`.User.update()`\n\n:arg dict access_params:\n    A dictionary of default query string parameters that will be used\n    when accessing **user's** protected resources.\n    Applied by :meth:`.access()`, :meth:`.update_user()` and\n    :meth:`.User.update()`", "id": "f5370:c1:m0"}
{"signature": "@property<EOL><INDENT>def type_id(self):<DEDENT>", "body": "cls = self.__class__<EOL>mod = sys.modules.get(cls.__module__)<EOL>return str(self.PROVIDER_TYPE_ID) + '<STR_LIT:->' +str(mod.PROVIDER_ID_MAP.index(cls))<EOL>", "docstring": "A short string representing the provider implementation id used for\nserialization of :class:`.Credentials` and to identify the type of\nprovider in JavaScript.\n\nThe part before hyphen denotes the type of the provider, the part\nafter hyphen denotes the class id e.g.\n``oauth2.Facebook.type_id = '2-5'``,\n``oauth1.Twitter.type_id = '1-5'``.", "id": "f5370:c1:m7"}
{"signature": "@classmethod<EOL><INDENT>def _authorization_header(cls, credentials):<DEDENT>", "body": "if cls._x_use_authorization_header:<EOL><INDENT>res = '<STR_LIT::>'.join(<EOL>(credentials.consumer_key,<EOL>credentials.consumer_secret))<EOL>res = base64.b64encode(six.b(res)).decode()<EOL>return {'<STR_LIT>': '<STR_LIT>'.format(res)}<EOL><DEDENT>else:<EOL><INDENT>return {}<EOL><DEDENT>", "docstring": "Creates authorization headers if the provider supports it. See:\nhttp://en.wikipedia.org/wiki/Basic_access_authentication.\n\n:param credentials:\n    :class:`.Credentials`\n\n:returns:\n    Headers as :class:`dict`.", "id": "f5370:c1:m11"}
{"signature": "@staticmethod<EOL><INDENT>def _x_credentials_parser(credentials, data):<DEDENT>", "body": "return credentials<EOL>", "docstring": "Override this to handle differences in naming conventions across\nproviders.\n\n:param credentials:\n    :class:`.Credentials`\n\n:param dict data:\n    Response data dictionary.\n\n:returns:\n    :class:`.Credentials`", "id": "f5370:c1:m15"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def login(self):<DEDENT>", "body": "", "docstring": "Launches the *login procedure* to get **user's credentials** from\n**provider**.\n\nShould be decorated with :func:`.login_decorator`. The *login\nprocedure* is considered finished when the :attr:`.user`\nattribute is not empty when the method runs out of it's flow or\nwhen there are errors.", "id": "f5370:c0:m7"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def create_request_elements(self, request_type, credentials,<EOL>url, method='<STR_LIT:GET>', params=None, headers=None,<EOL>body='<STR_LIT>'):<DEDENT>", "body": "", "docstring": "Must return :class:`.RequestElements`.\n\n.. warning::\n\n    |classmethod|\n\n:param int request_type:\n    Type of the request specified by one of the class's constants.\n\n:param credentials:\n    :class:`.Credentials` of the **user** whose\n    **protected resource** we want to access.\n\n:param str url:\n    URL of the request.\n\n:param str method:\n    HTTP method of the request.\n\n:param dict params:\n    Dictionary of request parameters.\n\n:param dict headers:\n    Dictionary of request headers.\n\n:param str body:\n    Body of ``POST``, ``PUT`` and ``PATCH`` requests.\n\n:returns:\n    :class:`.RequestElements`", "id": "f5370:c1:m6"}
{"signature": "@staticmethod<EOL><INDENT>def csrf_generator(secret):<DEDENT>", "body": "<EOL>hashed = hashlib.md5(uuid.uuid4().bytes + six.b(secret)).hexdigest()<EOL>span = <NUM_LIT:5><EOL>shift = random.randint(<NUM_LIT:0>, span)<EOL>return hashed[shift:shift - span - <NUM_LIT:1>]<EOL>", "docstring": "Generates CSRF token.\n\nInspired by this article:\nhttp://blog.ptsecurity.com/2012/10/random-number-security-in-python.html\n\n:returns:\n    :class:`str` Random unguessable string.", "id": "f5370:c0:m16"}
{"signature": "@staticmethod<EOL><INDENT>def _split_url(url):<DEDENT>", "body": "split = parse.urlsplit(url)<EOL>base = parse.urlunsplit((split.scheme, split.netloc, split.path, <NUM_LIT:0>, <NUM_LIT:0>))<EOL>params = parse.parse_qsl(split.query, True)<EOL>return base, params<EOL>", "docstring": "Splits given url to url base and params converted to list of tuples.", "id": "f5370:c1:m13"}
{"signature": "def _session_key(self, key):", "body": "return '<STR_LIT>'.format(self.settings.prefix, self.name, key)<EOL>", "docstring": "Generates session key string.\n\n:param str key:\n    e.g. ``\"authomatic:facebook:key\"``", "id": "f5370:c0:m13"}
{"signature": "def access(self, url, params=None, method='<STR_LIT:GET>', headers=None,<EOL>body='<STR_LIT>', max_redirects=<NUM_LIT:5>, content_parser=None):", "body": "if not self.user and not self.credentials:<EOL><INDENT>raise CredentialsError(u'<STR_LIT>')<EOL><DEDENT>headers = headers or {}<EOL>self._log(<EOL>logging.INFO,<EOL>u'<STR_LIT>'.format(url))<EOL>request_elements = self.create_request_elements(<EOL>request_type=self.PROTECTED_RESOURCE_REQUEST_TYPE,<EOL>credentials=self.credentials,<EOL>url=url,<EOL>body=body,<EOL>params=params,<EOL>headers=headers,<EOL>method=method<EOL>)<EOL>response = self._fetch(*request_elements,<EOL>max_redirects=max_redirects,<EOL>content_parser=content_parser)<EOL>self._log(<EOL>logging.INFO,<EOL>u'<STR_LIT>'.format(<EOL>response.status))<EOL>return response<EOL>", "docstring": "Fetches the **protected resource** of an authenticated **user**.\n\n:param credentials:\n    The **user's** :class:`.Credentials` (serialized or normal).\n\n:param str url:\n    The URL of the **protected resource**.\n\n:param str method:\n    HTTP method of the request.\n\n:param dict headers:\n    HTTP headers of the request.\n\n:param str body:\n    Body of ``POST``, ``PUT`` and ``PATCH`` requests.\n\n:param int max_redirects:\n    Maximum number of HTTP redirects to follow.\n\n:param function content_parser:\n    A function to be used to parse the :attr:`.Response.data`\n    from :attr:`.Response.content`.\n\n:returns:\n    :class:`.Response`", "id": "f5370:c1:m8"}
{"signature": "@abc.abstractproperty<EOL><INDENT>def request_token_url(self):<DEDENT>", "body": "", "docstring": ":class:`str` URL where we can get the |oauth1| request token.\nsee http://oauth.net/core/1.0a/#auth_step1.", "id": "f5371:c3:m1"}
{"signature": "def _access_user_info(self):", "body": "response = super(Bitbucket, self)._access_user_info()<EOL>response.data.setdefault(\"<STR_LIT:email>\", None)<EOL>email_response = self.access(self.user_email_url)<EOL>if email_response.data:<EOL><INDENT>for item in email_response.data:<EOL><INDENT>if item.get(\"<STR_LIT>\", False):<EOL><INDENT>response.data.update(email=item.get(\"<STR_LIT:email>\", None))<EOL><DEDENT><DEDENT><DEDENT>return response<EOL>", "docstring": "Email is available in separate method so second request is needed.", "id": "f5371:c4:m1"}
{"signature": "def method_names(self):", "body": "for c in self.classes():<EOL><INDENT>ms = inspect.getmembers(c, lambda f: inspect.ismethod(f) or inspect.isfunction(f))<EOL>method_name = getattr(self, '<STR_LIT>', '<STR_LIT>')<EOL>method_regex = '<STR_LIT>'<EOL>if method_name:<EOL><INDENT>if method_name.startswith(self.method_prefix):<EOL><INDENT>method_regex = re.compile(r'<STR_LIT>'.format(method_name), flags=re.I)<EOL><DEDENT>else:<EOL><INDENT>if method_name.startswith(\"<STR_LIT:*>\"):<EOL><INDENT>method_name = method_name.strip(\"<STR_LIT:*>\")<EOL>method_regex = re.compile(<EOL>r'<STR_LIT>'.format(self.method_prefix, method_name),<EOL>flags=re.I<EOL>)<EOL><DEDENT>else:<EOL><INDENT>method_regex = re.compile(<EOL>r'<STR_LIT>'.format(self.method_prefix, method_name),<EOL>flags=re.I<EOL>)<EOL><DEDENT><DEDENT><DEDENT>for m_name, m in ms:<EOL><INDENT>if not m_name.startswith(self.method_prefix): continue<EOL>can_yield = True<EOL>if method_regex and not method_regex.match(m_name):<EOL><INDENT>can_yield = False<EOL><DEDENT>if can_yield:<EOL><INDENT>logger.debug('<STR_LIT>'.format(m_name, method_name))<EOL>yield c, m_name<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "return the actual test methods that matched self.method_name", "id": "f5409:c2:m8"}
{"signature": "def raise_any_error(self):", "body": "for tc in self.possible:<EOL><INDENT>tc.raise_found_error()<EOL><DEDENT>", "docstring": "raise any found error in the possible PathFinders", "id": "f5409:c1:m1"}
{"signature": "def set_possible(self):", "body": "possible = []<EOL>name = self.name<EOL>logger.debug('<STR_LIT>'.format(name))<EOL>name_f = self.name.lower()<EOL>filepath = \"<STR_LIT>\"<EOL>if name_f.endswith(\"<STR_LIT>\") or \"<STR_LIT>\" in name_f:<EOL><INDENT>bits = name.split(\"<STR_LIT::>\", <NUM_LIT:1>)<EOL>filepath = bits[<NUM_LIT:0>]<EOL>logger.debug('<STR_LIT>'.format(filepath))<EOL>name = bits[<NUM_LIT:1>] if len(bits) > <NUM_LIT:1> else \"<STR_LIT>\"<EOL>if name:<EOL><INDENT>logger.debug('<STR_LIT>'.format(name, filepath))<EOL><DEDENT><DEDENT>bits = name.split('<STR_LIT:.>')<EOL>basedir = self.basedir<EOL>method_prefix = self.method_prefix<EOL>if re.search(r'<STR_LIT>', bits[-<NUM_LIT:1>]):<EOL><INDENT>logger.debug('<STR_LIT>'.format(bits[-<NUM_LIT:1>]))<EOL>possible.append(PathFinder(basedir, method_prefix, **{<EOL>'<STR_LIT>': bits[-<NUM_LIT:1>],<EOL>'<STR_LIT>': bits[-<NUM_LIT:2>] if len(bits) > <NUM_LIT:1> else '<STR_LIT>',<EOL>'<STR_LIT>': os.sep.join(bits[<NUM_LIT:0>:-<NUM_LIT:2>]),<EOL>'<STR_LIT>': filepath,<EOL>}))<EOL><DEDENT>elif len(bits) > <NUM_LIT:1> and re.search(r'<STR_LIT>', bits[-<NUM_LIT:2>]):<EOL><INDENT>logger.debug('<STR_LIT>'.format(bits[-<NUM_LIT:2>]))<EOL>possible.append(PathFinder(basedir, method_prefix, **{<EOL>'<STR_LIT>': bits[-<NUM_LIT:2>],<EOL>'<STR_LIT>': bits[-<NUM_LIT:1>],<EOL>'<STR_LIT>': bits[-<NUM_LIT:3>] if len(bits) > <NUM_LIT:2> else '<STR_LIT>',<EOL>'<STR_LIT>': os.sep.join(bits[<NUM_LIT:0>:-<NUM_LIT:3>]),<EOL>'<STR_LIT>': filepath,<EOL>}))<EOL><DEDENT>else:<EOL><INDENT>if self.name:<EOL><INDENT>if filepath:<EOL><INDENT>if len(bits):<EOL><INDENT>possible.append(PathFinder(basedir, method_prefix, **{<EOL>'<STR_LIT>': filepath,<EOL>'<STR_LIT>': bits[<NUM_LIT:0>],<EOL>}))<EOL><DEDENT>else:<EOL><INDENT>possible.append(PathFinder(basedir, method_prefix, **{<EOL>'<STR_LIT>': filepath,<EOL>}))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>logger.debug('<STR_LIT>')<EOL>possible.append(PathFinder(basedir, method_prefix, **{<EOL>'<STR_LIT>': bits[-<NUM_LIT:1>],<EOL>'<STR_LIT>': os.sep.join(bits[<NUM_LIT:0>:-<NUM_LIT:1>]),<EOL>'<STR_LIT>': filepath,<EOL>}))<EOL>possible.append(PathFinder(basedir, method_prefix, **{<EOL>'<STR_LIT>': bits[-<NUM_LIT:1>],<EOL>'<STR_LIT>': bits[-<NUM_LIT:2>] if len(bits) > <NUM_LIT:1> else '<STR_LIT>',<EOL>'<STR_LIT>': os.sep.join(bits[<NUM_LIT:0>:-<NUM_LIT:2>]),<EOL>'<STR_LIT>': filepath,<EOL>}))<EOL>possible.append(PathFinder(basedir, method_prefix, **{<EOL>'<STR_LIT>': os.sep.join(bits),<EOL>'<STR_LIT>': filepath,<EOL>}))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>possible.append(PathFinder(basedir, method_prefix, filepath=filepath))<EOL><DEDENT><DEDENT>logger.debug(\"<STR_LIT>\".format(len(possible)))<EOL>self.possible = possible<EOL>", "docstring": "break up a module path to its various parts (prefix, module, class, method)\n\nthis uses PEP 8 conventions, so foo.Bar would be foo module with class Bar\n\nreturn -- list -- a list of possible interpretations of the module path\n    (eg, foo.bar can be bar module in foo module, or bar method in foo module)", "id": "f5409:c1:m2"}
{"signature": "def _find_basename(self, name, basenames, is_prefix=False):", "body": "ret = \"<STR_LIT>\"<EOL>fileroots = [(os.path.splitext(n)[<NUM_LIT:0>], n) for n in basenames]<EOL>glob = False<EOL>if name.startswith(\"<STR_LIT:*>\"):<EOL><INDENT>glob = True<EOL><DEDENT>name = name.strip(\"<STR_LIT:*>\")<EOL>for fileroot, basename in fileroots:<EOL><INDENT>if name in fileroot or fileroot in name:<EOL><INDENT>for pf in self.module_postfixes:<EOL><INDENT>logger.debug(<EOL>'<STR_LIT>'.format(<EOL>basename,<EOL>name,<EOL>pf<EOL>))<EOL>if glob:<EOL><INDENT>if name in fileroot and fileroot.endswith(pf):<EOL><INDENT>ret = basename<EOL>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if fileroot.startswith(name) and fileroot.endswith(pf):<EOL><INDENT>ret = basename<EOL>break<EOL><DEDENT><DEDENT><DEDENT>if not ret:<EOL><INDENT>for pf in self.module_prefixes:<EOL><INDENT>n = pf + name<EOL>logger.debug('<STR_LIT>'.format(basename, n))<EOL>if glob:<EOL><INDENT>if fileroot.startswith(pf) and name in fileroot:<EOL><INDENT>ret = basename<EOL>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if fileroot.startswith(n):<EOL><INDENT>ret = basename<EOL>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if not ret:<EOL><INDENT>if is_prefix:<EOL><INDENT>logger.debug('<STR_LIT>'.format(basename, name))<EOL>if basename.startswith(name) or (glob and name in basename):<EOL><INDENT>ret = basename<EOL><DEDENT>else:<EOL><INDENT>logger.debug(<EOL>'<STR_LIT>'.format(<EOL>basename,<EOL>name<EOL>))<EOL>if glob:<EOL><INDENT>if name in basename and self._is_module_path(basename):<EOL><INDENT>ret = basename<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if basename.startswith(name) and self._is_module_path(basename):<EOL><INDENT>ret = basename<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>if ret:<EOL><INDENT>logger.debug('<STR_LIT>'.format(ret))<EOL>break<EOL><DEDENT><DEDENT><DEDENT>return ret<EOL>", "docstring": "check if name combined with test prefixes or postfixes is found anywhere\n        in the list of basenames\n\n        :param name: string, the name you're searching for\n        :param basenames: list, a list of basenames to check\n        :param is_prefix: bool, True if this is a prefix search, which means it will\n            also check if name matches any of the basenames without the prefixes or\n            postfixes, if it is False then the prefixes or postfixes must be present\n            (ie, the module we're looking for is the actual test module, not the parent\n             modules it's contained in)\n        :returns: string, the basename if it is found", "id": "f5409:c2:m9"}
{"signature": "def paths(self):", "body": "module_name = getattr(self, '<STR_LIT>', '<STR_LIT>')<EOL>module_prefix = getattr(self, '<STR_LIT>', '<STR_LIT>')<EOL>filepath = getattr(self, '<STR_LIT>', '<STR_LIT>')<EOL>if filepath:<EOL><INDENT>if os.path.isabs(filepath):<EOL><INDENT>yield filepath<EOL><DEDENT>else:<EOL><INDENT>yield os.path.join(self.basedir, filepath)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if module_prefix:<EOL><INDENT>basedirs = self._find_prefix_paths(self.basedir, module_prefix)<EOL><DEDENT>else:<EOL><INDENT>basedirs = [self.basedir]<EOL><DEDENT>for basedir in basedirs:<EOL><INDENT>try:<EOL><INDENT>if module_name:<EOL><INDENT>path = self._find_module_path(basedir, module_name)<EOL><DEDENT>else:<EOL><INDENT>path = basedir<EOL><DEDENT>if os.path.isfile(path):<EOL><INDENT>logger.debug('<STR_LIT>'.format(path))<EOL>yield path<EOL><DEDENT>else:<EOL><INDENT>seen_paths = set()<EOL>for root, dirs, files in self.walk(path):<EOL><INDENT>for basename in files:<EOL><INDENT>if basename.startswith(\"<STR_LIT>\"):<EOL><INDENT>if self._is_module_path(root):<EOL><INDENT>filepath = os.path.join(root, basename)<EOL>if filepath not in seen_paths:<EOL><INDENT>logger.debug('<STR_LIT>'.format(filepath))<EOL>seen_paths.add(filepath)<EOL>yield filepath<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>fileroot = os.path.splitext(basename)[<NUM_LIT:0>]<EOL>for pf in self.module_postfixes:<EOL><INDENT>if fileroot.endswith(pf):<EOL><INDENT>filepath = os.path.join(root, basename)<EOL>if filepath not in seen_paths:<EOL><INDENT>logger.debug('<STR_LIT>'.format(filepath))<EOL>seen_paths.add(filepath)<EOL>yield filepath<EOL><DEDENT><DEDENT><DEDENT>for pf in self.module_prefixes:<EOL><INDENT>if fileroot.startswith(pf):<EOL><INDENT>filepath = os.path.join(root, basename)<EOL>if filepath not in seen_paths:<EOL><INDENT>logger.debug('<STR_LIT>'.format(filepath))<EOL>seen_paths.add(filepath)<EOL>yield filepath<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>except IOError as e:<EOL><INDENT>logger.warning(e, exc_info=True)<EOL>pass<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "given a basedir, yield all test modules paths recursively found in\nbasedir that are test modules\n\nreturn -- generator", "id": "f5409:c2:m15"}
{"signature": "def loghandler_members():", "body": "Members = namedtuple(\"<STR_LIT>\", [\"<STR_LIT:name>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"])<EOL>log_manager = logging.Logger.manager<EOL>loggers = []<EOL>ignore = set([modname()])<EOL>if log_manager.root:<EOL><INDENT>loggers = list(log_manager.loggerDict.items())<EOL>loggers.append((\"<STR_LIT:root>\", log_manager.root))<EOL><DEDENT>for logger_name, logger in loggers:<EOL><INDENT>if logger_name in ignore: continue<EOL>for handler in getattr(logger, \"<STR_LIT>\", []):<EOL><INDENT>members = inspect.getmembers(handler)<EOL>for member_name, member in members:<EOL><INDENT>yield Members(logger_name, handler, member_name, member)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "iterate through the attributes of every logger's handler\n\n    this is used to switch out stderr and stdout in tests when buffer is True\n\n    :returns: generator of tuples, each tuple has (name, handler, member_name, member_val)", "id": "f5415:m4"}
{"signature": "def _find_by_path_local(self, path):", "body": "return glob('<STR_LIT>' % path)<EOL>", "docstring": "Finds files by globbing on the local filesystem.", "id": "f5421:c0:m9"}
{"signature": "def delete(self, filename, storage_type=None, bucket_name=None):", "body": "if not (storage_type and bucket_name):<EOL><INDENT>self._delete_local(filename)<EOL><DEDENT>else:<EOL><INDENT>if storage_type != '<STR_LIT>':<EOL><INDENT>raise ValueError('<STR_LIT>' % storage_type)<EOL><DEDENT>self._delete_s3(filename, bucket_name)<EOL><DEDENT>", "docstring": "Deletes the specified file, either locally or from S3, depending on the file's storage type.", "id": "f5421:c0:m5"}
{"signature": "def _save_local(self, temp_file, filename, obj):", "body": "path = self._get_path(filename)<EOL>if not os.path.exists(os.path.dirname(path)):<EOL><INDENT>os.makedirs(os.path.dirname(path), self.permission | <NUM_LIT>)<EOL><DEDENT>fd = open(path, '<STR_LIT:wb>')<EOL>temp_file.seek(<NUM_LIT:0>)<EOL>t = temp_file.read(<NUM_LIT>)<EOL>while t:<EOL><INDENT>fd.write(t)<EOL>t = temp_file.read(<NUM_LIT>)<EOL><DEDENT>fd.close()<EOL>if self.filesize_field:<EOL><INDENT>setattr(obj, self.filesize_field, os.path.getsize(path))<EOL><DEDENT>return filename<EOL>", "docstring": "Saves the specified file to the local file system.", "id": "f5421:c0:m6"}
{"signature": "def _delete_s3(self, filename, bucket_name):", "body": "conn = S3Connection(self.access_key_id, self.access_key_secret)<EOL>bucket = conn.get_bucket(bucket_name)<EOL>if type(filename).__name__ == '<STR_LIT>':<EOL><INDENT>filename = '<STR_LIT:/>' + filename.name<EOL><DEDENT>path = self._get_s3_path(filename)<EOL>k = Key(bucket)<EOL>k.key = path<EOL>try:<EOL><INDENT>bucket.delete_key(k)<EOL><DEDENT>except S3ResponseError:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Deletes the specified file from the given S3 bucket.", "id": "f5421:c0:m4"}
{"signature": "def parse_interfaces(interfaces):", "body": "parsed_interfaces = collections.defaultdict(dict)<EOL>for m, d in iteritems(interfaces):<EOL><INDENT>app, func = m.split('<STR_LIT:.>', <NUM_LIT:1>)<EOL>method = parsed_interfaces[app][func] = {}<EOL>method['<STR_LIT>'] = ['<STR_LIT>', '<STR_LIT>']<EOL>method['<STR_LIT>'] = '<STR_LIT:POST>'<EOL>method['<STR_LIT>'] = {}<EOL>method['<STR_LIT>'] = {}<EOL>for name, type_info in iteritems(dict(d['<STR_LIT>'])):<EOL><INDENT>optionality = '<STR_LIT>'<EOL>param_type = '<STR_LIT:string>'<EOL>type_info = TYPE_INFO_COMMENT_RE.sub('<STR_LIT>', type_info)<EOL>info_pieces = TYPE_INFO_SPLITTER_RE.findall(type_info)<EOL>for info_piece in info_pieces:<EOL><INDENT>if info_piece in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>optionality = info_piece<EOL><DEDENT>elif info_piece == '<STR_LIT>':<EOL><INDENT>optionality = '<STR_LIT>'<EOL>param_type = '<STR_LIT:string>'<EOL><DEDENT>elif info_piece == '<STR_LIT>':<EOL><INDENT>optionality = '<STR_LIT>'<EOL><DEDENT>elif info_piece == '<STR_LIT>':<EOL><INDENT>optionality = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>param_type = info_piece<EOL><DEDENT><DEDENT>method[optionality][name] = map_param_type(param_type)<EOL><DEDENT><DEDENT>return dict(parsed_interfaces)<EOL>", "docstring": "Parse the conduit.query json dict response\nThis performs the logic of parsing the non-standard params dict\n    and then returning a dict Resource can understand", "id": "f5425:m1"}
{"signature": "def get_version(package):", "body": "init_py = open(os.path.join(package, '<STR_LIT>')).read()<EOL>return re.search(\"<STR_LIT>\",<EOL>init_py, re.MULTILINE).group(<NUM_LIT:1>)<EOL>", "docstring": "Return package version as listed in `__version__` in `init.py`.", "id": "f5428:m0"}
{"signature": "@cli.command()<EOL>@click.argument('<STR_LIT>')<EOL>@click.pass_context<EOL>def retrieve(ctx, preview_id, *args, **kwargs):", "body": "file_previews = ctx.obj['<STR_LIT>']<EOL>results = file_previews.retrieve(preview_id)<EOL>click.echo(results)<EOL>", "docstring": "Retreive preview results for ID.", "id": "f5430:m2"}
{"signature": "def _run_ssh(entries, username, idfile, no_prompt=False, command=None,<EOL>show=None, only=None, sort_by=None, limit=None, tunnel=None,<EOL>num=None, random=False):", "body": "_print_entries = num is None<EOL>_print_help = False<EOL>if len(entries) == <NUM_LIT:0>:<EOL><INDENT>exit('<STR_LIT>')<EOL><DEDENT>if no_prompt is True and command is not None:<EOL><INDENT>return _run_ssh_command(entries, username, idfile, command, tunnel)<EOL><DEDENT>elif len(entries) == <NUM_LIT:1> or random is True:<EOL><INDENT>entry = py_random.choice(entries)<EOL>if command is None:<EOL><INDENT>return _connect_ssh(entry, username, idfile, tunnel)<EOL><DEDENT>else:<EOL><INDENT>return _run_ssh_command([entry], username, idfile, command, tunnel)<EOL><DEDENT><DEDENT>elif command is not None:<EOL><INDENT>print(HostEntry.render_entries(entries,<EOL>additional_columns=show,<EOL>only_show=only, numbers=True))<EOL>if no_prompt is False:<EOL><INDENT>get_input(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>.format(cyan(command), len(entries)))<EOL><DEDENT>return _run_ssh_command(entries, username, idfile, command, tunnel)<EOL><DEDENT>else:<EOL><INDENT>while True:<EOL><INDENT>if sort_by is not None:<EOL><INDENT>entries = HostEntry.sort_by(entries, sort_by)<EOL><DEDENT>if limit is not None:<EOL><INDENT>entries = entries[:limit]<EOL><DEDENT>if _print_entries is True:<EOL><INDENT>print(HostEntry.render_entries(entries,<EOL>additional_columns=show,<EOL>only_show=only, numbers=True))<EOL>print('<STR_LIT>' % len(entries))<EOL>_print_entries = False<EOL><DEDENT>if _print_help is True:<EOL><INDENT>cmd_str = green(command) if command is not None else '<STR_LIT>'<EOL>msg = COMMANDS_STRING.format(username=username or '<STR_LIT>',<EOL>idfile=idfile or '<STR_LIT>',<EOL>cur_cmd=cmd_str)<EOL>print(msg)<EOL>_print_help = False<EOL><DEDENT>elif command is not None:<EOL><INDENT>print('<STR_LIT>' % cyan(command))<EOL><DEDENT>msg = '<STR_LIT>' % (cyan('<STR_LIT:h>'),<EOL>cyan('<STR_LIT:q>'))<EOL>if num is not None:<EOL><INDENT>choice = num<EOL><DEDENT>else:<EOL><INDENT>choice = get_input(msg)<EOL><DEDENT>if isinstance(choice, int):<EOL><INDENT>if <NUM_LIT:0> <= choice <= len(entries):<EOL><INDENT>break<EOL><DEDENT>else:<EOL><INDENT>if num is not None:<EOL><INDENT>exit(\"<STR_LIT>\"<EOL>.format(num, len(entries) - <NUM_LIT:1>))<EOL><DEDENT>else:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>print(msg % (len(entries) - <NUM_LIT:1>))<EOL><DEDENT><DEDENT><DEDENT>elif choice == '<STR_LIT:x>':<EOL><INDENT>if command is None:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>return _run_ssh_command(entries, username, idfile,<EOL>command, tunnel)<EOL><DEDENT><DEDENT>elif choice == '<STR_LIT:h>':<EOL><INDENT>_print_help = True<EOL><DEDENT>elif choice in ['<STR_LIT:q>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>print('<STR_LIT>')<EOL>return<EOL><DEDENT>else:<EOL><INDENT>commands = choice.split()<EOL>if len(commands) < <NUM_LIT:2>:<EOL><INDENT>print(yellow('<STR_LIT>' % choice))<EOL><DEDENT>else:<EOL><INDENT>cmd = commands[<NUM_LIT:0>]<EOL>if cmd in ['<STR_LIT:u>', '<STR_LIT:i>', '<STR_LIT:p>']:<EOL><INDENT>if cmd == '<STR_LIT:u>':<EOL><INDENT>username = commands[<NUM_LIT:1>]<EOL><DEDENT>elif cmd == '<STR_LIT:i>':<EOL><INDENT>_idfile = commands[<NUM_LIT:1>]<EOL>if not os.path.exists(_idfile):<EOL><INDENT>print(yellow('<STR_LIT>' % _idfile))<EOL>continue<EOL><DEDENT>idfile = _idfile<EOL><DEDENT>elif cmd == '<STR_LIT:p>':<EOL><INDENT>p = commands[<NUM_LIT:1>]<EOL>try:<EOL><INDENT>profile = LsiProfile.load(p)<EOL>_username = profile.username<EOL>_idfile = expanduser(profile.identity_file)<EOL><DEDENT>except LsiProfile.LoadError:<EOL><INDENT>print(yellow('<STR_LIT>' % repr(p)))<EOL>continue<EOL><DEDENT>username = _username<EOL>idfile = _idfile<EOL><DEDENT>print('<STR_LIT>' % green(repr(username)))<EOL>print('<STR_LIT>' % green(repr(idfile)))<EOL><DEDENT>elif cmd == '<STR_LIT:f>':<EOL><INDENT>entries = filter_entries(entries, commands[<NUM_LIT:1>:], [])<EOL>_print_entries = True<EOL><DEDENT>elif cmd == '<STR_LIT:e>':<EOL><INDENT>entries = filter_entries(entries, [], commands[<NUM_LIT:1>:])<EOL>_print_entries = True<EOL><DEDENT>elif cmd == '<STR_LIT:c>':<EOL><INDENT>command = '<STR_LIT:U+0020>'.join(commands[<NUM_LIT:1>:])<EOL><DEDENT>elif cmd == '<STR_LIT>':<EOL><INDENT>try:<EOL><INDENT>limit = int(commands[<NUM_LIT:1>])<EOL>_print_entries = True<EOL><DEDENT>except ValueError:<EOL><INDENT>print(yellow('<STR_LIT>'))<EOL><DEDENT><DEDENT>elif cmd == '<STR_LIT>':<EOL><INDENT>sort_by = commands[<NUM_LIT:1>]<EOL>if sort_by not in show:<EOL><INDENT>show.append(sort_by)<EOL><DEDENT>_print_entries = True<EOL><DEDENT>elif cmd == '<STR_LIT>':<EOL><INDENT>if show is None:<EOL><INDENT>show = commands[<NUM_LIT:1>:]<EOL><DEDENT>else:<EOL><INDENT>show.extend(commands[<NUM_LIT:1>:])<EOL><DEDENT>_print_entries = True<EOL><DEDENT>else:<EOL><INDENT>print(yellow('<STR_LIT>' % cmd))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return _connect_ssh(entries[choice], username, idfile, tunnel)<EOL><DEDENT>", "docstring": "Lets the user choose which instance to SSH into.\n\n:param entries: The list of host entries.\n:type entries: [:py:class:`HostEntry`]\n:param username: The SSH username to use. Defaults to current user.\n:type username: ``str`` or ``NoneType``\n:param idfile: The identity file to use. Optional.\n:type idfile: ``str`` or ``NoneType``\n:param no_prompt: Whether to disable confirmation for SSH command.\n:type no_prompt: ``bool``\n:param command: SSH command to run on matching instances.\n:type command: ``str`` or ``NoneType``\n:param show: Instance attributes to show in addition to defaults.\n:type show: ``NoneType`` or ``list`` of ``str``\n:param only: If not ``None``, will *only* show these attributes.\n:type only: ``NoneType`` or ``list`` of ``str``\n:param sort_by: What to sort columns by. By default, sort by 'name'.\n:type sort_by: ``str``\n:param limit: At most how many results to show.\n:type limit: ``int`` or ``NoneType``\n:param num: If not None, choose the given entry from within filters.\n:type num: ``int`` or ``NoneType``\n:param random: If true, choose a random entry from within filters.\n:type random: ``bool``", "id": "f5436:m0"}
{"signature": "def _run_ssh_command(entries, username, idfile, command, tunnel,<EOL>parallel=False):", "body": "if len(entries) == <NUM_LIT:0>:<EOL><INDENT>print('<STR_LIT>')<EOL>return <NUM_LIT:1><EOL><DEDENT>if command.strip() == '<STR_LIT>' or command is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>print('<STR_LIT>'<EOL>.format(green(repr(command)), len(entries)))<EOL>shell_cmds = []<EOL>for entry in entries:<EOL><INDENT>hname = entry.hostname or entry.public_ip<EOL>cmd = _build_ssh_command(hname, username, idfile, command, tunnel)<EOL>shell_cmds.append({<EOL>'<STR_LIT>': cmd,<EOL>'<STR_LIT:description>': entry.display()<EOL>})<EOL><DEDENT>stream_commands(shell_cmds, parallel=parallel)<EOL>print(green('<STR_LIT>'))<EOL>", "docstring": "Runs the given command over SSH in parallel on all hosts in `entries`.\n\n:param entries: The host entries the hostnames from.\n:type entries: ``list`` of :py:class:`HostEntry`\n:param username: To use a specific username.\n:type username: ``str`` or ``NoneType``\n:param idfile: The SSH identity file to use, or none.\n:type idfile: ``str`` or ``NoneType``\n:param command: The command to run.\n:type command: ``str``\n:param parallel: If true, commands will be run in parallel.\n:type parallel: ``bool``", "id": "f5436:m6"}
{"signature": "def _build_ssh_command(hostname, username, idfile, ssh_command, tunnel):", "body": "command = [_get_path('<STR_LIT>'),<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>']<EOL>if idfile is not None:<EOL><INDENT>command.extend(['<STR_LIT>', idfile])<EOL><DEDENT>if tunnel is not None:<EOL><INDENT>command.extend(['<STR_LIT>', '<STR_LIT>', tunnel, '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL><DEDENT>if username is not None:<EOL><INDENT>command.append('<STR_LIT>'.format(username, hostname))<EOL><DEDENT>else:<EOL><INDENT>command.append(hostname)<EOL><DEDENT>if ssh_command is not None:<EOL><INDENT>command.append(repr(ssh_command))<EOL><DEDENT>return('<STR_LIT:U+0020>'.join(command))<EOL>", "docstring": "Uses hostname and other info to construct an SSH command.", "id": "f5436:m2"}
{"signature": "def _get_args():", "body": "parser = argparse.ArgumentParser(description='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', action='<STR_LIT:store_true>', default=False,<EOL>help='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', action='<STR_LIT:store_true>', default=False,<EOL>help='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', action='<STR_LIT:store_true>', default=False,<EOL>help='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', help='<STR_LIT>',<EOL>default=None)<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', action='<STR_LIT:store_true>',<EOL>help='<STR_LIT>', default=False)<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', help='<STR_LIT>',<EOL>default=None)<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', default=None,<EOL>help='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', nargs='<STR_LIT:*>',<EOL>help='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', nargs='<STR_LIT:+>',<EOL>help='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT:-c>', '<STR_LIT>', type=str,<EOL>help='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', action='<STR_LIT:store_true>', default=False,<EOL>help=\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', type=str,<EOL>help='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', nargs='<STR_LIT:+>', default=None,<EOL>help='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', nargs='<STR_LIT:+>', default=None,<EOL>help='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', type=str, default=None,<EOL>help='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', type=str, default=\"<STR_LIT:name>\",<EOL>help='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', type=int, default=None,<EOL>help='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', action='<STR_LIT:store_true>',<EOL>help='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', nargs=<NUM_LIT:2>, default=None,<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', nargs=<NUM_LIT:2>, default=None,<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', default=None,<EOL>help='<STR_LIT>')<EOL>parser.add_argument(\"<STR_LIT>\", \"<STR_LIT>\", action=\"<STR_LIT:store_true>\", default=False,<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument(\"<STR_LIT>\", \"<STR_LIT>\", type=int, default=None,<EOL>help=\"<STR_LIT>\")<EOL>args = parser.parse_args()<EOL>if args.exclude is None:<EOL><INDENT>args.exclude = []<EOL><DEDENT>if args.sort_by is not None:<EOL><INDENT>args.show = (args.show or []) + [args.sort_by]<EOL><DEDENT>return args<EOL>", "docstring": "Parse command-line arguments.", "id": "f5436:m9"}
{"signature": "@classmethod<EOL><INDENT>def load(cls, profile_name=None):<DEDENT>", "body": "lsi_location = os.path.expanduser('<STR_LIT>')<EOL>if not os.path.exists(lsi_location):<EOL><INDENT>return LsiProfile()<EOL><DEDENT>cfg_parser = ConfigParser()<EOL>cfg_parser.read(lsi_location)<EOL>if profile_name is None:<EOL><INDENT>if cfg_parser.has_section('<STR_LIT:default>'):<EOL><INDENT>profile_name = '<STR_LIT:default>'<EOL><DEDENT>else:<EOL><INDENT>return cls()<EOL><DEDENT><DEDENT>elif not cfg_parser.has_section(profile_name):<EOL><INDENT>raise cls.LoadError('<STR_LIT>'.format(profile_name))<EOL><DEDENT>def _get(option, alt=None):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if cfg_parser.has_option(profile_name, option):<EOL><INDENT>return cfg_parser.get(profile_name, option)<EOL><DEDENT>else:<EOL><INDENT>return alt<EOL><DEDENT><DEDENT>if cfg_parser.has_option(profile_name, '<STR_LIT>'):<EOL><INDENT>profile = cls.load(cfg_parser.get(profile_name, '<STR_LIT>'))<EOL><DEDENT>else:<EOL><INDENT>profile = cls()<EOL><DEDENT>profile.override('<STR_LIT:username>', _get('<STR_LIT:username>'))<EOL>profile.override('<STR_LIT>', _get('<STR_LIT>'))<EOL>profile.override('<STR_LIT>', _get('<STR_LIT>'))<EOL>filters = [s for s in _get('<STR_LIT>', '<STR_LIT>').split('<STR_LIT:U+002C>') if len(s) > <NUM_LIT:0>]<EOL>exclude = [s for s in _get('<STR_LIT>', '<STR_LIT>').split('<STR_LIT:U+002C>') if len(s) > <NUM_LIT:0>]<EOL>profile.filters.extend(filters)<EOL>profile.exclude.extend(exclude)<EOL>return profile<EOL>", "docstring": "Loads the user's LSI profile, or provides a default.", "id": "f5436:c0:m2"}
{"signature": "def prepare_rows(table):", "body": "num_columns = max(len(row) for row in table)<EOL>for row in table:<EOL><INDENT>while len(row) < num_columns:<EOL><INDENT>row.append('<STR_LIT>')<EOL><DEDENT>for i in range(num_columns):<EOL><INDENT>row[i] = str(row[i]) if row[i] is not None else '<STR_LIT>'<EOL><DEDENT><DEDENT>return table<EOL>", "docstring": "Prepare the rows so they're all strings, and all the same length.\n\n:param table: A 2D grid of anything.\n:type table: [[``object``]]\n\n:return: A table of strings, where every row is the same length.\n:rtype: [[``str``]]", "id": "f5437:m4"}
{"signature": "def render_row(num, columns, widths, column_colors=None):", "body": "row_str = '<STR_LIT:|>'<EOL>cell_strs = []<EOL>for i, column in enumerate(columns):<EOL><INDENT>try:<EOL><INDENT>cell = column[num]<EOL>spaces = '<STR_LIT:U+0020>' * (widths[i] - len(cell))<EOL>if column_colors is not None and column_colors[i] is not None:<EOL><INDENT>cell = column_colors[i](cell)<EOL><DEDENT>cell_strs.append('<STR_LIT>' % (cell, spaces))<EOL><DEDENT>except IndexError:<EOL><INDENT>cell_strs.append('<STR_LIT:U+0020>' * (widths[i] + <NUM_LIT:2>))<EOL><DEDENT><DEDENT>return '<STR_LIT>' % '<STR_LIT:|>'.join(cell_strs)<EOL>", "docstring": "Render the `num`th row of each column in `columns`.\n\n:param num: Which row to render.\n:type num: ``int``\n:param columns: The list of columns.\n:type columns: [[``str``]]\n:param widths: The widths of each column.\n:type widths: [``int``]\n:param column_colors: An optional list of coloring functions.\n:type column_colors: [``str`` -> ``str``] or ``NoneType``\n\n:return: The rendered row.\n:rtype: ``str``", "id": "f5437:m1"}
{"signature": "def transpose_table(table):", "body": "if len(table) == <NUM_LIT:0>:<EOL><INDENT>return table<EOL><DEDENT>else:<EOL><INDENT>num_columns = len(table[<NUM_LIT:0>])<EOL>return [[row[i] for row in table] for i in range(num_columns)]<EOL><DEDENT>", "docstring": "Transposes a table, turning rows into columns.\n:param table: A 2D string grid.\n:type table: [[``str``]]\n\n:return: The same table, with rows and columns flipped.\n:rtype: [[``str``]]", "id": "f5437:m3"}
{"signature": "def get_current_terminal_width():", "body": "try:<EOL><INDENT>return int(os.popen('<STR_LIT>', '<STR_LIT:r>').read().split()[<NUM_LIT:1>])<EOL><DEDENT>except Exception:<EOL><INDENT>return <NUM_LIT><EOL><DEDENT>", "docstring": "Returns the current terminal size, in characters.\n:rtype: ``int``", "id": "f5439:m4"}
{"signature": "def get_host(name):", "body": "f = {'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': name}<EOL>ec2 = boto.connect_ec2(region=get_region())<EOL>rs = ec2.get_all_instances(filters=f)<EOL>if len(rs) == <NUM_LIT:0>:<EOL><INDENT>raise Exception('<STR_LIT>' % name)<EOL><DEDENT>print(rs[<NUM_LIT:0>].instances[<NUM_LIT:0>].public_dns_name)<EOL>", "docstring": "Prints the public dns name of `name`, if it exists.\n\n:param name: The instance name.\n:type name: ``str``", "id": "f5441:m9"}
{"signature": "def _list_all_cached():", "body": "with open(get_cache_location()) as f:<EOL><INDENT>contents = f.read()<EOL>objects = json.loads(contents)<EOL>return [HostEntry.from_dict(obj) for obj in objects]<EOL><DEDENT>", "docstring": "Reads the description cache, returning each instance's information.\n:return: A list of host entries.\n:rtype: [:py:class:`HostEntry`]", "id": "f5441:m7"}
{"signature": "@classmethod<EOL><INDENT>def prettyname(cls, attrib_name):<DEDENT>", "body": "if attrib_name.startswith('<STR_LIT>'):<EOL><INDENT>tagname = attrib_name[len('<STR_LIT>'):]<EOL>return '<STR_LIT>'.format(tagname)<EOL><DEDENT>elif attrib_name in cls.COLUMN_NAMES:<EOL><INDENT>return cls.COLUMN_NAMES[attrib_name]<EOL><DEDENT>else:<EOL><INDENT>return attrib_name<EOL><DEDENT>", "docstring": "Returns the \"pretty name\" (capitalized, etc) of an attribute, by\nlooking it up in ``cls.COLUMN_NAMES`` if it exists there.\n\n:param attrib_name: An attribute name.\n:type attrib_name: ``str``\n\n:rtype: ``str``", "id": "f5441:c0:m13"}
{"signature": "@classmethod<EOL><INDENT>def from_boto_instance(cls, instance):<DEDENT>", "body": "return cls(<EOL>name=instance.tags.get('<STR_LIT:Name>'),<EOL>private_ip=instance.private_ip_address,<EOL>public_ip=instance.ip_address,<EOL>instance_type=instance.instance_type,<EOL>instance_id=instance.id,<EOL>hostname=instance.dns_name,<EOL>stack_id=instance.tags.get('<STR_LIT>'),<EOL>stack_name=instance.tags.get('<STR_LIT>'),<EOL>logical_id=instance.tags.get('<STR_LIT>'),<EOL>security_groups=[g.name for g in instance.groups],<EOL>launch_time=instance.launch_time,<EOL>ami_id=instance.image_id,<EOL>tags={k.lower(): v for k, v in six.iteritems(instance.tags)}<EOL>)<EOL>", "docstring": "Loads a ``HostEntry`` from a boto instance.\n\n:param instance: A boto instance object.\n:type instance: :py:class:`boto.ec2.instanceInstance`\n\n:rtype: :py:class:`HostEntry`", "id": "f5441:c0:m10"}
{"signature": "def format_string(self, fmat_string):", "body": "try:<EOL><INDENT>return fmat_string.format(**vars(self))<EOL><DEDENT>except KeyError as e:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>'.format(repr(fmat_string),<EOL>repr(e)))<EOL><DEDENT>", "docstring": "Takes a string containing 0 or more {variables} and formats it\naccording to this instance's attributes.\n\n:param fmat_string: A string, e.g. '{name}-foo.txt'\n:type fmat_string: ``str``\n\n:return: The string formatted according to this instance. E.g.\n         'production-runtime-foo.txt'\n:rtype: ``str``", "id": "f5441:c0:m14"}
{"signature": "def get_cache_location():", "body": "region = get_region()<EOL>return join(CACHE_DIRECTORY, region.name + \"<STR_LIT>\")<EOL>", "docstring": "Use the region name to get the location of the cache JSON file.", "id": "f5441:m4"}
{"signature": "def display(self):", "body": "if isinstance(self.name, six.string_types) and len(self.name) > <NUM_LIT:0>:<EOL><INDENT>return '<STR_LIT>'.format(self.name, self.public_ip)<EOL><DEDENT>else:<EOL><INDENT>return self.public_ip<EOL><DEDENT>", "docstring": "Returns the best name to display for this host. Uses the instance\nname if available; else just the public IP.\n\n:rtype: ``str``", "id": "f5441:c0:m12"}
{"signature": "@classmethod<EOL><INDENT>def list_attributes(cls):<DEDENT>", "body": "fake_args = [None for _ in inspect.getargspec(cls.__init__).args[<NUM_LIT:1>:]]<EOL>fake_instance = cls(*fake_args)<EOL>return vars(fake_instance).keys()<EOL>", "docstring": "Lists all of the attributes to be found on an instance of this class.\nIt creates a \"fake instance\" by passing in `None` to all of the\n``__init__`` arguments, then returns all of the attributes of that\ninstance.\n\n:return: A list of instance attributes of this class.\n:rtype: ``list`` of ``str``", "id": "f5441:c0:m7"}
{"signature": "def _uniquify(_list):", "body": "seen = set()<EOL>result = []<EOL>for x in _list:<EOL><INDENT>if x not in seen:<EOL><INDENT>result.append(x)<EOL>seen.add(x)<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Remove duplicates in a list.", "id": "f5441:m0"}
{"signature": "def create(self, path):", "body": "fpath = os.path.join(self.tempdir, path)<EOL>if not os.path.exists(os.path.dirname(fpath)):<EOL><INDENT>os.makedirs(os.path.dirname(fpath))<EOL><DEDENT>open(fpath, '<STR_LIT:a>').close()<EOL>return fpath<EOL>", "docstring": "Create an empty file in the temporary directory, return the full path.", "id": "f5457:c0:m0"}
{"signature": "def getint(self, section, option):", "body": "try:<EOL><INDENT>return super(BugwarriorConfigParser, self).getint(section, option)<EOL><DEDENT>except ValueError:<EOL><INDENT>if self.get(section, option) == u'<STR_LIT>':<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\".format(<EOL>section=section, option=option))<EOL><DEDENT><DEDENT>", "docstring": "Accepts both integers and empty values.", "id": "f5468:c0:m0"}
{"signature": "def get_config_path():", "body": "if os.environ.get(BUGWARRIORRC):<EOL><INDENT>return os.environ[BUGWARRIORRC]<EOL><DEDENT>xdg_config_home = (<EOL>os.environ.get('<STR_LIT>') or os.path.expanduser('<STR_LIT>'))<EOL>xdg_config_dirs = (<EOL>(os.environ.get('<STR_LIT>') or '<STR_LIT>').split('<STR_LIT::>'))<EOL>paths = [<EOL>os.path.join(xdg_config_home, '<STR_LIT>', '<STR_LIT>'),<EOL>os.path.expanduser(\"<STR_LIT>\")]<EOL>paths += [<EOL>os.path.join(d, '<STR_LIT>', '<STR_LIT>') for d in xdg_config_dirs]<EOL>for path in paths:<EOL><INDENT>if os.path.exists(path):<EOL><INDENT>return path<EOL><DEDENT><DEDENT>return paths[<NUM_LIT:0>]<EOL>", "docstring": "Determine the path to the config file. This will return, in this order of\nprecedence:\n- the value of $BUGWARRIORRC if set\n- $XDG_CONFIG_HOME/bugwarrior/bugwarriorc if exists\n- ~/.bugwarriorrc if exists\n- <dir>/bugwarrior/bugwarriorc if exists, for dir in $XDG_CONFIG_DIRS\n- $XDG_CONFIG_HOME/bugwarrior/bugwarriorc otherwise", "id": "f5468:m9"}
{"signature": "def get_service_password(service, username, oracle=None, interactive=False):", "body": "import getpass<EOL>password = None<EOL>if not oracle or oracle == \"<STR_LIT>\":<EOL><INDENT>keyring = get_keyring()<EOL>password = keyring.get_password(service, username)<EOL>if interactive and password is None:<EOL><INDENT>oracle = \"<STR_LIT>\"<EOL>password = get_service_password(service, username,<EOL>oracle, interactive=True)<EOL>if password:<EOL><INDENT>keyring.set_password(service, username, password)<EOL><DEDENT><DEDENT><DEDENT>elif interactive and oracle == \"<STR_LIT>\":<EOL><INDENT>prompt = \"<STR_LIT>\" % service<EOL>password = getpass.getpass(prompt)<EOL><DEDENT>elif oracle.startswith('<STR_LIT>'):<EOL><INDENT>command = oracle[<NUM_LIT>:]<EOL>return oracle_eval(command)<EOL><DEDENT>if password is None:<EOL><INDENT>die(\"<STR_LIT>\" %<EOL>(oracle, interactive, service))<EOL><DEDENT>return password<EOL>", "docstring": "Retrieve the sensitive password for a service by:\n\n  * retrieving password from a secure store (@oracle:use_keyring, default)\n  * asking the password from the user (@oracle:ask_password, interactive)\n  * executing a command and use the output as password\n    (@oracle:eval:<command>)\n\nNote that the keyring may or may not be locked\nwhich requires that the user provides a password (interactive mode).\n\n:param service:     Service name, may be key into secure store (as string).\n:param username:    Username for the service (as string).\n:param oracle:      Hint which password oracle strategy to use.\n:return: Retrieved password (as string)\n\n.. seealso::\n    https://bitbucket.org/kang/python-keyring-lib", "id": "f5468:m4"}
{"signature": "def __contains__(self, key):", "body": "return self.config_parser.has_option(<EOL>self.service_target, self._get_key(key))<EOL>", "docstring": "Does service section specify this option?", "id": "f5468:c1:m2"}
{"signature": "def __getattr__(self, name):", "body": "return getattr(self.config_parser, name)<EOL>", "docstring": "Proxy undefined attributes/methods to ConfigParser object.", "id": "f5468:c1:m1"}
{"signature": "def build_uda_config_overrides(targets):", "body": "from bugwarrior.services import get_service<EOL>targets_udas = {}<EOL>for target in targets:<EOL><INDENT>targets_udas.update(get_service(target).ISSUE_CLASS.UDAS)<EOL><DEDENT>return {<EOL>'<STR_LIT>': targets_udas<EOL>}<EOL>", "docstring": "Returns a list of UDAs defined by given targets\n\n    For all targets in `targets`, build a dictionary of configuration overrides\n    representing the UDAs defined by the passed-in services (`targets`).\n\n    Given a hypothetical situation in which you have two services, the first\n    of which defining a UDA named 'serviceAid' (\"Service A ID\", string) and\n    a second service defining two UDAs named 'serviceBproject'\n    (\"Service B Project\", string) and 'serviceBnumber'\n    (\"Service B Number\", numeric), this would return the following structure::\n\n        {\n            'uda': {\n                'serviceAid': {\n                    'label': 'Service A ID',\n                    'type': 'string',\n                },\n                'serviceBproject': {\n                    'label': 'Service B Project',\n                    'type': 'string',\n                },\n                'serviceBnumber': {\n                    'label': 'Service B Number',\n                    'type': 'numeric',\n                }\n            }\n        }", "id": "f5473:m10"}
{"signature": "def api_request(self, url, **params):", "body": "params['<STR_LIT:key>'] = self.config.get('<STR_LIT>'),<EOL>params['<STR_LIT>'] = self.config.get('<STR_LIT>'),<EOL>url = \"<STR_LIT>\" + url<EOL>return self.json_response(requests.get(url, params=params))<EOL>", "docstring": "Make a trello API request. This takes an absolute url (without protocol\nand host) and a list of argumnets and return a GET request with the\nkey and token from the configuration", "id": "f5480:c1:m8"}
{"signature": "def get_cards(self, list_id):", "body": "params = {'<STR_LIT>': '<STR_LIT>'}<EOL>member = self.config.get('<STR_LIT>', None)<EOL>unassigned = self.config.get('<STR_LIT>', False, asbool)<EOL>if member is not None:<EOL><INDENT>params['<STR_LIT>'] = '<STR_LIT:true>'<EOL>params['<STR_LIT>'] = '<STR_LIT:username>'<EOL><DEDENT>cards = self.api_request(<EOL>\"<STR_LIT>\".format(list_id=list_id),<EOL>**params)<EOL>for card in cards:<EOL><INDENT>if (member is None<EOL>or member in [m['<STR_LIT:username>'] for m in card['<STR_LIT>']]<EOL>or (unassigned and not card['<STR_LIT>'])):<EOL><INDENT>yield card<EOL><DEDENT><DEDENT>", "docstring": "Returns an iterator for the cards in a given list, filtered\n        according to configuration values of trello.only_if_assigned and\n        trello.also_unassigned", "id": "f5480:c1:m6"}
{"signature": "def get_query(self, query):", "body": "url = self._api_url(<EOL>\"<STR_LIT>\", query=query)<EOL>return self._getter(url, subkey='<STR_LIT>')<EOL>", "docstring": "Run a generic issue/PR query", "id": "f5482:c0:m3"}
{"signature": "@staticmethod<EOL><INDENT>def _link_field_to_dict(field):<DEDENT>", "body": "if not field:<EOL><INDENT>return dict()<EOL><DEDENT>return dict([<EOL>(<EOL>part.split('<STR_LIT>')[<NUM_LIT:1>][<NUM_LIT:5>:-<NUM_LIT:1>],<EOL>part.split('<STR_LIT>')[<NUM_LIT:0>][<NUM_LIT:1>:-<NUM_LIT:1>],<EOL>) for part in field.split('<STR_LIT:U+002CU+0020>')<EOL>])<EOL>", "docstring": "Utility for ripping apart github's Link header field.\n        It's kind of ugly.", "id": "f5482:c0:m9"}
{"signature": "def _api_url(self, path, **context):", "body": "if self.host == '<STR_LIT>':<EOL><INDENT>baseurl = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>baseurl = \"<STR_LIT>\".format(self.host)<EOL><DEDENT>return baseurl + path.format(**context)<EOL>", "docstring": "Build the full url to the API endpoint", "id": "f5482:c0:m1"}
{"signature": "def get_author(self, issue):", "body": "raise NotImplementedError()<EOL>", "docstring": "Override this for filtering on tickets", "id": "f5485:c0:m10"}
{"signature": "def _aggregate_issues(conf, main_section, target, queue, service_name):", "body": "start = time.time()<EOL>try:<EOL><INDENT>service = get_service(service_name)(conf, main_section, target)<EOL>issue_count = <NUM_LIT:0><EOL>for issue in service.issues():<EOL><INDENT>queue.put(issue)<EOL>issue_count += <NUM_LIT:1><EOL><DEDENT><DEDENT>except SystemExit as e:<EOL><INDENT>log.critical(str(e))<EOL>queue.put((SERVICE_FINISHED_ERROR, (target, e)))<EOL><DEDENT>except BaseException as e:<EOL><INDENT>if hasattr(e, '<STR_LIT>') and e.request:<EOL><INDENT>e.request.hooks = {}<EOL><DEDENT>log.exception(\"<STR_LIT>\" % (target, e))<EOL>queue.put((SERVICE_FINISHED_ERROR, (target, e)))<EOL><DEDENT>else:<EOL><INDENT>queue.put((SERVICE_FINISHED_OK, (target, issue_count, )))<EOL><DEDENT>finally:<EOL><INDENT>duration = time.time() - start<EOL>log.info(\"<STR_LIT>\" % (target, duration))<EOL><DEDENT>", "docstring": "This worker function is separated out from the main\n    :func:`aggregate_issues` func only so that we can use multiprocessing\n    on it for speed reasons.", "id": "f5485:m1"}
{"signature": "def to_taskwarrior(self):", "body": "raise NotImplementedError()<EOL>", "docstring": "Transform a foreign record into a taskwarrior dictionary.", "id": "f5485:c1:m2"}
{"signature": "def aggregate_issues(conf, main_section, debug):", "body": "log.info(\"<STR_LIT>\")<EOL>targets = aslist(conf.get(main_section, '<STR_LIT>'))<EOL>queue = multiprocessing.Queue()<EOL>log.info(\"<STR_LIT>\" % len(targets))<EOL>processes = []<EOL>if debug:<EOL><INDENT>for target in targets:<EOL><INDENT>_aggregate_issues(<EOL>conf,<EOL>main_section,<EOL>target,<EOL>queue,<EOL>conf.get(target, '<STR_LIT>')<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for target in targets:<EOL><INDENT>proc = multiprocessing.Process(<EOL>target=_aggregate_issues,<EOL>args=(conf, main_section, target, queue, conf.get(target, '<STR_LIT>'))<EOL>)<EOL>proc.start()<EOL>processes.append(proc)<EOL>time.sleep(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>currently_running = len(targets)<EOL>while currently_running > <NUM_LIT:0>:<EOL><INDENT>issue = queue.get(True)<EOL>if isinstance(issue, tuple):<EOL><INDENT>completion_type, args = issue<EOL>if completion_type == SERVICE_FINISHED_ERROR:<EOL><INDENT>target, e = args<EOL>log.info(\"<STR_LIT>\")<EOL>for process in processes:<EOL><INDENT>process.terminate()<EOL><DEDENT>raise RuntimeError(<EOL>\"<STR_LIT>\".format(target))<EOL><DEDENT>currently_running -= <NUM_LIT:1><EOL>continue<EOL><DEDENT>yield issue<EOL><DEDENT>log.info(\"<STR_LIT>\")<EOL>", "docstring": "Return all issues from every target.", "id": "f5485:m2"}
{"signature": "def issues(self):", "body": "raise NotImplementedError()<EOL>", "docstring": "Returns a list of dicts representing issues from a remote service.\n\n        This is the main place to begin if you are implementing a new service\n        for bugwarrior.  Override this to gather issues for each service.\n\n        Each item in the list should be a dict that looks something like this:\n\n            {\n                \"description\": \"Some description of the issue\",\n                \"project\": \"some_project\",\n                \"priority\": \"H\",\n                \"annotations\": [\n                    \"This is an annotation\",\n                    \"This is another annotation\",\n                ]\n            }\n\n\n        The description can be 'anything' but must be consistent and unique for\n        issues you're pulling from a remote service.  You can and should use\n        the ``.description(...)`` method to help format your descriptions.\n\n        The project should be a string and may be anything you like.\n\n        The priority should be one of \"H\", \"M\", or \"L\".", "id": "f5485:c0:m11"}
{"signature": "@classmethod<EOL><INDENT>def validate_config(cls, service_config, target):<DEDENT>", "body": "if service_config.has_option(target, '<STR_LIT>'):<EOL><INDENT>die(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (target, cls.CONFIG_PREFIX))<EOL><DEDENT>if service_config.has_option(target, '<STR_LIT>'):<EOL><INDENT>die(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (target, cls.CONFIG_PREFIX))<EOL><DEDENT>if service_config.has_option(target, '<STR_LIT>'):<EOL><INDENT>die(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (target, cls.CONFIG_PREFIX))<EOL><DEDENT>if service_config.has_option(target, '<STR_LIT>'):<EOL><INDENT>die(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (target, cls.CONFIG_PREFIX))<EOL><DEDENT>", "docstring": "Validate generic options for a particular target", "id": "f5485:c0:m7"}
{"signature": "def get_issue_generator(self, user_id, project_id, project_name):", "body": "user_tasks_data = self.call_api(<EOL>\"<STR_LIT>\" + six.text_type(project_id) + \"<STR_LIT>\")<EOL>for key, task in enumerate(user_tasks_data):<EOL><INDENT>assigned_task = self.get_task_dict(project_id, key, task)<EOL>if assigned_task:<EOL><INDENT>log.debug(<EOL>\"<STR_LIT>\" + assigned_task['<STR_LIT:description>'] +<EOL>\"<STR_LIT>\")<EOL>yield assigned_task<EOL><DEDENT><DEDENT>", "docstring": "Approach:\n\n1. Get user ID from bugwarriorrc file\n2. Get list of tickets from /user-tasks for a given project\n3. For each ticket/task returned from #2, get ticket/task info and\n   check if logged-in user is primary (look at `is_owner` and\n   `user_id`)", "id": "f5486:c0:m2"}
{"signature": "def copy(self):", "body": "return ObliviousCookieJar()<EOL>", "docstring": "Make sure to return an instance of the correct class on copying.", "id": "f5492:c0:m1"}
{"signature": "def get_instance(self, data):", "body": "if self.transient:<EOL><INDENT>return None<EOL><DEDENT>props = get_primary_keys(self.opts.model)<EOL>filters = {prop.key: data.get(prop.key) for prop in props}<EOL>if None not in filters.values():<EOL><INDENT>return self.session.query(self.opts.model).filter_by(**filters).first()<EOL><DEDENT>return None<EOL>", "docstring": "Retrieve an existing record by primary key(s). If the schema instance\n        is transient, return None.\n\n        :param data: Serialized data to inform lookup.", "id": "f5499:c6:m5"}
{"signature": "@ma.post_load<EOL><INDENT>def make_instance(self, data):<DEDENT>", "body": "instance = self.instance or self.get_instance(data)<EOL>if instance is not None:<EOL><INDENT>for key, value in iteritems(data):<EOL><INDENT>setattr(instance, key, value)<EOL><DEDENT>return instance<EOL><DEDENT>kwargs, association_attrs = self._split_model_kwargs_association(data)<EOL>instance = self.opts.model(**kwargs)<EOL>for attr, value in iteritems(association_attrs):<EOL><INDENT>setattr(instance, attr, value)<EOL><DEDENT>return instance<EOL>", "docstring": "Deserialize data to an instance of the model. Update an existing row\n        if specified in `self.instance` or loaded by primary key(s) in the data;\n        else create a new row.\n\n        :param data: Data to deserialize.", "id": "f5499:c6:m6"}
{"signature": "def add_value(self, name, value):", "body": "try:<EOL><INDENT>if self._rfc_values[name] is None:<EOL><INDENT>self._rfc_values[name] = value<EOL><DEDENT>elif self.strict:<EOL><INDENT>if name in ('<STR_LIT>', '<STR_LIT:type>'):<EOL><INDENT>raise errors.MalformedLinkValue(<EOL>'<STR_LIT>'.format(name))<EOL><DEDENT>return<EOL><DEDENT><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>if self.strict and name in ('<STR_LIT:title>', '<STR_LIT>'):<EOL><INDENT>return<EOL><DEDENT>self._values.append((name, value))<EOL>", "docstring": "Add a new value to the list.\n\n:param str name: name of the value that is being parsed\n:param str value: value that is being parsed\n:raises ietfparse.errors.MalformedLinkValue:\n    if *strict mode* is enabled and a validation error\n    is detected\n\nThis method implements most of the validation mentioned in\nsections 5.3 and 5.4 of :rfc:`5988`.  The ``_rfc_values``\ndictionary contains the appropriate values for the attributes\nthat get special handling.  If *strict mode* is enabled, then\nonly values that are acceptable will be added to ``_values``.", "id": "f5516:c0:m1"}
{"signature": "def parse_content_type(content_type, normalize_parameter_values=True):", "body": "parts = _remove_comments(content_type).split('<STR_LIT:;>')<EOL>content_type, content_subtype = parts.pop(<NUM_LIT:0>).split('<STR_LIT:/>')<EOL>if '<STR_LIT:+>' in content_subtype:<EOL><INDENT>content_subtype, content_suffix = content_subtype.split('<STR_LIT:+>')<EOL><DEDENT>else:<EOL><INDENT>content_suffix = None<EOL><DEDENT>parameters = _parse_parameter_list(<EOL>parts, normalize_parameter_values=normalize_parameter_values)<EOL>return datastructures.ContentType(content_type, content_subtype,<EOL>dict(parameters),<EOL>content_suffix)<EOL>", "docstring": "Parse a content type like header.\n\n    :param str content_type: the string to parse as a content type\n    :param bool normalize_parameter_values:\n        setting this to ``False`` will enable strict RFC2045 compliance\n        in which content parameter values are case preserving.\n    :return: a :class:`~ietfparse.datastructures.ContentType` instance", "id": "f5518:m5"}
{"signature": "def parse_accept_encoding(header_value):", "body": "return _parse_qualified_list(header_value)<EOL>", "docstring": "Parse the ``Accept-Encoding`` header into a sorted list.\n\n:param str header_value: header value to parse\n\n:return: list of encodings sorted from highest to lowest priority\n\nThe `Accept-Encoding`_ header is a list of encodings with\noptional *quality* values.  The quality value indicates the strength\nof the preference where 1.0 is a strong preference and less than 0.001\nis outright rejection by the client.\n\n.. note::\n\n   Encodings that are rejected by setting the quality value\n   to less than 0.001.  If a wildcard is included in the header,\n   then it will appear **BEFORE** values that are rejected.\n\n.. _Accept-Encoding: https://tools.ietf.org/html/rfc7231#section-5.3.4", "id": "f5518:m2"}
{"signature": "def parse_link(header_value, strict=True):", "body": "sanitized = _remove_comments(header_value)<EOL>links = []<EOL>def parse_links(buf):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>quoted = re.findall('<STR_LIT>', buf)<EOL>for segment in quoted:<EOL><INDENT>left, match, right = buf.partition(segment)<EOL>match = match.replace('<STR_LIT:U+002C>', '<STR_LIT>')<EOL>match = match.replace('<STR_LIT:;>', '<STR_LIT>')<EOL>buf = '<STR_LIT>'.join([left, match, right])<EOL><DEDENT>while buf:<EOL><INDENT>matched = re.match(r'<STR_LIT>', buf)<EOL>if matched:<EOL><INDENT>groups = matched.groupdict()<EOL>params, _, buf = groups['<STR_LIT>'].partition('<STR_LIT:U+002C>')<EOL>params = params.replace('<STR_LIT>', '<STR_LIT:U+002C>')  <EOL>if params and not params.startswith('<STR_LIT:;>'):<EOL><INDENT>raise errors.MalformedLinkValue(<EOL>'<STR_LIT>')<EOL><DEDENT>yield (groups['<STR_LIT>'].strip(),<EOL>[p.replace('<STR_LIT>', '<STR_LIT:;>').strip()<EOL>for p in params[<NUM_LIT:1>:].split('<STR_LIT:;>') if p])<EOL>buf = buf.strip()<EOL><DEDENT>else:<EOL><INDENT>raise errors.MalformedLinkValue('<STR_LIT>', buf)<EOL><DEDENT><DEDENT><DEDENT>for target, param_list in parse_links(sanitized):<EOL><INDENT>parser = _helpers.ParameterParser(strict=strict)<EOL>for name, value in _parse_parameter_list(param_list):<EOL><INDENT>parser.add_value(name, value)<EOL><DEDENT>links.append(datastructures.LinkHeader(target=target,<EOL>parameters=parser.values))<EOL><DEDENT>return links<EOL>", "docstring": "Parse a HTTP Link header.\n\n:param str header_value: the header value to parse\n:param bool strict: set this to ``False`` to disable semantic\n    checking.  Syntactical errors will still raise an exception.\n    Use this if you want to receive all parameters.\n:return: a sequence of :class:`~ietfparse.datastructures.LinkHeader`\n    instances\n:raises ietfparse.errors.MalformedLinkValue:\n    if the specified `header_value` cannot be parsed", "id": "f5518:m7"}
{"signature": "def parse_cache_control(header_value):", "body": "directives = {}<EOL>for segment in parse_list(header_value):<EOL><INDENT>name, sep, value = segment.partition('<STR_LIT:=>')<EOL>if sep != '<STR_LIT:=>':<EOL><INDENT>directives[name] = None<EOL><DEDENT>elif sep and value:<EOL><INDENT>value = _dequote(value.strip())<EOL>try:<EOL><INDENT>directives[name] = int(value)<EOL><DEDENT>except ValueError:<EOL><INDENT>directives[name] = value<EOL><DEDENT><DEDENT><DEDENT>for name in _CACHE_CONTROL_BOOL_DIRECTIVES:<EOL><INDENT>if directives.get(name, '<STR_LIT>') is None:<EOL><INDENT>directives[name] = True<EOL><DEDENT><DEDENT>return directives<EOL>", "docstring": "Parse a `Cache-Control`_ header, returning a dictionary of key-value pairs.\n\nAny of the ``Cache-Control`` parameters that do not have directives, such\nas ``public`` or ``no-cache`` will be returned with a value of ``True``\nif they are set in the header.\n\n:param str header_value: ``Cache-Control`` header value to parse\n:return: the parsed ``Cache-Control`` header values\n:rtype: dict\n\n.. _Cache-Control: https://tools.ietf.org/html/rfc7234#section-5.2", "id": "f5518:m4"}
{"signature": "def parse_http_accept_header(header_value):", "body": "warnings.warn(\"<STR_LIT>\", DeprecationWarning)<EOL>return parse_accept(header_value)<EOL>", "docstring": "Parse an HTTP accept-like header.\n\n    :param str header_value: the header value to parse\n    :return: a :class:`list` of :class:`.ContentType` instances\n        in decreasing quality order.  Each instance is augmented\n        with the associated quality as a ``float`` property\n        named ``quality``.\n\n    ``Accept`` is a class of headers that contain a list of values\n    and an associated preference value.  The ever present `Accept`_\n    header is a perfect example.  It is a list of content types and\n    an optional parameter named ``q`` that indicates the relative\n    weight of a particular type.  The most basic example is::\n\n        Accept: audio/*;q=0.2, audio/basic\n\n    Which states that I prefer the ``audio/basic`` content type\n    but will accept other ``audio`` sub-types with an 80% mark down.\n\n    .. _Accept: http://tools.ietf.org/html/rfc7231#section-5.3.2\n\n    .. deprecated:: 1.3.0\n       Use :func:`~ietfparse.headers.parse_accept` instead.", "id": "f5518:m13"}
{"signature": "def parse_accept(header_value):", "body": "next_explicit_q = decimal.ExtendedContext.next_plus(decimal.Decimal('<STR_LIT>'))<EOL>headers = [parse_content_type(header)<EOL>for header in parse_list(header_value)]<EOL>for header in headers:<EOL><INDENT>q = header.parameters.pop('<STR_LIT:q>', None)<EOL>if q is None:<EOL><INDENT>q = '<STR_LIT:1.0>'<EOL><DEDENT>elif float(q) == <NUM_LIT:1.0>:<EOL><INDENT>q = float(next_explicit_q)<EOL>next_explicit_q = next_explicit_q.next_minus()<EOL><DEDENT>header.quality = float(q)<EOL><DEDENT>def ordering(left, right):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if left.quality != right.quality:<EOL><INDENT>return right.quality - left.quality<EOL><DEDENT>if left == right:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>if left > right:<EOL><INDENT>return -<NUM_LIT:1><EOL><DEDENT>return <NUM_LIT:1><EOL><DEDENT>return sorted(headers, key=functools.cmp_to_key(ordering))<EOL>", "docstring": "Parse an HTTP accept-like header.\n\n    :param str header_value: the header value to parse\n    :return: a :class:`list` of :class:`.ContentType` instances\n        in decreasing quality order.  Each instance is augmented\n        with the associated quality as a ``float`` property\n        named ``quality``.\n\n    ``Accept`` is a class of headers that contain a list of values\n    and an associated preference value.  The ever present `Accept`_\n    header is a perfect example.  It is a list of content types and\n    an optional parameter named ``q`` that indicates the relative\n    weight of a particular type.  The most basic example is::\n\n        Accept: audio/*;q=0.2, audio/basic\n\n    Which states that I prefer the ``audio/basic`` content type\n    but will accept other ``audio`` sub-types with an 80% mark down.\n\n    .. _Accept: http://tools.ietf.org/html/rfc7231#section-5.3.2", "id": "f5518:m0"}
{"signature": "def parse_link_header(header_value, strict=True):", "body": "warnings.warn(\"<STR_LIT>\", DeprecationWarning)<EOL>return parse_link(header_value, strict)<EOL>", "docstring": "Parse a HTTP Link header.\n\n:param str header_value: the header value to parse\n:param bool strict: set this to ``False`` to disable semantic\n    checking.  Syntactical errors will still raise an exception.\n    Use this if you want to receive all parameters.\n:return: a sequence of :class:`~ietfparse.datastructures.LinkHeader`\n    instances\n:raises ietfparse.errors.MalformedLinkValue:\n    if the specified `header_value` cannot be parsed\n\n.. deprecated:: 1.3.0\n   Use :func:`~ietfparse.headers.parse_link` instead.", "id": "f5518:m14"}
{"signature": "def select_content_type(requested, available):", "body": "class Match(object):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>WILDCARD, PARTIAL, FULL_TYPE, = <NUM_LIT:2>, <NUM_LIT:1>, <NUM_LIT:0><EOL>def __init__(self, candidate, pattern):<EOL><INDENT>self.candidate = candidate<EOL>self.pattern = pattern<EOL>if pattern.content_type == pattern.content_subtype == '<STR_LIT:*>':<EOL><INDENT>self.match_type = self.WILDCARD<EOL><DEDENT>elif pattern.content_subtype == '<STR_LIT:*>':<EOL><INDENT>self.match_type = self.PARTIAL<EOL><DEDENT>else:<EOL><INDENT>self.match_type = self.FULL_TYPE<EOL><DEDENT>self.parameter_distance = len(self.candidate.parameters)<EOL>for key, value in candidate.parameters.items():<EOL><INDENT>if key in pattern.parameters:<EOL><INDENT>if pattern.parameters[key] == value:<EOL><INDENT>self.parameter_distance -= <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>self.parameter_distance += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>def extract_quality(obj):<EOL><INDENT>return getattr(obj, '<STR_LIT>', <NUM_LIT:1.0>)<EOL><DEDENT>matches = []<EOL>for pattern in sorted(requested, key=extract_quality, reverse=True):<EOL><INDENT>for candidate in sorted(available):<EOL><INDENT>if _content_type_matches(candidate, pattern):<EOL><INDENT>if candidate == pattern:  <EOL><INDENT>if extract_quality(pattern) == <NUM_LIT:0.0>:<EOL><INDENT>raise errors.NoMatch  <EOL><DEDENT>return candidate, pattern<EOL><DEDENT>matches.append(Match(candidate, pattern))<EOL><DEDENT><DEDENT><DEDENT>if not matches:<EOL><INDENT>raise errors.NoMatch<EOL><DEDENT>matches = sorted(matches,<EOL>key=attrgetter('<STR_LIT>', '<STR_LIT>'))<EOL>return matches[<NUM_LIT:0>].candidate, matches[<NUM_LIT:0>].pattern<EOL>", "docstring": "Selects the best content type.\n\n    :param requested: a sequence of :class:`.ContentType` instances\n    :param available: a sequence of :class:`.ContentType` instances\n        that the server is capable of producing\n\n    :returns: the selected content type (from ``available``) and the\n        pattern that it matched (from ``requested``)\n    :rtype: :class:`tuple` of :class:`.ContentType` instances\n    :raises: :class:`.NoMatch` when a suitable match was not found\n\n    This function implements the *Proactive Content Negotiation*\n    algorithm as described in sections 3.4.1 and 5.3 of :rfc:`7231`.\n    The input is the `Accept`_ header as parsed by\n    :func:`.parse_http_accept_header` and a list of\n    parsed :class:`.ContentType` instances.  The ``available`` sequence\n    should be a sequence of content types that the server is capable of\n    producing.  The selected value should ultimately be used as the\n    `Content-Type`_ header in the generated response.\n\n    .. _Accept: http://tools.ietf.org/html/rfc7231#section-5.3.2\n    .. _Content-Type: http://tools.ietf.org/html/rfc7231#section-3.1.1.5", "id": "f5521:m1"}
{"signature": "def _normalize_host(host, enable_long_host=False, encode_with_idna=None,<EOL>scheme=None):", "body": "if encode_with_idna is not None:<EOL><INDENT>enable_idna = encode_with_idna<EOL><DEDENT>else:<EOL><INDENT>enable_idna = scheme.lower() in IDNA_SCHEMES if scheme else False<EOL><DEDENT>if enable_idna:<EOL><INDENT>try:<EOL><INDENT>host = '<STR_LIT:.>'.join(segment.encode('<STR_LIT>').decode()<EOL>for segment in host.split('<STR_LIT:.>'))<EOL><DEDENT>except UnicodeError as exc:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(exc))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>host = parse.quote(host.encode('<STR_LIT:utf-8>'), safe=HOST_SAFE_CHARS)<EOL><DEDENT>if len(host) > <NUM_LIT:255> and not enable_long_host:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return host<EOL>", "docstring": "Normalize a host for a URL.\n\n:param str host: the host name to normalize\n\n:keyword bool enable_long_host: if this keyword is specified\n    and it is :data:`True`, then the host name length restriction\n    from :rfc:`3986#section-3.2.2` is relaxed.\n:keyword bool encode_with_idna: if this keyword is specified\n    and it is :data:`True`, then the ``host`` parameter will be\n    encoded using IDN.  If this value is provided as :data:`False`,\n    then the percent-encoding scheme is used instead.  If this\n    parameter is omitted or included with a different value, then\n    the ``host`` parameter is processed using :data:`IDNA_SCHEMES`.\n:keyword str scheme: if this keyword is specified, then it is\n    used to determine whether to apply IDN rules or not.  This\n    parameter is ignored if `encode_with_idna` is not :data:`None`.\n\n:return: the normalized and encoded string ready for inclusion\n    into a URL", "id": "f5521:m5"}
{"signature": "def _create_url_identifier(user, password):", "body": "if user is not None:<EOL><INDENT>user = parse.quote(user.encode('<STR_LIT:utf-8>'), safe=USERINFO_SAFE_CHARS)<EOL>if password:<EOL><INDENT>password = parse.quote(password.encode('<STR_LIT:utf-8>'),<EOL>safe=USERINFO_SAFE_CHARS)<EOL>return '<STR_LIT>'.format(user, password)<EOL><DEDENT>return user<EOL><DEDENT>return None<EOL>", "docstring": "Generate the user+password portion of a URL.\n\n:param str user: the user name or :data:`None`\n:param str password: the password or :data:`None`", "id": "f5521:m4"}
{"signature": "def __str__(self):", "body": "if self.response and not isinstance(self.response, dict):<EOL><INDENT>return \"<STR_LIT>\"\"<STR_LIT>\".format(self.code, self.message, self.response.content)<EOL><DEDENT>return \"<STR_LIT>\"\"<STR_LIT>\".format(self.code, self.message, self.response)<EOL>", "docstring": "Exception to String", "id": "f5526:c0:m1"}
{"signature": "def __init__(self, endpoint, processes=<NUM_LIT:1>):", "body": "self.processes = processes<EOL>if endpoint.endswith('<STR_LIT:/>'):  <EOL><INDENT>self.url_endpoint_root = endpoint[<NUM_LIT:0>:-<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>self.url_endpoint_root = endpoint<EOL><DEDENT>self.session = requests.Session()<EOL>self.session.header = {'<STR_LIT:Content-Type>': '<STR_LIT:application/json>'}<EOL>methods = ['<STR_LIT:POST>', '<STR_LIT>', '<STR_LIT:GET>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>http_retry = Retry(total=<NUM_LIT:5>, connect=<NUM_LIT:5>, read=<NUM_LIT:5>, backoff_factor=<NUM_LIT:0.1>,<EOL>method_whitelist=methods)<EOL>https_retry = Retry(total=<NUM_LIT:5>, connect=<NUM_LIT:5>, read=<NUM_LIT:5>, backoff_factor=<NUM_LIT:0.1>,<EOL>method_whitelist=methods)<EOL>http_adapter = HTTPAdapter(max_retries=http_retry)<EOL>https_adapter = HTTPAdapter(max_retries=https_retry)<EOL>self.session.mount('<STR_LIT>', http_adapter)<EOL>self.session.mount('<STR_LIT>', https_adapter)<EOL>self.authenticated = False<EOL>self._token = None<EOL>self.proxies = None<EOL>self.timeout = None<EOL>", "docstring": "Initialize a client connection\n\n:param endpoint: root endpoint (API URL)\n:type endpoint: str", "id": "f5526:c1:m0"}
{"signature": "def get_url(self, endpoint):", "body": "return urljoin(self.url_endpoint_root, endpoint)<EOL>", "docstring": "Returns the formated full URL endpoint\n:param endpoint: str. the relative endpoint to access\n:return: str", "id": "f5526:c1:m1"}
{"signature": "def set_token(self, token):", "body": "if token:<EOL><INDENT>auth = HTTPBasicAuth(token, '<STR_LIT>')<EOL>self._token = token<EOL>self.authenticated = True  <EOL>self.session.auth = auth<EOL>logger.debug(\"<STR_LIT>\", token)<EOL><DEDENT>else:<EOL><INDENT>self._token = None<EOL>self.authenticated = False<EOL>self.session.auth = None<EOL>logger.debug(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Set token in authentification for next requests\n:param token: str. token to set in auth. If None, reinit auth", "id": "f5526:c1:m4"}
{"signature": "def get_response(self, method, endpoint, headers=None, json=None, params=None, data=None):<EOL>", "body": "logger.debug(\"<STR_LIT>\")<EOL>logger.debug(\"<STR_LIT>\", endpoint)<EOL>logger.debug(\"<STR_LIT>\", method)<EOL>logger.debug(\"<STR_LIT>\", headers)<EOL>logger.debug(\"<STR_LIT>\", json)<EOL>logger.debug(\"<STR_LIT>\", params)<EOL>logger.debug(\"<STR_LIT>\", data)<EOL>url = self.get_url(endpoint)<EOL>try:<EOL><INDENT>response = self.session.request(method=method, url=url, headers=headers, json=json,<EOL>params=params, data=data, proxies=self.proxies,<EOL>timeout=self.timeout)<EOL>logger.debug(\"<STR_LIT>\", response.headers)<EOL>logger.debug(\"<STR_LIT>\", response.content)<EOL><DEDENT>except RequestException as e:<EOL><INDENT>response = {\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": {\"<STR_LIT:message>\": e, \"<STR_LIT:code>\": BACKEND_ERROR},<EOL>\"<STR_LIT>\": {\"<STR_LIT:message>\": e, \"<STR_LIT:code>\": BACKEND_ERROR}}<EOL>raise BackendException(code=BACKEND_ERROR,<EOL>message=e,<EOL>response=response)<EOL><DEDENT>else:<EOL><INDENT>return response<EOL><DEDENT>", "docstring": "Returns the response from the requested endpoint with the requested method\n:param method: str. one of the methods accepted by Requests ('POST', 'GET', ...)\n:param endpoint: str. the relative endpoint to access\n:param params: (optional) Dictionary or bytes to be sent in the query string\nfor the :class:`Request`.\n:param data: (optional) Dictionary, bytes, or file-like object to send in the body\nof the :class:`Request`.\n:param json: (optional) json to send in the body of the :class:`Request`.\n:param headers: (optional) Dictionary of HTTP Headers to send with the :class:`Request`.\n:return: Requests.response", "id": "f5526:c1:m2"}
{"signature": "def delete(self, endpoint, headers):", "body": "response = self.get_response(method='<STR_LIT>', endpoint=endpoint, headers=headers)<EOL>logger.debug(\"<STR_LIT>\", response)<EOL>if response.status_code != <NUM_LIT>:  <EOL><INDENT>resp = self.decode(response=response)<EOL><DEDENT>resp = {\"<STR_LIT>\": \"<STR_LIT:OK>\"}<EOL>return resp<EOL>", "docstring": "Method to delete an item or all items\n\nheaders['If-Match'] must contain the _etag identifier of the element to delete\n\n:param endpoint: endpoint (API URL)\n:type endpoint: str\n:param headers: headers (example: Content-Type)\n:type headers: dict\n:return: response (deletion information)\n:rtype: dict", "id": "f5526:c1:m14"}
{"signature": "@staticmethod<EOL><INDENT>def decode(response):<DEDENT>", "body": "<EOL>try:<EOL><INDENT>response.raise_for_status()<EOL><DEDENT>except requests.HTTPError as e:<EOL><INDENT>raise BackendException(code=response.status_code,<EOL>message=e,<EOL>response=response)<EOL><DEDENT>else:<EOL><INDENT>resp_json = response.json()<EOL>error = resp_json.get('<STR_LIT>', None)<EOL>if error:<EOL><INDENT>raise BackendException(code=error['<STR_LIT:code>'],<EOL>message=error['<STR_LIT:message>'],<EOL>response=response)<EOL><DEDENT>return resp_json<EOL><DEDENT>", "docstring": "Decodes and returns the response as JSON (dict) or raise BackendException\n:param response: requests.response object\n:return: dict", "id": "f5526:c1:m3"}
{"signature": "def get_token(self):", "body": "return self._token<EOL>", "docstring": "Get the stored backend token", "id": "f5526:c1:m5"}
{"signature": "@classmethod<EOL><INDENT>def setUpClass(cls):<DEDENT>", "body": "print(\"<STR_LIT>\")<EOL>cls.backend_address = \"<STR_LIT>\"<EOL>os.environ['<STR_LIT>'] = '<STR_LIT>'<EOL>exit_code = subprocess.call(<EOL>shlex.split(<EOL>'<STR_LIT>' % os.environ['<STR_LIT>'])<EOL>)<EOL>assert exit_code == <NUM_LIT:0><EOL>cls.pid = subprocess.Popen([<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>'<EOL>])<EOL>time.sleep(<NUM_LIT:3>)<EOL>headers = {'<STR_LIT:Content-Type>': '<STR_LIT:application/json>'}<EOL>params = {'<STR_LIT:username>': '<STR_LIT>', '<STR_LIT:password>': '<STR_LIT>', '<STR_LIT:action>': '<STR_LIT>'}<EOL>response = requests.post(cls.backend_address + '<STR_LIT>', json=params, headers=headers)<EOL>resp = response.json()<EOL>cls.token = resp['<STR_LIT>']<EOL>cls.auth = requests.auth.HTTPBasicAuth(cls.token, '<STR_LIT>')<EOL>response = requests.get(cls.backend_address + '<STR_LIT>',<EOL>auth=cls.auth)<EOL>resp = response.json()<EOL>cls.realmAll_id = resp['<STR_LIT>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>", "docstring": "Function used in the beginning of test to prepare the backend\n\n:param module:\n:return: None", "id": "f5530:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def setUpClass(cls):<DEDENT>", "body": "print(\"<STR_LIT>\")<EOL>cls.backend_address = \"<STR_LIT>\"<EOL>os.environ['<STR_LIT>'] = '<STR_LIT>'<EOL>exit_code = subprocess.call(<EOL>shlex.split(<EOL>'<STR_LIT>' % os.environ['<STR_LIT>'])<EOL>)<EOL>assert exit_code == <NUM_LIT:0><EOL>cls.pid = subprocess.Popen([<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>'<EOL>])<EOL>time.sleep(<NUM_LIT:3>)<EOL>headers = {'<STR_LIT:Content-Type>': '<STR_LIT:application/json>'}<EOL>params = {'<STR_LIT:username>': '<STR_LIT>', '<STR_LIT:password>': '<STR_LIT>', '<STR_LIT:action>': '<STR_LIT>'}<EOL>response = requests.post(cls.backend_address + '<STR_LIT>', json=params, headers=headers)<EOL>resp = response.json()<EOL>cls.token = resp['<STR_LIT>']<EOL>cls.auth = requests.auth.HTTPBasicAuth(cls.token, '<STR_LIT>')<EOL>response = requests.get(cls.backend_address + '<STR_LIT>',<EOL>auth=cls.auth)<EOL>resp = response.json()<EOL>cls.realmAll_id = resp['<STR_LIT>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>", "docstring": "Function used in the beginning of test to prepare the backend\n\n:param module:\n:return: None", "id": "f5533:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def setUpClass(cls):<DEDENT>", "body": "print(\"<STR_LIT>\")<EOL>cls.backend_address = \"<STR_LIT>\"<EOL>", "docstring": "Function used in the beginning of test to prepare the backend\n\n:param module:\n:return: None", "id": "f5536:c1:m0"}
{"signature": "@classmethod<EOL><INDENT>def tearDownClass(cls):<DEDENT>", "body": "print(\"<STR_LIT>\")<EOL>cls.pid.kill()<EOL>", "docstring": "Stop the backend at the end of the tests\n\n:param module:\n:return: None", "id": "f5537:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def setUpClass(cls):<DEDENT>", "body": "print(\"<STR_LIT>\")<EOL>cls.backend_address = \"<STR_LIT>\"<EOL>os.environ['<STR_LIT>'] = '<STR_LIT>'<EOL>exit_code = subprocess.call(<EOL>shlex.split(<EOL>'<STR_LIT>' % os.environ['<STR_LIT>'])<EOL>)<EOL>assert exit_code == <NUM_LIT:0><EOL>cls.pid = subprocess.Popen([<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>'<EOL>])<EOL>time.sleep(<NUM_LIT:3>)<EOL>headers = {'<STR_LIT:Content-Type>': '<STR_LIT:application/json>'}<EOL>params = {'<STR_LIT:username>': '<STR_LIT>', '<STR_LIT:password>': '<STR_LIT>', '<STR_LIT:action>': '<STR_LIT>'}<EOL>response = requests.post(cls.backend_address + '<STR_LIT>', json=params, headers=headers)<EOL>resp = response.json()<EOL>cls.token = resp['<STR_LIT>']<EOL>cls.auth = requests.auth.HTTPBasicAuth(cls.token, '<STR_LIT>')<EOL>response = requests.get(cls.backend_address + '<STR_LIT>',<EOL>auth=cls.auth)<EOL>resp = response.json()<EOL>cls.realmAll_id = resp['<STR_LIT>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>headers = {'<STR_LIT:Content-Type>': '<STR_LIT:application/json>'}<EOL>params = {'<STR_LIT:name>': '<STR_LIT>', '<STR_LIT>': cls.realmAll_id}<EOL>for num in range(<NUM_LIT:100>):<EOL><INDENT>params['<STR_LIT:name>'] = '<STR_LIT>' + str(num)<EOL>response = requests.post(cls.backend_address + '<STR_LIT>', json=params,<EOL>headers=headers, auth=cls.auth)<EOL>print(response.__dict__)<EOL>assert_equal(response.status_code, <NUM_LIT>)<EOL><DEDENT>", "docstring": "Function used in the beginning of test to prepare the backend\n\n:param module:\n:return: None", "id": "f5537:c0:m0"}
{"signature": "def _norm_unicode(s):", "body": "return normalize('<STR_LIT>', py3compat.cast_unicode(s))<EOL>", "docstring": "Normalize unicode strings", "id": "f5548:m1"}
{"signature": "def postgres_contents_config():", "body": "config = Config()<EOL>config.NotebookApp.contents_manager_class = PostgresContentsManager<EOL>config.PostgresContentsManager.user_id = '<STR_LIT:test>'<EOL>config.PostgresContentsManager.db_url = TEST_DB_URL<EOL>return config<EOL>", "docstring": "Shared setup code for PostgresContentsAPITest and subclasses.", "id": "f5550:m2"}
{"signature": "def memoize_single_arg(f):", "body": "memo = {}<EOL>@wraps(f)<EOL>def memoized_f(arg):<EOL><INDENT>try:<EOL><INDENT>return memo[arg]<EOL><DEDENT>except KeyError:<EOL><INDENT>result = memo[arg] = f(arg)<EOL>return result<EOL><DEDENT><DEDENT>return memoized_f<EOL>", "docstring": "Decorator memoizing a single-argument function", "id": "f5553:m5"}
{"signature": "def _managers_changed(self, name, old, new):", "body": "for key in new:<EOL><INDENT>if '<STR_LIT:/>' in key:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\" % key<EOL>)<EOL><DEDENT>self.managers = {k.strip('<STR_LIT:/>'): v for k, v in new.items()}<EOL><DEDENT>", "docstring": "Strip slashes from directories before updating.", "id": "f5555:c0:m1"}
{"signature": "def path_dispatch_kwarg(mname, path_default, returns_model):", "body": "def _wrapper(self, path=path_default, **kwargs):<EOL><INDENT>prefix, mgr, mgr_path = _resolve_path(path, self.managers)<EOL>result = getattr(mgr, mname)(path=mgr_path, **kwargs)<EOL>if returns_model and prefix:<EOL><INDENT>return _apply_prefix(prefix, result)<EOL><DEDENT>else:<EOL><INDENT>return result<EOL><DEDENT><DEDENT>return _wrapper<EOL>", "docstring": "Parameterized decorator for methods that accept path as a second\nargument.", "id": "f5555:m5"}
{"signature": "def path_dispatch2(mname, first_argname, returns_model):", "body": "def _wrapper(self, *args, **kwargs):<EOL><INDENT>other, args = _get_arg(first_argname, args, kwargs)<EOL>path, args = _get_arg('<STR_LIT:path>', args, kwargs)<EOL>prefix, mgr, mgr_path = _resolve_path(path, self.managers)<EOL>result = getattr(mgr, mname)(other, mgr_path, *args, **kwargs)<EOL>if returns_model and prefix:<EOL><INDENT>return _apply_prefix(prefix, result)<EOL><DEDENT>else:<EOL><INDENT>return result<EOL><DEDENT><DEDENT>return _wrapper<EOL>", "docstring": "Decorator for methods that accept path as a second argument.", "id": "f5555:m4"}
{"signature": "@outside_root_to_404<EOL><INDENT>def get(self, path, content=True, type=None, format=None):<DEDENT>", "body": "path = normalize_api_path(path)<EOL>if path:<EOL><INDENT>return self.__get(path, content=content, type=type, format=format)<EOL><DEDENT>if not content:<EOL><INDENT>return base_directory_model('<STR_LIT>')<EOL><DEDENT>extra_content = self._extra_root_dirs()<EOL>rm = self.root_manager<EOL>if rm is None:<EOL><INDENT>root_model = base_directory_model('<STR_LIT>')<EOL>root_model.update(<EOL>format='<STR_LIT>',<EOL>content=extra_content,<EOL>)<EOL><DEDENT>else:<EOL><INDENT>root_model = rm.get(<EOL>path,<EOL>content=content,<EOL>type=type,<EOL>format=format,<EOL>)<EOL>root_model['<STR_LIT:content>'].extend(extra_content)<EOL><DEDENT>return root_model<EOL>", "docstring": "Special case handling for listing root dir.", "id": "f5555:c0:m4"}
{"signature": "def _get_arg(argname, args, kwargs):", "body": "try:<EOL><INDENT>return kwargs.pop(argname), args<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>return args[<NUM_LIT:0>], args[<NUM_LIT:1>:]<EOL><DEDENT>except IndexError:<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % argname)<EOL><DEDENT>", "docstring": "Get an argument, either from kwargs or from the first entry in args.\nRaises a TypeError if argname not in kwargs and len(args) == 0.\n\nMutates kwargs in place if the value is found in kwargs.", "id": "f5555:m1"}
{"signature": "@contextmanager<EOL>def temp_alembic_ini(alembic_dir_location, sqlalchemy_url):", "body": "with TemporaryDirectory() as tempdir:<EOL><INDENT>alembic_ini_filename = join(tempdir, '<STR_LIT>')<EOL>with open(alembic_ini_filename, '<STR_LIT:w>') as f:<EOL><INDENT>f.write(<EOL>ALEMBIC_INI_TEMPLATE.format(<EOL>alembic_dir_location=alembic_dir_location,<EOL>sqlalchemy_url=sqlalchemy_url,<EOL>)<EOL>)<EOL><DEDENT>yield alembic_ini_filename<EOL><DEDENT>", "docstring": "Temporarily write an alembic.ini file for use with alembic migration\nscripts.", "id": "f5559:m0"}
{"signature": "def _get_file(db, user_id, api_path, query_fields, decrypt_func):", "body": "result = db.execute(<EOL>_select_file(user_id, api_path, query_fields, limit=<NUM_LIT:1>),<EOL>).first()<EOL>if result is None:<EOL><INDENT>raise NoSuchFile(api_path)<EOL><DEDENT>if files.c.content in query_fields:<EOL><INDENT>return to_dict_with_content(query_fields, result, decrypt_func)<EOL><DEDENT>else:<EOL><INDENT>return to_dict_no_content(query_fields, result)<EOL><DEDENT>", "docstring": "Get file data for the given user_id, path, and query_fields.  The\nquery_fields parameter specifies which database fields should be\nincluded in the returned file data.", "id": "f5560:m19"}
{"signature": "def ensure_directory(db, user_id, api_path):", "body": "with ignore_unique_violation():<EOL><INDENT>create_directory(db, user_id, api_path)<EOL><DEDENT>", "docstring": "Ensure that the given user has the given directory.", "id": "f5560:m6"}
{"signature": "def preprocess_incoming_content(content, encrypt_func, max_size_bytes):", "body": "encrypted = encrypt_func(content)<EOL>if max_size_bytes != UNLIMITED and len(encrypted) > max_size_bytes:<EOL><INDENT>raise FileTooLarge()<EOL><DEDENT>return encrypted<EOL>", "docstring": "Apply preprocessing steps to file/notebook content that we're going to\nwrite to the database.\n\nApplies ``encrypt_func`` to ``content`` and checks that the result is\nsmaller than ``max_size_bytes``.", "id": "f5560:m0"}
{"signature": "def delete_directory(db, user_id, api_path):", "body": "db_dirname = from_api_dirname(api_path)<EOL>try:<EOL><INDENT>result = db.execute(<EOL>directories.delete().where(<EOL>and_(<EOL>directories.c.user_id == user_id,<EOL>directories.c.name == db_dirname,<EOL>)<EOL>)<EOL>)<EOL><DEDENT>except IntegrityError as error:<EOL><INDENT>if is_foreign_key_violation(error):<EOL><INDENT>raise DirectoryNotEmpty(api_path)<EOL><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>rowcount = result.rowcount<EOL>if not rowcount:<EOL><INDENT>raise NoSuchDirectory(api_path)<EOL><DEDENT>return rowcount<EOL>", "docstring": "Delete a directory.", "id": "f5560:m9"}
{"signature": "def reencrypt_user_content(engine,<EOL>user_id,<EOL>old_decrypt_func,<EOL>new_encrypt_func,<EOL>logger):", "body": "logger.info(\"<STR_LIT>\", user_id)<EOL>with engine.begin() as db:<EOL><INDENT>logger.info(\"<STR_LIT>\", user_id)<EOL>for (file_id,) in select_file_ids(db, user_id):<EOL><INDENT>reencrypt_row_content(<EOL>db,<EOL>files,<EOL>file_id,<EOL>old_decrypt_func,<EOL>new_encrypt_func,<EOL>logger,<EOL>)<EOL><DEDENT>logger.info(\"<STR_LIT>\", user_id)<EOL>for (cp_id,) in select_remote_checkpoint_ids(db, user_id):<EOL><INDENT>reencrypt_row_content(<EOL>db,<EOL>remote_checkpoints,<EOL>cp_id,<EOL>old_decrypt_func,<EOL>new_encrypt_func,<EOL>logger,<EOL>)<EOL><DEDENT><DEDENT>logger.info(\"<STR_LIT>\", user_id)<EOL>", "docstring": "Re-encrypt all of the files and checkpoints for a single user.", "id": "f5560:m42"}
{"signature": "def files_in_directory(db, user_id, db_dirname):", "body": "fields = _file_default_fields()<EOL>rows = db.execute(<EOL>select(<EOL>fields,<EOL>).where(<EOL>_is_in_directory(files, user_id, db_dirname),<EOL>).order_by(<EOL>files.c.user_id,<EOL>files.c.parent_name,<EOL>files.c.name,<EOL>files.c.created_at,<EOL>).distinct(<EOL>files.c.user_id, files.c.parent_name, files.c.name,<EOL>)<EOL>)<EOL>return [to_dict_no_content(fields, row) for row in rows]<EOL>", "docstring": "Return files in a directory.", "id": "f5560:m12"}
{"signature": "def select_file_ids(db, user_id):", "body": "return list(<EOL>db.execute(<EOL>select([files.c.id])<EOL>.where(files.c.user_id == user_id)<EOL>)<EOL>)<EOL>", "docstring": "Get all file ids for a user.", "id": "f5560:m40"}
{"signature": "def _file_creation_order():", "body": "return desc(files.c.created_at)<EOL>", "docstring": "Return an order_by on file creation date.", "id": "f5560:m16"}
{"signature": "def save_file(db, user_id, path, content, encrypt_func, max_size_bytes):", "body": "content = preprocess_incoming_content(<EOL>content,<EOL>encrypt_func,<EOL>max_size_bytes,<EOL>)<EOL>directory, name = split_api_filepath(path)<EOL>with db.begin_nested() as savepoint:<EOL><INDENT>try:<EOL><INDENT>res = db.execute(<EOL>files.insert().values(<EOL>name=name,<EOL>user_id=user_id,<EOL>parent_name=directory,<EOL>content=content,<EOL>)<EOL>)<EOL><DEDENT>except IntegrityError as error:<EOL><INDENT>if is_unique_violation(error):<EOL><INDENT>savepoint.rollback()<EOL>res = db.execute(<EOL>files.update().where(<EOL>_file_where(user_id, path),<EOL>).values(<EOL>content=content,<EOL>created_at=func.now(),<EOL>)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT><DEDENT>return res<EOL>", "docstring": "Save a file.\n\nTODO: Update-then-insert is probably cheaper than insert-then-update.", "id": "f5560:m26"}
{"signature": "def reencrypt_row_content(db,<EOL>table,<EOL>row_id,<EOL>decrypt_func,<EOL>encrypt_func,<EOL>logger):", "body": "q = (select([table.c.content])<EOL>.with_for_update()<EOL>.where(table.c.id == row_id))<EOL>[(content,)] = db.execute(q)<EOL>logger.info(\"<STR_LIT>\", table.name, row_id)<EOL>db.execute(<EOL>table<EOL>.update()<EOL>.where(table.c.id == row_id)<EOL>.values(content=encrypt_func(decrypt_func(content)))<EOL>)<EOL>logger.info(\"<STR_LIT>\", table.name, row_id)<EOL>", "docstring": "Re-encrypt a row from ``table`` with ``id`` of ``row_id``.", "id": "f5560:m39"}
{"signature": "def run_migrations_offline():", "body": "url = config.get_main_option(\"<STR_LIT>\")<EOL>context.configure(url=url, target_metadata=target_metadata)<EOL>with context.begin_transaction():<EOL><INDENT>context.run_migrations()<EOL><DEDENT>", "docstring": "Run migrations in 'offline' mode.\n\n    This configures the context with just a URL\n    and not an Engine, though an Engine is acceptable\n    here as well.  By skipping the Engine creation\n    we don't even need a DBAPI to be available.\n\n    Calls to context.execute() here emit the given string to the\n    script output.", "id": "f5568:m0"}
{"signature": "@contextmanager<EOL>def ignore_unique_violation():", "body": "try:<EOL><INDENT>yield<EOL><DEDENT>except IntegrityError as error:<EOL><INDENT>if not is_unique_violation(error):<EOL><INDENT>raise<EOL><DEDENT><DEDENT>", "docstring": "Context manager for gobbling unique violations.\n\nNOTE: If a unique violation is raised, the existing psql connection will\nnot accept new commands.  This just silences the python-level error.  If\nyou need emit another command after possibly ignoring a unique violation,\nyou should explicitly use savepoints.", "id": "f5570:m2"}
{"signature": "def to_dict_no_content(fields, row):", "body": "assert(len(fields) == len(row))<EOL>field_names = list(map(_get_name, fields))<EOL>assert '<STR_LIT:content>' not in field_names, \"<STR_LIT>\"<EOL>return dict(zip(field_names, row))<EOL>", "docstring": "Convert a SQLAlchemy row that does not contain a 'content' field to a dict.\n\nIf row is None, return None.\n\nRaises AssertionError if there is a field named 'content' in ``fields``.", "id": "f5570:m4"}
{"signature": "@outside_root_to_404<EOL><INDENT>def guess_type(self, path, allow_directory=True):<DEDENT>", "body": "if path.endswith('<STR_LIT>'):<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>elif allow_directory and self.dir_exists(path):<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT:file>'<EOL><DEDENT>", "docstring": "Guess the type of a file.\n\nIf allow_directory is False, don't consider the possibility that the\nfile is a directory.", "id": "f5571:c0:m6"}
{"signature": "def _save_directory(self, db, path):", "body": "ensure_directory(db, self.user_id, path)<EOL>", "docstring": "'Save' a directory.", "id": "f5571:c0:m21"}
{"signature": "def _file_model_from_db(self, record, content, format):", "body": "<EOL>path = to_api_path(record['<STR_LIT>'] + record['<STR_LIT:name>'])<EOL>model = base_model(path)<EOL>model['<STR_LIT:type>'] = '<STR_LIT:file>'<EOL>model['<STR_LIT>'] = model['<STR_LIT>'] = record['<STR_LIT>']<EOL>if content:<EOL><INDENT>bcontent = record['<STR_LIT:content>']<EOL>model['<STR_LIT:content>'], model['<STR_LIT>'], model['<STR_LIT>'] = from_b64(<EOL>path,<EOL>bcontent,<EOL>format,<EOL>)<EOL><DEDENT>return model<EOL>", "docstring": "Build a file model from database record.", "id": "f5571:c0:m17"}
{"signature": "def _directory_model_from_db(self, record, content):", "body": "model = base_directory_model(to_api_path(record['<STR_LIT:name>']))<EOL>if content:<EOL><INDENT>model['<STR_LIT>'] = '<STR_LIT>'<EOL>model['<STR_LIT:content>'] = list(<EOL>chain(<EOL>self._convert_file_records(record['<STR_LIT>']),<EOL>(<EOL>self._directory_model_from_db(subdir, False)<EOL>for subdir in record['<STR_LIT>']<EOL>),<EOL>)<EOL>)<EOL><DEDENT>return model<EOL>", "docstring": "Build a directory model from database directory record.", "id": "f5571:c0:m16"}
{"signature": "def _notebook_model_from_db(self, record, content):", "body": "path = to_api_path(record['<STR_LIT>'] + record['<STR_LIT:name>'])<EOL>model = base_model(path)<EOL>model['<STR_LIT:type>'] = '<STR_LIT>'<EOL>model['<STR_LIT>'] = model['<STR_LIT>'] = record['<STR_LIT>']<EOL>if content:<EOL><INDENT>content = reads_base64(record['<STR_LIT:content>'])<EOL>self.mark_trusted_cells(content, path)<EOL>model['<STR_LIT:content>'] = content<EOL>model['<STR_LIT>'] = '<STR_LIT>'<EOL>self.validate_notebook_model(model)<EOL><DEDENT>return model<EOL>", "docstring": "Build a notebook model from database record.", "id": "f5571:c0:m13"}
{"signature": "def writes_base64(nb, version=NBFORMAT_VERSION):", "body": "return b64encode(writes(nb, version=version).encode('<STR_LIT:utf-8>'))<EOL>", "docstring": "Write a notebook as base64.", "id": "f5573:m8"}
{"signature": "def split_api_filepath(path):", "body": "parts = path.rsplit('<STR_LIT:/>', <NUM_LIT:1>)<EOL>if len(parts) == <NUM_LIT:1>:<EOL><INDENT>name = parts[<NUM_LIT:0>]<EOL>dirname = '<STR_LIT:/>'<EOL><DEDENT>else:<EOL><INDENT>name = parts[<NUM_LIT:1>]<EOL>dirname = parts[<NUM_LIT:0>] + '<STR_LIT:/>'<EOL><DEDENT>return from_api_dirname(dirname), name<EOL>", "docstring": "Split an API file path into directory and name.", "id": "f5573:m7"}
{"signature": "def from_b64(path, bcontent, format):", "body": "decoders = {<EOL>'<STR_LIT>': lambda path, bcontent: (bcontent.decode('<STR_LIT:ascii>'), '<STR_LIT>'),<EOL>'<STR_LIT:text>': _decode_text_from_base64,<EOL>None: _decode_unknown_from_base64,<EOL>}<EOL>try:<EOL><INDENT>content, real_format = decoders[format](path, bcontent)<EOL><DEDENT>except HTTPError:<EOL><INDENT>raise<EOL><DEDENT>except Exception as e:<EOL><INDENT>raise CorruptedFile(e)<EOL><DEDENT>default_mimes = {<EOL>'<STR_LIT:text>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>}<EOL>mimetype = mimetypes.guess_type(path)[<NUM_LIT:0>] or default_mimes[real_format]<EOL>return content, real_format, mimetype<EOL>", "docstring": "Decode base64 content for a file.\n\nformat:\n  If 'text', the contents will be decoded as UTF-8.\n  If 'base64', do nothing.\n  If not specified, try to decode as UTF-8, and fall back to base64\n\nReturns a triple of decoded_content, format, and mimetype.", "id": "f5573:m12"}
{"signature": "def _decode_unknown_from_base64(path, bcontent):", "body": "content = b64decode(bcontent)<EOL>try:<EOL><INDENT>return (content.decode('<STR_LIT:utf-8>'), '<STR_LIT:text>')<EOL><DEDENT>except UnicodeError:<EOL><INDENT>pass<EOL><DEDENT>return bcontent.decode('<STR_LIT:ascii>'), '<STR_LIT>'<EOL>", "docstring": "Decode base64 data of unknown format.\n\nAttempts to interpret data as utf-8, falling back to ascii on failure.", "id": "f5573:m11"}
{"signature": "def get_pull_requests(app, repo_config):", "body": "response = get_api_response(app, repo_config, \"<STR_LIT>\")<EOL>if not response.ok:<EOL><INDENT>raise Exception(\"<STR_LIT>\".format(response.status_code))<EOL><DEDENT>return (item for item in response.json)<EOL>", "docstring": "Last 30 pull requests from a repository.\n\n    :param app: Flask app\n    :param repo_config: dict with ``github_repo`` key\n\n    :returns: id for a pull request", "id": "f5575:m12"}
{"signature": "def get_key_for_purpose_and_type(self, purpose, key_type):", "body": "key = [key for key in self.keys.values() if key.purpose == purpose and key.key_type == key_type]<EOL>try:<EOL><INDENT>return key[<NUM_LIT:0>]<EOL><DEDENT>except IndexError:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Gets a list of keys that match the purpose and key_type, and returns the first key in that list\nNote, if there are many keys that match the criteria, the one you get back will be random from that list\n:returns: A key object that matches the criteria", "id": "f5583:c1:m4"}
{"signature": "@staticmethod<EOL><INDENT>def decrypt_with_key(encrypted_token, key):<DEDENT>", "body": "try:<EOL><INDENT>jwe_token = jwe.JWE(algs=['<STR_LIT>', '<STR_LIT>'])<EOL>jwe_token.deserialize(encrypted_token)<EOL>jwe_token.decrypt(key)<EOL>return jwe_token.payload.decode()<EOL><DEDENT>except (ValueError, InvalidJWEData) as e:<EOL><INDENT>raise InvalidTokenException(str(e)) from e<EOL><DEDENT>", "docstring": "Decrypts JWE token with supplied key\n:param encrypted_token:\n:param key: A (:class:`jwcrypto.jwk.JWK`) decryption key or a password\n:returns: The payload of the decrypted token", "id": "f5589:c0:m1"}
{"signature": "def get_private_key(platform, service, purpose, key_use, version, private_key, keys_folder):", "body": "private_key_data = get_file_contents(keys_folder, private_key)<EOL>private_key = load_pem_private_key(private_key_data.encode(), None, backend=backend)<EOL>pub_key = private_key.public_key()<EOL>pub_bytes = pub_key.public_bytes(Encoding.PEM, PublicFormat.SubjectPublicKeyInfo)<EOL>kid = _generate_kid_from_key(pub_bytes.decode())<EOL>key = _create_key(platform=platform, service=service, key_use=key_use,<EOL>key_type=\"<STR_LIT>\", purpose=purpose, version=version,<EOL>public_key=pub_bytes.decode(), private_key=private_key_data)<EOL>return kid, key<EOL>", "docstring": "Loads a private key from the file system and adds it to a dict of keys\n:param keys: A dict of keys\n:param platform the platform the key is for\n:param service the service the key is for\n:param key_use what the key is used for\n:param version the version of the key\n:param purpose: The purpose of the private key\n:param private_key: The name of the private key to add\n:param keys_folder: The location on disk where the key exists\n:param kid_override: This allows the caller to override the generated KID value\n:return: None", "id": "f5591:m5"}
{"signature": "def get_public_key(platform, service, purpose, key_use, version, public_key, keys_folder):", "body": "public_key_data = get_file_contents(keys_folder, public_key)<EOL>pub_key = load_pem_public_key(public_key_data.encode(), backend=backend)<EOL>pub_bytes = pub_key.public_bytes(Encoding.PEM, PublicFormat.SubjectPublicKeyInfo)<EOL>kid = _generate_kid_from_key(pub_bytes.decode())<EOL>key = _create_key(platform=platform, service=service, key_use=key_use,<EOL>key_type=\"<STR_LIT>\", purpose=purpose, version=version,<EOL>public_key=public_key_data)<EOL>return kid, key<EOL>", "docstring": "Loads a public key from the file system and adds it to a dict of keys\n:param keys: A dict of keys\n:param platform the platform the key is for\n:param service the service the key is for\n:param key_use what the key is used for\n:param version the version of the key\n:param purpose: The purpose of the public key\n:param public_key: The name of the public key to add\n:param keys_folder: The location on disk where the key exists\n:param kid_override: This allows the caller to override the generated KID value\n:return: None", "id": "f5591:m4"}
{"signature": "@pointfree<EOL>def pfmap(func, iterable):", "body": "for item in iterable:<EOL><INDENT>yield func(item)<EOL><DEDENT>", "docstring": "A pointfree map function: Returns an iterator over the results of\n    applying a function of one argument to the items of a given iterable.\n    The function is provided \"lazily\" to the given iterable; each function\n    application is performed on the fly as it is requested.\n\n    :param func: A function of one argument to apply to each item\n    :param iterable: An iterator yielding input for the function\n    :rtype: Iterator of function application results\n\n    Example::\n\n        >>> f = pfmap(lambda x: x+1) \\\\\n        ...     >> pfmap(lambda x: x*2) \\\\\n        ...     >> pfcollect\n\n        >>> f(range(5))\n        [2, 4, 6, 8, 10]", "id": "f5604:m0"}
{"signature": "@classmethod<EOL><INDENT>def make_copy(klass, inst, func=None, argv=None, extra_argv=None, copy_sig=True):<DEDENT>", "body": "dest            = klass(func or inst.func)<EOL>dest.argv       = (argv or inst.argv).copy()<EOL>dest.extra_argv = list(extra_argv if extra_argv else inst.extra_argv)<EOL>if copy_sig:<EOL><INDENT>dest.__sig_from_partial(inst)<EOL><DEDENT>return dest<EOL>", "docstring": "Makes a new instance of the partial application wrapper based on\n        an existing instance, optionally overriding the original's wrapped\n        function and/or saved arguments.\n\n        :param inst: The partial instance we're copying\n        :param func: Override the original's wrapped function\n        :param argv: Override saved argument values\n        :param extra_argv: Override saved extra positional arguments\n        :param copy_sig: Copy original's signature?\n        :rtype: New partial wrapper instance", "id": "f5604:c0:m3"}
{"signature": "@pointfree<EOL>def pffilter(pred, iterable):", "body": "for item in iterable:<EOL><INDENT>if pred(item): yield item<EOL><DEDENT>", "docstring": "Pointfree filter function.\n\n    Example::\n\n        >>> f = pffilter(lambda n: n % 2 == 0) \\\\\n        ...     >> pfcollect\n\n        >>> f(range(5))\n        [0, 2, 4]", "id": "f5604:m2"}
{"signature": "def __new_argv(self, *new_pargs, **new_kargs):", "body": "new_argv = self.argv.copy()<EOL>new_extra_argv = list(self.extra_argv)<EOL>for v in new_pargs:<EOL><INDENT>arg_name = None<EOL>for name in self.pargl:<EOL><INDENT>if not name in new_argv:<EOL><INDENT>arg_name = name<EOL>break<EOL><DEDENT><DEDENT>if arg_name:<EOL><INDENT>new_argv[arg_name] = v<EOL><DEDENT>elif self.var_pargs:<EOL><INDENT>new_extra_argv.append(v)<EOL><DEDENT>else:<EOL><INDENT>num_prev_pargs = len([name for name in self.pargl if name in self.argv])<EOL>raise TypeError(\"<STR_LIT>\"% (self.__name__,<EOL>len(self.pargl),<EOL>num_prev_pargs + len(new_pargs)))<EOL><DEDENT><DEDENT>for k,v in new_kargs.items():<EOL><INDENT>if not (self.var_kargs or (k in self.pargl) or (k in self.kargl)):<EOL><INDENT>raise TypeError(\"<STR_LIT>\"% (self.__name__, k))<EOL><DEDENT>new_argv[k] = v<EOL><DEDENT>return (new_argv, new_extra_argv)<EOL>", "docstring": "Calculate new argv and extra_argv values resulting from adding\n        the specified positional and keyword arguments.", "id": "f5604:c0:m5"}
{"signature": "@pointfree<EOL>def pfprint_all(iterable, end='<STR_LIT:\\n>', file=None):", "body": "for item in iterable:<EOL><INDENT>pfprint(item, end=end, file=file)<EOL><DEDENT>", "docstring": "Prints each item from an iterable.\n\n    :param iterable: An iterable yielding values to print\n    :param end: String to append to the end of printed output\n    :param file: File to which output is printed\n    :rtype: None\n\n    Example::\n\n        >>> @pointfree\n        ... def prefix_all(prefix, iterable):\n        ...     for item in iterable:\n        ...         yield \"%s%s\" % (prefix, item)\n\n        >>> fn = prefix_all(\"An item: \") >> pfprint_all\n\n        >>> fn([\"foo\", \"bar\", \"baz\"])\n        An item: foo\n        An item: bar\n        An item: baz", "id": "f5604:m5"}
{"signature": "@pointfree<EOL>def pfignore_all(iterator):", "body": "for item in iterator:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Consumes all the items from an iterable, discarding their output.\n    This may be useful if evaluating the iterable produces some desirable\n    side-effect, but you have no need to collect its output.\n\n    :param iterable: An iterable\n    :rtype: None\n\n    Example::\n\n        >>> result = []\n\n        >>> @pointfree\n        ... def append_all(collector, iterable):\n        ...     for item in iterable:\n        ...         collector.append(item)\n        ...         yield item\n\n        >>> @pointfree\n        ... def square_all(iterable):\n        ...     for item in iterable:\n        ...         yield item**2\n\n        >>> fn = square_all \\\\\n        ...      >> append_all(result) \\\\\n        ...      >> pfignore_all\n        >>> fn([1, 2, 3, 4])\n        >>> result\n        [1, 4, 9, 16]", "id": "f5604:m6"}
{"signature": "@pointfree<EOL>def pfcollect(iterable, n=None):", "body": "if n:<EOL><INDENT>return list(itertools.islice(iterable, n))<EOL><DEDENT>else:<EOL><INDENT>return list(iterable)<EOL><DEDENT>", "docstring": "Collects and returns a list of values from the given iterable.  If\n    the n parameter is not specified, collects all values from the\n    iterable.\n\n    :param iterable: An iterable yielding values for the list\n    :param n: An optional maximum number of items to collect\n    :rtype: List of values from the iterable\n\n    Example::\n\n        >>> @pointfree\n        ... def fibonaccis():\n        ...     a, b = 0, 1\n        ...     while True:\n        ...         a, b = b, a+b\n        ...         yield a\n\n        >>> (pfcollect(n=10) * fibonaccis)()\n        [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]", "id": "f5604:m3"}
{"signature": "@property<EOL><INDENT>def mid_price(self):<DEDENT>", "body": "return (self.ask_price + self.bid_price) / Decimal('<STR_LIT>')<EOL>", "docstring": "Compute the mid point between the bid and ask prices", "id": "f5625:c2:m2"}
{"signature": "def generate_dataframe(self, symbols=None, date_index=None, price_type=\"<STR_LIT>\"):", "body": "<EOL>if symbols is None:<EOL><INDENT>symbols = list(Currency.objects.all().values_list('<STR_LIT>', flat=True))<EOL><DEDENT>try:<EOL><INDENT>start_date = date_index[<NUM_LIT:0>]<EOL>end_date = date_index[-<NUM_LIT:1>]<EOL><DEDENT>except:<EOL><INDENT>start_date = DATEFRAME_START_DATE<EOL>end_date = date.today()<EOL><DEDENT>date_index = date_range(start_date, end_date)<EOL>currency_price_data = CurrencyPrice.objects.filter(currency__symbol__in=symbols,<EOL>date__gte=date_index[<NUM_LIT:0>],<EOL>date__lte=date_index[-<NUM_LIT:1>]).values_list('<STR_LIT:date>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>try:<EOL><INDENT>forex_data_array = np.core.records.fromrecords(currency_price_data, names=['<STR_LIT:date>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL><DEDENT>except IndexError:<EOL><INDENT>forex_data_array = np.core.records.fromrecords([(date(<NUM_LIT>, <NUM_LIT:1>, <NUM_LIT:1>), \"<STR_LIT>\", <NUM_LIT:0>, <NUM_LIT:0>)], names=['<STR_LIT:date>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL><DEDENT>df = DataFrame.from_records(forex_data_array, index='<STR_LIT:date>')<EOL>df['<STR_LIT:date>'] = df.index<EOL>if price_type == \"<STR_LIT>\":<EOL><INDENT>df['<STR_LIT>'] = (df['<STR_LIT>'] + df['<STR_LIT>']) / <NUM_LIT:2><EOL><DEDENT>elif price_type == \"<STR_LIT>\":<EOL><INDENT>df['<STR_LIT>'] = df['<STR_LIT>']<EOL><DEDENT>elif price_type == \"<STR_LIT>\":<EOL><INDENT>df['<STR_LIT>'] = df['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % str(price_type))<EOL><DEDENT>df = df.pivot(index='<STR_LIT:date>', columns='<STR_LIT>', values='<STR_LIT>')<EOL>df = df.reindex(date_index)<EOL>df = df.fillna(method=\"<STR_LIT>\")<EOL>unlisted_symbols = list(set(symbols) - set(df.columns))<EOL>for unlisted_symbol in unlisted_symbols:<EOL><INDENT>df[unlisted_symbol] = np.nan<EOL><DEDENT>df = df[symbols]<EOL>return df<EOL>", "docstring": "Generate a dataframe consisting of the currency prices (specified by symbols)\nfrom the start to end date", "id": "f5625:c1:m0"}
{"signature": "@property<EOL><INDENT>def spread(self):<DEDENT>", "body": "return (self.ask_price - self.bid_price)<EOL>", "docstring": "Compute the difference between bid and ask prices", "id": "f5625:c2:m3"}
{"signature": "@app.route('<STR_LIT>', methods=['<STR_LIT:GET>', '<STR_LIT:POST>'])<EOL>def preferences():", "body": "<EOL>if request.method == '<STR_LIT:POST>':<EOL><INDENT>resp = make_response(redirect(urljoin(settings['<STR_LIT>']['<STR_LIT>'], url_for('<STR_LIT:index>'))))<EOL>try:<EOL><INDENT>request.preferences.parse_form(request.form)<EOL><DEDENT>except ValidationException:<EOL><INDENT>request.errors.append(gettext('<STR_LIT>'))<EOL>return resp<EOL><DEDENT>return request.preferences.save(resp)<EOL><DEDENT>image_proxy = request.preferences.get_value('<STR_LIT>')<EOL>lang = request.preferences.get_value('<STR_LIT>')<EOL>disabled_engines = request.preferences.engines.get_disabled()<EOL>allowed_plugins = request.preferences.plugins.get_enabled()<EOL>stats = {}<EOL>for c in categories:<EOL><INDENT>for e in categories[c]:<EOL><INDENT>stats[e.name] = {'<STR_LIT:time>': None,<EOL>'<STR_LIT>': False,<EOL>'<STR_LIT>': False}<EOL>if e.timeout > settings['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>stats[e.name]['<STR_LIT>'] = True<EOL><DEDENT>stats[e.name]['<STR_LIT>'] = _is_selected_language_supported(e, request.preferences)<EOL><DEDENT><DEDENT>for engine_stat in get_engines_stats()[<NUM_LIT:0>][<NUM_LIT:1>]:<EOL><INDENT>stats[engine_stat.get('<STR_LIT:name>')]['<STR_LIT:time>'] = round(engine_stat.get('<STR_LIT>'), <NUM_LIT:3>)<EOL>if engine_stat.get('<STR_LIT>') > settings['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>stats[engine_stat.get('<STR_LIT:name>')]['<STR_LIT>'] = True<EOL><DEDENT><DEDENT>return render('<STR_LIT>',<EOL>locales=settings['<STR_LIT>'],<EOL>current_locale=get_locale(),<EOL>image_proxy=image_proxy,<EOL>engines_by_category=categories,<EOL>stats=stats,<EOL>answerers=[{'<STR_LIT:info>': a.self_info(), '<STR_LIT>': a.keywords} for a in answerers],<EOL>disabled_engines=disabled_engines,<EOL>autocomplete_backends=autocomplete_backends,<EOL>shortcuts={y: x for x, y in engine_shortcuts.items()},<EOL>themes=themes,<EOL>plugins=plugins,<EOL>doi_resolvers=settings['<STR_LIT>'],<EOL>current_doi_resolver=get_doi_resolver(request.args, request.preferences.get_value('<STR_LIT>')),<EOL>allowed_plugins=allowed_plugins,<EOL>theme=get_current_theme_name(),<EOL>preferences_url_params=request.preferences.get_as_url_params(),<EOL>base_url=get_base_url(),<EOL>preferences=True)<EOL>", "docstring": "Render preferences page && save user preferences", "id": "f5718:m15"}
{"signature": "@app.route('<STR_LIT>', methods=['<STR_LIT:GET>'])<EOL>def stats():", "body": "stats = get_engines_stats()<EOL>return render(<EOL>'<STR_LIT>',<EOL>stats=stats,<EOL>)<EOL>", "docstring": "Render engine statistics page.", "id": "f5718:m18"}
{"signature": "def get_current_theme_name(override=None):", "body": "if override and (override in themes or override == '<STR_LIT>'):<EOL><INDENT>return override<EOL><DEDENT>theme_name = request.args.get('<STR_LIT>', request.preferences.get_value('<STR_LIT>'))<EOL>if theme_name not in themes:<EOL><INDENT>theme_name = default_theme<EOL><DEDENT>return theme_name<EOL>", "docstring": "Returns theme name.\n\n    Checks in this order:\n    1. override\n    2. cookies\n    3. settings", "id": "f5718:m4"}
{"signature": "def request(method, url, **kwargs):", "body": "time_before_request = time()<EOL>session = SessionSinglePool()<EOL>kwargs['<STR_LIT>'] = settings['<STR_LIT>'].get('<STR_LIT>') or None<EOL>if '<STR_LIT>' in kwargs:<EOL><INDENT>timeout = kwargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>timeout = getattr(threadLocal, '<STR_LIT>', None)<EOL>if timeout is not None:<EOL><INDENT>kwargs['<STR_LIT>'] = timeout<EOL><DEDENT><DEDENT>response = session.request(method=method, url=url, **kwargs)<EOL>time_after_request = time()<EOL>if timeout is not None:<EOL><INDENT>timeout_overhead = <NUM_LIT>  <EOL>start_time = getattr(threadLocal, '<STR_LIT>', time_before_request)<EOL>search_duration = time_after_request - start_time<EOL>if search_duration > timeout + timeout_overhead:<EOL><INDENT>raise requests.exceptions.Timeout(response=response)<EOL><DEDENT><DEDENT>session.close()<EOL>if hasattr(threadLocal, '<STR_LIT>'):<EOL><INDENT>threadLocal.total_time += time_after_request - time_before_request<EOL><DEDENT>return response<EOL>", "docstring": "same as requests/requests/api.py request(...)", "id": "f5724:m3"}
{"signature": "def searx_bang(full_query):", "body": "<EOL>if len(full_query.getSearchQuery()) == <NUM_LIT:0>:<EOL><INDENT>return []<EOL><DEDENT>results = []<EOL>first_char = full_query.getSearchQuery()[<NUM_LIT:0>]<EOL>if first_char == '<STR_LIT:!>' or first_char == '<STR_LIT:?>':<EOL><INDENT>if len(full_query.getSearchQuery()) == <NUM_LIT:1>:<EOL><INDENT>results.append(first_char + \"<STR_LIT>\")<EOL>results.append(first_char + \"<STR_LIT>\")<EOL>results.append(first_char + \"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>engine_query = full_query.getSearchQuery()[<NUM_LIT:1>:]<EOL>for categorie in categories:<EOL><INDENT>if categorie.startswith(engine_query):<EOL><INDENT>results.append(first_char + '<STR_LIT>'.format(categorie=categorie))<EOL><DEDENT><DEDENT>for engine in engines:<EOL><INDENT>if engine.startswith(engine_query.replace('<STR_LIT:_>', '<STR_LIT:U+0020>')):<EOL><INDENT>results.append(first_char + '<STR_LIT>'.format(engine=engine.replace('<STR_LIT:U+0020>', '<STR_LIT:_>')))<EOL><DEDENT><DEDENT>for engine_shortcut in engine_shortcuts:<EOL><INDENT>if engine_shortcut.startswith(engine_query):<EOL><INDENT>results.append(first_char + '<STR_LIT>'.format(engine_shortcut=engine_shortcut))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>elif first_char == '<STR_LIT::>':<EOL><INDENT>if len(full_query.getSearchQuery()) == <NUM_LIT:1>:<EOL><INDENT>results.append(\"<STR_LIT>\")<EOL>results.append(\"<STR_LIT>\")<EOL>results.append(\"<STR_LIT>\")<EOL>results.append(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>engine_query = full_query.getSearchQuery()[<NUM_LIT:1>:]<EOL>for lc in language_codes:<EOL><INDENT>lang_id, lang_name, country, english_name = map(unicode.lower, lc)<EOL>if lang_id.startswith(engine_query):<EOL><INDENT>if len(engine_query) <= <NUM_LIT:2>:<EOL><INDENT>results.append(u'<STR_LIT>'.format(lang_id=lang_id.split('<STR_LIT:->')[<NUM_LIT:0>]))<EOL><DEDENT>else:<EOL><INDENT>results.append(u'<STR_LIT>'.format(lang_id=lang_id))<EOL><DEDENT><DEDENT>if lang_name.startswith(engine_query) or english_name.startswith(engine_query):<EOL><INDENT>results.append(u'<STR_LIT>'.format(lang_name=lang_name))<EOL><DEDENT>if country.startswith(engine_query.replace('<STR_LIT:_>', '<STR_LIT:U+0020>')):<EOL><INDENT>results.append(u'<STR_LIT>'.format(country=country.replace('<STR_LIT:U+0020>', '<STR_LIT:_>')))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>result_set = set(results)<EOL>for query_part in full_query.query_parts:<EOL><INDENT>if query_part in result_set:<EOL><INDENT>result_set.remove(query_part)<EOL><DEDENT><DEDENT>return list(result_set)<EOL>", "docstring": "check if the searchQuery contain a bang, and create fitting autocompleter results", "id": "f5823:m1"}
{"signature": "def request(query, params):", "body": "params['<STR_LIT:url>'] = '<STR_LIT>' % query<EOL>return params<EOL>", "docstring": "pre-request callback\n    params<dict>:\n      method  : POST/GET\n      headers : {}\n      data    : {} # if method == POST\n      url     : ''\n      category: 'search category'\n      pageno  : 1 # number of the requested page", "id": "f5825:m0"}
{"signature": "def response(resp):", "body": "return [{'<STR_LIT:url>': '<STR_LIT>', '<STR_LIT:title>': '<STR_LIT>', '<STR_LIT:content>': '<STR_LIT>'}]<EOL>", "docstring": "post-response callback\n    resp: requests response object", "id": "f5825:m1"}
{"signature": "def post_task():", "body": "", "docstring": "Test method.", "id": "f5827:m1"}
{"signature": "@dumps.command()<EOL>@click.argument('<STR_LIT>', type=click.File('<STR_LIT:r>'), nargs=-<NUM_LIT:1>)<EOL>@with_appcontext<EOL>def loaduserexts(sources):", "body": "from .tasks.oauthclient import load_userext<EOL>loadcommon(sources, load_userext)<EOL>", "docstring": "Load user identities (legacy UserEXT).", "id": "f5841:m11"}
{"signature": "@dumps.command()<EOL>@click.argument('<STR_LIT>', type=click.File('<STR_LIT:r>'), nargs=-<NUM_LIT:1>)<EOL>@with_appcontext<EOL>def loadremotetokens(sources):", "body": "from .tasks.oauthclient import load_remotetoken<EOL>loadcommon(sources, load_remotetoken)<EOL>", "docstring": "Load remote tokens.", "id": "f5841:m10"}
{"signature": "@dumps.command()<EOL>@click.argument('<STR_LIT>', type=click.File('<STR_LIT:r>'), nargs=-<NUM_LIT:1>)<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=int,<EOL>help='<STR_LIT>',<EOL>default=None)<EOL>@with_appcontext<EOL>def loaddeposit(sources, depid):", "body": "from .tasks.deposit import load_deposit<EOL>if depid is not None:<EOL><INDENT>def pred(dep):<EOL><INDENT>return int(dep[\"<STR_LIT>\"][\"<STR_LIT:id>\"]) == depid<EOL><DEDENT>loadcommon(sources, load_deposit, predicate=pred, asynchronous=False)<EOL><DEDENT>else:<EOL><INDENT>loadcommon(sources, load_deposit)<EOL><DEDENT>", "docstring": "Load deposit.\n\n    Usage:\n        invenio dumps loaddeposit ~/data/deposit_dump_*.json\n        invenio dumps loaddeposit -d 12345 ~/data/deposit_dump_*.json", "id": "f5841:m8"}
{"signature": "def prepare_files(self):", "body": "<EOL>files = {}<EOL>for f in self.data['<STR_LIT>']:<EOL><INDENT>k = f['<STR_LIT>']<EOL>if k not in files:<EOL><INDENT>files[k] = []<EOL><DEDENT>files[k].append(f)<EOL><DEDENT>for k in files.keys():<EOL><INDENT>files[k].sort(key=lambda x: x['<STR_LIT:version>'])<EOL><DEDENT>self.files = files<EOL>", "docstring": "Get files from data dump.", "id": "f5844:c1:m6"}
{"signature": "@cached_property<EOL><INDENT>def recid(self):<DEDENT>", "body": "return self.data['<STR_LIT>']<EOL>", "docstring": "Get recid.", "id": "f5844:c1:m3"}
{"signature": "@property<EOL><INDENT>def rest(self):<DEDENT>", "body": "return self.revisions[<NUM_LIT:1>:]<EOL>", "docstring": "The list of old revisions.", "id": "f5844:c1:m10"}
{"signature": "def prepare_revisions(self):", "body": "<EOL>self.revisions = []<EOL>it = [self.data['<STR_LIT>'][<NUM_LIT:0>]] if self.latest_onlyelse self.data['<STR_LIT>']<EOL>for i in it:<EOL><INDENT>self.revisions.append(self._prepare_revision(i))<EOL><DEDENT>", "docstring": "Prepare data.", "id": "f5844:c1:m5"}
{"signature": "def is_deleted(self, record=None):", "body": "record = record or self.revisions[-<NUM_LIT:1>][<NUM_LIT:1>]<EOL>return any(<EOL>col == '<STR_LIT>'<EOL>for col in record.get('<STR_LIT>', [])<EOL>)<EOL>", "docstring": "Check if record is deleted.", "id": "f5844:c1:m11"}
{"signature": "@cached_property<EOL><INDENT>def missing_pids(self):<DEDENT>", "body": "missing = []<EOL>for p in self.pids:<EOL><INDENT>try:<EOL><INDENT>PersistentIdentifier.get(p.pid_type, p.pid_value)<EOL><DEDENT>except PIDDoesNotExistError:<EOL><INDENT>missing.append(p)<EOL><DEDENT><DEDENT>return missing<EOL>", "docstring": "Filter persistent identifiers.", "id": "f5844:c1:m2"}
{"signature": "@shared_task()<EOL>def load_remotetoken(data):", "body": "from invenio_oauthclient.models import RemoteToken<EOL>load_common(RemoteToken, data)<EOL>", "docstring": "Load the remote tokens from data dump.\n\n    :param data: Dictionary containing remote tokens data.\n    :type data: dict", "id": "f5846:m1"}
{"signature": "@shared_task()<EOL>def load_remoteaccount(data):", "body": "from invenio_oauthclient.models import RemoteAccount<EOL>load_common(RemoteAccount, data)<EOL>", "docstring": "Load the remote accounts from data dump.\n\n    :param data: Dictionary containing remote accounts data.\n    :type data: dict", "id": "f5846:m0"}
{"signature": "@shared_task()<EOL>def load_client(data):", "body": "from invenio_oauth2server.models import Client<EOL>load_common(Client, data)<EOL>", "docstring": "Load the oauth2server client from data dump.", "id": "f5847:m0"}
{"signature": "def __init__(self, pid, recid, *args, **kwargs):", "body": "self.recid = recid<EOL>super(DepositRecidDoesNotExist, self).__init__(pid, *args, **kwargs)<EOL>", "docstring": "Initialize exception.", "id": "f5848:c1:m0"}
{"signature": "@shared_task()<EOL>def load_deposit(data):", "body": "from invenio_db import db<EOL>deposit, dep_pid = create_record_and_pid(data)<EOL>deposit = create_files_and_sip(deposit, dep_pid)<EOL>db.session.commit()<EOL>", "docstring": "Load the raw JSON dump of the Deposition.\n\n    Uses Record API in order to bypass all Deposit-specific initialization,\n    which are to be done after the final stage of deposit migration.\n\n    :param data: Dictionary containing deposition data.\n    :type data: dict", "id": "f5849:m0"}
{"signature": "@shared_task()<EOL>def load_featured(data):", "body": "from invenio_communities.models import FeaturedCommunity<EOL>obj = FeaturedCommunity(id=data['<STR_LIT:id>'],<EOL>id_community=data['<STR_LIT>'],<EOL>start_date=iso2dt(data['<STR_LIT>']))<EOL>db.session.add(obj)<EOL>db.session.commit()<EOL>", "docstring": "Load community featuring from data dump.\n\n    :param data: Dictionary containing community featuring data.\n    :type data: dict", "id": "f5850:m1"}
{"signature": "@shared_task()<EOL>def load_user(data):", "body": "from invenio_accounts.models import User<EOL>from invenio_userprofiles.api import UserProfile<EOL>email = data['<STR_LIT:email>'].strip()<EOL>if User.query.filter_by(email=email).count() > <NUM_LIT:0>:<EOL><INDENT>raise UserEmailExistsError(<EOL>\"<STR_LIT>\".format(email=email))<EOL><DEDENT>last_login = None<EOL>if data['<STR_LIT>']:<EOL><INDENT>last_login = arrow.get(data['<STR_LIT>']).datetime<EOL><DEDENT>confirmed_at = None<EOL>if data['<STR_LIT>'] == '<STR_LIT:1>':<EOL><INDENT>confirmed_at = datetime.utcnow()<EOL><DEDENT>salt = data['<STR_LIT>']<EOL>checksum = data['<STR_LIT:password>']<EOL>if not checksum:<EOL><INDENT>new_password = None<EOL><DEDENT>elif checksum.startswith('<STR_LIT:$>'):<EOL><INDENT>new_password = checksum<EOL><DEDENT>else:<EOL><INDENT>new_password = str.join('<STR_LIT:$>', ['<STR_LIT>', u'<STR_LIT>', salt, checksum])<EOL><DEDENT>with db.session.begin_nested():<EOL><INDENT>obj = User(<EOL>id=data['<STR_LIT:id>'],<EOL>password=new_password,<EOL>email=email,<EOL>confirmed_at=confirmed_at,<EOL>last_login_at=last_login,<EOL>active=(data['<STR_LIT>'] != '<STR_LIT:0>'),<EOL>)<EOL>db.session.add(obj)<EOL><DEDENT>nickname = data['<STR_LIT>'].strip()<EOL>overwritten_username = ('<STR_LIT:username>' in data and '<STR_LIT>' in data)<EOL>if nickname or overwritten_username:<EOL><INDENT>p = UserProfile(user=obj)<EOL>p.full_name = data.get('<STR_LIT>', '<STR_LIT>').strip()<EOL>if overwritten_username:<EOL><INDENT>p._username = data['<STR_LIT:username>'].lower()<EOL>p._displayname = data['<STR_LIT>']<EOL><DEDENT>elif nickname:<EOL><INDENT>if UserProfile.query.filter(<EOL>UserProfile._username == nickname.lower()).count() > <NUM_LIT:0>:<EOL><INDENT>raise UserUsernameExistsError(<EOL>\"<STR_LIT>\".format(<EOL>username=nickname))<EOL><DEDENT>try:<EOL><INDENT>p.username = nickname<EOL><DEDENT>except ValueError:<EOL><INDENT>current_app.logger.warn(<EOL>u'<STR_LIT>'.format(<EOL>nickname, data['<STR_LIT:id>']))<EOL>p._username = nickname.lower()<EOL>p._displayname = nickname<EOL><DEDENT><DEDENT>db.session.add(p)<EOL><DEDENT>db.session.commit()<EOL>", "docstring": "Load user from data dump.\n\n    NOTE: This task takes into account the possible duplication of emails and\n    usernames, hence it should be called synchronously.\n    In such case of collision it will raise UserEmailExistsError or\n    UserUsernameExistsError, if email or username are already existing in\n    the database. Caller of this task should take care to to resolve those\n    collisions beforehand or after catching an exception.\n\n    :param data: Dictionary containing user data.\n    :type data: dict", "id": "f5854:m0"}
{"signature": "def check(id_):", "body": "BibRecDocs, BibDoc = _import_bibdoc()<EOL>try:<EOL><INDENT>BibDoc(id_).list_all_files()<EOL><DEDENT>except Exception:<EOL><INDENT>click.secho(\"<STR_LIT>\".format(id_), fg='<STR_LIT>')<EOL><DEDENT>", "docstring": "Check bibdocs.", "id": "f5857:m6"}
{"signature": "def _get_recids_invenio2(from_date):", "body": "from invenio.legacy.dbquery import run_sql<EOL>return (id[<NUM_LIT:0>] for id in run_sql(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>(from_date, ), run_on_slave=True))<EOL>", "docstring": "Get BibDocs for Invenio 2.", "id": "f5857:m1"}
{"signature": "def _import_bibdoc():", "body": "try:<EOL><INDENT>from invenio.bibdocfile import BibRecDocs, BibDoc<EOL><DEDENT>except ImportError:<EOL><INDENT>from invenio.legacy.bibdocfile.api import BibRecDocs, BibDoc<EOL><DEDENT>return BibRecDocs, BibDoc<EOL>", "docstring": "Import BibDocFile.", "id": "f5857:m3"}
{"signature": "@click.group()<EOL>def cli():", "body": "pass<EOL>", "docstring": "Command for dumping all records as JSON.", "id": "f5859:m0"}
{"signature": "def _get_run_sql():", "body": "try:<EOL><INDENT>from invenio.dbquery import run_sql<EOL><DEDENT>except ImportError:<EOL><INDENT>from invenio.legacy.dbquery import run_sql<EOL><DEDENT>return run_sql<EOL>", "docstring": "Import ``run_sql``.", "id": "f5860:m0"}
{"signature": "def get_connected_roles(action_id):", "body": "try:<EOL><INDENT>from invenio.access_control_admin import compile_role_definition<EOL><DEDENT>except ImportError:<EOL><INDENT>from invenio.modules.access.firerole import compile_role_definition<EOL><DEDENT>run_sql = _get_run_sql()<EOL>roles = {}<EOL>res = run_sql(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>', (action_id, )<EOL>)<EOL>for r in res:<EOL><INDENT>role = roles.setdefault(<EOL>r[<NUM_LIT:0>], {<EOL>'<STR_LIT:id>': r[<NUM_LIT:0>],<EOL>'<STR_LIT:name>': r[<NUM_LIT:1>],<EOL>'<STR_LIT:description>': r[<NUM_LIT:2>],<EOL>'<STR_LIT>': r[<NUM_LIT:3>],<EOL>'<STR_LIT>': compile_role_definition(r[<NUM_LIT:3>]),<EOL>'<STR_LIT>': set(),<EOL>'<STR_LIT>': {}<EOL>}<EOL>)<EOL>param = role['<STR_LIT>'].setdefault(r[<NUM_LIT:4>], set())<EOL>param.add(r[<NUM_LIT:5>])<EOL>role['<STR_LIT>'].add(r[<NUM_LIT:6>])<EOL><DEDENT>return six.itervalues(roles)<EOL>", "docstring": "Get roles connected to an action.", "id": "f5860:m1"}
{"signature": "def get(*args, **kwargs):", "body": "from invenio.modules.oauthclient.models import RemoteAccount<EOL>q = RemoteAccount.query<EOL>return q.count(), q.all()<EOL>", "docstring": "Get users.", "id": "f5861:m0"}
{"signature": "def get(query, from_date, limit=<NUM_LIT:0>, **kwargs):", "body": "dep_generator = _get_depositions()<EOL>total_depids = <NUM_LIT:1>  <EOL>if limit > <NUM_LIT:0>:<EOL><INDENT>dep_generator = islice(dep_generator, limit)<EOL>total_depids = limit<EOL><DEDENT>return total_depids, dep_generator<EOL>", "docstring": "Get deposits.", "id": "f5862:m3"}
{"signature": "def _get_depositions(user=None, type=None):", "body": "from invenio.modules.workflows.models import BibWorkflowObject, Workflow<EOL>from invenio.modules.deposit.models import InvalidDepositionType<EOL>from flask import current_app<EOL>from invenio.ext.sqlalchemy import db<EOL>from invenio.modules.deposit.models import Deposition<EOL>params = [<EOL>Workflow.module_name == '<STR_LIT>',<EOL>]<EOL>if user:<EOL><INDENT>params.append(BibWorkflowObject.id_user == user.get_id())<EOL><DEDENT>else:<EOL><INDENT>params.append(BibWorkflowObject.id_user != <NUM_LIT:0>)<EOL><DEDENT>if type:<EOL><INDENT>params.append(Workflow.name == type.get_identifier())<EOL><DEDENT>objects = BibWorkflowObject.query.join(\"<STR_LIT>\").options(<EOL>db.contains_eager('<STR_LIT>')).filter(*params)<EOL>def _create_obj(o):<EOL><INDENT>try:<EOL><INDENT>obj = Deposition(o)<EOL><DEDENT>except InvalidDepositionType as err:<EOL><INDENT>current_app.logger.exception(err)<EOL>return None<EOL><DEDENT>if type is None or obj.type == type:<EOL><INDENT>return obj<EOL><DEDENT>return None<EOL><DEDENT>def mapper_filter(objs):<EOL><INDENT>for o in objs:<EOL><INDENT>o = _create_obj(o)<EOL>if o is not None:<EOL><INDENT>yield o<EOL><DEDENT><DEDENT><DEDENT>return mapper_filter(objects)<EOL>", "docstring": "Get list of depositions (as iterator).\n\n    This is redefined Deposition.get_depositions classmethod without order-by\n    for better performance.", "id": "f5862:m2"}
{"signature": "def default_serializer(o):", "body": "defs = (<EOL>((datetime.date, datetime.time),<EOL>lambda x: x.isoformat(), ),<EOL>((datetime.datetime, ),<EOL>lambda x: dt2utc_timestamp(x), ),<EOL>)<EOL>for types, fun in defs:<EOL><INDENT>if isinstance(o, types):<EOL><INDENT>return fun(o)<EOL><DEDENT><DEDENT>", "docstring": "Default serializer for json.", "id": "f5862:m1"}
{"signature": "def get(*args, **kwargs):", "body": "from invenio.modules.communities.models import Community<EOL>q = Community.query<EOL>return q.count(), q.all()<EOL>", "docstring": "Get communities.", "id": "f5863:m0"}
{"signature": "def get(*args, **kwargs):", "body": "from invenio.modules.oauthclient.models import RemoteToken<EOL>q = RemoteToken.query<EOL>return q.count(), q.all()<EOL>", "docstring": "Get users.", "id": "f5864:m0"}
{"signature": "def get_record_collections(recid):", "body": "try:<EOL><INDENT>from invenio.search_engine import (<EOL>get_all_collections_of_a_record,<EOL>get_restricted_collections_for_recid)<EOL><DEDENT>except ImportError:<EOL><INDENT>from invenio.legacy.search_engine import (<EOL>get_all_collections_of_a_record,<EOL>get_restricted_collections_for_recid)<EOL><DEDENT>collections = {<EOL>'<STR_LIT:all>':<EOL>get_all_collections_of_a_record(recid, recreate_cache_if_needed=False),<EOL>}<EOL>collections['<STR_LIT>'] = dict(<EOL>(coll, _get_collection_restrictions(coll))<EOL>for coll in get_restricted_collections_for_recid(<EOL>recid, recreate_cache_if_needed=False))<EOL>return collections<EOL>", "docstring": "Get all collections the record belong to.", "id": "f5865:m5"}
{"signature": "def dump_record_json(marcxml):", "body": "try:<EOL><INDENT>from invenio.modules.records.api import Record<EOL>d = Record.create(marcxml, '<STR_LIT>')<EOL>return d.dumps(clean=True)<EOL><DEDENT>except ImportError:<EOL><INDENT>from invenio.bibfield import create_record<EOL>d = create_record(marcxml, master_format='<STR_LIT>')<EOL>return d.dumps()<EOL><DEDENT>", "docstring": "Dump JSON of record.", "id": "f5865:m6"}
{"signature": "def _get_modified_recids_invenio2(from_date):", "body": "from invenio.legacy.search_engine import search_pattern<EOL>from invenio.modules.records.models import Record<EOL>date = datetime.datetime.strptime(from_date, '<STR_LIT>')<EOL>return set(<EOL>(x[<NUM_LIT:0>]<EOL>for x in Record.query.filter(Record.modification_date >= date).values(<EOL>Record.id))), search_pattern<EOL>", "docstring": "Get record ids for Invenio 2.", "id": "f5865:m1"}
{"signature": "def get_record_revisions(recid, from_date):", "body": "try:<EOL><INDENT>from invenio.dbquery import run_sql<EOL><DEDENT>except ImportError:<EOL><INDENT>from invenio.legacy.dbquery import run_sql<EOL><DEDENT>return run_sql(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>', (recid, from_date),<EOL>run_on_slave=True)<EOL>", "docstring": "Get record revisions.", "id": "f5865:m4"}
{"signature": "def _get_modified_recids_invenio12(from_date):", "body": "from invenio.search_engine import search_pattern<EOL>from invenio.dbquery import run_sql<EOL>return set((id[<NUM_LIT:0>] for id in run_sql(<EOL>'<STR_LIT>',<EOL>(from_date, ), run_on_slave=True))), search_pattern<EOL>", "docstring": "Get record ids for Invenio 1.", "id": "f5865:m0"}
{"signature": "def get(*args, **kwargs):", "body": "try:<EOL><INDENT>from invenio.modules.accounts.models import UserEXT<EOL><DEDENT>except ImportError:<EOL><INDENT>from invenio_accounts.models import UserEXT<EOL><DEDENT>q = UserEXT.query<EOL>return q.count(), q.all()<EOL>", "docstring": "Get UserEXT objects.", "id": "f5867:m0"}
{"signature": "def collect_things_entry_points():", "body": "things = dict()<EOL>for entry_point in iter_entry_points(group='<STR_LIT>'):<EOL><INDENT>things[entry_point.name] = entry_point.load()<EOL><DEDENT>return things<EOL>", "docstring": "Collect entry points.", "id": "f5869:m1"}
{"signature": "def memoize(func):", "body": "cache = {}<EOL>@wraps(func)<EOL>def wrap(*args, **kwargs):<EOL><INDENT>key = '<STR_LIT>'.format(args, kwargs)<EOL>if key not in cache:<EOL><INDENT>cache[key] = func(*args, **kwargs)<EOL><DEDENT>return cache[key]<EOL><DEDENT>return wrap<EOL>", "docstring": "Cache for heavy function calls.", "id": "f5869:m6"}
{"signature": "def datetime_toutc(dt):", "body": "return dt.replace(tzinfo=tzlocal()).astimezone(tzutc())<EOL>", "docstring": "Convert local datetime to UTC.", "id": "f5869:m3"}
{"signature": "def dump(u, *args, **kwargs):", "body": "return dict(<EOL>id=u.id,<EOL>email=u.email,<EOL>password=u.password,<EOL>password_salt=u.password_salt,<EOL>note=u.note,<EOL>full_name=u.full_name if hasattr(u, '<STR_LIT>') else '<STR_LIT>'.format(<EOL>u.given_names, u.family_name),<EOL>settings=u.settings,<EOL>nickname=u.nickname,<EOL>last_login=dt2iso_or_empty(u.last_login))<EOL>", "docstring": "Dump the users as a list of dictionaries.\n\n    :param u: User to be dumped.\n    :type u: `invenio.modules.accounts.models.User [Invenio2.x]` or namedtuple.\n    :returns: User serialized to dictionary.\n    :rtype: dict", "id": "f5870:m3"}
{"signature": "def step(self, step_name):", "body": "@contextmanager<EOL>def step_context(step_name):<EOL><INDENT>if self.event_receiver.current_case is not None:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>self.event_receiver.begin_case(step_name, self.now_seconds(), self.name)<EOL>try:<EOL><INDENT>yield self.event_receiver<EOL><DEDENT>except:<EOL><INDENT>etype, evalue, tb = sys.exc_info()<EOL>self.event_receiver.error('<STR_LIT>' % [etype, evalue, tb])<EOL>raise<EOL><DEDENT>finally:<EOL><INDENT>self.event_receiver.end_case(step_name, self.now_seconds())<EOL><DEDENT><DEDENT>return step_context(step_name)<EOL>", "docstring": "Start a new step. returns a context manager which allows you to\n        report an error", "id": "f5881:c0:m3"}
{"signature": "def networkdays(from_date, to_date, locale='<STR_LIT>'):", "body": "holidays = locales[locale]<EOL>return workdays.networkdays(from_date, to_date, holidays)<EOL>", "docstring": "Return the net work days according to RH's calendar.", "id": "f5897:m0"}
{"signature": "def listen(self):", "body": "self._sock.listen(<NUM_LIT:1>)<EOL>while self.starting:<EOL><INDENT>try:<EOL><INDENT>sock, ip = self._sock.accept()<EOL>threading.Thread(target=self.handle, args=(sock,)).start()<EOL><DEDENT>except socket.error:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>", "docstring": "Listen on host:port", "id": "f5912:c0:m5"}
{"signature": "def init_logger(self):", "body": "return PJFLogger.init_logger()<EOL>", "docstring": "Init the default logger", "id": "f5912:c0:m7"}
{"signature": "def custom_html(self, filepath):", "body": "try:<EOL><INDENT>response.headers.append(\"<STR_LIT>\", \"<STR_LIT:*>\")<EOL>response.headers.append(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>response.headers.append(\"<STR_LIT:Content-Type>\", \"<STR_LIT>\")<EOL>return static_file(filepath, root=self.config.html)<EOL><DEDENT>except Exception as e:<EOL><INDENT>raise PJFBaseException(e.message if hasattr(e, \"<STR_LIT:message>\") else str(e))<EOL><DEDENT>", "docstring": "Serve custom HTML page", "id": "f5915:c2:m5"}
{"signature": "def shutdown(self, *args):", "body": "try:<EOL><INDENT>self._shutdown()<EOL>if self.process:<EOL><INDENT>self.process.wait()<EOL>self.process.stdout.close()<EOL>self.process.stdin.close()<EOL>self.process.stderr.close()<EOL><DEDENT>self.finished = True<EOL>self.send_testcase('<STR_LIT>', '<STR_LIT:127.0.0.1>', self.config.ports[\"<STR_LIT>\"][\"<STR_LIT>\"])<EOL>self.logger.debug(\"<STR_LIT>\".format(time.strftime(\"<STR_LIT>\")))<EOL><DEDENT>except Exception as e:<EOL><INDENT>raise PJFBaseException(e.message if hasattr(e, \"<STR_LIT:message>\") else str(e))<EOL><DEDENT>", "docstring": "Shutdown the running process and the monitor", "id": "f5917:c0:m1"}
{"signature": "def dup(self):", "body": "return _socketobject(_sock=self._sock)<EOL>", "docstring": "dup() -> socket object\n\n        Return a new socket object connected to the same system resource.", "id": "f5919:c1:m3"}
{"signature": "def getfqdn(name='<STR_LIT>'):", "body": "name = name.strip()<EOL>if not name or name == '<STR_LIT>':<EOL><INDENT>name = gethostname()<EOL><DEDENT>try:<EOL><INDENT>hostname, aliases, ipaddrs = gethostbyaddr(name)<EOL><DEDENT>except error:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>aliases.insert(<NUM_LIT:0>, hostname)<EOL>for name in aliases:<EOL><INDENT>if '<STR_LIT:.>' in name:<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>name = hostname<EOL><DEDENT><DEDENT>return name<EOL>", "docstring": "Get fully qualified domain name from name.\n\n    An empty argument is interpreted as meaning the local host.\n\n    First the hostname returned by gethostbyaddr() is checked, then\n    possibly existing aliases. In case no FQDN is available, hostname\n    from gethostname() is returned.", "id": "f5919:m0"}
{"signature": "def create_connection(address, timeout=_GLOBAL_DEFAULT_TIMEOUT,<EOL>source_address=None):", "body": "host, port = address<EOL>err = None<EOL>for res in getaddrinfo(host, port, <NUM_LIT:0>, SOCK_STREAM):<EOL><INDENT>af, socktype, proto, canonname, sa = res<EOL>sock = None<EOL>try:<EOL><INDENT>sock = socket(af, socktype, proto)<EOL>if timeout is not _GLOBAL_DEFAULT_TIMEOUT:<EOL><INDENT>sock.settimeout(timeout)<EOL><DEDENT>if source_address:<EOL><INDENT>sock.bind(source_address)<EOL><DEDENT>sock.connect(sa)<EOL>return sock<EOL><DEDENT>except error as _:<EOL><INDENT>err = _<EOL>if sock is not None:<EOL><INDENT>sock.close()<EOL><DEDENT><DEDENT><DEDENT>if err is not None:<EOL><INDENT>raise err<EOL><DEDENT>else:<EOL><INDENT>raise error(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Connect to *address* and return the socket object.\n\n    Convenience function.  Connect to *address* (a 2-tuple ``(host,\n    port)``) and return the socket object.  Passing the optional\n    *timeout* parameter will set the timeout on the socket instance\n    before attempting to connect.  If no *timeout* is supplied, the\n    global default timeout setting returned by :func:`getdefaulttimeout`\n    is used.  If *source_address* is set it must be a tuple of (host, port)\n    for the socket to bind as a source address before making the connection.\n    An host of '' or port 0 tells the OS to use the default.", "id": "f5919:m2"}
{"signature": "def _get_random(self, obj_type):", "body": "return self.mutator[obj_type][random.randint(<NUM_LIT:0>, self.config.level)]<EOL>", "docstring": "Get a random mutator from a list of mutators", "id": "f5925:c0:m1"}
{"signature": "def random_action(self, b):", "body": "action = random.choice([<NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:3>, <NUM_LIT:4>, <NUM_LIT:5>, <NUM_LIT:6>, <NUM_LIT:7>, <NUM_LIT:8>, <NUM_LIT:9>, <NUM_LIT:10>])<EOL>if len(b) >= <NUM_LIT:3>:<EOL><INDENT>pos = random.randint(<NUM_LIT:0>, len(b)-<NUM_LIT:2>)<EOL>if action == <NUM_LIT:1>:<EOL><INDENT>rbyte = random.randrange(<NUM_LIT>)<EOL>rn = random.randrange(len(b))<EOL>b[rn] = \"<STR_LIT>\" % rbyte<EOL><DEDENT>elif action == <NUM_LIT:2>:<EOL><INDENT>howmany = random.randint(<NUM_LIT:1>, <NUM_LIT:100>)<EOL>curpos = pos<EOL>for _ in range(<NUM_LIT:0>, howmany):<EOL><INDENT>b.insert(curpos, b[pos])<EOL>pos += <NUM_LIT:1><EOL><DEDENT><DEDENT>elif action == <NUM_LIT:3>:<EOL><INDENT>n = random.choice([<NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:4>])<EOL>for _ in range(<NUM_LIT:0>, n):<EOL><INDENT>if len(b) > pos+<NUM_LIT:1>:<EOL><INDENT>tmp = b[pos]<EOL>b[pos] = b[pos+<NUM_LIT:1>]<EOL>b[pos+<NUM_LIT:1>] = tmp<EOL>pos += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>pos -= <NUM_LIT:2><EOL>tmp = b[pos]<EOL>b[pos] = b[pos+<NUM_LIT:1>]<EOL>b[pos+<NUM_LIT:1>] = tmp<EOL>pos += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>elif action in [<NUM_LIT:4>, <NUM_LIT:5>]:<EOL><INDENT>op = {<EOL><NUM_LIT:4>: lambda x, y: ord(x) << y,<EOL><NUM_LIT:5>: lambda x, y: ord(x) >> y,<EOL>}<EOL>n = random.choice([<NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:4>])<EOL>if len(b) < pos+n:<EOL><INDENT>pos = len(b) - (pos+n)<EOL><DEDENT>if n == <NUM_LIT:1>:<EOL><INDENT>f = \"<STR_LIT>\"<EOL>s = op[action](b[pos], n) % <NUM_LIT><EOL><DEDENT>elif n == <NUM_LIT:2>:<EOL><INDENT>f = \"<STR_LIT>\"<EOL>s = op[action](b[pos], n) % <NUM_LIT><EOL><DEDENT>elif n == <NUM_LIT:4>:<EOL><INDENT>f = \"<STR_LIT>\"<EOL>s = op[action](b[pos], n) % <NUM_LIT><EOL><DEDENT>val = struct.pack(f, s)<EOL>for v in val:<EOL><INDENT>if isinstance(v, int):<EOL><INDENT>v = chr(v)<EOL><DEDENT>b[pos] = v<EOL>pos += <NUM_LIT:1><EOL><DEDENT><DEDENT>elif action == <NUM_LIT:6>:<EOL><INDENT>b.insert(random.randint(<NUM_LIT:0>, len(b)-<NUM_LIT:1>), random.choice([\"<STR_LIT>\", \"<STR_LIT:[>\", \"<STR_LIT:]>\", \"<STR_LIT:+>\", \"<STR_LIT:->\", \"<STR_LIT:}>\", \"<STR_LIT:{>\"]))<EOL><DEDENT>elif action == <NUM_LIT:7>:<EOL><INDENT>del b[random.randint(<NUM_LIT:0>, len(b)-<NUM_LIT:1>)]<EOL><DEDENT>elif action in [<NUM_LIT:8>, <NUM_LIT:9>]:<EOL><INDENT>block = random.choice([<EOL>(r\"<STR_LIT>\", r\"<STR_LIT>\"),<EOL>(r\"<STR_LIT>\", r\"<STR_LIT>\"),<EOL>(r\"<STR_LIT>\", r\"<STR_LIT>\")<EOL>])<EOL>b_str = self.safe_join(b)<EOL>block_re = re.compile(str(\"<STR_LIT>\").format(block[<NUM_LIT:0>], block[<NUM_LIT:1>], block[<NUM_LIT:0>], block[<NUM_LIT:1>]))<EOL>if block_re.search(b_str):<EOL><INDENT>r = random.choice(block_re.findall(b_str))<EOL>random_re = re.compile(\"<STR_LIT>\".format(re.escape(r)))<EOL>if random_re.search(b_str):<EOL><INDENT>if action == <NUM_LIT:8>:<EOL><INDENT>newarr = list(random_re.sub(\"<STR_LIT>\", b_str))<EOL>b[:] = newarr<EOL><DEDENT>else:<EOL><INDENT>newarr = list(random_re.sub(\"<STR_LIT>\" * random.randint(<NUM_LIT:1>, <NUM_LIT:10>), b_str, <NUM_LIT:1>))<EOL>b[:] = newarr<EOL><DEDENT><DEDENT><DEDENT><DEDENT>elif action == <NUM_LIT:10>:<EOL><INDENT>b_str = self.safe_join(b)<EOL>limit_choice = random.choice([<EOL><NUM_LIT>,<EOL>-<NUM_LIT>,<EOL><NUM_LIT>,<EOL>-<NUM_LIT>,<EOL>])<EOL>block_re = re.compile(\"<STR_LIT>\")<EOL>if block_re.search(b_str):<EOL><INDENT>block = random.choice([m for m in block_re.finditer(b_str)])<EOL>new = b_str[<NUM_LIT:0>:block.start()] + str(int(block.group())*limit_choice) + b_str[block.start() +<EOL>len(block.group()):]<EOL>b[:] = list(new)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Perform the actual fuzzing using random strategies", "id": "f5925:c0:m5"}
{"signature": "def start(self):", "body": "from .pjf_worker import PJFWorker<EOL>worker = PJFWorker(self)<EOL>if self.update_pjf:<EOL><INDENT>worker.update_library()<EOL><DEDENT>elif self.browser_auto:<EOL><INDENT>worker.browser_autopwn()<EOL><DEDENT>elif self.fuzz_web:<EOL><INDENT>worker.web_fuzzer()<EOL><DEDENT>elif self.json:<EOL><INDENT>if not self.web_server and not self.ext_fuzz and not self.cmd_fuzz:<EOL><INDENT>worker.fuzz()<EOL><DEDENT>elif self.ext_fuzz:<EOL><INDENT>if self.stdin:<EOL><INDENT>worker.fuzz_stdin()<EOL><DEDENT>else:<EOL><INDENT>worker.fuzz_command_line()<EOL><DEDENT><DEDENT>elif self.cmd_fuzz:<EOL><INDENT>if self.stdin:<EOL><INDENT>worker.fuzz_external(True)<EOL><DEDENT>else:<EOL><INDENT>worker.fuzz_external()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>worker.start_http_server()<EOL><DEDENT><DEDENT>elif self.json_file:<EOL><INDENT>worker.start_file_fuzz()<EOL><DEDENT>elif self.process_to_monitor:<EOL><INDENT>worker.start_process_monitor()<EOL><DEDENT>", "docstring": "Parse the command line and start PyJFuzz", "id": "f5926:c0:m3"}
{"signature": "def __eq__(self, other):", "body": "return self.json == other<EOL>", "docstring": "Check if two object are equal", "id": "f5931:c0:m3"}
{"signature": "def __add__(self, other):", "body": "self.json.update(other)<EOL>return self<EOL>", "docstring": "Add keys to dictionary merging with another dictionary object", "id": "f5931:c0:m1"}
{"signature": "@property<EOL><INDENT>def fuzzed(self):<DEDENT>", "body": "try:<EOL><INDENT>if self.config.strong_fuzz:<EOL><INDENT>fuzzer = PJFMutators(self.config)<EOL>if self.config.url_encode:<EOL><INDENT>if sys.version_info >= (<NUM_LIT:3>, <NUM_LIT:0>):<EOL><INDENT>return urllib.parse.quote(fuzzer.fuzz(json.dumps(self.config.json)))<EOL><DEDENT>else:<EOL><INDENT>return urllib.quote(fuzzer.fuzz(json.dumps(self.config.json)))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if type(self.config.json) in [list, dict]:<EOL><INDENT>return fuzzer.fuzz(json.dumps(self.config.json))<EOL><DEDENT>else:<EOL><INDENT>return fuzzer.fuzz(self.config.json)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if self.config.url_encode:<EOL><INDENT>if sys.version_info >= (<NUM_LIT:3>, <NUM_LIT:0>):<EOL><INDENT>return urllib.parse.quote(self.get_fuzzed(self.config.indent, self.config.utf8))<EOL><DEDENT>else:<EOL><INDENT>return urllib.quote(self.get_fuzzed(self.config.indent, self.config.utf8))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return self.get_fuzzed(self.config.indent, self.config.utf8)<EOL><DEDENT><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>raise PJFBaseException(e.message if hasattr(e, \"<STR_LIT:message>\") else str(e))<EOL><DEDENT>", "docstring": "Get a printable fuzzed object", "id": "f5931:c0:m10"}
{"signature": "def init_logger(self):", "body": "return PJFLogger.init_logger()<EOL>", "docstring": "Init the default logger", "id": "f5931:c0:m9"}
{"signature": "def __init__(self, *values, **kwargs):", "body": "super(Q, self).__init__(*values, **kwargs)<EOL>self.escape = kwargs.setdefault(\"<STR_LIT>\", self.escape)<EOL>self.html_js_escape = kwargs.setdefault(\"<STR_LIT>\", self.html_js_escape)<EOL>self.quote = kwargs.setdefault(\"<STR_LIT>\", self.quote)<EOL>", "docstring": "Create the new ``Quote`` instance\n\n        :param bool escape: Whether or not quoted data should be escaped (default=``False``)\n        :param bool html_js_escape: Whether or not quoted data should be html-javascript escaped (default=``False``)\n        :param str quote: The quote character to be used if ``escape`` and ``html_js_escape`` are ``False``", "id": "f5940:c9:m0"}
{"signature": "def __init__(self, *values, **kwargs):", "body": "<EOL>self.shortest_vals = None<EOL>self.values = list(values)<EOL>if \"<STR_LIT>\" in kwargs and len(values) == <NUM_LIT:0>:<EOL><INDENT>self.values = kwargs[\"<STR_LIT>\"]<EOL><DEDENT>self.rolling = kwargs.setdefault(\"<STR_LIT>\", False)<EOL>", "docstring": "Create a new ``Or`` instance with the provide values\n\n        :param list values: The list of values to choose randomly from", "id": "f5940:c10:m0"}
{"signature": "def __init__(self, refname, **kwargs):", "body": "self.refname = refname<EOL>self.cat = kwargs.setdefault(\"<STR_LIT>\", self.cat)<EOL>self.failsafe = kwargs.setdefault(\"<STR_LIT>\", self.failsafe)<EOL>self.fuzzer = GramFuzzer.instance()<EOL>", "docstring": "Create a new ``Ref`` instance\n\n        :param str refname: The name of the rule to reference\n        :param str cat: The name of the category the rule is defined in", "id": "f5940:c13:m0"}
{"signature": "def __init__(self, value=None, **kwargs):", "body": "super(String, self).__init__(value, **kwargs)<EOL>self.charset = kwargs.setdefault(\"<STR_LIT>\", self.charset)<EOL>", "docstring": "Create a new instance of the ``String`` field.\n\n        :param value: The hard-coded value of the String field\n        :param int min: The minimum size of the String when built\n        :param int max: The maximum size of the String when built\n        :param str charset: The character-set to be used when building the string", "id": "f5940:c6:m0"}
{"signature": "def __init__(self, name, *values, **options):", "body": "self.name = name<EOL>self.options = options<EOL>self.values = list(values)<EOL>self.sep = self.options.setdefault(\"<STR_LIT>\", self.sep)<EOL>self.cat = self.options.setdefault(\"<STR_LIT>\", self.cat)<EOL>self.no_prune = self.options.setdefault(\"<STR_LIT>\", self.no_prune)<EOL>self.fuzzer = GramFuzzer.instance()<EOL>frame,mod_path,_,_,_,_ = inspect.stack()[<NUM_LIT:1>]<EOL>module_name = os.path.basename(mod_path).replace(\"<STR_LIT>\", \"<STR_LIT>\").replace(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>if \"<STR_LIT>\" in frame.f_locals:<EOL><INDENT>self.fuzzer.cat_group_defaults[module_name] = frame.f_locals[\"<STR_LIT>\"]<EOL><DEDENT>self.fuzzer.add_definition(self.cat, self.name, self, no_prune=self.no_prune, gram_file=module_name)<EOL>", "docstring": "Create a new rule definition. Simply instantiating a new rule definition\n        will add it to the current ``GramFuzzer`` instance.\n\n        :param str name: The name of the rule being defined\n        :param list values: The list of values that define the value of the rule\n            (will be concatenated when built)\n        :param str cat: The category to create the rule in (default=``\"default\"``).\n        :param bool no_prune: If this rule should not be pruned *EVEN IF* it is found to be\n            unreachable (default=``False``)", "id": "f5940:c12:m0"}
{"signature": "def data(length, charset):", "body": "return \"<STR_LIT>\".join(_choice(charset) for x in range(length))<EOL>", "docstring": "Generate ``length`` random characters from charset ``charset``\n\n    :param int length: The number of characters to randomly generate\n    :param str charset: The charset of characters to choose from\n    :returns: str", "id": "f5941:m4"}
{"signature": "def set_max_recursion(self, level):", "body": "import gramfuzz.fields<EOL>gramfuzz.fields.Ref.max_recursion = level<EOL>", "docstring": "Set the maximum reference-recursion depth (not the Python system maximum stack\n        recursion level). This controls how many levels deep of nested references are allowed\n        before gramfuzz attempts to generate the shortest (reference-wise) rules possible.\n\n        :param int level: The new maximum reference level", "id": "f5942:c0:m3"}
{"signature": "def ceiling_division(numerator, denominator):", "body": "<EOL>return -(-numerator // denominator)<EOL>", "docstring": "Divide and round up", "id": "f5945:m3"}
{"signature": "@contextmanager<EOL>def working_directory(path):", "body": "prev_dir = os.getcwd()<EOL>os.chdir(str(path))<EOL>try:<EOL><INDENT>yield<EOL><DEDENT>finally:<EOL><INDENT>os.chdir(prev_dir)<EOL><DEDENT>", "docstring": "Change working directory and restore the previous on exit", "id": "f5945:m0"}
{"signature": "def get_type_for_extra_dim(type_index):", "body": "try:<EOL><INDENT>return _extra_dims_style_1[type_index]<EOL><DEDENT>except IndexError:<EOL><INDENT>raise errors.UnknownExtraType(type_index)<EOL><DEDENT>", "docstring": "Returns the type str ('u1\" or \"u2\", etc) for the given type index\n    Parameters\n    ----------\n    type_index: int\n        index of the type as defined in the LAS Specification\n\n    Returns\n    -------\n    str,\n        a string representing the type, can be understood by numpy", "id": "f5972:m1"}
{"signature": "def __setattr__(self, key, value):", "body": "if key in dims.DIMENSIONS or key in self.points_data.all_dimensions_names:<EOL><INDENT>self.points_data[key] = value<EOL><DEDENT>else:<EOL><INDENT>super().__setattr__(key, value)<EOL><DEDENT>", "docstring": "This is called on every access to an attribute of the instance.\n        Again we use this to forward the call the the points record\n\n        But this time checking if the key is actually a dimension name\n        so that an error is raised if the user tries to set a valid\n        LAS dimension even if it is not present in the field.\n        eg: user tries to set the red field of a file with point format 0:\n        an error is raised", "id": "f5974:c0:m11"}
{"signature": "def write_to_file(self, filename, do_compress=None):", "body": "is_ext_laz = filename.split(\"<STR_LIT:.>\")[-<NUM_LIT:1>] == \"<STR_LIT>\"<EOL>if is_ext_laz and do_compress is None:<EOL><INDENT>do_compress = True<EOL><DEDENT>with open(filename, mode=\"<STR_LIT:wb>\") as out:<EOL><INDENT>self.write_to(out, do_compress=do_compress)<EOL><DEDENT>", "docstring": "Writes the las data into a file\n\n        Parameters\n        ----------\n        filename : str\n            The file where the data should be written.\n        do_compress: bool, optional, default None\n            if None the extension of the filename will be used\n            to determine if the data should be compressed\n            otherwise the do_compress flag indicate if the data should be compressed", "id": "f5974:c0:m18"}
{"signature": "def __getattr__(self, item):", "body": "return self.points_data[item]<EOL>", "docstring": "Automatically called by Python when the attribute\n        named 'item' is no found. We use this function to forward the call the\n        point record. This is the mechanism used to allow the users to access\n        the points dimensions directly through a LasData.\n\n        Parameters\n        ----------\n        item: str\n            name of the attribute, should be a dimension name\n\n        Returns\n        -------\n        The requested dimension if it exists", "id": "f5974:c0:m10"}
{"signature": "@property<EOL><INDENT>def points(self):<DEDENT>", "body": "return self.points_data.array<EOL>", "docstring": "returns the numpy array representing the points\n\n        Returns\n        -------\n        the Numpy structured array of points", "id": "f5974:c0:m8"}
{"signature": "@property<EOL><INDENT>def x(self):<DEDENT>", "body": "return scale_dimension(self.X, self.header.x_scale, self.header.x_offset)<EOL>", "docstring": "Returns the scaled x positions of the points as doubles", "id": "f5974:c0:m1"}
{"signature": "def _raise_if_wrong_file_signature(stream):", "body": "file_sig = stream.read(len(headers.LAS_FILE_SIGNATURE))<EOL>if file_sig != headers.LAS_FILE_SIGNATURE:<EOL><INDENT>raise errors.PylasError(<EOL>\"<STR_LIT>\".format(file_sig, headers.LAS_FILE_SIGNATURE)<EOL>)<EOL><DEDENT>", "docstring": "Reads the 4 first bytes of the stream to check that is LASF", "id": "f5976:m0"}
{"signature": "def read_vlrs(self):", "body": "self.stream.seek(self.start_pos + self.header.size)<EOL>return VLRList.read_from(self.stream, num_to_read=self.header.number_of_vlr)<EOL>", "docstring": "Reads and return the vlrs of the file", "id": "f5976:c0:m2"}
{"signature": "def read(self):", "body": "vlrs = self.read_vlrs()<EOL>self._warn_if_not_at_expected_pos(<EOL>self.header.offset_to_point_data, \"<STR_LIT>\", \"<STR_LIT>\"<EOL>)<EOL>self.stream.seek(self.start_pos + self.header.offset_to_point_data)<EOL>try:<EOL><INDENT>points = self._read_points(vlrs)<EOL><DEDENT>except (RuntimeError, errors.LazPerfNotFound) as e:<EOL><INDENT>logger.error(\"<STR_LIT>\".format(e))<EOL>self.stream.seek(self.start_pos)<EOL>self.__init__(io.BytesIO(laszip_decompress(self.stream)))<EOL>return self.read()<EOL><DEDENT>if points.point_format.has_waveform_packet:<EOL><INDENT>self.stream.seek(<EOL>self.start_pos + self.header.start_of_waveform_data_packet_record<EOL>)<EOL>if self.header.global_encoding.are_waveform_flag_equal():<EOL><INDENT>raise errors.PylasError(<EOL>\"<STR_LIT>\".format(<EOL>\"<STR_LIT>\"<EOL>if self.header.global_encoding.waveform_internal<EOL>else \"<STR_LIT>\"<EOL>)<EOL>)<EOL><DEDENT>if self.header.global_encoding.waveform_internal:<EOL><INDENT>_, _ = self._read_internal_waveform_packet()<EOL><DEDENT>elif self.header.global_encoding.waveform_external:<EOL><INDENT>logger.info(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT><DEDENT>if self.header.version >= \"<STR_LIT>\":<EOL><INDENT>evlrs = self.read_evlrs()<EOL>return las14.LasData(<EOL>header=self.header, vlrs=vlrs, points=points, evlrs=evlrs<EOL>)<EOL><DEDENT>return las12.LasData(header=self.header, vlrs=vlrs, points=points)<EOL>", "docstring": "Reads the whole las data (header, vlrs ,points, etc) and returns a LasData\n        object", "id": "f5976:c0:m3"}
{"signature": "@classmethod<EOL><INDENT>def empty(cls, point_format):<DEDENT>", "body": "return cls.zeros(point_format, point_count=<NUM_LIT:0>)<EOL>", "docstring": "Creates an empty point record.\n\n        Parameters\n        ----------\n        point_format: pylas.PointFormat\n            The point format id the point record should have\n\n        Returns\n        -------\n        PackedPointRecord", "id": "f5977:c2:m4"}
{"signature": "@property<EOL><INDENT>def point_size(self):<DEDENT>", "body": "return self.array.dtype.itemsize<EOL>", "docstring": "Returns the point size in bytes taken by each points of the record\n\n        Returns\n        -------\n        int\n            The point size in byte", "id": "f5977:c2:m2"}
{"signature": "@property<EOL><INDENT>def extra_dimension_names(self):<DEDENT>", "body": "return [extd[<NUM_LIT:0>] for extd in self.extra_dims]<EOL>", "docstring": "Returns the list of extra dimensions attached to this point format", "id": "f5980:c0:m6"}
{"signature": "def __init__(self, point_format_id, extra_dims=None):", "body": "self.id = point_format_id<EOL>if extra_dims is None:<EOL><INDENT>extra_dims = []<EOL><DEDENT>self.extra_dims = extra_dims<EOL>", "docstring": "Parameters\n----------\npoint_format_id: int\n    point format id\nextra_dims: list of tuple\n    [(name, type_str), ..] of extra dimensions attached to this point format", "id": "f5980:c0:m0"}
{"signature": "@property<EOL><INDENT>def composed_fields(self):<DEDENT>", "body": "return self._access_dict(dims.COMPOSED_FIELDS, self.id)<EOL>", "docstring": "Returns the dict of composed fields defined for the point format\n\n        Returns\n        -------\n        Dict[str, List[SubFields]]\n            maps a composed field name to its sub_fields", "id": "f5980:c0:m4"}
{"signature": "@mins.setter<EOL><INDENT>def mins(self, value):<DEDENT>", "body": "self.x_min, self.y_min, self.z_min = value<EOL>", "docstring": "Sets de minimum values of x, y, z as a numpy array", "id": "f5984:c2:m17"}
{"signature": "@point_format_id.setter<EOL><INDENT>def point_format_id(self, value):<DEDENT>", "body": "self._point_data_format_id = value<EOL>", "docstring": "Returns the point format id of the points", "id": "f5984:c2:m10"}
{"signature": "@property<EOL><INDENT>def date(self):<DEDENT>", "body": "try:<EOL><INDENT>return datetime.date(self.creation_year, <NUM_LIT:1>, <NUM_LIT:1>) + datetime.timedelta(<EOL>self.creation_day_of_year - <NUM_LIT:1><EOL>)<EOL><DEDENT>except ValueError:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Returns the creation date stored in the las file\n\n        Returns\n        -------\n        datetime.date", "id": "f5984:c2:m7"}
{"signature": "@property<EOL><INDENT>def mins(self):<DEDENT>", "body": "return np.array([self.x_min, self.y_min, self.z_min])<EOL>", "docstring": "Returns de minimum values of x, y, z as a numpy array", "id": "f5984:c2:m16"}
{"signature": "def files_have_same_dtype(las_files):", "body": "dtypes = {las.points.dtype for las in las_files}<EOL>return len(dtypes) == <NUM_LIT:1><EOL>", "docstring": "Returns true if all the files have the same numpy datatype", "id": "f5986:m2"}
{"signature": "@staticmethod<EOL><INDENT>@abstractmethod<EOL>def official_record_ids():<DEDENT>", "body": "pass<EOL>", "docstring": "Shall return the official record_id for the VLR\n\n        .. note::\n\n            Even if the VLR has one record_id, the return type must be a tuple\n\n        Returns\n        -------\n        tuple of int\n            The record_ids this VLR type can have", "id": "f5988:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>@abstractmethod<EOL>def official_user_id():<DEDENT>", "body": "pass<EOL>", "docstring": "Shall return the official user_id as described in the documentation", "id": "f5988:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def read_from(cls, data_stream, num_to_read):<DEDENT>", "body": "vlrlist = cls()<EOL>for _ in range(num_to_read):<EOL><INDENT>raw = RawVLR.read_from(data_stream)<EOL>try:<EOL><INDENT>vlrlist.append(vlr_factory(raw))<EOL><DEDENT>except UnicodeDecodeError:<EOL><INDENT>logger.error(\"<STR_LIT>\".format(raw))<EOL><DEDENT><DEDENT>return vlrlist<EOL>", "docstring": "Reads vlrs and parse them if possible from the stream\n\n        Parameters\n        ----------\n        data_stream : io.BytesIO\n                      stream to read from\n        num_to_read : int\n                      number of vlrs to be read\n\n        Returns\n        -------\n        pylas.vlrs.vlrlist.VLRList\n            List of vlrs", "id": "f5991:c1:m13"}
{"signature": "def append(self, vlr):", "body": "self.vlrs.append(vlr)<EOL>", "docstring": "append a vlr to the list\n\n        Parameters\n        ----------\n        vlr: RawVlR or VLR or KnownVlr\n\n        Returns\n        -------", "id": "f5991:c1:m1"}
{"signature": "def delete(self, resource_id):", "body": "self.logger.debug('<STR_LIT>'.format(resource_id))<EOL>if self.driver._es.exists(<EOL>index=self.driver._index,<EOL>id=resource_id,<EOL>doc_type='<STR_LIT>'<EOL>) == False:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(resource_id))<EOL><DEDENT>return self.driver._es.delete(<EOL>index=self.driver._index,<EOL>id=resource_id,<EOL>doc_type='<STR_LIT>'<EOL>)<EOL>", "docstring": "Delete an object from elasticsearch.\n        :param resource_id: id of the object to be deleted.\n        :return:", "id": "f6004:c0:m5"}
{"signature": "def update(self, obj, resource_id):", "body": "self.logger.debug('<STR_LIT>'.format(resource_id))<EOL>return self.driver._es.index(<EOL>index=self.driver._index,<EOL>id=resource_id,<EOL>body=obj,<EOL>doc_type='<STR_LIT>',<EOL>refresh='<STR_LIT>'<EOL>)['<STR_LIT>']<EOL>", "docstring": "Update object in elasticsearch using the resource_id.\n        :param metadata: new metadata for the transaction.\n        :param resource_id: id of the object to be updated.\n        :return: id of the object.", "id": "f6004:c0:m4"}
{"signature": "def query(self, search_model: QueryModel):", "body": "query_parsed = query_parser(search_model.query)<EOL>self.logger.debug(f'<STR_LIT>')<EOL>if search_model.sort is not None:<EOL><INDENT>self._mapping_to_sort(search_model.sort.keys())<EOL>sort = self._sort_object(search_model.sort)<EOL><DEDENT>else:<EOL><INDENT>sort = [{\"<STR_LIT>\": \"<STR_LIT>\"}]<EOL><DEDENT>if search_model.query == {}:<EOL><INDENT>query = {'<STR_LIT>': {}}<EOL><DEDENT>else:<EOL><INDENT>query = query_parsed[<NUM_LIT:0>]<EOL><DEDENT>body = {<EOL>'<STR_LIT>': query,<EOL>'<STR_LIT>': sort,<EOL>'<STR_LIT>': (search_model.page - <NUM_LIT:1>) * search_model.offset,<EOL>'<STR_LIT:size>': search_model.offset,<EOL>}<EOL>page = self.driver._es.search(<EOL>index=self.driver._index,<EOL>doc_type='<STR_LIT>',<EOL>body=body,<EOL>q=query_parsed[<NUM_LIT:1>]<EOL>)<EOL>object_list = []<EOL>for x in page['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>object_list.append(x['<STR_LIT>'])<EOL><DEDENT>return object_list<EOL>", "docstring": "Query elasticsearch for objects.\n        :param search_model: object of QueryModel.\n        :return: list of objects that match the query.", "id": "f6004:c0:m7"}
{"signature": "@property<EOL><INDENT>def type(self):<DEDENT>", "body": "return '<STR_LIT>'<EOL>", "docstring": "str: the type of this plugin (``'Elasticsearch'``)", "id": "f6004:c0:m1"}
{"signature": "def text_query(self, search_model: FullTextModel):", "body": "self.logger.debug('<STR_LIT>'.format(search_model.text))<EOL>if search_model.sort is not None:<EOL><INDENT>self._mapping_to_sort(search_model.sort.keys())<EOL>sort = self._sort_object(search_model.sort)<EOL><DEDENT>else:<EOL><INDENT>sort = [{\"<STR_LIT>\": \"<STR_LIT>\"}]<EOL><DEDENT>body = {<EOL>'<STR_LIT>': sort,<EOL>'<STR_LIT>': (search_model.page - <NUM_LIT:1>) * search_model.offset,<EOL>'<STR_LIT:size>': search_model.offset,<EOL>}<EOL>page = self.driver._es.search(<EOL>index=self.driver._index,<EOL>doc_type='<STR_LIT>',<EOL>body=body,<EOL>q=search_model.text<EOL>)<EOL>object_list = []<EOL>for x in page['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>object_list.append(x['<STR_LIT>'])<EOL><DEDENT>return object_list<EOL>", "docstring": "Query elasticsearch for objects.\n        :param search_model: object of FullTextModel\n        :return: list of objects that match the query.", "id": "f6004:c0:m8"}
{"signature": "def read(self, resource_id):", "body": "self.logger.debug('<STR_LIT>'.format(resource_id))<EOL>return self.driver._es.get(<EOL>index=self.driver._index,<EOL>id=resource_id,<EOL>doc_type='<STR_LIT>'<EOL>)['<STR_LIT>']<EOL>", "docstring": "Read object in elasticsearch using the resource_id.\n        :param resource_id: id of the object to be read.\n        :return: object value from elasticsearch.", "id": "f6004:c0:m3"}
{"signature": "def reduceCnf(cnf):", "body": "output = Cnf()<EOL>for x in cnf.dis:<EOL><INDENT>dont_add = False<EOL>for y in x:<EOL><INDENT>for z in x:<EOL><INDENT>if z == -y:<EOL><INDENT>dont_add = True<EOL>break<EOL><DEDENT><DEDENT>if dont_add: break<EOL><DEDENT>if dont_add: continue<EOL>if x not in output.dis:<EOL><INDENT>output.dis |= frozenset([x])<EOL><DEDENT><DEDENT>return output<EOL>", "docstring": "I just found a remarkably large bug in my SAT solver and found an\ninteresting solution.\nRemove all b | -b\n(-b | b) & (b | -a) & (-b | a) & (a | -a)\nbecomes\n(b | -a) & (-b | a)\n\nRemove all (-e) & (-e)\n(-e | a) & (-e | a) & (-e | a) & (-e | a)\nbecomes\n(-e | a)\n(-b | b | c) becomes nothing, not (c)", "id": "f6009:m0"}
{"signature": "def Bin(self):", "body": "err = _Bin(self.transit, self.limbdark, self.settings, self.arrays)<EOL>if err != _ERR_NONE: RaiseError(err)<EOL>", "docstring": "Bins the light curve model to the provided time array", "id": "f6024:c4:m4"}
{"signature": "@property<EOL><INDENT>def duration(self):<DEDENT>", "body": "ecc = self.ecc if not np.isnan(self.ecc) else np.sqrt(self.ecw**<NUM_LIT:2> + self.esw**<NUM_LIT:2>)<EOL>esw = self.esw if not np.isnan(self.esw) else ecc * np.sin(self.w)<EOL>aRs = ((G * self.rhos * (<NUM_LIT:1.> + self.MpMs) * <EOL>(self.per * DAYSEC)**<NUM_LIT>) / (<NUM_LIT> * np.pi))**(<NUM_LIT:1.>/<NUM_LIT>)<EOL>inc = np.arccos(self.bcirc/aRs)<EOL>becc = self.bcirc * (<NUM_LIT:1> - ecc**<NUM_LIT:2>)/(<NUM_LIT:1> - esw)<EOL>tdur = self.per / <NUM_LIT> / np.pi * np.arcsin(((<NUM_LIT:1.> + self.RpRs)**<NUM_LIT:2> -<EOL>becc**<NUM_LIT:2>)**<NUM_LIT:0.5> / (np.sin(inc) * aRs))<EOL>tdur *= np.sqrt(<NUM_LIT:1.> - ecc**<NUM_LIT>)/(<NUM_LIT:1.> - esw)<EOL>return tdur<EOL>", "docstring": "The approximate transit duration for the general case of an eccentric orbit", "id": "f6024:c0:m4"}
{"signature": "def __del__(self):", "body": "self.Free()<EOL>", "docstring": "Free the C arrays when the last reference to the class goes out of scope!", "id": "f6024:c4:m6"}
{"signature": "def Free(self):", "body": "if self.arrays._calloc:<EOL><INDENT>_dbl_free(self.arrays._time)<EOL>_dbl_free(self.arrays._flux)<EOL>_dbl_free(self.arrays._bflx)<EOL>_dbl_free(self.arrays._M)<EOL>_dbl_free(self.arrays._E)<EOL>_dbl_free(self.arrays._f)<EOL>_dbl_free(self.arrays._r)<EOL>_dbl_free(self.arrays._x)<EOL>_dbl_free(self.arrays._y)<EOL>_dbl_free(self.arrays._z)<EOL>self.arrays._calloc = <NUM_LIT:0><EOL><DEDENT>if self.arrays._balloc:  <EOL><INDENT>_dbl_free(self.arrays._b)<EOL>self.arrays._balloc = <NUM_LIT:0><EOL><DEDENT>if self.arrays._ialloc:<EOL><INDENT>_dbl_free(self.arrays._iarr)<EOL>self.arrays._ialloc = <NUM_LIT:0><EOL><DEDENT>", "docstring": "Frees the memory used by all of the dynamically allocated C arrays.", "id": "f6024:c4:m5"}
{"signature": "def create_validator(data_struct_dict, name=None):", "body": "if name is None:<EOL><INDENT>name = '<STR_LIT>'<EOL><DEDENT>attrs = {}<EOL>for field_name, field_info in six.iteritems(data_struct_dict):<EOL><INDENT>field_type = field_info['<STR_LIT:type>']<EOL>if field_type == DictField.FIELD_TYPE_NAME and isinstance(field_info.get('<STR_LIT>'), dict):<EOL><INDENT>field_info['<STR_LIT>'] = create_validator(field_info['<STR_LIT>'])<EOL><DEDENT>attrs[field_name] = create_field(field_info)<EOL><DEDENT>name = force_str(name)<EOL>return type(name, (Validator, ), attrs)<EOL>", "docstring": "create a Validator instance from data_struct_dict\n\n:param data_struct_dict: a dict describe validator's fields, like the dict `to_dict()` method returned.\n:param name: name of Validator class \n\n:return: Validator instance", "id": "f6048:m0"}
{"signature": "def __init__(self, raw_data):", "body": "assert isinstance(raw_data, dict), '<STR_LIT>'.format(type(raw_data).__name__)<EOL>self.raw_data = raw_data<EOL>self.validated_data = None<EOL>self.errors = {}<EOL>", "docstring": ":param raw_data: unvalidate data", "id": "f6048:c1:m0"}
{"signature": "@classmethod<EOL><INDENT>def to_dict(cls):<DEDENT>", "body": "d = dict()<EOL>for name, field in six.iteritems(cls._FIELDS_MAP):<EOL><INDENT>field_info = field.to_dict()<EOL>d[name] = field_info<EOL><DEDENT>return d<EOL>", "docstring": "format Validator to dict", "id": "f6048:c1:m5"}
{"signature": "def validate(self, data):", "body": "return data<EOL>", "docstring": "model-level validate.\nsub-class can override this method to validate data, return modified data", "id": "f6048:c1:m3"}
{"signature": "@classmethod<EOL><INDENT>def _get_all_params(cls):<DEDENT>", "body": "params = list(cls.PARAMS)<EOL>bases = cls.__bases__<EOL>for base in bases:<EOL><INDENT>if issubclass(base, BaseField):<EOL><INDENT>params.extend(base._get_all_params())<EOL><DEDENT><DEDENT>return params<EOL>", "docstring": "Collect all PARAMS from this class and its parent class.", "id": "f6050:c2:m4"}
{"signature": "def validate(self, value):", "body": "value = self._validate(value)<EOL>for v in self.validators:<EOL><INDENT>v(value)<EOL><DEDENT>return value<EOL>", "docstring": "return validated value or raise FieldValidationError.", "id": "f6050:c2:m5"}
{"signature": "def to_service(self, service, version):", "body": "service_url = self._service_locator.get_service_url(service, version)<EOL>return self.__copy_and_set('<STR_LIT>', self.__strip_trailing_slashes(service_url))<EOL>", "docstring": "Sets the service name and version the request should target\n\n        Args:\n            service (str): The name of the service as displayed in the services.json file\n            version (str): The version of the service as displayed in the services.json file\n\n        Returns:\n            The request builder instance in order to chain calls", "id": "f6064:c0:m4"}
{"signature": "def delete(self):", "body": "return self.__send('<STR_LIT>')<EOL>", "docstring": "Sends the request as parametrized with the DELETE verb\n\n        Returns:\n            The response object or body depending of the parametrization\n\n        Raises:\n            Any exception parametrized with the `throw` method", "id": "f6064:c0:m18"}
{"signature": "def get(self):", "body": "return self.__send('<STR_LIT:GET>')<EOL>", "docstring": "Sends the request as parametrized with the GET verb\n\n        Returns:\n            The response object or body depending of the parametrization\n\n        Raises:\n            Any exception parametrized with the `throw` method", "id": "f6064:c0:m16"}
{"signature": "def post(self):", "body": "return self.__send('<STR_LIT:POST>')<EOL>", "docstring": "Sends the request as parametrized with the POST verb\n\n        Returns:\n            The response object or body depending of the parametrization\n\n        Raises:\n            Any exception parametrized with the `throw` method", "id": "f6064:c0:m17"}
{"signature": "def put(self):", "body": "return self.__send('<STR_LIT>')<EOL>", "docstring": "Sends the request as parametrized with the PUT verb\n\n        Returns:\n            The response object or body depending of the parametrization\n\n        Raises:\n            Any exception parametrized with the `throw` method", "id": "f6064:c0:m19"}
{"signature": "def to_url(self, url):", "body": "return self.__copy_and_set('<STR_LIT:url>', url)<EOL>", "docstring": "Sets the request target url\n\n        Args:\n            url (str): The url the request should be targeted to\n\n        Returns:\n            The request builder instance in order to chain calls", "id": "f6064:c0:m3"}
{"signature": "def to_endpoint(self, endpoint):", "body": "return self.__copy_and_set('<STR_LIT>', self.__strip_leading_slashes(endpoint))<EOL>", "docstring": "Sets the endpoint of the service the request should target\n\n        Args:\n            endpoint (str): The endpoint that will be concatenated to the service url\n\n        Returns:\n            The request builder instance in order to chain calls", "id": "f6064:c0:m5"}
{"signature": "@classmethod<EOL><INDENT>def new(cls, access_token, environment='<STR_LIT>'):<DEDENT>", "body": "return cls(<EOL>storage_client=StorageClient.new(access_token, environment=environment))<EOL>", "docstring": "Creates a new cross-service client.", "id": "f6066:c0:m1"}
{"signature": "def list(self, path):", "body": "self.__validate_storage_path(path)<EOL>entity = self.api_client.get_entity_by_query(path=path)<EOL>if entity['<STR_LIT>'] not in self.__BROWSABLE_TYPES:<EOL><INDENT>raise StorageArgumentException('<STR_LIT>'<EOL>'<STR_LIT>'.format(entity['<STR_LIT>']))<EOL><DEDENT>entity_uuid = entity['<STR_LIT>']<EOL>file_names = []<EOL>more_pages = True<EOL>page_number = <NUM_LIT:1><EOL>while more_pages:<EOL><INDENT>response = self.api_client.list_folder_content(<EOL>entity_uuid, page=page_number, ordering='<STR_LIT:name>')<EOL>more_pages = response['<STR_LIT>'] is not None<EOL>page_number += <NUM_LIT:1><EOL>for child in response['<STR_LIT>']:<EOL><INDENT>pattern = '<STR_LIT>' if child['<STR_LIT>'] == '<STR_LIT>' else '<STR_LIT>'<EOL>file_names.append(pattern.format(name=child['<STR_LIT:name>']))<EOL><DEDENT><DEDENT>return file_names<EOL>", "docstring": "List the entities found directly under the given path.\n\n        Args:\n            path (str): The path of the entity to be listed. Must start with a '/'.\n\n        Returns:\n            The list of entity names directly under the given path:\n\n                u'/12345/folder_1'\n\n        Raises:\n            StorageArgumentException: Invalid arguments\n            StorageForbiddenException: Server response code 403\n            StorageNotFoundException: Server response code 404\n            StorageException: other 400-600 error codes", "id": "f6068:c0:m2"}
{"signature": "def __init__(self, services_url):", "body": "self.__services_url = services_url<EOL>", "docstring": "Create new service locator\n            Arguments:\n                services_url: The url of the json file where the services url are defined\n            Returns:\n                A service locator instance", "id": "f6070:c0:m0"}
{"signature": "def get_service_url(self, service, version):", "body": "return self.__get_services()[service][version]<EOL>", "docstring": "Get the service URL\n            Arguments:\n                service: The service name\n                version: The service version\n            Returns:\n                The URL where the service is located", "id": "f6070:c0:m2"}
{"signature": "def delete_file(self, file_id):", "body": "if not is_valid_uuid(file_id):<EOL><INDENT>raise StorageArgumentException(<EOL>'<STR_LIT>'.format(file_id))<EOL><DEDENT>self._authenticated_request.to_endpoint('<STR_LIT>'.format(file_id)).delete()<EOL>", "docstring": "Delete a file.\n\n        Args:\n            file_id (str): The UUID of the file to delete.\n\n        Returns:\n            None\n\n        Raises:\n            StorageArgumentException: Invalid arguments\n            StorageForbiddenException: Server response code 403\n            StorageNotFoundException: Server response code 404\n            StorageException: other 400-600 error codes", "id": "f6071:c0:m26"}
{"signature": "def delete_folder(self, folder):", "body": "if not is_valid_uuid(folder):<EOL><INDENT>raise StorageArgumentException(<EOL>'<STR_LIT>'.format(folder))<EOL><DEDENT>self._authenticated_request.to_endpoint('<STR_LIT>'.format(folder)).delete()<EOL>", "docstring": "Delete a folder. It will recursively delete all the content.\n\n        Args:\n            folder_id (str): The UUID of the folder to be deleted.\n\n        Returns:\n            None\n\n        Raises:\n            StorageArgumentException: Invalid arguments\n            StorageForbiddenException: 403\n            StorageNotFoundException: 404\n            HTTPError: other non-20x error codes", "id": "f6071:c0:m19"}
{"signature": "def create_project(self, collab_id):", "body": "return self._authenticated_request.to_endpoint('<STR_LIT>').with_json_body(self._prep_params(locals())).return_body().post()<EOL>", "docstring": "Create a new project.\n\n        Args:\n            collab_id (int): The id of the collab the project should be created in.\n\n        Returns:\n            A dictionary of details of the created project::\n\n                {\n                    u'collab_id': 12998,\n                    u'created_by': u'303447',\n                    u'created_on': u'2017-03-21T14:06:32.293902Z',\n                    u'description': u'',\n                    u'entity_type': u'project',\n                    u'modified_by': u'303447',\n                    u'modified_on': u'2017-03-21T14:06:32.293967Z',\n                    u'name': u'12998',\n                    u'uuid': u'2516442e-1e26-4de1-8ed8-94523224cc40'\n                }\n\n        Raises:\n            StorageForbiddenException: Server response code 403\n            StorageNotFoundException: Server response code 404\n            StorageException: other 400-600 error codes", "id": "f6071:c0:m14"}
{"signature": "def get_entity_collab_id(self, entity_id):", "body": "if not is_valid_uuid(entity_id):<EOL><INDENT>raise StorageArgumentException(<EOL>'<STR_LIT>'.format(entity_id))<EOL><DEDENT>return self._authenticated_request.to_endpoint('<STR_LIT>'.format(entity_id)).return_body().get()[\"<STR_LIT>\"]<EOL>", "docstring": "Retrieve entity Collab ID.\n\n        Args:\n            entity_id (str): The UUID of the requested entity.\n\n        Returns:\n            The id as interger of the Collebaration to which the entity belongs\n\n        Raises:\n            StorageArgumentException: Invalid arguments\n            StorageForbiddenException: Server response code 403\n            StorageNotFoundException: Server response code 404\n            StorageException: other 400-600 error codes", "id": "f6071:c0:m5"}
{"signature": "def download_file_content(self, file_id, etag=None):", "body": "if not is_valid_uuid(file_id):<EOL><INDENT>raise StorageArgumentException(<EOL>'<STR_LIT>'.format(file_id))<EOL><DEDENT>headers = {'<STR_LIT>': '<STR_LIT>'}<EOL>if etag:<EOL><INDENT>headers['<STR_LIT>'] = etag<EOL><DEDENT>resp = self._authenticated_request.to_endpoint('<STR_LIT>'.format(file_id)).with_headers(headers).get()<EOL>if resp.status_code == <NUM_LIT>:<EOL><INDENT>return (None, None)<EOL><DEDENT>if '<STR_LIT>' not in resp.headers:<EOL><INDENT>raise StorageException('<STR_LIT>')<EOL><DEDENT>return (resp.headers['<STR_LIT>'], resp.content)<EOL>", "docstring": "Download file content.\n\n        Args:\n            file_id (str): The UUID of the file whose content is requested\n            etag (str): If the content is not changed since the provided ETag,\n                the content won't be downloaded. If the content is changed, it\n                will be downloaded and returned with its new ETag.\n\n        Note:\n            ETags should be enclosed in double quotes::\n\n                my_etag = '\"71e1ed9ee52e565a56aec66bc648a32c\"'\n\n\n        Returns:\n            A tuple of ETag and content (etag, content) if the content was\n            retrieved. If an etag was provided, and content didn't change\n            returns (None, None)::\n\n                ('\"71e1ed9ee52e565a56aec66bc648a32c\"', 'Hello world!')\n\n        Raises:\n            StorageArgumentException: Invalid arguments\n            StorageForbiddenException: Server response code 403\n            StorageNotFoundException: Server response code 404\n            StorageException: other 400-600 error codes", "id": "f6071:c0:m24"}
{"signature": "@staticmethod<EOL><INDENT>def _prep_params(params):<DEDENT>", "body": "return {k: v for (k, v) in params.items() if v is not None and k != '<STR_LIT>'}<EOL>", "docstring": "Remove empty (None) valued keywords and self from function parameters", "id": "f6071:c0:m2"}
{"signature": "def get_metadata(self, entity_type, entity_id):", "body": "if not is_valid_uuid(entity_id):<EOL><INDENT>raise StorageArgumentException(<EOL>'<STR_LIT>'.format(entity_id))<EOL><DEDENT>return self._authenticated_request.to_endpoint('<STR_LIT>'.format(entity_type, entity_id)).return_body().get()<EOL>", "docstring": "Get metadata of an entity.\n\n        Args:\n            entity_type (str): Type of the entity. Admitted values: ['project',\n                'folder', 'file'].\n            entity_id (str): The UUID of the entity to be modified.\n\n        Returns:\n            A dictionary of the metadata::\n\n                {\n                    u'bar': u'200',\n                    u'foo': u'100'\n                }\n\n        Raises:\n            StorageArgumentException: Invalid arguments\n            StorageForbiddenException: Server response code 403\n            StorageNotFoundException: Server response code 404\n            StorageException: other 400-600 error codes", "id": "f6071:c0:m8"}
{"signature": "def copy_file_content(self, file_id, source_file):", "body": "if not is_valid_uuid(file_id):<EOL><INDENT>raise StorageArgumentException(<EOL>'<STR_LIT>'.format(file_id))<EOL><DEDENT>if not is_valid_uuid(source_file):<EOL><INDENT>raise StorageArgumentException(<EOL>'<STR_LIT>'.format(source_file))<EOL><DEDENT>self._authenticated_request.to_endpoint('<STR_LIT>'.format(file_id)).with_headers({'<STR_LIT>': source_file}).put()<EOL>", "docstring": "Copy file content from source file to target file.\n\n        Args:\n            file_id (str): The UUID of the file whose content is written.\n            source_file (str): The UUID of the file whose content is copied.\n\n        Returns:\n            None\n\n        Raises:\n        StorageArgumentException: Invalid arguments\n        StorageForbiddenException: Server response code 403\n        StorageNotFoundException: Server response code 404\n        StorageException: other 400-600 error codes", "id": "f6071:c0:m23"}
{"signature": "def list_folder_content(self, folder, name=None, entity_type=None,<EOL>content_type=None, page_size=DEFAULT_PAGE_SIZE,<EOL>page=None, ordering=None):", "body": "if not is_valid_uuid(folder):<EOL><INDENT>raise StorageArgumentException(<EOL>'<STR_LIT>'.format(folder))<EOL><DEDENT>params = self._prep_params(locals())<EOL>del params['<STR_LIT>']  <EOL>return self._authenticated_request.to_endpoint('<STR_LIT>'.format(folder)).with_params(params).return_body().get()<EOL>", "docstring": "List files and folders (not recursively) contained in the folder.\n\n        This function does not retrieve all results, pages have\n        to be manually retrieved by the caller.\n\n        Args:\n            folder (str): The UUID of the requested folder.\n            name (str): Optional filter on entity name.\n            entity_type (str): Optional filter on entity type.\n                Admitted values: ['file', 'folder'].\n            content_type (str): Optional filter on entity content type (only\n                files are returned).\n            page_size (int): Number of elements per page.\n            page (int): Number of the page.\n            ordering (str): Indicate on which fields to sort the result. Prepend\n                '-' to invert order. Multiple values can be provided.\n                Ordering is supported on: ['name', 'created_on', 'modified_on'].\n                Example: 'ordering=name,created_on'\n\n        Returns:\n            A dictionary of the results::\n\n                {\n                u'count': 1,\n                u'next': None,\n                u'previous': None,\n                u'results': [{u'content_type': u'plain/text',\n                    u'created_by': u'303447',\n                    u'created_on': u'2017-03-13T10:17:01.688472Z',\n                    u'description': u'',\n                    u'entity_type': u'file',\n                    u'modified_by': u'303447',\n                    u'modified_on': u'2017-03-13T10:17:01.688632Z',\n                    u'name': u'file_1',\n                    u'parent': u'eac11058-4ae0-4ea9-ada8-d3ea23887509',\n                    u'uuid': u'0e17eaac-cb00-4336-b9d7-657026844281'}]\n                }\n\n        Raises:\n            StorageArgumentException: Invalid arguments\n            StorageForbiddenException: Server response code 403\n            StorageNotFoundException: Server response code 404\n            StorageException: other 400-600 error codes", "id": "f6071:c0:m18"}
{"signature": "def decode_cmd_out(self, completed_cmd):", "body": "try:<EOL><INDENT>stdout = completed_cmd.stdout.encode('<STR_LIT:utf-8>').decode()<EOL><DEDENT>except AttributeError:<EOL><INDENT>try:<EOL><INDENT>stdout = str(bytes(completed_cmd.stdout), '<STR_LIT>').strip()<EOL><DEDENT>except AttributeError:<EOL><INDENT>stdout = str(bytes(completed_cmd.stdout).decode('<STR_LIT:utf-8>')).strip()<EOL><DEDENT><DEDENT>try:<EOL><INDENT>stderr = completed_cmd.stderr.encode('<STR_LIT:utf-8>').decode()<EOL><DEDENT>except AttributeError:<EOL><INDENT>try:<EOL><INDENT>stderr = str(bytes(completed_cmd.stderr), '<STR_LIT>').strip()<EOL><DEDENT>except AttributeError:<EOL><INDENT>stderr = str(bytes(completed_cmd.stderr).decode('<STR_LIT:utf-8>')).strip()<EOL><DEDENT><DEDENT>return ParsedCompletedCommand(<EOL>completed_cmd.returncode,<EOL>completed_cmd.args,<EOL>stdout,<EOL>stderr<EOL>)<EOL>", "docstring": "return a standard message", "id": "f6075:c0:m2"}
{"signature": "def __init_cache_file_if_needed(self):", "body": "exp_cache_file = self.get_data_path(self.name, self.version)<EOL>if not os.path.isdir(exp_cache_file):<EOL><INDENT>os.makedirs(exp_cache_file)<EOL><DEDENT>", "docstring": "Inits a file that we log historical experiments\n:return:", "id": "f6083:c0:m3"}
{"signature": "def __get_hopt_params(self, trial):", "body": "params = []<EOL>for k in trial.__dict__:<EOL><INDENT>v = trial.__dict__[k]<EOL>if v is None or v == False:<EOL><INDENT>continue<EOL><DEDENT>if self.__should_escape(v):<EOL><INDENT>cmd = '<STR_LIT>'.format(k, v)<EOL><DEDENT>else:<EOL><INDENT>cmd = '<STR_LIT>'.format(k, v)<EOL><DEDENT>params.append(cmd)<EOL><DEDENT>params.append('<STR_LIT>'.format(HyperOptArgumentParser.TRIGGER_CMD))<EOL>full_cmd = '<STR_LIT:U+0020>'.join(params)<EOL>return full_cmd<EOL>", "docstring": "Turns hopt trial into script params\n:param trial:\n:return:", "id": "f6087:c1:m12"}
{"signature": "def run_setup(script_name, script_args=None, stop_after=\"<STR_LIT>\"):", "body": "if stop_after not in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % stop_after)<EOL><DEDENT>core._setup_stop_after = stop_after<EOL>save_argv = sys.argv<EOL>glocals = copy(globals())<EOL>glocals['<STR_LIT>'] = script_name<EOL>glocals['<STR_LIT>'] = \"<STR_LIT:__main__>\"<EOL>try:<EOL><INDENT>try:<EOL><INDENT>sys.argv[<NUM_LIT:0>] = script_name<EOL>if script_args is not None:<EOL><INDENT>sys.argv[<NUM_LIT:1>:] = script_args<EOL><DEDENT>f = open(script_name)<EOL>try:<EOL><INDENT>exec(f.read(), glocals, glocals)<EOL><DEDENT>finally:<EOL><INDENT>f.close()<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>sys.argv = save_argv<EOL>core._setup_stop_after = None<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>logging.warn(\"<STR_LIT>\", exc_info=True)<EOL><DEDENT>if core._setup_distribution is None:<EOL><INDENT>raise RuntimeError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" %<EOL>script_name)<EOL><DEDENT>return core._setup_distribution<EOL>", "docstring": "Run a setup script in a somewhat controlled environment, and\n    return the Distribution instance that drives things.  This is useful\n    if you need to find out the distribution meta-data (passed as\n    keyword args from 'script' to 'setup()', or the contents of the\n    config files or command-line.\n\n    'script_name' is a file that will be run with 'execfile()';\n    'sys.argv[0]' will be replaced with 'script' for the duration of the\n    call.  'script_args' is a list of strings; if supplied,\n    'sys.argv[1:]' will be replaced by 'script_args' for the duration of\n    the call.\n\n    'stop_after' tells 'setup()' when to stop processing; possible\n    values:\n      init\n        stop after the Distribution instance has been created and\n        populated with the keyword arguments to 'setup()'\n      config\n        stop after config files have been parsed (and their data\n        stored in the Distribution instance)\n      commandline\n        stop after the command-line ('sys.argv[1:]' or 'script_args')\n        have been parsed (and the data stored in the Distribution)\n      run [default]\n        stop after all commands have been run (the same as if 'setup()'\n        had been called in the usual way\n\n    Returns the Distribution instance, which provides all information\n    used to drive the Distutils.", "id": "f6103:m0"}
{"signature": "def valid_set(self):", "body": "", "docstring": ":rtype: list of tuple", "id": "f6118:c0:m1"}
{"signature": "def train_size(self):", "body": "train_set = self.train_set()<EOL>if isinstance(train_set, collections.Iterable):<EOL><INDENT>return len(list(train_set))<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Return size of training data. (optional)\n:rtype: number", "id": "f6118:c0:m3"}
{"signature": "def pad_dataset(subset, side=\"<STR_LIT:right>\", length=-<NUM_LIT:1>):", "body": "assert length == -<NUM_LIT:1> or length > <NUM_LIT:0><EOL>if type(subset[<NUM_LIT:0>][<NUM_LIT:0>][<NUM_LIT:0>]) in [float, int, np.int64, np.int32, np.float32]:<EOL><INDENT>return _pad_2d(subset, side, length)<EOL><DEDENT>else:<EOL><INDENT>return _pad_3d(subset, side, length)<EOL><DEDENT>", "docstring": "Pad data set to specified length.\nParameters:\n    length - max length, a just to the max length in the batch if length is -1", "id": "f6120:m0"}
{"signature": "def monitor_layer_outputs(self):", "body": "for layer, hidden in zip(self.layers, self._hidden_outputs):<EOL><INDENT>self.training_monitors.append(('<STR_LIT>' % (layer.name), abs(hidden).mean()))<EOL><DEDENT>", "docstring": "Monitoring the outputs of each layer.\nUseful for troubleshooting convergence problems.", "id": "f6129:c0:m7"}
{"signature": "def load_params(self, path, exclude_free_params=False):", "body": "if not os.path.exists(path): return;<EOL>logging.info(\"<STR_LIT>\" % path)<EOL>if exclude_free_params:<EOL><INDENT>params_to_load = self.parameters<EOL><DEDENT>else:<EOL><INDENT>params_to_load = self.all_parameters<EOL><DEDENT>if path.endswith(\"<STR_LIT>\"):<EOL><INDENT>opener = gzip.open if path.lower().endswith('<STR_LIT>') else open<EOL>handle = opener(path, '<STR_LIT:rb>')<EOL>saved_params = pickle.load(handle)<EOL>handle.close()<EOL>for target, source in zip(params_to_load, saved_params):<EOL><INDENT>logging.info('<STR_LIT>', target.name, source.shape)<EOL>target.set_value(source)<EOL><DEDENT><DEDENT>elif path.endswith(\"<STR_LIT>\"):<EOL><INDENT>arrs = np.load(path)<EOL>for target, idx in zip(params_to_load, range(len(arrs.keys()))):<EOL><INDENT>source = arrs['<STR_LIT>' % idx]<EOL>logging.info('<STR_LIT>', target.name, source.shape)<EOL>target.set_value(source)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\" % path)<EOL><DEDENT>self.train_logger.load(path)<EOL>", "docstring": "Load parameters from file.", "id": "f6129:c0:m17"}
{"signature": "def register(self, *layers):", "body": "for layer in layers:<EOL><INDENT>self.register_layer(layer)<EOL><DEDENT>", "docstring": "Register multiple layers as the components of the network.\nThe parameter of those layers will be trained.\nBut the output of the layer will not be stacked.", "id": "f6129:c0:m2"}
{"signature": "def stack(self, *layers):", "body": "for layer in layers:<EOL><INDENT>self.stack_layer(layer)<EOL><DEDENT>return self<EOL>", "docstring": "Stack layers.", "id": "f6129:c0:m5"}
{"signature": "def register_layer(self, layer):", "body": "if type(layer) == Block:<EOL><INDENT>layer.fix()<EOL><DEDENT>self.parameter_count += layer.parameter_count<EOL>self.parameters.extend(layer.parameters)<EOL>self.free_parameters.extend(layer.free_parameters)<EOL>self.training_monitors.extend(layer.training_monitors)<EOL>self.testing_monitors.extend(layer.testing_monitors)<EOL>self.updates.extend(layer.updates)<EOL>self.training_updates.extend(layer.training_updates)<EOL>self.input_variables.extend(layer.external_inputs)<EOL>self.target_variables.extend(layer.external_targets)<EOL>self.training_callbacks.extend(layer.training_callbacks)<EOL>self.testing_callbacks.extend(layer.testing_callbacks)<EOL>self.epoch_callbacks.extend(layer.epoch_callbacks)<EOL>", "docstring": "Register the layer so that it's param will be trained.\nBut the output of the layer will not be stacked.", "id": "f6129:c0:m3"}
{"signature": "@property<EOL><INDENT>def cost(self):<DEDENT>", "body": "return T.constant(<NUM_LIT:0>)<EOL>", "docstring": "Return cost variable.", "id": "f6129:c0:m14"}
{"signature": "def report(self):", "body": "logging.info(\"<STR_LIT>\", \"<STR_LIT:U+0020>\".join(map(str, self.input_variables)))<EOL>logging.info(\"<STR_LIT>\", \"<STR_LIT:U+0020>\".join(map(str, self.target_variables)))<EOL>logging.info(\"<STR_LIT>\", \"<STR_LIT:U+0020>\".join(map(str, self.all_parameters)))<EOL>logging.info(\"<STR_LIT>\", self.parameter_count)<EOL>", "docstring": "Print network statistics.", "id": "f6129:c0:m18"}
{"signature": "def stack_encoders(self, *layers):", "body": "self.stack(*layers)<EOL>self.encoding_layes.extend(layers)<EOL>", "docstring": "Stack encoding layers, this must be done before stacking decoding layers.", "id": "f6130:c0:m4"}
{"signature": "def stack_decoders(self, *layers):", "body": "self.stack(*layers)<EOL>self.decoding_layers.extend(layers)<EOL>", "docstring": "Stack decoding layers.", "id": "f6130:c0:m5"}
{"signature": "def optimize_function(params, config=None):", "body": "gs = [dim_to_var(p.ndim) for p in params]<EOL>updates, _ = optimize_updates(params, gs, config)<EOL>return theano.function(gs, [], updates=updates)<EOL>", "docstring": "Create a optimizing function receives gradients.\nParameters:\n    params - parameters\n    config - training configuration\nReturns:\n    updating function receives gradients", "id": "f6133:m1"}
{"signature": "def __init__(self, patience=<NUM_LIT:3>, anneal_times=<NUM_LIT:4>):", "body": "self._iter = <NUM_LIT:0><EOL>self._annealed_iter = <NUM_LIT:0><EOL>self._patience = patience<EOL>self._anneal_times = anneal_times<EOL>self._annealed_times = <NUM_LIT:0><EOL>self._learning_rate = <NUM_LIT:0><EOL>if type(self._learning_rate) == float:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": ":type trainer: deepy.trainers.base.NeuralTrainer", "id": "f6134:c0:m0"}
{"signature": "def momentum_core(params, gradients, momentum=<NUM_LIT>, learning_rate=<NUM_LIT>):", "body": "free_parameters = []<EOL>updates = []<EOL>for param, grad in zip(params, gradients):<EOL><INDENT>delta = learning_rate * grad<EOL>velocity = theano.shared(np.zeros_like(param.get_value()), name=param.name + '<STR_LIT>')<EOL>updates.append((velocity, momentum * velocity - delta))<EOL>updates.append((param, param + velocity))<EOL>free_parameters.append(velocity)<EOL><DEDENT>return updates, free_parameters<EOL>", "docstring": "Momentum SGD optimization core.", "id": "f6141:m0"}
{"signature": "def report(self, score_map, type=\"<STR_LIT>\", epoch=-<NUM_LIT:1>, new_best=False):", "body": "type_str = type<EOL>if len(type_str) < <NUM_LIT:5>:<EOL><INDENT>type_str += \"<STR_LIT:U+0020>\" * (<NUM_LIT:5> - len(type_str))<EOL><DEDENT>info = \"<STR_LIT:U+0020>\".join(\"<STR_LIT>\" % el for el in score_map.items())<EOL>current_epoch = epoch if epoch > <NUM_LIT:0> else self.current_epoch()<EOL>epoch_str = \"<STR_LIT>\".format(current_epoch + <NUM_LIT:1>)<EOL>if epoch < <NUM_LIT:0>:<EOL><INDENT>epoch_str = \"<STR_LIT>\"<EOL>sys.stdout.write(\"<STR_LIT:\\r>\")<EOL>sys.stdout.flush()<EOL><DEDENT>marker = \"<STR_LIT>\" if new_best else \"<STR_LIT>\"<EOL>message = \"<STR_LIT>\".format(type_str, epoch_str, info, marker)<EOL>self.network.train_logger.record(message)<EOL>logging.info(message)<EOL>", "docstring": "Report the scores and record them in the log.", "id": "f6142:c0:m19"}
{"signature": "def _run_train(self, epoch, train_set, train_size=None):", "body": "self.network.train_logger.record_epoch(epoch + <NUM_LIT:1>)<EOL>costs = self.train_step(train_set, train_size)<EOL>if not epoch % self.config.monitor_frequency:<EOL><INDENT>self.report(dict(costs), \"<STR_LIT:train>\", epoch)<EOL><DEDENT>self.last_run_costs = costs<EOL>return costs<EOL>", "docstring": "Run one training iteration.", "id": "f6142:c0:m16"}
{"signature": "def add_iter_controllers(self, *controllers):", "body": "for controller in controllers:<EOL><INDENT>if isinstance(controller, TrainingController):<EOL><INDENT>controller.bind(self)<EOL><DEDENT>self._iter_controllers.append(controller)<EOL><DEDENT>", "docstring": "Add iteration callbacks function (receives an argument of the trainer).\n:param controllers: can be a `TrainingController` or a function.\n:type funcs: list of TrainingContoller", "id": "f6142:c0:m11"}
{"signature": "def current_epoch(self):", "body": "return self._epoch<EOL>", "docstring": "Get current epoch.", "id": "f6142:c0:m23"}
{"signature": "def exit(self):", "body": "self._ended = True<EOL>", "docstring": "End the training.", "id": "f6142:c0:m10"}
{"signature": "def __init__(self, network, config=None):", "body": "super(CustomizeTrainer, self).__init__(network, config)<EOL>", "docstring": "Basic neural network trainer.\n:type network: deepy.NeuralNetwork\n:type config: deepy.conf.TrainerConfig\n:return:", "id": "f6144:c0:m0"}
{"signature": "def get_gradients(self, params):", "body": "return T.grad(self.cost, params)<EOL>", "docstring": "Get gradients from given parameters.", "id": "f6146:c0:m4"}
{"signature": "def learning_function(self):", "body": "network_updates = list(self.network.updates) + list(self.network.training_updates)<EOL>learning_updates = list(self._learning_updates())<EOL>update_list = network_updates + learning_updates<EOL>logging.info(\"<STR_LIT>\" % \"<STR_LIT:U+0020>\".join(map(str, [x[<NUM_LIT:0>] for x in network_updates])))<EOL>logging.info(\"<STR_LIT>\" % \"<STR_LIT:U+0020>\".join(map(str, [x[<NUM_LIT:0>] for x in learning_updates])))<EOL>variables = self.network.input_variables + self.network.target_variables<EOL>givens = None<EOL>return theano.function(<EOL>variables,<EOL>map(lambda v: theano.Out(v, borrow=True), self.training_variables),<EOL>updates=update_list, allow_input_downcast=True,<EOL>mode=self.config.get(\"<STR_LIT>\", None),<EOL>givens=givens)<EOL>", "docstring": "Get the learning function.\n:param func:\n:return:", "id": "f6146:c0:m6"}
{"signature": "def invoke(self):", "body": "self._counter += <NUM_LIT:1><EOL>if self._counter % self._freq == <NUM_LIT:0>:<EOL><INDENT>cnt = <NUM_LIT:0.><EOL>sum_map = defaultdict(float)<EOL>for x in self._trainer.get_data(self._data_split):<EOL><INDENT>val_map = self.run(x)<EOL>if not isinstance(val_map, dict):<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>for k, val in val_map.items():<EOL><INDENT>sum_map[k] += val<EOL><DEDENT>cnt += <NUM_LIT:1><EOL><DEDENT>for k in sum_map:<EOL><INDENT>sum_map[k] /= cnt<EOL><DEDENT>new_best = self.compare(sum_map)<EOL>self._trainer.report(sum_map, self._data_split, new_best=new_best)<EOL>if new_best:<EOL><INDENT>self._trainer.save_checkpoint(self._save_path)<EOL><DEDENT><DEDENT>", "docstring": "This function will be called after each iteration.", "id": "f6147:c1:m5"}
{"signature": "def compare(self, cost_map):", "body": "cri_val = cost_map[self._criteria]<EOL>if self._best_criteria is None:<EOL><INDENT>self._best_criteria = cri_val<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>if self._smaller_is_better and cri_val < self._best_criteria:<EOL><INDENT>self._best_criteria = cri_val<EOL>return True<EOL><DEDENT>elif not self._smaller_is_better and cri_val > self._best_criteria:<EOL><INDENT>self._best_criteria = cri_val<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>", "docstring": "Compare to previous records and return whether the given cost is a new best.\n:return: True if the given cost is a new best", "id": "f6147:c1:m1"}
{"signature": "def compute_context_vector(self, prev_state, inputs, precomputed_values=None, mask=None):", "body": "precomputed_values = precomputed_values if precomputed_values else self.precompute(inputs)<EOL>align_weights = self.compute_alignments(prev_state, precomputed_values, mask)<EOL>context_vector = T.sum(align_weights[:, :, None] * inputs, axis=<NUM_LIT:1>)<EOL>return context_vector<EOL>", "docstring": "Compute the context vector with soft attention.", "id": "f6148:c0:m4"}
{"signature": "def register_monitors(self, *monitors):", "body": "for key, node in monitors:<EOL><INDENT>if key not in self._registered_monitors:<EOL><INDENT>node *= <NUM_LIT:1.0> <EOL>self.training_monitors.append((key, node))<EOL>self.testing_monitors.append((key, node))<EOL>self._registered_monitors.add(key)<EOL><DEDENT><DEDENT>", "docstring": "Register monitors they should be tuple of name and Theano variable.", "id": "f6164:c0:m12"}
{"signature": "def register_training_callbacks(self, *callbacks):", "body": "self.training_callbacks.extend(callbacks)<EOL>", "docstring": "Register callback for each iteration in the training.", "id": "f6164:c0:m15"}
{"signature": "def register_external_inputs(self, *variables):", "body": "self.external_inputs.extend(variables)<EOL>", "docstring": "Register external input variables.", "id": "f6164:c0:m13"}
{"signature": "def register_parameters(self, *parameters):", "body": "for param in parameters:<EOL><INDENT>self.parameter_count += np.prod(param.get_value().shape)<EOL><DEDENT>self.parameters.extend(parameters)<EOL>", "docstring": "Register parameters.", "id": "f6164:c0:m8"}
{"signature": "def __init__(self, *layers, **kwargs):", "body": "name = kwargs['<STR_LIT:name>'] if '<STR_LIT:name>' in kwargs else \"<STR_LIT>\".format(self._BLOCK_COUNT + <NUM_LIT:1>)<EOL>super(Block, self).__init__(name)<EOL>self._BLOCK_COUNT += <NUM_LIT:1><EOL>self.layers = list(layers)<EOL>self.fixed = False<EOL>", "docstring": "Create a new parameter block with some layers.\nYou can also specify a name through kwargs.", "id": "f6169:c0:m0"}
{"signature": "def register_layer(self, layer):", "body": "if self.fixed:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>self.layers.append(layer)<EOL>", "docstring": "Register one connected layer.\n:type layer: NeuralLayer", "id": "f6169:c0:m4"}
{"signature": "def register(self, *layers):", "body": "for layer in layers:<EOL><INDENT>self.register_layer(layer)<EOL><DEDENT>", "docstring": "Register many connected layers.\n:type layers: list of NeuralLayer", "id": "f6169:c0:m3"}
{"signature": "@neural_computation<EOL><INDENT>def get_initial_states(self, input_var, init_state=None):<DEDENT>", "body": "initial_states = {}<EOL>for state in self.state_names:<EOL><INDENT>if state != \"<STR_LIT:state>\" or not init_state:<EOL><INDENT>if self._input_type == '<STR_LIT>' and input_var.ndim == <NUM_LIT:2>:<EOL><INDENT>init_state = T.alloc(np.cast[env.FLOATX](<NUM_LIT:0.>), self.hidden_size)<EOL><DEDENT>else:<EOL><INDENT>init_state = T.alloc(np.cast[env.FLOATX](<NUM_LIT:0.>), input_var.shape[<NUM_LIT:0>], self.hidden_size)<EOL><DEDENT><DEDENT>initial_states[state] = init_state<EOL><DEDENT>return initial_states<EOL>", "docstring": ":type input_var: T.var\n:rtype: dict", "id": "f6174:c0:m6"}
{"signature": "@neural_computation<EOL><INDENT>def get_step_inputs(self, input_var, states=None, mask=None, additional_inputs=None):<DEDENT>", "body": "step_inputs = {}<EOL>if self._input_type == \"<STR_LIT>\":<EOL><INDENT>if not additional_inputs:<EOL><INDENT>additional_inputs = []<EOL><DEDENT>if mask:<EOL><INDENT>step_inputs['<STR_LIT>'] = mask.dimshuffle(<NUM_LIT:1>, <NUM_LIT:0>)<EOL><DEDENT>step_inputs.update(self.merge_inputs(input_var, additional_inputs=additional_inputs))<EOL><DEDENT>else:<EOL><INDENT>if additional_inputs:<EOL><INDENT>step_inputs.update(self.merge_inputs(None, additional_inputs=additional_inputs))<EOL><DEDENT><DEDENT>if states:<EOL><INDENT>for name in self.state_names:<EOL><INDENT>step_inputs[name] = states[name]<EOL><DEDENT><DEDENT>return step_inputs<EOL>", "docstring": ":type input_var: T.var\n:rtype: dict", "id": "f6174:c0:m7"}
{"signature": "def switch_training(self, flag):", "body": "if self._is_training == flag: return<EOL>self._is_training = flag<EOL>if flag:<EOL><INDENT>self._training_flag.set_value(<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>self._training_flag.set_value(<NUM_LIT:0>)<EOL><DEDENT>", "docstring": "Switch training mode.\n:param flag: switch on training mode when flag is True.", "id": "f6179:c0:m2"}
{"signature": "@neural_computation<EOL><INDENT>def iftrain(self, then_branch, else_branch):<DEDENT>", "body": "return ifelse(self._training_flag, then_branch, else_branch, name=\"<STR_LIT>\")<EOL>", "docstring": "Execute `then_branch` when training.", "id": "f6179:c0:m1"}
{"signature": "def __init__(self, seed=DEFAULT_SEED):", "body": "if seed != self.DEFAULT_SEED:<EOL><INDENT>self._seed = seed<EOL><DEDENT>elif '<STR_LIT>' in os.environ:<EOL><INDENT>self._seed = int(os.environ['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>self._seed = self.DEFAULT_SEED<EOL><DEDENT>if self._seed != self.DEFAULT_SEED:<EOL><INDENT>logging.info(\"<STR_LIT>\" % self._seed)<EOL><DEDENT>self._numpy_rand = np.random.RandomState(seed=self._seed)<EOL>self._theano_rand = RandomStreams(seed=self._seed)<EOL>self._shared_rand = SharedRandomStreams(seed=self._seed)<EOL>self._default_initializer = None<EOL>", "docstring": "Initialize seed and global random variables.", "id": "f6183:c0:m0"}
{"signature": "def _scan_step(self, vars):", "body": "from neural_var import NeuralVariable<EOL>if not self._loop_vars:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>replace_map = {}<EOL>for k, var in vars.items():<EOL><INDENT>if var is not None:<EOL><INDENT>replace_map[self._dummy_nodes[k].tensor] = var.tensor<EOL><DEDENT><DEDENT>outputs = {}<EOL>for k in self._outputs:<EOL><INDENT>if k not in self._loop_vars:<EOL><INDENT>raise Exception(\"<STR_LIT>\".format(k))<EOL><DEDENT>output_node = theano.clone(self._loop_vars[k].tensor, replace_map)<EOL>outputs[k] = NeuralVariable(output_node, self._loop_vars[k].dim())<EOL><DEDENT>return outputs<EOL>", "docstring": "Internal scan with dummy input variables.", "id": "f6184:c1:m4"}
{"signature": "@neural_computation<EOL><INDENT>def disconnect(self, x):<DEDENT>", "body": "return disconnected_grad(x)<EOL>", "docstring": "Disconnect a variable from backpropagation.", "id": "f6186:c0:m10"}
{"signature": "def end(self):", "body": "self.end_time = time.time()<EOL>", "docstring": "Stop the timer.", "id": "f6189:c0:m1"}
{"signature": "def sample(self, shape):", "body": "raise NotImplementedError<EOL>", "docstring": "Sample parameters with given shape.", "id": "f6190:c0:m1"}
{"signature": "def __init__(self, uniform=False, seed=None):", "body": "super(KaimingHeInitializer, self).__init__(seed)<EOL>self.uniform = uniform<EOL>", "docstring": "Parameters:\n    uniform - uniform distribution, default Gaussian\n    seed - random seed", "id": "f6190:c5:m0"}
{"signature": "@staticmethod<EOL><INDENT>def dump(iterable_to_pickle, file_obj):<DEDENT>", "body": "for elt in iterable_to_pickle:<EOL><INDENT>StreamPickler.dump_one(elt, file_obj)<EOL><DEDENT>", "docstring": "dump contents of an iterable iterable_to_pickle to file_obj, a file\nopened in write mode", "id": "f6194:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def load(file_obj):<DEDENT>", "body": "cur_elt = []<EOL>for line in file_obj:<EOL><INDENT>cur_elt.append(line)<EOL>if line == '<STR_LIT:\\n>':<EOL><INDENT>pickled_elt_str = '<STR_LIT>'.join(cur_elt)<EOL>cur_elt = []<EOL>try:<EOL><INDENT>elt = loads(pickled_elt_str)<EOL><DEDENT>except ValueError:<EOL><INDENT>continue<EOL><DEDENT>yield elt<EOL><DEDENT><DEDENT>", "docstring": "load contents from file_obj, returning a generator that yields one\nelement at a time", "id": "f6194:c0:m2"}
{"signature": "@neural_computation<EOL>def activate(var, method):", "body": "from activations import get_activation<EOL>return get_activation(method)(var)<EOL>", "docstring": "An activation function.\n:param var: input var\n:param method: type of activation, such as `relu`,`tanh`,`sigmoid`", "id": "f6200:m2"}
{"signature": "def handle_control(self, req, worker_id, req_info):", "body": "if self.start_time is None: self.start_time = time.time()<EOL>response = \"<STR_LIT>\"<EOL>if req == '<STR_LIT>':<EOL><INDENT>if self.num_train_batches == <NUM_LIT:0>:<EOL><INDENT>response = \"<STR_LIT>\"<EOL><DEDENT>elif self._done:<EOL><INDENT>response = \"<STR_LIT>\"<EOL>self.worker_is_done(worker_id)<EOL><DEDENT>elif self._evaluating:<EOL><INDENT>response = '<STR_LIT>'<EOL><DEDENT>elif not self.batch_pool:<EOL><INDENT>if self._train_costs:<EOL><INDENT>with self._lock:<EOL><INDENT>sys.stdout.write(\"<STR_LIT:\\r>\")<EOL>sys.stdout.flush()<EOL>mean_costs = []<EOL>for i in range(len(self._training_names)):<EOL><INDENT>mean_costs.append(np.mean([c[i] for c in self._train_costs]))<EOL><DEDENT>self.log(\"<STR_LIT>\".format(<EOL>self.epoch,<EOL>self.get_monitor_string(zip(self._training_names, mean_costs)))<EOL>)<EOL><DEDENT><DEDENT>response = {'<STR_LIT>': None, '<STR_LIT>': self._best_valid_cost}<EOL>self._evaluating = True<EOL><DEDENT>else:<EOL><INDENT>if worker_id not in self.prepared_worker_pool:<EOL><INDENT>response = {\"<STR_LIT>\": self.feed_hyperparams()}<EOL>self.prepared_worker_pool.add(worker_id)<EOL><DEDENT>elif self._iters_from_last_valid >= self._valid_freq:<EOL><INDENT>response = {'<STR_LIT>': None, '<STR_LIT>': self._best_valid_cost}<EOL>self._iters_from_last_valid = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>response = {\"<STR_LIT:train>\": self.feed_batches()}<EOL><DEDENT><DEDENT><DEDENT>elif '<STR_LIT>' in req:<EOL><INDENT>with self._lock:<EOL><INDENT>self._evaluating = False<EOL>sys.stdout.write(\"<STR_LIT:\\r>\")<EOL>sys.stdout.flush()<EOL>if '<STR_LIT>' in req and req['<STR_LIT>']:<EOL><INDENT>self.log(\"<STR_LIT>\".format(<EOL>self.epoch,<EOL>self.get_monitor_string(req['<STR_LIT>']),<EOL>worker_id)<EOL>)<EOL><DEDENT>if '<STR_LIT>' in req and req['<STR_LIT>']:<EOL><INDENT>valid_J = req['<STR_LIT>'][<NUM_LIT:0>][<NUM_LIT:1>]<EOL>if valid_J < self._best_valid_cost:<EOL><INDENT>self._best_valid_cost = valid_J<EOL>star_str = \"<STR_LIT:*>\"<EOL><DEDENT>else:<EOL><INDENT>star_str = \"<STR_LIT>\"<EOL>self.log(\"<STR_LIT>\".format(<EOL>self.epoch,<EOL>self.get_monitor_string(req['<STR_LIT>']),<EOL>star_str,<EOL>worker_id))<EOL><DEDENT><DEDENT>continue_training = self.prepare_epoch()<EOL>self._epoch_start_time = time.time()<EOL>if not continue_training:<EOL><INDENT>self._done = True<EOL>self.log(\"<STR_LIT>\".format(time.time() - self.start_time))<EOL>response = \"<STR_LIT>\"<EOL><DEDENT><DEDENT><DEDENT>elif '<STR_LIT>' in req:<EOL><INDENT>with self._lock:<EOL><INDENT>sys.stdout.write(\"<STR_LIT:\\r>\")<EOL>sys.stdout.flush()<EOL>if '<STR_LIT>' in req:<EOL><INDENT>valid_J = req['<STR_LIT>'][<NUM_LIT:0>][<NUM_LIT:1>]<EOL>if valid_J < self._best_valid_cost:<EOL><INDENT>self._best_valid_cost = valid_J<EOL>star_str = \"<STR_LIT:*>\"<EOL><DEDENT>else:<EOL><INDENT>star_str = \"<STR_LIT>\"<EOL><DEDENT>self.log(\"<STR_LIT>\".format(<EOL>self.get_monitor_string(req['<STR_LIT>']),<EOL>star_str,<EOL>worker_id<EOL>))<EOL><DEDENT><DEDENT><DEDENT>elif '<STR_LIT>' in req:<EOL><INDENT>costs = req['<STR_LIT>']<EOL>self._train_costs.append(costs)<EOL>sys.stdout.write(\"<STR_LIT>\" % (<EOL>self._current_iter * <NUM_LIT:100> / self.num_train_batches,<EOL>costs[<NUM_LIT:0>], float(len(self._train_costs) * self.sync_freq) / (time.time() - self._epoch_start_time)))<EOL>sys.stdout.flush()<EOL><DEDENT>elif '<STR_LIT>' in req:<EOL><INDENT>self.num_train_batches = req['<STR_LIT>']<EOL><DEDENT>elif '<STR_LIT>' in req:<EOL><INDENT>response = self._easgd_alpha<EOL><DEDENT>elif '<STR_LIT>' in req:<EOL><INDENT>response = {\"<STR_LIT>\": self.feed_hyperparams()}<EOL><DEDENT>elif '<STR_LIT>' in req:<EOL><INDENT>with self._lock:<EOL><INDENT>sys.stdout.write(\"<STR_LIT:\\r>\")<EOL>sys.stdout.flush()<EOL>self.log(\"<STR_LIT>\".format(worker_id))<EOL>if self.epoch == <NUM_LIT:0>:<EOL><INDENT>schedule_params = req['<STR_LIT>']<EOL>sch_str = \"<STR_LIT:U+0020>\".join(\"<STR_LIT>\".format(a, b) for (a, b) in schedule_params.items())<EOL>self.log(\"<STR_LIT>\".format(sch_str))<EOL>for key, val in schedule_params.items():<EOL><INDENT>if not val: continue<EOL>if key == '<STR_LIT>':<EOL><INDENT>self._lr = val<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>self.epoch_start_halving = val<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>self._halving_freq = val<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>self.end_at = val<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>self.sync_freq = val<EOL><DEDENT>elif key == '<STR_LIT>':<EOL><INDENT>self._valid_freq = val<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>elif '<STR_LIT>' in req:<EOL><INDENT>self._training_names = req['<STR_LIT>']<EOL>self._evaluation_names = req['<STR_LIT>']<EOL><DEDENT>return response<EOL>", "docstring": "Handles a control_request received from a worker.\nReturns:\n    string or dict: response\n\n    'stop' - the worker should quit\n    'wait' - wait for 1 second\n    'eval' - evaluate on valid and test set to start a new epoch\n    'sync_hyperparams' - set learning rate\n    'valid' - evaluate on valid and test set, then save the params\n    'train' - train next batches", "id": "f6207:c0:m6"}
{"signature": "def __init__(self, logger=None):", "body": "object.__setattr__(self, \"<STR_LIT>\", {})<EOL>object.__setattr__(self, \"<STR_LIT>\", set())<EOL>object.__setattr__(self, \"<STR_LIT>\", set())<EOL>object.__setattr__(self, \"<STR_LIT>\", logger)<EOL>", "docstring": "Create a general config", "id": "f6210:c0:m0"}
{"signature": "def prepare(self):", "body": "self.output_dim = <NUM_LIT:10><EOL>self.encoder = Chain(self.input_dim).stack(Dense(self.internal_layer_size, '<STR_LIT>'))<EOL>self.decoder = Chain(self.internal_layer_size).stack(Dense(self.input_dim))<EOL>self.classifier = Chain(self.internal_layer_size).stack(Dense(<NUM_LIT:50>, '<STR_LIT>'),<EOL>Dense(self.output_dim),<EOL>Softmax())<EOL>self.register_inner_layers(self.encoder, self.decoder, self.classifier)<EOL>self.target_input = T.ivector('<STR_LIT:target>')<EOL>self.register_external_inputs(self.target_input)<EOL>", "docstring": "All codes that create parameters should be put into 'setup' function.", "id": "f6226:c0:m1"}
{"signature": "def _refined_glimpse_sensor(self, x_t, l_p):", "body": "<EOL>l_p = l_p * <NUM_LIT> + <NUM_LIT> - <NUM_LIT:4><EOL>l_p = T.cast(T.round(l_p), \"<STR_LIT>\")<EOL>l_p = l_p * (l_p >= <NUM_LIT:0>)<EOL>l_p = l_p * (l_p < <NUM_LIT>) + (l_p >= <NUM_LIT>) * <NUM_LIT:20><EOL>glimpse_1 = x_t[l_p[<NUM_LIT:0>]: l_p[<NUM_LIT:0>] + <NUM_LIT:7>][:, l_p[<NUM_LIT:1>]: l_p[<NUM_LIT:1>] + <NUM_LIT:7>]<EOL>return glimpse_1<EOL>", "docstring": "Parameters:\n    x_t - 28x28 image\n    l_p - 2x1 focus vector\nReturns:\n    7*14 matrix", "id": "f6236:c0:m3"}
{"signature": "def _location_network(self, h_t):", "body": "return T.dot(h_t, self.W_l)<EOL>", "docstring": "Parameters:\n    h_t - 256x1 vector\nReturns:\n    2x1 focus vector", "id": "f6236:c0:m6"}
{"signature": "def _glimpse_network(self, x_t, l_p):", "body": "sensor_output = self._refined_glimpse_sensor(x_t, l_p)<EOL>sensor_output = T.flatten(sensor_output)<EOL>h_g = self._relu(T.dot(sensor_output, self.W_g0))<EOL>h_l = self._relu(T.dot(l_p, self.W_g1))<EOL>g = self._relu(T.dot(h_g, self.W_g2_hg) + T.dot(h_l, self.W_g2_hl))<EOL>return g<EOL>", "docstring": "Parameters:\n    x_t - 28x28 image\n    l_p - 2x1 focus vector\nReturns:\n    4x12 matrix", "id": "f6242:c0:m5"}
{"signature": "@classmethod<EOL><INDENT>def from_mapping(<EOL>cls: Type[\"<STR_LIT>\"], mapping: Optional[Mapping[str, Any]] = None, **kwargs: Any<EOL>) -> \"<STR_LIT>\":<DEDENT>", "body": "mappings: Dict[str, Any] = {}<EOL>if mapping is not None:<EOL><INDENT>mappings.update(mapping)<EOL><DEDENT>mappings.update(kwargs)<EOL>config = cls()<EOL>for key, value in mappings.items():<EOL><INDENT>try:<EOL><INDENT>setattr(config, key, value)<EOL><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return config<EOL>", "docstring": "Create a configuration from a mapping.\n\n        This allows either a mapping to be directly passed or as\n        keyword arguments, for example,\n\n        .. code-block:: python\n\n            config = {'keep_alive_timeout': 10}\n            Config.from_mapping(config)\n            Config.form_mapping(keep_alive_timeout=10)\n\n        Arguments:\n            mapping: Optionally a mapping object.\n            kwargs: Optionally a collection of keyword arguments to\n                form a mapping.", "id": "f6274:c1:m13"}
{"signature": "async def serve(<EOL>app: ASGIFramework,<EOL>config: Config,<EOL>*,<EOL>task_status: trio._core._run._TaskStatus = trio.TASK_STATUS_IGNORED,<EOL>) -> None:", "body": "if config.debug:<EOL><INDENT>warnings.warn(\"<STR_LIT>\", Warning)<EOL><DEDENT>if config.workers != <NUM_LIT:1>:<EOL><INDENT>warnings.warn(\"<STR_LIT>\", Warning)<EOL><DEDENT>if config.worker_class != \"<STR_LIT>\":<EOL><INDENT>warnings.warn(\"<STR_LIT>\", Warning)<EOL><DEDENT>await worker_serve(app, config, task_status=task_status)<EOL>", "docstring": "Serve an ASGI framework app given the config.\n\n    This allows for a programmatic way to serve an ASGI framework, it\n    can be used via,\n\n    .. code-block:: python\n\n        trio.run(partial(serve, app, config))\n\n    It is assumed that the event-loop is configured before calling\n    this function, therefore configuration values that relate to loop\n    setup or process setup are ignored.", "id": "f6279:m0"}
{"signature": "async def asgi_send(self, message: dict) -> None:", "body": "if message[\"<STR_LIT:type>\"] == \"<STR_LIT>\" and self.state == ASGIHTTPState.REQUEST:<EOL><INDENT>self.response = message<EOL><DEDENT>elif message[\"<STR_LIT:type>\"] == \"<STR_LIT>\" and self.state in {<EOL>ASGIHTTPState.REQUEST,<EOL>ASGIHTTPState.RESPONSE,<EOL>}:<EOL><INDENT>if self.state == ASGIHTTPState.REQUEST:<EOL><INDENT>headers = build_and_validate_headers(self.response[\"<STR_LIT>\"])<EOL>headers.extend(self.response_headers())<EOL>await self.asend(<EOL>h11.Response(status_code=int(self.response[\"<STR_LIT:status>\"]), headers=headers)<EOL>)<EOL>self.state = ASGIHTTPState.RESPONSE<EOL><DEDENT>if (<EOL>not suppress_body(self.scope[\"<STR_LIT>\"], int(self.response[\"<STR_LIT:status>\"]))<EOL>and message.get(\"<STR_LIT:body>\", b\"<STR_LIT>\") != b\"<STR_LIT>\"<EOL>):<EOL><INDENT>await self.asend(h11.Data(data=bytes(message[\"<STR_LIT:body>\"])))<EOL><DEDENT>if not message.get(\"<STR_LIT>\", False):<EOL><INDENT>if self.state != ASGIHTTPState.CLOSED:<EOL><INDENT>await self.asend(h11.EndOfMessage())<EOL>await self.asgi_put({\"<STR_LIT:type>\": \"<STR_LIT>\"})<EOL>self.state = ASGIHTTPState.CLOSED<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>raise UnexpectedMessage(self.state, message[\"<STR_LIT:type>\"])<EOL><DEDENT>", "docstring": "Called by the ASGI instance to send a message.", "id": "f6293:c0:m9"}
{"signature": "async def asgi_receive(self) -> dict:", "body": "pass<EOL>", "docstring": "Called by the ASGI instance to receive a message.", "id": "f6297:c6:m1"}
{"signature": "async def asgi_put(self, message: dict) -> None:", "body": "pass<EOL>", "docstring": "Called by the ASGI server to put a message to the ASGI instance.\n\n        See asgi_receive as the get to this put.", "id": "f6297:c6:m0"}
{"signature": "@classmethod<EOL><INDENT>def validate_args(cls, tag_name, *args, **kwargs):<DEDENT>", "body": "if cls.min_args is not None and len(args) < cls.min_args:<EOL><INDENT>if cls.min_args == <NUM_LIT:1>:<EOL><INDENT>raise TemplateSyntaxError(\"<STR_LIT>\".format(tag_name, cls.min_args))<EOL><DEDENT>else:<EOL><INDENT>raise TemplateSyntaxError(\"<STR_LIT>\".format(tag_name, cls.min_args))<EOL><DEDENT><DEDENT>if cls.max_args is not None and len(args) > cls.max_args:<EOL><INDENT>if cls.max_args == <NUM_LIT:0>:<EOL><INDENT>if cls.allowed_kwargs:<EOL><INDENT>raise TemplateSyntaxError(\"<STR_LIT>\".format(tag_name, cls.allowed_kwargs[<NUM_LIT:0>]))<EOL><DEDENT>else:<EOL><INDENT>raise TemplateSyntaxError(\"<STR_LIT>\".format(tag_name))<EOL><DEDENT><DEDENT>elif cls.max_args == <NUM_LIT:1>:<EOL><INDENT>raise TemplateSyntaxError(\"<STR_LIT>\".format(tag_name, cls.max_args))<EOL><DEDENT>else:<EOL><INDENT>raise TemplateSyntaxError(\"<STR_LIT>\".format(tag_name, cls.max_args))<EOL><DEDENT><DEDENT>", "docstring": "Validate the syntax of the template tag.", "id": "f6336:c0:m6"}
{"signature": "def get_request(self, context):", "body": "if '<STR_LIT>' not in context:<EOL><INDENT>raise ImproperlyConfigured(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(self.tag_name)<EOL>)<EOL><DEDENT>return context['<STR_LIT>']<EOL>", "docstring": "Fetch the request from the context.\n\nThis enforces the use of a RequestProcessor, e.g.\n::\n\n    render_to_response(\"page.html\", context, context_instance=RequestContext(request))", "id": "f6336:c0:m7"}
{"signature": "def get_template_name(self, *tag_args, **tag_kwargs):", "body": "return tag_kwargs.get('<STR_LIT>', self.template_name)<EOL>", "docstring": "Get the template name, by default using the :attr:`template_name` attribute.", "id": "f6336:c1:m1"}
{"signature": "def render_tag(self, context, *tag_args, **tag_kwargs):", "body": "<EOL>if self.as_var:<EOL><INDENT>return BaseAssignmentNode.render_tag(self, context, *tag_args, **tag_kwargs)<EOL><DEDENT>else:<EOL><INDENT>return BaseInclusionNode.render_tag(self, context, *tag_args, **tag_kwargs)<EOL><DEDENT>", "docstring": "Rendering of the tag. It either assigns the value as variable, or renders it.", "id": "f6336:c4:m1"}
{"signature": "@property<EOL><INDENT>def cpu_15min_load(self):<DEDENT>", "body": "if self._data is not None:<EOL><INDENT>return self._data[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL><DEDENT>", "docstring": "Average CPU load past 15 minutes", "id": "f6343:c1:m8"}
{"signature": "def _get_network(self, network_id):", "body": "if self._data is not None:<EOL><INDENT>for network in self._data[\"<STR_LIT>\"]:<EOL><INDENT>if network[\"<STR_LIT>\"] == network_id:<EOL><INDENT>return network<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Function to get specific network (eth0, total, etc)", "id": "f6343:c1:m16"}
{"signature": "@property<EOL><INDENT>def cpu_other_load(self):<DEDENT>", "body": "if self._data is not None:<EOL><INDENT>return self._data[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL><DEDENT>", "docstring": "Other' percentage of the total cpu load", "id": "f6343:c1:m2"}
{"signature": "def memory_available_swap(self, human_readable=True):", "body": "if self._data is not None:<EOL><INDENT>return_data = int(self._data[\"<STR_LIT>\"][\"<STR_LIT>\"]) * <NUM_LIT><EOL>if human_readable:<EOL><INDENT>return SynoFormatHelper.bytes_to_readable(<EOL>return_data)<EOL><DEDENT>else:<EOL><INDENT>return return_data<EOL><DEDENT><DEDENT>", "docstring": "Total Available Memory Swap", "id": "f6343:c1:m11"}
{"signature": "@staticmethod<EOL><INDENT>def bytes_to_terrabytes(num):<DEDENT>", "body": "var_tb = num / <NUM_LIT> / <NUM_LIT> / <NUM_LIT> / <NUM_LIT><EOL>return round(var_tb, <NUM_LIT:1>)<EOL>", "docstring": "Converts bytes to terrabytes", "id": "f6343:c0:m3"}
{"signature": "def memory_size(self, human_readable=True):", "body": "if self._data is not None:<EOL><INDENT>return_data = int(self._data[\"<STR_LIT>\"][\"<STR_LIT>\"]) * <NUM_LIT><EOL>if human_readable:<EOL><INDENT>return SynoFormatHelper.bytes_to_readable(<EOL>return_data)<EOL><DEDENT>else:<EOL><INDENT>return return_data<EOL><DEDENT><DEDENT>", "docstring": "Total Memory Size of Synology DSM", "id": "f6343:c1:m10"}
{"signature": "@property<EOL><INDENT>def cpu_system_load(self):<DEDENT>", "body": "if self._data is not None:<EOL><INDENT>return self._data[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL><DEDENT>", "docstring": "System' percentage of the total cpu load", "id": "f6343:c1:m4"}
{"signature": "def memory_available_real(self, human_readable=True):", "body": "if self._data is not None:<EOL><INDENT>return_data = int(self._data[\"<STR_LIT>\"][\"<STR_LIT>\"]) * <NUM_LIT><EOL>if human_readable:<EOL><INDENT>return SynoFormatHelper.bytes_to_readable(<EOL>return_data)<EOL><DEDENT>else:<EOL><INDENT>return return_data<EOL><DEDENT><DEDENT>", "docstring": "Real available memory", "id": "f6343:c1:m13"}
{"signature": "def _encode_credentials(self):", "body": "<EOL>auth = {<EOL>'<STR_LIT>': self.username,<EOL>'<STR_LIT>': self.password,<EOL>}<EOL>return urlencode(auth)<EOL>", "docstring": "Encode user credentials to support special characters.", "id": "f6343:c3:m2"}
{"signature": "def disk_name(self, disk):", "body": "disk = self._get_disk(disk)<EOL>if disk is not None:<EOL><INDENT>return disk[\"<STR_LIT:name>\"]<EOL><DEDENT>", "docstring": "The name of this disk", "id": "f6343:c2:m13"}
{"signature": "def _execute_get_url(self, request_url, append_sid=True):", "body": "<EOL>self._debuglog(\"<STR_LIT>\" + request_url + \"<STR_LIT:'>\")<EOL>if append_sid:<EOL><INDENT>self._debuglog(\"<STR_LIT>\" +<EOL>self.access_token + \"<STR_LIT>\")<EOL>request_url = \"<STR_LIT>\" % (<EOL>request_url, self.access_token)<EOL><DEDENT>try:<EOL><INDENT>resp = self._session.get(request_url)<EOL>self._debuglog(\"<STR_LIT>\" + str(resp.status_code))<EOL>if resp.status_code == <NUM_LIT:200>:<EOL><INDENT>json_data = json.loads(resp.text)<EOL>if json_data[\"<STR_LIT:success>\"]:<EOL><INDENT>self._debuglog(\"<STR_LIT>\")<EOL>self._debuglog(str(json_data))<EOL>return json_data<EOL><DEDENT>else:<EOL><INDENT>if json_data[\"<STR_LIT:error>\"][\"<STR_LIT:code>\"] in {<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>}:<EOL><INDENT>self._debuglog(\"<STR_LIT>\" +<EOL>str(json_data[\"<STR_LIT:error>\"][\"<STR_LIT:code>\"]))<EOL>self._session_error = True<EOL><DEDENT>else:<EOL><INDENT>self._debuglog(\"<STR_LIT>\" + resp.text)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>except:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Function to execute and handle a GET request", "id": "f6343:c3:m5"}
{"signature": "def update(self):", "body": "if self._utilisation is not None:<EOL><INDENT>api = \"<STR_LIT>\"<EOL>url = \"<STR_LIT>\" % (<EOL>self.base_url,<EOL>api,<EOL>self.access_token)<EOL>self._utilisation.update(self._get_url(url))<EOL><DEDENT>if self._storage is not None:<EOL><INDENT>api = \"<STR_LIT>\"<EOL>url = \"<STR_LIT>\" % (<EOL>self.base_url,<EOL>api,<EOL>self.access_token)<EOL>self._storage.update(self._get_url(url))<EOL><DEDENT>", "docstring": "Updates the various instanced modules", "id": "f6343:c3:m6"}
{"signature": "@property<EOL><INDENT>def disks(self):<DEDENT>", "body": "if self._data is not None:<EOL><INDENT>disks = []<EOL>for disk in self._data[\"<STR_LIT>\"]:<EOL><INDENT>disks.append(disk[\"<STR_LIT:id>\"])<EOL><DEDENT>return disks<EOL><DEDENT>", "docstring": "Returns all available (internal) disks", "id": "f6343:c2:m11"}
{"signature": "def volume_device_type(self, volume):", "body": "volume = self._get_volume(volume)<EOL>if volume is not None:<EOL><INDENT>return volume[\"<STR_LIT>\"]<EOL><DEDENT>", "docstring": "Returns the volume type (RAID1, RAID2, etc)", "id": "f6343:c2:m5"}
{"signature": "@staticmethod<EOL><INDENT>def bytes_to_readable(num):<DEDENT>", "body": "if num < <NUM_LIT>:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>elif num < <NUM_LIT>:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>for unit in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>if abs(num) < <NUM_LIT>:<EOL><INDENT>return \"<STR_LIT>\" % (num, unit)<EOL><DEDENT>num /= <NUM_LIT><EOL><DEDENT>return \"<STR_LIT>\" % (num, '<STR_LIT>')<EOL>", "docstring": "Converts bytes to a human readable format", "id": "f6343:c0:m0"}
{"signature": "def volume_size_total(self, volume, human_readable=True):", "body": "volume = self._get_volume(volume)<EOL>if volume is not None:<EOL><INDENT>return_data = int(volume[\"<STR_LIT:size>\"][\"<STR_LIT>\"])<EOL>if human_readable:<EOL><INDENT>return SynoFormatHelper.bytes_to_readable(<EOL>return_data)<EOL><DEDENT>else:<EOL><INDENT>return return_data<EOL><DEDENT><DEDENT>", "docstring": "Total size of volume", "id": "f6343:c2:m6"}
{"signature": "def volume_disk_temp_max(self, volume):", "body": "volume = self._get_volume(volume)<EOL>if volume is not None:<EOL><INDENT>vol_disks = volume[\"<STR_LIT>\"]<EOL>if vol_disks is not None:<EOL><INDENT>max_temp = <NUM_LIT:0><EOL>for vol_disk in vol_disks:<EOL><INDENT>disk_temp = self.disk_temp(vol_disk)<EOL>if disk_temp is not None and disk_temp > max_temp:<EOL><INDENT>max_temp = disk_temp<EOL><DEDENT><DEDENT>return max_temp<EOL><DEDENT><DEDENT>", "docstring": "Maximum temperature of all disks making up the volume", "id": "f6343:c2:m10"}
{"signature": "@property<EOL><INDENT>def storage(self):<DEDENT>", "body": "if self._storage is None:<EOL><INDENT>api = \"<STR_LIT>\"<EOL>url = \"<STR_LIT>\" % (<EOL>self.base_url,<EOL>api)<EOL>self._storage = SynoStorage(self._get_url(url))<EOL><DEDENT>return self._storage<EOL>", "docstring": "Getter for various Storage variables", "id": "f6343:c3:m8"}
{"signature": "def disk_device(self, disk):", "body": "disk = self._get_disk(disk)<EOL>if disk is not None:<EOL><INDENT>return disk[\"<STR_LIT>\"]<EOL><DEDENT>", "docstring": "The mount point of this disk", "id": "f6343:c2:m14"}
{"signature": "def to_python_source(classes, indent=DEFAULT_INDENT):", "body": "return header_source() + \"<STR_LIT:\\n>\" + classes_source(classes, indent)<EOL>", "docstring": "Convert a set of pyschemas to executable python source code\n\n    Currently supports all built-in types for basic usage.\n\n    Notably not supported:\n    * Maintaining class hierarchy\n    * Methods, properties and non-field attributes\n    * SELF-references", "id": "f6344:m0"}
{"signature": "def header_source():", "body": "return (<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL>", "docstring": "Get the required header for generated source", "id": "f6344:m4"}
{"signature": "def repr_vars(self):", "body": "d = OrderedDict()<EOL>d[\"<STR_LIT>\"] = repr(self.nullable)<EOL>d[\"<STR_LIT:default>\"] = repr(self.default)<EOL>if self.description is not None:<EOL><INDENT>d[\"<STR_LIT:description>\"] = repr(self.description)<EOL><DEDENT>return d<EOL>", "docstring": "Return a dictionary the field definition\n\n        Should contain all fields that are required for the definition of this field in a pyschema class", "id": "f6353:c5:m1"}
{"signature": "def to_json_compatible(record):", "body": "d = {}<EOL>for fname, f in record._fields.iteritems():<EOL><INDENT>val = getattr(record, fname)<EOL>if val is not None:<EOL><INDENT>d[fname] = f.dump(val)<EOL><DEDENT><DEDENT>return d<EOL>", "docstring": "Dump record in json-encodable object format", "id": "f6353:m4"}
{"signature": "def from_json_compatible(schema, dct):", "body": "kwargs = {}<EOL>for key in dct:<EOL><INDENT>field_type = schema._fields.get(key)<EOL>if field_type is None:<EOL><INDENT>raise ParseError(\"<STR_LIT>\" % (schema.__name__, key))<EOL><DEDENT>kwargs[key] = field_type.load(dct[key])<EOL><DEDENT>return schema(**kwargs)<EOL>", "docstring": "Load from json-encodable", "id": "f6353:m5"}
{"signature": "def serialize_validate(self, valid_record):", "body": "schema = jsonschema.get_root_schema_dict(valid_record)<EOL>record_json = jsonschema.dumps(valid_record)<EOL>record_dict = json.loads(record_json)<EOL>validate(record_dict, schema)<EOL>", "docstring": "Serialize and validate a record\n\n        The record is dumped to JSON and then loaded into a Python dictionary,\n        which is checked against the known schema", "id": "f6358:c5:m0"}
{"signature": "def get_root_schema_dict(record):", "body": "state = SchemaGeneratorState()<EOL>schema = get_schema_dict(record, state)<EOL>del state.record_schemas[record._schema_name]<EOL>if state.record_schemas:<EOL><INDENT>schema['<STR_LIT>'] = dict()<EOL>for name, sub_schema in state.record_schemas.iteritems():<EOL><INDENT>schema['<STR_LIT>'][name] = sub_schema<EOL><DEDENT><DEDENT>return schema<EOL>", "docstring": "Return a root jsonschema for a given record\n\n    A root schema includes the $schema attribute and all sub-record\n    schemas and definitions.", "id": "f6373:m1"}
{"signature": "def mr_writer(job, outputs, output_stream,<EOL>stderr=sys.stderr, dumps=core.dumps):", "body": "for output in outputs:<EOL><INDENT>try:<EOL><INDENT>print(dumps(output), file=output_stream)<EOL><DEDENT>except core.ParseError as e:<EOL><INDENT>print(e, file=stderr)<EOL>raise<EOL><DEDENT><DEDENT>", "docstring": "Writes a stream of json serialised pyschema Records to a file object\n\n    Can be used as job.writer in luigi.hadoop.JobTask", "id": "f6378:m1"}
{"signature": "def parse_schema_string(schema_string):", "body": "if isinstance(schema_string, str):<EOL><INDENT>schema_string = schema_string.decode(\"<STR_LIT:utf8>\")<EOL><DEDENT>schema_struct = json.loads(schema_string)<EOL>return AvroSchemaParser().parse_schema_struct(schema_struct)<EOL>", "docstring": "Load and return a PySchema class from an avsc string", "id": "f6379:m0"}
{"signature": "def select_renderer(request: web.Request, renderers: OrderedDict, force=True):", "body": "header = request.headers.get('<STR_LIT>', '<STR_LIT>')<EOL>best_match = mimeparse.best_match(renderers.keys(), header)<EOL>if not best_match or best_match not in renderers:<EOL><INDENT>if force:<EOL><INDENT>return tuple(renderers.items())[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>raise web.HTTPNotAcceptable<EOL><DEDENT><DEDENT>return best_match, renderers[best_match]<EOL>", "docstring": "Given a request, a list of renderers, and the ``force`` configuration\noption, return a two-tuple of:\n(media type, render callable). Uses mimeparse to find the best media\ntype match from the ACCEPT header.", "id": "f6387:m0"}
{"signature": "@contextmanager<EOL>def add_resource_context(<EOL>app: web.Application, module=None,<EOL>url_prefix: str=None, name_prefix: str=None, make_resource=lambda cls: cls()<EOL>):", "body": "assert isinstance(app.router, ResourceRouter), '<STR_LIT>'<EOL>if isinstance(module, (str, bytes)):<EOL><INDENT>module = importlib.import_module(module)<EOL><DEDENT>def get_base_name(resource, method_name, names):<EOL><INDENT>return names.get(method_name,<EOL>app.router.get_default_handler_name(resource, method_name))<EOL><DEDENT>default_make_resource = make_resource<EOL>def add_route(<EOL>path: str, resource, names: Mapping=None, make_resource=None<EOL>):<EOL><INDENT>make_resource = make_resource or default_make_resource<EOL>names = names or {}<EOL>if isinstance(resource, (str, bytes)):<EOL><INDENT>if not module:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>resource_cls = getattr(module, resource)<EOL>resource = make_resource(resource_cls)<EOL><DEDENT>path = make_path(path, url_prefix)<EOL>if name_prefix:<EOL><INDENT>supported_method_names = get_supported_method_names(resource)<EOL>names = {<EOL>method_name: '<STR_LIT:.>'.join(<EOL>(name_prefix, get_base_name(resource, method_name, names=names))<EOL>)<EOL>for method_name in supported_method_names<EOL>}<EOL><DEDENT>return app.router.add_resource_object(path, resource, names=names)<EOL><DEDENT>yield add_route<EOL>", "docstring": "Context manager which yields a function for adding multiple resources from a given module\n    to an app using `ResourceRouter <aiohttp_utils.routing.ResourceRouter>`.\n\n    Example:\n\n    .. code-block:: python\n\n        # myapp/articles/views.py\n        class ArticleList:\n            async def get(self, request):\n                return web.Response(b'article list...')\n\n        class ArticleDetail:\n            async def get(self, request):\n                return web.Response(b'article detail...')\n\n    .. code-block:: python\n\n        # myapp/app.py\n        from myapp.articles import views\n\n        with add_resource_context(app, url_prefix='/api/') as route:\n            route('/articles/', views.ArticleList())\n            route('/articles/{pk}', views.ArticleDetail())\n\n        app.router['ArticleList:get'].url()  # /api/articles/\n        app.router['ArticleDetail:get'].url(parts={'pk': 42})  # /api/articles/42\n\n    If you prefer, you can also pass module and class names as strings. ::\n\n        with add_resource_context(app, module='myapp.articles.views',\n                                  url_prefix='/api/') as route:\n            route('/articles/', 'ArticleList')\n            route('/articles/{pk}', 'ArticleDetail')\n\n    .. note::\n        If passing class names, the resource classes will be instantiated with no\n        arguments. You can change this behavior by overriding ``make_resource``.\n\n        .. code-block:: python\n\n            # myapp/authors/views.py\n            class AuthorList:\n                def __init__(self, db):\n                    self.db = db\n\n                async def get(self, request):\n                    # Fetch authors from self.db...\n\n        .. code-block:: python\n\n            # myapp/app.py\n            from myapp.database import db\n\n            with add_resource_context(app, module='myapp.authors.views',\n                                    url_prefix='/api/',\n                                    make_resource=lambda cls: cls(db=db)) as route:\n                route('/authors/', 'AuthorList')\n\n    :param app: Application to add routes to.\n    :param resource: Import path to module (str) or module object\n        which contains the resource classes.\n    :param url_prefix: Prefix to prepend to all route paths.\n    :param name_prefix: Prefix to prepend to all route names.\n    :param make_resource: Function which receives a resource class and returns\n        a resource instance.", "id": "f6388:m3"}
{"signature": "@register.tag<EOL>def systemjs_import(parser, token):", "body": "return SystemImportNode.handle_token(parser, token)<EOL>", "docstring": "Import a Javascript module via SystemJS, bundling the app.\n\nSyntax::\n\n    {% systemjs_import 'path/to/file' %}\n\nExample::\n\n    {% systemjs_import 'mydjangoapp/js/myapp' %}\n\nWhich would be rendered like::\n\n    <script type=\"text/javascript\" src=\"/static/CACHE/mydjangoapp.js.min.myapp.js\"></script>\n\nwhere /static/CACHE can be configured through settings.\n\nIn DEBUG mode, the result would be\n\n    <script type=\"text/javascript\">System.import('mydjangoapp/js/myapp.js');</script>", "id": "f6412:m0"}
{"signature": "def render(self, context):", "body": "module_path = self.path.resolve(context)<EOL>if not settings.SYSTEMJS_ENABLED:<EOL><INDENT>if settings.SYSTEMJS_DEFAULT_JS_EXTENSIONS:<EOL><INDENT>name, ext = posixpath.splitext(module_path)<EOL>if not ext:<EOL><INDENT>module_path = '<STR_LIT>'.format(module_path)<EOL><DEDENT><DEDENT>if settings.SYSTEMJS_SERVER_URL:<EOL><INDENT>tpl = \"\"\"<STR_LIT>\"\"\"<EOL><DEDENT>else:<EOL><INDENT>tpl = \"\"\"<STR_LIT>\"\"\"<EOL><DEDENT>return tpl.format(app=module_path, url=settings.SYSTEMJS_SERVER_URL)<EOL><DEDENT>rel_path = System.get_bundle_path(module_path)<EOL>url = staticfiles_storage.url(rel_path)<EOL>tag_attrs = {'<STR_LIT:type>': '<STR_LIT>'}<EOL>for key, value in self.tag_attrs.items():<EOL><INDENT>if not isinstance(value, bool):<EOL><INDENT>value = value.resolve(context)<EOL><DEDENT>tag_attrs[key] = value<EOL><DEDENT>return \"\"\"<STR_LIT>\"\"\".format(<EOL>url=url, attrs=flatatt(tag_attrs)<EOL>)<EOL>", "docstring": "Build the filepath by appending the extension.", "id": "f6412:c0:m1"}
{"signature": "def load_systemjs_manifest(self):", "body": "<EOL>_manifest_name = self.manifest_name<EOL>self.manifest_name = self.systemjs_manifest_name<EOL>bundle_files = self.load_manifest()<EOL>self.manifest_name = _manifest_name<EOL>for file, hashed_file in bundle_files.copy().items():<EOL><INDENT>if not self.exists(file) or not self.exists(hashed_file):<EOL><INDENT>del bundle_files[file]<EOL><DEDENT><DEDENT>return bundle_files<EOL>", "docstring": "Load the existing systemjs manifest and remove any entries that no longer\nexist on the storage.", "id": "f6415:c0:m1"}
{"signature": "def __init__(self, system, app, **options):", "body": "self.system = system<EOL>self.app = app<EOL>options.setdefault('<STR_LIT>', settings.SYSTEMJS_JSPM_EXECUTABLE)<EOL>self.opts = options<EOL>bundle_cmd = self.get_bundle_sfx_cmd() if self.opts.get('<STR_LIT>') else '<STR_LIT>'<EOL>self.command = '<STR_LIT>' + bundle_cmd + '<STR_LIT>'<EOL>self.stdout = self.stdin = self.stderr = subprocess.PIPE<EOL>", "docstring": "Initialize a SystemBundle object.\n\n:param system: a System instance that holds the non-bundle specific\nmeta information (such as jspm version, configuration)\n\n:param app: string, the name of the JS package to bundle. This may be\nmissing the '.js' extension.\n\n:param options: dict containing the bundle-specific options. Possible\noptions:\n    `jspm`: `jspm` executable (if it's not on $PATH, for example)\n    `log`: logging mode for jspm, can be ok|warn|err. Only available\n           for jspm >= 0.16.3\n    `minify`: boolean, whether go generate minified bundles or not\n    `sfx`: boolean, generate a self-executing bundle or not\n    `skip-source-maps: boolean, whether to generate source maps or not", "id": "f6416:c2:m0"}
{"signature": "def get_git_changeset():", "body": "repo_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))<EOL>git_log = subprocess.Popen(<EOL>'<STR_LIT>',<EOL>stdout=subprocess.PIPE, stderr=subprocess.PIPE,<EOL>shell=True, cwd=repo_dir, universal_newlines=True<EOL>)<EOL>timestamp = git_log.communicate()[<NUM_LIT:0>]<EOL>try:<EOL><INDENT>timestamp = datetime.datetime.utcfromtimestamp(int(timestamp))<EOL><DEDENT>except ValueError:<EOL><INDENT>return None<EOL><DEDENT>return timestamp.strftime('<STR_LIT>')<EOL>", "docstring": "Returns a numeric identifier of the latest git changeset.\n\n    The result is the UTC timestamp of the changeset in YYYYMMDDHHMMSS format.\n    This value isn't guaranteed to be unique, but collisions are very unlikely,\n    so it's sufficient for generating the development version numbers.", "id": "f6418:m3"}
{"signature": "def merge_(self, merge_dct):", "body": "for k, v in merge_dct.items():<EOL><INDENT>if (k in self and isinstance(self[k], dict) and isinstance(merge_dct[k], collections.Mapping)):<EOL><INDENT>self[k].merge_(dicto(merge_dct[k]))<EOL><DEDENT>else:<EOL><INDENT>self[k] = merge_dct[k]<EOL><DEDENT><DEDENT>return self<EOL>", "docstring": "Recursive dict merge. Inspired by :meth:``dict.update()``, instead of\n        updating only top-level keys, dict_merge recurses down into dicts nested\n        to an arbitrary depth, updating keys. The ``merge_dct`` is merged into\n        ``self``.\n        :param self: dict onto which the merge is executed\n        :param merge_dct: self merged into self\n        :return: None", "id": "f6434:c0:m4"}
{"signature": "def merge(dicto, other):", "body": "if not isinstance(dicto, Dicto):<EOL><INDENT>dicto = Dicto(dicto)<EOL><DEDENT>if not isinstance(other, Dicto):<EOL><INDENT>other = Dicto(other)<EOL><DEDENT>for k, v in other.__dict__.items():<EOL><INDENT>if k in dicto and isinstance(dicto[k], Dicto) and isinstance(other[k], Dicto):<EOL><INDENT>dicto[k] = merge(dicto[k], other[k])<EOL><DEDENT>else:<EOL><INDENT>dicto[k] = other[k]<EOL><DEDENT><DEDENT>return dicto<EOL>", "docstring": "Recursive dict merge. Inspired by :meth:``dict.update()``, instead of\n    updating only top-level keys, dict_merge recurses down into dicts nested\n    to an arbitrary depth, updating keys. The ``other`` is merged into\n    ``dicto``.\n    :param dicto: dict onto which the merge is executed\n    :param other: dict that is going to merged into dicto\n    :return: None", "id": "f6436:m2"}
{"signature": "def visualize(spect, frequencies, title=\"<STR_LIT>\"):", "body": "i = <NUM_LIT:0><EOL>for freq, (index, row) in zip(frequencies[::-<NUM_LIT:1>], enumerate(spect[::-<NUM_LIT:1>, :])):<EOL><INDENT>plt.subplot(spect.shape[<NUM_LIT:0>], <NUM_LIT:1>, index + <NUM_LIT:1>)<EOL>if i == <NUM_LIT:0>:<EOL><INDENT>plt.title(title)<EOL>i += <NUM_LIT:1><EOL><DEDENT>plt.ylabel(\"<STR_LIT>\".format(freq))<EOL>plt.plot(row)<EOL><DEDENT>plt.show()<EOL>", "docstring": "Visualize the result of calling seg.filter_bank() for any number of filters", "id": "f6451:m0"}
{"signature": "def generate_frames_as_segments(self, frame_duration_ms, zero_pad=True):", "body": "for frame in self.generate_frames(frame_duration_ms, zero_pad=zero_pad):<EOL><INDENT>seg = AudioSegment(pydub.AudioSegment(data=frame.bytes, sample_width=self.sample_width,<EOL>frame_rate=self.frame_rate, channels=self.channels), self.name)<EOL>yield seg, frame.timestamp<EOL><DEDENT>", "docstring": "Does the same thing as `generate_frames`, but yields tuples of (AudioSegment, timestamp) instead of Frames.", "id": "f6454:c0:m23"}
{"signature": "def _execute_sox_cmd(self, cmd, console_output=False):", "body": "on_windows = platform.system().lower() == \"<STR_LIT>\"<EOL>def _get_random_tmp_file():<EOL><INDENT>if on_windows:<EOL><INDENT>rand_string = \"<STR_LIT>\".join(random.choice(string.ascii_uppercase + string.digits) for _ in range(<NUM_LIT:8>))<EOL>tmp = self.name + \"<STR_LIT:_>\" + rand_string<EOL>WinTempFile = collections.namedtuple(\"<STR_LIT>\", \"<STR_LIT:name>\")<EOL>tmp = WinTempFile(tmp)<EOL><DEDENT>else:<EOL><INDENT>tmp = tempfile.NamedTemporaryFile()<EOL><DEDENT>return tmp<EOL><DEDENT>tmp = _get_random_tmp_file()<EOL>othertmp = _get_random_tmp_file()<EOL>self.export(tmp.name, format=\"<STR_LIT>\")<EOL>stdout = stderr = subprocess.PIPE if console_output else subprocess.DEVNULL<EOL>command = cmd.format(inputfile=tmp.name, outputfile=othertmp.name)<EOL>res = subprocess.call(command.split('<STR_LIT:U+0020>'), stdout=stdout, stderr=stderr)<EOL>assert res == <NUM_LIT:0>, \"<STR_LIT>\"<EOL>other = AudioSegment(pydub.AudioSegment.from_wav(othertmp.name), self.name)<EOL>if on_windows:<EOL><INDENT>os.remove(tmp.name)<EOL>os.remove(othertmp.name)<EOL><DEDENT>else:<EOL><INDENT>tmp.close()<EOL>othertmp.close()<EOL><DEDENT>return other<EOL>", "docstring": "Executes a Sox command in a platform-independent manner.\n\n`cmd` must be a format string that includes {inputfile} and {outputfile}.", "id": "f6454:c0:m19"}
{"signature": "def filter_bank(self, lower_bound_hz=<NUM_LIT:50>, upper_bound_hz=<NUM_LIT>, nfilters=<NUM_LIT>, mode='<STR_LIT>'):", "body": "<EOL>data = self.to_numpy_array()<EOL>if mode.lower() == '<STR_LIT>':<EOL><INDENT>frequencies = librosa.core.mel_frequencies(n_mels=nfilters, fmin=lower_bound_hz, fmax=upper_bound_hz)<EOL><DEDENT>elif mode.lower() == '<STR_LIT>':<EOL><INDENT>frequencies = np.linspace(lower_bound_hz, upper_bound_hz, num=nfilters, endpoint=True)<EOL><DEDENT>elif mode.lower() == '<STR_LIT>':<EOL><INDENT>start = np.log10(lower_bound_hz)<EOL>stop = np.log10(upper_bound_hz)<EOL>frequencies = np.logspace(start, stop, num=nfilters, endpoint=True, base=<NUM_LIT>)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(mode))<EOL><DEDENT>rows = [filters.bandpass_filter(data, freq*<NUM_LIT>, freq*<NUM_LIT>, self.frame_rate) for freq in frequencies]<EOL>rows = np.array(rows)<EOL>spect = np.vstack(rows)<EOL>return spect, frequencies<EOL>", "docstring": "Returns a numpy array of shape (nfilters, nsamples), where each\nrow of data is the result of bandpass filtering the audiosegment\naround a particular frequency. The frequencies are\nspaced from `lower_bound_hz` to `upper_bound_hz` and are returned with\nthe np array. The particular spacing of the frequencies depends on `mode`,\nwhich can be either: 'linear', 'mel', or 'log'.\n\n.. note:: This method is an approximation of a gammatone filterbank\n          until I get around to writing an actual gammatone filterbank\n          function.\n\n.. code-block:: python\n\n    # Example usage\n    import audiosegment\n    import matplotlib.pyplot as plt\n    import numpy as np\n\n    def visualize(spect, frequencies, title=\"\"):\n        # Visualize the result of calling seg.filter_bank() for any number of filters\n        i = 0\n        for freq, (index, row) in zip(frequencies[::-1], enumerate(spect[::-1, :])):\n            plt.subplot(spect.shape[0], 1, index + 1)\n            if i == 0:\n                plt.title(title)\n                i += 1\n            plt.ylabel(\"{0:.0f}\".format(freq))\n            plt.plot(row)\n        plt.show()\n\n    seg = audiosegment.from_file(\"some_audio.wav\").resample(sample_rate_Hz=24000, sample_width=2, channels=1)\n    spec, frequencies = seg.filter_bank(nfilters=5)\n    visualize(spec, frequencies)\n\n.. image:: images/filter_bank.png\n\n:param lower_bound_hz:  The lower bound of the frequencies to use in the bandpass filters.\n:param upper_bound_hz:  The upper bound of the frequencies to use in the bandpass filters.\n:param nfilters:        The number of filters to apply. This will determine which frequencies\n                        are used as well, as they are interpolated between\n                        `lower_bound_hz` and `upper_bound_hz` based on `mode`.\n:param mode:            The way the frequencies are spaced. Options are: `linear`, in which case\n                        the frequencies are linearly interpolated between `lower_bound_hz` and\n                        `upper_bound_hz`, `mel`, in which case the mel frequencies are used,\n                        or `log`, in which case they are log-10 spaced.\n:returns:               A numpy array of the form (nfilters, nsamples), where each row is the\n                        audiosegment, bandpass-filtered around a particular frequency,\n                        and the list of frequencies. I.e., returns (spec, freqs).", "id": "f6454:c0:m14"}
{"signature": "def __getstate__(self):", "body": "return {'<STR_LIT:name>': self.name, '<STR_LIT>': self.seg}<EOL>", "docstring": "Serializes into a dict for the pickle protocol.\n\n:returns: The dict to pickle.", "id": "f6454:c0:m28"}
{"signature": "def reduce(self, others):", "body": "ret = AudioSegment(self.seg, self.name)<EOL>selfdata = [self.seg._data]<EOL>otherdata = [o.seg._data for o in others]<EOL>ret.seg._data = b'<STR_LIT>'.join(selfdata + otherdata)<EOL>return ret<EOL>", "docstring": "Reduces others into this one by concatenating all the others onto this one and\nreturning the result. Does not modify self, instead, makes a copy and returns that.\n\n:param others: The other AudioSegment objects to append to this one.\n:returns: The concatenated result.", "id": "f6454:c0:m26"}
{"signature": "def __setstate__(self, d):", "body": "self.__dict__.update(d)<EOL>", "docstring": "Deserializes from a dict for the pickle protocol.\n\n:param d: The dict to unpickle from.", "id": "f6454:c0:m29"}
{"signature": "def generate_frames(self, frame_duration_ms, zero_pad=True):", "body": "Frame = collections.namedtuple(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>bytes_per_frame = int(self.frame_rate * (frame_duration_ms / <NUM_LIT:1000>) * self.sample_width)<EOL>offset = <NUM_LIT:0>  <EOL>timestamp = <NUM_LIT:0.0>  <EOL>frame_duration_s = (bytes_per_frame / self.frame_rate) / self.sample_width<EOL>while offset + bytes_per_frame < len(self.raw_data):<EOL><INDENT>yield Frame(self.raw_data[offset:offset + bytes_per_frame], timestamp, frame_duration_s)<EOL>timestamp += frame_duration_s<EOL>offset += bytes_per_frame<EOL><DEDENT>if zero_pad:<EOL><INDENT>rest = self.raw_data[offset:]<EOL>zeros = bytes(bytes_per_frame - len(rest))<EOL>yield Frame(rest + zeros, timestamp, frame_duration_s)<EOL><DEDENT>", "docstring": "Yields self's data in chunks of frame_duration_ms.\n\nThis function adapted from pywebrtc's example [https://github.com/wiseman/py-webrtcvad/blob/master/example.py].\n\n:param frame_duration_ms: The length of each frame in ms.\n:param zero_pad: Whether or not to zero pad the end of the AudioSegment object to get all\n                 the audio data out as frames. If not, there may be a part at the end\n                 of the Segment that is cut off (the part will be <= `frame_duration_ms` in length).\n:returns: A Frame object with properties 'bytes (the data)', 'timestamp (start time)', and 'duration'.", "id": "f6454:c0:m22"}
{"signature": "def spectrogram(self, start_s=None, duration_s=None, start_sample=None, num_samples=None,<EOL>window_length_s=None, window_length_samples=None, overlap=<NUM_LIT:0.5>, window=('<STR_LIT>', <NUM_LIT>)):", "body": "if start_s is not None and start_sample is not None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if duration_s is not None and num_samples is not None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if window_length_s is not None and window_length_samples is not None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if window_length_s is None and window_length_samples is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if start_s is None and start_sample is None:<EOL><INDENT>start_sample = <NUM_LIT:0><EOL><DEDENT>elif start_s is not None:<EOL><INDENT>start_sample = int(round(start_s * self.frame_rate))<EOL><DEDENT>if duration_s is None and num_samples is None:<EOL><INDENT>num_samples = len(self.get_array_of_samples()) - int(start_sample)<EOL><DEDENT>elif duration_s is not None:<EOL><INDENT>num_samples = int(round(duration_s * self.frame_rate))<EOL><DEDENT>if window_length_s is not None:<EOL><INDENT>window_length_samples = int(round(window_length_s * self.frame_rate))<EOL><DEDENT>if start_sample + num_samples > len(self.get_array_of_samples()):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>arr = self.to_numpy_array()[start_sample:start_sample+num_samples]<EOL>fs, ts, sxx = signal.spectrogram(arr, self.frame_rate, scaling='<STR_LIT>', nperseg=window_length_samples,<EOL>noverlap=int(round(overlap * window_length_samples)),<EOL>mode='<STR_LIT>', window=window)<EOL>return fs, ts, sxx<EOL>", "docstring": "Does a series of FFTs from `start_s` or `start_sample` for `duration_s` or `num_samples`.\nEffectively, transforms a slice of the AudioSegment into the frequency domain across different\ntime bins.\n\n.. code-block:: python\n\n    # Example for plotting a spectrogram using this function\n    import audiosegment\n    import matplotlib.pyplot as plt\n\n    #...\n    seg = audiosegment.from_file(\"somebodytalking.wav\")\n    freqs, times, amplitudes = seg.spectrogram(window_length_s=0.03, overlap=0.5)\n    amplitudes = 10 * np.log10(amplitudes + 1e-9)\n\n    # Plot\n    plt.pcolormesh(times, freqs, amplitudes)\n    plt.xlabel(\"Time in Seconds\")\n    plt.ylabel(\"Frequency in Hz\")\n    plt.show()\n\n.. image:: images/spectrogram.png\n\n:param start_s: The start time. Starts at the beginning if neither this nor `start_sample` is specified.\n:param duration_s: The duration of the spectrogram in seconds. Goes to the end if neither this nor\n                   `num_samples` is specified.\n:param start_sample: The index of the first sample to use. Starts at the beginning if neither this nor\n                     `start_s` is specified.\n:param num_samples: The number of samples in the spectrogram. Goes to the end if neither this nor\n                    `duration_s` is specified.\n:param window_length_s: The length of each FFT in seconds. If the total number of samples in the spectrogram\n                        is not a multiple of the window length in samples, the last window will be zero-padded.\n:param window_length_samples: The length of each FFT in number of samples. If the total number of samples in the\n                        spectrogram is not a multiple of the window length in samples, the last window will\n                        be zero-padded.\n:param overlap: The fraction of each window to overlap.\n:param window: See Scipy's spectrogram-function_.\n               This parameter is passed as-is directly into the Scipy spectrogram function. It's documentation is reproduced here:\n               Desired window to use. If window is a string or tuple, it is passed to get_window to generate the window values,\n               which are DFT-even by default. See get_window for a list of windows and required parameters.\n               If window is array_like it will be used directly as the window and its length must be\n               `window_length_samples`.\n               Defaults to a Tukey window with shape parameter of 0.25.\n:returns: Three np.ndarrays: The frequency values in Hz (the y-axis in a spectrogram), the time values starting\n          at start time and then increasing by `duration_s` each step (the x-axis in a spectrogram), and\n          the dB of each time/frequency bin as a 2D array of shape [len(frequency values), len(duration)].\n:raises ValueError: If `start_s` and `start_sample` are both specified, if `duration_s` and `num_samples` are both\n                    specified, if the first window's duration plus start time lead to running off the end\n                    of the AudioSegment, or if `window_length_s` and `window_length_samples` are either\n                    both specified or if they are both not specified.\n\n.. _spectrogram-function: https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.spectrogram.html", "id": "f6454:c0:m31"}
{"signature": "def _update_segmentation_mask(segmentation_mask, onset_fronts, offset_fronts, onset_front_id, offset_front_id_most_overlap):", "body": "<EOL>onset_front_overlap, offset_front_overlap = _get_consecutive_and_overlapping_fronts(onset_fronts, offset_fronts, onset_front_id, offset_front_id_most_overlap)<EOL>onset_front = _get_front_idxs_from_id(onset_fronts, onset_front_id)<EOL>offset_front = _get_front_idxs_from_id(offset_fronts, offset_front_id_most_overlap)<EOL>msg = \"<STR_LIT>\".format(<EOL>onset_front, offset_front, onset_front_overlap, offset_front_overlap<EOL>)<EOL>assert onset_front_overlap, msg<EOL>assert offset_front_overlap, msg<EOL>onset_front = onset_front_overlap<EOL>offset_front = offset_front_overlap<EOL>flow_on, _slow_on = onset_front[<NUM_LIT:0>]<EOL>fhigh_on, _shigh_on = onset_front[-<NUM_LIT:1>]<EOL>flow_off, _slow_off = offset_front[<NUM_LIT:0>]<EOL>fhigh_off, _shigh_off = offset_front[-<NUM_LIT:1>]<EOL>flow = max(flow_on, flow_off)<EOL>fhigh = min(fhigh_on, fhigh_off)<EOL>for fidx, _freqchan in enumerate(segmentation_mask[flow:fhigh + <NUM_LIT:1>, :], start=flow):<EOL><INDENT>assert fidx >= flow, \"<STR_LIT>\".format(fidx, flow)<EOL>assert (fidx - flow) < len(onset_front), \"<STR_LIT>\".format(<EOL>fidx, flow, len(onset_front), onset_front<EOL>)<EOL>assert (fidx - flow) < len(offset_front), \"<STR_LIT>\".format(<EOL>fidx, flow, len(offset_front), offset_front<EOL>)<EOL>_, beg = onset_front[fidx - flow]<EOL>_, end = offset_front[fidx - flow]<EOL>if beg > end:<EOL><INDENT>end, beg = beg, end<EOL><DEDENT>assert end >= beg<EOL>segmentation_mask[fidx, beg:end + <NUM_LIT:1>] = onset_front_id<EOL>onset_fronts[fidx, (beg + <NUM_LIT:1>):(end + <NUM_LIT:1>)] = <NUM_LIT:0><EOL>offset_fronts[fidx, (beg + <NUM_LIT:1>):(end + <NUM_LIT:1>)] = <NUM_LIT:0><EOL><DEDENT>nfreqs_used_in_onset_front = (fidx - flow) + <NUM_LIT:1><EOL>indexes = np.arange(flow, fhigh + <NUM_LIT:1>, <NUM_LIT:1>, dtype=np.int64)<EOL>onset_front_sample_idxs_across_freqs = np.array([s for _, s in onset_front])<EOL>onset_front_sample_idxs_across_freqs_up_to_break = onset_front_sample_idxs_across_freqs[:nfreqs_used_in_onset_front]<EOL>offset_front_sample_idxs_across_freqs = np.array([s for _, s in offset_front])<EOL>offset_front_sample_idxs_across_freqs_up_to_break = offset_front_sample_idxs_across_freqs[:nfreqs_used_in_onset_front]<EOL>offset_fronts[indexes[:nfreqs_used_in_onset_front], offset_front_sample_idxs_across_freqs_up_to_break] = <NUM_LIT:0><EOL>onset_fronts[indexes[:nfreqs_used_in_onset_front], onset_front_sample_idxs_across_freqs_up_to_break] = <NUM_LIT:0><EOL>whole_onset_front_matched = onset_front_id not in np.unique(onset_fronts)<EOL>return whole_onset_front_matched<EOL>", "docstring": "Returns an updated segmentation mask such that the input `segmentation_mask` has been updated by segmenting between\n`onset_front_id` and `offset_front_id`, as found in `onset_fronts` and `offset_fronts`, respectively.\n\nThis function also returns the onset_fronts and offset_fronts matrices, updated so that any fronts that are of\nless than 3 channels wide are removed.\n\nThis function also returns a boolean value indicating whether the onset channel went to completion.\n\nSpecifically, segments by doing the following:\n\n- Going across frequencies in the onset_front,\n- add the segment mask ID (the onset front ID) to all samples between the onset_front and the offset_front,\n  if the offset_front is in that frequency.\n\nPossible scenarios:\n\nFronts line up completely:\n\n::\n\n    |   |       S S S\n    |   |  =>   S S S\n    |   |       S S S\n    |   |       S S S\n\nOnset front starts before offset front:\n\n::\n\n    |           |\n    |   |       S S S\n    |   |  =>   S S S\n    |   |       S S S\n\nOnset front ends after offset front:\n\n::\n\n    |   |       S S S\n    |   |  =>   S S S\n    |   |       S S S\n    |           |\n\nOnset front starts before and ends after offset front:\n\n::\n\n    |           |\n    |   |  =>   S S S\n    |   |       S S S\n    |           |\n\nThe above three options in reverse:\n\n::\n\n        |       |S S|           |\n    |S S|       |S S|       |S S|\n    |S S|       |S S|       |S S|\n    |S S|           |           |\n\nThere is one last scenario:\n\n::\n\n    |   |\n    \\   /\n     \\ /\n     / \\\n    |   |\n\nWhere the offset and onset fronts cross one another. If this happens, we simply\nreverse the indices and accept:\n\n::\n\n    |sss|\n    \\sss/\n     \\s/\n     /s\\\n    |sss|\n\nThe other option would be to destroy the offset front from the crossover point on, and\nthen search for a new offset front for the rest of the onset front.", "id": "f6457:m17"}
{"signature": "def _form_onset_offset_fronts(ons_or_offs, sample_rate_hz, threshold_ms=<NUM_LIT:20>):", "body": "threshold_s = threshold_ms / <NUM_LIT:1000><EOL>threshold_samples = sample_rate_hz * threshold_s<EOL>ons_or_offs = np.copy(ons_or_offs)<EOL>claimed = []<EOL>this_id = <NUM_LIT:2><EOL>for frequency_index, row in enumerate(ons_or_offs[:, :]):<EOL><INDENT>ones = np.reshape(np.where(row == <NUM_LIT:1>), (-<NUM_LIT:1>,))<EOL>for top_level_frequency_one_index in ones:<EOL><INDENT>claimed.append((frequency_index, top_level_frequency_one_index))<EOL>found_a_front = False<EOL>for other_frequency_index, other_row in enumerate(ons_or_offs[frequency_index + <NUM_LIT:1>:, :], start=frequency_index + <NUM_LIT:1>):<EOL><INDENT>upper_limit_index = top_level_frequency_one_index + threshold_samples<EOL>lower_limit_index = top_level_frequency_one_index - threshold_samples<EOL>other_ones = np.reshape(np.where(other_row == <NUM_LIT:1>), (-<NUM_LIT:1>,))  <EOL>tmp = np.reshape(np.where((other_ones >= lower_limit_index)  <EOL>& (other_ones <= upper_limit_index)), (-<NUM_LIT:1>,))<EOL>other_ones = other_ones[tmp]  <EOL>if len(other_ones) > <NUM_LIT:0>:<EOL><INDENT>unclaimed_idx = other_ones[<NUM_LIT:0>]  <EOL>claimed.append((other_frequency_index, unclaimed_idx))<EOL><DEDENT>elif len(claimed) < <NUM_LIT:3>:<EOL><INDENT>ons_or_offs[frequency_index, top_level_frequency_one_index] = <NUM_LIT:0><EOL>claimed = []<EOL>break  <EOL><DEDENT>elif len(claimed) >= <NUM_LIT:3>:<EOL><INDENT>found_a_front = True<EOL>claimed_as_indexes = tuple(np.array(claimed).T)<EOL>ons_or_offs[claimed_as_indexes] = this_id<EOL>this_id += <NUM_LIT:1><EOL>claimed = []<EOL>break  <EOL><DEDENT><DEDENT>if len(claimed) >= <NUM_LIT:3>:<EOL><INDENT>claimed_as_indexes = tuple(np.array(claimed).T)<EOL>ons_or_offs[claimed_as_indexes] = this_id<EOL>this_id += <NUM_LIT:1><EOL>claimed = []<EOL><DEDENT>elif found_a_front:<EOL><INDENT>this_id += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>ons_or_offs[frequency_index, top_level_frequency_one_index] = <NUM_LIT:0><EOL>claimed = []<EOL><DEDENT><DEDENT><DEDENT>return ons_or_offs<EOL>", "docstring": "Takes an array of onsets or offsets (shape = [nfrequencies, nsamples], where a 1 corresponds to an on/offset,\nand samples are 0 otherwise), and returns a new array of the same shape, where each 1 has been replaced by\neither a 0, if the on/offset has been discarded, or a non-zero positive integer, such that\neach front within the array has a unique ID - for example, all 2s in the array will be the front for on/offset\nfront 2, and all the 15s will be the front for on/offset front 15, etc.\n\nDue to implementation details, there will be no 1 IDs.", "id": "f6457:m8"}
{"signature": "def _front_id_from_idx(front, index):", "body": "fidx, sidx = index<EOL>id = front[fidx, sidx]<EOL>if id == <NUM_LIT:0>:<EOL><INDENT>return -<NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>return id<EOL><DEDENT>", "docstring": "Returns the front ID found in `front` at the given `index`.\n\n:param front:               An onset or offset front array of shape [nfrequencies, nsamples]\n:index:                     A tuple of the form (frequency index, sample index)\n:returns:                   The ID of the front or -1 if not found in `front` and the item at `onsets_or_offsets[index]`\n                            is not a 1.", "id": "f6457:m18"}
{"signature": "def _downsample_one_or_the_other(mask, mask_indexes, stft, stft_indexes):", "body": "assert len(mask.shape) == <NUM_LIT:2>, \"<STR_LIT>\".format(len(mask.shape))<EOL>assert len(stft.shape) == <NUM_LIT:2>, \"<STR_LIT>\".format(len(stft.shape))<EOL>if mask.shape[<NUM_LIT:1>] > stft.shape[<NUM_LIT:1>]:<EOL><INDENT>downsample_factor = mask.shape[<NUM_LIT:1>] / stft.shape[<NUM_LIT:1>]<EOL>indexes = _get_downsampled_indexes(mask, downsample_factor)<EOL>mask = mask[:, indexes]<EOL>mask_indexes = np.array(indexes)<EOL><DEDENT>elif mask.shape[<NUM_LIT:1>] < stft.shape[<NUM_LIT:1>]:<EOL><INDENT>downsample_factor = stft.shape[<NUM_LIT:1>] / mask.shape[<NUM_LIT:1>]<EOL>indexes = _get_downsampled_indexes(stft, downsample_factor)<EOL>stft = stft[:, indexes]<EOL>stft_indexes = np.array(indexes)<EOL><DEDENT>return mask, mask_indexes, stft, stft_indexes<EOL>", "docstring": "Takes the given `mask` and `stft`, which must be matrices of shape `frequencies, times`\nand downsamples one of them into the other one's times, so that the time dimensions\nare equal. Leaves the frequency dimension untouched.", "id": "f6457:m33"}
{"signature": "def _choose_front_id_from_candidates(candidate_offset_front_ids, offset_fronts, offsets_corresponding_to_onsets):", "body": "noverlaps = []  <EOL>for offset_front_id in candidate_offset_front_ids:<EOL><INDENT>offset_front_f_idxs, offset_front_s_idxs = np.where(offset_fronts == offset_front_id)<EOL>offset_front_idxs = [(f, i) for f, i in zip(offset_front_f_idxs, offset_front_s_idxs)]<EOL>noverlap_this_id = len(set(offset_front_idxs).symmetric_difference(set(offsets_corresponding_to_onsets)))<EOL>noverlaps.append((noverlap_this_id, offset_front_id))<EOL><DEDENT>_overlapped, chosen_offset_front_id = max(noverlaps, key=lambda t: t[<NUM_LIT:0>])<EOL>return int(chosen_offset_front_id)<EOL>", "docstring": "Returns a front ID which is the id of the offset front that contains the most overlap\nwith offsets that correspond to the given onset front ID.", "id": "f6457:m11"}
{"signature": "def _compute_peaks_or_valleys_of_first_derivative(s, do_peaks=True):", "body": "<EOL>gradient = np.nan_to_num(np.apply_along_axis(np.gradient, <NUM_LIT:1>, s), copy=False)<EOL>threshold = np.squeeze(np.nanmean(gradient, axis=<NUM_LIT:1>) + np.nanstd(gradient, axis=<NUM_LIT:1>))<EOL>half_window = <NUM_LIT:4><EOL>if do_peaks:<EOL><INDENT>indexes = [signal.argrelextrema(gradient[i, :], np.greater, order=half_window)[<NUM_LIT:0>] for i in range(gradient.shape[<NUM_LIT:0>])]<EOL><DEDENT>else:<EOL><INDENT>indexes = [signal.argrelextrema(gradient[i, :], np.less, order=half_window)[<NUM_LIT:0>] for i in range(gradient.shape[<NUM_LIT:0>])]<EOL><DEDENT>extrema = np.zeros(s.shape)<EOL>for row_index, index_array in enumerate(indexes):<EOL><INDENT>for col_index in index_array:<EOL><INDENT>if do_peaks and (gradient[row_index, col_index] > threshold[row_index]):<EOL><INDENT>extrema[row_index, col_index] = <NUM_LIT:1><EOL><DEDENT>elif not do_peaks:<EOL><INDENT>extrema[row_index, col_index] = <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>return extrema, gradient<EOL>", "docstring": "Takes a spectrogram and returns a 2D array of the form:\n\n0 0 0 1 0 0 1 0 0 0 1   <-- Frequency 0\n0 0 1 0 0 0 0 0 0 1 0   <-- Frequency 1\n0 0 0 0 0 0 1 0 1 0 0   <-- Frequency 2\n*** Time axis *******\n\nWhere a 1 means that the value in that time bin in the spectrogram corresponds to\na peak/valley in the first derivative.\n\nThis function is used as part of the ASA algorithm and is not meant to be used publicly.", "id": "f6457:m6"}
{"signature": "def _get_corresponding_offsets(onset_fronts, onset_front_id, onsets, offsets):", "body": "corresponding_offsets = []<EOL>for index in _get_front_idxs_from_id(onset_fronts, onset_front_id):<EOL><INDENT>offset_fidx, offset_sidx = _lookup_offset_by_onset_idx(index, onsets, offsets)<EOL>corresponding_offsets.append((offset_fidx, offset_sidx))<EOL><DEDENT>return corresponding_offsets<EOL>", "docstring": "Gets the offsets that occur as close as possible to the onsets in the given onset-front.", "id": "f6457:m20"}
{"signature": "def _correlate_onsets_and_offsets(onsets, offsets, gradients):", "body": "<EOL>for freq_index, (ons, offs) in enumerate(zip(onsets[:, :], offsets[:, :])):<EOL><INDENT>indexes_of_all_ones = np.reshape(np.where(ons == <NUM_LIT:1>), (-<NUM_LIT:1>,))<EOL>last_idx = indexes_of_all_ones[<NUM_LIT:0>]<EOL>offs[<NUM_LIT:0>:last_idx + <NUM_LIT:1>] = <NUM_LIT:0><EOL>if len(indexes_of_all_ones > <NUM_LIT:1>):<EOL><INDENT>for next_idx in indexes_of_all_ones[<NUM_LIT:1>:]:<EOL><INDENT>offset_choices = offs[last_idx:next_idx]<EOL>offset_choice_indexes = np.where(offset_choices == <NUM_LIT:1>)<EOL>if not np.any(offset_choices):<EOL><INDENT>continue<EOL><DEDENT>assert np.any(offset_choices), \"<STR_LIT>\".format(last_idx, next_idx)<EOL>offset_choice_indexes = np.reshape(last_idx + offset_choice_indexes, (-<NUM_LIT:1>,))<EOL>assert np.all(offsets[freq_index, offset_choice_indexes])<EOL>gradient_values = gradients[freq_index, offset_choice_indexes]<EOL>index_of_largest_from_gradient_values = np.where(gradient_values == np.min(gradient_values))[<NUM_LIT:0>]<EOL>index_of_largest_offset_choice = offset_choice_indexes[index_of_largest_from_gradient_values]<EOL>assert offsets[freq_index, index_of_largest_offset_choice] == <NUM_LIT:1><EOL>offsets[freq_index, offset_choice_indexes] = <NUM_LIT:0><EOL>offsets[freq_index, index_of_largest_offset_choice] = <NUM_LIT:1><EOL>last_idx = next_idx<EOL><DEDENT><DEDENT>else:<EOL><INDENT>offsets[freq_index, :] = <NUM_LIT:0><EOL>offsets[freq_index, -<NUM_LIT:1>] = <NUM_LIT:1><EOL><DEDENT><DEDENT>return offsets<EOL>", "docstring": "Takes an array of onsets and an array of offsets, of the shape [nfrequencies, nsamples], where\neach item in these arrays is either a 0 (not an on/offset) or a 1 (a possible on/offset).\n\nThis function returns a new offsets array, where there is a one-to-one correlation between\nonsets and offsets, such that each onset has exactly one offset that occurs after it in\nthe time domain (the second dimension of the array).\n\nThe gradients array is used to decide which offset to use in the case of multiple possibilities.", "id": "f6457:m7"}
{"signature": "def lowpass_filter(data, cutoff, fs, order=<NUM_LIT:5>):", "body": "nyq = <NUM_LIT:0.5> * fs<EOL>normal_cutoff = cutoff / nyq<EOL>b, a = signal.butter(order, normal_cutoff, btype='<STR_LIT>', analog=False)<EOL>y = signal.lfilter(b, a, data)<EOL>return y<EOL>", "docstring": "Does a lowpass filter over the given data.\n\n:param data: The data (numpy array) to be filtered.\n:param cutoff: The high cutoff in Hz.\n:param fs: The sample rate in Hz of the data.\n:param order: The order of the filter. The higher the order, the tighter the roll-off.\n:returns: Filtered data (numpy array).", "id": "f6458:m1"}
{"signature": "async def process_succeed_response(self, request, response):", "body": "pass<EOL>", "docstring": "Corresponding processing for the succeed response\n:param request: Request\n:param response: Response\n:return:", "id": "f6555:c0:m2"}
{"signature": "def request(self,<EOL>url: str,<EOL>method: str = '<STR_LIT:GET>',<EOL>*,<EOL>callback=None,<EOL>encoding: typing.Optional[str] = None,<EOL>headers: dict = None,<EOL>metadata: dict = None,<EOL>request_config: dict = None,<EOL>request_session=None,<EOL>**kwargs):", "body": "headers = headers or {}<EOL>metadata = metadata or {}<EOL>request_config = request_config or {}<EOL>request_session = request_session or self.request_session<EOL>headers.update(self.headers.copy())<EOL>request_config.update(self.request_config.copy())<EOL>kwargs.update(self.kwargs.copy())<EOL>return Request(<EOL>url=url,<EOL>method=method,<EOL>callback=callback,<EOL>encoding=encoding,<EOL>headers=headers,<EOL>metadata=metadata,<EOL>request_config=request_config,<EOL>request_session=request_session,<EOL>**kwargs)<EOL>", "docstring": "Init a Request class for crawling html", "id": "f6555:c1:m13"}
{"signature": "async def _run_spider_hook(self, hook_func):", "body": "if callable(hook_func):<EOL><INDENT>try:<EOL><INDENT>aws_hook_func = hook_func(weakref.proxy(self))<EOL>if isawaitable(aws_hook_func):<EOL><INDENT>await aws_hook_func<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>self.logger.error(f'<STR_LIT>')<EOL><DEDENT><DEDENT>", "docstring": "Run hook before/after spider start crawling\n:param hook_func: aws function\n:return:", "id": "f6555:c0:m0"}
{"signature": "def __init__(self,<EOL>middleware: typing.Union[typing.Iterable, Middleware] = None,<EOL>loop=None,<EOL>is_async_start: bool = False):", "body": "if not self.start_urls or not isinstance(self.start_urls,<EOL>collections.Iterable):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>self.callback_result_map = self.callback_result_map or {}<EOL>self.request_config = self.request_config or {}<EOL>self.headers = self.headers or {}<EOL>self.metadata = self.metadata or {}<EOL>self.kwargs = self.kwargs or {}<EOL>self.request_config = self.request_config or {}<EOL>self.is_async_start = is_async_start<EOL>self.loop = loop<EOL>asyncio.set_event_loop(self.loop)<EOL>if isinstance(middleware, list):<EOL><INDENT>self.middleware = reduce(lambda x, y: x + y, middleware)<EOL><DEDENT>else:<EOL><INDENT>self.middleware = middleware or Middleware()<EOL><DEDENT>self.request_queue = asyncio.Queue()<EOL>self.sem = asyncio.Semaphore(self.concurrency)<EOL>", "docstring": "Init spider object.\n:param middleware: a list of or a single Middleware\n:param loop:\n:param is_async_start:", "id": "f6555:c1:m0"}
{"signature": "async def handle_request(self, request: Request<EOL>) -> typing.Tuple[AsyncGeneratorType, Response]:", "body": "callback_result, response = None, None<EOL>await self._run_request_middleware(request)<EOL>try:<EOL><INDENT>callback_result, response = await request.fetch_callback(self.sem)<EOL><DEDENT>except NotImplementedParseError as e:<EOL><INDENT>self.logger.error(e)<EOL><DEDENT>except NothingMatchedError as e:<EOL><INDENT>self.logger.error(f'<STR_LIT>')<EOL><DEDENT>except Exception as e:<EOL><INDENT>self.logger.error(f'<STR_LIT>')<EOL><DEDENT>await self._run_response_middleware(request, response)<EOL>await self._process_response(request=request, response=response)<EOL>return callback_result, response<EOL>", "docstring": "Wrap request with middleware.\n:param request:\n:return:", "id": "f6555:c1:m10"}
{"signature": "def __init__(self, default: str = '<STR_LIT>', many: bool = False):", "body": "self.default = default<EOL>self.many = many<EOL>", "docstring": "Init BaseField class\nurl: http://lxml.de/index.html\n:param default: default value\n:param many: if there are many fields in one page", "id": "f6558:c0:m0"}
{"signature": "def __init__(self,<EOL>css_select: str = None,<EOL>xpath_select: str = None,<EOL>default: str = None,<EOL>many: bool = False):", "body": "super(_LxmlElementField, self).__init__(default=default, many=many)<EOL>self.css_select = css_select<EOL>self.xpath_select = xpath_select<EOL>", "docstring": ":param css_select: css select http://lxml.de/cssselect.html\n:param xpath_select: http://www.w3school.com.cn/xpath/index.asp\n:param default: inherit\n:param many: inherit", "id": "f6558:c1:m0"}
{"signature": "async def clean_title(self, value):", "body": "return str(value).strip()<EOL>", "docstring": "\u6e05\u6d17\u76ee\u6807\u6570\u636e\n:param value: \u521d\u59cb\u76ee\u6807\u6570\u636e\n:return:", "id": "f6574:c0:m0"}
{"signature": "def django_boolean_icon(field_val, alt_text=None, title=None):", "body": "<EOL>BOOLEAN_MAPPING = {True: '<STR_LIT:yes>', False: '<STR_LIT>', None: '<STR_LIT>'}<EOL>alt_text = alt_text or BOOLEAN_MAPPING[field_val]<EOL>if title is not None:<EOL><INDENT>title = '<STR_LIT>' % title<EOL><DEDENT>else:<EOL><INDENT>title = '<STR_LIT>'<EOL><DEDENT>return mark_safe('<STR_LIT>' %<EOL>(settings.STATIC_URL, BOOLEAN_MAPPING[field_val], alt_text, title))<EOL>", "docstring": "Return HTML code for a nice representation of true/false.", "id": "f6576:m0"}
{"signature": "def ajax_editable_boolean(attr, short_description):", "body": "def _fn(self, item):<EOL><INDENT>return ajax_editable_boolean_cell(item, attr)<EOL><DEDENT>_fn.allow_tags = True<EOL>_fn.short_description = short_description<EOL>_fn.editable_boolean_field = attr<EOL>return _fn<EOL>", "docstring": "Convenience function: Assign the return value of this method to a variable\nof your ModelAdmin class and put the variable name into list_display.\n\nExample::\n\n    class MyTreeEditor(TreeEditor):\n        list_display = ('__unicode__', 'active_toggle')\n\n        active_toggle = ajax_editable_boolean('active', _('is active'))", "id": "f6576:m3"}
{"signature": "def has_change_permission(self, request, obj=None):", "body": "if settings.TREE_EDITOR_OBJECT_PERMISSIONS:<EOL><INDENT>opts = self.opts<EOL>r = request.user.has_perm(opts.app_label + '<STR_LIT:.>' + opts.get_change_permission(), obj)<EOL><DEDENT>else:<EOL><INDENT>r = True<EOL><DEDENT>return r and super(TreeEditor, self).has_change_permission(request, obj)<EOL>", "docstring": "Implement a lookup for object level permissions. Basically the same as\nModelAdmin.has_change_permission, but also passes the obj parameter in.", "id": "f6576:c1:m8"}
{"signature": "def _collect_editable_booleans(self):", "body": "if hasattr(self, '<STR_LIT>'):<EOL><INDENT>return<EOL><DEDENT>self._ajax_editable_booleans = {}<EOL>for field in self.list_display:<EOL><INDENT>item = getattr(self.__class__, field, None)<EOL>if not item:<EOL><INDENT>continue<EOL><DEDENT>attr = getattr(item, '<STR_LIT>', None)<EOL>if attr:<EOL><INDENT>def _fn(self, instance):<EOL><INDENT>return [ajax_editable_boolean_cell(instance, _fn.attr)]<EOL><DEDENT>_fn.attr = attr<EOL>result_func = getattr(item, '<STR_LIT>', _fn)<EOL>self._ajax_editable_booleans[attr] = result_func<EOL><DEDENT><DEDENT>", "docstring": "Collect all fields marked as editable booleans. We do not\nwant the user to be able to edit arbitrary fields by crafting\nan AJAX request by hand.", "id": "f6576:c1:m3"}
{"signature": "def _populate_contigs(self, contig_id, header, cov, sequence):", "body": "<EOL>gc_kwargs = self._get_gc_content(sequence, len(sequence))<EOL>logger.debug(\"<STR_LIT>\".format(gc_kwargs))<EOL>self.contigs[contig_id] = {<EOL>\"<STR_LIT>\": header,<EOL>\"<STR_LIT>\": sequence,<EOL>\"<STR_LIT>\": len(sequence),<EOL>\"<STR_LIT>\": cov,<EOL>**gc_kwargs<EOL>}<EOL>", "docstring": "Inserts data from a single contig into\\\n         :py:attr:`~Assembly.contigs`.\n\n        By providing a contig id, the original header, the coverage that\n        is parsed from the header and the sequence, this method will\n        populate the :py:attr:`~Assembly.contigs` attribute.\n\n        Parameters\n        ----------\n        contig_id : int\n            Arbitrary unique contig identifier.\n        header : str\n            Original header of the current contig.\n        cov : float\n            The contig coverage, parsed from the fasta header\n        sequence : str\n            The complete sequence of the contig.", "id": "f6596:c0:m4"}
{"signature": "def get_assembly_length(self):", "body": "return sum(<EOL>[vals[\"<STR_LIT>\"] for contig_id, vals in self.contigs.items()<EOL>if contig_id not in self.filtered_ids])<EOL>", "docstring": "Returns the length of the assembly, without the filtered contigs.\n\n        Returns\n        -------\n        x : int\n            Total length of the assembly.", "id": "f6596:c0:m8"}
{"signature": "@staticmethod<EOL><INDENT>def _parse_coverage(header_str):<DEDENT>", "body": "cov = None<EOL>for i in header_str.split(\"<STR_LIT:_>\")[::-<NUM_LIT:1>]:<EOL><INDENT>try:<EOL><INDENT>cov = float(i)<EOL>break<EOL><DEDENT>except ValueError:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>return cov<EOL>", "docstring": "Attempts to retrieve the coverage value from the header string.\n\n        It splits the header by \"_\" and then screens the list backwards in\n        search of the first float value. This will be interpreted as the\n        coverage value. If it cannot find a float value, it returns None.\n        This search methodology is based on the strings of assemblers\n        like spades and skesa that put the mean kmer coverage for each\n        contig in its corresponding fasta header.\n\n        Parameters\n        ----------\n        header_str : str\n            String\n\n        Returns\n        -------\n        float or None\n            The coverage value for the contig. None if it cannot find the\n            value in the provide string.", "id": "f6596:c0:m2"}
{"signature": "def check_summary_health(summary_file, **kwargs):", "body": "<EOL>fail_sensitive = kwargs.get(\"<STR_LIT>\", [<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\"<EOL>])<EOL>logger.debug(\"<STR_LIT>\".format(fail_sensitive))<EOL>must_pass = kwargs.get(\"<STR_LIT>\", [<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\"<EOL>])<EOL>logger.debug(\"<STR_LIT>\".format(must_pass))<EOL>warning_fail_sensitive = kwargs.get(\"<STR_LIT>\", [<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>])<EOL>warning_must_pass = kwargs.get(\"<STR_LIT>\", [<EOL>\"<STR_LIT>\"<EOL>])<EOL>summary_info = get_summary(summary_file)<EOL>health = True<EOL>failed = []<EOL>warning = []<EOL>for cat, test in summary_info.items():<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(cat, test))<EOL>if cat in fail_sensitive and test == \"<STR_LIT>\":<EOL><INDENT>health = False<EOL>failed.append(\"<STR_LIT>\".format(cat, test))<EOL>logger.error(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(cat))<EOL><DEDENT>if cat in must_pass and test != \"<STR_LIT>\":<EOL><INDENT>health = False<EOL>failed.append(\"<STR_LIT>\".format(cat, test))<EOL>logger.error(\"<STR_LIT>\".format(<EOL>cat))<EOL><DEDENT>if cat in warning_fail_sensitive and test == \"<STR_LIT>\":<EOL><INDENT>warning.append(\"<STR_LIT>\".format(cat))<EOL>logger.warning(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(cat))<EOL><DEDENT>if cat in warning_must_pass and test != \"<STR_LIT>\":<EOL><INDENT>warning.append(\"<STR_LIT>\".format(cat))<EOL>logger.warning(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(cat))<EOL><DEDENT><DEDENT>return health, failed, warning<EOL>", "docstring": "Checks the health of a sample from the FastQC summary file.\n\n    Parses the FastQC summary file and tests whether the sample is good\n    or not. There are four categories that cannot fail, and two that\n    must pass in order for the sample pass this check. If the sample fails\n    the quality checks, a list with the failing categories is also returned.\n\n    Categories that cannot fail::\n\n        fail_sensitive = [\n            \"Per base sequence quality\",\n            \"Overrepresented sequences\",\n            \"Sequence Length Distribution\",\n            \"Per sequence GC content\"\n        ]\n\n    Categories that must pass::\n\n        must_pass = [\n            \"Per base N content\",\n            \"Adapter Content\"\n        ]\n\n    Parameters\n    ----------\n    summary_file: str\n        Path to FastQC summary file.\n\n    Returns\n    -------\n    x : bool\n        Returns ``True`` if the sample passes all tests. ``False`` if not.\n    summary_info : list\n        A list with the FastQC categories that failed the tests. Is empty\n        if the sample passes all tests.", "id": "f6597:m6"}
{"signature": "def trim_range(data_file):", "body": "logger.debug(\"<STR_LIT>\")<EOL>target_nuc_bias = \"<STR_LIT>\"<EOL>logger.debug(\"<STR_LIT>\"<EOL>\"<STR_LIT:{}>\".format(target_nuc_bias))<EOL>gather = False<EOL>biased = []<EOL>with open(data_file) as fh:<EOL><INDENT>for line in fh:<EOL><INDENT>if line.startswith(target_nuc_bias):<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(line))<EOL>next(fh)<EOL>gather = True<EOL><DEDENT>elif line.startswith(\"<STR_LIT>\") and gather:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(line))<EOL>break<EOL><DEDENT>elif gather:<EOL><INDENT>g, a, t, c = [float(x) for x in line.strip().split()[<NUM_LIT:1>:]]<EOL>gc = (g + <NUM_LIT:0.1>) / (c + <NUM_LIT:0.1>)<EOL>at = (a + <NUM_LIT:0.1>) / (t + <NUM_LIT:0.1>)<EOL>if <NUM_LIT> <= gc <= <NUM_LIT> and <NUM_LIT> <= at <= <NUM_LIT>:<EOL><INDENT>biased.append(False)<EOL><DEDENT>else:<EOL><INDENT>biased.append(True)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>logger.debug(\"<STR_LIT>\".format(biased))<EOL>biased_5end, biased_3end = biased[:int(len(biased)/<NUM_LIT:2>)],biased[int(len(biased)/<NUM_LIT:2>):][::-<NUM_LIT:1>]<EOL>logger.debug(\"<STR_LIT>\")<EOL>trim_nt = [<NUM_LIT:0>, <NUM_LIT:0>]<EOL>trim_nt[<NUM_LIT:0>] = get_trim_index(biased_5end)<EOL>logger.debug(\"<STR_LIT>\".format(trim_nt[<NUM_LIT:0>]))<EOL>trim_nt[<NUM_LIT:1>] = len(biased) - get_trim_index(biased_3end)<EOL>logger.debug(\"<STR_LIT>\".format(trim_nt[<NUM_LIT:1>]))<EOL>return trim_nt<EOL>", "docstring": "Assess the optimal trim range for a given FastQC data file.\n\n    This function will parse a single FastQC data file, namely the\n    *'Per base sequence content'* category. It will retrieve the A/T and G/C\n    content for each nucleotide position in the reads, and check whether the\n    G/C and A/T proportions are between 80% and 120%. If they are, that\n    nucleotide position is marked as biased for future removal.\n\n    Parameters\n    ----------\n    data_file: str\n        Path to FastQC data file.\n\n    Returns\n    -------\n    trim_nt: list\n        List containing the range with the best trimming positions for the\n        corresponding FastQ file. The first element is the 5' end trim index\n        and the second element is the 3' end trim index.", "id": "f6597:m3"}
{"signature": "@MainWrapper<EOL>def main(sample_id, assembly_file, coverage_bp_file=None):", "body": "logger.info(\"<STR_LIT>\")<EOL>assembly_obj = Assembly(assembly_file, sample_id)<EOL>logger.info(\"<STR_LIT>\")<EOL>assembly_obj.get_summary_stats(\"<STR_LIT>\".format(sample_id))<EOL>size_dist = [len(x) for x in assembly_obj.contigs.values()]<EOL>json_dic = {<EOL>\"<STR_LIT>\": [{<EOL>\"<STR_LIT>\": sample_id,<EOL>\"<STR_LIT:data>\": [<EOL>{\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:value>\": assembly_obj.summary_info[\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": True},<EOL>{\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:value>\": assembly_obj.summary_info[\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": True},<EOL>]<EOL>}],<EOL>\"<STR_LIT>\": [{<EOL>\"<STR_LIT>\": sample_id,<EOL>\"<STR_LIT:data>\": {<EOL>\"<STR_LIT>\": size_dist<EOL>}<EOL>}]<EOL>}<EOL>if coverage_bp_file:<EOL><INDENT>try:<EOL><INDENT>window = <NUM_LIT><EOL>gc_sliding_data = assembly_obj.get_gc_sliding(window=window)<EOL>cov_sliding_data =assembly_obj.get_coverage_sliding(coverage_bp_file,<EOL>window=window)<EOL>total_bp = sum(<EOL>[sum(x) for x in assembly_obj.contig_coverage.values()]<EOL>)<EOL>json_dic[\"<STR_LIT>\"][<NUM_LIT:0>][\"<STR_LIT:data>\"][\"<STR_LIT>\"] = {<EOL>\"<STR_LIT>\": gc_sliding_data,<EOL>\"<STR_LIT>\": cov_sliding_data,<EOL>\"<STR_LIT>\": window,<EOL>\"<STR_LIT>\": assembly_obj._get_window_labels(window),<EOL>\"<STR_LIT>\": os.path.basename(assembly_file)<EOL>}<EOL>json_dic[\"<STR_LIT>\"][<NUM_LIT:0>][\"<STR_LIT:data>\"][\"<STR_LIT>\"] = total_bp<EOL><DEDENT>except:<EOL><INDENT>logger.error(\"<STR_LIT>\"<EOL>\"<STR_LIT:{}>\".format(traceback.format_exc()))<EOL><DEDENT><DEDENT>with open(\"<STR_LIT>\", \"<STR_LIT:w>\") as json_report:<EOL><INDENT>json_report.write(json.dumps(json_dic, separators=(\"<STR_LIT:U+002C>\", \"<STR_LIT::>\")))<EOL><DEDENT>with open(\"<STR_LIT>\", \"<STR_LIT:w>\") as status_fh:<EOL><INDENT>status_fh.write(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Main executor of the assembly_report template.\n\n    Parameters\n    ----------\n    sample_id : str\n        Sample Identification string.\n    assembly_file : str\n        Path to assembly file in Fasta format.", "id": "f6598:m1"}
{"signature": "@staticmethod<EOL><INDENT>def _get_contig_id(contig_str):<DEDENT>", "body": "contig_id = contig_str<EOL>try:<EOL><INDENT>contig_id = re.search(\"<STR_LIT>\", contig_str).group(<NUM_LIT:1>)<EOL><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>contig_id = re.search(\"<STR_LIT>\", contig_str).group(<NUM_LIT:1>)<EOL><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT>return contig_id<EOL>", "docstring": "Tries to retrieve contig id. Returns the original string if it\n        is unable to retrieve the id.\n\n        Parameters\n        ----------\n        contig_str : str\n            Full contig string (fasta header)\n\n        Returns\n        -------\n        str\n            Contig id", "id": "f6598:c0:m2"}
{"signature": "def get_gc_sliding(self, window=<NUM_LIT>):", "body": "gc_res = []<EOL>complete_seq = \"<STR_LIT>\".join(self.contigs.values()).lower()<EOL>for i in range(<NUM_LIT:0>, len(complete_seq), window):<EOL><INDENT>seq_window = complete_seq[i:i + window]<EOL>gc_res.append(round(self._gc_prop(seq_window, len(seq_window)), <NUM_LIT:2>))<EOL><DEDENT>return gc_res<EOL>", "docstring": "Calculates a sliding window of the GC content for the assembly\n\n\n        Returns\n        -------\n        gc_res : list\n            List of GC proportion floats for each data point in the sliding\n            window", "id": "f6598:c0:m6"}
{"signature": "@MainWrapper<EOL>def main(mash_output, hash_cutoff, sample_id, assembly_file):", "body": "input_f = open(mash_output, \"<STR_LIT:r>\")<EOL>master_dict = {}<EOL>for line in input_f:<EOL><INDENT>tab_split = line.split(\"<STR_LIT:\\t>\")<EOL>current_seq = tab_split[<NUM_LIT:1>].strip()<EOL>ref_accession = \"<STR_LIT:_>\".join(tab_split[<NUM_LIT:0>].strip().split(\"<STR_LIT:_>\")[<NUM_LIT:0>:<NUM_LIT:3>])<EOL>mash_dist = tab_split[<NUM_LIT:2>].strip()<EOL>hashes_list = tab_split[-<NUM_LIT:1>].strip().split(\"<STR_LIT:/>\")<EOL>perc_hashes = float(hashes_list[<NUM_LIT:0>]) / float(hashes_list[<NUM_LIT:1>])<EOL>if ref_accession in master_dict.keys():<EOL><INDENT>current_seq += \"<STR_LIT>\".format(master_dict[ref_accession][-<NUM_LIT:1>])<EOL><DEDENT>if perc_hashes > float(hash_cutoff):<EOL><INDENT>master_dict[ref_accession] = [<EOL>round(<NUM_LIT:1> - float(mash_dist), <NUM_LIT:2>),<EOL>round(perc_hashes, <NUM_LIT:2>),<EOL>current_seq<EOL>]<EOL><DEDENT><DEDENT>send_to_output(master_dict, mash_output, sample_id, assembly_file)<EOL>", "docstring": "Main function that allows to dump a mash dist txt file to a json file\n\nParameters\n----------\nmash_output: str\n    A string with the input file.\nhash_cutoff: str\n    the percentage cutoff for the percentage of shared hashes between query\n    and plasmid in database that is allowed for the plasmid to be reported\n    to the results outputs\nsample_id: str\n    The name of the sample.", "id": "f6599:m1"}
{"signature": "def clean_up(fastq):", "body": "for fq in fastq:<EOL><INDENT>rp = os.path.realpath(fq)<EOL>logger.debug(\"<STR_LIT>\".format(rp))<EOL>if re.match(\"<STR_LIT>\", rp):<EOL><INDENT>os.remove(rp)<EOL><DEDENT><DEDENT>", "docstring": "Cleans the temporary fastq files. If they are symlinks, the link\nsource is removed\n\nParameters\n----------\nfastq : list\n    List of fastq files.", "id": "f6600:m2"}
{"signature": "@MainWrapper<EOL>def main(sample_id, fastq_pair, max_len, kmer, opts, clear, disable_rr):", "body": "logger.info(\"<STR_LIT>\")<EOL>min_coverage, min_kmer_coverage = opts<EOL>logger.info(\"<STR_LIT>\")<EOL>kmers = set_kmers(kmer, max_len)<EOL>logger.info(\"<STR_LIT>\".format(kmers))<EOL>cli = [<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>min_coverage,<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT:.>\"<EOL>]<EOL>if kmers:<EOL><INDENT>cli += [\"<STR_LIT>\".format(\"<STR_LIT:U+002C>\".join([str(x) for x in kmers]))]<EOL><DEDENT>cli += [<EOL>\"<STR_LIT>\",<EOL>fastq_pair[<NUM_LIT:0>],<EOL>\"<STR_LIT>\",<EOL>fastq_pair[<NUM_LIT:1>]<EOL>]<EOL>if disable_rr == '<STR_LIT:true>':<EOL><INDENT>cli += ['<STR_LIT>']<EOL><DEDENT>logger.debug(\"<STR_LIT>\".format(cli))<EOL>p = subprocess.Popen(cli, stdout=PIPE, stderr=PIPE)<EOL>stdout, stderr = p.communicate()<EOL>try:<EOL><INDENT>stderr = stderr.decode(\"<STR_LIT:utf8>\")<EOL>stdout = stdout.decode(\"<STR_LIT:utf8>\")<EOL><DEDENT>except (UnicodeDecodeError, AttributeError):<EOL><INDENT>stderr = str(stderr)<EOL>stdout = str(stdout)<EOL><DEDENT>logger.info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(stdout))<EOL>logger.info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(stderr))<EOL>logger.info(\"<STR_LIT>\".format(<EOL>p.returncode))<EOL>with open(\"<STR_LIT>\", \"<STR_LIT:w>\") as fh:<EOL><INDENT>if p.returncode != <NUM_LIT:0>:<EOL><INDENT>fh.write(\"<STR_LIT:error>\")<EOL>sys.exit(p.returncode)<EOL><DEDENT>else:<EOL><INDENT>fh.write(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if \"<STR_LIT>\" in fastq_pair[<NUM_LIT:0>]:<EOL><INDENT>sample_id += \"<STR_LIT>\"<EOL><DEDENT>info = __get_version_spades()<EOL>assembly_file = \"<STR_LIT>\".format(<EOL>sample_id, info[\"<STR_LIT:version>\"].replace(\"<STR_LIT:.>\", \"<STR_LIT>\"))<EOL>os.rename(\"<STR_LIT>\", assembly_file)<EOL>logger.info(\"<STR_LIT>\".format(assembly_file))<EOL>if clear == \"<STR_LIT:true>\" and os.path.exists(assembly_file):<EOL><INDENT>clean_up(fastq_pair)<EOL><DEDENT>", "docstring": "Main executor of the spades template.\n\n    Parameters\n    ----------\n    sample_id : str\n        Sample Identification string.\n    fastq_pair : list\n        Two element list containing the paired FastQ files.\n    max_len : int\n        Maximum read length. This value is determined in\n        :py:class:`templates.integrity_coverage`\n    kmer : str\n        Can be either ``'auto'``, ``'default'`` or a\n        sequence of space separated integers, ``'23, 45, 67'``.\n    opts : List of options for spades execution. See above.\n    clear : str\n        Can be either 'true' or 'false'. If 'true', the input fastq files will\n        be removed at the end of the run, IF they are in the working directory\n    disable_rr : str\n        Can either be 'true' or 'false'. If 'true', disables repeat resolution \n        stage of assembling", "id": "f6600:m3"}
{"signature": "def clean_up(fastq):", "body": "for fq in fastq:<EOL><INDENT>rp = os.path.realpath(fq)<EOL>logger.debug(\"<STR_LIT>\".format(rp))<EOL>if re.match(\"<STR_LIT>\", rp):<EOL><INDENT>os.remove(rp)<EOL><DEDENT><DEDENT>", "docstring": "Cleans the temporary fastq files. If they are symlinks, the link\nsource is removed\n\nParameters\n----------\nfastq : list\n    List of fastq files.", "id": "f6601:m1"}
{"signature": "def evaluate_min_coverage(coverage_opt, assembly_coverage, assembly_size):", "body": "if coverage_opt == \"<STR_LIT>\":<EOL><INDENT>min_coverage = (assembly_coverage / assembly_size) * <NUM_LIT><EOL>logger.info(\"<STR_LIT>\"<EOL>\"<STR_LIT:{}>\".format(min_coverage))<EOL>if min_coverage < <NUM_LIT:10>:<EOL><INDENT>logger.info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>min_coverage = <NUM_LIT:10><EOL><DEDENT><DEDENT>else:<EOL><INDENT>min_coverage = int(coverage_opt)<EOL>logger.info(\"<STR_LIT>\".format(<EOL>min_coverage))<EOL><DEDENT>return min_coverage<EOL>", "docstring": "Evaluates the minimum coverage threshold from the value provided in\n    the coverage_opt.\n\n    Parameters\n    ----------\n    coverage_opt : str or int or float\n        If set to \"auto\" it will try to automatically determine the coverage\n        to 1/3 of the assembly size, to a minimum value of 10. If it set\n        to a int or float, the specified value will be used.\n    assembly_coverage : int or float\n        The average assembly coverage for a genome assembly. This value\n        is retrieved by the `:py:func:parse_coverage_table` function.\n    assembly_size : int\n        The size of the genome assembly. This value is retrieved by the\n        `py:func:get_assembly_size` function.\n\n    Returns\n    -------\n    x: int\n        Minimum coverage threshold.", "id": "f6602:m7"}
{"signature": "def filter_assembly(assembly_file, minimum_coverage, coverage_info,<EOL>output_file):", "body": "<EOL>write_flag = False<EOL>with open(assembly_file) as fh, open(output_file, \"<STR_LIT:w>\") as out_fh:<EOL><INDENT>for line in fh:<EOL><INDENT>if line.startswith(\"<STR_LIT:>>\"):<EOL><INDENT>write_flag = False<EOL>header = line.strip()[<NUM_LIT:1>:]<EOL>contig_cov = coverage_info[header][\"<STR_LIT>\"]<EOL>if contig_cov >= minimum_coverage:<EOL><INDENT>write_flag = True<EOL>out_fh.write(line)<EOL><DEDENT><DEDENT>elif write_flag:<EOL><INDENT>out_fh.write(line)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Generates a filtered assembly file.\n\n    This function generates a filtered assembly file based on an original\n    assembly and a minimum coverage threshold.\n\n    Parameters\n    ----------\n    assembly_file : str\n        Path to original assembly file.\n    minimum_coverage : int or float\n        Minimum coverage required for a contig to pass the filter.\n    coverage_info : OrderedDict or dict\n        Dictionary containing the coverage information for each contig.\n    output_file : str\n        Path where the filtered assembly file will be generated.", "id": "f6602:m3"}
{"signature": "def parse_coverage_table(coverage_file):", "body": "<EOL>coverage_dict = OrderedDict()<EOL>total_cov = <NUM_LIT:0><EOL>with open(coverage_file) as fh:<EOL><INDENT>for line in fh:<EOL><INDENT>contig, cov = line.strip().split()<EOL>coverage_dict[contig] = {\"<STR_LIT>\": int(cov)}<EOL>total_cov += int(cov)<EOL>logger.debug(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(contig, cov))<EOL><DEDENT><DEDENT>return coverage_dict, total_cov<EOL>", "docstring": "Parses a file with coverage information into objects.\n\n    This function parses a TSV file containing coverage results for\n    all contigs in a given assembly and will build an ``OrderedDict``\n    with the information about their coverage and length.  The length\n    information is actually gathered from the contig header using a\n    regular expression that assumes the usual header produced by Spades::\n\n        contig_len = int(re.search(\"length_(.+?)_\", line).group(1))\n\n    Parameters\n    ----------\n    coverage_file : str\n        Path to TSV file containing the coverage results.\n\n    Returns\n    -------\n    coverage_dict : OrderedDict\n        Contains the coverage and length information for each contig.\n    total_size : int\n        Total size of the assembly in base pairs.\n    total_cov : int\n        Sum of coverage values across all contigs.", "id": "f6602:m2"}
{"signature": "def get_assembly_length(self):", "body": "return sum(<EOL>[vals[\"<STR_LIT>\"] for contig_id, vals in self.contigs.items()<EOL>if contig_id not in self.filtered_ids])<EOL>", "docstring": "Returns the length of the assembly, without the filtered contigs.\n\n        Returns\n        -------\n        x : int\n            Total length of the assembly.", "id": "f6604:c0:m7"}
{"signature": "def write_report(self, output_file):", "body": "logger.debug(\"<STR_LIT>\".format(<EOL>output_file))<EOL>with open(output_file, \"<STR_LIT:w>\") as fh:<EOL><INDENT>for contig_id, vals in self.report.items():<EOL><INDENT>fh.write(\"<STR_LIT>\".format(contig_id, vals))<EOL><DEDENT><DEDENT>", "docstring": "Writes a report with the test results for the current assembly\n\n        Parameters\n        ----------\n        output_file : str\n            Name of the output assembly file.", "id": "f6604:c0:m9"}
{"signature": "def get_json_info(fields, header):", "body": "json_dic = dict((x, y) for x, y in zip(header, fields))<EOL>return json_dic<EOL>", "docstring": "Parameters\n----------\nfields\n\nReturns\n-------", "id": "f6605:m0"}
{"signature": "def parse_log(log_file):", "body": "template = OrderedDict([<EOL>(\"<STR_LIT>\", <NUM_LIT:0>),<EOL>(\"<STR_LIT>\", <NUM_LIT:0>),<EOL>(\"<STR_LIT>\", <NUM_LIT:0>),<EOL>(\"<STR_LIT>\", <NUM_LIT:0>),<EOL>(\"<STR_LIT>\", <NUM_LIT:0>),<EOL>(\"<STR_LIT>\", <NUM_LIT:0>)<EOL>])<EOL>with open(log_file) as fh:<EOL><INDENT>for line in fh:<EOL><INDENT>fields = [int(x) for x in line.strip().split()[-<NUM_LIT:4>:]]<EOL>if not fields[<NUM_LIT:0>]:<EOL><INDENT>template[\"<STR_LIT>\"] += <NUM_LIT:1><EOL><DEDENT>template[\"<STR_LIT>\"] += fields[<NUM_LIT:1>]<EOL>template[\"<STR_LIT>\"] += fields[<NUM_LIT:3>]<EOL>template[\"<STR_LIT>\"] += fields[<NUM_LIT:1>] + fields[<NUM_LIT:3>]<EOL>template[\"<STR_LIT>\"] += fields[<NUM_LIT:0>]<EOL><DEDENT>total_len = template[\"<STR_LIT>\"] + template[\"<STR_LIT>\"]<EOL>if total_len:<EOL><INDENT>template[\"<STR_LIT>\"] = round(<EOL>(template[\"<STR_LIT>\"] / total_len) * <NUM_LIT:100>, <NUM_LIT:2>)<EOL><DEDENT>else:<EOL><INDENT>template[\"<STR_LIT>\"] = <NUM_LIT:0><EOL><DEDENT><DEDENT>return template<EOL>", "docstring": "Retrieves some statistics from a single Trimmomatic log file.\n\n    This function parses Trimmomatic's log file and stores some trimming\n    statistics in an :py:class:`OrderedDict` object. This object contains\n    the following keys:\n\n        - ``clean_len``: Total length after trimming.\n        - ``total_trim``: Total trimmed base pairs.\n        - ``total_trim_perc``: Total trimmed base pairs in percentage.\n        - ``5trim``: Total base pairs trimmed at 5' end.\n        - ``3trim``: Total base pairs trimmed at 3' end.\n\n    Parameters\n    ----------\n    log_file : str\n        Path to trimmomatic log file.\n\n    Returns\n    -------\n    x : :py:class:`OrderedDict`\n        Object storing the trimming statistics.", "id": "f6606:m1"}
{"signature": "def merge_default_adapters():", "body": "default_adapters = [os.path.join(ADAPTERS_PATH, x) for x in<EOL>os.listdir(ADAPTERS_PATH)]<EOL>filepath = os.path.join(os.getcwd(), \"<STR_LIT>\")<EOL>with open(filepath, \"<STR_LIT:w>\") as fh,fileinput.input(default_adapters) as in_fh:<EOL><INDENT>for line in in_fh:<EOL><INDENT>fh.write(\"<STR_LIT>\".format(line, \"<STR_LIT>\"))<EOL><DEDENT><DEDENT>return filepath<EOL>", "docstring": "Merges the default adapters file in the trimmomatic adapters directory\n\n    Returns\n    -------\n    str\n        Path with the merged adapters file.", "id": "f6606:m5"}
{"signature": "def set_kmers(kmer_opt, max_read_len):", "body": "logger.debug(\"<STR_LIT>\".format(kmer_opt))<EOL>if kmer_opt == \"<STR_LIT>\":<EOL><INDENT>if max_read_len >= <NUM_LIT>:<EOL><INDENT>kmers = [<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>]<EOL><DEDENT>else:<EOL><INDENT>kmers = [<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>]<EOL><DEDENT>logger.debug(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(max_read_len, kmers))<EOL><DEDENT>elif len(kmer_opt.split()) > <NUM_LIT:1>:<EOL><INDENT>kmers = kmer_opt.split()<EOL>if kmers[<NUM_LIT:0>]<<NUM_LIT:15> or kmers[-<NUM_LIT:1>]><NUM_LIT:255> or is_odd(kmers):<EOL><INDENT>kmers = []<EOL>logger.debug(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(kmers))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>kmers = []<EOL>logger.debug(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>return kmers<EOL>", "docstring": "Returns a kmer list based on the provided kmer option and max read len.\n\n    Parameters\n    ----------\n    kmer_opt : str\n        The k-mer option. Can be either ``'auto'``, ``'default'`` or a\n        sequence of space separated integers, ``'23, 45, 67'``.\n    max_read_len : int\n        The maximum read length of the current sample.\n\n    Returns\n    -------\n    kmers : list\n        List of k-mer values that will be provided to megahit.", "id": "f6608:m2"}
{"signature": "@MainWrapper<EOL>def main(fastq_pair, adapter_file, cpus):", "body": "logger.info(\"<STR_LIT>\")<EOL>if os.path.exists(adapter_file):<EOL><INDENT>logger.info(\"<STR_LIT>\".format(adapter_file))<EOL>adapters = convert_adatpers(adapter_file)<EOL><DEDENT>else:<EOL><INDENT>logger.info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(adapter_file))<EOL>adapters = None<EOL><DEDENT>cli = [<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>str(cpus)<EOL>]<EOL>if adapters:<EOL><INDENT>cli += [\"<STR_LIT>\", \"<STR_LIT:{}>\".format(adapters)]<EOL><DEDENT>cli += fastq_pair<EOL>logger.debug(\"<STR_LIT>\".format(cli))<EOL>p = subprocess.Popen(cli, stdout=PIPE, stderr=PIPE, shell=False)<EOL>stdout, stderr = p.communicate()<EOL>try:<EOL><INDENT>stderr = stderr.decode(\"<STR_LIT:utf8>\")<EOL><DEDENT>except (UnicodeDecodeError, AttributeError):<EOL><INDENT>stderr = str(stderr)<EOL><DEDENT>logger.info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(stdout))<EOL>logger.info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(stderr))<EOL>logger.info(\"<STR_LIT>\".format(<EOL>p.returncode))<EOL>logger.info(\"<STR_LIT>\")<EOL>with open(\"<STR_LIT>\", \"<STR_LIT:w>\") as status_fh:<EOL><INDENT>for fastq in fastq_pair:<EOL><INDENT>fpath = join(fastq.rsplit(\"<STR_LIT:.>\", <NUM_LIT:2>)[<NUM_LIT:0>] + \"<STR_LIT>\",<EOL>\"<STR_LIT>\")<EOL>logger.debug(\"<STR_LIT>\".format(fpath))<EOL>if not exists(fpath):<EOL><INDENT>logger.warning(\"<STR_LIT>\".format(fpath))<EOL>status_fh.write(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>logger.debug(\"<STR_LIT>\".format(fpath))<EOL>status_fh.write(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>logger.info(\"<STR_LIT>\")<EOL>for i, fastq in enumerate(fastq_pair):<EOL><INDENT>fastqc_dir = fastq.rsplit(\"<STR_LIT:.>\", <NUM_LIT:2>)[<NUM_LIT:0>] + \"<STR_LIT>\"<EOL>summary_file = join(fastqc_dir, \"<STR_LIT>\")<EOL>logger.debug(\"<STR_LIT>\".format(summary_file))<EOL>fastqc_data_file = join(fastqc_dir, \"<STR_LIT>\")<EOL>logger.debug(\"<STR_LIT>\".format(fastqc_data_file))<EOL>os.rename(fastqc_data_file, \"<STR_LIT>\".format(i + <NUM_LIT:1>))<EOL>os.rename(summary_file, \"<STR_LIT>\".format(i + <NUM_LIT:1>))<EOL><DEDENT>", "docstring": "Main executor of the fastq template.\n\n    Parameters\n    ----------\n    fastq_pair : list\n        Two element list containing the paired FastQ files.\n    adapter_file : str\n        Path to adapters file.\n    cpus : int or str\n        Number of cpu's that will be by FastQC.", "id": "f6611:m2"}
{"signature": "@MainWrapper<EOL>def main(sample_id, assembly, min_size):", "body": "logger.info(\"<STR_LIT>\")<EOL>f_open = open(assembly, \"<STR_LIT>\")<EOL>entry = (x[<NUM_LIT:1>] for x in groupby(f_open, lambda line: line[<NUM_LIT:0>] == \"<STR_LIT:>>\"))<EOL>success = <NUM_LIT:0><EOL>for header in entry:<EOL><INDENT>headerStr = header.__next__()[<NUM_LIT:1>:].strip()<EOL>seq = \"<STR_LIT>\".join(s.strip() for s in entry.__next__())<EOL>if len(seq) >= min_size:<EOL><INDENT>with open(sample_id + '<STR_LIT:_>' + headerStr.replace(\"<STR_LIT:U+0020>\",\"<STR_LIT:_>\").replace(\"<STR_LIT:=>\",\"<STR_LIT:_>\") + '<STR_LIT>', \"<STR_LIT:w>\") as output_file:<EOL><INDENT>output_file.write(\"<STR_LIT:>>\" + sample_id + \"<STR_LIT:_>\" + headerStr.replace(\"<STR_LIT:U+0020>\",\"<STR_LIT:_>\").replace(\"<STR_LIT:=>\",\"<STR_LIT:_>\") + \"<STR_LIT>\" + seq + \"<STR_LIT>\")<EOL>success += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>f_open.close()<EOL>logger.info(\"<STR_LIT>\".format(success))<EOL>", "docstring": "Main executor of the split_fasta template.\n\n    Parameters\n    ----------\n    sample_id : str\n        Sample Identification string.\n    assembly : list\n        Assembly file.\n    min_size : int\n        Minimum contig size.", "id": "f6613:m0"}
{"signature": "def get_plot_data(self):", "body": "json_dic = {\"<STR_LIT>\": []}<EOL>sample_dic = {}<EOL>sample_assembly_map = {}<EOL>for entry in self.storage.values():<EOL><INDENT>sample_id = re.match(\"<STR_LIT>\", entry[\"<STR_LIT>\"]).groups()[<NUM_LIT:0>]<EOL>if sample_id not in sample_dic:<EOL><INDENT>sample_dic[sample_id] = {}<EOL><DEDENT>contig_id = self._get_contig_id(entry[\"<STR_LIT>\"])<EOL>database = entry[\"<STR_LIT>\"]<EOL>if database not in sample_dic[sample_id]:<EOL><INDENT>sample_dic[sample_id][database] = []<EOL><DEDENT>if sample_id not in sample_assembly_map:<EOL><INDENT>sample_assembly_map[sample_id] = entry[\"<STR_LIT>\"]<EOL><DEDENT>sample_dic[sample_id][database].append(<EOL>{\"<STR_LIT>\": contig_id,<EOL>\"<STR_LIT>\": entry[\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": entry[\"<STR_LIT>\"].replace(\"<STR_LIT:'>\", \"<STR_LIT>\"),<EOL>\"<STR_LIT>\": entry[\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": entry[\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": entry[\"<STR_LIT>\"],<EOL>},<EOL>)<EOL><DEDENT>for sample, data in sample_dic.items():<EOL><INDENT>json_dic[\"<STR_LIT>\"].append(<EOL>{<EOL>\"<STR_LIT>\": sample,<EOL>\"<STR_LIT:data>\": {\"<STR_LIT>\": data},<EOL>\"<STR_LIT>\": sample_assembly_map[sample]<EOL>}<EOL>)<EOL><DEDENT>return json_dic<EOL>", "docstring": "Generates the JSON report to plot the gene boxes\n\n        Following the convention of the reports platform, this method returns\n        a list of JSON/dict objects with the information about each entry in\n        the abricate file. The information contained in this JSON is::\n\n            {contig_id: <str>,\n             seqRange: [<int>, <int>],\n             gene: <str>,\n             accession: <str>,\n             coverage: <float>,\n             identity: <float>\n             }\n\n        Note that the `seqRange` entry contains the position in the\n        corresponding contig, not the absolute position in the whole assembly.\n\n        Returns\n        -------\n        json_dic : list\n            List of JSON/dict objects with the report data.", "id": "f6615:c1:m2"}
{"signature": "def parse_log(self, bowtie_log):", "body": "print(\"<STR_LIT>\")<EOL>regexes = {<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': r\"<STR_LIT>\",<EOL>'<STR_LIT>': r\"<STR_LIT>\",<EOL>'<STR_LIT>': r\"<STR_LIT>\"<EOL>},<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': r\"<STR_LIT>\",<EOL>'<STR_LIT>': r\"<STR_LIT>\",<EOL>'<STR_LIT>': r\"<STR_LIT>\",<EOL>'<STR_LIT>': r\"<STR_LIT>\",<EOL>'<STR_LIT>': r\"<STR_LIT>\",<EOL>'<STR_LIT>': r\"<STR_LIT>\",<EOL>'<STR_LIT>': r\"<STR_LIT>\",<EOL>'<STR_LIT>': r\"<STR_LIT>\"<EOL>}<EOL>}<EOL>with open(bowtie_log, \"<STR_LIT:r>\") as f:<EOL><INDENT>for l in f:<EOL><INDENT>print(l)<EOL>total = re.search(r\"<STR_LIT>\", l)<EOL>print(total)<EOL>if total:<EOL><INDENT>print(total)<EOL>self.set_n_reads(total.group(<NUM_LIT:1>))<EOL><DEDENT>paired = re.search(r\"<STR_LIT>\", l)<EOL>if paired:<EOL><INDENT>paired_total = int(paired.group(<NUM_LIT:1>))<EOL>paired_numbers = {}<EOL>l = f.readline()<EOL>while l.startswith('<STR_LIT:U+0020>'):<EOL><INDENT>for k, r in regexes['<STR_LIT>'].items():<EOL><INDENT>match = re.search(r, l)<EOL>if match:<EOL><INDENT>paired_numbers[k] = int(match.group(<NUM_LIT:1>))<EOL><DEDENT><DEDENT>l = f.readline()<EOL><DEDENT>align_zero_times = paired_numbers['<STR_LIT>'] + paired_numbers['<STR_LIT>']<EOL>if align_zero_times:<EOL><INDENT>self.set_align_0x(align_zero_times)<EOL><DEDENT>align_one_time = paired_numbers['<STR_LIT>'] + paired_numbers['<STR_LIT>']<EOL>if align_one_time:<EOL><INDENT>self.set_align_1x(align_one_time)<EOL><DEDENT>align_more_than_one_time = paired_numbers['<STR_LIT>'] + paired_numbers['<STR_LIT>']<EOL>if align_more_than_one_time:<EOL><INDENT>self.set_align_mt1x(align_more_than_one_time)<EOL><DEDENT><DEDENT>overall = re.search(r\"<STR_LIT>\", l)<EOL>if overall:<EOL><INDENT>self.overall_rate = float(overall.group(<NUM_LIT:1>))<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Parse a bowtie log file.\n\n        This is a bowtie log parsing method that populates the\n        :py:attr:`self.n_reads, self.align_0x, self.align_1x, self.align_mt1x and self.overall_rate` attributes with\n        data from the log file.\n\n        Disclamer: THIS METHOD IS HORRIBLE BECAUSE THE BOWTIE LOG IS HORRIBLE.\n\n        The insertion of data on the attribytes is done by the\n        :py:meth:`set_attribute method.\n\n        Parameters\n        ----------\n        bowtie_log : str\n            Path to the boetie log file.", "id": "f6616:c0:m6"}
{"signature": "@MainWrapper<EOL>def main(sample_id, bowite_log):", "body": "logger.info(\"<STR_LIT>\")<EOL>warnings = []<EOL>fails = \"<STR_LIT>\"<EOL>bowtie_info = Bowtie(sample_id, bowite_log)<EOL>print(bowtie_info.overall_rate)<EOL>with open(\"<STR_LIT>\", \"<STR_LIT:w>\") as json_report:<EOL><INDENT>json_dic = {<EOL>\"<STR_LIT>\": [{<EOL>\"<STR_LIT>\": sample_id,<EOL>\"<STR_LIT:data>\": [<EOL>{\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:value>\": int(bowtie_info.n_reads),<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": False},<EOL>{\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:value>\": int(bowtie_info.align_0x),<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": False},<EOL>{\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:value>\": int(bowtie_info.align_1x),<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": False},<EOL>{\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:value>\": int(bowtie_info.align_mt1x),<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": False},<EOL>{\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:value>\": float(bowtie_info.overall_rate),<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": False}<EOL>]<EOL>}],<EOL>}<EOL>if warnings:<EOL><INDENT>json_dic[\"<STR_LIT>\"] = [{<EOL>\"<STR_LIT>\": sample_id,<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:value>\": warnings<EOL>}]<EOL><DEDENT>if fails:<EOL><INDENT>json_dic[\"<STR_LIT>\"] = [{<EOL>\"<STR_LIT>\": sample_id,<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:value>\": [fails]<EOL>}]<EOL><DEDENT>json_report.write(json.dumps(json_dic, separators=(\"<STR_LIT:U+002C>\", \"<STR_LIT::>\")))<EOL><DEDENT>with open(\"<STR_LIT>\", \"<STR_LIT:w>\") as status_fh:<EOL><INDENT>status_fh.write(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Main executor of the process_mapping template.\n\n    Parameters\n    ----------\n    sample_id : str\n        Sample Identification string.\n    boetie_log: str\n        Path to the log file generated by bowtie.", "id": "f6616:m0"}
{"signature": "def depth_file_reader(depth_file):", "body": "<EOL>depth_dic_coverage = {}<EOL>for line in depth_file:<EOL><INDENT>tab_split = line.split()  <EOL>reference = \"<STR_LIT:_>\".join(tab_split[<NUM_LIT:0>].strip().split(\"<STR_LIT:_>\")[<NUM_LIT:0>:<NUM_LIT:3>])  <EOL>position = tab_split[<NUM_LIT:1>]<EOL>num_reads_align = float(tab_split[<NUM_LIT:2>].rstrip())<EOL>if reference not in depth_dic_coverage:<EOL><INDENT>depth_dic_coverage[reference] = {}<EOL><DEDENT>depth_dic_coverage[reference][position] = num_reads_align<EOL><DEDENT>logger.info(\"<STR_LIT>\")<EOL>depth_file.close()<EOL>logger.debug(\"<STR_LIT>\".format(<EOL>asizeof(depth_dic_coverage)/<NUM_LIT>))<EOL>return depth_dic_coverage<EOL>", "docstring": "Function that parse samtools depth file and creates 3 dictionaries that\nwill be useful to make the outputs of this script, both the tabular file\nand the json file that may be imported by pATLAS\n\nParameters\n----------\ndepth_file: textIO\n    the path to depth file for each sample\n\nReturns\n-------\ndepth_dic_coverage: dict\n        dictionary with the coverage per position for each plasmid", "id": "f6617:m0"}
{"signature": "def get_encodings_in_range(rmin, rmax):", "body": "valid_encodings = []<EOL>valid_phred = []<EOL>for encoding, (phred, (emin, emax)) in RANGES.items():<EOL><INDENT>if rmin >= emin and rmax <= emax:<EOL><INDENT>valid_encodings.append(encoding)<EOL>valid_phred.append(phred)<EOL><DEDENT><DEDENT>return valid_encodings, valid_phred<EOL>", "docstring": "Returns the valid encodings for a given encoding range.\n\n    The encoding ranges are stored in the :py:data:`RANGES` dictionary, with\n    the encoding name as a string and a list as a value containing the\n    phred score and a tuple with the encoding range. For a given encoding\n    range provided via the two first arguments, this function will return\n    all possible encodings and phred scores.\n\n    Parameters\n    ----------\n    rmin : int\n        Minimum Unicode code in range.\n    rmax : int\n        Maximum Unicode code in range.\n\n    Returns\n    -------\n    valid_encodings : list\n        List of all possible encodings for the provided range.\n    valid_phred : list\n        List of all possible phred scores.", "id": "f6618:m2"}
{"signature": "def build_versions(self):", "body": "version_storage = []<EOL>template_version = self.context.get(\"<STR_LIT>\", None)<EOL>template_program = self.context.get(\"<STR_LIT>\", None)<EOL>template_build = self.context.get(\"<STR_LIT>\", None)<EOL>if template_version and template_program and template_build:<EOL><INDENT>if self.logger:<EOL><INDENT>self.logger.debug(\"<STR_LIT>\"<EOL>\"<STR_LIT:{}>\".format(template_program,<EOL>template_version,<EOL>template_build))<EOL><DEDENT>version_storage.append({<EOL>\"<STR_LIT>\": template_program,<EOL>\"<STR_LIT:version>\": template_version,<EOL>\"<STR_LIT>\": template_build<EOL>})<EOL><DEDENT>for var, obj in self.context.items():<EOL><INDENT>if var.startswith(\"<STR_LIT>\"):<EOL><INDENT>ver = obj()<EOL>version_storage.append(ver)<EOL>if self.logger:<EOL><INDENT>self.logger.debug(\"<STR_LIT>\"<EOL>\"<STR_LIT:{}>\".format(ver))<EOL><DEDENT><DEDENT><DEDENT>with open(\"<STR_LIT>\", \"<STR_LIT:w>\") as fh:<EOL><INDENT>fh.write(json.dumps(version_storage, separators=(\"<STR_LIT:U+002C>\", \"<STR_LIT::>\")))<EOL><DEDENT>", "docstring": "Writes versions JSON for a template file\n\n        This method creates the JSON file ``.versions`` based on the metadata\n        and specific functions that are present in a given template script.\n\n        It starts by fetching the template metadata, which can be specified\n        via the ``__version__``, ``__template__`` and ``__build__``\n        attributes. If all of these attributes exist, it starts to populate\n        a JSON/dict array (Note that the absence of any one of them will\n        prevent the version from being written).\n\n        Then, it will search the\n        template scope for functions that start with the substring\n        ``__set_version`` (For example ``def __set_version_fastqc()`).\n        These functions should gather the version of\n        an arbitrary program and return a JSON/dict object with the following\n        information::\n\n            {\n                \"program\": <program_name>,\n                \"version\": <version>\n                \"build\": <build>\n            }\n\n        This JSON/dict object is then written in the ``.versions`` file.", "id": "f6619:c0:m2"}
{"signature": "def _build_connections(self, process_list, ignore_dependencies,<EOL>auto_dependency):", "body": "logger.debug(\"<STR_LIT>\")<EOL>logger.debug(\"<STR_LIT>\")<EOL>logger.debug(\"<STR_LIT>\")<EOL>logger.debug(\"<STR_LIT>\".format(process_list))<EOL>for p, con in enumerate(process_list):<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(p, con))<EOL>in_lane = con[\"<STR_LIT:input>\"][\"<STR_LIT>\"]<EOL>out_lane = con[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>logger.debug(\"<STR_LIT>\".format(p, in_lane))<EOL>logger.debug(\"<STR_LIT>\".format(p, out_lane))<EOL>if out_lane > self.lanes:<EOL><INDENT>self.lanes = out_lane<EOL><DEDENT>p_in_name, p_out_name, out_directives = self._get_process_names(<EOL>con, p)<EOL>if p_out_name not in self.process_map:<EOL><INDENT>logger.error(colored_print(<EOL>\"<STR_LIT>\"<EOL>.format(p_out_name), \"<STR_LIT>\"))<EOL>guess_process(p_out_name, self.process_map)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>out_process = self.process_map[p_out_name](template=p_out_name)<EOL>if out_directives:<EOL><INDENT>out_process.update_attributes(out_directives)<EOL><DEDENT>input_suf = \"<STR_LIT>\".format(in_lane, p)<EOL>output_suf = \"<STR_LIT>\".format(out_lane, p)<EOL>logger.debug(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(<EOL>p, input_suf, output_suf))<EOL>out_process.set_main_channel_names(input_suf, output_suf, out_lane)<EOL>if p_in_name != \"<STR_LIT>\":<EOL><INDENT>in_process = self.process_map[p_in_name](template=p_in_name)<EOL>logger.debug(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(p))<EOL>self._test_connection(in_process, out_process)<EOL>out_process.parent_lane = in_lane<EOL><DEDENT>else:<EOL><INDENT>out_process.parent_lane = None<EOL><DEDENT>logger.debug(\"<STR_LIT>\".format(<EOL>p, out_process.parent_lane))<EOL>if in_lane != out_lane:<EOL><INDENT>logger.debug(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(p))<EOL>self._fork_tree[in_lane].append(out_lane)<EOL>try:<EOL><INDENT>parent_process = [<EOL>x for x in self.processes if x.lane == in_lane and<EOL>x.template == p_in_name<EOL>][<NUM_LIT:0>]<EOL>logger.debug(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(p, parent_process,<EOL>out_process.input_channel))<EOL>parent_process.update_main_forks(out_process.input_channel)<EOL><DEDENT>except IndexError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>else:<EOL><INDENT>parent_process = self.processes[-<NUM_LIT:1>]<EOL>if parent_process.lane and parent_process.lane != out_lane:<EOL><INDENT>parent_process = [x for x in self.processes[::-<NUM_LIT:1>]<EOL>if x.lane == out_lane][<NUM_LIT:0>]<EOL><DEDENT>if parent_process.output_channel:<EOL><INDENT>logger.debug(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(<EOL>p, parent_process.output_channel))<EOL>out_process.input_channel = parent_process.output_channel<EOL><DEDENT><DEDENT>if out_process.dependencies and not ignore_dependencies:<EOL><INDENT>logger.debug(\"<STR_LIT>\"<EOL>\"<STR_LIT:{}>\".format(p, p_out_name,<EOL>out_process.dependencies))<EOL>parent_lanes = self._get_fork_tree(out_lane)<EOL>for dep in out_process.dependencies:<EOL><INDENT>if not self._search_tree_backwards(dep, parent_lanes):<EOL><INDENT>if auto_dependency:<EOL><INDENT>self._add_dependency(<EOL>out_process, dep, in_lane, out_lane, p)<EOL><DEDENT>elif not self.export_parameters:<EOL><INDENT>logger.error(colored_print(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(p_out_name, dep),<EOL>\"<STR_LIT>\"))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>self.processes.append(out_process)<EOL><DEDENT>logger.debug(\"<STR_LIT>\".format(self.processes))<EOL>logger.debug(\"<STR_LIT>\".format(self._fork_tree))<EOL>", "docstring": "Parses the process connections dictionaries into a process list\n\n        This method is called upon instantiation of the NextflowGenerator\n        class. Essentially, it sets the main input/output channel names of the\n        processes so that they can be linked correctly.\n\n        If a connection between two consecutive process is not possible due\n        to a mismatch in the input/output types, it exits with an error.\n\n        Returns\n        -------", "id": "f6624:c0:m2"}
{"signature": "def _update_secondary_channels(self, p):", "body": "<EOL>if p.link_start:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(<EOL>p.template, p.link_start))<EOL>for l in p.link_start:<EOL><INDENT>if l in self.secondary_channels:<EOL><INDENT>self.secondary_channels[l][p.lane] = {\"<STR_LIT:p>\": p, \"<STR_LIT:end>\": []}<EOL><DEDENT>else:<EOL><INDENT>self.secondary_channels[l] = {p.lane: {\"<STR_LIT:p>\": p, \"<STR_LIT:end>\": []}}<EOL><DEDENT><DEDENT><DEDENT>if p.link_end:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(<EOL>p.template, p.link_end))<EOL>for l in p.link_end:<EOL><INDENT>parent_forks = self._get_fork_tree(p.lane)<EOL>if l[\"<STR_LIT>\"].startswith(\"<STR_LIT>\"):<EOL><INDENT>self._set_implicit_link(p, l)<EOL>continue<EOL><DEDENT>if l[\"<STR_LIT>\"] not in self.secondary_channels:<EOL><INDENT>continue<EOL><DEDENT>for lane in parent_forks:<EOL><INDENT>if lane in self.secondary_channels[l[\"<STR_LIT>\"]]:<EOL><INDENT>self.secondary_channels[<EOL>l[\"<STR_LIT>\"]][lane][\"<STR_LIT:end>\"].append(\"<STR_LIT:{}>\".format(<EOL>\"<STR_LIT>\".format(l[\"<STR_LIT>\"], p.pid)))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>logger.debug(\"<STR_LIT>\".format(<EOL>p.template, self.secondary_channels))<EOL>", "docstring": "Given a process, this method updates the\n        :attr:`~Process.secondary_channels` attribute with the corresponding\n        secondary inputs of that channel.\n\n        The rationale of the secondary channels is the following:\n\n            - Start storing any secondary emitting channels, by checking the\n              `link_start` list attribute of each process. If there are\n              channel names in the link start, it adds to the secondary\n              channels dictionary.\n            - Check for secondary receiving channels, by checking the\n              `link_end` list attribute. If the link name starts with a\n              `__` signature, it will created an implicit link with the last\n              process with an output type after the signature. Otherwise,\n              it will check is a corresponding link start already exists in\n              the at least one process upstream of the pipeline and if so,\n              it will update the ``secondary_channels`` attribute with the\n              new link.\n\n        Parameters\n        ----------\n        p : flowcraft.Process.Process", "id": "f6624:c0:m13"}
{"signature": "def _get_process_names(self, con, pid):", "body": "try:<EOL><INDENT>_p_in_name = con[\"<STR_LIT:input>\"][\"<STR_LIT>\"]<EOL>p_in_name, _ = self._parse_process_name(_p_in_name)<EOL>logger.debug(\"<STR_LIT>\".format(pid, p_in_name))<EOL>_p_out_name = con[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>p_out_name, out_directives = self._parse_process_name(<EOL>_p_out_name)<EOL>logger.debug(\"<STR_LIT>\".format(pid, p_out_name))<EOL><DEDENT>except eh.ProcessError as ex:<EOL><INDENT>logger.error(colored_print(ex.value, \"<STR_LIT>\"))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>return p_in_name, p_out_name, out_directives<EOL>", "docstring": "Returns the input/output process names and output process directives\n\n        Parameters\n        ----------\n        con : dict\n            Dictionary with the connection information between two processes.\n\n        Returns\n        -------\n        input_name : str\n            Name of the input process\n        output_name : str\n            Name of the output process\n        output_directives : dict\n            Parsed directives from the output process", "id": "f6624:c0:m3"}
{"signature": "def _update_extra_inputs(self, p):", "body": "if p.extra_input:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(<EOL>p.template, p.extra_input))<EOL>if p.extra_input == \"<STR_LIT:default>\":<EOL><INDENT>if p.input_type in self.main_raw_inputs:<EOL><INDENT>logger.error(colored_print(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(p.input_type, p.template), \"<STR_LIT>\"))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>param = p.input_type<EOL><DEDENT>else:<EOL><INDENT>param = p.extra_input<EOL><DEDENT>dest_channel = \"<STR_LIT>\".format(p.template, p.pid)<EOL>if param not in self.extra_inputs:<EOL><INDENT>self.extra_inputs[param] = {<EOL>\"<STR_LIT>\": p.input_type,<EOL>\"<STR_LIT>\": [dest_channel]<EOL>}<EOL><DEDENT>else:<EOL><INDENT>if self.extra_inputs[param][\"<STR_LIT>\"] != p.input_type:<EOL><INDENT>logger.error(colored_print(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(<EOL>p.input_type, p.template,<EOL>self.extra_inputs[param][\"<STR_LIT>\"]),<EOL>\"<STR_LIT>\"))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>self.extra_inputs[param][\"<STR_LIT>\"].append(dest_channel)<EOL><DEDENT>logger.debug(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(p.template, param,<EOL>self.extra_inputs[param]))<EOL>p.update_main_input(<EOL>\"<STR_LIT>\".format(p.input_channel, dest_channel)<EOL>)<EOL><DEDENT>", "docstring": "Given a process, this method updates the\n        :attr:`~Process.extra_inputs` attribute with the corresponding extra\n        inputs of that process\n\n        Parameters\n        ----------\n        p : flowcraft.Process.Process", "id": "f6624:c0:m10"}
{"signature": "def render_pipeline(self):", "body": "dict_viz = {<EOL>\"<STR_LIT:name>\": \"<STR_LIT:root>\",<EOL>\"<STR_LIT>\": []<EOL>}<EOL>last_of_us = {}<EOL>f_tree = self._fork_tree if self._fork_tree else {<NUM_LIT:1>: [<NUM_LIT:1>]}<EOL>for x, (k, v) in enumerate(f_tree.items()):<EOL><INDENT>for p in self.processes[<NUM_LIT:1>:]:<EOL><INDENT>if x == <NUM_LIT:0> and p.lane not in [k] + v:<EOL><INDENT>continue<EOL><DEDENT>if x > <NUM_LIT:0> and p.lane not in v:<EOL><INDENT>continue<EOL><DEDENT>if not p.parent_lane:<EOL><INDENT>lst = dict_viz[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>lst = last_of_us[p.parent_lane]<EOL><DEDENT>tooltip = {<EOL>\"<STR_LIT:name>\": \"<STR_LIT>\".format(p.template, p.pid),<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": p.pid,<EOL>\"<STR_LIT:input>\": p.input_type,<EOL>\"<STR_LIT>\": p.output_type if p.output_type else \"<STR_LIT:None>\",<EOL>\"<STR_LIT>\": p.lane,<EOL>},<EOL>\"<STR_LIT>\": []<EOL>}<EOL>dir_var = \"<STR_LIT>\"<EOL>for k2, v2 in p.directives.items():<EOL><INDENT>dir_var += k2<EOL>for d in v2:<EOL><INDENT>try:<EOL><INDENT>directive = v2[d].replace(\"<STR_LIT:'>\", \"<STR_LIT>\").replace('<STR_LIT:\">', '<STR_LIT>')if isinstance(v2[d], str) else v2[d]<EOL>dir_var += \"<STR_LIT>\".format(d, directive)<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>if dir_var:<EOL><INDENT>tooltip[\"<STR_LIT>\"][\"<STR_LIT>\"] = dir_var<EOL><DEDENT>else:<EOL><INDENT>tooltip[\"<STR_LIT>\"][\"<STR_LIT>\"] = \"<STR_LIT>\"<EOL><DEDENT>lst.append(tooltip)<EOL>last_of_us[p.lane] = lst[-<NUM_LIT:1>][\"<STR_LIT>\"]<EOL><DEDENT><DEDENT>self.dag_to_file(dict_viz)<EOL>with open(os.path.join(dirname(self.nf_file),<EOL>\"<STR_LIT>\"), \"<STR_LIT:w>\") as fh:<EOL><INDENT>fh.write(json.dumps(self._fork_tree))<EOL><DEDENT>return self._render_config(\"<STR_LIT>\", {\"<STR_LIT:data>\": dict_viz})<EOL>", "docstring": "Write pipeline attributes to json\n\n        This function writes the pipeline and their attributes to a json file,\n        that is intended to be read by resources/pipeline_graph.html to render\n        a graphical output showing the DAG.", "id": "f6624:c0:m31"}
{"signature": "def fetch_docker_tags(self):", "body": "<EOL>dict_of_parsed = {}<EOL>terminal_width = shutil.get_terminal_size().columns - <NUM_LIT:3><EOL>center_string = \"<STR_LIT>\"<EOL>tags_list = [<EOL>[<EOL>\"<STR_LIT:=>\" * int(terminal_width / <NUM_LIT:4>),<EOL>\"<STR_LIT>\".format(<EOL>\"<STR_LIT:=>\" * int(((terminal_width/<NUM_LIT:2> - len(center_string)) / <NUM_LIT:2>)),<EOL>center_string)<EOL>,<EOL>\"<STR_LIT>\".format(\"<STR_LIT:=>\" * int(terminal_width / <NUM_LIT:4>))<EOL>],<EOL>[\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>[<EOL>\"<STR_LIT:=>\" * int(terminal_width / <NUM_LIT:4>),<EOL>\"<STR_LIT:=>\" * int(terminal_width / <NUM_LIT:2>),<EOL>\"<STR_LIT:=>\" * int(terminal_width / <NUM_LIT:4>)<EOL>]<EOL>]<EOL>for p in self.processes[<NUM_LIT:1>:]:<EOL><INDENT>template = p.template<EOL>if template in dict_of_parsed:<EOL><INDENT>continue<EOL><DEDENT>dict_of_parsed[template] = {<EOL>\"<STR_LIT>\": []<EOL>}<EOL>for directives in p.directives.values():<EOL><INDENT>try:<EOL><INDENT>repo = directives[\"<STR_LIT>\"]<EOL>default_version = directives[\"<STR_LIT:version>\"]<EOL><DEDENT>except KeyError:<EOL><INDENT>repo = \"<STR_LIT>\"<EOL>default_version = \"<STR_LIT>\"<EOL><DEDENT>repo_version = repo + default_version<EOL>if repo_version not in dict_of_parsed[template][\"<STR_LIT>\"]:<EOL><INDENT>r = requests.get(<EOL>\"<STR_LIT>\"<EOL>.format(repo)<EOL>)<EOL>if r.status_code != <NUM_LIT>:<EOL><INDENT>r_content = json.loads(r.content)[\"<STR_LIT>\"]<EOL>for version in r_content:<EOL><INDENT>printed_version = (version[\"<STR_LIT:name>\"] + \"<STR_LIT:*>\")if version[\"<STR_LIT:name>\"] == default_versionelse version[\"<STR_LIT:name>\"]<EOL>tags_list.append([template, repo, printed_version])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>tags_list.append([template, repo, \"<STR_LIT>\"])<EOL><DEDENT><DEDENT>dict_of_parsed[template][\"<STR_LIT>\"].append(repo_version)<EOL><DEDENT><DEDENT>for x, entry in enumerate(tags_list):<EOL><INDENT>color = \"<STR_LIT>\" if x < <NUM_LIT:3> else(\"<STR_LIT>\" if x % <NUM_LIT:2> != <NUM_LIT:0> else \"<STR_LIT>\")<EOL>final_width = [<EOL>int(terminal_width/<NUM_LIT:4>),<EOL>int(terminal_width/<NUM_LIT:2>),<EOL>int(terminal_width/<NUM_LIT:4>)<EOL>]<EOL>sys.stdout.write(<EOL>colored_print(\"<STR_LIT>\".format(<EOL>*entry, *final_width), color)<EOL>)<EOL><DEDENT>sys.stdout.write(\"<STR_LIT>\".format(\"<STR_LIT>\",<EOL>terminal_width + <NUM_LIT:3>))<EOL>", "docstring": "Export all dockerhub tags associated with each component given by\nthe -t flag.", "id": "f6624:c0:m35"}
{"signature": "def export_params(self):", "body": "params_json = {}<EOL>for p in self.processes[<NUM_LIT:1>:]:<EOL><INDENT>params_json[p.template] = p.params<EOL><DEDENT>sys.stdout.write(json.dumps(params_json))<EOL>", "docstring": "Export pipeline params as a JSON to stdout\n\n        This run mode iterates over the pipeline processes and exports the\n        params dictionary of each component as a JSON to stdout.", "id": "f6624:c0:m33"}
{"signature": "def build(self):", "body": "logger.info(colored_print(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(<EOL>len(self.processes[<NUM_LIT:1>:]), len(self._fork_tree), self.lanes)))<EOL>self._build_header()<EOL>self._set_channels()<EOL>self._set_init_process()<EOL>self._set_secondary_channels()<EOL>logger.info(colored_print(<EOL>\"<STR_LIT>\".format(<EOL>len(self.secondary_channels))))<EOL>self._set_compiler_channels()<EOL>self._set_configurations()<EOL>logger.info(colored_print(<EOL>\"<STR_LIT>\"))<EOL>for p in self.processes:<EOL><INDENT>self.template += \"<STR_LIT>\".format(p.template_str)<EOL><DEDENT>self._build_footer()<EOL>project_root = dirname(self.nf_file)<EOL>self.write_configs(project_root)<EOL>with open(self.nf_file, \"<STR_LIT:w>\") as fh:<EOL><INDENT>fh.write(self.template)<EOL><DEDENT>logger.info(colored_print(<EOL>\"<STR_LIT>\".format(self.nf_file)))<EOL>", "docstring": "Main pipeline builder\n\n        This method is responsible for building the\n        :py:attr:`NextflowGenerator.template` attribute that will contain\n        the nextflow code of the pipeline.\n\n        First it builds the header, then sets the main channels, the\n        secondary inputs, secondary channels and finally the\n        status channels. When the pipeline is built, is writes the code\n        to a nextflow file.", "id": "f6624:c0:m36"}
{"signature": "def dag_to_file(self, dict_viz, output_file=\"<STR_LIT>\"):", "body": "outfile_dag = open(os.path.join(dirname(self.nf_file), output_file)<EOL>, \"<STR_LIT:w>\")<EOL>outfile_dag.write(json.dumps(dict_viz))<EOL>outfile_dag.close()<EOL>", "docstring": "Writes dag to output file\n\n        Parameters\n        ----------\n        dict_viz: dict\n            Tree like dictionary that is used to export tree data of processes\n            to html file and here for the dotfile .treeDag.json", "id": "f6624:c0:m30"}
{"signature": "def _check_required_files(self):", "body": "if not os.path.exists(self.trace_file):<EOL><INDENT>raise eh.InspectionError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(self.trace_file))<EOL><DEDENT>if not os.path.exists(self.log_file):<EOL><INDENT>raise eh.InspectionError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Checks whetner the trace and log files are available", "id": "f6626:c0:m1"}
{"signature": "def _cpu_load_parser(self, cpus, cpu_per, t):", "body": "try:<EOL><INDENT>_cpus = float(cpus)<EOL>_cpu_per = float(cpu_per.replace(\"<STR_LIT:U+002C>\", \"<STR_LIT:.>\").replace(\"<STR_LIT:%>\", \"<STR_LIT>\"))<EOL>hours = self._hms(t) / <NUM_LIT> / <NUM_LIT><EOL>return ((_cpu_per / (<NUM_LIT:100> * _cpus)) * _cpus) * hours<EOL><DEDENT>except ValueError:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>", "docstring": "Parses the cpu load from the number of cpus and its usage\n        percentage and returnsde cpu/hour measure\n\n        Parameters\n        ----------\n        cpus : str\n            Number of cpus allocated.\n        cpu_per : str\n            Percentage of cpu load measured (e.g.: 200,5%).\n        t : str\n            The time string can be something like '20s', '1m30s' or '300ms'.", "id": "f6626:c0:m15"}
{"signature": "def _get_run_hash(self):", "body": "<EOL>pipeline_path = get_nextflow_filepath(self.log_file)<EOL>pipeline_hash = hashlib.md5()<EOL>with open(pipeline_path, \"<STR_LIT:rb>\") as fh:<EOL><INDENT>for chunk in iter(lambda: fh.read(<NUM_LIT>), b\"<STR_LIT>\"):<EOL><INDENT>pipeline_hash.update(chunk)<EOL><DEDENT><DEDENT>workdir = self.workdir.encode(\"<STR_LIT:utf8>\")<EOL>hostname = socket.gethostname().encode(\"<STR_LIT:utf8>\")<EOL>hardware_addr = str(uuid.getnode()).encode(\"<STR_LIT:utf8>\")<EOL>dir_hash = hashlib.md5(workdir + hostname + hardware_addr)<EOL>return pipeline_hash.hexdigest() + dir_hash.hexdigest()<EOL>", "docstring": "Gets the hash of the nextflow file", "id": "f6626:c0:m37"}
{"signature": "def _rightleft(self, direction):", "body": "if direction == \"<STR_LIT:left>\" and self.padding != <NUM_LIT:0>:<EOL><INDENT>self.padding -= <NUM_LIT:1><EOL><DEDENT>if direction == \"<STR_LIT:right>\" andself.screen.getmaxyx()[<NUM_LIT:1>] + self.padding < self.max_width:<EOL><INDENT>self.padding += <NUM_LIT:1><EOL><DEDENT>", "docstring": "Provides curses horizontal padding", "id": "f6626:c0:m24"}
{"signature": "def signal_handler(screen):", "body": "if screen:<EOL><INDENT>screen.clear()<EOL>screen.refresh()<EOL>curses.nocbreak()<EOL>screen.keypad(<NUM_LIT:0>)<EOL>curses.echo()<EOL>curses.endwin()<EOL><DEDENT>print(\"<STR_LIT>\")<EOL>sys.exit(<NUM_LIT:0>)<EOL>", "docstring": "This function is bound to the SIGINT signal (like ctrl+c) to graciously\n    exit the program and reset the curses options.", "id": "f6626:m0"}
{"signature": "def _updown(self, direction):", "body": "if direction == \"<STR_LIT>\" and self.top_line != <NUM_LIT:0>:<EOL><INDENT>self.top_line -= <NUM_LIT:1><EOL><DEDENT>elif direction == \"<STR_LIT>\" andself.screen.getmaxyx()[<NUM_LIT:0>] + self.top_line<= self.content_lines + <NUM_LIT:3>:<EOL><INDENT>self.top_line += <NUM_LIT:1><EOL><DEDENT>", "docstring": "Provides curses scroll functionality.", "id": "f6626:c0:m23"}
{"signature": "def update_inspection(self):", "body": "try:<EOL><INDENT>self.log_parser()<EOL><DEDENT>except (FileNotFoundError, StopIteration) as e:<EOL><INDENT>logger.debug(\"<STR_LIT>\" + str(sys.exc_info()[<NUM_LIT:0>]))<EOL>self.log_retry += <NUM_LIT:1><EOL>if self.log_retry == self.MAX_RETRIES:<EOL><INDENT>raise e<EOL><DEDENT><DEDENT>try:<EOL><INDENT>self.trace_parser()<EOL><DEDENT>except (FileNotFoundError, StopIteration) as e:<EOL><INDENT>logger.debug(\"<STR_LIT>\" + str(sys.exc_info()[<NUM_LIT:0>]))<EOL>self.trace_retry += <NUM_LIT:1><EOL>if self.trace_retry == self.MAX_RETRIES:<EOL><INDENT>raise e<EOL><DEDENT><DEDENT>", "docstring": "Wrapper method that calls the appropriate main updating methods of\n        the inspection.\n\n        It is meant to be used inside a loop (like while), so that it can\n        continuously update the class attributes from the trace and log files.\n        It already implements checks to parse these files only when they\n        change, and they ignore entries that have been previously processes.", "id": "f6626:c0:m20"}
{"signature": "def _update_tag_status(self, process, vals):", "body": "good_status = [\"<STR_LIT>\", \"<STR_LIT>\"]<EOL>for v in list(vals)[::-<NUM_LIT:1>]:<EOL><INDENT>p = self.processes[process]<EOL>tag = v[\"<STR_LIT>\"]<EOL>if tag in p[\"<STR_LIT>\"]:<EOL><INDENT>p[\"<STR_LIT>\"].remove(tag)<EOL>if v[\"<STR_LIT:status>\"] in good_status:<EOL><INDENT>p[\"<STR_LIT>\"].add(tag)<EOL><DEDENT>elif v[\"<STR_LIT:status>\"] == \"<STR_LIT>\":<EOL><INDENT>if not v[\"<STR_LIT>\"]:<EOL><INDENT>v[\"<STR_LIT>\"] = \"<STR_LIT>\"<EOL><DEDENT>self.process_tags[process][tag][\"<STR_LIT>\"] =self._retrieve_log(join(v[\"<STR_LIT>\"], \"<STR_LIT>\"))<EOL>p[\"<STR_LIT>\"].add(tag)<EOL><DEDENT><DEDENT>elif tag in p[\"<STR_LIT>\"]:<EOL><INDENT>if v[\"<STR_LIT:status>\"] in good_status:<EOL><INDENT>p[\"<STR_LIT>\"].remove(tag)<EOL>p[\"<STR_LIT>\"].remove(tag)<EOL>del self.process_tags[process][tag][\"<STR_LIT>\"]<EOL><DEDENT>elif self.run_status == \"<STR_LIT>\":<EOL><INDENT>p[\"<STR_LIT>\"].remove(tag)<EOL><DEDENT><DEDENT>elif v[\"<STR_LIT:status>\"] in good_status:<EOL><INDENT>p[\"<STR_LIT>\"].add(tag)<EOL><DEDENT>if v[\"<STR_LIT:status>\"] not in good_status:<EOL><INDENT>if v[\"<STR_LIT>\"] in list(p[\"<STR_LIT>\"]) + list(p[\"<STR_LIT>\"]):<EOL><INDENT>vals.remove(v)<EOL><DEDENT><DEDENT><DEDENT>return vals<EOL>", "docstring": "Updates the 'submitted', 'finished', 'failed' and 'retry' status\n        of each process/tag combination.\n\n        Process/tag combinations provided to this method already appear on\n        the trace file, so their submission status is updated based on their\n        execution status from nextflow.\n\n        For instance, if a tag is successfully\n        complete, it is moved from the 'submitted' to the 'finished' list.\n        If not, it is moved to the 'failed' list.\n\n        Parameters\n        ----------\n        process : str\n            Name of the current process. Must be present in attr:`processes`\n        vals : list\n            List of tags for this process that have been gathered in the\n            trace file.", "id": "f6626:c0:m10"}
{"signature": "def _get_log_lines(self, n=<NUM_LIT>):", "body": "with open(self.log_file) as fh:<EOL><INDENT>last_lines = fh.readlines()[-n:]<EOL><DEDENT>return last_lines<EOL>", "docstring": "Returns a list with the last ``n`` lines of the nextflow log file\n\n        Parameters\n        ----------\n        n : int\n            Number of last lines from the log file\n\n        Returns\n        -------\n        list\n            List of strings with the nextflow log", "id": "f6626:c0:m30"}
{"signature": "def _dag_file_to_dict(self):", "body": "try:<EOL><INDENT>dag_file = open(os.path.join(self.workdir, \"<STR_LIT>\"))<EOL>dag_json = json.load(dag_file)<EOL><DEDENT>except (FileNotFoundError, json.decoder.JSONDecodeError):<EOL><INDENT>logger.warning(colored_print(<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\"))<EOL>dag_json = {}<EOL><DEDENT>return dag_json<EOL>", "docstring": "Function that opens the dotfile named .treeDag.json in the current\n        working directory\n\n        Returns\n        -------\n        Returns a dictionary with the dag object to be used in the post\n        instance available through the method _establish_connection", "id": "f6626:c0:m34"}
{"signature": "def _update_process_stats(self):", "body": "good_status = [\"<STR_LIT>\", \"<STR_LIT>\"]<EOL>for process, vals in self.trace_info.items():<EOL><INDENT>vals = self._update_tag_status(process, vals)<EOL>self._update_process_resources(process, vals)<EOL>self.process_stats[process] = {}<EOL>inst = self.process_stats[process]<EOL>inst[\"<STR_LIT>\"] = \"<STR_LIT:{}>\".format(<EOL>len([x for x in vals if x[\"<STR_LIT:status>\"] in good_status]))<EOL>try:<EOL><INDENT>time_array = [self._hms(x[\"<STR_LIT>\"]) for x in vals]<EOL>mean_time = round(sum(time_array) / len(time_array), <NUM_LIT:1>)<EOL>mean_time_str = strftime('<STR_LIT>', gmtime(mean_time))<EOL>inst[\"<STR_LIT>\"] = mean_time_str<EOL><DEDENT>except KeyError:<EOL><INDENT>inst[\"<STR_LIT>\"] = \"<STR_LIT:->\"<EOL><DEDENT>try:<EOL><INDENT>cpu_hours = [self._cpu_load_parser(<EOL>x[\"<STR_LIT>\"], x[\"<STR_LIT>\"], x[\"<STR_LIT>\"]) for x in vals]<EOL>inst[\"<STR_LIT>\"] = round(sum(cpu_hours), <NUM_LIT:2>)<EOL><DEDENT>except KeyError:<EOL><INDENT>inst[\"<STR_LIT>\"] = \"<STR_LIT:->\"<EOL><DEDENT>inst[\"<STR_LIT>\"], inst[\"<STR_LIT>\"] =self._assess_resource_warnings(process, vals)<EOL>try:<EOL><INDENT>rss_values = [self._size_coverter(x[\"<STR_LIT>\"]) for x in vals<EOL>if x[\"<STR_LIT>\"] != \"<STR_LIT:->\"]<EOL>if rss_values:<EOL><INDENT>max_rss = round(max(rss_values))<EOL>rss_str = self._size_compress(max_rss)<EOL><DEDENT>else:<EOL><INDENT>rss_str = \"<STR_LIT:->\"<EOL><DEDENT>inst[\"<STR_LIT>\"] = rss_str<EOL><DEDENT>except KeyError:<EOL><INDENT>inst[\"<STR_LIT>\"] = \"<STR_LIT:->\"<EOL><DEDENT>try:<EOL><INDENT>rchar_values = [self._size_coverter(x[\"<STR_LIT>\"]) for x in vals<EOL>if x[\"<STR_LIT>\"] != \"<STR_LIT:->\"]<EOL>if rchar_values:<EOL><INDENT>avg_rchar = round(sum(rchar_values) / len(rchar_values))<EOL>rchar_str = self._size_compress(avg_rchar)<EOL><DEDENT>else:<EOL><INDENT>rchar_str = \"<STR_LIT:->\"<EOL><DEDENT><DEDENT>except KeyError:<EOL><INDENT>rchar_str = \"<STR_LIT:->\"<EOL><DEDENT>inst[\"<STR_LIT>\"] = rchar_str<EOL>try:<EOL><INDENT>wchar_values = [self._size_coverter(x[\"<STR_LIT>\"]) for x in vals<EOL>if x[\"<STR_LIT>\"] != \"<STR_LIT:->\"]<EOL>if wchar_values:<EOL><INDENT>avg_wchar = round(sum(wchar_values) / len(wchar_values))<EOL>wchar_str = self._size_compress(avg_wchar)<EOL><DEDENT>else:<EOL><INDENT>wchar_str = \"<STR_LIT:->\"<EOL><DEDENT><DEDENT>except KeyError:<EOL><INDENT>wchar_str = \"<STR_LIT:->\"<EOL><DEDENT>inst[\"<STR_LIT>\"] = wchar_str<EOL><DEDENT>", "docstring": "Updates the process stats with the information from the processes\n\n        This method is called at the end of each static parsing of the nextflow\n        trace file. It re-populates the :attr:`process_stats` dictionary\n        with the new stat metrics.", "id": "f6626:c0:m17"}
{"signature": "def linear_lane_connection(lane_list, lane):", "body": "logger.debug(<EOL>\"<STR_LIT>\".format(lane_list))<EOL>res = []<EOL>lane += <NUM_LIT:1><EOL>for l in lane_list:<EOL><INDENT>res.extend(linear_connection(l, lane))<EOL>lane += <NUM_LIT:1><EOL><DEDENT>return res<EOL>", "docstring": "Parameters\n----------\nlane_list : list\n    Each element should correspond to a list of processes for a given lane\nlane : int\n    Lane counter before the fork start\n\nReturns\n-------\nres : list\n    List of dictionaries with the links between processes", "id": "f6630:m17"}
{"signature": "def start_proc_insanity_check(p_string):", "body": "if FORK_TOKEN + FORK_TOKEN in p_string:<EOL><INDENT>raise SanityError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "This function checks if there is a starting process after the beginning of\neach fork. It checks for duplicated start tokens ['(('].\n\nParameters\n----------\np_string: str\n     String with the definition of the pipeline, e.g.::\n         'processA processB processC(ProcessD | ProcessE)'", "id": "f6630:m8"}
{"signature": "def remove_unique_identifiers(identifiers_to_tags, pipeline_links):", "body": "<EOL>for index, val in enumerate(pipeline_links):<EOL><INDENT>if val[\"<STR_LIT:input>\"][\"<STR_LIT>\"] != \"<STR_LIT>\":<EOL><INDENT>val[\"<STR_LIT:input>\"][\"<STR_LIT>\"] = identifiers_to_tags[<EOL>val[\"<STR_LIT:input>\"][\"<STR_LIT>\"]]<EOL><DEDENT>if val[\"<STR_LIT>\"][\"<STR_LIT>\"] != \"<STR_LIT>\":<EOL><INDENT>val[\"<STR_LIT>\"][\"<STR_LIT>\"] = identifiers_to_tags[<EOL>val[\"<STR_LIT>\"][\"<STR_LIT>\"]]<EOL><DEDENT><DEDENT>return pipeline_links<EOL>", "docstring": "Removes unique identifiers and add the original process names to the\n    already parsed pipelines\n\n    Parameters\n    ----------\n    identifiers_to_tags : dict\n        Match between unique process identifiers and process names\n    pipeline_links: list\n        Parsed pipeline list with unique identifiers\n\n    Returns\n    -------\n    list\n        Pipeline list with original identifiers", "id": "f6630:m19"}
{"signature": "def brackets_insanity_check(p_string):", "body": "if p_string.count(FORK_TOKEN) != p_string.count(CLOSE_TOKEN):<EOL><INDENT>dict_values = {<EOL>FORK_TOKEN: p_string.count(FORK_TOKEN),<EOL>CLOSE_TOKEN: p_string.count(CLOSE_TOKEN)<EOL>}<EOL>max_bracket = max(dict_values, key=dict_values.get)<EOL>raise SanityError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(<EOL>str(abs(<EOL>p_string.count(FORK_TOKEN) - p_string.count(CLOSE_TOKEN))),<EOL>max_bracket))<EOL><DEDENT>", "docstring": "This function performs a check for different number of '(' and ')'\ncharacters, which indicates that some forks are poorly constructed.\n\nParameters\n----------\np_string: str\n     String with the definition of the pipeline, e.g.::\n         'processA processB processC(ProcessD | ProcessE)'", "id": "f6630:m4"}
{"signature": "def late_proc_insanity_check(p_string):", "body": "if re.search('<STR_LIT>'.format(CLOSE_TOKEN), p_string):<EOL><INDENT>raise SanityError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "This function checks if there are processes after the close token. It\nsearches for everything that isn't \"|\" or \")\" after a \")\" token.\n\nParameters\n----------\np_string: str\n     String with the definition of the pipeline, e.g.::\n         'processA processB processC(ProcessD | ProcessE)'", "id": "f6630:m9"}
{"signature": "def remove_inner_forks(text):", "body": "n = <NUM_LIT:1>  <EOL>while n:<EOL><INDENT>text, n = re.subn(r'<STR_LIT>', '<STR_LIT>', text)<EOL><DEDENT>return text<EOL>", "docstring": "Recursively removes nested brackets\n\n    This function is used to remove nested brackets from fork strings using\n    regular expressions\n\n    Parameters\n    ----------\n    text: str\n        The string that contains brackets with inner forks to be removed\n\n    Returns\n    -------\n    text: str\n        the string with only the processes that are not in inner forks, thus\n        the processes that belong to a given fork.", "id": "f6630:m1"}
{"signature": "def set_param_id(self, param_id):", "body": "self._context = {**self._context, \"<STR_LIT>\": param_id}<EOL>", "docstring": "Sets the param_id for the process, which will be used to render\n        the template.\n\n        Parameters\n        ----------\n        param_id : str\n            The :attr:`param_id` attribute of the process.", "id": "f6631:c0:m3"}
{"signature": "def update_log_watch(self):", "body": "<EOL>size_stamp = os.path.getsize(self.log_file)<EOL>self.trace_retry = <NUM_LIT:0><EOL>if size_stamp and size_stamp == self.log_sizestamp:<EOL><INDENT>return<EOL><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\".format(size_stamp))<EOL>self.log_sizestamp = size_stamp<EOL><DEDENT>self._update_pipeline_status()<EOL>", "docstring": "Parses nextflow log file and updates the run status", "id": "f6632:c0:m7"}
{"signature": "@staticmethod<EOL><INDENT>def _expand_path(hash_str):<DEDENT>", "body": "try:<EOL><INDENT>first_hash, second_hash = hash_str.split(\"<STR_LIT:/>\")<EOL>first_hash_path = join(abspath(\"<STR_LIT>\"), first_hash)<EOL>for l in os.listdir(first_hash_path):<EOL><INDENT>if l.startswith(second_hash):<EOL><INDENT>return join(first_hash_path, l)<EOL><DEDENT><DEDENT><DEDENT>except FileNotFoundError:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Expands the hash string of a process (ae/1dasjdm) into a full\n        working directory\n\n        Parameters\n        ----------\n        hash_str : str\n            Nextflow process hash with the beggining of the work directory\n\n        Returns\n        -------\n        str\n            Path to working directory of the hash string", "id": "f6632:c0:m3"}
{"signature": "def _init_live_reports(self, report_id):", "body": "logger.debug(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(self.broadcast_address))<EOL>try:<EOL><INDENT>with open(\"<STR_LIT>\") as fh:<EOL><INDENT>metadata = [json.load(fh)]<EOL><DEDENT><DEDENT>except:<EOL><INDENT>metadata = []<EOL><DEDENT>start_json = {<EOL>\"<STR_LIT:data>\": {\"<STR_LIT>\": metadata}<EOL>}<EOL>try:<EOL><INDENT>requests.post(<EOL>self.broadcast_address,<EOL>json={\"<STR_LIT>\": report_id, \"<STR_LIT>\": start_json,<EOL>\"<STR_LIT:status>\": self.status_info}<EOL>)<EOL><DEDENT>except requests.exceptions.ConnectionError:<EOL><INDENT>logger.error(colored_print(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\", \"<STR_LIT>\"))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Sends a POST request to initialize the live reports\n\n        Parameters\n        ----------\n        report_id : str\n            Hash of the report JSON as retrieved from :func:`~_get_report_hash`", "id": "f6632:c0:m9"}
{"signature": "def _get_report_id(self):", "body": "if self.watch:<EOL><INDENT>pipeline_path = get_nextflow_filepath(self.log_file)<EOL>pipeline_hash = hashlib.md5()<EOL>with open(pipeline_path, \"<STR_LIT:rb>\") as fh:<EOL><INDENT>for chunk in iter(lambda: fh.read(<NUM_LIT>), b\"<STR_LIT>\"):<EOL><INDENT>pipeline_hash.update(chunk)<EOL><DEDENT><DEDENT>workdir = os.getcwd().encode(\"<STR_LIT:utf8>\")<EOL>hostname = socket.gethostname().encode(\"<STR_LIT:utf8>\")<EOL>hardware_addr = str(uuid.getnode()).encode(\"<STR_LIT:utf8>\")<EOL>dir_hash = hashlib.md5(workdir + hostname + hardware_addr)<EOL>return pipeline_hash.hexdigest() + dir_hash.hexdigest()<EOL><DEDENT>else:<EOL><INDENT>with open(self.report_file) as fh:<EOL><INDENT>report_json = json.loads(fh.read())<EOL><DEDENT>metadata = report_json[\"<STR_LIT:data>\"][\"<STR_LIT>\"][<NUM_LIT:0>][\"<STR_LIT>\"]<EOL>try:<EOL><INDENT>report_id = metadata[\"<STR_LIT>\"] + metadata[\"<STR_LIT>\"]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise eh.ReportError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>return report_id<EOL><DEDENT>", "docstring": "Returns a hash of the reports JSON file", "id": "f6632:c0:m4"}
{"signature": "def build_downstream(self, process_descriptions, task, all_tasks,<EOL>task_pipeline,<EOL>count_forks, total_tasks, forks):", "body": "if task in process_descriptions:<EOL><INDENT>if process_descriptions[task][<NUM_LIT:2>] is not None:<EOL><INDENT>if len(process_descriptions[task][<NUM_LIT:2>].split(\"<STR_LIT:|>\")) > <NUM_LIT:1>:<EOL><INDENT>local_forks = process_descriptions[task][<NUM_LIT:2>].split(\"<STR_LIT:|>\")<EOL>for local_fork in local_forks:<EOL><INDENT>if local_fork in total_tasks:<EOL><INDENT>count_forks += <NUM_LIT:1><EOL>task_pipeline.append(process_descriptions[task][<NUM_LIT:2>])<EOL>self.define_pipeline_string(<EOL>process_descriptions,<EOL>local_fork,<EOL>False,<EOL>True,<EOL>count_forks,<EOL>total_tasks,<EOL>forks<EOL>)<EOL><DEDENT><DEDENT>return task_pipeline<EOL><DEDENT>else:<EOL><INDENT>if process_descriptions[task][<NUM_LIT:2>] in total_tasks:<EOL><INDENT>task_pipeline.append(process_descriptions[task][<NUM_LIT:2>].split(\"<STR_LIT:|>\")[<NUM_LIT:0>])<EOL>self.build_downstream(<EOL>process_descriptions,<EOL>process_descriptions[task][<NUM_LIT:2>].split(\"<STR_LIT:|>\")[<NUM_LIT:0>],<EOL>all_tasks,<EOL>task_pipeline,<EOL>count_forks,<EOL>total_tasks,<EOL>forks<EOL>)<EOL><DEDENT>return task_pipeline<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return task_pipeline<EOL><DEDENT><DEDENT>", "docstring": "Builds the downstream pipeline of the current process\n\n        Checks for the downstream processes to the current process and\n        adds them to the current pipeline fragment.\n\n        Parameters\n        ----------\n        process_descriptions : dict\n            Information of processes input, output and if is forkable\n        task : str\n            Current process\n        all_tasks : list\n            A list of all provided processes\n        task_pipeline : list\n            Current pipeline fragment\n        count_forks : int\n            Current number of forks\n        total_tasks : str\n            All space separated processes\n        forks : list\n            Current forks\n        Returns\n        -------\n        list : resulting pipeline fragment", "id": "f6651:c0:m3"}
{"signature": "def list_recipes(full=False):", "body": "logger.info(colored_print(<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\"))<EOL>prefix = \"<STR_LIT>\".format(recipes.__name__)<EOL>for importer, modname, _ in pkgutil.iter_modules(recipes.__path__, prefix):<EOL><INDENT>_module = importer.find_module(modname).load_module(modname)<EOL>_recipe_classes = [cls for cls in _module.__dict__.values() if<EOL>isinstance(cls, type)]<EOL>for cls in _recipe_classes:<EOL><INDENT>recipe_cls = cls()<EOL>if hasattr(recipe_cls, \"<STR_LIT:name>\"):<EOL><INDENT>logger.info(colored_print(\"<STR_LIT>\".format(recipe_cls.name), \"<STR_LIT>\"))<EOL>if full:<EOL><INDENT>logger.info(colored_print(\"<STR_LIT>\".format(recipe_cls.__doc__), \"<STR_LIT>\"))<EOL>logger.info(colored_print(\"<STR_LIT>\".format(recipe_cls.pipeline_str), \"<STR_LIT>\"))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>sys.exit(<NUM_LIT:0>)<EOL>", "docstring": "Method that iterates over all available recipes and prints their\n    information to the standard output\n\n    Parameters\n    ----------\n    full : bool\n        If true, it will provide the pipeline string along with the recipe name", "id": "f6651:m2"}
{"signature": "def define_pipeline_string(self, process_descriptions, tasks,<EOL>check_upstream,<EOL>check_downstream, count_forks, total_tasks,<EOL>forks):", "body": "tasks_array = tasks.split()<EOL>for task_unsplit in tasks_array:<EOL><INDENT>task = task_unsplit.split(\"<STR_LIT:=>\")[<NUM_LIT:0>]<EOL>if task not in process_descriptions.keys():<EOL><INDENT>logger.error(<EOL>colored_print(<EOL>\"<STR_LIT>\".format(task),<EOL>\"<STR_LIT>\"<EOL>)<EOL>)<EOL>sys.exit()<EOL><DEDENT>else:<EOL><INDENT>process_split = task_unsplit.split(\"<STR_LIT:=>\")<EOL>if len(process_split) > <NUM_LIT:1>:<EOL><INDENT>self.process_to_id[process_split[<NUM_LIT:0>]] = process_split[<NUM_LIT:1>]<EOL><DEDENT><DEDENT>if not bool([x for x in forks if task in x]) and not bool([y for y in forks if process_descriptions[task][<NUM_LIT:2>] in y]):<EOL><INDENT>task_pipeline = []<EOL>if task in process_descriptions:<EOL><INDENT>if check_upstream:<EOL><INDENT>task_pipeline = self.build_upstream(<EOL>process_descriptions,<EOL>task,<EOL>tasks_array,<EOL>task_pipeline,<EOL>count_forks,<EOL>total_tasks,<EOL>forks<EOL>)<EOL><DEDENT>task_pipeline.append(task)<EOL>if check_downstream:<EOL><INDENT>task_pipeline = self.build_downstream(<EOL>process_descriptions,<EOL>task,<EOL>tasks_array,<EOL>task_pipeline,<EOL>count_forks,<EOL>total_tasks,<EOL>forks<EOL>)<EOL><DEDENT><DEDENT>forks.append(list(OrderedDict.fromkeys(task_pipeline)))<EOL><DEDENT>elif bool([y for y in forks if process_descriptions[task][<NUM_LIT:2>] in y]):<EOL><INDENT>for fork in forks:<EOL><INDENT>if task not in fork:<EOL><INDENT>try:<EOL><INDENT>dependent_index = fork.index(process_descriptions[task][<NUM_LIT:2>])<EOL>fork.insert(dependent_index, task)<EOL><DEDENT>except ValueError:<EOL><INDENT>continue<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>for i in range(<NUM_LIT:0>, len(forks)):<EOL><INDENT>for j in range(<NUM_LIT:0>, len(forks[i])):<EOL><INDENT>try:<EOL><INDENT>if len(forks[i][j].split(\"<STR_LIT:|>\")) > <NUM_LIT:1>:<EOL><INDENT>forks[i][j] = forks[i][j].split(\"<STR_LIT:|>\")<EOL>tmp_fork = []<EOL>for s in forks[i][j]:<EOL><INDENT>if s in total_tasks:<EOL><INDENT>tmp_fork.append(s)<EOL><DEDENT><DEDENT>forks[i][j] = tmp_fork<EOL><DEDENT><DEDENT>except AttributeError as e:<EOL><INDENT>continue<EOL><DEDENT><DEDENT><DEDENT>return forks<EOL>", "docstring": "Builds the possible forks and connections between the provided\n        processes\n\n        This method loops through all the provided tasks and builds the\n        upstream and downstream pipeline if required. It then returns all\n        possible forks than need to be merged \u00e0 posteriori`\n\n        Parameters\n        ----------\n        process_descriptions : dict\n            Information of processes input, output and if is forkable\n        tasks : str\n            Space separated processes\n        check_upstream : bool\n            If is to build the upstream pipeline of the current task\n        check_downstream : bool\n            If is to build the downstream pipeline of the current task\n        count_forks : int\n            Number of current forks\n        total_tasks : str\n            All space separated processes\n        forks : list\n            Current forks\n\n        Returns\n        -------\n        list : List with all the possible pipeline forks", "id": "f6651:c0:m4"}
{"signature": "@staticmethod<EOL><INDENT>def validate_pipeline(pipeline_string):<DEDENT>", "body": "if \"<STR_LIT:(>\" in pipeline_string or \"<STR_LIT:)>\" in pipeline_string or \"<STR_LIT:|>\" inpipeline_string:<EOL><INDENT>logger.error(<EOL>colored_print(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>)<EOL>return False<EOL><DEDENT>return True<EOL>", "docstring": "Validate pipeline string\n\n        Validates the pipeline string by searching for forbidden characters\n\n        Parameters\n        ----------\n        pipeline_string : str\n            STring with the processes provided\n\n        Returns\n        -------", "id": "f6651:c0:m1"}
{"signature": "def update_config_pwd(msg, cfg):", "body": "msg_type = msg.__class__.__name__.lower()<EOL>key_fmt = msg.profile + \"<STR_LIT:_>\" + msg_type<EOL>if isinstance(msg._auth, (MutableSequence, tuple)):<EOL><INDENT>cfg.pwd[key_fmt] = \"<STR_LIT>\".join(msg._auth)<EOL><DEDENT>else:<EOL><INDENT>cfg.pwd[key_fmt] = msg._auth<EOL><DEDENT>", "docstring": "Updates the profile's auth entry with values set by the user.\nThis will overwrite existing values.\n\nArgs:\n    :msg: (Message class) an instance of a message class.\n    :cfg: (jsonconfig.Config) config instance.", "id": "f6674:m5"}
{"signature": "def verify_profile_name(msg, cfg):", "body": "if msg.profile not in cfg.data:<EOL><INDENT>raise UnknownProfileError(msg.profile)<EOL><DEDENT>", "docstring": "Verifies the profile name exists in the config.json file.\n\nArgs:\n    :msg: (Message class) an instance of a message class.\n    :cfg: (jsonconfig.Config) config instance.", "id": "f6674:m1"}
{"signature": "def configure_profile(msg_type, profile_name, data, auth):", "body": "with jsonconfig.Config(\"<STR_LIT>\", indent=<NUM_LIT:4>) as cfg:<EOL><INDENT>write_data(msg_type, profile_name, data, cfg)<EOL>write_auth(msg_type, profile_name, auth, cfg)<EOL><DEDENT>print(\"<STR_LIT>\" + profile_name + \"<STR_LIT>\")<EOL>print(\"<STR_LIT>\" + cfg.filename)<EOL>", "docstring": "Create the profile entry.\n\nArgs:\n    :msg_type: (str) message type to create config entry.\n    :profile_name: (str) name of the profile entry\n    :data: (dict) dict values for the 'settings'\n    :auth: (dict) auth parameters", "id": "f6674:m11"}
{"signature": "def _construct_message(self):", "body": "self.message[\"<STR_LIT>\"] = self.chat_id<EOL>self.message[\"<STR_LIT:text>\"] = \"<STR_LIT>\"<EOL>if self.from_:<EOL><INDENT>self.message[\"<STR_LIT:text>\"] += \"<STR_LIT>\" + self.from_ + \"<STR_LIT:\\n>\"<EOL><DEDENT>if self.subject:<EOL><INDENT>self.message[\"<STR_LIT:text>\"] += \"<STR_LIT>\" + self.subject + \"<STR_LIT:\\n>\"<EOL><DEDENT>self.message[\"<STR_LIT:text>\"] += self.body<EOL>self.message.update(self.params)<EOL>", "docstring": "Build the message params.", "id": "f6675:c0:m3"}
{"signature": "def get_chat_id(self, username):", "body": "if username is not None:<EOL><INDENT>chats = requests.get(self.base_url + \"<STR_LIT>\").json()<EOL>user = username.split(\"<STR_LIT:@>\")[-<NUM_LIT:1>]<EOL>for chat in chats[\"<STR_LIT:result>\"]:<EOL><INDENT>if chat[\"<STR_LIT:message>\"][\"<STR_LIT>\"][\"<STR_LIT:username>\"] == user:<EOL><INDENT>return chat[\"<STR_LIT:message>\"][\"<STR_LIT>\"][\"<STR_LIT:id>\"]<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Lookup chat_id of username if chat_id is unknown via API call.", "id": "f6675:c0:m2"}
{"signature": "def send_async(self):", "body": "MESSAGELOOP.add_message(self)<EOL>", "docstring": "Send message asynchronously.", "id": "f6675:c0:m6"}
{"signature": "@abstractmethod<EOL><INDENT>def send(self):<DEDENT>", "body": "", "docstring": "Send message synchronously.", "id": "f6676:c0:m0"}
{"signature": "def __repr__(self):", "body": "class_name = type(self).__name__<EOL>output = \"<STR_LIT>\".format(class_name)<EOL>for attr in self:<EOL><INDENT>if attr == \"<STR_LIT>\":<EOL><INDENT>output += \"<STR_LIT>\"<EOL><DEDENT>elif attr == \"<STR_LIT:body>\":<EOL><INDENT>output += \"<STR_LIT>\".format(attr, reprlib.repr(getattr(self, attr)))<EOL><DEDENT>else:<EOL><INDENT>output += \"<STR_LIT>\".format(attr, getattr(self, attr))<EOL><DEDENT><DEDENT>output += \"<STR_LIT:)>\"<EOL>return output<EOL>", "docstring": "repr(self) in debugging format with auth attr obfuscated.", "id": "f6676:c0:m2"}
{"signature": "def send(self):", "body": "self._generate_email()<EOL>if self.verbose:<EOL><INDENT>print(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(timestamp())<EOL>)<EOL><DEDENT>recipients = []<EOL>for i in (self.to, self.cc, self.bcc):<EOL><INDENT>if i:<EOL><INDENT>if isinstance(i, MutableSequence):<EOL><INDENT>recipients += i<EOL><DEDENT>else:<EOL><INDENT>recipients.append(i)<EOL><DEDENT><DEDENT><DEDENT>session = self._get_session()<EOL>if self.verbose:<EOL><INDENT>print(timestamp(), \"<STR_LIT>\")<EOL><DEDENT>session.sendmail(self.from_, recipients, self.message.as_string())<EOL>session.quit()<EOL>if self.verbose:<EOL><INDENT>print(timestamp(), \"<STR_LIT>\")<EOL><DEDENT>if self.verbose:<EOL><INDENT>print(<EOL>timestamp(),<EOL>type(self).__name__ + \"<STR_LIT>\",<EOL>self.__str__(indentation=\"<STR_LIT>\"),<EOL>)<EOL><DEDENT>print(\"<STR_LIT>\")<EOL>", "docstring": "Send the message.\nFirst, a message is constructed, then a session with the email\nservers is created, finally the message is sent and the session\nis stopped.", "id": "f6678:c0:m11"}
{"signature": "def _get_session(self):", "body": "if self.port in (<NUM_LIT>, \"<STR_LIT>\"):<EOL><INDENT>session = self._get_ssl()<EOL><DEDENT>elif self.port in (<NUM_LIT>, \"<STR_LIT>\"):<EOL><INDENT>session = self._get_tls()<EOL><DEDENT>try:<EOL><INDENT>session.login(self.from_, self._auth)<EOL><DEDENT>except SMTPResponseException as e:<EOL><INDENT>raise MessageSendError(e.smtp_error.decode(\"<STR_LIT>\"))<EOL><DEDENT>return session<EOL>", "docstring": "Start session with email server.", "id": "f6678:c0:m8"}
{"signature": "def _get_ssl(self):", "body": "return smtplib.SMTP_SSL(<EOL>self.server, self.port, context=ssl.create_default_context()<EOL>)<EOL>", "docstring": "Get an SMTP session with SSL.", "id": "f6678:c0:m9"}
{"signature": "def _add_body(self):", "body": "if self.body:<EOL><INDENT>b = MIMEText(\"<STR_LIT:text>\", \"<STR_LIT>\")<EOL>b.set_payload(self.body)<EOL>self.message.attach(b)<EOL><DEDENT>", "docstring": "Add body content of email.", "id": "f6678:c0:m6"}
{"signature": "def send_async(self):", "body": "MESSAGELOOP.add_message(self)<EOL>", "docstring": "Send message asynchronously.", "id": "f6678:c0:m12"}
{"signature": "def __str__(self, indentation=\"<STR_LIT:\\n>\"):", "body": "return (<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(<EOL>indentation,<EOL>self.server,<EOL>self.port,<EOL>indentation,<EOL>self.from_,<EOL>indentation,<EOL>self.to,<EOL>indentation,<EOL>self.cc,<EOL>indentation,<EOL>self.bcc,<EOL>indentation,<EOL>self.subject,<EOL>indentation,<EOL>reprlib.repr(self.body),<EOL>indentation,<EOL>self.attachments,<EOL>)<EOL>)<EOL>", "docstring": "print(Email(**args)) method.\n           Indentation value can be overridden in the function call.\n           The default is new line", "id": "f6678:c0:m1"}
{"signature": "@main.command(\"<STR_LIT>\")<EOL>@click.argument(\"<STR_LIT>\", type=click.STRING, required=False)<EOL>@click.argument(\"<STR_LIT:body>\", type=click.STRING, default=\"<STR_LIT>\", required=False)<EOL>@option(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", help=\"<STR_LIT>\")<EOL>@option(\"<STR_LIT>\", \"<STR_LIT>\", multiple=True, help=\"<STR_LIT>\")<EOL>@option(\"<STR_LIT>\", \"<STR_LIT>\", help=\"<STR_LIT>\")<EOL>@option(<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>multiple=True,<EOL>help=\"<STR_LIT>\",<EOL>)<EOL>@option(\"<STR_LIT>\", \"<STR_LIT>\", is_flag=True, help=\"<STR_LIT>\")<EOL>@option(<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>is_flag=True,<EOL>help=\"<STR_LIT>\",<EOL>)<EOL>@click.pass_context<EOL>def main_whatsapp(ctx, **kwds):", "body": "send_message(\"<STR_LIT>\", kwds)<EOL>", "docstring": "Send WhatsApp text message via the Twilio API.\n\n    * [PROFILE]: Pre-configured user profile.\n\n    * [BODY]:    Message body text.\n\n    * Example: messages whatsapp myWhatsAppProfile 'hello from whatsapp' -t '+12223334444' --verbose", "id": "f6679:m10"}
{"signature": "def send_async(self):", "body": "MESSAGELOOP.add_message(self)<EOL>", "docstring": "Send message asynchronously.", "id": "f6681:c0:m3"}
{"signature": "def send(self):", "body": "url = (<EOL>\"<STR_LIT>\"<EOL>+ self._auth[<NUM_LIT:0>]<EOL>+ \"<STR_LIT>\"<EOL>)<EOL>data = {<EOL>\"<STR_LIT>\": self.from_,<EOL>\"<STR_LIT>\": self.to,<EOL>\"<STR_LIT>\": self.body,<EOL>\"<STR_LIT>\": self.attachments,<EOL>}<EOL>if self.verbose:<EOL><INDENT>print(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(timestamp())<EOL>)<EOL><DEDENT>try:<EOL><INDENT>resp = requests.post(url, data=data, auth=(self._auth[<NUM_LIT:0>], self._auth[<NUM_LIT:1>]))<EOL>resp.raise_for_status()<EOL><DEDENT>except requests.exceptions.RequestException as e:<EOL><INDENT>exc = \"<STR_LIT>\".format(e, resp.json()[\"<STR_LIT:message>\"])<EOL>raise MessageSendError(exc)<EOL><DEDENT>self.sid = resp.json()[\"<STR_LIT>\"]<EOL>if self.verbose:<EOL><INDENT>print(<EOL>timestamp(),<EOL>type(self).__name__ + \"<STR_LIT>\",<EOL>self.__str__(indentation=\"<STR_LIT>\"),<EOL>\"<STR_LIT>\",<EOL>resp.status_code,<EOL>)<EOL><DEDENT>print(\"<STR_LIT>\")<EOL>return resp<EOL>", "docstring": "Send the SMS/MMS message.\nSet self.sid to return code of message.", "id": "f6681:c0:m2"}
{"signature": "def send(self, encoding=\"<STR_LIT>\"):", "body": "self._construct_message()<EOL>if self.verbose:<EOL><INDENT>print(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(timestamp())<EOL>)<EOL><DEDENT>if encoding == \"<STR_LIT>\":<EOL><INDENT>resp = requests.post(self.url, json=self.message)<EOL><DEDENT>elif encoding == \"<STR_LIT:url>\":<EOL><INDENT>resp = requests.post(self.url, data=self.message)<EOL><DEDENT>try:<EOL><INDENT>resp.raise_for_status()<EOL>if resp.history and resp.history[<NUM_LIT:0>].status_code >= <NUM_LIT>:<EOL><INDENT>raise MessageSendError(\"<STR_LIT>\")<EOL><DEDENT>elif \"<STR_LIT>\" in resp.text:<EOL><INDENT>raise MessageSendError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>except (requests.exceptions.HTTPError, MessageSendError) as e:<EOL><INDENT>raise MessageSendError(e)<EOL><DEDENT>if self.verbose:<EOL><INDENT>print(<EOL>timestamp(),<EOL>type(self).__name__,<EOL>\"<STR_LIT>\",<EOL>self.__str__(indentation=\"<STR_LIT>\"),<EOL>\"<STR_LIT>\",<EOL>resp.status_code,<EOL>)<EOL><DEDENT>print(\"<STR_LIT>\")<EOL>", "docstring": "Send the message via HTTP POST, default is json-encoded.", "id": "f6684:c0:m2"}
{"signature": "def send_async(self):", "body": "MESSAGELOOP.add_message(self)<EOL>", "docstring": "Send message asynchronously.", "id": "f6684:c0:m3"}
{"signature": "def _construct_message(self):", "body": "self.message = {\"<STR_LIT>\": self._auth, \"<STR_LIT>\": self.channel}<EOL>super()._construct_message()<EOL>", "docstring": "Set the message token/channel, then call the bas class constructor.", "id": "f6684:c2:m2"}
{"signature": "def send(msg_type, send_async=False, *args, **kwargs):", "body": "message = message_factory(msg_type, *args, **kwargs)<EOL>try:<EOL><INDENT>if send_async:<EOL><INDENT>message.send_async()<EOL><DEDENT>else:<EOL><INDENT>message.send()<EOL><DEDENT><DEDENT>except MessageSendError as e:<EOL><INDENT>err_exit(\"<STR_LIT>\", e)<EOL><DEDENT>", "docstring": "Constructs a message class and sends the message.\nDefaults to sending synchronously.  Set send_async=True to send\nasynchronously.\n\nArgs:\n    :msg_type: (str) the type of message to send, i.e. 'Email'\n    :send_async: (bool) default is False, set True to send asynchronously.\n    :kwargs: (dict) keywords arguments that are required for the\n        various message types.  See docstrings for each type.\n        i.e. help(messages.Email), help(messages.Twilio), etc.\n\nExample:\n    >>> kwargs = {\n              from_: 'me@here.com',\n              to: 'you@there.com',\n              auth: 'yourPassword',\n              subject: 'Email Subject',\n              body: 'Your message to send',\n              attachments: ['filepath1', 'filepath2'],\n        }\n    >>> messages.send('email', **kwargs)\n    Message sent...", "id": "f6685:m0"}
{"signature": "def check_valid(msg_type, attr, value, func, exec_info):", "body": "if value is not None:<EOL><INDENT>if isinstance(value, MutableSequence):<EOL><INDENT>for v in value:<EOL><INDENT>if not func(v):<EOL><INDENT>raise InvalidMessageInputError(msg_type, attr, value, exec_info)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if not func(value):<EOL><INDENT>raise InvalidMessageInputError(msg_type, attr, value, exec_info)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Checker function all validate_* functions below will call.\nRaises InvalidMessageInputError if input is not valid as per\ngiven func.", "id": "f6686:m3"}
{"signature": "def validate_slackwebhook(attr, value):", "body": "check_valid(\"<STR_LIT>\", attr, value, validus.isurl, \"<STR_LIT:url>\")<EOL>", "docstring": "SlackWebhook input validator function.", "id": "f6686:m6"}
{"signature": "def validate_whatsapp(attr, value):", "body": "if attr in (\"<STR_LIT>\", \"<STR_LIT:to>\"):<EOL><INDENT>if value is not None and \"<STR_LIT>\" in value:<EOL><INDENT>value = value.split(\"<STR_LIT>\")[-<NUM_LIT:1>]<EOL><DEDENT>check_valid(<EOL>\"<STR_LIT>\",<EOL>attr,<EOL>value,<EOL>validus.isint,<EOL>\"<STR_LIT>\",<EOL>)<EOL><DEDENT>elif attr in (\"<STR_LIT>\"):<EOL><INDENT>check_valid(\"<STR_LIT>\", attr, value, validus.isurl, \"<STR_LIT:url>\")<EOL><DEDENT>", "docstring": "WhatsApp input validator function.", "id": "f6686:m9"}
{"signature": "def validate_twilio(attr, value):", "body": "if attr in (\"<STR_LIT>\", \"<STR_LIT:to>\"):<EOL><INDENT>check_valid(\"<STR_LIT>\", attr, value, validus.isphone, \"<STR_LIT>\")<EOL><DEDENT>elif attr in (\"<STR_LIT>\"):<EOL><INDENT>check_valid(\"<STR_LIT>\", attr, value, validus.isurl, \"<STR_LIT:url>\")<EOL><DEDENT>", "docstring": "Twilio input validator function.", "id": "f6686:m5"}
{"signature": "def verbatim_tags(parser, token, endtagname):", "body": "text_and_nodes = []<EOL>while <NUM_LIT:1>:<EOL><INDENT>token = parser.tokens.pop(<NUM_LIT:0>)<EOL>if token.contents == endtagname:<EOL><INDENT>break<EOL><DEDENT>if token.token_type == template.base.TOKEN_VAR:<EOL><INDENT>text_and_nodes.append('<STR_LIT>')<EOL>text_and_nodes.append(token.contents)<EOL><DEDENT>elif token.token_type == template.base.TOKEN_TEXT:<EOL><INDENT>text_and_nodes.append(token.contents)<EOL><DEDENT>elif token.token_type == template.base.TOKEN_BLOCK:<EOL><INDENT>try:<EOL><INDENT>command = token.contents.split()[<NUM_LIT:0>]<EOL><DEDENT>except IndexError:<EOL><INDENT>parser.empty_block_tag(token)<EOL><DEDENT>try:<EOL><INDENT>compile_func = parser.tags[command]<EOL><DEDENT>except KeyError:<EOL><INDENT>parser.invalid_block_tag(token, command, None)<EOL><DEDENT>try:<EOL><INDENT>node = compile_func(parser, token)<EOL><DEDENT>except template.TemplateSyntaxError as e:<EOL><INDENT>if not parser.compile_function_error(token, e):<EOL><INDENT>raise<EOL><DEDENT><DEDENT>text_and_nodes.append(node)<EOL><DEDENT>if token.token_type == template.base.TOKEN_VAR:<EOL><INDENT>text_and_nodes.append('<STR_LIT>')<EOL><DEDENT><DEDENT>return text_and_nodes<EOL>", "docstring": "Javascript templates (jquery, handlebars.js, mustache.js) use constructs like:\n\n::\n\n    {{if condition}} print something{{/if}}\n\nThis, of course, completely screws up Django templates,\nbecause Django thinks {{ and }} means something.\n\nThe following code preserves {{ }} tokens.\n\nThis version of verbatim template tag allows you to use tags\nlike url {% url name %}. {% trans \"foo\" %} or {% csrf_token %} within.", "id": "f6688:m0"}
{"signature": "def _default_ns_prefix(nsmap):", "body": "if None in nsmap:<EOL><INDENT>default_url = nsmap[None]<EOL>prefix = None<EOL>for key, val in nsmap.iteritems():<EOL><INDENT>if val == default_url and key is not None:<EOL><INDENT>prefix = key<EOL>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\".format(<EOL>url=default_url<EOL>)<EOL>)<EOL><DEDENT>return prefix<EOL><DEDENT>raise ValueError(\"<STR_LIT>\")<EOL>", "docstring": "XML doc may have several prefix:namespace_url pairs, can also specify\na namespace_url as default, tags in that namespace don't need a prefix\nNOTE:\nwe rely on default namespace also present in prefixed form, I'm not sure if\nthis is an XML certainty or a quirk of the eBay WSDLs\n\nin our case the WSDL contains:\n    <wsdl:documentation>\n        <Version>1.0.0</Version>\n    </wsdl:documentation>\n...but our query needs to give a prefix to the path of `Version` so we need\nto determine the default namespace of the doc, find the matching prefix and\nreturn it", "id": "f6696:m1"}
{"signature": "def version_from_schema(schema_el):", "body": "vc_el = schema_el<EOL>while True:<EOL><INDENT>vc_el = vc_el.getprevious()<EOL>if vc_el is None:<EOL><INDENT>break<EOL><DEDENT>if vc_el.tag is etree.Comment:<EOL><INDENT>match = VERSION_COMMENT.search(vc_el.text)<EOL>if match:<EOL><INDENT>try:<EOL><INDENT>return match.group(<NUM_LIT:1>)<EOL><DEDENT>except IndexError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT><DEDENT>raise VersionNotFound('<STR_LIT>')<EOL>", "docstring": "returns: API version number <str>\nraises: <VersionNotFound>\n\nNOTE:\nrelies on presence of comment tags in the XSD, which are currently present\nfor both ebaySvc.xsd (TradingAPI) and ShoppingService.xsd (ShoppingAPI)", "id": "f6696:m0"}
{"signature": "def make_auth_headers():", "body": "path = os.path.expanduser(\"<STR_LIT>\")<EOL>if not os.path.exists(path):<EOL><INDENT>raise RuntimeError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>with open(path) as f:<EOL><INDENT>token = f.read().strip()<EOL><DEDENT>headers = {<EOL>'<STR_LIT>': '<STR_LIT>'.format(token),<EOL>}<EOL>return headers<EOL>", "docstring": "Make the authentication headers needed to use the Appveyor API.", "id": "f6700:m0"}
{"signature": "def ensure_dirs(filename):", "body": "dirname = os.path.dirname(filename)<EOL>if dirname and not os.path.exists(dirname):<EOL><INDENT>os.makedirs(dirname)<EOL><DEDENT>", "docstring": "Make sure the directories exist for `filename`.", "id": "f6700:m2"}
{"signature": "@return_error<EOL>def apply_with_return_error(args):", "body": "return args[<NUM_LIT:0>](*args[<NUM_LIT:1>:])<EOL>", "docstring": "args is a tuple where the first argument is a callable.\n\neg::\n\n    apply_with_return_error((func, 1, 2, 3)) - this will call func(1, 2, 3)", "id": "f6705:m1"}
{"signature": "def debug_storage(storage, base_info=False, chars=True, runs=False):", "body": "import codecs<EOL>import locale<EOL>import sys<EOL>if six.PY2:<EOL><INDENT>stderr = codecs.getwriter(locale.getpreferredencoding())(sys.stderr)<EOL><DEDENT>else:<EOL><INDENT>stderr = sys.stderr<EOL><DEDENT>caller = inspect.stack()[<NUM_LIT:1>][<NUM_LIT:3>]<EOL>stderr.write('<STR_LIT>' % caller)<EOL>if base_info:<EOL><INDENT>stderr.write(u'<STR_LIT>' % storage['<STR_LIT>'])<EOL>stderr.write(u'<STR_LIT>' % storage['<STR_LIT>'])<EOL><DEDENT>if runs:<EOL><INDENT>stderr.write(u'<STR_LIT>' % list(storage['<STR_LIT>']))<EOL><DEDENT>if chars:<EOL><INDENT>output = u'<STR_LIT>'<EOL>for _ch in storage['<STR_LIT>']:<EOL><INDENT>if _ch != '<STR_LIT:\\n>':<EOL><INDENT>output += _ch['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>output += '<STR_LIT:C>'<EOL><DEDENT><DEDENT>stderr.write(output + u'<STR_LIT:\\n>')<EOL>output = u'<STR_LIT>' % u'<STR_LIT>'.join(<EOL>[six.text_type(_ch['<STR_LIT>']) for _ch in storage['<STR_LIT>']])<EOL>stderr.write(output)<EOL>_types = [_ch['<STR_LIT:type>'].ljust(<NUM_LIT:3>) for _ch in storage['<STR_LIT>']]<EOL>for i in range(<NUM_LIT:3>):<EOL><INDENT>if i:<EOL><INDENT>output = u'<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>output = u'<STR_LIT>'<EOL><DEDENT>stderr.write(output % u'<STR_LIT>'.join([_t[i] for _t in _types]))<EOL><DEDENT><DEDENT>", "docstring": "Display debug information for the storage", "id": "f6710:m3"}
{"signature": "def get_empty_storage():", "body": "return {<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': [],<EOL>'<STR_LIT>': deque(),<EOL>}<EOL>", "docstring": "Return an empty storage skeleton, usable for testing", "id": "f6710:m14"}
{"signature": "def apply_mirroring(storage, debug):", "body": "<EOL>for _ch in storage['<STR_LIT>']:<EOL><INDENT>unichar = _ch['<STR_LIT>']<EOL>if mirrored(unichar) and_embedding_direction(_ch['<STR_LIT>']) == '<STR_LIT:R>':<EOL><INDENT>_ch['<STR_LIT>'] = MIRRORED.get(unichar, unichar)<EOL><DEDENT><DEDENT>if debug:<EOL><INDENT>debug_storage(storage)<EOL><DEDENT>", "docstring": "Applies L4: mirroring\n\n    See: http://unicode.org/reports/tr9/#L4", "id": "f6710:m13"}
{"signature": "def resolve_neutral_types(storage, debug):", "body": "for run in storage['<STR_LIT>']:<EOL><INDENT>start, length = run['<STR_LIT:start>'], run['<STR_LIT>']<EOL>chars = [{'<STR_LIT:type>': run['<STR_LIT>']}] + storage['<STR_LIT>'][start:start+length] +[{'<STR_LIT:type>': run['<STR_LIT>']}]<EOL>total_chars = len(chars)<EOL>seq_start = None<EOL>for idx in range(total_chars):<EOL><INDENT>_ch = chars[idx]<EOL>if _ch['<STR_LIT:type>'] in ('<STR_LIT:B>', '<STR_LIT:S>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>if seq_start is None:<EOL><INDENT>seq_start = idx<EOL>prev_bidi_type = chars[idx-<NUM_LIT:1>]['<STR_LIT:type>']<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if seq_start is not None:<EOL><INDENT>next_bidi_type = chars[idx]['<STR_LIT:type>']<EOL>if prev_bidi_type in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>prev_bidi_type = '<STR_LIT:R>'<EOL><DEDENT>if next_bidi_type in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>next_bidi_type = '<STR_LIT:R>'<EOL><DEDENT>for seq_idx in range(seq_start, idx):<EOL><INDENT>if prev_bidi_type == next_bidi_type:<EOL><INDENT>chars[seq_idx]['<STR_LIT:type>'] = prev_bidi_type<EOL><DEDENT>else:<EOL><INDENT>chars[seq_idx]['<STR_LIT:type>'] =_embedding_direction(chars[seq_idx]['<STR_LIT>'])<EOL><DEDENT><DEDENT>seq_start = None<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if debug:<EOL><INDENT>debug_storage(storage)<EOL><DEDENT>", "docstring": "Resolving neutral types. Implements N1 and N2\n\n    See: http://unicode.org/reports/tr9/#Resolving_Neutral_Types", "id": "f6710:m9"}
{"signature": "def _encode_fields(self, xfield, yfield, time_unit=None,<EOL>scale=Scale(zero=False)):", "body": "if scale is None:<EOL><INDENT>scale = Scale()<EOL><DEDENT>xfieldtype = xfield[<NUM_LIT:1>]<EOL>yfieldtype = yfield[<NUM_LIT:1>]<EOL>x_options = None<EOL>if len(xfield) > <NUM_LIT:2>:<EOL><INDENT>x_options = xfield[<NUM_LIT:2>]<EOL><DEDENT>y_options = None<EOL>if len(yfield) > <NUM_LIT:2>:<EOL><INDENT>y_options = yfield[<NUM_LIT:2>]<EOL><DEDENT>if time_unit is not None:<EOL><INDENT>if x_options is None:<EOL><INDENT>xencode = X(xfieldtype, timeUnit=time_unit)<EOL><DEDENT>else:<EOL><INDENT>xencode = X(<EOL>xfieldtype,<EOL>axis=Axis(**x_options),<EOL>timeUnit=time_unit,<EOL>scale=scale<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if x_options is None:<EOL><INDENT>xencode = X(xfieldtype)<EOL><DEDENT>else:<EOL><INDENT>xencode = X(<EOL>xfieldtype,<EOL>axis=Axis(**x_options),<EOL>scale=scale<EOL>)<EOL><DEDENT><DEDENT>if y_options is None:<EOL><INDENT>yencode = Y(yfieldtype, scale=scale)<EOL><DEDENT>else:<EOL><INDENT>yencode = Y(<EOL>yfieldtype,<EOL>axis=Axis(**y_options),<EOL>scale=scale<EOL>)<EOL><DEDENT>return xencode, yencode<EOL>", "docstring": "Encode the fields in Altair format", "id": "f6714:c0:m10"}
{"signature": "def gen(self, slug, name, dataobj, xfield, yfield, time_unit=None,<EOL>chart_type=\"<STR_LIT>\", width=<NUM_LIT>,<EOL>height=<NUM_LIT>, color=Color(), size=Size(),<EOL>scale=Scale(zero=False), shape=Shape(), filepath=None,<EOL>html_before=\"<STR_LIT>\", html_after=\"<STR_LIT>\"):", "body": "chart_obj = self.serialize(dataobj, xfield, yfield, time_unit,<EOL>chart_type, width, height, color, size, scale, shape)<EOL>html = self.html(slug, name, chart_obj, filepath,<EOL>html_before, html_after)<EOL>return html<EOL>", "docstring": "Generates an html chart from either a pandas dataframe, a dictionnary,\na list or an Altair Data object and optionally write it to a file", "id": "f6714:c0:m0"}
{"signature": "def smart_account(app):", "body": "if os.environ['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>return<EOL><DEDENT>from flask_security import SQLAlchemyUserDatastore, Security<EOL>account_module_name, account_class_name = os.environ[<EOL>'<STR_LIT>'].rsplit('<STR_LIT:.>', <NUM_LIT:1>)<EOL>account_module = importlib.import_module(account_module_name)<EOL>account_class = getattr(account_module, account_class_name)<EOL>role_module_name, role_class_name = os.environ[<EOL>'<STR_LIT>'].rsplit('<STR_LIT:.>', <NUM_LIT:1>)<EOL>role_module = importlib.import_module(role_module_name)<EOL>role_class = getattr(role_module, role_class_name)<EOL>r = True if os.environ[<EOL>'<STR_LIT>'] != '<STR_LIT>' else False<EOL>Security(app,<EOL>SQLAlchemyUserDatastore(<EOL>app.db, account_class, role_class),<EOL>register_blueprint=r)<EOL>pass<EOL>", "docstring": "\u5c1d\u8bd5\u4f7f\u7528\u5185\u7f6e\u65b9\u5f0f\u6784\u5efa\u8d26\u6237", "id": "f6727:m2"}
{"signature": "def load_tasks(app, entry_file=None):", "body": "from celery import Task<EOL>tasks_txt = os.path.join(os.path.dirname(entry_file), '<STR_LIT>',<EOL>'<STR_LIT>')<EOL>if not os.path.exists(tasks_txt):<EOL><INDENT>import sys<EOL>print('<STR_LIT>' % tasks_txt)<EOL>sys.exit(-<NUM_LIT:1>)<EOL><DEDENT>class ContextTask(Task):<EOL><INDENT>abstract = True<EOL>def __call__(self, *args, **kwargs):<EOL><INDENT>with app.app_context():<EOL><INDENT>return super().__call__(*args, **kwargs)<EOL><DEDENT><DEDENT><DEDENT>app.celery.config_from_object(app.config, namespace='<STR_LIT>')<EOL>app.celery.Task = ContextTask<EOL>with app.app_context():<EOL><INDENT>with open(tasks_txt, '<STR_LIT:r>') as f:<EOL><INDENT>for line in f:<EOL><INDENT>mod = line.strip('<STR_LIT:\\n>')<EOL>if mod:<EOL><INDENT>importlib.import_module(mod + '<STR_LIT>')<EOL><DEDENT>pass<EOL><DEDENT>pass<EOL><DEDENT>pass<EOL><DEDENT>pass<EOL>", "docstring": "\u88c5\u8f7d\u4efb\u52a1\uff0c\u89e3\u51b3celery\u65e0\u6cd5\u81ea\u52a8\u88c5\u8f7d\u7684\u95ee\u9898", "id": "f6727:m4"}
{"signature": "def write_file(fobj, opts=None, data=None, eopts=None):", "body": "lines = []<EOL>lines.append(\"<STR_LIT>\")<EOL>if opts:<EOL><INDENT>lines.append(\"<STR_LIT>\" + \"<STR_LIT:U+0020>\".join(opts))<EOL><DEDENT>if eopts:<EOL><INDENT>lines.append(\"<STR_LIT>\" + eopts)<EOL><DEDENT>if not data:<EOL><INDENT>data = [[<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>]]<EOL><DEDENT>for row in data:<EOL><INDENT>lines.append(\"<STR_LIT:U+0020>\".join([str(item) for item in row]))<EOL><DEDENT>lines = [item + \"<STR_LIT:\\n>\" for item in lines]<EOL>fobj.writelines(lines)<EOL>", "docstring": "Write a sample Touchstone file.", "id": "f6737:m4"}
{"signature": "def log(line, append=True):", "body": "with open(<EOL>os.path.join(os.environ[\"<STR_LIT>\"], \"<STR_LIT>\"), \"<STR_LIT:a>\" if append else \"<STR_LIT:w>\"<EOL>) as fobj:<EOL><INDENT>fobj.write(\"<STR_LIT>\".format(line))<EOL><DEDENT>", "docstring": "Debug xdist.", "id": "f6738:m0"}
{"signature": "def to_sci_string(number):", "body": "mant, exp = peng.functions._to_eng_tuple(number)<EOL>return \"<STR_LIT>\".format(<EOL>mant=mant, exp_sign=\"<STR_LIT:->\" if exp < <NUM_LIT:0> else \"<STR_LIT:+>\", exp=abs(exp)<EOL>)<EOL>", "docstring": "Return string with the number formatted in scientific notation.\n\nThis function does not have all the configurability of the public function\nto_scientific_string, it is a convenience function to test _to_eng_tuple", "id": "f6739:m0"}
{"signature": "def full_fft():", "body": "wobj, fsample, finc = fft_wave()<EOL>npoints = len(wobj.indep_vector)<EOL>ret_indep_vector = barange(-fsample / <NUM_LIT>, +fsample / <NUM_LIT>, finc)<EOL>ret_dep_vector = fft(wobj.dep_vector, npoints)<EOL>return npoints, wobj, ret_indep_vector, ret_dep_vector<EOL>", "docstring": "FFT of waveform where independent axis is evenly spaced and a power of 2.", "id": "f6743:m2"}
{"signature": "def std_wobj(<EOL>dep_name,<EOL>indep_vector=None,<EOL>dep_vector=None,<EOL>interp=\"<STR_LIT>\",<EOL>dep_units=\"<STR_LIT>\",<EOL>indep_scale=\"<STR_LIT>\",<EOL>):", "body": "<EOL>indep_vector = np.array([<NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:3>]) if indep_vector is None else indep_vector<EOL>dep_vector = np.array([<NUM_LIT:6>, <NUM_LIT:5>, <NUM_LIT:4>]) if dep_vector is None else dep_vector<EOL>return peng.Waveform(<EOL>indep_vector=indep_vector,<EOL>dep_vector=dep_vector,<EOL>dep_name=dep_name,<EOL>indep_scale=indep_scale,<EOL>dep_scale=\"<STR_LIT>\",<EOL>indep_units=\"<STR_LIT>\",<EOL>dep_units=dep_units,<EOL>interp=interp,<EOL>)<EOL>", "docstring": "Return a waveform with fixed parameters and given name.", "id": "f6744:m1"}
{"signature": "def _chunk_pars(freq_vector, data_matrix, pformat):", "body": "pformat = pformat.upper()<EOL>length = <NUM_LIT:4><EOL>for freq, data in zip(freq_vector, data_matrix):<EOL><INDENT>data = data.flatten()<EOL>for index in range(<NUM_LIT:0>, data.size, length):<EOL><INDENT>fpoint = [freq] if not index else [None]<EOL>cdata = data[index : index + length]<EOL>if pformat == \"<STR_LIT>\":<EOL><INDENT>vector1 = np.abs(cdata)<EOL>vector2 = np.rad2deg(np.angle(cdata))<EOL><DEDENT>elif pformat == \"<STR_LIT>\":<EOL><INDENT>vector1 = np.real(cdata)<EOL>vector2 = np.imag(cdata)<EOL><DEDENT>else:  <EOL><INDENT>vector1 = <NUM_LIT> * np.log10(np.abs(cdata))<EOL>vector2 = np.rad2deg(np.angle(cdata))<EOL><DEDENT>sep_data = np.array([])<EOL>for item1, item2 in zip(vector1, vector2):<EOL><INDENT>sep_data = np.concatenate((sep_data, np.array([item1, item2])))<EOL><DEDENT>ret = np.concatenate((np.array(fpoint), sep_data))<EOL>yield ret<EOL><DEDENT><DEDENT>", "docstring": "Chunk input data into valid Touchstone file rows.", "id": "f6747:m1"}
{"signature": "@pexdoc.pcontracts.new_contract()<EOL>def touchstone_noise_data(obj):", "body": "if isinstance(obj, dict) and (not obj):<EOL><INDENT>return None<EOL><DEDENT>if (not isinstance(obj, dict)) or (<EOL>isinstance(obj, dict)<EOL>and (sorted(obj.keys()) != sorted([\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]))<EOL>):<EOL><INDENT>raise ValueError(pexdoc.pcontracts.get_exdesc())<EOL><DEDENT>if not (isinstance(obj[\"<STR_LIT>\"], int) and (obj[\"<STR_LIT>\"] > <NUM_LIT:0>)):<EOL><INDENT>raise ValueError(pexdoc.pcontracts.get_exdesc())<EOL><DEDENT>if _check_increasing_real_numpy_vector(obj[\"<STR_LIT>\"]):<EOL><INDENT>raise ValueError(pexdoc.pcontracts.get_exdesc())<EOL><DEDENT>if _check_real_numpy_vector(obj[\"<STR_LIT>\"]):<EOL><INDENT>raise ValueError(pexdoc.pcontracts.get_exdesc())<EOL><DEDENT>if _check_number_numpy_vector(obj[\"<STR_LIT>\"]):<EOL><INDENT>raise ValueError(pexdoc.pcontracts.get_exdesc())<EOL><DEDENT>if not (<EOL>isinstance(obj[\"<STR_LIT>\"], np.ndarray)<EOL>and (len(obj[\"<STR_LIT>\"].shape) == <NUM_LIT:1>)<EOL>and (obj[\"<STR_LIT>\"].shape[<NUM_LIT:0>] > <NUM_LIT:0>)<EOL>and np.all(obj[\"<STR_LIT>\"] >= <NUM_LIT:0>)<EOL>):<EOL><INDENT>raise ValueError(pexdoc.pcontracts.get_exdesc())<EOL><DEDENT>sizes = [obj[\"<STR_LIT>\"].size, obj[\"<STR_LIT>\"].size, obj[\"<STR_LIT>\"].size, obj[\"<STR_LIT>\"].size]<EOL>if set(sizes) != set([obj[\"<STR_LIT>\"]]):<EOL><INDENT>raise ValueError(pexdoc.pcontracts.get_exdesc())<EOL><DEDENT>return None<EOL>", "docstring": "r\"\"\"\n    Validate if an object is an :ref:`TouchstoneNoiseData` pseudo-type object.\n\n    :param obj: Object\n    :type  obj: any\n\n    :raises: RuntimeError (Argument \\`*[argument_name]*\\` is not valid). The\n     token \\*[argument_name]\\* is replaced by the name of the argument the\n     contract is attached to\n\n    :rtype: None", "id": "f6748:m9"}
{"signature": "@pexdoc.pcontracts.new_contract()<EOL>def engineering_notation_number(obj):", "body": "try:<EOL><INDENT>obj = obj.rstrip()<EOL>float(obj[:-<NUM_LIT:1>] if obj[-<NUM_LIT:1>] in _SUFFIX_TUPLE else obj)<EOL>return None<EOL><DEDENT>except (AttributeError, IndexError, ValueError):<EOL><INDENT>raise ValueError(pexdoc.pcontracts.get_exdesc())<EOL><DEDENT>", "docstring": "r\"\"\"\n    Validate if an object is an :ref:`EngineeringNotationNumber` pseudo-type object.\n\n    :param obj: Object\n    :type  obj: any\n\n    :raises: RuntimeError (Argument \\`*[argument_name]*\\` is not valid). The\n     token \\*[argument_name]\\* is replaced by the name of the argument the\n     contract is attached to\n\n    :rtype: None", "id": "f6748:m3"}
{"signature": "@pexdoc.pcontracts.new_contract()<EOL>def touchstone_options(obj):", "body": "if (not isinstance(obj, dict)) or (<EOL>isinstance(obj, dict)<EOL>and (sorted(obj.keys()) != sorted([\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]))<EOL>):<EOL><INDENT>raise ValueError(pexdoc.pcontracts.get_exdesc())<EOL><DEDENT>if not (<EOL>(obj[\"<STR_LIT>\"].lower() in [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"])<EOL>and (obj[\"<STR_LIT>\"].lower() in [\"<STR_LIT:s>\", \"<STR_LIT:y>\", \"<STR_LIT:z>\", \"<STR_LIT:h>\", \"<STR_LIT:g>\"])<EOL>and (obj[\"<STR_LIT>\"].lower() in [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"])<EOL>and isinstance(obj[\"<STR_LIT>\"], float)<EOL>and (obj[\"<STR_LIT>\"] >= <NUM_LIT:0>)<EOL>):<EOL><INDENT>raise ValueError(pexdoc.pcontracts.get_exdesc())<EOL><DEDENT>", "docstring": "r\"\"\"\n    Validate if an object is an :ref:`TouchstoneOptions` pseudo-type object.\n\n    :param obj: Object\n    :type  obj: any\n\n    :raises: RuntimeError (Argument \\`*[argument_name]*\\` is not valid). The\n     token \\*[argument_name]\\* is replaced by the name of the argument the\n     contract is attached to\n\n    :rtype: None", "id": "f6748:m10"}
{"signature": "@pexdoc.pcontracts.new_contract()<EOL>def touchstone_data(obj):", "body": "if (not isinstance(obj, dict)) or (<EOL>isinstance(obj, dict)<EOL>and (sorted(obj.keys()) != sorted([\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]))<EOL>):<EOL><INDENT>raise ValueError(pexdoc.pcontracts.get_exdesc())<EOL><DEDENT>if not (isinstance(obj[\"<STR_LIT>\"], int) and (obj[\"<STR_LIT>\"] > <NUM_LIT:0>)):<EOL><INDENT>raise ValueError(pexdoc.pcontracts.get_exdesc())<EOL><DEDENT>if _check_increasing_real_numpy_vector(obj[\"<STR_LIT>\"]):<EOL><INDENT>raise ValueError(pexdoc.pcontracts.get_exdesc())<EOL><DEDENT>if not isinstance(obj[\"<STR_LIT>\"], np.ndarray):<EOL><INDENT>raise ValueError(pexdoc.pcontracts.get_exdesc())<EOL><DEDENT>vdata = [\"<STR_LIT:int>\", \"<STR_LIT:float>\", \"<STR_LIT>\"]<EOL>if not any([obj[\"<STR_LIT>\"].dtype.name.startswith(item) for item in vdata]):<EOL><INDENT>raise ValueError(pexdoc.pcontracts.get_exdesc())<EOL><DEDENT>if obj[\"<STR_LIT>\"].size != obj[\"<STR_LIT>\"]:<EOL><INDENT>raise ValueError(pexdoc.pcontracts.get_exdesc())<EOL><DEDENT>nports = int(math.sqrt(obj[\"<STR_LIT>\"].size / obj[\"<STR_LIT>\"].size))<EOL>if obj[\"<STR_LIT>\"] * (nports ** <NUM_LIT:2>) != obj[\"<STR_LIT>\"].size:<EOL><INDENT>raise ValueError(pexdoc.pcontracts.get_exdesc())<EOL><DEDENT>", "docstring": "r\"\"\"\n    Validate if an object is an :ref:`TouchstoneData` pseudo-type object.\n\n    :param obj: Object\n    :type  obj: any\n\n    :raises: RuntimeError (Argument \\`*[argument_name]*\\` is not valid). The\n     token \\*[argument_name]\\* is replaced by the name of the argument the\n     contract is attached to\n\n    :rtype: None", "id": "f6748:m8"}
{"signature": "@pexdoc.pcontracts.new_contract()<EOL>def increasing_real_numpy_vector(obj):", "body": "if _check_increasing_real_numpy_vector(obj):<EOL><INDENT>raise ValueError(pexdoc.pcontracts.get_exdesc())<EOL><DEDENT>", "docstring": "r\"\"\"\n    Validate if an object is :ref:`IncreasingRealNumpyVector` pseudo-type object.\n\n    :param obj: Object\n    :type  obj: any\n\n    :raises: RuntimeError (Argument \\`*[argument_name]*\\` is not valid). The\n     token \\*[argument_name]\\* is replaced by the name of the argument the\n     contract is attached to\n\n    :rtype: None", "id": "f6748:m5"}
{"signature": "@pexdoc.pcontracts.new_contract()<EOL>def wave_interp_option(obj):", "body": "exdesc = pexdoc.pcontracts.get_exdesc()<EOL>if not isinstance(obj, str):<EOL><INDENT>raise ValueError(exdesc)<EOL><DEDENT>if obj.upper() in [\"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>return None<EOL><DEDENT>raise ValueError(exdesc)<EOL>", "docstring": "r\"\"\"\n    Validate if an object is a :ref:`WaveInterpOption` pseudo-type object.\n\n    :param obj: Object\n    :type  obj: any\n\n    :raises: RuntimeError (Argument \\`*[argument_name]*\\` is not valid). The\n     token \\*[argument_name]\\* is replaced by the name of the argument the\n     contract is attached to\n\n    :rtype: None", "id": "f6748:m11"}
{"signature": "@pexdoc.pcontracts.contract(suffix=\"<STR_LIT>\", offset=int)<EOL>def peng_suffix_math(suffix, offset):", "body": "<EOL>eobj = pexdoc.exh.addex(ValueError, \"<STR_LIT>\")<EOL>try:<EOL><INDENT>return _POWER_TO_SUFFIX_DICT[_SUFFIX_TO_POWER_DICT[suffix] + <NUM_LIT:3> * offset]<EOL><DEDENT>except KeyError:<EOL><INDENT>eobj(True)<EOL><DEDENT>", "docstring": "r\"\"\"\n    Return engineering suffix from a starting suffix and an number of suffixes offset.\n\n    :param suffix: Engineering suffix\n    :type  suffix: :ref:`EngineeringNotationSuffix`\n\n    :param offset: Engineering suffix offset\n    :type  offset: integer\n\n    :rtype: string\n\n    .. [[[cog cog.out(exobj_eng.get_sphinx_autodoc()) ]]]\n    .. Auto-generated exceptions documentation for\n    .. peng.functions.peng_suffix_math\n\n    :raises:\n     * RuntimeError (Argument \\`offset\\` is not valid)\n\n     * RuntimeError (Argument \\`suffix\\` is not valid)\n\n     * ValueError (Argument \\`offset\\` is not valid)\n\n    .. [[[end]]]\n\n    For example:\n\n        >>> import peng\n        >>> peng.peng_suffix_math('u', 6)\n        'T'", "id": "f6749:m18"}
{"signature": "def _to_eng_tuple(number):", "body": "<EOL>split = lambda x, p: (x.ljust(<NUM_LIT:3> + neg, \"<STR_LIT:0>\")[:p], x[p:].rstrip(\"<STR_LIT:0>\"))<EOL>mant, exp = to_scientific_tuple(number)<EOL>mant, neg = mant.replace(\"<STR_LIT:.>\", \"<STR_LIT>\"), mant.startswith(\"<STR_LIT:->\")<EOL>new_mant = \"<STR_LIT:.>\".join(filter(None, split(mant, <NUM_LIT:1> + (exp % <NUM_LIT:3>) + neg)))<EOL>new_exp = int(<NUM_LIT:3> * math.floor(exp / <NUM_LIT:3>))<EOL>return NumComp(new_mant, new_exp)<EOL>", "docstring": "Return tuple with mantissa and exponent of number formatted in engineering notation.\n\n:param number: Number\n:type  number: integer or float\n\n:rtype: tuple", "id": "f6749:m9"}
{"signature": "def _split_every(text, sep, count, lstrip=False, rstrip=False):", "body": "ltr = \"<STR_LIT>\"[<NUM_LIT:2> * lstrip + rstrip].strip()<EOL>func = lambda x: getattr(x, ltr + \"<STR_LIT>\")() if ltr != \"<STR_LIT:_>\" else x<EOL>items = text.split(sep)<EOL>groups = zip_longest(*[iter(items)] * count, fillvalue=\"<STR_LIT>\")<EOL>joints = (sep.join(group).rstrip(sep) for group in groups)<EOL>return tuple(func(joint) for joint in joints)<EOL>", "docstring": "Return list of the words in the string, using count of a separator as delimiter.\n\n:param text: String to split\n:type  text: string\n\n:param sep: Separator\n:type  sep: string\n\n:param count: Number of separators to use as delimiter\n:type  count: integer\n\n:param lstrip: Flag that indicates whether whitespace is removed\n               from the beginning of each list item (True) or not\n               (False)\n:type  lstrip: boolean\n\n:param rstrip: Flag that indicates whether whitespace is removed\n               from the end of each list item (True) or not (False)\n:type  rstrip: boolean\n\n:rtype: tuple", "id": "f6749:m8"}
{"signature": "@pexdoc.pcontracts.contract(snum=\"<STR_LIT>\")<EOL>def peng_float(snum):", "body": "<EOL>snum = snum.rstrip()<EOL>power = _SUFFIX_POWER_DICT[\"<STR_LIT:U+0020>\" if snum[-<NUM_LIT:1>].isdigit() else snum[-<NUM_LIT:1>]]<EOL>return float(snum if snum[-<NUM_LIT:1>].isdigit() else snum[:-<NUM_LIT:1>]) * power<EOL>", "docstring": "r\"\"\"\n    Return floating point equivalent of a number represented in engineering notation.\n\n    :param snum: Number\n    :type  snum: :ref:`EngineeringNotationNumber`\n\n    :rtype: string\n\n    .. [[[cog cog.out(exobj_eng.get_sphinx_autodoc()) ]]]\n    .. Auto-generated exceptions documentation for\n    .. peng.functions.peng_float\n\n    :raises: RuntimeError (Argument \\`snum\\` is not valid)\n\n    .. [[[end]]]\n\n    For example:\n\n        >>> import peng\n        >>> peng.peng_float(peng.peng(1235.6789E3, 3, False))\n        1236000.0", "id": "f6749:m12"}
{"signature": "@pexdoc.pcontracts.contract(number=\"<STR_LIT>\")<EOL>def no_exp(number):", "body": "mant, exp = to_scientific_tuple(number)<EOL>if not exp:<EOL><INDENT>return str(number)<EOL><DEDENT>floating_mant = \"<STR_LIT:.>\" in mant<EOL>mant = mant.replace(\"<STR_LIT:.>\", \"<STR_LIT>\")<EOL>if exp < <NUM_LIT:0>:<EOL><INDENT>return \"<STR_LIT>\" + \"<STR_LIT:0>\" * (-exp - <NUM_LIT:1>) + mant<EOL><DEDENT>if not floating_mant:<EOL><INDENT>return mant + \"<STR_LIT:0>\" * exp + (\"<STR_LIT>\" if isinstance(number, float) else \"<STR_LIT>\")<EOL><DEDENT>lfpart = len(mant) - <NUM_LIT:1><EOL>if lfpart < exp:<EOL><INDENT>return (mant + \"<STR_LIT:0>\" * (exp - lfpart)).rstrip(\"<STR_LIT:.>\")<EOL><DEDENT>return mant<EOL>", "docstring": "r\"\"\"\n    Convert number to string guaranteeing result is not in scientific notation.\n\n    :param number: Number to convert\n    :type  number: integer or float\n\n    :rtype: string\n\n    .. [[[cog cog.out(exobj_eng.get_sphinx_autodoc()) ]]]\n    .. Auto-generated exceptions documentation for peng.functions.no_exp\n\n    :raises: RuntimeError (Argument \\`number\\` is not valid)\n\n    .. [[[end]]]", "id": "f6749:m10"}
{"signature": "def _remove_extra_delims(expr, ldelim=\"<STR_LIT:(>\", rdelim=\"<STR_LIT:)>\", fcount=None):", "body": "if not expr.strip():<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>fcount = [<NUM_LIT:0>] if fcount is None else fcount<EOL>tfuncs = _get_functions(expr, ldelim=ldelim, rdelim=rdelim)<EOL>for fdict in reversed(tfuncs):<EOL><INDENT>fcount[<NUM_LIT:0>] += <NUM_LIT:1><EOL>fdict[\"<STR_LIT>\"] = \"<STR_LIT>\" + str(fcount[<NUM_LIT:0>])<EOL>expr = expr[: fdict[\"<STR_LIT:start>\"]] + fdict[\"<STR_LIT>\"] + expr[fdict[\"<STR_LIT>\"] + <NUM_LIT:1> :]<EOL>fdict[\"<STR_LIT>\"] = _remove_extra_delims(<EOL>fdict[\"<STR_LIT>\"], ldelim=ldelim, rdelim=rdelim, fcount=fcount<EOL>)<EOL><DEDENT>expr = _build_expr(<EOL>_parse_expr(expr, ldelim=ldelim, rdelim=rdelim), ldelim=ldelim, rdelim=rdelim<EOL>)<EOL>for fdict in tfuncs:<EOL><INDENT>expr = expr.replace(<EOL>fdict[\"<STR_LIT>\"], fdict[\"<STR_LIT>\"] + ldelim + fdict[\"<STR_LIT>\"] + rdelim<EOL>)<EOL><DEDENT>return expr<EOL>", "docstring": "Remove unnecessary delimiters (parenthesis, brackets, etc.).\n\nInternal function that can be recursed", "id": "f6749:m7"}
{"signature": "def __repr__(self):<EOL>", "body": "template = (<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL>return template.format(<EOL>repr(self._indep_vector),<EOL>repr(self._dep_vector),<EOL>repr(self._dep_name),<EOL>repr(self._indep_scale),<EOL>repr(self._dep_scale),<EOL>repr(self._indep_units),<EOL>repr(self._dep_units),<EOL>repr(self._interp),<EOL>)<EOL>", "docstring": "r\"\"\"\n        Return a string with the expression needed to re-create the object.\n\n        For example:\n\n            >>> import numpy as np\n            >>> import peng\n            >>> obj = peng.Waveform(\n            ...     np.array([1, 2, 3]),\n            ...     np.array([4, 5, 6]),\n            ...     'test'\n            ... )\n            >>> repr(obj)\n            \"peng.Waveform(indep_vector=array([1, 2, 3]), dep_vector=array([4, 5, 6]), dep_name='test', indep_scale='LINEAR', dep_scale='LINEAR', indep_units='', dep_units='', interp='CONTINUOUS')\"", "id": "f6751:c0:m31"}
{"signature": "def _get_indep_vector(wave_a, wave_b):", "body": "exobj = pexdoc.exh.addex(RuntimeError, \"<STR_LIT>\")<EOL>min_bound = max(np.min(wave_a.indep_vector), np.min(wave_b.indep_vector))<EOL>max_bound = min(np.max(wave_a.indep_vector), np.max(wave_b.indep_vector))<EOL>exobj(bool(min_bound > max_bound))<EOL>raw_range = np.unique(np.concatenate((wave_a.indep_vector, wave_b.indep_vector)))<EOL>return raw_range[np.logical_and(min_bound <= raw_range, raw_range <= max_bound)]<EOL>", "docstring": "Create new independent variable vector.", "id": "f6751:m2"}
{"signature": "def __floordiv__(self, other):", "body": "return self._operation(other, \"<STR_LIT>\")<EOL>", "docstring": "Integer-divide the dependent variable vector of a waveform.\n\nThe integer division may be by the dependent variable vector of another\nwaveform, the dependent variable vector of a waveform by a number, or a\nnumber by the dependent variable vector of a waveform. In the latter\ncase a :py:class:`peng.Waveform()` object is returned with the result.\n\nFor example:\n\n    >>> import numpy as np\n    >>> import peng\n    >>> indep_vector = np.array([1, 2, 3])\n    >>> dep_vector_a = np.array([4, 5, 6])\n    >>> dep_vector_b = np.array([8, 2, 4])\n    >>> obj_a = peng.Waveform(indep_vector, dep_vector_a, 'obj_a')\n    >>> obj_b = peng.Waveform(indep_vector, dep_vector_b, 'obj_b')\n    >>> print(obj_a//obj_b)\n    Waveform: obj_a//obj_b\n    Independent variable: [ 1, 2, 3 ]\n    Dependent variable: [ 0, 2, 1 ]\n    Independent variable scale: LINEAR\n    Dependent variable scale: LINEAR\n    Independent variable units: (None)\n    Dependent variable units: (None)\n    Interpolating function: CONTINUOUS\n\n.. [[[cog cog.out(exobj_eng.get_sphinx_autodoc(raised=True)) ]]]\n.. Auto-generated exceptions documentation for\n.. peng.wave_core.Waveform.__floordiv__\n\n:raises:\n * RuntimeError (Independent variable ranges do not overlap)\n\n * RuntimeError (Waveforms are not compatible)\n\n * TypeError (Complex operands not supported)\n\n * TypeError (Data type not supported)\n\n.. [[[end]]]", "id": "f6751:c0:m10"}
{"signature": "def __rfloordiv__(self, other):", "body": "return self._operation(other, \"<STR_LIT>\", reflected=True)<EOL>", "docstring": "Reflected floor (integer) division.\n\nSee :py:meth:`peng.Waveform.__floordiv__` for more details", "id": "f6751:c0:m32"}
{"signature": "def __rrshift__(self, other):", "body": "return self._operation(other, \"<STR_LIT>\", reflected=True)<EOL>", "docstring": "Reflected right shift.\n\nSee :py:meth:`peng.Waveform.__rshift__` for more details", "id": "f6751:c0:m38"}
{"signature": "def __nonzero__(self):  ", "body": "return not bool(<EOL>np.all(<EOL>np.isclose(<EOL>self._dep_vector, np.zeros(len(self._dep_vector)), FP_RTOL, FP_ATOL<EOL>)<EOL>)<EOL>)<EOL>", "docstring": "Test if the waveform dependent vector is zero for all its elements.\n\nFor example:\n\n    >>> import numpy as np\n    >>> import peng\n    >>> indep_vector = np.array([1, 2, 3])\n    >>> dep_vector = np.array([4, 5, 6])\n    >>> obj = peng.Waveform(indep_vector, dep_vector, 'obj_a')\n    >>> if obj:\n    ...     print('Boolean test returned: True')\n    ... else:\n    ...     print('Boolean test returned: False')\n    Boolean test returned: True\n    >>> dep_vector = np.zeros(3)\n    >>> obj = peng.Waveform(indep_vector, dep_vector, 'obj_a')\n    >>> if obj:\n    ...     print('Boolean test returned: True')\n    ... else:\n    ...     print('Boolean test returned: False')\n    Boolean test returned: False", "id": "f6751:c0:m24"}
{"signature": "def __rsub__(self, other):", "body": "return self._operation(other, \"<STR_LIT:->\")<EOL>", "docstring": "Reflected subtraction.\n\nSee :py:meth:`peng.Waveform.__sub__` for more details", "id": "f6751:c0:m40"}
{"signature": "def __iter__(self):", "body": "for iitem, ditem in zip(self._indep_vector, self._dep_vector):<EOL><INDENT>yield iitem, ditem<EOL><DEDENT>", "docstring": "Return an iterable over the independent and dependent variable vectors.\n\nEach item returned by an iterator is a :py:data:`peng.Point` named\ntuple\n\n:rtype: iterable", "id": "f6751:c0:m15"}
{"signature": "def __rlshift__(self, other):", "body": "return self._operation(other, \"<STR_LIT>\", reflected=True)<EOL>", "docstring": "Reflected left shift.\n\nSee :py:meth:`peng.Waveform.__lshift__` for more details", "id": "f6751:c0:m33"}
{"signature": "def __ne__(self, other):", "body": "return not self.__eq__(other)<EOL>", "docstring": "Test waveform inequality.\n\nTwo waveforms are considered unequal if their independent variable\nvectors are different with :py:data:`peng.FP_ATOL` absolute tolerance\nand :py:data:`peng.FP_RTOL` relative tolerance, and/or their dependent\nvariable vectors are different with :py:data:`peng.FP_ATOL` absolute\ntolerance and :py:data:`peng.FP_RTOL` relative tolerance, and/or their\nindependent variable scales are not the same, and/or their dependent\nvariable scales are not the, and/or their independent variable units\nare not the same, and/or their dependent variable units are not the\nsame and/or they do not have the same interpolation function.\n\nA waveform is considered unequal to a real number when its dependent\nvariable is not equal to that number at least in one element.", "id": "f6751:c0:m22"}
{"signature": "def __mul__(self, other):", "body": "return self._operation(other, \"<STR_LIT:*>\")<EOL>", "docstring": "Multiply the dependent variable vector of a waveform.\n\nThe multiplication may be computed element-by-element using another the\ndependent variable vector of another waveform or a number.\n\nFor example:\n\n    >>> import numpy as np\n    >>> import peng\n    >>> indep_vector = np.array([1, 2, 3])\n    >>> dep_vector_a = np.array([4, 5, 6])\n    >>> dep_vector_b = np.array([8, 2, 4])\n    >>> obj_a = peng.Waveform(indep_vector, dep_vector_a, 'obj_a')\n    >>> obj_b = peng.Waveform(indep_vector, dep_vector_b, 'obj_b')\n    >>> print(obj_a*obj_b)\n    Waveform: obj_a*obj_b\n    Independent variable: [ 1, 2, 3 ]\n    Dependent variable: [ 32, 10, 24 ]\n    Independent variable scale: LINEAR\n    Dependent variable scale: LINEAR\n    Independent variable units: (None)\n    Dependent variable units: (None)\n    Interpolating function: CONTINUOUS\n\n.. [[[cog cog.out(exobj_eng.get_sphinx_autodoc()) ]]]\n.. Auto-generated exceptions documentation for\n.. peng.wave_core.Waveform.__mul__\n\n:raises:\n * RuntimeError (Waveforms are not compatible)\n\n * TypeError (Data type not supported)\n\n.. [[[end]]]", "id": "f6751:c0:m21"}
{"signature": "def __rmul__(self, other):", "body": "return self._operation(other, \"<STR_LIT:*>\")<EOL>", "docstring": "Reflected multiplication.\n\nSee :py:meth:`peng.Waveform.__mul__` for more details", "id": "f6751:c0:m35"}
{"signature": "def __or__(self, other):", "body": "return self._operation(other, \"<STR_LIT:|>\")<EOL>", "docstring": "Bit-wise logic or the dependent variable of a waveform.\n\nThe other operand may be the dependent variable vector of another\nwaveform or a number.\n\nFor example:\n\n    >>> import numpy as np\n    >>> import peng\n    >>> indep_vector = np.array([1, 2, 3])\n    >>> dep_vector_a = np.array([4, 5, 6])\n    >>> dep_vector_b = np.array([8, 2, 4])\n    >>> obj_a = peng.Waveform(indep_vector, dep_vector_a, 'obj_a')\n    >>> obj_b = peng.Waveform(indep_vector, dep_vector_b, 'obj_b')\n    >>> print(obj_a|obj_b)\n    Waveform: obj_a|obj_b\n    Independent variable: [ 1, 2, 3 ]\n    Dependent variable: [ 12, 7, 6 ]\n    Independent variable scale: LINEAR\n    Dependent variable scale: LINEAR\n    Independent variable units: (None)\n    Dependent variable units: (None)\n    Interpolating function: CONTINUOUS\n\n.. [[[cog cog.out(exobj_eng.get_sphinx_autodoc(raised=True)) ]]]\n.. Auto-generated exceptions documentation for\n.. peng.wave_core.Waveform.__or__\n\n:raises:\n * RuntimeError (Independent variable ranges do not overlap)\n\n * RuntimeError (Waveforms are not compatible)\n\n * TypeError (Complex operands not supported)\n\n * TypeError (Data type not supported)\n\n.. [[[end]]]", "id": "f6751:c0:m25"}
{"signature": "def __rmod__(self, other):", "body": "return self._operation(other, \"<STR_LIT:%>\", reflected=True)<EOL>", "docstring": "Reflected division.\n\nSee :py:meth:`peng.Waveform.__mod__` for more details", "id": "f6751:c0:m34"}
{"signature": "def __contains__(self, item):", "body": "if (not isinstance(item, tuple)) or (<EOL>isinstance(item, tuple) and (len(item) != <NUM_LIT:2>)<EOL>):<EOL><INDENT>return False<EOL><DEDENT>tchk = any([isinstance(item[<NUM_LIT:0>], typ) for typ in [int, float]])<EOL>if not tchk:<EOL><INDENT>return False<EOL><DEDENT>tchk = any([isinstance(item[<NUM_LIT:1>], typ) for typ in [int, float, complex]])<EOL>if not tchk:<EOL><INDENT>return False<EOL><DEDENT>indices = [np.where(self._indep_vector >= item[<NUM_LIT:0>])[<NUM_LIT:0>][<NUM_LIT:0>]]<EOL>if indices[<NUM_LIT:0>]:<EOL><INDENT>indices.append(indices[<NUM_LIT:0>] - <NUM_LIT:1>)<EOL><DEDENT>for index in indices:<EOL><INDENT>icmp = np.isclose(<EOL>np.array([self._indep_vector[index]]),<EOL>np.array([item[<NUM_LIT:0>]]),<EOL>FP_RTOL,<EOL>FP_ATOL,<EOL>)<EOL>dcmp = np.isclose(<EOL>np.array([self._dep_vector[index]]),<EOL>np.array([item[<NUM_LIT:1>]]),<EOL>FP_RTOL,<EOL>FP_ATOL,<EOL>)<EOL>if icmp and dcmp:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Test if an item is a data point in the waveform.\n\nAn item is in a waveform when it is a tuple with the characteristics of\nthe :py:data:`peng.Point` named tuple and its independent and dependent\nvalues match a waveform's data point with :py:data:`peng.FP_ATOL`\nabsolute tolerance and :py:data:`peng.FP_RTOL` relative tolerance\n\n:param item: Object\n:type  item: any", "id": "f6751:c0:m5"}
{"signature": "def __le__(self, other):", "body": "return self._operation(other, \"<STR_LIT>\")<EOL>", "docstring": "Test whether waveform is less than or equal to another waveform or real number.\n\nA waveform is less than or equal to another waveform or a number if\nall elements of its dependent variable vector are less than or equal\nto, element-by-element, the elements of the dependent variable vector\nof another waveform or a real number with :py:data:`peng.FP_ATOL`\nabsolute tolerance and :py:data:`peng.FP_RTOL` relative tolerance\n\n.. [[[cog cog.out(exobj_eng.get_sphinx_autodoc(raised=True)) ]]]\n.. Auto-generated exceptions documentation for\n.. peng.wave_core.Waveform.__le__\n\n:raises:\n * RuntimeError (Independent variable ranges do not overlap)\n\n * RuntimeError (Waveforms are not compatible)\n\n * TypeError (Complex operands not supported)\n\n * TypeError (Data type not supported)\n\n.. [[[end]]]", "id": "f6751:c0:m16"}
{"signature": "@pexdoc.pcontracts.contract(wave=Waveform)<EOL>def cos(wave):", "body": "return _operation(wave, \"<STR_LIT>\", \"<STR_LIT>\", np.cos)<EOL>", "docstring": "r\"\"\"\n    Return the cosine of a waveform's dependent variable vector.\n\n    :param wave: Waveform\n    :type  wave: :py:class:`peng.eng.Waveform`\n\n    :rtype: :py:class:`peng.eng.Waveform`\n\n    .. [[[cog cog.out(exobj_eng.get_sphinx_autodoc()) ]]]\n    .. Auto-generated exceptions documentation for peng.wave_functions.cos\n\n    :raises: RuntimeError (Argument \\`wave\\` is not valid)\n\n    .. [[[end]]]", "id": "f6752:m14"}
{"signature": "@pexdoc.pcontracts.contract(wave=Waveform)<EOL>def asin(wave):", "body": "pexdoc.exh.addex(<EOL>ValueError,<EOL>\"<STR_LIT>\",<EOL>bool((min(wave._dep_vector) < -<NUM_LIT:1>) or (max(wave._dep_vector) > <NUM_LIT:1>)),<EOL>)<EOL>return _operation(wave, \"<STR_LIT>\", \"<STR_LIT>\", np.arcsin)<EOL>", "docstring": "r\"\"\"\n    Return the arc sine of a waveform's dependent variable vector.\n\n    :param wave: Waveform\n    :type  wave: :py:class:`peng.eng.Waveform`\n\n    :rtype: :py:class:`peng.eng.Waveform`\n\n    .. [[[cog cog.out(exobj_eng.get_sphinx_autodoc()) ]]]\n    .. Auto-generated exceptions documentation for\n    .. peng.wave_functions.asin\n\n    :raises:\n     * RuntimeError (Argument \\`wave\\` is not valid)\n\n     * ValueError (Math domain error)\n\n    .. [[[end]]]", "id": "f6752:m8"}
{"signature": "@pexdoc.pcontracts.contract(wave=Waveform)<EOL>def wfloat(wave):", "body": "pexdoc.exh.addex(<EOL>TypeError,<EOL>\"<STR_LIT>\",<EOL>wave._dep_vector.dtype.name.startswith(\"<STR_LIT>\"),<EOL>)<EOL>ret = copy.copy(wave)<EOL>ret._dep_vector = ret._dep_vector.astype(np.float)<EOL>return ret<EOL>", "docstring": "r\"\"\"\n    Convert a waveform's dependent variable vector to float.\n\n    :param wave: Waveform\n    :type  wave: :py:class:`peng.eng.Waveform`\n\n    :rtype: :py:class:`peng.eng.Waveform`\n\n    .. [[[cog cog.out(exobj_eng.get_sphinx_autodoc()) ]]]\n    .. Auto-generated exceptions documentation for\n    .. peng.wave_functions.wfloat\n\n    :raises:\n     * RuntimeError (Argument \\`wave\\` is not valid)\n\n     * TypeError (Cannot convert complex to float)\n\n    .. [[[end]]]", "id": "f6752:m52"}
{"signature": "@pexdoc.pcontracts.contract(<EOL>wave=Waveform, indep_min=\"<STR_LIT>\", indep_max=\"<STR_LIT>\"<EOL>)<EOL>def average(wave, indep_min=None, indep_max=None):", "body": "ret = copy.copy(wave)<EOL>_bound_waveform(ret, indep_min, indep_max)<EOL>area = _running_area(ret._indep_vector, ret._dep_vector)<EOL>area[<NUM_LIT:0>] = ret._dep_vector[<NUM_LIT:0>]<EOL>deltas = ret._indep_vector - ret._indep_vector[<NUM_LIT:0>]<EOL>deltas[<NUM_LIT:0>] = <NUM_LIT:1.0><EOL>ret._dep_vector = np.divide(area, deltas)<EOL>ret.dep_name = \"<STR_LIT>\".format(ret._dep_name)<EOL>return ret<EOL>", "docstring": "r\"\"\"\n    Return the running average of a waveform's dependent variable vector.\n\n    :param wave: Waveform\n    :type  wave: :py:class:`peng.eng.Waveform`\n\n    :param indep_min: Independent vector start point of computation\n    :type  indep_min: integer or float\n\n    :param indep_max: Independent vector stop point of computation\n    :type  indep_max: integer or float\n\n    :rtype: :py:class:`peng.eng.Waveform`\n\n    .. [[[cog cog.out(exobj_eng.get_sphinx_autodoc(raised=True)) ]]]\n    .. Auto-generated exceptions documentation for\n    .. peng.wave_functions.average\n\n    :raises:\n     * RuntimeError (Argument \\`indep_max\\` is not valid)\n\n     * RuntimeError (Argument \\`indep_min\\` is not valid)\n\n     * RuntimeError (Argument \\`wave\\` is not valid)\n\n     * RuntimeError (Incongruent \\`indep_min\\` and \\`indep_max\\`\n       arguments)\n\n    .. [[[end]]]", "id": "f6752:m12"}
{"signature": "@pexdoc.pcontracts.contract(<EOL>wave=Waveform,<EOL>npoints=\"<STR_LIT>\",<EOL>indep_min=\"<STR_LIT>\",<EOL>indep_max=\"<STR_LIT>\",<EOL>unwrap=bool,<EOL>rad=bool,<EOL>)<EOL>def ifftp(wave, npoints=None, indep_min=None, indep_max=None, unwrap=True, rad=True):", "body": "return phase(ifft(wave, npoints, indep_min, indep_max), unwrap=unwrap, rad=rad)<EOL>", "docstring": "r\"\"\"\n    Return the phase of the inverse Fast Fourier Transform of a waveform.\n\n    :param wave: Waveform\n    :type  wave: :py:class:`peng.eng.Waveform`\n\n    :param npoints: Number of points to use in the transform. If **npoints**\n                    is less than the size of the independent variable vector\n                    the waveform is truncated; if **npoints** is greater than\n                    the size of the independent variable vector, the waveform\n                    is zero-padded\n    :type  npoints: positive integer\n\n    :param indep_min: Independent vector start point of computation\n    :type  indep_min: integer or float\n\n    :param indep_max: Independent vector stop point of computation\n    :type  indep_max: integer or float\n\n    :param unwrap: Flag that indicates whether phase should change phase shifts\n                   to their :code:`2*pi` complement (True) or not (False)\n    :type  unwrap: boolean\n\n    :param rad: Flag that indicates whether phase should be returned in radians\n                (True) or degrees (False)\n    :type  rad: boolean\n\n    :rtype: :py:class:`peng.eng.Waveform`\n\n    .. [[[cog cog.out(exobj_eng.get_sphinx_autodoc(raised=True)) ]]]\n    .. Auto-generated exceptions documentation for\n    .. peng.wave_functions.ifftp\n\n    :raises:\n     * RuntimeError (Argument \\`indep_max\\` is not valid)\n\n     * RuntimeError (Argument \\`indep_min\\` is not valid)\n\n     * RuntimeError (Argument \\`npoints\\` is not valid)\n\n     * RuntimeError (Argument \\`rad\\` is not valid)\n\n     * RuntimeError (Argument \\`unwrap\\` is not valid)\n\n     * RuntimeError (Argument \\`wave\\` is not valid)\n\n     * RuntimeError (Incongruent \\`indep_min\\` and \\`indep_max\\`\n       arguments)\n\n     * RuntimeError (Non-uniform frequency spacing)\n\n    .. [[[end]]]", "id": "f6752:m31"}
{"signature": "@pexdoc.pcontracts.contract(wave=Waveform)<EOL>def sinh(wave):", "body": "return _operation(wave, \"<STR_LIT>\", \"<STR_LIT>\", np.sinh)<EOL>", "docstring": "r\"\"\"\n    Return the hyperbolic sine of a waveform's dependent variable vector.\n\n    :param wave: Waveform\n    :type  wave: :py:class:`peng.eng.Waveform`\n\n    :rtype: :py:class:`peng.eng.Waveform`\n\n    .. [[[cog cog.out(exobj_eng.get_sphinx_autodoc()) ]]]\n    .. Auto-generated exceptions documentation for\n    .. peng.wave_functions.sinh\n\n    :raises: RuntimeError (Argument \\`wave\\` is not valid)\n\n    .. [[[end]]]", "id": "f6752:m46"}
{"signature": "@pexdoc.pcontracts.contract(wave=Waveform)<EOL>def floor(wave):", "body": "return _operation(wave, \"<STR_LIT>\", wave.dep_units, np.floor)<EOL>", "docstring": "r\"\"\"\n    Return the floor of a waveform's dependent variable vector.\n\n    :param wave: Waveform\n    :type  wave: :py:class:`peng.eng.Waveform`\n\n    :rtype: :py:class:`peng.eng.Waveform`\n\n    .. [[[cog cog.out(exobj_eng.get_sphinx_autodoc()) ]]]\n    .. Auto-generated exceptions documentation for\n    .. peng.wave_functions.floor\n\n    :raises: RuntimeError (Argument \\`wave\\` is not valid)\n\n    .. [[[end]]]", "id": "f6752:m26"}
{"signature": "def _operation(wave, desc, units, fpointer):", "body": "ret = copy.copy(wave)<EOL>ret.dep_units = units<EOL>ret.dep_name = \"<STR_LIT>\".format(desc, ret.dep_name)<EOL>ret._dep_vector = fpointer(ret._dep_vector)<EOL>return ret<EOL>", "docstring": "Perform generic operation on a waveform object.", "id": "f6752:m3"}
{"signature": "@pexdoc.pcontracts.contract(<EOL>wave=Waveform,<EOL>dep_var=\"<STR_LIT>\",<EOL>der=\"<STR_LIT>\",<EOL>inst=\"<STR_LIT>\",<EOL>indep_min=\"<STR_LIT>\",<EOL>indep_max=\"<STR_LIT>\",<EOL>)<EOL>def find(wave, dep_var, der=None, inst=<NUM_LIT:1>, indep_min=None, indep_max=None):", "body": "<EOL>ret = copy.copy(wave)<EOL>_bound_waveform(ret, indep_min, indep_max)<EOL>close_min = np.isclose(min(ret._dep_vector), dep_var, FP_RTOL, FP_ATOL)<EOL>close_max = np.isclose(max(ret._dep_vector), dep_var, FP_RTOL, FP_ATOL)<EOL>if ((np.amin(ret._dep_vector) > dep_var) and (not close_min)) or (<EOL>(np.amax(ret._dep_vector) < dep_var) and (not close_max)<EOL>):<EOL><INDENT>return None<EOL><DEDENT>cross_wave = ret._dep_vector - dep_var<EOL>sign_wave = np.sign(cross_wave)<EOL>exact_idx = np.where(np.isclose(ret._dep_vector, dep_var, FP_RTOL, FP_ATOL))[<NUM_LIT:0>]<EOL>left_idx = np.where(np.diff(sign_wave))[<NUM_LIT:0>]<EOL>left_idx = np.setdiff1d(left_idx, exact_idx)<EOL>left_idx = np.setdiff1d(left_idx, exact_idx - <NUM_LIT:1>)<EOL>right_idx = left_idx + <NUM_LIT:1> if left_idx.size else np.array([])<EOL>indep_var = ret._indep_vector[exact_idx] if exact_idx.size else np.array([])<EOL>dvector = np.zeros(exact_idx.size).astype(int) if exact_idx.size else np.array([])<EOL>if left_idx.size and (ret.interp == \"<STR_LIT>\"):<EOL><INDENT>idvector = (<EOL><NUM_LIT> * (ret._dep_vector[right_idx] > ret._dep_vector[left_idx]).astype(int)<EOL>- <NUM_LIT:1><EOL>)<EOL>if indep_var.size:<EOL><INDENT>indep_var = np.concatenate((indep_var, ret._indep_vector[right_idx]))<EOL>dvector = np.concatenate((dvector, idvector))<EOL>sidx = np.argsort(indep_var)<EOL>indep_var = indep_var[sidx]<EOL>dvector = dvector[sidx]<EOL><DEDENT>else:<EOL><INDENT>indep_var = ret._indep_vector[right_idx]<EOL>dvector = idvector<EOL><DEDENT><DEDENT>elif left_idx.size:<EOL><INDENT>y_left = ret._dep_vector[left_idx]<EOL>y_right = ret._dep_vector[right_idx]<EOL>x_left = ret._indep_vector[left_idx]<EOL>x_right = ret._indep_vector[right_idx]<EOL>slope = ((y_left - y_right) / (x_left - x_right)).astype(float)<EOL>if indep_var.size:<EOL><INDENT>indep_var = np.concatenate(<EOL>(indep_var, x_left + ((dep_var - y_left) / slope))<EOL>)<EOL>dvector = np.concatenate((dvector, np.where(slope > <NUM_LIT:0>, <NUM_LIT:1>, -<NUM_LIT:1>)))<EOL>sidx = np.argsort(indep_var)<EOL>indep_var = indep_var[sidx]<EOL>dvector = dvector[sidx]<EOL><DEDENT>else:<EOL><INDENT>indep_var = x_left + ((dep_var - y_left) / slope)<EOL>dvector = np.where(slope > <NUM_LIT:0>, +<NUM_LIT:1>, -<NUM_LIT:1>)<EOL><DEDENT><DEDENT>if der is not None:<EOL><INDENT>indep_var = np.extract(dvector == der, indep_var)<EOL><DEDENT>return indep_var[inst - <NUM_LIT:1>] if inst <= indep_var.size else None<EOL>", "docstring": "r\"\"\"\n    Return the independent variable point associated with a dependent variable point.\n\n    If the dependent variable point is not in the dependent variable vector the\n    independent variable vector point is obtained by linear interpolation\n\n    :param wave: Waveform\n    :type  wave: :py:class:`peng.eng.Waveform`\n\n    :param dep_var: Dependent vector value to search for\n    :type  dep_var: integer, float or complex\n\n    :param der: Dependent vector derivative filter. If +1 only independent\n                vector points that have positive derivatives when crossing\n                the requested dependent vector point are returned; if -1 only\n                independent vector points that have negative derivatives when\n                crossing the requested dependent vector point are returned;\n                if 0 only independent vector points that have null derivatives\n                when crossing the requested dependent vector point are\n                returned; otherwise if None all independent vector points are\n                returned regardless of the dependent vector derivative. The\n                derivative of the first and last point of the waveform is\n                assumed to be null\n    :type  der: integer, float or complex\n\n    :param inst: Instance number filter. If, for example, **inst** equals 3,\n                 then the independent variable vector point at which the\n                 dependent variable vector equals the requested value for the\n                 third time is returned\n    :type  inst: positive integer\n\n    :param indep_min: Independent vector start point of computation\n    :type  indep_min: integer or float\n\n    :param indep_max: Independent vector stop point of computation\n    :type  indep_max: integer or float\n\n    :rtype: integer, float or None if the dependent variable point is not found\n\n    .. [[[cog cog.out(exobj_eng.get_sphinx_autodoc(raised=True)) ]]]\n    .. Auto-generated exceptions documentation for\n    .. peng.wave_functions.find\n\n    :raises:\n     * RuntimeError (Argument \\`dep_var\\` is not valid)\n\n     * RuntimeError (Argument \\`der\\` is not valid)\n\n     * RuntimeError (Argument \\`indep_max\\` is not valid)\n\n     * RuntimeError (Argument \\`indep_min\\` is not valid)\n\n     * RuntimeError (Argument \\`inst\\` is not valid)\n\n     * RuntimeError (Argument \\`wave\\` is not valid)\n\n     * RuntimeError (Incongruent \\`indep_min\\` and \\`indep_max\\`\n       arguments)\n\n    .. [[[end]]]", "id": "f6752:m25"}
{"signature": "@pexdoc.pcontracts.contract(<EOL>wave=Waveform, indep_min=\"<STR_LIT>\", indep_max=\"<STR_LIT>\"<EOL>)<EOL>def nmin(wave, indep_min=None, indep_max=None):", "body": "ret = copy.copy(wave)<EOL>_bound_waveform(ret, indep_min, indep_max)<EOL>return np.min(ret._dep_vector)<EOL>", "docstring": "r\"\"\"\n    Return the minimum of a waveform's dependent variable vector.\n\n    :param wave: Waveform\n    :type  wave: :py:class:`peng.eng.Waveform`\n\n    :param indep_min: Independent vector start point of computation\n    :type  indep_min: integer or float\n\n    :param indep_max: Independent vector stop point of computation\n    :type  indep_max: integer or float\n\n    :rtype: float\n\n    .. [[[cog cog.out(exobj_eng.get_sphinx_autodoc(raised=True)) ]]]\n    .. Auto-generated exceptions documentation for\n    .. peng.wave_functions.nmin\n\n    :raises:\n     * RuntimeError (Argument \\`indep_max\\` is not valid)\n\n     * RuntimeError (Argument \\`indep_min\\` is not valid)\n\n     * RuntimeError (Argument \\`wave\\` is not valid)\n\n     * RuntimeError (Incongruent \\`indep_min\\` and \\`indep_max\\`\n       arguments)\n\n    .. [[[end]]]", "id": "f6752:m41"}
{"signature": "@pexdoc.pcontracts.contract(wave=Waveform)<EOL>def asinh(wave):", "body": "return _operation(wave, \"<STR_LIT>\", \"<STR_LIT>\", np.arcsinh)<EOL>", "docstring": "r\"\"\"\n    Return the hyperbolic arc sine of a waveform's dependent variable vector.\n\n    :param wave: Waveform\n    :type  wave: :py:class:`peng.eng.Waveform`\n\n    :rtype: :py:class:`peng.eng.Waveform`\n\n    .. [[[cog cog.out(exobj_eng.get_sphinx_autodoc()) ]]]\n    .. Auto-generated exceptions documentation for\n    .. peng.wave_functions.asinh\n\n    :raises: RuntimeError (Argument \\`wave\\` is not valid)\n\n    .. [[[end]]]", "id": "f6752:m9"}
{"signature": "@pexdoc.pcontracts.contract(wave=Waveform)<EOL>def sin(wave):", "body": "return _operation(wave, \"<STR_LIT>\", \"<STR_LIT>\", np.sin)<EOL>", "docstring": "r\"\"\"\n    Return the sine of a waveform's dependent variable vector.\n\n    :param wave: Waveform\n    :type  wave: :py:class:`peng.eng.Waveform`\n\n    :rtype: :py:class:`peng.eng.Waveform`\n\n    .. [[[cog cog.out(exobj_eng.get_sphinx_autodoc()) ]]]\n    .. Auto-generated exceptions documentation for peng.wave_functions.sin\n\n    :raises: RuntimeError (Argument \\`wave\\` is not valid)\n\n    .. [[[end]]]", "id": "f6752:m45"}
{"signature": "@pexdoc.pcontracts.contract(wave=Waveform)<EOL>def cosh(wave):", "body": "return _operation(wave, \"<STR_LIT>\", \"<STR_LIT>\", np.cosh)<EOL>", "docstring": "r\"\"\"\n    Return the hyperbolic cosine of a waveform's dependent variable vector.\n\n    :param wave: Waveform\n    :type  wave: :py:class:`peng.eng.Waveform`\n\n    :rtype: :py:class:`peng.eng.Waveform`\n\n    .. [[[cog cog.out(exobj_eng.get_sphinx_autodoc()) ]]]\n    .. Auto-generated exceptions documentation for\n    .. peng.wave_functions.cosh\n\n    :raises: RuntimeError (Argument \\`wave\\` is not valid)\n\n    .. [[[end]]]", "id": "f6752:m15"}
{"signature": "@pexdoc.pcontracts.contract(wave=Waveform)<EOL>def real(wave):", "body": "return _operation(wave, \"<STR_LIT>\", wave.dep_units, np.real)<EOL>", "docstring": "r\"\"\"\n    Return the real part of a waveform's dependent variable vector.\n\n    :param wave: Waveform\n    :type  wave: :py:class:`peng.eng.Waveform`\n\n    :rtype: :py:class:`peng.eng.Waveform`\n\n    .. [[[cog cog.out(exobj_eng.get_sphinx_autodoc()) ]]]\n    .. Auto-generated exceptions documentation for\n    .. peng.wave_functions.real\n\n    :raises: RuntimeError (Argument \\`wave\\` is not valid)\n\n    .. [[[end]]]", "id": "f6752:m43"}
{"signature": "def trace_module(no_print=True):", "body": "mname = \"<STR_LIT>\"<EOL>fname = \"<STR_LIT>\"<EOL>module_prefix = \"<STR_LIT>\".format(mname)<EOL>callable_names = (<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>)<EOL>return docs.support.trace_support.run_trace(<EOL>mname, fname, module_prefix, callable_names, no_print<EOL>)<EOL>", "docstring": "Trace eng wave module exceptions.", "id": "f6756:m0"}
{"signature": "def ste(command, nindent, mdir, fpointer):", "body": "term_echo(<EOL>\"<STR_LIT>\".format(sep=os.path.sep, cmd=command),<EOL>nindent,<EOL>{\"<STR_LIT>\": mdir},<EOL>fpointer,<EOL>)<EOL>", "docstring": "r\"\"\"\n    Echo terminal output.\n\n    Print STDOUT resulting from a given Bash shell command (relative to the\n    package :code:`pypkg` directory) formatted in reStructuredText\n\n    :param command: Bash shell command, relative to\n                    :bash:`${PMISC_DIR}/pypkg`\n    :type  command: string\n\n    :param nindent: Indentation level\n    :type  nindent: integer\n\n    :param mdir: Module directory\n    :type  mdir: string\n\n    :param fpointer: Output function pointer. Normally is :code:`cog.out` but\n                     :code:`print` or other functions can be used for\n                     debugging\n    :type  fpointer: function object\n\n    For example::\n\n        .. This is a reStructuredText file snippet\n        .. [[[cog\n        .. import os, sys\n        .. from docs.support.term_echo import term_echo\n        .. file_name = sys.modules['docs.support.term_echo'].__file__\n        .. mdir = os.path.realpath(\n        ..     os.path.dirname(\n        ..         os.path.dirname(os.path.dirname(file_name))\n        ..     )\n        .. )\n        .. [[[cog ste('build_docs.py -h', 0, mdir, cog.out) ]]]\n\n        .. code-block:: bash\n\n        $ ${PMISC_DIR}/pypkg/build_docs.py -h\n        usage: build_docs.py [-h] [-d DIRECTORY] [-n NUM_CPUS]\n        ...\n\n        .. ]]]", "id": "f6758:m0"}
{"signature": "def term_echo(command, nindent=<NUM_LIT:0>, env=None, fpointer=None, cols=<NUM_LIT>):", "body": "<EOL>os.environ[\"<STR_LIT>\"] = str(cols)<EOL>command_int = command<EOL>if env:<EOL><INDENT>for var, repl in env.items():<EOL><INDENT>command_int = command_int.replace(\"<STR_LIT>\" + var + \"<STR_LIT:}>\", repl)<EOL><DEDENT><DEDENT>tokens = command_int.split(\"<STR_LIT:U+0020>\")<EOL>if (platform.system().lower() == \"<STR_LIT>\") and (tokens[<NUM_LIT:0>].endswith(\"<STR_LIT>\")):<EOL><INDENT>tokens = [sys.executable] + tokens<EOL><DEDENT>proc = subprocess.Popen(tokens, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)<EOL>stdout = proc.communicate()[<NUM_LIT:0>]<EOL>if sys.hexversion >= <NUM_LIT>:<EOL><INDENT>stdout = stdout.decode(\"<STR_LIT:utf-8>\")<EOL><DEDENT>stdout = stdout.split(\"<STR_LIT:\\n>\")<EOL>indent = nindent * \"<STR_LIT:U+0020>\"<EOL>fpointer(\"<STR_LIT:\\n>\", dedent=False)<EOL>fpointer(\"<STR_LIT>\".format(indent), dedent=False)<EOL>fpointer(\"<STR_LIT:\\n>\", dedent=False)<EOL>fpointer(\"<STR_LIT>\".format(indent, command), dedent=False)<EOL>for line in stdout:<EOL><INDENT>if line.strip():<EOL><INDENT>fpointer(indent + \"<STR_LIT:U+0020>\" + line.replace(\"<STR_LIT:\\t>\", \"<STR_LIT:U+0020>\") + \"<STR_LIT:\\n>\", dedent=False)<EOL><DEDENT>else:<EOL><INDENT>fpointer(\"<STR_LIT:\\n>\", dedent=False)<EOL><DEDENT><DEDENT>fpointer(\"<STR_LIT:\\n>\", dedent=False)<EOL>", "docstring": "Print STDOUT resulting from a Bash shell command formatted in reStructuredText.\n\n:param command: Bash shell command\n:type  command: string\n\n:param nindent: Indentation level\n:type  nindent: integer\n\n:param env: Environment variable replacement dictionary. The Bash\n            command is pre-processed and any environment variable\n            represented in the full notation (:bash:`${...}`) is replaced.\n            The dictionary key is the environment variable name and the\n            dictionary value is the replacement value. For example, if\n            **command** is :code:`'${PYTHON_CMD} -m \"x=5\"'` and **env**\n            is :code:`{'PYTHON_CMD':'python3'}` the actual command issued\n            is :code:`'python3 -m \"x=5\"'`\n:type  env: dictionary\n\n:param fpointer: Output function pointer. Normally is :code:`cog.out` but\n                 :code:`print` or other functions can be used for\n                 debugging\n:type  fpointer: function object\n\n:param cols: Number of columns of output\n:type  cols: integer", "id": "f6758:m1"}
{"signature": "@pexdoc.pcontracts.new_contract()<EOL>def touchstone_data(obj):", "body": "if (not isinstance(obj, dict)) or (<EOL>isinstance(obj, dict)<EOL>and (sorted(obj.keys()) != sorted([\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]))<EOL>):<EOL><INDENT>raise ValueError(pexdoc.pcontracts.get_exdesc())<EOL><DEDENT>if not (isinstance(obj[\"<STR_LIT>\"], int) and (obj[\"<STR_LIT>\"] > <NUM_LIT:0>)):<EOL><INDENT>raise ValueError(pexdoc.pcontracts.get_exdesc())<EOL><DEDENT>if _check_increasing_real_numpy_vector(obj[\"<STR_LIT>\"]):<EOL><INDENT>raise ValueError(pexdoc.pcontracts.get_exdesc())<EOL><DEDENT>if not isinstance(obj[\"<STR_LIT>\"], np.ndarray):<EOL><INDENT>raise ValueError(pexdoc.pcontracts.get_exdesc())<EOL><DEDENT>vdata = [\"<STR_LIT:int>\", \"<STR_LIT:float>\", \"<STR_LIT>\"]<EOL>if not any([obj[\"<STR_LIT>\"].dtype.name.startswith(item) for item in vdata]):<EOL><INDENT>raise ValueError(pexdoc.pcontracts.get_exdesc())<EOL><DEDENT>if obj[\"<STR_LIT>\"].size != obj[\"<STR_LIT>\"]:<EOL><INDENT>raise ValueError(pexdoc.pcontracts.get_exdesc())<EOL><DEDENT>nports = int(math.sqrt(obj[\"<STR_LIT>\"].size / obj[\"<STR_LIT>\"].size))<EOL>if obj[\"<STR_LIT>\"] * (nports ** <NUM_LIT:2>) != obj[\"<STR_LIT>\"].size:<EOL><INDENT>raise ValueError(pexdoc.pcontracts.get_exdesc())<EOL><DEDENT>", "docstring": "r\"\"\"\n    Validate if an object is an :ref:`TouchstoneData` pseudo-type object.\n\n    :param obj: Object\n    :type  obj: any\n\n    :raises: RuntimeError (Argument \\`*[argument_name]*\\` is not valid). The\n     token \\*[argument_name]\\* is replaced by the name of the argument the\n     contract is attached to\n\n    :rtype: None", "id": "f6759:m8"}
{"signature": "def def_links(mobj):", "body": "fdict = json_load(os.path.join(\"<STR_LIT:data>\", \"<STR_LIT>\"))<EOL>sdeps = sorted(fdict.keys())<EOL>olines = []<EOL>for item in sdeps:<EOL><INDENT>olines.append(<EOL>\"<STR_LIT>\".format(<EOL>name=fdict[item][\"<STR_LIT:name>\"], url=fdict[item][\"<STR_LIT:url>\"]<EOL>)<EOL>)<EOL><DEDENT>ret = []<EOL>for line in olines:<EOL><INDENT>wobj = textwrap.wrap(line, width=LINE_WIDTH, subsequent_indent=\"<STR_LIT:U+0020>\")<EOL>ret.append(\"<STR_LIT:\\n>\".join([item for item in wobj]))<EOL><DEDENT>mobj.out(\"<STR_LIT:\\n>\".join(ret))<EOL>", "docstring": "Define Sphinx requirements links.", "id": "f6760:m0"}
{"signature": "def ops_to_words(item):", "body": "unsupp_ops = [\"<STR_LIT>\", \"<STR_LIT>\"]<EOL>supp_ops = [\"<STR_LIT>\", \"<STR_LIT:>>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT:<>\", \"<STR_LIT>\"]<EOL>tokens = sorted(item.split(\"<STR_LIT:U+002C>\"), reverse=True)<EOL>actual_tokens = []<EOL>for req in tokens:<EOL><INDENT>for op in unsupp_ops:<EOL><INDENT>if req.startswith(op):<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\".format(op))<EOL><DEDENT><DEDENT>for op in supp_ops:<EOL><INDENT>if req.startswith(op):<EOL><INDENT>actual_tokens.append(op)<EOL>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\".format(op))<EOL><DEDENT><DEDENT>if len(list(set(actual_tokens))) != len(actual_tokens):<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>if \"<STR_LIT>\" in actual_tokens:<EOL><INDENT>return (<EOL>\"<STR_LIT>\".join([op_to_words(token) for token in tokens[:-<NUM_LIT:1>]])<EOL>+ \"<STR_LIT:U+0020>\"<EOL>+ op_to_words(tokens[-<NUM_LIT:1>])<EOL>)<EOL><DEDENT>return \"<STR_LIT>\".join([op_to_words(token) for token in tokens])<EOL>", "docstring": "Translate requirement specification to words.", "id": "f6760:m4"}
{"signature": "def make_multi_entry(plist, pkg_pyvers, ver_dict):", "body": "for pyver in pkg_pyvers:<EOL><INDENT>pver = pyver[<NUM_LIT:2>] + \"<STR_LIT:.>\" + pyver[<NUM_LIT:3>:]<EOL>plist.append(\"<STR_LIT>\".format(pver, ops_to_words(ver_dict[pyver])))<EOL><DEDENT>", "docstring": "Generate Python interpreter version entries.", "id": "f6760:m2"}
{"signature": "def op_to_words(item):", "body": "sdicts = [<EOL>{\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>{\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>{\"<STR_LIT:>>\": \"<STR_LIT>\"},<EOL>{\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>{\"<STR_LIT:<>\": \"<STR_LIT>\"},<EOL>{\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>]<EOL>for sdict in sdicts:<EOL><INDENT>prefix = list(sdict.keys())[<NUM_LIT:0>]<EOL>suffix = sdict[prefix]<EOL>if item.startswith(prefix):<EOL><INDENT>if prefix == \"<STR_LIT>\":<EOL><INDENT>return item[<NUM_LIT:2>:]<EOL><DEDENT>if prefix == \"<STR_LIT>\":<EOL><INDENT>return suffix + item[<NUM_LIT:2>:]<EOL><DEDENT>if prefix in [\"<STR_LIT:>>\", \"<STR_LIT:<>\"]:<EOL><INDENT>return suffix + item[<NUM_LIT:1>:]<EOL><DEDENT>return item[<NUM_LIT:2>:] + suffix<EOL><DEDENT><DEDENT>raise RuntimeError(\"<STR_LIT>\")<EOL>", "docstring": "Translate >=, ==, <= to words.", "id": "f6760:m3"}
{"signature": "def proc_requirements(mobj):", "body": "pyvers = [\"<STR_LIT>\".format(item.replace(\"<STR_LIT:.>\", \"<STR_LIT>\")) for item in get_supported_interps()]<EOL>py2vers = sorted([item for item in pyvers if item.startswith(\"<STR_LIT>\")])<EOL>py3vers = sorted([item for item in pyvers if item.startswith(\"<STR_LIT>\")])<EOL>fdict = json_load(os.path.join(\"<STR_LIT:data>\", \"<STR_LIT>\"))<EOL>olines = [\"<STR_LIT>\"]<EOL>sdict = dict([(item[\"<STR_LIT:name>\"], item) for item in fdict.values()])<EOL>for real_name in sorted(sdict.keys()):<EOL><INDENT>pkg_dict = sdict[real_name]<EOL>if pkg_dict[\"<STR_LIT>\"] == [\"<STR_LIT>\"]:<EOL><INDENT>continue<EOL><DEDENT>plist = [] if not pkg_dict[\"<STR_LIT>\"] else [\"<STR_LIT>\"]<EOL>if isinstance(pkg_dict[\"<STR_LIT>\"], str):<EOL><INDENT>pkg_dict[\"<STR_LIT>\"] = dict([(pyver, pkg_dict[\"<STR_LIT>\"]) for pyver in pyvers])<EOL><DEDENT>pkg_pyvers = sorted(pkg_dict[\"<STR_LIT>\"].keys())<EOL>pkg_py2vers = sorted(<EOL>[item for item in pkg_dict[\"<STR_LIT>\"].keys() if item.startswith(\"<STR_LIT>\")]<EOL>)<EOL>req_vers = list(set(pkg_dict[\"<STR_LIT>\"].values()))<EOL>req_py2vers = list(<EOL>set([pkg_dict[\"<STR_LIT>\"][item] for item in py2vers if item in pkg_dict[\"<STR_LIT>\"]])<EOL>)<EOL>req_py3vers = list(<EOL>set([pkg_dict[\"<STR_LIT>\"][item] for item in py3vers if item in pkg_dict[\"<STR_LIT>\"]])<EOL>)<EOL>if (len(req_vers) == <NUM_LIT:1>) and (pkg_pyvers == pyvers):<EOL><INDENT>plist.append(ops_to_words(req_vers[<NUM_LIT:0>]))<EOL><DEDENT>elif (<EOL>(pkg_pyvers == pyvers)<EOL>and (len(req_py2vers) == <NUM_LIT:1>)<EOL>and (len(req_py3vers) == <NUM_LIT:1>)<EOL>):<EOL><INDENT>make_common_entry(plist, \"<STR_LIT:2>\", \"<STR_LIT>\", req_py2vers[<NUM_LIT:0>])<EOL>make_common_entry(plist, \"<STR_LIT:3>\", \"<STR_LIT>\", req_py3vers[<NUM_LIT:0>])<EOL><DEDENT>elif (<EOL>(pkg_pyvers == pyvers)<EOL>and (len(req_py2vers) == len(py2vers))<EOL>and (len(req_py3vers) == <NUM_LIT:1>)<EOL>and (pkg_dict[\"<STR_LIT>\"][pkg_py2vers[-<NUM_LIT:1>]] == req_py3vers[<NUM_LIT:0>])<EOL>):<EOL><INDENT>py2dict = dict(<EOL>[<EOL>(key, value)<EOL>for key, value in pkg_dict[\"<STR_LIT>\"].items()<EOL>if key.startswith(\"<STR_LIT>\") and (key != pkg_py2vers[-<NUM_LIT:1>])<EOL>]<EOL>)<EOL>make_multi_entry(plist, py2vers[:-<NUM_LIT:1>], py2dict)<EOL>pver = pkg_py2vers[-<NUM_LIT:1>][<NUM_LIT:2>] + \"<STR_LIT:.>\" + pkg_py2vers[-<NUM_LIT:1>][<NUM_LIT:3>:]<EOL>plist.append(<EOL>\"<STR_LIT>\".format(<EOL>pyver=pver, ver=ops_to_words(req_py3vers[<NUM_LIT:0>])<EOL>)<EOL>)<EOL><DEDENT>elif (<EOL>(pkg_pyvers == pyvers)<EOL>and (len(req_py2vers) == len(py2vers))<EOL>and (len(req_py3vers) == <NUM_LIT:1>)<EOL>):<EOL><INDENT>py2dict = dict(<EOL>[<EOL>(key, value)<EOL>for key, value in pkg_dict[\"<STR_LIT>\"].items()<EOL>if key.startswith(\"<STR_LIT>\")<EOL>]<EOL>)<EOL>make_multi_entry(plist, py2vers, py2dict)<EOL>make_common_entry(plist, \"<STR_LIT:3>\", \"<STR_LIT>\", req_py3vers[<NUM_LIT:0>])<EOL><DEDENT>elif (<EOL>(pkg_pyvers == pyvers)<EOL>and (len(req_py3vers) == len(py3vers))<EOL>and (len(req_py2vers) == <NUM_LIT:1>)<EOL>):<EOL><INDENT>py3dict = dict(<EOL>[<EOL>(key, value)<EOL>for key, value in pkg_dict[\"<STR_LIT>\"].items()<EOL>if key.startswith(\"<STR_LIT>\")<EOL>]<EOL>)<EOL>make_common_entry(plist, \"<STR_LIT:2>\", \"<STR_LIT>\", req_py2vers[<NUM_LIT:0>])<EOL>make_multi_entry(plist, py3vers, py3dict)<EOL><DEDENT>elif (len(req_vers) == <NUM_LIT:1>) and (pkg_pyvers == py2vers):<EOL><INDENT>make_common_entry(plist, \"<STR_LIT:2>\", \"<STR_LIT>\", req_vers[<NUM_LIT:0>])<EOL><DEDENT>elif (len(req_vers) == <NUM_LIT:1>) and (pkg_pyvers == py3vers):<EOL><INDENT>make_common_entry(plist, \"<STR_LIT:3>\", \"<STR_LIT>\", req_vers[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>make_multi_entry(plist, pkg_pyvers, pkg_dict[\"<STR_LIT>\"])<EOL><DEDENT>olines.append(<EOL>\"<STR_LIT>\".format(<EOL>name=pkg_dict[\"<STR_LIT:name>\"], par=\"<STR_LIT:U+002CU+0020>\".join(plist)<EOL>)<EOL>)<EOL><DEDENT>ret = []<EOL>for line in olines:<EOL><INDENT>wobj = textwrap.wrap(line, width=LINE_WIDTH, subsequent_indent=\"<STR_LIT:U+0020>\")<EOL>ret.append(\"<STR_LIT:\\n>\".join([item for item in wobj]))<EOL><DEDENT>mobj.out(\"<STR_LIT>\".join(ret) + \"<STR_LIT>\")<EOL>", "docstring": "Get requirements in reStructuredText format.", "id": "f6760:m5"}
{"signature": "def trace_module(no_print=True):", "body": "mname = \"<STR_LIT>\"<EOL>fname = \"<STR_LIT>\"<EOL>module_prefix = \"<STR_LIT>\".format(mname)<EOL>callable_names = (<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>)<EOL>return docs.support.trace_support.run_trace(<EOL>mname, fname, module_prefix, callable_names, no_print<EOL>)<EOL>", "docstring": "Trace eng functions module exceptions.", "id": "f6761:m0"}
{"signature": "def incfile(fname, fpointer, lrange=\"<STR_LIT>\", sdir=None):", "body": "<EOL>file_dir = (<EOL>sdir<EOL>if sdir<EOL>else os.environ.get(\"<STR_LIT>\", os.path.abspath(os.path.dirname(__file__)))<EOL>)<EOL>fname = os.path.join(file_dir, fname)<EOL>with open(fname) as fobj:<EOL><INDENT>lines = fobj.readlines()<EOL><DEDENT>tokens = [item.strip() for item in lrange.split(\"<STR_LIT:U+002C>\")]<EOL>inc_lines = []<EOL>for token in tokens:<EOL><INDENT>if \"<STR_LIT:->\" in token:<EOL><INDENT>subtokens = token.split(\"<STR_LIT:->\")<EOL>lmin, lmax = (<EOL>int(subtokens[<NUM_LIT:0>]),<EOL>int(subtokens[<NUM_LIT:1>]) if subtokens[<NUM_LIT:1>] else len(lines),<EOL>)<EOL>for num in range(lmin, lmax + <NUM_LIT:1>):<EOL><INDENT>inc_lines.append(num)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>inc_lines.append(int(token))<EOL><DEDENT><DEDENT>fpointer(\"<STR_LIT>\")<EOL>fpointer(\"<STR_LIT:\\n>\")<EOL>for num, line in enumerate(lines):<EOL><INDENT>if num + <NUM_LIT:1> in inc_lines:<EOL><INDENT>fpointer(\"<STR_LIT:U+0020>\" + line.replace(\"<STR_LIT:\\t>\", \"<STR_LIT:U+0020>\") if line.strip() else \"<STR_LIT:\\n>\")<EOL><DEDENT><DEDENT>fpointer(\"<STR_LIT:\\n>\")<EOL>", "docstring": "r\"\"\"\n    Include a Python source file in a docstring formatted in reStructuredText.\n\n    :param fname: File name, relative to environment variable\n                  :bash:`${TRACER_DIR}`\n    :type  fname: string\n\n    :param fpointer: Output function pointer. Normally is :code:`cog.out` but\n                     :code:`print` or other functions can be used for\n                     debugging\n    :type  fpointer: function object\n\n    :param lrange: Line range to include, similar to Sphinx\n                   `literalinclude <http://sphinx-doc.org/markup/code.html\n                   #directive-literalinclude>`_ directive\n    :type  lrange: string\n\n    :param sdir: Source file directory. If None the :bash:`${TRACER_DIR}`\n                 environment variable is used if it is defined, otherwise\n                 the directory where the :code:`docs.support.incfile` module\n                 is located is used\n    :type  sdir: string\n\n    For example:\n\n    .. code-block:: python\n\n        def func():\n            \\\"\\\"\\\"\n            This is a docstring. This file shows how to use it:\n\n            .. =[=cog\n            .. import docs.support.incfile\n            .. docs.support.incfile.incfile('func_example.py', cog.out)\n            .. =]=\n            .. code-block:: python\n\n                # func_example.py\n                if __name__ == '__main__':\n                    func()\n\n            .. =[=end=]=\n            \\\"\\\"\\\"\n            return 'This is func output'", "id": "f6763:m0"}
{"signature": "def filter_glyph_names( alist, filter ):", "body": "count  = <NUM_LIT:0><EOL>extras = []<EOL>for name in alist:<EOL><INDENT>try:<EOL><INDENT>filtered_index = filter.index( name )<EOL><DEDENT>except:<EOL><INDENT>extras.append( name )<EOL><DEDENT><DEDENT>return extras<EOL>", "docstring": "filter `alist' by taking _out_ all glyph names that are in `filter", "id": "f6765:m1"}
{"signature": "def  __init__( self ):", "body": "self.reset()<EOL>self.sections = {}    <EOL>self.section  = None  <EOL>self.chapters = []    <EOL>self.headers  = {}<EOL>", "docstring": "initialize a block content processor", "id": "f6769:c6:m0"}
{"signature": "def  make_html_words( self, words ):", "body": "line = \"<STR_LIT>\"<EOL>if words:<EOL><INDENT>line = html_quote( words[<NUM_LIT:0>] )<EOL>for w in words[<NUM_LIT:1>:]:<EOL><INDENT>line = line + \"<STR_LIT:U+0020>\" + html_quote( w )<EOL><DEDENT><DEDENT>return line<EOL>", "docstring": "convert a series of simple words into some HTML text", "id": "f6770:c0:m3"}
{"signature": "def  make_html_word( self, word ):", "body": "<EOL>m = re_crossref.match( word )<EOL>if m:<EOL><INDENT>try:<EOL><INDENT>name = m.group( <NUM_LIT:1> )<EOL>rest = m.group( <NUM_LIT:2> )<EOL>block = self.identifiers[name]<EOL>url   = self.make_block_url( block )<EOL>return '<STR_LIT>' + url + '<STR_LIT>' + name + '<STR_LIT>' + rest<EOL><DEDENT>except:<EOL><INDENT>sys.stderr.write(\"<STR_LIT>\" + name + \"<STR_LIT>\" )<EOL>return '<STR_LIT:?>' + name + '<STR_LIT:?>' + rest<EOL><DEDENT><DEDENT>m = re_italic.match( word )<EOL>if m:<EOL><INDENT>name = m.group( <NUM_LIT:1> )<EOL>rest = m.group( <NUM_LIT:3> )<EOL>return '<STR_LIT>' + name + '<STR_LIT>' + rest<EOL><DEDENT>m = re_bold.match( word )<EOL>if m:<EOL><INDENT>name = m.group( <NUM_LIT:1> )<EOL>rest = m.group( <NUM_LIT:3> )<EOL>return '<STR_LIT>' + name + '<STR_LIT>' + rest<EOL><DEDENT>return html_quote( word )<EOL>", "docstring": "analyze a simple word to detect cross-references and styling", "id": "f6770:c0:m4"}
{"signature": "def  file_exists( pathname ):", "body": "result = <NUM_LIT:1><EOL>try:<EOL><INDENT>file = open( pathname, \"<STR_LIT:r>\" )<EOL>file.close()<EOL><DEDENT>except:<EOL><INDENT>result = None<EOL>sys.stderr.write( pathname + \"<STR_LIT>\" )<EOL><DEDENT>return result<EOL>", "docstring": "checks that a given file exists", "id": "f6772:m5"}
{"signature": "def  main( argv ):", "body": "global output_dir<EOL>try:<EOL><INDENT>opts, args = getopt.getopt( sys.argv[<NUM_LIT:1>:],\"<STR_LIT>\",[\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"] )<EOL><DEDENT>except getopt.GetoptError:<EOL><INDENT>usage()<EOL>sys.exit( <NUM_LIT:2> )<EOL><DEDENT>if args == []:<EOL><INDENT>usage()<EOL>sys.exit( <NUM_LIT:1> )<EOL><DEDENT>project_title  = \"<STR_LIT>\"<EOL>project_prefix = None<EOL>output_dir     = None<EOL>for opt in opts:<EOL><INDENT>if opt[<NUM_LIT:0>] in ( \"<STR_LIT>\", \"<STR_LIT>\" ):<EOL><INDENT>usage()<EOL>sys.exit( <NUM_LIT:0> )<EOL><DEDENT>if opt[<NUM_LIT:0>] in ( \"<STR_LIT>\", \"<STR_LIT>\" ):<EOL><INDENT>project_title = opt[<NUM_LIT:1>]<EOL><DEDENT>if opt[<NUM_LIT:0>] in ( \"<STR_LIT>\", \"<STR_LIT>\" ):<EOL><INDENT>utils.output_dir = opt[<NUM_LIT:1>]<EOL><DEDENT>if opt[<NUM_LIT:0>] in ( \"<STR_LIT>\", \"<STR_LIT>\" ):<EOL><INDENT>project_prefix = opt[<NUM_LIT:1>]<EOL><DEDENT><DEDENT>check_output()<EOL>source_processor  = SourceProcessor()<EOL>content_processor = ContentProcessor()<EOL>file_list = make_file_list( args )<EOL>for filename in file_list:<EOL><INDENT>source_processor.parse_file( filename )<EOL>content_processor.parse_sources( source_processor )<EOL><DEDENT>content_processor.finish()<EOL>formatter = HtmlFormatter( content_processor, project_title, project_prefix )<EOL>formatter.toc_dump()<EOL>formatter.index_dump()<EOL>formatter.section_dump_all()<EOL>", "docstring": "main program loop", "id": "f6773:m1"}
{"signature": "def has_axis(self, axis):", "body": "return (axis & self._supported_axes_mask) != <NUM_LIT:0><EOL>", "docstring": "Returns ``True`` if the controller has the requested axis, a value of enumeration :class:`ControllerAxes`.", "id": "f6775:c0:m2"}
{"signature": "@property<EOL><INDENT>def action_left(self):<DEDENT>", "body": "return self._buttons & ControllerButtons.action_left<EOL>", "docstring": "``True`` if the left action button (\"X\" on Xbox 360) is pressed.  Available only on game controllers with \n        the ``standard`` or ``extended`` profiles.", "id": "f6775:c0:m18"}
{"signature": "@property<EOL><INDENT>def right_trigger(self):<DEDENT>", "body": "return self.get_axis(ControllerAxes.right_trigger)<EOL>", "docstring": "The absolute right trigger value, between 0.0 and 1.0.  Available only on game controllers with the\n        ``extended`` profile.", "id": "f6775:c0:m12"}
{"signature": "@property<EOL><INDENT>def controller_index(self):<DEDENT>", "body": "return self._controller_index<EOL>", "docstring": "The index of the controller, between 0 and 4 (read-only).  Typically this is assigned in the order the\n        controllers are detected, however some controllers may have an intrinsic \"player number\" that is exposed\n        through this number.  No two controllers will have the same controller index.", "id": "f6775:c0:m1"}
{"signature": "def has_button(self, button):", "body": "return (button & self._supported_buttons_mask) != <NUM_LIT:0><EOL>", "docstring": "Returns ``True`` if the controller has the requested button, a value of enumeration :class:`ControllerButtons`.", "id": "f6775:c0:m4"}
{"signature": "@property<EOL><INDENT>def left_thumb_x(self):<DEDENT>", "body": "return self.get_axis(ControllerAxes.left_thumb_x)<EOL>", "docstring": "The absolute X axis value of the left thumb-stick, or the main stick on a joystick.", "id": "f6775:c0:m7"}
{"signature": "@property<EOL><INDENT>def action_up(self):<DEDENT>", "body": "return self._buttons & ControllerButtons.action_up<EOL>", "docstring": "``True`` if the up action button (\"Y\" on Xbox 360) is pressed.  Available only on game controllers with \n        the ``standard`` or ``extended`` profiles.", "id": "f6775:c0:m16"}
{"signature": "@property<EOL><INDENT>def height(self):<DEDENT>", "body": "return self._height<EOL>", "docstring": "The height of the image, in texels (read-only).", "id": "f6776:c0:m4"}
{"signature": "def set_transform(matrix):", "body": "lib.SetTransform((c_float * <NUM_LIT:16>)(*matrix))<EOL>", "docstring": "Replace the current graphics transform with the given 4x4 matrix.  For example, to replace\n    the transform with a translation by ``(x, y)``::\n\n        bacon.set_transform([1, 0, 0, x,\n                             0, 1, 0, y,\n                             0, 0, 1, 0,\n                             0, 0, 0, 1])\n\n    :param matrix: a 4x4 matrix in column major order, represented as a flat 16 element sequence.", "id": "f6778:m0"}
{"signature": "@property<EOL><INDENT>def right(self):<DEDENT>", "body": "return self.button_mask & (<NUM_LIT:1> << <NUM_LIT:2>)<EOL>", "docstring": "``True`` if the right mouse button is currently pressed.", "id": "f6783:c0:m4"}
{"signature": "def run(game):", "body": "if bacon._current_game:<EOL><INDENT>bacon._current_game = game<EOL>return<EOL><DEDENT>global _tick_callback_handle<EOL>bacon._current_game = game<EOL>window_resize_callback_handle = lib.WindowResizeEventHandler(window._window_resize_event_handler)<EOL>lib.SetWindowResizeEventHandler(window_resize_callback_handle)<EOL>key_callback_handle = lib.KeyEventHandler(keyboard._key_event_handler)<EOL>lib.SetKeyEventHandler(key_callback_handle)<EOL>mouse_button_callback_handle = lib.MouseButtonEventHandler(mouse_input._mouse_button_event_handler)<EOL>lib.SetMouseButtonEventHandler(mouse_button_callback_handle)<EOL>mouse_scroll_callback_handle = lib.MouseScrollEventHandler(mouse_input._mouse_scroll_event_handler)<EOL>lib.SetMouseScrollEventHandler(mouse_scroll_callback_handle)<EOL>controller_connected_handle = lib.ControllerConnectedEventHandler(controller._controller_connected_event_handler)<EOL>lib.SetControllerConnectedEventHandler(controller_connected_handle)<EOL>controller_button_handle = lib.ControllerButtonEventHandler(controller._controller_button_event_handler)<EOL>lib.SetControllerButtonEventHandler(controller_button_handle)<EOL>controller_axis_handle = lib.ControllerAxisEventHandler(controller._controller_axis_event_handler)<EOL>lib.SetControllerAxisEventHandler(controller_axis_handle)<EOL>_tick_callback_handle = lib.TickCallback(_first_tick_callback)<EOL>lib.SetTickCallback(_tick_callback_handle)<EOL>lib.Run()<EOL>bacon._current_game = None<EOL>_tick_callback_handle = None<EOL>lib.SetWindowResizeEventHandler(lib.WindowResizeEventHandler(<NUM_LIT:0>))<EOL>lib.SetKeyEventHandler(lib.KeyEventHandler(<NUM_LIT:0>))<EOL>lib.SetMouseButtonEventHandler(lib.MouseButtonEventHandler(<NUM_LIT:0>))<EOL>lib.SetMouseScrollEventHandler(lib.MouseScrollEventHandler(<NUM_LIT:0>))<EOL>lib.SetControllerConnectedEventHandler(lib.ControllerConnectedEventHandler(<NUM_LIT:0>))<EOL>lib.SetControllerButtonEventHandler(lib.ControllerButtonEventHandler(<NUM_LIT:0>))<EOL>lib.SetControllerAxisEventHandler(lib.ControllerAxisEventHandler(<NUM_LIT:0>))<EOL>lib.SetTickCallback(lib.TickCallback(<NUM_LIT:0>))<EOL>", "docstring": "Start running the game.  The window is created and shown at this point, and then\n    the main event loop is entered.  'game.on_tick' and other event handlers are called\n    repeatedly until the game exits.\n\n    If a game is already running, this function replaces the :class:`Game` instance that\n    receives events.", "id": "f6786:m3"}
{"signature": "def on_controller_disconnected(self, controller):", "body": "pass<EOL>", "docstring": "Called when a game controller is disconnected.  You should use the `controller` parameter only\n        to identify a previously used controller; its properties and values will no longer be available.\n\n        :param controller: the :class:`Controller` that was disconnected", "id": "f6786:c0:m7"}
{"signature": "def on_tick(self):", "body": "clear(<NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:1>)<EOL>", "docstring": "Called once per frame to update and render the game.  You may only call\n        drawing functions within the scope of this method.", "id": "f6786:c0:m1"}
{"signature": "def on_controller_axis(self, controller, axis, value):", "body": "pass<EOL>", "docstring": "Called when an axis on a game controller is moved.\n\n        :param controller: the :class:`Controller` containing the axis\n        :param button: axis index, of :class:`ControllerAxes` enumeration\n        :param value: absolute position of the axis, between ``-1.0`` and ``1.0``", "id": "f6786:c0:m9"}
{"signature": "def on_controller_button(self, controller, button, pressed):", "body": "pass<EOL>", "docstring": "Called when a button on a game controller is pressed or released.\n\n        :param controller: the :class:`Controller` containing the button\n        :param button: button index, of :class:`ControllerButtons` enumeration\n        :param pressed: ``True`` if the button was pressed, otherwise ``False``", "id": "f6786:c0:m8"}
{"signature": "def draw_string(font, text, x, y, width=None, height=None, align=Alignment.left, vertical_align=VerticalAlignment.baseline):", "body": "style = Style(font)<EOL>run = GlyphRun(style, text)<EOL>glyph_layout = GlyphLayout([run], x, y, width, height, align, vertical_align)<EOL>draw_glyph_layout(glyph_layout)<EOL>", "docstring": "Draw a string with the given font.\n\n    :note: Text alignment and word-wrapping is not yet implemented.  The text is rendered with the left edge and\n        baseline at ``(x, y)``.\n\n    :param font: the :class:`Font` to render text with\n    :param text: a string of text to render.", "id": "f6787:m0"}
{"signature": "@property<EOL><INDENT>def fragment_source(self):<DEDENT>", "body": "return self._fragment_source<EOL>", "docstring": "Get the fragment shader source\n\n        :type: ``str``", "id": "f6793:c0:m4"}
{"signature": "@property<EOL><INDENT>def vertex_source(self):<DEDENT>", "body": "return self._vertex_source<EOL>", "docstring": "Get the vertex shader source\n\n        :type: ``str``", "id": "f6793:c0:m3"}
{"signature": "@property<EOL><INDENT>def metrics(self):<DEDENT>", "body": "return self._metrics<EOL>", "docstring": "Retrieves the pixel-space design metrics of the font.\n\n        :return: :class:`FontMetrics`", "id": "f6794:c3:m1"}
{"signature": "@property<EOL><INDENT>def ascent(self):<DEDENT>", "body": "return self._ascent<EOL>", "docstring": "Ascent of the font above the baseline, in pixels; typically negative", "id": "f6794:c0:m2"}
{"signature": "def get_glyphs(self, str):", "body": "return [self.get_glyph(c) for c in str]<EOL>", "docstring": "Retrieves a list of :class:`Glyph` for the given string.\n\n        :param str: the string to render", "id": "f6794:c3:m5"}
{"signature": "def arc_distance(theta_1, phi_1, theta_2, phi_2):", "body": "temp = (np.sin((theta_2-theta_1)/<NUM_LIT:2>)**<NUM_LIT:2><EOL>+ np.cos(theta_1)*np.cos(theta_2) * np.sin((phi_2-phi_1)/<NUM_LIT:2>)**<NUM_LIT:2>)<EOL>distance_matrix = <NUM_LIT:2> * np.arctan2(np.sqrt(temp), np.sqrt(<NUM_LIT:1>-temp))<EOL>return distance_matrix<EOL>", "docstring": "Calculates the pairwise arc distance\nbetween all points in vector a and b.", "id": "f6876:m0"}
{"signature": "def export_hdf5_v1(dataset, path, column_names=None, byteorder=\"<STR_LIT:=>\", shuffle=False, selection=False, progress=None, virtual=True):", "body": "if selection:<EOL><INDENT>if selection == True:  <EOL><INDENT>selection = \"<STR_LIT:default>\"<EOL><DEDENT><DEDENT>with h5py.File(path, \"<STR_LIT:w>\") as h5file_output:<EOL><INDENT>h5data_output = h5file_output.require_group(\"<STR_LIT:data>\")<EOL>N = len(dataset) if not selection else dataset.selected_length(selection)<EOL>if N == <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>logger.debug(\"<STR_LIT>\", virtual)<EOL>logger.debug(\"<STR_LIT>\" % (N, path))<EOL>column_names = column_names or dataset.get_column_names(virtual=virtual, strings=True)<EOL>logger.debug(\"<STR_LIT>\" % column_names)<EOL>for column_name in column_names:<EOL><INDENT>dtype = dataset.dtype(column_name)<EOL>if column_name in dataset.get_column_names(strings=True):<EOL><INDENT>column = dataset.columns[column_name]<EOL>shape = (N,) + column.shape[<NUM_LIT:1>:]<EOL><DEDENT>else:<EOL><INDENT>shape = (N,)<EOL><DEDENT>if dtype.type == np.datetime64:<EOL><INDENT>array = h5file_output.require_dataset(\"<STR_LIT>\" % column_name, shape=shape, dtype=np.int64)<EOL>array.attrs[\"<STR_LIT>\"] = dtype.name<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>array = h5file_output.require_dataset(\"<STR_LIT>\" % column_name, shape=shape, dtype=dtype.newbyteorder(byteorder))<EOL><DEDENT>except:<EOL><INDENT>logging.exception(\"<STR_LIT>\" % (column_name, dtype))<EOL><DEDENT><DEDENT>array[<NUM_LIT:0>] = array[<NUM_LIT:0>]  <EOL><DEDENT>random_index_name = None<EOL>column_order = list(column_names)  <EOL>if shuffle:<EOL><INDENT>random_index_name = \"<STR_LIT>\"<EOL>while random_index_name in dataset.get_column_names():<EOL><INDENT>random_index_name += \"<STR_LIT>\"<EOL><DEDENT>shuffle_array = h5file_output.require_dataset(\"<STR_LIT>\" + random_index_name, shape=(N,), dtype=byteorder + \"<STR_LIT>\")<EOL>shuffle_array[<NUM_LIT:0>] = shuffle_array[<NUM_LIT:0>]<EOL>column_order.append(random_index_name)  <EOL><DEDENT>h5data_output.attrs[\"<STR_LIT>\"] = \"<STR_LIT:U+002C>\".join(column_order)  <EOL><DEDENT>dataset_output = vaex.hdf5.dataset.Hdf5MemoryMapped(path, write=True)<EOL>column_names = vaex.export._export(dataset_input=dataset, dataset_output=dataset_output, path=path, random_index_column=random_index_name,<EOL>column_names=column_names, selection=selection, shuffle=shuffle, byteorder=byteorder,<EOL>progress=progress)<EOL>import getpass<EOL>import datetime<EOL>user = getpass.getuser()<EOL>date = str(datetime.datetime.now())<EOL>source = dataset.path<EOL>description = \"<STR_LIT>\" % (user, date, source)<EOL>if dataset.description:<EOL><INDENT>description += \"<STR_LIT>\" + dataset.description<EOL><DEDENT>dataset_output.copy_metadata(dataset)<EOL>dataset_output.description = description<EOL>logger.debug(\"<STR_LIT>\")<EOL>dataset_output.write_meta()<EOL>dataset_output.close_files()<EOL>return<EOL>", "docstring": ":param DatasetLocal dataset: dataset to export\n:param str path: path for file\n:param lis[str] column_names: list of column names to export or None for all columns\n:param str byteorder: = for native, < for little endian and > for big endian\n:param bool shuffle: export rows in random order\n:param bool selection: export selection or not\n:param progress: progress callback that gets a progress fraction as argument and should return True to continue,\n        or a default progress bar when progress=True\n:param: bool virtual: When True, export virtual columns\n:return:", "id": "f6895:m0"}
{"signature": "def write_meta(self):", "body": "with h5py.File(self.filename, \"<STR_LIT>\") as h5file_output:<EOL><INDENT>h5table_root = h5file_output[self.h5table_root_name]<EOL>if self.description is not None:<EOL><INDENT>h5table_root.attrs[\"<STR_LIT:description>\"] = self.description<EOL><DEDENT>h5columns = h5table_root if self._version == <NUM_LIT:1> else h5table_root['<STR_LIT>']<EOL>for column_name in self.columns.keys():<EOL><INDENT>h5dataset = None<EOL>if column_name in h5columns:<EOL><INDENT>h5dataset = h5columns[column_name]<EOL><DEDENT>else:<EOL><INDENT>for group in h5columns.values():<EOL><INDENT>if '<STR_LIT:type>' in group.attrs:<EOL><INDENT>if group.attrs['<STR_LIT:type>'] in ['<STR_LIT>']: <EOL><INDENT>for name, column in group.items():<EOL><INDENT>if name == column_name:<EOL><INDENT>h5dataset = column<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>if h5dataset is None:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(column_name))<EOL><DEDENT>for name, values in [(\"<STR_LIT>\", self.ucds), (\"<STR_LIT>\", self.units), (\"<STR_LIT:description>\", self.descriptions)]:<EOL><INDENT>if column_name in values:<EOL><INDENT>value = ensure_string(values[column_name], cast=True)<EOL>h5dataset.attrs[name] = value<EOL><DEDENT>else:<EOL><INDENT>if name in h5columns.attrs:<EOL><INDENT>del h5dataset.attrs[name]<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "ucds, descriptions and units are written as attributes in the hdf5 file, instead of a seperate file as\n         the default :func:`Dataset.write_meta`.", "id": "f6897:c0:m1"}
{"signature": "def _hide_column(self, column):", "body": "column = _ensure_string_from_expression(column)<EOL>new_name = self._find_valid_name('<STR_LIT>' + column)<EOL>self._rename(column, new_name)<EOL>", "docstring": "Hides a column by prefixing the name with \\'__\\", "id": "f6914:c0:m193"}
{"signature": "def propagate_uncertainties(self, columns, depending_variables=None, cov_matrix='<STR_LIT>',<EOL>covariance_format=\"<STR_LIT>\",<EOL>uncertainty_format=\"<STR_LIT>\"):", "body": "names = _ensure_strings_from_expressions(columns)<EOL>virtual_columns = self._expr(*columns, always_list=True)<EOL>if depending_variables is None:<EOL><INDENT>depending_variables = set()<EOL>for expression in virtual_columns:<EOL><INDENT>depending_variables |= expression.variables()<EOL><DEDENT>depending_variables = list(sorted(list(depending_variables)))<EOL><DEDENT>fs = [self[self.virtual_columns[name]] for name in names]<EOL>jacobian = self._jacobian(fs, depending_variables)<EOL>m = len(fs)<EOL>n = len(depending_variables)<EOL>cov_matrix = self._covariance_matrix_guess(depending_variables, full=cov_matrix == \"<STR_LIT>\", as_expression=True)<EOL>cov_matrix_out = [[self['<STR_LIT:0>'] for __ in range(m)] for __ in range(m)]<EOL>for i in range(m):<EOL><INDENT>for j in range(m):<EOL><INDENT>for k in range(n):<EOL><INDENT>for l in range(n):<EOL><INDENT>if jacobian[i][k].expression == '<STR_LIT:0>' or jacobian[j][l].expression == '<STR_LIT:0>' or cov_matrix[k][l].expression == '<STR_LIT:0>':<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>cov_matrix_out[i][j] = cov_matrix_out[i][j] + jacobian[i][k] * cov_matrix[k][l] * jacobian[j][l]<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>for i in range(m):<EOL><INDENT>for j in range(i + <NUM_LIT:1>):<EOL><INDENT>sigma = cov_matrix_out[i][j]<EOL>sigma = self._expr(vaex.expresso.simplify(_ensure_string_from_expression(sigma)))<EOL>if i != j:<EOL><INDENT>self.add_virtual_column(covariance_format.format(names[i], names[j]), sigma)<EOL><DEDENT>else:<EOL><INDENT>self.add_virtual_column(uncertainty_format.format(names[i]), np.sqrt(sigma))<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Propagates uncertainties (full covariance matrix) for a set of virtual columns.\n\n        Covariance matrix of the depending variables is guessed by finding columns prefixed by \"e\"\n        or `\"e_\"` or postfixed by \"_error\", \"_uncertainty\", \"e\" and `\"_e\"`.\n        Off diagonals (covariance or correlation) by postfixes with \"_correlation\" or \"_corr\" for\n        correlation or \"_covariance\" or \"_cov\" for covariances.\n        (Note that x_y_cov = x_e * y_e * x_y_correlation.)\n\n\n        Example\n\n        >>> df = vaex.from_scalars(x=1, y=2, e_x=0.1, e_y=0.2)\n        >>> df[\"u\"] = df.x + df.y\n        >>> df[\"v\"] = np.log10(df.x)\n        >>> df.propagate_uncertainties([df.u, df.v])\n        >>> df.u_uncertainty, df.v_uncertainty\n\n        :param columns: list of columns for which to calculate the covariance matrix.\n        :param depending_variables: If not given, it is found out automatically, otherwise a list of columns which have uncertainties.\n        :param cov_matrix: List of list with expressions giving the covariance matrix, in the same order as depending_variables. If 'full' or 'auto',\n            the covariance matrix for the depending_variables will be guessed, where 'full' gives an error if an entry was not found.", "id": "f6914:c0:m114"}
{"signature": "@vaex.utils.deprecated('<STR_LIT>')<EOL><INDENT>def _hstack(self, other, prefix=None):<DEDENT>", "body": "assert len(self) == len(other), \"<STR_LIT>\"<EOL>for name in other.get_column_names():<EOL><INDENT>if prefix:<EOL><INDENT>new_name = prefix + name<EOL><DEDENT>else:<EOL><INDENT>new_name = name<EOL><DEDENT>self.add_column(new_name, other.columns[name])<EOL><DEDENT>", "docstring": "Join the columns of the other DataFrame to this one, assuming the ordering is the same", "id": "f6914:c1:m12"}
{"signature": "@docsubst<EOL><INDENT>@stat_1d<EOL>def minmax(self, expression, binby=[], limits=None, shape=default_shape, selection=False, delay=False, progress=None):<DEDENT>", "body": "<EOL>@delayed<EOL>def finish(*minmax_list):<EOL><INDENT>value = vaex.utils.unlistify(waslist, np.array(minmax_list))<EOL>value = value.astype(dtype0)<EOL>return value<EOL><DEDENT>@delayed<EOL>def calculate(expression, limits):<EOL><INDENT>task = tasks.TaskStatistic(self, binby, shape, limits, weight=expression, op=tasks.OP_MIN_MAX, selection=selection)<EOL>self.executor.schedule(task)<EOL>progressbar.add_task(task, \"<STR_LIT>\" % expression)<EOL>return task<EOL><DEDENT>@delayed<EOL>def finish(*minmax_list):<EOL><INDENT>value = vaex.utils.unlistify(waslist, np.array(minmax_list))<EOL>value = value.astype(dtype0)<EOL>return value<EOL><DEDENT>expression = _ensure_strings_from_expressions(expression)<EOL>binby = _ensure_strings_from_expressions(binby)<EOL>waslist, [expressions, ] = vaex.utils.listify(expression)<EOL>dtypes = [self.dtype(expr) for expr in expressions]<EOL>dtype0 = dtypes[<NUM_LIT:0>]<EOL>if not all([k.kind == dtype0.kind for k in dtypes]):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>progressbar = vaex.utils.progressbars(progress, name=\"<STR_LIT>\")<EOL>limits = self.limits(binby, limits, selection=selection, delay=True)<EOL>all_tasks = [calculate(expression, limits) for expression in expressions]<EOL>result = finish(*all_tasks)<EOL>return self._delay(delay, result)<EOL>", "docstring": "Calculate the minimum and maximum for expressions, possibly on a grid defined by binby.\n\n\n        Example:\n\n        >>> df.minmax(\"x\")\n        array([-128.293991,  271.365997])\n        >>> df.minmax([\"x\", \"y\"])\n        array([[-128.293991 ,  271.365997 ],\n                   [ -71.5523682,  146.465836 ]])\n        >>> df.minmax(\"x\", binby=\"x\", shape=5, limits=[-10, 10])\n        array([[-9.99919128, -6.00010443],\n                   [-5.99972439, -2.00002384],\n                   [-1.99991322,  1.99998057],\n                   [ 2.0000093 ,  5.99983597],\n                   [ 6.0004878 ,  9.99984646]])\n\n        :param expression: {expression}\n        :param binby: {binby}\n        :param limits: {limits}\n        :param shape: {shape}\n        :param selection: {selection}\n        :param delay: {delay}\n        :param progress: {progress}\n        :return: {return_stat_scalar}, the last dimension is of shape (2)", "id": "f6914:c0:m36"}
{"signature": "def dtype(self, expression, internal=False):", "body": "expression = _ensure_string_from_expression(expression)<EOL>if expression in self.variables:<EOL><INDENT>return np.float64(<NUM_LIT:1>).dtype<EOL><DEDENT>elif expression in self.columns.keys():<EOL><INDENT>column = self.columns[expression]<EOL>data = column[<NUM_LIT:0>:<NUM_LIT:1>]<EOL>dtype = data.dtype<EOL><DEDENT>else:<EOL><INDENT>data = self.evaluate(expression, <NUM_LIT:0>, <NUM_LIT:1>, filtered=False)<EOL>dtype = data.dtype<EOL><DEDENT>if not internal:<EOL><INDENT>if dtype != str_type:<EOL><INDENT>if dtype.kind in '<STR_LIT>':<EOL><INDENT>return str_type<EOL><DEDENT>if dtype.kind == '<STR_LIT:O>':<EOL><INDENT>if isinstance(data[<NUM_LIT:0>], six.string_types):<EOL><INDENT>return str_type<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return dtype<EOL>", "docstring": "Return the numpy dtype for the given expression, if not a column, the first row will be evaluated to get the dtype.", "id": "f6914:c0:m57"}
{"signature": "@docsubst<EOL><INDENT>@stat_1d<EOL>def sum(self, expression, binby=[], limits=None, shape=default_shape, selection=False, delay=False, progress=None, edges=False):<DEDENT>", "body": "return self._compute_agg('<STR_LIT>', expression, binby, limits, shape, selection, delay, edges, progress)<EOL>@delayed<EOL>def finish(*sums):<EOL><INDENT>return vaex.utils.unlistify(waslist, sums)<EOL><DEDENT>expression = _ensure_strings_from_expressions(expression)<EOL>binby = _ensure_strings_from_expressions(binby)<EOL>waslist, [expressions, ] = vaex.utils.listify(expression)<EOL>progressbar = vaex.utils.progressbars(progress)<EOL>limits = self.limits(binby, limits, delay=True)<EOL>sums = [self._sum_calculation(expression, binby=binby, limits=limits, shape=shape, selection=selection, progressbar=progressbar) for expression in expressions]<EOL>s = finish(*sums)<EOL>return self._delay(delay, s)<EOL>", "docstring": "Calculate the sum for the given expression, possible on a grid defined by binby\n\n        Example:\n\n        >>> df.sum(\"L\")\n        304054882.49378014\n        >>> df.sum(\"L\", binby=\"E\", shape=4)\n        array([  8.83517994e+06,   5.92217598e+07,   9.55218726e+07,\n                         1.40008776e+08])\n\n        :param expression: {expression}\n        :param binby: {binby}\n        :param limits: {limits}\n        :param shape: {shape}\n        :param selection: {selection}\n        :param delay: {delay}\n        :param progress: {progress}\n        :return: {return_stat_scalar}", "id": "f6914:c0:m30"}
{"signature": "def selected_length(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Returns the number of rows that are selected.", "id": "f6914:c0:m154"}
{"signature": "def evaluate(self, expression, i1=None, i2=None, out=None, selection=None, filtered=True, internal=False):", "body": "expression = _ensure_string_from_expression(expression)<EOL>selection = _ensure_strings_from_expressions(selection)<EOL>i1 = i1 or <NUM_LIT:0><EOL>i2 = i2 or (len(self) if (self.filtered and filtered) else self.length_unfiltered())<EOL>mask = None<EOL>if self.filtered and filtered:  <EOL><INDENT>indices = self._filtered_range_to_unfiltered_indices(i1, i2)<EOL>i1 = indices[<NUM_LIT:0>]<EOL>i2 = indices[-<NUM_LIT:1>] + <NUM_LIT:1>  <EOL><DEDENT>if selection is not None or (self.filtered and filtered):<EOL><INDENT>mask = self.evaluate_selection_mask(selection, i1, i2)<EOL><DEDENT>scope = scopes._BlockScope(self, i1, i2, mask=mask, **self.variables)<EOL>if out is not None:<EOL><INDENT>scope.buffers[expression] = out<EOL><DEDENT>value = scope.evaluate(expression)<EOL>if isinstance(value, ColumnString) and not internal:<EOL><INDENT>value = value.to_numpy()<EOL><DEDENT>return value<EOL>", "docstring": "The local implementation of :func:`DataFrame.evaluate`", "id": "f6914:c1:m17"}
{"signature": "@docsubst<EOL><INDENT>def to_dict(self, column_names=None, selection=None, strings=True, virtual=False):<DEDENT>", "body": "return dict(self.to_items(column_names=column_names, selection=selection, strings=strings, virtual=virtual))<EOL>", "docstring": "Return a dict containing the ndarray corresponding to the evaluated data\n\n        :param column_names: list of column names, to export, when None DataFrame.get_column_names(strings=strings, virtual=virtual) is used\n        :param selection: {selection}\n        :param strings: argument passed to DataFrame.get_column_names when column_names is None\n        :param virtual: argument passed to DataFrame.get_column_names when column_names is None\n        :return: dict", "id": "f6914:c0:m95"}
{"signature": "@_hidden<EOL><INDENT>def add_virtual_columns_cartesian_to_spherical(self, x=\"<STR_LIT:x>\", y=\"<STR_LIT:y>\", z=\"<STR_LIT:z>\", alpha=\"<STR_LIT:l>\", delta=\"<STR_LIT:b>\", distance=\"<STR_LIT>\", radians=False, center=None, center_name=\"<STR_LIT>\"):<DEDENT>", "body": "transform = \"<STR_LIT>\" if radians else \"<STR_LIT>\"<EOL>if center is not None:<EOL><INDENT>self.add_variable(center_name, center)<EOL><DEDENT>if center is not None and center[<NUM_LIT:0>] != <NUM_LIT:0>:<EOL><INDENT>x = \"<STR_LIT>\".format(**locals())<EOL><DEDENT>if center is not None and center[<NUM_LIT:1>] != <NUM_LIT:0>:<EOL><INDENT>y = \"<STR_LIT>\".format(**locals())<EOL><DEDENT>if center is not None and center[<NUM_LIT:2>] != <NUM_LIT:0>:<EOL><INDENT>z = \"<STR_LIT>\".format(**locals())<EOL><DEDENT>self.add_virtual_column(distance, \"<STR_LIT>\".format(**locals()))<EOL>self.add_virtual_column(alpha, \"<STR_LIT>\".format(**locals()))<EOL>self.add_virtual_column(delta, \"<STR_LIT>\".format(**locals()))<EOL>", "docstring": "Convert cartesian to spherical coordinates.\n\n\n\n        :param x:\n        :param y:\n        :param z:\n        :param alpha:\n        :param delta: name for polar angle, ranges from -90 to 90 (or -pi to pi when radians is True).\n        :param distance:\n        :param radians:\n        :param center:\n        :param center_name:\n        :return:", "id": "f6914:c0:m122"}
{"signature": "def __getitem__(self, item):", "body": "if isinstance(item, int):<EOL><INDENT>names = self.get_column_names()<EOL>return [self.evaluate(name, item, item+<NUM_LIT:1>)[<NUM_LIT:0>] for name in names]<EOL><DEDENT>elif isinstance(item, six.string_types):<EOL><INDENT>if hasattr(self, item) and isinstance(getattr(self, item), Expression):<EOL><INDENT>return getattr(self, item)<EOL><DEDENT>return Expression(self, item)  <EOL><DEDENT>elif isinstance(item, Expression):<EOL><INDENT>expression = item.expression<EOL>df = self.copy()<EOL>df.select(expression, name=FILTER_SELECTION_NAME, mode='<STR_LIT>')<EOL>return df<EOL><DEDENT>elif isinstance(item, (tuple, list)):<EOL><INDENT>df = self.copy(column_names=item)<EOL>return df<EOL><DEDENT>elif isinstance(item, slice):<EOL><INDENT>df = self.extract()<EOL>start, stop, step = item.start, item.stop, item.step<EOL>start = start or <NUM_LIT:0><EOL>stop = stop or len(df)<EOL>assert step in [None, <NUM_LIT:1>]<EOL>df.set_active_range(start, stop)<EOL>return df.trim()<EOL><DEDENT>", "docstring": "Convenient way to get expressions, (shallow) copies of a few columns, or to apply filtering.\n\n        Example:\n\n        >>> df['Lz']  # the expression 'Lz\n        >>> df['Lz/2'] # the expression 'Lz/2'\n        >>> df[[\"Lz\", \"E\"]] # a shallow copy with just two columns\n        >>> df[df.Lz < 0]  # a shallow copy with the filter Lz < 0 applied", "id": "f6914:c0:m190"}
{"signature": "@docsubst<EOL><INDENT>@stat_1d<EOL>def var(self, expression, binby=[], limits=None, shape=default_shape, selection=False, delay=False, progress=None):<DEDENT>", "body": "expression = _ensure_strings_from_expressions(expression)<EOL>@delayed<EOL>def calculate(expression, limits):<EOL><INDENT>task = tasks.TaskStatistic(self, binby, shape, limits, weight=expression, op=tasks.OP_ADD_WEIGHT_MOMENTS_012, selection=selection)<EOL>progressbar.add_task(task, \"<STR_LIT>\" % expression)<EOL>self.executor.schedule(task)<EOL>return task<EOL><DEDENT>@delayed<EOL>def finish(*stats_args):<EOL><INDENT>stats = np.array(stats_args)<EOL>counts = stats[..., <NUM_LIT:0>]<EOL>with np.errstate(divide='<STR_LIT:ignore>'):<EOL><INDENT>with np.errstate(divide='<STR_LIT:ignore>', invalid='<STR_LIT:ignore>'):  <EOL><INDENT>mean = stats[..., <NUM_LIT:1>] / counts<EOL>raw_moments2 = stats[..., <NUM_LIT:2>] / counts<EOL><DEDENT><DEDENT>variance = (raw_moments2 - mean**<NUM_LIT:2>)<EOL>return vaex.utils.unlistify(waslist, variance)<EOL><DEDENT>binby = _ensure_strings_from_expressions(binby)<EOL>waslist, [expressions, ] = vaex.utils.listify(expression)<EOL>progressbar = vaex.utils.progressbars(progress)<EOL>limits = self.limits(binby, limits, delay=True)<EOL>stats = [calculate(expression, limits) for expression in expressions]<EOL>var = finish(*stats)<EOL>return self._delay(delay, var)<EOL>", "docstring": "Calculate the sample variance for the given expression, possible on a grid defined by binby\n\n        Example:\n\n        >>> df.var(\"vz\")\n        12170.002429456246\n        >>> df.var(\"vz\", binby=[\"(x**2+y**2)**0.5\"], shape=4)\n        array([ 15271.90481083,   7284.94713504,   3738.52239232,   1449.63418988])\n        >>> df.var(\"vz\", binby=[\"(x**2+y**2)**0.5\"], shape=4)**0.5\n        array([ 123.57954851,   85.35190177,   61.14345748,   38.0740619 ])\n        >>> df.std(\"vz\", binby=[\"(x**2+y**2)**0.5\"], shape=4)\n        array([ 123.57954851,   85.35190177,   61.14345748,   38.0740619 ])\n\n        :param expression: {expression}\n        :param binby: {binby}\n        :param limits: {limits}\n        :param shape: {shape}\n        :param selection: {selection}\n        :param delay: {delay}\n        :param progress: {progress}\n        :return: {return_stat_scalar}", "id": "f6914:c0:m32"}
{"signature": "@docsubst<EOL><INDENT>@stat_1d<EOL>def _agg(self, aggregator, grid, selection=False, delay=False, progress=None):<DEDENT>", "body": "task_agg = self._get_task_agg(grid)<EOL>sub_task = aggregator.add_operations(task_agg)<EOL>return self._delay(delay, sub_task)<EOL>", "docstring": ":param selection: {selection}\n:param delay: {delay}\n:param progress: {progress}\n:return: {return_stat_scalar}", "id": "f6914:c1:m32"}
{"signature": "@docsubst<EOL><INDENT>def covar(self, x, y, binby=[], limits=None, shape=default_shape, selection=False, delay=False, progress=None):<DEDENT>", "body": "@delayed<EOL>def cov(mean_x, mean_y, mean_xy):<EOL><INDENT>return mean_xy - mean_x * mean_y<EOL><DEDENT>waslist, [xlist, ylist] = vaex.utils.listify(x, y)<EOL>limits = self.limits(binby, limits, selection=selection, delay=True)<EOL>@delayed<EOL>def calculate(limits):<EOL><INDENT>results = []<EOL>for x, y in zip(xlist, ylist):<EOL><INDENT>mx = self.mean(x, binby=binby, limits=limits, shape=shape, selection=selection, delay=True, progress=progressbar)<EOL>my = self.mean(y, binby=binby, limits=limits, shape=shape, selection=selection, delay=True, progress=progressbar)<EOL>cxy = self.mean(\"<STR_LIT>\" % (x, y), binby=binby, limits=limits, shape=shape, selection=selection,<EOL>delay=True, progress=progressbar)<EOL>results.append(cov(mx, my, cxy))<EOL><DEDENT>return results<EOL><DEDENT>progressbar = vaex.utils.progressbars(progress)<EOL>covars = calculate(limits)<EOL>@delayed<EOL>def finish(covars):<EOL><INDENT>value = np.array(vaex.utils.unlistify(waslist, covars))<EOL>return value<EOL><DEDENT>return self._delay(delay, finish(delayed_list(covars)))<EOL>", "docstring": "Calculate the covariance cov[x,y] between and x and y, possibly on a grid defined by binby.\n\n        Example:\n\n        >>> df.covar(\"x**2+y**2+z**2\", \"-log(-E+1)\")\n        array(52.69461456005138)\n        >>> df.covar(\"x**2+y**2+z**2\", \"-log(-E+1)\")/(df.std(\"x**2+y**2+z**2\") * df.std(\"-log(-E+1)\"))\n        0.63666373822156686\n        >>> df.covar(\"x**2+y**2+z**2\", \"-log(-E+1)\", binby=\"Lz\", shape=4)\n        array([ 10.17387143,  51.94954078,  51.24902796,  20.2163929 ])\n\n\n\n        :param x: {expression}\n        :param y: {expression}\n        :param binby: {binby}\n        :param limits: {limits}\n        :param shape: {shape}\n        :param selection: {selection}\n        :param delay: {delay}\n        :param progress: {progress}\n        :return: {return_stat_scalar}", "id": "f6914:c0:m33"}
{"signature": "def nop(self, expression, progress=False, delay=False):", "body": "expression = _ensure_string_from_expression(expression)<EOL>def map(ar):<EOL><INDENT>pass<EOL><DEDENT>def reduce(a, b):<EOL><INDENT>pass<EOL><DEDENT>return self.map_reduce(map, reduce, [expression], delay=delay, progress=progress, name='<STR_LIT>', to_numpy=False)<EOL>", "docstring": "Evaluates expression, and drop the result, usefull for benchmarking, since vaex is usually lazy", "id": "f6914:c0:m13"}
{"signature": "@_hidden<EOL><INDENT>def add_column_healpix(self, name=\"<STR_LIT>\", longitude=\"<STR_LIT>\", latitude=\"<STR_LIT>\", degrees=True, healpix_order=<NUM_LIT:12>, nest=True):<DEDENT>", "body": "import healpy as hp<EOL>if degrees:<EOL><INDENT>scale = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>scale = \"<STR_LIT>\"<EOL><DEDENT>phi = self.evaluate(\"<STR_LIT>\" % (longitude, scale))<EOL>theta = self.evaluate(\"<STR_LIT>\" % (latitude, scale))<EOL>hp_index = hp.ang2pix(hp.order2nside(healpix_order), theta, phi, nest=nest)<EOL>self.add_column(\"<STR_LIT>\", hp_index)<EOL>", "docstring": "Add a healpix (in memory) column based on a longitude and latitude\n\n        :param name: Name of column\n        :param longitude: longitude expression\n        :param latitude: latitude expression  (astronomical convenction latitude=90 is north pole)\n        :param degrees: If lon/lat are in degrees (default) or radians.\n        :param healpix_order: healpix order, >= 0\n        :param nest: Nested healpix (default) or ring.", "id": "f6914:c0:m109"}
{"signature": "@docsubst<EOL><INDENT>def to_items(self, column_names=None, selection=None, strings=True, virtual=False):<DEDENT>", "body": "items = []<EOL>for name in column_names or self.get_column_names(strings=strings, virtual=virtual):<EOL><INDENT>items.append((name, self.evaluate(name, selection=selection)))<EOL><DEDENT>return items<EOL>", "docstring": "Return a list of [(column_name, ndarray), ...)] pairs where the ndarray corresponds to the evaluated data\n\n        :param column_names: list of column names, to export, when None DataFrame.get_column_names(strings=strings, virtual=virtual) is used\n        :param selection: {selection}\n        :param strings: argument passed to DataFrame.get_column_names when column_names is None\n        :param virtual: argument passed to DataFrame.get_column_names when column_names is None\n        :return: list of (name, ndarray) pairs", "id": "f6914:c0:m94"}
{"signature": "def select_circle(self, x, y, xc, yc, r, mode=\"<STR_LIT:replace>\", name=\"<STR_LIT:default>\", inclusive=True):", "body": "<EOL>if inclusive:<EOL><INDENT>expr = (self[x] - xc)**<NUM_LIT:2> + (self[y] - yc)**<NUM_LIT:2> <= r**<NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>expr = (self[x] - xc)**<NUM_LIT:2> + (self[y] - yc)**<NUM_LIT:2> < r**<NUM_LIT:2><EOL><DEDENT>self.select(boolean_expression=expr, mode=mode, name=name)<EOL>", "docstring": "Select a circular region centred on xc, yc, with a radius of r.\n\nExample:\n\n>>> df.select_circle('x','y',2,3,1)\n\n:param x: expression for the x space\n:param y: expression for the y space\n:param xc: location of the centre of the circle in x\n:param yc: location of the centre of the circle in y\n:param r: the radius of the circle\n:param name: name of the selection\n:param mode:\n:return:", "id": "f6914:c0:m182"}
{"signature": "def select_non_missing(self, drop_nan=True, drop_masked=True, column_names=None, mode=\"<STR_LIT:replace>\", name=\"<STR_LIT:default>\"):", "body": "column_names = column_names or self.get_column_names(virtual=False)<EOL>def create(current):<EOL><INDENT>return selections.SelectionDropNa(drop_nan, drop_masked, column_names, current, mode)<EOL><DEDENT>self._selection(create, name)<EOL>", "docstring": "Create a selection that selects rows having non missing values for all columns in column_names.\n\n        The name reflect Panda's, no rows are really dropped, but a mask is kept to keep track of the selection\n\n        :param drop_nan: drop rows when there is a NaN in any of the columns (will only affect float values)\n        :param drop_masked: drop rows when there is a masked value in any of the columns\n        :param column_names: The columns to consider, default: all (real, non-virtual) columns\n        :param str mode: Possible boolean operator: replace/and/or/xor/subtract\n        :param str name: history tree or selection 'slot' to use\n        :return:", "id": "f6914:c0:m177"}
{"signature": "def __current_sequence_index(self):", "body": "return <NUM_LIT:0><EOL>", "docstring": "TODO", "id": "f6914:c0:m146"}
{"signature": "def select_ellipse(self, x, y, xc, yc, width, height, angle=<NUM_LIT:0>, mode=\"<STR_LIT:replace>\", name=\"<STR_LIT:default>\", radians=False, inclusive=True):", "body": "<EOL>if radians:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>alpha = np.deg2rad(angle)<EOL><DEDENT>xr = width / <NUM_LIT:2><EOL>yr = height / <NUM_LIT:2><EOL>r = max(xr, yr)<EOL>a = xr / r<EOL>b = yr / r<EOL>expr = \"<STR_LIT>\".format(**locals())<EOL>if inclusive:<EOL><INDENT>expr = ((self[x] - xc) * np.cos(alpha) + (self[y] - yc) * np.sin(alpha))**<NUM_LIT:2> / a**<NUM_LIT:2> + ((self[x] - xc) * np.sin(alpha) - (self[y] - yc) * np.cos(alpha))**<NUM_LIT:2> / b**<NUM_LIT:2> <= r**<NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>expr = ((self[x] - xc) * np.cos(alpha) + (self[y] - yc) * np.sin(alpha))**<NUM_LIT:2> / a**<NUM_LIT:2> + ((self[x] - xc) * np.sin(alpha) - (self[y] - yc) * np.cos(alpha))**<NUM_LIT:2> / b**<NUM_LIT:2> < r**<NUM_LIT:2><EOL><DEDENT>self.select(boolean_expression=expr, mode=mode, name=name)<EOL>", "docstring": "Select an elliptical region centred on xc, yc, with a certain width, height\nand angle.\n\nExample:\n\n>>> df.select_ellipse('x','y', 2, -1, 5,1, 30, name='my_ellipse')\n\n:param x: expression for the x space\n:param y: expression for the y space\n:param xc: location of the centre of the ellipse in x\n:param yc: location of the centre of the ellipse in y\n:param width: the width of the ellipse (diameter)\n:param height: the width of the ellipse (diameter)\n:param angle: (degrees) orientation of the ellipse, counter-clockwise\n              measured from the y axis\n:param name: name of the selection\n:param mode:\n:return:", "id": "f6914:c0:m183"}
{"signature": "def select(self, boolean_expression, mode=\"<STR_LIT:replace>\", name=\"<STR_LIT:default>\"):", "body": "raise NotImplementedError<EOL>", "docstring": "Select rows based on the boolean_expression, if there was a previous selection, the mode is taken into account.\n\n        if boolean_expression is None, remove the selection, has_selection() will returns false\n\n        Note that per DataFrame, only one selection is possible.\n\n        :param str boolean_expression: boolean expression, such as 'x < 0', '(x < 0) || (y > -10)' or None to remove the selection\n        :param str mode: boolean operation to perform with the previous selection, \"replace\", \"and\", \"or\", \"xor\", \"subtract\"\n        :return: None", "id": "f6914:c0:m103"}
{"signature": "def get_private_dir(self, create=False):", "body": "if self.is_local():<EOL><INDENT>name = os.path.abspath(self.path).replace(os.path.sep, \"<STR_LIT:_>\")[:<NUM_LIT>]  <EOL>name = name.replace(\"<STR_LIT::>\", \"<STR_LIT:_>\")  <EOL><DEDENT>else:<EOL><INDENT>server = self.server<EOL>name = \"<STR_LIT>\" % (server.hostname, server.port, server.base_path.replace(\"<STR_LIT:/>\", \"<STR_LIT:_>\"), self.name)<EOL><DEDENT>dir = os.path.join(vaex.utils.get_private_dir(), \"<STR_LIT>\", name)<EOL>if create and not os.path.exists(dir):<EOL><INDENT>os.makedirs(dir)<EOL><DEDENT>return dir<EOL>", "docstring": "Each DataFrame has a directory where files are stored for metadata etc.\n\n        Example\n\n        >>> import vaex\n        >>> ds = vaex.example()\n        >>> vaex.get_private_dir()\n        '/Users/users/breddels/.vaex/dfs/_Users_users_breddels_vaex-testing_data_helmi-dezeeuw-2000-10p.hdf5'\n\n        :param bool create: is True, it will create the directory if it does not exist", "id": "f6914:c0:m68"}
{"signature": "def export(self, path, column_names=None, byteorder=\"<STR_LIT:=>\", shuffle=False, selection=False, progress=None, virtual=False, sort=None, ascending=True):", "body": "if path.endswith('<STR_LIT>'):<EOL><INDENT>self.export_arrow(path, column_names, byteorder, shuffle, selection, progress=progress, virtual=virtual, sort=sort, ascending=ascending)<EOL><DEDENT>elif path.endswith('<STR_LIT>'):<EOL><INDENT>self.export_hdf5(path, column_names, byteorder, shuffle, selection, progress=progress, virtual=virtual, sort=sort, ascending=ascending)<EOL><DEDENT>elif path.endswith('<STR_LIT>'):<EOL><INDENT>self.export_fits(path, column_names, shuffle, selection, progress=progress, virtual=virtual, sort=sort, ascending=ascending)<EOL><DEDENT>if path.endswith('<STR_LIT>'):<EOL><INDENT>self.export_parquet(path, column_names, shuffle, selection, progress=progress, virtual=virtual, sort=sort, ascending=ascending)<EOL><DEDENT>", "docstring": "Exports the DataFrame to a file written with arrow\n\n        :param DataFrameLocal df: DataFrame to export\n        :param str path: path for file\n        :param lis[str] column_names: list of column names to export or None for all columns\n        :param str byteorder: = for native, < for little endian and > for big endian (not supported for fits)\n        :param bool shuffle: export rows in random order\n        :param bool selection: export selection or not\n        :param progress: progress callback that gets a progress fraction as argument and should return True to continue,\n                or a default progress bar when progress=True\n        :param: bool virtual: When True, export virtual columns\n        :param str sort: expression used for sorting the output\n        :param bool ascending: sort ascending (True) or descending\n        :return:", "id": "f6914:c1:m21"}
{"signature": "@property<EOL><INDENT>def nbytes(self):<DEDENT>", "body": "return self.byte_size()<EOL>", "docstring": "Alias for `df.byte_size()`, see :meth:`DataFrame.byte_size`.", "id": "f6914:c0:m56"}
{"signature": "def has_selection(self, name=\"<STR_LIT:default>\"):", "body": "return self.get_selection(name) is not None<EOL>", "docstring": "Returns True if there is a selection with the given name.", "id": "f6914:c0:m188"}
{"signature": "def is_category(self, column):", "body": "column = _ensure_string_from_expression(column)<EOL>return column in self._categories<EOL>", "docstring": "Returns true if column is a category.", "id": "f6914:c0:m5"}
{"signature": "@vaex.utils.deprecated('<STR_LIT>')<EOL><INDENT>@_hidden<EOL>def __call__(self, *expressions, **kwargs):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Alias/shortcut for :func:`DataFrame.subspace`", "id": "f6914:c0:m87"}
{"signature": "def is_masked(self, column):", "body": "column = _ensure_string_from_expression(column)<EOL>if column in self.columns:<EOL><INDENT>return np.ma.isMaskedArray(self.columns[column])<EOL><DEDENT>return False<EOL>", "docstring": "Return if a column is a masked (numpy.ma) column.", "id": "f6914:c0:m59"}
{"signature": "def dropna(self, drop_nan=True, drop_masked=True, column_names=None):", "body": "copy = self.copy()<EOL>copy.select_non_missing(drop_nan=drop_nan, drop_masked=drop_masked, column_names=column_names,<EOL>name=FILTER_SELECTION_NAME, mode='<STR_LIT>')<EOL>return copy<EOL>", "docstring": "Create a shallow copy of a DataFrame, with filtering set using select_non_missing.\n\n        :param drop_nan: drop rows when there is a NaN in any of the columns (will only affect float values)\n        :param drop_masked: drop rows when there is a masked value in any of the columns\n        :param column_names: The columns to consider, default: all (real, non-virtual) columns\n        :rtype: DataFrame", "id": "f6914:c0:m178"}
{"signature": "@_hidden<EOL><INDENT>def write_meta(self):<DEDENT>", "body": "<EOL>path = os.path.join(self.get_private_dir(create=True), \"<STR_LIT>\")<EOL>units = {key: str(value) for key, value in self.units.items()}<EOL>meta_info = dict(description=self.description,<EOL>ucds=self.ucds, units=units, descriptions=self.descriptions,<EOL>)<EOL>vaex.utils.write_json_or_yaml(path, meta_info)<EOL>", "docstring": "Writes all meta data, ucd,description and units\n\n        The default implementation is to write this to a file called meta.yaml in the directory defined by\n        :func:`DataFrame.get_private_dir`. Other implementation may store this in the DataFrame file itself.\n        (For instance the vaex hdf5 implementation does this)\n\n        This method is called after virtual columns or variables are added. Upon opening a file, :func:`DataFrame.update_meta`\n        is called, so that the information is not lost between sessions.\n\n        Note: opening a DataFrame twice may result in corruption of this file.", "id": "f6914:c0:m76"}
{"signature": "def select_rectangle(self, x, y, limits, mode=\"<STR_LIT:replace>\", name=\"<STR_LIT:default>\"):", "body": "self.select_box([x, y], limits, mode=mode, name=name)<EOL>", "docstring": "Select a 2d rectangular box in the space given by x and y, bounds by limits.\n\n        Example:\n\n        >>> df.select_box('x', 'y', [(0, 10), (0, 1)])\n\n        :param x: expression for the x space\n        :param y: expression fo the y space\n        :param limits: sequence of shape [(x1, x2), (y1, y2)]\n        :param mode:", "id": "f6914:c0:m180"}
{"signature": "@_hidden<EOL><INDENT>def __call__(self, *expressions, **kwargs):<DEDENT>", "body": "import vaex.legacy<EOL>return vaex.legacy.SubspaceLocal(self, expressions, kwargs.get(\"<STR_LIT>\") or self.executor, delay=kwargs.get(\"<STR_LIT>\", False))<EOL>", "docstring": "The local implementation of :func:`DataFrame.__call__`", "id": "f6914:c1:m9"}
{"signature": "def selection_redo(self, name=\"<STR_LIT:default>\", executor=None):", "body": "logger.debug(\"<STR_LIT>\")<EOL>executor = executor or self.executor<EOL>assert self.selection_can_redo(name=name)<EOL>selection_history = self.selection_histories[name]<EOL>index = self.selection_history_indices[name]<EOL>next = selection_history[index + <NUM_LIT:1>]<EOL>self.selection_history_indices[name] += <NUM_LIT:1><EOL>self.signal_selection_changed.emit(self)<EOL>logger.debug(\"<STR_LIT>\", selection_history, index)<EOL>", "docstring": "Redo selection, for the name.", "id": "f6914:c0:m173"}
{"signature": "def selection_can_undo(self, name=\"<STR_LIT:default>\"):", "body": "return self.selection_history_indices[name] > -<NUM_LIT:1><EOL>", "docstring": "Can selection name be undone?", "id": "f6914:c0:m174"}
{"signature": "@_hidden<EOL><INDENT>def subspaces(self, expressions_list=None, dimensions=None, exclude=None, **kwargs):<DEDENT>", "body": "if dimensions is not None:<EOL><INDENT>expressions_list = list(itertools.combinations(self.get_column_names(), dimensions))<EOL>if exclude is not None:<EOL><INDENT>import six<EOL>def excluded(expressions):<EOL><INDENT>if callable(exclude):<EOL><INDENT>return exclude(expressions)<EOL><DEDENT>elif isinstance(exclude, six.string_types):<EOL><INDENT>return exclude in expressions<EOL><DEDENT>elif isinstance(exclude, (list, tuple)):<EOL><INDENT>for e in exclude:<EOL><INDENT>if isinstance(e, six.string_types):<EOL><INDENT>if e in expressions:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>elif isinstance(e, (list, tuple)):<EOL><INDENT>if set(e).issubset(expressions):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return False<EOL><DEDENT>expressions_list = [expr for expr in expressions_list if not excluded(expr)]<EOL><DEDENT>logger.debug(\"<STR_LIT>\", expressions_list)<EOL><DEDENT>import vaex.legacy<EOL>return vaex.legacy.Subspaces([self(*expressions, **kwargs) for expressions in expressions_list])<EOL>", "docstring": "Generate a Subspaces object, based on a custom list of expressions or all possible combinations based on\n        dimension\n\n        :param expressions_list: list of list of expressions, where the inner list defines the subspace\n        :param dimensions: if given, generates a subspace with all possible combinations for that dimension\n        :param exclude: list of", "id": "f6914:c0:m85"}
{"signature": "@docsubst<EOL><INDENT>def limits_percentage(self, expression, percentage=<NUM_LIT>, square=False, delay=False):<DEDENT>", "body": "<EOL>import scipy<EOL>logger.info(\"<STR_LIT>\", expression, percentage)<EOL>waslist, [expressions, ] = vaex.utils.listify(expression)<EOL>limits = []<EOL>for expr in expressions:<EOL><INDENT>subspace = self(expr)<EOL>limits_minmax = subspace.minmax()<EOL>vmin, vmax = limits_minmax[<NUM_LIT:0>]<EOL>size = <NUM_LIT> * <NUM_LIT:16><EOL>counts = subspace.histogram(size=size, limits=limits_minmax)<EOL>cumcounts = np.concatenate([[<NUM_LIT:0>], np.cumsum(counts)])<EOL>cumcounts /= cumcounts.max()<EOL>f = (<NUM_LIT:1> - percentage / <NUM_LIT>) / <NUM_LIT:2><EOL>x = np.linspace(vmin, vmax, size + <NUM_LIT:1>)<EOL>l = scipy.interp([f, <NUM_LIT:1> - f], cumcounts, x)<EOL>limits.append(l)<EOL><DEDENT>return vaex.utils.unlistify(waslist, limits)<EOL>", "docstring": "Calculate the [min, max] range for expression, containing approximately a percentage of the data as defined\n        by percentage.\n\n        The range is symmetric around the median, i.e., for a percentage of 90, this gives the same results as:\n\n        Example:\n\n        >>> df.limits_percentage(\"x\", 90)\n        array([-12.35081376,  12.14858052]\n        >>> df.percentile_approx(\"x\", 5), df.percentile_approx(\"x\", 95)\n        (array([-12.36813152]), array([ 12.13275818]))\n\n        NOTE: this value is approximated by calculating the cumulative distribution on a grid.\n        NOTE 2: The values above are not exactly the same, since percentile and limits_percentage do not share the same code\n\n        :param expression: {expression_limits}\n        :param float percentage: Value between 0 and 100\n        :param delay: {delay}\n        :return: {return_limits}", "id": "f6914:c0:m43"}
{"signature": "def add_virtual_column(self, name, expression, unique=False):", "body": "type = \"<STR_LIT>\" if name in self.virtual_columns else \"<STR_LIT>\"<EOL>expression = _ensure_string_from_expression(expression)<EOL>if name in self.get_column_names(virtual=False):<EOL><INDENT>renamed = '<STR_LIT>' +vaex.utils.find_valid_name(name, used=self.get_column_names())<EOL>expression = self._rename(name, renamed, expression)[<NUM_LIT:0>].expression<EOL><DEDENT>name = vaex.utils.find_valid_name(name, used=[] if not unique else self.get_column_names())<EOL>self.virtual_columns[name] = expression<EOL>self.column_names.append(name)<EOL>self._save_assign_expression(name)<EOL>self.signal_column_changed.emit(self, name, \"<STR_LIT>\")<EOL>", "docstring": "Add a virtual column to the DataFrame.\n\n        Example:\n\n        >>> df.add_virtual_column(\"r\", \"sqrt(x**2 + y**2 + z**2)\")\n        >>> df.select(\"r < 10\")\n\n        :param: str name: name of virtual column\n        :param: expression: expression for the column\n        :param str unique: if name is already used, make it unique by adding a postfix, e.g. _1, or _2", "id": "f6914:c0:m126"}
{"signature": "def add_variable(self, name, expression, overwrite=True, unique=True):", "body": "if unique or overwrite or name not in self.variables:<EOL><INDENT>existing_names = self.get_column_names(virtual=False) + list(self.variables.keys())<EOL>name = vaex.utils.find_valid_name(name, used=[] if not unique else existing_names)<EOL>self.variables[name] = expression<EOL>self.signal_variable_changed.emit(self, name, \"<STR_LIT>\")<EOL>if unique:<EOL><INDENT>return name<EOL><DEDENT><DEDENT>", "docstring": "Add a variable to to a DataFrame.\n\n        A variable may refer to other variables, and virtual columns and expression may refer to variables.\n\n        Example\n\n        >>> df.add_variable('center', 0)\n        >>> df.add_virtual_column('x_prime', 'x-center')\n        >>> df.select('x_prime < 0')\n\n        :param: str name: name of virtual varible\n        :param: expression: expression for the variable", "id": "f6914:c0:m129"}
{"signature": "def __len__(self):", "body": "if not self.filtered:<EOL><INDENT>return self._length_unfiltered<EOL><DEDENT>else:<EOL><INDENT>return int(self.count())<EOL><DEDENT>", "docstring": "Returns the number of rows in the DataFrame (filtering applied).", "id": "f6914:c0:m153"}
{"signature": "def concat(self, other):", "body": "dfs = []<EOL>if isinstance(self, DataFrameConcatenated):<EOL><INDENT>dfs.extend(self.dfs)<EOL><DEDENT>else:<EOL><INDENT>dfs.extend([self])<EOL><DEDENT>if isinstance(other, DataFrameConcatenated):<EOL><INDENT>dfs.extend(other.dfs)<EOL><DEDENT>else:<EOL><INDENT>dfs.extend([other])<EOL><DEDENT>return DataFrameConcatenated(dfs)<EOL>", "docstring": "Concatenates two DataFrames, adding the rows of one the other DataFrame to the current, returned in a new DataFrame.\n\n        No copy of the data is made.\n\n        :param other: The other DataFrame that is concatenated with this DataFrame\n        :return: New DataFrame with the rows concatenated\n        :rtype: DataFrameConcatenated", "id": "f6914:c1:m13"}
{"signature": "def select(self, boolean_expression, mode=\"<STR_LIT:replace>\", name=\"<STR_LIT:default>\", executor=None):", "body": "boolean_expression = _ensure_string_from_expression(boolean_expression)<EOL>if boolean_expression is None and not self.has_selection(name=name):<EOL><INDENT>pass  <EOL>self.signal_selection_changed.emit(self)  <EOL><DEDENT>else:<EOL><INDENT>def create(current):<EOL><INDENT>return selections.SelectionExpression(boolean_expression, current, mode) if boolean_expression else None<EOL><DEDENT>self._selection(create, name)<EOL><DEDENT>", "docstring": "Perform a selection, defined by the boolean expression, and combined with the previous selection using the given mode.\n\n        Selections are recorded in a history tree, per name, undo/redo can be done for them separately.\n\n        :param str boolean_expression: Any valid column expression, with comparison operators\n        :param str mode: Possible boolean operator: replace/and/or/xor/subtract\n        :param str name: history tree or selection 'slot' to use\n        :param executor:\n        :return:", "id": "f6914:c0:m176"}
{"signature": "def describe(self, strings=True, virtual=True, selection=None):", "body": "import pandas as pd<EOL>N = len(self)<EOL>columns = {}<EOL>for feature in self.get_column_names(strings=strings, virtual=virtual)[:]:<EOL><INDENT>dtype = str(self.dtype(feature)) if self.dtype(feature) != str else '<STR_LIT:str>'<EOL>if self.dtype(feature) == str_type or self.dtype(feature).kind in ['<STR_LIT:S>', '<STR_LIT>', '<STR_LIT:O>']:<EOL><INDENT>count = self.count(feature, selection=selection, delay=True)<EOL>self.execute()<EOL>count = count.get()<EOL>columns[feature] = ((dtype, count, N-count, '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'))<EOL><DEDENT>else:<EOL><INDENT>count = self.count(feature, selection=selection, delay=True)<EOL>mean = self.mean(feature, selection=selection, delay=True)<EOL>std = self.std(feature, selection=selection, delay=True)<EOL>minmax = self.minmax(feature, selection=selection, delay=True)<EOL>self.execute()<EOL>count, mean, std, minmax = count.get(), mean.get(), std.get(), minmax.get()<EOL>count = int(count)<EOL>columns[feature] = ((dtype, count, N-count, mean, std, minmax[<NUM_LIT:0>], minmax[<NUM_LIT:1>]))<EOL><DEDENT><DEDENT>return pd.DataFrame(data=columns, index=['<STR_LIT>', '<STR_LIT:count>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>", "docstring": "Give a description of the DataFrame.\n\n        >>> import vaex\n        >>> df = vaex.example()[['x', 'y', 'z']]\n        >>> df.describe()\n                         x          y          z\n        dtype      float64    float64    float64\n        count       330000     330000     330000\n        missing          0          0          0\n        mean    -0.0671315 -0.0535899  0.0169582\n        std        7.31746    7.78605    5.05521\n        min       -128.294   -71.5524   -44.3342\n        max        271.366    146.466    50.7185\n        >>> df.describe(selection=df.x > 0)\n                           x         y          z\n        dtype        float64   float64    float64\n        count         164060    164060     164060\n        missing       165940    165940     165940\n        mean         5.13572 -0.486786 -0.0868073\n        std          5.18701   7.61621    5.02831\n        min      1.51635e-05  -71.5524   -44.3342\n        max          271.366   78.0724    40.2191\n\n        :param bool strings: Describe string columns or not\n        :param bool virtual: Describe virtual columns or not\n        :param selection: Optional selection to use.\n        :return: Pandas dataframe", "id": "f6914:c0:m137"}
{"signature": "def set_active_range(self, i1, i2):", "body": "logger.debug(\"<STR_LIT>\", (i1, i2))<EOL>self._active_fraction = (i2 - i1) / float(self.length_original())<EOL>self._index_start = i1<EOL>self._index_end = i2<EOL>self.select(None)<EOL>self.set_current_row(None)<EOL>self._length_unfiltered = i2 - i1<EOL>self.signal_active_fraction_changed.emit(self, self._active_fraction)<EOL>", "docstring": "Sets the active_fraction, set picked row to None, and remove selection.\n\n        TODO: we may be able to keep the selection, if we keep the expression, and also the picked row", "id": "f6914:c0:m161"}
{"signature": "@docsubst<EOL><INDENT>@stat_1d<EOL>def mean(self, expression, binby=[], limits=None, shape=default_shape, selection=False, delay=False, progress=None, edges=False):<DEDENT>", "body": "return self._compute_agg('<STR_LIT>', expression, binby, limits, shape, selection, delay, edges, progress)<EOL>logger.debug(\"<STR_LIT>\", expression, binby, limits, shape, selection, delay)<EOL>expression = _ensure_strings_from_expressions(expression)<EOL>selection = _ensure_strings_from_expressions(selection)<EOL>binby = _ensure_strings_from_expressions(binby)<EOL>@delayed<EOL>def calculate(expression, limits):<EOL><INDENT>task = tasks.TaskStatistic(self, binby, shape, limits, weight=expression, op=tasks.OP_ADD_WEIGHT_MOMENTS_01, selection=selection)<EOL>self.executor.schedule(task)<EOL>progressbar.add_task(task, \"<STR_LIT>\" % expression)<EOL>return task<EOL><DEDENT>@delayed<EOL>def finish(*stats_args):<EOL><INDENT>stats = np.array(stats_args)<EOL>counts = stats[..., <NUM_LIT:0>]<EOL>with np.errstate(divide='<STR_LIT:ignore>', invalid='<STR_LIT:ignore>'):<EOL><INDENT>mean = stats[..., <NUM_LIT:1>] / counts<EOL><DEDENT>return vaex.utils.unlistify(waslist, mean)<EOL><DEDENT>waslist, [expressions, ] = vaex.utils.listify(expression)<EOL>progressbar = vaex.utils.progressbars(progress)<EOL>limits = self.limits(binby, limits, delay=True)<EOL>stats = [calculate(expression, limits) for expression in expressions]<EOL>var = finish(*stats)<EOL>return self._delay(delay, var)<EOL>", "docstring": "Calculate the mean for expression, possibly on a grid defined by binby.\n\n        Example:\n\n        >>> df.mean(\"x\")\n        -0.067131491264005971\n        >>> df.mean(\"(x**2+y**2)**0.5\", binby=\"E\", shape=4)\n        array([  2.43483742,   4.41840721,   8.26742458,  15.53846476])\n\n        :param expression: {expression}\n        :param binby: {binby}\n        :param limits: {limits}\n        :param shape: {shape}\n        :param selection: {selection}\n        :param delay: {delay}\n        :param progress: {progress}\n        :return: {return_stat_scalar}", "id": "f6914:c0:m28"}
{"signature": "def ordinal_encode(self, column, values=None, inplace=False):", "body": "column = _ensure_string_from_expression(column)<EOL>df = self if inplace else self.copy()<EOL>df_unfiltered = df.copy()<EOL>df_unfiltered.select_nothing(name=FILTER_SELECTION_NAME)<EOL>df_unfiltered._length_unfiltered = df._length_original<EOL>df_unfiltered.set_active_range(<NUM_LIT:0>, df._length_original)<EOL>found_values, codes = df_unfiltered.unique(column, return_inverse=True)<EOL>if values is None:<EOL><INDENT>values = found_values<EOL><DEDENT>else:<EOL><INDENT>translation = np.zeros(len(found_values), dtype=np.uint64)<EOL>missing_value = len(found_values)<EOL>for i, found_value in enumerate(found_values):<EOL><INDENT>try:<EOL><INDENT>found_value = found_value.decode('<STR_LIT:ascii>')<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>if found_value not in values:  <EOL><INDENT>translation[i] = missing_value<EOL><DEDENT>else:<EOL><INDENT>translation[i] = values.index(found_value)<EOL><DEDENT><DEDENT>codes = translation[codes]<EOL>if missing_value in translation:<EOL><INDENT>codes = np.ma.masked_array(codes, codes==missing_value)<EOL><DEDENT><DEDENT>original_column = df.rename_column(column, '<STR_LIT>' + column, unique=True)<EOL>labels = [str(k) for k in values]<EOL>df.add_column(column, codes)<EOL>df._categories[column] = dict(labels=labels, N=len(values), values=values)<EOL>return df<EOL>", "docstring": "Encode column as ordinal values and mark it as categorical.\n\n        The existing column is renamed to a hidden column and replaced by a numerical columns\n        with values between [0, len(values)-1].", "id": "f6914:c1:m3"}
{"signature": "def state_load(self, f, use_active_range=False):", "body": "state = vaex.utils.read_json_or_yaml(f)<EOL>self.state_set(state, use_active_range=use_active_range)<EOL>", "docstring": "Load a state previously stored by :meth:`DataFrame.state_store`, see also :meth:`DataFrame.state_set`.", "id": "f6914:c0:m72"}
{"signature": "@register<EOL>def mean(expression):", "body": "return AggregatorDescriptorMean('<STR_LIT>', expression, '<STR_LIT>')<EOL>", "docstring": "Creates a mean aggregation", "id": "f6916:m3"}
{"signature": "@register<EOL>def sum(expression):", "body": "return AggregatorDescriptorBasic('<STR_LIT>', expression, '<STR_LIT>')<EOL>", "docstring": "Creates a sum aggregation", "id": "f6916:m2"}
{"signature": "def iter_properties(fh, comments=False):", "body": "for line in _property_lines(fh):<EOL><INDENT>key, value = _split_key_value(line)<EOL>if key is not COMMENT:<EOL><INDENT>key = _unescape(key)<EOL><DEDENT>elif not comments:<EOL><INDENT>continue<EOL><DEDENT>yield key, _unescape(value)<EOL><DEDENT>", "docstring": "Incrementally read properties from a Java .properties file.\n\nYields tuples of key/value pairs.\n\nIf ``comments`` is `True`, comments will be included with ``jprops.COMMENT``\nin place of the key.\n\n:param fh: a readable file-like object\n:param comments: should include comments (default: False)", "id": "f6925:m5"}
{"signature": "def _graphviz(self, dot=None):", "body": "from graphviz import Graph, Digraph<EOL>node = self._graph()<EOL>dot = dot or Digraph(comment=self.expression)<EOL>def walk(node):<EOL><INDENT>if isinstance(node, six.string_types):<EOL><INDENT>dot.node(node, node)<EOL>return node, node<EOL><DEDENT>else:<EOL><INDENT>node_repr, fname, fobj, deps = node<EOL>node_id = node_repr<EOL>dot.node(node_id, node_repr)<EOL>for dep in deps:<EOL><INDENT>dep_id, dep = walk(dep)<EOL>dot.edge(node_id, dep_id)<EOL><DEDENT>return node_id, node<EOL><DEDENT><DEDENT>walk(node)<EOL>return dot<EOL>", "docstring": "Return a graphviz.Digraph object with a graph of the expression", "id": "f6960:c4:m10"}
{"signature": "def __call__(self, *args, **kwargs):", "body": "return self.f(*args, **kwargs)<EOL>", "docstring": "Forward the call to the real function", "id": "f6960:c6:m6"}
{"signature": "def sum(self, binby=[], limits=None, shape=default_shape, selection=False, delay=False, progress=None):", "body": "kwargs = dict(locals())<EOL>del kwargs['<STR_LIT>']<EOL>kwargs['<STR_LIT>'] = self.expression<EOL>return self.ds.sum(**kwargs)<EOL>", "docstring": "Shortcut for ds.sum(expression, ...), see `Dataset.sum`", "id": "f6960:c4:m16"}
{"signature": "@property<EOL><INDENT>def masked(self):<DEDENT>", "body": "return self.ds.is_masked(self.expression)<EOL>", "docstring": "Alias to df.is_masked(expression)", "id": "f6960:c4:m25"}
{"signature": "def var(self, binby=[], limits=None, shape=default_shape, selection=False, delay=False, progress=None):", "body": "kwargs = dict(locals())<EOL>del kwargs['<STR_LIT>']<EOL>kwargs['<STR_LIT>'] = self.expression<EOL>return self.ds.var(**kwargs)<EOL>", "docstring": "Shortcut for ds.std(expression, ...), see `Dataset.var`", "id": "f6960:c4:m19"}
{"signature": "def mean(self, binby=[], limits=None, shape=default_shape, selection=False, delay=False, progress=None):", "body": "kwargs = dict(locals())<EOL>del kwargs['<STR_LIT>']<EOL>kwargs['<STR_LIT>'] = self.expression<EOL>return self.ds.mean(**kwargs)<EOL>", "docstring": "Shortcut for ds.mean(expression, ...), see `Dataset.mean`", "id": "f6960:c4:m17"}
{"signature": "@property<EOL><INDENT>def str(self):<DEDENT>", "body": "return StringOperations(self)<EOL>", "docstring": "Gives access to string operations", "id": "f6960:c4:m2"}
{"signature": "def std(self, binby=[], limits=None, shape=default_shape, selection=False, delay=False, progress=None):", "body": "kwargs = dict(locals())<EOL>del kwargs['<STR_LIT>']<EOL>kwargs['<STR_LIT>'] = self.expression<EOL>return self.ds.std(**kwargs)<EOL>", "docstring": "Shortcut for ds.std(expression, ...), see `Dataset.std`", "id": "f6960:c4:m18"}
{"signature": "@register_function(scope='<STR_LIT:str>')<EOL>def str_rindex(x, sub, start=<NUM_LIT:0>, end=None):", "body": "return str_rfind(x, sub, start, end)<EOL>", "docstring": "Returns the highest indices in each string in a column, where the provided substring is fully contained between within a\n    sample. If the substring is not found, -1 is returned. Same as `str.rfind`.\n\n    :param str sub: A substring to be found in the samples\n    :param int start:\n    :param int end:\n    :returns: an expression containing the highest indices specifying the start of the substring.\n\n    Example:\n\n    >>> import vaex\n    >>> text = ['Something', 'very pretty', 'is coming', 'our', 'way.']\n    >>> df = vaex.from_arrays(text=text)\n    >>> df\n      #  text\n      0  Something\n      1  very pretty\n      2  is coming\n      3  our\n      4  way.\n\n    >>> df.text.str.rindex(sub=\"et\")\n    Expression = str_rindex(text, sub='et')\n    Length: 5 dtype: int64 (expression)\n    -----------------------------------\n    0   3\n    1   7\n    2  -1\n    3  -1\n    4  -1", "id": "f6962:m35"}
{"signature": "@register_function(scope='<STR_LIT>', as_property=True)<EOL>def dt_month_name(x):", "body": "import pandas as pd<EOL>return pd.Series(_pandas_dt_fix(x)).dt.month_name().values.astype(str)<EOL>", "docstring": "Returns the month names of a datetime sample in English.\n\n    :returns: an expression containing the month names extracted from a datetime column.\n\n    Example:\n\n    >>> import vaex\n    >>> import numpy as np\n    >>> date = np.array(['2009-10-12T03:31:00', '2016-02-11T10:17:34', '2015-11-12T11:34:22'], dtype=np.datetime64)\n    >>> df = vaex.from_arrays(date=date)\n    >>> df\n      #  date\n      0  2009-10-12 03:31:00\n      1  2016-02-11 10:17:34\n      2  2015-11-12 11:34:22\n\n    >>> df.date.dt.month_name\n    Expression = dt_month_name(date)\n    Length: 3 dtype: str (expression)\n    ---------------------------------\n    0   October\n    1  February\n    2  November", "id": "f6962:m8"}
{"signature": "@register_function(scope='<STR_LIT>', as_property=True)<EOL>def dt_weekofyear(x):", "body": "import pandas as pd<EOL>return pd.Series(x).dt.weekofyear.values<EOL>", "docstring": "Returns the week ordinal of the year.\n\n    :returns: an expression containing the week ordinal of the year, extracted from a datetime column.\n\n    Example:\n\n    >>> import vaex\n    >>> import numpy as np\n    >>> date = np.array(['2009-10-12T03:31:00', '2016-02-11T10:17:34', '2015-11-12T11:34:22'], dtype=np.datetime64)\n    >>> df = vaex.from_arrays(date=date)\n    >>> df\n      #  date\n      0  2009-10-12 03:31:00\n      1  2016-02-11 10:17:34\n      2  2015-11-12 11:34:22\n\n    >>> df.date.dt.weekofyear\n    Expression = dt_weekofyear(date)\n    Length: 3 dtype: int64 (expression)\n    -----------------------------------\n    0  42\n    1   6\n    2  46", "id": "f6962:m11"}
{"signature": "@register_function(scope='<STR_LIT:str>')<EOL>def str_index(x, sub, start=<NUM_LIT:0>, end=None):", "body": "return str_find(x, sub, start, end)<EOL>", "docstring": "Returns the lowest indices in each string in a column, where the provided substring is fully contained between within a\n    sample. If the substring is not found, -1 is returned. It is the same as `str.find`.\n\n    :param str sub: A substring to be found in the samples\n    :param int start:\n    :param int end:\n    :returns: an expression containing the lowest indices specifying the start of the substring.\n\n    Example:\n\n    >>> import vaex\n    >>> text = ['Something', 'very pretty', 'is coming', 'our', 'way.']\n    >>> df = vaex.from_arrays(text=text)\n    >>> df\n      #  text\n      0  Something\n      1  very pretty\n      2  is coming\n      3  our\n      4  way.\n\n    >>> df.text.str.index(sub=\"et\")\n    Expression = str_find(text, sub='et')\n    Length: 5 dtype: int64 (expression)\n    -----------------------------------\n    0   3\n    1   7\n    2  -1\n    3  -1\n    4  -1", "id": "f6962:m23"}
{"signature": "@register_function(scope='<STR_LIT:str>')<EOL>def str_repeat(x, repeats):", "body": "sl = _to_string_sequence(x).repeat(repeats)<EOL>return column.ColumnStringArrow(sl.bytes, sl.indices, sl.length, sl.offset, string_sequence=sl)<EOL>", "docstring": "Duplicate each string in a column.\n\n    :param int repeats: number of times each string sample is to be duplicated.\n    :returns: an expression containing the duplicated strings\n\n    Example:\n\n    >>> import vaex\n    >>> text = ['Something', 'very pretty', 'is coming', 'our', 'way.']\n    >>> df = vaex.from_arrays(text=text)\n    >>> df\n      #  text\n      0  Something\n      1  very pretty\n      2  is coming\n      3  our\n      4  way.\n\n    >>> df.text.str.repeat(3)\n    Expression = str_repeat(text, 3)\n    Length: 5 dtype: str (expression)\n    ---------------------------------\n    0        SomethingSomethingSomething\n    1  very prettyvery prettyvery pretty\n    2        is comingis comingis coming\n    3                          ourourour\n    4                       way.way.way.", "id": "f6962:m32"}
{"signature": "@register_function(scope='<STR_LIT:str>')<EOL>def str_rstrip(x, to_strip=None):", "body": "<EOL>sl = _to_string_sequence(x).rstrip('<STR_LIT>' if to_strip is None else to_strip) if to_strip != '<STR_LIT>' else x<EOL>return column.ColumnStringArrow(sl.bytes, sl.indices, sl.length, sl.offset, string_sequence=sl)<EOL>", "docstring": "Remove trailing characters from a string sample.\n\n    :param str to_strip: The string to be removed\n    :returns: an expression containing the modified string column.\n\n    Example:\n\n    >>> import vaex\n    >>> text = ['Something', 'very pretty', 'is coming', 'our', 'way.']\n    >>> df = vaex.from_arrays(text=text)\n    >>> df\n      #  text\n      0  Something\n      1  very pretty\n      2  is coming\n      3  our\n      4  way.\n\n    >>> df.text.str.rstrip(to_strip='ing')\n    Expression = str_rstrip(text, to_strip='ing')\n    Length: 5 dtype: str (expression)\n    ---------------------------------\n    0       Someth\n    1  very pretty\n    2       is com\n    3          our\n    4         way.", "id": "f6962:m37"}
{"signature": "@register_function(scope='<STR_LIT>', as_property=True)<EOL>def dt_is_leap_year(x):", "body": "import pandas as pd<EOL>return pd.Series(x).dt.is_leap_year.values<EOL>", "docstring": "Check whether a year is a leap year.\n\n    :returns: an expression which evaluates to True if a year is a leap year, and to False otherwise.\n\n    Example:\n\n    >>> import vaex\n    >>> import numpy as np\n    >>> date = np.array(['2009-10-12T03:31:00', '2016-02-11T10:17:34', '2015-11-12T11:34:22'], dtype=np.datetime64)\n    >>> df = vaex.from_arrays(date=date)\n    >>> df\n      #  date\n      0  2009-10-12 03:31:00\n      1  2016-02-11 10:17:34\n      2  2015-11-12 11:34:22\n\n    >>> df.date.dt.is_leap_year\n    Expression = dt_is_leap_year(date)\n    Length: 3 dtype: bool (expression)\n    ----------------------------------\n    0  False\n    1   True\n    2  False", "id": "f6962:m5"}
{"signature": "@register_function(scope='<STR_LIT:str>')<EOL>def str_title(x):", "body": "sl = _to_string_sequence(x).title()<EOL>return column.ColumnStringArrow(sl.bytes, sl.indices, sl.length, sl.offset, string_sequence=sl)<EOL>", "docstring": "Converts all string samples to titlecase.\n\n    :returns: an expression containing the converted strings.\n\n    Example:\n\n    >>> import vaex\n    >>> text = ['Something', 'very pretty', 'is coming', 'our', 'way.']\n    >>> df = vaex.from_arrays(text=text)\n    >>> df\n      #  text\n      0  Something\n      1  very pretty\n      2  is coming\n      3  our\n      4  way.\n\n    >>> df.text.str.title()\n    Expression = str_title(text)\n    Length: 5 dtype: str (expression)\n    ---------------------------------\n    0    Something\n    1  Very Pretty\n    2    Is Coming\n    3          Our\n    4         Way.", "id": "f6962:m42"}
{"signature": "@register_function(scope='<STR_LIT:str>')<EOL>def str_center(x, width, fillchar='<STR_LIT:U+0020>'):", "body": "sl = _to_string_sequence(x).pad(width, fillchar, True, True)<EOL>return column.ColumnStringArrow(sl.bytes, sl.indices, sl.length, sl.offset, string_sequence=sl)<EOL>", "docstring": "Fills the left and right side of the strings with additional characters, such that the sample has a total of `width`\n    characters.\n\n    :param int width: The total number of characters of the resulting string sample.\n    :param str fillchar: The character used for filling.\n    :returns: an expression containing the filled strings.\n\n    Example:\n    >>> import vaex\n    >>> text = ['Something', 'very pretty', 'is coming', 'our', 'way.']\n    >>> df = vaex.from_arrays(text=text)\n    >>> df\n      #  text\n      0  Something\n      1  very pretty\n      2  is coming\n      3  our\n      4  way.\n\n    >>> df.text.str.center(width=11, fillchar='!')\n    Expression = str_center(text, width=11, fillchar='!')\n    Length: 5 dtype: str (expression)\n    ---------------------------------\n    0  !Something!\n    1  very pretty\n    2  !is coming!\n    3  !!!!our!!!!\n    4  !!!!way.!!!", "id": "f6962:m17"}
{"signature": "@register_function(scope='<STR_LIT:str>')<EOL>def str_rjust(x, width, fillchar='<STR_LIT:U+0020>'):", "body": "sl = _to_string_sequence(x).pad(width, fillchar, True, False)<EOL>return column.ColumnStringArrow(sl.bytes, sl.indices, sl.length, sl.offset, string_sequence=sl)<EOL>", "docstring": "Fills the left side of string samples with a specified character such that the strings are left-hand justified.\n\n    :param int width: The minimal width of the strings.\n    :param str fillchar: The character used for filling.\n    :returns: an expression containing the filled strings.\n\n    Example:\n\n    >>> import vaex\n    >>> text = ['Something', 'very pretty', 'is coming', 'our', 'way.']\n    >>> df = vaex.from_arrays(text=text)\n    >>> df\n      #  text\n      0  Something\n      1  very pretty\n      2  is coming\n      3  our\n      4  way.\n\n    >>> df.text.str.rjust(width=10, fillchar='!')\n    Expression = str_rjust(text, width=10, fillchar='!')\n    Length: 5 dtype: str (expression)\n    ---------------------------------\n    0   !Something\n    1  very pretty\n    2   !is coming\n    3   !!!!!!!our\n    4   !!!!!!way.", "id": "f6962:m36"}
{"signature": "@register_function(scope='<STR_LIT>', as_property=True)<EOL>def dt_hour(x):", "body": "import pandas as pd<EOL>return pd.Series(x).dt.hour.values<EOL>", "docstring": "Extracts the hour out of a datetime samples.\n\n    :returns: an expression containing the hour extracted from a datetime column.\n\n    Example:\n\n    >>> import vaex\n    >>> import numpy as np\n    >>> date = np.array(['2009-10-12T03:31:00', '2016-02-11T10:17:34', '2015-11-12T11:34:22'], dtype=np.datetime64)\n    >>> df = vaex.from_arrays(date=date)\n    >>> df\n      #  date\n      0  2009-10-12 03:31:00\n      1  2016-02-11 10:17:34\n      2  2015-11-12 11:34:22\n\n    >>> df.date.dt.hour\n    Expression = dt_hour(date)\n    Length: 3 dtype: int64 (expression)\n    -----------------------------------\n    0   3\n    1  10\n    2  11", "id": "f6962:m12"}
{"signature": "@register_function(scope='<STR_LIT:str>')<EOL>def str_contains(x, pattern, regex=True):", "body": "return _to_string_sequence(x).search(pattern, regex)<EOL>", "docstring": "Check if a string pattern or regex is contained within a sample of a string column.\n\n    :param str pattern: A string or regex pattern\n    :param bool regex: If True,\n    :returns: an expression which is evaluated to True if the pattern is found in a given sample, and it is False otherwise.\n\n    Example:\n\n    >>> import vaex\n    >>> text = ['Something', 'very pretty', 'is coming', 'our', 'way.']\n    >>> df = vaex.from_arrays(text=text)\n    >>> df\n      #  text\n      0  Something\n      1  very pretty\n      2  is coming\n      3  our\n      4  way.\n\n    >>> df.text.str.contains('very')\n    Expression = str_contains(text, 'very')\n    Length: 5 dtype: bool (expression)\n    ----------------------------------\n    0  False\n    1   True\n    2  False\n    3  False\n    4  False", "id": "f6962:m18"}
{"signature": "@register_function(scope='<STR_LIT:str>')<EOL>def str_capitalize(x):", "body": "sl = _to_string_sequence(x).capitalize()<EOL>return column.ColumnStringArrow(sl.bytes, sl.indices, sl.length, sl.offset, string_sequence=sl)<EOL>", "docstring": "Capitalize the first letter of a string sample.\n\n    :returns: an expression containing the capitalized strings.\n\n    Example:\n\n    >>> import vaex\n    >>> text = ['Something', 'very pretty', 'is coming', 'our', 'way.']\n    >>> df = vaex.from_arrays(text=text)\n    >>> df\n      #  text\n      0  Something\n      1  very pretty\n      2  is coming\n      3  our\n      4  way.\n\n    >>> df.text.str.capitalize()\n    Expression = str_capitalize(text)\n    Length: 5 dtype: str (expression)\n    ---------------------------------\n    0    Something\n    1  Very pretty\n    2    Is coming\n    3          Our\n    4         Way.", "id": "f6962:m15"}
{"signature": "@register_function(scope='<STR_LIT>', as_property=True)<EOL>def dt_dayofweek(x):", "body": "import pandas as pd<EOL>return pd.Series(x).dt.dayofweek.values<EOL>", "docstring": "Obtain the day of the week with Monday=0 and Sunday=6\n\n    :returns: an expression containing the day of week.\n\n    Example:\n\n    >>> import vaex\n    >>> import numpy as np\n    >>> date = np.array(['2009-10-12T03:31:00', '2016-02-11T10:17:34', '2015-11-12T11:34:22'], dtype=np.datetime64)\n    >>> df = vaex.from_arrays(date=date)\n    >>> df\n      #  date\n      0  2009-10-12 03:31:00\n      1  2016-02-11 10:17:34\n      2  2015-11-12 11:34:22\n\n    >>> df.date.dt.dayofweek\n    Expression = dt_dayofweek(date)\n    Length: 3 dtype: int64 (expression)\n    -----------------------------------\n    0  0\n    1  3\n    2  3", "id": "f6962:m3"}
{"signature": "@register_function(scope='<STR_LIT>', as_property=True)<EOL>def dt_day(x):", "body": "import pandas as pd<EOL>return pd.Series(x).dt.day.values<EOL>", "docstring": "Extracts the day from a datetime sample.\n\n    :returns: an expression containing the day extracted from a datetime column.\n\n    Example:\n\n    >>> import vaex\n    >>> import numpy as np\n    >>> date = np.array(['2009-10-12T03:31:00', '2016-02-11T10:17:34', '2015-11-12T11:34:22'], dtype=np.datetime64)\n    >>> df = vaex.from_arrays(date=date)\n    >>> df\n      #  date\n      0  2009-10-12 03:31:00\n      1  2016-02-11 10:17:34\n      2  2015-11-12 11:34:22\n\n    >>> df.date.dt.day\n    Expression = dt_day(date)\n    Length: 3 dtype: int64 (expression)\n    -----------------------------------\n    0  12\n    1  11\n    2  12", "id": "f6962:m9"}
{"signature": "@register_function(scope='<STR_LIT:str>')<EOL>def str_lower(x):", "body": "sl = _to_string_sequence(x).lower()<EOL>return column.ColumnStringArrow(sl.bytes, sl.indices, sl.length, sl.offset, string_sequence=sl)<EOL>", "docstring": "Converts string samples to lower case.\n\n    :returns: an expression containing the converted strings.\n\n    Example:\n\n    >>> import vaex\n    >>> text = ['Something', 'very pretty', 'is coming', 'our', 'way.']\n    >>> df = vaex.from_arrays(text=text)\n    >>> df\n      #  text\n      0  Something\n      1  very pretty\n      2  is coming\n      3  our\n      4  way.\n\n    >>> df.text.str.lower()\n    Expression = str_lower(text)\n    Length: 5 dtype: str (expression)\n    ---------------------------------\n    0    something\n    1  very pretty\n    2    is coming\n    3          our\n    4         way.", "id": "f6962:m28"}
{"signature": "@register_function(scope='<STR_LIT:str>')<EOL>def str_rfind(x, sub, start=<NUM_LIT:0>, end=None):", "body": "return _to_string_sequence(x).find(sub, start, <NUM_LIT:0> if end is None else end, end is None, False)<EOL>", "docstring": "Returns the highest indices in each string in a column, where the provided substring is fully contained between within a\n    sample. If the substring is not found, -1 is returned.\n\n    :param str sub: A substring to be found in the samples\n    :param int start:\n    :param int end:\n    :returns: an expression containing the highest indices specifying the start of the substring.\n\n    Example:\n\n    >>> import vaex\n    >>> text = ['Something', 'very pretty', 'is coming', 'our', 'way.']\n    >>> df = vaex.from_arrays(text=text)\n    >>> df\n      #  text\n      0  Something\n      1  very pretty\n      2  is coming\n      3  our\n      4  way.\n\n    >>> df.text.str.rfind(sub=\"et\")\n    Expression = str_rfind(text, sub='et')\n    Length: 5 dtype: int64 (expression)\n    -----------------------------------\n    0   3\n    1   7\n    2  -1\n    3  -1\n    4  -1", "id": "f6962:m34"}
{"signature": "def server(url, **kwargs):", "body": "from vaex.remote import ServerRest<EOL>url = urlparse(url)<EOL>if url.scheme == \"<STR_LIT>\":<EOL><INDENT>websocket = True<EOL><DEDENT>else:<EOL><INDENT>websocket = False<EOL><DEDENT>assert url.scheme in [\"<STR_LIT>\", \"<STR_LIT:http>\"]<EOL>port = url.port<EOL>base_path = url.path<EOL>hostname = url.hostname<EOL>return vaex.remote.ServerRest(hostname, base_path=base_path, port=port, websocket=websocket, **kwargs)<EOL>", "docstring": "Connect to hostname supporting the vaex web api.\n\n    :param str hostname: hostname or ip address of server\n    :return vaex.dataframe.ServerRest: returns a server object, note that it does not connect to the server yet, so this will always succeed\n    :rtype: ServerRest", "id": "f6963:m16"}
{"signature": "def read_csv_and_convert(path, shuffle=False, copy_index=True, **kwargs):", "body": "from concurrent.futures import ProcessPoolExecutor<EOL>import pandas as pd<EOL>filenames = glob.glob(path)<EOL>if len(filenames) > <NUM_LIT:1>:<EOL><INDENT>filename_hdf5 = _convert_name(filenames, shuffle=shuffle)<EOL>filename_hdf5_noshuffle = _convert_name(filenames, shuffle=False)<EOL>if not os.path.exists(filename_hdf5):<EOL><INDENT>if not os.path.exists(filename_hdf5_noshuffle):<EOL><INDENT>for filename in filenames:<EOL><INDENT>read_csv_and_convert(filename, shuffle=shuffle, copy_index=copy_index, **kwargs)<EOL><DEDENT>ds = open_many([_convert_name(k, shuffle=shuffle) for k in filenames])<EOL><DEDENT>else:<EOL><INDENT>ds = open(filename_hdf5_noshuffle)<EOL><DEDENT>ds.export_hdf5(filename_hdf5, shuffle=shuffle)<EOL><DEDENT>return open(filename_hdf5)<EOL><DEDENT>else:<EOL><INDENT>filename = filenames[<NUM_LIT:0>]<EOL>filename_hdf5 = _convert_name(filename, shuffle=shuffle)<EOL>filename_hdf5_noshuffle = _convert_name(filename, shuffle=False)<EOL>if not os.path.exists(filename_hdf5):<EOL><INDENT>if not os.path.exists(filename_hdf5_noshuffle):<EOL><INDENT>df = pd.read_csv(filename, **kwargs)<EOL>ds = from_pandas(df, copy_index=copy_index)<EOL><DEDENT>else:<EOL><INDENT>ds = open(filename_hdf5_noshuffle)<EOL><DEDENT>ds.export_hdf5(filename_hdf5, shuffle=shuffle)<EOL><DEDENT>return open(filename_hdf5)<EOL><DEDENT>", "docstring": "Convert a path (or glob pattern) to a single hdf5 file, will open the hdf5 file if exists.\n\n    Example:\n            >>> vaex.read_csv_and_convert('test-*.csv', shuffle=True)  # this may take a while\n            >>> vaex.read_csv_and_convert('test-*.csv', shuffle=True)  # 2nd time it is instant\n\n    :param str path: path of file or glob pattern for multiple files\n    :param bool shuffle: shuffle DataFrame when converting to hdf5\n    :param bool copy_index: by default pandas will create an index (row number), set to false if you want to drop that\n    :param kwargs: parameters passed to pandas' read_cvs", "id": "f6963:m15"}
{"signature": "def concat(dfs):", "body": "ds = reduce((lambda x, y: x.concat(y)), dfs)<EOL>return ds<EOL>", "docstring": "Concatenate a list of DataFrames.\n\n    :rtype: DataFrame", "id": "f6963:m24"}
{"signature": "def from_dict(data):", "body": "return vaex.from_arrays(**data)<EOL>", "docstring": "Create an in memory dataset from a dict with column names as keys and list/numpy-arrays as values\n\n    Example\n\n    >>> data = {'A':[1,2,3],'B':['a','b','c']}\n    >>> vaex.from_dict(data)\n      #    A    B\n      0    1   'a'\n      1    2   'b'\n      2    3   'c'\n\n    :param data: A dict of {columns:[value, value,...]}\n    :rtype: DataFrame", "id": "f6963:m6"}
{"signature": "def from_astropy_table(table):", "body": "import vaex.file.other<EOL>return vaex.file.other.DatasetAstropyTable(table=table)<EOL>", "docstring": "Create a vaex DataFrame from an Astropy Table.", "id": "f6963:m5"}
{"signature": "def from_samp(username=None, password=None):", "body": "print(\"<STR_LIT>\")<EOL>import vaex.samp<EOL>t = vaex.samp.single_table(username=username, password=password)<EOL>return from_astropy_table(t.to_table())<EOL>", "docstring": "Connect to a SAMP Hub and wait for a single table load event, disconnect, download the table and return the DataFrame.\n\n    Useful if you want to send a single table from say TOPCAT to vaex in a python console or notebook.", "id": "f6963:m4"}
{"signature": "def open(path, convert=False, shuffle=False, copy_index=True, *args, **kwargs):", "body": "import vaex<EOL>try:<EOL><INDENT>if path in aliases:<EOL><INDENT>path = aliases[path]<EOL><DEDENT>if path.startswith(\"<STR_LIT>\") or path.startswith(\"<STR_LIT>\"):  <EOL><INDENT>server, DataFrame = path.rsplit(\"<STR_LIT:/>\", <NUM_LIT:1>)<EOL>server = vaex.server(server, **kwargs)<EOL>DataFrames = server.DataFrames(as_dict=True)<EOL>if DataFrame not in DataFrames:<EOL><INDENT>raise KeyError(\"<STR_LIT>\" % (DataFrame, \"<STR_LIT:U+0020>\".join(DataFrames.keys())))<EOL><DEDENT>return DataFrames[DataFrame]<EOL><DEDENT>if path.startswith(\"<STR_LIT>\"):<EOL><INDENT>import vaex.distributed<EOL>return vaex.distributed.open(path, *args, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>import vaex.file<EOL>import glob<EOL>filenames = list(sorted(glob.glob(path)))<EOL>ds = None<EOL>if len(filenames) == <NUM_LIT:0>:<EOL><INDENT>raise IOError('<STR_LIT>'.format(path))<EOL><DEDENT>filename_hdf5 = _convert_name(filenames, shuffle=shuffle)<EOL>filename_hdf5_noshuffle = _convert_name(filenames, shuffle=False)<EOL>if len(filenames) == <NUM_LIT:1>:<EOL><INDENT>path = filenames[<NUM_LIT:0>]<EOL>ext = os.path.splitext(path)[<NUM_LIT:1>]<EOL>if os.path.exists(filename_hdf5) and convert:  <EOL><INDENT>if convert:<EOL><INDENT>ds = vaex.file.open(filename_hdf5)<EOL><DEDENT>else:<EOL><INDENT>ds = vaex.file.open(filename_hdf5, *args, **kwargs)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if ext == '<STR_LIT>':  <EOL><INDENT>ds = from_csv(path, copy_index=copy_index, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>ds = vaex.file.open(path, *args, **kwargs)<EOL><DEDENT>if convert:<EOL><INDENT>ds.export_hdf5(filename_hdf5, shuffle=shuffle)<EOL>ds = vaex.file.open(filename_hdf5) <EOL><DEDENT><DEDENT>if ds is None:<EOL><INDENT>if os.path.exists(path):<EOL><INDENT>raise IOError('<STR_LIT>'.format(path))<EOL><DEDENT>if os.path.exists(path):<EOL><INDENT>raise IOError('<STR_LIT>'.format(path))<EOL><DEDENT><DEDENT><DEDENT>elif len(filenames) > <NUM_LIT:1>:<EOL><INDENT>if convert not in [True, False]:<EOL><INDENT>filename_hdf5 = convert<EOL><DEDENT>else:<EOL><INDENT>filename_hdf5 = _convert_name(filenames, shuffle=shuffle)<EOL><DEDENT>if os.path.exists(filename_hdf5) and convert:  <EOL><INDENT>ds = open(filename_hdf5)<EOL><DEDENT>else:<EOL><INDENT>DataFrames = []<EOL>for filename in filenames:<EOL><INDENT>DataFrames.append(open(filename, convert=bool(convert), shuffle=shuffle, **kwargs))<EOL><DEDENT>ds = vaex.dataframe.DataFrameConcatenated(DataFrames)<EOL><DEDENT>if convert:<EOL><INDENT>ds.export_hdf5(filename_hdf5, shuffle=shuffle)<EOL>ds = vaex.file.open(filename_hdf5, *args, **kwargs)<EOL><DEDENT><DEDENT><DEDENT>if ds is None:<EOL><INDENT>raise IOError('<STR_LIT>'.format(path))<EOL><DEDENT>return ds<EOL><DEDENT>except:<EOL><INDENT>logging.getLogger(\"<STR_LIT>\").error(\"<STR_LIT>\" % path)<EOL>raise<EOL><DEDENT>", "docstring": "Open a DataFrame from file given by path.\n\n    Example:\n\n    >>> ds = vaex.open('sometable.hdf5')\n    >>> ds = vaex.open('somedata*.csv', convert='bigdata.hdf5')\n\n    :param str path: local or absolute path to file, or glob string\n    :param convert: convert files to an hdf5 file for optimization, can also be a path\n    :param bool shuffle: shuffle converted DataFrame or not\n    :param args: extra arguments for file readers that need it\n    :param kwargs: extra keyword arguments\n    :param bool copy_index: copy index when source is read via pandas\n    :return: return a DataFrame on succes, otherwise None\n    :rtype: DataFrame", "id": "f6963:m2"}
{"signature": "def set_log_level_info():", "body": "import logging<EOL>logging.getLogger(\"<STR_LIT>\").setLevel(logging.INFO)<EOL>", "docstring": "set log level to info", "id": "f6963:m20"}
{"signature": "def open_many(filenames):", "body": "dfs = []<EOL>for filename in filenames:<EOL><INDENT>filename = filename.strip()<EOL>if filename and filename[<NUM_LIT:0>] != \"<STR_LIT:#>\":<EOL><INDENT>dfs.append(open(filename))<EOL><DEDENT><DEDENT>return vaex.dataframe.DataFrameConcatenated(dfs=dfs)<EOL>", "docstring": "Open a list of filenames, and return a DataFrame with all DataFrames cocatenated.\n\n    :param list[str] filenames: list of filenames/paths\n    :rtype: DataFrame", "id": "f6963:m3"}
{"signature": "def subdivide(length, parts=None, max_length=None):", "body": "if max_length:<EOL><INDENT>i1 = <NUM_LIT:0><EOL>done = False<EOL>while not done:<EOL><INDENT>i2 = min(length, i1 + max_length)<EOL>yield i1, i2<EOL>i1 = i2<EOL>if i1 == length:<EOL><INDENT>done = True<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>part_length = int(math.ceil(float(length) / parts))<EOL>for index in range(parts):<EOL><INDENT>i1, i2 = index * part_length, min(length, (index + <NUM_LIT:1>) * part_length)<EOL>yield i1, i2<EOL><DEDENT><DEDENT>", "docstring": "Generates a list with start end stop indices of length parts, [(0, length/parts), ..., (.., length)]", "id": "f6969:m1"}
{"signature": "def delayed(f):", "body": "def wrapped(*args, **kwargs):<EOL><INDENT>key_promise = list([(key, promisify(value)) for key, value in kwargs.items()])<EOL>arg_promises = list([promisify(value) for value in args])<EOL>kwarg_promises = list([promise for key, promise in key_promise])<EOL>promises = arg_promises + kwarg_promises<EOL>for promise in promises:<EOL><INDENT>def echo_error(exc, promise=promise):<EOL><INDENT>print(\"<STR_LIT>\", promise, \"<STR_LIT>\", exc)<EOL><DEDENT>def echo(value, promise=promise):<EOL><INDENT>print(\"<STR_LIT>\", repr(promise), \"<STR_LIT>\", value)<EOL><DEDENT><DEDENT>allarguments = aplus.listPromise(*promises)<EOL>def call(_):<EOL><INDENT>kwargs_real = {key: promise.get() for key, promise in key_promise}<EOL>args_real = list([promise.get() for promise in arg_promises])<EOL>return f(*args_real, **kwargs_real)<EOL><DEDENT>def error(exc):<EOL><INDENT>print(\"<STR_LIT:error>\", exc)<EOL>raise exc<EOL><DEDENT>return allarguments.then(call, error)<EOL><DEDENT>return wrapped<EOL>", "docstring": "Decorator to transparantly accept delayed computation.\n\n    Example:\n\n    >>> delayed_sum = ds.sum(ds.E, binby=ds.x, limits=limits,\n    >>>                   shape=4, delay=True)\n    >>> @vaex.delayed\n    >>> def total_sum(sums):\n    >>>     return sums.sum()\n    >>> sum_of_sums = total_sum(delayed_sum)\n    >>> ds.execute()\n    >>> sum_of_sums.get()\n    See the tutorial for a more complete example https://docs.vaex.io/en/latest/tutorial.html#Parallel-computations", "id": "f6972:m1"}
{"signature": "def plot(self, grid=None, size=<NUM_LIT>, limits=None, square=False, center=None, weight=None, weight_stat=\"<STR_LIT>\", figsize=None,<EOL>aspect=\"<STR_LIT>\", f=\"<STR_LIT>\", axes=None, xlabel=None, ylabel=None,<EOL>group_by=None, group_limits=None, group_colors='<STR_LIT>', group_labels=None, group_count=None,<EOL>vmin=None, vmax=None,<EOL>cmap=\"<STR_LIT>\",<EOL>**kwargs):", "body": "import pylab<EOL>f = _parse_f(f)<EOL>limits = self.limits(limits)<EOL>if limits is None:<EOL><INDENT>limits = self.limits_sigma()<EOL><DEDENT>if group_limits is None and group_by:<EOL><INDENT>group_limits = tuple(self.df(group_by).minmax()[<NUM_LIT:0>]) + (group_count,)<EOL><DEDENT>if figsize is not None:<EOL><INDENT>pylab.figure(num=None, figsize=figsize, dpi=<NUM_LIT>, facecolor='<STR_LIT:w>', edgecolor='<STR_LIT:k>')<EOL><DEDENT>if axes is None:<EOL><INDENT>axes = pylab.gca()<EOL><DEDENT>fig = pylab.gcf()<EOL>pylab.xlabel(xlabel or self.expressions[<NUM_LIT:0>])<EOL>pylab.ylabel(ylabel or self.expressions[<NUM_LIT:1>])<EOL>rgba8 = self.image_rgba(grid=grid, size=size, limits=limits, square=square, center=center, weight=weight, weight_stat=weight_stat,<EOL>f=f, axes=axes,<EOL>group_by=group_by, group_limits=group_limits, group_colors=group_colors, group_count=group_count,<EOL>vmin=vmin, vmax=vmax,<EOL>cmap=cmap)<EOL>import matplotlib<EOL>if group_by:<EOL><INDENT>if isinstance(group_colors, six.string_types):<EOL><INDENT>group_colors = matplotlib.cm.get_cmap(group_colors)<EOL><DEDENT>if isinstance(group_colors, matplotlib.colors.Colormap):<EOL><INDENT>group_count = group_limits[<NUM_LIT:2>]<EOL>colors = [group_colors(k / float(group_count - <NUM_LIT:1.>)) for k in range(group_count)]<EOL><DEDENT>else:<EOL><INDENT>colors = [matplotlib.colors.colorConverter.to_rgba(k) for k in group_colors]<EOL><DEDENT>colormap = matplotlib.colors.ListedColormap(colors)<EOL>gmin, gmax, group_count = group_limits  <EOL>delta = (gmax - gmin) / (group_count - <NUM_LIT:1.>)<EOL>norm = matplotlib.colors.Normalize(gmin - delta / <NUM_LIT:2>, gmax + delta / <NUM_LIT:2>)<EOL>sm = matplotlib.cm.ScalarMappable(norm, colormap)<EOL>sm.set_array(<NUM_LIT:1>)  <EOL>colorbar = fig.colorbar(sm)<EOL>if group_labels:<EOL><INDENT>colorbar.set_ticks(np.arange(gmin, gmax + delta / <NUM_LIT:2>, delta))<EOL>colorbar.set_ticklabels(group_labels)<EOL><DEDENT>else:<EOL><INDENT>colorbar.set_ticks(np.arange(gmin, gmax + delta / <NUM_LIT:2>, delta))<EOL>colorbar.set_ticklabels(map(lambda x: \"<STR_LIT>\" % x, np.arange(gmin, gmax + delta / <NUM_LIT:2>, delta)))<EOL><DEDENT>colorbar.ax.set_ylabel(group_by)<EOL>im = axes.imshow(rgba8, extent=np.array(limits).flatten(), origin=\"<STR_LIT>\", aspect=aspect, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>norm = matplotlib.colors.Normalize(<NUM_LIT:0>, <NUM_LIT>)<EOL>sm = matplotlib.cm.ScalarMappable(norm, cmap)<EOL>sm.set_array(<NUM_LIT:1>)  <EOL>colorbar = fig.colorbar(sm)<EOL>im = axes.imshow(rgba8, extent=np.array(limits).flatten(), origin=\"<STR_LIT>\", aspect=aspect, **kwargs)<EOL>colorbar = None<EOL><DEDENT>return im, colorbar<EOL>", "docstring": "Plot the subspace using sane defaults to get a quick look at the data.\n\n        :param grid: A 2d numpy array with the counts, if None it will be calculated using limits provided and Subspace.histogram\n        :param size: Passed to Subspace.histogram\n        :param limits: Limits for the subspace in the form [[xmin, xmax], [ymin, ymax]], if None it will be calculated using Subspace.limits_sigma\n        :param square: argument passed to Subspace.limits_sigma\n        :param Executor executor: responsible for executing the tasks\n        :param figsize: (x, y) tuple passed to pylab.figure for setting the figure size\n        :param aspect: Passed to matplotlib's axes.set_aspect\n        :param xlabel: String for label on x axis (may contain latex)\n        :param ylabel: Same for y axis\n        :param kwargs: extra argument passed to axes.imshow, useful for setting the colormap for instance, e.g. cmap='afmhot'\n        :return: matplotlib.image.AxesImage", "id": "f6974:c5:m15"}
{"signature": "def sum(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Return a sequence of [sum, ... , sum] corresponding to the sum of values of each expression in this subspace ignoring NaN.", "id": "f6974:c5:m26"}
{"signature": "def bounded_by_minmax(self):", "body": "bounds = self.minmax()<EOL>return SubspaceBounded(self, bounds)<EOL>", "docstring": "Returns a bounded subspace (SubspaceBounded) with limits given by Subspace.minmax()\n\n        :rtype: SubspaceBounded", "id": "f6974:c5:m21"}
{"signature": "def bounded_by_sigmas(self, sigmas=<NUM_LIT:3>, square=False):", "body": "bounds = self.limits_sigma(sigmas=sigmas, square=square)<EOL>return SubspaceBounded(self, bounds)<EOL>", "docstring": "Returns a bounded subspace (SubspaceBounded) with limits given by Subspace.limits_sigma()\n\n        :rtype: SubspaceBounded", "id": "f6974:c5:m22"}
{"signature": "def limits(self, value, square=False):", "body": "if isinstance(value, six.string_types):<EOL><INDENT>import re<EOL>match = re.match(r\"<STR_LIT>\", value)<EOL>if match is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>value, type = match.groups()<EOL>import ast<EOL>value = ast.literal_eval(value)<EOL>type = type.strip()<EOL>if type in [\"<STR_LIT:s>\", \"<STR_LIT>\"]:<EOL><INDENT>return self.limits_sigma(value)<EOL><DEDENT>elif type in [\"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>return self.limits_sigma(value, square=True)<EOL><DEDENT>elif type in [\"<STR_LIT:%>\", \"<STR_LIT>\"]:<EOL><INDENT>return self.limits_percentage(value)<EOL><DEDENT>elif type in [\"<STR_LIT:%s>\", \"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>return self.limits_percentage(value, square=True)<EOL><DEDENT><DEDENT><DEDENT>if value is None:<EOL><INDENT>return self.limits_percentage(square=square)<EOL><DEDENT>else:<EOL><INDENT>return value<EOL><DEDENT>", "docstring": "TODO: doc + server side implementation", "id": "f6974:c5:m12"}
{"signature": "def count(expression='<STR_LIT:*>'):", "body": "return _Statistic('<STR_LIT:count>', expression)<EOL>", "docstring": "Creates a count statistic", "id": "f6977:m0"}
{"signature": "@patch<EOL>def add_virtual_columns_cartesian_velocities_to_pmvr(self, x=\"<STR_LIT:x>\", y=\"<STR_LIT:y>\", z=\"<STR_LIT:z>\", vx=\"<STR_LIT>\", vy=\"<STR_LIT>\", vz=\"<STR_LIT>\", vr=\"<STR_LIT>\", pm_long=\"<STR_LIT>\", pm_lat=\"<STR_LIT>\", distance=None):", "body": "if distance is None:<EOL><INDENT>distance = \"<STR_LIT>\".format(**locals())<EOL><DEDENT>k = <NUM_LIT><EOL>self.add_variable(\"<STR_LIT:k>\", k, overwrite=False)<EOL>self.add_virtual_column(vr, \"<STR_LIT>\".format(**locals()))<EOL>self.add_virtual_column(pm_long, \"<STR_LIT>\".format(**locals()))<EOL>self.add_virtual_column(pm_lat, \"<STR_LIT>\".format(**locals()))<EOL>", "docstring": "Concert velocities from a cartesian system to proper motions and radial velocities\n\n    TODO: errors\n\n    :param x: name of x column (input)\n    :param y:         y\n    :param z:         z\n    :param vx:       vx\n    :param vy:       vy\n    :param vz:       vz\n    :param vr: name of the column for the radial velocity in the r direction (output)\n    :param pm_long: name of the column for the proper motion component in the longitude direction  (output)\n    :param pm_lat: name of the column for the proper motion component in the latitude direction, positive points to the north pole (output)\n    :param distance: Expression for distance, if not given defaults to sqrt(x**2+y**2+z**2), but if this column already exists, passing this expression may lead to a better performance\n    :return:", "id": "f6985:m5"}
{"signature": "def patch(f):", "body": "name = f.__name__<EOL>Dataset.__hidden__[name] = f<EOL>return f<EOL>", "docstring": "Adds method f to the Dataset class", "id": "f6985:m0"}
{"signature": "@patch<EOL>def add_virtual_columns_lbrvr_proper_motion2vcartesian(self, long_in=\"<STR_LIT:l>\", lat_in=\"<STR_LIT:b>\", distance=\"<STR_LIT>\", pm_long=\"<STR_LIT>\", pm_lat=\"<STR_LIT>\",<EOL>vr=\"<STR_LIT>\", vx=\"<STR_LIT>\", vy=\"<STR_LIT>\", vz=\"<STR_LIT>\",<EOL>center_v=(<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>),<EOL>propagate_uncertainties=False, radians=False):", "body": "k = <NUM_LIT><EOL>a, d, distance = self._expr(long_in, lat_in, distance)<EOL>pm_long, pm_lat, vr = self._expr(pm_long, pm_lat, vr)<EOL>if not radians:<EOL><INDENT>a = a * np.pi/<NUM_LIT><EOL>d = d * np.pi/<NUM_LIT><EOL><DEDENT>A = [[np.cos(a)*np.cos(d), -np.sin(a), -np.cos(a)*np.sin(d)],<EOL>[np.sin(a)*np.cos(d),  np.cos(a), -np.sin(a)*np.sin(d)],<EOL>[np.sin(d), d*<NUM_LIT:0>, np.cos(d)]]<EOL>self.add_virtual_columns_matrix3d(vr, k * pm_long * distance, k * pm_lat * distance, vx, vy, vz, A, translation=center_v)<EOL>if propagate_uncertainties:<EOL><INDENT>self.propagate_uncertainties([self[vx], self[vy], self[vz]])<EOL><DEDENT>", "docstring": "Convert radial velocity and galactic proper motions (and positions) to cartesian velocities wrt the center_v\n\n    Based on http://adsabs.harvard.edu/abs/1987AJ.....93..864J\n\n\n    :param long_in: Name/expression for galactic longitude\n    :param lat_in: Name/expression for galactic latitude\n    :param distance: Name/expression for heliocentric distance\n    :param pm_long: Name/expression for the galactic proper motion in latitude direction (pm_l*, so cosine(b) term should be included)\n    :param pm_lat: Name/expression for the galactic proper motion in longitude direction\n    :param vr: Name/expression for the radial velocity\n    :param vx: Output name for the cartesian velocity x-component\n    :param vy: Output name for the cartesian velocity y-component\n    :param vz: Output name for the cartesian velocity z-component\n    :param center_v: Extra motion that should be added, for instance lsr + motion of the sun wrt the galactic restframe\n    :param radians: input and output in radians (True), or degrees (False)\n    :return:", "id": "f6985:m8"}
{"signature": "def get_transform(self):", "body": "return self.get_patch_transform()<EOL>", "docstring": "Return the :class:`~matplotlib.transforms.Transform` applied\nto the :class:`Patch`.", "id": "f7001:c0:m4"}
{"signature": "def __init__(self, dataset, parent=None, *args):", "body": "QtCore.QAbstractTableModel.__init__(self, parent, *args)<EOL>self.dataset = dataset<EOL>self.row_count_start = <NUM_LIT:1><EOL>self.table_column_names = [\"<STR_LIT:Name>\", \"<STR_LIT>\", \"<STR_LIT>\"]<EOL>", "docstring": ":type dataset: Dataset", "id": "f7011:c0:m0"}
{"signature": "def __init__(self, parent, dataset, variables=False):", "body": "QtGui.QComboBox.__init__(self, parent)<EOL>self.identifiers = []<EOL>self.columns = dataset.get_column_names(virtual=True)<EOL>self.identifiers.extend(vaex.dataset.expression_namespace.keys())<EOL>self.identifiers.extend(self.columns)<EOL>if variables:<EOL><INDENT>self.identifiers.extend(list(dataset.variables.keys()))<EOL><DEDENT>self.addItems([\"<STR_LIT>\"] + self.columns)<EOL>self.setEditable(True)<EOL>lineEdit = self.lineEdit()<EOL>self.completer = IdentifierCompleter(lineEdit, self.identifiers)<EOL>lineEdit.setCompleter(self.completer)<EOL>", "docstring": ":param parent:\n:param Dataset dataset:", "id": "f7018:c7:m0"}
{"signature": "@property<EOL><INDENT>def vx(self):<DEDENT>", "body": "return self.state.vector_expressions[<NUM_LIT:0>]<EOL>", "docstring": "vector x expression", "id": "f7020:c2:m12"}
{"signature": "@property<EOL><INDENT>def zlim(self):<DEDENT>", "body": "return self.get_range(<NUM_LIT:2>)<EOL>", "docstring": "vector z expression", "id": "f7020:c2:m28"}
{"signature": "@property<EOL><INDENT>def statistic(self):<DEDENT>", "body": "return self.state.statistic<EOL>", "docstring": "vector z expression", "id": "f7020:c2:m18"}
{"signature": "def disconnect(self):", "body": "self.canvas.mpl_disconnect(self._cidmotion)<EOL>self.canvas.mpl_disconnect(self._ciddraw)<EOL>", "docstring": "disconnect events", "id": "f7025:c0:m2"}
{"signature": "def _wait(self):", "body": "logger.debug(\"<STR_LIT>\")<EOL>self._plot_event = threading.Event()<EOL>self.queue_update._wait()<EOL>self.queue_replot._wait()<EOL>self.queue_redraw._wait()<EOL>qt_app = QtCore.QCoreApplication.instance()<EOL>sleep = <NUM_LIT:10><EOL>while not self._plot_event.is_set():<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>qt_app.processEvents()<EOL>QtTest.QTest.qSleep(sleep)<EOL><DEDENT>logger.debug(\"<STR_LIT>\")<EOL>", "docstring": "Used for unittesting to make sure the plots are all done", "id": "f7025:c1:m20"}
{"signature": "def arrow_table_from_vaex_df(ds, column_names=None, selection=None, strings=True, virtual=False):", "body": "names = []<EOL>arrays = []<EOL>for name, array in ds.to_items(column_names=column_names, selection=selection, strings=strings, virtual=virtual):<EOL><INDENT>names.append(name)<EOL>arrays.append(arrow_array_from_numpy_array(array))<EOL><DEDENT>return pyarrow.Table.from_arrays(arrays, names)<EOL>", "docstring": "Implementation of Dataset.to_arrow_table", "id": "f7030:m4"}
{"signature": "def _export_table(dataset, column_names=None, byteorder=\"<STR_LIT:=>\", shuffle=False, selection=False, progress=None, virtual=True, sort=None, ascending=True):", "body": "column_names = column_names or dataset.get_column_names(virtual=virtual, strings=True)<EOL>for name in column_names:<EOL><INDENT>if name not in dataset.columns:<EOL><INDENT>warnings.warn('<STR_LIT>')<EOL><DEDENT><DEDENT>N = len(dataset) if not selection else dataset.selected_length(selection)<EOL>if N == <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if shuffle and sort:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if shuffle:<EOL><INDENT>random_index_column = \"<STR_LIT>\"<EOL>while random_index_column in dataset.get_column_names():<EOL><INDENT>random_index_column += \"<STR_LIT>\"<EOL><DEDENT><DEDENT>partial_shuffle = shuffle and len(dataset) != N<EOL>order_array = None<EOL>if partial_shuffle:<EOL><INDENT>shuffle_array_full = np.random.choice(len(dataset), len(dataset), replace=False)<EOL>shuffle_array = shuffle_array_full[shuffle_array_full < N]<EOL>del shuffle_array_full<EOL>order_array = shuffle_array<EOL><DEDENT>elif shuffle:<EOL><INDENT>shuffle_array = np.random.choice(N, N, replace=False)<EOL>order_array = shuffle_array<EOL><DEDENT>if sort:<EOL><INDENT>if selection:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>logger.info(\"<STR_LIT>\")<EOL>indices = np.argsort(dataset.evaluate(sort))<EOL>order_array = indices if ascending else indices[::-<NUM_LIT:1>]<EOL>logger.info(\"<STR_LIT>\")<EOL><DEDENT>if selection:<EOL><INDENT>full_mask = dataset.evaluate_selection_mask(selection)<EOL><DEDENT>else:<EOL><INDENT>full_mask = None<EOL><DEDENT>arrow_arrays = []<EOL>for column_name in column_names:<EOL><INDENT>mask = full_mask<EOL>if selection:<EOL><INDENT>values = dataset.evaluate(column_name, filtered=False)<EOL>values = values[mask]<EOL><DEDENT>else:<EOL><INDENT>values = dataset.evaluate(column_name)<EOL>if shuffle or sort:<EOL><INDENT>indices = order_array<EOL>values = values[indices]<EOL><DEDENT><DEDENT>arrow_arrays.append(arrow_array_from_numpy_array(values))<EOL><DEDENT>if shuffle:<EOL><INDENT>arrow_arrays.append(arrow_array_from_numpy_array(order_array))<EOL>column_names = column_names + [random_index_column]<EOL><DEDENT>table = pa.Table.from_arrays(arrow_arrays, column_names)<EOL>return table<EOL>", "docstring": ":param DatasetLocal dataset: dataset to export\n:param str path: path for file\n:param lis[str] column_names: list of column names to export or None for all columns\n:param str byteorder: = for native, < for little endian and > for big endian\n:param bool shuffle: export rows in random order\n:param bool selection: export selection or not\n:param progress: progress callback that gets a progress fraction as argument and should return True to continue,\n        or a default progress bar when progress=True\n:param: bool virtual: When True, export virtual columns\n:return:", "id": "f7031:m2"}
{"signature": "def _main(argv):", "body": "parser = argparse.ArgumentParser(<EOL>description=DESCRIPTION,<EOL>formatter_class=argparse.RawDescriptionHelpFormatter,<EOL>)<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>default=URL_BASE,<EOL>help='<STR_LIT>' % URL_BASE,<EOL>)<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>default=None,<EOL>help='<STR_LIT>',<EOL>)<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>default='<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>)<EOL>parser.add_argument('<STR_LIT>', '<STR_LIT>', help=\"<STR_LIT>\")<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>action='<STR_LIT:store_true>',<EOL>help='<STR_LIT>',<EOL>)<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>help='<STR_LIT>',<EOL>)<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>nargs='<STR_LIT:?>',<EOL>default=None,<EOL>help='<STR_LIT>',<EOL>)<EOL>args = parser.parse_args(argv)<EOL>if args.save_token:<EOL><INDENT>if not args.token:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>LuminosoClient.save_token(args.token,<EOL>domain=urlparse(args.base_url).netloc)<EOL><DEDENT>client = LuminosoClient.connect(url=args.base_url, token=args.token)<EOL>name = args.project_name<EOL>if name is None:<EOL><INDENT>name = input('<STR_LIT>')<EOL>if not name:<EOL><INDENT>print('<STR_LIT>')<EOL>return<EOL><DEDENT><DEDENT>result = upload_docs(<EOL>client,<EOL>args.input_filename,<EOL>args.language,<EOL>name,<EOL>account=args.account_id,<EOL>progress=True,<EOL>)<EOL>print(<EOL>'<STR_LIT>'.format(<EOL>result['<STR_LIT>'], result['<STR_LIT>']<EOL>)<EOL>)<EOL>", "docstring": "Handle arguments for the 'lumi-upload' command.", "id": "f7054:m5"}
{"signature": "def _simplify_doc(doc):", "body": "<EOL>doc = dict(doc)<EOL>if '<STR_LIT:text>' not in doc:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(doc))<EOL><DEDENT>return {<EOL>'<STR_LIT:text>': doc['<STR_LIT:text>'],<EOL>'<STR_LIT>': doc.get('<STR_LIT>', []),<EOL>'<STR_LIT:title>': doc.get('<STR_LIT:title>', '<STR_LIT>')<EOL>}<EOL>", "docstring": "Limit a document to just the three fields we should upload.", "id": "f7054:m1"}
{"signature": "def transcode_to_stream(input_filename, date_format=None):", "body": "tmp = tempfile.TemporaryFile()<EOL>for entry in open_json_or_csv_somehow(input_filename,<EOL>date_format=date_format):<EOL><INDENT>tmp.write(json.dumps(entry, ensure_ascii=False).encode('<STR_LIT:utf-8>'))<EOL>tmp.write(b'<STR_LIT:\\n>')<EOL><DEDENT>tmp.seek(<NUM_LIT:0>)<EOL>return tmp<EOL>", "docstring": "Read a JSON or CSV file and convert it into a JSON stream, which will\nbe saved in an anonymous temp file.", "id": "f7056:m1"}
{"signature": "def _convert_date(date_string, date_format):", "body": "if date_format != '<STR_LIT>':<EOL><INDENT>return datetime.strptime(date_string, date_format).timestamp()<EOL><DEDENT>else:<EOL><INDENT>return float(date_string)<EOL><DEDENT>", "docstring": "Convert a date in a given format to epoch time. Mostly a wrapper for\ndatetime's strptime.", "id": "f7056:m4"}
{"signature": "def detect_file_encoding(filename):", "body": "with open(filename, '<STR_LIT:rb>') as opened:<EOL><INDENT>sample = opened.read(<NUM_LIT:2> ** <NUM_LIT:20>)<EOL>_, encoding = ftfy.guess_bytes(sample)<EOL>return encoding<EOL><DEDENT>", "docstring": "Use ftfy to detect the encoding of a file, based on a sample of its\nfirst megabyte.\n\nftfy's encoding detector is limited. The only encodings it can detect are\nUTF-8, CESU-8, UTF-16, Windows-1252, and occasionally MacRoman. But it\ndoes much better than chardet.", "id": "f7056:m5"}
{"signature": "def transcode(input_filename, output_filename=None, date_format=None):", "body": "if output_filename is None:<EOL><INDENT>output = sys.stdout<EOL><DEDENT>else:<EOL><INDENT>if output_filename.endswith('<STR_LIT>'):<EOL><INDENT>logger.warning(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>output_filename += '<STR_LIT:s>'<EOL><DEDENT>output = open(output_filename, '<STR_LIT:w>')<EOL><DEDENT>for entry in open_json_or_csv_somehow(input_filename,<EOL>date_format=date_format):<EOL><INDENT>output.write(json.dumps(entry, ensure_ascii=False).encode('<STR_LIT:utf-8>'))<EOL>output.write('<STR_LIT:\\n>')<EOL><DEDENT>output.close()<EOL>", "docstring": "Convert a JSON or CSV file of input to a JSON stream (.jsons). This\nkind of file can be easily uploaded using `luminoso_api.upload`.", "id": "f7056:m0"}
{"signature": "def open_csv_somehow(filename):", "body": "if PY3:<EOL><INDENT>return open_csv_somehow_py3(filename)<EOL><DEDENT>else:<EOL><INDENT>return open_csv_somehow_py2(filename)<EOL><DEDENT>", "docstring": "Given a filename that we're told is a CSV file, detect its encoding,\nparse its header, and return a generator yielding its rows as dictionaries.", "id": "f7056:m7"}
{"signature": "def open_json_or_csv_somehow(filename, date_format=None):", "body": "fileformat = None<EOL>if filename.endswith('<STR_LIT>'):<EOL><INDENT>fileformat = '<STR_LIT>'<EOL><DEDENT>elif filename.endswith('<STR_LIT>'):<EOL><INDENT>fileformat = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>with open(filename) as opened:<EOL><INDENT>line = opened.readline()<EOL>if line[<NUM_LIT:0>] not in '<STR_LIT>' and not filename.endswith('<STR_LIT>'):<EOL><INDENT>fileformat = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>if (line.count('<STR_LIT:{>') == line.count('<STR_LIT:}>') and<EOL>line.count('<STR_LIT:[>') == line.count('<STR_LIT:]>')):<EOL><INDENT>char = '<STR_LIT:U+0020>'<EOL>while char.isspace():<EOL><INDENT>char = opened.read()<EOL>if char == '<STR_LIT>':<EOL><INDENT>fileformat = '<STR_LIT>'<EOL>break<EOL><DEDENT><DEDENT>if fileformat is None:<EOL><INDENT>fileformat = '<STR_LIT>'<EOL><DEDENT><DEDENT>else:<EOL><INDENT>fileformat = '<STR_LIT>'<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if fileformat == '<STR_LIT>':<EOL><INDENT>stream = json.load(open(filename), encoding='<STR_LIT:utf-8>')<EOL><DEDENT>elif fileformat == '<STR_LIT>':<EOL><INDENT>stream = open_csv_somehow(filename)<EOL><DEDENT>else:<EOL><INDENT>stream = stream_json_lines(filename)<EOL><DEDENT>return _normalize_data(stream, date_format=date_format)<EOL>", "docstring": "Deduce the format of a file, within reason.\n\n- If the filename ends with .csv or .txt, it's csv.\n- If the filename ends with .jsons, it's a JSON stream (conveniently the\n  format we want to output).\n- If the filename ends with .json, it could be a legitimate JSON file, or\n  it could be a JSON stream, following a nonstandard convention that many\n  people including us are guilty of. In that case:\n  - If the first line is a complete JSON document, and there is more in the\n    file besides the first line, then it is a JSON stream.\n  - Otherwise, it is probably really JSON.\n- If the filename does not end with .json, .jsons, or .csv, we have to guess\n  whether it's still CSV or tab-separated values or something like that.\n  If it's JSON, the first character would almost certainly have to be a\n  bracket or a brace. If it isn't, assume it's CSV or similar.", "id": "f7056:m2"}
{"signature": "def _json_request(self, req_type, url, **kwargs):", "body": "response = self._request(req_type, url, **kwargs)<EOL>try:<EOL><INDENT>json_response = response.json()<EOL><DEDENT>except ValueError:<EOL><INDENT>logger.error(\"<STR_LIT>\" %<EOL>(response, response.content))<EOL>raise LuminosoError('<STR_LIT>')<EOL><DEDENT>return json_response<EOL>", "docstring": "Make a request of the specified type and expect a JSON object in\nresponse.\n\nIf the result has an 'error' value, raise a LuminosoAPIError with\nits contents. Otherwise, return the contents of the 'result' value.", "id": "f7058:c0:m6"}
{"signature": "def delete(self, path='<STR_LIT>', **params):", "body": "params = jsonify_parameters(params)<EOL>url = ensure_trailing_slash(self.url + path.lstrip('<STR_LIT:/>'))<EOL>return self._json_request('<STR_LIT>', url, params=params)<EOL>", "docstring": "Make a DELETE request to the given path, and return the JSON-decoded\nresult.\n\nKeyword parameters will be converted to URL parameters.\n\nDELETE requests ask to delete the object represented by this URL.", "id": "f7058:c0:m11"}
{"signature": "def __init__(self, session, url):", "body": "self.session = session<EOL>self.url = ensure_trailing_slash(url)<EOL>self.root_url = get_root_url(url, warn=False)<EOL>", "docstring": "Create a LuminosoClient given an existing Session object that has a\n_TokenAuth object as its .auth attribute.\n\nIt is probably easier to call LuminosoClient.connect() to handle\nthe authentication for you.", "id": "f7058:c0:m0"}
{"signature": "def client_for_path(self, path):", "body": "if path.startswith('<STR_LIT:/>'):<EOL><INDENT>url = self.root_url + path<EOL><DEDENT>else:<EOL><INDENT>url = self.url + path<EOL><DEDENT>return self.__class__(self.session, url)<EOL>", "docstring": "Returns a new client with the same root URL and authentication, but\na different specific URL.  For instance, if you have a client pointed\nat https://analytics.luminoso.com/api/v5/, and you want new ones for\nProject A and Project B, you would call:\n\n    client_a = client.client_for_path('projects/<project_id_a>')\n    client_b = client.client_for_path('projects/<project_id_b>')\n\nand your base client would remian unchanged.\n\nPaths with leading slashes are appended to the root url; otherwise,\npaths are set relative to the current path.", "id": "f7058:c0:m12"}
{"signature": "def upload_file(filename, server, account, projname, language=None,<EOL>username=None, password=None,<EOL>append=False, stage=False, date_format=None):", "body": "stream = transcode_to_stream(filename, date_format)<EOL>upload_stream(stream_json_lines(stream),<EOL>server, account, projname, language=language,<EOL>username=username, password=password,<EOL>append=append, stage=stage)<EOL>", "docstring": "Upload a file to Luminoso with the given account and project name.\n\nGiven a file containing JSON, JSON stream, or CSV data, this verifies\nthat we can successfully convert it to a JSON stream, then uploads that\nJSON stream.", "id": "f7060:m2"}
{"signature": "def upload_stream(stream, server, account, projname, language=None,<EOL>username=None, password=None,<EOL>append=False, stage=False):", "body": "client = LuminosoClient.connect(server,<EOL>username=username, password=password)<EOL>if not append:<EOL><INDENT>info = client.post('<STR_LIT>' + account, name=projname)<EOL>project_id = info['<STR_LIT>']<EOL>print('<STR_LIT>', project_id)<EOL><DEDENT>else:<EOL><INDENT>projects = client.get('<STR_LIT>' + account, name=projname)<EOL>if len(projects) == <NUM_LIT:0>:<EOL><INDENT>print('<STR_LIT>')<EOL>return<EOL><DEDENT>if len(projects) > <NUM_LIT:1>:<EOL><INDENT>print('<STR_LIT>' % projname,<EOL>end='<STR_LIT>')<EOL><DEDENT>project_id = projects[<NUM_LIT:0>]['<STR_LIT>']<EOL>print('<STR_LIT>' % project_id)<EOL><DEDENT>project = client.change_path('<STR_LIT>' + account + '<STR_LIT:/>' + project_id)<EOL>counter = <NUM_LIT:0><EOL>for batch in batches(stream, <NUM_LIT:1000>):<EOL><INDENT>counter += <NUM_LIT:1><EOL>documents = list(batch)<EOL>project.upload('<STR_LIT>', documents)<EOL>print('<STR_LIT>' % (counter))<EOL><DEDENT>if not stage:<EOL><INDENT>print('<STR_LIT>')<EOL>kwargs = {}<EOL>if language is not None:<EOL><INDENT>kwargs = {'<STR_LIT>': language}<EOL><DEDENT>job_id = project.post('<STR_LIT>', **kwargs)<EOL>project.wait_for(job_id)<EOL><DEDENT>", "docstring": "Given a file-like object containing a JSON stream, upload it to\nLuminoso with the given account name and project name.", "id": "f7060:m1"}
{"signature": "def post(self, path='<STR_LIT>', **params):", "body": "params = jsonify_parameters(params)<EOL>url = ensure_trailing_slash(self.url + path.lstrip('<STR_LIT:/>'))<EOL>return self._json_request('<STR_LIT>', url, data=params)<EOL>", "docstring": "Make a POST request to the given path, and return the JSON-decoded\nresult.\n\nKeyword parameters will be converted to form values, sent in the body\nof the POST.\n\nPOST requests are requests that cause a change on the server,\nespecially those that ask to create and return an object of some kind.", "id": "f7061:c0:m8"}
{"signature": "def get_raw(self, path, **params):", "body": "url = ensure_trailing_slash(self.url + path.lstrip('<STR_LIT:/>'))<EOL>return self._request('<STR_LIT>', url, params=params).text<EOL>", "docstring": "Get the raw text of a response.\n\nThis is only generally useful for specific URLs, such as documentation.", "id": "f7061:c0:m20"}
{"signature": "def put(self, path='<STR_LIT>', **params):", "body": "params = jsonify_parameters(params)<EOL>url = ensure_trailing_slash(self.url + path.lstrip('<STR_LIT:/>'))<EOL>return self._json_request('<STR_LIT>', url, data=params)<EOL>", "docstring": "Make a PUT request to the given path, and return the JSON-decoded\nresult.\n\nKeyword parameters will be converted to form values, sent in the body\nof the PUT.\n\nPUT requests are usually requests to *update* the object represented by\nthis URL. Unlike POST requests, PUT requests can be safely duplicated.", "id": "f7061:c0:m9"}
{"signature": "def post_data(self, path, data, content_type, **params):", "body": "params = jsonify_parameters(params)<EOL>url = ensure_trailing_slash(self.url + path.lstrip('<STR_LIT:/>'))<EOL>return self._json_request('<STR_LIT>', url,<EOL>params=params,<EOL>data=data,<EOL>headers={'<STR_LIT:Content-Type>': content_type}<EOL>)<EOL>", "docstring": "Make a POST request to the given path, with `data` in its body.\nReturn the JSON-decoded result.\n\nThe content_type must be set to reflect the kind of data being sent,\nwhich is often `application/json`.\n\nKeyword parameters will be converted to URL parameters. This is unlike\nother POST requests which encode those parameters in the body, because\nthe body is already being used.\n\nThis is used by the Luminoso API to upload new documents in JSON\nformat.", "id": "f7061:c0:m12"}
{"signature": "@classmethod<EOL><INDENT>def connect(cls, url=None, username=None, password=None, token=None,<EOL>token_file=None):<DEDENT>", "body": "auto_account = False<EOL>if url is None:<EOL><INDENT>auto_account = True<EOL>url = '<STR_LIT:/>'<EOL><DEDENT>if url.startswith('<STR_LIT:http>'):<EOL><INDENT>root_url = get_root_url(url)<EOL><DEDENT>else:<EOL><INDENT>url = URL_BASE + '<STR_LIT:/>' + url.lstrip('<STR_LIT:/>')<EOL>root_url = URL_BASE<EOL><DEDENT>auth = cls._get_token_auth(username, password, token, token_file,<EOL>root_url)<EOL>session = requests.session()<EOL>session.auth = auth<EOL>client = cls(session, url)<EOL>if auto_account:<EOL><INDENT>client = client.change_path('<STR_LIT>' %<EOL>client._get_default_account())<EOL><DEDENT>return client<EOL>", "docstring": "Returns an object that makes requests to the API, authenticated\nwith the provided username/password, at URLs beginning with `url`.\n\nYou can leave out the URL and get your 'default URL', a base path\nthat is probably appropriate for creating projects on your\naccount:\n\n    client = LuminosoClient.connect(username=username)\n\nIf the URL is simply a path, omitting the scheme and domain, then\nit will default to https://analytics.luminoso.com/api/v4/, which is\nprobably what you want:\n\n    client = LuminosoClient.connect('/projects/public', username=username)\n\nIf you leave out the username, it will use your system username,\nwhich is convenient if it matches your Luminoso username:\n\n    client = LuminosoClient.connect()", "id": "f7061:c0:m2"}
{"signature": "def get(self, path='<STR_LIT>', **params):", "body": "params = jsonify_parameters(params)<EOL>url = ensure_trailing_slash(self.url + path.lstrip('<STR_LIT:/>'))<EOL>return self._json_request('<STR_LIT>', url, params=params)<EOL>", "docstring": "Make a GET request to the given path, and return the JSON-decoded\nresult.\n\nKeyword parameters will be converted to URL parameters.\n\nGET requests are requests that retrieve information without changing\nanything on the server.", "id": "f7061:c0:m7"}
{"signature": "def __call__(self, request):", "body": "request.headers['<STR_LIT>'] = '<STR_LIT>' + self.token<EOL>return request<EOL>", "docstring": "Add an authorization header containing the token.", "id": "f7063:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def from_user_creds(cls, username, password, url=URL_BASE):<DEDENT>", "body": "session = requests.session()<EOL>token_resp = session.post(url.rstrip('<STR_LIT:/>') + '<STR_LIT>',<EOL>data={'<STR_LIT:username>': username,<EOL>'<STR_LIT:password>': password})<EOL>if token_resp.status_code != <NUM_LIT:200>:<EOL><INDENT>error = token_resp.text<EOL>try:<EOL><INDENT>error = json.loads(error)['<STR_LIT:error>']<EOL><DEDENT>except (KeyError, ValueError):<EOL><INDENT>pass<EOL><DEDENT>raise LuminosoLoginError(error)<EOL><DEDENT>return cls(token_resp.json()['<STR_LIT:result>']['<STR_LIT>'])<EOL>", "docstring": "Obtain a short-lived token using a username and password, and use that\ntoken to create an auth object.", "id": "f7063:c0:m2"}
{"signature": "def _print_csv(result):", "body": "if type(result) is not list:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>first_line = result[<NUM_LIT:0>]<EOL>w = csv.DictWriter(sys.stdout, fieldnames=sorted(first_line.keys()))<EOL>w.writeheader()<EOL>for line in result:<EOL><INDENT>w.writerow(line)<EOL><DEDENT>", "docstring": "Print a JSON list of JSON objects in CSV format.", "id": "f7064:m0"}
{"signature": "def _read_params(input_file, json_body, p_params):", "body": "params = {}<EOL>try:<EOL><INDENT>if input_file:<EOL><INDENT>params.update(json.load(input_file))<EOL><DEDENT>if json_body is not None:<EOL><INDENT>params.update(json.loads(json_body))<EOL><DEDENT><DEDENT>except ValueError as e:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % e)<EOL><DEDENT>try:<EOL><INDENT>params.update({p.split('<STR_LIT:=>', <NUM_LIT:1>)[<NUM_LIT:0>]: p.split('<STR_LIT:=>', <NUM_LIT:1>)[<NUM_LIT:1>] for p in p_params})<EOL><DEDENT>except IndexError:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return params<EOL>", "docstring": "Read parameters from input file, -j, and -p arguments, in that order.", "id": "f7064:m1"}
{"signature": "def _mkdir_p(path):", "body": "try:<EOL><INDENT>os.makedirs(path)<EOL><DEDENT>except OSError as exc:<EOL><INDENT>if exc.errno == errno.EEXIST and os.path.isdir(path):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>else:<EOL><INDENT>logger.info(\"<STR_LIT>\", path, os.path.sep)<EOL><DEDENT>", "docstring": "mkdir -p path", "id": "f7065:m7"}
{"signature": "def generate_controller(args):", "body": "controller_template = os.path.join(dirname(abspath(__file__)), '<STR_LIT>')<EOL>test_template = os.path.join(dirname(abspath(__file__)), '<STR_LIT>')<EOL>controller_name = args.get('<STR_LIT>')<EOL>current_path = os.getcwd()<EOL>logger.info('<STR_LIT>')<EOL>if not controller_name:<EOL><INDENT>logger.warning('<STR_LIT>')<EOL>return<EOL><DEDENT>with open(controller_template, '<STR_LIT:r>') as template_file:<EOL><INDENT>controller_file_path = os.path.join(current_path, '<STR_LIT>',<EOL>controller_name + '<STR_LIT>')<EOL>with open(controller_file_path, '<STR_LIT>') as controller_file:<EOL><INDENT>for line in template_file:<EOL><INDENT>new_line = line.replace('<STR_LIT>', controller_name)<EOL>controller_file.write(new_line)<EOL><DEDENT><DEDENT><DEDENT>logger.info(\"<STR_LIT>\" % _relative_path(controller_file_path))<EOL>with open(test_template, '<STR_LIT:r>') as template_file:<EOL><INDENT>test_file_path = os.path.join(current_path, '<STR_LIT>',<EOL>'<STR_LIT>' % controller_name)<EOL>with open(test_file_path, '<STR_LIT>') as test_file:<EOL><INDENT>for line in template_file:<EOL><INDENT>new_line = line.replace('<STR_LIT>', controller_name).replace('<STR_LIT>', controller_name.title())<EOL>test_file.write(new_line)<EOL><DEDENT><DEDENT><DEDENT>logger.info(\"<STR_LIT>\" % _relative_path(test_file_path))<EOL>assets_dir_path = os.path.join(current_path, '<STR_LIT>' % controller_name)<EOL>_mkdir_p(assets_dir_path)<EOL>_generate_form(controller_name)<EOL>logger.info('<STR_LIT>')<EOL>", "docstring": "Generate controller, include the controller file, template & css & js directories.", "id": "f7065:m1"}
{"signature": "@bp.route('<STR_LIT:/>')<EOL>def index():", "body": "return render_template('<STR_LIT>')<EOL>", "docstring": "Index page.", "id": "f7079:m0"}
{"signature": "@bp.route('<STR_LIT>')<EOL>def about():", "body": "return render_template('<STR_LIT>')<EOL>", "docstring": "About page.", "id": "f7079:m1"}
{"signature": "@bp.route('<STR_LIT>', methods=['<STR_LIT:GET>', '<STR_LIT:POST>'])<EOL>@VisitorPermission()<EOL>def signup():", "body": "form = SignupForm()<EOL>if form.validate_on_submit():<EOL><INDENT>params = form.data.copy()<EOL>params.pop('<STR_LIT>')<EOL>user = User(**params)<EOL>db.session.add(user)<EOL>db.session.commit()<EOL>signin_user(user)<EOL>return redirect(url_for('<STR_LIT>'))<EOL><DEDENT>return render_template('<STR_LIT>', form=form)<EOL>", "docstring": "Signup", "id": "f7080:m1"}
{"signature": "@bp.route('<STR_LIT>')<EOL>def signout():", "body": "signout_user()<EOL>return redirect(request.referrer or url_for('<STR_LIT>'))<EOL>", "docstring": "Signout", "id": "f7080:m2"}
{"signature": "def encode(something):", "body": "secret_key = current_app.config.get('<STR_LIT>')<EOL>s = URLSafeSerializer(secret_key)<EOL>return s.dumps(something)<EOL>", "docstring": "Encode something with SECRET_KEY.", "id": "f7086:m0"}
{"signature": "def absolute_url_for(endpoint, **values):", "body": "config = current_app.config<EOL>site_domain = config.get('<STR_LIT>')<EOL>relative_url = url_for(endpoint, **values)<EOL>return join_url(site_domain, relative_url)<EOL>", "docstring": "Absolute url for endpoint.", "id": "f7088:m0"}
{"signature": "def get_current_user():", "body": "if not '<STR_LIT>' in session:<EOL><INDENT>return None<EOL><DEDENT>user = User.query.filter(User.id == session['<STR_LIT>']).first()<EOL>if not user:<EOL><INDENT>signout_user()<EOL>return None<EOL><DEDENT>return user<EOL>", "docstring": "Get current user.", "id": "f7089:m2"}
{"signature": "def register_error_handle(app):", "body": "@app.errorhandler(<NUM_LIT>)<EOL>def page_403(error):<EOL><INDENT>return render_template('<STR_LIT>'), <NUM_LIT><EOL><DEDENT>@app.errorhandler(<NUM_LIT>)<EOL>def page_404(error):<EOL><INDENT>return render_template('<STR_LIT>'), <NUM_LIT><EOL><DEDENT>@app.errorhandler(<NUM_LIT>)<EOL>def page_500(error):<EOL><INDENT>return render_template('<STR_LIT>'), <NUM_LIT><EOL><DEDENT>", "docstring": "Register HTTP error pages.", "id": "f7095:m4"}
{"signature": "def create_app():", "body": "config = load_config()<EOL>app = Flask(__name__)<EOL>app.config.from_object(config)<EOL>app.wsgi_app = ProxyFix(app.wsgi_app)<EOL>CsrfProtect(app)<EOL>if app.debug or app.testing:<EOL><INDENT>DebugToolbarExtension(app)<EOL>app.wsgi_app = SharedDataMiddleware(app.wsgi_app, {<EOL>'<STR_LIT>': os.path.join(app.config.get('<STR_LIT>'), '<STR_LIT>')<EOL>})<EOL><DEDENT>else:<EOL><INDENT>app.logger.addHandler(logging.StreamHandler())<EOL>app.logger.setLevel(logging.ERROR)<EOL>if app.config.get('<STR_LIT>'):<EOL><INDENT>from .utils.sentry import sentry<EOL>sentry.init_app(app, dsn=app.config.get('<STR_LIT>'))<EOL><DEDENT>app.wsgi_app = SharedDataMiddleware(app.wsgi_app, {<EOL>'<STR_LIT>': os.path.join(app.config.get('<STR_LIT>'), '<STR_LIT>'),<EOL>'<STR_LIT>': os.path.join(app.config.get('<STR_LIT>'), '<STR_LIT>'),<EOL>'<STR_LIT>': os.path.join(app.config.get('<STR_LIT>'), '<STR_LIT>')<EOL>})<EOL><DEDENT>register_db(app)<EOL>register_routes(app)<EOL>register_jinja(app)<EOL>register_error_handle(app)<EOL>register_hooks(app)<EOL>return app<EOL>", "docstring": "Create Flask app.", "id": "f7095:m0"}
{"signature": "def register_routes(app):", "body": "from . import controllers<EOL>from flask.blueprints import Blueprint<EOL>for module in _import_submodules_from_package(controllers):<EOL><INDENT>bp = getattr(module, '<STR_LIT>')<EOL>if bp and isinstance(bp, Blueprint):<EOL><INDENT>app.register_blueprint(bp)<EOL><DEDENT><DEDENT>", "docstring": "Register routes.", "id": "f7095:m3"}
{"signature": "@manager.command<EOL>def live():", "body": "from livereload import Server<EOL>server = Server(app)<EOL>map(server.watch, glob2.glob(\"<STR_LIT>\"))  <EOL>map(server.watch, glob2.glob(\"<STR_LIT>\"))  <EOL>map(server.watch, glob2.glob(\"<STR_LIT>\"))  <EOL>server.serve(port=PORT)<EOL>", "docstring": "Run livereload server", "id": "f7097:m1"}
{"signature": "@manager.command<EOL>def build():", "body": "os.system('<STR_LIT>')<EOL>os.chdir('<STR_LIT>')<EOL>os.system('<STR_LIT>')<EOL>", "docstring": "Use FIS to compile assets.", "id": "f7097:m2"}
{"signature": "def setUp(self):", "body": "pass<EOL>", "docstring": "Called before every test.", "id": "f7099:c0:m0"}
{"signature": "def tearDown(self):", "body": "pass<EOL>", "docstring": "Called after every test.", "id": "f7099:c0:m1"}
{"signature": "def __init__(self, host, port, loop, monitored_zones=[],<EOL>monitored_outputs=[], partitions=[]):", "body": "self._host = host<EOL>self._port = port<EOL>self._loop = loop<EOL>self._message_handlers = {}<EOL>self._monitored_zones = monitored_zones<EOL>self.violated_zones = []<EOL>self._monitored_outputs = monitored_outputs<EOL>self.violated_outputs = []<EOL>self.partition_states = {}<EOL>self._keep_alive_timeout = <NUM_LIT:20><EOL>self._reconnection_timeout = <NUM_LIT:15><EOL>self._reader = None<EOL>self._writer = None<EOL>self.closed = False<EOL>self._alarm_status_callback = None<EOL>self._zone_changed_callback = None<EOL>self._output_changed_callback = None<EOL>self._partitions = partitions<EOL>self._command_status_event = asyncio.Event()<EOL>self._command_status = False<EOL>self._message_handlers[b'<STR_LIT:\\x00>'] = self._zone_violated<EOL>self._message_handlers[b'<STR_LIT>'] = self._output_changed<EOL>self._message_handlers[b'<STR_LIT>'] = lambda msg: self._armed(<EOL>AlarmState.ARMED_MODE0, msg)<EOL>self._message_handlers[b'<STR_LIT>'] = lambda msg: self._armed(<EOL>AlarmState.ARMED_MODE1, msg)<EOL>self._message_handlers[b'<STR_LIT>'] = lambda msg: self._armed(<EOL>AlarmState.ARMED_MODE2, msg)<EOL>self._message_handlers[b'<STR_LIT>'] = lambda msg: self._armed(<EOL>AlarmState.ARMED_MODE3, msg)<EOL>self._message_handlers[b'<STR_LIT>'] = lambda msg: self._armed(<EOL>AlarmState.ARMED_SUPPRESSED, msg)<EOL>self._message_handlers[b'<STR_LIT>'] = lambda msg: self._armed(<EOL>AlarmState.ENTRY_TIME, msg)<EOL>self._message_handlers[b'<STR_LIT>'] = lambda msg: self._armed(<EOL>AlarmState.EXIT_COUNTDOWN_OVER_10, msg)<EOL>self._message_handlers[b'<STR_LIT>'] = lambda msg: self._armed(<EOL>AlarmState.EXIT_COUNTDOWN_UNDER_10, msg)<EOL>self._message_handlers[b'<STR_LIT>'] = lambda msg: self._command_result(msg)<EOL>self._message_handlers[b'<STR_LIT>'] = lambda msg: self._armed(<EOL>AlarmState.TRIGGERED, msg)<EOL>self._message_handlers[b'<STR_LIT>'] = lambda msg: self._armed(<EOL>AlarmState.TRIGGERED_FIRE, msg)<EOL>", "docstring": "Init the Satel alarm data.", "id": "f7103:c1:m0"}
{"signature": "def generate_query(command):", "body": "data = bytearray(command)<EOL>c = checksum(data)<EOL>data.append(c >> <NUM_LIT:8>)<EOL>data.append(c & <NUM_LIT>)<EOL>data.replace(b'<STR_LIT>', b'<STR_LIT>')<EOL>data = bytearray.fromhex(\"<STR_LIT>\") + data + bytearray.fromhex(\"<STR_LIT>\")<EOL>return data<EOL>", "docstring": "Add header, checksum and footer to command data.", "id": "f7103:m4"}
{"signature": "async def disarm(self, code, partition_list):", "body": "_LOGGER.info(\"<STR_LIT>\")<EOL>while len(code) < <NUM_LIT:16>:<EOL><INDENT>code += '<STR_LIT:F>'<EOL><DEDENT>code_bytes = bytearray.fromhex(code)<EOL>data = generate_query(b'<STR_LIT>' + code_bytes<EOL>+ partition_bytes(partition_list))<EOL>await self._send_data(data)<EOL>", "docstring": "Send command to disarm.", "id": "f7103:c1:m9"}
{"signature": "async def clear_alarm(self, code, partition_list):", "body": "_LOGGER.info(\"<STR_LIT>\")<EOL>while len(code) < <NUM_LIT:16>:<EOL><INDENT>code += '<STR_LIT:F>'<EOL><DEDENT>code_bytes = bytearray.fromhex(code)<EOL>data = generate_query(b'<STR_LIT>' + code_bytes<EOL>+ partition_bytes(partition_list))<EOL>await self._send_data(data)<EOL>", "docstring": "Send command to clear the alarm.", "id": "f7103:c1:m10"}
{"signature": "async def start_monitoring(self):", "body": "data = generate_query(<EOL>b'<STR_LIT>')<EOL>await self._send_data(data)<EOL>resp = await self._read_data()<EOL>if resp is None:<EOL><INDENT>_LOGGER.warning(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>if resp[<NUM_LIT:1>:<NUM_LIT:2>] != b'<STR_LIT>':<EOL><INDENT>_LOGGER.warning(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Start monitoring for interesting events.", "id": "f7103:c1:m3"}
{"signature": "def _output_changed(self, msg):", "body": "status = {\"<STR_LIT>\": {}}<EOL>output_states = list_set_bits(msg, <NUM_LIT:32>)<EOL>self.violated_outputs = output_states<EOL>_LOGGER.debug(\"<STR_LIT>\",<EOL>output_states, self._monitored_outputs)<EOL>for output in self._monitored_outputs:<EOL><INDENT>status[\"<STR_LIT>\"][output] =<NUM_LIT:1> if output in output_states else <NUM_LIT:0><EOL><DEDENT>_LOGGER.debug(\"<STR_LIT>\", status)<EOL>if self._output_changed_callback:<EOL><INDENT>self._output_changed_callback(status)<EOL><DEDENT>return status<EOL>", "docstring": "0x17   outputs state 0x17   + 16/32 bytes", "id": "f7103:c1:m5"}
{"signature": "def validate(validator):", "body": "def decorator(func):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>@wraps(func)<EOL>def wrapper(image, size, validate=True):<EOL><INDENT>if validate:<EOL><INDENT>validator(image, size)<EOL><DEDENT>return func(image, size)<EOL><DEDENT>return wrapper<EOL><DEDENT>return decorator<EOL>", "docstring": "Return a decorator that validates arguments with provided `validator`\nfunction.\n\nThis will also store the validator function as `func.validate`.\nThe decorator returned by this function, can bypass the validator\nif `validate=False` is passed as argument otherwise the fucntion is\ncalled directly.\n\nThe validator must raise an exception, if the function can not\nbe called.", "id": "f7107:m0"}
{"signature": "def url_to_image(url):", "body": "r = requests.get(url)<EOL>image = StringIO(r.content)<EOL>return image<EOL>", "docstring": "Fetch an image from url and convert it into a Pillow Image object", "id": "f7108:m1"}
{"signature": "def string_to_image(image_string):", "body": "image_filelike = StringIO(image_string)<EOL>image = Image.open(image_filelike)<EOL>return image<EOL>", "docstring": "Convert string datas into a Pillow Image object", "id": "f7108:m2"}
{"signature": "def file_to_image(image_file_name):", "body": "with open(image_file_name, '<STR_LIT:r>') as f_image:<EOL><INDENT>return Image.open(f_image)<EOL><DEDENT>", "docstring": "Convert a file into a Pillow Image object", "id": "f7108:m0"}
{"signature": "@task<EOL>def clean():", "body": "rm(\"<STR_LIT>\")<EOL>", "docstring": "clean up the crap left behind by setup.py build", "id": "f7118:m0"}
{"signature": "@task<EOL>def reinstall():", "body": "pip(\"<STR_LIT>\")<EOL>install()<EOL>", "docstring": "uninstall and reinstall pub; probably only useful for developers", "id": "f7118:m3"}
{"signature": "@task<EOL>def build():", "body": "python(\"<STR_LIT>\")<EOL>", "docstring": "build pub", "id": "f7118:m1"}
{"signature": "def is_robot(user_agent):", "body": "return _match_useragent(user_agent, '<STR_LIT>')<EOL>", "docstring": "Determine if user agent is a robot/crawler/spider.\n\n    Determined according to the *Code of Practice for Research Data*.", "id": "f7129:m4"}
{"signature": "def memoize(func):", "body": "cache = {}<EOL>@wraps(func)<EOL>def inner(filename):<EOL><INDENT>if filename not in cache:<EOL><INDENT>cache[filename] = func(filename)<EOL><DEDENT>return cache[filename]<EOL><DEDENT>return inner<EOL>", "docstring": "Cache result of function call.", "id": "f7129:m1"}
{"signature": "def _change_value(self, key, value):", "body": "if not self.config.has_section(key[<NUM_LIT:0>]):<EOL><INDENT>self.config.add_section(key[<NUM_LIT:0>])<EOL><DEDENT>self.config.set(key[<NUM_LIT:0>], key[<NUM_LIT:1>], str(value))<EOL>with open(self.configfile, \"<STR_LIT:w>\") as f:<EOL><INDENT>self.config.write(f)<EOL><DEDENT>", "docstring": "Change the value of the given key in the given file to the given value", "id": "f7138:c1:m4"}
{"signature": "def _migrate_config(self, oldname=DEFAULT_CONFIG, newname=DEFAULT_CONFIG):", "body": "self._log(\"<STR_LIT>\"<EOL>\"<STR_LIT>\", logging.WARNING)<EOL>with open(oldname, \"<STR_LIT:r>\") as old:<EOL><INDENT>with open(newname, \"<STR_LIT:w>\") as new:<EOL><INDENT>new.write(\"<STR_LIT>\")<EOL>new.write(old.read())<EOL><DEDENT><DEDENT>", "docstring": "Migrates the old config file format to the new one", "id": "f7138:c1:m5"}
{"signature": "def _get_value(self, key, func=None, split_val=None, as_boolean=False,<EOL>exception_default=None):", "body": "try:<EOL><INDENT>if as_boolean:<EOL><INDENT>return self.config.getboolean(key[<NUM_LIT:0>], key[<NUM_LIT:1>])<EOL><DEDENT>value = self.config.get(key[<NUM_LIT:0>], key[<NUM_LIT:1>])<EOL>if split_val is not None:<EOL><INDENT>value = value.split(split_val)<EOL><DEDENT>if func is not None:<EOL><INDENT>return func(value)<EOL><DEDENT>return value<EOL><DEDENT>except (KeyError, configparser.NoSectionError, configparser.NoOptionError) as e:<EOL><INDENT>if exception_default is not None:<EOL><INDENT>return exception_default<EOL><DEDENT>raise KeyError(e)<EOL><DEDENT>", "docstring": "Helper method to get a value from the config", "id": "f7138:c1:m3"}
{"signature": "def _start_webserver(self, authorize_url=None):", "body": "server_address = (SERVER_URL, SERVER_PORT)<EOL>self.server = HTTPServer(server_address, OAuth2UtilRequestHandler)<EOL>self.server.response_code = None<EOL>self.server.authorize_url = authorize_url<EOL>t = Thread(target=self.server.serve_forever)<EOL>t.daemon = True<EOL>t.start()<EOL>", "docstring": "Start the webserver that will receive the code", "id": "f7138:c1:m6"}
{"signature": "def _set_app_info(self):", "body": "redirect_url = \"<STR_LIT>\".format(SERVER_URL, SERVER_PORT,<EOL>SERVER_REDIRECT_PATH)<EOL>self.r.set_oauth_app_info(self._get_value(CONFIGKEY_APP_KEY),<EOL>self._get_value(CONFIGKEY_APP_SECRET),<EOL>redirect_url)<EOL>", "docstring": "Set the app info (id & secret) read from the config file on the Reddit object", "id": "f7138:c1:m2"}
{"signature": "@property<EOL><INDENT>def tls_client(self):<DEDENT>", "body": "if self.tls_cert and self.tls_key:<EOL><INDENT>return (self.tls_cert, self.tls_key)<EOL><DEDENT>return None<EOL>", "docstring": "A tuple consisting of the TLS client certificate and key if they\n        have been provided, otherwise None.", "id": "f7145:c1:m2"}
{"signature": "def pad(data_to_pad, block_size, style='<STR_LIT>'):", "body": "padding_len = block_size-len(data_to_pad)%block_size<EOL>if style == '<STR_LIT>':<EOL><INDENT>padding = bchr(padding_len)*padding_len<EOL><DEDENT>elif style == '<STR_LIT>':<EOL><INDENT>padding = bchr(<NUM_LIT:0>)*(padding_len-<NUM_LIT:1>) + bchr(padding_len)<EOL><DEDENT>elif style == '<STR_LIT>':<EOL><INDENT>padding = bchr(<NUM_LIT>) + bchr(<NUM_LIT:0>)*(padding_len-<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return data_to_pad + padding<EOL>", "docstring": "Apply standard padding.\n\n    :Parameters:\n      data_to_pad : byte string\n        The data that needs to be padded.\n      block_size : integer\n        The block boundary to use for padding. The output length is guaranteed\n        to be a multiple of ``block_size``.\n      style : string\n        Padding algorithm. It can be *'pkcs7'* (default), *'iso7816'* or *'x923'*.\n    :Return:\n      The original data with the appropriate padding added at the end.", "id": "f7155:m0"}
{"signature": "def __mul__(self, rhs):", "body": "if isinstance(rhs, scipy.sparse.spmatrix):<EOL><INDENT>def qIter(qs):<EOL><INDENT>for j in range(qs.shape[<NUM_LIT:1>]):<EOL><INDENT>qi = qs.getcol(j).toarray().ravel()<EOL>yield qi<EOL><DEDENT>return<EOL><DEDENT><DEDENT>else:<EOL><INDENT>def qIter(qs):<EOL><INDENT>for j in range(qs.shape[<NUM_LIT:1>]):<EOL><INDENT>qi = qs[:, j]<EOL>yield qi<EOL><DEDENT>return<EOL><DEDENT><DEDENT>result = np.empty(rhs.shape, dtype=np.complex128)<EOL>for i, q in enumerate(qIter(rhs)):<EOL><INDENT>result[:, i] = self._solve(q)<EOL><DEDENT>return result<EOL>", "docstring": "Carries out the action of solving for wavefields.\n\nArgs:\n    rhs (sparse matrix): Right-hand side vector(s)\n\nReturns:\n    np.ndarray: Wavefields", "id": "f7165:c0:m5"}
{"signature": "@property<EOL><INDENT>def Ainv(self):<DEDENT>", "body": "if getattr(self, '<STR_LIT>', None) is None:<EOL><INDENT>self._Ainv = self.Solver(self.A, <NUM_LIT>)<EOL>self._Ainv.run_pardiso(<NUM_LIT:12>)<EOL><DEDENT>return self._Ainv<EOL>", "docstring": "Returns a Solver instance", "id": "f7165:c2:m0"}
{"signature": "def params_matching(layers, patterns):", "body": "if isinstance(patterns, basestring):<EOL><INDENT>patterns = (patterns, )<EOL><DEDENT>for layer in layers:<EOL><INDENT>for param in layer.params:<EOL><INDENT>name = param.name<EOL>for pattern in patterns:<EOL><INDENT>if fnmatch.fnmatch(name, pattern):<EOL><INDENT>yield name, param<EOL>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Get the parameters from a network that match a pattern.\n\n    Parameters\n    ----------\n    layers : list of :class:`theanets.layers.Layer`\n        A list of network layers to retrieve parameters from.\n    patterns : sequence of str\n        A sequence of glob-style patterns to match against. Any parameter\n        matching any pattern in this sequence will be included in the match.\n\n    Yields\n    ------\n    matches : pair of str, theano expression\n        Generates a sequence of (name, expression) pairs. The name is the name\n        of the parameter that matched, and the expression represents the\n        parameter symbolically.", "id": "f7167:m3"}
{"signature": "def _find_output(self, layer):", "body": "if layer is None:<EOL><INDENT>layer = len(self.layers) // <NUM_LIT:2><EOL><DEDENT>if isinstance(layer, int):<EOL><INDENT>layer = self.layers[layer]<EOL><DEDENT>if isinstance(layer, util.basestring):<EOL><INDENT>try:<EOL><INDENT>layer = [l for l in self.layers if l.name == layer][<NUM_LIT:0>]<EOL><DEDENT>except IndexError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if isinstance(layer, layers.Layer):<EOL><INDENT>layer = layer.output_name<EOL><DEDENT>return layer<EOL>", "docstring": "Find a layer output name for the given layer specifier.\n\n        Parameters\n        ----------\n        layer : None, int, str, or :class:`theanets.layers.Layer`\n            A layer specification. If this is None, the \"middle\" layer in the\n            network will be used (i.e., the layer at the middle index in the\n            list of network layers). If this is an integer, the corresponding\n            layer in the network's layer list will be used. If this is a string,\n            the layer with the corresponding name will be returned.\n\n        Returns\n        -------\n        name : str\n            The fully-scoped output name for the desired layer.", "id": "f7168:c0:m3"}
{"signature": "def predict_proba(self, x, **kwargs):", "body": "return self.feed_forward(x, **kwargs)[self.layers[-<NUM_LIT:1>].output_name]<EOL>", "docstring": "Compute class posterior probabilities for the given set of data.\n\n        Parameters\n        ----------\n        x : ndarray (num-examples, num-variables)\n            An array containing examples to predict. Examples are given as the\n            rows in this array.\n\n        Returns\n        -------\n        p : ndarray (num-examples, num-classes)\n            An array of class posterior probability values, one per row of input\n            data.", "id": "f7168:c2:m4"}
{"signature": "def monitors(self, **kwargs):", "body": "monitors = super(Classifier, self).monitors(**kwargs)<EOL>regs = regularizers.from_kwargs(self, **kwargs)<EOL>outputs, _ = self.build_graph(regs)<EOL>return monitors + [('<STR_LIT>', self.losses[<NUM_LIT:0>].accuracy(outputs))]<EOL>", "docstring": "Return expressions that should be computed to monitor training.\n\n        Returns\n        -------\n        monitors : list of (name, expression) pairs\n            A list of named monitor expressions to compute for this network.", "id": "f7168:c2:m1"}
{"signature": "def predict_logit(self, x, **kwargs):", "body": "return self.feed_forward(x, **kwargs)[self.layers[-<NUM_LIT:1>].full_name('<STR_LIT>')]<EOL>", "docstring": "Compute the logit values that underlie the softmax output.\n\n        Parameters\n        ----------\n        x : ndarray (num-examples, num-variables)\n            An array containing examples to classify. Examples are given as the\n            rows in this array.\n\n        Returns\n        -------\n        l : ndarray (num-examples, num-classes)\n            An array of posterior class logit values, one row of logit values\n            per row of input data.", "id": "f7168:c2:m5"}
{"signature": "def log(self):", "body": "util.log('<STR_LIT>'<EOL>'<STR_LIT>', self)<EOL>", "docstring": "Log some diagnostic info about this regularizer.", "id": "f7169:c7:m1"}
{"signature": "def loss(self, layers, outputs):", "body": "return <NUM_LIT:0.><EOL>", "docstring": "Compute a scalar term to add to the loss function for a model.\n\n        Parameters\n        ----------\n        layers : list of :class:`theanets.layers.Layer`\n            A list of the layers in the model being regularized.\n        outputs : dict of Theano expressions\n            A dictionary mapping string expression names to their corresponding\n            Theano expressions in the computation graph. This dictionary\n            contains the fully-scoped name of every layer output in the graph.", "id": "f7169:c0:m3"}
{"signature": "def modify_graph(self, outputs):", "body": "pass<EOL>", "docstring": "Modify the outputs of a particular layer in the computation graph.\n\n        Parameters\n        ----------\n        outputs : dict of Theano expressions\n            A map from string output names to the corresponding Theano\n            expression. This dictionary contains the fully-scoped name of all\n            outputs from a single layer in the computation graph.\n\n            This map is mutable, so any changes that the regularizer makes will\n            be retained when the caller regains control.\n\n        Notes\n        -----\n\n        This method is applied during graph-construction time to change the\n        behavior of one or more layer outputs. For example, the\n        :class:`BernoulliDropout` class replaces matching outputs with an\n        expression containing \"masked\" outputs, where some elements are randomly\n        set to zero each time the expression is evaluated.\n\n        Any regularizer that needs to modify the structure of the computation\n        graph should implement this method.", "id": "f7169:c0:m2"}
{"signature": "def itertrain(self, train, valid=None, **kwargs):", "body": "from . import feedforward<EOL>original_layer_names = set(l.name for l in self.network.layers[:-<NUM_LIT:1>])<EOL>layers_ = list(l.to_spec() for l in self.network.layers[:-<NUM_LIT:1>])<EOL>for i, l in enumerate(layers_[::-<NUM_LIT:1>][:-<NUM_LIT:2>]):<EOL><INDENT>layers_.append(dict(<EOL>form='<STR_LIT>', partner=l['<STR_LIT:name>'], activation=l['<STR_LIT>']))<EOL><DEDENT>layers_.append(dict(<EOL>form='<STR_LIT>', partner=layers_[<NUM_LIT:1>]['<STR_LIT:name>'], activation='<STR_LIT>'))<EOL>util.log('<STR_LIT>')<EOL>ae = feedforward.Autoencoder(layers=layers_)<EOL>pre = SupervisedPretrainer(self.algo, ae)<EOL>for monitors in pre.itertrain(train, valid, **kwargs):<EOL><INDENT>yield monitors<EOL><DEDENT>for param in ae.params:<EOL><INDENT>l, p = param.name.split('<STR_LIT:.>')<EOL>if l in original_layer_names:<EOL><INDENT>util.log('<STR_LIT>', param.name)<EOL>self.network.find(l, p).set_value(param.get_value())<EOL><DEDENT><DEDENT>util.log('<STR_LIT>')<EOL>", "docstring": "Train a model using a training and validation set.\n\n        This method yields a series of monitor values to the caller. After every\n        iteration, a pair of monitor dictionaries is generated: one evaluated on\n        the training dataset, and another evaluated on the validation dataset.\n        The validation monitors might not be updated during every training\n        iteration; in this case, the most recent validation monitors will be\n        yielded along with the training monitors.\n\n        Parameters\n        ----------\n        train : :class:`Dataset <theanets.dataset.Dataset>`\n            A set of training data for computing updates to model parameters.\n        valid : :class:`Dataset <theanets.dataset.Dataset>`\n            A set of validation data for computing monitor values and\n            determining when the loss has stopped improving.\n\n        Yields\n        ------\n        training : dict\n            A dictionary mapping monitor names to values, evaluated on the\n            training dataset.\n        validation : dict\n            A dictionary containing monitor values evaluated on the validation\n            dataset.", "id": "f7170:c3:m1"}
{"signature": "def itertrain(self, train, valid=None, **kwargs):", "body": "net = self.network<EOL>original = list(net.layers)<EOL>output_name = original[-<NUM_LIT:1>].output_name<EOL>tied = any(isinstance(l, layers.Tied) for l in original)<EOL>L = <NUM_LIT:1> + len(original) // <NUM_LIT:2> if tied else len(original) - <NUM_LIT:1><EOL>for i in range(<NUM_LIT:1>, L):<EOL><INDENT>tail = []<EOL>if i == L - <NUM_LIT:1>:<EOL><INDENT>net.layers = original<EOL><DEDENT>elif tied:<EOL><INDENT>net.layers = original[:i+<NUM_LIT:1>]<EOL>for j in range(i):<EOL><INDENT>prev = tail[-<NUM_LIT:1>] if tail else net.layers[-<NUM_LIT:1>]<EOL>tail.append(layers.Layer.build(<EOL>'<STR_LIT>', partner=original[i-j].name, inputs=prev.name))<EOL><DEDENT>net.layers = original[:i+<NUM_LIT:1>] + tail<EOL><DEDENT>else:<EOL><INDENT>tail.append(layers.Layer.build(<EOL>'<STR_LIT>',<EOL>name='<STR_LIT>',<EOL>inputs=original[i].output_name,<EOL>size=original[-<NUM_LIT:1>].output_size,<EOL>activation=original[-<NUM_LIT:1>].kwargs['<STR_LIT>']))<EOL>net.layers = original[:i+<NUM_LIT:1>] + tail<EOL><DEDENT>util.log('<STR_LIT>',<EOL>'<STR_LIT>'.join(l.name for l in net.layers))<EOL>[l.bind(net, initialize=False) for l in net.layers]<EOL>[l.setup() for l in tail]<EOL>net.losses[<NUM_LIT:0>].output_name = net.layers[-<NUM_LIT:1>].output_name<EOL>trainer = DownhillTrainer(self.algo, net)<EOL>for monitors in trainer.itertrain(train, valid, **kwargs):<EOL><INDENT>yield monitors<EOL><DEDENT><DEDENT>net.layers = original<EOL>net.losses[<NUM_LIT:0>].output_name = output_name<EOL>", "docstring": "Train a model using a training and validation set.\n\n        This method yields a series of monitor values to the caller. After every\n        iteration, a pair of monitor dictionaries is generated: one evaluated on\n        the training dataset, and another evaluated on the validation dataset.\n        The validation monitors might not be updated during every training\n        iteration; in this case, the most recent validation monitors will be\n        yielded along with the training monitors.\n\n        Parameters\n        ----------\n        train : :class:`Dataset <theanets.dataset.Dataset>`\n            A set of training data for computing updates to model parameters.\n        valid : :class:`Dataset <theanets.dataset.Dataset>`\n            A set of validation data for computing monitor values and\n            determining when the loss has stopped improving.\n\n        Yields\n        ------\n        training : dict\n            A dictionary mapping monitor names to values, evaluated on the\n            training dataset.\n        validation : dict\n            A dictionary containing monitor values evaluated on the validation\n            dataset.", "id": "f7170:c2:m1"}
{"signature": "@staticmethod<EOL><INDENT>def reservoir(xs, n, rng):<DEDENT>", "body": "pool = []<EOL>for i, x in enumerate(xs):<EOL><INDENT>if len(pool) < n:<EOL><INDENT>pool.append(x / np.linalg.norm(x))<EOL>continue<EOL><DEDENT>j = rng.randint(i + <NUM_LIT:1>)<EOL>if j < n:<EOL><INDENT>pool[j] = x / np.linalg.norm(x)<EOL><DEDENT><DEDENT>L = len(pool)<EOL>S = np.std(pool, axis=<NUM_LIT:0>)<EOL>while len(pool) < n:<EOL><INDENT>x = pool[rng.randint(L)]<EOL>pool.append(x + S * rng.randn(*x.shape))<EOL><DEDENT>return np.array(pool, dtype=pool[<NUM_LIT:0>].dtype)<EOL>", "docstring": "Select a random sample of n items from xs.", "id": "f7170:c1:m0"}
{"signature": "def __call__(self, x):", "body": "raise NotImplementedError<EOL>", "docstring": "Compute a symbolic expression for this activation function.\n\n        Parameters\n        ----------\n        x : Theano expression\n            A Theano expression representing the input to this activation\n            function.\n\n        Returns\n        -------\n        y : Theano expression\n            A Theano expression representing the output from this activation\n            function.", "id": "f7171:c0:m1"}
{"signature": "@property<EOL><INDENT>def input_name(self):<DEDENT>", "body": "if len(self._input_shapes) != <NUM_LIT:1>:<EOL><INDENT>raise util.ConfigurationError(<EOL>'<STR_LIT>'<EOL>.format(self.name, self._input_shapes))<EOL><DEDENT>return list(self._input_shapes)[<NUM_LIT:0>]<EOL>", "docstring": "Name of layer input (for layers with one input).", "id": "f7173:c0:m2"}
{"signature": "def bind(self, graph, reset=True, initialize=True):", "body": "if reset:<EOL><INDENT>for k in self._input_shapes:<EOL><INDENT>self._input_shapes[k] = None<EOL><DEDENT>for k in self._output_shapes:<EOL><INDENT>self._output_shapes[k] = None<EOL><DEDENT><DEDENT>self.resolve_inputs(graph.layers)<EOL>self.resolve_outputs()<EOL>self.activate = activations.build(<EOL>self.kwargs.get('<STR_LIT>', '<STR_LIT:relu>'), self)<EOL>if initialize:<EOL><INDENT>self.setup()<EOL><DEDENT>self.log()<EOL>", "docstring": "Bind this layer into a computation graph.\n\n        This method is a wrapper for performing common initialization tasks. It\n        calls :func:`resolve`, :func:`setup`, and :func:`log`.\n\n        Parameters\n        ----------\n        graph : :class:`Network <theanets.graph.Network>`\n            A computation network in which this layer is to be bound.\n        reset : bool, optional\n            If ``True`` (the default), reset the resolved layers for this layer.\n        initialize : bool, optional\n            If ``True`` (the default), initialize the parameters for this layer\n            by calling :func:`setup`.\n\n        Raises\n        ------\n        theanets.util.ConfigurationError :\n            If an input cannot be resolved.", "id": "f7173:c0:m11"}
{"signature": "@property<EOL><INDENT>def output_name(self):<DEDENT>", "body": "return self.full_name('<STR_LIT>')<EOL>", "docstring": "Full name of the default output for this layer.", "id": "f7173:c0:m5"}
{"signature": "def log(self):", "body": "inputs = '<STR_LIT:U+002CU+0020>'.join('<STR_LIT>'.format(*ns) for ns in self._input_shapes.items())<EOL>util.log('<STR_LIT>',<EOL>self, getattr(self.activate, '<STR_LIT:name>', self.activate), inputs)<EOL>util.log('<STR_LIT>', self.log_params())<EOL>", "docstring": "Log some information about this layer.", "id": "f7173:c0:m15"}
{"signature": "def connect(self, inputs):", "body": "outputs, updates = self.transform(inputs)<EOL>if isinstance(outputs, dict):<EOL><INDENT>outputs = sorted(outputs.items())<EOL><DEDENT>if isinstance(outputs, (TT.TensorVariable, SS.SparseVariable)):<EOL><INDENT>outputs = [('<STR_LIT>', outputs)]<EOL><DEDENT>outs = {self.full_name(name): expr for name, expr in outputs}<EOL>return outs, updates<EOL>", "docstring": "Create Theano variables representing the outputs of this layer.\n\n        Parameters\n        ----------\n        inputs : dict of Theano expressions\n            Symbolic inputs to this layer, given as a dictionary mapping string\n            names to Theano expressions. Each string key should be of the form\n            \"{layer_name}:{output_name}\" and refers to a specific output from\n            a specific layer in the graph.\n\n        Returns\n        -------\n        outputs : dict\n            A dictionary mapping names to Theano expressions for the outputs\n            from this layer.\n        updates : sequence of (parameter, expression) tuples\n            Updates that should be performed by a Theano function that computes\n            something using this layer.", "id": "f7173:c0:m9"}
{"signature": "@property<EOL><INDENT>def input_size(self):<DEDENT>", "body": "shape = self.input_shape<EOL>if shape is None:<EOL><INDENT>raise util.ConfigurationError(<EOL>'<STR_LIT>'.format(self.name))<EOL><DEDENT>return shape[-<NUM_LIT:1>]<EOL>", "docstring": "Size of layer input (for layers with one input).", "id": "f7173:c0:m4"}
{"signature": "def add_weights(self, name, nin, nout, mean=<NUM_LIT:0>, std=<NUM_LIT:0>, sparsity=<NUM_LIT:0>, diagonal=<NUM_LIT:0>):", "body": "glorot = <NUM_LIT:1> / np.sqrt(nin + nout)<EOL>m = self.kwargs.get(<EOL>'<STR_LIT>'.format(name), self.kwargs.get('<STR_LIT>', mean))<EOL>s = self.kwargs.get(<EOL>'<STR_LIT>'.format(name), self.kwargs.get('<STR_LIT>', std or glorot))<EOL>p = self.kwargs.get(<EOL>'<STR_LIT>'.format(name), self.kwargs.get('<STR_LIT>', sparsity))<EOL>d = self.kwargs.get(<EOL>'<STR_LIT>'.format(name), self.kwargs.get('<STR_LIT>', diagonal))<EOL>self._params.append(theano.shared(<EOL>util.random_matrix(nin, nout, mean=m, std=s, sparsity=p,<EOL>diagonal=d, rng=self.rng),<EOL>name=self._fmt(name)))<EOL>", "docstring": "Helper method to create a new weight matrix.\n\n        Parameters\n        ----------\n        name : str\n            Name of the parameter to add.\n        nin : int\n            Size of \"input\" for this weight matrix.\n        nout : int\n            Size of \"output\" for this weight matrix.\n        mean : float, optional\n            Mean value for randomly-initialized weights. Defaults to 0.\n        std : float, optional\n            Standard deviation of initial matrix values. Defaults to\n            :math:`1 / sqrt(n_i + n_o)`.\n        sparsity : float, optional\n            Fraction of weights to be set to zero. Defaults to 0.\n        diagonal : float, optional\n            Initialize weights to a matrix of zeros with this value along the\n            diagonal. Defaults to None, which initializes all weights randomly.", "id": "f7173:c0:m20"}
{"signature": "def log_params(self):", "body": "total = <NUM_LIT:0><EOL>for p in self.params:<EOL><INDENT>shape = p.get_value().shape<EOL>util.log('<STR_LIT>', p.name, shape)<EOL>total += np.prod(shape)<EOL><DEDENT>return total<EOL>", "docstring": "Log information about this layer's parameters.", "id": "f7173:c0:m16"}
{"signature": "def add_conv_weights(self, name, mean=<NUM_LIT:0>, std=None, sparsity=<NUM_LIT:0>):", "body": "nin = self.input_size<EOL>nout = self.output_size<EOL>mean = self.kwargs.get(<EOL>'<STR_LIT>'.format(name),<EOL>self.kwargs.get('<STR_LIT>', mean))<EOL>std = self.kwargs.get(<EOL>'<STR_LIT>'.format(name),<EOL>self.kwargs.get('<STR_LIT>', std or <NUM_LIT:1> / np.sqrt(nin + nout)))<EOL>sparsity = self.kwargs.get(<EOL>'<STR_LIT>'.format(name),<EOL>self.kwargs.get('<STR_LIT>', sparsity))<EOL>arr = np.zeros((nout, nin) + self.filter_size, util.FLOAT)<EOL>for r in range(self.filter_size[<NUM_LIT:0>]):<EOL><INDENT>for c in range(self.filter_size[<NUM_LIT:1>]):<EOL><INDENT>arr[:, :, r, c] = util.random_matrix(<EOL>nout, nin, mean, std, sparsity=sparsity, rng=self.rng)<EOL><DEDENT><DEDENT>self._params.append(theano.shared(arr, name=self._fmt(name)))<EOL>", "docstring": "Add a convolutional weight array to this layer's parameters.\n\n        Parameters\n        ----------\n        name : str\n            Name of the parameter to add.\n        mean : float, optional\n            Mean value for randomly-initialized weights. Defaults to 0.\n        std : float, optional\n            Standard deviation of initial matrix values. Defaults to\n            :math:`1 / sqrt(n_i + n_o)`.\n        sparsity : float, optional\n            Fraction of weights to set to zero. Defaults to 0.", "id": "f7175:c0:m2"}
{"signature": "def _create_rates(self, dist='<STR_LIT>', size=None, eps=<NUM_LIT>):", "body": "if size is None:<EOL><INDENT>size = self.output_size<EOL><DEDENT>if dist == '<STR_LIT>':<EOL><INDENT>z = np.random.uniform(eps, <NUM_LIT:1> - eps, size=size).astype(util.FLOAT)<EOL>return theano.shared(z, name=self._fmt('<STR_LIT>'))<EOL><DEDENT>if dist == '<STR_LIT>':<EOL><INDENT>z = np.random.uniform(-<NUM_LIT:6>, -eps, size=size).astype(util.FLOAT)<EOL>return theano.shared(np.exp(z), name=self._fmt('<STR_LIT>'))<EOL><DEDENT>return None<EOL>", "docstring": "Create a rate parameter (usually for a recurrent network layer).\n\n        Parameters\n        ----------\n        dist : {'uniform', 'log'}, optional\n            Distribution of rate values. Defaults to ``'uniform'``.\n        size : int, optional\n            Number of rates to create. Defaults to ``self.output_size``.\n        eps : float, optional\n            A \"buffer\" preventing rate values from getting too close to 0 or 1.\n            Defaults to 1e-4.\n\n        Returns\n        -------\n        rates : theano shared or None\n            A vector of rate parameters for certain types of recurrent layers.", "id": "f7176:c0:m4"}
{"signature": "def find(self, which, param):", "body": "for i, layer in enumerate(self.layers):<EOL><INDENT>if which == i or which == layer.name:<EOL><INDENT>return layer.find(param)<EOL><DEDENT><DEDENT>raise KeyError(which)<EOL>", "docstring": "Get a parameter from a layer in the network.\n\n        Parameters\n        ----------\n        which : int or str\n            The layer that owns the parameter to return.\n\n            If this is an integer, then 0 refers to the input layer, 1 refers\n            to the first hidden layer, 2 to the second, and so on.\n\n            If this is a string, the layer with the corresponding name, if any,\n            will be used.\n\n        param : int or str\n            Name of the parameter to retrieve from the specified layer, or its\n            index in the parameter list of the layer.\n\n        Raises\n        ------\n        KeyError\n            If there is no such layer, or if there is no such parameter in the\n            specified layer.\n\n        Returns\n        -------\n        param : Theano shared variable\n            A shared parameter variable from the indicated layer.", "id": "f7180:c0:m11"}
{"signature": "def updates(self, **kwargs):", "body": "regs = regularizers.from_kwargs(self, **kwargs)<EOL>_, updates = self.build_graph(regs)<EOL>return updates<EOL>", "docstring": "Return expressions to run as updates during network training.\n\n        Returns\n        -------\n        updates : list of (parameter, expression) pairs\n            A list of named parameter update expressions for this network.", "id": "f7180:c0:m21"}
{"signature": "def build_graph(self, regularizers=()):", "body": "key = self._hash(regularizers)<EOL>if key not in self._graphs:<EOL><INDENT>util.log('<STR_LIT>')<EOL>for loss in self.losses:<EOL><INDENT>loss.log()<EOL><DEDENT>for reg in regularizers:<EOL><INDENT>reg.log()<EOL><DEDENT>outputs = {}<EOL>updates = []<EOL>for layer in self.layers:<EOL><INDENT>out, upd = layer.connect(outputs)<EOL>for reg in regularizers:<EOL><INDENT>reg.modify_graph(out)<EOL><DEDENT>outputs.update(out)<EOL>updates.extend(upd)<EOL><DEDENT>self._graphs[key] = outputs, updates<EOL><DEDENT>return self._graphs[key]<EOL>", "docstring": "Connect the layers in this network to form a computation graph.\n\n        Parameters\n        ----------\n        regularizers : list of :class:`theanets.regularizers.Regularizer`\n            A list of the regularizers to apply while building the computation\n            graph.\n\n        Returns\n        -------\n        outputs : list of Theano variables\n            A list of expressions giving the output of each layer in the graph.\n        updates : list of update tuples\n            A list of updates that should be performed by a Theano function that\n            computes something using this graph.", "id": "f7180:c0:m7"}
{"signature": "def itertrain(self, train, valid=None, algo='<STR_LIT>', subalgo='<STR_LIT>',<EOL>save_every=<NUM_LIT:0>, save_progress=None, **kwargs):", "body": "if '<STR_LIT>' not in kwargs:<EOL><INDENT>kwargs['<STR_LIT>'] = self._rng<EOL><DEDENT>def create_dataset(data, **kwargs):<EOL><INDENT>name = kwargs.get('<STR_LIT:name>', '<STR_LIT>')<EOL>s = '<STR_LIT>'.format(name)<EOL>return downhill.Dataset(<EOL>data,<EOL>name=name,<EOL>batch_size=kwargs.get('<STR_LIT>', <NUM_LIT:32>),<EOL>iteration_size=kwargs.get('<STR_LIT>', kwargs.get(s)),<EOL>axis=kwargs.get('<STR_LIT>', <NUM_LIT:0>),<EOL>rng=kwargs['<STR_LIT>'])<EOL><DEDENT>if valid is None:<EOL><INDENT>valid = train<EOL><DEDENT>if not isinstance(valid, downhill.Dataset):<EOL><INDENT>valid = create_dataset(valid, name='<STR_LIT>', **kwargs)<EOL><DEDENT>if not isinstance(train, downhill.Dataset):<EOL><INDENT>train = create_dataset(train, name='<STR_LIT:train>', **kwargs)<EOL><DEDENT>if '<STR_LIT>' in kwargs:<EOL><INDENT>warnings.warn(<EOL>'<STR_LIT>',<EOL>DeprecationWarning)<EOL>algo = kwargs.pop('<STR_LIT>')<EOL>if isinstance(algo, (list, tuple)):<EOL><INDENT>algo = algo[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>if isinstance(algo, util.basestring):<EOL><INDENT>algo = algo.lower()<EOL>if algo == '<STR_LIT>':<EOL><INDENT>algo = trainer.SampleTrainer(self)<EOL><DEDENT>elif algo.startswith('<STR_LIT>') or algo.startswith('<STR_LIT>'):<EOL><INDENT>algo = trainer.SupervisedPretrainer(subalgo, self)<EOL><DEDENT>elif algo.startswith('<STR_LIT>') or algo.startswith('<STR_LIT>'):<EOL><INDENT>algo = trainer.UnsupervisedPretrainer(subalgo, self)<EOL><DEDENT>else:<EOL><INDENT>algo = trainer.DownhillTrainer(algo, self)<EOL><DEDENT><DEDENT>def needs_saving(elapsed, iteration):<EOL><INDENT>if save_progress is None:<EOL><INDENT>return False<EOL><DEDENT>if isinstance(save_every, float):<EOL><INDENT>return elapsed > <NUM_LIT> * save_every<EOL><DEDENT>if isinstance(save_every, int):<EOL><INDENT>return iteration % save_every == <NUM_LIT:0><EOL><DEDENT>return False<EOL><DEDENT>start = time.time()<EOL>for i, monitors in enumerate(algo.itertrain(train, valid, **kwargs)):<EOL><INDENT>yield monitors<EOL>now = time.time()<EOL>if i and needs_saving(now - start, i):<EOL><INDENT>filename_or_handle = save_progress<EOL>if isinstance(filename_or_handle, util.basestring):<EOL><INDENT>filename_or_handle = save_progress.format(int(now))<EOL><DEDENT>self.save(filename_or_handle)<EOL>start = now<EOL><DEDENT><DEDENT>", "docstring": "Train our network, one batch at a time.\n\n        This method yields a series of ``(train, valid)`` monitor pairs. The\n        ``train`` value is a dictionary mapping names to monitor values\n        evaluated on the training dataset. The ``valid`` value is also a\n        dictionary mapping names to values, but these values are evaluated on\n        the validation dataset.\n\n        Because validation might not occur every training iteration, the\n        validation monitors might be repeated for multiple training iterations.\n        It is probably most helpful to think of the validation monitors as being\n        the \"most recent\" values that have been computed.\n\n        After training completes, the network attribute of this class will\n        contain the trained network parameters.\n\n        Parameters\n        ----------\n        train : :class:`Dataset <downhill.dataset.Dataset>` or list\n            A dataset to use when training the network. If this is a\n            ``downhill.Dataset`` instance, it will be used directly as the\n            training datset. If it is a list of numpy arrays or a list of\n            callables, it will be converted to a ``downhill.Dataset`` and then\n            used as the training set.\n        valid : :class:`Dataset <downhill.dataset.Dataset>` or list, optional\n            If this is provided, it will be used as a validation dataset. If not\n            provided, the training set will be used for validation. (This is not\n            recommended!)\n        algo : str, optional\n            An optimization algorithm to use for training our network. If not\n            provided, :class:`RMSProp <downhill.adaptive.RMSProp>` will be used.\n        subalgo : str, optional\n            An optimization algorithm to use for a trainer that requires a\n            \"sub-algorithm,\" sugh as an unsupervised pretrainer. Defaults to\n            :class:`RMSProp <downhill.adaptive.RMSProp>`.\n        save_every : int or float, optional\n            If this is nonzero and ``save_progress`` is not None, then the model\n            being trained will be saved periodically. If this is a float, it is\n            treated as a number of minutes to wait between savings. If it is an\n            int, it is treated as the number of training epochs to wait between\n            savings. Defaults to 0.\n        save_progress : str or file handle, optional\n            If this is not None, and ``save_progress`` is nonzero, then save the\n            model periodically during training. This parameter gives either (a)\n            the full path of a file to save the model, or (b) a file-like object\n            where the model should be saved. If it is a string and the given\n            name contains a \"{}\" format specifier, it will be filled with the\n            integer Unix timestamp at the time the model is saved. Defaults to\n            None, which does not save models.\n\n        Yields\n        ------\n        training : dict\n            A dictionary of monitor values computed using the training dataset,\n            at the conclusion of training. This dictionary will at least contain\n            a 'loss' key that indicates the value of the loss function. Other\n            keys may be available depending on the trainer being used.\n        validation : dict\n            A dictionary of monitor values computed using the validation\n            dataset, at the conclusion of training.", "id": "f7180:c0:m4"}
{"signature": "def score(self, x, y, w=None, **kwargs):", "body": "u = y - self.predict(x, **kwargs)<EOL>v = y - y.mean()<EOL>if w is None:<EOL><INDENT>w = np.ones_like(u)<EOL><DEDENT>return <NUM_LIT:1> - (w * u * u).sum() / (w * v * v).sum()<EOL>", "docstring": "Compute R^2 coefficient of determination for a given labeled input.\n\n        Parameters\n        ----------\n        x : ndarray (num-examples, num-inputs)\n            An array containing data to be fed into the network. Multiple\n            examples are arranged as rows in this array, with columns containing\n            the variables for each example.\n        y : ndarray (num-examples, num-outputs)\n            An array containing expected target data for the network. Multiple\n            examples are arranged as rows in this array, with columns containing\n            the variables for each example.\n\n        Returns\n        -------\n        r2 : float\n            The R^2 correlation between the prediction of this netork and its\n            target output.", "id": "f7180:c0:m14"}
{"signature": "def _hash(self, regularizers=()):", "body": "def add(s):<EOL><INDENT>h.update(str(s).encode('<STR_LIT:utf-8>'))<EOL><DEDENT>h = hashlib.md5()<EOL>for l in self.layers:<EOL><INDENT>add('<STR_LIT>'.format(l.__class__.__name__, l.name, l.output_shape))<EOL><DEDENT>for l in self.losses:<EOL><INDENT>add('<STR_LIT>'.format(l.__class__.__name__, l.weight))<EOL><DEDENT>for r in regularizers:<EOL><INDENT>add('<STR_LIT>'.format(r.__class__.__name__, r.weight, r.pattern))<EOL><DEDENT>return h.hexdigest()<EOL>", "docstring": "Construct a string key for representing a computation graph.\n\n        This key will be unique for a given (a) network topology, (b) set of\n        losses, and (c) set of regularizers.\n\n        Returns\n        -------\n        key : str\n            A hash representing the computation graph for the current network.", "id": "f7180:c0:m6"}
{"signature": "def train(self, *args, **kwargs):", "body": "monitors = None<EOL>for monitors in self.itertrain(*args, **kwargs):<EOL><INDENT>pass<EOL><DEDENT>return monitors<EOL>", "docstring": "Train the network until the trainer converges.\n\n        All arguments are passed to :func:`itertrain`.\n\n        Returns\n        -------\n        training : dict\n            A dictionary of monitor values computed using the training dataset,\n            at the conclusion of training. This dictionary will at least contain\n            a 'loss' key that indicates the value of the loss function. Other\n            keys may be available depending on the trainer being used.\n        validation : dict\n            A dictionary of monitor values computed using the validation\n            dataset, at the conclusion of training.", "id": "f7180:c0:m5"}
{"signature": "@classmethod<EOL><INDENT>def load(cls, filename_or_handle):<DEDENT>", "body": "assert not isinstance(cls, Network),'<STR_LIT>'<EOL>if isinstance(filename_or_handle, util.basestring):<EOL><INDENT>opener = gzip.open if filename_or_handle.lower().endswith('<STR_LIT>') else open<EOL>handle = opener(filename_or_handle, '<STR_LIT:rb>')<EOL><DEDENT>else:<EOL><INDENT>handle = filename_or_handle<EOL><DEDENT>model = pickle.load(handle)<EOL>if isinstance(filename_or_handle, util.basestring):<EOL><INDENT>handle.close()<EOL><DEDENT>util.log('<STR_LIT>', filename_or_handle)<EOL>return model<EOL>", "docstring": "Load a saved network from disk.\n\n        Parameters\n        ----------\n        filename_or_handle : str or file handle\n            Load the state of this network from a pickle file. If this parameter\n            is a string, it names the file where the pickle will be saved. If it\n            is a file-like object, this object will be used for reading the\n            pickle. If the filename ends in \".gz\" then the output will\n            automatically be gunzipped.", "id": "f7180:c0:m18"}
{"signature": "def monitors(self, **kwargs):", "body": "regs = regularizers.from_kwargs(self, **kwargs)<EOL>outputs, _ = self.build_graph(regs)<EOL>monitors = [('<STR_LIT>', self.losses[<NUM_LIT:0>](outputs))]<EOL>def matching(pattern):<EOL><INDENT>'''<STR_LIT>'''<EOL>for name, expr in util.outputs_matching(outputs, pattern):<EOL><INDENT>yield name, expr<EOL><DEDENT>for name, expr in util.params_matching(self.layers, pattern):<EOL><INDENT>yield name, expr<EOL><DEDENT><DEDENT>def parse_levels(levels):<EOL><INDENT>'''<STR_LIT>'''<EOL>if isinstance(levels, dict):<EOL><INDENT>levels = levels.items()<EOL><DEDENT>if isinstance(levels, (int, float)):<EOL><INDENT>levels = [levels]<EOL><DEDENT>for level in levels:<EOL><INDENT>if isinstance(level, (tuple, list)):<EOL><INDENT>label, call = level<EOL>yield '<STR_LIT>'.format(label), call<EOL><DEDENT>if isinstance(level, (int, float)):<EOL><INDENT>def call(expr):<EOL><INDENT>return (expr < level).mean()<EOL><DEDENT>yield '<STR_LIT>'.format(level), call<EOL><DEDENT><DEDENT><DEDENT>inputs = kwargs.get('<STR_LIT>', {})<EOL>if isinstance(inputs, dict):<EOL><INDENT>inputs = inputs.items()<EOL><DEDENT>for pattern, levels in inputs:<EOL><INDENT>for name, expr in matching(pattern):<EOL><INDENT>for key, value in parse_levels(levels):<EOL><INDENT>monitors.append(('<STR_LIT>'.format(name, key), value(expr)))<EOL><DEDENT><DEDENT><DEDENT>return monitors<EOL>", "docstring": "Return expressions that should be computed to monitor training.\n\n        Returns\n        -------\n        monitors : list of (name, expression) pairs\n            A list of named monitor expressions to compute for this network.", "id": "f7180:c0:m20"}
{"signature": "def __call__(self, outputs):", "body": "output = outputs[self.output_name]<EOL>k = output.shape[-<NUM_LIT:1>]<EOL>n = TT.prod(output.shape) // k<EOL>prob = output.reshape((n, k))[TT.arange(n), self._target.reshape((n, ))]<EOL>nlp = -TT.log(TT.clip(prob, <NUM_LIT>, <NUM_LIT:1>))<EOL>if self._weights is not None:<EOL><INDENT>return (self._weights.reshape((n, )) * nlp).sum() / self._weights.sum()<EOL><DEDENT>return nlp.mean()<EOL>", "docstring": "Construct the computation graph for this loss function.\n\n        Parameters\n        ----------\n        outputs : dict of Theano expressions\n            A dictionary mapping network output names to Theano expressions\n            representing the outputs of a computation graph.\n\n        Returns\n        -------\n        loss : Theano expression\n            The values of the loss given the network output.", "id": "f7181:c6:m1"}
{"signature": "def decode(self, enc):", "body": "return '<STR_LIT>'.join(self._rev_index[c] for c in enc)<EOL>", "docstring": "Encode a text string by replacing characters with alphabet index.\n\n        Parameters\n        ----------\n        classes : list of int\n            A sequence of alphabet index values to convert to text.\n\n        Returns\n        -------\n        txt : str\n            A string containing corresponding characters from the alphabet.", "id": "f7182:c0:m2"}
{"signature": "def encode(self, txt):", "body": "return list(self._fwd_index.get(c, <NUM_LIT:0>) for c in txt)<EOL>", "docstring": "Encode a text string by replacing characters with alphabet index.\n\n        Parameters\n        ----------\n        txt : str\n            A string to encode.\n\n        Returns\n        -------\n        classes : list of int\n            A sequence of alphabet index values corresponding to the given text.", "id": "f7182:c0:m1"}
{"signature": "def plot_layers(weights, tied_weights=False, channels=<NUM_LIT:1>):", "body": "if hasattr(weights[<NUM_LIT:0>], '<STR_LIT>'):<EOL><INDENT>weights = [w.get_value() for w in weights]<EOL><DEDENT>k = min(len(weights), <NUM_LIT:9>)<EOL>imgs = np.eye(weights[<NUM_LIT:0>].shape[<NUM_LIT:0>])<EOL>for i, weight in enumerate(weights[:-<NUM_LIT:1>]):<EOL><INDENT>imgs = np.dot(weight.T, imgs)<EOL>plot_images(imgs,<EOL><NUM_LIT:100> + <NUM_LIT:10> * k + i + <NUM_LIT:1>,<EOL>channels=channels,<EOL>title='<STR_LIT>'.format(i+<NUM_LIT:1>))<EOL><DEDENT>weight = weights[-<NUM_LIT:1>]<EOL>n = weight.shape[<NUM_LIT:1>] / channels<EOL>if int(np.sqrt(n)) ** <NUM_LIT:2> != n:<EOL><INDENT>return<EOL><DEDENT>if tied_weights:<EOL><INDENT>imgs = np.dot(weight.T, imgs)<EOL>plot_images(imgs,<EOL><NUM_LIT:100> + <NUM_LIT:10> * k + k,<EOL>channels=channels,<EOL>title='<STR_LIT>'.format(k))<EOL><DEDENT>else:<EOL><INDENT>plot_images(weight,<EOL><NUM_LIT:100> + <NUM_LIT:10> * k + k,<EOL>channels=channels,<EOL>title='<STR_LIT>')<EOL><DEDENT>", "docstring": "Create a plot of weights, visualized as \"bottom-level\" pixel arrays.", "id": "f7208:m4"}
{"signature": "def readline(self, use_raw=None, prompt='<STR_LIT>'):", "body": "if self.closed: raise ValueError<EOL>if <NUM_LIT:0> == len(self.input):<EOL><INDENT>self.closed = True<EOL>raise EOFError<EOL><DEDENT>line = self.input[<NUM_LIT:0>]<EOL>del self.input[<NUM_LIT:0>]<EOL>return line<EOL>", "docstring": "Read a line of input. EOFError will be raised on EOF.\n\n        Note that we don't support prompting", "id": "f7220:c0:m3"}
{"signature": "def open(self, inp, opts=None):", "body": "if isinstance(inp, list):<EOL><INDENT>self.input = inp<EOL><DEDENT>else:<EOL><INDENT>raise IOError(\"<STR_LIT>\" % (type(inp), inp))<EOL><DEDENT>return<EOL>", "docstring": "Use this to set where to read from.", "id": "f7220:c0:m2"}
{"signature": "def open(self, output):", "body": "if isinstance(output, types.Listype):<EOL><INDENT>self.output = output<EOL><DEDENT>else:<EOL><INDENT>raise IOError(\"<STR_LIT>\" % (type(output),<EOL>output))<EOL><DEDENT>return<EOL>", "docstring": "Use this to set where to write to. output can be a\n        file object or a string. This code raises IOError on error.\n\n        If another file was previously open upon calling this open,\n        that will be stacked and will come back into use after\n        a close_write().", "id": "f7220:c1:m3"}
{"signature": "def id_name_checker(self):", "body": "name2id = Mthread.map_thread_names()<EOL>for thread_id, f in list(sys._current_frames().items()):<EOL><INDENT>self.assertEqual(thread_id,<EOL>name2id[Mthread.id2thread_name(thread_id)])<EOL>self.assertNotEqual(f, Mthread.find_debugged_frame(f))<EOL>pass<EOL><DEDENT>", "docstring": "Helper for testing map_thread_names and id2thread", "id": "f7245:c1:m0"}
{"signature": "def writeline(self, msg):", "body": "self.write(msg)<EOL>self.output.append('<STR_LIT>')<EOL>return<EOL>", "docstring": "used to write to a debugger that is connected to this\n        server; Here, we use the null string '' as an indicator of a\n        newline.", "id": "f7286:c1:m5"}
{"signature": "def close(self):", "body": "self.closed = True<EOL>return<EOL>", "docstring": "Interface is for compatibility", "id": "f7286:c0:m1"}
{"signature": "def open(self, inp, opts=None):", "body": "if isinstance(inp, list):<EOL><INDENT>self.input = inp<EOL><DEDENT>else:<EOL><INDENT>raise IOError(\"<STR_LIT>\" % (type(inp), inp))<EOL><DEDENT>return<EOL>", "docstring": "Use this to set where to read from.", "id": "f7286:c0:m2"}
{"signature": "def readline(self, use_raw=None, prompt='<STR_LIT>'):", "body": "if self.closed: raise ValueError<EOL>if <NUM_LIT:0> == len(self.input):<EOL><INDENT>self.closed = True<EOL>raise EOFError<EOL><DEDENT>line = self.input[<NUM_LIT:0>]<EOL>del self.input[<NUM_LIT:0>]<EOL>return line<EOL>", "docstring": "Read a line of input. EOFError will be raised on EOF.\n\n        Note that we don't support prompting", "id": "f7286:c0:m3"}
{"signature": "def close(self):", "body": "self.closed = True<EOL>return<EOL>", "docstring": "Nothing to do here. Interface is for compatibility", "id": "f7286:c1:m1"}
{"signature": "def readline(self, prompt='<STR_LIT>', use_raw=None):", "body": "line = self.input.readline()<EOL>if not line: raise EOFError<EOL>return line.rstrip(\"<STR_LIT:\\n>\")<EOL>", "docstring": "Read a line of input. Prompt and use_raw exist to be\n        compatible with other input routines and are ignored.\n        EOFError will be raised on EOF.", "id": "f7288:c0:m3"}
{"signature": "def run(self, cmd, start_opts=None, globals_=None, locals_=None):", "body": "if globals_ is None:<EOL><INDENT>globals_ = globals()<EOL><DEDENT>if locals_ is None:<EOL><INDENT>locals_ = globals_<EOL><DEDENT>if not isinstance(cmd, types.CodeType):<EOL><INDENT>self.eval_string = cmd<EOL>cmd = cmd+'<STR_LIT:\\n>'<EOL>pass<EOL><DEDENT>retval = None<EOL>self.core.start(start_opts)<EOL>try:<EOL><INDENT>retval = eval(cmd, globals_, locals_)<EOL><DEDENT>except SyntaxError:<EOL><INDENT>try:<EOL><INDENT>exec(cmd, globals_, locals_)<EOL><DEDENT>except DebuggerQuit:<EOL><INDENT>pass<EOL><DEDENT>except DebuggerQuit:<EOL><INDENT>pass<EOL><DEDENT>pass<EOL><DEDENT>except DebuggerQuit:<EOL><INDENT>pass<EOL><DEDENT>finally:<EOL><INDENT>self.core.stop()<EOL><DEDENT>return retval<EOL>", "docstring": "Run debugger on string `cmd' using builtin function eval\n        and if that builtin exec.  Arguments `globals_' and `locals_'\n        are the dictionaries to use for local and global variables. By\n        default, the value of globals is globals(), the current global\n        variables. If `locals_' is not given, it becomes a copy of\n        `globals_'.\n\n        Debugger.core.start settings are passed via optional\n        dictionary `start_opts'. Overall debugger settings are in\n        Debugger.settings which changed after an instance is created\n        . Also see `run_eval' if what you want to run is an\n        run_eval'able expression have that result returned and\n        `run_call' if you want to debug function run_call.", "id": "f7290:c0:m0"}
{"signature": "def run_exec(self, cmd, start_opts=None, globals_=None, locals_=None):", "body": "if globals_ is None:<EOL><INDENT>globals_ = globals()<EOL><DEDENT>if locals_ is None:<EOL><INDENT>locals_ = globals_<EOL><DEDENT>if not isinstance(cmd, types.CodeType):<EOL><INDENT>cmd = cmd+'<STR_LIT:\\n>'<EOL>pass<EOL><DEDENT>self.core.start(start_opts)<EOL>try:<EOL><INDENT>exec(cmd, globals_, locals_)<EOL><DEDENT>except DebuggerQuit:<EOL><INDENT>pass<EOL><DEDENT>finally:<EOL><INDENT>self.core.stop()<EOL><DEDENT>return<EOL>", "docstring": "Run debugger on string `cmd' which will executed via the\n        builtin function exec. Arguments `globals_' and `locals_' are\n        the dictionaries to use for local and global variables. By\n        default, the value of globals is globals(), the current global\n        variables. If `locals_' is not given, it becomes a copy of\n        `globals_'.\n\n        Debugger.core.start settings are passed via optional\n        dictionary `start_opts'. Overall debugger settings are in\n        Debugger.settings which changed after an instance is created\n        . Also see `run_eval' if what you want to run is an\n        run_eval'able expression have that result returned and\n        `run_call' if you want to debug function run_call.", "id": "f7290:c0:m1"}
{"signature": "def parse_list_cmd(proc, args, listsize=<NUM_LIT:10>):", "body": "text = proc.current_command[len(args[<NUM_LIT:0>])+<NUM_LIT:1>:].strip()<EOL>if text in frozenset(('<STR_LIT>', '<STR_LIT:.>', '<STR_LIT:+>', '<STR_LIT:->')):<EOL><INDENT>if text == '<STR_LIT:.>':<EOL><INDENT>location = resolve_location(proc, '<STR_LIT:.>')<EOL>return location.path, location.line_number, listsize<EOL><DEDENT>else:<EOL><INDENT>if proc.list_lineno is None:<EOL><INDENT>proc.errmsg(\"<STR_LIT>\")<EOL>return INVALID_PARSE_LIST<EOL><DEDENT>filename = proc.list_filename<EOL>if text == '<STR_LIT:+>':<EOL><INDENT>first = max(<NUM_LIT:1>, proc.list_lineno + listsize)<EOL><DEDENT>elif text == '<STR_LIT:->':<EOL><INDENT>if proc.list_lineno == <NUM_LIT:1> + listsize:<EOL><INDENT>proc.errmsg(\"<STR_LIT>\" % proc.list_filename)<EOL>return INVALID_PARSE_LIST<EOL><DEDENT>first = max(<NUM_LIT:1>, proc.list_lineno - (<NUM_LIT:2>*listsize) - <NUM_LIT:1>)<EOL><DEDENT>elif text == '<STR_LIT>':<EOL><INDENT>first = proc.list_lineno + <NUM_LIT:1><EOL><DEDENT><DEDENT>last = first + listsize - <NUM_LIT:1><EOL>return filename, first, last<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>list_range = build_range(text)<EOL><DEDENT>except LocationError as e:<EOL><INDENT>proc.errmsg(\"<STR_LIT>\")<EOL>proc.errmsg(e.text)<EOL>proc.errmsg(e.text_cursor)<EOL>return INVALID_PARSE_LIST<EOL><DEDENT>except ScannerError as e:<EOL><INDENT>proc.errmsg(\"<STR_LIT>\")<EOL>proc.errmsg(e.text)<EOL>proc.errmsg(e.text_cursor)<EOL>return INVALID_PARSE_LIST<EOL><DEDENT>if list_range.first is None:<EOL><INDENT>assert isinstance(list_range.last, Location)<EOL>location = resolve_location(proc, list_range.last)<EOL>if not location:<EOL><INDENT>return INVALID_PARSE_LIST<EOL><DEDENT>last     = location.line_number<EOL>first    = max(<NUM_LIT:1>, last - listsize)<EOL>return location.path, first, last<EOL><DEDENT>elif isinstance(list_range.first, int):<EOL><INDENT>first    = list_range.first<EOL>location = resolve_location(proc, list_range.last)<EOL>if not location:<EOL><INDENT>return INVALID_PARSE_LIST<EOL><DEDENT>filename = location.path<EOL>last     = location.line_number<EOL>if last < first:<EOL><INDENT>last = first + last<EOL><DEDENT>return location.path, first, last<EOL><DEDENT>else:<EOL><INDENT>assert isinstance(list_range.first, Location)<EOL>location = resolve_location(proc, list_range.first)<EOL>if not location:<EOL><INDENT>return INVALID_PARSE_LIST<EOL><DEDENT>first    = location.line_number<EOL>last     = list_range.last<EOL>if location.method:<EOL><INDENT>first -= listsize // <NUM_LIT:2><EOL><DEDENT>if isinstance(last, str):<EOL><INDENT>assert last[<NUM_LIT:0>] == '<STR_LIT:+>'<EOL>last = first + int(last[<NUM_LIT:1>:])<EOL><DEDENT>elif not last:<EOL><INDENT>last = first + listsize<EOL><DEDENT>elif last < first:<EOL><INDENT>last = first + last<EOL><DEDENT>return location.path, first, last<EOL><DEDENT>pass<EOL><DEDENT>return<EOL>", "docstring": "Parses arguments for the \"list\" command and returns the tuple:\n    (filename, first line number, last line number)\n    or sets these to None if there was some problem.", "id": "f7294:m0"}
{"signature": "def help(self, args):", "body": "if len(args) <= <NUM_LIT:2>:<EOL><INDENT>doc = self.__doc__ or self.run.__doc__<EOL>if doc:<EOL><INDENT>self.rst_msg(doc.rstrip('<STR_LIT:\\n>'))<EOL><DEDENT>else:<EOL><INDENT>self.proc.intf[-<NUM_LIT:1>].errmsg('<STR_LIT>' +<EOL>'<STR_LIT>' +<EOL>self.name)<EOL>pass<EOL><DEDENT>return<EOL><DEDENT>subcmd_name = args[<NUM_LIT:2>]<EOL>if '<STR_LIT:*>' == subcmd_name:<EOL><INDENT>self.section(\"<STR_LIT>\" % self.name)<EOL>self.msg(self.columnize_commands(self.cmds.list()))<EOL>return<EOL><DEDENT>cmd = self.cmds.lookup(subcmd_name)<EOL>if cmd:<EOL><INDENT>doc = cmd.__doc__ or cmd.run.__doc__<EOL>if doc:<EOL><INDENT>self.proc.rst_msg(doc.rstrip('<STR_LIT:\\n>'))<EOL><DEDENT>else:<EOL><INDENT>self.proc.intf[-<NUM_LIT:1>].errmsg('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(subcmd_name, self.name))<EOL>pass<EOL><DEDENT><DEDENT>else:<EOL><INDENT>cmds = [c for c in self.cmds.list()<EOL>if re.match('<STR_LIT>' + subcmd_name, c) ]<EOL>if cmds == []:<EOL><INDENT>self.errmsg(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (self.name, subcmd_name))<EOL><DEDENT>else:<EOL><INDENT>self.section(\"<STR_LIT>\" %<EOL>(self.name, subcmd_name,))<EOL>self.msg_nocr(self.columnize_commands(cmds))<EOL>pass<EOL><DEDENT>pass<EOL><DEDENT>return<EOL>", "docstring": "Give help for a command which has subcommands. This can be\n        called in several ways:\n            help cmd\n            help cmd subcmd\n            help cmd commands\n\n        Our shtick is to give help for the overall command only if\n        subcommand or 'commands' is not given. If a subcommand is given and\n        found, then specific help for that is given. If 'commands' is given\n        we will list the all the subcommands.", "id": "f7308:c0:m2"}
{"signature": "def _load_debugger_subcommands(self, name):", "body": "<EOL>cmd_instances     = []<EOL>class_prefix      = capitalize(name)  <EOL>module_dir        = '<STR_LIT>' % name<EOL>mod               = __import__(module_dir, None, None, ['<STR_LIT:*>'])<EOL>eval_cmd_template = '<STR_LIT>'<EOL>for module_name in mod.__modules__:<EOL><INDENT>import_name = module_dir + '<STR_LIT:.>' + module_name<EOL>try:<EOL><INDENT>command_mod = importlib.import_module(import_name)<EOL><DEDENT>except ImportError:<EOL><INDENT>print((\"<STR_LIT>\" %<EOL>(import_name, module_name, sys.exc_info()[<NUM_LIT:0>])))<EOL>continue<EOL><DEDENT>classnames = [ classname for classname, classvalue in<EOL>inspect.getmembers(command_mod, inspect.isclass)<EOL>if ('<STR_LIT>' != classname and<EOL>classname.startswith(class_prefix)) ]<EOL>for classname in classnames:<EOL><INDENT>eval_cmd = eval_cmd_template % classname<EOL>try:<EOL><INDENT>instance = eval(eval_cmd)<EOL>self.cmds.add(instance)<EOL><DEDENT>except:<EOL><INDENT>print(\"<STR_LIT>\" % classname)<EOL>pass<EOL><DEDENT>pass<EOL><DEDENT>pass<EOL><DEDENT>return cmd_instances<EOL>", "docstring": "Create an instance of each of the debugger\n        subcommands. Commands are found by importing files in the\n        directory 'name' + 'sub'. Some files are excluded via an array set\n        in __init__.  For each of the remaining files, we import them\n        and scan for class names inside those files and for each class\n        name, we will create an instance of that class. The set of\n        DebuggerCommand class instances form set of possible debugger\n        commands.", "id": "f7308:c0:m1"}
{"signature": "def msg(self, msg, opts={}):", "body": "try:<EOL><INDENT>return(self.debugger.intf[-<NUM_LIT:1>].msg(msg))<EOL><DEDENT>except EOFError:<EOL><INDENT>pass<EOL><DEDENT>return None<EOL>", "docstring": "Convenience short-hand for self.debugger.intf[-1].msg", "id": "f7314:c0:m4"}
{"signature": "def msg_nocr(self, msg, opts={}):", "body": "try:<EOL><INDENT>return(self.debugger.intf[-<NUM_LIT:1>].msg_nocr(msg))<EOL><DEDENT>except EOFError:<EOL><INDENT>pass<EOL><DEDENT>return None<EOL>", "docstring": "Convenience short-hand for self.debugger.intf[-1].msg_nocr", "id": "f7314:c0:m5"}
{"signature": "def rst_msg(self, text, opts={}):", "body": "text = Mformat.rst_text(text,<EOL>'<STR_LIT>' == self.debugger.settings['<STR_LIT>'],<EOL>self.debugger.settings['<STR_LIT:width>'])<EOL>return self.msg(text)<EOL>", "docstring": "Convert ReStructuredText and run through msg()", "id": "f7314:c0:m6"}
{"signature": "def run(self, args):", "body": "mainfile = self.core.filename(None)<EOL>if self.core.is_running():<EOL><INDENT>curframe = self.proc.curframe<EOL>if curframe:<EOL><INDENT>line_no = inspect.getlineno(curframe)<EOL>offset  = curframe.f_lasti<EOL>self.msg(\"<STR_LIT>\" % offset)<EOL>offset = max(offset, <NUM_LIT:0>)<EOL>code = curframe.f_code<EOL>co_code = code.co_code<EOL>disassemble_bytes(self.msg, self.msg_nocr,<EOL>co_code, offset, line_no, line_no-<NUM_LIT:1>, line_no+<NUM_LIT:1>,<EOL>constants=code.co_consts, cells=code.co_cellvars,<EOL>varnames=code.co_varnames, freevars=code.co_freevars,<EOL>linestarts=dict(findlinestarts(code)),<EOL>end_offset=offset+<NUM_LIT:10>)<EOL>pass<EOL><DEDENT>pass<EOL><DEDENT>else:<EOL><INDENT>if mainfile:<EOL><INDENT>part1 = \"<STR_LIT>\" % mainfile<EOL>msg   = \"<STR_LIT>\"<EOL>self.msg(Mmisc.wrapped_lines(part1, msg,<EOL>self.settings['<STR_LIT:width>']))<EOL><DEDENT>else:<EOL><INDENT>self.msg('<STR_LIT>')<EOL>pass<EOL><DEDENT>self.msg(self.core.execution_status)<EOL>pass<EOL><DEDENT>return False<EOL>", "docstring": "Program counter.", "id": "f7327:c0:m0"}
{"signature": "def show_category(self, category, args):", "body": "n2cmd = self.proc.commands<EOL>names = list(n2cmd.keys())<EOL>if len(args) == <NUM_LIT:1> and args[<NUM_LIT:0>] == '<STR_LIT:*>':<EOL><INDENT>self.section(\"<STR_LIT>\" % category)<EOL>cmds = [cmd for cmd in names if category == n2cmd[cmd].category]<EOL>cmds.sort()<EOL>self.msg_nocr(self.columnize_commands(cmds))<EOL>return<EOL><DEDENT>self.msg(\"<STR_LIT>\" % categories[category])<EOL>self.section(\"<STR_LIT>\")<EOL>names.sort()<EOL>for name in names:  <EOL><INDENT>if category != n2cmd[name].category: continue<EOL>self.msg(\"<STR_LIT>\" % (name, n2cmd[name].short_help,))<EOL>pass<EOL><DEDENT>return<EOL>", "docstring": "Show short help for all commands in `category'.", "id": "f7357:c0:m3"}
{"signature": "def threaded_quit(self, arg):", "body": "threading_list = threading.enumerate()<EOL>mythread =  threading.currentThread()<EOL>for t in threading_list:<EOL><INDENT>if t != mythread:<EOL><INDENT>ctype_async_raise(t, Mexcept.DebuggerQuit)<EOL>pass<EOL><DEDENT>pass<EOL><DEDENT>raise Mexcept.DebuggerQuit<EOL>", "docstring": "quit command when several threads are involved.", "id": "f7359:c0:m1"}
{"signature": "def find_and_set_debugged_frame(self, frame, thread_id):", "body": "thread = threading._active[thread_id]<EOL>thread_name = thread.getName()<EOL>if (not self.settings['<STR_LIT>'] and<EOL>thread_name == Mthread.current_thread_name()):<EOL><INDENT>newframe = Mthread.find_debugged_frame(frame)<EOL>if newframe is not None:  frame = newframe<EOL>pass<EOL><DEDENT>self.stack, self.curindex = Mcmdproc.get_stack(frame, None,<EOL>self.proc)<EOL>self.proc.stack, self.proc.curindex = self.stack, self.curindex<EOL>self.proc.frame_thread_name = thread_name<EOL>return<EOL>", "docstring": "The dance we have to do to set debugger frame state to\n        *frame*, which is in the thread with id *thread_id*. We may\n        need to the hide initial debugger frames.", "id": "f7360:c0:m1"}
{"signature": "def confirm(self, msg, default=False):", "body": "return(self.debugger.intf[-<NUM_LIT:1>].confirm(msg, default))<EOL>", "docstring": "Convenience short-hand for self.debugger.intf.confirm", "id": "f7361:c0:m2"}
{"signature": "def rst_msg(self, text):", "body": "return(self.proc.rst_msg(text))<EOL>", "docstring": "Convenience short-hand for self.proc.rst_msg(text)", "id": "f7361:c0:m6"}
{"signature": "def interact(banner=None, readfunc=None, my_locals=None, my_globals=None):", "body": "console = code.InteractiveConsole(my_locals, filename='<STR_LIT>')<EOL>console.runcode = lambda code_obj: runcode(console, code_obj)<EOL>setattr(console, '<STR_LIT>', my_globals)<EOL>if readfunc is not None:<EOL><INDENT>console.raw_input = readfunc<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>import readline<EOL><DEDENT>except ImportError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>console.interact(banner)<EOL>pass<EOL>", "docstring": "Almost a copy of code.interact\n    Closely emulate the interactive Python interpreter.\n\n    This is a backwards compatible interface to the InteractiveConsole\n    class.  When readfunc is not specified, it attempts to import the\n    readline module to enable GNU readline if it is available.\n\n    Arguments (all optional, all default to None):\n\n    banner -- passed to InteractiveConsole.interact()\n    readfunc -- if not None, replaces InteractiveConsole.raw_input()\n    local -- passed to InteractiveInterpreter.__init__()", "id": "f7367:m0"}
{"signature": "def dbgr(self, string):", "body": "print('<STR_LIT>')<EOL>self.proc.cmd_queue.append(string)<EOL>self.proc.process_command()<EOL>return<EOL>", "docstring": "Invoke a debugger command from inside a python shell called inside\n        the debugger.", "id": "f7370:c0:m0"}
{"signature": "def cache_from_source(path, debug_override=None):", "body": "debug = not sys.flags.optimize if debug_override is None else debug_override<EOL>if debug:<EOL><INDENT>suffixes = DEBUG_BYTECODE_SUFFIXES<EOL><DEDENT>else:<EOL><INDENT>suffixes = OPTIMIZED_BYTECODE_SUFFIXES<EOL>pass<EOL><DEDENT>head, tail = os.path.split(path)<EOL>base_filename, sep, _ = tail.partition('<STR_LIT:.>')<EOL>if not hasattr(sys, '<STR_LIT>'):<EOL><INDENT>raise NotImplementedError('<STR_LIT>')<EOL><DEDENT>tag = sys.implementation.cache_tag<EOL>if tag is None:<EOL><INDENT>raise NotImplementedError('<STR_LIT>')<EOL><DEDENT>filename = '<STR_LIT>'.join([base_filename, sep, tag, suffixes[<NUM_LIT:0>]])<EOL>return os.path.join(head, _PYCACHE, filename)<EOL>", "docstring": "Given the path to a .py file, return the path to its .pyc/.pyo file.\n\n    The .py file does not need to exist; this simply returns the path to the\n    .pyc/.pyo file calculated as if the .py file were imported.  The extension\n    will be .pyc unless sys.flags.optimize is non-zero, then it will be .pyo.\n\n    If debug_override is not None, then it must be a boolean and is used in\n    place of sys.flags.optimize.\n\n    If sys.implementation.cache_tag is None then NotImplementedError is raised.", "id": "f7377:m0"}
{"signature": "def interact(banner=None, readfunc=None, my_locals=None, my_globals=None):", "body": "def console_runcode(code_obj):<EOL><INDENT>runcode(console, code_obj)<EOL><DEDENT>console = code.InteractiveConsole(my_locals, filename='<STR_LIT>')<EOL>console.runcode = console_runcode<EOL>setattr(console, '<STR_LIT>', my_globals)<EOL>if readfunc is not None:<EOL><INDENT>console.raw_input = readfunc<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>import readline<EOL><DEDENT>except ImportError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>console.interact(banner)<EOL>pass<EOL>", "docstring": "Almost a copy of code.interact\n    Closely emulate the interactive Python interpreter.\n\n    This is a backwards compatible interface to the InteractiveConsole\n    class.  When readfunc is not specified, it attempts to import the\n    readline module to enable GNU readline if it is available.\n\n    Arguments (all optional, all default to None):\n\n    banner -- passed to InteractiveConsole.interact()\n    readfunc -- if not None, replaces InteractiveConsole.raw_input()\n    local -- passed to InteractiveInterpreter.__init__()", "id": "f7399:m0"}
{"signature": "def event_processor(self, frame, event, arg):", "body": "out = self.debugger.intf[-<NUM_LIT:1>].output<EOL>lineno = frame.f_lineno<EOL>filename = self.core.canonic_filename(frame)<EOL>filename = self.core.filename(filename)<EOL>if not out:<EOL><INDENT>print(\"<STR_LIT>\" % (event, filename, lineno))<EOL><DEDENT>else:<EOL><INDENT>out.write(\"<STR_LIT>\" % (event, filename, lineno))<EOL>if arg is not None:<EOL><INDENT>out.writeline('<STR_LIT>' % repr(arg))<EOL><DEDENT>else:<EOL><INDENT>out.writeline('<STR_LIT>')<EOL>pass<EOL><DEDENT>pass<EOL><DEDENT>return self.event_processor<EOL>", "docstring": "A simple event processor that prints out events.", "id": "f7405:c0:m1"}
{"signature": "def complete_token_filtered(aliases, prefix, expanded):", "body": "complete_ary = list(aliases.keys())<EOL>results = [cmd for cmd in<EOL>complete_ary if cmd.startswith(prefix)] and not (<EOL>cmd in aliases and expanded not in aliases[cmd])<EOL>return sorted(results, key=lambda pair: pair[<NUM_LIT:0>])<EOL>", "docstring": "Find all starting matches in dictionary *aliases* that start\n    with *prefix*, but filter out any matches already in\n    *expanded*.", "id": "f7406:m0"}
{"signature": "def complete_identifier(cmd, prefix):", "body": "if not cmd.proc.curframe: return [None]<EOL>ns = cmd.proc.curframe.f_globals.copy()<EOL>ns.update(cmd.proc.curframe.f_locals)<EOL>if '<STR_LIT:.>' in prefix:<EOL><INDENT>dotted = prefix.split('<STR_LIT:.>')<EOL>try:<EOL><INDENT>obj = ns[dotted[<NUM_LIT:0>]]<EOL>for part in dotted[<NUM_LIT:1>:-<NUM_LIT:1>]:<EOL><INDENT>obj = getattr(obj, part)<EOL><DEDENT><DEDENT>except (KeyError, AttributeError):<EOL><INDENT>return []<EOL><DEDENT>pre_prefix = '<STR_LIT:.>'.join(dotted[:-<NUM_LIT:1>]) + '<STR_LIT:.>'<EOL>return [pre_prefix + n for n in dir(obj) if<EOL>n.startswith(dotted[-<NUM_LIT:1>])]<EOL><DEDENT>else:<EOL><INDENT>return Mcomplete.complete_token(ns.keys(), prefix)<EOL><DEDENT>", "docstring": "Complete an arbitrary expression.", "id": "f7406:m5"}
{"signature": "def lookup(self, subcmd_prefix):", "body": "for subcmd_name in list(self.subcmds.keys()):<EOL><INDENT>if subcmd_name.startswith(subcmd_prefix)and len(subcmd_prefix) >=self.subcmds[subcmd_name].__class__.min_abbrev:<EOL><INDENT>return self.subcmds[subcmd_name]<EOL><DEDENT>pass<EOL><DEDENT>return None<EOL>", "docstring": "Find subcmd in self.subcmds", "id": "f7407:c0:m1"}
{"signature": "def add(self, subcmd_cb):", "body": "subcmd_name = subcmd_cb.name<EOL>self.subcmds[subcmd_name] = subcmd_cb<EOL>self.cmdlist.append(subcmd_name)<EOL>", "docstring": "Add subcmd to the available subcommands for this object.\n        It will have the supplied docstring, and subcmd_cb will be called\n        when we want to run the command. min_len is the minimum length\n        allowed to abbreviate the command. in_list indicates with the\n        show command will be run when giving a list of all sub commands\n        of this object. Some commands have long output like \"show commands\"\n        so we might not want to show that.", "id": "f7407:c0:m3"}
{"signature": "def help(self, *args):", "body": "print(args)<EOL>subcmd_prefix = args[<NUM_LIT:0>]<EOL>if not subcmd_prefix or len(subcmd_prefix) == <NUM_LIT:0>:<EOL><INDENT>self.msg(self.doc)<EOL>self.msg(", "docstring": "help for subcommands.", "id": "f7407:c0:m5"}
{"signature": "def get_int_noerr(self, arg):", "body": "if self.curframe:<EOL><INDENT>g = self.curframe.f_globals<EOL>l = self.curframe.f_locals<EOL><DEDENT>else:<EOL><INDENT>g = globals()<EOL>l = locals()<EOL>pass<EOL><DEDENT>try:<EOL><INDENT>val = int(eval(arg, g, l))<EOL><DEDENT>except (SyntaxError, NameError, ValueError, TypeError):<EOL><INDENT>return None<EOL><DEDENT>return val<EOL>", "docstring": "Eval arg and it is an integer return the value. Otherwise\n        return None", "id": "f7408:c0:m10"}
{"signature": "def print_source_location_info(print_fn, filename, lineno, fn_name=None,<EOL>f_lasti=None, remapped_file=None):", "body": "if remapped_file:<EOL><INDENT>mess = '<STR_LIT>' % (remapped_file, lineno, filename)<EOL><DEDENT>else:<EOL><INDENT>mess = '<STR_LIT>' % (filename, lineno)<EOL><DEDENT>if f_lasti and f_lasti != -<NUM_LIT:1>:<EOL><INDENT>mess += '<STR_LIT>' % f_lasti<EOL>pass<EOL><DEDENT>mess += '<STR_LIT>'<EOL>if fn_name and fn_name != '<STR_LIT:?>':<EOL><INDENT>mess += \"<STR_LIT>\" % fn_name<EOL>pass<EOL><DEDENT>print_fn(mess)<EOL>return<EOL>", "docstring": "Print out a source location , e.g. the first line in\n    line in:\n        (/tmp.py:2 @21):  <module>\n        L -- 2 import sys,os\n        (trepan3k)", "id": "f7408:m6"}
{"signature": "def get_int(self, arg, min_value=<NUM_LIT:0>, default=<NUM_LIT:1>, cmdname=None,<EOL>at_most=None):", "body": "if arg is None: return default<EOL>default = self.get_int_noerr(arg)<EOL>if default is None:<EOL><INDENT>if cmdname:<EOL><INDENT>self.errmsg((\"<STR_LIT>\"<EOL>+ \"<STR_LIT>\") % (cmdname, str(arg)))<EOL><DEDENT>else:<EOL><INDENT>self.errmsg('<STR_LIT>'<EOL>% str(arg))<EOL>pass<EOL><DEDENT>return None<EOL>pass<EOL><DEDENT>if default < min_value:<EOL><INDENT>if cmdname:<EOL><INDENT>self.errmsg((\"<STR_LIT>\" +<EOL>'<STR_LIT>')<EOL>% (cmdname, min_value, default))<EOL><DEDENT>else:<EOL><INDENT>self.errmsg((\"<STR_LIT>\" +<EOL>'<STR_LIT>')<EOL>% (min_value, default))<EOL>pass<EOL><DEDENT>return None<EOL><DEDENT>elif at_most and default > at_most:<EOL><INDENT>if cmdname:<EOL><INDENT>self.errmsg((\"<STR_LIT>\" +<EOL>'<STR_LIT>')<EOL>% (cmdname, at_most, default))<EOL><DEDENT>else:<EOL><INDENT>self.errmsg((\"<STR_LIT>\")<EOL>% (at_most, default))<EOL>pass<EOL><DEDENT>pass<EOL><DEDENT>return default<EOL>", "docstring": "If no argument use the default. If arg is a an integer between\n        least min_value and at_most, use that. Otherwise report an error.\n        If there's a stack frame use that in evaluation.", "id": "f7408:c0:m11"}
{"signature": "def print_source_line(msg, lineno, line, event_str=None):", "body": "<EOL>return msg('<STR_LIT>' % (event_str, lineno, line))<EOL>", "docstring": "Print out a source line of text , e.g. the second\n    line in:\n        (/tmp.py:2):  <module>\n        L -- 2 import sys,os\n        (trepan3k)\n\n    We define this method\n    specifically so it can be customized for such applications\n    like ipython.", "id": "f7408:m5"}
{"signature": "def read_history_file(self):", "body": "histfile = self.debugger.intf[-<NUM_LIT:1>].histfile<EOL>try:<EOL><INDENT>import readline<EOL>readline.read_history_file(histfile)<EOL><DEDENT>except IOError:<EOL><INDENT>pass<EOL><DEDENT>except ImportError:<EOL><INDENT>pass<EOL><DEDENT>return<EOL>", "docstring": "Read the command history file -- possibly.", "id": "f7408:c0:m20"}
{"signature": "def run_show_bool(obj, what=None):", "body": "val = show_onoff(obj.debugger.settings[obj.name])<EOL>if not what: what = obj.name<EOL>return obj.msg(\"<STR_LIT>\" % (what, val))<EOL>", "docstring": "Generic subcommand showing a boolean-valued debugger setting.\n    'obj' is generally a subcommand that has 'name' and\n    'debugger.setting' attributes.", "id": "f7409:m9"}
{"signature": "def show_onoff(b):", "body": "if not isinstance(b, bool):<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>if b:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>return \"<STR_LIT>\"<EOL>", "docstring": "Return 'on' for True and 'off' for False, and ?? for anything\n    else.", "id": "f7409:m11"}
{"signature": "def p_list_range(self, args):", "body": "", "docstring": "range_start  ::= opt_space range\nrange ::= location\nrange ::= location opt_space COMMA opt_space NUMBER\nrange ::= location opt_space COMMA opt_space OFFSET\nrange ::= COMMA opt_space location\nrange ::= location opt_space COMMA\nrange ::= location\nrange ::= DIRECTION", "id": "f7411:c1:m5"}
{"signature": "def p_asm_range(self, args):", "body": "", "docstring": "arange_start  ::= opt_space arange\narange ::= range\narange ::= addr_location opt_space COMMA opt_space NUMBER\narange ::= addr_location opt_space COMMA opt_space OFFSET\narange ::= addr_location opt_space COMMA opt_space ADDRESS\narange ::= location opt_space COMMA opt_space ADDRESS\narange ::= addr_location opt_space COMMA\narange ::= addr_location\n\n# Unlike ranges, We don't allow ending at an address\n# arange ::= COMMA opt_space addr_location\n\naddr_location ::= location\naddr_location ::= ADDRESS", "id": "f7411:c1:m4"}
{"signature": "def t_single_quote_file(self, s):", "body": "<EOL>base = s[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL>self.add_token('<STR_LIT>', base)<EOL>self.pos += len(s)<EOL>", "docstring": "r\"'[^'].+", "id": "f7413:c1:m5"}
{"signature": "def t_direction(self, s):", "body": "<EOL>self.add_token('<STR_LIT>', s)<EOL>self.pos += len(s)<EOL>", "docstring": "r'^[+-]$", "id": "f7413:c1:m9"}
{"signature": "def t_double_quote_file(self, s):", "body": "<EOL>base = s[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL>self.add_token('<STR_LIT>', base)<EOL>self.pos += len(s)<EOL>", "docstring": "r'\"[^\"]+", "id": "f7413:c1:m6"}
{"signature": "def t_whitespace(self, s):", "body": "self.add_token('<STR_LIT>', s)<EOL>self.pos += len(s)<EOL>pass<EOL>", "docstring": "r'\\s+", "id": "f7413:c1:m3"}
{"signature": "def t_address(self, s):", "body": "pos = self.pos<EOL>self.add_token('<STR_LIT>', s)<EOL>self.pos = pos + len(s)<EOL>", "docstring": "r'[*]\\d+", "id": "f7413:c1:m12"}
{"signature": "def _postprocess_options(dbg, opts):", "body": "<EOL>print_events = []<EOL>if opts.fntrace:   print_events = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>if opts.linetrace: print_events += ['<STR_LIT>']<EOL>if len(print_events):<EOL><INDENT>dbg.settings['<STR_LIT>'] = frozenset(print_events)<EOL>pass<EOL><DEDENT>for setting in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>dbg.settings[setting] = getattr(opts, setting)<EOL>pass<EOL><DEDENT>if getattr(opts, '<STR_LIT>'):<EOL><INDENT>dbg.settings['<STR_LIT>'] = opts.highlight<EOL><DEDENT>else:<EOL><INDENT>dbg.settings['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>dbg.settings['<STR_LIT>'] = None<EOL>if not opts.private:<EOL><INDENT>Mdebugger.debugger_obj = dbg<EOL>pass<EOL><DEDENT>if opts.post_mortem:<EOL><INDENT>Mapi.debugger_on_post_mortem()<EOL>pass<EOL><DEDENT>return<EOL>", "docstring": "Handle options (`opts') that feed into the debugger (`dbg')", "id": "f7414:m3"}
{"signature": "def process_options(debugger_name, pkg_version, sys_argv, option_list=None):", "body": "usage_str=\"\"\"<STR_LIT>\"\"\"<EOL>optparser = OptionParser(usage=usage_str, option_list=option_list,<EOL>version=\"<STR_LIT>\" % pkg_version)<EOL>optparser.add_option(\"<STR_LIT>\", \"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>action=\"<STR_LIT:store_true>\", default=False,<EOL>help=\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>optparser.add_option(\"<STR_LIT>\", \"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>action=\"<STR_LIT:store_true>\", default=False,<EOL>help=\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>optparser.add_option(\"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>action=\"<STR_LIT:store_true>\", default=False,<EOL>help=\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL>optparser.add_option(\"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>action='<STR_LIT:store_true>',<EOL>help=\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>optparser.add_option(\"<STR_LIT>\", \"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>action=\"<STR_LIT:store>\", type='<STR_LIT:string>', metavar='<STR_LIT>',<EOL>help=\"<STR_LIT>\")<EOL>optparser.add_option(\"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>action=\"<STR_LIT:store>\", type='<STR_LIT:string>', metavar='<STR_LIT>',<EOL>help=\"<STR_LIT>\")<EOL>optparser.add_option(\"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>action=\"<STR_LIT:store_true>\", default=True,<EOL>help=\"<STR_LIT>\")<EOL>optparser.add_option(\"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>action=\"<STR_LIT:store_true>\", default=False,<EOL>help=\"<STR_LIT>\")<EOL>optparser.add_option(\"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>action=\"<STR_LIT:store_true>\", default=True,<EOL>help=\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>optparser.add_option(\"<STR_LIT>\", \"<STR_LIT>\", dest=\"<STR_LIT>\", type=\"<STR_LIT:string>\",<EOL>help=\"<STR_LIT>\" +<EOL>\"<STR_LIT>\")<EOL>optparser.add_option(\"<STR_LIT>\", \"<STR_LIT>\", dest=\"<STR_LIT:host>\", default='<STR_LIT:127.0.0.1>',<EOL>action=\"<STR_LIT:store>\", type='<STR_LIT:string>', metavar='<STR_LIT>',<EOL>help=\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>optparser.add_option(\"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>action=\"<STR_LIT:store>\", type='<STR_LIT:string>',<EOL>metavar='<STR_LIT>',<EOL>default='<STR_LIT>',<EOL>help=\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>optparser.add_option(\"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>action='<STR_LIT:store_true>', default=False,<EOL>help=\"<STR_LIT>\")<EOL>optparser.add_option(\"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>action=\"<STR_LIT:store_true>\", default=True,<EOL>help=\"<STR_LIT>\"<EOL>)<EOL>optparser.add_option(\"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>action=\"<STR_LIT>\", default=True,<EOL>help=\"<STR_LIT>\"<EOL>)<EOL>optparser.add_option(\"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>action='<STR_LIT:store_true>', default=True,<EOL>help=(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"))<EOL>optparser.add_option(\"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>action='<STR_LIT>', default=True,<EOL>help=(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"))<EOL>optparser.add_option(\"<STR_LIT>\", \"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>action=\"<STR_LIT:store_true>\", default=False,<EOL>help=(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"))<EOL>optparser.add_option(\"<STR_LIT>\", \"<STR_LIT>\", dest=\"<STR_LIT>\", metavar='<STR_LIT>',<EOL>action=\"<STR_LIT:store>\", type='<STR_LIT:string>',<EOL>help=(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"))<EOL>optparser.add_option(\"<STR_LIT>\", \"<STR_LIT>\", dest=\"<STR_LIT:port>\", default=<NUM_LIT>,<EOL>action=\"<STR_LIT:store>\", type='<STR_LIT:int>',<EOL>help=\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>optparser.add_option(\"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>action='<STR_LIT:store_true>',<EOL>help=\"<STR_LIT>\")<EOL>optparser.add_option(\"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>action=\"<STR_LIT:store_true>\", default=False,<EOL>help=\"<STR_LIT>\")<EOL>optparser.add_option(\"<STR_LIT>\", \"<STR_LIT>\", dest=\"<STR_LIT:target>\",<EOL>help=(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")),<EOL>optparser.add_option(\"<STR_LIT>\", dest='<STR_LIT>', action='<STR_LIT:store_true>',<EOL>default=False, help=\"<STR_LIT>\")<EOL>optparser.add_option(\"<STR_LIT>\", default=<NUM_LIT:0>, type=\"<STR_LIT:int>\",<EOL>help=\"<STR_LIT>\")<EOL>optparser.disable_interspersed_args()<EOL>sys.argv = list(sys_argv)<EOL>(opts, sys.argv) = optparser.parse_args()<EOL>dbg_opts = {'<STR_LIT>': opts.from_ipython}<EOL>dbg_initfiles = []<EOL>if not opts.noexecute:<EOL><INDENT>add_startup_file(dbg_initfiles)<EOL><DEDENT>if opts.command:<EOL><INDENT>dbg_initfiles.append(opts.command)<EOL>pass<EOL><DEDENT>dbg_opts['<STR_LIT>'] = {'<STR_LIT>': dbg_initfiles}<EOL>if opts.cd:<EOL><INDENT>os.chdir(opts.cd)<EOL>pass<EOL><DEDENT>if opts.output:<EOL><INDENT>try:<EOL><INDENT>dbg_opts['<STR_LIT>'] = Moutput.DebuggerUserOutput(opts.output)<EOL><DEDENT>except IOError:<EOL><INDENT>_, xxx_todo_changeme, _ = sys.exc_info()<EOL>(errno, strerror) = xxx_todo_changeme.args<EOL>print(\"<STR_LIT>\" % opts.output)<EOL>print(\"<STR_LIT>\" % (errno, strerror))<EOL><DEDENT>except:<EOL><INDENT>print(\"<STR_LIT>\" %<EOL>opts.output)<EOL>print(sys.exc_info()[<NUM_LIT:0>])<EOL>sys.exit(<NUM_LIT:2>)<EOL>pass<EOL><DEDENT>pass<EOL><DEDENT>return opts, dbg_opts, sys.argv<EOL>", "docstring": "Handle debugger options. Set `option_list' if you are writing\n    another main program and want to extend the existing set of debugger\n    options.\n\n    The options dicionary from optparser is returned. sys_argv is\n    also updated.", "id": "f7414:m2"}
{"signature": "def process_options(pkg_version, sys_argv, option_list=None):", "body": "usage_str=\"\"\"<STR_LIT>\"\"\"<EOL>optparser = OptionParser(usage=usage_str, option_list=option_list,<EOL>version=\"<STR_LIT>\" % pkg_version)<EOL>optparser.add_option(\"<STR_LIT>\", \"<STR_LIT>\", dest=\"<STR_LIT:host>\", default='<STR_LIT:127.0.0.1>',<EOL>action=\"<STR_LIT:store>\", type='<STR_LIT:string>', metavar='<STR_LIT>',<EOL>help=\"<STR_LIT>\")<EOL>optparser.add_option(\"<STR_LIT>\", \"<STR_LIT>\", dest=\"<STR_LIT:port>\", default=<NUM_LIT>,<EOL>action=\"<STR_LIT:store>\", type='<STR_LIT:int>', metavar='<STR_LIT>',<EOL>help=\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>optparser.add_option(\"<STR_LIT>\", dest=\"<STR_LIT>\", default=<NUM_LIT:0>,<EOL>action=\"<STR_LIT:store>\", type='<STR_LIT:int>', metavar='<STR_LIT>',<EOL>help=\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>optparser.disable_interspersed_args()<EOL>sys.argv = list(sys_argv)<EOL>(opts, sys.argv) = optparser.parse_args()<EOL>return opts, sys.argv<EOL>", "docstring": "Handle debugger options. Set `option_list' if you are writing\n    another main program and want to extend the existing set of debugger\n    options.\n\n    The options dicionary from opt_parser is return. sys_argv is\n    also updated.", "id": "f7415:m0"}
{"signature": "def main(dbg=None, sys_argv=list(sys.argv)):", "body": "global __title__<EOL>orig_sys_argv = list(sys_argv)<EOL>opts, dbg_opts, sys_argv  = process_options(__title__, __version__,<EOL>sys_argv)<EOL>dbg_opts['<STR_LIT>'] = sys_argv<EOL>dbg_opts['<STR_LIT>']     = Mbullwinkle.BWInterface()<EOL>dbg_opts['<STR_LIT>']     = '<STR_LIT>'<EOL>if dbg is None:<EOL><INDENT>dbg = Mdebugger.Trepan(dbg_opts)<EOL>dbg.core.add_ignore(main)<EOL>pass<EOL><DEDENT>_postprocess_options(dbg, opts)<EOL>if len(sys_argv) == <NUM_LIT:0>:<EOL><INDENT>mainpyfile = None<EOL><DEDENT>else:<EOL><INDENT>mainpyfile = sys_argv[<NUM_LIT:0>]  <EOL>if not os.path.isfile(mainpyfile):<EOL><INDENT>mainpyfile=Mclifns.whence_file(mainpyfile)<EOL>is_readable = Mfile.readable(mainpyfile)<EOL>if is_readable is None:<EOL><INDENT>print(\"<STR_LIT>\"<EOL>% (__title__, mainpyfile,))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>elif not is_readable:<EOL><INDENT>print(\"<STR_LIT>\"<EOL>% (__title__, mainpyfile,))<EOL>sys.exit(<NUM_LIT:1>)<EOL>return<EOL><DEDENT><DEDENT>mainpyfile_noopt = Mfile.file_pyc2py(mainpyfile)<EOL>if mainpyfile != mainpyfile_nooptand Mfile.readable(mainpyfile_noopt):<EOL><INDENT>print(\"<STR_LIT>\"<EOL>% __title__)<EOL>print(\"<STR_LIT>\" % (<EOL>__title__, mainpyfile_noopt,))<EOL>mainpyfile = mainpyfile_noopt<EOL>pass<EOL><DEDENT>sys.path[<NUM_LIT:0>] = dbg.main_dirname = os.path.dirname(mainpyfile)<EOL><DEDENT>dbg.sig_received = False<EOL>while True:<EOL><INDENT>try:<EOL><INDENT>if dbg.program_sys_argv and mainpyfile:<EOL><INDENT>normal_termination = dbg.run_script(mainpyfile)<EOL>if not normal_termination: break<EOL><DEDENT>else:<EOL><INDENT>dbg.core.execution_status = '<STR_LIT>'<EOL>dbg.core.processor.process_commands()<EOL>pass<EOL><DEDENT>dbg.core.execution_status = '<STR_LIT>'<EOL>dbg.intf[-<NUM_LIT:1>].msg(\"<STR_LIT>\")<EOL>dbg.core.processor.process_commands()<EOL><DEDENT>except Mexcept.DebuggerQuit:<EOL><INDENT>break<EOL><DEDENT>except Mexcept.DebuggerRestart:<EOL><INDENT>dbg.core.execution_status = '<STR_LIT>'<EOL>if dbg.program_sys_argv:<EOL><INDENT>sys.argv = list(dbg.program_sys_argv)<EOL>part1 = ('<STR_LIT>' %<EOL>dbg.core.filename(mainpyfile))<EOL>args  = '<STR_LIT:U+0020>'.join(dbg.program_sys_argv[<NUM_LIT:1>:])<EOL>dbg.intf[-<NUM_LIT:1>].msg(Mmisc.wrapped_lines(part1, args,<EOL>dbg.settings['<STR_LIT:width>']))<EOL><DEDENT>else: break<EOL><DEDENT>except SystemExit:<EOL><INDENT>break<EOL><DEDENT>pass<EOL><DEDENT>sys.argv = orig_sys_argv<EOL>return<EOL>", "docstring": "Routine which gets run if we were invoked directly", "id": "f7416:m2"}
{"signature": "def post_mortem(exc=None, frameno=<NUM_LIT:1>, dbg=None):", "body": "if dbg is None:<EOL><INDENT>if Mdebugger.debugger_obj is None:<EOL><INDENT>Mdebugger.debugger_obj = Mdebugger.Trepan()<EOL>pass<EOL><DEDENT>dbg = Mdebugger.debugger_obj<EOL>pass<EOL><DEDENT>re_bogus_file = re.compile(\"<STR_LIT>\")<EOL>if exc[<NUM_LIT:0>] is None:<EOL><INDENT>exc = get_last_or_frame_exception()<EOL>if exc[<NUM_LIT:0>] is None:<EOL><INDENT>print(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>return<EOL><DEDENT>pass<EOL><DEDENT>exc_type, exc_value, exc_tb = exc<EOL>dbg.core.execution_status = ('<STR_LIT>'<EOL>% exc_type)<EOL>if exc_tb is not None:<EOL><INDENT>while exc_tb.tb_next is not None:<EOL><INDENT>filename = exc_tb.tb_frame.f_code.co_filename<EOL>if (dbg.mainpyfile and <NUM_LIT:0> == len(dbg.mainpyfile)<EOL>and not re_bogus_file.match(filename)):<EOL><INDENT>dbg.mainpyfile = filename<EOL>pass<EOL><DEDENT>exc_tb = exc_tb.tb_next<EOL>pass<EOL><DEDENT>dbg.core.processor.curframe = exc_tb.tb_frame<EOL>pass<EOL><DEDENT>if <NUM_LIT:0> == len(dbg.program_sys_argv):<EOL><INDENT>dbg.program_sys_argv = list(sys.argv[<NUM_LIT:1>:])<EOL>dbg.program_sys_argv[:<NUM_LIT:0>] = [dbg.mainpyfile]<EOL><DEDENT>try:<EOL><INDENT>f = exc_tb.tb_frame<EOL>if f and f.f_lineno != exc_tb.tb_lineno : f = f.f_back<EOL>dbg.core.processor.event_processor(f, '<STR_LIT>', exc, '<STR_LIT>')<EOL><DEDENT>except DebuggerRestart:<EOL><INDENT>while True:<EOL><INDENT>sys.argv = list(dbg._program_sys_argv)<EOL>dbg.msg(\"<STR_LIT>\"<EOL>% (dbg.filename(dbg.mainpyfile),<EOL>\"<STR_LIT:U+0020>\".join(dbg._program_sys_argv[<NUM_LIT:1>:])))<EOL>try:<EOL><INDENT>dbg.run_script(dbg.mainpyfile)<EOL><DEDENT>except DebuggerRestart:<EOL><INDENT>pass<EOL><DEDENT>pass<EOL><DEDENT><DEDENT>except DebuggerQuit:<EOL><INDENT>pass<EOL><DEDENT>return<EOL>", "docstring": "Enter debugger read loop after your program has crashed.\n\n    exc is a triple like you get back from sys.exc_info.  If no exc\n    parameter, is supplied, the values from sys.last_type,\n    sys.last_value, sys.last_traceback are used. And if these don't\n    exist either we'll assume that sys.exc_info() contains what we\n    want and frameno is the index location of where we want to start.\n\n    'frameno' specifies how many frames to ignore in the traceback.\n    The default is 1, that is, we don't need to show the immediate\n    call into post_mortem. If you have wrapper functions that call\n    this one, you may want to increase frameno.", "id": "f7417:m3"}
{"signature": "def pm(frameno=<NUM_LIT:1>, dbg=None):", "body": "post_mortem(get_last_or_frame_exception(), frameno, dbg=dbg)<EOL>return<EOL>", "docstring": "Set up post-mortem debugging using the last traceback.  But if\n    there is no traceback, we'll assume that sys.exc_info() contains\n    what we want and frameno is the index location of where we want\n    to start.\n\n    'dbg', is an optional trepan.Trepan object.", "id": "f7417:m1"}
{"signature": "def errmsg(self, msg):", "body": "return self.msg(msg)<EOL>", "docstring": "Common routine for reporting debugger error messages.", "id": "f7418:c0:m2"}
{"signature": "def close(self):", "body": "self.input.close()<EOL>self.output.close()<EOL>return<EOL>", "docstring": "Closes both input and output", "id": "f7418:c0:m1"}
{"signature": "def errmsg(self, msg, prefix=\"<STR_LIT>\"):", "body": "<EOL>if not self.verbose:<EOL><INDENT>location = (\"<STR_LIT>\"<EOL>% (self.script_name, self.input_lineno))<EOL>msg = \"<STR_LIT>\" %(prefix, location, prefix, msg)<EOL><DEDENT>else:<EOL><INDENT>msg = \"<STR_LIT>\" %(prefix, msg)<EOL>pass<EOL><DEDENT>self.msg(msg)<EOL>if self.abort_on_error:<EOL><INDENT>raise EOFError<EOL><DEDENT>return<EOL>", "docstring": "Common routine for reporting debugger error messages.", "id": "f7420:c0:m3"}
{"signature": "def confirm(self, prompt, default):", "body": "while True:<EOL><INDENT>try:<EOL><INDENT>self.write_confirm(prompt, default)<EOL>reply = self.readline('<STR_LIT>').strip().lower()<EOL><DEDENT>except EOFError:<EOL><INDENT>return default<EOL><DEDENT>if reply in ('<STR_LIT:y>', '<STR_LIT:yes>'):<EOL><INDENT>return True<EOL><DEDENT>elif reply in ('<STR_LIT:n>', '<STR_LIT>'):<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>self.msg(\"<STR_LIT>\")<EOL>pass<EOL><DEDENT>pass<EOL><DEDENT>return default<EOL>", "docstring": "Called when a dangerous action is about to be done to make sure\n        it's okay. `prompt' is printed; user response is returned.", "id": "f7421:c0:m2"}
{"signature": "def state(self):", "body": "return self.inout.state<EOL>", "docstring": "Return connected", "id": "f7421:c0:m11"}
{"signature": "def errmsg(self, str, prefix=\"<STR_LIT>\"):", "body": "return self.msg(\"<STR_LIT>\" %(prefix, str))<EOL>", "docstring": "Common routine for reporting debugger error messages.", "id": "f7421:c0:m3"}
{"signature": "def msg(self, msg):", "body": "self.inout.writeline(Mcomcodes.PRINT + msg)<EOL>return<EOL>", "docstring": "used to write to a debugger that is connected to this\n        server; `str' written will have a newline added to it", "id": "f7421:c0:m6"}
{"signature": "def errmsg(self, msg, prefix=\"<STR_LIT>\"):", "body": "return self.msg(\"<STR_LIT>\" %(prefix, msg))<EOL>", "docstring": "Common routine for reporting debugger error messages.", "id": "f7423:c0:m3"}
{"signature": "def close(self):", "body": "try:<EOL><INDENT>self.input.close()<EOL>self.output.close()<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>return<EOL>", "docstring": "Closes both input and output", "id": "f7423:c0:m1"}
{"signature": "def is_dark_rgb(r, g, b):", "body": "try:<EOL><INDENT>midpoint = int(environ.get('<STR_LIT>', None))<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>if not midpoint:<EOL><INDENT>term = environ.get('<STR_LIT>', None)<EOL>print(\"<STR_LIT>\", midpoint, '<STR_LIT>',  (<NUM_LIT:16>*<NUM_LIT:5> + <NUM_LIT:16>*g + <NUM_LIT:16>*b))<EOL>midpoint = <NUM_LIT> if term and term == '<STR_LIT>' else <NUM_LIT><EOL><DEDENT>if ( (<NUM_LIT:16>*<NUM_LIT:5> + <NUM_LIT:16>*g + <NUM_LIT:16>*b) < midpoint ):<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Pass as parameters R G B values in hex\n    On return, variable is_dark_bg is set", "id": "f7426:m1"}
{"signature": "def set_default_bg():", "body": "term = environ.get('<STR_LIT>', None)<EOL>if term:<EOL><INDENT>if (term.startswith('<STR_LIT>',) or term.startswith('<STR_LIT>')<EOL>or term == '<STR_LIT>'):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Get bacground from\n    default values based on the TERM environment variable", "id": "f7426:m0"}
{"signature": "def format(self, show_enabled=True):", "body": "what = '<STR_LIT>'<EOL>if show_enabled:<EOL><INDENT>if self.enabled:<EOL><INDENT>what += '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>what += '<STR_LIT>'<EOL>pass<EOL><DEDENT>pass<EOL><DEDENT>if self.fmt:<EOL><INDENT>what += self.fmt + '<STR_LIT:U+0020>'<EOL>pass<EOL><DEDENT>what += self.arg<EOL>return '<STR_LIT>' % (self.number, what)<EOL>", "docstring": "format display item", "id": "f7430:c1:m2"}
{"signature": "def all(self):", "body": "found = False<EOL>s = []<EOL>for display in self.list:<EOL><INDENT>if not found:<EOL><INDENT>s.append(\"\"\"<STR_LIT>\"\"\")<EOL>found = True<EOL>pass<EOL><DEDENT>s.append(display.format())<EOL><DEDENT>return s<EOL>", "docstring": "List all display items; return 0 if none", "id": "f7430:c0:m2"}
{"signature": "def signature(frame):", "body": "if not frame: return None<EOL>code = frame.f_code<EOL>return (code.co_name, code.co_filename, code.co_firstlineno)<EOL>", "docstring": "return suitable frame signature to key display expressions off of.", "id": "f7430:m0"}
{"signature": "def clear(self):", "body": "self.list = []<EOL>return<EOL>", "docstring": "Delete all display expressions", "id": "f7430:c0:m3"}
{"signature": "def is_compiled_py(filename):", "body": "return True if filename[-<NUM_LIT:4>:].lower() in ('<STR_LIT>', '<STR_LIT>') else False<EOL>", "docstring": "Given a file name, return True if the suffix is pyo or pyc (an\noptimized bytecode file).", "id": "f7434:m1"}
{"signature": "def lookupmodule(name):", "body": "if sys.modules.get(name):<EOL><INDENT>return (sys.modules[name], sys.modules[name].__file__)<EOL><DEDENT>if os.path.isabs(name) and readable(name):<EOL><INDENT>return (None, name)<EOL><DEDENT>f = os.path.join(sys.path[<NUM_LIT:0>], name)<EOL>if readable(f):<EOL><INDENT>return (None, f)<EOL><DEDENT>root, ext = os.path.splitext(name)<EOL>if ext == '<STR_LIT>':<EOL><INDENT>name = name + '<STR_LIT>'<EOL>pass<EOL><DEDENT>if os.path.isabs(name):<EOL><INDENT>return (None, name)<EOL><DEDENT>for dirname in sys.path:<EOL><INDENT>while os.path.islink(dirname):<EOL><INDENT>dirname = os.readlink(dirname)<EOL>pass<EOL><DEDENT>fullname = os.path.join(dirname, name)<EOL>if readable(fullname):<EOL><INDENT>return (None, fullname)<EOL><DEDENT>pass<EOL><DEDENT>return (None, None)<EOL>", "docstring": "lookupmodule()->(module, file) translates a possibly incomplete\n    file or module name into an absolute file name. None can be\n    returned for either of the values positions of module or file when\n    no or module or file is found.", "id": "f7434:m3"}
{"signature": "def checkfuncname(b, frame):", "body": "if not b.funcname:<EOL><INDENT>if b.line != frame.f_lineno:<EOL><INDENT>return False<EOL><DEDENT>return True<EOL><DEDENT>if frame.f_code.co_name != b.funcname:<EOL><INDENT>return False<EOL><DEDENT>if not b.func_first_executable_line:<EOL><INDENT>b.func_first_executable_line = frame.f_lineno<EOL><DEDENT>if b.func_first_executable_line != frame.f_lineno:<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "Check whether we should break here because of `b.funcname`.", "id": "f7435:m0"}
{"signature": "def canonic_filename(self, frame):", "body": "return self.canonic(frame.f_code.co_filename)<EOL>", "docstring": "Picks out the file name from `frame' and returns its\n         canonic() value, a string.", "id": "f7436:c0:m3"}
{"signature": "def start(self, opts=None):", "body": "<EOL>try:<EOL><INDENT>self.trace_hook_suspend = True<EOL>get_option = lambda key: Mmisc.option_set(opts, key,<EOL>default.START_OPTS)<EOL>add_hook_opts = get_option('<STR_LIT>')<EOL>if not tracer.is_started() or get_option('<STR_LIT>'):<EOL><INDENT>tracer_start_opts = default.START_OPTS.copy()<EOL>if opts:<EOL><INDENT>tracer_start_opts.update(opts.get('<STR_LIT>', {}))<EOL><DEDENT>tracer_start_opts['<STR_LIT>'] = self.trace_dispatch<EOL>tracer_start_opts['<STR_LIT>'] = add_hook_opts<EOL>tracer.start(tracer_start_opts)<EOL><DEDENT>elif not tracer.find_hook(self.trace_dispatch):<EOL><INDENT>tracer.add_hook(self.trace_dispatch, add_hook_opts)<EOL>pass<EOL><DEDENT>self.execution_status = '<STR_LIT>'<EOL><DEDENT>finally:<EOL><INDENT>self.trace_hook_suspend = False<EOL><DEDENT>return<EOL>", "docstring": "We've already created a debugger object, but here we start\n        debugging in earnest. We can also turn off debugging (but have\n        the hooks suspended or not) using 'stop'.\n\n        'opts' is a hash of every known value you might want to set when\n        starting the debugger. See START_OPTS of module default.", "id": "f7436:c0:m8"}
{"signature": "def filename(self, filename=None):", "body": "if filename is None:<EOL><INDENT>if self.debugger.mainpyfile:<EOL><INDENT>filename = self.debugger.mainpyfile<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>if self.debugger.settings['<STR_LIT>']:<EOL><INDENT>return(os.path.basename(filename))<EOL><DEDENT>return filename<EOL>", "docstring": "Return filename or the basename of that depending on the\n        basename setting", "id": "f7436:c0:m4"}
{"signature": "def is_stop_here(self, frame, event, arg):", "body": "<EOL>lineno = frame.f_lineno<EOL>filename = frame.f_code.co_filename<EOL>if self.different_line and event == '<STR_LIT>':<EOL><INDENT>if self.last_lineno == lineno and self.last_filename == filename:<EOL><INDENT>return False<EOL><DEDENT>pass<EOL><DEDENT>self.last_lineno   = lineno<EOL>self.last_filename = filename<EOL>if self.stop_level is not None:<EOL><INDENT>if frame != self.last_frame:<EOL><INDENT>self.last_level = Mstack.count_frames(frame)<EOL>self.last_frame = frame<EOL>pass<EOL><DEDENT>if self.last_level > self.stop_level:<EOL><INDENT>return False<EOL><DEDENT>elif self.last_level == self.stop_level andself.stop_on_finish and event in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>self.stop_level = None<EOL>self.stop_reason = \"<STR_LIT>\"<EOL>return True<EOL><DEDENT>pass<EOL><DEDENT>if self._is_step_next_stop(event):<EOL><INDENT>self.stop_reason = '<STR_LIT>'<EOL>return True<EOL><DEDENT>return False<EOL>", "docstring": "Does the magic to determine if we stop here and run a\n        command processor or not. If so, return True and set\n        self.stop_reason; if not, return False.\n\n        Determining factors can be whether a breakpoint was\n        encountered, whether we are stepping, next'ing, finish'ing,\n        and, if so, whether there is an ignore counter.", "id": "f7436:c0:m12"}
{"signature": "def handle(self, signum, frame):", "body": "if self.print_method:<EOL><INDENT>self.print_method('<STR_LIT>'<EOL>% self.signame)<EOL><DEDENT>if self.print_stack:<EOL><INDENT>import traceback<EOL>strings = traceback.format_stack(frame)<EOL>for s in strings:<EOL><INDENT>if s[-<NUM_LIT:1>] == '<STR_LIT:\\n>': s = s[<NUM_LIT:0>:-<NUM_LIT:1>]<EOL>self.print_method(s)<EOL>pass<EOL><DEDENT>pass<EOL><DEDENT>if self.b_stop:<EOL><INDENT>core = self.dbgr.core<EOL>old_trace_hook_suspend = core.trace_hook_suspend<EOL>core.trace_hook_suspend = True<EOL>core.stop_reason = ('<STR_LIT>' %<EOL>(self.signame, signum))<EOL>core.processor.event_processor(frame, '<STR_LIT>', signum)<EOL>core.trace_hook_suspend = old_trace_hook_suspend<EOL>pass<EOL><DEDENT>if self.pass_along:<EOL><INDENT>if self.old_handler:<EOL><INDENT>self.old_handler(signum, frame)<EOL>pass<EOL><DEDENT>pass<EOL><DEDENT>return<EOL>", "docstring": "This method is called when a signal is received.", "id": "f7437:c1:m1"}
{"signature": "def lookup_signum(name):", "body": "uname = name.upper()<EOL>if (uname.startswith('<STR_LIT>') and hasattr(signal, uname)):<EOL><INDENT>return getattr(signal, uname)<EOL><DEDENT>else:<EOL><INDENT>uname = \"<STR_LIT>\"+uname<EOL>if hasattr(signal, uname):<EOL><INDENT>return getattr(signal, uname)<EOL><DEDENT>return None<EOL><DEDENT>return<EOL>", "docstring": "Find the corresponding signal number for 'name'. Return None\n    if 'name' is invalid.", "id": "f7437:m2"}
{"signature": "def handle_ignore(self, signame, set_ignore):", "body": "self.handle_pass(signame, not set_ignore)<EOL>return set_ignore<EOL>", "docstring": "pass' and 'noignore' are synonyms. 'nopass and 'ignore' are\n        synonyms.", "id": "f7437:c0:m12"}
{"signature": "def check_and_adjust_sighandler(self, signame, sigs):", "body": "signum = lookup_signum(signame)<EOL>try:<EOL><INDENT>old_handler = signal.getsignal(signum)<EOL><DEDENT>except ValueError:<EOL><INDENT>if signame in self.sigs:<EOL><INDENT>sigs.pop(signame)<EOL>pass<EOL><DEDENT>return None<EOL><DEDENT>if old_handler != self.sigs[signame].handle:<EOL><INDENT>if old_handler not in [signal.SIG_IGN, signal.SIG_DFL]:<EOL><INDENT>sigs[signame].old_handler = old_handler<EOL>pass<EOL><DEDENT>try:<EOL><INDENT>self._orig_set_signal(signum, self.sigs[signame].handle)<EOL><DEDENT>except ValueError:<EOL><INDENT>return False<EOL><DEDENT>except KeyError:<EOL><INDENT>return False<EOL><DEDENT>pass<EOL><DEDENT>return True<EOL>", "docstring": "Check to see if a single signal handler that we are interested\nin has changed or has not been set initially. On return\nself.sigs[signame] should have our signal handler. True is\nreturned if the same or adjusted, False or None if error or\nnot found.", "id": "f7437:c0:m3"}
{"signature": "def pprint_simple_array(val, displaywidth, msg_nocr, msg, lineprefix='<STR_LIT>'):", "body": "if type(val) != list:<EOL><INDENT>return False<EOL><DEDENT>numeric = True<EOL>for i in range(len(val)):<EOL><INDENT>if not (type(val[i]) in [bool, float, int]):<EOL><INDENT>numeric = False<EOL>if not (type(val[i]) in [bool, float, int, bytes]):<EOL><INDENT>return False<EOL><DEDENT>pass<EOL><DEDENT>pass<EOL><DEDENT>mess = columnize([repr(v) for v in val],<EOL>opts={\"<STR_LIT>\": True,<EOL>\"<STR_LIT>\": lineprefix,<EOL>\"<STR_LIT>\": int(displaywidth)-<NUM_LIT:3>,<EOL>'<STR_LIT>': not numeric})<EOL>msg_nocr(mess)<EOL>return True<EOL>", "docstring": "Try to pretty print a simple case where a list is not nested.\n    Return True if we can do it and False if not.", "id": "f7438:m1"}
{"signature": "def dis(msg, msg_nocr, section, errmsg, x=None, start_line=-<NUM_LIT:1>, end_line=None,<EOL>relative_pos = False, highlight='<STR_LIT>', start_offset=<NUM_LIT:0>, end_offset=None,<EOL>include_header=False):", "body": "lasti = -<NUM_LIT:1><EOL>if x is None:<EOL><INDENT>distb()<EOL>return None, None<EOL><DEDENT>if start_offset is None:<EOL><INDENT>start_offset = <NUM_LIT:0><EOL><DEDENT>mess = '<STR_LIT>'<EOL>if start_line > <NUM_LIT:1>:<EOL><INDENT>mess += \"<STR_LIT>\" % start_line<EOL><DEDENT>elif start_offset > <NUM_LIT:1>:<EOL><INDENT>mess = \"<STR_LIT>\" % start_offset<EOL><DEDENT>if end_line:<EOL><INDENT>mess += \"<STR_LIT>\" % end_line<EOL><DEDENT>elif end_offset:<EOL><INDENT>mess += \"<STR_LIT>\" % end_offset<EOL><DEDENT>sectioned = False<EOL>if hasattr(types, '<STR_LIT>') and isinstance(x, types.InstanceType):<EOL><INDENT>x = x.__class__<EOL><DEDENT>if inspect.ismethod(x):<EOL><INDENT>section(\"<STR_LIT>\" % (x, mess))<EOL>sectioned = True<EOL>x = x.im_func<EOL><DEDENT>elif inspect.isfunction(x) or inspect.isgeneratorfunction(x):<EOL><INDENT>section(\"<STR_LIT>\" % (x, mess))<EOL>x = x.func_code<EOL>sectioned = True<EOL><DEDENT>elif inspect.isgenerator(x):<EOL><INDENT>section(\"<STR_LIT>\" % (x, mess))<EOL>frame = x.gi_frame<EOL>lasti = frame.f_last_i<EOL>x = x.gi_code<EOL>sectioned = True<EOL><DEDENT>elif inspect.isframe(x):<EOL><INDENT>section(\"<STR_LIT>\" % (x, mess))<EOL>sectioned = True<EOL>if hasattr(x, '<STR_LIT>'):<EOL><INDENT>lasti = x.f_lasti<EOL>if lasti == -<NUM_LIT:1>: lasti = <NUM_LIT:0><EOL>pass<EOL><DEDENT>opc = get_opcode(PYTHON_VERSION, IS_PYPY)<EOL>x = x.f_code<EOL>if include_header:<EOL><INDENT>header_lines = Bytecode(x, opc).info().split(\"<STR_LIT:\\n>\")<EOL>header = '<STR_LIT:\\n>'.join([format_token(Mformat.Comment, h) for h in header_lines])<EOL>msg(header)<EOL><DEDENT>pass<EOL><DEDENT>elif inspect.iscode(x):<EOL><INDENT>pass<EOL><DEDENT>if hasattr(x, '<STR_LIT>'):  <EOL><INDENT>items = sorted(x.__dict__.items())<EOL>for name, x1 in items:<EOL><INDENT>if isinstance(x1, _have_code):<EOL><INDENT>if not sectioned:<EOL><INDENT>section(\"<STR_LIT>\" % x)<EOL><DEDENT>try:<EOL><INDENT>dis(msg, msg_nocr, section, errmsg, x1,<EOL>start_line=start_line, end_line=end_line,<EOL>relative_pos = relative_pos)<EOL>msg(\"<STR_LIT>\")<EOL><DEDENT>except TypeError:<EOL><INDENT>_, msg, _ = sys.exc_info()<EOL>errmsg(\"<STR_LIT>\", msg)<EOL>pass<EOL><DEDENT>pass<EOL><DEDENT>pass<EOL><DEDENT>pass<EOL><DEDENT>elif hasattr(x, '<STR_LIT>'):  <EOL><INDENT>if not sectioned:<EOL><INDENT>section(\"<STR_LIT>\" % x)<EOL><DEDENT>return disassemble(msg, msg_nocr, section, x, lasti=lasti,<EOL>start_line=start_line, end_line=end_line,<EOL>relative_pos = relative_pos,<EOL>highlight = highlight,<EOL>start_offset = start_offset,<EOL>end_offset = end_offset)<EOL><DEDENT>elif isinstance(x, str):    <EOL><INDENT>return disassemble_string(msg, msg_nocr, x,)<EOL><DEDENT>else:<EOL><INDENT>errmsg(\"<STR_LIT>\" %<EOL>type(x).__name__)<EOL><DEDENT>return None, None<EOL>", "docstring": "Disassemble classes, methods, functions, or code.\n\n    With no argument, disassemble the last traceback.", "id": "f7440:m1"}
{"signature": "def is_exec_stmt(frame):", "body": "return hasattr(frame, '<STR_LIT>') and get_call_function_name(frame) == '<STR_LIT>'<EOL>", "docstring": "Return True if we are looking at an exec statement", "id": "f7441:m6"}
{"signature": "def print_stack_trace(proc_obj, count=None, color='<STR_LIT>', opts={}):", "body": "if count is None:<EOL><INDENT>n=len(proc_obj.stack)<EOL><DEDENT>else:<EOL><INDENT>n=min(len(proc_obj.stack), count)<EOL><DEDENT>try:<EOL><INDENT>for i in range(n):<EOL><INDENT>print_stack_entry(proc_obj, i, color=color, opts=opts)<EOL><DEDENT><DEDENT>except KeyboardInterrupt:<EOL><INDENT>pass<EOL><DEDENT>return<EOL>", "docstring": "Print count entries of the stack trace", "id": "f7441:m9"}
{"signature": "def next_opcode(code, offset):", "body": "n = len(code)<EOL>while offset < n:<EOL><INDENT>op = code[offset]<EOL>offset += <NUM_LIT:1><EOL>if op >= HAVE_ARGUMENT:<EOL><INDENT>offset += <NUM_LIT:2><EOL>pass<EOL><DEDENT>yield op, offset<EOL>pass<EOL><DEDENT>yield -<NUM_LIT:100>, -<NUM_LIT:1000><EOL>pass<EOL>", "docstring": "Return the next opcode and offset as a tuple. Tuple (-100,\n    -1000) is returned when reaching the end.", "id": "f7442:m2"}
{"signature": "def is_class_def(line, frame):", "body": "return (line and _re_class.match(line)<EOL>and stmt_contains_opcode(frame.f_code, frame.f_lineno,<EOL>'<STR_LIT>'))<EOL>", "docstring": "Return True if we are looking at a class definition statement", "id": "f7442:m6"}
{"signature": "def msg_nocr(self, msg):", "body": "self.output.write(msg)<EOL>return<EOL>", "docstring": "used to write to a debugger that is connected to this\n        server; `str' written will not have a newline added to it", "id": "f7444:c0:m6"}
{"signature": "def msg(self, msg):", "body": "if hasattr(self.output, '<STR_LIT>'):<EOL><INDENT>self.output.writeline(msg)<EOL><DEDENT>elif hasattr(self.output, '<STR_LIT>'):<EOL><INDENT>self.output.writelines(msg + \"<STR_LIT:\\n>\")<EOL>pass<EOL><DEDENT>return<EOL>", "docstring": "used to write to a debugger that is connected to this\n        server; `str' written will have a newline added to it", "id": "f7444:c0:m5"}
{"signature": "def _populate_cmd_lists(self):", "body": "self.commands = {}<EOL>for cmd_instance in self.cmd_instances:<EOL><INDENT>cmd_name = cmd_instance.name<EOL>self.commands[cmd_name] = cmd_instance<EOL>pass<EOL><DEDENT>return<EOL>", "docstring": "Populate self.commands", "id": "f7447:c0:m15"}
{"signature": "def setup(self):", "body": "self.forget()<EOL>if self.settings('<STR_LIT>'):<EOL><INDENT>self.frame = inspect.currentframe()<EOL>pass<EOL><DEDENT>if self.event in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>exc_type, exc_value, exc_traceback = self.event_arg<EOL><DEDENT>else:<EOL><INDENT>_, _, exc_traceback = (None, None, None,)  <EOL>pass<EOL><DEDENT>if self.frame or exc_traceback:<EOL><INDENT>self.stack, self.curindex =get_stack(self.frame, exc_traceback, None, self)<EOL>self.curframe = self.stack[self.curindex][<NUM_LIT:0>]<EOL>self.thread_name = Mthread.current_thread_name()<EOL><DEDENT>else:<EOL><INDENT>self.stack = self.curframe =self.botframe = None<EOL>pass<EOL><DEDENT>if self.curframe:<EOL><INDENT>self.list_lineno =max(<NUM_LIT:1>, inspect.getlineno(self.curframe))<EOL><DEDENT>else:<EOL><INDENT>self.list_lineno = None<EOL>pass<EOL><DEDENT>return False<EOL>", "docstring": "Initialization done before entering the debugger-command\n        loop. In particular we set up the call stack used for local\n        variable lookup and frame/up/down commands.\n\n        We return True if we should NOT enter the debugger-command\n        loop.", "id": "f7447:c0:m12"}
{"signature": "def run(self, args):", "body": "raise NotImplementedError(NotImplementedMessage)<EOL>", "docstring": "The method that implements the debugger command.\n        Help on the command comes from the docstring of this method.", "id": "f7449:c0:m4"}
{"signature": "def nothread_quit(self, arg):", "body": "self.debugger.core.stop()<EOL>self.debugger.core.execution_status = '<STR_LIT>'<EOL>self.proc.response['<STR_LIT>'] = '<STR_LIT>'<EOL>self.proc.response['<STR_LIT:name>']  = '<STR_LIT:status>'<EOL>self.proc.intf[-<NUM_LIT:1>].msg(self.proc.response)<EOL>raise Mexcept.DebuggerQuit<EOL>", "docstring": "quit command when there's just one thread.", "id": "f7450:c0:m0"}
{"signature": "def run_call(func, debug_opts=None, start_opts=None, *args, **kwds):", "body": "dbg = Mdebugger.Trepan(opts=debug_opts)<EOL>try:<EOL><INDENT>return dbg.run_call(func, start_opts, *args, **kwds)<EOL><DEDENT>except:<EOL><INDENT>Mpost_mortem.uncaught_exception(dbg)<EOL>pass<EOL><DEDENT>return<EOL>", "docstring": "Call the function (a function or method object, not a string)\n    with the given arguments starting with the statement subsequent to\n    the place that this appears in your program.\n\n    When run_call() returns, it returns whatever the function call\n    returned.  The debugger prompt appears as soon as the function is\n    entered.", "id": "f7455:m2"}
{"signature": "def file2module(filename):", "body": "basename = osp.basename(filename)<EOL>if '<STR_LIT:.>' in basename:<EOL><INDENT>pos = basename.rfind('<STR_LIT:.>')<EOL>return basename[:pos]<EOL><DEDENT>else:<EOL><INDENT>return basename<EOL><DEDENT>return None<EOL>", "docstring": "Given a file name, extract the most likely module name.", "id": "f7456:m1"}
{"signature": "def whence_file(py_script, dirnames=None):", "body": "if py_script.find(os.sep) != -<NUM_LIT:1>:<EOL><INDENT>return py_script<EOL><DEDENT>if dirnames is None:<EOL><INDENT>dirnames = os.environ['<STR_LIT>'].split(os.pathsep)<EOL><DEDENT>for dirname in dirnames:<EOL><INDENT>py_script_try = osp.join(dirname, py_script)<EOL>if osp.exists(py_script_try):<EOL><INDENT>return py_script_try<EOL><DEDENT><DEDENT>return py_script<EOL>", "docstring": "Do a shell-like path lookup for py_script and return the results.\n    If we can't find anything return py_script", "id": "f7456:m3"}
{"signature": "def msg(self, msg, opts={}):", "body": "return(self.intf[-<NUM_LIT:1>].msg(msg))<EOL>", "docstring": "Convenience short-hand for self.debugger.intf[-1].msg", "id": "f7457:c0:m2"}
{"signature": "def grouper(iterable, n, fillvalue=None):", "body": "return list(zip_longest(*[iter(iterable)] * n, fillvalue=fillvalue))<EOL>", "docstring": "Group iterable by n elements.\n\n    >>> for t in grouper('abcdefg', 3, fillvalue='x'):\n    ...     print(''.join(t))\n    abc\n    def\n    gxx", "id": "f7460:m0"}
{"signature": "def _compute_missing_rates(self, currency):", "body": "rates = self._rates[currency]<EOL>tmp = defaultdict(lambda: [None, None])<EOL>for date in sorted(rates):<EOL><INDENT>rate = rates[date]<EOL>if rate is not None:<EOL><INDENT>closest_rate = rate<EOL>dist = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>dist += <NUM_LIT:1><EOL>tmp[date][<NUM_LIT:0>] = closest_rate, dist<EOL><DEDENT><DEDENT>for date in sorted(rates, reverse=True):<EOL><INDENT>rate = rates[date]<EOL>if rate is not None:<EOL><INDENT>closest_rate = rate<EOL>dist = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>dist += <NUM_LIT:1><EOL>tmp[date][<NUM_LIT:1>] = closest_rate, dist<EOL><DEDENT><DEDENT>for date in sorted(tmp):<EOL><INDENT>(r0, d0), (r1, d1) = tmp[date]<EOL>rates[date] = (r0 * d1 + r1 * d0) / (d0 + d1)<EOL>if self.verbose:<EOL><INDENT>print(('<STR_LIT>'<EOL>'<STR_LIT>').format(currency, date, r0, d0, r1, d1))<EOL><DEDENT><DEDENT>", "docstring": "Fill missing rates of a currency.\n\n        This is done by linear interpolation of the two closest available rates.\n\n        :param str currency: The currency to fill missing rates for.", "id": "f7462:c1:m5"}
{"signature": "def _get_rate(self, currency, date):", "body": "if currency == self.ref_currency:<EOL><INDENT>return <NUM_LIT:1.0><EOL><DEDENT>if date not in self._rates[currency]:<EOL><INDENT>first_date, last_date = self.bounds[currency]<EOL>if not self.fallback_on_wrong_date:<EOL><INDENT>raise RateNotFoundError('<STR_LIT>'.format(<EOL>date, currency, first_date, last_date))<EOL><DEDENT>if date < first_date:<EOL><INDENT>fallback_date = first_date<EOL><DEDENT>elif date > last_date:<EOL><INDENT>fallback_date = last_date<EOL><DEDENT>else:<EOL><INDENT>raise AssertionError('<STR_LIT>')<EOL><DEDENT>if self.verbose:<EOL><INDENT>print(r'<STR_LIT>'.format(<EOL>date, currency, first_date, last_date, fallback_date))<EOL><DEDENT>date = fallback_date<EOL><DEDENT>rate = self._rates[currency][date]<EOL>if rate is None:<EOL><INDENT>raise RateNotFoundError('<STR_LIT>'.format(currency, date))<EOL><DEDENT>return rate<EOL>", "docstring": "Get a rate for a given currency and date.\n\n        :type date: datetime.date\n\n        >>> from datetime import date\n        >>> c = CurrencyConverter()\n        >>> c._get_rate('USD', date=date(2014, 3, 28))\n        1.375...\n        >>> c._get_rate('BGN', date=date(2010, 11, 21))\n        Traceback (most recent call last):\n        RateNotFoundError: BGN has no rate for 2010-11-21", "id": "f7462:c1:m6"}
{"signature": "def _set_missing_to_none(self, currency):", "body": "rates = self._rates[currency]<EOL>first_date, last_date = self.bounds[currency]<EOL>for date in list_dates_between(first_date, last_date):<EOL><INDENT>if date not in rates:<EOL><INDENT>rates[date] = None<EOL><DEDENT><DEDENT>if self.verbose:<EOL><INDENT>missing = len([r for r in itervalues(rates) if r is None])<EOL>if missing:<EOL><INDENT>print('<STR_LIT>'.format(<EOL>currency, missing, first_date, last_date,<EOL><NUM_LIT:1> + (last_date - first_date).days))<EOL><DEDENT><DEDENT>", "docstring": "Fill missing rates of a currency with the closest available ones.", "id": "f7462:c1:m4"}
{"signature": "def _format_lazy(value):", "body": "args = value._proxy____args<EOL>kw = value._proxy____kw<EOL>if not kw and len(args) == <NUM_LIT:1> and isinstance(args[<NUM_LIT:0>], six.string_types):<EOL><INDENT>return LiteralStr(u'<STR_LIT>'.format(repr(value._proxy____args[<NUM_LIT:0>])))<EOL><DEDENT>return value<EOL>", "docstring": "Expand a _(\"TEST\") call to something meaningful.", "id": "f7468:m9"}
{"signature": "def _format_object(object):", "body": "attrs = iter(object.__dict__.items())<EOL>if object.__class__:<EOL><INDENT>attrs = chain(attrs, iter(object.__class__.__dict__.items()))<EOL><DEDENT>is_model = isinstance(object, Model)<EOL>is_form = isinstance(object, BaseForm)<EOL>attrs = dict(<EOL>(k, v)<EOL>for k, v in attrs<EOL>if not k.startswith('<STR_LIT:_>')<EOL>and not getattr(v, '<STR_LIT>', False)<EOL>and not (is_model and k in ('<STR_LIT>', '<STR_LIT>'))<EOL>and not (is_form and k in ('<STR_LIT:Meta>',))<EOL>)<EOL>for member in dir(object):<EOL><INDENT>try:<EOL><INDENT>if member.startswith('<STR_LIT:_>') or not hasattr(object, member):<EOL><INDENT>continue<EOL><DEDENT><DEDENT>except HANDLED_EXCEPTIONS as e:<EOL><INDENT>attrs[member] = _format_exception(e)<EOL>continue<EOL><DEDENT>value = getattr(object, member)<EOL>if callable(value) or member in attrs or getattr(value, '<STR_LIT>', False):<EOL><INDENT>continue<EOL><DEDENT>attrs[member] = value<EOL><DEDENT>for name, value in list(attrs.items()):  <EOL><INDENT>if isinstance(value, property):<EOL><INDENT>attrs[name] = _try_call(lambda: getattr(object, name))<EOL><DEDENT>elif isinstance(value, types.FunctionType):<EOL><INDENT>if PY3:<EOL><INDENT>spec = inspect.getfullargspec(value)<EOL><DEDENT>else:<EOL><INDENT>spec = inspect.getargspec(value)<EOL><DEDENT>if len(spec.args) == <NUM_LIT:1> or len(spec.args) == len(spec.defaults or ()) + <NUM_LIT:1>:<EOL><INDENT>if _is_unsafe_name(name):<EOL><INDENT>attrs[name] = LiteralStr('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>attrs[name] = _try_call(lambda: value(object))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>del attrs[name]<EOL><DEDENT><DEDENT>elif hasattr(value, '<STR_LIT>'):<EOL><INDENT>attrs[name] = value = _try_call(lambda: getattr(object, name), return_exceptions=True)<EOL>if isinstance(value, Manager):<EOL><INDENT>attrs[name] = LiteralStr('<STR_LIT>'.format(value.__class__.__name__))<EOL><DEDENT>elif isinstance(value, AttributeError):<EOL><INDENT>del attrs[name]  <EOL><DEDENT>elif isinstance(value, HANDLED_EXCEPTIONS):<EOL><INDENT>attrs[name] = _format_exception(value)<EOL><DEDENT><DEDENT><DEDENT>if getattr(object, '<STR_LIT>', None) is not object.__str__:<EOL><INDENT>attrs['<STR_LIT>'] = _try_call(lambda: smart_str(object))<EOL><DEDENT>elif getattr(object, '<STR_LIT>', None) is not object.__unicode__:<EOL><INDENT>attrs['<STR_LIT>'] = _try_call(lambda: smart_str(object))<EOL><DEDENT>if hasattr(object, '<STR_LIT>'):<EOL><INDENT>attrs['<STR_LIT>'] = LiteralStr('<STR_LIT>')<EOL><DEDENT>if hasattr(object, '<STR_LIT>'):<EOL><INDENT>attrs['<STR_LIT>'] = LiteralStr('<STR_LIT>')<EOL><DEDENT>if hasattr(object, '<STR_LIT>'):<EOL><INDENT>attrs['<STR_LIT>'] = LiteralStr('<STR_LIT>')<EOL><DEDENT>if hasattr(object, '<STR_LIT>'):<EOL><INDENT>attrs['<STR_LIT>'] = len(object)<EOL><DEDENT>if isinstance(object, BaseForm):<EOL><INDENT>for field_name in list(object.fields.keys()):<EOL><INDENT>attrs[field_name] = object[field_name]<EOL><DEDENT>del attrs['<STR_LIT>']<EOL><DEDENT>return _format_dict(attrs)<EOL>", "docstring": "# Instead of just printing <SomeType at 0xfoobar>, expand the fields.", "id": "f7468:m4"}
{"signature": "def pformat_django_context_html(object):", "body": "if isinstance(object, QuerySet):<EOL><INDENT>text = '<STR_LIT>'<EOL>lineno = <NUM_LIT:0><EOL>for item in object.all()[:<NUM_LIT>]:<EOL><INDENT>lineno += <NUM_LIT:1><EOL>if lineno >= <NUM_LIT>:<EOL><INDENT>text += u'<STR_LIT>'<EOL>break<EOL><DEDENT>text += u'<STR_LIT>'.format(escape(repr(item)))<EOL><DEDENT>return text<EOL><DEDENT>elif isinstance(object, Manager):<EOL><INDENT>return mark_safe(u'<STR_LIT>')<EOL><DEDENT>elif isinstance(object, six.string_types):<EOL><INDENT>return escape(repr(object))<EOL><DEDENT>elif isinstance(object, Promise):<EOL><INDENT>return escape(_format_lazy(object))<EOL><DEDENT>elif isinstance(object, dict):<EOL><INDENT>return _format_dict(object)<EOL><DEDENT>elif isinstance(object, list):<EOL><INDENT>return _format_list(object)<EOL><DEDENT>elif hasattr(object, '<STR_LIT>'):<EOL><INDENT>return _format_object(object)<EOL><DEDENT>else:<EOL><INDENT>text = DebugPrettyPrinter(width=<NUM_LIT:200>).pformat(object)<EOL>return _style_text(text)<EOL><DEDENT>", "docstring": "Dump a variable to a HTML string with sensible output for template context fields.\nIt filters out all fields which are not usable in a template context.", "id": "f7468:m1"}
{"signature": "def _format(self, object, stream, indent, allowance, context, level):", "body": "try:<EOL><INDENT>PrettyPrinter._format(self, object, stream, indent, allowance, context, level)<EOL><DEDENT>except Exception as e:<EOL><INDENT>stream.write(_format_exception(e))<EOL><DEDENT>", "docstring": "Recursive part of the formatting", "id": "f7468:c1:m2"}
{"signature": "def _try_call(func, extra_exceptions=(), return_exceptions=False):", "body": "try:<EOL><INDENT>return func()<EOL><DEDENT>except HANDLED_EXCEPTIONS as e:<EOL><INDENT>if return_exceptions:<EOL><INDENT>return e<EOL><DEDENT>else:<EOL><INDENT>return _format_exception(e)<EOL><DEDENT><DEDENT>except extra_exceptions as e:<EOL><INDENT>if return_exceptions:<EOL><INDENT>return e<EOL><DEDENT>else:<EOL><INDENT>return _format_exception(e)<EOL><DEDENT><DEDENT>", "docstring": "Call a method, but\n:param func:\n:type func:\n:param extra_exceptions:\n:type extra_exceptions:\n:return:\n:rtype:", "id": "f7468:m12"}
{"signature": "def get_used_template(response):", "body": "if not hasattr(response, '<STR_LIT>'):<EOL><INDENT>return None, None<EOL><DEDENT>template = response.template_name<EOL>if template is None:<EOL><INDENT>return None, None<EOL><DEDENT>if isinstance(template, (list, tuple)):<EOL><INDENT>if len(template) == <NUM_LIT:1>:<EOL><INDENT>return template[<NUM_LIT:0>], None<EOL><DEDENT>else:<EOL><INDENT>used_name = _get_used_template_name(template)<EOL>return used_name, template<EOL><DEDENT><DEDENT>elif isinstance(template, six.string_types):<EOL><INDENT>return template, None<EOL><DEDENT>else:<EOL><INDENT>filename = _get_template_filename(template)<EOL>template_name = '<STR_LIT>'.format(filename) if filename else '<STR_LIT>'<EOL>return template_name, None<EOL><DEDENT>", "docstring": "Get the template used in a TemplateResponse.\nThis returns a tuple of \"active choice, all choices\"", "id": "f7471:m3"}
{"signature": "def _get_view_data(self, context_data):", "body": "view = context_data.get('<STR_LIT>')<EOL>if not isinstance(view, View):<EOL><INDENT>view = None<EOL><DEDENT>template_context = []<EOL>for key, obj in context_data.items():<EOL><INDENT>if isinstance(obj, (BaseForm, BaseFormSet, Model)):<EOL><INDENT>template_context.append((key, _format_path(obj.__class__)))<EOL><DEDENT><DEDENT>return {<EOL>'<STR_LIT>': _get_view_model(view),<EOL>'<STR_LIT>': _get_form_class(view),<EOL>'<STR_LIT>': template_context,<EOL>}<EOL>", "docstring": "Extract the used view from the TemplateResponse context (ContextMixin)", "id": "f7473:c0:m3"}
{"signature": "def csv(self, filename=None, **format_params):", "body": "if not self.pretty:<EOL><INDENT>return None  <EOL><DEDENT>if filename:<EOL><INDENT>outfile = open(filename, '<STR_LIT:w>')<EOL><DEDENT>else:<EOL><INDENT>outfile = StringIO()<EOL><DEDENT>writer = UnicodeWriter(outfile, **format_params)<EOL>writer.writerow(self.field_names)<EOL>for row in self:<EOL><INDENT>writer.writerow(row)<EOL><DEDENT>if filename:<EOL><INDENT>outfile.close()<EOL>return CsvResultDescriptor(filename)<EOL><DEDENT>else:<EOL><INDENT>return outfile.getvalue()<EOL><DEDENT>", "docstring": "Generates results in comma-separated form.  Write to ``filename``\n        if given. Any other parameter will be passed on to ``csv.writer``.\n\n        :param filename: if given, the CSV will be written to filename.\n\n        Any additional keyword arguments will be passsed\n        through to ``csv.writer``.", "id": "f7480:c2:m12"}
{"signature": "def plot(self, title=None, **kwargs):", "body": "if not plt:<EOL><INDENT>raise ImportError(\"<STR_LIT>\")<EOL><DEDENT>self.guess_plot_columns()<EOL>self.x = self.x or range(len(self.ys[<NUM_LIT:0>]))<EOL>coords = reduce(operator.add, [(self.x, y) for y in self.ys])<EOL>plot = plt.plot(*coords, **kwargs)<EOL>if hasattr(self.x, '<STR_LIT:name>'):<EOL><INDENT>plt.xlabel(self.x.name)<EOL><DEDENT>ylabel = \"<STR_LIT:U+002CU+0020>\".join(y.name for y in self.ys)<EOL>plt.title(title or ylabel)<EOL>plt.ylabel(ylabel)<EOL>return plot<EOL>", "docstring": "Generates a pylab plot from the result set.\n\n        ``matplotlib`` must be installed, and in an\n        IPython Notebook, inlining must be on::\n\n            %%matplotlib inline\n\n        The first and last columns are taken as the X and Y\n        values.  Any columns between are ignored.\n\n        :param title: plot title, defaults to names of Y value columns\n\n        Any additional keyword arguments will be passsed\n        through to ``matplotlib.pylab.plot``.", "id": "f7480:c2:m10"}
{"signature": "def __str__(self, *arg, **kwarg):", "body": "return str(self.pretty or '<STR_LIT>')<EOL>", "docstring": "String representation of a ``ResultSet``.", "id": "f7480:c2:m2"}
{"signature": "def interpret_stats(results):", "body": "stats = results.stats<EOL>contains_updates = stats.pop(\"<STR_LIT>\", False) if stats else False<EOL>if not contains_updates:<EOL><INDENT>result = '<STR_LIT>'.format(len(results))<EOL><DEDENT>else:<EOL><INDENT>result = '<STR_LIT>'<EOL>for stat, value in stats.items():<EOL><INDENT>if value:<EOL><INDENT>result = \"<STR_LIT>\".format(result, value,<EOL>stat.replace(\"<STR_LIT:_>\", \"<STR_LIT:U+0020>\"))<EOL><DEDENT><DEDENT><DEDENT>return result.strip()<EOL>", "docstring": "Generates the string to be shown as updates after the execution of a\n    Cypher query\n\n    :param results: ``ResultSet`` with the raw results of the execution of\n                    the Cypher query", "id": "f7480:m1"}
{"signature": "def draw(self, directed=True, layout=\"<STR_LIT>\",<EOL>node_label_attr=None, show_node_labels=True,<EOL>edge_label_attr=None, show_edge_labels=True,<EOL>node_size=<NUM_LIT>, node_color='<STR_LIT>', node_alpha=<NUM_LIT>,<EOL>node_text_size=<NUM_LIT:12>,<EOL>edge_color='<STR_LIT>', edge_alpha=<NUM_LIT>, edge_tickness=<NUM_LIT:1>,<EOL>edge_text_pos=<NUM_LIT>,<EOL>text_font='<STR_LIT>', ax=None):", "body": "graph = self.get_graph(directed=directed)<EOL>pos = getattr(nx, \"<STR_LIT>\".format(layout))(graph)<EOL>node_labels = {}<EOL>edge_labels = {}<EOL>node_colors = set()<EOL>if show_node_labels:<EOL><INDENT>for node, props in graph.nodes(data=True):<EOL><INDENT>labels = props.pop('<STR_LIT>', [])<EOL>for label in labels:<EOL><INDENT>node_colors.add(label)<EOL><DEDENT>if node_label_attr is None:<EOL><INDENT>node_labels[node] = \"<STR_LIT>\".format(<EOL>\"<STR_LIT::>\".join(labels),<EOL>next(iter(props.values())) if props else \"<STR_LIT>\",<EOL>)<EOL><DEDENT>else:<EOL><INDENT>props_list = [\"<STR_LIT>\".format(k, v)<EOL>for k, v in props.items()]<EOL>node_labels[node] = \"<STR_LIT>\".format(<EOL>\"<STR_LIT::>\".join(labels), \"<STR_LIT:\\n>\".join(props_list)<EOL>)<EOL><DEDENT><DEDENT><DEDENT>node_color = []<EOL>node_colors = list(node_colors)<EOL>legend_colors = []<EOL>colors = list(plt.matplotlib.colors.ColorConverter().cache.items())[<NUM_LIT:2>:]<EOL>for _, color_rgb in colors[:len(node_colors)]:<EOL><INDENT>node_color.append(color_rgb)<EOL>legend_colors.append(color_rgb)<EOL><DEDENT>if show_edge_labels:<EOL><INDENT>for start, end, props in graph.edges(data=True):<EOL><INDENT>if edge_label_attr is None:<EOL><INDENT>edge_label = props.get(\"<STR_LIT:type>\", '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>edge_label = props.get(edge_label_attr, '<STR_LIT>')<EOL><DEDENT>edge_labels[(start, end)] = edge_label<EOL><DEDENT><DEDENT>if not ax:<EOL><INDENT>fig = plt.figure()<EOL>ax = fig.add_subplot(<NUM_LIT>)<EOL><DEDENT>nodes = nx.draw_networkx_nodes(<EOL>graph, pos=pos, node_color=node_color,<EOL>node_size=node_size, alpha=node_alpha,<EOL>ax=ax<EOL>)<EOL>nx.draw_networkx_labels(<EOL>graph, pos=pos, labels=node_labels,<EOL>font_size=node_text_size,<EOL>font_family=text_font,<EOL>ax=ax<EOL>)<EOL>nx.draw_networkx_edges(<EOL>graph, pos=pos, width=edge_tickness,<EOL>alpha=edge_alpha, edge_color=edge_color,<EOL>ax=ax<EOL>)<EOL>nx.draw_networkx_edge_labels(<EOL>graph, pos=pos, edge_labels=edge_labels,<EOL>ax=ax<EOL>)<EOL>ax.legend([plt.Line2D([<NUM_LIT:0>], [<NUM_LIT:0>], linestyle=\"<STR_LIT:none>\", marker=\"<STR_LIT:o>\",<EOL>alpha=node_alpha,<EOL>markersize=<NUM_LIT:10>, markerfacecolor=color)<EOL>for color in legend_colors],<EOL>node_colors, loc=(-<NUM_LIT>, <NUM_LIT:1>), numpoints=<NUM_LIT:1>, frameon=False)<EOL>ax.set_axis_off()<EOL>return graph, ax, nodes<EOL>", "docstring": "Plot of a NetworkX multi-graph instance\n\n        :param directed: boolean, optional (default=`True`).\n            Whether to return a directed graph or not.\n        :param layout: string, optional (default=`\"spring\"`).\n            Layout to apply. Any of the possible NetworkX layouts will work:\n            ``'circular_layout'``, ``'random_layout'``, ``'shell_layout'``,\n            ``'spring_layout'``, ``'spectral_layout'``,\n            or ``'fruchterman_reingold_layout'``.\n        :param node_label_attr: string, optional (default=`None`).\n            Attribute of the nodes that has to be used as the label.\n        :param show_node_labels: boolean, optional (default=`True`).\n            Whether to show or not the labels of the nodes.\n        :param edge_label_attr: boolean, optional (default=`None`).\n            Attribute of the edges that has to be used as the label.\n        :param show_edge_labels: . optional (default=`True`).\n            Whether to show or not the labels of the edges.\n        :param node_size: integer, optional (default=`1600`).\n            Desired size for nodes.\n        :param node_color: color string, or array of floats, (default=`'blue'`)\n            Node color. Can be a single color format string, or a sequence of\n            colors with the same length as nodelist. If numeric values are\n            specified they will be mapped to colors using the ``cmap`` and\n            ``vmin``, ``vmax`` parameters. See ``matplotlib.scatter`` for more\n            details.\n        :param node_alpha: float, optional (default=`0.3`).\n            Between 0 and 1 for transparency of nodes.\n        :param node_text_size: integer, optional (default=`12`).\n            Size of the node text.\n        :param edge_color: color string, or array of floats (default=`'blue'`)\n            Edge color. Can be a single color format string, or a sequence of\n            colors with the same length as edgelist. If numeric values are\n            specified they will be mapped to colors using the ``edge_cmap`` and\n            ``edge_vmin``, ``edge_vmax`` parameters.\n        :param edge_alpha: float, optional (default=`0.3`)\n            Transparency for thee edges.\n        :param edge_tickness: float or integer, optional (default=`1`).\n            Thickness of the lines drawn for the edges.\n        :param edge_text_pos: . Default to optional (d0)=\n        :param text_font: . Default to optional (default=`'sans-serif'`).\n        :param ax: ``matplotlib.Figure``, optional (default=`None`).\n            A ``matplotlib.Figure`` to use when rendering the graph. If `None`,\n            a new object is created and returned.----\n\n        :return: a ``matplotlib.Figure`` with the graph rendered.", "id": "f7480:c2:m8"}
{"signature": "def clear(self):", "body": "with self._lock:<EOL><INDENT>try:<EOL><INDENT>del self._data_store[:]<EOL><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>", "docstring": "Clears all data associated with the mappers data store", "id": "f7503:c0:m7"}
{"signature": "def s_add(self, path, function, method=None, type_cast=None):", "body": "with self._lock:<EOL><INDENT>try:<EOL><INDENT>path = '<STR_LIT>'.format(path.lstrip('<STR_LIT:/>'))<EOL>path = '<STR_LIT>'.format(path.rstrip('<STR_LIT:/>'))<EOL>path = path.replace('<STR_LIT:<>', '<STR_LIT>')<EOL>path = path.replace('<STR_LIT:>>', '<STR_LIT>')<EOL>self.add(path, function, method, type_cast)<EOL><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>", "docstring": "Function for registering a simple path.\n\n        Args:\n            path (str): Path to be matched.\n            function (function): Function to associate with this path.\n            method (str, optional): Usually used to define one of GET, POST,\n                PUT, DELETE. You may use whatever fits your situation though.\n                Defaults to None.\n            type_cast (dict, optional): Mapping between the param name and\n                one of `int`, `float` or `bool`. The value reflected by the\n                provided param name will than be casted to the given type.\n                Defaults to None.", "id": "f7503:c0:m6"}
{"signature": "def __init__(self):", "body": "self._lock = threading.RLock()<EOL>self._data_store = list()<EOL>", "docstring": "Create a new mapper instance.\n           Using `Mapper.get()`_ is the prefered way.", "id": "f7503:c0:m0"}
{"signature": "@property<EOL><INDENT>def first_item_number(self):<DEDENT>", "body": "return self.offset + <NUM_LIT:1><EOL>", "docstring": ":return: The first \"item number\", used when displaying messages to the user\nlike \"Displaying items 1 to 10 of 123\" - in this example 1 would be returned", "id": "f7518:c0:m14"}
{"signature": "def get_full_page_url(self, page_number, scheme=None):", "body": "args = dict(<EOL>request.view_args,<EOL>_external=True,<EOL>)<EOL>if scheme is not None:<EOL><INDENT>args['<STR_LIT>'] = scheme<EOL><DEDENT>if page_number != <NUM_LIT:1>:<EOL><INDENT>args['<STR_LIT>'] = page_number<EOL><DEDENT>return url_for(request.endpoint, **args)<EOL>", "docstring": "Get the full, external URL for this page, optinally with the passed in URL scheme", "id": "f7518:c0:m9"}
{"signature": "def format_commas(number):", "body": "if number is None:<EOL><INDENT>return None<EOL><DEDENT>return '<STR_LIT>'.format(number)<EOL>", "docstring": "Rounds a number and formats it with commas i.e. 123,456,789", "id": "f7519:m10"}
{"signature": "def is_uk_mobile_number(phone_number):", "body": "stripped = phone_number.replace('<STR_LIT:U+0020>', '<STR_LIT>')<EOL>return stripped.startswith('<STR_LIT>') or stripped.startswith('<STR_LIT>')<EOL>", "docstring": "Is the passed in phone number a uk mobile number", "id": "f7519:m29"}
{"signature": "def format_phone_number(phone_number):", "body": "if phone_number is None:<EOL><INDENT>return None<EOL><DEDENT>return PHONE_NUMBER_DISALLOWED_SYMBOLS.sub('<STR_LIT>', phone_number)<EOL>", "docstring": "Removes unnecessary symbols from phone numbers", "id": "f7519:m15"}
{"signature": "def make_csv_response(csv_data, filename):", "body": "resp = make_response(csv_data)<EOL>resp.headers['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>resp.headers['<STR_LIT>'] = '<STR_LIT>' % filename<EOL>return resp<EOL>", "docstring": ":param csv_data: A string with the contents of a csv file in it\n:param filename: The filename that the file will be saved as when it is downloaded by the user\n:return: The response to return to the web connection", "id": "f7519:m18"}
{"signature": "def remove_namespaces(root):", "body": "for elem in root.getiterator():<EOL><INDENT>if not hasattr(elem.tag, '<STR_LIT>'):<EOL><INDENT>continue<EOL><DEDENT>i = elem.tag.find('<STR_LIT:}>')<EOL>if i >= <NUM_LIT:0>:<EOL><INDENT>elem.tag = elem.tag[i + <NUM_LIT:1>:]<EOL><DEDENT><DEDENT>objectify.deannotate(root, cleanup_namespaces=True)<EOL>", "docstring": "Call this on an lxml.etree document to remove all namespaces", "id": "f7520:m0"}
{"signature": "def add_months_to_date(months, date):", "body": "month = date.month<EOL>new_month = month + months<EOL>years = <NUM_LIT:0><EOL>while new_month < <NUM_LIT:1>:<EOL><INDENT>new_month += <NUM_LIT:12><EOL>years -= <NUM_LIT:1><EOL><DEDENT>while new_month > <NUM_LIT:12>:<EOL><INDENT>new_month -= <NUM_LIT:12><EOL>years += <NUM_LIT:1><EOL><DEDENT>year = date.year + years<EOL>try:<EOL><INDENT>return datetime.date(year, new_month, date.day)<EOL><DEDENT>except ValueError:<EOL><INDENT>if months > <NUM_LIT:0>:<EOL><INDENT>new_month += <NUM_LIT:1><EOL>if new_month > <NUM_LIT:12>:<EOL><INDENT>new_month -= <NUM_LIT:12><EOL>year += <NUM_LIT:1><EOL><DEDENT>return datetime.datetime(year, new_month, <NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>new_day = calendar.monthrange(year, new_month)[<NUM_LIT:1>]<EOL>return datetime.datetime(year, new_month, new_day)<EOL><DEDENT><DEDENT>", "docstring": "Add a number of months to a date", "id": "f7521:m20"}
{"signature": "def get_enable_celery_error_reporting_function(site_name, from_address):", "body": "def enable_celery_email_logging(sender, signal, logger, loglevel, logfile, format, colorize, **kwargs):<EOL><INDENT>from celery import current_app<EOL>log.info('<STR_LIT>'.format(logger.name))<EOL>send_errors = current_app.conf['<STR_LIT>']<EOL>send_warnings = current_app.conf['<STR_LIT>']<EOL>if send_errors or send_warnings:<EOL><INDENT>error_email_subject = '<STR_LIT>'.format(site_name)<EOL>celery_handler = CeleryEmailHandler(from_address, current_app.conf['<STR_LIT>'],<EOL>error_email_subject)<EOL>if send_warnings:<EOL><INDENT>celery_handler.setLevel(logging.WARNING)<EOL><DEDENT>else:<EOL><INDENT>celery_handler.setLevel(logging.ERROR)<EOL><DEDENT>logger.addHandler(celery_handler)<EOL><DEDENT><DEDENT>return enable_celery_email_logging<EOL>", "docstring": "Use this to enable error reporting.  You need to put the following in your tasks.py or wherever you\nwant to create your celery instance:\n\ncelery = Celery(__name__)\n\nenable_celery_email_logging = get_enable_celery_error_reporting_function('My Website [LIVE]', 'errors@mywebsite.com')\nafter_setup_logger.connect(enable_celery_email_logging)\nafter_setup_task_logger.connect(enable_celery_email_logging)", "id": "f7522:m0"}
{"signature": "def init_celery(app, celery):", "body": "celery.conf.update(app.config)<EOL>TaskBase = celery.Task<EOL>class ContextTask(TaskBase):<EOL><INDENT>abstract = True<EOL>def __call__(self, *args, **kwargs):<EOL><INDENT>with app.app_context():<EOL><INDENT>return TaskBase.__call__(self, *args, **kwargs)<EOL><DEDENT><DEDENT><DEDENT>celery.Task = ContextTask<EOL>return celery<EOL>", "docstring": "Initialise Celery and set up logging\n\n:param app: Flask app\n:param celery: Celery instance", "id": "f7522:m1"}
{"signature": "def resize_crop_image(image, dest_w, dest_h, pad_when_tall=False):", "body": "<EOL>dest_w = float(dest_w)<EOL>dest_h = float(dest_h)<EOL>dest_ratio = dest_w / dest_h<EOL>src_w = float(image.size[<NUM_LIT:0>])<EOL>src_h = float(image.size[<NUM_LIT:1>])<EOL>src_ratio = src_w / src_h<EOL>if src_ratio < dest_ratio:<EOL><INDENT>scale = dest_w / src_w<EOL>scaled_w = dest_w<EOL>scaled_h = src_h * scale<EOL>left = <NUM_LIT:0><EOL>right = dest_w<EOL>top = (scaled_h - dest_h) / <NUM_LIT><EOL>bottom = top + dest_h<EOL><DEDENT>else:<EOL><INDENT>scale = dest_h / src_h<EOL>scaled_h = dest_h<EOL>scaled_w = src_w * scale<EOL>left = (scaled_w - dest_w) / <NUM_LIT><EOL>right = left + dest_w<EOL>top = <NUM_LIT:0><EOL>bottom = dest_h<EOL><DEDENT>if pad_when_tall:<EOL><INDENT>if (bottom - top) < (scaled_h * <NUM_LIT>):<EOL><INDENT>log.info('<STR_LIT>')<EOL>return resize_pad_image(image, dest_w, dest_h)<EOL><DEDENT><DEDENT>if src_w > dest_w or src_h > dest_h:<EOL><INDENT>scaled_image = image.resize((int(scaled_w), int(scaled_h)), PIL.Image.ANTIALIAS)<EOL>cropped_image = scaled_image.crop((int(left), int(top), int(right), int(bottom)))<EOL>return cropped_image<EOL><DEDENT>elif scaled_w < src_w or scaled_h < src_h:<EOL><INDENT>cropped_image = image.crop((int(left), int(top), int(right), int(bottom)))<EOL>return cropped_image<EOL><DEDENT>else:<EOL><INDENT>return image<EOL><DEDENT>", "docstring": ":param image: PIL.Image\n:param dest_w: Target width\n:param dest_h: Target height\n:return: Scaled and cropped image", "id": "f7523:m1"}
{"signature": "def resize_image_to_fit_height(image, dest_h):", "body": "scale_factor = dest_h / image.size[<NUM_LIT:1>]<EOL>dest_w = image.size[<NUM_LIT:0>] * scale_factor<EOL>scaled_image = image.resize((int(dest_w), int(dest_h)), PIL.Image.ANTIALIAS)<EOL>return scaled_image<EOL>", "docstring": "Resize and image to fit the passed in height, keeping the aspect ratio the same\n\n:param image: PIL.Image\n:param dest_h: The desired height", "id": "f7523:m4"}
{"signature": "def resize_image_to_fit(image, dest_w, dest_h):", "body": "dest_w = float(dest_w)<EOL>dest_h = float(dest_h)<EOL>dest_ratio = dest_w / dest_h<EOL>src_w = float(image.size[<NUM_LIT:0>])<EOL>src_h = float(image.size[<NUM_LIT:1>])<EOL>src_ratio = src_w / src_h<EOL>if src_ratio < dest_ratio:<EOL><INDENT>scale = dest_h / src_h<EOL>scaled_h = dest_h<EOL>scaled_w = src_w * scale<EOL><DEDENT>else:<EOL><INDENT>scale = dest_w / src_w<EOL>scaled_w = dest_w<EOL>scaled_h = src_h * scale<EOL><DEDENT>scaled_image = image.resize((int(scaled_w), int(scaled_h)), PIL.Image.ANTIALIAS)<EOL>return scaled_image<EOL>", "docstring": "Resize the image to fit inside dest rectangle.  Resultant image may be smaller than target\n:param image: PIL.Image\n:param dest_w: Target width\n:param dest_h: Target height\n:return: Scaled image", "id": "f7523:m0"}
{"signature": "def resize_image_to_fit_width(image, dest_w):", "body": "scale_factor = dest_w / image.size[<NUM_LIT:0>]<EOL>dest_h = image.size[<NUM_LIT:1>] * scale_factor<EOL>scaled_image = image.resize((int(dest_w), int(dest_h)), PIL.Image.ANTIALIAS)<EOL>return scaled_image<EOL>", "docstring": "Resize and image to fit the passed in width, keeping the aspect ratio the same\n\n:param image: PIL.Image\n:param dest_w: The desired width", "id": "f7523:m3"}
{"signature": "def file_md5sum(filename):", "body": "hash_md5 = hashlib.md5()<EOL>with open(filename, '<STR_LIT:rb>') as f:<EOL><INDENT>for chunk in iter(lambda: f.read(<NUM_LIT> * <NUM_LIT:4>), b'<STR_LIT>'):<EOL><INDENT>hash_md5.update(chunk)<EOL><DEDENT><DEDENT>return hash_md5.hexdigest()<EOL>", "docstring": ":param filename: The filename of the file to process\n:returns: The MD5 hash of the file", "id": "f7525:m3"}
{"signature": "def queue_email(to_addresses, from_address, subject, body, commit=True, html=True, session=None):", "body": "from models import QueuedEmail<EOL>if session is None:<EOL><INDENT>session = _db.session<EOL><DEDENT>log.info('<STR_LIT>' % (to_addresses, subject))<EOL>queued_email = QueuedEmail(html, to_addresses, from_address, subject, body, STATUS_QUEUED)<EOL>session.add(queued_email)<EOL>session.commit()<EOL>return queued_email<EOL>", "docstring": "Add a mail to the queue to be sent.\n\nWARNING: Commits by default!\n\n:param to_addresses: The names and addresses to send the email to, i.e. \"Steve<steve@fig14.com>, info@fig14.com\"\n:param from_address: Who the email is from i.e. \"Stephen Brown <s@fig14.com>\"\n:param subject: The email subject\n:param body: The html / text body of the email\n:param commit: Whether to commit to the database\n:param html: Is this a html email?\n:param session: The sqlalchemy session or None to use db.session", "id": "f7527:m1"}
{"signature": "def init(db, queued_email_model_class):", "body": "global _db, _QueuedEmail<EOL>_db = db<EOL>_QueuedEmail = queued_email_model_class<EOL>", "docstring": ":param db: Flask-SQLAlchemy database object\n:param queued_email_model_class: Model class (see above example)", "id": "f7527:m0"}
{"signature": "def blend_html_colour_to_white(html_colour, alpha):", "body": "html_colour = html_colour.upper()<EOL>has_hash = False<EOL>if html_colour[<NUM_LIT:0>] == '<STR_LIT:#>':<EOL><INDENT>has_hash = True<EOL>html_colour = html_colour[<NUM_LIT:1>:]<EOL><DEDENT>r_str = html_colour[<NUM_LIT:0>:<NUM_LIT:2>]<EOL>g_str = html_colour[<NUM_LIT:2>:<NUM_LIT:4>]<EOL>b_str = html_colour[<NUM_LIT:4>:<NUM_LIT:6>]<EOL>r = int(r_str, <NUM_LIT:16>)<EOL>g = int(g_str, <NUM_LIT:16>)<EOL>b = int(b_str, <NUM_LIT:16>)<EOL>r = int(alpha * r + (<NUM_LIT:1> - alpha) * <NUM_LIT:255>)<EOL>g = int(alpha * g + (<NUM_LIT:1> - alpha) * <NUM_LIT:255>)<EOL>b = int(alpha * b + (<NUM_LIT:1> - alpha) * <NUM_LIT:255>)<EOL>out = '<STR_LIT>'.format(r, g, b)<EOL>if has_hash:<EOL><INDENT>out = '<STR_LIT:#>' + out<EOL><DEDENT>return out<EOL>", "docstring": ":param html_colour: Colour string like FF552B or #334455\n:param alpha: Alpha value\n:return: Html colour alpha blended onto white", "id": "f7532:m3"}
{"signature": "def print_location(**kwargs):", "body": "stack = inspect.stack()[<NUM_LIT:1>]<EOL>debug_print('<STR_LIT>'.format(stack[<NUM_LIT:1>], stack[<NUM_LIT:2>], stack[<NUM_LIT:3>]))<EOL>for k, v in kwargs.items():<EOL><INDENT>lesser_debug_print('<STR_LIT>'.format(k, v))<EOL><DEDENT>", "docstring": ":param kwargs: Pass in the arguments to the function and they will be printed too!", "id": "f7535:m4"}
{"signature": "def service(self):", "body": "with self.lock:<EOL><INDENT>for key in list(self.attempts.keys()):<EOL><INDENT>log.debug('<STR_LIT>' % key)<EOL>if key in self.attempts:<EOL><INDENT>if self.attempts[key] <= <NUM_LIT:1>:<EOL><INDENT>del self.attempts[key]<EOL><DEDENT>else:<EOL><INDENT>self.attempts[key] -= <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>now = datetime.datetime.utcnow()<EOL>for key in list(self.locks.keys()):<EOL><INDENT>if key in self.locks and self.locks[key] < now:<EOL><INDENT>log.info('<STR_LIT>' % key)<EOL>del self.locks[key]<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Decrease the countdowns, and remove any expired locks.  Should be called once every <decrease_every> seconds.", "id": "f7539:c0:m3"}
{"signature": "def _fetch_index_package_info(self, package_name, current_version):", "body": "try:<EOL><INDENT>package_canonical_name = package_name<EOL>if self.PYPI_API_TYPE == '<STR_LIT>':<EOL><INDENT>package_canonical_name = canonicalize_name(package_name)<EOL><DEDENT>response = requests.get(self.PYPI_API_URL.format(package=package_canonical_name), timeout=<NUM_LIT:15>)<EOL><DEDENT>except HTTPError as e:  <EOL><INDENT>return False, e.message<EOL><DEDENT>if not response.ok:  <EOL><INDENT>return False, '<STR_LIT>'.format(response.reason)<EOL><DEDENT>if self.PYPI_API_TYPE == '<STR_LIT>':<EOL><INDENT>return self._parse_pypi_json_package_info(package_name, current_version, response)<EOL><DEDENT>elif self.PYPI_API_TYPE == '<STR_LIT>':<EOL><INDENT>return self._parse_simple_html_package_info(package_name, current_version, response)<EOL><DEDENT>else:  <EOL><INDENT>raise NotImplementedError('<STR_LIT>')<EOL><DEDENT>", "docstring": ":type package_name: str\n:type current_version: version.Version", "id": "f7549:c0:m4"}
{"signature": "def _parse_simple_html_package_info(self, package_name, current_version, response):", "body": "pattern = r'<STR_LIT>'.format(name=re.escape(package_name))<EOL>versions_match = re.findall(pattern, response.content.decode('<STR_LIT:utf-8>'), flags=re.IGNORECASE)<EOL>all_versions = [version.parse(vers) for vers in versions_match]<EOL>filtered_versions = [vers for vers in all_versions if not vers.is_prerelease and not vers.is_postrelease]<EOL>if not filtered_versions:  <EOL><INDENT>return False, '<STR_LIT>'<EOL><DEDENT>latest_version = max(filtered_versions)<EOL>if self._prerelease or current_version.is_postrelease or current_version.is_prerelease:<EOL><INDENT>prerelease_versions = [vers for vers in all_versions if vers.is_prerelease or vers.is_postrelease]<EOL>if prerelease_versions:<EOL><INDENT>latest_version = max(prerelease_versions)<EOL><DEDENT><DEDENT>return {<EOL>'<STR_LIT:name>': package_name,<EOL>'<STR_LIT>': current_version,<EOL>'<STR_LIT>': latest_version,<EOL>'<STR_LIT>': current_version < latest_version,<EOL>'<STR_LIT>': '<STR_LIT:->'<EOL>}, '<STR_LIT:success>'<EOL>", "docstring": ":type package_name: str\n:type current_version: version.Version\n:type response: requests.models.Response", "id": "f7549:c0:m7"}
{"signature": "def init_app(self, app):", "body": "app.config.setdefault('<STR_LIT>', '<STR_LIT:localhost>')<EOL>app.config.setdefault('<STR_LIT>', None)<EOL>app.config.setdefault('<STR_LIT>', None)<EOL>app.config.setdefault('<STR_LIT>', None)<EOL>app.config.setdefault('<STR_LIT>', <NUM_LIT>)<EOL>app.config.setdefault('<STR_LIT>', None)<EOL>app.config.setdefault('<STR_LIT>', <NUM_LIT:10>)<EOL>app.config.setdefault('<STR_LIT>', None)<EOL>app.config.setdefault('<STR_LIT>', True)<EOL>app.config.setdefault('<STR_LIT>', '<STR_LIT:utf8>')<EOL>app.config.setdefault('<STR_LIT>', None)<EOL>app.config.setdefault('<STR_LIT>', None)<EOL>if hasattr(app, '<STR_LIT>'):<EOL><INDENT>app.teardown_appcontext(self.teardown)<EOL><DEDENT>", "docstring": "Initialize the `app` for use with this\n        :class:`~flask_mysqldb.MySQL` class.\n        This is called automatically if `app` is passed to\n        :meth:`~MySQL.__init__`.\n\n        :param flask.Flask app: the application to configure for use with\n            this :class:`~flask_mysqldb.MySQL` class.", "id": "f7552:c0:m1"}
{"signature": "def get_template(name):", "body": "text = re.sub(r'<STR_LIT:\\r\\n>', r'<STR_LIT:\\n>', name)<EOL>text = re.sub(r'<STR_LIT>', r'<STR_LIT>', text)<EOL>return text<EOL>", "docstring": "Still unsure about best way to do this, hence cruft.", "id": "f7568:m0"}
{"signature": "def plot(self, fmt=None):", "body": "for d in self.__list:<EOL><INDENT>d.plot(fmt=fmt)<EOL><DEDENT>return None<EOL>", "docstring": "Make a simple plot of the legend.\n\nSimply calls Decor.plot() on all of its members.\n\nTODO: Build a more attractive plot.", "id": "f7569:c2:m24"}
{"signature": "def get_colour(self, c, default='<STR_LIT>', match_only=None):", "body": "return self.getattr(c=c,<EOL>attr='<STR_LIT>',<EOL>default=default,<EOL>match_only=match_only)<EOL>", "docstring": "Get the display colour of a component. Wraps `getattr()`.\n\nDevelopment note:\n    Cannot define this as a `partial()` because I want\n    to maintain the order of arguments in `getattr()`.\n\nArgs:\n   c (component): The component to look up.\n   default (str): The colour to return in the event of no match.\n   match_only (list of str): The component attributes to include in the\n       comparison. Default: All of them.\n\nReturns:\n   str. The hex string of the matching Decor in the Legend.", "id": "f7569:c2:m21"}
{"signature": "def _repr_html_(self):", "body": "all_keys = list(set(itertools.chain(*[d.keys for d in self])))<EOL>rows = '<STR_LIT>'<EOL>for decor in self:<EOL><INDENT>th, tr = decor._repr_html_row_(keys=all_keys)<EOL>rows += '<STR_LIT>'.format(tr)<EOL><DEDENT>header = '<STR_LIT>'.format(th)<EOL>html = '<STR_LIT>'.format(header, rows)<EOL>return html<EOL>", "docstring": "Jupyter Notebook magic repr function.", "id": "f7569:c2:m11"}
{"signature": "@classmethod<EOL><INDENT>def builtin_timescale(cls, name):<DEDENT>", "body": "names = {<EOL>'<STR_LIT>': TIMESCALE__ISC,<EOL>'<STR_LIT>': TIMESCALE__USGS_ISC,<EOL>'<STR_LIT>': TIMESCALE__DNAG,<EOL>}<EOL>return cls.from_csv(text=names[name.lower()])<EOL>", "docstring": "Generate a default timescale legend. No arguments.\n\nReturns:\n    Legend: The timescale stored in `defaults.py`.", "id": "f7569:c2:m13"}
{"signature": "@property<EOL><INDENT>def span(self):<DEDENT>", "body": "return self.lower, self.upper<EOL>", "docstring": "Property. A tuple of lower, upper. Provided for convenience.", "id": "f7571:c2:m8"}
{"signature": "@property<EOL><INDENT>def z(self):<DEDENT>", "body": "return self.__dict__.get('<STR_LIT>', (self.upper + self.lower)/<NUM_LIT:2>)<EOL>", "docstring": "Property. Guaranteed to give the 'middle' depth, either as defined,\nor the average of the upper and lower bounds.", "id": "f7571:c2:m6"}
{"signature": "def __hash__(self):", "body": "return hash(frozenset(self.__dict__.keys()))<EOL>", "docstring": "If we define __eq__ we also need __hash__ otherwise the object\nbecomes unhashable. All this does is hash the frozenset of the\nkeys. (You can only hash immutables.)", "id": "f7576:c1:m11"}
{"signature": "def _repr_html_(self):", "body": "rows = '<STR_LIT>'<EOL>s = '<STR_LIT>'<EOL>for k, v in self.__dict__.items():<EOL><INDENT>rows += s.format(k=k, v=v)<EOL><DEDENT>html = '<STR_LIT>'.format(rows)<EOL>return html<EOL>", "docstring": "Jupyter Notebook magic repr function.", "id": "f7576:c1:m13"}
{"signature": "@classmethod<EOL><INDENT>def from_text(cls, text, lexicon, required=None, first_only=True):<DEDENT>", "body": "component = lexicon.get_component(text, first_only=first_only)<EOL>if required and (required not in component):<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>return cls(component)<EOL><DEDENT>", "docstring": "Generate a Component from a text string, using a Lexicon.\n\nArgs:\n    text (str): The text string to parse.\n    lexicon (Lexicon): The dictionary to use for the\n        categories and lexemes.\n    required (str): An attribute that we must have. If a required\n        attribute is missing from the component, then None is returned.\n    first_only (bool): Whether to only take the first\n        match of a lexeme against the text string.\n\nReturns:\n    Component: A Component object, or None if there was no\n        must-have field.", "id": "f7576:c1:m15"}
{"signature": "def _process_row(text, columns):", "body": "if not text:<EOL><INDENT>return<EOL><DEDENT>coldict = {k: {'<STR_LIT:start>': s,<EOL>'<STR_LIT>': l,<EOL>'<STR_LIT>': r,<EOL>'<STR_LIT>': w} for k, (s, l, r, w) in columns.items()}<EOL>item = {}<EOL>for field in coldict:<EOL><INDENT>value = _get_field(text, coldict, field)<EOL>if value is not None:<EOL><INDENT>item[field] = value<EOL><DEDENT><DEDENT>return item<EOL>", "docstring": "Processes a single row from the file.", "id": "f7578:m4"}
{"signature": "def _combine(self, old_self, other, blend=True):", "body": "if blend:<EOL><INDENT>self.components = old_self.components.copy()<EOL>for c in other.components:<EOL><INDENT>if c not in self.components:<EOL><INDENT>self.components.append(c)<EOL><DEDENT><DEDENT>self.description = old_self._blend_descriptions(other)<EOL>self.data = old_self._combine_data(other)<EOL><DEDENT>else:<EOL><INDENT>self.components = other.components<EOL>self.description = other.description<EOL>self.data = other.data<EOL><DEDENT>return self<EOL>", "docstring": "Private method. Combines data, components, and descriptions but\nnothing else.\n\nArgs:\n    old_self (Interval): You have to pass the instance explicitly.\n    other (Interval): The other Interval.\n    blend (bool): Whether to blend or not.\n\nReturns:\n    Interval. The combined description.", "id": "f7579:c1:m25"}
{"signature": "@property<EOL><INDENT>def thickness(self):<DEDENT>", "body": "return abs(self.base.z - self.top.z)<EOL>", "docstring": "Returns the thickness of the interval.\n\nReturns:\n    Float: The thickness.", "id": "f7579:c1:m10"}
{"signature": "def _blend_descriptions(self, other):", "body": "thin, thick = sorted([self, other], key=lambda k: k.thickness)<EOL>total = thin.thickness + thick.thickness<EOL>prop = <NUM_LIT:100> * thick.thickness / total<EOL>if self.components == other.components:<EOL><INDENT>return self.description.strip('<STR_LIT>')<EOL><DEDENT>d1 = thick.description.strip('<STR_LIT>') or thick.summary()<EOL>d2 = thin.description.strip('<STR_LIT>') or thin.summary()<EOL>if d1:<EOL><INDENT>d = '<STR_LIT>'.format(prop, d1, <NUM_LIT:100>-prop, d2)<EOL><DEDENT>else:<EOL><INDENT>d = '<STR_LIT>'<EOL><DEDENT>return d<EOL>", "docstring": "Private method. Computes the description for combining two intervals.\nMake sure that the intervals are already adjusted to the correct\nthicknesses.\n\nArgs:\n    other (Interval): The other Interval.\n\nReturns:\n    str. The blended description.", "id": "f7579:c1:m24"}
{"signature": "@property<EOL><INDENT>def primary(self):<DEDENT>", "body": "if self.components:<EOL><INDENT>return self.components[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Convenience function returning the first component.\n\nReturns:\n    Component. The first one in the list of components.", "id": "f7579:c1:m9"}
{"signature": "def __add__(self, other):", "body": "if isinstance(other, self.__class__):<EOL><INDENT>return self.union(other)<EOL><DEDENT>elif isinstance(other, Component):<EOL><INDENT>top = self.top.z<EOL>base = self.base.z<EOL>d = self.description + '<STR_LIT>' + other.summary()<EOL>c = self.components + [other]<EOL>data = self._combine_data(other)<EOL>return Interval(top, base, description=d, data=data, components=c)<EOL><DEDENT>else:<EOL><INDENT>m = \"<STR_LIT>\"<EOL>raise IntervalError(m)<EOL><DEDENT>", "docstring": "TODO:\n    If adding components, should take account of 'amount', if present.\n    Or 'proportion'? ...Could be specified by lexicon??", "id": "f7579:c1:m4"}
{"signature": "def intersect(self, other, blend=True):", "body": "if not self.any_overlaps(other):<EOL><INDENT>m = '<STR_LIT>'<EOL>raise IntervalError(m)<EOL><DEDENT>_, intersection, _ = self._explode(other)<EOL>return intersection._combine(self, other, blend=blend)<EOL>", "docstring": "Perform the intersection binary operation. self must at least\npartially overlap with other or an IntervalError is raised.\n\nIf blend is False, you are essentially replacing self with other.\n\nArgs:\n    other (Interval): The other Interval.\n    blend (bool): Whether to blend or not.\n\nReturns:\n    Interval. The intersection of the Interval with the one provided.", "id": "f7579:c1:m26"}
{"signature": "def union(self, other, blend=True):", "body": "if not (self.touches(other) or self.any_overlaps(other)):<EOL><INDENT>return self, other<EOL><DEDENT>if self.order == '<STR_LIT>':<EOL><INDENT>top = max(self.top.z, other.top.z)<EOL>bot = min(self.base.z, other.base.z)<EOL><DEDENT>else:<EOL><INDENT>top = min(self.top.z, other.top.z)<EOL>bot = max(self.base.z, other.base.z)<EOL><DEDENT>result = self.copy()<EOL>result.top = top<EOL>result.base = bot<EOL>return result._combine(self, other, blend=blend)<EOL>", "docstring": "Perform the union binary operation. self must at least touch other or\nan IntervalError is raised.\n\nIf blend is False, you are essentially replacing self with other.\n\nArgs:\n    other (Interval): The other Interval.\n    blend (bool): Whether to blend or not.\n\nReturns:\n    Interval. The union of the Interval with the one provided.", "id": "f7579:c1:m28"}
{"signature": "def invert(self, copy=False):", "body": "if copy:<EOL><INDENT>d = self.__dict__.copy()<EOL>del(d['<STR_LIT>'])<EOL>del(d['<STR_LIT>'])<EOL>self.base.invert()<EOL>self.top.invert()<EOL>return Interval(top=self.base, base=self.top, **d)<EOL><DEDENT>else:<EOL><INDENT>self.base.invert()<EOL>self.top.invert()<EOL>old_base = self.base<EOL>self.base = self.top<EOL>self.top = old_base<EOL>return<EOL><DEDENT>", "docstring": "Inverts the interval. If it was depth-ordered (positive numbers\nincreasing downwards.), it will now be elevation-ordered, and\nvice versa.\n\nArgs:\n    copy (bool): Whether to make a copy or not. Default: False.", "id": "f7579:c1:m16"}
{"signature": "def hex_to_name(hexx):", "body": "for n, h in defaults.COLOURS.items():<EOL><INDENT>if (len(n) > <NUM_LIT:1>) and (h == hexx.upper()):<EOL><INDENT>return n.lower()<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Convert hex to a color name, using matplotlib's colour names.\n\nArgs:\n    hexx (str): A hexadecimal colour, starting with '#'.\n\nReturns:\n    str: The name of the colour, or None if not found.", "id": "f7580:m7"}
{"signature": "def flatten_list(l):", "body": "if (l == []) or (l is None):<EOL><INDENT>return l<EOL><DEDENT>if isinstance(l[<NUM_LIT:0>], list):<EOL><INDENT>return flatten_list(l[<NUM_LIT:0>]) + flatten_list(l[<NUM_LIT:1>:])<EOL><DEDENT>return l[:<NUM_LIT:1>] + flatten_list(l[<NUM_LIT:1>:])<EOL>", "docstring": "Unpacks lists in a list:\n\n    [1, 2, [3, 4], [5, [6, 7]]]\n\nbecomes\n\n    [1, 2, 3, 4, 5, 6, 7]\n\nhttp://stackoverflow.com/a/12472564/3381305", "id": "f7580:m16"}
{"signature": "def tops_from_loglike(a, offset=<NUM_LIT:0>, null=None):", "body": "a = np.copy(a)<EOL>try:<EOL><INDENT>contains_nans = np.isnan(a).any()<EOL><DEDENT>except:<EOL><INDENT>contains_nans = False<EOL><DEDENT>if contains_nans:<EOL><INDENT>_null = null or -<NUM_LIT:1><EOL>while _null in a:<EOL><INDENT>_null -= <NUM_LIT:1><EOL><DEDENT>try:<EOL><INDENT>a[np.isnan(a)] = _null<EOL>transformed = True<EOL><DEDENT>except:<EOL><INDENT>transformed = False<EOL><DEDENT><DEDENT>edges = a[<NUM_LIT:1>:] == a[:-<NUM_LIT:1>]<EOL>edges = np.append(True, edges)<EOL>tops = np.where(~edges)[<NUM_LIT:0>]<EOL>tops = np.append(<NUM_LIT:0>, tops)<EOL>values = a[tops + offset]<EOL>if contains_nans and transformed:<EOL><INDENT>values[values == _null] = np.nan<EOL><DEDENT>return tops, values<EOL>", "docstring": "Take a log-like stream of numbers or strings, and return two arrays:\none of the tops (changes), and one of the values from the stream.\n\nArgs:\n    loglike (array-like): The input stream of loglike data.\n    offset (int): Offset (down) from top at which to get lithology,\n        to be sure of getting 'clean' pixels.\n\nReturns:\n    ndarray: Two arrays, tops and values.", "id": "f7580:m14"}
{"signature": "def list_and_add(a, b):", "body": "if not isinstance(b, list):<EOL><INDENT>b = [b]<EOL><DEDENT>if not isinstance(a, list):<EOL><INDENT>a = [a]<EOL><DEDENT>return a + b<EOL>", "docstring": "Coerce to lists and concatenate.\n\nArgs:\n    a: A thing.\n    b: A thing.\n\nReturns:\n    List. All the things.", "id": "f7580:m15"}
{"signature": "def null_default(x):", "body": "def null(y):<EOL><INDENT>return x<EOL><DEDENT>return null<EOL>", "docstring": "Null function. Used for default in functions that can apply a user-\nsupplied function to data before returning.", "id": "f7580:m4"}
{"signature": "def hex_to_rgb(hexx):", "body": "h = hexx.strip('<STR_LIT:#>')<EOL>l = len(h)<EOL>return tuple(int(h[i:i+l//<NUM_LIT:3>], <NUM_LIT:16>) for i in range(<NUM_LIT:0>, l, l//<NUM_LIT:3>))<EOL>", "docstring": "Utility function to convert hex to (r,g,b) triples.\nhttp://ageo.co/1CFxXpO\n\nArgs:\n    hexx (str): A hexadecimal colour, starting with '#'.\n\nReturns:\n    tuple: The equivalent RGB triple, in the range 0 to 255.", "id": "f7580:m10"}
{"signature": "def axis_transform(ax, x, y, xlim=None, ylim=None, inverse=False):", "body": "xlim = xlim or ax.get_xlim()<EOL>ylim = ylim or ax.get_ylim()<EOL>xdelta = xlim[<NUM_LIT:1>] - xlim[<NUM_LIT:0>]<EOL>ydelta = ylim[<NUM_LIT:1>] - ylim[<NUM_LIT:0>]<EOL>if not inverse:<EOL><INDENT>xout = xlim[<NUM_LIT:0>] + x * xdelta<EOL>yout = ylim[<NUM_LIT:0>] + y * ydelta<EOL><DEDENT>else:<EOL><INDENT>xdelta2 = x - xlim[<NUM_LIT:0>]<EOL>ydelta2 = y - ylim[<NUM_LIT:0>]<EOL>xout = xdelta2 / xdelta<EOL>yout = ydelta2 / ydelta<EOL><DEDENT>return xout, yout<EOL>", "docstring": "http://stackoverflow.com/questions/29107800\n\ninverse = False : Axis => Data\n        = True  : Data => Axis", "id": "f7580:m17"}
{"signature": "def rgb_to_hex(rgb):", "body": "r, g, b = rgb[:<NUM_LIT:3>]<EOL>if (r < <NUM_LIT:0>) or (g < <NUM_LIT:0>) or (b < <NUM_LIT:0>):<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>if (r > <NUM_LIT:255>) or (g > <NUM_LIT:255>) or (b > <NUM_LIT:255>):<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>if (<NUM_LIT:0> < r < <NUM_LIT:1>) or (<NUM_LIT:0> < g < <NUM_LIT:1>) or (<NUM_LIT:0> < b < <NUM_LIT:1>):<EOL><INDENT>if (r > <NUM_LIT:1>) or (g > <NUM_LIT:1>) or (b > <NUM_LIT:1>):<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if (<NUM_LIT:0> <= r <= <NUM_LIT:1>) and (<NUM_LIT:0> <= g <= <NUM_LIT:1>) and (<NUM_LIT:0> <= b <= <NUM_LIT:1>):<EOL><INDENT>rgb = tuple([int(round(val * <NUM_LIT:255>)) for val in [r, g, b]])<EOL><DEDENT>else:<EOL><INDENT>rgb = (int(r), int(g), int(b))<EOL><DEDENT>result = '<STR_LIT>' % rgb<EOL>return result.lower()<EOL>", "docstring": "Utility function to convert (r,g,b) triples to hex.\nhttp://ageo.co/1CFxXpO\nArgs:\n  rgb (tuple): A sequence of RGB values in the\n    range 0-255 or 0-1.\nReturns:\n  str: The hex code for the colour.", "id": "f7580:m9"}
{"signature": "def get_field(self, field_name, args, kwargs):", "body": "try:<EOL><INDENT>s = super(CustomFormatter, self)<EOL>return s.get_field(field_name, args, kwargs)<EOL><DEDENT>except KeyError:    <EOL><INDENT>return (\"<STR_LIT:_>\", field_name)<EOL><DEDENT>except IndexError:  <EOL><INDENT>return (\"<STR_LIT:_>\", field_name)<EOL><DEDENT>", "docstring": "Return an underscore if the attribute is absent.\nNot all components have the same attributes.", "id": "f7580:c0:m1"}
{"signature": "def split_description(self, text):", "body": "<EOL>t = re.sub(r'<STR_LIT>', r'<STR_LIT>', text)  <EOL>t = re.sub(r'<STR_LIT>', r'<STR_LIT>', t)  <EOL>words = getattr(self, '<STR_LIT>')<EOL>try:<EOL><INDENT>splitter = words[<NUM_LIT:0>].strip()<EOL><DEDENT>except:<EOL><INDENT>splitter = '<STR_LIT>'<EOL><DEDENT>t = re.sub(r'<STR_LIT>', r'<STR_LIT:U+0020>'+splitter+'<STR_LIT>', t)<EOL>f = re.IGNORECASE<EOL>pattern = re.compile(r'<STR_LIT>' + r'<STR_LIT:|>'.join(words) + r'<STR_LIT:)>', flags=f)<EOL>parts = filter(None, pattern.split(t))<EOL>return [i.strip() for i in parts]<EOL>", "docstring": "Split a description into parts, each of which can be turned into\na single component.", "id": "f7582:c1:m9"}
{"signature": "def next(self):", "body": "return self.__next__()<EOL>", "docstring": "For Python 2 compatibility.", "id": "f7583:c1:m10"}
{"signature": "def crop(self, extent, copy=False):", "body": "try:<EOL><INDENT>if extent[<NUM_LIT:0>] is None:<EOL><INDENT>extent = (self.start.z, extent[<NUM_LIT:1>])<EOL><DEDENT>if extent[<NUM_LIT:1>] is None:<EOL><INDENT>extent = (extent[<NUM_LIT:0>], self.stop.z)<EOL><DEDENT><DEDENT>except:<EOL><INDENT>m = \"<STR_LIT>\"<EOL>m += \"<STR_LIT>\"<EOL>raise StriplogError(m)<EOL><DEDENT>first_ix = self.read_at(extent[<NUM_LIT:0>], index=True)<EOL>last_ix = self.read_at(extent[<NUM_LIT:1>], index=True)<EOL>first = self[first_ix].split_at(extent[<NUM_LIT:0>])[<NUM_LIT:1>]<EOL>last = self[last_ix].split_at(extent[<NUM_LIT:1>])[<NUM_LIT:0>]<EOL>new_list = self.__list[first_ix:last_ix+<NUM_LIT:1>].copy()<EOL>new_list[<NUM_LIT:0>] = first<EOL>new_list[-<NUM_LIT:1>] = last<EOL>if copy:<EOL><INDENT>return Striplog(new_list)<EOL><DEDENT>else:<EOL><INDENT>self.__list = new_list<EOL>return<EOL><DEDENT>", "docstring": "Crop to a new depth range.\n\nArgs:\n    extent (tuple): The new start and stop depth. Must be 'inside'\n        existing striplog.\n    copy (bool): Whether to operate in place or make a copy.\n\nReturns:\n    Operates in place by deault; if copy is True, returns a striplog.", "id": "f7583:c1:m67"}
{"signature": "def merge_overlaps(self):", "body": "overlaps = np.array(self.find_overlaps(index=True))<EOL>if not overlaps.any():<EOL><INDENT>return<EOL><DEDENT>for overlap in overlaps:<EOL><INDENT>before = self[overlap].copy()<EOL>after = self[overlap + <NUM_LIT:1>].copy()<EOL>del self[overlap]<EOL>del self[overlap]<EOL>new_segment = before.merge(after)<EOL>self.__insert(overlap, new_segment)<EOL>overlaps += <NUM_LIT:1><EOL><DEDENT>return<EOL>", "docstring": "Merges overlaps by merging overlapping Intervals.\n\nThe function takes no arguments and returns ``None``. It operates on\nthe striplog 'in place'\n\nTODO: This function will not work if any interval overlaps more than\n    one other intervals at either its base or top.", "id": "f7583:c1:m60"}
{"signature": "def __next__(self):", "body": "try:<EOL><INDENT>result = self.__list[self.__index]<EOL><DEDENT>except IndexError:<EOL><INDENT>self.__index = <NUM_LIT:0><EOL>raise StopIteration<EOL><DEDENT>self.__index += <NUM_LIT:1><EOL>return result<EOL>", "docstring": "Supports iterable.", "id": "f7583:c1:m9"}
{"signature": "@classmethod<EOL><INDENT>def __intervals_from_tops(self,<EOL>tops,<EOL>values,<EOL>basis,<EOL>components,<EOL>field=None,<EOL>ignore_nan=True):<DEDENT>", "body": "<EOL>length = float(basis.size)<EOL>start, stop = basis[<NUM_LIT:0>], basis[-<NUM_LIT:1>]<EOL>tops = [start + (p/(length-<NUM_LIT:1>)) * (stop-start) for p in tops]<EOL>bases = tops[<NUM_LIT:1>:] + [stop]<EOL>list_of_Intervals = []<EOL>for i, t in enumerate(tops):<EOL><INDENT>v, c, d = values[i], [], {}<EOL>if ignore_nan and np.isnan(v):<EOL><INDENT>continue<EOL><DEDENT>if (field is not None):<EOL><INDENT>d = {field: v}<EOL><DEDENT>if components is not None:<EOL><INDENT>try:<EOL><INDENT>c = [deepcopy(components[int(v)])]<EOL><DEDENT>except IndexError:<EOL><INDENT>c = []<EOL><DEDENT>if c and (c[<NUM_LIT:0>] is None):<EOL><INDENT>c = []<EOL><DEDENT><DEDENT>interval = Interval(t, bases[i], data=d, components=c)<EOL>list_of_Intervals.append(interval)<EOL><DEDENT>return list_of_Intervals<EOL>", "docstring": "Private method. Take a sequence of tops in an arbitrary dimension,\nand provide a list of intervals from which a striplog can be made.\n\nThis is only intended to be used by ``from_image()``.\n\nArgs:\n    tops (iterable). A list of floats.\n    values (iterable). A list of values to look up.\n    basis (iterable). A list of components.\n    components (iterable). A list of Components.\n\nReturns:\n    List. A list of Intervals.", "id": "f7583:c1:m23"}
{"signature": "@property<EOL><INDENT>def start(self):<DEDENT>", "body": "if self.order == '<STR_LIT>':<EOL><INDENT>return self[<NUM_LIT:0>].top<EOL><DEDENT>else:<EOL><INDENT>return self[-<NUM_LIT:1>].base<EOL><DEDENT>", "docstring": "Property. The closest Position to the datum.\n\nReturns:\n    Position.", "id": "f7583:c1:m14"}
{"signature": "@property<EOL><INDENT>def mean(self):<DEDENT>", "body": "return self.cum / len(self)<EOL>", "docstring": "Property. Returns the mean thickness of all filled intervals.\n\nReturns:\n    Float. The mean average of interval thickness.", "id": "f7583:c1:m19"}
{"signature": "def read_at(self, d, index=False):", "body": "for i, iv in enumerate(self):<EOL><INDENT>if iv.spans(d):<EOL><INDENT>return i if index else iv<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Get the index of the interval at a particular 'depth' (though this\n    might be an elevation or age or anything).\n\nArgs:\n    d (Number): The 'depth' to query.\n    index (bool): Whether to return the index instead of the interval.\n\nReturns:\n    Interval: The interval, or if ``index==True`` the index of the\n        interval, at the specified 'depth', or ``None`` if the depth is\n        outside the striplog's range.", "id": "f7583:c1:m48"}
{"signature": "def get_data(self, field, function=None, default=None):", "body": "f = function or utils.null<EOL>data = []<EOL>for iv in self:<EOL><INDENT>d = iv.data.get(field)<EOL>if d is None:<EOL><INDENT>if default is not None:<EOL><INDENT>d = default<EOL><DEDENT>else:<EOL><INDENT>d = np.nan<EOL><DEDENT><DEDENT>data.append(f(d))<EOL><DEDENT>return np.array(data)<EOL>", "docstring": "Get data from the striplog.", "id": "f7583:c1:m46"}
{"signature": "def merge_neighbours(self, strict=True):", "body": "new_strip = [self[<NUM_LIT:0>].copy()]<EOL>for lower in self[<NUM_LIT:1>:]:<EOL><INDENT>touching = new_strip[-<NUM_LIT:1>].touches(lower)<EOL>if strict:<EOL><INDENT>similar = new_strip[-<NUM_LIT:1>].components == lower.components<EOL><DEDENT>else:<EOL><INDENT>similar = new_strip[-<NUM_LIT:1>].primary == lower.primary<EOL><DEDENT>if touching and similar:<EOL><INDENT>new_strip[-<NUM_LIT:1>] = new_strip[-<NUM_LIT:1>].union(lower)<EOL><DEDENT>else:<EOL><INDENT>new_strip.append(lower.copy())<EOL><DEDENT><DEDENT>return Striplog(new_strip)<EOL>", "docstring": "Makes a new striplog in which matching neighbours (for which the\ncomponents are the same) are unioned. That is, they are replaced by\na new Interval with the same top as the uppermost and the same bottom\nas the lowermost.\n\nArgs\n    strict (bool): If True, then all of the components must match.\n        If False, then only the primary must match.\n\nReturns:\n    Striplog. A new striplog.\n\nTODO:\n    Might need to be tweaked to deal with 'binary striplogs' if those\n    aren't implemented with components.", "id": "f7583:c1:m61"}
{"signature": "@classmethod<EOL><INDENT>def _from_array(cls, a,<EOL>lexicon=None,<EOL>source=\"<STR_LIT>\",<EOL>points=False,<EOL>abbreviations=False):<DEDENT>", "body": "with warnings.catch_warnings():<EOL><INDENT>warnings.simplefilter(\"<STR_LIT>\")<EOL>w = \"<STR_LIT>\"<EOL>warnings.warn(w, DeprecationWarning, stacklevel=<NUM_LIT:2>)<EOL><DEDENT>csv_text = '<STR_LIT>'<EOL>for interval in a:<EOL><INDENT>interval = [str(i) for i in interval]<EOL>if (len(interval) < <NUM_LIT:2>) or (len(interval) > <NUM_LIT:3>):<EOL><INDENT>raise StriplogError('<STR_LIT>')<EOL><DEDENT>descr = interval[-<NUM_LIT:1>].strip('<STR_LIT>')<EOL>interval[-<NUM_LIT:1>] = '<STR_LIT:\">' + descr + '<STR_LIT:\">'<EOL>csv_text += '<STR_LIT:U+002CU+0020>'.join(interval) + '<STR_LIT:\\n>'<EOL><DEDENT>return cls.from_descriptions(csv_text,<EOL>lexicon,<EOL>source=source,<EOL>points=points,<EOL>abbreviations=abbreviations)<EOL>", "docstring": "DEPRECATING.\n\nTurn an array-like into a Striplog. It should have the following\nformat (where ``base`` is optional):\n\n    [(top, base, description),\n     (top, base, description),\n     ...\n     ]\n\nArgs:\n    a (array-like): A list of lists or of tuples, or an array.\n    lexicon (Lexicon): A language dictionary to extract structured\n        objects from the descriptions.\n    source (str): The source of the data. Default: ''.\n    points (bool): Whether to treat as point data. Default: False.\n\nReturns:\n    Striplog: The ``striplog`` object.", "id": "f7583:c1:m31"}
{"signature": "def invert(self, copy=False):", "body": "if copy:<EOL><INDENT>return Striplog([i.invert(copy=True) for i in self])<EOL><DEDENT>else:<EOL><INDENT>for i in self:<EOL><INDENT>i.invert()<EOL><DEDENT>self.__sort()<EOL>o = self.order<EOL>self.order = {'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>'}[o]<EOL>return<EOL><DEDENT>", "docstring": "Inverts the striplog, changing its order and the order of its contents.\n\nOperates in place by default.\n\nArgs:\n    copy (bool): Whether to operate in place or make a copy.\n\nReturns:\n    None if operating in-place, or an inverted copy of the striplog\n        if not.", "id": "f7583:c1:m66"}
{"signature": "def intersect(self, other):", "body": "if not isinstance(other, self.__class__):<EOL><INDENT>m = \"<STR_LIT>\"<EOL>raise StriplogError(m)<EOL><DEDENT>result = []<EOL>for iv in self:<EOL><INDENT>for jv in other:<EOL><INDENT>try:<EOL><INDENT>result.append(iv.intersect(jv))<EOL><DEDENT>except IntervalError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>return Striplog(result)<EOL>", "docstring": "Makes a striplog of all intersections.\n\nArgs:\n    Striplog. The striplog instance to intersect with.\n\nReturns:\n    Striplog. The result of the intersection.", "id": "f7583:c1:m59"}
{"signature": "def bar(self, height='<STR_LIT>', sort=False, reverse=False,<EOL>legend=None, ax=None, figsize=None, **kwargs):", "body": "if sort:<EOL><INDENT>if sort is True:<EOL><INDENT>def func(x): return x.thickness<EOL>reverse = True<EOL><DEDENT>data = sorted(self, key=func, reverse=reverse)<EOL><DEDENT>else:<EOL><INDENT>data = self[:]<EOL><DEDENT>if ax is None:<EOL><INDENT>fig, ax = plt.subplots(figsize=figsize)<EOL><DEDENT>heights = [getattr(i, height) for i in data]<EOL>comps = [i[<NUM_LIT:0>] for i in self.unique]<EOL>if legend is None:<EOL><INDENT>legend = Legend.random(comps)<EOL><DEDENT>colors = [legend.get_colour(i.primary) for i in data]<EOL>bars = ax.bar(range(len(data)), height=heights, color=colors, **kwargs)<EOL>colourables = [i.primary.summary() for i in data]<EOL>unique_bars = dict(zip(colourables, bars))<EOL>ax.legend(unique_bars.values(), unique_bars.keys())<EOL>ax.set_ylabel(height.title())<EOL>return ax<EOL>", "docstring": "Make a bar plot of thickness per interval.\n\nArgs:\n    height (str): The property of the primary component to plot.\n    sort (bool or function): Either pass a boolean indicating whether\n        to reverse sort by thickness, or pass a function to be used as\n        the sort key.\n    reverse (bool): Reverses the sort order.\n    legend (Legend): The legend to plot with.\n    ax (axis): Optional axis to plot to.\n    figsize (tuple): A figure size, (width, height), optional.\n    **kwargs: passed to the matplotlib bar plot command, ax.bar().\n\nReturns:\n    axis: If you sent an axis in, you get it back.", "id": "f7583:c1:m65"}
{"signature": "def anneal(self):", "body": "strip = self.copy()<EOL>gaps = strip.find_gaps(index=True)<EOL>if not gaps:<EOL><INDENT>return<EOL><DEDENT>for gap in gaps:<EOL><INDENT>before = strip[gap]<EOL>after = strip[gap + <NUM_LIT:1>]<EOL>if strip.order == '<STR_LIT>':<EOL><INDENT>t = (after.top.z-before.base.z)/<NUM_LIT:2><EOL>before.base = before.base.z + t<EOL>after.top = after.top.z - t<EOL><DEDENT>else:<EOL><INDENT>t = (after.base-before.top)/<NUM_LIT:2><EOL>before.top = before.top.z + t<EOL>after.base = after.base.z - t<EOL><DEDENT><DEDENT>return strip<EOL>", "docstring": "Fill in empty intervals by growing from top and base.\n\nNote that this operation happens in-place and destroys any information\nabout the ``Position`` (e.g. metadata associated with the top or base).\nSee GitHub issue #54.", "id": "f7583:c1:m56"}
{"signature": "def __strict(self):", "body": "def conc(a, b):<EOL><INDENT>return a + b<EOL><DEDENT>b = np.array(reduce(conc, [[i.top.z, i.base.z] for i in self]))<EOL>return all(np.diff(b) >= <NUM_LIT:0>)<EOL>", "docstring": "Private method. Checks if striplog is monotonically increasing in\ndepth.\n\nReturns:\n    Bool.", "id": "f7583:c1:m17"}
{"signature": "def to_canstrat(self, filename, params):", "body": "return None<EOL>", "docstring": "Write a Canstrat ASCII file.\n\nArgs:\n    filename (str)\n    params (dict): The well details. You can use a ``welly`` header\n        object.\n\nReturns:", "id": "f7583:c1:m36"}
{"signature": "def fill(self, component=None):", "body": "c = [component] if component is not None else []<EOL>gaps = self.find_gaps()<EOL>if not gaps:<EOL><INDENT>return self<EOL><DEDENT>for iv in gaps:<EOL><INDENT>iv.components = c<EOL><DEDENT>return deepcopy(self) + gaps<EOL>", "docstring": "Fill gaps with the component provided.\n\nExample\n    t = s.fill(Component({'lithology': 'cheese'}))", "id": "f7583:c1:m57"}
{"signature": "def find(self, search_term, index=False):", "body": "hits = []<EOL>for i, iv in enumerate(self):<EOL><INDENT>try:<EOL><INDENT>search_text = iv.description or iv.primary.summary()<EOL>pattern = re.compile(search_term, flags=re.IGNORECASE)<EOL>if pattern.search(search_text):<EOL><INDENT>hits.append(i)<EOL><DEDENT><DEDENT>except TypeError:<EOL><INDENT>if search_term in iv.components:<EOL><INDENT>hits.append(i)<EOL><DEDENT><DEDENT><DEDENT>if hits and index:<EOL><INDENT>return hits<EOL><DEDENT>elif hits:<EOL><INDENT>return self[hits]<EOL><DEDENT>else:<EOL><INDENT>return<EOL><DEDENT>", "docstring": "Look for a regex expression in the descriptions of the striplog.\nIf there's no description, it looks in the summaries.\n\nIf you pass a Component, then it will search the components, not the\ndescriptions or summaries.\n\nCase insensitive.\n\nArgs:\n    search_term (string or Component): The thing you want to search\n        for. Strings are treated as regular expressions.\n    index (bool): Whether to return the index instead of the interval.\nReturns:\n    Striplog: A striplog that contains only the 'hit' Intervals.\n        However, if ``index`` was ``True``, then that's what you get.", "id": "f7583:c1:m51"}
{"signature": "def find_gaps(self, index=False):", "body": "return self.__find_incongruities(op=operator.lt, index=index)<EOL>", "docstring": "Finds gaps in a striplog.\n\nArgs:\n    index (bool): If True, returns indices of intervals with\n    gaps after them.\n\nReturns:\n    Striplog: A striplog of all the gaps. A sort of anti-striplog.", "id": "f7583:c1:m54"}
{"signature": "def to_flag(self, **kwargs):", "body": "return self.to_log(**kwargs).astype(bool)<EOL>", "docstring": "A wrapper for ``to_log()`` that returns a boolean array.\nUseful for masking. Has the same interface as ``to_log()``.", "id": "f7583:c1:m40"}
{"signature": "def _ensure_wrappability(fn):", "body": "<EOL>if isinstance(fn, (type(object.__init__), type(object.__call__))):<EOL><INDENT>wrappable_fn = lambda *args, **kwargs: fn(*args, **kwargs)<EOL>wrappable_fn.__name__ = fn.__name__<EOL>wrappable_fn.__doc__ = fn.__doc__<EOL>wrappable_fn.__module__ = '<STR_LIT>'  <EOL>wrappable_fn.__wrapped__ = fn<EOL>return wrappable_fn<EOL><DEDENT>return fn<EOL>", "docstring": "Make sure `fn` can be wrapped cleanly by functools.wraps.", "id": "f7587:m1"}
{"signature": "def _is_literally_representable(value):", "body": "return _format_value(value) is not None<EOL>", "docstring": "Returns `True` if `value` can be (parseably) represented as a string.\n\n    Args:\n      value: The value to check.\n\n    Returns:\n      `True` when `value` can be represented as a string parseable by\n      `parse_literal`, `False` otherwise.", "id": "f7587:m7"}
{"signature": "def iterate_references(config, to=None):", "body": "for value in _iterate_flattened_values(config):<EOL><INDENT>if isinstance(value, ConfigurableReference):<EOL><INDENT>if to is None or value.configurable.fn_or_cls == to:<EOL><INDENT>yield value<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Provides an iterator over references in the given config.\n\n    Args:\n      config: A dictionary mapping scoped configurable names to argument bindings.\n      to: If supplied, only yield references whose `configurable_fn` matches `to`.\n\n    Yields:\n      `ConfigurableReference` instances within `config`, maybe restricted to those\n      matching the `to` parameter if it is supplied.", "id": "f7587:m38"}
{"signature": "def query_parameter(binding_key):", "body": "pbk = ParsedBindingKey(binding_key)<EOL>if pbk.config_key not in _CONFIG:<EOL><INDENT>err_str = \"<STR_LIT>\"<EOL>raise ValueError(err_str.format(pbk.given_selector))<EOL><DEDENT>if pbk.arg_name not in _CONFIG[pbk.config_key]:<EOL><INDENT>err_str = \"<STR_LIT>\"<EOL>raise ValueError(err_str.format(pbk.given_selector, pbk.arg_name))<EOL><DEDENT>return _CONFIG[pbk.config_key][pbk.arg_name]<EOL>", "docstring": "Returns the currently bound value to the specified `binding_key`.\n\n    The `binding_key` argument should look like\n    'maybe/some/scope/maybe.moduels.configurable_name.parameter_name'. Note that\n    this will not include default parameters.\n\n    Args:\n      binding_key: The parameter whose value should be set.\n\n    Returns:\n      The value bound to the configurable/parameter combination given in\n      `binding_key`.\n\n    Raises:\n      ValueError: If no function can be found matching the configurable name\n        specified by `biding_key`, or if the specified parameter name is\n        blacklisted or not in the function's whitelist (if present) or if there is\n        no value bound for the queried parameter or configurable.", "id": "f7587:m10"}
{"signature": "def _format_value(value):", "body": "literal = repr(value)<EOL>try:<EOL><INDENT>if parse_value(literal) == value:<EOL><INDENT>return literal<EOL><DEDENT><DEDENT>except SyntaxError:<EOL><INDENT>pass<EOL><DEDENT>return None<EOL>", "docstring": "Returns `value` in a format parseable by `parse_value`, or `None`.\n\n    Simply put, This function ensures that when it returns a string value, the\n    following will hold:\n\n        parse_value(_format_value(value)) == value\n\n    Args:\n      value: The value to format.\n\n    Returns:\n      A string representation of `value` when `value` is literally representable,\n      or `None`.", "id": "f7587:m6"}
{"signature": "def __deepcopy__(self, memo):", "body": "addl_msg = '<STR_LIT>'<EOL>_raise_unknown_reference_error(self, addl_msg)<EOL>", "docstring": "Dishonestly implements the __deepcopy__ special method.\n\n        See `ConfigurableReference` above. If this method is called, it means there\n        was an attempt to use this unknown configurable reference, so we throw an\n        error here.\n\n        Args:\n          memo: The memoization dict (unused).\n\n        Raises:\n          ValueError: To report that there is no matching configurable.", "id": "f7587:c2:m3"}
{"signature": "def register_finalize_hook(fn):", "body": "_FINALIZE_HOOKS.append(fn)<EOL>return fn<EOL>", "docstring": "Registers `fn` as a hook that will run during `gin.finalize`.\n\n    All finalize hooks should accept the current config, and return a dictionary\n    containing any additional parameter bindings that should occur in the form of\n    a mapping from (scoped) configurable names to values.\n\n    Args:\n      fn: The function to register.\n\n    Returns:\n      `fn`, allowing `register_finalize_hook` to be used as a decorator.", "id": "f7587:m36"}
{"signature": "@configurable('<STR_LIT>', module='<STR_LIT>')<EOL>def _retrieve_constant():", "body": "return _CONSTANTS[current_scope_str()]<EOL>", "docstring": "Fetches and returns a constant from the _CONSTANTS map.", "id": "f7587:m41"}
{"signature": "def after_create_session(self, session=None, coord=None):", "body": "config_str = config.operative_config_str()<EOL>if not tf.gfile.IsDirectory(self._output_dir):<EOL><INDENT>tf.gfile.MakeDirs(self._output_dir)<EOL><DEDENT>global_step_val = <NUM_LIT:0><EOL>if session is not None:<EOL><INDENT>global_step = tf.train.get_global_step()<EOL>if global_step is not None:<EOL><INDENT>global_step_val = session.run(global_step)<EOL><DEDENT><DEDENT>filename = '<STR_LIT>' % (self._base_name, global_step_val)<EOL>config_path = os.path.join(self._output_dir, filename)<EOL>with tf.gfile.GFile(config_path, '<STR_LIT:w>') as f:<EOL><INDENT>f.write(config_str)<EOL><DEDENT>if self._summarize_config:<EOL><INDENT>md_config_str = self._markdownify_operative_config_str(config_str)<EOL>summary_metadata = summary_pb2.SummaryMetadata()<EOL>summary_metadata.plugin_data.plugin_name = '<STR_LIT:text>'<EOL>summary_metadata.plugin_data.content = b'<STR_LIT:{}>'<EOL>text_tensor = tf.make_tensor_proto(md_config_str)<EOL>summary = summary_pb2.Summary()<EOL>summary.value.add(<EOL>tag='<STR_LIT>' + self._base_name,<EOL>tensor=text_tensor,<EOL>metadata=summary_metadata)<EOL>if not self._summary_writer:<EOL><INDENT>self._summary_writer = tf.summary.FileWriterCache.get(self._output_dir)<EOL><DEDENT>self._summary_writer.add_summary(summary, global_step_val)<EOL>self._summary_writer.flush()<EOL><DEDENT>", "docstring": "Writes out Gin's operative config, and maybe adds a summary of it.", "id": "f7592:c0:m2"}
{"signature": "def __init__(self,<EOL>output_dir,<EOL>base_name='<STR_LIT>',<EOL>summarize_config=True,<EOL>summary_writer=None):", "body": "self._output_dir = output_dir<EOL>self._base_name = base_name<EOL>self._summarize_config = summarize_config<EOL>self._summary_writer = summary_writer<EOL>", "docstring": "Construct the GinConfigSaverHook.\n\n        Args:\n          output_dir: The directory in which to save the operative config. This\n            should in general be the same as the directory in which summaries are\n            stored (and thus may be different for train vs. eval jobs.\n          base_name: The base name (name excluding path and extension) of the file\n            where this hook will write the operative config. Also used as the\n            summary tag if summarizing the config for display in TensorBoard.\n          summarize_config: Whether to save a summary of the operative config that\n            will be loaded by TensorBoard and displayed in its \"Text\" tab.\n          summary_writer: A tf.summary.FileWriter object to use for writing\n            summaries. If `None` (default), a FileWriter object for `output_dir`\n            will be created/retrieved by the tf.summary.FileWriterCache associated\n            with `output_dir` in `after_create_session`.", "id": "f7592:c0:m0"}
{"signature": "def __contains__(self, complete_selector):", "body": "return complete_selector in self._selector_map<EOL>", "docstring": "Check if `complete_selector` is present.", "id": "f7593:c0:m8"}
{"signature": "def __getitem__(self, complete_selector):", "body": "return self._selector_map[complete_selector]<EOL>", "docstring": "Look up the value of `complete_selector` (no partial matching).", "id": "f7593:c0:m7"}
{"signature": "def minimal_selector(self, complete_selector):", "body": "if complete_selector not in self._selector_map:<EOL><INDENT>raise KeyError(\"<STR_LIT>\".format(complete_selector))<EOL><DEDENT>selector_components = complete_selector.split('<STR_LIT:.>')<EOL>node = self._selector_tree<EOL>start = None<EOL>for i, component in enumerate(reversed(selector_components)):<EOL><INDENT>if len(node) == <NUM_LIT:1>:<EOL><INDENT>if start is None:<EOL><INDENT>start = -i  <EOL><DEDENT><DEDENT>else:<EOL><INDENT>start = None<EOL><DEDENT>node = node[component]<EOL><DEDENT>if len(node) > <NUM_LIT:1>:  <EOL><INDENT>return complete_selector<EOL><DEDENT>return '<STR_LIT:.>'.join(selector_components[start:])<EOL>", "docstring": "Returns the minimal selector that uniquely matches `complete_selector`.\n\n        Args:\n          complete_selector: A complete selector stored in the map.\n\n        Returns:\n          A partial selector that unambiguously matches `complete_selector`.\n\n        Raises:\n          KeyError: If `complete_selector` is not in the map.", "id": "f7593:c0:m13"}
{"signature": "def _parse_selector(self, scoped=True, allow_periods_in_scope=False):", "body": "if self._current_token.kind != tokenize.NAME:<EOL><INDENT>self._raise_syntax_error('<STR_LIT>')<EOL><DEDENT>begin_line_num = self._current_token.begin[<NUM_LIT:0>]<EOL>begin_char_num = self._current_token.begin[<NUM_LIT:1>]<EOL>end_char_num = self._current_token.end[<NUM_LIT:1>]<EOL>line = self._current_token.line<EOL>selector_parts = []<EOL>step_parity = <NUM_LIT:0><EOL>while (step_parity == <NUM_LIT:0> and self._current_token.kind == tokenize.NAME or<EOL>step_parity == <NUM_LIT:1> and self._current_token.value in ('<STR_LIT:/>', '<STR_LIT:.>')):<EOL><INDENT>selector_parts.append(self._current_token.value)<EOL>step_parity = not step_parity<EOL>end_char_num = self._current_token.end[<NUM_LIT:1>]<EOL>self._advance_one_token()<EOL><DEDENT>self._skip_whitespace_and_comments()<EOL>scoped_selector = '<STR_LIT>'.join(selector_parts)<EOL>untokenized_scoped_selector = line[begin_char_num:end_char_num]<EOL>scope_re = IDENTIFIER_RE<EOL>if allow_periods_in_scope:<EOL><INDENT>scope_re = MODULE_RE<EOL><DEDENT>selector_re = MODULE_RE<EOL>scope_parts = scoped_selector.split('<STR_LIT:/>')<EOL>valid_format = all(scope_re.match(scope) for scope in scope_parts[:-<NUM_LIT:1>])<EOL>valid_format &= bool(selector_re.match(scope_parts[-<NUM_LIT:1>]))<EOL>valid_format &= bool(scoped or len(scope_parts) == <NUM_LIT:1>)<EOL>if untokenized_scoped_selector != scoped_selector or not valid_format:<EOL><INDENT>location = (self._filename, begin_line_num, begin_char_num + <NUM_LIT:1>, line)<EOL>self._raise_syntax_error('<STR_LIT>', location)<EOL><DEDENT>return scoped_selector<EOL>", "docstring": "Parse a (possibly scoped) selector.\n\n        A selector is a sequence of one or more valid Python-style identifiers\n        separated by periods (see also `SelectorMap`). A scoped selector is a\n        selector that may be preceded by scope names (separated by slashes).\n\n        Args:\n          scoped: Whether scopes are allowed.\n          allow_periods_in_scope: Whether to allow period characters in the scope\n            names preceding the selector.\n\n        Returns:\n          The parsed selector (as a string).\n\n        Raises:\n          SyntaxError: If the scope or selector is malformatted.", "id": "f7595:c4:m14"}
{"signature": "def __init__(self, string_or_filelike, parser_delegate):", "body": "if hasattr(string_or_filelike, '<STR_LIT>'):<EOL><INDENT>line_reader = string_or_filelike.readline<EOL><DEDENT>else:  <EOL><INDENT>if six.PY2:<EOL><INDENT>string_or_filelike = unicode(string_or_filelike)<EOL><DEDENT>string_io = io.StringIO(string_or_filelike)<EOL>line_reader = string_io.readline<EOL><DEDENT>def _text_line_reader():<EOL><INDENT>line = line_reader()<EOL>if isinstance(line, bytes):<EOL><INDENT>line = line.decode('<STR_LIT:utf8>')<EOL><DEDENT>return line<EOL><DEDENT>self._token_generator = tokenize.generate_tokens(_text_line_reader)<EOL>self._filename = getattr(string_or_filelike, '<STR_LIT:name>', None)<EOL>self._current_token = None<EOL>self._delegate = parser_delegate<EOL>self._advance_one_token()<EOL>", "docstring": "Construct the parser.\n\n        Args:\n          string_or_filelike: Either the string to parse, or a file-like object\n            supporting the readline method.\n          parser_delegate: An instance of the ParserDelegate class, that will be\n            responsible for constructing appropriate objects for configurable\n            references and macros.", "id": "f7595:c4:m0"}
{"signature": "def advance_one_line(self):", "body": "current_line = self._current_token.line_number<EOL>while current_line == self._current_token.line_number:<EOL><INDENT>self._current_token = ConfigParser.Token(*next(self._token_generator))<EOL><DEDENT>", "docstring": "Advances to next line.", "id": "f7595:c4:m8"}
{"signature": "def _maybe_parse_macro(self):", "body": "if self._current_token.value != '<STR_LIT:%>':<EOL><INDENT>return False, None<EOL><DEDENT>location = self._current_location()<EOL>self._advance_one_token()<EOL>scoped_name = self._parse_selector(allow_periods_in_scope=True)<EOL>with utils.try_with_location(location):<EOL><INDENT>macro = self._delegate.macro(scoped_name)<EOL><DEDENT>return True, macro<EOL>", "docstring": "Try to parse an macro (%scope/name).", "id": "f7595:c4:m18"}
{"signature": "def unsupported_versions_1979():", "body": "v = sys.version_info<EOL>if (v.major == <NUM_LIT:3>) and (<EOL>(v.minor == <NUM_LIT:7> and v.micro <= <NUM_LIT:2>)<EOL>or (v.minor == <NUM_LIT:8> and v.micro == <NUM_LIT:0> and v.releaselevel == '<STR_LIT>' and v.serial <= <NUM_LIT:1>)<EOL>):<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Unsupported python versions for itertags\n       3.7.0 - 3.7.2 and 3.8.0a1\n       - https://github.com/streamlink/streamlink/issues/1979\n       - https://bugs.python.org/issue34294", "id": "f7820:m0"}
{"signature": "def __call__(self, values):", "body": "values = product(values, self._map)<EOL>for value in map(self._mapped_func, filter(self._cmp_filter, values)):<EOL><INDENT>if isinstance(value, tuple) and len(value) == <NUM_LIT:2>:<EOL><INDENT>yield value<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>if isinstance(value, dict):<EOL><INDENT>for __ in value.items():<EOL><INDENT>yield __<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for __ in value:<EOL><INDENT>yield __<EOL><DEDENT><DEDENT><DEDENT>except TypeError:<EOL><INDENT>continue<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Runs through each value and transform it with a mapped function.", "id": "f7826:c0:m4"}
{"signature": "def load_support_plugin(name):", "body": "<EOL>stack = list(filter(lambda f: f[<NUM_LIT:3>] == \"<STR_LIT>\", inspect.stack()))<EOL>prev_frame = stack[<NUM_LIT:0>]<EOL>path = os.path.dirname(prev_frame[<NUM_LIT:1>])<EOL>if not os.path.isabs(path):<EOL><INDENT>prefix = os.path.normpath(__file__ + \"<STR_LIT>\")<EOL>path = os.path.join(prefix, path)<EOL><DEDENT>return load_module(name, path)<EOL>", "docstring": "Loads a plugin from the same directory as the calling plugin.\n\n    The path used is extracted from the last call in module scope,\n    therefore this must be called only from module level in the\n    originating plugin or the correct plugin path will not be found.", "id": "f7827:m0"}
{"signature": "def parse_cookies(self, cookies, **kwargs):", "body": "for name, value in _parse_keyvalue_list(cookies):<EOL><INDENT>self.cookies.set(name, value, **kwargs)<EOL><DEDENT>", "docstring": "Parses a semi-colon delimited list of cookies.\n\n        Example: foo=bar;baz=qux", "id": "f7828:c1:m4"}
{"signature": "def parse_query_params(self, cookies, **kwargs):", "body": "for name, value in _parse_keyvalue_list(cookies):<EOL><INDENT>self.params[name] = value<EOL><DEDENT>", "docstring": "Parses a semi-colon delimited list of query parameters.\n\n        Example: foo=bar;baz=qux", "id": "f7828:c1:m6"}
{"signature": "@classmethod<EOL><INDENT>def xml(cls, res, *args, **kwargs):<DEDENT>", "body": "return parse_xml(res.text, *args, **kwargs)<EOL>", "docstring": "Parses XML from a response.", "id": "f7828:c1:m3"}
{"signature": "def xml_findtext(xpath):", "body": "return all(<EOL>xml_find(xpath),<EOL>getattr(\"<STR_LIT:text>\"),<EOL>)<EOL>", "docstring": "Find a XML element via xpath and extract its text.", "id": "f7830:m13"}
{"signature": "def getattr(attr, default=None):", "body": "def getter(value):<EOL><INDENT>return _getattr(value, attr, default)<EOL><DEDENT>return transform(getter)<EOL>", "docstring": "Get a named attribute from an object.\n\n    When a default argument is given, it is returned when the attribute\n    doesn't exist.", "id": "f7830:m6"}
{"signature": "def length(length):", "body": "def min_len(value):<EOL><INDENT>if not len(value) >= length:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\".format(length, len(value))<EOL>)<EOL><DEDENT>return True<EOL><DEDENT>return min_len<EOL>", "docstring": "Checks value for minimum length using len().", "id": "f7830:m1"}
{"signature": "def load_cookies(self):", "body": "if not self.session or not self.cache:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>restored = []<EOL>for key, value in self.cache.get_all().items():<EOL><INDENT>if key.startswith(\"<STR_LIT>\"):<EOL><INDENT>cookie = requests.cookies.create_cookie(**value)<EOL>self.session.http.cookies.set_cookie(cookie)<EOL>restored.append(cookie.name)<EOL><DEDENT><DEDENT>if restored:<EOL><INDENT>self.logger.debug(\"<STR_LIT>\".format(\"<STR_LIT:U+002CU+0020>\".join(restored)))<EOL><DEDENT>return restored<EOL>", "docstring": "Load any stored cookies for the plugin that have not expired.\n\n:return: list of the restored cookie names", "id": "f7834:c1:m16"}
{"signature": "@classmethod<EOL><INDENT>def priority(cls, url):<DEDENT>", "body": "return NORMAL_PRIORITY<EOL>", "docstring": "Return the plugin priority for a given URL, by default it returns\nNORMAL priority.\n:return: priority level", "id": "f7834:c1:m9"}
{"signature": "def save_cookies(self, cookie_filter=None, default_expires=<NUM_LIT> * <NUM_LIT> * <NUM_LIT> * <NUM_LIT:7>):", "body": "if not self.session or not self.cache:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>cookie_filter = cookie_filter or (lambda c: True)<EOL>saved = []<EOL>for cookie in filter(cookie_filter, self.session.http.cookies):<EOL><INDENT>cookie_dict = {}<EOL>for attr in (\"<STR_LIT:version>\", \"<STR_LIT:name>\", \"<STR_LIT:value>\", \"<STR_LIT:port>\", \"<STR_LIT>\", \"<STR_LIT:path>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>cookie_dict[attr] = getattr(cookie, attr, None)<EOL><DEDENT>cookie_dict[\"<STR_LIT>\"] = getattr(cookie, \"<STR_LIT>\", getattr(cookie, \"<STR_LIT>\", None))<EOL>expires = default_expires<EOL>if cookie_dict['<STR_LIT>']:<EOL><INDENT>expires = int(cookie_dict['<STR_LIT>'] - time.time())<EOL><DEDENT>key = \"<STR_LIT>\".format(cookie.name,<EOL>cookie.domain,<EOL>cookie.port_specified and cookie.port or \"<STR_LIT>\",<EOL>cookie.path_specified and cookie.path or \"<STR_LIT:*>\")<EOL>self.cache.set(key, cookie_dict, expires)<EOL>saved.append(cookie.name)<EOL><DEDENT>if saved:<EOL><INDENT>self.logger.debug(\"<STR_LIT>\".format(\"<STR_LIT:U+002CU+0020>\".join(saved)))<EOL><DEDENT>return saved<EOL>", "docstring": "Store the cookies from ``http`` in the plugin cache until they expire. The cookies can be filtered\nby supplying a filter method. eg. ``lambda c: \"auth\" in c.name``. If no expiry date is given in the\ncookie then the ``default_expires`` value will be used.\n\n:param cookie_filter: a function to filter the cookies\n:type cookie_filter: function\n:param default_expires: time (in seconds) until cookies with no expiry will expire\n:type default_expires: int\n:return: list of the saved cookie names", "id": "f7834:c1:m15"}
{"signature": "def __init__(self, name, required=False, requires=None, prompt=None, sensitive=False, argument_name=None,<EOL>dest=None, **options):", "body": "self.required = required<EOL>self.name = name<EOL>self.options = options<EOL>self._argument_name = argument_name  <EOL>self._dest = dest  <EOL>self.requires = requires and (list(requires) if isinstance(requires, (list, tuple)) else [requires]) or []<EOL>self.prompt = prompt<EOL>self.sensitive = sensitive<EOL>self._default = options.get(\"<STR_LIT:default>\")<EOL>", "docstring": ":param name: name of the argument, without -- or plugin name prefixes, eg. ``\"password\"``, ``\"mux-subtitles\"``, etc.\n:param required (bool): if the argument is required for the plugin\n:param requires: list of the arguments which this argument requires, eg ``[\"password\"]``\n:param prompt: if the argument is required and not given, this prompt will show at run time\n:param sensitive (bool): if the argument is sensitive (passwords, etc) and should be masked in logs and if\n                      prompted use askpass\n:param argument_name:\n:param option_name:\n:param options: arguments passed to :func:`ArgumentParser.add_argument`, excluding requires, and dest", "id": "f7837:c1:m0"}
{"signature": "def pkcs7_decode(paddedData, keySize=<NUM_LIT:16>):", "body": "<EOL>val = ord(paddedData[-<NUM_LIT:1>:])<EOL>if val > keySize:<EOL><INDENT>raise StreamError(\"<STR_LIT>\".format(val))<EOL><DEDENT>return paddedData[:-val]<EOL>", "docstring": "Remove the PKCS#7 padding", "id": "f7842:m1"}
{"signature": "@classmethod<EOL><INDENT>def parse_variant_playlist(cls, session_, url, name_key=\"<STR_LIT:name>\",<EOL>name_prefix=\"<STR_LIT>\", check_streams=False,<EOL>force_restart=False, name_fmt=None,<EOL>start_offset=<NUM_LIT:0>, duration=None,<EOL>**request_params):<DEDENT>", "body": "locale = session_.localization<EOL>name_key = request_params.pop(\"<STR_LIT>\", name_key)<EOL>name_prefix = request_params.pop(\"<STR_LIT>\", name_prefix)<EOL>audio_select = session_.options.get(\"<STR_LIT>\") or []<EOL>res = session_.http.get(url, exception=IOError, **request_params)<EOL>try:<EOL><INDENT>parser = hls_playlist.load(res.text, base_uri=res.url)<EOL><DEDENT>except ValueError as err:<EOL><INDENT>raise IOError(\"<STR_LIT>\".format(err))<EOL><DEDENT>streams = {}<EOL>for playlist in filter(lambda p: not p.is_iframe, parser.playlists):<EOL><INDENT>names = dict(name=None, pixels=None, bitrate=None)<EOL>audio_streams = []<EOL>fallback_audio = []<EOL>default_audio = []<EOL>preferred_audio = []<EOL>for media in playlist.media:<EOL><INDENT>if media.type == \"<STR_LIT>\" and media.name:<EOL><INDENT>names[\"<STR_LIT:name>\"] = media.name<EOL><DEDENT>elif media.type == \"<STR_LIT>\":<EOL><INDENT>audio_streams.append(media)<EOL><DEDENT><DEDENT>for media in audio_streams:<EOL><INDENT>if not media.uri:<EOL><INDENT>continue<EOL><DEDENT>if not fallback_audio and media.default:<EOL><INDENT>fallback_audio = [media]<EOL><DEDENT>if not default_audio and (media.autoselect and locale.equivalent(language=media.language)):<EOL><INDENT>default_audio = [media]<EOL><DEDENT>if (('<STR_LIT:*>' in audio_select or media.language in audio_select or media.name in audio_select) or<EOL>((not preferred_audio or media.default) and locale.explicit and locale.equivalent(<EOL>language=media.language))):<EOL><INDENT>preferred_audio.append(media)<EOL><DEDENT><DEDENT>fallback_audio = fallback_audio or (len(audio_streams) and<EOL>audio_streams[<NUM_LIT:0>].uri and [audio_streams[<NUM_LIT:0>]])<EOL>if playlist.stream_info.resolution:<EOL><INDENT>width, height = playlist.stream_info.resolution<EOL>names[\"<STR_LIT>\"] = \"<STR_LIT>\".format(height)<EOL><DEDENT>if playlist.stream_info.bandwidth:<EOL><INDENT>bw = playlist.stream_info.bandwidth<EOL>if bw >= <NUM_LIT:1000>:<EOL><INDENT>names[\"<STR_LIT>\"] = \"<STR_LIT>\".format(int(bw / <NUM_LIT>))<EOL><DEDENT>else:<EOL><INDENT>names[\"<STR_LIT>\"] = \"<STR_LIT>\".format(bw / <NUM_LIT>)<EOL><DEDENT><DEDENT>if name_fmt:<EOL><INDENT>stream_name = name_fmt.format(**names)<EOL><DEDENT>else:<EOL><INDENT>stream_name = (names.get(name_key) or names.get(\"<STR_LIT:name>\") or<EOL>names.get(\"<STR_LIT>\") or names.get(\"<STR_LIT>\"))<EOL><DEDENT>if not stream_name:<EOL><INDENT>continue<EOL><DEDENT>if stream_name in streams:  <EOL><INDENT>stream_name = \"<STR_LIT>\".format(stream_name)<EOL>num_alts = len(list(filter(lambda n: n.startswith(stream_name), streams.keys())))<EOL>if num_alts >= <NUM_LIT:2>:<EOL><INDENT>continue<EOL><DEDENT>elif num_alts > <NUM_LIT:0>:<EOL><INDENT>stream_name = \"<STR_LIT>\".format(stream_name, num_alts + <NUM_LIT:1>)<EOL><DEDENT><DEDENT>if check_streams:<EOL><INDENT>try:<EOL><INDENT>session_.http.get(playlist.uri, **request_params)<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>raise<EOL><DEDENT>except Exception:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>external_audio = preferred_audio or default_audio or fallback_audio<EOL>if external_audio and FFMPEGMuxer.is_usable(session_):<EOL><INDENT>external_audio_msg = \"<STR_LIT:U+002CU+0020>\".join([<EOL>\"<STR_LIT>\".format(x.language, (x.name or \"<STR_LIT>\"))<EOL>for x in external_audio<EOL>])<EOL>log.debug(\"<STR_LIT>\", name_prefix + stream_name,<EOL>external_audio_msg)<EOL>stream = MuxedHLSStream(session_,<EOL>video=playlist.uri,<EOL>audio=[x.uri for x in external_audio if x.uri],<EOL>force_restart=force_restart,<EOL>start_offset=start_offset,<EOL>duration=duration,<EOL>**request_params)<EOL><DEDENT>else:<EOL><INDENT>stream = cls(session_,<EOL>playlist.uri,<EOL>force_restart=force_restart,<EOL>start_offset=start_offset,<EOL>duration=duration,<EOL>**request_params)<EOL><DEDENT>streams[name_prefix + stream_name] = stream<EOL><DEDENT>return streams<EOL>", "docstring": "Attempts to parse a variant playlist and return its streams.\n\n        :param url: The URL of the variant playlist.\n        :param name_key: Prefer to use this key as stream name, valid keys are:\n                         name, pixels, bitrate.\n        :param name_prefix: Add this prefix to the stream names.\n        :param check_streams: Only allow streams that are accessible.\n        :param force_restart: Start at the first segment even for a live stream\n        :param name_fmt: A format string for the name, allowed format keys are\n                         name, pixels, bitrate.", "id": "f7842:c4:m4"}
{"signature": "def put(self, segment):", "body": "if self.closed:<EOL><INDENT>return<EOL><DEDENT>if segment is not None:<EOL><INDENT>future = self.executor.submit(self.fetch, segment,<EOL>retries=self.retries)<EOL><DEDENT>else:<EOL><INDENT>future = None<EOL><DEDENT>self.queue(self.futures, (segment, future))<EOL>", "docstring": "Adds a segment to the download pool and write queue.", "id": "f7850:c1:m2"}
{"signature": "def __reduce__(self):", "body": "items = [[k, self[k]] for k in self]<EOL>inst_dict = vars(self).copy()<EOL>for k in vars(OrderedDict()):<EOL><INDENT>inst_dict.pop(k, None)<EOL><DEDENT>if inst_dict:<EOL><INDENT>return (self.__class__, (items,), inst_dict)<EOL><DEDENT>return self.__class__, (items,)<EOL>", "docstring": "Return state information for pickling", "id": "f7864:c0:m17"}
{"signature": "def __setitem__(self, key, value, dict_setitem=dict.__setitem__):", "body": "<EOL>if key not in self:<EOL><INDENT>root = self.__root<EOL>last = root[<NUM_LIT:0>]<EOL>last[<NUM_LIT:1>] = root[<NUM_LIT:0>] = self.__map[key] = [last, root, key]<EOL><DEDENT>dict_setitem(self, key, value)<EOL>", "docstring": "od.__setitem__(i, y) <==> od[i]=y", "id": "f7864:c0:m1"}
{"signature": "def viewitems(self):", "body": "return ItemsView(self)<EOL>", "docstring": "od.viewitems() -> a set-like object providing a view on od's items", "id": "f7864:c0:m24"}
{"signature": "def pop(self, key, default=__marker):", "body": "if key in self:<EOL><INDENT>result = self[key]<EOL>del self[key]<EOL>return result<EOL><DEDENT>if default is self.__marker:<EOL><INDENT>raise KeyError(key)<EOL><DEDENT>return default<EOL>", "docstring": "od.pop(k[,d]) -> v, remove specified key and return the corresponding value.\n        If key is not found, d is returned if given, otherwise KeyError is raised.", "id": "f7864:c0:m14"}
{"signature": "@classmethod<EOL><INDENT>def fromkeys(cls, iterable, value=None):<DEDENT>", "body": "d = cls()<EOL>for key in iterable:<EOL><INDENT>d[key] = value<EOL><DEDENT>return d<EOL>", "docstring": "OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S\n        and values equal to v (which defaults to None).", "id": "f7864:c0:m19"}
{"signature": "def send(self, request, **kwargs):", "body": "<EOL>if request.method not in (\"<STR_LIT:GET>\", \"<STR_LIT>\"):<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % request.method)<EOL><DEDENT>url_parts = urlparse(request.url)<EOL>if is_win32 and url_parts.netloc.endswith(\"<STR_LIT::>\"):<EOL><INDENT>url_parts = url_parts._replace(path=\"<STR_LIT:/>\" + url_parts.netloc + url_parts.path, netloc='<STR_LIT>')<EOL><DEDENT>if url_parts.netloc and url_parts.netloc not in (\"<STR_LIT:localhost>\", \"<STR_LIT:.>\", \"<STR_LIT:..>\", \"<STR_LIT:->\"):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if url_parts.netloc in (\"<STR_LIT:.>\", \"<STR_LIT:..>\"):<EOL><INDENT>pwd = os.path.abspath(url_parts.netloc).replace(os.sep, \"<STR_LIT:/>\") + \"<STR_LIT:/>\"<EOL>if is_win32:<EOL><INDENT>pwd = \"<STR_LIT:/>\" + pwd<EOL><DEDENT>url_parts = url_parts._replace(path=urljoin(pwd, url_parts.path.lstrip(\"<STR_LIT:/>\")))<EOL><DEDENT>resp = Response()<EOL>resp.url = request.url<EOL>try:<EOL><INDENT>if url_parts.netloc == \"<STR_LIT:->\":<EOL><INDENT>if is_py3:<EOL><INDENT>resp.raw = sys.stdin.buffer<EOL><DEDENT>else:<EOL><INDENT>resp.raw = sys.stdin<EOL><DEDENT>resp.url = \"<STR_LIT>\" + os.path.abspath(\"<STR_LIT:.>\").replace(os.sep, \"<STR_LIT:/>\") + \"<STR_LIT:/>\"<EOL><DEDENT>else:<EOL><INDENT>path_parts = [unquote(p) for p in url_parts.path.split('<STR_LIT:/>')]<EOL>while path_parts and not path_parts[<NUM_LIT:0>]:<EOL><INDENT>path_parts.pop(<NUM_LIT:0>)<EOL><DEDENT>if any(os.sep in p for p in path_parts):<EOL><INDENT>raise IOError(errno.ENOENT, os.strerror(errno.ENOENT))<EOL><DEDENT>if path_parts and (path_parts[<NUM_LIT:0>].endswith('<STR_LIT:|>') or<EOL>path_parts[<NUM_LIT:0>].endswith('<STR_LIT::>')):<EOL><INDENT>path_drive = path_parts.pop(<NUM_LIT:0>)<EOL>if path_drive.endswith('<STR_LIT:|>'):<EOL><INDENT>path_drive = path_drive[:-<NUM_LIT:1>] + '<STR_LIT::>'<EOL><DEDENT>while path_parts and not path_parts[<NUM_LIT:0>]:<EOL><INDENT>path_parts.pop(<NUM_LIT:0>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>path_drive = '<STR_LIT>'<EOL><DEDENT>path = path_drive + os.sep + os.path.join(*path_parts)<EOL>if path_drive and not os.path.splitdrive(path):<EOL><INDENT>path = os.sep + os.path.join(path_drive, *path_parts)<EOL><DEDENT>resp.raw = io.open(path, \"<STR_LIT:rb>\")<EOL>resp.raw.release_conn = resp.raw.close<EOL><DEDENT><DEDENT>except IOError as e:<EOL><INDENT>if e.errno == errno.EACCES:<EOL><INDENT>resp.status_code = codes.forbidden<EOL><DEDENT>elif e.errno == errno.ENOENT:<EOL><INDENT>resp.status_code = codes.not_found<EOL><DEDENT>else:<EOL><INDENT>resp.status_code = codes.bad_request<EOL><DEDENT>resp_str = str(e).encode(locale.getpreferredencoding(False))<EOL>resp.raw = BytesIO(resp_str)<EOL>resp.headers['<STR_LIT>'] = len(resp_str)<EOL>resp.raw.release_conn = resp.raw.close<EOL><DEDENT>else:<EOL><INDENT>resp.status_code = codes.ok<EOL>resp_stat = os.fstat(resp.raw.fileno())<EOL>if stat.S_ISREG(resp_stat.st_mode):<EOL><INDENT>resp.headers['<STR_LIT>'] = resp_stat.st_size<EOL><DEDENT><DEDENT>return resp<EOL>", "docstring": "Wraps a file, described in request, in a Response object.\n\n            :param request: The PreparedRequest` being \"sent\".\n            :returns: a Response object containing the file", "id": "f7867:c0:m0"}
{"signature": "def get_versions():", "body": "<EOL>cfg = get_config()<EOL>verbose = cfg.verbose<EOL>try:<EOL><INDENT>return git_versions_from_keywords(get_keywords(), cfg.tag_prefix,<EOL>verbose)<EOL><DEDENT>except NotThisMethod:<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>root = os.path.realpath(__file__)<EOL>for i in cfg.versionfile_source.split('<STR_LIT:/>'):<EOL><INDENT>root = os.path.dirname(root)<EOL><DEDENT><DEDENT>except NameError:<EOL><INDENT>return {\"<STR_LIT:version>\": \"<STR_LIT>\", \"<STR_LIT>\": None,<EOL>\"<STR_LIT>\": None,<EOL>\"<STR_LIT:error>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:date>\": None}<EOL><DEDENT>try:<EOL><INDENT>pieces = git_pieces_from_vcs(cfg.tag_prefix, root, verbose)<EOL>return render(pieces, cfg.style)<EOL><DEDENT>except NotThisMethod:<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>if cfg.parentdir_prefix:<EOL><INDENT>return versions_from_parentdir(cfg.parentdir_prefix, root, verbose)<EOL><DEDENT><DEDENT>except NotThisMethod:<EOL><INDENT>pass<EOL><DEDENT>return {\"<STR_LIT:version>\": \"<STR_LIT>\", \"<STR_LIT>\": None,<EOL>\"<STR_LIT>\": None,<EOL>\"<STR_LIT:error>\": \"<STR_LIT>\", \"<STR_LIT:date>\": None}<EOL>", "docstring": "Get version information or return default if unable to do so.", "id": "f7868:m16"}
{"signature": "def versions_from_parentdir(parentdir_prefix, root, verbose):", "body": "rootdirs = []<EOL>for i in range(<NUM_LIT:3>):<EOL><INDENT>dirname = os.path.basename(root)<EOL>if dirname.startswith(parentdir_prefix):<EOL><INDENT>return {\"<STR_LIT:version>\": dirname[len(parentdir_prefix):],<EOL>\"<STR_LIT>\": None,<EOL>\"<STR_LIT>\": False, \"<STR_LIT:error>\": None, \"<STR_LIT:date>\": None}<EOL><DEDENT>else:<EOL><INDENT>rootdirs.append(root)<EOL>root = os.path.dirname(root)  <EOL><DEDENT><DEDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" %<EOL>(str(rootdirs), parentdir_prefix))<EOL><DEDENT>raise NotThisMethod(\"<STR_LIT>\")<EOL>", "docstring": "Try to determine the version from the parent directory name.\n\n    Source tarballs conventionally unpack into a directory that includes both\n    the project name and a version string. We will also support searching up\n    two directory levels for an appropriately named parent directory", "id": "f7868:m4"}
{"signature": "def render_pep440_post(pieces):", "body": "if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered = pieces[\"<STR_LIT>\"]<EOL>if pieces[\"<STR_LIT>\"] or pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += \"<STR_LIT>\" % pieces[\"<STR_LIT>\"]<EOL>if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += \"<STR_LIT>\"<EOL><DEDENT>rendered += plus_or_dot(pieces)<EOL>rendered += \"<STR_LIT>\" % pieces[\"<STR_LIT>\"]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>rendered = \"<STR_LIT>\" % pieces[\"<STR_LIT>\"]<EOL>if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += \"<STR_LIT>\"<EOL><DEDENT>rendered += \"<STR_LIT>\" % pieces[\"<STR_LIT>\"]<EOL><DEDENT>return rendered<EOL>", "docstring": "TAG[.postDISTANCE[.dev0]+gHEX] .\n\n    The \".dev0\" means dirty. Note that .dev0 sorts backwards\n    (a dirty tree will appear \"older\" than the corresponding clean one),\n    but you shouldn't be releasing software with -dirty anyways.\n\n    Exceptions:\n    1: no tags. 0.postDISTANCE[.dev0]", "id": "f7868:m11"}
{"signature": "def plus_or_dot(pieces):", "body": "if \"<STR_LIT:+>\" in pieces.get(\"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>return \"<STR_LIT:.>\"<EOL><DEDENT>return \"<STR_LIT:+>\"<EOL>", "docstring": "Return a + if we don't already have one, else return a .", "id": "f7868:m8"}
{"signature": "def register_vcs_handler(vcs, method):  ", "body": "def decorate(f):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if vcs not in HANDLERS:<EOL><INDENT>HANDLERS[vcs] = {}<EOL><DEDENT>HANDLERS[vcs][method] = f<EOL>return f<EOL><DEDENT>return decorate<EOL>", "docstring": "Decorator to mark a method as the handler for a particular VCS.", "id": "f7868:m2"}
{"signature": "def vod_data(self, vid=None):", "body": "page = self.session.http.get(self.url)<EOL>m = self._vod_re.search(page.text)<EOL>vod_data_url = m and urljoin(self.url, m.group(<NUM_LIT:0>))<EOL>if vod_data_url:<EOL><INDENT>self.logger.debug(\"<STR_LIT>\", vod_data_url)<EOL>res = self.session.http.get(vod_data_url)<EOL>return self.session.http.json(res)<EOL><DEDENT>", "docstring": "Get the VOD data path and the default VOD ID\n:return:", "id": "f7878:c0:m6"}
{"signature": "def get_stream_id(self, html):", "body": "stream_id = stream_id_pattern.search(html)<EOL>if not stream_id:<EOL><INDENT>self.logger.error(\"<STR_LIT>\")<EOL><DEDENT>return stream_id.group(\"<STR_LIT>\")<EOL>", "docstring": "Returns the stream_id contained in the HTML.", "id": "f7905:c0:m1"}
{"signature": "def _get_streams(self):", "body": "match = self._url_re.match(self.url).groupdict()<EOL>if match.get(\"<STR_LIT:path>\") == \"<STR_LIT>\":<EOL><INDENT>return self._get_live_streams(match)<EOL><DEDENT>else:<EOL><INDENT>return self._get_vod_stream()<EOL><DEDENT>", "docstring": "Find the streams for euronews\n:return:", "id": "f7923:c0:m3"}
{"signature": "def get_info(self, media_id, fields=None, schema=None):", "body": "params = {\"<STR_LIT>\": media_id}<EOL>if fields:<EOL><INDENT>params[\"<STR_LIT>\"] = \"<STR_LIT:U+002C>\".join(fields)<EOL><DEDENT>return self._api_call(\"<STR_LIT:info>\", params, schema=schema)<EOL>", "docstring": "Returns the data for a certain media item.\n\n:param media_id: id that identifies the media item to be accessed.\n:param fields: list of the media\"s field to be returned. By default the\nAPI returns some fields, but others are not returned unless they are\nexplicity asked for. I have no real documentation on the fields, but\nthey all seem to start with the \"media.\" prefix (e.g. media.name,\nmedia.stream_data).\n:param schema: validation schema to use", "id": "f7928:c1:m6"}
{"signature": "@classmethod<EOL><INDENT>def priority(cls, url):<DEDENT>", "body": "m = cls._url_re.match(url)<EOL>if m:<EOL><INDENT>prefix, url = cls._url_re.match(url).groups()<EOL>url_path = urlparse(url).path<EOL>if prefix is None and url_path.endswith(\"<STR_LIT>\"):<EOL><INDENT>return LOW_PRIORITY<EOL><DEDENT>elif prefix is not None:<EOL><INDENT>return NORMAL_PRIORITY<EOL><DEDENT><DEDENT>return NO_PRIORITY<EOL>", "docstring": "Returns LOW priority if the URL is not prefixed with hls:// but ends with\n.m3u8 and return NORMAL priority if the URL is prefixed.\n:param url: the URL to find the plugin priority for\n:return: plugin priority for the given URL", "id": "f7935:c0:m0"}
{"signature": "def _get_streams(self):", "body": "<EOL>self.login()<EOL>res = self.session.http.get(self.url)<EOL>matches = self.config_re.finditer(res.text)<EOL>try:<EOL><INDENT>config = self.config_schema.validate(dict(<EOL>[m.group(\"<STR_LIT:key>\", \"<STR_LIT:value>\") for m in matches]<EOL>))<EOL><DEDENT>except PluginError:<EOL><INDENT>return<EOL><DEDENT>if config[\"<STR_LIT>\"]:<EOL><INDENT>self.logger.debug(\"<STR_LIT>\", config[\"<STR_LIT>\"])<EOL>api_url = urljoin(self.url, urljoin(config[\"<STR_LIT>\"], config[\"<STR_LIT>\"]))<EOL><DEDENT>elif config[\"<STR_LIT>\"]:<EOL><INDENT>self.logger.debug(\"<STR_LIT>\", config[\"<STR_LIT>\"])<EOL>api_url = urljoin(self.url, config[\"<STR_LIT>\"])<EOL><DEDENT>else:<EOL><INDENT>return<EOL><DEDENT>ares = self.session.http.get(api_url)<EOL>data = self.session.http.json(ares, schema=self.api_schema)<EOL>viewing_urls = data[\"<STR_LIT>\"]<EOL>if \"<STR_LIT:error>\" in viewing_urls:<EOL><INDENT>self.logger.error(\"<STR_LIT>\", viewing_urls[\"<STR_LIT:error>\"])<EOL><DEDENT>else:<EOL><INDENT>for url in viewing_urls[\"<STR_LIT>\"]:<EOL><INDENT>try:<EOL><INDENT>label = \"<STR_LIT>\".format(url.get(\"<STR_LIT>\", url[\"<STR_LIT:label>\"]))<EOL><DEDENT>except KeyError:<EOL><INDENT>label = \"<STR_LIT>\"<EOL><DEDENT>if url[\"<STR_LIT:type>\"] == \"<STR_LIT>\" and RTMPStream.is_usable(self.session):<EOL><INDENT>params = {<EOL>\"<STR_LIT>\": url[\"<STR_LIT:src>\"],<EOL>\"<STR_LIT>\": self.url,<EOL>\"<STR_LIT>\": True,<EOL>}<EOL>yield label, RTMPStream(self.session, params)<EOL><DEDENT>elif url[\"<STR_LIT:type>\"] == \"<STR_LIT>\":<EOL><INDENT>for s in HLSStream.parse_variant_playlist(self.session, url[\"<STR_LIT:src>\"]).items():<EOL><INDENT>yield s<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Get the config object from the page source and call the\nAPI to get the list of streams\n:return:", "id": "f7969:c0:m2"}
{"signature": "def login(self):", "body": "email = self.get_option(\"<STR_LIT:email>\")<EOL>password = self.get_option(\"<STR_LIT:password>\")<EOL>if email and password:<EOL><INDENT>res = self.session.http.get(self.login_url)<EOL>csrf_match = self.csrf_re.search(res.text)<EOL>token = csrf_match and csrf_match.group(<NUM_LIT:1>)<EOL>self.logger.debug(\"<STR_LIT>\", email, token)<EOL>res = self.session.http.post(self.login_url,<EOL>data=dict(login=email, password=password, csrfmiddlewaretoken=token),<EOL>allow_redirects=False,<EOL>raise_for_status=False,<EOL>headers={\"<STR_LIT>\": self.login_url})<EOL>if res.status_code != <NUM_LIT>:<EOL><INDENT>self.logger.error(\"<STR_LIT>\", email)<EOL><DEDENT><DEDENT>", "docstring": "Attempt a login to LiveEdu.tv", "id": "f7969:c0:m1"}
{"signature": "def login(self, ptrt_url):", "body": "def auth_check(res):<EOL><INDENT>return ptrt_url in ([h.url for h in res.history] + [res.url])<EOL><DEDENT>session_res = self.session.http.get(<EOL>self.session_url,<EOL>params=dict(ptrt=ptrt_url)<EOL>)<EOL>if auth_check(session_res):<EOL><INDENT>log.debug(\"<STR_LIT>\")<EOL>return True<EOL><DEDENT>http_nonce = self._extract_nonce(session_res)<EOL>res = self.session.http.post(<EOL>self.auth_url,<EOL>params=dict(<EOL>ptrt=ptrt_url,<EOL>nonce=http_nonce<EOL>),<EOL>data=dict(<EOL>jsEnabled=True,<EOL>username=self.get_option(\"<STR_LIT:username>\"),<EOL>password=self.get_option('<STR_LIT:password>'),<EOL>attempts=<NUM_LIT:0><EOL>),<EOL>headers={\"<STR_LIT>\": self.url})<EOL>return auth_check(res)<EOL>", "docstring": "Create session using BBC ID. See https://www.bbc.co.uk/usingthebbc/account/\n\n:param ptrt_url: The snapback URL to redirect to after successful authentication\n:type ptrt_url: string\n:return: Whether authentication was successful\n:rtype: bool", "id": "f7995:c0:m6"}
{"signature": "@property<EOL><INDENT>def device_id(self):<DEDENT>", "body": "if self._device_id is None:<EOL><INDENT>self._device_id = \"<STR_LIT>\".join(<EOL>random.choice(\"<STR_LIT>\") for _ in range(<NUM_LIT:50>))<EOL><DEDENT>return self._device_id<EOL>", "docstring": "Randomly generated deviceId.\n:return:", "id": "f8027:c0:m2"}
{"signature": "def hours_minutes_seconds(value):", "body": "try:<EOL><INDENT>return int(value)<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT>match = (_hours_minutes_seconds_re.match(value)<EOL>or _hours_minutes_seconds_2_re.match(value))<EOL>if not match:<EOL><INDENT>raise ValueError<EOL><DEDENT>s = <NUM_LIT:0><EOL>s += int(match.group(\"<STR_LIT>\") or \"<STR_LIT:0>\") * <NUM_LIT> * <NUM_LIT><EOL>s += int(match.group(\"<STR_LIT>\") or \"<STR_LIT:0>\") * <NUM_LIT><EOL>s += int(match.group(\"<STR_LIT>\") or \"<STR_LIT:0>\")<EOL>return s<EOL>", "docstring": "converts a timestamp to seconds\n\n      - hours:minutes:seconds to seconds\n      - minutes:seconds to seconds\n      - 11h22m33s to seconds\n      - 11h to seconds\n      - 20h15m to seconds\n      - seconds to seconds\n\n    :param value: hh:mm:ss ; 00h00m00s ; seconds\n    :return: seconds", "id": "f8052:m0"}
{"signature": "def prepend_www(url):", "body": "parsed = urlparse(url)<EOL>if parsed.netloc.split(\"<STR_LIT:.>\")[<NUM_LIT:0>] != \"<STR_LIT>\":<EOL><INDENT>return parsed.scheme + \"<STR_LIT>\" + parsed.netloc + parsed.path<EOL><DEDENT>else:<EOL><INDENT>return url<EOL><DEDENT>", "docstring": "Changes google.com to www.google.com", "id": "f8056:m3"}
{"signature": "def parse_qsd(data, name=\"<STR_LIT>\", exception=PluginError, schema=None, **params):", "body": "value = dict(parse_qsl(data, **params))<EOL>if schema:<EOL><INDENT>value = schema.validate(value, name=name, exception=exception)<EOL><DEDENT>return value<EOL>", "docstring": "Parses a query string into a dict.\n\n    Unlike parse_qs and parse_qsl, duplicate keys are not preserved in\n    favor of a simpler return value.", "id": "f8056:m6"}
{"signature": "def url_equal(first, second, ignore_scheme=False, ignore_netloc=False, ignore_path=False, ignore_params=False,<EOL>ignore_query=False, ignore_fragment=False):", "body": "<EOL>firstp = urlparse(first)<EOL>secondp = urlparse(second)<EOL>return ((firstp.scheme == secondp.scheme or ignore_scheme) and<EOL>(firstp.netloc == secondp.netloc or ignore_netloc) and<EOL>(firstp.path == secondp.path or ignore_path) and<EOL>(firstp.params == secondp.params or ignore_params) and<EOL>(firstp.query == secondp.query or ignore_query) and<EOL>(firstp.fragment == secondp.fragment or ignore_fragment))<EOL>", "docstring": "Compare two URLs and return True if they are equal, some parts of the URLs can be ignored\n:param first: URL\n:param second: URL\n:param ignore_scheme: ignore the scheme\n:param ignore_netloc: ignore the netloc\n:param ignore_path: ignore the path\n:param ignore_params: ignore the params\n:param ignore_query: ignore the query string\n:param ignore_fragment: ignore the fragment\n:return: result of comparison", "id": "f8059:m1"}
{"signature": "def update_qsd(url, qsd=None, remove=None):", "body": "qsd = qsd or {}<EOL>remove = remove or []<EOL>parsed = urlparse(url)<EOL>current_qsd = OrderedDict(parse_qsl(parsed.query))<EOL>if remove == \"<STR_LIT:*>\":<EOL><INDENT>remove = list(current_qsd.keys())<EOL><DEDENT>for key in remove:<EOL><INDENT>if key not in qsd:<EOL><INDENT>del current_qsd[key]<EOL><DEDENT><DEDENT>for key, value in qsd.items():<EOL><INDENT>if value:<EOL><INDENT>current_qsd[key] = value<EOL><DEDENT><DEDENT>return parsed._replace(query=urlencode(current_qsd)).geturl()<EOL>", "docstring": "Update or remove keys from a query string in a URL\n\n:param url: URL to update\n:param qsd: dict of keys to update, a None value leaves it unchanged\n:param remove: list of keys to remove, or \"*\" to remove all\n               note: updated keys are never removed, even if unchanged\n:return: updated URL", "id": "f8059:m3"}
{"signature": "def set_loglevel(self, level):", "body": "self.logger.set_level(level)<EOL>", "docstring": "Sets the log level used by this session.\n\n        Valid levels are: \"none\", \"error\", \"warning\", \"info\"\n        and \"debug\".\n\n        :param level: level of logging to output", "id": "f8063:c0:m6"}
{"signature": "def makeRecord(self, name, level, fn, lno, msg, args, exc_info,<EOL>func=None, extra=None, sinfo=None):", "body": "if name.startswith(\"<STR_LIT>\"):<EOL><INDENT>rv = _LogRecord(name, level, fn, lno, msg, args, exc_info, func, sinfo)<EOL><DEDENT>else:<EOL><INDENT>rv = _CompatLogRecord(name, level, fn, lno, msg, args, exc_info, func, sinfo)<EOL><DEDENT>if extra is not None:<EOL><INDENT>for key in extra:<EOL><INDENT>if (key in [\"<STR_LIT:message>\", \"<STR_LIT>\"]) or (key in rv.__dict__):<EOL><INDENT>raise KeyError(\"<STR_LIT>\" % key)<EOL><DEDENT>rv.__dict__[key] = extra[key]<EOL><DEDENT><DEDENT>return rv<EOL>", "docstring": "A factory method which can be overridden in subclasses to create\nspecialized LogRecords.", "id": "f8064:c2:m2"}
{"signature": "def iter_http_requests(server, player):", "body": "while not player or player.running:<EOL><INDENT>try:<EOL><INDENT>yield server.open(timeout=<NUM_LIT>)<EOL><DEDENT>except OSError:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>", "docstring": "Repeatedly accept HTTP connections on a server.\n\n    Forever if the serving externally, or while a player is running if it is not\n    empty.", "id": "f8069:m4"}
{"signature": "def setup_plugins(extra_plugin_dir=None):", "body": "if os.path.isdir(PLUGINS_DIR):<EOL><INDENT>load_plugins([PLUGINS_DIR])<EOL><DEDENT>if extra_plugin_dir:<EOL><INDENT>load_plugins(extra_plugin_dir)<EOL><DEDENT>", "docstring": "Loads any additional plugins.", "id": "f8069:m23"}
{"signature": "def fetch_streams_with_retry(plugin, interval, count):", "body": "try:<EOL><INDENT>streams = fetch_streams(plugin)<EOL><DEDENT>except PluginError as err:<EOL><INDENT>log.error(u\"<STR_LIT>\", err)<EOL>streams = None<EOL><DEDENT>if not streams:<EOL><INDENT>log.info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\", interval)<EOL><DEDENT>attempts = <NUM_LIT:0><EOL>while not streams:<EOL><INDENT>sleep(interval)<EOL>try:<EOL><INDENT>streams = fetch_streams(plugin)<EOL><DEDENT>except FatalPluginError as err:<EOL><INDENT>raise<EOL><DEDENT>except PluginError as err:<EOL><INDENT>log.error(u\"<STR_LIT>\", err)<EOL><DEDENT>if count > <NUM_LIT:0>:<EOL><INDENT>attempts += <NUM_LIT:1><EOL>if attempts >= count:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>return streams<EOL>", "docstring": "Attempts to fetch streams repeatedly\n       until some are returned or limit hit.", "id": "f8069:m12"}
{"signature": "def output_stream_passthrough(plugin, stream):", "body": "global output<EOL>title = create_title(plugin)<EOL>filename = '<STR_LIT>'.format(stream_to_url(stream))<EOL>output = PlayerOutput(args.player, args=args.player_args,<EOL>filename=filename, call=True,<EOL>quiet=not args.verbose_player,<EOL>title=title)<EOL>try:<EOL><INDENT>log.info(\"<STR_LIT>\", args.player)<EOL>output.open()<EOL><DEDENT>except OSError as err:<EOL><INDENT>console.exit(\"<STR_LIT>\", args.player, err)<EOL>return False<EOL><DEDENT>return True<EOL>", "docstring": "Prepares a filename to be passed to the player.", "id": "f8069:m6"}
{"signature": "def log_current_versions():", "body": "if logger.root.isEnabledFor(logging.DEBUG):<EOL><INDENT>if sys.platform == \"<STR_LIT>\":<EOL><INDENT>os_version = \"<STR_LIT>\".format(platform.mac_ver()[<NUM_LIT:0>])<EOL><DEDENT>elif sys.platform.startswith(\"<STR_LIT>\"):<EOL><INDENT>os_version = \"<STR_LIT>\".format(platform.system(), platform.release())<EOL><DEDENT>else:<EOL><INDENT>os_version = platform.platform()<EOL><DEDENT>log.debug(\"<STR_LIT>\".format(os_version))<EOL>log.debug(\"<STR_LIT>\".format(platform.python_version()))<EOL>log.debug(\"<STR_LIT>\".format(streamlink_version))<EOL>log.debug(\"<STR_LIT>\".format(<EOL>requests.__version__, socks_version, websocket_version))<EOL><DEDENT>", "docstring": "Show current installed versions", "id": "f8069:m29"}
{"signature": "def setup_args(parser, config_files=[], ignore_unknown=False):", "body": "global args<EOL>arglist = sys.argv[<NUM_LIT:1>:]<EOL>for config_file in filter(os.path.isfile, config_files):<EOL><INDENT>arglist.insert(<NUM_LIT:0>, \"<STR_LIT:@>\" + config_file)<EOL><DEDENT>args, unknown = parser.parse_known_args(arglist)<EOL>if unknown and not ignore_unknown:<EOL><INDENT>msg = gettext('<STR_LIT>')<EOL>parser.error(msg % '<STR_LIT:U+0020>'.join(unknown))<EOL><DEDENT>if args.stream:<EOL><INDENT>args.stream = [stream.lower() for stream in args.stream]<EOL><DEDENT>if not args.url and args.url_param:<EOL><INDENT>args.url = args.url_param<EOL><DEDENT>", "docstring": "Parses arguments.", "id": "f8069:m19"}
{"signature": "def check_file_output(filename, force):", "body": "log.debug(\"<STR_LIT>\")<EOL>if os.path.isfile(filename) and not force:<EOL><INDENT>if sys.stdin.isatty():<EOL><INDENT>answer = console.ask(\"<STR_LIT>\",<EOL>filename)<EOL>if answer.lower() != \"<STR_LIT:y>\":<EOL><INDENT>sys.exit()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>log.error(\"<STR_LIT>\".format(filename))<EOL>sys.exit()<EOL><DEDENT><DEDENT>return FileOutput(filename)<EOL>", "docstring": "Checks if file already exists and ask the user if it should\n    be overwritten if it does.", "id": "f8069:m0"}
{"signature": "def output_stream_http(plugin, initial_streams, external=False, port=<NUM_LIT:0>):", "body": "global output<EOL>if not external:<EOL><INDENT>if not args.player:<EOL><INDENT>console.exit(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>title = create_title(plugin)<EOL>server = create_http_server()<EOL>player = output = PlayerOutput(args.player, args=args.player_args,<EOL>filename=server.url,<EOL>quiet=not args.verbose_player,<EOL>title=title)<EOL>try:<EOL><INDENT>log.info(\"<STR_LIT>\", args.player)<EOL>if player:<EOL><INDENT>player.open()<EOL><DEDENT><DEDENT>except OSError as err:<EOL><INDENT>console.exit(\"<STR_LIT>\",<EOL>args.player, err)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>server = create_http_server(host=None, port=port)<EOL>player = None<EOL>log.info(\"<STR_LIT>\")<EOL>for url in server.urls:<EOL><INDENT>log.info(\"<STR_LIT:U+0020>\" + url)<EOL><DEDENT><DEDENT>for req in iter_http_requests(server, player):<EOL><INDENT>user_agent = req.headers.get(\"<STR_LIT>\") or \"<STR_LIT>\"<EOL>log.info(\"<STR_LIT>\".format(user_agent))<EOL>stream_fd = prebuffer = None<EOL>while not stream_fd and (not player or player.running):<EOL><INDENT>try:<EOL><INDENT>streams = initial_streams or fetch_streams(plugin)<EOL>initial_streams = None<EOL>for stream_name in (resolve_stream_name(streams, s) for s in args.stream):<EOL><INDENT>if stream_name in streams:<EOL><INDENT>stream = streams[stream_name]<EOL>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>log.info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>sleep(<NUM_LIT:10>)<EOL>continue<EOL><DEDENT><DEDENT>except PluginError as err:<EOL><INDENT>log.error(u\"<STR_LIT>\", err)<EOL>continue<EOL><DEDENT>try:<EOL><INDENT>log.info(\"<STR_LIT>\", stream_name,<EOL>type(stream).shortname())<EOL>stream_fd, prebuffer = open_stream(stream)<EOL><DEDENT>except StreamError as err:<EOL><INDENT>log.error(\"<STR_LIT>\", err)<EOL><DEDENT><DEDENT>if stream_fd and prebuffer:<EOL><INDENT>log.debug(\"<STR_LIT>\")<EOL>read_stream(stream_fd, server, prebuffer)<EOL><DEDENT>server.close(True)<EOL><DEDENT>player.close()<EOL>server.close()<EOL>", "docstring": "Continuously output the stream over HTTP.", "id": "f8069:m5"}
{"signature": "def authenticate_twitch_oauth():", "body": "client_id = TWITCH_CLIENT_ID<EOL>redirect_uri = \"<STR_LIT>\"<EOL>url = (\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\").format(client_id, redirect_uri)<EOL>console.msg(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>try:<EOL><INDENT>if not webbrowser.open_new_tab(url):<EOL><INDENT>raise webbrowser.Error<EOL><DEDENT><DEDENT>except webbrowser.Error:<EOL><INDENT>console.exit(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(url))<EOL><DEDENT>", "docstring": "Opens a web browser to allow the user to grant Streamlink\n       access to their Twitch account.", "id": "f8069:m17"}
{"signature": "def handle_url():", "body": "try:<EOL><INDENT>plugin = streamlink.resolve_url(args.url)<EOL>setup_plugin_options(streamlink, plugin)<EOL>log.info(\"<STR_LIT>\",<EOL>plugin.module, args.url)<EOL>plugin_args = []<EOL>for parg in plugin.arguments:<EOL><INDENT>value = plugin.get_option(parg.dest)<EOL>if value:<EOL><INDENT>plugin_args.append((parg, value))<EOL><DEDENT><DEDENT>if plugin_args:<EOL><INDENT>log.debug(\"<STR_LIT>\")<EOL>for parg, value in plugin_args:<EOL><INDENT>log.debug(\"<STR_LIT>\".format(parg.argument_name(plugin.module),<EOL>value if not parg.sensitive else (\"<STR_LIT:*>\" * <NUM_LIT:8>),<EOL>parg.dest))<EOL><DEDENT><DEDENT>if args.retry_max or args.retry_streams:<EOL><INDENT>retry_streams = <NUM_LIT:1><EOL>retry_max = <NUM_LIT:0><EOL>if args.retry_streams:<EOL><INDENT>retry_streams = args.retry_streams<EOL><DEDENT>if args.retry_max:<EOL><INDENT>retry_max = args.retry_max<EOL><DEDENT>streams = fetch_streams_with_retry(plugin, retry_streams,<EOL>retry_max)<EOL><DEDENT>else:<EOL><INDENT>streams = fetch_streams(plugin)<EOL><DEDENT><DEDENT>except NoPluginError:<EOL><INDENT>console.exit(\"<STR_LIT>\", args.url)<EOL><DEDENT>except PluginError as err:<EOL><INDENT>console.exit(u\"<STR_LIT>\", err)<EOL><DEDENT>if not streams:<EOL><INDENT>console.exit(\"<STR_LIT>\", args.url)<EOL><DEDENT>if args.default_stream and not args.stream and not args.json:<EOL><INDENT>args.stream = args.default_stream<EOL><DEDENT>if args.stream:<EOL><INDENT>validstreams = format_valid_streams(plugin, streams)<EOL>for stream_name in args.stream:<EOL><INDENT>if stream_name in streams:<EOL><INDENT>log.info(\"<STR_LIT>\", validstreams)<EOL>handle_stream(plugin, streams, stream_name)<EOL>return<EOL><DEDENT><DEDENT>err = (\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(\"<STR_LIT:U+002CU+0020>\".join(args.stream)))<EOL>if console.json:<EOL><INDENT>console.msg_json(dict(streams=streams, plugin=plugin.module,<EOL>error=err))<EOL><DEDENT>else:<EOL><INDENT>console.exit(\"<STR_LIT>\",<EOL>err, validstreams)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if console.json:<EOL><INDENT>console.msg_json(dict(streams=streams, plugin=plugin.module))<EOL><DEDENT>else:<EOL><INDENT>validstreams = format_valid_streams(plugin, streams)<EOL>console.msg(\"<STR_LIT>\", validstreams)<EOL><DEDENT><DEDENT>", "docstring": "The URL handler.\n\n    Attempts to resolve the URL to a plugin and then attempts\n    to fetch a list of available streams.\n\n    Proceeds to handle stream if user specified a valid one,\n    otherwise output list of valid streams.", "id": "f8069:m15"}
{"signature": "def terminal_width(value):", "body": "if isinstance(value, bytes):<EOL><INDENT>value = value.decode(\"<STR_LIT:utf8>\", \"<STR_LIT:ignore>\")<EOL><DEDENT>return sum(map(get_width, map(ord, value)))<EOL>", "docstring": "Returns the width of the string it would be when displayed.", "id": "f8072:m1"}
{"signature": "def create_status_line(**params):", "body": "max_size = get_terminal_size().columns - <NUM_LIT:1><EOL>for fmt in PROGRESS_FORMATS:<EOL><INDENT>status = fmt.format(**params)<EOL>if len(status) <= max_size:<EOL><INDENT>break<EOL><DEDENT><DEDENT>return status<EOL>", "docstring": "Creates a status line with appropriate size.", "id": "f8072:m6"}
{"signature": "def versions_from_parentdir(parentdir_prefix, root, verbose):", "body": "rootdirs = []<EOL>for i in range(<NUM_LIT:3>):<EOL><INDENT>dirname = os.path.basename(root)<EOL>if dirname.startswith(parentdir_prefix):<EOL><INDENT>return {\"<STR_LIT:version>\": dirname[len(parentdir_prefix):],<EOL>\"<STR_LIT>\": None,<EOL>\"<STR_LIT>\": False, \"<STR_LIT:error>\": None, \"<STR_LIT:date>\": None}<EOL><DEDENT>else:<EOL><INDENT>rootdirs.append(root)<EOL>root = os.path.dirname(root)  <EOL><DEDENT><DEDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" %<EOL>(str(rootdirs), parentdir_prefix))<EOL><DEDENT>raise NotThisMethod(\"<STR_LIT>\")<EOL>", "docstring": "Try to determine the version from the parent directory name.\n\n    Source tarballs conventionally unpack into a directory that includes both\n    the project name and a version string. We will also support searching up\n    two directory levels for an appropriately named parent directory", "id": "f8078:m8"}
{"signature": "def get_cmdclass():", "body": "if \"<STR_LIT>\" in sys.modules:<EOL><INDENT>del sys.modules[\"<STR_LIT>\"]<EOL><DEDENT>cmds = {}<EOL>from distutils.core import Command<EOL>class cmd_version(Command):<EOL><INDENT>description = \"<STR_LIT>\"<EOL>user_options = []<EOL>boolean_options = []<EOL>def initialize_options(self):<EOL><INDENT>pass<EOL><DEDENT>def finalize_options(self):<EOL><INDENT>pass<EOL><DEDENT>def run(self):<EOL><INDENT>vers = get_versions(verbose=True)<EOL>print(\"<STR_LIT>\" % vers[\"<STR_LIT:version>\"])<EOL>print(\"<STR_LIT>\" % vers.get(\"<STR_LIT>\"))<EOL>print(\"<STR_LIT>\" % vers.get(\"<STR_LIT>\"))<EOL>print(\"<STR_LIT>\" % vers.get(\"<STR_LIT:date>\"))<EOL>if vers[\"<STR_LIT:error>\"]:<EOL><INDENT>print(\"<STR_LIT>\" % vers[\"<STR_LIT:error>\"])<EOL><DEDENT><DEDENT><DEDENT>cmds[\"<STR_LIT:version>\"] = cmd_version<EOL>if \"<STR_LIT>\" in sys.modules:<EOL><INDENT>from setuptools.command.build_py import build_py as _build_py<EOL><DEDENT>else:<EOL><INDENT>from distutils.command.build_py import build_py as _build_py<EOL><DEDENT>class cmd_build_py(_build_py):<EOL><INDENT>def run(self):<EOL><INDENT>root = get_root()<EOL>cfg = get_config_from_root(root)<EOL>versions = get_versions()<EOL>_build_py.run(self)<EOL>if cfg.versionfile_build:<EOL><INDENT>target_versionfile = os.path.join(self.build_lib,<EOL>cfg.versionfile_build)<EOL>print(\"<STR_LIT>\" % target_versionfile)<EOL>write_to_version_file(target_versionfile, versions)<EOL><DEDENT><DEDENT><DEDENT>cmds[\"<STR_LIT>\"] = cmd_build_py<EOL>if \"<STR_LIT>\" in sys.modules:  <EOL><INDENT>from cx_Freeze.dist import build_exe as _build_exe<EOL>class cmd_build_exe(_build_exe):<EOL><INDENT>def run(self):<EOL><INDENT>root = get_root()<EOL>cfg = get_config_from_root(root)<EOL>versions = get_versions()<EOL>target_versionfile = cfg.versionfile_source<EOL>print(\"<STR_LIT>\" % target_versionfile)<EOL>write_to_version_file(target_versionfile, versions)<EOL>_build_exe.run(self)<EOL>os.unlink(target_versionfile)<EOL>with open(cfg.versionfile_source, \"<STR_LIT:w>\") as f:<EOL><INDENT>LONG = LONG_VERSION_PY[cfg.VCS]<EOL>f.write(LONG %<EOL>{\"<STR_LIT>\": \"<STR_LIT:$>\",<EOL>\"<STR_LIT>\": cfg.style,<EOL>\"<STR_LIT>\": cfg.tag_prefix,<EOL>\"<STR_LIT>\": cfg.parentdir_prefix,<EOL>\"<STR_LIT>\": cfg.versionfile_source,<EOL>})<EOL><DEDENT><DEDENT><DEDENT>cmds[\"<STR_LIT>\"] = cmd_build_exe<EOL>del cmds[\"<STR_LIT>\"]<EOL><DEDENT>if '<STR_LIT>' in sys.modules:  <EOL><INDENT>try:<EOL><INDENT>from py2exe.distutils_buildexe import py2exe as _py2exe  <EOL><DEDENT>except ImportError:<EOL><INDENT>from py2exe.build_exe import py2exe as _py2exe  <EOL><DEDENT>class cmd_py2exe(_py2exe):<EOL><INDENT>def run(self):<EOL><INDENT>root = get_root()<EOL>cfg = get_config_from_root(root)<EOL>versions = get_versions()<EOL>target_versionfile = cfg.versionfile_source<EOL>print(\"<STR_LIT>\" % target_versionfile)<EOL>write_to_version_file(target_versionfile, versions)<EOL>_py2exe.run(self)<EOL>os.unlink(target_versionfile)<EOL>with open(cfg.versionfile_source, \"<STR_LIT:w>\") as f:<EOL><INDENT>LONG = LONG_VERSION_PY[cfg.VCS]<EOL>f.write(LONG %<EOL>{\"<STR_LIT>\": \"<STR_LIT:$>\",<EOL>\"<STR_LIT>\": cfg.style,<EOL>\"<STR_LIT>\": cfg.tag_prefix,<EOL>\"<STR_LIT>\": cfg.parentdir_prefix,<EOL>\"<STR_LIT>\": cfg.versionfile_source,<EOL>})<EOL><DEDENT><DEDENT><DEDENT>cmds[\"<STR_LIT>\"] = cmd_py2exe<EOL><DEDENT>if \"<STR_LIT>\" in sys.modules:<EOL><INDENT>from setuptools.command.sdist import sdist as _sdist<EOL><DEDENT>else:<EOL><INDENT>from distutils.command.sdist import sdist as _sdist<EOL><DEDENT>class cmd_sdist(_sdist):<EOL><INDENT>def run(self):<EOL><INDENT>versions = get_versions()<EOL>self._versioneer_generated_versions = versions<EOL>self.distribution.metadata.version = versions[\"<STR_LIT:version>\"]<EOL>return _sdist.run(self)<EOL><DEDENT>def make_release_tree(self, base_dir, files):<EOL><INDENT>root = get_root()<EOL>cfg = get_config_from_root(root)<EOL>_sdist.make_release_tree(self, base_dir, files)<EOL>target_versionfile = os.path.join(base_dir, cfg.versionfile_source)<EOL>print(\"<STR_LIT>\" % target_versionfile)<EOL>write_to_version_file(target_versionfile,<EOL>self._versioneer_generated_versions)<EOL><DEDENT><DEDENT>cmds[\"<STR_LIT>\"] = cmd_sdist<EOL>return cmds<EOL>", "docstring": "Get the custom setuptools/distutils subclasses used by Versioneer.", "id": "f8078:m21"}
{"signature": "def get_versions(verbose=False):", "body": "if \"<STR_LIT>\" in sys.modules:<EOL><INDENT>del sys.modules[\"<STR_LIT>\"]<EOL><DEDENT>root = get_root()<EOL>cfg = get_config_from_root(root)<EOL>assert cfg.VCS is not None, \"<STR_LIT>\"<EOL>handlers = HANDLERS.get(cfg.VCS)<EOL>assert handlers, \"<STR_LIT>\" % cfg.VCS<EOL>verbose = verbose or cfg.verbose<EOL>assert cfg.versionfile_source is not None,\"<STR_LIT>\"<EOL>assert cfg.tag_prefix is not None, \"<STR_LIT>\"<EOL>versionfile_abs = os.path.join(root, cfg.versionfile_source)<EOL>get_keywords_f = handlers.get(\"<STR_LIT>\")<EOL>from_keywords_f = handlers.get(\"<STR_LIT>\")<EOL>if get_keywords_f and from_keywords_f:<EOL><INDENT>try:<EOL><INDENT>keywords = get_keywords_f(versionfile_abs)<EOL>ver = from_keywords_f(keywords, cfg.tag_prefix, verbose)<EOL>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % ver)<EOL><DEDENT>return ver<EOL><DEDENT>except NotThisMethod:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>try:<EOL><INDENT>ver = versions_from_file(versionfile_abs)<EOL>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % (versionfile_abs, ver))<EOL><DEDENT>return ver<EOL><DEDENT>except NotThisMethod:<EOL><INDENT>pass<EOL><DEDENT>from_vcs_f = handlers.get(\"<STR_LIT>\")<EOL>if from_vcs_f:<EOL><INDENT>try:<EOL><INDENT>pieces = from_vcs_f(cfg.tag_prefix, root, verbose)<EOL>ver = render(pieces, cfg.style)<EOL>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % ver)<EOL><DEDENT>return ver<EOL><DEDENT>except NotThisMethod:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>try:<EOL><INDENT>if cfg.parentdir_prefix:<EOL><INDENT>ver = versions_from_parentdir(cfg.parentdir_prefix, root, verbose)<EOL>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % ver)<EOL><DEDENT>return ver<EOL><DEDENT><DEDENT>except NotThisMethod:<EOL><INDENT>pass<EOL><DEDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>return {\"<STR_LIT:version>\": \"<STR_LIT>\", \"<STR_LIT>\": None,<EOL>\"<STR_LIT>\": None, \"<STR_LIT:error>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:date>\": None}<EOL>", "docstring": "Get the project version from whatever source is available.\n\n    Returns dict with two keys: 'version' and 'full'.", "id": "f8078:m19"}
{"signature": "def register_vcs_handler(vcs, method):  ", "body": "def decorate(f):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if vcs not in HANDLERS:<EOL><INDENT>HANDLERS[vcs] = {}<EOL><DEDENT>HANDLERS[vcs][method] = f<EOL>return f<EOL><DEDENT>return decorate<EOL>", "docstring": "Decorator to mark a method as the handler for a particular VCS.", "id": "f8078:m2"}
{"signature": "def write_to_version_file(filename, versions):", "body": "os.unlink(filename)<EOL>contents = json.dumps(versions, sort_keys=True,<EOL>indent=<NUM_LIT:1>, separators=(\"<STR_LIT:U+002C>\", \"<STR_LIT>\"))<EOL>with open(filename, \"<STR_LIT:w>\") as f:<EOL><INDENT>f.write(SHORT_VERSION_PY % contents)<EOL><DEDENT>print(\"<STR_LIT>\" % (filename, versions[\"<STR_LIT:version>\"]))<EOL>", "docstring": "Write the given version number to the given _version.py file.", "id": "f8078:m10"}
{"signature": "def do_vcs_install(manifest_in, versionfile_source, ipy):", "body": "GITS = [\"<STR_LIT>\"]<EOL>if sys.platform == \"<STR_LIT:win32>\":<EOL><INDENT>GITS = [\"<STR_LIT>\", \"<STR_LIT>\"]<EOL><DEDENT>files = [manifest_in, versionfile_source]<EOL>if ipy:<EOL><INDENT>files.append(ipy)<EOL><DEDENT>try:<EOL><INDENT>me = __file__<EOL>if me.endswith(\"<STR_LIT>\") or me.endswith(\"<STR_LIT>\"):<EOL><INDENT>me = os.path.splitext(me)[<NUM_LIT:0>] + \"<STR_LIT>\"<EOL><DEDENT>versioneer_file = os.path.relpath(me)<EOL><DEDENT>except NameError:<EOL><INDENT>versioneer_file = \"<STR_LIT>\"<EOL><DEDENT>files.append(versioneer_file)<EOL>present = False<EOL>try:<EOL><INDENT>f = open(\"<STR_LIT>\", \"<STR_LIT:r>\")<EOL>for line in f.readlines():<EOL><INDENT>if line.strip().startswith(versionfile_source):<EOL><INDENT>if \"<STR_LIT>\" in line.strip().split()[<NUM_LIT:1>:]:<EOL><INDENT>present = True<EOL><DEDENT><DEDENT><DEDENT>f.close()<EOL><DEDENT>except EnvironmentError:<EOL><INDENT>pass<EOL><DEDENT>if not present:<EOL><INDENT>f = open(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>f.write(\"<STR_LIT>\" % versionfile_source)<EOL>f.close()<EOL>files.append(\"<STR_LIT>\")<EOL><DEDENT>run_command(GITS, [\"<STR_LIT>\", \"<STR_LIT>\"] + files)<EOL>", "docstring": "Git-specific installation logic for Versioneer.\n\n    For Git, this means creating/changing .gitattributes to mark _version.py\n    for export-subst keyword substitution.", "id": "f8078:m7"}
{"signature": "@register_vcs_handler(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>def git_get_keywords(versionfile_abs):", "body": "<EOL>keywords = {}<EOL>try:<EOL><INDENT>f = open(versionfile_abs, \"<STR_LIT:r>\")<EOL>for line in f.readlines():<EOL><INDENT>if line.strip().startswith(\"<STR_LIT>\"):<EOL><INDENT>mo = re.search(r'<STR_LIT>', line)<EOL>if mo:<EOL><INDENT>keywords[\"<STR_LIT>\"] = mo.group(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>if line.strip().startswith(\"<STR_LIT>\"):<EOL><INDENT>mo = re.search(r'<STR_LIT>', line)<EOL>if mo:<EOL><INDENT>keywords[\"<STR_LIT>\"] = mo.group(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>if line.strip().startswith(\"<STR_LIT>\"):<EOL><INDENT>mo = re.search(r'<STR_LIT>', line)<EOL>if mo:<EOL><INDENT>keywords[\"<STR_LIT:date>\"] = mo.group(<NUM_LIT:1>)<EOL><DEDENT><DEDENT><DEDENT>f.close()<EOL><DEDENT>except EnvironmentError:<EOL><INDENT>pass<EOL><DEDENT>return keywords<EOL>", "docstring": "Extract version information from the given file.", "id": "f8078:m4"}
{"signature": "async def _close_session(self) -> None:", "body": "await self.client_session.close()<EOL>await asyncio.sleep(<NUM_LIT>)<EOL>", "docstring": "According to the aiohttp documentation all opened sessions need to be closed, before leaving the program. This\nfunction takes care that the client session is closed. This async co-routine is automatically scheduled, when\nthe client object is destroyed.", "id": "f8085:c1:m2"}
{"signature": "@staticmethod<EOL><INDENT>def _transform_data(data: dict) -> dict:<DEDENT>", "body": "for key in data.keys():<EOL><INDENT>return_value = data[key]<EOL>if isinstance(return_value, dict):<EOL><INDENT>return return_value<EOL><DEDENT><DEDENT>return data<EOL>", "docstring": "Each CloudStack API call returns a nested dictionary structure. The first level contains only one key indicating\nthe API that originated the response. This function removes that first level from the data returned to the\ncaller.\n\n:param data: Response of the API call\n:type data: dict\n:return: Simplified response without the information about the API that originated the response.\n:rtype: dict", "id": "f8085:c1:m7"}
{"signature": "def __getattr__(self, command: str) -> Callable:", "body": "return partial(self.request, command=command)<EOL>", "docstring": "This allows to support any available and future CloudStack API in this client. The returned partial function can\ndirectly be used to call the corresponding CloudStack API including all supported parameters.\n\n:param command: Command string indicating the CloudStack API to be called.\n:type command: str\n:return: Partial function that can be used the call the CloudStack API specified in the command string.", "id": "f8085:c1:m3"}
{"signature": "async def _handle_response(self, response: aiohttp.client_reqrep.ClientResponse, await_final_result: bool) -> dict:", "body": "try:<EOL><INDENT>data = await response.json()<EOL><DEDENT>except aiohttp.client_exceptions.ContentTypeError:<EOL><INDENT>text = await response.text()<EOL>logging.debug('<STR_LIT>'.format(text))<EOL>raise CloudStackClientException(message=\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>data = self._transform_data(data)<EOL>if response.status != <NUM_LIT:200>:<EOL><INDENT>raise CloudStackClientException(message=\"<STR_LIT>\",<EOL>error_code=data.get(\"<STR_LIT>\", response.status),<EOL>error_text=data.get(\"<STR_LIT>\"),<EOL>response=data)<EOL><DEDENT><DEDENT>while await_final_result and ('<STR_LIT>' in data):<EOL><INDENT>await asyncio.sleep(self.async_poll_latency)<EOL>data = await self.queryAsyncJobResult(jobid=data['<STR_LIT>'])<EOL>if data['<STR_LIT>']:  <EOL><INDENT>if not data['<STR_LIT>']:  <EOL><INDENT>try:<EOL><INDENT>return data['<STR_LIT>']<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>logging.debug(\"<STR_LIT>\".format(str(data)))<EOL>raise CloudStackClientException(message=\"<STR_LIT>\",<EOL>error_code=data.get(\"<STR_LIT>\"),<EOL>error_text=data.get(\"<STR_LIT>\"),<EOL>response=data)<EOL><DEDENT><DEDENT>return data<EOL>", "docstring": "Handles the response returned from the CloudStack API. Some CloudStack API are implemented asynchronous, which\nmeans that the API call returns just a job id. The actually expected API response is postponed and a specific\nasyncJobResults API has to be polled using the job id to get the final result once the API call has been\nprocessed.\n\n:param response: The response returned by the aiohttp call.\n:type response: aiohttp.client_reqrep.ClientResponse\n:param await_final_result: Specifier that indicates whether the function should poll the asyncJobResult API\n                           until the asynchronous API call has been processed\n:type await_final_result: bool\n:return: Dictionary containing the JSON response of the API call\n:rtype: dict", "id": "f8085:c1:m5"}
{"signature": "def __init__(<EOL>self,<EOL>string: Union[str, MutableSequence[str]],<EOL>header: bool = False,<EOL>_type_to_spans: Dict[str, List[List[int]]] = None,<EOL>_span: int = None,<EOL>_type: int = None,<EOL>_match: Match = None,<EOL>_attrs_match: Match = None,<EOL>) -> None:", "body": "super().__init__(string, _type_to_spans, _span, _type)<EOL>self._header = header<EOL>if _match:<EOL><INDENT>string = self.string<EOL>self._match_cache = _match, string<EOL>if _attrs_match:<EOL><INDENT>self._attrs_match_cache = _attrs_match, string<EOL><DEDENT>else:<EOL><INDENT>self._attrs_match_cache =ATTRS_MATCH(_match['<STR_LIT>']), string<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self._attrs_match_cache = self._match_cache = None, None<EOL><DEDENT>", "docstring": "Initialize the object.", "id": "f8126:c0:m0"}
{"signature": "@value.setter<EOL><INDENT>def value(self, new_value: str) -> None:<DEDENT>", "body": "m = self._match<EOL>offset = m.start()<EOL>s, e = m.span('<STR_LIT:data>')<EOL>self[s - offset:e - offset] = new_value<EOL>", "docstring": "Assign new_value to self.", "id": "f8126:c0:m3"}
{"signature": "def set_attr(self, attr_name: str, attr_value: str) -> None:", "body": "<EOL>cell_match = self._match<EOL>shadow = cell_match.string<EOL>attrs_start, attrs_end = cell_match.span('<STR_LIT>')<EOL>if attrs_start != -<NUM_LIT:1>:<EOL><INDENT>encoded_attr_name = attr_name.encode()<EOL>attrs_m = ATTRS_MATCH(shadow, attrs_start, attrs_end)<EOL>for i, n in enumerate(reversed(attrs_m.captures('<STR_LIT>'))):<EOL><INDENT>if n == encoded_attr_name:<EOL><INDENT>vs, ve = attrs_m.spans('<STR_LIT>')[-i - <NUM_LIT:1>]<EOL>q = <NUM_LIT:1> if attrs_m.string[ve] in b'<STR_LIT>' else <NUM_LIT:0><EOL>self[vs - q:ve + q] = '<STR_LIT>'.format(attr_value)<EOL>return<EOL><DEDENT><DEDENT>attr_end = cell_match.end('<STR_LIT>')<EOL>fmt = '<STR_LIT>' if shadow[attr_end - <NUM_LIT:1>] == <NUM_LIT:32> else '<STR_LIT>'<EOL>self.insert(attr_end, fmt.format(attr_name, attr_value))<EOL>return<EOL><DEDENT>fmt = '<STR_LIT>' if attr_value else '<STR_LIT>'<EOL>if shadow[<NUM_LIT:0>] == <NUM_LIT:10>:  <EOL><INDENT>self.insert(<EOL>cell_match.start('<STR_LIT>') + <NUM_LIT:1>,<EOL>fmt.format(attr_name, attr_value)<EOL>)<EOL>return<EOL><DEDENT>self.insert(<NUM_LIT:2>, fmt.format(attr_name, attr_value))<EOL>return<EOL>", "docstring": "Set the value for the given attribute name.\n\n        If there are already multiple attributes with that name, only\n        set the value for the last one.\n        If attr_value == '', use the implicit empty attribute syntax.", "id": "f8126:c0:m5"}
{"signature": "@property<EOL><INDENT>def text(self) -> Optional[str]:<DEDENT>", "body": "head, pipe, tail = self._atomic_partition(<NUM_LIT>)<EOL>if pipe:<EOL><INDENT>return tail[:-<NUM_LIT:2>]<EOL><DEDENT>return None<EOL>", "docstring": "Return the text of this WikiLink. Do not include linktrail.", "id": "f8127:c0:m2"}
{"signature": "def get_arg(self, name: str) -> Optional[Argument]:", "body": "return get_arg(name, reversed(self.arguments))<EOL>", "docstring": "Return the last argument with the given name.\n\n        Return None if no argument with that name is found.", "id": "f8130:c0:m4"}
{"signature": "def del_arg(self, name: str) -> None:", "body": "for arg in reversed(self.arguments):<EOL><INDENT>if arg.name.strip(WS) == name.strip(WS):<EOL><INDENT>del arg[:]<EOL><DEDENT><DEDENT>", "docstring": "Delete all arguments with the given then.", "id": "f8130:c0:m6"}
{"signature": "def parse_pm_pf_tl(<EOL>byte_array: bytearray, start: int, end: Optional[int],<EOL>parameter_spans_append: Callable,<EOL>pfunction_spans_append: Callable,<EOL>template_spans_append: Callable,<EOL>) -> None:", "body": "while True:<EOL><INDENT>for m in SINGLE_BRACES_FINDITER(byte_array, start, end):<EOL><INDENT>byte_array[m.start()] = <NUM_LIT>  <EOL><DEDENT>match = None<EOL>for match in PM_PF_TL_FINDITER(byte_array, start, end):<EOL><INDENT>ms, me = match.span()<EOL>if match[<NUM_LIT:1>] is not None:<EOL><INDENT>parameter_spans_append([ms, me])<EOL><DEDENT>elif match[<NUM_LIT:2>] is not None:<EOL><INDENT>pfunction_spans_append([ms, me])<EOL><DEDENT>elif match[<NUM_LIT:3>] is not None:  <EOL><INDENT>byte_array[ms:me] = b'<STR_LIT:_>' * (me - ms)<EOL>continue<EOL><DEDENT>else:<EOL><INDENT>template_spans_append([ms, me])<EOL><DEDENT>byte_array[ms:me] = b'<STR_LIT:X>' * (me - ms)<EOL><DEDENT>if match is None:<EOL><INDENT>return<EOL><DEDENT><DEDENT>", "docstring": "Find the spans of parameters, parser functions, and templates.\n\n    :byte_array: The byte_array or part of byte_array that is being parsed.\n    :start: Add to every returned start.\n\n    This is the innermost loop of the parse_to_spans function.\n    If the byte_array passed to parse_to_spans contains n WikiLinks, then\n    this function will be called n + 1 times. One time for the whole byte_array\n    and n times for each of the n WikiLinks.", "id": "f8131:m2"}
{"signature": "def parse_to_spans(byte_array: bytearray) -> Dict[str, List[List[int]]]:", "body": "comment_spans = []  <EOL>comment_spans_append = comment_spans.append<EOL>extension_tag_spans = []  <EOL>extension_tag_spans_append = extension_tag_spans.append<EOL>wikilink_spans = []  <EOL>wikilink_spans_append = wikilink_spans.append<EOL>parameter_spans = []  <EOL>parameter_spans_append = parameter_spans.append<EOL>parser_function_spans = []  <EOL>parser_function_spans_append = parser_function_spans.append<EOL>template_spans = []  <EOL>template_spans_append = template_spans.append<EOL>for match in COMMENT_FINDITER(byte_array):<EOL><INDENT>ms, me = match.span()<EOL>comment_spans_append([ms, me])<EOL>byte_array[ms:me] = b'<STR_LIT:U+0020>' * (me - ms)<EOL><DEDENT>for match in EXTENSION_TAGS_FINDITER(byte_array):<EOL><INDENT>ms, me = match.span()<EOL>extension_tag_spans_append([ms, me])<EOL>if match[<NUM_LIT:2>]:  <EOL><INDENT>parse_tag_extensions(<EOL>byte_array, ms, me,<EOL>wikilink_spans_append,<EOL>parameter_spans_append,<EOL>parser_function_spans_append,<EOL>template_spans_append)<EOL><DEDENT>byte_array[ms:me] = b'<STR_LIT:_>' * (me - ms)<EOL><DEDENT>while True:<EOL><INDENT>match = None<EOL>for match in WIKILINK_FINDITER(byte_array):<EOL><INDENT>ms, me = match.span()<EOL>wikilink_spans_append([ms, me])<EOL>parse_pm_pf_tl(<EOL>byte_array, ms, me,<EOL>parameter_spans_append,<EOL>parser_function_spans_append,<EOL>template_spans_append)<EOL>byte_array[ms:me] = b'<STR_LIT:_>' * (me - ms)<EOL><DEDENT>if match is None:<EOL><INDENT>break<EOL><DEDENT><DEDENT>parse_pm_pf_tl(<EOL>byte_array, <NUM_LIT:0>, None,<EOL>parameter_spans_append,<EOL>parser_function_spans_append,<EOL>template_spans_append)<EOL>return {<EOL>'<STR_LIT>': sorted(comment_spans),<EOL>'<STR_LIT>': sorted(extension_tag_spans),<EOL>'<STR_LIT>': sorted(parameter_spans),<EOL>'<STR_LIT>': sorted(parser_function_spans),<EOL>'<STR_LIT>': sorted(template_spans),<EOL>'<STR_LIT>': sorted(wikilink_spans)}<EOL>", "docstring": "Calculate and set self._type_to_spans.\n\n    The result is a dictionary containing lists of spans:\n    {\n        'Comment': comment_spans,\n        'ExtTag': extension_tag_spans,\n        'Parameter': parameter_spans,\n        'ParserFunction': parser_function_spans,\n        'Template': template_spans,\n        'WikiLink': wikilink_spans,\n    }", "id": "f8131:m0"}
{"signature": "def append_default(self, new_default_name: str) -> None:", "body": "stripped_default_name = new_default_name.strip(WS)<EOL>if stripped_default_name == self.name.strip(WS):<EOL><INDENT>return<EOL><DEDENT>dig = True<EOL>innermost_param = self<EOL>while dig:<EOL><INDENT>dig = False<EOL>default = innermost_param.default<EOL>for p in innermost_param.parameters:<EOL><INDENT>if p.string == default:<EOL><INDENT>if stripped_default_name == p.name.strip(WS):<EOL><INDENT>return<EOL><DEDENT>innermost_param = p<EOL>dig = True<EOL><DEDENT><DEDENT><DEDENT>innermost_default = innermost_param.default<EOL>if innermost_default is None:<EOL><INDENT>innermost_param.insert(-<NUM_LIT:3>, '<STR_LIT>' + new_default_name + '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>name = innermost_param.name<EOL>innermost_param[<EOL>len('<STR_LIT>' + name + '<STR_LIT:|>'):<EOL>len('<STR_LIT>' + name + '<STR_LIT:|>' + innermost_default)<EOL>] = '<STR_LIT>' + new_default_name + '<STR_LIT:|>' + innermost_default + '<STR_LIT>'<EOL><DEDENT>", "docstring": "Append a new default parameter in the appropriate place.\n\n        Add the new default to the innter-most parameter.\n        If the parameter already exists among defaults, don't change anything.\n\n        Example:\n            >>> p = Parameter('{{{p1|{{{p2|}}}}}}')\n            >>> p.append_default('p3')\n            >>> p\n            Parameter(\"'{{{p1|{{{p2|{{{p3|}}}}}}}}}'\")", "id": "f8132:c0:m5"}
{"signature": "@text.setter<EOL><INDENT>def text(self, newtext: str) -> None:<DEDENT>", "body": "string = self.string<EOL>if string[<NUM_LIT:0>] == '<STR_LIT:[>':<EOL><INDENT>text = self.text<EOL>if text:<EOL><INDENT>self[-len(text) - <NUM_LIT:1>:-<NUM_LIT:1>] = newtext<EOL>return<EOL><DEDENT>self.insert(-<NUM_LIT:1>, '<STR_LIT:U+0020>' + newtext)<EOL>return<EOL><DEDENT>self.insert(len(string), '<STR_LIT:U+0020>' + newtext + '<STR_LIT:]>')<EOL>self.insert(<NUM_LIT:0>, '<STR_LIT:[>')<EOL>", "docstring": "Set a new text.\n\n        Automatically put the ExternalLink in brackets if it's not already.", "id": "f8133:c0:m3"}
{"signature": "@property<EOL><INDENT>def in_brackets(self) -> bool:<DEDENT>", "body": "return self[<NUM_LIT:0>] == '<STR_LIT:[>'<EOL>", "docstring": "Return true if the ExternalLink is in brackets. False otherwise.", "id": "f8133:c0:m4"}
{"signature": "@property<EOL><INDENT>def url(self) -> str:<DEDENT>", "body": "if self[<NUM_LIT:0>] == '<STR_LIT:[>':<EOL><INDENT>return self[<NUM_LIT:1>:URL_MATCH(self._ext_link_shadow, <NUM_LIT:1>).end()]<EOL><DEDENT>return self.string<EOL>", "docstring": "Return the url.", "id": "f8133:c0:m0"}
{"signature": "@contents.setter<EOL><INDENT>def contents(self, value: str) -> None:<DEDENT>", "body": "level = self.level<EOL>if level == <NUM_LIT:0>:<EOL><INDENT>self[:] = value<EOL>return<EOL><DEDENT>contents = self.contents<EOL>start = level + len(self.title) + level + <NUM_LIT:1><EOL>self[start:start + len(contents)] = value<EOL>", "docstring": "Set value as the contents of this section.", "id": "f8135:c0:m5"}
{"signature": "@property<EOL><INDENT>def title(self) -> str:<DEDENT>", "body": "level = self.level<EOL>if level == <NUM_LIT:0>:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>return self._atomic_partition(<NUM_LIT:10>)[<NUM_LIT:0>].rstrip(WS)[level:-level]<EOL>", "docstring": "Return title of this section. Return '' for lead sections.", "id": "f8135:c0:m2"}
{"signature": "@level.setter<EOL><INDENT>def level(self, value: int) -> None:<DEDENT>", "body": "old_level = self.level<EOL>title = self.title<EOL>new_equals = '<STR_LIT:=>' * value<EOL>self[<NUM_LIT:0>:old_level + len(title) + old_level] =new_equals + title + new_equals<EOL>", "docstring": "Change level of this section.", "id": "f8135:c0:m1"}
{"signature": "@property<EOL><INDENT>def level(self) -> int:<DEDENT>", "body": "m = HEADER_MATCH(self._shadow)<EOL>if m:<EOL><INDENT>return len(m.group(<NUM_LIT:1>))<EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Return level of this section.\n\n        Level is in range(1,7) or 0 for the lead section.", "id": "f8135:c0:m0"}
{"signature": "def _lstrip_increase(shadow: bytearray, pos: int) -> int:", "body": "length = len(shadow)<EOL>while pos < length and shadow[pos:pos + <NUM_LIT:1>].isspace():<EOL><INDENT>pos += <NUM_LIT:1><EOL><DEDENT>return pos<EOL>", "docstring": "Return the new position to lstrip the shadow.", "id": "f8136:m1"}
{"signature": "@property<EOL><INDENT>def arguments(self) -> List[Argument]:<DEDENT>", "body": "shadow = self._shadow<EOL>split_spans = self._args_matcher(shadow).spans('<STR_LIT>')<EOL>if not split_spans:<EOL><INDENT>return []<EOL><DEDENT>arguments = []<EOL>arguments_append = arguments.append<EOL>type_to_spans = self._type_to_spans<EOL>ss, se = span = self._span<EOL>type_ = id(span)<EOL>lststr = self._lststr<EOL>string = lststr[<NUM_LIT:0>]<EOL>arg_spans = type_to_spans.setdefault(type_, [])<EOL>span_tuple_to_span_get = {(s[<NUM_LIT:0>], s[<NUM_LIT:1>]): s for s in arg_spans}.get<EOL>for arg_self_start, arg_self_end in split_spans:<EOL><INDENT>s, e = arg_span = [ss + arg_self_start, ss + arg_self_end]<EOL>old_span = span_tuple_to_span_get((s, e))<EOL>if old_span is None:<EOL><INDENT>insort(arg_spans, arg_span)<EOL><DEDENT>else:<EOL><INDENT>arg_span = old_span<EOL><DEDENT>arg = Argument(lststr, type_to_spans, arg_span, type_)<EOL>arg._shadow_cache = (<EOL>string[s:e], shadow[arg_self_start:arg_self_end])<EOL>arguments_append(arg)<EOL><DEDENT>return arguments<EOL>", "docstring": "Parse template content. Create self.name and self.arguments.", "id": "f8137:c0:m0"}
{"signature": "def __delitem__(self, key: Union[slice, int]) -> None:", "body": "start, stop = self._check_index(key)<EOL>lststr = self._lststr<EOL>lststr0 = lststr[<NUM_LIT:0>]<EOL>lststr[<NUM_LIT:0>] = lststr0[:start] + lststr0[stop:]<EOL>self._shrink_update(start, stop)<EOL>", "docstring": "Remove the specified range or character from self.string.\n\n        Note: If an operation involves both insertion and deletion, it'll be\n        safer to use the `insert` function first. Otherwise there is a\n        possibility of insertion into the wrong spans.", "id": "f8138:c0:m8"}
{"signature": "def __init__(<EOL>self,<EOL>string: Union[MutableSequence[str], str],<EOL>_type_to_spans: Dict[str, List[List[int]]] = None,<EOL>) -> None:", "body": "if _type_to_spans is not None:<EOL><INDENT>self._type_to_spans = _type_to_spans<EOL>self._lststr = string  <EOL>return<EOL><DEDENT>self._lststr = [string]<EOL>span = self._span = [<NUM_LIT:0>, len(string)]<EOL>byte_array = bytearray(string, '<STR_LIT:ascii>', '<STR_LIT:replace>')<EOL>_type = self._type<EOL>if _type not in SPAN_PARSER_TYPES:<EOL><INDENT>type_to_spans = self._type_to_spans = parse_to_spans(byte_array)<EOL>type_to_spans[_type] = [span]<EOL>self._shadow_cache = string, byte_array<EOL><DEDENT>else:<EOL><INDENT>head = byte_array[:<NUM_LIT:2>]<EOL>tail = byte_array[-<NUM_LIT:2>:]<EOL>byte_array[-<NUM_LIT:2>:] = byte_array[:<NUM_LIT:2>] = b'<STR_LIT>'<EOL>type_to_spans = parse_to_spans(byte_array)<EOL>self._shadow_cache = string, byte_array<EOL>type_to_spans[_type].insert(<NUM_LIT:0>, span)<EOL>self._type_to_spans = type_to_spans<EOL>byte_array[:<NUM_LIT:2>] = head<EOL>byte_array[-<NUM_LIT:2>:] = tail<EOL><DEDENT>", "docstring": "Initialize the object.\n\n        Set the initial values for self._lststr, self._type_to_spans.\n\n        :param string: The string to be parsed or a list containing the string\n            of the parent object.\n        :param _type_to_spans: If the lststr is already parsed, pass its\n            _type_to_spans property as _type_to_spans to avoid parsing it\n            again.", "id": "f8138:c0:m0"}
{"signature": "@property<EOL><INDENT>def tables(self) -> List['<STR_LIT>']:<DEDENT>", "body": "tables = []  <EOL>tables_append = tables.append<EOL>type_to_spans = self._type_to_spans<EOL>lststr = self._lststr<EOL>shadow = self._shadow[:]<EOL>ss, se = self._span<EOL>spans = type_to_spans.setdefault('<STR_LIT>', [])<EOL>if not spans:<EOL><INDENT>m = True  <EOL>while m:<EOL><INDENT>m = False<EOL>for m in TABLE_FINDITER(shadow):<EOL><INDENT>ms, me = m.span()<EOL>span = [ss + ms + len(m[<NUM_LIT:1>]), ss + me]<EOL>spans.append(span)<EOL>tables_append(Table(lststr, type_to_spans, span, '<STR_LIT>'))<EOL>shadow[ms:me] = b'<STR_LIT:_>' * (me - ms)<EOL><DEDENT><DEDENT>return tables<EOL><DEDENT>span_tuple_to_span_get = {(s[<NUM_LIT:0>], s[<NUM_LIT:1>]): s for s in spans}.get<EOL>m = True<EOL>while m:<EOL><INDENT>m = False<EOL>for m in TABLE_FINDITER(shadow):<EOL><INDENT>ms, me = m.span()<EOL>s, e = ss + ms + len(m[<NUM_LIT:1>]), ss + me<EOL>old_span = span_tuple_to_span_get((s, e))<EOL>if old_span is None:<EOL><INDENT>span = [s, e]<EOL>insort(spans, span)<EOL><DEDENT>else:<EOL><INDENT>span = old_span<EOL><DEDENT>tables_append(Table(lststr, type_to_spans, span, '<STR_LIT>'))<EOL>shadow[ms:me] = b'<STR_LIT:_>' * (me - ms)<EOL><DEDENT><DEDENT>return tables<EOL>", "docstring": "Return a list of found table objects.", "id": "f8138:c0:m32"}
{"signature": "def __contains__(self, value: Union[str, '<STR_LIT>']) -> bool:", "body": "<EOL>if isinstance(value, str):<EOL><INDENT>return value in self.string<EOL><DEDENT>if self._lststr is not value._lststr:<EOL><INDENT>return False<EOL><DEDENT>ps, pe = value._span<EOL>ss, se = self._span<EOL>if ss <= ps and se >= pe:<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Return True if parsed_wikitext is inside self. False otherwise.\n\n        Also self and parsed_wikitext should belong to the same parsed\n        wikitext object for this function to return True.", "id": "f8138:c0:m3"}
{"signature": "@staticmethod<EOL><INDENT>def parent(type_: Optional[str] = None) -> None:<DEDENT>", "body": "return None<EOL>", "docstring": "Return None (The parent of the root node is None).", "id": "f8138:c0:m36"}
{"signature": "@property<EOL><INDENT>def sections(self) -> List['<STR_LIT>']:<DEDENT>", "body": "sections = []  <EOL>sections_append = sections.append<EOL>type_to_spans = self._type_to_spans<EOL>lststr = self._lststr<EOL>ss, se = _span = self._span<EOL>type_spans = type_to_spans.setdefault('<STR_LIT>', [])<EOL>full_match = SECTIONS_FULLMATCH(self._shadow)<EOL>section_spans = full_match.spans('<STR_LIT>')<EOL>levels = [len(eq) for eq in full_match.captures('<STR_LIT>')]<EOL>if not type_spans:<EOL><INDENT>spans_append = type_spans.append<EOL>for current_index, (current_level, (s, e)) in enumerate(<EOL>zip(levels, section_spans), <NUM_LIT:1><EOL>):<EOL><INDENT>for section_index, section_level in enumerate(<EOL>levels[current_index:], current_index<EOL>):<EOL><INDENT>if current_level and section_level > current_level:<EOL><INDENT>e = section_spans[section_index][<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>span = [ss + s, ss + e]<EOL>spans_append(span)<EOL>sections_append(<EOL>Section(lststr, type_to_spans, span, '<STR_LIT>'))<EOL><DEDENT>return sections<EOL><DEDENT>span_tuple_to_span = {(s[<NUM_LIT:0>], s[<NUM_LIT:1>]): s for s in type_spans}.get<EOL>for current_index, (current_level, (s, e)) in enumerate(<EOL>zip(levels, section_spans), <NUM_LIT:1><EOL>):<EOL><INDENT>for section_index, section_level in enumerate(<EOL>levels[current_index:], current_index<EOL>):<EOL><INDENT>if current_level and section_level > current_level:<EOL><INDENT>e = section_spans[section_index][<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>s, e = ss + s, ss + e<EOL>old_span = span_tuple_to_span((s, e))<EOL>if old_span is None:<EOL><INDENT>span = [s, e]<EOL>insort(type_spans, span)<EOL><DEDENT>else:<EOL><INDENT>span = old_span<EOL><DEDENT>sections_append(Section(lststr, type_to_spans, span, '<STR_LIT>'))<EOL><DEDENT>return sections<EOL>", "docstring": "Return a list of section in current wikitext.\n\n        The first section will always be the lead section, even if it is an\n        empty string.", "id": "f8138:c0:m31"}
{"signature": "def _subspans(self, _type: str) -> Generator[int, None, None]:", "body": "ss, se = self._span<EOL>spans = self._type_to_spans[_type]<EOL>b = bisect(spans, [ss])<EOL>for span in spans[b:bisect(spans, [se], b)]:<EOL><INDENT>if span[<NUM_LIT:1>] <= se:<EOL><INDENT>yield span<EOL><DEDENT><DEDENT>", "docstring": "Yield all the sub-span indices excluding self._span.", "id": "f8138:c1:m1"}
{"signature": "def __repr__(self) -> str:", "body": "return '<STR_LIT>'.format(type(self).__name__, repr(self.string))<EOL>", "docstring": "Return the string representation of self.", "id": "f8138:c0:m2"}
{"signature": "def __str__(self) -> str:", "body": "return self.string<EOL>", "docstring": "Return self-object as a string.", "id": "f8138:c0:m1"}
{"signature": "def _subspans(self, type_: str) -> List[List[int]]:", "body": "return self._type_to_spans[type_]<EOL>", "docstring": "Return all the sub-span including self._span.", "id": "f8138:c0:m15"}
{"signature": "def pprint(self, indent: str = '<STR_LIT:U+0020>', remove_comments=False):", "body": "warn(<EOL>'<STR_LIT>',<EOL>DeprecationWarning,<EOL>)<EOL>return self.pformat(indent, remove_comments)<EOL>", "docstring": "Deprecated, use self.pformat instead.", "id": "f8138:c0:m23"}
{"signature": "def _shrink_update(self, rmstart: int, rmstop: int) -> None:", "body": "<EOL>for spans in self._type_to_spans.values():<EOL><INDENT>i = len(spans) - <NUM_LIT:1><EOL>while i >= <NUM_LIT:0>:<EOL><INDENT>s, e = span = spans[i]<EOL>if rmstop <= s:<EOL><INDENT>rmlength = rmstop - rmstart<EOL>span[:] = s - rmlength, e - rmlength<EOL>i -= <NUM_LIT:1><EOL>continue<EOL><DEDENT>break<EOL><DEDENT>else:<EOL><INDENT>continue<EOL><DEDENT>while True:<EOL><INDENT>if rmstart <= s:<EOL><INDENT>if rmstop < e:<EOL><INDENT>span[:] = rmstart, e + rmstart - rmstop<EOL>i -= <NUM_LIT:1><EOL>if i < <NUM_LIT:0>:<EOL><INDENT>break<EOL><DEDENT>s, e = span = spans[i]<EOL>continue<EOL><DEDENT>spans.pop(i)[:] = -<NUM_LIT:1>, -<NUM_LIT:1><EOL>i -= <NUM_LIT:1><EOL>if i < <NUM_LIT:0>:<EOL><INDENT>break<EOL><DEDENT>s, e = span = spans[i]<EOL>continue<EOL><DEDENT>break<EOL><DEDENT>while i >= <NUM_LIT:0>:<EOL><INDENT>if e <= rmstart:<EOL><INDENT>i -= <NUM_LIT:1><EOL>if i < <NUM_LIT:0>:<EOL><INDENT>break<EOL><DEDENT>s, e = span = spans[i]<EOL>continue<EOL><DEDENT>span[<NUM_LIT:1>] -= rmstop - rmstart<EOL>i -= <NUM_LIT:1><EOL>if i < <NUM_LIT:0>:<EOL><INDENT>break<EOL><DEDENT>s, e = span = spans[i]<EOL>continue<EOL><DEDENT><DEDENT>", "docstring": "Update self._type_to_spans according to the removed span.\n\n        Warning: If an operation involves both _shrink_update and\n        _insert_update, you might wanna consider doing the\n        _insert_update before the _shrink_update as this function\n        can cause data loss in self._type_to_spans.", "id": "f8138:c0:m17"}
{"signature": "@string.deleter<EOL><INDENT>def string(self) -> None:<DEDENT>", "body": "del self[:]<EOL>", "docstring": "Set a new string for this object. Note the old data will be lost.", "id": "f8138:c0:m13"}
{"signature": "@contents.setter<EOL><INDENT>def contents(self, contents: str) -> None:<DEDENT>", "body": "match = self._match<EOL>start, end = match.span('<STR_LIT>')<EOL>if start != -<NUM_LIT:1>:<EOL><INDENT>self[start:end] = contents<EOL><DEDENT>else:<EOL><INDENT>s, e = match.span('<STR_LIT>')<EOL>self[s:e] = '<STR_LIT>'.format(contents, match['<STR_LIT:name>'].decode())<EOL><DEDENT>", "docstring": "Set new contents.\n\n        Note that if the tag is self-closing, then it will be expanded to\n        have a start tag and an end tag. For example:\n        >>> t = Tag('<t/>')\n        >>> t.contents = 'n'\n        >>> t.string\n        '<t>n</t>'", "id": "f8139:c1:m4"}
{"signature": "@property<EOL><INDENT>def _match(self) -> Any:<DEDENT>", "body": "cached_match, cached_string = self._match_cache<EOL>string = self.string<EOL>if cached_string == string:<EOL><INDENT>return cached_match<EOL><DEDENT>match = TAG_FULLMATCH(self._shadow)<EOL>self._match_cache = match, string<EOL>return match<EOL>", "docstring": "Return the match object for the current tag. Cache the result.", "id": "f8139:c1:m0"}
{"signature": "@property<EOL><INDENT>def name(self) -> str:<DEDENT>", "body": "return self._match['<STR_LIT:name>'].decode()<EOL>", "docstring": "Return tag name.", "id": "f8139:c1:m1"}
{"signature": "@property<EOL><INDENT>def items(self) -> List[str]:<DEDENT>", "body": "items = []  <EOL>append = items.append<EOL>string = self.string<EOL>match = self._match<EOL>ms = match.start()<EOL>for s, e in match.spans('<STR_LIT>'):<EOL><INDENT>append(string[s - ms:e - ms])<EOL><DEDENT>return items<EOL>", "docstring": "Return items as a list of strings.\n\n        Don't include sub-items and the start pattern.", "id": "f8140:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def readonly(cls, *args, **kwargs):<DEDENT>", "body": "fridge = cls(*args, **kwargs)<EOL>fridge.close()<EOL>return fridge<EOL>", "docstring": "Return an already closed read-only instance of Fridge.\nArguments are the same as for the constructor.", "id": "f8144:c0:m0"}
{"signature": "def compare_waterfall_fil_to_h5_methods_and_attributes():", "body": "a = bl.Waterfall(voyager_h5)<EOL>b = bl.Waterfall(voyager_fil)<EOL>print(\"<STR_LIT>\")<EOL>assert a.beam_axis == b.beam_axis<EOL>assert a.freq_axis == b.freq_axis<EOL>assert a.time_axis == b.time_axis<EOL>assert a.calc_n_coarse_chan() == b.calc_n_coarse_chan()<EOL>assert a.file_shape == b.file_shape<EOL>assert a.n_channels_in_file == b.n_channels_in_file<EOL>assert a.n_ints_in_file == b.n_ints_in_file<EOL>assert a.selection_shape == b.selection_shape<EOL>print(\"<STR_LIT>\")<EOL>a.populate_freqs()<EOL>a.populate_timestamps()<EOL>a.info()<EOL>a.blank_dc(<NUM_LIT:1>)<EOL>a.calibrate_band_pass_N1()<EOL>b.populate_freqs()<EOL>b.populate_timestamps()<EOL>b.info()<EOL>b.blank_dc(<NUM_LIT:1>)<EOL>b.calibrate_band_pass_N1()<EOL>dir_a = dir(a)<EOL>dir_b = dir(b)<EOL>print(\"<STR_LIT>\")<EOL>for item in dir_a:<EOL><INDENT>if item not in dir_b:<EOL><INDENT>print(item)<EOL><DEDENT><DEDENT>print(\"<STR_LIT>\")<EOL>for item in dir_b:<EOL><INDENT>if item not in dir_a:<EOL><INDENT>print(item)<EOL><DEDENT><DEDENT>", "docstring": "Compare attributes and check methods", "id": "f8156:m1"}
{"signature": "def find_header_size(filename):", "body": "<EOL>filfile=open(filename,'<STR_LIT:rb>')<EOL>filfile.seek(<NUM_LIT:0>)<EOL>round1 = filfile.read(<NUM_LIT:1000>)<EOL>headersize = round1.find('<STR_LIT>')+len('<STR_LIT>')<EOL>return headersize<EOL>", "docstring": "Script to find the header size of a filterbank file", "id": "f8160:m2"}
{"signature": "def write_polfils(str, str_I, **kwargs):", "body": "lin,circ=fracpols(str, **kwargs)<EOL>obs = Waterfall(str_I, max_load=<NUM_LIT>)<EOL>obs.data = lin<EOL>obs.write_to_fil(str[:-<NUM_LIT:15>]+'<STR_LIT>')   <EOL>obs.data = circ<EOL>obs.write_to_fil(str[:-<NUM_LIT:15>]+'<STR_LIT>')<EOL>", "docstring": "Writes two new filterbank files containing fractional linear and\n    circular polarization data", "id": "f8161:m8"}
{"signature": "def convert_to_coarse(data,chan_per_coarse):", "body": "<EOL>num_coarse = data.size/chan_per_coarse<EOL>data_shaped = np.array(np.reshape(data,(num_coarse,chan_per_coarse)))<EOL>return np.mean(data_shaped[:,<NUM_LIT:2>:-<NUM_LIT:1>],axis=<NUM_LIT:1>)<EOL>", "docstring": "Converts a data array with length n_chans to an array of length n_coarse_chans\nby averaging over the coarse channels", "id": "f8161:m1"}
{"signature": "def fracpols(str, **kwargs):", "body": "I,Q,U,V,L=get_stokes(str, **kwargs)<EOL>return L/I,V/I<EOL>", "docstring": "Output fractional linear and circular polarizations for a\n    rawspec cross polarization .fil file. NOT STANDARD USE", "id": "f8161:m6"}
{"signature": "def plot_fullcalib(dio_cross,feedtype='<STR_LIT:l>',**kwargs):", "body": "plt.figure(\"<STR_LIT>\", figsize=(<NUM_LIT:12>,<NUM_LIT:9>))<EOL>left, width = <NUM_LIT>,<NUM_LIT><EOL>bottom, height = <NUM_LIT>,<NUM_LIT:0.5><EOL>width2 = <NUM_LIT><EOL>bottom2, height2 = <NUM_LIT>,<NUM_LIT><EOL>rect_uncal = [left,bottom,width,height]<EOL>rect_cal = [left+width+<NUM_LIT>,bottom,width,height]<EOL>rect_fold = [left,bottom2,width2,<NUM_LIT>]<EOL>rect_gain1 = [left+width2+<NUM_LIT:0.1>,bottom2,width2,height2]<EOL>rect_phase1 = [left+width2*<NUM_LIT:2>+<NUM_LIT:0.1>*<NUM_LIT:2>,bottom2,width2,height2]<EOL>rect_gain2 = [left+width2+<NUM_LIT:0.1>,bottom2+height2+<NUM_LIT>,width2,height2]<EOL>rect_phase2 = [left+width2*<NUM_LIT:2>+<NUM_LIT:0.1>*<NUM_LIT:2>,bottom2+height2+<NUM_LIT>,width2,height2]<EOL>axFold = plt.axes(rect_fold)<EOL>print('<STR_LIT>')<EOL>plot_diode_fold(dio_cross,bothfeeds=False,feedtype=feedtype,min_samp=<NUM_LIT>,max_samp=<NUM_LIT>,legend=False,**kwargs)<EOL>print('<STR_LIT>')<EOL>plot_gain_offsets(dio_cross,feedtype=feedtype,ax1=rect_gain2,ax2=rect_gain1,legend=False,**kwargs)<EOL>print('<STR_LIT>')<EOL>plot_phase_offsets(dio_cross,feedtype=feedtype,ax1=rect_phase1,ax2=rect_phase2,legend=False,**kwargs)<EOL>plt.ylabel('<STR_LIT>')<EOL>ax_uncal = plt.axes(rect_uncal)<EOL>print('<STR_LIT>')<EOL>plot_Stokes_diode(dio_cross,feedtype=feedtype,**kwargs)<EOL>ax_cal = plt.axes(rect_cal,sharey=ax_uncal)<EOL>print('<STR_LIT>')<EOL>plot_calibrated_diode(dio_cross,feedtype=feedtype,**kwargs)<EOL>plt.ylabel('<STR_LIT>')<EOL>plt.setp(ax_cal.get_yticklabels(),visible=False)<EOL>plt.savefig(dio_cross[:-<NUM_LIT:4>]+'<STR_LIT>',dpi=<NUM_LIT>)<EOL>plt.show()<EOL>", "docstring": "Generates and shows five plots: Uncalibrated diode, calibrated diode, fold information,\nphase offsets, and gain offsets for a noise diode measurement. Most useful diagnostic plot to\nmake sure calibration proceeds correctly.", "id": "f8164:m6"}
{"signature": "def plot_calibrated_diode(dio_cross,chan_per_coarse=<NUM_LIT:8>,feedtype='<STR_LIT:l>',**kwargs):", "body": "<EOL>obs = Waterfall(dio_cross,max_load=<NUM_LIT>)<EOL>freqs = obs.populate_freqs()<EOL>tsamp = obs.header['<STR_LIT>']<EOL>data = obs.data<EOL>obs = None<EOL>I,Q,U,V = get_stokes(data,feedtype)<EOL>data = None<EOL>psis = phase_offsets(I,Q,U,V,tsamp,chan_per_coarse,feedtype,**kwargs)<EOL>G = gain_offsets(I,Q,U,V,tsamp,chan_per_coarse,feedtype,**kwargs)<EOL>I,Q,U,V = apply_Mueller(I,Q,U,V,G,psis,chan_per_coarse,feedtype)<EOL>I_OFF,I_ON = foldcal(I,tsamp,**kwargs)<EOL>Q_OFF,Q_ON = foldcal(Q,tsamp,**kwargs)<EOL>U_OFF,U_ON = foldcal(U,tsamp,**kwargs)<EOL>V_OFF,V_ON = foldcal(V,tsamp,**kwargs)<EOL>I = None<EOL>Q = None<EOL>U = None<EOL>V = None<EOL>plt.plot(freqs,I_ON-I_OFF,'<STR_LIT>',label='<STR_LIT:I>')<EOL>plt.plot(freqs,Q_ON-Q_OFF,'<STR_LIT>',label='<STR_LIT>')<EOL>plt.plot(freqs,U_ON-U_OFF,'<STR_LIT>',label='<STR_LIT>')<EOL>plt.plot(freqs,V_ON-V_OFF,'<STR_LIT>',label='<STR_LIT>')<EOL>plt.legend()<EOL>plt.xlabel('<STR_LIT>')<EOL>plt.title('<STR_LIT>')<EOL>plt.ylabel('<STR_LIT>')<EOL>", "docstring": "Plots the corrected noise diode spectrum for a given noise diode measurement\nafter application of the inverse Mueller matrix for the electronics chain.", "id": "f8164:m2"}
{"signature": "def get_diff(dio_cross,feedtype,**kwargs):", "body": "<EOL>obs = Waterfall(dio_cross,max_load=<NUM_LIT>)<EOL>freqs = obs.populate_freqs()<EOL>tsamp = obs.header['<STR_LIT>']<EOL>data = obs.data<EOL>obs = None<EOL>I,Q,U,V = get_stokes(data,feedtype)<EOL>I_OFF,I_ON = foldcal(I,tsamp,**kwargs)<EOL>Q_OFF,Q_ON = foldcal(Q,tsamp,**kwargs)<EOL>U_OFF,U_ON = foldcal(U,tsamp,**kwargs)<EOL>V_OFF,V_ON = foldcal(V,tsamp,**kwargs)<EOL>Idiff = I_ON-I_OFF<EOL>Qdiff = Q_ON-Q_OFF<EOL>Udiff = U_ON-U_OFF<EOL>Vdiff = V_ON-V_OFF<EOL>return Idiff,Qdiff,Udiff,Vdiff,freqs<EOL>", "docstring": "Returns ON-OFF for all Stokes parameters given a cross_pols noise diode measurement", "id": "f8164:m0"}
{"signature": "def read_header(self):", "body": "start_idx = self.file_obj.tell()<EOL>key, val = '<STR_LIT>', '<STR_LIT>'<EOL>header_dict = {}<EOL>keep_reading = True<EOL>first_line = self.file_obj<EOL>try:<EOL><INDENT>while keep_reading:<EOL><INDENT>if start_idx + <NUM_LIT> > self.filesize:<EOL><INDENT>keep_reading = False<EOL>raise EndOfFileError(\"<STR_LIT>\")<EOL><DEDENT>line = self.file_obj.read(<NUM_LIT>)<EOL>if PYTHON3:<EOL><INDENT>line = line.decode(\"<STR_LIT:utf-8>\")<EOL><DEDENT>if line.startswith('<STR_LIT>'):<EOL><INDENT>keep_reading = False<EOL>break<EOL><DEDENT>else:<EOL><INDENT>key, val = line.split('<STR_LIT:=>')<EOL>key, val = key.strip(), val.strip()<EOL>if \"<STR_LIT:'>\" in val:<EOL><INDENT>val = str(val.strip(\"<STR_LIT:'>\").strip())<EOL><DEDENT>elif \"<STR_LIT:.>\" in val:<EOL><INDENT>val = float(val)<EOL><DEDENT>else:<EOL><INDENT>val = int(val)<EOL><DEDENT><DEDENT>header_dict[key] = val<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>print(\"<STR_LIT>\", line)<EOL>print(\"<STR_LIT>\", start_idx)<EOL>print(\"<STR_LIT>\", self.filesize)<EOL>print(\"<STR_LIT>\")<EOL>print(self.file_obj.read(<NUM_LIT>))<EOL>raise<EOL><DEDENT>data_idx = self.file_obj.tell()<EOL>if \"<STR_LIT>\" in header_dict.keys():<EOL><INDENT>if int(header_dict[\"<STR_LIT>\"]) == <NUM_LIT:1>:<EOL><INDENT>if data_idx % <NUM_LIT>:<EOL><INDENT>data_idx += (<NUM_LIT> - data_idx % <NUM_LIT>)<EOL><DEDENT><DEDENT><DEDENT>self.file_obj.seek(start_idx)<EOL>return header_dict, data_idx<EOL>", "docstring": "Read next header (multiple headers in file)\n\n        Returns:\n            (header, data_idx) - a dictionary of keyword:value header data and\n            also the byte index of where the corresponding data block resides.", "id": "f8167:c1:m4"}
{"signature": "def generate_filterbank_header(self, nchans=<NUM_LIT:1>, ):", "body": "gp_head = self.read_first_header()<EOL>fb_head = {}<EOL>telescope_str = gp_head.get(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>if telescope_str in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>fb_head[\"<STR_LIT>\"] = <NUM_LIT:6><EOL><DEDENT>elif telescope_str in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>fb_head[\"<STR_LIT>\"] = <NUM_LIT:7><EOL><DEDENT>else:<EOL><INDENT>fb_head[\"<STR_LIT>\"] = <NUM_LIT:0><EOL><DEDENT>fb_head[\"<STR_LIT>\"] = gp_head.get(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>fb_head[\"<STR_LIT>\"] = gp_head.get(\"<STR_LIT>\", <NUM_LIT:0>)<EOL>fb_head[\"<STR_LIT>\"] = gp_head.get(\"<STR_LIT>\", <NUM_LIT:0>)<EOL>fb_head[\"<STR_LIT>\"] = Angle(str(gp_head.get(\"<STR_LIT>\", <NUM_LIT:0.0>)) + \"<STR_LIT>\")<EOL>fb_head[\"<STR_LIT>\"] = Angle(str(gp_head.get(\"<STR_LIT>\", <NUM_LIT:0.0>)) + \"<STR_LIT>\")<EOL>fb_head[\"<STR_LIT>\"] = self.filename<EOL>fb_head[\"<STR_LIT>\"] = <NUM_LIT:20><EOL>fb_head[\"<STR_LIT>\"] = <NUM_LIT:1>  <EOL>fb_head[\"<STR_LIT>\"] = <NUM_LIT:0><EOL>fb_head[\"<STR_LIT>\"] = <NUM_LIT:0><EOL>fb_head[\"<STR_LIT>\"] = <NUM_LIT:32><EOL>fb_head[\"<STR_LIT>\"] = <NUM_LIT:0.0><EOL>fb_head[\"<STR_LIT>\"] = <NUM_LIT:1.0><EOL>fb_head[\"<STR_LIT>\"] = <NUM_LIT:0.0><EOL>fb_head[\"<STR_LIT>\"] = <NUM_LIT> / nchans<EOL>fb_head[\"<STR_LIT>\"] = nchans<EOL>fb_head[\"<STR_LIT>\"] = <NUM_LIT:1><EOL>fb_head[\"<STR_LIT>\"] = <NUM_LIT:1><EOL>return fb_head<EOL>", "docstring": "Generate a blimpy header dictionary", "id": "f8167:c1:m16"}
{"signature": "def read_first_header(self):", "body": "self.file_obj.seek(<NUM_LIT:0>)<EOL>header_dict, pos = self.read_header()<EOL>self.file_obj.seek(<NUM_LIT:0>)<EOL>return header_dict<EOL>", "docstring": "Read first header in file\n\n        Returns:\n            header (dict): keyword:value pairs of header metadata", "id": "f8167:c1:m5"}
{"signature": "def __exit__(self, exception_type, exception_value, traceback):", "body": "self.file_obj.close()<EOL>", "docstring": "closes the file after `with` block has exited\n:param exception_type:\n:param exception_value:\n:param traceback:\n:return:", "id": "f8167:c1:m2"}
{"signature": "def plot_spectrum(self, filename=None, plot_db=True):", "body": "header, data = self.read_next_data_block()<EOL>print(\"<STR_LIT>\")<EOL>d_xx_fft = np.abs(np.fft.fft(data[..., <NUM_LIT:0>]))<EOL>d_xx_fft = d_xx_fft.flatten()<EOL>dec_fac_x = <NUM_LIT:1><EOL>if d_xx_fft.shape[<NUM_LIT:0>] > MAX_PLT_POINTS:<EOL><INDENT>dec_fac_x = d_xx_fft.shape[<NUM_LIT:0>] / MAX_PLT_POINTS<EOL><DEDENT>d_xx_fft = rebin(d_xx_fft, dec_fac_x)<EOL>print(\"<STR_LIT>\")<EOL>if plot_db:<EOL><INDENT>plt.plot(<NUM_LIT:10> * np.log10(d_xx_fft))<EOL>plt.ylabel(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>plt.plot(d_xx_fft)<EOL>plt.ylabel(\"<STR_LIT>\")<EOL>plt.xlabel(\"<STR_LIT>\")<EOL><DEDENT>plt.title(self.filename)<EOL>if filename:<EOL><INDENT>plt.savefig(filename)<EOL><DEDENT>plt.show()<EOL>", "docstring": "Do a (slow) numpy FFT and take power of data", "id": "f8167:c1:m15"}
{"signature": "def __get_blob_dimensions(self, chunk_dim):", "body": "<EOL>if self.selection_shape[self.freq_axis] > chunk_dim[self.freq_axis]*MAX_BLOB_MB:<EOL><INDENT>freq_axis_size = self.selection_shape[self.freq_axis]<EOL><INDENT>while freq_axis_size > chunk_dim[self.freq_axis]*MAX_BLOB_MB:<EOL><INDENT>freq_axis_size /= <NUM_LIT:2><EOL><DEDENT><DEDENT>time_axis_size = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>freq_axis_size = self.selection_shape[self.freq_axis]<EOL>time_axis_size = np.min([chunk_dim[self.time_axis] * MAX_BLOB_MB * chunk_dim[self.freq_axis] / freq_axis_size, self.selection_shape[self.time_axis]])<EOL><DEDENT>blob_dim = (int(time_axis_size), <NUM_LIT:1>, freq_axis_size)<EOL>return blob_dim<EOL>", "docstring": "Sets the blob dimmentions, trying to read around 1024 MiB at a time.\n            This is assuming a chunk is about 1 MiB.", "id": "f8168:c0:m13"}
{"signature": "def __get_chunk_dimensions(self):", "body": "<EOL>if np.abs(self.header[b'<STR_LIT>']) < <NUM_LIT>:<EOL><INDENT>logger.info('<STR_LIT>')<EOL>chunk_dim = (<NUM_LIT:1>,<NUM_LIT:1>,<NUM_LIT>) <EOL>return chunk_dim<EOL><DEDENT>elif np.abs(self.header[b'<STR_LIT>']) < <NUM_LIT>:<EOL><INDENT>logger.info('<STR_LIT>')<EOL>chunk_dim = (<NUM_LIT>,<NUM_LIT:1>,<NUM_LIT>) <EOL>return chunk_dim<EOL><DEDENT>elif np.abs(self.header[b'<STR_LIT>']) < <NUM_LIT> and np.abs(self.header[b'<STR_LIT>'])  >= <NUM_LIT>:<EOL><INDENT>logger.info('<STR_LIT>')<EOL>chunk_dim = (<NUM_LIT:10>,<NUM_LIT:1>,<NUM_LIT>)  <EOL><INDENT>chunk_dim = (<NUM_LIT:1>,<NUM_LIT:1>,<NUM_LIT>/<NUM_LIT:4>)<EOL><DEDENT>return chunk_dim<EOL><DEDENT>else:<EOL><INDENT>logger.warning('<STR_LIT>')<EOL>chunk_dim = (<NUM_LIT:1>,<NUM_LIT:1>,<NUM_LIT>)<EOL>return chunk_dim<EOL><DEDENT>", "docstring": "Sets the chunking dimmentions depending on the file type.", "id": "f8168:c0:m14"}
{"signature": "def __write_to_fil_heavy(self, filename_out, *args, **kwargs):", "body": "<EOL>chunk_dim = self.__get_chunk_dimensions()<EOL>blob_dim = self.__get_blob_dimensions(chunk_dim)<EOL>n_blobs = self.container.calc_n_blobs(blob_dim)<EOL>n_bytes  = self.header[b'<STR_LIT>'] / <NUM_LIT:8><EOL>with open(filename_out, \"<STR_LIT:wb>\") as fileh:<EOL><INDENT>fileh.write(generate_sigproc_header(self)) <EOL><DEDENT>logger.info('<STR_LIT>'% n_blobs)<EOL>for ii in range(<NUM_LIT:0>, n_blobs):<EOL><INDENT>logger.info('<STR_LIT>' % (ii + <NUM_LIT:1>, n_blobs))<EOL>bob = self.container.read_blob(blob_dim,n_blob=ii)<EOL>with open(filename_out, \"<STR_LIT:a>\") as fileh:<EOL><INDENT>j = bob<EOL>if n_bytes == <NUM_LIT:4>:<EOL><INDENT>np.float32(j.ravel()).tofile(fileh)<EOL><DEDENT>elif n_bytes == <NUM_LIT:2>:<EOL><INDENT>np.int16(j.ravel()).tofile(fileh)<EOL><DEDENT>elif n_bytes == <NUM_LIT:1>:<EOL><INDENT>np.int8(j.ravel()).tofile(fileh)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Write data to .fil file.\n\n        Args:\n            filename_out (str): Name of output file", "id": "f8168:c0:m8"}
{"signature": "def calc_n_coarse_chan(self, chan_bw=None):", "body": "n_coarse_chan = self.container.calc_n_coarse_chan(chan_bw)<EOL>return n_coarse_chan<EOL>", "docstring": "This makes an attempt to calculate the number of coarse channels in a given freq selection.\n            It assumes for now that a single coarse channel is 2.9296875 MHz", "id": "f8168:c0:m15"}
{"signature": "def __write_to_hdf5_light(self, filename_out, *args, **kwargs):", "body": "block_size = <NUM_LIT:0><EOL>with h5py.File(filename_out, '<STR_LIT:w>') as h5:<EOL><INDENT>h5.attrs[b'<STR_LIT>']   = b'<STR_LIT>'<EOL>h5.attrs[b'<STR_LIT>'] = b'<STR_LIT:1.0>'<EOL>if HAS_BITSHUFFLE:<EOL><INDENT>bs_compression = bitshuffle.h5.H5FILTER<EOL>bs_compression_opts = (block_size, bitshuffle.h5.H5_COMPRESS_LZ4)<EOL><DEDENT>else:<EOL><INDENT>bs_compression = None<EOL>bs_compression_opts = None<EOL>logger.warning(\"<STR_LIT>\")<EOL><DEDENT>dset = h5.create_dataset('<STR_LIT:data>',<EOL>data=self.data,<EOL>compression='<STR_LIT>')<EOL><INDENT>compression=bs_compression,<EOL>compression_opts=bs_compression_opts)<EOL>dset_mask = h5.create_dataset('<STR_LIT>',<EOL>shape=self.file_shape,<EOL><INDENT>compression='<STR_LIT>',<EOL><DEDENT>compression=bs_compression,<EOL>compression_opts=bs_compression_opts,<EOL>dtype='<STR_LIT>')<EOL>dset.dims[<NUM_LIT:0>].label = b\"<STR_LIT>\"<EOL>dset.dims[<NUM_LIT:1>].label = b\"<STR_LIT>\"<EOL>dset.dims[<NUM_LIT:2>].label = b\"<STR_LIT:time>\"<EOL>dset_mask.dims[<NUM_LIT:0>].label = b\"<STR_LIT>\"<EOL>dset_mask.dims[<NUM_LIT:1>].label = b\"<STR_LIT>\"<EOL>dset_mask.dims[<NUM_LIT:2>].label = b\"<STR_LIT:time>\"<EOL>for key, value in self.header.items():<EOL>dset.attrs[key] = value<EOL>", "docstring": "Write data to HDF5 file in one go.\n\n        Args:\n            filename_out (str): Name of output file", "id": "f8168:c0:m12"}
{"signature": "def grab_data(self, f_start=None, f_stop=None,t_start=None, t_stop=None, if_id=<NUM_LIT:0>):", "body": "self.freqs = self.populate_freqs()<EOL>self.timestamps = self.populate_timestamps()<EOL>if f_start is None:<EOL><INDENT>f_start = self.freqs[<NUM_LIT:0>]<EOL><DEDENT>if f_stop is None:<EOL><INDENT>f_stop = self.freqs[-<NUM_LIT:1>]<EOL><DEDENT>i0 = np.argmin(np.abs(self.freqs - f_start))<EOL>i1 = np.argmin(np.abs(self.freqs - f_stop))<EOL>if i0 < i1:<EOL><INDENT>plot_f    = self.freqs[i0:i1 + <NUM_LIT:1>]<EOL>plot_data = np.squeeze(self.data[t_start:t_stop, ..., i0:i1 + <NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>plot_f    = self.freqs[i1:i0 + <NUM_LIT:1>]<EOL>plot_data = np.squeeze(self.data[t_start:t_stop, ..., i1:i0 + <NUM_LIT:1>])<EOL><DEDENT>return plot_f, plot_data<EOL>", "docstring": "Extract a portion of data by frequency range.\n\n        Args:\n            f_start (float): start frequency in MHz\n            f_stop (float): stop frequency in MHz\n            if_id (int): IF input identification (req. when multiple IFs in file)\n\n        Returns:\n            (freqs, data) (np.arrays): frequency axis in MHz and data subset", "id": "f8168:c0:m16"}
{"signature": "def populate_timestamps(self,update_header=False):", "body": "<EOL>ii_start, ii_stop = <NUM_LIT:0>, self.n_ints_in_file<EOL>if self.t_start:<EOL><INDENT>ii_start = self.t_start<EOL><DEDENT>if self.t_stop:<EOL><INDENT>ii_stop = self.t_stop<EOL><DEDENT>t0 = self.header[b'<STR_LIT>']<EOL>t_delt = self.header[b'<STR_LIT>']<EOL>if update_header:<EOL><INDENT>timestamps = ii_start * t_delt / <NUM_LIT>/<NUM_LIT>/<NUM_LIT> + t0<EOL><DEDENT>else:<EOL><INDENT>timestamps = np.arange(ii_start, ii_stop) * t_delt / <NUM_LIT>/<NUM_LIT>/<NUM_LIT> + t0<EOL><DEDENT>return timestamps<EOL>", "docstring": "Populate time axis.\n            IF update_header then only return tstart", "id": "f8172:c0:m8"}
{"signature": "def _find_blob_start(self):", "body": "<EOL>self._setup_chans()<EOL>blob_time_start = self.t_start<EOL>blob_freq_start = self.chan_start_idx<EOL>blob_start = blob_time_start * self.n_channels_in_file + blob_freq_start<EOL>return blob_start<EOL>", "docstring": "Find first blob from selection.", "id": "f8172:c2:m4"}
{"signature": "def _setup_selection_range(self, f_start=None, f_stop=None, t_start=None, t_stop=None, init=False):", "body": "<EOL>if init is True:<EOL><INDENT>if t_start is None:<EOL><INDENT>t_start = self.t_begin<EOL><DEDENT>if t_stop is None:<EOL><INDENT>t_stop = self.t_end<EOL><DEDENT>if f_start is None:<EOL><INDENT>f_start = self.f_begin<EOL><DEDENT>if f_stop is None:<EOL><INDENT>f_stop = self.f_end<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if f_start is None:<EOL><INDENT>f_start = self.f_start<EOL><DEDENT>if f_stop is None:<EOL><INDENT>f_stop = self.f_stop<EOL><DEDENT>if t_start is None:<EOL><INDENT>t_start = self.t_start<EOL><DEDENT>if t_stop is None:<EOL><INDENT>t_stop = self.t_stop<EOL><DEDENT><DEDENT>if t_stop >= <NUM_LIT:0> and t_start >= <NUM_LIT:0> and t_stop < t_start:<EOL><INDENT>t_stop, t_start = t_start,t_stop<EOL>logger.warning('<STR_LIT>')<EOL><DEDENT>if f_stop and f_start and f_stop < f_start:<EOL><INDENT>f_stop, f_start = f_start,f_stop<EOL>logger.warning('<STR_LIT>')<EOL><DEDENT>if t_start >= self.t_begin and t_start < self.t_end:<EOL><INDENT>self.t_start = int(t_start)<EOL><DEDENT>else:<EOL><INDENT>if init is False or t_start != None:<EOL><INDENT>logger.warning('<STR_LIT>'%self.t_begin)<EOL><DEDENT>self.t_start = self.t_begin<EOL><DEDENT>if t_stop <= self.t_end  and t_stop > self.t_begin:<EOL><INDENT>self.t_stop = int(t_stop)<EOL><DEDENT>else:<EOL><INDENT>if init is False or t_stop:<EOL><INDENT>logger.warning('<STR_LIT>'%self.t_end)<EOL><DEDENT>self.t_stop = self.t_end<EOL><DEDENT>if f_start >= self.f_begin and f_start < self.f_end:<EOL><INDENT>self.f_start = f_start<EOL><DEDENT>else:<EOL><INDENT>if init is False or f_start:<EOL><INDENT>logger.warning('<STR_LIT>'%self.f_begin)<EOL><DEDENT>self.f_start = self.f_begin<EOL><DEDENT>if f_stop <= self.f_end and f_stop > self.f_begin:<EOL><INDENT>self.f_stop = f_stop<EOL><DEDENT>else:<EOL><INDENT>if init is False or f_stop:<EOL><INDENT>logger.warning('<STR_LIT>'%self.f_end)<EOL><DEDENT>self.f_stop = self.f_end<EOL><DEDENT>self.selection_shape = self._calc_selection_shape()<EOL>", "docstring": "Making sure the selection if time and frequency are within the file limits.\n\n        Args:\n            init (bool): If call during __init__", "id": "f8172:c0:m1"}
{"signature": "def _setup_n_ints_in_file(self):", "body": "self.n_ints_in_file = sigproc.calc_n_ints_in_file(self.filename)<EOL>", "docstring": "Calculate the number of integrations in the file.", "id": "f8172:c2:m1"}
{"signature": "def cmd_tool(args=None):", "body": "from argparse import ArgumentParser<EOL>if not HAS_BITSHUFFLE:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>exit()<EOL><DEDENT>parser = ArgumentParser(description=\"<STR_LIT>\")<EOL>parser.add_argument('<STR_LIT:filename>', type=str, help='<STR_LIT>')<EOL>args = parser.parse_args()<EOL>fileroot = args.filename.split('<STR_LIT>')[<NUM_LIT:0>]<EOL>filelist = glob.glob(fileroot + '<STR_LIT>')<EOL>filelist = sorted(filelist)<EOL>r = GuppiRaw(filelist[<NUM_LIT:0>])<EOL>header, data = r.read_next_data_block()<EOL>dshape = data.shape <EOL>print(dshape)<EOL>n_blocks_total = <NUM_LIT:0><EOL>for filename in filelist:<EOL><INDENT>print(filename)<EOL>r = GuppiRaw(filename)<EOL>n_blocks_total += r.n_blocks<EOL><DEDENT>print(n_blocks_total)<EOL>full_dshape = np.concatenate(((n_blocks_total,), dshape))<EOL>h5 = h5py.File(fileroot + '<STR_LIT>', '<STR_LIT:w>')<EOL>h5.attrs['<STR_LIT>'] = '<STR_LIT>'<EOL>block_size = <NUM_LIT:0>      <EOL>dset = h5.create_dataset('<STR_LIT:data>',<EOL>shape=full_dshape,<EOL>dtype=data.dtype) <EOL>h5_idx = <NUM_LIT:0><EOL>for filename in filelist:<EOL><INDENT>print(\"<STR_LIT>\" % filename)<EOL>r = GuppiRaw(filename)<EOL>h5 = h5py.File(filename + '<STR_LIT>', '<STR_LIT:w>')<EOL>header, data = r.read_next_data_block()<EOL>for ii in range(<NUM_LIT:0>, r.n_blocks):<EOL><INDENT>t0 = time.time()<EOL>print(\"<STR_LIT>\" % (h5_idx+<NUM_LIT:1>, full_dshape[<NUM_LIT:0>]))<EOL>header, data = r.read_next_data_block()<EOL>t1 = time.time()<EOL>t2 = time.time()<EOL>print(\"<STR_LIT>\" % (h5_idx+<NUM_LIT:1>, full_dshape[<NUM_LIT:0>]))<EOL>dset[h5_idx, :] = data<EOL>t3 = time.time()<EOL>print(\"<STR_LIT>\" % ((t1-t0), (t3-t2)))<EOL>h5_idx += <NUM_LIT:1><EOL>for key, value in header.items():<EOL><INDENT>dset.attrs[key] = value<EOL><DEDENT><DEDENT>h5.close()<EOL>t1 = time.time()<EOL>print(\"<STR_LIT>\" % (t1- t0))<EOL><DEDENT>", "docstring": "Command line tool for converting guppi raw into HDF5 versions of guppi raw", "id": "f8173:m0"}
{"signature": "def read_header(filename, return_idxs=False):", "body": "with open(filename, '<STR_LIT:rb>') as fh:<EOL><INDENT>header_dict = {}<EOL>header_idxs = {}<EOL>keyword, value, idx = read_next_header_keyword(fh)<EOL>try:<EOL><INDENT>assert keyword == b'<STR_LIT>'<EOL><DEDENT>except AssertionError:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>while True:<EOL><INDENT>keyword, value, idx = read_next_header_keyword(fh)<EOL>if keyword == b'<STR_LIT>':<EOL><INDENT>break<EOL><DEDENT>else:<EOL><INDENT>header_dict[keyword] = value<EOL>header_idxs[keyword] = idx<EOL><DEDENT><DEDENT><DEDENT>if return_idxs:<EOL><INDENT>return header_idxs<EOL><DEDENT>else:<EOL><INDENT>return header_dict<EOL><DEDENT>", "docstring": "Read blimpy header and return a Python dictionary of key:value pairs\n\n    Args:\n        filename (str): name of file to open\n\n    Optional args:\n        return_idxs (bool): Default False. If true, returns the file offset indexes\n                            for values\n\n    returns", "id": "f8174:m3"}
{"signature": "def calc_n_ints_in_file(filename):", "body": "<EOL>h = read_header(filename)<EOL>n_bytes  = int(h[b'<STR_LIT>'] / <NUM_LIT:8>)<EOL>n_chans = h[b'<STR_LIT>']<EOL>n_ifs   = h[b'<STR_LIT>']<EOL>idx_data = len_header(filename)<EOL>f = open(filename, '<STR_LIT:rb>')<EOL>f.seek(idx_data)<EOL>filesize = os.path.getsize(filename)<EOL>n_bytes_data = filesize - idx_data<EOL>if h[b'<STR_LIT>'] == <NUM_LIT:2>:<EOL><INDENT>n_ints = int(<NUM_LIT:4> * n_bytes_data / (n_chans * n_ifs))<EOL><DEDENT>else:<EOL><INDENT>n_ints = int(n_bytes_data / (n_bytes * n_chans * n_ifs))<EOL><DEDENT>return n_ints<EOL>", "docstring": "Calculate number of integrations in a given file", "id": "f8174:m9"}
{"signature": "def read_next_header_keyword(fh):", "body": "n_bytes = np.fromstring(fh.read(<NUM_LIT:4>), dtype='<STR_LIT>')[<NUM_LIT:0>]<EOL>if n_bytes > <NUM_LIT:255>:<EOL><INDENT>n_bytes = <NUM_LIT:16><EOL><DEDENT>keyword = fh.read(n_bytes)<EOL>if keyword == b'<STR_LIT>' or keyword == b'<STR_LIT>':<EOL><INDENT>return keyword, <NUM_LIT:0>, fh.tell()<EOL><DEDENT>else:<EOL><INDENT>dtype = header_keyword_types[keyword]<EOL>idx = fh.tell()<EOL>if dtype == b'<STR_LIT>':<EOL><INDENT>val = struct.unpack(dtype, fh.read(<NUM_LIT:4>))[<NUM_LIT:0>]<EOL><DEDENT>if dtype == b'<STR_LIT>':<EOL><INDENT>val = struct.unpack(dtype, fh.read(<NUM_LIT:8>))[<NUM_LIT:0>]<EOL><DEDENT>if dtype == b'<STR_LIT:str>':<EOL><INDENT>str_len = np.fromstring(fh.read(<NUM_LIT:4>), dtype='<STR_LIT>')[<NUM_LIT:0>]<EOL>val = fh.read(str_len)<EOL><DEDENT>if dtype == b'<STR_LIT>':<EOL><INDENT>val = struct.unpack('<STR_LIT>', fh.read(<NUM_LIT:8>))[<NUM_LIT:0>]<EOL>val = fil_double_to_angle(val)<EOL>if keyword == b'<STR_LIT>':<EOL><INDENT>val = Angle(val, unit=u.hour)<EOL><DEDENT>else:<EOL><INDENT>val = Angle(val, unit=u.deg)<EOL><DEDENT><DEDENT>return keyword, val, idx<EOL><DEDENT>", "docstring": "Args:\n    fh (file): file handler\n\nReturns:", "id": "f8174:m1"}
{"signature": "def unpack(data, nbit):", "body": "if nbit > <NUM_LIT:8>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if <NUM_LIT:8> % nbit != <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if data.dtype not in (np.uint8, np.int8):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if nbit == <NUM_LIT:8>:<EOL><INDENT>return data<EOL><DEDENT>elif nbit == <NUM_LIT:4>:<EOL><INDENT>data = unpack_4to8(data)<EOL>return data<EOL><DEDENT>elif nbit == <NUM_LIT:2>:<EOL><INDENT>data = unpack_2to8(data)<EOL>return data<EOL><DEDENT>elif nbit == <NUM_LIT:1>:<EOL><INDENT>data = unpack_1to8(data)<EOL>return data<EOL><DEDENT>", "docstring": "upgrade data from nbits to 8bits\n\n    Notes: Pretty sure this function is a little broken!", "id": "f8175:m4"}
{"signature": "def rebin(d, n_x, n_y=None):", "body": "if d.ndim == <NUM_LIT:2>:<EOL><INDENT>if n_y is None:<EOL><INDENT>n_y = <NUM_LIT:1><EOL><DEDENT>if n_x is None:<EOL><INDENT>n_x = <NUM_LIT:1><EOL><DEDENT>d = d[:int(d.shape[<NUM_LIT:0>] // n_x) * n_x, :int(d.shape[<NUM_LIT:1>] // n_y) * n_y]<EOL>d = d.reshape((d.shape[<NUM_LIT:0>] // n_x, n_x, d.shape[<NUM_LIT:1>] // n_y, n_y))<EOL>d = d.mean(axis=<NUM_LIT:3>)<EOL>d = d.mean(axis=<NUM_LIT:1>)<EOL><DEDENT>elif d.ndim == <NUM_LIT:1>:<EOL><INDENT>d = d[:int(d.shape[<NUM_LIT:0>] // n_x) * n_x]<EOL>d = d.reshape((d.shape[<NUM_LIT:0>] // n_x, n_x))<EOL>d = d.mean(axis=<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>return d<EOL>", "docstring": "Rebin data by averaging bins together\n\n    Args:\n    d (np.array): data\n    n_x (int): number of bins in x dir to rebin into one\n    n_y (int): number of bins in y dir to rebin into one\n\n    Returns:\n    d: rebinned data with shape (n_x, n_y)", "id": "f8175:m3"}
{"signature": "def compute_lst(self):", "body": "if self.header[b'<STR_LIT>'] == <NUM_LIT:6>:<EOL><INDENT>self.coords = gbt_coords<EOL><DEDENT>elif self.header[b'<STR_LIT>'] == <NUM_LIT:4>:<EOL><INDENT>self.coords = parkes_coords<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>if HAS_SLALIB:<EOL><INDENT>dut1 = <NUM_LIT:0.0><EOL>mjd = self.header[b'<STR_LIT>']<EOL>tellong = np.deg2rad(self.coords[<NUM_LIT:1>])<EOL>last = s.sla_gmst(mjd) - tellong + s.sla_eqeqx(mjd) + dut1<EOL>if last < <NUM_LIT:0.0> : last = last + <NUM_LIT>*np.pi<EOL>return last<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Compute LST for observation", "id": "f8176:c0:m6"}
{"signature": "def cmd_tool(args=None):", "body": "from argparse import ArgumentParser<EOL>parser = ArgumentParser(description=\"<STR_LIT>\")<EOL>parser.add_argument('<STR_LIT>', action='<STR_LIT:store>',  default='<STR_LIT>', dest='<STR_LIT>', type=str,<EOL>help='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT:filename>', type=str,<EOL>help='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', action='<STR_LIT:store>', default=None, dest='<STR_LIT>', type=float,<EOL>help='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', action='<STR_LIT:store>', default=None, dest='<STR_LIT>', type=float,<EOL>help='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', action='<STR_LIT:store>', default=None, dest='<STR_LIT>', type=int,<EOL>help='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', action='<STR_LIT:store>', default=None, dest='<STR_LIT>', type=int,<EOL>help='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', action='<STR_LIT:store_true>', default=False, dest='<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', action='<STR_LIT:store_true>', default=False, dest='<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', action='<STR_LIT:store>', default='<STR_LIT>', dest='<STR_LIT>', type=str,<EOL>help='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', action='<STR_LIT:store_true>', default=False, dest='<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', action='<STR_LIT>', default=True, dest='<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT:-c>', action='<STR_LIT:store_true>', default=False, dest='<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>args = parser.parse_args()<EOL>filename = args.filename<EOL>load_data = not args.info_only<EOL>wtp = args.what_to_plot<EOL>if not wtp or '<STR_LIT:s>' in wtp:<EOL><INDENT>if args.t_start == None:<EOL><INDENT>t_start = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>t_start = args.t_start<EOL><DEDENT>t_stop  = t_start + <NUM_LIT:1><EOL>if args.average:<EOL><INDENT>t_start = None<EOL>t_stop  = None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>t_start = args.t_start<EOL>t_stop  = args.t_stop<EOL><DEDENT>if args.info_only:<EOL><INDENT>args.blank_dc = False<EOL>args.calibrate_band_pass = False<EOL><DEDENT>fil = Filterbank(filename, f_start=args.f_start, f_stop=args.f_stop,<EOL>t_start=t_start, t_stop=t_stop,<EOL>load_data=load_data,blank_dc=args.blank_dc,<EOL>cal_band_pass=args.calibrate_band_pass)<EOL>fil.info()<EOL>if not args.info_only:<EOL><INDENT>if args.what_to_plot == \"<STR_LIT:w>\":<EOL><INDENT>plt.figure(\"<STR_LIT>\", figsize=(<NUM_LIT:8>, <NUM_LIT:6>))<EOL>fil.plot_waterfall(f_start=args.f_start, f_stop=args.f_stop)<EOL><DEDENT>elif args.what_to_plot == \"<STR_LIT:s>\":<EOL><INDENT>plt.figure(\"<STR_LIT>\", figsize=(<NUM_LIT:8>, <NUM_LIT:6>))<EOL>fil.plot_spectrum(logged=True, f_start=args.f_start, f_stop=args.f_stop, t='<STR_LIT:all>')<EOL><DEDENT>elif args.what_to_plot == \"<STR_LIT>\":<EOL><INDENT>plt.figure(\"<STR_LIT>\", figsize=(<NUM_LIT:8>, <NUM_LIT:6>))<EOL>fil.plot_spectrum_min_max(logged=True, f_start=args.f_start, f_stop=args.f_stop, t='<STR_LIT:all>')<EOL><DEDENT>elif args.what_to_plot == \"<STR_LIT:k>\":<EOL><INDENT>plt.figure(\"<STR_LIT>\", figsize=(<NUM_LIT:8>, <NUM_LIT:6>))<EOL>fil.plot_kurtosis(f_start=args.f_start, f_stop=args.f_stop)<EOL><DEDENT>elif args.what_to_plot == \"<STR_LIT:t>\":<EOL><INDENT>plt.figure(\"<STR_LIT>\", figsize=(<NUM_LIT:8>, <NUM_LIT:6>))<EOL>fil.plot_time_series(f_start=args.f_start, f_stop=args.f_stop,orientation='<STR_LIT:h>')<EOL><DEDENT>elif args.what_to_plot == \"<STR_LIT:a>\":<EOL><INDENT>plt.figure(\"<STR_LIT>\", figsize=(<NUM_LIT:12>, <NUM_LIT:9>),facecolor='<STR_LIT>')<EOL>fil.plot_all(logged=True, f_start=args.f_start, f_stop=args.f_stop, t='<STR_LIT:all>')<EOL><DEDENT>elif args.what_to_plot == \"<STR_LIT>\":<EOL><INDENT>plt.figure(\"<STR_LIT>\", figsize=(<NUM_LIT:12>, <NUM_LIT:9>),facecolor='<STR_LIT>')<EOL>fil.plot_all(logged=True, f_start=args.f_start, f_stop=args.f_stop, t='<STR_LIT:all>',kurtosis=False)<EOL><DEDENT>if args.plt_filename != '<STR_LIT>':<EOL><INDENT>plt.savefig(args.plt_filename)<EOL><DEDENT>if not args.save_only:<EOL><INDENT>if '<STR_LIT>' in os.environ.keys():<EOL><INDENT>plt.show()<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Command line tool for plotting and viewing info on filterbank files", "id": "f8176:m0"}
{"signature": "def grab_data(self, f_start=None, f_stop=None, t_start=None, t_stop=None, if_id=<NUM_LIT:0>):", "body": "if f_start is None:<EOL><INDENT>f_start = self.freqs[<NUM_LIT:0>]<EOL><DEDENT>if f_stop is None:<EOL><INDENT>f_stop = self.freqs[-<NUM_LIT:1>]<EOL><DEDENT>i0 = np.argmin(np.abs(self.freqs - f_start))<EOL>i1 = np.argmin(np.abs(self.freqs - f_stop))<EOL>if i0 < i1:<EOL><INDENT>plot_f    = self.freqs[i0:i1 + <NUM_LIT:1>]<EOL>plot_data = np.squeeze(self.data[t_start:t_stop, ..., i0:i1 + <NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>plot_f    = self.freqs[i1:i0 + <NUM_LIT:1>]<EOL>plot_data = np.squeeze(self.data[t_start:t_stop, ..., i1:i0 + <NUM_LIT:1>])<EOL><DEDENT>return plot_f, plot_data<EOL>", "docstring": "Extract a portion of data by frequency range.\n\n        Args:\n            f_start (float): start frequency in MHz\n            f_stop (float): stop frequency in MHz\n            if_id (int): IF input identification (req. when multiple IFs in file)\n\n        Returns:\n            (freqs, data) (np.arrays): frequency axis in MHz and data subset", "id": "f8176:c0:m11"}
{"signature": "def _setup_time_axis(self, t_start=None, t_stop=None):", "body": "<EOL>ii_start, ii_stop = <NUM_LIT:0>, self.n_ints_in_file<EOL>if t_start:<EOL><INDENT>ii_start = t_start<EOL><DEDENT>if t_stop:<EOL><INDENT>ii_stop = t_stop<EOL><DEDENT>n_ints = ii_stop - ii_start<EOL>t0 = self.header[b'<STR_LIT>']<EOL>t_delt = self.header[b'<STR_LIT>']<EOL>self.timestamps = np.arange(<NUM_LIT:0>, n_ints) * t_delt / <NUM_LIT>/<NUM_LIT>/<NUM_LIT> + t0<EOL>return ii_start, ii_stop, n_ints<EOL>", "docstring": "Setup time axis.", "id": "f8176:c0:m4"}
{"signature": "def _setup_freqs(self, f_start=None, f_stop=None):", "body": "<EOL>f0 = self.header[b'<STR_LIT>']<EOL>f_delt = self.header[b'<STR_LIT>']<EOL>i_start, i_stop = <NUM_LIT:0>, self.header[b'<STR_LIT>']<EOL>if f_start:<EOL><INDENT>i_start = int((f_start - f0) / f_delt)<EOL><DEDENT>if f_stop:<EOL><INDENT>i_stop  = int((f_stop - f0)  / f_delt)<EOL><DEDENT>chan_start_idx = np.int(i_start)<EOL>chan_stop_idx  = np.int(i_stop)<EOL>if i_start < i_stop:<EOL><INDENT>i_vals = np.arange(chan_start_idx, chan_stop_idx)<EOL><DEDENT>else:<EOL><INDENT>i_vals = np.arange(chan_stop_idx, chan_start_idx)<EOL><DEDENT>self.freqs = f_delt * i_vals + f0<EOL><INDENT>if f_delt < <NUM_LIT:0>:<EOL><INDENT>self.freqs = self.freqs[::-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>if chan_stop_idx < chan_start_idx:<EOL><INDENT>chan_stop_idx, chan_start_idx = chan_start_idx,chan_stop_idx<EOL><DEDENT>return i_start, i_stop, chan_start_idx, chan_stop_idx<EOL>", "docstring": "Setup frequency axis", "id": "f8176:c0:m3"}
{"signature": "@sportsref.decorators.memoize<EOL><INDENT>def get_team_ids(self):<DEDENT>", "body": "df = self.team_stats_per_game()<EOL>if not df.empty:<EOL><INDENT>return df.index.tolist()<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>')<EOL>return []<EOL><DEDENT>", "docstring": "Returns a list of the team IDs for the given year.\n        :returns: List of team IDs.", "id": "f8179:c0:m7"}
{"signature": "@sportsref.decorators.memoize<EOL><INDENT>def get_sub_doc(self, subpage):<DEDENT>", "body": "html = sportsref.utils.get_html(self._subpage_url(subpage))<EOL>return pq(html)<EOL>", "docstring": "Returns PyQuery object for a given subpage URL.\n        :subpage: The subpage of the season, e.g. 'per_game'.\n        :returns: PyQuery object.", "id": "f8179:c0:m6"}
{"signature": "@sportsref.decorators.memoize<EOL><INDENT>def _get_player_stats_table(self, identifier):<DEDENT>", "body": "doc = self.get_sub_doc(identifier)<EOL>table = doc('<STR_LIT>'.format(identifier))<EOL>df = sportsref.utils.parse_table(table)<EOL>return df<EOL>", "docstring": "Helper function for player season stats.\n\n        :identifier: string identifying the type of stat, e.g. 'per_game'.\n        :returns: A DataFrame of stats.", "id": "f8179:c0:m22"}
{"signature": "def standings(self):", "body": "doc = self.get_sub_doc('<STR_LIT>')<EOL>east_table = doc('<STR_LIT>')<EOL>east_df = pd.DataFrame(sportsref.utils.parse_table(east_table))<EOL>east_df.sort_values('<STR_LIT>', ascending=False, inplace=True)<EOL>east_df['<STR_LIT>'] = range(<NUM_LIT:1>, len(east_df) + <NUM_LIT:1>)<EOL>east_df['<STR_LIT>'] = '<STR_LIT:E>'<EOL>west_table = doc('<STR_LIT>')<EOL>west_df = sportsref.utils.parse_table(west_table)<EOL>west_df.sort_values('<STR_LIT>', ascending=False, inplace=True)<EOL>west_df['<STR_LIT>'] = range(<NUM_LIT:1>, len(west_df) + <NUM_LIT:1>)<EOL>west_df['<STR_LIT>'] = '<STR_LIT>'<EOL>full_df = pd.concat([east_df, west_df], axis=<NUM_LIT:0>).reset_index(drop=True)<EOL>full_df['<STR_LIT>'] = full_df.team_id.str.extract(r'<STR_LIT>', expand=False)<EOL>full_df['<STR_LIT>'] = [gb if isinstance(gb, int) or isinstance(gb, float) else <NUM_LIT:0><EOL>for gb in full_df['<STR_LIT>']]<EOL>full_df = full_df.drop('<STR_LIT>', axis=<NUM_LIT:1>)<EOL>expanded_table = doc('<STR_LIT>')<EOL>expanded_df = sportsref.utils.parse_table(expanded_table)<EOL>full_df = pd.merge(full_df, expanded_df, on='<STR_LIT>')<EOL>return full_df<EOL>", "docstring": "Returns a DataFrame containing standings information.", "id": "f8179:c0:m13"}
{"signature": "def misc_stats(self):", "body": "return self._get_team_stats_table('<STR_LIT>')<EOL>", "docstring": "Returns a Pandas DataFrame of miscellaneous stats about each team's\n        season.", "id": "f8179:c0:m19"}
{"signature": "def team_stats_totals(self):", "body": "return self._get_team_stats_table('<STR_LIT>')<EOL>", "docstring": "Returns a Pandas DataFrame of each team's basic stat totals for the\n        season.", "id": "f8179:c0:m17"}
{"signature": "def player_stats_per_game(self):", "body": "return self._get_player_stats_table('<STR_LIT>')<EOL>", "docstring": "Returns a DataFrame of per-game player stats for a season.", "id": "f8179:c0:m23"}
{"signature": "def finals_loser(self):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Returns the team ID for the loser of that year's NBA Finals.\n        :returns: 3-letter team ID for runner-up.", "id": "f8179:c0:m12"}
{"signature": "@sportsref.decorators.memoize<EOL><INDENT>def draft_year(self):<DEDENT>", "body": "raise Exception('<STR_LIT>')<EOL>", "docstring": "Returns the year the player was selected (or undrafted).\n        :returns: TODO", "id": "f8180:c0:m14"}
{"signature": "@sportsref.decorators.memoize<EOL><INDENT>@sportsref.decorators.kind_rpb(include_type=True)<EOL>def gamelog_advanced(self, year, kind='<STR_LIT:R>'):<DEDENT>", "body": "doc = self.get_sub_doc('<STR_LIT>'.format(year))<EOL>table = (doc('<STR_LIT>')<EOL>if kind == '<STR_LIT:P>' else doc('<STR_LIT>'))<EOL>df = sportsref.utils.parse_table(table)<EOL>return df<EOL>", "docstring": "Returns a table of a player's advanced game-by-game stats for a\n        season.\n\n        :param year: The year representing the desired season.\n        :param kind: specifies regular season, playoffs, or both. One of 'R',\n            'P', 'B'. Defaults to 'R'.\n        :returns: A DataFrame of the player's advanced stats from each game of\n            the season.\n        :rtype: pd.DataFrame", "id": "f8180:c0:m24"}
{"signature": "@sportsref.decorators.memoize<EOL><INDENT>def age(self, year, month=<NUM_LIT:2>, day=<NUM_LIT:1>):<DEDENT>", "body": "doc = self.get_main_doc()<EOL>date_string = doc('<STR_LIT>').attr('<STR_LIT>')<EOL>regex = r'<STR_LIT>'<EOL>date_args = map(int, re.match(regex, date_string).groups())<EOL>birth_date = datetime.date(*date_args)<EOL>age_date = datetime.date(year=year, month=month, day=day)<EOL>delta = age_date - birth_date<EOL>age = delta.days / <NUM_LIT><EOL>return age<EOL>", "docstring": "Returns the age of the player on a given date.\n\n        :year: int representing the year.\n        :month: int representing the month (1-12).\n        :day: int representing the day within the month (1-31).\n        :returns: Age in years as a float.", "id": "f8180:c0:m8"}
{"signature": "@sportsref.decorators.memoize<EOL><INDENT>def name(self):<DEDENT>", "body": "doc = self.get_main_doc()<EOL>return doc('<STR_LIT>').text()<EOL>", "docstring": "Returns the name of the player as a string.", "id": "f8180:c0:m7"}
{"signature": "@sportsref.decorators.memoize<EOL><INDENT>def away(self):<DEDENT>", "body": "linescore = self.linescore()<EOL>return linescore.loc['<STR_LIT>', '<STR_LIT>']<EOL>", "docstring": "Returns away team ID.\n        :returns: 3-character string representing away team's ID.", "id": "f8181:c0:m10"}
{"signature": "@sportsref.decorators.memoize<EOL><INDENT>def season(self):<DEDENT>", "body": "d = self.date()<EOL>if d.month >= <NUM_LIT:9>:<EOL><INDENT>return d.year + <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>return d.year<EOL><DEDENT>", "docstring": "Returns the year ID of the season in which this game took place.\n\n:returns: An int representing the year of the season.", "id": "f8181:c0:m14"}
{"signature": "@sportsref.decorators.memoize<EOL><INDENT>def basic_stats(self):<DEDENT>", "body": "return self._get_player_stats('<STR_LIT>')<EOL>", "docstring": "Returns a DataFrame of basic player stats from the game.", "id": "f8181:c0:m16"}
{"signature": "@sportsref.decorators.memoize<EOL><INDENT>def home_score(self):<DEDENT>", "body": "linescore = self.linescore()<EOL>return linescore.loc['<STR_LIT>', '<STR_LIT:T>']<EOL>", "docstring": "Returns score of the home team.\n        :returns: int of the home score.", "id": "f8181:c0:m11"}
{"signature": "@sportsref.decorators.memoize<EOL><INDENT>def linescore(self):<DEDENT>", "body": "doc = self.get_main_doc()<EOL>table = doc('<STR_LIT>')<EOL>columns = [th.text() for th in table('<STR_LIT>').items('<STR_LIT>')]<EOL>columns[<NUM_LIT:0>] = '<STR_LIT>'<EOL>data = [<EOL>[sportsref.utils.flatten_links(td) for td in tr('<STR_LIT>').items()]<EOL>for tr in table('<STR_LIT>').next_all('<STR_LIT>').items()<EOL>]<EOL>return pd.DataFrame(data, index=['<STR_LIT>', '<STR_LIT>'],<EOL>columns=columns, dtype='<STR_LIT:float>')<EOL>", "docstring": "Returns the linescore for the game as a DataFrame.", "id": "f8181:c0:m8"}
{"signature": "def _get_player_stats(self, table_id_fmt):", "body": "<EOL>doc = self.get_main_doc()<EOL>tms = self.away(), self.home()<EOL>tm_ids = [table_id_fmt.format(tm) for tm in tms]<EOL>tables = [doc('<STR_LIT>'.format(tm_id).lower()) for tm_id in tm_ids]<EOL>dfs = [sportsref.utils.parse_table(table) for table in tables]<EOL>for i, (tm, df) in enumerate(zip(tms, dfs)):<EOL><INDENT>no_time = df['<STR_LIT>'] == <NUM_LIT:0><EOL>stat_cols = [col for col, dtype in df.dtypes.items()<EOL>if dtype != '<STR_LIT:object>']<EOL>df.loc[no_time, stat_cols] = <NUM_LIT:0><EOL>df['<STR_LIT>'] = tm<EOL>df['<STR_LIT>'] = i == <NUM_LIT:1><EOL>df['<STR_LIT>'] = [p < <NUM_LIT:5> for p in range(df.shape[<NUM_LIT:0>])]<EOL>df.drop_duplicates(subset='<STR_LIT>', keep='<STR_LIT>', inplace=True)<EOL><DEDENT>return pd.concat(dfs)<EOL>", "docstring": "Returns a DataFrame of player stats from the game (either basic or\n        advanced, depending on the argument.\n\n        :param table_id_fmt: Format string for str.format with a placeholder\n            for the team ID (e.g. 'box_{}_basic')\n        :returns: DataFrame of player stats", "id": "f8181:c0:m15"}
{"signature": "@sportsref.decorators.memoize<EOL><INDENT>def home(self):<DEDENT>", "body": "linescore = self.linescore()<EOL>return linescore.loc['<STR_LIT>', '<STR_LIT>']<EOL>", "docstring": "Returns home team ID.\n        :returns: 3-character string representing home team's ID.", "id": "f8181:c0:m9"}
{"signature": "@sportsref.decorators.memoize<EOL><INDENT>def team_ids_to_names(self):<DEDENT>", "body": "return sportsref.nfl.teams.team_names(self.yr)<EOL>", "docstring": "Mapping from 3-letter team IDs to full team names.\n\n        :returns: Dictionary with team IDs as keys and full team strings as\n            values.", "id": "f8187:c0:m8"}
{"signature": "@sportsref.decorators.memoize<EOL><INDENT>def team_names_to_ids(self):<DEDENT>", "body": "return sportsref.nfl.teams.team_ids(self.yr)<EOL>", "docstring": "Mapping from full team names to 3-letter team IDs.\n        :returns: Dictionary with tean names as keys and team IDs as values.", "id": "f8187:c0:m9"}
{"signature": "@sportsref.decorators.memoize<EOL><INDENT>@sportsref.decorators.kind_rpb(include_type=True)<EOL>def defense(self, kind='<STR_LIT:R>'):<DEDENT>", "body": "doc = self.get_doc()<EOL>table = (doc('<STR_LIT>') if kind == '<STR_LIT:R>' else<EOL>doc('<STR_LIT>'))<EOL>df = sportsref.utils.parse_table(table)<EOL>return df<EOL>", "docstring": "Gets yearly defense stats for the player (also has AV stats for OL).\n\n        :kind: One of 'R', 'P', or 'B'. Case-insensitive; defaults to 'R'.\n        :returns: Pandas DataFrame with rushing/receiving stats.", "id": "f8188:c0:m23"}
{"signature": "@sportsref.decorators.memoize<EOL><INDENT>def _simple_year_award(self, award_id):<DEDENT>", "body": "doc = self.get_doc()<EOL>table = doc('<STR_LIT>'.format(award_id))<EOL>return list(map(int, sportsref.utils.parse_awards_table(table)))<EOL>", "docstring": "Template for simple award functions that simply list years, such as\n        pro bowls and first-team all pro.\n\n        :award_id: The div ID that is appended to \"leaderboard_\" in selecting\n        the table's div.\n        :returns: List of years for the award.", "id": "f8188:c0:m30"}
{"signature": "@sportsref.decorators.memoize<EOL><INDENT>@sportsref.decorators.kind_rpb(include_type=True)<EOL>def gamelog(self, year=None, kind='<STR_LIT:R>'):<DEDENT>", "body": "url = self._subpage_url('<STR_LIT>', None)  <EOL>doc = pq(sportsref.utils.get_html(url))<EOL>table = (doc('<STR_LIT>') if kind == '<STR_LIT:R>' else<EOL>doc('<STR_LIT>'))<EOL>df = sportsref.utils.parse_table(table)<EOL>if year is not None:<EOL><INDENT>df = df.query('<STR_LIT>').reset_index(drop=True)<EOL><DEDENT>return df<EOL>", "docstring": "Gets the career gamelog of the given player.\n        :kind: One of 'R', 'P', or 'B' (for regular season, playoffs, or both).\n        Case-insensitive; defaults to 'R'.\n        :year: The year for which the gamelog should be returned; if None,\n        return entire career gamelog. Defaults to None.\n        :returns: A DataFrame with the player's career gamelog.", "id": "f8188:c0:m20"}
{"signature": "@sportsref.decorators.memoize<EOL><INDENT>@sportsref.decorators.kind_rpb(include_type=True)<EOL>def passing(self, kind='<STR_LIT:R>'):<DEDENT>", "body": "doc = self.get_doc()<EOL>table = (doc('<STR_LIT>') if kind == '<STR_LIT:R>' else<EOL>doc('<STR_LIT>'))<EOL>df = sportsref.utils.parse_table(table)<EOL>return df<EOL>", "docstring": "Gets yearly passing stats for the player.\n\n        :kind: One of 'R', 'P', or 'B'. Case-insensitive; defaults to 'R'.\n        :returns: Pandas DataFrame with passing stats.", "id": "f8188:c0:m21"}
{"signature": "@decorators.switch_to_dir(os.path.dirname(os.path.realpath(__file__)))<EOL>def inputs_options_defaults():", "body": "<EOL>if os.path.isfile(PSF_CONSTANTS_FILENAME):<EOL><INDENT>modtime = int(os.path.getmtime(PSF_CONSTANTS_FILENAME))<EOL>curtime = int(time.time())<EOL><DEDENT>if (os.path.isfile(PSF_CONSTANTS_FILENAME)<EOL>and curtime - modtime <= <NUM_LIT:7> * <NUM_LIT> * <NUM_LIT> * <NUM_LIT>):<EOL><INDENT>with open(PSF_CONSTANTS_FILENAME, '<STR_LIT:r>') as const_f:<EOL><INDENT>def_dict = json.load(const_f)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>print('<STR_LIT>')<EOL>html = utils.get_html(PSF_URL)<EOL>doc = pq(html)<EOL>def_dict = {}<EOL>for inp in doc('<STR_LIT>'):<EOL><INDENT>name = inp.attrib['<STR_LIT:name>']<EOL>if name not in def_dict:<EOL><INDENT>def_dict[name] = {<EOL>'<STR_LIT:value>': set(),<EOL>'<STR_LIT>': set(),<EOL>'<STR_LIT:type>': inp.attrib['<STR_LIT:type>']<EOL>}<EOL><DEDENT>if inp.attrib['<STR_LIT:type>'] in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>if '<STR_LIT>' in inp.attrib:<EOL><INDENT>def_dict[name]['<STR_LIT:value>'].add(inp.attrib['<STR_LIT:value>'])<EOL><DEDENT>def_dict[name]['<STR_LIT>'].add(inp.attrib['<STR_LIT:value>'])<EOL><DEDENT>else:<EOL><INDENT>def_dict[name]['<STR_LIT:value>'].add(inp.attrib.get('<STR_LIT:value>', '<STR_LIT>'))<EOL><DEDENT><DEDENT>for sel in doc.items('<STR_LIT>'):<EOL><INDENT>name = sel.attr['<STR_LIT:name>']<EOL>if name not in def_dict:<EOL><INDENT>def_dict[name] = {<EOL>'<STR_LIT:value>': set(),<EOL>'<STR_LIT>': set(),<EOL>'<STR_LIT:type>': '<STR_LIT>'<EOL>}<EOL><DEDENT>defaultOpt = sel('<STR_LIT>')<EOL>if len(defaultOpt):<EOL><INDENT>defaultOpt = defaultOpt[<NUM_LIT:0>]<EOL>def_dict[name]['<STR_LIT:value>'].add(defaultOpt.attrib.get('<STR_LIT:value>', '<STR_LIT>'))<EOL><DEDENT>else:<EOL><INDENT>def_dict[name]['<STR_LIT:value>'].add(<EOL>sel('<STR_LIT>')[<NUM_LIT:0>].attrib.get('<STR_LIT:value>', '<STR_LIT>')<EOL>)<EOL><DEDENT>def_dict[name]['<STR_LIT>'] = {<EOL>opt.attrib['<STR_LIT:value>'] for opt in sel('<STR_LIT>')<EOL>if opt.attrib.get('<STR_LIT:value>')<EOL>}<EOL><DEDENT>def_dict.pop('<STR_LIT>', None)<EOL>def_dict.pop('<STR_LIT>', None)<EOL>with open(PSF_CONSTANTS_FILENAME, '<STR_LIT>') as f:<EOL><INDENT>for k in def_dict:<EOL><INDENT>try:<EOL><INDENT>def_dict[k]['<STR_LIT:value>'] = sorted(<EOL>list(def_dict[k]['<STR_LIT:value>']), key=int<EOL>)<EOL>def_dict[k]['<STR_LIT>'] = sorted(<EOL>list(def_dict[k]['<STR_LIT>']), key=int<EOL>)<EOL><DEDENT>except Exception:<EOL><INDENT>def_dict[k]['<STR_LIT:value>'] = sorted(list(def_dict[k]['<STR_LIT:value>']))<EOL>def_dict[k]['<STR_LIT>'] = sorted(<EOL>list(def_dict[k]['<STR_LIT>'])<EOL>)<EOL><DEDENT><DEDENT>json.dump(def_dict, f)<EOL><DEDENT><DEDENT>return def_dict<EOL>", "docstring": "Handles scraping options for player-season finder form.\n\n    :returns: {'name1': {'value': val, 'options': [opt1, ...] }, ... }", "id": "f8189:m2"}
{"signature": "def _kwargs_to_qs(**kwargs):", "body": "<EOL>inpOptDef = inputs_options_defaults()<EOL>opts = {<EOL>name: dct['<STR_LIT:value>']<EOL>for name, dct in inpOptDef.items()<EOL>}<EOL>for k, v in kwargs.items():<EOL><INDENT>if k.lower() in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>del kwargs[k]<EOL>kwargs['<STR_LIT>'] = v<EOL><DEDENT>if k == '<STR_LIT>':<EOL><INDENT>if v.startswith('<STR_LIT>'):<EOL><INDENT>kwargs[k] = utils.rel_url_to_id(v)<EOL><DEDENT><DEDENT>if isinstance(v, bool):<EOL><INDENT>kwargs[k] = '<STR_LIT:Y>' if v else '<STR_LIT:N>'<EOL><DEDENT>if k.lower() in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>del kwargs[k]<EOL>kwargs['<STR_LIT>'] = v<EOL><DEDENT>if k.lower() in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>del kwargs[k]<EOL>if k.lower() == '<STR_LIT>':<EOL><INDENT>kwargs['<STR_LIT>'] = int(v)<EOL><DEDENT>else:<EOL><INDENT>kwargs['<STR_LIT>'] = int(v)<EOL><DEDENT><DEDENT>if k.lower() in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>del kwargs[k]<EOL>if k.lower() == '<STR_LIT>':<EOL><INDENT>kwargs['<STR_LIT>'] = int(v)<EOL><DEDENT>else:<EOL><INDENT>kwargs['<STR_LIT>'] = int(v)<EOL><DEDENT><DEDENT>if k.lower() in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>del kwargs[k]<EOL>if isinstance(v, collections.Iterable):<EOL><INDENT>lst = list(v)<EOL>kwargs['<STR_LIT>'] = min(lst)<EOL>kwargs['<STR_LIT>'] = max(lst)<EOL><DEDENT>elif isinstance(v, basestring):<EOL><INDENT>v = list(map(int, v.split('<STR_LIT:U+002C>')))<EOL>kwargs['<STR_LIT>'] = min(v)<EOL>kwargs['<STR_LIT>'] = max(v)<EOL><DEDENT>else:<EOL><INDENT>kwargs['<STR_LIT>'] = v<EOL>kwargs['<STR_LIT>'] = v<EOL><DEDENT><DEDENT>if k.lower() in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>del kwargs[k]<EOL>if isinstance(v, collections.Iterable):<EOL><INDENT>lst = list(v)<EOL>kwargs['<STR_LIT>'] = min(lst)<EOL>kwargs['<STR_LIT>'] = max(lst)<EOL><DEDENT>elif isinstance(v, basestring):<EOL><INDENT>v = list(map(int, v.split('<STR_LIT:U+002C>')))<EOL>kwargs['<STR_LIT>'] = min(v)<EOL>kwargs['<STR_LIT>'] = max(v)<EOL><DEDENT>else:<EOL><INDENT>kwargs['<STR_LIT>'] = v<EOL>kwargs['<STR_LIT>'] = v<EOL><DEDENT><DEDENT>if k == '<STR_LIT>':<EOL><INDENT>kwargs['<STR_LIT>'] = '<STR_LIT:P>'<EOL><DEDENT>if isinstance(v, basestring):<EOL><INDENT>v = v.split('<STR_LIT:U+002C>')<EOL><DEDENT>if not isinstance(v, collections.Iterable):<EOL><INDENT>v = [v]<EOL><DEDENT><DEDENT>for k in kwargs:<EOL><INDENT>if k in opts:<EOL><INDENT>opts[k] = []<EOL><DEDENT><DEDENT>for k, v in kwargs.items():<EOL><INDENT>if k in opts:<EOL><INDENT>if isinstance(v, basestring):<EOL><INDENT>v = v.split('<STR_LIT:U+002C>')<EOL><DEDENT>elif not isinstance(v, collections.Iterable):<EOL><INDENT>v = [v]<EOL><DEDENT>for val in v:<EOL><INDENT>opts[k].append(val)<EOL><DEDENT><DEDENT><DEDENT>opts['<STR_LIT>'] = [<NUM_LIT:1>]<EOL>qs = '<STR_LIT:&>'.join('<STR_LIT>'.format(name, val)<EOL>for name, vals in sorted(opts.items()) for val in vals)<EOL>return qs<EOL>", "docstring": "Converts kwargs given to GPF to a querystring.\n\n    :returns: the querystring.", "id": "f8190:m1"}
{"signature": "@sportsref.decorators.memoize<EOL><INDENT>def week(self):<DEDENT>", "body": "doc = self.get_doc()<EOL>raw = doc('<STR_LIT>').attr['<STR_LIT>']<EOL>match = re.match(<EOL>r'<STR_LIT>'.format(self.season()), raw<EOL>)<EOL>if match:<EOL><INDENT>return int(match.group(<NUM_LIT:1>))<EOL><DEDENT>else:<EOL><INDENT>return <NUM_LIT><EOL><DEDENT>", "docstring": "Returns the week in which this game took place. 18 is WC round, 19\n        is Div round, 20 is CC round, 21 is SB.\n        :returns: Integer from 1 to 21.", "id": "f8193:c0:m14"}
{"signature": "@sportsref.decorators.memoize<EOL><INDENT>def snap_counts(self):<DEDENT>", "body": "<EOL>doc = self.get_doc()<EOL>table_ids = ('<STR_LIT>', '<STR_LIT>')<EOL>tms = (self.away(), self.home())<EOL>df = pd.concat([<EOL>sportsref.utils.parse_table(doc('<STR_LIT>'.format(table_id)))<EOL>.assign(is_home=bool(i), team=tms[i], opp=tms[i*-<NUM_LIT:1>+<NUM_LIT:1>])<EOL>for i, table_id in enumerate(table_ids)<EOL>])<EOL>if df.empty:<EOL><INDENT>return df<EOL><DEDENT>return df.set_index('<STR_LIT>')<EOL>", "docstring": "Gets the snap counts for both teams' players and returns them in a\n        DataFrame. Note: only goes back to 2012.\n\n        :returns: DataFrame of snap count data", "id": "f8193:c0:m25"}
{"signature": "@sportsref.decorators.memoize<EOL><INDENT>def ref_info(self):<DEDENT>", "body": "doc = self.get_doc()<EOL>table = doc('<STR_LIT>')<EOL>return sportsref.utils.parse_info_table(table)<EOL>", "docstring": "Gets a dictionary of ref positions and the ref IDs of the refs for\n        that game.\n\n        :returns: A dictionary of ref positions and IDs.", "id": "f8193:c0:m23"}
{"signature": "@sportsref.decorators.memoize<EOL><INDENT>def coin_toss(self):<DEDENT>", "body": "doc = self.get_doc()<EOL>table = doc('<STR_LIT>')<EOL>giTable = sportsref.utils.parse_info_table(table)<EOL>if '<STR_LIT>' in giTable:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Gets information relating to the opening coin toss.\n\n        Keys are:\n        * wonToss - contains the ID of the team that won the toss\n        * deferred - bool whether the team that won the toss deferred it\n\n        :returns: Dictionary of coin toss-related info.", "id": "f8193:c0:m20"}
{"signature": "@sportsref.decorators.memoize<EOL><INDENT>def weekday(self):<DEDENT>", "body": "days = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>']<EOL>date = self.date()<EOL>wd = date.weekday()<EOL>return days[wd]<EOL>", "docstring": "Returns the day of the week on which the game occurred.\n        :returns: String representation of the day of the week for the game.", "id": "f8193:c0:m8"}
{"signature": "@sportsref.decorators.memoize<EOL><INDENT>def away(self):<DEDENT>", "body": "doc = self.get_doc()<EOL>table = doc('<STR_LIT>')<EOL>relURL = table('<STR_LIT>').eq(<NUM_LIT:1>)('<STR_LIT:a>').eq(<NUM_LIT:2>).attr['<STR_LIT>']<EOL>away = sportsref.utils.rel_url_to_id(relURL)<EOL>return away<EOL>", "docstring": "Returns away team ID.\n        :returns: 3-character string representing away team's ID.", "id": "f8193:c0:m10"}
{"signature": "@sportsref.decorators.memoize<EOL><INDENT>def opp_stats(self, year):<DEDENT>", "body": "doc = self.get_year_doc(year)<EOL>table = doc('<STR_LIT>')<EOL>df = sportsref.utils.parse_table(table)<EOL>return df.loc[df.player_id == '<STR_LIT>'].iloc[<NUM_LIT:0>]<EOL>", "docstring": "Returns a Series (dict-like) of the team's opponent's stats from the\n        team-season page.\n\n        :year: Int representing the season.\n        :returns: A Series of team stats.", "id": "f8195:c0:m24"}
{"signature": "@sportsref.decorators.memoize<EOL><INDENT>def team_stats(self, year):<DEDENT>", "body": "doc = self.get_year_doc(year)<EOL>table = doc('<STR_LIT>')<EOL>df = sportsref.utils.parse_table(table)<EOL>if df.empty:<EOL><INDENT>return pd.Series()<EOL><DEDENT>return df.loc[df.player_id == '<STR_LIT>'].iloc[<NUM_LIT:0>]<EOL>", "docstring": "Returns a Series (dict-like) of team stats from the team-season\n        page.\n\n        :year: Int representing the season.\n        :returns: A Series of team stats.", "id": "f8195:c0:m23"}
{"signature": "@sportsref.decorators.memoize<EOL>def team_ids(year):", "body": "names = team_names(year)<EOL>return {v: k for k, v in names.items()}<EOL>", "docstring": "Returns a mapping from team name to team ID for a given season. Inverse\n    mapping of team_names. Example of a full team name: \"New England Patriots\"\n\n    :year: The year of the season in question (as an int).\n    :returns: A dictionary with full team name keys and teamID values.", "id": "f8195:m1"}
{"signature": "@sportsref.decorators.memoize<EOL><INDENT>def stadium(self, year):<DEDENT>", "body": "anchor = self._year_info_pq(year, '<STR_LIT>')('<STR_LIT:a>')<EOL>return sportsref.utils.rel_url_to_id(anchor.attr['<STR_LIT>'])<EOL>", "docstring": "Returns the ID for the stadium in which the team played in a given\n        year.\n\n        :year: The year in question.\n        :returns: A string representing the stadium ID.", "id": "f8195:c0:m20"}
{"signature": "@sportsref.decorators.memoize<EOL><INDENT>def schedule(self, year):<DEDENT>", "body": "doc = self.get_year_doc(year)<EOL>table = doc('<STR_LIT>')<EOL>df = sportsref.utils.parse_table(table)<EOL>if df.empty:<EOL><INDENT>return pd.DataFrame()<EOL><DEDENT>df = df.loc[df['<STR_LIT>'].notnull()]<EOL>df['<STR_LIT>'] = np.arange(len(df)) + <NUM_LIT:1><EOL>df['<STR_LIT>'] = df['<STR_LIT>'] == '<STR_LIT>'<EOL>df['<STR_LIT>'] = df['<STR_LIT>'] == '<STR_LIT:L>'<EOL>df['<STR_LIT>'] = df['<STR_LIT>'] == '<STR_LIT:T>'<EOL>df['<STR_LIT>'] = df['<STR_LIT>'].isnull()<EOL>df['<STR_LIT>'] = df['<STR_LIT>'].notnull()<EOL>return df<EOL>", "docstring": "Returns a DataFrame with schedule information for the given year.\n\n        :year: The year for the season in question.\n        :returns: Pandas DataFrame with schedule information.", "id": "f8195:c0:m15"}
{"signature": "@sportsref.decorators.memoize<EOL><INDENT>def boxscores(self, year):<DEDENT>", "body": "doc = self.get_year_doc(year)<EOL>table = doc('<STR_LIT>')<EOL>df = sportsref.utils.parse_table(table)<EOL>if df.empty:<EOL><INDENT>return np.array([])<EOL><DEDENT>return df.boxscore_id.values<EOL>", "docstring": "Gets list of BoxScore objects corresponding to the box scores from\n        that year.\n\n        :year: The year for which we want the boxscores; defaults to current\n        year.\n        :returns: np.array of strings representing boxscore IDs.", "id": "f8195:c0:m11"}
{"signature": "@sportsref.decorators.memoize<EOL><INDENT>def def_splits(self, year):<DEDENT>", "body": "doc = self.get_year_doc('<STR_LIT>'.format(year))<EOL>tables = doc('<STR_LIT>')<EOL>dfs = [sportsref.utils.parse_table(table) for table in tables.items()]<EOL>dfs = [<EOL>df.assign(split=df.columns[<NUM_LIT:0>])<EOL>.rename(columns={df.columns[<NUM_LIT:0>]: '<STR_LIT>'})<EOL>for df in dfs<EOL>]<EOL>if not dfs:<EOL><INDENT>return pd.DataFrame()<EOL><DEDENT>return pd.concat(dfs).reset_index(drop=True)<EOL>", "docstring": "Returns a DataFrame of defensive team splits (i.e. opponent splits)\n        for a season.\n\n        :year: int representing the season.\n        :returns: Pandas DataFrame of split data.", "id": "f8195:c0:m28"}
{"signature": "@sportsref.decorators.cache<EOL>def get_html(url):", "body": "global last_request_time<EOL>with throttle_process_lock:<EOL><INDENT>with throttle_thread_lock:<EOL><INDENT>wait_left = THROTTLE_DELAY - (time.time() - last_request_time.value)<EOL>if wait_left > <NUM_LIT:0>:<EOL><INDENT>time.sleep(wait_left)<EOL><DEDENT>response = requests.get(url)<EOL>last_request_time.value = time.time()<EOL><DEDENT><DEDENT>if <NUM_LIT> <= response.status_code < <NUM_LIT>:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>.format(response.status_code, url)<EOL>)<EOL><DEDENT>html = response.text<EOL>html = html.replace('<STR_LIT>', '<STR_LIT>').replace('<STR_LIT>', '<STR_LIT>')<EOL>return html<EOL>", "docstring": "Gets the HTML for the given URL using a GET request.\n\n    :url: the absolute URL of the desired page.\n    :returns: a string of HTML.", "id": "f8197:m0"}
{"signature": "def memoize(fun):", "body": "@funcutils.wraps(fun)<EOL>def wrapper(*args, **kwargs):<EOL><INDENT>do_memoization = sportsref.get_option('<STR_LIT>')<EOL>if not do_memoization:<EOL><INDENT>return fun(*args, **kwargs)<EOL><DEDENT>hash_args = tuple(args)<EOL>hash_kwargs = frozenset(sorted(kwargs.items()))<EOL>key = (hash_args, hash_kwargs)<EOL>def _copy(v):<EOL><INDENT>if isinstance(v, pq):<EOL><INDENT>return v.clone()<EOL><DEDENT>else:<EOL><INDENT>return copy.deepcopy(v)<EOL><DEDENT><DEDENT>try:<EOL><INDENT>ret = _copy(cache[key])<EOL>return ret<EOL><DEDENT>except KeyError:<EOL><INDENT>cache[key] = fun(*args, **kwargs)<EOL>ret = _copy(cache[key])<EOL>return ret<EOL><DEDENT>except TypeError:<EOL><INDENT>print('<STR_LIT>'<EOL>.format(fun.__name__, key))<EOL>raise<EOL><DEDENT><DEDENT>cache = {}<EOL>return wrapper<EOL>", "docstring": "A decorator for memoizing functions.\n\n    Only works on functions that take simple arguments - arguments that take\n    list-like or dict-like arguments will not be memoized, and this function\n    will raise a TypeError.", "id": "f8198:m6"}
{"signature": "def _read_ready(self):", "body": "try:<EOL><INDENT>data = os.read(self._fileno, self.max_size)<EOL><DEDENT>except InterruptedError:<EOL><INDENT>pass<EOL><DEDENT>except OSError as exc:<EOL><INDENT>self._fatal_error(exc, \"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>if data:<EOL><INDENT>self._protocol.data_received(data)<EOL><DEDENT>else:<EOL><INDENT>if self._loop.get_debug():<EOL><INDENT>logger.info(\"<STR_LIT>\", self)<EOL><DEDENT>self._closing = False<EOL>self.pause_reading()<EOL>self._loop.call_soon(self._protocol.eof_received)<EOL>self._loop.call_soon(self._call_connection_lost, None)<EOL><DEDENT><DEDENT>", "docstring": "Called by the event loop whenever the fd is ready for reading.", "id": "f8208:c0:m2"}
{"signature": "@asyncio.coroutine<EOL>def stream_from_fd(fd, loop):", "body": "reader = asyncio.StreamReader(loop=loop)<EOL>protocol = asyncio.StreamReaderProtocol(reader, loop=loop)<EOL>waiter = asyncio.futures.Future(loop=loop)<EOL>transport = UnixFileDescriptorTransport(<EOL>loop=loop,<EOL>fileno=fd,<EOL>protocol=protocol,<EOL>waiter=waiter,<EOL>)<EOL>try:<EOL><INDENT>yield from waiter<EOL><DEDENT>except Exception:<EOL><INDENT>transport.close()<EOL><DEDENT>if loop.get_debug():<EOL><INDENT>logger.debug(\"<STR_LIT>\", fd, transport, protocol)<EOL><DEDENT>return reader, transport<EOL>", "docstring": "Recieve a streamer for a given file descriptor.", "id": "f8208:m0"}
{"signature": "def pause_reading(self):", "body": "self._loop.remove_reader(self._fileno)<EOL>self._active = False<EOL>", "docstring": "Public API: pause reading the transport.", "id": "f8208:c0:m3"}
{"signature": "def close(self):", "body": "if not self._closing:<EOL><INDENT>self._close()<EOL><DEDENT>", "docstring": "Public API: close the transport.", "id": "f8208:c0:m5"}
{"signature": "def setUp(self):", "body": "PyFunceble.INTERN[\"<STR_LIT>\"] = \"<STR_LIT>\"<EOL>self.file = (<EOL>PyFunceble.CURRENT_DIRECTORY<EOL>+ PyFunceble.OUTPUTS[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>)<EOL>self.expected_content = {<EOL>PyFunceble.INTERN[\"<STR_LIT>\"]: {<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:state>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:state>\": \"<STR_LIT>\",<EOL>},<EOL>}<EOL>}<EOL>", "docstring": "Setup everything needed for the test", "id": "f8209:c1:m0"}
{"signature": "def setUp(self):", "body": "self.data_list = [<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT:hello>\",<EOL>]<EOL>self.data_list_url = [<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>]<EOL>load_config(True)<EOL>", "docstring": "Setup everything needed for the tests.", "id": "f8211:c0:m0"}
{"signature": "def setUp(self):", "body": "PyFunceble.load_config(True)<EOL>self.valid_domain = [<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>]<EOL>self.not_valid_domain = [<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT:..>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>]<EOL>", "docstring": "Setup what we need for the tests.", "id": "f8212:c0:m0"}
{"signature": "def setUp(self):", "body": "self.to_test = {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": {\"<STR_LIT>\", \"<STR_LIT:hello>\"},<EOL>\"<STR_LIT>\": [\"<STR_LIT>\", \"<STR_LIT>\"],<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": [\"<STR_LIT>\"],<EOL>}<EOL>", "docstring": "Setup everything needed for the tests.", "id": "f8221:c3:m0"}
{"signature": "def setUp(self):", "body": "PyFunceble.initiate(True)<EOL>PyFunceble.load_config(True)<EOL>BaseStdout.setUp(self)<EOL>logo =", "docstring": "Setup everything needed.", "id": "f8222:c1:m0"}
{"signature": "def setUp(self):", "body": "PyFunceble.load_config(True)<EOL>self.domains = [<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>]<EOL>", "docstring": "Setup everything that is needed for the tests.", "id": "f8222:c2:m0"}
{"signature": "def setUp(self):", "body": "PyFunceble.load_config(True)<EOL>self.file = \"<STR_LIT>\"<EOL>self.to_print = {<EOL>\"<STR_LIT>\": {\"<STR_LIT:hello>\": <NUM_LIT:5>, \"<STR_LIT>\": <NUM_LIT:6>, \"<STR_LIT>\": <NUM_LIT:7>, \"<STR_LIT>\": <NUM_LIT:8>, \"<STR_LIT>\": <NUM_LIT:10>},<EOL>\"<STR_LIT>\": [<NUM_LIT:5>, <NUM_LIT:6>, <NUM_LIT:7>, <NUM_LIT:8>, <NUM_LIT:9>, <NUM_LIT:10>],<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": {\"<STR_LIT>\": <NUM_LIT:7>, \"<STR_LIT>\": <NUM_LIT:11>},<EOL>}<EOL>", "docstring": "Setup everything needed for the tests.", "id": "f8224:c0:m0"}
{"signature": "def load(self):", "body": "if \"<STR_LIT>\" not in PyFunceble.INTERN or not PyFunceble.INTERN[\"<STR_LIT>\"]:<EOL><INDENT>PyFunceble.INTERN[\"<STR_LIT>\"] = self.iana_db<EOL><DEDENT>", "docstring": "Initiate the IANA database if it is not the case.", "id": "f8225:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def _install_directory_structure_file(cls):<DEDENT>", "body": "<EOL>dir_structure_link = PyFunceble.CONFIGURATION[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>dir_structure_link = Version(True).right_url_from_version(dir_structure_link)<EOL>destination = (<EOL>PyFunceble.CURRENT_DIRECTORY<EOL>+ PyFunceble.CONFIGURATION[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>)<EOL>if not Version(True).is_cloned() or not PyFunceble.path.isfile(destination):<EOL><INDENT>data = Download(dir_structure_link, destination, return_data=True).text()<EOL>File(destination).write(data, overwrite=True)<EOL>return True<EOL><DEDENT>return None<EOL>", "docstring": "Download the latest version of `dir_structure_production.json`.", "id": "f8227:c0:m6"}
{"signature": "@classmethod<EOL><INDENT>def check_versions_literally(cls, local, upstream):<DEDENT>", "body": "return local == upstream<EOL>", "docstring": "Compare the given versions literally.\n\n:param local: The local version converted by split_versions().\n:type local: str\n\n:param upstream: The upstream version converted by split_versions().\n:type upstream: str\n\n:return:\n    - True: local == upstream\n    - False: local != upstream\n:rtype: bool", "id": "f8227:c2:m2"}
{"signature": "@classmethod<EOL><INDENT>def is_cloned(cls):<DEDENT>", "body": "if not PyFunceble.path.isdir(\"<STR_LIT>\"):<EOL><INDENT>return False<EOL><DEDENT>list_of_file = [<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>]<EOL>list_of_dir = [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]<EOL>for file in list_of_file:<EOL><INDENT>if not PyFunceble.path.isfile(file):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>for directory in list_of_dir:<EOL><INDENT>if not PyFunceble.path.isdir(directory):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Let us know if we are currently in the cloned version of\nPyFunceble which implicitly mean that we are in developement mode.", "id": "f8227:c2:m5"}
{"signature": "@classmethod<EOL><INDENT>def right_url_from_version(cls, url):<DEDENT>", "body": "if \"<STR_LIT>\" in PyFunceble.VERSION:<EOL><INDENT>return url.replace(\"<STR_LIT>\", \"<STR_LIT>\")<EOL><DEDENT>return url.replace(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>", "docstring": "Convert the GitHub URL to the right one depending of the\nbranch or version we are working with.\n\n:param url: The URL to convert.\n:type url: str\n\n:return: The converted URL.\n:rtype: str", "id": "f8227:c2:m6"}
{"signature": "def compare(self):", "body": "if self.upstream_data[\"<STR_LIT>\"][\"<STR_LIT:status>\"]:<EOL><INDENT>for minimal in self.upstream_data[\"<STR_LIT>\"][\"<STR_LIT>\"]:<EOL><INDENT>checked = self.check_versions(<EOL>self.local_splited, self.split_versions(minimal)<EOL>)<EOL>if not PyFunceble.CONFIGURATION[\"<STR_LIT>\"]:<EOL><INDENT>if checked or checked is not False and not checked:<EOL><INDENT>message = (<EOL>PyFunceble.Style.BRIGHT<EOL>+ PyFunceble.Fore.RED<EOL>+ \"<STR_LIT>\"<EOL>+ PyFunceble.Style.RESET_ALL<EOL>)  <EOL>message += (<EOL>PyFunceble.Style.BRIGHT<EOL>+ PyFunceble.Fore.GREEN<EOL>+ \"<STR_LIT>\"<EOL>+ PyFunceble.Style.RESET_ALL<EOL>)  <EOL>print(message)<EOL>exit(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>elif checked or checked is not False and not checked:<EOL><INDENT>raise Exception(<EOL>\"<STR_LIT>\"  <EOL>)<EOL><DEDENT><DEDENT><DEDENT>for version in self.upstream_data[\"<STR_LIT>\"]:<EOL><INDENT>checked = self.check_versions(<EOL>self.local_splited, self.split_versions(version)<EOL>)<EOL>if (<EOL>not PyFunceble.CONFIGURATION[\"<STR_LIT>\"]<EOL>and checked<EOL>or checked is not False<EOL>and not checked<EOL>):<EOL><INDENT>message = (<EOL>PyFunceble.Style.BRIGHT<EOL>+ PyFunceble.Fore.RED<EOL>+ \"<STR_LIT>\"<EOL>+ PyFunceble.Style.RESET_ALL<EOL>)  <EOL>message += (<EOL>PyFunceble.Style.BRIGHT<EOL>+ PyFunceble.Fore.GREEN<EOL>+ \"<STR_LIT>\"<EOL>+ PyFunceble.Style.RESET_ALL<EOL>)  <EOL>print(message)<EOL>return<EOL><DEDENT>if checked or checked is not False and not checked:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return<EOL><DEDENT><DEDENT>status = self.check_versions(<EOL>self.local_splited,<EOL>self.split_versions(self.upstream_data[\"<STR_LIT>\"]),<EOL>)<EOL>if status is not None and not status and not PyFunceble.CONFIGURATION[\"<STR_LIT>\"]:<EOL><INDENT>message = (<EOL>PyFunceble.Style.BRIGHT<EOL>+ PyFunceble.Fore.CYAN<EOL>+ \"<STR_LIT>\"  <EOL>+ PyFunceble.Style.RESET_ALL<EOL>)<EOL>message += (<EOL>PyFunceble.Style.BRIGHT<EOL>+ \"<STR_LIT>\"<EOL>+ PyFunceble.Style.RESET_ALL<EOL>+ PyFunceble.VERSION<EOL>+ \"<STR_LIT:\\n>\"<EOL>)<EOL>message += (<EOL>PyFunceble.Style.BRIGHT<EOL>+ \"<STR_LIT>\"<EOL>+ PyFunceble.Style.RESET_ALL<EOL>+ self.upstream_data[\"<STR_LIT>\"]<EOL>+ \"<STR_LIT:\\n>\"<EOL>)<EOL>print(message)<EOL><DEDENT>elif status:<EOL><INDENT>if not PyFunceble.CONFIGURATION[\"<STR_LIT>\"]:<EOL><INDENT>message = (<EOL>PyFunceble.Style.BRIGHT<EOL>+ PyFunceble.Fore.YELLOW<EOL>+ \"<STR_LIT>\"<EOL>+ PyFunceble.Style.RESET_ALL<EOL>)  <EOL>message += (<EOL>PyFunceble.Style.BRIGHT<EOL>+ \"<STR_LIT>\"<EOL>+ PyFunceble.Style.RESET_ALL<EOL>+ PyFunceble.VERSION<EOL>+ \"<STR_LIT:\\n>\"<EOL>)  <EOL>message += (<EOL>PyFunceble.Style.BRIGHT<EOL>+ \"<STR_LIT>\"<EOL>+ PyFunceble.Style.RESET_ALL<EOL>+ self.upstream_data[  <EOL>\"<STR_LIT>\"<EOL>]<EOL>+ \"<STR_LIT:\\n>\"<EOL>)<EOL>print(message)<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>return<EOL>", "docstring": "Compare the current version with the upstream saved version.", "id": "f8227:c2:m4"}
{"signature": "def header(<EOL>self, do_not_print=False<EOL>):  ", "body": "if (<EOL>not PyFunceble.CONFIGURATION[\"<STR_LIT>\"]<EOL>or self.template == \"<STR_LIT>\"<EOL>or do_not_print<EOL>):<EOL><INDENT>if (<EOL>self.template.lower() in PyFunceble.STATUS[\"<STR_LIT:list>\"][\"<STR_LIT>\"]<EOL>or self.template == \"<STR_LIT>\"<EOL>):<EOL><INDENT>to_print = self.headers[\"<STR_LIT>\"]<EOL>if (<EOL>self.template.lower() in PyFunceble.STATUS[\"<STR_LIT:list>\"][\"<STR_LIT>\"]<EOL>and PyFunceble.HTTP_CODE[\"<STR_LIT>\"]<EOL>):<EOL><INDENT>to_print = Dict(to_print).remove_key(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>elif self.template.lower() in PyFunceble.STATUS[\"<STR_LIT:list>\"][\"<STR_LIT>\"]:<EOL><INDENT>to_print = self.headers[PyFunceble.STATUS[\"<STR_LIT>\"][\"<STR_LIT>\"]]<EOL><DEDENT>elif self.template.lower() in PyFunceble.STATUS[\"<STR_LIT:list>\"][\"<STR_LIT>\"]:<EOL><INDENT>to_print = self.headers[PyFunceble.STATUS[\"<STR_LIT>\"][\"<STR_LIT>\"]]<EOL><DEDENT>elif self.template.lower() in PyFunceble.STATUS[\"<STR_LIT:list>\"][\"<STR_LIT>\"]:<EOL><INDENT>to_print = self.headers[PyFunceble.STATUS[\"<STR_LIT>\"][\"<STR_LIT>\"]]<EOL><DEDENT>elif self.template.lower() in PyFunceble.STATUS[\"<STR_LIT:list>\"][\"<STR_LIT>\"]:<EOL><INDENT>to_print = self.headers[PyFunceble.STATUS[\"<STR_LIT>\"][\"<STR_LIT>\"]]<EOL><DEDENT>elif (<EOL>self.template == \"<STR_LIT>\"<EOL>or self.template == \"<STR_LIT>\"<EOL>or self.template == \"<STR_LIT>\"<EOL>):  <EOL><INDENT>to_print = self.headers[self.template]<EOL>if self.template == \"<STR_LIT>\" and not PyFunceble.HTTP_CODE[\"<STR_LIT>\"]:<EOL><INDENT>to_print[\"<STR_LIT>\"] = <NUM_LIT:10><EOL><DEDENT><DEDENT>if not PyFunceble.HTTP_CODE[\"<STR_LIT>\"]:<EOL><INDENT>to_print = Dict(to_print).remove_key(\"<STR_LIT>\")<EOL><DEDENT>self.currently_used_header = to_print<EOL>if not do_not_print:<EOL><INDENT>self._before_header()<EOL>for formatted_template in self._header_constructor(to_print):<EOL><INDENT>if not self.only_on_file:<EOL><INDENT>print(formatted_template)<EOL><DEDENT>if not PyFunceble.CONFIGURATION[\"<STR_LIT>\"] and self.output:<EOL><INDENT>File(self.output).write(formatted_template + \"<STR_LIT:\\n>\")<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Management and creation of templates of header.\nPlease consider as \"header\" the title of each columns.\n\n:param do_not_print:\n    Tell us if we have to print the header or not.\n:type do_not_print: bool", "id": "f8228:c0:m3"}
{"signature": "def data(self):  ", "body": "if isinstance(self.data_to_print, list):<EOL><INDENT>to_print = {}<EOL>to_print_size = []<EOL>alone_cases = [\"<STR_LIT>\", \"<STR_LIT>\"]<EOL>without_header = [\"<STR_LIT>\", \"<STR_LIT>\"]<EOL>if self.template.lower() == \"<STR_LIT>\":<EOL><INDENT>if not PyFunceble.CONFIGURATION[\"<STR_LIT>\"] and self.output:<EOL><INDENT>return self._json_print()<EOL><DEDENT>return None<EOL><DEDENT>if self.template not in alone_cases and self.template not in without_header:<EOL><INDENT>self.header(True)<EOL>to_print_size = self._size_from_header(self.currently_used_header)<EOL><DEDENT>elif self.template in without_header:<EOL><INDENT>for data in self.data_to_print:<EOL><INDENT>to_print_size.append(str(len(data)))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>to_print_size = self._size_from_header(self.headers[self.template])<EOL><DEDENT>to_print = self._data_constructor(to_print_size)<EOL>self._before_header()<EOL>for data in self._header_constructor(to_print, False):<EOL><INDENT>if self.template.lower() in PyFunceble.STATUS[\"<STR_LIT:list>\"][<EOL>\"<STR_LIT>\"<EOL>] or self.template in [\"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>if not self.only_on_file:<EOL><INDENT>colorified_data = self._colorify(data)<EOL>print(colorified_data)<EOL><DEDENT><DEDENT>if not PyFunceble.CONFIGURATION[\"<STR_LIT>\"] and self.output:<EOL><INDENT>File(self.output).write(data + \"<STR_LIT:\\n>\")<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Management and input of data to the table.\n\n:raises:\n    :code:`Exception`\n        When self.data_to_print is not a list.", "id": "f8228:c0:m8"}
{"signature": "@classmethod<EOL><INDENT>def file_to_delete(cls):<DEDENT>", "body": "<EOL>directory = PyFunceble.OUTPUT_DIRECTORY + PyFunceble.OUTPUTS[\"<STR_LIT>\"]<EOL>if not directory.endswith(PyFunceble.directory_separator):  <EOL><INDENT>directory += PyFunceble.directory_separator<EOL><DEDENT>result = []<EOL>for root, _, files in PyFunceble.walk(directory):<EOL><INDENT>for file in files:<EOL><INDENT>if file not in [\"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>if root.endswith(PyFunceble.directory_separator):<EOL><INDENT>result.append(root + file)<EOL><DEDENT>else:<EOL><INDENT>result.append(<EOL>root + PyFunceble.directory_separator + file<EOL>)  <EOL><DEDENT><DEDENT><DEDENT><DEDENT>return result<EOL>", "docstring": "Return the list of file to delete.", "id": "f8229:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def databases_to_delete(cls):  <DEDENT>", "body": "<EOL>directory = PyFunceble.CURRENT_DIRECTORY<EOL>result = []<EOL>result.append(<EOL>directory<EOL>+ PyFunceble.CONFIGURATION[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>)<EOL>result.append(<EOL>directory + PyFunceble.CONFIGURATION[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>)<EOL>result.append(<EOL>directory<EOL>+ PyFunceble.CONFIGURATION[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>)<EOL>result.append(<EOL>directory<EOL>+ PyFunceble.CONFIGURATION[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>)<EOL>result.append(<EOL>directory + PyFunceble.CONFIGURATION[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>)<EOL>result.append(<EOL>directory + PyFunceble.CONFIGURATION[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>)<EOL>return result<EOL>", "docstring": "Set the databases files to delete.", "id": "f8229:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def _calculate(cls):<DEDENT>", "body": "<EOL>percentages = {<EOL>\"<STR_LIT>\": PyFunceble.INTERN[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": PyFunceble.INTERN[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": PyFunceble.INTERN[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>}<EOL>for percentage in percentages:<EOL><INDENT>calculation = (<EOL>percentages[percentage]<EOL>* <NUM_LIT:100><EOL>// PyFunceble.INTERN[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>)<EOL>PyFunceble.INTERN[\"<STR_LIT>\"][\"<STR_LIT>\"].update({percentage: calculation})<EOL><DEDENT>", "docstring": "Calculate the percentage of each status.", "id": "f8230:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def travis_permissions(cls):<DEDENT>", "body": "if PyFunceble.CONFIGURATION[\"<STR_LIT>\"]:<EOL><INDENT>try:<EOL><INDENT>build_dir = PyFunceble.environ[\"<STR_LIT>\"]<EOL>commands = [<EOL>\"<STR_LIT>\" % (build_dir),<EOL>\"<STR_LIT>\" % (build_dir),<EOL>\"<STR_LIT>\" % (build_dir),<EOL>\"<STR_LIT>\"<EOL>% (build_dir + PyFunceble.directory_separator),<EOL>r\"<STR_LIT>\" % (build_dir),<EOL>]<EOL>for command in commands:<EOL><INDENT>Command(command).execute()<EOL><DEDENT>if Command(\"<STR_LIT>\").execute() == \"<STR_LIT>\":<EOL><INDENT>Command(\"<STR_LIT>\").execute()<EOL><DEDENT><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>", "docstring": "Set permissions in order to avoid issues before commiting.", "id": "f8231:c0:m1"}
{"signature": "def _travis(self):", "body": "if PyFunceble.CONFIGURATION[\"<STR_LIT>\"]:<EOL><INDENT>try:<EOL><INDENT>_ = PyFunceble.environ[\"<STR_LIT>\"]<EOL>time_autorisation = False<EOL>try:<EOL><INDENT>time_autorisation = int(PyFunceble.time()) >= int(<EOL>PyFunceble.INTERN[\"<STR_LIT:start>\"]<EOL>) + (int(PyFunceble.CONFIGURATION[\"<STR_LIT>\"]) * <NUM_LIT>)<EOL><DEDENT>except KeyError:<EOL><INDENT>if self.last and not self.bypass:<EOL><INDENT>raise Exception(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT><DEDENT>if self.last or time_autorisation or self.bypass:<EOL><INDENT>Percentage().log()<EOL>self.travis_permissions()<EOL>command = '<STR_LIT>'<EOL>if self.last or self.bypass:<EOL><INDENT>if PyFunceble.CONFIGURATION[\"<STR_LIT>\"]:<EOL><INDENT>for line in Command(<EOL>PyFunceble.CONFIGURATION[\"<STR_LIT>\"]<EOL>).run():<EOL><INDENT>sys_stdout.write(\"<STR_LIT>\".format(line))<EOL><DEDENT>self.travis_permissions()<EOL><DEDENT>message = (<EOL>PyFunceble.CONFIGURATION[\"<STR_LIT>\"]<EOL>+ \"<STR_LIT>\"<EOL>)<EOL>Command(command % message).execute()<EOL><DEDENT>else:<EOL><INDENT>if PyFunceble.CONFIGURATION[\"<STR_LIT>\"]:<EOL><INDENT>for line in Command(<EOL>PyFunceble.CONFIGURATION[\"<STR_LIT>\"]<EOL>).run():<EOL><INDENT>sys_stdout.write(\"<STR_LIT>\".format(line))<EOL><DEDENT>self.travis_permissions()<EOL><DEDENT>Command(<EOL>command % PyFunceble.CONFIGURATION[\"<STR_LIT>\"]<EOL>).execute()<EOL><DEDENT>print(<EOL>Command(<EOL>\"<STR_LIT>\"<EOL>% PyFunceble.CONFIGURATION[\"<STR_LIT>\"]<EOL>).execute()<EOL>)<EOL>exit(<NUM_LIT:0>)<EOL><DEDENT><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>", "docstring": "Logic behind autosave under Travis CI.", "id": "f8231:c0:m2"}
{"signature": "def analytic_file(self, new_status, old_status=None):", "body": "if not old_status:<EOL><INDENT>old_status = self.domain_status<EOL><DEDENT>if \"<STR_LIT>\" in PyFunceble.INTERN and PyFunceble.INTERN[\"<STR_LIT>\"]:<EOL><INDENT>output = (<EOL>self.output_parent_dir<EOL>+ PyFunceble.OUTPUTS[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>+ \"<STR_LIT>\"<EOL>)<EOL>if new_status.lower() in PyFunceble.STATUS[\"<STR_LIT:list>\"][\"<STR_LIT>\"]:<EOL><INDENT>output = output % (<EOL>PyFunceble.OUTPUTS[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>PyFunceble.OUTPUTS[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>)<EOL>Generate(\"<STR_LIT>\").info_files()<EOL><DEDENT>elif new_status.lower() in PyFunceble.STATUS[\"<STR_LIT:list>\"][\"<STR_LIT>\"]:<EOL><INDENT>output = output % (<EOL>PyFunceble.OUTPUTS[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>PyFunceble.OUTPUTS[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>)<EOL>Generate(\"<STR_LIT>\").info_files()<EOL><DEDENT>elif new_status.lower() in PyFunceble.STATUS[\"<STR_LIT:list>\"][\"<STR_LIT>\"]:<EOL><INDENT>output = output % (<EOL>PyFunceble.OUTPUTS[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>PyFunceble.OUTPUTS[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>)<EOL>Generate(\"<STR_LIT>\").info_files()<EOL><DEDENT>else:<EOL><INDENT>output = output % (<EOL>PyFunceble.OUTPUTS[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>PyFunceble.OUTPUTS[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>)<EOL>Generate(\"<STR_LIT>\").info_files()<EOL><DEDENT>Prints(<EOL>[<EOL>self.tested,<EOL>old_status,<EOL>PyFunceble.INTERN[\"<STR_LIT>\"],<EOL>PyFunceble.CURRENT_TIME,<EOL>],<EOL>\"<STR_LIT>\",<EOL>output,<EOL>True,<EOL>).data()<EOL><DEDENT>", "docstring": "Generate :code:`Analytic/*` files based on the given old and\nnew statuses.\n\n:param new_status: The new status of the domain.\n:type new_status: str\n\n:param old_status: The old status of the domain.\n:type old_status: str", "id": "f8232:c0:m5"}
{"signature": "def _prints_status_file(self):  ", "body": "if PyFunceble.INTERN[\"<STR_LIT>\"]:<EOL><INDENT>output = (<EOL>self.output_parent_dir<EOL>+ PyFunceble.OUTPUTS[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>+ self.domain_status<EOL>)<EOL>if PyFunceble.CONFIGURATION[\"<STR_LIT>\"]:<EOL><INDENT>Prints(<EOL>[self.tested, self.domain_status, self.source], \"<STR_LIT>\", output, True<EOL>).data()<EOL><DEDENT>elif PyFunceble.CONFIGURATION[\"<STR_LIT>\"]:<EOL><INDENT>if self.domain_status.lower() in PyFunceble.STATUS[\"<STR_LIT:list>\"][\"<STR_LIT>\"]:<EOL><INDENT>if PyFunceble.HTTP_CODE[\"<STR_LIT>\"]:<EOL><INDENT>data_to_print = [<EOL>self.tested,<EOL>self.expiration_date,<EOL>self.source,<EOL>PyFunceble.INTERN[\"<STR_LIT>\"],<EOL>PyFunceble.CURRENT_TIME,<EOL>]<EOL><DEDENT>else:<EOL><INDENT>data_to_print = [<EOL>self.tested,<EOL>self.expiration_date,<EOL>self.source,<EOL>PyFunceble.CURRENT_TIME,<EOL>]<EOL><DEDENT>Prints(<EOL>data_to_print, PyFunceble.STATUS[\"<STR_LIT>\"][\"<STR_LIT>\"], output, True<EOL>).data()<EOL><DEDENT>elif self.domain_status.lower() in PyFunceble.STATUS[\"<STR_LIT:list>\"][\"<STR_LIT>\"]:<EOL><INDENT>data_to_print = [self.tested, self.source, PyFunceble.CURRENT_TIME]<EOL>Prints(<EOL>data_to_print,<EOL>PyFunceble.STATUS[\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>output,<EOL>True,<EOL>).data()<EOL><DEDENT>elif self.domain_status.lower() in PyFunceble.STATUS[\"<STR_LIT:list>\"][\"<STR_LIT>\"]:<EOL><INDENT>if PyFunceble.HTTP_CODE[\"<STR_LIT>\"]:<EOL><INDENT>data_to_print = [<EOL>self.tested,<EOL>PyFunceble.INTERN[\"<STR_LIT>\"],<EOL>self.domain_status,<EOL>self.source,<EOL>PyFunceble.INTERN[\"<STR_LIT>\"],<EOL>PyFunceble.CURRENT_TIME,<EOL>]<EOL><DEDENT>else:<EOL><INDENT>data_to_print = [<EOL>self.tested,<EOL>PyFunceble.INTERN[\"<STR_LIT>\"],<EOL>self.domain_status,<EOL>self.source,<EOL>PyFunceble.CURRENT_TIME,<EOL>]<EOL><DEDENT>Prints(<EOL>data_to_print,<EOL>PyFunceble.STATUS[\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>output,<EOL>True,<EOL>).data()<EOL><DEDENT>elif self.domain_status.lower() in PyFunceble.STATUS[\"<STR_LIT:list>\"][\"<STR_LIT>\"]:<EOL><INDENT>if PyFunceble.HTTP_CODE[\"<STR_LIT>\"]:<EOL><INDENT>data_to_print = [<EOL>self.tested,<EOL>self.source,<EOL>PyFunceble.INTERN[\"<STR_LIT>\"],<EOL>PyFunceble.CURRENT_TIME,<EOL>]<EOL><DEDENT>else:<EOL><INDENT>data_to_print = [<EOL>self.tested,<EOL>self.source,<EOL>PyFunceble.CURRENT_TIME,<EOL>]<EOL><DEDENT>Prints(<EOL>data_to_print,<EOL>PyFunceble.STATUS[\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>output,<EOL>True,<EOL>).data()<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Logic behind the printing (in file) when generating status file.", "id": "f8232:c0:m6"}
{"signature": "def status_file(self):  ", "body": "if \"<STR_LIT>\" in PyFunceble.INTERN:<EOL><INDENT>Generate(self.domain_status, self.source, self.expiration_date).info_files()<EOL>Percentage(self.domain_status).count()<EOL>self._prints_status_screen()<EOL>if self._do_not_produce_file():<EOL><INDENT>return None<EOL><DEDENT>if (<EOL>not PyFunceble.CONFIGURATION[\"<STR_LIT>\"]<EOL>and PyFunceble.CONFIGURATION[\"<STR_LIT>\"]<EOL>):<EOL><INDENT>self._prints_status_file()<EOL><DEDENT>else:<EOL><INDENT>self.unified_file()<EOL><DEDENT><DEDENT>", "docstring": "Generate a file according to the domain status.", "id": "f8232:c0:m8"}
{"signature": "def _extract_base(self, element):", "body": "if isinstance(element, list):<EOL><INDENT>return [self._extract_base(x) for x in element]<EOL><DEDENT>base = self.checker.is_url_valid(url=element, return_base=True)<EOL>if base:<EOL><INDENT>return base<EOL><DEDENT>if \"<STR_LIT:/>\" in element:<EOL><INDENT>return element.split(\"<STR_LIT:/>\")[<NUM_LIT:0>]<EOL><DEDENT>return element<EOL>", "docstring": "Extract the base of the given element.\n\n.. example:\n    given \"hello/world?world=beautiful\" return \"hello\"\n\n:param element: The element we are working with.\n:type element: str|list", "id": "f8233:c0:m4"}
{"signature": "def _format_decoded(self, to_format, result=None):  ", "body": "if not result:<EOL><INDENT>result = []<EOL><DEDENT>for data in List(to_format).format():<EOL><INDENT>if data:<EOL><INDENT>if \"<STR_LIT>\" in data:<EOL><INDENT>return self._format_decoded(data.split(\"<STR_LIT>\"), result)<EOL><DEDENT>if \"<STR_LIT:#>\" in data:<EOL><INDENT>return self._format_decoded(data.split(\"<STR_LIT:#>\"), result)<EOL><DEDENT>if \"<STR_LIT:U+002C>\" in data:<EOL><INDENT>return self._format_decoded(data.split(\"<STR_LIT:U+002C>\"), result)<EOL><DEDENT>if \"<STR_LIT:!>\" in data:<EOL><INDENT>return self._format_decoded(data.split(\"<STR_LIT:!>\"), result)<EOL><DEDENT>if \"<STR_LIT:|>\" in data:<EOL><INDENT>return self._format_decoded(data.split(\"<STR_LIT:|>\"), result)<EOL><DEDENT>if data:<EOL><INDENT>data = self._extract_base(data)<EOL>if data and (<EOL>self.checker.is_domain_valid(data)<EOL>or self.checker.is_ip_valid(data)<EOL>):<EOL><INDENT>result.append(data)<EOL><DEDENT>elif data:<EOL><INDENT>url_base = self.checker.is_url_valid(data, return_base=True)<EOL>if url_base:<EOL><INDENT>result.append(url_base)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>return result<EOL>", "docstring": "Format the exctracted adblock line before passing it to the system.\n\n:param to_format: The extracted line from the file.\n:type to_format: str\n\n:param result: A list of the result of this method.\n:type result: list\n\n:return: The list of domains or IP to test.\n:rtype: list", "id": "f8233:c0:m6"}
{"signature": "def _handle_options(self, options):", "body": "<EOL>result = []<EOL>regex_domain_option = r\"<STR_LIT>\"<EOL>for option in options:<EOL><INDENT>try:<EOL><INDENT>domains = Regex(<EOL>option, regex_domain_option, return_data=True, rematch=True, group=<NUM_LIT:0><EOL>).match()[-<NUM_LIT:1>]<EOL>if domains:<EOL><INDENT>if self.aggressive:  <EOL><INDENT>result.extend(<EOL>[<EOL>x<EOL>for x in domains.split(\"<STR_LIT:|>\")<EOL>if x and not x.startswith(\"<STR_LIT>\")<EOL>]<EOL>)<EOL><DEDENT>else:<EOL><INDENT>return True<EOL><DEDENT><DEDENT><DEDENT>except TypeError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Handle the data from the options.\n\n:param options: The list of options from the rule.\n:type options: list\n\n:return: The list of domains to return globally.\n:rtype: list", "id": "f8233:c0:m3"}
{"signature": "def _remove_ignored(self, list_from_file):", "body": "return [x for x in list_from_file if not self._is_to_ignore(x)]<EOL>", "docstring": "Removed the ignored element from the given list.\n\n:param list_from_file:\n    The list which represent the file we are decoding.\n:type list_from_list: list\n\n:return: The filtered list.\n:rtype: list", "id": "f8233:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def _is_to_ignore(cls, line):<DEDENT>", "body": "<EOL>to_ignore = [r\"<STR_LIT>\"]  <EOL>for element in to_ignore:<EOL><INDENT>if Regex(line, element, return_data=False).match():<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Check if we have to ignore the given line.\n\n:param line: The line from the file.\n:type line: str", "id": "f8233:c0:m2"}
{"signature": "def _update_structure_from_config(self, structure):", "body": "<EOL>to_replace_base_map = {\"<STR_LIT>\": PyFunceble.OUTPUTS[\"<STR_LIT>\"]}<EOL>to_replace_map = {<EOL>\"<STR_LIT>\": PyFunceble.OUTPUTS[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": PyFunceble.OUTPUTS[\"<STR_LIT>\"][\"<STR_LIT>\"][<EOL>\"<STR_LIT>\"<EOL>]<EOL>+ PyFunceble.OUTPUTS[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": PyFunceble.OUTPUTS[\"<STR_LIT>\"][<EOL>\"<STR_LIT>\"<EOL>][\"<STR_LIT>\"]<EOL>+ PyFunceble.OUTPUTS[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": PyFunceble.OUTPUTS[\"<STR_LIT>\"][<EOL>\"<STR_LIT>\"<EOL>][\"<STR_LIT>\"]<EOL>+ PyFunceble.OUTPUTS[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": PyFunceble.OUTPUTS[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": PyFunceble.OUTPUTS[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>+ PyFunceble.OUTPUTS[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": PyFunceble.OUTPUTS[\"<STR_LIT>\"][<EOL>\"<STR_LIT>\"<EOL>][\"<STR_LIT>\"]<EOL>+ PyFunceble.OUTPUTS[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": PyFunceble.OUTPUTS[\"<STR_LIT>\"][<EOL>\"<STR_LIT>\"<EOL>][\"<STR_LIT>\"]<EOL>+ PyFunceble.OUTPUTS[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": PyFunceble.OUTPUTS[\"<STR_LIT>\"][\"<STR_LIT>\"][<EOL>\"<STR_LIT>\"<EOL>]<EOL>+ PyFunceble.OUTPUTS[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": PyFunceble.OUTPUTS[\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": PyFunceble.OUTPUTS[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>+ PyFunceble.STATUS[\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": PyFunceble.OUTPUTS[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>+ PyFunceble.STATUS[\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": PyFunceble.OUTPUTS[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>+ PyFunceble.STATUS[\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": PyFunceble.OUTPUTS[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>+ PyFunceble.STATUS[\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": PyFunceble.OUTPUTS[\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": PyFunceble.OUTPUTS[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>+ PyFunceble.STATUS[\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": PyFunceble.OUTPUTS[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>+ PyFunceble.STATUS[\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": PyFunceble.OUTPUTS[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>+ PyFunceble.STATUS[\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": PyFunceble.OUTPUTS[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>+ PyFunceble.STATUS[\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": PyFunceble.OUTPUTS[\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": PyFunceble.OUTPUTS[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>+ PyFunceble.STATUS[\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": PyFunceble.OUTPUTS[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>+ PyFunceble.STATUS[\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": PyFunceble.OUTPUTS[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>+ PyFunceble.STATUS[\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": PyFunceble.OUTPUTS[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>+ PyFunceble.STATUS[\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": PyFunceble.OUTPUTS[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": PyFunceble.OUTPUTS[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>+ PyFunceble.OUTPUTS[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": PyFunceble.OUTPUTS[\"<STR_LIT>\"][\"<STR_LIT>\"],<EOL>}<EOL>to_replace = {}<EOL>for mapped, declared in to_replace_map.items():<EOL><INDENT>declared = Directory(declared).fix_path()<EOL>to_replace.update({mapped: declared})<EOL><DEDENT>to_replace_base = {}<EOL>for mapped, declared in to_replace_base_map.items():<EOL><INDENT>declared = Directory(declared).fix_path()<EOL>to_replace_base.update({mapped: declared})<EOL><DEDENT>structure = Dict(structure).rename_key(to_replace_base)<EOL>structure[PyFunceble.OUTPUTS[\"<STR_LIT>\"]] = Dict(<EOL>structure[PyFunceble.OUTPUTS[\"<STR_LIT>\"]]<EOL>).rename_key(to_replace)<EOL>try:<EOL><INDENT>Dict(structure).to_json(self.structure)<EOL><DEDENT>except FileNotFoundError:<EOL><INDENT>PyFunceble.mkdir(<EOL>PyFunceble.directory_separator.join(<EOL>self.structure.split(PyFunceble.directory_separator)[:-<NUM_LIT:1>]<EOL>)<EOL>)<EOL>Dict(structure).to_json(self.structure)<EOL><DEDENT>return structure<EOL>", "docstring": "Update the paths according to configs.\n\n:param structure: The read structure.\n:type structure: dict", "id": "f8235:c0:m3"}
{"signature": "def restore(self):", "body": "<EOL>structure = self._get_structure()<EOL>list_of_key = list(structure.keys())<EOL>structure = structure[list_of_key[<NUM_LIT:0>]]<EOL>parent_path = list_of_key[<NUM_LIT:0>]<EOL>if not parent_path.endswith(PyFunceble.directory_separator):<EOL><INDENT>parent_path += PyFunceble.directory_separator<EOL><DEDENT>replacement_status = self._restore_replace()<EOL>for directory in structure:<EOL><INDENT>base = self.base + parent_path + directory<EOL>if not base.endswith(PyFunceble.directory_separator):<EOL><INDENT>base += PyFunceble.directory_separator<EOL><DEDENT>self._create_directory(base)<EOL>for file in structure[directory]:<EOL><INDENT>file_path = base + file<EOL>content_to_write = structure[directory][file][\"<STR_LIT:content>\"]<EOL>online_sha = structure[directory][file][\"<STR_LIT>\"]<EOL>content_to_write = Regex(<EOL>content_to_write, \"<STR_LIT>\", escape=True, replace_with=\"<STR_LIT>\"<EOL>).replace()<EOL>git_to_keep = file_path.replace(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>keep_to_git = file_path.replace(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>if replacement_status:<EOL><INDENT>if (<EOL>PyFunceble.path.isfile(file_path)<EOL>and Hash(file_path, \"<STR_LIT>\", True).get() == online_sha<EOL>):<EOL><INDENT>PyFunceble.rename(file_path, git_to_keep)<EOL>write = False<EOL><DEDENT>else:<EOL><INDENT>File(file_path).delete()<EOL>file_path = git_to_keep<EOL>write = True<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if (<EOL>PyFunceble.path.isfile(keep_to_git)<EOL>and Hash(file_path, \"<STR_LIT>\", True).get() == online_sha<EOL>):<EOL><INDENT>PyFunceble.rename(file_path, keep_to_git)<EOL>write = False<EOL><DEDENT>else:<EOL><INDENT>File(keep_to_git).delete()<EOL>file_path = keep_to_git<EOL>write = True<EOL><DEDENT><DEDENT>if write:<EOL><INDENT>File(file_path).write(content_to_write + \"<STR_LIT:\\n>\", True)<EOL><DEDENT><DEDENT><DEDENT>self.delete_uneeded()<EOL>", "docstring": "Restore the 'output/' directory structure based on the `dir_structure.json` file.", "id": "f8235:c0:m6"}
{"signature": "@classmethod<EOL><INDENT>def _create_directory(cls, directory, loop=False):<DEDENT>", "body": "if not loop and PyFunceble.directory_separator in directory:<EOL><INDENT>splited_directory = directory.split(PyFunceble.directory_separator)<EOL>full_path_to_create = \"<STR_LIT>\"<EOL>for single_directory in splited_directory:<EOL><INDENT>full_path_to_create += single_directory + PyFunceble.directory_separator<EOL>cls._create_directory(full_path_to_create, True)<EOL><DEDENT><DEDENT>if not PyFunceble.path.isdir(directory):<EOL><INDENT>AutoSave.travis_permissions()<EOL>PyFunceble.mkdir(directory)<EOL>AutoSave.travis_permissions()<EOL><DEDENT>", "docstring": "Creates the given directory if it does not exists.\n\n:param directory: The directory to create.\n:type directory: str\n\n:param loop: Tell us if we are in the creation loop or not.\n:type loop: bool", "id": "f8235:c0:m5"}
{"signature": "@classmethod<EOL><INDENT>def nslookup(cls):<DEDENT>", "body": "try:<EOL><INDENT>if \"<STR_LIT>\" in PyFunceble.INTERN:  <EOL><INDENT>if not Check().is_ip_valid():<EOL><INDENT>request = PyFunceble.socket.getaddrinfo(<EOL>PyFunceble.INTERN[\"<STR_LIT>\"],<EOL><NUM_LIT>,<EOL><NUM_LIT:0>,<EOL><NUM_LIT:0>,<EOL>PyFunceble.socket.IPPROTO_TCP,<EOL>)<EOL>for sequence in request:<EOL><INDENT>PyFunceble.INTERN[\"<STR_LIT>\"][\"<STR_LIT>\"].append(<EOL>sequence[-<NUM_LIT:1>][<NUM_LIT:0>]<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>request = PyFunceble.socket.gethostbyaddr(<EOL>PyFunceble.INTERN[\"<STR_LIT>\"]<EOL>)<EOL>PyFunceble.INTERN[\"<STR_LIT>\"][\"<STR_LIT>\"][<EOL>\"<STR_LIT>\"<EOL>] = request[<NUM_LIT:0>]<EOL>PyFunceble.INTERN[\"<STR_LIT>\"][\"<STR_LIT>\"][<EOL>\"<STR_LIT>\"<EOL>] = request[<NUM_LIT:1>]<EOL>PyFunceble.INTERN[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"] = request[<EOL><NUM_LIT:2><EOL>]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if not Check().is_ip_valid():<EOL><INDENT>PyFunceble.socket.getaddrinfo(<EOL>PyFunceble.INTERN[\"<STR_LIT>\"],<EOL><NUM_LIT>,<EOL><NUM_LIT:0>,<EOL><NUM_LIT:0>,<EOL>PyFunceble.socket.IPPROTO_TCP,<EOL>)<EOL><DEDENT>else:<EOL><INDENT>PyFunceble.socket.gethostbyaddr(PyFunceble.INTERN[\"<STR_LIT>\"])<EOL><DEDENT><DEDENT>return True<EOL><DEDENT>except (OSError, PyFunceble.socket.herror, PyFunceble.socket.gaierror):<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Implementation of UNIX nslookup.", "id": "f8236:c0:m0"}
{"signature": "def is_url_valid(self, url=None, return_base=False, return_formatted=False):", "body": "<EOL>initial_base = None<EOL>if url:<EOL><INDENT>to_test = url<EOL><DEDENT>elif self.element:<EOL><INDENT>to_test = self.element<EOL><DEDENT>else:<EOL><INDENT>to_test = PyFunceble.INTERN[\"<STR_LIT>\"]<EOL><DEDENT>if to_test.startswith(\"<STR_LIT:http>\"):<EOL><INDENT>try:<EOL><INDENT>regex = r\"<STR_LIT>\"<EOL>initial_base = base = Regex(<EOL>to_test, regex, return_data=True, rematch=True<EOL>).match()[<NUM_LIT:2>]<EOL>if PyFunceble.CONFIGURATION[\"<STR_LIT>\"]:<EOL><INDENT>base = domain2idna(base)<EOL><DEDENT>domain_status = self.is_domain_valid(base)<EOL>ip_status = self.is_ip_valid(base)<EOL>if domain_status or ip_status:<EOL><INDENT>if PyFunceble.CONFIGURATION[\"<STR_LIT>\"] and return_formatted:<EOL><INDENT>return Regex(<EOL>to_test,<EOL>initial_base,<EOL>escape=True,<EOL>return_data=True,<EOL>replace_with=base,<EOL>occurences=<NUM_LIT:1>,<EOL>).replace()<EOL><DEDENT>if return_formatted:<EOL><INDENT>return to_test<EOL><DEDENT>if return_base:<EOL><INDENT>return base<EOL><DEDENT>return True<EOL><DEDENT><DEDENT>except TypeError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if return_formatted:<EOL><INDENT>return to_test<EOL><DEDENT>return False<EOL>", "docstring": "Check if the given URL is valid.\n\n:param url: The url to validate.\n:type url: str\n\n:param return_base:\n    Allow us the return of the url base (if URL formatted correctly).\n:type return_formatted: bool\n\n:param return_formatted:\n    Allow us to get the URL converted to IDNA if the conversion\n    is activated.\n:type return_formatted: bool\n\n\n:return: The validity of the URL or its base.\n:rtype: bool|str", "id": "f8238:c0:m1"}
{"signature": "def run(self):", "body": "with Popen(self.command, stdout=PIPE, shell=True) as process:<EOL><INDENT>while True:<EOL><INDENT>current_line = process.stdout.readline().rstrip()<EOL>if not current_line:<EOL><INDENT>break<EOL><DEDENT>yield self._decode_output(current_line)<EOL><DEDENT><DEDENT>", "docstring": "Run the given command and yield each line(s) one by one.\n\n.. note::\n    The difference between this method and :code:`self.execute()`\n    is that :code:`self.execute()` wait for the process to end\n    in order to return its output.", "id": "f8240:c1:m3"}
{"signature": "def to_json(self, destination):", "body": "try:<EOL><INDENT>with open(destination, \"<STR_LIT:w>\") as file:<EOL><INDENT>dump(<EOL>self.main_dictionnary,<EOL>file,<EOL>ensure_ascii=False,<EOL>indent=<NUM_LIT:4>,<EOL>sort_keys=True,<EOL>)<EOL><DEDENT><DEDENT>except UnicodeEncodeError:  <EOL><INDENT>with open(destination, \"<STR_LIT:w>\", encoding=\"<STR_LIT:utf-8>\") as file:<EOL><INDENT>dump(<EOL>self.main_dictionnary,<EOL>file,<EOL>ensure_ascii=False,<EOL>indent=<NUM_LIT:4>,<EOL>sort_keys=True,<EOL>)<EOL><DEDENT><DEDENT>", "docstring": "Save a dictionnary into a JSON file.\n\n:param destination:\n    A path to a file where we're going to\n    write the converted dict into a JSON format.\n:type destination: str", "id": "f8240:c2:m4"}
{"signature": "def get(self):", "body": "<EOL>result = {}<EOL>if self.algorithm in self.valid_algorithms:<EOL><INDENT>if self.algorithm == \"<STR_LIT:all>\":<EOL><INDENT>del self.valid_algorithms[<NUM_LIT:0>]<EOL>for algo in self.valid_algorithms:<EOL><INDENT>if self.path and path.isfile(self.path):<EOL><INDENT>result[algo] = self._hash_file(algo)<EOL><DEDENT>elif self.data:<EOL><INDENT>result[algo] = self._hash_data(algo)<EOL><DEDENT>else:  <EOL><INDENT>return None<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if self.path and path.isfile(self.path):<EOL><INDENT>result[self.algorithm] = self._hash_file(self.algorithm)<EOL><DEDENT>elif self.data:<EOL><INDENT>result[self.algorithm] = self._hash_data(self.algorithm)<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT><DEDENT><DEDENT>else:  <EOL><INDENT>return None<EOL><DEDENT>if self.algorithm != \"<STR_LIT:all>\" and self.only_hash:<EOL><INDENT>return result[self.algorithm]<EOL><DEDENT>return result<EOL>", "docstring": "Return the hash of the given file", "id": "f8240:c0:m3"}
{"signature": "@classmethod<EOL><INDENT>def from_json(cls, data):<DEDENT>", "body": "try:<EOL><INDENT>return loads(data)<EOL><DEDENT>except decoder.JSONDecodeError:  <EOL><INDENT>return {}<EOL><DEDENT>", "docstring": "Convert a JSON formatted string into a dictionary.\n\n:param data: A JSON formatted string to convert to dict format.\n:type data: str\n\n:return: The dict representation of the JSON formatted string.\n:rtype: dict", "id": "f8240:c2:m6"}
{"signature": "def not_matching_list(self):", "body": "pre_result = comp(self.regex)<EOL>return [x for x in self.data if not pre_result.search(str(x))]<EOL>", "docstring": "Return a list of string which don't match the\ngiven regex.", "id": "f8240:c6:m1"}
{"signature": "def execute(self):", "body": "<EOL>process = Popen(self.command, stdout=PIPE, stderr=PIPE, shell=True)<EOL>(output, error) = process.communicate()<EOL>if process.returncode != <NUM_LIT:0>:  <EOL><INDENT>return self._decode_output(error)<EOL><DEDENT>return self._decode_output(output)<EOL>", "docstring": "Execute the given command.\n\n:return: The output of the command.\n:rtype: str", "id": "f8240:c1:m2"}
{"signature": "def referer_not_found(self, extension):", "body": "if PyFunceble.CONFIGURATION[\"<STR_LIT>\"]:<EOL><INDENT>to_write = {<EOL>self.current_time: {<EOL>\"<STR_LIT>\": PyFunceble.INTERN[\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": extension,<EOL>}<EOL>}<EOL>if self.output:<EOL><INDENT>output = self.output<EOL><DEDENT>else:<EOL><INDENT>output = PyFunceble.OUTPUT_DIRECTORY<EOL>output += PyFunceble.OUTPUTS[\"<STR_LIT>\"]<EOL>output += PyFunceble.OUTPUTS[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>output += PyFunceble.OUTPUTS[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL><DEDENT>current_content = self._get_content(output)<EOL>current_content.update(to_write)<EOL>self._write_content(current_content, output)<EOL>if PyFunceble.CONFIGURATION[\"<STR_LIT>\"]:<EOL><INDENT>PyFunceble.requests.post(<EOL>PyFunceble.LINKS[\"<STR_LIT>\"], data=to_write[self.current_time]<EOL>)<EOL><DEDENT><DEDENT>", "docstring": "Logs the case that the referer was not found.\n\n:param extension: The extension of the domain we are testing.\n:type extension: str", "id": "f8241:c0:m5"}
{"signature": "def restore(self):", "body": "if PyFunceble.CONFIGURATION[\"<STR_LIT>\"] and self.backup_content:<EOL><INDENT>file_to_restore = PyFunceble.INTERN[\"<STR_LIT>\"]<EOL>if file_to_restore in self.backup_content:<EOL><INDENT>to_initiate = [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]<EOL>alternatives = {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>}<EOL>for string in to_initiate:<EOL><INDENT>try:<EOL><INDENT>PyFunceble.INTERN[\"<STR_LIT>\"][\"<STR_LIT>\"].update(<EOL>{string: self.backup_content[file_to_restore][string]}<EOL>)<EOL><DEDENT>except KeyError:<EOL><INDENT>PyFunceble.INTERN[\"<STR_LIT>\"][\"<STR_LIT>\"].update(<EOL>{<EOL>string: self.backup_content[file_to_restore][<EOL>alternatives[string]<EOL>]<EOL>}<EOL>)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Restore data from the given path.", "id": "f8242:c0:m2"}
{"signature": "def backup(self):", "body": "if PyFunceble.CONFIGURATION[\"<STR_LIT>\"]:<EOL><INDENT>data_to_backup = {}<EOL>configuration_counter = PyFunceble.INTERN[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>data_to_backup[PyFunceble.INTERN[\"<STR_LIT>\"]] = {<EOL>\"<STR_LIT>\": configuration_counter[\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": configuration_counter[\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": configuration_counter[\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": configuration_counter[\"<STR_LIT>\"],<EOL>}<EOL>to_save = {}<EOL>to_save.update(self.backup_content)<EOL>to_save.update(data_to_backup)<EOL>Dict(to_save).to_json(self.autocontinue_log_file)<EOL><DEDENT>", "docstring": "Backup the current execution state.", "id": "f8242:c0:m1"}
{"signature": "def _retrieve(self):", "body": "if PyFunceble.CONFIGURATION[\"<STR_LIT>\"]:<EOL><INDENT>if \"<STR_LIT>\" not in PyFunceble.INTERN:<EOL><INDENT>PyFunceble.INTERN[\"<STR_LIT>\"] = {}<EOL><DEDENT>if PyFunceble.path.isfile(self.file):<EOL><INDENT>data = Dict().from_json(File(self.file).read())<EOL>for file_path in data:<EOL><INDENT>PyFunceble.INTERN[\"<STR_LIT>\"][file_path] = {}<EOL>for element in data[file_path]:<EOL><INDENT>if data[file_path][element]:<EOL><INDENT>PyFunceble.INTERN[\"<STR_LIT>\"][file_path][element] = data[<EOL>file_path<EOL>][element]<EOL><DEDENT><DEDENT><DEDENT>return<EOL><DEDENT><DEDENT>PyFunceble.INTERN[\"<STR_LIT>\"] = {}<EOL>return<EOL>", "docstring": "Retrieve the mining informations.", "id": "f8243:c0:m2"}
{"signature": "def file_url(self):", "body": "<EOL>list_to_test = self._file_list_to_test_filtering()<EOL>not_filtered = list_to_test<EOL>try:<EOL><INDENT>list_to_test = List(<EOL>list(<EOL>set(<EOL>list_to_test[PyFunceble.INTERN[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"] :]<EOL>)<EOL>- set(PyFunceble.INTERN[\"<STR_LIT>\"])<EOL>)<EOL>).format()<EOL>_ = list_to_test[-<NUM_LIT:1>]<EOL><DEDENT>except IndexError:<EOL><INDENT>list_to_test = not_filtered[<EOL>PyFunceble.INTERN[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"] :<EOL>]<EOL>del not_filtered<EOL><DEDENT>if PyFunceble.CONFIGURATION[\"<STR_LIT>\"]:<EOL><INDENT>list_to_test = List(list(list_to_test)).custom_format(Sort.hierarchical)<EOL><DEDENT>try:<EOL><INDENT>return [self.url(x, list_to_test[-<NUM_LIT:1>]) for x in list_to_test if x]<EOL><DEDENT>except IndexError:<EOL><INDENT>print(PyFunceble.Fore.CYAN + PyFunceble.Style.BRIGHT + \"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Manage the case that we have to test a file\n\n.. note::\n    1 URL per line.", "id": "f8244:c0:m17"}
{"signature": "@classmethod<EOL><INDENT>def _print_header(cls):<DEDENT>", "body": "if (<EOL>not PyFunceble.CONFIGURATION[\"<STR_LIT>\"]<EOL>and not PyFunceble.CONFIGURATION[\"<STR_LIT>\"]<EOL>):<EOL><INDENT>print(\"<STR_LIT:\\n>\")<EOL>if PyFunceble.CONFIGURATION[\"<STR_LIT>\"]:<EOL><INDENT>Prints(None, \"<STR_LIT>\").header()<EOL><DEDENT>else:<EOL><INDENT>Prints(None, \"<STR_LIT>\").header()<EOL><DEDENT>PyFunceble.CONFIGURATION[\"<STR_LIT>\"] = True<EOL><DEDENT>", "docstring": "Decide if we print or not the header.", "id": "f8244:c0:m7"}
{"signature": "def _entry_management(self):  ", "body": "if not self.modulo_test:  <EOL><INDENT>PyFunceble.INTERN[<EOL>\"<STR_LIT>\"<EOL>] = self.file_path  <EOL>self._entry_management_url()<EOL>AutoSave().travis_permissions()<EOL>self.bypass()<EOL>ExecutionTime(\"<STR_LIT:start>\")<EOL>if PyFunceble.CONFIGURATION[\"<STR_LIT>\"]:<EOL><INDENT>PyFunceble.HTTP_CODE[\"<STR_LIT>\"] = False<EOL><DEDENT>if self.domain_or_ip_to_test:  <EOL><INDENT>PyFunceble.INTERN[\"<STR_LIT>\"] = \"<STR_LIT>\"<EOL>ExecutionTime(\"<STR_LIT:start>\")<EOL>PyFunceble.CONFIGURATION[\"<STR_LIT>\"] = False<EOL>PyFunceble.CONFIGURATION[\"<STR_LIT>\"] = False<EOL>if PyFunceble.CONFIGURATION[\"<STR_LIT>\"]:<EOL><INDENT>domain_or_ip_to_test = domain2idna(<EOL>self.domain_or_ip_to_test.lower()  <EOL>)<EOL><DEDENT>else:<EOL><INDENT>domain_or_ip_to_test = (<EOL>self.domain_or_ip_to_test.lower()  <EOL>)  <EOL><DEDENT>self.domain(domain_or_ip_to_test)<EOL><DEDENT>elif self.url_to_test and not self.file_path:  <EOL><INDENT>PyFunceble.INTERN[\"<STR_LIT>\"] = \"<STR_LIT:url>\"<EOL>ExecutionTime(\"<STR_LIT:start>\")<EOL>PyFunceble.CONFIGURATION[\"<STR_LIT>\"] = False<EOL>self.url(<EOL>self.checker.is_url_valid(<EOL>self.url_to_test,  <EOL>return_formatted=True,<EOL>)<EOL>)<EOL><DEDENT>elif (<EOL>self._entry_management_url_download(<EOL>self.url_file  <EOL>)<EOL>or self.url_file  <EOL>):<EOL><INDENT>PyFunceble.CONFIGURATION[\"<STR_LIT>\"] = PyFunceble.CONFIGURATION[<EOL>\"<STR_LIT>\"<EOL>] = PyFunceble.CONFIGURATION[\"<STR_LIT>\"] = True<EOL>PyFunceble.CONFIGURATION[\"<STR_LIT>\"] = False<EOL>PyFunceble.INTERN[\"<STR_LIT>\"] = \"<STR_LIT:url>\"<EOL>self.file_url()<EOL><DEDENT>elif (<EOL>self._entry_management_url_download(<EOL>self.link_to_test  <EOL>)<EOL>or self._entry_management_url_download(<EOL>self.file_path  <EOL>)  <EOL>or self.file_path  <EOL>):<EOL><INDENT>PyFunceble.INTERN[\"<STR_LIT>\"] = \"<STR_LIT>\"<EOL>self.file()<EOL><DEDENT>else:<EOL><INDENT>print(<EOL>PyFunceble.Fore.CYAN + PyFunceble.Style.BRIGHT + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if (<EOL>self.domain_or_ip_to_test  <EOL>or self.url_to_test  <EOL>):<EOL><INDENT>ExecutionTime(\"<STR_LIT>\", last=True)<EOL>self.percentage.log()<EOL>self.colorify_logo()<EOL><DEDENT>PyFunceble.stay_safe()<EOL><DEDENT>else:<EOL><INDENT>PyFunceble.CONFIGURATION[\"<STR_LIT>\"] = PyFunceble.CONFIGURATION[<EOL>\"<STR_LIT>\"<EOL>] = PyFunceble.CONFIGURATION[\"<STR_LIT>\"] = True<EOL>PyFunceble.CONFIGURATION[\"<STR_LIT>\"] = PyFunceble.CONFIGURATION[<EOL>\"<STR_LIT>\"<EOL>] = PyFunceble.CONFIGURATION[\"<STR_LIT>\"] = PyFunceble.CONFIGURATION[<EOL>\"<STR_LIT>\"<EOL>] = False<EOL>if self.domain_or_ip_to_test:  <EOL><INDENT>PyFunceble.INTERN[\"<STR_LIT>\"] = \"<STR_LIT>\"<EOL>PyFunceble.INTERN[<EOL>\"<STR_LIT>\"<EOL>] = self.domain_or_ip_to_test.lower()  <EOL><DEDENT>elif self.url_to_test:  <EOL><INDENT>PyFunceble.INTERN[\"<STR_LIT>\"] = \"<STR_LIT:url>\"<EOL>PyFunceble.INTERN[<EOL>\"<STR_LIT>\"<EOL>] = self.url_to_test<EOL><DEDENT><DEDENT>", "docstring": "Avoid to have 1 millions line into self.__init__()", "id": "f8244:c0:m3"}
{"signature": "@classmethod<EOL><INDENT>def colorify_logo(cls, home=False):<DEDENT>", "body": "if not PyFunceble.CONFIGURATION[\"<STR_LIT>\"]:<EOL><INDENT>to_print = []<EOL>if home:<EOL><INDENT>for line in PyFunceble.ASCII_PYFUNCEBLE.split(\"<STR_LIT:\\n>\"):<EOL><INDENT>to_print.append(<EOL>PyFunceble.Fore.YELLOW + line + PyFunceble.Fore.RESET<EOL>)<EOL><DEDENT><DEDENT>elif PyFunceble.INTERN[\"<STR_LIT>\"][\"<STR_LIT>\"][\"<STR_LIT>\"] >= <NUM_LIT:50>:<EOL><INDENT>for line in PyFunceble.ASCII_PYFUNCEBLE.split(\"<STR_LIT:\\n>\"):<EOL><INDENT>to_print.append(<EOL>PyFunceble.Fore.GREEN + line + PyFunceble.Fore.RESET<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for line in PyFunceble.ASCII_PYFUNCEBLE.split(\"<STR_LIT:\\n>\"):<EOL><INDENT>to_print.append(PyFunceble.Fore.RED + line + PyFunceble.Fore.RESET)<EOL><DEDENT><DEDENT>print(\"<STR_LIT:\\n>\".join(to_print))<EOL><DEDENT>", "docstring": "Print the colored logo based on global results.\n\n:param home: Tell us if we have to print the initial coloration.\n:type home: bool", "id": "f8244:c0:m12"}
{"signature": "def _entry_management_url(self):", "body": "if (<EOL>self.url_file  <EOL>and not self._entry_management_url_download(<EOL>self.url_file  <EOL>)<EOL>):  <EOL><INDENT>PyFunceble.INTERN[<EOL>\"<STR_LIT>\"<EOL>] = self.url_file<EOL><DEDENT>", "docstring": "Manage the loading of the url system.", "id": "f8244:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def reset_counters(cls):<DEDENT>", "body": "for string in [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>PyFunceble.INTERN[\"<STR_LIT>\"][\"<STR_LIT>\"].update({string: <NUM_LIT:0>})<EOL><DEDENT>", "docstring": "Reset the counters when needed.", "id": "f8244:c0:m11"}
{"signature": "@classmethod<EOL><INDENT>def _get_current_version_yaml(cls):<DEDENT>", "body": "return Dict().from_yaml(<EOL>File(PyFunceble.CURRENT_DIRECTORY + \"<STR_LIT>\").read()<EOL>)<EOL>", "docstring": "Get and return the content of version.yaml", "id": "f8246:c0:m2"}
{"signature": "def _update_code_urls(self):", "body": "to_ignore = [\"<STR_LIT>\", \"<STR_LIT>\"]<EOL>for root, _, files in PyFunceble.walk(<EOL>PyFunceble.CURRENT_DIRECTORY<EOL>+ PyFunceble.directory_separator<EOL>+ \"<STR_LIT>\"<EOL>+ PyFunceble.directory_separator<EOL>):<EOL><INDENT>for file in files:<EOL><INDENT>if file not in to_ignore and \"<STR_LIT>\" not in root:<EOL><INDENT>if root.endswith(PyFunceble.directory_separator):<EOL><INDENT>self._update_docs(root + file)<EOL><DEDENT>else:<EOL><INDENT>self._update_docs(root + PyFunceble.directory_separator + file)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>for root, _, files in PyFunceble.walk(<EOL>PyFunceble.CURRENT_DIRECTORY<EOL>+ PyFunceble.directory_separator<EOL>+ \"<STR_LIT>\"<EOL>+ PyFunceble.directory_separator<EOL>):<EOL><INDENT>for file in files:<EOL><INDENT>if file not in to_ignore and \"<STR_LIT>\" not in root:<EOL><INDENT>if root.endswith(PyFunceble.directory_separator):<EOL><INDENT>self._update_docs(root + file)<EOL><DEDENT>else:<EOL><INDENT>self._update_docs(root + PyFunceble.directory_separator + file)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Read the code and update all links.", "id": "f8246:c0:m1"}
{"signature": "def is_time_older(self):", "body": "if (<EOL>self._authorization()<EOL>and self.is_in_database()<EOL>and int(<EOL>PyFunceble.INTERN[\"<STR_LIT>\"][PyFunceble.INTERN[\"<STR_LIT>\"]][<EOL>PyFunceble.INTERN[\"<STR_LIT>\"]<EOL>][\"<STR_LIT>\"]<EOL>)<EOL>< int(PyFunceble.time())<EOL>):<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Check if the current time is older than the one in the database.", "id": "f8247:c1:m5"}
{"signature": "def _backup(self):", "body": "if self._authorization():<EOL><INDENT>Dict(PyFunceble.INTERN[\"<STR_LIT>\"]).to_json(self.whois_db_path)<EOL><DEDENT>", "docstring": "Backup the database into its file.", "id": "f8247:c1:m3"}
{"signature": "def get_expiration_date(self):", "body": "if self._authorization() and self.is_in_database() and not self.is_time_older():<EOL><INDENT>result = PyFunceble.INTERN[\"<STR_LIT>\"][PyFunceble.INTERN[\"<STR_LIT>\"]][<EOL>PyFunceble.INTERN[\"<STR_LIT>\"]<EOL>][\"<STR_LIT>\"]<EOL>if result:<EOL><INDENT>return result<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Get the expiration date from the database.\n\n:return: The expiration date from the database.\n:rtype: str|None", "id": "f8247:c1:m6"}
{"signature": "@classmethod<EOL><INDENT>def _authorization(cls):<DEDENT>", "body": "if (<EOL>not PyFunceble.CONFIGURATION[\"<STR_LIT>\"]<EOL>and PyFunceble.CONFIGURATION[\"<STR_LIT>\"]<EOL>):<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Check if we are authorized to work with our database.", "id": "f8247:c1:m1"}
{"signature": "def _backup(self):", "body": "if PyFunceble.CONFIGURATION[\"<STR_LIT>\"]:<EOL><INDENT>Dict(PyFunceble.INTERN[\"<STR_LIT>\"]).to_json(self.inactive_db_path)<EOL><DEDENT>", "docstring": "Save the current database into the inactive-db.json file.", "id": "f8247:c0:m4"}
{"signature": "@classmethod<EOL><INDENT>def _convert_or_shorten_month(cls, data):<DEDENT>", "body": "<EOL>short_month = {<EOL>\"<STR_LIT>\": [str(<NUM_LIT:1>), \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>\"<STR_LIT>\": [str(<NUM_LIT:2>), \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>\"<STR_LIT>\": [str(<NUM_LIT:3>), \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>\"<STR_LIT>\": [str(<NUM_LIT:4>), \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>\"<STR_LIT>\": [str(<NUM_LIT:5>), \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>\"<STR_LIT>\": [str(<NUM_LIT:6>), \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>\"<STR_LIT>\": [str(<NUM_LIT:7>), \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>\"<STR_LIT>\": [str(<NUM_LIT:8>), \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>\"<STR_LIT>\": [str(<NUM_LIT:9>), \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>\"<STR_LIT>\": [str(<NUM_LIT:10>), \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>\"<STR_LIT>\": [str(<NUM_LIT:11>), \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>\"<STR_LIT>\": [str(<NUM_LIT:12>), \"<STR_LIT>\", \"<STR_LIT>\"],<EOL>}<EOL>for month in short_month:<EOL><INDENT>if data in short_month[month]:<EOL><INDENT>return month<EOL><DEDENT><DEDENT>return data<EOL>", "docstring": "Convert a given month into our unified format.\n\n:param data: The month to convert or shorten.\n:type data: str\n\n:return: The unified month name.\n:rtype: str", "id": "f8249:c0:m3"}
{"signature": "def get(self):  ", "body": "<EOL>domain_validation = self.checker.is_domain_valid()<EOL>ip_validation = self.checker.is_ip_valid()<EOL>if \"<STR_LIT>\" in PyFunceble.INTERN:<EOL><INDENT>PyFunceble.INTERN[\"<STR_LIT>\"].update(<EOL>{<EOL>\"<STR_LIT>\": domain_validation,<EOL>\"<STR_LIT>\": ip_validation,<EOL>}<EOL>)<EOL><DEDENT>if (<EOL>domain_validation<EOL>and not ip_validation<EOL>or domain_validation<EOL>or PyFunceble.CONFIGURATION[\"<STR_LIT>\"]<EOL>):<EOL><INDENT>PyFunceble.INTERN.update(<EOL>{\"<STR_LIT>\": HTTPCode().get(), \"<STR_LIT>\": Referer().get()}<EOL>)<EOL>if not PyFunceble.INTERN[\"<STR_LIT>\"]:<EOL><INDENT>return PyFunceble.INTERN[\"<STR_LIT>\"]<EOL><DEDENT>if PyFunceble.INTERN[\"<STR_LIT>\"] and not self.checker.is_subdomain():<EOL><INDENT>return self._extract()<EOL><DEDENT>Logs().whois(self.whois_record)<EOL>return None<EOL><DEDENT>if (<EOL>ip_validation<EOL>and not domain_validation<EOL>or ip_validation<EOL>or PyFunceble.CONFIGURATION[\"<STR_LIT>\"]<EOL>):<EOL><INDENT>PyFunceble.INTERN[\"<STR_LIT>\"] = HTTPCode().get()<EOL>Logs().whois(self.whois_record)<EOL>return None<EOL><DEDENT>Logs().whois(self.whois_record)<EOL>return False<EOL>", "docstring": "Execute the logic behind the meaning of ExpirationDate + return the matched status.\n\n:return:\n    The status of the tested domain.\n    Can be one of the official status.\n:rtype: str", "id": "f8249:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def handle(cls, status, invalid_source=\"<STR_LIT>\"):<DEDENT>", "body": "if status.lower() not in PyFunceble.STATUS[\"<STR_LIT:list>\"][\"<STR_LIT>\"]:<EOL><INDENT>source = \"<STR_LIT>\"<EOL>if Lookup().nslookup():<EOL><INDENT>status, source = cls.extra_rules.handle(<EOL>PyFunceble.STATUS[\"<STR_LIT>\"][\"<STR_LIT>\"], source<EOL>)<EOL>Generate(status, source).status_file()<EOL>return status, source<EOL><DEDENT>status, source = cls.extra_rules.handle(<EOL>PyFunceble.STATUS[\"<STR_LIT>\"][\"<STR_LIT>\"], source<EOL>)<EOL>Generate(status, source).status_file()<EOL>return status, source<EOL><DEDENT>status, source = cls.extra_rules.handle(<EOL>PyFunceble.STATUS[\"<STR_LIT>\"][\"<STR_LIT>\"], invalid_source<EOL>)<EOL>Generate(status, source).status_file()<EOL>return status, source<EOL>", "docstring": "Handle the lack of WHOIS and expiration date. :smile_cat:\n\n:param matched_status: The status that we have to handle.\n:type status: str\n\n:param invalid_source:\n    The source to set when we handle INVALID element.\n:type invalid_source: str\n\n:return:\n    The strus of the domain after generating the files desired\n    by the user.\n:rtype: str", "id": "f8251:c0:m2"}
{"signature": "def get_account_hash(self):", "body": "return self.storage_path.rsplit('<STR_LIT:/>', <NUM_LIT:1>)[<NUM_LIT:1>]<EOL>", "docstring": "See :py:func:`swiftly.client.client.Client.get_account_hash`", "id": "f8256:c0:m3"}
{"signature": "@contextlib.contextmanager<EOL><INDENT>def with_client(self):<DEDENT>", "body": "client = self.get_client()<EOL>yield client<EOL>self.put_client(client)<EOL>", "docstring": "A context manager that obtains a client for use, whether an\nexisting unused client or a brand new one if none are\navailable.", "id": "f8257:c0:m3"}
{"signature": "def reset(self):", "body": "pass<EOL>", "docstring": "Resets the client, closing any connections and discarding any\nstate. This can be useful if some exceptional condition\noccurred and the request/response state can no longer be\ncertain.", "id": "f8258:c0:m1"}
{"signature": "def post_account(self, headers=None, query=None, cdn=False, body=None):", "body": "return self.request(<EOL>'<STR_LIT:POST>', '<STR_LIT>', body or '<STR_LIT>', headers, query=query, cdn=cdn)<EOL>", "docstring": "POSTs the account and returns the results. This is usually\ndone to set X-Account-Meta-xxx headers. Note that any existing\nX-Account-Meta-xxx headers will remain untouched. To remove an\nX-Account-Meta-xxx header, send the header with an empty\nstring as its value.\n\n:param headers: Additional headers to send with the request.\n:param query: Set to a dict of query values to send on the\n    query string of the request.\n:param cdn: If set True, the CDN management interface will be\n    used.\n:param body: No known Swift POSTs take a body; but the option\n    is there for the future.\n:returns: A tuple of (status, reason, headers, contents).\n\n    :status: is an int for the HTTP status code.\n    :reason: is the str for the HTTP status (ex: \"Ok\").\n    :headers: is a dict with all lowercase keys of the HTTP\n        headers; if a header has multiple values, it will be a\n        list.\n    :contents: is the str for the HTTP body.", "id": "f8258:c0:m10"}
{"signature": "def put_container(self, container, headers=None, query=None, cdn=False,<EOL>body=None):", "body": "path = self._container_path(container)<EOL>return self.request(<EOL>'<STR_LIT>', path, body or '<STR_LIT>', headers, query=query, cdn=cdn)<EOL>", "docstring": "PUTs the container and returns the results. This is usually\ndone to create new containers and can also be used to set\nX-Container-Meta-xxx headers. Note that if the container\nalready exists, any existing X-Container-Meta-xxx headers will\nremain untouched. To remove an X-Container-Meta-xxx header,\nsend the header with an empty string as its value.\n\n:param container: The name of the container.\n:param headers: Additional headers to send with the request.\n:param query: Set to a dict of query values to send on the\n    query string of the request.\n:param cdn: If set True, the CDN management interface will be\n    used.\n:param body: Some container PUT requests, like the\n    extract-archive bulk upload request, take a body.\n:returns: A tuple of (status, reason, headers, contents).\n\n    :status: is an int for the HTTP status code.\n    :reason: is the str for the HTTP status (ex: \"Ok\").\n    :headers: is a dict with all lowercase keys of the HTTP\n        headers; if a header has multiple values, it will be a\n        list.\n    :contents: is the str for the HTTP body.", "id": "f8258:c0:m14"}
{"signature": "def get_account(self, headers=None, prefix=None, delimiter=None,<EOL>marker=None, end_marker=None, limit=None, query=None,<EOL>cdn=False, decode_json=True):", "body": "query = dict(query or {})<EOL>query['<STR_LIT>'] = '<STR_LIT>'<EOL>if prefix:<EOL><INDENT>query['<STR_LIT>'] = prefix<EOL><DEDENT>if delimiter:<EOL><INDENT>query['<STR_LIT>'] = delimiter<EOL><DEDENT>if marker:<EOL><INDENT>query['<STR_LIT>'] = marker<EOL><DEDENT>if end_marker:<EOL><INDENT>query['<STR_LIT>'] = end_marker<EOL><DEDENT>if limit:<EOL><INDENT>query['<STR_LIT>'] = limit<EOL><DEDENT>return self.request(<EOL>'<STR_LIT:GET>', '<STR_LIT>', '<STR_LIT>', headers, decode_json=decode_json, query=query,<EOL>cdn=cdn)<EOL>", "docstring": "GETs the account and returns the results. This is done to list\nthe containers for the account. Some useful headers are also\nreturned:\n\n=========================== =================================\nx-account-bytes-used        Object storage used for the\n                            account, in bytes.\nx-account-container-count   The number of containers in the\n                            account.\nx-account-object-count      The number of objects in the\n                            account.\n=========================== =================================\n\nAlso, any user headers beginning with x-account-meta- are\nreturned.\n\nThese values can be delayed depending the Swift cluster.\n\n:param headers: Additional headers to send with the request.\n:param prefix: The prefix container names must match to be\n    listed.\n:param delimiter: The delimiter for the listing. Delimiters\n    indicate how far to progress through container names\n    before \"rolling them up\". For instance, a delimiter='.'\n    query on an account with the containers::\n\n        one.one\n        one.two\n        two\n        three.one\n\n    would return the JSON value of::\n\n        [{'subdir': 'one.'},\n         {'count': 0, 'bytes': 0, 'name': 'two'},\n         {'subdir': 'three.'}]\n\n    Using this with prefix can allow you to traverse a psuedo\n    hierarchy.\n:param marker: Only container names after this marker will be\n    returned. Swift returns a limited number of containers\n    per request (often 10,000). To get the next batch of\n    names, you issue another query with the marker set to the\n    last name you received. You can continue to issue\n    requests until you receive no more names.\n:param end_marker: Only container names before this marker will be\n    returned.\n:param limit: Limits the size of the list returned per\n    request. The default and maximum depends on the Swift\n    cluster (usually 10,000).\n:param query: Set to a dict of query values to send on the\n    query string of the request.\n:param cdn: If set True, the CDN management interface will be\n    used.\n:param decode_json: If set False, the usual decoding of the\n    JSON response will be skipped and the raw contents will\n    be returned instead.\n:returns: A tuple of (status, reason, headers, contents).\n\n    :status: is an int for the HTTP status code.\n    :reason: is the str for the HTTP status (ex: \"Ok\").\n    :headers: is a dict with all lowercase keys of the HTTP\n        headers; if a header has multiple values, it will be a\n        list.\n    :contents: is the decoded JSON response or the raw str\n        for the HTTP body.", "id": "f8258:c0:m8"}
{"signature": "def get_object(self, container, obj, headers=None, stream=True, query=None,<EOL>cdn=False):", "body": "path = self._object_path(container, obj)<EOL>return self.request(<EOL>'<STR_LIT:GET>', path, '<STR_LIT>', headers, query=query, stream=stream, cdn=cdn)<EOL>", "docstring": "GETs the object and returns the results.\n\n:param container: The name of the container.\n:param obj: The name of the object.\n:param headers: Additional headers to send with the request.\n:param stream: Indicates whether to stream the contents or\n    preread them fully and return them as a str. Default:\n    True to stream the contents. When streaming, contents\n    will have the standard file-like-object read function,\n    which accepts an optional size parameter to limit how\n    much data is read per call. When streaming is on, be\n    certain to fully read the contents before issuing another\n    request.\n:param query: Set to a dict of query values to send on the\n    query string of the request.\n:param cdn: If set True, the CDN management interface will be\n    used.\n:returns: A tuple of (status, reason, headers, contents).\n\n    :status: is an int for the HTTP status code.\n    :reason: is the str for the HTTP status (ex: \"Ok\").\n    :headers: is a dict with all lowercase keys of the HTTP\n        headers; if a header has multiple values, it will be a\n        list.\n    :contents: if *stream* was True, *contents* is a\n        file-like-object of the contents of the HTTP body. If\n        *stream* was False, *contents* is just a simple str of\n        the HTTP body.", "id": "f8258:c0:m18"}
{"signature": "def delete_account(self, headers=None,<EOL>yes_i_mean_delete_the_account=False, query=None,<EOL>cdn=False, body=None):", "body": "if not yes_i_mean_delete_the_account and (<EOL>not body or not query or '<STR_LIT>' not in query):<EOL><INDENT>return (<NUM_LIT:0>, '<STR_LIT>', {},<EOL>'<STR_LIT>')<EOL><DEDENT>return self.request(<EOL>'<STR_LIT>', '<STR_LIT>', body or '<STR_LIT>', headers, query=query, cdn=cdn)<EOL>", "docstring": "Sends a DELETE request to the account and returns the results.\n\nWith ``query['bulk-delete'] = ''`` this might mean a bulk\ndelete request where the body of the request is new-line\nseparated, url-encoded list of names to delete. Be careful\nwith this! One wrong move and you might mark your account for\ndeletion of you have the access to do so!\n\nFor a plain DELETE to the account, on clusters that support\nit and, assuming you have permissions to do so, the account\nwill be marked as deleted and immediately begin removing the\nobjects from the cluster in the backgound.\n\nTHERE IS NO GOING BACK!\n\n:param headers: Additional headers to send with the request.\n:param yes_i_mean_delete_the_account: Set to True to verify\n    you really mean to delete the entire account. This is\n    required unless ``body and 'bulk-delete' in query``.\n:param query: Set to a dict of query values to send on the\n    query string of the request.\n:param cdn: If set True, the CDN management interface will be\n    used.\n:param body: Some account DELETE requests, like the bulk\n    delete request, take a body.\n:returns: A tuple of (status, reason, headers, contents).\n\n    :status: is an int for the HTTP status code.\n    :reason: is the str for the HTTP status (ex: \"Ok\").\n    :headers: is a dict with all lowercase keys of the HTTP\n        headers; if a header has multiple values, it will be\n        a list.\n    :contents: is the str for the HTTP body.", "id": "f8258:c0:m11"}
{"signature": "def quote(value, safe='<STR_LIT>'):", "body": "if isinstance(value, six.text_type):<EOL><INDENT>value = value.encode('<STR_LIT:utf8>')<EOL><DEDENT>elif not isinstance(value, six.string_types):<EOL><INDENT>value = str(value)<EOL><DEDENT>return parse.quote(value, safe)<EOL>", "docstring": "Much like parse.quote in that it returns a URL encoded string\nfor the given value, protecting the safe characters; but this\nversion also ensures the value is UTF-8 encoded.", "id": "f8262:m2"}
{"signature": "def write_headers(self, fp, headers, mute=None):", "body": "if headers:<EOL><INDENT>if not mute:<EOL><INDENT>mute = []<EOL><DEDENT>fmt = '<STR_LIT>' % (max(len(k) for k in headers) + <NUM_LIT:1>)<EOL>for key in sorted(headers):<EOL><INDENT>if key in mute:<EOL><INDENT>continue<EOL><DEDENT>fp.write(fmt % (key.title() + '<STR_LIT::>', headers[key]))<EOL><DEDENT>fp.flush()<EOL><DEDENT>", "docstring": "Convenience function to output headers in a formatted fashion\nto a file-like fp, optionally muting any headers in the mute\nlist.", "id": "f8270:c0:m3"}
{"signature": "def copy(self):", "body": "context = CLIContext()<EOL>for item in dir(self):<EOL><INDENT>if item[<NUM_LIT:0>] != '<STR_LIT:_>' and item not in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>setattr(context, item, getattr(self, item))<EOL><DEDENT><DEDENT>return context<EOL>", "docstring": "Returns a new CLIContext instance that is a shallow copy of\nthe original, much like dict's copy method.", "id": "f8270:c0:m2"}
{"signature": "def cli_get_account_listing(context):", "body": "limit = context.query.get('<STR_LIT>')<EOL>delimiter = context.query.get('<STR_LIT>')<EOL>prefix = context.query.get('<STR_LIT>')<EOL>marker = context.query.get('<STR_LIT>')<EOL>end_marker = context.query.get('<STR_LIT>')<EOL>if context.raw:<EOL><INDENT>with context.client_manager.with_client() as client:<EOL><INDENT>status, reason, headers, contents = client.get_account(<EOL>decode_json=False, headers=context.headers, limit=limit,<EOL>marker=marker, end_marker=end_marker, query=context.query,<EOL>cdn=context.cdn)<EOL>if hasattr(contents, '<STR_LIT>'):<EOL><INDENT>contents = contents.read()<EOL><DEDENT><DEDENT>if status // <NUM_LIT:100> != <NUM_LIT:2>:<EOL><INDENT>if status == <NUM_LIT> and context.ignore_404:<EOL><INDENT>return<EOL><DEDENT>raise ReturnCode('<STR_LIT>' % (status, reason))<EOL><DEDENT>with context.io_manager.with_stdout() as fp:<EOL><INDENT>if context.output_headers:<EOL><INDENT>context.write_headers(<EOL>fp, headers, context.muted_account_headers)<EOL><DEDENT>fp.write(contents)<EOL>fp.flush()<EOL><DEDENT>return<EOL><DEDENT>with context.client_manager.with_client() as client:<EOL><INDENT>status, reason, headers, contents = client.get_account(<EOL>headers=context.headers, limit=limit, marker=marker,<EOL>end_marker=end_marker, query=context.query, cdn=context.cdn)<EOL>if status // <NUM_LIT:100> != <NUM_LIT:2>:<EOL><INDENT>if status == <NUM_LIT> and context.ignore_404:<EOL><INDENT>return<EOL><DEDENT>if hasattr(contents, '<STR_LIT>'):<EOL><INDENT>contents.read()<EOL><DEDENT>raise ReturnCode('<STR_LIT>' % (status, reason))<EOL><DEDENT><DEDENT>if context.output_headers and not context.all_objects:<EOL><INDENT>with context.io_manager.with_stdout() as fp:<EOL><INDENT>context.write_headers(<EOL>fp, headers, context.muted_account_headers)<EOL><DEDENT><DEDENT>while contents:<EOL><INDENT>if context.all_objects:<EOL><INDENT>new_context = context.copy()<EOL>new_context.query = dict(new_context.query)<EOL>for remove in (<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>if remove in new_context.query:<EOL><INDENT>del new_context.query[remove]<EOL><DEDENT><DEDENT>for item in contents:<EOL><INDENT>if '<STR_LIT:name>' in item:<EOL><INDENT>new_path = item['<STR_LIT:name>'].encode('<STR_LIT:utf8>')<EOL>cli_get_container_listing(new_context, new_path)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>with context.io_manager.with_stdout() as fp:<EOL><INDENT>for item in contents:<EOL><INDENT>if context.full:<EOL><INDENT>fp.write('<STR_LIT>' % (<EOL>item.get('<STR_LIT>', '<STR_LIT:->'),<EOL>item.get('<STR_LIT:count>', '<STR_LIT:->')))<EOL><DEDENT>fp.write(item.get(<EOL>'<STR_LIT:name>', item.get('<STR_LIT>')))<EOL>fp.write('<STR_LIT:\\n>')<EOL><DEDENT>fp.flush()<EOL><DEDENT><DEDENT>if limit:<EOL><INDENT>break<EOL><DEDENT>marker = contents[-<NUM_LIT:1>].get('<STR_LIT:name>', contents[-<NUM_LIT:1>].get('<STR_LIT>', '<STR_LIT>'))<EOL>with context.client_manager.with_client() as client:<EOL><INDENT>status, reason, headers, contents = client.get_account(<EOL>headers=context.headers, limit=limit, delimiter=delimiter,<EOL>prefix=prefix, end_marker=end_marker, marker=marker,<EOL>query=context.query, cdn=context.cdn)<EOL>if status // <NUM_LIT:100> != <NUM_LIT:2>:<EOL><INDENT>if status == <NUM_LIT> and context.ignore_404:<EOL><INDENT>return<EOL><DEDENT>if hasattr(contents, '<STR_LIT>'):<EOL><INDENT>contents.read()<EOL><DEDENT>raise ReturnCode('<STR_LIT>' % (status, reason))<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Performs a GET on the account as a listing request.\n\nSee :py:mod:`swiftly.cli.get` for context usage information.\n\nSee :py:class:`CLIGet` for more information.", "id": "f8273:m0"}
{"signature": "def cli_get(context, path=None):", "body": "path = path.lstrip('<STR_LIT:/>') if path else None<EOL>if not path:<EOL><INDENT>return cli_get_account_listing(context)<EOL><DEDENT>elif '<STR_LIT:/>' not in path.rstrip('<STR_LIT:/>'):<EOL><INDENT>return cli_get_container_listing(context, path)<EOL><DEDENT>status, reason, headers, contents = <NUM_LIT:0>, '<STR_LIT>', {}, '<STR_LIT>'<EOL>with context.client_manager.with_client() as client:<EOL><INDENT>status, reason, headers, contents = client.get_object(<EOL>*path.split('<STR_LIT:/>', <NUM_LIT:1>), headers=context.headers, query=context.query,<EOL>cdn=context.cdn)<EOL>if status // <NUM_LIT:100> != <NUM_LIT:2>:<EOL><INDENT>if status == <NUM_LIT> and context.ignore_404:<EOL><INDENT>return<EOL><DEDENT>if hasattr(contents, '<STR_LIT>'):<EOL><INDENT>contents.read()<EOL><DEDENT>raise ReturnCode(<EOL>'<STR_LIT>' % (path, status, reason))<EOL><DEDENT>if context.decrypt:<EOL><INDENT>crypt_type = contents.read(<NUM_LIT:1>)<EOL>if crypt_type == AES256CBC:<EOL><INDENT>contents = FileLikeIter(aes_decrypt(<EOL>context.decrypt, contents,<EOL>chunk_size=getattr(client, '<STR_LIT>', <NUM_LIT>)))<EOL><DEDENT>else:<EOL><INDENT>raise ReturnCode(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % (path, crypt_type))<EOL><DEDENT><DEDENT>def disk_closed_callback(disk_path):<EOL><INDENT>if context.remove_empty_files and not os.path.getsize(disk_path):<EOL><INDENT>os.unlink(disk_path)<EOL>if context.io_manager.stdout_root:<EOL><INDENT>dirname = os.path.dirname(disk_path)<EOL>while dirname and dirname.startswith(<EOL>context.io_manager.stdout_root):<EOL><INDENT>try:<EOL><INDENT>os.rmdir(dirname)<EOL><DEDENT>except OSError:<EOL><INDENT>pass<EOL><DEDENT>dirname = os.path.dirname(dirname)<EOL><DEDENT><DEDENT>return<EOL><DEDENT>if (headers.get('<STR_LIT>') in<EOL>['<STR_LIT>', '<STR_LIT>'] and<EOL>headers.get('<STR_LIT>') == '<STR_LIT:0>'):<EOL><INDENT>os.unlink(disk_path)<EOL>os.makedirs(disk_path)<EOL><DEDENT>mtime = <NUM_LIT:0><EOL>if '<STR_LIT>' in headers:<EOL><INDENT>mtime = float(headers['<STR_LIT>'])<EOL><DEDENT>elif '<STR_LIT>' in headers:<EOL><INDENT>mtime = time.mktime(time.strptime(<EOL>headers['<STR_LIT>'], '<STR_LIT>'))<EOL><DEDENT>if mtime:<EOL><INDENT>os.utime(disk_path, (mtime, mtime))<EOL><DEDENT><DEDENT>out_path = path<EOL>if context.suppress_container_name:<EOL><INDENT>out_path = out_path.split('<STR_LIT:/>', <NUM_LIT:1>)[<NUM_LIT:1>]<EOL><DEDENT>out_path = context.io_manager.client_path_to_os_path(out_path)<EOL>with context.io_manager.with_stdout(<EOL>out_path, disk_closed_callback=disk_closed_callback) as fp:<EOL><INDENT>if context.output_headers:<EOL><INDENT>context.write_headers(<EOL>fp, headers, context.muted_object_headers)<EOL>fp.write('<STR_LIT:\\n>')<EOL><DEDENT>chunk = contents.read(<NUM_LIT>)<EOL>while chunk:<EOL><INDENT>fp.write(chunk)<EOL>chunk = contents.read(<NUM_LIT>)<EOL><DEDENT>fp.flush()<EOL><DEDENT><DEDENT>", "docstring": "Performs a GET on the item (account, container, or object).\n\nSee :py:mod:`swiftly.cli.get` for context usage information.\n\nSee :py:class:`CLIGet` for more information.", "id": "f8273:m2"}
{"signature": "def cli_get_container_listing(context, path=None):", "body": "path = path.strip('<STR_LIT:/>') if path else None<EOL>if not path or '<STR_LIT:/>' in path:<EOL><INDENT>raise ReturnCode(<EOL>'<STR_LIT>' %<EOL>path)<EOL><DEDENT>context.suppress_container_name = True<EOL>limit = context.query.get('<STR_LIT>')<EOL>delimiter = context.query.get('<STR_LIT>')<EOL>prefix = context.query.get('<STR_LIT>')<EOL>marker = context.query.get('<STR_LIT>')<EOL>end_marker = context.query.get('<STR_LIT>')<EOL>if context.raw:<EOL><INDENT>with context.client_manager.with_client() as client:<EOL><INDENT>status, reason, headers, contents = client.get_container(<EOL>path, decode_json=False, headers=context.headers, limit=limit,<EOL>marker=marker, end_marker=end_marker, query=context.query,<EOL>cdn=context.cdn)<EOL>if hasattr(contents, '<STR_LIT>'):<EOL><INDENT>contents = contents.read()<EOL><DEDENT><DEDENT>if status // <NUM_LIT:100> != <NUM_LIT:2>:<EOL><INDENT>if status == <NUM_LIT> and context.ignore_404:<EOL><INDENT>return<EOL><DEDENT>raise ReturnCode(<EOL>'<STR_LIT>' % (path, status, reason))<EOL><DEDENT>with context.io_manager.with_stdout() as fp:<EOL><INDENT>if context.output_headers:<EOL><INDENT>context.write_headers(<EOL>fp, headers, context.muted_container_headers)<EOL><DEDENT>fp.write(contents)<EOL>fp.flush()<EOL><DEDENT>return<EOL><DEDENT>with context.client_manager.with_client() as client:<EOL><INDENT>status, reason, headers, contents = client.get_container(<EOL>path, headers=context.headers, limit=limit, delimiter=delimiter,<EOL>prefix=prefix, marker=marker, end_marker=end_marker,<EOL>query=context.query, cdn=context.cdn)<EOL>if status // <NUM_LIT:100> != <NUM_LIT:2>:<EOL><INDENT>if status == <NUM_LIT> and context.ignore_404:<EOL><INDENT>return<EOL><DEDENT>if hasattr(contents, '<STR_LIT>'):<EOL><INDENT>contents.read()<EOL><DEDENT>raise ReturnCode(<EOL>'<STR_LIT>' % (path, status, reason))<EOL><DEDENT><DEDENT>if context.output_headers and not context.all_objects:<EOL><INDENT>with context.io_manager.with_stdout() as fp:<EOL><INDENT>context.write_headers(<EOL>fp, headers, context.muted_container_headers)<EOL><DEDENT><DEDENT>conc = Concurrency(context.concurrency)<EOL>while contents:<EOL><INDENT>if context.all_objects:<EOL><INDENT>new_context = context.copy()<EOL>new_context.query = dict(new_context.query)<EOL>for remove in (<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>if remove in new_context.query:<EOL><INDENT>del new_context.query[remove]<EOL><DEDENT><DEDENT>for item in contents:<EOL><INDENT>if '<STR_LIT:name>' in item:<EOL><INDENT>for (exc_type, exc_value, exc_tb, result) insix.itervalues(conc.get_results()):<EOL><INDENT>if exc_value:<EOL><INDENT>conc.join()<EOL>raise exc_value<EOL><DEDENT><DEDENT>new_path = path + '<STR_LIT:/>' + item['<STR_LIT:name>'].encode('<STR_LIT:utf8>')<EOL>conc.spawn(new_path, cli_get, new_context, new_path)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>with context.io_manager.with_stdout() as fp:<EOL><INDENT>for item in contents:<EOL><INDENT>if context.full:<EOL><INDENT>fp.write('<STR_LIT>' % (<EOL>item.get('<STR_LIT>', '<STR_LIT:->'),<EOL>item.get('<STR_LIT>', '<STR_LIT:->')[:<NUM_LIT>].replace(<EOL>'<STR_LIT:T>', '<STR_LIT:U+0020>'),<EOL>item.get('<STR_LIT>', '<STR_LIT:->'),<EOL>item.get('<STR_LIT>', '<STR_LIT:->')))<EOL><DEDENT>fp.write(item.get(<EOL>'<STR_LIT:name>', item.get('<STR_LIT>')))<EOL>fp.write('<STR_LIT:\\n>')<EOL><DEDENT>fp.flush()<EOL><DEDENT><DEDENT>if limit:<EOL><INDENT>break<EOL><DEDENT>marker = contents[-<NUM_LIT:1>].get('<STR_LIT:name>', contents[-<NUM_LIT:1>].get('<STR_LIT>', '<STR_LIT>'))<EOL>with context.client_manager.with_client() as client:<EOL><INDENT>status, reason, headers, contents = client.get_container(<EOL>path, headers=context.headers, limit=limit,<EOL>delimiter=delimiter, prefix=prefix, end_marker=end_marker,<EOL>marker=marker, query=context.query, cdn=context.cdn)<EOL>if status // <NUM_LIT:100> != <NUM_LIT:2>:<EOL><INDENT>if status == <NUM_LIT> and context.ignore_404:<EOL><INDENT>return<EOL><DEDENT>if hasattr(contents, '<STR_LIT>'):<EOL><INDENT>contents.read()<EOL><DEDENT>raise ReturnCode(<EOL>'<STR_LIT>' % (path, status, reason))<EOL><DEDENT><DEDENT><DEDENT>conc.join()<EOL>for (exc_type, exc_value, exc_tb, result) insix.itervalues(conc.get_results()):<EOL><INDENT>if exc_value:<EOL><INDENT>raise exc_value<EOL><DEDENT><DEDENT>", "docstring": "Performs a GET on the container as a listing request.\n\nSee :py:mod:`swiftly.cli.get` for context usage information.\n\nSee :py:class:`CLIGet` for more information.", "id": "f8273:m1"}
{"signature": "def cli_help(context, command_name, general_parser, command_parsers):", "body": "if command_name == '<STR_LIT>':<EOL><INDENT>command_name = '<STR_LIT>'<EOL><DEDENT>with context.io_manager.with_stdout() as stdout:<EOL><INDENT>if not command_name:<EOL><INDENT>general_parser.print_help(stdout)<EOL><DEDENT>elif command_name in command_parsers:<EOL><INDENT>command_parsers[command_name].option_parser.print_help(stdout)<EOL><DEDENT>else:<EOL><INDENT>raise ReturnCode('<STR_LIT>' % command_name)<EOL><DEDENT><DEDENT>", "docstring": "Outputs help information.\n\nSee :py:mod:`swiftly.cli.help` for context usage information.\n\nSee :py:class:`CLIHelp` for more information.\n\n:param context: The :py:class:`swiftly.cli.context.CLIContext` to\n    use.\n:param command_name: The command_name to output help information\n    for, or set to None or an empty string to output the general\n    help information.\n:param general_parser: The\n    :py:class:`swiftly.cli.optionparser.OptionParser` for general\n    usage.\n:param command_parsers: A dict of (name, :py:class:`CLICommand`)\n    for specific command usage.", "id": "f8276:m0"}
{"signature": "def _stderr_filed(func):", "body": "def wrapper(self, msg, file=None):<EOL><INDENT>if file:<EOL><INDENT>return func(self, msg, file=file)<EOL><DEDENT>elif self.io_manager:<EOL><INDENT>with self.io_manager.with_stderr() as stderr:<EOL><INDENT>return func(self, msg, file=stderr)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return func(self, msg, file=sys.stderr)<EOL><DEDENT><DEDENT>wrapper.__doc__ = func.__doc__<EOL>return wrapper<EOL>", "docstring": "Instance method decorator to convert an optional file keyword\nargument into an actual value, whether it be a passed value, a\nvalue obtained from an io_manager, or sys.stderr.", "id": "f8281:m1"}
{"signature": "def get_stdout(self, os_path=None, skip_sub_command=False):", "body": "sub_command = None if skip_sub_command else self.stdout_sub_command<EOL>out, path = self._get_out_and_path(<EOL>self.stdout, self.stdout_root, sub_command, os_path)<EOL>if hasattr(out, '<STR_LIT>'):<EOL><INDENT>return out.stdin<EOL><DEDENT>return out<EOL>", "docstring": "Returns a stdout-suitable file-like object based on the\noptional os_path and optionally skipping any configured\nsub-command.", "id": "f8283:c0:m7"}
{"signature": "def get_stdin(self, os_path=None, skip_sub_command=False):", "body": "sub_command = None if skip_sub_command else self.stdin_sub_command<EOL>inn, path = self._get_in_and_path(<EOL>self.stdin, self.stdin_root, sub_command, os_path)<EOL>if hasattr(inn, '<STR_LIT>'):<EOL><INDENT>return inn.stdout<EOL><DEDENT>return inn<EOL>", "docstring": "Returns a stdin-suitable file-like object based on the\noptional os_path and optionally skipping any configured\nsub-command.", "id": "f8283:c0:m6"}
{"signature": "def join(self):", "body": "if self._pool:<EOL><INDENT>self._pool.waitall()<EOL><DEDENT>", "docstring": "Blocks until all currently pending functions have finished.", "id": "f8286:c0:m4"}
{"signature": "def get_location_observation(lat, lng, token):", "body": "req = requests.get(<EOL>API_ENDPOINT_GEO % (lat, lng),<EOL>params={<EOL>'<STR_LIT>': token<EOL>})<EOL>if req.status_code == <NUM_LIT:200> and req.json()[\"<STR_LIT:status>\"] == \"<STR_LIT>\":<EOL><INDENT>return parse_observation_response(req.json()[\"<STR_LIT:data>\"])<EOL><DEDENT>return {}<EOL>", "docstring": "Lookup observations by geo coordinates.", "id": "f8291:m1"}
{"signature": "def create_joining_subplan(<EOL>pipeline_def, solid, join_step_key, parallel_steps, parallel_step_output<EOL>):", "body": "check.inst_param(pipeline_def, '<STR_LIT>', PipelineDefinition)<EOL>check.inst_param(solid, '<STR_LIT>', Solid)<EOL>check.str_param(join_step_key, '<STR_LIT>')<EOL>check.list_param(parallel_steps, '<STR_LIT>', of_type=ExecutionStep)<EOL>check.str_param(parallel_step_output, '<STR_LIT>')<EOL>for parallel_step in parallel_steps:<EOL><INDENT>check.invariant(parallel_step.has_step_output(parallel_step_output))<EOL><DEDENT>join_step = create_join_step(<EOL>pipeline_def, solid, join_step_key, parallel_steps, parallel_step_output<EOL>)<EOL>output_name = join_step.step_outputs[<NUM_LIT:0>].name<EOL>return ExecutionValueSubplan(<EOL>parallel_steps + [join_step], StepOutputHandle.from_step(join_step, output_name)<EOL>)<EOL>", "docstring": "This captures a common pattern of fanning out a single value to N steps,\nwhere each step has similar structure. The strict requirement here is that each step\nmust provide an output named the parameters parallel_step_output.\n\nThis takes those steps and then uses a join node to coalesce them so that downstream\nsteps can depend on a single output.\n\nCurrently the join step just does a passthrough with no computation. It remains\nto be seen if there should be any work or verification done in this step, especially\nin multi-process environments that require persistence between steps.", "id": "f8357:m2"}
{"signature": "def as_dagster_type(<EOL>existing_type,<EOL>name=None,<EOL>description=None,<EOL>input_schema=None,<EOL>output_schema=None,<EOL>serialization_strategy=None,<EOL>storage_plugins=None,<EOL>):", "body": "check.type_param(existing_type, '<STR_LIT>')<EOL>check.opt_str_param(name, '<STR_LIT:name>')<EOL>check.opt_str_param(description, '<STR_LIT:description>')<EOL>check.opt_inst_param(input_schema, '<STR_LIT>', InputSchema)<EOL>check.opt_inst_param(output_schema, '<STR_LIT>', OutputSchema)<EOL>check.opt_inst_param(serialization_strategy, '<STR_LIT>', SerializationStrategy)<EOL>storage_plugins = check.opt_dict_param(storage_plugins, '<STR_LIT>')<EOL>if serialization_strategy is None:<EOL><INDENT>serialization_strategy = PickleSerializationStrategy()<EOL><DEDENT>name = existing_type.__name__ if name is None else name<EOL>return _decorate_as_dagster_type(<EOL>existing_type,<EOL>key=name,<EOL>name=name,<EOL>description=description,<EOL>input_schema=input_schema,<EOL>output_schema=output_schema,<EOL>serialization_strategy=serialization_strategy,<EOL>storage_plugins=storage_plugins,<EOL>)<EOL>", "docstring": "Takes a python cls and creates a type for it in the Dagster domain.\n\nArgs:\n    existing_type (cls)\n        The python type you want to project in to the Dagster type system.\n    name (Optional[str]):\n    description (Optiona[str]):\n    input_schema (Optional[InputSchema]):\n        An instance of a class that inherits from :py:class:`InputSchema` that\n        can map config data to a value of this type.\n\n    output_schema (Optiona[OutputSchema]):\n        An instance of a class that inherits from :py:class:`OutputSchema` that\n        can map config data to persisting values of this type.\n\n    serialization_strategy (Optional[SerializationStrategy]):\n        The default behavior for how to serialize this value for\n        persisting between execution steps.\n\n    storage_plugins (Optional[Dict[RunStorageMode, TypeStoragePlugin]]):\n        Storage type specific overrides for the serialization strategy.\n        This allows for storage specific optimzations such as effecient\n        distributed storage on S3.", "id": "f8366:m6"}
{"signature": "def output_schema(config_cls):", "body": "config_type = resolve_config_cls_arg(config_cls)<EOL>return lambda func: _create_output_schema(config_type, func)<EOL>", "docstring": "A decorator for a annotating a function that can take a ``config_value``\nand an instance of a custom type and materialize it.\n\nArgs:\n    config_cls (Any):", "id": "f8368:m6"}
{"signature": "def materialize_runtime_value(self, _context, _config_value, _runtime_value):", "body": "check.not_implemented('<STR_LIT>')<EOL>", "docstring": "How to materialize a runtime value given configuration.", "id": "f8368:c1:m1"}
{"signature": "def input_schema(config_cls):", "body": "config_type = resolve_config_cls_arg(config_cls)<EOL>return lambda func: _create_input_schema(config_type, func)<EOL>", "docstring": "A decorator for annotating a function that can turn a ``config_value`` in to\nan instance of a custom type.\n\nArgs:\n    config_cls (Any):", "id": "f8368:m3"}
{"signature": "def List(inner_type):", "body": "return WrappingListType(inner_type)<EOL>", "docstring": "Validates at runtime that the value is ``List[inner_type]``.\n\nArgs:\n    inner_type (DagsterType)", "id": "f8371:m0"}
{"signature": "def NamedSelector(name, fields, description=None, type_attributes=DEFAULT_TYPE_ATTRIBUTES):", "body": "check.str_param(name, '<STR_LIT:name>')<EOL>check_user_facing_fields_dict(fields, '<STR_LIT>'.format(name))<EOL>class _NamedSelector(_ConfigSelector):<EOL><INDENT>def __init__(self):<EOL><INDENT>super(_NamedSelector, self).__init__(<EOL>key=name,<EOL>name=name,<EOL>fields=fields,<EOL>description=description,<EOL>type_attributes=type_attributes,<EOL>)<EOL><DEDENT><DEDENT>return _NamedSelector<EOL>", "docstring": "A :py:class`Selector` with a name, allowing it to be referenced by that name.\n\nArgs:\n    name (str):\n    fields (Dict[str, Field])", "id": "f8375:m10"}
{"signature": "def Dict(fields):", "body": "check_user_facing_fields_dict(fields, '<STR_LIT>')<EOL>class _Dict(_ConfigComposite):<EOL><INDENT>def __init__(self):<EOL><INDENT>key = '<STR_LIT>' + str(DictCounter.get_next_count())<EOL>super(_Dict, self).__init__(<EOL>name=None,<EOL>key=key,<EOL>fields=fields,<EOL>description='<STR_LIT>',<EOL>type_attributes=ConfigTypeAttributes(is_builtin=True),<EOL>)<EOL><DEDENT><DEDENT>return _Dict<EOL>", "docstring": "Schema for configuration data with string keys and typed values via :py:class:`Field` .\n\nArgs:\n    fields (Dict[str, Field])", "id": "f8375:m7"}
{"signature": "def construct_json_event_logger(json_path):", "body": "check.str_param(json_path, '<STR_LIT>')<EOL>return construct_single_handler_logger(<EOL>\"<STR_LIT>\",<EOL>DEBUG,<EOL>JsonEventLoggerHandler(<EOL>json_path,<EOL>lambda record: construct_event_record(<EOL>StructuredLoggerMessage(<EOL>name=record.name,<EOL>message=record.msg,<EOL>level=record.levelno,<EOL>meta=record.dagster_meta,<EOL>record=record,<EOL>)<EOL>),<EOL>),<EOL>)<EOL>", "docstring": "Record a stream of event records to json", "id": "f8385:m3"}
{"signature": "@staticmethod<EOL><INDENT>def passthrough_context_definition(context_params):<DEDENT>", "body": "check.inst_param(context_params, '<STR_LIT>', ExecutionContext)<EOL>context_definition = PipelineContextDefinition(context_fn=lambda *_args: context_params)<EOL>return {DEFAULT_CONTEXT_NAME: context_definition}<EOL>", "docstring": "Create a context definition from a pre-existing context. This can be useful\n        in testing contexts where you may want to create a context manually and then\n        pass it into a one-off PipelineDefinition\n\n        Args:\n            context (ExecutionContext): The context that will provided to the pipeline.\n        Returns:\n            PipelineContextDefinition: The passthrough context definition.", "id": "f8392:c0:m0"}
{"signature": "@property<EOL><INDENT>def display_name(self):<DEDENT>", "body": "return self.name if self.name else '<STR_LIT>'<EOL>", "docstring": "Name suitable for exception messages, logging etc. If pipeline\n        is unnamed the method with return \"<<unnamed>>\".\n\n        Returns:\n            str: Display name of pipeline", "id": "f8395:c0:m1"}
{"signature": "def get_all_pipelines(self):", "body": "pipelines = list(map(self.get_pipeline, self.pipeline_dict.keys()))<EOL>self._construct_solid_defs(pipelines)<EOL>return pipelines<EOL>", "docstring": "Return all pipelines as a list\n\n        Returns:\n            List[PipelineDefinition]:", "id": "f8397:c0:m3"}
{"signature": "def lambda_solid(name=None, inputs=None, output=None, description=None):", "body": "output = output or OutputDefinition()<EOL>if callable(name):<EOL><INDENT>check.invariant(inputs is None)<EOL>check.invariant(description is None)<EOL>return _LambdaSolid(output=output)(name)<EOL><DEDENT>return _LambdaSolid(name=name, inputs=inputs, output=output, description=description)<EOL>", "docstring": "(decorator) Create a simple solid.\n\n    This shortcut allows the creation of simple solids that do not require\n    configuration and whose implementations do not require a context.\n\n    Lambda solids take inputs and produce a single output. The body of the function\n    should return a single value.\n\n    Args:\n        name (str): Name of solid.\n        inputs (list[InputDefinition]): List of inputs.\n        output (OutputDefinition): The output of the solid. Defaults to ``OutputDefinition()``.\n        description (str): Solid description.\n\n    Examples:\n\n        .. code-block:: python\n\n            @lambda_solid\n            def hello_world():\n                return 'hello'\n\n            @lambda_solid(inputs=[InputDefinition(name='foo')])\n            def hello_world(foo):\n                return foo", "id": "f8402:m0"}
{"signature": "def SystemNamedDict(name, fields, description=None):", "body": "return NamedDict(name, fields, description, ConfigTypeAttributes(is_system_config=True))<EOL>", "docstring": "A SystemNamedDict object is simply a NamedDict intended for internal (dagster) use.", "id": "f8404:m0"}
{"signature": "@contextmanager<EOL>def user_code_context_manager(user_fn, error_cls, msg):", "body": "check.callable_param(user_fn, '<STR_LIT>')<EOL>check.subclass_param(error_cls, '<STR_LIT>', DagsterUserCodeExecutionError)<EOL>with user_code_error_boundary(error_cls, msg):<EOL><INDENT>thing_or_gen = user_fn()<EOL>gen = _ensure_gen(thing_or_gen)<EOL>try:<EOL><INDENT>thing = next(gen)<EOL><DEDENT>except StopIteration:<EOL><INDENT>check.failed('<STR_LIT>')<EOL><DEDENT>yield thing<EOL>stopped = False<EOL>try:<EOL><INDENT>next(gen)<EOL><DEDENT>except StopIteration:<EOL><INDENT>stopped = True<EOL><DEDENT>check.invariant(stopped, '<STR_LIT>')<EOL><DEDENT>", "docstring": "Wraps the output of a user provided function that may yield or return a value and\n    returns a generator that asserts it only yields a single value.", "id": "f8406:m4"}
{"signature": "def execute_pipeline_iterator(pipeline, environment_dict=None, run_config=None):", "body": "check.inst_param(pipeline, '<STR_LIT>', PipelineDefinition)<EOL>environment_dict = check.opt_dict_param(environment_dict, '<STR_LIT>')<EOL>run_config = check_run_config_param(run_config)<EOL>environment_config = create_environment_config(pipeline, environment_dict)<EOL>intermediates_manager = construct_intermediates_manager(<EOL>run_config, environment_config, pipeline<EOL>)<EOL>with _pipeline_execution_context_manager(<EOL>pipeline, environment_config, run_config, intermediates_manager<EOL>) as pipeline_context:<EOL><INDENT>return _execute_pipeline_iterator(pipeline_context)<EOL><DEDENT>", "docstring": "Returns iterator that yields :py:class:`SolidExecutionResult` for each\n    solid executed in the pipeline.\n\n    This is intended to allow the caller to do things between each executed\n    node. For the 'synchronous' API, see :py:func:`execute_pipeline`.\n\n    Parameters:\n      pipeline (PipelineDefinition): Pipeline to run\n      environment_dict (dict): The enviroment configuration that parameterizes this run\n      run_config (RunConfig): Configuration for how this pipeline will be executed\n\n    Returns:\n      Iterator[DagsterEvent]", "id": "f8406:m15"}
{"signature": "@property<EOL><INDENT>def success(self):<DEDENT>", "body": "any_success = False<EOL>for step_event in itertools.chain(<EOL>self.input_expectations, self.output_expectations, self.transforms<EOL>):<EOL><INDENT>if step_event.event_type == DagsterEventType.STEP_FAILURE:<EOL><INDENT>return False<EOL><DEDENT>if step_event.event_type == DagsterEventType.STEP_SUCCESS:<EOL><INDENT>any_success = True<EOL><DEDENT><DEDENT>return any_success<EOL>", "docstring": "Whether the solid execution was successful", "id": "f8406:c1:m5"}
{"signature": "@property<EOL><INDENT>def skipped(self):<DEDENT>", "body": "return all(<EOL>[<EOL>step_event.event_type == DagsterEventType.STEP_SKIPPED<EOL>for step_event in itertools.chain(<EOL>self.input_expectations, self.output_expectations, self.transforms<EOL>)<EOL>]<EOL>)<EOL>", "docstring": "Whether the solid execution was skipped", "id": "f8406:c1:m6"}
{"signature": "def block(self, text, prefix='<STR_LIT>'):", "body": "wrapper = TextWrapper(<EOL>width=self.line_length - len(self.current_indent_str),<EOL>initial_indent=prefix,<EOL>subsequent_indent=prefix,<EOL>break_long_words=False,<EOL>break_on_hyphens=False,<EOL>)<EOL>for line in wrapper.wrap(text):<EOL><INDENT>self.line(line)<EOL><DEDENT>", "docstring": "Automagically wrap a block of text.", "id": "f8411:c0:m3"}
{"signature": "def dict_param(obj, param_name, key_type=None, value_type=None):", "body": "if not isinstance(obj, dict):<EOL><INDENT>raise_with_traceback(_param_type_mismatch_exception(obj, dict, param_name))<EOL><DEDENT>if not (key_type or value_type):<EOL><INDENT>return obj<EOL><DEDENT>return _check_key_value_types(obj, key_type, value_type)<EOL>", "docstring": "Ensures argument obj is a native Python dictionary, raises an exception if not, and otherwise\n    returns obj.", "id": "f8427:m36"}
{"signature": "def opt_dict_param(obj, param_name, key_type=None, value_type=None, value_class=None):", "body": "if obj is not None and not isinstance(obj, dict):<EOL><INDENT>raise_with_traceback(_param_type_mismatch_exception(obj, dict, param_name))<EOL><DEDENT>if not obj:<EOL><INDENT>return {}<EOL><DEDENT>if value_class:<EOL><INDENT>return _check_key_value_types(obj, key_type, value_type=value_class, value_check=issubclass)<EOL><DEDENT>return _check_key_value_types(obj, key_type, value_type)<EOL>", "docstring": "Ensures argument obj is either a dictionary or None; if the latter, instantiates an empty\n    dictionary.", "id": "f8427:m37"}
{"signature": "def define_spark_config():", "body": "master_url = Field(<EOL>String,<EOL>description='<STR_LIT>',<EOL>is_optional=False,<EOL>)<EOL>deploy_mode = Field(<EOL>SparkDeployMode,<EOL>description='''<STR_LIT>''',<EOL>is_optional=True,<EOL>)<EOL>application_jar = Field(<EOL>Path,<EOL>description='''<STR_LIT>''',<EOL>is_optional=False,<EOL>)<EOL>application_arguments = Field(<EOL>String,<EOL>description='<STR_LIT>',<EOL>is_optional=True,<EOL>)<EOL>spark_home = Field(<EOL>String,<EOL>description='<STR_LIT>',<EOL>is_optional=True,<EOL>)<EOL>spark_outputs = Field(List(String), description='<STR_LIT>')<EOL>return Field(<EOL>Dict(<EOL>fields={<EOL>'<STR_LIT>': master_url,<EOL>'<STR_LIT>': deploy_mode,<EOL>'<STR_LIT>': application_jar,<EOL>'<STR_LIT>': spark_config(),<EOL>'<STR_LIT>': spark_home,<EOL>'<STR_LIT>': application_arguments,<EOL>'<STR_LIT>': spark_outputs,<EOL>}<EOL>)<EOL>)<EOL>", "docstring": "Spark configuration.\n\n    See the Spark documentation for reference:\n        https://spark.apache.org/docs/latest/submitting-applications.html", "id": "f8532:m0"}
{"signature": "def define_bigquery_query_config():", "body": "sf = _define_shared_fields()<EOL>allow_large_results = Field(<EOL>Bool,<EOL>description='''<STR_LIT>''',<EOL>is_optional=True,<EOL>)<EOL>default_dataset = Field(<EOL>Dataset,<EOL>description='''<STR_LIT>''',<EOL>is_optional=True,<EOL>)<EOL>destination = Field(<EOL>Table,<EOL>description='''<STR_LIT>''',<EOL>is_optional=True,<EOL>)<EOL>dry_run = Field(<EOL>Bool,<EOL>description='''<STR_LIT>''',<EOL>is_optional=True,<EOL>)<EOL>flatten_results = Field(<EOL>Bool,<EOL>description='''<STR_LIT>''',<EOL>is_optional=True,<EOL>)<EOL>maximum_billing_tier = Field(<EOL>Int,<EOL>description='''<STR_LIT>''',<EOL>is_optional=True,<EOL>)<EOL>maximum_bytes_billed = Field(<EOL>Int,<EOL>description='''<STR_LIT>''',<EOL>is_optional=True,<EOL>)<EOL>priority = Field(<EOL>BQPriority,<EOL>description='''<STR_LIT>''',<EOL>is_optional=True,<EOL>)<EOL>query_parameters = Field(<EOL>List(String),<EOL>description='''<STR_LIT>''',<EOL>is_optional=True,<EOL>)<EOL>use_legacy_sql = Field(<EOL>Bool,<EOL>description='''<STR_LIT>''',<EOL>is_optional=True,<EOL>)<EOL>use_query_cache = Field(<EOL>Bool,<EOL>description='''<STR_LIT>''',<EOL>is_optional=True,<EOL>)<EOL>return Field(<EOL>Dict(<EOL>fields={<EOL>'<STR_LIT>': Field(<EOL>Dict(<EOL>fields={<EOL>'<STR_LIT>': allow_large_results,<EOL>'<STR_LIT>': sf['<STR_LIT>'],<EOL>'<STR_LIT>': sf['<STR_LIT>'],<EOL>'<STR_LIT>': default_dataset,<EOL>'<STR_LIT>': destination,<EOL>'<STR_LIT>': sf[<EOL>'<STR_LIT>'<EOL>],<EOL>'<STR_LIT>': dry_run,<EOL>'<STR_LIT>': flatten_results,<EOL>'<STR_LIT>': maximum_billing_tier,<EOL>'<STR_LIT>': maximum_bytes_billed,<EOL>'<STR_LIT>': priority,<EOL>'<STR_LIT>': query_parameters,<EOL>'<STR_LIT>': sf['<STR_LIT>'],<EOL>'<STR_LIT>': sf['<STR_LIT>'],<EOL>'<STR_LIT>': use_legacy_sql,<EOL>'<STR_LIT>': use_query_cache,<EOL>'<STR_LIT>': sf['<STR_LIT>'],<EOL>}<EOL>)<EOL>)<EOL>}<EOL>),<EOL>description='<STR_LIT>',<EOL>)<EOL>", "docstring": "See:\n    https://googleapis.github.io/google-cloud-python/latest/bigquery/generated/google.cloud.bigquery.job.QueryJobConfig.html", "id": "f8539:m2"}
{"signature": "def _is_valid_table(config_value):", "body": "return re.match(<EOL>r'<STR_LIT>'<EOL>+ RE_PROJECT  <EOL>+ r'<STR_LIT>'  <EOL>+ RE_DS_TABLE  <EOL>+ r'<STR_LIT>'  <EOL>+ RE_DS_TABLE  <EOL>+ r'<STR_LIT>'  <EOL>+ RE_DS_TABLE  <EOL>+ r'<STR_LIT>'  <EOL>+ RE_DS_TABLE  <EOL>+ r'<STR_LIT:$>',<EOL>config_value,<EOL>)<EOL>", "docstring": "Tables must be of form \"project.dataset.table\" or \"dataset.table\"", "id": "f8541:m1"}
{"signature": "def format_config_for_graphql(config):", "body": "def _format_config_subdict(config, current_indent=<NUM_LIT:0>):<EOL><INDENT>check.dict_param(config, '<STR_LIT>', key_type=str)<EOL>printer = IndentingStringIoPrinter(indent_level=<NUM_LIT:2>, current_indent=current_indent)<EOL>printer.line('<STR_LIT:{>')<EOL>n_elements = len(config)<EOL>for i, key in enumerate(sorted(config, key=lambda x: x[<NUM_LIT:0>])):<EOL><INDENT>value = config[key]<EOL>with printer.with_indent():<EOL><INDENT>formatted_value = (<EOL>_format_config_item(value, current_indent=printer.current_indent)<EOL>.lstrip('<STR_LIT:U+0020>')<EOL>.rstrip('<STR_LIT:\\n>')<EOL>)<EOL>printer.line(<EOL>'<STR_LIT>'.format(<EOL>key=key,<EOL>formatted_value=formatted_value,<EOL>comma='<STR_LIT:U+002C>' if i != n_elements - <NUM_LIT:1> else '<STR_LIT>',<EOL>)<EOL>)<EOL><DEDENT><DEDENT>printer.line('<STR_LIT:}>')<EOL>return printer.read()<EOL><DEDENT>def _format_config_sublist(config, current_indent=<NUM_LIT:0>):<EOL><INDENT>printer = IndentingStringIoPrinter(indent_level=<NUM_LIT:2>, current_indent=current_indent)<EOL>printer.line('<STR_LIT:[>')<EOL>n_elements = len(config)<EOL>for i, value in enumerate(config):<EOL><INDENT>with printer.with_indent():<EOL><INDENT>formatted_value = (<EOL>_format_config_item(value, current_indent=printer.current_indent)<EOL>.lstrip('<STR_LIT:U+0020>')<EOL>.rstrip('<STR_LIT:\\n>')<EOL>)<EOL>printer.line(<EOL>'<STR_LIT>'.format(<EOL>formatted_value=formatted_value, comma='<STR_LIT:U+002C>' if i != n_elements - <NUM_LIT:1> else '<STR_LIT>'<EOL>)<EOL>)<EOL><DEDENT><DEDENT>printer.line('<STR_LIT:]>')<EOL>return printer.read()<EOL><DEDENT>def _format_config_item(config, current_indent=<NUM_LIT:0>):<EOL><INDENT>printer = IndentingStringIoPrinter(indent_level=<NUM_LIT:2>, current_indent=current_indent)<EOL>if isinstance(config, dict):<EOL><INDENT>return _format_config_subdict(config, printer.current_indent)<EOL><DEDENT>elif isinstance(config, list):<EOL><INDENT>return _format_config_sublist(config, printer.current_indent)<EOL><DEDENT>elif isinstance(config, bool):<EOL><INDENT>return repr(config).lower()<EOL><DEDENT>else:<EOL><INDENT>return repr(config).replace('<STR_LIT>', '<STR_LIT:\">')<EOL><DEDENT><DEDENT>check.dict_param(config, '<STR_LIT>', key_type=str)<EOL>if not isinstance(config, dict):<EOL><INDENT>check.failed('<STR_LIT>'.format(item=repr(config)))<EOL><DEDENT>return _format_config_subdict(config)<EOL>", "docstring": "This recursive descent thing formats a config dict for GraphQL.", "id": "f8590:m0"}
{"signature": "@cli.command()<EOL>@click.argument('<STR_LIT:version>')<EOL>def release(version):", "body": "check_new_version(version)<EOL>set_new_version(version)<EOL>commit_new_version(version)<EOL>set_git_tag(version)<EOL>", "docstring": "Tags all submodules for a new release.\n\n    Ensures that git tags, as well as the version.py files in each submodule, agree and that the\n    new version is strictly greater than the current version. Will fail if the new version\n    is not an increment (following PEP 440). Creates a new git tag and commit.", "id": "f8612:m28"}
{"signature": "def which_(exe):", "body": "<EOL>return spawn.find_executable(exe)<EOL>", "docstring": "Uses distutils to look for an executable, mimicking unix which", "id": "f8612:m1"}
{"signature": "def read_config(path):", "body": "config = configparser.ConfigParser()<EOL>config.read(path)<EOL>return config<EOL>", "docstring": "Make a config parser for the given config file.\n\n    Return a :class:`configparser.ConfigParser` instance with the given file\n    loaded.\n\n    :param path:\n        Path to the config file to read.", "id": "f8613:m0"}
{"signature": "def get_repository_config(self, repository):", "body": "servers = self._read_index_servers()<EOL>repo_config = self._find_repo_config(servers, repository)<EOL>return repo_config<EOL>", "docstring": "Get config dictionary for the given repository.\n\n        If the repository section is not found in the config file,\n        return ``None``.  If the file is invalid, raise\n        :exc:`configparser.Error`.\n\n        Otherwise return a dictionary with:\n\n        * ``'repository'`` -- the repository URL\n        * ``'username'`` -- username for authentication\n        * ``'password'`` -- password for authentication\n\n        :param repository:\n            Name or URL of the repository to find in the ``.pypirc`` file.\n            The repository section must be defined in the config file.", "id": "f8613:c1:m2"}
{"signature": "def mkdir_p(newdir, mode=<NUM_LIT>):", "body": "try:<EOL><INDENT>os.makedirs(newdir, mode)<EOL><DEDENT>except OSError as err:<EOL><INDENT>if err.errno != errno.EEXIST or not os.path.isdir(newdir):<EOL><INDENT>raise<EOL><DEDENT><DEDENT>", "docstring": "The missing mkdir -p functionality in os.", "id": "f8619:m0"}
{"signature": "@solid(<EOL>name='<STR_LIT>',<EOL>config_field=Field(<EOL>Dict(<EOL>fields={<EOL>'<STR_LIT>': Field(String, description='<STR_LIT>'),<EOL>'<STR_LIT:key>': Field(String, description='<STR_LIT>'),<EOL>'<STR_LIT>': Field(<EOL>Any,  <EOL>description='<STR_LIT>',<EOL>is_optional=True,<EOL>),<EOL>}<EOL>)<EOL>),<EOL>inputs=[InputDefinition('<STR_LIT>', Bytes, description='<STR_LIT>')],<EOL>description='<STR_LIT>',<EOL>outputs=[<EOL>OutputDefinition(<EOL>String, description='<STR_LIT>', name='<STR_LIT>'<EOL>),<EOL>OutputDefinition(String, description='<STR_LIT>', name='<STR_LIT:key>'),<EOL>],<EOL>)<EOL>def upload_to_s3(context, file_obj):", "body": "bucket = context.solid_config['<STR_LIT>']<EOL>key = context.solid_config['<STR_LIT:key>']<EOL>context.resources.s3.put_object(<EOL>Bucket=bucket, Body=file_obj.read(), Key=key, **(context.solid_config.get('<STR_LIT>') or {})<EOL>)<EOL>yield Result(bucket, '<STR_LIT>')<EOL>yield Result(key, '<STR_LIT:key>')<EOL>", "docstring": "Upload a file to s3.\n\n    Args:\n        info (ExpectationExecutionInfo): Must expose a boto3 S3 client as its `s3` resource.\n\n    Returns:\n        (str, str):\n            The bucket and key to which the file was uploaded.", "id": "f8620:m4"}
{"signature": "def nonce_solid(name, n_inputs, n_outputs):", "body": "@solid(<EOL>name=name,<EOL>inputs=[<EOL>InputDefinition(name='<STR_LIT>'.format(i)) for i in range(n_inputs)<EOL>],<EOL>outputs=[<EOL>OutputDefinition(name='<STR_LIT>'.format(i))<EOL>for i in range(n_outputs)<EOL>],<EOL>)<EOL>def solid_fn(context, **_kwargs):<EOL><INDENT>for i in range(<NUM_LIT:200>):<EOL><INDENT>time.sleep(<NUM_LIT>)<EOL>if i % <NUM_LIT:1000> == <NUM_LIT>:<EOL><INDENT>context.log.error(<EOL>'<STR_LIT>'.format(<EOL>i=i, name=name<EOL>)<EOL>)<EOL><DEDENT>elif i % <NUM_LIT:100> == <NUM_LIT:0>:<EOL><INDENT>context.log.warning(<EOL>'<STR_LIT>'.format(<EOL>i=i, name=name<EOL>)<EOL>)<EOL><DEDENT>elif i % <NUM_LIT:10> == <NUM_LIT:0>:<EOL><INDENT>context.log.info(<EOL>'<STR_LIT>'.format(<EOL>i=i, name=name<EOL>)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>context.log.debug(<EOL>'<STR_LIT>'.format(<EOL>i=i, name=name<EOL>)<EOL>)<EOL><DEDENT><DEDENT>return MultipleResults.from_dict(<EOL>{'<STR_LIT>'.format(i): '<STR_LIT:foo>' for i in range(n_outputs)}<EOL>)<EOL><DEDENT>return solid_fn<EOL>", "docstring": "Creates a solid with the given number of (meaningless) inputs and outputs.\n\n    Config controls the behavior of the nonce solid.", "id": "f8629:m0"}
{"signature": "def computeContribs(urls, rank):", "body": "num_urls = len(urls)<EOL>for url in urls:<EOL><INDENT>yield (url, rank / num_urls)<EOL><DEDENT>", "docstring": "Calculates URL contributions to the rank of other URLs.", "id": "f8640:m3"}
{"signature": "def parseNeighbors(urls):", "body": "parts = re.split(r'<STR_LIT>', urls)<EOL>return parts[<NUM_LIT:0>], parts[<NUM_LIT:1>]<EOL>", "docstring": "Parses a urls pair string into urls pair.", "id": "f8640:m0"}
{"signature": "def computeContribs(urls, rank):", "body": "num_urls = len(urls)<EOL>for url in urls:<EOL><INDENT>yield (url, rank / num_urls)<EOL><DEDENT>", "docstring": "Calculates URL contributions to the rank of other URLs.", "id": "f8641:m0"}
{"signature": "def parseNeighbors(urls):", "body": "parts = re.split(r'<STR_LIT>', urls)<EOL>return parts[<NUM_LIT:0>], parts[<NUM_LIT:1>]<EOL>", "docstring": "Parses a urls pair string into urls pair.", "id": "f8642:m0"}
{"signature": "def computeContribs(urls, rank):", "body": "num_urls = len(urls)<EOL>for url in urls:<EOL><INDENT>yield (url, rank / num_urls)<EOL><DEDENT>", "docstring": "Calculates URL contributions to the rank of other URLs.", "id": "f8644:m0"}
{"signature": "def list(self):", "body": "return list(<EOL>filter(<EOL>lambda x: x.get('<STR_LIT:type>') != '<STR_LIT>',  <EOL>self._post(<EOL>request=ApiActions.LIST.value,<EOL>uri=ApiUri.ACTIONS.value,<EOL>).get('<STR_LIT>')<EOL>)<EOL>)<EOL>", "docstring": "Get all current alerts\n\n:return: All alerts\n:rtype: list of dict\n\n:raises: This will raise a\n    :class:`ServerException<logentries_api.exceptions.ServerException>`\n    if there is an error from Logentries", "id": "f8650:c6:m1"}
{"signature": "def create(self,<EOL>alert_config,<EOL>occurrence_frequency_count=None,<EOL>occurrence_frequency_unit=None,<EOL>alert_frequency_count=None,<EOL>alert_frequency_unit=None):", "body": "data = {<EOL>'<STR_LIT>': occurrence_frequency_count or <NUM_LIT:1>,<EOL>'<STR_LIT>': occurrence_frequency_unit or '<STR_LIT>',<EOL>'<STR_LIT>': alert_frequency_count or <NUM_LIT:1>,<EOL>'<STR_LIT>': alert_frequency_unit or '<STR_LIT>',<EOL>'<STR_LIT>': [],<EOL>'<STR_LIT>': True,<EOL>}<EOL>data.update(alert_config.args())<EOL>return self._post(<EOL>request=ApiActions.CREATE.value,<EOL>uri=ApiUri.ACTIONS.value,<EOL>params=data<EOL>)<EOL>", "docstring": "Create a new alert\n\n:param alert_config: A list of AlertConfig classes (Ex:\n    ``[EmailAlertConfig('me@mydomain.com')]``)\n:type alert_config: list of\n    :class:`PagerDutyAlertConfig<logentries_api.alerts.PagerDutyAlertConfig>`,\n    :class:`WebHookAlertConfig<logentries_api.alerts.WebHookAlertConfig>`,\n    :class:`EmailAlertConfig<logentries_api.alerts.EmailAlertConfig>`,\n    :class:`SlackAlertConfig<logentries_api.alerts.SlackAlertConfig>`, or\n    :class:`HipChatAlertConfig<logentries_api.alerts.HipChatAlertConfig>`\n\n:param occurrence_frequency_count: How many times per\n    ``alert_frequency_unit`` for a match before issuing an alert.\n    Defaults to 1\n:type occurrence_frequency_count: int\n\n:param occurrence_frequency_unit: The time period to monitor for sending\n    an alert. Must be 'day', or 'hour'. Defaults to 'hour'\n:type occurrence_frequency_unit: str\n\n:param alert_frequency_count: How many times per\n    ``alert_frequency_unit`` to issue an alert. Defaults to 1\n:type alert_frequency_count: int\n\n:param alert_frequency_unit: How often to regulate sending alerts.\n    Must be 'day', or 'hour'. Defaults to 'hour'\n:type alert_frequency_unit: str\n\n:returns: The response of your post\n:rtype: dict\n\n:raises: This will raise a\n    :class:`ServerException<logentries_api.exceptions.ServerException>`\n    if there is an error from Logentries", "id": "f8650:c6:m0"}
{"signature": "def update(self, alert):", "body": "data = {<EOL>'<STR_LIT:id>': alert['<STR_LIT:id>'],<EOL>'<STR_LIT:args>': alert['<STR_LIT:args>'],<EOL>'<STR_LIT>': alert['<STR_LIT>'],<EOL>'<STR_LIT>': alert['<STR_LIT>'],<EOL>'<STR_LIT>': alert['<STR_LIT>'],<EOL>'<STR_LIT>': alert['<STR_LIT>'],<EOL>'<STR_LIT>': alert['<STR_LIT>'],<EOL>'<STR_LIT>': alert['<STR_LIT>'],<EOL>'<STR_LIT:type>': alert['<STR_LIT:type>'],<EOL>}<EOL>return self._post(<EOL>request=ApiActions.UPDATE.value,<EOL>uri=ApiUri.ACTIONS.value,<EOL>params=data<EOL>)<EOL>", "docstring": "Update an alert\n\n:param alert: The data to update. Must include keys:\n\n    * id (str)\n    * rate_count (int)\n    * rate_range (str): 'day' or 'hour'\n    * limit_count (int)\n    * limit_range (str): 'day' or 'hour'\n    * type (str)\n    * schedule (list)\n    * args (dict)\n:type alert: dict\n\nExample:\n\n.. code-block:: python\n\n    Alert().update(\n        alert={\n            'id': 'd9d4596e-49e4-4135-b3b3-847f9e7c1f43',\n            'args': {'direct': 'you@example.com'},\n            'rate_count': 1,\n            'rate_range': 'hour',\n            'limit_count': 1,\n            'limit_range': 'hour',\n            'schedule': [],\n            'enabled': True,\n            'type': 'mailto',\n        }\n    )\n\n:return:\n:rtype: dict", "id": "f8650:c6:m3"}
{"signature": "def delete(self, id):", "body": "return self._post(<EOL>request=ApiActions.DELETE.value,<EOL>uri=ApiUri.ACTIONS.value,<EOL>params={'<STR_LIT:id>': id}<EOL>)<EOL>", "docstring": "Delete the specified alert\n\n:param id: the alert's ID\n:type id: str\n\n:raises: This will raise a\n    :class:`ServerException<logentries_api.exceptions.ServerException>`\n    if there is an error from Logentries", "id": "f8650:c6:m4"}
{"signature": "def list(self):", "body": "return self._post(<EOL>request='<STR_LIT:list>',<EOL>uri=ApiUri.TAGS.value,<EOL>).get('<STR_LIT>')<EOL>", "docstring": "Get all current labels\n\n:return: The Logentries API response\n:rtype: list of dict\n\n:raises: This will raise a\n    :class:`ServerException<logentries_api.exceptions.ServerException>`\n    if there is an error from Logentries", "id": "f8650:c3:m1"}
{"signature": "def delete(self, tag_id):", "body": "tag_url = '<STR_LIT>'<EOL>self._api_delete(<EOL>url=tag_url.format(<EOL>account_id=self.account_id,<EOL>tag_id=tag_id<EOL>)<EOL>)<EOL>", "docstring": "Delete the specified InactivityAlert\n\n:param tag_id: The tag ID to delete\n:type tag_id: str\n\n:raises: This will raise a\n    :class:`ServerException <logentries_api.exceptions.ServerException>`\n    if there is an error from Logentries", "id": "f8658:c3:m1"}
{"signature": "def create(self,<EOL>name,<EOL>query,<EOL>scope_count,<EOL>scope_unit,<EOL>increase_positive,<EOL>percentage_change,<EOL>trigger_config,<EOL>logs,<EOL>alert_reports):", "body": "change = '<STR_LIT>'.format(<EOL>pos='<STR_LIT:+>' if increase_positive else '<STR_LIT:->',<EOL>change=str(percentage_change)<EOL>)<EOL>query_response = self._create_scheduled_query(<EOL>query=query,<EOL>change=change,<EOL>scope_unit=scope_unit,<EOL>scope_count=scope_count,<EOL>)<EOL>scheduled_query_id = query_response.get('<STR_LIT>', {}).get('<STR_LIT:id>')<EOL>tag_data = {<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': [<EOL>alert_report.to_dict()<EOL>for alert_report<EOL>in alert_reports<EOL>],<EOL>'<STR_LIT:name>': name,<EOL>'<STR_LIT>': scheduled_query_id,<EOL>'<STR_LIT>': [<EOL>{'<STR_LIT:id>': log}<EOL>for log<EOL>in logs<EOL>],<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:type>': '<STR_LIT>'<EOL>}<EOL>}<EOL>tag_data['<STR_LIT>'].update(trigger_config.to_dict())<EOL>tag_url = '<STR_LIT>'.format(<EOL>account_id=self.account_id<EOL>)<EOL>return self._api_post(<EOL>url=tag_url,<EOL>data=json.dumps(tag_data, sort_keys=True),<EOL>)<EOL>", "docstring": "Create an anomaly alert. This call makes 2 requests, one to create a\n\"scheduled_query\", and another to create the alert.\n\n:param name: The name for the alert\n:type name: str\n\n:param query: The `LEQL`_ query to use for detecting anomalies. Must\n    result in a numerical value, so it should look something like\n    ``where(...) calculate(COUNT)``\n:type query: str\n\n:param scope_count: How many ``scope_unit`` s to inspect for detecting\n    an anomaly\n:type scope_count: int\n\n:param scope_unit: How far to look back in detecting an anomaly. Must\n    be one of \"hour\", \"day\", or \"week\"\n:type scope_unit: str\n\n:param increase_positive: Detect a positive increase for the anomaly. A\n    value of ``False`` results in detecting a decrease for the anomaly.\n:type increase_positive: bool\n\n:param percentage_change: The percentage of change to detect. Must be a\n    number between 0 and 100 (inclusive).\n:type percentage_change: int\n\n:param trigger_config: A AlertTriggerConfig describing how far back to\n    look back to compare to the anomaly scope.\n:type trigger_config: :class:`AlertTriggerConfig<logentries_api.special_alerts.AlertTriggerConfig>`\n\n:param logs: A list of log UUID's. (The 'key' key of a log)\n:type logs: list of str\n\n:param alert_reports: A list of AlertReportConfig to send alerts to\n:type alert_reports: list of\n    :class:`AlertReportConfig<logentries_api.special_alerts.AlertReportConfig>`\n\n:return: The API response of the alert creation\n:rtype: dict\n\n:raises: This will raise a\n    :class:`ServerException <logentries_api.exceptions.ServerException>`\n    if there is an error from Logentries\n\n.. _Leql: https://blog.logentries.com/2015/06/introducing-leql/", "id": "f8658:c4:m1"}
{"signature": "def create(self, name, patterns, logs, trigger_config, alert_reports):", "body": "data = {<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': [<EOL>alert_report.to_dict()<EOL>for alert_report<EOL>in alert_reports<EOL>],<EOL>'<STR_LIT:name>': name,<EOL>'<STR_LIT>': patterns,<EOL>'<STR_LIT>': [<EOL>{'<STR_LIT:id>': log}<EOL>for log<EOL>in logs<EOL>],<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:type>': '<STR_LIT>'<EOL>}<EOL>}<EOL>data['<STR_LIT>'].update(trigger_config.to_dict())<EOL>return self._api_post(<EOL>url=self.url_template.format(account_id=self.account_id),<EOL>data=json.dumps(data, sort_keys=True)<EOL>)<EOL>", "docstring": "Create an inactivity alert\n\n:param name: A name for the inactivity alert\n:type name: str\n\n:param patterns: A list of regexes to match\n:type patterns: list of str\n\n:param logs: A list of log UUID's. (The 'key' key of a log)\n:type logs: list of str\n\n:param trigger_config: A AlertTriggerConfig describing how far back to\n    look for inactivity.\n:type trigger_config: :class:`AlertTriggerConfig<logentries_api.special_alerts.AlertTriggerConfig>`\n\n:param alert_reports: A list of AlertReportConfigs to send alerts to\n:type alert_reports: list of\n    :class:`AlertReportConfig<logentries_api.special_alerts.AlertReportConfig>`\n\n:return: The API response\n:rtype: dict\n\n:raises: This will raise a\n    :class:`ServerException<logentries_api.exceptions.ServerException>`\n    if there is an error from Logentries", "id": "f8658:c3:m0"}
{"signature": "def _create_scheduled_query(self, query, change, scope_unit, scope_count):", "body": "query_data = {<EOL>'<STR_LIT>': {<EOL>'<STR_LIT:name>': '<STR_LIT>',<EOL>'<STR_LIT>': query,<EOL>'<STR_LIT>': '<STR_LIT:%>',<EOL>'<STR_LIT>': change,<EOL>'<STR_LIT>': scope_unit.title(),<EOL>'<STR_LIT>': scope_count,<EOL>}<EOL>}<EOL>query_url = '<STR_LIT>'<EOL>return self._api_post(<EOL>url=query_url.format(account_id=self.account_id),<EOL>data=json.dumps(query_data, sort_keys=True)<EOL>)<EOL>", "docstring": "Create the scheduled query", "id": "f8658:c4:m0"}
{"signature": "def _post(self, request, uri, params=None):", "body": "request_data = {<EOL>'<STR_LIT>': self.account_key,<EOL>'<STR_LIT>': self.account_key,<EOL>'<STR_LIT>': request,<EOL>}<EOL>request_data.update(params or {})<EOL>response = requests.post(<EOL>url='<STR_LIT>'.format(uri),<EOL>headers=self.headers,<EOL>data=json.dumps(request_data)<EOL>)<EOL>if not response.ok:<EOL><INDENT>raise ServerException(<EOL>'<STR_LIT>'.format(response.status_code, response.text))<EOL><DEDENT>return response.json()<EOL>", "docstring": "A wrapper for posting things.\n\n:param request: The request type. Must be one of the\n    :class:`ApiActions<logentries_api.base.ApiActions>`\n:type request: str\n\n:param uri: The API endpoint to hit. Must be one of\n    :class:`ApiUri<logentries_api.base.ApiUri>`\n:type uri: str\n\n:param params: A dictionary of supplemental kw args\n:type params: dict\n\n:returns: The response of your post\n:rtype: dict\n\n:raises: This will raise a\n    :class:`ServerException<logentries_api.exceptions.ServerException>`\n    if there is an error from Logentries", "id": "f8659:c2:m2"}
{"signature": "def args(self):", "body": "return {<EOL>'<STR_LIT:args>': {<EOL>'<STR_LIT>': self.address,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'<EOL>},<EOL>'<STR_LIT:type>': AlertTypes.EMAIL.value<EOL>}<EOL>", "docstring": ":rtype: dict", "id": "f8660:c3:m1"}
{"signature": "def __init__(self, url):", "body": "super(WebHookAlertConfig, self).__init__(url=url)<EOL>", "docstring": "Requires a 'url' parameter", "id": "f8660:c4:m0"}
{"signature": "@abstractmethod<EOL><INDENT>def args(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Must return a dictionary with an `args` for the alert, and a `type` key\nwith the type\n:rtype: dict", "id": "f8660:c1:m1"}
{"signature": "def __init__(self, address):", "body": "super(EmailAlertConfig, self).__init__(address=address)<EOL>", "docstring": "Requires an 'address' parameter", "id": "f8660:c3:m0"}
{"signature": "def args(self):", "body": "return {<EOL>'<STR_LIT:args>': {<EOL>'<STR_LIT:url>': self.url,<EOL>},<EOL>'<STR_LIT:type>': AlertTypes.SLACK.value<EOL>}<EOL>", "docstring": ":rtype: dict", "id": "f8660:c5:m1"}
{"signature": "def list(self):", "body": "response = requests.get(self.base_url)<EOL>if not response.ok:<EOL><INDENT>raise ServerException(<EOL>'<STR_LIT>'.format(response.status_code, response.text))<EOL><DEDENT>return {<EOL>host.get('<STR_LIT:name>'): [<EOL>log.get('<STR_LIT:key>')<EOL>for log<EOL>in host.get('<STR_LIT>')]<EOL>for host<EOL>in response.json().get('<STR_LIT:list>')<EOL>}<EOL>", "docstring": "Get all log sets\n\n:return: Returns a dictionary where the key is the hostname or log set,\n    and the value is a list of the log keys\n:rtype: dict\n\n:raises: This will raise a\n    :class:`ServerException<logentries_api.exceptions.ServerException>`\n    if there is an error from Logentries", "id": "f8662:c0:m1"}
{"signature": "def register(name, impl):", "body": "_implementations[name] = impl<EOL>", "docstring": "Register your own implementation,\n    it also override registered implementation without any check.", "id": "f8676:m0"}
{"signature": "def serializer(codec):", "body": "formats = {'<STR_LIT>': json,<EOL>'<STR_LIT>': pickle,<EOL>'<STR_LIT>': Storable}<EOL>return formats[codec]<EOL>", "docstring": "Create a serializer that support loads/dumps methods.\njson and pickle are fully supported.\nstorable support read only.", "id": "f8677:m0"}
{"signature": "def save_session(self, request=None, response=None):", "body": "if not self._session_key:<EOL><INDENT>return<EOL><DEDENT>if self._session_data is None:  <EOL><INDENT>self.client.delete(self._session_key)<EOL>return<EOL><DEDENT>self.client.set(self._session_key, self._session_data)<EOL>", "docstring": "Save the session in the key value store, in case a session\n        has been found", "id": "f8679:c1:m2"}
{"signature": "def update_session_token(self, header_name, value):", "body": "if self._session_key:<EOL><INDENT>self.client.delete(self._session_key)<EOL><DEDENT>self._session_key = '<STR_LIT>' % (header_name, value)<EOL>", "docstring": "Create a session from the givent header name", "id": "f8679:c1:m1"}
{"signature": "def add_timestamp(logger_class, log_method, event_dict):", "body": "event_dict['<STR_LIT>'] = calendar.timegm(time.gmtime())<EOL>return event_dict<EOL>", "docstring": "Attach the event time, as unix epoch", "id": "f8687:m1"}
{"signature": "def add_unique_id(logger_class, log_method, event):", "body": "event['<STR_LIT:id>'] = dna.utils.generate_unique_id()<EOL>return event<EOL>", "docstring": "Attach a unique id per event", "id": "f8687:m0"}
{"signature": "def requires_basic_auth(resource):", "body": "@functools.wraps(resource)<EOL>def decorated(*args, **kwargs):<EOL><INDENT>'''<STR_LIT>'''<EOL>auth = flask.request.authorization<EOL>user = check_credentials(auth.username, auth.password)<EOL>if not auth or user is None:<EOL><INDENT>log.warn('<STR_LIT>', credentials=auth)<EOL>return auth_failed()<EOL><DEDENT>log.info('<STR_LIT>', credentials=auth)<EOL>flask.g.user = user<EOL>return resource(*args, **kwargs)<EOL><DEDENT>return decorated<EOL>", "docstring": "Flask decorator protecting ressources using username/password scheme", "id": "f8692:m3"}
{"signature": "def auth_failed():", "body": "return flask.Response(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>', <NUM_LIT>,<EOL>{'<STR_LIT>': '<STR_LIT>'})<EOL>", "docstring": "Sends a 401 response", "id": "f8692:m2"}
{"signature": "def check_token(token):", "body": "user = models.User.objects(api_key=token).first()<EOL>return user or None<EOL>", "docstring": "Verify http header token authentification", "id": "f8692:m1"}
{"signature": "def api_url(full_version, resource):", "body": "return '<STR_LIT>'.format(dna.utils.Version(full_version).major, resource)<EOL>", "docstring": ">>> # Harmonize api endpoints\n>>> # __version__ should be like major.minor.fix\n>>> from my_app import __version__\n>>> api_url(__version__, '/some/endpoint')\n/v0/some/endpoint", "id": "f8695:m0"}
{"signature": "@cors.crossdomain(origin='<STR_LIT:*>')<EOL><INDENT>def get(self, worker_id):<DEDENT>", "body": "code = <NUM_LIT:200><EOL>if worker_id == '<STR_LIT:all>':<EOL><INDENT>report = {'<STR_LIT>': [{<EOL>'<STR_LIT:id>': job,<EOL>'<STR_LIT>': self._inspect_worker(job)}<EOL>for job in self.jobs]<EOL>}<EOL><DEDENT>elif worker_id in self.jobs:<EOL><INDENT>report = {<EOL>'<STR_LIT:id>': worker_id,<EOL>'<STR_LIT>': self._inspect_worker(worker_id)<EOL>}<EOL><DEDENT>else:<EOL><INDENT>report = {'<STR_LIT:error>': '<STR_LIT>'.format(worker_id)}<EOL>code = <NUM_LIT><EOL><DEDENT>return flask.jsonify(report), code<EOL>", "docstring": "Return status report", "id": "f8696:c0:m2"}
{"signature": "def __get__(self, obj, objtype):", "body": "return functools.partial(self.__call__, obj)<EOL>", "docstring": "Support instance methods.", "id": "f8699:c0:m3"}
{"signature": "def __repr__(self):", "body": "return self.func.__doc__<EOL>", "docstring": "Return the function's docstring.", "id": "f8699:c0:m2"}
{"signature": "def dynamic_import(mod_path, obj_name=None):", "body": "try:<EOL><INDENT>module = __import__(mod_path, fromlist=['<STR_LIT>'])<EOL><DEDENT>except ImportError as error:<EOL><INDENT>raise errors.DynamicImportFailed(<EOL>module='<STR_LIT:.>'.join([mod_path, obj_name]), reason=error)<EOL><DEDENT>importlib.reload(module)<EOL>if obj_name is None:<EOL><INDENT>obj = module<EOL><DEDENT>elif hasattr(module, obj_name):<EOL><INDENT>obj = getattr(module, obj_name)<EOL><DEDENT>else:<EOL><INDENT>raise errors.DynamicImportFailed(<EOL>module='<STR_LIT:.>'.join([mod_path, obj_name]),<EOL>reason='<STR_LIT>'.<EOL>format(module.__name__, obj_name))<EOL>return None<EOL><DEDENT>return obj<EOL>", "docstring": "Take a string and return the corresponding module", "id": "f8703:m4"}
{"signature": "def generate_random_name(size=<NUM_LIT:8>, chars=string.ascii_lowercase + string.digits):", "body": "return '<STR_LIT>'.join(random.choice(chars) for _ in range(size))<EOL>", "docstring": "Create a random name to assign to a node", "id": "f8703:m1"}
{"signature": "def iter_osm_notes(feed_limit=<NUM_LIT>, interval=<NUM_LIT>, parse_timestamps=True):", "body": "last_seen_guid = None<EOL>while True:<EOL><INDENT>u = urllib2.urlopen('<STR_LIT>' % feed_limit)<EOL>tree = etree.parse(u)<EOL>new_notes = []<EOL>for note_item in tree.xpath('<STR_LIT>'):<EOL><INDENT>title = note_item.xpath('<STR_LIT:title>')[<NUM_LIT:0>].text<EOL>if title.startswith('<STR_LIT>'):<EOL><INDENT>action = '<STR_LIT>'<EOL><DEDENT>elif title.startswith('<STR_LIT>'):<EOL><INDENT>action = '<STR_LIT>'<EOL><DEDENT>elif title.startswith('<STR_LIT>'):<EOL><INDENT>action = '<STR_LIT>'<EOL><DEDENT>guid = note_item.xpath('<STR_LIT>')[<NUM_LIT:0>].text<EOL>if last_seen_guid == guid:<EOL><INDENT>break<EOL><DEDENT>elif last_seen_guid == None:<EOL><INDENT>last_seen_guid = guid<EOL><DEDENT>else:<EOL><INDENT>note_id = int(guid.split('<STR_LIT:/>')[-<NUM_LIT:1>].split('<STR_LIT>')[<NUM_LIT:0>])<EOL>new_notes.append((action, get_note(note_id, parse_timestamps)))<EOL><DEDENT><DEDENT>for note in reversed(new_notes):<EOL><INDENT>yield note<EOL><DEDENT>yield model.Finished(None, None)<EOL>time.sleep(interval)<EOL><DEDENT>", "docstring": "Parses the global OSM Notes feed and yields as much Note information as possible.", "id": "f8714:m12"}
{"signature": "def run_once(f):", "body": "@wraps(f)<EOL>def wrapper(*args, **kwargs):<EOL><INDENT>if not wrapper.has_run:<EOL><INDENT>result = f(*args, **kwargs)<EOL>wrapper.has_run = True<EOL>return result<EOL><DEDENT><DEDENT>wrapper.has_run = False<EOL>return wrapper<EOL>", "docstring": "Runs a function (successfully) only once.\n    The running can be reset by setting the `has_run` attribute to False", "id": "f8732:m0"}
{"signature": "def gcp_revoke_authentication(self):", "body": "self._validate_key_set()<EOL>self.log.info(\"<STR_LIT>\")<EOL>self.execute_cmd(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'.format(self.project_id)])<EOL>self.execute_cmd(<EOL>['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:none>', '<STR_LIT>'.format(self.project_id)]<EOL>)<EOL>", "docstring": "Change default authentication to none - which is not existing one.", "id": "f8734:c0:m7"}
{"signature": "def gcp_store_authentication(self):", "body": "self._validate_key_set()<EOL>if not GcpAuthenticator.original_account:<EOL><INDENT>GcpAuthenticator.original_account = self.check_output(<EOL>['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'.format(self.project_id)]<EOL>).decode('<STR_LIT:utf-8>')<EOL>self.log.info(\"<STR_LIT>\".format(GcpAuthenticator.original_account))<EOL><DEDENT>", "docstring": "Store authentication as it was originally so it can be restored and revoke\nauthentication.", "id": "f8734:c0:m8"}
{"signature": "def restart_cluster_endpoint(host):", "body": "return '<STR_LIT>'.format(host)<EOL>", "docstring": "Utility function to generate the get run endpoint given the host.", "id": "f8769:m5"}
{"signature": "def run_now_endpoint(host):", "body": "return '<STR_LIT>'.format(host)<EOL>", "docstring": "Utility function to generate the run now endpoint given the host.", "id": "f8769:m0"}
{"signature": "def get_after(sentinel, iterable):", "body": "truncated = dropwhile(lambda el: el != sentinel, iterable)<EOL>next(truncated)<EOL>return next(truncated)<EOL>", "docstring": "Get the value after `sentinel` in an `iterable`", "id": "f8786:m0"}
{"signature": "def a_function(arg_x, arg_y):", "body": "pass<EOL>", "docstring": "A function with two args", "id": "f8973:m0"}
{"signature": "def set_dags_paused_state(is_paused):", "body": "session = settings.Session()<EOL>dms = session.query(DagModel).filter(<EOL>DagModel.dag_id.in_(DAG_IDS))<EOL>for dm in dms:<EOL><INDENT>logging.info('<STR_LIT>'.format(dm, is_paused))<EOL>dm.is_paused = is_paused<EOL><DEDENT>session.commit()<EOL>", "docstring": "Toggle the pause state of the DAGs in the test.", "id": "f9102:m2"}
{"signature": "def get_components(principal):", "body": "if not principal:<EOL><INDENT>return None<EOL><DEDENT>return re.split(r'<STR_LIT>', str(principal))<EOL>", "docstring": "get_components(principal) -> (short name, instance (FQDN), realm)\n\n``principal`` is the kerberos principal to parse.", "id": "f9107:m0"}
{"signature": "def add_volume(self, volume):", "body": "self._add_volume(name=volume.name, configs=volume.configs)<EOL>", "docstring": "Args:\n    volume (Volume):", "id": "f9110:c0:m3"}
{"signature": "def _add_mount(self,<EOL>name,<EOL>mount_path,<EOL>sub_path,<EOL>read_only):", "body": "self.volume_mounts.append({<EOL>'<STR_LIT:name>': name,<EOL>'<STR_LIT>': mount_path,<EOL>'<STR_LIT>': sub_path,<EOL>'<STR_LIT>': read_only<EOL>})<EOL>", "docstring": "Args:\n    name (str):\n    mount_path (str):\n    sub_path (str):\n    read_only:\n\nReturns:", "id": "f9110:c0:m6"}
{"signature": "def run_pod(self, pod, startup_timeout=<NUM_LIT>, get_logs=True):<EOL>", "body": "resp = self.run_pod_async(pod)<EOL>curr_time = dt.now()<EOL>if resp.status.start_time is None:<EOL><INDENT>while self.pod_not_started(pod):<EOL><INDENT>delta = dt.now() - curr_time<EOL>if delta.seconds >= startup_timeout:<EOL><INDENT>raise AirflowException(\"<STR_LIT>\")<EOL><DEDENT>time.sleep(<NUM_LIT:1>)<EOL><DEDENT>self.log.debug('<STR_LIT>')<EOL><DEDENT>return self._monitor_pod(pod, get_logs)<EOL>", "docstring": "Launches the pod synchronously and waits for completion.\nArgs:\n    pod (Pod):\n    startup_timeout (int): Timeout for startup of the pod (if pod is pending for\n     too long, considers task a failure", "id": "f9111:c1:m3"}
{"signature": "def _get_init_containers(self):", "body": "<EOL>if self.kube_config.dags_volume_claim orself.kube_config.dags_volume_host or self.kube_config.dags_in_image:<EOL><INDENT>return []<EOL><DEDENT>init_environment = [{<EOL>'<STR_LIT:name>': '<STR_LIT>',<EOL>'<STR_LIT:value>': self.kube_config.git_repo<EOL>}, {<EOL>'<STR_LIT:name>': '<STR_LIT>',<EOL>'<STR_LIT:value>': self.kube_config.git_branch<EOL>}, {<EOL>'<STR_LIT:name>': '<STR_LIT>',<EOL>'<STR_LIT:value>': self.kube_config.git_sync_root<EOL>}, {<EOL>'<STR_LIT:name>': '<STR_LIT>',<EOL>'<STR_LIT:value>': self.kube_config.git_sync_dest<EOL>}, {<EOL>'<STR_LIT:name>': '<STR_LIT>',<EOL>'<STR_LIT:value>': '<STR_LIT:1>'<EOL>}, {<EOL>'<STR_LIT:name>': '<STR_LIT>',<EOL>'<STR_LIT:value>': '<STR_LIT:true>'<EOL>}]<EOL>if self.kube_config.git_user:<EOL><INDENT>init_environment.append({<EOL>'<STR_LIT:name>': '<STR_LIT>',<EOL>'<STR_LIT:value>': self.kube_config.git_user<EOL>})<EOL><DEDENT>if self.kube_config.git_password:<EOL><INDENT>init_environment.append({<EOL>'<STR_LIT:name>': '<STR_LIT>',<EOL>'<STR_LIT:value>': self.kube_config.git_password<EOL>})<EOL><DEDENT>volume_mounts = [{<EOL>'<STR_LIT>': self.kube_config.git_sync_root,<EOL>'<STR_LIT:name>': self.dags_volume_name,<EOL>'<STR_LIT>': False<EOL>}]<EOL>if self.kube_config.git_ssh_key_secret_name:<EOL><INDENT>volume_mounts.append({<EOL>'<STR_LIT:name>': self.git_sync_ssh_secret_volume_name,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'<EOL>})<EOL>init_environment.extend([<EOL>{<EOL>'<STR_LIT:name>': '<STR_LIT>',<EOL>'<STR_LIT:value>': '<STR_LIT>'<EOL>},<EOL>{<EOL>'<STR_LIT:name>': '<STR_LIT>',<EOL>'<STR_LIT:value>': '<STR_LIT:true>'<EOL>}])<EOL><DEDENT>if self.kube_config.git_ssh_known_hosts_configmap_name:<EOL><INDENT>volume_mounts.append({<EOL>'<STR_LIT:name>': self.git_sync_ssh_known_hosts_volume_name,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'<EOL>})<EOL>init_environment.extend([<EOL>{<EOL>'<STR_LIT:name>': '<STR_LIT>',<EOL>'<STR_LIT:value>': '<STR_LIT:true>'<EOL>},<EOL>{<EOL>'<STR_LIT:name>': '<STR_LIT>',<EOL>'<STR_LIT:value>': '<STR_LIT>'<EOL>}<EOL>])<EOL><DEDENT>else:<EOL><INDENT>init_environment.append({<EOL>'<STR_LIT:name>': '<STR_LIT>',<EOL>'<STR_LIT:value>': '<STR_LIT:false>'<EOL>})<EOL><DEDENT>return [{<EOL>'<STR_LIT:name>': self.kube_config.git_sync_init_container_name,<EOL>'<STR_LIT:image>': self.kube_config.git_sync_container,<EOL>'<STR_LIT>': {'<STR_LIT>': <NUM_LIT>},  <EOL>'<STR_LIT>': init_environment,<EOL>'<STR_LIT>': volume_mounts<EOL>}]<EOL>", "docstring": "When using git to retrieve the DAGs, use the GitSync Init Container", "id": "f9114:c0:m1"}
{"signature": "def validate(self, body_to_validate):", "body": "try:<EOL><INDENT>for validation_spec in self._validation_specs:<EOL><INDENT>self._validate_field(validation_spec=validation_spec,<EOL>dictionary_to_validate=body_to_validate)<EOL><DEDENT><DEDENT>except GcpFieldValidationException as e:<EOL><INDENT>raise GcpFieldValidationException(<EOL>\"<STR_LIT>\".<EOL>format(body_to_validate, e))<EOL><DEDENT>all_field_names = [spec['<STR_LIT:name>'] for spec in self._validation_specs<EOL>if spec.get('<STR_LIT:type>') != '<STR_LIT>' and<EOL>spec.get('<STR_LIT>') != self._api_version]<EOL>all_union_fields = [spec for spec in self._validation_specs<EOL>if spec.get('<STR_LIT:type>') == '<STR_LIT>']<EOL>for union_field in all_union_fields:<EOL><INDENT>all_field_names.extend(<EOL>[nested_union_spec['<STR_LIT:name>'] for nested_union_spec in union_field['<STR_LIT>']<EOL>if nested_union_spec.get('<STR_LIT:type>') != '<STR_LIT>' and<EOL>nested_union_spec.get('<STR_LIT>') != self._api_version])<EOL><DEDENT>for field_name in body_to_validate.keys():<EOL><INDENT>if field_name not in all_field_names:<EOL><INDENT>self.log.warning(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>field_name, self._validation_specs)<EOL><DEDENT><DEDENT>", "docstring": "Validates if the body (dictionary) follows specification that the validator was\ninstantiated with. Raises ValidationSpecificationException or\nValidationFieldException in case of problems with specification or the\nbody not conforming to the specification respectively.\n\n:param body_to_validate: body that must follow the specification\n:type body_to_validate: dict\n:return: None", "id": "f9120:c2:m8"}
{"signature": "def check_tuning_config(self, tuning_config):", "body": "for channel in tuning_config['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>self.check_s3_url(channel['<STR_LIT>']['<STR_LIT>']['<STR_LIT>'])<EOL><DEDENT>", "docstring": "Check if a tuning configuration is valid\n\n:param tuning_config: tuning_config\n:type tuning_config: dict\n:return: None", "id": "f9127:c1:m5"}
{"signature": "def multi_stream_iter(self, log_group, streams, positions=None):", "body": "positions = positions or {s: Position(timestamp=<NUM_LIT:0>, skip=<NUM_LIT:0>) for s in streams}<EOL>event_iters = [self.log_stream(log_group, s, positions[s].timestamp, positions[s].skip)<EOL>for s in streams]<EOL>events = []<EOL>for s in event_iters:<EOL><INDENT>if not s:<EOL><INDENT>events.append(None)<EOL>continue<EOL><DEDENT>try:<EOL><INDENT>events.append(next(s))<EOL><DEDENT>except StopIteration:<EOL><INDENT>events.append(None)<EOL><DEDENT><DEDENT>while any(events):<EOL><INDENT>i = argmin(events, lambda x: x['<STR_LIT>'] if x else <NUM_LIT>)<EOL>yield (i, events[i])<EOL>try:<EOL><INDENT>events[i] = next(event_iters[i])<EOL><DEDENT>except StopIteration:<EOL><INDENT>events[i] = None<EOL><DEDENT><DEDENT>", "docstring": "Iterate over the available events coming from a set of log streams in a single log group\ninterleaving the events from each stream so they're yielded in timestamp order.\n\n:param log_group: The name of the log group.\n:type log_group: str\n:param streams: A list of the log stream names. The position of the stream in this list is\n    the stream number.\n:type streams: list\n:param positions: A list of pairs of (timestamp, skip) which represents the last record\n    read from each stream.\n:type positions: list\n:return: A tuple of (stream number, cloudwatch log event).", "id": "f9127:c1:m9"}
{"signature": "def check_status(self, job_name, key,<EOL>describe_function, check_interval,<EOL>max_ingestion_time,<EOL>non_terminal_states=None):", "body": "if not non_terminal_states:<EOL><INDENT>non_terminal_states = self.non_terminal_states<EOL><DEDENT>sec = <NUM_LIT:0><EOL>running = True<EOL>while running:<EOL><INDENT>time.sleep(check_interval)<EOL>sec = sec + check_interval<EOL>try:<EOL><INDENT>response = describe_function(job_name)<EOL>status = response[key]<EOL>self.log.info('<STR_LIT>'<EOL>'<STR_LIT>' % (sec, status))<EOL><DEDENT>except KeyError:<EOL><INDENT>raise AirflowException('<STR_LIT>')<EOL><DEDENT>except ClientError:<EOL><INDENT>raise AirflowException('<STR_LIT>')<EOL><DEDENT>if status in non_terminal_states:<EOL><INDENT>running = True<EOL><DEDENT>elif status in self.failed_states:<EOL><INDENT>raise AirflowException('<STR_LIT>' % response['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>running = False<EOL><DEDENT>if max_ingestion_time and sec > max_ingestion_time:<EOL><INDENT>raise AirflowException('<STR_LIT>', max_ingestion_time)<EOL><DEDENT><DEDENT>self.log.info('<STR_LIT>')<EOL>response = describe_function(job_name)<EOL>return response<EOL>", "docstring": "Check status of a SageMaker job\n\n:param job_name: name of the job to check status\n:type job_name: str\n:param key: the key of the response dict\n    that points to the state\n:type key: str\n:param describe_function: the function used to retrieve the status\n:type describe_function: python callable\n:param args: the arguments for the function\n:param check_interval: the time interval in seconds which the operator\n    will check the status of any SageMaker job\n:type check_interval: int\n:param max_ingestion_time: the maximum ingestion time in seconds. Any\n    SageMaker jobs that run longer than this will fail. Setting this to\n    None implies no timeout for any SageMaker job.\n:type max_ingestion_time: int\n:param non_terminal_states: the set of nonterminal states\n:type non_terminal_states: set\n:return: response of describe call after job is done", "id": "f9127:c1:m24"}
{"signature": "def create_tuning_job(self, config, wait_for_completion=True,<EOL>check_interval=<NUM_LIT:30>, max_ingestion_time=None):", "body": "self.check_tuning_config(config)<EOL>response = self.get_conn().create_hyper_parameter_tuning_job(**config)<EOL>if wait_for_completion:<EOL><INDENT>self.check_status(config['<STR_LIT>'],<EOL>'<STR_LIT>',<EOL>self.describe_tuning_job,<EOL>check_interval, max_ingestion_time<EOL>)<EOL><DEDENT>return response<EOL>", "docstring": "Create a tuning job\n\n:param config: the config for tuning\n:type config: dict\n:param wait_for_completion: if the program should keep running until job finishes\n:type wait_for_completion: bool\n:param check_interval: the time interval in seconds which the operator\n    will check the status of any SageMaker job\n:type check_interval: int\n:param max_ingestion_time: the maximum ingestion time in seconds. Any\n    SageMaker jobs that run longer than this will fail. Setting this to\n    None implies no timeout for any SageMaker job.\n:type max_ingestion_time: int\n:return: A response to tuning job creation", "id": "f9127:c1:m11"}
{"signature": "def describe_endpoint_config(self, name):", "body": "return self.get_conn().describe_endpoint_config(EndpointConfigName=name)<EOL>", "docstring": "Return the endpoint config info associated with the name\n\n:param name: the name of the endpoint config\n:type name: string\n:return: A dict contains all the endpoint config info", "id": "f9127:c1:m22"}
{"signature": "def create_cluster(self, cluster, project_id=None, retry=DEFAULT, timeout=DEFAULT):", "body": "if isinstance(cluster, dict):<EOL><INDENT>cluster_proto = Cluster()<EOL>cluster = self._dict_to_proto(py_dict=cluster, proto=cluster_proto)<EOL><DEDENT>elif not isinstance(cluster, Cluster):<EOL><INDENT>raise AirflowException(<EOL>\"<STR_LIT>\")<EOL><DEDENT>self._append_label(cluster, '<STR_LIT>', '<STR_LIT:v>' + version.version)<EOL>self.log.info(<EOL>\"<STR_LIT>\",<EOL>self.project_id, self.location, cluster.name<EOL>)<EOL>try:<EOL><INDENT>op = self.get_client().create_cluster(project_id=project_id or self.project_id,<EOL>zone=self.location,<EOL>cluster=cluster,<EOL>retry=retry,<EOL>timeout=timeout)<EOL>op = self.wait_for_operation(op)<EOL>return op.target_link<EOL><DEDENT>except AlreadyExists as error:<EOL><INDENT>self.log.info('<STR_LIT>', error.message)<EOL>return self.get_cluster(name=cluster.name).self_link<EOL><DEDENT>", "docstring": "Creates a cluster, consisting of the specified number and type of Google Compute\nEngine instances.\n\n:param cluster: A Cluster protobuf or dict. If dict is provided, it must\n    be of the same form as the protobuf message\n    :class:`google.cloud.container_v1.types.Cluster`\n:type cluster: dict or google.cloud.container_v1.types.Cluster\n:param project_id: Google Cloud Platform project ID\n:type project_id: str\n:param retry: A retry object (``google.api_core.retry.Retry``) used to\n    retry requests.\n    If None is specified, requests will not be retried.\n:type retry: google.api_core.retry.Retry\n:param timeout: The amount of time, in seconds, to wait for the request to\n    complete. Note that if retry is specified, the timeout applies to each\n    individual attempt.\n:type timeout: float\n:return: The full url to the new, or existing, cluster\n:raises:\n    ParseError: On JSON parsing problems when trying to convert dict\n    AirflowException: cluster is not dict type nor Cluster proto type", "id": "f9128:c0:m7"}
{"signature": "def delete_subscription(self, project, subscription,<EOL>fail_if_not_exists=False):", "body": "service = self.get_conn()<EOL>full_subscription = _format_subscription(project, subscription)<EOL>try:<EOL><INDENT>service.projects().subscriptions().delete(<EOL>subscription=full_subscription).execute(num_retries=self.num_retries)<EOL><DEDENT>except HttpError as e:<EOL><INDENT>if str(e.resp['<STR_LIT:status>']) == '<STR_LIT>':<EOL><INDENT>message = '<STR_LIT>'.format(<EOL>full_subscription)<EOL>self.log.warning(message)<EOL>if fail_if_not_exists:<EOL><INDENT>raise PubSubException(message)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise PubSubException(<EOL>'<STR_LIT>'.format(full_subscription),<EOL>e)<EOL><DEDENT><DEDENT>", "docstring": "Deletes a Pub/Sub subscription, if it exists.\n\n        :param project: the GCP project ID where the subscription exists\n        :type project: str\n        :param subscription: the Pub/Sub subscription name to delete; do not\n            include the ``projects/{project}/subscriptions/`` prefix.\n        :type subscription: str\n        :param fail_if_not_exists: if set, raise an exception if the topic\n            does not exist\n        :type fail_if_not_exists: bool", "id": "f9129:c1:m6"}
{"signature": "def publish(self, project, topic, messages):", "body": "body = {'<STR_LIT>': messages}<EOL>full_topic = _format_topic(project, topic)<EOL>request = self.get_conn().projects().topics().publish(<EOL>topic=full_topic, body=body)<EOL>try:<EOL><INDENT>request.execute(num_retries=self.num_retries)<EOL><DEDENT>except HttpError as e:<EOL><INDENT>raise PubSubException(<EOL>'<STR_LIT>'.format(full_topic), e)<EOL><DEDENT>", "docstring": "Publishes messages to a Pub/Sub topic.\n\n        :param project: the GCP project ID in which to publish\n        :type project: str\n        :param topic: the Pub/Sub topic to which to publish; do not\n            include the ``projects/{project}/topics/`` prefix.\n        :type topic: str\n        :param messages: messages to publish; if the data field in a\n            message is set, it should already be base64 encoded.\n        :type messages: list of PubSub messages; see\n            http://cloud.google.com/pubsub/docs/reference/rest/v1/PubsubMessage", "id": "f9129:c1:m2"}
{"signature": "def acknowledge(self, project, subscription, ack_ids):", "body": "service = self.get_conn()<EOL>full_subscription = _format_subscription(project, subscription)<EOL>try:<EOL><INDENT>service.projects().subscriptions().acknowledge(<EOL>subscription=full_subscription, body={'<STR_LIT>': ack_ids}<EOL>).execute(num_retries=self.num_retries)<EOL><DEDENT>except HttpError as e:<EOL><INDENT>raise PubSubException(<EOL>'<STR_LIT>'<EOL>.format(len(ack_ids), full_subscription), e)<EOL><DEDENT>", "docstring": "Pulls up to ``max_messages`` messages from Pub/Sub subscription.\n\n        :param project: the GCP project name or ID in which to create\n            the topic\n        :type project: str\n        :param subscription: the Pub/Sub subscription name to delete; do not\n            include the 'projects/{project}/topics/' prefix.\n        :type subscription: str\n        :param ack_ids: List of ReceivedMessage ackIds from a previous pull\n            response\n        :type ack_ids: list", "id": "f9129:c1:m8"}
{"signature": "def get_conn(self):", "body": "http_authorized = self._authorize()<EOL>return build(<EOL>'<STR_LIT>', '<STR_LIT>', http=http_authorized, cache_discovery=False)<EOL>", "docstring": "Returns a Pub/Sub service object.\n\n        :rtype: googleapiclient.discovery.Resource", "id": "f9129:c1:m1"}
{"signature": "def _get_project_id(self, project_id):", "body": "return project_id if project_id else self.project_id<EOL>", "docstring": "In case project_id is None, overrides it with default project_id from\nthe service account that is authorized.\n\n:param project_id: project id to\n:type project_id: str\n:return: the project_id specified or default project id if project_id is None", "id": "f9130:c0:m8"}
{"signature": "def _authorize(self):", "body": "credentials = self._get_credentials()<EOL>http = httplib2.Http()<EOL>authed_http = google_auth_httplib2.AuthorizedHttp(<EOL>credentials, http=http)<EOL>return authed_http<EOL>", "docstring": "Returns an authorized HTTP object to be used to build a Google cloud\nservice hook connection.", "id": "f9130:c0:m3"}
{"signature": "def get_conn(self):", "body": "conn_config = self._get_conn_params()<EOL>conn = snowflake.connector.connect(**conn_config)<EOL>return conn<EOL>", "docstring": "Returns a snowflake.connection object", "id": "f9131:c0:m3"}
{"signature": "def _resolve_should_track_driver_status(self):", "body": "return ('<STR_LIT>' in self._connection['<STR_LIT>'] and<EOL>self._connection['<STR_LIT>'] == '<STR_LIT>')<EOL>", "docstring": "Determines whether or not this hook should poll the spark driver status through\nsubsequent spark-submit status requests after the initial spark-submit request\n:return: if the driver status should be tracked", "id": "f9133:c0:m1"}
{"signature": "def _start_driver_status_tracking(self):", "body": "<EOL>missed_job_status_reports = <NUM_LIT:0><EOL>max_missed_job_status_reports = <NUM_LIT:10><EOL>while self._driver_status not in [\"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>time.sleep(<NUM_LIT:1>)<EOL>self.log.debug(\"<STR_LIT>\"<EOL>.format(self._driver_id))<EOL>poll_drive_status_cmd = self._build_track_driver_status_command()<EOL>status_process = subprocess.Popen(poll_drive_status_cmd,<EOL>stdout=subprocess.PIPE,<EOL>stderr=subprocess.STDOUT,<EOL>bufsize=-<NUM_LIT:1>,<EOL>universal_newlines=True)<EOL>self._process_spark_status_log(iter(status_process.stdout.readline, '<STR_LIT>'))<EOL>returncode = status_process.wait()<EOL>if returncode:<EOL><INDENT>if missed_job_status_reports < max_missed_job_status_reports:<EOL><INDENT>missed_job_status_reports = missed_job_status_reports + <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>raise AirflowException(<EOL>\"<STR_LIT>\"<EOL>.format(max_missed_job_status_reports, returncode)<EOL>)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Polls the driver based on self._driver_id to get the status.\nFinish successfully when the status is FINISHED.\nFinish failed when the status is ERROR/UNKNOWN/KILLED/FAILED.\n\nPossible status:\n\nSUBMITTED\n    Submitted but not yet scheduled on a worker\nRUNNING\n    Has been allocated to a worker to run\nFINISHED\n    Previously ran and exited cleanly\nRELAUNCHING\n    Exited non-zero or due to worker failure, but has not yet\n    started running again\nUNKNOWN\n    The status of the driver is temporarily not known due to\n    master failure recovery\nKILLED\n    A user manually killed this driver\nFAILED\n    The driver exited non-zero and was not supervised\nERROR\n    Unable to run or restart due to an unrecoverable error\n    (e.g. missing jar file)", "id": "f9133:c0:m10"}
{"signature": "def _process_spark_submit_log(self, itr):", "body": "<EOL>for line in itr:<EOL><INDENT>line = line.strip()<EOL>if self._is_yarn and self._connection['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>match = re.search('<STR_LIT>', line)<EOL>if match:<EOL><INDENT>self._yarn_application_id = match.groups()[<NUM_LIT:0>]<EOL>self.log.info(\"<STR_LIT>\",<EOL>self._yarn_application_id)<EOL><DEDENT><DEDENT>elif self._is_kubernetes:<EOL><INDENT>match = re.search(r'<STR_LIT>', line)<EOL>if match:<EOL><INDENT>self._kubernetes_driver_pod = match.groups()[<NUM_LIT:0>]<EOL>self.log.info(\"<STR_LIT>\",<EOL>self._kubernetes_driver_pod)<EOL><DEDENT>match_exit_code = re.search(r'<STR_LIT>', line)<EOL>if match_exit_code:<EOL><INDENT>self._spark_exit_code = int(match_exit_code.groups()[<NUM_LIT:0>])<EOL><DEDENT><DEDENT>elif self._should_track_driver_status and not self._driver_id:<EOL><INDENT>match_driver_id = re.search(r'<STR_LIT>', line)<EOL>if match_driver_id:<EOL><INDENT>self._driver_id = match_driver_id.groups()[<NUM_LIT:0>]<EOL>self.log.info(\"<STR_LIT>\"<EOL>.format(self._driver_id))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.log.info(line)<EOL><DEDENT>self.log.debug(\"<STR_LIT>\".format(line))<EOL><DEDENT>", "docstring": "Processes the log files and extracts useful information out of it.\n\nIf the deploy-mode is 'client', log the output of the submit command as those\nare the output logs of the Spark worker directly.\n\nRemark: If the driver needs to be tracked for its status, the log-level of the\nspark deploy needs to be at least INFO (log4j.logger.org.apache.spark.deploy=INFO)\n\n:param itr: An iterator which iterates over the input of the subprocess", "id": "f9133:c0:m8"}
{"signature": "def _build_spark_submit_command(self, application):", "body": "connection_cmd = self._get_spark_binary_path()<EOL>connection_cmd += [\"<STR_LIT>\", self._connection['<STR_LIT>']]<EOL>if self._conf:<EOL><INDENT>for key in self._conf:<EOL><INDENT>connection_cmd += [\"<STR_LIT>\", \"<STR_LIT>\".format(key, str(self._conf[key]))]<EOL><DEDENT><DEDENT>if self._env_vars and (self._is_kubernetes or self._is_yarn):<EOL><INDENT>if self._is_yarn:<EOL><INDENT>tmpl = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>tmpl = \"<STR_LIT>\"<EOL><DEDENT>for key in self._env_vars:<EOL><INDENT>connection_cmd += [<EOL>\"<STR_LIT>\",<EOL>tmpl.format(key, str(self._env_vars[key]))]<EOL><DEDENT><DEDENT>elif self._env_vars and self._connection['<STR_LIT>'] != \"<STR_LIT>\":<EOL><INDENT>self._env = self._env_vars  <EOL><DEDENT>elif self._env_vars and self._connection['<STR_LIT>'] == \"<STR_LIT>\":<EOL><INDENT>raise AirflowException(<EOL>\"<STR_LIT>\")<EOL><DEDENT>if self._is_kubernetes:<EOL><INDENT>connection_cmd += [\"<STR_LIT>\", \"<STR_LIT>\".format(<EOL>self._connection['<STR_LIT>'])]<EOL><DEDENT>if self._files:<EOL><INDENT>connection_cmd += [\"<STR_LIT>\", self._files]<EOL><DEDENT>if self._py_files:<EOL><INDENT>connection_cmd += [\"<STR_LIT>\", self._py_files]<EOL><DEDENT>if self._archives:<EOL><INDENT>connection_cmd += [\"<STR_LIT>\", self._archives]<EOL><DEDENT>if self._driver_class_path:<EOL><INDENT>connection_cmd += [\"<STR_LIT>\", self._driver_class_path]<EOL><DEDENT>if self._jars:<EOL><INDENT>connection_cmd += [\"<STR_LIT>\", self._jars]<EOL><DEDENT>if self._packages:<EOL><INDENT>connection_cmd += [\"<STR_LIT>\", self._packages]<EOL><DEDENT>if self._exclude_packages:<EOL><INDENT>connection_cmd += [\"<STR_LIT>\", self._exclude_packages]<EOL><DEDENT>if self._repositories:<EOL><INDENT>connection_cmd += [\"<STR_LIT>\", self._repositories]<EOL><DEDENT>if self._num_executors:<EOL><INDENT>connection_cmd += [\"<STR_LIT>\", str(self._num_executors)]<EOL><DEDENT>if self._total_executor_cores:<EOL><INDENT>connection_cmd += [\"<STR_LIT>\", str(self._total_executor_cores)]<EOL><DEDENT>if self._executor_cores:<EOL><INDENT>connection_cmd += [\"<STR_LIT>\", str(self._executor_cores)]<EOL><DEDENT>if self._executor_memory:<EOL><INDENT>connection_cmd += [\"<STR_LIT>\", self._executor_memory]<EOL><DEDENT>if self._driver_memory:<EOL><INDENT>connection_cmd += [\"<STR_LIT>\", self._driver_memory]<EOL><DEDENT>if self._keytab:<EOL><INDENT>connection_cmd += [\"<STR_LIT>\", self._keytab]<EOL><DEDENT>if self._principal:<EOL><INDENT>connection_cmd += [\"<STR_LIT>\", self._principal]<EOL><DEDENT>if self._name:<EOL><INDENT>connection_cmd += [\"<STR_LIT>\", self._name]<EOL><DEDENT>if self._java_class:<EOL><INDENT>connection_cmd += [\"<STR_LIT>\", self._java_class]<EOL><DEDENT>if self._verbose:<EOL><INDENT>connection_cmd += [\"<STR_LIT>\"]<EOL><DEDENT>if self._connection['<STR_LIT>']:<EOL><INDENT>connection_cmd += [\"<STR_LIT>\", self._connection['<STR_LIT>']]<EOL><DEDENT>if self._connection['<STR_LIT>']:<EOL><INDENT>connection_cmd += [\"<STR_LIT>\", self._connection['<STR_LIT>']]<EOL><DEDENT>connection_cmd += [application]<EOL>if self._application_args:<EOL><INDENT>connection_cmd += self._application_args<EOL><DEDENT>self.log.info(\"<STR_LIT>\", connection_cmd)<EOL>return connection_cmd<EOL>", "docstring": "Construct the spark-submit command to execute.\n:param application: command to append to the spark-submit command\n:type application: str\n:return: full command to be executed", "id": "f9133:c0:m5"}
{"signature": "def get_conn(self):", "body": "self.log.debug('<STR_LIT>', self.ssh_conn_id)<EOL>client = paramiko.SSHClient()<EOL>if not self.allow_host_key_change:<EOL><INDENT>self.log.warning('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>client.load_system_host_keys()<EOL><DEDENT>if self.no_host_key_check:<EOL><INDENT>self.log.warning('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>client.set_missing_host_key_policy(paramiko.AutoAddPolicy())<EOL><DEDENT>if self.password and self.password.strip():<EOL><INDENT>client.connect(hostname=self.remote_host,<EOL>username=self.username,<EOL>password=self.password,<EOL>key_filename=self.key_file,<EOL>timeout=self.timeout,<EOL>compress=self.compress,<EOL>port=self.port,<EOL>sock=self.host_proxy)<EOL><DEDENT>else:<EOL><INDENT>client.connect(hostname=self.remote_host,<EOL>username=self.username,<EOL>key_filename=self.key_file,<EOL>timeout=self.timeout,<EOL>compress=self.compress,<EOL>port=self.port,<EOL>sock=self.host_proxy)<EOL><DEDENT>if self.keepalive_interval:<EOL><INDENT>client.get_transport().set_keepalive(self.keepalive_interval)<EOL><DEDENT>self.client = client<EOL>return client<EOL>", "docstring": "Opens a ssh connection to the remote host.\n\n:rtype: paramiko.client.SSHClient", "id": "f9137:c0:m1"}
{"signature": "def encrypt(self, key_name, plaintext, authenticated_data=None):", "body": "keys = self.get_conn().projects().locations().keyRings().cryptoKeys()<EOL>body = {'<STR_LIT>': _b64encode(plaintext)}<EOL>if authenticated_data:<EOL><INDENT>body['<STR_LIT>'] = _b64encode(authenticated_data)<EOL><DEDENT>request = keys.encrypt(name=key_name, body=body)<EOL>response = request.execute(num_retries=self.num_retries)<EOL>ciphertext = response['<STR_LIT>']<EOL>return ciphertext<EOL>", "docstring": "Encrypts a plaintext message using Google Cloud KMS.\n\n:param key_name: The Resource Name for the key (or key version)\n                 to be used for encyption. Of the form\n                 ``projects/*/locations/*/keyRings/*/cryptoKeys/**``\n:type key_name: str\n:param plaintext: The message to be encrypted.\n:type plaintext: bytes\n:param authenticated_data: Optional additional authenticated data that\n                           must also be provided to decrypt the message.\n:type authenticated_data: bytes\n:return: The base 64 encoded ciphertext of the original message.\n:rtype: str", "id": "f9138:c0:m2"}
{"signature": "def _b64decode(s):", "body": "return base64.b64decode(s.encode('<STR_LIT:utf-8>'))<EOL>", "docstring": "Base 64 decodes a string to bytes.", "id": "f9138:m1"}
{"signature": "def _b64encode(s):", "body": "return base64.b64encode(s).decode('<STR_LIT:ascii>')<EOL>", "docstring": "Base 64 encodes a bytes object to a string", "id": "f9138:m0"}
{"signature": "def kill(self, ti):", "body": "if self.cmd is None:<EOL><INDENT>if not ti and not self.task_instance:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>elif not ti:<EOL><INDENT>ti = self.task_instance<EOL><DEDENT>cmd_id = ti.xcom_pull(key=\"<STR_LIT>\", task_ids=ti.task_id)<EOL>self.cmd = self.cls.find(cmd_id)<EOL><DEDENT>if self.cls and self.cmd:<EOL><INDENT>self.log.info('<STR_LIT>', self.cmd.id)<EOL>self.cmd.cancel()<EOL><DEDENT>", "docstring": "Kill (cancel) a Qubole command\n:param ti: Task Instance of the dag, used to determine the Quboles command id\n:return: response from Qubole", "id": "f9139:c0:m3"}
{"signature": "def execute(self):", "body": "proxies = {}<EOL>if self.proxy:<EOL><INDENT>proxies = {'<STR_LIT>': self.proxy}<EOL><DEDENT>slack_message = self._build_slack_message()<EOL>self.run(endpoint=self.webhook_token,<EOL>data=slack_message,<EOL>headers={'<STR_LIT>': '<STR_LIT:application/json>'},<EOL>extra_options={'<STR_LIT>': proxies})<EOL>", "docstring": "Remote Popen (actually execute the slack webhook call)", "id": "f9140:c0:m3"}
{"signature": "def upsert_document(self, document, database_name=None, collection_name=None, document_id=None):", "body": "<EOL>if document_id is None:<EOL><INDENT>document_id = str(uuid.uuid4())<EOL><DEDENT>if document is None:<EOL><INDENT>raise AirflowBadRequest(\"<STR_LIT>\")<EOL><DEDENT>if '<STR_LIT:id>' in document:<EOL><INDENT>if document['<STR_LIT:id>'] is None:<EOL><INDENT>document['<STR_LIT:id>'] = document_id<EOL><DEDENT><DEDENT>else:<EOL><INDENT>document['<STR_LIT:id>'] = document_id<EOL><DEDENT>created_document = self.get_conn().CreateItem(<EOL>get_collection_link(<EOL>self.__get_database_name(database_name),<EOL>self.__get_collection_name(collection_name)),<EOL>document)<EOL>return created_document<EOL>", "docstring": "Inserts a new document (or updates an existing one) into an existing\ncollection in the CosmosDB database.", "id": "f9141:c0:m10"}
{"signature": "def delete_document(self, document_id, database_name=None, collection_name=None):", "body": "if document_id is None:<EOL><INDENT>raise AirflowBadRequest(\"<STR_LIT>\")<EOL><DEDENT>self.get_conn().DeleteItem(<EOL>get_document_link(<EOL>self.__get_database_name(database_name),<EOL>self.__get_collection_name(collection_name),<EOL>document_id))<EOL>", "docstring": "Delete an existing document out of a collection in the CosmosDB database.", "id": "f9141:c0:m12"}
{"signature": "def delete_collection(self, collection_name, database_name=None):", "body": "if collection_name is None:<EOL><INDENT>raise AirflowBadRequest(\"<STR_LIT>\")<EOL><DEDENT>self.get_conn().DeleteContainer(<EOL>get_collection_link(self.__get_database_name(database_name), collection_name))<EOL>", "docstring": "Deletes an existing collection in the CosmosDB database.", "id": "f9141:c0:m9"}
{"signature": "def get_file(self, file_path, container_name, blob_name, **kwargs):", "body": "return self.connection.get_blob_to_path(container_name, blob_name,<EOL>file_path, **kwargs)<EOL>", "docstring": "Download a file from Azure Blob Storage.\n\n:param file_path: Path to the file to download.\n:type file_path: str\n:param container_name: Name of the container.\n:type container_name: str\n:param blob_name: Name of the blob.\n:type blob_name: str\n:param kwargs: Optional keyword arguments that\n    `BlockBlobService.create_blob_from_path()` takes.\n:type kwargs: object", "id": "f9143:c0:m6"}
{"signature": "@GoogleCloudBaseHook.catch_http_exception<EOL><INDENT>def cancel_transfer_operation(self, operation_name):<DEDENT>", "body": "self.get_conn().transferOperations().cancel(name=operation_name).execute(num_retries=self.num_retries)<EOL>", "docstring": "Cancels an transfer operation in Google Storage Transfer Service.\n\n:param operation_name: Name of the transfer operation.\n:type operation_name: str\n:rtype: None", "id": "f9144:c2:m7"}
{"signature": "def list_transfer_job(self, filter):", "body": "conn = self.get_conn()<EOL>filter = self._inject_project_id(filter, FILTER, FILTER_PROJECT_ID)<EOL>request = conn.transferJobs().list(filter=json.dumps(filter))<EOL>jobs = []<EOL>while request is not None:<EOL><INDENT>response = request.execute(num_retries=self.num_retries)<EOL>jobs.extend(response[TRANSFER_JOBS])<EOL>request = conn.transferJobs().list_next(previous_request=request, previous_response=response)<EOL><DEDENT>return jobs<EOL>", "docstring": "Lists long-running operations in Google Storage Transfer\nService that match the specified filter.\n\n:param filter: (Required) A request filter, as described in\n    https://cloud.google.com/storage-transfer/docs/reference/rest/v1/transferJobs/list#body.QUERY_PARAMETERS.filter\n:type filter: dict\n:return: List of Transfer Jobs\n:rtype: list[dict]", "id": "f9144:c2:m4"}
{"signature": "@GoogleCloudBaseHook.catch_http_exception<EOL><INDENT>def update_transfer_job(self, job_name, body):<DEDENT>", "body": "body = self._inject_project_id(body, BODY, PROJECT_ID)<EOL>return (<EOL>self.get_conn()<EOL>.transferJobs()<EOL>.patch(jobName=job_name, body=body)<EOL>.execute(num_retries=self.num_retries)<EOL>)<EOL>", "docstring": "Updates a transfer job that runs periodically.\n\n:param job_name: (Required) Name of the job to be updated\n:type job_name: str\n:param body: A request body, as described in\n    https://cloud.google.com/storage-transfer/docs/reference/rest/v1/transferJobs/patch#request-body\n:type body: dict\n:return: If successful, TransferJob.\n:rtype: dict", "id": "f9144:c2:m5"}
{"signature": "def start_proxy(self):", "body": "self._download_sql_proxy_if_needed()<EOL>if self.sql_proxy_process:<EOL><INDENT>raise AirflowException(\"<STR_LIT>\".format(<EOL>self.sql_proxy_process))<EOL><DEDENT>else:<EOL><INDENT>command_to_run = [self.sql_proxy_path]<EOL>command_to_run.extend(self.command_line_parameters)<EOL>try:<EOL><INDENT>self.log.info(\"<STR_LIT>\",<EOL>self.cloud_sql_proxy_socket_directory)<EOL>os.makedirs(self.cloud_sql_proxy_socket_directory)<EOL><DEDENT>except OSError:<EOL><INDENT>pass<EOL><DEDENT>command_to_run.extend(self._get_credential_parameters())<EOL>self.log.info(\"<STR_LIT>\", \"<STR_LIT:U+0020>\".join(command_to_run))<EOL>self.sql_proxy_process = Popen(command_to_run,<EOL>stdin=PIPE, stdout=PIPE, stderr=PIPE)<EOL>self.log.info(\"<STR_LIT>\", self.sql_proxy_process.pid)<EOL>while True:<EOL><INDENT>line = self.sql_proxy_process.stderr.readline().decode('<STR_LIT:utf-8>')<EOL>return_code = self.sql_proxy_process.poll()<EOL>if line == '<STR_LIT>' and return_code is not None:<EOL><INDENT>self.sql_proxy_process = None<EOL>raise AirflowException(<EOL>\"<STR_LIT>\".format(<EOL>return_code))<EOL><DEDENT>if line != '<STR_LIT>':<EOL><INDENT>self.log.info(line)<EOL><DEDENT>if \"<STR_LIT>\" in line or \"<STR_LIT>\" in line:<EOL><INDENT>self.stop_proxy()<EOL>raise AirflowException(<EOL>\"<STR_LIT>\".format(<EOL>line))<EOL><DEDENT>if \"<STR_LIT>\" in line:<EOL><INDENT>return<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Starts Cloud SQL Proxy.\n\nYou have to remember to stop the proxy if you started it!", "id": "f9146:c2:m5"}
{"signature": "@GoogleCloudBaseHook.fallback_to_default_project_id<EOL><INDENT>def get_instance(self, instance, project_id=None):<DEDENT>", "body": "return self.get_conn().instances().get(<EOL>project=project_id,<EOL>instance=instance<EOL>).execute(num_retries=self.num_retries)<EOL>", "docstring": "Retrieves a resource containing information about a Cloud SQL instance.\n\n:param instance: Database instance ID. This does not include the project ID.\n:type instance: str\n:param project_id: Project ID of the project that contains the instance. If set\n    to None or missing, the default project_id from the GCP connection is used.\n:type project_id: str\n:return: A Cloud SQL instance resource.\n:rtype: dict", "id": "f9146:c1:m2"}
{"signature": "@provide_session<EOL><INDENT>def create_connection(self, session=None):<DEDENT>", "body": "connection = Connection(conn_id=self.db_conn_id)<EOL>uri = self._generate_connection_uri()<EOL>self.log.info(\"<STR_LIT>\", self.db_conn_id)<EOL>connection.parse_from_uri(uri)<EOL>session.add(connection)<EOL>session.commit()<EOL>", "docstring": "Create connection in the Connection table, according to whether it uses\nproxy, TCP, UNIX sockets, SSL. Connection ID will be randomly generated.\n\n:param session: Session of the SQL Alchemy ORM (automatically generated with\n                decorator).", "id": "f9146:c3:m11"}
{"signature": "def _wait_for_operation_to_complete(self, project_id, operation_name):", "body": "service = self.get_conn()<EOL>while True:<EOL><INDENT>operation_response = service.operations().get(<EOL>project=project_id,<EOL>operation=operation_name,<EOL>).execute(num_retries=self.num_retries)<EOL>if operation_response.get(\"<STR_LIT:status>\") == CloudSqlOperationStatus.DONE:<EOL><INDENT>error = operation_response.get(\"<STR_LIT:error>\")<EOL>if error:<EOL><INDENT>error_msg = str(error.get(\"<STR_LIT>\"))[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL>raise AirflowException(error_msg)<EOL><DEDENT>return<EOL><DEDENT>time.sleep(TIME_TO_SLEEP_IN_SECONDS)<EOL><DEDENT>", "docstring": "Waits for the named operation to complete - checks status of the\nasynchronous call.\n\n:param project_id: Project ID of the project that contains the instance.\n:type project_id: str\n:param operation_name: Name of the operation.\n:type operation_name: str\n:return: None", "id": "f9146:c1:m12"}
{"signature": "def check_for_directory(self, share_name, directory_name, **kwargs):", "body": "return self.connection.exists(share_name, directory_name,<EOL>**kwargs)<EOL>", "docstring": "Check if a directory exists on Azure File Share.\n\n:param share_name: Name of the share.\n:type share_name: str\n:param directory_name: Name of the directory.\n:type directory_name: str\n:param kwargs: Optional keyword arguments that\n    `FileService.exists()` takes.\n:type kwargs: object\n:return: True if the file exists, False otherwise.\n:rtype: bool", "id": "f9148:c0:m2"}
{"signature": "def list_directories_and_files(self, share_name, directory_name=None, **kwargs):", "body": "return self.connection.list_directories_and_files(share_name,<EOL>directory_name,<EOL>**kwargs)<EOL>", "docstring": "Return the list of directories and files stored on a Azure File Share.\n\n:param share_name: Name of the share.\n:type share_name: str\n:param directory_name: Name of the directory.\n:type directory_name: str\n:param kwargs: Optional keyword arguments that\n    `FileService.list_directories_and_files()` takes.\n:type kwargs: object\n:return: A list of files and directories\n:rtype: list", "id": "f9148:c0:m4"}
{"signature": "def load_file(self, file_path, share_name, directory_name, file_name, **kwargs):", "body": "self.connection.create_file_from_path(share_name, directory_name,<EOL>file_name, file_path, **kwargs)<EOL>", "docstring": "Upload a file to Azure File Share.\n\n:param file_path: Path to the file to load.\n:type file_path: str\n:param share_name: Name of the share.\n:type share_name: str\n:param directory_name: Name of the directory.\n:type directory_name: str\n:param file_name: Name of the file.\n:type file_name: str\n:param kwargs: Optional keyword arguments that\n    `FileService.create_file_from_path()` takes.\n:type kwargs: object", "id": "f9148:c0:m8"}
{"signature": "def load_stream(self, stream, share_name, directory_name, file_name, count, **kwargs):", "body": "self.connection.create_file_from_stream(share_name, directory_name,<EOL>file_name, stream, count, **kwargs)<EOL>", "docstring": "Upload a stream to Azure File Share.\n\n:param stream: Opened file/stream to upload as the file content.\n:type stream: file-like\n:param share_name: Name of the share.\n:type share_name: str\n:param directory_name: Name of the directory.\n:type directory_name: str\n:param file_name: Name of the file.\n:type file_name: str\n:param count: Size of the stream in bytes\n:type count: int\n:param kwargs: Optional keyword arguments that\n    `FileService.create_file_from_stream()` takes.\n:type kwargs: object", "id": "f9148:c0:m10"}
{"signature": "def get_conn(self):", "body": "conn = self.get_connection(self.conn_id)<EOL>service_options = conn.extra_dejson<EOL>return FileService(account_name=conn.login,<EOL>account_key=conn.password, **service_options)<EOL>", "docstring": "Return the FileService object.", "id": "f9148:c0:m1"}
{"signature": "def list_versions(self, project_id, model_name):", "body": "result = []<EOL>full_parent_name = '<STR_LIT>'.format(<EOL>project_id, model_name)<EOL>request = self._mlengine.projects().models().versions().list(<EOL>parent=full_parent_name, pageSize=<NUM_LIT:100>)<EOL>response = request.execute()<EOL>next_page_token = response.get('<STR_LIT>', None)<EOL>result.extend(response.get('<STR_LIT>', []))<EOL>while next_page_token is not None:<EOL><INDENT>next_request = self._mlengine.projects().models().versions().list(<EOL>parent=full_parent_name,<EOL>pageToken=next_page_token,<EOL>pageSize=<NUM_LIT:100>)<EOL>response = next_request.execute()<EOL>next_page_token = response.get('<STR_LIT>', None)<EOL>result.extend(response.get('<STR_LIT>', []))<EOL>time.sleep(<NUM_LIT:5>)<EOL><DEDENT>return result<EOL>", "docstring": "Lists all available versions of a model. Blocks until finished.", "id": "f9151:c0:m7"}
{"signature": "def create_job(self, project_id, job, use_existing_job_fn=None):", "body": "request = self._mlengine.projects().jobs().create(<EOL>parent='<STR_LIT>'.format(project_id),<EOL>body=job)<EOL>job_id = job['<STR_LIT>']<EOL>try:<EOL><INDENT>request.execute()<EOL><DEDENT>except HttpError as e:<EOL><INDENT>if e.resp.status == <NUM_LIT>:<EOL><INDENT>if use_existing_job_fn is not None:<EOL><INDENT>existing_job = self._get_job(project_id, job_id)<EOL>if not use_existing_job_fn(existing_job):<EOL><INDENT>self.log.error(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>job_id, existing_job<EOL>)<EOL>raise<EOL><DEDENT><DEDENT>self.log.info(<EOL>'<STR_LIT>',<EOL>job_id<EOL>)<EOL><DEDENT>else:<EOL><INDENT>self.log.error('<STR_LIT>'.format(e))<EOL>raise<EOL><DEDENT><DEDENT>return self._wait_for_job_done(project_id, job_id)<EOL>", "docstring": "Launches a MLEngine job and wait for it to reach a terminal state.\n\n:param project_id: The Google Cloud project id within which MLEngine\n    job will be launched.\n:type project_id: str\n\n:param job: MLEngine Job object that should be provided to the MLEngine\n    API, such as: ::\n\n        {\n          'jobId': 'my_job_id',\n          'trainingInput': {\n            'scaleTier': 'STANDARD_1',\n            ...\n          }\n        }\n\n:type job: dict\n\n:param use_existing_job_fn: In case that a MLEngine job with the same\n    job_id already exist, this method (if provided) will decide whether\n    we should use this existing job, continue waiting for it to finish\n    and returning the job object. It should accepts a MLEngine job\n    object, and returns a boolean value indicating whether it is OK to\n    reuse the existing job. If 'use_existing_job_fn' is not provided,\n    we by default reuse the existing MLEngine job.\n:type use_existing_job_fn: function\n\n:return: The MLEngine job object if the job successfully reach a\n    terminal state (which might be FAILED or CANCELLED state).\n:rtype: dict", "id": "f9151:c0:m2"}
{"signature": "def create_version(self, project_id, model_name, version_spec):", "body": "parent_name = '<STR_LIT>'.format(project_id, model_name)<EOL>create_request = self._mlengine.projects().models().versions().create(<EOL>parent=parent_name, body=version_spec)<EOL>response = create_request.execute()<EOL>get_request = self._mlengine.projects().operations().get(<EOL>name=response['<STR_LIT:name>'])<EOL>return _poll_with_exponential_delay(<EOL>request=get_request,<EOL>max_n=<NUM_LIT:9>,<EOL>is_done_func=lambda resp: resp.get('<STR_LIT>', False),<EOL>is_error_func=lambda resp: resp.get('<STR_LIT:error>', None) is not None)<EOL>", "docstring": "Creates the Version on Google Cloud ML Engine.\n\nReturns the operation if the version was created successfully and\nraises an error otherwise.", "id": "f9151:c0:m5"}
{"signature": "def _get_job(self, project_id, job_id):", "body": "job_name = '<STR_LIT>'.format(project_id, job_id)<EOL>request = self._mlengine.projects().jobs().get(name=job_name)<EOL>while True:<EOL><INDENT>try:<EOL><INDENT>return request.execute()<EOL><DEDENT>except HttpError as e:<EOL><INDENT>if e.resp.status == <NUM_LIT>:<EOL><INDENT>time.sleep(<NUM_LIT:30>)<EOL><DEDENT>else:<EOL><INDENT>self.log.error('<STR_LIT>'.format(e))<EOL>raise<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Gets a MLEngine job based on the job name.\n\n:return: MLEngine job object if succeed.\n:rtype: dict\n\nRaises:\n    googleapiclient.errors.HttpError: if HTTP error is returned from server", "id": "f9151:c0:m3"}
{"signature": "def delete_many(self, mongo_collection, filter_doc, mongo_db=None, **kwargs):", "body": "collection = self.get_collection(mongo_collection, mongo_db=mongo_db)<EOL>return collection.delete_many(filter_doc, **kwargs)<EOL>", "docstring": "Deletes one or more documents in a mongo collection.\nhttps://api.mongodb.com/python/current/api/pymongo/collection.html#pymongo.collection.Collection.delete_many\n\n:param mongo_collection: The name of the collection to delete from.\n:type mongo_collection: str\n:param filter_doc: A query that matches the documents to delete.\n:type filter_doc: dict\n:param mongo_db: The name of the database to use.\n    Can be omitted; then the database from the connection string is used.\n:type mongo_db: str", "id": "f9152:c0:m15"}
{"signature": "def replace_many(self, mongo_collection, docs,<EOL>filter_docs=None, mongo_db=None, upsert=False, collation=None,<EOL>**kwargs):", "body": "collection = self.get_collection(mongo_collection, mongo_db=mongo_db)<EOL>if not filter_docs:<EOL><INDENT>filter_docs = [{'<STR_LIT>': doc['<STR_LIT>']} for doc in docs]<EOL><DEDENT>requests = [<EOL>ReplaceOne(<EOL>filter_docs[i],<EOL>docs[i],<EOL>upsert=upsert,<EOL>collation=collation)<EOL>for i in range(len(docs))<EOL>]<EOL>return collection.bulk_write(requests, **kwargs)<EOL>", "docstring": "Replaces many documents in a mongo collection.\n\nUses bulk_write with multiple ReplaceOne operations\nhttps://api.mongodb.com/python/current/api/pymongo/collection.html#pymongo.collection.Collection.bulk_write\n\n.. note::\n    If no ``filter_docs``are given, it is assumed that all\n    replacement documents contain the ``_id`` field which are then\n    used as filters.\n\n:param mongo_collection: The name of the collection to update.\n:type mongo_collection: str\n:param docs: The new documents.\n:type docs: list[dict]\n:param filter_docs: A list of queries that match the documents to replace.\n    Can be omitted; then the _id fields from docs will be used.\n:type filter_docs: list[dict]\n:param mongo_db: The name of the database to use.\n    Can be omitted; then the database from the connection string is used.\n:type mongo_db: str\n:param upsert: If ``True``, perform an insert if no documents\n    match the filters for the replace operation.\n:type upsert: bool\n:param collation: An instance of\n    :class:`~pymongo.collation.Collation`. This option is only\n    supported on MongoDB 3.4 and above.\n:type collation: pymongo.collation.Collation", "id": "f9152:c0:m13"}
{"signature": "def aggregate(self, mongo_collection, aggregate_query, mongo_db=None, **kwargs):", "body": "collection = self.get_collection(mongo_collection, mongo_db=mongo_db)<EOL>return collection.aggregate(aggregate_query, **kwargs)<EOL>", "docstring": "Runs an aggregation pipeline and returns the results\nhttps://api.mongodb.com/python/current/api/pymongo/collection.html#pymongo.collection.Collection.aggregate\nhttps://api.mongodb.com/python/current/examples/aggregation.html", "id": "f9152:c0:m6"}
{"signature": "def get_conn(self):", "body": "if self.client is not None:<EOL><INDENT>return self.client<EOL><DEDENT>options = self.extras<EOL>if options.get('<STR_LIT>', False):<EOL><INDENT>options.update({'<STR_LIT>': CERT_NONE})<EOL><DEDENT>self.client = MongoClient(self.uri, **options)<EOL>return self.client<EOL>", "docstring": "Fetches PyMongo Client", "id": "f9152:c0:m3"}
{"signature": "def insert_one(self, mongo_collection, doc, mongo_db=None, **kwargs):", "body": "collection = self.get_collection(mongo_collection, mongo_db=mongo_db)<EOL>return collection.insert_one(doc, **kwargs)<EOL>", "docstring": "Inserts a single document into a mongo collection\nhttps://api.mongodb.com/python/current/api/pymongo/collection.html#pymongo.collection.Collection.insert_one", "id": "f9152:c0:m8"}
{"signature": "@GoogleCloudBaseHook.fallback_to_default_project_id<EOL><INDENT>def get_instance_group_manager(self, zone, resource_id, project_id=None):<DEDENT>", "body": "response = self.get_conn().instanceGroupManagers().get(<EOL>project=project_id,<EOL>zone=zone,<EOL>instanceGroupManager=resource_id<EOL>).execute(num_retries=self.num_retries)<EOL>return response<EOL>", "docstring": "Retrieves Instance Group Manager by project_id, zone and resource_id.\nMust be called with keyword arguments rather than positional.\n\n:param zone: Google Cloud Platform zone where the Instance Group Manager exists\n:type zone: str\n:param resource_id: Name of the Instance Group Manager\n:type resource_id: str\n:param project_id: Optional, Google Cloud Platform project ID where the\n    Compute Engine Instance exists. If set to None or missing,\n    the default project_id from the GCP connection is used.\n:type project_id: str\n:return: Instance group manager representation as object according to\n    https://cloud.google.com/compute/docs/reference/rest/beta/instanceGroupManagers\n:rtype: dict", "id": "f9154:c1:m8"}
{"signature": "def get_conn(self):", "body": "if not self._conn:<EOL><INDENT>http_authorized = self._authorize()<EOL>self._conn = build('<STR_LIT>', self.api_version,<EOL>http=http_authorized, cache_discovery=False)<EOL><DEDENT>return self._conn<EOL>", "docstring": "Retrieves connection to Google Compute Engine.\n\n:return: Google Compute Engine services object\n:rtype: dict", "id": "f9154:c1:m1"}
{"signature": "def delete_operation(self, name):", "body": "conn = self.get_conn()<EOL>resp = (conn<EOL>.projects()<EOL>.operations()<EOL>.delete(name=name)<EOL>.execute(num_retries=self.num_retries))<EOL>return resp<EOL>", "docstring": "Deletes the long-running operation.\n\n.. seealso::\n    https://cloud.google.com/datastore/docs/reference/data/rest/v1/projects.operations/delete\n\n:param name: the name of the operation resource.\n:type name: str\n:return: none if successful.\n:rtype: dict", "id": "f9155:c0:m9"}
{"signature": "def poll_operation_until_done(self, name, polling_interval_in_seconds):", "body": "while True:<EOL><INDENT>result = self.get_operation(name)<EOL>state = result['<STR_LIT>']['<STR_LIT>']['<STR_LIT:state>']<EOL>if state == '<STR_LIT>':<EOL><INDENT>self.log.info('<STR_LIT>'<EOL>.format(polling_interval_in_seconds))<EOL>time.sleep(polling_interval_in_seconds)<EOL><DEDENT>else:<EOL><INDENT>return result<EOL><DEDENT><DEDENT>", "docstring": "Poll backup operation state until it's completed.\n\n:param name: the name of the operation resource\n:type name: str\n:param polling_interval_in_seconds: The number of seconds to wait before calling another request.\n:type polling_interval_in_seconds: int\n:return: a resource operation instance.\n:rtype: dict", "id": "f9155:c0:m10"}
{"signature": "def lookup(self, keys, read_consistency=None, transaction=None):", "body": "conn = self.get_conn()<EOL>body = {'<STR_LIT>': keys}<EOL>if read_consistency:<EOL><INDENT>body['<STR_LIT>'] = read_consistency<EOL><DEDENT>if transaction:<EOL><INDENT>body['<STR_LIT>'] = transaction<EOL><DEDENT>resp = (conn<EOL>.projects()<EOL>.lookup(projectId=self.project_id, body=body)<EOL>.execute(num_retries=self.num_retries))<EOL>return resp<EOL>", "docstring": "Lookup some entities by key.\n\n.. seealso::\n    https://cloud.google.com/datastore/docs/reference/rest/v1/projects/lookup\n\n:param keys: the keys to lookup.\n:type keys: list\n:param read_consistency: the read consistency to use. default, strong or eventual.\n                         Cannot be used with a transaction.\n:type read_consistency: str\n:param transaction: the transaction to use, if any.\n:type transaction: str\n:return: the response body of the lookup request.\n:rtype: dict", "id": "f9155:c0:m5"}
{"signature": "def commit(self, body):", "body": "conn = self.get_conn()<EOL>resp = (conn<EOL>.projects()<EOL>.commit(projectId=self.project_id, body=body)<EOL>.execute(num_retries=self.num_retries))<EOL>return resp<EOL>", "docstring": "Commit a transaction, optionally creating, deleting or modifying some entities.\n\n.. seealso::\n    https://cloud.google.com/datastore/docs/reference/rest/v1/projects/commit\n\n:param body: the body of the commit request.\n:type body: dict\n:return: the response body of the commit request.\n:rtype: dict", "id": "f9155:c0:m4"}
{"signature": "def get_conn(self):", "body": "if not self.connection:<EOL><INDENT>http_authorized = self._authorize()<EOL>self.connection = build('<STR_LIT>', self.api_version, http=http_authorized,<EOL>cache_discovery=False)<EOL><DEDENT>return self.connection<EOL>", "docstring": "Establishes a connection to the Google API.\n\n:return: a Google Cloud Datastore service object.\n:rtype: Resource", "id": "f9155:c0:m1"}
{"signature": "def import_from_storage_bucket(self, bucket, file, namespace=None, entity_filter=None, labels=None):", "body": "admin_conn = self.get_conn()<EOL>input_url = '<STR_LIT>' + '<STR_LIT:/>'.join(filter(None, [bucket, namespace, file]))<EOL>if not entity_filter:<EOL><INDENT>entity_filter = {}<EOL><DEDENT>if not labels:<EOL><INDENT>labels = {}<EOL><DEDENT>body = {<EOL>'<STR_LIT>': input_url,<EOL>'<STR_LIT>': entity_filter,<EOL>'<STR_LIT>': labels,<EOL>}<EOL>resp = (admin_conn<EOL>.projects()<EOL>.import_(projectId=self.project_id, body=body)<EOL>.execute(num_retries=self.num_retries))<EOL>return resp<EOL>", "docstring": "Import a backup from Cloud Storage to Cloud Datastore.\n\n.. note::\n    Keep in mind that this requests the Admin API not the Data API.\n\n.. seealso::\n    https://cloud.google.com/datastore/docs/reference/admin/rest/v1/projects/import\n\n:param bucket: The name of the Cloud Storage bucket.\n:type bucket: str\n:param file: the metadata file written by the projects.export operation.\n:type file: str\n:param namespace: The Cloud Storage namespace path.\n:type namespace: str\n:param entity_filter: specify which kinds/namespaces are to be imported.\n:type entity_filter: dict\n:param labels: Client-assigned labels.\n:type labels: dict of str\n:return: a resource operation instance.\n:rtype: dict", "id": "f9155:c0:m12"}
{"signature": "def begin_transaction(self):", "body": "conn = self.get_conn()<EOL>resp = (conn<EOL>.projects()<EOL>.beginTransaction(projectId=self.project_id, body={})<EOL>.execute(num_retries=self.num_retries))<EOL>return resp['<STR_LIT>']<EOL>", "docstring": "Begins a new transaction.\n\n.. seealso::\n    https://cloud.google.com/datastore/docs/reference/rest/v1/projects/beginTransaction\n\n:return: a transaction handle.\n:rtype: str", "id": "f9155:c0:m3"}
{"signature": "def get_conn(self):", "body": "conn = self.get_connection(self.vertica_conn_id)<EOL>conn_config = {<EOL>\"<STR_LIT:user>\": conn.login,<EOL>\"<STR_LIT:password>\": conn.password or '<STR_LIT>',<EOL>\"<STR_LIT>\": conn.schema,<EOL>\"<STR_LIT:host>\": conn.host or '<STR_LIT:localhost>'<EOL>}<EOL>if not conn.port:<EOL><INDENT>conn_config[\"<STR_LIT:port>\"] = <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>conn_config[\"<STR_LIT:port>\"] = int(conn.port)<EOL><DEDENT>conn = connect(**conn_config)<EOL>return conn<EOL>", "docstring": "Returns verticaql connection object", "id": "f9156:c0:m0"}
{"signature": "def close_conn(self):", "body": "conn = self.conn<EOL>conn.quit()<EOL>self.conn = None<EOL>", "docstring": "Closes the connection. An error will occur if the\nconnection wasn't ever opened.", "id": "f9158:c0:m4"}
{"signature": "def delete_directory(self, path):", "body": "conn = self.get_conn()<EOL>conn.rmd(path)<EOL>", "docstring": "Deletes a directory on the remote system.\n\n:param path: full path to the remote directory to delete\n:type path: str", "id": "f9158:c0:m8"}
{"signature": "def get_size(self, path):", "body": "conn = self.get_conn()<EOL>return conn.size(path)<EOL>", "docstring": "Returns the size of a file (in bytes)\n\n:param path: remote file path\n:type path: string", "id": "f9158:c0:m14"}
{"signature": "def delete_file(self, path):", "body": "conn = self.get_conn()<EOL>conn.delete(path)<EOL>", "docstring": "Removes a file on the FTP Server.\n\n:param path: full path to the remote file\n:type path: str", "id": "f9158:c0:m11"}
{"signature": "def describe_directory(self, path):", "body": "conn = self.get_conn()<EOL>conn.cwd(path)<EOL>try:<EOL><INDENT>files = dict(conn.mlsd())<EOL><DEDENT>except AttributeError:<EOL><INDENT>files = dict(mlsd(conn))<EOL><DEDENT>return files<EOL>", "docstring": "Returns a dictionary of {filename: {attributes}} for all files\non the remote system (where the MLSD command is supported).\n\n:param path: full path to the remote directory\n:type path: str", "id": "f9158:c0:m5"}
{"signature": "def get_session(self, region_name=None):", "body": "session, _ = self._get_credentials(region_name)<EOL>return session<EOL>", "docstring": "Get the underlying boto3.session.", "id": "f9159:c0:m4"}
{"signature": "def write_batch_data(self, items):", "body": "dynamodb_conn = self.get_conn()<EOL>try:<EOL><INDENT>table = dynamodb_conn.Table(self.table_name)<EOL>with table.batch_writer(overwrite_by_pkeys=self.table_keys) as batch:<EOL><INDENT>for item in items:<EOL><INDENT>batch.put_item(Item=item)<EOL><DEDENT><DEDENT>return True<EOL><DEDENT>except Exception as general_error:<EOL><INDENT>raise AirflowException(<EOL>'<STR_LIT>'.format(<EOL>error=str(general_error)<EOL>)<EOL>)<EOL><DEDENT>", "docstring": "Write batch items to dynamodb table with provisioned throughout capacity.", "id": "f9160:c0:m2"}
{"signature": "def get_attachments_by_name(self, name, check_regex, find_first=False):", "body": "attachments = []<EOL>for part in self.mail.walk():<EOL><INDENT>mail_part = MailPart(part)<EOL>if mail_part.is_attachment():<EOL><INDENT>found_attachment = mail_part.has_matching_name(name) if check_regexelse mail_part.has_equal_name(name)<EOL>if found_attachment:<EOL><INDENT>file_name, file_payload = mail_part.get_file()<EOL>self.log.info('<STR_LIT>'.format(file_name))<EOL>attachments.append((file_name, file_payload))<EOL>if find_first:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return attachments<EOL>", "docstring": "Gets all attachments by name for the mail.\n\n:param name: The name of the attachment to look for.\n:type name: str\n:param check_regex: Checks the name for a regular expression.\n:type check_regex: bool\n:param find_first: If set to True it will only find the first match and then quit.\n:type find_first: bool\n:returns: a list of tuples each containing name and payload\n          where the attachments name matches the given name.\n:rtype: list of tuple", "id": "f9163:c1:m2"}
{"signature": "def get_partitions(self,<EOL>database_name,<EOL>table_name,<EOL>expression='<STR_LIT>',<EOL>page_size=None,<EOL>max_items=None):", "body": "config = {<EOL>'<STR_LIT>': page_size,<EOL>'<STR_LIT>': max_items,<EOL>}<EOL>paginator = self.get_conn().get_paginator('<STR_LIT>')<EOL>response = paginator.paginate(<EOL>DatabaseName=database_name,<EOL>TableName=table_name,<EOL>Expression=expression,<EOL>PaginationConfig=config<EOL>)<EOL>partitions = set()<EOL>for page in response:<EOL><INDENT>for p in page['<STR_LIT>']:<EOL><INDENT>partitions.add(tuple(p['<STR_LIT>']))<EOL><DEDENT><DEDENT>return partitions<EOL>", "docstring": "Retrieves the partition values for a table.\n\n:param database_name: The name of the catalog database where the partitions reside.\n:type database_name: str\n:param table_name: The name of the partitions' table.\n:type table_name: str\n:param expression: An expression filtering the partitions to be returned.\n    Please see official AWS documentation for further information.\n    https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-catalog-partitions.html#aws-glue-api-catalog-partitions-GetPartitions\n:type expression: str\n:param page_size: pagination size\n:type page_size: int\n:param max_items: maximum items to return\n:type max_items: int\n:return: set of partition values where each value is a tuple since\n    a partition may be composed of multiple columns. For example:\n    ``{('2018-01-01','1'), ('2018-01-01','2')}``", "id": "f9164:c0:m2"}
{"signature": "def get_table_location(self, database_name, table_name):", "body": "table = self.get_table(database_name, table_name)<EOL>return table['<STR_LIT>']['<STR_LIT>']<EOL>", "docstring": "Get the physical location of the table\n\n:param database_name: Name of hive database (schema) @table belongs to\n:type database_name: str\n:param table_name: Name of hive table\n:type table_name: str\n:return: str", "id": "f9164:c0:m5"}
{"signature": "def describe_object(self, obj):", "body": "conn = self.get_conn()<EOL>return conn.__getattr__(obj).describe()<EOL>", "docstring": "Get the description of an object from Salesforce.\nThis description is the object's schema and\nsome extra metadata that Salesforce stores for each object.\n\n:param obj: The name of the Salesforce object that we are getting a description of.\n:type obj: str\n:return: the description of the Salesforce object.\n:rtype: dict", "id": "f9165:c0:m3"}
{"signature": "def __init__(self, conn_id):", "body": "super().__init__(conn_id)<EOL>self.conn_id = conn_id<EOL>self.conn = None<EOL>", "docstring": "Create new connection to Salesforce and allows you to pull data out of SFDC and save it to a file.\n\nYou can then use that file with other Airflow operators to move the data into another data source.\n\n:param conn_id: the name of the connection that has the parameters we need to connect to Salesforce.\n    The connection should be type `http` and include a user's security token in the `Extras` field.\n:type conn_id: str\n\n.. note::\n    For the HTTP connection type, you can include a\n    JSON structure in the `Extras` field.\n    We need a user's security token to connect to Salesforce.\n    So we define it in the `Extras` field as:\n        `{\"security_token\":\"YOUR_SECURITY_TOKEN\"}`", "id": "f9165:c0:m0"}
{"signature": "def write_object_to_file(self,<EOL>query_results,<EOL>filename,<EOL>fmt=\"<STR_LIT>\",<EOL>coerce_to_timestamp=False,<EOL>record_time_added=False):", "body": "fmt = fmt.lower()<EOL>if fmt not in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(fmt))<EOL><DEDENT>df = pd.DataFrame.from_records(query_results, exclude=[\"<STR_LIT>\"])<EOL>df.columns = [column.lower() for column in df.columns]<EOL>if coerce_to_timestamp and df.shape[<NUM_LIT:0>] > <NUM_LIT:0>:<EOL><INDENT>object_name = query_results[<NUM_LIT:0>]['<STR_LIT>']['<STR_LIT:type>']<EOL>self.log.info(\"<STR_LIT>\", object_name)<EOL>schema = self.describe_object(object_name)<EOL>possible_timestamp_cols = [<EOL>field['<STR_LIT:name>'].lower()<EOL>for field in schema['<STR_LIT>']<EOL>if field['<STR_LIT:type>'] in [\"<STR_LIT:date>\", \"<STR_LIT>\"] and field['<STR_LIT:name>'].lower() in df.columns<EOL>]<EOL>df[possible_timestamp_cols] = df[possible_timestamp_cols].apply(self._to_timestamp)<EOL><DEDENT>if record_time_added:<EOL><INDENT>fetched_time = time.time()<EOL>df[\"<STR_LIT>\"] = fetched_time<EOL><DEDENT>if fmt == \"<STR_LIT>\":<EOL><INDENT>self.log.info(\"<STR_LIT>\")<EOL>possible_strings = df.columns[df.dtypes == \"<STR_LIT:object>\"]<EOL>df[possible_strings] = df[possible_strings].apply(<EOL>lambda x: x.str.replace(\"<STR_LIT:\\r\\n>\", \"<STR_LIT>\").str.replace(\"<STR_LIT:\\n>\", \"<STR_LIT>\")<EOL>)<EOL>df.to_csv(filename, index=False)<EOL><DEDENT>elif fmt == \"<STR_LIT>\":<EOL><INDENT>df.to_json(filename, \"<STR_LIT>\", date_unit=\"<STR_LIT:s>\")<EOL><DEDENT>elif fmt == \"<STR_LIT>\":<EOL><INDENT>df.to_json(filename, \"<STR_LIT>\", lines=True, date_unit=\"<STR_LIT:s>\")<EOL><DEDENT>return df<EOL>", "docstring": "Write query results to file.\n\nAcceptable formats are:\n    - csv:\n        comma-separated-values file. This is the default format.\n    - json:\n        JSON array. Each element in the array is a different row.\n    - ndjson:\n        JSON array but each element is new-line delimited instead of comma delimited like in `json`\n\nThis requires a significant amount of cleanup.\nPandas doesn't handle output to CSV and json in a uniform way.\nThis is especially painful for datetime types.\nPandas wants to write them as strings in CSV, but as millisecond Unix timestamps.\n\nBy default, this function will try and leave all values as they are represented in Salesforce.\nYou use the `coerce_to_timestamp` flag to force all datetimes to become Unix timestamps (UTC).\nThis is can be greatly beneficial as it will make all of your datetime fields look the same,\nand makes it easier to work with in other database environments\n\n:param query_results: the results from a SQL query\n:type query_results: list of dict\n:param filename: the name of the file where the data should be dumped to\n:type filename: str\n:param fmt: the format you want the output in. Default:  'csv'\n:type fmt: str\n:param coerce_to_timestamp: True if you want all datetime fields to be converted into Unix timestamps.\n    False if you want them to be left in the same format as they were in Salesforce.\n    Leaving the value as False will result in datetimes being strings. Default: False\n:type coerce_to_timestamp: bool\n:param record_time_added: True if you want to add a Unix timestamp field\n    to the resulting data that marks when the data was fetched from Salesforce. Default: False\n:type record_time_added: bool\n:return: the dataframe that gets written to the file.\n:rtype: pd.Dataframe", "id": "f9165:c0:m7"}
{"signature": "@classmethod<EOL><INDENT>def _to_timestamp(cls, column):<DEDENT>", "body": "<EOL>try:<EOL><INDENT>column = pd.to_datetime(column)<EOL><DEDENT>except ValueError:<EOL><INDENT>log = LoggingMixin().log<EOL>log.warning(\"<STR_LIT>\", column.name)<EOL>return column<EOL><DEDENT>converted = []<EOL>for value in column:<EOL><INDENT>try:<EOL><INDENT>converted.append(value.timestamp())<EOL><DEDENT>except (ValueError, AttributeError):<EOL><INDENT>converted.append(pd.np.NaN)<EOL><DEDENT><DEDENT>return pd.Series(converted, index=column.index)<EOL>", "docstring": "Convert a column of a dataframe to UNIX timestamps if applicable\n\n:param column: A Series object representing a column of a dataframe.\n:type column: pd.Series\n:return: a new series that maintains the same index as the original\n:rtype: pd.Series", "id": "f9165:c0:m6"}
{"signature": "def get_available_fields(self, obj):", "body": "self.get_conn()<EOL>obj_description = self.describe_object(obj)<EOL>return [field['<STR_LIT:name>'] for field in obj_description['<STR_LIT>']]<EOL>", "docstring": "Get a list of all available fields for an object.\n\n:param obj: The name of the Salesforce object that we are getting a description of.\n:type obj: str\n:return: the names of the fields.\n:rtype: list of str", "id": "f9165:c0:m4"}
{"signature": "def delete_file(self, path):", "body": "conn = self.get_conn()<EOL>conn.remove(path)<EOL>", "docstring": "Removes a file on the FTP Server\n:param path: full path to the remote file\n:type path: str", "id": "f9168:c0:m9"}
{"signature": "def fetchmany(self, size=None):", "body": "if size is None:<EOL><INDENT>size = self.arraysize<EOL><DEDENT>result = []<EOL>for _ in range(size):<EOL><INDENT>one = self.fetchone()<EOL>if one is None:<EOL><INDENT>break<EOL><DEDENT>else:<EOL><INDENT>result.append(one)<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Fetch the next set of rows of a query result, returning a sequence of sequences\n(e.g. a list of tuples). An empty sequence is returned when no more rows are\navailable. The number of rows to fetch per call is specified by the parameter.\nIf it is not given, the cursor's arraysize determines the number of rows to be\nfetched. The method should try to fetch as many rows as indicated by the size\nparameter. If this is not possible due to the specified number of rows not being\navailable, fewer rows may be returned. An :py:class:`~pyhive.exc.Error`\n(or subclass) exception is raised if the previous call to\n:py:meth:`execute` did not produce any result set or no call was issued yet.", "id": "f9169:c4:m8"}
{"signature": "def run_grant_dataset_view_access(self,<EOL>source_dataset,<EOL>view_dataset,<EOL>view_table,<EOL>source_project=None,<EOL>view_project=None):", "body": "<EOL>source_project = source_project if source_project else self.project_id<EOL>view_project = view_project if view_project else self.project_id<EOL>source_dataset_resource = self.service.datasets().get(<EOL>projectId=source_project, datasetId=source_dataset).execute(num_retries=self.num_retries)<EOL>access = source_dataset_resource[<EOL>'<STR_LIT>'] if '<STR_LIT>' in source_dataset_resource else []<EOL>view_access = {<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': view_project,<EOL>'<STR_LIT>': view_dataset,<EOL>'<STR_LIT>': view_table<EOL>}<EOL>}<EOL>if view_access not in access:<EOL><INDENT>self.log.info(<EOL>'<STR_LIT>',<EOL>view_project, view_dataset, view_table, source_project,<EOL>source_dataset)<EOL>access.append(view_access)<EOL>return self.service.datasets().patch(<EOL>projectId=source_project,<EOL>datasetId=source_dataset,<EOL>body={<EOL>'<STR_LIT>': access<EOL>}).execute(num_retries=self.num_retries)<EOL><DEDENT>else:<EOL><INDENT>self.log.info(<EOL>'<STR_LIT>',<EOL>view_project, view_dataset, view_table, source_project, source_dataset)<EOL>return source_dataset_resource<EOL><DEDENT>", "docstring": "Grant authorized view access of a dataset to a view table.\nIf this view has already been granted access to the dataset, do nothing.\nThis method is not atomic.  Running it may clobber a simultaneous update.\n\n:param source_dataset: the source dataset\n:type source_dataset: str\n:param view_dataset: the dataset that the view is in\n:type view_dataset: str\n:param view_table: the table of the view\n:type view_table: str\n:param source_project: the project of the source dataset. If None,\n    self.project_id will be used.\n:type source_project: str\n:param view_project: the project that the view is in. If None,\n    self.project_id will be used.\n:type view_project: str\n:return: the datasets resource of the source dataset.", "id": "f9169:c3:m15"}
{"signature": "def get_tabledata(self, dataset_id, table_id,<EOL>max_results=None, selected_fields=None, page_token=None,<EOL>start_index=None):", "body": "optional_params = {}<EOL>if max_results:<EOL><INDENT>optional_params['<STR_LIT>'] = max_results<EOL><DEDENT>if selected_fields:<EOL><INDENT>optional_params['<STR_LIT>'] = selected_fields<EOL><DEDENT>if page_token:<EOL><INDENT>optional_params['<STR_LIT>'] = page_token<EOL><DEDENT>if start_index:<EOL><INDENT>optional_params['<STR_LIT>'] = start_index<EOL><DEDENT>return (self.service.tabledata().list(<EOL>projectId=self.project_id,<EOL>datasetId=dataset_id,<EOL>tableId=table_id,<EOL>**optional_params).execute(num_retries=self.num_retries))<EOL>", "docstring": "Get the data of a given dataset.table and optionally with selected columns.\nsee https://cloud.google.com/bigquery/docs/reference/v2/tabledata/list\n\n:param dataset_id: the dataset ID of the requested table.\n:param table_id: the table ID of the requested table.\n:param max_results: the maximum results to return.\n:param selected_fields: List of fields to return (comma-separated). If\n    unspecified, all fields are returned.\n:param page_token: page token, returned from a previous call,\n    identifying the result set.\n:param start_index: zero based index of the starting row to read.\n:return: map containing the requested rows.", "id": "f9169:c3:m12"}
{"signature": "def close(self):", "body": "pass<EOL>", "docstring": "By default, do nothing", "id": "f9169:c4:m2"}
{"signature": "def run_query(self,<EOL>sql,<EOL>destination_dataset_table=None,<EOL>write_disposition='<STR_LIT>',<EOL>allow_large_results=False,<EOL>flatten_results=None,<EOL>udf_config=None,<EOL>use_legacy_sql=None,<EOL>maximum_billing_tier=None,<EOL>maximum_bytes_billed=None,<EOL>create_disposition='<STR_LIT>',<EOL>query_params=None,<EOL>labels=None,<EOL>schema_update_options=(),<EOL>priority='<STR_LIT>',<EOL>time_partitioning=None,<EOL>api_resource_configs=None,<EOL>cluster_fields=None,<EOL>location=None):", "body": "if time_partitioning is None:<EOL><INDENT>time_partitioning = {}<EOL><DEDENT>if location:<EOL><INDENT>self.location = location<EOL><DEDENT>if not api_resource_configs:<EOL><INDENT>api_resource_configs = self.api_resource_configs<EOL><DEDENT>else:<EOL><INDENT>_validate_value('<STR_LIT>',<EOL>api_resource_configs, dict)<EOL><DEDENT>configuration = deepcopy(api_resource_configs)<EOL>if '<STR_LIT>' not in configuration:<EOL><INDENT>configuration['<STR_LIT>'] = {}<EOL><DEDENT>else:<EOL><INDENT>_validate_value(\"<STR_LIT>\",<EOL>configuration['<STR_LIT>'], dict)<EOL><DEDENT>if sql is None and not configuration['<STR_LIT>'].get('<STR_LIT>', None):<EOL><INDENT>raise TypeError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>allowed_schema_update_options = [<EOL>'<STR_LIT>', \"<STR_LIT>\"<EOL>]<EOL>if not set(allowed_schema_update_options<EOL>).issuperset(set(schema_update_options)):<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>.format(schema_update_options,<EOL>allowed_schema_update_options))<EOL><DEDENT>if schema_update_options:<EOL><INDENT>if write_disposition not in [\"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if destination_dataset_table:<EOL><INDENT>destination_project, destination_dataset, destination_table =_split_tablename(table_input=destination_dataset_table,<EOL>default_project_id=self.project_id)<EOL>destination_dataset_table = {<EOL>'<STR_LIT>': destination_project,<EOL>'<STR_LIT>': destination_dataset,<EOL>'<STR_LIT>': destination_table,<EOL>}<EOL><DEDENT>if cluster_fields:<EOL><INDENT>cluster_fields = {'<STR_LIT>': cluster_fields}<EOL><DEDENT>query_param_list = [<EOL>(sql, '<STR_LIT>', None, six.string_types),<EOL>(priority, '<STR_LIT>', '<STR_LIT>', six.string_types),<EOL>(use_legacy_sql, '<STR_LIT>', self.use_legacy_sql, bool),<EOL>(query_params, '<STR_LIT>', None, list),<EOL>(udf_config, '<STR_LIT>', None, list),<EOL>(maximum_billing_tier, '<STR_LIT>', None, int),<EOL>(maximum_bytes_billed, '<STR_LIT>', None, float),<EOL>(time_partitioning, '<STR_LIT>', {}, dict),<EOL>(schema_update_options, '<STR_LIT>', None, tuple),<EOL>(destination_dataset_table, '<STR_LIT>', None, dict),<EOL>(cluster_fields, '<STR_LIT>', None, dict),<EOL>]<EOL>for param_tuple in query_param_list:<EOL><INDENT>param, param_name, param_default, param_type = param_tuple<EOL>if param_name not in configuration['<STR_LIT>'] and param in [None, {}, ()]:<EOL><INDENT>if param_name == '<STR_LIT>':<EOL><INDENT>param_default = _cleanse_time_partitioning(<EOL>destination_dataset_table, time_partitioning)<EOL><DEDENT>param = param_default<EOL><DEDENT>if param not in [None, {}, ()]:<EOL><INDENT>_api_resource_configs_duplication_check(<EOL>param_name, param, configuration['<STR_LIT>'])<EOL>configuration['<STR_LIT>'][param_name] = param<EOL>_validate_value(param_name, configuration['<STR_LIT>'][param_name],<EOL>param_type)<EOL>if param_name == '<STR_LIT>' and param:<EOL><INDENT>self.log.info(\"<STR_LIT>\"<EOL>\"<STR_LIT:%s>\", schema_update_options)<EOL><DEDENT>if param_name == '<STR_LIT>':<EOL><INDENT>for key in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>if key not in configuration['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT>configuration['<STR_LIT>'].update({<EOL>'<STR_LIT>': allow_large_results,<EOL>'<STR_LIT>': flatten_results,<EOL>'<STR_LIT>': write_disposition,<EOL>'<STR_LIT>': create_disposition,<EOL>})<EOL><DEDENT><DEDENT><DEDENT>if '<STR_LIT>' in configuration['<STR_LIT>'] and configuration['<STR_LIT>']['<STR_LIT>'] and'<STR_LIT>' in configuration['<STR_LIT>']:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>if labels:<EOL><INDENT>_api_resource_configs_duplication_check(<EOL>'<STR_LIT>', labels, configuration)<EOL>configuration['<STR_LIT>'] = labels<EOL><DEDENT>return self.run_with_configuration(configuration)<EOL>", "docstring": "Executes a BigQuery SQL query. Optionally persists results in a BigQuery\ntable. See here:\n\nhttps://cloud.google.com/bigquery/docs/reference/v2/jobs\n\nFor more details about these parameters.\n\n:param sql: The BigQuery SQL to execute.\n:type sql: str\n:param destination_dataset_table: The dotted ``<dataset>.<table>``\n    BigQuery table to save the query results.\n:type destination_dataset_table: str\n:param write_disposition: What to do if the table already exists in\n    BigQuery.\n:type write_disposition: str\n:param allow_large_results: Whether to allow large results.\n:type allow_large_results: bool\n:param flatten_results: If true and query uses legacy SQL dialect, flattens\n    all nested and repeated fields in the query results. ``allowLargeResults``\n    must be true if this is set to false. For standard SQL queries, this\n    flag is ignored and results are never flattened.\n:type flatten_results: bool\n:param udf_config: The User Defined Function configuration for the query.\n    See https://cloud.google.com/bigquery/user-defined-functions for details.\n:type udf_config: list\n:param use_legacy_sql: Whether to use legacy SQL (true) or standard SQL (false).\n    If `None`, defaults to `self.use_legacy_sql`.\n:type use_legacy_sql: bool\n:param api_resource_configs: a dictionary that contain params\n    'configuration' applied for Google BigQuery Jobs API:\n    https://cloud.google.com/bigquery/docs/reference/rest/v2/jobs\n    for example, {'query': {'useQueryCache': False}}. You could use it\n    if you need to provide some params that are not supported by the\n    BigQueryHook like args.\n:type api_resource_configs: dict\n:param maximum_billing_tier: Positive integer that serves as a\n    multiplier of the basic price.\n:type maximum_billing_tier: int\n:param maximum_bytes_billed: Limits the bytes billed for this job.\n    Queries that will have bytes billed beyond this limit will fail\n    (without incurring a charge). If unspecified, this will be\n    set to your project default.\n:type maximum_bytes_billed: float\n:param create_disposition: Specifies whether the job is allowed to\n    create new tables.\n:type create_disposition: str\n:param query_params: a list of dictionary containing query parameter types and\n    values, passed to BigQuery\n:type query_params: list\n:param labels: a dictionary containing labels for the job/query,\n    passed to BigQuery\n:type labels: dict\n:param schema_update_options: Allows the schema of the destination\n    table to be updated as a side effect of the query job.\n:type schema_update_options: tuple\n:param priority: Specifies a priority for the query.\n    Possible values include INTERACTIVE and BATCH.\n    The default value is INTERACTIVE.\n:type priority: str\n:param time_partitioning: configure optional time partitioning fields i.e.\n    partition by field, type and expiration as per API specifications.\n:type time_partitioning: dict\n:param cluster_fields: Request that the result of this query be stored sorted\n    by one or more columns. This is only available in combination with\n    time_partitioning. The order of columns given determines the sort order.\n:type cluster_fields: list[str]\n:param location: The geographic location of the job. Required except for\n    US and EU. See details at\n    https://cloud.google.com/bigquery/docs/locations#specifying_your_location\n:type location: str", "id": "f9169:c3:m4"}
{"signature": "def get_pandas_df(self, sql, parameters=None, dialect=None):", "body": "private_key = self._get_field('<STR_LIT>', None) or self._get_field('<STR_LIT>', None)<EOL>if dialect is None:<EOL><INDENT>dialect = '<STR_LIT>' if self.use_legacy_sql else '<STR_LIT>'<EOL><DEDENT>return read_gbq(sql,<EOL>project_id=self._get_field('<STR_LIT>'),<EOL>dialect=dialect,<EOL>verbose=False,<EOL>private_key=private_key)<EOL>", "docstring": "Returns a Pandas DataFrame for the results produced by a BigQuery\nquery. The DbApiHook method must be overridden because Pandas\ndoesn't support PEP 249 connections, except for SQLite. See:\n\nhttps://github.com/pydata/pandas/blob/master/pandas/io/sql.py#L447\nhttps://github.com/pydata/pandas/issues/6900\n\n:param sql: The BigQuery SQL to execute.\n:type sql: str\n:param parameters: The parameters to render the SQL query with (not\n    used, leave to override superclass method)\n:type parameters: mapping or iterable\n:param dialect: Dialect of BigQuery SQL \u2013 legacy SQL or standard SQL\n    defaults to use `self.use_legacy_sql` if not specified\n:type dialect: str in {'legacy', 'standard'}", "id": "f9169:c0:m4"}
{"signature": "def run_load(self,<EOL>destination_project_dataset_table,<EOL>source_uris,<EOL>schema_fields=None,<EOL>source_format='<STR_LIT>',<EOL>create_disposition='<STR_LIT>',<EOL>skip_leading_rows=<NUM_LIT:0>,<EOL>write_disposition='<STR_LIT>',<EOL>field_delimiter='<STR_LIT:U+002C>',<EOL>max_bad_records=<NUM_LIT:0>,<EOL>quote_character=None,<EOL>ignore_unknown_values=False,<EOL>allow_quoted_newlines=False,<EOL>allow_jagged_rows=False,<EOL>schema_update_options=(),<EOL>src_fmt_configs=None,<EOL>time_partitioning=None,<EOL>cluster_fields=None,<EOL>autodetect=False):", "body": "<EOL>if schema_fields is None and not autodetect:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>')<EOL><DEDENT>if src_fmt_configs is None:<EOL><INDENT>src_fmt_configs = {}<EOL><DEDENT>source_format = source_format.upper()<EOL>allowed_formats = [<EOL>\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\"<EOL>]<EOL>if source_format not in allowed_formats:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>.format(source_format, allowed_formats))<EOL><DEDENT>allowed_schema_update_options = [<EOL>'<STR_LIT>', \"<STR_LIT>\"<EOL>]<EOL>if not set(allowed_schema_update_options).issuperset(<EOL>set(schema_update_options)):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>.format(schema_update_options, allowed_schema_update_options))<EOL><DEDENT>destination_project, destination_dataset, destination_table =_split_tablename(table_input=destination_project_dataset_table,<EOL>default_project_id=self.project_id,<EOL>var_name='<STR_LIT>')<EOL>configuration = {<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': autodetect,<EOL>'<STR_LIT>': create_disposition,<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': destination_project,<EOL>'<STR_LIT>': destination_dataset,<EOL>'<STR_LIT>': destination_table,<EOL>},<EOL>'<STR_LIT>': source_format,<EOL>'<STR_LIT>': source_uris,<EOL>'<STR_LIT>': write_disposition,<EOL>'<STR_LIT>': ignore_unknown_values<EOL>}<EOL>}<EOL>time_partitioning = _cleanse_time_partitioning(<EOL>destination_project_dataset_table,<EOL>time_partitioning<EOL>)<EOL>if time_partitioning:<EOL><INDENT>configuration['<STR_LIT>'].update({<EOL>'<STR_LIT>': time_partitioning<EOL>})<EOL><DEDENT>if cluster_fields:<EOL><INDENT>configuration['<STR_LIT>'].update({'<STR_LIT>': {'<STR_LIT>': cluster_fields}})<EOL><DEDENT>if schema_fields:<EOL><INDENT>configuration['<STR_LIT>']['<STR_LIT>'] = {'<STR_LIT>': schema_fields}<EOL><DEDENT>if schema_update_options:<EOL><INDENT>if write_disposition not in [\"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>self.log.info(<EOL>\"<STR_LIT>\",<EOL>schema_update_options<EOL>)<EOL>configuration['<STR_LIT>'][<EOL>'<STR_LIT>'] = schema_update_options<EOL><DEDENT><DEDENT>if max_bad_records:<EOL><INDENT>configuration['<STR_LIT>']['<STR_LIT>'] = max_bad_records<EOL><DEDENT>if '<STR_LIT>' not in src_fmt_configs:<EOL><INDENT>src_fmt_configs['<STR_LIT>'] = skip_leading_rows<EOL><DEDENT>if '<STR_LIT>' not in src_fmt_configs:<EOL><INDENT>src_fmt_configs['<STR_LIT>'] = field_delimiter<EOL><DEDENT>if '<STR_LIT>' not in src_fmt_configs:<EOL><INDENT>src_fmt_configs['<STR_LIT>'] = ignore_unknown_values<EOL><DEDENT>if quote_character is not None:<EOL><INDENT>src_fmt_configs['<STR_LIT>'] = quote_character<EOL><DEDENT>if allow_quoted_newlines:<EOL><INDENT>src_fmt_configs['<STR_LIT>'] = allow_quoted_newlines<EOL><DEDENT>src_fmt_to_configs_mapping = {<EOL>'<STR_LIT>': [<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>'<EOL>],<EOL>'<STR_LIT>': ['<STR_LIT>'],<EOL>'<STR_LIT>': ['<STR_LIT>', '<STR_LIT>'],<EOL>'<STR_LIT>': ['<STR_LIT>', '<STR_LIT>'],<EOL>'<STR_LIT>': ['<STR_LIT>'],<EOL>}<EOL>valid_configs = src_fmt_to_configs_mapping[source_format]<EOL>src_fmt_configs = {<EOL>k: v<EOL>for k, v in src_fmt_configs.items() if k in valid_configs<EOL>}<EOL>configuration['<STR_LIT>'].update(src_fmt_configs)<EOL>if allow_jagged_rows:<EOL><INDENT>configuration['<STR_LIT>']['<STR_LIT>'] = allow_jagged_rows<EOL><DEDENT>return self.run_with_configuration(configuration)<EOL>", "docstring": "Executes a BigQuery load command to load data from Google Cloud Storage\nto BigQuery. See here:\n\nhttps://cloud.google.com/bigquery/docs/reference/v2/jobs\n\nFor more details about these parameters.\n\n:param destination_project_dataset_table:\n    The dotted ``(<project>.|<project>:)<dataset>.<table>($<partition>)`` BigQuery\n    table to load data into. If ``<project>`` is not included, project will be the\n    project defined in the connection json. If a partition is specified the\n    operator will automatically append the data, create a new partition or create\n    a new DAY partitioned table.\n:type destination_project_dataset_table: str\n:param schema_fields: The schema field list as defined here:\n    https://cloud.google.com/bigquery/docs/reference/v2/jobs#configuration.load\n    Required if autodetect=False; optional if autodetect=True.\n:type schema_fields: list\n:param autodetect: Attempt to autodetect the schema for CSV and JSON\n    source files.\n:type autodetect: bool\n:param source_uris: The source Google Cloud\n    Storage URI (e.g. gs://some-bucket/some-file.txt). A single wild\n    per-object name can be used.\n:type source_uris: list\n:param source_format: File format to export.\n:type source_format: str\n:param create_disposition: The create disposition if the table doesn't exist.\n:type create_disposition: str\n:param skip_leading_rows: Number of rows to skip when loading from a CSV.\n:type skip_leading_rows: int\n:param write_disposition: The write disposition if the table already exists.\n:type write_disposition: str\n:param field_delimiter: The delimiter to use when loading from a CSV.\n:type field_delimiter: str\n:param max_bad_records: The maximum number of bad records that BigQuery can\n    ignore when running the job.\n:type max_bad_records: int\n:param quote_character: The value that is used to quote data sections in a CSV\n    file.\n:type quote_character: str\n:param ignore_unknown_values: [Optional] Indicates if BigQuery should allow\n    extra values that are not represented in the table schema.\n    If true, the extra values are ignored. If false, records with extra columns\n    are treated as bad records, and if there are too many bad records, an\n    invalid error is returned in the job result.\n:type ignore_unknown_values: bool\n:param allow_quoted_newlines: Whether to allow quoted newlines (true) or not\n    (false).\n:type allow_quoted_newlines: bool\n:param allow_jagged_rows: Accept rows that are missing trailing optional columns.\n    The missing values are treated as nulls. If false, records with missing\n    trailing columns are treated as bad records, and if there are too many bad\n    records, an invalid error is returned in the job result. Only applicable when\n    soure_format is CSV.\n:type allow_jagged_rows: bool\n:param schema_update_options: Allows the schema of the destination\n    table to be updated as a side effect of the load job.\n:type schema_update_options: tuple\n:param src_fmt_configs: configure optional fields specific to the source format\n:type src_fmt_configs: dict\n:param time_partitioning: configure optional time partitioning fields i.e.\n    partition by field, type and  expiration as per API specifications.\n:type time_partitioning: dict\n:param cluster_fields: Request that the result of this load be stored sorted\n    by one or more columns. This is only available in combination with\n    time_partitioning. The order of columns given determines the sort order.\n:type cluster_fields: list[str]", "id": "f9169:c3:m7"}
{"signature": "def run_with_configuration(self, configuration):", "body": "jobs = self.service.jobs()<EOL>job_data = {'<STR_LIT>': configuration}<EOL>query_reply = jobs.insert(projectId=self.project_id, body=job_data).execute(num_retries=self.num_retries)<EOL>self.running_job_id = query_reply['<STR_LIT>']['<STR_LIT>']<EOL>if '<STR_LIT:location>' in query_reply['<STR_LIT>']:<EOL><INDENT>location = query_reply['<STR_LIT>']['<STR_LIT:location>']<EOL><DEDENT>else:<EOL><INDENT>location = self.location<EOL><DEDENT>keep_polling_job = True<EOL>while keep_polling_job:<EOL><INDENT>try:<EOL><INDENT>if location:<EOL><INDENT>job = jobs.get(<EOL>projectId=self.project_id,<EOL>jobId=self.running_job_id,<EOL>location=location).execute(num_retries=self.num_retries)<EOL><DEDENT>else:<EOL><INDENT>job = jobs.get(<EOL>projectId=self.project_id,<EOL>jobId=self.running_job_id).execute(num_retries=self.num_retries)<EOL><DEDENT>if job['<STR_LIT:status>']['<STR_LIT:state>'] == '<STR_LIT>':<EOL><INDENT>keep_polling_job = False<EOL>if '<STR_LIT>' in job['<STR_LIT:status>']:<EOL><INDENT>raise Exception(<EOL>'<STR_LIT>'.<EOL>format(job['<STR_LIT:status>']['<STR_LIT>'], job))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.log.info('<STR_LIT>',<EOL>self.project_id, self.running_job_id)<EOL>time.sleep(<NUM_LIT:5>)<EOL><DEDENT><DEDENT>except HttpError as err:<EOL><INDENT>if err.resp.status in [<NUM_LIT>, <NUM_LIT>]:<EOL><INDENT>self.log.info(<EOL>'<STR_LIT>',<EOL>err.resp.status, self.running_job_id)<EOL>time.sleep(<NUM_LIT:5>)<EOL><DEDENT>else:<EOL><INDENT>raise Exception(<EOL>'<STR_LIT>'.<EOL>format(err.resp.status))<EOL><DEDENT><DEDENT><DEDENT>return self.running_job_id<EOL>", "docstring": "Executes a BigQuery SQL query. See here:\n\nhttps://cloud.google.com/bigquery/docs/reference/v2/jobs\n\nFor more details about the configuration parameter.\n\n:param configuration: The configuration parameter maps directly to\n    BigQuery's configuration field in the job object. See\n    https://cloud.google.com/bigquery/docs/reference/v2/jobs for\n    details.", "id": "f9169:c3:m8"}
{"signature": "def get_datasets_list(self, project_id=None):", "body": "dataset_project_id = project_id if project_id else self.project_id<EOL>try:<EOL><INDENT>datasets_list = self.service.datasets().list(<EOL>projectId=dataset_project_id).execute(num_retries=self.num_retries)['<STR_LIT>']<EOL>self.log.info(\"<STR_LIT>\", datasets_list)<EOL><DEDENT>except HttpError as err:<EOL><INDENT>raise AirflowException(<EOL>'<STR_LIT>'.format(err.content))<EOL><DEDENT>return datasets_list<EOL>", "docstring": "Method returns full list of BigQuery datasets in the current project\n\n.. seealso::\n    For more information, see:\n    https://cloud.google.com/bigquery/docs/reference/rest/v2/datasets/list\n\n:param project_id: Google Cloud Project for which you\n    try to get all datasets\n:type project_id: str\n:return: datasets_list\n\n    Example of returned datasets_list: ::\n\n           {\n              \"kind\":\"bigquery#dataset\",\n              \"location\":\"US\",\n              \"id\":\"your-project:dataset_2_test\",\n              \"datasetReference\":{\n                 \"projectId\":\"your-project\",\n                 \"datasetId\":\"dataset_2_test\"\n              }\n           },\n           {\n              \"kind\":\"bigquery#dataset\",\n              \"location\":\"US\",\n              \"id\":\"your-project:dataset_1_test\",\n              \"datasetReference\":{\n                 \"projectId\":\"your-project\",\n                 \"datasetId\":\"dataset_1_test\"\n              }\n           }\n        ]", "id": "f9169:c3:m19"}
{"signature": "def execute(self, operation, parameters=None):", "body": "sql = _bind_parameters(operation,<EOL>parameters) if parameters else operation<EOL>self.job_id = self.run_query(sql)<EOL>", "docstring": "Executes a BigQuery query, and returns the job ID.\n\n:param operation: The query to execute.\n:type operation: str\n:param parameters: Parameters to substitute into the query.\n:type parameters: dict", "id": "f9169:c4:m4"}
{"signature": "def commit(self):", "body": "pass<EOL>", "docstring": "BigQueryConnection does not support transactions.", "id": "f9169:c2:m2"}
{"signature": "def fetchall(self):", "body": "result = []<EOL>while True:<EOL><INDENT>one = self.fetchone()<EOL>if one is None:<EOL><INDENT>break<EOL><DEDENT>else:<EOL><INDENT>result.append(one)<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Fetch all (remaining) rows of a query result, returning them as a sequence of\nsequences (e.g. a list of tuples).", "id": "f9169:c4:m9"}
{"signature": "def setinputsizes(self, sizes):", "body": "pass<EOL>", "docstring": "Does nothing by default", "id": "f9169:c4:m12"}
{"signature": "@property<EOL><INDENT>def description(self):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "The schema description method is not currently implemented.", "id": "f9169:c4:m1"}
{"signature": "def _validate_value(key, value, expected_type):", "body": "if not isinstance(value, expected_type):<EOL><INDENT>raise TypeError(\"<STR_LIT>\".format(<EOL>key, expected_type, type(value)))<EOL><DEDENT>", "docstring": "function to check expected type and raise\n    error if type is not correct", "id": "f9169:m5"}
{"signature": "def close(self):", "body": "pass<EOL>", "docstring": "BigQueryConnection does not have anything to close.", "id": "f9169:c2:m1"}
{"signature": "def cursor(self):", "body": "return BigQueryCursor(*self._args, **self._kwargs)<EOL>", "docstring": "Return a new :py:class:`Cursor` object using the connection.", "id": "f9169:c2:m3"}
{"signature": "def _get_webhook_endpoint(self, http_conn_id, webhook_endpoint):", "body": "if webhook_endpoint:<EOL><INDENT>endpoint = webhook_endpoint<EOL><DEDENT>elif http_conn_id:<EOL><INDENT>conn = self.get_connection(http_conn_id)<EOL>extra = conn.extra_dejson<EOL>endpoint = extra.get('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>raise AirflowException('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>if not re.match('<STR_LIT>', endpoint):<EOL><INDENT>raise AirflowException('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>return endpoint<EOL>", "docstring": "Given a Discord http_conn_id, return the default webhook endpoint or override if a\nwebhook_endpoint is manually supplied.\n\n:param http_conn_id: The provided connection ID\n:param webhook_endpoint: The manually provided webhook endpoint\n:return: Webhook endpoint (str) to use", "id": "f9171:c0:m1"}
{"signature": "def _do_api_call(self, endpoint_info, json):", "body": "method, endpoint = endpoint_info<EOL>url = '<STR_LIT>'.format(<EOL>host=self._parse_host(self.databricks_conn.host),<EOL>endpoint=endpoint)<EOL>if '<STR_LIT>' in self.databricks_conn.extra_dejson:<EOL><INDENT>self.log.info('<STR_LIT>')<EOL>auth = _TokenAuth(self.databricks_conn.extra_dejson['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>self.log.info('<STR_LIT>')<EOL>auth = (self.databricks_conn.login, self.databricks_conn.password)<EOL><DEDENT>if method == '<STR_LIT:GET>':<EOL><INDENT>request_func = requests.get<EOL><DEDENT>elif method == '<STR_LIT:POST>':<EOL><INDENT>request_func = requests.post<EOL><DEDENT>else:<EOL><INDENT>raise AirflowException('<STR_LIT>' + method)<EOL><DEDENT>attempt_num = <NUM_LIT:1><EOL>while True:<EOL><INDENT>try:<EOL><INDENT>response = request_func(<EOL>url,<EOL>json=json,<EOL>auth=auth,<EOL>headers=USER_AGENT_HEADER,<EOL>timeout=self.timeout_seconds)<EOL>response.raise_for_status()<EOL>return response.json()<EOL><DEDENT>except requests_exceptions.RequestException as e:<EOL><INDENT>if not _retryable_error(e):<EOL><INDENT>raise AirflowException('<STR_LIT>'.format(<EOL>e.response.content, e.response.status_code))<EOL><DEDENT>self._log_request_error(attempt_num, e)<EOL><DEDENT>if attempt_num == self.retry_limit:<EOL><INDENT>raise AirflowException(('<STR_LIT>' +<EOL>'<STR_LIT>').format(self.retry_limit))<EOL><DEDENT>attempt_num += <NUM_LIT:1><EOL>sleep(self.retry_delay)<EOL><DEDENT>", "docstring": "Utility function to perform an API call with retries\n\n:param endpoint_info: Tuple of method and endpoint\n:type endpoint_info: tuple[string, string]\n:param json: Parameters for this API call.\n:type json: dict\n:return: If the api call returns a OK status code,\n    this function returns the response in JSON. Otherwise,\n    we throw an AirflowException.\n:rtype: dict", "id": "f9172:c0:m2"}
{"signature": "def __init__(<EOL>self,<EOL>databricks_conn_id='<STR_LIT>',<EOL>timeout_seconds=<NUM_LIT>,<EOL>retry_limit=<NUM_LIT:3>,<EOL>retry_delay=<NUM_LIT:1.0>):", "body": "self.databricks_conn_id = databricks_conn_id<EOL>self.databricks_conn = self.get_connection(databricks_conn_id)<EOL>self.timeout_seconds = timeout_seconds<EOL>if retry_limit < <NUM_LIT:1>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>self.retry_limit = retry_limit<EOL>self.retry_delay = retry_delay<EOL>", "docstring": ":param databricks_conn_id: The name of the databricks connection to use.\n:type databricks_conn_id: str\n:param timeout_seconds: The amount of time in seconds the requests library\n    will wait before timing-out.\n:type timeout_seconds: int\n:param retry_limit: The number of times to retry the connection in case of\n    service outages.\n:type retry_limit: int\n:param retry_delay: The number of seconds to wait between retries (it\n    might be a floating point number).\n:type retry_delay: float", "id": "f9172:c0:m0"}
{"signature": "def send_message(self, queue_url, message_body, delay_seconds=<NUM_LIT:0>, message_attributes=None):", "body": "return self.get_conn().send_message(QueueUrl=queue_url,<EOL>MessageBody=message_body,<EOL>DelaySeconds=delay_seconds,<EOL>MessageAttributes=message_attributes or {})<EOL>", "docstring": "Send message to the queue\n\n:param queue_url: queue url\n:type queue_url: str\n:param message_body: the contents of the message\n:type message_body: str\n:param delay_seconds: seconds to delay the message\n:type delay_seconds: int\n:param message_attributes: additional attributes for the message (default: None)\n    For details of the attributes parameter see :py:meth:`botocore.client.SQS.send_message`\n:type message_attributes: dict\n\n:return: dict with the information about the message sent\n    For details of the returned value see :py:meth:`botocore.client.SQS.send_message`\n:rtype: dict", "id": "f9176:c0:m2"}
{"signature": "@GoogleCloudBaseHook.fallback_to_default_project_id<EOL><INDENT>def create_instance(self, instance_id, configuration_name, node_count,<EOL>display_name, project_id=None):<DEDENT>", "body": "self._apply_to_instance(project_id, instance_id, configuration_name,<EOL>node_count, display_name, lambda x: x.create())<EOL>", "docstring": "Creates a new Cloud Spanner instance.\n\n:param instance_id: The ID of the Cloud Spanner instance.\n:type instance_id: str\n:param configuration_name: The name of the instance configuration defining how the\n    instance will be created. Possible configuration values can be retrieved via\n    https://cloud.google.com/spanner/docs/reference/rest/v1/projects.instanceConfigs/list\n:type configuration_name: str\n:param node_count: (Optional) The number of nodes allocated to the Cloud Spanner\n    instance.\n:type node_count: int\n:param display_name: (Optional) The display name for the instance in the GCP\n    Console. Must be between 4 and 30 characters.  If this value is not set in\n    the constructor, the name falls back to the instance ID.\n:type display_name: str\n:param project_id: Optional, the ID of the  GCP project that owns the Cloud Spanner\n    database. If set to None or missing, the default project_id from the GCP connection is used.\n:type project_id: str\n:return: None", "id": "f9178:c0:m4"}
{"signature": "@GoogleCloudBaseHook.fallback_to_default_project_id<EOL><INDENT>def execute_dml(self, instance_id, database_id, queries, project_id=None):<DEDENT>", "body": "self._get_client(project_id=project_id).instance(instance_id=instance_id).database(database_id=database_id).run_in_transaction(<EOL>lambda transaction: self._execute_sql_in_transaction(transaction, queries))<EOL>", "docstring": "Executes an arbitrary DML query (INSERT, UPDATE, DELETE).\n\n:param instance_id: The ID of the Cloud Spanner instance.\n:type instance_id: str\n:param database_id: The ID of the database in Cloud Spanner.\n:type database_id: str\n:param queries: The queries to execute.\n:type queries: str\n:param project_id: Optional, the ID of the  GCP project that owns the Cloud Spanner\n    database. If set to None or missing, the default project_id from the GCP connection is used.\n:type project_id: str", "id": "f9178:c0:m11"}
{"signature": "def _apply_to_instance(self, project_id, instance_id, configuration_name, node_count,<EOL>display_name, func):", "body": "<EOL>instance = self._get_client(project_id=project_id).instance(<EOL>instance_id=instance_id, configuration_name=configuration_name,<EOL>node_count=node_count, display_name=display_name)<EOL>try:<EOL><INDENT>operation = func(instance)  <EOL><DEDENT>except GoogleAPICallError as e:<EOL><INDENT>self.log.error('<STR_LIT>', e.message)<EOL>raise e<EOL><DEDENT>if operation:<EOL><INDENT>result = operation.result()<EOL>self.log.info(result)<EOL><DEDENT>", "docstring": "Invokes a method on a given instance by applying a specified Callable.\n\n:param project_id: The ID of the  GCP project that owns the Cloud Spanner\n    database.\n:type project_id: str\n:param instance_id: The ID of the instance.\n:type instance_id: str\n:param configuration_name: Name of the instance configuration defining how the\n    instance will be created. Required for instances which do not yet exist.\n:type configuration_name: str\n:param node_count: (Optional) Number of nodes allocated to the instance.\n:type node_count: int\n:param display_name: (Optional) The display name for the instance in the Cloud\n    Console UI. (Must be between 4 and 30 characters.) If this value is not set\n    in the constructor, will fall back to the instance ID.\n:type display_name: str\n:param func: Method of the instance to be called.\n:type func: Callable", "id": "f9178:c0:m3"}
{"signature": "def _get_client(self, project_id):", "body": "if not self._client:<EOL><INDENT>self._client = Client(project=project_id, credentials=self._get_credentials())<EOL><DEDENT>return self._client<EOL>", "docstring": "Provides a client for interacting with the Cloud Spanner API.\n\n:param project_id: The ID of the  GCP project.\n:type project_id: str\n:return: google.cloud.spanner_v1.client.Client\n:rtype: object", "id": "f9178:c0:m1"}
{"signature": "def post_event(self, title, text, aggregation_key=None, alert_type=None, date_happened=None,<EOL>handle=None, priority=None, related_event_id=None, tags=None, device_name=None):", "body": "response = api.Event.create(<EOL>title=title,<EOL>text=text,<EOL>aggregation_key=aggregation_key,<EOL>alert_type=alert_type,<EOL>date_happened=date_happened,<EOL>handle=handle,<EOL>priority=priority,<EOL>related_event_id=related_event_id,<EOL>tags=tags,<EOL>host=self.host,<EOL>device_name=device_name,<EOL>source_type_name=self.source_type_name)<EOL>self.validate_response(response)<EOL>return response<EOL>", "docstring": "Posts an event to datadog (processing finished, potentially alerts, other issues)\nThink about this as a means to maintain persistence of alerts, rather than\nalerting itself.\n\n:param title: The title of the event\n:type title: str\n:param text: The body of the event (more information)\n:type text: str\n:param aggregation_key: Key that can be used to aggregate this event in a stream\n:type aggregation_key: str\n:param alert_type: The alert type for the event, one of\n    [\"error\", \"warning\", \"info\", \"success\"]\n:type alert_type: str\n:param date_happened: POSIX timestamp of the event; defaults to now\n:type date_happened: int\n:handle: User to post the event as; defaults to owner of the application key used\n    to submit.\n:param handle: str\n:param priority: Priority to post the event as. (\"normal\" or \"low\", defaults to \"normal\")\n:type priority: str\n:param related_event_id: Post event as a child of the given event\n:type related_event_id: id\n:param tags: List of tags to apply to the event\n:type tags: list[str]\n:param device_name: device_name to post the event with\n:type device_name: list", "id": "f9179:c0:m4"}
{"signature": "def send_metric(self, metric_name, datapoint, tags=None, type_=None, interval=None):", "body": "response = api.Metric.send(<EOL>metric=metric_name,<EOL>points=datapoint,<EOL>host=self.host,<EOL>tags=tags,<EOL>type=type_,<EOL>interval=interval)<EOL>self.validate_response(response)<EOL>return response<EOL>", "docstring": "Sends a single datapoint metric to DataDog\n\n:param metric_name: The name of the metric\n:type metric_name: str\n:param datapoint: A single integer or float related to the metric\n:type datapoint: int or float\n:param tags: A list of tags associated with the metric\n:type tags: list\n:param type_: Type of your metric: gauge, rate, or count\n:type type_: str\n:param interval: If the type of the metric is rate or count, define the corresponding interval\n:type interval: int", "id": "f9179:c0:m2"}
{"signature": "@GoogleCloudBaseHook.catch_http_exception<EOL><INDENT>def classify_text(self, document, retry=None, timeout=None, metadata=None):<DEDENT>", "body": "client = self.get_conn()<EOL>return client.classify_text(document=document, retry=retry, timeout=timeout, metadata=metadata)<EOL>", "docstring": "Classifies a document into categories.\n\n:param document: Input document.\n    If a dict is provided, it must be of the same form as the protobuf message Document\n:type document: dict or class google.cloud.language_v1.types.Document\n:param retry: A retry object used to retry requests. If None is specified, requests will not be\n    retried.\n:type retry: google.api_core.retry.Retry\n:param timeout: The amount of time, in seconds, to wait for the request to complete. Note that if\n    retry is specified, the timeout applies to each individual attempt.\n:type timeout: float\n:param metadata: Additional metadata that is provided to the method.\n:type metadata: sequence[tuple[str, str]]]\n:rtype: google.cloud.language_v1.types.AnalyzeEntitiesResponse", "id": "f9180:c0:m7"}
{"signature": "@GoogleCloudBaseHook.catch_http_exception<EOL><INDENT>def analyze_entities(self, document, encoding_type=None, retry=None, timeout=None, metadata=None):<DEDENT>", "body": "client = self.get_conn()<EOL>return client.analyze_entities(<EOL>document=document, encoding_type=encoding_type, retry=retry, timeout=timeout, metadata=metadata<EOL>)<EOL>", "docstring": "Finds named entities in the text along with entity types,\nsalience, mentions for each entity, and other properties.\n\n:param document: Input document.\n    If a dict is provided, it must be of the same form as the protobuf message Document\n:type document: dict or class google.cloud.language_v1.types.Document\n:param encoding_type: The encoding type used by the API to calculate offsets.\n:type encoding_type: google.cloud.language_v1.types.EncodingType\n:param retry: A retry object used to retry requests. If None is specified, requests will not be\n    retried.\n:type retry: google.api_core.retry.Retry\n:param timeout: The amount of time, in seconds, to wait for the request to complete. Note that if\n    retry is specified, the timeout applies to each individual attempt.\n:type timeout: float\n:param metadata: Additional metadata that is provided to the method.\n:type metadata: sequence[tuple[str, str]]]\n:rtype: google.cloud.language_v1.types.AnalyzeEntitiesResponse", "id": "f9180:c0:m2"}
{"signature": "@GoogleCloudBaseHook.catch_http_exception<EOL><INDENT>def annotate_text(self, document, features, encoding_type=None, retry=None, timeout=None, metadata=None):<DEDENT>", "body": "client = self.get_conn()<EOL>return client.annotate_text(<EOL>document=document,<EOL>features=features,<EOL>encoding_type=encoding_type,<EOL>retry=retry,<EOL>timeout=timeout,<EOL>metadata=metadata,<EOL>)<EOL>", "docstring": "A convenience method that provides all the features that analyzeSentiment,\nanalyzeEntities, and analyzeSyntax provide in one call.\n\n:param document: Input document.\n    If a dict is provided, it must be of the same form as the protobuf message Document\n:type document: dict or google.cloud.language_v1.types.Document\n:param features: The enabled features.\n    If a dict is provided, it must be of the same form as the protobuf message Features\n:type features: dict or google.cloud.language_v1.enums.Features\n:param encoding_type: The encoding type used by the API to calculate offsets.\n:type encoding_type: google.cloud.language_v1.types.EncodingType\n:param retry: A retry object used to retry requests. If None is specified, requests will not be\n    retried.\n:type retry: google.api_core.retry.Retry\n:param timeout: The amount of time, in seconds, to wait for the request to complete. Note that if\n    retry is specified, the timeout applies to each individual attempt.\n:type timeout: float\n:param metadata: Additional metadata that is provided to the method.\n:type metadata: sequence[tuple[str, str]]]\n:rtype: google.cloud.language_v1.types.AnnotateTextResponse", "id": "f9180:c0:m6"}
{"signature": "@GoogleCloudBaseHook.catch_http_exception<EOL><INDENT>def analyze_entity_sentiment(self, document, encoding_type=None, retry=None, timeout=None, metadata=None):<DEDENT>", "body": "client = self.get_conn()<EOL>return client.analyze_entity_sentiment(<EOL>document=document, encoding_type=encoding_type, retry=retry, timeout=timeout, metadata=metadata<EOL>)<EOL>", "docstring": "Finds entities, similar to AnalyzeEntities in the text and analyzes sentiment associated with each\nentity and its mentions.\n\n:param document: Input document.\n    If a dict is provided, it must be of the same form as the protobuf message Document\n:type document: dict or class google.cloud.language_v1.types.Document\n:param encoding_type: The encoding type used by the API to calculate offsets.\n:type encoding_type: google.cloud.language_v1.types.EncodingType\n:param retry: A retry object used to retry requests. If None is specified, requests will not be\n    retried.\n:type retry: google.api_core.retry.Retry\n:param timeout: The amount of time, in seconds, to wait for the request to complete. Note that if\n    retry is specified, the timeout applies to each individual attempt.\n:type timeout: float\n:param metadata: Additional metadata that is provided to the method.\n:type metadata: sequence[tuple[str, str]]]\n:rtype: google.cloud.language_v1.types.AnalyzeEntitiesResponse", "id": "f9180:c0:m3"}
{"signature": "def get_conn(self):", "body": "self.conn = self.get_client_type('<STR_LIT>', self.region_name)<EOL>return self.conn<EOL>", "docstring": "Returns AwsHook connection object.", "id": "f9182:c0:m1"}
{"signature": "@GoogleCloudBaseHook.catch_http_exception<EOL><INDENT>@GoogleCloudBaseHook.fallback_to_default_project_id<EOL>def remove_product_from_product_set(<EOL>self,<EOL>product_set_id,<EOL>product_id,<EOL>location=None,<EOL>project_id=None,<EOL>retry=None,<EOL>timeout=None,<EOL>metadata=None,<EOL>):<DEDENT>", "body": "client = self.get_conn()<EOL>product_name = ProductSearchClient.product_path(project_id, location, product_id)<EOL>product_set_name = ProductSearchClient.product_set_path(project_id, location, product_set_id)<EOL>self.log.info('<STR_LIT>', product_name, product_set_name)<EOL>client.remove_product_from_product_set(<EOL>name=product_set_name, product=product_name, retry=retry, timeout=timeout, metadata=metadata<EOL>)<EOL>self.log.info('<STR_LIT>')<EOL>", "docstring": "For the documentation see:\n:py:class:`~airflow.contrib.operators.gcp_vision_operator.CloudVisionRemoveProductFromProductSetOperator`", "id": "f9183:c1:m15"}
{"signature": "@GoogleCloudBaseHook.catch_http_exception<EOL><INDENT>@GoogleCloudBaseHook.fallback_to_default_project_id<EOL>def add_product_to_product_set(<EOL>self,<EOL>product_set_id,<EOL>product_id,<EOL>location=None,<EOL>project_id=None,<EOL>retry=None,<EOL>timeout=None,<EOL>metadata=None,<EOL>):<DEDENT>", "body": "client = self.get_conn()<EOL>product_name = ProductSearchClient.product_path(project_id, location, product_id)<EOL>product_set_name = ProductSearchClient.product_set_path(project_id, location, product_set_id)<EOL>self.log.info('<STR_LIT>', product_name, product_set_name)<EOL>client.add_product_to_product_set(<EOL>name=product_set_name, product=product_name, retry=retry, timeout=timeout, metadata=metadata<EOL>)<EOL>self.log.info('<STR_LIT>')<EOL>", "docstring": "For the documentation see:\n:py:class:`~airflow.contrib.operators.gcp_vision_operator.CloudVisionAddProductToProductSetOperator`", "id": "f9183:c1:m14"}
{"signature": "@GoogleCloudBaseHook.catch_http_exception<EOL><INDENT>@GoogleCloudBaseHook.fallback_to_default_project_id<EOL>def get_product(self, location, product_id, project_id=None, retry=None, timeout=None, metadata=None):<DEDENT>", "body": "client = self.get_conn()<EOL>name = ProductSearchClient.product_path(project_id, location, product_id)<EOL>self.log.info('<STR_LIT>', name)<EOL>response = client.get_product(name=name, retry=retry, timeout=timeout, metadata=metadata)<EOL>self.log.info('<STR_LIT>')<EOL>self.log.debug('<STR_LIT>', response)<EOL>return MessageToDict(response)<EOL>", "docstring": "For the documentation see:\n:class:`~airflow.contrib.operators.gcp_vision_operator.CloudVisionProductGetOperator`", "id": "f9183:c1:m9"}
{"signature": "@GoogleCloudBaseHook.catch_http_exception<EOL><INDENT>def text_detection(<EOL>self, image, max_results=None, retry=None, timeout=None, additional_properties=None<EOL>):<DEDENT>", "body": "client = self.annotator_client<EOL>self.log.info(\"<STR_LIT>\")<EOL>if additional_properties is None:<EOL><INDENT>additional_properties = {}<EOL><DEDENT>response = client.text_detection(<EOL>image=image, max_results=max_results, retry=retry, timeout=timeout, **additional_properties<EOL>)<EOL>response = MessageToDict(response)<EOL>self._check_for_error(response)<EOL>self.log.info(\"<STR_LIT>\")<EOL>return response<EOL>", "docstring": "For the documentation see:\n:py:class:`~airflow.contrib.operators.gcp_vision_operator.CloudVisionDetectTextOperator`", "id": "f9183:c1:m17"}
{"signature": "@GoogleCloudBaseHook.catch_http_exception<EOL><INDENT>@GoogleCloudBaseHook.fallback_to_default_project_id<EOL>def create_reference_image(<EOL>self,<EOL>location,<EOL>product_id,<EOL>reference_image,<EOL>reference_image_id=None,<EOL>project_id=None,<EOL>retry=None,<EOL>timeout=None,<EOL>metadata=None,<EOL>):<DEDENT>", "body": "client = self.get_conn()<EOL>self.log.info('<STR_LIT>')<EOL>parent = ProductSearchClient.product_path(project=project_id, location=location, product=product_id)<EOL>response = client.create_reference_image(<EOL>parent=parent,<EOL>reference_image=reference_image,<EOL>reference_image_id=reference_image_id,<EOL>retry=retry,<EOL>timeout=timeout,<EOL>metadata=metadata,<EOL>)<EOL>self.log.info('<STR_LIT>', response.name if response else '<STR_LIT>')<EOL>self.log.debug('<STR_LIT>', response)<EOL>if not reference_image_id:<EOL><INDENT>reference_image_id = self._get_autogenerated_id(response)<EOL>self.log.info(<EOL>'<STR_LIT>', reference_image_id<EOL>)<EOL><DEDENT>return reference_image_id<EOL>", "docstring": "For the documentation see:\n:py:class:`~airflow.contrib.operators.gcp_vision_operator.CloudVisionReferenceImageCreateOperator`", "id": "f9183:c1:m12"}
{"signature": "@GoogleCloudBaseHook.catch_http_exception<EOL><INDENT>@GoogleCloudBaseHook.fallback_to_default_project_id<EOL>def update_product(<EOL>self,<EOL>product,<EOL>location=None,<EOL>product_id=None,<EOL>update_mask=None,<EOL>project_id=None,<EOL>retry=None,<EOL>timeout=None,<EOL>metadata=None,<EOL>):<DEDENT>", "body": "client = self.get_conn()<EOL>product = self.product_name_determiner.get_entity_with_name(product, product_id, location, project_id)<EOL>self.log.info('<STR_LIT>', product.name)<EOL>response = client.update_product(<EOL>product=product, update_mask=update_mask, retry=retry, timeout=timeout, metadata=metadata<EOL>)<EOL>self.log.info('<STR_LIT>', response.name if response else '<STR_LIT>')<EOL>self.log.debug('<STR_LIT>', response)<EOL>return MessageToDict(response)<EOL>", "docstring": "For the documentation see:\n:class:`~airflow.contrib.operators.gcp_vision_operator.CloudVisionProductUpdateOperator`", "id": "f9183:c1:m10"}
{"signature": "@GoogleCloudBaseHook.catch_http_exception<EOL><INDENT>def annotate_image(self, request, retry=None, timeout=None):<DEDENT>", "body": "client = self.annotator_client<EOL>self.log.info('<STR_LIT>')<EOL>response = client.annotate_image(request=request, retry=retry, timeout=timeout)<EOL>self.log.info('<STR_LIT>')<EOL>return MessageToDict(response)<EOL>", "docstring": "For the documentation see:\n:py:class:`~airflow.contrib.operators.gcp_vision_image_annotator_operator.CloudVisionAnnotateImage`", "id": "f9183:c1:m16"}
{"signature": "@GoogleCloudBaseHook.fallback_to_default_project_id<EOL><INDENT>def delete_table(self, instance_id, table_id, project_id=None):<DEDENT>", "body": "table = self.get_instance(instance_id=instance_id, project_id=project_id).table(table_id=table_id)<EOL>table.delete()<EOL>", "docstring": "Deletes the specified table in Cloud Bigtable.\nRaises google.api_core.exceptions.NotFound if the table does not exist.\n\n:type instance_id: str\n:param instance_id: The ID of the Cloud Bigtable instance.\n:type table_id: str\n:param table_id: The ID of the table in Cloud Bigtable.\n:type project_id: str\n:param project_id: Optional, Google Cloud Platform project ID where the\n    BigTable exists. If set to None or missing,\n    the default project_id from the GCP connection is used.", "id": "f9184:c0:m6"}
{"signature": "@staticmethod<EOL><INDENT>def get_cluster_states_for_table(instance, table_id):<DEDENT>", "body": "table = Table(table_id, instance)<EOL>return table.get_cluster_states()<EOL>", "docstring": "Fetches Cluster States for the specified table in Cloud Bigtable.\nRaises google.api_core.exceptions.NotFound if the table does not exist.\n\n:type instance: Instance\n:param instance: The Cloud Bigtable instance that owns the table.\n:type table_id: str\n:param table_id: The ID of the table in Cloud Bigtable to fetch Cluster States\n    from.", "id": "f9184:c0:m9"}
{"signature": "@GoogleCloudBaseHook.fallback_to_default_project_id<EOL><INDENT>def get_instance(self, instance_id, project_id=None):<DEDENT>", "body": "instance = self._get_client(project_id=project_id).instance(instance_id)<EOL>if not instance.exists():<EOL><INDENT>return None<EOL><DEDENT>return instance<EOL>", "docstring": "Retrieves and returns the specified Cloud Bigtable instance if it exists.\nOtherwise, returns None.\n\n:param instance_id: The ID of the Cloud Bigtable instance.\n:type instance_id: str\n:param project_id: Optional, Google Cloud Platform project ID where the\n    BigTable exists. If set to None or missing,\n    the default project_id from the GCP connection is used.\n:type project_id: str", "id": "f9184:c0:m2"}
{"signature": "def download_file(self, local_path, remote_path, nthreads=<NUM_LIT:64>, overwrite=True,<EOL>buffersize=<NUM_LIT>, blocksize=<NUM_LIT>):", "body": "multithread.ADLDownloader(self.connection,<EOL>lpath=local_path,<EOL>rpath=remote_path,<EOL>nthreads=nthreads,<EOL>overwrite=overwrite,<EOL>buffersize=buffersize,<EOL>blocksize=blocksize)<EOL>", "docstring": "Download a file from Azure Blob Storage.\n\n:param local_path: local path. If downloading a single file, will write to this\n    specific file, unless it is an existing directory, in which case a file is\n    created within it. If downloading multiple files, this is the root\n    directory to write within. Will create directories as required.\n:type local_path: str\n:param remote_path: remote path/globstring to use to find remote files.\n    Recursive glob patterns using `**` are not supported.\n:type remote_path: str\n:param nthreads: Number of threads to use. If None, uses the number of cores.\n:type nthreads: int\n:param overwrite: Whether to forcibly overwrite existing files/directories.\n    If False and remote path is a directory, will quit regardless if any files\n    would be overwritten or not. If True, only matching filenames are actually\n    overwritten.\n:type overwrite: bool\n:param buffersize: int [2**22]\n    Number of bytes for internal buffer. This block cannot be bigger than\n    a chunk and cannot be smaller than a block.\n:type buffersize: int\n:param blocksize: int [2**22]\n    Number of bytes for a block. Within each chunk, we write a smaller\n    block for each API call. This block cannot be bigger than a chunk.\n:type blocksize: int", "id": "f9186:c0:m4"}
{"signature": "def table_exists(self, table):", "body": "keyspace = self.keyspace<EOL>if '<STR_LIT:.>' in table:<EOL><INDENT>keyspace, table = table.split('<STR_LIT:.>', <NUM_LIT:1>)<EOL><DEDENT>cluster_metadata = self.get_conn().cluster.metadata<EOL>return (keyspace in cluster_metadata.keyspaces and<EOL>table in cluster_metadata.keyspaces[keyspace].tables)<EOL>", "docstring": "Checks if a table exists in Cassandra\n\n:param table: Target Cassandra table.\n              Use dot notation to target a specific keyspace.\n:type table: str", "id": "f9187:c0:m5"}
{"signature": "def get_state_exitcode_details(self, resource_group, name):", "body": "current_state = self._get_instance_view(resource_group, name).current_state<EOL>return (current_state.state,<EOL>current_state.exit_code,<EOL>current_state.detail_status)<EOL>", "docstring": "Get the state and exitcode of a container group\n\n:param resource_group: the name of the resource group\n:type resource_group: str\n:param name: the name of the container group\n:type name: str\n:return: A tuple with the state, exitcode, and details.\n    If the exitcode is unknown 0 is returned.\n:rtype: tuple(state,exitcode,details)", "id": "f9188:c0:m3"}
{"signature": "def exists(self, resource_group, name):", "body": "for container in self.connection.container_groups.list_by_resource_group(resource_group):<EOL><INDENT>if container.name == name:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Test if a container group exists\n\n:param resource_group: the name of the resource group\n:type resource_group: str\n:param name: the name of the container group\n:type name: str", "id": "f9188:c0:m8"}
{"signature": "@staticmethod<EOL><INDENT>def _full_location(project_id, location):<DEDENT>", "body": "return '<STR_LIT>'.format(project_id, location)<EOL>", "docstring": "Retrieve full location of the function in the form of\nprojects/<GCP_PROJECT_ID>/locations/<GCP_LOCATION>\n\n:param project_id: The Google Cloud Project project_id where the function belongs.\n:type project_id: str\n:param location: The location where the function is created.\n:type location: str\n:return:", "id": "f9189:c0:m1"}
{"signature": "def get_function(self, name):", "body": "return self.get_conn().projects().locations().functions().get(<EOL>name=name).execute(num_retries=self.num_retries)<EOL>", "docstring": "Returns the Cloud Function with the given name.\n\n:param name: Name of the function.\n:type name: str\n:return: A Cloud Functions object representing the function.\n:rtype: dict", "id": "f9189:c0:m3"}
{"signature": "def _wait_for_operation_to_complete(self, operation_name):", "body": "service = self.get_conn()<EOL>while True:<EOL><INDENT>operation_response = service.operations().get(<EOL>name=operation_name,<EOL>).execute(num_retries=self.num_retries)<EOL>if operation_response.get(\"<STR_LIT>\"):<EOL><INDENT>response = operation_response.get(\"<STR_LIT>\")<EOL>error = operation_response.get(\"<STR_LIT:error>\")<EOL>if error:<EOL><INDENT>raise AirflowException(str(error))<EOL><DEDENT>return response<EOL><DEDENT>time.sleep(TIME_TO_SLEEP_IN_SECONDS)<EOL><DEDENT>", "docstring": "Waits for the named operation to complete - checks status of the\nasynchronous call.\n\n:param operation_name: The name of the operation.\n:type operation_name: str\n:return: The response returned by the operation.\n:rtype: dict\n:exception: AirflowException in case error is returned.", "id": "f9189:c0:m8"}
{"signature": "def update_function(self, name, body, update_mask):", "body": "response = self.get_conn().projects().locations().functions().patch(<EOL>updateMask=\"<STR_LIT:U+002C>\".join(update_mask),<EOL>name=name,<EOL>body=body<EOL>).execute(num_retries=self.num_retries)<EOL>operation_name = response[\"<STR_LIT:name>\"]<EOL>self._wait_for_operation_to_complete(operation_name=operation_name)<EOL>", "docstring": "Updates Cloud Functions according to the specified update mask.\n\n:param name: The name of the function.\n:type name: str\n:param body: The body required by the cloud function patch API.\n:type body: dict\n:param update_mask: The update mask - array of fields that should be patched.\n:type update_mask: [str]\n:return: None", "id": "f9189:c0:m5"}
{"signature": "def insert_object_acl(self, bucket_name, object_name, entity, role, user_project=None):", "body": "self.log.info('<STR_LIT>',<EOL>object_name, bucket_name)<EOL>client = self.get_conn()<EOL>bucket = client.bucket(bucket_name=bucket_name)<EOL>blob = bucket.blob(object_name)<EOL>blob.acl.reload()<EOL>blob.acl.entity_from_dict(entity_dict={\"<STR_LIT>\": entity, \"<STR_LIT>\": role})<EOL>if user_project:<EOL><INDENT>blob.acl.user_project = user_project<EOL><DEDENT>blob.acl.save()<EOL>self.log.info('<STR_LIT>',<EOL>object_name, bucket_name)<EOL>", "docstring": "Creates a new ACL entry on the specified object.\nSee: https://cloud.google.com/storage/docs/json_api/v1/objectAccessControls/insert\n\n:param bucket_name: Name of a bucket_name.\n:type bucket_name: str\n:param object_name: Name of the object. For information about how to URL encode\n    object names to be path safe, see:\n    https://cloud.google.com/storage/docs/json_api/#encoding\n:type object_name: str\n:param entity: The entity holding the permission, in one of the following forms:\n    user-userId, user-email, group-groupId, group-email, domain-domain,\n    project-team-projectId, allUsers, allAuthenticatedUsers\n    See: https://cloud.google.com/storage/docs/access-control/lists#scopes\n:type entity: str\n:param role: The access permission for the entity.\n    Acceptable values are: \"OWNER\", \"READER\".\n:type role: str\n:param user_project: (Optional) The project to be billed for this request.\n    Required for Requester Pays buckets.\n:type user_project: str", "id": "f9190:c0:m15"}
{"signature": "def upload(self, bucket_name, object_name, filename,<EOL>mime_type='<STR_LIT>', gzip=False):", "body": "if gzip:<EOL><INDENT>filename_gz = filename + '<STR_LIT>'<EOL>with open(filename, '<STR_LIT:rb>') as f_in:<EOL><INDENT>with gz.open(filename_gz, '<STR_LIT:wb>') as f_out:<EOL><INDENT>shutil.copyfileobj(f_in, f_out)<EOL>filename = filename_gz<EOL><DEDENT><DEDENT><DEDENT>client = self.get_conn()<EOL>bucket = client.get_bucket(bucket_name=bucket_name)<EOL>blob = bucket.blob(blob_name=object_name)<EOL>blob.upload_from_filename(filename=filename,<EOL>content_type=mime_type)<EOL>if gzip:<EOL><INDENT>os.remove(filename)<EOL><DEDENT>self.log.info('<STR_LIT>', filename, object_name, bucket_name)<EOL>", "docstring": "Uploads a local file to Google Cloud Storage.\n\n:param bucket_name: The bucket to upload to.\n:type bucket_name: str\n:param object_name: The object name to set when uploading the local file.\n:type object_name: str\n:param filename: The local file path to the file to be uploaded.\n:type filename: str\n:param mime_type: The MIME type to set when uploading the file.\n:type mime_type: str\n:param gzip: Option to compress file for upload\n:type gzip: bool", "id": "f9190:c0:m5"}
{"signature": "def download(self, bucket_name, object_name, filename=None):", "body": "client = self.get_conn()<EOL>bucket = client.get_bucket(bucket_name)<EOL>blob = bucket.blob(blob_name=object_name)<EOL>if filename:<EOL><INDENT>blob.download_to_filename(filename)<EOL>self.log.info('<STR_LIT>', filename)<EOL><DEDENT>return blob.download_as_string()<EOL>", "docstring": "Get a file from Google Cloud Storage.\n\n:param bucket_name: The bucket to fetch from.\n:type bucket_name: str\n:param object_name: The object to fetch.\n:type object_name: str\n:param filename: If set, a local file path where the file should be written to.\n:type filename: str", "id": "f9190:c0:m4"}
{"signature": "def export_table(self, table, export_dir, input_null_string,<EOL>input_null_non_string, staging_table,<EOL>clear_staging_table, enclosed_by,<EOL>escaped_by, input_fields_terminated_by,<EOL>input_lines_terminated_by,<EOL>input_optionally_enclosed_by, batch,<EOL>relaxed_isolation, extra_export_options=None):", "body": "cmd = self._export_cmd(table, export_dir, input_null_string,<EOL>input_null_non_string, staging_table,<EOL>clear_staging_table, enclosed_by, escaped_by,<EOL>input_fields_terminated_by,<EOL>input_lines_terminated_by,<EOL>input_optionally_enclosed_by, batch,<EOL>relaxed_isolation, extra_export_options)<EOL>self.Popen(cmd)<EOL>", "docstring": "Exports Hive table to remote location. Arguments are copies of direct\nsqoop command line Arguments\n\n:param table: Table remote destination\n:param export_dir: Hive table to export\n:param input_null_string: The string to be interpreted as null for\n    string columns\n:param input_null_non_string: The string to be interpreted as null\n    for non-string columns\n:param staging_table: The table in which data will be staged before\n    being inserted into the destination table\n:param clear_staging_table: Indicate that any data present in the\n    staging table can be deleted\n:param enclosed_by: Sets a required field enclosing character\n:param escaped_by: Sets the escape character\n:param input_fields_terminated_by: Sets the field separator character\n:param input_lines_terminated_by: Sets the end-of-line character\n:param input_optionally_enclosed_by: Sets a field enclosing character\n:param batch: Use batch mode for underlying statement execution\n:param relaxed_isolation: Transaction isolation to read uncommitted\n    for the mappers\n:param extra_export_options: Extra export options to pass as dict.\n    If a key doesn't have a value, just pass an empty string to it.\n    Don't include prefix of -- for sqoop options.", "id": "f9195:c0:m10"}
{"signature": "def get_conn(self):", "body": "conn = self.get_connection(self.cloudant_conn_id)<EOL>self._validate_connection(conn)<EOL>cloudant_session = cloudant(user=conn.login, passwd=conn.password, account=conn.host)<EOL>return cloudant_session<EOL>", "docstring": "Opens a connection to the cloudant service and closes it automatically if used as context manager.\n\n.. note::\n    In the connection form:\n    - 'host' equals the 'Account' (optional)\n    - 'login' equals the 'Username (or API Key)' (required)\n    - 'password' equals the 'Password' (required)\n\n:return: an authorized cloudant session context manager object.\n:rtype: cloudant", "id": "f9197:c0:m1"}
{"signature": "def run_next(self, next_job):", "body": "self.log.info('<STR_LIT>', str(next_job))<EOL>key, command, kube_executor_config = next_job<EOL>dag_id, task_id, execution_date, try_number = key<EOL>self.log.debug(\"<STR_LIT>\", command)<EOL>self.log.debug(\"<STR_LIT>\", self.kube_config.kube_image)<EOL>pod = self.worker_configuration.make_pod(<EOL>namespace=self.namespace, worker_uuid=self.worker_uuid,<EOL>pod_id=self._create_pod_id(dag_id, task_id),<EOL>dag_id=self._make_safe_label_value(dag_id),<EOL>task_id=self._make_safe_label_value(task_id),<EOL>try_number=try_number,<EOL>execution_date=self._datetime_to_label_safe_datestring(execution_date),<EOL>airflow_command=command, kube_executor_config=kube_executor_config<EOL>)<EOL>self.launcher.run_pod_async(pod)<EOL>self.log.debug(\"<STR_LIT>\")<EOL>", "docstring": "The run_next command will check the task_queue for any un-run jobs.\nIt will then create a unique job-id, launch that job in the cluster,\nand store relevant info in the current_jobs map so we can track the job's\nstatus", "id": "f9229:c3:m3"}
{"signature": "@staticmethod<EOL><INDENT>def _make_safe_pod_id(safe_dag_id, safe_task_id, safe_uuid):<DEDENT>", "body": "MAX_POD_ID_LEN = <NUM_LIT><EOL>safe_key = safe_dag_id + safe_task_id<EOL>safe_pod_id = safe_key[:MAX_POD_ID_LEN - len(safe_uuid) - <NUM_LIT:1>] + \"<STR_LIT:->\" + safe_uuid<EOL>return safe_pod_id<EOL>", "docstring": "Kubernetes pod names must be <= 253 chars and must pass the following regex for\nvalidation\n\"^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\\\\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$\"\n\n:param safe_dag_id: a dag_id with only alphanumeric characters\n:param safe_task_id: a task_id with only alphanumeric characters\n:param random_uuid: a uuid\n:return: ``str`` valid Pod name of appropriate length", "id": "f9229:c3:m8"}
{"signature": "@staticmethod<EOL><INDENT>def _make_safe_label_value(string):<DEDENT>", "body": "MAX_LABEL_LEN = <NUM_LIT><EOL>safe_label = re.sub(r'<STR_LIT>', '<STR_LIT>', string)<EOL>if len(safe_label) > MAX_LABEL_LEN or string != safe_label:<EOL><INDENT>safe_hash = hashlib.md5(string.encode()).hexdigest()[:<NUM_LIT:9>]<EOL>safe_label = safe_label[:MAX_LABEL_LEN - len(safe_hash) - <NUM_LIT:1>] + \"<STR_LIT:->\" + safe_hash<EOL><DEDENT>return safe_label<EOL>", "docstring": "Valid label values must be 63 characters or less and must be empty or begin and\nend with an alphanumeric character ([a-z0-9A-Z]) with dashes (-), underscores (_),\ndots (.), and alphanumerics between.\n\nIf the label value is then greater than 63 chars once made safe, or differs in any\nway from the original value sent to this function, then we need to truncate to\n53chars, and append it with a unique hash.", "id": "f9229:c3:m9"}
{"signature": "def execute(self, context):", "body": "super().execute(context)<EOL>return self._messages<EOL>", "docstring": "Overridden to allow messages to be passed", "id": "f9231:c0:m1"}
{"signature": "def is_bucket_updated(self, current_num_objects):", "body": "if current_num_objects > self.previous_num_objects:<EOL><INDENT>self.log.info(<EOL>'''<STR_LIT>'''.format(os.path.join(self.bucket, self.prefix)))<EOL>self.last_activity_time = get_time()<EOL>self.inactivity_seconds = <NUM_LIT:0><EOL>self.previous_num_objects = current_num_objects<EOL><DEDENT>elif current_num_objects < self.previous_num_objects:<EOL><INDENT>if self.allow_delete:<EOL><INDENT>self.previous_num_objects = current_num_objects<EOL>self.last_activity_time = get_time()<EOL>self.log.warning(<EOL>'''<STR_LIT>'''<EOL>)<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(<EOL>'''<STR_LIT>'''.format(os.path.join(self.bucket, self.prefix))<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if self.last_activity_time:<EOL><INDENT>self.inactivity_seconds = (<EOL>get_time() - self.last_activity_time).total_seconds()<EOL><DEDENT>else:<EOL><INDENT>self.last_activity_time = get_time()<EOL>self.inactivity_seconds = <NUM_LIT:0><EOL><DEDENT>if self.inactivity_seconds >= self.inactivity_period:<EOL><INDENT>if current_num_objects >= self.min_objects:<EOL><INDENT>self.log.info(<EOL>'''<STR_LIT>'''.format(<EOL>current_num_objects,<EOL>os.path.join(self.bucket, self.prefix),<EOL>self.inactivity_period))<EOL>return True<EOL><DEDENT>warn_msg ='''<STR_LIT>'''.format(<EOL>os.path.join(self.bucket, self.prefix))<EOL>self.log.warning(warn_msg)<EOL>return False<EOL><DEDENT>return False<EOL><DEDENT>", "docstring": "Checks whether new objects have been uploaded and the inactivity_period\nhas passed and updates the state of the sensor accordingly.\n\n:param current_num_objects: number of objects in bucket during last poke.\n:type current_num_objects: int", "id": "f9232:c3:m1"}
{"signature": "def _create_hook(self):", "body": "return FTPSHook(ftp_conn_id=self.ftp_conn_id)<EOL>", "docstring": "Return connection hook.", "id": "f9235:c1:m0"}
{"signature": "def _get_error_code(self, e):", "body": "try:<EOL><INDENT>matches = self.error_code_pattern.match(str(e))<EOL>code = int(matches.group(<NUM_LIT:0>))<EOL>return code<EOL><DEDENT>except ValueError:<EOL><INDENT>return e<EOL><DEDENT>", "docstring": "Extract error code from ftp exception", "id": "f9235:c0:m2"}
{"signature": "def poke(self, context):", "body": "self.log.info('<STR_LIT>', self.attachment_name)<EOL>with ImapHook(imap_conn_id=self.conn_id) as imap_hook:<EOL><INDENT>return imap_hook.has_mail_attachment(<EOL>name=self.attachment_name,<EOL>mail_folder=self.mail_folder,<EOL>check_regex=self.check_regex<EOL>)<EOL><DEDENT>", "docstring": "Pokes for a mail attachment on the mail server.\n\n:param context: The context that is being provided when poking.\n:type context: dict\n:return: True if attachment with the given name is present and False if not.\n:rtype: bool", "id": "f9239:c0:m1"}
{"signature": "def poke(self, context):", "body": "sqs_hook = SQSHook(aws_conn_id=self.aws_conn_id)<EOL>sqs_conn = sqs_hook.get_conn()<EOL>self.log.info('<STR_LIT>', self.sqs_queue)<EOL>messages = sqs_conn.receive_message(QueueUrl=self.sqs_queue,<EOL>MaxNumberOfMessages=self.max_messages,<EOL>WaitTimeSeconds=self.wait_time_seconds)<EOL>self.log.info(\"<STR_LIT>\", str(messages))<EOL>if '<STR_LIT>' in messages and len(messages['<STR_LIT>']) > <NUM_LIT:0>:<EOL><INDENT>entries = [{'<STR_LIT>': message['<STR_LIT>'], '<STR_LIT>': message['<STR_LIT>']}<EOL>for message in messages['<STR_LIT>']]<EOL>result = sqs_conn.delete_message_batch(QueueUrl=self.sqs_queue,<EOL>Entries=entries)<EOL>if '<STR_LIT>' in result:<EOL><INDENT>context['<STR_LIT>'].xcom_push(key='<STR_LIT>', value=messages)<EOL>return True<EOL><DEDENT>else:<EOL><INDENT>raise AirflowException(<EOL>'<STR_LIT>' + str(result) + '<STR_LIT>' + str(messages))<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Check for message on subscribed queue and write to xcom the message with key ``messages``\n\n:param context: the context object\n:type context: dict\n:return: ``True`` if message is available or ``False``", "id": "f9259:c0:m1"}
{"signature": "def poke(self, context):", "body": "bash_command = self.bash_command<EOL>self.log.info(\"<STR_LIT>\", gettempdir())<EOL>with TemporaryDirectory(prefix='<STR_LIT>') as tmp_dir:<EOL><INDENT>with NamedTemporaryFile(dir=tmp_dir, prefix=self.task_id) as f:<EOL><INDENT>f.write(bytes(bash_command, '<STR_LIT>'))<EOL>f.flush()<EOL>fname = f.name<EOL>script_location = tmp_dir + \"<STR_LIT:/>\" + fname<EOL>self.log.info(\"<STR_LIT>\", script_location)<EOL>self.log.info(\"<STR_LIT>\", bash_command)<EOL>sp = Popen(<EOL>['<STR_LIT>', fname],<EOL>stdout=PIPE, stderr=STDOUT,<EOL>close_fds=True, cwd=tmp_dir,<EOL>env=self.env, preexec_fn=os.setsid)<EOL>self.sp = sp<EOL>self.log.info(\"<STR_LIT>\")<EOL>line = '<STR_LIT>'<EOL>for line in iter(sp.stdout.readline, b'<STR_LIT>'):<EOL><INDENT>line = line.decode(self.output_encoding).strip()<EOL>self.log.info(line)<EOL><DEDENT>sp.wait()<EOL>self.log.info(\"<STR_LIT>\", sp.returncode)<EOL>return not sp.returncode<EOL><DEDENT><DEDENT>", "docstring": "Execute the bash command in a temporary directory\nwhich will be cleaned afterwards", "id": "f9262:c0:m1"}
{"signature": "def _get_field(self, extras, field, default=None):", "body": "long_f = '<STR_LIT>'.format(field)<EOL>if long_f in extras:<EOL><INDENT>return extras[long_f]<EOL><DEDENT>else:<EOL><INDENT>self.log.info('<STR_LIT>', field)<EOL>return default<EOL><DEDENT>", "docstring": "Fetches a field from extras, and returns it. This is some Airflow\nmagic. The google_cloud_platform hook type adds custom UI elements\nto the hook page, which allow admins to specify service_account,\nkey_path, etc. They get formatted as shown below.", "id": "f9266:c2:m3"}
{"signature": "def execute(self, context):", "body": "hook = WasbHook(wasb_conn_id=self.wasb_conn_id)<EOL>self.log.info(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(self.file_path, self.container_name, self.blob_name)<EOL>)<EOL>hook.load_file(self.file_path, self.container_name,<EOL>self.blob_name, **self.load_options)<EOL>", "docstring": "Upload a file to Azure Blob Storage.", "id": "f9274:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def _convert_date_to_dict(field_date):<DEDENT>", "body": "return {DAY: field_date.day, MONTH: field_date.month, YEAR: field_date.year}<EOL>", "docstring": "Convert native python ``datetime.date`` object  to a format supported by the API", "id": "f9287:c0:m6"}
{"signature": "def _normalize_mlengine_job_id(job_id):", "body": "<EOL>match = re.search(r'<STR_LIT>', job_id)<EOL>if match and match.start() == <NUM_LIT:0>:<EOL><INDENT>job = '<STR_LIT>'.format(job_id)<EOL><DEDENT>else:<EOL><INDENT>job = job_id<EOL><DEDENT>tracker = <NUM_LIT:0><EOL>cleansed_job_id = '<STR_LIT>'<EOL>for m in re.finditer(r'<STR_LIT>', job):<EOL><INDENT>cleansed_job_id += re.sub(r'<STR_LIT>', '<STR_LIT:_>',<EOL>job[tracker:m.start()])<EOL>cleansed_job_id += job[m.start():m.end()]<EOL>tracker = m.end()<EOL><DEDENT>cleansed_job_id += re.sub(r'<STR_LIT>', '<STR_LIT:_>', job[tracker:])<EOL>return cleansed_job_id<EOL>", "docstring": "Replaces invalid MLEngine job_id characters with '_'.\n\nThis also adds a leading 'z' in case job_id starts with an invalid\ncharacter.\n\nArgs:\n    job_id: A job_id str that may have invalid characters.\n\nReturns:\n    A valid job_id representation.", "id": "f9297:m0"}
{"signature": "def execute(self, context):", "body": "self.hook = OpsgenieAlertHook(self.opsgenie_conn_id)<EOL>self.hook.execute(self._build_opsgenie_payload())<EOL>", "docstring": "Call the OpsgenieAlertHook to post message", "id": "f9302:c0:m2"}
{"signature": "def prepare_additional_parameters(additional_properties, language_hints, web_detection_params):", "body": "if language_hints is None and web_detection_params is None:<EOL><INDENT>return additional_properties<EOL><DEDENT>if additional_properties is None:<EOL><INDENT>return {}<EOL><DEDENT>merged_additional_parameters = deepcopy(additional_properties)<EOL>if '<STR_LIT>' not in merged_additional_parameters:<EOL><INDENT>merged_additional_parameters['<STR_LIT>'] = {}<EOL><DEDENT>merged_additional_parameters['<STR_LIT>']['<STR_LIT>'] = merged_additional_parameters[<EOL>'<STR_LIT>'<EOL>].get('<STR_LIT>', language_hints)<EOL>merged_additional_parameters['<STR_LIT>']['<STR_LIT>'] = merged_additional_parameters[<EOL>'<STR_LIT>'<EOL>].get('<STR_LIT>', web_detection_params)<EOL>return merged_additional_parameters<EOL>", "docstring": "Creates additional_properties parameter based on language_hints, web_detection_params and\nadditional_properties parameters specified by the user", "id": "f9315:m0"}
{"signature": "def _wait_for_task_ended(self):", "body": "try:<EOL><INDENT>waiter = self.client.get_waiter('<STR_LIT>')<EOL>waiter.config.max_attempts = sys.maxsize  <EOL>waiter.wait(jobs=[self.jobId])<EOL><DEDENT>except ValueError:<EOL><INDENT>retry = True<EOL>retries = <NUM_LIT:0><EOL>while retries < self.max_retries and retry:<EOL><INDENT>self.log.info('<STR_LIT>', retries)<EOL>response = self.client.describe_jobs(<EOL>jobs=[self.jobId]<EOL>)<EOL>if response['<STR_LIT>'][-<NUM_LIT:1>]['<STR_LIT:status>'] in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>retry = False<EOL><DEDENT>sleep(<NUM_LIT:1> + pow(retries * <NUM_LIT:0.1>, <NUM_LIT:2>))<EOL>retries += <NUM_LIT:1><EOL><DEDENT><DEDENT>", "docstring": "Try to use a waiter from the below pull request\n\n    * https://github.com/boto/botocore/pull/1307\n\nIf the waiter is not available apply a exponential backoff\n\n    * docs.aws.amazon.com/general/latest/gr/api-retries.html", "id": "f9317:c0:m2"}
{"signature": "@apply_defaults<EOL><INDENT>def __init__(<EOL>self,<EOL>job_id,<EOL>json=None,<EOL>notebook_params=None,<EOL>python_params=None,<EOL>spark_submit_params=None,<EOL>databricks_conn_id='<STR_LIT>',<EOL>polling_period_seconds=<NUM_LIT:30>,<EOL>databricks_retry_limit=<NUM_LIT:3>,<EOL>databricks_retry_delay=<NUM_LIT:1>,<EOL>do_xcom_push=False,<EOL>**kwargs):<DEDENT>", "body": "super().__init__(**kwargs)<EOL>self.json = json or {}<EOL>self.databricks_conn_id = databricks_conn_id<EOL>self.polling_period_seconds = polling_period_seconds<EOL>self.databricks_retry_limit = databricks_retry_limit<EOL>self.databricks_retry_delay = databricks_retry_delay<EOL>if job_id is not None:<EOL><INDENT>self.json['<STR_LIT>'] = job_id<EOL><DEDENT>if notebook_params is not None:<EOL><INDENT>self.json['<STR_LIT>'] = notebook_params<EOL><DEDENT>if python_params is not None:<EOL><INDENT>self.json['<STR_LIT>'] = python_params<EOL><DEDENT>if spark_submit_params is not None:<EOL><INDENT>self.json['<STR_LIT>'] = spark_submit_params<EOL><DEDENT>self.json = _deep_string_coerce(self.json)<EOL>self.run_id = None<EOL>self.do_xcom_push = do_xcom_push<EOL>", "docstring": "Creates a new ``DatabricksRunNowOperator``.", "id": "f9320:c1:m0"}
{"signature": "def execute(self, context):", "body": "self.log.info(<EOL>'<STR_LIT>',<EOL>self.imap_attachment_name, self.s3_key<EOL>)<EOL>with ImapHook(imap_conn_id=self.imap_conn_id) as imap_hook:<EOL><INDENT>imap_mail_attachments = imap_hook.retrieve_mail_attachments(<EOL>name=self.imap_attachment_name,<EOL>mail_folder=self.imap_mail_folder,<EOL>check_regex=self.imap_check_regex,<EOL>latest_only=True<EOL>)<EOL><DEDENT>s3_hook = S3Hook(aws_conn_id=self.s3_conn_id)<EOL>s3_hook.load_bytes(bytes_data=imap_mail_attachments[<NUM_LIT:0>][<NUM_LIT:1>], key=self.s3_key)<EOL>", "docstring": "This function executes the transfer from the email server (via imap) into s3.\n\n:param context: The context while executing.\n:type context: dict", "id": "f9328:c0:m1"}
{"signature": "def _make_intermediate_dirs(sftp_client, remote_directory):", "body": "if remote_directory == '<STR_LIT:/>':<EOL><INDENT>sftp_client.chdir('<STR_LIT:/>')<EOL>return<EOL><DEDENT>if remote_directory == '<STR_LIT>':<EOL><INDENT>return<EOL><DEDENT>try:<EOL><INDENT>sftp_client.chdir(remote_directory)<EOL><DEDENT>except IOError:<EOL><INDENT>dirname, basename = os.path.split(remote_directory.rstrip('<STR_LIT:/>'))<EOL>_make_intermediate_dirs(sftp_client, dirname)<EOL>sftp_client.mkdir(basename)<EOL>sftp_client.chdir(basename)<EOL>return<EOL><DEDENT>", "docstring": "Create all the intermediate directories in a remote host\n\n:param sftp_client: A Paramiko SFTP client.\n:param remote_directory: Absolute Path of the directory containing the file\n:return:", "id": "f9333:m0"}
{"signature": "def google_cloud_to_local(self, file_name):", "body": "if not file_name.startswith('<STR_LIT>'):<EOL><INDENT>return file_name<EOL><DEDENT>path_components = file_name[self.GCS_PREFIX_LENGTH:].split('<STR_LIT:/>')<EOL>if len(path_components) < <NUM_LIT:2>:<EOL><INDENT>raise Exception(<EOL>'<STR_LIT>'<EOL>.format(file_name))<EOL><DEDENT>bucket_id = path_components[<NUM_LIT:0>]<EOL>object_id = '<STR_LIT:/>'.join(path_components[<NUM_LIT:1>:])<EOL>local_file = '<STR_LIT>'.format(str(uuid.uuid4())[:<NUM_LIT:8>],<EOL>path_components[-<NUM_LIT:1>])<EOL>self._gcs_hook.download(bucket_id, object_id, local_file)<EOL>if os.stat(local_file).st_size > <NUM_LIT:0>:<EOL><INDENT>return local_file<EOL><DEDENT>raise Exception(<EOL>'<STR_LIT>'<EOL>.format(file_name))<EOL>", "docstring": "Checks whether the file specified by file_name is stored in Google Cloud\nStorage (GCS), if so, downloads the file and saves it locally. The full\npath of the saved file will be returned. Otherwise the local file_name\nwill be returned immediately.\n\n:param file_name: The full path of input file.\n:type file_name: str\n:return: The full path of local file.\n:rtype: str", "id": "f9334:c3:m1"}
{"signature": "def execute(self, context):", "body": "self.hook = SqoopHook(<EOL>conn_id=self.conn_id,<EOL>verbose=self.verbose,<EOL>num_mappers=self.num_mappers,<EOL>hcatalog_database=self.hcatalog_database,<EOL>hcatalog_table=self.hcatalog_table,<EOL>properties=self.properties<EOL>)<EOL>if self.cmd_type == '<STR_LIT>':<EOL><INDENT>self.hook.export_table(<EOL>table=self.table,<EOL>export_dir=self.export_dir,<EOL>input_null_string=self.input_null_string,<EOL>input_null_non_string=self.input_null_non_string,<EOL>staging_table=self.staging_table,<EOL>clear_staging_table=self.clear_staging_table,<EOL>enclosed_by=self.enclosed_by,<EOL>escaped_by=self.escaped_by,<EOL>input_fields_terminated_by=self.input_fields_terminated_by,<EOL>input_lines_terminated_by=self.input_lines_terminated_by,<EOL>input_optionally_enclosed_by=self.input_optionally_enclosed_by,<EOL>batch=self.batch,<EOL>relaxed_isolation=self.relaxed_isolation,<EOL>extra_export_options=self.extra_export_options)<EOL><DEDENT>elif self.cmd_type == '<STR_LIT>':<EOL><INDENT>if self.create_hcatalog_table:<EOL><INDENT>self.extra_import_options['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>if self.table and self.query:<EOL><INDENT>raise AirflowException(<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>if self.table:<EOL><INDENT>self.hook.import_table(<EOL>table=self.table,<EOL>target_dir=self.target_dir,<EOL>append=self.append,<EOL>file_type=self.file_type,<EOL>columns=self.columns,<EOL>split_by=self.split_by,<EOL>where=self.where,<EOL>direct=self.direct,<EOL>driver=self.driver,<EOL>extra_import_options=self.extra_import_options)<EOL><DEDENT>elif self.query:<EOL><INDENT>self.hook.import_query(<EOL>query=self.query,<EOL>target_dir=self.target_dir,<EOL>append=self.append,<EOL>file_type=self.file_type,<EOL>split_by=self.split_by,<EOL>direct=self.direct,<EOL>driver=self.driver,<EOL>extra_import_options=self.extra_import_options)<EOL><DEDENT>else:<EOL><INDENT>raise AirflowException(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise AirflowException(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Execute sqoop job", "id": "f9338:c0:m1"}
{"signature": "def build_job(self, jenkins_server):", "body": "<EOL>if self.parameters and isinstance(self.parameters, six.string_types):<EOL><INDENT>import ast<EOL>self.parameters = ast.literal_eval(self.parameters)<EOL><DEDENT>if not self.parameters:<EOL><INDENT>self.parameters = None<EOL><DEDENT>request = Request(jenkins_server.build_job_url(self.job_name,<EOL>self.parameters, None))<EOL>return jenkins_request_with_headers(jenkins_server, request)<EOL>", "docstring": "This function makes an API call to Jenkins to trigger a build for 'job_name'\nIt returned a dict with 2 keys : body and headers.\nheaders contains also a dict-like object which can be queried to get\nthe location to poll in the queue.\n\n:param jenkins_server: The jenkins server where the job should be triggered\n:return: Dict containing the response body (key body)\n    and the headers coming along (headers)", "id": "f9344:c0:m1"}
{"signature": "def poll_job_in_queue(self, location, jenkins_server):", "body": "try_count = <NUM_LIT:0><EOL>location = location + '<STR_LIT>'<EOL>self.log.info('<STR_LIT>', location)<EOL>while try_count < self.max_try_before_job_appears:<EOL><INDENT>location_answer = jenkins_request_with_headers(jenkins_server,<EOL>Request(location))<EOL>if location_answer is not None:<EOL><INDENT>json_response = json.loads(location_answer['<STR_LIT:body>'])<EOL>if '<STR_LIT>' in json_response:<EOL><INDENT>build_number = json_response['<STR_LIT>']['<STR_LIT>']<EOL>self.log.info('<STR_LIT>',<EOL>build_number)<EOL>return build_number<EOL><DEDENT><DEDENT>try_count += <NUM_LIT:1><EOL>time.sleep(self.sleep_time)<EOL><DEDENT>raise AirflowException(\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>self.max_try_before_job_appears)<EOL>", "docstring": "This method poll the jenkins queue until the job is executed.\nWhen we trigger a job through an API call,\nthe job is first put in the queue without having a build number assigned.\nThus we have to wait the job exit the queue to know its build number.\nTo do so, we have to add /api/json (or /api/xml) to the location\nreturned by the build_job call and poll this file.\nWhen a 'executable' block appears in the json, it means the job execution started\nand the field 'number' then contains the build number.\n\n:param location: Location to poll, returned in the header of the build_job call\n:param jenkins_server: The jenkins server to poll\n:return: The build_number corresponding to the triggered job", "id": "f9344:c0:m2"}
{"signature": "@staticmethod<EOL><INDENT>def get_s3_key(s3_key):<DEDENT>", "body": "parsed_s3_key = urlparse(s3_key)<EOL>return parsed_s3_key.path.lstrip('<STR_LIT:/>')<EOL>", "docstring": "This parses the correct format for S3 keys\n            regardless of how the S3 url is passed.", "id": "f9346:c0:m1"}
{"signature": "def _configure_csv_file(self, file_handle, schema):", "body": "csv_writer = csv.writer(file_handle, encoding='<STR_LIT:utf-8>',<EOL>delimiter=self.field_delimiter)<EOL>csv_writer.writerow(schema)<EOL>return csv_writer<EOL>", "docstring": "Configure a csv writer with the file_handle and write schema\n        as headers for the new file.", "id": "f9347:c0:m4"}
{"signature": "def _get_col_type_dict(self):", "body": "schema = []<EOL>if isinstance(self.schema, string_types):<EOL><INDENT>schema = json.loads(self.schema)<EOL><DEDENT>elif isinstance(self.schema, list):<EOL><INDENT>schema = self.schema<EOL><DEDENT>elif self.schema is not None:<EOL><INDENT>self.log.warn('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>col_type_dict = {}<EOL>try:<EOL><INDENT>col_type_dict = {col['<STR_LIT:name>']: col['<STR_LIT:type>'] for col in schema}<EOL><DEDENT>except KeyError:<EOL><INDENT>self.log.warn('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>return col_type_dict<EOL>", "docstring": "Return a dict of column name and column type based on self.schema if not None.", "id": "f9347:c0:m8"}
{"signature": "@classmethod<EOL><INDENT>def type_map(cls, mssql_type):<DEDENT>", "body": "d = {<EOL><NUM_LIT:3>: '<STR_LIT>',<EOL><NUM_LIT:4>: '<STR_LIT>',<EOL><NUM_LIT:5>: '<STR_LIT>'<EOL>}<EOL>return d[mssql_type] if mssql_type in d else '<STR_LIT>'<EOL>", "docstring": "Helper function that maps from MSSQL fields to BigQuery fields. Used\nwhen a schema_filename is set.", "id": "f9348:c0:m7"}
{"signature": "def _write_local_schema_file(self, cursor):", "body": "schema = []<EOL>for field in cursor.description:<EOL><INDENT>field_name = field[<NUM_LIT:0>].replace('<STR_LIT:U+0020>', '<STR_LIT:_>')  <EOL>field_type = self.type_map(field[<NUM_LIT:1>])<EOL>field_mode = '<STR_LIT>'  <EOL>schema.append({<EOL>'<STR_LIT:name>': field_name,<EOL>'<STR_LIT:type>': field_type,<EOL>'<STR_LIT>': field_mode,<EOL>})<EOL><DEDENT>self.log.info('<STR_LIT>', self.schema_filename, schema)<EOL>tmp_schema_file_handle = NamedTemporaryFile(delete=True)<EOL>s = json.dumps(schema, sort_keys=True)<EOL>s = s.encode('<STR_LIT:utf-8>')<EOL>tmp_schema_file_handle.write(s)<EOL>return {self.schema_filename: tmp_schema_file_handle}<EOL>", "docstring": "Takes a cursor, and writes the BigQuery schema for the results to a\nlocal file system.\n\n:return: A dictionary where key is a filename to be used as an object\n    name in GCS, and values are file handles to local files that\n    contains the BigQuery schema fields in .json format.", "id": "f9348:c0:m4"}
{"signature": "def execute(self, context):", "body": "self._hook = SparkSubmitHook(<EOL>conf=self._conf,<EOL>conn_id=self._conn_id,<EOL>files=self._files,<EOL>py_files=self._py_files,<EOL>archives=self._archives,<EOL>driver_class_path=self._driver_class_path,<EOL>jars=self._jars,<EOL>java_class=self._java_class,<EOL>packages=self._packages,<EOL>exclude_packages=self._exclude_packages,<EOL>repositories=self._repositories,<EOL>total_executor_cores=self._total_executor_cores,<EOL>executor_cores=self._executor_cores,<EOL>executor_memory=self._executor_memory,<EOL>driver_memory=self._driver_memory,<EOL>keytab=self._keytab,<EOL>principal=self._principal,<EOL>name=self._name,<EOL>num_executors=self._num_executors,<EOL>application_args=self._application_args,<EOL>env_vars=self._env_vars,<EOL>verbose=self._verbose,<EOL>spark_binary=self._spark_binary<EOL>)<EOL>self._hook.submit(self._application)<EOL>", "docstring": "Call the SparkSubmitHook to run the provided spark job", "id": "f9352:c0:m1"}
{"signature": "def _query_cassandra(self):", "body": "self.hook = CassandraHook(cassandra_conn_id=self.cassandra_conn_id)<EOL>session = self.hook.get_conn()<EOL>cursor = session.execute(self.cql)<EOL>return cursor<EOL>", "docstring": "Queries cassandra and returns a cursor to the results.", "id": "f9355:c0:m2"}
{"signature": "def data_profiling(self):", "body": "return self.data_profiler<EOL>", "docstring": "Provides access to data profiling tools", "id": "f9360:c2:m6"}
{"signature": "@property<EOL><INDENT>def is_active(self):<DEDENT>", "body": "return True<EOL>", "docstring": "Required by flask_login", "id": "f9360:c2:m2"}
{"signature": "@property<EOL><INDENT>def is_anonymous(self):<DEDENT>", "body": "return False<EOL>", "docstring": "Required by flask_login", "id": "f9363:c0:m3"}
{"signature": "def data_profiling(self):", "body": "return True<EOL>", "docstring": "Provides access to data profiling tools", "id": "f9363:c0:m5"}
{"signature": "def _unauthorized():", "body": "return Response(\"<STR_LIT>\", <NUM_LIT>, {\"<STR_LIT>\": \"<STR_LIT>\"})<EOL>", "docstring": "Indicate that authorization is required\n:return:", "id": "f9364:m3"}
{"signature": "def return_code(self):", "body": "raise NotImplementedError()<EOL>", "docstring": ":return: The return code associated with running the task instance or\n    None if the task is not yet done.\n:rtype: int", "id": "f9365:c0:m4"}
{"signature": "@property<EOL><INDENT>def name(self):<DEDENT>", "body": "return getattr(self, '<STR_LIT>', self.__class__.__name__)<EOL>", "docstring": "The human-readable name for the dependency. Use the classname as the default name\nif this method is not overridden in the subclass.", "id": "f9373:c0:m4"}
{"signature": "def run_migrations_online():", "body": "connectable = settings.engine<EOL>with connectable.connect() as connection:<EOL><INDENT>context.configure(<EOL>connection=connection,<EOL>transaction_per_migration=True,<EOL>target_metadata=target_metadata,<EOL>compare_type=COMPARE_TYPE,<EOL>)<EOL>with context.begin_transaction():<EOL><INDENT>context.run_migrations()<EOL><DEDENT><DEDENT>", "docstring": "Run migrations in 'online' mode.\n\n    In this scenario we need to create an Engine\n    and associate a connection with the context.", "id": "f9430:m1"}
{"signature": "def run_migrations_offline():", "body": "context.configure(<EOL>url=settings.SQL_ALCHEMY_CONN, target_metadata=target_metadata,<EOL>literal_binds=True, compare_type=COMPARE_TYPE)<EOL>with context.begin_transaction():<EOL><INDENT>context.run_migrations()<EOL><DEDENT>", "docstring": "Run migrations in 'offline' mode.\n\n    This configures the context with just a URL\n    and not an Engine, though an Engine is acceptable\n    here as well.  By skipping the Engine creation\n    we don't even need a DBAPI to be available.\n\n    Calls to context.execute() here emit the given string to the\n    script output.", "id": "f9430:m0"}
{"signature": "def sync_perm_for_dag(self, dag_id, access_control=None):", "body": "for dag_perm in self.DAG_PERMS:<EOL><INDENT>perm_on_dag = self.find_permission_view_menu(dag_perm, dag_id)<EOL>if perm_on_dag is None:<EOL><INDENT>self.add_permission_view_menu(dag_perm, dag_id)<EOL><DEDENT><DEDENT>if access_control:<EOL><INDENT>self._sync_dag_view_permissions(dag_id, access_control)<EOL><DEDENT>", "docstring": "Sync permissions for given dag id. The dag id surely exists in our dag bag\nas only / refresh button or cli.sync_perm will call this function\n\n:param dag_id: the ID of the DAG whose permissions should be updated\n:type dag_id: string\n:param access_control: a dict where each key is a rolename and\n    each value is a set() of permission names (e.g.,\n    {'can_dag_read'}\n:type access_control: dict\n:return:", "id": "f9435:c0:m15"}
{"signature": "def _has_perm(self, permission_name, view_menu_name):", "body": "if hasattr(self, '<STR_LIT>'):<EOL><INDENT>if (permission_name, view_menu_name) in self.perms:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>self._get_and_cache_perms()<EOL>return (permission_name, view_menu_name) in self.perms<EOL>", "docstring": "Whether the user has this perm", "id": "f9435:c0:m8"}
{"signature": "def get_accessible_dag_ids(self, username=None):", "body": "if not username:<EOL><INDENT>username = g.user<EOL><DEDENT>if username.is_anonymous or '<STR_LIT>' in username.roles:<EOL><INDENT>return set()<EOL><DEDENT>roles = {role.name for role in username.roles}<EOL>if {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'} & roles:<EOL><INDENT>return self.DAG_VMS<EOL><DEDENT>user_perms_views = self.get_all_permissions_views()<EOL>return set([view for perm, view in user_perms_views if perm in self.DAG_PERMS])<EOL>", "docstring": "Return a set of dags that user has access to(either read or write).\n\n:param username: Name of the user.\n:return: A set of dag ids that the user could access.", "id": "f9435:c0:m4"}
{"signature": "def has_all_dags_access(self):", "body": "return (<EOL>self._has_role(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']) or<EOL>self._has_perm('<STR_LIT>', '<STR_LIT>') or<EOL>self._has_perm('<STR_LIT>', '<STR_LIT>'))<EOL>", "docstring": "Has all the dag access in any of the 3 cases:\n1. Role needs to be in (Admin, Viewer, User, Op).\n2. Has can_dag_read permission on all_dags view.\n3. Has can_dag_edit permission on all_dags view.", "id": "f9435:c0:m9"}
{"signature": "def get_all_permissions_views(self):", "body": "perms_views = set()<EOL>for role in self.get_user_roles():<EOL><INDENT>perms_views.update({(perm_view.permission.name, perm_view.view_menu.name)<EOL>for perm_view in role.permissions})<EOL><DEDENT>return perms_views<EOL>", "docstring": "Returns a set of tuples with the perm name and view menu name", "id": "f9435:c0:m3"}
{"signature": "def update_admin_perm_view(self):", "body": "pvms = self.get_session.query(sqla_models.PermissionView).all()<EOL>pvms = [p for p in pvms if p.permission and p.view_menu]<EOL>admin = self.find_role('<STR_LIT>')<EOL>admin.permissions = list(set(admin.permissions) | set(pvms))<EOL>self.get_session.commit()<EOL>", "docstring": "Admin should have all the permission-views.\nAdd the missing ones to the table for admin.\n\n:return: None.", "id": "f9435:c0:m13"}
{"signature": "def get_user_roles(self, user=None):", "body": "if user is None:<EOL><INDENT>user = g.user<EOL><DEDENT>if user.is_anonymous:<EOL><INDENT>public_role = appbuilder.config.get('<STR_LIT>')<EOL>return [appbuilder.security_manager.find_role(public_role)]if public_role else []<EOL><DEDENT>return user.roles<EOL>", "docstring": "Get all the roles associated with the user.\n\n:param user: the ab_user in FAB model.\n:return: a list of roles associated with the user.", "id": "f9435:c0:m2"}
{"signature": "def sync_roles(self):", "body": "self.log.debug('<STR_LIT>')<EOL>self.create_perm_vm_for_all_dag()<EOL>for config in self.ROLE_CONFIGS:<EOL><INDENT>role = config['<STR_LIT>']<EOL>vms = config['<STR_LIT>']<EOL>perms = config['<STR_LIT>']<EOL>self.init_role(role, vms, perms)<EOL><DEDENT>self.create_custom_dag_permission_view()<EOL>self.update_admin_perm_view()<EOL>self.clean_perms()<EOL>", "docstring": "1. Init the default role(Admin, Viewer, User, Op, public)\n   with related permissions.\n2. Init the custom role(dag-user) with related permissions.\n\n:return: None.", "id": "f9435:c0:m14"}
{"signature": "@api_experimental.route('<STR_LIT>', methods=['<STR_LIT:GET>'])<EOL>@requires_authentication<EOL>def task_info(dag_id, task_id):", "body": "try:<EOL><INDENT>info = get_task(dag_id, task_id)<EOL><DEDENT>except AirflowException as err:<EOL><INDENT>_log.info(err)<EOL>response = jsonify(error=\"<STR_LIT:{}>\".format(err))<EOL>response.status_code = err.status_code<EOL>return response<EOL><DEDENT>fields = {k: str(v)<EOL>for k, v in vars(info).items()<EOL>if not k.startswith('<STR_LIT:_>')}<EOL>return jsonify(fields)<EOL>", "docstring": "Returns a JSON with a task's public instance variables.", "id": "f9437:m5"}
{"signature": "@api_experimental.route('<STR_LIT>', methods=['<STR_LIT:GET>'])<EOL>@requires_authentication<EOL>def dag_runs(dag_id):", "body": "try:<EOL><INDENT>state = request.args.get('<STR_LIT:state>')<EOL>dagruns = get_dag_runs(dag_id, state)<EOL><DEDENT>except AirflowException as err:<EOL><INDENT>_log.info(err)<EOL>response = jsonify(error=\"<STR_LIT:{}>\".format(err))<EOL>response.status_code = <NUM_LIT><EOL>return response<EOL><DEDENT>return jsonify(dagruns)<EOL>", "docstring": "Returns a list of Dag Runs for a specific DAG ID.\n:query param state: a query string parameter '?state=queued|running|success...'\n:param dag_id: String identifier of a DAG\n:return: List of DAG runs of a DAG with requested state,\nor all runs if the state is not specified", "id": "f9437:m2"}
{"signature": "@csrf.exempt<EOL>@api_experimental.route('<STR_LIT>', methods=['<STR_LIT>'])<EOL>@requires_authentication<EOL>def delete_dag(dag_id):", "body": "try:<EOL><INDENT>count = delete.delete_dag(dag_id)<EOL><DEDENT>except AirflowException as err:<EOL><INDENT>_log.error(err)<EOL>response = jsonify(error=\"<STR_LIT:{}>\".format(err))<EOL>response.status_code = err.status_code<EOL>return response<EOL><DEDENT>return jsonify(message=\"<STR_LIT>\".format(count), count=count)<EOL>", "docstring": "Delete all DB records related to the specified Dag.", "id": "f9437:m1"}
{"signature": "@api_experimental.route(<EOL>'<STR_LIT>',<EOL>methods=['<STR_LIT:GET>'])<EOL>@requires_authentication<EOL>def dag_run_status(dag_id, execution_date):", "body": "<EOL>try:<EOL><INDENT>execution_date = timezone.parse(execution_date)<EOL><DEDENT>except ValueError:<EOL><INDENT>error_message = (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>execution_date))<EOL>_log.info(error_message)<EOL>response = jsonify({'<STR_LIT:error>': error_message})<EOL>response.status_code = <NUM_LIT><EOL>return response<EOL><DEDENT>try:<EOL><INDENT>info = get_dag_run_state(dag_id, execution_date)<EOL><DEDENT>except AirflowException as err:<EOL><INDENT>_log.info(err)<EOL>response = jsonify(error=\"<STR_LIT:{}>\".format(err))<EOL>response.status_code = err.status_code<EOL>return response<EOL><DEDENT>return jsonify(info)<EOL>", "docstring": "Returns a JSON with a dag_run's public instance variables.\nThe format for the exec_date is expected to be\n\"YYYY-mm-DDTHH:MM:SS\", for example: \"2016-11-16T11:34:15\". This will\nof course need to have been encoded for URL in the request.", "id": "f9437:m8"}
{"signature": "@api_experimental.route('<STR_LIT>', methods=['<STR_LIT:GET>'])<EOL>@requires_authentication<EOL>def dag_paused(dag_id, paused):", "body": "DagModel = models.DagModel<EOL>with create_session() as session:<EOL><INDENT>orm_dag = (<EOL>session.query(DagModel)<EOL>.filter(DagModel.dag_id == dag_id).first()<EOL>)<EOL>if paused == '<STR_LIT:true>':<EOL><INDENT>orm_dag.is_paused = True<EOL><DEDENT>else:<EOL><INDENT>orm_dag.is_paused = False<EOL><DEDENT>session.merge(orm_dag)<EOL>session.commit()<EOL><DEDENT>return jsonify({'<STR_LIT>': '<STR_LIT>'})<EOL>", "docstring": "(Un)pauses a dag", "id": "f9437:m6"}
{"signature": "def make_cache_key(*args, **kwargs):", "body": "path = request.path<EOL>args = str(hash(frozenset(request.args.items())))<EOL>return (path + args).encode('<STR_LIT:ascii>', '<STR_LIT:ignore>')<EOL>", "docstring": "Used by cache to get a unique key per URL", "id": "f9440:m6"}
{"signature": "def get_chart_height(dag):", "body": "return <NUM_LIT> + len(dag.tasks) * <NUM_LIT:10><EOL>", "docstring": "TODO(aoen): See [AIRFLOW-1263] We use the number of tasks in the DAG as a heuristic to\napproximate the size of generated chart (otherwise the charts are tiny and unreadable\nwhen DAGs have a large number of tasks). Ideally nvd3 should allow for dynamic-height\ncharts, that is charts that take up space based on the size of the components within.", "id": "f9440:m19"}
{"signature": "def epoch(dttm):", "body": "return int(time.mktime(dttm.timetuple())) * <NUM_LIT:1000>,<EOL>", "docstring": "Returns an epoch-type date", "id": "f9440:m3"}
{"signature": "def gzipped(f):", "body": "@functools.wraps(f)<EOL>def view_func(*args, **kwargs):<EOL><INDENT>@after_this_request<EOL>def zipper(response):<EOL><INDENT>accept_encoding = request.headers.get('<STR_LIT>', '<STR_LIT>')<EOL>if '<STR_LIT>' not in accept_encoding.lower():<EOL><INDENT>return response<EOL><DEDENT>response.direct_passthrough = False<EOL>if (response.status_code < <NUM_LIT:200> or response.status_code >= <NUM_LIT> or<EOL>'<STR_LIT>' in response.headers):<EOL><INDENT>return response<EOL><DEDENT>gzip_buffer = IO()<EOL>gzip_file = gzip.GzipFile(mode='<STR_LIT:wb>',<EOL>fileobj=gzip_buffer)<EOL>gzip_file.write(response.data)<EOL>gzip_file.close()<EOL>response.data = gzip_buffer.getvalue()<EOL>response.headers['<STR_LIT>'] = '<STR_LIT>'<EOL>response.headers['<STR_LIT>'] = '<STR_LIT>'<EOL>response.headers['<STR_LIT>'] = len(response.data)<EOL>return response<EOL><DEDENT>return f(*args, **kwargs)<EOL><DEDENT>return view_func<EOL>", "docstring": "Decorator to make a view compressed", "id": "f9441:m1"}
{"signature": "def configure_manifest_files(app):", "body": "def parse_manifest_json():<EOL><INDENT>try:<EOL><INDENT>global manifest<EOL>manifest_file = os.path.join(os.path.dirname(__file__),<EOL>'<STR_LIT>')<EOL>with open(manifest_file, '<STR_LIT:r>') as f:<EOL><INDENT>manifest.update(json.load(f))<EOL>for k in manifest.keys():<EOL><INDENT>manifest[k] = os.path.join(\"<STR_LIT>\", manifest[k])<EOL><DEDENT><DEDENT><DEDENT>except Exception:<EOL><INDENT>print(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>pass<EOL><DEDENT><DEDENT>def get_asset_url(filename):<EOL><INDENT>if app.debug:<EOL><INDENT>parse_manifest_json()<EOL><DEDENT>return url_for('<STR_LIT>', filename=manifest.get(filename, '<STR_LIT>'))<EOL><DEDENT>parse_manifest_json()<EOL>@app.context_processor<EOL>def get_url_for_asset():<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return dict(url_for_asset=get_asset_url)<EOL><DEDENT>", "docstring": "Loads the manifest file and register the `url_for_asset_` template tag.\n:param app:\n:return:", "id": "f9442:m0"}
{"signature": "@provide_session<EOL><INDENT>def clear(self,<EOL>start_date=None,<EOL>end_date=None,<EOL>upstream=False,<EOL>downstream=False,<EOL>session=None):<DEDENT>", "body": "TI = TaskInstance<EOL>qry = session.query(TI).filter(TI.dag_id == self.dag_id)<EOL>if start_date:<EOL><INDENT>qry = qry.filter(TI.execution_date >= start_date)<EOL><DEDENT>if end_date:<EOL><INDENT>qry = qry.filter(TI.execution_date <= end_date)<EOL><DEDENT>tasks = [self.task_id]<EOL>if upstream:<EOL><INDENT>tasks += [<EOL>t.task_id for t in self.get_flat_relatives(upstream=True)]<EOL><DEDENT>if downstream:<EOL><INDENT>tasks += [<EOL>t.task_id for t in self.get_flat_relatives(upstream=False)]<EOL><DEDENT>qry = qry.filter(TI.task_id.in_(tasks))<EOL>count = qry.count()<EOL>clear_task_instances(qry.all(), session, dag=self.dag)<EOL>session.commit()<EOL>return count<EOL>", "docstring": "Clears the state of task instances associated with the task, following\nthe parameters specified.", "id": "f9444:c0:m34"}
{"signature": "def get_flat_relatives(self, upstream=False):", "body": "return list(map(lambda task_id: self._dag.task_dict[task_id],<EOL>self.get_flat_relative_ids(upstream)))<EOL>", "docstring": "Get a flat list of relatives, either upstream or downstream.", "id": "f9444:c0:m37"}
{"signature": "@property<EOL><INDENT>def upstream_list(self):<DEDENT>", "body": "return [self.dag.get_task(tid) for tid in self._upstream_task_ids]<EOL>", "docstring": "@property: list of tasks directly upstream", "id": "f9444:c0:m30"}
{"signature": "def on_kill(self):", "body": "pass<EOL>", "docstring": "Override this method to cleanup subprocesses when a task instance\ngets killed. Any use of the threading, subprocess or multiprocessing\nmodule within an operator needs to be cleaned up or it will leave\nghost processes behind.", "id": "f9444:c0:m21"}
{"signature": "def get_flat_relative_ids(self, upstream=False, found_descendants=None):", "body": "if not found_descendants:<EOL><INDENT>found_descendants = set()<EOL><DEDENT>relative_ids = self.get_direct_relative_ids(upstream)<EOL>for relative_id in relative_ids:<EOL><INDENT>if relative_id not in found_descendants:<EOL><INDENT>found_descendants.add(relative_id)<EOL>relative_task = self._dag.task_dict[relative_id]<EOL>relative_task.get_flat_relative_ids(upstream,<EOL>found_descendants)<EOL><DEDENT><DEDENT>return found_descendants<EOL>", "docstring": "Get a flat list of relatives' ids, either upstream or downstream.", "id": "f9444:c0:m36"}
{"signature": "@provide_session<EOL><INDENT>def get_task_instances(self, start_date=None, end_date=None, session=None):<DEDENT>", "body": "end_date = end_date or timezone.utcnow()<EOL>return session.query(TaskInstance).filter(TaskInstance.dag_id == self.dag_id).filter(TaskInstance.task_id == self.task_id).filter(TaskInstance.execution_date >= start_date).filter(TaskInstance.execution_date <= end_date).order_by(TaskInstance.execution_date).all()<EOL>", "docstring": "Get a set of task instance related to this task for a specific date\nrange.", "id": "f9444:c0:m35"}
{"signature": "@abstractmethod<EOL><INDENT>def get_link(self, operator, dttm):<EOL><DEDENT>", "body": "pass<EOL>", "docstring": "Link to external system.\n\n:param operator: airflow operator\n:param dttm: datetime\n:return: link to external system", "id": "f9444:c1:m1"}
{"signature": "def execute(self, context):", "body": "raise NotImplementedError()<EOL>", "docstring": "This is the main method to derive when creating an operator.\nContext is the same dictionary used as when rendering jinja templates.\n\nRefer to get_template_context for more context.", "id": "f9444:c0:m19"}
{"signature": "@classmethod<EOL><INDENT>@provide_session<EOL>def get_many(cls,<EOL>execution_date,<EOL>key=None,<EOL>task_ids=None,<EOL>dag_ids=None,<EOL>include_prior_dates=False,<EOL>limit=<NUM_LIT:100>,<EOL>session=None):<DEDENT>", "body": "filters = []<EOL>if key:<EOL><INDENT>filters.append(cls.key == key)<EOL><DEDENT>if task_ids:<EOL><INDENT>filters.append(cls.task_id.in_(as_tuple(task_ids)))<EOL><DEDENT>if dag_ids:<EOL><INDENT>filters.append(cls.dag_id.in_(as_tuple(dag_ids)))<EOL><DEDENT>if include_prior_dates:<EOL><INDENT>filters.append(cls.execution_date <= execution_date)<EOL><DEDENT>else:<EOL><INDENT>filters.append(cls.execution_date == execution_date)<EOL><DEDENT>query = (<EOL>session.query(cls).filter(and_(*filters))<EOL>.order_by(cls.execution_date.desc(), cls.timestamp.desc())<EOL>.limit(limit))<EOL>results = query.all()<EOL>return results<EOL>", "docstring": "Retrieve an XCom value, optionally meeting certain criteria\nTODO: \"pickling\" has been deprecated and JSON is preferred.\n\"pickling\" will be removed in Airflow 2.0.", "id": "f9445:c0:m4"}
{"signature": "@classmethod<EOL><INDENT>@provide_session<EOL>def get_one(cls,<EOL>execution_date,<EOL>key=None,<EOL>task_id=None,<EOL>dag_id=None,<EOL>include_prior_dates=False,<EOL>session=None):<DEDENT>", "body": "filters = []<EOL>if key:<EOL><INDENT>filters.append(cls.key == key)<EOL><DEDENT>if task_id:<EOL><INDENT>filters.append(cls.task_id == task_id)<EOL><DEDENT>if dag_id:<EOL><INDENT>filters.append(cls.dag_id == dag_id)<EOL><DEDENT>if include_prior_dates:<EOL><INDENT>filters.append(cls.execution_date <= execution_date)<EOL><DEDENT>else:<EOL><INDENT>filters.append(cls.execution_date == execution_date)<EOL><DEDENT>query = (<EOL>session.query(cls.value).filter(and_(*filters))<EOL>.order_by(cls.execution_date.desc(), cls.timestamp.desc()))<EOL>result = query.first()<EOL>if result:<EOL><INDENT>enable_pickling = configuration.getboolean('<STR_LIT>', '<STR_LIT>')<EOL>if enable_pickling:<EOL><INDENT>return pickle.loads(result.value)<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>return json.loads(result.value.decode('<STR_LIT>'))<EOL><DEDENT>except ValueError:<EOL><INDENT>log = LoggingMixin().log<EOL>log.error(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>raise<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Retrieve an XCom value, optionally meeting certain criteria.\nTODO: \"pickling\" has been deprecated and JSON is preferred.\n\"pickling\" will be removed in Airflow 2.0.\n\n:return: XCom value", "id": "f9445:c0:m3"}
{"signature": "@property<EOL><INDENT>def extra_dejson(self):<DEDENT>", "body": "obj = {}<EOL>if self.extra:<EOL><INDENT>try:<EOL><INDENT>obj = json.loads(self.extra)<EOL><DEDENT>except Exception as e:<EOL><INDENT>self.log.exception(e)<EOL>self.log.error(\"<STR_LIT>\", self.conn_id)<EOL><DEDENT><DEDENT>return obj<EOL>", "docstring": "Returns the extra property by deserializing json.", "id": "f9448:c0:m12"}
{"signature": "@provide_session<EOL><INDENT>def sync_to_db(self, owner=None, sync_time=None, session=None):<DEDENT>", "body": "if owner is None:<EOL><INDENT>owner = self.owner<EOL><DEDENT>if sync_time is None:<EOL><INDENT>sync_time = timezone.utcnow()<EOL><DEDENT>orm_dag = session.query(<EOL>DagModel).filter(DagModel.dag_id == self.dag_id).first()<EOL>if not orm_dag:<EOL><INDENT>orm_dag = DagModel(dag_id=self.dag_id)<EOL>self.log.info(\"<STR_LIT>\", self.dag_id)<EOL><DEDENT>orm_dag.fileloc = self.fileloc<EOL>orm_dag.is_subdag = self.is_subdag<EOL>orm_dag.owners = owner<EOL>orm_dag.is_active = True<EOL>orm_dag.last_scheduler_run = sync_time<EOL>orm_dag.default_view = self._default_view<EOL>orm_dag.description = self.description<EOL>orm_dag.schedule_interval = self.schedule_interval<EOL>session.merge(orm_dag)<EOL>session.commit()<EOL>for subdag in self.subdags:<EOL><INDENT>subdag.sync_to_db(owner=owner, sync_time=sync_time, session=session)<EOL><DEDENT>", "docstring": "Save attributes about this DAG to the DB. Note that this method\ncan be called for both DAGs and SubDAGs. A SubDag is actually a\nSubDagOperator.\n\n:param dag: the DAG object to save to the DB\n:type dag: airflow.models.DAG\n:param sync_time: The time that the DAG should be marked as sync'ed\n:type sync_time: datetime\n:return: None", "id": "f9451:c0:m65"}
{"signature": "def get_active_runs(self):", "body": "runs = DagRun.find(dag_id=self.dag_id, state=State.RUNNING)<EOL>active_dates = []<EOL>for run in runs:<EOL><INDENT>active_dates.append(run.execution_date)<EOL><DEDENT>return active_dates<EOL>", "docstring": "Returns a list of dag run execution dates currently running\n\n:return: List of execution dates", "id": "f9451:c0:m38"}
{"signature": "def add_tasks(self, tasks):", "body": "for task in tasks:<EOL><INDENT>self.add_task(task)<EOL><DEDENT>", "docstring": "Add a list of tasks to the DAG\n\n:param tasks: a lit of tasks you want to add\n:type tasks: list of tasks", "id": "f9451:c0:m61"}
{"signature": "def topological_sort(self):", "body": "<EOL>graph_unsorted = OrderedDict((task.task_id, task) for task in self.tasks)<EOL>graph_sorted = []<EOL>if len(self.tasks) == <NUM_LIT:0>:<EOL><INDENT>return tuple(graph_sorted)<EOL><DEDENT>while graph_unsorted:<EOL><INDENT>acyclic = False<EOL>for node in list(graph_unsorted.values()):<EOL><INDENT>for edge in node.upstream_list:<EOL><INDENT>if edge.task_id in graph_unsorted:<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>acyclic = True<EOL>del graph_unsorted[node.task_id]<EOL>graph_sorted.append(node)<EOL><DEDENT><DEDENT>if not acyclic:<EOL><INDENT>raise AirflowException(\"<STR_LIT>\"<EOL>.format(self.dag_id))<EOL><DEDENT><DEDENT>return tuple(graph_sorted)<EOL>", "docstring": "Sorts tasks in topographical order, such that a task comes after any of its\nupstream dependencies.\n\nHeavily inspired by:\nhttp://blog.jupo.org/2012/04/06/topological-sorting-acyclic-directed-graphs/\n\n:return: list of tasks in topological order", "id": "f9451:c0:m49"}
{"signature": "def run(<EOL>self,<EOL>start_date=None,<EOL>end_date=None,<EOL>mark_success=False,<EOL>local=False,<EOL>executor=None,<EOL>donot_pickle=configuration.conf.getboolean('<STR_LIT>', '<STR_LIT>'),<EOL>ignore_task_deps=False,<EOL>ignore_first_depends_on_past=False,<EOL>pool=None,<EOL>delay_on_limit_secs=<NUM_LIT:1.0>,<EOL>verbose=False,<EOL>conf=None,<EOL>rerun_failed_tasks=False,<EOL>run_backwards=False,<EOL>):", "body": "from airflow.jobs import BackfillJob<EOL>if not executor and local:<EOL><INDENT>executor = LocalExecutor()<EOL><DEDENT>elif not executor:<EOL><INDENT>executor = get_default_executor()<EOL><DEDENT>job = BackfillJob(<EOL>self,<EOL>start_date=start_date,<EOL>end_date=end_date,<EOL>mark_success=mark_success,<EOL>executor=executor,<EOL>donot_pickle=donot_pickle,<EOL>ignore_task_deps=ignore_task_deps,<EOL>ignore_first_depends_on_past=ignore_first_depends_on_past,<EOL>pool=pool,<EOL>delay_on_limit_secs=delay_on_limit_secs,<EOL>verbose=verbose,<EOL>conf=conf,<EOL>rerun_failed_tasks=rerun_failed_tasks,<EOL>run_backwards=run_backwards,<EOL>)<EOL>job.run()<EOL>", "docstring": "Runs the DAG.\n\n:param start_date: the start date of the range to run\n:type start_date: datetime.datetime\n:param end_date: the end date of the range to run\n:type end_date: datetime.datetime\n:param mark_success: True to mark jobs as succeeded without running them\n:type mark_success: bool\n:param local: True to run the tasks using the LocalExecutor\n:type local: bool\n:param executor: The executor instance to run the tasks\n:type executor: airflow.executor.BaseExecutor\n:param donot_pickle: True to avoid pickling DAG object and send to workers\n:type donot_pickle: bool\n:param ignore_task_deps: True to skip upstream tasks\n:type ignore_task_deps: bool\n:param ignore_first_depends_on_past: True to ignore depends_on_past\n    dependencies for the first set of tasks only\n:type ignore_first_depends_on_past: bool\n:param pool: Resource pool to use\n:type pool: str\n:param delay_on_limit_secs: Time in seconds to wait before next attempt to run\n    dag run when max_active_runs limit has been reached\n:type delay_on_limit_secs: float\n:param verbose: Make logging output more verbose\n:type verbose: bool\n:param conf: user defined dictionary passed from CLI\n:type conf: dict\n:param rerun_failed_tasks:\n:type: bool\n:param run_backwards:\n:type: bool", "id": "f9451:c0:m62"}
{"signature": "@property<EOL><INDENT>def folder(self):<DEDENT>", "body": "return os.path.dirname(self.full_filepath)<EOL>", "docstring": "Folder location of where the dag object is instantiated", "id": "f9451:c0:m31"}
{"signature": "@provide_session<EOL><INDENT>def skip(self, dag_run, execution_date, tasks, session=None):<DEDENT>", "body": "if not tasks:<EOL><INDENT>return<EOL><DEDENT>task_ids = [d.task_id for d in tasks]<EOL>now = timezone.utcnow()<EOL>if dag_run:<EOL><INDENT>session.query(TaskInstance).filter(<EOL>TaskInstance.dag_id == dag_run.dag_id,<EOL>TaskInstance.execution_date == dag_run.execution_date,<EOL>TaskInstance.task_id.in_(task_ids)<EOL>).update({TaskInstance.state: State.SKIPPED,<EOL>TaskInstance.start_date: now,<EOL>TaskInstance.end_date: now},<EOL>synchronize_session=False)<EOL>session.commit()<EOL><DEDENT>else:<EOL><INDENT>assert execution_date is not None, \"<STR_LIT>\"<EOL>self.log.warning(\"<STR_LIT>\")<EOL>for task in tasks:<EOL><INDENT>ti = TaskInstance(task, execution_date=execution_date)<EOL>ti.state = State.SKIPPED<EOL>ti.start_date = now<EOL>ti.end_date = now<EOL>session.merge(ti)<EOL><DEDENT>session.commit()<EOL><DEDENT>", "docstring": "Sets tasks instances to skipped from the same dag run.\n\n:param dag_run: the DagRun for which to set the tasks to skipped\n:param execution_date: execution_date\n:param tasks: tasks to skip (not task_ids)\n:param session: db session to use", "id": "f9455:c0:m0"}
{"signature": "def is_eligible_to_retry(self):", "body": "return self.task.retries and self.try_number <= self.max_tries<EOL>", "docstring": "Is task instance is eligible for retry", "id": "f9457:c0:m34"}
{"signature": "@provide_session<EOL><INDENT>def refresh_from_db(self, session=None, lock_for_update=False):<DEDENT>", "body": "TI = TaskInstance<EOL>qry = session.query(TI).filter(<EOL>TI.dag_id == self.dag_id,<EOL>TI.task_id == self.task_id,<EOL>TI.execution_date == self.execution_date)<EOL>if lock_for_update:<EOL><INDENT>ti = qry.with_for_update().first()<EOL><DEDENT>else:<EOL><INDENT>ti = qry.first()<EOL><DEDENT>if ti:<EOL><INDENT>self.state = ti.state<EOL>self.start_date = ti.start_date<EOL>self.end_date = ti.end_date<EOL>self.try_number = ti._try_number<EOL>self.max_tries = ti.max_tries<EOL>self.hostname = ti.hostname<EOL>self.pid = ti.pid<EOL>self.executor_config = ti.executor_config<EOL><DEDENT>else:<EOL><INDENT>self.state = None<EOL><DEDENT>", "docstring": "Refreshes the task instance from the database based on the primary key\n\n:param lock_for_update: if True, indicates that the database should\n    lock the TaskInstance (issuing a FOR UPDATE clause) until the\n    session is committed.", "id": "f9457:c0:m13"}
{"signature": "def ready_for_retry(self):", "body": "return (self.state == State.UP_FOR_RETRY and<EOL>self.next_retry_datetime() < timezone.utcnow())<EOL>", "docstring": "Checks on whether the task instance is in the right state and timeframe\nto be retried.", "id": "f9457:c0:m25"}
{"signature": "@provide_session<EOL><INDENT>def get_dagrun(self, session):<DEDENT>", "body": "from airflow.models.dagrun import DagRun  <EOL>dr = session.query(DagRun).filter(<EOL>DagRun.dag_id == self.dag_id,<EOL>DagRun.execution_date == self.execution_date<EOL>).first()<EOL>return dr<EOL>", "docstring": "Returns the DagRun for this TaskInstance\n\n:param session:\n:return: DagRun", "id": "f9457:c0:m27"}
{"signature": "@provide_session<EOL><INDENT>def clear_xcom_data(self, session=None):<DEDENT>", "body": "session.query(XCom).filter(<EOL>XCom.dag_id == self.dag_id,<EOL>XCom.task_id == self.task_id,<EOL>XCom.execution_date == self.execution_date<EOL>).delete()<EOL>session.commit()<EOL>", "docstring": "Clears all XCom data from the database for the task instance", "id": "f9457:c0:m14"}
{"signature": "@provide_session<EOL><INDENT>def are_dependencies_met(<EOL>self,<EOL>dep_context=None,<EOL>session=None,<EOL>verbose=False):<DEDENT>", "body": "dep_context = dep_context or DepContext()<EOL>failed = False<EOL>verbose_aware_logger = self.log.info if verbose else self.log.debug<EOL>for dep_status in self.get_failed_dep_statuses(<EOL>dep_context=dep_context,<EOL>session=session):<EOL><INDENT>failed = True<EOL>verbose_aware_logger(<EOL>\"<STR_LIT>\",<EOL>self, dep_status.dep_name, dep_status.reason<EOL>)<EOL><DEDENT>if failed:<EOL><INDENT>return False<EOL><DEDENT>verbose_aware_logger(\"<STR_LIT>\", self)<EOL>return True<EOL>", "docstring": "Returns whether or not all the conditions are met for this task instance to be run\ngiven the context for the dependencies (e.g. a task instance being force run from\nthe UI will ignore some dependencies).\n\n:param dep_context: The execution context that determines the dependencies that\n    should be evaluated.\n:type dep_context: DepContext\n:param session: database session\n:type session: sqlalchemy.orm.session.Session\n:param verbose: whether log details on failed dependencies on\n    info or debug log level\n:type verbose: bool", "id": "f9457:c0:m21"}
{"signature": "@staticmethod<EOL><INDENT>@provide_session<EOL>def find(dag_id=None, run_id=None, execution_date=None,<EOL>state=None, external_trigger=None, no_backfills=False,<EOL>session=None):<DEDENT>", "body": "DR = DagRun<EOL>qry = session.query(DR)<EOL>if dag_id:<EOL><INDENT>qry = qry.filter(DR.dag_id == dag_id)<EOL><DEDENT>if run_id:<EOL><INDENT>qry = qry.filter(DR.run_id == run_id)<EOL><DEDENT>if execution_date:<EOL><INDENT>if isinstance(execution_date, list):<EOL><INDENT>qry = qry.filter(DR.execution_date.in_(execution_date))<EOL><DEDENT>else:<EOL><INDENT>qry = qry.filter(DR.execution_date == execution_date)<EOL><DEDENT><DEDENT>if state:<EOL><INDENT>qry = qry.filter(DR.state == state)<EOL><DEDENT>if external_trigger is not None:<EOL><INDENT>qry = qry.filter(DR.external_trigger == external_trigger)<EOL><DEDENT>if no_backfills:<EOL><INDENT>from airflow.jobs import BackfillJob<EOL>qry = qry.filter(DR.run_id.notlike(BackfillJob.ID_PREFIX + '<STR_LIT:%>'))<EOL><DEDENT>dr = qry.order_by(DR.execution_date).all()<EOL>return dr<EOL>", "docstring": "Returns a set of dag runs for the given search criteria.\n\n:param dag_id: the dag_id to find dag runs for\n:type dag_id: int, list\n:param run_id: defines the the run id for this dag run\n:type run_id: str\n:param execution_date: the execution date\n:type execution_date: datetime.datetime\n:param state: the state of the dag run\n:type state: airflow.utils.state.State\n:param external_trigger: whether this dag run is externally triggered\n:type external_trigger: bool\n:param no_backfills: return no backfills (True), return all (False).\n    Defaults to False\n:type no_backfills: bool\n:param session: database session\n:type session: sqlalchemy.orm.session.Session", "id": "f9460:c0:m6"}
{"signature": "def get_dag(self):", "body": "if not self.dag:<EOL><INDENT>raise AirflowException(\"<STR_LIT>\"<EOL>.format(self))<EOL><DEDENT>return self.dag<EOL>", "docstring": "Returns the Dag associated with this DagRun.\n\n:return: DAG", "id": "f9460:c0:m9"}
{"signature": "@staticmethod<EOL><INDENT>def get_run(session, dag_id, execution_date):<DEDENT>", "body": "qry = session.query(DagRun).filter(<EOL>DagRun.dag_id == dag_id,<EOL>DagRun.external_trigger == False, <EOL>DagRun.execution_date == execution_date,<EOL>)<EOL>return qry.first()<EOL>", "docstring": ":param dag_id: DAG ID\n:type dag_id: unicode\n:param execution_date: execution date\n:type execution_date: datetime\n:return: DagRun corresponding to the given dag_id and execution date\n    if one exists. None otherwise.\n:rtype: airflow.models.DagRun", "id": "f9460:c0:m15"}
{"signature": "@provide_session<EOL><INDENT>def get_task_instance(self, task_id, session=None):<DEDENT>", "body": "from airflow.models.taskinstance import TaskInstance  <EOL>TI = TaskInstance<EOL>ti = session.query(TI).filter(<EOL>TI.dag_id == self.dag_id,<EOL>TI.execution_date == self.execution_date,<EOL>TI.task_id == task_id<EOL>).first()<EOL>return ti<EOL>", "docstring": "Returns the task instance specified by task_id for this dag run\n\n:param task_id: the task id", "id": "f9460:c0:m8"}
{"signature": "@provide_session<EOL><INDENT>def verify_integrity(self, session=None):<DEDENT>", "body": "from airflow.models.taskinstance import TaskInstance  <EOL>dag = self.get_dag()<EOL>tis = self.get_task_instances(session=session)<EOL>task_ids = []<EOL>for ti in tis:<EOL><INDENT>task_ids.append(ti.task_id)<EOL>task = None<EOL>try:<EOL><INDENT>task = dag.get_task(ti.task_id)<EOL><DEDENT>except AirflowException:<EOL><INDENT>if ti.state == State.REMOVED:<EOL><INDENT>pass  <EOL><DEDENT>elif self.state is not State.RUNNING and not dag.partial:<EOL><INDENT>self.log.warning(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(ti, dag))<EOL>Stats.incr(<EOL>\"<STR_LIT>\".format(dag.dag_id), <NUM_LIT:1>, <NUM_LIT:1>)<EOL>ti.state = State.REMOVED<EOL><DEDENT><DEDENT>is_task_in_dag = task is not None<EOL>should_restore_task = is_task_in_dag and ti.state == State.REMOVED<EOL>if should_restore_task:<EOL><INDENT>self.log.info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(ti, dag))<EOL>Stats.incr(\"<STR_LIT>\".format(dag.dag_id), <NUM_LIT:1>, <NUM_LIT:1>)<EOL>ti.state = State.NONE<EOL><DEDENT><DEDENT>for task in six.itervalues(dag.task_dict):<EOL><INDENT>if task.start_date > self.execution_date and not self.is_backfill:<EOL><INDENT>continue<EOL><DEDENT>if task.task_id not in task_ids:<EOL><INDENT>Stats.incr(<EOL>\"<STR_LIT>\".format(task.__class__.__name__),<EOL><NUM_LIT:1>, <NUM_LIT:1>)<EOL>ti = TaskInstance(task, self.execution_date)<EOL>session.add(ti)<EOL><DEDENT><DEDENT>session.commit()<EOL>", "docstring": "Verifies the DagRun by checking for removed tasks or tasks that are not in the\ndatabase yet. It will set state to removed or add the task if required.", "id": "f9460:c0:m14"}
{"signature": "@provide_session<EOL><INDENT>def _task_instances_for_dag_run(self, dag_run, session=None):<DEDENT>", "body": "tasks_to_run = {}<EOL>if dag_run is None:<EOL><INDENT>return tasks_to_run<EOL><DEDENT>self.reset_state_for_orphaned_tasks(filter_by_dag_run=dag_run, session=session)<EOL>dag_run.refresh_from_db()<EOL>make_transient(dag_run)<EOL>for ti in dag_run.get_task_instances():<EOL><INDENT>if ti.state == State.NONE:<EOL><INDENT>ti.set_state(State.SCHEDULED, session=session)<EOL><DEDENT>if ti.state != State.REMOVED:<EOL><INDENT>tasks_to_run[ti.key] = ti<EOL><DEDENT><DEDENT>return tasks_to_run<EOL>", "docstring": "Returns a map of task instance key to task instance object for the tasks to\nrun in the given dag run.\n\n:param dag_run: the dag run to get the tasks from\n:type dag_run: airflow.models.DagRun\n:param session: the database session object\n:type session: sqlalchemy.orm.session.Session", "id": "f9464:c3:m4"}
{"signature": "@property<EOL><INDENT>def start_time(self):<DEDENT>", "body": "if self._start_time is None:<EOL><INDENT>raise AirflowException(\"<STR_LIT>\")<EOL><DEDENT>return self._start_time<EOL>", "docstring": ":return: when this started to process the file\n:rtype: datetime", "id": "f9464:c1:m9"}
{"signature": "@provide_session<EOL><INDENT>def _set_unfinished_dag_runs_to_failed(self, dag_runs, session=None):<DEDENT>", "body": "for dag_run in dag_runs:<EOL><INDENT>dag_run.update_state()<EOL>if dag_run.state not in State.finished():<EOL><INDENT>dag_run.set_state(State.FAILED)<EOL><DEDENT>session.merge(dag_run)<EOL><DEDENT>", "docstring": "Go through the dag_runs and update the state based on the task_instance state.\nThen set DAG runs that are not finished to failed.\n\n:param dag_runs: DAG runs\n:param session: session\n:return: None", "id": "f9464:c3:m9"}
{"signature": "@property<EOL><INDENT>def result(self):<DEDENT>", "body": "if not self.done:<EOL><INDENT>raise AirflowException(\"<STR_LIT>\")<EOL><DEDENT>return self._result<EOL>", "docstring": ":return: result of running SchedulerJob.process_file()\n:rtype: airflow.utils.dag_processing.SimpleDag", "id": "f9464:c1:m8"}
{"signature": "@provide_session<EOL><INDENT>def _process_backfill_task_instances(self,<EOL>ti_status,<EOL>executor,<EOL>pickle_id,<EOL>start_date=None, session=None):<DEDENT>", "body": "executed_run_dates = []<EOL>while ((len(ti_status.to_run) > <NUM_LIT:0> or len(ti_status.running) > <NUM_LIT:0>) and<EOL>len(ti_status.deadlocked) == <NUM_LIT:0>):<EOL><INDENT>self.log.debug(\"<STR_LIT>\")<EOL>ti_status.not_ready.clear()<EOL>@provide_session<EOL>def _per_task_process(task, key, ti, session=None):<EOL><INDENT>ti.refresh_from_db()<EOL>task = self.dag.get_task(ti.task_id)<EOL>ti.task = task<EOL>ignore_depends_on_past = (<EOL>self.ignore_first_depends_on_past and<EOL>ti.execution_date == (start_date or ti.start_date))<EOL>self.log.debug(<EOL>\"<STR_LIT>\", ti, ti.state)<EOL>if ti.state == State.SUCCESS:<EOL><INDENT>ti_status.succeeded.add(key)<EOL>self.log.debug(\"<STR_LIT>\", ti)<EOL>ti_status.to_run.pop(key)<EOL>if key in ti_status.running:<EOL><INDENT>ti_status.running.pop(key)<EOL><DEDENT>return<EOL><DEDENT>elif ti.state == State.SKIPPED:<EOL><INDENT>ti_status.skipped.add(key)<EOL>self.log.debug(\"<STR_LIT>\", ti)<EOL>ti_status.to_run.pop(key)<EOL>if key in ti_status.running:<EOL><INDENT>ti_status.running.pop(key)<EOL><DEDENT>return<EOL><DEDENT>elif ti.state == State.NONE:<EOL><INDENT>self.log.warning(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL>ti.set_state(State.SCHEDULED, session=session)<EOL><DEDENT>if self.rerun_failed_tasks:<EOL><INDENT>if ti.state in (State.FAILED, State.UPSTREAM_FAILED):<EOL><INDENT>self.log.error(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(ti=ti,<EOL>state=ti.state))<EOL>if key in ti_status.running:<EOL><INDENT>ti_status.running.pop(key)<EOL><DEDENT>ti.set_state(State.SCHEDULED, session=session)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if ti.state in (State.FAILED, State.UPSTREAM_FAILED):<EOL><INDENT>self.log.error(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(ti=ti,<EOL>state=ti.state))<EOL>ti_status.failed.add(key)<EOL>ti_status.to_run.pop(key)<EOL>if key in ti_status.running:<EOL><INDENT>ti_status.running.pop(key)<EOL><DEDENT>return<EOL><DEDENT><DEDENT>backfill_context = DepContext(<EOL>deps=RUN_DEPS,<EOL>ignore_depends_on_past=ignore_depends_on_past,<EOL>ignore_task_deps=self.ignore_task_deps,<EOL>flag_upstream_failed=True)<EOL>if ti.are_dependencies_met(<EOL>dep_context=backfill_context,<EOL>session=session,<EOL>verbose=self.verbose):<EOL><INDENT>ti.refresh_from_db(lock_for_update=True, session=session)<EOL>if ti.state in (State.SCHEDULED, State.UP_FOR_RETRY, State.UP_FOR_RESCHEDULE):<EOL><INDENT>if executor.has_task(ti):<EOL><INDENT>self.log.debug(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>ti<EOL>)<EOL><DEDENT>else:<EOL><INDENT>self.log.debug('<STR_LIT>', ti)<EOL>ti.state = State.QUEUED<EOL>ti.queued_dttm = timezone.utcnow() if not ti.queued_dttm else ti.queued_dttm<EOL>session.merge(ti)<EOL>cfg_path = None<EOL>if executor.__class__ in (executors.LocalExecutor,<EOL>executors.SequentialExecutor):<EOL><INDENT>cfg_path = tmp_configuration_copy()<EOL><DEDENT>executor.queue_task_instance(<EOL>ti,<EOL>mark_success=self.mark_success,<EOL>pickle_id=pickle_id,<EOL>ignore_task_deps=self.ignore_task_deps,<EOL>ignore_depends_on_past=ignore_depends_on_past,<EOL>pool=self.pool,<EOL>cfg_path=cfg_path)<EOL>ti_status.running[key] = ti<EOL>ti_status.to_run.pop(key)<EOL><DEDENT><DEDENT>session.commit()<EOL>return<EOL><DEDENT>if ti.state == State.UPSTREAM_FAILED:<EOL><INDENT>self.log.error(\"<STR_LIT>\", ti)<EOL>ti_status.failed.add(key)<EOL>ti_status.to_run.pop(key)<EOL>if key in ti_status.running:<EOL><INDENT>ti_status.running.pop(key)<EOL><DEDENT>return<EOL><DEDENT>if ti.state == State.UP_FOR_RETRY:<EOL><INDENT>self.log.debug(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\", ti)<EOL>if key in ti_status.running:<EOL><INDENT>ti_status.running.pop(key)<EOL><DEDENT>ti_status.to_run[key] = ti<EOL>return<EOL><DEDENT>if ti.state == State.UP_FOR_RESCHEDULE:<EOL><INDENT>self.log.debug(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\", ti)<EOL>if key in ti_status.running:<EOL><INDENT>ti_status.running.pop(key)<EOL><DEDENT>ti_status.to_run[key] = ti<EOL>return<EOL><DEDENT>self.log.debug('<STR_LIT>', ti)<EOL>ti_status.not_ready.add(key)<EOL><DEDENT>non_pool_slots = conf.getint('<STR_LIT>', '<STR_LIT>')<EOL>try:<EOL><INDENT>for task in self.dag.topological_sort():<EOL><INDENT>for key, ti in list(ti_status.to_run.items()):<EOL><INDENT>if task.task_id != ti.task_id:<EOL><INDENT>continue<EOL><DEDENT>if task.pool:<EOL><INDENT>pool = session.query(models.Pool).filter(models.Pool.pool == task.pool).first()<EOL>if not pool:<EOL><INDENT>raise PoolNotFound('<STR_LIT>'.format(task.pool))<EOL><DEDENT>open_slots = pool.open_slots(session=session)<EOL>if open_slots <= <NUM_LIT:0>:<EOL><INDENT>raise NoAvailablePoolSlot(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(<EOL>open_slots, task.pool))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if non_pool_slots <= <NUM_LIT:0>:<EOL><INDENT>raise NoAvailablePoolSlot(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>non_pool_slots -= <NUM_LIT:1><EOL><DEDENT>num_running_tasks = DAG.get_num_task_instances(<EOL>self.dag_id,<EOL>states=(State.QUEUED, State.RUNNING))<EOL>if num_running_tasks >= self.dag.concurrency:<EOL><INDENT>raise DagConcurrencyLimitReached(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>_per_task_process(task, key, ti)<EOL><DEDENT><DEDENT><DEDENT>except (NoAvailablePoolSlot, DagConcurrencyLimitReached) as e:<EOL><INDENT>self.log.debug(e)<EOL><DEDENT>self.heartbeat()<EOL>executor.heartbeat()<EOL>if (ti_status.not_ready and<EOL>ti_status.not_ready == set(ti_status.to_run) and<EOL>len(ti_status.running) == <NUM_LIT:0>):<EOL><INDENT>self.log.warning(<EOL>\"<STR_LIT>\",<EOL>ti_status.to_run.values()<EOL>)<EOL>ti_status.deadlocked.update(ti_status.to_run.values())<EOL>ti_status.to_run.clear()<EOL><DEDENT>self._manage_executor_state(ti_status.running)<EOL>self._update_counters(ti_status=ti_status)<EOL>_dag_runs = ti_status.active_runs[:]<EOL>for run in _dag_runs:<EOL><INDENT>run.update_state(session=session)<EOL>if run.state in State.finished():<EOL><INDENT>ti_status.finished_runs += <NUM_LIT:1><EOL>ti_status.active_runs.remove(run)<EOL>executed_run_dates.append(run.execution_date)<EOL><DEDENT><DEDENT>self._log_progress(ti_status)<EOL><DEDENT>return executed_run_dates<EOL>", "docstring": "Process a set of task instances from a set of dag runs. Special handling is done\nto account for different task instance states that could be present when running\nthem in a backfill process.\n\n:param ti_status: the internal status of the job\n:type ti_status: BackfillJob._DagRunTaskStatus\n:param executor: the executor to run the task instances\n:type executor: BaseExecutor\n:param pickle_id: the pickle_id if dag is pickled, None otherwise\n:type pickle_id: int\n:param start_date: the start date of the backfill job\n:type start_date: datetime.datetime\n:param session: the current session object\n:type session: sqlalchemy.orm.session.Session\n:return: the list of execution_dates for the finished dag runs\n:rtype: list", "id": "f9464:c3:m6"}
{"signature": "@provide_session<EOL><INDENT>def _find_executable_task_instances(self, simple_dag_bag, states, session=None):<DEDENT>", "body": "executable_tis = []<EOL>TI = models.TaskInstance<EOL>DR = models.DagRun<EOL>DM = models.DagModel<EOL>ti_query = (<EOL>session<EOL>.query(TI)<EOL>.filter(TI.dag_id.in_(simple_dag_bag.dag_ids))<EOL>.outerjoin(<EOL>DR,<EOL>and_(DR.dag_id == TI.dag_id, DR.execution_date == TI.execution_date)<EOL>)<EOL>.filter(or_(DR.run_id == None,  <EOL>not_(DR.run_id.like(BackfillJob.ID_PREFIX + '<STR_LIT:%>'))))<EOL>.outerjoin(DM, DM.dag_id == TI.dag_id)<EOL>.filter(or_(DM.dag_id == None,  <EOL>not_(DM.is_paused)))<EOL>)<EOL>if None in states:<EOL><INDENT>ti_query = ti_query.filter(<EOL>or_(TI.state == None, TI.state.in_(states))  <EOL>)<EOL><DEDENT>else:<EOL><INDENT>ti_query = ti_query.filter(TI.state.in_(states))<EOL><DEDENT>task_instances_to_examine = ti_query.all()<EOL>if len(task_instances_to_examine) == <NUM_LIT:0>:<EOL><INDENT>self.log.debug(\"<STR_LIT>\")<EOL>return executable_tis<EOL><DEDENT>task_instance_str = \"<STR_LIT>\".join(<EOL>[repr(x) for x in task_instances_to_examine])<EOL>self.log.info(<EOL>\"<STR_LIT>\", len(task_instances_to_examine),<EOL>task_instance_str<EOL>)<EOL>pools = {p.pool: p for p in session.query(models.Pool).all()}<EOL>pool_to_task_instances = defaultdict(list)<EOL>for task_instance in task_instances_to_examine:<EOL><INDENT>pool_to_task_instances[task_instance.pool].append(task_instance)<EOL><DEDENT>states_to_count_as_running = [State.RUNNING, State.QUEUED]<EOL>dag_concurrency_map, task_concurrency_map = self.__get_concurrency_maps(<EOL>states=states_to_count_as_running, session=session)<EOL>for pool, task_instances in pool_to_task_instances.items():<EOL><INDENT>pool_name = pool<EOL>if not pool:<EOL><INDENT>open_slots = models.Pool.default_pool_open_slots()<EOL>pool_name = models.Pool.default_pool_name<EOL><DEDENT>else:<EOL><INDENT>if pool not in pools:<EOL><INDENT>self.log.warning(<EOL>\"<STR_LIT>\",<EOL>pool<EOL>)<EOL>open_slots = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>open_slots = pools[pool].open_slots(session=session)<EOL><DEDENT><DEDENT>num_ready = len(task_instances)<EOL>self.log.info(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>pool, open_slots, num_ready<EOL>)<EOL>priority_sorted_task_instances = sorted(<EOL>task_instances, key=lambda ti: (-ti.priority_weight, ti.execution_date))<EOL>num_starving_tasks = <NUM_LIT:0><EOL>for current_index, task_instance in enumerate(priority_sorted_task_instances):<EOL><INDENT>if open_slots <= <NUM_LIT:0>:<EOL><INDENT>self.log.info(<EOL>\"<STR_LIT>\",<EOL>open_slots, pool<EOL>)<EOL>num_starving_tasks = len(priority_sorted_task_instances) - current_index<EOL>break<EOL><DEDENT>dag_id = task_instance.dag_id<EOL>simple_dag = simple_dag_bag.get_dag(dag_id)<EOL>current_dag_concurrency = dag_concurrency_map[dag_id]<EOL>dag_concurrency_limit = simple_dag_bag.get_dag(dag_id).concurrency<EOL>self.log.info(<EOL>\"<STR_LIT>\",<EOL>dag_id, current_dag_concurrency, dag_concurrency_limit<EOL>)<EOL>if current_dag_concurrency >= dag_concurrency_limit:<EOL><INDENT>self.log.info(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>task_instance, dag_id, dag_concurrency_limit<EOL>)<EOL>continue<EOL><DEDENT>task_concurrency_limit = simple_dag.get_task_special_arg(<EOL>task_instance.task_id,<EOL>'<STR_LIT>')<EOL>if task_concurrency_limit is not None:<EOL><INDENT>current_task_concurrency = task_concurrency_map[<EOL>(task_instance.dag_id, task_instance.task_id)<EOL>]<EOL>if current_task_concurrency >= task_concurrency_limit:<EOL><INDENT>self.log.info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\", task_instance)<EOL>continue<EOL><DEDENT><DEDENT>if self.executor.has_task(task_instance):<EOL><INDENT>self.log.debug(<EOL>\"<STR_LIT>\",<EOL>task_instance.key<EOL>)<EOL>continue<EOL><DEDENT>executable_tis.append(task_instance)<EOL>open_slots -= <NUM_LIT:1><EOL>dag_concurrency_map[dag_id] += <NUM_LIT:1><EOL>task_concurrency_map[(task_instance.dag_id, task_instance.task_id)] += <NUM_LIT:1><EOL><DEDENT>Stats.gauge('<STR_LIT>'.format(pool_name=pool_name),<EOL>num_starving_tasks)<EOL><DEDENT>task_instance_str = \"<STR_LIT>\".join(<EOL>[repr(x) for x in executable_tis])<EOL>self.log.info(<EOL>\"<STR_LIT>\", task_instance_str)<EOL>for ti in executable_tis:<EOL><INDENT>copy_dag_id = ti.dag_id<EOL>copy_execution_date = ti.execution_date<EOL>copy_task_id = ti.task_id<EOL>make_transient(ti)<EOL>ti.dag_id = copy_dag_id<EOL>ti.execution_date = copy_execution_date<EOL>ti.task_id = copy_task_id<EOL><DEDENT>return executable_tis<EOL>", "docstring": "Finds TIs that are ready for execution with respect to pool limits,\ndag concurrency, executor state, and priority.\n\n:param simple_dag_bag: TaskInstances associated with DAGs in the\n    simple_dag_bag will be fetched from the DB and executed\n:type simple_dag_bag: airflow.utils.dag_processing.SimpleDagBag\n:param executor: the executor that runs task instances\n:type executor: BaseExecutor\n:param states: Execute TaskInstances in these states\n:type states: tuple[airflow.utils.state.State]\n:return: list[airflow.models.TaskInstance]", "id": "f9464:c2:m8"}
{"signature": "def heartbeat(self):", "body": "try:<EOL><INDENT>with create_session() as session:<EOL><INDENT>job = session.query(BaseJob).filter_by(id=self.id).one()<EOL>make_transient(job)<EOL>session.commit()<EOL><DEDENT>if job.state == State.SHUTDOWN:<EOL><INDENT>self.kill()<EOL><DEDENT>is_unit_test = conf.getboolean('<STR_LIT>', '<STR_LIT>')<EOL>if not is_unit_test:<EOL><INDENT>sleep_for = <NUM_LIT:0><EOL>if job.latest_heartbeat:<EOL><INDENT>seconds_remaining = self.heartrate -(timezone.utcnow() - job.latest_heartbeat).total_seconds()<EOL>sleep_for = max(<NUM_LIT:0>, seconds_remaining)<EOL><DEDENT>sleep(sleep_for)<EOL><DEDENT>with create_session() as session:<EOL><INDENT>job = session.query(BaseJob).filter(BaseJob.id == self.id).first()<EOL>job.latest_heartbeat = timezone.utcnow()<EOL>session.merge(job)<EOL>session.commit()<EOL>self.heartbeat_callback(session=session)<EOL>self.log.debug('<STR_LIT>')<EOL><DEDENT><DEDENT>except OperationalError as e:<EOL><INDENT>self.log.error(\"<STR_LIT>\", str(e))<EOL><DEDENT>", "docstring": "Heartbeats update the job's entry in the database with a timestamp\nfor the latest_heartbeat and allows for the job to be killed\nexternally. This allows at the system level to monitor what is\nactually active.\n\nFor instance, an old heartbeat for SchedulerJob would mean something\nis wrong.\n\nThis also allows for any job to be killed externally, regardless\nof who is running it or on which machine it is running.\n\nNote that if your heartbeat is set to 60 seconds and you call this\nmethod after 10 seconds of processing since the last heartbeat, it\nwill sleep 50 seconds to complete the 60 seconds and keep a steady\nheart rate. If you go over 60 seconds before calling it, it won't\nsleep at all.", "id": "f9464:c0:m5"}
{"signature": "@property<EOL><INDENT>def done(self):<DEDENT>", "body": "if self._process is None:<EOL><INDENT>raise AirflowException(\"<STR_LIT>\")<EOL><DEDENT>if self._done:<EOL><INDENT>return True<EOL><DEDENT>if self._result_queue and not self._result_queue.empty():<EOL><INDENT>self._result = self._result_queue.get_nowait()<EOL>self._done = True<EOL>self.log.debug(\"<STR_LIT>\", self._process)<EOL>self._process.join()<EOL>return True<EOL><DEDENT>if self._result_queue and not self._process.is_alive():<EOL><INDENT>self._done = True<EOL>if not self._result_queue.empty():<EOL><INDENT>self._result = self._result_queue.get_nowait()<EOL><DEDENT>self.log.debug(\"<STR_LIT>\", self._process)<EOL>self._process.join()<EOL>return True<EOL><DEDENT>return False<EOL>", "docstring": "Check if the process launched to process this file is done.\n\n:return: whether the process is finished running\n:rtype: bool", "id": "f9464:c1:m7"}
{"signature": "@provide_session<EOL><INDENT>def _execute(self, session=None):<DEDENT>", "body": "ti_status = BackfillJob._DagRunTaskStatus()<EOL>start_date = self.bf_start_date<EOL>run_dates = self.dag.get_run_dates(start_date=start_date,<EOL>end_date=self.bf_end_date)<EOL>if self.run_backwards:<EOL><INDENT>tasks_that_depend_on_past = [t.task_id for t in self.dag.task_dict.values() if t.depends_on_past]<EOL>if tasks_that_depend_on_past:<EOL><INDENT>raise AirflowException(<EOL>'<STR_LIT>'.format(<EOL>\"<STR_LIT:U+002C>\".join(tasks_that_depend_on_past)))<EOL><DEDENT>run_dates = run_dates[::-<NUM_LIT:1>]<EOL><DEDENT>if len(run_dates) == <NUM_LIT:0>:<EOL><INDENT>self.log.info(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>pickle_id = None<EOL>if not self.donot_pickle and self.executor.__class__ not in (<EOL>executors.LocalExecutor, executors.SequentialExecutor):<EOL><INDENT>pickle = DagPickle(self.dag)<EOL>session.add(pickle)<EOL>session.commit()<EOL>pickle_id = pickle.id<EOL><DEDENT>executor = self.executor<EOL>executor.start()<EOL>ti_status.total_runs = len(run_dates)  <EOL>try:<EOL><INDENT>remaining_dates = ti_status.total_runs<EOL>while remaining_dates > <NUM_LIT:0>:<EOL><INDENT>dates_to_process = [run_date for run_date in run_dates<EOL>if run_date not in ti_status.executed_dag_run_dates]<EOL>self._execute_for_run_dates(run_dates=dates_to_process,<EOL>ti_status=ti_status,<EOL>executor=executor,<EOL>pickle_id=pickle_id,<EOL>start_date=start_date,<EOL>session=session)<EOL>remaining_dates = (<EOL>ti_status.total_runs - len(ti_status.executed_dag_run_dates)<EOL>)<EOL>err = self._collect_errors(ti_status=ti_status, session=session)<EOL>if err:<EOL><INDENT>raise AirflowException(err)<EOL><DEDENT>if remaining_dates > <NUM_LIT:0>:<EOL><INDENT>self.log.info(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>self.dag_id<EOL>)<EOL>time.sleep(self.delay_on_limit_secs)<EOL><DEDENT><DEDENT><DEDENT>except (KeyboardInterrupt, SystemExit):<EOL><INDENT>self.log.warning(\"<STR_LIT>\")<EOL>self._set_unfinished_dag_runs_to_failed(ti_status.active_runs)<EOL><DEDENT>finally:<EOL><INDENT>session.commit()<EOL>executor.end()<EOL><DEDENT>self.log.info(\"<STR_LIT>\")<EOL>", "docstring": "Initializes all components required to run a dag for a specified date range and\ncalls helper method to execute the tasks.", "id": "f9464:c3:m10"}
{"signature": "def __init__(self, file_path, pickle_dags, dag_id_white_list, zombies):", "body": "self._file_path = file_path<EOL>self._result_queue = multiprocessing.Queue()<EOL>self._process = None<EOL>self._dag_id_white_list = dag_id_white_list<EOL>self._pickle_dags = pickle_dags<EOL>self._zombies = zombies<EOL>self._result = None<EOL>self._done = False<EOL>self._start_time = None<EOL>self._instance_id = DagFileProcessor.class_creation_counter<EOL>DagFileProcessor.class_creation_counter += <NUM_LIT:1><EOL>", "docstring": ":param file_path: a Python file containing Airflow DAG definitions\n:type file_path: unicode\n:param pickle_dags: whether to serialize the DAG objects to the DB\n:type pickle_dags: bool\n:param dag_id_whitelist: If specified, only look at these DAG ID's\n:type dag_id_whitelist: list[unicode]\n:param zombies: zombie task instances to kill\n:type zombies: list[airflow.utils.dag_processing.SimpleTaskInstance]", "id": "f9464:c1:m0"}
{"signature": "@staticmethod<EOL><INDENT>def update_import_errors(session, dagbag):<DEDENT>", "body": "<EOL>for dagbag_file in dagbag.file_last_changed:<EOL><INDENT>session.query(errors.ImportError).filter(<EOL>errors.ImportError.filename == dagbag_file<EOL>).delete()<EOL><DEDENT>for filename, stacktrace in six.iteritems(dagbag.import_errors):<EOL><INDENT>session.add(errors.ImportError(<EOL>filename=filename,<EOL>stacktrace=stacktrace))<EOL><DEDENT>session.commit()<EOL>", "docstring": "For the DAGs in the given DagBag, record any associated import errors and clears\nerrors for files that no longer have them. These are usually displayed through the\nAirflow UI so that users know that there are issues parsing DAGs.\n\n:param session: session for ORM operations\n:type session: sqlalchemy.orm.session.Session\n:param dagbag: DagBag containing DAGs with import errors\n:type dagbag: airflow.models.DagBag", "id": "f9464:c2:m3"}
{"signature": "def send_lineage(self,<EOL>operator=None, inlets=None, outlets=None, context=None):", "body": "raise NotImplementedError()<EOL>", "docstring": "Sends lineage metadata to a backend\n:param operator: the operator executing a transformation on the inlets and outlets\n:param inlets: the inlets to this operator\n:param outlets: the outlets from this operator\n:param context: the current context of the task instance", "id": "f9468:c0:m0"}
{"signature": "def parse(string, timezone=None):", "body": "return pendulum.parse(string, tz=timezone or TIMEZONE)<EOL>", "docstring": "Parse a time string and return an aware datetime\n:param string: time string", "id": "f9470:m8"}
{"signature": "def make_naive(value, timezone=None):", "body": "if timezone is None:<EOL><INDENT>timezone = TIMEZONE<EOL><DEDENT>if is_naive(value):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>o = value.astimezone(timezone)<EOL>naive = dt.datetime(o.year,<EOL>o.month,<EOL>o.day,<EOL>o.hour,<EOL>o.minute,<EOL>o.second,<EOL>o.microsecond)<EOL>return naive<EOL>", "docstring": "Make an aware datetime.datetime naive in a given time zone.\n\n:param value: datetime\n:param timezone: timezone\n:return: naive datetime", "id": "f9470:m6"}
{"signature": "def datetime(*args, **kwargs):", "body": "if '<STR_LIT>' not in kwargs:<EOL><INDENT>kwargs['<STR_LIT>'] = TIMEZONE<EOL><DEDENT>return dt.datetime(*args, **kwargs)<EOL>", "docstring": "Wrapper around datetime.datetime that adds settings.TIMEZONE if tzinfo not specified\n\n:return: datetime.datetime", "id": "f9470:m7"}
{"signature": "def utc_epoch():", "body": "<EOL>d = dt.datetime(<NUM_LIT>, <NUM_LIT:1>, <NUM_LIT:1>)<EOL>d = d.replace(tzinfo=utc)<EOL>return d<EOL>", "docstring": "Gets the epoch in the users timezone\n:return:", "id": "f9470:m3"}
{"signature": "def context_to_airflow_vars(context, in_env_var_format=False):", "body": "params = dict()<EOL>if in_env_var_format:<EOL><INDENT>name_format = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>name_format = '<STR_LIT:default>'<EOL><DEDENT>task_instance = context.get('<STR_LIT>')<EOL>if task_instance and task_instance.dag_id:<EOL><INDENT>params[AIRFLOW_VAR_NAME_FORMAT_MAPPING['<STR_LIT>'][<EOL>name_format]] = task_instance.dag_id<EOL><DEDENT>if task_instance and task_instance.task_id:<EOL><INDENT>params[AIRFLOW_VAR_NAME_FORMAT_MAPPING['<STR_LIT>'][<EOL>name_format]] = task_instance.task_id<EOL><DEDENT>if task_instance and task_instance.execution_date:<EOL><INDENT>params[<EOL>AIRFLOW_VAR_NAME_FORMAT_MAPPING['<STR_LIT>'][<EOL>name_format]] = task_instance.execution_date.isoformat()<EOL><DEDENT>dag_run = context.get('<STR_LIT>')<EOL>if dag_run and dag_run.run_id:<EOL><INDENT>params[AIRFLOW_VAR_NAME_FORMAT_MAPPING['<STR_LIT>'][<EOL>name_format]] = dag_run.run_id<EOL><DEDENT>return params<EOL>", "docstring": "Given a context, this function provides a dictionary of values that can be used to\nexternally reconstruct relations between dags, dag_runs, tasks and task_instances.\nDefault to abc.def.ghi format and can be made to ABC_DEF_GHI format if\nin_env_var_format is set to True.\n\n:param context: The context for the task_instance of interest.\n:type context: dict\n:param in_env_var_format: If returned vars should be in ABC_DEF_GHI format.\n:type in_env_var_format: bool\n:return: task_instance context as dict.", "id": "f9471:m0"}
{"signature": "def close(self):", "body": "<EOL>if self.closed:<EOL><INDENT>return<EOL><DEDENT>super().close()<EOL>if not self.upload_on_close:<EOL><INDENT>return<EOL><DEDENT>local_loc = os.path.join(self.local_base, self.log_relative_path)<EOL>remote_loc = os.path.join(self.remote_base, self.log_relative_path)<EOL>if os.path.exists(local_loc):<EOL><INDENT>with open(local_loc, '<STR_LIT:r>') as logfile:<EOL><INDENT>log = logfile.read()<EOL><DEDENT>self.s3_write(log, remote_loc)<EOL><DEDENT>self.closed = True<EOL>", "docstring": "Close and upload local log file to remote storage S3.", "id": "f9473:c0:m3"}
{"signature": "def _read(self, ti, try_number, metadata=None):", "body": "<EOL>log_relative_path = self._render_filename(ti, try_number)<EOL>remote_loc = os.path.join(self.remote_base, log_relative_path)<EOL>if self.s3_log_exists(remote_loc):<EOL><INDENT>remote_log = self.s3_read(remote_loc, return_error=True)<EOL>log = '<STR_LIT>'.format(<EOL>remote_loc, remote_log)<EOL>return log, {'<STR_LIT>': True}<EOL><DEDENT>else:<EOL><INDENT>return super()._read(ti, try_number)<EOL><DEDENT>", "docstring": "Read logs of given task instance and try_number from S3 remote storage.\nIf failed, read the log from task instance host machine.\n:param ti: task instance object\n:param try_number: task instance try_number to read logs from\n:param metadata: log metadata,\n                 can be used for steaming log reading and auto-tailing.", "id": "f9473:c0:m4"}
{"signature": "def _read(self, ti, try_number, metadata=None):", "body": "<EOL>log_relative_path = self._render_filename(ti, try_number)<EOL>remote_loc = os.path.join(self.remote_base, log_relative_path)<EOL>if self.wasb_log_exists(remote_loc):<EOL><INDENT>remote_log = self.wasb_read(remote_loc, return_error=True)<EOL>log = '<STR_LIT>'.format(<EOL>remote_loc, remote_log)<EOL>return log, {'<STR_LIT>': True}<EOL><DEDENT>else:<EOL><INDENT>return super()._read(ti, try_number)<EOL><DEDENT>", "docstring": "Read logs of given task instance and try_number from Wasb remote storage.\nIf failed, read the log from task instance host machine.\n:param ti: task instance object\n:param try_number: task instance try_number to read logs from\n:param metadata: log metadata,\n                 can be used for steaming log reading and auto-tailing.", "id": "f9474:c0:m4"}
{"signature": "def wasb_log_exists(self, remote_log_location):", "body": "try:<EOL><INDENT>return self.hook.check_for_blob(self.wasb_container, remote_log_location)<EOL><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT>return False<EOL>", "docstring": "Check if remote_log_location exists in remote storage\n:param remote_log_location: log's location in remote storage\n:return: True if location exists else False", "id": "f9474:c0:m5"}
{"signature": "def wasb_write(self, log, remote_log_location, append=True):", "body": "if append and self.wasb_log_exists(remote_log_location):<EOL><INDENT>old_log = self.wasb_read(remote_log_location)<EOL>log = '<STR_LIT:\\n>'.join([old_log, log]) if old_log else log<EOL><DEDENT>try:<EOL><INDENT>self.hook.load_string(<EOL>log,<EOL>self.wasb_container,<EOL>remote_log_location,<EOL>)<EOL><DEDENT>except AzureHttpError:<EOL><INDENT>self.log.exception('<STR_LIT>',<EOL>remote_log_location)<EOL><DEDENT>", "docstring": "Writes the log to the remote_log_location. Fails silently if no hook\nwas created.\n:param log: the log to write to the remote_log_location\n:type log: str\n:param remote_log_location: the log's location in remote storage\n:type remote_log_location: str (path)\n:param append: if False, any existing log file is overwritten. If True,\n    the new log is appended to any existing logs.\n:type append: bool", "id": "f9474:c0:m7"}
{"signature": "def flush(self):", "body": "if len(self._buffer) > <NUM_LIT:0>:<EOL><INDENT>self.logger.log(self.level, self._buffer)<EOL>self._buffer = str()<EOL><DEDENT>", "docstring": "Ensure all logging output has been flushed", "id": "f9475:c1:m3"}
{"signature": "@property<EOL><INDENT>def closed(self):<DEDENT>", "body": "return False<EOL>", "docstring": "Returns False to indicate that the stream is not closed (as it will be\nopen for the duration of Airflow's lifecycle).\n\nFor compatibility with the io.IOBase interface.", "id": "f9475:c1:m1"}
{"signature": "def _read(self, ti, try_number, metadata=None):", "body": "<EOL>log_relative_path = self._render_filename(ti, try_number)<EOL>remote_loc = os.path.join(self.remote_base, log_relative_path)<EOL>try:<EOL><INDENT>remote_log = self.gcs_read(remote_loc)<EOL>log = '<STR_LIT>'.format(<EOL>remote_loc, remote_log)<EOL>return log, {'<STR_LIT>': True}<EOL><DEDENT>except Exception as e:<EOL><INDENT>log = '<STR_LIT>'.format(<EOL>remote_loc, str(e))<EOL>self.log.error(log)<EOL>local_log, metadata = super()._read(ti, try_number)<EOL>log += local_log<EOL>return log, metadata<EOL><DEDENT>", "docstring": "Read logs of given task instance and try_number from GCS.\nIf failed, read the log from task instance host machine.\n:param ti: task instance object\n:param try_number: task instance try_number to read logs from\n:param metadata: log metadata,\n                 can be used for steaming log reading and auto-tailing.", "id": "f9479:c0:m4"}
{"signature": "def _build_metrics(func_name, namespace):", "body": "metrics = {'<STR_LIT>': func_name, '<STR_LIT>': datetime.utcnow(),<EOL>'<STR_LIT>': '<STR_LIT:{}>'.format(list(sys.argv)), '<STR_LIT:user>': getpass.getuser()}<EOL>assert isinstance(namespace, Namespace)<EOL>tmp_dic = vars(namespace)<EOL>metrics['<STR_LIT>'] = tmp_dic.get('<STR_LIT>')<EOL>metrics['<STR_LIT>'] = tmp_dic.get('<STR_LIT>')<EOL>metrics['<STR_LIT>'] = tmp_dic.get('<STR_LIT>')<EOL>metrics['<STR_LIT>'] = socket.gethostname()<EOL>extra = json.dumps(dict((k, metrics[k]) for k in ('<STR_LIT>', '<STR_LIT>')))<EOL>log = Log(<EOL>event='<STR_LIT>'.format(func_name),<EOL>task_instance=None,<EOL>owner=metrics['<STR_LIT:user>'],<EOL>extra=extra,<EOL>task_id=metrics.get('<STR_LIT>'),<EOL>dag_id=metrics.get('<STR_LIT>'),<EOL>execution_date=metrics.get('<STR_LIT>'))<EOL>metrics['<STR_LIT>'] = log<EOL>return metrics<EOL>", "docstring": "Builds metrics dict from function args\nIt assumes that function arguments is from airflow.bin.cli module's function\nand has Namespace instance where it optionally contains \"dag_id\", \"task_id\",\nand \"execution_date\".\n\n:param func_name: name of function\n:param namespace: Namespace instance from argparse\n:return: dict with metrics", "id": "f9481:m1"}
{"signature": "def action_logging(f):", "body": "@functools.wraps(f)<EOL>def wrapper(*args, **kwargs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>assert args<EOL>assert isinstance(args[<NUM_LIT:0>], Namespace),\"<STR_LIT>\"\"<STR_LIT>\".format(args[<NUM_LIT:0>])<EOL>metrics = _build_metrics(f.__name__, args[<NUM_LIT:0>])<EOL>cli_action_loggers.on_pre_execution(**metrics)<EOL>try:<EOL><INDENT>return f(*args, **kwargs)<EOL><DEDENT>except Exception as e:<EOL><INDENT>metrics['<STR_LIT:error>'] = e<EOL>raise<EOL><DEDENT>finally:<EOL><INDENT>metrics['<STR_LIT>'] = datetime.utcnow()<EOL>cli_action_loggers.on_post_execution(**metrics)<EOL><DEDENT><DEDENT>return wrapper<EOL>", "docstring": "Decorates function to execute function at the same time submitting action_logging\nbut in CLI context. It will call action logger callbacks twice,\none for pre-execution and the other one for post-execution.\n\nAction logger will be called with below keyword parameters:\n    sub_command : name of sub-command\n    start_datetime : start datetime instance by utc\n    end_datetime : end datetime instance by utc\n    full_command : full command line arguments\n    user : current user\n    log : airflow.models.log.Log ORM instance\n    dag_id : dag id (optional)\n    task_id : task_id (optional)\n    execution_date : execution date (optional)\n    error : exception instance if there's an exception\n\n:param f: function instance\n:return: wrapped function", "id": "f9481:m0"}
{"signature": "def days_ago(n, hour=<NUM_LIT:0>, minute=<NUM_LIT:0>, second=<NUM_LIT:0>, microsecond=<NUM_LIT:0>):", "body": "today = timezone.utcnow().replace(<EOL>hour=hour,<EOL>minute=minute,<EOL>second=second,<EOL>microsecond=microsecond)<EOL>return today - timedelta(days=n)<EOL>", "docstring": "Get a datetime object representing `n` days ago. By default the time is\nset to midnight.", "id": "f9485:m4"}
{"signature": "def date_range(start_date, end_date=None, num=None, delta=None):", "body": "if not delta:<EOL><INDENT>return []<EOL><DEDENT>if end_date and start_date > end_date:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>if end_date and num:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>if not end_date and not num:<EOL><INDENT>end_date = timezone.utcnow()<EOL><DEDENT>delta_iscron = False<EOL>tz = start_date.tzinfo<EOL>if isinstance(delta, six.string_types):<EOL><INDENT>delta_iscron = True<EOL>start_date = timezone.make_naive(start_date, tz)<EOL>cron = croniter(delta, start_date)<EOL><DEDENT>elif isinstance(delta, timedelta):<EOL><INDENT>delta = abs(delta)<EOL><DEDENT>dates = []<EOL>if end_date:<EOL><INDENT>if timezone.is_naive(start_date):<EOL><INDENT>end_date = timezone.make_naive(end_date, tz)<EOL><DEDENT>while start_date <= end_date:<EOL><INDENT>if timezone.is_naive(start_date):<EOL><INDENT>dates.append(timezone.make_aware(start_date, tz))<EOL><DEDENT>else:<EOL><INDENT>dates.append(start_date)<EOL><DEDENT>if delta_iscron:<EOL><INDENT>start_date = cron.get_next(datetime)<EOL><DEDENT>else:<EOL><INDENT>start_date += delta<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for _ in range(abs(num)):<EOL><INDENT>if timezone.is_naive(start_date):<EOL><INDENT>dates.append(timezone.make_aware(start_date, tz))<EOL><DEDENT>else:<EOL><INDENT>dates.append(start_date)<EOL><DEDENT>if delta_iscron:<EOL><INDENT>if num > <NUM_LIT:0>:<EOL><INDENT>start_date = cron.get_next(datetime)<EOL><DEDENT>else:<EOL><INDENT>start_date = cron.get_prev(datetime)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if num > <NUM_LIT:0>:<EOL><INDENT>start_date += delta<EOL><DEDENT>else:<EOL><INDENT>start_date -= delta<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return sorted(dates)<EOL>", "docstring": "Get a set of dates as a list based on a start, end and delta, delta\ncan be something that can be added to `datetime.datetime`\nor a cron expression as a `str`\n\n:Example::\n\n    date_range(datetime(2016, 1, 1), datetime(2016, 1, 3), delta=timedelta(1))\n        [datetime.datetime(2016, 1, 1, 0, 0), datetime.datetime(2016, 1, 2, 0, 0),\n        datetime.datetime(2016, 1, 3, 0, 0)]\n    date_range(datetime(2016, 1, 1), datetime(2016, 1, 3), delta='0 0 * * *')\n        [datetime.datetime(2016, 1, 1, 0, 0), datetime.datetime(2016, 1, 2, 0, 0),\n        datetime.datetime(2016, 1, 3, 0, 0)]\n    date_range(datetime(2016, 1, 1), datetime(2016, 3, 3), delta=\"0 0 0 * *\")\n        [datetime.datetime(2016, 1, 1, 0, 0), datetime.datetime(2016, 2, 1, 0, 0),\n        datetime.datetime(2016, 3, 1, 0, 0)]\n\n:param start_date: anchor date to start the series from\n:type start_date: datetime.datetime\n:param end_date: right boundary for the date range\n:type end_date: datetime.datetime\n:param num: alternatively to end_date, you can specify the number of\n    number of entries you want in the range. This number can be negative,\n    output will always be sorted regardless\n:type num: int", "id": "f9485:m0"}
{"signature": "def send_email(to, subject, html_content,<EOL>files=None, dryrun=False, cc=None, bcc=None,<EOL>mime_subtype='<STR_LIT>', mime_charset='<STR_LIT:utf-8>', **kwargs):", "body": "path, attr = configuration.conf.get('<STR_LIT:email>', '<STR_LIT>').rsplit('<STR_LIT:.>', <NUM_LIT:1>)<EOL>module = importlib.import_module(path)<EOL>backend = getattr(module, attr)<EOL>to = get_email_address_list(to)<EOL>to = \"<STR_LIT:U+002CU+0020>\".join(to)<EOL>return backend(to, subject, html_content, files=files,<EOL>dryrun=dryrun, cc=cc, bcc=bcc,<EOL>mime_subtype=mime_subtype, mime_charset=mime_charset, **kwargs)<EOL>", "docstring": "Send email using backend specified in EMAIL_BACKEND.", "id": "f9486:m0"}
{"signature": "def tmp_configuration_copy(chmod=<NUM_LIT>):", "body": "cfg_dict = conf.as_dict(display_sensitive=True, raw=True)<EOL>temp_fd, cfg_path = mkstemp()<EOL>with os.fdopen(temp_fd, '<STR_LIT:w>') as temp_file:<EOL><INDENT>if chmod is not None:<EOL><INDENT>os.fchmod(temp_fd, chmod)<EOL><DEDENT>json.dump(cfg_dict, temp_file)<EOL><DEDENT>return cfg_path<EOL>", "docstring": "Returns a path for a temporary file including a full copy of the configuration\nsettings.\n:return: a path to a temporary file", "id": "f9489:m0"}
{"signature": "def chain(*tasks):", "body": "for up_task, down_task in zip(tasks[:-<NUM_LIT:1>], tasks[<NUM_LIT:1>:]):<EOL><INDENT>up_task.set_downstream(down_task)<EOL><DEDENT>", "docstring": "Given a number of tasks, builds a dependency chain.\n\nchain(task_1, task_2, task_3, task_4)\n\nis equivalent to\n\ntask_1.set_downstream(task_2)\ntask_2.set_downstream(task_3)\ntask_3.set_downstream(task_4)", "id": "f9491:m9"}
{"signature": "def pprinttable(rows):", "body": "if not rows:<EOL><INDENT>return<EOL><DEDENT>if hasattr(rows[<NUM_LIT:0>], '<STR_LIT>'):  <EOL><INDENT>headers = rows[<NUM_LIT:0>]._fields<EOL><DEDENT>else:<EOL><INDENT>headers = [\"<STR_LIT>\".format(i) for i in range(len(rows[<NUM_LIT:0>]))]<EOL><DEDENT>lens = [len(s) for s in headers]<EOL>for row in rows:<EOL><INDENT>for i in range(len(rows[<NUM_LIT:0>])):<EOL><INDENT>slenght = len(\"<STR_LIT:{}>\".format(row[i]))<EOL>if slenght > lens[i]:<EOL><INDENT>lens[i] = slenght<EOL><DEDENT><DEDENT><DEDENT>formats = []<EOL>hformats = []<EOL>for i in range(len(rows[<NUM_LIT:0>])):<EOL><INDENT>if isinstance(rows[<NUM_LIT:0>][i], int):<EOL><INDENT>formats.append(\"<STR_LIT>\" % lens[i])<EOL><DEDENT>else:<EOL><INDENT>formats.append(\"<STR_LIT>\" % lens[i])<EOL><DEDENT>hformats.append(\"<STR_LIT>\" % lens[i])<EOL><DEDENT>pattern = \"<STR_LIT>\".join(formats)<EOL>hpattern = \"<STR_LIT>\".join(hformats)<EOL>separator = \"<STR_LIT>\".join(['<STR_LIT:->' * n for n in lens])<EOL>s = \"<STR_LIT>\"<EOL>s += separator + '<STR_LIT:\\n>'<EOL>s += (hpattern % tuple(headers)) + '<STR_LIT:\\n>'<EOL>s += separator + '<STR_LIT:\\n>'<EOL>def f(t):<EOL><INDENT>return \"<STR_LIT:{}>\".format(t) if isinstance(t, basestring) else t<EOL><DEDENT>for line in rows:<EOL><INDENT>s += pattern % tuple(f(t) for t in line) + '<STR_LIT:\\n>'<EOL><DEDENT>s += separator + '<STR_LIT:\\n>'<EOL>return s<EOL>", "docstring": "Returns a pretty ascii table from tuples\n\n    If namedtuple are used, the table will have headers", "id": "f9491:m11"}
{"signature": "@property<EOL><INDENT>def concurrency(self):<DEDENT>", "body": "return self._concurrency<EOL>", "docstring": ":return: maximum number of tasks that can run simultaneously from this DAG\n:rtype: int", "id": "f9493:c0:m4"}
{"signature": "def get_all_pids(self):", "body": "return [x.pid for x in self._processors.values()]<EOL>", "docstring": ":return: a list of the PIDs for the processors that are running\n:rtype: List[int]", "id": "f9493:c6:m11"}
{"signature": "@property<EOL><INDENT>def dag_ids(self):<DEDENT>", "body": "return self.dag_id_to_simple_dag.keys()<EOL>", "docstring": ":return: IDs of all the DAGs in this\n:rtype: list[unicode]", "id": "f9493:c2:m1"}
{"signature": "def _refresh_dag_dir(self):", "body": "elapsed_time_since_refresh = (timezone.utcnow() -<EOL>self.last_dag_dir_refresh_time).total_seconds()<EOL>if elapsed_time_since_refresh > self.dag_dir_list_interval:<EOL><INDENT>self.log.info(\"<STR_LIT>\", self._dag_directory)<EOL>self._file_paths = list_py_file_paths(self._dag_directory)<EOL>self.last_dag_dir_refresh_time = timezone.utcnow()<EOL>self.log.info(\"<STR_LIT>\", len(self._file_paths), self._dag_directory)<EOL>self.set_file_paths(self._file_paths)<EOL>try:<EOL><INDENT>self.log.debug(\"<STR_LIT>\")<EOL>self.clear_nonexistent_import_errors()<EOL><DEDENT>except Exception:<EOL><INDENT>self.log.exception(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>", "docstring": "Refresh file paths from dag dir if we haven't done it for too long.", "id": "f9493:c6:m5"}
{"signature": "def processing_count(self):", "body": "return len(self._processors)<EOL>", "docstring": ":return: the number of files currently being processed\n:rtype: int", "id": "f9493:c6:m17"}
{"signature": "@property<EOL><INDENT>@abstractmethod<EOL>def file_path(self):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": ":return: the path to the file that this is processing\n:rtype: unicode", "id": "f9493:c3:m7"}
{"signature": "def harvest_simple_dags(self):", "body": "<EOL>self._sync_metadata()<EOL>self._heartbeat_manager()<EOL>simple_dags = []<EOL>if sys.platform == \"<STR_LIT>\":<EOL><INDENT>qsize = self._result_count<EOL><DEDENT>else:<EOL><INDENT>qsize = self._result_queue.qsize()<EOL><DEDENT>for _ in range(qsize):<EOL><INDENT>simple_dags.append(self._result_queue.get())<EOL><DEDENT>self._result_count = <NUM_LIT:0><EOL>return simple_dags<EOL>", "docstring": "Harvest DAG parsing results from result queue and sync metadata from stat queue.\n:return: List of parsing result in SimpleDag format.", "id": "f9493:c5:m5"}
{"signature": "@abstractmethod<EOL><INDENT>def terminate(self, sigkill=False):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "Terminate (and then kill) the process launched to process the file", "id": "f9493:c3:m1"}
{"signature": "@provide_session<EOL><INDENT>def clear_nonexistent_import_errors(self, session):<DEDENT>", "body": "query = session.query(errors.ImportError)<EOL>if self._file_paths:<EOL><INDENT>query = query.filter(<EOL>~errors.ImportError.filename.in_(self._file_paths)<EOL>)<EOL><DEDENT>query.delete(synchronize_session='<STR_LIT>')<EOL>session.commit()<EOL>", "docstring": "Clears import errors for files that no longer exist.\n\n:param session: session for ORM operations\n:type session: sqlalchemy.orm.session.Session", "id": "f9493:c6:m7"}
{"signature": "def __init__(self,<EOL>dag_directory,<EOL>file_paths,<EOL>max_runs,<EOL>processor_factory,<EOL>signal_conn,<EOL>stat_queue,<EOL>result_queue,<EOL>async_mode=True):", "body": "self._file_paths = file_paths<EOL>self._file_path_queue = []<EOL>self._dag_directory = dag_directory<EOL>self._max_runs = max_runs<EOL>self._processor_factory = processor_factory<EOL>self._signal_conn = signal_conn<EOL>self._stat_queue = stat_queue<EOL>self._result_queue = result_queue<EOL>self._async_mode = async_mode<EOL>self._parallelism = conf.getint('<STR_LIT>', '<STR_LIT>')<EOL>if '<STR_LIT>' in conf.get('<STR_LIT>', '<STR_LIT>') and self._parallelism > <NUM_LIT:1>:<EOL><INDENT>self.log.error(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>self._parallelism = <NUM_LIT:1><EOL><DEDENT>self._file_process_interval = conf.getint('<STR_LIT>',<EOL>'<STR_LIT>')<EOL>self.print_stats_interval = conf.getint('<STR_LIT>',<EOL>'<STR_LIT>')<EOL>self._zombie_threshold_secs = (<EOL>conf.getint('<STR_LIT>', '<STR_LIT>'))<EOL>self._processors = {}<EOL>self._last_runtime = {}<EOL>self._last_finish_time = {}<EOL>self._last_zombie_query_time = timezone.utcnow()<EOL>self.last_dag_dir_refresh_time = timezone.utcnow()<EOL>self.last_stat_print_time = timezone.datetime(<NUM_LIT>, <NUM_LIT:1>, <NUM_LIT:1>)<EOL>self._zombie_query_interval = <NUM_LIT:10><EOL>self._run_count = defaultdict(int)<EOL>self._heart_beat_key = '<STR_LIT>'<EOL>self.dag_dir_list_interval = conf.getint('<STR_LIT>',<EOL>'<STR_LIT>')<EOL>self._log = logging.getLogger('<STR_LIT>')<EOL>signal.signal(signal.SIGINT, self._exit_gracefully)<EOL>signal.signal(signal.SIGTERM, self._exit_gracefully)<EOL>", "docstring": ":param dag_directory: Directory where DAG definitions are kept. All\n    files in file_paths should be under this directory\n:type dag_directory: unicode\n:param file_paths: list of file paths that contain DAG definitions\n:type file_paths: list[unicode]\n:param max_runs: The number of times to parse and schedule each file. -1\n    for unlimited.\n:type max_runs: int\n:param processor_factory: function that creates processors for DAG\n    definition files. Arguments are (dag_definition_path)\n:type processor_factory: (unicode, unicode, list) -> (AbstractDagFileProcessor)\n:param signal_conn: connection to communicate signal with processor agent.\n:type signal_conn: airflow.models.connection.Connection\n:param stat_queue: the queue to use for passing back parsing stat to agent.\n:type stat_queue: multiprocessing.Queue\n:param result_queue: the queue to use for passing back the result to agent.\n:type result_queue: multiprocessing.Queue\n:param async_mode: whether to start the manager in async mode\n:type async_mode: bool", "id": "f9493:c6:m0"}
{"signature": "def get_last_finish_time(self, file_path):", "body": "return self._last_finish_time.get(file_path)<EOL>", "docstring": ":param file_path: the path to the file that was processed\n:type file_path: unicode\n:return: the finish time of the process of the last run, or None if the\n    file was never processed.\n:rtype: datetime", "id": "f9493:c6:m14"}
{"signature": "def correct_maybe_zipped(fileloc):", "body": "_, archive, filename = re.search(<EOL>r'<STR_LIT>'.format(re.escape(os.sep)), fileloc).groups()<EOL>if archive and zipfile.is_zipfile(archive):<EOL><INDENT>return archive<EOL><DEDENT>else:<EOL><INDENT>return fileloc<EOL><DEDENT>", "docstring": "If the path contains a folder with a .zip suffix, then\nthe folder is treated as a zip archive and path to zip is returned.", "id": "f9493:m0"}
{"signature": "def terminate(self):", "body": "for processor in self._processors.values():<EOL><INDENT>processor.terminate()<EOL><DEDENT>", "docstring": "Stops all running processors\n:return: None", "id": "f9493:c6:m22"}
{"signature": "def default_action_log(log, **_):", "body": "with create_session() as session:<EOL><INDENT>session.add(log)<EOL><DEDENT>", "docstring": "A default action logger callback that behave same as www.utils.action_logging\nwhich uses global session and pushes log ORM object.\n:param log: An log ORM instance\n:param **_: other keyword arguments that is not being used by this function\n:return: None", "id": "f9494:m4"}
{"signature": "def register_post_exec_callback(action_logger):", "body": "logging.debug(\"<STR_LIT>\", action_logger)<EOL>__post_exec_callbacks.append(action_logger)<EOL>", "docstring": "Registers more action_logger function callback for post-execution.\nThis function callback is expected to be called with keyword args.\nFor more about the arguments that is being passed to the callback,\nrefer to airflow.utils.cli.action_logging()\n:param action_logger: An action logger function\n:return: None", "id": "f9494:m1"}
{"signature": "def get_first(self, hql, parameters=None):", "body": "try:<EOL><INDENT>return super().get_first(<EOL>self._strip_sql(hql), parameters)<EOL><DEDENT>except DatabaseError as e:<EOL><INDENT>raise PrestoException(self._get_pretty_exception_message(e))<EOL><DEDENT>", "docstring": "Returns only the first row, regardless of how many rows the query\nreturns.", "id": "f9501:c1:m4"}
{"signature": "def run(self, hql, parameters=None):", "body": "return super().run(self._strip_sql(hql), parameters)<EOL>", "docstring": "Execute the statement against Presto. Can be used to create views.", "id": "f9501:c1:m6"}
{"signature": "def set_autocommit(self, conn, autocommit):", "body": "if not self.supports_autocommit and autocommit:<EOL><INDENT>self.log.warn(<EOL>(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"),<EOL>getattr(self, self.conn_name_attr))<EOL><DEDENT>conn.autocommit = autocommit<EOL>", "docstring": "Sets the autocommit flag on the connection", "id": "f9502:c0:m8"}
{"signature": "def run_and_check(self, session, prepped_request, extra_options):", "body": "extra_options = extra_options or {}<EOL>try:<EOL><INDENT>response = session.send(<EOL>prepped_request,<EOL>stream=extra_options.get(\"<STR_LIT>\", False),<EOL>verify=extra_options.get(\"<STR_LIT>\", True),<EOL>proxies=extra_options.get(\"<STR_LIT>\", {}),<EOL>cert=extra_options.get(\"<STR_LIT>\"),<EOL>timeout=extra_options.get(\"<STR_LIT>\"),<EOL>allow_redirects=extra_options.get(\"<STR_LIT>\", True))<EOL>if extra_options.get('<STR_LIT>', True):<EOL><INDENT>self.check_response(response)<EOL><DEDENT>return response<EOL><DEDENT>except requests.exceptions.ConnectionError as ex:<EOL><INDENT>self.log.warn(str(ex) + '<STR_LIT>')<EOL>raise ex<EOL><DEDENT>", "docstring": "Grabs extra options like timeout and actually runs the request,\nchecking for the result\n\n:param session: the session to be used to execute the request\n:type session: requests.Session\n:param prepped_request: the prepared request generated in run()\n:type prepped_request: session.prepare_request\n:param extra_options: additional options to be used when executing the request\n    i.e. {'check_response': False} to avoid checking raising exceptions on non 2XX\n    or 3XX status codes\n:type extra_options: dict", "id": "f9503:c0:m4"}
{"signature": "def insert_rows(self, table, rows, target_fields=None, commit_every=<NUM_LIT:1000>):", "body": "if target_fields:<EOL><INDENT>target_fields = '<STR_LIT:U+002CU+0020>'.join(target_fields)<EOL>target_fields = '<STR_LIT>'.format(target_fields)<EOL><DEDENT>else:<EOL><INDENT>target_fields = '<STR_LIT>'<EOL><DEDENT>conn = self.get_conn()<EOL>cur = conn.cursor()<EOL>if self.supports_autocommit:<EOL><INDENT>cur.execute('<STR_LIT>')<EOL><DEDENT>conn.commit()<EOL>i = <NUM_LIT:0><EOL>for row in rows:<EOL><INDENT>i += <NUM_LIT:1><EOL>lst = []<EOL>for cell in row:<EOL><INDENT>if isinstance(cell, basestring):<EOL><INDENT>lst.append(\"<STR_LIT:'>\" + str(cell).replace(\"<STR_LIT:'>\", \"<STR_LIT>\") + \"<STR_LIT:'>\")<EOL><DEDENT>elif cell is None:<EOL><INDENT>lst.append('<STR_LIT>')<EOL><DEDENT>elif type(cell) == float andnumpy.isnan(cell):  <EOL><INDENT>lst.append('<STR_LIT>')<EOL><DEDENT>elif isinstance(cell, numpy.datetime64):<EOL><INDENT>lst.append(\"<STR_LIT:'>\" + str(cell) + \"<STR_LIT:'>\")<EOL><DEDENT>elif isinstance(cell, datetime):<EOL><INDENT>lst.append(\"<STR_LIT>\" +<EOL>cell.strftime('<STR_LIT>') +<EOL>\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>lst.append(str(cell))<EOL><DEDENT><DEDENT>values = tuple(lst)<EOL>sql = '<STR_LIT>''<STR_LIT>'.format(table,<EOL>target_fields,<EOL>'<STR_LIT:U+002C>'.join(values))<EOL>cur.execute(sql)<EOL>if i % commit_every == <NUM_LIT:0>:<EOL><INDENT>conn.commit()<EOL>self.log.info('<STR_LIT>', i, table)<EOL><DEDENT><DEDENT>conn.commit()<EOL>cur.close()<EOL>conn.close()<EOL>self.log.info('<STR_LIT>', i)<EOL>", "docstring": "A generic way to insert a set of tuples into a table,\nthe whole set of inserts is treated as one transaction\nChanges from standard DbApiHook implementation:\n\n- Oracle SQL queries in cx_Oracle can not be terminated with a semicolon (`;`)\n- Replace NaN values with NULL using `numpy.nan_to_num` (not using\n  `is_nan()` because of input types error for strings)\n- Coerce datetime cells to Oracle DATETIME format during insert\n\n:param table: target Oracle table, use dot notation to target a\n    specific database\n:type table: str\n:param rows: the rows to insert into the table\n:type rows: iterable of tuples\n:param target_fields: the names of the columns to fill in the table\n:type target_fields: iterable of str\n:param commit_every: the maximum number of rows to insert in one transaction\n    Default 1000, Set greater than 0.\n    Set 1 to insert each row in each single transaction\n:type commit_every: int", "id": "f9504:c0:m1"}
{"signature": "def select_key(self, key, bucket_name=None,<EOL>expression='<STR_LIT>',<EOL>expression_type='<STR_LIT>',<EOL>input_serialization=None,<EOL>output_serialization=None):", "body": "if input_serialization is None:<EOL><INDENT>input_serialization = {'<STR_LIT>': {}}<EOL><DEDENT>if output_serialization is None:<EOL><INDENT>output_serialization = {'<STR_LIT>': {}}<EOL><DEDENT>if not bucket_name:<EOL><INDENT>(bucket_name, key) = self.parse_s3_url(key)<EOL><DEDENT>response = self.get_conn().select_object_content(<EOL>Bucket=bucket_name,<EOL>Key=key,<EOL>Expression=expression,<EOL>ExpressionType=expression_type,<EOL>InputSerialization=input_serialization,<EOL>OutputSerialization=output_serialization)<EOL>return '<STR_LIT>'.join(event['<STR_LIT>']['<STR_LIT>'].decode('<STR_LIT:utf-8>')<EOL>for event in response['<STR_LIT>']<EOL>if '<STR_LIT>' in event)<EOL>", "docstring": "Reads a key with S3 Select.\n\n:param key: S3 key that will point to the file\n:type key: str\n:param bucket_name: Name of the bucket in which the file is stored\n:type bucket_name: str\n:param expression: S3 Select expression\n:type expression: str\n:param expression_type: S3 Select expression type\n:type expression_type: str\n:param input_serialization: S3 Select input data serialization format\n:type input_serialization: dict\n:param output_serialization: S3 Select output data serialization format\n:type output_serialization: dict\n:return: retrieved subset of original data by S3 Select\n:rtype: str\n\n.. seealso::\n    For more details about S3 Select parameters:\n    http://boto3.readthedocs.io/en/latest/reference/services/s3.html#S3.Client.select_object_content", "id": "f9505:c0:m11"}
{"signature": "def check_for_prefix(self, bucket_name, prefix, delimiter):", "body": "prefix = prefix + delimiter if prefix[-<NUM_LIT:1>] != delimiter else prefix<EOL>prefix_split = re.split(r'<STR_LIT>'.format(d=delimiter), prefix, <NUM_LIT:1>)<EOL>previous_level = prefix_split[<NUM_LIT:0>]<EOL>plist = self.list_prefixes(bucket_name, previous_level, delimiter)<EOL>return False if plist is None else prefix in plist<EOL>", "docstring": "Checks that a prefix exists in a bucket\n\n:param bucket_name: the name of the bucket\n:type bucket_name: str\n:param prefix: a key prefix\n:type prefix: str\n:param delimiter: the delimiter marks key hierarchy.\n:type delimiter: str", "id": "f9505:c0:m5"}
{"signature": "def get_conn(self):", "body": "conn = self.get_connection(self.mysql_conn_id)<EOL>conn_config = {<EOL>\"<STR_LIT:user>\": conn.login,<EOL>\"<STR_LIT>\": conn.password or '<STR_LIT>',<EOL>\"<STR_LIT:host>\": conn.host or '<STR_LIT:localhost>',<EOL>\"<STR_LIT>\": self.schema or conn.schema or '<STR_LIT>'<EOL>}<EOL>if not conn.port:<EOL><INDENT>conn_config[\"<STR_LIT:port>\"] = <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>conn_config[\"<STR_LIT:port>\"] = int(conn.port)<EOL><DEDENT>if conn.extra_dejson.get('<STR_LIT>', False):<EOL><INDENT>conn_config[\"<STR_LIT>\"] = conn.extra_dejson[\"<STR_LIT>\"]<EOL>if (conn_config[\"<STR_LIT>\"]).lower() == '<STR_LIT:utf8>' or(conn_config[\"<STR_LIT>\"]).lower() == '<STR_LIT:utf-8>':<EOL><INDENT>conn_config[\"<STR_LIT>\"] = True<EOL><DEDENT><DEDENT>if conn.extra_dejson.get('<STR_LIT>', False):<EOL><INDENT>if (conn.extra_dejson[\"<STR_LIT>\"]).lower() == '<STR_LIT>':<EOL><INDENT>conn_config[\"<STR_LIT>\"] = MySQLdb.cursors.SSCursor<EOL><DEDENT>elif (conn.extra_dejson[\"<STR_LIT>\"]).lower() == '<STR_LIT>':<EOL><INDENT>conn_config[\"<STR_LIT>\"] = MySQLdb.cursors.DictCursor<EOL><DEDENT>elif (conn.extra_dejson[\"<STR_LIT>\"]).lower() == '<STR_LIT>':<EOL><INDENT>conn_config[\"<STR_LIT>\"] = MySQLdb.cursors.SSDictCursor<EOL><DEDENT><DEDENT>local_infile = conn.extra_dejson.get('<STR_LIT>', False)<EOL>if conn.extra_dejson.get('<STR_LIT>', False):<EOL><INDENT>dejson_ssl = conn.extra_dejson['<STR_LIT>']<EOL>if isinstance(dejson_ssl, six.string_types):<EOL><INDENT>dejson_ssl = json.loads(dejson_ssl)<EOL><DEDENT>conn_config['<STR_LIT>'] = dejson_ssl<EOL><DEDENT>if conn.extra_dejson.get('<STR_LIT>'):<EOL><INDENT>conn_config['<STR_LIT>'] = conn.extra_dejson['<STR_LIT>']<EOL><DEDENT>if local_infile:<EOL><INDENT>conn_config[\"<STR_LIT>\"] = <NUM_LIT:1><EOL><DEDENT>conn = MySQLdb.connect(**conn_config)<EOL>return conn<EOL>", "docstring": "Returns a mysql connection object", "id": "f9506:c0:m3"}
{"signature": "def run_cli(self, pig, verbose=True):", "body": "with TemporaryDirectory(prefix='<STR_LIT>') as tmp_dir:<EOL><INDENT>with NamedTemporaryFile(dir=tmp_dir) as f:<EOL><INDENT>f.write(pig.encode('<STR_LIT:utf-8>'))<EOL>f.flush()<EOL>fname = f.name<EOL>pig_bin = '<STR_LIT>'<EOL>cmd_extra = []<EOL>pig_cmd = [pig_bin, '<STR_LIT>', fname] + cmd_extra<EOL>if self.pig_properties:<EOL><INDENT>pig_properties_list = self.pig_properties.split()<EOL>pig_cmd.extend(pig_properties_list)<EOL><DEDENT>if verbose:<EOL><INDENT>self.log.info(\"<STR_LIT:%s>\", \"<STR_LIT:U+0020>\".join(pig_cmd))<EOL><DEDENT>sp = subprocess.Popen(<EOL>pig_cmd,<EOL>stdout=subprocess.PIPE,<EOL>stderr=subprocess.STDOUT,<EOL>cwd=tmp_dir,<EOL>close_fds=True)<EOL>self.sp = sp<EOL>stdout = '<STR_LIT>'<EOL>for line in iter(sp.stdout.readline, b'<STR_LIT>'):<EOL><INDENT>stdout += line.decode('<STR_LIT:utf-8>')<EOL>if verbose:<EOL><INDENT>self.log.info(line.strip())<EOL><DEDENT><DEDENT>sp.wait()<EOL>if sp.returncode:<EOL><INDENT>raise AirflowException(stdout)<EOL><DEDENT>return stdout<EOL><DEDENT><DEDENT>", "docstring": "Run an pig script using the pig cli\n\n>>> ph = PigCliHook()\n>>> result = ph.run_cli(\"ls /;\")\n>>> (\"hdfs://\" in result)\nTrue", "id": "f9508:c0:m1"}
{"signature": "def get_conn(self):", "body": "<EOL>effective_user = self.proxy_user<EOL>autoconfig = self.autoconfig<EOL>use_sasl = configuration.conf.get('<STR_LIT>', '<STR_LIT>') == '<STR_LIT>'<EOL>try:<EOL><INDENT>connections = self.get_connections(self.hdfs_conn_id)<EOL>if not effective_user:<EOL><INDENT>effective_user = connections[<NUM_LIT:0>].login<EOL><DEDENT>if not autoconfig:<EOL><INDENT>autoconfig = connections[<NUM_LIT:0>].extra_dejson.get('<STR_LIT>',<EOL>False)<EOL><DEDENT>hdfs_namenode_principal = connections[<NUM_LIT:0>].extra_dejson.get(<EOL>'<STR_LIT>')<EOL><DEDENT>except AirflowException:<EOL><INDENT>if not autoconfig:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>if autoconfig:<EOL><INDENT>client = AutoConfigClient(effective_user=effective_user,<EOL>use_sasl=use_sasl)<EOL><DEDENT>elif len(connections) == <NUM_LIT:1>:<EOL><INDENT>client = Client(connections[<NUM_LIT:0>].host, connections[<NUM_LIT:0>].port,<EOL>effective_user=effective_user, use_sasl=use_sasl,<EOL>hdfs_namenode_principal=hdfs_namenode_principal)<EOL><DEDENT>elif len(connections) > <NUM_LIT:1>:<EOL><INDENT>nn = [Namenode(conn.host, conn.port) for conn in connections]<EOL>client = HAClient(nn, effective_user=effective_user,<EOL>use_sasl=use_sasl,<EOL>hdfs_namenode_principal=hdfs_namenode_principal)<EOL><DEDENT>else:<EOL><INDENT>raise HDFSHookException(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>return client<EOL>", "docstring": "Returns a snakebite HDFSClient object.", "id": "f9515:c1:m1"}
{"signature": "def bulk_load(self, table, tmp_file):", "body": "self.copy_expert(\"<STR_LIT>\".format(table=table), tmp_file)<EOL>", "docstring": "Loads a tab-delimited file into a database table", "id": "f9517:c0:m3"}
{"signature": "@staticmethod<EOL><INDENT>def _serialize_cell(cell, conn):<DEDENT>", "body": "return cell<EOL>", "docstring": "Postgresql will adapt all arguments to the execute() method internally,\nhence we return cell without any conversion.\n\nSee http://initd.org/psycopg/docs/advanced.html#adapting-new-types for\nmore information.\n\n:param cell: The cell to insert into the table\n:type cell: object\n:param conn: The database connection\n:type conn: connection object\n:return: The cell\n:rtype: object", "id": "f9517:c0:m5"}
{"signature": "def bulk_dump(self, table, tmp_file):", "body": "self.copy_expert(\"<STR_LIT>\".format(table=table), tmp_file)<EOL>", "docstring": "Dumps a database table into a tab-delimited file", "id": "f9517:c0:m4"}
{"signature": "def __handle_rate_limit_exception(self, rate_limit_exception):", "body": "retry_after = int(<EOL>rate_limit_exception.response.headers.get('<STR_LIT>', <NUM_LIT>))<EOL>self.log.info(<EOL>\"<STR_LIT>\",<EOL>retry_after<EOL>)<EOL>time.sleep(retry_after)<EOL>", "docstring": "Sleep for the time specified in the exception. If not specified, wait\nfor 60 seconds.", "id": "f9519:c0:m2"}
{"signature": "def get_conn(self):", "body": "conn = self.get_connection(self.sqlite_conn_id)<EOL>conn = sqlite3.connect(conn.host)<EOL>return conn<EOL>", "docstring": "Returns a sqlite connection object", "id": "f9520:c0:m0"}
{"signature": "def get_metastore_client(self):", "body": "import hmsclient<EOL>from thrift.transport import TSocket, TTransport<EOL>from thrift.protocol import TBinaryProtocol<EOL>ms = self.metastore_conn<EOL>auth_mechanism = ms.extra_dejson.get('<STR_LIT>', '<STR_LIT>')<EOL>if configuration.conf.get('<STR_LIT>', '<STR_LIT>') == '<STR_LIT>':<EOL><INDENT>auth_mechanism = ms.extra_dejson.get('<STR_LIT>', '<STR_LIT>')<EOL>kerberos_service_name = ms.extra_dejson.get('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>socket = TSocket.TSocket(ms.host, ms.port)<EOL>if configuration.conf.get('<STR_LIT>', '<STR_LIT>') == '<STR_LIT>'and auth_mechanism == '<STR_LIT>':<EOL><INDENT>try:<EOL><INDENT>import saslwrapper as sasl<EOL><DEDENT>except ImportError:<EOL><INDENT>import sasl<EOL><DEDENT>def sasl_factory():<EOL><INDENT>sasl_client = sasl.Client()<EOL>sasl_client.setAttr(\"<STR_LIT:host>\", ms.host)<EOL>sasl_client.setAttr(\"<STR_LIT>\", kerberos_service_name)<EOL>sasl_client.init()<EOL>return sasl_client<EOL><DEDENT>from thrift_sasl import TSaslClientTransport<EOL>transport = TSaslClientTransport(sasl_factory, \"<STR_LIT>\", socket)<EOL><DEDENT>else:<EOL><INDENT>transport = TTransport.TBufferedTransport(socket)<EOL><DEDENT>protocol = TBinaryProtocol.TBinaryProtocol(transport)<EOL>return hmsclient.HMSClient(iprot=protocol)<EOL>", "docstring": "Returns a Hive thrift client.", "id": "f9521:c1:m3"}
{"signature": "def get_partitions(<EOL>self, schema, table_name, filter=None):", "body": "with self.metastore as client:<EOL><INDENT>table = client.get_table(dbname=schema, tbl_name=table_name)<EOL>if len(table.partitionKeys) == <NUM_LIT:0>:<EOL><INDENT>raise AirflowException(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>if filter:<EOL><INDENT>parts = client.get_partitions_by_filter(<EOL>db_name=schema, tbl_name=table_name,<EOL>filter=filter, max_parts=HiveMetastoreHook.MAX_PART_COUNT)<EOL><DEDENT>else:<EOL><INDENT>parts = client.get_partitions(<EOL>db_name=schema, tbl_name=table_name,<EOL>max_parts=HiveMetastoreHook.MAX_PART_COUNT)<EOL><DEDENT>pnames = [p.name for p in table.partitionKeys]<EOL>return [dict(zip(pnames, p.values)) for p in parts]<EOL><DEDENT><DEDENT>", "docstring": "Returns a list of all partitions in a table. Works only\nfor tables with less than 32767 (java short max val).\nFor subpartitioned table, the number might easily exceed this.\n\n>>> hh = HiveMetastoreHook()\n>>> t = 'static_babynames_partitioned'\n>>> parts = hh.get_partitions(schema='airflow', table_name=t)\n>>> len(parts)\n1\n>>> parts\n[{'ds': '2015-01-01'}]", "id": "f9521:c1:m10"}
{"signature": "def get_results(self, hql, schema='<STR_LIT:default>', fetch_size=None, hive_conf=None):", "body": "results_iter = self._get_results(hql, schema,<EOL>fetch_size=fetch_size, hive_conf=hive_conf)<EOL>header = next(results_iter)<EOL>results = {<EOL>'<STR_LIT:data>': list(results_iter),<EOL>'<STR_LIT>': header<EOL>}<EOL>return results<EOL>", "docstring": "Get results of the provided hql in target schema.\n\n:param hql: hql to be executed.\n:type hql: str or list\n:param schema: target schema, default to 'default'.\n:type schema: str\n:param fetch_size: max size of result to fetch.\n:type fetch_size: int\n:param hive_conf: hive_conf to execute alone with the hql.\n:type hive_conf: dict\n:return: results of hql execution, dict with data (list of results) and header\n:rtype: dict", "id": "f9521:c2:m3"}
{"signature": "def table_exists(self, table_name, db='<STR_LIT:default>'):", "body": "try:<EOL><INDENT>self.get_table(table_name, db)<EOL>return True<EOL><DEDENT>except Exception:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Check if table exists\n\n>>> hh = HiveMetastoreHook()\n>>> hh.table_exists(db='airflow', table_name='static_babynames')\nTrue\n>>> hh.table_exists(db='airflow', table_name='does_not_exist')\nFalse", "id": "f9521:c1:m13"}
{"signature": "def set_date_flag(self, date_flag=False):", "body": "self.date_flag = date_flag<EOL>", "docstring": "Set date flag", "id": "f9523:c0:m7"}
{"signature": "@cli_utils.action_logging<EOL>def dag_state(args):", "body": "dag = get_dag(args)<EOL>dr = DagRun.find(dag.dag_id, execution_date=args.execution_date)<EOL>print(dr[<NUM_LIT:0>].state if len(dr) > <NUM_LIT:0> else None)<EOL>", "docstring": "Returns the state of a DagRun at the command line.\n>>> airflow dag_state tutorial 2015-01-01T00:00:00.000000\nrunning", "id": "f9538:m23"}
{"signature": "def run_command(command):", "body": "process = subprocess.Popen(<EOL>shlex.split(command),<EOL>stdout=subprocess.PIPE,<EOL>stderr=subprocess.PIPE,<EOL>close_fds=True)<EOL>output, stderr = [stream.decode(sys.getdefaultencoding(), '<STR_LIT:ignore>')<EOL>for stream in process.communicate()]<EOL>if process.returncode != <NUM_LIT:0>:<EOL><INDENT>raise AirflowConfigException(<EOL>\"<STR_LIT>\"<EOL>.format(command, process.returncode, output, stderr)<EOL>)<EOL><DEDENT>return output<EOL>", "docstring": "Runs command and returns stdout", "id": "f9540:m2"}
{"signature": "def get_pools(self):", "body": "raise NotImplementedError()<EOL>", "docstring": "Get all pools.", "id": "f9541:c0:m4"}
{"signature": "def create_pool(self, name, slots, description):", "body": "raise NotImplementedError()<EOL>", "docstring": "Create a pool.\n\n        :param name: pool name\n        :param slots: pool slots amount\n        :param description: pool description", "id": "f9541:c0:m5"}
{"signature": "def get_dag_run_state(dag_id, execution_date):", "body": "dagbag = DagBag()<EOL>if dag_id not in dagbag.dags:<EOL><INDENT>error_message = \"<STR_LIT>\".format(dag_id)<EOL>raise DagNotFound(error_message)<EOL><DEDENT>dag = dagbag.get_dag(dag_id)<EOL>dagrun = dag.get_dagrun(execution_date=execution_date)<EOL>if not dagrun:<EOL><INDENT>error_message = ('<STR_LIT>'<EOL>.format(execution_date, dag_id))<EOL>raise DagRunNotFound(error_message)<EOL><DEDENT>return {'<STR_LIT:state>': dagrun.get_state()}<EOL>", "docstring": "Return the task object identified by the given dag_id and task_id.", "id": "f9547:m0"}
{"signature": "def push_by_returning(**kwargs):", "body": "return value_2<EOL>", "docstring": "Pushes an XCom without a specific target, just by returning it", "id": "f9563:m1"}
{"signature": "def ds_format(ds, input_format, output_format):", "body": "return datetime.strptime(ds, input_format).strftime(output_format)<EOL>", "docstring": "Takes an input string and outputs another string\nas specified in the output format\n\n:param ds: input string which contains a date\n:type ds: str\n:param input_format: input string format. E.g. %Y-%m-%d\n:type input_format: str\n:param output_format: output string format  E.g. %Y-%m-%d\n:type output_format: str\n\n>>> ds_format('2015-01-01', \"%Y-%m-%d\", \"%m-%d-%y\")\n'01-01-15'\n>>> ds_format('1/5/2015', \"%m/%d/%Y\",  \"%Y-%m-%d\")\n'2015-01-05'", "id": "f9577:m1"}
{"signature": "def closest_ds_partition(<EOL>table, ds, before=True, schema=\"<STR_LIT:default>\",<EOL>metastore_conn_id='<STR_LIT>'):", "body": "from airflow.hooks.hive_hooks import HiveMetastoreHook<EOL>if '<STR_LIT:.>' in table:<EOL><INDENT>schema, table = table.split('<STR_LIT:.>')<EOL><DEDENT>hh = HiveMetastoreHook(metastore_conn_id=metastore_conn_id)<EOL>partitions = hh.get_partitions(schema=schema, table_name=table)<EOL>if not partitions:<EOL><INDENT>return None<EOL><DEDENT>part_vals = [list(p.values())[<NUM_LIT:0>] for p in partitions]<EOL>if ds in part_vals:<EOL><INDENT>return ds<EOL><DEDENT>else:<EOL><INDENT>parts = [datetime.datetime.strptime(pv, '<STR_LIT>')<EOL>for pv in part_vals]<EOL>target_dt = datetime.datetime.strptime(ds, '<STR_LIT>')<EOL>closest_ds = _closest_date(target_dt, parts, before_target=before)<EOL>return closest_ds.isoformat()<EOL><DEDENT>", "docstring": "This function finds the date in a list closest to the target date.\nAn optional parameter can be given to get the closest before or after.\n\n:param table: A hive table name\n:type table: str\n:param ds: A datestamp ``%Y-%m-%d`` e.g. ``yyyy-mm-dd``\n:type ds: list[datetime.date]\n:param before: closest before (True), after (False) or either side of ds\n:type before: bool or None\n:returns: The closest date\n:rtype: str or None\n\n>>> tbl = 'airflow.static_babynames_partitioned'\n>>> closest_ds_partition(tbl, '2015-01-02')\n'2015-01-01'", "id": "f9578:m2"}
{"signature": "def prepare_classpath():", "body": "if DAGS_FOLDER not in sys.path:<EOL><INDENT>sys.path.append(DAGS_FOLDER)<EOL><DEDENT>config_path = os.path.join(AIRFLOW_HOME, '<STR_LIT>')<EOL>if config_path not in sys.path:<EOL><INDENT>sys.path.append(config_path)<EOL><DEDENT>if PLUGINS_FOLDER not in sys.path:<EOL><INDENT>sys.path.append(PLUGINS_FOLDER)<EOL><DEDENT>", "docstring": "Ensures that certain subfolders of AIRFLOW_HOME are on the classpath", "id": "f9579:m7"}
{"signature": "def get_default_executor():", "body": "global DEFAULT_EXECUTOR<EOL>if DEFAULT_EXECUTOR is not None:<EOL><INDENT>return DEFAULT_EXECUTOR<EOL><DEDENT>executor_name = configuration.conf.get('<STR_LIT>', '<STR_LIT>')<EOL>DEFAULT_EXECUTOR = _get_executor(executor_name)<EOL>log = LoggingMixin().log<EOL>log.info(\"<STR_LIT>\", executor_name)<EOL>return DEFAULT_EXECUTOR<EOL>", "docstring": "Creates a new instance of the configured executor if none exists and returns it", "id": "f9583:m1"}
{"signature": "def __init__(self, parallelism=PARALLELISM):", "body": "self.parallelism = parallelism<EOL>self.queued_tasks = OrderedDict()<EOL>self.running = {}<EOL>self.event_buffer = {}<EOL>", "docstring": "Class to derive in order to interface with executor-type systems\nlike Celery, Yarn and the likes.\n\n:param parallelism: how many jobs should run at one time. Set to\n    ``0`` for infinity\n:type parallelism: int", "id": "f9584:c0:m0"}
{"signature": "def has_task(self, task_instance):", "body": "if task_instance.key in self.queued_tasks or task_instance.key in self.running:<EOL><INDENT>return True<EOL><DEDENT>", "docstring": "Checks if a task is either queued or running in this executor\n\n:param task_instance: TaskInstance\n:return: True if the task is known to this executor", "id": "f9584:c0:m4"}
{"signature": "def _num_tasks_per_send_process(self, to_send_count):", "body": "return max(<NUM_LIT:1>,<EOL>int(math.ceil(<NUM_LIT:1.0> * to_send_count / self._sync_parallelism)))<EOL>", "docstring": "How many Celery tasks should each worker process send.\n\n:return: Number of tasks that should be sent per process\n:rtype: int", "id": "f9585:c1:m2"}
{"signature": "def poke(self, context):", "body": "raise AirflowException('<STR_LIT>')<EOL>", "docstring": "Function that the sensors defined while deriving this class should\noverride.", "id": "f9599:c0:m2"}
{"signature": "@property<EOL><INDENT>@abstractmethod<EOL>def concurrency(self):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": ":return: maximum number of tasks that can run simultaneously from this DAG\n:rtype: int", "id": "f9600:c0:m3"}
{"signature": "@property<EOL><INDENT>@abstractmethod<EOL>def task_ids(self):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": ":return: A list of task IDs that are in this DAG\n:rtype: List[unicode]", "id": "f9600:c0:m1"}
{"signature": "def construct_ingest_query(self, static_path, columns):", "body": "<EOL>num_shards = self.num_shards<EOL>target_partition_size = self.target_partition_size<EOL>if self.target_partition_size == -<NUM_LIT:1>:<EOL><INDENT>if self.num_shards == -<NUM_LIT:1>:<EOL><INDENT>target_partition_size = DEFAULT_TARGET_PARTITION_SIZE<EOL><DEDENT><DEDENT>else:<EOL><INDENT>num_shards = -<NUM_LIT:1><EOL><DEDENT>metric_names = [m['<STR_LIT>'] for m in self.metric_spec if m['<STR_LIT:type>'] != '<STR_LIT:count>']<EOL>dimensions = [c for c in columns if c not in metric_names and c != self.ts_dim]<EOL>ingest_query_dict = {<EOL>\"<STR_LIT:type>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": self.metric_spec,<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": self.query_granularity,<EOL>\"<STR_LIT>\": self.intervals,<EOL>\"<STR_LIT:type>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": self.segment_granularity,<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT:type>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": columns,<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": [],<EOL>\"<STR_LIT>\": dimensions,  <EOL>\"<STR_LIT>\": []<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": self.ts_dim,<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>}<EOL>},<EOL>\"<STR_LIT>\": self.druid_datasource<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT:type>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT:false>\",<EOL>\"<STR_LIT>\": \"<STR_LIT:false>\",<EOL>\"<STR_LIT>\": \"<STR_LIT:false>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT:type>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": target_partition_size,<EOL>\"<STR_LIT>\": num_shards,<EOL>},<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": static_path,<EOL>\"<STR_LIT:type>\": \"<STR_LIT>\"<EOL>},<EOL>\"<STR_LIT:type>\": \"<STR_LIT>\"<EOL>}<EOL>}<EOL>}<EOL>if self.job_properties:<EOL><INDENT>ingest_query_dict['<STR_LIT>']['<STR_LIT>']['<STR_LIT>'].update(self.job_properties)<EOL><DEDENT>if self.hadoop_dependency_coordinates:<EOL><INDENT>ingest_query_dict['<STR_LIT>']= self.hadoop_dependency_coordinates<EOL><DEDENT>return ingest_query_dict<EOL>", "docstring": "Builds an ingest query for an HDFS TSV load.\n\n:param static_path: The path on hdfs where the data is\n:type static_path: str\n:param columns: List of all the columns that are available\n:type columns: list", "id": "f9601:c0:m2"}
{"signature": "def _convert_to_float_if_possible(s):", "body": "try:<EOL><INDENT>ret = float(s)<EOL><DEDENT>except (ValueError, TypeError):<EOL><INDENT>ret = s<EOL><DEDENT>return ret<EOL>", "docstring": "A small helper function to convert a string to a numeric value\nif appropriate\n\n:param s: the string to be converted\n:type s: str", "id": "f9606:m0"}
{"signature": "def get_db_hook(self):", "body": "return DruidDbApiHook(druid_broker_conn_id=self.druid_broker_conn_id)<EOL>", "docstring": "Return the druid db api hook.", "id": "f9619:c0:m1"}
{"signature": "def template_field_role(app, typ, rawtext, text, lineno, inliner, options={}, content=[]):", "body": "text = utils.unescape(text)<EOL>try:<EOL><INDENT>template_fields = get_template_field(app.env, text)<EOL><DEDENT>except RoleException as e:<EOL><INDENT>msg = inliner.reporter.error(\"<STR_LIT>\" % (text, e, ), line=lineno)<EOL>prb = inliner.problematic(rawtext, rawtext, msg)<EOL>return [prb], [msg]<EOL><DEDENT>node = nodes.inline(rawtext=rawtext)<EOL>for i, field in enumerate(template_fields):<EOL><INDENT>if i != <NUM_LIT:0>:<EOL><INDENT>node += nodes.Text(\"<STR_LIT:U+002CU+0020>\")<EOL><DEDENT>node += nodes.literal(field, \"<STR_LIT>\", nodes.Text(field))<EOL><DEDENT>return [node], []<EOL>", "docstring": "A role that allows you to include a list of template fields in the middle of the text. This is especially\nuseful when writing guides describing how to use the operator.\nThe result is a list of fields where each field is shorted in the literal block.\n\nSample usage::\n\n:template-fields:`airflow.contrib.operators.gcp_natural_language_operator.CloudLanguageAnalyzeSentimentOperator`\n\nFor further information look at:\n\n* [http://docutils.sourceforge.net/docs/howto/rst-roles.html](Creating reStructuredText Interpreted\n  Text Roles)", "id": "f9637:m1"}
{"signature": "def tube_hires(script, height=<NUM_LIT:1.0>, radius=None, radius1=None, radius2=None,<EOL>diameter=None, diameter1=None, diameter2=None, cir_segments=<NUM_LIT:32>,<EOL>rad_segments=<NUM_LIT:1>, height_segments=<NUM_LIT:1>, center=False,<EOL>simple_bottom=False, color=None):", "body": "<EOL>if radius is not None and diameter is None:<EOL><INDENT>if radius1 is None and diameter1 is None:<EOL><INDENT>radius1 = radius<EOL><DEDENT>if radius2 is None and diameter2 is None:<EOL><INDENT>radius2 = <NUM_LIT:0><EOL><DEDENT><DEDENT>if diameter is not None:<EOL><INDENT>if radius1 is None and diameter1 is None:<EOL><INDENT>radius1 = diameter / <NUM_LIT:2><EOL><DEDENT>if radius2 is None and diameter2 is None:<EOL><INDENT>radius2 = <NUM_LIT:0><EOL><DEDENT><DEDENT>if diameter1 is not None:<EOL><INDENT>radius1 = diameter1 / <NUM_LIT:2><EOL><DEDENT>if diameter2 is not None:<EOL><INDENT>radius2 = diameter2 / <NUM_LIT:2><EOL><DEDENT>if radius1 is None:<EOL><INDENT>radius1 = <NUM_LIT:1><EOL><DEDENT>if radius2 is None:<EOL><INDENT>radius2 = <NUM_LIT:0><EOL><DEDENT>annulus_hires(script,<EOL>radius1=radius1,<EOL>radius2=radius2,<EOL>cir_segments=cir_segments,<EOL>rad_segments=rad_segments)<EOL>transform.translate(script, [<NUM_LIT:0>, <NUM_LIT:0>, height])<EOL>if simple_bottom:<EOL><INDENT>annulus(script,<EOL>radius1=radius1,<EOL>radius2=radius2,<EOL>cir_segments=cir_segments)<EOL><DEDENT>else:<EOL><INDENT>layers.duplicate(script)<EOL>transform.translate(script, [<NUM_LIT:0>, <NUM_LIT:0>, -height])<EOL><DEDENT>transform.rotate(script, '<STR_LIT:x>', <NUM_LIT>)<EOL>cylinder_open_hires(script, height, radius1,<EOL>cir_segments=cir_segments,<EOL>height_segments=height_segments)<EOL>if radius2 != <NUM_LIT:0>:<EOL><INDENT>cylinder_open_hires(script, height, radius2,<EOL>cir_segments=cir_segments,<EOL>height_segments=height_segments,<EOL>invert_normals=True)<EOL><DEDENT>layers.join(script)<EOL>clean.merge_vert(script, threshold=<NUM_LIT>)<EOL>if center:<EOL><INDENT>transform.translate(script, [<NUM_LIT:0>, <NUM_LIT:0>, -height / <NUM_LIT:2>])<EOL><DEDENT>if color is not None:<EOL><INDENT>vert_color.function(script, color=color)<EOL><DEDENT>return None<EOL>", "docstring": "Create a cylinder with user defined number of segments", "id": "f9642:m14"}
{"signature": "def torus(script, major_radius=<NUM_LIT>, minor_radius=<NUM_LIT:1.0>, inner_diameter=None,<EOL>outer_diameter=None, major_segments=<NUM_LIT>, minor_segments=<NUM_LIT:12>,<EOL>color=None):", "body": "if inner_diameter is not None and outer_diameter is not None:<EOL><INDENT>major_radius = (inner_diameter + outer_diameter) / <NUM_LIT:4><EOL>minor_radius = major_radius - inner_diameter / <NUM_LIT:2><EOL><DEDENT>filter_xml = '<STR_LIT>'.join([<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % major_radius,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % minor_radius,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % major_segments,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % minor_segments,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'])<EOL>util.write_filter(script, filter_xml)<EOL>if isinstance(script, FilterScript):<EOL><INDENT>script.add_layer('<STR_LIT>', change_layer=True)<EOL><DEDENT>if color is not None:<EOL><INDENT>vert_color.function(script, color=color)<EOL><DEDENT>return None<EOL>", "docstring": "Create a torus mesh\n\n    Args:\n        major_radius (float, (optional)): radius from the origin to the\n            center of the cross sections\n        minor_radius (float, (optional)): radius of the torus cross\n            section\n        inner_diameter (float, (optional)): inner diameter of torus. If\n            both inner_diameter and outer_diameter are provided then\n            these will override major_radius and minor_radius.,\n        outer_diameter (float, (optional)): outer diameter of torus. If\n            both inner_diameter and outer_diameter are provided then\n            these will override major_radius and minor_radius.\n        major_segments (int (optional)): number of segments for the main\n            ring of the torus\n        minor_segments (int (optional)): number of segments for the minor\n            ring of the torus\n        color (str (optional)): color name to apply vertex colors to the\n            newly created mesh\n\n    Returns:\n        None", "id": "f9642:m4"}
{"signature": "def cube_open_hires_old(script, size=<NUM_LIT:1.0>, x_segments=<NUM_LIT:1>, y_segments=<NUM_LIT:1>, z_segments=<NUM_LIT:1>,<EOL>center=False, color=None):", "body": "\"\"\"<STR_LIT>\"\"\"<EOL>size = util.make_list(size, <NUM_LIT:3>)<EOL>grid(script, [size[<NUM_LIT:0>], size[<NUM_LIT:2>]],<EOL>x_segments=x_segments,<EOL>y_segments=z_segments)<EOL>transform.rotate(script, '<STR_LIT:x>', <NUM_LIT>)<EOL>layers.duplicate(script)<EOL>transform.rotate(script, '<STR_LIT:z>', <NUM_LIT>)<EOL>transform.translate(script, [size[<NUM_LIT:0>], size[<NUM_LIT:1>], <NUM_LIT:0>])<EOL>grid(script, [size[<NUM_LIT:2>], size[<NUM_LIT:1>]],<EOL>x_segments=z_segments,<EOL>y_segments=y_segments)<EOL>transform.rotate(script, '<STR_LIT:y>', -<NUM_LIT>)<EOL>layers.duplicate(script)<EOL>transform.rotate(script, '<STR_LIT:z>', <NUM_LIT>)<EOL>transform.translate(script, [size[<NUM_LIT:0>], size[<NUM_LIT:1>], <NUM_LIT:0>])<EOL>layers.join(script)<EOL>clean.merge_vert(script, threshold=<NUM_LIT>)<EOL>if center:<EOL><INDENT>transform.translate(script, [-size[<NUM_LIT:0>] / <NUM_LIT:2>, -size[<NUM_LIT:1>] / <NUM_LIT:2>, -size[<NUM_LIT:2>] / <NUM_LIT:2>])<EOL><DEDENT>if color is not None:<EOL><INDENT>vert_color.function(script, color=color)<EOL><DEDENT>return None<EOL>", "docstring": "Creates a square open tube, e.g. a box with no top or bottom.\n\n    Useful if you want to wrap it around and join the open ends together, forming a torus.", "id": "f9642:m8"}
{"signature": "def cube(script, size=<NUM_LIT:1.0>, center=False, color=None):", "body": "\"\"\"<STR_LIT>\"\"\"<EOL>size = util.make_list(size, <NUM_LIT:3>)<EOL>if script.ml_version == '<STR_LIT>':<EOL><INDENT>filter_name = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>filter_name = '<STR_LIT>'<EOL><DEDENT>filter_xml = '<STR_LIT>'.join([<EOL>'<STR_LIT>'.format(filter_name),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'])<EOL>util.write_filter(script, filter_xml)<EOL>if isinstance(script, FilterScript):<EOL><INDENT>script.add_layer('<STR_LIT>', change_layer=True)<EOL><DEDENT>transform.scale(script, value=size)<EOL>if not center:<EOL><INDENT>transform.translate(script, value=[size[<NUM_LIT:0>]/<NUM_LIT:2>, size[<NUM_LIT:1>]/<NUM_LIT:2>, size[<NUM_LIT:2>]/<NUM_LIT:2>])<EOL><DEDENT>if color is not None:<EOL><INDENT>vert_color.function(script, color=color)<EOL><DEDENT>return None<EOL>", "docstring": "Create a cube primitive\n\n    Note that this is made of 6 quads, not triangles", "id": "f9642:m0"}
{"signature": "def dna(sequence='<STR_LIT>'):", "body": "pass<EOL>", "docstring": "Create  doublehelix function, takes spacing between helixes and\n    rungs, rung diameter", "id": "f9642:m16"}
{"signature": "def annulus(script, radius=None, radius1=None, radius2=None, diameter=None,<EOL>diameter1=None, diameter2=None, cir_segments=<NUM_LIT:32>, color=None):", "body": "if radius is not None and diameter is None:<EOL><INDENT>if radius1 is None and diameter1 is None:<EOL><INDENT>radius1 = radius<EOL><DEDENT>if radius2 is None and diameter2 is None:<EOL><INDENT>radius2 = <NUM_LIT:0><EOL><DEDENT><DEDENT>if diameter is not None:<EOL><INDENT>if radius1 is None and diameter1 is None:<EOL><INDENT>radius1 = diameter / <NUM_LIT:2><EOL><DEDENT>if radius2 is None and diameter2 is None:<EOL><INDENT>radius2 = <NUM_LIT:0><EOL><DEDENT><DEDENT>if diameter1 is not None:<EOL><INDENT>radius1 = diameter1 / <NUM_LIT:2><EOL><DEDENT>if diameter2 is not None:<EOL><INDENT>radius2 = diameter2 / <NUM_LIT:2><EOL><DEDENT>if radius1 is None:<EOL><INDENT>radius1 = <NUM_LIT:1><EOL><DEDENT>if radius2 is None:<EOL><INDENT>radius2 = <NUM_LIT:0><EOL><DEDENT>filter_xml = '<STR_LIT>'.join([<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % radius1,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % radius2,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % cir_segments,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'])<EOL>util.write_filter(script, filter_xml)<EOL>if isinstance(script, FilterScript):<EOL><INDENT>script.add_layer('<STR_LIT>', change_layer=True)<EOL><DEDENT>if color is not None:<EOL><INDENT>vert_color.function(script, color=color)<EOL><DEDENT>return None<EOL>", "docstring": "Create a 2D (surface) circle or annulus\n    radius1=1 # Outer radius of the circle\n    radius2=0 # Inner radius of the circle (if non-zero it creates an annulus)\n    color=\"\" # specify a color name to apply vertex colors to the newly created mesh\n\n    OpenSCAD: parameters: diameter overrides radius, radius1 & radius2 override radius", "id": "f9642:m6"}
{"signature": "def grid(script, size=<NUM_LIT:1.0>, x_segments=<NUM_LIT:1>, y_segments=<NUM_LIT:1>, center=False,<EOL>color=None):", "body": "size = util.make_list(size, <NUM_LIT:2>)<EOL>filter_xml = '<STR_LIT>'.join([<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(size[<NUM_LIT:0>]),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(size[<NUM_LIT:1>]),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(x_segments + <NUM_LIT:1>),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(y_segments + <NUM_LIT:1>),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'])<EOL>util.write_filter(script, filter_xml)<EOL>if isinstance(script, FilterScript):<EOL><INDENT>script.add_layer('<STR_LIT>', change_layer=True)<EOL><DEDENT>\"\"\"<STR_LIT>\"\"\"<EOL>transform.vert_function(script, z_func='<STR_LIT>')<EOL>\"\"\"<STR_LIT>\"\"\"<EOL>if center:<EOL><INDENT>transform.translate(script, value=[size[<NUM_LIT:0>]/<NUM_LIT:2>, -size[<NUM_LIT:1>]/<NUM_LIT:2>, <NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>transform.translate(script, value=[size[<NUM_LIT:0>], <NUM_LIT:0>, <NUM_LIT:0>])<EOL><DEDENT>if color is not None:<EOL><INDENT>vert_color.function(script, color=color)<EOL><DEDENT>return None<EOL>", "docstring": "2D square/plane/grid created on XY plane\n\n    x_segments # Number of segments in the X direction.\n    y_segments # Number of segments in the Y direction.\n    center=\"false\" # If true square will be centered on origin;\n    otherwise it is place in the positive XY quadrant.", "id": "f9642:m5"}
{"signature": "def flip(script, force_flip=False, selected=False):", "body": "filter_xml = '<STR_LIT>'.join([<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(force_flip).lower()),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(selected).lower()),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'])<EOL>util.write_filter(script, filter_xml)<EOL>return None<EOL>", "docstring": "Invert faces orientation, flipping the normals of the mesh.\n\n    If requested, it tries to guess the right orientation; mainly it decides to\n    flip all the faces if the minimum/maximum vertexes have not outward point\n    normals for a few directions. Works well for single component watertight\n    objects.\n\n    Args:\n        script: the FilterScript object or script filename to write\n            the filter to.\n        force_flip (bool): If selected, the normals will always be flipped;\n            otherwise, the filter tries to set them outside.\n        selected (bool): If selected, only selected faces will be affected.\n\n    Layer stack:\n        No impacts\n\n    MeshLab versions:\n        2016.12\n        1.3.4BETA", "id": "f9644:m1"}
{"signature": "def fix(script):", "body": "reorient(script)<EOL>flip(script)<EOL>return<EOL>", "docstring": "Will reorient normals & ensure they are oriented outwards\n\n    Layer stack:\n        No impacts\n\n    MeshLab versions:\n        2016.12\n        1.3.4BETA", "id": "f9644:m2"}
{"signature": "def function(script, red=<NUM_LIT:255>, green=<NUM_LIT:255>, blue=<NUM_LIT:255>, alpha=<NUM_LIT:255>, color=None):", "body": "<EOL>if color is not None:<EOL><INDENT>red, green, blue, _ = color_name[color.lower()]<EOL><DEDENT>filter_xml = '<STR_LIT>'.join([<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(red).replace('<STR_LIT:&>', '<STR_LIT>').replace('<STR_LIT:<>', '<STR_LIT>')),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(green).replace('<STR_LIT:&>', '<STR_LIT>').replace('<STR_LIT:<>', '<STR_LIT>')),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(blue).replace('<STR_LIT:&>', '<STR_LIT>').replace('<STR_LIT:<>', '<STR_LIT>')),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(alpha).replace('<STR_LIT:&>', '<STR_LIT>').replace('<STR_LIT:<>', '<STR_LIT>')),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'])<EOL>util.write_filter(script, filter_xml)<EOL>return None<EOL>", "docstring": "Color function using muparser lib to generate new RGBA color for every\n        vertex\n\n    Red, Green, Blue and Alpha channels may be defined by specifying a function\n    for each.\n\n    See help(mlx.muparser_ref) for muparser reference documentation.\n\n    It's possible to use the following per-vertex variables in the expression:\n\n    Variables (per vertex):\n        x, y, z (coordinates)\n        nx, ny, nz (normal)\n        r, g, b, a (color)\n        q (quality)\n        rad (radius)\n        vi (vertex index)\n        vtu, vtv (texture coordinates)\n        ti (texture index)\n        vsel (is the vertex selected? 1 yes, 0 no)\n        and all custom vertex attributes already defined by user.\n\n    Args:\n        script: the FilterScript object or script filename to write\n            the filter to.\n        red (str [0, 255]): function to generate red component\n        green (str [0, 255]): function to generate green component\n        blue (str [0, 255]): function to generate blue component\n        alpha (str [0, 255]): function to generate alpha component\n        color (str): name of one of the 140 HTML Color Names defined\n            in CSS & SVG.\n            Ref: https://en.wikipedia.org/wiki/Web_colors#X11_color_names\n            If not None this will override the per component variables.\n\n    Layer stack:\n        No impacts\n\n    MeshLab versions:\n        2016.12\n        1.3.4BETA", "id": "f9645:m0"}
{"signature": "def split_vert_on_nonmanifold_face(script, vert_displacement_ratio=<NUM_LIT:0.0>):", "body": "filter_xml = '<STR_LIT>'.join([<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(vert_displacement_ratio),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'])<EOL>util.write_filter(script, filter_xml)<EOL>return None<EOL>", "docstring": "Split non-manifold vertices until it becomes two-manifold.\n\n    Args:\n        script: the FilterScript object or script filename to write\n            the filter to.\n        vert_displacement_ratio (float): When a vertex is split it is moved\n            along the average vector going from its position to the centroid\n            of the FF connected faces sharing it.\n\n    Layer stack:\n        No impacts\n\n    MeshLab versions:\n        2016.12\n        1.3.4BETA", "id": "f9646:m2"}
{"signature": "def close_holes(script, hole_max_edge=<NUM_LIT:30>, selected=False,<EOL>sel_new_face=True, self_intersection=True):", "body": "filter_xml = '<STR_LIT>'.join([<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(hole_max_edge),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(selected).lower()),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(sel_new_face).lower()),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(self_intersection).lower()),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'])<EOL>util.write_filter(script, filter_xml)<EOL>return None<EOL>", "docstring": "Close holes smaller than a given threshold\n\n    Args:\n        script: the FilterScript object or script filename to write\n            the filter to.\n        hole_max_edge (int): The size is expressed as number of edges composing\n            the hole boundary.\n        selected (bool): Only the holes with at least one of the boundary faces\n            selected are closed.\n        sel_new_face (bool): After closing a hole the faces that have been\n            created are left selected. Any previous selection is lost. Useful\n            for example for smoothing or subdividing the newly created holes.\n        self_intersection (bool): When closing an holes it tries to prevent the\n            creation of faces that intersect faces adjacent to the boundary of\n            the hole. It is an heuristic, non intersecting hole filling can be\n            NP-complete.\n\n    Layer stack:\n        No impacts\n\n    MeshLab versions:\n        2016.12\n        1.3.4BETA", "id": "f9646:m1"}
{"signature": "def tex2vc_2_meshes(script, source_mesh=<NUM_LIT:0>, target_mesh=<NUM_LIT:1>, max_distance=<NUM_LIT:0.5>):", "body": "if script.ml_version == '<STR_LIT>':<EOL><INDENT>filter_name = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>filter_name = '<STR_LIT>'<EOL><DEDENT>filter_xml = '<STR_LIT>'.join([<EOL>'<STR_LIT>'.format(filter_name),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % source_mesh,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % target_mesh,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % max_distance,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'])<EOL>util.write_filter(script, filter_xml)<EOL>return None<EOL>", "docstring": "Transfer texture colors to vertex colors (between 2 meshes)\n\n    Args:\n        script: the FilterScript object or script filename to write\n            the filter to.\n        source_mesh (int): The mesh with associated texture that we want to sample from\n        target_mesh (int): The mesh whose vertex color will be filled according to source mesh texture\n        max_distance (float): Sample points for which we do not find anything within this distance are rejected and not considered for recovering color\n\n    Layer stack:\n        No impacts\n\n    MeshLab versions:\n        2016.12\n        1.3.4BETA", "id": "f9647:m7"}
{"signature": "def vc2fc(script):", "body": "filter_xml = '<STR_LIT>'<EOL>util.write_filter(script, filter_xml)<EOL>return None<EOL>", "docstring": "Transfer vertex colors to face colors\n\n    Args:\n        script: the FilterScript object or script filename to write\n            the filter to.", "id": "f9647:m3"}
{"signature": "def fc2vc(script):", "body": "filter_xml = '<STR_LIT>'<EOL>util.write_filter(script, filter_xml)<EOL>return None<EOL>", "docstring": "Transfer face colors to vertex colors\n\n    Args:\n        script: the FilterScript object or script filename to write\n            the filter to.", "id": "f9647:m2"}
{"signature": "def vert_attr2tex_2_meshes(script, source_mesh=<NUM_LIT:0>, target_mesh=<NUM_LIT:1>, attribute=<NUM_LIT:0>,<EOL>max_distance=<NUM_LIT:0.5>, tex_name='<STR_LIT>',<EOL>tex_width=<NUM_LIT>, tex_height=<NUM_LIT>,<EOL>overwrite_tex=True, assign_tex=False,<EOL>fill_tex=True):", "body": "if script.ml_version == '<STR_LIT>':<EOL><INDENT>filter_name = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>filter_name = '<STR_LIT>'<EOL><DEDENT>filter_xml = '<STR_LIT>'.join([<EOL>'<STR_LIT>'.format(filter_name),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % source_mesh,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % target_mesh,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % attribute,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % max_distance,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % tex_name,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % tex_width,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % tex_height,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % str(overwrite_tex).lower(),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % str(assign_tex).lower(),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % str(fill_tex).lower(),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'])<EOL>util.write_filter(script, filter_xml)<EOL>return None<EOL>", "docstring": "Transfer Vertex Attributes to Texture (between 2 meshes)\n\n    Args:\n        script: the FilterScript object or script filename to write\n            the filter to.\n        source_mesh (int): The mesh that contains the source data that we want to transfer\n        target_mesh (int): The mesh whose texture will be filled according to source mesh data\n        attribute (int): Choose what attribute has to be transferred onto the target texture. You can choose between Per vertex attributes (color, normal, quality) or to transfer color information from source mesh texture\n        max_distance (float): Sample points for which we do not find anything within this distance are rejected and not considered for recovering data\n        tex_name (str): The texture file to be created\n        tex_width (int): The texture width\n        tex_height (int): The texture height\n        overwrite_tex (bool): If target mesh has a texture will be overwritten (with provided texture dimension)\n        assign_tex (bool): Assign the newly created texture to target mesh\n        fill_tex (bool): If enabled the unmapped texture space is colored using a pull push filling algorithm, if false is set to black\n\n    Layer stack:\n        No impacts\n\n    MeshLab versions:\n        2016.12\n        1.3.4BETA", "id": "f9647:m6"}
{"signature": "def measure_section(fbasename=None, log=None, axis='<STR_LIT:z>', offset=<NUM_LIT:0.0>,<EOL>rotate_x_angle=None, ml_version=ml_version):", "body": "ml_script1_file = '<STR_LIT>'<EOL>file_out = '<STR_LIT>'<EOL>ml_script1 = mlx.FilterScript(file_in=fbasename, file_out=file_out, ml_version=ml_version)<EOL>if rotate_x_angle is not None:<EOL><INDENT>transform.rotate(ml_script1, axis='<STR_LIT:x>', angle=rotate_x_angle)<EOL><DEDENT>compute.section(ml_script1, axis=axis, offset=offset)<EOL>layers.delete_lower(ml_script1)<EOL>ml_script1.save_to_file(ml_script1_file)<EOL>ml_script1.run_script(log=log, script_file=ml_script1_file)<EOL>aabb = measure_aabb(file_out, log)<EOL>return aabb<EOL>", "docstring": "Measure a cross section of a mesh\n\n    Perform a plane cut in one of the major axes (X, Y, Z). If you want to cut on\n    a different plane you will need to rotate the model in place, perform the cut,\n    and rotate it back.\n\n    Args:\n        fbasename (str): filename of input model\n        log (str): filename of log file\n        axis (str): axis perpendicular to the cutting plane, e.g. specify \"z\" to cut\n            parallel to the XY plane.\n        offset (float): amount to offset the cutting plane from the origin\n        rotate_x_angle (float): degrees to rotate about the X axis. Useful for correcting \"Up\" direction: 90 to rotate Y to Z, and -90 to rotate Z to Y. \n\n    Returns:\n        dict: dictionary with the following keys for the aabb of the section:\n            min (list): list of the x, y & z minimum values\n            max (list): list of the x, y & z maximum values\n            center (list): the x, y & z coordinates of the center of the aabb\n            size (list): list of the x, y & z sizes (max - min)\n            diagonal (float): the diagonal of the aabb", "id": "f9648:m1"}
{"signature": "def polylinesort(fbasename=None, log=None):", "body": "fext = os.path.splitext(fbasename)[<NUM_LIT:1>][<NUM_LIT:1>:].strip().lower()<EOL>if fext != '<STR_LIT>':<EOL><INDENT>print('<STR_LIT>')<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>fread = open(fbasename, '<STR_LIT:r>')<EOL>first = True<EOL>polyline_vertices = []<EOL>line_segments = []<EOL>for line in fread:<EOL><INDENT>element, x_co, y_co, z_co = line.split()<EOL>if element == '<STR_LIT:v>':<EOL><INDENT>polyline_vertices.append(<EOL>[util.to_float(x_co), util.to_float(y_co), util.to_float(z_co)])<EOL><DEDENT>elif element == '<STR_LIT:l>':<EOL><INDENT>p1 = x_co<EOL>p2 = y_co<EOL>line_segments.append([int(p1), int(p2)])<EOL><DEDENT><DEDENT>fread.close()<EOL>if log is not None:<EOL><INDENT>log_file = open(log, '<STR_LIT:a>')<EOL>\"\"\"<STR_LIT>\"\"\"<EOL>log_file.close()<EOL><DEDENT>return None<EOL>", "docstring": "Sort separate line segments in obj format into a continuous polyline or polylines.\n    NOT FINISHED; DO NOT USE\n\n    Also measures the length of each polyline\n\n    Return polyline and polylineMeta (lengths)", "id": "f9648:m2"}
{"signature": "def measure_dimension(fbasename=None, log=None, axis1=None, offset1=<NUM_LIT:0.0>,<EOL>axis2=None, offset2=<NUM_LIT:0.0>, ml_version=ml_version):", "body": "axis1 = axis1.lower()<EOL>axis2 = axis2.lower()<EOL>ml_script1_file = '<STR_LIT>'<EOL>file_out = '<STR_LIT>'<EOL>ml_script1 = mlx.FilterScript(file_in=fbasename, file_out=file_out, ml_version=ml_version)<EOL>compute.section(ml_script1, axis1, offset1, surface=True)<EOL>compute.section(ml_script1, axis2, offset2, surface=False)<EOL>layers.delete_lower(ml_script1)<EOL>ml_script1.save_to_file(ml_script1_file)<EOL>ml_script1.run_script(log=log, script_file=ml_script1_file)<EOL>for val in ('<STR_LIT:x>', '<STR_LIT:y>', '<STR_LIT:z>'):<EOL><INDENT>if val not in (axis1, axis2):<EOL><INDENT>axis = val<EOL><DEDENT><DEDENT>axis_num = ord(axis) - ord('<STR_LIT:x>')<EOL>aabb = measure_aabb(file_out, log)<EOL>dimension = {'<STR_LIT>': aabb['<STR_LIT>'][axis_num], '<STR_LIT>': aabb['<STR_LIT>'][axis_num],<EOL>'<STR_LIT>': aabb['<STR_LIT:size>'][axis_num], '<STR_LIT>': axis}<EOL>if log is None:<EOL><INDENT>print('<STR_LIT>' % fbasename)<EOL>print('<STR_LIT>' % (axis, axis1, offset1,<EOL>axis2, offset2))<EOL>print('<STR_LIT>' % (dimension['<STR_LIT>'],<EOL>dimension['<STR_LIT>'], dimension['<STR_LIT>']))<EOL><DEDENT>else:<EOL><INDENT>log_file = open(log, '<STR_LIT:a>')<EOL>log_file.write('<STR_LIT>' % fbasename)<EOL>log_file.write('<STR_LIT>' % (axis, axis1, offset1,<EOL>axis2, offset2))<EOL>log_file.write('<STR_LIT>' % dimension['<STR_LIT>'])<EOL>log_file.write('<STR_LIT>' % dimension['<STR_LIT>'])<EOL>log_file.write('<STR_LIT>' % dimension['<STR_LIT>'])<EOL>log_file.close()<EOL><DEDENT>return dimension<EOL>", "docstring": "Measure a dimension of a mesh", "id": "f9648:m6"}
{"signature": "def scale(script, value=<NUM_LIT:1.0>):", "body": "\"\"\"<STR_LIT>\"\"\"<EOL>value = util.make_list(value, <NUM_LIT:3>)<EOL>vert_function(script,<EOL>x_func='<STR_LIT>' % value[<NUM_LIT:0>],<EOL>y_func='<STR_LIT>' % value[<NUM_LIT:1>],<EOL>z_func='<STR_LIT>' % value[<NUM_LIT:2>])<EOL>return None<EOL>", "docstring": "An alternative scale implementation that uses a geometric function.\n    This is more accurate than the built-in version.", "id": "f9649:m5"}
{"signature": "def deform2curve(script, curve=mp_func.torus_knot('<STR_LIT:t>'), step=<NUM_LIT>):", "body": "curve_step = []<EOL>for idx, val in enumerate(curve):<EOL><INDENT>curve[idx] = val.replace('<STR_LIT:t>', '<STR_LIT:z>')<EOL>curve_step.append(val.replace('<STR_LIT:t>', '<STR_LIT>'.format(step)))<EOL><DEDENT>tangent = mp_func.v_subtract(curve_step, curve)<EOL>normal1 = mp_func.v_add(curve_step, curve)<EOL>bee = mp_func.v_cross(tangent, normal1)<EOL>normal = mp_func.v_cross(bee, tangent)<EOL>bee = mp_func.v_normalize(bee)<EOL>normal = mp_func.v_normalize(normal)<EOL>new_point = mp_func.v_add(mp_func.v_multiply('<STR_LIT:x>', normal), mp_func.v_multiply('<STR_LIT:y>', bee))<EOL>function = mp_func.v_add(curve, new_point)<EOL>vert_function(script, x_func=function[<NUM_LIT:0>], y_func=function[<NUM_LIT:1>], z_func=function[<NUM_LIT:2>])<EOL>return function<EOL>", "docstring": "Deform a mesh along a parametric curve function\n\n    Provide a parametric curve function with z as the parameter. This will\n    deform the xy cross section of the mesh along the curve as z increases.\n\n    Source: http://blackpawn.com/texts/pqtorus/\n\n    Methodology:\n    T  = P' - P\n    N1 = P' + P\n    B  = T x N1\n    N  = B x T\n\n    newPoint = point.x*N + point.y*B", "id": "f9649:m17"}
{"signature": "def vert_function(script, x_func='<STR_LIT:x>', y_func='<STR_LIT:y>', z_func='<STR_LIT:z>', selected=False):", "body": "if script.ml_version == '<STR_LIT>':<EOL><INDENT>filter_xml = '<STR_LIT>'.join([<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(x_func).replace('<STR_LIT:&>', '<STR_LIT>').replace('<STR_LIT:<>', '<STR_LIT>')),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(y_func).replace('<STR_LIT:&>', '<STR_LIT>').replace('<STR_LIT:<>', '<STR_LIT>')),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(z_func).replace('<STR_LIT:&>', '<STR_LIT>').replace('<STR_LIT:<>', '<STR_LIT>')),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>filter_xml = '<STR_LIT>'.join([<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(x_func).replace('<STR_LIT:&>', '<STR_LIT>').replace('<STR_LIT:<>', '<STR_LIT>')),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(y_func).replace('<STR_LIT:&>', '<STR_LIT>').replace('<STR_LIT:<>', '<STR_LIT>')),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(z_func).replace('<STR_LIT:&>', '<STR_LIT>').replace('<STR_LIT:<>', '<STR_LIT>')),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % str(selected).lower(),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'])<EOL><DEDENT>util.write_filter(script, filter_xml)<EOL>return None<EOL>", "docstring": "Geometric function using muparser lib to generate new Coordinates\n\n    You can change x, y, z for every vertex according to the function specified.\n\n    See help(mlx.muparser_ref) for muparser reference documentation.\n    It's possible to use the following per-vertex variables in the expression:\n\n    Variables (per vertex):\n        x, y, z (coordinates)\n        nx, ny, nz (normal)\n        r, g, b, a (color)\n        q (quality)\n        rad (radius)\n        vi (vertex index)\n        vtu, vtv (texture coordinates)\n        ti (texture index)\n        vsel (is the vertex selected? 1 yes, 0 no)\n        and all custom vertex attributes already defined by user.\n\n    Args:\n        x_func (str): function to generate new coordinates for x\n        y_func (str): function to generate new coordinates for y\n        z_func (str): function to generate new coordinates for z\n        selected (bool): if True, only affects selected vertices (ML ver 2016.12 & up)\n\n    Layer stack:\n        No impacts\n\n    MeshLab versions:\n        2016.12\n        1.3.4BETA", "id": "f9649:m8"}
{"signature": "def radial_flare(script, flare_radius=None, start_radius=None, end_radius=None,<EOL>end_height=None):", "body": "<EOL>effective_radius = '<STR_LIT>'<EOL>r_func = '<STR_LIT>'<EOL>z_func = '<STR_LIT>'<EOL>r_func = r_func.replace('<STR_LIT>', str(effective_radius)).replace('<STR_LIT>', str(start_radius)).replace('<STR_LIT>', str(flare_radius))<EOL>z_func = z_func.replace('<STR_LIT>', str(effective_radius)).replace('<STR_LIT>', str(start_radius)).replace('<STR_LIT>', str(flare_radius))<EOL>function_cyl_co(script=script, r_func=r_func, z_func=z_func)<EOL>return None<EOL>", "docstring": "flare_radius must be >= z2 (height)\nr2 max = flare_radius + r\n\nr2 (num): radius of mesh at end of flare\n\n+15 r= 8.8205\n-15 r= 1.1795\n\nz=10, 5 +/-15 - +/-15*0.74535599249992989880305788957709", "id": "f9649:m11"}
{"signature": "def butterfly(script, iterations=<NUM_LIT:1>, edge_threshold=<NUM_LIT:0>, selected=False):", "body": "filter_xml = '<STR_LIT>'.join([<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(iterations),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(edge_threshold),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(selected).lower()),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'])<EOL>util.write_filter(script, filter_xml)<EOL>return None<EOL>", "docstring": "Apply Butterfly Subdivision Surface algorithm.\n\n    It is an interpolated method, defined on arbitrary triangular meshes.\n    The scheme is known to be C1 but not C2 on regular meshes.\n\n    Args:\n        script: the FilterScript object or script filename to write\n            the filter to.\n        iterations (int): Number of times the model is subdivided.\n        edge_threshold (float): All the edges longer than this threshold will\n            be refined. Setting this value to zero will force a uniform\n            refinement.\n        selected (bool): If selected the filter is performed only on the\n            selected faces.\n\n    Layer stack:\n        No impacts\n\n    MeshLab versions:\n        2016.12\n        1.3.4BETA", "id": "f9650:m3"}
{"signature": "def catmull_clark(script):", "body": "filter_xml = '<STR_LIT>'<EOL>util.write_filter(script, filter_xml)<EOL>return None<EOL>", "docstring": "Apply the Catmull-Clark Subdivision Surfaces.\n\n    Note that position of the new vertices is simply linearly interpolated.\n    If the mesh is triangle based (no faux edges) it generates a quad mesh,\n    otherwise it honors the faux-edge bits.\n\n    Args:\n        script: the FilterScript object or script filename to write\n            the filter to.\n\n    Layer stack:\n        No impacts\n\n    MeshLab versions:\n        2016.12\n        1.3.4BETA", "id": "f9650:m4"}
{"signature": "def curvature_flipping(script, angle_threshold=<NUM_LIT:1.0>, curve_type=<NUM_LIT:0>,<EOL>selected=False):", "body": "filter_xml = '<STR_LIT>'.join([<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(selected).lower()),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(angle_threshold),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(curve_type),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'])<EOL>util.write_filter(script, filter_xml)<EOL>return None<EOL>", "docstring": "Use the points and normals to build a surface using the Poisson\n        Surface reconstruction approach.\n\n    Args:\n        script: the FilterScript object or script filename to write\n            the filter to.\n        angle_threshold (float): To avoid excessive flipping/swapping we\n            consider only couple of faces with a significant diedral angle\n            (e.g. greater than the indicated threshold).\n        curve_type (int): Choose a metric to compute surface curvature on vertices\n            H = mean curv, K = gaussian curv, A = area per vertex\n            1: Mean curvature = H\n            2: Norm squared mean curvature = (H * H) / A\n            3: Absolute curvature:\n                if(K >= 0) return 2 * H\n                else return 2 * sqrt(H ^ 2 - A * K)\n\n    Layer stack:\n        No impacts\n\n    MeshLab versions:\n        2016.12\n        1.3.4BETA", "id": "f9651:m5"}
{"signature": "def simplify(script, texture=True, faces=<NUM_LIT>, target_perc=<NUM_LIT:0.0>,<EOL>quality_thr=<NUM_LIT>, preserve_boundary=False, boundary_weight=<NUM_LIT:1.0>,<EOL>optimal_placement=True, preserve_normal=False,<EOL>planar_quadric=False, selected=False, extra_tex_coord_weight=<NUM_LIT:1.0>,<EOL>preserve_topology=True, quality_weight=False, autoclean=True):", "body": "if texture:<EOL><INDENT>if isinstance(script, FilterScript) and (script.ml_version == '<STR_LIT>'):<EOL><INDENT>filter_xml = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>filter_xml = '<STR_LIT>'<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if isinstance(script, FilterScript) and (script.ml_version == '<STR_LIT>'):<EOL><INDENT>filter_xml = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>filter_xml = '<STR_LIT>'<EOL><DEDENT><DEDENT>filter_xml = '<STR_LIT>'.join([<EOL>filter_xml,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(faces),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(target_perc),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(quality_thr),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(preserve_boundary).lower()),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(boundary_weight),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(optimal_placement).lower()),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(preserve_normal).lower()),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(planar_quadric).lower()),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(selected).lower()),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'])<EOL>if texture:  <EOL><INDENT>filter_xml = '<STR_LIT>'.join([<EOL>filter_xml,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(extra_tex_coord_weight),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'])<EOL><DEDENT>else:  <EOL><INDENT>filter_xml = '<STR_LIT>'.join([<EOL>filter_xml,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(preserve_topology).lower()),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(quality_weight).lower()),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(autoclean).lower()),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'])<EOL><DEDENT>filter_xml = '<STR_LIT>'.join([filter_xml, '<STR_LIT>'])<EOL>util.write_filter(script, filter_xml)<EOL>return None<EOL>", "docstring": "Simplify a mesh using a Quadric based Edge Collapse Strategy, better\n        than clustering but slower. Optionally tries to preserve UV\n        parametrization for textured meshes.\n\n    Args:\n        script: the FilterScript object or script filename to write\n            the filter to.\n        texture (bool):\n        faces (int): The desired final number of faces\n        target_perc (float): If non zero, this parameter specifies the desired\n            final size of the mesh as a percentage of the initial mesh size.\n        quality_thr (float): Quality threshold for penalizing bad shaped faces.\n            The value is in the range [0..1]0 accept any kind of face (no\n            penalties), 0.5 penalize faces with quality less than 0.5,\n            proportionally to their shape.\n        preserve_boundary (bool): The simplification process tries not to\n            affect mesh boundaries\n        boundary_weight (float): The importance of the boundary during\n            simplification. Default (1.0) means that the boundary has the same\n            importance of the rest. Values greater than 1.0 raise boundary\n            importance and has the effect of removing less vertices on the\n            border. Admitted range of values (0,+inf).\n        optimal_placement (bool): Each collapsed vertex is placed in the\n            position minimizing the quadric error. It can fail (creating bad\n            spikes) in case of very flat areas. If disabled edges are collapsed\n            onto one of the two original vertices and the final mesh is\n            composed by a subset of the original vertices.\n        preserve_normal (bool): Try to avoid face flipping effects and try to\n            preserve the original orientation of the surface.\n        planar_quadric (bool): Add additional simplification constraints that\n            improves the quality of the simplification of the planar portion of\n            the mesh.\n        selected (bool): The simplification is applied only to the selected set\n            of faces. Take care of the target number of faces!\n        extra_tex_coord_weight (float): Additional weight for each extra\n            Texture Coordinates for every (selected) vertex. Ignored if texture\n            is False.\n        preserve_topology (bool): Avoid all the collapses that should cause a\n            topology change in the mesh (like closing holes, squeezing handles,\n            etc). If checked the genus of the mesh should stay unchanged.\n        quality_weight (bool): Use the Per-Vertex quality as a weighting factor\n            for the simplification. The weight is used as a error amplification\n            value, so a vertex with a high quality value will not be simplified\n            and a portion of the mesh with low quality values will be\n            aggressively simplified.\n        autoclean (bool): After the simplification an additional set of steps\n            is performed to clean the mesh (unreferenced vertices, bad faces,\n            etc).\n\n    Layer stack:\n        Unchanged; current mesh is simplified in place.\n\n    MeshLab versions:\n        2016.12 (different filter name)\n        1.3.4BETA", "id": "f9651:m0"}
{"signature": "def cylindrical_vert(script, radius=<NUM_LIT:1.0>, inside=True):", "body": "if inside:<EOL><INDENT>function = '<STR_LIT>'.format(radius)<EOL><DEDENT>else:<EOL><INDENT>function = '<STR_LIT>'.format(radius)<EOL><DEDENT>vert_function(script, function=function)<EOL>return None<EOL>", "docstring": "Select all vertices within a cylindrical radius\n\n    Args:\n        radius (float): radius of the sphere\n        center_pt (3 coordinate tuple or list): center point of the sphere\n\n    Layer stack:\n        No impacts\n\n    MeshLab versions:\n        2016.12\n        1.3.4BETA", "id": "f9652:m13"}
{"signature": "def grow(script, iterations=<NUM_LIT:1>):", "body": "filter_xml = '<STR_LIT>'<EOL>for _ in range(iterations):<EOL><INDENT>util.write_filter(script, filter_xml)<EOL><DEDENT>return None<EOL>", "docstring": "Grow (dilate, expand) the current set of selected faces\n\n    Args:\n        script: the FilterScript object or script filename to write\n            the filter to.\n        iterations (int): the number of times to grow the selection.\n\n    Layer stack:\n        No impacts\n\n    MeshLab versions:\n        2016.12\n        1.3.4BETA", "id": "f9652:m4"}
{"signature": "def none(script, face=True, vert=True):", "body": "filter_xml = '<STR_LIT>'.join([<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(face).lower()),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(vert).lower()),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'])<EOL>util.write_filter(script, filter_xml)<EOL>return None<EOL>", "docstring": "Clear the current set of selected faces\n\n    Args:\n        script: the FilterScript object or script filename to write\n            the filter to.\n        faces (bool): If True the filter will deselect all the faces.\n        verts (bool): If True the filter will deselect all the vertices.\n\n    Layer stack:\n        No impacts\n\n    MeshLab versions:\n        2016.12\n        1.3.4BETA", "id": "f9652:m1"}
{"signature": "def spherical_vert(script, radius=<NUM_LIT:1.0>, center_pt=(<NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT:0.0>)):", "body": "function = '<STR_LIT>'.format(<EOL>center_pt[<NUM_LIT:0>], center_pt[<NUM_LIT:1>], center_pt[<NUM_LIT:2>], radius)<EOL>vert_function(script, function=function)<EOL>return None<EOL>", "docstring": "Select all vertices within a spherical radius\n\n    Args:\n        radius (float): radius of the sphere\n        center_pt (3 coordinate tuple or list): center point of the sphere\n\n    Layer stack:\n        No impacts\n\n    MeshLab versions:\n        2016.12\n        1.3.4BETA", "id": "f9652:m14"}
{"signature": "def vert_function(script, function='<STR_LIT>', strict_face_select=True):", "body": "if script.ml_version == '<STR_LIT>':<EOL><INDENT>strict_select = '<STR_LIT>'.join([<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(strict_face_select).lower()),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>])<EOL><DEDENT>else:<EOL><INDENT>strict_select = '<STR_LIT>'<EOL><DEDENT>filter_xml = '<STR_LIT>'.join([<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(function).replace('<STR_LIT:&>', '<STR_LIT>').replace('<STR_LIT:<>', '<STR_LIT>')),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>strict_select,<EOL>'<STR_LIT>'])<EOL>util.write_filter(script, filter_xml)<EOL>return None<EOL>", "docstring": "Boolean function using muparser lib to perform vertex selection over current mesh.\n\n    See help(mlx.muparser_ref) for muparser reference documentation.\n\n    It's possible to use parenthesis, per-vertex variables and boolean operator:\n        (, ), and, or, <, >, =\n    It's possible to use the following per-vertex variables in the expression:\n\n    Variables:\n        x, y, z (coordinates)\n        nx, ny, nz (normal)\n        r, g, b, a (color)\n        q (quality)\n        rad\n        vi (vertex index)\n        vtu, vtv (texture coordinates)\n        ti (texture index)\n        vsel (is the vertex selected? 1 yes, 0 no)\n        and all custom vertex attributes already defined by user.\n\n    Args:\n        script: the FilterScript object or script filename to write\n            the filter] to.\n        function (str): a boolean function that will be evaluated in order\n            to select a subset of vertices. Example: (y > 0) and (ny > 0)\n        strict_face_select (bool): if True a face is selected if ALL its\n            vertices are selected. If False a face is selected if at least\n            one of its vertices is selected. ML v1.3.4BETA only; this is\n            ignored in 2016.12. In 2016.12 only vertices are selected.\n\n    Layer stack:\n        No impacts\n\n    MeshLab versions:\n        2016.12\n        1.3.4BETA", "id": "f9652:m12"}
{"signature": "def invert(script, face=True, vert=True):", "body": "filter_xml = '<STR_LIT>'.join([<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(face).lower()),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(vert).lower()),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'])<EOL>util.write_filter(script, filter_xml)<EOL>return None<EOL>", "docstring": "Invert the current set of selected faces\n\n    Args:\n        script: the FilterScript object or script filename to write\n            the filter to.\n        faces (bool): If True the filter will invert the selected faces.\n        verts (bool): If True the filter will invert the selected vertices.\n\n    Layer stack:\n        No impacts\n\n    MeshLab versions:\n        2016.12\n        1.3.4BETA", "id": "f9652:m2"}
{"signature": "def small_parts(script, ratio=<NUM_LIT>, non_closed_only=False):", "body": "filter_xml = '<STR_LIT>'.join([<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(ratio),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(non_closed_only).lower()),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'])<EOL>util.write_filter(script, filter_xml)<EOL>return None<EOL>", "docstring": "Select the small disconnected parts (components) of a mesh.\n\n    Args:\n        script: the FilterScript object or script filename to write\n            the filter to.\n        ratio (float): This ratio (between 0 and 1) defines the meaning of\n            'small' as the threshold ratio between the number of faces of the\n            largest component and the other ones. A larger value will select\n            more components.\n        non_closed_only (bool): Select only non-closed components.\n\n    Layer stack:\n        No impacts\n\n    MeshLab versions:\n        2016.12\n        1.3.4BETA", "id": "f9652:m9"}
{"signature": "def taubin(script, iterations=<NUM_LIT:10>, t_lambda=<NUM_LIT:0.5>, t_mu=-<NUM_LIT>, selected=False):", "body": "filter_xml = '<STR_LIT>'.join([<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(t_lambda),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(t_mu),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(iterations),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(selected).lower()),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'])<EOL>util.write_filter(script, filter_xml)<EOL>return None<EOL>", "docstring": "The lambda & mu Taubin smoothing, it make two steps of smoothing, forth\n        and back, for each iteration.\n\n    Based on:\n    Gabriel Taubin\n    \"A signal processing approach to fair surface design\"\n    Siggraph 1995\n\n    Args:\n        script: the FilterScript object or script filename to write\n            the filter to.\n        iterations (int): The number of times that the taubin smoothing is\n            iterated. Usually it requires a larger number of iteration than the\n            classical laplacian.\n        t_lambda (float): The lambda parameter of the Taubin Smoothing algorithm\n        t_mu (float): The mu parameter of the Taubin Smoothing algorithm\n        selected (bool): If selected the filter is performed only on the\n            selected faces\n\n    Layer stack:\n        No impacts\n\n    MeshLab versions:\n        2016.12\n        1.3.4BETA", "id": "f9653:m2"}
{"signature": "def hc_laplacian(script):", "body": "filter_xml = '<STR_LIT>'<EOL>util.write_filter(script, filter_xml)<EOL>return None<EOL>", "docstring": "HC Laplacian Smoothing, extended version of Laplacian Smoothing, based\n        on the paper of Vollmer, Mencl, and Muller\n\n    Layer stack:\n        No impacts\n\n    MeshLab versions:\n        2016.12\n        1.3.4BETA", "id": "f9653:m1"}
{"signature": "def laplacian(script, iterations=<NUM_LIT:1>, boundary=True, cotangent_weight=True,<EOL>selected=False):", "body": "filter_xml = '<STR_LIT>'.join([<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(iterations),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(boundary).lower()),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(cotangent_weight).lower()),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(selected).lower()),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'])<EOL>util.write_filter(script, filter_xml)<EOL>return None<EOL>", "docstring": "Laplacian smooth of the mesh: for each vertex it calculates the average\n        position with nearest vertex\n\n    Args:\n        script: the FilterScript object or script filename to write\n            the filter to.\n        iterations (int): The number of times that the whole algorithm (normal\n            smoothing + vertex fitting) is iterated.\n        boundary (bool): If true the boundary edges are smoothed only by\n            themselves (e.g. the polyline forming the boundary of the mesh is\n            independently smoothed). Can reduce the shrinking on the border but\n            can have strange effects on very small boundaries.\n        cotangent_weight (bool): If True the cotangent weighting scheme is\n            computed for the averaging of the position. Otherwise (False) the\n            simpler umbrella scheme (1 if the edge is present) is used.\n        selected (bool): If selected the filter is performed only on the\n            selected faces\n\n    Layer stack:\n        No impacts\n\n    MeshLab versions:\n        2016.12\n        1.3.4BETA", "id": "f9653:m0"}
{"signature": "def join(script, merge_visible=True, merge_vert=False, delete_layer=True,<EOL>keep_unreferenced_vert=False):", "body": "filter_xml = '<STR_LIT>'.join([<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(merge_visible).lower()),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(merge_vert).lower()),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(delete_layer).lower()),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(keep_unreferenced_vert).lower()),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'])<EOL>util.write_filter(script, filter_xml)<EOL>if isinstance(script, mlx.FilterScript):<EOL><INDENT>script.add_layer('<STR_LIT>')<EOL>if delete_layer:<EOL><INDENT>for i in range(script.last_layer()):<EOL><INDENT>script.del_layer(<NUM_LIT:0>)<EOL><DEDENT><DEDENT><DEDENT>return None<EOL>", "docstring": "Flatten all or only the visible layers into a single new mesh.\n\n    Transformations are preserved. Existing layers can be optionally\n    deleted.\n\n    Args:\n        script: the mlx.FilterScript object or script filename to write\n            the filter to.\n        merge_visible (bool): merge only visible layers\n        merge_vert (bool): merge the vertices that are duplicated among\n            different layers. Very useful when the layers are spliced portions\n            of a single big mesh.\n        delete_layer (bool): delete all the merged layers. If all layers are\n            visible only a single layer will remain after the invocation of\n            this filter.\n        keep_unreferenced_vert (bool): Do not discard unreferenced vertices\n            from source layers. Necessary for point-only layers.\n\n    Layer stack:\n        Creates a new layer \"Merged Mesh\"\n        Changes current layer to the new layer\n        Optionally deletes all other layers\n\n    MeshLab versions:\n        2016.12\n        1.3.4BETA\n\n    Bugs:\n        UV textures: not currently preserved, however will be in a future\n            release. https://github.com/cnr-isti-vclab/meshlab/issues/128\n        merge_visible: it is not currently possible to change the layer\n            visibility from meshlabserver, however this will be possible\n            in the future https://github.com/cnr-isti-vclab/meshlab/issues/123", "id": "f9655:m0"}
{"signature": "def rename(script, label='<STR_LIT:blank>', layer_num=None):", "body": "filter_xml = '<STR_LIT>'.join([<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(label),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'])<EOL>if isinstance(script, mlx.FilterScript):<EOL><INDENT>if (layer_num is None) or (layer_num == script.current_layer()):<EOL><INDENT>util.write_filter(script, filter_xml)<EOL>script.layer_stack[script.current_layer()] = label<EOL><DEDENT>else:<EOL><INDENT>cur_layer = script.current_layer()<EOL>change(script, layer_num)<EOL>util.write_filter(script, filter_xml)<EOL>change(script, cur_layer)<EOL>script.layer_stack[layer_num] = label<EOL><DEDENT><DEDENT>else:<EOL><INDENT>util.write_filter(script, filter_xml)<EOL><DEDENT>return None<EOL>", "docstring": "Rename layer label\n\n    Can be useful for outputting mlp files, as the output file names use\n    the labels.\n\n    Args:\n        script: the mlx.FilterScript object or script filename to write\n            the filter to.\n        label (str): new label for the mesh layer\n        layer_num (int): layer number to rename. Default is the\n            current layer. Not supported on the file base API.\n\n    Layer stack:\n        Renames a layer\n\n    MeshLab versions:\n        2016.12\n        1.3.4BETA", "id": "f9655:m2"}
{"signature": "def delete_lower(script, layer_num=None):", "body": "if layer_num is None:<EOL><INDENT>layer_num = script.current_layer()<EOL><DEDENT>if layer_num != <NUM_LIT:0>:<EOL><INDENT>change(script, <NUM_LIT:0>)<EOL><DEDENT>for i in range(layer_num):<EOL><INDENT>delete(script, <NUM_LIT:0>)<EOL><DEDENT>return None<EOL>", "docstring": "Delete all layers below the specified one.\n\n    Useful for MeshLab ver 2016.12, whcih will only output layer 0.", "id": "f9655:m6"}
{"signature": "def selected(script, face=True, vert=True):", "body": "if face and vert:<EOL><INDENT>filter_xml = '<STR_LIT>'<EOL><DEDENT>elif face and not vert:<EOL><INDENT>filter_xml = '<STR_LIT>'<EOL><DEDENT>elif not face and vert:<EOL><INDENT>filter_xml = '<STR_LIT>'<EOL><DEDENT>util.write_filter(script, filter_xml)<EOL>return None<EOL>", "docstring": "Delete selected vertices and/or faces\n\n    Note: if the mesh has no faces (e.g. a point cloud) you must\n    set face=False, or the vertices will not be deleted\n\n    Args:\n        script: the FilterScript object or script filename to write\n            the filter to.\n        face (bool): if True the selected faces will be deleted. If vert\n            is also True, then all the vertices surrounded by those faces will\n            also be deleted. Note that if no faces are selected (only vertices)\n            then this filter will not do anything. For example, if you want to\n            delete a point cloud selection, you must set this to False.\n        vert (bool): if True the selected vertices will be deleted.\n\n    Layer stack:\n        No impacts\n\n    MeshLab versions:\n        2016.12\n        1.3.4BETA", "id": "f9656:m3"}
{"signature": "def nonmanifold_edge(script):", "body": "select.nonmanifold_edge(script)<EOL>selected(script, face=False)<EOL>return None<EOL>", "docstring": "Select & delete the faces and the vertices incident on\n        non manifold edges (e.g. edges where more than two faces are incident).\n\n    Note that this function selects the components that are related to\n    non manifold edges. The case of non manifold vertices is specifically\n    managed by nonmanifold_vert.\n\n    Args:\n        script: the FilterScript object or script filename to write\n            the filter to.\n\n    Layer stack:\n        No impacts\n\n    MeshLab versions:\n        2016.12\n        1.3.4BETA", "id": "f9656:m1"}
{"signature": "def nonmanifold_vert(script):", "body": "select.nonmanifold_vert(script)<EOL>selected(script, face=False)<EOL>return None<EOL>", "docstring": "Select & delete the non manifold vertices that do not belong to\n        non manifold edges.\n\n    For example two cones connected by their apex. Vertices incident on\n    non manifold edges are ignored.\n\n    Args:\n        script: the FilterScript object or script filename to write\n            the filter to.\n\n    Layer stack:\n        No impacts\n\n    MeshLab versions:\n        2016.12\n        1.3.4BETA", "id": "f9656:m0"}
{"signature": "def poisson_disk(script, sample_num=<NUM_LIT:1000>, radius=<NUM_LIT:0.0>,<EOL>montecarlo_rate=<NUM_LIT:20>, save_montecarlo=False,<EOL>approx_geodesic_dist=False, subsample=False, refine=False,<EOL>refine_layer=<NUM_LIT:0>, best_sample=True, best_sample_pool=<NUM_LIT:10>,<EOL>exact_num=False, radius_variance=<NUM_LIT:1.0>):", "body": "filter_xml = '<STR_LIT>'.join([<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(sample_num),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(radius),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(montecarlo_rate),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(save_montecarlo).lower()),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(approx_geodesic_dist).lower()),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(subsample).lower()),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(refine).lower()),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(refine_layer),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(best_sample).lower()),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(best_sample_pool),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(exact_num).lower()),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(radius_variance),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'])<EOL>util.write_filter(script, filter_xml)<EOL>if isinstance(script, FilterScript):<EOL><INDENT>script.add_layer('<STR_LIT>')<EOL>if save_montecarlo:<EOL><INDENT>script.add_layer('<STR_LIT>')<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Create a new layer populated with a point sampling of the current mesh.\n\n    Samples are generated according to a Poisson-disk distribution, using the\n    algorithm described in:\n\n    'Efficient and Flexible Sampling with Blue Noise Properties of Triangular Meshes'\n    Massimiliano Corsini, Paolo Cignoni, Roberto Scopigno\n    IEEE TVCG 2012\n\n    Args:\n        script: the FilterScript object or script filename to write\n            the filter to.\n        sample_num (int): The desired number of samples. The radius of the disk\n            is calculated according to the sampling density.\n        radius (float): If not zero this parameter overrides the previous\n            parameter to allow exact radius specification.\n        montecarlo_rate (int): The over-sampling rate that is used to generate\n            the intial Monte Carlo samples (e.g. if this parameter is 'K' means\n            that 'K * sample_num' points will be used). The generated\n            Poisson-disk samples are a subset of these initial Monte Carlo\n            samples. Larger numbers slow the process but make it a bit more\n            accurate.\n        save_montecarlo (bool): If True, it will generate an additional Layer\n            with the Monte Carlo sampling that was pruned to build the Poisson\n            distribution.\n        approx_geodesic_dist (bool): If True Poisson-disk distances are\n            computed using an approximate geodesic distance, e.g. an Euclidean\n            distance weighted by a function of the difference between the\n            normals of the two points.\n        subsample (bool): If True the original vertices of the base mesh are\n            used as base set of points. In this case the sample_num should be\n            obviously much smaller than the original vertex number. Note that\n            this option is very useful in the case you want to subsample a\n            dense point cloud.\n        refine (bool): If True the vertices of the refine_layer mesh layer are\n            used as starting vertices, and they will be utterly refined by\n            adding more and more points until possible.\n        refine_layer (int): Used only if refine is True.\n        best_sample (bool): If True it will use a simple heuristic for choosing\n            the samples. At a small cost (it can slow the process a bit) it\n            usually improves the maximality of the generated sampling.\n        best_sample_pool (bool): Used only if best_sample is True. It controls\n            the number of attempts that it makes to get the best sample. It is\n            reasonable that it is smaller than the Monte Carlo oversampling\n            factor.\n        exact_num (bool): If True it will try to do a dicotomic search for the\n            best Poisson-disk radius that will generate the requested number of\n            samples with a tolerance of the 0.5%. Obviously it takes much\n            longer.\n        radius_variance (float): The radius of the disk is allowed to vary\n            between r and r*var. If this parameter is 1 the sampling is the\n            same as the Poisson-disk Sampling.\n\n    Layer stack:\n        Creates new layer 'Poisson-disk Samples'. Current layer is NOT changed\n            to the new layer (see Bugs).\n        If save_montecarlo is True, creates a new layer 'Montecarlo Samples'.\n            Current layer is NOT changed to the new layer (see Bugs).\n\n    MeshLab versions:\n        2016.12\n        1.3.4BETA\n\n    Bugs:\n        Current layer is NOT changed to the new layer, which is inconsistent\n            with the majority of filters that create new layers.", "id": "f9657:m1"}
{"signature": "def clustered_vert(script, cell_size=<NUM_LIT:1.0>, strategy='<STR_LIT>', selected=False):", "body": "if strategy.lower() == '<STR_LIT>':<EOL><INDENT>strategy_num = <NUM_LIT:0><EOL><DEDENT>elif strategy.lower() == '<STR_LIT>':<EOL><INDENT>strategy_num = <NUM_LIT:1><EOL><DEDENT>filter_xml = '<STR_LIT>'.join([<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(cell_size),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(strategy_num),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(selected).lower()),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'])<EOL>util.write_filter(script, filter_xml)<EOL>if isinstance(script, FilterScript):<EOL><INDENT>script.add_layer('<STR_LIT>')<EOL><DEDENT>return None<EOL>", "docstring": "Create a new layer populated with a subsampling of the vertexes of the\n        current mesh\n\n    The subsampling is driven by a simple one-per-gridded cell strategy.\n\n    Args:\n        script: the FilterScript object or script filename to write\n            the filter to.\n        cell_size (float): The size of the cell of the clustering grid. Smaller the cell finer the resulting mesh. For obtaining a very coarse mesh use larger values.\n        strategy (enum 'AVERAGE' or 'CENTER'): &lt;b>Average&lt;/b>: for each cell we take the average of the sample falling into. The resulting point is a new point.&lt;br>&lt;b>Closest to center&lt;/b>: for each cell we take the sample that is closest to the center of the cell. Choosen vertices are a subset of the original ones.\n        selected (bool): If true only for the filter is applied only on the selected subset of the mesh.\n\n    Layer stack:\n        Creates new layer 'Cluster Samples'. Current layer is changed to the new\n            layer.\n\n    MeshLab versions:\n        2016.12\n        1.3.4BETA", "id": "f9657:m3"}
{"signature": "def param_texture_from_rasters(script, textName=\"<STR_LIT>\", texsize=<NUM_LIT>,<EOL>colorCorrection=True, colorCorrectionFilterSize=<NUM_LIT:1>,<EOL>useDistanceWeight=True, useImgBorderWeight=True,<EOL>useAlphaWeight=False, cleanIsolatedTriangles=True,<EOL>stretchingAllowed=False, textureGutter=<NUM_LIT:4>):", "body": "filter_xml = '<STR_LIT>'.join([<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % texsize,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % textName,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % str(colorCorrection).lower(),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % colorCorrectionFilterSize,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % str(useDistanceWeight).lower(),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % str(useImgBorderWeight).lower(),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % str(useAlphaWeight).lower(),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % str(cleanIsolatedTriangles).lower(),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % str(stretchingAllowed).lower(),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % textureGutter,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'])<EOL>util.write_filter(script, filter_xml)<EOL>return None<EOL>", "docstring": "Set texture", "id": "f9658:m11"}
{"signature": "def project_rasters(script, tex_file_out=\"<STR_LIT>\", tex_size=<NUM_LIT>,<EOL>fill_atlas_gaps=False, depth_threshold=<NUM_LIT:0.5>,<EOL>selected=False, use_angle=True, use_distance=True,<EOL>use_borders=True, use_silhouettes=True, use_alpha=False):", "body": "filter_xml = '<STR_LIT>'.join([<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % tex_file_out,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % tex_size,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % str(fill_atlas_gaps).lower(),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % depth_threshold,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % str(selected).lower(),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % str(use_angle).lower(),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % str(use_distance).lower(),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % str(use_borders).lower(),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % str(use_silhouettes).lower(),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % str(use_alpha).lower(),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'])<EOL>util.write_filter(script, filter_xml)<EOL>return None<EOL>", "docstring": "Set texture\n\n    Creates new texture file\n    tex_file_out = must be png\n    fill_atlas_gaps  = setting this to false will leave the unprojected area transparent. This can then be easily composed with the original texture with PIL", "id": "f9658:m10"}
{"signature": "def set_texture(script, textName=\"<STR_LIT>\", textDim=<NUM_LIT>):", "body": "filter_xml = '<STR_LIT>'.join([<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % textName,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % textDim,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'])<EOL>util.write_filter(script, filter_xml)<EOL>return None<EOL>", "docstring": "Set texture", "id": "f9658:m9"}
{"signature": "def per_triangle(script, sidedim=<NUM_LIT:0>, textdim=<NUM_LIT>, border=<NUM_LIT:2>, method=<NUM_LIT:1>):", "body": "filter_xml = '<STR_LIT>'.join([<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % sidedim,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % textdim,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % border,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % method,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'])<EOL>util.write_filter(script, filter_xml)<EOL>return None<EOL>", "docstring": "Trivial Per-Triangle parameterization", "id": "f9658:m1"}
{"signature": "def isometric_load(script, AbsName=\"<STR_LIT>\"):", "body": "filter_xml = '<STR_LIT>'.join([<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % AbsName,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'])<EOL>util.write_filter(script, filter_xml)<EOL>return None<EOL>", "docstring": "Isometric parameterization: Load Abstract Domain", "id": "f9658:m6"}
{"signature": "def isometric_remesh(script, SamplingRate=<NUM_LIT:10>):", "body": "filter_xml = '<STR_LIT>'.join([<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % SamplingRate,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'])<EOL>util.write_filter(script, filter_xml)<EOL>return None<EOL>", "docstring": "Isometric parameterization: remeshing", "id": "f9658:m8"}
{"signature": "def isometric_transfer(script, sourceMesh=<NUM_LIT:0>, targetMesh=<NUM_LIT:1>):", "body": "filter_xml = '<STR_LIT>'.join([<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % sourceMesh,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>' % targetMesh,<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'])<EOL>util.write_filter(script, filter_xml)<EOL>return None<EOL>", "docstring": "Isometric parameterization: transfer between meshes\n\n    Provide the layer numbers of the source and target meshes.", "id": "f9658:m7"}
{"signature": "def vert_attr(script, name='<STR_LIT>', function='<STR_LIT>'):", "body": "filter_xml = '<STR_LIT>'.join([<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(name),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(function).replace('<STR_LIT:&>', '<STR_LIT>').replace('<STR_LIT:<>', '<STR_LIT>')),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'])<EOL>util.write_filter(script, filter_xml)<EOL>return None<EOL>", "docstring": "Add a new Per-Vertex scalar attribute to current mesh and fill it with\n        the defined function.\n\n    The specified name can be used in other filter functions.\n\n    It's possible to use parenthesis, per-vertex variables and boolean operator:\n        (, ), and, or, <, >, =\n    It's possible to use the following per-vertex variables in the expression:\n\n    Variables:\n        x, y, z (coordinates)\n        nx, ny, nz (normal)\n        r, g, b, a (color)\n        q (quality)\n        rad\n        vi (vertex index)\n        ?vtu, vtv (texture coordinates)\n        ?ti (texture index)\n        ?vsel (is the vertex selected? 1 yes, 0 no)\n        and all custom vertex attributes already defined by user.\n\n    Args:\n        script: the FilterScript object or script filename to write\n            the filter] to.\n        name (str): the name of new attribute. You can access attribute in\n            other filters through this name.\n        function (str): function to calculate custom attribute value for each\n            vertex\n\n    Layer stack:\n        No impacts\n\n    MeshLab versions:\n        2016.12\n        1.3.4BETA", "id": "f9659:m11"}
{"signature": "def mp_atan2(y, x):", "body": "return '<STR_LIT>'.replace(<EOL>'<STR_LIT>', str(math.pi)).replace('<STR_LIT:y>', y).replace('<STR_LIT:x>', x)<EOL>", "docstring": "muparser atan2 function\n\n    Implements an atan2(y,x) function for older muparser versions (<2.1.0);\n    atan2 was added as a built-in function in muparser 2.1.0\n\n    Args:\n        y (str): y argument of the atan2(y,x) function\n        x (str): x argument of the atan2(y,x) function\n\n    Returns:\n        A muparser string that calculates atan2(y,x)", "id": "f9659:m1"}
{"signature": "def face_attr(script, name='<STR_LIT>', function='<STR_LIT>'):", "body": "filter_xml = '<STR_LIT>'.join([<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(name),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(function).replace('<STR_LIT:&>', '<STR_LIT>').replace('<STR_LIT:<>', '<STR_LIT>')),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'])<EOL>util.write_filter(script, filter_xml)<EOL>return None<EOL>", "docstring": "Add a new Per-Face attribute to current mesh and fill it with\n        the defined function..\n\n    The specified name can be used in other filter functions.\n\n    It's possible to use parenthesis, per-face variables and boolean operator:\n        (, ), and, or, <, >, =\n\n    It's possible to use per-face variables like attributes associated to the\n    three vertices of every face.\n\n    It's possible to use the following per-face variables in the expression:\n\n    Variables:\n        x0,y0,z0 (first vertex); x1,y1,z1 (second vertex); x2,y2,z2 (third vertex)\n        nx0,ny0,nz0; nx1,ny1,nz1; nx2,ny2,nz2 (normals)\n        r0,g0,b0 (color)\n        q0,q1,q2 (quality)\n        wtu0, wtv0; wtu1, wtv1; wtu2, wtv2 (per wedge tex coord)\n        fi (face index)\n        ?fsel (is the vertex selected? 1 yes, 0 no)\n        fi (face index)\n        and all custom face attributes already defined by user.\n\n    Args:\n        script: the FilterScript object or script filename to write\n            the filter] to.\n        name (str): the name of new attribute. You can access attribute in\n            other filters through this name.\n        function (str): function to calculate custom attribute value for each\n            face\n\n    Layer stack:\n        No impacts\n\n    MeshLab versions:\n        2016.12\n        1.3.4BETA", "id": "f9659:m12"}
{"signature": "def section(script, axis='<STR_LIT:z>', offset=<NUM_LIT:0.0>, surface=False, custom_axis=None,<EOL>planeref=<NUM_LIT:2>):", "body": "<EOL>if axis.lower() == '<STR_LIT:x>':<EOL><INDENT>axis_num = <NUM_LIT:0><EOL>axis_name = '<STR_LIT:X>'<EOL><DEDENT>elif axis.lower() == '<STR_LIT:y>':<EOL><INDENT>axis_num = <NUM_LIT:1><EOL>axis_name = '<STR_LIT:Y>'<EOL><DEDENT>elif axis.lower() == '<STR_LIT:z>':<EOL><INDENT>axis_num = <NUM_LIT:2><EOL>axis_name = '<STR_LIT>'<EOL><DEDENT>else:  <EOL><INDENT>axis_num = <NUM_LIT:3><EOL>axis_name = '<STR_LIT>'<EOL>if custom_axis is None:<EOL><INDENT>print('<STR_LIT>',<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>if custom_axis is None:<EOL><INDENT>custom_axis = (<NUM_LIT:0.0>, <NUM_LIT:0.0>, <NUM_LIT:1.0>)<EOL><DEDENT>filter_xml = '<STR_LIT>'.join([<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(axis_num),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(custom_axis[<NUM_LIT:0>], custom_axis[<NUM_LIT:1>],<EOL>custom_axis[<NUM_LIT:2>]),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(offset),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(planeref),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(str(surface).lower()),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'])<EOL>util.write_filter(script, filter_xml)<EOL>if isinstance(script, mlx.FilterScript):<EOL><INDENT>current_layer_label = script.layer_stack[script.current_layer()]<EOL>script.add_layer('<STR_LIT>'.format(current_layer_label, axis_name,<EOL>int(offset)))<EOL>if surface:<EOL><INDENT>script.add_layer('<STR_LIT>'.format(current_layer_label,<EOL>axis_name, int(offset)))<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Compute the polyline representing a planar section (a slice) of a mesh.\n\n    If the resulting polyline is closed the result can be filled with a\n    triangular mesh representing the section.\n\n    Args:\n        script: the mlx.FilterScript object or script filename to write\n            the filter to.\n        axis (str): The slicing plane is perpendicular to this axis. Accepted\n            values are 'x', 'y', or 'z'; any other input will be interpreted\n            as a custom axis (although using 'custom' is recommended\n            for clarity). Upper or lowercase values are accepted.\n        offset (float): Specify an offset of the cross-plane. The offset\n            corresponds to the distance along 'axis' from the point specified\n            in 'planeref'.\n        surface (bool): If True, in addition to a layer with the section\n            polyline, also a layer with a triangulated version of the section\n            polyline will be created. This only works if the section polyline\n            is closed.\n        custom_axis (3 component list or tuple): Specify a custom axis as\n            a 3 component vector (x, y, z); this is ignored unless 'axis' is\n            set  to 'custom'.\n        planeref (int): Specify the reference from which the planes are\n            shifted. Valid values are:\n            0 - Bounding box center\n            1 - Bounding box min\n            2 - Origin (default)\n\n    Layer stack:\n        Creates a new layer '{label}_sect_{axis_name}_{offset}', where\n            'axis_name' is one of [X, Y, Z, custom] and 'offest' is\n            truncated 'offset'\n        If surface is True, create a new layer '{label}_sect_{axis}_{offset}_mesh'\n        Current layer is changed to the last (newly created) layer\n\n    MeshLab versions:\n        2016.12\n        1.3.4BETA", "id": "f9660:m0"}
{"signature": "def parse_hausdorff(ml_log, log=None, print_output=False):", "body": "hausdorff_distance = {\"<STR_LIT>\": <NUM_LIT:0.0>,<EOL>\"<STR_LIT>\": <NUM_LIT:0.0>,<EOL>\"<STR_LIT>\": <NUM_LIT:0.0>,<EOL>\"<STR_LIT>\": <NUM_LIT:0.0>,<EOL>\"<STR_LIT>\": <NUM_LIT:0>}<EOL>with open(ml_log) as fread:<EOL><INDENT>result = fread.readlines()<EOL>data = \"<STR_LIT>\"<EOL>for idx, line in enumerate(result):<EOL><INDENT>m = re.match(r\"<STR_LIT>\", line)<EOL>if m is not None:<EOL><INDENT>hausdorff_distance[\"<STR_LIT>\"] = int(m.group(<NUM_LIT:1>))<EOL><DEDENT>if '<STR_LIT>' in line:<EOL><INDENT>data = result[idx + <NUM_LIT:2>]<EOL><DEDENT><DEDENT>m = re.match(r\"<STR_LIT>\", data)<EOL>hausdorff_distance[\"<STR_LIT>\"] = float(m.group(<NUM_LIT:1>))<EOL>hausdorff_distance[\"<STR_LIT>\"] = float(m.group(<NUM_LIT:2>))<EOL>hausdorff_distance[\"<STR_LIT>\"] = float(m.group(<NUM_LIT:3>))<EOL>hausdorff_distance[\"<STR_LIT>\"] = float(m.group(<NUM_LIT:4>))<EOL>for key, value in hausdorff_distance.items():<EOL><INDENT>if log is not None:<EOL><INDENT>log_file = open(log, '<STR_LIT:a>')<EOL>log_file.write('<STR_LIT>'.format(key, value))<EOL>log_file.close()<EOL><DEDENT>elif print_output:<EOL><INDENT>print('<STR_LIT>'.format(key, value))<EOL><DEDENT><DEDENT>return hausdorff_distance<EOL><DEDENT>", "docstring": "Parse the ml_log file generated by the hausdorff_distance function.\n\n    Args:\n        ml_log (str): MeshLab log file to parse\n        log (str): filename to log output\n\n    Returns:\n        dict: dictionary with the following keys:\n            number_points (int): number of points in mesh\n            min_distance (float): minimum hausdorff distance\n            max_distance (float): maximum hausdorff distance\n            mean_distance (float): mean hausdorff distance\n            rms_distance (float): root mean square distance", "id": "f9660:m5"}
{"signature": "def find_texture_files(fbasename, log=None):", "body": "fext = os.path.splitext(fbasename)[<NUM_LIT:1>][<NUM_LIT:1>:].strip().lower()<EOL>material_file = None<EOL>texture_files = []<EOL>vert_colors = False<EOL>face_colors = False<EOL>if fext == '<STR_LIT>':<EOL><INDENT>with open(fbasename, '<STR_LIT:r>') as fread:<EOL><INDENT>for line in fread:<EOL><INDENT>if '<STR_LIT>' in line:<EOL><INDENT>material_file = os.path.basename(line.split()[<NUM_LIT:1>])<EOL>break<EOL><DEDENT><DEDENT><DEDENT>if material_file is not None:<EOL><INDENT>with open(material_file, '<STR_LIT:r>') as fread:<EOL><INDENT>for line in fread:<EOL><INDENT>if '<STR_LIT>' in line:<EOL><INDENT>texture_files.append(os.path.basename(line.split()[<NUM_LIT:1>]))<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>elif fext == '<STR_LIT>':<EOL><INDENT>face_element = False<EOL>with open(fbasename, '<STR_LIT:rb>') as fread:<EOL><INDENT>while True:<EOL><INDENT>line = fread.readline().strip().decode('<STR_LIT:ascii>')<EOL>if '<STR_LIT>' in line:<EOL><INDENT>face_element = True<EOL><DEDENT>if '<STR_LIT>' in line:<EOL><INDENT>if face_element:<EOL><INDENT>face_colors = True<EOL><DEDENT>else:<EOL><INDENT>vert_colors = True<EOL><DEDENT><DEDENT>if '<STR_LIT>' in line:<EOL><INDENT>texture_files.append(os.path.basename(line.split()[<NUM_LIT:2>]))<EOL><DEDENT>if '<STR_LIT>' in line:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT>elif fext == '<STR_LIT>':  <EOL><INDENT>namespace = '<STR_LIT>'<EOL>tree = ET.parse(fbasename)<EOL>for elem in tree.findall(<EOL>'<STR_LIT>' % (namespace, namespace, namespace)):<EOL><INDENT>texture_files.append(elem.text)<EOL><DEDENT><DEDENT>elif fext == '<STR_LIT>':<EOL><INDENT>tree = ET.parse(fbasename)<EOL>for elem in tree.iter(tag='<STR_LIT>'):<EOL><INDENT>texture_files.append(elem.attrib['<STR_LIT:url>'])<EOL><DEDENT><DEDENT>elif fext == '<STR_LIT>':<EOL><INDENT>with open(fbasename, '<STR_LIT:r>') as fread:<EOL><INDENT>for line in fread:<EOL><INDENT>if '<STR_LIT>' in line:<EOL><INDENT>texture_files.append(os.path.basename(line.split('<STR_LIT:\">')[<NUM_LIT:1>]))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>elif fext != '<STR_LIT>':  <EOL><INDENT>print('<STR_LIT>' % fext)<EOL><DEDENT>texture_files_unique = list(set(texture_files))<EOL>if log is not None:<EOL><INDENT>log_file = open(log, '<STR_LIT:a>')<EOL>log_file.write('<STR_LIT>')<EOL>log_file.write('<STR_LIT>' % fbasename)<EOL>log_file.write('<STR_LIT>' % texture_files)<EOL>log_file.write('<STR_LIT>' % texture_files_unique)<EOL>log_file.write('<STR_LIT>' % len(texture_files))<EOL>log_file.write(<EOL>'<STR_LIT>' %<EOL>len(texture_files_unique))<EOL>log_file.write('<STR_LIT>' % vert_colors)<EOL>log_file.write('<STR_LIT>' % face_colors)<EOL>log_file.close()<EOL><DEDENT>colors = {'<STR_LIT>':bool(texture_files), '<STR_LIT>':vert_colors, '<STR_LIT>':face_colors}<EOL>return texture_files, texture_files_unique, material_file, colors<EOL>", "docstring": "Finds the filenames of the referenced texture file(s) (and material\n    file for obj) for the mesh.\n\n    Args:\n        fbasename (str): input filename. Supported file extensions:\n            obj\n            ply\n            dae\n            x3d\n            wrl\n        log (str): filename to log output\n\n    Returns:\n        list: list of all of the texture filenames referenced by the input file.\n            May contain duplicates if the texture files are referenced more\n            than once. List is empty if no texture files are found.\n        list: list of all of the unique texture filenames, also empty if no\n            texture files are found.\n        str: for obj files only, returns the name of the referenced material file.\n            Returns None if no material file is found.", "id": "f9661:m2"}
{"signature": "def create_mlp(file_out, mlp_mesh=None, mlp_raster=None):", "body": "<EOL>mlp_file = open(file_out, '<STR_LIT:w>')<EOL>mlp_file.write('<STR_LIT:\\n>'.join([<EOL>'<STR_LIT>',<EOL>'<STR_LIT>']))<EOL>mlp_file.close()<EOL>if mlp_mesh is not None:<EOL><INDENT>mlp_file = open(file_out, '<STR_LIT:a>')<EOL>mlp_file.write('<STR_LIT>')<EOL>for i, val in enumerate(mlp_mesh):<EOL><INDENT>if '<STR_LIT:label>' not in mlp_mesh[i]:<EOL><INDENT>mlp_mesh[i]['<STR_LIT:label>'] = mlp_mesh[i]['<STR_LIT:filename>']<EOL><DEDENT>if '<STR_LIT>' not in mlp_mesh[i]:<EOL><INDENT>mlp_mesh[i]['<STR_LIT>'] = [[<NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>], [<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>], [<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>], [<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>]]<EOL><DEDENT>mlp_file.write('<STR_LIT>'.format(mlp_mesh[i]['<STR_LIT:filename>'], mlp_mesh[i]['<STR_LIT:label>']))<EOL>mlp_file.write('<STR_LIT:\\n>'.join([<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(m=mlp_mesh[i]['<STR_LIT>'][<NUM_LIT:0>]),<EOL>'<STR_LIT>'.format(m=mlp_mesh[i]['<STR_LIT>'][<NUM_LIT:1>]),<EOL>'<STR_LIT>'.format(m=mlp_mesh[i]['<STR_LIT>'][<NUM_LIT:2>]),<EOL>'<STR_LIT>'.format(m=mlp_mesh[i]['<STR_LIT>'][<NUM_LIT:3>]),<EOL>'<STR_LIT>',<EOL>'<STR_LIT>']))<EOL><DEDENT>mlp_file.write('<STR_LIT>')<EOL>mlp_file.close()<EOL><DEDENT>else:<EOL><INDENT>mlp_file = open(file_out, '<STR_LIT:a>')<EOL>mlp_file.write('<STR_LIT>')<EOL>mlp_file.close()<EOL><DEDENT>if mlp_raster is not None:<EOL><INDENT>mlp_file = open(file_out, '<STR_LIT:a>')<EOL>mlp_file.write('<STR_LIT>')<EOL>for i, val in enumerate(mlp_raster):<EOL><INDENT>if '<STR_LIT:label>' not in mlp_raster[i]:<EOL><INDENT>mlp_raster[i]['<STR_LIT:label>'] = mlp_raster[i]['<STR_LIT:filename>']<EOL><DEDENT>if '<STR_LIT>' not in mlp_raster[i]:<EOL><INDENT>mlp_raster[i]['<STR_LIT>'] = <NUM_LIT:1><EOL><DEDENT>if '<STR_LIT>' not in mlp_raster[i]['<STR_LIT>']:<EOL><INDENT>mlp_raster[i]['<STR_LIT>']['<STR_LIT>'] = [<NUM_LIT:0>, <NUM_LIT:0>]<EOL><DEDENT>if '<STR_LIT>' not in mlp_raster[i]['<STR_LIT>']:<EOL><INDENT>mlp_raster[i]['<STR_LIT>']['<STR_LIT>'] = [int(mlp_raster[i]['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:0>]/<NUM_LIT:2>), int(mlp_raster[i]['<STR_LIT>']['<STR_LIT>'][<NUM_LIT:1>]/<NUM_LIT:2>)]<EOL><DEDENT>mlp_file.write('<STR_LIT>'.format(mlp_raster[i]['<STR_LIT:label>']))<EOL>mlp_file.write('<STR_LIT:U+0020>'.join([<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'.format(m=mlp_raster[i]['<STR_LIT>']['<STR_LIT>']),<EOL>'<STR_LIT>'.format(m=mlp_raster[i]['<STR_LIT>']['<STR_LIT>']),<EOL>'<STR_LIT>'.format(mlp_raster[i]['<STR_LIT>']['<STR_LIT>']),<EOL>'<STR_LIT>'.format(m=mlp_raster[i]['<STR_LIT>']['<STR_LIT>']),<EOL>'<STR_LIT>'.format(m=mlp_raster[i]['<STR_LIT>']['<STR_LIT>']),<EOL>'<STR_LIT>'.format(m=mlp_raster[i]['<STR_LIT>']['<STR_LIT>']),<EOL>'<STR_LIT>'.format(m=mlp_raster[i]['<STR_LIT>']['<STR_LIT>']),<EOL>'<STR_LIT>']))<EOL>mlp_file.write('<STR_LIT>'.format(mlp_raster[i]['<STR_LIT>'], mlp_raster[i]['<STR_LIT:filename>']))<EOL>mlp_file.write('<STR_LIT>')<EOL><DEDENT>mlp_file.write('<STR_LIT>')<EOL>mlp_file.close()<EOL><DEDENT>else:<EOL><INDENT>mlp_file = open(file_out, '<STR_LIT:a>')<EOL>mlp_file.write('<STR_LIT>')<EOL>mlp_file.close()<EOL><DEDENT>mlp_file = open(file_out, '<STR_LIT:a>')<EOL>mlp_file.write('<STR_LIT>')<EOL>mlp_file.close()<EOL>return<EOL>", "docstring": "Create mlp file\n    mlp_mesh (list containing dictionary)\n        filename*\n        label\n        matrix\n\n    mlp_raster\n        filename*\n        label\n        semantic\n        camera\n            trans_vector*\n            rotation_matrix*\n            focal_length*\n            image_px*\n            image_res_mm_per_px*\n            lens_distortion\n            center_px\n    * Required\n\n    http://vcg.isti.cnr.it/~cignoni/newvcglib/html/shot.html", "id": "f9661:m6"}
{"signature": "def add_layer(self, label, change_layer=True):", "body": "self.layer_stack.insert(self.last_layer() + <NUM_LIT:1>, label)<EOL>if change_layer:<EOL><INDENT>self.set_current_layer(self.last_layer())<EOL><DEDENT>return None<EOL>", "docstring": "Add new mesh layer to the end of the stack\n\n        Args:\n            label (str): new label for the mesh layer\n            change_layer (bool): change to the newly created layer", "id": "f9661:c0:m4"}
{"signature": "def default_output_mask(file_out, texture=True, vert_normals=True, vert_colors=False,<EOL>face_colors=False, ml_version=ML_VERSION):", "body": "vn = '<STR_LIT>'<EOL>wt = '<STR_LIT>'<EOL>vc = '<STR_LIT>'<EOL>fc = '<STR_LIT>'<EOL>if ml_version < '<STR_LIT>':<EOL><INDENT>om = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>om = '<STR_LIT>'<EOL><DEDENT>fext = os.path.splitext(file_out)[<NUM_LIT:1>][<NUM_LIT:1>:].strip().lower()<EOL>if fext in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>om = '<STR_LIT>'<EOL>texture = False<EOL>vert_normals = False<EOL>vert_colors = False<EOL>face_colors = False<EOL>", "docstring": "Set default output mask options based on file extension\nNote: v1.34BETA changed -om switch to -m\nPossible options (not all options are available for every format):\n vc -> vertex colors\n vf -> vertex flags\n vq -> vertex quality\n vn -> vertex normals\n vt -> vertex texture coords\n fc -> face colors\n ff -> face flags\n fq -> face quality\n fn -> face normals\n wc -> wedge colors\n wn -> wedge normals\n wt -> wedge texture coords", "id": "f9661:m3"}
{"signature": "def install_npm(path=None, build_dir=None, source_dir=None, build_cmd='<STR_LIT>', force=False, npm=None):", "body": "class NPM(BaseCommand):<EOL><INDENT>description = '<STR_LIT>'<EOL>def run(self):<EOL><INDENT>if skip_npm:<EOL><INDENT>log.info('<STR_LIT>')<EOL>return<EOL><DEDENT>node_package = path or HERE<EOL>node_modules = pjoin(node_package, '<STR_LIT>')<EOL>is_yarn = os.path.exists(pjoin(node_package, '<STR_LIT>'))<EOL>npm_cmd = npm<EOL>if npm is None:<EOL><INDENT>if is_yarn:<EOL><INDENT>npm_cmd = ['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>npm_cmd = ['<STR_LIT>']<EOL><DEDENT><DEDENT>if not which(npm_cmd[<NUM_LIT:0>]):<EOL><INDENT>log.error(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>.format(npm_cmd[<NUM_LIT:0>]))<EOL>return<EOL><DEDENT>if force or is_stale(node_modules, pjoin(node_package, '<STR_LIT>')):<EOL><INDENT>log.info('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>run(npm_cmd + ['<STR_LIT>'], cwd=node_package)<EOL><DEDENT>if build_dir and source_dir and not force:<EOL><INDENT>should_build = is_stale(build_dir, source_dir)<EOL><DEDENT>else:<EOL><INDENT>should_build = True<EOL><DEDENT>if should_build:<EOL><INDENT>run(npm_cmd + ['<STR_LIT>', build_cmd], cwd=node_package)<EOL><DEDENT><DEDENT><DEDENT>return NPM<EOL>", "docstring": "Return a Command for managing an npm installation.\n\n    Note: The command is skipped if the `--skip-npm` flag is used.\n\n    Parameters\n    ----------\n    path: str, optional\n        The base path of the node package.  Defaults to the repo root.\n    build_dir: str, optional\n        The target build directory.  If this and source_dir are given,\n        the JavaScript will only be build if necessary.\n    source_dir: str, optional\n        The source code directory.\n    build_cmd: str, optional\n        The npm command to build assets to the build_dir.\n    npm: str or list, optional.\n        The npm executable name, or a tuple of ['node', executable].", "id": "f9671:m12"}
{"signature": "def get_version(file, name='<STR_LIT>'):", "body": "path = os.path.realpath(file)<EOL>version_ns = {}<EOL>with io.open(path, encoding=\"<STR_LIT:utf8>\") as f:<EOL><INDENT>exec(f.read(), {}, version_ns)<EOL><DEDENT>return version_ns[name]<EOL>", "docstring": "Get the version of the package from the given file by\n    executing it and extracting the given `name`.", "id": "f9671:m0"}
{"signature": "def combine_commands(*commands):", "body": "class CombinedCommand(Command):<EOL><INDENT>user_options = []<EOL>def initialize_options(self):<EOL><INDENT>self.commands = []<EOL>for C in commands:<EOL><INDENT>self.commands.append(C(self.distribution))<EOL><DEDENT>for c in self.commands:<EOL><INDENT>c.initialize_options()<EOL><DEDENT><DEDENT>def finalize_options(self):<EOL><INDENT>for c in self.commands:<EOL><INDENT>c.finalize_options()<EOL><DEDENT><DEDENT>def run(self):<EOL><INDENT>for c in self.commands:<EOL><INDENT>c.run()<EOL><DEDENT><DEDENT><DEDENT>return CombinedCommand<EOL>", "docstring": "Return a Command that combines several commands.", "id": "f9671:m8"}
{"signature": "def create_cmdclass(prerelease_cmd=None, package_data_spec=None,<EOL>data_files_spec=None):", "body": "wrapped = [prerelease_cmd] if prerelease_cmd else []<EOL>if package_data_spec or data_files_spec:<EOL><INDENT>wrapped.append('<STR_LIT>')<EOL><DEDENT>wrapper = functools.partial(_wrap_command, wrapped)<EOL>handle_files = _get_file_handler(package_data_spec, data_files_spec)<EOL>if '<STR_LIT>' in sys.argv:<EOL><INDENT>egg = wrapper(bdist_egg, strict=True)<EOL><DEDENT>else:<EOL><INDENT>egg = bdist_egg_disabled<EOL><DEDENT>cmdclass = dict(<EOL>build_py=wrapper(build_py, strict=is_repo),<EOL>bdist_egg=egg,<EOL>sdist=wrapper(sdist, strict=True),<EOL>handle_files=handle_files,<EOL>)<EOL>if bdist_wheel:<EOL><INDENT>cmdclass['<STR_LIT>'] = wrapper(bdist_wheel, strict=True)<EOL><DEDENT>cmdclass['<STR_LIT>'] = wrapper(develop, strict=True)<EOL>return cmdclass<EOL>", "docstring": "Create a command class with the given optional prerelease class.\n\n    Parameters\n    ----------\n    prerelease_cmd: (name, Command) tuple, optional\n        The command to run before releasing.\n    package_data_spec: dict, optional\n        A dictionary whose keys are the dotted package names and\n        whose values are a list of glob patterns.\n    data_files_spec: list, optional\n        A list of (path, dname, pattern) tuples where the path is the\n        `data_files` install path, dname is the source directory, and the\n        pattern is a glob pattern.\n\n    Notes\n    -----\n    We use specs so that we can find the files *after* the build\n    command has run.\n\n    The package data glob patterns should be relative paths from the package\n    folder containing the __init__.py file, which is given as the package\n    name.\n    e.g. `dict(foo=['./bar/*', './baz/**'])`\n\n    The data files directories should be absolute paths or relative paths\n    from the root directory of the repository.  Data files are specified\n    differently from `package_data` because we need a separate path entry\n    for each nested folder in `data_files`, and this makes it easier to\n    parse.\n    e.g. `('share/foo/bar', 'pkgname/bizz, '*')`", "id": "f9671:m4"}
{"signature": "def find_packages(top=HERE):", "body": "packages = []<EOL>for d, dirs, _ in os.walk(top, followlinks=True):<EOL><INDENT>if os.path.exists(pjoin(d, '<STR_LIT>')):<EOL><INDENT>packages.append(os.path.relpath(d, top).replace(os.path.sep, '<STR_LIT:.>'))<EOL><DEDENT>elif d != top:<EOL><INDENT>dirs[:] = []<EOL><DEDENT><DEDENT>return packages<EOL>", "docstring": "Find all of the packages.", "id": "f9671:m2"}
{"signature": "def _join_translated(translated_parts, os_sep_class):", "body": "res = '<STR_LIT>'<EOL>for part in translated_parts[:-<NUM_LIT:1>]:<EOL><INDENT>if part == '<STR_LIT>':<EOL><INDENT>res += part<EOL><DEDENT>else:<EOL><INDENT>res += part + os_sep_class<EOL><DEDENT><DEDENT>if translated_parts[-<NUM_LIT:1>] == '<STR_LIT>':<EOL><INDENT>res += '<STR_LIT>'<EOL>res += '<STR_LIT>'.format(os_sep_class=os_sep_class)<EOL><DEDENT>else:<EOL><INDENT>res += translated_parts[-<NUM_LIT:1>]<EOL><DEDENT>return res<EOL>", "docstring": "Join translated glob pattern parts.\n\n    This is different from a simple join, as care need to be taken\n    to allow ** to match ZERO or more directories.", "id": "f9671:m23"}
{"signature": "def ensure_targets(targets):", "body": "class TargetsCheck(BaseCommand):<EOL><INDENT>def run(self):<EOL><INDENT>if skip_npm:<EOL><INDENT>log.info('<STR_LIT>')<EOL>return<EOL><DEDENT>missing = [t for t in targets if not os.path.exists(t)]<EOL>if missing:<EOL><INDENT>raise ValueError(('<STR_LIT>' % missing))<EOL><DEDENT><DEDENT><DEDENT>return TargetsCheck<EOL>", "docstring": "Return a Command that checks that certain files exist.\n\n    Raises a ValueError if any of the files are missing.\n\n    Note: The check is skipped if the `--skip-npm` flag is used.", "id": "f9671:m13"}
{"signature": "def _iexplode_path(path):", "body": "(head, tail) = os.path.split(path)<EOL>if not head or (not tail and head == path):<EOL><INDENT>if head:<EOL><INDENT>yield head<EOL><DEDENT>if tail or not head:<EOL><INDENT>yield tail<EOL><DEDENT>return<EOL><DEDENT>for p in _iexplode_path(head):<EOL><INDENT>yield p<EOL><DEDENT>yield tail<EOL>", "docstring": "Iterate over all the parts of a path.\n\n    Splits path recursively with os.path.split().", "id": "f9671:m21"}
{"signature": "def compare_recursive_mtime(path, cutoff, newest=True):", "body": "if os.path.isfile(path):<EOL><INDENT>mt = mtime(path)<EOL>if newest:<EOL><INDENT>if mt > cutoff:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>elif mt < cutoff:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>for dirname, _, filenames in os.walk(path, topdown=False):<EOL><INDENT>for filename in filenames:<EOL><INDENT>mt = mtime(pjoin(dirname, filename))<EOL>if newest:  <EOL><INDENT>if mt > cutoff:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>elif mt < cutoff:<EOL><INDENT>return True<EOL><DEDENT><DEDENT><DEDENT>return False<EOL>", "docstring": "Compare the newest/oldest mtime for all files in a directory.\n\n    Cutoff should be another mtime to be compared against. If an mtime that is\n    newer/older than the cutoff is found it will return True.\n    E.g. if newest=True, and a file in path is newer than the cutoff, it will\n    return True.", "id": "f9671:m9"}
{"signature": "def _get_files(file_patterns, top=HERE):", "body": "if not isinstance(file_patterns, (list, tuple)):<EOL><INDENT>file_patterns = [file_patterns]<EOL><DEDENT>for i, p in enumerate(file_patterns):<EOL><INDENT>if os.path.isabs(p):<EOL><INDENT>file_patterns[i] = os.path.relpath(p, top)<EOL><DEDENT><DEDENT>matchers = [_compile_pattern(p) for p in file_patterns]<EOL>files = set()<EOL>for root, dirnames, filenames in os.walk(top):<EOL><INDENT>if '<STR_LIT>' in dirnames:<EOL><INDENT>dirnames.remove('<STR_LIT>')<EOL><DEDENT>for m in matchers:<EOL><INDENT>for filename in filenames:<EOL><INDENT>fn = os.path.relpath(pjoin(root, filename), top)<EOL>if m(fn):<EOL><INDENT>files.add(fn.replace(os.sep, '<STR_LIT:/>'))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return list(files)<EOL>", "docstring": "Expand file patterns to a list of paths.\n\n    Parameters\n    -----------\n    file_patterns: list or str\n        A list of glob patterns for the data file locations.\n        The globs can be recursive if they include a `**`.\n        They should be relative paths from the top directory or\n        absolute paths.\n    top: str\n        the directory to consider for data files\n\n    Note:\n    Files in `node_modules` are ignored.", "id": "f9671:m18"}
{"signature": "def which(cmd, mode=os.F_OK | os.X_OK, path=None):", "body": "<EOL>def _access_check(fn, mode):<EOL><INDENT>return (os.path.exists(fn) and os.access(fn, mode) and<EOL>not os.path.isdir(fn))<EOL><DEDENT>if _access_check(cmd, mode):<EOL><INDENT>return cmd<EOL><DEDENT>path = (path or os.environ.get(\"<STR_LIT>\", os.defpath)).split(os.pathsep)<EOL>if sys.platform == \"<STR_LIT:win32>\":<EOL><INDENT>if os.curdir not in path:<EOL><INDENT>path.insert(<NUM_LIT:0>, os.curdir)<EOL><DEDENT>pathext = os.environ.get(\"<STR_LIT>\", \"<STR_LIT>\").split(os.pathsep)<EOL>matches = [cmd for ext in pathext if cmd.lower().endswith(ext.lower())]<EOL>files = [cmd] if matches else [cmd + ext.lower() for ext in pathext]<EOL><DEDENT>else:<EOL><INDENT>files = [cmd]<EOL><DEDENT>seen = set()<EOL>for dir in path:<EOL><INDENT>dir = os.path.normcase(dir)<EOL>if dir not in seen:<EOL><INDENT>seen.add(dir)<EOL>for thefile in files:<EOL><INDENT>name = os.path.join(dir, thefile)<EOL>if _access_check(name, mode):<EOL><INDENT>return name<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return None<EOL>", "docstring": "Given a command, mode, and a PATH string, return the path which\n    conforms to the given mode on the PATH, or None if there is no such\n    file.\n    `mode` defaults to os.F_OK | os.X_OK. `path` defaults to the result\n    of os.environ.get(\"PATH\"), or can be overridden with a custom search\n    path.", "id": "f9671:m14"}
{"signature": "def _get_package_data(root, file_patterns=None):", "body": "if file_patterns is None:<EOL><INDENT>file_patterns = ['<STR_LIT:*>']<EOL><DEDENT>return _get_files(file_patterns, pjoin(HERE, root))<EOL>", "docstring": "Expand file patterns to a list of `package_data` paths.\n\n    Parameters\n    -----------\n    root: str\n        The relative path to the package root from `HERE`.\n    file_patterns: list or str, optional\n        A list of glob patterns for the data file locations.\n        The globs can be recursive if they include a `**`.\n        They should be relative paths from the root or\n        absolute paths.  If not given, all files will be used.\n\n    Note:\n    Files in `node_modules` are ignored.", "id": "f9671:m19"}
{"signature": "def _translate_glob(pat):", "body": "translated_parts = []<EOL>for part in _iexplode_path(pat):<EOL><INDENT>translated_parts.append(_translate_glob_part(part))<EOL><DEDENT>os_sep_class = '<STR_LIT>' % re.escape(SEPARATORS)<EOL>res = _join_translated(translated_parts, os_sep_class)<EOL>return '<STR_LIT>'.format(res=res)<EOL>", "docstring": "Translate a glob PATTERN to a regular expression.", "id": "f9671:m22"}
{"signature": "def img_from_vgg(x):", "body": "x = x.transpose((<NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:0>))<EOL>x[:, :, <NUM_LIT:0>] += <NUM_LIT><EOL>x[:, :, <NUM_LIT:1>] += <NUM_LIT><EOL>x[:, :, <NUM_LIT:2>] += <NUM_LIT><EOL>x = x[:,:,::-<NUM_LIT:1>]  <EOL>return x<EOL>", "docstring": "Decondition an image from the VGG16 model.", "id": "f9677:m0"}
{"signature": "def get(value):", "body": "if not isinstance(value, Token):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if not hasattr(value, '<STR_LIT>'):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if not value.identifier:<EOL><INDENT>value = value.__class__(**value.__dict__)<EOL>value.identifier = '<STR_LIT:v>'<EOL><DEDENT>ident = Identifier(value.identifier)<EOL>return Query([<EOL>Match(value),<EOL>Return(ident)<EOL>])<EOL>", "docstring": "Query to get the value.", "id": "f9687:m1"}
{"signature": "def range(self, index, *args):", "body": "self.data['<STR_LIT>'].append('<STR_LIT>'%(index,<EOL>'<STR_LIT:U+002C>'.join(map(smart_str, args))))<EOL>return self.parent<EOL>", "docstring": "Set the range of each axis, one at a time\nargs are of the form <start of range>,<end of range>,<interval>\nAPIPARAM: chxr", "id": "f9693:c0:m6"}
{"signature": "def save(self, fname=None):", "body": "if not fname:<EOL><INDENT>fname = self.getname()<EOL><DEDENT>assert fname != None, '<STR_LIT>'<EOL>if not fname.endswith('<STR_LIT>'):<EOL><INDENT>fname += '<STR_LIT>'<EOL><DEDENT>try:<EOL><INDENT>urlretrieve(self.url, fname)<EOL><DEDENT>except Exception:<EOL><INDENT>raise IOError('<STR_LIT>'%fname)<EOL><DEDENT>return fname<EOL>", "docstring": "Download the chart from the URL into a filename as a PNG\n\nThe filename defaults to the chart title (chtt) if any", "id": "f9693:c1:m32"}
{"signature": "def level_data(self, *args):", "body": "assert args[<NUM_LIT:0>].lower() in '<STR_LIT>', '<STR_LIT>'%level<EOL>self['<STR_LIT>'] = '<STR_LIT>'%args<EOL>return self<EOL>", "docstring": "Just used in QRCode for the moment\nargs are error_correction,margin_size\nAPIPARAM: chld", "id": "f9693:c1:m3"}
{"signature": "def scale(self, *args):", "body": "self._scale =  ['<STR_LIT:U+002C>'.join(map(smart_str, args))]<EOL>return self<EOL>", "docstring": "Scales the data down to the given size\nargs must be of the form::\n    <data set 1 minimum value>,\n    <data set 1 maximum value>,\n    <data set n minimum value>,\n    <data set n maximum value>\nwill only work with text encoding!\nAPIPARAM: chds", "id": "f9693:c1:m7"}
{"signature": "def label(self, index, *args):", "body": "self.data['<STR_LIT>'].append(<EOL>str('<STR_LIT>'%(index, '<STR_LIT:|>'.join(map(str,args)) )).replace('<STR_LIT:None>','<STR_LIT>')<EOL>)<EOL>return self.parent<EOL>", "docstring": "Label each axes one at a time\nargs are of the form <label 1>,...,<label n>\nAPIPARAM: chxl", "id": "f9693:c0:m4"}
{"signature": "def output_encoding(self, encoding):", "body": "assert encoding in ('<STR_LIT>','<STR_LIT>','<STR_LIT>'),'<STR_LIT>'%encoding<EOL>self['<STR_LIT>'] = encoding<EOL>return self<EOL>", "docstring": "Output encoding to use for QRCode encoding\nMust be one of 'Shift_JIS','UTF-8', or 'ISO-8859-1'\nAPIPARAM: choe", "id": "f9693:c1:m6"}
{"signature": "def render(self):", "body": "for opt,values in self.data.items():<EOL><INDENT>if opt == '<STR_LIT>':<EOL><INDENT>self['<STR_LIT>'] = '<STR_LIT:|>'.join(values)<EOL><DEDENT>else:<EOL><INDENT>self['<STR_LIT>'%opt[<NUM_LIT:0>]] = '<STR_LIT:|>'.join(values)<EOL><DEDENT><DEDENT>return self<EOL>", "docstring": "Render the axes data into the dict data", "id": "f9693:c0:m8"}
{"signature": "def grid(self, *args):", "body": "grids =  map(str,map(float,args))<EOL>self['<STR_LIT>'] = '<STR_LIT:U+002C>'.join(grids).replace('<STR_LIT:None>','<STR_LIT>')<EOL>return self<EOL>", "docstring": "Apply a grid to your chart\nargs are of the form::\n    <x axis step size>,\n    <y axis step size>,\n    <length of line segment>,\n    <length of blank segment>\n    <x offset>,\n    <y offset>\nAPIPARAM: chg", "id": "f9693:c1:m13"}
{"signature": "def style(self, index, *args):", "body": "args = color_args(args, <NUM_LIT:0>)<EOL>self.data['<STR_LIT>'].append(<EOL>'<STR_LIT:U+002C>'.join([str(index)]+list(map(str,args)))<EOL>)<EOL>return self.parent<EOL>", "docstring": "Add style to your axis, one at a time\nargs are of the form::\n    <axis color>,\n    <font size>,\n    <alignment>,\n    <drawing control>,\n    <tick mark color>\nAPIPARAM: chxs", "id": "f9693:c0:m7"}
{"signature": "def type(self, type):", "body": "self['<STR_LIT>'] = self.check_type(str(type))<EOL>return self<EOL>", "docstring": "Set the chart type, either Google API type or regular name\nAPIPARAM: cht", "id": "f9693:c1:m15"}
{"signature": "def check_type(self, type):", "body": "if type in TYPES:<EOL><INDENT>return type<EOL><DEDENT>tdict = dict(zip(TYPES,TYPES))<EOL>tdict.update({<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:bar>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT:p>',<EOL>'<STR_LIT>': '<STR_LIT:v>',<EOL>'<STR_LIT>': '<STR_LIT:s>',<EOL>'<STR_LIT>': '<STR_LIT:r>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>})<EOL>assert type in tdict, '<STR_LIT>'%type<EOL>return tdict[type]<EOL>", "docstring": "Check to see if the type is either in TYPES or fits type name\n\n        Returns proper type", "id": "f9693:c1:m24"}
{"signature": "def dataset(self, data, series='<STR_LIT>'):", "body": "self._dataset = data<EOL>self._series = series<EOL>return self<EOL>", "docstring": "Update the chart's dataset, can be two dimensional or contain string data", "id": "f9693:c1:m8"}
{"signature": "def _chart_support(self, *args, **kwargs):", "body": "print(args,kwargs)<EOL>return '<STR_LIT>'<EOL>", "docstring": "Helper callback.", "id": "f9703:c0:m1"}
{"signature": "def graph_coloring_qubo(graph, k):", "body": "K = nx.complete_graph(k)<EOL>g1 = nx.cartesian_product(nx.create_empty_copy(graph), K)<EOL>g2 = nx.cartesian_product(graph, nx.create_empty_copy(K))<EOL>return nx.compose(g1, g2)<EOL>", "docstring": "the QUBO for k-coloring a graph A is as follows:\n\nvariables:\nx_{v,c} = 1 if vertex v of A gets color c; x_{v,c} = 0 otherwise\n\nconstraints:\n1)  each v in A gets exactly one color.\n   This constraint is enforced by including the term (\\sum_c x_{v,c} - 1)^2 in the QUBO,\n   which is minimized when \\sum_c x_{v,c} = 1.\n\n2) If u and v in A are adjacent, then they get different colors.\n   This constraint is enforced by including terms x_{v,c} x_{u,c} in the QUBO,\n   which is minimzed when at most one of u and v get color c.\n\nTotal QUBO:\nQ(x) = \\sum_v (\\sum_c x_{v,c} - 1)^2  + \\sum_{u ~ v} \\sum_c x_{v,c} x_{u,c}\n\nThe graph of interactions for this QUBO consists of cliques of size k (with vertices {x_{v,c} for c = 0,...,k-1})\nplus k disjoint copies of the graph A (one for each color).", "id": "f9720:m0"}
{"signature": "def ecom_course_data(self, course_id):", "body": "return {<EOL>\"<STR_LIT:id>\": course_id,<EOL>\"<STR_LIT:url>\": \"<STR_LIT>\".format(course_id),<EOL>\"<STR_LIT:name>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:type>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\".format(course_id),<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>}<EOL>", "docstring": "Returns dummy course data.", "id": "f9725:c2:m2"}
{"signature": "def mock_api_response(self, status, body):", "body": "httpretty.register_uri(<EOL>httpretty.POST,<EOL>'<STR_LIT>',<EOL>status=status,<EOL>body=json.dumps(body),<EOL>content_type='<STR_LIT:application/json>'<EOL>)<EOL>", "docstring": "Mock the Sailthru send API.", "id": "f9725:c3:m1"}
{"signature": "def get_error_code(self):", "body": "return self.code<EOL>", "docstring": "Get error code", "id": "f9725:c1:m2"}
{"signature": "def get_error(self):", "body": "return MockSailthruError(self.error, self.code)<EOL>", "docstring": "Get error description", "id": "f9725:c0:m2"}
{"signature": "def assert_get_sailthru_client_raises(self, exc_class, config):", "body": "overrides = {<EOL>self.SITE_CODE: {<EOL>'<STR_LIT>': config<EOL>}<EOL>}<EOL>with mock.patch.dict(self.SITE_OVERRIDES_MODULE, overrides):<EOL><INDENT>with self.assertRaises(exc_class):<EOL><INDENT>get_sailthru_client(self.SITE_CODE)<EOL><DEDENT><DEDENT>", "docstring": "Asserts an error is raised by a call to get_sailthru_client.", "id": "f9726:c0:m0"}
{"signature": "def _update_unenrolled_list(sailthru_client, email, course_url, unenroll):", "body": "try:<EOL><INDENT>sailthru_response = sailthru_client.api_get(\"<STR_LIT:user>\", {\"<STR_LIT:id>\": email, \"<STR_LIT>\": {\"<STR_LIT>\": <NUM_LIT:1>}})<EOL>if not sailthru_response.is_ok():<EOL><INDENT>error = sailthru_response.get_error()<EOL>logger.error(\"<STR_LIT>\", error.get_message())<EOL>return not can_retry_sailthru_request(error)<EOL><DEDENT>response_json = sailthru_response.json<EOL>unenroll_list = []<EOL>if response_json and \"<STR_LIT>\" in response_json and response_json[\"<STR_LIT>\"]and \"<STR_LIT>\" in response_json[\"<STR_LIT>\"]:<EOL><INDENT>unenroll_list = response_json[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL><DEDENT>changed = False<EOL>if unenroll:<EOL><INDENT>if course_url not in unenroll_list:<EOL><INDENT>unenroll_list.append(course_url)<EOL>changed = True<EOL><DEDENT><DEDENT>elif course_url in unenroll_list:<EOL><INDENT>unenroll_list.remove(course_url)<EOL>changed = True<EOL><DEDENT>if changed:<EOL><INDENT>sailthru_response = sailthru_client.api_post(<EOL>'<STR_LIT:user>', {'<STR_LIT:id>': email, '<STR_LIT:key>': '<STR_LIT:email>', '<STR_LIT>': {'<STR_LIT>': unenroll_list}})<EOL>if not sailthru_response.is_ok():<EOL><INDENT>error = sailthru_response.get_error()<EOL>logger.error(\"<STR_LIT>\", error.get_message())<EOL>return not can_retry_sailthru_request(error)<EOL><DEDENT><DEDENT>return True<EOL><DEDENT>except SailthruClientError as exc:<EOL><INDENT>logger.exception(\"<STR_LIT>\", email, text_type(exc))<EOL>return False<EOL><DEDENT>", "docstring": "Maintain a list of courses the user has unenrolled from in the Sailthru user record\n\n    Arguments:\n        sailthru_client (object): SailthruClient\n        email (str): user's email address\n        course_url (str): LMS url for course info page.\n        unenroll (boolean): True if unenrolling, False if enrolling\n\n    Returns:\n        False if retryable error, else True", "id": "f9727:m5"}
{"signature": "def _send_offer_assignment_notification_email(config, user_email, subject, email_body, site_code, task):", "body": "try:<EOL><INDENT>sailthru_client = get_sailthru_client(site_code)<EOL><DEDENT>except SailthruError:<EOL><INDENT>logger.exception(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(message=email_body)<EOL>)<EOL>return None<EOL><DEDENT>email_vars = {<EOL>'<STR_LIT>': subject,<EOL>'<STR_LIT>': email_body,<EOL>}<EOL>try:<EOL><INDENT>response = sailthru_client.send(<EOL>template=config['<STR_LIT>']['<STR_LIT>'],<EOL>email=user_email,<EOL>_vars=email_vars<EOL>)<EOL><DEDENT>except SailthruClientError:<EOL><INDENT>logger.exception(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(message=email_body)<EOL>)<EOL>return None<EOL><DEDENT>if not response.is_ok():<EOL><INDENT>error = response.get_error()<EOL>logger.error(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>message=email_body,<EOL>token_error_code=error.get_error_code(),<EOL>token_error_message=error.get_message()<EOL>)<EOL>)<EOL>if can_retry_sailthru_request(error):<EOL><INDENT>logger.info(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(message=email_body)<EOL>)<EOL>schedule_retry(task, config)<EOL><DEDENT>else:<EOL><INDENT>logger.warning(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(message=email_body)<EOL>)<EOL><DEDENT><DEDENT>return response<EOL>", "docstring": "Handles sending offer assignment notification emails and retrying failed emails when appropriate.", "id": "f9727:m10"}
{"signature": "def _get_course_content(course_id, course_url, sailthru_client, site_code, config):", "body": "<EOL>cache_key = \"<STR_LIT>\".format(site_code, course_url)<EOL>response = cache.get(cache_key)<EOL>if not response:<EOL><INDENT>try:<EOL><INDENT>sailthru_response = sailthru_client.api_get(\"<STR_LIT:content>\", {\"<STR_LIT:id>\": course_url})<EOL>if not sailthru_response.is_ok():<EOL><INDENT>response = {}<EOL><DEDENT>else:<EOL><INDENT>response = sailthru_response.json<EOL>cache.set(cache_key, response, config.get('<STR_LIT>'))<EOL><DEDENT><DEDENT>except SailthruClientError:<EOL><INDENT>response = {}<EOL><DEDENT>if not response:<EOL><INDENT>logger.error('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>response = _get_course_content_from_ecommerce(course_id, site_code=site_code)<EOL>if response:<EOL><INDENT>cache.set(cache_key, response, config.get('<STR_LIT>'))<EOL><DEDENT><DEDENT><DEDENT>return response<EOL>", "docstring": "Get course information using the Sailthru content api or from cache.\n\n    If there is an error, just return with an empty response.\n\n    Arguments:\n        course_id (str): course key of the course\n        course_url (str): LMS url for course info page.\n        sailthru_client (object): SailthruClient\n        site_code (str): site code\n        config (dict): config options\n\n    Returns:\n        course information from Sailthru", "id": "f9727:m3"}
{"signature": "def _get_course_content_from_ecommerce(course_id, site_code=None):", "body": "api = get_ecommerce_client(site_code=site_code)<EOL>try:<EOL><INDENT>api_response = api.courses(course_id).get()<EOL><DEDENT>except Exception:  <EOL><INDENT>logger.exception(<EOL>'<STR_LIT>',<EOL>course_id,<EOL>exc_info=True<EOL>)<EOL>return {}<EOL><DEDENT>return {<EOL>'<STR_LIT:title>': api_response.get('<STR_LIT:name>'),<EOL>'<STR_LIT>': api_response.get('<STR_LIT>')<EOL>}<EOL>", "docstring": "Get course information using the Ecommerce course api.\n\nIn case of error returns empty response.\nArguments:\n    course_id (str): course key of the course\n    site_code (str): site code\n\nReturns:\n    course information from Ecommerce", "id": "f9727:m4"}
{"signature": "def get_sailthru_client(site_code):", "body": "<EOL>config = get_sailthru_configuration(site_code)<EOL>if not config.get('<STR_LIT>'):<EOL><INDENT>msg = '<STR_LIT>'.format(site_code)<EOL>log.debug(msg)<EOL>raise SailthruNotEnabled(msg)<EOL><DEDENT>key = config.get('<STR_LIT>')<EOL>secret = config.get('<STR_LIT>')<EOL>if not (key and secret):<EOL><INDENT>msg = '<STR_LIT>'.format(site_code)<EOL>log.error(msg)<EOL>raise ConfigurationError(msg)<EOL><DEDENT>return SailthruClient(key, secret)<EOL>", "docstring": "Returns a Sailthru client for the specified site.\n\nArgs:\n    site_code (str): Site for which the client should be configured.\n\nReturns:\n    SailthruClient\n\nRaises:\n    SailthruNotEnabled: If Sailthru is not enabled for the specified site.\n    ConfigurationError: If either the Sailthru API key or secret are not set for the site.", "id": "f9728:m1"}
{"signature": "def get_sailthru_configuration(site_code):", "body": "config = get_configuration('<STR_LIT>', site_code=site_code)<EOL>return config<EOL>", "docstring": "Returns the Sailthru configuration for the specified site.", "id": "f9728:m0"}
{"signature": "def _retry_order(self, exception, max_fulfillment_retries, order_number):", "body": "retries = self.request.retries<EOL>if retries == max_fulfillment_retries:<EOL><INDENT>logger.exception('<STR_LIT>', order_number)<EOL><DEDENT>else:<EOL><INDENT>logger.warning('<STR_LIT>', order_number)<EOL><DEDENT>countdown = <NUM_LIT:2> ** retries<EOL>raise self.retry(exc=exception, countdown=countdown, max_retries=max_fulfillment_retries)<EOL>", "docstring": "Retry with exponential backoff until fulfillment\nsucceeds or the retry limit is reached. If the retry limit is exceeded,\nthe exception is re-raised.", "id": "f9735:m0"}
{"signature": "def get_overrides_filename(variable):", "body": "filename = os.environ.get(variable)<EOL>if filename is None:<EOL><INDENT>msg = '<STR_LIT>'.format(variable)<EOL>raise EnvironmentError(msg)<EOL><DEDENT>return filename<EOL>", "docstring": "Get the name of the file containing configuration overrides\nfrom the provided environment variable.", "id": "f9739:m0"}
{"signature": "def get_logger_config(log_dir='<STR_LIT>',<EOL>logging_env='<STR_LIT>',<EOL>edx_filename='<STR_LIT>',<EOL>dev_env=False,<EOL>debug=False,<EOL>local_loglevel='<STR_LIT>',<EOL>service_variant='<STR_LIT>'):", "body": "<EOL>if local_loglevel not in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>local_loglevel = '<STR_LIT>'<EOL><DEDENT>hostname = platform.node().split('<STR_LIT:.>')[<NUM_LIT:0>]<EOL>syslog_format = (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>).format(<EOL>service_variant=service_variant,<EOL>logging_env=logging_env, hostname=hostname<EOL>)<EOL>if debug:<EOL><INDENT>handlers = ['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>handlers = ['<STR_LIT>']<EOL><DEDENT>logger_config = {<EOL>'<STR_LIT:version>': <NUM_LIT:1>,<EOL>'<STR_LIT>': False,<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': '<STR_LIT>'<EOL>'<STR_LIT>',<EOL>},<EOL>'<STR_LIT>': {'<STR_LIT>': syslog_format},<EOL>'<STR_LIT>': {'<STR_LIT>': '<STR_LIT>'},<EOL>},<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': '<STR_LIT>' if debug else '<STR_LIT>',<EOL>'<STR_LIT:class>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': sys.stdout,<EOL>},<EOL>},<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': handlers,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': True<EOL>},<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': handlers,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': False<EOL>},<EOL>}<EOL>}<EOL>if dev_env:<EOL><INDENT>edx_file_loc = os.path.join(log_dir, edx_filename)<EOL>logger_config['<STR_LIT>'].update({<EOL>'<STR_LIT>': {<EOL>'<STR_LIT:class>': '<STR_LIT>',<EOL>'<STR_LIT>': local_loglevel,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:filename>': edx_file_loc,<EOL>'<STR_LIT>': <NUM_LIT> * <NUM_LIT> * <NUM_LIT:2>,<EOL>'<STR_LIT>': <NUM_LIT:5>,<EOL>},<EOL>})<EOL><DEDENT>else:<EOL><INDENT>logger_config['<STR_LIT>'].update({<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': local_loglevel,<EOL>'<STR_LIT:class>': '<STR_LIT>',<EOL>'<STR_LIT:address>': '<STR_LIT>' if sys.platform == '<STR_LIT>' else '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': SysLogHandler.LOG_LOCAL0,<EOL>},<EOL>})<EOL><DEDENT>return logger_config<EOL>", "docstring": "Returns a dictionary containing logging configuration.\n\nIf dev_env is True, logging will not be done via local rsyslogd.\nInstead, application logs will be dropped into log_dir. 'edx_filename'\nis ignored unless dev_env is True.", "id": "f9742:m0"}
{"signature": "def send_genes(self, gene_list, url):", "body": "payload = {<EOL>'<STR_LIT:list>': (None, gene_list),<EOL>'<STR_LIT:description>': (None, self.descriptions)<EOL>}<EOL>response = requests.post(url, files=payload)<EOL>if not response.ok:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>sleep(<NUM_LIT:1>)<EOL>job_id = json.loads(response.text)<EOL>return job_id<EOL>", "docstring": "send gene list to enrichr server", "id": "f9747:c0:m4"}
{"signature": "def get_background(self):", "body": "<EOL>if os.path.isfile(self.background):<EOL><INDENT>with open(self.background) as b:<EOL><INDENT>bg2 = b.readlines() <EOL><DEDENT>bg = [g.strip() for g in bg2]  <EOL>return set(bg)<EOL><DEDENT>DB_FILE = resource_filename(\"<STR_LIT>\", \"<STR_LIT>\".format(self.background))<EOL>filename = os.path.join(DEFAULT_CACHE_PATH, \"<STR_LIT>\".format(self.background))  <EOL>if os.path.exists(filename):<EOL><INDENT>df = pd.read_csv(filename,sep=\"<STR_LIT:\\t>\")<EOL><DEDENT>elif os.path.exists(DB_FILE):<EOL><INDENT>df = pd.read_csv(DB_FILE,sep=\"<STR_LIT:\\t>\")<EOL><DEDENT>else:<EOL><INDENT>self._logger.warning(\"<STR_LIT>\"%self.background)<EOL>bm = Biomart()<EOL>df = bm.query(dataset=self.background)<EOL>df.dropna(subset=['<STR_LIT>'], inplace=True)<EOL><DEDENT>self._logger.info(\"<STR_LIT>\")<EOL>df.dropna(subset=['<STR_LIT>'], inplace=True)     <EOL>if self._isezid:<EOL><INDENT>bg = df['<STR_LIT>'].astype(int)<EOL><DEDENT>else:<EOL><INDENT>bg = df['<STR_LIT>']<EOL><DEDENT>return set(bg)<EOL>", "docstring": "get background gene", "id": "f9747:c0:m9"}
{"signature": "def parse_genesets(self):", "body": "enrichr_library = self.get_libraries()<EOL>if isinstance(self.gene_sets, list):<EOL><INDENT>gss = self.gene_sets<EOL><DEDENT>elif isinstance(self.gene_sets, str):<EOL><INDENT>gss = [ g.strip() for g in self.gene_sets.strip().split(\"<STR_LIT:U+002C>\") ]<EOL><DEDENT>elif isinstance(self.gene_sets, dict):<EOL><INDENT>gss = [self.gene_sets]<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>gss_exist = [] <EOL>for g in gss:<EOL><INDENT>if isinstance(g, dict): <EOL><INDENT>gss_exist.append(g)<EOL>continue<EOL><DEDENT>if isinstance(g, str): <EOL><INDENT>if g in enrichr_library: <EOL><INDENT>gss_exist.append(g)<EOL>continue<EOL><DEDENT>if g.lower().endswith(\"<STR_LIT>\") and os.path.exists(g):<EOL><INDENT>self._logger.info(\"<STR_LIT>\"%g)<EOL>with open(g) as genesets:<EOL><INDENT>g_dict = { line.strip().split(\"<STR_LIT:\\t>\")[<NUM_LIT:0>]: line.strip().split(\"<STR_LIT:\\t>\")[<NUM_LIT:2>:]<EOL>for line in genesets.readlines() }<EOL><DEDENT>gss_exist.append(g_dict)<EOL><DEDENT><DEDENT><DEDENT>return gss_exist<EOL>", "docstring": "parse gene_sets input file type", "id": "f9747:c0:m2"}
{"signature": "def gsea_compute(data, gmt, n, weighted_score_type, permutation_type,<EOL>method, pheno_pos, pheno_neg, classes, ascending,<EOL>processes=<NUM_LIT:1>, seed=None, single=False, scale=False):", "body": "w = weighted_score_type<EOL>subsets = sorted(gmt.keys())<EOL>es = []<EOL>RES=[]<EOL>hit_ind=[]<EOL>esnull = [ [] for a in range(len(subsets)) ]<EOL>logging.debug(\"<STR_LIT>\")<EOL>if permutation_type == \"<STR_LIT>\":<EOL><INDENT>logging.debug(\"<STR_LIT>\")<EOL>rs = np.random.RandomState(seed)<EOL>genes_mat, cor_mat = ranking_metric_tensor(exprs=data, method=method,<EOL>permutation_num=n,<EOL>pos=pheno_pos, neg=pheno_neg,<EOL>classes=classes,<EOL>ascending=ascending, rs=rs)<EOL>logging.debug(\"<STR_LIT>\")<EOL>es, esnull, hit_ind, RES = enrichment_score_tensor(gene_mat=genes_mat,<EOL>cor_mat=cor_mat,<EOL>gene_sets=gmt,<EOL>weighted_score_type=w,<EOL>nperm=n, rs=rs,<EOL>single=False, scale=False,)<EOL><DEDENT>else:<EOL><INDENT>gl, cor_vec = data.index.values, data.values<EOL>logging.debug(\"<STR_LIT>\")<EOL>temp_esnu=[]<EOL>pool_esnu = Pool(processes=processes)<EOL>for subset in subsets:<EOL><INDENT>rs = np.random.RandomState(seed)<EOL>temp_esnu.append(pool_esnu.apply_async(enrichment_score,<EOL>args=(gl, cor_vec, gmt.get(subset), w,<EOL>n, rs, single, scale)))<EOL><DEDENT>pool_esnu.close()<EOL>pool_esnu.join()<EOL>for si, temp in enumerate(temp_esnu):<EOL><INDENT>e, enu, hit, rune = temp.get()<EOL>esnull[si] = enu<EOL>es.append(e)<EOL>RES.append(rune)<EOL>hit_ind.append(hit)<EOL><DEDENT><DEDENT>return gsea_significance(es, esnull), hit_ind, RES, subsets<EOL>", "docstring": "compute enrichment scores and enrichment nulls.\n\n        :param data: preprocessed expression dataframe or a pre-ranked file if prerank=True.\n        :param dict gmt: all gene sets in .gmt file. need to call load_gmt() to get results.\n        :param int n: permutation number. default: 1000.\n        :param str method: ranking_metric method. see above.\n        :param str pheno_pos: one of labels of phenotype's names.\n        :param str pheno_neg: one of labels of phenotype's names.\n        :param list classes: a list of phenotype labels, to specify which column of dataframe belongs to what category of phenotype.\n        :param float weighted_score_type: default:1\n        :param bool ascending: sorting order of rankings. Default: False.\n        :param seed: random seed. Default: np.random.RandomState()\n        :param bool scale: if true, scale es by gene number.\n\n        :return: a tuple contains::\n\n                | zipped results of es, nes, pval, fdr.\n                | nested list of hit indices of input gene_list.\n                | nested list of ranked enrichment score of each input gene_sets.\n                | list of enriched terms", "id": "f9748:m5"}
{"signature": "def gsea_compute_tensor(data, gmt, n, weighted_score_type, permutation_type,<EOL>method, pheno_pos, pheno_neg, classes, ascending,<EOL>processes=<NUM_LIT:1>, seed=None, single=False, scale=False):", "body": "w = weighted_score_type<EOL>subsets = sorted(gmt.keys())<EOL>rs = np.random.RandomState(seed)<EOL>genes_mat, cor_mat = data.index.values, data.values<EOL>base = <NUM_LIT:5> if data.shape[<NUM_LIT:0>] >= <NUM_LIT> else <NUM_LIT:10><EOL>block = ceil(len(subsets) / base)<EOL>if permutation_type == \"<STR_LIT>\":<EOL><INDENT>logging.debug(\"<STR_LIT>\")<EOL>genes_ind = []<EOL>cor_mat = []<EOL>temp_rnk = []<EOL>pool_rnk = Pool(processes=processes)<EOL>i=<NUM_LIT:1><EOL>while i <= block:<EOL><INDENT>rs = np.random.RandomState(seed)<EOL>temp_rnk.append(pool_rnk.apply_async(ranking_metric_tensor,<EOL>args=(data, method, base, pheno_pos, pheno_neg, classes,<EOL>ascending, rs)))<EOL>i +=<NUM_LIT:1><EOL><DEDENT>pool_rnk.close()<EOL>pool_rnk.join()<EOL>for k, temp in enumerate(temp_rnk):<EOL><INDENT>gi, cor = temp.get()<EOL>if k+<NUM_LIT:1> == block:<EOL><INDENT>genes_ind.append(gi)<EOL>cor_mat.append(cor)<EOL><DEDENT>else:<EOL><INDENT>genes_ind.append(gi[:-<NUM_LIT:1>])<EOL>cor_mat.append(cor[:-<NUM_LIT:1>])<EOL><DEDENT><DEDENT>genes_ind, cor_mat = np.vstack(genes_ind), np.vstack(cor_mat)<EOL>genes_mat = (data.index.values, genes_ind)<EOL><DEDENT>logging.debug(\"<STR_LIT>\")<EOL>es = []<EOL>RES = []<EOL>hit_ind = []<EOL>esnull = []<EOL>temp_esnu = []<EOL>pool_esnu = Pool(processes=processes)<EOL>i, m = <NUM_LIT:1>, <NUM_LIT:0><EOL>while i <= block:<EOL><INDENT>rs = np.random.RandomState(seed)<EOL>gmtrim = {k: gmt.get(k) for k in subsets[m:base * i]}<EOL>temp_esnu.append(pool_esnu.apply_async(enrichment_score_tensor,<EOL>args=(genes_mat, cor_mat,<EOL>gmtrim, w, n, rs,<EOL>single, scale)))<EOL>m = base * i<EOL>i += <NUM_LIT:1><EOL><DEDENT>pool_esnu.close()<EOL>pool_esnu.join()<EOL>for si, temp in enumerate(temp_esnu):<EOL><INDENT>e, enu, hit, rune = temp.get()<EOL>esnull.append(enu)<EOL>es.append(e)<EOL>RES.append(rune)<EOL>hit_ind += hit<EOL><DEDENT>es, esnull, RES = np.hstack(es), np.vstack(esnull), np.vstack(RES)<EOL>return gsea_significance(es, esnull), hit_ind, RES, subsets<EOL>", "docstring": "compute enrichment scores and enrichment nulls.\n\n        :param data: preprocessed expression dataframe or a pre-ranked file if prerank=True.\n        :param dict gmt: all gene sets in .gmt file. need to call load_gmt() to get results.\n        :param int n: permutation number. default: 1000.\n        :param str method: ranking_metric method. see above.\n        :param str pheno_pos: one of labels of phenotype's names.\n        :param str pheno_neg: one of labels of phenotype's names.\n        :param list classes: a list of phenotype labels, to specify which column of dataframe belongs to what category of phenotype.\n        :param float weighted_score_type: default:1\n        :param bool ascending: sorting order of rankings. Default: False.\n        :param seed: random seed. Default: np.random.RandomState()\n        :param bool scale: if true, scale es by gene number.\n\n        :return: a tuple contains::\n\n                | zipped results of es, nes, pval, fdr.\n                | nested list of hit indices of input gene_list.\n                | nested list of ranked enrichment score of each input gene_sets.\n                | list of enriched terms", "id": "f9748:m4"}
{"signature": "def ranking_metric_tensor(exprs, method, permutation_num, pos, neg, classes,<EOL>ascending, rs=np.random.RandomState()):", "body": "<EOL>G, S = exprs.shape<EOL>expr_mat = exprs.values.T<EOL>perm_cor_tensor = np.tile(expr_mat, (permutation_num+<NUM_LIT:1>,<NUM_LIT:1>,<NUM_LIT:1>))<EOL>for arr in perm_cor_tensor[:-<NUM_LIT:1>]: rs.shuffle(arr)<EOL>classes = np.array(classes)<EOL>pos = classes == pos<EOL>neg = classes == neg<EOL>pos_cor_mean = perm_cor_tensor[:,pos,:].mean(axis=<NUM_LIT:1>)<EOL>neg_cor_mean = perm_cor_tensor[:,neg,:].mean(axis=<NUM_LIT:1>)<EOL>pos_cor_std = perm_cor_tensor[:,pos,:].std(axis=<NUM_LIT:1>, ddof=<NUM_LIT:1>)<EOL>neg_cor_std = perm_cor_tensor[:,neg,:].std(axis=<NUM_LIT:1>, ddof=<NUM_LIT:1>)<EOL>if method == '<STR_LIT>':<EOL><INDENT>cor_mat = (pos_cor_mean - neg_cor_mean)/(pos_cor_std + neg_cor_std)<EOL><DEDENT>elif method == '<STR_LIT>':<EOL><INDENT>denom = <NUM_LIT:1.0>/G<EOL>cor_mat = (pos_cor_mean - neg_cor_mean)/ np.sqrt(denom*pos_cor_std**<NUM_LIT:2> + denom*neg_cor_std**<NUM_LIT:2>)<EOL><DEDENT>elif method == '<STR_LIT>':<EOL><INDENT>cor_mat = pos_cor_mean / neg_cor_mean<EOL><DEDENT>elif method == '<STR_LIT>':<EOL><INDENT>cor_mat  = pos_cor_mean - neg_cor_mean<EOL><DEDENT>elif method == '<STR_LIT>':<EOL><INDENT>cor_mat  =  np.log2(pos_cor_mean / neg_cor_mean)<EOL><DEDENT>else:<EOL><INDENT>logging.error(\"<STR_LIT>\")<EOL>sys.exit(<NUM_LIT:0>)<EOL><DEDENT>cor_mat_ind = cor_mat.argsort()<EOL>cor_mat.sort()<EOL>if ascending: return cor_mat_ind, cor_mat<EOL>return cor_mat_ind[:, ::-<NUM_LIT:1>], cor_mat[:, ::-<NUM_LIT:1>]<EOL>", "docstring": "Build shuffled ranking matrix when permutation_type eq to phenotype.\n\n       :param exprs:   gene_expression DataFrame, gene_name indexed.\n       :param str method:  calculate correlation or ranking. methods including:\n                           1. 'signal_to_noise'.\n                           2. 't_test'.\n                           3. 'ratio_of_classes' (also referred to as fold change).\n                           4. 'diff_of_classes'.\n                           5. 'log2_ratio_of_classes'.\n       :param int permuation_num: how many times of classes is being shuffled\n       :param str pos: one of labels of phenotype's names.\n       :param str neg: one of labels of phenotype's names.\n       :param list classes:  a list of phenotype labels, to specify which column of\n                             dataframe belongs to what class of phenotype.\n       :param bool ascending:  bool. Sort ascending vs. descending.\n\n       :return:\n                returns two 2d ndarray with shape (nperm, gene_num).\n\n                | cor_mat_indices: the indices of sorted and permutated (exclude last row) ranking matrix.\n                | cor_mat: sorted and permutated (exclude last row) ranking matrix.", "id": "f9748:m2"}
{"signature": "def gsea_cls_parser(cls):", "body": "if isinstance(cls, list) :<EOL><INDENT>classes = cls<EOL>sample_name= unique(classes)<EOL><DEDENT>elif isinstance(cls, str) :<EOL><INDENT>with open(cls) as c:<EOL><INDENT>file = c.readlines()<EOL><DEDENT>classes = file[<NUM_LIT:2>].strip('<STR_LIT:\\n>').split(\"<STR_LIT:U+0020>\")<EOL>sample_name = file[<NUM_LIT:1>].lstrip(\"<STR_LIT>\").strip('<STR_LIT:\\n>').split(\"<STR_LIT:U+0020>\")<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>return sample_name[<NUM_LIT:0>], sample_name[<NUM_LIT:1>], classes<EOL>", "docstring": "Extract class(phenotype) name from .cls file.\n\n    :param cls: the a class list instance or .cls file which is identical to GSEA input .\n    :return: phenotype name and a list of class vector.", "id": "f9749:m0"}
{"signature": "def get_library_name(database='<STR_LIT>'):", "body": "<EOL>if database not in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>sys.stderr.write(\"\"\"<STR_LIT>\"\"\")<EOL>return <EOL><DEDENT>if database in ['<STR_LIT>', '<STR_LIT>']: database='<STR_LIT>'<EOL>lib_url='<STR_LIT>'%database<EOL>libs_json = json.loads(requests.get(lib_url).text)<EOL>libs = [lib['<STR_LIT>'] for lib in libs_json['<STR_LIT>']]<EOL>return sorted(libs)<EOL>", "docstring": "return enrichr active enrichr library name. \n    :param str database: Select one from { 'Human', 'Mouse', 'Yeast', 'Fly', 'Fish', 'Worm' }", "id": "f9749:m3"}
{"signature": "def heatmap(df, z_score=None, title='<STR_LIT>', figsize=(<NUM_LIT:5>,<NUM_LIT:5>), cmap='<STR_LIT>', <EOL>xticklabels=True, yticklabels=True, ofname=None, **kwargs):", "body": "df = zscore(df, axis=z_score)<EOL>df = df.iloc[::-<NUM_LIT:1>]<EOL>ny, nx = df.shape<EOL>xticks = np.arange(<NUM_LIT:0>, nx, <NUM_LIT:1>) + <NUM_LIT><EOL>yticks = np.arange(<NUM_LIT:0>, ny, <NUM_LIT:1>) + <NUM_LIT><EOL>if hasattr(sys, '<STR_LIT>') and (ofname is None): <EOL><INDENT>fig = plt.figure(figsize=figsize)<EOL><DEDENT>else:<EOL><INDENT>fig = Figure(figsize=figsize)<EOL>canvas = FigureCanvas(fig)<EOL><DEDENT>ax = fig.add_subplot(<NUM_LIT>)<EOL>vmin = np.percentile(df.min(), <NUM_LIT:2>)<EOL>vmax =  np.percentile(df.max(), <NUM_LIT>)<EOL>matrix = ax.pcolormesh(df.values, cmap=cmap, vmin=vmin, vmax=vmax)<EOL>ax.set_ylim([<NUM_LIT:0>,len(df)])<EOL>ax.set(xticks=xticks, yticks=yticks)<EOL>ax.set_xticklabels(df.columns.values if xticklabels else '<STR_LIT>', fontsize=<NUM_LIT>, rotation=<NUM_LIT>)<EOL>ax.set_yticklabels(df.index.values if yticklabels else '<STR_LIT>',  fontsize=<NUM_LIT>)<EOL>ax.set_title(\"<STR_LIT>\"%title, fontsize=<NUM_LIT:20>)<EOL>ax.tick_params(axis='<STR_LIT>', which='<STR_LIT>', bottom=False, top=False,<EOL>right=False, left=False)<EOL>cbar = colorbar(matrix)<EOL>cbar.ax.tick_params(axis='<STR_LIT>', which='<STR_LIT>', bottom=False, top=False,<EOL>right=False, left=False)<EOL>for side in [\"<STR_LIT>\", \"<STR_LIT:right>\", \"<STR_LIT:left>\", \"<STR_LIT>\"]:<EOL><INDENT>ax.spines[side].set_visible(False)<EOL>cbar.ax.spines[side].set_visible(False)<EOL><DEDENT>if ofname is not None: <EOL><INDENT>fig.savefig(ofname, bbox_inches='<STR_LIT>', dpi=<NUM_LIT>)<EOL><DEDENT>return<EOL>", "docstring": "Visualize the dataframe.\n\n    :param df: DataFrame from expression table.\n    :param z_score: z_score axis{0, 1}. If None, don't normalize data.\n    :param title: gene set name.\n    :param outdir: path to save heatmap.\n    :param figsize: heatmap figsize.\n    :param cmap: matplotlib colormap.\n    :param ofname: output file name. If None, don't save figure", "id": "f9750:m2"}
{"signature": "def dotplot(df, column='<STR_LIT>', title='<STR_LIT>', cutoff=<NUM_LIT>, top_term=<NUM_LIT:10>, <EOL>sizes=None, norm=None, legend=True, figsize=(<NUM_LIT:6>, <NUM_LIT>), <EOL>cmap='<STR_LIT>', ofname=None, **kwargs):", "body": "colname = column    <EOL>if colname in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>can_be_coerced = df[colname].map(isfloat)<EOL>if np.sum(~can_be_coerced) > <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>'%colname)<EOL><DEDENT>else:<EOL><INDENT>df.loc[:, colname] = df[colname].map(float)<EOL><DEDENT>df = df[df[colname] <= cutoff]<EOL>if len(df) < <NUM_LIT:1>: <EOL><INDENT>msg = \"<STR_LIT>\"%cutoff<EOL>return msg<EOL><DEDENT>df = df.assign(logAP=lambda x: - x[colname].apply(np.log10))<EOL>colname='<STR_LIT>'<EOL><DEDENT>df = df.sort_values(by=colname).iloc[-top_term:,:]<EOL>temp = df['<STR_LIT>'].str.split(\"<STR_LIT:/>\", expand=True).astype(int)<EOL>df = df.assign(Hits=temp.iloc[:,<NUM_LIT:0>], Background=temp.iloc[:,<NUM_LIT:1>])<EOL>df = df.assign(Hits_ratio=lambda x:x.Hits / x.Background)<EOL>x = df.loc[:, colname].values<EOL>combined_score = df['<STR_LIT>'].round().astype('<STR_LIT:int>')<EOL>y = [i for i in range(<NUM_LIT:0>,len(df))]<EOL>ylabels = df['<STR_LIT>'].values<EOL>levels = numbers = np.sort(df.Hits.unique())<EOL>if norm is None:<EOL><INDENT>norm = Normalize()<EOL><DEDENT>elif isinstance(norm, tuple):<EOL><INDENT>norm = Normalize(*norm)<EOL><DEDENT>elif not isinstance(norm, Normalize):<EOL><INDENT>err = (\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>raise ValueError(err)<EOL><DEDENT>min_width, max_width = np.r_[<NUM_LIT:20>, <NUM_LIT:100>] * plt.rcParams[\"<STR_LIT>\"]<EOL>norm.clip = True<EOL>if not norm.scaled():<EOL><INDENT>norm(np.asarray(numbers))<EOL><DEDENT>size_limits = norm.vmin, norm.vmax<EOL>scl = norm(numbers)<EOL>widths = np.asarray(min_width + scl * (max_width - min_width))<EOL>if scl.mask.any():<EOL><INDENT>widths[scl.mask] = <NUM_LIT:0><EOL><DEDENT>sizes = dict(zip(levels, widths))<EOL>df['<STR_LIT>'] = df.Hits.map(sizes)<EOL>area = df['<STR_LIT>'].values<EOL>if hasattr(sys, '<STR_LIT>') and (ofname is None):<EOL><INDENT>fig, ax = plt.subplots(figsize=figsize)<EOL><DEDENT>else:<EOL><INDENT>fig = Figure(figsize=figsize)<EOL>canvas = FigureCanvas(fig)<EOL>ax = fig.add_subplot(<NUM_LIT>)<EOL><DEDENT>vmin = np.percentile(combined_score.min(), <NUM_LIT:2>)<EOL>vmax =  np.percentile(combined_score.max(), <NUM_LIT>)<EOL>sc = ax.scatter(x=x, y=y, s=area, edgecolors='<STR_LIT>', c=combined_score,<EOL>cmap=cmap, vmin=vmin, vmax=vmax)<EOL>if column in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>xlabel = \"<STR_LIT>\"%column<EOL><DEDENT>else:<EOL><INDENT>xlabel = column <EOL><DEDENT>ax.set_xlabel(xlabel, fontsize=<NUM_LIT>, fontweight='<STR_LIT>')<EOL>ax.yaxis.set_major_locator(plt.FixedLocator(y))<EOL>ax.yaxis.set_major_formatter(plt.FixedFormatter(ylabels))<EOL>ax.set_yticklabels(ylabels, fontsize=<NUM_LIT:16>)<EOL>ax.grid()<EOL>cax=fig.add_axes([<NUM_LIT>,<NUM_LIT>,<NUM_LIT>,<NUM_LIT>])<EOL>cbar = fig.colorbar(sc, cax=cax,)<EOL>cbar.ax.tick_params(right=True)<EOL>cbar.ax.set_title('<STR_LIT>',loc='<STR_LIT:left>', fontsize=<NUM_LIT:12>)<EOL>if len(df) >= <NUM_LIT:3>:<EOL><INDENT>idx = [area.argmax(), np.abs(area - area.mean()).argmin(), area.argmin()]<EOL>idx = unique(idx)<EOL><DEDENT>else:<EOL><INDENT>idx = df.index.values<EOL><DEDENT>label = df.iloc[idx, df.columns.get_loc('<STR_LIT>')]<EOL>if legend:<EOL><INDENT>handles, _ = ax.get_legend_handles_labels()<EOL>legend_markers = []<EOL>for ix in idx: <EOL><INDENT>legend_markers.append(ax.scatter([],[], s=area[ix], c='<STR_LIT:b>'))<EOL><DEDENT>ax.legend(legend_markers, label, title='<STR_LIT>')<EOL><DEDENT>ax.set_title(title, fontsize=<NUM_LIT:20>, fontweight='<STR_LIT>')<EOL>if ofname is not None: <EOL><INDENT>fig.savefig(ofname, bbox_inches='<STR_LIT>', dpi=<NUM_LIT>)<EOL>return<EOL><DEDENT>return ax<EOL>", "docstring": "Visualize enrichr results.\n\n    :param df: GSEApy DataFrame results.\n    :param column: which column of DataFrame to show. Default: Adjusted P-value\n    :param title: figure title\n    :param cutoff: p-adjust cut-off.\n    :param top_term: number of enriched terms to show.\n    :param ascending: bool, the order of y axis.\n    :param sizes: tuple, (min, max) scatter size. Not functional for now\n    :param norm: maplotlib.colors.Normalize object.\n    :param legend: bool, whether to show legend.\n    :param figsize: tuple, figure size. \n    :param cmap: matplotlib colormap\n    :param ofname: output file name. If None, don't save figure", "id": "f9750:m5"}
{"signature": "def adjust_spines(ax, spines):", "body": "for loc, spine in ax.spines.items():<EOL><INDENT>if loc in spines:<EOL><INDENT>continue<EOL><DEDENT>else:<EOL><INDENT>spine.set_color('<STR_LIT:none>')  <EOL><DEDENT><DEDENT>if '<STR_LIT:left>' in spines:<EOL><INDENT>ax.yaxis.set_ticks_position('<STR_LIT:left>')<EOL><DEDENT>else:<EOL><INDENT>ax.yaxis.set_ticks([])<EOL><DEDENT>if '<STR_LIT>' in spines:<EOL><INDENT>ax.xaxis.set_ticks_position('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>ax.xaxis.set_ticks([])<EOL><DEDENT>", "docstring": "function for removing spines and ticks.\n\n    :param ax: axes object\n    :param spines: a list of spines names to keep. e.g [left, right, top, bottom]\n                    if spines = []. remove all spines and ticks.", "id": "f9750:m7"}
{"signature": "def zscore(data2d, axis=<NUM_LIT:0>):", "body": "if axis is None:<EOL><INDENT>return data2d<EOL><DEDENT>assert axis in [<NUM_LIT:0>,<NUM_LIT:1>]<EOL>z_scored = data2d.apply(lambda x: (x-x.mean())/x.std(ddof=<NUM_LIT:1>), <EOL>axis=operator.xor(<NUM_LIT:1>, axis))<EOL>return z_scored<EOL>", "docstring": "Standardize the mean and variance of the data axis Parameters.\n\n    :param data2d: DataFrame to normalize.\n    :param axis: int, Which axis to normalize across. If 0, normalize across rows,\n                  if 1, normalize across columns. If None, don't change data\n\n    :Returns: Normalized DataFrame. Normalized data with a mean of 0 and variance of 1\n              across the specified axis.", "id": "f9750:m0"}
{"signature": "def runSamplesPermu(self, df, gmt=None):", "body": "assert self.min_size <= self.max_size<EOL>mkdirs(self.outdir)<EOL>self.resultsOnSamples = OrderedDict()<EOL>outdir = self.outdir<EOL>for name, ser in df.iteritems():<EOL><INDENT>self.outdir = os.path.join(outdir, str(name))<EOL>self._logger.info(\"<STR_LIT>\" % name)<EOL>mkdirs(self.outdir)<EOL>dat2 = ser.sort_values(ascending=self.ascending)<EOL>gsea_results, hit_ind,rank_ES, subsets = gsea_compute(data=dat2, n=self.permutation_num, gmt=gmt,<EOL>weighted_score_type=self.weighted_score_type,<EOL>permutation_type='<STR_LIT>', method=None,<EOL>pheno_pos='<STR_LIT>', pheno_neg='<STR_LIT>',<EOL>classes=None, ascending=self.ascending,<EOL>processes=self._processes,<EOL>seed=self.seed, single=True, scale=self.scale)<EOL>res_zip = zip(subsets, list(gsea_results), hit_ind, rank_ES)<EOL>self._save_results(zipdata=res_zip, outdir=self.outdir, module=self.module,<EOL>gmt=gmt, rank_metric=dat2, permutation_type=\"<STR_LIT>\")<EOL>self.resultsOnSamples[name] = self.res2d.es<EOL>if self._noplot: continue<EOL>self._logger.info(\"<STR_LIT>\" % name)<EOL>self._plotting(rank_metric=dat2, results=self.results,<EOL>graph_num=self.graph_num, outdir=self.outdir,<EOL>figsize=self.figsize, format=self.format)<EOL><DEDENT>self._save(outdir)<EOL>return<EOL>", "docstring": "Single Sample GSEA workflow with permutation procedure", "id": "f9751:c3:m6"}
{"signature": "def run(self):", "body": "self._logger.info(\"<STR_LIT>\")<EOL>data = self.load_data()<EOL>normdat = self.norm_samples(data)<EOL>gmt = self.load_gmt(gene_list=normdat.index.values, gmt=self.gene_sets)<EOL>self._logger.info(\"<STR_LIT>\"% len(gmt))<EOL>self._set_cores()<EOL>self._logger.info(\"<STR_LIT>\")<EOL>if self.permutation_num == <NUM_LIT:0> :<EOL><INDENT>self.runSamples(df=normdat, gmt=gmt)<EOL><DEDENT>else:<EOL><INDENT>self._logger.warning(\"<STR_LIT>\")<EOL>self.runSamplesPermu(df=normdat, gmt=gmt)<EOL><DEDENT>if self._outdir is None:<EOL><INDENT>self._tmpdir.cleanup()<EOL><DEDENT>", "docstring": "run entry", "id": "f9751:c3:m5"}
{"signature": "def parse_gmt(self, gmt):", "body": "if gmt.lower().endswith(\"<STR_LIT>\"):<EOL><INDENT>with open(gmt) as genesets:<EOL><INDENT>genesets_dict = { line.strip().split(\"<STR_LIT:\\t>\")[<NUM_LIT:0>]: line.strip().split(\"<STR_LIT:\\t>\")[<NUM_LIT:2>:]<EOL>for line in genesets.readlines()}<EOL><DEDENT>return genesets_dict<EOL><DEDENT>elif gmt in DEFAULT_LIBRARY:<EOL><INDENT>pass<EOL><DEDENT>elif gmt in self.get_libraries():<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>self._logger.error(\"<STR_LIT>\"%gmt)<EOL>sys.exit(<NUM_LIT:0>)<EOL><DEDENT>tmpname = \"<STR_LIT>\" + gmt + \"<STR_LIT>\"<EOL>tempath = os.path.join(DEFAULT_CACHE_PATH, tmpname)<EOL>if os.path.isfile(tempath):<EOL><INDENT>self._logger.info(\"<STR_LIT>\"%DEFAULT_CACHE_PATH)<EOL>return self.parse_gmt(tempath)<EOL><DEDENT>else:<EOL><INDENT>return self._download_libraries(gmt)<EOL><DEDENT>", "docstring": "gmt parser", "id": "f9751:c0:m5"}
{"signature": "def _heatmat(self, df, classes, pheno_pos, pheno_neg):", "body": "width = len(classes) if len(classes) >= <NUM_LIT:6> else  <NUM_LIT:5><EOL>cls_booA =list(map(lambda x: True if x == pheno_pos else False, classes))<EOL>cls_booB =list(map(lambda x: True if x == pheno_neg else False, classes))<EOL>datA = df.loc[:, cls_booA]<EOL>datB = df.loc[:, cls_booB]<EOL>datAB=pd.concat([datA,datB], axis=<NUM_LIT:1>)<EOL>self._width = width<EOL>self.heatmat = datAB<EOL>return<EOL>", "docstring": "only use for gsea heatmap", "id": "f9751:c0:m8"}
{"signature": "def corplot(self):", "body": "", "docstring": "NES Correlation plot\n        TODO", "id": "f9751:c3:m1"}
{"signature": "def prerank(rnk, gene_sets, outdir='<STR_LIT>', pheno_pos='<STR_LIT>', pheno_neg='<STR_LIT>',<EOL>min_size=<NUM_LIT:15>, max_size=<NUM_LIT>, permutation_num=<NUM_LIT:1000>, weighted_score_type=<NUM_LIT:1>,<EOL>ascending=False, processes=<NUM_LIT:1>, figsize=(<NUM_LIT>,<NUM_LIT:6>), format='<STR_LIT>',<EOL>graph_num=<NUM_LIT:20>, no_plot=False, seed=None, verbose=False):", "body": "pre = Prerank(rnk, gene_sets, outdir, pheno_pos, pheno_neg,<EOL>min_size, max_size, permutation_num, weighted_score_type,<EOL>ascending, processes, figsize, format, graph_num, no_plot, seed, verbose)<EOL>pre.run()<EOL>return pre<EOL>", "docstring": "Run Gene Set Enrichment Analysis with pre-ranked correlation defined by user.\n\n    :param rnk: pre-ranked correlation table or pandas DataFrame. Same input with ``GSEA`` .rnk file.\n    :param gene_sets: Enrichr Library name or .gmt gene sets file or dict of gene sets. Same input with GSEA.\n    :param outdir: results output directory.\n    :param int permutation_num: Number of permutations for significance computation. Default: 1000.\n    :param int min_size: Minimum allowed number of genes from gene set also the data set. Default: 15.\n    :param int max_size: Maximum allowed number of genes from gene set also the data set. Defaults: 500.\n    :param str weighted_score_type: Refer to :func:`algorithm.enrichment_score`. Default:1.\n    :param bool ascending: Sorting order of rankings. Default: False.\n    :param int processes: Number of Processes you are going to use. Default: 1.\n    :param list figsize: Matplotlib figsize, accept a tuple or list, e.g. [width,height]. Default: [6.5,6].\n    :param str format: Matplotlib figure format. Default: 'pdf'.\n    :param int graph_num: Plot graphs for top sets of each phenotype.\n    :param bool no_plot: If equals to True, no figure will be drawn. Default: False.\n    :param seed: Random seed. expect an integer. Default:None.\n    :param bool verbose: Bool, increase output verbosity, print out progress of your job, Default: False.\n\n    :return: Return a Prerank obj. All results store to  a dictionary, obj.results,\n             where contains::\n\n                 | {es: enrichment score,\n                 |  nes: normalized enrichment score,\n                 |  p: P-value,\n                 |  fdr: FDR,\n                 |  size: gene set size,\n                 |  matched_size: genes matched to the data,\n                 |  genes: gene names from the data set\n                 |  ledge_genes: leading edge genes}", "id": "f9751:m2"}
{"signature": "def add_plot_parser(subparsers):", "body": "argparser_replot = subparsers.add_parser(\"<STR_LIT>\", help=\"<STR_LIT>\")<EOL>group_replot = argparser_replot.add_argument_group(\"<STR_LIT>\")<EOL>group_replot.add_argument(\"<STR_LIT>\", \"<STR_LIT>\", action=\"<STR_LIT:store>\", dest=\"<STR_LIT>\", required=True, metavar='<STR_LIT>',<EOL>help=\"<STR_LIT>\")<EOL>add_output_option(group_replot)<EOL>group_replot.add_argument(\"<STR_LIT>\", \"<STR_LIT>\", action='<STR_LIT:store>', dest='<STR_LIT>', default=<NUM_LIT:1.0>, type=float, metavar='<STR_LIT:float>',<EOL>help='<STR_LIT>',)<EOL>return<EOL>", "docstring": "Add function 'plot' argument parsers.", "id": "f9752:m7"}
{"signature": "def add_output_option(parser):", "body": "parser.add_argument(\"<STR_LIT>\", \"<STR_LIT>\", dest=\"<STR_LIT>\", type=str, default='<STR_LIT>',<EOL>metavar='<STR_LIT>', action=\"<STR_LIT:store>\",<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument(\"<STR_LIT>\", \"<STR_LIT>\", dest=\"<STR_LIT>\", type=str, metavar='<STR_LIT>', action=\"<STR_LIT:store>\",<EOL>choices=(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"), default=\"<STR_LIT>\",<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument(\"<STR_LIT>\", \"<STR_LIT>\", action='<STR_LIT:store>', nargs=<NUM_LIT:2>, dest='<STR_LIT>',<EOL>metavar=('<STR_LIT:width>', '<STR_LIT>'),type=float, default=(<NUM_LIT>, <NUM_LIT:6>),<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument(\"<STR_LIT>\", dest = \"<STR_LIT>\", action=\"<STR_LIT:store>\", type=int, default=<NUM_LIT:20>, metavar='<STR_LIT:int>',<EOL>help=\"<STR_LIT>\")<EOL>parser.add_argument(\"<STR_LIT>\", action='<STR_LIT:store_true>', dest='<STR_LIT>', default=False,<EOL>help=\"<STR_LIT>\"+\"<STR_LIT>\")<EOL>parser.add_argument(\"<STR_LIT>\", \"<STR_LIT>\", action=\"<STR_LIT:store_true>\", default=False, dest='<STR_LIT>',<EOL>help=\"<STR_LIT>\", )<EOL>", "docstring": "output option", "id": "f9752:m2"}
{"signature": "def add_enrichr_parser(subparsers):", "body": "argparser_enrichr = subparsers.add_parser(\"<STR_LIT>\", help=\"<STR_LIT>\")<EOL>enrichr_opt = argparser_enrichr.add_argument_group(\"<STR_LIT>\")<EOL>enrichr_opt.add_argument(\"<STR_LIT>\", \"<STR_LIT>\", action=\"<STR_LIT:store>\", dest=\"<STR_LIT>\", type=str, required=True, metavar='<STR_LIT>',<EOL>help=\"<STR_LIT>\")<EOL>enrichr_opt.add_argument(\"<STR_LIT>\", \"<STR_LIT>\", action=\"<STR_LIT:store>\", dest=\"<STR_LIT>\", type=str, required=True, metavar='<STR_LIT>',<EOL>help=\"<STR_LIT>\")<EOL>enrichr_opt.add_argument(\"<STR_LIT>\", \"<STR_LIT>\", action=\"<STR_LIT:store>\", dest=\"<STR_LIT>\", type=str, default='<STR_LIT>',<EOL>help=\"<STR_LIT>\")<EOL>enrichr_opt.add_argument(\"<STR_LIT>\", \"<STR_LIT>\", action=\"<STR_LIT:store>\", dest=\"<STR_LIT>\", type=str, default='<STR_LIT>', metavar='<STR_LIT>',<EOL>help=\"<STR_LIT>\")<EOL>enrichr_opt.add_argument(\"<STR_LIT>\", \"<STR_LIT>\", action=\"<STR_LIT:store>\", dest=\"<STR_LIT>\", metavar='<STR_LIT:float>', type=float, default=<NUM_LIT>,<EOL>help=\"<STR_LIT>\")<EOL>enrichr_opt.add_argument(\"<STR_LIT>\", \"<STR_LIT>\", action=\"<STR_LIT:store>\", dest=\"<STR_LIT>\", default='<STR_LIT>', metavar='<STR_LIT>',<EOL>help=\"<STR_LIT>\")<EOL>enrichr_opt.add_argument(\"<STR_LIT>\", \"<STR_LIT>\", dest=\"<STR_LIT>\", action=\"<STR_LIT:store>\", type=int, default=<NUM_LIT:10>, metavar='<STR_LIT:int>',<EOL>help=\"<STR_LIT>\")<EOL>enrichr_output = argparser_enrichr.add_argument_group(\"<STR_LIT>\")<EOL>add_output_option(enrichr_output)<EOL>return<EOL>", "docstring": "Add function 'enrichr' argument parsers.", "id": "f9752:m8"}
{"signature": "def add_gsea_parser(subparsers):", "body": "argparser_gsea = subparsers.add_parser(\"<STR_LIT>\", help=\"<STR_LIT>\")<EOL>group_input = argparser_gsea.add_argument_group(\"<STR_LIT>\")<EOL>group_input.add_argument(\"<STR_LIT>\", \"<STR_LIT>\", dest=\"<STR_LIT:data>\", action=\"<STR_LIT:store>\", type=str, required=True,<EOL>help=\"<STR_LIT>\")<EOL>group_input.add_argument(\"<STR_LIT:-c>\", \"<STR_LIT>\", dest=\"<STR_LIT>\", action=\"<STR_LIT:store>\", type=str, required=True,<EOL>help=\"<STR_LIT>\")<EOL>group_input.add_argument(\"<STR_LIT>\", \"<STR_LIT>\", dest=\"<STR_LIT>\", action=\"<STR_LIT:store>\", type=str, required=True,<EOL>help=\"<STR_LIT>\")<EOL>group_input.add_argument(\"<STR_LIT>\", \"<STR_LIT>\", action=\"<STR_LIT:store>\", dest=\"<STR_LIT:type>\", type=str, metavar='<STR_LIT>',<EOL>choices=(\"<STR_LIT>\", \"<STR_LIT>\"), default=\"<STR_LIT>\",<EOL>help=\"<STR_LIT>\")<EOL>group_output = argparser_gsea.add_argument_group(\"<STR_LIT>\")<EOL>add_output_option(group_output)<EOL>group_opt = argparser_gsea.add_argument_group(\"<STR_LIT>\")<EOL>group_opt.add_argument(\"<STR_LIT>\", \"<STR_LIT>\", dest = \"<STR_LIT:n>\", action=\"<STR_LIT:store>\", type=int, default=<NUM_LIT:1000>, metavar='<STR_LIT>',<EOL>help=\"<STR_LIT>\")<EOL>group_opt.add_argument(\"<STR_LIT>\",  dest=\"<STR_LIT>\", action=\"<STR_LIT:store>\", type=int, default=<NUM_LIT:15>, metavar='<STR_LIT:int>',<EOL>help=\"<STR_LIT>\")<EOL>group_opt.add_argument(\"<STR_LIT>\", dest = \"<STR_LIT>\", action=\"<STR_LIT:store>\", type=int, default=<NUM_LIT>, metavar='<STR_LIT:int>',<EOL>help=\"<STR_LIT>\")<EOL>group_opt.add_argument(\"<STR_LIT>\", \"<STR_LIT>\", action='<STR_LIT:store>', dest='<STR_LIT>', default=<NUM_LIT:1.0>, type=float, metavar='<STR_LIT:float>',<EOL>help='<STR_LIT>',)<EOL>group_opt.add_argument(\"<STR_LIT>\", \"<STR_LIT>\", action=\"<STR_LIT:store>\", dest=\"<STR_LIT>\", type=str, metavar='<STR_LIT>',<EOL>choices=(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"),<EOL>default=\"<STR_LIT>\",<EOL>help=\"<STR_LIT>\")<EOL>group_opt.add_argument(\"<STR_LIT>\", \"<STR_LIT>\", action='<STR_LIT:store_true>', dest='<STR_LIT>', default=False,<EOL>help='<STR_LIT>')<EOL>group_opt.add_argument(\"<STR_LIT>\", \"<STR_LIT>\", dest = \"<STR_LIT>\", action=\"<STR_LIT:store>\", type=int, default=None, metavar='<STR_LIT>',<EOL>help=\"<STR_LIT>\")<EOL>group_opt.add_argument(\"<STR_LIT>\", \"<STR_LIT>\", dest = \"<STR_LIT>\", action=\"<STR_LIT:store>\", type=int, default=<NUM_LIT:1>, metavar='<STR_LIT>',<EOL>help=\"<STR_LIT>\")<EOL>return<EOL>", "docstring": "Add main function 'gsea' argument parsers.", "id": "f9752:m4"}
{"signature": "def retry(num=<NUM_LIT:5>):", "body": "s = requests.Session()<EOL>retries = Retry(total=num, backoff_factor=<NUM_LIT:0.1>,<EOL>status_forcelist=[<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>])<EOL>s.mount('<STR_LIT>', HTTPAdapter(max_retries=retries))<EOL>return s<EOL>", "docstring": "retry connection.\n\n        define max tries num\n        if the backoff_factor is 0.1, then sleep() will sleep for\n        [0.1s, 0.2s, 0.4s, ...] between retries.\n        It will also force a retry if the status code returned is 500, 502, 503 or 504.", "id": "f9755:m4"}
{"signature": "def unique(seq):", "body": "seen = set()<EOL>seen_add = seen.add<EOL>\"\"\"<STR_LIT>\"\"\"<EOL>return [x for x in seq if x not in seen and not seen_add(x)]<EOL>", "docstring": "Remove duplicates from a list in Python while preserving order.\n\n    :param seq: a python list object.\n    :return: a list without duplicates while preserving order.", "id": "f9755:m0"}
{"signature": "def parse_args():", "body": "usage = \"<STR_LIT>\"<EOL>description = \"<STR_LIT>\"<EOL>argparser = argparse.ArgumentParser(<EOL>usage=usage, description=description)<EOL>argparser.add_argument(<EOL>'<STR_LIT>', type=argparse.FileType('<STR_LIT:r>'),<EOL>help=\"<STR_LIT>\")<EOL>argparser.add_argument(<EOL>'<STR_LIT>', nargs='<STR_LIT:?>', type=argparse.FileType('<STR_LIT:w>'),<EOL>default=sys.stdout, help=\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>argparser.add_argument(<EOL>'<STR_LIT>', nargs=\"<STR_LIT:?>\", const=str, help=\"<STR_LIT>\")<EOL>args = argparser.parse_args()<EOL>return args<EOL>", "docstring": "Parses command line args using argparse library", "id": "f9793:m1"}
{"signature": "@property<EOL><INDENT>def one_minute_rate(self):<DEDENT>", "body": "return self.meter.one_minute_rate<EOL>", "docstring": "Returns the one-minute average rate.", "id": "f9816:c0:m9"}
{"signature": "@property<EOL><INDENT>def min(self):<DEDENT>", "body": "return self.histogram.min<EOL>", "docstring": "Returns the minimum amount of time spent in the operation.", "id": "f9816:c0:m13"}
{"signature": "@property<EOL><INDENT>def mean(self):<DEDENT>", "body": "return self.histogram.mean<EOL>", "docstring": "Returns the mean time spent in the operation.", "id": "f9816:c0:m15"}
{"signature": "@property<EOL><INDENT>def fifteen_minute_rate(self):<DEDENT>", "body": "return self.meter.fifteen_minute_rate<EOL>", "docstring": "Returns the fifteen-minute average rate.", "id": "f9816:c0:m11"}
{"signature": "@property<EOL><INDENT>def max(self):<DEDENT>", "body": "return self.histogram.max<EOL>", "docstring": "Returns the maximum amount of time spent in the operation.", "id": "f9816:c0:m14"}
{"signature": "@property<EOL><INDENT>@ticker<EOL>def five_minute_rate(self):<DEDENT>", "body": "return self.m5_rate.rate<EOL>", "docstring": "Returns the five-minute average rate.", "id": "f9817:c0:m10"}
{"signature": "@property<EOL><INDENT>@ticker<EOL>def one_minute_rate(self):<DEDENT>", "body": "return self.m1_rate.rate<EOL>", "docstring": "Returns the one-minute average rate.", "id": "f9817:c0:m9"}
{"signature": "@property<EOL><INDENT>def mean_rate(self):<DEDENT>", "body": "if self.counter.value == <NUM_LIT:0>:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>else:<EOL><INDENT>elapsed = time() - self.start_time<EOL>return self.counter.value / elapsed<EOL><DEDENT>", "docstring": "Returns the mean rate of the events since the start of the process.", "id": "f9817:c0:m12"}
{"signature": "@property<EOL><INDENT>def stddev(self):<DEDENT>", "body": "if self.counter.value > <NUM_LIT:0>:<EOL><INDENT>return self.variance ** <NUM_LIT><EOL><DEDENT>return <NUM_LIT:0.0><EOL>", "docstring": "Returns the standard deviation.", "id": "f9818:c0:m11"}
{"signature": "def mark(self, value=<NUM_LIT:1>):", "body": "last = self.last.get_and_set(value)<EOL>if last <= value:<EOL><INDENT>value = value - last<EOL><DEDENT>super(Derive, self).mark(value)<EOL>", "docstring": "Record an event with the derive.\n\n        :param value: counter value to record", "id": "f9822:c0:m1"}
{"signature": "def send_metric(self, name, metric):", "body": "config = SERIALIZER_CONFIG[class_name(metric)]<EOL>mmap(<EOL>self._buffered_send_metric,<EOL>self.serialize_metric(<EOL>metric,<EOL>name,<EOL>config['<STR_LIT>'],<EOL>config['<STR_LIT>']<EOL>)<EOL>)<EOL>if hasattr(metric, '<STR_LIT>') and config.get('<STR_LIT>'):<EOL><INDENT>mmap(<EOL>self._buffered_send_metric,<EOL>self.serialize_metric(<EOL>metric.snapshot,<EOL>name,<EOL>config['<STR_LIT>'],<EOL>config['<STR_LIT>']<EOL>)<EOL>)<EOL><DEDENT>", "docstring": "Send metric and its snapshot.", "id": "f9829:c0:m3"}
{"signature": "def format_metric_string(self, name, value, m_type):", "body": "<EOL>template = '<STR_LIT>'<EOL>if self.prefix:<EOL><INDENT>name = \"<STR_LIT>\".format(prefix=self.prefix, m_name=name)<EOL><DEDENT>return template.format(name=name, value=value, m_type=m_type)<EOL>", "docstring": "Compose a statsd compatible string for a metric's measurement.", "id": "f9829:c0:m5"}
{"signature": "def reconnect(self):", "body": "<EOL>self.log.debug(\"<STR_LIT>\")<EOL>self.connected.clear()<EOL>self.reconnect_required.set()<EOL>if self.socket:<EOL><INDENT>self.socket.close()<EOL><DEDENT>", "docstring": "Issues a reconnection by setting the reconnect_required event.\n\n        :return:", "id": "f9861:c0:m2"}
{"signature": "def _data_handler(self, data, ts):", "body": "<EOL>self.log.debug(\"<STR_LIT>\",<EOL>data)<EOL>self.pass_to_client('<STR_LIT:data>', data, ts)<EOL>", "docstring": "Handles data messages by passing them up to the client.\n\n        :param data:\n        :param ts:\n        :return:", "id": "f9861:c0:m24"}
{"signature": "def __init__(self, *args, url=None, timeout=None, sslopt=None,<EOL>http_proxy_host=None, http_proxy_port=None, http_proxy_auth=None, http_no_proxy=None,<EOL>reconnect_interval=None, log_level=None, **kwargs):", "body": "<EOL>self.q = Queue()<EOL>self.socket = None<EOL>self.url = url if url else '<STR_LIT>'<EOL>self.sslopt = sslopt if sslopt else {}<EOL>self.http_proxy_host = http_proxy_host<EOL>self.http_proxy_port = http_proxy_port<EOL>self.http_proxy_auth = http_proxy_auth<EOL>self.http_no_proxy = http_no_proxy<EOL>self.channel_configs = OrderedDict()<EOL>self.connected = Event()<EOL>self.disconnect_called = Event()<EOL>self.reconnect_required = Event()<EOL>self.reconnect_interval = reconnect_interval if reconnect_interval else <NUM_LIT:10><EOL>self.paused = Event()<EOL>self.ping_timer = None<EOL>self.ping_interval = <NUM_LIT><EOL>self.connection_timer = None<EOL>self.connection_timeout = timeout if timeout else <NUM_LIT:10><EOL>self.pong_timer = None<EOL>self.pong_received = False<EOL>self.pong_timeout = <NUM_LIT:30><EOL>self.log = logging.getLogger(self.__module__)<EOL>if log_level == logging.DEBUG:<EOL><INDENT>websocket.enableTrace(True)<EOL><DEDENT>self.log.setLevel(level=log_level if log_level else logging.INFO)<EOL>Thread.__init__(self)<EOL>self.daemon = True<EOL>self.bitfinex_config = None<EOL>", "docstring": "Initialize a WebSocketConnection Instance.\n\n        :param data_q: Queue(), connection to the Client Class\n        :param args: args for Thread.__init__()\n        :param url: websocket address, defaults to v2 websocket.\n        :param http_proxy_host: proxy host name.\n        :param http_proxy_port: http proxy port. If not set, set to 80.\n        :param http_proxy_auth: http proxy auth information.\n                                tuple of username and password.\n        :param http_no_proxy: host names, which doesn't use proxy. \n        :param timeout: timeout for connection; defaults to 10s\n        :param reconnect_interval: interval at which to try reconnecting;\n                                   defaults to 10s.\n        :param log_level: logging level for the connection Logger. Defaults to\n                          logging.INFO.\n        :param kwargs: kwargs for Thread.__ini__()", "id": "f9861:c0:m0"}
{"signature": "def _pong_handler(self):", "body": "<EOL>self.log.debug(\"<STR_LIT>\")<EOL>self.pong_received = True<EOL>", "docstring": "Handle a pong response.\n\n        :return:", "id": "f9861:c0:m19"}
{"signature": "def _info_handler(self, data):", "body": "def raise_exception():<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>self.log.error(\"<STR_LIT>\", data['<STR_LIT:code>'], info_message[data['<STR_LIT:code>']])<EOL>raise ValueError(\"<STR_LIT>\" % (data['<STR_LIT:code>'], info_message[data['<STR_LIT:code>']]))<EOL><DEDENT>if '<STR_LIT:code>' not in data and '<STR_LIT:version>' in data:<EOL><INDENT>self.log.info('<STR_LIT>', data['<STR_LIT:version>'])<EOL>return<EOL><DEDENT>info_message = {<NUM_LIT>: '<STR_LIT>',<EOL><NUM_LIT>: '<STR_LIT>'<EOL>'<STR_LIT>',<EOL><NUM_LIT>: '<STR_LIT>'<EOL>'<STR_LIT>',<EOL><NUM_LIT>: '<STR_LIT>'<EOL>'<STR_LIT>'}<EOL>codes = {<NUM_LIT>: self.reconnect, <NUM_LIT>: self._pause,<EOL><NUM_LIT>: self._unpause}<EOL>if '<STR_LIT:version>' in data:<EOL><INDENT>self.log.info(\"<STR_LIT>\", data['<STR_LIT:version>'])<EOL>return<EOL><DEDENT>try:<EOL><INDENT>self.log.info(info_message[data['<STR_LIT:code>']])<EOL>codes[data['<STR_LIT:code>']]()<EOL><DEDENT>except KeyError as e:<EOL><INDENT>self.log.exception(e)<EOL>self.log.error(\"<STR_LIT>\", data['<STR_LIT:code>'])<EOL>raise<EOL><DEDENT>", "docstring": "Handle INFO messages from the API and issues relevant actions.\n\n:param data:\n:param ts:", "id": "f9861:c0:m22"}
{"signature": "def send(self, api_key=None, secret=None, list_data=None, auth=False, **kwargs):", "body": "if auth:<EOL><INDENT>nonce = str(int(time.time() * <NUM_LIT>))<EOL>auth_string = '<STR_LIT>' + nonce<EOL>auth_sig = hmac.new(secret.encode(), auth_string.encode(),<EOL>hashlib.sha384).hexdigest()<EOL>payload = {'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': api_key, '<STR_LIT>': auth_sig,<EOL>'<STR_LIT>': auth_string, '<STR_LIT>': nonce}<EOL>payload = json.dumps(payload)<EOL><DEDENT>elif list_data:<EOL><INDENT>payload = json.dumps(list_data)<EOL><DEDENT>else:<EOL><INDENT>payload = json.dumps(kwargs)<EOL><DEDENT>self.log.debug(\"<STR_LIT>\", payload)<EOL>try:<EOL><INDENT>self.socket.send(payload)<EOL><DEDENT>except websocket.WebSocketConnectionClosedException:<EOL><INDENT>self.log.error(\"<STR_LIT>\", kwargs)<EOL><DEDENT>", "docstring": "Sends the given Payload to the API via the websocket connection.\n\n        :param kwargs: payload paarameters as key=value pairs\n        :return:", "id": "f9861:c0:m13"}
{"signature": "def _start_timers(self):", "body": "self.log.debug(\"<STR_LIT>\")<EOL>self._stop_timers()<EOL>self.ping_timer = Timer(self.ping_interval, self.send_ping)<EOL>self.ping_timer.start()<EOL>self.connection_timer = Timer(self.connection_timeout,<EOL>self._connection_timed_out)<EOL>self.connection_timer.start()<EOL>", "docstring": "Resets and starts timers for API data and connection.\n\n        :return:", "id": "f9861:c0:m10"}
{"signature": "def _pause(self):", "body": "self.log.debug(\"<STR_LIT>\")<EOL>self.paused.set()<EOL>", "docstring": "Pauses the connection.\n\n        :return:", "id": "f9861:c0:m16"}
{"signature": "def _resubscribe(self, soft=False):", "body": "<EOL>if self.bitfinex_config:<EOL><INDENT>self.send(**self.bitfinex_config)<EOL><DEDENT>q_list = []<EOL>while True:<EOL><INDENT>try:<EOL><INDENT>identifier, q = self.channel_configs.popitem(last=True if soft else False)<EOL><DEDENT>except KeyError:<EOL><INDENT>break<EOL><DEDENT>q_list.append((identifier, q.copy()))<EOL>if identifier == '<STR_LIT>':<EOL><INDENT>self.send(**q, auth=True)<EOL>continue<EOL><DEDENT>if soft:<EOL><INDENT>q['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>self.send(**q)<EOL><DEDENT>if soft:<EOL><INDENT>for identifier, q in reversed(q_list):<EOL><INDENT>self.channel_configs[identifier] = q<EOL>self.send(**q)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for identifier, q in q_list:<EOL><INDENT>self.channel_configs[identifier] = q<EOL><DEDENT><DEDENT>", "docstring": "Resubscribes to all channels found in self.channel_configs.\n\n        :param soft: if True, unsubscribes first.\n        :return: None", "id": "f9861:c0:m25"}
{"signature": "def pass_to_client(self, event, data, *args):", "body": "self.q.put((event, data, *args))<EOL>", "docstring": "Passes data up to the client via a Queue().\n\n        :param event:\n        :param data:\n        :param args:\n        :return:", "id": "f9861:c0:m14"}
{"signature": "@is_connected<EOL><INDENT>def subscribe_to_ticker(self, pair, **kwargs):<DEDENT>", "body": "identifier = ('<STR_LIT>', pair)<EOL>self._subscribe('<STR_LIT>', identifier, symbol=pair, **kwargs)<EOL>", "docstring": "Subscribe to the passed pair's ticker channel.\n\n        :param pair: str, Symbol pair to request data for\n        :param kwargs:\n        :return:", "id": "f9862:c0:m14"}
{"signature": "@is_connected<EOL><INDENT>def cancel_order(self, multi=False, **order_identifiers):<DEDENT>", "body": "if multi:<EOL><INDENT>self._send_auth_command('<STR_LIT>', order_identifiers)<EOL><DEDENT>else:<EOL><INDENT>self._send_auth_command('<STR_LIT>', order_identifiers)<EOL><DEDENT>", "docstring": "Cancel one or multiple orders via Websocket.\n\n        :param multi: bool, whether order_settings contains settings for one, or\n                      multiples orders\n        :param order_identifiers: Identifiers for the order(s) you with to cancel\n        :return:", "id": "f9862:c0:m26"}
{"signature": "def books(self, pair):", "body": "key = ('<STR_LIT>', pair)<EOL>return self.queue_processor.books[key]<EOL>", "docstring": "Return a queue containing all received book data.\n\n        :param pair:\n        :return: Queue()", "id": "f9862:c0:m7"}
{"signature": "@is_connected<EOL><INDENT>def unsubscribe_from_trades(self, pair, **kwargs):<DEDENT>", "body": "identifier = ('<STR_LIT>', pair)<EOL>self._unsubscribe('<STR_LIT>', identifier, symbol=pair, **kwargs)<EOL>", "docstring": "Unsubscribe to the passed pair's trades channel.\n\n        :param pair: str, Symbol pair to request data for\n        :param kwargs:\n        :return:", "id": "f9862:c0:m21"}
{"signature": "@is_connected<EOL><INDENT>def order_multi_op(self, *operations):<DEDENT>", "body": "self._send_auth_command('<STR_LIT>', operations)<EOL>", "docstring": "Execute multiple, order-related operations via Websocket.\n\n        :param operations: operations to send to the websocket\n        :return:", "id": "f9862:c0:m27"}
{"signature": "@is_connected<EOL><INDENT>def subscribe_to_raw_order_book(self, pair, prec=None, **kwargs):<DEDENT>", "body": "identifier = ('<STR_LIT>', pair)<EOL>prec = '<STR_LIT>' if prec is None else prec<EOL>self._subscribe('<STR_LIT>', identifier, pair=pair, prec=prec, **kwargs)<EOL>", "docstring": "Subscribe to the passed pair's raw order book channel.\n\n        :param pair: str, Symbol pair to request data for\n        :param prec:\n        :param kwargs:\n        :return:", "id": "f9862:c0:m18"}
{"signature": "def raw_books(self, pair):", "body": "key = ('<STR_LIT>', pair)<EOL>return self.queue_processor.raw_books[key]<EOL>", "docstring": "Return a queue containing all received raw book data.\n\n        :param pair:\n        :return: Queue()", "id": "f9862:c0:m8"}
{"signature": "def _handle_auth(self, dtype, data, ts):", "body": "<EOL>if dtype == '<STR_LIT>':<EOL><INDENT>raise NotImplementedError<EOL><DEDENT>channel_id = data.pop('<STR_LIT>')<EOL>user_id = data.pop('<STR_LIT>')<EOL>identifier = ('<STR_LIT>', user_id)<EOL>self.channel_handlers[identifier] = channel_id<EOL>self.channel_directory[identifier] = channel_id<EOL>self.channel_directory[channel_id] = identifier<EOL>", "docstring": "Handles authentication responses.\n\n        :param dtype:\n        :param data:\n        :param ts:\n        :return:", "id": "f9864:c0:m5"}
{"signature": "def _handle_account(self, data, ts):", "body": "<EOL>chan_id, channel_short_name, *data = data<EOL>entry = (channel_short_name, data, ts)<EOL>self.account.put(entry)<EOL>", "docstring": "Handles Account related data.\n\n        translation table for channel names:\n            Data Channels\n            os      -   Orders\n            hos     -   Historical Orders\n            ps      -   Positions\n            hts     -   Trades (snapshot)\n            te      -   Trade Event\n            tu      -   Trade Update\n            ws      -   Wallets\n            bu      -   Balance Info\n            miu     -   Margin Info\n            fiu     -   Funding Info\n            fos     -   Offers\n            hfos    -   Historical Offers\n            fcs     -   Credits\n            hfcs    -   Historical Credits\n            fls     -   Loans\n            hfls    -   Historical Loans\n            htfs    -   Funding Trades\n            n       -   Notifications (WIP)\n\n        :param dtype:\n        :param data:\n        :param ts:\n        :return:", "id": "f9864:c0:m8"}
{"signature": "def __init__(self, data_q, log_level=None,<EOL>*args, **kwargs):", "body": "super(QueueProcessor, self).__init__(*args, **kwargs)<EOL>self.q = data_q<EOL>self._response_handlers = {'<STR_LIT>': self._handle_unsubscribed,<EOL>'<STR_LIT>': self._handle_subscribed,<EOL>'<STR_LIT>': self._handle_conf,<EOL>'<STR_LIT>': self._handle_auth,<EOL>'<STR_LIT>': self._handle_auth}<EOL>self._data_handlers = {'<STR_LIT>': self._handle_ticker,<EOL>'<STR_LIT>': self._handle_book,<EOL>'<STR_LIT>': self._handle_raw_book,<EOL>'<STR_LIT>': self._handle_candles,<EOL>'<STR_LIT>': self._handle_trades}<EOL>self._registry = {}<EOL>self.channel_directory = {}<EOL>self.channel_handlers = {}<EOL>self.last_update = {}<EOL>self.tickers = defaultdict(Queue)<EOL>self.books = defaultdict(Queue)<EOL>self.raw_books = defaultdict(Queue)<EOL>self.trades = defaultdict(Queue)<EOL>self.candles = defaultdict(Queue)<EOL>self.account = Queue()<EOL>self._stopped = Event()<EOL>self.log = logging.getLogger(self.__module__)<EOL>self.log.setLevel(level=logging.INFO if not log_level else log_level)<EOL>", "docstring": "Initialze a QueueProcessor instance.\n\n        :param data_q: Queue()\n        :param log_level: logging level\n        :param args: Thread *args\n        :param kwargs: Thread **kwargs", "id": "f9864:c0:m0"}
{"signature": "def _handle_unsubscribed(self, dtype, data, ts):", "body": "self.log.debug(\"<STR_LIT>\", dtype, data, ts)<EOL>channel_id = data.pop('<STR_LIT>')<EOL>chan_identifier = self.channel_directory.pop(channel_id)<EOL>self.channel_directory.pop(chan_identifier)<EOL>self.channel_handlers.pop(channel_id)<EOL>self.last_update.pop(channel_id)<EOL>self.log.info(\"<STR_LIT>\", chan_identifier)<EOL>", "docstring": "Handles responses to unsubscribe() commands.\n\n        Removes a channel id from the client.\n\n        :param dtype:\n        :param data:\n        :param ts:\n        :return:", "id": "f9864:c0:m4"}
{"signature": "def _handle_trades(self, dtype, data, ts):", "body": "self.log.debug(\"<STR_LIT>\", dtype, data, ts)<EOL>channel_id, *data = data<EOL>channel_identifier = self.channel_directory[channel_id]<EOL>entry = (data, ts)<EOL>self.trades[channel_identifier].put(entry)<EOL>", "docstring": "Files trades in self._trades[chan_id].\n\n        :param dtype:\n        :param data:\n        :param ts:\n        :return:", "id": "f9864:c0:m12"}
{"signature": "def run(self):", "body": "while not self._stopped.is_set():<EOL><INDENT>try:<EOL><INDENT>message = self.q.get(timeout=<NUM_LIT:0.1>)<EOL><DEDENT>except Empty:<EOL><INDENT>continue<EOL><DEDENT>dtype, data, ts = message<EOL>if dtype in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>try:<EOL><INDENT>self._response_handlers[dtype](dtype, data, ts)<EOL><DEDENT>except KeyError:<EOL><INDENT>self.log.error(\"<STR_LIT>\"<EOL>\"<STR_LIT>\", dtype, message)<EOL><DEDENT><DEDENT>elif dtype == '<STR_LIT:data>':<EOL><INDENT>try:<EOL><INDENT>channel_id = data[<NUM_LIT:0>]<EOL>if channel_id != <NUM_LIT:0>:<EOL><INDENT>channel_type, *_ = self.channel_directory[channel_id]<EOL>self._data_handlers[channel_type](channel_type, data, ts)<EOL>self.update_timestamps(channel_id, ts)<EOL><DEDENT>else:<EOL><INDENT>self._handle_account(data=data, ts=ts)<EOL><DEDENT><DEDENT>except KeyError:<EOL><INDENT>self.log.error(\"<STR_LIT>\",<EOL>message)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.log.error(\"<STR_LIT>\", message)<EOL>continue<EOL><DEDENT><DEDENT>", "docstring": "Main routine.\n\n        :return:", "id": "f9864:c0:m2"}
{"signature": "def main(args,parser,subparser):", "body": "from sregistry.main import get_client<EOL>cli = get_client(quiet=args.quiet)<EOL>for query in args.query:<EOL><INDENT>if query in ['<STR_LIT>','<STR_LIT:*>']:<EOL><INDENT>query = None<EOL><DEDENT>cli.ls(query=query)<EOL><DEDENT>", "docstring": "the list command corresponds with listing images for an external\n       resource. This is different from listing images that are local to the\n       database, which should be done with \"images\"", "id": "f9872:m0"}
{"signature": "def instances():", "body": "from sregistry.main import Client as cli<EOL>cli.list_builders()<EOL>sys.exit(<NUM_LIT:0>)<EOL>", "docstring": "list running instances for a user, including all builders and report\n       instance names and statuses.", "id": "f9876:m3"}
{"signature": "def templates(args, template_name=None):", "body": "from sregistry.main import get_client<EOL>cli = get_client(init=False)<EOL>if len(args.commands) > <NUM_LIT:0>:<EOL><INDENT>template_name = args.commands.pop(<NUM_LIT:0>)<EOL><DEDENT>cli.list_templates(template_name)<EOL>sys.exit(<NUM_LIT:0>)<EOL>", "docstring": "list a specific template (if a name is provided) or all templates\n       available.\n\n       Parameters\n       ==========\n       args: the argparse object to look for a template name\n       template_name: if not set, show all", "id": "f9876:m4"}
{"signature": "def main(args,parser,subparser):", "body": "from sregistry.main import get_client<EOL>cli = get_client(quiet=args.quiet)<EOL>for query in args.query:<EOL><INDENT>if query in ['<STR_LIT>','<STR_LIT:*>']:<EOL><INDENT>query = None<EOL><DEDENT>cli.images(query=query)<EOL><DEDENT>", "docstring": "the images entrypoint is intended to list images locally in the user\n       database, optionally taking one or more query string to subset the \n       search", "id": "f9878:m0"}
{"signature": "def add(backend, variable, value, force=False):", "body": "print('<STR_LIT>')<EOL>settings = read_client_secrets()<EOL>prefix = '<STR_LIT>' %backend.upper()<EOL>if not variable.startswith(prefix):<EOL><INDENT>variable = '<STR_LIT>' %(prefix, variable)<EOL><DEDENT>variable = variable.upper()<EOL>bot.info(\"<STR_LIT>\" %(variable, value))<EOL>if backend in settings:<EOL><INDENT>if variable in settings[backend] and force is False:<EOL><INDENT>previous = settings[backend][variable]<EOL>bot.error('<STR_LIT>' %(variable, previous))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>if backend not in settings:<EOL><INDENT>settings[backend] = {}<EOL><DEDENT>settings[backend][variable] = value<EOL>update_secrets(settings)<EOL>", "docstring": "add the variable to the config", "id": "f9888:m3"}
{"signature": "def activate(backend):", "body": "settings = read_client_secrets()<EOL>if backend is not None:<EOL><INDENT>settings['<STR_LIT>'] = backend<EOL>update_secrets(settings)<EOL>print('<STR_LIT>' %backend)<EOL><DEDENT>", "docstring": "activate a backend by adding it to the .sregistry configuration file.", "id": "f9888:m5"}
{"signature": "def get_cache(subfolder=None, quiet=False):", "body": "DISABLE_CACHE = convert2boolean(getenv(\"<STR_LIT>\",<EOL>default=False))<EOL>if DISABLE_CACHE:<EOL><INDENT>SINGULARITY_CACHE = tempfile.mkdtemp()<EOL><DEDENT>else:<EOL><INDENT>userhome = pwd.getpwuid(os.getuid())[<NUM_LIT:5>]<EOL>_cache = os.path.join(userhome, \"<STR_LIT>\")<EOL>SINGULARITY_CACHE = getenv(\"<STR_LIT>\", default=_cache)<EOL><DEDENT>cache_base = clean_path(SINGULARITY_CACHE)<EOL>if subfolder is not None:<EOL><INDENT>cache_base = \"<STR_LIT>\" % (cache_base, subfolder)<EOL><DEDENT>mkdir_p(cache_base)<EOL>if not quiet:<EOL><INDENT>bot.debug(\"<STR_LIT>\" % cache_base)<EOL><DEDENT>return cache_base<EOL>", "docstring": "get_cache will return the user's cache for singularity.\n    :param subfolder: a subfolder in the cache base to retrieve, specifically", "id": "f9890:m3"}
{"signature": "def get_installdir():", "body": "return os.path.abspath(os.path.dirname(os.path.dirname(__file__)))<EOL>", "docstring": "get_installdir returns the installation directory of the application", "id": "f9891:m3"}
{"signature": "def run_command(cmd, sudo=False):", "body": "if sudo is True:<EOL><INDENT>cmd = ['<STR_LIT>'] + cmd<EOL><DEDENT>try:<EOL><INDENT>output = Popen(cmd, stderr=STDOUT, stdout=PIPE)<EOL><DEDENT>except FileNotFoundError:<EOL><INDENT>cmd.pop(<NUM_LIT:0>)<EOL>output = Popen(cmd, stderr=STDOUT, stdout=PIPE)<EOL><DEDENT>t = output.communicate()[<NUM_LIT:0>],output.returncode<EOL>output = {'<STR_LIT:message>':t[<NUM_LIT:0>],<EOL>'<STR_LIT>':t[<NUM_LIT:1>]}<EOL>if isinstance(output['<STR_LIT:message>'], bytes):<EOL><INDENT>output['<STR_LIT:message>'] = output['<STR_LIT:message>'].decode('<STR_LIT:utf-8>')<EOL><DEDENT>return output<EOL>", "docstring": "run_command uses subprocess to send a command to the terminal.\n\n    Parameters\n    ==========\n    cmd: the command to send, should be a list for subprocess\n    error_message: the error message to give to user if fails,\n    if none specified, will alert that command failed.", "id": "f9891:m5"}
{"signature": "def format_container_name(name, special_characters=None):", "body": "if special_characters is None:<EOL><INDENT>special_characters = []<EOL><DEDENT>return '<STR_LIT>'.join(e.lower()<EOL>for e in name if e.isalnum() or e in special_characters)<EOL>", "docstring": "format_container_name will take a name supplied by the user,\n    remove all special characters (except for those defined by \"special-characters\"\n    and return the new image name.", "id": "f9893:m3"}
{"signature": "def get_image_hash(image_path):", "body": "hasher = hashlib.md5()<EOL>with open(image_path, \"<STR_LIT:rb>\") as f:<EOL><INDENT>for chunk in iter(lambda: f.read(<NUM_LIT>), b\"<STR_LIT>\"):<EOL><INDENT>hasher.update(chunk)<EOL><DEDENT><DEDENT>return hasher.hexdigest()<EOL>", "docstring": "return an md5 hash of the file based on a criteria level. This\n       is intended to give the file a reasonable version.\n\n       Parameters\n       ==========\n       image_path: full path to the singularity image", "id": "f9893:m0"}
{"signature": "def _extract_tar(archive, output_folder):", "body": "from .terminal import ( run_command, which )<EOL>result = which('<STR_LIT>')<EOL>if result['<STR_LIT>'] != <NUM_LIT:0>:<EOL><INDENT>bot.error('<STR_LIT>')<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>script = result['<STR_LIT:message>'] <EOL>command = ['<STR_LIT>' ,script, '<STR_LIT>', archive, '<STR_LIT>', output_folder]<EOL>if not bot.is_quiet():<EOL><INDENT>print(\"<STR_LIT>\" % archive)<EOL><DEDENT>return run_command(command)<EOL>", "docstring": "use blob2oci to handle whiteout files for extraction. Credit for this\n       script goes to docker2oci by Olivier Freyermouth, and see script\n       folder for license.\n\n       Parameters\n       ==========\n       archive: the archive to extract\n       output_folder the output folder (sandbox) to extract to", "id": "f9894:m5"}
{"signature": "def write_json(json_obj, filename, mode=\"<STR_LIT:w>\", print_pretty=True):", "body": "with open(filename, mode) as filey:<EOL><INDENT>if print_pretty:<EOL><INDENT>filey.writelines(print_json(json_obj))<EOL><DEDENT>else:<EOL><INDENT>filey.writelines(json.dumps(json_obj))<EOL><DEDENT><DEDENT>return filename<EOL>", "docstring": "write_json will (optionally,pretty print) a json object to file\n\n       Parameters\n       ==========\n       json_obj: the dict to print to json\n       filename: the output file to write to\n       pretty_print: if True, will use nicer formatting", "id": "f9894:m11"}
{"signature": "def read_json(filename, mode='<STR_LIT:r>'):", "body": "with open(filename, mode) as filey:<EOL><INDENT>data = json.load(filey)<EOL><DEDENT>return data<EOL>", "docstring": "read_json reads in a json file and returns\n       the data structure as dict.", "id": "f9894:m14"}
{"signature": "def get_userhome():", "body": "return pwd.getpwuid(os.getuid())[<NUM_LIT:5>]<EOL>", "docstring": "get the user home based on the effective uid", "id": "f9894:m3"}
{"signature": "def print_json(json_obj):", "body": "return json.dumps(<EOL>json_obj,<EOL>indent=<NUM_LIT:4>,<EOL>separators=(<EOL>'<STR_LIT:U+002C>',<EOL>'<STR_LIT>'))<EOL>", "docstring": "just dump the json in a \"pretty print\" format", "id": "f9894:m12"}
{"signature": "def mkdir_p(path):", "body": "try:<EOL><INDENT>os.makedirs(path)<EOL><DEDENT>except OSError as e:<EOL><INDENT>if e.errno == errno.EEXIST and os.path.isdir(path):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>bot.error(\"<STR_LIT>\" % path)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>", "docstring": "mkdir_p attempts to get the same functionality as mkdir -p\n    :param path: the path to create.", "id": "f9894:m0"}
{"signature": "def get_recipe_tag(path):", "body": "tag = re.sub('<STR_LIT>','<STR_LIT>', path)<EOL>if tag in ['<STR_LIT>', None]:<EOL><INDENT>tag = '<STR_LIT>'<EOL><DEDENT>return tag<EOL>", "docstring": "get a recipe tag (the extension of a Singularity file). The extension\n       determines the tag. If no extension is found, latest is used.\n\n       Parameters\n       ==========\n       path: the path to the recipe file (e.g. /opt/Singularity.tag)", "id": "f9895:m0"}
{"signature": "def parse_header(recipe, header=\"<STR_LIT>\", remove_header=True):", "body": "parsed_header = None<EOL>fromline = [x for x in recipe.split('<STR_LIT:\\n>') if \"<STR_LIT>\" %header in x.lower()]<EOL>if len(fromline) == <NUM_LIT:0>:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>if len(fromline) > <NUM_LIT:0>:<EOL><INDENT>fromline = fromline[<NUM_LIT:0>]<EOL>parsed_header = fromline.strip()<EOL><DEDENT>if remove_header is True:<EOL><INDENT>parsed_header = fromline.split('<STR_LIT::>', <NUM_LIT:1>)[-<NUM_LIT:1>].strip()<EOL><DEDENT>return parsed_header<EOL>", "docstring": "take a recipe, and return the complete header, line. If\n       remove_header is True, only return the value.\n\n       Parameters\n       ==========\n       recipe: the recipe file\n       headers: the header key to find and parse\n       remove_header: if true, remove the key", "id": "f9895:m1"}
{"signature": "def rmi(self, image_name):", "body": "container = self.rm(image_name, delete=True)<EOL>if container is not None:<EOL><INDENT>bot.info(\"<STR_LIT>\" % container)<EOL><DEDENT>", "docstring": "Remove an image from the database and filesystem.", "id": "f9896:m9"}
{"signature": "def rm(self, image_name, delete=False):", "body": "container = self.get(image_name)<EOL>if container is not None:<EOL><INDENT>name = container.uri or container.get_uri()<EOL>image = container.image<EOL>self.session.delete(container)<EOL>self.session.commit()<EOL>if image is not None:<EOL><INDENT>if os.path.exists(image) and delete is True:<EOL><INDENT>os.remove(container.image)<EOL><DEDENT>return image<EOL><DEDENT>bot.info(\"<STR_LIT>\" % name)<EOL><DEDENT>", "docstring": "Remove an image from the database, akin to untagging the image. This\n    does not delete the file from the cache, unless delete is set to True\n    (as called by rmi).", "id": "f9896:m10"}
{"signature": "def add(self, image_path=None,<EOL>image_uri=None,<EOL>image_name=None,<EOL>url=None,<EOL>metadata=None,<EOL>save=True, <EOL>copy=False):", "body": "from sregistry.database.models import (<EOL>Container,<EOL>Collection<EOL>)<EOL>if image_path is not None:<EOL><INDENT>if not os.path.exists(image_path) and save is True:<EOL><INDENT>bot.error('<STR_LIT>' %image_path)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>if image_uri is None:<EOL><INDENT>bot.error('<STR_LIT>')<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>names = parse_image_name( remove_uri(image_uri) )<EOL>bot.debug('<STR_LIT>' % names['<STR_LIT>'])    <EOL>metadata = self.get_metadata(image_path, names=names)<EOL>collection = self.get_or_create_collection(names['<STR_LIT>'])<EOL>version = names.get('<STR_LIT:version>')<EOL>if version == None:<EOL><INDENT>if image_path != None:<EOL><INDENT>version = get_image_hash(image_path)<EOL><DEDENT>else:<EOL><INDENT>version = '<STR_LIT>'  <EOL><DEDENT>names = parse_image_name( remove_uri(image_uri), version=version )<EOL><DEDENT>if save is True and image_path is not None:<EOL><INDENT>if image_name is None:      <EOL><INDENT>image_name = self._get_storage_name(names)<EOL><DEDENT>if copy is True:<EOL><INDENT>copyfile(image_path, image_name)<EOL><DEDENT>else:<EOL><INDENT>shutil.move(image_path, image_name)<EOL><DEDENT>image_path = image_name<EOL><DEDENT>if url is None and \"<STR_LIT:url>\" in metadata:<EOL><INDENT>url = metadata['<STR_LIT:url>']<EOL><DEDENT>container = self.get_container(name=names['<STR_LIT:image>'],<EOL>collection_id=collection.id, <EOL>tag=names['<STR_LIT>'],<EOL>version=version)<EOL>if container is None:<EOL><INDENT>action = \"<STR_LIT>\"<EOL>container = Container(metrics=json.dumps(metadata),<EOL>name=names['<STR_LIT:image>'],<EOL>image=image_path,<EOL>client=self.client_name,<EOL>tag=names['<STR_LIT>'],<EOL>version=version,<EOL>url=url,<EOL>uri=names['<STR_LIT>'],<EOL>collection_id=collection.id)<EOL>self.session.add(container)<EOL>collection.containers.append(container)<EOL><DEDENT>else:<EOL><INDENT>action=\"<STR_LIT>\"<EOL>metrics=json.loads(container.metrics)<EOL>metrics.update(metadata)<EOL>container.url= url<EOL>container.client=self.client_name<EOL>if image_path is not None:<EOL><INDENT>container.image=image_path<EOL><DEDENT>container.metrics=json.dumps(metrics)<EOL><DEDENT>self.session.commit()<EOL>bot.info(\"<STR_LIT>\" % (action,names['<STR_LIT>']))<EOL>return container<EOL>", "docstring": "get or create a container, including the collection to add it to.\n    This function can be used from a file on the local system, or via a URL\n    that has been downloaded. Either way, if one of url, version, or image_file\n    is not provided, the model is created without it. If a version is not\n    provided but a file path is, then the file hash is used.\n\n    Parameters\n    ==========\n    image_path: full path to image file\n    image_name: if defined, the user wants a custom name (and not based on uri)\n    metadata: any extra metadata to keep for the image (dict)\n    save: if True, move the image to the cache if it's not there\n    copy: If True, copy the image instead of moving it.\n\n    image_name: a uri that gets parsed into a names object that looks like:\n\n    {'collection': 'vsoch',\n     'image': 'hello-world',\n     'storage': 'vsoch/hello-world-latest.img',\n     'tag': 'latest',\n     'version': '12345'\n     'uri': 'vsoch/hello-world:latest@12345'}\n\n    After running add, the user will take some image in a working\n    directory, add it to the database, and have it available for search\n    and use under SREGISTRY_STORAGE/<collection>/<container>\n\n    If the container was retrieved from a webby place, it should have version\n    If no version is found, the file hash is used.", "id": "f9896:m11"}
{"signature": "def init_db(self, db_path=None):", "body": "<EOL>self.database = '<STR_LIT>'<EOL>", "docstring": "initialize the database, meaning we just set the name to be dummy", "id": "f9897:m1"}
{"signature": "def init_db(self, db_path):", "body": "<EOL>self.database = '<STR_LIT>' % db_path<EOL>self.storage = SREGISTRY_STORAGE<EOL>bot.debug(\"<STR_LIT>\" % self.database)<EOL>self.engine = create_engine(self.database, convert_unicode=True)<EOL>self.session = scoped_session(sessionmaker(autocommit=False,<EOL>autoflush=False,<EOL>bind=self.engine))<EOL>Base.query = self.session.query_property()<EOL>Base.metadata.create_all(bind=self.engine)<EOL>self.Base = Base<EOL>", "docstring": "initialize the database, with the default database path or custom of\n\n       the format sqlite:////scif/data/expfactory.db\n\n    The custom path can be set with the environment variable SREGISTRY_DATABASE\n    when a user creates the client, we must initialize this db\n    the database should use the .singularity cache folder to cache\n    layers and images, and .singularity/sregistry.db as a database", "id": "f9899:m0"}
{"signature": "def url(self):", "body": "return \"<STR_LIT>\"<EOL>", "docstring": "return the collection url", "id": "f9899:c0:m3"}
{"signature": "def addColor(self, level, text):", "body": "if self.colorize:<EOL><INDENT>if level in self.colors:<EOL><INDENT>text = \"<STR_LIT>\" % (self.colors[level],<EOL>text,<EOL>self.colors[\"<STR_LIT>\"])<EOL><DEDENT><DEDENT>return text<EOL>", "docstring": "addColor to the prompt (usually prefix) if terminal\n        supports, and specified to do so", "id": "f9902:c0:m2"}
{"signature": "def write(self, stream, message):", "body": "if isinstance(message, bytes):<EOL><INDENT>message = message.decode('<STR_LIT:utf-8>')<EOL><DEDENT>stream.write(message)<EOL>", "docstring": "write will write a message to a stream,\n        first checking the encoding", "id": "f9902:c0:m7"}
{"signature": "def isEnabledFor(self, messageLevel):", "body": "if messageLevel <= self.level:<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "check if a messageLevel is enabled to emit a level", "id": "f9902:c0:m5"}
{"signature": "def emit(self, level, message, prefix=None, color=None):", "body": "if color is None:<EOL><INDENT>color = level<EOL><DEDENT>if prefix is not None:<EOL><INDENT>prefix = self.addColor(color, \"<STR_LIT>\" % (prefix))<EOL><DEDENT>else:<EOL><INDENT>prefix = \"<STR_LIT>\"<EOL>message = self.addColor(color, message)<EOL><DEDENT>message = \"<STR_LIT>\" % (prefix, message)<EOL>if not message.endswith('<STR_LIT:\\n>'):<EOL><INDENT>message = \"<STR_LIT>\" % message<EOL><DEDENT>if self.level == QUIET:<EOL><INDENT>pass<EOL><DEDENT>elif self.isEnabledFor(level):<EOL><INDENT>if self.emitError(level):<EOL><INDENT>self.write(self.errorStream, message)<EOL><DEDENT>else:<EOL><INDENT>self.write(self.outputStream, message)<EOL><DEDENT><DEDENT>self.history.append(message)<EOL>", "docstring": "emit is the main function to print the message\n        optionally with a prefix\n        :param level: the level of the message\n        :param message: the message to print\n        :param prefix: a prefix for the message", "id": "f9902:c0:m6"}
{"signature": "def _select(self, select_from):", "body": "if len(select_from) <= <NUM_LIT:0>:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>return choice(select_from)<EOL>", "docstring": "select an element from a list using random.choice\n\n            Parameters\n            ==========\n            should be a list of things to select from", "id": "f9904:c0:m1"}
{"signature": "def generate(self, delim='<STR_LIT:->', length=<NUM_LIT:4>, chars='<STR_LIT>'):", "body": "descriptor = self._select(self._descriptors)<EOL>noun = self._select(self._nouns)<EOL>numbers = '<STR_LIT>'.join((self._select(chars) for _ in range(length)))<EOL>return delim.join([descriptor, noun, numbers])<EOL>", "docstring": "Generate a robot name. Inspiration from Haikunator, but much more\n         poorly implemented ;)\n\nParameters\n==========\ndelim: Delimiter\nlength: TokenLength\nchars: TokenChars", "id": "f9904:c0:m0"}
{"signature": "def _speak(self):", "body": "bot.info('<STR_LIT>' % self._bucket_name)<EOL>", "docstring": "add the bucket name to be printed to the user at appropriate times", "id": "f9910:c0:m1"}
{"signature": "def print_log(self, logname):", "body": "content = None<EOL>logfile = self._bucket.get_blob(logname)<EOL>print(logname)<EOL>if logfile:<EOL><INDENT>bot.info('<STR_LIT>' %logname)<EOL>content = requests.get(logfile.media_link).text<EOL>print(content)<EOL><DEDENT>return content<EOL>", "docstring": "helper function to retrieve a particular log, and print.\n\n       Parameters\n       ==========\n       name: the name of the log to retrieve", "id": "f9911:m2"}
{"signature": "def delete(self, name):", "body": "bot.debug(\"<STR_LIT>\" % name)<EOL>for file_object in files:<EOL><INDENT>if isinstance(file_object, dict):<EOL><INDENT>if \"<STR_LIT>\" in file_object:<EOL><INDENT>if file_object['<STR_LIT>'] == \"<STR_LIT>\":<EOL><INDENT>object_name = \"<STR_LIT:/>\".join(file_object['<STR_LIT:id>'].split('<STR_LIT:/>')[:-<NUM_LIT:1>])<EOL>object_name = re.sub('<STR_LIT>' %self._bucket['<STR_LIT:name>'],'<STR_LIT>', object_name,<NUM_LIT:1>)<EOL>delete_object(service=self._bucket_service,<EOL>bucket_name=bucket['<STR_LIT:name>'],<EOL>object_name=object_name)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "delete an image from Google Storage.\n\n       Parameters\n       ==========\n       name: the name of the file (or image) to delete", "id": "f9912:m1"}
{"signature": "def pull(self, images, file_name=None, save=True, force=False, **kwargs):", "body": "if not isinstance(images,list):<EOL><INDENT>images = [images]<EOL><DEDENT>bot.debug('<STR_LIT>' %len(images))<EOL>finished = []<EOL>for image in images:<EOL><INDENT>q = parse_image_name( remove_uri(image), <EOL>default_collection='<STR_LIT>' )<EOL>image_file = self._pull(file_name=file_name, <EOL>save=save, <EOL>force=force, <EOL>names=q,<EOL>kwargs=kwargs)<EOL>finished.append(image_file)<EOL><DEDENT>if len(finished) == <NUM_LIT:1>:<EOL><INDENT>finished = finished[<NUM_LIT:0>]<EOL><DEDENT>return finished<EOL>", "docstring": "pull an image from a docker hub. This is a (less than ideal) workaround\n       that actually does the following:\n\n       - creates a sandbox folder\n       - adds docker layers, metadata folder, and custom metadata to it\n       - converts to a squashfs image with build\n\n    the docker manifests are stored with registry metadata.\n\n    Parameters\n    ==========\n    images: refers to the uri given by the user to pull in the format\n    <collection>/<namespace>. You should have an API that is able to \n    retrieve a container based on parsing this uri.\n    file_name: the user's requested name for the file. It can \n               optionally be None if the user wants a default.\n    save: if True, you should save the container to the database\n          using self.add()\n\n    Returns\n    =======\n    finished: a single container path, or list of paths", "id": "f9914:m0"}
{"signature": "def __init__(self, secrets=None, **kwargs):", "body": "self.reverseLayers = False<EOL>self._reset_headers()<EOL>self._update_secrets()<EOL>self._set_base()<EOL>self._update_headers()<EOL>super(ApiConnection, self).__init__(**kwargs)<EOL>", "docstring": "to work with nvidia container registry. If you need help with\n           their API, the best reference is:\n\n           https://docs.aws.amazon.com/AmazonECR/latest/APIReference/ecr-api.pdf", "id": "f9915:c0:m0"}
{"signature": "def _update_secrets(self):", "body": "bot.debug('<STR_LIT>')<EOL>try:<EOL><INDENT>from awscli.clidriver import create_clidriver<EOL><DEDENT>except:<EOL><INDENT>bot.exit('<STR_LIT>')<EOL><DEDENT>driver = create_clidriver()<EOL>self.aws = driver.session.create_client('<STR_LIT>')<EOL>", "docstring": "update secrets will take a secrets credential file\n           either located at .sregistry or the environment variable\n           SREGISTRY_CLIENT_SECRETS and update the current client \n           secrets as well as the associated API base. For the case of\n           using Docker Hub, if we find a .docker secrets file, we update\n           from there.", "id": "f9915:c0:m4"}
{"signature": "def get_manifest(self, repo_name, tag):", "body": "image = None<EOL>repo = self.aws.describe_images(repositoryName=repo_name)<EOL>if '<STR_LIT>' in repo:<EOL><INDENT>for contender in repo.get('<STR_LIT>'):<EOL><INDENT>if tag in contender['<STR_LIT>']:<EOL><INDENT>image = contender<EOL>break<EOL><DEDENT><DEDENT><DEDENT>if image is None:<EOL><INDENT>bot.exit('<STR_LIT>' %(repo_name, digest))<EOL><DEDENT>digest = image['<STR_LIT>']<EOL>digests = self.aws.batch_get_image(repositoryName=repo_name, <EOL>imageIds=[{\"<STR_LIT>\": digest,<EOL>\"<STR_LIT>\": tag}])<EOL>self.manifest = json.loads(digests['<STR_LIT>'][<NUM_LIT:0>]['<STR_LIT>'])<EOL>return self.manifest<EOL>", "docstring": "return the image manifest via the aws client, saved in self.manifest", "id": "f9916:m2"}
{"signature": "def get_digests(self, repo_name, tag):", "body": "if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>bot.error('<STR_LIT>')<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>return self.manifest['<STR_LIT>']<EOL>", "docstring": "return a list of layers from a manifest.\nThe function is intended to work with both version\n1 and 2 of the schema. All layers (including redundant)\nare returned. By default, we try version 2 first,\nthen fall back to version 1.\n\nFor version 1 manifests: extraction is reversed\n\nParameters\n==========\nmanifest: the manifest to read_layers from", "id": "f9916:m3"}
{"signature": "def call(url, func, data=None, headers=None, <EOL>return_json=True, stream=False, <EOL>retry=True):", "body": "if DISABLE_SSL_CHECK is True:<EOL><INDENT>bot.warning('<STR_LIT>')<EOL><DEDENT>if data is not None:<EOL><INDENT>if not isinstance(data,dict):<EOL><INDENT>data = json.dumps(data)<EOL><DEDENT><DEDENT>response = func(url=url,<EOL>headers=headers,<EOL>data=data,<EOL>verify=not DISABLE_SSL_CHECK,<EOL>stream=stream)<EOL>if response.status_code in [<NUM_LIT>, <NUM_LIT>]:<EOL><INDENT>bot.error(\"<STR_LIT>\" %(response.reason,<EOL>response.status_code))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>bot.error(\"<STR_LIT>\" %(response.reason,<EOL>response.status_code))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>if retry is True:<EOL><INDENT>headers = update_token(response, headers)<EOL>return call(url, func, data=data,<EOL>headers=headers,<EOL>return_json=return_json,<EOL>stream=stream, retry=False)<EOL><DEDENT>bot.error(\"<STR_LIT>\" %(response.reason,<EOL>response.status_code))<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>elif response.status_code == <NUM_LIT:200>:<EOL><INDENT>if return_json:<EOL><INDENT>try:<EOL><INDENT>response = response.json()<EOL><DEDENT>except ValueError:<EOL><INDENT>bot.error(\"<STR_LIT>\")<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT><DEDENT><DEDENT>return response<EOL>", "docstring": "call will issue the call, and issue a refresh token\n    given a 401 response, and if the client has a _update_token function\n\n    Parameters\n    ==========\n    func: the function (eg, post, get) to call\n    url: the url to send file to\n    headers: headers for the request\n    data: additional data to add to the request\n    return_json: return json if successful", "id": "f9919:m5"}
{"signature": "def download_task(url, headers, destination, download_type='<STR_LIT>'):", "body": "<EOL>bot.verbose(\"<STR_LIT>\" % (download_type, url))<EOL>file_name = \"<STR_LIT>\" % (destination,<EOL>next(tempfile._get_candidate_names()))<EOL>tar_download = download(url, file_name, headers=headers)<EOL>try:<EOL><INDENT>shutil.move(tar_download, destination)<EOL><DEDENT>except Exception:<EOL><INDENT>msg = \"<STR_LIT>\" % tar_download<EOL>msg += \"<STR_LIT>\"<EOL>bot.error(msg)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>return destination<EOL>", "docstring": "download an image layer (.tar.gz) to a specified download folder.\n       This task is done by using local versions of the same download functions\n       that are used for the client.\n       core stream/download functions of the parent client.\n\n       Parameters\n       ==========\n       image_id: the shasum id of the layer, already determined to not exist\n       repo_name: the image name (library/ubuntu) to retrieve\n       download_folder: download to this folder. If not set, uses temp.", "id": "f9919:m0"}
{"signature": "def stream(url, headers, stream_to=None, retry=True):", "body": "bot.debug(\"<STR_LIT>\" %url)<EOL>if DISABLE_SSL_CHECK is True:<EOL><INDENT>bot.warning('<STR_LIT>')<EOL><DEDENT>response = requests.get(url,         <EOL>headers=headers,<EOL>verify=not DISABLE_SSL_CHECK,<EOL>stream=True)<EOL>if response.status_code == <NUM_LIT> and retry is True:<EOL><INDENT>headers = update_token(response, headers)<EOL>return stream(url, headers, stream_to, retry=False)<EOL><DEDENT>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>content_size = None<EOL>if '<STR_LIT>' in response.headers:<EOL><INDENT>progress = <NUM_LIT:0><EOL>content_size = int(response.headers['<STR_LIT>'])<EOL>bot.show_progress(progress,content_size,length=<NUM_LIT>)<EOL><DEDENT>chunk_size = <NUM_LIT:1> << <NUM_LIT:20><EOL>with open(stream_to,'<STR_LIT:wb>') as filey:<EOL><INDENT>for chunk in response.iter_content(chunk_size=chunk_size):<EOL><INDENT>filey.write(chunk)<EOL>if content_size is not None:<EOL><INDENT>progress+=chunk_size<EOL>bot.show_progress(iteration=progress,<EOL>total=content_size,<EOL>length=<NUM_LIT>,<EOL>carriage_return=False)<EOL><DEDENT><DEDENT><DEDENT>sys.stdout.write('<STR_LIT:\\n>')<EOL>return stream_to <EOL><DEDENT>bot.error(\"<STR_LIT>\" %(response.status_code))<EOL>sys.exit(<NUM_LIT:1>)<EOL>", "docstring": "stream is a get that will stream to file_name. Since this is a worker\n       task, it differs from the client provided version in that it requires\n       headers.", "id": "f9919:m4"}
{"signature": "def run(self, func, tasks, func2=None):", "body": "<EOL>progress = <NUM_LIT:1><EOL>total = len(tasks)<EOL>if len(tasks) == <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>if func2 is not None:<EOL><INDENT>total = total * <NUM_LIT:2><EOL><DEDENT>finished = []<EOL>level1 = []<EOL>results = []<EOL>try:<EOL><INDENT>prefix = \"<STR_LIT>\" % (progress, total)<EOL>bot.show_progress(<NUM_LIT:0>, total, length=<NUM_LIT>, prefix=prefix)<EOL>pool = multiprocessing.Pool(self.workers, init_worker)<EOL>self.start()<EOL>for task in tasks:<EOL><INDENT>result = pool.apply_async(multi_wrapper,<EOL>multi_package(func, [task]))<EOL>results.append(result)<EOL>level1.append(result._job)<EOL><DEDENT>while len(results) > <NUM_LIT:0>:<EOL><INDENT>result = results.pop()<EOL>result.wait()<EOL>bot.show_progress(progress, total, length=<NUM_LIT>, prefix=prefix)<EOL>progress += <NUM_LIT:1><EOL>prefix = \"<STR_LIT>\" % (progress, total)<EOL>if func2 is not None and result._job in level1:<EOL><INDENT>result = pool.apply_async(multi_wrapper,<EOL>multi_package(func2,<EOL>[(result.get(),)]))<EOL>results.append(result)<EOL><DEDENT>else:<EOL><INDENT>finished.append(result.get())<EOL><DEDENT><DEDENT>self.end()<EOL>pool.close()<EOL>pool.join()<EOL><DEDENT>except (KeyboardInterrupt, SystemExit):<EOL><INDENT>bot.error(\"<STR_LIT>\")<EOL>pool.terminate()<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>except Exception as e:<EOL><INDENT>bot.error(e)<EOL><DEDENT>return finished<EOL>", "docstring": "run will send a list of tasks,\n        a tuple with arguments, through a function.\n        the arguments should be ordered correctly.\n        :param func: the function to run with multiprocessing.pool\n        :param tasks: a list of tasks, each a tuple\n                      of arguments to process\n        :param func2: filter function to run result\n                      from func through (optional)", "id": "f9920:c0:m3"}
{"signature": "def _update_secrets(self, base=None):", "body": "<EOL>self.base = self._get_and_update_setting('<STR_LIT>', self.base)<EOL>self._id = self._required_get_and_update('<STR_LIT>')<EOL>self._key = self._required_get_and_update('<STR_LIT>')<EOL>self._signature = self._get_and_update_setting('<STR_LIT>')<EOL>if self._signature == '<STR_LIT>':<EOL><INDENT>self._signature = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>self._signature = '<STR_LIT>'<EOL><DEDENT>self.get_bucket_name()<EOL>self.get_resource()<EOL>self.get_bucket()<EOL>", "docstring": "update secrets will update/get the base for the server, along\n           with the bucket name, defaulting to sregistry.", "id": "f9924:c0:m7"}
{"signature": "def get_bucket(self):", "body": "for attr in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>if not hasattr(self, attr):<EOL><INDENT>bot.exit('<STR_LIT>' %(attr))<EOL><DEDENT><DEDENT>self.bucket = None<EOL>for bucket in self.s3.buckets.all():<EOL><INDENT>if bucket.name == self.bucket_name:<EOL><INDENT>self.bucket = bucket<EOL><DEDENT><DEDENT>if self.bucket is None:<EOL><INDENT>self.bucket = self.s3.create_bucket(Bucket=self.bucket_name)<EOL>bot.info('<STR_LIT>' % self.bucket.name )<EOL><DEDENT>return self.bucket<EOL>", "docstring": "given a bucket name and a client that is initialized, get or\n           create the bucket.", "id": "f9924:c0:m5"}
{"signature": "def _read_response(self,response, field=\"<STR_LIT>\"):", "body": "try:<EOL><INDENT>message = json.loads(response._content.decode('<STR_LIT:utf-8>'))[field]<EOL><DEDENT>except:<EOL><INDENT>message = response.reason<EOL><DEDENT>return message<EOL>", "docstring": "attempt to read the detail provided by the response. If none, \n        default to using the reason", "id": "f9924:c0:m3"}
{"signature": "def _pull(self, <EOL>file_name, <EOL>names, <EOL>save=True, <EOL>force=False, <EOL>uri=\"<STR_LIT>\", <EOL>**kwargs):", "body": "<EOL>if file_name is None:<EOL><INDENT>file_name = self._get_storage_name(names)<EOL><DEDENT>if os.path.exists(file_name) and force is False:<EOL><INDENT>bot.error('<STR_LIT>')<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>digest = names['<STR_LIT:version>'] or names['<STR_LIT>']<EOL>sandbox = get_tmpdir(prefix=\"<STR_LIT>\")<EOL>layers = self._download_layers(names['<STR_LIT:url>'], digest)<EOL>url = self._get_manifest_selfLink(names['<STR_LIT:url>'], digest)<EOL>envtar = self._get_environment_tar()<EOL>layers = [envtar] + layers<EOL>for layer in layers:<EOL><INDENT>bot.info('<STR_LIT>' %layer)<EOL>result = extract_tar(layer, sandbox, handle_whiteout=True)<EOL>if result['<STR_LIT>'] != <NUM_LIT:0>:<EOL><INDENT>bot.error(result['<STR_LIT:message>'])<EOL>sys.exit(<NUM_LIT:1>)        <EOL><DEDENT><DEDENT>sudo = kwargs.get('<STR_LIT>', False)<EOL>image_file = Singularity.build(image=file_name,<EOL>recipe=sandbox,<EOL>sudo=sudo)<EOL>if image_file is None:<EOL><INDENT>bot.info('<STR_LIT>')<EOL>image = image.replace('<STR_LIT>', uri)<EOL>image_file = Singularity.pull(image, pull_folder=sandbox)<EOL><DEDENT>if save is True:<EOL><INDENT>manifests = {}<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>manifests = self.manifests<EOL><DEDENT>container = self.add(image_path = image_file,<EOL>image_uri = names['<STR_LIT>'],<EOL>metadata = manifests,<EOL>url = url)<EOL>image_file = container.image<EOL><DEDENT>if os.path.exists(image_file):<EOL><INDENT>bot.debug('<STR_LIT>' %image_file)<EOL>bot.custom(prefix=\"<STR_LIT>\", message=image_file)<EOL><DEDENT>shutil.rmtree(sandbox)<EOL>return image_file<EOL>", "docstring": "pull an image from a docker hub. This is a (less than ideal) workaround\n       that actually does the following:\n\n       - creates a sandbox folder\n       - adds docker layers, metadata folder, and custom metadata to it\n       - converts to a squashfs image with build\n\n    the docker manifests are stored with registry metadata.\n\n    Parameters\n    ==========\n    images: refers to the uri given by the user to pull in the format\n    <collection>/<namespace>. You should have an API that is able to \n    retrieve a container based on parsing this uri.\n    file_name: the user's requested name for the file. It can \n               optionally be None if the user wants a default.\n    save: if True, you should save the container to the database\n          using self.add()\n\n    Returns\n    =======\n    finished: a single container path, or list of paths", "id": "f9925:m1"}
{"signature": "def pull(self, images, <EOL>file_name=None, <EOL>save=True, <EOL>force=False, <EOL>base=None, <EOL>**kwargs):", "body": "if not isinstance(images,list):<EOL><INDENT>images = [images]<EOL><DEDENT>bot.debug('<STR_LIT>' %len(images))<EOL>finished = []<EOL>for image in images:<EOL><INDENT>base = self._update_base(image)<EOL>q = parse_image_name(remove_uri(image), base=base)<EOL>image_file = self._pull(file_name=file_name, <EOL>save=save, <EOL>force=force, <EOL>names=q,<EOL>kwargs=kwargs)<EOL>finished.append(image_file)<EOL><DEDENT>if len(finished) == <NUM_LIT:1>:<EOL><INDENT>finished = finished[<NUM_LIT:0>]<EOL><DEDENT>return finished<EOL>", "docstring": "pull an image from a docker hub. This is a (less than ideal) workaround\n       that actually does the following:\n\n       - creates a sandbox folder\n       - adds docker layers, metadata folder, and custom metadata to it\n       - converts to a squashfs image with build\n\n    the docker manifests are stored with registry metadata.\n\n    Parameters\n    ==========\n    images: refers to the uri given by the user to pull in the format\n    <collection>/<namespace>. You should have an API that is able to \n    retrieve a container based on parsing this uri.\n    file_name: the user's requested name for the file. It can \n               optionally be None if the user wants a default.\n    save: if True, you should save the container to the database\n          using self.add()\n    base: the registry base, in case the client doesn't want to set in env.\n\n    Returns\n    =======\n    finished: a single container path, or list of paths", "id": "f9925:m0"}
{"signature": "def _set_base(self, default_base=None):", "body": "base = self._get_setting('<STR_LIT>')<EOL>version = self._get_setting('<STR_LIT>')<EOL>if base is None:<EOL><INDENT>if default_base is None:<EOL><INDENT>base = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>base = default_base<EOL><DEDENT><DEDENT>if version is None:<EOL><INDENT>version = \"<STR_LIT>\"<EOL><DEDENT>nohttps = self._get_setting('<STR_LIT>')<EOL>if nohttps is None:<EOL><INDENT>nohttps = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>nohttps = \"<STR_LIT>\"<EOL><DEDENT>self._base = \"<STR_LIT>\" %(nohttps, base)<EOL>self._version = version<EOL>self.base = \"<STR_LIT>\" %(nohttps, base.strip('<STR_LIT:/>'), version)<EOL>", "docstring": "set the API base or default to use Docker Hub. The user is able\n           to set the base, api version, and protocol via a settings file\n           of environment variables:\n\n           SREGISTRY_DOCKERHUB_BASE: defaults to index.docker.io\n           SREGISTRY_DOCKERHUB_VERSION: defaults to v1\n           SREGISTRY_DOCKERHUB_NO_HTTPS: defaults to not set (so https)", "id": "f9926:c0:m4"}
{"signature": "def _speak(self):", "body": "pass<EOL>", "docstring": "if you want to add an extra print (of a parameter, for example)\n           for the user when the client initalizes, write it here, eg:\n           bot.info('[setting] value')", "id": "f9926:c0:m1"}
{"signature": "def get_size(self, add_padding=True, round_up=True, return_mb=True):", "body": "if not hasattr(self,'<STR_LIT>'):<EOL><INDENT>bot.error('<STR_LIT>')<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>size = <NUM_LIT>  <EOL>for schemaVersion, manifest in self.manifests.items():<EOL><INDENT>if \"<STR_LIT>\" in manifest:<EOL><INDENT>size = <NUM_LIT:0><EOL>for layer in manifest[\"<STR_LIT>\"]:<EOL><INDENT>if \"<STR_LIT:size>\" in layer:<EOL><INDENT>size += layer['<STR_LIT:size>']<EOL><DEDENT><DEDENT>if add_padding is True:<EOL><INDENT>size = size * <NUM_LIT:5><EOL><DEDENT>if return_mb is True:<EOL><INDENT>size = size / (<NUM_LIT> * <NUM_LIT>)  <EOL><DEDENT>if round_up is True:<EOL><INDENT>size = math.ceil(size)<EOL><DEDENT>size = int(size)<EOL><DEDENT>return size<EOL><DEDENT>", "docstring": "get_size will return the image size (must use v.2.0 manifest)\n\n       Parameters\n       ==========\n       add_padding: if true, return reported size * 5\n       round_up: if true, round up to nearest integer\n       return_mb: if true, defaults bytes are converted to MB", "id": "f9927:m9"}
{"signature": "def get_manifests(self, repo_name, digest=None):", "body": "if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>self.manifests = {}<EOL><DEDENT>schemaVersions = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>for schemaVersion in schemaVersions:<EOL><INDENT>manifest = self._get_manifest(repo_name, digest, schemaVersion)<EOL>if manifest is not None:<EOL><INDENT>if schemaVersion == \"<STR_LIT>\" and \"<STR_LIT>\" in manifest:<EOL><INDENT>bot.debug('<STR_LIT>')<EOL>url = self._get_layerLink(repo_name, manifest['<STR_LIT>']['<STR_LIT>'])        <EOL>headers = {'<STR_LIT>': manifest['<STR_LIT>']['<STR_LIT>']}<EOL>self.manifests['<STR_LIT>'] = self._get(url, headers=headers)<EOL><DEDENT>self.manifests[schemaVersion] = manifest<EOL><DEDENT><DEDENT>return self.manifests<EOL>", "docstring": "get_manifests calls get_manifest for each of the schema versions,\n       including v2 and v1. Version 1 includes image layers and metadata,\n       and version 2 must be parsed for a specific manifest, and the 2nd\n       call includes the layers. If a digest is not provided\n       latest is used.\n\n       Parameters\n       ==========\n       repo_name: reference to the <username>/<repository>:<tag> to obtain\n       digest: a tag or shasum version", "id": "f9927:m1"}
{"signature": "def get_manifest_selfLink(self, repo_name, digest=None):", "body": "url = \"<STR_LIT>\" % (self.base, repo_name)<EOL>if digest is None:<EOL><INDENT>digest = '<STR_LIT>'<EOL><DEDENT>return \"<STR_LIT>\" % (url, digest)<EOL>", "docstring": "get a selfLink for the manifest, for use by the client get_manifest\n        function, along with the parents pull\n\n       Parameters\n       ==========\n       repo_name: reference to the <username>/<repository>:<tag> to obtain\n       digest: a tag or shasum version", "id": "f9927:m2"}
{"signature": "def get_download_cache(self, destination, subfolder='<STR_LIT>'):", "body": "<EOL>if destination is None:<EOL><INDENT>destination = self._get_setting('<STR_LIT>', <EOL>SINGULARITY_CACHE)<EOL>destination = get_tmpdir(destination)<EOL><DEDENT>if not destination.endswith(subfolder):<EOL><INDENT>destination = \"<STR_LIT>\" %(destination, subfolder)<EOL><DEDENT>mkdir_p(destination)<EOL>return destination<EOL>", "docstring": "determine the user preference for atomic download of layers. If\n       the user has set a singularity cache directory, honor it. Otherwise,\n       use the Singularity default.", "id": "f9927:m5"}
{"signature": "def create_metadata_tar(self, destination=None, metadata_folder=\"<STR_LIT>\"):", "body": "tar_file = None<EOL>files = []<EOL>environ = self._extract_env()<EOL>if environ not in [None, \"<STR_LIT>\"]:<EOL><INDENT>bot.verbose3('<STR_LIT>')<EOL>template = get_template('<STR_LIT>')<EOL>template['<STR_LIT:name>'] = '<STR_LIT>' % (metadata_folder)<EOL>template['<STR_LIT:content>'] = environ<EOL>files.append(template)<EOL><DEDENT>labels = self._extract_labels()<EOL>if labels is not None:<EOL><INDENT>labels = print_json(labels)<EOL>bot.verbose3('<STR_LIT>')<EOL>template = get_template('<STR_LIT>')<EOL>template['<STR_LIT:name>'] = \"<STR_LIT>\" % metadata_folder<EOL>template['<STR_LIT:content>'] = labels<EOL>files.append(template)<EOL><DEDENT>runscript = self._extract_runscript()<EOL>if runscript is not None:<EOL><INDENT>bot.verbose3('<STR_LIT>')<EOL>template = get_template('<STR_LIT>')<EOL>template['<STR_LIT:name>'] = \"<STR_LIT>\" % metadata_folder<EOL>template['<STR_LIT:content>'] = runscript<EOL>files.append(template)<EOL><DEDENT>if len(files) > <NUM_LIT:0>:<EOL><INDENT>dest = self._get_download_cache(destination, subfolder='<STR_LIT>')<EOL>tar_file = create_tar(files, dest)<EOL><DEDENT>else:<EOL><INDENT>bot.warning(\"<STR_LIT>\")<EOL><DEDENT>return tar_file<EOL>", "docstring": "create a metadata tar (runscript and environment) to add to the\n       downloaded image. This function uses all functions in this section\n       to obtain key--> values from the manifest config, and write\n       to a .tar.gz\n\n       Parameters\n       ==========\n       metadata_folder: the metadata folder in the singularity image.\n                        default is .singularity.d", "id": "f9927:m12"}
{"signature": "def search(self, query=None, args=None):", "body": "if query is None:<EOL><INDENT>bot.exit('<STR_LIT>')<EOL><DEDENT>return self._search_all(query)<EOL>", "docstring": "query a GitLab artifacts folder for a list of images. \n     If query is None, collections are listed.", "id": "f9929:m0"}
{"signature": "def _parse_image_name(self, image, retry=True):", "body": "try:<EOL><INDENT>job_id, collection, job_name = image.split('<STR_LIT:U+002C>')<EOL><DEDENT>except:<EOL><INDENT>if retry:<EOL><INDENT>return self._parse_image_name(\"<STR_LIT>\" %(image, self.job),<EOL>retry=False)<EOL><DEDENT>bot.exit('''<STR_LIT>''')<EOL><DEDENT>return job_id, collection, job_name<EOL>", "docstring": "starting with an image string in either of the following formats:\n           job_id|collection\n           job_id|collection|job_name\n\n           Parse the job_name, job_id, and collection uri from it. If the user\n           provides the first option, we use the job_name set by the client\n           (default is build).\n\n           Parameters\n           ==========\n           image: the string to parse, with values separated by |\n           retry: the client can call itself recursively once, providing the\n                  default job_name if the user doesn't.", "id": "f9930:c0:m6"}
{"signature": "def pull(self, images, file_name=None, save=True, **kwargs):", "body": "force = False<EOL>if \"<STR_LIT>\" in kwargs:<EOL><INDENT>force = kwargs['<STR_LIT>']<EOL><DEDENT>if not isinstance(images, list):<EOL><INDENT>images = [images]<EOL><DEDENT>bot.debug('<STR_LIT>' %len(images))<EOL>finished = []<EOL>for image in images:<EOL><INDENT>names = parse_image_name(remove_uri(image))<EOL>dropbox_path = '<STR_LIT>' % names['<STR_LIT>']<EOL>if file_name is None:<EOL><INDENT>file_name = self._get_storage_name(names)<EOL><DEDENT>if os.path.exists(file_name) and force is False:<EOL><INDENT>bot.error('<STR_LIT>')<EOL>sys.exit(<NUM_LIT:1>) <EOL><DEDENT>if self.exists(dropbox_path) is True:<EOL><INDENT>metadata, response = self.dbx.files_download(dropbox_path)<EOL>image_file = self._stream(response, stream_to=file_name)<EOL>metadata = self._get_metadata(image_file, metadata)<EOL>if save is True:<EOL><INDENT>container = self.add(image_path = image_file,<EOL>image_uri = dropbox_path.strip('<STR_LIT:/>'),<EOL>metadata = metadata,<EOL>url = response.url)<EOL>image_file = container.image<EOL><DEDENT>if os.path.exists(image_file):<EOL><INDENT>bot.debug('<STR_LIT>' %image_file)<EOL>bot.custom(prefix=\"<STR_LIT>\", message=image_file)<EOL>finished.append(image_file)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>bot.error('<STR_LIT>' %path)<EOL><DEDENT><DEDENT>if len(finished) == <NUM_LIT:1>:<EOL><INDENT>finished = finished[<NUM_LIT:0>]<EOL><DEDENT>return finished<EOL>", "docstring": "pull an image from a dropbox. The image is found based on the storage \n       uri\n\n       Parameters\n       ==========\n       images: refers to the uri given by the user to pull in the format\n       <collection>/<namespace>. You should have an API that is able to \n       retrieve a container based on parsing this uri.\n       file_name: the user's requested name for the file. It can \n                  optionally be None if the user wants a default.\n       save: if True, you should save the container to the database\n             using self.add()\n\n       Returns\n       =======\n       finished: a single container path, or list of paths", "id": "f9932:m0"}
{"signature": "def search_all(self):", "body": "results = []<EOL>for entry in self.dbx.files_list_folder('<STR_LIT>').entries:<EOL><INDENT>for item in self.dbx.files_list_folder(entry.path_lower).entries:<EOL><INDENT>name = item.name.replace('<STR_LIT>','<STR_LIT>')<EOL>results.append([ \"<STR_LIT>\" % (entry.name, name) ])<EOL><DEDENT><DEDENT>if len(results) == <NUM_LIT:0>:<EOL><INDENT>bot.info(\"<STR_LIT>\")<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>bot.info(\"<STR_LIT>\")<EOL>bot.table(results)<EOL>return results<EOL>", "docstring": "a \"show all\" search that doesn't require a query", "id": "f9933:m1"}
{"signature": "def search(self, query=None, args=None):", "body": "if query is not None:<EOL><INDENT>return self._container_query(query)<EOL><DEDENT>return self._search_all()<EOL>", "docstring": "query a Singularity registry for a list of images. \n     If query is None, collections are listed.", "id": "f9933:m0"}
{"signature": "def search(self, query=None, args=None):", "body": "if query is not None:<EOL><INDENT>if query.endswith('<STR_LIT:/>'):  <EOL><INDENT>return self._collection_search(query)<EOL><DEDENT>elif query.startswith('<STR_LIT:/>'):  <EOL><INDENT>return self._container_search(query, across_collections=True)<EOL><DEDENT>elif \"<STR_LIT:/>\" in query or \"<STR_LIT::>\" in query:<EOL><INDENT>return self._container_search(query)<EOL><DEDENT>return self._collection_search(query=query)<EOL><DEDENT>return self._search_all()<EOL>", "docstring": "query a Singularity registry for a list of images. \n     If query is None, collections are listed. \n\n    EXAMPLE QUERIES:\n\n    [empty]             list all collections in registry\n    vsoch               do a general search for the expression \"vsoch\"\n    vsoch/              list all containers in collection vsoch\n    /dinosaur           list containers across collections called \"dinosaur\"\n    vsoch/dinosaur      list details of container vsoch/dinosaur\n                          tag \"latest\" is used by default, and then the most recent\n    vsoch/dinosaur:tag  list details for specific container", "id": "f9939:m0"}
{"signature": "def container_search(self, query, across_collections=False):", "body": "query = query.lower().strip('<STR_LIT:/>')<EOL>q = parse_image_name(remove_uri(query), defaults=False)<EOL>if q['<STR_LIT>'] is not None:<EOL><INDENT>if across_collections is True:<EOL><INDENT>url = '<STR_LIT>' % (self.base, q['<STR_LIT:image>'], q['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>url = '<STR_LIT>' % (self.base, q['<STR_LIT>'], q['<STR_LIT:image>'], q['<STR_LIT>'])<EOL><DEDENT><DEDENT>elif q['<STR_LIT>'] is None: <EOL><INDENT>if across_collections is True:<EOL><INDENT>url = '<STR_LIT>' % (self.base, q['<STR_LIT:image>'])<EOL><DEDENT>else:<EOL><INDENT>url = '<STR_LIT>' % (self.base, q['<STR_LIT>'], q['<STR_LIT:image>'])<EOL><DEDENT><DEDENT>result = self._get(url)<EOL>if \"<STR_LIT>\" in result:<EOL><INDENT>result = result['<STR_LIT>']<EOL><DEDENT>if len(result) == <NUM_LIT:0>:<EOL><INDENT>bot.info(\"<STR_LIT>\")<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>bot.info(\"<STR_LIT>\" %query)<EOL>rows = []<EOL>for c in result:        <EOL><INDENT>rows.append([ '<STR_LIT>' %(c['<STR_LIT>'], c['<STR_LIT:name>']),<EOL>c['<STR_LIT>'] ])<EOL><DEDENT>bot.table(rows)<EOL>return rows<EOL>", "docstring": "search for a specific container. If across collections is False,\n    the query is parsed as a full container name and a specific container\n    is returned. If across_collections is True, the container is searched\n    for across collections. If across collections is True, details are\n    not shown", "id": "f9939:m4"}
{"signature": "def label_search(self, key=None, value=None):", "body": "if key is not None:<EOL><INDENT>key = key.lower()<EOL><DEDENT>if value is not None:<EOL><INDENT>value = value.lower()<EOL><DEDENT>show_details = True<EOL>if key is None and value is None:<EOL><INDENT>url = '<STR_LIT>' % (self.base)<EOL>show_details = False<EOL><DEDENT>elif key is not None and value is not None:<EOL><INDENT>url = '<STR_LIT>' % (self.base, key, value)<EOL><DEDENT>elif key is None:<EOL><INDENT>url = '<STR_LIT>' % (self.base, value)<EOL><DEDENT>else:<EOL><INDENT>url = '<STR_LIT>' % (self.base, key)<EOL><DEDENT>result = self._get(url)<EOL>if len(result) == <NUM_LIT:0>:<EOL><INDENT>bot.info(\"<STR_LIT>\")<EOL>sys.exit(<NUM_LIT:0>)<EOL><DEDENT>bot.info(\"<STR_LIT>\")<EOL>rows = []<EOL>for l in result:        <EOL><INDENT>if show_details is True:<EOL><INDENT>entry = [\"<STR_LIT>\" %(l['<STR_LIT:key>'],l['<STR_LIT:value>']),<EOL>\"<STR_LIT>\" %\"<STR_LIT:\\n>\".join(l['<STR_LIT>'])]<EOL><DEDENT>else:<EOL><INDENT>entry = [\"<STR_LIT>\" %len(l['<STR_LIT>']),<EOL>\"<STR_LIT>\" %(l['<STR_LIT:key>'],l['<STR_LIT:value>']) ]<EOL><DEDENT>rows.append(entry)<EOL><DEDENT>bot.table(rows)<EOL>return rows<EOL>", "docstring": "search across labels", "id": "f9939:m3"}
{"signature": "def _add_https(self, q):", "body": "<EOL>if not q['<STR_LIT>'].startswith('<STR_LIT:http>'):<EOL><INDENT>if q['<STR_LIT>'].startswith('<STR_LIT>'):<EOL><INDENT>q['<STR_LIT>'] = '<STR_LIT>' % q['<STR_LIT>']<EOL><DEDENT>elif q['<STR_LIT>'].startswith('<STR_LIT>'):<EOL><INDENT>q['<STR_LIT>'] = '<STR_LIT>' % q['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>prefix = '<STR_LIT>'<EOL>nohttps = os.environ.get('<STR_LIT>')<EOL>if nohttps != None:<EOL><INDENT>prefix = '<STR_LIT>'<EOL><DEDENT>q['<STR_LIT>'] = '<STR_LIT>' %(prefix, q['<STR_LIT>'])<EOL><DEDENT><DEDENT>return q<EOL>", "docstring": "for push, pull, and other api interactions, the user can optionally\n           define a custom registry. If the registry name doesn't include http\n           or https, add it.\n\n           Parameters\n           ==========\n           q: the parsed image query (names), including the original", "id": "f9940:c0:m3"}
{"signature": "def update_headers(self,fields=None):", "body": "do_reset = True<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>if self.headers is not None:<EOL><INDENT>do_reset = False<EOL><DEDENT><DEDENT>if do_reset is True:<EOL><INDENT>self._reset_headers()<EOL><DEDENT>if fields is not None:<EOL><INDENT>for key,value in fields.items():<EOL><INDENT>self.headers[key] = value<EOL><DEDENT><DEDENT>header_names = \"<STR_LIT:U+002C>\".join(list(self.headers.keys()))<EOL>bot.debug(\"<STR_LIT>\" %header_names)<EOL>", "docstring": "update headers with a token & other fields", "id": "f9943:m2"}
{"signature": "def get_headers(self):", "body": "return self.headers<EOL>", "docstring": "simply return the headers", "id": "f9943:m0"}
{"signature": "def reset_headers(self):", "body": "self.headers = {'<STR_LIT:Content-Type>':\"<STR_LIT:application/json>\"}<EOL>", "docstring": "reset headers to a reasonable default to specify content type of json", "id": "f9943:m1"}
{"signature": "def get_metadata(self, image_file, names={}):", "body": "metadata = dict()<EOL>if image_file is not None:<EOL><INDENT>if not os.path.exists(image_file):<EOL><INDENT>bot.error('<STR_LIT>' %image_file)<EOL>return names or metadata<EOL><DEDENT><DEDENT>if not names:<EOL><INDENT>names = parse_image_name(remove_uri(image_file))<EOL><DEDENT>singularity = which('<STR_LIT>')['<STR_LIT:message>']<EOL>if os.path.exists(singularity) and image_file is not None:<EOL><INDENT>from spython.main import Client as Singularity<EOL>try:<EOL><INDENT>Singularity.quiet = True<EOL>updates = Singularity.inspect(image=image_file)<EOL><DEDENT>except:<EOL><INDENT>bot.warning('<STR_LIT>')<EOL>updates = None<EOL><DEDENT>if updates is not None:<EOL><INDENT>try:<EOL><INDENT>updates = json.loads(updates)<EOL>metadata.update(updates)<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>metadata.update(names)<EOL>return metadata<EOL>", "docstring": "extract metadata using Singularity inspect, if the executable is found.\n       If not, return a reasonable default (the parsed image name)\n\n       Parameters\n       ==========\n       image_file: the full path to a Singularity image\n       names: optional, an extracted or otherwise created dictionary of\n              variables for the image, likely from utils.parse_image_name", "id": "f9944:m0"}
{"signature": "def delete(self, url,<EOL>headers=None,<EOL>return_json=True,<EOL>default_headers=True):", "body": "bot.debug('<STR_LIT>' %url)<EOL>return self._call(url,<EOL>headers=headers,<EOL>func=requests.delete,<EOL>return_json=return_json,<EOL>default_headers=default_headers)<EOL>", "docstring": "delete request, use with caution", "id": "f9947:m0"}
{"signature": "def download(self, url,<EOL>file_name,<EOL>headers=None,<EOL>show_progress=True):", "body": "tmp_file = get_tmpfile(prefix=\"<STR_LIT>\" % file_name)<EOL>verify = self._verify()<EOL>if requests.head(url, verify=verify).status_code in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>response = self.stream(url,<EOL>headers=headers,<EOL>stream_to=tmp_file,<EOL>show_progress=show_progress)<EOL>if isinstance(response, HTTPError):<EOL><INDENT>bot.error(\"<STR_LIT>\" %url)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>shutil.move(tmp_file, file_name)<EOL><DEDENT>else:<EOL><INDENT>bot.error(\"<STR_LIT>\" %url)<EOL><DEDENT>return file_name<EOL>", "docstring": "stream to a temporary file, rename on successful completion\n\n        Parameters\n        ==========\n        file_name: the file name to stream to\n        url: the url to stream from\n        headers: additional headers to add\n        force: If the final image exists, don't overwrite\n        show_progress: boolean to show progress bar", "id": "f9947:m8"}
{"signature": "def stream(self, url, <EOL>headers=None, <EOL>stream_to=None,<EOL>retry=True, <EOL>default_headers=True,<EOL>show_progress=True):", "body": "bot.debug(\"<STR_LIT>\" %url)<EOL>if headers == None:<EOL><INDENT>if self.headers is None:<EOL><INDENT>self._reset_headers()<EOL><DEDENT>headers = self.headers.copy()<EOL><DEDENT>response = requests.get(url,         <EOL>headers=headers,<EOL>verify=self._verify(),<EOL>stream=True)<EOL>if response.status_code == <NUM_LIT> and retry is True:<EOL><INDENT>if hasattr(self,'<STR_LIT>'):<EOL><INDENT>self._update_token(response)<EOL>return self.stream(url,<EOL>headers, <EOL>stream_to, <EOL>retry=False,<EOL>show_progress=show_progress)<EOL><DEDENT><DEDENT>if response.status_code == <NUM_LIT:200>: <EOL><INDENT>return self._stream(response,<EOL>stream_to=stream_to,<EOL>show_progress=show_progress)<EOL><DEDENT>bot.error(\"<STR_LIT>\" %(response.status_code))<EOL>sys.exit(<NUM_LIT:1>)<EOL>", "docstring": "stream is a get that will stream to file_name. This stream is intended\nto take a url and (optionally) a set of headers and file to stream to,\nand will generate a response with requests.get.\n\nParameters\n==========\nurl: the url to do a requests.get to\nheaders: any updated headers to use for the requets\nstream_to: the file to stream to\nshow_progress: boolean to show progress bar\nretry: should the client retry? (intended for use after token refresh)\n       by default we retry once after token refresh, then fail.", "id": "f9947:m9"}
{"signature": "def post(self,url,<EOL>headers=None,<EOL>data=None,<EOL>return_json=True,<EOL>default_headers=True):", "body": "bot.debug(\"<STR_LIT>\" %url)<EOL>return self._call(url,<EOL>headers=headers,<EOL>func=requests.post,<EOL>data=data,<EOL>return_json=return_json,<EOL>default_headers=default_headers)<EOL>", "docstring": "post will use requests to get a particular url", "id": "f9947:m4"}
{"signature": "def stream_response(self, response, stream_to=None, show_progress=True):", "body": "if response.status_code == <NUM_LIT:200>:<EOL><INDENT>if show_progress is False:<EOL><INDENT>bot.quiet = True<EOL><DEDENT>content_size = None<EOL>if '<STR_LIT>' in response.headers:<EOL><INDENT>progress = <NUM_LIT:0><EOL>content_size = int(response.headers['<STR_LIT>'])<EOL>bot.show_progress(progress, content_size, length=<NUM_LIT>)<EOL><DEDENT>chunk_size = <NUM_LIT:1> << <NUM_LIT:20><EOL>with open(stream_to, '<STR_LIT:wb>') as filey:<EOL><INDENT>for chunk in response.iter_content(chunk_size=chunk_size):<EOL><INDENT>filey.write(chunk)<EOL>if content_size is not None:<EOL><INDENT>progress+=chunk_size<EOL>bot.show_progress(iteration=progress,<EOL>total=content_size,<EOL>length=<NUM_LIT>,<EOL>carriage_return=False)<EOL><DEDENT><DEDENT><DEDENT>sys.stdout.write('<STR_LIT:\\n>')<EOL>return stream_to <EOL><DEDENT>bot.error(\"<STR_LIT>\" %(response.status_code))<EOL>sys.exit(<NUM_LIT:1>)<EOL>", "docstring": "stream response is one level higher up than stream, starting with a \nresponse object and then performing the stream without making the\nrequests.get. The expectation is that the request was successful \n(status code 20*).\nshow_progress: boolean to show progress bar\n\nParameters\n==========\nresponse: a response that is ready to be iterated over to download in\n          streamed chunks\nstream_to: the file to stream to", "id": "f9947:m10"}
{"signature": "def get_settings(self, client_name=None):", "body": "settings = read_client_secrets()<EOL>if client_name is not None and client_name in settings:<EOL><INDENT>return settings[client_name]           <EOL><DEDENT>return settings<EOL>", "docstring": "get all settings, either for a particular client if a name is provided,\n       or across clients.\n\n       Parameters\n       ==========\n       client_name: the client name to return settings for (optional)", "id": "f9948:m0"}
{"signature": "def update_setting(self, name, value):", "body": "if value is not None:<EOL><INDENT>updates = {name : value}<EOL>update_client_secrets(backend=self.client_name, <EOL>updates=updates)<EOL><DEDENT>", "docstring": "Just update a setting, doesn't need to be returned.", "id": "f9948:m4"}
{"signature": "def get_client(image=None, quiet=False, **kwargs):", "body": "from sregistry.defaults import SREGISTRY_CLIENT<EOL>if not check_install():<EOL><INDENT>bot.warning('<STR_LIT>')<EOL><DEDENT>client_name = get_uri(image)<EOL>if client_name is not None:<EOL><INDENT>SREGISTRY_CLIENT = client_name<EOL><DEDENT>if   SREGISTRY_CLIENT == '<STR_LIT>': from .aws import Client<EOL>elif SREGISTRY_CLIENT == '<STR_LIT>': from .docker import Client<EOL>elif SREGISTRY_CLIENT == '<STR_LIT>': from .dropbox import Client<EOL>elif SREGISTRY_CLIENT == '<STR_LIT>': from .gitlab import Client<EOL>elif SREGISTRY_CLIENT == '<STR_LIT>': from .globus import Client<EOL>elif SREGISTRY_CLIENT == '<STR_LIT>': from .nvidia import Client<EOL>elif SREGISTRY_CLIENT == '<STR_LIT>': from .hub import Client<EOL>elif SREGISTRY_CLIENT == '<STR_LIT>': from .google_drive import Client<EOL>elif SREGISTRY_CLIENT == '<STR_LIT>': from .google_storage import Client<EOL>elif SREGISTRY_CLIENT == '<STR_LIT>': from .google_storage import Client<EOL>elif SREGISTRY_CLIENT == '<STR_LIT>': from .google_build import Client<EOL>elif SREGISTRY_CLIENT == '<STR_LIT>': from .registry import Client<EOL>elif SREGISTRY_CLIENT == '<STR_LIT>': from .s3 import Client<EOL>elif SREGISTRY_CLIENT == '<STR_LIT>': from .swift import Client<EOL>else: from .hub import Client<EOL>Client.client_name = SREGISTRY_CLIENT<EOL>Client.quiet = quiet<EOL>Client._credential_cache = get_credential_cache()<EOL>if SREGISTRY_DATABASE is not None:<EOL><INDENT>from sregistry.database import (<EOL>init_db, add, cp, get, mv, rm, rmi, <EOL>images, inspect,<EOL>rename,<EOL>get_container,<EOL>get_collection, <EOL>get_or_create_collection <EOL>)<EOL>Client._init_db = init_db<EOL>Client.add = add<EOL>Client.cp = cp<EOL>Client.get = get<EOL>Client.inspect = inspect<EOL>Client.mv = mv<EOL>Client.rename = rename<EOL>Client.rm = rm<EOL>Client.rmi = rmi<EOL>Client.images = images<EOL>Client.get_or_create_collection = get_or_create_collection<EOL>Client.get_container = get_container<EOL>Client.get_collection = get_collection<EOL><DEDENT>else:<EOL><INDENT>from sregistry.database import ( add, init_db )<EOL>Client.add = add<EOL>Client._init_db = init_db        <EOL><DEDENT>cli = Client()<EOL>if hasattr(Client, '<STR_LIT>'):<EOL><INDENT>cli._init_db(SREGISTRY_DATABASE)<EOL><DEDENT>return cli<EOL>", "docstring": "get the correct client depending on the driver of interest. The\nselected client can be chosen based on the environment variable\nSREGISTRY_CLIENT, and later changed based on the image uri parsed\nIf there is no preference, the default is to load the singularity \nhub client.\n\nParameters\n==========\nimage: if provided, we derive the correct client based on the uri\nof an image. If not provided, we default to environment, then hub.\nquiet: if True, suppress most output about the client (e.g. speak)", "id": "f9949:m0"}
{"signature": "def search(self, query=None, **kwargs):", "body": "if query is not None:<EOL><INDENT>return self._search_collection(query)<EOL><DEDENT>return self.list()<EOL>", "docstring": "query a Singularity registry for a list of images. \n     If query is None, collections are listed. \n\n    EXAMPLE QUERIES:\n\n    [empty]             list all collections in singularity hub\n    vsoch               do a general search for collection \"vsoch\"\n    vsoch/dinosaur      list details of container vsoch/dinosaur\n                          tag \"latest\" is used by default, and then the most recent\n    vsoch/dinosaur:tag  list details for specific container", "id": "f9951:m0"}
{"signature": "def __init__(self, secrets=None, **kwargs):", "body": "self._set_base()<EOL>self.reverseLayers = False<EOL>self._reset_headers()<EOL>self._update_secrets()<EOL>self._update_headers()<EOL>super(ApiConnection, self).__init__(**kwargs)<EOL>", "docstring": "to work with nvidia container registry, we do the following:\n\n        1. set the base to index.docker.io, or defined in environment \n        2. assume starting with v2 schema, we won't reverse layers \n        3. set headers to ask for version 2 schema first\n        4. update secrets, 1st priority environment, then .docker/config.json \n        5. update headers based on secrets", "id": "f9954:c0:m0"}
{"signature": "def search(self, query=None, args=None):", "body": "<EOL>if query is not None:<EOL><INDENT>return self._container_query(query)<EOL><DEDENT>return self._search_all()<EOL>", "docstring": "query a Singularity registry for a list of images. \n     If query is None, collections are listed. \n\n    EXAMPLE QUERIES:", "id": "f9957:m0"}
{"signature": "def _update_secrets(self):", "body": "<EOL>setting = self._get_setting('<STR_LIT>')<EOL>setting = self._get_and_update_setting('<STR_LIT>')<EOL>self.secrets = read_client_secrets()<EOL>if self._credential_cache is not None:<EOL><INDENT>bot.info(\"<STR_LIT>\" %self._credential_cache)<EOL><DEDENT>", "docstring": "update secrets will take a secrets credential file\n           either located at .sregistry or the environment variable\n           SREGISTRY_CLIENT_SECRETS and update the current client \n           secrets as well as the associated API base. This is where you\n           should do any customization of the secrets flie, or using\n           it to update your client, if needed.", "id": "f9958:c0:m2"}
{"signature": "def push(self, path, name, tag=None):", "body": "<EOL>parent = self._get_or_create_folder(self._base)<EOL>image = None<EOL>path = os.path.abspath(path)<EOL>bot.debug(\"<STR_LIT>\" % path)<EOL>if not os.path.exists(path):<EOL><INDENT>bot.error('<STR_LIT>' %path)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>names = parse_image_name(remove_uri(name),tag=tag)<EOL>if names['<STR_LIT:version>'] is None:<EOL><INDENT>version = get_image_hash(path)<EOL>names = parse_image_name(remove_uri(name), tag=tag, version=version)<EOL><DEDENT>metadata = self.get_metadata(path, names=names)<EOL>metadata = metadata['<STR_LIT:data>']<EOL>metadata.update(names)<EOL>metadata.update(metadata['<STR_LIT>']['<STR_LIT>'])<EOL>del metadata['<STR_LIT>']<EOL>file_metadata = {<EOL>'<STR_LIT:name>': names['<STR_LIT>'],<EOL>'<STR_LIT>' : '<STR_LIT>',<EOL>'<STR_LIT>': [parent['<STR_LIT:id>']],<EOL>'<STR_LIT>': metadata<EOL>}<EOL>media = MediaFileUpload(path,resumable=True)<EOL>try:<EOL><INDENT>bot.spinner.start()<EOL>image = self._service.files().create(body=file_metadata,<EOL>media_body=media,<EOL>fields='<STR_LIT:id>').execute()<EOL>thumbnail = get_thumbnail()<EOL>with open(thumbnail, \"<STR_LIT:rb>\") as f:<EOL><INDENT>body = { \"<STR_LIT>\": { <EOL>\"<STR_LIT>\": { \"<STR_LIT:image>\": base64.urlsafe_b64encode(f.read()).decode('<STR_LIT:utf8>'),<EOL>\"<STR_LIT>\": \"<STR_LIT>\" }<EOL>}}<EOL>image = self._service.files().update(fileId=image['<STR_LIT:id>'],<EOL>body = body).execute()<EOL><DEDENT>bot.spinner.stop()<EOL>print(image['<STR_LIT:name>'])<EOL><DEDENT>except HttpError:<EOL><INDENT>bot.error('<STR_LIT>' %path)<EOL>pass<EOL><DEDENT>return image<EOL>", "docstring": "push an image to Google Cloud Drive, meaning uploading it\n\n    path: should correspond to an absolte image path (or derive it)\n    name: should be the complete uri that the user has requested to push.\n    tag: should correspond with an image tag. This is provided to mirror Docker", "id": "f9959:m0"}
{"signature": "def container_query(self, query, quiet=False):", "body": "results = self._list_containers()<EOL>matches = []<EOL>for result in results:<EOL><INDENT>is_match = False<EOL>if query in result['<STR_LIT:id>']:<EOL><INDENT>is_match = True<EOL><DEDENT>elif query in result['<STR_LIT:name>']:<EOL><INDENT>is_match = True<EOL><DEDENT>else:<EOL><INDENT>for key,val in result['<STR_LIT>'].items():<EOL><INDENT>if query in val and is_match is False:<EOL><INDENT>is_match = True<EOL>break<EOL><DEDENT><DEDENT><DEDENT>if is_match is True:<EOL><INDENT>matches.append(result)<EOL><DEDENT><DEDENT>if not quiet:<EOL><INDENT>bot.info(\"<STR_LIT>\" %(self._base,len(matches)))<EOL>for image in matches:<EOL><INDENT>if '<STR_LIT>' in image:<EOL><INDENT>image.update(image['<STR_LIT>'])<EOL><DEDENT>bot.info(image['<STR_LIT>'])<EOL>for key in sorted(image, key=len):<EOL><INDENT>val = image[key]<EOL>if isinstance(val,str):<EOL><INDENT>bot.custom(prefix=key.ljust(<NUM_LIT:10>), message=val, color=\"<STR_LIT>\")<EOL><DEDENT><DEDENT>bot.newline()<EOL><DEDENT><DEDENT>return matches<EOL>", "docstring": "search for a specific container.\n    This function is the same as the search all, but instead of showing all\n    results, filters them down based on user criteria (the query)", "id": "f9961:m3"}
{"signature": "def _update_secrets(self):", "body": "env = '<STR_LIT>'<EOL>self._secrets = self._get_and_update_setting(env)<EOL>self._base = self._get_and_update_setting('<STR_LIT>')<EOL>if self._base is None:<EOL><INDENT>self._base = '<STR_LIT>'<EOL><DEDENT>if self._secrets is None:<EOL><INDENT>bot.error('<STR_LIT>' %env)<EOL>bot.info(\"<STR_LIT>\")<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "The user is required to have an application secrets file in his\n           or her environment. The client exists with error \n           if the variable isn't found.", "id": "f9962:c0:m2"}
{"signature": "def get_or_create_folder(self, folder):", "body": "q = \"<STR_LIT>\" %folder<EOL>response = self._service.files().list(q=q,<EOL>spaces='<STR_LIT>').execute().get('<STR_LIT>',[])<EOL>if len(response) == <NUM_LIT:0>:            <EOL><INDENT>folder = self._create_folder(folder)<EOL><DEDENT>else:<EOL><INDENT>folder = response[<NUM_LIT:0>]<EOL><DEDENT>return folder<EOL>", "docstring": "create a folder at the drive root. If the folder already exists,\n       it is simply returned.\n\n           folder = self._get_or_create_folder(self._base)\n           $ folder\n             {'id': '1pXR5S8wufELh9Q-jDkhCoYu-BL1NqN9y'}", "id": "f9963:m0"}
{"signature": "def share(self, query, share_to):", "body": "images = self._container_query(query, quiet=True)<EOL>if len(images) == <NUM_LIT:0>:<EOL><INDENT>bot.error('<STR_LIT>' %query)<EOL>sys.exit(<NUM_LIT:0>)<EOL><DEDENT>image = images[<NUM_LIT:0>]<EOL>def callback(request_id, response, exception):<EOL><INDENT>if exception:<EOL><INDENT>print(exception)<EOL><DEDENT>else:<EOL><INDENT>share_id = response.get('<STR_LIT:id>')<EOL>bot.info('<STR_LIT>' %(share_to, share_id))<EOL><DEDENT><DEDENT>batch = self._service.new_batch_http_request(callback=callback)<EOL>user_permission = {<EOL>'<STR_LIT:type>': '<STR_LIT:user>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': share_to<EOL>}<EOL>batch.add(self._service.permissions().create(<EOL>fileId=image['<STR_LIT:id>'],<EOL>body=user_permission,<EOL>fields='<STR_LIT:id>',<EOL>))<EOL>batch.execute()<EOL>return image<EOL>", "docstring": "share will use the client to get an image based on a query, and then\n       the link with an email or endpoint (share_to) of choice.", "id": "f9964:m0"}
{"signature": "def list_endpoints(self, query=None):", "body": "bot.info('<STR_LIT>')<EOL>endpoints = self._get_endpoints(query)<EOL>bot.custom(prefix=\"<STR_LIT>\", message=\"<STR_LIT>\", color=\"<STR_LIT>\")<EOL>rows = []<EOL>for kind,eps in endpoints.items():<EOL><INDENT>for epid,epmeta in eps.items():<EOL><INDENT>rows.append([epid, '<STR_LIT>' %kind, epmeta['<STR_LIT:name>']])<EOL><DEDENT><DEDENT>bot.table(rows)<EOL>return rows<EOL>", "docstring": "list all endpoints, providing a list of endpoints to the user to\n       better filter the search. This function takes no arguments,\n       as the user has not provided an endpoint id or query.", "id": "f9967:m1"}
{"signature": "def search(self, query=None, args=None):", "body": "<EOL>if query is None:<EOL><INDENT>if args.endpoint is None:<EOL><INDENT>bot.info('<STR_LIT>')<EOL>return self._list_endpoints()<EOL><DEDENT>else:<EOL><INDENT>return self._list_endpoint(args.endpoint)<EOL><DEDENT><DEDENT>if args.endpoint is None:<EOL><INDENT>bot.info('<STR_LIT>')<EOL>return self._list_endpoints(query)<EOL><DEDENT>return self._list_endpoint(endpoint=args.endpoint, <EOL>query=query)<EOL>", "docstring": "query will show images determined by the extension of img\n       or simg.\n\n       Parameters\n       ==========\n       query: the container name (path) or uri to search for\n       args.endpoint: can be an endpoint id and optional path, e.g.:\n\n             --endpoint  6881ae2e-db26-11e5-9772-22000b9da45e:.singularity'\n             --endpoint  6881ae2e-db26-11e5-9772-22000b9da45e'\n\n       if not defined, we show the user endpoints to choose from\n\n       Usage\n       =====\n       If endpoint is defined with a query, then we search the given endpoint\n       for a container of interested (designated by ending in .img or .simg\n\n       If no endpoint is provided but instead just a query, we use the query\n       to search endpoints.", "id": "f9967:m0"}
{"signature": "def parse_endpoint_name(self, endpoint):", "body": "parts = [x for x in endpoint.split('<STR_LIT::>') if x]<EOL>endpoint = parts[<NUM_LIT:0>]<EOL>if len(parts) == <NUM_LIT:1>:<EOL><INDENT>path = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>path = '<STR_LIT:/>'.join(parts[<NUM_LIT:1>:])<EOL><DEDENT>return endpoint, path<EOL>", "docstring": "split an endpoint name by colon, as the user can provide an\n       endpoint name separated from a path:\n\n       Parameters\n       ==========\n       endpoint 12345:/path/on/remote", "id": "f9969:m0"}
{"signature": "def get_ipaddress(self, name, retries=<NUM_LIT:3>, delay=<NUM_LIT:3>):", "body": "for rr in range(retries):<EOL><INDENT>instances = self._get_instances()<EOL>for instance in instances['<STR_LIT>']:<EOL><INDENT>if instance['<STR_LIT:name>'] == name:<EOL><INDENT>for network in instance['<STR_LIT>']:<EOL><INDENT>if network['<STR_LIT:name>'] == '<STR_LIT>':<EOL><INDENT>for subnet in network['<STR_LIT>']:<EOL><INDENT>if subnet['<STR_LIT:name>'] == '<STR_LIT>':<EOL><INDENT>if '<STR_LIT>' in subnet:<EOL><INDENT>return subnet['<STR_LIT>']<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>sleep(delay) <EOL><DEDENT>bot.warning('<STR_LIT>')<EOL>", "docstring": "get the ip_address of an inserted instance. Will try three times with\n       delay to give the instance time to start up.\n\n       Parameters\n       ==========\n       name: the name of the instance to get the ip address for.\n       retries: the number of retries before giving up\n       delay: the delay between retry\n\n       Note from @vsoch: this function is pretty nasty.", "id": "f9972:m6"}
{"signature": "def load_templates(self, name):", "body": "configs = self._get_templates()<EOL>templates = []<EOL>matches = [x for x in configs['<STR_LIT:data>'] if name in x['<STR_LIT:name>']]<EOL>if len(matches) > <NUM_LIT:0>:<EOL><INDENT>for match in matches:<EOL><INDENT>response = self._get(match['<STR_LIT:id>'])<EOL>templates.append(response)<EOL><DEDENT>return templates<EOL><DEDENT>bot.info('<STR_LIT>' %name)<EOL>", "docstring": "load a particular template based on a name. We look for a name IN data,\n       so the query name can be a partial string of the full name.\n\n       Parameters\n       ==========\n       name: the name of a template to look up", "id": "f9972:m4"}
{"signature": "def load_build_config(self, config=None):", "body": "<EOL>if isinstance(config, dict):<EOL><INDENT>bot.debug('<STR_LIT>')<EOL>return config<EOL><DEDENT>if config is None:<EOL><INDENT>config = self._get_and_update_setting('<STR_LIT>',<EOL>'<STR_LIT>')<EOL><DEDENT>elif os.path.exists(config):<EOL><INDENT>return read_json(config)<EOL><DEDENT>configs = self._load_templates(config)<EOL>if configs is None:<EOL><INDENT>bot.error('<STR_LIT>' %name)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>bot.info('<STR_LIT>' %config)<EOL>config = configs[<NUM_LIT:0>]<EOL>return config<EOL>", "docstring": "load a google compute config, meaning that we have the following cases:\n\n       1. the user has not provided a config file directly, we look in env.\n       2. the environment is not set, so we use a reasonable default\n       3. if the final string is not found as a file, we look for it in library\n       4. we load the library name, or the user file, else error\n\n       Parameters\n       ==========\n       config: the config file the user has provided, or the library URI", "id": "f9972:m7"}
{"signature": "def get_templates(self):", "body": "base = '<STR_LIT>'<EOL>base = self._get_and_update_setting('<STR_LIT>', base)<EOL>base = \"<STR_LIT>\" %base<EOL>return self._get(base)<EOL>", "docstring": "list templates in the builder bundle library. If a name is provided,\n       look it up", "id": "f9972:m3"}
{"signature": "@retry(wait_exponential_multiplier=<NUM_LIT:1000>,<EOL>wait_exponential_max=<NUM_LIT>,<EOL>stop_max_attempt_number=<NUM_LIT:3>)<EOL>def run_build(self, config):", "body": "project = self._get_project()<EOL>zone = self._get_zone()<EOL>bot.custom(prefix='<STR_LIT>', message=config['<STR_LIT:name>'], color=\"<STR_LIT>\")<EOL>bot.info(config['<STR_LIT:description>'])<EOL>response = self._compute_service.instances().insert(project=project,<EOL>zone=zone,<EOL>body=config).execute()<EOL>ipaddress = self._get_ipaddress(config['<STR_LIT:name>'])<EOL>bot.info('<STR_LIT>' %ipaddress)<EOL>bot.info('<STR_LIT>')<EOL>return response<EOL>", "docstring": "run a build, meaning inserting an instance. Retry if there is failure\n\n       Parameters\n       ==========\n       config: the configuration dictionary generated by setup_build", "id": "f9972:m10"}
{"signature": "def list_templates(self, name=None):", "body": "configs = self._get_templates()<EOL>rows = []<EOL>if name:<EOL><INDENT>matches = self._load_templates(name)<EOL>bot.debug('<STR_LIT>' %(len(matches), name))<EOL>for match in matches:<EOL><INDENT>print(json.dumps(match, indent=<NUM_LIT:4>, sort_keys=True))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for config in configs['<STR_LIT:data>']:<EOL><INDENT>rows.append([config['<STR_LIT:name>']])<EOL><DEDENT>bot.table(rows)<EOL><DEDENT>", "docstring": "list templates in the builder bundle library. If a name is provided,\n       look it up\n\n       Parameters\n       ==========\n       name: the name of a template to look up", "id": "f9972:m2"}
{"signature": "def search_all(self):", "body": "results = self._list_containers()<EOL>bot.info(\"<STR_LIT>\" %self._bucket_name)<EOL>rows = []<EOL>for i in results:<EOL><INDENT>size = round(i.size / (<NUM_LIT>*<NUM_LIT>))<EOL>size = (\"<STR_LIT>\" %size).rjust(<NUM_LIT:10>)<EOL>rows.append([size,i.metadata['<STR_LIT>']])<EOL><DEDENT>bot.table(rows)<EOL>return rows<EOL>", "docstring": "a \"list all\" search that doesn't require a query. Here we return to\n       the user all objects that have custom metadata value of \"container\"\n\n       IMPORTANT: the upload function adds this metadata. For a container to\n       be found by the client, it must have the type as container in metadata.", "id": "f9973:m2"}
{"signature": "def list_containers(self):", "body": "results = []<EOL>for image in self._bucket.list_blobs():<EOL><INDENT>if image.metadata is not None:<EOL><INDENT>if \"<STR_LIT:type>\" in image.metadata:<EOL><INDENT>if image.metadata['<STR_LIT:type>'] == \"<STR_LIT>\":<EOL><INDENT>results.append(image)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if len(results) == <NUM_LIT:0>:<EOL><INDENT>bot.info(\"<STR_LIT>\")<EOL><DEDENT>return results<EOL>", "docstring": "return a list of containers, determined by finding the metadata field\n       \"type\" with value \"container.\" We alert the user to no containers \n       if results is empty, and exit\n\n       {'metadata': {'items': \n                              [\n                               {'key': 'type', 'value': 'container'}, ... \n                              ]\n                    }\n       }", "id": "f9973:m1"}
{"signature": "def _get_bucket(self):", "body": "<EOL>try:<EOL><INDENT>self._bucket = self._bucket_service.get_bucket(self._bucket_name)<EOL><DEDENT>except google.cloud.exceptions.NotFound:<EOL><INDENT>self._bucket = self._bucket_service.create_bucket(self._bucket_name)<EOL><DEDENT>except:<EOL><INDENT>bot.error('<STR_LIT>' %self._bucket_name)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>return self._bucket<EOL>", "docstring": "get a bucket based on a bucket name. If it doesn't exist, create it.", "id": "f9974:c0:m5"}
{"signature": "def _get_zone(self, zone='<STR_LIT>'):", "body": "return self._get_and_update_setting('<STR_LIT>', zone)<EOL>", "docstring": "get zone returns the zone set in the environment, or the default\n\n           Parameters\n           ==========\n           zone: a default zone, will be us-west1-a by default", "id": "f9974:c0:m7"}
{"signature": "def _speak(self):", "body": "bot.info('<STR_LIT>' %self._bucket_name)<EOL>", "docstring": "add the bucket name to be printed to the user at appropriate times", "id": "f9974:c0:m1"}
{"signature": "def _get_services(self, version='<STR_LIT>'):", "body": "self._bucket_service = storage.Client()<EOL>creds = GoogleCredentials.get_application_default()<EOL>self._storage_service = discovery_build('<STR_LIT>', version, credentials=creds)<EOL>self._compute_service = discovery_build('<STR_LIT>', version, credentials=creds)<EOL>", "docstring": "get version 1 of the google compute and storage service\n\n        Parameters\n        ==========\n        version: version to use (default is v1)", "id": "f9974:c0:m4"}
{"signature": "def prepare_metadata(metadata):", "body": "pairs = {<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': [{<EOL>'<STR_LIT:key>': '<STR_LIT>',<EOL>'<STR_LIT:value>': '<STR_LIT>'<EOL>}<EOL>]<EOL>}<EOL>}<EOL>for key,val in metadata.items():<EOL><INDENT>if not isinstance(val,dict) and not isinstance(val,list):<EOL><INDENT>pairs['<STR_LIT>']['<STR_LIT>'].append({'<STR_LIT:key>':key,'<STR_LIT:value>':val})<EOL><DEDENT>elif isinstance(val,dict):            <EOL><INDENT>for k,v in val.items():<EOL><INDENT>if not isinstance(v,dict) and not isinstance(v,list):<EOL><INDENT>pairs['<STR_LIT>']['<STR_LIT>'].append({'<STR_LIT:key>':k,'<STR_LIT:value>':v})<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return pairs<EOL>", "docstring": "prepare a key/value list of metadata for the request. The metadata\n       object that comes in is only parsed one level.", "id": "f9975:m0"}
{"signature": "def push(self, path, name, tag=None):", "body": "path = os.path.abspath(path)<EOL>bot.debug(\"<STR_LIT>\" % path)<EOL>if not os.path.exists(path):<EOL><INDENT>bot.error('<STR_LIT>' %path)<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>names = parse_image_name(remove_uri(name), tag=tag)<EOL>file_size = os.path.getsize(path)<EOL>chunk_size = <NUM_LIT:4> * <NUM_LIT> * <NUM_LIT><EOL>storage_path = \"<STR_LIT>\" %names['<STR_LIT>']<EOL>collection = self._get_or_create_collection(names['<STR_LIT>'])<EOL>image_name = os.path.basename(names['<STR_LIT>'])<EOL>progress = <NUM_LIT:0><EOL>bot.show_progress(progress, file_size, length=<NUM_LIT>)<EOL>with open(path, '<STR_LIT:rb>') as F:<EOL><INDENT>self.conn.put_object(names['<STR_LIT>'], image_name,<EOL>contents= F.read(),<EOL>content_type='<STR_LIT>')<EOL><DEDENT>bot.show_progress(iteration=file_size,<EOL>total=file_size,<EOL>length=<NUM_LIT>,<EOL>carriage_return=True)<EOL>sys.stdout.write('<STR_LIT:\\n>')<EOL>", "docstring": "push an image to your Storage. If the collection doesn't exist,\n       it is created.\n\n       Parameters\n       ==========\n       path: should correspond to an absolute image path (or derive it)\n       name: should be the complete uri that the user has requested to push.\n       tag: should correspond with an image tag. This is provided to mirror Docker", "id": "f9976:m0"}
{"signature": "def pull(self, images, file_name=None, save=True, **kwargs):", "body": "force = False<EOL>if \"<STR_LIT>\" in kwargs:<EOL><INDENT>force = kwargs['<STR_LIT>']<EOL><DEDENT>if not isinstance(images, list):<EOL><INDENT>images = [images]<EOL><DEDENT>bot.debug('<STR_LIT>' % len(images))<EOL>finished = []<EOL>for image in images:<EOL><INDENT>names = parse_image_name(remove_uri(image))<EOL>collection = self._get_collection(names['<STR_LIT>'])<EOL>if collection is None:<EOL><INDENT>bot.error('<STR_LIT>' % names['<STR_LIT>'])<EOL>collections = self.get_collections()<EOL>if collections:<EOL><INDENT>bot.info('<STR_LIT>' %'<STR_LIT:\\n>'.join(collections))<EOL><DEDENT>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>image_name = os.path.basename(names['<STR_LIT>'])<EOL>try:<EOL><INDENT>obj_tuple = self.conn.get_object(names['<STR_LIT>'], image_name)<EOL><DEDENT>except ClientException:<EOL><INDENT>bot.exit('<STR_LIT>' % names['<STR_LIT>'])<EOL><DEDENT>if names['<STR_LIT:version>'] == None:<EOL><INDENT>names['<STR_LIT:version>'] = obj_tuple[<NUM_LIT:0>]['<STR_LIT>']<EOL><DEDENT>if file_name is None:<EOL><INDENT>file_name = self._get_storage_name(names)<EOL><DEDENT>if os.path.exists(file_name) and force is False:<EOL><INDENT>bot.error('<STR_LIT>')<EOL>sys.exit(<NUM_LIT:1>) <EOL><DEDENT>with open(file_name, '<STR_LIT:wb>') as filey:<EOL><INDENT>filey.write(obj_tuple[<NUM_LIT:1>])<EOL><DEDENT>if save is True:<EOL><INDENT>names.update(obj_tuple[<NUM_LIT:0>])<EOL>container = self.add(image_path = file_name,<EOL>image_uri = names['<STR_LIT>'],<EOL>metadata = names)<EOL>image_file = container.image<EOL>if os.path.exists(image_file):<EOL><INDENT>bot.debug('<STR_LIT>' %image_file)<EOL>bot.custom(prefix=\"<STR_LIT>\", message=image_file)<EOL>finished.append(image_file)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>bot.error('<STR_LIT>' % path)<EOL><DEDENT><DEDENT>if len(finished) == <NUM_LIT:1>:<EOL><INDENT>finished = finished[<NUM_LIT:0>]<EOL><DEDENT>return finished<EOL>", "docstring": "pull an image from storage using Swift. The image is found based on the\n       storage uri\n\n       Parameters\n       ==========\n       images: refers to the uri given by the user to pull in the format\n       <collection>/<namespace>. You should have an API that is able to \n       retrieve a container based on parsing this uri.\n       file_name: the user's requested name for the file. It can \n                  optionally be None if the user wants a default.\n       save: if True, you should save the container to the database\n             using self.add()\n\n       Returns\n       =======\n       finished: a single container path, or list of paths", "id": "f9977:m0"}
{"signature": "def container_query(self, query):", "body": "results = set()<EOL>query = remove_uri(query)<EOL>for container in self.conn.get_account()[<NUM_LIT:1>]:<EOL><INDENT>for result in self.conn.get_container(container['<STR_LIT:name>'])[<NUM_LIT:1>]:<EOL><INDENT>if query in collection['<STR_LIT:name>']:<EOL><INDENT>results.add('<STR_LIT>' %(container['<STR_LIT:name>'], result['<STR_LIT:name>']))<EOL><DEDENT><DEDENT><DEDENT>if len(results) == <NUM_LIT:0>:<EOL><INDENT>bot.info(\"<STR_LIT>\")<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>bot.info(\"<STR_LIT>\")<EOL>bot.table([list(results)])<EOL>return list(results)<EOL>", "docstring": "search for a specific container.\n    This function would likely be similar to the above, but have different\n    filter criteria from the user (based on the query)", "id": "f9978:m2"}
{"signature": "def _speak(self):", "body": "if hasattr(self, '<STR_LIT>'):<EOL><INDENT>bot.info('<STR_LIT>' % self.name)<EOL><DEDENT>", "docstring": "if you want to add an extra print (of a parameter, for example)\n           for the user when the client initalizes, write it here, eg:\n           bot.info('[setting] value')", "id": "f9979:c0:m1"}
{"signature": "def read_client_secrets():", "body": "client_secrets = _default_client_secrets()<EOL>secrets = get_secrets_file()<EOL>if secrets is not None:<EOL><INDENT>client_secrets = read_json(secrets)<EOL><DEDENT>else:<EOL><INDENT>from sregistry.defaults import SREGISTRY_CLIENT_SECRETS<EOL>write_json(client_secrets, SREGISTRY_CLIENT_SECRETS)<EOL><DEDENT>return client_secrets<EOL>", "docstring": "for private or protected registries, a client secrets file is required\n       to be located at .sregistry. If no secrets are found, we use default\n       of Singularity Hub, and return a dummy secrets.", "id": "f9981:m3"}
{"signature": "def get_lookup():", "body": "lookup = dict()<EOL>version_file = os.path.join('<STR_LIT>', '<STR_LIT>')<EOL>with open(version_file) as filey:<EOL><INDENT>exec(filey.read(), lookup)<EOL><DEDENT>return lookup<EOL>", "docstring": "get version by way of sregistry.version, returns a \n    lookup dictionary with several global variables without\n    needing to import singularity", "id": "f9983:m0"}
{"signature": "def handle_cdata(pos, window, charpat, stopchars):", "body": "cdata = '<STR_LIT>'<EOL>cursor = start = pos<EOL>try:<EOL><INDENT>while True:<EOL><INDENT>while charpat.match(window[cursor]):<EOL><INDENT>cursor += <NUM_LIT:1><EOL><DEDENT>addchars = window[start:cursor]<EOL>cdata += addchars<EOL>if window[cursor] in stopchars:<EOL><INDENT>return cdata, cursor<EOL><DEDENT>elif window[cursor] == '<STR_LIT:&>':<EOL><INDENT>start = cursor = cursor + <NUM_LIT:1><EOL>if window[cursor] == '<STR_LIT:#>' and window[cursor + <NUM_LIT:1>] == '<STR_LIT:x>':<EOL><INDENT>start = cursor = cursor + <NUM_LIT:2><EOL>while True:<EOL><INDENT>if HEXCHARENTOK.match(window[cursor]):<EOL><INDENT>cursor += <NUM_LIT:1><EOL><DEDENT>elif window[cursor] == '<STR_LIT:;>':<EOL><INDENT>c = chr(int(window[start:cursor], <NUM_LIT:16>))<EOL>if not CHARACTER.match(c):<EOL><INDENT>raise RuntimeError('<STR_LIT>'.format('<STR_LIT:&>' + window[start:cursor] + '<STR_LIT:;>'))<EOL><DEDENT>cdata += c<EOL>break<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>'.format(window[cursor]))<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>while True:<EOL><INDENT>if NAMEDCHARENTOK.match(window[cursor]):<EOL><INDENT>cursor += <NUM_LIT:1><EOL><DEDENT>elif window[cursor] == '<STR_LIT:;>':<EOL><INDENT>for cn, c in CHARNAMES:<EOL><INDENT>if window[start:cursor] == cn:<EOL><INDENT>cdata += c<EOL>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>'.format(repr(window[start:cursor])))<EOL><DEDENT>break<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>'.format(window[cursor]), error_context(window, start, cursor))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>cursor += <NUM_LIT:1><EOL>start = cursor<EOL><DEDENT><DEDENT>except IndexError:<EOL><INDENT>return None, cursor<EOL><DEDENT>", "docstring": "Return (result, new_position) tuple.\nResult is cdata string if possible and None if more input is needed\nOr of course bad syntax can raise a RuntimeError", "id": "f9985:m0"}
{"signature": "def __call__(self, ctx):", "body": "yield from self.compute(ctx)<EOL>", "docstring": "Alias for user convenience", "id": "f9988:c7:m3"}
{"signature": "def __call__(self, ctx):", "body": "yield from self.compute(ctx)<EOL>", "docstring": "Alias for user convenience", "id": "f9988:c2:m3"}
{"signature": "def __call__(self, ctx):", "body": "yield from self.compute(ctx)<EOL>", "docstring": "Alias for user convenience", "id": "f9988:c4:m3"}
{"signature": "def p_axis_specifier_abbrev(p):", "body": "p[<NUM_LIT:0>] = '<STR_LIT>'<EOL>", "docstring": "AxisSpecifier : ABBREV_AXIS_AT", "id": "f9989:m19"}
{"signature": "def p_expr_sequence_empty(p):", "body": "p[<NUM_LIT:0>] = ast.Sequence([])<EOL>", "docstring": "Expr : OPEN_PAREN CLOSE_PAREN", "id": "f9989:m2"}
{"signature": "def p_formal_arguments_list(p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:2>]<EOL>", "docstring": "FormalArguments : OPEN_PAREN ArgumentList CLOSE_PAREN", "id": "f9989:m32"}
{"signature": "def p_expr_paths_etc(p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "Expr : RelativeLocationPath\n     | AbsoluteLocationPath\n     | AbbreviatedAbsoluteLocationPath\n     | PredicatedExpression\n     | FunctionCall\n     | VariableReference", "id": "f9989:m8"}
{"signature": "def p_expr_boolean(p):", "body": "p[<NUM_LIT:0>] = ast.BinaryExpression(p[<NUM_LIT:1>], p[<NUM_LIT:2>], p[<NUM_LIT:3>])<EOL>", "docstring": "Expr : Expr OR_OP Expr\n     | Expr AND_OP Expr\n     | Expr EQUAL_OP Expr\n     | Expr REL_OP Expr\n     | Expr PLUS_OP Expr\n     | Expr MINUS_OP Expr\n     | Expr MULT_OP Expr\n     | Expr DIV_OP Expr\n     | Expr MOD_OP Expr", "id": "f9989:m0"}
{"signature": "def p_relative_location_path_binary(p):", "body": "p[<NUM_LIT:0>] = ast.BinaryExpression(p[<NUM_LIT:1>], p[<NUM_LIT:2>], p[<NUM_LIT:3>])<EOL>", "docstring": "RelativeLocationPath : RelativeLocationPath PATH_SEP Step\n                     | RelativeLocationPath ABBREV_PATH_SEP Step", "id": "f9989:m14"}
{"signature": "def p_relative_location_path_simple(p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "RelativeLocationPath : Step", "id": "f9989:m13"}
{"signature": "def p_expr_sequence(p):", "body": "p[<NUM_LIT:0>] = ast.Sequence(p[<NUM_LIT:2>])<EOL>", "docstring": "Expr : OPEN_PAREN ExprList CLOSE_PAREN", "id": "f9989:m3"}
{"signature": "def p_function_call(p):", "body": "<EOL>if p[<NUM_LIT:1>] in ('<STR_LIT>', '<STR_LIT:text>'):<EOL><INDENT>p[<NUM_LIT:0>] = ast.NodeType(p[<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>p[<NUM_LIT:0>] = ast.FunctionCall(p[<NUM_LIT:1>], p[<NUM_LIT:2>])<EOL><DEDENT>", "docstring": "FunctionCall : NAME FormalArguments", "id": "f9989:m30"}
{"signature": "def p_expr_predicates(p):", "body": "p[<NUM_LIT:0>] = ast.PredicatedExpression(p[<NUM_LIT:1>], p[<NUM_LIT:2>])<EOL>", "docstring": "PredicatedExpression : Expr PredicateList", "id": "f9989:m24"}
{"signature": "def p_argument_list_single(p):", "body": "p[<NUM_LIT:0>] = [p[<NUM_LIT:1>]]<EOL>", "docstring": "ArgumentList : Expr", "id": "f9989:m33"}
{"signature": "def p_predicate(p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:2>]<EOL>", "docstring": "Predicate : OPEN_BRACKET Expr CLOSE_BRACKET", "id": "f9989:m27"}
{"signature": "def p_variable_reference(p):", "body": "p[<NUM_LIT:0>] = ast.VariableReference(p[<NUM_LIT:2>])<EOL>", "docstring": "VariableReference : DOLLAR NAME", "id": "f9989:m28"}
{"signature": "@microxpath_function('<STR_LIT>')<EOL>def normalize_space(ctx, s):", "body": "<EOL>raise NotImplementedError<EOL>yield s<EOL>", "docstring": "Yields one string", "id": "f9990:m16"}
{"signature": "@microxpath_function('<STR_LIT>')<EOL>def number(ctx, seq=None):", "body": "if hasattr(obj, '<STR_LIT>'):<EOL><INDENT>obj = next(seq.compute(ctx), '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>obj = seq<EOL><DEDENT>yield next(to_number(obj), '<STR_LIT>')<EOL>", "docstring": "Yields one float, derived from the first item in the argument sequence (unless empty in which case yield NaN) as follows:\n\n* If string with optional whitespace followed by an optional minus sign followed by a Number followed by whitespace, converte to the IEEE 754 number that is nearest (according to the IEEE 754 round-to-nearest rule) to the mathematical value represented by the string; in case of any other string yield NaN\n* If boolean true yield 1; if boolean false yield 0\n* If a node convert to string as if by a call to string(); yield the same value as if passed that string argument to number()", "id": "f9990:m23"}
{"signature": "@microxpath_function('<STR_LIT>')<EOL>def _not(ctx, obj):", "body": "yield not next(boolean_arg(ctx, obj), False)<EOL>", "docstring": "Yields one boolean", "id": "f9990:m20"}
{"signature": "@microxpath_function('<STR_LIT>')<EOL>def string_length(ctx, s=None):", "body": "if s is None:<EOL><INDENT>s = ctx.node<EOL><DEDENT>elif callable(s):<EOL><INDENT>s = next(s.compute(ctx), '<STR_LIT>')<EOL><DEDENT>yield len(s)<EOL>", "docstring": "Yields one number", "id": "f9990:m15"}
{"signature": "@microxpath_function('<STR_LIT>')<EOL>def concat(ctx, *strings):", "body": "strings = flatten([ (s.compute(ctx) if callable(s) else s) for s in strings ])<EOL>strings = (next(string_arg(ctx, s), '<STR_LIT>') for s in strings)<EOL>yield '<STR_LIT>'.join(strings)<EOL>", "docstring": "Yields one string, concatenation of argument strings", "id": "f9990:m9"}
{"signature": "@microxpath_function('<STR_LIT>')<EOL>def foreach_(ctx, seq, expr):", "body": "from . import context, parse as uxpathparse<EOL>if hasattr(seq, '<STR_LIT>'):<EOL><INDENT>seq = seq.compute(ctx)<EOL><DEDENT>expr = next(string_arg(ctx, expr), '<STR_LIT>')<EOL>pexpr = uxpathparse(expr)<EOL>for item in seq:<EOL><INDENT>innerctx = ctx.copy(item=item)<EOL>yield from pexpr.compute(innerctx)<EOL><DEDENT>", "docstring": "Yields the result of applying an expression to each item in the input sequence.\n\n* seq: input sequence\n* expr: expression to be converted to string, then dynamically evaluated for each item on the sequence to produce the result", "id": "f9990:m24"}
{"signature": "@microxpath_function('<STR_LIT>')<EOL>def translate(ctx, s, subst):", "body": "<EOL>raise NotImplementedError<EOL>yield s<EOL>", "docstring": "Yields one string", "id": "f9990:m17"}
{"signature": "@microxpath_function('<STR_LIT>')<EOL>def boolean(ctx, obj):", "body": "if hasattr(obj, '<STR_LIT>'):<EOL><INDENT>obj = next(seq.compute(ctx), '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>obj = seq<EOL><DEDENT>yield next(to_boolean(obj), '<STR_LIT>')<EOL>", "docstring": "Yields one boolean, false if the argument sequence is empty, otherwise\n\n* false if the first item is a boolean and false\n* false if the first item is a number and positive or negative zero or NaN\n* false if the first item is a string and ''\n* true in all other cases", "id": "f9990:m19"}
{"signature": "def t_FLOAT(t):", "body": "t.value = float(t.value)<EOL>return t<EOL>", "docstring": "r'\\d+\\.\\d*|\\.\\d+", "id": "f9992:m1"}
{"signature": "def select_attribute(source, name, val=None):", "body": "def check(x):<EOL><INDENT>if val is None:<EOL><INDENT>return name in x.xml_attributes<EOL><DEDENT>else:<EOL><INDENT>return name in x.xml_attributes and x.xml_attributes[name] == val<EOL><DEDENT><DEDENT>return filter(check, select_elements(source))<EOL>", "docstring": "Yields elements from the source having the given attrivute, optionally with the given attribute value\nsource - if an element, starts with all child elements in order; can also be any other iterator\nname - attribute name to check\nval - if None check only for the existence of the attribute, otherwise compare the given value as well", "id": "f9994:m5"}
{"signature": "def following_siblings(elem):", "body": "it = itertools.dropwhile(lambda x: x != elem, elem.xml_parent.xml_children)<EOL>next(it) <EOL>return it<EOL>", "docstring": "Yields elements and text which have the same parent as elem, but come afterward in document order", "id": "f9994:m6"}
{"signature": "def select_pattern(node, pattern, state=None):", "body": "if state is None:<EOL><INDENT>state = _prep_pattern(pattern)<EOL><DEDENT>if isinstance(node, element):<EOL><INDENT>for child in node.xml_children:<EOL><INDENT>new_state = state(child)<EOL>if new_state == MATCHED_STATE:<EOL><INDENT>yield child<EOL><DEDENT>elif new_state is not None:<EOL><INDENT>yield from select_pattern(child, None, state=new_state)<EOL><DEDENT><DEDENT><DEDENT>return<EOL>", "docstring": "Yield descendant nodes matching the given pattern specification\npattern - tuple of steps, each of which matches an element by name, with \"*\" acting like a wildcard, descending the tree in tuple order\n            sort of like a subset of XPath in Python tuple form\nstate - for internal use only\n\npattern examples:\n\n(\"a\", \"b\", \"c\") - all c elements whose parent is a b element whose parent is an a element whose parent is node\n(\"*\", \"*\") - any \"grandchild\" of node\n(\"*\", \"*\", \"*\") - any \"great grandchild\" of node\n(\"**\", \"a\") - any a descendant of node\n\n>>> from amara3.uxml import tree\n>>> from amara3.uxml.treeutil import *\n>>>\n>>> tb = tree.treebuilder()\n>>> DOC = '<a xmlns=\"urn:namespaces:suck\"><b><x>1</x></b><c><x>2</x><d><x>3</x></d></c><x>4</x><y>5</y></a>'\n>>> root = tb.parse(DOC)\n>>> results = [ e.xml_value for e in select_pattern(root, ('**', 'x')) ]\n>>> results\n['1', '2', '3', '4']", "id": "f9994:m13"}
{"signature": "def cloneNode(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Return a shallow copy of the current node i.e. a node with the same\n        name and attributes but with no parent or child nodes", "id": "f9998:c0:m4"}
{"signature": "def expect_regex(self, pattern):", "body": "<EOL>end_time = time.time() + self.timeout<EOL>buf = '<STR_LIT>'<EOL>prog = regex.compile(pattern)<EOL>while (end_time - time.time()) > <NUM_LIT:0.0>:<EOL><INDENT>reads, _, _ = select.select([self.fd], [], [], end_time - time.time())<EOL>if len(reads) > <NUM_LIT:0>:<EOL><INDENT>try:<EOL><INDENT>buf = remove_ansi_escape_sequences(buf + self.read())<EOL><DEDENT>except EOFError:<EOL><INDENT>assert prog.match(buf) is not None,'<STR_LIT>' % (buf, pattern)<EOL><DEDENT>if prog.match(buf):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>else:<EOL><INDENT>time.sleep(self.timeout/<NUM_LIT:10>)<EOL><DEDENT><DEDENT>assert prog.match(buf) is not None,'<STR_LIT>' % (buf, pattern)<EOL>", "docstring": "Read until matches pattern or timeout.", "id": "f10022:c1:m7"}
{"signature": "def create_example_fixture(example):", "body": "@pytest.fixture<EOL>def example_app():<EOL><INDENT>p = SimplePty.spawn(['<STR_LIT>', example])<EOL>yield p<EOL>time.sleep(p.delayafterterminate)<EOL>p.sendintr()  <EOL>p.wait()  <EOL><DEDENT>return example_app<EOL>", "docstring": "Create a pytest fixture to run the example in pty subprocess & cleanup.\n\n    :param example: relative path like 'examples/input.py'\n    :return: pytest fixture", "id": "f10022:m2"}
{"signature": "def write(self, s):", "body": "if isinstance(s, basestring):<EOL><INDENT>b = s.encode(self.encoding)<EOL><DEDENT>count = super(SimplePty, self).write(b)<EOL>return count<EOL>", "docstring": "Write the unicode string ``s`` to the pseudoterminal.\n        This intends to make tests a little less verbose.\n\n        Returns the number of bytes written.", "id": "f10022:c1:m3"}
{"signature": "def expect(self, text):", "body": "<EOL>end_time = time.time() + self.timeout<EOL>buf = '<STR_LIT>'<EOL>while (end_time - time.time()) > <NUM_LIT:0.0>:<EOL><INDENT>reads, _, _ = select.select([self.fd], [], [], end_time - time.time())<EOL>if len(reads) > <NUM_LIT:0>:<EOL><INDENT>try:<EOL><INDENT>buf = remove_ansi_escape_sequences(buf + self.read())<EOL><DEDENT>except EOFError:<EOL><INDENT>print('<STR_LIT>' % len(buf))<EOL>assert buf == text<EOL><DEDENT>if buf == text:<EOL><INDENT>return<EOL><DEDENT>elif len(buf) >= len(text):<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>time.sleep(self.timeout/<NUM_LIT:10>)<EOL><DEDENT><DEDENT>assert buf == text<EOL>", "docstring": "Read until equals text or timeout.", "id": "f10022:c1:m6"}
{"signature": "def get_connection(db=DATABASE):", "body": "return database.connect(host=HOST, port=PORT, user=USER, password=PASSWORD, database=db)<EOL>", "docstring": "Returns a new connection to the database.", "id": "f10056:m0"}
{"signature": "def __init__(self, host, port, user='<STR_LIT:root>', password='<STR_LIT>', database='<STR_LIT>'):", "body": "self.logger = logging.getLogger('<STR_LIT>')<EOL>self._pool = ConnectionPool()<EOL>self._refresh_aggregator_list = memoize(<NUM_LIT:30>)(self._update_aggregator_list)<EOL>self._lock = threading.RLock()<EOL>self._primary_aggregator = (host, port)<EOL>self._user = user<EOL>self._password = password<EOL>self._database = database<EOL>self._aggregators = []<EOL>self._aggregator = None<EOL>self._master_aggregator = None<EOL>", "docstring": "Initialize the RandomAggregatorPool with connection\n        information for an aggregator in a MemSQL Distributed System.\n\n        All aggregator connections will share the same user/password/database.", "id": "f10061:c0:m0"}
{"signature": "def connect(self):", "body": "conn = self._connect()<EOL>self._refresh_aggregator_list(conn)<EOL>return conn<EOL>", "docstring": "Returns an aggregator connection, and periodically updates the aggregator list.", "id": "f10061:c0:m1"}
{"signature": "def rolling_restart(self):", "body": "self._current_version = self._current_version + <NUM_LIT:1><EOL>", "docstring": "Gradually close all existing connections, allowing currently-used connections to finish.\n\n        This may be used after MemSQL session state has changed and pre-existing connections\n        are no longer valid.", "id": "f10062:c2:m1"}
{"signature": "def __potential_connection_failure(self, e):", "body": "try:<EOL><INDENT>self._conn.query('<STR_LIT>')<EOL><DEDENT>except (IOError, _mysql.OperationalError):<EOL><INDENT>self.__handle_connection_failure(e)<EOL><DEDENT>else:<EOL><INDENT>raise _mysql.DatabaseError(*e.args)<EOL><DEDENT>", "docstring": "OperationalError's are emitted by the _mysql library for\n        almost every error code emitted by MySQL.  Because of this we\n        verify that the error is actually a connection error before\n        terminating the connection and firing off a PoolConnectionException", "id": "f10062:c3:m7"}
{"signature": "def __init__(self, table_name, execution_ttl=<NUM_LIT>, task_handler_class=TaskHandler):", "body": "super(SQLStepQueue, self).__init__()<EOL>self.table_name = table_name<EOL>self.execution_ttl = execution_ttl<EOL>self.TaskHandlerClass = task_handler_class<EOL>self._define_table(self.table_name, PRIMARY_TABLE % { '<STR_LIT>': self.table_name })<EOL>", "docstring": "table_name      the table name for the queue in the DB\nexecution_ttl   the amount of time (in seconds) that can pass before a task is automatically requeued", "id": "f10066:c0:m0"}
{"signature": "def valid(self):", "body": "if self.finished is not None:<EOL><INDENT>return False<EOL><DEDENT>with self._db_conn() as conn:<EOL><INDENT>row = conn.get('''<STR_LIT>''' % self._queue.table_name,<EOL>now=datetime.utcnow(),<EOL>ttl=self._queue.execution_ttl,<EOL>task_id=self.task_id,<EOL>execution_id=self.execution_id)<EOL><DEDENT>return bool(row is not None and row.valid)<EOL>", "docstring": "Check to see if we are still active.", "id": "f10068:c0:m1"}
{"signature": "def simple_expression(joiner='<STR_LIT:U+002CU+0020>', **fields):", "body": "expression, params = [], {}<EOL>for field_name, value in sorted(fields.items(), key=lambda kv: kv[<NUM_LIT:0>]):<EOL><INDENT>key = '<STR_LIT>' % field_name<EOL>expression.append('<STR_LIT>' % (field_name, key))<EOL>params[key] = value<EOL><DEDENT>return joiner.join(expression), params<EOL>", "docstring": "Build a simple expression ready to be added onto another query.\n\n    >>> simple_expression(joiner=' AND ', name='bob', role='admin')\n    \"`name`=%(_QB_name)s AND `name`=%(_QB_role)s\", { '_QB_name': 'bob', '_QB_role': 'admin' }", "id": "f10080:m0"}
{"signature": "def multi_replace(table_name, *rows):", "body": "return __multi_insert(table_name, rows, replace=True)<EOL>", "docstring": "Build a multi-replace query.\n        Each row in rows should be a dict of { column_name: column_value }\n\n    >>> multi_replace('foo_table', { 'a': 5, 'b': 2 }, { 'a': 5, 'b': 2 })\n    \"REPLACE INTO `foo_table` (`a`, `b`) VALUES (%(_QB_ROW_0)s), (%(_QB_ROW_1)s)\"", "id": "f10080:m3"}
{"signature": "def thread_id(self):", "body": "return self._db.thread_id()<EOL>", "docstring": "Retrieve the thread id for the current connection", "id": "f10082:c0:m9"}
{"signature": "def execute_lastrowid(self, query, *parameters, **kwparameters):", "body": "self._execute(query, parameters, kwparameters)<EOL>self._result = self._db.store_result()<EOL>return self._db.insert_id()<EOL>", "docstring": "Executes the given query, returning the lastrowid from the query.", "id": "f10082:c0:m14"}
{"signature": "@staticmethod<EOL><INDENT>def deserialize(pickle_serialized='<STR_LIT>'):<DEDENT>", "body": "return pickle.loads(pickle_serialized)<EOL>", "docstring": "ddserialize", "id": "f10088:c3:m1"}
{"signature": "def error_function(self, y_prediction, y_truth):<EOL>", "body": "if y_prediction != y_truth:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>", "docstring": "Error function to calculate error", "id": "f10091:c0:m6"}
{"signature": "def load_train_data(self, input_data_file='<STR_LIT>'):", "body": "self.status = '<STR_LIT>'<EOL>if (input_data_file == '<STR_LIT>'):<EOL><INDENT>input_data_file = os.path.normpath(os.path.join(os.path.join(os.getcwd(), os.path.dirname(__file__)), \"<STR_LIT>\"))<EOL><DEDENT>else:<EOL><INDENT>if (os.path.isfile(input_data_file) is not True):<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return self.train_X, self.train_Y<EOL><DEDENT><DEDENT>self.train_X, self.train_Y = utility.DatasetLoader.load(input_data_file)<EOL>return self.train_X, self.train_Y<EOL>", "docstring": "Load train data\nPlease check dataset/pla_binary_train.dat to understand the data format\nEach feature of data x separated with spaces\nAnd the ground truth y put in the end of line separated by a space", "id": "f10091:c0:m1"}
{"signature": "def set_feature_transform(self, mode='<STR_LIT>', degree=<NUM_LIT:1>):", "body": "if self.status != '<STR_LIT>':<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return self.train_X<EOL><DEDENT>self.feature_transform_mode = mode<EOL>self.feature_transform_degree = degree<EOL>self.train_X = self.train_X[:, <NUM_LIT:1>:]<EOL>self.train_X = utility.DatasetLoader.feature_transform(<EOL>self.train_X,<EOL>self.feature_transform_mode,<EOL>self.feature_transform_degree<EOL>)<EOL>return self.train_X<EOL>", "docstring": "Transform data feature to high level", "id": "f10092:c0:m3"}
{"signature": "def __init__(self):", "body": "self.status = '<STR_LIT>'<EOL>self.train_X = []<EOL>self.train_Y = []<EOL>self.W = []<EOL>self.data_num = <NUM_LIT:0><EOL>self.data_demension = <NUM_LIT:0><EOL>self.test_X = []<EOL>self.test_Y = []<EOL>self.feature_transform_mode = '<STR_LIT>'<EOL>self.feature_transform_degree = <NUM_LIT:1><EOL>self.lambda_p = <NUM_LIT><EOL>self.svm_kernel = '<STR_LIT>'<EOL>self.zeta = <NUM_LIT:0><EOL>self.gamma = <NUM_LIT:1><EOL>self.Q = <NUM_LIT:1><EOL>self.C = <NUM_LIT:0.1><EOL>self.beta = []<EOL>", "docstring": "init", "id": "f10094:c0:m0"}
{"signature": "def score_function(self, x, W):<EOL>", "body": "score = self.theta(np.inner(x, W))<EOL>return score<EOL>", "docstring": "Score function to calculate score", "id": "f10097:c0:m6"}
{"signature": "def __init__(self):", "body": "self.status = '<STR_LIT>'<EOL>self.train_X = []<EOL>self.train_Y = []<EOL>self.W = {}<EOL>self.data_num = <NUM_LIT:0><EOL>self.data_demension = <NUM_LIT:0><EOL>self.test_X = []<EOL>self.test_Y = []<EOL>self.feature_transform_mode = '<STR_LIT>'<EOL>self.feature_transform_degree = <NUM_LIT:1><EOL>self.feed_mode = '<STR_LIT>'<EOL>self.step_eta = <NUM_LIT><EOL>self.updates = <NUM_LIT><EOL>self.class_list = []<EOL>self.temp_train_X = []<EOL>self.temp_train_Y = []<EOL>self.temp_W = {}<EOL>self.temp_data_num = <NUM_LIT:0><EOL>self.decomposition = '<STR_LIT>'<EOL>", "docstring": "init", "id": "f10097:c2:m0"}
{"signature": "def init_W(self, mode='<STR_LIT>'):", "body": "if (self.status != '<STR_LIT>') and (self.status != '<STR_LIT:train>'):<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return self.W<EOL><DEDENT>self.status = '<STR_LIT>'<EOL>self.data_num = len(self.train_Y)<EOL>self.data_demension = len(self.train_X[<NUM_LIT:0>])<EOL>self.W = np.zeros(self.data_demension)<EOL>if mode == '<STR_LIT>':<EOL><INDENT>accelerator = linear_regression.Accelerator()<EOL>self.W = accelerator.init_W(self)<EOL><DEDENT>return self.W<EOL>", "docstring": "Init the W\nSimple way is init W all zeros", "id": "f10097:c0:m4"}
{"signature": "def train(self):", "body": "if (self.status != '<STR_LIT>'):<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return self.W<EOL><DEDENT>self.status = '<STR_LIT:train>'<EOL>for i in range(<NUM_LIT:0>, self.updates):<EOL><INDENT>if self.feed_mode == '<STR_LIT>':<EOL><INDENT>stochastic_i = random.randint(<NUM_LIT:0>, self.data_num - <NUM_LIT:1>)<EOL>x = self.train_X[stochastic_i]<EOL>y = self.train_Y[stochastic_i]<EOL>gradient = self.calculate_gradient(x, y, self.W)<EOL><DEDENT>else:<EOL><INDENT>gradient = self.calculate_gradient(self.train_X, self.train_Y, self.W)<EOL><DEDENT>if np.linalg.norm(gradient) == <NUM_LIT:0>:<EOL><INDENT>return self.W<EOL><DEDENT>self.W = self.W - self.step_eta * gradient<EOL><DEDENT>return self.W<EOL>", "docstring": "Train Linear Regression Algorithm\nFrom f(x) = WX\nFind best h(x) = WX similar to f(x)\nOutput W\n\nmode: batch / stochastic", "id": "f10097:c0:m11"}
{"signature": "def __init__(self):", "body": "self.status = '<STR_LIT>'<EOL>self.train_X = []<EOL>self.train_Y = []<EOL>self.W = []<EOL>self.data_num = <NUM_LIT:0><EOL>self.data_demension = <NUM_LIT:0><EOL>self.test_X = []<EOL>self.test_Y = []<EOL>self.feature_transform_mode = '<STR_LIT>'<EOL>self.feature_transform_degree = <NUM_LIT:1><EOL>self.feed_mode = '<STR_LIT>'<EOL>self.step_eta = <NUM_LIT><EOL>self.updates = <NUM_LIT><EOL>", "docstring": "init", "id": "f10097:c0:m0"}
{"signature": "def __init__(self):", "body": "self.status = '<STR_LIT>'<EOL>self.train_X = []<EOL>self.train_Y = []<EOL>self.W = []<EOL>self.data_num = <NUM_LIT:0><EOL>self.data_demension = <NUM_LIT:0><EOL>self.test_X = []<EOL>self.test_Y = []<EOL>self.feature_transform_mode = '<STR_LIT>'<EOL>self.feature_transform_degree = <NUM_LIT:1><EOL>self.lambda_p = <NUM_LIT><EOL>self.svm_kernel = '<STR_LIT>'<EOL>self.zeta = <NUM_LIT:0><EOL>self.gamma = <NUM_LIT:1><EOL>self.Q = <NUM_LIT:1><EOL>self.C = <NUM_LIT:0.1><EOL>self.beta = []<EOL>self.class_list = []<EOL>self.classifier_list = {}<EOL>self.decomposition = '<STR_LIT>'<EOL>", "docstring": "init", "id": "f10098:c2:m0"}
{"signature": "def score_function(self, x, W):<EOL>", "body": "score = np.inner(x, W)<EOL>return score<EOL>", "docstring": "Score function to calculate score", "id": "f10102:c0:m4"}
{"signature": "def error_function(self, y_prediction, y_truth):<EOL>", "body": "error = (y_prediction - y_truth) ** <NUM_LIT:2><EOL>return error<EOL>", "docstring": "Error function to calculate error", "id": "f10102:c0:m5"}
{"signature": "def init_W(self, mode='<STR_LIT>'):", "body": "if (self.status != '<STR_LIT>') and (self.status != '<STR_LIT:train>'):<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return self.W<EOL><DEDENT>self.status = '<STR_LIT>'<EOL>self.data_num = len(self.train_Y)<EOL>self.data_demension = len(self.train_X[<NUM_LIT:0>])<EOL>self.W = np.zeros(self.data_demension)<EOL>if (self.svm_kernel != '<STR_LIT>' and self.svm_kernel != '<STR_LIT>'):<EOL><INDENT>if mode == '<STR_LIT>':<EOL><INDENT>accelerator = linear_regression.Accelerator()<EOL>self.W = accelerator.init_W(self)<EOL><DEDENT><DEDENT>return self.W<EOL>", "docstring": "Init the W\nSimple way is init W all zeros", "id": "f10103:c0:m4"}
{"signature": "def init_W(self, mode='<STR_LIT>'):", "body": "if (self.status != '<STR_LIT>') and (self.status != '<STR_LIT:train>'):<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return self.W<EOL><DEDENT>self.status = '<STR_LIT>'<EOL>self.data_num = len(self.train_Y)<EOL>self.data_demension = len(self.train_X[<NUM_LIT:0>])<EOL>self.W = np.zeros(self.data_demension)<EOL>if mode == '<STR_LIT>':<EOL><INDENT>accelerator = linear_regression.Accelerator()<EOL>self.W = accelerator.init_W(self)<EOL><DEDENT>return self.W<EOL>", "docstring": "Init the W\nSimple way is init W all zeros", "id": "f10104:c0:m4"}
{"signature": "def train(self):", "body": "if (self.status != '<STR_LIT>'):<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return self.W<EOL><DEDENT>self.status = '<STR_LIT:train>'<EOL>new_W = self.W<EOL>self.temp_avg_error = self.calculate_avg_error(self.train_X, self.train_Y, new_W)<EOL>for _ in range(self.updates):<EOL><INDENT>if (self.loop_mode is '<STR_LIT>'):<EOL><INDENT>data_check_order = range(self.data_num)<EOL><DEDENT>elif (self.loop_mode is '<STR_LIT>'):<EOL><INDENT>data_check_order = range(self.data_num)<EOL>data_check_order = random.sample(data_check_order, self.data_num)<EOL><DEDENT>else:<EOL><INDENT>data_check_order = range(self.data_num)<EOL>data_check_order = random.sample(data_check_order, self.data_num)<EOL><DEDENT>for i in data_check_order:<EOL><INDENT>if self.error_function(self.score_function(self.train_X[i], new_W), self.train_Y[i]):<EOL><INDENT>self.tune_times += <NUM_LIT:1><EOL>new_W = new_W + self.step_alpha * (self.train_Y[i] * self.train_X[i])<EOL>new_avg_error = self.calculate_avg_error(self.train_X, self.train_Y, new_W)<EOL>if new_avg_error < self.temp_avg_error:<EOL><INDENT>self.put_in_pocket_times += <NUM_LIT:1><EOL>self.temp_avg_error = new_avg_error<EOL>self.W = new_W<EOL><DEDENT>break<EOL><DEDENT><DEDENT><DEDENT>return self.W<EOL>", "docstring": "Train Pocket Perceptron Learning Algorithm\nFrom f(x) = WX\nFind best h(x) = WX similar to f(x)\nOutput W", "id": "f10104:c0:m9"}
{"signature": "def score_function(self, x, W):<EOL>", "body": "score = self.sign * np.sign(x[self.feature_index] - self.theta)<EOL>return score<EOL>", "docstring": "Score function to calculate score", "id": "f10108:c0:m5"}
{"signature": "def init_W(self, mode='<STR_LIT>'):", "body": "if (self.status != '<STR_LIT>') and (self.status != '<STR_LIT:train>'):<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return self.W<EOL><DEDENT>self.status = '<STR_LIT>'<EOL>self.data_num = len(self.train_Y)<EOL>self.data_demension = len(self.train_X[<NUM_LIT:0>])<EOL>self.W = np.zeros(self.data_demension)<EOL>if self.u is None:<EOL><INDENT>self.u = np.array([(<NUM_LIT:1.0> / self.data_num)] * self.data_num)<EOL><DEDENT>return self.W<EOL>", "docstring": "Init the W\nSimple way is init W all zeros", "id": "f10108:c0:m4"}
{"signature": "def error_function(self, y_prediction, y_truth):<EOL>", "body": "if y_prediction != y_truth:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>", "docstring": "Error function to calculate error", "id": "f10108:c0:m6"}
{"signature": "def AsyncMock(*args, **kwargs):", "body": "m = mock.MagicMock(*args, **kwargs)<EOL>async def mock_coro(*args, **kwargs):<EOL><INDENT>return m(*args, **kwargs)<EOL><DEDENT>mock_coro.mock = m<EOL>return mock_coro<EOL>", "docstring": "Create an async function mock.", "id": "f10114:m0"}
{"signature": "def AsyncMock(*args, **kwargs):", "body": "m = mock.MagicMock(*args, **kwargs)<EOL>async def mock_coro(*args, **kwargs):<EOL><INDENT>return m(*args, **kwargs)<EOL><DEDENT>mock_coro.mock = m<EOL>return mock_coro<EOL>", "docstring": "Create an async function mock.", "id": "f10116:m0"}
{"signature": "@property<EOL><INDENT>def df(self):<DEDENT>", "body": "if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>dfs = []<EOL>for symbol, bars in self.items():<EOL><INDENT>df = bars.df.copy()<EOL>df.columns = pd.MultiIndex.from_product(<EOL>[[symbol, ], df.columns])<EOL>dfs.append(df)<EOL><DEDENT>if len(dfs) == <NUM_LIT:0>:<EOL><INDENT>self._df = pd.DataFrame()<EOL><DEDENT>else:<EOL><INDENT>self._df = pd.concat(dfs, axis=<NUM_LIT:1>)<EOL><DEDENT><DEDENT>return self._df<EOL>", "docstring": "Experimental", "id": "f10117:c7:m1"}
{"signature": "def get_position(self, symbol):", "body": "resp = self.get('<STR_LIT>'.format(symbol))<EOL>return Position(resp)<EOL>", "docstring": "Get an open position", "id": "f10118:c2:m14"}
{"signature": "def list_positions(self):", "body": "resp = self.get('<STR_LIT>')<EOL>return [Position(o) for o in resp]<EOL>", "docstring": "Get a list of open positions", "id": "f10118:c2:m13"}
{"signature": "def list_assets(self, status=None, asset_class=None):", "body": "params = {<EOL>'<STR_LIT:status>': status,<EOL>'<STR_LIT>': asset_class,<EOL>}<EOL>resp = self.get('<STR_LIT>', params)<EOL>return [Asset(o) for o in resp]<EOL>", "docstring": "Get a list of assets", "id": "f10118:c2:m15"}
{"signature": "def get_asset(self, symbol):", "body": "resp = self.get('<STR_LIT>'.format(symbol))<EOL>return Asset(resp)<EOL>", "docstring": "Get an asset", "id": "f10118:c2:m16"}
{"signature": "def get_barset(self,<EOL>symbols,<EOL>timeframe,<EOL>limit=None,<EOL>start=None,<EOL>end=None,<EOL>after=None,<EOL>until=None):", "body": "if not isinstance(symbols, str):<EOL><INDENT>symbols = '<STR_LIT:U+002C>'.join(symbols)<EOL><DEDENT>params = {<EOL>'<STR_LIT>': symbols,<EOL>}<EOL>if limit is not None:<EOL><INDENT>params['<STR_LIT>'] = limit<EOL><DEDENT>if start is not None:<EOL><INDENT>params['<STR_LIT:start>'] = start<EOL><DEDENT>if end is not None:<EOL><INDENT>params['<STR_LIT:end>'] = end<EOL><DEDENT>if after is not None:<EOL><INDENT>params['<STR_LIT>'] = after<EOL><DEDENT>if until is not None:<EOL><INDENT>params['<STR_LIT>'] = until<EOL><DEDENT>resp = self.data_get('<STR_LIT>'.format(timeframe), params)<EOL>return BarSet(resp)<EOL>", "docstring": "Get BarSet(dict[str]->list[Bar])\n        The parameter symbols can be either a comma-split string\n        or a list of string. Each symbol becomes the key of\n        the returned value.", "id": "f10118:c2:m17"}
{"signature": "async def subscribe(self, channels):", "body": "ws_channels = []<EOL>nats_channels = []<EOL>for c in channels:<EOL><INDENT>if c.startswith(('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',)):<EOL><INDENT>nats_channels.append(c)<EOL><DEDENT>else:<EOL><INDENT>ws_channels.append(c)<EOL><DEDENT><DEDENT>if len(ws_channels) > <NUM_LIT:0>:<EOL><INDENT>await self._ensure_ws()<EOL>await self._ws.send(json.dumps({<EOL>'<STR_LIT:action>': '<STR_LIT>',<EOL>'<STR_LIT:data>': {<EOL>'<STR_LIT>': ws_channels,<EOL>}<EOL>}))<EOL><DEDENT>if len(nats_channels) > <NUM_LIT:0>:<EOL><INDENT>await self._ensure_nats()<EOL>await self.polygon.subscribe(nats_channels)<EOL><DEDENT>", "docstring": "Start subscribing channels.\n        If the necessary connection isn't open yet, it opens now.", "id": "f10127:c0:m5"}
{"signature": "def run(self, initial_channels=[]):", "body": "loop = asyncio.get_event_loop()<EOL>try:<EOL><INDENT>loop.run_until_complete(self.subscribe(initial_channels))<EOL>loop.run_forever()<EOL><DEDENT>finally:<EOL><INDENT>loop.run_until_complete(self.close())<EOL><DEDENT>", "docstring": "Run forever and block until exception is rasised.\n        initial_channels is the channels to start with.", "id": "f10127:c0:m6"}
{"signature": "def check_output(self, cmd):", "body": "ret, output = self._exec(cmd)<EOL>if not ret == <NUM_LIT:0>:<EOL><INDENT>raise CommandError(self)<EOL><DEDENT>return output<EOL>", "docstring": "Wrapper for subprocess.check_output.", "id": "f10130:c1:m8"}
{"signature": "@property<EOL><INDENT>def last_output(self):<DEDENT>", "body": "if not len(self.log):<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>return self.log[-<NUM_LIT:1>][<NUM_LIT:2>]<EOL>", "docstring": "Get the output of the last command exevuted.", "id": "f10130:c1:m3"}
{"signature": "def call(self, cmd):", "body": "ret, _ = self._exec(cmd)<EOL>return ret<EOL>", "docstring": "Fake the interface of subprocess.call().", "id": "f10130:c1:m10"}
{"signature": "@staticmethod<EOL><INDENT>def unpack_pargs(positional_args, param_kwargs, gnu=False):<DEDENT>", "body": "def _transform(argname):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if len(argname) == <NUM_LIT:1>:<EOL><INDENT>return '<STR_LIT>'.format(argname)<EOL><DEDENT>return '<STR_LIT>'.format(argname.replace('<STR_LIT:_>', '<STR_LIT:->'))<EOL><DEDENT>args = []<EOL>for item in param_kwargs.keys():<EOL><INDENT>for value in param_kwargs.getlist(item):<EOL><INDENT>if gnu:<EOL><INDENT>args.append('<STR_LIT>'.format(<EOL>_transform(item),<EOL>value<EOL>))<EOL><DEDENT>else:<EOL><INDENT>args.extend([<EOL>_transform(item),<EOL>value<EOL>])<EOL><DEDENT><DEDENT><DEDENT>if positional_args: <EOL><INDENT>for item in positional_args:    <EOL><INDENT>args.append(_transform(item))<EOL><DEDENT><DEDENT>return args<EOL>", "docstring": "Unpack multidict and positional args into a\n        list appropriate for subprocess.\n        :param param_kwargs: \n            ``ParamDict`` storing '--param' style data.\n        :param positional_args: flags\n        :param gnu: \n            if True, long-name args are unpacked as:\n                --parameter=argument\n            otherwise, they are unpacked as:\n                --parameter argument\n        :returns: list appropriate for sending to subprocess", "id": "f10130:c1:m12"}
{"signature": "def check_call(self, cmd):", "body": "ret, _ = self._exec(cmd)<EOL>if not ret == <NUM_LIT:0>:<EOL><INDENT>raise CommandError(self)<EOL><DEDENT>return ret<EOL>", "docstring": "Fake the interface of subprocess.call().", "id": "f10130:c1:m9"}
{"signature": "@property<EOL><INDENT>def last_returncode(self):<DEDENT>", "body": "try:<EOL><INDENT>return self.log[-<NUM_LIT:1>][<NUM_LIT:1>]<EOL><DEDENT>except IndexError:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Get the return code of the last command exevuted.", "id": "f10130:c1:m1"}
{"signature": "@property<EOL><INDENT>def output(self):<DEDENT>", "body": "return '<STR_LIT:\\n>'.join(['<STR_LIT:\\n>'.join(l[<NUM_LIT:2>]) for l in self.log])<EOL>", "docstring": "Get the output of the entire session.", "id": "f10130:c1:m5"}
{"signature": "def get_profiler_statistics(sort=\"<STR_LIT>\", count=<NUM_LIT:20>, strip_dirs=True):", "body": "json_stats = []<EOL>pstats = yappi.convert2pstats(yappi.get_func_stats())<EOL>if strip_dirs:<EOL><INDENT>pstats.strip_dirs()<EOL><DEDENT>for func, func_stat in pstats.stats.iteritems():<EOL><INDENT>path, line, func_name = func<EOL>cc, num_calls, total_time, cum_time, callers = func_stat<EOL>json_stats.append({<EOL>\"<STR_LIT:path>\": path,<EOL>\"<STR_LIT>\": line,<EOL>\"<STR_LIT>\": func_name,<EOL>\"<STR_LIT>\": num_calls,<EOL>\"<STR_LIT>\": total_time,<EOL>\"<STR_LIT>\": total_time/num_calls if total_time else <NUM_LIT:0>,<EOL>\"<STR_LIT>\": cum_time,<EOL>\"<STR_LIT>\": cum_time/num_calls if cum_time else <NUM_LIT:0><EOL>})<EOL><DEDENT>return sorted(json_stats, key=itemgetter(sort), reverse=True)[:count]<EOL>", "docstring": "Return profiler statistics.\n\n    :param str sort: dictionary key to sort by\n    :param int|None count: the number of results to return, None returns all results.\n    :param bool strip_dirs: if True strip the directory, otherwise return the full path", "id": "f10138:m4"}
{"signature": "def get(self):", "body": "sort = self.get_argument('<STR_LIT>', '<STR_LIT>')<EOL>count = self.get_argument('<STR_LIT:count>', <NUM_LIT:20>)<EOL>strip_dirs = self.get_argument('<STR_LIT>', True)<EOL>error = '<STR_LIT>'<EOL>sorts = ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>')<EOL>if sort not in sorts:<EOL><INDENT>error += \"<STR_LIT>\" % (sort, sorts)<EOL><DEDENT>try:<EOL><INDENT>count = int(count)<EOL><DEDENT>except (ValueError, TypeError):<EOL><INDENT>error += \"<STR_LIT>\" % count<EOL><DEDENT>if count <= <NUM_LIT:0>:<EOL><INDENT>count = None<EOL><DEDENT>strip_dirs = str(strip_dirs).lower() not in ('<STR_LIT:false>', '<STR_LIT>', '<STR_LIT:none>',<EOL>'<STR_LIT:null>', '<STR_LIT:0>', '<STR_LIT>')<EOL>if error:<EOL><INDENT>self.write({'<STR_LIT:error>': error})<EOL>self.set_status(<NUM_LIT>)<EOL>self.finish()<EOL>return<EOL><DEDENT>try:<EOL><INDENT>statistics = get_profiler_statistics(sort, count, strip_dirs)<EOL>self.write({'<STR_LIT>': statistics})<EOL>self.set_status(<NUM_LIT:200>)<EOL><DEDENT>except TypeError:<EOL><INDENT>logger.exception('<STR_LIT>')<EOL>self.write({'<STR_LIT:error>': '<STR_LIT>'})<EOL>self.set_status(<NUM_LIT>)<EOL><DEDENT>self.finish()<EOL>", "docstring": "Return current profiler statistics.", "id": "f10138:c0:m1"}
{"signature": "def delete(self):", "body": "CProfileWrapper.profiler.disable()<EOL>self.running = False<EOL>self.set_status(<NUM_LIT>)<EOL>self.finish()<EOL>", "docstring": "Stop the profiler.", "id": "f10138:c5:m2"}
{"signature": "def start_profiling():", "body": "<EOL>yappi.start(builtins=False, profile_threads=False)<EOL>", "docstring": "Start profiler.", "id": "f10138:m0"}
{"signature": "def get(self):", "body": "self.write({\"<STR_LIT>\": self.running})<EOL>self.set_status(<NUM_LIT:200>)<EOL>self.finish()<EOL>", "docstring": "Check if the profiler is running.", "id": "f10138:c5:m3"}
{"signature": "def create_call_kwargs(self):", "body": "return {<EOL>'<STR_LIT>': self.bucket,<EOL>'<STR_LIT:key>': self.key,<EOL>}<EOL>", "docstring": "The kwargs to be passed to the transfer manager method", "id": "f10144:c0:m2"}
{"signature": "def full_path(self, filename):", "body": "return os.path.join(self.rootdir, filename)<EOL>", "docstring": "Translate relative path to full path in temp dir.\n        f.full_path('foo/bar.txt') -> /tmp/asdfasd/foo/bar.txt", "id": "f10166:c0:m5"}
{"signature": "def create_file(self, filename, contents, mode='<STR_LIT:w>'):", "body": "full_path = os.path.join(self.rootdir, filename)<EOL>if not os.path.isdir(os.path.dirname(full_path)):<EOL><INDENT>os.makedirs(os.path.dirname(full_path))<EOL><DEDENT>with open(full_path, mode) as f:<EOL><INDENT>f.write(contents)<EOL><DEDENT>return full_path<EOL>", "docstring": "Creates a file in a tmpdir\n        ``filename`` should be a relative path, e.g. \"foo/bar/baz.txt\"\n        It will be translated into a full path in a tmp dir.\n        ``mode`` is the mode the file should be opened either as ``w`` or\n        `wb``.\n        Returns the full path to the file.", "id": "f10166:c0:m2"}
{"signature": "def create_file(self, filename, contents, mode='<STR_LIT:w>'):", "body": "full_path = os.path.join(self.rootdir, filename)<EOL>if not os.path.isdir(os.path.dirname(full_path)):<EOL><INDENT>os.makedirs(os.path.dirname(full_path))<EOL><DEDENT>with open(full_path, mode) as f:<EOL><INDENT>f.write(contents)<EOL><DEDENT>return full_path<EOL>", "docstring": "Creates a file in a tmpdir\n        ``filename`` should be a relative path, e.g. \"foo/bar/baz.txt\"\n        It will be translated into a full path in a tmp dir.\n        ``mode`` is the mode the file should be opened either as ``w`` or\n        `wb``.\n        Returns the full path to the file.", "id": "f10169:c2:m2"}
{"signature": "def skip_if_using_serial_implementation(reason):", "body": "def decorator(func):<EOL><INDENT>return unittest.skipIf(<EOL>is_serial_implementation(), reason)(func)<EOL><DEDENT>return decorator<EOL>", "docstring": "Decorator to skip tests when running as the serial implementation", "id": "f10169:m7"}
{"signature": "def create_invalid_extra_args(self):", "body": "raise NotImplementedError(<EOL>'<STR_LIT>')<EOL>", "docstring": "A value for extra_args that will cause validation errors", "id": "f10169:c10:m3"}
{"signature": "def manager(self):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "The transfer manager to use", "id": "f10169:c10:m0"}
{"signature": "def skip_if_windows(reason):", "body": "def decorator(func):<EOL><INDENT>return unittest.skipIf(<EOL>platform.system() not in ['<STR_LIT>', '<STR_LIT>'], reason)(func)<EOL><DEDENT>return decorator<EOL>", "docstring": "Decorator to skip tests that should not be run on windows.\n\n    Example usage:\n\n        @skip_if_windows(\"Not valid\")\n        def test_some_non_windows_stuff(self):\n            self.assertEqual(...)", "id": "f10169:m6"}
{"signature": "def create_expected_progress_callback_info(self):", "body": "raise NotImplementedError(<EOL>'<STR_LIT>')<EOL>", "docstring": "A list of kwargs expected to be passed to each progress callback\n\n        Note that the future kwargs does not need to be added to each\n        dictionary provided in the list. This is injected for you. An example\n        is::\n\n            [\n                {'bytes_transferred': 4},\n                {'bytes_transferred': 4},\n                {'bytes_transferred': 2}\n            ]\n\n        This indicates that the progress callback will be called three\n        times and pass along the specified keyword arguments and corresponding\n        values.", "id": "f10169:c10:m5"}
{"signature": "def create_call_kwargs(self):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "The kwargs to be passed to the transfer manager method", "id": "f10169:c10:m2"}
{"signature": "def signal_transferring(self):", "body": "self.enable_bandwidth_limiting()<EOL>", "docstring": "Signal that data being read is being transferred to S3", "id": "f10170:c4:m5"}
{"signature": "def record_consumption_rate(self, amt, time_at_consumption):", "body": "if self._last_time is None:<EOL><INDENT>self._last_time = time_at_consumption<EOL>self._current_rate = <NUM_LIT:0.0><EOL>return<EOL><DEDENT>self._current_rate = self._calculate_exponential_moving_average_rate(<EOL>amt, time_at_consumption)<EOL>self._last_time = time_at_consumption<EOL>", "docstring": "Record the consumption rate based off amount and time point\n\n        :type amt: int\n        :param amt: The amount that got consumed\n\n        :type time_at_consumption: float\n        :param time_at_consumption: The time at which the amount was consumed", "id": "f10170:c7:m3"}
{"signature": "def read(self, amount):", "body": "if not self._bandwidth_limiting_enabled:<EOL><INDENT>return self._fileobj.read(amount)<EOL><DEDENT>self._bytes_seen += amount<EOL>if self._bytes_seen < self._bytes_threshold:<EOL><INDENT>return self._fileobj.read(amount)<EOL><DEDENT>self._consume_through_leaky_bucket()<EOL>return self._fileobj.read(amount)<EOL>", "docstring": "Read a specified amount\n\n        Reads will only be throttled if bandwidth limiting is enabled.", "id": "f10170:c4:m3"}
{"signature": "def disable_bandwidth_limiting(self):", "body": "self._bandwidth_limiting_enabled = False<EOL>", "docstring": "Disable bandwidth limiting on reads to the stream", "id": "f10170:c4:m2"}
{"signature": "@classmethod<EOL><INDENT>def is_compatible(cls, upload_source):<DEDENT>", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Determines if the source for the upload is compatible with manager\n\n        :param upload_source: The source for which the upload will pull data\n            from.\n\n        :returns: True if the manager can handle the type of source specified\n            otherwise returns False.", "id": "f10171:c2:m1"}
{"signature": "def __init__(self, callbacks, threshold=<NUM_LIT> * <NUM_LIT>):", "body": "self._callbacks = callbacks<EOL>self._threshold = threshold<EOL>self._bytes_seen = <NUM_LIT:0><EOL>", "docstring": "Aggregates progress updates for every provided progress callback\n\n        :type callbacks: A list of functions that accepts bytes_transferred\n            as a single argument\n        :param callbacks: The callbacks to invoke when threshold is reached\n\n        :type threshold: int\n        :param threshold: The progress threshold in which to take the\n            aggregated progress and invoke the progress callback with that\n            aggregated progress total", "id": "f10171:c0:m0"}
{"signature": "def yield_upload_part_bodies(self, transfer_future, chunksize):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Yields the part number and body to use for each UploadPart\n\n        :type transfer_future: s3transfer.futures.TransferFuture\n        :param transfer_future: The future associated with upload request\n\n        :type chunksize: int\n        :param chunksize: The chunksize to use for this upload.\n\n        :rtype: int, s3transfer.utils.ReadFileChunk\n        :returns: Yields the part number and the ReadFileChunk including all\n            progress callbacks associated with the transfer future for that\n            specific yielded part.", "id": "f10171:c2:m6"}
{"signature": "def wait(self):", "body": "try:<EOL><INDENT>transfer_coordinator = None<EOL>for transfer_coordinator in self.tracked_transfer_coordinators:<EOL><INDENT>transfer_coordinator.result()<EOL><DEDENT><DEDENT>except KeyboardInterrupt:<EOL><INDENT>logger.debug('<STR_LIT>')<EOL>if transfer_coordinator:<EOL><INDENT>logger.debug(<EOL>'<STR_LIT>',<EOL>transfer_coordinator)<EOL><DEDENT>raise<EOL><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Wait until there are no more inprogress transfers\n\n        This will not stop when failures are encountered and not propogate any\n        of these errors from failed transfers, but it can be interrupted with\n        a KeyboardInterrupt.", "id": "f10172:c2:m5"}
{"signature": "def add_transfer_coordinator(self, transfer_coordinator):", "body": "with self._lock:<EOL><INDENT>self._tracked_transfer_coordinators.add(transfer_coordinator)<EOL><DEDENT>", "docstring": "Adds a transfer coordinator of a transfer to be canceled if needed\n\n        :type transfer_coordinator: s3transfer.futures.TransferCoordinator\n        :param transfer_coordinator: The transfer coordinator for the\n            particular transfer", "id": "f10172:c2:m2"}
{"signature": "def request_writes(self, offset, data):", "body": "if offset < self._next_offset:<EOL><INDENT>return []<EOL><DEDENT>writes = []<EOL>if offset in self._pending_offsets:<EOL><INDENT>return []<EOL><DEDENT>heapq.heappush(self._writes, (offset, data))<EOL>self._pending_offsets.add(offset)<EOL>while self._writes and self._writes[<NUM_LIT:0>][<NUM_LIT:0>] == self._next_offset:<EOL><INDENT>next_write = heapq.heappop(self._writes)<EOL>writes.append({'<STR_LIT>': next_write[<NUM_LIT:0>], '<STR_LIT:data>': next_write[<NUM_LIT:1>]})<EOL>self._pending_offsets.remove(next_write[<NUM_LIT:0>])<EOL>self._next_offset += len(next_write[<NUM_LIT:1>])<EOL><DEDENT>return writes<EOL>", "docstring": "Request any available writes given new incoming data.\n\n        You call this method by providing new data along with the\n        offset associated with the data.  If that new data unlocks\n        any contiguous writes that can now be submitted, this\n        method will return all applicable writes.\n\n        This is done with 1 method call so you don't have to\n        make two method calls (put(), get()) which acquires a lock\n        each method call.", "id": "f10173:c14:m1"}
{"signature": "def queue_file_io_task(self, fileobj, data, offset):", "body": "self._transfer_coordinator.submit(<EOL>self._io_executor,<EOL>self.get_io_write_task(fileobj, data, offset)<EOL>)<EOL>", "docstring": "Queue IO write for submission to the IO executor.\n\n        This method accepts an IO executor and information about the\n        downloaded data, and handles submitting this to the IO executor.\n\n        This method may defer submission to the IO executor if necessary.", "id": "f10173:c0:m4"}
{"signature": "def get_download_task_tag(self):", "body": "return None<EOL>", "docstring": "Get the tag (if any) to associate all GetObjectTasks\n\n        :rtype: s3transfer.futures.TaskTag\n        :returns: The tag to associate all GetObjectTasks with", "id": "f10173:c0:m2"}
{"signature": "def _submit(self, client, config, osutil, request_executor, io_executor,<EOL>transfer_future, bandwidth_limiter=None):", "body": "if transfer_future.meta.size is None:<EOL><INDENT>response = client.head_object(<EOL>Bucket=transfer_future.meta.call_args.bucket,<EOL>Key=transfer_future.meta.call_args.key,<EOL>**transfer_future.meta.call_args.extra_args<EOL>)<EOL>transfer_future.meta.provide_transfer_size(<EOL>response['<STR_LIT>'])<EOL><DEDENT>download_output_manager = self._get_download_output_manager_cls(<EOL>transfer_future, osutil)(osutil, self._transfer_coordinator,<EOL>io_executor)<EOL>if transfer_future.meta.size < config.multipart_threshold:<EOL><INDENT>self._submit_download_request(<EOL>client, config, osutil, request_executor, io_executor,<EOL>download_output_manager, transfer_future, bandwidth_limiter)<EOL><DEDENT>else:<EOL><INDENT>self._submit_ranged_download_request(<EOL>client, config, osutil, request_executor, io_executor,<EOL>download_output_manager, transfer_future, bandwidth_limiter)<EOL><DEDENT>", "docstring": ":param client: The client associated with the transfer manager\n\n:type config: s3transfer.manager.TransferConfig\n:param config: The transfer config associated with the transfer\n    manager\n\n:type osutil: s3transfer.utils.OSUtil\n:param osutil: The os utility associated to the transfer manager\n\n:type request_executor: s3transfer.futures.BoundedExecutor\n:param request_executor: The request executor associated with the\n    transfer manager\n\n:type io_executor: s3transfer.futures.BoundedExecutor\n:param io_executor: The io executor associated with the\n    transfer manager\n\n:type transfer_future: s3transfer.futures.TransferFuture\n:param transfer_future: The transfer future associated with the\n    transfer request that tasks are being submitted for\n\n:type bandwidth_limiter: s3transfer.bandwidth.BandwidthLimiter\n:param bandwidth_limiter: The bandwidth limiter to use when\n    downloading streams", "id": "f10173:c5:m1"}
{"signature": "def _main(self, client, copy_source, bucket, key, upload_id, part_number,<EOL>extra_args, callbacks, size):", "body": "response = client.upload_part_copy(<EOL>CopySource=copy_source, Bucket=bucket, Key=key,<EOL>UploadId=upload_id, PartNumber=part_number, **extra_args)<EOL>for callback in callbacks:<EOL><INDENT>callback(bytes_transferred=size)<EOL><DEDENT>etag = response['<STR_LIT>']['<STR_LIT>']<EOL>return {'<STR_LIT>': etag, '<STR_LIT>': part_number}<EOL>", "docstring": ":param client: The client to use when calling PutObject\n:param copy_source: The CopySource parameter to use\n:param bucket: The name of the bucket to upload to\n:param key: The name of the key to upload to\n:param upload_id: The id of the upload\n:param part_number: The number representing the part of the multipart\n    upload\n:param extra_args: A dictionary of any extra arguments that may be\n    used in the upload.\n:param callbacks: List of callbacks to call after copy part\n:param size: The size of the transfer. This value is passed into\n    the callbacks\n\n:rtype: dict\n:returns: A dictionary representing a part::\n\n    {'Etag': etag_value, 'PartNumber': part_number}\n\n    This value can be appended to a list to be used to complete\n    the multipart upload.", "id": "f10174:c2:m0"}
{"signature": "def on_done(self, future, **kwargs):", "body": "pass<EOL>", "docstring": "Callback to be invoked once a transfer is done\n\n        This callback can be useful for:\n\n            * Recording and displaying whether the transfer succeeded or\n              failed using future.result()\n            * Running some task after the transfer completed like changing\n              the last modified time of a downloaded file.\n\n        :type future: s3transfer.futures.TransferFuture\n        :param future: The TransferFuture representing the requested transfer.", "id": "f10175:c0:m4"}
{"signature": "def _main(self, transfer_future, **kwargs):", "body": "try:<EOL><INDENT>self._transfer_coordinator.set_status_to_queued()<EOL>on_queued_callbacks = get_callbacks(transfer_future, '<STR_LIT>')<EOL>for on_queued_callback in on_queued_callbacks:<EOL><INDENT>on_queued_callback()<EOL><DEDENT>self._transfer_coordinator.set_status_to_running()<EOL>self._submit(transfer_future=transfer_future, **kwargs)<EOL><DEDENT>except BaseException as e:<EOL><INDENT>self._log_and_set_exception(e)<EOL>self._wait_for_all_submitted_futures_to_complete()<EOL>self._transfer_coordinator.announce_done()<EOL><DEDENT>", "docstring": ":type transfer_future: s3transfer.futures.TransferFuture\n:param transfer_future: The transfer future associated with the\n    transfer request that tasks are being submitted for\n\n:param kwargs: Any additional kwargs that you may want to pass\n    to the _submit() method", "id": "f10179:c1:m0"}
{"signature": "def _main(self, client, bucket, key, extra_args):", "body": "client.delete_object(Bucket=bucket, Key=key, **extra_args)<EOL>", "docstring": ":param client: The S3 client to use when calling DeleteObject\n\n:type bucket: str\n:param bucket: The name of the bucket.\n\n:type key: str\n:param key: The name of the object to delete.\n\n:type extra_args: dict\n:param extra_args: Extra arguments to pass to the DeleteObject call.", "id": "f10180:c1:m0"}
{"signature": "def invoke_progress_callbacks(callbacks, bytes_transferred):", "body": "<EOL>if bytes_transferred:<EOL><INDENT>for callback in callbacks:<EOL><INDENT>callback(bytes_transferred=bytes_transferred)<EOL><DEDENT><DEDENT>", "docstring": "Calls all progress callbacks\n\n    :param callbacks: A list of progress callbacks to invoke\n    :param bytes_transferred: The number of bytes transferred. This is passed\n        to the callbacks. If no bytes were transferred the callbacks will not\n        be invoked because no progress was achieved. It is also possible\n        to receive a negative amount which comes from retrying a transfer\n        request.", "id": "f10181:m6"}
{"signature": "@classmethod<EOL><INDENT>def from_filename(cls, filename, start_byte, chunk_size, callbacks=None,<EOL>enable_callbacks=True):<DEDENT>", "body": "f = open(filename, '<STR_LIT:rb>')<EOL>f.seek(start_byte)<EOL>file_size = os.fstat(f.fileno()).st_size<EOL>return cls(f, chunk_size, file_size, callbacks, enable_callbacks)<EOL>", "docstring": "Convenience factory function to create from a filename.\n\n        :type start_byte: int\n        :param start_byte: The first byte from which to start reading.\n\n        :type chunk_size: int\n        :param chunk_size: The max chunk size to read.  Trying to read\n            pass the end of the chunk size will behave like you've\n            reached the end of the file.\n\n        :type full_file_size: int\n        :param full_file_size: The entire content length associated\n            with ``fileobj``.\n\n        :type callbacks: function(amount_read)\n        :param callbacks: Called whenever data is read from this object.\n\n        :type enable_callbacks: bool\n        :param enable_callbacks: Indicate whether to invoke callback\n            during read() calls.\n\n        :rtype: ``ReadFileChunk``\n        :return: A new instance of ``ReadFileChunk``", "id": "f10181:c5:m1"}
{"signature": "def get_callbacks(transfer_future, callback_type):", "body": "callbacks = []<EOL>for subscriber in transfer_future.meta.call_args.subscribers:<EOL><INDENT>callback_name = '<STR_LIT>' + callback_type<EOL>if hasattr(subscriber, callback_name):<EOL><INDENT>callbacks.append(<EOL>functools.partial(<EOL>getattr(subscriber, callback_name),<EOL>future=transfer_future<EOL>)<EOL>)<EOL><DEDENT><DEDENT>return callbacks<EOL>", "docstring": "Retrieves callbacks from a subscriber\n\n    :type transfer_future: s3transfer.futures.TransferFuture\n    :param transfer_future: The transfer future the subscriber is associated\n        to.\n\n    :type callback_type: str\n    :param callback_type: The type of callback to retrieve from the subscriber.\n        Valid types include:\n            * 'queued'\n            * 'progress'\n            * 'done'\n\n    :returns: A list of callbacks for the type specified. All callbacks are\n        preinjected with the transfer future.", "id": "f10181:m5"}
{"signature": "def increment(self):", "body": "with self._lock:<EOL><INDENT>if self._is_finalized:<EOL><INDENT>raise RuntimeError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>self._count += <NUM_LIT:1><EOL><DEDENT>", "docstring": "Increment the count by one", "id": "f10181:c2:m2"}
{"signature": "def is_special_file(cls, filename):", "body": "<EOL>if not os.path.exists(filename):<EOL><INDENT>return False<EOL><DEDENT>mode = os.stat(filename).st_mode<EOL>if stat.S_ISCHR(mode):<EOL><INDENT>return True<EOL><DEDENT>if stat.S_ISBLK(mode):<EOL><INDENT>return True<EOL><DEDENT>if stat.S_ISFIFO(mode):<EOL><INDENT>return True<EOL><DEDENT>if stat.S_ISSOCK(mode):<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Checks to see if a file is a special UNIX file.\n\n        It checks if the file is a character special device, block special\n        device, FIFO, or socket.\n\n        :param filename: Name of the file\n\n        :returns: True if the file is a special file. False, if is not.", "id": "f10181:c3:m6"}
{"signature": "def finalize(self):", "body": "with self._lock:<EOL><INDENT>self._is_finalized = True<EOL>if self._count == <NUM_LIT:0>:<EOL><INDENT>self._callback()<EOL><DEDENT><DEDENT>", "docstring": "Finalize the counter\n\n        Once finalized, the counter never be incremented and the callback\n        can be invoked once the count reaches zero", "id": "f10181:c2:m4"}
{"signature": "@property<EOL><INDENT>def transfer_id(self):<DEDENT>", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "The unique id of the transfer", "id": "f10182:c1:m1"}
{"signature": "@property<EOL><INDENT>def failure_cleanups(self):<DEDENT>", "body": "return self._failure_cleanups<EOL>", "docstring": "The list of callbacks to call when the TransferFuture fails", "id": "f10182:c4:m4"}
{"signature": "@property<EOL><INDENT>def user_context(self):<DEDENT>", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "A dictionary that requesters can store data in", "id": "f10182:c1:m2"}
{"signature": "def cancel(self, msg='<STR_LIT>', exc_type=CancelledError):", "body": "with self._lock:<EOL><INDENT>if not self.done():<EOL><INDENT>should_announce_done = False<EOL>logger.debug('<STR_LIT>', self, msg)<EOL>self._exception = exc_type(msg)<EOL>if self._status == '<STR_LIT>':<EOL><INDENT>should_announce_done = True<EOL><DEDENT>self._status = '<STR_LIT>'<EOL>if should_announce_done:<EOL><INDENT>self.announce_done()<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Cancels the TransferFuture\n\n        :param msg: The message to attach to the cancellation\n        :param exc_type: The type of exception to set for the cancellation", "id": "f10182:c4:m9"}
{"signature": "def add_failure_cleanup(self, function, *args, **kwargs):", "body": "with self._failure_cleanups_lock:<EOL><INDENT>self._failure_cleanups.append(<EOL>FunctionContainer(function, *args, **kwargs))<EOL><DEDENT>", "docstring": "Adds a callback to call upon failure", "id": "f10182:c4:m18"}
{"signature": "def add_done_callback(self, fn):", "body": "<EOL>def done_callback(future_passed_to_callback):<EOL><INDENT>return fn()<EOL><DEDENT>self._future.add_done_callback(done_callback)<EOL>", "docstring": "Adds a callback to be completed once future is done\n\n        :parm fn: A callable that takes no arguments. Note that is different\n            than concurrent.futures.Future.add_done_callback that requires\n            a single argument for the future.", "id": "f10182:c6:m2"}
{"signature": "@property<EOL><INDENT>def size(self):<DEDENT>", "body": "return self._size<EOL>", "docstring": "The size of the transfer request if known", "id": "f10182:c3:m3"}
{"signature": "@property<EOL><INDENT>def status(self):<DEDENT>", "body": "return self._status<EOL>", "docstring": "The status of the TransferFuture\n\n        The currently supported states are:\n            * not-started - Has yet to start. If in this state, a transfer\n              can be canceled immediately and nothing will happen.\n            * queued - SubmissionTask is about to submit tasks\n            * running - Is inprogress. In-progress as of now means that\n              the SubmissionTask that runs the transfer is being executed. So\n              there is no guarantee any transfer requests had been made to\n              S3 if this state is reached.\n            * cancelled - Was cancelled\n            * failed - An exception other than CancelledError was thrown\n            * success - No exceptions were thrown and is done.", "id": "f10182:c4:m5"}
{"signature": "def add_done_callback(self, function, *args, **kwargs):", "body": "with self._done_callbacks_lock:<EOL><INDENT>self._done_callbacks.append(<EOL>FunctionContainer(function, *args, **kwargs)<EOL>)<EOL><DEDENT>", "docstring": "Add a done callback to be invoked when transfer is done", "id": "f10182:c4:m17"}
{"signature": "def announce_done(self):", "body": "if self.status != '<STR_LIT:success>':<EOL><INDENT>self._run_failure_cleanups()<EOL><DEDENT>self._done_event.set()<EOL>self._run_done_callbacks()<EOL>", "docstring": "Announce that future is done running and run associated callbacks\n\n        This will run any failure cleanups if the transfer failed if not\n        they have not been run, allows the result() to be unblocked, and will\n        run any done callbacks associated to the TransferFuture if they have\n        not already been ran.", "id": "f10182:c4:m19"}
{"signature": "def set_status_to_queued(self):", "body": "self._transition_to_non_done_state('<STR_LIT>')<EOL>", "docstring": "Sets the TransferFutrue's status to running", "id": "f10182:c4:m10"}
{"signature": "def notify_exception(self, transfer_id, exception):", "body": "<EOL>self._transfer_states[transfer_id].exception = exception<EOL>", "docstring": "Notify an exception was encountered for a transfer\n\n        :param transfer_id: Unique identifier for the transfer\n        :param exception: The exception encountered for that transfer", "id": "f10184:c5:m5"}
{"signature": "def notify_done(self, transfer_id):", "body": "self._transfer_states[transfer_id].set_done()<EOL>", "docstring": "Notify a particular transfer is complete\n\n        :param transfer_id: Unique identifier for the transfer", "id": "f10184:c5:m3"}
{"signature": "def create_client(self):", "body": "return botocore.session.Session().create_client(<EOL>'<STR_LIT>', **self._client_kwargs)<EOL>", "docstring": "Create a botocore S3 client", "id": "f10184:c4:m1"}
{"signature": "def __init__(self,<EOL>multipart_threshold=<NUM_LIT:8> * MB,<EOL>multipart_chunksize=<NUM_LIT:8> * MB,<EOL>max_request_processes=<NUM_LIT:10>):", "body": "self.multipart_threshold = multipart_threshold<EOL>self.multipart_chunksize = multipart_chunksize<EOL>self.max_request_processes = max_request_processes<EOL>", "docstring": "Configuration for the ProcessPoolDownloader\n\n        :param multipart_threshold: The threshold for which ranged downloads\n            occur.\n\n        :param multipart_chunksize: The chunk size of each ranged download.\n\n        :param max_request_processes: The maximum number of processes that\n            will be making S3 API transfer-related requests at a time.", "id": "f10184:c0:m0"}
{"signature": "def notify_job_complete(self, transfer_id):", "body": "return self._transfer_states[transfer_id].decrement_jobs_to_complete()<EOL>", "docstring": "Notify that a single job is completed for a transfer\n\n        :param transfer_id: Unique identifier for the transfer\n        :return: The number of jobs remaining to complete the transfer", "id": "f10184:c5:m9"}
{"signature": "def __init__(self):", "body": "<EOL>self._transfer_states = {}<EOL>self._id_count = <NUM_LIT:0><EOL>self._init_lock = threading.Lock()<EOL>", "docstring": "Monitors transfers for cross-proccess communication\n\n        Notifications can be sent to the monitor and information can be\n        retrieved from the monitor for a particular transfer. This abstraction\n        is ran in a ``multiprocessing.managers.BaseManager`` in order to be\n        shared across processes.", "id": "f10184:c5:m0"}
{"signature": "def __init__(self, client_kwargs=None, config=None):", "body": "if client_kwargs is None:<EOL><INDENT>client_kwargs = {}<EOL><DEDENT>self._client_factory = ClientFactory(client_kwargs)<EOL>self._transfer_config = config<EOL>if config is None:<EOL><INDENT>self._transfer_config = ProcessTransferConfig()<EOL><DEDENT>self._download_request_queue = multiprocessing.Queue(<NUM_LIT:1000>)<EOL>self._worker_queue = multiprocessing.Queue(<NUM_LIT:1000>)<EOL>self._osutil = OSUtils()<EOL>self._started = False<EOL>self._start_lock = threading.Lock()<EOL>self._manager = None<EOL>self._transfer_monitor = None<EOL>self._submitter = None<EOL>self._workers = []<EOL>", "docstring": "Downloads S3 objects using process pools\n\n        :type client_kwargs: dict\n        :param client_kwargs: The keyword arguments to provide when\n            instantiating S3 clients. The arguments must match the keyword\n            arguments provided to the\n            `botocore.session.Session.create_client()` method.\n\n        :type config: ProcessTransferConfig\n        :param config: Configuration for the downloader", "id": "f10184:c1:m0"}
{"signature": "def download_file(self, bucket, key, filename, extra_args=None,<EOL>expected_size=None):", "body": "self._start_if_needed()<EOL>if extra_args is None:<EOL><INDENT>extra_args = {}<EOL><DEDENT>self._validate_all_known_args(extra_args)<EOL>transfer_id = self._transfer_monitor.notify_new_transfer()<EOL>download_file_request = DownloadFileRequest(<EOL>transfer_id=transfer_id, bucket=bucket, key=key,<EOL>filename=filename, extra_args=extra_args,<EOL>expected_size=expected_size,<EOL>)<EOL>logger.debug(<EOL>'<STR_LIT>', download_file_request)<EOL>self._download_request_queue.put(download_file_request)<EOL>call_args = CallArgs(<EOL>bucket=bucket, key=key, filename=filename, extra_args=extra_args,<EOL>expected_size=expected_size)<EOL>future = self._get_transfer_future(transfer_id, call_args)<EOL>return future<EOL>", "docstring": "Downloads the object's contents to a file\n\n        :type bucket: str\n        :param bucket: The name of the bucket to download from\n\n        :type key: str\n        :param key: The name of the key to download from\n\n        :type filename: str\n        :param filename: The name of a file to download to.\n\n        :type extra_args: dict\n        :param extra_args: Extra arguments that may be passed to the\n            client operation\n\n        :type expected_size: int\n        :param expected_size: The expected size in bytes of the download. If\n            provided, the downloader will not call HeadObject to determine the\n            object's size and use the provided value instead. The size is\n            needed to determine whether to do a multipart download.\n\n        :rtype: s3transfer.futures.TransferFuture\n        :returns: Transfer future representing the download", "id": "f10184:c1:m1"}
{"signature": "async def get_token_status(<EOL>self, user_id, channel_id=None, include=None, *, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_token_status.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", user_id, '<STR_LIT:str>')<EOL>if channel_id is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", channel_id, '<STR_LIT:str>')<EOL><DEDENT>if include is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", include, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = await self._client.async_send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": ":param user_id:\n:type user_id: str\n:param channel_id:\n:type channel_id: str\n:param include:\n:type include: str\n:param dict custom_headers: headers that will be added to the request\n:param bool raw: returns the direct response alongside the\n deserialized response\n:param operation_config: :ref:`Operation configuration\n overrides<msrest:optionsforoperations>`.\n:return: list or ClientRawResponse if raw=true\n:rtype: list[~botframework.tokenapi.models.TokenStatus] or\n ~msrest.pipeline.ClientRawResponse\n:raises:\n :class:`ErrorResponseException<botframework.tokenapi.models.ErrorResponseException>`", "id": "f10202:c0:m4"}
{"signature": "async def reply_to_activity(<EOL>self, conversation_id, activity_id, activity, *, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.reply_to_activity.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", conversation_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", activity_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(activity, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = await self._client.async_send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "ReplyToActivity.\n\n        This method allows you to reply to an activity.\n        This is slightly different from SendToConversation().\n        * SendToConversation(conversationId) - will append the activity to the\n        end of the conversation according to the timestamp or semantics of the\n        channel.\n        * ReplyToActivity(conversationId,ActivityId) - adds the activity as a\n        reply to another activity, if the channel supports it. If the channel\n        does not support nested replies, ReplyToActivity falls back to\n        SendToConversation.\n        Use ReplyToActivity when replying to a specific activity in the\n        conversation.\n        Use SendToConversation in all other cases.\n\n        :param conversation_id: Conversation ID\n        :type conversation_id: str\n        :param activity_id: activityId the reply is to (OPTIONAL)\n        :type activity_id: str\n        :param activity: Activity to send\n        :type activity: ~botframework.connector.models.Activity\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ResourceResponse or ClientRawResponse if raw=true\n        :rtype: ~botframework.connector.models.ResourceResponse or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<botframework.connector.models.ErrorResponseException>`", "id": "f10212:c0:m6"}
{"signature": "async def get_activity_members(<EOL>self, conversation_id, activity_id, *, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_activity_members.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", conversation_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", activity_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = await self._client.async_send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "GetActivityMembers.\n\n        Enumerate the members of an activity.\n        This REST API takes a ConversationId and a ActivityId, returning an\n        array of ChannelAccount objects representing the members of the\n        particular activity in the conversation.\n\n        :param conversation_id: Conversation ID\n        :type conversation_id: str\n        :param activity_id: Activity ID\n        :type activity_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype: list[~botframework.connector.models.ChannelAccount] or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<botframework.connector.models.ErrorResponseException>`", "id": "f10212:c0:m11"}
{"signature": "async def delete_conversation_member(<EOL>self, conversation_id, member_id, *, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete_conversation_member.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", conversation_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", member_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = await self._client.async_send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "DeleteConversationMember.\n\n        Deletes a member from a conversation.\n        This REST API takes a ConversationId and a memberId (of type string)\n        and removes that member from the conversation. If that member was the\n        last member\n        of the conversation, the conversation will also be deleted.\n\n        :param conversation_id: Conversation ID\n        :type conversation_id: str\n        :param member_id: ID of the member to delete from this conversation\n        :type member_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<botframework.connector.models.ErrorResponseException>`", "id": "f10212:c0:m10"}
{"signature": "async def get_conversation_paged_members(<EOL>self, conversation_id, page_size=None, continuation_token=None, *, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_conversation_paged_members.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", conversation_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if page_size is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", page_size, '<STR_LIT:int>')<EOL><DEDENT>if continuation_token is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", continuation_token, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = await self._client.async_send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise HttpOperationError(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "GetConversationPagedMembers.\n\n        Enumerate the members of a conversation one page at a time.\n        This REST API takes a ConversationId. Optionally a pageSize and/or\n        continuationToken can be provided. It returns a PagedMembersResult,\n        which contains an array\n        of ChannelAccounts representing the members of the conversation and a\n        continuation token that can be used to get more values.\n        One page of ChannelAccounts records are returned with each call. The\n        number of records in a page may vary between channels and calls. The\n        pageSize parameter can be used as\n        a suggestion. If there are no additional results the response will not\n        contain a continuation token. If there are no members in the\n        conversation the Members will be empty or not present in the response.\n        A response to a request that has a continuation token from a prior\n        request may rarely return members from a previous request.\n\n        :param conversation_id: Conversation ID\n        :type conversation_id: str\n        :param page_size: Suggested page size\n        :type page_size: int\n        :param continuation_token: Continuation Token\n        :type continuation_token: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PagedMembersResult or ClientRawResponse if raw=true\n        :rtype: ~botframework.connector.models.PagedMembersResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`HttpOperationError<msrest.exceptions.HttpOperationError>`", "id": "f10212:c0:m9"}
{"signature": "async def async_send(self, request, headers=None, content=None, **config):", "body": "loop = asyncio.get_event_loop()<EOL>if self.config.keep_alive and self._session is None:<EOL><INDENT>self._session = requests.Session()<EOL><DEDENT>try:<EOL><INDENT>session = self.creds.signed_session(self._session)<EOL><DEDENT>except TypeError:  <EOL><INDENT>session = self.creds.signed_session()<EOL>if self._session is not None:<EOL><INDENT>_LOGGER.warning(<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT>kwargs = self._configure_session(session, **config)<EOL>if headers:<EOL><INDENT>request.headers.update(headers)<EOL><DEDENT>if not kwargs.get('<STR_LIT>'):<EOL><INDENT>request.add_content(content)<EOL><DEDENT>if request.data:<EOL><INDENT>kwargs['<STR_LIT:data>'] = request.data<EOL><DEDENT>kwargs['<STR_LIT>'].update(request.headers)<EOL>response = None<EOL>try:<EOL><INDENT>try:<EOL><INDENT>future = loop.run_in_executor(<EOL>None,<EOL>functools.partial(<EOL>session.request,<EOL>request.method,<EOL>request.url,<EOL>**kwargs<EOL>)<EOL>)<EOL>return await future<EOL><DEDENT>except (oauth2.rfc6749.errors.InvalidGrantError,<EOL>oauth2.rfc6749.errors.TokenExpiredError) as err:<EOL><INDENT>error = \"<STR_LIT>\"<EOL>_LOGGER.warning(error)<EOL><DEDENT>try:<EOL><INDENT>session = self.creds.refresh_session()<EOL>kwargs = self._configure_session(session)<EOL>if request.data:<EOL><INDENT>kwargs['<STR_LIT:data>'] = request.data<EOL><DEDENT>kwargs['<STR_LIT>'].update(request.headers)<EOL>future = loop.run_in_executor(<EOL>None,<EOL>functools.partial(<EOL>session.request,<EOL>request.method,<EOL>request.url,<EOL>**kwargs<EOL>)<EOL>)<EOL>return await future<EOL><DEDENT>except (oauth2.rfc6749.errors.InvalidGrantError,<EOL>oauth2.rfc6749.errors.TokenExpiredError) as err:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise_with_traceback(TokenExpiredError, msg, err)<EOL><DEDENT><DEDENT>except (requests.RequestException,<EOL>oauth2.rfc6749.errors.OAuth2Error) as err:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise_with_traceback(ClientRequestError, msg, err)<EOL><DEDENT>finally:<EOL><INDENT>self._close_local_session_if_necessary(response, session, kwargs['<STR_LIT>'])<EOL><DEDENT>", "docstring": "Prepare and send request object according to configuration.\n        :param ClientRequest request: The request object to be sent.\n        :param dict headers: Any headers to add to the request.\n        :param content: Any body data to add to the request.\n        :param config: Any specific config overrides", "id": "f10218:c0:m1"}
{"signature": "def get_attachment_info(<EOL>self, attachment_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_attachment_info.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", attachment_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "GetAttachmentInfo.\n\n        Get AttachmentInfo structure describing the attachment views.\n\n        :param attachment_id: attachment id\n        :type attachment_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: AttachmentInfo or ClientRawResponse if raw=true\n        :rtype: ~botframework.connector.models.AttachmentInfo or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<botframework.connector.models.ErrorResponseException>`", "id": "f10219:c0:m1"}
{"signature": "def delete_activity(<EOL>self, conversation_id, activity_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete_activity.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", conversation_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", activity_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "DeleteActivity.\n\n        Delete an existing activity.\n        Some channels allow you to delete an existing activity, and if\n        successful this method will remove the specified activity.\n\n        :param conversation_id: Conversation ID\n        :type conversation_id: str\n        :param activity_id: activityId to delete\n        :type activity_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<botframework.connector.models.ErrorResponseException>`", "id": "f10220:c0:m7"}
{"signature": "def delete_conversation_member(<EOL>self, conversation_id, member_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete_conversation_member.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", conversation_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", member_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "DeleteConversationMember.\n\n        Deletes a member from a conversation.\n        This REST API takes a ConversationId and a memberId (of type string)\n        and removes that member from the conversation. If that member was the\n        last member\n        of the conversation, the conversation will also be deleted.\n\n        :param conversation_id: Conversation ID\n        :type conversation_id: str\n        :param member_id: ID of the member to delete from this conversation\n        :type member_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<botframework.connector.models.ErrorResponseException>`", "id": "f10220:c0:m10"}
{"signature": "def upload_attachment(<EOL>self, conversation_id, attachment_upload, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.upload_attachment.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", conversation_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(attachment_upload, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "UploadAttachment.\n\n        Upload an attachment directly into a channel's blob storage.\n        This is useful because it allows you to store data in a compliant store\n        when dealing with enterprises.\n        The response is a ResourceResponse which contains an AttachmentId which\n        is suitable for using with the attachments API.\n\n        :param conversation_id: Conversation ID\n        :type conversation_id: str\n        :param attachment_upload: Attachment data\n        :type attachment_upload: ~botframework.connector.models.AttachmentData\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ResourceResponse or ClientRawResponse if raw=true\n        :rtype: ~botframework.connector.models.ResourceResponse or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<botframework.connector.models.ErrorResponseException>`", "id": "f10220:c0:m12"}
{"signature": "def get_activity_members(<EOL>self, conversation_id, activity_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_activity_members.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", conversation_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", activity_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "GetActivityMembers.\n\n        Enumerate the members of an activity.\n        This REST API takes a ConversationId and a ActivityId, returning an\n        array of ChannelAccount objects representing the members of the\n        particular activity in the conversation.\n\n        :param conversation_id: Conversation ID\n        :type conversation_id: str\n        :param activity_id: Activity ID\n        :type activity_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype: list[~botframework.connector.models.ChannelAccount] or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<botframework.connector.models.ErrorResponseException>`", "id": "f10220:c0:m11"}
{"signature": "async def sign_out(<EOL>self, user_id, connection_name=None, channel_id=None, *, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.sign_out.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", user_id, '<STR_LIT:str>')<EOL>if connection_name is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", connection_name, '<STR_LIT:str>')<EOL><DEDENT>if channel_id is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", channel_id, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = await self._client.async_send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT:object>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": ":param user_id:\n:type user_id: str\n:param connection_name:\n:type connection_name: str\n:param channel_id:\n:type channel_id: str\n:param dict custom_headers: headers that will be added to the request\n:param bool raw: returns the direct response alongside the\n deserialized response\n:param operation_config: :ref:`Operation configuration\n overrides<msrest:optionsforoperations>`.\n:return: object or ClientRawResponse if raw=true\n:rtype: object or ~msrest.pipeline.ClientRawResponse\n:raises:\n :class:`ErrorResponseException<botframework.tokenapi.models.ErrorResponseException>`", "id": "f10234:c0:m3"}
{"signature": "def get_aad_tokens(<EOL>self, user_id, connection_name, channel_id=None, resource_urls=None, custom_headers=None, raw=False, **operation_config):", "body": "aad_resource_urls = models.AadResourceUrls(resource_urls=resource_urls)<EOL>url = self.get_aad_tokens.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", user_id, '<STR_LIT:str>')<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", connection_name, '<STR_LIT:str>')<EOL>if channel_id is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", channel_id, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(aad_resource_urls, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": ":param user_id:\n:type user_id: str\n:param connection_name:\n:type connection_name: str\n:param channel_id:\n:type channel_id: str\n:param resource_urls:\n:type resource_urls: list[str]\n:param dict custom_headers: headers that will be added to the request\n:param bool raw: returns the direct response alongside the\n deserialized response\n:param operation_config: :ref:`Operation configuration\n overrides<msrest:optionsforoperations>`.\n:return: dict or ClientRawResponse if raw=true\n:rtype: dict[str, ~botframework.tokenapi.models.TokenResponse] or\n ~msrest.pipeline.ClientRawResponse\n:raises:\n :class:`ErrorResponseException<botframework.tokenapi.models.ErrorResponseException>`", "id": "f10235:c0:m2"}
{"signature": "def egg2dist(self, egginfo_path, distinfo_path):", "body": "def adios(p):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if os.path.exists(p) and not os.path.islink(p) and os.path.isdir(p):<EOL><INDENT>shutil.rmtree(p)<EOL><DEDENT>elif os.path.exists(p):<EOL><INDENT>os.unlink(p)<EOL><DEDENT><DEDENT>adios(distinfo_path)<EOL>if not os.path.exists(egginfo_path):<EOL><INDENT>import glob<EOL>pat = os.path.join(os.path.dirname(egginfo_path), '<STR_LIT>')<EOL>possible = glob.glob(pat)<EOL>err = \"<STR_LIT>\" % (egginfo_path,)<EOL>if possible:<EOL><INDENT>alt = os.path.basename(possible[<NUM_LIT:0>])<EOL>err += \"<STR_LIT>\" % (alt,)<EOL><DEDENT>raise ValueError(err)<EOL><DEDENT>if os.path.isfile(egginfo_path):<EOL><INDENT>pkginfo_path = egginfo_path<EOL>pkg_info = self._pkginfo_to_metadata(egginfo_path, egginfo_path)<EOL>os.mkdir(distinfo_path)<EOL><DEDENT>else:<EOL><INDENT>pkginfo_path = os.path.join(egginfo_path, '<STR_LIT>')<EOL>pkg_info = self._pkginfo_to_metadata(egginfo_path, pkginfo_path)<EOL>shutil.copytree(egginfo_path, distinfo_path,<EOL>ignore=lambda x, y: set(('<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',)))<EOL>dependency_links_path = os.path.join(distinfo_path, '<STR_LIT>')<EOL>with open(dependency_links_path, '<STR_LIT:r>') as dependency_links_file:<EOL><INDENT>dependency_links = dependency_links_file.read().strip()<EOL><DEDENT>if not dependency_links:<EOL><INDENT>adios(dependency_links_path)<EOL><DEDENT><DEDENT>write_pkg_info(os.path.join(distinfo_path, '<STR_LIT>'), pkg_info)<EOL>metadata_path = os.path.join(distinfo_path, '<STR_LIT>')<EOL>self.add_requirements(metadata_path)<EOL>metadata_json_path = os.path.join(distinfo_path, '<STR_LIT>')<EOL>pymeta = pkginfo_to_dict(metadata_path,<EOL>distribution=self.distribution)<EOL>if '<STR_LIT:description>' in pymeta:<EOL><INDENT>description_filename = '<STR_LIT>'<EOL>description_text = pymeta.pop('<STR_LIT:description>')<EOL>description_path = os.path.join(distinfo_path,<EOL>description_filename)<EOL>with open(description_path, \"<STR_LIT:wb>\") as description_file:<EOL><INDENT>description_file.write(description_text.encode('<STR_LIT:utf-8>'))<EOL><DEDENT>pymeta['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT:description>'] = description_filename<EOL><DEDENT>license = self.license_file()<EOL>if license:<EOL><INDENT>license_filename = '<STR_LIT>'<EOL>shutil.copy(license, os.path.join(self.distinfo_dir, license_filename))<EOL>pymeta['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT>'] = license_filename<EOL><DEDENT>with open(metadata_json_path, \"<STR_LIT:w>\") as metadata_json:<EOL><INDENT>json.dump(pymeta, metadata_json, sort_keys=True)<EOL><DEDENT>adios(egginfo_path)<EOL>", "docstring": "Convert an .egg-info directory into a .dist-info directory", "id": "f10244:c0:m12"}
{"signature": "def get_archive_basename(self):", "body": "impl_tag, abi_tag, plat_tag = self.get_tag()<EOL>archive_basename = \"<STR_LIT>\" % (<EOL>self.wheel_dist_name,<EOL>impl_tag,<EOL>abi_tag,<EOL>plat_tag)<EOL>return archive_basename<EOL>", "docstring": "Return archive name without extension", "id": "f10244:c0:m4"}
{"signature": "def license_file(self):", "body": "metadata = self.distribution.get_option_dict('<STR_LIT>')<EOL>if not '<STR_LIT>' in metadata:<EOL><INDENT>return None<EOL><DEDENT>return metadata['<STR_LIT>'][<NUM_LIT:1>]<EOL>", "docstring": "Return license filename from a license-file key in setup.cfg, or None.", "id": "f10244:c0:m9"}
{"signature": "def add_requirements(self, metadata_path):", "body": "additional = list(self.setupcfg_requirements())<EOL>if not additional: return<EOL>pkg_info = read_pkg_info(metadata_path)<EOL>if '<STR_LIT>' in pkg_info or '<STR_LIT>' in pkg_info:<EOL><INDENT>warnings.warn('<STR_LIT>')<EOL>del pkg_info['<STR_LIT>']<EOL>del pkg_info['<STR_LIT>']<EOL><DEDENT>for k, v in additional:<EOL><INDENT>pkg_info[k] = v<EOL><DEDENT>write_pkg_info(metadata_path, pkg_info)<EOL>", "docstring": "Add additional requirements from setup.cfg to file metadata_path", "id": "f10244:c0:m11"}
{"signature": "@property<EOL><INDENT>def wheel_dist_name(self):<DEDENT>", "body": "return '<STR_LIT:->'.join((safer_name(self.distribution.get_name()),<EOL>safer_version(self.distribution.get_version())))<EOL>", "docstring": "Return distribution full name with - replaced with _", "id": "f10244:c0:m2"}
{"signature": "async def get_answers(<EOL>self, <EOL>context: TurnContext, <EOL>options: QnAMakerOptions = None, <EOL>telemetry_properties: Dict[str,str] = None,<EOL>telemetry_metrics: Dict[str,int] = None<EOL>) -> [QueryResult]:", "body": "hydrated_options = self._hydrate_options(options)<EOL>self._validate_options(hydrated_options)<EOL>result = self._query_qna_service(context.activity, hydrated_options)<EOL>await self._emit_trace_info(context, result, hydrated_options)<EOL>return result<EOL>", "docstring": "Generates answers from the knowledge base.\n\n:return: A list of answers for the user's query, sorted in decreasing order of ranking score.\n\n:rtype: [QueryResult]", "id": "f10247:c1:m7"}
{"signature": "def fill_qna_event(<EOL>self,<EOL>query_results: [QueryResult],<EOL>turn_context: TurnContext,<EOL>telemetry_properties: Dict[str,str] = None,<EOL>telemetry_metrics: Dict[str,float] = None<EOL>) -> EventData:", "body": "properties: Dict[str,str] = dict()<EOL>metrics: Dict[str, float] = dict()<EOL>properties[QnATelemetryConstants.knowledge_base_id_property] = self._endpoint.knowledge_base_id<EOL>text: str = turn_context.activity.text<EOL>userName: str = turn_context.activity.from_property.name<EOL>if self.log_personal_information:<EOL><INDENT>if text:<EOL><INDENT>properties[QnATelemetryConstants.question_property] = text<EOL><DEDENT>if userName:<EOL><INDENT>properties[QnATelemetryConstants.username_property] = userName<EOL><DEDENT><DEDENT>if len(query_results) > <NUM_LIT:0>:<EOL><INDENT>query_result = query_results[<NUM_LIT:0>]<EOL>result_properties = {<EOL>QnATelemetryConstants.matched_question_property: json.dumps(query_result.questions),<EOL>QnATelemetryConstants.question_id_property: str(query_result.id),<EOL>QnATelemetryConstants.answer_property: query_result.answer,<EOL>QnATelemetryConstants.score_metric: query_result.score,<EOL>QnATelemetryConstants.article_found_property: '<STR_LIT:true>'<EOL>}<EOL>properties.update(result_properties)<EOL><DEDENT>else:<EOL><INDENT>no_match_properties = {<EOL>QnATelemetryConstants.matched_question_property : '<STR_LIT>',<EOL>QnATelemetryConstants.question_id_property : '<STR_LIT>',<EOL>QnATelemetryConstants.answer_property : '<STR_LIT>',<EOL>QnATelemetryConstants.article_found_property : '<STR_LIT:false>'<EOL>}<EOL>properties.update(no_match_properties)<EOL><DEDENT>if telemetry_properties:<EOL><INDENT>properties.update(telemetry_properties)<EOL><DEDENT>if telemetry_metrics:<EOL><INDENT>metrics.update(telemetry_metrics)<EOL><DEDENT>return EventData(properties=properties, metrics=metrics)<EOL>", "docstring": "Fills the event properties and metrics for the QnaMessage event for telemetry.\n\n:return: A tuple of event data properties and metrics that will be sent to the BotTelemetryClient.track_event() method for the QnAMessage event. The properties and metrics returned the standard properties logged with any properties passed from the get_answers() method.\n\n:rtype: EventData", "id": "f10247:c1:m6"}
{"signature": "def _hydrate_options(self, query_options: QnAMakerOptions) -> QnAMakerOptions:", "body": "hydrated_options = copy(self._options)<EOL>if query_options:<EOL><INDENT>if (<EOL>query_options.score_threshold != hydrated_options.score_threshold <EOL>and query_options.score_threshold<EOL>):<EOL><INDENT>hydrated_options.score_threshold = query_options.score_threshold<EOL><DEDENT>if (query_options.top != hydrated_options.top and query_options.top != <NUM_LIT:0>):<EOL><INDENT>hydrated_options.top = query_options.top<EOL><DEDENT>if (len(query_options.strict_filters) > <NUM_LIT:0>):<EOL><INDENT>hydrated_options.strict_filters = query_options.strict_filters<EOL><DEDENT><DEDENT>return hydrated_options<EOL>", "docstring": "Combines QnAMakerOptions passed into the QnAMaker constructor with the options passed as arguments into get_answers().\n\n:return: QnAMakerOptions with options passed into constructor overwritten by new options passed into get_answers()\n\n:rtype: QnAMakerOptions", "id": "f10247:c1:m9"}
{"signature": "@property<EOL><INDENT>def log_personal_information(self) -> bool:<DEDENT>", "body": "return self._log_personal_information<EOL>", "docstring": "Gets a value indicating whether to log personal information that came from the user to telemetry.\n\n        :return: If True, personal information is logged to Telemetry; otherwise the properties will be filtered.\n        :rtype: bool", "id": "f10247:c1:m1"}
{"signature": "@property<EOL><INDENT>def score(self) -> float:<DEDENT>", "body": "return self._score<EOL>", "docstring": "Gets confidence in an intent.\n\n        :return: Confidence in an intent.\n        :rtype: float", "id": "f10257:c0:m1"}
{"signature": "@property<EOL><INDENT>def properties(self) -> Dict[str, object]:<DEDENT>", "body": "return self._properties<EOL>", "docstring": "Gets any extra properties to include in the results.\n\n        :return: Any extra properties to include in the results.\n        :rtype: Dict[str, object]", "id": "f10257:c0:m3"}
{"signature": "@properties.setter<EOL><INDENT>def properties(self, value: Dict[str, object]) -> None:<DEDENT>", "body": "self._properties = value<EOL>", "docstring": "Sets any extra properties to include in the results.\n\n        :param value: Any extra properties to include in the results.\n        :type value: Dict[str, object]\n        :return:\n        :rtype: None", "id": "f10257:c0:m4"}
{"signature": "def __init__(self, application_id: str, endpoint_key: str, endpoint: str):", "body": "_, valid = LuisApplication._try_parse_uuid4(application_id)<EOL>if not valid:<EOL><INDENT>raise ValueError(f'<STR_LIT>')<EOL><DEDENT>_, valid = LuisApplication._try_parse_uuid4(endpoint_key)<EOL>if not valid:<EOL><INDENT>raise ValueError(f'<STR_LIT>')<EOL><DEDENT>if not endpoint or endpoint.isspace():<EOL><INDENT>endpoint = \"<STR_LIT>\"<EOL><DEDENT>_, valid = LuisApplication._try_parse_url(endpoint)<EOL>if not valid:<EOL><INDENT>raise ValueError(f'<STR_LIT>')<EOL><DEDENT>self._application_id = application_id<EOL>self._endpoint_key = endpoint_key<EOL>self._endpoint = endpoint<EOL>", "docstring": "Initializes a new instance of the <see cref=\"LuisApplication\"/> class.\n\n        :param application_id: LUIS application ID.\n        :type application_id: str\n        :param endpoint_key: LUIS subscription or endpoint key.\n        :type endpoint_key: str\n        :param endpoint: LUIS endpoint to use like https://westus.api.cognitive.microsoft.com.\n        :type endpoint: str\n        :raises ValueError: \n        :raises ValueError:\n        :raises ValueError:", "id": "f10258:c0:m0"}
{"signature": "@property<EOL><INDENT>def telemetry_client(self) -> BotTelemetryClient:<DEDENT>", "body": "return self._telemetry_client<EOL>", "docstring": "Gets the BotTelemetryClient used to log the LuisResult event.\n\n        :return: The client used to log telemetry events.\n        :rtype: BotTelemetryClient", "id": "f10259:c0:m17"}
{"signature": "@property<EOL><INDENT>def log(self) -> bool:<DEDENT>", "body": "return self._log<EOL>", "docstring": "Gets if queries should be logged in LUIS.\n\n        :return: If queries should be logged in LUIS.\n        :rtype: bool", "id": "f10259:c0:m7"}
{"signature": "@property<EOL><INDENT>def include_all_intents(self) -> bool:<DEDENT>", "body": "return self._include_all_intents<EOL>", "docstring": "Gets whether all intents come back or only the top one.\n\n        :return: True for returning all intents.\n        :rtype: bool", "id": "f10259:c0:m3"}
{"signature": "@property<EOL><INDENT>def spell_check(self) -> bool:<DEDENT>", "body": "return self._spell_check<EOL>", "docstring": "Gets whether to spell check queries.\n\n        :return: Whether to spell check queries.\n        :rtype: bool", "id": "f10259:c0:m9"}
{"signature": "@bing_spell_check_subscription_key.setter<EOL><INDENT>def bing_spell_check_subscription_key(self, value: str) -> None:<DEDENT>", "body": "self._bing_spell_check_subscription_key = value<EOL>", "docstring": "Sets the Bing Spell Check subscription key.\n\n        :param value: The Bing Spell Check subscription key.\n        :type value: str\n        :return:\n        :rtype: None", "id": "f10259:c0:m2"}
{"signature": "@property<EOL><INDENT>def staging(self) -> bool:<DEDENT>", "body": "return self._staging<EOL>", "docstring": "Gets whether to use the staging endpoint.\n\n        :return: Whether to use the staging endpoint.\n        :rtype: bool", "id": "f10259:c0:m11"}
{"signature": "@property<EOL><INDENT>def include_instance_data(self) -> bool:<DEDENT>", "body": "return self._include_instance_data<EOL>", "docstring": "Gets a value indicating whether or not instance data should be included in response.\n\n        :return: A value indicating whether or not instance data should be included in response.\n        :rtype: bool", "id": "f10259:c0:m5"}
{"signature": "@property<EOL><INDENT>def bing_spell_check_subscription_key(self) -> str:<DEDENT>", "body": "return self._bing_spell_check_subscription_key<EOL>", "docstring": "Gets the Bing Spell Check subscription key.\n\n        :return: The Bing Spell Check subscription key.\n        :rtype: str", "id": "f10259:c0:m1"}
{"signature": "@property<EOL><INDENT>def log_personal_information(self) -> bool:<DEDENT>", "body": "return self._log_personal_information<EOL>", "docstring": "Gets a value indicating whether to log personal information that came from the user to telemetry.\n\n        :return: If True, personal information is logged to Telemetry; otherwise the properties will be filtered.\n        :rtype: bool", "id": "f10260:c0:m1"}
{"signature": "@telemetry_client.setter<EOL><INDENT>def telemetry_client(self, value: BotTelemetryClient):<DEDENT>", "body": "self._telemetry_client = value<EOL>", "docstring": "Gets the currently configured <see cref=\"BotTelemetryClient\"/> that logs the LuisResult event.\n\n        :param value: The <see cref=\"BotTelemetryClient\"/> being used to log events.\n        :type value: BotTelemetryClient", "id": "f10260:c0:m4"}
{"signature": "@staticmethod<EOL><INDENT>def top_intent(<EOL>results: RecognizerResult, default_intent: str = \"<STR_LIT:None>\", min_score: float = <NUM_LIT:0.0><EOL>) -> str:<DEDENT>", "body": "if results is None:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>top_intent: str = None<EOL>top_score: float = -<NUM_LIT:1.0><EOL>if results.intents:<EOL><INDENT>for intent_name, intent_score in results.intents.items():<EOL><INDENT>score = intent_score.score<EOL>if score > top_score and score >= min_score:<EOL><INDENT>top_intent = intent_name<EOL>top_score = score<EOL><DEDENT><DEDENT><DEDENT>return top_intent or default_intent<EOL>", "docstring": "Returns the name of the top scoring intent from a set of LUIS results.\n\n        :param results: Result set to be searched.\n        :type results: RecognizerResult\n        :param default_intent: Intent name to return should a top intent be found, defaults to \"None\"\n        :param default_intent: str, optional\n        :param min_score: Minimum score needed for an intent to be considered as a top intent. If all intents in the set are below this threshold then the `defaultIntent` will be returned, defaults to 0.0\n        :param min_score: float, optional\n        :raises TypeError:\n        :return: The top scoring intent name.\n        :rtype: str", "id": "f10260:c0:m5"}
{"signature": "@staticmethod<EOL><INDENT>def create_trace(<EOL>turn_activity: Activity,<EOL>name: str,<EOL>value: object = None,<EOL>value_type: str = None,<EOL>label: str = None,<EOL>) -> Activity:<DEDENT>", "body": "from_property = (<EOL>ChannelAccount(<EOL>id=turn_activity.recipient.id, name=turn_activity.recipient.name<EOL>)<EOL>if turn_activity.recipient is not None<EOL>else ChannelAccount()<EOL>)<EOL>if value_type is None and value is not None:<EOL><INDENT>value_type = type(value).__name__<EOL><DEDENT>reply = Activity(<EOL>type=ActivityTypes.trace,<EOL>timestamp=datetime.utcnow(),<EOL>from_property=from_property,<EOL>recipient=ChannelAccount(<EOL>id=turn_activity.from_property.id, name=turn_activity.from_property.name<EOL>),<EOL>reply_to_id=turn_activity.id,<EOL>service_url=turn_activity.service_url,<EOL>channel_id=turn_activity.channel_id,<EOL>conversation=ConversationAccount(<EOL>is_group=turn_activity.conversation.is_group,<EOL>id=turn_activity.conversation.id,<EOL>name=turn_activity.conversation.name,<EOL>),<EOL>name=name,<EOL>label=label,<EOL>value_type=value_type,<EOL>value=value,<EOL>)<EOL>return reply<EOL>", "docstring": "Creates a trace activity based on this activity.\n\n        :param turn_activity:\n        :type turn_activity: Activity\n        :param name: The value to assign to the trace activity's <see cref=\"Activity.name\"/> property.\n        :type name: str\n        :param value: The value to assign to the trace activity's <see cref=\"Activity.value\"/> property., defaults to None\n        :param value: object, optional\n        :param value_type: The value to assign to the trace activity's <see cref=\"Activity.value_type\"/> property, defaults to None\n        :param value_type: str, optional\n        :param label: The value to assign to the trace activity's <see cref=\"Activity.label\"/> property, defaults to None\n        :param label: str, optional\n        :return: The created trace activity.\n        :rtype: Activity", "id": "f10261:c0:m0"}
{"signature": "@text.setter<EOL><INDENT>def text(self, value: str) -> None:<DEDENT>", "body": "self._text = value<EOL>", "docstring": "Sets the input text to recognize.\n\n        :param value: Original text to recognizer.\n        :type value: str\n        :return:\n        :rtype: None", "id": "f10262:c1:m2"}
{"signature": "@property<EOL><INDENT>def intents(self) -> Dict[str, IntentScore]:<DEDENT>", "body": "return self._intents<EOL>", "docstring": "Gets the recognized intents, with the intent as key and the confidence as value.\n\n        :return: Mapping from intent to information about the intent.\n        :rtype: Dict[str, IntentScore]", "id": "f10262:c1:m5"}
{"signature": "@property<EOL><INDENT>def altered_text(self) -> str:<DEDENT>", "body": "return self._altered_text<EOL>", "docstring": "Gets the input text as modified by the recognizer, for example for spelling correction.\n\n        :return: Text modified by recognizer.\n        :rtype: str", "id": "f10262:c1:m3"}
{"signature": "@state.setter<EOL><INDENT>def state(self, value: Dict[str, object]) -> None:<DEDENT>", "body": "self._state = value<EOL>", "docstring": "Sets the instance's persisted state.\n\n        :param:\n        :param value: The instance's persisted state.\n        :return:", "id": "f10271:c0:m4"}
{"signature": "@property<EOL><INDENT>def id(self) -> str:<DEDENT>", "body": "return self._id<EOL>", "docstring": "Gets the ID of the dialog this instance is for.\n\n        :param:\n        :return str:", "id": "f10271:c0:m1"}
{"signature": "@property<EOL><INDENT>def action(self) -> CardAction:<DEDENT>", "body": "return self._action<EOL>", "docstring": "Gets the action to use when rendering the choice as a suggested action or hero card.\n        This is optional.\n\n        :return: The action to use when rendering the choice as a suggested action or hero card.\n        :rtype: CardAction", "id": "f10272:c0:m3"}
{"signature": "@property<EOL><INDENT>def synonyms(self) -> List[str]:<DEDENT>", "body": "return self._synonyms<EOL>", "docstring": "Gets the list of synonyms to recognize in addition to the value. This is optional.\n\n        :return: The list of synonyms to recognize in addition to the value.\n        :rtype: List[str]", "id": "f10272:c0:m5"}
{"signature": "@inline_separator.setter<EOL><INDENT>def inline_separator(self, value: str) -> None:<DEDENT>", "body": "self._inline_separator = value<EOL>", "docstring": "Sets the character used to separate individual choices when there are more than 2 choices.\n        The default value is `\", \"`. This is optional.\n\n        :param value: The character used to separate individual choices when there are more than 2 choices.\n        :type value: str\n        :return:\n        :rtype: None", "id": "f10273:c0:m2"}
{"signature": "@property<EOL><INDENT>def active_dialog(self):<DEDENT>", "body": "if self._stack != None and len(self._stack) > <NUM_LIT:0>:<EOL><INDENT>return self._stack[<NUM_LIT:0>]<EOL><DEDENT>return None<EOL>", "docstring": "Return the container link in the database.\n\n        :param:\n        :return str:", "id": "f10277:c0:m6"}
{"signature": "@property<EOL><INDENT>def parent(self) -> '<STR_LIT>':<DEDENT>", "body": "return self._parent<EOL>", "docstring": "Gets the parent DialogContext if any. Used when searching for dialogs to start.\n\n:param:\n:return The parent DialogContext:", "id": "f10277:c0:m4"}
{"signature": "def add_dialog(self, dialog: Dialog) -> object:", "body": "self._dialogs.add(dialog)<EOL>if not self.initial_dialog_id:<EOL><INDENT>self.initial_dialog_id = dialog.id<EOL><DEDENT>return self<EOL>", "docstring": "Adds a dialog to the component dialog.\nAdding a new dialog will inherit the BotTelemetryClient of the ComponentDialog.\n:param dialog: The dialog to add.\n:return: The updated ComponentDialog", "id": "f10282:c0:m8"}
{"signature": "@succeeded.setter<EOL><INDENT>def succeeded(self, value: bool) -> None:<DEDENT>", "body": "self._succeeded = value<EOL>", "docstring": "Sets the whether the users utterance was successfully recognized\n        Parameters\n        ----------\n        value\n            A bool indicating whether the users utterance was successfully recognized", "id": "f10283:c0:m2"}
{"signature": "@property<EOL><INDENT>def default_locale(self) -> str:<DEDENT>", "body": "return self._default_locale<EOL>", "docstring": "Gets the locale used if `TurnContext.activity.locale` is not specified.", "id": "f10286:c0:m1"}
{"signature": "@default_locale.setter<EOL><INDENT>def default_locale(self, value: str) -> None:<DEDENT>", "body": "self._default_locale = value<EOL>", "docstring": "Gets the locale used if `TurnContext.activity.locale` is not specified.\n\n        :param value: The locale used if `TurnContext.activity.locale` is not specified.", "id": "f10286:c0:m2"}
{"signature": "@number_of_attempts.setter<EOL><INDENT>def number_of_attempts(self, value: int) -> None:<DEDENT>", "body": "self._number_of_attempts = value<EOL>", "docstring": "Sets the count of the number of times the prompt has retried.\n        Parameters\n        ----------\n        value\n            Count of the number of times the prompt has retried.", "id": "f10287:c0:m12"}
{"signature": "@retry_prompt.setter<EOL><INDENT>def retry_prompt(self, value: Activity) -> None:<DEDENT>", "body": "self._retry_prompt = value<EOL>", "docstring": "Sets the retry prompt to send the user as Activity.\n        Parameters\n        ----------\n        value\n            The new value of the retry prompt.", "id": "f10287:c0:m4"}
{"signature": "@property<EOL><INDENT>def state(self) -> Dict:<DEDENT>", "body": "return self._recognized<EOL>", "docstring": "A dictionary of values persisted for each conversational turn while the prompt is active.\n\n        Note\n        ----\n        The validator can use this to persist things like turn counts or other state information.", "id": "f10292:c0:m3"}
{"signature": "@property<EOL><INDENT>def options(self) -> PromptOptions:<DEDENT>", "body": "return self._options<EOL>", "docstring": "Original set of options passed to the prompt by the calling dialog.\n\n        Note\n        ----\n        The validator can extend this interface to support additional prompt options.", "id": "f10292:c0:m4"}
{"signature": "async def resume_dialog(self, dc, reason: DialogReason, result: object):", "body": "<EOL>return await dc.EndDialog(result)<EOL>", "docstring": "Method called when an instance of the dialog is being returned to from another\ndialog that was started by the current instance using `begin_dialog()`.\nIf this method is NOT implemented then the dialog will be automatically ended with a call\nto `end_dialog()`. Any result passed from the called dialog will be passed\nto the current dialog's parent.        \n:param dc: The dialog context for the current turn of conversation.\n:param reason: Reason why the dialog resumed.\n:param result: (Optional) value returned from the dialog that was called. The type of the value returned is dependent on the dialog that was called.\n:return:", "id": "f10296:c0:m6"}
{"signature": "@abstractmethod<EOL><INDENT>async def begin_dialog(self, dc, options: object = None):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "Method called when a new dialog has been pushed onto the stack and is being activated.\n:param dc: The dialog context for the current turn of conversation.\n:param options: (Optional) additional argument(s) to pass to the dialog being started.", "id": "f10296:c0:m4"}
{"signature": "async def continue_dialog(self, dc):", "body": "<EOL>return await dc.end_dialog(None)<EOL>", "docstring": "Method called when an instance of the dialog is the \"current\" dialog and the\nuser replies with a new activity. The dialog will generally continue to receive the user's\nreplies until it calls either `end_dialog()` or `begin_dialog()`.\nIf this method is NOT implemented then the dialog will automatically be ended when the user replies.\n:param dc: The dialog context for the current turn of conversation.\n:return:", "id": "f10296:c0:m5"}
{"signature": "def add_step(self, step):", "body": "if not step:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>self._steps.append(step)<EOL>return self<EOL>", "docstring": "Adds a new step to the waterfall.\n:param step: Step to add\n\n:return: Waterfall dialog for fluent calls to `add_step()`.", "id": "f10297:c0:m1"}
{"signature": "def track_exception(self, type_exception: type = None, value : Exception =None, tb : traceback =None, <EOL>properties: Dict[str, object]=None, measurements: Dict[str, object]=None) -> None:", "body": "self._client.track_exception(type_exception, value, tb, properties, measurements)<EOL>", "docstring": "Send information about a single exception that occurred in the application.\n:param type_exception: the type of the exception that was thrown.\n:param value: the exception that the client wants to send.\n:param tb: the traceback information as returned by :func:`sys.exc_info`.\n:param properties: the set of custom properties the client wants attached to this data item. (defaults to: None)\n:param measurements: the set of custom measurements the client wants to attach to this data item. (defaults to: None)", "id": "f10309:c0:m2"}
{"signature": "def track_exception(self, type_exception: type = None, value : Exception =None, tb : traceback =None, <EOL>properties: Dict[str, object]=None, measurements: Dict[str, object]=None) -> None:", "body": "self._client.track_exception(type_exception, value, tb, properties, measurements)<EOL>", "docstring": "Send information about a single exception that occurred in the application.\n:param type_exception: the type of the exception that was thrown.\n:param value: the exception that the client wants to send.\n:param tb: the traceback information as returned by :func:`sys.exc_info`.\n:param properties: the set of custom properties the client wants attached to this data item. (defaults to: None)\n:param measurements: the set of custom measurements the client wants to attach to this data item. (defaults to: None)", "id": "f10311:c0:m2"}
{"signature": "async def delete(self, keys: List[str]):", "body": "try:<EOL><INDENT>if not self.__container_exists:<EOL><INDENT>self.__create_db_and_container()<EOL><DEDENT>for k in keys:<EOL><INDENT>self.client.DeleteItem(<EOL>document_link=self.__item_link(self.__sanitize_key(k)))<EOL><DEDENT><DEDENT>except cosmos_errors.HTTPFailure as h:<EOL><INDENT>if h.status_code != <NUM_LIT>:<EOL><INDENT>raise h<EOL><DEDENT><DEDENT>except TypeError as e:<EOL><INDENT>raise e<EOL><DEDENT>", "docstring": "Remove storeitems from storage.\n\n        :param keys:\n        :return:", "id": "f10327:c1:m3"}
{"signature": "def __get_or_create_database(self, doc_client, id) -> str:", "body": "<EOL>dbs = list(doc_client.QueryDatabases({<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": [<EOL>{\"<STR_LIT:name>\": \"<STR_LIT>\", \"<STR_LIT:value>\": id}<EOL>]<EOL>}))<EOL>if len(dbs) > <NUM_LIT:0>:<EOL><INDENT>return dbs[<NUM_LIT:0>]['<STR_LIT:id>']<EOL><DEDENT>else:<EOL><INDENT>res = doc_client.CreateDatabase({'<STR_LIT:id>': id})<EOL>return res['<STR_LIT:id>']<EOL><DEDENT>", "docstring": "Return the database link.\n\n        Check if the database exists or create the db.\n\n        :param doc_client:\n        :param id:\n        :return str:", "id": "f10327:c1:m12"}
{"signature": "@property<EOL><INDENT>def __container_exists(self) -> bool:<DEDENT>", "body": "return self.db and self.container<EOL>", "docstring": "Return whether the database and container have been created.\n\n        :return bool:", "id": "f10327:c1:m10"}
{"signature": "@property<EOL><INDENT>def __container_link(self) -> str:<DEDENT>", "body": "return self.__database_link + '<STR_LIT>' + self.container<EOL>", "docstring": "Return the container link in the database.\n\n        :param:\n        :return str:", "id": "f10327:c1:m8"}
{"signature": "@staticmethod<EOL><INDENT>def receipt_card(card: ReceiptCard) -> Attachment:<DEDENT>", "body": "if not isinstance(card, ReceiptCard):<EOL><INDENT>raise TypeError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>return Attachment(content_type=CardFactory.content_types.receipt_card,<EOL>content=card)<EOL>", "docstring": "Returns an attachment for a receipt card. Will raise a TypeError if 'card' argument is not a ReceiptCard.\n:param card:\n:return:", "id": "f10336:c1:m5"}
{"signature": "@staticmethod<EOL><INDENT>def thumbnail_card(card: ThumbnailCard) -> Attachment:<DEDENT>", "body": "if not isinstance(card, ThumbnailCard):<EOL><INDENT>raise TypeError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>return Attachment(content_type=CardFactory.content_types.thumbnail_card,<EOL>content=card)<EOL>", "docstring": "Returns an attachment for a thumbnail card. Thumbnail cards are similar to\nbut instead of a full width image, they're typically rendered with a smaller thumbnail version of\nthe image on either side and the text will be rendered in column next to the image. Any buttons\nwill typically show up under the card. Will raise a TypeError if 'card' argument is not a ThumbnailCard.\n:param card:\n:return:", "id": "f10336:c1:m7"}
{"signature": "@staticmethod<EOL><INDENT>def adaptive_card(card: dict) -> Attachment:<DEDENT>", "body": "if not type(card) == dict:<EOL><INDENT>raise TypeError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>return Attachment(content_type=CardFactory.content_types.adaptive_card,<EOL>content=card)<EOL>", "docstring": "Returns an attachment for an adaptive card. The attachment will contain the card and the\nappropriate 'contentType'. Will raise a TypeError if the 'card' argument is not an\ndict.\n:param card:\n:return:", "id": "f10336:c1:m0"}
{"signature": "async def delete(self, turn_context: TurnContext) -> None:", "body": "if turn_context == None:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>turn_context.turn_state.pop(self._context_service_key)<EOL>storage_key = self.get_storage_key(turn_context)<EOL>await self._storage.delete({ storage_key })<EOL>", "docstring": "Delete any state currently stored in this state scope.\n\n:param turn_context: The context object for this turn.\n:return: None", "id": "f10337:c1:m6"}
{"signature": "async def clear_state(self, turn_context: TurnContext):", "body": "if turn_context == None:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>cache_value = CachedBotState()<EOL>cache_value.hash = '<STR_LIT>'<EOL>turn_context.turn_state[self._context_service_key] = cache_value<EOL>", "docstring": "Clears any state currently stored in this state scope.\nNOTE: that save_changes must be called in order for the cleared state to be persisted to the underlying store.\n\n:param turn_context: The context object for this turn.\n:return: None", "id": "f10337:c1:m5"}
{"signature": "async def save_changes(self, turn_context: TurnContext, force: bool = False) -> None:", "body": "if turn_context == None:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>cached_state = turn_context.turn_state.get(self._context_service_key)<EOL>if force or (cached_state != None and cached_state.is_changed == True):<EOL><INDENT>storage_key = self.get_storage_key(turn_context)<EOL>changes : Dict[str, object] = { storage_key: cached_state.state }<EOL>await self._storage.write(changes)<EOL>cached_state.hash = cached_state.compute_hash(cached_state.state)<EOL><DEDENT>", "docstring": "If it has changed, writes to storage the state object that is cached in the current context object for this turn.\n:param turn_context: The context object for this turn.\n:param force: Optional. True to save state to storage whether or not there are changes.", "id": "f10337:c1:m4"}
{"signature": "async def continue_conversation(self, reference, logic):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "The `TestAdapter` doesn't implement `continueConversation()` and will return an error if it's\ncalled.\n:param reference:\n:param logic:\n:return:", "id": "f10344:c0:m4"}
{"signature": "async def send(self, user_says) -> '<STR_LIT>':", "body": "async def new_previous():<EOL><INDENT>nonlocal self, user_says<EOL>if callable(self.previous):<EOL><INDENT>await self.previous()<EOL><DEDENT>await self.adapter.receive_activity(user_says)<EOL><DEDENT>return TestFlow(await new_previous(), self.adapter)<EOL>", "docstring": "Sends something to the bot.\n:param user_says:\n:return:", "id": "f10344:c1:m2"}
{"signature": "async def send(self, user_says) -> object:", "body": "return TestFlow(await self.receive_activity(user_says), self)<EOL>", "docstring": "Sends something to the bot. This returns a new `TestFlow` instance which can be used to add\nadditional steps for inspecting the bots reply and then sending additional activities.\n:param user_says:\n:return: A new instance of the TestFlow object", "id": "f10344:c0:m6"}
{"signature": "async def delete_activity(self, context, reference: ConversationReference):", "body": "self.deleted_activities.append(reference)<EOL>", "docstring": "INTERNAL: called by the logic under test to delete an existing activity. These are simply\npushed onto a [deletedActivities](#deletedactivities) array for inspection after the turn\ncompletes.\n:param reference:\n:return:", "id": "f10344:c0:m2"}
{"signature": "def on_update_activity(self, handler) -> '<STR_LIT>':", "body": "self._on_update_activity.append(handler)<EOL>return self<EOL>", "docstring": "Registers a handler to be notified of and potentially intercept an activity being updated.\n:param handler:\n:return:", "id": "f10346:c0:m15"}
{"signature": "def on_send_activities(self, handler) -> '<STR_LIT>':", "body": "self._on_send_activities.append(handler)<EOL>return self<EOL>", "docstring": "Registers a handler to be notified of and potentially intercept the sending of activities.\n:param handler:\n:return:", "id": "f10346:c0:m14"}
{"signature": "@property<EOL><INDENT>def services(self):<DEDENT>", "body": "return self._services<EOL>", "docstring": "Map of services and other values cached for the lifetime of the turn.\n:return:", "id": "f10346:c0:m7"}
{"signature": "def set(self, key: str, value: object) -> None:", "body": "if not key or not isinstance(key, str):<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>self._services[key] = value<EOL>", "docstring": "Caches a value for the lifetime of the current turn.\n:param key:\n:param value:\n:return:", "id": "f10346:c0:m10"}
{"signature": "def copy_to(self, context: '<STR_LIT>') -> None:", "body": "for attribute in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>setattr(context, attribute, getattr(self, attribute))<EOL><DEDENT>", "docstring": "Called when this TurnContext instance is passed into the constructor of a new TurnContext\ninstance. Can be overridden in derived classes.\n:param context:\n:return:", "id": "f10346:c0:m2"}
{"signature": "async def send_activity(self, *activity_or_text: Union[Activity, str]) -> ResourceResponse:", "body": "reference = TurnContext.get_conversation_reference(self.activity)<EOL>output = [TurnContext.apply_conversation_reference(<EOL>Activity(text=a, type='<STR_LIT:message>') if isinstance(a, str) else a, reference)<EOL>for a in activity_or_text]<EOL>for activity in output:<EOL><INDENT>activity.input_hint = '<STR_LIT>'<EOL><DEDENT>async def callback(context: '<STR_LIT>', output):<EOL><INDENT>responses = await context.adapter.send_activities(context, output)<EOL>context._responded = True<EOL>return responses<EOL><DEDENT>await self._emit(self._on_send_activities, output, callback(self, output))<EOL>", "docstring": "Sends a single activity or message to the user.\n:param activity_or_text:\n:return:", "id": "f10346:c0:m11"}
{"signature": "@abstractmethod<EOL><INDENT>async def delete_activity(self, context: TurnContext, reference: ConversationReference):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "Deletes an existing activity.\n:param reference:\n:return:", "id": "f10347:c0:m3"}
{"signature": "@staticmethod<EOL><INDENT>def list(attachments: List[Attachment], text: str = None, speak: str = None,<EOL>input_hint: Union[InputHints, str] = None) -> Activity:<DEDENT>", "body": "return attachment_activity(AttachmentLayoutTypes.list, attachments, text, speak, input_hint)<EOL>", "docstring": "Returns a message that will display a set of attachments in list form.\n\n:Example:\nmessage = MessageFactory.list([CardFactory.hero_card(HeroCard(title='title1',\n                                                     images=[CardImage(url='imageUrl1')],\n                                                     buttons=[CardAction(title='button1')])),\n                               CardFactory.hero_card(HeroCard(title='title2',\n                                                     images=[CardImage(url='imageUrl2')],\n                                                     buttons=[CardAction(title='button2')])),\n                               CardFactory.hero_card(HeroCard(title='title3',\n                                                     images=[CardImage(url='imageUrl3')],\n                                                     buttons=[CardAction(title='button3')]))])\nawait context.send_activity(message)\n\n:param attachments:\n:param text:\n:param speak:\n:param input_hint:\n:return:", "id": "f10350:c0:m3"}
{"signature": "@abstractmethod<EOL><INDENT>def track_dependency(self, name:str, data:str, type:str=None, target:str=None, duration:int=None, <EOL>success:bool=None, result_code:str=None, properties:Dict[str, object]=None, <EOL>measurements:Dict[str, object]=None, dependency_id:str=None):<DEDENT>", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Sends a single dependency telemetry that was captured for the application.\n:param name: the name of the command initiated with this dependency call. Low cardinality value. Examples are stored procedure name and URL path template.\n:param data: the command initiated by this dependency call. Examples are SQL statement and HTTP URL with all query parameters.\n:param type: the dependency type name. Low cardinality value for logical grouping of dependencies and interpretation of other fields like commandName and resultCode. Examples are SQL, Azure table, and HTTP. (default to: None)\n:param target: the target site of a dependency call. Examples are server name, host address. (default to: None)\n:param duration: the number of milliseconds that this dependency call lasted. (defaults to: None)\n:param success: true if the dependency call ended in success, false otherwise. (defaults to: None)\n:param result_code: the result code of a dependency call. Examples are SQL error code and HTTP status code. (defaults to: None)\n:param properties: the set of custom properties the client wants attached to this data item. (defaults to: None)\n:param measurements: the set of custom measurements the client wants to attach to this data item. (defaults to: None)\n:param id: the id for this dependency call. If None, a new uuid will be generated. (defaults to: None)", "id": "f10352:c1:m6"}
{"signature": "@abstractmethod<EOL><INDENT>def track_exception(self, type: type = None, value : Exception =None, tb : traceback =None, <EOL>properties: Dict[str, object]=None, measurements: Dict[str, object]=None) -> None:<DEDENT>", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Send information about a single exception that occurred in the application.\n:param type: the type of the exception that was thrown.\n:param value: the exception that the client wants to send.\n:param tb: the traceback information as returned by :func:`sys.exc_info`.\n:param properties: the set of custom properties the client wants attached to this data item. (defaults to: None)\n:param measurements: the set of custom measurements the client wants to attach to this data item. (defaults to: None)", "id": "f10352:c1:m1"}
{"signature": "@abstractmethod<EOL><INDENT>async def get(self, turnContext: TurnContext, default_value_factory = None):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "Get the property value from the source\n:param turn_context: Turn Context.\n:param default_value_factory: Function which defines the property value to be returned if no value has been set.\n\n:return:", "id": "f10353:c0:m0"}
{"signature": "@abstractmethod<EOL><INDENT>async def delete(self, turnContext: TurnContext):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "Saves store items to storage.\n:param turn_context: Turn Context.\n:return:", "id": "f10353:c0:m1"}
{"signature": "def track_pageview(self, name: str, url, duration: int = <NUM_LIT:0>, properties : Dict[str, object]=None, <EOL>measurements: Dict[str, object]=None) -> None:", "body": "pass<EOL>", "docstring": "Send information about the page viewed in the application (a web page for instance).\n:param name: the name of the page that was viewed.\n:param url: the URL of the page that was viewed.\n:param duration: the duration of the page view in milliseconds. (defaults to: 0)\n:param properties: the set of custom properties the client wants attached to this data item. (defaults to: None)\n:param measurements: the set of custom measurements the client wants to attach to this data item. (defaults to: None)", "id": "f10355:c0:m1"}
{"signature": "def track_trace(self, name, properties=None, severity=None):", "body": "pass<EOL>", "docstring": "Sends a single trace statement.\n:param name: the trace statement.\\n\n:param properties: the set of custom properties the client wants attached to this data item. (defaults to: None)\\n\n:param severity: the severity level of this trace, one of DEBUG, INFO, WARNING, ERROR, CRITICAL", "id": "f10355:c0:m5"}
{"signature": "def create_connector_client(self, service_url: str) -> ConnectorClient:", "body": "client = ConnectorClient(self._credentials, base_url=service_url)<EOL>client.config.add_user_agent(USER_AGENT)<EOL>return client<EOL>", "docstring": "Allows for mocking of the connector client in unit tests.\n:param service_url:\n:return:", "id": "f10356:c1:m14"}
{"signature": "def create_context(self, activity):", "body": "return TurnContext(self, activity)<EOL>", "docstring": "Allows for the overriding of the context object in unit tests and derived adapters.\n:param activity:\n:return:", "id": "f10356:c1:m5"}
{"signature": "async def process_activity(self, req, auth_header: str, logic: Callable):", "body": "activity = await self.parse_request(req)<EOL>auth_header = auth_header or '<STR_LIT>'<EOL>await self.authenticate_request(activity, auth_header)<EOL>context = self.create_context(activity)<EOL>return await self.run_middleware(context, logic)<EOL>", "docstring": "Processes an activity received by the bots web server. This includes any messages sent from a\nuser and is the method that drives what's often referred to as the bots \"Reactive Messaging\"\nflow.\n:param req:\n:param auth_header:\n:param logic:\n:return:", "id": "f10356:c1:m3"}
{"signature": "async def send_activities(self, context: TurnContext, activities: List[Activity]):", "body": "if context is None:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if type(activities) != list:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if len(activities) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>async def next_activity(i: int):<EOL><INDENT>responses = []<EOL>if i < len(activities):<EOL><INDENT>responses.append(ResourceResponse())<EOL>a = activities[i]<EOL>if a.type == '<STR_LIT>':<EOL><INDENT>await asyncio.sleep(a.delay)<EOL>await next_activity(i + <NUM_LIT:1>)<EOL><DEDENT>elif a.type == ActivityTypes.message:<EOL><INDENT>if a.attachments is not None and len(a.attachments) > <NUM_LIT:0>:<EOL><INDENT>append = '<STR_LIT>' if len(a.attachments) == <NUM_LIT:1> else f'<STR_LIT>'<EOL>print(f'<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>print(a.text)<EOL><DEDENT>await next_activity(i + <NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>print(f'<STR_LIT>')<EOL>await next_activity(i + <NUM_LIT:1>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return responses<EOL><DEDENT><DEDENT>await next_activity(<NUM_LIT:0>)<EOL>", "docstring": "Logs a series of activities to the console.\n:param context:\n:param activities:\n:return:", "id": "f10374:c0:m2"}
{"signature": "async def update_activity(self, context: TurnContext, activity: Activity):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Not supported for the ConsoleAdapter. Calling this method or `TurnContext.update_activity()`\nwill result an error being returned.\n:param context:\n:param activity:\n:return:", "id": "f10374:c0:m4"}
{"signature": "def view(request):", "body": "from django import forms<EOL>from django.http import HttpResponse<EOL>from django.shortcuts import redirect<EOL>from django.template import Context, Template<EOL>class TestForm(forms.Form):<EOL><INDENT>name = forms.CharField()<EOL><DEDENT>if request.POST:<EOL><INDENT>form = TestForm(request.POST)<EOL>if form.is_valid():<EOL><INDENT>return redirect('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>form = TestForm()<EOL><DEDENT>template = Template(\"<STR_LIT>\")<EOL>context = Context({'<STR_LIT>' : form})<EOL>return HttpResponse(template.render(context))<EOL>", "docstring": "Test view that returning form", "id": "f10405:m0"}
{"signature": "@any_form.register_default<EOL>def any_form_default(form_cls, **kwargs):", "body": "form_data = {}<EOL>form_files = {}<EOL>form_fields, fields_args = split_model_kwargs(kwargs)<EOL>for name, field in form_cls.base_fields.iteritems():<EOL><INDENT>if name in form_fields:<EOL><INDENT>form_data[name] = kwargs[name]<EOL><DEDENT>else:<EOL><INDENT>form_data[name] = any_form_field(field, **fields_args[name])<EOL><DEDENT><DEDENT>return form_data, form_files<EOL>", "docstring": "Returns tuple with form data and files", "id": "f10407:m0"}
{"signature": "@any_form_field.register(forms.DecimalField)<EOL>def decimal_field_data(field, **kwargs):", "body": "min_value = <NUM_LIT:0><EOL>max_value = <NUM_LIT:10><EOL>from django.core.validators import MinValueValidator, MaxValueValidator <EOL>for elem in field.validators:<EOL><INDENT>if isinstance(elem, MinValueValidator):<EOL><INDENT>min_value = elem.limit_value<EOL><DEDENT>if isinstance(elem, MaxValueValidator):<EOL><INDENT>max_value = elem.limit_value<EOL><DEDENT><DEDENT>if (field.max_digits and field.decimal_places):<EOL><INDENT>from decimal import Decimal<EOL>max_value = min(max_value,<EOL>Decimal('<STR_LIT>' % ('<STR_LIT>'*(field.max_digits-field.decimal_places),<EOL>'<STR_LIT>'*field.decimal_places)))<EOL><DEDENT>min_value = kwargs.get('<STR_LIT>') or min_value<EOL>max_value = kwargs.get('<STR_LIT>') or max_value<EOL>return str(xunit.any_decimal(min_value=min_value,<EOL>max_value=max_value,<EOL>decimal_places = field.decimal_places or <NUM_LIT:2>))<EOL>", "docstring": "Return random value for DecimalField\n\n>>> result = any_form_field(forms.DecimalField(max_value=100, min_value=11, max_digits=4, decimal_places = 2))\n>>> type(result)\n<type 'str'>\n>>> from decimal import Decimal\n>>> Decimal(result) >= 11, Decimal(result) <= Decimal('99.99')\n(True, True)", "id": "f10407:m5"}
{"signature": "@any_form_field.register(forms.models.ModelChoiceField)<EOL>def model_choice_field_data(field, **kwargs):", "body": "data = list(field.queryset[:<NUM_LIT:10>])<EOL>if data:<EOL><INDENT>return random.choice(data)<EOL><DEDENT>else:<EOL><INDENT>raise TypeError('<STR_LIT>' % field.queryset.model)<EOL><DEDENT>", "docstring": "Return one of first ten items for field queryset", "id": "f10407:m18"}
{"signature": "@any_form_field.register(forms.IPAddressField)<EOL>def ipaddress_field_data(field, **kwargs):", "body": "choices = kwargs.get('<STR_LIT>')<EOL>if choices:<EOL><INDENT>return random.choice(choices)<EOL><DEDENT>else:<EOL><INDENT>nums = [str(xunit.any_int(min_value=<NUM_LIT:0>, max_value=<NUM_LIT:255>)) for _ in xrange(<NUM_LIT:0>, <NUM_LIT:4>)]<EOL>return \"<STR_LIT:.>\".join(nums)<EOL><DEDENT>", "docstring": "Return random value for IPAddressField\n\n>>> result = any_form_field(forms.IPAddressField())\n>>> type(result)\n<type 'str'>\n>>> from django.core.validators import ipv4_re\n>>> import re\n>>> re.match(ipv4_re, result) is not None\nTrue", "id": "f10407:m11"}
{"signature": "@any_form_field.register(forms.IntegerField)<EOL>def integer_field_data(field, **kwargs):", "body": "min_value = <NUM_LIT:0><EOL>max_value = <NUM_LIT:100><EOL>from django.core.validators import MinValueValidator, MaxValueValidator <EOL>for elem in field.validators:<EOL><INDENT>if isinstance(elem, MinValueValidator):<EOL><INDENT>min_value = elem.limit_value<EOL><DEDENT>if isinstance(elem, MaxValueValidator):<EOL><INDENT>max_value = elem.limit_value<EOL><DEDENT><DEDENT>min_value = kwargs.get('<STR_LIT>', min_value)<EOL>max_value = kwargs.get('<STR_LIT>', max_value)<EOL>return str(xunit.any_int(min_value=min_value, max_value=max_value))<EOL>", "docstring": "Return random value for IntegerField\n\n>>> result = any_form_field(forms.IntegerField(max_value=200, min_value=100))\n>>> type(result)\n<type 'str'>\n>>> int(result) >=100, int(result) <=200\n(True, True)", "id": "f10407:m10"}
{"signature": "@any_form_field.register(forms.FloatField)<EOL>def float_field_data(field, **kwargs):", "body": "min_value = <NUM_LIT:0><EOL>max_value = <NUM_LIT:100><EOL>from django.core.validators import MinValueValidator, MaxValueValidator<EOL>for elem in field.validators:<EOL><INDENT>if isinstance(elem, MinValueValidator):<EOL><INDENT>min_value = elem.limit_value<EOL><DEDENT>if isinstance(elem, MaxValueValidator):<EOL><INDENT>max_value = elem.limit_value<EOL><DEDENT><DEDENT>min_value = kwargs.get('<STR_LIT>', min_value)<EOL>max_value = kwargs.get('<STR_LIT>', max_value)<EOL>precision = kwargs.get('<STR_LIT>', <NUM_LIT:3>)<EOL>return str(xunit.any_float(min_value=min_value, max_value=max_value, precision=precision))<EOL>", "docstring": "Return random value for FloatField\n\n>>> result = any_form_field(forms.FloatField(max_value=200, min_value=100))\n>>> type(result)\n<type 'str'>\n>>> float(result) >=100, float(result) <=200\n(True, True)", "id": "f10407:m9"}
{"signature": "@any_form_field.register(forms.NullBooleanField)<EOL>def null_boolean_field_data(field, **kwargs):", "body": "return random.choice(['<STR_LIT:None>', '<STR_LIT:True>', '<STR_LIT:False>'])<EOL>", "docstring": "Return random value for NullBooleanField\n\n>>> result = any_form_field(forms.NullBooleanField())\n>>> type(result)\n<type 'unicode'>\n>>> result in [u'1', u'2', u'3']\nTrue", "id": "f10407:m12"}
{"signature": "@any_form_field.register(forms.MultipleChoiceField)<EOL>def multiple_choice_field_data(field, **kwargs):", "body": "if field.choices:<EOL><INDENT>from django_any.functions import valid_choices <EOL>l = list(valid_choices(field.choices))<EOL>random.shuffle(l)<EOL>choices = []<EOL>count = xunit.any_int(min_value=<NUM_LIT:1>, max_value=len(field.choices))<EOL>for i in xrange(<NUM_LIT:0>, count):<EOL><INDENT>choices.append(l[i])<EOL><DEDENT>return '<STR_LIT:U+0020>'.join(choices)<EOL><DEDENT>return '<STR_LIT:None>'<EOL>", "docstring": "Return random value for MultipleChoiceField\n\n>>> CHOICES = [('YNG', 'Child'), ('MIDDLE', 'Parent') ,('OLD', 'GrandParent')]\n>>> result = any_form_field(forms.MultipleChoiceField(choices=CHOICES))\n>>> type(result)\n<type 'str'>", "id": "f10407:m17"}
{"signature": "def set_seed(func, seed=None):", "body": "def _wrapper(self, seed=seed, *args, **kwargs):<EOL><INDENT>self.__django_any_seed = seed if seed else int(time.time()*<NUM_LIT:1000>)<EOL>random.seed(self.__django_any_seed)<EOL>return func(self, *args, **kwargs)<EOL><DEDENT>return _wrapper<EOL>", "docstring": "Set randon seed before executing function. If seed is \nnot provided current timestamp used", "id": "f10408:m4"}
{"signature": "def valid_choices(choices):", "body": "for key, value in choices:<EOL><INDENT>if isinstance(value, (list, tuple)):<EOL><INDENT>for key, _ in value:<EOL><INDENT>yield key<EOL><DEDENT><DEDENT>else:<EOL><INDENT>yield key<EOL><DEDENT><DEDENT>", "docstring": "Return list of choices's keys", "id": "f10409:m0"}
{"signature": "def split_model_kwargs(kw):", "body": "from collections import defaultdict<EOL>model_fields = {}<EOL>fields_agrs = defaultdict(lambda : {})<EOL>for key in kw.keys():<EOL><INDENT>if '<STR_LIT>' in key:<EOL><INDENT>field, _, subfield = key.partition('<STR_LIT>')<EOL>fields_agrs[field][subfield] = kw[key]<EOL><DEDENT>else:<EOL><INDENT>model_fields[key] = kw[key]<EOL><DEDENT><DEDENT>return model_fields, fields_agrs<EOL>", "docstring": "django_any birds language parser", "id": "f10409:m1"}
{"signature": "def _create_value(self, *args, **kwargs):", "body": "if not len(args):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if self.by_instance:<EOL><INDENT>field_type = args[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>field_type = args[<NUM_LIT:0>].__class__<EOL><DEDENT>function = self.registry.get(field_type, self.default)<EOL>if function is None:<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % field_type)<EOL><DEDENT>return function(*args, **kwargs)<EOL>", "docstring": "Lowest value generator.\n\nSeparated from __call__, because it seems that python\ncache __call__ reference on module import", "id": "f10409:c0:m4"}
{"signature": "def any_string(letters = ascii_letters, min_length=<NUM_LIT:3>, max_length=<NUM_LIT:100>):", "body": "length = random.randint(min_length, max_length)<EOL>letters = [any_letter(letters=letters) for _ in range(<NUM_LIT:0>, length)]<EOL>return \"<STR_LIT>\".join(letters)<EOL>", "docstring": "Return string with random content\n\n>>> result = any_string(letters = ascii_letters, min_length=3, max_length=100)\n>>> type(result)\n<type 'str'>\n>>> len(result) in range(3,101)\nTrue\n>>> any([c in ascii_letters for c in result])\nTrue", "id": "f10411:m5"}
{"signature": "def any_int(min_value=<NUM_LIT:0>, max_value=<NUM_LIT:100>, **kwargs):", "body": "return random.randint(min_value, max_value)<EOL>", "docstring": "Return random integer from the selected range\n\n>>> result = any_int(min_value=0, max_value=100)\n>>> type(result)\n<type 'int'>\n>>> result in range(0,101)\nTrue", "id": "f10411:m2"}
{"signature": "def any_decimal(min_value=Decimal(<NUM_LIT:0>), max_value=Decimal('<STR_LIT>'), decimal_places=<NUM_LIT:2>):", "body": "return Decimal(str(any_float(min_value=float(min_value),<EOL>max_value=float(max_value),<EOL>precision=decimal_places)))<EOL>", "docstring": "Return random decimal from the [min_value, max_value] interval\n\n>>> result = any_decimal(min_value=0.999, max_value=3, decimal_places=3)\n>>> type(result)\n<class 'decimal.Decimal'>\n>>> result >= Decimal('0.999') and result <= Decimal(3)\nTrue", "id": "f10411:m8"}
{"signature": "def any_date(from_date=date(<NUM_LIT>, <NUM_LIT:1>, <NUM_LIT:1>), to_date=date.today()):", "body": "days = any_int(min_value=<NUM_LIT:0>, max_value=(to_date - from_date).days)<EOL>return from_date + timedelta(days=days)<EOL>", "docstring": "Return random date from the [from_date, to_date] interval\n\n>>> result = any_date(from_date=date(1990,1,1), to_date=date(1990,1,3))\n>>> type(result)\n<type 'datetime.date'>\n>>> result >= date(1990,1,1) and result <= date(1990,1,3)\nTrue", "id": "f10411:m6"}
{"signature": "@any_field.register(models.PositiveIntegerField)<EOL>def any_positiveinteger_field(field, **kwargs):", "body": "min_value = kwargs.get('<STR_LIT>', <NUM_LIT:1>)<EOL>max_value = kwargs.get('<STR_LIT>', <NUM_LIT>)<EOL>return xunit.any_int(min_value=min_value, max_value=max_value)<EOL>", "docstring": "An positive integer\n\n>>> result = any_field(models.PositiveIntegerField())\n>>> type(result)\n<type 'int'>\n>>> result > 0\nTrue", "id": "f10412:m4"}
{"signature": "@any_field.register(models.CharField)<EOL>def any_char_field(field, **kwargs):", "body": "min_length = kwargs.get('<STR_LIT>', <NUM_LIT:1>)<EOL>max_length = kwargs.get('<STR_LIT:max_length>', field.max_length)<EOL>return xunit.any_string(min_length=min_length, max_length=max_length)<EOL>", "docstring": "Return random value for CharField\n\n>>> result = any_field(models.CharField(max_length=10))\n>>> type(result)\n<type 'str'>", "id": "f10412:m5"}
{"signature": "@any_field.register(models.SmallIntegerField)<EOL>def any_smallinteger_field(field, **kwargs):", "body": "min_value = kwargs.get('<STR_LIT>', -<NUM_LIT:255>)<EOL>max_value = kwargs.get('<STR_LIT>', <NUM_LIT:255>)<EOL>return xunit.any_int(min_value=min_value, max_value=max_value)<EOL>", "docstring": "Return random value for SmallIntegerValue\n>>> result = any_field(models.SmallIntegerField())\n>>> type(result)\n<type 'int'>\n>>> result > -256, result < 256\n(True, True)", "id": "f10412:m18"}
{"signature": "@any_field.decorator<EOL>def any_field_blank(function):", "body": "def wrapper(field, **kwargs):<EOL><INDENT>if kwargs.get('<STR_LIT>', False):<EOL><INDENT>return None<EOL><DEDENT>if field.blank and random.random < <NUM_LIT:0.1>:<EOL><INDENT>return None<EOL><DEDENT>return function(field, **kwargs)<EOL><DEDENT>return wrapper<EOL>", "docstring": "Sometimes return None if field could be blank", "id": "f10412:m0"}
{"signature": "@any_field.register(models.FilePathField)<EOL>def any_filepath_field(field, **kwargs):", "body": "def get_some_file(path):<EOL><INDENT>subdirs, files = [], []<EOL>for entry in os.listdir(path):<EOL><INDENT>entry_path = os.path.join(path, entry)<EOL>if os.path.isdir(entry_path):<EOL><INDENT>subdirs.append(entry_path)<EOL><DEDENT>else:<EOL><INDENT>if not field.match or re.match(field.match,entry):<EOL><INDENT>files.append(entry_path)<EOL><DEDENT><DEDENT><DEDENT>if files:<EOL><INDENT>return random.choice(files)<EOL><DEDENT>if field.recursive:<EOL><INDENT>for subdir in subdirs:<EOL><INDENT>result = get_some_file(subdir)<EOL>if result:<EOL><INDENT>return result<EOL><DEDENT><DEDENT><DEDENT><DEDENT>result = get_some_file(field.path)<EOL>if result is None and not field.null:<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % field.path)<EOL><DEDENT>return result<EOL>", "docstring": "Lookup for nearest existing file", "id": "f10412:m13"}
{"signature": "@any_field.register(models.SlugField)<EOL>def any_slug_field(field, **kwargs):", "body": "letters = ascii_letters + digits + '<STR_LIT>'<EOL>return xunit.any_string(letters = letters, max_length = field.max_length)<EOL>", "docstring": "Return random value for SlugField\n>>> result = any_field(models.SlugField())\n>>> type(result)\n<type 'str'>\n>>> from django.core.validators import slug_re\n>>> re.match(slug_re, result) is not None\nTrue", "id": "f10412:m17"}
{"signature": "@any_field.register(models.CommaSeparatedIntegerField)<EOL>def any_commaseparatedinteger_field(field, **kwargs):", "body": "nums_count = field.max_length/<NUM_LIT:2><EOL>nums = [str(xunit.any_int(min_value=<NUM_LIT:0>, max_value=<NUM_LIT:9>)) for _ in xrange(<NUM_LIT:0>, nums_count)]<EOL>return \"<STR_LIT:U+002C>\".join(nums)<EOL>", "docstring": "Return random value for CharField\n\n>>> result = any_field(models.CommaSeparatedIntegerField(max_length=10))\n>>> type(result)\n<type 'str'>\n>>> [int(num) for num in result.split(',')] and 'OK'\n'OK'", "id": "f10412:m6"}
{"signature": "def cancelAll(self):", "body": "cancel = self.cancel<EOL>result = []<EOL>for block, _ in self._submitted.itervalues():<EOL><INDENT>try:<EOL><INDENT>result.append(cancel(block))<EOL><DEDENT>except OSError as exc:<EOL><INDENT>if exc.errno != errno.EINVAL:<EOL><INDENT>raise<EOL><DEDENT><DEDENT><DEDENT>return result<EOL>", "docstring": "Cancel all submitted IO blocks.\n\nBlocks until all submitted transfers have been finalised.\nSubmitting more transfers or processing completion events while this\nmethod is running produces undefined behaviour.\nReturns the list of values returned by individual cancellations.\nSee \"cancel\" documentation.", "id": "f10417:c2:m8"}
{"signature": "def __del__(self):", "body": "self.close()<EOL>", "docstring": "Calls close, in case instance was not properly closed by the time it\ngets garbage-collected.", "id": "f10417:c2:m4"}
{"signature": "@property<EOL><INDENT>def io_priority(self):<DEDENT>", "body": "return (<EOL>self._iocb.aio_reqprio<EOL>if self._iocb.u.c.flags & libaio.IOCB_FLAG_IOPRIO else<EOL>None<EOL>)<EOL>", "docstring": "IO priority for this instance.", "id": "f10417:c1:m13"}
{"signature": "def close(self):", "body": "if self._ctx is not None:<EOL><INDENT>self._io_queue_release(self._ctx)<EOL>del self._ctx<EOL><DEDENT>", "docstring": "Cancels all pending IO blocks.\nWaits until all non-cancellable IO blocks finish.\nDe-initialises AIO context.", "id": "f10417:c2:m1"}
{"signature": "def __init__(self, maxevents):", "body": "self._maxevents = maxevents<EOL>self._submitted = {}<EOL>self._io_queue_release = libaio.io_queue_release<EOL>ctx = libaio.io_context_t()<EOL>libaio.io_queue_init(self._maxevents, byref(ctx))<EOL>self._ctx = ctx<EOL>", "docstring": "maxevents (int)\n    Maximum number of events this context will have to handle.", "id": "f10417:c2:m0"}
{"signature": "def read(self):", "body": "return unpack('<STR_LIT>', self._file.read(<NUM_LIT:8>))[<NUM_LIT:0>]<EOL>", "docstring": "Read current counter value.\n\nSee manpage for flags effect on this.", "id": "f10417:c0:m4"}
{"signature": "@property<EOL><INDENT>def offset(self):<DEDENT>", "body": "return self._iocb.u.c.offset.value<EOL>", "docstring": "The file offset this instance writes to/reads from.\n\nOnly available in mode != AIOBLOCK_MODE_POLL.", "id": "f10417:c1:m9"}
{"signature": "def cancel(self, block):", "body": "event = libaio.io_event()<EOL>try:<EOL><INDENT>libaio.io_cancel(self._ctx, byref(block._iocb), byref(event))<EOL><DEDENT>except OSError as exc:<EOL><INDENT>if exc.errno == errno.EINPROGRESS:<EOL><INDENT>return None<EOL><DEDENT>raise<EOL><DEDENT>return self._eventToPython(event)<EOL>", "docstring": "Cancel an IO block.\n\nblock (AIOBlock)\n    The IO block to cancel.\n\nReturns cancelled block's event data (see getEvents), or None if the\nkernel returned EINPROGRESS. In the latter case, event completion will\nhappen on a later getEvents call.", "id": "f10417:c2:m7"}
{"signature": "def detect():", "body": "compiler = new_compiler()<EOL>hasopenmp = hasfunction(compiler, '<STR_LIT>')<EOL>needs_gomp = hasopenmp<EOL>if not hasopenmp:<EOL><INDENT>compiler.add_library('<STR_LIT>')<EOL><DEDENT>hasopenmp = hasfunction(compiler, '<STR_LIT>')<EOL>needs_gomp = hasopenmp<EOL>return hasopenmp<EOL>", "docstring": "Does this compiler support OpenMP parallelization?", "id": "f10421:m0"}
{"signature": "def db_file_widget(cls):", "body": "def get_link_display(url):<EOL><INDENT>unquoted = unquote(url.split('<STR_LIT>')[-<NUM_LIT:1>])<EOL>if sys.version_info.major == <NUM_LIT:2>:  <EOL><INDENT>from django.utils.encoding import force_unicode<EOL>unquoted = force_unicode(unquoted)<EOL><DEDENT>return escape(unquoted)<EOL><DEDENT>def get_template_substitution_values(self, value):<EOL><INDENT>subst = super(cls, self).get_template_substitution_values(value)<EOL>subst['<STR_LIT>'] = get_link_display(value.url)<EOL>return subst<EOL><DEDENT>setattr(cls,<EOL>'<STR_LIT>',<EOL>get_template_substitution_values)<EOL>def get_context(self, name, value, attrs):<EOL><INDENT>context = super(cls, self).get_context(name, value, attrs)<EOL>if value and hasattr(value, '<STR_LIT:url>'):<EOL><INDENT>context['<STR_LIT>']['<STR_LIT>'] = get_link_display(value.url)<EOL><DEDENT>return context<EOL><DEDENT>setattr(cls, '<STR_LIT>', get_context)<EOL>return cls<EOL>", "docstring": "Edit the download-link inner text.", "id": "f10435:m0"}
{"signature": "def new_generator(self):", "body": "return self.generator_function(**self.arguments)<EOL>", "docstring": "Create a new generator object.", "id": "f10498:c0:m3"}
{"signature": "def __repr__(self):", "body": "class_str = self.__class__.__name__<EOL>json_str = json.dumps(self.__dict__, ensure_ascii=False)<EOL>return \"<STR_LIT>\".format(class_str, repr(json_str))<EOL>", "docstring": "A string representing this object as valid Python expression.", "id": "f10499:c0:m2"}
{"signature": "def __str__(self):", "body": "return json.dumps(self.__dict__, ensure_ascii=False, indent=<NUM_LIT:4>)<EOL>", "docstring": "A human-readable string representation of this object.", "id": "f10499:c0:m1"}
{"signature": "def simple_data_factory(model, json_data):", "body": "return SimpleDataModel(json_data)<EOL>", "docstring": "Factory function for creating SimpleDataModel objects.\n\n    Args:\n        model(basestring): The data model to use when creating the data\n            object (message, room, membership, etc.).\n        json_data(basestring, dict): The JSON string or dictionary data with\n            which to initialize the object.\n\n    Returns:\n        SimpleDataModel: The created SimpleDataModel object.\n\n    Raises:\n        TypeError: If the json_data parameter is not a JSON string or\n            dictionary.", "id": "f10499:m0"}
{"signature": "@property<EOL><INDENT>def id(self):<DEDENT>", "body": "return self._json_data.get('<STR_LIT:id>')<EOL>", "docstring": "The unique ID for the Organization.", "id": "f10501:c0:m0"}
{"signature": "@property<EOL><INDENT>def displayName(self):<DEDENT>", "body": "return self._json_data.get('<STR_LIT>')<EOL>", "docstring": "The human-friendly display name of the Organization.", "id": "f10501:c0:m1"}
{"signature": "@property<EOL><INDENT>def name(self):<DEDENT>", "body": "return self._json_data.get('<STR_LIT:name>')<EOL>", "docstring": "The name of the Role.", "id": "f10502:c0:m1"}
{"signature": "@property<EOL><INDENT>def name(self):<DEDENT>", "body": "return self._json_data.get('<STR_LIT:name>')<EOL>", "docstring": "The name of the License.", "id": "f10503:c0:m1"}
{"signature": "@property<EOL><INDENT>def totalUnits(self):<DEDENT>", "body": "return self._json_data.get('<STR_LIT>')<EOL>", "docstring": "The total number of license units.", "id": "f10503:c0:m2"}
{"signature": "@property<EOL><INDENT>def ownedBy(self):<DEDENT>", "body": "return self._json_data.get('<STR_LIT>')<EOL>", "docstring": "Indicates if the webhook is owned by the `org` or the `creator`.\n\n        Webhooks owned by the creator can only receive events that are\n        accessible to the creator of the webhook. Those owned by the\n        organization will receive events that are visible to anyone in the\n        organization.", "id": "f10505:c0:m8"}
{"signature": "@property<EOL><INDENT>def name(self):<DEDENT>", "body": "return self._json_data.get('<STR_LIT:name>')<EOL>", "docstring": "A user-friendly name for this webhook.", "id": "f10505:c0:m1"}
{"signature": "@property<EOL><INDENT>def orgId(self):<DEDENT>", "body": "return self._json_data.get('<STR_LIT>')<EOL>", "docstring": "The ID of the organization that owns the webhook.", "id": "f10505:c0:m5"}
{"signature": "@property<EOL><INDENT>def personId(self):<DEDENT>", "body": "return self._json_data.get('<STR_LIT>')<EOL>", "docstring": "The ID of the person.", "id": "f10506:c0:m2"}
{"signature": "@property<EOL><INDENT>def created(self):<DEDENT>", "body": "created = self._json_data.get('<STR_LIT>')<EOL>if created:<EOL><INDENT>return WebexTeamsDateTime.strptime(created)<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "The date and time when the room was created.", "id": "f10508:c0:m5"}
{"signature": "@property<EOL><INDENT>def teamId(self):<DEDENT>", "body": "return self._json_data.get('<STR_LIT>')<EOL>", "docstring": "The ID for the team with which this room is associated.", "id": "f10508:c0:m7"}
{"signature": "@property<EOL><INDENT>def type(self):<DEDENT>", "body": "return self._json_data.get('<STR_LIT:type>')<EOL>", "docstring": "The type of room (i.e. 'group', 'direct' etc.).", "id": "f10508:c0:m2"}
{"signature": "@property<EOL><INDENT>def invitePending(self):<DEDENT>", "body": "return self._json_data.get('<STR_LIT>')<EOL>", "docstring": "Person has been sent an invite, but hasn't responded.", "id": "f10509:c0:m14"}
{"signature": "@property<EOL><INDENT>def status(self):<DEDENT>", "body": "return self._json_data.get('<STR_LIT:status>')<EOL>", "docstring": "The person's current status.", "id": "f10509:c0:m12"}
{"signature": "@property<EOL><INDENT>def licenses(self):<DEDENT>", "body": "return self._json_data.get('<STR_LIT>')<EOL>", "docstring": "Licenses allocated to the person.", "id": "f10509:c0:m10"}
{"signature": "@property<EOL><INDENT>def appId(self):<DEDENT>", "body": "return self._json_data.get('<STR_LIT>')<EOL>", "docstring": "Identifies the application that added the webhook.", "id": "f10510:c0:m9"}
{"signature": "@property<EOL><INDENT>def created(self):<DEDENT>", "body": "created = self._json_data.get('<STR_LIT>')<EOL>if created:<EOL><INDENT>return WebexTeamsDateTime.strptime(created)<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Creation date and time in ISO8601 format.", "id": "f10510:c0:m12"}
{"signature": "@property<EOL><INDENT>def name(self):<DEDENT>", "body": "return self._json_data.get('<STR_LIT:name>')<EOL>", "docstring": "A user-friendly name for this webhook.", "id": "f10510:c0:m1"}
{"signature": "@property<EOL><INDENT>def isModerator(self):<DEDENT>", "body": "return self._json_data.get('<STR_LIT>')<EOL>", "docstring": "Person is a moderator for the team.", "id": "f10512:c0:m6"}
{"signature": "@property<EOL><INDENT>def personOrgId(self):<DEDENT>", "body": "return self._json_data.get('<STR_LIT>')<EOL>", "docstring": "The ID of the organization that the person is associated with.", "id": "f10512:c0:m5"}
{"signature": "@property<EOL><INDENT>def teamId(self):<DEDENT>", "body": "return self._json_data.get('<STR_LIT>')<EOL>", "docstring": "The ID of the team.", "id": "f10512:c0:m1"}
{"signature": "@property<EOL><INDENT>def personEmail(self):<DEDENT>", "body": "return self._json_data.get('<STR_LIT>')<EOL>", "docstring": "The email address of the person.", "id": "f10512:c0:m3"}
{"signature": "@property<EOL><INDENT>def id(self):<DEDENT>", "body": "return self._json_data.get('<STR_LIT:id>')<EOL>", "docstring": "The message's unique ID.", "id": "f10513:c0:m0"}
{"signature": "@property<EOL><INDENT>def roomId(self):<DEDENT>", "body": "return self._json_data.get('<STR_LIT>')<EOL>", "docstring": "The ID of the room.", "id": "f10513:c0:m1"}
{"signature": "@property<EOL><INDENT>def roomType(self):<DEDENT>", "body": "return self._json_data.get('<STR_LIT>')<EOL>", "docstring": "The type of room (i.e. 'group', 'direct' etc.).", "id": "f10513:c0:m2"}
{"signature": "@property<EOL><INDENT>def personEmail(self):<DEDENT>", "body": "return self._json_data.get('<STR_LIT>')<EOL>", "docstring": "The email address of the sender.", "id": "f10513:c0:m6"}
{"signature": "@property<EOL><INDENT>def id(self):<DEDENT>", "body": "return self._json_data.get('<STR_LIT:id>')<EOL>", "docstring": "Event ID.", "id": "f10514:c0:m0"}
{"signature": "@property<EOL><INDENT>def created(self):<DEDENT>", "body": "created = self._json_data.get('<STR_LIT>')<EOL>if created:<EOL><INDENT>return WebexTeamsDateTime.strptime(created)<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "The date and time the event was performed.", "id": "f10514:c0:m4"}
{"signature": "@property<EOL><INDENT>def type(self):<DEDENT>", "body": "return self._json_data.get('<STR_LIT:type>')<EOL>", "docstring": "The event type (`created`, `updated`, `deleted`).", "id": "f10514:c0:m2"}
{"signature": "def to_dict(self):", "body": "return dict(self._json_data)<EOL>", "docstring": "Convert the Webex Teams object data to a dictionary.", "id": "f10515:c0:m9"}
{"signature": "@property<EOL><INDENT>def json_data(self):<DEDENT>", "body": "<EOL>return self._json_data.copy()<EOL>", "docstring": "A copy of the data object's JSON data (OrderedDict).", "id": "f10515:c0:m8"}
{"signature": "def __init__(self, json_data):", "body": "super(ImmutableData, self).__init__()<EOL>self._json_data = json_dict(json_data)<EOL>", "docstring": "Init a new ImmutableData object from a dictionary or JSON string.\n\n        Args:\n            json_data(dict, basestring): Input JSON string or dictionary.\n\n        Raises:\n            TypeError: If the input object is not a dictionary or string.", "id": "f10515:c0:m0"}
{"signature": "@property<EOL><INDENT>def data(self):<DEDENT>", "body": "return ImmutableData(self._json_data.get('<STR_LIT:data>'))<EOL>", "docstring": "The event resource data.", "id": "f10515:c13:m0"}
{"signature": "def versions_from_parentdir(parentdir_prefix, root, verbose):", "body": "rootdirs = []<EOL>for i in range(<NUM_LIT:3>):<EOL><INDENT>dirname = os.path.basename(root)<EOL>if dirname.startswith(parentdir_prefix):<EOL><INDENT>return {\"<STR_LIT:version>\": dirname[len(parentdir_prefix):],<EOL>\"<STR_LIT>\": None,<EOL>\"<STR_LIT>\": False, \"<STR_LIT:error>\": None, \"<STR_LIT:date>\": None}<EOL><DEDENT>else:<EOL><INDENT>rootdirs.append(root)<EOL>root = os.path.dirname(root)  <EOL><DEDENT><DEDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" %<EOL>(str(rootdirs), parentdir_prefix))<EOL><DEDENT>raise NotThisMethod(\"<STR_LIT>\")<EOL>", "docstring": "Try to determine the version from the parent directory name.\n\n    Source tarballs conventionally unpack into a directory that includes both\n    the project name and a version string. We will also support searching up\n    two directory levels for an appropriately named parent directory", "id": "f10516:m4"}
{"signature": "@register_vcs_handler(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>def git_get_keywords(versionfile_abs):", "body": "<EOL>keywords = {}<EOL>try:<EOL><INDENT>f = open(versionfile_abs, \"<STR_LIT:r>\")<EOL>for line in f.readlines():<EOL><INDENT>if line.strip().startswith(\"<STR_LIT>\"):<EOL><INDENT>mo = re.search(r'<STR_LIT>', line)<EOL>if mo:<EOL><INDENT>keywords[\"<STR_LIT>\"] = mo.group(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>if line.strip().startswith(\"<STR_LIT>\"):<EOL><INDENT>mo = re.search(r'<STR_LIT>', line)<EOL>if mo:<EOL><INDENT>keywords[\"<STR_LIT>\"] = mo.group(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>if line.strip().startswith(\"<STR_LIT>\"):<EOL><INDENT>mo = re.search(r'<STR_LIT>', line)<EOL>if mo:<EOL><INDENT>keywords[\"<STR_LIT:date>\"] = mo.group(<NUM_LIT:1>)<EOL><DEDENT><DEDENT><DEDENT>f.close()<EOL><DEDENT>except EnvironmentError:<EOL><INDENT>pass<EOL><DEDENT>return keywords<EOL>", "docstring": "Extract version information from the given file.", "id": "f10516:m5"}
{"signature": "def render_pep440_pre(pieces):", "body": "if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered = pieces[\"<STR_LIT>\"]<EOL>if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += \"<STR_LIT>\" % pieces[\"<STR_LIT>\"]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>rendered = \"<STR_LIT>\" % pieces[\"<STR_LIT>\"]<EOL><DEDENT>return rendered<EOL>", "docstring": "TAG[.post.devDISTANCE] -- No -dirty.\n\n    Exceptions:\n    1: no tags. 0.post.devDISTANCE", "id": "f10516:m10"}
{"signature": "def get_keywords():", "body": "<EOL>git_refnames = \"<STR_LIT>\"<EOL>git_full = \"<STR_LIT>\"<EOL>git_date = \"<STR_LIT>\"<EOL>keywords = {\"<STR_LIT>\": git_refnames, \"<STR_LIT>\": git_full, \"<STR_LIT:date>\": git_date}<EOL>return keywords<EOL>", "docstring": "Get the keywords needed to look up the version information.", "id": "f10516:m0"}
{"signature": "def render_git_describe(pieces):", "body": "if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered = pieces[\"<STR_LIT>\"]<EOL>if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += \"<STR_LIT>\" % (pieces[\"<STR_LIT>\"], pieces[\"<STR_LIT>\"])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>rendered = pieces[\"<STR_LIT>\"]<EOL><DEDENT>if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += \"<STR_LIT>\"<EOL><DEDENT>return rendered<EOL>", "docstring": "TAG[-DISTANCE-gHEX][-dirty].\n\n    Like 'git describe --tags --dirty --always'.\n\n    Exceptions:\n    1: no tags. HEX[-dirty]  (note: no 'g' prefix)", "id": "f10516:m13"}
{"signature": "def render(pieces, style):", "body": "if pieces[\"<STR_LIT:error>\"]:<EOL><INDENT>return {\"<STR_LIT:version>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": pieces.get(\"<STR_LIT>\"),<EOL>\"<STR_LIT>\": None,<EOL>\"<STR_LIT:error>\": pieces[\"<STR_LIT:error>\"],<EOL>\"<STR_LIT:date>\": None}<EOL><DEDENT>if not style or style == \"<STR_LIT:default>\":<EOL><INDENT>style = \"<STR_LIT>\"  <EOL><DEDENT>if style == \"<STR_LIT>\":<EOL><INDENT>rendered = render_pep440(pieces)<EOL><DEDENT>elif style == \"<STR_LIT>\":<EOL><INDENT>rendered = render_pep440_pre(pieces)<EOL><DEDENT>elif style == \"<STR_LIT>\":<EOL><INDENT>rendered = render_pep440_post(pieces)<EOL><DEDENT>elif style == \"<STR_LIT>\":<EOL><INDENT>rendered = render_pep440_old(pieces)<EOL><DEDENT>elif style == \"<STR_LIT>\":<EOL><INDENT>rendered = render_git_describe(pieces)<EOL><DEDENT>elif style == \"<STR_LIT>\":<EOL><INDENT>rendered = render_git_describe_long(pieces)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % style)<EOL><DEDENT>return {\"<STR_LIT:version>\": rendered, \"<STR_LIT>\": pieces[\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": pieces[\"<STR_LIT>\"], \"<STR_LIT:error>\": None,<EOL>\"<STR_LIT:date>\": pieces.get(\"<STR_LIT:date>\")}<EOL>", "docstring": "Render the given version pieces into the requested style.", "id": "f10516:m15"}
{"signature": "def get(self, licenseId):", "body": "check_type(licenseId, basestring, may_be_none=False)<EOL>json_data = self._session.get(API_ENDPOINT + '<STR_LIT:/>' + licenseId)<EOL>return self._object_factory(OBJECT_TYPE, json_data)<EOL>", "docstring": "Get the details of a License, by ID.\n\n        Args:\n            licenseId(basestring): The ID of the License to be retrieved.\n\n        Returns:\n            License: A License object with the details of the requested\n            License.\n\n        Raises:\n            TypeError: If the parameter types are incorrect.\n            ApiError: If the Webex Teams cloud returns an error.", "id": "f10519:c0:m2"}
{"signature": "def refresh(self, client_id, client_secret, refresh_token):", "body": "check_type(client_id, basestring, may_be_none=False)<EOL>check_type(client_secret, basestring, may_be_none=False)<EOL>check_type(refresh_token, basestring, may_be_none=False)<EOL>post_data = dict_from_items_with_values(<EOL>grant_type=\"<STR_LIT>\",<EOL>client_id=client_id,<EOL>client_secret=client_secret,<EOL>refresh_token=refresh_token,<EOL>)<EOL>response = requests.post(self._endpoint_url, data=post_data,<EOL>**self._request_kwargs)<EOL>check_response_code(response, EXPECTED_RESPONSE_CODE['<STR_LIT:POST>'])<EOL>json_data = extract_and_parse_json(response)<EOL>return self._object_factory(OBJECT_TYPE, json_data)<EOL>", "docstring": "Return a refreshed Access Token from the provided refresh_token.\n\n        Args:\n            client_id(basestring): Provided when you created your integration.\n            client_secret(basestring): Provided when you created your\n                integration.\n            refresh_token(basestring): Provided when you requested the Access\n                Token.\n\n        Returns:\n            AccessToken: With the access token provided by the Webex Teams\n            cloud.\n\n        Raises:\n            TypeError: If the parameter types are incorrect.\n            ApiError: If the Webex Teams cloud returns an error.", "id": "f10520:c0:m4"}
{"signature": "def delete(self, personId):", "body": "check_type(personId, basestring, may_be_none=False)<EOL>self._session.delete(API_ENDPOINT + '<STR_LIT:/>' + personId)<EOL>", "docstring": "Remove a person from the system.\n\n        Only an admin can remove a person.\n\n        Args:\n            personId(basestring): The ID of the person to be deleted.\n\n        Raises:\n            TypeError: If the parameter types are incorrect.\n            ApiError: If the Webex Teams cloud returns an error.", "id": "f10521:c0:m5"}
{"signature": "@generator_container<EOL><INDENT>def list(self, email=None, displayName=None, id=None, orgId=None, max=None,<EOL>**request_parameters):<DEDENT>", "body": "check_type(id, basestring)<EOL>check_type(email, basestring)<EOL>check_type(displayName, basestring)<EOL>check_type(orgId, basestring)<EOL>check_type(max, int)<EOL>params = dict_from_items_with_values(<EOL>request_parameters,<EOL>id=id,<EOL>email=email,<EOL>displayName=displayName,<EOL>orgId=orgId,<EOL>max=max,<EOL>)<EOL>items = self._session.get_items(API_ENDPOINT, params=params)<EOL>for item in items:<EOL><INDENT>yield self._object_factory(OBJECT_TYPE, item)<EOL><DEDENT>", "docstring": "List people\n\n        This method supports Webex Teams's implementation of RFC5988 Web\n        Linking to provide pagination support.  It returns a generator\n        container that incrementally yields all people returned by the\n        query.  The generator will automatically request additional 'pages' of\n        responses from Webex as needed until all responses have been returned.\n        The container makes the generator safe for reuse.  A new API call will\n        be made, using the same parameters that were specified when the\n        generator was created, every time a new iterator is requested from the\n        container.\n\n        Args:\n            email(basestring): The e-mail address of the person to be found.\n            displayName(basestring): The complete or beginning portion of\n                the displayName to be searched.\n            id(basestring): List people by ID. Accepts up to 85 person IDs\n                separated by commas.\n            orgId(basestring): The organization ID.\n            max(int): Limit the maximum number of items returned from the Webex\n                Teams service per request.\n            **request_parameters: Additional request parameters (provides\n                support for parameters that may be added in the future).\n\n        Returns:\n            GeneratorContainer: A GeneratorContainer which, when iterated,\n            yields the people returned by the Webex Teams query.\n\n        Raises:\n            TypeError: If the parameter types are incorrect.\n            ApiError: If the Webex Teams cloud returns an error.", "id": "f10521:c0:m1"}
{"signature": "def delete(self, messageId):", "body": "check_type(messageId, basestring, may_be_none=False)<EOL>self._session.delete(API_ENDPOINT + '<STR_LIT:/>' + messageId)<EOL>", "docstring": "Delete a message.\n\n        Args:\n            messageId(basestring): The ID of the message to be deleted.\n\n        Raises:\n            TypeError: If the parameter types are incorrect.\n            ApiError: If the Webex Teams cloud returns an error.", "id": "f10523:c0:m4"}
{"signature": "@generator_container<EOL><INDENT>def list(self, roomId, mentionedPeople=None, before=None,<EOL>beforeMessage=None, max=None, **request_parameters):<DEDENT>", "body": "check_type(roomId, basestring, may_be_none=False)<EOL>check_type(mentionedPeople, basestring)<EOL>check_type(before, basestring)<EOL>check_type(beforeMessage, basestring)<EOL>check_type(max, int)<EOL>params = dict_from_items_with_values(<EOL>request_parameters,<EOL>roomId=roomId,<EOL>mentionedPeople=mentionedPeople,<EOL>before=before,<EOL>beforeMessage=beforeMessage,<EOL>max=max,<EOL>)<EOL>items = self._session.get_items(API_ENDPOINT, params=params)<EOL>for item in items:<EOL><INDENT>yield self._object_factory(OBJECT_TYPE, item)<EOL><DEDENT>", "docstring": "Lists messages in a room.\n\n        Each message will include content attachments if present.\n\n        The list API sorts the messages in descending order by creation date.\n\n        This method supports Webex Teams's implementation of RFC5988 Web\n        Linking to provide pagination support.  It returns a generator\n        container that incrementally yields all messages returned by the\n        query.  The generator will automatically request additional 'pages' of\n        responses from Webex as needed until all responses have been returned.\n        The container makes the generator safe for reuse.  A new API call will\n        be made, using the same parameters that were specified when the\n        generator was created, every time a new iterator is requested from the\n        container.\n\n        Args:\n            roomId(basestring): List messages for a room, by ID.\n            mentionedPeople(basestring): List messages where the caller is\n                mentioned by specifying \"me\" or the caller `personId`.\n            before(basestring): List messages sent before a date and time, in\n                ISO8601 format.\n            beforeMessage(basestring): List messages sent before a message,\n                by ID.\n            max(int): Limit the maximum number of items returned from the Webex\n                Teams service per request.\n            **request_parameters: Additional request parameters (provides\n                support for parameters that may be added in the future).\n\n        Returns:\n            GeneratorContainer: A GeneratorContainer which, when iterated,\n            yields the messages returned by the Webex Teams query.\n\n        Raises:\n            TypeError: If the parameter types are incorrect.\n            ApiError: If the Webex Teams cloud returns an error.", "id": "f10523:c0:m1"}
{"signature": "def delete(self, webhookId):", "body": "check_type(webhookId, basestring, may_be_none=False)<EOL>self._session.delete(API_ENDPOINT + '<STR_LIT:/>' + webhookId)<EOL>", "docstring": "Delete a webhook, by ID.\n\n        Args:\n            webhookId(basestring): The ID of the webhook to be deleted.\n\n        Raises:\n            TypeError: If the parameter types are incorrect.\n            ApiError: If the Webex Teams cloud returns an error.", "id": "f10525:c0:m5"}
{"signature": "def create(self, name, targetUrl, resource, event,<EOL>filter=None, secret=None, **request_parameters):", "body": "check_type(name, basestring, may_be_none=False)<EOL>check_type(targetUrl, basestring, may_be_none=False)<EOL>check_type(resource, basestring, may_be_none=False)<EOL>check_type(event, basestring, may_be_none=False)<EOL>check_type(filter, basestring)<EOL>check_type(secret, basestring)<EOL>post_data = dict_from_items_with_values(<EOL>request_parameters,<EOL>name=name,<EOL>targetUrl=targetUrl,<EOL>resource=resource,<EOL>event=event,<EOL>filter=filter,<EOL>secret=secret,<EOL>)<EOL>json_data = self._session.post(API_ENDPOINT, json=post_data)<EOL>return self._object_factory(OBJECT_TYPE, json_data)<EOL>", "docstring": "Create a webhook.\n\n        Args:\n            name(basestring): A user-friendly name for this webhook.\n            targetUrl(basestring): The URL that receives POST requests for\n                each event.\n            resource(basestring): The resource type for the webhook.\n            event(basestring): The event type for the webhook.\n            filter(basestring): The filter that defines the webhook scope.\n            secret(basestring): The secret used to generate payload signature.\n            **request_parameters: Additional request parameters (provides\n                support for parameters that may be added in the future).\n\n        Returns:\n            Webhook: A Webhook object with the details of the created webhook.\n\n        Raises:\n            TypeError: If the parameter types are incorrect.\n            ApiError: If the Webex Teams cloud returns an error.", "id": "f10525:c0:m2"}
{"signature": "@generator_container<EOL><INDENT>def list(self, max=None, **request_parameters):<DEDENT>", "body": "check_type(max, int)<EOL>params = dict_from_items_with_values(<EOL>request_parameters,<EOL>max=max,<EOL>)<EOL>items = self._session.get_items(API_ENDPOINT, params=params)<EOL>for item in items:<EOL><INDENT>yield self._object_factory(OBJECT_TYPE, item)<EOL><DEDENT>", "docstring": "List all of the authenticated user's webhooks.\n\n        This method supports Webex Teams's implementation of RFC5988 Web\n        Linking to provide pagination support.  It returns a generator\n        container that incrementally yields all webhooks returned by the\n        query.  The generator will automatically request additional 'pages' of\n        responses from Webex as needed until all responses have been returned.\n        The container makes the generator safe for reuse.  A new API call will\n        be made, using the same parameters that were specified when the\n        generator was created, every time a new iterator is requested from the\n        container.\n\n        Args:\n            max(int): Limit the maximum number of items returned from the Webex\n                Teams service per request.\n            **request_parameters: Additional request parameters (provides\n                support for parameters that may be added in the future).\n\n        Returns:\n            GeneratorContainer: A GeneratorContainer which, when iterated,\n            yields the webhooks returned by the Webex Teams query.\n\n        Raises:\n            TypeError: If the parameter types are incorrect.\n            ApiError: If the Webex Teams cloud returns an error.", "id": "f10525:c0:m1"}
{"signature": "def update(self, webhookId, name=None, targetUrl=None,<EOL>**request_parameters):", "body": "check_type(webhookId, basestring, may_be_none=False)<EOL>check_type(name, basestring)<EOL>check_type(targetUrl, basestring)<EOL>put_data = dict_from_items_with_values(<EOL>request_parameters,<EOL>name=name,<EOL>targetUrl=targetUrl,<EOL>)<EOL>json_data = self._session.put(API_ENDPOINT + '<STR_LIT:/>' + webhookId,<EOL>json=put_data)<EOL>return self._object_factory(OBJECT_TYPE, json_data)<EOL>", "docstring": "Update a webhook, by ID.\n\n        Args:\n            webhookId(basestring): The webhook ID.\n            name(basestring): A user-friendly name for this webhook.\n            targetUrl(basestring): The URL that receives POST requests for\n                each event.\n            **request_parameters: Additional request parameters (provides\n                support for parameters that may be added in the future).\n\n        Returns:\n            Webhook: A Webhook object with the updated Webex Teams webhook\n                details.\n\n        Raises:\n            TypeError: If the parameter types are incorrect.\n            ApiError: If the Webex Teams cloud returns an error.", "id": "f10525:c0:m4"}
{"signature": "def __init__(self, access_token=None, base_url=DEFAULT_BASE_URL,<EOL>single_request_timeout=DEFAULT_SINGLE_REQUEST_TIMEOUT,<EOL>wait_on_rate_limit=DEFAULT_WAIT_ON_RATE_LIMIT,<EOL>object_factory=immutable_data_factory,<EOL>client_id=None,<EOL>client_secret=None,<EOL>oauth_code=None,<EOL>redirect_uri=None):", "body": "check_type(access_token, basestring)<EOL>check_type(base_url, basestring)<EOL>check_type(single_request_timeout, int)<EOL>check_type(wait_on_rate_limit, bool)<EOL>check_type(client_id, basestring, may_be_none=True)<EOL>check_type(client_secret, basestring, may_be_none=True)<EOL>check_type(oauth_code, basestring, may_be_none=True)<EOL>check_type(redirect_uri, basestring, may_be_none=True)<EOL>access_token = access_token or WEBEX_TEAMS_ACCESS_TOKEN<EOL>self.access_tokens = AccessTokensAPI(<EOL>base_url, object_factory,<EOL>single_request_timeout=single_request_timeout,<EOL>)<EOL>oauth_param_list = [client_id, client_secret, oauth_code, redirect_uri]<EOL>if not access_token and all(oauth_param_list):<EOL><INDENT>access_token = self.access_tokens.get(<EOL>client_id=client_id,<EOL>client_secret=client_secret,<EOL>code=oauth_code,<EOL>redirect_uri=redirect_uri<EOL>).access_token<EOL><DEDENT>if not access_token:<EOL><INDENT>raise AccessTokenError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>self._session = RestSession(<EOL>access_token=access_token,<EOL>base_url=base_url,<EOL>single_request_timeout=single_request_timeout,<EOL>wait_on_rate_limit=wait_on_rate_limit<EOL>)<EOL>self.people = PeopleAPI(self._session, object_factory)<EOL>self.rooms = RoomsAPI(self._session, object_factory)<EOL>self.memberships = MembershipsAPI(self._session, object_factory)<EOL>self.messages = MessagesAPI(self._session, object_factory)<EOL>self.teams = TeamsAPI(self._session, object_factory)<EOL>self.team_memberships = TeamMembershipsAPI(<EOL>self._session, object_factory<EOL>)<EOL>self.webhooks = WebhooksAPI(self._session, object_factory)<EOL>self.organizations = OrganizationsAPI(self._session, object_factory)<EOL>self.licenses = LicensesAPI(self._session, object_factory)<EOL>self.roles = RolesAPI(self._session, object_factory)<EOL>self.events = EventsAPI(self._session, object_factory)<EOL>self.guest_issuer = GuestIssuerAPI(self._session, object_factory)<EOL>", "docstring": "Create a new WebexTeamsAPI object.\n\n        An access token must be used when interacting with the Webex Teams API.\n        This package supports three methods for you to provide that access\n        token:\n\n          1. You may manually specify the access token via the `access_token`\n             argument, when creating a new WebexTeamsAPI object.\n\n          2. If an access_token argument is not supplied, the package checks\n             for a WEBEX_TEAMS_ACCESS_TOKEN environment variable.\n\n          3. Provide the parameters (client_id, client_secret, oauth_code and\n             oauth_redirect_uri) from your oauth flow.\n\n        An AccessTokenError is raised if an access token is not provided\n        via one of these two methods.\n\n        Args:\n            access_token(basestring): The access token to be used for API\n                calls to the Webex Teams service.  Defaults to checking for a\n                WEBEX_TEAMS_ACCESS_TOKEN environment variable.\n            base_url(basestring): The base URL to be prefixed to the\n                individual API endpoint suffixes.\n                Defaults to webexteamssdk.DEFAULT_BASE_URL.\n            single_request_timeout(int): Timeout (in seconds) for RESTful HTTP\n                requests. Defaults to\n                webexteamssdk.config.DEFAULT_SINGLE_REQUEST_TIMEOUT.\n            wait_on_rate_limit(bool): Enables or disables automatic rate-limit\n                handling. Defaults to\n                webexteamssdk.config.DEFAULT_WAIT_ON_RATE_LIMIT.\n            object_factory(callable): The factory function to use to create\n                Python objects from the returned Webex Teams JSON data objects.\n            client_id(basestring): The client id of your integration. Provided\n                upon creation in the portal.\n            client_secret(basestring): The client secret of your integration.\n                Provided upon creation in the portal.\n            oauth_code(basestring): The oauth authorization code provided by\n                the user oauth process.\n            oauth_redirect_uri(basestring): The redirect URI used in the user\n                OAuth process.\n\n        Returns:\n            WebexTeamsAPI: A new WebexTeamsAPI object.\n\n        Raises:\n            TypeError: If the parameter types are incorrect.\n            AccessTokenError: If an access token is not provided via the\n                access_token argument or an environment variable.", "id": "f10526:c0:m0"}
{"signature": "def update(self, teamId, name=None, **request_parameters):", "body": "check_type(teamId, basestring, may_be_none=False)<EOL>check_type(name, basestring)<EOL>put_data = dict_from_items_with_values(<EOL>request_parameters,<EOL>name=name,<EOL>)<EOL>json_data = self._session.put(API_ENDPOINT + '<STR_LIT:/>' + teamId,<EOL>json=put_data)<EOL>return self._object_factory(OBJECT_TYPE, json_data)<EOL>", "docstring": "Update details for a team, by ID.\n\n        Args:\n            teamId(basestring): The team ID.\n            name(basestring): A user-friendly name for the team.\n            **request_parameters: Additional request parameters (provides\n                support for parameters that may be added in the future).\n\n        Returns:\n            Team: A Team object with the updated Webex Teams team details.\n\n        Raises:\n            TypeError: If the parameter types are incorrect.\n            ApiError: If the Webex Teams cloud returns an error.", "id": "f10527:c0:m4"}
{"signature": "def get(self, orgId):", "body": "check_type(orgId, basestring, may_be_none=False)<EOL>json_data = self._session.get(API_ENDPOINT + '<STR_LIT:/>' + orgId)<EOL>return self._object_factory(OBJECT_TYPE, json_data)<EOL>", "docstring": "Get the details of an Organization, by ID.\n\n        Args:\n            orgId(basestring): The ID of the Organization to be retrieved.\n\n        Returns:\n            Organization: An Organization object with the details of the\n            requested organization.\n\n        Raises:\n            TypeError: If the parameter types are incorrect.\n            ApiError: If the Webex Teams cloud returns an error.", "id": "f10528:c0:m2"}
{"signature": "def __init__(self, session, object_factory):", "body": "check_type(session, RestSession)<EOL>super(GuestIssuerAPI, self).__init__()<EOL>self._session = session<EOL>self._object_factory = object_factory<EOL>", "docstring": "Initialize a new GuestIssuerAPI object with the provided RestSession\n\n        Args:\n            session(RestSession): The RESTful session object to be used for\n            API calls to the Webex Teams service\n\n        Raises:\n            TypeError: If the parameter types are incorrect", "id": "f10529:c0:m0"}
{"signature": "@generator_container<EOL><INDENT>def list(self, teamId=None, type=None, sortBy=None, max=None,<EOL>**request_parameters):<DEDENT>", "body": "check_type(teamId, basestring)<EOL>check_type(type, basestring)<EOL>check_type(sortBy, basestring)<EOL>check_type(max, int)<EOL>params = dict_from_items_with_values(<EOL>request_parameters,<EOL>teamId=teamId,<EOL>type=type,<EOL>sortBy=sortBy,<EOL>max=max,<EOL>)<EOL>items = self._session.get_items(API_ENDPOINT, params=params)<EOL>for item in items:<EOL><INDENT>yield self._object_factory(OBJECT_TYPE, item)<EOL><DEDENT>", "docstring": "List rooms.\n\n        By default, lists rooms to which the authenticated user belongs.\n\n        This method supports Webex Teams's implementation of RFC5988 Web\n        Linking to provide pagination support.  It returns a generator\n        container that incrementally yields all rooms returned by the\n        query.  The generator will automatically request additional 'pages' of\n        responses from Webex as needed until all responses have been returned.\n        The container makes the generator safe for reuse.  A new API call will\n        be made, using the same parameters that were specified when the\n        generator was created, every time a new iterator is requested from the\n        container.\n\n        Args:\n            teamId(basestring): Limit the rooms to those associated with a\n                team, by ID.\n            type(basestring): 'direct' returns all 1-to-1 rooms. `group`\n                returns all group rooms. If not specified or values not\n                matched, will return all room types.\n            sortBy(basestring): Sort results by room ID (`id`), most recent\n                activity (`lastactivity`), or most recently created\n                (`created`).\n            max(int): Limit the maximum number of items returned from the Webex\n                Teams service per request.\n            **request_parameters: Additional request parameters (provides\n                support for parameters that may be added in the future).\n\n        Returns:\n            GeneratorContainer: A GeneratorContainer which, when iterated,\n            yields the rooms returned by the Webex Teams query.\n\n        Raises:\n            TypeError: If the parameter types are incorrect.\n            ApiError: If the Webex Teams cloud returns an error.", "id": "f10530:c0:m1"}
{"signature": "def update(self, roomId, title=None, **request_parameters):", "body": "check_type(roomId, basestring, may_be_none=False)<EOL>check_type(roomId, basestring)<EOL>put_data = dict_from_items_with_values(<EOL>request_parameters,<EOL>title=title,<EOL>)<EOL>json_data = self._session.put(API_ENDPOINT + '<STR_LIT:/>' + roomId,<EOL>json=put_data)<EOL>return self._object_factory(OBJECT_TYPE, json_data)<EOL>", "docstring": "Update details for a room, by ID.\n\n        Args:\n            roomId(basestring): The room ID.\n            title(basestring): A user-friendly name for the room.\n            **request_parameters: Additional request parameters (provides\n                support for parameters that may be added in the future).\n\n        Returns:\n            Room: A Room object with the updated Webex Teams room details.\n\n        Raises:\n            TypeError: If the parameter types are incorrect.\n            ApiError: If the Webex Teams cloud returns an error.", "id": "f10530:c0:m4"}
{"signature": "def get(self, eventId):", "body": "check_type(eventId, basestring, may_be_none=False)<EOL>json_data = self._session.get(API_ENDPOINT + '<STR_LIT:/>' + eventId)<EOL>return self._object_factory(OBJECT_TYPE, json_data)<EOL>", "docstring": "Get the details for an event, by event ID.\n\n        Args:\n            eventId(basestring): The ID of the event to be retrieved.\n\n        Returns:\n            Event: A event object with the details of the requested room.\n\n        Raises:\n            TypeError: If the parameter types are incorrect.\n            ApiError: If the Webex Teams cloud returns an error.", "id": "f10531:c0:m2"}
{"signature": "def __init__(self, session, object_factory):", "body": "check_type(session, RestSession, may_be_none=False)<EOL>super(EventsAPI, self).__init__()<EOL>self._session = session<EOL>self._object_factory = object_factory<EOL>", "docstring": "Initialize a new EventsAPI object with the provided RestSession.\n\n        Args:\n            session(RestSession): The RESTful session object to be used for\n                API calls to the Webex Teams service.\n\n        Raises:\n            TypeError: If the parameter types are incorrect.", "id": "f10531:c0:m0"}
{"signature": "def delete(self, membershipId):", "body": "check_type(membershipId, basestring)<EOL>self._session.delete(API_ENDPOINT + '<STR_LIT:/>' + membershipId)<EOL>", "docstring": "Delete a membership, by ID.\n\n        Args:\n            membershipId(basestring): The membership ID.\n\n        Raises:\n            TypeError: If the parameter types are incorrect.\n            ApiError: If the Webex Teams cloud returns an error.", "id": "f10532:c0:m5"}
{"signature": "def get(self, membershipId):", "body": "check_type(membershipId, basestring, may_be_none=False)<EOL>json_data = self._session.get(API_ENDPOINT + '<STR_LIT:/>' + membershipId)<EOL>return self._object_factory(OBJECT_TYPE, json_data)<EOL>", "docstring": "Get details for a membership, by ID.\n\n        Args:\n            membershipId(basestring): The membership ID.\n\n        Returns:\n            Membership: A Membership object with the details of the requested\n            membership.\n\n        Raises:\n            TypeError: If the parameter types are incorrect.\n            ApiError: If the Webex Teams cloud returns an error.", "id": "f10532:c0:m3"}
{"signature": "def create(self, roomId, personId=None, personEmail=None,<EOL>isModerator=False, **request_parameters):", "body": "check_type(roomId, basestring, may_be_none=False)<EOL>check_type(personId, basestring)<EOL>check_type(personEmail, basestring)<EOL>check_type(isModerator, bool)<EOL>post_data = dict_from_items_with_values(<EOL>request_parameters,<EOL>roomId=roomId,<EOL>personId=personId,<EOL>personEmail=personEmail,<EOL>isModerator=isModerator,<EOL>)<EOL>json_data = self._session.post(API_ENDPOINT, json=post_data)<EOL>return self._object_factory(OBJECT_TYPE, json_data)<EOL>", "docstring": "Add someone to a room by Person ID or email address.\n\n        Add someone to a room by Person ID or email address; optionally\n        making them a moderator.\n\n        Args:\n            roomId(basestring): The room ID.\n            personId(basestring): The ID of the person.\n            personEmail(basestring): The email address of the person.\n            isModerator(bool): Set to True to make the person a room moderator.\n            **request_parameters: Additional request parameters (provides\n                support for parameters that may be added in the future).\n\n        Returns:\n            Membership: A Membership object with the details of the created\n            membership.\n\n        Raises:\n            TypeError: If the parameter types are incorrect.\n            ApiError: If the Webex Teams cloud returns an error.", "id": "f10532:c0:m2"}
{"signature": "@property<EOL><INDENT>def base_url(self):<DEDENT>", "body": "return self._base_url<EOL>", "docstring": "The base URL for the API endpoints.", "id": "f10534:c0:m1"}
{"signature": "@property<EOL><INDENT>def headers(self):<DEDENT>", "body": "return self._req_session.headers.copy()<EOL>", "docstring": "The HTTP headers used for requests in this session.", "id": "f10534:c0:m7"}
{"signature": "def post(self, url, json=None, data=None, **kwargs):", "body": "check_type(url, basestring, may_be_none=False)<EOL>erc = kwargs.pop('<STR_LIT>', EXPECTED_RESPONSE_CODE['<STR_LIT:POST>'])<EOL>response = self.request('<STR_LIT:POST>', url, erc, json=json, data=data,<EOL>**kwargs)<EOL>return extract_and_parse_json(response)<EOL>", "docstring": "Sends a POST request.\n\n        Args:\n            url(basestring): The URL of the API endpoint.\n            json: Data to be sent in JSON format in tbe body of the request.\n            data: Data to be sent in the body of the request.\n            **kwargs:\n                erc(int): The expected (success) response code for the request.\n                others: Passed on to the requests package.\n\n        Raises:\n            ApiError: If anything other than the expected response code is\n                returned by the Webex Teams API endpoint.", "id": "f10534:c0:m14"}
{"signature": "@wait_on_rate_limit.setter<EOL><INDENT>def wait_on_rate_limit(self, value):<DEDENT>", "body": "check_type(value, bool, may_be_none=False)<EOL>self._wait_on_rate_limit = value<EOL>", "docstring": "Enable or disable automatic rate-limit handling.", "id": "f10534:c0:m6"}
{"signature": "def to_bytes(string):", "body": "assert isinstance(string, basestring)<EOL>if sys.version_info[<NUM_LIT:0>] >= <NUM_LIT:3>:<EOL><INDENT>if isinstance(string, str):<EOL><INDENT>return string.encode('<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>return string<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if isinstance(string, unicode):<EOL><INDENT>return string.encode('<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>return string<EOL><DEDENT><DEDENT>", "docstring": "Convert a string (bytes, str or unicode) to bytes.", "id": "f10535:m1"}
{"signature": "def __str__(self):", "body": "dt = self.astimezone(ZuluTimeZone())<EOL>return dt.strftime(\"<STR_LIT>\").format(<EOL>self.microsecond // <NUM_LIT:1000><EOL>)<EOL>", "docstring": "Human readable string representation of this WebexTeamsDateTime.", "id": "f10535:c1:m2"}
{"signature": "def utcoffset(self, dt):", "body": "return timedelta(<NUM_LIT:0>)<EOL>", "docstring": "UTC Offset.", "id": "f10535:c0:m1"}
{"signature": "def main():", "body": "api = WebexTeamsAPI()<EOL>delete_webhooks_with_name(api, name=WEBHOOK_NAME)<EOL>public_url = get_ngrok_public_url()<EOL>if public_url is not None:<EOL><INDENT>create_ngrok_webhook(api, public_url)<EOL><DEDENT>", "docstring": "Delete previous webhooks. If local ngrok tunnel, create a webhook.", "id": "f10539:m3"}
{"signature": "@events_service.post()<EOL>def post_events_service(request):", "body": "<EOL>json_data = request.json<EOL>log.info(\"<STR_LIT:\\n>\")<EOL>log.info(\"<STR_LIT>\")<EOL>log.info(json_data)<EOL>log.info(\"<STR_LIT:\\n>\")<EOL>webhook_obj = Webhook(json_data)<EOL>room = api.rooms.get(webhook_obj.data.roomId)<EOL>message = api.messages.get(webhook_obj.data.id)<EOL>person = api.people.get(message.personId)<EOL>log.info(\"<STR_LIT>\".format(room.title))<EOL>log.info(\"<STR_LIT>\".format(person.displayName))<EOL>log.info(\"<STR_LIT>\".format(message.text))<EOL>me = api.people.me()<EOL>if message.personId == me.id:<EOL><INDENT>return {'<STR_LIT>': '<STR_LIT:OK>'}<EOL><DEDENT>else:<EOL><INDENT>if \"<STR_LIT>\" in message.text:<EOL><INDENT>log.info(\"<STR_LIT>\")<EOL>catfact = get_catfact()<EOL>log.info(\"<STR_LIT>\".format(catfact))<EOL>api.messages.create(room.id, text=catfact)<EOL><DEDENT>return {'<STR_LIT>': '<STR_LIT:OK>'}<EOL><DEDENT>", "docstring": "Respond to inbound webhook JSON HTTP POST from Webex Teams.", "id": "f10544:m2"}
{"signature": "def scan_setup_py():", "body": "found = set()<EOL>setters = False<EOL>errors = <NUM_LIT:0><EOL>with open(\"<STR_LIT>\", \"<STR_LIT:r>\") as f:<EOL><INDENT>for line in f.readlines():<EOL><INDENT>if \"<STR_LIT>\" in line:<EOL><INDENT>found.add(\"<STR_LIT>\")<EOL><DEDENT>if \"<STR_LIT>\" in line:<EOL><INDENT>found.add(\"<STR_LIT>\")<EOL><DEDENT>if \"<STR_LIT>\" in line:<EOL><INDENT>found.add(\"<STR_LIT>\")<EOL><DEDENT>if \"<STR_LIT>\" in line:<EOL><INDENT>setters = True<EOL><DEDENT>if \"<STR_LIT>\" in line:<EOL><INDENT>setters = True<EOL><DEDENT><DEDENT><DEDENT>if len(found) != <NUM_LIT:3>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>errors += <NUM_LIT:1><EOL><DEDENT>if setters:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>errors += <NUM_LIT:1><EOL><DEDENT>return errors<EOL>", "docstring": "Validate the contents of setup.py against Versioneer's expectations.", "id": "f10548:m23"}
{"signature": "def get_cmdclass():", "body": "if \"<STR_LIT>\" in sys.modules:<EOL><INDENT>del sys.modules[\"<STR_LIT>\"]<EOL><DEDENT>cmds = {}<EOL>from distutils.core import Command<EOL>class cmd_version(Command):<EOL><INDENT>description = \"<STR_LIT>\"<EOL>user_options = []<EOL>boolean_options = []<EOL>def initialize_options(self):<EOL><INDENT>pass<EOL><DEDENT>def finalize_options(self):<EOL><INDENT>pass<EOL><DEDENT>def run(self):<EOL><INDENT>vers = get_versions(verbose=True)<EOL>print(\"<STR_LIT>\" % vers[\"<STR_LIT:version>\"])<EOL>print(\"<STR_LIT>\" % vers.get(\"<STR_LIT>\"))<EOL>print(\"<STR_LIT>\" % vers.get(\"<STR_LIT>\"))<EOL>print(\"<STR_LIT>\" % vers.get(\"<STR_LIT:date>\"))<EOL>if vers[\"<STR_LIT:error>\"]:<EOL><INDENT>print(\"<STR_LIT>\" % vers[\"<STR_LIT:error>\"])<EOL><DEDENT><DEDENT><DEDENT>cmds[\"<STR_LIT:version>\"] = cmd_version<EOL>if \"<STR_LIT>\" in sys.modules:<EOL><INDENT>from setuptools.command.build_py import build_py as _build_py<EOL><DEDENT>else:<EOL><INDENT>from distutils.command.build_py import build_py as _build_py<EOL><DEDENT>class cmd_build_py(_build_py):<EOL><INDENT>def run(self):<EOL><INDENT>root = get_root()<EOL>cfg = get_config_from_root(root)<EOL>versions = get_versions()<EOL>_build_py.run(self)<EOL>if cfg.versionfile_build:<EOL><INDENT>target_versionfile = os.path.join(self.build_lib,<EOL>cfg.versionfile_build)<EOL>print(\"<STR_LIT>\" % target_versionfile)<EOL>write_to_version_file(target_versionfile, versions)<EOL><DEDENT><DEDENT><DEDENT>cmds[\"<STR_LIT>\"] = cmd_build_py<EOL>if \"<STR_LIT>\" in sys.modules:  <EOL><INDENT>from cx_Freeze.dist import build_exe as _build_exe<EOL>class cmd_build_exe(_build_exe):<EOL><INDENT>def run(self):<EOL><INDENT>root = get_root()<EOL>cfg = get_config_from_root(root)<EOL>versions = get_versions()<EOL>target_versionfile = cfg.versionfile_source<EOL>print(\"<STR_LIT>\" % target_versionfile)<EOL>write_to_version_file(target_versionfile, versions)<EOL>_build_exe.run(self)<EOL>os.unlink(target_versionfile)<EOL>with open(cfg.versionfile_source, \"<STR_LIT:w>\") as f:<EOL><INDENT>LONG = LONG_VERSION_PY[cfg.VCS]<EOL>f.write(LONG %<EOL>{\"<STR_LIT>\": \"<STR_LIT:$>\",<EOL>\"<STR_LIT>\": cfg.style,<EOL>\"<STR_LIT>\": cfg.tag_prefix,<EOL>\"<STR_LIT>\": cfg.parentdir_prefix,<EOL>\"<STR_LIT>\": cfg.versionfile_source,<EOL>})<EOL><DEDENT><DEDENT><DEDENT>cmds[\"<STR_LIT>\"] = cmd_build_exe<EOL>del cmds[\"<STR_LIT>\"]<EOL><DEDENT>if '<STR_LIT>' in sys.modules:  <EOL><INDENT>try:<EOL><INDENT>from py2exe.distutils_buildexe import py2exe as _py2exe  <EOL><DEDENT>except ImportError:<EOL><INDENT>from py2exe.build_exe import py2exe as _py2exe  <EOL><DEDENT>class cmd_py2exe(_py2exe):<EOL><INDENT>def run(self):<EOL><INDENT>root = get_root()<EOL>cfg = get_config_from_root(root)<EOL>versions = get_versions()<EOL>target_versionfile = cfg.versionfile_source<EOL>print(\"<STR_LIT>\" % target_versionfile)<EOL>write_to_version_file(target_versionfile, versions)<EOL>_py2exe.run(self)<EOL>os.unlink(target_versionfile)<EOL>with open(cfg.versionfile_source, \"<STR_LIT:w>\") as f:<EOL><INDENT>LONG = LONG_VERSION_PY[cfg.VCS]<EOL>f.write(LONG %<EOL>{\"<STR_LIT>\": \"<STR_LIT:$>\",<EOL>\"<STR_LIT>\": cfg.style,<EOL>\"<STR_LIT>\": cfg.tag_prefix,<EOL>\"<STR_LIT>\": cfg.parentdir_prefix,<EOL>\"<STR_LIT>\": cfg.versionfile_source,<EOL>})<EOL><DEDENT><DEDENT><DEDENT>cmds[\"<STR_LIT>\"] = cmd_py2exe<EOL><DEDENT>if \"<STR_LIT>\" in sys.modules:<EOL><INDENT>from setuptools.command.sdist import sdist as _sdist<EOL><DEDENT>else:<EOL><INDENT>from distutils.command.sdist import sdist as _sdist<EOL><DEDENT>class cmd_sdist(_sdist):<EOL><INDENT>def run(self):<EOL><INDENT>versions = get_versions()<EOL>self._versioneer_generated_versions = versions<EOL>self.distribution.metadata.version = versions[\"<STR_LIT:version>\"]<EOL>return _sdist.run(self)<EOL><DEDENT>def make_release_tree(self, base_dir, files):<EOL><INDENT>root = get_root()<EOL>cfg = get_config_from_root(root)<EOL>_sdist.make_release_tree(self, base_dir, files)<EOL>target_versionfile = os.path.join(base_dir, cfg.versionfile_source)<EOL>print(\"<STR_LIT>\" % target_versionfile)<EOL>write_to_version_file(target_versionfile,<EOL>self._versioneer_generated_versions)<EOL><DEDENT><DEDENT>cmds[\"<STR_LIT>\"] = cmd_sdist<EOL>return cmds<EOL>", "docstring": "Get the custom setuptools/distutils subclasses used by Versioneer.", "id": "f10548:m21"}
{"signature": "def versions_from_file(filename):", "body": "try:<EOL><INDENT>with open(filename) as f:<EOL><INDENT>contents = f.read()<EOL><DEDENT><DEDENT>except EnvironmentError:<EOL><INDENT>raise NotThisMethod(\"<STR_LIT>\")<EOL><DEDENT>mo = re.search(r\"<STR_LIT>\",<EOL>contents, re.M | re.S)<EOL>if not mo:<EOL><INDENT>mo = re.search(r\"<STR_LIT>\",<EOL>contents, re.M | re.S)<EOL><DEDENT>if not mo:<EOL><INDENT>raise NotThisMethod(\"<STR_LIT>\")<EOL><DEDENT>return json.loads(mo.group(<NUM_LIT:1>))<EOL>", "docstring": "Try to determine the version from _version.py if present.", "id": "f10548:m9"}
{"signature": "def get_version():", "body": "return get_versions()[\"<STR_LIT:version>\"]<EOL>", "docstring": "Get the short version string for this project.", "id": "f10548:m20"}
{"signature": "@register_vcs_handler(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>def git_get_keywords(versionfile_abs):", "body": "<EOL>keywords = {}<EOL>try:<EOL><INDENT>f = open(versionfile_abs, \"<STR_LIT:r>\")<EOL>for line in f.readlines():<EOL><INDENT>if line.strip().startswith(\"<STR_LIT>\"):<EOL><INDENT>mo = re.search(r'<STR_LIT>', line)<EOL>if mo:<EOL><INDENT>keywords[\"<STR_LIT>\"] = mo.group(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>if line.strip().startswith(\"<STR_LIT>\"):<EOL><INDENT>mo = re.search(r'<STR_LIT>', line)<EOL>if mo:<EOL><INDENT>keywords[\"<STR_LIT>\"] = mo.group(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>if line.strip().startswith(\"<STR_LIT>\"):<EOL><INDENT>mo = re.search(r'<STR_LIT>', line)<EOL>if mo:<EOL><INDENT>keywords[\"<STR_LIT:date>\"] = mo.group(<NUM_LIT:1>)<EOL><DEDENT><DEDENT><DEDENT>f.close()<EOL><DEDENT>except EnvironmentError:<EOL><INDENT>pass<EOL><DEDENT>return keywords<EOL>", "docstring": "Extract version information from the given file.", "id": "f10548:m4"}
{"signature": "def render_git_describe(pieces):", "body": "if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered = pieces[\"<STR_LIT>\"]<EOL>if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += \"<STR_LIT>\" % (pieces[\"<STR_LIT>\"], pieces[\"<STR_LIT>\"])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>rendered = pieces[\"<STR_LIT>\"]<EOL><DEDENT>if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += \"<STR_LIT>\"<EOL><DEDENT>return rendered<EOL>", "docstring": "TAG[-DISTANCE-gHEX][-dirty].\n\n    Like 'git describe --tags --dirty --always'.\n\n    Exceptions:\n    1: no tags. HEX[-dirty]  (note: no 'g' prefix)", "id": "f10548:m16"}
{"signature": "def write_to_version_file(filename, versions):", "body": "os.unlink(filename)<EOL>contents = json.dumps(versions, sort_keys=True,<EOL>indent=<NUM_LIT:1>, separators=(\"<STR_LIT:U+002C>\", \"<STR_LIT>\"))<EOL>with open(filename, \"<STR_LIT:w>\") as f:<EOL><INDENT>f.write(SHORT_VERSION_PY % contents)<EOL><DEDENT>print(\"<STR_LIT>\" % (filename, versions[\"<STR_LIT:version>\"]))<EOL>", "docstring": "Write the given version number to the given _version.py file.", "id": "f10548:m10"}
{"signature": "def get_config_from_root(root):", "body": "<EOL>setup_cfg = os.path.join(root, \"<STR_LIT>\")<EOL>parser = configparser.SafeConfigParser()<EOL>with open(setup_cfg, \"<STR_LIT:r>\") as f:<EOL><INDENT>parser.readfp(f)<EOL><DEDENT>VCS = parser.get(\"<STR_LIT>\", \"<STR_LIT>\")  <EOL>def get(parser, name):<EOL><INDENT>if parser.has_option(\"<STR_LIT>\", name):<EOL><INDENT>return parser.get(\"<STR_LIT>\", name)<EOL><DEDENT>return None<EOL><DEDENT>cfg = VersioneerConfig()<EOL>cfg.VCS = VCS<EOL>cfg.style = get(parser, \"<STR_LIT>\") or \"<STR_LIT>\"<EOL>cfg.versionfile_source = get(parser, \"<STR_LIT>\")<EOL>cfg.versionfile_build = get(parser, \"<STR_LIT>\")<EOL>cfg.tag_prefix = get(parser, \"<STR_LIT>\")<EOL>if cfg.tag_prefix in (\"<STR_LIT>\", '<STR_LIT>'):<EOL><INDENT>cfg.tag_prefix = \"<STR_LIT>\"<EOL><DEDENT>cfg.parentdir_prefix = get(parser, \"<STR_LIT>\")<EOL>cfg.verbose = get(parser, \"<STR_LIT>\")<EOL>return cfg<EOL>", "docstring": "Read the project setup.cfg file to determine Versioneer config.", "id": "f10548:m1"}
{"signature": "def render_pep440_post(pieces):", "body": "if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered = pieces[\"<STR_LIT>\"]<EOL>if pieces[\"<STR_LIT>\"] or pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += \"<STR_LIT>\" % pieces[\"<STR_LIT>\"]<EOL>if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += \"<STR_LIT>\"<EOL><DEDENT>rendered += plus_or_dot(pieces)<EOL>rendered += \"<STR_LIT>\" % pieces[\"<STR_LIT>\"]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>rendered = \"<STR_LIT>\" % pieces[\"<STR_LIT>\"]<EOL>if pieces[\"<STR_LIT>\"]:<EOL><INDENT>rendered += \"<STR_LIT>\"<EOL><DEDENT>rendered += \"<STR_LIT>\" % pieces[\"<STR_LIT>\"]<EOL><DEDENT>return rendered<EOL>", "docstring": "TAG[.postDISTANCE[.dev0]+gHEX] .\n\n    The \".dev0\" means dirty. Note that .dev0 sorts backwards\n    (a dirty tree will appear \"older\" than the corresponding clean one),\n    but you shouldn't be releasing software with -dirty anyways.\n\n    Exceptions:\n    1: no tags. 0.postDISTANCE[.dev0]", "id": "f10548:m14"}
{"signature": "@register_vcs_handler(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>def git_versions_from_keywords(keywords, tag_prefix, verbose):", "body": "if not keywords:<EOL><INDENT>raise NotThisMethod(\"<STR_LIT>\")<EOL><DEDENT>date = keywords.get(\"<STR_LIT:date>\")<EOL>if date is not None:<EOL><INDENT>date = date.strip().replace(\"<STR_LIT:U+0020>\", \"<STR_LIT:T>\", <NUM_LIT:1>).replace(\"<STR_LIT:U+0020>\", \"<STR_LIT>\", <NUM_LIT:1>)<EOL><DEDENT>refnames = keywords[\"<STR_LIT>\"].strip()<EOL>if refnames.startswith(\"<STR_LIT>\"):<EOL><INDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>raise NotThisMethod(\"<STR_LIT>\")<EOL><DEDENT>refs = set([r.strip() for r in refnames.strip(\"<STR_LIT>\").split(\"<STR_LIT:U+002C>\")])<EOL>TAG = \"<STR_LIT>\"<EOL>tags = set([r[len(TAG):] for r in refs if r.startswith(TAG)])<EOL>if not tags:<EOL><INDENT>tags = set([r for r in refs if re.search(r'<STR_LIT>', r)])<EOL>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % \"<STR_LIT:U+002C>\".join(refs - tags))<EOL><DEDENT><DEDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % \"<STR_LIT:U+002C>\".join(sorted(tags)))<EOL><DEDENT>for ref in sorted(tags):<EOL><INDENT>if ref.startswith(tag_prefix):<EOL><INDENT>r = ref[len(tag_prefix):]<EOL>if verbose:<EOL><INDENT>print(\"<STR_LIT>\" % r)<EOL><DEDENT>return {\"<STR_LIT:version>\": r,<EOL>\"<STR_LIT>\": keywords[\"<STR_LIT>\"].strip(),<EOL>\"<STR_LIT>\": False, \"<STR_LIT:error>\": None,<EOL>\"<STR_LIT:date>\": date}<EOL><DEDENT><DEDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>return {\"<STR_LIT:version>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": keywords[\"<STR_LIT>\"].strip(),<EOL>\"<STR_LIT>\": False, \"<STR_LIT:error>\": \"<STR_LIT>\", \"<STR_LIT:date>\": None}<EOL>", "docstring": "Get version information from git keywords.", "id": "f10548:m5"}
{"signature": "def __init__(self, repository, token):", "body": "self._repo = repository<EOL>self._api = Github(token)<EOL>", "docstring": "Args:\n    repository (str): a string in the form 'owner/repository-name'\n        indicating the GitHub repository to report against.\n    token (str): a GitHub token obtained following:\n        https://help.github.com/articles/creating-a-personal-access-token-for-the-command-line/", "id": "f10550:c0:m0"}
{"signature": "def linear(times: np.ndarray, m: float, b: float = <NUM_LIT:0.1>) -> np.ndarray:", "body": "return m*times+b<EOL>", "docstring": "Linear test function\n    Args:\n        times: Input times.\n        m: Slope.\n        b: Intercept\n    Returns:\n        np.ndarray", "id": "f10583:m0"}
{"signature": "def setUp(self):", "body": "z = np.asarray([<NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>]).astype(np.bool)<EOL>x = np.asarray([<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>]).astype(np.bool)<EOL>self.ref_p = Pauli(z, x)<EOL>self.ref_label = '<STR_LIT>'<EOL>self.ref_matrix = np.array([[<NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> - <NUM_LIT>,<EOL><NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>,<EOL><NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>,<EOL><NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>],<EOL>[<NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>,<EOL><NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>,<EOL><NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>,<EOL><NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>],<EOL>[<NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> - <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>,<EOL><NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>,<EOL><NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>,<EOL><NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>],<EOL>[<NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>,<EOL><NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>,<EOL><NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>,<EOL><NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>],<EOL>[<NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>,<EOL><NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>,<EOL><NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>,<EOL><NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>],<EOL>[<NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>,<EOL><NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> - <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>,<EOL><NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>,<EOL><NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>],<EOL>[<NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>,<EOL><NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>,<EOL><NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>,<EOL><NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>],<EOL>[<NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>,<EOL><NUM_LIT:0.> - <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>,<EOL><NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>,<EOL><NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>],<EOL>[<NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>,<EOL><NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>,<EOL><NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> - <NUM_LIT>,<EOL><NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>],<EOL>[<NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>,<EOL><NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>,<EOL><NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>,<EOL><NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>],<EOL>[<NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>,<EOL><NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>,<EOL><NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> - <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>,<EOL><NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>],<EOL>[<NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>,<EOL><NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>,<EOL><NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>,<EOL><NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>],<EOL>[<NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>,<EOL><NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>,<EOL><NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>,<EOL><NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>],<EOL>[<NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>,<EOL><NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>,<EOL><NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>,<EOL><NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> - <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>],<EOL>[<NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>,<EOL><NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>,<EOL><NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>,<EOL><NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>],<EOL>[<NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>,<EOL><NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>,<EOL><NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>,<EOL><NUM_LIT:0.> - <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>, <NUM_LIT:0.> + <NUM_LIT>]])<EOL>", "docstring": "Setup.", "id": "f10598:c0:m0"}
{"signature": "def simple_circuit_with_measure(self):", "body": "qr = QuantumRegister(<NUM_LIT:2>)<EOL>cr = ClassicalRegister(<NUM_LIT:2>)<EOL>circ = QuantumCircuit(qr, cr)<EOL>circ.h(qr[<NUM_LIT:0>])<EOL>circ.x(qr[<NUM_LIT:1>])<EOL>circ.measure(qr, cr)<EOL>return circ<EOL>", "docstring": "Return a unitary circuit with measurement.", "id": "f10601:c0:m3"}
{"signature": "def _compare_multiply_to_superop(self, rep, dim, samples, unitary=False):", "body": "for _ in range(samples):<EOL><INDENT>if unitary:<EOL><INDENT>mat1 = self.rand_matrix(dim, dim)<EOL>sop1 = np.kron(np.conj(mat1), mat1)<EOL><DEDENT>else:<EOL><INDENT>sop1 = self.rand_matrix(dim * dim, dim * dim)<EOL><DEDENT>val = <NUM_LIT:2> * (np.random.rand() - <NUM_LIT:0.5>)<EOL>targ = SuperOp(val * sop1)<EOL>channel = SuperOp(rep(SuperOp(sop1)).multiply(val))<EOL>self.assertEqual(channel, targ)<EOL><DEDENT>", "docstring": "Test channel scalar multiplication is equivalent to SuperOp", "id": "f10608:c0:m2"}
{"signature": "def _check_add_other_reps(self, chan):", "body": "current_rep = chan.__class__<EOL>other_reps = [Operator, Choi, SuperOp, Kraus, Stinespring, Chi, PTM]<EOL>for rep in other_reps:<EOL><INDENT>self.assertEqual(current_rep, chan.add(rep(chan)).__class__)<EOL><DEDENT>", "docstring": "Check addition works for other representations", "id": "f10608:c0:m4"}
{"signature": "def _compare_negate_to_superop(self, rep, dim, samples, unitary=False):", "body": "for _ in range(samples):<EOL><INDENT>if unitary:<EOL><INDENT>mat1 = self.rand_matrix(dim, dim)<EOL>sop1 = np.kron(np.conj(mat1), mat1)<EOL><DEDENT>else:<EOL><INDENT>sop1 = self.rand_matrix(dim * dim, dim * dim)<EOL><DEDENT>targ = SuperOp(-<NUM_LIT:1> * sop1)<EOL>channel = SuperOp(-rep(SuperOp(sop1)))<EOL>self.assertEqual(channel, targ)<EOL><DEDENT>", "docstring": "Test negative channel is equivalent to SuperOp", "id": "f10608:c0:m3"}
{"signature": "def rand_kraus(self, input_dim, output_dim, n):", "body": "return [self.rand_matrix(output_dim, input_dim) for _ in range(n)]<EOL>", "docstring": "Return a random (non-CPTP) Kraus operator map", "id": "f10613:c0:m7"}
{"signature": "def depol_sop(self, p):", "body": "return (<NUM_LIT:1> - p) * self.sopI + p * np.array(<EOL>[[<NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>], [<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>], [<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>], [<NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>]]) / <NUM_LIT:2><EOL>", "docstring": "Depolarizing channel superoperator matrix", "id": "f10613:c0:m2"}
{"signature": "def depol_choi(self, p):", "body": "return (<NUM_LIT:1> - p) * self.choiI + p * np.eye(<NUM_LIT:4>) / <NUM_LIT:2><EOL>", "docstring": "Depolarizing channel Choi-matrix", "id": "f10613:c0:m3"}
{"signature": "def _check_tensor_other_reps(self, chan):", "body": "current_rep = chan.__class__<EOL>other_reps = [Operator, Choi, SuperOp, Kraus, Stinespring, Chi, PTM]<EOL>for rep in other_reps:<EOL><INDENT>self.assertEqual(current_rep, chan.tensor(rep(chan)).__class__)<EOL><DEDENT>", "docstring": "Check tensor works for other representations", "id": "f10615:c0:m3"}
{"signature": "def assertFilesAreEqual(self, current, expected):", "body": "self.assertTrue(os.path.exists(current))<EOL>self.assertTrue(os.path.exists(expected))<EOL>with open(current, \"<STR_LIT:r>\", encoding='<STR_LIT>') as cur,open(expected, \"<STR_LIT:r>\", encoding='<STR_LIT>') as exp:<EOL><INDENT>self.assertEqual(cur.read(), exp.read())<EOL><DEDENT>", "docstring": "Checks if both file are the same.", "id": "f10633:c0:m4"}
{"signature": "def make_qubit_with_error(readout_error):", "body": "calib_time = datetime(year=<NUM_LIT>, month=<NUM_LIT:2>, day=<NUM_LIT:1>, hour=<NUM_LIT:0>, minute=<NUM_LIT:0>, second=<NUM_LIT:0>)<EOL>return [Nduv(name=\"<STR_LIT>\", date=calib_time, unit=\"<STR_LIT>\", value=<NUM_LIT>),<EOL>Nduv(name=\"<STR_LIT>\", date=calib_time, unit=\"<STR_LIT>\", value=<NUM_LIT>),<EOL>Nduv(name=\"<STR_LIT>\", date=calib_time, unit=\"<STR_LIT>\", value=<NUM_LIT>),<EOL>Nduv(name=\"<STR_LIT>\", date=calib_time, unit=\"<STR_LIT>\", value=readout_error)]<EOL>", "docstring": "Create a qubit for BackendProperties", "id": "f10654:m0"}
{"signature": "def assertResult(self, result, circuit):", "body": "picklename = '<STR_LIT>' % (type(self).__name__, circuit.name)<EOL>filename = os.path.join(DIRNAME, picklename)<EOL>if self.regenerate_expected:<EOL><INDENT>self.generate_ground_truth(result, filename)<EOL><DEDENT>with open(filename, \"<STR_LIT:rb>\") as input_file:<EOL><INDENT>expected = pickle.load(input_file)<EOL><DEDENT>self.assertEqual(result, expected)<EOL>", "docstring": "Fetches the pickle in circuit.name file and compares it with result.", "id": "f10663:c0:m3"}
{"signature": "def create_passmanager(self, coupling_map, initial_layout=None):", "body": "passmanager = PassManager(<EOL>self.pass_class(CouplingMap(coupling_map),  <EOL>**self.additional_args))<EOL>if initial_layout:<EOL><INDENT>passmanager.property_set['<STR_LIT>'] = Layout(initial_layout)<EOL><DEDENT>return passmanager<EOL>", "docstring": "Returns a PassManager using self.pass_class(coupling_map, initial_layout)", "id": "f10663:c0:m0"}
{"signature": "def assertCommutationSet(self, result, expected):", "body": "result_to_compare = {}<EOL>for qbit_str, sets in result.items():<EOL><INDENT>if not isinstance(qbit_str, str):<EOL><INDENT>continue<EOL><DEDENT>result_to_compare[qbit_str] = []<EOL>for commutation_set in sets:<EOL><INDENT>result_to_compare[qbit_str].append(<EOL>sorted([node._node_id for node in commutation_set]))<EOL><DEDENT><DEDENT>for qbit_str, sets in expected.items():<EOL><INDENT>for commutation_set in sets:<EOL><INDENT>commutation_set.sort()<EOL><DEDENT><DEDENT>self.assertDictEqual(result_to_compare, expected)<EOL>", "docstring": "Compares the result of propertyset[\"commutation_set\"] with a dictionary of the form\n        {'q[0]': [ [node_id, ...], [node_id, ...] ]}", "id": "f10677:c0:m1"}
{"signature": "def _filter_deprecation_warnings():", "body": "deprecation_filter = ('<STR_LIT>', None, DeprecationWarning,<EOL>re.compile(r'<STR_LIT>', re.UNICODE), <NUM_LIT:0>)<EOL>try:<EOL><INDENT>warnings._add_filter(*deprecation_filter, append=False)<EOL><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT>warnings.simplefilter('<STR_LIT:ignore>', category=ChangedInMarshmallow3Warning)<EOL>", "docstring": "Apply filters to deprecation warnings.\n\n    Force the `DeprecationWarning` warnings to be displayed for the qiskit\n    module, overriding the system configuration as they are ignored by default\n    [1] for end-users. Additionally, silence the `ChangedInMarshmallow3Warning`\n    messages.\n\n    TODO: on Python 3.7, this might not be needed due to PEP-0565 [2].\n\n    [1] https://docs.python.org/3/library/warnings.html#default-warning-filters\n    [2] https://www.python.org/dev/peps/pep-0565/", "id": "f10700:m1"}
{"signature": "def _check_python_version():", "body": "if sys.version_info < (<NUM_LIT:3>, <NUM_LIT:5>):<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>", "docstring": "Check for Python version 3.5+.", "id": "f10700:m0"}
{"signature": "def compile(circuits, backend,<EOL>config=None, basis_gates=None, coupling_map=None, initial_layout=None,<EOL>shots=<NUM_LIT>, max_credits=<NUM_LIT:10>, seed=None, qobj_id=None, seed_mapper=None,<EOL>pass_manager=None, memory=False):", "body": "warnings.warn('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>DeprecationWarning)<EOL>new_circuits = transpile(circuits,<EOL>basis_gates=basis_gates,<EOL>coupling_map=coupling_map,<EOL>initial_layout=initial_layout,<EOL>seed_transpiler=seed_mapper,<EOL>backend=backend,<EOL>pass_manager=pass_manager)<EOL>qobj = assemble(new_circuits,<EOL>qobj_header=None,<EOL>shots=shots,<EOL>max_credits=max_credits,<EOL>seed_simulator=seed,<EOL>memory=memory,<EOL>qobj_id=qobj_id,<EOL>config=config)  <EOL>return qobj<EOL>", "docstring": "Compile a list of circuits into a qobj.\n\n    Args:\n        circuits (QuantumCircuit or list[QuantumCircuit]): circuits to compile\n        backend (BaseBackend): a backend to compile for\n        config (dict): dictionary of parameters (e.g. noise) used by runner\n        basis_gates (list[str]): list of basis gates names supported by the\n            target. Default: ['u1','u2','u3','cx','id']\n        coupling_map (list): coupling map (perhaps custom) to target in mapping\n        initial_layout (list): initial layout of qubits in mapping\n        shots (int): number of repetitions of each circuit, for sampling\n        max_credits (int): maximum credits to use\n        seed (int): random seed for simulators\n        seed_mapper (int): random seed for swapper mapper\n        qobj_id (int): identifier for the generated qobj\n        pass_manager (PassManager): a pass manger for the transpiler pipeline\n        memory (bool): if True, per-shot measurement bitstrings are returned as well\n\n    Returns:\n        Qobj: the qobj to be run on the backends\n\n    Raises:\n        QiskitError: if the desired options are not supported by backend", "id": "f10702:m0"}
{"signature": "def random_unitary_matrix(dim, seed=None):", "body": "warnings.warn('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>DeprecationWarning)<EOL>return random.random_unitary(dim, seed).data<EOL>", "docstring": "Deprecated in 0.8+", "id": "f10704:m9"}
{"signature": "def purity(state):", "body": "warnings.warn('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>DeprecationWarning)<EOL>return new_purity(state)<EOL>", "docstring": "Calculate the purity of a quantum state.\n\n    Args:\n        state (np.array): a quantum state\n    Returns:\n        float: purity.", "id": "f10704:m11"}
{"signature": "def __eof_qubit(rho):", "body": "c = concurrence(rho)<EOL>c = <NUM_LIT:0.5> + <NUM_LIT:0.5> * np.sqrt(<NUM_LIT:1> - c * c)<EOL>return shannon_entropy([c, <NUM_LIT:1> - c])<EOL>", "docstring": "Compute the Entanglement of Formation of a 2-qubit density matrix.\n\nArgs:\n    rho ((array_like): (4,4) array_like, input density matrix.\n\nReturns:\n    float: The entanglement of formation.", "id": "f10704:m17"}
{"signature": "def __partial_trace_mat(mat, trace_systems, dimensions, reverse=True):", "body": "trace_systems = sorted(trace_systems, reverse=True)<EOL>for j in trace_systems:<EOL><INDENT>dimension_trace = int(dimensions[j])  <EOL>if reverse:<EOL><INDENT>left_dimensions = dimensions[j + <NUM_LIT:1>:]<EOL>right_dimensions = dimensions[:j]<EOL>dimensions = right_dimensions + left_dimensions<EOL><DEDENT>else:<EOL><INDENT>left_dimensions = dimensions[:j]<EOL>right_dimensions = dimensions[j + <NUM_LIT:1>:]<EOL>dimensions = left_dimensions + right_dimensions<EOL><DEDENT>dimension_left = int(np.prod(left_dimensions))<EOL>dimension_right = int(np.prod(right_dimensions))<EOL>mat = mat.reshape([dimension_left, dimension_trace, dimension_right,<EOL>dimension_left, dimension_trace, dimension_right])<EOL>mat = mat.trace(axis1=<NUM_LIT:1>, axis2=<NUM_LIT:4>).reshape(<EOL>dimension_left * dimension_right,<EOL>dimension_left * dimension_right)<EOL><DEDENT>return mat<EOL>", "docstring": "Partial trace over subsystems of multi-partite matrix.\n\nNote that subsystems are ordered as rho012 = rho0(x)rho1(x)rho2.\n\nArgs:\n    mat (matrix_like): a matrix NxN.\n    trace_systems (list(int)): a list of subsystems (starting from 0) to\n                              trace over.\n    dimensions (list(int)): a list of the dimensions of the subsystems.\n                            If this is not set it will assume all\n                            subsystems are qubits.\n    reverse (bool): ordering of systems in operator.\n        If True system-0 is the right most system in tensor product.\n        If False system-0 is the left most system in tensor product.\n\nReturns:\n    ndarray: A density matrix with the appropriate subsystems traced over.", "id": "f10704:m3"}
{"signature": "def vectorize(density_matrix, method='<STR_LIT>'):", "body": "density_matrix = np.array(density_matrix)<EOL>if method == '<STR_LIT>':<EOL><INDENT>return density_matrix.flatten(order='<STR_LIT:F>')<EOL><DEDENT>elif method == '<STR_LIT>':<EOL><INDENT>return density_matrix.flatten(order='<STR_LIT:C>')<EOL><DEDENT>elif method in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>num = int(np.log2(len(density_matrix)))  <EOL>if len(density_matrix) != <NUM_LIT:2>**num:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>if method == '<STR_LIT>':<EOL><INDENT>pgroup = pauli_group(num, case='<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>pgroup = pauli_group(num, case='<STR_LIT>')<EOL><DEDENT>vals = [np.trace(np.dot(p.to_matrix(), density_matrix))<EOL>for p in pgroup]<EOL>return np.array(vals)<EOL><DEDENT>return None<EOL>", "docstring": "Flatten an operator to a vector in a specified basis.\n\n    Args:\n        density_matrix (ndarray): a density matrix.\n        method (str): the method of vectorization. Allowed values are\n            - 'col' (default) flattens to column-major vector.\n            - 'row' flattens to row-major vector.\n            - 'pauli'flattens in the n-qubit Pauli basis.\n            - 'pauli-weights': flattens in the n-qubit Pauli basis ordered by\n               weight.\n\n    Returns:\n        ndarray: the resulting vector.\n    Raises:\n        Exception: if input state is not a n-qubit state", "id": "f10704:m4"}
{"signature": "def parallel_map(task, values, task_args=tuple(), task_kwargs={},  <EOL>num_processes=CPU_COUNT):", "body": "if len(values) == <NUM_LIT:1>:<EOL><INDENT>return [task(values[<NUM_LIT:0>], *task_args, **task_kwargs)]<EOL><DEDENT>Publisher().publish(\"<STR_LIT>\", len(values))<EOL>nfinished = [<NUM_LIT:0>]<EOL>def _callback(_):<EOL><INDENT>nfinished[<NUM_LIT:0>] += <NUM_LIT:1><EOL>Publisher().publish(\"<STR_LIT>\", nfinished[<NUM_LIT:0>])<EOL><DEDENT>if platform.system() != '<STR_LIT>' and num_processes > <NUM_LIT:1>and os.getenv('<STR_LIT>') == '<STR_LIT>':<EOL><INDENT>os.environ['<STR_LIT>'] = '<STR_LIT>'<EOL>try:<EOL><INDENT>pool = Pool(processes=num_processes)<EOL>async_res = [pool.apply_async(task, (value,) + task_args, task_kwargs,<EOL>_callback) for value in values]<EOL>while not all([item.ready() for item in async_res]):<EOL><INDENT>for item in async_res:<EOL><INDENT>item.wait(timeout=<NUM_LIT:0.1>)<EOL><DEDENT><DEDENT>pool.terminate()<EOL>pool.join()<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>pool.terminate()<EOL>pool.join()<EOL>Publisher().publish(\"<STR_LIT>\")<EOL>raise QiskitError('<STR_LIT>')<EOL><DEDENT>Publisher().publish(\"<STR_LIT>\")<EOL>os.environ['<STR_LIT>'] = '<STR_LIT>'<EOL>return [ar.get() for ar in async_res]<EOL><DEDENT>results = []<EOL>for _, value in enumerate(values):<EOL><INDENT>result = task(value, *task_args, **task_kwargs)<EOL>results.append(result)<EOL>_callback(<NUM_LIT:0>)<EOL><DEDENT>Publisher().publish(\"<STR_LIT>\")<EOL>return results<EOL>", "docstring": "Parallel execution of a mapping of `values` to the function `task`. This\nis functionally equivalent to::\n\n    result = [task(value, *task_args, **task_kwargs) for value in values]\n\nOn Windows this function defaults to a serial implementation to avoid the\noverhead from spawning processes in Windows.\n\nArgs:\n    task (func): Function that is to be called for each value in ``values``.\n    values (array_like): List or array of values for which the ``task``\n                        function is to be evaluated.\n    task_args (list): Optional additional arguments to the ``task`` function.\n    task_kwargs (dict): Optional additional keyword argument to the ``task`` function.\n    num_processes (int): Number of processes to spawn.\n\nReturns:\n    result: The result list contains the value of\n            ``task(value, *task_args, **task_kwargs)`` for\n                each value in ``values``.\n\nRaises:\n    QiskitError: If user interrupts via keyboard.\n\nEvents:\n    terra.parallel.start: The collection of parallel tasks are about to start.\n    terra.parallel.update: One of the parallel task has finished.\n    terra.parallel.finish: All the parallel tasks have finished.", "id": "f10709:m0"}
{"signature": "def dispatch(self, event, *args, **kwargs):", "body": "<EOL>if event not in self._subscribers:<EOL><INDENT>return<EOL><DEDENT>for subscriber in self._subscribers[event]:<EOL><INDENT>subscriber.callback(*args, **kwargs)<EOL><DEDENT>", "docstring": "Emits an event if there are any subscribers.\n\n        Args\n            event (String): The event to be emitted\n            args: Arguments linked with the event\n            kwargs: Named arguments linked with the event", "id": "f10712:c0:m2"}
{"signature": "def clear(self):", "body": "self._subscribers.clear()<EOL>", "docstring": "Unsubscribe everything, leaving the Broker without subscribers/events.", "id": "f10712:c0:m4"}
{"signature": "def time_elapsed(self):", "body": "return \"<STR_LIT>\" % (time.time() - self.t_start)<EOL>", "docstring": "Return the time elapsed since start.\n\n        Returns:\n            elapsed_time: Time since progress bar started.", "id": "f10713:c0:m3"}
{"signature": "def time_remaining_est(self, completed_iter):", "body": "if completed_iter:<EOL><INDENT>t_r_est = (time.time() - self.t_start) /completed_iter*(self.iter-completed_iter)<EOL><DEDENT>else:<EOL><INDENT>t_r_est = <NUM_LIT:0><EOL><DEDENT>date_time = datetime.datetime(<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>) + datetime.timedelta(seconds=t_r_est)<EOL>time_string = \"<STR_LIT>\" %(date_time.day - <NUM_LIT:1>, date_time.hour, date_time.minute, date_time.second)<EOL>return time_string<EOL>", "docstring": "Estimate the remaining time left.\n\n        Parameters:\n            completed_iter (int): Number of iterations completed.\n\n        Returns:\n            est_time: Estimated time remaining.", "id": "f10713:c0:m4"}
{"signature": "def process_tomography_set(meas_qubits, meas_basis='<STR_LIT>',<EOL>prep_qubits=None, prep_basis='<STR_LIT>'):", "body": "return tomography_set(meas_qubits, meas_basis=meas_basis,<EOL>prep_qubits=prep_qubits, prep_basis=prep_basis)<EOL>", "docstring": "Generate a dictionary of process tomography experiment configurations.\n\n This returns a data structure that is used by other tomography functions\n to generate state and process tomography circuits, and extract tomography\n data from results after execution on a backend.\n\nA quantum process tomography set is created by specifying a preparation\n basis along with a measurement basis. The preparation basis may be a\n user defined `tomography_basis`, or one of the two built in basis 'SIC'\n or 'Pauli'.\n - SIC: Is a minimal symmetric informationally complete preparation\n        basis for 4 states for each qubit (4 ^ number of qubits total\n        preparation states). These correspond to the |0> state and the 3\n        other vertices of a tetrahedron on the Bloch-sphere.\n - Pauli: Is a tomographically overcomplete preparation basis of the six\n          eigenstates of the 3 Pauli operators (6 ^ number of qubits\n          total preparation states).\n\n Args:\n     meas_qubits (list): The qubits being measured.\n     meas_basis (tomography_basis or str): The qubit measurement basis.\n         The default value is 'Pauli'.\n     prep_qubits (list or None): The qubits being prepared. If None then\n         meas_qubits will be used for process tomography experiments.\n     prep_basis (tomography_basis or str): The qubit preparation basis.\n         The default value is 'SIC'.\n\n Returns:\n     dict: A dict of tomography configurations that can be parsed by\n     `create_tomography_circuits` and `tomography_data` functions\n     for implementing quantum tomography experiments. This output contains\n     fields \"qubits\", \"meas_basis\", \"prep_basus\", circuits\".\n     ```\n     {\n         'qubits': qubits (list[ints]),\n         'meas_basis': meas_basis (tomography_basis),\n         'prep_basis': prep_basis (tomography_basis),\n         'circuit_labels': (list[string]),\n         'circuits': (list[dict])  # prep and meas configurations\n     }\n     ```", "id": "f10714:m6"}
{"signature": "def meas_gate(self, circuit, qreg, op):", "body": "if self.meas_fun is None:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>self.meas_fun(circuit, qreg, op)<EOL><DEDENT>", "docstring": "Add measurement gates to a circuit.\n\nArgs:\n    circuit (QuantumCircuit): circuit to add measurement to.\n    qreg (tuple(QuantumRegister,int)): quantum register being measured.\n    op (str): the basis label for the measurement.", "id": "f10714:c0:m1"}
{"signature": "def state_tomography_set(qubits, meas_basis='<STR_LIT>'):", "body": "return tomography_set(qubits, meas_basis=meas_basis)<EOL>", "docstring": "Generate a dictionary of state tomography experiment configurations.\n\nThis returns a data structure that is used by other tomography functions\nto generate state and process tomography circuits, and extract tomography\ndata from results after execution on a backend.\n\nQuantum State Tomography:\n    Be default it will return a set for performing Quantum State\n    Tomography where individual qubits are measured in the Pauli basis.\n    A custom measurement basis may also be used by defining a user\n    `tomography_basis` and passing this in for the `meas_basis` argument.\n\nQuantum Process Tomography:\n    A quantum process tomography set is created by specifying a preparation\n    basis along with a measurement basis. The preparation basis may be a\n    user defined `tomography_basis`, or one of the two built in basis 'SIC'\n    or 'Pauli'.\n    - SIC: Is a minimal symmetric informationally complete preparation\n           basis for 4 states for each qubit (4 ^ number of qubits total\n           preparation states). These correspond to the |0> state and the 3\n           other vertices of a tetrahedron on the Bloch-sphere.\n    - Pauli: Is a tomographically overcomplete preparation basis of the six\n             eigenstates of the 3 Pauli operators (6 ^ number of qubits\n             total preparation states).\n\nArgs:\n    qubits (list): The qubits being measured.\n    meas_basis (tomography_basis or str): The qubit measurement basis.\n        The default value is 'Pauli'.\n\nReturns:\n    dict: A dict of tomography configurations that can be parsed by\n    `create_tomography_circuits` and `tomography_data` functions\n    for implementing quantum tomography experiments. This output contains\n    fields \"qubits\", \"meas_basis\", \"circuits\".\n    ```\n    {\n        'qubits': qubits (list[ints]),\n        'meas_basis': meas_basis (tomography_basis),\n        'circuit_labels': (list[string]),\n        'circuits': (list[dict])  # prep and meas configurations\n    }\n    ```", "id": "f10714:m5"}
{"signature": "def fit_tomography_data(tomo_data, method='<STR_LIT>', options=None):", "body": "if isinstance(method, str) and method.lower() in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>trace = __get_option('<STR_LIT>', options)<EOL>beta = __get_option('<STR_LIT>', options)<EOL>rho = __leastsq_fit(tomo_data, trace=trace, beta=beta)<EOL>if method == '<STR_LIT>':<EOL><INDENT>epsilon = __get_option('<STR_LIT>', options)<EOL>rho = __wizard(rho, epsilon=epsilon)<EOL><DEDENT>return rho<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>' % method)<EOL><DEDENT>", "docstring": "Reconstruct a density matrix or process-matrix from tomography data.\n\nIf the input data is state_tomography_data the returned operator will\nbe a density matrix. If the input data is process_tomography_data the\nreturned operator will be a Choi-matrix in the column-vectorization\nconvention.\n\nArgs:\n    tomo_data (dict): process tomography measurement data.\n    method (str): the fitting method to use.\n        Available methods:\n            - 'wizard' (default)\n            - 'leastsq'\n    options (dict or None): additional options for fitting method.\n\nReturns:\n    numpy.array: The fitted operator.\n\nAvailable methods:\n    - 'wizard' (Default): The returned operator will be constrained to be\n                          positive-semidefinite.\n        Options:\n        - 'trace': the trace of the returned operator.\n                   The default value is 1.\n        - 'beta': hedging parameter for computing frequencies from\n                  zero-count data. The default value is 0.50922.\n        - 'epsilon: threshold for truncating small eigenvalues to zero.\n                    The default value is 0\n    - 'leastsq': Fitting without positive-semidefinite constraint.\n        Options:\n        - 'trace': Same as for 'wizard' method.\n        - 'beta': Same as for 'wizard' method.\nRaises:\n    Exception: if the `method` parameter is not valid.", "id": "f10714:m12"}
{"signature": "def count_keys(n):", "body": "return [bin(j)[<NUM_LIT:2>:].zfill(n) for j in range(<NUM_LIT:2>**n)]<EOL>", "docstring": "Generate outcome bitstrings for n-qubits.\n\n    Args:\n        n (int): the number of qubits.\n\n    Returns:\n        list: A list of bitstrings ordered as follows:\n        Example: n=2 returns ['00', '01', '10', '11'].", "id": "f10714:m11"}
{"signature": "def __pauli_meas_gates(circuit, qreg, op):", "body": "if op not in ['<STR_LIT:X>', '<STR_LIT:Y>', '<STR_LIT>']:<EOL><INDENT>raise QiskitError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>if op == \"<STR_LIT:X>\":<EOL><INDENT>circuit.u2(<NUM_LIT:0.>, np.pi, qreg)  <EOL><DEDENT>elif op == \"<STR_LIT:Y>\":<EOL><INDENT>circuit.u2(<NUM_LIT:0.>, <NUM_LIT:0.5> * np.pi, qreg)<EOL><DEDENT>", "docstring": "Add state measurement gates to a circuit.", "id": "f10714:m2"}
{"signature": "def prep_gate(self, circuit, qreg, op):", "body": "if self.prep_fun is None:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>self.prep_fun(circuit, qreg, op)<EOL><DEDENT>", "docstring": "Add state preparation gates to a circuit.\n\nArgs:\n    circuit (QuantumCircuit): circuit to add a preparation to.\n    qreg (tuple(QuantumRegister,int)): quantum register to apply\n    preparation to.\n    op (tuple(str, int)): the basis label and index for the\n    preparation op.", "id": "f10714:c0:m0"}
{"signature": "def __leastsq_fit(tomo_data, weights=None, trace=None, beta=None):", "body": "if trace is None:<EOL><INDENT>trace = <NUM_LIT:1.>  <EOL><DEDENT>data = tomo_data['<STR_LIT:data>']<EOL>keys = data[<NUM_LIT:0>]['<STR_LIT>'].keys()<EOL>counts = []<EOL>shots = []<EOL>ops = []<EOL>for dat in data:<EOL><INDENT>for key in keys:<EOL><INDENT>counts.append(dat['<STR_LIT>'][key])<EOL>shots.append(dat['<STR_LIT>'])<EOL>projectors = dat['<STR_LIT>'][key]<EOL>op = __projector(projectors['<STR_LIT>'], tomo_data['<STR_LIT>'])<EOL>if '<STR_LIT>' in projectors:<EOL><INDENT>op_prep = __projector(projectors['<STR_LIT>'],<EOL>tomo_data['<STR_LIT>'])<EOL>op = np.kron(op_prep.conj(), op)<EOL><DEDENT>ops.append(op)<EOL><DEDENT><DEDENT>counts = np.array(counts)<EOL>shots = np.array(shots)<EOL>freqs = counts / shots<EOL>if weights is None:<EOL><INDENT>if beta is None:<EOL><INDENT>beta = <NUM_LIT><EOL><DEDENT>K = len(keys)<EOL>freqs_hedged = (counts + beta) / (shots + K * beta)<EOL>weights = np.sqrt(shots / (freqs_hedged * (<NUM_LIT:1> - freqs_hedged)))<EOL><DEDENT>return __tomo_linear_inv(freqs, ops, weights, trace=trace)<EOL>", "docstring": "Reconstruct a state from unconstrained least-squares fitting.\n\nArgs:\n    tomo_data (list[dict]): state or process tomography data.\n    weights (list or array or None): weights to use for least squares\n        fitting. The default is standard deviation from a binomial\n        distribution.\n    trace (float or None): trace of returned operator. The default is 1.\n    beta (float or None): hedge parameter (>=0) for computing frequencies\n        from zero-count data. The default value is 0.50922.\n\nReturns:\n    numpy.array: A numpy array of the reconstructed operator.", "id": "f10714:m14"}
{"signature": "def create_tomography_circuits(circuit, qreg, creg, tomoset):", "body": "if not isinstance(circuit, QuantumCircuit):<EOL><INDENT>raise QiskitError('<STR_LIT>')<EOL><DEDENT>dics = tomoset['<STR_LIT>']<EOL>labels = tomography_circuit_names(tomoset, circuit.name)<EOL>tomography_circuits = []<EOL>for label, conf in zip(labels, dics):<EOL><INDENT>tmp = circuit<EOL>if '<STR_LIT>' in conf:<EOL><INDENT>prep = QuantumCircuit(qreg, creg, name='<STR_LIT>')<EOL>for qubit, op in conf['<STR_LIT>'].items():<EOL><INDENT>tomoset['<STR_LIT>'].prep_gate(prep, qreg[qubit], op)<EOL>prep.barrier(qreg[qubit])<EOL><DEDENT>tmp = prep + tmp<EOL><DEDENT>meas = QuantumCircuit(qreg, creg, name='<STR_LIT>')<EOL>for qubit, op in conf['<STR_LIT>'].items():<EOL><INDENT>meas.barrier(qreg[qubit])<EOL>tomoset['<STR_LIT>'].meas_gate(meas, qreg[qubit], op)<EOL>meas.measure(qreg[qubit], creg[qubit])<EOL><DEDENT>tmp = tmp + meas<EOL>tmp.name = label<EOL>tomography_circuits.append(tmp)<EOL><DEDENT>logger.info('<STR_LIT>', circuit.name)<EOL>return tomography_circuits<EOL>", "docstring": "Add tomography measurement circuits to a QuantumProgram.\n\nThe quantum program must contain a circuit 'name', which is treated as a\nstate preparation circuit for state tomography, or as teh circuit being\nmeasured for process tomography. This function then appends the circuit\nwith a set of measurements specified by the input `tomography_set`,\noptionally it also prepends the circuit with state preparation circuits if\nthey are specified in the `tomography_set`.\n\nFor n-qubit tomography with a tomographically complete set of preparations\nand measurements this results in $4^n 3^n$ circuits being added to the\nquantum program.\n\nArgs:\n    circuit (QuantumCircuit): The circuit to be appended with tomography\n                              state preparation and/or measurements.\n    qreg (QuantumRegister): the quantum register containing qubits to be\n                            measured.\n    creg (ClassicalRegister): the classical register containing bits to\n                              store measurement outcomes.\n    tomoset (tomography_set): the dict of tomography configurations.\n\nReturns:\n    list: A list of quantum tomography circuits for the input circuit.\n\nRaises:\n    QiskitError: if circuit is not a valid QuantumCircuit\n\nExample:\n    For a tomography set specifying state tomography of qubit-0 prepared\n    by a circuit 'circ' this would return:\n    ```\n    ['circ_meas_X(0)', 'circ_meas_Y(0)', 'circ_meas_Z(0)']\n    ```\n    For process tomography of the same circuit with preparation in the\n    SIC-POVM basis it would return:\n    ```\n    [\n        'circ_prep_S0(0)_meas_X(0)', 'circ_prep_S0(0)_meas_Y(0)',\n        'circ_prep_S0(0)_meas_Z(0)', 'circ_prep_S1(0)_meas_X(0)',\n        'circ_prep_S1(0)_meas_Y(0)', 'circ_prep_S1(0)_meas_Z(0)',\n        'circ_prep_S2(0)_meas_X(0)', 'circ_prep_S2(0)_meas_Y(0)',\n        'circ_prep_S2(0)_meas_Z(0)', 'circ_prep_S3(0)_meas_X(0)',\n        'circ_prep_S3(0)_meas_Y(0)', 'circ_prep_S3(0)_meas_Z(0)'\n    ]\n    ```", "id": "f10714:m8"}
{"signature": "def plot_coherence(xdata, ydata, std_error, fit, fit_function, xunit, exp_str,<EOL>qubit_label):", "body": "if not HAS_MATPLOTLIB:<EOL><INDENT>raise ImportError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>plt.errorbar(xdata, ydata, std_error, marker='<STR_LIT:.>',<EOL>markersize=<NUM_LIT:9>, c='<STR_LIT:b>', linestyle='<STR_LIT>')<EOL>plt.plot(xdata, fit_function(xdata, *fit), c='<STR_LIT:r>', linestyle='<STR_LIT>',<EOL>label=(exp_str + '<STR_LIT>' % (str(round(fit[<NUM_LIT:1>])), xunit)))<EOL>plt.xticks(fontsize=<NUM_LIT>, rotation=<NUM_LIT>)<EOL>plt.yticks(fontsize=<NUM_LIT>)<EOL>plt.xlabel('<STR_LIT>' % (xunit), fontsize=<NUM_LIT:16>)<EOL>plt.ylabel('<STR_LIT>', fontsize=<NUM_LIT:16>)<EOL>plt.title(exp_str + '<STR_LIT>' % (str(qubit_label)), fontsize=<NUM_LIT>)<EOL>plt.legend(fontsize=<NUM_LIT:12>)<EOL>plt.grid(True)<EOL>plt.show()<EOL>", "docstring": "Plot coherence data.\n\n    Args:\n        xdata\n        ydata\n        std_error\n        fit\n        fit_function\n        xunit\n        exp_str\n        qubit_label\n    Raises:\n        ImportError: If matplotlib is not installed.", "id": "f10715:m3"}
{"signature": "@cell_magic<EOL><INDENT>@magic_arguments.magic_arguments()<EOL>@magic_arguments.argument(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>type=float,<EOL>default=None,<EOL>help='<STR_LIT>'<EOL>)<EOL>def qiskit_job_status(self, line='<STR_LIT>', cell=None):<DEDENT>", "body": "args = magic_arguments.parse_argstring(self.qiskit_job_status, line)<EOL>if args.interval is None:<EOL><INDENT>args.interval = <NUM_LIT:2><EOL>_interval_set = False<EOL><DEDENT>else:<EOL><INDENT>_interval_set = True<EOL><DEDENT>cell_lines = cell.split('<STR_LIT:\\n>')<EOL>line_vars = []<EOL>for cline in cell_lines:<EOL><INDENT>if '<STR_LIT:=>' in cline and '<STR_LIT>' not in cline:<EOL><INDENT>line_vars.append(cline.replace('<STR_LIT:U+0020>', '<STR_LIT>').split('<STR_LIT:=>')[<NUM_LIT:0>])<EOL><DEDENT>elif '<STR_LIT>' in cline:<EOL><INDENT>line_vars.append(cline.replace('<STR_LIT:U+0020>', '<STR_LIT>').split('<STR_LIT:(>')[<NUM_LIT:0>])<EOL><DEDENT><DEDENT>self.shell.ex(cell)<EOL>jobs = []<EOL>for var in line_vars:<EOL><INDENT>iter_var = False<EOL>if '<STR_LIT:#>' not in var:<EOL><INDENT>if '<STR_LIT:[>' in var:<EOL><INDENT>var = var.split('<STR_LIT:[>')[<NUM_LIT:0>]<EOL>iter_var = True<EOL><DEDENT>elif '<STR_LIT>' in var:<EOL><INDENT>var = var.split('<STR_LIT>')[<NUM_LIT:0>]<EOL>iter_var = True<EOL><DEDENT>if iter_var:<EOL><INDENT>for item in self.shell.user_ns[var]:<EOL><INDENT>if isinstance(item, qiskit.providers.basejob.BaseJob):<EOL><INDENT>jobs.append(item)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if isinstance(self.shell.user_ns[var],<EOL>qiskit.providers.basejob.BaseJob):<EOL><INDENT>jobs.append(self.shell.user_ns[var])<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if not any(jobs):<EOL><INDENT>raise Exception(<EOL>\"<STR_LIT>\")<EOL><DEDENT>multi_job = False<EOL>if len(jobs) > <NUM_LIT:1>:<EOL><INDENT>multi_job = True<EOL><DEDENT>job_checkers = []<EOL>for idx, job_var in enumerate(jobs):<EOL><INDENT>style = \"<STR_LIT>\"<EOL>if multi_job:<EOL><INDENT>idx_str = '<STR_LIT>' % idx<EOL><DEDENT>else:<EOL><INDENT>idx_str = '<STR_LIT>'<EOL><DEDENT>header = \"<STR_LIT>\".format(id=idx_str,<EOL>style=style)<EOL>status = widgets.HTML(<EOL>value=header % job_var.status().value)<EOL>thread = threading.Thread(target=_html_checker, args=(job_var, args.interval,<EOL>status, header,<EOL>_interval_set))<EOL>thread.start()<EOL>job_checkers.append(status)<EOL><DEDENT>box = widgets.VBox(job_checkers)<EOL>display(box)<EOL>", "docstring": "A Jupyter magic function to check the status of a Qiskit job instance.", "id": "f10717:c0:m0"}
{"signature": "def _html_checker(job_var, interval, status, header,<EOL>_interval_set=False):", "body": "job_status = job_var.status()<EOL>job_status_name = job_status.name<EOL>job_status_msg = job_status.value<EOL>status.value = header % (job_status_msg)<EOL>while job_status_name not in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>time.sleep(interval)<EOL>job_status = job_var.status()<EOL>job_status_name = job_status.name<EOL>job_status_msg = job_status.value<EOL>if job_status_name == '<STR_LIT>':<EOL><INDENT>break<EOL><DEDENT>else:<EOL><INDENT>if job_status_name == '<STR_LIT>':<EOL><INDENT>job_status_msg += '<STR_LIT>' % job_var.queue_position()<EOL>if not _interval_set:<EOL><INDENT>interval = max(job_var.queue_position(), <NUM_LIT:2>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if not _interval_set:<EOL><INDENT>interval = <NUM_LIT:2><EOL><DEDENT><DEDENT>status.value = header % (job_status_msg)<EOL><DEDENT><DEDENT>status.value = header % (job_status_msg)<EOL>", "docstring": "Internal function that updates the status\n    of a HTML job monitor.\n\n    Args:\n        job_var (BaseJob): The job to keep track of.\n        interval (int): The status check interval\n        status (widget): HTML ipywidget for output ot screen\n        header (str): String representing HTML code for status.\n        _interval_set (bool): Was interval set by user?", "id": "f10717:m0"}
{"signature": "@cell_magic<EOL><INDENT>@magic_arguments.magic_arguments()<EOL>@magic_arguments.argument(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>type=str,<EOL>default='<STR_LIT:html>',<EOL>help=\"<STR_LIT>\"<EOL>)<EOL>def qiskit_progress_bar(self, line='<STR_LIT>', cell=None):  <DEDENT>", "body": "args = magic_arguments.parse_argstring(self.qiskit_progress_bar, line)<EOL>if args.type == '<STR_LIT:html>':<EOL><INDENT>HTMLProgressBar()<EOL><DEDENT>elif args.type == '<STR_LIT:text>':<EOL><INDENT>TextProgressBar()<EOL><DEDENT>else:<EOL><INDENT>raise qiskit.QiskitError('<STR_LIT>')<EOL><DEDENT>self.shell.ex(cell)<EOL>", "docstring": "A Jupyter magic function to generate progressbar.", "id": "f10717:c1:m0"}
{"signature": "def gates_tab(backend):", "body": "config = backend.configuration().to_dict()<EOL>props = backend.properties().to_dict()<EOL>multi_qubit_gates = props['<STR_LIT>'][<NUM_LIT:3>*config['<STR_LIT>']:]<EOL>header_html = \"<STR_LIT>\"<EOL>header_html = header_html.format(key='<STR_LIT>',<EOL>value=props['<STR_LIT>'])<EOL>update_date_widget = widgets.HTML(value=header_html,<EOL>layout=widgets.Layout(grid_area='<STR_LIT>'))<EOL>gate_html = \"<STR_LIT>\"<EOL>gate_html += \"\"\"<STR_LIT>\"\"\"<EOL>gate_html += \"<STR_LIT>\"<EOL>gate_footer = \"<STR_LIT>\"<EOL>left_num = math.ceil(len(multi_qubit_gates)/<NUM_LIT:3>)<EOL>mid_num = math.ceil((len(multi_qubit_gates)-left_num)/<NUM_LIT:2>)<EOL>left_table = gate_html<EOL>for qub in range(left_num):<EOL><INDENT>gate = multi_qubit_gates[qub]<EOL>name = gate['<STR_LIT:name>']<EOL>ttype = gate['<STR_LIT>']<EOL>error = round(gate['<STR_LIT>'][<NUM_LIT:0>]['<STR_LIT:value>'], <NUM_LIT:5>)<EOL>left_table += \"<STR_LIT>\"<EOL>left_table += \"<STR_LIT>\"<EOL>left_table = left_table % (name, ttype, error)<EOL><DEDENT>left_table += gate_footer<EOL>middle_table = gate_html<EOL>for qub in range(left_num, left_num+mid_num):<EOL><INDENT>gate = multi_qubit_gates[qub]<EOL>name = gate['<STR_LIT:name>']<EOL>ttype = gate['<STR_LIT>']<EOL>error = round(gate['<STR_LIT>'][<NUM_LIT:0>]['<STR_LIT:value>'], <NUM_LIT:5>)<EOL>middle_table += \"<STR_LIT>\"<EOL>middle_table += \"<STR_LIT>\"<EOL>middle_table = middle_table % (name, ttype, error)<EOL><DEDENT>middle_table += gate_footer<EOL>right_table = gate_html<EOL>for qub in range(left_num+mid_num, len(multi_qubit_gates)):<EOL><INDENT>gate = multi_qubit_gates[qub]<EOL>name = gate['<STR_LIT:name>']<EOL>ttype = gate['<STR_LIT>']<EOL>error = round(gate['<STR_LIT>'][<NUM_LIT:0>]['<STR_LIT:value>'], <NUM_LIT:5>)<EOL>right_table += \"<STR_LIT>\"<EOL>right_table += \"<STR_LIT>\"<EOL>right_table = right_table % (name, ttype, error)<EOL><DEDENT>right_table += gate_footer<EOL>left_table_widget = widgets.HTML(value=left_table,<EOL>layout=widgets.Layout(grid_area='<STR_LIT:left>'))<EOL>middle_table_widget = widgets.HTML(value=middle_table,<EOL>layout=widgets.Layout(grid_area='<STR_LIT>'))<EOL>right_table_widget = widgets.HTML(value=right_table,<EOL>layout=widgets.Layout(grid_area='<STR_LIT:right>'))<EOL>grid = widgets.GridBox(children=[update_date_widget,<EOL>left_table_widget,<EOL>middle_table_widget,<EOL>right_table_widget],<EOL>layout=widgets.Layout(<EOL>grid_template_rows='<STR_LIT>',<EOL>grid_template_columns='<STR_LIT>',<EOL>grid_template_areas='''<STR_LIT>''',<EOL>grid_gap='<STR_LIT>'))<EOL>return grid<EOL>", "docstring": "The multiple qubit gate error widget.\n\n    Args:\n        backend (IBMQbackend): The backend.\n\n    Returns:\n        VBox: A VBox widget.", "id": "f10718:m2"}
{"signature": "def qubits_tab(backend):", "body": "props = backend.properties().to_dict()<EOL>header_html = \"<STR_LIT>\"<EOL>header_html = header_html.format(key='<STR_LIT>',<EOL>value=props['<STR_LIT>'])<EOL>update_date_widget = widgets.HTML(value=header_html)<EOL>qubit_html = \"<STR_LIT>\"<EOL>qubit_html += \"\"\"<STR_LIT>\"\"\"<EOL>qubit_html += \"<STR_LIT>\"<EOL>qubit_html += \"<STR_LIT>\"<EOL>qubit_html += \"<STR_LIT>\"<EOL>qubit_footer = \"<STR_LIT>\"<EOL>for qub in range(len(props['<STR_LIT>'])):<EOL><INDENT>name = '<STR_LIT>' % qub<EOL>qubit_data = props['<STR_LIT>'][qub]<EOL>gate_data = props['<STR_LIT>'][<NUM_LIT:3>*qub:<NUM_LIT:3>*qub+<NUM_LIT:3>]<EOL>t1_info = qubit_data[<NUM_LIT:0>]<EOL>t2_info = qubit_data[<NUM_LIT:1>]<EOL>freq_info = qubit_data[<NUM_LIT:2>]<EOL>readout_info = qubit_data[<NUM_LIT:3>]<EOL>freq = str(round(freq_info['<STR_LIT:value>'], <NUM_LIT:5>))+'<STR_LIT:U+0020>'+freq_info['<STR_LIT>']<EOL>T1 = str(round(t1_info['<STR_LIT:value>'],  <EOL><NUM_LIT:5>))+'<STR_LIT:U+0020>' + t1_info['<STR_LIT>']<EOL>T2 = str(round(t2_info['<STR_LIT:value>'],  <EOL><NUM_LIT:5>))+'<STR_LIT:U+0020>' + t2_info['<STR_LIT>']<EOL>U1 = str(round(gate_data[<NUM_LIT:0>]['<STR_LIT>'][<NUM_LIT:0>]['<STR_LIT:value>'], <NUM_LIT:5>))<EOL>U2 = str(round(gate_data[<NUM_LIT:1>]['<STR_LIT>'][<NUM_LIT:0>]['<STR_LIT:value>'], <NUM_LIT:5>))<EOL>U3 = str(round(gate_data[<NUM_LIT:2>]['<STR_LIT>'][<NUM_LIT:0>]['<STR_LIT:value>'], <NUM_LIT:5>))<EOL>readout_error = round(readout_info['<STR_LIT:value>'], <NUM_LIT:5>)<EOL>qubit_html += \"<STR_LIT>\"<EOL>qubit_html += \"<STR_LIT>\"<EOL>qubit_html = qubit_html % (name, freq, T1, T2, U1, U2, U3, readout_error)<EOL><DEDENT>qubit_html += qubit_footer<EOL>qubit_widget = widgets.HTML(value=qubit_html)<EOL>out = widgets.VBox([update_date_widget,<EOL>qubit_widget])<EOL>return out<EOL>", "docstring": "The qubits properties widget\n\n    Args:\n        backend (IBMQbackend): The backend.\n\n    Returns:\n        VBox: A VBox widget.", "id": "f10718:m1"}
{"signature": "@line_magic<EOL><INDENT>def qiskit_backend_monitor(self, line='<STR_LIT>', cell=None):  <DEDENT>", "body": "backend = self.shell.user_ns[line]<EOL>if not isinstance(backend, IBMQBackend):<EOL><INDENT>raise QiskitError('<STR_LIT>')<EOL><DEDENT>title_style = \"<STR_LIT>\"<EOL>title_style += \"<STR_LIT>\"<EOL>title_html = \"<STR_LIT>\".format(<EOL>style=title_style, name=backend.name())<EOL>details = [config_tab(backend)]<EOL>tab_contents = ['<STR_LIT>']<EOL>if not backend.configuration().simulator:<EOL><INDENT>tab_contents.extend(['<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>'])<EOL>details.extend([qubits_tab(backend), gates_tab(backend),<EOL>detailed_map(backend), job_history(backend)])<EOL><DEDENT>tabs = widgets.Tab(layout=widgets.Layout(overflow_y='<STR_LIT>'))<EOL>tabs.children = details<EOL>for i in range(len(details)):<EOL><INDENT>tabs.set_title(i, tab_contents[i])<EOL><DEDENT>title_widget = widgets.HTML(value=title_html,<EOL>layout=widgets.Layout(margin='<STR_LIT>'))<EOL>backend_monitor = widgets.VBox([title_widget, tabs],<EOL>layout=widgets.Layout(border='<STR_LIT>',<EOL>max_height='<STR_LIT>', min_height='<STR_LIT>',<EOL>overflow_y='<STR_LIT>'))<EOL>display(backend_monitor)<EOL>", "docstring": "A Jupyter magic function to monitor backends.", "id": "f10718:c0:m0"}
{"signature": "def update_backend_info(self, interval=<NUM_LIT>):", "body": "my_thread = threading.currentThread()<EOL>current_interval = <NUM_LIT:0><EOL>started = False<EOL>all_dead = False<EOL>stati = [None]*len(self._backends)<EOL>while getattr(my_thread, \"<STR_LIT>\", True) and not all_dead:<EOL><INDENT>if current_interval == interval or started is False:<EOL><INDENT>for ind, back in enumerate(self._backends):<EOL><INDENT>_value = self.children[ind].children[<NUM_LIT:2>].value<EOL>_head = _value.split('<STR_LIT>')[<NUM_LIT:0>]<EOL>try:<EOL><INDENT>_status = back.status()<EOL>stati[ind] = _status<EOL><DEDENT>except Exception:  <EOL><INDENT>self.children[ind].children[<NUM_LIT:2>].value = _value.replace(<EOL>_head, \"<STR_LIT>\")<EOL>self.children[ind]._is_alive = False<EOL><DEDENT>else:<EOL><INDENT>self.children[ind]._is_alive = True<EOL>self.children[ind].children[<NUM_LIT:2>].value = _value.replace(<EOL>_head, \"<STR_LIT>\")<EOL><DEDENT><DEDENT>idx = list(range(len(self._backends)))<EOL>pending = [s.pending_jobs for s in stati]<EOL>_, least_idx = zip(*sorted(zip(pending, idx)))<EOL>for ind in least_idx:<EOL><INDENT>if stati[ind].operational:<EOL><INDENT>least_pending_idx = ind<EOL>break<EOL><DEDENT><DEDENT>for var in idx:<EOL><INDENT>if var == least_pending_idx:<EOL><INDENT>self.children[var].children[<NUM_LIT:4>].value = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>self.children[var].children[<NUM_LIT:4>].value = \"<STR_LIT>\"<EOL><DEDENT>self.children[var].children[<NUM_LIT:3>].children[<NUM_LIT:1>].value = pending[var]<EOL>self.children[var].children[<NUM_LIT:3>].children[<NUM_LIT:1>].max = max(<EOL>self.children[var].children[<NUM_LIT:3>].children[<NUM_LIT:1>].max, pending[var]+<NUM_LIT:10>)<EOL>if stati[var].operational:<EOL><INDENT>self.children[var].children[<NUM_LIT:5>].value = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>self.children[var].children[<NUM_LIT:5>].value = \"<STR_LIT>\"<EOL><DEDENT><DEDENT>started = True<EOL>current_interval = <NUM_LIT:0><EOL><DEDENT>time.sleep(<NUM_LIT:1>)<EOL>all_dead = not any([wid._is_alive for wid in self.children])<EOL>current_interval += <NUM_LIT:1><EOL><DEDENT>", "docstring": "Updates the monitor info\n    Called from another thread.", "id": "f10719:m1"}
{"signature": "def format_level_2_memory(memory, header=None):", "body": "memory_list = []<EOL>for shot_memory in memory:<EOL><INDENT>memory_list.append(format_counts_memory(shot_memory, header))<EOL><DEDENT>return memory_list<EOL>", "docstring": "Format an experiment result memory object for measurement level 2.\n\n    Args:\n        memory (list): Memory from experiment with `meas_level==2` and `memory==True`.\n        header (dict): the experiment header dictionary containing\n            useful information for postprocessing.\n\n    Returns:\n        list[str]: List of bitstrings", "id": "f10723:m7"}
{"signature": "def _list_to_complex_array(complex_list):", "body": "arr = np.asarray(complex_list, dtype=np.complex_)<EOL>if not arr.shape[-<NUM_LIT:1>] == <NUM_LIT:2>:<EOL><INDENT>raise QiskitError('<STR_LIT>')<EOL><DEDENT>return arr[..., <NUM_LIT:0>] + <NUM_LIT>*arr[..., <NUM_LIT:1>]<EOL>", "docstring": "Convert nested list of shape (..., 2) to complex numpy array with shape (...)\n\n    Args:\n        complex_list (list): List to convert.\n\n    Returns:\n        np.ndarray: Complex numpy aray\n\n    Raises:\n        QiskitError: If inner most array of input nested list is not of length 2.", "id": "f10723:m4"}
{"signature": "def format_level_1_memory(memory):", "body": "formatted_memory = _list_to_complex_array(memory)<EOL>if not <NUM_LIT:1> <= len(formatted_memory.shape) <= <NUM_LIT:2>:<EOL><INDENT>raise QiskitError('<STR_LIT>')<EOL><DEDENT>return formatted_memory<EOL>", "docstring": "Format an experiment result memory object for measurement level 1.\n\n    Args:\n        memory (list): Memory from experiment with `meas_level==1`. `avg` or\n            `single` will be inferred from shape of result memory.\n\n    Returns:\n        np.ndarray: Measurement level 1 complex numpy array\n\n    Raises:\n        QiskitError: If the returned numpy array does not have 1 (avg) or 2 (single)\n            indicies.", "id": "f10723:m6"}
{"signature": "def _pad_zeros(bitstring, memory_slots):", "body": "return format(int(bitstring, <NUM_LIT:2>), '<STR_LIT>'.format(memory_slots))<EOL>", "docstring": "If the bitstring is truncated, pad extra zeros to make its\n    length equal to memory_slots", "id": "f10723:m1"}
{"signature": "def get_counts(self, experiment=None):", "body": "try:<EOL><INDENT>exp = self._get_experiment(experiment)<EOL>try:<EOL><INDENT>header = exp.header.to_dict()<EOL><DEDENT>except (AttributeError, QiskitError):  <EOL><INDENT>header = None<EOL><DEDENT>return postprocess.format_counts(self.data(experiment)['<STR_LIT>'],<EOL>header)<EOL><DEDENT>except KeyError:<EOL><INDENT>raise QiskitError('<STR_LIT>'.format(experiment))<EOL><DEDENT>", "docstring": "Get the histogram data of an experiment.\n\n        Args:\n            experiment (str or QuantumCircuit or Schedule or int or None): the index of the\n                experiment, as specified by ``get_data()``.\n\n        Returns:\n            dict[str:int]: a dictionary with the counts for each qubit, with\n                the keys containing a string in binary format and separated\n                according to the registers in circuit (e.g. ``0100 1110``).\n                The string is little-endian (cr[0] on the right hand side).\n\n        Raises:\n            QiskitError: if there are no counts for the experiment.", "id": "f10724:c0:m3"}
{"signature": "@definition.setter<EOL><INDENT>def definition(self, array):<DEDENT>", "body": "self._definition = array<EOL>", "docstring": "Set matrix representation", "id": "f10727:c0:m6"}
{"signature": "def assemble(self):", "body": "instruction = QasmQobjInstruction(name=self.name)<EOL>if self.params:<EOL><INDENT>params = [<EOL>x.evalf() if hasattr(x, '<STR_LIT>') else x for x in self.params<EOL>]<EOL>params = [<EOL>sympy.matrix2numpy(x, dtype=complex) if isinstance(<EOL>x, sympy.Matrix) else x for x in params<EOL>]<EOL>instruction.params = params<EOL><DEDENT>if self.num_qubits:<EOL><INDENT>instruction.qubits = list(range(self.num_qubits))<EOL><DEDENT>if self.num_clbits:<EOL><INDENT>instruction.memory = list(range(self.num_clbits))<EOL><DEDENT>if self.control:<EOL><INDENT>instruction._control = self.control<EOL><DEDENT>return instruction<EOL>", "docstring": "Assemble a QasmQobjInstruction", "id": "f10727:c0:m7"}
{"signature": "def __eq__(self, other):", "body": "if type(self) is not type(other) orself.name != other.name orself.num_qubits != other.num_qubits orself.num_clbits != other.num_clbits orself.definition != other.definition:<EOL><INDENT>return False<EOL><DEDENT>for self_param, other_param in zip_longest(self.params, other.params):<EOL><INDENT>if self_param == other_param:<EOL><INDENT>continue<EOL><DEDENT>try:<EOL><INDENT>if numpy.isclose(float(self_param), float(other_param),<EOL>atol=_CUTOFF_PRECISION):<EOL><INDENT>continue<EOL><DEDENT><DEDENT>except TypeError:<EOL><INDENT>pass<EOL><DEDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "Two instructions are the same if they have the same name,\n        same dimensions, and same params.\n\n        Args:\n            other (instruction): other instruction\n\n        Returns:\n            bool: are self and other equal.", "id": "f10727:c0:m1"}
{"signature": "def __init__(self, name, num_qubits, num_clbits, params):", "body": "if not isinstance(num_qubits, int) or not isinstance(num_clbits, int):<EOL><INDENT>raise QiskitError(\"<STR_LIT>\")<EOL><DEDENT>if num_qubits < <NUM_LIT:0> or num_clbits < <NUM_LIT:0>:<EOL><INDENT>raise QiskitError(<EOL>\"<STR_LIT>\" %<EOL>num_qubits, num_clbits)<EOL><DEDENT>self.name = name<EOL>self.num_qubits = num_qubits<EOL>self.num_clbits = num_clbits<EOL>self._params = []  <EOL>self.control = None<EOL>self._definition = None<EOL>self.params = params<EOL>", "docstring": "Create a new instruction.\n        Args:\n            name (str): instruction name\n            num_qubits (int): instruction's qubit width\n            num_clbits (int): instructions's clbit width\n            params (list[sympy.Basic|qasm.Node|int|float|complex|str|ndarray]): list of parameters\n        Raises:\n            QiskitError: when the register is not in the correct format.", "id": "f10727:c0:m0"}
{"signature": "def qasm(self):", "body": "name_param = self.name<EOL>if self.params:<EOL><INDENT>name_param = \"<STR_LIT>\" % (name_param, \"<STR_LIT:U+002C>\".join(<EOL>[str(i) for i in self.params]))<EOL><DEDENT>return self._qasmif(name_param)<EOL>", "docstring": "Return a default OpenQASM string for the instruction.\n\n        Derived instructions may override this to print in a\n        different format (e.g. measure q[0] -> c[0];).", "id": "f10727:c0:m13"}
{"signature": "@property<EOL><INDENT>def params(self):<DEDENT>", "body": "<EOL>if self._definition and not self._params:<EOL><INDENT>self._params = []<EOL>for sub_instr, _, _ in self._definition:<EOL><INDENT>self._params.extend(sub_instr.params)  <EOL><DEDENT>return self._params<EOL><DEDENT>else:<EOL><INDENT>return self._params<EOL><DEDENT>", "docstring": "return instruction params", "id": "f10727:c0:m3"}
{"signature": "def __init__(self):", "body": "super().__init__(\"<STR_LIT>\", <NUM_LIT:1>, <NUM_LIT:0>, [])<EOL>", "docstring": "Create new reset instruction.", "id": "f10728:c0:m0"}
{"signature": "def qasm(self):", "body": "return \"<STR_LIT>\" % (self.name, self.size)<EOL>", "docstring": "Return OPENQASM string for this register.", "id": "f10729:c0:m0"}
{"signature": "def __setitem__(self, parameter, instr_params):", "body": "for instruction, param_index in instr_params:<EOL><INDENT>assert isinstance(instruction, Instruction)<EOL>assert isinstance(param_index, int)<EOL><DEDENT>self._table[parameter] = instr_params<EOL>", "docstring": "Sets list of Instructions that depend on Parameter.\n\n        Args:\n            parameter (Parameter): the parameter to set\n            instr_params (list): List of (Instruction, int) tuples. Int is the\n              parameter index at which the parameter appears in the instruction.", "id": "f10730:c0:m2"}
{"signature": "def __iter__(self):", "body": "return zip([self]*self.size, range(self.size))<EOL>", "docstring": "Returns:\n    iterator: an iterator over the bits/qubits of the register, in the\n        form `tuple (Register, int)`.", "id": "f10732:c0:m5"}
{"signature": "def __hash__(self):", "body": "return hash((type(self), self.name, self.size))<EOL>", "docstring": "Make object hashable, based on the name and size to hash.", "id": "f10732:c0:m7"}
{"signature": "def qasm(self):", "body": "return \"<STR_LIT>\" % (self.name, self.size)<EOL>", "docstring": "Return OPENQASM string for this register.", "id": "f10733:c0:m0"}
{"signature": "def __len__(self):", "body": "return len(self.instructions)<EOL>", "docstring": "Return number of instructions in set", "id": "f10735:c0:m1"}
{"signature": "def to_matrix(self):", "body": "raise QiskitError(\"<STR_LIT>\".format(type(self)))<EOL>", "docstring": "Return a Numpy.array for the gate unitary matrix.\n\n        Additional Information\n        ----------------------\n        If a Gate subclass does not implement this method an exception\n        will be raised when this base class method is called.", "id": "f10736:c0:m1"}
{"signature": "def clbits(self):", "body": "return [cbit for creg in self.cregs for cbit in creg]<EOL>", "docstring": "Returns a list of classical bits in the order that the registers had been added.", "id": "f10739:c0:m12"}
{"signature": "def __add__(self, rhs):", "body": "return self.combine(rhs)<EOL>", "docstring": "Overload + to implement self.combine.", "id": "f10739:c0:m13"}
{"signature": "def depth(self):", "body": "<EOL>reg_offset = <NUM_LIT:0><EOL>reg_map = {}<EOL>for reg in self.qregs+self.cregs:<EOL><INDENT>reg_map[reg.name] = reg_offset<EOL>reg_offset += reg.size<EOL><DEDENT>op_stack = [<NUM_LIT:0>]*reg_offset<EOL>for instr, qargs, cargs in self.data:<EOL><INDENT>if instr.name not in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>levels = []<EOL>reg_ints = []<EOL>for ind, reg in enumerate(qargs+cargs):<EOL><INDENT>reg_ints.append(reg_map[reg[<NUM_LIT:0>].name]+reg[<NUM_LIT:1>])<EOL>levels.append(op_stack[reg_ints[ind]] + <NUM_LIT:1>)<EOL><DEDENT>if instr.control:<EOL><INDENT>cint = reg_map[instr.control[<NUM_LIT:0>].name]<EOL>for off in range(instr.control[<NUM_LIT:0>].size):<EOL><INDENT>if cint+off not in reg_ints:<EOL><INDENT>reg_ints.append(cint+off)<EOL>levels.append(op_stack[cint+off]+<NUM_LIT:1>)<EOL><DEDENT><DEDENT><DEDENT>max_level = max(levels)<EOL>for ind in reg_ints:<EOL><INDENT>op_stack[ind] = max_level<EOL><DEDENT><DEDENT><DEDENT>return max(op_stack)<EOL>", "docstring": "Return circuit depth (i.e. length of critical path).\n        This does not include compiler or simulator directives\n        such as 'barrier' or 'snapshot'.\n\n        Returns:\n            int: Depth of circuit.\n\n        Notes:\n            The circuit depth and the DAG depth need not bt the\n            same.", "id": "f10739:c0:m29"}
{"signature": "def has_register(self, register):", "body": "has_reg = False<EOL>if (isinstance(register, QuantumRegister) and<EOL>register in self.qregs):<EOL><INDENT>has_reg = True<EOL><DEDENT>elif (isinstance(register, ClassicalRegister) and<EOL>register in self.cregs):<EOL><INDENT>has_reg = True<EOL><DEDENT>return has_reg<EOL>", "docstring": "Test if this circuit has the register r.\n\nArgs:\n    register (Register): a quantum or classical register.\n\nReturns:\n    bool: True if the register is contained in this circuit.", "id": "f10739:c0:m6"}
{"signature": "@staticmethod<EOL><INDENT>def from_qasm_file(path):<DEDENT>", "body": "qasm = Qasm(filename=path)<EOL>return _circuit_from_qasm(qasm)<EOL>", "docstring": "Take in a QASM file and generate a QuantumCircuit object.\n\n        Args:\n          path (str): Path to the file for a QASM program\n        Return:\n          QuantumCircuit: The QuantumCircuit object for the input QASM", "id": "f10739:c0:m36"}
{"signature": "def size(self):", "body": "gate_ops = <NUM_LIT:0><EOL>for instr, _, _ in self.data:<EOL><INDENT>if instr.name not in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>gate_ops += <NUM_LIT:1><EOL><DEDENT><DEDENT>return gate_ops<EOL>", "docstring": "Returns total number of gate operations in circuit.\n\n        Returns:\n            int: Total number of gate operations.", "id": "f10739:c0:m28"}
{"signature": "def num_tensor_factors(self):", "body": "return self.num_unitary_factors()<EOL>", "docstring": "Computes the number of tensor factors in the unitary\n        (quantum) part of the circuit only.\n\n        Notes:\n            This is here for backwards compatibility, and will be\n            removed in a future release of qiskit. You should call\n            `num_unitary_factors` instead.", "id": "f10739:c0:m34"}
{"signature": "def _check_compatible_regs(self, rhs):", "body": "list1 = self.qregs + self.cregs<EOL>list2 = rhs.qregs + rhs.cregs<EOL>for element1 in list1:<EOL><INDENT>for element2 in list2:<EOL><INDENT>if element2.name == element1.name:<EOL><INDENT>if element1 != element2:<EOL><INDENT>raise QiskitError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Raise exception if the circuits are defined on incompatible registers", "id": "f10739:c0:m25"}
{"signature": "def combine(self, rhs):", "body": "<EOL>self._check_compatible_regs(rhs)<EOL>combined_qregs = deepcopy(self.qregs)<EOL>combined_cregs = deepcopy(self.cregs)<EOL>for element in rhs.qregs:<EOL><INDENT>if element not in self.qregs:<EOL><INDENT>combined_qregs.append(element)<EOL><DEDENT><DEDENT>for element in rhs.cregs:<EOL><INDENT>if element not in self.cregs:<EOL><INDENT>combined_cregs.append(element)<EOL><DEDENT><DEDENT>circuit = QuantumCircuit(*combined_qregs, *combined_cregs)<EOL>for instruction_context in itertools.chain(self.data, rhs.data):<EOL><INDENT>circuit.append(*instruction_context)<EOL><DEDENT>return circuit<EOL>", "docstring": "Append rhs to self if self contains compatible registers.\n\nTwo circuits are compatible if they contain the same registers\nor if they contain different registers with unique names. The\nreturned circuit will contain all unique registers between both\ncircuits.\n\nReturn self + rhs as a new object.", "id": "f10739:c0:m9"}
{"signature": "def qasm(self):", "body": "string_temp = self.header + \"<STR_LIT:\\n>\"<EOL>string_temp += self.extension_lib + \"<STR_LIT:\\n>\"<EOL>for register in self.qregs:<EOL><INDENT>string_temp += register.qasm() + \"<STR_LIT:\\n>\"<EOL><DEDENT>for register in self.cregs:<EOL><INDENT>string_temp += register.qasm() + \"<STR_LIT:\\n>\"<EOL><DEDENT>for instruction, qargs, cargs in self.data:<EOL><INDENT>if instruction.name == '<STR_LIT>':<EOL><INDENT>qubit = qargs[<NUM_LIT:0>]<EOL>clbit = cargs[<NUM_LIT:0>]<EOL>string_temp += \"<STR_LIT>\" % (instruction.qasm(),<EOL>qubit[<NUM_LIT:0>].name, qubit[<NUM_LIT:1>],<EOL>clbit[<NUM_LIT:0>].name, clbit[<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>string_temp += \"<STR_LIT>\" % (instruction.qasm(),<EOL>\"<STR_LIT:U+002C>\".join([\"<STR_LIT>\" % (j[<NUM_LIT:0>].name, j[<NUM_LIT:1>])<EOL>for j in qargs + cargs]))<EOL><DEDENT><DEDENT>return string_temp<EOL>", "docstring": "Return OpenQASM string.", "id": "f10739:c0:m26"}
{"signature": "def _attach(self, gate):", "body": "self.append(gate)<EOL>", "docstring": "DEPRECATED after 0.8.", "id": "f10740:c0:m3"}
{"signature": "def append(self, gate):", "body": "self.data.append(gate)<EOL>return gate<EOL>", "docstring": "Attach a gate.", "id": "f10740:c0:m2"}
{"signature": "def __init__(self, name, params, inverse_name=None):", "body": "warnings.warn('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>', DeprecationWarning)<EOL>super().__init__(name, params)<EOL>self.data = []  <EOL>self.inverse_flag = False<EOL>self.inverse_name = inverse_name or (name + '<STR_LIT>')<EOL>", "docstring": "Create a new composite gate.\n\n        name = instruction name string\n        params = list of real parameters", "id": "f10740:c0:m0"}
{"signature": "def __eq__(self, other):", "body": "if type(self) is type(other) andself._qubits == other._qubits:<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Two device specs are the same if they have the same qubits.\n\n        Args:\n            other (DeviceSpecification): other DeviceSpecification\n\n        Returns:\n            bool: are self and other equal.", "id": "f10741:c0:m2"}
{"signature": "def __init__(self,<EOL>qubits: List[Qubit],<EOL>registers: List[RegisterSlot],<EOL>mem_slots: List[MemorySlot]):", "body": "self._qubits = qubits<EOL>self._reg_slots = registers<EOL>self._mem_slots = mem_slots<EOL>", "docstring": "Create device specification with specified `qubits`.\nArgs:\n    qubits:", "id": "f10741:c0:m0"}
{"signature": "def __eq__(self, other):", "body": "if (type(self) is type(other) and<EOL>self._ub == other._ub and<EOL>self._lb == other._lb):<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Two LO ranges are the same if they are of the same type, and\n        have the same frequency range\n\n        Args:\n            other (LoRange): other LoRange\n\n        Returns:\n            bool: are self and other equal.", "id": "f10742:c0:m5"}
{"signature": "def __init__(self, index: int,<EOL>lo_freq: float = None,<EOL>lo_freq_range: Tuple[float, float] = (<NUM_LIT:0>, float(\"<STR_LIT>\"))):", "body": "super().__init__(index, lo_freq, lo_freq_range)<EOL>", "docstring": "Create new measurement (m) channel.\n\n        Args:\n            index (int): index of the channel\n            lo_freq (float): default frequency of LO (local oscillator)\n            lo_freq_range (tuple): feasible range of LO frequency", "id": "f10742:c4:m0"}
{"signature": "@property<EOL><INDENT>def lo_freq(self) -> float:<DEDENT>", "body": "return self._lo_freq<EOL>", "docstring": "Get the default lo frequency.", "id": "f10742:c1:m1"}
{"signature": "def __init__(self, index):", "body": "super().__init__(index)<EOL>", "docstring": "Create new register slot.\n\n        Args:\n            index (int): Index of the channel.", "id": "f10744:c4:m0"}
{"signature": "def __init__(self):", "body": "super().__init__(<NUM_LIT:0>)<EOL>", "docstring": "Create new snapshot channel.", "id": "f10744:c2:m0"}
{"signature": "@property<EOL><INDENT>def measure(self) -> MeasureChannel:<DEDENT>", "body": "if self._measures:<EOL><INDENT>return self._measures[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>raise PulseError(\"<STR_LIT>\" % self._index)<EOL><DEDENT>", "docstring": "Return the primary measure channel of this qubit.", "id": "f10745:c0:m5"}
{"signature": "def union(*schedules: List[Union[ScheduleComponent, Tuple[int, ScheduleComponent]]],<EOL>name: str = None) -> Schedule:", "body": "if name is None and schedules:<EOL><INDENT>sched = schedules[<NUM_LIT:0>]<EOL>if isinstance(sched, (list, tuple)):<EOL><INDENT>name = sched[<NUM_LIT:1>].name<EOL><DEDENT>else:<EOL><INDENT>name = sched.name<EOL><DEDENT><DEDENT>return Schedule(*schedules, name=name)<EOL>", "docstring": "Create a union (and also shift if desired) of all input `Schedule`s.\n\n    Args:\n        *schedules: Schedules to take the union of\n        name: Name of the new schedule. Defaults to first element of `schedules`", "id": "f10746:m0"}
{"signature": "def right_sample(continuous_pulse: Callable, duration: int, *args, **kwargs) -> np.ndarray:", "body": "times = np.arange(<NUM_LIT:1>, duration+<NUM_LIT:1>)<EOL>return continuous_pulse(times, *args, **kwargs)<EOL>", "docstring": "Sampling strategy for decorator.\n    Args:\n        continuous_pulse: Continuous pulse function to sample.\n        duration: Duration to sample for.\n        *args: Continuous pulse function args.\n        **kwargs: Continuous pulse function kwargs.", "id": "f10747:m1"}
{"signature": "def right(continuous_pulse: Callable) -> Callable:", "body": "return sampler(strategies.right_sample)(continuous_pulse)<EOL>", "docstring": "r\"\"\"Right sampling strategy decorator.\n\n    See `pulse.samplers.sampler` for more information.\n\n    For `duration`, return:\n        $$\\{f(t) \\in \\mathbb{C} | t \\in \\mathbb{Z} \\wedge  0<t<=\\texttt{duration}\\}$$\n\n    Args:\n        continuous_pulse: To sample.", "id": "f10749:m4"}
{"signature": "def sampler(sample_function: Callable) -> Callable:", "body": "def generate_sampler(continuous_pulse: Callable) -> Callable:<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>@functools.wraps(continuous_pulse)<EOL>def call_sampler(duration: int, *args, **kwargs) -> commands.SamplePulse:<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>sampled_pulse = sample_function(continuous_pulse, duration, *args, **kwargs)<EOL>return np.asarray(sampled_pulse, dtype=np.complex_)<EOL><DEDENT>call_sampler = _update_annotations(call_sampler)<EOL>call_sampler = _update_docstring(call_sampler, sample_function)<EOL>call_sampler.__dict__.pop('<STR_LIT>')<EOL>return commands.functional_pulse(call_sampler)<EOL><DEDENT>return generate_sampler<EOL>", "docstring": "Sampler decorator base method.\n\n    Samplers are used for converting an continuous function to a discretized pulse.\n\n    They operate on a function with the signature:\n        `def f(times: np.ndarray, *args, **kwargs) -> np.ndarray`\n    Where `times` is a numpy array of floats with length n_times and the output array\n    is a complex numpy array with length n_times. The output of the decorator is an\n    instance of `FunctionalPulse` with signature:\n        `def g(duration: int, *args, **kwargs) -> SamplePulse`\n\n    Note if your continuous pulse function outputs a `complex` scalar rather than a\n    `np.ndarray`, you should first vectorize it before applying a sampler.\n\n\n    This class implements the sampler boilerplate for the sampler.\n\n    Args:\n        sample_function: A sampler function to be decorated.", "id": "f10749:m2"}
{"signature": "def triangle(times: np.ndarray, amp: complex, period: float, phase: float = <NUM_LIT:0>) -> np.ndarray:", "body": "return amp*(-<NUM_LIT:2>*np.abs(sawtooth(times, <NUM_LIT:1>, period, (phase-np.pi/<NUM_LIT:2>)/<NUM_LIT:2>)) + <NUM_LIT:1>).astype(np.complex_)<EOL>", "docstring": "Continuous triangle wave.\n\n    Args:\n        times: Times to output wave for.\n        amp: Pulse amplitude. Wave range is [-amp, amp].\n        period: Pulse period, units of dt.\n        phase: Pulse phase.", "id": "f10750:m4"}
{"signature": "def gaussian_deriv(times: np.ndarray, amp: complex, center: float, sigma: float,<EOL>ret_gaussian: bool = False) -> np.ndarray:", "body": "gauss, x = gaussian(times, amp=amp, center=center, sigma=sigma, ret_x=True)<EOL>gauss_deriv = -x/sigma*gauss<EOL>if ret_gaussian:<EOL><INDENT>return gauss_deriv, gauss<EOL><DEDENT>return gauss_deriv<EOL>", "docstring": "Continuous unnormalized gaussian derivative pulse.\n\n    Args:\n        times: Times to output pulse for.\n        amp: Pulse amplitude at `center`.\n        center: Center (mean) of pulse.\n        sigma: Width (standard deviation) of pulse.\n        ret_gaussian: Return gaussian with which derivative was taken with.", "id": "f10750:m9"}
{"signature": "def gaussian_square(times: np.ndarray, amp: complex, center: float, width: float,<EOL>sigma: float, zeroed_width: Union[None, float] = None) -> np.ndarray:", "body": "square_start = center-width/<NUM_LIT:2><EOL>square_stop = center+width/<NUM_LIT:2><EOL>if zeroed_width:<EOL><INDENT>zeroed_width = min(width, zeroed_width)<EOL>gauss_zeroed_width = zeroed_width-width<EOL><DEDENT>else:<EOL><INDENT>gauss_zeroed_width = None<EOL><DEDENT>funclist = [functools.partial(gaussian, amp=amp, center=square_start, sigma=sigma,<EOL>zeroed_width=gauss_zeroed_width, rescale_amp=True),<EOL>functools.partial(gaussian, amp=amp, center=square_stop, sigma=sigma,<EOL>zeroed_width=gauss_zeroed_width, rescale_amp=True),<EOL>functools.partial(constant, amp=amp)]<EOL>condlist = [times <= square_start, times >= square_stop]<EOL>return np.piecewise(times.astype(np.complex_), condlist, funclist)<EOL>", "docstring": "r\"\"\"Continuous gaussian square pulse.\n\n    Args:\n        times: Times to output pulse for.\n        amp: Pulse amplitude.\n        center: Center of the square pulse component.\n        width: Width of the square pulse component.\n        sigma: Width (standard deviation) of gaussian rise/fall portion of the pulse.\n        zeroed_width: Subtract baseline of gaussian square pulse\n                      to enforce $\\OmegaSquare(center \\pm zeroed_width/2)=0$.", "id": "f10750:m10"}
{"signature": "def sin(times: np.ndarray, amp: complex, freq: float, phase: float = <NUM_LIT:0>) -> np.ndarray:", "body": "return amp*np.sin(<NUM_LIT:2>*np.pi*freq*times+phase).astype(np.complex_)<EOL>", "docstring": "Continuous cosine wave.\n\n    Args:\n        times: Times to output wave for.\n        amp: Pulse amplitude.\n        freq: Pulse frequency, units of 1/dt.\n        phase: Pulse phase.", "id": "f10750:m6"}
{"signature": "def gaussian(duration: int, amp: complex, sigma: float, name: str = None) -> SamplePulse:", "body": "center = duration/<NUM_LIT:2><EOL>zeroed_width = duration + <NUM_LIT:2><EOL>return _sampled_gaussian_pulse(duration, amp, center, sigma,<EOL>zeroed_width=zeroed_width, rescale_amp=True, name=name)<EOL>", "docstring": "r\"\"\"Generates unnormalized gaussian `SamplePulse`.\n\n    Centered at `duration/2` and zeroed at `t=-1` to prevent large initial discontinuity.\n\n    Applies `left` sampling strategy to generate discrete pulse from continuous function.\n\n    Integrated area under curve is $\\Omega_g(amp, sigma) = amp \\times np.sqrt(2\\pi \\sigma^2)$\n\n    Args:\n        duration: Duration of pulse. Must be greater than zero.\n        amp: Pulse amplitude at `duration/2`.\n        sigma: Width (standard deviation) of pulse.\n        name: Name of pulse.", "id": "f10752:m7"}
{"signature": "def sin(duration: int, amp: complex, freq: float = None,<EOL>phase: float = <NUM_LIT:0>, name: str = None) -> SamplePulse:", "body": "if freq is None:<EOL><INDENT>freq = <NUM_LIT:1>/duration<EOL><DEDENT>return _sampled_sin_pulse(duration, amp, freq, phase=phase, name=name)<EOL>", "docstring": "Generates sine wave `SamplePulse`.\n\n    Args:\n        duration: Duration of pulse. Must be greater than zero.\n        amp: Pulse amplitude.\n        freq: Pulse frequency, units of 1/dt. If `None` defaults to single cycle.\n        phase: Pulse phase.\n        name: Name of pulse.", "id": "f10752:m6"}
{"signature": "@abstractmethod<EOL><INDENT>def __lshift__(self, time: int) -> '<STR_LIT>':<DEDENT>", "body": "pass<EOL>", "docstring": "Return a new schedule which is shifted forward by `time`.", "id": "f10753:c0:m18"}
{"signature": "@abstractmethod<EOL><INDENT>def append(self, schedule: '<STR_LIT>') -> '<STR_LIT>':<DEDENT>", "body": "pass<EOL>", "docstring": "Return a new schedule with `schedule` inserted at the maximum time over\n        all channels shared between `self` and `schedule`.\n        Args:\n            schedule: schedule to be appended", "id": "f10753:c0:m15"}
{"signature": "@property<EOL><INDENT>@abstractmethod<EOL>def name(self) -> str:<DEDENT>", "body": "pass<EOL>", "docstring": "Name of ScheduleComponent.", "id": "f10753:c0:m0"}
{"signature": "@abstractmethod<EOL><INDENT>def insert(self, start_time: int, schedule: '<STR_LIT>') -> '<STR_LIT>':<DEDENT>", "body": "pass<EOL>", "docstring": "Return a new schedule with `schedule` inserted at `start_time` of `self`.\n        Args:\n            start_time: time to be inserted\n            schedule: schedule to be inserted", "id": "f10753:c0:m14"}
{"signature": "@property<EOL><INDENT>@abstractmethod<EOL>def instructions(self) -> Tuple[Tuple[int, '<STR_LIT>']]:<DEDENT>", "body": "pass<EOL>", "docstring": "Return iterable for all `Instruction`s in `Schedule` tree.", "id": "f10753:c0:m10"}
{"signature": "@property<EOL><INDENT>@abstractmethod<EOL>def children(self) -> Tuple[Union[int, '<STR_LIT>']]:<DEDENT>", "body": "pass<EOL>", "docstring": "Child nodes of this schedule component.", "id": "f10753:c0:m9"}
{"signature": "@property<EOL><INDENT>@abstractmethod<EOL>def channels(self) -> List[Channel]:<DEDENT>", "body": "pass<EOL>", "docstring": "Return channels used by schedule.", "id": "f10753:c0:m1"}
{"signature": "@abstractmethod<EOL><INDENT>def __add__(self, schedule: '<STR_LIT>') -> '<STR_LIT>':<DEDENT>", "body": "pass<EOL>", "docstring": "Return a new schedule with `schedule` inserted within `self` at `start_time`.", "id": "f10753:c0:m16"}
{"signature": "@property<EOL><INDENT>def type(self) -> str:<DEDENT>", "body": "return self._type<EOL>", "docstring": "Type of snapshot.", "id": "f10754:c0:m1"}
{"signature": "def __eq__(self, other):", "body": "if type(self) is type(other) andself._name == other._name andself._params == other._params:<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Two measurement options are the same if they are of the same type\n        and have the same name and params.\n\n        Args:\n            other (MeasOpts): Other Discriminator/Kernel.\n\n        Returns:\n            bool: are self and other equal.", "id": "f10755:c0:m3"}
{"signature": "@property<EOL><INDENT>def name(self):<DEDENT>", "body": "return self._name<EOL>", "docstring": "Return parameter name.", "id": "f10755:c0:m1"}
{"signature": "def __eq__(self, other):", "body": "if type(self) is type(other) andself.phase == other.phase:<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Two FrameChanges are the same if they are of the same type\n        and have the same phase.\n\n        Args:\n            other (FrameChange): other FrameChange\n\n        Returns:\n            bool: are self and other equal.", "id": "f10756:c0:m2"}
{"signature": "def insert(self, start_time: int, schedule: ScheduleComponent) -> '<STR_LIT>':", "body": "return ops.insert(self, start_time, schedule)<EOL>", "docstring": "Return a new schedule with `schedule` inserted within `self` at `start_time`.\n\n        Args:\n            start_time: time to be inserted\n            schedule: schedule to be inserted", "id": "f10757:c0:m17"}
{"signature": "def __add__(self, schedule: ScheduleComponent) -> '<STR_LIT>':", "body": "return self.append(schedule)<EOL>", "docstring": "Return a new schedule with `schedule` inserted within `self` at `start_time`.", "id": "f10757:c0:m19"}
{"signature": "@property<EOL><INDENT>def stop_time(self) -> int:<DEDENT>", "body": "return self.timeslots.stop_time<EOL>", "docstring": "Relative end time of this instruction.", "id": "f10757:c0:m6"}
{"signature": "def _instructions(self, time: int = <NUM_LIT:0>) -> Iterable[Tuple[int, '<STR_LIT>']]:", "body": "yield (time, self)<EOL>", "docstring": "Iterable for flattening Schedule tree.\n\n        Args:\n            time: Shifted time of this node due to parent\n\n        Yields:\n            Tuple[int, ScheduleComponent]: Tuple containing time `ScheduleComponent` starts\n                at and the flattened `ScheduleComponent`.", "id": "f10757:c0:m13"}
{"signature": "def append(self, schedule: ScheduleComponent) -> '<STR_LIT>':", "body": "return ops.append(self, schedule)<EOL>", "docstring": "Return a new schedule with `schedule` inserted at the maximum time over\n        all channels shared between `self` and `schedule`.\n\n        Args:\n            schedule: schedule to be appended", "id": "f10757:c0:m18"}
{"signature": "def ch_duration(self, *channels: List[Channel]) -> int:", "body": "return self.timeslots.ch_duration(*channels)<EOL>", "docstring": "Return duration of the supplied channels in this Instruction.\n\n        Args:\n            *channels: Supplied channels", "id": "f10757:c0:m10"}
{"signature": "def ch_stop_time(self, *channels: List[Channel]) -> int:", "body": "return self.timeslots.ch_stop_time(*channels)<EOL>", "docstring": "Return maximum start time for supplied channels.\n\n        Args:\n            *channels: Supplied channels", "id": "f10757:c0:m12"}
{"signature": "@property<EOL><INDENT>def discriminator(self):<DEDENT>", "body": "return self._discriminator<EOL>", "docstring": "Return discrimination settings.", "id": "f10758:c0:m2"}
{"signature": "def __eq__(self, other):", "body": "if type(self) is type(other) andself.kernel == other.kernel andself.discriminator == other.discriminator:<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Two Acquires are the same if they are of the same type\n        and have the same kernel and discriminator.\n\n        Args:\n            other (Acquire): Other Acquire\n\n        Returns:\n            bool: are self and other equal.", "id": "f10758:c0:m3"}
{"signature": "@property<EOL><INDENT>def kernel(self):<DEDENT>", "body": "return self._kernel<EOL>", "docstring": "Return kernel settings.", "id": "f10758:c0:m1"}
{"signature": "def __call__(self, *args, **kwargs):", "body": "return self.to_instruction(*args, **kwargs)<EOL>", "docstring": "Creates an Instruction obtained from call to `to_instruction` wrapped in a Schedule.", "id": "f10759:c0:m4"}
{"signature": "def __eq__(self, other):", "body": "if super().__eq__(other) and(self._samples == other._samples).all():<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Two SamplePulses are the same if they are of the same type\n        and have the same name and samples.\n\n        Args:\n            other (SamplePulse): other SamplePulse\n\n        Returns:\n            bool: are self and other equal.", "id": "f10763:c0:m3"}
{"signature": "@property<EOL><INDENT>def samples(self):<DEDENT>", "body": "return self._samples<EOL>", "docstring": "Return sample values.", "id": "f10763:c0:m1"}
{"signature": "def meas_lo_dict(self) -> Dict:", "body": "return self._m_lo_freq<EOL>", "docstring": "Return items of meas LOs.", "id": "f10764:c0:m2"}
{"signature": "def qubit_lo_dict(self) -> Dict:", "body": "return self._q_lo_freq<EOL>", "docstring": "Return items of qubit LOs.", "id": "f10764:c0:m1"}
{"signature": "def insert(self, start_time: int, schedule: ScheduleComponent) -> '<STR_LIT>':", "body": "return ops.insert(self, start_time, schedule)<EOL>", "docstring": "Return a new schedule with `schedule` inserted within `self` at `start_time`.\n\n        Args:\n            start_time: time to be inserted\n            schedule: schedule to be inserted", "id": "f10766:c0:m15"}
{"signature": "def append(self, schedule: ScheduleComponent) -> '<STR_LIT>':", "body": "return ops.append(self, schedule)<EOL>", "docstring": "Return a new schedule with `schedule` inserted at the maximum time over\n        all channels shared between `self` and `schedule`.\n\n        Args:\n            schedule: schedule to be appended", "id": "f10766:c0:m16"}
{"signature": "def __lshift__(self, time: int) -> '<STR_LIT>':", "body": "return self.shift(time)<EOL>", "docstring": "Return a new schedule which is shifted forward by `time`.", "id": "f10766:c0:m20"}
{"signature": "@property<EOL><INDENT>def start_time(self) -> int:<DEDENT>", "body": "return self.ch_start_time(*self.channels)<EOL>", "docstring": "Return earliest start time in this collection.", "id": "f10767:c2:m3"}
{"signature": "def __init__(self, *timeslots: List[Timeslot]):", "body": "self._table = defaultdict(list)<EOL>for slot in timeslots:<EOL><INDENT>for interval in self._table[slot.channel]:<EOL><INDENT>if slot.interval.has_overlap(interval):<EOL><INDENT>raise PulseError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>self._table[slot.channel].append(slot.interval)<EOL><DEDENT>self._timeslots = tuple(timeslots)<EOL>", "docstring": "Create a new time-slot collection.\n\n        Args:\n            *timeslots: list of time slots\n        Raises:\n            PulseError: when overlapped time slots are specified", "id": "f10767:c2:m0"}
{"signature": "@property<EOL><INDENT>def channel(self):<DEDENT>", "body": "return self._channel<EOL>", "docstring": "Channel of this time slot.", "id": "f10767:c1:m2"}
{"signature": "@property<EOL><INDENT>def timeslots(self) -> Tuple[Timeslot]:<DEDENT>", "body": "return self._timeslots<EOL>", "docstring": "`Timeslot`s in collection.", "id": "f10767:c2:m1"}
{"signature": "def __eq__(self, other):", "body": "if self._begin == other._begin and self._end == other._end:<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Two intervals are the same if they have the same begin and end.\n\n        Args:\n            other (Interval): other Interval\n\n        Returns:\n            bool: are self and other equal.", "id": "f10767:c0:m6"}
{"signature": "def ch_duration(self, *channels: List[Channel]) -> int:", "body": "return self.ch_stop_time(*channels)<EOL>", "docstring": "Return maximum duration of timeslots over all channels.\n\n        Args:\n            *channels: Channels over which to obtain the duration.", "id": "f10767:c2:m8"}
{"signature": "@property<EOL><INDENT>def duration(self):<DEDENT>", "body": "return self._end - self._begin<EOL>", "docstring": "Duration of this interval.", "id": "f10767:c0:m3"}
{"signature": "def topological_nodes(self):", "body": "return nx.lexicographical_topological_sort(self._multi_graph,<EOL>key=lambda x: str(x.qargs))<EOL>", "docstring": "Yield nodes in topological order.\n\nReturns:\n    generator(DAGNode): node in topological order", "id": "f10770:c0:m36"}
{"signature": "@property<EOL><INDENT>def node_counter(self):<DEDENT>", "body": "warnings.warn('<STR_LIT>'<EOL>'<STR_LIT>',<EOL>DeprecationWarning, <NUM_LIT:2>)<EOL>return len(self._multi_graph)<EOL>", "docstring": "Deprecated usage to return max node id, now returns size of DAG", "id": "f10770:c0:m8"}
{"signature": "def _check_bits(self, args, amap):", "body": "<EOL>for wire in args:<EOL><INDENT>if wire not in amap:<EOL><INDENT>raise DAGCircuitError(\"<STR_LIT>\" %<EOL>(wire[<NUM_LIT:0>].name, wire[<NUM_LIT:1>]))<EOL><DEDENT><DEDENT>", "docstring": "Check the values of a list of (qu)bit arguments.\n\n        For each element of args, check that amap contains it.\n\n        Args:\n            args (list): (register,idx) tuples\n            amap (dict): a dictionary keyed on (register,idx) tuples\n\n        Raises:\n            DAGCircuitError: if a qubit is not contained in amap", "id": "f10770:c0:m15"}
{"signature": "def get_2q_nodes(self):", "body": "warnings.warn('<STR_LIT>',<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>DeprecationWarning, <NUM_LIT:2>)<EOL>two_q_nodes = []<EOL>for node in self._multi_graph.nodes():<EOL><INDENT>if node.type == '<STR_LIT>' and len(node.qargs) == <NUM_LIT:2>:<EOL><INDENT>two_q_nodes.append(node.data_dict)<EOL><DEDENT><DEDENT>return two_q_nodes<EOL>", "docstring": "Deprecated. Use twoQ_gates().", "id": "f10770:c0:m48"}
{"signature": "def serial_layers(self):", "body": "for next_node in self.topological_op_nodes():<EOL><INDENT>new_layer = DAGCircuit()<EOL>for qreg in self.qregs.values():<EOL><INDENT>new_layer.add_qreg(qreg)<EOL><DEDENT>for creg in self.cregs.values():<EOL><INDENT>new_layer.add_creg(creg)<EOL><DEDENT>support_list = []<EOL>op = copy.copy(next_node.op)<EOL>qa = copy.copy(next_node.qargs)<EOL>ca = copy.copy(next_node.cargs)<EOL>co = copy.copy(next_node.condition)<EOL>_ = self._bits_in_condition(co)<EOL>new_layer.apply_operation_back(op, qa, ca, co)<EOL>if next_node.name not in [\"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>support_list.append(list(qa))<EOL><DEDENT>l_dict = {\"<STR_LIT>\": new_layer, \"<STR_LIT>\": support_list}<EOL>yield l_dict<EOL><DEDENT>", "docstring": "Yield a layer for all gates of this circuit.\n\n        A serial layer is a circuit with one gate. The layers have the\n        same structure as in layers().", "id": "f10770:c0:m65"}
{"signature": "def num_tensor_factors(self):", "body": "return nx.number_weakly_connected_components(self._multi_graph)<EOL>", "docstring": "Compute how many components the circuit can decompose into.", "id": "f10770:c0:m30"}
{"signature": "def get_named_nodes(self, *names):", "body": "warnings.warn('<STR_LIT>',<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>DeprecationWarning, <NUM_LIT:2>)<EOL>named_nodes = []<EOL>for node in self._multi_graph.nodes():<EOL><INDENT>if node.type == '<STR_LIT>' and node.op.name in names:<EOL><INDENT>named_nodes.append(node._node_id)<EOL><DEDENT><DEDENT>return named_nodes<EOL>", "docstring": "Deprecated. Use named_nodes().", "id": "f10770:c0:m46"}
{"signature": "def substitute_node_with_dag(self, node, input_dag, wires=None):", "body": "if isinstance(node, int):<EOL><INDENT>warnings.warn('<STR_LIT>'<EOL>'<STR_LIT>',<EOL>DeprecationWarning, <NUM_LIT:2>)<EOL>node = self._id_to_node[node]<EOL><DEDENT>condition = node.condition<EOL>if condition:<EOL><INDENT>input_dag.add_creg(condition[<NUM_LIT:0>])<EOL>to_replay = []<EOL>for sorted_node in input_dag.topological_nodes():<EOL><INDENT>if sorted_node.type == \"<STR_LIT>\":<EOL><INDENT>sorted_node.op.control = condition<EOL>to_replay.append(sorted_node)<EOL><DEDENT><DEDENT>for input_node in input_dag.op_nodes():<EOL><INDENT>input_dag.remove_op_node(input_node)<EOL><DEDENT>for replay_node in to_replay:<EOL><INDENT>input_dag.apply_operation_back(replay_node.op, replay_node.qargs,<EOL>replay_node.cargs, condition=condition)<EOL><DEDENT><DEDENT>if wires is None:<EOL><INDENT>qwires = [w for w in input_dag.wires if isinstance(w[<NUM_LIT:0>], QuantumRegister)]<EOL>cwires = [w for w in input_dag.wires if isinstance(w[<NUM_LIT:0>], ClassicalRegister)]<EOL>wires = qwires + cwires<EOL><DEDENT>self._check_wires_list(wires, node)<EOL>proxy_map = {w: QuantumRegister(<NUM_LIT:1>, '<STR_LIT>') for w in wires}<EOL>add_qregs = self._check_edgemap_registers(proxy_map,<EOL>input_dag.qregs,<EOL>{}, False)<EOL>for qreg in add_qregs:<EOL><INDENT>self.add_qreg(qreg)<EOL><DEDENT>add_cregs = self._check_edgemap_registers(proxy_map,<EOL>input_dag.cregs,<EOL>{}, False)<EOL>for creg in add_cregs:<EOL><INDENT>self.add_creg(creg)<EOL><DEDENT>if node.type != \"<STR_LIT>\":<EOL><INDENT>raise DAGCircuitError(\"<STR_LIT>\"<EOL>% node.type)<EOL><DEDENT>condition_bit_list = self._bits_in_condition(node.condition)<EOL>wire_map = {k: v for k, v in zip(wires,<EOL>[i for s in [node.qargs,<EOL>node.cargs,<EOL>condition_bit_list]<EOL>for i in s])}<EOL>self._check_wiremap_validity(wire_map, wires, self.input_map)<EOL>pred_map, succ_map = self._make_pred_succ_maps(node)<EOL>full_pred_map, full_succ_map = self._full_pred_succ_maps(pred_map, succ_map,<EOL>input_dag, wire_map)<EOL>self._multi_graph.remove_node(node)<EOL>for sorted_node in input_dag.topological_op_nodes():<EOL><INDENT>condition = self._map_condition(wire_map, sorted_node.condition)<EOL>m_qargs = list(map(lambda x: wire_map.get(x, x),<EOL>sorted_node.qargs))<EOL>m_cargs = list(map(lambda x: wire_map.get(x, x),<EOL>sorted_node.cargs))<EOL>self._add_op_node(sorted_node.op, m_qargs, m_cargs, condition)<EOL>all_cbits = self._bits_in_condition(condition)<EOL>all_cbits.extend(m_cargs)<EOL>al = [m_qargs, all_cbits]<EOL>for q in itertools.chain(*al):<EOL><INDENT>self._multi_graph.add_edge(full_pred_map[q],<EOL>self._id_to_node[self._max_node_id],<EOL>name=\"<STR_LIT>\" % (q[<NUM_LIT:0>].name, q[<NUM_LIT:1>]),<EOL>wire=q)<EOL>full_pred_map[q] = self._id_to_node[self._max_node_id]<EOL><DEDENT><DEDENT>for w in full_pred_map:<EOL><INDENT>self._multi_graph.add_edge(full_pred_map[w],<EOL>full_succ_map[w],<EOL>name=\"<STR_LIT>\" % (w[<NUM_LIT:0>].name, w[<NUM_LIT:1>]),<EOL>wire=w)<EOL>o_pred = list(self._multi_graph.predecessors(self.output_map[w]))<EOL>if len(o_pred) > <NUM_LIT:1>:<EOL><INDENT>if len(o_pred) != <NUM_LIT:2>:<EOL><INDENT>raise DAGCircuitError(\"<STR_LIT>\")<EOL><DEDENT>p = [x for x in o_pred if x != full_pred_map[w]]<EOL>if len(p) != <NUM_LIT:1>:<EOL><INDENT>raise DAGCircuitError(\"<STR_LIT>\")<EOL><DEDENT>self._multi_graph.remove_edge(p[<NUM_LIT:0>], self.output_map[w])<EOL><DEDENT><DEDENT>", "docstring": "Replace one node with dag.\n\n        Args:\n            node (DAGNode): node to substitute\n            input_dag (DAGCircuit): circuit that will substitute the node\n            wires (list[(Register, index)]): gives an order for (qu)bits\n                in the input circuit. This order gets matched to the node wires\n                by qargs first, then cargs, then conditions.\n\n        Raises:\n            DAGCircuitError: if met with unexpected predecessor/successors", "id": "f10770:c0:m38"}
{"signature": "def nodes(self):", "body": "for node in self._multi_graph.nodes:<EOL><INDENT>yield node<EOL><DEDENT>", "docstring": "Iterator for node values.\n\n        Yield:\n            node: the node.", "id": "f10770:c0:m40"}
{"signature": "def _bits_in_condition(self, cond):", "body": "all_bits = []<EOL>if cond is not None:<EOL><INDENT>all_bits.extend([(cond[<NUM_LIT:0>], j) for j in range(self.cregs[cond[<NUM_LIT:0>].name].size)])<EOL><DEDENT>return all_bits<EOL>", "docstring": "Return a list of bits in the given condition.\n\n        Args:\n            cond (tuple or None): optional condition (ClassicalRegister, int)\n\n        Returns:\n            list[(ClassicalRegister, idx)]: list of bits", "id": "f10770:c0:m16"}
{"signature": "def get_3q_or_more_nodes(self):", "body": "warnings.warn('<STR_LIT>'<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>DeprecationWarning, <NUM_LIT:2>)<EOL>three_q_nodes = []<EOL>for node in self._multi_graph.nodes():<EOL><INDENT>if node.type == '<STR_LIT>' and len(node.qargs) >= <NUM_LIT:3>:<EOL><INDENT>three_q_nodes.append((node._node_id, node.data_dict))<EOL><DEDENT><DEDENT>return three_q_nodes<EOL>", "docstring": "Deprecated. Use threeQ_or_more_gates().", "id": "f10770:c0:m50"}
{"signature": "def depth(self):", "body": "if not nx.is_directed_acyclic_graph(self._multi_graph):<EOL><INDENT>raise DAGCircuitError(\"<STR_LIT>\")<EOL><DEDENT>depth = nx.dag_longest_path_length(self._multi_graph) - <NUM_LIT:1><EOL>return depth if depth != -<NUM_LIT:1> else <NUM_LIT:0><EOL>", "docstring": "Return the circuit depth.\n        Returns:\n            int: the circuit depth\n        Raises:\n            DAGCircuitError: if not a directed acyclic graph", "id": "f10770:c0:m27"}
{"signature": "def properties(self):", "body": "summary = {\"<STR_LIT:size>\": self.size(),<EOL>\"<STR_LIT>\": self.depth(),<EOL>\"<STR_LIT:width>\": self.width(),<EOL>\"<STR_LIT>\": self.num_cbits(),<EOL>\"<STR_LIT>\": self.num_tensor_factors(),<EOL>\"<STR_LIT>\": self.count_ops()}<EOL>return summary<EOL>", "docstring": "Return a dictionary of circuit properties.", "id": "f10770:c0:m70"}
{"signature": "def extend_back(self, dag, edge_map=None):", "body": "edge_map = edge_map or {}<EOL>for qreg in dag.qregs.values():<EOL><INDENT>if qreg.name not in self.qregs:<EOL><INDENT>self.add_qreg(QuantumRegister(qreg.size, qreg.name))<EOL><DEDENT>edge_map.update([(qbit, qbit) for qbit in qreg if qbit not in edge_map])<EOL><DEDENT>for creg in dag.cregs.values():<EOL><INDENT>if creg.name not in self.cregs:<EOL><INDENT>self.add_creg(ClassicalRegister(creg.size, creg.name))<EOL><DEDENT>edge_map.update([(cbit, cbit) for cbit in creg if cbit not in edge_map])<EOL><DEDENT>self.compose_back(dag, edge_map)<EOL>", "docstring": "Add `dag` at the end of `self`, using `edge_map`.", "id": "f10770:c0:m23"}
{"signature": "def num_cbits(self):", "body": "return sum(creg.size for creg in self.cregs.values())<EOL>", "docstring": "Return the total number of bits used by the circuit.", "id": "f10770:c0:m29"}
{"signature": "def size(self):", "body": "return self._multi_graph.order() - <NUM_LIT:2> * len(self.wires)<EOL>", "docstring": "Return the number of operations.", "id": "f10770:c0:m26"}
{"signature": "def qubits(self):", "body": "return [(v, i) for k, v in self.qregs.items() for i in range(v.size)]<EOL>", "docstring": "Return a list of qubits as (QuantumRegister, index) pairs.", "id": "f10770:c0:m5"}
{"signature": "def topological_op_nodes(self):", "body": "return (nd for nd in self.topological_nodes() if nd.type == '<STR_LIT>')<EOL>", "docstring": "Yield op nodes in topological order.\n\nReturns:\n    generator(DAGnode): op node in topological order", "id": "f10770:c0:m37"}
{"signature": "def _check_condition(self, name, condition):", "body": "<EOL>if condition is not None and condition[<NUM_LIT:0>].name not in self.cregs:<EOL><INDENT>raise DAGCircuitError(\"<STR_LIT>\" % name)<EOL><DEDENT>", "docstring": "Verify that the condition is valid.\n\n        Args:\n            name (string): used for error reporting\n            condition (tuple or None): a condition tuple (ClassicalRegister,int)\n\n        Raises:\n            DAGCircuitError: if conditioning on an invalid register", "id": "f10770:c0:m14"}
{"signature": "@property<EOL><INDENT>def wire(self):<DEDENT>", "body": "if self.data_dict['<STR_LIT:type>'] not in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>raise QiskitError('<STR_LIT>' % str(self))<EOL><DEDENT>return self.data_dict.get('<STR_LIT>')<EOL>", "docstring": "Returns (Register, int) tuple where the int is the index of\nthe wire else None", "id": "f10771:c0:m9"}
{"signature": "@property<EOL><INDENT>def cargs(self):<DEDENT>", "body": "return self.data_dict.get('<STR_LIT>', [])<EOL>", "docstring": "Returns list of (ClassicalRegister, int) tuples where the int is the index\nof the cbit else an empty list", "id": "f10771:c0:m7"}
{"signature": "@qargs.setter<EOL><INDENT>def qargs(self, new_qargs):<DEDENT>", "body": "self.data_dict['<STR_LIT>'] = new_qargs<EOL>", "docstring": "Sets the qargs to be the given list of qargs", "id": "f10771:c0:m6"}
{"signature": "@staticmethod<EOL><INDENT>def semantic_eq(node1, node2):<DEDENT>", "body": "<EOL>if '<STR_LIT>' == node1.name == node2.name:<EOL><INDENT>return set(node1.qargs) == set(node2.qargs)<EOL><DEDENT>return node1.data_dict == node2.data_dict<EOL>", "docstring": "Check if DAG nodes are considered equivalent, e.g. as a node_match for nx.is_isomorphic.\n\nArgs:\n    node1 (DAGNode): A node to compare.\n    node2 (DAGNode): The other node to compare.\n\nReturn:\n    Bool: If node1 == node2", "id": "f10771:c0:m15"}
{"signature": "@name.setter<EOL><INDENT>def name(self, new_name):<DEDENT>", "body": "self.data_dict['<STR_LIT:name>'] = new_name<EOL>", "docstring": "Sets the name of the node to be the given value", "id": "f10771:c0:m4"}
{"signature": "def __init__(self, *msg):", "body": "super().__init__(*msg)<EOL>self.msg = '<STR_LIT:U+0020>'.join(msg)<EOL>", "docstring": "Set the error message.", "id": "f10773:c0:m0"}
{"signature": "def _process_cnot(self, node):", "body": "id0 = self._process_bit_id(node.children[<NUM_LIT:0>])<EOL>id1 = self._process_bit_id(node.children[<NUM_LIT:1>])<EOL>if not(len(id0) == len(id1) or len(id0) == <NUM_LIT:1> or len(id1) == <NUM_LIT:1>):<EOL><INDENT>raise QiskitError(\"<STR_LIT>\",<EOL>\"<STR_LIT>\" % node.line, \"<STR_LIT>\" % node.file)<EOL><DEDENT>maxidx = max([len(id0), len(id1)])<EOL>for idx in range(maxidx):<EOL><INDENT>if len(id0) > <NUM_LIT:1> and len(id1) > <NUM_LIT:1>:<EOL><INDENT>self.dag.apply_operation_back(CXBase(), [id0[idx], id1[idx]], [], self.condition)<EOL><DEDENT>elif len(id0) > <NUM_LIT:1>:<EOL><INDENT>self.dag.apply_operation_back(CXBase(), [id0[idx], id1[<NUM_LIT:0>]], [], self.condition)<EOL><DEDENT>else:<EOL><INDENT>self.dag.apply_operation_back(CXBase(), [id0[<NUM_LIT:0>], id1[idx]], [], self.condition)<EOL><DEDENT><DEDENT>", "docstring": "Process a CNOT gate node.", "id": "f10779:c0:m4"}
{"signature": "def _create_dag_op(self, name, params, qargs):", "body": "if name == \"<STR_LIT>\":<EOL><INDENT>op_class = U0Gate<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>op_class = U1Gate<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>op_class = U2Gate<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>op_class = U3Gate<EOL><DEDENT>elif name == \"<STR_LIT:x>\":<EOL><INDENT>op_class = XGate<EOL><DEDENT>elif name == \"<STR_LIT:y>\":<EOL><INDENT>op_class = YGate<EOL><DEDENT>elif name == \"<STR_LIT:z>\":<EOL><INDENT>op_class = ZGate<EOL><DEDENT>elif name == \"<STR_LIT:t>\":<EOL><INDENT>op_class = TGate<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>op_class = TdgGate<EOL><DEDENT>elif name == \"<STR_LIT:s>\":<EOL><INDENT>op_class = SGate<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>op_class = SdgGate<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>op_class = SwapGate<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>op_class = RXGate<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>op_class = RYGate<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>op_class = RZGate<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>op_class = RZZGate<EOL><DEDENT>elif name == \"<STR_LIT:id>\":<EOL><INDENT>op_class = IdGate<EOL><DEDENT>elif name == \"<STR_LIT:h>\":<EOL><INDENT>op_class = HGate<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>op_class = CnotGate<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>op_class = CyGate<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>op_class = CzGate<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>op_class = CHGate<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>op_class = CrzGate<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>op_class = Cu1Gate<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>op_class = Cu3Gate<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>op_class = ToffoliGate<EOL><DEDENT>elif name == \"<STR_LIT>\":<EOL><INDENT>op_class = FredkinGate<EOL><DEDENT>else:<EOL><INDENT>raise QiskitError(\"<STR_LIT>\" % name)<EOL><DEDENT>op = op_class(*params)<EOL>self.dag.apply_operation_back(op, qargs, [], condition=self.condition)<EOL>", "docstring": "Create a DAG node out of a parsed AST op node.\n\nArgs:\n    name (str): operation name to apply to the dag.\n    params (list): op parameters\n    qargs (list(QuantumRegister, int)): qubits to attach to\n\nRaises:\n    QiskitError: if encountering a non-basis opaque gate", "id": "f10779:c0:m9"}
{"signature": "def _process_children(self, node):", "body": "for kid in node.children:<EOL><INDENT>self._process_node(kid)<EOL><DEDENT>", "docstring": "Call process_node for all children of node.", "id": "f10779:c0:m7"}
{"signature": "def projector(state, flatten=False):", "body": "density_matrix = np.outer(state.conjugate(), state)<EOL>if flatten:<EOL><INDENT>return density_matrix.flatten(order='<STR_LIT:F>')<EOL><DEDENT>return density_matrix<EOL>", "docstring": "maps a pure state to a state matrix\n\nArgs:\n    state (ndarray): the number of qubits\n    flatten (bool): determine if state matrix of column work\nReturns:\n    ndarray:  state_mat(2**num, 2**num) if flatten is false\n    ndarray:  state_mat(4**num) if flatten is true stacked on by the column", "id": "f10781:m1"}
{"signature": "def _funm_svd(a, func):", "body": "U, s, Vh = la.svd(a, lapack_driver='<STR_LIT>')<EOL>S = np.diag(func(s))<EOL>return U.dot(S).dot(Vh)<EOL>", "docstring": "Apply real scalar function to singular values of a matrix.\n\n    Args:\n        a (array_like): (N, N) Matrix at which to evaluate the function.\n        func (callable): Callable object that evaluates a scalar function f.\n\n    Returns:\n        ndarray: funm (N, N) Value of the matrix function specified by func\n        evaluated at `A`.", "id": "f10782:m1"}
{"signature": "def random_density_matrix(length, rank=None, method='<STR_LIT>', seed=None):", "body": "if method == '<STR_LIT>':<EOL><INDENT>return __random_density_hs(length, rank, seed)<EOL><DEDENT>elif method == '<STR_LIT>':<EOL><INDENT>return __random_density_bures(length, rank, seed)<EOL><DEDENT>else:<EOL><INDENT>raise QiskitError('<STR_LIT>'.format(method))<EOL><DEDENT>", "docstring": "Generate a random density matrix rho.\n\nArgs:\n    length (int): the length of the density matrix.\n    rank (int or None): the rank of the density matrix. The default\n        value is full-rank.\n    method (string): the method to use.\n        'Hilbert-Schmidt': sample rho from the Hilbert-Schmidt metric.\n        'Bures': sample rho from the Bures metric.\n    seed (int): Optional. To set a random seed.\nReturns:\n    ndarray: rho (length, length) a density matrix.\nRaises:\n    QiskitError: if the method is not valid.", "id": "f10785:m2"}
{"signature": "def __random_density_hs(N, rank=None, seed=None):", "body": "G = __ginibre_matrix(N, rank, seed)<EOL>G = G.dot(G.conj().T)<EOL>return G / np.trace(G)<EOL>", "docstring": "Generate a random density matrix from the Hilbert-Schmidt metric.\n\nArgs:\n    N (int): the length of the density matrix.\n    rank (int or None): the rank of the density matrix. The default\n        value is full-rank.\n    seed (int): Optional. To set a random seed.\nReturns:\n    ndarray: rho (N,N  a density matrix.", "id": "f10785:m4"}
{"signature": "def __ginibre_matrix(nrow, ncol=None, seed=None):", "body": "if ncol is None:<EOL><INDENT>ncol = nrow<EOL><DEDENT>if seed is not None:<EOL><INDENT>np.random.seed(seed)<EOL><DEDENT>G = np.random.normal(size=(nrow, ncol)) +np.random.normal(size=(nrow, ncol)) * <NUM_LIT><EOL>return G<EOL>", "docstring": "Return a normally distributed complex random matrix.\n\nArgs:\n    nrow (int): number of rows in output matrix.\n    ncol (int): number of columns in output matrix.\n    seed (int): Optional. To set a random seed.\nReturns:\n    ndarray: A complex rectangular matrix where each real and imaginary\n        entry is sampled from the normal distribution.", "id": "f10785:m3"}
{"signature": "def average_data(counts, observable):", "body": "if not isinstance(observable, dict):<EOL><INDENT>observable = make_dict_observable(observable)<EOL><DEDENT>temp = <NUM_LIT:0><EOL>tot = sum(counts.values())<EOL>for key in counts:<EOL><INDENT>if key in observable:<EOL><INDENT>temp += counts[key] * observable[key] / tot<EOL><DEDENT><DEDENT>return temp<EOL>", "docstring": "Compute the mean value of an diagonal observable.\n\n    Takes in a diagonal observable in dictionary, list or matrix format and then\n    calculates the sum_i value(i) P(i) where value(i) is the value of the\n    observable for state i.\n\n    Args:\n        counts (dict): a dict of outcomes from an experiment\n        observable (dict or matrix or list): The observable to be averaged over.\n        As an example, ZZ on qubits can be given as:\n        * dict: {\"00\": 1, \"11\": 1, \"01\": -1, \"10\": -1}\n        * matrix: [[1, 0, 0, 0], [0, -1, 0, 0, ], [0, 0, -1, 0], [0, 0, 0, 1]]\n        * matrix diagonal (list): [1, -1, -1, 1]\n\n    Returns:\n        Double: Average of the observable", "id": "f10791:m0"}
{"signature": "def process_fidelity(channel1, channel2, require_cptp=True):", "body": "<EOL>is_cptp1 = None<EOL>is_cptp2 = None<EOL>if isinstance(channel1, (list, np.ndarray)):<EOL><INDENT>channel1 = Operator(channel1)<EOL>if require_cptp:<EOL><INDENT>is_cptp1 = channel1.is_unitary()<EOL><DEDENT><DEDENT>if isinstance(channel2, (list, np.ndarray)):<EOL><INDENT>channel2 = Operator(channel2)<EOL>if require_cptp:<EOL><INDENT>is_cptp2 = channel2.is_unitary()<EOL><DEDENT><DEDENT>s1 = SuperOp(channel1)<EOL>s2 = SuperOp(channel2)<EOL>if require_cptp:<EOL><INDENT>if is_cptp1 is None:<EOL><INDENT>is_cptp1 = s1.is_cptp()<EOL><DEDENT>if not is_cptp1:<EOL><INDENT>raise QiskitError('<STR_LIT>')<EOL><DEDENT>if is_cptp2 is None:<EOL><INDENT>is_cptp2 = s2.is_cptp()<EOL><DEDENT>if not is_cptp2:<EOL><INDENT>raise QiskitError('<STR_LIT>')<EOL><DEDENT><DEDENT>input_dim1, output_dim1 = s1.dim<EOL>input_dim2, output_dim2 = s2.dim<EOL>if input_dim1 != output_dim1 or input_dim2 != output_dim2:<EOL><INDENT>raise QiskitError('<STR_LIT>')<EOL><DEDENT>if input_dim1 != input_dim2:<EOL><INDENT>raise QiskitError('<STR_LIT>')<EOL><DEDENT>fidelity = np.trace(s1.compose(s2.adjoint()).data) / (input_dim1 ** <NUM_LIT:2>)<EOL>return fidelity<EOL>", "docstring": "Return the process fidelity between two quantum channels.\n\n    This is given by\n\n        F_p(E1, E2) = Tr[S2^dagger.S1])/dim^2\n\n    where S1 and S2 are the SuperOp matrices for channels E1 and E2,\n    and dim is the dimension of the input output statespace.\n\n    Args:\n        channel1 (QuantumChannel or matrix): a quantum channel or unitary matrix.\n        channel2 (QuantumChannel or matrix): a quantum channel or unitary matrix.\n        require_cptp (bool): require input channels to be CPTP [Default: True].\n\n    Returns:\n        array_like: The state fidelity F(state1, state2).\n\n    Raises:\n        QiskitError: if inputs channels do not have the same dimensions,\n        have different input and output dimensions, or are not CPTP with\n        `require_cptp=True`.", "id": "f10792:m0"}
{"signature": "def quaternion_from_axis_rotation(angle, axis):", "body": "out = np.zeros(<NUM_LIT:4>, dtype=float)<EOL>if axis == '<STR_LIT:x>':<EOL><INDENT>out[<NUM_LIT:1>] = <NUM_LIT:1><EOL><DEDENT>elif axis == '<STR_LIT:y>':<EOL><INDENT>out[<NUM_LIT:2>] = <NUM_LIT:1><EOL><DEDENT>elif axis == '<STR_LIT:z>':<EOL><INDENT>out[<NUM_LIT:3>] = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>out *= math.sin(angle/<NUM_LIT>)<EOL>out[<NUM_LIT:0>] = math.cos(angle/<NUM_LIT>)<EOL>return Quaternion(out)<EOL>", "docstring": "Return quaternion for rotation about given axis.\n\n    Args:\n        angle (float): Angle in radians.\n        axis (str): Axis for rotation\n\n    Returns:\n        Quaternion: Quaternion for axis rotation.\n\n    Raises:\n        ValueError: Invalid input axis.", "id": "f10793:m0"}
{"signature": "def norm(self):", "body": "return la.norm(self.data)<EOL>", "docstring": "Norm of quaternion.", "id": "f10793:c0:m5"}
{"signature": "def to_zyz(self):", "body": "mat = self.to_matrix()<EOL>euler = np.zeros(<NUM_LIT:3>, dtype=float)<EOL>if mat[<NUM_LIT:2>, <NUM_LIT:2>] < <NUM_LIT:1>:<EOL><INDENT>if mat[<NUM_LIT:2>, <NUM_LIT:2>] > -<NUM_LIT:1>:<EOL><INDENT>euler[<NUM_LIT:0>] = math.atan2(mat[<NUM_LIT:1>, <NUM_LIT:2>], mat[<NUM_LIT:0>, <NUM_LIT:2>])<EOL>euler[<NUM_LIT:1>] = math.acos(mat[<NUM_LIT:2>, <NUM_LIT:2>])<EOL>euler[<NUM_LIT:2>] = math.atan2(mat[<NUM_LIT:2>, <NUM_LIT:1>], -mat[<NUM_LIT:2>, <NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>euler[<NUM_LIT:0>] = -math.atan2(mat[<NUM_LIT:1>, <NUM_LIT:0>], mat[<NUM_LIT:1>, <NUM_LIT:1>])<EOL>euler[<NUM_LIT:1>] = np.pi<EOL><DEDENT><DEDENT>else:<EOL><INDENT>euler[<NUM_LIT:0>] = math.atan2(mat[<NUM_LIT:1>, <NUM_LIT:0>], mat[<NUM_LIT:1>, <NUM_LIT:1>])<EOL><DEDENT>return euler<EOL>", "docstring": "Converts a unit-length quaternion to a sequence\n        of ZYZ Euler angles.\n\n        Returns:\n            ndarray: Array of Euler angles.", "id": "f10793:c0:m8"}
{"signature": "def is_positive_semidefinite_matrix(mat, rtol=RTOL_DEFAULT, atol=ATOL_DEFAULT):", "body": "if atol is None:<EOL><INDENT>atol = ATOL_DEFAULT<EOL><DEDENT>if rtol is None:<EOL><INDENT>rtol = RTOL_DEFAULT<EOL><DEDENT>if not is_hermitian_matrix(mat, rtol=rtol, atol=atol):<EOL><INDENT>return False<EOL><DEDENT>vals = np.linalg.eigvalsh(mat)<EOL>for v in vals:<EOL><INDENT>if v < -atol:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Test if a matrix is positive semidefinite", "id": "f10794:m5"}
{"signature": "def is_hermitian_matrix(mat, rtol=RTOL_DEFAULT, atol=ATOL_DEFAULT):", "body": "if atol is None:<EOL><INDENT>atol = ATOL_DEFAULT<EOL><DEDENT>if rtol is None:<EOL><INDENT>rtol = RTOL_DEFAULT<EOL><DEDENT>mat = np.array(mat)<EOL>if mat.ndim != <NUM_LIT:2>:<EOL><INDENT>return False<EOL><DEDENT>return np.allclose(mat, np.conj(mat.T), rtol=rtol, atol=atol)<EOL>", "docstring": "Test if an array is a Hermitian matrix", "id": "f10794:m4"}
{"signature": "@abstractmethod<EOL><INDENT>def is_unitary(self, atol=None, rtol=None):<DEDENT>", "body": "pass<EOL>", "docstring": "Return True if operator is a unitary matrix.", "id": "f10796:c0:m15"}
{"signature": "@property<EOL><INDENT>def dim(self):<DEDENT>", "body": "return self._input_dim, self._output_dim<EOL>", "docstring": "Return tuple (input_shape, output_shape).", "id": "f10796:c0:m4"}
{"signature": "@property<EOL><INDENT>def _rtol(self):<DEDENT>", "body": "return self.__class__.RTOL<EOL>", "docstring": "The relative tolerence parameter for float comparisons.", "id": "f10796:c0:m8"}
{"signature": "@abstractmethod<EOL><INDENT>def multiply(self, other):<DEDENT>", "body": "pass<EOL>", "docstring": "Return the linear operator self + other.\n\n        Args:\n            other (complex): a complex number.\n\n        Returns:\n            Operator: the linear operator other * self.\n\n        Raises:\n            QiskitError: if other is not a valid complex number.", "id": "f10796:c0:m25"}
{"signature": "@abstractmethod<EOL><INDENT>def to_operator(self):<DEDENT>", "body": "pass<EOL>", "docstring": "Convert operator to matrix operator class", "id": "f10796:c0:m16"}
{"signature": "def to_matrix(self):", "body": "mat = self.to_spmatrix()<EOL>return mat.toarray()<EOL>", "docstring": "r\"\"\"\n        Convert Pauli to a matrix representation.\n\n        Order is q_{n-1} .... q_0, i.e., $P_{n-1} \\otimes ... P_0$\n\n        Returns:\n            numpy.array: a matrix that represents the pauli.", "id": "f10797:c0:m15"}
{"signature": "def __repr__(self):", "body": "z = [p for p in self._z]<EOL>x = [p for p in self._x]<EOL>ret = self.__class__.__name__ + \"<STR_LIT>\".format(z, x)<EOL>return ret<EOL>", "docstring": "Return the representation of self.", "id": "f10797:c0:m4"}
{"signature": "def __init__(self, z=None, x=None, label=None):", "body": "if label is not None:<EOL><INDENT>a = Pauli.from_label(label)<EOL>self._z = a.z<EOL>self._x = a.x<EOL><DEDENT>else:<EOL><INDENT>self._init_from_bool(z, x)<EOL><DEDENT>", "docstring": "r\"\"\"Make the Pauli object.\n\n        Note that, for the qubit index:\n            - Order of z, x vectors is q_0 ... q_{n-1},\n            - Order of pauli label is q_{n-1} ... q_0\n\n        E.g.,\n            - z and x vectors: z = [z_0 ... z_{n-1}], x = [x_0 ... x_{n-1}]\n            - a pauli is $P_{n-1} \\otimes ... \\otimes P_0$\n\n        Args:\n            z (numpy.ndarray): boolean, z vector\n            x (numpy.ndarray): boolean, x vector\n            label (str): pauli label", "id": "f10797:c0:m0"}
{"signature": "def __len__(self):", "body": "return len(self._z)<EOL>", "docstring": "Return number of qubits.", "id": "f10797:c0:m3"}
{"signature": "def to_operator(self):", "body": "<EOL>from qiskit.quantum_info.operators.operator import Operator<EOL>return Operator(self.to_matrix())<EOL>", "docstring": "Convert to Operator object.", "id": "f10797:c0:m17"}
{"signature": "def to_spmatrix(self):", "body": "mat = sparse.coo_matrix(<NUM_LIT:1>)<EOL>for z, x in zip(self._z, self._x):<EOL><INDENT>if not z and not x:  <EOL><INDENT>mat = sparse.bmat([[mat, None], [None, mat]], format='<STR_LIT>')<EOL><DEDENT>elif z and not x:  <EOL><INDENT>mat = sparse.bmat([[mat, None], [None, -mat]], format='<STR_LIT>')<EOL><DEDENT>elif not z and x:  <EOL><INDENT>mat = sparse.bmat([[None, mat], [mat, None]], format='<STR_LIT>')<EOL><DEDENT>else:  <EOL><INDENT>mat = mat * <NUM_LIT><EOL>mat = sparse.bmat([[None, -mat], [mat, None]], format='<STR_LIT>')<EOL><DEDENT><DEDENT>return mat.tocsr()<EOL>", "docstring": "r\"\"\"\n        Convert Pauli to a sparse matrix representation (CSR format).\n\n        Order is q_{n-1} .... q_0, i.e., $P_{n-1} \\otimes ... P_0$\n\n        Returns:\n            scipy.sparse.csr_matrix: a sparse matrix with CSR format that\n            represnets the pauli.", "id": "f10797:c0:m16"}
{"signature": "def _init_from_bool(self, z, x):", "body": "if z is None:<EOL><INDENT>raise QiskitError(\"<STR_LIT>\")<EOL><DEDENT>if x is None:<EOL><INDENT>raise QiskitError(\"<STR_LIT>\")<EOL><DEDENT>if len(z) != len(x):<EOL><INDENT>raise QiskitError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(len(z), len(x)))<EOL><DEDENT>z = _make_np_bool(z)<EOL>x = _make_np_bool(x)<EOL>self._z = z<EOL>self._x = x<EOL>return self<EOL>", "docstring": "Construct pauli from boolean array.\n\n        Args:\n            z (numpy.ndarray): boolean, z vector\n            x (numpy.ndarray): boolean, x vector\n\n        Returns:\n            Pauli: self\n\n        Raises:\n            QiskitError: if z or x are None or the length of z and x are different.", "id": "f10797:c0:m2"}
{"signature": "def __imul__(self, other):", "body": "if len(self) != len(other):<EOL><INDENT>raise QiskitError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(len(self), len(other)))<EOL><DEDENT>self._z = np.logical_xor(self._z, other.z)<EOL>self._x = np.logical_xor(self._x, other.x)<EOL>return self<EOL>", "docstring": "Multiply two Paulis.\n\n        Returns:\n            Pauli: the multiplied pauli and save to itself, in-place computation.\n\n        Raises:\n            QiskitError: if the number of qubits of two paulis are different.", "id": "f10797:c0:m8"}
{"signature": "@property<EOL><INDENT>def numberofqubits(self):<DEDENT>", "body": "return len(self)<EOL>", "docstring": "Number of qubits.", "id": "f10797:c0:m13"}
{"signature": "@classmethod<EOL><INDENT>def pauli_single(cls, num_qubits, index, pauli_label):<DEDENT>", "body": "tmp = Pauli.from_label(pauli_label)<EOL>z = np.zeros(num_qubits, dtype=np.bool)<EOL>x = np.zeros(num_qubits, dtype=np.bool)<EOL>z[index] = tmp.z[<NUM_LIT:0>]<EOL>x[index] = tmp.x[<NUM_LIT:0>]<EOL>return cls(z, x)<EOL>", "docstring": "Generate single qubit pauli at index with pauli_label with length num_qubits.\n\nArgs:\n    num_qubits (int): the length of pauli\n    index (int): the qubit index to insert the single qubii\n    pauli_label (str): pauli\n\nReturns:\n    Pauli: single qubit pauli", "id": "f10797:c0:m25"}
{"signature": "def subtract(self, other):", "body": "if not isinstance(other, Operator):<EOL><INDENT>other = Operator(other)<EOL><DEDENT>if self.dim != other.dim:<EOL><INDENT>raise QiskitError(\"<STR_LIT>\")<EOL><DEDENT>return Operator(self.data - other.data, self.input_dims(),<EOL>self.output_dims())<EOL>", "docstring": "Return the operator self - other.\n\n        Args:\n            other (Operator): an operator object.\n\n        Returns:\n            Operator: the operator self - other.\n\n        Raises:\n            QiskitError: if other is not an operator, or has incompatible\n            dimensions.", "id": "f10798:c0:m11"}
{"signature": "def compose(self, other, qargs=None, front=False):", "body": "<EOL>if not isinstance(other, Operator):<EOL><INDENT>other = Operator(other)<EOL><DEDENT>if front and self.input_dims(qargs=qargs) != other.output_dims():<EOL><INDENT>raise QiskitError(<EOL>'<STR_LIT>')<EOL><DEDENT>if not front and self.output_dims(qargs=qargs) != other.input_dims():<EOL><INDENT>raise QiskitError(<EOL>'<STR_LIT>')<EOL><DEDENT>if qargs is None:<EOL><INDENT>if front:<EOL><INDENT>input_dims = other.input_dims()<EOL>output_dims = self.output_dims()<EOL>data = np.dot(self._data, other.data)<EOL><DEDENT>else:<EOL><INDENT>input_dims = self.input_dims()<EOL>output_dims = other.output_dims()<EOL>data = np.dot(other.data, self._data)<EOL><DEDENT>return Operator(data, input_dims, output_dims)<EOL><DEDENT>return self._compose_subsystem(other, qargs, front)<EOL>", "docstring": "Return the composition channel self\u2218other.\n\n        Args:\n            other (Operator): an operator object.\n            qargs (list): a list of subsystem positions to compose other on.\n            front (bool): If False compose in standard order other(self(input))\n                          otherwise compose in reverse order self(other(input))\n                          [default: False]\n\n        Returns:\n            Operator: The composed operator.\n\n        Raises:\n            QiskitError: if other cannot be converted to an Operator or has\n            incompatible dimensions.", "id": "f10798:c0:m6"}
{"signature": "def expand(self, other):", "body": "return self._tensor_product(other, reverse=True)<EOL>", "docstring": "Return the tensor product operator other \u2297 self.\n\n        Args:\n            other (Operator): an operator object.\n\n        Returns:\n            Operator: the tensor product operator other \u2297 self.\n\n        Raises:\n            QiskitError: if other cannot be converted to an operator.", "id": "f10798:c0:m9"}
{"signature": "def _tensor_product(self, other, reverse=False):", "body": "<EOL>if not isinstance(other, Operator):<EOL><INDENT>other = Operator(other)<EOL><DEDENT>if reverse:<EOL><INDENT>input_dims = self.input_dims() + other.input_dims()<EOL>output_dims = self.output_dims() + other.output_dims()<EOL>data = np.kron(other._data, self._data)<EOL><DEDENT>else:<EOL><INDENT>input_dims = other.input_dims() + self.input_dims()<EOL>output_dims = other.output_dims() + self.output_dims()<EOL>data = np.kron(self._data, other._data)<EOL><DEDENT>return Operator(data, input_dims, output_dims)<EOL>", "docstring": "Return the tensor product operator.\n\n        Args:\n            other (Operator): another operator.\n            reverse (bool): If False return self \u2297 other, if True return\n                            if True return (other \u2297 self) [Default: False\n        Returns:\n            Operator: the tensor product operator.\n\n        Raises:\n            QiskitError: if other cannot be converted into an Operator.", "id": "f10798:c0:m15"}
{"signature": "def to_instruction(self):", "body": "from qiskit.extensions.unitary import UnitaryGate<EOL>return UnitaryGate(self.data)<EOL>", "docstring": "Convert to a UnitaryGate instruction.", "id": "f10798:c0:m3"}
{"signature": "def _compose_subsystem(self, other, qargs, front=False):", "body": "<EOL>input_dims = list(self.input_dims())<EOL>output_dims = list(self.output_dims())<EOL>if front:<EOL><INDENT>num_indices = len(self.input_dims())<EOL>shift = len(self.output_dims())<EOL>right_mul = True<EOL>for pos, qubit in enumerate(qargs):<EOL><INDENT>input_dims[qubit] = other._input_dims[pos]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>num_indices = len(self.output_dims())<EOL>shift = <NUM_LIT:0><EOL>right_mul = False<EOL>for pos, qubit in enumerate(qargs):<EOL><INDENT>output_dims[qubit] = other._output_dims[pos]<EOL><DEDENT><DEDENT>tensor = np.reshape(self.data, self._shape)<EOL>mat = np.reshape(other.data, other._shape)<EOL>indices = [num_indices - <NUM_LIT:1> - qubit for qubit in qargs]<EOL>final_shape = [np.product(output_dims), np.product(input_dims)]<EOL>data = np.reshape(<EOL>self._einsum_matmul(tensor, mat, indices, shift, right_mul),<EOL>final_shape)<EOL>return Operator(data, input_dims, output_dims)<EOL>", "docstring": "Return the composition channel.", "id": "f10798:c0:m16"}
{"signature": "def _append_instruction(self, obj, qargs=None):", "body": "if isinstance(obj, Instruction):<EOL><INDENT>mat = None<EOL>if hasattr(obj, '<STR_LIT>'):<EOL><INDENT>try:<EOL><INDENT>mat = obj.to_matrix()<EOL><DEDENT>except QiskitError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if mat is not None:<EOL><INDENT>op = self.compose(mat, qargs=qargs)<EOL>self._data = op.data<EOL><DEDENT>else:<EOL><INDENT>if obj.definition is None:<EOL><INDENT>raise QiskitError('<STR_LIT>'.format(obj.name))<EOL><DEDENT>for instr, qregs, cregs in obj.definition:<EOL><INDENT>if cregs:<EOL><INDENT>raise QiskitError(<EOL>'<STR_LIT>'.format(<EOL>instr.name))<EOL><DEDENT>new_qargs = [tup[<NUM_LIT:1>] for tup in qregs]<EOL>self._append_instruction(instr, qargs=new_qargs)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>raise QiskitError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Update the current Operator by apply an instruction.", "id": "f10798:c0:m20"}
{"signature": "def multiply(self, other):", "body": "if not isinstance(other, Number):<EOL><INDENT>raise QiskitError(\"<STR_LIT>\")<EOL><DEDENT>return Operator(other * self.data, self.input_dims(),<EOL>self.output_dims())<EOL>", "docstring": "Return the operator self + other.\n\n        Args:\n            other (complex): a complex number.\n\n        Returns:\n            Operator: the operator other * self.\n\n        Raises:\n            QiskitError: if other is not a valid complex number.", "id": "f10798:c0:m12"}
{"signature": "def _evolve_subsystem(self, state, qargs):", "body": "mat = np.reshape(self.data, self._shape)<EOL>state_size = len(state)<EOL>state_dims = self._automatic_dims(None, state_size)<EOL>if self.input_dims() != len(qargs) * (<NUM_LIT:2>,):<EOL><INDENT>raise QiskitError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if state.ndim == <NUM_LIT:1>:<EOL><INDENT>tensor = np.reshape(state, state_dims)<EOL>indices = [len(state_dims) - <NUM_LIT:1> - qubit for qubit in qargs]<EOL>tensor = self._einsum_matmul(tensor, mat, indices)<EOL>return np.reshape(tensor, state_size)<EOL><DEDENT>tensor = np.reshape(state, <NUM_LIT:2> * state_dims)<EOL>indices = [len(state_dims) - <NUM_LIT:1> - qubit for qubit in qargs]<EOL>right_shift = len(state_dims)<EOL>tensor = self._einsum_matmul(tensor, mat, indices)<EOL>tensor = self._einsum_matmul(<EOL>tensor, np.conj(mat), indices, shift=right_shift)<EOL>return np.reshape(tensor, [state_size, state_size])<EOL>", "docstring": "Evolve a quantum state by the operator.\n\n        Args:\n            state (QuantumState): The input statevector or density matrix.\n            qargs (list): a list of QuantumState subsystem positions to apply\n                           the operator on.\n\n        Returns:\n            QuantumState: the output quantum state.\n\n        Raises:\n            QiskitError: if the operator dimension does not match the\n            specified QuantumState subsystem dimensions.", "id": "f10798:c0:m17"}
{"signature": "def compose(self, other, qargs=None, front=False):", "body": "if qargs is not None:<EOL><INDENT>return Chi(<EOL>SuperOp(self).compose(other, qargs=qargs, front=front))<EOL><DEDENT>if not isinstance(other, Choi):<EOL><INDENT>other = Choi(other)<EOL><DEDENT>if front and self._input_dim != other._output_dim:<EOL><INDENT>raise QiskitError(<EOL>'<STR_LIT>')<EOL><DEDENT>if not front and self._output_dim != other._input_dim:<EOL><INDENT>raise QiskitError(<EOL>'<STR_LIT>')<EOL><DEDENT>return Chi(Choi(self).compose(other, front=front))<EOL>", "docstring": "Return the composition channel self\u2218other.\n\n        Args:\n            other (QuantumChannel): a quantum channel.\n            qargs (list): a list of subsystem positions to compose other on.\n            front (bool): If False compose in standard order other(self(input))\n                          otherwise compose in reverse order self(other(input))\n                          [default: False]\n\n        Returns:\n            Chi: The composition channel as a Chi object.\n\n        Raises:\n            QiskitError: if other is not a QuantumChannel subclass, or\n            has incompatible dimensions.", "id": "f10799:c0:m4"}
{"signature": "def tensor(self, other):", "body": "return self._tensor_product(other, reverse=False)<EOL>", "docstring": "Return the tensor product channel self \u2297 other.\n\n        Args:\n            other (QuantumChannel): a quantum channel.\n\n        Returns:\n            SuperOp: the tensor product channel self \u2297 other as a SuperOp\n            object.\n\n        Raises:\n            QiskitError: if other cannot be converted to a channel.", "id": "f10800:c0:m7"}
{"signature": "def _evolve(self, state, qargs=None):", "body": "state = self._format_state(state, density_matrix=True)<EOL>if qargs is None:<EOL><INDENT>if state.shape[<NUM_LIT:0>] != self._input_dim:<EOL><INDENT>raise QiskitError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>shape_in = self._input_dim * self._input_dim<EOL>shape_out = (self._output_dim, self._output_dim)<EOL>return np.reshape(<EOL>np.dot(self._data, np.reshape(state, shape_in, order='<STR_LIT:F>')),<EOL>shape_out,<EOL>order='<STR_LIT:F>')<EOL><DEDENT>return self._evolve_subsystem(state, qargs)<EOL>", "docstring": "Evolve a quantum state by the QuantumChannel.\n\n        Args:\n            state (QuantumState): The input statevector or density matrix.\n            qargs (list): a list of QuantumState subsystem positions to apply\n                           the operator on.\n\n        Returns:\n            DensityMatrix: the output quantum state as a density matrix.\n\n        Raises:\n            QiskitError: if the operator dimension does not match the\n            specified QuantumState subsystem dimensions.", "id": "f10800:c0:m12"}
{"signature": "def expand(self, other):", "body": "return self._tensor_product(other, reverse=True)<EOL>", "docstring": "Return the tensor product channel other \u2297 self.\n\n        Args:\n            other (QuantumChannel): a quantum channel subclass.\n\n        Returns:\n            Stinespring: the tensor product channel other \u2297 self as a\n            Stinespring object.\n\n        Raises:\n            QiskitError: if other cannot be converted to a channel.", "id": "f10801:c0:m8"}
{"signature": "def _evolve(self, state, qargs=None):", "body": "<EOL>if qargs is not None:<EOL><INDENT>return SuperOp(self)._evolve(state, qargs)<EOL><DEDENT>state = self._format_state(state)<EOL>if state.shape[<NUM_LIT:0>] != self._input_dim:<EOL><INDENT>raise QiskitError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if state.ndim == <NUM_LIT:1> and self._data[<NUM_LIT:1>] is None andself._data[<NUM_LIT:0>].shape[<NUM_LIT:0>] // self._output_dim == <NUM_LIT:1>:<EOL><INDENT>return np.dot(self._data[<NUM_LIT:0>], state)<EOL><DEDENT>state = self._format_state(state, density_matrix=True)<EOL>stine_l, stine_r = self._data<EOL>if stine_r is None:<EOL><INDENT>stine_r = stine_l<EOL><DEDENT>din, dout = self.dim<EOL>dtr = stine_l.shape[<NUM_LIT:0>] // dout<EOL>shape = (dout, dtr, din)<EOL>return np.einsum('<STR_LIT>', np.reshape(stine_l, shape), state,<EOL>np.reshape(np.conjugate(stine_r), shape))<EOL>", "docstring": "Evolve a quantum state by the QuantumChannel.\n\n        Args:\n            state (QuantumState): The input statevector or density matrix.\n            qargs (list): a list of QuantumState subsystem positions to apply\n                           the operator on.\n\n        Returns:\n            QuantumState: the output quantum state.\n\n        Raises:\n            QiskitError: if the operator dimension does not match the\n            specified QuantumState subsystem dimensions.", "id": "f10801:c0:m12"}
{"signature": "def tensor(self, other):", "body": "return self._tensor_product(other, reverse=False)<EOL>", "docstring": "Return the tensor product channel self \u2297 other.\n\n        Args:\n            other (QuantumChannel): a quantum channel subclass.\n\n        Returns:\n            Stinespring: the tensor product channel other \u2297 self as a\n            Stinespring object.\n\n        Raises:\n            QiskitError: if other cannot be converted to a channel.", "id": "f10801:c0:m7"}
{"signature": "def multiply(self, other):", "body": "if not isinstance(other, Number):<EOL><INDENT>raise QiskitError(\"<STR_LIT>\")<EOL><DEDENT>if isinstance(other, complex) or other < <NUM_LIT:1>:<EOL><INDENT>return Stinespring(Choi(self).multiply(other))<EOL><DEDENT>num = np.sqrt(other)<EOL>stine_l, stine_r = self._data<EOL>stine_l = num * self._data[<NUM_LIT:0>]<EOL>stine_r = None<EOL>if self._data[<NUM_LIT:1>] is not None:<EOL><INDENT>stine_r = num * self._data[<NUM_LIT:1>]<EOL><DEDENT>return Stinespring((stine_l, stine_r), self.input_dims(),<EOL>self.output_dims())<EOL>", "docstring": "Return the QuantumChannel self + other.\n\n        Args:\n            other (complex): a complex number.\n\n        Returns:\n            Stinespring: the scalar multiplication other * self as a\n            Stinespring object.\n\n        Raises:\n            QiskitError: if other is not a valid scalar.", "id": "f10801:c0:m11"}
{"signature": "def _ptm_to_superop(data, input_dim, output_dim):", "body": "num_qubits = int(np.log2(input_dim))<EOL>return _transform_from_pauli(data, num_qubits)<EOL>", "docstring": "Transform PTM representation to SuperOp representation.", "id": "f10803:m21"}
{"signature": "def _stinespring_to_superop(data, input_dim, output_dim):", "body": "trace_dim = data[<NUM_LIT:0>].shape[<NUM_LIT:0>] // output_dim<EOL>stine_l = np.reshape(data[<NUM_LIT:0>], (output_dim, trace_dim, input_dim))<EOL>if data[<NUM_LIT:1>] is None:<EOL><INDENT>stine_r = stine_l<EOL><DEDENT>else:<EOL><INDENT>stine_r = np.reshape(data[<NUM_LIT:1>], (output_dim, trace_dim, input_dim))<EOL><DEDENT>return np.reshape(<EOL>np.einsum('<STR_LIT>', stine_r.conj(), stine_l),<EOL>(output_dim * output_dim, input_dim * input_dim))<EOL>", "docstring": "Transform Stinespring representation to SuperOp representation.", "id": "f10803:m16"}
{"signature": "def _choi_to_chi(data, input_dim, output_dim):", "body": "num_qubits = int(np.log2(input_dim))<EOL>return _transform_to_pauli(data, num_qubits)<EOL>", "docstring": "Transform Choi representation to the Chi representation.", "id": "f10803:m20"}
{"signature": "def _kraus_to_stinespring(data, input_dim, output_dim):", "body": "stine_pair = [None, None]<EOL>for i, kraus in enumerate(data):<EOL><INDENT>if kraus is not None:<EOL><INDENT>num_kraus = len(kraus)<EOL>stine = np.zeros((output_dim * num_kraus, input_dim),<EOL>dtype=complex)<EOL>for j, mat in enumerate(kraus):<EOL><INDENT>vec = np.zeros(num_kraus)<EOL>vec[j] = <NUM_LIT:1><EOL>stine += np.kron(mat, vec[:, None])<EOL><DEDENT>stine_pair[i] = stine<EOL><DEDENT><DEDENT>return tuple(stine_pair)<EOL>", "docstring": "Transform Kraus representation to Stinespring representation.", "id": "f10803:m17"}
{"signature": "def _kraus_to_operator(data, input_dim, output_dim):", "body": "if data[<NUM_LIT:1>] is not None or len(data[<NUM_LIT:0>]) > <NUM_LIT:1>:<EOL><INDENT>raise QiskitError(<EOL>'<STR_LIT>')<EOL><DEDENT>return data[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>", "docstring": "Transform Kraus representation to Operator representation.", "id": "f10803:m8"}
{"signature": "def _choi_to_superop(data, input_dim, output_dim):", "body": "shape = (input_dim, output_dim, input_dim, output_dim)<EOL>return _reshuffle(data, shape)<EOL>", "docstring": "Transform Choi to SuperOp representation.", "id": "f10803:m11"}
{"signature": "def _transform_to_pauli(data, num_qubits):", "body": "<EOL>basis_mat = np.array(<EOL>[[<NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>], [<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:0>], [<NUM_LIT:0>, -<NUM_LIT>, <NUM_LIT>, <NUM_LIT:0>], [<NUM_LIT:1>, <NUM_LIT>, <NUM_LIT:0>, -<NUM_LIT:1>]],<EOL>dtype=complex)<EOL>cob = basis_mat<EOL>for _ in range(num_qubits - <NUM_LIT:1>):<EOL><INDENT>dim = int(np.sqrt(len(cob)))<EOL>cob = np.reshape(<EOL>np.transpose(<EOL>np.reshape(<EOL>np.kron(basis_mat, cob), (<NUM_LIT:4>, dim * dim, <NUM_LIT:2>, <NUM_LIT:2>, dim, dim)),<EOL>(<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:4>, <NUM_LIT:3>, <NUM_LIT:5>)), (<NUM_LIT:4> * dim * dim, <NUM_LIT:4> * dim * dim))<EOL><DEDENT>return np.dot(np.dot(cob, data), cob.conj().T) / <NUM_LIT:2>**num_qubits<EOL>", "docstring": "Change of basis of bipartite matrix represenation.", "id": "f10803:m25"}
{"signature": "def _choi_to_kraus(data, input_dim, output_dim, atol=ATOL_DEFAULT):", "body": "<EOL>if is_hermitian_matrix(data, atol=atol):<EOL><INDENT>w, v = la.eigh(data)<EOL>if len(w[w < -atol]) == <NUM_LIT:0>:<EOL><INDENT>kraus = []<EOL>for val, vec in zip(w, v.T):<EOL><INDENT>if abs(val) > atol:<EOL><INDENT>k = np.sqrt(val) * vec.reshape(<EOL>(output_dim, input_dim), order='<STR_LIT:F>')<EOL>kraus.append(k)<EOL><DEDENT><DEDENT>if not kraus:<EOL><INDENT>kraus.append(np.zeros((output_dim, input_dim), dtype=complex))<EOL><DEDENT>return (kraus, None)<EOL><DEDENT><DEDENT>mat_u, svals, mat_vh = la.svd(data)<EOL>kraus_l = []<EOL>kraus_r = []<EOL>for val, vec_l, vec_r in zip(svals, mat_u.T, mat_vh.conj()):<EOL><INDENT>kraus_l.append(<EOL>np.sqrt(val) * vec_l.reshape((output_dim, input_dim), order='<STR_LIT:F>'))<EOL>kraus_r.append(<EOL>np.sqrt(val) * vec_r.reshape((output_dim, input_dim), order='<STR_LIT:F>'))<EOL><DEDENT>return (kraus_l, kraus_r)<EOL>", "docstring": "Transform Choi representation to Kraus representation.", "id": "f10803:m13"}
{"signature": "def _stinespring_to_operator(data, input_dim, output_dim):", "body": "trace_dim = data[<NUM_LIT:0>].shape[<NUM_LIT:0>] // output_dim<EOL>if data[<NUM_LIT:1>] is not None or trace_dim != <NUM_LIT:1>:<EOL><INDENT>raise QiskitError(<EOL>'<STR_LIT>')<EOL><DEDENT>return data[<NUM_LIT:0>]<EOL>", "docstring": "Transform Stinespring representation to Operator representation.", "id": "f10803:m9"}
{"signature": "def _is_cp_helper(self, choi, atol, rtol):", "body": "if atol is None:<EOL><INDENT>atol = self._atol<EOL><DEDENT>if rtol is None:<EOL><INDENT>rtol = self._rtol<EOL><DEDENT>return is_positive_semidefinite_matrix(choi, rtol=rtol, atol=atol)<EOL>", "docstring": "Test if a channel is completely-positive (CP)", "id": "f10804:c0:m6"}
{"signature": "def is_unitary(self, atol=None, rtol=None):", "body": "try:<EOL><INDENT>op = self.to_operator()<EOL>return op.is_unitary(atol=atol, rtol=rtol)<EOL><DEDENT>except QiskitError:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Return True if QuantumChannel is a unitary channel.", "id": "f10804:c0:m3"}
{"signature": "def to_instruction(self):", "body": "from qiskit.circuit.instruction import Instruction<EOL>n_qubits = int(np.log2(self._input_dim))<EOL>if self._input_dim != self._output_dim or <NUM_LIT:2>**n_qubits != self._input_dim:<EOL><INDENT>raise QiskitError(<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>if not self.is_cptp():<EOL><INDENT>raise QiskitError(<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>kraus, _ = _to_kraus(self.rep, self._data, *self.dim)<EOL>if len(kraus) == <NUM_LIT:1>:<EOL><INDENT>return Operator(kraus[<NUM_LIT:0>]).to_instruction()<EOL><DEDENT>return Instruction('<STR_LIT>', n_qubits, <NUM_LIT:0>, kraus)<EOL>", "docstring": "Convert to a Kraus or UnitaryGate circuit instruction.\n\n        If the channel is unitary it will be added as a unitary gate,\n        otherwise it will be added as a kraus simulator instruction.\n\n        Returns:\n            Instruction: A kraus instruction for the channel.\n\n        Raises:\n            QiskitError: if input data is not an N-qubit CPTP quantum channel.", "id": "f10804:c0:m5"}
{"signature": "def is_tp(self, atol=None, rtol=None):", "body": "choi = _to_choi(self.rep, self._data, *self.dim)<EOL>return self._is_tp_helper(choi, atol, rtol)<EOL>", "docstring": "Test if a channel is completely-positive (CP)", "id": "f10804:c0:m1"}
{"signature": "@property<EOL><INDENT>def _bipartite_shape(self):<DEDENT>", "body": "return (self._input_dim, self._output_dim, self._input_dim,<EOL>self._output_dim)<EOL>", "docstring": "Return the shape for bipartite matrix", "id": "f10805:c0:m1"}
{"signature": "def multiply(self, other):", "body": "if not isinstance(other, Number):<EOL><INDENT>raise QiskitError(\"<STR_LIT>\")<EOL><DEDENT>return Choi(other * self._data, self._input_dims, self._output_dims)<EOL>", "docstring": "Return the QuantumChannel self + other.\n\n        Args:\n            other (complex): a complex number.\n\n        Returns:\n            Choi: the scalar multiplication other * self as a Choi object.\n\n        Raises:\n            QiskitError: if other is not a valid scalar.", "id": "f10805:c0:m10"}
{"signature": "def transpose(self):", "body": "kraus_l, kraus_r = self._data<EOL>kraus_l = [k.T for k in kraus_l]<EOL>if kraus_r is not None:<EOL><INDENT>kraus_r = [k.T for k in kraus_r]<EOL><DEDENT>return Kraus((kraus_l, kraus_r),<EOL>input_dims=self.output_dims(),<EOL>output_dims=self.input_dims())<EOL>", "docstring": "Return the transpose of the QuantumChannel.", "id": "f10806:c0:m4"}
{"signature": "def power(self, n):", "body": "if n > <NUM_LIT:0>:<EOL><INDENT>return super().power(n)<EOL><DEDENT>return Kraus(SuperOp(self).power(n))<EOL>", "docstring": "The matrix power of the channel.\n\n        Args:\n            n (int): compute the matrix power of the superoperator matrix.\n\n        Returns:\n            Kraus: the matrix power of the SuperOp converted to a Kraus channel.\n\n        Raises:\n            QiskitError: if the input and output dimensions of the\n            QuantumChannel are not equal, or the power is not an integer.", "id": "f10806:c0:m6"}
{"signature": "def __init__(self, data, input_dims=None, output_dims=None):", "body": "<EOL>if isinstance(data, (list, tuple, np.ndarray)):<EOL><INDENT>if isinstance(data, np.ndarray) or np.array(data).ndim == <NUM_LIT:2>:<EOL><INDENT>kraus = ([np.array(data, dtype=complex)], None)<EOL>shape = kraus[<NUM_LIT:0>][<NUM_LIT:0>].shape<EOL><DEDENT>elif isinstance(data, list) and len(data) > <NUM_LIT:0>:<EOL><INDENT>kraus = [np.array(data[<NUM_LIT:0>], dtype=complex)]<EOL>shape = kraus[<NUM_LIT:0>].shape<EOL>for i in data[<NUM_LIT:1>:]:<EOL><INDENT>op = np.array(i, dtype=complex)<EOL>if op.shape != shape:<EOL><INDENT>raise QiskitError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>kraus.append(op)<EOL><DEDENT>kraus = (kraus, None)<EOL><DEDENT>elif isinstance(data,<EOL>tuple) and len(data) == <NUM_LIT:2> and len(data[<NUM_LIT:0>]) > <NUM_LIT:0>:<EOL><INDENT>kraus_left = [np.array(data[<NUM_LIT:0>][<NUM_LIT:0>], dtype=complex)]<EOL>shape = kraus_left[<NUM_LIT:0>].shape<EOL>for i in data[<NUM_LIT:0>][<NUM_LIT:1>:]:<EOL><INDENT>op = np.array(i, dtype=complex)<EOL>if op.shape != shape:<EOL><INDENT>raise QiskitError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>kraus_left.append(op)<EOL><DEDENT>if data[<NUM_LIT:1>] is None:<EOL><INDENT>kraus = (kraus_left, None)<EOL><DEDENT>else:<EOL><INDENT>kraus_right = []<EOL>for i in data[<NUM_LIT:1>]:<EOL><INDENT>op = np.array(i, dtype=complex)<EOL>if op.shape != shape:<EOL><INDENT>raise QiskitError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>kraus_right.append(op)<EOL><DEDENT>kraus = (kraus_left, kraus_right)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise QiskitError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if isinstance(data, (QuantumCircuit, Instruction)):<EOL><INDENT>data = SuperOp._instruction_to_superop(data)<EOL><DEDENT>else:<EOL><INDENT>data = self._init_transformer(data)<EOL><DEDENT>input_dim, output_dim = data.dim<EOL>kraus = _to_kraus(data.rep, data._data, input_dim, output_dim)<EOL>if input_dims is None:<EOL><INDENT>input_dims = data.input_dims()<EOL><DEDENT>if output_dims is None:<EOL><INDENT>output_dims = data.output_dims()<EOL><DEDENT><DEDENT>output_dim, input_dim = kraus[<NUM_LIT:0>][<NUM_LIT:0>].shape<EOL>input_dims = self._automatic_dims(input_dims, input_dim)<EOL>output_dims = self._automatic_dims(output_dims, output_dim)<EOL>if kraus[<NUM_LIT:1>] is None or np.allclose(kraus[<NUM_LIT:0>], kraus[<NUM_LIT:1>]):<EOL><INDENT>super().__init__('<STR_LIT>', (kraus[<NUM_LIT:0>], None), input_dims,<EOL>output_dims)<EOL><DEDENT>else:<EOL><INDENT>super().__init__('<STR_LIT>', kraus, input_dims, output_dims)<EOL><DEDENT>", "docstring": "Initialize a quantum channel Kraus operator.\n\n        Args:\n            data (QuantumCircuit or\n                  Instruction or\n                  BaseOperator or\n                  matrix): data to initialize superoperator.\n            input_dims (tuple): the input subsystem dimensions.\n                                [Default: None]\n            output_dims (tuple): the output subsystem dimensions.\n                                 [Default: None]\n\n        Raises:\n            QiskitError: if input data cannot be initialized as a\n            a list of Kraus matrices.\n\n        Additional Information\n        ----------------------\n        If the input or output dimensions are None, they will be\n        automatically determined from the input data. If the input data is\n        a list of Numpy arrays of shape (2**N, 2**N) qubit systems will be used. If\n        the input does not correspond to an N-qubit channel, it will assign a\n        single subsystem with dimension specifed by the shape of the input.", "id": "f10806:c0:m0"}
{"signature": "def _tensor_product(self, other, reverse=False):", "body": "if not isinstance(other, PTM):<EOL><INDENT>other = PTM(other)<EOL><DEDENT>if reverse:<EOL><INDENT>input_dims = self.input_dims() + other.input_dims()<EOL>output_dims = self.output_dims() + other.output_dims()<EOL>data = np.kron(other.data, self._data)<EOL><DEDENT>else:<EOL><INDENT>input_dims = other.input_dims() + self.input_dims()<EOL>output_dims = other.output_dims() + self.output_dims()<EOL>data = np.kron(self._data, other.data)<EOL><DEDENT>return PTM(data, input_dims, output_dims)<EOL>", "docstring": "Return the tensor product channel.\n\n        Args:\n            other (QuantumChannel): a quantum channel.\n            reverse (bool): If False return self \u2297 other, if True return\n                            if True return (other \u2297 self) [Default: False\n        Returns:\n            PTM: the tensor product channel as a PTM object.\n\n        Raises:\n            QiskitError: if other cannot be converted to a channel.", "id": "f10807:c0:m12"}
{"signature": "def conjugate(self):", "body": "<EOL>return PTM(SuperOp(self).conjugate())<EOL>", "docstring": "Return the conjugate of the QuantumChannel.", "id": "f10807:c0:m2"}
{"signature": "def expand(self, other):", "body": "return self._tensor_product(other, reverse=True)<EOL>", "docstring": "Return the tensor product channel other \u2297 self.\n\n        Args:\n            other (QuantumChannel): a quantum channel.\n\n        Returns:\n            PTM: the tensor product channel other \u2297 self as a PTM object.\n\n        Raises:\n            QiskitError: if other cannot be converted to a channel.", "id": "f10807:c0:m7"}
{"signature": "def multiply(self, other):", "body": "if not isinstance(other, Number):<EOL><INDENT>raise QiskitError(\"<STR_LIT>\")<EOL><DEDENT>return PTM(other * self._data, self._input_dims, self._output_dims)<EOL>", "docstring": "Return the QuantumChannel self + other.\n\n        Args:\n            other (complex): a complex number.\n\n        Returns:\n            PTM: the scalar multiplication other * self as a PTM object.\n\n        Raises:\n            QiskitError: if other is not a valid scalar.", "id": "f10807:c0:m10"}
{"signature": "def _evolve(self, state, qargs=None):", "body": "return SuperOp(self)._evolve(state, qargs)<EOL>", "docstring": "Evolve a quantum state by the QuantumChannel.\n\n        Args:\n            state (QuantumState): The input statevector or density matrix.\n            qargs (list): a list of QuantumState subsystem positions to apply\n                           the operator on.\n\n        Returns:\n            DensityMatrix: the output quantum state as a density matrix.", "id": "f10807:c0:m11"}
{"signature": "def disassemble(qobj):", "body": "run_config = qobj.config.to_dict()<EOL>user_qobj_header = qobj.header.to_dict()<EOL>circuits = _experiments_to_circuits(qobj)<EOL>return circuits, run_config, user_qobj_header<EOL>", "docstring": "Dissasemble a qobj and return the circuits, run_config, and user header\n\n    Args:\n        qobj (Qobj): The input qobj object to dissasemble\n    Returns:\n        circuits (list): A list of quantum circuits\n        run_config (dict): The dist of the run config\n        user_qobj_header (dict): The dict of any user headers in the qobj", "id": "f10810:m1"}
{"signature": "def assemble_circuits(circuits, qobj_id=None, qobj_header=None, run_config=None):", "body": "qobj_config = QasmQobjConfig()<EOL>if run_config:<EOL><INDENT>qobj_config = QasmQobjConfig(**run_config.to_dict())<EOL><DEDENT>experiments = []<EOL>max_n_qubits = <NUM_LIT:0><EOL>max_memory_slots = <NUM_LIT:0><EOL>for circuit in circuits:<EOL><INDENT>n_qubits = <NUM_LIT:0><EOL>memory_slots = <NUM_LIT:0><EOL>qubit_labels = []<EOL>clbit_labels = []<EOL>qreg_sizes = []<EOL>creg_sizes = []<EOL>for qreg in circuit.qregs:<EOL><INDENT>qreg_sizes.append([qreg.name, qreg.size])<EOL>for j in range(qreg.size):<EOL><INDENT>qubit_labels.append([qreg.name, j])<EOL><DEDENT>n_qubits += qreg.size<EOL><DEDENT>for creg in circuit.cregs:<EOL><INDENT>creg_sizes.append([creg.name, creg.size])<EOL>for j in range(creg.size):<EOL><INDENT>clbit_labels.append([creg.name, j])<EOL><DEDENT>memory_slots += creg.size<EOL><DEDENT>experimentheader = QobjExperimentHeader(qubit_labels=qubit_labels,<EOL>n_qubits=n_qubits,<EOL>qreg_sizes=qreg_sizes,<EOL>clbit_labels=clbit_labels,<EOL>memory_slots=memory_slots,<EOL>creg_sizes=creg_sizes,<EOL>name=circuit.name)<EOL>experimentconfig = QasmQobjExperimentConfig(n_qubits=n_qubits, memory_slots=memory_slots)<EOL>is_conditional_experiment = any(op.control for (op, qargs, cargs) in circuit.data)<EOL>max_conditional_idx = <NUM_LIT:0><EOL>instructions = []<EOL>for op_context in circuit.data:<EOL><INDENT>instruction = op_context[<NUM_LIT:0>].assemble()<EOL>qargs = op_context[<NUM_LIT:1>]<EOL>cargs = op_context[<NUM_LIT:2>]<EOL>if qargs:<EOL><INDENT>qubit_indices = [qubit_labels.index([qubit[<NUM_LIT:0>].name, qubit[<NUM_LIT:1>]])<EOL>for qubit in qargs]<EOL>instruction.qubits = qubit_indices<EOL><DEDENT>if cargs:<EOL><INDENT>clbit_indices = [clbit_labels.index([clbit[<NUM_LIT:0>].name, clbit[<NUM_LIT:1>]])<EOL>for clbit in cargs]<EOL>instruction.memory = clbit_indices<EOL>if instruction.name == \"<STR_LIT>\" and is_conditional_experiment:<EOL><INDENT>instruction.register = clbit_indices<EOL><DEDENT><DEDENT>if hasattr(instruction, '<STR_LIT>'):<EOL><INDENT>ctrl_reg, ctrl_val = instruction._control<EOL>mask = <NUM_LIT:0><EOL>val = <NUM_LIT:0><EOL>for clbit in clbit_labels:<EOL><INDENT>if clbit[<NUM_LIT:0>] == ctrl_reg.name:<EOL><INDENT>mask |= (<NUM_LIT:1> << clbit_labels.index(clbit))<EOL>val |= (((ctrl_val >> clbit[<NUM_LIT:1>]) & <NUM_LIT:1>) << clbit_labels.index(clbit))<EOL><DEDENT><DEDENT>conditional_reg_idx = memory_slots + max_conditional_idx<EOL>conversion_bfunc = QasmQobjInstruction(name='<STR_LIT>',<EOL>mask=\"<STR_LIT>\" % mask,<EOL>relation='<STR_LIT>',<EOL>val=\"<STR_LIT>\" % val,<EOL>register=conditional_reg_idx)<EOL>instructions.append(conversion_bfunc)<EOL>instruction.conditional = conditional_reg_idx<EOL>max_conditional_idx += <NUM_LIT:1><EOL>del instruction._control<EOL><DEDENT>instructions.append(instruction)<EOL><DEDENT>experiments.append(QasmQobjExperiment(instructions=instructions, header=experimentheader,<EOL>config=experimentconfig))<EOL>if n_qubits > max_n_qubits:<EOL><INDENT>max_n_qubits = n_qubits<EOL><DEDENT>if memory_slots > max_memory_slots:<EOL><INDENT>max_memory_slots = memory_slots<EOL><DEDENT><DEDENT>qobj_config.memory_slots = max_memory_slots<EOL>qobj_config.n_qubits = max_n_qubits<EOL>return QasmQobj(qobj_id=qobj_id,<EOL>config=qobj_config,<EOL>experiments=experiments,<EOL>header=qobj_header)<EOL>", "docstring": "Assembles a list of circuits into a qobj which can be run on the backend.\n\n    Args:\n        circuits (list[QuantumCircuits]): circuit(s) to assemble\n        qobj_id (int): identifier for the generated qobj\n        qobj_header (QobjHeader): header to pass to the results\n        run_config (RunConfig): configuration of the runtime environment\n\n    Returns:\n        QasmQobj: the Qobj to be run on the backends", "id": "f10812:m0"}
{"signature": "def _parse_transpile_args(circuits, backend,<EOL>basis_gates, coupling_map, backend_properties,<EOL>initial_layout, seed_transpiler, optimization_level,<EOL>pass_manager):", "body": "<EOL>num_circuits = len(circuits)<EOL>basis_gates = _parse_basis_gates(basis_gates, backend, circuits)<EOL>coupling_map = _parse_coupling_map(coupling_map, backend, num_circuits)<EOL>backend_properties = _parse_backend_properties(backend_properties, backend, num_circuits)<EOL>initial_layout = _parse_initial_layout(initial_layout, circuits)<EOL>seed_transpiler = _parse_seed_transpiler(seed_transpiler, num_circuits)<EOL>optimization_level = _parse_optimization_level(optimization_level, num_circuits)<EOL>pass_manager = _parse_pass_manager(pass_manager, num_circuits)<EOL>transpile_configs = []<EOL>for args in zip(basis_gates, coupling_map, backend_properties, initial_layout,<EOL>seed_transpiler, optimization_level, pass_manager):<EOL><INDENT>transpile_config = TranspileConfig(basis_gates=args[<NUM_LIT:0>],<EOL>coupling_map=args[<NUM_LIT:1>],<EOL>backend_properties=args[<NUM_LIT:2>],<EOL>initial_layout=args[<NUM_LIT:3>],<EOL>seed_transpiler=args[<NUM_LIT:4>],<EOL>optimization_level=args[<NUM_LIT:5>],<EOL>pass_manager=args[<NUM_LIT:6>])<EOL>transpile_configs.append(transpile_config)<EOL><DEDENT>return transpile_configs<EOL>", "docstring": "Resolve the various types of args allowed to the transpile() function through\n    duck typing, overriding args, etc. Refer to the transpile() docstring for details on\n    what types of inputs are allowed.\n\n    Here the args are resolved by converting them to standard instances, and prioritizing\n    them in case a transpile option is passed through multiple args (explicitly setting an\n    arg has more priority than the arg set by backend)\n\n    Returns:\n        list[TranspileConfig]: a transpile config for each circuit, which is a standardized\n            object that configures the transpiler and determines the pass manager to use.", "id": "f10813:m2"}
{"signature": "def _multiplex(self, target_gate, list_of_angles):", "body": "list_len = len(list_of_angles)<EOL>local_num_qubits = int(math.log2(list_len)) + <NUM_LIT:1><EOL>q = QuantumRegister(local_num_qubits)<EOL>circuit = QuantumCircuit(q, name=\"<STR_LIT>\" + local_num_qubits.__str__())<EOL>lsb = q[<NUM_LIT:0>]<EOL>msb = q[local_num_qubits - <NUM_LIT:1>]<EOL>if local_num_qubits == <NUM_LIT:1>:<EOL><INDENT>circuit.append(target_gate(list_of_angles[<NUM_LIT:0>]), [q[<NUM_LIT:0>]])<EOL>return circuit<EOL><DEDENT>angle_weight = scipy.kron([[<NUM_LIT:0.5>, <NUM_LIT:0.5>], [<NUM_LIT:0.5>, -<NUM_LIT:0.5>]],<EOL>np.identity(<NUM_LIT:2> ** (local_num_qubits - <NUM_LIT:2>)))<EOL>list_of_angles = angle_weight.dot(np.array(list_of_angles)).tolist()<EOL>multiplex_1 = self._multiplex(target_gate, list_of_angles[<NUM_LIT:0>:(list_len // <NUM_LIT:2>)])<EOL>circuit.append(multiplex_1.to_instruction(), q[<NUM_LIT:0>:-<NUM_LIT:1>])<EOL>circuit.append(CnotGate(), [msb, lsb])<EOL>multiplex_2 = self._multiplex(target_gate, list_of_angles[(list_len // <NUM_LIT:2>):])<EOL>if list_len > <NUM_LIT:1>:<EOL><INDENT>circuit.append(multiplex_2.to_instruction().mirror(), q[<NUM_LIT:0>:-<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>circuit.append(multiplex_2.to_instruction(), q[<NUM_LIT:0>:-<NUM_LIT:1>])<EOL><DEDENT>circuit.append(CnotGate(), [msb, lsb])<EOL>return circuit<EOL>", "docstring": "Return a recursive implementation of a multiplexor circuit,\nwhere each instruction itself has a decomposition based on\nsmaller multiplexors.\n\nThe LSB is the multiplexor \"data\" and the other bits are multiplexor \"select\".\n\nArgs:\n    target_gate (Gate): Ry or Rz gate to apply to target qubit, multiplexed\n        over all other \"select\" qubits\n    list_of_angles (list[float]): list of rotation angles to apply Ry and Rz\n\nReturns:\n    DAGCircuit: the circuit implementing the multiplexor's action", "id": "f10815:c0:m5"}
{"signature": "def gates_to_uncompute(self):", "body": "q = QuantumRegister(self.num_qubits)<EOL>circuit = QuantumCircuit(q, name='<STR_LIT>')<EOL>remaining_param = self.params<EOL>for i in range(self.num_qubits):<EOL><INDENT>(remaining_param,<EOL>thetas,<EOL>phis) = Initialize._rotations_to_disentangle(remaining_param)<EOL>rz_mult = self._multiplex(RZGate, phis)<EOL>ry_mult = self._multiplex(RYGate, thetas)<EOL>circuit.append(rz_mult.to_instruction(), q[i:self.num_qubits])<EOL>circuit.append(ry_mult.to_instruction(), q[i:self.num_qubits])<EOL><DEDENT>return circuit<EOL>", "docstring": "Call to create a circuit with gates that take the\ndesired vector to zero.\n\nReturns:\n    QuantumCircuit: circuit to take self.params vector to |00..0>", "id": "f10815:c0:m2"}
{"signature": "@_to_bits(<NUM_LIT:2>)<EOL>@_op_expand(<NUM_LIT:2>)<EOL>def cu1(self, theta, ctl, tgt):", "body": "return self.append(Cu1Gate(theta), [ctl, tgt], [])<EOL>", "docstring": "Apply cu1 from ctl to tgt with angle theta.", "id": "f10817:m0"}
{"signature": "def __init__(self, theta):", "body": "super().__init__(\"<STR_LIT>\", <NUM_LIT:2>, [theta])<EOL>", "docstring": "Create new cu1 gate.", "id": "f10817:c0:m0"}
{"signature": "def __init__(self, theta, label=None):", "body": "super().__init__(\"<STR_LIT>\", <NUM_LIT:1>, [theta], label=label)<EOL>", "docstring": "Create new diagonal single-qubit gate.", "id": "f10819:c0:m0"}
{"signature": "@_to_bits(<NUM_LIT:1>)<EOL>@_op_expand(<NUM_LIT:1>)<EOL>def u2(self, phi, lam, q):", "body": "return self.append(U2Gate(phi, lam), [q], [])<EOL>", "docstring": "Apply u2 to q.", "id": "f10820:m0"}
{"signature": "def to_matrix(self):", "body": "isqrt2 = <NUM_LIT:1> / numpy.sqrt(<NUM_LIT:2>)<EOL>phi, lam = self.params<EOL>phi, lam = float(phi), float(lam)<EOL>return numpy.array([[isqrt2, -numpy.exp(<NUM_LIT> * lam) * isqrt2],<EOL>[<EOL>numpy.exp(<NUM_LIT> * phi) * isqrt2,<EOL>numpy.exp(<NUM_LIT> * (phi + lam)) * isqrt2<EOL>]],<EOL>dtype=complex)<EOL>", "docstring": "Return a Numpy.array for the U3 gate.", "id": "f10820:c0:m3"}
{"signature": "def inverse(self):", "body": "return CrzGate(-self.params[<NUM_LIT:0>])<EOL>", "docstring": "Invert this gate.", "id": "f10821:c0:m2"}
{"signature": "def to_matrix(self):", "body": "return numpy.array([[<NUM_LIT:1>, <NUM_LIT:0>],<EOL>[<NUM_LIT:0>, <NUM_LIT:1>]], dtype=complex)<EOL>", "docstring": "Return a Numpy.array for the Id gate.", "id": "f10823:c0:m3"}
{"signature": "def inverse(self):", "body": "return HGate()<EOL>", "docstring": "Invert this gate.", "id": "f10824:c0:m2"}
{"signature": "def to_matrix(self):", "body": "return numpy.array([[<NUM_LIT:1>, <NUM_LIT:1>],<EOL>[<NUM_LIT:1>, -<NUM_LIT:1>]], dtype=complex) / numpy.sqrt(<NUM_LIT:2>)<EOL>", "docstring": "Return a Numpy.array for the H gate.", "id": "f10824:c0:m3"}
{"signature": "def __init__(self, label=None):", "body": "super().__init__(\"<STR_LIT:y>\", <NUM_LIT:1>, [], label=label)<EOL>", "docstring": "Create new Y gate.", "id": "f10825:c0:m0"}
{"signature": "def inverse(self):", "body": "return YGate()<EOL>", "docstring": "Invert this gate.", "id": "f10825:c0:m2"}
{"signature": "def to_matrix(self):", "body": "return numpy.array([[<NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>],<EOL>[<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>],<EOL>[<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>],<EOL>[<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>],<EOL>[<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>],<EOL>[<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>],<EOL>[<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>],<EOL>[<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>]], dtype=complex)<EOL>", "docstring": "Return a Numpy.array for the Toffoli gate.", "id": "f10826:c0:m3"}
{"signature": "@_to_bits(<NUM_LIT:3>)<EOL>@_op_expand(<NUM_LIT:3>, broadcastable=[True, True, False])<EOL>def ccx(self, ctl1, ctl2, tgt):", "body": "return self.append(ToffoliGate(), [ctl1, ctl2, tgt], [])<EOL>", "docstring": "Apply Toffoli to from ctl1 and ctl2 to tgt.", "id": "f10826:m0"}
{"signature": "def to_matrix(self):", "body": "theta, phi, lam = self.params<EOL>theta, phi, lam = float(theta), float(phi), float(lam)<EOL>return numpy.array(<EOL>[[<EOL>numpy.cos(theta / <NUM_LIT:2>),<EOL>-numpy.exp(<NUM_LIT> * lam) * numpy.sin(theta / <NUM_LIT:2>)<EOL>],<EOL>[<EOL>numpy.exp(<NUM_LIT> * phi) * numpy.sin(theta / <NUM_LIT:2>),<EOL>numpy.exp(<NUM_LIT> * (phi + lam)) * numpy.cos(theta / <NUM_LIT:2>)<EOL>]],<EOL>dtype=complex)<EOL>", "docstring": "Return a Numpy.array for the U3 gate.", "id": "f10827:c0:m3"}
{"signature": "@_to_bits(<NUM_LIT:2>)<EOL>@_op_expand(<NUM_LIT:2>)<EOL>def ch(self, ctl, tgt):", "body": "return self.append(CHGate(), [ctl, tgt], [])<EOL>", "docstring": "Apply CH from ctl to tgt.", "id": "f10829:m0"}
{"signature": "def inverse(self):", "body": "return CHGate()<EOL>", "docstring": "Invert this gate.", "id": "f10829:c0:m2"}
{"signature": "@_to_bits(<NUM_LIT:1>)<EOL>@_op_expand(<NUM_LIT:1>)<EOL>def iden(self, q):", "body": "return self.append(IdGate(), [q], [])<EOL>", "docstring": "Apply Identity to q.", "id": "f10833:m0"}
{"signature": "@_to_bits(<NUM_LIT:1>)<EOL>@_op_expand(<NUM_LIT:1>)<EOL>def rz(self, phi, q):", "body": "return self.append(RZGate(phi), [q], [])<EOL>", "docstring": "Apply Rz to q.", "id": "f10834:m0"}
{"signature": "def __init__(self, phi):", "body": "super().__init__(\"<STR_LIT>\", <NUM_LIT:1>, [phi])<EOL>", "docstring": "Create new rz single qubit gate.", "id": "f10834:c0:m0"}
{"signature": "def __init__(self):", "body": "super().__init__(\"<STR_LIT>\", <NUM_LIT:3>, [])<EOL>", "docstring": "Create new Fredkin gate.", "id": "f10835:c0:m0"}
{"signature": "def inverse(self):", "body": "return Barrier(self.num_qubits)<EOL>", "docstring": "Special case. Return self.", "id": "f10836:c0:m1"}
{"signature": "def __init__(self, label=None):", "body": "super().__init__(\"<STR_LIT:s>\", <NUM_LIT:1>, [], label=label)<EOL>", "docstring": "Create new S gate.", "id": "f10837:c0:m0"}
{"signature": "def inverse(self):", "body": "return SdgGate()<EOL>", "docstring": "Invert this gate.", "id": "f10837:c0:m2"}
{"signature": "@_to_bits(<NUM_LIT:1>)<EOL>@_op_expand(<NUM_LIT:1>)<EOL>def s(self, q):", "body": "return self.append(SGate(), [q], [])<EOL>", "docstring": "Apply S to q.", "id": "f10837:m0"}
{"signature": "def to_matrix(self):", "body": "return numpy.array([[<NUM_LIT:1>, <NUM_LIT:0>],<EOL>[<NUM_LIT:0>, -<NUM_LIT>]], dtype=complex)<EOL>", "docstring": "Return a Numpy.array for the Sdg gate.", "id": "f10837:c1:m3"}
{"signature": "def _define(self):", "body": "definition = []<EOL>q = QuantumRegister(<NUM_LIT:2>, \"<STR_LIT:q>\")<EOL>rule = [<EOL>(HGate(), [q[<NUM_LIT:1>]], []),<EOL>(CnotGate(), [q[<NUM_LIT:0>], q[<NUM_LIT:1>]], []),<EOL>(HGate(), [q[<NUM_LIT:1>]], [])<EOL>]<EOL>for inst in rule:<EOL><INDENT>definition.append(inst)<EOL><DEDENT>self.definition = definition<EOL>", "docstring": "gate cz a,b { h b; cx a,b; h b; }", "id": "f10838:c0:m1"}
{"signature": "@_to_bits(<NUM_LIT:2>)<EOL>@_op_expand(<NUM_LIT:2>)<EOL>def cx_base(self, ctl, tgt):", "body": "return self.append(CXBase(), [ctl, tgt], [])<EOL>", "docstring": "Apply CX ctl, tgt.", "id": "f10839:m0"}
{"signature": "def inverse(self):", "body": "return RXGate(-self.params[<NUM_LIT:0>])<EOL>", "docstring": "Invert this gate.\n\n        rx(theta)^dagger = rx(-theta)", "id": "f10841:c0:m2"}
{"signature": "def to_matrix(self):", "body": "return numpy.array([[<NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>],<EOL>[<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>],<EOL>[<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>],<EOL>[<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>]], dtype=complex)<EOL>", "docstring": "Return a Numpy.array for the Cx gate.", "id": "f10842:c0:m3"}
{"signature": "@_to_bits(<NUM_LIT:2>)<EOL>@_op_expand(<NUM_LIT:2>)<EOL>def cx(self, ctl, tgt):", "body": "return self.append(CnotGate(), [ctl, tgt], [])<EOL>", "docstring": "Apply CX from ctl to tgt.", "id": "f10842:m0"}
{"signature": "def inverse(self):", "body": "return ZGate()<EOL>", "docstring": "Invert this gate.", "id": "f10843:c0:m2"}
{"signature": "def __init__(self, label=None):", "body": "super().__init__(\"<STR_LIT:z>\", <NUM_LIT:1>, [], label=label)<EOL>", "docstring": "Create new Z gate.", "id": "f10843:c0:m0"}
{"signature": "@_to_bits(<NUM_LIT:1>)<EOL>@_op_expand(<NUM_LIT:1>)<EOL>def z(self, q):", "body": "return self.append(ZGate(), [q], [])<EOL>", "docstring": "Apply Z to q.", "id": "f10843:m0"}
{"signature": "def to_matrix(self):", "body": "return numpy.array([[<NUM_LIT:1>, <NUM_LIT:0>],<EOL>[<NUM_LIT:0>, -<NUM_LIT:1>]], dtype=complex)<EOL>", "docstring": "Return a Numpy.array for the X gate.", "id": "f10843:c0:m3"}
{"signature": "def __init__(self, theta):", "body": "super().__init__(\"<STR_LIT>\", <NUM_LIT:1>, [theta])<EOL>", "docstring": "Create new ry single qubit gate.", "id": "f10844:c0:m0"}
{"signature": "def inverse(self):", "body": "return TdgGate()<EOL>", "docstring": "Invert this gate.", "id": "f10845:c0:m2"}
{"signature": "def snapshot(self,<EOL>label,<EOL>snapshot_type='<STR_LIT>',<EOL>qubits=None,<EOL>params=None):", "body": "<EOL>if not isinstance(label, str):<EOL><INDENT>warnings.warn(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\", DeprecationWarning)<EOL>label = str(label)<EOL><DEDENT>if isinstance(qubits, QuantumRegister):<EOL><INDENT>qubits = qubits[:]<EOL><DEDENT>if not qubits:<EOL><INDENT>tuples = []<EOL>if isinstance(self, QuantumCircuit):<EOL><INDENT>for register in self.qregs:<EOL><INDENT>tuples.append(register)<EOL><DEDENT><DEDENT>if not tuples:<EOL><INDENT>raise ExtensionError('<STR_LIT>')<EOL><DEDENT>qubits = []<EOL>for tuple_element in tuples:<EOL><INDENT>if isinstance(tuple_element, QuantumRegister):<EOL><INDENT>for j in range(tuple_element.size):<EOL><INDENT>qubits.append((tuple_element, j))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>qubits.append(tuple_element)<EOL><DEDENT><DEDENT><DEDENT>return self.append(<EOL>Snapshot(<EOL>label,<EOL>snapshot_type=snapshot_type,<EOL>num_qubits=len(qubits),<EOL>params=params), qubits)<EOL>", "docstring": "Take a statevector snapshot of the internal simulator representation.\n    Works on all qubits, and prevents reordering (like barrier).\n\n    For other types of snapshots use the Snapshot extension directly.\n\n    Args:\n        label (str): a snapshot label to report the result\n        snapshot_type (str): the type of the snapshot.\n        qubits (list or None): the qubits to apply snapshot to [Default: None].\n        params (list or None): the parameters for snapshot_type [Default: None].\n\n    Returns:\n        QuantumCircuit: with attached command\n\n    Raises:\n        ExtensionError: malformed command", "id": "f10847:m0"}
{"signature": "def __init__(self,<EOL>label,<EOL>snapshot_type='<STR_LIT>',<EOL>num_qubits=<NUM_LIT:0>,<EOL>num_clbits=<NUM_LIT:0>,<EOL>params=None):", "body": "if not isinstance(label, str):<EOL><INDENT>raise ExtensionError('<STR_LIT>')<EOL><DEDENT>self._label = label<EOL>self._snapshot_type = snapshot_type<EOL>if params is None:<EOL><INDENT>params = []<EOL><DEDENT>super().__init__('<STR_LIT>', num_qubits, num_clbits, params)<EOL>", "docstring": "Create new snapshot instruction.\n\n        Args:\n            label (str): the snapshot label for result data.\n            snapshot_type (str): the type of the snapshot.\n            num_qubits (int): the number of qubits for the snapshot type [Default: 0].\n            num_clbits (int): the number of classical bits for the snapshot type [Default: 0].\n            params (list or None): the parameters for snapshot_type [Default: None].\n\n        Raises:\n            ExtensionError: if snapshot label is invalid.", "id": "f10847:c0:m0"}
{"signature": "def assemble(self):", "body": "instruction = super().assemble()<EOL>instruction.label = self._label<EOL>instruction.snapshot_type = self._snapshot_type<EOL>return instruction<EOL>", "docstring": "Assemble a QasmQobjInstruction", "id": "f10847:c0:m1"}
{"signature": "def _is_ci_fork_pull_request():", "body": "if os.getenv('<STR_LIT>'):<EOL><INDENT>if os.getenv('<STR_LIT>'):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>elif os.getenv('<STR_LIT>'):<EOL><INDENT>if os.getenv('<STR_LIT>'):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Check if the tests are being run in a CI environment from a PR.\n\n    Check if the tests are being run in a CI environment and if it is a pull\n    request.\n\n    Returns:\n        bool: True if the tests are executed inside a CI tool, and the changes\n            are not against the \"master\" branch.", "id": "f10850:m1"}
{"signature": "@staticmethod<EOL><INDENT>def get_responses_with(string_to_find, cassette_dict):<DEDENT>", "body": "return [response for response, request in<EOL>zip(cassette_dict['<STR_LIT>'], cassette_dict['<STR_LIT>'])<EOL>if string_to_find in request.path]<EOL>", "docstring": "Filters the requests from cassette_dict\n\n        Args:\n            string_to_find (str): request path\n            cassette_dict (dict): a VCR cassette dictionary\n\n        Returns:\n            Request: VCR's representation of a request.", "id": "f10852:c0:m0"}
{"signature": "def _purge_headers_cb(headers):", "body": "header_list = []<EOL>for item in headers:<EOL><INDENT>if not isinstance(item, tuple):<EOL><INDENT>item = (item, None)<EOL><DEDENT>header_list.append(item[<NUM_LIT:0>:<NUM_LIT:2>])  <EOL><DEDENT>def before_record_response_cb(response):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>for (header, value) in header_list:<EOL><INDENT>with suppress(KeyError):<EOL><INDENT>if value:<EOL><INDENT>response['<STR_LIT>'][header] = value<EOL><DEDENT>else:<EOL><INDENT>del response['<STR_LIT>'][header]<EOL><DEDENT><DEDENT><DEDENT>return response<EOL><DEDENT>return before_record_response_cb<EOL>", "docstring": "Remove headers from the response.\n\n    Args:\n        headers (list): headers to remove from the response\n\n    Returns:\n        callable: for been used in before_record_response VCR constructor.", "id": "f10852:m1"}
{"signature": "@staticmethod<EOL><INDENT>def get_new_id(field, path, id_tracker, type_=str):<DEDENT>", "body": "if type_ == float:<EOL><INDENT>return <NUM_LIT><EOL><DEDENT>if type_ == int:<EOL><INDENT>return <NUM_LIT><EOL><DEDENT>dummy_name = '<STR_LIT>' % (path.replace('<STR_LIT:/>', '<STR_LIT>'), field)<EOL>count = len(list(filter(lambda x: str(x).startswith(dummy_name), id_tracker.values())))<EOL>return \"<STR_LIT>\" % (dummy_name, count + <NUM_LIT:1>)<EOL>", "docstring": "Creates a new dummy id (or value) for replacing an existing id (or value).\n\n        Args:\n            field (str): field name is used, in same cases, to create a dummy value.\n            path (str): path of the request is used, in same cases, to create a dummy value.\n            id_tracker (dict): a map of already assigned ids and generated ids.\n            type_ (type): type of the value.\n\n        Returns:\n            str: that is used to replace a value.", "id": "f10852:c0:m1"}
{"signature": "def __init__(self):", "body": "cmap = [[<NUM_LIT:1>, <NUM_LIT:0>], [<NUM_LIT:2>, <NUM_LIT:0>], [<NUM_LIT:2>, <NUM_LIT:1>], [<NUM_LIT:3>, <NUM_LIT:2>], [<NUM_LIT:3>, <NUM_LIT:4>], [<NUM_LIT:4>, <NUM_LIT:2>]]<EOL>configuration = BackendConfiguration(<EOL>backend_name='<STR_LIT>',<EOL>backend_version='<STR_LIT>',<EOL>n_qubits=<NUM_LIT:5>,<EOL>basis_gates=['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:id>'],<EOL>simulator=False,<EOL>local=True,<EOL>conditional=False,<EOL>open_pulse=False,<EOL>memory=False,<EOL>max_shots=<NUM_LIT>,<EOL>gates=[GateConfig(name='<STR_LIT>', parameters=[], qasm_def='<STR_LIT>')],<EOL>coupling_map=cmap,<EOL>)<EOL>super().__init__(configuration)<EOL>", "docstring": "1\n  / |\n0 - 2 - 3\n    | /\n    4", "id": "f10854:c4:m0"}
{"signature": "@staticmethod<EOL><INDENT>def bell_no_measure():<DEDENT>", "body": "qr = QuantumRegister(<NUM_LIT:2>, name='<STR_LIT>')<EOL>qc = QuantumCircuit(qr, name='<STR_LIT>')<EOL>qc.h(qr[<NUM_LIT:0>])<EOL>qc.cx(qr[<NUM_LIT:0>], qr[<NUM_LIT:1>])<EOL>return qc<EOL>", "docstring": "Return a Bell circuit.", "id": "f10855:c0:m1"}
{"signature": "def _get_provider(self):", "body": "return self.provider_cls()<EOL>", "docstring": "Return an instance of a Provider.", "id": "f10856:c0:m2"}
{"signature": "def is_aer_provider_available():", "body": "<EOL>if sys.platform == '<STR_LIT>':<EOL><INDENT>return False<EOL><DEDENT>try:<EOL><INDENT>import qiskit.providers.aer  <EOL><DEDENT>except ImportError:<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "Check if the C++ simulator can be instantiated.\n\n    Returns:\n        bool: True if simulator executable is available", "id": "f10860:m0"}
{"signature": "def two_qubit_kak(unitary_matrix, verify_gate_sequence=False):", "body": "warnings.warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\", DeprecationWarning)<EOL>return synthesis.two_qubit_kak(unitary_matrix)<EOL>", "docstring": "Deprecated after 0.8", "id": "f10862:m1"}
{"signature": "def __init__(self, *msg):", "body": "super().__init__(*msg)<EOL>self.msg = '<STR_LIT:U+0020>'.join(msg)<EOL>", "docstring": "Set the error message.", "id": "f10865:c0:m0"}
{"signature": "def iplot_state_hinton(rho, figsize=None):", "body": "<EOL>html_template = Template(\"\"\"<STR_LIT>\"\"\")<EOL>javascript_template = Template(\"\"\"<STR_LIT>\"\"\")<EOL>rho = _validate_input_state(rho)<EOL>if figsize is None:<EOL><INDENT>options = {}<EOL><DEDENT>else:<EOL><INDENT>options = {'<STR_LIT:width>': figsize[<NUM_LIT:0>], '<STR_LIT>': figsize[<NUM_LIT:1>]}<EOL><DEDENT>div_number = str(time.time())<EOL>div_number = re.sub('<STR_LIT>', '<STR_LIT>', div_number)<EOL>real = []<EOL>imag = []<EOL>for xvalue in rho:<EOL><INDENT>row_real = []<EOL>col_imag = []<EOL>for value_real in xvalue.real:<EOL><INDENT>row_real.append(float(value_real))<EOL><DEDENT>real.append(row_real)<EOL>for value_imag in xvalue.imag:<EOL><INDENT>col_imag.append(float(value_imag))<EOL><DEDENT>imag.append(col_imag)<EOL><DEDENT>html = html_template.substitute({<EOL>'<STR_LIT>': div_number<EOL>})<EOL>javascript = javascript_template.substitute({<EOL>'<STR_LIT>': div_number,<EOL>'<STR_LIT>': [{'<STR_LIT:data>': real}, {'<STR_LIT:data>': imag}],<EOL>'<STR_LIT>': options<EOL>})<EOL>display(HTML(html + javascript))<EOL>", "docstring": "Create a hinton representation.\n\n        Graphical representation of the input array using a 2D city style\n        graph (hinton).\n\n        Args:\n            rho (array): Density matrix\n            figsize (tuple): Figure size in pixels.", "id": "f10869:m0"}
{"signature": "def iplot_bloch_multivector(rho, figsize=None):", "body": "<EOL>html_template = Template(\"\"\"<STR_LIT>\"\"\")<EOL>javascript_template = Template(\"\"\"<STR_LIT>\"\"\")<EOL>rho = _validate_input_state(rho)<EOL>if figsize is None:<EOL><INDENT>options = {}<EOL><DEDENT>else:<EOL><INDENT>options = {'<STR_LIT:width>': figsize[<NUM_LIT:0>], '<STR_LIT>': figsize[<NUM_LIT:1>]}<EOL><DEDENT>num = int(np.log2(len(rho)))<EOL>bloch_data = []<EOL>for i in range(num):<EOL><INDENT>pauli_singles = [Pauli.pauli_single(num, i, '<STR_LIT:X>'), Pauli.pauli_single(num, i, '<STR_LIT:Y>'),<EOL>Pauli.pauli_single(num, i, '<STR_LIT>')]<EOL>bloch_state = list(map(lambda x: np.real(np.trace(np.dot(x.to_matrix(), rho))),<EOL>pauli_singles))<EOL>bloch_data.append(bloch_state)<EOL><DEDENT>div_number = str(time.time())<EOL>div_number = re.sub('<STR_LIT>', '<STR_LIT>', div_number)<EOL>html = html_template.substitute({<EOL>'<STR_LIT>': div_number<EOL>})<EOL>javascript = javascript_template.substitute({<EOL>'<STR_LIT:data>': bloch_data,<EOL>'<STR_LIT>': div_number,<EOL>'<STR_LIT>': options<EOL>})<EOL>display(HTML(html + javascript))<EOL>", "docstring": "Create a bloch sphere representation.\n\n        Graphical representation of the input array, using as much bloch\n        spheres as qubit are required.\n\n        Args:\n            rho (array): State vector or density matrix\n            figsize (tuple): Figure size in pixels.", "id": "f10871:m0"}
{"signature": "def iplot_state_qsphere(rho, figsize=None):", "body": "<EOL>html_template = Template(\"\"\"<STR_LIT>\"\"\")<EOL>javascript_template = Template(\"\"\"<STR_LIT>\"\"\")<EOL>rho = _validate_input_state(rho)<EOL>if figsize is None:<EOL><INDENT>options = {}<EOL><DEDENT>else:<EOL><INDENT>options = {'<STR_LIT:width>': figsize[<NUM_LIT:0>], '<STR_LIT>': figsize[<NUM_LIT:1>]}<EOL><DEDENT>qspheres_data = []<EOL>num = int(np.log2(len(rho)))<EOL>weig, stateall = linalg.eigh(rho)<EOL>for _ in range(<NUM_LIT:2>**num):<EOL><INDENT>probmix = weig.max()<EOL>prob_location = weig.argmax()<EOL>if probmix > <NUM_LIT>:<EOL><INDENT>state = stateall[:, prob_location]<EOL>loc = np.absolute(state).argmax()<EOL>for j in range(<NUM_LIT:2>**num):<EOL><INDENT>test = np.absolute(np.absolute(state[j]) -<EOL>np.absolute(state[loc]))<EOL>if test < <NUM_LIT>:<EOL><INDENT>loc = j<EOL>break<EOL><DEDENT><DEDENT>angles = (np.angle(state[loc]) + <NUM_LIT:2> * np.pi) % (<NUM_LIT:2> * np.pi)<EOL>angleset = np.exp(-<NUM_LIT>*angles)<EOL>state = angleset*state<EOL>state.flatten()<EOL>spherepoints = []<EOL>for i in range(<NUM_LIT:2>**num):<EOL><INDENT>element = bin(i)[<NUM_LIT:2>:].zfill(num)<EOL>weight = element.count(\"<STR_LIT:1>\")<EOL>number_of_divisions = n_choose_k(num, weight)<EOL>weight_order = bit_string_index(element)<EOL>angle = weight_order * <NUM_LIT:2> * np.pi / number_of_divisions<EOL>zvalue = -<NUM_LIT:2> * weight / num + <NUM_LIT:1><EOL>xvalue = np.sqrt(<NUM_LIT:1> - zvalue**<NUM_LIT:2>) * np.cos(angle)<EOL>yvalue = np.sqrt(<NUM_LIT:1> - zvalue**<NUM_LIT:2>) * np.sin(angle)<EOL>prob = np.real(np.dot(state[i], state[i].conj()))<EOL>angles = (np.angle(state[i]) + <NUM_LIT:2> * np.pi) % (<NUM_LIT:2> * np.pi)<EOL>qpoint = {<EOL>'<STR_LIT:x>': xvalue,<EOL>'<STR_LIT:y>': yvalue,<EOL>'<STR_LIT:z>': zvalue,<EOL>'<STR_LIT>': prob,<EOL>'<STR_LIT>': angles<EOL>}<EOL>spherepoints.append(qpoint)<EOL><DEDENT>sphere = {<EOL>'<STR_LIT>': spherepoints,<EOL>'<STR_LIT>': probmix<EOL>}<EOL>qspheres_data.append(sphere)<EOL>weig[prob_location] = <NUM_LIT:0><EOL><DEDENT><DEDENT>div_number = str(time.time())<EOL>div_number = re.sub('<STR_LIT>', '<STR_LIT>', div_number)<EOL>html = html_template.substitute({<EOL>'<STR_LIT>': div_number<EOL>})<EOL>javascript = javascript_template.substitute({<EOL>'<STR_LIT:data>': qspheres_data,<EOL>'<STR_LIT>': div_number,<EOL>'<STR_LIT>': options<EOL>})<EOL>display(HTML(html + javascript))<EOL>", "docstring": "Create a Q sphere representation.\n\n        Graphical representation of the input array, using a Q sphere for each\n        eigenvalue.\n\n        Args:\n            rho (array): State vector or density matrix.\n            figsize (tuple): Figure size in pixels.", "id": "f10872:m0"}
{"signature": "def bit_string_index(text):", "body": "n = len(text)<EOL>k = text.count(\"<STR_LIT:1>\")<EOL>if text.count(\"<STR_LIT:0>\") != n - k:<EOL><INDENT>raise VisualizationError(\"<STR_LIT>\")<EOL><DEDENT>ones = [pos for pos, char in enumerate(text) if char == \"<STR_LIT:1>\"]<EOL>return lex_index(n, k, ones)<EOL>", "docstring": "Return the index of a string of 0s and 1s.", "id": "f10872:m2"}
{"signature": "def iplot_state_paulivec(rho, figsize=None, slider=False, show_legend=False):", "body": "<EOL>html_template = Template(\"\"\"<STR_LIT>\"\"\")<EOL>javascript_template = Template(\"\"\"<STR_LIT>\"\"\")<EOL>rho = _validate_input_state(rho)<EOL>if figsize is None:<EOL><INDENT>figsize = (<NUM_LIT:7>, <NUM_LIT:5>)<EOL><DEDENT>options = {'<STR_LIT:width>': figsize[<NUM_LIT:0>], '<STR_LIT>': figsize[<NUM_LIT:1>],<EOL>'<STR_LIT>': int(slider), '<STR_LIT>': int(show_legend)}<EOL>div_number = str(time.time())<EOL>div_number = re.sub('<STR_LIT>', '<STR_LIT>', div_number)<EOL>data_to_plot = []<EOL>rho_data = process_data(rho)<EOL>data_to_plot.append(dict(<EOL>data=rho_data<EOL>))<EOL>html = html_template.substitute({<EOL>'<STR_LIT>': div_number<EOL>})<EOL>javascript = javascript_template.substitute({<EOL>'<STR_LIT>': div_number,<EOL>'<STR_LIT>': data_to_plot,<EOL>'<STR_LIT>': options<EOL>})<EOL>display(HTML(html + javascript))<EOL>", "docstring": "Create a paulivec representation.\n\n        Graphical representation of the input array.\n\n        Args:\n            rho (array): State vector or density matrix.\n            figsize (tuple): Figure size in pixels.\n            slider (bool): activate slider\n            show_legend (bool): show legend of graph content", "id": "f10874:m1"}
{"signature": "def process_data(data, number_to_keep):", "body": "result = dict()<EOL>if number_to_keep != <NUM_LIT:0>:<EOL><INDENT>data_temp = dict(Counter(data).most_common(number_to_keep))<EOL>data_temp['<STR_LIT>'] = sum(data.values()) - sum(data_temp.values())<EOL>data = data_temp<EOL><DEDENT>labels = data<EOL>values = np.array([data[key] for key in labels], dtype=float)<EOL>pvalues = values / sum(values)<EOL>for position, label in enumerate(labels):<EOL><INDENT>result[label] = round(pvalues[position], <NUM_LIT:5>)<EOL><DEDENT>return result<EOL>", "docstring": "Prepare received data for representation.\n\n        Args:\n            data (dict): values to represent (ex. {'001' : 130})\n            number_to_keep (int): number of elements to show individually.\n\n        Returns:\n            dict: processed data to show.", "id": "f10875:m0"}
{"signature": "def iplot_histogram(data, figsize=None, number_to_keep=None,<EOL>sort='<STR_LIT>', legend=None):", "body": "<EOL>html_template = Template(\"\"\"<STR_LIT>\"\"\")<EOL>javascript_template = Template(\"\"\"<STR_LIT>\"\"\")<EOL>div_number = str(time.time())<EOL>div_number = re.sub('<STR_LIT>', '<STR_LIT>', div_number)<EOL>if figsize is None:<EOL><INDENT>figsize = (<NUM_LIT:7>, <NUM_LIT:5>)<EOL><DEDENT>options = {'<STR_LIT>': <NUM_LIT:0> if number_to_keep is None else number_to_keep,<EOL>'<STR_LIT>': sort,<EOL>'<STR_LIT>': <NUM_LIT:0>,<EOL>'<STR_LIT:width>': int(figsize[<NUM_LIT:0>]),<EOL>'<STR_LIT>': int(figsize[<NUM_LIT:1>])}<EOL>if legend:<EOL><INDENT>options['<STR_LIT>'] = <NUM_LIT:1><EOL><DEDENT>data_to_plot = []<EOL>if isinstance(data, dict):<EOL><INDENT>data = [data]<EOL><DEDENT>if legend and len(legend) != len(data):<EOL><INDENT>raise VisualizationError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" %<EOL>(len(legend), len(data)))<EOL><DEDENT>for item, execution in enumerate(data):<EOL><INDENT>exec_data = process_data(execution, options['<STR_LIT>'])<EOL>out_dict = {'<STR_LIT:data>': exec_data}<EOL>if legend:<EOL><INDENT>out_dict['<STR_LIT:name>'] = legend[item]<EOL><DEDENT>data_to_plot.append(out_dict)<EOL><DEDENT>html = html_template.substitute({<EOL>'<STR_LIT>': div_number<EOL>})<EOL>javascript = javascript_template.substitute({<EOL>'<STR_LIT>': div_number,<EOL>'<STR_LIT>': data_to_plot,<EOL>'<STR_LIT>': options<EOL>})<EOL>display(HTML(html + javascript))<EOL>", "docstring": "Create a histogram representation.\n\n        Graphical representation of the input array using a vertical bars\n        style graph.\n\n        Args:\n            data (list or dict):  This is either a list of dicts or a single\n                dict containing the values to represent (ex. {'001' : 130})\n            figsize (tuple): Figure size in pixels.\n            number_to_keep (int): The number of terms to plot and\n                rest is made into a single bar called other values\n            sort (string): Could be 'asc' or 'desc'\n            legend (list): A list of strings to use for labels of the data.\n                The number of entries must match the length of data.\n        Raises:\n            VisualizationError: When legend is provided and the length doesn't\n                match the input data.", "id": "f10875:m1"}
{"signature": "def plot_bloch_multivector(rho, title='<STR_LIT>', figsize=None):", "body": "if not HAS_MATPLOTLIB:<EOL><INDENT>raise ImportError('<STR_LIT>')<EOL><DEDENT>rho = _validate_input_state(rho)<EOL>num = int(np.log2(len(rho)))<EOL>width, height = plt.figaspect(<NUM_LIT:1>/num)<EOL>fig = plt.figure(figsize=(width, height))<EOL>for i in range(num):<EOL><INDENT>ax = fig.add_subplot(<NUM_LIT:1>, num, i + <NUM_LIT:1>, projection='<STR_LIT>')<EOL>pauli_singles = [<EOL>Pauli.pauli_single(num, i, '<STR_LIT:X>'),<EOL>Pauli.pauli_single(num, i, '<STR_LIT:Y>'),<EOL>Pauli.pauli_single(num, i, '<STR_LIT>')<EOL>]<EOL>bloch_state = list(<EOL>map(lambda x: np.real(np.trace(np.dot(x.to_matrix(), rho))),<EOL>pauli_singles))<EOL>plot_bloch_vector(bloch_state, \"<STR_LIT>\" + str(i), ax=ax,<EOL>figsize=figsize)<EOL><DEDENT>fig.suptitle(title, fontsize=<NUM_LIT:16>)<EOL>plt.close(fig)<EOL>return fig<EOL>", "docstring": "Plot the Bloch sphere.\n\n    Plot a sphere, axes, the Bloch vector, and its projections onto each axis.\n\n    Args:\n        rho (ndarray): Numpy array for state vector or density matrix.\n        title (str): a string that represents the plot title\n        figsize (tuple): Has no effect, here for compatibility only.\n\n    Returns:\n        Figure: A matplotlib figure instance if `ax = None`.\n\n    Raises:\n        ImportError: Requires matplotlib.", "id": "f10878:m2"}
{"signature": "def phase_to_color_wheel(complex_number):", "body": "angles = np.angle(complex_number)<EOL>angle_round = int(((angles + <NUM_LIT:2> * np.pi) % (<NUM_LIT:2> * np.pi))/np.pi*<NUM_LIT:6>)<EOL>color_map = {<EOL><NUM_LIT:0>: (<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>),  <EOL><NUM_LIT:1>: (<NUM_LIT:0.5>, <NUM_LIT:0>, <NUM_LIT:1>),  <EOL><NUM_LIT:2>: (<NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:1>),  <EOL><NUM_LIT:3>: (<NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0.5>),  <EOL><NUM_LIT:4>: (<NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>),  <EOL><NUM_LIT:5>: (<NUM_LIT:1>, <NUM_LIT:0.5>, <NUM_LIT:0>),  <EOL><NUM_LIT:6>: (<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:0>),  <EOL><NUM_LIT:7>: (<NUM_LIT:0.5>, <NUM_LIT:1>, <NUM_LIT:0>),  <EOL><NUM_LIT:8>: (<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>),  <EOL><NUM_LIT:9>: (<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0.5>),  <EOL><NUM_LIT:10>: (<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:1>),  <EOL><NUM_LIT:11>: (<NUM_LIT:0>, <NUM_LIT:0.5>, <NUM_LIT:1>)  <EOL>}<EOL>return color_map[angle_round]<EOL>", "docstring": "Map a phase of a complexnumber to a color in (r,g,b).\n\n    complex_number is phase is first mapped to angle in the range\n    [0, 2pi] and then to a color wheel with blue at zero phase.", "id": "f10878:m8"}
{"signature": "def plot_state(quantum_state, method='<STR_LIT>', figsize=None):", "body": "if not HAS_MATPLOTLIB:<EOL><INDENT>raise ImportError('<STR_LIT>')<EOL><DEDENT>warnings.warn(\"<STR_LIT>\",<EOL>DeprecationWarning)<EOL>rho = _validate_input_state(quantum_state)<EOL>fig = None<EOL>if method == '<STR_LIT>':<EOL><INDENT>fig = plot_state_city(rho, figsize=figsize)<EOL><DEDENT>elif method == \"<STR_LIT>\":<EOL><INDENT>fig = plot_state_paulivec(rho, figsize=figsize)<EOL><DEDENT>elif method == \"<STR_LIT>\":<EOL><INDENT>fig = plot_state_qsphere(rho, figsize=figsize)<EOL><DEDENT>elif method == \"<STR_LIT>\":<EOL><INDENT>plot_bloch_multivector(rho, figsize=figsize)<EOL><DEDENT>elif method == \"<STR_LIT>\":<EOL><INDENT>fig = plot_state_hinton(rho, figsize=figsize)<EOL><DEDENT>return fig<EOL>", "docstring": "Plot the quantum state.\n\n    Args:\n        quantum_state (ndarray): statevector or density matrix\n                                 representation of a quantum state.\n        method (str): Plotting method to use.\n        figsize (tuple): Figure size in inches,\n\n    Returns:\n         matplotlib.Figure: The matplotlib.Figure of the visualization\n    Raises:\n        ImportError: Requires matplotlib.\n        VisualizationError: if the input is not a statevector or density\n        matrix, or if the state is not an multi-qubit quantum state.", "id": "f10878:m10"}
{"signature": "def _generate_normals(polygons):", "body": "if isinstance(polygons, np.ndarray):<EOL><INDENT>n = polygons.shape[-<NUM_LIT:2>]<EOL>i1, i2, i3 = <NUM_LIT:0>, n//<NUM_LIT:3>, <NUM_LIT:2>*n//<NUM_LIT:3><EOL>v1 = polygons[..., i1, :] - polygons[..., i2, :]<EOL>v2 = polygons[..., i2, :] - polygons[..., i3, :]<EOL><DEDENT>else:<EOL><INDENT>v1 = np.empty((len(polygons), <NUM_LIT:3>))<EOL>v2 = np.empty((len(polygons), <NUM_LIT:3>))<EOL>for poly_i, ps in enumerate(polygons):<EOL><INDENT>n = len(ps)<EOL>i1, i2, i3 = <NUM_LIT:0>, n//<NUM_LIT:3>, <NUM_LIT:2>*n//<NUM_LIT:3><EOL>v1[poly_i, :] = ps[i1, :] - ps[i2, :]<EOL>v2[poly_i, :] = ps[i2, :] - ps[i3, :]<EOL><DEDENT><DEDENT>return np.cross(v1, v2)<EOL>", "docstring": "Takes a list of polygons and return an array of their normals.\nNormals point towards the viewer for a face with its vertices in\ncounterclockwise order, following the right hand rule.\nUses three points equally spaced around the polygon.\nThis normal of course might not make sense for polygons with more than\nthree points not lying in a plane, but it's a plausible and fast\napproximation.\nArgs:\n    polygons (list): list of (M_i, 3) array_like, or (..., M, 3) array_like\n        A sequence of polygons to compute normals for, which can have\n        varying numbers of vertices. If the polygons all have the same\n        number of vertices and array is passed, then the operation will\n        be vectorized.\nReturns:\n    normals: (..., 3) array_like\n        A normal vector estimated for the polygon.", "id": "f10878:m12"}
{"signature": "@staticmethod<EOL><INDENT>def fillup_layer(names):  <DEDENT>", "body": "longest = max([len(name) for name in names])<EOL>inputs_wires = []<EOL>for name in names:<EOL><INDENT>inputs_wires.append(InputWire(name.rjust(longest)))<EOL><DEDENT>return inputs_wires<EOL>", "docstring": "Creates a layer with InputWire elements.\nArgs:\n    names (list): List of names for the wires.\n\nReturns:\n    list: The new layer", "id": "f10880:c19:m1"}
{"signature": "def _instruction_to_gate(self, instruction, layer):", "body": "current_cons = []<EOL>connection_label = None<EOL>def add_connected_gate(instruction, gates, layer, current_cons):<EOL><INDENT>for i, gate in enumerate(gates):<EOL><INDENT>layer.set_qubit(instruction.qargs[i], gate)<EOL>actual_index = self.qregs.index(instruction.qargs[i])<EOL>current_cons.append((actual_index, gate))<EOL><DEDENT><DEDENT>if instruction.name == '<STR_LIT>':<EOL><INDENT>gate = MeasureFrom()<EOL>layer.set_qubit(instruction.qargs[<NUM_LIT:0>], gate)<EOL>layer.set_clbit(instruction.cargs[<NUM_LIT:0>], MeasureTo())<EOL><DEDENT>elif instruction.name in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>']:<EOL><INDENT>if not self.plotbarriers:<EOL><INDENT>return layer, current_cons, connection_label<EOL><DEDENT>for qubit in instruction.qargs:<EOL><INDENT>layer.set_qubit(qubit, Barrier())<EOL><DEDENT><DEDENT>elif instruction.name == '<STR_LIT>':<EOL><INDENT>gates = [Ex() for _ in range(len(instruction.qargs))]<EOL>add_connected_gate(instruction, gates, layer, current_cons)<EOL><DEDENT>elif instruction.name == '<STR_LIT>':<EOL><INDENT>gates = [Bullet(), Ex(), Ex()]<EOL>add_connected_gate(instruction, gates, layer, current_cons)<EOL><DEDENT>elif instruction.name == '<STR_LIT>':<EOL><INDENT>layer.set_qubit(instruction.qargs[<NUM_LIT:0>], Reset())<EOL><DEDENT>elif instruction.condition is not None:<EOL><INDENT>cllabel = TextDrawing.label_for_conditional(instruction)<EOL>qulabel = TextDrawing.label_for_box(instruction)<EOL>layer.set_cl_multibox(instruction.condition[<NUM_LIT:0>], cllabel, top_connect='<STR_LIT>')<EOL>layer.set_qubit(instruction.qargs[<NUM_LIT:0>], BoxOnQuWire(qulabel, bot_connect='<STR_LIT>'))<EOL><DEDENT>elif instruction.name in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>gates = [Bullet() for _ in range(len(instruction.qargs) - <NUM_LIT:1>)]<EOL>gates.append(BoxOnQuWire('<STR_LIT:X>'))<EOL>add_connected_gate(instruction, gates, layer, current_cons)<EOL><DEDENT>elif instruction.name == '<STR_LIT>':<EOL><INDENT>gates = [Bullet(), BoxOnQuWire('<STR_LIT:Y>')]<EOL>add_connected_gate(instruction, gates, layer, current_cons)<EOL><DEDENT>elif instruction.name == '<STR_LIT>':<EOL><INDENT>gates = [Bullet(), Bullet()]<EOL>add_connected_gate(instruction, gates, layer, current_cons)<EOL><DEDENT>elif instruction.name == '<STR_LIT>':<EOL><INDENT>gates = [Bullet(), BoxOnQuWire('<STR_LIT:H>')]<EOL>add_connected_gate(instruction, gates, layer, current_cons)<EOL><DEDENT>elif instruction.name == '<STR_LIT>':<EOL><INDENT>connection_label = TextDrawing.params_for_label(instruction)[<NUM_LIT:0>]<EOL>gates = [Bullet(), Bullet()]<EOL>add_connected_gate(instruction, gates, layer, current_cons)<EOL><DEDENT>elif instruction.name == '<STR_LIT>':<EOL><INDENT>connection_label = \"<STR_LIT>\" % TextDrawing.params_for_label(instruction)[<NUM_LIT:0>]<EOL>gates = [Bullet(), Bullet()]<EOL>add_connected_gate(instruction, gates, layer, current_cons)<EOL><DEDENT>elif instruction.name == '<STR_LIT>':<EOL><INDENT>params = TextDrawing.params_for_label(instruction)<EOL>gates = [Bullet(), BoxOnQuWire(\"<STR_LIT>\" % '<STR_LIT:U+002C>'.join(params))]<EOL>add_connected_gate(instruction, gates, layer, current_cons)<EOL><DEDENT>elif instruction.name == '<STR_LIT>':<EOL><INDENT>label = \"<STR_LIT>\" % TextDrawing.params_for_label(instruction)[<NUM_LIT:0>]<EOL>gates = [Bullet(), BoxOnQuWire(label)]<EOL>add_connected_gate(instruction, gates, layer, current_cons)<EOL><DEDENT>elif len(instruction.qargs) == <NUM_LIT:1> and not instruction.cargs:<EOL><INDENT>layer.set_qubit(instruction.qargs[<NUM_LIT:0>],<EOL>BoxOnQuWire(TextDrawing.label_for_box(instruction)))<EOL><DEDENT>elif len(instruction.qargs) >= <NUM_LIT:2> and not instruction.cargs:<EOL><INDENT>label = instruction.name<EOL>params = TextDrawing.params_for_label(instruction)<EOL>if params:<EOL><INDENT>label += \"<STR_LIT>\" % '<STR_LIT:U+002C>'.join(params)<EOL><DEDENT>layer.set_qu_multibox(instruction.qargs, label)<EOL><DEDENT>else:<EOL><INDENT>raise VisualizationError(<EOL>\"<STR_LIT>\", instruction)<EOL><DEDENT>current_cons.sort(key=lambda tup: tup[<NUM_LIT:0>])<EOL>current_cons = [g for q, g in current_cons]<EOL>return layer, current_cons, connection_label<EOL>", "docstring": "Convert an instruction into its corresponding Gate object, and establish\n        any connections it introduces between qubits", "id": "f10880:c20:m15"}
{"signature": "@property<EOL><INDENT>def full_layer(self):<DEDENT>", "body": "return self.qubit_layer + self.clbit_layer<EOL>", "docstring": "Returns the composition of qubits and classic wires.\nReturns:\n    String: self.qubit_layer + self.clbit_layer", "id": "f10880:c21:m1"}
{"signature": "@staticmethod<EOL><INDENT>def draw_wires(wires, vertically_compressed=True):<DEDENT>", "body": "lines = []<EOL>bot_line = None<EOL>for wire in wires:<EOL><INDENT>top_line = '<STR_LIT>'<EOL>for instruction in wire:<EOL><INDENT>top_line += instruction.top<EOL><DEDENT>if bot_line is None:<EOL><INDENT>lines.append(top_line)<EOL><DEDENT>else:<EOL><INDENT>if vertically_compressed:<EOL><INDENT>lines.append(TextDrawing.merge_lines(lines.pop(), top_line))<EOL><DEDENT>else:<EOL><INDENT>lines.append(TextDrawing.merge_lines(lines[-<NUM_LIT:1>], top_line, icod=\"<STR_LIT>\"))<EOL><DEDENT><DEDENT>mid_line = '<STR_LIT>'<EOL>for instruction in wire:<EOL><INDENT>mid_line += instruction.mid<EOL><DEDENT>lines.append(TextDrawing.merge_lines(lines[-<NUM_LIT:1>], mid_line, icod=\"<STR_LIT>\"))<EOL>bot_line = '<STR_LIT>'<EOL>for instruction in wire:<EOL><INDENT>bot_line += instruction.bot<EOL><DEDENT>lines.append(TextDrawing.merge_lines(lines[-<NUM_LIT:1>], bot_line, icod=\"<STR_LIT>\"))<EOL><DEDENT>return lines<EOL>", "docstring": "Given a list of wires, creates a list of lines with the text drawing.\nArgs:\n    wires (list): A list of wires with instructions.\n    vertically_compressed (bool): Default is `True`. It merges the lines\n                             so the drawing will take less vertical room.\nReturns:\n    list: A list of lines with the text drawing.", "id": "f10880:c20:m9"}
{"signature": "def center_label(self, input_length, order):", "body": "location_in_the_box = '<STR_LIT:*>'.center(input_length * <NUM_LIT:2> - <NUM_LIT:1>).index('<STR_LIT:*>') + <NUM_LIT:1><EOL>top_limit = order * <NUM_LIT:2> + <NUM_LIT:2><EOL>bot_limit = top_limit + <NUM_LIT:2><EOL>if top_limit <= location_in_the_box < bot_limit:<EOL><INDENT>if location_in_the_box == top_limit:<EOL><INDENT>self.top_connect = self.label<EOL><DEDENT>elif location_in_the_box == top_limit + <NUM_LIT:1>:<EOL><INDENT>self.mid_content = self.label<EOL><DEDENT>else:<EOL><INDENT>self.bot_connect = self.label<EOL><DEDENT><DEDENT>", "docstring": "In multi-bit elements, the label is centered vertically.\nArgs:\n    input_length (int): Rhe amount of wires affected.\n    order (int): Which middle element is this one?", "id": "f10880:c5:m0"}
{"signature": "def single_string(self):", "body": "return \"<STR_LIT:\\n>\".join(self.lines())<EOL>", "docstring": "Creates a long string with the ascii art\nReturns:\n    str: The lines joined by '\\n'", "id": "f10880:c20:m5"}
{"signature": "@property<EOL><INDENT>def length(self):<DEDENT>", "body": "return max(len(self.top), len(self.mid), len(self.bot))<EOL>", "docstring": "Returns the length of the element, including the box around.", "id": "f10880:c0:m4"}
{"signature": "def build_layers(self):", "body": "wire_names = self.wire_names(with_initial_value=True)<EOL>if not wire_names:<EOL><INDENT>return []<EOL><DEDENT>layers = [InputWire.fillup_layer(wire_names)]<EOL>for instruction_layer in self.instructions:<EOL><INDENT>layer = Layer(self.qregs, self.cregs)<EOL>for instruction in instruction_layer:<EOL><INDENT>layer, current_connections, connection_label =self._instruction_to_gate(instruction, layer)<EOL>layer.connections.append((connection_label, current_connections))<EOL>layer.connect_with(\"<STR_LIT>\")<EOL><DEDENT>layers.append(layer.full_layer)<EOL><DEDENT>return layers<EOL>", "docstring": "Constructs layers.\nReturns:\n    list: List of DrawElements.\nRaises:\n    VisualizationError: When the drawing is, for some reason, impossible to be drawn.", "id": "f10880:c20:m16"}
{"signature": "@property<EOL><INDENT>def width(self):<DEDENT>", "body": "if self._width:<EOL><INDENT>return self._width<EOL><DEDENT>return len(self.mid_content)<EOL>", "docstring": "Returns the width of the label, including padding", "id": "f10880:c0:m5"}
{"signature": "def pulse_drawer(samples, duration, dt=None, interp_method='<STR_LIT:None>',<EOL>filename=None, interactive=False,<EOL>dpi=<NUM_LIT>, nop=<NUM_LIT:1000>, size=(<NUM_LIT:6>, <NUM_LIT:5>)):", "body": "try:<EOL><INDENT>from matplotlib import pyplot as plt<EOL><DEDENT>except ImportError:<EOL><INDENT>raise ImportError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>if dt:<EOL><INDENT>_dt = dt<EOL><DEDENT>else:<EOL><INDENT>_dt = <NUM_LIT:1><EOL><DEDENT>re_y = np.real(samples)<EOL>im_y = np.imag(samples)<EOL>image = plt.figure(figsize=size)<EOL>ax0 = image.add_subplot(<NUM_LIT>)<EOL>if interp_method == '<STR_LIT>':<EOL><INDENT>time = np.arange(<NUM_LIT:0>, duration + <NUM_LIT:1>) * _dt + <NUM_LIT:0.5> * _dt<EOL>cs_ry = CubicSpline(time[:-<NUM_LIT:1>], re_y)<EOL>cs_iy = CubicSpline(time[:-<NUM_LIT:1>], im_y)<EOL>_time = np.linspace(<NUM_LIT:0>, duration * _dt, nop)<EOL>_re_y = cs_ry(_time)<EOL>_im_y = cs_iy(_time)<EOL><DEDENT>elif interp_method == '<STR_LIT:None>':<EOL><INDENT>time = np.arange(<NUM_LIT:0>, duration + <NUM_LIT:1>) * _dt<EOL>_time = np.r_[time[<NUM_LIT:0>], np.repeat(time[<NUM_LIT:1>:-<NUM_LIT:1>], <NUM_LIT:2>), time[-<NUM_LIT:1>]]<EOL>_re_y = np.repeat(re_y, <NUM_LIT:2>)<EOL>_im_y = np.repeat(im_y, <NUM_LIT:2>)<EOL><DEDENT>else:<EOL><INDENT>raise QiskitError('<STR_LIT>' % interp_method)<EOL><DEDENT>ax0.fill_between(x=_time, y1=_re_y, y2=np.zeros_like(_time),<EOL>facecolor='<STR_LIT>', alpha=<NUM_LIT>,<EOL>edgecolor='<STR_LIT>', linewidth=<NUM_LIT>,<EOL>label='<STR_LIT>')<EOL>ax0.fill_between(x=_time, y1=_im_y, y2=np.zeros_like(_time),<EOL>facecolor='<STR_LIT>', alpha=<NUM_LIT>,<EOL>edgecolor='<STR_LIT>', linewidth=<NUM_LIT>,<EOL>label='<STR_LIT>')<EOL>ax0.set_xlim(<NUM_LIT:0>, duration * _dt)<EOL>ax0.grid(b=True, linestyle='<STR_LIT:->')<EOL>ax0.legend(bbox_to_anchor=(<NUM_LIT:0.5>, <NUM_LIT>), loc='<STR_LIT>',<EOL>ncol=<NUM_LIT:2>, frameon=False, fontsize=<NUM_LIT>)<EOL>if filename:<EOL><INDENT>image.savefig(filename, dpi=dpi, bbox_inches='<STR_LIT>')<EOL><DEDENT>plt.close(image)<EOL>if image and interactive:<EOL><INDENT>plt.show(image)<EOL><DEDENT>return image<EOL>", "docstring": "Plot the interpolated envelope of pulse\n\n    Args:\n        samples (ndarray): Data points of complex pulse envelope.\n        duration (int): Pulse length (number of points).\n        dt (float): Time interval of samples.\n        interp_method (str): Method of interpolation\n            (set `None` for turn off the interpolation).\n        filename (str): Name required to save pulse image.\n        interactive (bool): When set true show the circuit in a new window\n            (this depends on the matplotlib backend being used supporting this).\n        dpi (int): Resolution of saved image.\n        nop (int): Data points for interpolation.\n        size (tuple): Size of figure.\n    Returns:\n        matplotlib.figure: A matplotlib figure object for the pulse envelope.\n    Raises:\n        ImportError: when the output methods requieres non-installed libraries.\n        QiskitError: when invalid interpolation method is specified.", "id": "f10882:m0"}
{"signature": "def clear(self):", "body": "self.points = []<EOL>self.vectors = []<EOL>self.point_style = []<EOL>self.annotations = []<EOL>", "docstring": "Resets Bloch sphere data sets to empty.", "id": "f10884:c1:m3"}
{"signature": "def add_vectors(self, vectors):", "body": "if isinstance(vectors[<NUM_LIT:0>], (list, np.ndarray)):<EOL><INDENT>for vec in vectors:<EOL><INDENT>self.vectors.append(vec)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.vectors.append(vectors)<EOL><DEDENT>", "docstring": "Add a list of vectors to Bloch sphere.\n\n        Args:\n            vectors (array_like):\n                Array with vectors of unit length or smaller.", "id": "f10884:c1:m5"}
{"signature": "def show(self, title='<STR_LIT>'):", "body": "self.render(title=title)<EOL>if self.fig:<EOL><INDENT>plt.show(self.fig)<EOL><DEDENT>", "docstring": "Display Bloch sphere and corresponding data sets.", "id": "f10884:c1:m16"}
{"signature": "def _get_gate_span(qregs, instruction):", "body": "min_index = len(qregs)<EOL>max_index = <NUM_LIT:0><EOL>for qreg in instruction.qargs:<EOL><INDENT>index = qregs.index(qreg)<EOL>if index < min_index:<EOL><INDENT>min_index = index<EOL><DEDENT>if index > max_index:<EOL><INDENT>max_index = index<EOL><DEDENT><DEDENT>if instruction.cargs:<EOL><INDENT>return qregs[min_index:]<EOL><DEDENT>return qregs[min_index:max_index + <NUM_LIT:1>]<EOL>", "docstring": "Get the list of qubits drawing this gate would cover", "id": "f10885:m3"}
{"signature": "def _truncate_float(matchobj, format_str='<STR_LIT>'):", "body": "if matchobj.group(<NUM_LIT:0>):<EOL><INDENT>return format(float(matchobj.group(<NUM_LIT:0>)), format_str)<EOL><DEDENT>return '<STR_LIT>'<EOL>", "docstring": "Truncate long floats\n\n    Args:\n        matchobj (re.Match): contains original float\n        format_str (str): format specifier\n    Returns:\n       str: returns truncated float", "id": "f10887:m1"}
{"signature": "def _get_image_depth(self):", "body": "max_column_widths = []<EOL>for layer in self.ops:<EOL><INDENT>current_max = <NUM_LIT:0><EOL>for op in layer:<EOL><INDENT>arg_str_len = <NUM_LIT:0><EOL>for arg in op.op.params:<EOL><INDENT>arg_str = re.sub(r'<STR_LIT>',<EOL>_truncate_float, str(arg))<EOL>arg_str_len += len(arg_str)<EOL><DEDENT>current_max = max(arg_str_len, current_max)<EOL><DEDENT>max_column_widths.append(current_max)<EOL><DEDENT>columns = <NUM_LIT:2><EOL>columns += len(self.ops)<EOL>sum_column_widths = sum(<NUM_LIT:1> + v / <NUM_LIT:3> for v in max_column_widths)<EOL>return columns, math.ceil(sum_column_widths) + <NUM_LIT:4><EOL>", "docstring": "Get depth information for the circuit.\n\n        Returns:\n            int: number of columns in the circuit\n            int: total size of columns in the circuit", "id": "f10887:c0:m3"}
{"signature": "def _get_qubit_index(self, qubit):", "body": "for i, bit in enumerate(self.qubit_list):<EOL><INDENT>if qubit == bit:<EOL><INDENT>qindex = i<EOL>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise exceptions.VisualizationError(\"<STR_LIT>\")<EOL><DEDENT>return qindex<EOL>", "docstring": "Get the index number for a quantum bit\n        Args:\n            qubit (tuple): The tuple of the bit of the form\n                (register_name, bit_number)\n        Returns:\n            int: The index in the bit list\n        Raises:\n            VisualizationError: If the bit isn't found", "id": "f10887:c0:m7"}
{"signature": "def latex(self, aliases=None):", "body": "self._initialize_latex_array(aliases)<EOL>self._build_latex_array(aliases)<EOL>header_1 = r\"\"\"<STR_LIT>\"\"\"% instead and customize the height and width (in cm) to fit.<EOL>images may run out of memory quickly.<EOL><INDENT>this use the LuaLaTeX compiler, which dynamically<EOL><DEDENT>tes memory.<EOL>age[braket, qm]{qcircuit}<EOL>age{amsmath}<EOL>ile{+sansmathaccent.map}<EOL>ckage[landscape]{geometry}<EOL>t out the above line if using the beamer documentclass.<EOL>ocument}<EOL>quation*}\"\"\"<STR_LIT>\"\"\"<EOL>rcuit @C=%<NUM_LIT>fem @R=%<NUM_LIT>fem @!R {<EOL>output = io.StringIO()<EOL>output.write(header_1)<EOL>output.write('<STR_LIT>' % (self.img_width, self.img_depth))<EOL>output.write(beamer_line % self._get_beamer_page())<EOL>output.write(header_2)<EOL>output.write(qcircuit_line %<EOL><INDENT>(self.column_separation, self.row_separation))<EOL>for i in range(self.img_width):<EOL>output.write(\"<STR_LIT>\")<EOL>for j in range(self.img_depth + <NUM_LIT:1>):<EOL>cell_str = self._latex[i][j]<EOL>if '<STR_LIT>' in cell_str:<EOL>output.write(cell_str)<EOL>else:<EOL>cell_str = re.sub(r'<STR_LIT>',<EOL><INDENT>_truncate_float,<EOL>cell_str)<EOL>output.write(cell_str)<EOL>if j != self.img_depth:<EOL>output.write(\"<STR_LIT>\")<EOL>else:<EOL>output.write(r'<STR_LIT:\\\\>' + '<STR_LIT:\\n>')<EOL>output.write('<STR_LIT>')<EOL>output.write('<STR_LIT>')<EOL>output.write('<STR_LIT>')<EOL>contents = output.getvalue()<EOL>output.close()<EOL>return contents<EOL>", "docstring": "Return LaTeX string representation of circuit.\n\n        This method uses the LaTeX Qconfig package to create a graphical\n        representation of the circuit.\n\n        Returns:\n            string: for writing to a LaTeX file.", "id": "f10887:c0:m1"}
{"signature": "def size(self):", "body": "return len(self.graph.nodes)<EOL>", "docstring": "Return the number of physical qubits in this graph.", "id": "f10890:c0:m1"}
{"signature": "def _join_options(self, passset_options):", "body": "default = {'<STR_LIT>': False,  <EOL>'<STR_LIT>': False,  <EOL>'<STR_LIT>': <NUM_LIT:1000>}  <EOL>passmanager_level = {k: v for k, v in self.passmanager_options.items() if v is not None}<EOL>passset_level = {k: v for k, v in passset_options.items() if v is not None}<EOL>return {**default, **passmanager_level, **passset_level}<EOL>", "docstring": "Set the options of each passset, based on precedence rules:\n        passset options (set via ``PassManager.append()``) override\n        passmanager options (set via ``PassManager.__init__()``), which override Default.\n        .", "id": "f10893:c0:m1"}
{"signature": "def transpile(circuits, backend=None, basis_gates=None, coupling_map=None,<EOL>initial_layout=None, seed_mapper=None, pass_manager=None):", "body": "warnings.warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>DeprecationWarning)<EOL>return compiler.transpile(circuits=circuits, backend=backend,<EOL>basis_gates=basis_gates, coupling_map=coupling_map,<EOL>initial_layout=initial_layout, seed_transpiler=seed_mapper,<EOL>pass_manager=pass_manager)<EOL>", "docstring": "transpile one or more circuits.\n\n    Args:\n        circuits (QuantumCircuit or list[QuantumCircuit]): circuits to compile\n        backend (BaseBackend): a backend to compile for\n        basis_gates (list[str]): list of basis gate names supported by the\n            target. Default: ['u1','u2','u3','cx','id']\n        coupling_map (list): coupling map (perhaps custom) to target in mapping\n\n        initial_layout (Layout or dict or list):\n            Initial position of virtual qubits on physical qubits. The final\n            layout is not guaranteed to be the same, as the transpiler may permute\n            qubits through swaps or other means.\n\n        seed_mapper (int): random seed for the swap_mapper\n        pass_manager (PassManager): a pass_manager for the transpiler stages\n\n    Returns:\n        QuantumCircuit or list[QuantumCircuit]: transpiled circuit(s).\n\n    Raises:\n        TranspilerError: in case of bad inputs to transpiler or errors in passes", "id": "f10897:m0"}
{"signature": "def transpile_dag(dag, basis_gates=None, coupling_map=None,<EOL>initial_layout=None, seed_mapper=None, pass_manager=None):", "body": "warnings.warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\", DeprecationWarning)<EOL>if basis_gates is None:<EOL><INDENT>basis_gates = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:id>']<EOL><DEDENT>if pass_manager is None:<EOL><INDENT>if coupling_map:<EOL><INDENT>pass_manager = default_pass_manager(basis_gates,<EOL>CouplingMap(coupling_map),<EOL>initial_layout,<EOL>seed_transpiler=seed_mapper)<EOL><DEDENT>else:<EOL><INDENT>pass_manager = default_pass_manager_simulator(basis_gates)<EOL><DEDENT><DEDENT>name = dag.name<EOL>circuit = dag_to_circuit(dag)<EOL>circuit = pass_manager.run(circuit)<EOL>dag = circuit_to_dag(circuit)<EOL>dag.name = name<EOL>return dag<EOL>", "docstring": "Deprecated - Use qiskit.compiler.transpile for transpiling from\n    circuits to circuits.\n    Transform a dag circuit into another dag circuit\n    (transpile), through consecutive passes on the dag.\n\n    Args:\n        dag (DAGCircuit): dag circuit to transform via transpilation\n        basis_gates (list[str]): list of basis gate names supported by the\n            target. Default: ['u1','u2','u3','cx','id']\n        coupling_map (list): A graph of coupling::\n\n            [\n             [control0(int), target0(int)],\n             [control1(int), target1(int)],\n            ]\n\n            eg. [[0, 2], [1, 2], [1, 3], [3, 4]}\n\n        initial_layout (Layout or None): A layout object\n        seed_mapper (int): random seed_mapper for the swap mapper\n        pass_manager (PassManager): pass manager instance for the transpilation process\n            If None, a default set of passes are run.\n            Otherwise, the passes defined in it will run.\n            If contains no passes in it, no dag transformations occur.\n\n    Returns:\n        DAGCircuit: transformed dag", "id": "f10897:m1"}
{"signature": "@property<EOL><INDENT>def is_transformation_pass(self):<DEDENT>", "body": "return isinstance(self, TransformationPass)<EOL>", "docstring": "If the pass is a TransformationPass, that means that the pass can manipulate the DAG,\n        but cannot modify the property set (but it can be read).", "id": "f10898:c1:m5"}
{"signature": "@abstractmethod<EOL><INDENT>def run(self, dag):<DEDENT>", "body": "raise NotImplementedError<EOL>", "docstring": "Run a pass on the DAGCircuit. This is implemented by the pass developer.\nArgs:\n    dag (DAGCircuit): the dag on which the pass is run.\nRaises:\n    NotImplementedError: when this is left unimplemented for a pass.", "id": "f10898:c1:m4"}
{"signature": "def __init__(self, input_dict=None):", "body": "self._p2v = {}<EOL>self._v2p = {}<EOL>if input_dict is not None:<EOL><INDENT>if not isinstance(input_dict, dict):<EOL><INDENT>raise LayoutError(\"<STR_LIT>\")<EOL><DEDENT>self.from_dict(input_dict)<EOL><DEDENT>", "docstring": "construct a Layout from a bijective dictionary, mapping\n        virtual qubits to physical qubits", "id": "f10899:c0:m0"}
{"signature": "def from_dict(self, input_dict):", "body": "<EOL>if len(input_dict) >= <NUM_LIT:1>:<EOL><INDENT>key = list(input_dict.keys())[<NUM_LIT:0>]<EOL>value = input_dict[key]<EOL>if (isinstance(key, tuple) and  <EOL>len(key) == <NUM_LIT:2> and<EOL>isinstance(key[<NUM_LIT:0>], str) and<EOL>isinstance(key[<NUM_LIT:1>], int) and<EOL>isinstance(value, tuple) and<EOL>len(value) == <NUM_LIT:2> and<EOL>isinstance(key[<NUM_LIT:0>], str) and<EOL>isinstance(key[<NUM_LIT:1>], int)):<EOL><INDENT>warnings.warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (key + value),<EOL>DeprecationWarning)<EOL>qreg_names = {qubit[<NUM_LIT:0>] for qubit in input_dict.keys()}<EOL>qregs = {}<EOL>for qreg_name in qreg_names:<EOL><INDENT>qregs[qreg_name] = QuantumRegister(<EOL>max([qubit[<NUM_LIT:1>] for qubit in input_dict.keys() if qubit[<NUM_LIT:0>] == qreg_name]) + <NUM_LIT:1>,<EOL>qreg_name)<EOL><DEDENT>new_input_dict = {}<EOL>for key, value in input_dict.items():<EOL><INDENT>new_input_dict[value[<NUM_LIT:1>]] = (qregs[key[<NUM_LIT:0>]], key[<NUM_LIT:1>])<EOL><DEDENT>input_dict = new_input_dict<EOL><DEDENT><DEDENT>for key, value in input_dict.items():<EOL><INDENT>virtual, physical = Layout.order_based_on_type(key, value)<EOL>self._p2v[physical] = virtual<EOL>if virtual is None:<EOL><INDENT>continue<EOL><DEDENT>self._v2p[virtual] = physical<EOL><DEDENT>", "docstring": "Populates a Layout from a dictionary.\nThe dictionary must be a bijective mapping between\nvirtual qubits (tuple) and physical qubits (int).\n\nArgs:\n    input_dict (dict):\n        e.g.:\n        {(QuantumRegister(3, 'qr'), 0): 0,\n         (QuantumRegister(3, 'qr'), 1): 1,\n         (QuantumRegister(3, 'qr'), 2): 2}\n\n        Can be written more concisely as follows:\n\n        virtual to physical:\n            {qr[0]: 0,\n             qr[1]: 1,\n             qr[2]: 2}\n\n        physical to virtual:\n            {0: qr[0],\n             1: qr[1],\n             2: qr[2]}", "id": "f10899:c0:m2"}
{"signature": "def copy(self):", "body": "layout_copy = type(self)()<EOL>layout_copy._p2v = self._p2v.copy()<EOL>layout_copy._v2p = self._v2p.copy()<EOL>return layout_copy<EOL>", "docstring": "Returns a copy of a Layout instance.", "id": "f10899:c0:m10"}
{"signature": "@staticmethod<EOL><INDENT>def generate_trivial_layout(*regs):<DEDENT>", "body": "layout = Layout()<EOL>for reg in regs:<EOL><INDENT>layout.add_register(reg)<EOL><DEDENT>return layout<EOL>", "docstring": "Creates a trivial (\"one-to-one\") Layout with the registers in `regs`.\nArgs:\n    *regs (Registers): registers to include in the layout.\nReturns:\n    Layout: A layout with all the `regs` in the given order.", "id": "f10899:c0:m18"}
{"signature": "def swap(self, left, right):", "body": "if type(left) is not type(right):<EOL><INDENT>raise LayoutError('<STR_LIT>')<EOL><DEDENT>temp = self[left]<EOL>self[left] = self[right]<EOL>self[right] = temp<EOL>", "docstring": "Swaps the map between left and right.\n        Args:\n            left (tuple or int): Item to swap with right.\n            right (tuple or int): Item to swap with left.\n        Raises:\n            LayoutError: If left and right have not the same type.", "id": "f10899:c0:m16"}
{"signature": "def __init__(self, *msg):", "body": "super().__init__(*msg)<EOL>self.msg = '<STR_LIT:U+0020>'.join(msg)<EOL>", "docstring": "Set the error message.", "id": "f10900:c3:m0"}
{"signature": "def __init__(self, property_to_check):", "body": "super().__init__()<EOL>self._property = property_to_check<EOL>", "docstring": "Args:\n    property_to_check (str): The property to check if a fixed point was reached.", "id": "f10911:c0:m0"}
{"signature": "def run(self, dag):", "body": "diagonal_1q_gates = (RZGate, ZGate, TGate, SGate, TdgGate, SdgGate, U1Gate)<EOL>diagonal_2q_gates = (CzGate, CrzGate, Cu1Gate, RZZGate)<EOL>nodes_to_remove = set()<EOL>for measure in dag.op_nodes(Measure):<EOL><INDENT>predecessor = dag.quantum_predecessors(measure)[<NUM_LIT:0>]<EOL>if predecessor.type == '<STR_LIT>' and isinstance(predecessor.op, diagonal_1q_gates):<EOL><INDENT>nodes_to_remove.add(predecessor)<EOL><DEDENT>if predecessor.type == '<STR_LIT>' and isinstance(predecessor.op, diagonal_2q_gates):<EOL><INDENT>successors = dag.quantum_successors(predecessor)<EOL>if all([s.type == '<STR_LIT>' and isinstance(s.op, Measure) for s in successors]):<EOL><INDENT>nodes_to_remove.add(predecessor)<EOL><DEDENT><DEDENT><DEDENT>for node_to_remove in nodes_to_remove:<EOL><INDENT>dag.remove_op_node(node_to_remove)<EOL><DEDENT>return dag<EOL>", "docstring": "Return a new circuit that has been optimized.", "id": "f10914:c0:m0"}
{"signature": "def run(self, dag):", "body": "resets = dag.op_nodes(Reset)<EOL>for reset in resets:<EOL><INDENT>predecessor = next(dag.predecessors(reset))<EOL>if predecessor.type == '<STR_LIT>':<EOL><INDENT>dag.remove_op_node(reset)<EOL><DEDENT><DEDENT>return dag<EOL>", "docstring": "Return a new circuit that has been optimized.", "id": "f10918:c0:m0"}
{"signature": "def __init__(self, coupling_map):", "body": "super().__init__()<EOL>self.coupling_map = coupling_map<EOL>", "docstring": "Choose a TrivialLayout.\n\nArgs:\n    coupling_map (Coupling): directed graph representing a coupling map.\n\nRaises:\n    TranspilerError: if invalid options", "id": "f10919:c0:m0"}
{"signature": "def gates_to_idx(gates, qregs):", "body": "sizes = [qr.size for qr in qregs.values()]<EOL>reg_idx = np.cumsum([<NUM_LIT:0>]+sizes)<EOL>regint = {}<EOL>for ind, qreg in enumerate(qregs.values()):<EOL><INDENT>regint[qreg] = ind<EOL><DEDENT>out = np.zeros(<NUM_LIT:2>*len(gates), dtype=np.int32)<EOL>for idx, gate in enumerate(gates):<EOL><INDENT>out[<NUM_LIT:2>*idx] = reg_idx[regint[gate[<NUM_LIT:0>][<NUM_LIT:0>]]]+gate[<NUM_LIT:0>][<NUM_LIT:1>]<EOL>out[<NUM_LIT:2>*idx+<NUM_LIT:1>] = reg_idx[regint[gate[<NUM_LIT:1>][<NUM_LIT:0>]]]+gate[<NUM_LIT:1>][<NUM_LIT:1>]<EOL><DEDENT>return out<EOL>", "docstring": "Converts gate tuples into a nested list of integers.\n\n    Args:\n        gates (list): List of (QuantumRegister, int) pairs\n                      representing gates.\n        qregs (dict): List of )QuantumRegister, int) tuples.\n\n    Returns:\n        list: Nested list of integers for gates.", "id": "f10920:m2"}
{"signature": "def regtuple_to_numeric(items, qregs):", "body": "sizes = [qr.size for qr in qregs.values()]<EOL>reg_idx = np.cumsum([<NUM_LIT:0>]+sizes)<EOL>regint = {}<EOL>for ind, qreg in enumerate(qregs.values()):<EOL><INDENT>regint[qreg] = ind<EOL><DEDENT>out = np.zeros(len(items), dtype=np.int32)<EOL>for idx, val in enumerate(items):<EOL><INDENT>out[idx] = reg_idx[regint[val[<NUM_LIT:0>]]]+val[<NUM_LIT:1>]<EOL><DEDENT>return out<EOL>", "docstring": "Takes (QuantumRegister, int) tuples and converts\n    them into an integer array.\n\n    Args:\n        items (list): List of tuples of (QuantumRegister, int)\n                      to convert.\n        qregs (dict): List of )QuantumRegister, int) tuples.\n    Returns:\n        ndarray: Array of integers.", "id": "f10920:m1"}
{"signature": "def _select_best_remaining_qubit(self, prog_qubit):", "body": "reliab_store = {}<EOL>for hw_qubit in self.available_hw_qubits:<EOL><INDENT>reliab = <NUM_LIT:1><EOL>for n in self.prog_graph.neighbors(prog_qubit):<EOL><INDENT>if n in self.prog2hw:<EOL><INDENT>reliab *= self.swap_costs[self.prog2hw[n]][hw_qubit]<EOL><DEDENT><DEDENT>reliab *= self.readout_errors[hw_qubit]<EOL>reliab_store[hw_qubit] = reliab<EOL><DEDENT>max_reliab = <NUM_LIT:0><EOL>best_hw_qubit = None<EOL>for hw_qubit in reliab_store:<EOL><INDENT>if reliab_store[hw_qubit] > max_reliab:<EOL><INDENT>max_reliab = reliab_store[hw_qubit]<EOL>best_hw_qubit = hw_qubit<EOL><DEDENT><DEDENT>return best_hw_qubit<EOL>", "docstring": "Select the best remaining hardware qubit for the next program qubit.", "id": "f10921:c0:m6"}
{"signature": "def run(self, dag):", "body": "if self.layout is None:<EOL><INDENT>if self.property_set[\"<STR_LIT>\"]:<EOL><INDENT>self.layout = self.property_set[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>self.layout = Layout.generate_trivial_layout(*dag.qregs.values())<EOL><DEDENT><DEDENT>self.property_set['<STR_LIT>'] = True<EOL>edges = self.coupling_map.get_edges()<EOL>for gate in dag.twoQ_gates():<EOL><INDENT>physical_q0 = self.layout[gate.qargs[<NUM_LIT:0>]]<EOL>physical_q1 = self.layout[gate.qargs[<NUM_LIT:1>]]<EOL>if isinstance(gate.op, (CXBase, CnotGate)) and (<EOL>physical_q0, physical_q1) not in edges:<EOL><INDENT>self.property_set['<STR_LIT>'] = False<EOL>return<EOL><DEDENT><DEDENT>", "docstring": "If `dag` is mapped and the direction is correct the property\n`is_direction_mapped` is set to True (or to False otherwise).\n\nArgs:\n    dag (DAGCircuit): DAG to check.", "id": "f10924:c0:m1"}
{"signature": "def __init__(self, coupling_map, initial_layout=None):", "body": "super().__init__()<EOL>self.layout = initial_layout<EOL>self.coupling_map = coupling_map<EOL>", "docstring": "Checks if the CNOTs in DAGCircuit are in the allowed direction with\nrespect to `coupling_map`.\nArgs:\n    coupling_map (CouplingMap): Directed graph representing a coupling map.\n    initial_layout (Layout): The initial layout of the DAG to analyze.", "id": "f10924:c0:m0"}
{"signature": "def run(self, dag):", "body": "if dag.width() > self.coupling_map.size():<EOL><INDENT>raise TranspilerError(\"<STR_LIT>\")<EOL><DEDENT>layerlist = list(dag.layers())<EOL>if self.initial_layout is None and self.property_set[\"<STR_LIT>\"]:<EOL><INDENT>self.initial_layout = self.property_set[\"<STR_LIT>\"]<EOL><DEDENT>if self.initial_layout is not None:<EOL><INDENT>virtual_qubits = self.initial_layout.get_virtual_bits()<EOL>self.initial_layout = {(v[<NUM_LIT:0>].name, v[<NUM_LIT:1>]): ('<STR_LIT:q>', self.initial_layout[v]) for v in<EOL>virtual_qubits}<EOL>device_register = QuantumRegister(self.coupling_map.size(), '<STR_LIT:q>')<EOL>initial_layout = {(dag.qregs[k[<NUM_LIT:0>]], k[<NUM_LIT:1>]): (device_register, v[<NUM_LIT:1>])<EOL>for k, v in self.initial_layout.items()}<EOL>circ_qubits = dag.qubits()<EOL>coup_qubits = [(QuantumRegister(self.coupling_map.size(), '<STR_LIT:q>'), wire) for wire in<EOL>self.coupling_map.physical_qubits]<EOL>qubit_subset = []<EOL>for k, v in initial_layout.items():<EOL><INDENT>qubit_subset.append(v)<EOL>if k not in circ_qubits:<EOL><INDENT>raise TranspilerError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (k[<NUM_LIT:0>].name, k[<NUM_LIT:1>]))<EOL><DEDENT>if v not in coup_qubits:<EOL><INDENT>raise TranspilerError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (v[<NUM_LIT:0>].name, v[<NUM_LIT:1>]))<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>qubit_subset = [(QuantumRegister(self.coupling_map.size(), '<STR_LIT:q>'), wire) for wire in<EOL>self.coupling_map.physical_qubits]<EOL>qubit_subset = qubit_subset[<NUM_LIT:0>:dag.width()]<EOL>initial_layout = {a: b for a, b in zip(dag.qubits(), qubit_subset)}<EOL><DEDENT>layout = initial_layout.copy()<EOL>dagcircuit_output = DAGCircuit()<EOL>dagcircuit_output.name = dag.name<EOL>dagcircuit_output.add_qreg(QuantumRegister(self.coupling_map.size(), \"<STR_LIT:q>\"))<EOL>for creg in dag.cregs.values():<EOL><INDENT>dagcircuit_output.add_creg(creg)<EOL><DEDENT>identity_wire_map = {}<EOL>q = QuantumRegister(self.coupling_map.size(), '<STR_LIT:q>')<EOL>for j in range(self.coupling_map.size()):<EOL><INDENT>identity_wire_map[(q, j)] = (q, j)<EOL><DEDENT>for creg in dag.cregs.values():<EOL><INDENT>for j in range(creg.size):<EOL><INDENT>identity_wire_map[(creg, j)] = (creg, j)<EOL><DEDENT><DEDENT>first_layer = True  <EOL>for i, layer in enumerate(layerlist):<EOL><INDENT>success_flag, best_circ, best_d, best_layout, trivial_flag= self.layer_permutation(layer[\"<STR_LIT>\"], layout, qubit_subset)<EOL>if not success_flag:<EOL><INDENT>serial_layerlist = list(layer[\"<STR_LIT>\"].serial_layers())<EOL>for j, serial_layer in enumerate(serial_layerlist):<EOL><INDENT>success_flag, best_circ, best_d, best_layout, trivial_flag= self.layer_permutation(serial_layer[\"<STR_LIT>\"], layout, qubit_subset)<EOL>if not success_flag:<EOL><INDENT>raise TranspilerError(\"<STR_LIT>\" +<EOL>\"<STR_LIT>\" % (i, j))<EOL><DEDENT>if trivial_flag and first_layer:<EOL><INDENT>continue<EOL><DEDENT>layout = best_layout<EOL>dagcircuit_output.compose_back(<EOL>self.swap_mapper_layer_update(j,<EOL>first_layer,<EOL>best_layout,<EOL>best_d,<EOL>best_circ,<EOL>serial_layerlist),<EOL>identity_wire_map)<EOL>if first_layer:<EOL><INDENT>initial_layout = layout<EOL>first_layer = False<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>layout = best_layout<EOL>dagcircuit_output.compose_back(<EOL>self.swap_mapper_layer_update(i,<EOL>first_layer,<EOL>best_layout,<EOL>best_d,<EOL>best_circ,<EOL>layerlist),<EOL>identity_wire_map)<EOL>if first_layer:<EOL><INDENT>initial_layout = layout<EOL>first_layer = False<EOL><DEDENT><DEDENT><DEDENT>if first_layer:<EOL><INDENT>layout = initial_layout<EOL>for i, layer in enumerate(layerlist):<EOL><INDENT>dagcircuit_output.compose_back(layer[\"<STR_LIT>\"], layout)<EOL><DEDENT><DEDENT>return dagcircuit_output<EOL>", "docstring": "Map a DAGCircuit onto a CouplingGraph using swap gates.\n\n        Args:\n            dag (DAGCircuit): input DAG circuit\n\n        Returns:\n            DAGCircuit: object containing a circuit equivalent to\n            circuit_graph that respects couplings in coupling_map, and\n            a layout dict mapping qubits of circuit_graph into qubits\n            of coupling_map. The layout may differ from the initial_layout\n            if the first layer of gates cannot be executed on the\n            initial_layout.\n\n        Raises:\n            TranspilerError: if there was any error during the mapping or with the\n                parameters.", "id": "f10925:c0:m1"}
{"signature": "def run(self, dag):", "body": "<EOL>final_op_types = ['<STR_LIT>', '<STR_LIT>']<EOL>final_ops = []<EOL>for candidate_node in dag.named_nodes(*final_op_types):<EOL><INDENT>is_final_op = True<EOL>for _, child_successors in dag.bfs_successors(candidate_node):<EOL><INDENT>if any(suc.type == '<STR_LIT>' and suc.name not in final_op_types<EOL>for suc in child_successors):<EOL><INDENT>is_final_op = False<EOL>break<EOL><DEDENT><DEDENT>if is_final_op:<EOL><INDENT>final_ops.append(candidate_node)<EOL><DEDENT><DEDENT>if not final_ops:<EOL><INDENT>return dag<EOL><DEDENT>barrier_layer = DAGCircuit()<EOL>for qreg in dag.qregs.values():<EOL><INDENT>barrier_layer.add_qreg(qreg)<EOL><DEDENT>for creg in dag.cregs.values():<EOL><INDENT>barrier_layer.add_creg(creg)<EOL><DEDENT>final_qubits = set(final_op.qargs[<NUM_LIT:0>] for final_op in final_ops)<EOL>barrier_layer.apply_operation_back(<EOL>Barrier(len(final_qubits)), list(final_qubits), [])<EOL>ordered_final_nodes = [node for node in dag.topological_op_nodes()<EOL>if node in set(final_ops)]<EOL>for final_node in ordered_final_nodes:<EOL><INDENT>barrier_layer.apply_operation_back(final_node.op,<EOL>final_node.qargs,<EOL>final_node.cargs)<EOL><DEDENT>for final_op in final_ops:<EOL><INDENT>dag.remove_op_node(final_op)<EOL><DEDENT>dag.extend_back(barrier_layer)<EOL>adjacent_pass = MergeAdjacentBarriers()<EOL>return adjacent_pass.run(dag)<EOL>", "docstring": "Return a circuit with a barrier before last measurements.", "id": "f10927:c0:m0"}
{"signature": "def _best_subset(self, n_qubits):", "body": "if n_qubits == <NUM_LIT:1>:<EOL><INDENT>return np.array([<NUM_LIT:0>])<EOL><DEDENT>device_qubits = self.coupling_map.size()<EOL>cmap = np.asarray(self.coupling_map.get_edges())<EOL>data = np.ones_like(cmap[:, <NUM_LIT:0>])<EOL>sp_cmap = sp.coo_matrix((data, (cmap[:, <NUM_LIT:0>], cmap[:, <NUM_LIT:1>])),<EOL>shape=(device_qubits, device_qubits)).tocsr()<EOL>best = <NUM_LIT:0><EOL>best_map = None<EOL>for k in range(sp_cmap.shape[<NUM_LIT:0>]):<EOL><INDENT>bfs = cs.breadth_first_order(sp_cmap, i_start=k, directed=False,<EOL>return_predecessors=False)<EOL>connection_count = <NUM_LIT:0><EOL>sub_graph = []<EOL>for i in range(n_qubits):<EOL><INDENT>node_idx = bfs[i]<EOL>for j in range(sp_cmap.indptr[node_idx],<EOL>sp_cmap.indptr[node_idx + <NUM_LIT:1>]):<EOL><INDENT>node = sp_cmap.indices[j]<EOL>for counter in range(n_qubits):<EOL><INDENT>if node == bfs[counter]:<EOL><INDENT>connection_count += <NUM_LIT:1><EOL>sub_graph.append([node_idx, node])<EOL>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if connection_count > best:<EOL><INDENT>best = connection_count<EOL>best_map = bfs[<NUM_LIT:0>:n_qubits]<EOL>mapping = {}<EOL>for edge in range(best_map.shape[<NUM_LIT:0>]):<EOL><INDENT>mapping[best_map[edge]] = edge<EOL><DEDENT>new_cmap = [[mapping[c[<NUM_LIT:0>]], mapping[c[<NUM_LIT:1>]]] for c in sub_graph]<EOL>rows = [edge[<NUM_LIT:0>] for edge in new_cmap]<EOL>cols = [edge[<NUM_LIT:1>] for edge in new_cmap]<EOL>data = [<NUM_LIT:1>]*len(rows)<EOL>sp_sub_graph = sp.coo_matrix((data, (rows, cols)),<EOL>shape=(n_qubits, n_qubits)).tocsr()<EOL>perm = cs.reverse_cuthill_mckee(sp_sub_graph)<EOL>best_map = best_map[perm]<EOL><DEDENT><DEDENT>return best_map<EOL>", "docstring": "Computes the qubit mapping with the best connectivity.\n\n        Args:\n            n_qubits (int): Number of subset qubits to consider.\n\n        Returns:\n            ndarray: Array of qubits to use for best connectivity mapping.", "id": "f10929:c0:m2"}
{"signature": "def _swap_ops_from_edge(edge, layout):", "body": "device_qreg = QuantumRegister(len(layout.get_physical_bits()), '<STR_LIT:q>')<EOL>qreg_edge = [(device_qreg, i) for i in edge]<EOL>return [<EOL>DAGNode({'<STR_LIT>': SwapGate(), '<STR_LIT>': qreg_edge, '<STR_LIT>': [], '<STR_LIT:type>': '<STR_LIT>'})<EOL>]<EOL>", "docstring": "Generate list of ops to implement a SWAP gate along a coupling edge.", "id": "f10930:m6"}
{"signature": "def __init__(self,<EOL>coupling_map,<EOL>initial_layout=None):", "body": "super().__init__()<EOL>self.coupling_map = coupling_map<EOL>self.initial_layout = initial_layout<EOL>self.requires.append(BarrierBeforeFinalMeasurements())<EOL>", "docstring": "Maps a DAGCircuit onto a `coupling_map` using swap gates.\nArgs:\n    coupling_map (CouplingMap): Directed graph represented a coupling map.\n    initial_layout (Layout): initial layout of qubits in mapping", "id": "f10932:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def compose_u3(theta1, phi1, lambda1, theta2, phi2, lambda2):<DEDENT>", "body": "<EOL>thetap, phip, lambdap = Optimize1qGates.yzy_to_zyz((lambda1 + phi2), theta1, theta2)<EOL>(theta, phi, lamb) = (thetap, phi1 + phip, lambda2 + lambdap)<EOL>return (theta, phi, lamb)<EOL>", "docstring": "Return a triple theta, phi, lambda for the product.\n\n        u3(theta, phi, lambda)\n           = u3(theta1, phi1, lambda1).u3(theta2, phi2, lambda2)\n           = Rz(phi1).Ry(theta1).Rz(lambda1+phi2).Ry(theta2).Rz(lambda2)\n           = Rz(phi1).Rz(phi').Ry(theta').Rz(lambda').Rz(lambda2)\n           = u3(theta', phi1 + phi', lambda2 + lambda')\n\n        Return theta, phi, lambda.", "id": "f10938:c0:m2"}
{"signature": "def run_experiment(self, experiment):", "body": "start = time.time()<EOL>self._number_of_qubits = experiment.header.n_qubits<EOL>self._validate_initial_unitary()<EOL>self._initialize_unitary()<EOL>for operation in experiment.instructions:<EOL><INDENT>if operation.name in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>params = getattr(operation, '<STR_LIT>', None)<EOL>qubit = operation.qubits[<NUM_LIT:0>]<EOL>gate = single_gate_matrix(operation.name, params)<EOL>self._add_unitary_single(gate, qubit)<EOL><DEDENT>elif operation.name in ('<STR_LIT:id>', '<STR_LIT>'):<EOL><INDENT>pass<EOL><DEDENT>elif operation.name in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>qubit0 = operation.qubits[<NUM_LIT:0>]<EOL>qubit1 = operation.qubits[<NUM_LIT:1>]<EOL>gate = cx_gate_matrix()<EOL>self._add_unitary_two(gate, qubit0, qubit1)<EOL><DEDENT>elif operation.name == '<STR_LIT>':<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>backend = self.name()<EOL>err_msg = '<STR_LIT>'<EOL>raise BasicAerError(err_msg.format(backend, operation.name))<EOL><DEDENT><DEDENT>data = {'<STR_LIT>': self._get_unitary()}<EOL>end = time.time()<EOL>return {'<STR_LIT:name>': experiment.header.name,<EOL>'<STR_LIT>': <NUM_LIT:1>,<EOL>'<STR_LIT:data>': data,<EOL>'<STR_LIT:status>': '<STR_LIT>',<EOL>'<STR_LIT:success>': True,<EOL>'<STR_LIT>': (end - start),<EOL>'<STR_LIT>': experiment.header.as_dict()}<EOL>", "docstring": "Run an experiment (circuit) and return a single experiment result.\n\n        Args:\n            experiment (QobjExperiment): experiment from qobj experiments list\n\n        Returns:\n            dict: A result dictionary which looks something like::\n\n                {\n                \"name\": name of this experiment (obtained from qobj.experiment header)\n                \"seed\": random seed used for simulation\n                \"shots\": number of shots used in the simulation\n                \"data\":\n                    {\n                    \"unitary\": [[[0.0, 0.0], [1.0, 0.0]],\n                                [[1.0, 0.0], [0.0, 0.0]]]\n                    },\n                \"status\": status string for the simulation\n                \"success\": boolean\n                \"time taken\": simulation time of this single experiment\n                }\n\n        Raises:\n            BasicAerError: if the number of qubits in the circuit is greater than 24.\n            Note that the practical qubit limit is much lower than 24.", "id": "f10946:c0:m9"}
{"signature": "def _get_unitary(self):", "body": "unitary = np.reshape(self._unitary, <NUM_LIT:2> * [<NUM_LIT:2> ** self._number_of_qubits])<EOL>unitary = np.stack((unitary.real, unitary.imag), axis=-<NUM_LIT:1>)<EOL>unitary[abs(unitary) < self._chop_threshold] = <NUM_LIT:0.0><EOL>return unitary<EOL>", "docstring": "Return the current unitary in JSON Result spec format", "id": "f10946:c0:m6"}
{"signature": "def _add_qasm_measure(self, qubit, cmembit, cregbit=None):", "body": "<EOL>outcome, probability = self._get_measure_outcome(qubit)<EOL>membit = <NUM_LIT:1> << cmembit<EOL>self._classical_memory = (self._classical_memory & (~membit)) | (int(outcome) << cmembit)<EOL>if cregbit is not None:<EOL><INDENT>regbit = <NUM_LIT:1> << cregbit<EOL>self._classical_register =(self._classical_register & (~regbit)) | (int(outcome) << cregbit)<EOL><DEDENT>if outcome == '<STR_LIT:0>':<EOL><INDENT>update_diag = [[<NUM_LIT:1> / np.sqrt(probability), <NUM_LIT:0>], [<NUM_LIT:0>, <NUM_LIT:0>]]<EOL><DEDENT>else:<EOL><INDENT>update_diag = [[<NUM_LIT:0>, <NUM_LIT:0>], [<NUM_LIT:0>, <NUM_LIT:1> / np.sqrt(probability)]]<EOL><DEDENT>self._add_unitary_single(update_diag, qubit)<EOL>", "docstring": "Apply a measure instruction to a qubit.\n\n        Args:\n            qubit (int): qubit is the qubit measured.\n            cmembit (int): is the classical memory bit to store outcome in.\n            cregbit (int, optional): is the classical register bit to store outcome in.", "id": "f10947:c0:m5"}
{"signature": "def run(self, qobj, backend_options=None):", "body": "self._set_options(qobj_config=qobj.config,<EOL>backend_options=backend_options)<EOL>job_id = str(uuid.uuid4())<EOL>job = BasicAerJob(self, job_id, self._run_job, qobj)<EOL>job.submit()<EOL>return job<EOL>", "docstring": "Run qobj asynchronously.\n\n        Args:\n            qobj (Qobj): payload of the experiment\n            backend_options (dict): backend options\n\n        Returns:\n            BasicAerJob: derived from BaseJob\n\n        Additional Information:\n            backend_options: Is a dict of options for the backend. It may contain\n                * \"initial_statevector\": vector_like\n\n            The \"initial_statevector\" option specifies a custom initial\n            initial statevector for the simulator to be used instead of the all\n            zero state. This size of this vector must be correct for the number\n            of qubits in all experiments in the qobj.\n\n            Example::\n\n                backend_options = {\n                    \"initial_statevector\": np.array([1, 0, 0, 1j]) / np.sqrt(2),\n                }", "id": "f10947:c0:m12"}
{"signature": "def _add_unitary_single(self, gate, qubit):", "body": "<EOL>indexes = einsum_vecmul_index([qubit], self._number_of_qubits)<EOL>gate_tensor = np.array(gate, dtype=complex)<EOL>self._statevector = np.einsum(indexes, gate_tensor,<EOL>self._statevector,<EOL>dtype=complex,<EOL>casting='<STR_LIT>')<EOL>", "docstring": "Apply an arbitrary 1-qubit unitary matrix.\n\n        Args:\n            gate (matrix_like): a single qubit gate matrix\n            qubit (int): the qubit to apply gate to", "id": "f10947:c0:m1"}
{"signature": "def _set_options(self, qobj_config=None, backend_options=None):", "body": "<EOL>self._initial_statevector = self.DEFAULT_OPTIONS[\"<STR_LIT>\"]<EOL>self._chop_threshold = self.DEFAULT_OPTIONS[\"<STR_LIT>\"]<EOL>if backend_options is None:<EOL><INDENT>backend_options = {}<EOL><DEDENT>if '<STR_LIT>' in backend_options:<EOL><INDENT>self._initial_statevector = np.array(backend_options['<STR_LIT>'],<EOL>dtype=complex)<EOL><DEDENT>elif hasattr(qobj_config, '<STR_LIT>'):<EOL><INDENT>self._initial_statevector = np.array(qobj_config.initial_statevector,<EOL>dtype=complex)<EOL><DEDENT>if self._initial_statevector is not None:<EOL><INDENT>norm = np.linalg.norm(self._initial_statevector)<EOL>if round(norm, <NUM_LIT:12>) != <NUM_LIT:1>:<EOL><INDENT>raise BasicAerError('<STR_LIT>' +<EOL>'<STR_LIT>'.format(norm))<EOL><DEDENT><DEDENT>if '<STR_LIT>' in backend_options:<EOL><INDENT>self._chop_threshold = backend_options['<STR_LIT>']<EOL><DEDENT>elif hasattr(qobj_config, '<STR_LIT>'):<EOL><INDENT>self._chop_threshold = qobj_config.chop_threshold<EOL><DEDENT>", "docstring": "Set the backend options for all experiments in a qobj", "id": "f10947:c0:m8"}
{"signature": "def _validate(self, qobj):", "body": "n_qubits = qobj.config.n_qubits<EOL>max_qubits = self.configuration().n_qubits<EOL>if n_qubits > max_qubits:<EOL><INDENT>raise BasicAerError('<STR_LIT>'.format(n_qubits) +<EOL>'<STR_LIT>'.format(max_qubits) +<EOL>'<STR_LIT>'.format(self.name()))<EOL><DEDENT>if qobj.config.shots != <NUM_LIT:1>:<EOL><INDENT>logger.info('<STR_LIT>',<EOL>self.name())<EOL>qobj.config.shots = <NUM_LIT:1><EOL><DEDENT>for experiment in qobj.experiments:<EOL><INDENT>name = experiment.header.name<EOL>if getattr(experiment.config, '<STR_LIT>', <NUM_LIT:1>) != <NUM_LIT:1>:<EOL><INDENT>logger.info('<STR_LIT>'<EOL>'<STR_LIT>',<EOL>self.name(), name)<EOL>experiment.config.shots = <NUM_LIT:1><EOL><DEDENT><DEDENT>", "docstring": "Semantic validations of the qobj which cannot be done via schemas.\n        Some of these may later move to backend schemas.\n\n        1. No shots\n        2. No measurements in the middle", "id": "f10949:c0:m2"}
{"signature": "def single_gate_matrix(gate, params=None):", "body": "<EOL>(theta, phi, lam) = map(float, single_gate_params(gate, params))<EOL>return np.array([[np.cos(theta / <NUM_LIT:2>),<EOL>-np.exp(<NUM_LIT> * lam) * np.sin(theta / <NUM_LIT:2>)],<EOL>[np.exp(<NUM_LIT> * phi) * np.sin(theta / <NUM_LIT:2>),<EOL>np.exp(<NUM_LIT> * phi + <NUM_LIT> * lam) * np.cos(theta / <NUM_LIT:2>)]])<EOL>", "docstring": "Get the matrix for a single qubit.\n\n    Args:\n        gate(str): the single qubit gate name\n        params(list): the operation parameters op['params']\n    Returns:\n        array: A numpy array representing the matrix", "id": "f10950:m1"}
{"signature": "def cx_gate_matrix():", "body": "return np.array([[<NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>],<EOL>[<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>],<EOL>[<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>],<EOL>[<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>]], dtype=complex)<EOL>", "docstring": "Get the matrix for a controlled-NOT gate.", "id": "f10950:m2"}
{"signature": "def __init__(self, *message):", "body": "super().__init__(*message)<EOL>self.message = '<STR_LIT:U+0020>'.join(message)<EOL>", "docstring": "Set the error message.", "id": "f10951:c0:m0"}
{"signature": "@requires_submit<EOL><INDENT>def result(self, timeout=None):<EOL><DEDENT>", "body": "return self._future.result(timeout=timeout)<EOL>", "docstring": "Get job result. The behavior is the same as the underlying\n        concurrent Future objects,\n\n        https://docs.python.org/3/library/concurrent.futures.html#future-objects\n\n        Args:\n            timeout (float): number of seconds to wait for results.\n\n        Returns:\n            qiskit.Result: Result object\n\n        Raises:\n            concurrent.futures.TimeoutError: if timeout occurred.\n            concurrent.futures.CancelledError: if job cancelled before completed.", "id": "f10952:c0:m2"}
{"signature": "def submit(self):", "body": "if self._future is not None:<EOL><INDENT>raise JobError(\"<STR_LIT>\")<EOL><DEDENT>validate_qobj_against_schema(self._qobj)<EOL>self._future = self._executor.submit(self._fn, self._job_id, self._qobj)<EOL>", "docstring": "Submit the job to the backend for execution.\n\n        Raises:\n            QobjValidationError: if the JSON serialization of the Qobj passed\n            during construction does not validate against the Qobj schema.\n\n            JobError: if trying to re-submit the job.", "id": "f10952:c0:m1"}
{"signature": "def _get_backend_instance(self, backend_cls):", "body": "<EOL>try:<EOL><INDENT>backend_instance = backend_cls(provider=self)<EOL><DEDENT>except Exception as err:<EOL><INDENT>raise QiskitError('<STR_LIT>' %<EOL>(backend_cls, err))<EOL><DEDENT>return backend_instance<EOL>", "docstring": "Return an instance of a backend from its class.\n\nArgs:\n    backend_cls (class): Backend class.\nReturns:\n    BaseBackend: a backend instance.\nRaises:\n    QiskitError: if the backend could not be instantiated.", "id": "f10953:c0:m5"}
{"signature": "@abstractmethod<EOL><INDENT>def submit(self):<DEDENT>", "body": "pass<EOL>", "docstring": "Submit the job to the backend.", "id": "f10955:c0:m3"}
{"signature": "@abstractmethod<EOL><INDENT>def __init__(self, configuration, provider=None):<DEDENT>", "body": "self._configuration = configuration<EOL>self._provider = provider<EOL>", "docstring": "Base class for backends.\n\n        This method should initialize the module and its configuration, and\n        raise an exception if a component of the module is\n        not available.\n\n        Args:\n            configuration (BackendConfiguration): backend configuration\n            provider (BaseProvider): provider responsible for this backend\n\n        Raises:\n            FileNotFoundError if backend executable is not available.\n            QiskitError: if there is no name in the configuration", "id": "f10957:c0:m0"}
{"signature": "def status(self):", "body": "return BackendStatus(backend_name=self.name(),<EOL>backend_version=__version__,<EOL>operational=True,<EOL>pending_jobs=<NUM_LIT:0>,<EOL>status_msg='<STR_LIT>')<EOL>", "docstring": "Return backend status.\n\n        Returns:\n            BackendStatus: the status of the backend.", "id": "f10957:c0:m5"}
{"signature": "def __repr__(self):", "body": "return \"<STR_LIT>\".format(self.__class__.__name__,<EOL>self.name(),<EOL>self._provider)<EOL>", "docstring": "Official string representation of a Backend.\n\n        Note that, by Qiskit convention, it is consciously *not* a fully valid\n        Python expression. Subclasses should provide 'a string of the form\n        <...some useful description...>'. [0]\n\n        [0] https://docs.python.org/3/reference/datamodel.html#object.__repr__", "id": "f10957:c0:m8"}
{"signature": "def provider(self):", "body": "return self._provider<EOL>", "docstring": "Return the backend Provider.\n\n        Returns:\n            BaseProvider: the Provider responsible for the backend.", "id": "f10957:c0:m4"}
{"signature": "def __init__(self, *message):", "body": "super().__init__(*message)<EOL>self.message = '<STR_LIT:U+0020>'.join(message)<EOL>", "docstring": "Set the error message.", "id": "f10959:c1:m0"}
{"signature": "def _deserialize(self, value, attr, data):", "body": "try:<EOL><INDENT>return super()._deserialize(value, attr, data)<EOL><DEDENT>except ValidationError as ex:<EOL><INDENT>if '<STR_LIT>' in ex.messages[<NUM_LIT:0>]:<EOL><INDENT>ex.messages[<NUM_LIT:0>] = '<STR_LIT>'<EOL><DEDENT>raise<EOL><DEDENT>", "docstring": "Override ``_deserialize`` for customizing the exception raised.", "id": "f10961:c0:m3"}
{"signature": "def from_dict_selector(self, choices, *args, **kwargs):", "body": "raise NotImplementedError<EOL>", "docstring": "Return an schema in ``choices`` for deserialization.", "id": "f10961:c0:m2"}
{"signature": "def check_type(self, value, attr, data):", "body": "if self.many and not is_collection(value):<EOL><INDENT>raise self._not_expected_type(<EOL>value, Iterable, fields=[self], field_names=attr, data=data)<EOL><DEDENT>_check_type = super().check_type<EOL>errors = []<EOL>values = value if self.many else [value]<EOL>for idx, v in enumerate(values):<EOL><INDENT>try:<EOL><INDENT>_check_type(v, idx, values)<EOL><DEDENT>except ValidationError as err:<EOL><INDENT>errors.append(err.messages)<EOL><DEDENT><DEDENT>if errors:<EOL><INDENT>errors = errors if self.many else errors[<NUM_LIT:0>]<EOL>raise ValidationError(errors)<EOL><DEDENT>return value<EOL>", "docstring": "Validate if the value is of the type of the schema's model.\n\n        Assumes the nested schema is a ``BaseSchema``.", "id": "f10963:c0:m1"}
{"signature": "def to_dict(self):", "body": "try:<EOL><INDENT>data, _ = self.schema.dump(self)<EOL><DEDENT>except ValidationError as ex:<EOL><INDENT>raise ModelValidationError(<EOL>ex.messages, ex.field_names, ex.fields, ex.data, **ex.kwargs) from None<EOL><DEDENT>return data<EOL>", "docstring": "Serialize the model into a Python dict of simple types.\n\n        Note that this method requires that the model is bound with\n        ``@bind_schema``.", "id": "f10964:c3:m2"}
{"signature": "def __contains__(self, item):", "body": "return item in self.__dict__<EOL>", "docstring": "Custom implementation of membership test.\n\n        Implement the ``__contains__`` method for catering to the common case\n        of finding out if a model contains a certain key (``key in model``).", "id": "f10964:c3:m1"}
{"signature": "def bind_schema(schema):", "body": "return _SchemaBinder(schema)<EOL>", "docstring": "Class decorator for adding schema validation to its instances.\n\n    Instances of the decorated class are automatically validated after\n    instantiation and they are augmented to allow further validations with the\n    private method ``_validate()``.\n\n    The decorator also adds the class attribute ``schema`` with the schema used\n    for validation, along with a class attribute ``shallow_schema`` used for\n    validation during instantiation.\n\n    It also allows using the ``to_dict`` and ``from_dict`` in the model class,\n    with perform serialization/deserialization to/from simple Python objects\n    respectively.\n\n    The same schema cannot be bound more than once. If you need to reuse a\n    schema for a different class, create a new schema subclassing the one you\n    want to reuse and leave the new empty::\n\n        class MySchema(BaseSchema):\n            title = String()\n\n        class AnotherSchema(MySchema):\n            pass\n\n        @bind_schema(MySchema):\n        class MyModel(BaseModel):\n            pass\n\n        @bind_schema(AnotherSchema):\n        class AnotherModel(BaseModel):\n            pass\n\n    Raises:\n        ValueError: when trying to bind the same schema more than once.\n\n    Return:\n        type: the same class with validation capabilities.", "id": "f10964:m0"}
{"signature": "def check_type(self, value, attr, data):", "body": "expected_types = self._expected_types()<EOL>if not isinstance(value, expected_types):<EOL><INDENT>raise self._not_expected_type(<EOL>value, expected_types, fields=[self], field_names=attr, data=data)<EOL><DEDENT>return value<EOL>", "docstring": "Validates a value against the correct type of the field.\n\n        It calls ``_expected_types`` to get a list of valid types.\n\n        Subclasses can do one of the following:\n\n            1. They can override the ``valid_types`` property with a tuple with\n            the expected types for this field.\n\n            2. They can override the ``_expected_types`` method to return a\n            tuple of expected types for the field.\n\n            3. They can change ``check_type`` completely to customize\n            validation.\n\n        This method or the overrides must return the ``value`` parameter\n        untouched.", "id": "f10964:c0:m1"}
{"signature": "def _get_validator(name, schema=None, check_schema=True,<EOL>validator_class=None, **validator_kwargs):", "body": "if schema is None:<EOL><INDENT>try:<EOL><INDENT>schema = _SCHEMAS[name]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise SchemaValidationError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if name not in _VALIDATORS:<EOL><INDENT>if validator_class is None:<EOL><INDENT>validator_class = jsonschema.validators.validator_for(schema)<EOL><DEDENT>_VALIDATORS[name] = validator_class(schema, **validator_kwargs)<EOL><DEDENT>validator = _VALIDATORS[name]<EOL>if check_schema:<EOL><INDENT>validator.check_schema(schema)<EOL><DEDENT>return validator<EOL>", "docstring": "Generate validator for JSON schema.\n\n    Args:\n        name (str): Name for validator. Will be validator key in\n            `_VALIDATORS` dict.\n        schema (dict): JSON schema `dict`. If not provided searches for schema\n            in `_SCHEMAS`.\n        check_schema (bool): Verify schema is valid.\n        validator_class (jsonschema.IValidator): jsonschema IValidator instance.\n            Default behavior is to determine this from the schema `$schema`\n            field.\n        **validator_kwargs (dict): Additional keyword arguments for validator.\n\n    Return:\n        jsonschema.IValidator: Validator for JSON schema.\n\n    Raises:\n        SchemaValidationError: Raised if validation fails.", "id": "f10967:m1"}
{"signature": "def verify_bit_list(self, obj):", "body": "<EOL>for children in obj.children:<EOL><INDENT>self.verify_declared_bit(children)<EOL><DEDENT>", "docstring": "Verify each qubit in a list of ids.", "id": "f10971:c0:m5"}
{"signature": "def p_unitary_op_3(self, program):", "body": "program[<NUM_LIT:0>] = node.CustomUnitary([program[<NUM_LIT:1>], program[<NUM_LIT:4>]])<EOL>self.verify_as_gate(program[<NUM_LIT:1>], program[<NUM_LIT:4>])<EOL>self.verify_reg_list(program[<NUM_LIT:4>], '<STR_LIT>')<EOL>self.verify_distinct([program[<NUM_LIT:4>]])<EOL>", "docstring": "unitary_op : id '(' ')' primary_list", "id": "f10971:c0:m48"}
{"signature": "def verify_reg_list(self, obj, object_type):", "body": "<EOL>for children in obj.children:<EOL><INDENT>self.verify_reg(children, object_type)<EOL><DEDENT>", "docstring": "Verify a list of registers.", "id": "f10971:c0:m9"}
{"signature": "def pop_scope(self):", "body": "self.current_symtab = self.symbols.pop()<EOL>", "docstring": "Return to the previous scope.", "id": "f10971:c0:m12"}
{"signature": "def p_gate_op_4(self, program):", "body": "program[<NUM_LIT:0>] = node.CustomUnitary([program[<NUM_LIT:1>], program[<NUM_LIT:3>], program[<NUM_LIT:5>]])<EOL>self.verify_as_gate(program[<NUM_LIT:1>], program[<NUM_LIT:5>], arglist=program[<NUM_LIT:3>])<EOL>self.verify_bit_list(program[<NUM_LIT:5>])<EOL>self.verify_exp_list(program[<NUM_LIT:3>])<EOL>self.verify_distinct([program[<NUM_LIT:5>]])<EOL>", "docstring": "gate_op : id '(' exp_list ')' id_list ';'", "id": "f10971:c0:m59"}
{"signature": "def p_gate_op_5(self, program):", "body": "program[<NUM_LIT:0>] = node.Barrier([program[<NUM_LIT:2>]])<EOL>self.verify_bit_list(program[<NUM_LIT:2>])<EOL>self.verify_distinct([program[<NUM_LIT:2>]])<EOL>", "docstring": "gate_op : BARRIER id_list ';'", "id": "f10971:c0:m62"}
{"signature": "def find_column(self, input_, token):", "body": "if token is None:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>last_cr = input_.rfind('<STR_LIT:\\n>', <NUM_LIT:0>, token.lexpos)<EOL>if last_cr < <NUM_LIT:0>:<EOL><INDENT>last_cr = <NUM_LIT:0><EOL><DEDENT>column = (token.lexpos - last_cr) + <NUM_LIT:1><EOL>return column<EOL>", "docstring": "Compute the column.\n\n        Input is the input text string.\n        token is a token instance.", "id": "f10971:c0:m87"}
{"signature": "def id_tuple_list(self, id_node):", "body": "if id_node.type != \"<STR_LIT:id>\":<EOL><INDENT>raise QasmError(\"<STR_LIT>\")<EOL><DEDENT>bit_list = []<EOL>try:<EOL><INDENT>g_sym = self.current_symtab[id_node.name]<EOL><DEDENT>except KeyError:<EOL><INDENT>g_sym = self.global_symtab[id_node.name]<EOL><DEDENT>if g_sym.type == \"<STR_LIT>\" or g_sym.type == \"<STR_LIT>\":<EOL><INDENT>for idx in range(g_sym.index):<EOL><INDENT>bit_list.append((id_node.name, idx))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>bit_list.append((id_node.name, -<NUM_LIT:1>))<EOL><DEDENT>return bit_list<EOL>", "docstring": "Return a list of (name, index) tuples for this id node.", "id": "f10971:c0:m10"}
{"signature": "def p_gate_op_1e1(self, program):", "body": "raise QasmError(\"<STR_LIT>\"<EOL>+ \"<STR_LIT>\"<EOL>+ str(program[<NUM_LIT:2>].value) + \"<STR_LIT:'>\")<EOL>", "docstring": "gate_op : CX error", "id": "f10971:c0:m54"}
{"signature": "def p_gate_id_list_1(self, program):", "body": "program[<NUM_LIT:0>] = program[<NUM_LIT:1>]<EOL>program[<NUM_LIT:0>].add_child(program[<NUM_LIT:3>])<EOL>self.update_symtab(program[<NUM_LIT:3>])<EOL>", "docstring": "gate_id_list : gate_id_list ',' id", "id": "f10971:c0:m27"}
{"signature": "def p_id_list_1(self, program):", "body": "program[<NUM_LIT:0>] = program[<NUM_LIT:1>]<EOL>program[<NUM_LIT:0>].add_child(program[<NUM_LIT:3>])<EOL>", "docstring": "id_list : id_list ',' id", "id": "f10971:c0:m25"}
{"signature": "def p_gate_op_4e0(self, program):", "body": "raise QasmError(\"<STR_LIT>\"<EOL>+ \"<STR_LIT>\")<EOL>", "docstring": "gate_op : id '(' ')'  error", "id": "f10971:c0:m60"}
{"signature": "def p_gate_op_2e(self, program):", "body": "raise QasmError(\"<STR_LIT>\")<EOL>", "docstring": "gate_op : id  id_list error", "id": "f10971:c0:m57"}
{"signature": "def get_tokens(self):", "body": "try:<EOL><INDENT>while True:<EOL><INDENT>token = self.lexer.token()<EOL>if not token:<EOL><INDENT>break<EOL><DEDENT>yield token<EOL><DEDENT><DEDENT>except QasmError as e:<EOL><INDENT>print('<STR_LIT>', e.msg)<EOL><DEDENT>", "docstring": "Returns a generator of the tokens.", "id": "f10971:c0:m88"}
{"signature": "def p_unitary_op_0(self, program):", "body": "program[<NUM_LIT:0>] = node.UniversalUnitary([program[<NUM_LIT:3>], program[<NUM_LIT:5>]])<EOL>self.verify_reg(program[<NUM_LIT:5>], '<STR_LIT>')<EOL>self.verify_exp_list(program[<NUM_LIT:3>])<EOL>", "docstring": "unitary_op : U '(' exp_list ')' primary", "id": "f10971:c0:m45"}
{"signature": "def get_filename(self):", "body": "return self._filename<EOL>", "docstring": "Return the filename.", "id": "f10972:c0:m1"}
{"signature": "def __init__(self, filename=None, data=None):", "body": "if filename is None and data is None:<EOL><INDENT>raise QasmError(\"<STR_LIT>\")<EOL><DEDENT>if filename is not None and data is not None:<EOL><INDENT>raise QasmError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>self._filename = filename<EOL>self._data = data<EOL>", "docstring": "Create an OPENQASM circuit object.", "id": "f10972:c0:m0"}
{"signature": "def __init__(self, children):", "body": "super().__init__('<STR_LIT>', children, None)<EOL>", "docstring": "Create the cnot node.", "id": "f10974:c0:m0"}
{"signature": "def latex(self, prec=<NUM_LIT:15>, nested_scope=None):", "body": "<EOL>return \"<STR_LIT>\" % self.value<EOL>", "docstring": "Return the corresponding math mode latex string.", "id": "f10975:c0:m3"}
{"signature": "def qasm(self, prec=<NUM_LIT:15>):", "body": "return \"<STR_LIT:(>\" + self.children[<NUM_LIT:1>].qasm(prec) + self.children[<NUM_LIT:0>].value +self.children[<NUM_LIT:2>].qasm(prec) + \"<STR_LIT:)>\"<EOL>", "docstring": "Return the corresponding OPENQASM string.", "id": "f10976:c0:m1"}
{"signature": "def latex(self, prec=<NUM_LIT:15>, nested_scope=None):", "body": "<EOL>return sympy.latex(self.sym(nested_scope))<EOL>", "docstring": "Return the corresponding math mode latex string.", "id": "f10976:c0:m2"}
{"signature": "def real(self, nested_scope=None):", "body": "operation = self.children[<NUM_LIT:0>].operation()<EOL>lhs = self.children[<NUM_LIT:1>].real(nested_scope)<EOL>rhs = self.children[<NUM_LIT:2>].real(nested_scope)<EOL>return operation(lhs, rhs)<EOL>", "docstring": "Return the correspond floating point number.", "id": "f10976:c0:m3"}
{"signature": "def qasm(self, prec=<NUM_LIT:15>):", "body": "<EOL>return self.value<EOL>", "docstring": "Return QASM representation.", "id": "f10977:c0:m2"}
{"signature": "def __init__(self, children):", "body": "super().__init__('<STR_LIT>', children, None)<EOL>", "docstring": "Create the external node.", "id": "f10978:c0:m0"}
{"signature": "def __init__(self, operation):", "body": "super().__init__('<STR_LIT>', None, None)<EOL>self.value = operation<EOL>", "docstring": "Create the operator node.", "id": "f10979:c0:m0"}
{"signature": "def __init__(self, children):", "body": "super().__init__('<STR_LIT>', children, None)<EOL>self.id = children[<NUM_LIT:0>]<EOL>self.name = self.id.name<EOL>self.line = self.id.line<EOL>self.file = self.id.file<EOL>if len(children) == <NUM_LIT:3>:<EOL><INDENT>self.arguments = children[<NUM_LIT:1>]<EOL>self.bitlist = children[<NUM_LIT:2>]<EOL><DEDENT>else:<EOL><INDENT>self.arguments = None<EOL>self.bitlist = children[<NUM_LIT:1>]<EOL><DEDENT>", "docstring": "Create the opaque gate node.", "id": "f10980:c0:m0"}
{"signature": "def qasm(self, prec=<NUM_LIT:15>):", "body": "string = \"<STR_LIT>\"<EOL>for children in self.children:<EOL><INDENT>string += children.qasm(prec) + \"<STR_LIT:\\n>\"<EOL><DEDENT>return string<EOL>", "docstring": "Return the corresponding OPENQASM string.", "id": "f10981:c0:m1"}
{"signature": "def __init__(self, children):", "body": "super().__init__('<STR_LIT>', children, None)<EOL>", "docstring": "Create the prefix node.", "id": "f10982:c0:m0"}
{"signature": "def qasm(self, prec=<NUM_LIT:15>):", "body": "return \"<STR_LIT>\" + self.children[<NUM_LIT:0>].qasm(prec) + \"<STR_LIT>\" +self.children[<NUM_LIT:1>].qasm(prec) + \"<STR_LIT:;>\"<EOL>", "docstring": "Return the corresponding OPENQASM string.", "id": "f10984:c0:m1"}
{"signature": "def qasm(self, prec=<NUM_LIT:15>):", "body": "return \"<STR_LIT:U+002C>\".join([self.children[j].qasm(prec)<EOL>for j in range(self.size())])<EOL>", "docstring": "Return the corresponding OPENQASM string.", "id": "f10985:c0:m2"}
{"signature": "def qasm(self, prec=<NUM_LIT:15>):", "body": "return \"<STR_LIT>\" + self.children[<NUM_LIT:0>].qasm(prec) + \"<STR_LIT>\"+ str(self.children[<NUM_LIT:1>].value) + \"<STR_LIT>\" +self.children[<NUM_LIT:2>].qasm(prec)<EOL>", "docstring": "Return the corresponding OPENQASM string.", "id": "f10986:c0:m1"}
{"signature": "def latex(self, prec=<NUM_LIT:15>, nested_scope=None):", "body": "if not nested_scope:<EOL><INDENT>return \"<STR_LIT>\" + self.name + \"<STR_LIT:}>\"<EOL><DEDENT>else:<EOL><INDENT>if self.name not in nested_scope[-<NUM_LIT:1>]:<EOL><INDENT>raise NodeException(\"<STR_LIT>\",<EOL>\"<STR_LIT>\" % self.name,<EOL>\"<STR_LIT>\" % self.line,<EOL>\"<STR_LIT>\" % self.file)<EOL><DEDENT>else:<EOL><INDENT>return nested_scope[-<NUM_LIT:1>][self.name].latex(prec,<EOL>nested_scope[<NUM_LIT:0>:-<NUM_LIT:1>])<EOL><DEDENT><DEDENT>", "docstring": "Return the correspond math mode latex string.", "id": "f10988:c0:m3"}
{"signature": "def qasm(self, prec=<NUM_LIT:15>):", "body": "<EOL>return self.name<EOL>", "docstring": "Return the corresponding OPENQASM string.", "id": "f10988:c0:m2"}
{"signature": "def version(self):", "body": "return \"<STR_LIT>\" % (self.majorversion, self.minorversion)<EOL>", "docstring": "Return the version.", "id": "f10990:c0:m1"}
{"signature": "def __init__(self, children):", "body": "super().__init__('<STR_LIT>', children, None)<EOL>", "docstring": "Create the idlist node.", "id": "f10991:c0:m0"}
{"signature": "def size(self):", "body": "return len(self.children)<EOL>", "docstring": "Return the length of the list.", "id": "f10991:c0:m1"}
{"signature": "def __init__(self, children):", "body": "super().__init__('<STR_LIT>', children, None)<EOL>", "docstring": "Create the measure node.", "id": "f10992:c0:m0"}
{"signature": "def __init__(self, children):", "body": "super().__init__('<STR_LIT>', children, None)<EOL>", "docstring": "Create the barrier node.", "id": "f10993:c0:m0"}
{"signature": "def __init__(self, children):", "body": "super().__init__('<STR_LIT>', children, None)<EOL>", "docstring": "Create the gatebody node.", "id": "f10994:c0:m0"}
{"signature": "def n_args(self):", "body": "if self.arguments:<EOL><INDENT>return self.arguments.size()<EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Return the number of parameter expressions.", "id": "f10995:c0:m1"}
{"signature": "def n_bits(self):", "body": "return self.bitlist.size()<EOL>", "docstring": "Return the number of qubit arguments.", "id": "f10995:c0:m2"}
{"signature": "def size(self):", "body": "return len(self.children)<EOL>", "docstring": "Return the size of the list.", "id": "f10997:c0:m1"}
{"signature": "def to_string(self, indent):", "body": "ind = indent * '<STR_LIT:U+0020>'<EOL>print(ind, '<STR_LIT>')<EOL>self.children[<NUM_LIT:0>].to_string(indent + <NUM_LIT:3>)<EOL>", "docstring": "Print the node data, with indent.", "id": "f10998:c0:m1"}
{"signature": "def to_string(self, indent):", "body": "ind = indent * '<STR_LIT:U+0020>'<EOL>print(ind, '<STR_LIT>', self.value)<EOL>", "docstring": "Print with indent.", "id": "f10999:c0:m1"}
{"signature": "def to_string(self, indent):", "body": "ind = indent * '<STR_LIT:U+0020>'<EOL>if self.root:<EOL><INDENT>print(ind, self.type, '<STR_LIT>', self.root)<EOL><DEDENT>else:<EOL><INDENT>print(ind, self.type)<EOL><DEDENT>indent = indent + <NUM_LIT:3><EOL>ind = indent * '<STR_LIT:U+0020>'<EOL>for children in self.children:<EOL><INDENT>if children is None:<EOL><INDENT>print(\"<STR_LIT>\", type(self))<EOL>print(self.children)<EOL><DEDENT>if isinstance(children, str):<EOL><INDENT>print(ind, children)<EOL><DEDENT>elif isinstance(children, int):<EOL><INDENT>print(ind, str(children))<EOL><DEDENT>elif isinstance(children, float):<EOL><INDENT>print(ind, str(children))<EOL><DEDENT>else:<EOL><INDENT>children.to_string(indent)<EOL><DEDENT><DEDENT>", "docstring": "Print with indent.", "id": "f11000:c0:m3"}
{"signature": "def qasm(self, prec=<NUM_LIT:15>):", "body": "<EOL>return self.name + \"<STR_LIT>\" % self.index<EOL>", "docstring": "Return the corresponding OPENQASM string.", "id": "f11001:c0:m2"}
{"signature": "def t_MATCHES(self, t):", "body": "return t<EOL>", "docstring": "==", "id": "f11003:c0:m9"}
{"signature": "def t_ID(self, t):", "body": "t.type = self.reserved.get(t.value, '<STR_LIT>')<EOL>if t.type == '<STR_LIT>':<EOL><INDENT>t.value = node.Id(t.value, self.lineno, self.filename)<EOL><DEDENT>return t<EOL>", "docstring": "r'[a-z][a-zA-Z0-9_]*", "id": "f11003:c0:m16"}
{"signature": "def t_STRING(self, t):", "body": "return t<EOL>", "docstring": "r'\\\"([^\\\\\\\"]|\\\\.)*\\", "id": "f11003:c0:m10"}
{"signature": "def t_NNINTEGER(self, t):", "body": "t.value = int(t.value)<EOL>return t<EOL>", "docstring": "r'[1-9]+[0-9]*|0", "id": "f11003:c0:m7"}
{"signature": "def t_ASSIGN(self, t):", "body": "return t<EOL>", "docstring": "->", "id": "f11003:c0:m8"}
{"signature": "def __init__(self, *msg):", "body": "super().__init__(*msg)<EOL>self.msg = '<STR_LIT:U+0020>'.join(msg)<EOL>", "docstring": "Set the error message.", "id": "f11004:c0:m0"}
{"signature": "@bind_instruction(commands.PersistentValueInstruction)<EOL><INDENT>def convert_persistent_value(self, shift, instruction):<DEDENT>", "body": "command_dict = {<EOL>'<STR_LIT:name>': '<STR_LIT>',<EOL>'<STR_LIT>': shift+instruction.start_time,<EOL>'<STR_LIT>': instruction.channels[<NUM_LIT:0>].name,<EOL>'<STR_LIT>': instruction.command.value<EOL>}<EOL>return self._qobj_model(**command_dict)<EOL>", "docstring": "Return converted `PersistentValueInstruction`.\n\n        Args:\n            shift(int): Offset time.\n            instruction (PersistentValueInstruction): persistent value instruction.\n        Returns:\n            dict: Dictionary of required parameters.", "id": "f11005:c1:m4"}
{"signature": "def get_bound_method(self, instruction):", "body": "try:<EOL><INDENT>return self._bound_instructions[type(instruction)]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise PulseError('<STR_LIT>' % instruction)<EOL><DEDENT>", "docstring": "Get conversion method for instruction.", "id": "f11005:c0:m2"}
{"signature": "def get_meas_los(self, user_lo_config):", "body": "try:<EOL><INDENT>_m_los = self.default_meas_los.copy()<EOL><DEDENT>except KeyError:<EOL><INDENT>raise PulseError('<STR_LIT>')<EOL><DEDENT>for channel, lo_freq in user_lo_config.meas_lo_dict().items():<EOL><INDENT>_m_los[channel.index] = lo_freq<EOL><DEDENT>if _m_los == self.default_meas_los:<EOL><INDENT>return None<EOL><DEDENT>return _m_los<EOL>", "docstring": "Embed default meas LO frequencies from backend and format them to list object.\n        If configured lo frequency is the same as default, this method returns `None`.\n\n        Args:\n            user_lo_config (LoConfig): A dictionary of LOs to format.\n\n        Returns:\n            list: A list of meas LOs.\n\n        Raises:\n            PulseError: when LO frequencies are missing.", "id": "f11007:c0:m3"}
{"signature": "def list_or_single(iterable):", "body": "warnings.warn(\"<STR_LIT>\", DeprecationWarning, stacklevel=<NUM_LIT:2>)<EOL>return maybe_single(list(iterable))<EOL>", "docstring": "Given an iterable, return the items as a list. If the iterable contains\nexactly one item, return that item. Correlary function to always_iterable.", "id": "f11047:m25"}
{"signature": "def always_iterable(item):", "body": "base_types = six.text_type, bytes, collections.abc.Mapping<EOL>return more_itertools.always_iterable(item, base_type=base_types)<EOL>", "docstring": "Given an object, always return an iterable. If the item is not\nalready iterable, return a tuple containing only the item. If item is\nNone, an empty iterable is returned.\n\n>>> always_iterable([1,2,3])\n<list_iterator...>\n>>> always_iterable('foo')\n<tuple_iterator...>\n>>> always_iterable(None)\n<tuple_iterator...>\n>>> always_iterable(range(10))\n<range_iterator...>\n>>> def _test_func(): yield \"I'm iterable\"\n>>> print(next(always_iterable(_test_func())))\nI'm iterable\n\nAlthough mappings are iterable, treat each like a singleton, as\nit's more like an object than a sequence.\n\n>>> next(always_iterable(dict(a=1)))\n{'a': 1}", "id": "f11047:m22"}
{"signature": "def every_other(iterable):", "body": "items = iter(iterable)<EOL>while True:<EOL><INDENT>try:<EOL><INDENT>yield next(items)<EOL>next(items)<EOL><DEDENT>except StopIteration:<EOL><INDENT>return<EOL><DEDENT><DEDENT>", "docstring": "Yield every other item from the iterable\n\n>>> ' '.join(every_other('abcdefg'))\n'a c e g'", "id": "f11047:m9"}
{"signature": "def nwise(iter, n):", "body": "iterset = [iter]<EOL>while len(iterset) < n:<EOL><INDENT>iterset[-<NUM_LIT:1>:] = itertools.tee(iterset[-<NUM_LIT:1>])<EOL>next(iterset[-<NUM_LIT:1>], None)<EOL><DEDENT>return six.moves.zip(*iterset)<EOL>", "docstring": "Like pairwise, except returns n-tuples of adjacent items.\ns -> (s0,s1,...,sn), (s1,s2,...,s(n+1)), ...", "id": "f11047:m17"}
{"signature": "def last(iterable):", "body": "for item in iterable:<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>return item<EOL><DEDENT>except NameError:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Return the last item from the iterable, discarding the rest.\n\n>>> last(range(20))\n19\n>>> last([])\nTraceback (most recent call last):\n...\nValueError: Iterable contains no items", "id": "f11047:m15"}
{"signature": "def duplicates(*iterables, **kwargs):", "body": "key = kwargs.pop('<STR_LIT:key>', lambda x: x)<EOL>assert not kwargs<EOL>zipped = more_itertools.collate(*iterables, key=key)<EOL>grouped = itertools.groupby(zipped, key=key)<EOL>groups = (<EOL>tuple(g)<EOL>for k, g in grouped<EOL>)<EOL>def has_dupes(group):<EOL><INDENT>return len(group) > <NUM_LIT:1><EOL><DEDENT>return filter(has_dupes, groups)<EOL>", "docstring": "Yield duplicate items from any number of sorted iterables of items\n\n>>> items_a = [1, 2, 3]\n>>> items_b = [0, 3, 4, 5, 6]\n>>> list(duplicates(items_a, items_b))\n[(3, 3)]\n\nIt won't behave as you expect if the iterables aren't ordered\n\n>>> items_b.append(1)\n>>> list(duplicates(items_a, items_b))\n[(3, 3)]\n>>> list(duplicates(items_a, sorted(items_b)))\n[(1, 1), (3, 3)]\n\nThis function is most interesting when it's operating on a key\nof more complex objects.\n\n>>> items_a = [dict(email='joe@example.com', id=1)]\n>>> items_b = [dict(email='joe@example.com', id=2), dict(email='other')]\n>>> dupe, = duplicates(items_a, items_b, key=operator.itemgetter('email'))\n>>> dupe[0]['email'] == dupe[1]['email'] == 'joe@example.com'\nTrue\n>>> dupe[0]['id']\n1\n>>> dupe[1]['id']\n2", "id": "f11047:m28"}
{"signature": "def skip_first(iterable):", "body": "return itertools.islice(iterable, <NUM_LIT:1>, None)<EOL>", "docstring": "Skip the first element of an iterable\n\n>>> tuple(skip_first(range(10)))\n(1, 2, 3, 4, 5, 6, 7, 8, 9)", "id": "f11047:m11"}
{"signature": "def _mutable_iter(dict):", "body": "while dict:<EOL><INDENT>prev_key = next(iter(dict))<EOL>yield prev_key, dict.pop(prev_key)<EOL><DEDENT>", "docstring": "Iterate over items in the dict, yielding the first one, but allowing\nit to be mutated during the process.\n>>> d = dict(a=1)\n>>> it = _mutable_iter(d)\n>>> next(it)\n('a', 1)\n>>> d\n{}\n>>> d.update(b=2)\n>>> list(it)\n[('b', 2)]", "id": "f11047:m31"}
{"signature": "def remove_duplicates(iterable, key=None):", "body": "return itertools.chain.from_iterable(six.moves.map(<EOL>every_other, six.moves.map(<EOL>operator.itemgetter(<NUM_LIT:1>),<EOL>itertools.groupby(iterable, key)<EOL>)))<EOL>", "docstring": "Given an iterable with items that may come in as sequential duplicates,\nremove those duplicates.\n\nUnlike unique_justseen, this function does not remove triplicates.\n\n>>> ' '.join(remove_duplicates('abcaabbccaaabbbcccbcbc'))\n'a b c a b c a a b b c c b c b c'\n>>> ' '.join(remove_duplicates('aaaabbbbb'))\n'a a b b b'", "id": "f11047:m10"}
{"signature": "def reverse_lists(lists):", "body": "return list(map(list, map(reversed, lists)))<EOL>", "docstring": ">>> reverse_lists([[1,2,3], [4,5,6]])\n[[3, 2, 1], [6, 5, 4]]", "id": "f11047:m21"}
{"signature": "def configure_uploads(app, upload_sets):", "body": "if isinstance(upload_sets, UploadSet):<EOL><INDENT>upload_sets = (upload_sets,)<EOL><DEDENT>if not hasattr(app, '<STR_LIT>'):<EOL><INDENT>app.upload_set_config = {}<EOL><DEDENT>set_config = app.upload_set_config<EOL>defaults = dict(dest=app.config.get('<STR_LIT>'),<EOL>url=app.config.get('<STR_LIT>'))<EOL>for uset in upload_sets:<EOL><INDENT>config = config_for_set(uset, app, defaults)<EOL>set_config[uset.name] = config<EOL><DEDENT>should_serve = any(s.base_url is None for s in set_config.values())<EOL>if '<STR_LIT>' not in app.blueprints and should_serve:<EOL><INDENT>app.register_blueprint(uploads_mod)<EOL><DEDENT>", "docstring": "Call this after the app has been configured. It will go through all the\nupload sets, get their configuration, and store the configuration on the\napp. It will also register the uploads module if it hasn't been set. This\ncan be called multiple times with different upload sets.\n\n.. versionchanged:: 0.1.3\n   The uploads module/blueprint will only be registered if it is needed\n   to serve the upload sets.\n\n:param app: The `~flask.Flask` instance to get the configuration from.\n:param upload_sets: The `UploadSet` instances to configure.", "id": "f11049:m6"}
{"signature": "def save(self, storage, folder=None, name=None):", "body": "if not isinstance(storage, FileStorage):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if folder is None and name is not None and \"<STR_LIT:/>\" in name:<EOL><INDENT>folder, name = os.path.split(name)<EOL><DEDENT>basename = self.get_basename(storage.filename)<EOL>if name:<EOL><INDENT>if name.endswith('<STR_LIT:.>'):<EOL><INDENT>basename = name + extension(basename)<EOL><DEDENT>else:<EOL><INDENT>basename = name<EOL><DEDENT><DEDENT>if not self.file_allowed(storage, basename):<EOL><INDENT>raise UploadNotAllowed()<EOL><DEDENT>if folder:<EOL><INDENT>target_folder = os.path.join(self.config.destination, folder)<EOL><DEDENT>else:<EOL><INDENT>target_folder = self.config.destination<EOL><DEDENT>if not os.path.exists(target_folder):<EOL><INDENT>os.makedirs(target_folder)<EOL><DEDENT>if os.path.exists(os.path.join(target_folder, basename)):<EOL><INDENT>basename = self.resolve_conflict(target_folder, basename)<EOL><DEDENT>target = os.path.join(target_folder, basename)<EOL>storage.save(target)<EOL>if folder:<EOL><INDENT>return posixpath.join(folder, basename)<EOL><DEDENT>else:<EOL><INDENT>return basename<EOL><DEDENT>", "docstring": "This saves a `werkzeug.FileStorage` into this upload set. If the\nupload is not allowed, an `UploadNotAllowed` error will be raised.\nOtherwise, the file will be saved and its name (including the folder)\nwill be returned.\n\n:param storage: The uploaded file to save.\n:param folder: The subfolder within the upload set to save to.\n:param name: The name to save the file as. If it ends with a dot, the\n             file's extension will be appended to the end. (If you\n             are using `name`, you can include the folder in the\n             `name` instead of explicitly using `folder`, i.e.\n             ``uset.save(file, name=\"someguy/photo_123.\")``", "id": "f11049:c4:m7"}
{"signature": "def path(self, filename, folder=None):", "body": "if folder is not None:<EOL><INDENT>target_folder = os.path.join(self.config.destination, folder)<EOL><DEDENT>else:<EOL><INDENT>target_folder = self.config.destination<EOL><DEDENT>return os.path.join(target_folder, filename)<EOL>", "docstring": "This returns the absolute path of a file uploaded to this set. It\ndoesn't actually check whether said file exists.\n\n:param filename: The filename to return the path for.\n:param folder: The subfolder within the upload set previously used\n               to save to.", "id": "f11049:c4:m3"}
{"signature": "def file_allowed(self, storage, basename):", "body": "return self.extension_allowed(extension(basename))<EOL>", "docstring": "This tells whether a file is allowed. It should return `True` if the\ngiven `werkzeug.FileStorage` object can be saved with the given\nbasename, and `False` if it can't. The default implementation just\nchecks the extension, so you can override this if you want.\n\n:param storage: The `werkzeug.FileStorage` to check.\n:param basename: The basename it will be saved under.", "id": "f11049:c4:m4"}
{"signature": "def patch_request_class(app, size=<NUM_LIT:64> * <NUM_LIT> * <NUM_LIT>):", "body": "if size is None:<EOL><INDENT>if isinstance(app.request_class.__dict__['<STR_LIT>'],<EOL>property):<EOL><INDENT>return<EOL><DEDENT>size = app.config.get('<STR_LIT>')<EOL><DEDENT>reqclass = app.request_class<EOL>patched = type(reqclass.__name__, (reqclass,),<EOL>{'<STR_LIT>': size})<EOL>app.request_class = patched<EOL>", "docstring": "By default, Flask will accept uploads to an arbitrary size. While Werkzeug\nswitches uploads from memory to a temporary file when they hit 500 KiB,\nit's still possible for someone to overload your disk space with a\ngigantic file.\n\nThis patches the app's request class's\n`~werkzeug.BaseRequest.max_content_length` attribute so that any upload\nlarger than the given size is rejected with an HTTP error.\n\n.. note::\n\n   In Flask 0.6, you can do this by setting the `MAX_CONTENT_LENGTH`\n   setting, without patching the request class. To emulate this behavior,\n   you can pass `None` as the size (you must pass it explicitly). That is\n   the best way to call this function, as it won't break the Flask 0.6\n   functionality if it exists.\n\n.. versionchanged:: 0.1.1\n\n:param app: The app to patch the request class of.\n:param size: The maximum size to accept, in bytes. The default is 64 MiB.\n             If it is `None`, the app's `MAX_CONTENT_LENGTH` configuration\n             setting will be used to patch.", "id": "f11049:m4"}
{"signature": "def extension_allowed(self, ext):", "body": "return ((ext in self.config.allow) or<EOL>(ext in self.extensions and ext not in self.config.deny))<EOL>", "docstring": "This determines whether a specific extension is allowed. It is called\nby `file_allowed`, so if you override that but still want to check\nextensions, call back into this.\n\n:param ext: The extension to check, without the dot.", "id": "f11049:c4:m5"}
{"signature": "def update_path(self, board, color, path):", "body": "wins = board.score(BLACK) >= board.score(WHITE)<EOL>for node in path:<EOL><INDENT>if color == BLACK:<EOL><INDENT>color = WHITE<EOL><DEDENT>else:<EOL><INDENT>color = BLACK<EOL><DEDENT>if wins == (color == BLACK):<EOL><INDENT>node.wins += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>node.losses += <NUM_LIT:1><EOL><DEDENT>if node.parent:<EOL><INDENT>node.parent.bestchild = node.parent.best_child()<EOL><DEDENT><DEDENT>", "docstring": "update win/loss count along path", "id": "f11082:c4:m4"}
{"signature": "def select(self, board):", "body": "if self.unexplored:<EOL><INDENT>i = random.randrange(len(self.unexplored))<EOL>pos = self.unexplored[i]<EOL>self.unexplored[i] = self.unexplored[len(self.unexplored) - <NUM_LIT:1>]<EOL>self.unexplored.pop()<EOL>return pos<EOL><DEDENT>elif self.bestchild:<EOL><INDENT>return self.bestchild.pos<EOL><DEDENT>else:<EOL><INDENT>return PASS<EOL><DEDENT>", "docstring": "select move; unexplored children first, then according to uct value", "id": "f11082:c4:m2"}
{"signature": "def tdist95conf_level(df):", "body": "df = int(round(df))<EOL>highest_table_df = len(_T_DIST_95_CONF_LEVELS)<EOL>if df >= <NUM_LIT:200>:<EOL><INDENT>return <NUM_LIT><EOL><DEDENT>if df >= <NUM_LIT:100>:<EOL><INDENT>return <NUM_LIT><EOL><DEDENT>if df >= <NUM_LIT>:<EOL><INDENT>return <NUM_LIT><EOL><DEDENT>if df >= <NUM_LIT>:<EOL><INDENT>return <NUM_LIT><EOL><DEDENT>if df >= <NUM_LIT:50>:<EOL><INDENT>return <NUM_LIT><EOL><DEDENT>if df >= <NUM_LIT>:<EOL><INDENT>return <NUM_LIT><EOL><DEDENT>if df >= highest_table_df:<EOL><INDENT>return _T_DIST_95_CONF_LEVELS[highest_table_df - <NUM_LIT:1>]<EOL><DEDENT>return _T_DIST_95_CONF_LEVELS[df]<EOL>", "docstring": "Approximate the 95% confidence interval for Student's T distribution.\n\n    Given the degrees of freedom, returns an approximation to the 95%\n    confidence interval for the Student's T distribution.\n\n    Args:\n        df: An integer, the number of degrees of freedom.\n\n    Returns:\n        A float.", "id": "f11112:m1"}
{"signature": "def is_significant(sample1, sample2):", "body": "deg_freedom = len(sample1) + len(sample2) - <NUM_LIT:2><EOL>critical_value = tdist95conf_level(deg_freedom)<EOL>t_score = tscore(sample1, sample2)<EOL>return (abs(t_score) >= critical_value, t_score)<EOL>", "docstring": "Determine whether two samples differ significantly.\n\n    This uses a Student's two-sample, two-tailed t-test with alpha=0.95.\n\n    Args:\n        sample1: one sample.\n        sample2: the other sample.\n\n    Returns:\n        (significant, t_score) where significant is a bool indicating whether\n        the two samples differ significantly; t_score is the score from the\n        two-sample T test.", "id": "f11112:m4"}
{"signature": "def install_from_zip(url):", "body": "fname = '<STR_LIT>'<EOL>downlad_file(url, fname)<EOL>unzip_file(fname)<EOL>print(\"<STR_LIT>\".format(fname))<EOL>os.unlink(fname)<EOL>", "docstring": "Download and unzip from url.", "id": "f11117:m2"}
{"signature": "@staticmethod<EOL><INDENT>def blank_canvas(width, height):<DEDENT>", "body": "canvas = np.zeros((height, width, <NUM_LIT:3>), dtype=np.uint8)<EOL>return canvas.view(Canvas)<EOL>", "docstring": "Return a blank canvas to annotate.\n\n        :param width: xdim (int)\n        :param height: ydim (int)\n        :returns: :class:`jicbioimage.illustrate.Canvas`", "id": "f11120:c0:m0"}
{"signature": "@staticmethod<EOL><INDENT>def from_grayscale(im, channels_on=(True, True, True)):<DEDENT>", "body": "xdim, ydim = im.shape<EOL>canvas = np.zeros((xdim, ydim, <NUM_LIT:3>), dtype=np.uint8)<EOL>for i, include in enumerate(channels_on):<EOL><INDENT>if include:<EOL><INDENT>canvas[:, :, i] = im<EOL><DEDENT><DEDENT>return canvas.view(AnnotatedImage)<EOL>", "docstring": "Return a canvas from a grayscale image.\n\n        :param im: single channel image\n        :channels_on: channels to populate with input image\n        :returns: :class:`jicbioimage.illustrate.Canvas`", "id": "f11120:c1:m0"}
{"signature": "def mask_region(self, region, color=(<NUM_LIT:0>, <NUM_LIT:255>, <NUM_LIT:0>)):", "body": "self[region] = color<EOL>", "docstring": "Mask a region with a color.\n\n        :param region: :class:`jicbioimage.core.region.Region`\n        :param color: RGB tuple", "id": "f11120:c0:m3"}
{"signature": "def intersection(self, coordinates, objects=False):", "body": "if objects:<EOL><INDENT>return self._intersection_obj(coordinates, objects)<EOL><DEDENT>p_mins, p_maxs = self.get_coordinate_pointers(coordinates)<EOL>p_num_results = ctypes.c_uint64(<NUM_LIT:0>)<EOL>it = ctypes.pointer(ctypes.c_int64())<EOL>core.rt.Index_Intersects_id(self.handle,<EOL>p_mins,<EOL>p_maxs,<EOL>self.properties.dimension,<EOL>ctypes.byref(it),<EOL>ctypes.byref(p_num_results))<EOL>return self._get_ids(it, p_num_results.value)<EOL>", "docstring": "Return ids or objects in the index that intersect the given\n        coordinates.\n\n        :param coordinates: sequence or array\n            This may be an object that satisfies the numpy array\n            protocol, providing the index's dimension * 2 coordinate\n            pairs representing the `mink` and `maxk` coordinates in\n            each dimension defining the bounds of the query window.\n\n        :param objects: True or False or 'raw'\n            If True, the intersection method will return index objects that\n            were pickled when they were stored with each index entry, as well\n            as the id and bounds of the index entries. If 'raw', the objects\n            will be returned without the :class:`rtree.index.Item` wrapper.\n\n        The following example queries the index for any objects any objects\n        that were stored in the index intersect the bounds given in the\n        coordinates::\n\n            >>> from rtree import index\n            >>> idx = index.Index()\n            >>> idx.insert(4321,\n            ...            (34.3776829412, 26.7375853734, 49.3776829412,\n            ...             41.7375853734),\n            ...            obj=42)\n\n            >>> hits = list(idx.intersection((0, 0, 60, 60), objects=True))\n            >>> [(item.object, item.bbox) for item in hits if item.id == 4321]\n            ... # doctest: +NORMALIZE_WHITESPACE +ELLIPSIS\n            [(42, [34.37768294..., 26.73758537..., 49.37768294...,\n                   41.73758537...])]\n\n        If the :class:`rtree.index.Item` wrapper is not used, it is faster to\n        request the 'raw' objects::\n\n            >>> list(idx.intersection((0, 0, 60, 60), objects=\"raw\"))\n            [42]", "id": "f11126:c0:m10"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "if args:<EOL><INDENT>if isinstance(args[<NUM_LIT:0>], rtree.index.string_types)or isinstance(args[<NUM_LIT:0>], bytes)or isinstance(args[<NUM_LIT:0>], rtree.index.ICustomStorage):<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>% self.__class__)<EOL><DEDENT><DEDENT>self._objects = {}<EOL>return super(RtreeContainer, self).__init__(*args, **kwargs)<EOL>", "docstring": "Creates a new index\n\n        :param stream:\n            If the first argument in the constructor is not of type basestring,\n            it is assumed to be an iterable stream of data that will raise a\n            StopIteration.  It must be in the form defined by the\n            :attr:`interleaved` attribute of the index. The following example\n            would assume :attr:`interleaved` is False::\n\n            (obj, (minx, maxx, miny, maxy, minz, maxz, ..., ..., mink, maxk))\n\n        :param interleaved: True or False, defaults to True.\n            This parameter determines the coordinate order for all methods that\n            take in coordinates.\n\n        :param properties: An :class:`index.Property` object\n            This object sets both the creation and instantiation properties\n            for the object and they are passed down into libspatialindex.\n            A few properties are curried from instantiation parameters\n            for you like ``pagesize`` to ensure compatibility with previous\n            versions of the library.  All other properties must be set on the\n            object.\n\n        .. warning::\n            The coordinate ordering for all functions are sensitive the\n            index's :attr:`interleaved` data member.  If :attr:`interleaved`\n            is False, the coordinates must be in the form\n            [xmin, xmax, ymin, ymax, ..., ..., kmin, kmax]. If\n            :attr:`interleaved` is True, the coordinates must be in the form\n            [xmin, ymin, ..., kmin, xmax, ymax, ..., kmax].\n\n        A basic example\n        ::\n\n            >>> from rtree import index\n            >>> p = index.Property()\n\n            >>> idx = index.RtreeContainer(properties=p)\n            >>> idx  # doctest: +ELLIPSIS\n            <rtree.index.RtreeContainer object at 0x...>\n\n        Insert an item into the index::\n\n            >>> idx.insert(object(),\n            ...            (34.3776829412, 26.7375853734, 49.3776829412,\n            ...             41.7375853734))\n\n        Query::\n\n            >>> hits = idx.intersection((0, 0, 60, 60), bbox=True)\n            >>> for obj in hits:\n            ...     obj.object\n            ...     obj.bbox  # doctest: +ELLIPSIS\n            <object object at 0x...>\n            [34.37768294..., 26.73758537..., 49.37768294..., 41.73758537...]", "id": "f11126:c12:m0"}
{"signature": "def deleteByteArray(self, context, page, returnError):", "body": "returnError.contents.value = self.IllegalStateError<EOL>raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "please override", "id": "f11126:c10:m5"}
{"signature": "def __init__(self, loads, handle, owned=False):", "body": "if handle:<EOL><INDENT>self.handle = handle<EOL><DEDENT>self.owned = owned<EOL>self.id = core.rt.IndexItem_GetID(self.handle)<EOL>self.object = None<EOL>self.object = self.get_object(loads)<EOL>self.bounds = _get_bounds(<EOL>self.handle, core.rt.IndexItem_GetBounds, False)<EOL>", "docstring": "There should be no reason to instantiate these yourself. Items are\n        created automatically when you call\n        :meth:`rtree.index.Index.intersection` (or other index querying\n        methods) with objects=True given the parameters of the function.", "id": "f11126:c1:m0"}
{"signature": "def delete(self, id, coordinates):", "body": "p_mins, p_maxs = self.get_coordinate_pointers(coordinates)<EOL>core.rt.Index_DeleteData(<EOL>self.handle, id, p_mins, p_maxs, self.properties.dimension)<EOL>", "docstring": "Deletes items from the index with the given ``'id'`` within the\n        specified coordinates.\n\n        :param id: long integer\n            A long integer that is the identifier for this index entry.  IDs\n            need not be unique to be inserted into the index, and it is up\n            to the user to ensure they are unique if this is a requirement.\n\n        :param coordinates: sequence or array\n            Dimension * 2 coordinate pairs, representing the min\n            and max coordinates in each dimension of the item to be\n            deleted from the index. Their ordering will depend on the\n            index's :attr:`interleaved` data member.\n            These are not the coordinates of a space containing the\n            item, but those of the item itself. Together with the\n            id parameter, they determine which item will be deleted.\n            This may be an object that satisfies the numpy array protocol.\n\n        Example::\n\n            >>> from rtree import index\n            >>> idx = index.Index()\n            >>> idx.delete(4321,\n            ...            (34.3776829412, 26.7375853734, 49.3776829412,\n            ...             41.7375853734))", "id": "f11126:c0:m17"}
{"signature": "def loadByteArray(self, page, returnError):", "body": "returnError.contents.value = self.IllegalStateError<EOL>raise NotImplementedError(\"<STR_LIT>\")<EOL>return '<STR_LIT>'<EOL>", "docstring": "Must be overridden. Must return a string with the loaded data.", "id": "f11126:c11:m10"}
{"signature": "def destroy(self, context, returnError):", "body": "returnError.contents.value = self.IllegalStateError<EOL>raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "please override", "id": "f11126:c10:m2"}
{"signature": "def destroy(self, returnError):", "body": "returnError.contents.value = self.IllegalStateError<EOL>raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "Must be overridden. No return value.", "id": "f11126:c11:m8"}
{"signature": "def deleteByteArray(self, page, returnError):", "body": "returnError.contents.value = self.IllegalStateError<EOL>raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "please override", "id": "f11126:c11:m12"}
{"signature": "def check_value_free(result, func, cargs):", "body": "count = rt.Error_GetErrorCount()<EOL>if count != <NUM_LIT:0>:<EOL><INDENT>s = rt.Error_GetLastErrorMsg().decode()<EOL>msg = '<STR_LIT>' % (func.__name__, s)<EOL>rt.Error_Reset()<EOL>raise RTreeError(msg)<EOL><DEDENT>return result<EOL>", "docstring": "Error checking proper value returns", "id": "f11128:m4"}
{"signature": "def check_return(result, func, cargs):", "body": "if result != <NUM_LIT:0>:<EOL><INDENT>s = rt.Error_GetLastErrorMsg().decode()<EOL>msg = '<STR_LIT>' %(func.__name__, s)<EOL>rt.Error_Reset()<EOL>raise RTreeError(msg)<EOL><DEDENT>return True<EOL>", "docstring": "Error checking for Error calls", "id": "f11128:m0"}
{"signature": "def check_value(result, func, cargs):", "body": "count = rt.Error_GetErrorCount()<EOL>if count != <NUM_LIT:0>:<EOL><INDENT>s = rt.Error_GetLastErrorMsg().decode()<EOL>msg = '<STR_LIT>' % (func.__name__, s)<EOL>rt.Error_Reset()<EOL>raise RTreeError(msg)<EOL><DEDENT>return result<EOL>", "docstring": "Error checking proper value returns", "id": "f11128:m3"}
{"signature": "def ask_question(self, description=None):", "body": "failure_description = None<EOL>if self.interactive:<EOL><INDENT>failure_description = _ask_user_to_verify(description)<EOL>if failure_description is not None:<EOL><INDENT>self.fail(failure_description)<EOL><DEDENT><DEDENT>", "docstring": "Ask a question to verify the current test result. Uses the console or an external gui\n        as no window is available.", "id": "f11146:c0:m6"}
{"signature": "def _take_screenshot(self, window=None):", "body": "screenshot_name = self._get_next_screenshot_name()<EOL>screenshot_file_name = self._get_screenshot_session_file_name(screenshot_name)<EOL>if window is not None:<EOL><INDENT>window.switch_to()<EOL><DEDENT>get_buffer_manager().get_color_buffer().image_data.save(screenshot_file_name)<EOL>self.screenshots.append(screenshot_name)<EOL>self._schedule_commit()<EOL>return screenshot_name<EOL>", "docstring": "Take a screenshot to allow visual verification.", "id": "f11146:c0:m7"}
{"signature": "def on_menu_exit(self,new):", "body": "super(WorldViewMouseRotatable,self).on_menu_exit(new)<EOL>self.world.peng.window.toggle_exclusivity(False)<EOL>", "docstring": "Fake event handler, same as :py:meth:`WorldView.on_menu_exit()` but force-disables mouse exclusivity.", "id": "f11150:c3:m1"}
{"signature": "def render3d(self,view=None):", "body": "for actor in self.actors.values():<EOL><INDENT>actor.render(view)<EOL><DEDENT>", "docstring": "Renders the world in 3d-mode.\n\nIf you want to render custom terrain, you may override this method. Be careful that you still call the original method or else actors may not be rendered.", "id": "f11150:c0:m5"}
{"signature": "def on_menu_enter(self,old):", "body": "super(WorldViewMouseRotatable,self).on_menu_enter(old)<EOL>self.world.peng.window.toggle_exclusivity(True)<EOL>", "docstring": "Fake event handler, same as :py:meth:`WorldView.on_menu_enter()` but forces mouse exclusivity.", "id": "f11150:c3:m0"}
{"signature": "def redraw(self,obj):", "body": "self.ensureModelData(obj)<EOL>data = obj._modeldata<EOL>vlists = data[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>for name,region in self.modeldata[\"<STR_LIT>\"].items():<EOL><INDENT>vlists[name].vertices = region.getVertices(data)<EOL>if region.enable_tex:<EOL><INDENT>vlists[name].tex_coords = region.getTexCoords(data)<EOL><DEDENT><DEDENT>", "docstring": "Redraws the model of the given object.\n\nNote that currently this method probably won't change any data since all movement and animation is done through pyglet groups.", "id": "f11151:c7:m4"}
{"signature": "def setAnimation(self,obj,animation,transition=None,force=False):", "body": "self.ensureModelData(obj)<EOL>data = obj._modeldata<EOL>if animation not in self.modeldata[\"<STR_LIT>\"]:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"%(animation,self.modelname))<EOL><DEDENT>if data.get(\"<STR_LIT>\",{}).get(\"<STR_LIT>\",None)==animation and not force:<EOL><INDENT>return <EOL><DEDENT>anim = self.modeldata[\"<STR_LIT>\"][animation]<EOL>if transition is None:<EOL><INDENT>transition = anim.default_jt<EOL><DEDENT>anim.startAnimation(data,transition)<EOL>if \"<STR_LIT>\" not in data:<EOL><INDENT>data[\"<STR_LIT>\"]={}<EOL><DEDENT>adata = data[\"<STR_LIT>\"]<EOL>adata[\"<STR_LIT>\"]=animation<EOL>if \"<STR_LIT>\" in adata:<EOL><INDENT>pyglet.clock.unschedule(adata[\"<STR_LIT>\"])<EOL><DEDENT>def schedfunc(*args):<EOL><INDENT>anim.tickEntity(data)<EOL><DEDENT>pyglet.clock.schedule_interval(schedfunc,<NUM_LIT:1.>/(anim.kps if anim.atype==\"<STR_LIT>\" else <NUM_LIT>))<EOL>adata[\"<STR_LIT>\"] = schedfunc<EOL>", "docstring": "Sets the animation to be used by the object.\n\nSee :py:meth:`Actor.setAnimation()` for more information.", "id": "f11151:c7:m7"}
{"signature": "def setRotate(self,data):", "body": "self.parent.setRotate(data)<EOL>glPushMatrix()<EOL>x,y = self.getRot(data)<EOL>pivot = self.getPivotPoint(data)<EOL>px,py,pz = pivot<EOL>normx = [<NUM_LIT:0>,<NUM_LIT:1>,<NUM_LIT:0>] <EOL>normy = [<NUM_LIT:0>,<NUM_LIT:0>,<NUM_LIT:1>]<EOL>glTranslatef(px,py,pz)<EOL>glRotatef(x-self.start_rot[<NUM_LIT:0>], normx[<NUM_LIT:0>],normx[<NUM_LIT:1>],normx[<NUM_LIT:2>])<EOL>glRotatef(y-self.start_rot[<NUM_LIT:1>], normy[<NUM_LIT:0>],normy[<NUM_LIT:1>],normy[<NUM_LIT:2>])<EOL>glTranslatef(-px,-py,-pz)<EOL>", "docstring": "Sets the OpenGL state required for proper drawing of the model.\n\nMostly rotates and translates the camera.\n\nIt is important to call :py:meth:`unsetRotate()` after calling this method to properly unset state and avoid OpenGL errors.", "id": "f11151:c1:m7"}
{"signature": "def getGeometryType(self,data):", "body": "return self.geometry_type<EOL>", "docstring": "Returns the OpenGL constant representing the type of primitives used by this region.\n\nMay be one of :py:data:`GL_QUADS`\\ , :py:data:`GL_TRIANGLES`\\ , :py:data:`GL_LINES` or :py:data:`GL_POINTS`\\ .", "id": "f11151:c3:m2"}
{"signature": "@property<EOL><INDENT>def texdata(self):<DEDENT>", "body": "return self.rsrcMgr.getTex(self,texname,self.texcat)<EOL>", "docstring": "Read-only property equivalent to a 3-tuple containing :py:attr:`target`\\ , :py:attr:`id` and :py:attr:`tex_coords`\\ .\n\nShould be faster than getting each value directly. Useful if all of these values are needed.", "id": "f11151:c0:m4"}
{"signature": "@property<EOL><INDENT>def pos(self):<DEDENT>", "body": "return self._pos<EOL>", "docstring": "Property for accessing the position of the camera.\n\nThis property uses a setter to call the :py:meth:`on_move()` method if set and the new location is not equal to the old location.", "id": "f11152:c0:m4"}
{"signature": "@property<EOL><INDENT>def rot(self):<DEDENT>", "body": "return self.actor.rot<EOL>", "docstring": "This property always equals the value of ``self.actor.rot``\\ .\n\nThis property may also be written to.", "id": "f11152:c1:m3"}
{"signature": "def run(self,evloop=None):", "body": "self.setup()<EOL>if evloop is not None:<EOL><INDENT>pyglet.app.event_loop = evloop<EOL><DEDENT>pyglet.app.run() <EOL>", "docstring": "Runs the application in the current thread.\n\nThis method should not be called directly, especially when using multiple windows, use :py:meth:`Peng.run()` instead.\n\nNote that this method is blocking as rendering needs to happen in the main thread.\nIt is thus recommendable to run your game logic in another thread that should be started before calling this method.\n\n``evloop`` may optionally be a subclass of :py:class:`pyglet.app.base.EventLoop` to replace the default event loop.", "id": "f11153:c0:m4"}
{"signature": "def addCategory(self,name):", "body": "self.categories[name]={}<EOL>self.categoriesTexCache[name]={}<EOL>self.categoriesTexBin[name]=pyglet.image.atlas.TextureBin(self.texsize,self.texsize)<EOL>self.peng.sendEvent(\"<STR_LIT>\",{\"<STR_LIT>\":self.peng,\"<STR_LIT>\":name})<EOL>", "docstring": "Adds a new texture category with the given name.\n\nIf the category already exists, it will be overridden.", "id": "f11155:c0:m3"}
{"signature": "def resourceNameToPath(self,name,ext=\"<STR_LIT>\"):", "body": "nsplit = name.split(\"<STR_LIT::>\")[<NUM_LIT:1>].split(\"<STR_LIT:.>\")<EOL>return os.path.join(self.basepath,\"<STR_LIT>\",name.split(\"<STR_LIT::>\")[<NUM_LIT:0>],*nsplit)+ext<EOL>", "docstring": "Converts the given resource name to a file path.\n\nA resource path is of the format ``<app>:<cat1>.<cat2>.<name>`` where cat1 and cat2 can be repeated as often as desired.\n\n``ext`` is the file extension to use, e.g. ``.png`` or similar.\n\nAs an example, the resource name ``peng3d:some.category.foo`` with the extension ``.png`` results in the path ``<basepath>/assets/peng3d/some/category/foo.png``\\ .\n\nThis resource naming scheme is used by most other methods of this class.\n\nNote that it is currently not possible to define multiple base paths to search through.", "id": "f11155:c0:m1"}
{"signature": "def resourceExists(self,name,ext=\"<STR_LIT>\"):", "body": "return os.path.exists(self.resourceNameToPath(name,ext))<EOL>", "docstring": "Returns whether or not the resource with the given name and extension exists.\n\nThis must not mean that the resource is meaningful, it simply signals that the file exists.", "id": "f11155:c0:m2"}
{"signature": "def getTex(self,name,category):", "body": "if category not in self.categoriesTexCache:<EOL><INDENT>return self.getMissingTex(category)<EOL><DEDENT>if name not in self.categoriesTexCache[category]:<EOL><INDENT>self.loadTex(name,category)<EOL><DEDENT>return self.categoriesTexCache[category][name]<EOL>", "docstring": "Gets the texture associated with the given name and category.\n\n``category`` must have been created using :py:meth:`addCategory()` before.\n\nIf it was loaded previously, a cached version will be returned.\nIf it was not loaded, it will be loaded and inserted into the cache.\n\nSee :py:meth:`loadTex()` for more information.", "id": "f11155:c0:m4"}
{"signature": "def on_enter(self,old):", "body": "for layer in self.layers:<EOL><INDENT>layer.on_menu_enter(old)<EOL><DEDENT>", "docstring": "Same as :py:meth:`BasicMenu.on_enter()`\\ , but also calls :py:meth:`Layer.on_menu_enter()` on every layer.", "id": "f11156:c1:m3"}
{"signature": "def draw(self):", "body": "pass<EOL>", "docstring": "This method is called if it is time to render the menu.\n\nOverride this method in subclasses to customize behavior and actually draw stuff.", "id": "f11156:c0:m1"}
{"signature": "def sendEvent(self,event,data=None):", "body": "if self.cfg[\"<STR_LIT>\"]!=\"<STR_LIT>\" and event not in self.event_list:<EOL><INDENT>self.event_list.add(event)<EOL><DEDENT>if event not in self.eventHandlers:<EOL><INDENT>if event not in self.events_ignored or self.events_ignored[event]<=self.cfg[\"<STR_LIT>\"]: <EOL><INDENT>self.events_ignored[event] = self.events_ignored.get(event,<NUM_LIT:0>)+<NUM_LIT:1><EOL><DEDENT>return<EOL><DEDENT>for handler in self.eventHandlers[event]:<EOL><INDENT>f = handler[<NUM_LIT:0>]<EOL>try:<EOL><INDENT>f(event,data)<EOL><DEDENT>except Exception:<EOL><INDENT>if not handler[<NUM_LIT:1>]:<EOL><INDENT>raise<EOL><DEDENT>else:<EOL><INDENT>if self.cfg[\"<STR_LIT>\"]:<EOL><INDENT>self.delEventListener(event,f)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Sends an event with attached data.\n\n``event`` should be a string of format ``<namespace>:<category1>.<subcategory2>.<name>``\\ .\nThere may be an arbitrary amount of subcategories. Also note that this\nformat is not strictly enforced, but rather recommended by convention.\n\n``data`` may be any Python Object, but it usually is a dictionary containing relevant parameters.\nFor example, most built-in events use a dictionary containing at least the ``peng`` key set to an instance of this class.\n\nIf there are no handlers for the event, a corresponding message will be printed to the log file.\nTo prevent spam, the maximum amount of ignored messages can be configured via :confval:`events.maxignore` and defaults to 3.\n\nIf the config value :confval:`debug.events.dumpfile` is a file path, the event type will be added to an internal list and be saved to the given file during program exit.", "id": "f11157:c0:m5"}
{"signature": "def addEventListener(self,event,func,raiseErrors=False):", "body": "if not isinstance(event,str):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if event not in self.eventHandlers:<EOL><INDENT>self.eventHandlers[event]=[]<EOL><DEDENT>self.eventHandlers[event].append([func,raiseErrors])<EOL>", "docstring": "Adds a handler to the given event.\n\nA event may have an arbitrary amount of handlers, though assigning too\nmany handlers may slow down event processing.\n\nFor the format of ``event``\\ , see :py:meth:`sendEvent()`\\ .\n\n``func`` is the handler which will be executed with two arguments, ``event_type`` and ``data``\\ , as supplied to :py:meth:`sendEvent()`\\ .\n\nIf ``raiseErrors`` is True, exceptions caused by the handler will be re-raised.\nDefaults to ``False``\\ .", "id": "f11157:c0:m6"}
{"signature": "def points2htmlfontsize(points):", "body": "<EOL>if points<=<NUM_LIT:8>:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>elif points<=<NUM_LIT:10>:<EOL><INDENT>return <NUM_LIT:2><EOL><DEDENT>elif points<=<NUM_LIT:12>:<EOL><INDENT>return <NUM_LIT:3><EOL><DEDENT>elif points<=<NUM_LIT>:<EOL><INDENT>return <NUM_LIT:4><EOL><DEDENT>elif points<=<NUM_LIT>:<EOL><INDENT>return <NUM_LIT:5><EOL><DEDENT>elif points<=<NUM_LIT>:<EOL><INDENT>return <NUM_LIT:6><EOL><DEDENT>else:<EOL><INDENT>return <NUM_LIT:7><EOL><DEDENT>", "docstring": "Approximate font size converter, converts from Points to HTML ``<font>`` tag font sizes.\n\nNote that this method is very inaccurate, since there are only seven possible output values that represent at least 25 input values.\nWhen in doubt, this function always rounds down, e.g. every input value less than eight is converted to HTML size 1.", "id": "f11158:m1"}
{"signature": "def addAction(self,action,func,*args,**kwargs):", "body": "if not hasattr(self,\"<STR_LIT>\"):<EOL><INDENT>self.actions = {}<EOL><DEDENT>if action not in self.actions:<EOL><INDENT>self.actions[action] = []<EOL><DEDENT>self.actions[action].append((func,args,kwargs))<EOL>", "docstring": "Adds a callback to the specified action.\n\nAll other positional and keyword arguments will be stored and passed to the function upon activation.", "id": "f11159:c1:m0"}
{"signature": "def predraw(self):", "body": "self.group.set_state()<EOL>", "docstring": "Sets the group state.", "id": "f11160:c3:m1"}
{"signature": "def draw(self):", "body": "pass<EOL>", "docstring": "Called when this layer needs to be drawn.\n\nOverride this method in subclasses to redefine behavior.", "id": "f11160:c0:m1"}
{"signature": "def predraw(self):", "body": "self.cam = self.view.cam<EOL>super(LayerWorld,self).predraw()<EOL>", "docstring": "Sets up the attributes used by :py:class:`Layer3D()` and calls :py:meth:`Layer3D.predraw()`\\ .", "id": "f11160:c4:m2"}
{"signature": "def on_menu_enter(self,old):", "body": "pass<EOL>", "docstring": "Custom fake event handler called by :py:meth:`Menu.on_enter()` for every layer.\n\nUseful for adding and removing event handlers per layer.", "id": "f11160:c0:m4"}
{"signature": "def setLang(self,lang):", "body": "self.lang = lang<EOL>self.peng.cfg[\"<STR_LIT>\"] = lang<EOL>if lang not in self.cache:<EOL><INDENT>self.cache[lang]={}<EOL><DEDENT>self.doAction(\"<STR_LIT>\")<EOL>self.peng.sendEvent(\"<STR_LIT>\",{\"<STR_LIT>\":self.lang,\"<STR_LIT>\":self})<EOL>", "docstring": "Sets the default language for all domains.\n\nFor recommendations regarding the format of the language code, see\n:py:class:`TranslationManager`\\ .\n\nNote that the ``lang`` parameter of both :py:meth:`translate()` and\n:py:meth:`translate_lazy()` will override this setting.\n\nAlso note that the code won't be checked for existence or plausibility.\nThis may cause the fallback strings to be displayed instead if the language\ndoes not exist.\n\nCalling this method will cause the ``setlang`` action and the\n:peng3d:event`peng3d:i18n.set_lang` event to be triggered. Note that both\naction and event will be triggered even if the language did not actually change.\n\nThis method also automatically updates the :confval:`i18n.lang` config value.", "id": "f11162:c0:m1"}
{"signature": "def initialize(self):", "body": "pass<EOL>", "docstring": "Called just before :py:meth:`on_redraw()` is called the first time.", "id": "f11163:c2:m2"}
{"signature": "def postdraw(self):", "body": "pass<EOL>", "docstring": "Called after calling the :py:meth:`draw()` Method.\n\nUseful for unsetting OpenGL state.", "id": "f11163:c1:m5"}
{"signature": "def switchImage(self,name):", "body": "if name not in self.imgs:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"%name)<EOL><DEDENT>elif self.cur_img==name:<EOL><INDENT>return<EOL><DEDENT>self.cur_img = name<EOL>self.on_redraw()<EOL>", "docstring": "Switches the active image to the given name.\n\n:raises ValueError: If there is no such image", "id": "f11163:c6:m2"}
{"signature": "def getLayer(self,name):", "body": "return self._layers[name]<EOL>", "docstring": "Returns the layer corresponding to the given name.\n\n:raises KeyError: If there is no Layer with the given name.", "id": "f11163:c0:m2"}
{"signature": "def delete(self):", "body": "for vlist in self._vlists:<EOL><INDENT>vlist.delete()<EOL><DEDENT>self._vlists = []<EOL>", "docstring": "Deletes this Layer.\n\nCurrently only deletes VertexLists registered with :py:meth:`regVList()`\\ .", "id": "f11163:c1:m7"}
{"signature": "@property<EOL><INDENT>def offset(self):<DEDENT>", "body": "if callable(self._offset):<EOL><INDENT>return util.WatchingList(self._offset(*(self.widget.pos+self.widget.size)),self._wlredraw_offset)<EOL><DEDENT>else:<EOL><INDENT>return util.WatchingList(self._offset,self._wlredraw_offset)<EOL><DEDENT>", "docstring": "Property to be used for setting and getting the offset of the layer.\n\nNote that setting this property causes an immediate redraw.", "id": "f11163:c2:m5"}
{"signature": "@property<EOL><INDENT>def pressed(self):<DEDENT>", "body": "return self.change_on_press and self.widget.pressed<EOL>", "docstring": "Read-only helper property to be used by styles for determining if the layer should be rendered as pressed or not.\n\nNote that this property may not represent the actual pressed state, it will always be False if ``change_on_press`` is disabled.", "id": "f11163:c11:m7"}
{"signature": "@property<EOL><INDENT>def nmax(self):<DEDENT>", "body": "return self._nmax<EOL>", "docstring": "Property representing the maximum value of the progressbar. Typically ``100`` to represent percentages easily.", "id": "f11164:c1:m3"}
{"signature": "def deleteCategory(self,name):", "body": "if name not in self.categories:<EOL><INDENT>raise KeyError(\"<STR_LIT>\"%name)<EOL><DEDENT>del self.categories[name]<EOL>self.redraw()<EOL>", "docstring": "Deletes the category with the given name.\n\nIf the category does not exist, a :py:exc:`KeyError` will be thrown.", "id": "f11164:c2:m12"}
{"signature": "def addCategory(self,name,nmin=<NUM_LIT:0>,n=<NUM_LIT:0>,nmax=<NUM_LIT:100>):", "body": "assert isinstance(name,basestring) <EOL>if name in self.categories:<EOL><INDENT>raise KeyError(\"<STR_LIT>\"%name)<EOL><DEDENT>self.categories[name]=[nmin,n,nmax]<EOL>self.redraw()<EOL>", "docstring": "Adds a category with the given name.\n\nIf the category already exists, a :py:exc:`KeyError` will be thrown. Use\n:py:meth:`updateCategory()` instead if you want to update a category.", "id": "f11164:c2:m10"}
{"signature": "@property<EOL><INDENT>def text(self):<DEDENT>", "body": "return self._text.text<EOL>", "docstring": "Property for accessing the text.", "id": "f11165:c2:m10"}
{"signature": "def getPosSize(self):", "body": "sx,sy = self.widget.size<EOL>x,y = self.widget.pos<EOL>bx,by = self.border<EOL>return sx,sy,x,y,bx,by<EOL>", "docstring": "Helper function converting the actual widget position and size into a usable and offsetted form.\n\nThis function should return a 6-tuple of ``(sx,sy,x,y,bx,by)`` where sx and sy are the size, x and y the position and bx and by are the border size.\n\nAll values should be in pixels and already include all offsets, as they are used directly for generation of vertex data.\n\nThis method can also be overridden to limit the background to a specific part of its widget.", "id": "f11166:c0:m3"}
{"signature": "def redraw_label(self):", "body": "<EOL>sx,sy = self.size<EOL>x,y = self.pos<EOL>self._label.x = x+sx/<NUM_LIT><EOL>self._label.y = y+sy/<NUM_LIT><EOL>self._label._update()<EOL>", "docstring": "Re-draws the label by calculating its position.\n\nCurrently, the label will always be centered on the Button.", "id": "f11166:c1:m2"}
{"signature": "def draw(self):", "body": "super(GUIMenu,self).draw()<EOL>self.submenu.draw()<EOL>", "docstring": "Draws each menu layer and the active submenu.\n\nNote that the layers are drawn first and may be overridden by the submenu and widgets.", "id": "f11167:c0:m3"}
{"signature": "def changeSubMenu(self,submenu):", "body": "if submenu not in self.submenus:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"%submenu)<EOL><DEDENT>elif submenu == self.activeSubMenu:<EOL><INDENT>return <EOL><DEDENT>old = self.activeSubMenu<EOL>self.activeSubMenu = submenu<EOL>if old is not None:<EOL><INDENT>self.submenus[old].on_exit(submenu)<EOL>self.submenus[old].doAction(\"<STR_LIT>\")<EOL><DEDENT>self.submenu.on_enter(old)<EOL>self.submenu.doAction(\"<STR_LIT>\")<EOL>", "docstring": "Changes the submenu that is displayed.\n\n:raises ValueError: if the name was not previously registered", "id": "f11167:c0:m2"}
{"signature": "def on_exit(self,new):", "body": "pass<EOL>", "docstring": "Dummy method defined for compatibility with :py:class:`peng3d.gui.SubMenu`, simply does nothing.", "id": "f11168:c1:m11"}
{"signature": "def add_btn_confirm(self,label_confirm):", "body": "<EOL>self.wbtn_confirm = button.Button(\"<STR_LIT>\",self,self.window,self.peng,<EOL>pos=lambda sw,sh, bw,bh: (sw/<NUM_LIT:2>-bw-<NUM_LIT:4>,sh/<NUM_LIT:2>-bh/<NUM_LIT:2>-bh*<NUM_LIT:2>),<EOL>size=[<NUM_LIT:0>,<NUM_LIT:0>],<EOL>label=label_confirm,<EOL>borderstyle=self.borderstyle<EOL>)<EOL>self.wbtn_confirm.size = lambda sw,sh: (self.wbtn_confirm._label.font_size*<NUM_LIT:8>,self.wbtn_confirm._label.font_size*<NUM_LIT:2>)<EOL>self.addWidget(self.wbtn_confirm)<EOL>def f():<EOL><INDENT>self.doAction(\"<STR_LIT>\")<EOL>self.exitDialog()<EOL><DEDENT>self.wbtn_confirm.addAction(\"<STR_LIT>\",f)<EOL>", "docstring": "Adds a confirm button to let the user confirm whatever action they were presented with.\n\nThis widget can be triggered by setting the label ``label_confirm`` to a string.\n\nThis widget will be positioned slightly below the main label and to the left\nof the cancel button.", "id": "f11169:c1:m0"}
{"signature": "def add_btn_cancel(self,label_cancel):", "body": "<EOL>self.wbtn_cancel = button.Button(\"<STR_LIT>\",self,self.window,self.peng,<EOL>pos=lambda sw,sh, bw,bh: (sw/<NUM_LIT:2>+<NUM_LIT:4>,sh/<NUM_LIT:2>-bh/<NUM_LIT:2>-bh*<NUM_LIT:2>),<EOL>size=[<NUM_LIT:0>,<NUM_LIT:0>],<EOL>label=label_cancel,<EOL>borderstyle=self.borderstyle<EOL>)<EOL>self.wbtn_cancel.size = lambda sw,sh: (self.wbtn_cancel._label.font_size*<NUM_LIT:8>,self.wbtn_cancel._label.font_size*<NUM_LIT:2>)<EOL>self.addWidget(self.wbtn_cancel)<EOL>def f():<EOL><INDENT>self.doAction(\"<STR_LIT>\")<EOL>self.exitDialog()<EOL><DEDENT>self.wbtn_cancel.addAction(\"<STR_LIT>\",f)<EOL>", "docstring": "Adds a cancel button to let the user cancel whatever choice they were given.\n\nThis widget can be triggered by setting the label ``label_cancel`` to a string.\n\nThis widget will be positioned slightly below the main label and to the right\nof the confirm button.", "id": "f11169:c1:m1"}
{"signature": "@property<EOL><INDENT>def label_confirm(self):<DEDENT>", "body": "return self.wbtn_confirm.label<EOL>", "docstring": "Property that proxies the ``label_confirm`` label.\n\nSetting this property will cause the ``label_confirm_change`` action to trigger.\n\nNote that trying to access this property if the widget is not used may cause\nan error.", "id": "f11169:c1:m2"}
{"signature": "@property<EOL><INDENT>def progress_nmax(self):<DEDENT>", "body": "return self.wprogressbar.nmax<EOL>", "docstring": "Property that proxies the ``progress_nmax`` label.\n\nSetting this property will cause the progressbar label to be recalculated.\n\nNote that setting this property if the widget has not been initialized may\ncause various errors to occur.", "id": "f11169:c3:m6"}
{"signature": "@property<EOL><INDENT>def progress_n(self):<DEDENT>", "body": "return self.wprogressbar.n<EOL>", "docstring": "Property that proxies the ``progress_n`` label.\n\nSetting this property will cause the progressbar label to be recalculated.\n\nAdditionally, if the supplied value is higher than the maximum value and\n:py:attr:`auto_exit` is true, the dialog will exit.", "id": "f11169:c3:m2"}
{"signature": "def addCategory(self,*args,**kwargs):", "body": "return self.wprogressbar.addCategory(*args,**kwargs)<EOL>", "docstring": "Proxy for :py:meth:`~peng3d.gui.slider.AdvancedProgressbar.addCategory()`\\ .", "id": "f11169:c4:m1"}
{"signature": "@property<EOL><INDENT>def label_cancel(self):<DEDENT>", "body": "return self.wbtn_cancel.label<EOL>", "docstring": "Property that proxies the ``label_cancel`` label.\n\nSetting this property will cause the ``label_cancel_change`` action to trigger.\n\nNote that trying to access this property if the widget is not used may cause\nan error.", "id": "f11169:c1:m4"}
{"signature": "def init_bg(self):", "body": "pass<EOL>", "docstring": "Called just before the background will be drawn the first time.\n\nCommonly used to initialize vertex lists.\n\nIt is recommended to add all vertex lists to the ``submenu.batch2d`` Batch to speed up rendering and preventing glitches with grouping.", "id": "f11170:c0:m1"}
{"signature": "def draw(self):", "body": "if self.do_redraw:<EOL><INDENT>self.on_redraw()<EOL>self.do_redraw = False<EOL><DEDENT>", "docstring": "Draws all vertex lists associated with this widget.", "id": "f11170:c2:m12"}
{"signature": "@property<EOL><INDENT>def clickable(self):<DEDENT>", "body": "if not isinstance(self.submenu,Container):<EOL><INDENT>return self.submenu.name == self.submenu.menu.activeSubMenu and self.submenu.menu.name == self.window.activeMenu and self.enabled<EOL><DEDENT>else:<EOL><INDENT>return self.submenu.clickable and self.enabled<EOL><DEDENT>", "docstring": "Property used for determining if the widget should be clickable by the user.\n\nThis is only true if the submenu of this widget is active and this widget is enabled.\n\nThe widget may be either disabled by setting this property or the :py:attr:`enabled` attribute.", "id": "f11170:c2:m6"}
{"signature": "def update(self,dt):", "body": "if not self.enabled:<EOL><INDENT>return<EOL><DEDENT>speed = self.movespeed<EOL>d = dt * speed <EOL>dx, dy, dz = self.get_motion_vector()<EOL>dx, dy, dz = dx * d, dy * d, dz * d<EOL>x,y,z = self.actor._pos<EOL>newpos = dx+x, dy+y, dz+z<EOL>self.actor.pos = newpos<EOL>", "docstring": "Should be called regularly to move the actor.\n\nThis method does nothing if the :py:attr:`enabled` property is set to false.\n\nNote that this method is called automatically and should not be manually called.", "id": "f11171:c0:m2"}
{"signature": "def registerEventHandlers(self):", "body": "<EOL>self.peng.keybinds.add(self.peng.cfg[\"<STR_LIT>\"],\"<STR_LIT>\"%self.actor.uuid,self.on_crouch_down,False)<EOL>self.peng.keybinds.add(self.peng.cfg[\"<STR_LIT>\"],\"<STR_LIT>\"%self.actor.uuid,self.on_jump_down,False)<EOL>pyglet.clock.schedule_interval(self.update,<NUM_LIT:1.0>/<NUM_LIT>)<EOL>", "docstring": "Registers the up and down handlers.\n\nAlso registers a scheduled function every 60th of a second, causing pyglet to redraw your window with 60fps.", "id": "f11171:c2:m1"}
{"signature": "def get_motion_vector(self):", "body": "if any(self.move):<EOL><INDENT>x, y = self.actor._rot<EOL>strafe = math.degrees(math.atan2(*self.move))<EOL>y_angle = math.radians(y)<EOL>x_angle = math.radians(x + strafe)<EOL>dy = <NUM_LIT:0.0><EOL>dx = math.cos(x_angle)<EOL>dz = math.sin(x_angle)<EOL><DEDENT>else:<EOL><INDENT>dy = <NUM_LIT:0.0><EOL>dx = <NUM_LIT:0.0><EOL>dz = <NUM_LIT:0.0><EOL><DEDENT>return (dx, dy, dz)<EOL>", "docstring": "Returns the movement vector according to held buttons and the rotation.\n\n:return: 3-Tuple of ``(dx,dy,dz)``\n:rtype: tuple", "id": "f11171:c0:m3"}
{"signature": "@property<EOL><INDENT>def pos(self):<DEDENT>", "body": "return self._pos<EOL>", "docstring": "Property allowing access to the position of this actor.\n\nThis actor is read-write but calls :py:meth:`on_move()` if it is set.", "id": "f11172:c1:m6"}
{"signature": "def move(self,dist):", "body": "x, y = self._rot<EOL>y_angle = math.radians(y)<EOL>x_angle = math.radians(x)<EOL>m = math.cos(y_angle)<EOL>dy = math.sin(y_angle)<EOL>dy = <NUM_LIT:0.0><EOL>dx = math.cos(x_angle)<EOL>dz = math.sin(x_angle)<EOL>dx,dy,dz = dx*dist,dy*dist,dz*dist<EOL>x,y,z = self._pos<EOL>self.pos = x+dx,y+dy,z+dz<EOL>return dx,dy,dz<EOL>", "docstring": "Moves the actor using standard trigonometry along the current rotational vector.\n\n:param float dist: Distance to move\n\n.. todo::\n\n   Test this method, also with negative distances", "id": "f11172:c2:m1"}
{"signature": "def registerEventHandlers(self):", "body": "pass<EOL>", "docstring": "Method to be overridden by subclasses for registering event handlers.\n\nAutomatically called upon object creation.", "id": "f11172:c0:m1"}
{"signature": "def setModel(self,model):", "body": "if self.model is not None:<EOL><INDENT>self.model.cleanup(self)<EOL><DEDENT>self.model = model<EOL>model.create(self)<EOL>", "docstring": "Sets the model this actor should use when drawing.\n\nThis method also automatically initializes the new model and removes the old, if any.", "id": "f11172:c1:m2"}
{"signature": "def render(self,view=None):", "body": "if self.model is not None:<EOL><INDENT>self.model.draw(self)<EOL><DEDENT>", "docstring": "Called by :py:meth:`World.render3d()` to render this actor.\n\nBy default, this method calls the draw method of its model, if any.\n\nFor custom render behavior, it is recommended to extend this method or modify the model.", "id": "f11172:c1:m4"}
{"signature": "def handle_combo(self,combo,symbol,modifiers,release=False,mod=True):", "body": "if self.peng.cfg[\"<STR_LIT>\"]:<EOL><INDENT>print(\"<STR_LIT>\"%(mod,combo))<EOL><DEDENT>if mod:<EOL><INDENT>for kbname in self.keybinds.get(combo,[]):<EOL><INDENT>self.kbname[kbname](symbol,modifiers,release)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for kbname in self.keybinds_nm.get(combo,[]):<EOL><INDENT>self.kbname[kbname](symbol,modifiers,release)<EOL><DEDENT><DEDENT>self.peng.sendPygletEvent(\"<STR_LIT>\",(combo,symbol,modifiers,release,mod))<EOL>self.peng.sendEvent(\"<STR_LIT>\",{\"<STR_LIT>\":self.peng,\"<STR_LIT>\":combo,\"<STR_LIT>\":symbol,\"<STR_LIT>\":modifiers,\"<STR_LIT>\":release,\"<STR_LIT>\":mod})<EOL>if release:<EOL><INDENT>self.peng.sendEvent(\"<STR_LIT>\",{\"<STR_LIT>\":self.peng,\"<STR_LIT>\":combo,\"<STR_LIT>\":symbol,\"<STR_LIT>\":modifiers,\"<STR_LIT>\":release,\"<STR_LIT>\":mod})<EOL><DEDENT>else:<EOL><INDENT>self.peng.sendEvent(\"<STR_LIT>\",{\"<STR_LIT>\":self.peng,\"<STR_LIT>\":combo,\"<STR_LIT>\":symbol,\"<STR_LIT>\":modifiers,\"<STR_LIT>\":release,\"<STR_LIT>\":mod})<EOL><DEDENT>", "docstring": "Handles a key combination and dispatches associated events.\n\nFirst, all keybind handlers registered via :py:meth:`add` will be handled,\nthen the pyglet event :peng3d:pgevent:`on_key_combo` with params ``(combo,symbol,modifiers,release,mod)`` is sent to the :py:class:`Peng()` instance.\n\nAlso sends the events :peng3d:event:`peng3d:keybind.combo`\\, :peng3d:event:`peng3d:keybind.combo.press` and :peng3d:event`peng3d:keybind.combo.release`\\ .\n\n:params str combo: Key combination pressed\n:params int symbol: Key pressed, passed from the same argument within pyglet\n:params int modifiers: Modifiers held while the key was pressed\n:params bool release: If the combo was released\n:params bool mod: If the combo was sent without mods", "id": "f11173:c0:m5"}
{"signature": "def first_kwonly_arg(name):", "body": "def decorate(wrapped):<EOL><INDENT>if sys.version_info[<NUM_LIT:0>] == <NUM_LIT:2>:<EOL><INDENT>arg_names, varargs, _, defaults = inspect.getargspec(wrapped)<EOL><DEDENT>else:<EOL><INDENT>arg_names, varargs, _, defaults = inspect.getfullargspec(wrapped)[:<NUM_LIT:4>]<EOL><DEDENT>if not defaults:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>first_default_index = len(arg_names) - len(defaults)<EOL>if name is FIRST_DEFAULT_ARG:<EOL><INDENT>first_kwonly_index = first_default_index<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>first_kwonly_index = arg_names.index(name)<EOL><DEDENT>except ValueError:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % (<EOL>getattr(wrapped, '<STR_LIT>', '<STR_LIT:?>'), name))<EOL><DEDENT><DEDENT>if first_kwonly_index < first_default_index:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % (name,))<EOL><DEDENT>kwonly_defaults = defaults[-(len(arg_names)-first_kwonly_index):]<EOL>kwonly_args = tuple(zip(arg_names[first_kwonly_index:], kwonly_defaults))<EOL>required_kwonly_args = frozenset(arg for arg, default in kwonly_args if default is KWONLY_REQUIRED)<EOL>def wrapper(*args, **kwargs):<EOL><INDENT>if required_kwonly_args:<EOL><INDENT>missing_kwonly_args = required_kwonly_args.difference(kwargs.keys())<EOL>if missing_kwonly_args:<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % (<EOL>getattr(wrapped, '<STR_LIT>', '<STR_LIT:?>'), len(missing_kwonly_args),<EOL>'<STR_LIT:U+002CU+0020>'.join(sorted(missing_kwonly_args))))<EOL><DEDENT><DEDENT>if len(args) > first_kwonly_index:<EOL><INDENT>if varargs is None:<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % (<EOL>getattr(wrapped, '<STR_LIT>', '<STR_LIT:?>'), first_kwonly_index, len(args)))<EOL><DEDENT>kwonly_args_from_kwargs = tuple(kwargs.pop(arg, default) for arg, default in kwonly_args)<EOL>args = args[:first_kwonly_index] + kwonly_args_from_kwargs + args[first_kwonly_index:]<EOL><DEDENT>return wrapped(*args, **kwargs)<EOL><DEDENT>return update_wrapper(wrapper, wrapped)<EOL><DEDENT>return decorate<EOL>", "docstring": "Emulates keyword-only arguments under python2. Works with both python2 and python3.\n    With this decorator you can convert all or some of the default arguments of your function\n    into kwonly arguments. Use ``KWONLY_REQUIRED`` as the default value of required kwonly args.\n\n    :param name: The name of the first default argument to be treated as a keyword-only argument. This default\n    argument along with all default arguments that follow this one will be treated as keyword only arguments.\n\n    You can also pass here the ``FIRST_DEFAULT_ARG`` constant in order to select the first default argument. This\n    way you turn all default arguments into keyword-only arguments. As a shortcut you can use the\n    ``@kwonly_defaults`` decorator (without any parameters) instead of ``@first_kwonly_arg(FIRST_DEFAULT_ARG)``.\n\n        >>> from kwonly_args import first_kwonly_arg, KWONLY_REQUIRED, FIRST_DEFAULT_ARG, kwonly_defaults\n        >>>\n        >>> # this decoration converts the ``d1`` and ``d2`` default args into kwonly args\n        >>> @first_kwonly_arg('d1')\n        >>> def func(a0, a1, d0='d0', d1='d1', d2='d2', *args, **kwargs):\n        >>>     print(a0, a1, d0, d1, d2, args, kwargs)\n        >>>\n        >>> func(0, 1, 2, 3, 4)\n        0 1 2 d1 d2 (3, 4) {}\n        >>>\n        >>> func(0, 1, 2, 3, 4, d2='my_param')\n        0 1 2 d1 my_param (3, 4) {}\n        >>>\n        >>> # d0 is an optional deyword argument, d1 is required\n        >>> def func(d0='d0', d1=KWONLY_REQUIRED):\n        >>>     print(d0, d1)\n        >>>\n        >>> # The ``FIRST_DEFAULT_ARG`` constant automatically selects the first default argument so it\n        >>> # turns all default arguments into keyword-only ones. Both d0 and d1 are keyword-only arguments.\n        >>> @first_kwonly_arg(FIRST_DEFAULT_ARG)\n        >>> def func(a0, a1, d0='d0', d1='d1'):\n        >>>     print(a0, a1, d0, d1)\n        >>>\n        >>> # ``@kwonly_defaults`` is a shortcut for the ``@first_kwonly_arg(FIRST_DEFAULT_ARG)``\n        >>> # in the previous example. This example has the same effect as the previous one.\n        >>> @kwonly_defaults\n        >>> def func(a0, a1, d0='d0', d1='d1'):\n        >>>     print(a0, a1, d0, d1)", "id": "f11202:m0"}
{"signature": "def entry_point(items=tuple()):", "body": "try:<EOL><INDENT>if not items:<EOL><INDENT>from .example import ExampleCommand<EOL>from .version import Version<EOL>items = [(ExampleCommand.NAME, ExampleCommand),<EOL>(Version.NAME, Version)]<EOL><DEDENT>main(\"<STR_LIT>\", items=items)<EOL><DEDENT>except Stop as stop:<EOL><INDENT>print(stop)<EOL>sys.exit(stop.rc)<EOL><DEDENT>except SystemExit:<EOL><INDENT>raise<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>except Exception:<EOL><INDENT>traceback.print_exc()<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "External entry point which calls main() and\nif Stop is raised, calls sys.exit()", "id": "f11210:m0"}
{"signature": "def main(fw_name, args=None, items=None):", "body": "global DEBUG_LEVEL<EOL>global FRAMEWORK_NAME<EOL>debug_name = \"<STR_LIT>\" % fw_name.upper()<EOL>if debug_name in os.environ:<EOL><INDENT>try:<EOL><INDENT>DEBUG_LEVEL = int(os.environ.get(debug_name))<EOL><DEDENT>except ValueError:<EOL><INDENT>DEBUG_LEVEL = <NUM_LIT:10>  <EOL><DEDENT><DEDENT>FRAMEWORK_NAME = fw_name<EOL>if args is None:<EOL><INDENT>args = sys.argv[<NUM_LIT:1>:]<EOL><DEDENT>if items is None:<EOL><INDENT>items = list(globals().items())<EOL><DEDENT>yaclifw_parser, sub_parsers = parsers()<EOL>for name, MyCommand in sorted(items):<EOL><INDENT>if not isinstance(MyCommand, type):<EOL><INDENT>continue<EOL><DEDENT>if not issubclass(MyCommand, Command):<EOL><INDENT>continue<EOL><DEDENT>if MyCommand.NAME == \"<STR_LIT>\":<EOL><INDENT>continue<EOL><DEDENT>MyCommand(sub_parsers)<EOL><DEDENT>ns = yaclifw_parser.parse_args(args)<EOL>ns.func(ns)<EOL>if hasattr(ns, '<STR_LIT>'):<EOL><INDENT>if callable(ns.callback):<EOL><INDENT>ns.callback()<EOL><DEDENT>else:<EOL><INDENT>raise Stop(<NUM_LIT:3>, \"<STR_LIT>\")<EOL><DEDENT><DEDENT>", "docstring": "Reusable entry point. Arguments are parsed\nvia the argparse-subcommands configured via\neach Command class found in globals(). Stop\nexceptions are propagated to callers.\n\nThe name of the framework will be used in logging\nand similar.", "id": "f11211:m1"}
{"signature": "def get_relationship_info(tree, media, image_sizes):", "body": "if tree is None:<EOL><INDENT>return {}<EOL><DEDENT>result = {}<EOL>for el in tree.iter():<EOL><INDENT>el_id = el.get('<STR_LIT>')<EOL>if el_id is None:<EOL><INDENT>continue<EOL><DEDENT>target = el.get('<STR_LIT>')<EOL>if any(<EOL>target.lower().endswith(ext) for<EOL>ext in IMAGE_EXTENSIONS_TO_SKIP):<EOL><INDENT>continue<EOL><DEDENT>if target in media:<EOL><INDENT>image_size = image_sizes.get(el_id)<EOL>target = convert_image(media[target], image_size)<EOL><DEDENT>result[el_id] = cgi.escape(target)<EOL><DEDENT>return result<EOL>", "docstring": "There is a separate file holds the targets to links as well as the targets\nfor images. Return a dictionary based on the relationship id and the\ntarget.", "id": "f11219:m31"}
{"signature": "@ensure_tag(['<STR_LIT:p>'])<EOL>def get_ilvl(li, w_namespace):", "body": "ilvls = li.xpath('<STR_LIT>', namespaces=li.nsmap)<EOL>if len(ilvls) == <NUM_LIT:0>:<EOL><INDENT>return -<NUM_LIT:1><EOL><DEDENT>return int(ilvls[<NUM_LIT:0>].get('<STR_LIT>' % w_namespace))<EOL>", "docstring": "The ilvl on an li tag tells the li tag at what level of indentation this\ntag is at. This is used to determine if the li tag needs to be nested or\nnot.", "id": "f11219:m13"}
{"signature": "@ensure_tag(['<STR_LIT>'])<EOL>def build_table(table, meta_data):", "body": "<EOL>table_el = etree.Element('<STR_LIT>')<EOL>w_namespace = get_namespace(table, '<STR_LIT:w>')<EOL>row_spans = get_rowspan_data(table)<EOL>for el in table:<EOL><INDENT>if el.tag == '<STR_LIT>' % w_namespace:<EOL><INDENT>tr_el = build_tr(<EOL>el,<EOL>meta_data,<EOL>row_spans,<EOL>)<EOL>table_el.append(tr_el)<EOL><DEDENT><DEDENT>visited_nodes = list(table.iter())<EOL>return table_el, visited_nodes<EOL>", "docstring": "This returns a table object with all rows and cells correctly populated.", "id": "f11219:m37"}
{"signature": "@ensure_tag(['<STR_LIT:t>'])<EOL>def get_t_tag_content(<EOL>t, parent, remove_bold, remove_italics, meta_data):", "body": "if t is None or t.text is None:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>text = cgi.escape(t.text)<EOL>el_is_bold = not remove_bold and (<EOL>is_bold(parent) or<EOL>is_underlined(parent)<EOL>)<EOL>el_is_italics = not remove_italics and is_italics(parent)<EOL>if el_is_bold:<EOL><INDENT>text = '<STR_LIT>' % text<EOL><DEDENT>if el_is_italics:<EOL><INDENT>text = '<STR_LIT>' % text<EOL><DEDENT>return text<EOL>", "docstring": "Generate the string data that for this particular t tag.", "id": "f11219:m38"}
{"signature": "def _strip_tag(tree, tag):", "body": "for el in tree.iter():<EOL><INDENT>if el.tag == tag:<EOL><INDENT>el.getparent().remove(el)<EOL><DEDENT><DEDENT>", "docstring": "Remove all tags that have the tag name ``tag``", "id": "f11219:m44"}
{"signature": "@ensure_tag(['<STR_LIT:p>'])<EOL>def is_li(el, meta_data):", "body": "if is_header(el, meta_data):<EOL><INDENT>return False<EOL><DEDENT>return _is_li(el)<EOL>", "docstring": "The only real distinction between an ``li`` tag and a ``p`` tag is that an\n``li`` tag has an attribute called numPr which holds the list id and ilvl\n(indentation level)", "id": "f11219:m9"}
{"signature": "def is_last_li(li, meta_data, current_numId):", "body": "if not is_li(li, meta_data):<EOL><INDENT>return False<EOL><DEDENT>w_namespace = get_namespace(li, '<STR_LIT:w>')<EOL>next_el = li<EOL>while True:<EOL><INDENT>if next_el is None:<EOL><INDENT>return True<EOL><DEDENT>next_el = next_el.getnext()<EOL>if not is_li(next_el, meta_data):<EOL><INDENT>continue<EOL><DEDENT>new_numId = get_numId(next_el, w_namespace)<EOL>if current_numId != new_numId:<EOL><INDENT>return True<EOL><DEDENT>return False<EOL><DEDENT>", "docstring": "Determine if ``li`` is the last list item for a given list", "id": "f11219:m11"}
{"signature": "@ensure_tag(['<STR_LIT:r>'])<EOL>def get_text_run_content_data(r):", "body": "w_namespace = get_namespace(r, '<STR_LIT:w>')<EOL>valid_elements = (<EOL>'<STR_LIT>' % w_namespace,<EOL>'<STR_LIT>' % w_namespace,<EOL>'<STR_LIT>' % w_namespace,<EOL>'<STR_LIT>' % w_namespace,<EOL>)<EOL>for el in r:<EOL><INDENT>if el.tag in valid_elements:<EOL><INDENT>yield el<EOL><DEDENT><DEDENT>", "docstring": "It turns out that r tags can contain both t tags and drawing tags. Since we\nneed both, this function will return them in the order in which they are\nfound.", "id": "f11219:m25"}
{"signature": "def has_text(p):", "body": "return '<STR_LIT>' != etree.tostring(p, encoding=unicode, method='<STR_LIT:text>').strip()<EOL>", "docstring": "It is possible for a ``p`` tag in document.xml to not have any content. If\nthis is the case we do not want that tag interfering with things like\nlists. Detect if this tag has any content.", "id": "f11219:m10"}
{"signature": "def get_style_dict(tree):", "body": "<EOL>headers = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>}<EOL>if tree is None:<EOL><INDENT>return {}<EOL><DEDENT>w_namespace = get_namespace(tree, '<STR_LIT:w>')<EOL>result = {}<EOL>for el in tree:<EOL><INDENT>style_id = el.get('<STR_LIT>' % w_namespace)<EOL>el_result = {<EOL>'<STR_LIT>': False,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>}<EOL>name = el.find('<STR_LIT>' % w_namespace)<EOL>if name is None:<EOL><INDENT>continue<EOL><DEDENT>value = name.get('<STR_LIT>' % w_namespace).lower()<EOL>if value in headers:<EOL><INDENT>el_result['<STR_LIT>'] = headers[value]<EOL><DEDENT>rpr = el.find('<STR_LIT>' % w_namespace)<EOL>if rpr is None:<EOL><INDENT>continue<EOL><DEDENT>size = rpr.find('<STR_LIT>' % w_namespace)<EOL>if size is None:<EOL><INDENT>el_result['<STR_LIT>'] = None<EOL><DEDENT>else:<EOL><INDENT>el_result['<STR_LIT>'] = size.get('<STR_LIT>' % w_namespace)<EOL><DEDENT>based_on = el.find('<STR_LIT>' % w_namespace)<EOL>if based_on is None:<EOL><INDENT>el_result['<STR_LIT>'] = None<EOL><DEDENT>else:<EOL><INDENT>el_result['<STR_LIT>'] = based_on.get('<STR_LIT>' % w_namespace)<EOL><DEDENT>result[style_id] = el_result<EOL><DEDENT>return result<EOL>", "docstring": "Some things that are considered lists are actually supposed to be H tags\n(h1, h2, etc.) These can be denoted by their styleId", "id": "f11219:m29"}
{"signature": "@ensure_tag(['<STR_LIT>'])<EOL>def get_v_merge(tc):", "body": "if tc is None:<EOL><INDENT>return None<EOL><DEDENT>v_merges = tc.xpath('<STR_LIT>', namespaces=tc.nsmap)<EOL>if len(v_merges) != <NUM_LIT:1>:<EOL><INDENT>return None<EOL><DEDENT>v_merge = v_merges[<NUM_LIT:0>]<EOL>return v_merge<EOL>", "docstring": "vMerge is what docx uses to denote that a table cell is part of a rowspan.\nThe first cell to have a vMerge is the start of the rowspan, and the vMerge\nwill be denoted with 'restart'. If it is anything other than restart then\nit is a continuation of another rowspan.", "id": "f11219:m16"}
{"signature": "@ensure_tag(['<STR_LIT:r>'])<EOL>def is_bold(r):", "body": "w_namespace = get_namespace(r, '<STR_LIT:w>')<EOL>rpr = r.find('<STR_LIT>' % w_namespace)<EOL>if rpr is None:<EOL><INDENT>return False<EOL><DEDENT>bold = rpr.find('<STR_LIT>' % w_namespace)<EOL>return style_is_false(bold)<EOL>", "docstring": "The function will return True if the r tag passed in is considered bold.", "id": "f11219:m21"}
{"signature": "@ensure_tag(['<STR_LIT>'])<EOL>def get_grid_span(tc):", "body": "w_namespace = get_namespace(tc, '<STR_LIT:w>')<EOL>grid_spans = tc.xpath('<STR_LIT>', namespaces=tc.nsmap)<EOL>if len(grid_spans) != <NUM_LIT:1>:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>grid_span = grid_spans[<NUM_LIT:0>]<EOL>return int(grid_span.get('<STR_LIT>' % w_namespace))<EOL>", "docstring": "gridSpan is what docx uses to denote that a table cell has a colspan. This\nis much more simple than rowspans in that there is a one-to-one mapping\nfrom gridSpan to colspan.", "id": "f11219:m17"}
{"signature": "@ensure_tag(['<STR_LIT:p>'])<EOL>def get_numId(li, w_namespace):", "body": "numIds = li.xpath('<STR_LIT>', namespaces=li.nsmap)<EOL>if len(numIds) == <NUM_LIT:0>:<EOL><INDENT>return -<NUM_LIT:1><EOL><DEDENT>return numIds[<NUM_LIT:0>].get('<STR_LIT>' % w_namespace)<EOL>", "docstring": "The numId on an li tag maps to the numbering dictionary along side the ilvl\nto determine what the list should look like (unordered, digits, lower\nalpha, etc)", "id": "f11219:m14"}
{"signature": "def send(addr, *body):", "body": "connection = socket.socket(socket.AF_INET, socket.SOCK_STREAM)<EOL>connection.connect(addr)<EOL>connection.sendall('<STR_LIT:\\r\\n>'.join(body).encode())<EOL>return connection<EOL>", "docstring": "Connect to the address, send body.", "id": "f11224:m1"}
{"signature": "def method_not_found(request_id):", "body": "response = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:id>': request_id,<EOL>'<STR_LIT:error>': {<EOL>'<STR_LIT:code>': -<NUM_LIT>,<EOL>'<STR_LIT:message>': '<STR_LIT>',<EOL>},<EOL>}<EOL>raise ServiceException(<NUM_LIT>, dumps(response))<EOL>", "docstring": "JSON-RPC method not found error.\n\n    :param request_id: JSON-RPC request id\n    :type request_id: int or str or None", "id": "f11226:m2"}
{"signature": "def validate_params(request):", "body": "if '<STR_LIT>' in request:<EOL><INDENT>correct_params = isinstance(request['<STR_LIT>'], (list, dict))<EOL>error = '<STR_LIT>'<EOL>assert correct_params, error<EOL><DEDENT>", "docstring": "Validate request params.", "id": "f11227:m2"}
{"signature": "def validate_version(request):", "body": "correct_version = request['<STR_LIT>'] == '<STR_LIT>'<EOL>error = '<STR_LIT>'<EOL>assert correct_version, error<EOL>", "docstring": "Validate request version.", "id": "f11227:m0"}
{"signature": "def validate_id(request):", "body": "if '<STR_LIT:id>' in request:<EOL><INDENT>correct_id = isinstance(<EOL>request['<STR_LIT:id>'],<EOL>(string_types, int, None),<EOL>)<EOL>error = '<STR_LIT>'<EOL>assert correct_id, error<EOL><DEDENT>", "docstring": "Validate request id.", "id": "f11227:m3"}
{"signature": "def service_factory(app, host, port,<EOL>report_message='<STR_LIT>',<EOL>provider_cls=HTTPServiceProvider):", "body": "service = Service(app)<EOL>server = provider_cls(service, host, port, report_message)<EOL>server.serve_forever()<EOL>", "docstring": "Create service, start server.\n\n    :param app: application to instantiate a service\n    :param host: interface to bound provider\n    :param port: port to bound provider\n    :param report_message: message format to report port\n    :param provider_cls: server class provide a service", "id": "f11233:m0"}
{"signature": "def validate(self, request):", "body": "try:<EOL><INDENT>validate_version(request)<EOL>validate_method(request)<EOL>validate_params(request)<EOL>validate_id(request)<EOL><DEDENT>except (AssertionError, KeyError) as error:<EOL><INDENT>invalid_request(error)<EOL><DEDENT>", "docstring": "Validate JSON-RPC request.\n\n        :param request: RPC request object\n        :type request: dict", "id": "f11234:c0:m3"}
{"signature": "def make_response(self, args, result):", "body": "return dumps({<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:id>': args['<STR_LIT:id>'],<EOL>'<STR_LIT:result>': result,<EOL>})<EOL>", "docstring": "Create response body from given result.", "id": "f11234:c0:m6"}
{"signature": "def get_old_safe_contract(w3: Web3, address=None):", "body": "return w3.eth.contract(address,<EOL>abi=OLD_GNOSIS_SAFE_INTERFACE['<STR_LIT>'],<EOL>bytecode=OLD_GNOSIS_SAFE_INTERFACE['<STR_LIT>'])<EOL>", "docstring": "Get Old Gnosis Safe Master contract. It should be used to access Safe methods on Proxy contracts.\n:param w3: Web3 instance\n:param address: address of the safe contract/proxy contract\n:return: Safe Contract", "id": "f11236:m1"}
{"signature": "def get_paying_proxy_contract(w3: Web3, address=None):", "body": "return w3.eth.contract(address,<EOL>abi=PAYING_PROXY_INTERFACE['<STR_LIT>'],<EOL>bytecode=PAYING_PROXY_INTERFACE['<STR_LIT>'])<EOL>", "docstring": "Get Paying Proxy Contract. This should be used just for contract creation/changing master_copy\nIf you want to call Safe methods you should use `get_safe_contract` with the Proxy address,\nso you can access every method of the Safe\n:param w3: Web3 instance\n:param address: address of the proxy contract\n:return: Paying Proxy Contract", "id": "f11236:m2"}
{"signature": "def get_transfer_history(self, from_block: int, to_block: Optional[int] = None,<EOL>from_address: Optional[str] = None, to_address: Optional[str] = None,<EOL>token_address: Optional[str] = None) -> List[Dict[str, any]]:", "body": "assert from_address or to_address or token_address, '<STR_LIT>'<EOL>erc20 = get_erc20_contract(self.w3)<EOL>argument_filters = {}<EOL>if from_address:<EOL><INDENT>argument_filters['<STR_LIT>'] = from_address<EOL><DEDENT>if to_address:<EOL><INDENT>argument_filters['<STR_LIT:to>'] = to_address<EOL><DEDENT>return erc20.events.Transfer.createFilter(fromBlock=from_block,<EOL>toBlock=to_block,<EOL>address=token_address,<EOL>argument_filters=argument_filters).get_all_entries()<EOL>", "docstring": "Get events for erc20 transfers. At least one of `from_address`, `to_address` or `token_address` must be\ndefined\nAn example of event:\n{\n    \"args\": {\n        \"from\": \"0x1Ce67Ea59377A163D47DFFc9BaAB99423BE6EcF1\",\n        \"to\": \"0xaE9E15896fd32E59C7d89ce7a95a9352D6ebD70E\",\n        \"value\": 15000000000000000\n    },\n    \"event\": \"Transfer\",\n    \"logIndex\": 42,\n    \"transactionIndex\": 60,\n    \"transactionHash\": \"0x71d6d83fef3347bad848e83dfa0ab28296e2953de946ee152ea81c6dfb42d2b3\",\n    \"address\": \"0xfecA834E7da9D437645b474450688DA9327112a5\",\n    \"blockHash\": \"0x054de9a496fc7d10303068cbc7ee3e25181a3b26640497859a5e49f0342e7db2\",\n    \"blockNumber\": 7265022\n}\n:param from_block: Block to start querying from\n:param to_block: Block to stop querying from\n:param from_address: Address sending the erc20 transfer\n:param to_address: Address receiving the erc20 transfer\n:param token_address: Address of the token\n:return: List of events\n:throws: ReadTimeout", "id": "f11251:c12:m3"}
{"signature": "def send_eth_to(self, private_key: str, to: str, gas_price: int, value: int, gas: int=<NUM_LIT>,<EOL>retry: bool = False, block_identifier=None, max_eth_to_send: int = <NUM_LIT:0>) -> bytes:", "body": "assert check_checksum(to)<EOL>if max_eth_to_send and value > self.w3.toWei(max_eth_to_send, '<STR_LIT>'):<EOL><INDENT>raise EtherLimitExceeded('<STR_LIT>' % (value, max_eth_to_send))<EOL><DEDENT>tx = {<EOL>'<STR_LIT:to>': to,<EOL>'<STR_LIT:value>': value,<EOL>'<STR_LIT>': gas,<EOL>'<STR_LIT>': gas_price,<EOL>}<EOL>return self.send_unsigned_transaction(tx, private_key=private_key, retry=retry,<EOL>block_identifier=block_identifier)<EOL>", "docstring": "Send ether using configured account\n:param to: to\n:param gas_price: gas_price\n:param value: value(wei)\n:param gas: gas, defaults to 22000\n:param retry: Retry if a problem is found\n:param block_identifier: None default, 'pending' not confirmed txs\n:return: tx_hash", "id": "f11251:c14:m14"}
{"signature": "def execute(self,<EOL>tx_sender_private_key: str,<EOL>tx_gas: Optional[int] = None,<EOL>tx_gas_price: Optional[int] = None,<EOL>tx_nonce: Optional[int] = None,<EOL>block_identifier='<STR_LIT>') -> Tuple[bytes, Dict[str, any]]:", "body": "tx_gas_price = tx_gas_price or self.gas_price  <EOL>tx_gas = tx_gas or (self.safe_tx_gas + self.data_gas) * <NUM_LIT:2><EOL>tx_sender_address = Account.privateKeyToAccount(tx_sender_private_key).address<EOL>tx_parameters = {<EOL>'<STR_LIT>': tx_sender_address,<EOL>'<STR_LIT>': tx_gas,<EOL>'<STR_LIT>': tx_gas_price,<EOL>}<EOL>if tx_nonce is not None:<EOL><INDENT>tx_parameters['<STR_LIT>'] = tx_nonce<EOL><DEDENT>self.tx = self.w3_tx.buildTransaction(tx_parameters)<EOL>self.tx_hash = self.ethereum_client.send_unsigned_transaction(self.tx,<EOL>private_key=tx_sender_private_key,<EOL>retry=True,<EOL>block_identifier=block_identifier)<EOL>return self.tx_hash, self.tx<EOL>", "docstring": "Send multisig tx to the Safe\n:param tx_sender_private_key: Sender private key\n:param tx_gas: Gas for the external tx. If not, `(safe_tx_gas + data_gas) * 2` will be used\n:param tx_gas_price: Gas price of the external tx. If not, `gas_price` will be used\n:param tx_nonce: Force nonce for `tx_sender`\n:param block_identifier: `latest` or `pending`\n:return: Tuple(tx_hash, tx)\n:raises: InvalidMultisigTx: If user tx cannot go through the Safe", "id": "f11261:c0:m7"}
{"signature": "def estimate_tx_operational_gas(self, safe_address: str, data_bytes_length: int):", "body": "threshold = self.retrieve_threshold(safe_address)<EOL>return <NUM_LIT> + data_bytes_length // <NUM_LIT:32> * <NUM_LIT:100> + <NUM_LIT> * threshold<EOL>", "docstring": "Estimates the gas for the verification of the signatures and other safe related tasks\nbefore and after executing a transaction.\nCalculation will be the sum of:\n  - Base cost of 15000 gas\n  - 100 of gas per word of `data_bytes`\n  - Validate the signatures 5000 * threshold (ecrecover for ecdsa ~= 4K gas)\n:param safe_address: Address of the safe\n:param data_bytes_length: Length of the data (in bytes, so `len(HexBytes('0x12'))` would be `1`\n:return: gas costs per signature * threshold of Safe", "id": "f11263:c3:m20"}
{"signature": "def check_proxy_code(self, address) -> bool:", "body": "deployed_proxy_code = self.w3.eth.getCode(address)<EOL>proxy_code_fns = (get_paying_proxy_deployed_bytecode,<EOL>get_proxy_factory_contract(self.w3,<EOL>self.proxy_factory_address).functions.proxyRuntimeCode().call)<EOL>for proxy_code_fn in proxy_code_fns:<EOL><INDENT>if deployed_proxy_code == proxy_code_fn():<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Check if proxy is valid\n:param address: address of the proxy\n:return: True if proxy is valid, False otherwise", "id": "f11263:c3:m7"}
{"signature": "def estimate_tx_gas_with_web3(self, safe_address: str, to: str, value: int, data: bytes) -> int:", "body": "return self.ethereum_client.estimate_gas(safe_address, to, value, data, block_identifier='<STR_LIT>')<EOL>", "docstring": "Estimate tx gas using web3", "id": "f11263:c3:m18"}
{"signature": "def deploy_proxy_factory_contract(self, deployer_account=None, deployer_private_key=None) -> str:", "body": "assert deployer_account or deployer_private_key<EOL>deployer_address = deployer_account or self.ethereum_client.private_key_to_address(deployer_private_key)<EOL>proxy_factory_contract = get_proxy_factory_contract(self.w3)<EOL>tx = proxy_factory_contract.constructor().buildTransaction({'<STR_LIT>': deployer_address})<EOL>tx_hash = self.ethereum_client.send_unsigned_transaction(tx, private_key=deployer_private_key,<EOL>public_key=deployer_account)<EOL>tx_receipt = self.ethereum_client.get_transaction_receipt(tx_hash, timeout=<NUM_LIT>)<EOL>assert tx_receipt.status<EOL>contract_address = tx_receipt.contractAddress<EOL>logger.info(\"<STR_LIT>\", contract_address, deployer_address)<EOL>return contract_address<EOL>", "docstring": "Deploy proxy factory contract. Takes deployer_account (if unlocked in the node) or the deployer private key\n:param deployer_account: Unlocked ethereum account\n:param deployer_private_key: Private key of an ethereum account\n:return: deployed contract address", "id": "f11263:c3:m14"}
{"signature": "def deploy_old_master_contract(self, deployer_account=None, deployer_private_key=None) -> str:", "body": "assert deployer_account or deployer_private_key<EOL>deployer_address = deployer_account or self.ethereum_client.private_key_to_address(deployer_private_key)<EOL>safe_contract = get_old_safe_contract(self.w3)<EOL>tx = safe_contract.constructor().buildTransaction({'<STR_LIT>': deployer_address})<EOL>tx_hash = self.ethereum_client.send_unsigned_transaction(tx, private_key=deployer_private_key,<EOL>public_key=deployer_account)<EOL>tx_receipt = self.ethereum_client.get_transaction_receipt(tx_hash, timeout=<NUM_LIT>)<EOL>assert tx_receipt.status<EOL>contract_address = tx_receipt.contractAddress<EOL>master_safe = get_old_safe_contract(self.w3, contract_address)<EOL>tx = master_safe.functions.setup(<EOL>[\"<STR_LIT>\", \"<STR_LIT>\"],<EOL><NUM_LIT:2>,             <EOL>NULL_ADDRESS,  <EOL>b'<STR_LIT>'            <EOL>).buildTransaction({'<STR_LIT>': deployer_address})<EOL>tx_hash = self.ethereum_client.send_unsigned_transaction(tx, private_key=deployer_private_key,<EOL>public_key=deployer_account)<EOL>tx_receipt = self.ethereum_client.get_transaction_receipt(tx_hash, timeout=<NUM_LIT>)<EOL>assert tx_receipt.status<EOL>logger.info(\"<STR_LIT>\", contract_address, deployer_address)<EOL>return contract_address<EOL>", "docstring": "Deploy master contract. Takes deployer_account (if unlocked in the node) or the deployer private key\n:param deployer_account: Unlocked ethereum account\n:param deployer_private_key: Private key of an ethereum account\n:return: deployed contract address", "id": "f11263:c3:m10"}
{"signature": "def deploy_master_contract(self, deployer_account=None, deployer_private_key=None) -> str:", "body": "assert deployer_account or deployer_private_key<EOL>deployer_address = deployer_account or self.ethereum_client.private_key_to_address(deployer_private_key)<EOL>safe_contract = self.get_contract()<EOL>tx = safe_contract.constructor().buildTransaction({'<STR_LIT>': deployer_address})<EOL>tx_hash = self.ethereum_client.send_unsigned_transaction(tx, private_key=deployer_private_key,<EOL>public_key=deployer_account)<EOL>tx_receipt = self.ethereum_client.get_transaction_receipt(tx_hash, timeout=<NUM_LIT>)<EOL>assert tx_receipt.status<EOL>contract_address = tx_receipt.contractAddress<EOL>master_safe = self.get_contract(contract_address)<EOL>tx = master_safe.functions.setup(<EOL>[\"<STR_LIT>\", \"<STR_LIT>\"],<EOL><NUM_LIT:2>,             <EOL>NULL_ADDRESS,  <EOL>b'<STR_LIT>',           <EOL>NULL_ADDRESS,  <EOL><NUM_LIT:0>,             <EOL>NULL_ADDRESS   <EOL>).buildTransaction({'<STR_LIT>': deployer_address})<EOL>tx_hash = self.ethereum_client.send_unsigned_transaction(tx, private_key=deployer_private_key,<EOL>public_key=deployer_account)<EOL>tx_receipt = self.ethereum_client.get_transaction_receipt(tx_hash, timeout=<NUM_LIT>)<EOL>assert tx_receipt.status<EOL>logger.info(\"<STR_LIT>\", contract_address, deployer_address)<EOL>return contract_address<EOL>", "docstring": "Deploy master contract. Takes deployer_account (if unlocked in the node) or the deployer private key\n:param deployer_account: Unlocked ethereum account\n:param deployer_private_key: Private key of an ethereum account\n:return: deployed contract address", "id": "f11263:c3:m9"}
{"signature": "def estimate_tx_gas_with_safe(self, safe_address: str, to: str, value: int, data: bytes, operation: int,<EOL>block_identifier='<STR_LIT>') -> int:", "body": "data = data or b'<STR_LIT>'<EOL>def parse_revert_data(result: bytes) -> int:<EOL><INDENT>gas_estimation_offset = <NUM_LIT:4> + <NUM_LIT:32> + <NUM_LIT:32><EOL>estimated_gas = result[gas_estimation_offset:]<EOL>if len(estimated_gas) != <NUM_LIT:32>:<EOL><INDENT>logger.warning('<STR_LIT>',<EOL>safe_address, result.hex(), tx)<EOL>raise CannotEstimateGas('<STR_LIT>' % (result.hex(), tx))<EOL><DEDENT>return int(estimated_gas.hex(), <NUM_LIT:16>)<EOL><DEDENT>try:<EOL><INDENT>tx = self.get_contract(safe_address).functions.requiredTxGas(<EOL>to,<EOL>value,<EOL>data,<EOL>operation<EOL>).buildTransaction({<EOL>'<STR_LIT>': safe_address,<EOL>'<STR_LIT>': int(<NUM_LIT>),<EOL>'<STR_LIT>': <NUM_LIT:0>,<EOL>})<EOL>result: HexBytes = self.w3.eth.call(tx, block_identifier=block_identifier)<EOL>return parse_revert_data(result)<EOL><DEDENT>except ValueError as exc:  <EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>error_dict = exc.args[<NUM_LIT:0>]<EOL>data = error_dict.get('<STR_LIT:data>')<EOL>if not data:<EOL><INDENT>raise exc<EOL><DEDENT>elif isinstance(data, str) and '<STR_LIT>' in data:<EOL><INDENT>result = HexBytes(data.replace('<STR_LIT>', '<STR_LIT>'))<EOL>return parse_revert_data(result)<EOL><DEDENT>key = list(data.keys())[<NUM_LIT:0>]<EOL>result = data[key]['<STR_LIT>']<EOL>if result == '<STR_LIT>':<EOL><INDENT>raise exc<EOL><DEDENT>else:<EOL><INDENT>logger.warning('<STR_LIT>')<EOL>estimated_gas_hex = result[<NUM_LIT>:]<EOL>assert len(estimated_gas_hex) == <NUM_LIT:64><EOL>estimated_gas = int(estimated_gas_hex, <NUM_LIT:16>)<EOL>return estimated_gas<EOL><DEDENT><DEDENT>", "docstring": "Estimate tx gas using safe `requiredTxGas` method\n:return: int: Estimated gas\n:raises: CannotEstimateGas: If gas cannot be estimated\n:raises: ValueError: Cannot decode received data", "id": "f11263:c3:m17"}
{"signature": "def deploy_paying_proxy_contract(self, initializer=b'<STR_LIT>', deployer_account=None, deployer_private_key=None) -> str:", "body": "assert deployer_account or deployer_private_key<EOL>deployer_address = deployer_account or self.ethereum_client.private_key_to_address(deployer_private_key)<EOL>safe_proxy_contract = get_paying_proxy_contract(self.w3)<EOL>tx = safe_proxy_contract.constructor(self.master_copy_address, initializer,<EOL>NULL_ADDRESS,<EOL>NULL_ADDRESS, <NUM_LIT:0>).buildTransaction({'<STR_LIT>': deployer_address})<EOL>tx_hash = self.ethereum_client.send_unsigned_transaction(tx, private_key=deployer_private_key,<EOL>public_key=deployer_account)<EOL>tx_receipt = self.ethereum_client.get_transaction_receipt(tx_hash, timeout=<NUM_LIT>)<EOL>assert tx_receipt.status<EOL>return tx_receipt.contractAddress<EOL>", "docstring": "Deploy proxy contract. Takes deployer_account (if unlocked in the node) or the deployer private key\n:param initializer: Initializer\n:param deployer_account: Unlocked ethereum account\n:param deployer_private_key: Private key of an ethereum account\n:return: deployed contract address", "id": "f11263:c3:m11"}
{"signature": "def _estimate_gas(self, initializer: bytes, salt_nonce: int,<EOL>payment_token: str, payment_receiver: str) -> int:", "body": "<EOL>gas: int = self.proxy_factory_contract.functions.createProxyWithNonce(self.master_copy_address,<EOL>initializer, salt_nonce).estimateGas()<EOL>payment: int = <NUM_LIT:1><EOL>if payment_token == NULL_ADDRESS:<EOL><INDENT>gas += self.w3.eth.estimateGas({'<STR_LIT:to>': payment_receiver, '<STR_LIT:value>': payment})<EOL><DEDENT>else:<EOL><INDENT>gas += <NUM_LIT><EOL><DEDENT>return gas<EOL>", "docstring": "Gas estimation done using web3 and calling the node\nPayment cannot be estimated, as no ether is in the address. So we add some gas later.\n:param initializer: Data initializer to send to GnosisSafe setup method\n:param salt_nonce: Nonce that will be used to generate the salt to calculate\nthe address of the new proxy contract.\n:return: Total gas estimation", "id": "f11265:c2:m5"}
{"signature": "def __init__(self, w3: Web3, owners: List[str], threshold: int, signature_s: int, master_copy: str,<EOL>gas_price: int, funder: Optional[str], payment_token: Optional[str] = None,<EOL>payment_token_eth_value: float = <NUM_LIT:1.0>, fixed_creation_cost: Optional[int] = None):", "body": "assert <NUM_LIT:0> < threshold <= len(owners)<EOL>funder = funder or NULL_ADDRESS<EOL>payment_token = payment_token or NULL_ADDRESS<EOL>assert Web3.isChecksumAddress(master_copy)<EOL>assert Web3.isChecksumAddress(funder)<EOL>assert Web3.isChecksumAddress(payment_token)<EOL>self.w3 = w3<EOL>self.owners = owners<EOL>self.threshold = threshold<EOL>self.s = signature_s<EOL>self.master_copy = master_copy<EOL>self.gas_price = gas_price<EOL>self.funder = funder<EOL>self.payment_token = payment_token<EOL>self.payment_token_eth_value = payment_token_eth_value<EOL>self.fixed_creation_cost = fixed_creation_cost<EOL>safe_setup_data: bytes = self._get_initial_setup_safe_data(owners, threshold)<EOL>calculated_gas: int = self._calculate_gas(owners, safe_setup_data, payment_token)<EOL>estimated_gas: int = self._estimate_gas(master_copy, safe_setup_data, funder, payment_token)<EOL>self.gas = max(calculated_gas, estimated_gas)<EOL>self.payment = self._calculate_refund_payment(self.gas,<EOL>gas_price,<EOL>fixed_creation_cost,<EOL>payment_token_eth_value)<EOL>self.tx_dict: Dict[str, any] = self._build_proxy_contract_creation_tx(master_copy=master_copy,<EOL>initializer=safe_setup_data,<EOL>funder=funder,<EOL>payment_token=payment_token,<EOL>payment=self.payment,<EOL>gas=self.gas,<EOL>gas_price=gas_price)<EOL>self.tx_pyethereum: Transaction = self._build_contract_creation_tx_with_valid_signature(self.tx_dict, self.s)<EOL>self.tx_raw = rlp.encode(self.tx_pyethereum)<EOL>self.tx_hash = self.tx_pyethereum.hash<EOL>self.deployer_address = checksum_encode(self.tx_pyethereum.sender)<EOL>self.safe_address = checksum_encode(self.tx_pyethereum.creates)<EOL>self.v = self.tx_pyethereum.v<EOL>self.r = self.tx_pyethereum.r<EOL>assert checksum_encode(mk_contract_address(self.deployer_address, nonce=<NUM_LIT:0>)) == self.safe_address<EOL>", "docstring": "Prepare Safe creation\n:param w3: Web3 instance\n:param owners: Owners of the Safe\n:param threshold: Minimum number of users required to operate the Safe\n:param signature_s: Random s value for ecdsa signature\n:param master_copy: Safe master copy address\n:param gas_price: Gas Price\n:param funder: Address to refund when the Safe is created. Address(0) if no need to refund\n:param payment_token: Payment token instead of paying the funder with ether. If None Ether will be used\n:param payment_token_eth_value: Value of payment token per 1 Ether\n:param fixed_creation_cost: Fixed creation cost of Safe (Wei)", "id": "f11268:c1:m0"}
{"signature": "def _build_proxy_contract_creation_constructor(self,<EOL>master_copy: str,<EOL>initializer: bytes,<EOL>funder: str,<EOL>payment_token: str,<EOL>payment: int) -> ContractConstructor:", "body": "if not funder or funder == NULL_ADDRESS:<EOL><INDENT>funder = NULL_ADDRESS<EOL>payment = <NUM_LIT:0><EOL><DEDENT>return get_paying_proxy_contract(self.w3).constructor(<EOL>master_copy,<EOL>initializer,<EOL>funder,<EOL>payment_token,<EOL>payment)<EOL>", "docstring": ":param master_copy: Master Copy of Gnosis Safe already deployed\n:param initializer: Data initializer to send to GnosisSafe setup method\n:param funder: Address that should get the payment (if payment set)\n:param payment_token: Address if a token is used. If not set, 0x0 will be ether\n:param payment: Payment\n:return: Transaction dictionary", "id": "f11268:c1:m5"}
{"signature": "@staticmethod<EOL><INDENT>def _sign_web3_transaction(tx: Dict[str, any], v: int, r: int, s: int) -> (bytes, HexBytes):<DEDENT>", "body": "unsigned_transaction = serializable_unsigned_transaction_from_dict(tx)<EOL>rlp_encoded_transaction = encode_transaction(unsigned_transaction, vrs=(v, r, s))<EOL>return rlp_encoded_transaction, unsigned_transaction.hash()<EOL>", "docstring": "Signed transaction that compatible with `w3.eth.sendRawTransaction`\nIs not used because `pyEthereum` implementation of Transaction was found to be more\nrobust regarding invalid signatures", "id": "f11268:c1:m10"}
{"signature": "def api_auth(function=None):", "body": "def real_decorator(func):<EOL><INDENT>def wrapped(request, *args, **kwargs):<EOL><INDENT>try:<EOL><INDENT>user = _auth_url(request.get_full_path(), request.body)<EOL>request.user = user  <EOL><DEDENT>except Exception as e:<EOL><INDENT>return JsonResponse({\"<STR_LIT:error>\": str(e)}, status=<NUM_LIT>)<EOL><DEDENT>return func(request, *args, **kwargs)<EOL><DEDENT>setattr(wrapped, '<STR_LIT>', True)<EOL>return wrapped<EOL><DEDENT>return real_decorator if not function else real_decorator(function)<EOL>", "docstring": "check:\n1, timestamp in reasonable range\n2, api key exists\n3, entry point allowed for this api key\n4, signature correctness\n\neffect:\n- add user object in request if the api key is binding with an user", "id": "f11279:m2"}
{"signature": "def is_protected_api(u):", "body": "return u.callback and getattr(u.callback, \"<STR_LIT>\", False)<EOL>", "docstring": "if a url is registered as protected", "id": "f11280:m2"}
{"signature": "def validate(self, *args, **kwargs):", "body": "valid = FlaskForm.validate(self, *args, **kwargs)<EOL>if not valid:<EOL><INDENT>logging.debug(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(self.errors))<EOL>return valid<EOL><DEDENT>return self.validate_ldap()<EOL>", "docstring": "Validates the form by calling `validate` on each field, passing any\nextra `Form.validate_<fieldname>` validators to the field validator.\n\nalso calls `validate_ldap`", "id": "f11296:c1:m1"}
{"signature": "def init_config(self, config):", "body": "self.config.update(config)<EOL>self.config.setdefault('<STR_LIT>', <NUM_LIT>)<EOL>self.config.setdefault('<STR_LIT>', None)<EOL>self.config.setdefault('<STR_LIT>', False)<EOL>self.config.setdefault('<STR_LIT>', True)<EOL>self.config.setdefault('<STR_LIT>', True)<EOL>self.config.setdefault('<STR_LIT>', False)<EOL>self.config.setdefault('<STR_LIT>', '<STR_LIT>')<EOL>self.config.setdefault('<STR_LIT>', '<STR_LIT>')<EOL>self.config.setdefault('<STR_LIT>', True)<EOL>self.config.setdefault('<STR_LIT>', False)<EOL>self.config.setdefault('<STR_LIT>', '<STR_LIT>')<EOL>self.config.setdefault('<STR_LIT>', None)<EOL>self.config.setdefault('<STR_LIT>', None)<EOL>self.config.setdefault('<STR_LIT>', True)<EOL>self.config.setdefault('<STR_LIT>', False)<EOL>self.config.setdefault('<STR_LIT>', '<STR_LIT>')<EOL>self.config.setdefault('<STR_LIT>', '<STR_LIT>')<EOL>self.config.setdefault('<STR_LIT>', '<STR_LIT>')<EOL>self.config.setdefault('<STR_LIT>',<EOL>'<STR_LIT>')<EOL>self.config.setdefault('<STR_LIT>',<EOL>'<STR_LIT>')<EOL>self.config.setdefault('<STR_LIT>', '<STR_LIT>')<EOL>self.config.setdefault('<STR_LIT>', '<STR_LIT>')<EOL>self.config.setdefault(<EOL>'<STR_LIT>', ldap3.ALL_ATTRIBUTES)<EOL>self.config.setdefault('<STR_LIT>',<EOL>'<STR_LIT>')<EOL>self.config.setdefault(<EOL>'<STR_LIT>', '<STR_LIT>')<EOL>self.config.setdefault('<STR_LIT>', '<STR_LIT>')<EOL>self.config.setdefault(<EOL>'<STR_LIT>', ldap3.ALL_ATTRIBUTES)<EOL>self.config.setdefault('<STR_LIT>', True)<EOL>if self.config['<STR_LIT>']:<EOL><INDENT>self.add_server(<EOL>hostname=self.config['<STR_LIT>'],<EOL>port=self.config['<STR_LIT>'],<EOL>use_ssl=self.config['<STR_LIT>']<EOL>)<EOL><DEDENT>", "docstring": "Configures this extension with a given configuration dictionary.\nThis allows use of this extension without a flask app.\n\nArgs:\n    config (dict): A dictionary with configuration keys", "id": "f11297:c1:m2"}
{"signature": "@property<EOL><INDENT>def connection(self):<DEDENT>", "body": "ctx = stack.top<EOL>if ctx is None:<EOL><INDENT>raise Exception(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>if hasattr(ctx, '<STR_LIT>'):<EOL><INDENT>return ctx.ldap3_manager_main_connection<EOL><DEDENT>else:<EOL><INDENT>connection = self._make_connection(<EOL>bind_user=self.config.get('<STR_LIT>'),<EOL>bind_password=self.config.get('<STR_LIT>'),<EOL>contextualise=False<EOL>)<EOL>connection.bind()<EOL>if ctx is not None:<EOL><INDENT>ctx.ldap3_manager_main_connection = connection<EOL><DEDENT>return connection<EOL><DEDENT>", "docstring": "Convenience property for externally accessing an authenticated\nconnection to the server. This connection is automatically\nhandled by the appcontext, so you do not have to perform an unbind.\n\nReturns:\n    ldap3.Connection: A bound ldap3.Connection\nRaises:\n    ldap3.core.exceptions.LDAPException: Since this method is performing\n        a bind on behalf of the caller. You should handle this case\n        occuring, such as invalid service credentials.", "id": "f11297:c1:m17"}
{"signature": "@property<EOL><INDENT>def full_group_search_dn(self):<DEDENT>", "body": "return self.compiled_sub_dn(self.config.get('<STR_LIT>'))<EOL>", "docstring": "Returns a the base search DN with the group search DN prepended.\n\nReturns:\n    str: Full group search dn", "id": "f11297:c1:m22"}
{"signature": "def authenticate_direct_bind(self, username, password):", "body": "bind_user = '<STR_LIT>'.format(<EOL>rdn=self.config.get('<STR_LIT>'),<EOL>username=username,<EOL>user_search_dn=self.full_user_search_dn,<EOL>)<EOL>connection = self._make_connection(<EOL>bind_user=bind_user,<EOL>bind_password=password,<EOL>)<EOL>response = AuthenticationResponse()<EOL>try:<EOL><INDENT>connection.bind()<EOL>log.debug(<EOL>\"<STR_LIT>\".format(username))<EOL>response.status = AuthenticationResponseStatus.success<EOL>user_info = self.get_user_info(<EOL>dn=bind_user, _connection=connection)<EOL>response.user_dn = bind_user<EOL>response.user_id = username<EOL>response.user_info = user_info<EOL>if self.config.get('<STR_LIT>'):<EOL><INDENT>response.user_groups = self.get_user_groups(<EOL>dn=bind_user, _connection=connection)<EOL><DEDENT><DEDENT>except ldap3.core.exceptions.LDAPInvalidCredentialsResult:<EOL><INDENT>log.debug(<EOL>\"<STR_LIT>\".format(username))<EOL>response.status = AuthenticationResponseStatus.fail<EOL><DEDENT>except Exception as e:<EOL><INDENT>log.error(e)<EOL>response.status = AuthenticationResponseStatus.fail<EOL><DEDENT>self.destroy_connection(connection)<EOL>return response<EOL>", "docstring": "Performs a direct bind. We can do this since the RDN is the same\nas the login attribute. Hence we just string together a dn to find\nthis user with.\n\nArgs:\n    username (str): Username of the user to bind (the field specified\n        as LDAP_BIND_RDN_ATTR)\n    password (str): User's password to bind with.\n\nReturns:\n    AuthenticationResponse", "id": "f11297:c1:m10"}
{"signature": "def get_user_info_for_username(self, username, _connection=None):", "body": "ldap_filter = '<STR_LIT>'.format(<EOL>self.config.get('<STR_LIT>'),<EOL>username,<EOL>self.config.get('<STR_LIT>')<EOL>)<EOL>return self.get_object(<EOL>dn=self.full_user_search_dn,<EOL>filter=ldap_filter,<EOL>attributes=self.config.get(\"<STR_LIT>\"),<EOL>_connection=_connection,<EOL>)<EOL>", "docstring": "Gets info about a user at a specified username by searching the\nUsers DN. Username attribute is the same as specified as\nLDAP_USER_LOGIN_ATTR.\n\n\nArgs:\n    username (str): Username of the user to search for.\n    _connection (ldap3.Connection): A connection object to use when\n        searching. If not given, a temporary connection will be\n        created, and destroyed after use.\nReturns:\n    dict: A dictionary of the user info from LDAP", "id": "f11297:c1:m14"}
{"signature": "@property<EOL><INDENT>def full_user_search_dn(self):<DEDENT>", "body": "return self.compiled_sub_dn(self.config.get('<STR_LIT>'))<EOL>", "docstring": "Returns a the base search DN with the user search DN prepended.\n\nReturns:\n    str: Full user search dn", "id": "f11297:c1:m21"}
{"signature": "def destroy_connection(self, connection):", "body": "log.debug(\"<STR_LIT>\".format(hex(id(connection))))<EOL>self._decontextualise_connection(connection)<EOL>connection.unbind()<EOL>", "docstring": "Destroys a connection. Removes the connection from the appcontext, and\nunbinds it.\n\nArgs:\n    connection (ldap3.Connection):  The connnection to destroy", "id": "f11297:c1:m20"}
{"signature": "def teardown(self, exception):", "body": "ctx = stack.top<EOL>if ctx is not None:<EOL><INDENT>if hasattr(ctx, '<STR_LIT>'):<EOL><INDENT>for connection in ctx.ldap3_manager_connections:<EOL><INDENT>self.destroy_connection(connection)<EOL><DEDENT><DEDENT>if hasattr(ctx, '<STR_LIT>'):<EOL><INDENT>log.debug(<EOL>\"<STR_LIT>\")<EOL>ctx.ldap3_manager_main_connection.unbind()<EOL>ctx.ldap3_manager_main_connection = None<EOL><DEDENT><DEDENT>", "docstring": "Cleanup after a request. Close any open connections.", "id": "f11297:c1:m6"}
{"signature": "def get_global_settings(self):", "body": "return dict((key, getattr(global_settings, key)) for key in dir(global_settings)<EOL>if key.isupper())<EOL>", "docstring": "Return a dictionary of all global_settings values.", "id": "f11312:c0:m1"}
{"signature": "def without_apps(*apps):", "body": "apps_list = [a for a in settings.INSTALLED_APPS if a not in apps]<EOL>return override_settings(INSTALLED_APPS=apps_list)<EOL>", "docstring": "Class decorator that makes sure the passed apps are not present in\nINSTALLED_APPS.", "id": "f11312:m1"}
{"signature": "def add_prices_for_yesterday_and_today(session, symbol: SecuritySymbol):", "body": "app = PriceDbApplication(session)<EOL>assert isinstance(symbol, SecuritySymbol)<EOL>price = PriceModel()<EOL>price.datum = Datum()<EOL>price.currency = \"<STR_LIT>\"<EOL>price.symbol = symbol<EOL>price.value = Decimal(\"<STR_LIT>\")<EOL>app.add_price(price)<EOL>price.datum.yesterday()<EOL>price.value = Decimal(\"<STR_LIT>\")<EOL>app.add_price(price)<EOL>", "docstring": "Add prices for the same symbol for yesterday and today", "id": "f11318:m3"}
{"signature": "def save(self):", "body": "file_path = self.get_config_path()<EOL>contents = self.get_contents()<EOL>with open(file_path, mode='<STR_LIT:w>') as cfg_file:<EOL><INDENT>cfg_file.write(contents)<EOL><DEDENT>", "docstring": "Save the config file", "id": "f11327:c1:m10"}
{"signature": "def __get_config_template_path(self) -> str:", "body": "filename = resource_filename(<EOL>Requirement.parse(package_name),<EOL>template_path + config_filename)<EOL>return filename<EOL>", "docstring": "gets the default config path from resources", "id": "f11327:c1:m3"}
{"signature": "def set(self, option: ConfigKeys, value):", "body": "assert isinstance(option, ConfigKeys)<EOL>section = SECTION<EOL>self.config.set(section, option.name, value)<EOL>self.save()<EOL>", "docstring": "Sets a value in config", "id": "f11327:c1:m8"}
{"signature": "def __create_user_config(self):", "body": "src_path = self.__get_config_template_path()<EOL>src = os.path.abspath(src_path)<EOL>if not os.path.exists(src):<EOL><INDENT>message = f\"<STR_LIT>\"<EOL>self.logger.error(message)<EOL>raise FileNotFoundError(message)<EOL><DEDENT>dst = os.path.abspath(self.get_config_path())<EOL>shutil.copyfile(src, dst)<EOL>if not os.path.exists(dst):<EOL><INDENT>raise FileNotFoundError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Copy the config template into user's directory", "id": "f11327:c1:m5"}
{"signature": "@click.command(\"<STR_LIT>\")<EOL>@click.option(\"<STR_LIT>\", \"<STR_LIT>\", is_flag=True, help=\"<STR_LIT>\")<EOL>@click.option(\"<STR_LIT>\", \"<STR_LIT>\", help=\"<STR_LIT>\")<EOL>@click_log.simple_verbosity_option(logger)<EOL>def prune(symbol: str, all: str):", "body": "app = PriceDbApplication()<EOL>app.logger = logger<EOL>count = <NUM_LIT:0><EOL>if symbol is not None:<EOL><INDENT>sec_symbol = SecuritySymbol(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>sec_symbol.parse(symbol)<EOL>deleted = app.prune(sec_symbol)<EOL>if deleted:<EOL><INDENT>count = <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>count = app.prune_all()<EOL><DEDENT>print(f\"<STR_LIT>\")<EOL>", "docstring": "Delete old prices, leaving just the last.", "id": "f11329:m6"}
{"signature": "@click.group()<EOL>@click_log.simple_verbosity_option(logger)<EOL>def cli():", "body": "pass<EOL>", "docstring": "entry point", "id": "f11329:m0"}
{"signature": "@click.command(\"<STR_LIT>\")<EOL>@click.argument(\"<STR_LIT>\") <EOL>@click.argument(\"<STR_LIT>\") <EOL>@click_log.simple_verbosity_option(logger)<EOL>def import_csv(filepath: str, currency: str):", "body": "logger.debug(f\"<STR_LIT>\")<EOL>currency = currency.upper()<EOL>app = PriceDbApplication()<EOL>app.logger = logger<EOL>app.import_prices(filepath, currency)<EOL>", "docstring": "Import prices from CSV file", "id": "f11329:m2"}
{"signature": "@click.command(\"<STR_LIT>\")<EOL>@click.option(\"<STR_LIT>\", \"<STR_LIT>\", default=None, help=\"<STR_LIT>\")<EOL>@click.option(\"<STR_LIT>\", \"<STR_LIT>\", default=None, help=\"<STR_LIT>\")<EOL>@click.option(\"<STR_LIT>\", \"<STR_LIT>\", default=None,<EOL>help=\"<STR_LIT>\")<EOL>@click.option(\"<STR_LIT>\", \"<STR_LIT:-c>\", default=None, help=\"<STR_LIT>\")<EOL>@click.option(\"<STR_LIT>\", \"<STR_LIT>\", is_flag=True)<EOL>@click_log.simple_verbosity_option(logger)<EOL>@click.pass_context<EOL>def download(ctx, help: bool, symbol: str, namespace: str, agent: str, currency: str):", "body": "if help:<EOL><INDENT>click.echo(ctx.get_help())<EOL>ctx.exit()<EOL><DEDENT>app = PriceDbApplication()<EOL>app.logger = logger<EOL>if currency:<EOL><INDENT>currency = currency.strip()<EOL>currency = currency.upper()<EOL><DEDENT>app.download_prices(currency=currency, agent=agent, symbol=symbol, namespace=namespace)<EOL>", "docstring": "Download the latest prices", "id": "f11329:m5"}
{"signature": "@click.command()<EOL>@click.option(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>def last(symbol: str):", "body": "app = PriceDbApplication()<EOL>if symbol:<EOL><INDENT>symbol = symbol.upper()<EOL>sec_symbol = SecuritySymbol(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>sec_symbol.parse(symbol)<EOL>latest = app.get_latest_price(sec_symbol)<EOL>assert isinstance(latest, PriceModel)<EOL>print(f\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>latest = app.get_latest_prices()<EOL>for price in latest:<EOL><INDENT>print(f\"<STR_LIT>\")<EOL><DEDENT><DEDENT>", "docstring": "displays last price, for symbol if provided", "id": "f11329:m3"}
{"signature": "def load_file(self, file_path) -> List[str]:", "body": "content = []<EOL>content = read_lines_from_file(file_path)<EOL>return content<EOL>", "docstring": "Loads the content of the text file", "id": "f11331:c0:m2"}
{"signature": "def __load_symbol_maps(self):", "body": "repo = SymbolMapRepository(self.__get_session())<EOL>all_maps = repo.get_all()<EOL>self.symbol_maps = {}<EOL>for item in all_maps:<EOL><INDENT>self.symbol_maps[item.in_symbol] = item.out_symbol<EOL><DEDENT>", "docstring": "Loads all symbol maps from db", "id": "f11331:c0:m5"}
{"signature": "def get_session(db_path: str):", "body": "<EOL>con_str = \"<STR_LIT>\" + db_path<EOL>engine = create_engine(con_str, echo=False)<EOL>Base.metadata.create_all(engine)<EOL>Session = sessionmaker(bind=engine)<EOL>session = Session()<EOL>return session<EOL>", "docstring": "Creates and opens a database session", "id": "f11332:m1"}
{"signature": "@property<EOL><INDENT>def session(self):<DEDENT>", "body": "if not self.__session:<EOL><INDENT>self.__session = get_default_session()<EOL><DEDENT>return self.__session<EOL>", "docstring": "db session", "id": "f11334:c2:m1"}
{"signature": "@property<EOL><INDENT>def query(self):<DEDENT>", "body": "return self.session.query(Price)<EOL>", "docstring": "Base query", "id": "f11334:c1:m4"}
{"signature": "@property<EOL><INDENT>def query(self):<DEDENT>", "body": "return self.session.query(SymbolMap)<EOL>", "docstring": "Basic query", "id": "f11334:c0:m3"}
{"signature": "@property<EOL><INDENT>def session(self):<DEDENT>", "body": "if not self.__session:<EOL><INDENT>self.__session = get_default_session()<EOL><DEDENT>return self.__session<EOL>", "docstring": "db session", "id": "f11334:c1:m3"}
{"signature": "@click.group(\"<STR_LIT>\")<EOL>def symbol_map():", "body": "pass<EOL>", "docstring": "Operations with symbol maps", "id": "f11335:m0"}
{"signature": "@click.command(\"<STR_LIT>\")<EOL>@click.argument(\"<STR_LIT>\") <EOL>@click.argument(\"<STR_LIT>\") <EOL>def add_map(incoming, outgoing):", "body": "db_path = Config().get(ConfigKeys.pricedb_path)<EOL>session = get_session(db_path)<EOL>new_map = SymbolMap()<EOL>new_map.in_symbol = incoming<EOL>new_map.out_symbol = outgoing<EOL>session.add(new_map)<EOL>session.commit()<EOL>click.echo(\"<STR_LIT>\")<EOL>", "docstring": "Creates a symbol mapping", "id": "f11335:m1"}
{"signature": "def get_prices(self, date: str, currency: str) -> List[PriceModel]:", "body": "from .repositories import PriceRepository<EOL>session = self.session<EOL>repo = PriceRepository(session)<EOL>query = repo.query<EOL>if date:<EOL><INDENT>query = query.filter(dal.Price.date == date)<EOL><DEDENT>if currency:<EOL><INDENT>query = query.filter(dal.Price.currency == currency)<EOL><DEDENT>query = query.order_by(dal.Price.namespace, dal.Price.symbol)<EOL>price_entities = query.all()<EOL>mapper = mappers.PriceMapper()<EOL>result = []<EOL>for entity in price_entities:<EOL><INDENT>model = mapper.map_entity(entity)<EOL>result.append(model)<EOL><DEDENT>return result<EOL>", "docstring": "Fetches all the prices for the given arguments", "id": "f11337:c0:m8"}
{"signature": "def save(self):", "body": "if self.__session:<EOL><INDENT>self.session.commit()<EOL><DEDENT>else:<EOL><INDENT>self.logger.warning(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Save changes", "id": "f11337:c0:m15"}
{"signature": "def get_security_repository(self):", "body": "from .repositories import SecurityRepository<EOL>if not self.security_repo:<EOL><INDENT>self.security_repo = SecurityRepository(self.session)<EOL><DEDENT>return self.security_repo<EOL>", "docstring": "Security repository", "id": "f11337:c0:m12"}
{"signature": "def download_price(self, symbol: str, currency: str, agent: str) -> PriceModel:", "body": "price = self.__download_price(symbol, currency, agent)<EOL>self.save()<EOL>return price<EOL>", "docstring": "Download and save price online", "id": "f11337:c0:m3"}
{"signature": "def load_soil_sample_data(sl0):", "body": "<EOL>sl0.height = <NUM_LIT>  <EOL>sl0.phi = <NUM_LIT>  <EOL>sl0.unit_dry_weight = <NUM_LIT>  <EOL>sl0.c_a = <NUM_LIT:0><EOL>sl0.cohesion = <NUM_LIT:0><EOL>", "docstring": "Sample data for the Soil object\n:param sl0: Soil Object\n:return:", "id": "f11338:m18"}
{"signature": "def capacity_hansen_1970(sl, fd, h_l=<NUM_LIT:0>, h_b=<NUM_LIT:0>, vertical_load=<NUM_LIT:1>, slope=<NUM_LIT:0>, base_tilt=<NUM_LIT:0>, verbose=<NUM_LIT:0>, **kwargs):", "body": "if not kwargs.get(\"<STR_LIT>\", False):<EOL><INDENT>models.check_required(sl, [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"])<EOL>models.check_required(fd, [\"<STR_LIT>\", \"<STR_LIT:width>\", \"<STR_LIT>\"])<EOL><DEDENT>area_foundation = fd.length * fd.width<EOL>horizontal_load = np.sqrt(h_l ** <NUM_LIT:2> + h_b ** <NUM_LIT:2>)<EOL>c_a = <NUM_LIT> - <NUM_LIT:1.0> * sl.cohesion<EOL>fd.nq_factor = ((np.tan(np.pi / <NUM_LIT:4> + sl.phi_r / <NUM_LIT:2>)) ** <NUM_LIT:2> * np.exp(np.pi * np.tan(sl.phi_r)))<EOL>if sl.phi_r == <NUM_LIT:0>:<EOL><INDENT>fd.nc_factor = <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>fd.nc_factor = (fd.nq_factor - <NUM_LIT:1>) / np.tan(sl.phi_r)<EOL><DEDENT>fd.ng_factor = <NUM_LIT> * (fd.nq_factor - <NUM_LIT:1>) * np.tan(sl.phi_r)<EOL>if sl.phi_r == <NUM_LIT:0>:<EOL><INDENT>s_c = <NUM_LIT> * fd.width / fd.length<EOL><DEDENT>else:<EOL><INDENT>s_c = <NUM_LIT:1.0> + fd.nq_factor / fd.nc_factor * fd.width / fd.length<EOL><DEDENT>s_q = <NUM_LIT:1.0> + fd.width / fd.length * np.sin(sl.phi_r)<EOL>s_g = <NUM_LIT:1.0> - <NUM_LIT> * fd.width / fd.length<EOL>if fd.depth / fd.width > <NUM_LIT:1>:<EOL><INDENT>k = np.arctan(fd.depth / fd.width)<EOL><DEDENT>else:<EOL><INDENT>k = fd.depth / fd.width<EOL><DEDENT>d_c = <NUM_LIT:1> + <NUM_LIT> * k<EOL>if sl.phi == <NUM_LIT:0>:<EOL><INDENT>d_c = <NUM_LIT> * k<EOL><DEDENT>d_q = <NUM_LIT:1> + <NUM_LIT:2> * np.tan(sl.phi_r) * (<NUM_LIT:1> - np.sin(sl.phi_r)) ** <NUM_LIT:2> * k<EOL>d_g = <NUM_LIT:1.0><EOL>if sl.phi_r == <NUM_LIT:0>:<EOL><INDENT>i_q = <NUM_LIT:1.0><EOL>i_c = <NUM_LIT:0.5> - <NUM_LIT:0.5> * np.sqrt(<NUM_LIT:1> - horizontal_load / area_foundation * c_a)<EOL>i_g = <NUM_LIT:1.0><EOL><DEDENT>else:<EOL><INDENT>i_q = ((<NUM_LIT:1.0> - <NUM_LIT:0.5> * horizontal_load /<EOL>(vertical_load + area_foundation * c_a / np.tan(sl.phi_r))) ** <NUM_LIT:5>)<EOL>i_c = i_q - (<NUM_LIT:1> - i_q) / (fd.nq_factor - <NUM_LIT:1>)<EOL>i_g = ((<NUM_LIT:1> - (<NUM_LIT> * horizontal_load) /<EOL>(vertical_load + area_foundation * c_a / np.tan(sl.phi_r))) ** <NUM_LIT:5>)<EOL><DEDENT>if sl.phi_r == <NUM_LIT:0>:<EOL><INDENT>g_c = (slope / np.pi * <NUM_LIT>) / <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>g_c = <NUM_LIT:1.0> - (slope / np.pi * <NUM_LIT>) / <NUM_LIT><EOL><DEDENT>g_q = <NUM_LIT:1> - <NUM_LIT:0.5> * np.tan(slope) ** <NUM_LIT:5><EOL>g_g = g_q<EOL>if sl.phi_r == <NUM_LIT:0>:<EOL><INDENT>b_c = (base_tilt / np.pi * <NUM_LIT>) / <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>b_c = <NUM_LIT:1.0> - (base_tilt / np.pi * <NUM_LIT>) / <NUM_LIT><EOL><DEDENT>b_q = (np.exp(-<NUM_LIT> * (base_tilt / np.pi * <NUM_LIT>) * np.tan(sl.phi_r)))<EOL>b_g = (np.exp(-<NUM_LIT> * (base_tilt / np.pi * <NUM_LIT>) * np.tan(sl.phi_r)))<EOL>if verbose:<EOL><INDENT>log(\"<STR_LIT>\", fd.nc_factor)<EOL>log(\"<STR_LIT>\", fd.nq_factor)<EOL>log(\"<STR_LIT>\", fd.ng_factor)<EOL>log(\"<STR_LIT>\", s_c)<EOL>log(\"<STR_LIT>\", s_q)<EOL>log(\"<STR_LIT>\", s_g)<EOL>log(\"<STR_LIT>\", d_c)<EOL>log(\"<STR_LIT>\", d_q)<EOL>log(\"<STR_LIT>\", d_g)<EOL>log(\"<STR_LIT>\", i_c)<EOL>log(\"<STR_LIT>\", i_q)<EOL>log(\"<STR_LIT>\", i_g)<EOL>log(\"<STR_LIT>\", g_c)<EOL>log(\"<STR_LIT>\", g_q)<EOL>log(\"<STR_LIT>\", g_g)<EOL>log(\"<STR_LIT>\", b_c)<EOL>log(\"<STR_LIT>\", b_q)<EOL>log(\"<STR_LIT>\", b_g)<EOL><DEDENT>q_d = sl.unit_dry_weight * fd.depth<EOL>if sl.phi_r == <NUM_LIT:0>:<EOL><INDENT>fd.q_ult = (sl.cohesion * fd.nc_factor *<EOL>(<NUM_LIT:1> + s_c + d_c - i_c - g_c - b_c) + q_d)<EOL><DEDENT>else:<EOL><INDENT>fd.q_ult = (sl.cohesion * fd.nc_factor *<EOL>s_c * d_c * i_c * g_c * b_c +<EOL>q_d * fd.nq_factor * s_q * d_q * i_q * g_q * b_q +<EOL><NUM_LIT:0.5> * fd.width * sl.unit_dry_weight *<EOL>fd.ng_factor * s_g * d_g * i_g * g_g * b_g)<EOL><DEDENT>", "docstring": "Calculates the foundation capacity according Hansen (1970)\nRef: http://bestengineeringprojects.com/civil-projects/\nhansens-bearing-capacity-theory/\n\n:param sl: Soil object\n:param fd: Foundation object\n:param h_l: Horizontal load parallel to length\n:param h_b: Horizontal load parallel to width\n:param vertical_load: Vertical load\n:param slope: ground slope\n:param base_tilt: The slope of the underside of the foundation\n:param verbose: verbosity\n:return: ultimate bearing stress", "id": "f11348:m2"}
{"signature": "def size_footing_for_capacity(sl, vertical_load, fos=<NUM_LIT:1.0>, length_to_width=<NUM_LIT:1.0>, verbose=<NUM_LIT:0>, **kwargs):", "body": "method = kwargs.get(\"<STR_LIT>\", '<STR_LIT>')<EOL>depth_to_width = kwargs.get(\"<STR_LIT>\", <NUM_LIT:0>)<EOL>depth = kwargs.get(\"<STR_LIT>\", <NUM_LIT:0>)<EOL>use_depth_to_width = <NUM_LIT:0><EOL>if not depth:<EOL><INDENT>use_depth_to_width = <NUM_LIT:1><EOL><DEDENT>fd = models.FoundationRaft()<EOL>fd.width = <NUM_LIT>  <EOL>for i in range(<NUM_LIT:50>):<EOL><INDENT>fd.length = length_to_width * fd.width<EOL>if use_depth_to_width:<EOL><INDENT>fd.depth = depth_to_width * fd.width<EOL><DEDENT>capacity_method_selector(sl, fd, method)<EOL>q = fd.q_ult<EOL>bearing_capacity = q * fd.length * fd.width<EOL>fs_actual = bearing_capacity / vertical_load<EOL>if fs_actual < fos:<EOL><INDENT>fd.width += <NUM_LIT:0.5><EOL><DEDENT>else:<EOL><INDENT>if verbose:<EOL><INDENT>log(\"<STR_LIT>\", fs_actual)<EOL>log(\"<STR_LIT>\", fd.width)<EOL><DEDENT>break<EOL><DEDENT><DEDENT>width_array = []<EOL>fs_array = []<EOL>for j in range(<NUM_LIT:11>):<EOL><INDENT>width_array.append(fd.width)<EOL>fd.length = length_to_width * fd.width<EOL>if use_depth_to_width:<EOL><INDENT>fd.depth = depth_to_width * fd.width<EOL><DEDENT>capacity_method_selector(sl, fd, method)<EOL>q = fd.q_ult<EOL>capacity = q * fd.length * fd.width<EOL>fs_array.append(capacity / vertical_load)<EOL>fd.width = fd.width - <NUM_LIT:0.5> / <NUM_LIT:10><EOL><DEDENT>if verbose:<EOL><INDENT>log(\"<STR_LIT>\", fos)<EOL>log(\"<STR_LIT>\", width_array)<EOL>log(\"<STR_LIT>\", fs_array)<EOL><DEDENT>for fs in range(len(fs_array)):<EOL><INDENT>if fs_array[fs] < fos:<EOL><INDENT>fd.width = width_array[fs - <NUM_LIT:1>]<EOL>fd.length = length_to_width * fd.width<EOL>if use_depth_to_width:<EOL><INDENT>fd.depth = depth_to_width * fd.width<EOL><DEDENT>capacity_method_selector(sl, fd, method)<EOL>break<EOL><DEDENT>if fs == len(fs_array) - <NUM_LIT:1>:<EOL><INDENT>DesignError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>return fd<EOL>", "docstring": "Determine the size of a footing given an aspect ratio and a load\n:param sl: Soil object\n:param vertical_load: The applied load to the foundation\n:param fos: The target factor of safety\n:param length_to_width: The desired length to width ratio of the foundation\n:param verbose: verbosity\n:return: a Foundation object", "id": "f11348:m6"}
{"signature": "def capacity_terzaghi_1943(sl, fd, round_footing=False, verbose=<NUM_LIT:0>, **kwargs):", "body": "if not kwargs.get(\"<STR_LIT>\", False):<EOL><INDENT>models.check_required(sl, [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"])<EOL>models.check_required(fd, [\"<STR_LIT>\", \"<STR_LIT:width>\", \"<STR_LIT>\"])<EOL><DEDENT>a02 = ((np.exp(np.pi * (<NUM_LIT> - sl.phi / <NUM_LIT>) * np.tan(sl.phi_r))) ** <NUM_LIT:2>)<EOL>a0_check = (np.exp((<NUM_LIT> - sl.phi) / <NUM_LIT> * np.pi * np.tan(sl.phi_r)))<EOL>if (a02 - a0_check) / a02 > <NUM_LIT>:<EOL><INDENT>raise DesignError<EOL><DEDENT>fd.nq_factor = (a02 / (<NUM_LIT:2> * (np.cos((<NUM_LIT> + sl.phi / <NUM_LIT:2>) * np.pi / <NUM_LIT>)) ** <NUM_LIT:2>))<EOL>fd.ng_factor = (<NUM_LIT:2> * (fd.nq_factor + <NUM_LIT:1>) * np.tan(sl.phi_r) / (<NUM_LIT:1> + <NUM_LIT> * np.sin(<NUM_LIT:4> * sl.phi_r)))<EOL>if sl.phi_r == <NUM_LIT:0>:<EOL><INDENT>fd.nc_factor = <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>fd.nc_factor = (fd.nq_factor - <NUM_LIT:1>) / np.tan(sl.phi_r)<EOL><DEDENT>if round_footing:<EOL><INDENT>s_c = <NUM_LIT><EOL>s_g = <NUM_LIT><EOL><DEDENT>elif fd.length / fd.width < <NUM_LIT:5>:<EOL><INDENT>s_c = <NUM_LIT><EOL>s_g = <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>s_c = <NUM_LIT:1.0><EOL>s_g = <NUM_LIT:1.0><EOL><DEDENT>s_q = <NUM_LIT:1.0><EOL>q_d = sl.unit_dry_weight * fd.depth<EOL>fd.q_ult = (sl.cohesion * fd.nc_factor * s_c + q_d * fd.nq_factor * s_q + <NUM_LIT:0.5> * fd.width *<EOL>sl.unit_dry_weight * fd.ng_factor * s_g)<EOL>if verbose:<EOL><INDENT>log(\"<STR_LIT>\", fd.nc_factor)<EOL>log(\"<STR_LIT>\", fd.nq_factor)<EOL>log(\"<STR_LIT>\", fd.ng_factor)<EOL>log(\"<STR_LIT>\", s_c)<EOL>log(\"<STR_LIT>\", s_q)<EOL>log(\"<STR_LIT>\", s_g)<EOL>log(\"<STR_LIT>\", fd.q_ult)<EOL><DEDENT>return fd.q_ult<EOL>", "docstring": "Calculates the foundation capacity according Terzaghi (1943)\nRef: http://geo.cv.nctu.edu.tw/foundation/\ndownload/BearingCapacityOfFoundations.pdf\n\n:param sl: Soil object\n:param fd: Foundation object\n:param round_footing: if True, then foundation is round\n:param verbose: verbosity\n:return: ultimate bearing stress\nNote: the shape factor of 1.3 is used for aspect ratio > 6", "id": "f11348:m1"}
{"signature": "def capacity_salgado_2008(sl, fd, h_l=<NUM_LIT:0>, h_b=<NUM_LIT:0>, vertical_load=<NUM_LIT:1>, verbose=<NUM_LIT:0>, **kwargs):", "body": "<EOL>if not kwargs.get(\"<STR_LIT>\", False):<EOL><INDENT>models.check_required(sl, [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"])<EOL>models.check_required(fd, [\"<STR_LIT>\", \"<STR_LIT:width>\", \"<STR_LIT>\"])<EOL><DEDENT>h_eff_b = kwargs.get(\"<STR_LIT>\", <NUM_LIT:0>)<EOL>h_eff_l = kwargs.get(\"<STR_LIT>\", <NUM_LIT:0>)<EOL>loc_v_l = kwargs.get(\"<STR_LIT>\", fd.length / <NUM_LIT:2>)<EOL>loc_v_b = kwargs.get(\"<STR_LIT>\", fd.width / <NUM_LIT:2>)<EOL>ecc_b = h_b * h_eff_b / vertical_load<EOL>ecc_l = h_l * h_eff_l / vertical_load<EOL>width_eff = min(fd.width, <NUM_LIT:2> * (loc_v_b + ecc_b), <NUM_LIT:2> * (fd.width - loc_v_b - ecc_b))<EOL>length_eff = min(fd.length, <NUM_LIT:2> * (loc_v_l + ecc_l), <NUM_LIT:2> * (fd.length - loc_v_l - ecc_l))<EOL>if width_eff / <NUM_LIT:2> < fd.width / <NUM_LIT:6>:<EOL><INDENT>DesignError(\"<STR_LIT>\")<EOL><DEDENT>fd.nq_factor = np.exp(np.pi * np.tan(sl.phi_r)) * (<NUM_LIT:1> + np.sin(sl.phi_r)) / (<NUM_LIT:1> - np.sin(sl.phi_r))<EOL>fd.ng_factor = <NUM_LIT> * (fd.nq_factor - <NUM_LIT:1>) * np.tan(sl.phi_r)<EOL>if sl.phi_r == <NUM_LIT:0>:<EOL><INDENT>fd.nc_factor = <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>fd.nc_factor = (fd.nq_factor - <NUM_LIT:1>) / np.tan(sl.phi_r)<EOL><DEDENT>s_q = <NUM_LIT:1> + (width_eff / length_eff) * np.tan(sl.phi_r)<EOL>s_g = max(<NUM_LIT:1> - <NUM_LIT> * width_eff / length_eff, <NUM_LIT>)<EOL>s_c = <NUM_LIT:1.0><EOL>d_q = <NUM_LIT:1> + <NUM_LIT:2> * np.tan(sl.phi_r) * (<NUM_LIT:1> - np.sin(sl.phi_r)) ** <NUM_LIT:2> * fd.depth / width_eff<EOL>d_g = <NUM_LIT:1.0><EOL>d_c = <NUM_LIT:1.0><EOL>q_d = sl.unit_dry_weight * fd.depth<EOL>if verbose:<EOL><INDENT>log(\"<STR_LIT>\", width_eff)<EOL>log(\"<STR_LIT>\", length_eff)<EOL>log(\"<STR_LIT>\", fd.nc_factor)<EOL>log(\"<STR_LIT>\", fd.nq_factor)<EOL>log(\"<STR_LIT>\", fd.ng_factor)<EOL>log(\"<STR_LIT>\", s_c)<EOL>log(\"<STR_LIT>\", s_q)<EOL>log(\"<STR_LIT>\", s_g)<EOL>log(\"<STR_LIT>\", d_c)<EOL>log(\"<STR_LIT>\", d_q)<EOL>log(\"<STR_LIT>\", d_g)<EOL>log(\"<STR_LIT>\", q_d)<EOL><DEDENT>fd.q_ult = (sl.cohesion * fd.nc_factor * s_c * d_c +<EOL>q_d * fd.nq_factor * s_q * d_q +<EOL><NUM_LIT:0.5> * width_eff * sl.unit_dry_weight *<EOL>fd.ng_factor * s_g * d_g)<EOL>if verbose:<EOL><INDENT>log(\"<STR_LIT>\", fd.q_ult)<EOL><DEDENT>return fd.q_ult<EOL>", "docstring": "calculates the capacity according to\n THe Engineering of Foundations textbook by Salgado\n\n ISBN: 0072500581\n\n:param sl: Soil object\n:param fd: Foundation object\n:param h_l: Horizontal load parallel to length\n:param h_b: Horizontal load parallel to width\n:param vertical_load: Vertical load\n:param verbose: verbosity\n:return: ultimate bearing stress", "id": "f11348:m5"}
{"signature": "@assert_draft<EOL><INDENT>def revert_to_public(self):<DEDENT>", "body": "if not self.publisher_linked:<EOL><INDENT>return<EOL><DEDENT>draft_obj = self<EOL>publish_obj = self.publisher_linked<EOL>draft_obj.publisher_linked = None<EOL>draft_obj.save()<EOL>draft_obj.delete()<EOL>draft_obj = publish_obj<EOL>publish_obj = None<EOL>draft_obj.publisher_is_draft = draft_obj.STATE_DRAFT<EOL>draft_obj.save()<EOL>draft_obj.publish()<EOL>return draft_obj<EOL>", "docstring": "@todo Relook at this method. It would be nice if the draft pk did not have to change\n@toavoid Updates self to a alternative instance\n@toavoid self.__class__ = draft_obj.__class__\n@toavoid self.__dict__ = draft_obj.__dict__", "id": "f11369:c0:m6"}
{"signature": "@property<EOL><INDENT>def currency(self):<DEDENT>", "body": "return self.start.currency<EOL>", "docstring": "Return the currency of the range.", "id": "f11372:c0:m5"}
{"signature": "@staticmethod<EOL><INDENT>def currencyFormat(_context, code, symbol, format,<EOL>currency_digits=True, decimal_quantization=True,<EOL>name='<STR_LIT>'):<DEDENT>", "body": "_context.action(<EOL>discriminator=('<STR_LIT>', name, code),<EOL>callable=_register_currency,<EOL>args=(name, code, symbol, format, currency_digits,<EOL>decimal_quantization)<EOL>)<EOL>", "docstring": "Handle currencyFormat subdirectives.", "id": "f11373:c0:m2"}
{"signature": "def setrate(self, currency, rate):", "body": "if not self.base:<EOL><INDENT>raise Warning(\"<STR_LIT>\")<EOL><DEDENT>self._rates[currency] = rate<EOL>", "docstring": "Sets the rate for currency to provided rate.", "id": "f11374:c1:m0"}
{"signature": "@ensure_fresh_rates<EOL><INDENT>def quotation(self, origin, target):<DEDENT>", "body": "return super(CoinBaseBackend, self).quotation(origin, target)<EOL>", "docstring": "Returns the rate of exchange from origin -> target currency.", "id": "f11374:c2:m4"}
{"signature": "def rate(self, currency):", "body": "if currency == self.base:<EOL><INDENT>rate = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>rate = self._rates.get(currency, None)<EOL><DEDENT>if rate:<EOL><INDENT>return Decimal(rate)<EOL><DEDENT>", "docstring": "Returns the rate of exchange from base -> currency.", "id": "f11374:c1:m1"}
{"signature": "def rate(currency):", "body": "", "docstring": "Return the rate of exchange from the base currency to currency.", "id": "f11375:c1:m0"}
{"signature": "def quotation(origin, target):", "body": "", "docstring": "Return a quotation from origin to target currency.", "id": "f11375:c1:m1"}
{"signature": "def rate(currency):", "body": "", "docstring": "Return quotation between the base and another currency", "id": "f11375:c4:m0"}
{"signature": "def __contains__(self, item):", "body": "", "docstring": "Return whether item (Price obj) is contained within range.", "id": "f11375:c3:m0"}
{"signature": "def to_uri():", "body": "", "docstring": "Return a formatted BIP21 Payment URI.", "id": "f11375:c5:m0"}
{"signature": "@classmethod<EOL><INDENT>def parse(cls, s):<DEDENT>", "body": "try:<EOL><INDENT>s = s.replace('<STR_LIT:U+002C>', '<STR_LIT>')<EOL>currency, amount = s.strip().split('<STR_LIT:U+0020>')<EOL>return cls(amount, currency)<EOL><DEDENT>except ValueError as err:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\".format(s, err)) from None<EOL><DEDENT>", "docstring": "Parse from a string representation (repr)", "id": "f11376:c0:m33"}
{"signature": "def sub_symbols(pattern, code, symbol):", "body": "return pattern.replace('<STR_LIT>', code).replace('<STR_LIT>', symbol)<EOL>", "docstring": "Substitutes symbols in CLDR number pattern.", "id": "f11376:m0"}
{"signature": "def format_currency(number, currency, format=None,<EOL>locale=LC_NUMERIC, currency_digits=True,<EOL>format_type='<STR_LIT>', decimal_quantization=True):", "body": "locale = Locale.parse(locale)<EOL>if format:<EOL><INDENT>pattern = parse_pattern(format)<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>p = locale.currency_formats[format_type]<EOL>pattern = NumberPattern(<EOL>p.pattern, p.prefix, p.suffix, p.grouping, p.int_prec,<EOL>p.frac_prec, p.exp_prec, p.exp_plus)<EOL><DEDENT>except KeyError:<EOL><INDENT>raise UnknownCurrencyFormatError(<EOL>\"<STR_LIT>\" % format_type)<EOL><DEDENT><DEDENT>return pattern.apply(<EOL>number, locale, currency=currency, currency_digits=currency_digits,<EOL>decimal_quantization=decimal_quantization)<EOL>", "docstring": "Return formatted currency value.\n\n    >>> format_currency(1099.98, 'USD', locale='en_US')\n    u'$1,099.98'\n    >>> format_currency(1099.98, 'USD', locale='es_CO')\n    u'US$\\\\xa01.099,98'\n    >>> format_currency(1099.98, 'EUR', locale='de_DE')\n    u'1.099,98\\\\xa0\\\\u20ac'\n\n    The format can also be specified explicitly.  The currency is\n    placed with the '\u00a4' sign.  As the sign gets repeated the format\n    expands (\u00a4 being the symbol, \u00a4\u00a4 is the currency abbreviation and\n    \u00a4\u00a4\u00a4 is the full name of the currency):\n\n    >>> format_currency(1099.98, 'EUR', u'\\xa4\\xa4 #,##0.00', locale='en_US')\n    u'EUR 1,099.98'\n    >>> format_currency(1099.98, 'EUR', u'#,##0.00 \\xa4\\xa4\\xa4',\n    ...                 locale='en_US')\n    u'1,099.98 euros'\n\n    Currencies usually have a specific number of decimal digits. This function\n    favours that information over the given format:\n\n    >>> format_currency(1099.98, 'JPY', locale='en_US')\n    u'\\\\xa51,100'\n    >>> format_currency(1099.98, 'COP', u'#,##0.00', locale='es_ES')\n    u'1.100'\n\n    However, the number of decimal digits can be overriden from the currency\n    information, by setting the last parameter to ``False``:\n\n    >>> format_currency(1099.98, 'JPY', locale='en_US', currency_digits=False)\n    u'\\\\xa51,099.98'\n    >>> format_currency(1099.98, 'COP', u'#,##0.00', locale='es_ES',\n    ...                 currency_digits=False)\n    u'1.099,98'\n\n    If a format is not specified the type of currency format to use\n    from the locale can be specified:\n\n    >>> format_currency(1099.98, 'EUR', locale='en_US', format_type='standard')\n    u'\\\\u20ac1,099.98'\n\n    When the given currency format type is not available, an exception is\n    raised:\n\n    >>> format_currency('1099.98', 'EUR', locale='root', format_type='unknown')\n    Traceback (most recent call last):\n        ...\n    UnknownCurrencyFormatError: \"'unknown' is not a known currency format type\"\n\n    By default the locale is allowed to truncate and round a high-precision\n    number by forcing its format pattern onto the decimal part. You can bypass\n    this behavior with the `decimal_quantization` parameter:\n\n    >>> format_currency(1099.9876, 'USD', locale='en_US')\n    u'$1,099.99'\n    >>> format_currency(1099.9876, 'USD', locale='en_US',\n    ...                 decimal_quantization=False)\n    u'$1,099.9876'\n\n    :param number: the number to format\n    :param currency: the currency code\n    :param format: the format string to use\n    :param locale: the `Locale` object or locale identifier\n    :param currency_digits: use the currency's natural number of decimal digits\n    :param format_type: the currency format type to use\n    :param decimal_quantization: Truncate and round high-precision numbers to\n                                 the format pattern. Defaults to `True`.", "id": "f11377:m0"}
{"signature": "def parse_pattern(pattern):", "body": "if isinstance(pattern, NumberPattern):<EOL><INDENT>return pattern<EOL><DEDENT>def _match_number(pattern):<EOL><INDENT>rv = number_re.search(pattern)<EOL>if rv is None:<EOL><INDENT>raise ValueError('<STR_LIT>' % pattern)<EOL><DEDENT>return rv.groups()<EOL><DEDENT>pos_pattern = pattern<EOL>if '<STR_LIT:;>' in pattern:<EOL><INDENT>pos_pattern, neg_pattern = pattern.split('<STR_LIT:;>', <NUM_LIT:1>)<EOL>pos_prefix, number, pos_suffix = _match_number(pos_pattern)<EOL>neg_prefix, _, neg_suffix = _match_number(neg_pattern)<EOL><DEDENT>else:<EOL><INDENT>pos_prefix, number, pos_suffix = _match_number(pos_pattern)<EOL>neg_prefix = '<STR_LIT:->' + pos_prefix<EOL>neg_suffix = pos_suffix<EOL><DEDENT>if '<STR_LIT:E>' in number:<EOL><INDENT>number, exp = number.split('<STR_LIT:E>', <NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>exp = None<EOL><DEDENT>if '<STR_LIT:@>' in number:<EOL><INDENT>if '<STR_LIT:.>' in number and '<STR_LIT:0>' in number:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>if '<STR_LIT:.>' in number:<EOL><INDENT>integer, fraction = number.rsplit('<STR_LIT:.>', <NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>integer = number<EOL>fraction = '<STR_LIT>'<EOL><DEDENT>def parse_precision(p):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>min = max = <NUM_LIT:0><EOL>for c in p:<EOL><INDENT>if c in '<STR_LIT>':<EOL><INDENT>min += <NUM_LIT:1><EOL>max += <NUM_LIT:1><EOL><DEDENT>elif c == '<STR_LIT:#>':<EOL><INDENT>max += <NUM_LIT:1><EOL><DEDENT>elif c == '<STR_LIT:U+002C>':<EOL><INDENT>continue<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>return min, max<EOL><DEDENT>int_prec = parse_precision(integer)<EOL>frac_prec = parse_precision(fraction)<EOL>if exp:<EOL><INDENT>exp_plus = exp.startswith('<STR_LIT:+>')<EOL>exp = exp.lstrip('<STR_LIT:+>')<EOL>exp_prec = parse_precision(exp)<EOL><DEDENT>else:<EOL><INDENT>exp_plus = None<EOL>exp_prec = None<EOL><DEDENT>grouping = babel.numbers.parse_grouping(integer)<EOL>return NumberPattern(pattern, (pos_prefix, neg_prefix),<EOL>(pos_suffix, neg_suffix), grouping,<EOL>int_prec, frac_prec,<EOL>exp_prec, exp_plus)<EOL>", "docstring": "Parse number format patterns", "id": "f11377:m1"}
{"signature": "def scientific_notation_elements(self, value, locale):", "body": "<EOL>exp = value.adjusted()<EOL>value = value * get_decimal_quantum(exp)<EOL>assert value.adjusted() == <NUM_LIT:0><EOL>lead_shift = max([<NUM_LIT:1>, min(self.int_prec)]) - <NUM_LIT:1><EOL>exp = exp - lead_shift<EOL>value = value * get_decimal_quantum(-lead_shift)<EOL>exp_sign = '<STR_LIT>'<EOL>if exp < <NUM_LIT:0>:<EOL><INDENT>exp_sign = babel.numbers.get_minus_sign_symbol(locale)<EOL><DEDENT>elif self.exp_plus:<EOL><INDENT>exp_sign = babel.numbers.get_plus_sign_symbol(locale)<EOL><DEDENT>exp = abs(exp)<EOL>return value, exp, exp_sign<EOL>", "docstring": "Returns normalized scientific notation components of a value.", "id": "f11377:c0:m2"}
{"signature": "def price(*args, **kwargs):", "body": "kwargs.setdefault('<STR_LIT:default>', '<STR_LIT>')<EOL>kwargs.setdefault('<STR_LIT>', price_converter)<EOL>if '<STR_LIT>' in kwargs:<EOL><INDENT>validator = kwargs.pop('<STR_LIT>')<EOL>if not isinstance(validator, (tuple, list)):<EOL><INDENT>validator = [validator]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>validator = []<EOL><DEDENT>validator.append(instance_of(PriceClass))<EOL>return attr.ib(validator=validator, *args, **kwargs)<EOL>", "docstring": "Price field for attrs.\n\n    See `help(attr.ib)` for full signature.\n\n    Usage:\n\n        >>> from pricing import fields\n        ... @attr.s\n        ... class Test:\n        ...     price: Price = fields.price(default='USD 5.00')\n        ...\n        ... Test()\n        Test(price=USD 5.00)", "id": "f11378:m1"}
{"signature": "def price_converter(obj):", "body": "if isinstance(obj, str):<EOL><INDENT>obj = PriceClass.parse(obj)<EOL><DEDENT>return obj<EOL>", "docstring": "Ensures that string prices are converted into Price objects.", "id": "f11378:m0"}
{"signature": "def fromUnicode(self, value):", "body": "v = value.strip()<EOL>if isinstance(v, bytes):<EOL><INDENT>v = v.decode()<EOL><DEDENT>v = PriceClass.parse(value)<EOL>self.validate(v)<EOL>return v<EOL>", "docstring": "See IFromUnicode.", "id": "f11378:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def parse_uri(cls, uri):<DEDENT>", "body": "parsed = URL(uri)<EOL>currency = parsed.scheme<EOL>address = parsed.path<EOL>value = parsed.qp['<STR_LIT:value>']<EOL>return cls(currency, address, value)<EOL>", "docstring": "Parses a EIP681 Payment URI into this class", "id": "f11381:c1:m3"}
{"signature": "def add_inputs(self, inputs):<EOL>", "body": "if self.hash:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>count = <NUM_LIT:0><EOL>for addy in inputs:<EOL><INDENT>if count > <NUM_LIT:0>:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'.format(cls=type(self).__name__),<EOL>)<EOL><DEDENT>if not isinstance(addy, MultisigAddress):<EOL><INDENT>raise with_context(<EOL>exc =<EOL>TypeError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>actual    = type(addy).__name__,<EOL>cls       = type(self).__name__,<EOL>expected  = MultisigAddress.__name__,<EOL>),<EOL>),<EOL>context = {<EOL>'<STR_LIT>': addy,<EOL>},<EOL>)<EOL><DEDENT>security_level = addy.security_level<EOL>if security_level < <NUM_LIT:1>:<EOL><INDENT>raise with_context(<EOL>exc =<EOL>ValueError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>type = type(addy).__name__,<EOL>),<EOL>),<EOL>context = {<EOL>'<STR_LIT>':   addy,<EOL>'<STR_LIT>': security_level,<EOL>},<EOL>)<EOL><DEDENT>if not addy.balance:<EOL><INDENT>raise with_context(<EOL>exc =<EOL>ValueError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>type = type(self).__name__,<EOL>),<EOL>),<EOL>context = {<EOL>'<STR_LIT>': addy,<EOL>},<EOL>)<EOL><DEDENT>self._create_input_transactions(addy)<EOL>count += <NUM_LIT:1><EOL><DEDENT>", "docstring": "Adds inputs to spend in the bundle.\n\nNote that each input may require multiple transactions, in order to\nhold the entire signature.\n\n:param inputs:\n  MultisigAddresses to use as the inputs for this bundle.\n\n  Note: at this time, only a single multisig input is supported.", "id": "f11399:c0:m0"}
{"signature": "def get_private_keys(<EOL>self,<EOL>index=<NUM_LIT:0>,<EOL>count=<NUM_LIT:1>,<EOL>security_level=AddressGenerator.DEFAULT_SECURITY_LEVEL,<EOL>):<EOL>", "body": "return commands.GetPrivateKeysCommand(self.adapter)(<EOL>seed=self.seed,<EOL>index=index,<EOL>count=count,<EOL>securityLevel=security_level,<EOL>)<EOL>", "docstring": "Generates one or more private keys from the seed.\n\nAs the name implies, private keys should not be shared.\nHowever, in a few cases it may be necessary (e.g., for M-of-N\ntransactions).\n\n:param index:\n    The starting key index.\n\n:param count:\n    Number of keys to generate.\n\n:param security_level:\n    Number of iterations to use when generating new keys.\n\n    Larger values take longer, but the resulting signatures are\n    more secure.\n\n    This value must be between 1 and 3, inclusive.\n\n:return:\n    Dict with the following items::\n\n        {\n            'keys': List[PrivateKey],\n                Always contains a list, even if only one key was\n                generated.\n        }\n\nReferences:\n\n- :py:class:`iota.crypto.signing.KeyGenerator`\n- https://github.com/iotaledger/wiki/blob/master/multisigs.md#how-m-of-n-works", "id": "f11409:c0:m2"}
{"signature": "def add_trits(left, right):<EOL>", "body": "target_len = max(len(left), len(right))<EOL>res = [<NUM_LIT:0>] * target_len<EOL>left += [<NUM_LIT:0>] * (target_len - len(left))<EOL>right += [<NUM_LIT:0>] * (target_len - len(right))<EOL>carry = <NUM_LIT:0><EOL>for i in range(len(res)):<EOL><INDENT>res[i], carry = _full_add_trits(left[i], right[i], carry)<EOL><DEDENT>return res<EOL>", "docstring": "Adds two sequences of trits together.\n\nThe result is a list of trits equal in length to the longer of the\ntwo sequences.\n\n.. note::\n    Overflow is possible.\n\n    For example, ``add_trits([1], [1])`` returns ``[-1]``.", "id": "f11410:m0"}
{"signature": "def get_addresses(self, start, count=<NUM_LIT:1>, step=<NUM_LIT:1>):<EOL>", "body": "if count < <NUM_LIT:1>:<EOL><INDENT>raise with_context(<EOL>exc=ValueError('<STR_LIT>'),<EOL>context={<EOL>'<STR_LIT:start>': start,<EOL>'<STR_LIT:count>': count,<EOL>'<STR_LIT>': step,<EOL>},<EOL>)<EOL><DEDENT>if not step:<EOL><INDENT>raise with_context(<EOL>exc=ValueError('<STR_LIT>'),<EOL>context={<EOL>'<STR_LIT:start>': start,<EOL>'<STR_LIT:count>': count,<EOL>'<STR_LIT>': step,<EOL>},<EOL>)<EOL><DEDENT>generator = self.create_iterator(start, step)<EOL>addresses = []<EOL>for _ in range(count):<EOL><INDENT>try:<EOL><INDENT>next_addy = next(generator)<EOL><DEDENT>except StopIteration:<EOL><INDENT>break<EOL><DEDENT>else:<EOL><INDENT>addresses.append(next_addy)<EOL><DEDENT><DEDENT>return addresses<EOL>", "docstring": "Generates and returns one or more addresses at the specified\nindex(es).\n\nThis is a one-time operation; if you want to create lots of\naddresses across multiple contexts, consider invoking\n:py:meth:`create_iterator` and sharing the resulting generator\nobject instead.\n\nWarning: This method may take awhile to run if the starting\nindex and/or the number of requested addresses is a large\nnumber!\n\n:param start:\n    Starting index.\n    Must be >= 0.\n\n:param count:\n    Number of addresses to generate.\n    Must be > 0.\n\n:param step:\n    Number of indexes to advance after each address.\n    This may be any non-zero (positive or negative) integer.\n\n:return:\n    Always returns a list, even if only one address is generated.\n\n    The returned list will contain ``count`` addresses, except\n    when ``step * count < start`` (only applies when ``step`` is\n    negative).", "id": "f11412:c0:m2"}
{"signature": "def convert_sign(byte):", "body": "if byte < <NUM_LIT:0>:<EOL><INDENT>return <NUM_LIT> + byte<EOL><DEDENT>elif byte > <NUM_LIT>:<EOL><INDENT>return -<NUM_LIT> + byte<EOL><DEDENT>return byte<EOL>", "docstring": "Convert between signed and unsigned bytes.", "id": "f11413:m8"}
{"signature": "def sign_input_transactions(self, bundle, start_index):<EOL>", "body": "if not bundle.hash:<EOL><INDENT>raise with_context(<EOL>exc=ValueError('<STR_LIT>'),<EOL>context={<EOL>'<STR_LIT>': bundle,<EOL>'<STR_LIT>': self.key_index,<EOL>'<STR_LIT>': start_index,<EOL>},<EOL>)<EOL><DEDENT>from iota.crypto.signing import SignatureFragmentGenerator<EOL>signature_fragment_generator = (<EOL>SignatureFragmentGenerator(self, bundle.hash)<EOL>)<EOL>for j in range(self.security_level):<EOL><INDENT>try:<EOL><INDENT>txn = bundle[start_index + j]<EOL><DEDENT>except IndexError as e:<EOL><INDENT>raise with_context(<EOL>exc=e,<EOL>context={<EOL>'<STR_LIT>': bundle,<EOL>'<STR_LIT>': self.key_index,<EOL>'<STR_LIT>': start_index + j,<EOL>},<EOL>)<EOL><DEDENT>if txn.value > <NUM_LIT:0>:<EOL><INDENT>raise with_context(<EOL>exc=ValueError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>i=txn.current_index,<EOL>value=txn.value,<EOL>),<EOL>),<EOL>context={<EOL>'<STR_LIT>': bundle,<EOL>'<STR_LIT>': self.key_index,<EOL>'<STR_LIT>': start_index,<EOL>},<EOL>)<EOL><DEDENT>if txn.signature_message_fragment:<EOL><INDENT>raise with_context(<EOL>exc=ValueError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>i=txn.current_index,<EOL>),<EOL>),<EOL>context={<EOL>'<STR_LIT>': bundle,<EOL>'<STR_LIT>': self.key_index,<EOL>'<STR_LIT>': start_index,<EOL>},<EOL>)<EOL><DEDENT>txn.signature_message_fragment = next(signature_fragment_generator)<EOL><DEDENT>", "docstring": "Signs the inputs starting at the specified index.\n\n:param bundle:\n    The bundle that contains the input transactions to sign.\n\n:param start_index:\n    The index of the first input transaction.\n\n    If necessary, the resulting signature will be split across\n    subsequent transactions automatically.", "id": "f11417:c2:m3"}
{"signature": "def advance(self):", "body": "self.current += self.step<EOL>", "docstring": "Advances the generator without creating a key.", "id": "f11419:c1:m3"}
{"signature": "def _create_sponge(self, index):<EOL>", "body": "seed = self.seed_as_trits[:]<EOL>sponge = Kerl()<EOL>sponge.absorb(add_trits(seed, trits_from_int(index)))<EOL>sponge.squeeze(seed)<EOL>sponge.reset()<EOL>sponge.absorb(seed)<EOL>return sponge<EOL>", "docstring": "Prepares the hash sponge for the generator.", "id": "f11419:c1:m4"}
{"signature": "def get_key(self, index, iterations):<EOL>", "body": "return (<EOL>self.get_keys(<EOL>start=index,<EOL>count=<NUM_LIT:1>,<EOL>step=<NUM_LIT:1>,<EOL>iterations=iterations,<EOL>)[<NUM_LIT:0>]<EOL>)<EOL>", "docstring": "Generates a single key.\n\n:param index:\n    The key index.\n\n:param iterations:\n    Number of transform iterations to apply to the key, also\n    known as security level.\n    Must be >= 1.\n\n    Increasing this value makes key generation slower, but more\n    resistant to brute-forcing.", "id": "f11419:c0:m1"}
{"signature": "@property<EOL><INDENT>def errors(self):<EOL><DEDENT>", "body": "try:<EOL><INDENT>self._errors.extend(self._validator)  <EOL><DEDENT>except StopIteration:<EOL><INDENT>pass<EOL><DEDENT>return self._errors<EOL>", "docstring": "Returns all errors found with the bundle.", "id": "f11421:c0:m1"}
{"signature": "def is_valid(self):<EOL>", "body": "if not self._errors:<EOL><INDENT>try:<EOL><INDENT>self._errors.append(next(self._validator))<EOL><DEDENT>except StopIteration:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return not self._errors<EOL>", "docstring": "Returns whether the bundle is valid.", "id": "f11421:c0:m2"}
{"signature": "def _create_validator(self):<EOL>", "body": "<EOL>grouped_transactions = self.bundle.group_transactions()<EOL>bundle_hash = self.bundle.hash<EOL>last_index = len(self.bundle) - <NUM_LIT:1><EOL>balance = <NUM_LIT:0><EOL>counter = <NUM_LIT:0><EOL>for group in grouped_transactions:<EOL><INDENT>for txn in group:<EOL><INDENT>balance += txn.value<EOL>if txn.bundle_hash != bundle_hash:<EOL><INDENT>yield '<STR_LIT>'.format(<EOL>i=counter,<EOL>)<EOL><DEDENT>if txn.current_index != counter:<EOL><INDENT>yield (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>actual=txn.current_index,<EOL>i=counter,<EOL>)<EOL>)<EOL><DEDENT>if txn.last_index != last_index:<EOL><INDENT>yield (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>actual=txn.last_index,<EOL>expected=last_index,<EOL>i=counter,<EOL>)<EOL>)<EOL><DEDENT>counter += <NUM_LIT:1><EOL><DEDENT><DEDENT>if balance != <NUM_LIT:0>:<EOL><INDENT>yield (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>actual=balance,<EOL>)<EOL>)<EOL><DEDENT>if not self._errors:<EOL><INDENT>signature_validation_queue = []  <EOL>for group in grouped_transactions:<EOL><INDENT>if group[<NUM_LIT:0>].value >= <NUM_LIT:0>:<EOL><INDENT>continue<EOL><DEDENT>validate_group_signature = True<EOL>for j, txn in enumerate(group):<EOL><INDENT>if (j > <NUM_LIT:0>) and (txn.value != <NUM_LIT:0>):<EOL><INDENT>yield (<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>actual=txn.value,<EOL>i=txn.current_index,<EOL>)<EOL>)<EOL>validate_group_signature = False<EOL>continue<EOL><DEDENT><DEDENT>if validate_group_signature:<EOL><INDENT>signature_validation_queue.append(group)<EOL><DEDENT><DEDENT>if signature_validation_queue:<EOL><INDENT>for error in self._get_bundle_signature_errors(<EOL>signature_validation_queue<EOL>):<EOL><INDENT>yield error<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Creates a generator that does all the work.", "id": "f11421:c0:m3"}
{"signature": "def _create_input_transactions(self, addy):<EOL>", "body": "self._transactions.append(ProposedTransaction(<EOL>address=addy,<EOL>tag=self.tag,<EOL>value=-addy.balance,<EOL>))<EOL>for _ in range(addy.security_level - <NUM_LIT:1>):<EOL><INDENT>self._transactions.append(ProposedTransaction(<EOL>address=addy,<EOL>tag=self.tag,<EOL>value=<NUM_LIT:0>,<EOL>))<EOL><DEDENT>", "docstring": "Creates transactions for the specified input address.", "id": "f11422:c1:m15"}
{"signature": "def send_unspent_inputs_to(self, address):<EOL>", "body": "if self.hash:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>self.change_address = address<EOL>", "docstring": "Adds a transaction to send \"change\" (unspent inputs) to the\nspecified address.\n\nIf the bundle has no unspent inputs, this method does nothing.", "id": "f11422:c1:m11"}
{"signature": "def increment_legacy_tag(self):", "body": "self._legacy_tag = (<EOL>Tag.from_trits(add_trits(self.legacy_tag.as_trits(), [<NUM_LIT:1>]))<EOL>)<EOL>", "docstring": "Increments the transaction's legacy tag, used to fix insecure\nbundle hashes when finalizing a bundle.\n\nReferences:\n\n- https://github.com/iotaledger/iota.lib.py/issues/84", "id": "f11422:c0:m2"}
{"signature": "def __iter__(self):<EOL>", "body": "return iter(self._transactions)<EOL>", "docstring": "Iterates over transactions in the bundle.", "id": "f11422:c1:m4"}
{"signature": "def get_signature_validation_trytes(self):<EOL>", "body": "return (<EOL>self.address.address<EOL>+ self.value_as_trytes<EOL>+ self.legacy_tag<EOL>+ self.timestamp_as_trytes<EOL>+ self.current_index_as_trytes<EOL>+ self.last_index_as_trytes<EOL>)<EOL>", "docstring": "Returns the values needed to validate the transaction's\n``signature_message_fragment`` value.", "id": "f11423:c0:m12"}
{"signature": "@property<EOL><INDENT>def is_confirmed(self):<EOL><DEDENT>", "body": "return self._is_confirmed<EOL>", "docstring": "Returns whether this bundle has been confirmed by neighbor\nnodes.\n\nThis attribute must be set manually.\n\nReferences:\n\n- :py:class:`iota.commands.extended.get_transfers.GetTransfersCommand`", "id": "f11423:c1:m6"}
{"signature": "@classmethod<EOL><INDENT>def from_tryte_string(cls, trytes, hash_=None):<EOL><DEDENT>", "body": "tryte_string = TransactionTrytes(trytes)<EOL>if not hash_:<EOL><INDENT>hash_trits = [<NUM_LIT:0>] * HASH_LENGTH  <EOL>sponge = Curl()<EOL>sponge.absorb(tryte_string.as_trits())<EOL>sponge.squeeze(hash_trits)<EOL>hash_ = TransactionHash.from_trits(hash_trits)<EOL><DEDENT>return cls(<EOL>hash_=hash_,<EOL>signature_message_fragment=Fragment(tryte_string[<NUM_LIT:0>:<NUM_LIT>]),<EOL>address=Address(tryte_string[<NUM_LIT>:<NUM_LIT>]),<EOL>value=int_from_trits(tryte_string[<NUM_LIT>:<NUM_LIT>].as_trits()),<EOL>legacy_tag=Tag(tryte_string[<NUM_LIT>:<NUM_LIT>]),<EOL>timestamp=int_from_trits(tryte_string[<NUM_LIT>:<NUM_LIT>].as_trits()),<EOL>current_index=int_from_trits(tryte_string[<NUM_LIT>:<NUM_LIT>].as_trits()),<EOL>last_index=int_from_trits(tryte_string[<NUM_LIT>:<NUM_LIT>].as_trits()),<EOL>bundle_hash=BundleHash(tryte_string[<NUM_LIT>:<NUM_LIT>]),<EOL>trunk_transaction_hash=TransactionHash(tryte_string[<NUM_LIT>:<NUM_LIT>]),<EOL>branch_transaction_hash=TransactionHash(tryte_string[<NUM_LIT>:<NUM_LIT>]),<EOL>tag=Tag(tryte_string[<NUM_LIT>:<NUM_LIT>]),<EOL>attachment_timestamp=int_from_trits(<EOL>tryte_string[<NUM_LIT>:<NUM_LIT>].as_trits()),<EOL>attachment_timestamp_lower_bound=int_from_trits(<EOL>tryte_string[<NUM_LIT>:<NUM_LIT>].as_trits()),<EOL>attachment_timestamp_upper_bound=int_from_trits(<EOL>tryte_string[<NUM_LIT>:<NUM_LIT>].as_trits()),<EOL>nonce=Nonce(tryte_string[<NUM_LIT>:<NUM_LIT>]),<EOL>)<EOL>", "docstring": "Creates a Transaction object from a sequence of trytes.\n\n:param trytes:\n    Raw trytes.  Should be exactly 2673 trytes long.\n\n:param hash_:\n    The transaction hash, if available.\n\n    If not provided, it will be computed from the transaction\n    trytes.", "id": "f11423:c0:m0"}
{"signature": "@property<EOL><INDENT>def attachment_timestamp_as_trytes(self):<EOL><DEDENT>", "body": "<EOL>return TryteString.from_trits(<EOL>trits_from_int(self.attachment_timestamp, pad=<NUM_LIT>),<EOL>)<EOL>", "docstring": "Returns a TryteString representation of the transaction's\n:py:attr:`attachment_timestamp`.", "id": "f11423:c0:m7"}
{"signature": "def group_transactions(self):<EOL>", "body": "groups = []<EOL>if self:<EOL><INDENT>last_txn = self.tail_transaction<EOL>current_group = [last_txn]<EOL>for current_txn in self.transactions[<NUM_LIT:1>:]:<EOL><INDENT>if current_txn.address == last_txn.address:<EOL><INDENT>current_group.append(current_txn)<EOL><DEDENT>else:<EOL><INDENT>groups.append(current_group)<EOL>current_group = [current_txn]<EOL><DEDENT>last_txn = current_txn<EOL><DEDENT>if current_group:<EOL><INDENT>groups.append(current_group)<EOL><DEDENT><DEDENT>return groups<EOL>", "docstring": "Groups transactions in the bundle by address.", "id": "f11423:c1:m13"}
{"signature": "@property<EOL><INDENT>def attachment_timestamp_lower_bound_as_trytes(self):<EOL><DEDENT>", "body": "<EOL>return TryteString.from_trits(<EOL>trits_from_int(self.attachment_timestamp_lower_bound, pad=<NUM_LIT>),<EOL>)<EOL>", "docstring": "Returns a TryteString representation of the transaction's\n:py:attr:`attachment_timestamp_lower_bound`.", "id": "f11423:c0:m8"}
{"signature": "@property<EOL><INDENT>def is_tail(self):<EOL><DEDENT>", "body": "return self.current_index == <NUM_LIT:0><EOL>", "docstring": "Returns whether this transaction is a tail (first one in the\nbundle).\n\nBecause of the way the Tangle is organized, the tail transaction\nis generally the last one in the bundle that gets attached, even\nthough it occupies the first logical position inside the bundle.", "id": "f11423:c0:m2"}
{"signature": "def _traverse_bundle(self, txn_hash, target_bundle_hash=None):<EOL>", "body": "trytes = (<EOL>GetTrytesCommand(self.adapter)(hashes=[txn_hash])['<STR_LIT>']<EOL>)  <EOL>if not trytes:<EOL><INDENT>raise with_context(<EOL>exc=BadApiResponse(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>),<EOL>context={<EOL>'<STR_LIT>': txn_hash,<EOL>'<STR_LIT>': target_bundle_hash,<EOL>},<EOL>)<EOL><DEDENT>transaction = Transaction.from_tryte_string(trytes[<NUM_LIT:0>])<EOL>if (not target_bundle_hash) and transaction.current_index:<EOL><INDENT>raise with_context(<EOL>exc=BadApiResponse(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>),<EOL>context={<EOL>'<STR_LIT>': transaction,<EOL>'<STR_LIT>': target_bundle_hash,<EOL>},<EOL>)<EOL><DEDENT>if target_bundle_hash:<EOL><INDENT>if target_bundle_hash != transaction.bundle_hash:<EOL><INDENT>return []<EOL><DEDENT><DEDENT>else:<EOL><INDENT>target_bundle_hash = transaction.bundle_hash<EOL><DEDENT>if transaction.current_index == transaction.last_index == <NUM_LIT:0>:<EOL><INDENT>return [transaction]<EOL><DEDENT>return [transaction] + self._traverse_bundle(<EOL>txn_hash=transaction.trunk_transaction_hash,<EOL>target_bundle_hash=target_bundle_hash<EOL>)<EOL>", "docstring": "Recursively traverse the Tangle, collecting transactions until\nwe hit a new bundle.\n\nThis method is (usually) faster than ``findTransactions``, and\nit ensures we don't collect transactions from replayed bundles.", "id": "f11457:c0:m3"}
{"signature": "@abstract_method<EOL><INDENT>def _prepare_response(self, response):<EOL><DEDENT>", "body": "raise NotImplementedError(<EOL>'<STR_LIT>'.format(cls=type(self).__name__),<EOL>)<EOL>", "docstring": "Modifies the response from the node.\n\nIf this method returns a dict, it will replace the response\nentirely.\n\n:param response:\n  Guaranteed to be a dict, but it might be empty.", "id": "f11460:c1:m5"}
{"signature": "def reset(self):<EOL>", "body": "self.called   = False<EOL>self.request  = None <EOL>self.response = None<EOL>", "docstring": "Resets the command, allowing it to be called again.", "id": "f11460:c1:m2"}
{"signature": "def __init__(self, default_adapter):<EOL>", "body": "super(RoutingWrapper, self).__init__(default_adapter)<EOL>self.adapter_aliases = {}  <EOL>self.routes = {}<EOL>", "docstring": ":param default_adapter:\n    Adapter to use for any routes not listed in ``routes``.", "id": "f11461:c1:m0"}
{"signature": "def get_adapter(self, command):<EOL>", "body": "return self.routes.get(command, self.adapter)<EOL>", "docstring": "Return the adapter for the specified command.", "id": "f11461:c1:m2"}
{"signature": "@abstract_method<EOL><INDENT>def get_uri(self):<EOL><DEDENT>", "body": "raise NotImplementedError(<EOL>'<STR_LIT>'.format(cls=type(self).__name__),<EOL>)<EOL>", "docstring": "Returns the URI that this adapter will use.", "id": "f11462:c3:m1"}
{"signature": "def set_logger(self, logger):<EOL>", "body": "self._logger = logger<EOL>return self<EOL>", "docstring": "Attaches a logger instance to the adapter.\nThe adapter will send information about API requests/responses\nto the logger.", "id": "f11462:c3:m3"}
{"signature": "@property<EOL><INDENT>def node_url(self):<EOL><DEDENT>", "body": "return self.uri.geturl()<EOL>", "docstring": "Returns the node URL.", "id": "f11462:c4:m1"}
{"signature": "def resolve_adapter(uri):<EOL>", "body": "if isinstance(uri, BaseAdapter):<EOL><INDENT>return uri<EOL><DEDENT>parsed = compat.urllib_parse.urlsplit(uri)  <EOL>if not parsed.scheme:<EOL><INDENT>raise with_context(<EOL>exc=InvalidUri(<EOL>'<STR_LIT>',<EOL>),<EOL>context={<EOL>'<STR_LIT>': parsed,<EOL>'<STR_LIT>': uri,<EOL>},<EOL>)<EOL><DEDENT>try:<EOL><INDENT>adapter_type = adapter_registry[parsed.scheme]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise with_context(<EOL>exc=InvalidUri('<STR_LIT>'.format(<EOL>protocol=parsed.scheme,<EOL>)),<EOL>context={<EOL>'<STR_LIT>': parsed,<EOL>'<STR_LIT>': uri,<EOL>},<EOL>)<EOL><DEDENT>return adapter_type.configure(parsed)<EOL>", "docstring": "Given a URI, returns a properly-configured adapter instance.", "id": "f11462:m0"}
{"signature": "def configure(cls, parsed):<EOL>", "body": "return cls(parsed)<EOL>", "docstring": "Creates a new instance using the specified URI.\n\n:param parsed:\n  Result of :py:func:`urllib.parse.urlsplit`.", "id": "f11462:c2:m1"}
{"signature": "def create_argument_parser(self):<EOL>", "body": "parser = ArgumentParser(<EOL>description=self.__doc__,<EOL>epilog='<STR_LIT>'.format(version=__version__),<EOL>)<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>type=text_type,<EOL>default='<STR_LIT>',<EOL>help=(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>),<EOL>)<EOL>if self.requires_seed:<EOL><INDENT>parser.add_argument(<EOL>'<STR_LIT>',<EOL>type=text_type,<EOL>dest='<STR_LIT>',<EOL>help=(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>),<EOL>)<EOL><DEDENT>parser.add_argument(<EOL>'<STR_LIT>',<EOL>action='<STR_LIT:store_true>',<EOL>default=False,<EOL>help='<STR_LIT>',<EOL>)<EOL>return parser<EOL>", "docstring": "Returns the argument parser that will be used to interpret\narguments and options from argv.", "id": "f11465:c0:m5"}
{"signature": "@staticmethod<EOL><INDENT>def prompt_for_seed():<EOL><DEDENT>", "body": "seed = secure_input(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL>if isinstance(seed, text_type):<EOL><INDENT>seed = seed.encode('<STR_LIT:ascii>')<EOL><DEDENT>return Seed(seed) if seed else Seed.random()<EOL>", "docstring": "Prompts the user to enter their seed via stdin.", "id": "f11465:c0:m7"}
{"signature": "def __init__(self, trytes, pad=None):<EOL>", "body": "super(TryteString, self).__init__()<EOL>if isinstance(trytes, (int, float)):<EOL><INDENT>raise with_context(<EOL>exc=TypeError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>type=type(trytes).__name__,<EOL>cls=type(self).__name__,<EOL>),<EOL>),<EOL>context={<EOL>'<STR_LIT>': trytes,<EOL>},<EOL>)<EOL><DEDENT>if isinstance(trytes, TryteString):<EOL><INDENT>incoming_type = type(trytes)<EOL>if (<EOL>(incoming_type is TryteString) or<EOL>issubclass(incoming_type, type(self))<EOL>):<EOL><INDENT>trytes = bytearray(trytes._trytes)<EOL><DEDENT>else:<EOL><INDENT>raise with_context(<EOL>exc=TypeError(<EOL>'<STR_LIT>'.format(<EOL>type=type(trytes).__name__,<EOL>cls=type(self).__name__,<EOL>),<EOL>),<EOL>context={<EOL>'<STR_LIT>': trytes,<EOL>},<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if isinstance(trytes, text_type):<EOL><INDENT>trytes = encode(trytes, '<STR_LIT:ascii>')<EOL><DEDENT>if not isinstance(trytes, bytearray):<EOL><INDENT>trytes = bytearray(trytes)<EOL><DEDENT>for i, ordinal in enumerate(trytes):<EOL><INDENT>if ordinal not in AsciiTrytesCodec.index:<EOL><INDENT>raise with_context(<EOL>exc=ValueError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>char=chr(ordinal),<EOL>i=i,<EOL>),<EOL>),<EOL>context={<EOL>'<STR_LIT>': trytes,<EOL>},<EOL>)<EOL><DEDENT><DEDENT><DEDENT>if pad:<EOL><INDENT>trytes += b'<STR_LIT>' * max(<NUM_LIT:0>, pad - len(trytes))<EOL><DEDENT>self._trytes = trytes<EOL>", "docstring": ":param trytes:\n    Byte string or bytearray.\n\n:param pad:\n    Ensure at least this many trytes.\n\n    If there are too few, null trytes will be appended to the\n    TryteString.\n\n    .. note::\n        If the TryteString is too long, it will *not* be\n        truncated!", "id": "f11466:c0:m6"}
{"signature": "def count_chunks(self, chunk_size):<EOL>", "body": "return len(self.iter_chunks(chunk_size))<EOL>", "docstring": "Returns the number of constant-size chunks the TryteString can\nbe divided into (rounded up).\n\n:param chunk_size:\n    Number of trytes per chunk.", "id": "f11466:c0:m20"}
{"signature": "def is_checksum_valid(self):<EOL>", "body": "if self.checksum:<EOL><INDENT>return self.checksum == self._generate_checksum()<EOL><DEDENT>return False<EOL>", "docstring": "Returns whether this address has a valid checksum.", "id": "f11466:c3:m2"}
{"signature": "@classmethod<EOL><INDENT>def from_trytes(cls, trytes, *args, **kwargs):<EOL><DEDENT>", "body": "chars = bytearray()<EOL>for t in trytes:<EOL><INDENT>converted = int_from_trits(t)<EOL>if converted < <NUM_LIT:0>:<EOL><INDENT>converted += <NUM_LIT><EOL><DEDENT>chars.append(AsciiTrytesCodec.alphabet[converted])<EOL><DEDENT>return cls(chars, *args, **kwargs)<EOL>", "docstring": "Creates a TryteString from a sequence of trytes.\n\n:param trytes:\n    Iterable of tryte values.\n\n    In this context, a tryte is defined as a list containing 3\n    trits.\n\n:param args:\n    Additional positional arguments to pass to the initializer.\n\n:param kwargs:\n    Additional keyword arguments to pass to the initializer.\n\nReferences:\n\n- :py:meth:`as_trytes`", "id": "f11466:c0:m4"}
{"signature": "@classmethod<EOL><INDENT>def random(cls, length):<EOL><DEDENT>", "body": "alphabet = list(itervalues(AsciiTrytesCodec.alphabet))<EOL>generator = SystemRandom()<EOL>return cls(<EOL>'<STR_LIT>'.join(<EOL>chr(generator.choice(alphabet)) for _ in range(length)<EOL>).encode('<STR_LIT:ascii>')<EOL>)<EOL>", "docstring": "Generates a random sequence of trytes.\n\n:param length:\n    Number of trytes to generate.", "id": "f11466:c0:m0"}
{"signature": "def as_json_compatible(self):<EOL>", "body": "return self._trytes.decode('<STR_LIT:ascii>')<EOL>", "docstring": "Returns a JSON-compatible representation of the object.\n\nReferences:\n\n- :py:class:`iota.json.JsonEncoder`.", "id": "f11466:c0:m26"}
{"signature": "def __init__(self, trytes, chunk_size):<EOL>", "body": "super(ChunkIterator, self).__init__()<EOL>self.trytes = trytes<EOL>self.chunk_size = chunk_size<EOL>self._offset = <NUM_LIT:0><EOL>", "docstring": ":param trytes:\n    :py:class:`TryteString` to iterate over.\n\n:param chunk_size:\n    Number of trytes per chunk.\n\n    The final chunk will be padded if it is too short.", "id": "f11466:c1:m0"}
{"signature": "def _repr_pretty_(self, p, cycle):", "body": "class_name = type(self).__name__<EOL>if cycle:<EOL><INDENT>p.text('<STR_LIT>'.format(<EOL>cls=class_name,<EOL>))<EOL><DEDENT>else:<EOL><INDENT>with p.group(<EOL>len(class_name) + <NUM_LIT:1>,<EOL>'<STR_LIT>'.format(cls=class_name),<EOL>'<STR_LIT:)>',<EOL>):<EOL><INDENT>prepared = self.as_json_compatible()<EOL>if isinstance(prepared, Mapping):<EOL><INDENT>p.text('<STR_LIT>')<EOL><DEDENT>elif isinstance(prepared, Iterable):<EOL><INDENT>p.text('<STR_LIT:*>')<EOL><DEDENT>p.pretty(prepared)<EOL><DEDENT><DEDENT>", "docstring": "Makes JSON-serializable objects play nice with IPython's default\npretty-printer.\n\nSadly, :py:func:`pprint.pprint` does not have a similar\nmechanism.\n\nReferences:\n\n- http://ipython.readthedocs.io/en/stable/api/generated/IPython.lib.pretty.html\n- :py:meth:`IPython.lib.pretty.RepresentationPrinter.pretty`\n- :py:func:`pprint._safe_repr`", "id": "f11468:c0:m1"}
{"signature": "@property<EOL><INDENT>def default_min_weight_magnitude(self):<EOL><DEDENT>", "body": "return <NUM_LIT:9> if self.testnet else <NUM_LIT><EOL>", "docstring": "Returns the default ``min_weight_magnitude`` value to use for\nAPI requests.", "id": "f11469:c2:m3"}
{"signature": "def get_tips(self):<EOL>", "body": "return core.GetTipsCommand(self.adapter)()<EOL>", "docstring": "Returns the list of tips (transactions which have no other\ntransactions referencing them).\n\nReferences:\n\n- https://iota.readme.io/docs/gettips\n- https://iota.readme.io/docs/glossary#iota-terms", "id": "f11469:c2:m13"}
{"signature": "def store_transactions(self, trytes):<EOL>", "body": "return core.StoreTransactionsCommand(self.adapter)(trytes=trytes)<EOL>", "docstring": "Store transactions into local storage.\n\nThe input trytes for this call are provided by\n:py:meth:`attach_to_tangle`.\n\nReferences:\n\n- https://iota.readme.io/docs/storetransactions", "id": "f11469:c2:m18"}
{"signature": "def get_transactions_to_approve(self, depth):<EOL>", "body": "return core.GetTransactionsToApproveCommand(self.adapter)(depth=depth)<EOL>", "docstring": "Tip selection which returns ``trunkTransaction`` and\n``branchTransaction``.\n\n:param depth:\n  Determines how many bundles to go back to when finding the\n  transactions to approve.\n\n  The higher the depth value, the more \"babysitting\" the node\n  will perform for the network (as it will confirm more\n  transactions that way).\n\nReferences:\n\n- https://iota.readme.io/docs/gettransactionstoapprove", "id": "f11469:c2:m14"}
{"signature": "def get_trytes(self, hashes):<EOL>", "body": "return core.GetTrytesCommand(self.adapter)(hashes=hashes)<EOL>", "docstring": "Returns the raw transaction data (trytes) of one or more\ntransactions.\n\nReferences:\n\n- https://iota.readme.io/docs/gettrytes", "id": "f11469:c2:m15"}
{"signature": "def prepare_transfer(<EOL>self,<EOL>transfers,  <EOL>inputs=None,  <EOL>change_address=None,  <EOL>security_level=None,  <EOL>):<EOL>", "body": "return extended.PrepareTransferCommand(self.adapter)(<EOL>seed=self.seed,<EOL>transfers=transfers,<EOL>inputs=inputs,<EOL>changeAddress=change_address,<EOL>securityLevel=security_level,<EOL>)<EOL>", "docstring": "Prepares transactions to be broadcast to the Tangle, by\ngenerating the correct bundle, as well as choosing and signing\nthe inputs (for value transfers).\n\n:param transfers:\n    Transaction objects to prepare.\n\n:param inputs:\n    List of addresses used to fund the transfer.\n    Ignored for zero-value transfers.\n\n    If not provided, addresses will be selected automatically by\n    scanning the Tangle for unspent inputs.  Depending on how\n    many transfers you've already sent with your seed, this\n    process could take awhile.\n\n:param change_address:\n    If inputs are provided, any unspent amount will be sent to\n    this address.\n\n    If not specified, a change address will be generated\n    automatically.\n\n:param security_level:\n    Number of iterations to use when generating new addresses\n    (see :py:meth:`get_new_addresses`).\n\n    This value must be between 1 and 3, inclusive.\n\n    If not set, defaults to\n    :py:attr:`AddressGenerator.DEFAULT_SECURITY_LEVEL`.\n\n:return:\n    Dict with the following structure::\n\n        {\n            'trytes': List[TransactionTrytes],\n                Raw trytes for the transactions in the bundle,\n                ready to be provided to :py:meth:`send_trytes`.\n        }\n\nReferences:\n\n- https://github.com/iotaledger/wiki/blob/master/api-proposal.md#preparetransfers", "id": "f11469:c3:m8"}
{"signature": "def promote_transaction(<EOL>self,<EOL>transaction,<EOL>depth=<NUM_LIT:3>,<EOL>min_weight_magnitude=None,<EOL>):<EOL>", "body": "if min_weight_magnitude is None:<EOL><INDENT>min_weight_magnitude = self.default_min_weight_magnitude<EOL><DEDENT>return extended.PromoteTransactionCommand(self.adapter)(<EOL>transaction=transaction,<EOL>depth=depth,<EOL>minWeightMagnitude=min_weight_magnitude,<EOL>)<EOL>", "docstring": "Promotes a transaction by adding spam on top of it.\n\n:return:\n    Dict with the following structure::\n\n        {\n            'bundle': Bundle,\n                The newly-published bundle.\n        }", "id": "f11469:c3:m9"}
{"signature": "def get_inputs(<EOL>self,<EOL>start=<NUM_LIT:0>,<EOL>stop=None,<EOL>threshold=None,<EOL>security_level=None,<EOL>):<EOL>", "body": "return extended.GetInputsCommand(self.adapter)(<EOL>seed=self.seed,<EOL>start=start,<EOL>stop=stop,<EOL>threshold=threshold,<EOL>securityLevel=security_level<EOL>)<EOL>", "docstring": "Gets all possible inputs of a seed and returns them, along with\nthe total balance.\n\nThis is either done deterministically (by generating all\naddresses until :py:meth:`find_transactions` returns an empty\nresult), or by providing a key range to search.\n\n:param start:\n    Starting key index.\n    Defaults to 0.\n\n:param stop:\n    Stop before this index.\n\n    Note that this parameter behaves like the ``stop`` attribute\n    in a :py:class:`slice` object; the stop index is *not*\n    included in the result.\n\n    If ``None`` (default), then this method will not stop until\n    it finds an unused address.\n\n:param threshold:\n    If set, determines the minimum threshold for a successful\n    result:\n\n    - As soon as this threshold is reached, iteration will stop.\n    - If the command runs out of addresses before the threshold\n      is reached, an exception is raised.\n\n    .. note::\n        This method does not attempt to \"optimize\" the result\n        (e.g., smallest number of inputs, get as close to\n        ``threshold`` as possible, etc.); it simply accumulates\n        inputs in order until the threshold is met.\n\n    If ``threshold`` is 0, the first address in the key range\n    with a non-zero balance will be returned (if it exists).\n\n    If ``threshold`` is ``None`` (default), this method will\n    return **all** inputs in the specified key range.\n\n:param security_level:\n    Number of iterations to use when generating new addresses\n    (see :py:meth:`get_new_addresses`).\n\n    This value must be between 1 and 3, inclusive.\n\n    If not set, defaults to\n    :py:attr:`AddressGenerator.DEFAULT_SECURITY_LEVEL`.\n\n:return:\n    Dict with the following structure::\n\n        {\n            'inputs': List[Address],\n                Addresses with nonzero balances that can be used\n                as inputs.\n\n            'totalBalance': int,\n                Aggregate balance from all matching addresses.\n        }\n\n    Note that each Address in the result has its ``balance``\n    attribute set.\n\n    Example:\n\n    .. code-block:: python\n\n        response = iota.get_inputs(...)\n\n        input0 = response['inputs'][0] # type: Address\n        input0.balance # 42\n\n:raise:\n    - :py:class:`iota.adapter.BadApiResponse` if ``threshold``\n      is not met.  Not applicable if ``threshold`` is ``None``.\n\nReferences:\n\n- https://github.com/iotaledger/wiki/blob/master/api-proposal.md#getinputs", "id": "f11469:c3:m4"}
{"signature": "def get_bundles(self, transaction):<EOL>", "body": "return extended.GetBundlesCommand(self.adapter)(transaction=transaction)<EOL>", "docstring": "Returns the bundle(s) associated with the specified transaction\nhash.\n\n:param transaction:\n    Transaction hash.  Must be a tail transaction.\n\n:return:\n    Dict with the following structure::\n\n     {\n       'bundles': List[Bundle],\n            List of matching bundles.  Note that this value is\n            always a list, even if only one bundle was found.\n     }\n\n:raise:\n  - :py:class:`iota.adapter.BadApiResponse` if any of the\n    bundles fails validation.\n\nReferences:\n\n- https://github.com/iotaledger/wiki/blob/master/api-proposal.md#getbundle", "id": "f11469:c3:m3"}
{"signature": "def __getattr__(self, command):<EOL>", "body": "<EOL>if command == '<STR_LIT>':<EOL><INDENT>return None<EOL><DEDENT>if command.startswith(\"<STR_LIT>\"):<EOL><INDENT>return super(StrictIota, self).__getattr__(command)<EOL><DEDENT>try:<EOL><INDENT>command_class = self.commands[command]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise InvalidCommand(<EOL>'<STR_LIT>'.format(<EOL>cls=type(self).__name__,<EOL>command=command,<EOL>),<EOL>)<EOL><DEDENT>return command_class(self.adapter)<EOL>", "docstring": "Creates a pre-configured command instance.\n\nThis method will only return commands supported by the API\nclass.\n\nIf you want to execute an arbitrary API command, use\n:py:meth:`create_command`.\n\n:param command:\n    The name of the command to create.\n\nReferences:\n\n- https://iota.readme.io/docs/making-requests", "id": "f11469:c2:m1"}
{"signature": "def create_http_response(content, status=<NUM_LIT:200>):<EOL>", "body": "response = requests.Response()<EOL>response.encoding     = '<STR_LIT:utf-8>'<EOL>response.status_code  = status<EOL>response.raw          = BytesIO(content.encode('<STR_LIT:utf-8>'))<EOL>return response<EOL>", "docstring": "Creates an HTTP Response object for a test.\n\nReferences:\n  - :py:meth:`requests.adapters.HTTPAdapter.build_response`", "id": "f11525:m0"}
{"signature": "def parse(self, config_file=None, specs=None, default_file=None):", "body": "self._config_exists(config_file)<EOL>self._specs_exists(specs)<EOL>self.loaded_config = anyconfig.load(self.config_file, ac_parser='<STR_LIT>')<EOL>if default_file is not None:<EOL><INDENT>self._merge_default(default_file)<EOL><DEDENT>if self.specs is None:<EOL><INDENT>return self.loaded_config<EOL><DEDENT>self._validate()<EOL>return self.loaded_config<EOL>", "docstring": "Read a config_file, check the validity with a JSON Schema as specs\n        and get default values from default_file if asked.\n\n        All parameters are optionnal.\n\n        If there is no config_file defined, read the venv base\n        dir and try to get config/app.yml.\n\n        If no specs, don't validate anything.\n\n        If no default_file, don't merge with default values.", "id": "f11538:c0:m0"}
{"signature": "def itervalues(self):", "body": "for key in self.iterkeys():<EOL><INDENT>yield self[key]<EOL><DEDENT>", "docstring": "Enumerate the values found at any scope for the current plugin.\n\nrtype: Generator[jsonable]", "id": "f11542:c9:m8"}
{"signature": "def export_settings(settings, config_path):", "body": "other = QtCore.QSettings(config_path, QtCore.QSettings.IniFormat)<EOL>for k, v in settings.iteritems():<EOL><INDENT>other.setValue(k, v)<EOL><DEDENT>", "docstring": "Export the given settings instance to the given file system path.\n\ntype settings: IDASettingsInterface\ntype config_path: str", "id": "f11542:m10"}
{"signature": "def iteritems(self):", "body": "for key in self.iterkeys():<EOL><INDENT>yield (key, self[key])<EOL><DEDENT>", "docstring": "Enumerate the (key, value) pairs found at any scope for the current plugin.\n\nrtype: Sequence[Tuple[str, jsonable]]", "id": "f11542:c9:m10"}
{"signature": "def del_netnode_plugin_name(plugin_name):", "body": "current_names = set(get_netnode_plugin_names())<EOL>if plugin_name not in current_names:<EOL><INDENT>return<EOL><DEDENT>try:<EOL><INDENT>current_names.remove(plugin_name)<EOL><DEDENT>except KeyError:<EOL><INDENT>return<EOL><DEDENT>get_meta_netnode()[PLUGIN_NAMES_KEY] = json.dumps(list(current_names))<EOL>", "docstring": "Remove the given plugin name to the list of plugin names registered in\n  the current IDB.\nNote that this implicitly uses the open IDB via the idc iterface.", "id": "f11542:m7"}
{"signature": "def iterkeys(self):", "body": "visited_keys = set()<EOL>try:<EOL><INDENT>for key in self.idb.iterkeys():<EOL><INDENT>if key not in visited_keys:<EOL><INDENT>yield key<EOL>visited_keys.add(key)<EOL><DEDENT><DEDENT><DEDENT>except (PermissionError, EnvironmentError):<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>for key in self.directory.iterkeys():<EOL><INDENT>if key not in visited_keys:<EOL><INDENT>yield key<EOL>visited_keys.add(key)<EOL><DEDENT><DEDENT><DEDENT>except (PermissionError, EnvironmentError):<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>for key in self.user.iterkeys():<EOL><INDENT>if key not in visited_keys:<EOL><INDENT>yield key<EOL>visited_keys.add(key)<EOL><DEDENT><DEDENT><DEDENT>except (PermissionError, EnvironmentError):<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>for key in self.system.iterkeys():<EOL><INDENT>if key not in visited_keys:<EOL><INDENT>yield key<EOL>visited_keys.add(key)<EOL><DEDENT><DEDENT><DEDENT>except (PermissionError, EnvironmentError):<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Enumerate the keys found at any scope for the current plugin.\n\nrtype: Generator[str]", "id": "f11542:c9:m6"}
{"signature": "def get_netnode_plugin_names():", "body": "try:<EOL><INDENT>return json.loads(get_meta_netnode()[PLUGIN_NAMES_KEY])<EOL><DEDENT>except KeyError:<EOL><INDENT>return []<EOL><DEDENT>", "docstring": "Get a iterable of the plugin names registered in the current IDB.\nNote that this implicitly uses the open IDB via the idc iterface.", "id": "f11542:m5"}
{"signature": "def PopulateForm(self):", "body": "hbox = QtWidgets.QHBoxLayout(self.parent)<EOL>self._splitter = QtWidgets.QSplitter(QtCore.Qt.Horizontal)<EOL>self._plugin_list = QtWidgets.QListWidget()<EOL>plugin_names = set([])<EOL>for scope, fn in ((\"<STR_LIT>\", ida_settings.IDASettings.get_idb_plugin_names),<EOL>(\"<STR_LIT>\", ida_settings.IDASettings.get_directory_plugin_names),<EOL>(\"<STR_LIT:user>\", ida_settings.IDASettings.get_user_plugin_names),<EOL>(\"<STR_LIT>\", ida_settings.IDASettings.get_system_plugin_names)):<EOL><INDENT>for plugin_name in fn():<EOL><INDENT>plugin_names.add(plugin_name)<EOL><DEDENT><DEDENT>for plugin_name in plugin_names:<EOL><INDENT>self._plugin_list.addItem(plugin_name)<EOL><DEDENT>self._splitter.addWidget(self._plugin_list)<EOL>hbox.addWidget(self._splitter)<EOL>self.parent.setLayout(hbox)<EOL>self._plugin_list.currentItemChanged.connect(self._handle_plugin_changed)<EOL>", "docstring": "+-----------------------------------------------------------------------+\n| +--- splitter ------------------------------------------------------+ |\n| | +-- list widget--------------+  +- IdaSettingsView -------------+ | |\n| | |                            |  |                               | | |\n| | |  - plugin name             |  |                               | | |\n| | |  - plugin name             |  |                               | | |\n| | |  - plugin name             |  |                               | | |\n| | |                            |  |                               | | |\n| | |                            |  |                               | | |\n| | |                            |  |                               | | |\n| | |                            |  |                               | | |\n| | |                            |  |                               | | |\n| | |                            |  |                               | | |\n| | |                            |  |                               | | |\n| | |                            |  |                               | | |\n| | |                            |  |                               | | |\n| | |                            |  |                               | | |\n| | |                            |  |                               | | |\n| | |                            |  |                               | | |\n| | |                            |  |                               | | |\n| | +----------------------------+  +-------------------------------+ | |\n| +-------------------------------------------------------------------+ |\n+-----------------------------------------------------------------------+", "id": "f11544:c0:m1"}
{"signature": "def read_byte(self, addr):", "body": "assert self._device is not None, '<STR_LIT>'<EOL>self._select_device(addr)<EOL>return ord(self._device.read(<NUM_LIT:1>))<EOL>", "docstring": "Read a single byte from the specified device.", "id": "f11548:c2:m7"}
{"signature": "def write_i2c_block_data(self, addr, cmd, vals):", "body": "assert self._device is not None, '<STR_LIT>'<EOL>data = bytearray(len(vals)+<NUM_LIT:1>)<EOL>data[<NUM_LIT:0>] = cmd & <NUM_LIT>  <EOL>data[<NUM_LIT:1>:] = vals[<NUM_LIT:0>:]   <EOL>self._select_device(addr)<EOL>self._device.write(data)<EOL>", "docstring": "Write a buffer of data to the specified cmd register of the device.", "id": "f11548:c2:m19"}
{"signature": "def write_bytes(self, addr, buf):", "body": "assert self._device is not None, '<STR_LIT>'<EOL>self._select_device(addr)<EOL>self._device.write(buf)<EOL>", "docstring": "Write many bytes to the specified device. buf is a bytearray", "id": "f11548:c2:m15"}
{"signature": "def read_byte_data(self, addr, cmd):", "body": "assert self._device is not None, '<STR_LIT>'<EOL>reg = c_uint8(cmd)<EOL>result = c_uint8()<EOL>request = make_i2c_rdwr_data([<EOL>(addr, <NUM_LIT:0>, <NUM_LIT:1>, pointer(reg)),             <EOL>(addr, I2C_M_RD, <NUM_LIT:1>, pointer(result))    <EOL>])<EOL>ioctl(self._device.fileno(), I2C_RDWR, request)<EOL>return result.value<EOL>", "docstring": "Read a single byte from the specified cmd register of the device.", "id": "f11548:c2:m9"}
{"signature": "def process_call(self, addr, cmd, val):", "body": "assert self._device is not None, '<STR_LIT>'<EOL>data = create_string_buffer(struct.pack('<STR_LIT>', cmd, val))<EOL>result = c_uint16()<EOL>request = make_i2c_rdwr_data([<EOL>(addr, <NUM_LIT:0>, <NUM_LIT:3>, cast(pointer(data), POINTER(c_uint8))),          <EOL>(addr, I2C_M_RD, <NUM_LIT:2>, cast(pointer(result), POINTER(c_uint8)))  <EOL>])<EOL>ioctl(self._device.fileno(), I2C_RDWR, request)<EOL>return result.value<EOL>", "docstring": "Perform a smbus process call by writing a word (2 byte) value to\n        the specified register of the device, and then reading a word of response\n        data (which is returned).", "id": "f11548:c2:m20"}
{"signature": "def download_file_insecure(url, target):", "body": "try:<EOL><INDENT>from urllib.request import urlopen<EOL><DEDENT>except ImportError:<EOL><INDENT>from urllib2 import urlopen<EOL><DEDENT>src = dst = None<EOL>try:<EOL><INDENT>src = urlopen(url)<EOL>data = src.read()<EOL>dst = open(target, \"<STR_LIT:wb>\")<EOL>dst.write(data)<EOL><DEDENT>finally:<EOL><INDENT>if src:<EOL><INDENT>src.close()<EOL><DEDENT>if dst:<EOL><INDENT>dst.close()<EOL><DEDENT><DEDENT>", "docstring": "Use Python to download the file, even though it cannot authenticate the\nconnection.", "id": "f11550:m14"}
{"signature": "def _python_cmd(*args):", "body": "args = (sys.executable,) + args<EOL>return subprocess.call(args) == <NUM_LIT:0><EOL>", "docstring": "Return True if the command succeeded.", "id": "f11550:m0"}
{"signature": "def main():", "body": "options = _parse_args()<EOL>archive = download_setuptools(<EOL>version=options.version,<EOL>download_base=options.download_base,<EOL>downloader_factory=options.downloader_factory,<EOL>)<EOL>return _install(archive, _build_install_args(options))<EOL>", "docstring": "Install or upgrade setuptools and EasyInstall", "id": "f11550:m19"}
{"signature": "def close_session(self):", "body": "self._session.close()<EOL>self._session = None<EOL>", "docstring": "Close current session.", "id": "f11552:c1:m8"}
{"signature": "def login(self):", "body": "if self._session is None:<EOL><INDENT>self._session = requests.session()<EOL>self._session.headers.update({'<STR_LIT>': str(UserAgent().random)})<EOL><DEDENT>return self._post_login_page()<EOL>", "docstring": "Set http session.", "id": "f11552:c1:m1"}
{"signature": "def fetch_data(self):", "body": "for t in [HOURLY, DAILY, MONTHLY, YEARLY]:<EOL><INDENT>self._data[t] = self.get_data_per_period(t)<EOL><DEDENT>", "docstring": "Get the latest data from Enedis.", "id": "f11552:c1:m6"}
{"signature": "def remove_accelerator(control, key):", "body": "key = str_to_key(key)<EOL>t = _tables.get(control, [])<EOL>for a in t:<EOL><INDENT>if a[:<NUM_LIT:2>] == key:<EOL><INDENT>t.remove(a)<EOL>if t:<EOL><INDENT>_tables[control] = t<EOL><DEDENT>else:<EOL><INDENT>del _tables[control]<EOL><DEDENT>update_accelerators(control)<EOL>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Removes an accelerator from control.\n\ncontrol: The control to affect.\nkey: The key to remove.", "id": "f11557:m4"}
{"signature": "@property<EOL><INDENT>def modified(self):<DEDENT>", "body": "return None<EOL>", "docstring": "Return last modified date of item.", "id": "f11560:c4:m2"}
{"signature": "def _fetchChildren(self):", "body": "children = []<EOL>for path in self._collection:<EOL><INDENT>try:<EOL><INDENT>child = ItemFactory(path)<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>children.append(child)<EOL><DEDENT><DEDENT>return children<EOL>", "docstring": "Fetch and return new child items.", "id": "f11560:c5:m4"}
{"signature": "def _fetchChildren(self):", "body": "return []<EOL>", "docstring": "Fetch and return new child items.\n\n        Override in subclasses to fetch actual children and return list of\n        *unparented* :py:class:`Item` instances.", "id": "f11560:c0:m12"}
{"signature": "def canFetchMore(self):", "body": "if not self._fetched:<EOL><INDENT>if self.mayHaveChildren():<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Return whether more items can be fetched under this one.", "id": "f11560:c0:m9"}
{"signature": "@property<EOL><INDENT>def name(self):<DEDENT>", "body": "return os.path.basename(self.path) or self.path<EOL>", "docstring": "Return name of item.", "id": "f11560:c0:m2"}
{"signature": "@property<EOL><INDENT>def type(self):<DEDENT>", "body": "return '<STR_LIT>'<EOL>", "docstring": "Return type of item as string.", "id": "f11560:c3:m0"}
{"signature": "@property<EOL><INDENT>def size(self):<DEDENT>", "body": "return None<EOL>", "docstring": "Return size of item.", "id": "f11560:c5:m2"}
{"signature": "def rowCount(self, parent):", "body": "if parent.column() > <NUM_LIT:0>:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>if parent.isValid():<EOL><INDENT>item = parent.internalPointer()<EOL><DEDENT>else:<EOL><INDENT>item = self.root<EOL><DEDENT>return len(item.children)<EOL>", "docstring": "Return number of children *parent* index has.", "id": "f11560:c6:m1"}
{"signature": "def _fetchChildren(self):", "body": "children = []<EOL>paths = []<EOL>for name in os.listdir(self.path):<EOL><INDENT>paths.append(os.path.normpath(os.path.join(self.path, name)))<EOL><DEDENT>collections, remainder = clique.assemble(<EOL>paths, [clique.PATTERNS['<STR_LIT>']]<EOL>)<EOL>for path in remainder:<EOL><INDENT>try:<EOL><INDENT>child = ItemFactory(path)<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>children.append(child)<EOL><DEDENT><DEDENT>for collection in collections:<EOL><INDENT>children.append(Collection(collection))<EOL><DEDENT>return children<EOL>", "docstring": "Fetch and return new child items.", "id": "f11560:c3:m1"}
{"signature": "def addChild(self, item):", "body": "if item.parent and item.parent != self:<EOL><INDENT>item.parent.removeChild(item)<EOL><DEDENT>self.children.append(item)<EOL>item.parent = self<EOL>", "docstring": "Add *item* as child of this item.", "id": "f11560:c0:m7"}
{"signature": "@property<EOL><INDENT>def type(self):<DEDENT>", "body": "return '<STR_LIT>'<EOL>", "docstring": "Return type of item as string.", "id": "f11560:c5:m1"}
{"signature": "@property<EOL><INDENT>def iconFactory(self):<DEDENT>", "body": "sourceModel = self.sourceModel()<EOL>if not sourceModel:<EOL><INDENT>return None<EOL><DEDENT>return sourceModel.iconFactory<EOL>", "docstring": "Return iconFactory of model.", "id": "f11560:c7:m2"}
{"signature": "@property<EOL><INDENT>def root(self):<DEDENT>", "body": "sourceModel = self.sourceModel()<EOL>if not sourceModel:<EOL><INDENT>return None<EOL><DEDENT>return sourceModel.root<EOL>", "docstring": "Return root of model.", "id": "f11560:c7:m1"}
{"signature": "def columnCount(self, parent):", "body": "return len(self.columns)<EOL>", "docstring": "Return amount of data *parent* index has.", "id": "f11560:c6:m2"}
{"signature": "def __init__(self):", "body": "super(Computer, self).__init__('<STR_LIT>')<EOL>", "docstring": "Initialise item.", "id": "f11560:c1:m0"}
{"signature": "def lessThan(self, left, right):", "body": "sourceModel = self.sourceModel()<EOL>if sourceModel:<EOL><INDENT>leftItem = sourceModel.item(left)<EOL>rightItem = sourceModel.item(right)<EOL>if (isinstance(leftItem, Directory)<EOL>and not isinstance(rightItem, Directory)):<EOL><INDENT>return self.sortOrder() == Qt.AscendingOrder<EOL><DEDENT>elif (not isinstance(leftItem, Directory)<EOL>and isinstance(rightItem, Directory)):<EOL><INDENT>return self.sortOrder() == Qt.DescendingOrder<EOL><DEDENT><DEDENT>return super(FilesystemSortProxy, self).lessThan(left, right)<EOL>", "docstring": "Return ordering of *left* vs *right*.", "id": "f11560:c7:m0"}
{"signature": "def pathIndex(self, path):", "body": "if path == self.root.path:<EOL><INDENT>return QModelIndex()<EOL><DEDENT>if not path.startswith(self.root.path):<EOL><INDENT>return QModelIndex()<EOL><DEDENT>parts = []<EOL>while True:<EOL><INDENT>if path == self.root.path:<EOL><INDENT>break<EOL><DEDENT>head, tail = os.path.split(path)<EOL>if head == path:<EOL><INDENT>if path:<EOL><INDENT>parts.append(path)<EOL><DEDENT>break<EOL><DEDENT>parts.append(tail)<EOL>path = head<EOL><DEDENT>parts.reverse()<EOL>if parts:<EOL><INDENT>item = self.root<EOL>count = <NUM_LIT:0><EOL>for count, part in enumerate(parts):<EOL><INDENT>matched = False<EOL>for child in item.children:<EOL><INDENT>if child.name == part:<EOL><INDENT>item = child<EOL>matched = True<EOL>break<EOL><DEDENT><DEDENT>if not matched:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if count + <NUM_LIT:1> == len(parts):<EOL><INDENT>return self.createIndex(item.row, <NUM_LIT:0>, item)<EOL><DEDENT><DEDENT>return QModelIndex()<EOL>", "docstring": "Return index of item with *path*.", "id": "f11560:c6:m5"}
{"signature": "@property<EOL><INDENT>def name(self):<DEDENT>", "body": "return '<STR_LIT>'<EOL>", "docstring": "Return name of item.", "id": "f11560:c1:m1"}
{"signature": "def flags(self, index):", "body": "if not index.isValid():<EOL><INDENT>return Qt.NoItemFlags<EOL><DEDENT>return Qt.ItemIsEnabled | Qt.ItemIsSelectable<EOL>", "docstring": "Return flags for *index*.", "id": "f11560:c6:m3"}
{"signature": "def _onSelectItem(self, selection, previousSelection):", "body": "self._acceptButton.setEnabled(True)<EOL>del self._selected[:]<EOL>item = self._filesystemWidget.model().item(selection)<EOL>self._selected.append(item.path)<EOL>", "docstring": "Handle selection of item in listing.", "id": "f11564:c0:m5"}
{"signature": "def autodoc_skip(app, what, name, obj, skip, options):", "body": "if name == '<STR_LIT>':<EOL><INDENT>return False<EOL><DEDENT>return skip<EOL>", "docstring": "Don't skip __init__ method for autodoc.", "id": "f11567:m0"}
{"signature": "def nearest_freq(self, freq, bin_size):", "body": "return round(freq / bin_size) * bin_size<EOL>", "docstring": "Return nearest frequency based on bin size", "id": "f11571:c0:m1"}
{"signature": "def setup(self, bins, repeats, base_buffer_size=<NUM_LIT:0>, max_buffer_size=<NUM_LIT:0>, fft_window='<STR_LIT>',<EOL>fft_overlap=<NUM_LIT:0.5>, crop_factor=<NUM_LIT:0>, log_scale=True, remove_dc=False, detrend=None,<EOL>lnb_lo=<NUM_LIT:0>, tune_delay=<NUM_LIT:0>, reset_stream=False, max_threads=<NUM_LIT:0>, max_queue_size=<NUM_LIT:0>):", "body": "if self.device.is_streaming:<EOL><INDENT>self.device.stop_stream()<EOL><DEDENT>base_buffer = self.device.start_stream(buffer_size=base_buffer_size)<EOL>self._bins = bins<EOL>self._repeats = repeats<EOL>self._base_buffer_size = len(base_buffer)<EOL>self._max_buffer_size = max_buffer_size<EOL>self._buffer_repeats, self._buffer = self.create_buffer(<EOL>bins, repeats, self._base_buffer_size, self._max_buffer_size<EOL>)<EOL>self._tune_delay = tune_delay<EOL>self._reset_stream = reset_stream<EOL>self._psd = psd.PSD(bins, self.device.sample_rate, fft_window=fft_window, fft_overlap=fft_overlap,<EOL>crop_factor=crop_factor, log_scale=log_scale, remove_dc=remove_dc, detrend=detrend,<EOL>lnb_lo=lnb_lo, max_threads=max_threads, max_queue_size=max_queue_size)<EOL>self._writer = writer.formats[self._output_format](self._output)<EOL>", "docstring": "Prepare samples buffer and start streaming samples from device", "id": "f11571:c0:m10"}
{"signature": "def wait_for_result(self, psd_state):", "body": "if len(psd_state['<STR_LIT>']) > <NUM_LIT:1>:<EOL><INDENT>concurrent.futures.wait(psd_state['<STR_LIT>'])<EOL><DEDENT>elif psd_state['<STR_LIT>']:<EOL><INDENT>psd_state['<STR_LIT>'][<NUM_LIT:0>].result()<EOL><DEDENT>return self.result(psd_state)<EOL>", "docstring": "Wait for all PSD threads to finish and return result", "id": "f11572:c0:m3"}
{"signature": "def update(self, psd_state, samples_array):", "body": "freq_array, pwr_array = simplespectral.welch(samples_array, self._sample_rate, nperseg=self._bins,<EOL>window=self._fft_window, noverlap=self._fft_overlap_bins,<EOL>detrend=self._detrend)<EOL>if self._remove_dc:<EOL><INDENT>pwr_array[<NUM_LIT:0>] = (pwr_array[<NUM_LIT:1>] + pwr_array[-<NUM_LIT:1>]) / <NUM_LIT:2><EOL><DEDENT>with psd_state['<STR_LIT>']:<EOL><INDENT>psd_state['<STR_LIT>'] += <NUM_LIT:1><EOL>if psd_state['<STR_LIT>'] is None:<EOL><INDENT>psd_state['<STR_LIT>'] = pwr_array<EOL><DEDENT>else:<EOL><INDENT>psd_state['<STR_LIT>'] += pwr_array<EOL><DEDENT><DEDENT>", "docstring": "Compute PSD from samples and update average for given center frequency", "id": "f11572:c0:m6"}
{"signature": "def wrap(text, indent='<STR_LIT:U+0020>'):", "body": "wrapper = textwrap.TextWrapper(<EOL>width=int(os.environ.get('<STR_LIT>', <NUM_LIT>)),<EOL>initial_indent=indent,<EOL>subsequent_indent=indent<EOL>)<EOL>return '<STR_LIT:\\n>'.join(wrapper.wrap(text))<EOL>", "docstring": "Wrap text to terminal width with default indentation", "id": "f11573:m4"}
{"signature": "def detect_devices(soapy_args='<STR_LIT>'):", "body": "devices = simplesoapy.detect_devices(soapy_args, as_string=True)<EOL>text = []<EOL>text.append('<STR_LIT>')<EOL>if devices:<EOL><INDENT>for i, d in enumerate(devices):<EOL><INDENT>text.append('<STR_LIT>'.format(d))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>text.append('<STR_LIT>')<EOL><DEDENT>return (devices, '<STR_LIT:\\n>'.join(text))<EOL>", "docstring": "Returns detected SoapySDR devices", "id": "f11573:m5"}
{"signature": "def write(self, psd_data_or_future, time_start, time_stop, samples):", "body": "try:<EOL><INDENT>f_array, pwr_array = psd_data_or_future.result()<EOL><DEDENT>except AttributeError:<EOL><INDENT>f_array, pwr_array = psd_data_or_future<EOL><DEDENT>try:<EOL><INDENT>step = f_array[<NUM_LIT:1>] - f_array[<NUM_LIT:0>]<EOL>self.formatter.write(<EOL>self.output,<EOL>time_start.timestamp(),<EOL>time_stop.timestamp(),<EOL>f_array[<NUM_LIT:0>],<EOL>f_array[-<NUM_LIT:1>] + step,<EOL>step,<EOL>samples,<EOL>pwr_array<EOL>)<EOL><DEDENT>except Exception as e:<EOL><INDENT>logging.exception('<STR_LIT>'.format(e))<EOL><DEDENT>", "docstring": "Write PSD of one frequency hop", "id": "f11574:c2:m1"}
{"signature": "def write_next(self):", "body": "self.output.write('<STR_LIT:\\n>')<EOL>self.output.flush()<EOL>", "docstring": "Write marker for next run of measurement", "id": "f11574:c3:m2"}
{"signature": "def write_next(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Write marker for next run of measurement", "id": "f11574:c0:m3"}
{"signature": "def create_zipfile(context):", "body": "if not prerequisites_ok():<EOL><INDENT>return<EOL><DEDENT>subprocess.call(['<STR_LIT>', '<STR_LIT>'])<EOL>for zipfile in glob.glob('<STR_LIT>'):<EOL><INDENT>first_part = zipfile.split('<STR_LIT:.>')[<NUM_LIT:0>]<EOL>new_name = \"<STR_LIT>\" % (first_part, context['<STR_LIT:version>'])<EOL>target = os.path.join(context['<STR_LIT>'], new_name)<EOL>shutil.copy(zipfile, target)<EOL>print(\"<STR_LIT>\" % (zipfile, target))<EOL><DEDENT>", "docstring": "This is the actual zest.releaser entry point\n\n    Relevant items in the context dict:\n\n    name\n        Name of the project being released\n\n    tagdir\n        Directory where the tag checkout is placed (*if* a tag\n        checkout has been made)\n\n    version\n        Version we're releasing\n\n    workingdir\n        Original working directory", "id": "f11578:m1"}
{"signature": "def _init_properties(self):", "body": "self._missing = {}<EOL>for k, p in self.params.items():<EOL><INDENT>if p.required:<EOL><INDENT>self._missing[k] = p<EOL><DEDENT>if isinstance(p, Derived):<EOL><INDENT>if p.loader is None:<EOL><INDENT>p.loader = self.__getattribute__(\"<STR_LIT>\" % k)<EOL><DEDENT>elif isinstance(p.loader, str):<EOL><INDENT>p.loader = self.__getattribute__(p.loader)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Loop through the list of Properties,\n        extract the derived and required properties and do the\n        appropriate book-keeping", "id": "f11584:c0:m9"}
{"signature": "def asscalar(a):", "body": "try:<EOL><INDENT>return a.item()<EOL><DEDENT>except AttributeError:<EOL><INDENT>return np.asarray(a).item()<EOL><DEDENT>", "docstring": "Convert single-item lists and numpy arrays to scalars. Does\n    not care about the type of the elements (i.e., will work fine on\n    strings, etc.)\n\n    https://github.com/numpy/numpy/issues/4701\n    https://github.com/numpy/numpy/pull/5126", "id": "f11587:m0"}
{"signature": "def __call__(self):", "body": "return self.value<EOL>", "docstring": "__call__ will return the current value\n\n        By default this invokes `self.value`\n        so, any additional functionality that sub-classes implement,\n        (such as caching the results of\n        complicated operations needed to compute the value)\n        will also be invoked", "id": "f11587:c1:m7"}
{"signature": "def clear_value(self):", "body": "self.set_value(None)<EOL>", "docstring": "Set the value to None\n\n        This can be useful for sub-classes that use None\n        to indicate an un-initialized value.\n\n        Note that this invokes hooks for type-checking and\n        bounds-checking that may be implemented by sub-classes, so it\n        should will need to be re-implemented if those checks do note\n        accept None as a valid value.", "id": "f11587:c1:m10"}
{"signature": "def check_type(self, value):", "body": "try:<EOL><INDENT>scalar = asscalar(value)<EOL><DEDENT>except ValueError as e:<EOL><INDENT>raise TypeError(e)<EOL><DEDENT>super(Parameter, self).check_type(scalar)<EOL>", "docstring": "Hook for type-checking, invoked during assignment. Allows size 1\n        numpy arrays and lists, but raises TypeError if value can not\n        be cast to a scalar.", "id": "f11587:c3:m1"}
{"signature": "@staticmethod<EOL><INDENT>def representer(dumper, data):<DEDENT>", "body": "tag = yaml.resolver.BaseResolver.DEFAULT_MAPPING_TAG<EOL>return dumper.represent_mapping(<EOL>tag, data.todict().items(), flow_style=True)<EOL>", "docstring": "http://stackoverflow.com/a/14001707/4075339\nhttp://stackoverflow.com/a/21912744/4075339", "id": "f11587:c3:m64"}
{"signature": "def _load(self, **kwargs):", "body": "defaults = dict([(d[<NUM_LIT:0>], d[<NUM_LIT:1>]) for d in self.defaults])<EOL>for k in kwargs:<EOL><INDENT>if k not in defaults:<EOL><INDENT>msg = \"<STR_LIT>\" % (<EOL>self.__class__.__name__, k)<EOL>raise AttributeError(msg)<EOL><DEDENT><DEDENT>defaults.update(kwargs)<EOL>self.__dict__.update(defaults)<EOL>self.check_type(self.__dict__['<STR_LIT:default>'])<EOL>self.set(**defaults)<EOL>", "docstring": "Load kwargs key,value pairs into __dict__", "id": "f11587:c1:m3"}
{"signature": "@property<EOL><INDENT>def errors(self):<DEDENT>", "body": "return self.__errors__<EOL>", "docstring": "Return the parameter uncertainties.\n\n        None implies no error estimate.\n        Single value implies symmetric errors.\n        Two values implies low,high asymmetric errors.", "id": "f11587:c3:m54"}
{"signature": "def innertype(self):", "body": "return type(self.__value__)<EOL>", "docstring": "Return the type of the current value", "id": "f11587:c1:m6"}
{"signature": "def check_bounds(self, value):", "body": "pass<EOL>", "docstring": "Hook for bounds-checking, invoked during assignment.\n\n        Sub-classes can raise an exception for out-of-bounds input values.", "id": "f11587:c1:m13"}
{"signature": "def set_value(self, value):", "body": "self.check_bounds(value)<EOL>self.check_type(value)<EOL>self.__value__ = value<EOL>", "docstring": "Set the value\n\n        This invokes hooks for type-checking and bounds-checking that\n        may be implemented by sub-classes.", "id": "f11587:c1:m9"}
{"signature": "@classmethod<EOL><INDENT>def defaults_docstring(cls, header=None, indent=None, footer=None):<DEDENT>", "body": "return defaults_docstring(cls.defaults, header=header,<EOL>indent=indent, footer=footer)<EOL>", "docstring": "Add the default values to the class docstring", "id": "f11587:c1:m4"}
{"signature": "@property<EOL><INDENT>def value(self):<DEDENT>", "body": "return self.__value__<EOL>", "docstring": "Return the current value\n\n        This may be modified by sub-classes to do additional\n        operations (such as caching the results of\n        complicated operations needed to compute the value)", "id": "f11587:c1:m5"}
{"signature": "def check_dates(self, event, valid_dates):", "body": "for year, dates in valid_dates.items():<EOL><INDENT>for month, days in dates.items():<EOL><INDENT>response = self.client.get(reverse(<EOL>'<STR_LIT>', kwargs={'<STR_LIT>': year, '<STR_LIT>': month}<EOL>))<EOL>self.clean_whitespace(response)<EOL>if days:<EOL><INDENT>self.assertContains(response, event.title)<EOL><DEDENT>else:<EOL><INDENT>self.assertNotContains(response, event.title)<EOL><DEDENT>for day in days:<EOL><INDENT>self.assertContains(response, self.cal_str(day))<EOL><DEDENT>[self.assertNotContains(response, self.cal_str(day)) for<EOL>day in xrange(<NUM_LIT:1>, monthrange(<NUM_LIT>, int(month))[<NUM_LIT:1>] + <NUM_LIT:1>)<EOL>if day not in days]<EOL><DEDENT><DEDENT>", "docstring": "A DRY helper function.", "id": "f11593:c0:m0"}
{"signature": "def create_event(created_by, title, description, all_day=False,<EOL>start_date=None, end_date=None, categories=None, tags=None,<EOL>repeat='<STR_LIT>', end_repeat=None, full=True, utc=False):", "body": "if start_date and end_date:<EOL><INDENT>if utc:<EOL><INDENT>val = timezone.utc<EOL><DEDENT>else:<EOL><INDENT>val = timezone.get_default_timezone()<EOL><DEDENT>start_date = timezone.make_aware(datetime.datetime(*start_date), val)<EOL>end_date = timezone.make_aware(datetime.datetime(*end_date), val)<EOL><DEDENT>elif start_date and not end_date or end_date and not start_date:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>start_date = timezone.now()<EOL>end_date = timezone.now()<EOL><DEDENT>event = Event.objects.create(<EOL>start_date=start_date,<EOL>end_date=end_date,<EOL>all_day=all_day,<EOL>created_by=created_by,<EOL>title=title,<EOL>description=description,<EOL>repeat=repeat,<EOL>end_repeat=end_repeat<EOL>)<EOL>if categories:<EOL><INDENT>for category in categories:<EOL><INDENT>event.categories.create(title=category)<EOL><DEDENT><DEDENT>if tags:<EOL><INDENT>for tag in tags:<EOL><INDENT>event.tags.create(name=tag)<EOL><DEDENT><DEDENT>if full:<EOL><INDENT>event.full_clean()<EOL>event.save()<EOL><DEDENT>return event<EOL>", "docstring": "A factory method for creating events. If start_date is supplied,\nend_date must also be supplied, and they must both be either lists\nor tuples e.g. start_date=[2014, 2, 2], end_date=[2014, 2, 3].", "id": "f11600:m0"}
{"signature": "def assertContentBefore(self, response, text1, text2):", "body": "failing_msg = \"<STR_LIT>\" % (text1, text2)<EOL>self.assertEqual(response.status_code, <NUM_LIT:200>)<EOL>self.assertTrue(<EOL>response.content.index(force_bytes(text1)) <<EOL>response.content.index(force_bytes(text2)),<EOL>failing_msg)<EOL>", "docstring": "Testing utility asserting that text1 appears before text2 in response\ncontent. Modified from:\nhttps://github.com/django/django/blob/master/tests/admin_views/tests.py", "id": "f11615:c0:m1"}
{"signature": "def _get_kwargs(self, category, tag):", "body": "vals = {<EOL>'<STR_LIT>': category,<EOL>'<STR_LIT>': tag<EOL>}<EOL>kwargs = {}<EOL>for k, v in vals.items():<EOL><INDENT>if v:<EOL><INDENT>kwargs[k] = v<EOL><DEDENT><DEDENT>return kwargs<EOL>", "docstring": "Helper function for getting category/tag kwargs.", "id": "f11625:c0:m0"}
{"signature": "def render_to_json_response(self, context, **kwargs):", "body": "return HttpResponse(<EOL>self.convert_context_to_json(context),<EOL>content_type='<STR_LIT:application/json>',<EOL>**kwargs<EOL>)<EOL>", "docstring": "Returns a JSON response, transforming 'context' to make the payload.", "id": "f11626:c0:m0"}
{"signature": "def formatday(<EOL>self, day, weekday,<EOL>day_template='<STR_LIT>',<EOL>noday_template='<STR_LIT>',<EOL>popover_template='<STR_LIT>',<EOL>):", "body": "super(EventCalendar, self).formatday(day, weekday)<EOL>now = get_now()<EOL>context = self.get_context()<EOL>context['<STR_LIT>'] = []<EOL>context['<STR_LIT>'] = day<EOL>context['<STR_LIT>'] = self.get_day_url(day)<EOL>context['<STR_LIT>'] = date(self.yr, self.mo, <NUM_LIT:1>)<EOL>context['<STR_LIT>'] = weekday<EOL>context['<STR_LIT>'] = self.cssclasses[weekday]<EOL>context['<STR_LIT>'] = popover_template<EOL>context['<STR_LIT>'] = len(self.count.get(day, [])),<EOL>try:<EOL><INDENT>processed_date = date(self.yr, self.mo, day)<EOL><DEDENT>except ValueError:<EOL><INDENT>processed_date = None<EOL><DEDENT>context['<STR_LIT>'] = date(self.yr, self.mo, <NUM_LIT:1>)<EOL>if day == <NUM_LIT:0>:<EOL><INDENT>template = noday_template<EOL><DEDENT>else:<EOL><INDENT>template = day_template<EOL><DEDENT>if now.date() == processed_date:<EOL><INDENT>context['<STR_LIT>'] = True<EOL><DEDENT>if processed_date and (day in self.count):<EOL><INDENT>for item in self.count[day]:<EOL><INDENT>self.pk = item[<NUM_LIT:1>]<EOL>self.title = item[<NUM_LIT:0>]<EOL>for event in self.events:<EOL><INDENT>if event.pk == self.pk:<EOL><INDENT>event.check_if_cancelled(processed_date)<EOL>context['<STR_LIT>'].append(event)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return render_to_string(template, context)<EOL>", "docstring": "Return a day as a table cell.", "id": "f11628:c1:m1"}
{"signature": "def formatday(self, day, weekday):", "body": "super(EventCalendar, self).formatday(day, weekday)<EOL>now = get_now()<EOL>self.day = day<EOL>out = '<STR_LIT>'<EOL>if day == <NUM_LIT:0>:<EOL><INDENT>return '<STR_LIT>'  <EOL><DEDENT>elif now.month == self.mo and now.year == self.yr and day == now.day:<EOL><INDENT>if day in self.count:<EOL><INDENT>out = self.wkday_today + self.anch<EOL><DEDENT>else:<EOL><INDENT>return self.wkday_today + self.anch + self.end<EOL><DEDENT><DEDENT>elif day in self.count:<EOL><INDENT>out = self.wkday_not_today + self.anch<EOL><DEDENT>else:<EOL><INDENT>return self.wkday_not_today + self.anch + self.end<EOL><DEDENT>detail = \"<STR_LIT>\"<EOL>extras = ('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>common = '<STR_LIT>'<EOL>for item in self.count[day]:<EOL><INDENT>self.pk = item[<NUM_LIT:1>]<EOL>self.title = item[<NUM_LIT:0>]<EOL>for event in self.events:<EOL><INDENT>if event.pk == self.pk:<EOL><INDENT>self.event = event<EOL>self.check_if_cancelled()<EOL>self.popover_helper()<EOL>bg, fnt = self.event.get_colors()<EOL><DEDENT><DEDENT>out += ('<STR_LIT>' + self.event_url + '<STR_LIT>' +<EOL>extras % (<EOL>self.title,<EOL>detail % (<EOL>self.when, self.where, self.desc, self.event_url<EOL>),<EOL>common % (bg, fnt)<EOL>) +<EOL>self.title2 + '<STR_LIT>')<EOL><DEDENT>return out + self.end<EOL>", "docstring": "Return a day as a table cell.", "id": "f11628:c4:m1"}
{"signature": "def clean_year_month(year, month, month_orig):", "body": "error = False<EOL>error_msg = \"<STR_LIT>\"<EOL>if month_orig not in xrange(<NUM_LIT:1>, <NUM_LIT>) and month_orig is not None:<EOL><INDENT>month = now.month<EOL>error = error_msg<EOL><DEDENT>while month > <NUM_LIT:12>:<EOL><INDENT>month -= <NUM_LIT:12><EOL>year += <NUM_LIT:1><EOL><DEDENT>while month < <NUM_LIT:1>:<EOL><INDENT>month += <NUM_LIT:12><EOL>year -= <NUM_LIT:1><EOL><DEDENT>year, month, error = _check_year(year, month, error, error_msg)<EOL>return year, month, error<EOL>", "docstring": "If 'month_orig', which is the month given in the url BEFORE any next/prev\nquery strings have been applied, is out of range, sets month to the\ncurrent month and returns an error message. Also Returns an error\nmessage if the year given is +/- 50 years from now.\nIf 'month', which is the month given in the url AFTER any next/prev\nquery strings have been applied, is out of range, adjusts it to be\nin range (by also adjusting the year).", "id": "f11629:m10"}
{"signature": "def _inc_day(year, month, day, net):", "body": "d = date(year, month, day)<EOL>new_d = d + timezone.timedelta(days=net)<EOL>return new_d.year, new_d.month, new_d.day<EOL>", "docstring": "Increments the day by converting to a datetime.date().", "id": "f11629:m1"}
{"signature": "def inc_month(month, year):", "body": "month += <NUM_LIT:1><EOL>if month > <NUM_LIT:12>:<EOL><INDENT>month = <NUM_LIT:1><EOL>year += <NUM_LIT:1><EOL><DEDENT>return month, year<EOL>", "docstring": "Increment the month and, if neccessary, the year.\nBoth month and year should be ints.", "id": "f11629:m0"}
{"signature": "def repeat_reverse(self, start, end):", "body": "day = start<EOL>diff = start - end<EOL>try:<EOL><INDENT>if date(self.year, self.month, day) <= self.end_repeat:<EOL><INDENT>self.count_it(day)<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT>for i in xrange(diff):<EOL><INDENT>day -= <NUM_LIT:1><EOL>try:<EOL><INDENT>if date(self.year, self.month, day) <= self.end_repeat:<EOL><INDENT>self.count_it(day)<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>", "docstring": "Starts from 'start' day and counts backwards until 'end' day.\n'start' should be >= 'end'. If it's equal to, does nothing.\nIf a day falls outside of end_repeat, it won't be counted.", "id": "f11630:c0:m4"}
{"signature": "def _handle_weekly_repeat_out(self):", "body": "start_d = _first_weekday(<EOL>self.event.l_start_date.weekday(), date(self.year, self.month, <NUM_LIT:1>)<EOL>)<EOL>self.day = start_d.day<EOL>self.count_first = True<EOL>if self.event.repeats('<STR_LIT>'):<EOL><INDENT>self._biweekly_helper()<EOL><DEDENT>elif self.event.repeats('<STR_LIT>'):<EOL><INDENT>self.repeat()<EOL>if self.event.is_chunk():<EOL><INDENT>diff = self.event.start_end_diff<EOL>self.count = _chunk_fill_out_first_week(<EOL>self.year, self.month, self.count, self.event, diff<EOL>)<EOL>for i in xrange(diff):<EOL><INDENT>self.day = start_d.day + i + <NUM_LIT:1><EOL>self.repeat()<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Handles repeating an event weekly (or biweekly) if the current\nyear and month are outside of its start year and month.\nIt takes care of cases 3 and 4 in _handle_weekly_repeat_in() comments.", "id": "f11630:c4:m1"}
{"signature": "def repeat_biweekly(self):", "body": "mycount = defaultdict(list)<EOL>d = self.event.l_start_date<EOL>while d.year != self.year or d.month != self.month:<EOL><INDENT>d += timedelta(days=<NUM_LIT>)<EOL><DEDENT>r = self.__class__(<EOL>mycount, self.year, self.month, d.day, self.event.end_repeat,<EOL>self.event, num=self.num, count_first=True<EOL>)<EOL>r.repeat()<EOL>if self.event.is_chunk() and r.count:<EOL><INDENT>r.day = min(r.count)<EOL>r.repeat_chunk(self.event.start_end_diff)<EOL><DEDENT>return r.count<EOL>", "docstring": "This function is unique b/c it creates an empty defaultdict,\nadds in the event occurrences by creating an instance of Repeater,\nthen returns the defaultdict, likely to be merged into the 'main'\ndefaultdict (the one holding all event occurrences for this month).", "id": "f11630:c0:m6"}
{"signature": "def _first_weekday(weekday, d):", "body": "while weekday != d.weekday():<EOL><INDENT>d += timedelta(days=<NUM_LIT:1>)<EOL><DEDENT>return d<EOL>", "docstring": "Given a weekday and a date, will increment the date until it's\nweekday matches that of the given weekday, then that date is returned.", "id": "f11630:m0"}
{"signature": "def _handle_weekly_repeat_in(self):", "body": "self.day = self.event.l_start_date.day<EOL>self.count_first = False<EOL>repeats = {'<STR_LIT>': <NUM_LIT:7>, '<STR_LIT>': <NUM_LIT>}<EOL>if self.event.starts_same_year_month_as(self.year, self.month):<EOL><INDENT>for repeat, num in repeats.items():<EOL><INDENT>self.num = num<EOL>if self.event.repeats(repeat):<EOL><INDENT>self.repeat()<EOL>if self.event.is_chunk():<EOL><INDENT>self.repeat_chunk(diff=self.event.start_end_diff)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Handles repeating both weekly and biweekly events, if the\ncurrent year and month are inside it's l_start_date and l_end_date.\nFour possibilites:\n    1. The event starts this month and ends repeating this month.\n    2. The event starts this month and doesn't finish repeating\n    this month.\n    3. The event didn't start this month but ends repeating this month.\n    4. The event didn't start this month and doesn't end repeating\n    this month.", "id": "f11630:c4:m2"}
{"signature": "def _chunk_fill_out_first_week(year, month, count, event, diff):", "body": "first_of_the_month = date(year, month, <NUM_LIT:1>)<EOL>d = _first_weekday(event.l_end_date.weekday(), first_of_the_month)<EOL>d2 = _first_weekday(event.l_start_date.weekday(), first_of_the_month)<EOL>diff_weekdays = d.day - d2.day<EOL>day = first_of_the_month.day<EOL>start = event.l_start_date.weekday()<EOL>first = first_of_the_month.weekday()<EOL>if start == first or diff_weekdays == diff:<EOL><INDENT>return count<EOL><DEDENT>elif start > first:<EOL><INDENT>end = event.l_end_date.weekday()<EOL>diff = end - first + <NUM_LIT:1><EOL><DEDENT>elif start < first:<EOL><INDENT>diff = d.day<EOL><DEDENT>for i in xrange(diff):<EOL><INDENT>if event.end_repeat is not None anddate(year, month, day) >= event.end_repeat:<EOL><INDENT>break<EOL><DEDENT>count[day].append((event.title, event.pk))<EOL>day += <NUM_LIT:1><EOL><DEDENT>return count<EOL>", "docstring": "If a repeating chunk event exists in a particular month, but didn't\nstart that month, it may be neccessary to fill out the first week.\nFive cases:\n    1. event starts repeating on the 1st day of month\n    2. event starts repeating past the 1st day of month\n    3. event starts repeating before the 1st day of month, and continues\n    through it.\n    4. event starts repeating before the 1st day of month, and finishes\n    repeating before it.\n    5. event starts repeating before the 1st day of month, and finishes\n    on it.", "id": "f11630:m1"}
{"signature": "def repeat_it(self):", "body": "start_day = self.event.l_start_date.day<EOL>if not self.event.starts_same_month_as(self.month):<EOL><INDENT>self.count_it(start_day)<EOL><DEDENT>elif self.event.starts_same_month_not_year_as(self.month, self.year):<EOL><INDENT>self.count_it(start_day)<EOL><DEDENT>if self.event.is_chunk():<EOL><INDENT>self._repeat_chunk()<EOL><DEDENT>return self.count<EOL>", "docstring": "Events that repeat every month should be shown every month\non the same date they started e.g. an event that starts on the 23rd\nwould appear on the 23rd every month it is scheduled to repeat.", "id": "f11630:c2:m1"}
{"signature": "def repeat(self, day=None):", "body": "if day is None:<EOL><INDENT>day = self.day<EOL><DEDENT>try:<EOL><INDENT>d = date(self.year, self.month, day)<EOL><DEDENT>except ValueError:  <EOL><INDENT>return self.count<EOL><DEDENT>if self.count_first and d <= self.end_repeat:<EOL><INDENT>self.count_it(d.day)<EOL><DEDENT>d += timedelta(days=self.num)<EOL>if self.end_on is not None:<EOL><INDENT>while d.month == self.month andd <= self.end_repeat andd.day <= self.end_on:<EOL><INDENT>self.count_it(d.day)<EOL>d += timedelta(days=self.num)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>while d.month == self.month and d <= self.end_repeat:<EOL><INDENT>self.count_it(d.day)<EOL>d += timedelta(days=self.num)<EOL><DEDENT><DEDENT>", "docstring": "Add 'num' to the day and count that day until we reach end_repeat, or\nuntil we're outside of the current month, counting the days\nas we go along.", "id": "f11630:c0:m2"}
{"signature": "def day_display(year, month, all_month_events, day):", "body": "<EOL>count = CountHandler(year, month, all_month_events).get_count()<EOL>pks = [x[<NUM_LIT:1>] for x in count[day]]  <EOL>day_events = list(Event.objects.filter(pk__in=pks).order_by(<EOL>'<STR_LIT>').prefetch_related('<STR_LIT>'))<EOL>day_events.sort(key=lambda x: x.l_start_date.hour)<EOL>return day_events<EOL>", "docstring": "Returns the events that occur on the given day.\nWorks by getting all occurrences for the month, then drilling\ndown to only those occurring on the given day.", "id": "f11631:m2"}
{"signature": "def we_should_stop(self, start, start_):", "body": "if start > self.finish orself.event.end_repeat is not None andstart_ > self.event.end_repeat:<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Checks 'start' to see if we should stop collecting upcoming events.\n'start' should be a datetime.datetime, 'start_' should be the same\nas 'start', but it should be a datetime.date to allow comparison\nw/ end_repeat.", "id": "f11632:c0:m2"}
{"signature": "def get_l_end_date(self):", "body": "return timezone.localtime(self.end_date)<EOL>", "docstring": "Localized end date.", "id": "f11637:c0:m3"}
{"signature": "def check_if_cancelled(self, date):", "body": "result = self._check_if_cancelled_cache.get(date, None)<EOL>if result is None:<EOL><INDENT>try:<EOL><INDENT>self._prefetched_objects_cache[Event.cancellations.related.field.related_query_name()]<EOL>result = any(<EOL>((cancellation.date == date) for cancellation in self.cancellations.all())<EOL>)<EOL><DEDENT>except (AttributeError, KeyError):<EOL><INDENT>result = False<EOL>result = self.cancellations.filter(date=date).exists()<EOL><DEDENT>self._check_if_cancelled_cache[date] = result<EOL><DEDENT>if result:<EOL><INDENT>self.title_extra = _(\"<STR_LIT>\")<EOL><DEDENT>self._last_check_if_cancelled = result<EOL>return result<EOL>", "docstring": "Return True if event was in cancelled state at 'date'. Also set self.title_extra to ' (CANCELLED)' if it was so.\n\n        Warning! Results are memoized on instance level. If you need to reset \"cache\" of results then set ``instance._prefetched_objects_cache = {}``", "id": "f11637:c0:m20"}
{"signature": "def is_happening(self, now):", "body": "start = self.l_start_date<EOL>end = self.l_end_date<EOL>happening = False<EOL>if (now >= start) and (start.time() <= now.time() <= end.time()):<EOL><INDENT>if self.repeats('<STR_LIT>'):<EOL><INDENT>if not now.weekday() > <NUM_LIT:4>:  <EOL><INDENT>happening = True<EOL><DEDENT><DEDENT>elif self.repeats('<STR_LIT>') or self.repeats('<STR_LIT>'):<EOL><INDENT>happening = True<EOL><DEDENT>elif self.repeats('<STR_LIT>'):<EOL><INDENT>if start.day <= now.day <= end.day:<EOL><INDENT>happening = True<EOL><DEDENT><DEDENT>elif self.repeats('<STR_LIT>'):<EOL><INDENT>if (start.month <= now.month <= end.month) and(start.day <= now.day <= end.day):<EOL><INDENT>happening = True<EOL><DEDENT><DEDENT>else:<EOL><INDENT>repeat = {'<STR_LIT>': <NUM_LIT:7>, '<STR_LIT>': <NUM_LIT>}<EOL>while end <= now:<EOL><INDENT>start += datetime.timedelta(days=repeat[self.repeat])<EOL>end += datetime.timedelta(days=repeat[self.repeat])<EOL><DEDENT>if start <= now <= end:<EOL><INDENT>happening = True<EOL><DEDENT><DEDENT><DEDENT>return happening<EOL>", "docstring": "Return True if the event is happening 'now', False if not.", "id": "f11637:c0:m5"}
{"signature": "def get_start_end_diff(self):", "body": "s = self.l_start_date<EOL>e = self.l_end_date<EOL>start = datetime.date(s.year, s.month, s.day)<EOL>end = datetime.date(e.year, e.month, e.day)<EOL>diff = start - end<EOL>return abs(diff.days)<EOL>", "docstring": "Return the difference between start and end dates.", "id": "f11637:c0:m14"}
{"signature": "def _get_max_fd(self):", "body": "limits = resource.getrlimit(resource.RLIMIT_NOFILE)<EOL>result = limits[<NUM_LIT:1>]<EOL>if result == resource.RLIM_INFINITY:<EOL><INDENT>result = maxfd<EOL><DEDENT>return result<EOL>", "docstring": "Return the maximum file descriptor value.", "id": "f11639:c1:m1"}
{"signature": "def call(args, stdout=None, stderr=None, stdin=None, daemonize=False,<EOL>preexec_fn=None, shell=False, cwd=None, env=None):", "body": "stream = lambda s, m: s is None and os.open(os.devnull, m) or s<EOL>stdout = stream(stdout, os.O_WRONLY)<EOL>stderr = stream(stderr, os.O_WRONLY)<EOL>stdin = stream(stdin, os.O_RDONLY)<EOL>shared_pid = Value('<STR_LIT:i>', <NUM_LIT:0>)<EOL>pid = os.fork()<EOL>if pid > <NUM_LIT:0>:<EOL><INDENT>os.waitpid(pid, <NUM_LIT:0>)<EOL>child_pid = shared_pid.value<EOL>del shared_pid<EOL>if daemonize:<EOL><INDENT>sys.exit(<NUM_LIT:0>)<EOL><DEDENT>return child_pid<EOL><DEDENT>else:<EOL><INDENT>os.setsid()<EOL>proc = subprocess.Popen(args, stdout=stdout, stderr=stderr, stdin=stdin, close_fds=True,<EOL>preexec_fn=preexec_fn, shell=shell, cwd=cwd, env=env)<EOL>shared_pid.value = proc.pid<EOL>os._exit(<NUM_LIT:0>)<EOL><DEDENT>", "docstring": "Run an external command in a separate process and detach it from the current process. Excepting\n`stdout`, `stderr`, and `stdin` all file descriptors are closed after forking. If `daemonize`\nis True then the parent process exits. All stdio is redirected to `os.devnull` unless\nspecified. The `preexec_fn`, `shell`, `cwd`, and `env` parameters are the same as their `Popen`\ncounterparts. Return the PID of the child process if not daemonized.", "id": "f11639:m0"}
{"signature": "def __init__(self, stdout=None, stderr=None, stdin=None, close_fds=False, exclude_fds=None,<EOL>daemonize=False):", "body": "self.stdout = stdout<EOL>self.stderr = stderr<EOL>self.stdin = stdin<EOL>self.close_fds = close_fds<EOL>self.exclude_fds = set()<EOL>self.daemonize = daemonize<EOL>self.pid = None<EOL>self.shared_pid = Value('<STR_LIT:i>', <NUM_LIT:0>)<EOL>for item in list(exclude_fds or []) + [stdout, stderr, stdin]:<EOL><INDENT>if hasattr(item, '<STR_LIT>'):<EOL><INDENT>item = item.fileno()<EOL><DEDENT>self.exclude_fds.add(item)<EOL><DEDENT>", "docstring": "Fork and detach a process. The stdio streams of the child default to /dev/null but may be\noverridden with the `stdout`, `stderr`, and `stdin` parameters. If `close_fds` is True then\nall open file descriptors (except those passed as overrides for stdio) are closed by the\nchild process. File descriptors in `exclude_fds` will not be closed. If `daemonize` is True\nthen the parent process exits.", "id": "f11639:c1:m0"}
{"signature": "def parentonly(func):", "body": "def wrapper(*args, **kwargs):<EOL><INDENT>pid = os.getpid()<EOL>if pid == parent_pid:<EOL><INDENT>return func(*args, **kwargs)<EOL><DEDENT><DEDENT>wrapper.__name__ = func.__name__<EOL>return wrapper<EOL>", "docstring": "Only execute the decorated function in the parent thread.", "id": "f11641:m0"}
{"signature": "def apply_tasks_to_issue(self, issue, tasks, issue_body=None):", "body": "issue_body = issue_body or issue.body<EOL>task_numbers = transport.format_task_numbers_with_links(tasks)<EOL>if task_numbers:<EOL><INDENT>new_body = transport.ASANA_SECTION_RE.sub('<STR_LIT>', issue_body)<EOL>new_body = new_body + \"<STR_LIT>\" % task_numbers<EOL>transport.issue_edit(issue,<EOL>body=new_body)<EOL>return new_body<EOL><DEDENT>return issue_body<EOL>", "docstring": "Applies task numbers to an issue.", "id": "f11643:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def add_arguments(cls, parser):<DEDENT>", "body": "parser.add_argument(<EOL>'<STR_LIT>',<EOL>action='<STR_LIT:store>',<EOL>nargs='<STR_LIT:?>',<EOL>const='<STR_LIT>',<EOL>dest='<STR_LIT>',<EOL>help=\"<STR_LIT>\",<EOL>)<EOL>parser.add_argument(<EOL>'<STR_LIT>',<EOL>action='<STR_LIT:store>',<EOL>nargs='<STR_LIT:?>',<EOL>const='<STR_LIT>',<EOL>dest='<STR_LIT>',<EOL>help=\"<STR_LIT>\",<EOL>)<EOL>pass<EOL>", "docstring": "Add arguments to the parser for collection in app.args.\n\n        Args:\n            parser:\n                `argparse.ArgumentParser`. Parser.\n                Arguments added here are server on\n                self.args.", "id": "f11647:c0:m0"}
{"signature": "def __init__(self, filename, args, version):", "body": "self.args = args<EOL>self.version = version<EOL>self.filename = filename<EOL>try:<EOL><INDENT>with open(self.filename, '<STR_LIT:rb>') as file:<EOL><INDENT>self.data = json.load(file)<EOL><DEDENT><DEDENT>except IOError:<EOL><INDENT>self.data = {}<EOL><DEDENT>", "docstring": "Args:\n    filename:\n        Filename for database.\n    args:\n        Program arguments.\n    version:\n        Version of file.", "id": "f11648:c0:m0"}
{"signature": "def __setitem__(self, key, value):", "body": "self.data[key] = value<EOL>", "docstring": "Set a value by key.", "id": "f11648:c0:m3"}
{"signature": "def get_saved_task_data(self, task):", "body": "if isinstance(task, int):<EOL><INDENT>task_number = str(task)<EOL><DEDENT>elif isinstance(task, str):<EOL><INDENT>task_number = task<EOL><DEDENT>else:<EOL><INDENT>task_number = task['<STR_LIT:id>']<EOL><DEDENT>task_data_key = self._task_data_key()<EOL>task_data = self.data.get(task_data_key, {})<EOL>_data = task_data.get(str(task_number), {})<EOL>task_data[str(task_number)] = _data<EOL>return _data<EOL>", "docstring": "Returns task data from local data.\n\n        Args:\n            task:\n                `int`. Asana task number.", "id": "f11649:c0:m13"}
{"signature": "@classmethod<EOL><INDENT>def _task_data_key(cls):<DEDENT>", "body": "return '<STR_LIT>'<EOL>", "docstring": "Returns key for task_data in data.", "id": "f11649:c0:m11"}
{"signature": "def get_saved_issue_data(self, issue, namespace='<STR_LIT>'):", "body": "if isinstance(issue, int):<EOL><INDENT>issue_number = str(issue)<EOL><DEDENT>elif isinstance(issue, str):<EOL><INDENT>issue_number = issue<EOL><DEDENT>else:<EOL><INDENT>issue_number = issue.number<EOL><DEDENT>issue_data_key = self._issue_data_key(namespace)<EOL>issue_data = self.data.get(issue_data_key,<EOL>{})<EOL>_data = issue_data.get(str(issue_number), {})<EOL>issue_data[str(issue_number)] = _data<EOL>return _data<EOL>", "docstring": "Returns issue data from local data.\n\n        Args:\n            issue:\n                `int`. Github issue number.\n            namespace:\n                `str`. Namespace for storing this issue.", "id": "f11649:c0:m9"}
{"signature": "@classmethod<EOL><INDENT>def _list_select(cls, lst, prompt, offset=<NUM_LIT:0>):<DEDENT>", "body": "inp = input(\"<STR_LIT>\" % prompt)<EOL>assert inp, \"<STR_LIT>\"<EOL>try:<EOL><INDENT>return lst[int(inp)+offset]<EOL><DEDENT>except ValueError:<EOL><INDENT>return inp<EOL><DEDENT>except IndexError:<EOL><INDENT>assert False, \"<STR_LIT>\"<EOL><DEDENT>", "docstring": "Given a list of values and names, accepts the index value or name.", "id": "f11649:c0:m2"}
{"signature": "def authenticate(self):", "body": "if self.oauth:<EOL><INDENT>return False<EOL><DEDENT>self.settings.apply('<STR_LIT>', self.args.asana_api,<EOL>\"<STR_LIT>\")<EOL>self.settings.apply('<STR_LIT>', self.args.github_api,<EOL>\"<STR_LIT>\")<EOL>logging.debug(\"<STR_LIT>\")<EOL>self.asana = Client.basic_auth(self.settings['<STR_LIT>'])<EOL>self.asana_errors = asana_errors<EOL>self.asana_me = self.asana.users.me()<EOL>logging.debug(\"<STR_LIT>\")<EOL>self.github = Github(self.settings['<STR_LIT>'])<EOL>self.github_user = self.github.get_user()<EOL>self.oauth = True<EOL>", "docstring": "Connects to Github and Asana and authenticates via OAuth.", "id": "f11649:c0:m1"}
{"signature": "def tool_app():", "body": "app = ToolApp(version=__VERSION__)<EOL>exit(app.exit_code)<EOL>", "docstring": "Starts the tool.", "id": "f11650:m0"}
{"signature": "def iter_settings():", "body": "while True:<EOL><INDENT>try:<EOL><INDENT>item = settings_queue.get(timeout=<NUM_LIT:1>)<EOL>yield item<EOL><DEDENT>except queue.Empty:<EOL><INDENT>return<EOL><DEDENT><DEDENT>", "docstring": "Yields items from the settings queue.", "id": "f11651:m10"}
{"signature": "@transport_task<EOL><INDENT>def apply_tasks_to_issue(self, tasks, issue_number, issue_body):<DEDENT>", "body": "issue_body = issue_body<EOL>task_numbers = format_task_numbers_with_links(tasks)<EOL>if task_numbers:<EOL><INDENT>new_body = ASANA_SECTION_RE.sub('<STR_LIT>', issue_body)<EOL>new_body = new_body + \"<STR_LIT>\" % task_numbers<EOL>put(\"<STR_LIT>\",<EOL>issue_number=issue_number,<EOL>body=new_body)<EOL>return new_body<EOL><DEDENT>return issue_body<EOL>", "docstring": "Applies task numbers to an issue.", "id": "f11651:c0:m8"}
{"signature": "def task_create(asana_workspace_id, name, notes, assignee, projects,<EOL>completed, **kwargs):", "body": "put(\"<STR_LIT>\",<EOL>asana_workspace_id=asana_workspace_id,<EOL>name=name,<EOL>notes=notes,<EOL>assignee=assignee,<EOL>projects=projects,<EOL>completed=completed,<EOL>**kwargs)<EOL>", "docstring": "Creates a task", "id": "f11651:m6"}
{"signature": "def issue_edit(issue, **kwargs):", "body": "put(\"<STR_LIT>\",<EOL>issue_number=issue.number,<EOL>**kwargs)<EOL>", "docstring": "Saves an issue", "id": "f11651:m5"}
{"signature": "def find_next_sibling(self, *args, **kwargs):", "body": "return NullNode()<EOL>", "docstring": "Returns :class:`NullNode`", "id": "f11655:c12:m5"}
{"signature": "@property<EOL><INDENT>def next_sibling(self):<DEDENT>", "body": "return self._wrap_node(operator.attrgetter('<STR_LIT>'))<EOL>", "docstring": "The :class:`Node` sibling after this, or :class:`NullNode`", "id": "f11655:c10:m11"}
{"signature": "def find_all(self, *args, **kwargs):", "body": "return NullCollection()<EOL>", "docstring": "Returns :class:`NullCollection`", "id": "f11655:c12:m6"}
{"signature": "def dropwhile(self, func=None):", "body": "func = _make_callable(func)<EOL>return Collection(dropwhile(func, self._items))<EOL>", "docstring": "Return a new Collection with the first few items removed.\n\nParameters:\n\n    func : function(Node) -> Node\n\nReturns:\n\n    A new Collection, discarding all items\n    before the first item where bool(func(item)) == True", "id": "f11655:c7:m9"}
{"signature": "@property<EOL><INDENT>def attrs(self):<DEDENT>", "body": "return self._wrap_scalar(operator.attrgetter('<STR_LIT>'))<EOL>", "docstring": "A :class:`Scalar` of this Node's attribute dictionary\n\nExample:\n\n    >>> Soupy(\"<a val=3></a>\").find('a').attrs\n    Scalar({u'val': u'3'})", "id": "f11655:c10:m13"}
{"signature": "def find_parents(self, *args, **kwargs):", "body": "return NullCollection()<EOL>", "docstring": "Returns :class:`NullCollection`", "id": "f11655:c12:m7"}
{"signature": "@property<EOL><INDENT>def previous_sibling(self):<DEDENT>", "body": "return self._wrap_node(operator.attrgetter('<STR_LIT>'))<EOL>", "docstring": "The :class:`Node` sibling prior to this, or :class:`NullNode`", "id": "f11655:c10:m12"}
{"signature": "def find_next_sibling(self, *args, **kwargs):", "body": "op = operator.methodcaller('<STR_LIT>', *args, **kwargs)<EOL>return self._wrap_node(op)<EOL>", "docstring": "Like :meth:`find`, but searches through :attr:`next_siblings`", "id": "f11655:c10:m17"}
{"signature": "def val(self):", "body": "return self._value<EOL>", "docstring": "Return the value inside a wrapper.\n\nRaises :class:`NullValueError` if called on a Null object", "id": "f11655:c4:m4"}
{"signature": "def val(self):", "body": "return list(self.iter_val())<EOL>", "docstring": "Unwraps each item in the collection, and returns as a list", "id": "f11655:c7:m2"}
{"signature": "@classmethod<EOL><INDENT>def wrap(cls, value):<DEDENT>", "body": "if isinstance(value, Wrapper):<EOL><INDENT>return value<EOL><DEDENT>if hasattr(value, '<STR_LIT>'):<EOL><INDENT>return Node(value)<EOL><DEDENT>return Scalar(value)<EOL>", "docstring": "Wrap value in the appropriate wrapper class,\nbased upon its type.", "id": "f11655:c0:m6"}
{"signature": "def exclude(self, func=None):", "body": "func = _make_callable(func)<EOL>inverse = lambda x: not func(x)<EOL>return self.filter(inverse)<EOL>", "docstring": "Return a new Collection excluding some items\n\nParameters:\n\n    func : function(Node) -> Scalar\n\n        A function that, when called on each item\n        in the collection, returns a boolean-like\n        value. If no function is provided, then\n        truthy items will be removed.\n\nReturns:\n\n    A new Collection consisting of the items\n    where bool(func(item)) == False", "id": "f11655:c7:m6"}
{"signature": "def find_previous_sibling(self, *args, **kwargs):", "body": "op = operator.methodcaller('<STR_LIT>', *args, **kwargs)<EOL>return self._wrap_node(op)<EOL>", "docstring": "Like :meth:`find`, but searches through :attr:`previous_siblings`", "id": "f11655:c10:m19"}
{"signature": "def apply(self, func):", "body": "return self<EOL>", "docstring": "Returns :class:`Null`", "id": "f11655:c3:m3"}
{"signature": "def takewhile(self, func=None):", "body": "func = _make_callable(func)<EOL>return Collection(takewhile(func, self._items))<EOL>", "docstring": "Return a new Collection with the last few items removed.\n\nParameters:\n\n    func : function(Node) -> Node\n\nReturns:\n\n    A new Collection, discarding all items\n    at and after the first item where bool(func(item)) == False\n\nExamples:\n\n    node.find_all('tr').takewhile(Q.find_all('td').count() > 3)", "id": "f11655:c7:m8"}
{"signature": "@property<EOL><INDENT>def next_siblings(self):<DEDENT>", "body": "return self._wrap_multi(operator.attrgetter('<STR_LIT>'))<EOL>", "docstring": "A :class:`Collection` of all siblings after this node", "id": "f11655:c10:m8"}
{"signature": "@property<EOL><INDENT>def descendants(self):<DEDENT>", "body": "return self._wrap_multi(operator.attrgetter('<STR_LIT>'))<EOL>", "docstring": "A :class:`Collection` of all elements nested inside this Node.", "id": "f11655:c10:m7"}
{"signature": "def map(self, func):", "body": "return Wrapper.wrap(_make_callable(func)(self._value))<EOL>", "docstring": "Call a function on a wrapper's value, and wrap the result if necessary.\n\nParameters:\n\n    func : function(val) -> val\n\nExamples:\n\n    >>> s = Scalar(3)\n    >>> s.map(Q * 2)\n    Scalar(6)", "id": "f11655:c4:m1"}
{"signature": "def generate_population(self):", "body": "if self.__num_processes > <NUM_LIT:1>:<EOL><INDENT>process_pool = Pool(processes=self.__num_processes)<EOL><DEDENT>self.__members = []<EOL>for _ in range(self.__pop_size):<EOL><INDENT>feed_dict = {}<EOL>for param in self.__parameters:<EOL><INDENT>feed_dict[param.name] = self.__random_param_val(<EOL>param.min_val,<EOL>param.max_val,<EOL>param.dtype<EOL>)<EOL><DEDENT>if self.__num_processes > <NUM_LIT:1>:<EOL><INDENT>self.__members.append(process_pool.apply_async(<EOL>self._start_process,<EOL>[self.__cost_fn, feed_dict, self.__cost_fn_args])<EOL>)<EOL><DEDENT>else:<EOL><INDENT>self.__members.append(<EOL>Member(<EOL>feed_dict,<EOL>self.__cost_fn(feed_dict, self.__cost_fn_args)<EOL>)<EOL>)<EOL><DEDENT><DEDENT>if self.__num_processes > <NUM_LIT:1>:<EOL><INDENT>process_pool.close()<EOL>process_pool.join()<EOL><DEDENT>self.__determine_best_member()<EOL>", "docstring": "Generates self.__pop_size Members with randomly initialized values\n        for each parameter added with add_parameter(), evaluates their fitness", "id": "f11657:c2:m11"}
{"signature": "def __determine_best_member(self):", "body": "if self.__num_processes > <NUM_LIT:1>:<EOL><INDENT>members = [m.get() for m in self.__members]<EOL><DEDENT>else:<EOL><INDENT>members = self.__members<EOL><DEDENT>if self.__best_fitness is None:<EOL><INDENT>self.__best_fitness = members[<NUM_LIT:0>].fitness_score<EOL>self.__best_cost_fn_val = members[<NUM_LIT:0>].cost_fn_val<EOL>self.__best_parameters = {}<EOL>for p in self.__parameters:<EOL><INDENT>self.__best_parameters[p.name] = members[<NUM_LIT:0>].parameters[p.name]<EOL><DEDENT><DEDENT>for m_id, member in enumerate(members):<EOL><INDENT>if member.fitness_score > self.__best_fitness:<EOL><INDENT>self.__best_fitness = member.fitness_score<EOL>self.__best_cost_fn_val = member.cost_fn_val<EOL>self.__best_parameters = {}<EOL>for p in self.__parameters:<EOL><INDENT>self.__best_parameters[p.name] = member.parameters[p.name]<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Private method: determines if any current population members have a\n        fitness score better than the current best", "id": "f11657:c2:m16"}
{"signature": "@property<EOL><INDENT>def fitness(self):<DEDENT>", "body": "if len(self.__members) != <NUM_LIT:0>:<EOL><INDENT>if self.__num_processes > <NUM_LIT:1>:<EOL><INDENT>members = [m.get() for m in self.__members]<EOL><DEDENT>else:<EOL><INDENT>members = self.__members<EOL><DEDENT>return sum(m.fitness_score for m in members) / len(members)<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Population fitness == average member fitness score", "id": "f11657:c2:m2"}
{"signature": "def next_generation(self, mut_rate=<NUM_LIT:0>, max_mut_amt=<NUM_LIT:0>, log_base=<NUM_LIT:10>):", "body": "if self.__num_processes > <NUM_LIT:1>:<EOL><INDENT>process_pool = Pool(processes=self.__num_processes)<EOL>members = [m.get() for m in self.__members]<EOL><DEDENT>else:<EOL><INDENT>members = self.__members<EOL><DEDENT>if len(members) == <NUM_LIT:0>:<EOL><INDENT>raise Exception(<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>selected_members = self.__select_fn(members)<EOL>reproduction_probs = list(reversed(logspace(<NUM_LIT:0.0>, <NUM_LIT:1.0>,<EOL>num=len(selected_members), base=log_base)))<EOL>reproduction_probs = reproduction_probs / sum(reproduction_probs)<EOL>self.__members = []<EOL>for _ in range(self.__pop_size):<EOL><INDENT>parent_1 = nrandom.choice(selected_members, p=reproduction_probs)<EOL>parent_2 = nrandom.choice(selected_members, p=reproduction_probs)<EOL>feed_dict = {}<EOL>for param in self.__parameters:<EOL><INDENT>which_parent = uniform(<NUM_LIT:0>, <NUM_LIT:1>)<EOL>if which_parent < <NUM_LIT:0.5>:<EOL><INDENT>feed_dict[param.name] = parent_1.parameters[param.name]<EOL><DEDENT>else:<EOL><INDENT>feed_dict[param.name] = parent_2.parameters[param.name]<EOL><DEDENT>feed_dict[param.name] = self.__mutate_parameter(<EOL>feed_dict[param.name], param, mut_rate, max_mut_amt<EOL>)<EOL><DEDENT>if self.__num_processes > <NUM_LIT:1>:<EOL><INDENT>self.__members.append(process_pool.apply_async(<EOL>self._start_process,<EOL>[self.__cost_fn, feed_dict, self.__cost_fn_args])<EOL>)<EOL><DEDENT>else:<EOL><INDENT>self.__members.append(<EOL>Member(<EOL>feed_dict,<EOL>self.__cost_fn(feed_dict, self.__cost_fn_args)<EOL>)<EOL>)<EOL><DEDENT><DEDENT>if self.__num_processes > <NUM_LIT:1>:<EOL><INDENT>process_pool.close()<EOL>process_pool.join()<EOL><DEDENT>self.__determine_best_member()<EOL>", "docstring": "Generates the next population from a previously evaluated generation\n\n        Args:\n            mut_rate (float): mutation rate for new members (0.0 - 1.0)\n            max_mut_amt (float): how much the member is allowed to mutate\n                (0.0 - 1.0, proportion change of mutated parameter)\n            log_base (int): the higher this number, the more likely the first\n                Members (chosen with supplied selection function) are chosen\n                as parents for the next generation", "id": "f11657:c2:m12"}
{"signature": "@property<EOL><INDENT>def med_cost_fn_val(self):<DEDENT>", "body": "if len(self.__members) != <NUM_LIT:0>:<EOL><INDENT>if self.__num_processes > <NUM_LIT:1>:<EOL><INDENT>members = [m.get() for m in self.__members]<EOL><DEDENT>else:<EOL><INDENT>members = self.__members<EOL><DEDENT>return median([m.cost_fn_val for m in members])<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Returns median cost function return value for all members", "id": "f11657:c2:m5"}
{"signature": "@staticmethod<EOL><INDENT>def __random_param_val(min_val, max_val, dtype):<DEDENT>", "body": "return SUPPORTED_DTYPES[dtype](min_val, max_val)<EOL>", "docstring": "Private, static method: returns a random value\n\nArgs:\n    min_val (int or float): minimum value for random value\n    max_Val (int or float): maximum value for random vlaue\n    dtype (type): type of random value, int or float\n\nReturns:\n    int or float: random value", "id": "f11657:c2:m14"}
{"signature": "def begin(self, total: int, name=None, message=None):", "body": "self.total = total<EOL>message = message or name or \"<STR_LIT>\"<EOL>self.name = name or \"<STR_LIT>\"<EOL>self.update(<NUM_LIT:0>, message)<EOL>", "docstring": "Call before starting work on a monitor, specifying name and amount of work", "id": "f11665:c0:m1"}
{"signature": "def monitored(total: int, name=None, message=None):", "body": "def decorator(f):<EOL><INDENT>nonlocal name<EOL>monitor_index = list(inspect.signature(f).parameters.keys()).index('<STR_LIT>')<EOL>if name is None:<EOL><INDENT>name=f.__name__<EOL><DEDENT>@wraps(f)<EOL>def wrapper(*args, **kargs):<EOL><INDENT>if len(args) > monitor_index:<EOL><INDENT>monitor = args[monitor_index]<EOL><DEDENT>elif '<STR_LIT>' in kargs:<EOL><INDENT>monitor = kargs['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>monitor = kargs['<STR_LIT>'] = NullMonitor()<EOL><DEDENT>with monitor.task(total, name, message):<EOL><INDENT>f(*args, **kargs)<EOL><DEDENT><DEDENT>return wrapper<EOL><DEDENT>return decorator<EOL>", "docstring": "Decorate a function to automatically begin and end a task on the progressmonitor.\nThe function must have a parameter called 'monitor'", "id": "f11665:m0"}
{"signature": "def update(self, units: int=<NUM_LIT:1>, message: str=None):", "body": "if self.total is None:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>self.worked = min(self.total, self.worked+units)<EOL>if message:<EOL><INDENT>self.message = message<EOL><DEDENT>for listener in self.listeners:<EOL><INDENT>listener(self)<EOL><DEDENT>", "docstring": "Increment the monitor with N units worked and an optional message", "id": "f11665:c0:m5"}
{"signature": "def log_listener(log:logging.Logger=None, level=logging.INFO):", "body": "if log is None:<EOL><INDENT>log = logging.getLogger(\"<STR_LIT>\")<EOL><DEDENT>def listen(monitor):<EOL><INDENT>name = \"<STR_LIT>\".format(monitor.name) if monitor.name is not None else \"<STR_LIT>\"<EOL>perc = int(monitor.progress * <NUM_LIT:100>)<EOL>msg = \"<STR_LIT>\".format(**locals())<EOL>log.log(level, msg)<EOL><DEDENT>return listen<EOL>", "docstring": "Progress Monitor listener that logs all updates to the given logger", "id": "f11666:m1"}
{"signature": "def snap_tz(dttm, instruction, timezone):", "body": "transformations = parse(instruction)<EOL>return reduce(lambda dt, transformation: transformation.apply_to_with_tz(dt, timezone), transformations, dttm)<EOL>", "docstring": "This function handles timezone aware datetimes.\n    Sometimes it is necessary to keep daylight saving time switches in mind.\n\n    Args:\n        instruction (string): a string that encodes 0 to n transformations of a time, i.e. \"-1h@h\", \"@mon+2d+4h\", ...\n        dttm (datetime): a datetime with timezone\n        timezone: a pytz timezone\n    Returns:\n        datetime: The datetime resulting from applying all transformations to the input datetime.\n\n    Example:\n        >>> import pytz\n        >>> CET = pytz.timezone(\"Europe/Berlin\")\n        >>> dttm = CET.localize(datetime(2017, 3, 26, 3, 44)\n        >>> dttm\n        datetime.datetime(2017, 3, 26, 3, 44, tzinfo=<DstTzInfo 'Europe/Berlin' CEST+2:00:00 DST>)\n\n        >>> snap_tz(dttm, \"-2h@h\", CET)\n        datetime.datetime(2017, 3, 26, 0, 0, tzinfo=<DstTzInfo 'Europe/Berlin' CET+1:00:00 STD>)\n        >>> # switch from winter to summer time!", "id": "f11670:m7"}
{"signature": "def get_token(s, pos, brackets_are_chars=True, environments=True, **parse_flags):", "body": "return LatexWalker(s, **parse_flags).get_token(pos=pos,<EOL>brackets_are_chars=brackets_are_chars,<EOL>environments=environments)<EOL>", "docstring": "Parse the next token in the stream.\n\nReturns a `LatexToken`. Raises `LatexWalkerEndOfStream` if end of stream reached.\n\n.. deprecated:: 1.0\n   Please use :py:meth:`LatexWalker.get_token()` instead.", "id": "f11675:m0"}
{"signature": "def get_latex_expression(s, pos, **parse_flags):", "body": "return LatexWalker(s, **parse_flags).get_latex_expression(pos=pos)<EOL>", "docstring": "Reads a latex expression, e.g. macro argument. This may be a single char, an escape\nsequence, or a expression placed in braces.\n\nReturns a tuple `(<LatexNode instance>, pos, len)`. `pos` is the first char of the\nexpression, and `len` is its length.\n\n.. deprecated:: 1.0\n   Please use :py:meth:`LatexWalker.get_latex_expression()` instead.", "id": "f11675:m1"}
{"signature": "def parse_flags(self):", "body": "return {<EOL>'<STR_LIT>': self.keep_inline_math,<EOL>'<STR_LIT>': self.tolerant_parsing,<EOL>'<STR_LIT>': self.strict_braces,<EOL>}<EOL>", "docstring": "The parse flags currently set on this object.  Returns a dictionary with keys\n'keep_inline_math', 'tolerant_parsing' and 'strict_braces'.", "id": "f11675:c12:m1"}
{"signature": "def set_tex_input_directory(self, tex_input_directory, latex_walker_init_args=None, strict_input=True):", "body": "self.tex_input_directory = tex_input_directory<EOL>self.latex_walker_init_args = latex_walker_init_args if latex_walker_init_args else {}<EOL>self.strict_input = strict_input<EOL>if tex_input_directory:<EOL><INDENT>self.macro_dict['<STR_LIT:input>'] = MacroDef('<STR_LIT:input>', lambda n: self._callback_input(n))<EOL>self.macro_dict['<STR_LIT>'] = MacroDef('<STR_LIT>', lambda n: self._callback_input(n))<EOL><DEDENT>else:<EOL><INDENT>self.macro_dict['<STR_LIT:input>'] = MacroDef('<STR_LIT:input>', discard=True)<EOL>self.macro_dict['<STR_LIT>'] = MacroDef('<STR_LIT>', discard=True)<EOL><DEDENT>", "docstring": "Set where to look for input files when encountering the ``\\\\input`` or\n``\\\\include`` macro.\n\nAlternatively, you may also override :py:meth:`read_input_file()` to\nimplement a custom file lookup mechanism.\n\nThe argument `tex_input_directory` is the directory relative to which to\nsearch for input files.\n\nIf `strict_input` is set to `True`, then we always check that the\nreferenced file lies within the subtree of `tex_input_directory`,\nprohibiting for instance hacks with '..' in filenames or using symbolic\nlinks to refer to files out of the directory tree.\n\nThe argument `latex_walker_init_args` allows you to specify the parse\nflags passed to the constructor of\n:py:class:`pylatexenc.latexwalker.LatexWalker` when parsing the input\nfile.", "id": "f11677:c2:m1"}
{"signature": "def latexnodes2text(nodelist, keep_inline_math=False, keep_comments=False):", "body": "return LatexNodes2Text(<EOL>keep_inline_math=keep_inline_math,<EOL>keep_comments=keep_comments<EOL>).nodelist_to_text(nodelist)<EOL>", "docstring": "Extracts text from a node list. `nodelist` is a list of nodes as returned by\n:py:func:`pylatexenc.latexwalker.get_latex_nodes()`.\n\n.. deprecated:: 1.0\n   Please use :py:class:`LatexNodes2Text` instead.", "id": "f11677:m6"}
{"signature": "def backwards(self, orm):", "body": "", "docstring": "Write your backwards methods here.", "id": "f11707:c0:m1"}
{"signature": "@property<EOL><INDENT>def package(self):<DEDENT>", "body": "return Package.from_url(self.uri())<EOL>", "docstring": "Return the package from a URL\n:return:", "id": "f11721:c1:m0"}
{"signature": "def dependencies(self):", "body": "cpio = self.rpm.gzip_file.read()<EOL>content = cpio.read()<EOL>return []<EOL>", "docstring": "Read the contents of the rpm itself\n:return:", "id": "f11721:c3:m3"}
{"signature": "def __init__(self, path_to_config):", "body": "super(RepoFile, self).__init__()<EOL>self._path_to_config = str(path_to_config)<EOL>self.read(self._path_to_config)<EOL>self._yum_variables = {}<EOL>", "docstring": "Path on disk to the ini file containing the repo description\n:param str path_to_config:\n:return:", "id": "f11722:c1:m0"}
{"signature": "@classmethod<EOL><INDENT>def parse(cls, xml_path):<DEDENT>", "body": "parser = etree.XMLParser(target=cls.xml_parse())<EOL>return etree.parse(xml_path, parser)<EOL>", "docstring": "Parses an xml_path with the inherited xml parser\n:param xml_path:\n:return:", "id": "f11726:c1:m0"}
{"signature": "def encode(self):", "body": "instruction_iter = itertools.chain([self.opcode], self.args)<EOL>elems = ARG_SEP.join(self.encode_arg(arg) for arg in instruction_iter)<EOL>return elems + INST_TERM<EOL>", "docstring": "Prepare the instruction to be sent over the wire.\n\n:return: str", "id": "f11732:c0:m4"}
{"signature": "def handshake(self, protocol='<STR_LIT>', width=<NUM_LIT>, height=<NUM_LIT>, dpi=<NUM_LIT>,<EOL>audio=None, video=None, image=None, **kwargs):", "body": "if protocol not in PROTOCOLS:<EOL><INDENT>self.logger.debug('<STR_LIT>' % protocol)<EOL>raise GuacamoleError('<STR_LIT>')<EOL><DEDENT>if audio is None:<EOL><INDENT>audio = list()<EOL><DEDENT>if video is None:<EOL><INDENT>video = list()<EOL><DEDENT>if image is None:<EOL><INDENT>image = list()<EOL><DEDENT>self.logger.debug('<STR_LIT>')<EOL>self.send_instruction(Instruction('<STR_LIT>', protocol))<EOL>instruction = self.read_instruction()<EOL>self.logger.debug('<STR_LIT>'<EOL>% str(instruction))<EOL>if not instruction:<EOL><INDENT>self.close()<EOL>raise GuacamoleError(<EOL>'<STR_LIT>')<EOL><DEDENT>if instruction.opcode != '<STR_LIT:args>':<EOL><INDENT>self.close()<EOL>raise GuacamoleError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % instruction.opcode)<EOL><DEDENT>self.logger.debug('<STR_LIT>'<EOL>% (width, height, dpi))<EOL>self.send_instruction(Instruction('<STR_LIT:size>', width, height, dpi))<EOL>self.logger.debug('<STR_LIT>' % audio)<EOL>self.send_instruction(Instruction('<STR_LIT>', *audio))<EOL>self.logger.debug('<STR_LIT>' % video)<EOL>self.send_instruction(Instruction('<STR_LIT>', *video))<EOL>self.logger.debug('<STR_LIT>' % image)<EOL>self.send_instruction(Instruction('<STR_LIT:image>', *image))<EOL>connection_args = [<EOL>kwargs.get(arg.replace('<STR_LIT:->', '<STR_LIT:_>'), '<STR_LIT>') for arg in instruction.args<EOL>]<EOL>self.logger.debug('<STR_LIT>' % connection_args)<EOL>self.send_instruction(Instruction('<STR_LIT>', *connection_args))<EOL>instruction = self.read_instruction()<EOL>self.logger.debug('<STR_LIT>'<EOL>% str(instruction))<EOL>if instruction.opcode != '<STR_LIT>':<EOL><INDENT>self.logger.warning(<EOL>'<STR_LIT>')<EOL><DEDENT>if instruction.args:<EOL><INDENT>self._id = instruction.args[<NUM_LIT:0>]<EOL>self.logger.debug(<EOL>'<STR_LIT>' % self.id)<EOL><DEDENT>self.logger.debug('<STR_LIT>')<EOL>self.connected = True<EOL>", "docstring": "Establish connection with Guacamole guacd server via handshake.", "id": "f11733:c0:m8"}
{"signature": "def send_instruction(self, instruction):", "body": "self.logger.debug('<STR_LIT>' % str(instruction))<EOL>return self.send(instruction.encode())<EOL>", "docstring": "Send instruction after encoding.", "id": "f11733:c0:m7"}
{"signature": "def send(self, data):", "body": "self.logger.debug('<STR_LIT>' % data)<EOL>self.client.sendall(data.encode())<EOL>", "docstring": "Send encoded instructions to Guacamole guacd server.", "id": "f11733:c0:m5"}
{"signature": "@property<EOL><INDENT>def id(self):<DEDENT>", "body": "return self._id<EOL>", "docstring": "Return client id", "id": "f11733:c0:m2"}
{"signature": "def __init__(self, host, port, timeout=<NUM_LIT:20>, debug=False, logger=None):", "body": "self.host = host<EOL>self.port = port<EOL>self.timeout = timeout<EOL>self._client = None<EOL>self.connected = False<EOL>self._buffer = bytearray()<EOL>self._id = None<EOL>self.logger = guac_logger<EOL>if logger:<EOL><INDENT>self.logger = logger<EOL><DEDENT>if debug:<EOL><INDENT>self.logger.setLevel(logging.DEBUG)<EOL><DEDENT>", "docstring": "Guacamole Client class. This class can handle communication with guacd\nserver.\n\n:param host: guacd server host.\n\n:param port: guacd server port.\n\n:param timeout: socket connection timeout.\n\n:param debug: if True, default logger will switch to Debug level.", "id": "f11733:c0:m0"}
{"signature": "def onOpen(self):", "body": "self.factory.protocols.append(self)<EOL>", "docstring": "Store this protocol instance in the factory and wave hello.", "id": "f11738:c0:m4"}
{"signature": "def read_channel(self):", "body": "channel, message = self.protocol.channel_layer.receive_many([u'<STR_LIT>'], block=False)<EOL>delay = <NUM_LIT:0.1><EOL>if channel:<EOL><INDENT>self.protocols[<NUM_LIT:0>].sendSlack(message)<EOL><DEDENT>reactor.callLater(delay, self.read_channel)<EOL>", "docstring": "Get available messages and send through to the protocol", "id": "f11738:c1:m1"}
{"signature": "def make_message(self, text, channel):", "body": "try:<EOL><INDENT>channel_id = self.slack.channel_from_name(channel)['<STR_LIT:id>']<EOL><DEDENT>except ValueError:<EOL><INDENT>channel_id = channel<EOL><DEDENT>return pack({<EOL>'<STR_LIT:text>': text,<EOL>'<STR_LIT:type>': '<STR_LIT:message>',<EOL>'<STR_LIT>': channel_id,<EOL>'<STR_LIT:id>': self.message_id,<EOL>})<EOL>", "docstring": "High-level function for creating messages. Return packed bytes.\n\nArgs:\n    text: {str}\n    channel: {str} Either name or ID", "id": "f11738:c0:m2"}
{"signature": "def pack(message):", "body": "return json.dumps(message).encode('<STR_LIT:utf8>')<EOL>", "docstring": "Serialize the message into something for sending\nacross the wire.\n\nArgs:\n    message: {dict} dictionary that full specifies a slack message", "id": "f11738:m0"}
{"signature": "def sendSlack(self, message):", "body": "channel = message.get('<STR_LIT>', '<STR_LIT>')<EOL>self.sendMessage(self.make_message(message['<STR_LIT:text>'], channel))<EOL>", "docstring": "Send message to Slack", "id": "f11738:c0:m6"}
{"signature": "def run(self):", "body": "slack = SlackAPI(token=self.token)<EOL>rtm = slack.rtm_start()<EOL>factory = SlackClientFactory(rtm['<STR_LIT:url>'])<EOL>factory.protocol = SlackClientProtocol<EOL>factory.protocol.slack = slack<EOL>factory.protocol.channel_layer = self.channel_layer<EOL>factory.channel_name = self.channel_name<EOL>factory.run()<EOL>", "docstring": "Main interface. Instantiate the SlackAPI, connect to RTM\nand start the client.", "id": "f11738:c2:m1"}
{"signature": "@property<EOL><INDENT>def channels(self):<DEDENT>", "body": "if not self._channels:<EOL><INDENT>self._channels = self._call_api('<STR_LIT>')['<STR_LIT>']<EOL><DEDENT>return self._channels<EOL>", "docstring": "List of channels of this slack team", "id": "f11740:c0:m2"}
{"signature": "def channel_from_name(self, name):", "body": "try:<EOL><INDENT>channel = [channel for channel in self.channels<EOL>if channel['<STR_LIT:name>'] == name][<NUM_LIT:0>]<EOL><DEDENT>except IndexError:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(name))<EOL><DEDENT>return channel<EOL>", "docstring": "Return the channel dict given by human-readable {name}", "id": "f11740:c0:m6"}
{"signature": "def manifest_header(type_name, version='<STR_LIT:1.0>'):", "body": "return \"<STR_LIT>\".format(<EOL>type_name.title(),<EOL>version,<EOL>)<EOL>", "docstring": "Returns a header, suitable for use in a manifest.\n\n    >>> manifest_header(\"signature\")\n    \"Signature-Version: 1.0\"\n\n    :param type_name: The kind of manifest which needs a header:\n        \"manifest\", \"signature\".\n    :param version: The manifest version to encode in the header\n        (default: '1.0')", "id": "f11745:m4"}
{"signature": "@classmethod<EOL><INDENT>def from_symbol(cls, symbol):<DEDENT>", "body": "if symbol.lower() == symbol:<EOL><INDENT>return cls(PIECE_SYMBOLS.index(symbol), WHITE)<EOL><DEDENT>else:<EOL><INDENT>return cls(PIECE_SYMBOLS.index(symbol.lower()), BLACK)<EOL><DEDENT>", "docstring": "Creates a piece instance from a piece symbol.\nRaises `ValueError` if the symbol is invalid.", "id": "f11761:c0:m10"}
{"signature": "def set_sfen(self, sfen):", "body": "<EOL>parts = sfen.split()<EOL>if len(parts) != <NUM_LIT:4>:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(repr(sfen)))<EOL><DEDENT>rows = parts[<NUM_LIT:0>].split('<STR_LIT:/>')<EOL>if len(rows) != <NUM_LIT:9>:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(repr(sfen)))<EOL><DEDENT>for row in rows:<EOL><INDENT>field_sum = <NUM_LIT:0><EOL>previous_was_digit = False<EOL>previous_was_plus = False<EOL>for c in row:<EOL><INDENT>if c in ['<STR_LIT:1>', '<STR_LIT:2>', '<STR_LIT:3>', '<STR_LIT:4>', '<STR_LIT:5>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>if previous_was_digit:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(repr(sfen)))<EOL><DEDENT>if previous_was_plus:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(repr(sfen)))<EOL><DEDENT>field_sum += int(c)<EOL>previous_was_digit = True<EOL>previous_was_plus = False<EOL><DEDENT>elif c == '<STR_LIT:+>':<EOL><INDENT>if previous_was_plus:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(repr(sfen)))<EOL><DEDENT>previous_was_digit = False<EOL>previous_was_plus = True<EOL><DEDENT>elif c.lower() in ['<STR_LIT:p>', '<STR_LIT:l>', '<STR_LIT:n>', '<STR_LIT:s>', '<STR_LIT:g>', '<STR_LIT:b>', '<STR_LIT:r>', '<STR_LIT:k>']:<EOL><INDENT>field_sum += <NUM_LIT:1><EOL>if previous_was_plus and (c.lower() == '<STR_LIT:g>' or c.lower() == '<STR_LIT:k>'):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>previous_was_digit = False<EOL>previous_was_plus = False<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(repr(sfen)))<EOL><DEDENT><DEDENT>if field_sum != <NUM_LIT:9>:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(repr(sfen)))<EOL><DEDENT><DEDENT>if not parts[<NUM_LIT:1>] in ['<STR_LIT:b>', '<STR_LIT:w>']:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(repr(sfen)))<EOL><DEDENT>if int(parts[<NUM_LIT:3>]) < <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(repr(sfen)))<EOL><DEDENT>self.clear()<EOL>square_index = <NUM_LIT:0><EOL>previous_was_plus = False<EOL>for c in parts[<NUM_LIT:0>]:<EOL><INDENT>if c in ['<STR_LIT:1>', '<STR_LIT:2>', '<STR_LIT:3>', '<STR_LIT:4>', '<STR_LIT:5>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>square_index += int(c)<EOL><DEDENT>elif c == '<STR_LIT:+>':<EOL><INDENT>previous_was_plus = True<EOL><DEDENT>elif c == '<STR_LIT:/>':<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>piece_symbol = c<EOL>if previous_was_plus:<EOL><INDENT>piece_symbol = '<STR_LIT:+>' + piece_symbol<EOL><DEDENT>self.set_piece_at(square_index, Piece.from_symbol(piece_symbol))<EOL>square_index += <NUM_LIT:1><EOL>previous_was_plus = False<EOL><DEDENT><DEDENT>if parts[<NUM_LIT:1>] == '<STR_LIT:w>':<EOL><INDENT>self.turn = WHITE<EOL><DEDENT>else:<EOL><INDENT>self.turn = BLACK<EOL><DEDENT>self.pieces_in_hand = [collections.Counter(), collections.Counter()]<EOL>if parts[<NUM_LIT:2>] != '<STR_LIT:->':<EOL><INDENT>piece_count = <NUM_LIT:0><EOL>for c in parts[<NUM_LIT:2>]:<EOL><INDENT>if c in ['<STR_LIT:0>', '<STR_LIT:1>', '<STR_LIT:2>', '<STR_LIT:3>', '<STR_LIT:4>', '<STR_LIT:5>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>piece_count *= <NUM_LIT:10><EOL>piece_count += int(c)<EOL><DEDENT>else:<EOL><INDENT>piece = Piece.from_symbol(c)<EOL>if piece_count == <NUM_LIT:0>:<EOL><INDENT>piece_count = <NUM_LIT:1><EOL><DEDENT>self.add_piece_into_hand(piece.piece_type, piece.color, piece_count)<EOL>piece_count = <NUM_LIT:0><EOL><DEDENT><DEDENT><DEDENT>self.move_number = int(parts[<NUM_LIT:3>]) or <NUM_LIT:1><EOL>self.transpositions = collections.Counter((self.zobrist_hash(), ))<EOL>", "docstring": "Parses a SFEN and sets the position from it.\nRasies `ValueError` if the SFEN string is invalid.", "id": "f11764:c1:m31"}
{"signature": "@classmethod<EOL><INDENT>def from_usi(cls, usi):<DEDENT>", "body": "if usi == '<STR_LIT>':<EOL><INDENT>return cls.null()<EOL><DEDENT>elif len(usi) == <NUM_LIT:4>:<EOL><INDENT>if usi[<NUM_LIT:1>] == '<STR_LIT:*>':<EOL><INDENT>piece = Piece.from_symbol(usi[<NUM_LIT:0>])<EOL>return cls(None, SQUARE_NAMES.index(usi[<NUM_LIT:2>:<NUM_LIT:4>]), False, piece.piece_type)<EOL><DEDENT>else:<EOL><INDENT>return cls(SQUARE_NAMES.index(usi[<NUM_LIT:0>:<NUM_LIT:2>]), SQUARE_NAMES.index(usi[<NUM_LIT:2>:<NUM_LIT:4>]))<EOL><DEDENT><DEDENT>elif len(usi) == <NUM_LIT:5> and usi[<NUM_LIT:4>] == '<STR_LIT:+>':<EOL><INDENT>return cls(SQUARE_NAMES.index(usi[<NUM_LIT:0>:<NUM_LIT:2>]), SQUARE_NAMES.index(usi[<NUM_LIT:2>:<NUM_LIT:4>]), True)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Parses an USI string.\nRaises `ValueError` if the USI string is invalid.", "id": "f11766:c0:m9"}
{"signature": "def run():", "body": "control_loop()<EOL>", "docstring": "Start the capture agent state process.", "id": "f11780:m1"}
{"signature": "def sigint_handler(signum, frame):", "body": "utils.terminate(True)<EOL>", "docstring": "Intercept sigint and terminate services gracefully.", "id": "f11781:m1"}
{"signature": "def usage(retval=<NUM_LIT:0>):", "body": "print(USAGE % sys.argv[<NUM_LIT:0>])<EOL>sys.exit(retval)<EOL>", "docstring": "Print usage information to stdout and exit.", "id": "f11781:m0"}
{"signature": "def sigterm_handler(signum, frame):", "body": "sigint_handler(signum, frame)<EOL>for process in multiprocessing.active_children():<EOL><INDENT>process.terminate()<EOL><DEDENT>sys.exit(<NUM_LIT:0>)<EOL>", "docstring": "Intercept sigterm and terminate all processes.", "id": "f11781:m2"}
{"signature": "def safe_start_ingest(event):", "body": "try:<EOL><INDENT>ingest(event)<EOL><DEDENT>except Exception:<EOL><INDENT>logger.error('<STR_LIT>')<EOL>logger.error(traceback.format_exc())<EOL>recording_state(event.uid, '<STR_LIT>')<EOL>update_event_status(event, Status.FAILED_UPLOADING)<EOL>set_service_status_immediate(Service.INGEST, ServiceStatus.IDLE)<EOL><DEDENT>", "docstring": "Start a capture process but make sure to catch any errors during this\n    process, log them but otherwise ignore them.", "id": "f11782:m2"}
{"signature": "def ingest(event):", "body": "<EOL>set_service_status(Service.INGEST, ServiceStatus.BUSY)<EOL>notify.notify('<STR_LIT>')<EOL>recording_state(event.uid, '<STR_LIT>')<EOL>update_event_status(event, Status.UPLOADING)<EOL>service = config('<STR_LIT>')<EOL>service = service[randrange(<NUM_LIT:0>, len(service))]<EOL>logger.info('<STR_LIT>' + service)<EOL>logger.info('<STR_LIT>')<EOL>mediapackage = http_request(service + '<STR_LIT>')<EOL>prop = '<STR_LIT>'<EOL>dcns = '<STR_LIT>'<EOL>for attachment in event.get_data().get('<STR_LIT>'):<EOL><INDENT>data = attachment.get('<STR_LIT:data>')<EOL>if attachment.get('<STR_LIT>') == prop:<EOL><INDENT>workflow_def, workflow_config = get_config_params(data)<EOL><DEDENT>elif attachment.get('<STR_LIT>') == '<STR_LIT>' and dcns in data:<EOL><INDENT>name = attachment.get('<STR_LIT>', '<STR_LIT>').rsplit('<STR_LIT:.>', <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>logger.info('<STR_LIT>' % name)<EOL>fields = [('<STR_LIT>', mediapackage),<EOL>('<STR_LIT>', '<STR_LIT>' % name),<EOL>('<STR_LIT>', data.encode('<STR_LIT:utf-8>'))]<EOL>mediapackage = http_request(service + '<STR_LIT>', fields)<EOL><DEDENT><DEDENT>for (flavor, track) in event.get_tracks():<EOL><INDENT>logger.info('<STR_LIT>'.format(flavor, track))<EOL>track = track.encode('<STR_LIT:ascii>', '<STR_LIT:ignore>')<EOL>fields = [('<STR_LIT>', mediapackage), ('<STR_LIT>', flavor),<EOL>('<STR_LIT>', (pycurl.FORM_FILE, track))]<EOL>mediapackage = http_request(service + '<STR_LIT>', fields)<EOL><DEDENT>logger.info('<STR_LIT>')<EOL>fields = [('<STR_LIT>', mediapackage)]<EOL>if workflow_def:<EOL><INDENT>fields.append(('<STR_LIT>', workflow_def))<EOL><DEDENT>if event.uid:<EOL><INDENT>fields.append(('<STR_LIT>',<EOL>event.uid.encode('<STR_LIT:ascii>', '<STR_LIT:ignore>')))<EOL><DEDENT>fields += workflow_config<EOL>mediapackage = http_request(service + '<STR_LIT>', fields)<EOL>recording_state(event.uid, '<STR_LIT>')<EOL>update_event_status(event, Status.FINISHED_UPLOADING)<EOL>notify.notify('<STR_LIT>')<EOL>set_service_status_immediate(Service.INGEST, ServiceStatus.IDLE)<EOL>logger.info('<STR_LIT>')<EOL>", "docstring": "Ingest a finished recording to the Opencast server.", "id": "f11782:m1"}
{"signature": "def recording_command(event):", "body": "conf = config('<STR_LIT>')<EOL>cmd = conf['<STR_LIT>']<EOL>cmd = cmd.replace('<STR_LIT>', str(event.remaining_duration(timestamp())))<EOL>cmd = cmd.replace('<STR_LIT>', event.directory())<EOL>cmd = cmd.replace('<STR_LIT>', event.name())<EOL>cmd = cmd.replace('<STR_LIT>', conf['<STR_LIT>'])<EOL>sigterm_time = conf['<STR_LIT>']<EOL>sigkill_time = conf['<STR_LIT>']<EOL>sigcustom_time = conf['<STR_LIT>']<EOL>sigcustom_time = <NUM_LIT:0> if sigcustom_time < <NUM_LIT:0> else event.end + sigcustom_time<EOL>sigterm_time = <NUM_LIT:0> if sigterm_time < <NUM_LIT:0> else event.end + sigterm_time<EOL>sigkill_time = <NUM_LIT:0> if sigkill_time < <NUM_LIT:0> else event.end + sigkill_time<EOL>logger.info(cmd)<EOL>args = shlex.split(cmd)<EOL>DEVNULL = getattr(subprocess, '<STR_LIT>', os.open(os.devnull, os.O_RDWR))<EOL>captureproc = subprocess.Popen(args, stdin=DEVNULL)<EOL>hasattr(subprocess, '<STR_LIT>') or os.close(DEVNULL)<EOL>notify.notify('<STR_LIT>')<EOL>while captureproc.poll() is None:<EOL><INDENT>notify.notify('<STR_LIT>')<EOL>if sigcustom_time and timestamp() > sigcustom_time:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>captureproc.send_signal(conf['<STR_LIT>'])<EOL>sigcustom_time = <NUM_LIT:0>  <EOL><DEDENT>if sigterm_time and timestamp() > sigterm_time:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>captureproc.terminate()<EOL>sigterm_time = <NUM_LIT:0>  <EOL><DEDENT>elif sigkill_time and timestamp() > sigkill_time:<EOL><INDENT>logger.warning(\"<STR_LIT>\")<EOL>captureproc.kill()<EOL>sigkill_time = <NUM_LIT:0>  <EOL><DEDENT>time.sleep(<NUM_LIT:0.1>)<EOL><DEDENT>for preview in conf['<STR_LIT>']:<EOL><INDENT>try:<EOL><INDENT>os.remove(preview.replace('<STR_LIT>', conf['<STR_LIT>']))<EOL><DEDENT>except OSError:<EOL><INDENT>logger.warning('<STR_LIT>')<EOL>logger.warning(traceback.format_exc())<EOL><DEDENT><DEDENT>exitcode = config()['<STR_LIT>']['<STR_LIT>']<EOL>if captureproc.poll() > <NUM_LIT:0> and captureproc.returncode != exitcode:<EOL><INDENT>raise RuntimeError('<STR_LIT>' % captureproc.returncode)<EOL><DEDENT>notify.notify('<STR_LIT>')<EOL>files = (f.replace('<STR_LIT>', event.directory()) for f in conf['<STR_LIT>'])<EOL>files = (f.replace('<STR_LIT>', event.name()) for f in files)<EOL>return list(zip(conf['<STR_LIT>'], files))<EOL>", "docstring": "Run the actual command to record the a/v material.", "id": "f11783:m3"}
{"signature": "def safe_start_capture(event):", "body": "try:<EOL><INDENT>start_capture(event)<EOL><DEDENT>except Exception:<EOL><INDENT>logger.error('<STR_LIT>')<EOL>logger.error(traceback.format_exc())<EOL>recording_state(event.uid, '<STR_LIT>')<EOL>update_event_status(event, Status.FAILED_RECORDING)<EOL>set_service_status_immediate(Service.CAPTURE, ServiceStatus.IDLE)<EOL><DEDENT>", "docstring": "Start a capture process but make sure to catch any errors during this\n    process, log them but otherwise ignore them.", "id": "f11783:m2"}
{"signature": "def control_loop():", "body": "set_service_status(Service.CAPTURE, ServiceStatus.IDLE)<EOL>notify.notify('<STR_LIT>')<EOL>notify.notify('<STR_LIT>')<EOL>while not terminate():<EOL><INDENT>notify.notify('<STR_LIT>')<EOL>event = get_session().query(UpcomingEvent).filter(UpcomingEvent.start <= timestamp()).filter(UpcomingEvent.end > timestamp()).first()<EOL>if event:<EOL><INDENT>safe_start_capture(event)<EOL><DEDENT>time.sleep(<NUM_LIT:1.0>)<EOL><DEDENT>logger.info('<STR_LIT>')<EOL>set_service_status(Service.CAPTURE, ServiceStatus.STOPPED)<EOL>", "docstring": "Main loop of the capture agent, retrieving and checking the schedule as\n    well as starting the capture process if necessry.", "id": "f11783:m4"}
{"signature": "def __repr__(self):", "body": "return '<STR_LIT>' % (self.start, self.uid)<EOL>", "docstring": "Return a string representation of an artist object.\n\n        :return: String representation of object.", "id": "f11785:c4:m8"}
{"signature": "def control_loop():", "body": "set_service_status(Service.SCHEDULE, ServiceStatus.BUSY)<EOL>notify.notify('<STR_LIT>')<EOL>while not terminate():<EOL><INDENT>notify.notify('<STR_LIT>')<EOL>get_schedule()<EOL>session = get_session()<EOL>next_event = session.query(UpcomingEvent).filter(UpcomingEvent.end > timestamp()).order_by(UpcomingEvent.start).first()<EOL>if next_event:<EOL><INDENT>logger.info('<STR_LIT>',<EOL>datetime.fromtimestamp(next_event.start))<EOL>notify.notify('<STR_LIT>' %<EOL>datetime.fromtimestamp(next_event.start))<EOL><DEDENT>else:<EOL><INDENT>logger.info('<STR_LIT>')<EOL>notify.notify('<STR_LIT>')<EOL><DEDENT>session.close()<EOL>next_update = timestamp() + config()['<STR_LIT>']['<STR_LIT>']<EOL>while not terminate() and timestamp() < next_update:<EOL><INDENT>time.sleep(<NUM_LIT:0.1>)<EOL><DEDENT><DEDENT>logger.info('<STR_LIT>')<EOL>set_service_status(Service.SCHEDULE, ServiceStatus.STOPPED)<EOL>", "docstring": "Main loop, retrieving the schedule.", "id": "f11786:m2"}
{"signature": "@app.route('<STR_LIT>')<EOL>@requires_auth<EOL>@jsonapi_mediatype<EOL>def events():", "body": "db = get_session()<EOL>upcoming_events = db.query(UpcomingEvent).order_by(UpcomingEvent.start)<EOL>recorded_events = db.query(RecordedEvent).order_by(RecordedEvent.start.desc())<EOL>result = [event.serialize() for event in upcoming_events]<EOL>result += [event.serialize() for event in recorded_events]<EOL>return make_data_response(result)<EOL>", "docstring": "Serve a JSON representation of events", "id": "f11787:m3"}
{"signature": "def make_data_response(data, status=<NUM_LIT:200>):", "body": "content = {'<STR_LIT:data>': ensurelist(data)}<EOL>return make_response(jsonify(content), status)<EOL>", "docstring": "Return a response with a list of jsonapi data objects", "id": "f11787:m1"}
{"signature": "@app.route('<STR_LIT>')<EOL>@requires_auth<EOL>@jsonapi_mediatype<EOL>def internal_state():", "body": "data = {'<STR_LIT>': {<EOL>'<STR_LIT>': ServiceStatus.str(get_service_status(Service.CAPTURE)),<EOL>'<STR_LIT>': ServiceStatus.str(get_service_status(Service.INGEST)),<EOL>'<STR_LIT>': ServiceStatus.str(get_service_status(Service.SCHEDULE)),<EOL>'<STR_LIT>': ServiceStatus.str(get_service_status(Service.AGENTSTATE))<EOL>}<EOL>}<EOL>return make_response(jsonify({'<STR_LIT>': data}))<EOL>", "docstring": "Serve a json representation of internal agentstate as meta data", "id": "f11787:m2"}
{"signature": "@app.route(\"<STR_LIT>\")<EOL>@requires_auth<EOL>def serve_image(image_id):", "body": "try:<EOL><INDENT>preview_dir = config()['<STR_LIT>']['<STR_LIT>']<EOL>filepath = config()['<STR_LIT>']['<STR_LIT>'][image_id]<EOL>filepath = filepath.replace('<STR_LIT>', preview_dir)<EOL>filepath = os.path.abspath(filepath)<EOL>if os.path.isfile(filepath):<EOL><INDENT>directory, filename = filepath.rsplit('<STR_LIT:/>', <NUM_LIT:1>)<EOL>return send_from_directory(directory, filename)<EOL><DEDENT><DEDENT>except (IndexError, KeyError):<EOL><INDENT>pass<EOL><DEDENT>return '<STR_LIT>', <NUM_LIT><EOL>", "docstring": "Serve the preview image with the given id", "id": "f11788:m1"}
{"signature": "@app.route('<STR_LIT:/>')<EOL>@requires_auth<EOL>def home():", "body": "<EOL>preview = config()['<STR_LIT>']['<STR_LIT>']<EOL>previewdir = config()['<STR_LIT>']['<STR_LIT>']<EOL>preview = [p.replace('<STR_LIT>', previewdir) for p in preview]<EOL>preview = zip(preview, range(len(preview)))<EOL>preview = [p[<NUM_LIT:1>] for p in preview if os.path.isfile(p[<NUM_LIT:0>])]<EOL>try:<EOL><INDENT>limit_upcoming = int(request.args.get('<STR_LIT>', <NUM_LIT:5>))<EOL>limit_processed = int(request.args.get('<STR_LIT>', <NUM_LIT:15>))<EOL><DEDENT>except ValueError:<EOL><INDENT>limit_upcoming = <NUM_LIT:5><EOL>limit_processed = <NUM_LIT:15><EOL><DEDENT>db = get_session()<EOL>upcoming_events = db.query(UpcomingEvent).order_by(UpcomingEvent.start).limit(limit_upcoming)<EOL>recorded_events = db.query(RecordedEvent).order_by(RecordedEvent.start.desc()).limit(limit_processed)<EOL>recording = get_service_status(Service.CAPTURE) == ServiceStatus.BUSY<EOL>uploading = get_service_status(Service.INGEST) == ServiceStatus.BUSY<EOL>processed = db.query(RecordedEvent).count()<EOL>upcoming = db.query(UpcomingEvent).count()<EOL>return render_template('<STR_LIT>', preview=preview, config=config(),<EOL>recorded_events=recorded_events,<EOL>upcoming_events=upcoming_events,<EOL>recording=recording, uploading=uploading,<EOL>processed=processed, upcoming=upcoming,<EOL>limit_upcoming=limit_upcoming,<EOL>limit_processed=limit_processed,<EOL>dtfmt=dtfmt)<EOL>", "docstring": "Serve the status page of the capture agent.", "id": "f11788:m0"}
{"signature": "def set_service_status_immediate(service, status):", "body": "set_service_status(service, status)<EOL>update_agent_state()<EOL>", "docstring": "Update the status of a particular service in the database and send an\n    immediate signal to Opencast.", "id": "f11790:m11"}
{"signature": "def timestamp():", "body": "return unix_ts(datetime.now(tzutc()))<EOL>", "docstring": "Get current unix timestamp", "id": "f11790:m3"}
{"signature": "def unix_ts(dtval):", "body": "epoch = datetime(<NUM_LIT>, <NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:0>, tzinfo=tzutc())<EOL>delta = (dtval - epoch)<EOL>return delta.days * <NUM_LIT> * <NUM_LIT> + delta.seconds<EOL>", "docstring": "Convert datetime into a unix timestamp.\n    This is the equivalent to Python 3's int(datetime.timestamp()).\n\n    :param dt: datetime to convert", "id": "f11790:m2"}
{"signature": "def ensurelist(x):", "body": "return x if type(x) == list else [x]<EOL>", "docstring": "Ensure an element is a list.", "id": "f11790:m6"}
{"signature": "def register_ca(status='<STR_LIT>'):", "body": "<EOL>if config()['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>return<EOL><DEDENT>params = [('<STR_LIT:address>', config()['<STR_LIT>']['<STR_LIT:url>']), ('<STR_LIT:state>', status)]<EOL>name = urlquote(config()['<STR_LIT>']['<STR_LIT:name>'].encode('<STR_LIT:utf-8>'), safe='<STR_LIT>')<EOL>url = '<STR_LIT>' % (config()['<STR_LIT>'][<NUM_LIT:0>], name)<EOL>try:<EOL><INDENT>response = http_request(url, params).decode('<STR_LIT:utf-8>')<EOL>if response:<EOL><INDENT>logger.info(response)<EOL><DEDENT><DEDENT>except pycurl.error as e:<EOL><INDENT>logger.warning('<STR_LIT>' % (status, e))<EOL><DEDENT>", "docstring": "Register this capture agent at the Matterhorn admin server so that it\n    shows up in the admin interface.\n\n    :param address: Address of the capture agent web ui\n    :param status: Current status of the capture agent", "id": "f11790:m7"}
{"signature": "@staticmethod<EOL><INDENT>def mention(user):<DEDENT>", "body": "return \"\"\"<STR_LIT>\"\"\".format(user.id, user.name)<EOL>", "docstring": "Mention a user in a message.  This may trigger a notification for them even if the conversation is muted.\n\nArgs:\n    user (SkypeUser): user who is to be mentioned\n\nReturns:\n    str: tag to display the mention", "id": "f11793:c0:m7"}
{"signature": "@staticmethod<EOL><INDENT>def link(url, display=None):<DEDENT>", "body": "return \"\"\"<STR_LIT>\"\"\".format(url, display or url)<EOL>", "docstring": "Create a hyperlink.  If ``display`` is not specified, display the URL.\n\n.. note:: Anomalous API behaviour: official clients don't provide the ability to set display text.\n\nArgs:\n    url (str): full URL to link to\n    display (str): custom label for the hyperlink\n\nReturns:\n    str: tag to display a hyperlink", "id": "f11793:c0:m5"}
{"signature": "@staticmethod<EOL><INDENT>def colour(s, colour):<DEDENT>", "body": "return \"\"\"<STR_LIT>\"\"\".format(colour, s)<EOL>", "docstring": "Format text to be coloured.\n\nArgs:\n    s (str): string to format\n    colour (str): colour to display text in\n\nReturns:\n    str: formatted string", "id": "f11793:c0:m4"}
{"signature": "@staticmethod<EOL><INDENT>def italic(s):<DEDENT>", "body": "return \"\"\"<STR_LIT>\"\"\".format(s)<EOL>", "docstring": "Format text to be italic.\n\nArgs:\n    s (str): string to format\n\nReturns:\n    str: formatted string", "id": "f11793:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def emote(shortcut):<DEDENT>", "body": "for emote in SkypeUtils.static[\"<STR_LIT>\"]:<EOL><INDENT>if shortcut == emote[\"<STR_LIT:id>\"]:<EOL><INDENT>return \"\"\"<STR_LIT>\"\"\".format(shortcut, emote[\"<STR_LIT>\"][<NUM_LIT:0>])<EOL><DEDENT>elif shortcut in emote[\"<STR_LIT>\"]:<EOL><INDENT>return \"\"\"<STR_LIT>\"\"\".format(emote[\"<STR_LIT:id>\"], shortcut)<EOL><DEDENT><DEDENT>return shortcut<EOL>", "docstring": "Display an emoticon.  This accepts any valid shortcut.\n\nArgs:\n    shortcut (str): emoticon shortcut\n\nReturns:\n    str: tag to render the emoticon", "id": "f11793:c0:m6"}
{"signature": "@staticmethod<EOL><INDENT>def uriObject(content, type, url, thumb=None, title=None, desc=None, **values):<DEDENT>", "body": "titleTag = \"\"\"<STR_LIT>\"\"\".format(title) if title else \"\"\"<STR_LIT>\"\"\"<EOL>descTag = \"\"\"<STR_LIT>\"\"\".format(desc) if desc else \"\"\"<STR_LIT>\"\"\"<EOL>thumbAttr = \"<STR_LIT>\".format(thumb) if thumb else \"<STR_LIT>\"<EOL>valTags = \"<STR_LIT>\".join(\"\"\"<STR_LIT>\"\"\".format(k, v) for k, v in values.items())<EOL>return \"\"\"<STR_LIT>\"\"\".format(content, type, url, thumbAttr, titleTag, descTag, valTags)<EOL>", "docstring": "Generate the markup needed for a URI component in a rich message.\n\nArgs:\n    content (str): object-specific content inside the object tag\n    type (str): URI object type\n    url (str): URL to content\n    title (str): name of object\n    desc (str): additional line of information\n    thumb (str): URL to thumbnail of content\n    values (dict): standard value tags of the form ``<key v=\"value\"/>``\n\nReturns:\n    str: ``<URIObject>`` tag", "id": "f11793:c0:m9"}
{"signature": "@staticmethod<EOL><INDENT>def userToId(url):<DEDENT>", "body": "match = re.search(r\"<STR_LIT>\", url)<EOL>return match.group(<NUM_LIT:2>) if match else None<EOL>", "docstring": "Extract the username from a contact URL.\n\nMatches addresses containing ``users/<user>`` or ``users/ME/contacts/<user>``.\n\nArgs:\n    url (str): Skype API URL\n\nReturns:\n    str: extracted identifier", "id": "f11794:c0:m1"}
{"signature": "def __init__(self, user=None, pwd=None, tokenFile=None, connect=True):", "body": "super(Skype, self).__init__(self)<EOL>self.conn = SkypeConnection()<EOL>if tokenFile:<EOL><INDENT>self.conn.setTokenFile(tokenFile)<EOL><DEDENT>if user and pwd:<EOL><INDENT>self.conn.setUserPwd(user, pwd)<EOL><DEDENT>if connect and ((user and pwd) or tokenFile):<EOL><INDENT>try:<EOL><INDENT>self.conn.readToken()<EOL><DEDENT>except SkypeAuthException:<EOL><INDENT>self.conn.getSkypeToken()<EOL><DEDENT><DEDENT>self.contacts = SkypeContacts(self)<EOL>self.chats = SkypeChats(self)<EOL>self.settings = SkypeSettings(self)<EOL>self.translate = SkypeTranslator(self)<EOL>", "docstring": "Create a new Skype object and corresponding connection.\n\nIf ``user`` and ``pwd`` are given, they will be passed to :meth:`.SkypeConnection.setUserPwd`.  This can be\neither a Skype username/password pair, or a Microsoft account email address and its associated password.\n\nIf a token file path is present, it will be used if valid.  On a successful connection, the token file will\nalso be written to.\n\nBy default, a connection attempt will be made if any valid form of credentials are supplied.  It is also\npossible to handle authentication manually, by working with the underlying connection object instead.\n\nArgs:\n    user (str): Skype username of the connecting account\n    pwd (str): corresponding Skype account password\n    tokenFile (str): path to file used for token storage\n    connect (bool): whether to try and connect straight away\n\nRaises:\n    .SkypeAuthException: if connecting, and the login request is rejected\n    .SkypeApiException: if connecting, and the login form can't be processed", "id": "f11795:c0:m0"}
{"signature": "def getUrlMeta(self, url):", "body": "return self.conn(\"<STR_LIT:GET>\", SkypeConnection.API_URL, params={\"<STR_LIT:url>\": url},<EOL>auth=SkypeConnection.Auth.Authorize).json()<EOL>", "docstring": "Retrieve various metadata associated with a URL, as seen by Skype.\n\nArgs:\n    url (str): address to ping for info\n\nReturns:\n    dict: metadata for the website queried", "id": "f11795:c0:m8"}
{"signature": "def setPresence(self, status=SkypeUtils.Status.Online):", "body": "self.conn(\"<STR_LIT>\", \"<STR_LIT>\".format(self.conn.msgsHost),<EOL>auth=SkypeConnection.Auth.RegToken, json={\"<STR_LIT:status>\": status.label})<EOL>", "docstring": "Set the current user's presence on the network.  Supports :attr:`.Status.Online`, :attr:`.Status.Busy` or\n:attr:`.Status.Hidden` (shown as :attr:`.Status.Offline` to others).\n\nArgs:\n    status (.Status): new availability to display to contacts", "id": "f11795:c0:m5"}
{"signature": "def onEvent(self, event):", "body": "pass<EOL>", "docstring": "A stub method that subclasses should implement to react to messages and status changes.\n\nArgs:\n    event (SkypeEvent): an incoming event", "id": "f11795:c1:m3"}
{"signature": "def auth(self, skypeToken):", "body": "token = expiry = endpoint = None<EOL>msgsHost = SkypeConnection.API_MSGSHOST<EOL>while not token:<EOL><INDENT>secs = int(time.time())<EOL>hash = self.getMac256Hash(str(secs))<EOL>headers = {\"<STR_LIT>\": \"<STR_LIT>\".format(secs, hash),<EOL>\"<STR_LIT>\": \"<STR_LIT>\" + skypeToken, \"<STR_LIT>\": \"<STR_LIT>\"}<EOL>endpointResp = self.conn(\"<STR_LIT:POST>\", \"<STR_LIT>\".format(msgsHost), codes=(<NUM_LIT:200>, <NUM_LIT>, <NUM_LIT>),<EOL>headers=headers, json={\"<STR_LIT>\": \"<STR_LIT>\"})<EOL>regTokenHead = endpointResp.headers.get(\"<STR_LIT>\")<EOL>locHead = endpointResp.headers.get(\"<STR_LIT>\")<EOL>if locHead:<EOL><INDENT>locParts = re.search(r\"<STR_LIT>\", locHead).groups()<EOL>if locParts[<NUM_LIT:2>]:<EOL><INDENT>endpoint = SkypeEndpoint(self.conn, locParts[<NUM_LIT:2>].replace(\"<STR_LIT>\", \"<STR_LIT:{>\").replace(\"<STR_LIT>\", \"<STR_LIT:}>\"))<EOL><DEDENT>if not locParts[<NUM_LIT:0>] == msgsHost:<EOL><INDENT>msgsHost = locHead.rsplit(\"<STR_LIT:/>\", <NUM_LIT:4> if locParts[<NUM_LIT:2>] else <NUM_LIT:3>)[<NUM_LIT:0>]<EOL>continue<EOL><DEDENT><DEDENT>if regTokenHead:<EOL><INDENT>token = re.search(r\"<STR_LIT>\", regTokenHead, re.I).group(<NUM_LIT:1>)<EOL>regExpiry = re.search(r\"<STR_LIT>\", regTokenHead).group(<NUM_LIT:1>)<EOL>expiry = datetime.fromtimestamp(int(regExpiry))<EOL>regEndMatch = re.search(r\"<STR_LIT>\", regTokenHead)<EOL>if regEndMatch:<EOL><INDENT>endpoint = SkypeEndpoint(self.conn, regEndMatch.group(<NUM_LIT:1>))<EOL><DEDENT><DEDENT>if not endpoint and endpointResp.status_code == <NUM_LIT:200> and endpointResp.json():<EOL><INDENT>endpoint = SkypeEndpoint(self.conn, endpointResp.json()[<NUM_LIT:0>][\"<STR_LIT:id>\"])<EOL><DEDENT><DEDENT>return token, expiry, msgsHost, endpoint<EOL>", "docstring": "Request a new registration token using a current Skype token.\n\nArgs:\n    skypeToken (str): existing Skype token\n\nReturns:\n    (str, datetime.datetime, str, SkypeEndpoint) tuple: registration token, associated expiry if known,\n                                                        resulting endpoint hostname, endpoint if provided\n\nRaises:\n    .SkypeAuthException: if the login request is rejected\n    .SkypeApiException: if the login form can't be processed", "id": "f11797:c6:m0"}
{"signature": "def subscribe(self):", "body": "self.conn(\"<STR_LIT:POST>\", \"<STR_LIT>\".format(self.conn.msgsHost, self.id),<EOL>auth=SkypeConnection.Auth.RegToken,<EOL>json={\"<STR_LIT>\": [\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\"],<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\"})<EOL>self.subscribed = True<EOL>", "docstring": "Subscribe to contact and conversation events.  These are accessible through :meth:`getEvents`.", "id": "f11797:c7:m3"}
{"signature": "def __init__(self):", "body": "self.userId = None<EOL>self.tokens = {}<EOL>self.tokenExpiry = {}<EOL>self.tokenFile = None<EOL>self.msgsHost = self.API_MSGSHOST<EOL>self.sess = requests.Session()<EOL>self.endpoints = {\"<STR_LIT>\": SkypeEndpoint(self, \"<STR_LIT>\")}<EOL>self.syncStates = {}<EOL>", "docstring": "Create a new, unconnected instance.", "id": "f11797:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def externalCall(cls, method, url, codes=(<NUM_LIT:200>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>), **kwargs):<DEDENT>", "body": "if os.getenv(\"<STR_LIT>\"):<EOL><INDENT>print(\"<STR_LIT>\".format(datetime.now().strftime(\"<STR_LIT>\"), method, url))<EOL>print(pformat(kwargs))<EOL><DEDENT>resp = cls.extSess.request(method, url, **kwargs)<EOL>if os.getenv(\"<STR_LIT>\"):<EOL><INDENT>print(\"<STR_LIT>\".format(datetime.now().strftime(\"<STR_LIT>\"), resp.status_code))<EOL>print(pformat(dict(resp.headers)))<EOL>try:<EOL><INDENT>print(pformat(resp.json()))<EOL><DEDENT>except ValueError:<EOL><INDENT>print(resp.text)<EOL><DEDENT><DEDENT>if resp.status_code not in codes:<EOL><INDENT>raise SkypeApiException(\"<STR_LIT>\".format(resp.status_code, method, url), resp)<EOL><DEDENT>return resp<EOL>", "docstring": "Make a public API call without a connected :class:`.Skype` instance.\n\nThe obvious implications are that no authenticated calls are possible, though this allows accessing some public\nAPIs such as join URL lookups.\n\nArgs:\n    method (str): HTTP request method\n    url (str): full URL to connect to\n    codes (int list): expected HTTP response codes for success\n    kwargs (dict): any extra parameters to pass to :func:`requests.request`\n\nReturns:\n    requests.Response: response object provided by :mod:`requests`\n\nRaises:\n    .SkypeAuthException: if an authentication rate limit is reached\n    .SkypeApiException: if a successful status code is not received", "id": "f11797:c0:m1"}
{"signature": "def config(self, name=\"<STR_LIT>\"):", "body": "self.conn(\"<STR_LIT>\", \"<STR_LIT>\"<EOL>.format(self.conn.msgsHost, self.id),<EOL>auth=SkypeConnection.Auth.RegToken,<EOL>json={\"<STR_LIT:id>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:type>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": {\"<STR_LIT>\": name},<EOL>\"<STR_LIT>\": {\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:type>\": <NUM_LIT:1>,<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT:version>\": \"<STR_LIT>\"}})<EOL>", "docstring": "Configure this endpoint to allow setting presence.\n\nArgs:\n    name (str): display name for this endpoint", "id": "f11797:c7:m1"}
{"signature": "def getRegToken(self):", "body": "self.verifyToken(self.Auth.SkypeToken)<EOL>token, expiry, msgsHost, endpoint = SkypeRegistrationTokenProvider(self).auth(self.tokens[\"<STR_LIT>\"])<EOL>self.tokens[\"<STR_LIT>\"] = token<EOL>self.tokenExpiry[\"<STR_LIT>\"] = expiry<EOL>self.msgsHost = msgsHost<EOL>if endpoint:<EOL><INDENT>endpoint.config()<EOL>self.endpoints[\"<STR_LIT>\"] = endpoint<EOL><DEDENT>self.syncEndpoints()<EOL>if self.tokenFile:<EOL><INDENT>self.writeToken()<EOL><DEDENT>", "docstring": "Acquire a new registration token.\n\nOnce successful, all tokens and expiry times are written to the token file (if specified on initialisation).", "id": "f11797:c0:m17"}
{"signature": "def setUserPwd(self, user, pwd):", "body": "def getSkypeToken(self):<EOL><INDENT>self.liveLogin(user, pwd)<EOL><DEDENT>self.getSkypeToken = MethodType(getSkypeToken, self)<EOL>", "docstring": "Replace the stub :meth:`getSkypeToken` method with one that connects via the Microsoft account flow using the\ngiven credentials.  Avoids storing the account password in an accessible way.\n\nArgs:\n    user (str): username or email address of the connecting account\n    pwd (str): password of the connecting account", "id": "f11797:c0:m7"}
{"signature": "def user(self, id):", "body": "json = self.skype.conn(\"<STR_LIT:POST>\", \"<STR_LIT>\".format(SkypeConnection.API_PROFILE),<EOL>auth=SkypeConnection.Auth.SkypeToken, json={\"<STR_LIT>\": [id]}).json()<EOL>if json and \"<STR_LIT:status>\" not in json[<NUM_LIT:0>]:<EOL><INDENT>return self.merge(SkypeUser.fromRaw(self.skype, json[<NUM_LIT:0>]))<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Retrieve public information about a user.\n\nArgs:\n    id (str): user identifier to lookup\n\nReturns:\n    SkypeUser: resulting user object", "id": "f11798:c3:m6"}
{"signature": "def accept(self):", "body": "self.skype.conn(\"<STR_LIT>\", \"<STR_LIT>\"<EOL>.format(SkypeConnection.API_CONTACTS, self.skype.userId, self.userId),<EOL>auth=SkypeConnection.Auth.SkypeToken)<EOL>self.skype.conn(\"<STR_LIT>\", \"<STR_LIT>\".format(self.skype.conn.msgsHost, self.userId),<EOL>auth=SkypeConnection.Auth.RegToken)<EOL>", "docstring": "Accept the contact request, and add the user to the contact list.", "id": "f11798:c5:m1"}
{"signature": "def contact(self, id):", "body": "try:<EOL><INDENT>json = self.skype.conn(\"<STR_LIT:POST>\", \"<STR_LIT>\".format(SkypeConnection.API_USER),<EOL>json={\"<STR_LIT>\": [id]}, auth=SkypeConnection.Auth.SkypeToken).json()<EOL>contact = SkypeContact.fromRaw(self.skype, json[<NUM_LIT:0>])<EOL>if contact.id not in self.contactIds:<EOL><INDENT>self.contactIds.append(contact.id)<EOL><DEDENT>return self.merge(contact)<EOL><DEDENT>except SkypeApiException as e:<EOL><INDENT>if len(e.args) >= <NUM_LIT:2> and getattr(e.args[<NUM_LIT:1>], \"<STR_LIT>\", None) == <NUM_LIT>:<EOL><INDENT>return None<EOL><DEDENT>raise<EOL><DEDENT>", "docstring": "Retrieve all details for a specific contact, including fields such as birthday and mood.\n\nArgs:\n    id (str): user identifier to lookup\n\nReturns:\n    SkypeContact: resulting contact object", "id": "f11798:c3:m5"}
{"signature": "def bot(self, id):", "body": "json = self.skype.conn(\"<STR_LIT:GET>\", \"<STR_LIT>\".format(SkypeConnection.API_BOT), params={\"<STR_LIT>\": id},<EOL>auth=SkypeConnection.Auth.SkypeToken).json().get(\"<STR_LIT>\", [])<EOL>return self.merge(SkypeBotUser.fromRaw(self.skype, json[<NUM_LIT:0>])) if json else None<EOL>", "docstring": "Retrieve a single bot.\n\nArgs:\n    id (str): UUID or username of the bot\n\nReturns:\n    SkypeBotUser: resulting bot user object", "id": "f11798:c3:m8"}
{"signature": "def __repr__(self):", "body": "if self.names:<EOL><INDENT>return \"<STR_LIT>\".format(self.__class__.__name__, repr(self.label), repr(self.names))<EOL><DEDENT>else:<EOL><INDENT>return \"<STR_LIT>\".format(self.path, self.label) if self.path else self.label<EOL><DEDENT>", "docstring": "Show constructor for the parent, or just the qualified name for each item.", "id": "f11799:c2:m3"}
{"signature": "def __init__(self, skype=None, raw=None):", "body": "self.skype = skype<EOL>self.raw = raw<EOL>", "docstring": "Instantiate a plain instance of this class, and store a reference to the Skype object for later API calls.\n\nNormally this method won't be called or implemented directly.\n\nImplementers should make use of :meth:`fromRaw` and the :meth:`initAttrs` decorator instead.\n\nArgs:\n    skype (Skype): parent Skype instance\n    raw (dict): raw object, as provided by the API", "id": "f11799:c0:m0"}
{"signature": "def merge(self, obj):", "body": "if obj.id in self.cache:<EOL><INDENT>self.cache[obj.id].merge(obj)<EOL><DEDENT>else:<EOL><INDENT>self.cache[obj.id] = obj<EOL><DEDENT>return self.cache[obj.id]<EOL>", "docstring": "Add a given object to the cache, or update an existing entry to include more fields.\n\nArgs:\n    obj (SkypeObj): object to add to the cache", "id": "f11799:c1:m4"}
{"signature": "def __repr__(self):", "body": "reprs = []<EOL>for attr in self.attrs:<EOL><INDENT>val = getattr(self, attr)<EOL>if not val == self.defaults.get(attr):<EOL><INDENT>reprs.append(\"<STR_LIT>\".format(attr, repr(val)))<EOL><DEDENT><DEDENT>return \"<STR_LIT>\".format(self.__class__.__name__, \"<STR_LIT:U+002CU+0020>\".join(reprs))<EOL>", "docstring": "Dump properties of the object into a Python-like statement, based on the class' :attr:`attrs`.\n\nThe resulting string is an expression that should evaluate to a similar object, minus Skype connection.", "id": "f11799:c0:m5"}
{"signature": "def __str__(self):", "body": "if self.names:<EOL><INDENT>return \"<STR_LIT>\".format(self.__class__.__name__, self.label, \"<STR_LIT:\\n>\".join(self.names))<EOL><DEDENT>else:<EOL><INDENT>return self.label<EOL><DEDENT>", "docstring": "Show a list of items for the parent, or just the label for each item.", "id": "f11799:c2:m2"}
{"signature": "def delete(self):", "body": "self.skype.conn(\"<STR_LIT>\", \"<STR_LIT>\".format(self.skype.conn.msgsHost, self.id),<EOL>auth=SkypeConnection.Auth.RegToken)<EOL>", "docstring": "Delete the conversation and all message history.", "id": "f11801:c0:m9"}
{"signature": "def indent(text, prefix, predicate=None):", "body": "if predicate is None:<EOL><INDENT>def predicate(line):<EOL><INDENT>return line.strip()<EOL><DEDENT><DEDENT>def prefixed_lines():<EOL><INDENT>for line in text.splitlines(True):<EOL><INDENT>yield (prefix + line if predicate(line) else line)<EOL><DEDENT><DEDENT>return '<STR_LIT>'.join(prefixed_lines())<EOL>", "docstring": "Adds 'prefix' to the beginning of selected lines in 'text'.\n\n    If 'predicate' is provided, 'prefix' will only be added to the lines\n    where 'predicate(line)' is True. If 'predicate' is not provided,\n    it will default to adding 'prefix' to all non-empty lines that do not\n    consist solely of whitespace characters.\n\n    Borrowed from Py3 `textwrap` module.", "id": "f11807:m1"}
{"signature": "def all(self):", "body": "if self._thumbnails is not None:<EOL><INDENT>return self._thumbnails<EOL><DEDENT>self._refresh_cache()<EOL>return self._thumbnails<EOL>", "docstring": "Return all thumbnails in a dict format.", "id": "f11826:c2:m3"}
{"signature": "def get(self, size, create=True):", "body": "if self._thumbnails is None:<EOL><INDENT>self._refresh_cache()<EOL><DEDENT>thumbnail = self._thumbnails.get(size)<EOL>if thumbnail is None:<EOL><INDENT>thumbnail = images.get(self.source_image.name, size,<EOL>self.metadata_backend, self.storage)<EOL>if thumbnail is None:<EOL><INDENT>thumbnail = self.create(size)<EOL><DEDENT>self._thumbnails[size] = thumbnail<EOL><DEDENT>return thumbnail<EOL>", "docstring": "Returns a Thumbnail instance.\nFirst check whether thumbnail is already cached. If it doesn't:\n1. Try to fetch the thumbnail\n2. Create thumbnail if it's not present\n3. Cache the thumbnail for future use", "id": "f11826:c2:m4"}
{"signature": "def create(self, size):", "body": "thumbnail = images.create(self.source_image.name, size,<EOL>self.metadata_backend, self.storage)<EOL>return thumbnail<EOL>", "docstring": "Creates and return a thumbnail of a given size.", "id": "f11826:c2:m5"}
{"signature": "def get(source_name, size, metadata_backend=None, storage_backend=None):", "body": "if storage_backend is None:<EOL><INDENT>storage_backend = backends.storage.get_backend()<EOL><DEDENT>if metadata_backend is None:<EOL><INDENT>metadata_backend = backends.metadata.get_backend()<EOL><DEDENT>metadata = metadata_backend.get_thumbnail(source_name, size)<EOL>if metadata is None:<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>return Thumbnail(metadata=metadata, storage=storage_backend)<EOL><DEDENT>", "docstring": "Returns a Thumbnail instance, or None if thumbnail does not yet exist.", "id": "f11829:m2"}
{"signature": "def create(source_name, size, metadata_backend=None, storage_backend=None):", "body": "if storage_backend is None:<EOL><INDENT>storage_backend = backends.storage.get_backend()<EOL><DEDENT>if metadata_backend is None:<EOL><INDENT>metadata_backend = backends.metadata.get_backend()<EOL><DEDENT>thumbnail_file = processors.process(storage_backend.open(source_name), size)<EOL>thumbnail_file = post_processors.process(thumbnail_file, size)<EOL>name = get_thumbnail_name(source_name, size)<EOL>name = storage_backend.save(name, thumbnail_file)<EOL>metadata = metadata_backend.add_thumbnail(source_name, size, name)<EOL>return Thumbnail(metadata=metadata, storage=storage_backend)<EOL>", "docstring": "Creates a thumbnail file and its relevant metadata. Returns a\nThumbnail instance.", "id": "f11829:m1"}
{"signature": "def south_field_triple(self):", "body": "from south.modelsinspector import introspector<EOL>field_class = '<STR_LIT>'<EOL>args, kwargs = introspector(self)<EOL>return (field_class, args, kwargs)<EOL>", "docstring": "Return a suitable description of this field for South.\nTaken from smiley chris' easy_thumbnails", "id": "f11830:c0:m4"}
{"signature": "def crop(image, **kwargs):", "body": "image.crop(**kwargs)<EOL>return image<EOL>", "docstring": "Crops an image based on given width or height", "id": "f11832:m3"}
{"signature": "def rotate(image, **kwargs):", "body": "image.rotate(**kwargs)<EOL>return image<EOL>", "docstring": "Rotates an argument by X degrees.", "id": "f11832:m1"}
{"signature": "def flip(image, **kwargs):", "body": "image.flip(**kwargs)<EOL>return image<EOL>", "docstring": "Flips an image. Expects \"horizontal\" or \"vertical\" as argument.", "id": "f11832:m2"}
{"signature": "def set_mock_engine(self, engine):", "body": "if not engine:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>mock_engine = engine(self)<EOL>methods = ('<STR_LIT>', '<STR_LIT>')<EOL>if not all([hasattr(mock_engine, method) for method in methods]):<EOL><INDENT>raise NotImplementedError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>self.mock_engine = mock_engine<EOL>if self.active:<EOL><INDENT>self.mock_engine.activate()<EOL><DEDENT>", "docstring": "Sets a custom mock engine, replacing the built-in one.\n\nThis is particularly useful if you want to replace the built-in\nHTTP traffic mock interceptor engine with your custom one.\n\nFor mock engine implementation details, see `pook.MockEngine`.\n\nArguments:\n    engine (pook.MockEngine): custom mock engine to use.", "id": "f11876:c0:m1"}
{"signature": "def isunmatched(self):", "body": "return len(self.unmatched()) > <NUM_LIT:0><EOL>", "docstring": "Returns ``True`` if there are unmatched requests. Otherwise ``False``.\n\nUnmatched requests will be registered only if ``networking`` mode\nhas been enabled.\n\nReturns:\n    bool", "id": "f11876:c0:m19"}
{"signature": "def isdone(self):", "body": "return all(mock.isdone() for mock in self.mocks)<EOL>", "docstring": "Returns True if all the registered mocks has been triggered.\n\nReturns:\n    bool: True is all the registered mocks are gone, otherwise False.", "id": "f11876:c0:m24"}
{"signature": "def activate(self):", "body": "if self.active:<EOL><INDENT>return None<EOL><DEDENT>self.mock_engine.activate()<EOL>self.active = True<EOL>", "docstring": "Activates the registered interceptors in the mocking engine.\n\nThis means any HTTP traffic captures by those interceptors will\ntrigger the HTTP mock matching engine in order to determine if a given\nHTTP transaction should be mocked out or not.", "id": "f11876:c0:m14"}
{"signature": "def remove_mock(self, mock):", "body": "self.mocks = [m for m in self.mocks if m is not mock]<EOL>", "docstring": "Removes a specific mock instance by object reference.\n\nArguments:\n    mock (pook.Mock): mock instance to remove.", "id": "f11876:c0:m8"}
{"signature": "def unmatched_requests(self):", "body": "return [mock for mock in self.unmatched_reqs]<EOL>", "docstring": "Returns a ``tuple`` of unmatched requests.\n\nUnmatched requests will be registered only if ``networking`` mode\nhas been enabled.\n\nReturns:\n    list: unmatched intercepted requests.", "id": "f11876:c0:m17"}
{"signature": "def add_mock(self, mock):", "body": "self.mocks.append(mock)<EOL>", "docstring": "Adds a new mock instance to the current engine.\n\nArguments:\n    mock (pook.Mock): mock instance to add.", "id": "f11876:c0:m7"}
{"signature": "def map(self, *mappers):", "body": "self._append(self.mappers, *mappers)<EOL>", "docstring": "Append engine-level HTTP request mapper functions.\n\nArguments:\n    filters*: variadic mapper functions to be added.", "id": "f11876:c0:m27"}
{"signature": "def disable(self):", "body": "<EOL>for interceptor in self.interceptors:<EOL><INDENT>try:<EOL><INDENT>interceptor.disable()<EOL><DEDENT>except RuntimeError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>", "docstring": "Disables interceptors and stops intercepting any outgoing HTTP traffic.", "id": "f11877:c0:m5"}
{"signature": "def itermerged(self):", "body": "for key in self:<EOL><INDENT>val = self._container[key.lower()]<EOL>yield val[<NUM_LIT:0>], '<STR_LIT:U+002CU+0020>'.join(val[<NUM_LIT:1>:])<EOL><DEDENT>", "docstring": "Iterate over all headers, merging duplicate ones together.", "id": "f11878:c0:m19"}
{"signature": "def add(self, key, val):", "body": "key_lower = key.lower()<EOL>new_vals = key, val<EOL>vals = self._container.setdefault(key_lower, new_vals)<EOL>if new_vals is not vals:<EOL><INDENT>if isinstance(vals, list):<EOL><INDENT>vals.append(val)<EOL><DEDENT>else:<EOL><INDENT>self._container[key_lower] = [vals[<NUM_LIT:0>], vals[<NUM_LIT:1>], val]<EOL><DEDENT><DEDENT>", "docstring": "Adds a (name, value) pair, doesn't overwrite the value if it already\nexists.\n\nUsage::\n\n    headers = HTTPHeaderDict(foo='bar')\n    headers.add('Foo', 'baz')\n    headers['foo']\n    > 'bar, baz'", "id": "f11878:c0:m11"}
{"signature": "def extend(self, *args, **kwargs):", "body": "if len(args) > <NUM_LIT:1>:<EOL><INDENT>raise TypeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(len(args)))<EOL><DEDENT>other = args[<NUM_LIT:0>] if len(args) >= <NUM_LIT:1> else ()<EOL>if isinstance(other, HTTPHeaderDict):<EOL><INDENT>for key, val in other.iteritems():<EOL><INDENT>self.add(key, val)<EOL><DEDENT><DEDENT>elif isinstance(other, Mapping):<EOL><INDENT>for key in other:<EOL><INDENT>self.add(key, other[key])<EOL><DEDENT><DEDENT>elif hasattr(other, \"<STR_LIT>\"):<EOL><INDENT>for key in other.keys():<EOL><INDENT>self.add(key, other[key])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for key, value in other:<EOL><INDENT>self.add(key, value)<EOL><DEDENT><DEDENT>for key, value in kwargs.items():<EOL><INDENT>self.add(key, value)<EOL><DEDENT>", "docstring": "Generic import function for any type of header-like object.\nAdapted version of MutableMapping.update in order to insert items\nwith self.add instead of self.__setitem__", "id": "f11878:c0:m13"}
{"signature": "def set(self, key, val):", "body": "key_lower = key.lower()<EOL>new_vals = key, val<EOL>vals = self._container.setdefault(key_lower, new_vals)<EOL>if new_vals is not vals:<EOL><INDENT>self._container[key_lower] = [vals[<NUM_LIT:0>], vals[<NUM_LIT:1>], val]<EOL><DEDENT>", "docstring": "Sets a header field with the given value, removing\nprevious values.\n\nUsage::\n\n    headers = HTTPHeaderDict(foo='bar')\n    headers.set('Foo', 'baz')\n    headers['foo']\n    > 'baz'", "id": "f11878:c0:m12"}
{"signature": "def compare(self, value, expectation, regex_expr=False):", "body": "return compare(value, expectation, regex_expr=regex_expr)<EOL>", "docstring": "Compares two values with regular expression matching support.\n\nArguments:\n    value (mixed): value to compare.\n    expectation (mixed): value to match.\n    regex_expr (bool, optional): enables string based regex matching.\n\nReturns:\n    bool", "id": "f11884:c0:m5"}
{"signature": "def to_dict(self):", "body": "return {self.name: deepcopy(self.expectation)}<EOL>", "docstring": "Returns the current matcher representation as dictionary.\n\nReturns:\n    dict", "id": "f11884:c0:m6"}
{"signature": "def get(name):", "body": "for matcher in matchers:<EOL><INDENT>if matcher.__name__ == name or getattr(matcher, '<STR_LIT:name>', None) == name:<EOL><INDENT>return matcher<EOL><DEDENT><DEDENT>", "docstring": "Returns a matcher instance by class or alias name.\n\nArguments:\n    name (str): matcher class name or alias.\n\nReturns:\n    matcher: found matcher instance, otherwise ``None``.", "id": "f11890:m1"}
{"signature": "@abstractmethod<EOL><INDENT>def activate(self):<DEDENT>", "body": "pass<EOL>", "docstring": "Activates the traffic interceptor.\nThis method must be implemented by any interceptor.", "id": "f11895:c0:m2"}
{"signature": "def get(name):", "body": "for interceptor in interceptors:<EOL><INDENT>if interceptor.__name__ == name:<EOL><INDENT>return interceptor<EOL><DEDENT><DEDENT>", "docstring": "Returns an interceptor by class name.\n\nArguments:\n    name (str): interceptor class name or alias.\n\nReturns:\n    interceptor: found interceptor instance, otherwise ``None``.", "id": "f11897:m1"}
{"signature": "def activate(self):", "body": "[self._patch(path) for path in PATCHES]<EOL>", "docstring": "Activates the traffic interceptor.\nThis method must be implemented by any interceptor.", "id": "f11900:c0:m3"}
{"signature": "def __repr__(self):", "body": "matchers = [repr(matcher) for matcher in self]<EOL>return '<STR_LIT>'.format('<STR_LIT>'.join(matchers))<EOL>", "docstring": "Returns an human friendly readable instance data representation.\n\nReturns:\n    str", "id": "f11901:c0:m3"}
{"signature": "def trigger_methods(instance, args):", "body": "<EOL>for name in sorted(args):<EOL><INDENT>value = args[name]<EOL>target = instance<EOL>if name.startswith('<STR_LIT>') or name.startswith('<STR_LIT>'):<EOL><INDENT>name = name.replace('<STR_LIT>', '<STR_LIT>').replace('<STR_LIT>', '<STR_LIT>')<EOL>if hasattr(instance, '<STR_LIT>'):<EOL><INDENT>target = instance._response<EOL><DEDENT><DEDENT>member = getattr(target, name, None)<EOL>isattr = name in dir(target)<EOL>iscallable = ismethod(member) and not isfunction(member)<EOL>if not iscallable and not isattr:<EOL><INDENT>raise PookInvalidArgument('<STR_LIT>'.format(name))<EOL><DEDENT>if iscallable:<EOL><INDENT>member(value)<EOL><DEDENT>else:<EOL><INDENT>setattr(target, name, value)<EOL><DEDENT><DEDENT>", "docstring": "Triggers specific class methods using a simple reflection\nmechanism based on the given input dictionary params.\n\nArguments:\n    instance (object): target instance to dynamically trigger methods.\n    args (iterable): input arguments to trigger objects to\n\nReturns:\n    None", "id": "f11903:m0"}
{"signature": "@fluent<EOL><INDENT>def filter(self, *filters):<DEDENT>", "body": "_append_funcs(self.filters, filters)<EOL>", "docstring": "Registers one o multiple request filters used during the matching\nphase.\n\nArguments:\n    *mappers (function): variadic mapper functions.\n\nReturns:\n    self: current Mock instance.", "id": "f11904:c0:m22"}
{"signature": "@fluent<EOL><INDENT>def url(self, url):<DEDENT>", "body": "self._request.url = url<EOL>self.add_matcher(matcher('<STR_LIT>', url))<EOL>", "docstring": "Defines the mock URL to match.\nIt can be a full URL with path and query params.\n\nProtocol schema is optional, defaults to ``http://``.\n\nArguments:\n    url (str): mock URL to match. E.g: ``server.com/api``.\n\nReturns:\n    self: current Mock instance.", "id": "f11904:c0:m1"}
{"signature": "@fluent<EOL><INDENT>def params(self, params):<DEDENT>", "body": "url = furl(self._request.rawurl)<EOL>url = url.add(params)<EOL>self._request.url = url.url<EOL>self.add_matcher(matcher('<STR_LIT>', params))<EOL>", "docstring": "Defines a set of URL query params to match.\n\nArguments:\n    params (dict): set of params to match.\n\nReturns:\n    self: current Mock instance.", "id": "f11904:c0:m12"}
{"signature": "def isdone(self):", "body": "return (self._persist and self._matches > <NUM_LIT:0>) or self._times <= <NUM_LIT:0><EOL>", "docstring": "Returns ``True`` if the mock has been matched by outgoing HTTP traffic.\n\nReturns:\n    bool: ``True`` if the mock was matched succesfully.", "id": "f11904:c0:m30"}
{"signature": "@property<EOL><INDENT>def matched(self):<DEDENT>", "body": "return self._matches > <NUM_LIT:0><EOL>", "docstring": "Accessor property that would be ``True`` if the current mock\nhave been matched at least once.\n\nSee ``Mock.total_matches`` for more information.\n\nReturns:\n    bool", "id": "f11904:c0:m33"}
{"signature": "def _trigger_request(instance, request):", "body": "if not isinstance(request, Request):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>for key in request.keys:<EOL><INDENT>if hasattr(instance, key):<EOL><INDENT>getattr(instance, key)(getattr(request, key))<EOL><DEDENT><DEDENT>", "docstring": "Triggers request mock definition methods dynamically based on input\nkeyword arguments passed to `pook.Mock` constructor.\n\nThis is used to provide a more Pythonic interface vs chainable API\napproach.", "id": "f11904:m1"}
{"signature": "def __exit__(self, etype, value, traceback):", "body": "<EOL>self._times = <NUM_LIT:0><EOL>if getattr(self, '<STR_LIT>', False):<EOL><INDENT>self._disable_engine = False<EOL>self._engine.disable()<EOL><DEDENT>if etype is not None:<EOL><INDENT>raise value<EOL><DEDENT>", "docstring": "Implements context manager exit interface.", "id": "f11904:c0:m41"}
{"signature": "@property<EOL><INDENT>def total_matches(self):<DEDENT>", "body": "return self._matches<EOL>", "docstring": "Accessor property to retrieve the total number of times that the\ncurrent mock has been matched.\n\nReturns:\n    int", "id": "f11904:c0:m34"}
{"signature": "def ismatched(self):", "body": "return self._matches > <NUM_LIT:0><EOL>", "docstring": "Returns ``True`` if the mock has been matched at least once time.\n\nReturns:\n    bool", "id": "f11904:c0:m31"}
{"signature": "@fluent<EOL><INDENT>def persist(self, status=None):<DEDENT>", "body": "self._persist = status if type(status) is bool else True<EOL>", "docstring": "Enables persistent mode for the current mock.\n\nReturns:\n    self: current Mock instance.", "id": "f11904:c0:m21"}
{"signature": "@property<EOL><INDENT>def calls(self):<DEDENT>", "body": "return len(self.matches)<EOL>", "docstring": "Accessor to retrieve the amount of mock matched calls.\n\nReturns:\n    int", "id": "f11904:c0:m36"}
{"signature": "def reply(self, status=<NUM_LIT:200>, new_response=False, **kw):", "body": "<EOL>res = Response(**kw) if new_response else self._response<EOL>res.status(status or res._status)<EOL>res.mock = self<EOL>self._response = res<EOL>return res<EOL>", "docstring": "Defines the mock response.\n\nArguments:\n    status (int, optional): response status code. Defaults to ``200``.\n    **kw (dict): optional keyword arguments passed to ``pook.Response``\n        constructor.\n\nReturns:\n    pook.Response: mock response definition instance.", "id": "f11904:c0:m27"}
{"signature": "@fluent<EOL><INDENT>def error(self, error):<DEDENT>", "body": "self._error = RuntimeError(error) if isinstance(error, str) else error<EOL>", "docstring": "Defines a simulated exception error that will be raised.\n\nArguments:\n    error (str|Exception): error to raise.\n\nReturns:\n    self: current Mock instance.", "id": "f11904:c0:m26"}
{"signature": "@fluent<EOL><INDENT>def json(self, json):<DEDENT>", "body": "self._request.json = json<EOL>self.add_matcher(matcher('<STR_LIT>', json))<EOL>", "docstring": "Defines the JSON body to match.\n\n``json`` argument can be an JSON string, a JSON serializable\nPython structure, such as a ``dict`` or ``list`` or it can be\na regular expression used to match the body.\n\nArguments:\n    json (str|dict|list|regex): body JSON to match.\n\nReturns:\n    self: current Mock instance.", "id": "f11904:c0:m14"}
{"signature": "@fluent<EOL><INDENT>def header(self, name, value):<DEDENT>", "body": "headers = {name: value}<EOL>self._request.headers = headers<EOL>self.add_matcher(matcher('<STR_LIT>', headers))<EOL>", "docstring": "Defines a URL path to match.\n\nOnly call this method if the URL has no path already defined.\n\nArguments:\n    path (str): URL path value to match. E.g: ``/api/users``.\n\nReturns:\n    self: current Mock instance.", "id": "f11904:c0:m4"}
{"signature": "def mock(url=None, **kw):", "body": "return _engine.mock(url, **kw)<EOL>", "docstring": "Creates and register a new HTTP mock.\n\nArguments:\n    url (str): request URL to mock.\n    activate (bool): force mock engine activation.\n        Defaults to ``False``.\n    **kw (mixed): variadic keyword arguments.\n\nReturns:\n    pook.Mock: mock instance", "id": "f11905:m15"}
{"signature": "def ispending():", "body": "return _engine.ispending()<EOL>", "docstring": "Returns the numbers of pending mocks to be matched.\n\nReturns:\n    int: number of pending mocks to match.", "id": "f11905:m24"}
{"signature": "def flush_network_filters():", "body": "_engine.flush_network_filters()<EOL>", "docstring": "Flushes registered real networking filters in the current\nmock engine.", "id": "f11905:m14"}
{"signature": "def pending():", "body": "return _engine.pending()<EOL>", "docstring": "Returns the numbers of pending mocks to be matched.\n\nReturns:\n    int: number of pending mocks to match.", "id": "f11905:m23"}
{"signature": "def delete(url, **kw):", "body": "return mock(url, method='<STR_LIT>', **kw)<EOL>", "docstring": "Registers a new mock HTTP request with DELETE method.\n\nArguments:\n    url (str): request URL to mock.\n    activate (bool): force mock engine activation.\n        Defaults to ``False``.\n    **kw (mixed): variadic arguments to ``pook.Mock`` constructor.\n\nReturns:\n    pook.Mock: mock instance", "id": "f11905:m19"}
{"signature": "def isregex(value):", "body": "if not value:<EOL><INDENT>return False<EOL><DEDENT>return any((isregex_expr(value), isinstance(value, retype)))<EOL>", "docstring": "Returns ``True`` if the input argument object is a native\nregular expression object, otherwise ``False``.\n\nArguments:\n    value (mixed): input value to test.\n\nReturns:\n    bool", "id": "f11908:m1"}
{"signature": "@fluent<EOL><INDENT>def header(self, key, value):<DEDENT>", "body": "if type(key) is tuple:<EOL><INDENT>key, value = str(key[<NUM_LIT:0>]), key[<NUM_LIT:1>]<EOL><DEDENT>headers = {key: value}<EOL>self._headers.extend(headers)<EOL>", "docstring": "Defines a new response header.\nAlias to ``Response.header()``.\n\nArguments:\n    header (str): header name.\n    value (str): header value.\n\nReturns:\n    self: ``pook.Response`` current instance.", "id": "f11910:c0:m2"}
{"signature": "@fluent<EOL><INDENT>def xml(self, xml):<DEDENT>", "body": "self.body(xml)<EOL>", "docstring": "Defines the mock response XML body.\n\nFor not it only supports ``str`` as input type.\n\nArguments:\n    xml (str): XML body data to use.\n\nReturns:\n    self: ``pook.Response`` current instance.", "id": "f11910:c0:m9"}
{"signature": "@fluent<EOL><INDENT>def content(self, name):<DEDENT>", "body": "self._headers['<STR_LIT:Content-Type>'] = TYPES.get(name, name)<EOL>", "docstring": "Defines the response ``Content-Type`` header.\n\nYou can pass one of the following type aliases instead of the full\nMIME type representation:\n\n- ``json`` = ``application/json``\n- ``xml`` = ``application/xml``\n- ``html`` = ``text/html``\n- ``text`` = ``text/plain``\n- ``urlencoded`` = ``application/x-www-form-urlencoded``\n- ``form`` = ``application/x-www-form-urlencoded``\n- ``form-data`` = ``application/x-www-form-urlencoded``\n\nArguments:\n    value (str): type alias or header value to match.\n\nReturns:\n    self: ``pook.Response`` current instance.", "id": "f11910:c0:m6"}
{"signature": "@fluent<EOL><INDENT>def status(self, code=<NUM_LIT:200>):<DEDENT>", "body": "self._status = int(code)<EOL>", "docstring": "Defines the response status code.\n\nArguments:\n    code (int): response status code.\n\nReturns:\n    self: ``pook.Response`` current instance.", "id": "f11910:c0:m1"}
{"signature": "def __repr__(self):", "body": "args = []<EOL>for key in ('<STR_LIT>', '<STR_LIT:status>', '<STR_LIT:body>'):<EOL><INDENT>value = getattr(self, '<STR_LIT>'.format(key))<EOL>args.append('<STR_LIT>'.format(key, value))<EOL><DEDENT>return '<STR_LIT>'.format('<STR_LIT>'.join(args))<EOL>", "docstring": "Returns an human friendly readable instance data representation.\n\nReturns:\n    str", "id": "f11910:c0:m13"}
{"signature": "def main(arguments=None):", "body": "if not arguments:<EOL><INDENT>arguments = sys.argv[<NUM_LIT:1>:]<EOL><DEDENT>wordlist, sowpods, by_length, start, end = argument_parser(arguments)<EOL>for word in wordlist:<EOL><INDENT>pretty_print(<EOL>word,<EOL>anagrams_in_word(word, sowpods, start, end),<EOL>by_length,<EOL>)<EOL><DEDENT>", "docstring": "Main command line entry point.", "id": "f11916:m2"}
{"signature": "def argument_parser(args):", "body": "parser = argparse.ArgumentParser(<EOL>prog=\"<STR_LIT>\",<EOL>description=\"<STR_LIT>\",<EOL>formatter_class=argparse.RawDescriptionHelpFormatter,<EOL>add_help=False,<EOL>)<EOL>parser.add_argument(<EOL>\"<STR_LIT>\", \"<STR_LIT>\",<EOL>dest=\"<STR_LIT>\",<EOL>action=\"<STR_LIT:store_true>\",<EOL>default=False,<EOL>)<EOL>parser.add_argument(<EOL>\"<STR_LIT>\",<EOL>dest=\"<STR_LIT>\",<EOL>action=\"<STR_LIT:store_true>\",<EOL>default=False,<EOL>)<EOL>parser.add_argument(<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>dest=\"<STR_LIT>\",<EOL>action=\"<STR_LIT:store_true>\",<EOL>default=False,<EOL>)<EOL>parser.add_argument(<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>dest=\"<STR_LIT>\",<EOL>metavar=\"<STR_LIT>\",<EOL>default=\"<STR_LIT>\",<EOL>nargs=<NUM_LIT:1>,<EOL>type=str,<EOL>)<EOL>parser.add_argument(<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>dest=\"<STR_LIT>\",<EOL>metavar=\"<STR_LIT>\",<EOL>default=\"<STR_LIT>\",<EOL>nargs=<NUM_LIT:1>,<EOL>type=str,<EOL>)<EOL>parser.add_argument(<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>action=\"<STR_LIT:version>\",<EOL>version=\"<STR_LIT>\".format(<EOL>nagaram.__version__,<EOL>nagaram.__release_date__,<EOL>)<EOL>)<EOL>parser.add_argument(<EOL>dest=\"<STR_LIT>\",<EOL>metavar=\"<STR_LIT>\",<EOL>nargs=argparse.REMAINDER,<EOL>)<EOL>settings = parser.parse_args(args)<EOL>if settings.help:<EOL><INDENT>raise SystemExit(nagaram.__doc__.strip())<EOL><DEDENT>if not settings.wordlist:<EOL><INDENT>raise SystemExit(parser.print_usage())<EOL><DEDENT>if settings.starts_with:<EOL><INDENT>settings.starts_with = settings.starts_with[<NUM_LIT:0>]<EOL><DEDENT>if settings.ends_with:<EOL><INDENT>settings.ends_with = settings.ends_with[<NUM_LIT:0>]<EOL><DEDENT>return (settings.wordlist, settings.sowpods, settings.length,<EOL>settings.starts_with, settings.ends_with)<EOL>", "docstring": "Argparse logic, command line options.\n\n    Args:\n        args: sys.argv[1:], everything passed to the program after its name\n\n    Returns:\n        A tuple of:\n            a list of words/letters to search\n            a boolean to declare if we want to use the sowpods words file\n            a boolean to declare if we want to output anagrams by length\n            a string of starting characters to find anagrams based on\n            a string of ending characters to find anagrams based on\n\n    Raises:\n        SystemExit if the user passes invalid arguments, --version or --help", "id": "f11916:m1"}
{"signature": "def word_list(sowpods=False, start=\"<STR_LIT>\", end=\"<STR_LIT>\"):", "body": "location = os.path.join(<EOL>os.path.dirname(os.path.realpath(__file__)),<EOL>\"<STR_LIT>\",<EOL>)<EOL>if sowpods:<EOL><INDENT>filename = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>filename = \"<STR_LIT>\"<EOL><DEDENT>filepath = os.path.join(location, filename)<EOL>with open(filepath) as wordfile:<EOL><INDENT>for word in wordfile.readlines():<EOL><INDENT>word = word.strip()<EOL>if start and end and word.startswith(start) and word.endswith(end):<EOL><INDENT>yield word<EOL><DEDENT>elif start and word.startswith(start) and not end:<EOL><INDENT>yield word<EOL><DEDENT>elif end and word.endswith(end) and not start:<EOL><INDENT>yield word<EOL><DEDENT>elif not start and not end:<EOL><INDENT>yield word<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Opens the word list file.\n\n    Args:\n        sowpods: a boolean to declare using the sowpods list or TWL (default)\n        start: a string of starting characters to find anagrams based on\n        end: a string of ending characters to find anagrams based on\n\n    Yeilds:\n        a word at a time out of 178691 words for TWL, 267751 for sowpods. Much\n        less if either start or end are used (filtering is applied here)", "id": "f11917:m3"}
{"signature": "def word_score(word, input_letters, questions=<NUM_LIT:0>):", "body": "score = <NUM_LIT:0><EOL>bingo = <NUM_LIT:0><EOL>filled_by_blanks = []<EOL>rack = list(input_letters)  <EOL>for letter in word:<EOL><INDENT>if letter in rack:<EOL><INDENT>bingo += <NUM_LIT:1><EOL>score += letter_score(letter)<EOL>rack.remove(letter)<EOL><DEDENT>else:<EOL><INDENT>filled_by_blanks.append(letter_score(letter))<EOL><DEDENT><DEDENT>for blank_score in sorted(filled_by_blanks, reverse=True):<EOL><INDENT>if questions > <NUM_LIT:0>:<EOL><INDENT>score += blank_score<EOL>questions -= <NUM_LIT:1><EOL><DEDENT><DEDENT>if bingo > <NUM_LIT:6>:<EOL><INDENT>score += <NUM_LIT:50><EOL><DEDENT>return score<EOL>", "docstring": "Checks the Scrabble score of a single word.\n\n    Args:\n        word: a string to check the Scrabble score of\n        input_letters: the letters in our rack\n        questions: integer of the tiles already on the board to build on\n\n    Returns:\n        an integer Scrabble score amount for the word", "id": "f11917:m1"}
{"signature": "def anagrams_in_word(word, sowpods=False, start=\"<STR_LIT>\", end=\"<STR_LIT>\"):", "body": "input_letters, blanks, questions = blank_tiles(word)<EOL>for tile in start + end:<EOL><INDENT>input_letters.append(tile)<EOL><DEDENT>for word in word_list(sowpods, start, end):<EOL><INDENT>lmap = _letter_map(input_letters)<EOL>used_blanks = <NUM_LIT:0><EOL>for letter in word:<EOL><INDENT>if letter in lmap:<EOL><INDENT>lmap[letter] -= <NUM_LIT:1><EOL>if lmap[letter] < <NUM_LIT:0>:<EOL><INDENT>used_blanks += <NUM_LIT:1><EOL>if used_blanks > (blanks + questions):<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>used_blanks += <NUM_LIT:1><EOL>if used_blanks > (blanks + questions):<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>yield (word, word_score(word, input_letters, questions))<EOL><DEDENT><DEDENT>", "docstring": "Finds anagrams in word.\n\n    Args:\n        word: the string to base our search off of\n        sowpods: boolean to declare TWL or SOWPODS words file\n        start: a string of starting characters to find anagrams based on\n        end: a string of ending characters to find anagrams based on\n\n    Yields:\n        a tuple of (word, score) that can be made with the input_word", "id": "f11919:m1"}
{"signature": "def _letter_map(word):", "body": "lmap = {}<EOL>for letter in word:<EOL><INDENT>try:<EOL><INDENT>lmap[letter] += <NUM_LIT:1><EOL><DEDENT>except KeyError:<EOL><INDENT>lmap[letter] = <NUM_LIT:1><EOL><DEDENT><DEDENT>return lmap<EOL>", "docstring": "Creates a map of letter use in a word.\n\n    Args:\n        word: a string to create a letter map from\n\n    Returns:\n        a dictionary of {letter: integer count of letter in word}", "id": "f11919:m0"}
{"signature": "def find_version(filename):", "body": "with io.open(filename, encoding=\"<STR_LIT:utf-8>\") as version_file:<EOL><INDENT>version_match = re.search(r'<STR_LIT>',<EOL>version_file.read(), re.M)<EOL><DEDENT>if version_match:<EOL><INDENT>return version_match.group(<NUM_LIT:1>)<EOL><DEDENT>return \"<STR_LIT>\"<EOL>", "docstring": "Uses re to pull out the assigned value to __version__ in filename.", "id": "f11920:m0"}
{"signature": "@property<EOL><INDENT>def format_tags(self):<DEDENT>", "body": "tags = VcfRecord._EMPTY_SET<EOL>if self.sample_tag_values:<EOL><INDENT>first_sample = list(self.sample_tag_values.keys())[<NUM_LIT:0>]<EOL>tags = set(self.sample_tag_values[first_sample].keys())<EOL><DEDENT>return tags<EOL>", "docstring": "Returns set of format tags.", "id": "f11930:c5:m4"}
{"signature": "def add_sample_tag_value(self, tag_name, new_sample_values):", "body": "if tag_name in self.format_tags:<EOL><INDENT>msg = \"<STR_LIT>\".format(tag_name)<EOL>raise KeyError(msg)<EOL><DEDENT>if not self._samples_match(new_sample_values):<EOL><INDENT>raise KeyError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>for sample in self.sample_tag_values.keys():<EOL><INDENT>value = str(new_sample_values[sample])<EOL>self.sample_tag_values[sample][tag_name] = value<EOL><DEDENT>", "docstring": "Appends a new format tag-value for all samples.\n\n        Args:\n            tag_name: string tag name; must not already exist\n            new_sample\n\n        Raises:\n            KeyError: if tag_name to be added already exists", "id": "f11949:c1:m15"}
{"signature": "def text(self):", "body": "stringifier = [self.chrom, self.pos, self.vcf_id, self.ref, self.alt,<EOL>self.qual, self.filter, self.info,<EOL>self._format_field()]<EOL>for sample in self.sample_tag_values:<EOL><INDENT>stringifier.append(self._sample_field(sample))<EOL><DEDENT>return \"<STR_LIT:\\t>\".join(stringifier) + \"<STR_LIT:\\n>\"<EOL>", "docstring": "Returns tab-delimited, newline terminated string of VcfRecord.", "id": "f11949:c1:m13"}
{"signature": "@property<EOL><INDENT>def format_tags(self):<DEDENT>", "body": "tags = VcfRecord._EMPTY_SET<EOL>if self.sample_tag_values:<EOL><INDENT>first_sample = list(self.sample_tag_values.keys())[<NUM_LIT:0>]<EOL>tags = set(self.sample_tag_values[first_sample].keys())<EOL><DEDENT>return tags<EOL>", "docstring": "Returns set of format tags.", "id": "f11949:c1:m6"}
{"signature": "def initialize_logger(args):", "body": "global log_filename<EOL>log_filename = os.path.join(os.getcwd(), \"<STR_LIT>\")<EOL>if args.log_file:<EOL><INDENT>_validate_log_file(args.log_file)<EOL>log_filename = args.log_file<EOL><DEDENT>logging.basicConfig(format=_FILE_LOG_FORMAT,<EOL>level=\"<STR_LIT>\",<EOL>datefmt=_DATE_FORMAT,<EOL>filename=log_filename)<EOL>global _verbose<EOL>if args.verbose:<EOL><INDENT>_verbose = args.verbose<EOL><DEDENT>start_time = datetime.now().strftime(_DATE_FORMAT)<EOL>global _logging_dict<EOL>_logging_dict = {'<STR_LIT:user>': getpass.getuser(),<EOL>'<STR_LIT:host>': socket.gethostname(),<EOL>'<STR_LIT>': start_time,<EOL>'<STR_LIT>': args.subparser_name}<EOL>", "docstring": "Sets command name and formatting for subsequent calls to logger", "id": "f11954:m2"}
{"signature": "def error(self, message):", "body": "message = self._remessage_invalid_subparser(message)<EOL>raise utils.UsageError(message)<EOL>", "docstring": "Suppress default exit behavior", "id": "f11956:c0:m1"}
{"signature": "def claim(self, file_readers):", "body": "(prefix_to_readers,<EOL>filter_files,<EOL>unclaimed_set) = self._find_varscan_files(file_readers)<EOL>prefix_by_patients = self._split_prefix_by_patient(prefix_to_readers)<EOL>self._validate_vcf_readers(prefix_by_patients)<EOL>vcf_hc_pairs = self._pair_files(prefix_to_readers, filter_files)<EOL>self._validate_vcf_hc_pairs(vcf_hc_pairs)<EOL>vcf_readers = self._create_vcf_readers(vcf_hc_pairs)<EOL>return list(unclaimed_set), vcf_readers<EOL>", "docstring": "Recognizes and claims VarScan VCFs form the set of all input VCFs.\n\n        Each defined caller has a chance to evaluate and claim all the incoming\n        files as something that it can process. Since VarScan can claim\n        high-confidence files as well, this process is significantly more\n        complex than for other callers.\n\n        Args:\n            file_readers: the collection of currently unclaimed files\n\n        Returns:\n            A tuple of unclaimed readers and VarScanVcfReaders.", "id": "f11958:c5:m15"}
{"signature": "@abc.abstractmethod<EOL>def validate_args(args):", "body": "", "docstring": "validates command-line arguments", "id": "f11964:m0"}
{"signature": "@abc.abstractmethod<EOL><INDENT>@property<EOL>def metaheaders(self):<DEDENT>", "body": "", "docstring": "adds and returns new metaheaders", "id": "f11964:c2:m5"}
{"signature": "def has_changed(self):", "body": "<EOL>if self.formsets:<EOL><INDENT>for formset in self.formsets.values():<EOL><INDENT>for form in formset.forms:<EOL><INDENT>if form.has_changed():<EOL><INDENT>return True<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return bool(self.changed_data)<EOL>", "docstring": "Return True if data differs from initial.", "id": "f11991:c4:m6"}
{"signature": "def create_deferring_foreign_related_manager(related, original_manager_cls):", "body": "relation_name = related.get_accessor_name()<EOL>rel_field = related.field<EOL>rel_model = related.related_model<EOL>superclass = rel_model._default_manager.__class__<EOL>class DeferringRelatedManager(superclass):<EOL><INDENT>def __init__(self, instance):<EOL><INDENT>super(DeferringRelatedManager, self).__init__()<EOL>self.model = rel_model<EOL>self.instance = instance<EOL><DEDENT>def _get_cluster_related_objects(self):<EOL><INDENT>try:<EOL><INDENT>return self.instance._cluster_related_objects<EOL><DEDENT>except AttributeError:<EOL><INDENT>cluster_related_objects = {}<EOL>self.instance._cluster_related_objects = cluster_related_objects<EOL>return cluster_related_objects<EOL><DEDENT><DEDENT>def get_live_query_set(self):<EOL><INDENT>return self.get_live_queryset()<EOL><DEDENT>def get_live_queryset(self):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return original_manager_cls(self.instance).get_queryset()<EOL><DEDENT>def get_queryset(self):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>try:<EOL><INDENT>results = self.instance._cluster_related_objects[relation_name]<EOL><DEDENT>except (AttributeError, KeyError):<EOL><INDENT>return self.get_live_queryset()<EOL><DEDENT>return FakeQuerySet(related.related_model, results)<EOL><DEDENT>def _apply_rel_filters(self, queryset):<EOL><INDENT>return queryset._next_is_sticky()<EOL><DEDENT>def get_prefetch_queryset(self, instances, queryset=None):<EOL><INDENT>if queryset is None:<EOL><INDENT>db = self._db or router.db_for_read(self.model, instance=instances[<NUM_LIT:0>])<EOL>queryset = super(DeferringRelatedManager, self).get_queryset().using(db)<EOL><DEDENT>rel_obj_attr = rel_field.get_local_related_value<EOL>instance_attr = rel_field.get_foreign_related_value<EOL>instances_dict = dict((instance_attr(inst), inst) for inst in instances)<EOL>query = {'<STR_LIT>' % rel_field.name: instances}<EOL>qs = queryset.filter(**query)<EOL>for rel_obj in qs:<EOL><INDENT>instance = instances_dict[rel_obj_attr(rel_obj)]<EOL>setattr(rel_obj, rel_field.name, instance)<EOL><DEDENT>cache_name = rel_field.related_query_name()<EOL>return qs, rel_obj_attr, instance_attr, False, cache_name, False<EOL><DEDENT>def get_object_list(self):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>cluster_related_objects = self._get_cluster_related_objects()<EOL>try:<EOL><INDENT>object_list = cluster_related_objects[relation_name]<EOL><DEDENT>except KeyError:<EOL><INDENT>object_list = list(self.get_live_queryset())<EOL>cluster_related_objects[relation_name] = object_list<EOL><DEDENT>return object_list<EOL><DEDENT>def add(self, *new_items):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>items = self.get_object_list()<EOL>for target in new_items:<EOL><INDENT>item_matched = False<EOL>for i, item in enumerate(items):<EOL><INDENT>if item == target:<EOL><INDENT>items[i] = target<EOL>item_matched = True<EOL>break<EOL><DEDENT><DEDENT>if not item_matched:<EOL><INDENT>items.append(target)<EOL><DEDENT>setattr(target, related.field.name, self.instance)<EOL><DEDENT>if rel_model._meta.ordering and len(items) > <NUM_LIT:1>:<EOL><INDENT>sort_by_fields(items, rel_model._meta.ordering)<EOL><DEDENT><DEDENT>def remove(self, *items_to_remove):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>items = self.get_object_list()<EOL>items[:] = [item for item in items if item not in items_to_remove]<EOL><DEDENT>def create(self, **kwargs):<EOL><INDENT>items = self.get_object_list()<EOL>new_item = related.related_model(**kwargs)<EOL>items.append(new_item)<EOL>return new_item<EOL><DEDENT>def clear(self):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>self.set([])<EOL><DEDENT>def set(self, objs, bulk=True, clear=False):<EOL><INDENT>objs = list(objs)<EOL>cluster_related_objects = self._get_cluster_related_objects()<EOL>for obj in objs:<EOL><INDENT>setattr(obj, related.field.name, self.instance)<EOL><DEDENT>if rel_model._meta.ordering and len(objs) > <NUM_LIT:1>:<EOL><INDENT>sort_by_fields(objs, rel_model._meta.ordering)<EOL><DEDENT>cluster_related_objects[relation_name] = objs<EOL><DEDENT>def commit(self):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if self.instance.pk is None:<EOL><INDENT>raise IntegrityError(\"<STR_LIT>\" % relation_name)<EOL><DEDENT>try:<EOL><INDENT>final_items = self.instance._cluster_related_objects[relation_name]<EOL><DEDENT>except (AttributeError, KeyError):<EOL><INDENT>return<EOL><DEDENT>original_manager = original_manager_cls(self.instance)<EOL>live_items = list(original_manager.get_queryset())<EOL>for item in live_items:<EOL><INDENT>if item not in final_items:<EOL><INDENT>item.delete()<EOL><DEDENT><DEDENT>for item in final_items:<EOL><INDENT>original_manager.add(item, bulk=False)<EOL><DEDENT>del self.instance._cluster_related_objects[relation_name]<EOL><DEDENT><DEDENT>return DeferringRelatedManager<EOL>", "docstring": "Create a DeferringRelatedManager class that wraps an ordinary RelatedManager\nwith 'deferring' behaviour: any updates to the object set (via e.g. add() or clear())\nare written to a holding area rather than committed to the database immediately.\nWriting to the database is deferred until the model is saved.", "id": "f11992:m0"}
{"signature": "def get_all_child_m2m_relations(model):", "body": "return [<EOL>field for field in model._meta.get_fields()<EOL>if isinstance(field, ParentalManyToManyField)<EOL>]<EOL>", "docstring": "Return a list of ParentalManyToManyFields on the given model,\nincluding ones attached to ancestors of the model", "id": "f11995:m4"}
{"signature": "def get_all_child_relations(model):", "body": "return [<EOL>field for field in model._meta.get_fields()<EOL>if isinstance(field.remote_field, ParentalKey)<EOL>]<EOL>", "docstring": "Return a list of RelatedObject records for child relations of the given model,\nincluding ones attached to ancestors of the model", "id": "f11995:m3"}
{"signature": "@classmethod<EOL><INDENT>def from_serializable_data(cls, data, check_fks=True, strict_fks=False):<DEDENT>", "body": "obj = model_from_serializable_data(cls, data, check_fks=check_fks, strict_fks=strict_fks)<EOL>if obj is None:<EOL><INDENT>return None<EOL><DEDENT>child_relations = get_all_child_relations(cls)<EOL>for rel in child_relations:<EOL><INDENT>rel_name = rel.get_accessor_name()<EOL>try:<EOL><INDENT>child_data_list = data[rel_name]<EOL><DEDENT>except KeyError:<EOL><INDENT>continue<EOL><DEDENT>related_model = rel.related_model<EOL>if hasattr(related_model, '<STR_LIT>'):<EOL><INDENT>children = [<EOL>related_model.from_serializable_data(child_data, check_fks=check_fks, strict_fks=True)<EOL>for child_data in child_data_list<EOL>]<EOL><DEDENT>else:<EOL><INDENT>children = [<EOL>model_from_serializable_data(related_model, child_data, check_fks=check_fks, strict_fks=True)<EOL>for child_data in child_data_list<EOL>]<EOL><DEDENT>children = filter(lambda child: child is not None, children)<EOL>setattr(obj, rel_name, children)<EOL><DEDENT>return obj<EOL>", "docstring": "Build an instance of this model from the JSON-like structure passed in,\nrecursing into related objects as required.\nIf check_fks is true, it will check whether referenced foreign keys still\nexist in the database.\n- dangling foreign keys on related objects are dealt with by either nullifying the key or\ndropping the related object, according to the 'on_delete' setting.\n- dangling foreign keys on the base object will be nullified, unless strict_fks is true,\nin which case any dangling foreign keys with on_delete=CASCADE will cause None to be\nreturned for the entire object.", "id": "f11995:c0:m4"}
{"signature": "def save(self, **kwargs):", "body": "child_relation_names = [rel.get_accessor_name() for rel in get_all_child_relations(self)]<EOL>child_m2m_field_names = [field.name for field in get_all_child_m2m_relations(self)]<EOL>update_fields = kwargs.pop('<STR_LIT>', None)<EOL>if update_fields is None:<EOL><INDENT>real_update_fields = None<EOL>relations_to_commit = child_relation_names<EOL>m2m_fields_to_commit = child_m2m_field_names<EOL><DEDENT>else:<EOL><INDENT>real_update_fields = []<EOL>relations_to_commit = []<EOL>m2m_fields_to_commit = []<EOL>for field in update_fields:<EOL><INDENT>if field in child_relation_names:<EOL><INDENT>relations_to_commit.append(field)<EOL><DEDENT>elif field in child_m2m_field_names:<EOL><INDENT>m2m_fields_to_commit.append(field)<EOL><DEDENT>else:<EOL><INDENT>real_update_fields.append(field)<EOL><DEDENT><DEDENT><DEDENT>super(ClusterableModel, self).save(update_fields=real_update_fields, **kwargs)<EOL>for relation in relations_to_commit:<EOL><INDENT>getattr(self, relation).commit()<EOL><DEDENT>for field in m2m_fields_to_commit:<EOL><INDENT>getattr(self, field).commit()<EOL><DEDENT>", "docstring": "Save the model and commit all child relations.", "id": "f11995:c0:m1"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "child_relation_names = (<EOL>[rel.get_accessor_name() for rel in get_all_child_relations(self)] +<EOL>[field.name for field in get_all_child_m2m_relations(self)]<EOL>)<EOL>if any(name in kwargs for name in child_relation_names):<EOL><INDENT>kwargs_for_super = kwargs.copy()<EOL>relation_assignments = {}<EOL>for rel_name in child_relation_names:<EOL><INDENT>if rel_name in kwargs:<EOL><INDENT>relation_assignments[rel_name] = kwargs_for_super.pop(rel_name)<EOL><DEDENT><DEDENT>super(ClusterableModel, self).__init__(*args, **kwargs_for_super)<EOL>for (field_name, related_instances) in relation_assignments.items():<EOL><INDENT>setattr(self, field_name, related_instances)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>super(ClusterableModel, self).__init__(*args, **kwargs)<EOL><DEDENT>", "docstring": "Extend the standard model constructor to allow child object lists to be passed in\nvia kwargs", "id": "f11995:c0:m0"}
{"signature": "def __call__(self, asset):", "body": "raise NotImplementedError<EOL>", "docstring": "Subclasses have to override this method to implement the actual\n        handler function code. This method is called with asset as argument.\n        Depending on the type of the handler, this method must change asset\n        state (as it does in :class:`~gears.processors.Directivesprocessor`)\n        or return some value (in case of asset compressors).", "id": "f12021:c1:m0"}
{"signature": "@property<EOL><INDENT>def preprocessors(self):<DEDENT>", "body": "return self.environment.preprocessors.get(self.mimetype)<EOL>", "docstring": "The list of preprocessors used to build asset.", "id": "f12022:c0:m10"}
{"signature": "@property<EOL><INDENT>def postprocessors(self):<DEDENT>", "body": "return self.environment.postprocessors.get(self.mimetype)<EOL>", "docstring": "The list of postprocessors used to build asset.", "id": "f12022:c0:m11"}
{"signature": "@property<EOL><INDENT>def processors(self):<DEDENT>", "body": "return self.preprocessors + list(reversed(self.compilers)) + self.postprocessors<EOL>", "docstring": "The list of all processors (preprocessors, compilers,\n        postprocessors) used to build asset.", "id": "f12022:c0:m12"}
{"signature": "@cached_property<EOL><INDENT>def search_paths(self):<DEDENT>", "body": "paths = [self.path]<EOL>if os.path.basename(self.path_without_suffix) != '<STR_LIT:index>':<EOL><INDENT>path = os.path.join(self.path_without_suffix, '<STR_LIT:index>')<EOL>paths.append(path + '<STR_LIT>'.join(self.suffix))<EOL><DEDENT>return paths<EOL>", "docstring": "The list of logical paths which are used to search for an asset.\n        This property makes sense only if the attributes was created with\n        logical path.\n\n        It is assumed that the logical path can be a directory containing a\n        file named ``index`` with the same suffix.\n\n        Example::\n\n            >>> attrs = AssetAttributes(environment, 'js/app.js')\n            >>> attrs.search_paths\n            ['js/app.js', 'js/app/index.js']\n\n            >>> attrs = AssetAttributes(environment, 'js/app/index.js')\n            >>> attrs.search_paths\n            ['js/models/index.js']", "id": "f12022:c0:m1"}
{"signature": "@cached_property<EOL><INDENT>def path_without_suffix(self):<DEDENT>", "body": "if self.suffix:<EOL><INDENT>return self.path[:-len('<STR_LIT>'.join(self.suffix))]<EOL><DEDENT>return self.path<EOL>", "docstring": "The relative path to asset without suffix.\n        Example::\n\n            >>> attrs = AssetAttributes(environment, 'js/app.js')\n            >>> attrs.path_without_suffix\n            'js/app'", "id": "f12022:c0:m2"}
{"signature": "def find(self, item, logical=False):", "body": "if isinstance(item, AssetAttributes):<EOL><INDENT>for path in item.search_paths:<EOL><INDENT>try:<EOL><INDENT>return self.find(path, logical)<EOL><DEDENT>except FileNotFound:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>raise FileNotFound(item.path)<EOL><DEDENT>if logical:<EOL><INDENT>asset_attributes = AssetAttributes(self, item)<EOL>suffixes = self.suffixes.find(asset_attributes.mimetype)<EOL>if not suffixes:<EOL><INDENT>return self.find(item)<EOL><DEDENT>path = asset_attributes.path_without_suffix<EOL>for suffix in suffixes:<EOL><INDENT>try:<EOL><INDENT>return self.find(path + suffix)<EOL><DEDENT>except FileNotFound:<EOL><INDENT>continue<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for finder in self.finders:<EOL><INDENT>try:<EOL><INDENT>absolute_path = finder.find(item)<EOL><DEDENT>except FileNotFound:<EOL><INDENT>continue<EOL><DEDENT>return AssetAttributes(self, item), absolute_path<EOL><DEDENT><DEDENT>raise FileNotFound(item)<EOL>", "docstring": "Find files using :attr:`finders` registry. The ``item`` parameter\n        can be an instance of :class:`~gears.asset_attributes.AssetAttributes`\n        class, a path to the asset or a logical path to the asset. If ``item``\n        is a logical path, `logical` parameter must be set to ``True``.\n\n        Returns a tuple with :class:`~gears.asset_attributes.AssetAttributes`\n        instance for found file path as first item, and absolute path to this\n        file as second item.\n\n        If nothing is found, :class:`gears.exceptions.FileNotFound` exception\n        is rased.", "id": "f12028:c8:m5"}
{"signature": "def unregister(self, finder):", "body": "if finder in self:<EOL><INDENT>self.remove(finder)<EOL><DEDENT>", "docstring": "Remove passed ``finder`` from the list of finders. If ``finder``\n        does not found in the registry, nothing happens.", "id": "f12028:c0:m1"}
{"signature": "@property<EOL><INDENT>def paths(self):<DEDENT>", "body": "if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>paths = []<EOL>for finder in self.finders:<EOL><INDENT>if hasattr(finder, '<STR_LIT>'):<EOL><INDENT>paths.extend(finder.paths)<EOL><DEDENT><DEDENT>self._paths = paths<EOL><DEDENT>return self._paths<EOL>", "docstring": "The list of search paths. It is built from registered finders, which\n        has ``paths`` property. Can be useful for compilers to resolve internal\n        dependencies.", "id": "f12028:c8:m2"}
{"signature": "def register_defaults(self):", "body": "self.register('<STR_LIT>', '<STR_LIT>')<EOL>self.register('<STR_LIT>', '<STR_LIT>')<EOL>", "docstring": "Register MIME types for ``.js`` and ``.css`` extensions.", "id": "f12028:c1:m0"}
{"signature": "@singledispatch<EOL>def fmap(functor, func):<EOL>", "body": "return functor.map(func)<EOL>", "docstring": "Applies a function to the data 'inside' a functor.\n\n    Uses functools.singledispatch so you can write your own functors\n    for use with the library.", "id": "f12052:m9"}
{"signature": "@singledispatch<EOL>def contains_remove(self, item):<EOL>", "body": "try:<EOL><INDENT>self._lens_contains_remove<EOL><DEDENT>except AttributeError:<EOL><INDENT>message = '<STR_LIT>'<EOL>raise NotImplementedError(message.format(type(self)))<EOL><DEDENT>else:<EOL><INDENT>return self._lens_contains_remove(item)<EOL><DEDENT>", "docstring": "Takes a collection and an item and returns a new collection\n    of the same type with that item removed. The notion of \"contains\"\n    is defined by the object itself; the following must be ``True``:\n\n    .. code-block:: python\n\n        item not in contains_remove(obj, item)\n\n    This function is used by some lenses (particularly ContainsLens)\n    to remove items from containers when necessary.\n\n    The corresponding method call for this hook is\n    ``obj._lens_contains_remove(item)``.\n\n    There is no default implementation.", "id": "f12056:m9"}
{"signature": "def maybe(self, guard=None):<EOL>", "body": "return self.item<EOL>", "docstring": "Unwraps the value, returning it is there is one, else\n        returning the guard.", "id": "f12057:c0:m6"}
{"signature": "def Error(self, exception, message=None):<EOL>", "body": "return self._compose_optic(optics.ErrorIso(exception, message))<EOL>", "docstring": "An optic that raises an exception whenever it tries to focus\n        something. If `message is None` then the exception will be\n        raised unmodified. If `message is not None` then when the lens\n        is asked to focus something it will run `message.format(state)`\n        and the exception will be called with the resulting formatted\n        message as it's only argument. Useful for debugging.\n\n            >>> from lenses import lens\n            >>> lens.Error(Exception())\n            UnboundLens(ErrorIso(Exception()))\n            >>> lens.Error(Exception, '{}')\n            UnboundLens(ErrorIso(<...Exception...>, '{}'))\n            >>> lens.Error(Exception).get()(True)\n            Traceback (most recent call last):\n              File \"<stdin>\", line 1, in ?\n            Exception\n            >>> lens.Error(Exception('An error occurred')).set(False)(True)\n            Traceback (most recent call last):\n              File \"<stdin>\", line 1, in ?\n            Exception: An error occurred\n            >>> lens.Error(ValueError, 'applied to {}').get()(True)\n            Traceback (most recent call last):\n              File \"<stdin>\", line 1, in ?\n            ValueError: applied to True", "id": "f12060:c0:m6"}
{"signature": "def GetItem(self, key):<EOL>", "body": "return self._compose_optic(optics.GetitemLens(key))<EOL>", "docstring": "A lens that focuses an item inside a container. Analogous to\n        `operator.itemgetter`.\n\n            >>> from lenses import lens\n            >>> lens[0]\n            UnboundLens(GetitemLens(0))\n            >>> lens.GetItem(0)\n            UnboundLens(GetitemLens(0))\n            >>> lens[0].get()([1, 2, 3])\n            1\n            >>> lens['hello'].get()({'hello': 'world'})\n            'world'\n            >>> lens[0].set(4)([1, 2, 3])\n            [4, 2, 3]\n            >>> lens['hello'].set('universe')({'hello': 'world'})\n            {'hello': 'universe'}", "id": "f12060:c0:m13"}
{"signature": "def Item(self, key):<EOL>", "body": "return self._compose_optic(optics.ItemLens(key))<EOL>", "docstring": "A lens that focuses a single item (key-value pair) in a\n        dictionary by its key. Set an item to `None` to remove it from\n        the dictionary.\n\n            >>> from lenses import lens\n            >>> from collections import OrderedDict\n            >>> data = OrderedDict([(1, 10), (2, 20)])\n            >>> lens.Item(1)\n            UnboundLens(ItemLens(1))\n            >>> lens.Item(1).get()(data)\n            (1, 10)\n            >>> lens.Item(3).get()(data) is None\n            True\n            >>> lens.Item(1).set((1, 11))(data)\n            OrderedDict([(1, 11), (2, 20)])\n            >>> lens.Item(1).set(None)(data)\n            OrderedDict([(2, 20)])", "id": "f12060:c0:m18"}
{"signature": "def call(self, method_name, *args, **kwargs):<EOL>", "body": "caller = operator.methodcaller(method_name, *args, **kwargs)<EOL>return self.modify(caller)<EOL>", "docstring": "Call a method on the focus. The method must return a new\n        value for the focus.\n\n            >>> from lenses import lens\n            >>> lens[2].call('upper')(['alpha', 'beta', 'gamma'])\n            ['alpha', 'beta', 'GAMMA']\n\n        As a shortcut, you can include the name of the method you want\n        to call immediately after `call_`:\n\n            >>> lens[2].call_upper()(['alpha', 'beta', 'gamma'])\n            ['alpha', 'beta', 'GAMMA']", "id": "f12060:c0:m0"}
{"signature": "def call_mut(self, method_name, *args, **kwargs):<EOL>", "body": "shallow = False<EOL>if '<STR_LIT>' in kwargs:<EOL><INDENT>shallow = kwargs['<STR_LIT>']<EOL>del kwargs['<STR_LIT>']<EOL><DEDENT>def func(a):<EOL><INDENT>a = copy.copy(a) if shallow else copy.deepcopy(a)<EOL>getattr(a, method_name)(*args, **kwargs)<EOL>return cast(B, a)<EOL><DEDENT>return self.modify(func)<EOL>", "docstring": "Call a method on the focus that will mutate it in place.\n        Works by making a deep copy of the focus before calling the\n        mutating method on it. The return value of that method is ignored.\n        You can pass a keyword argument shallow=True to only make a\n        shallow copy.\n\n            >>> from lenses import lens\n            >>> lens[0].call_mut('sort')([[3, 1, 2], [5, 4]])\n            [[1, 2, 3], [5, 4]]\n\n        As a shortcut, you can include the name of the method you want\n        to call immediately after `call_mut_`:\n\n            >>> lens[0].call_mut_sort()([[3, 1, 2], [5, 4]])\n            [[1, 2, 3], [5, 4]]", "id": "f12060:c0:m1"}
{"signature": "def Just(self):<EOL>", "body": "return self._compose_optic(optics.JustPrism())<EOL>", "docstring": "A prism that focuses the value inside a `lenses.maybe.Just`\n        object.\n\n            >>> from lenses import lens\n            >>> from lenses.maybe import Just, Nothing\n            >>> lens.Just()\n            UnboundLens(JustPrism())\n            >>> lens.Just().collect()(Just(1))\n            [1]\n            >>> lens.Just().collect()(Nothing())\n            []\n            >>> lens.Just().set(2)(Just(1))\n            Just(2)\n            >>> lens.Just().set(2)(Nothing())\n            Nothing()", "id": "f12060:c0:m23"}
{"signature": "def Norm(self, setter):<EOL>", "body": "return self._compose_optic(optics.NormalisingIso(setter))<EOL>", "docstring": "An isomorphism that applies a function as it sets a new\n        focus without regard to the old state. It will get foci without\n        transformation. This lens allows you to pre-process values before\n        you set them, but still get values as they exist in the state.\n        Useful for type conversions or normalising data.\n\n        For best results, your normalisation function should be\n        idempotent.  That is, applying the function twice should have\n        no effect::\n\n            setter(setter(value)) == setter(value)\n\n        Equivalent to `Isomorphism((lambda s: s), setter)`.\n\n            >>> from lenses import lens\n            >>> def real_only(num):\n            ...     return num.real\n            ...\n            >>> lens.Norm(real_only)\n            UnboundLens(NormalisingIso(<function real_only at ...>))\n            >>> lens[0].Norm(real_only).get()([1.0, 2.0, 3.0])\n            1.0\n            >>> lens[0].Norm(real_only).set(4+7j)([1.0, 2.0, 3.0])\n            [4.0, 2.0, 3.0]\n\n        Types with constructors that do conversion are often good targets\n        for this lens:\n\n            >>> lens[0].Norm(int).set(4.0)([1, 2, 3])\n            [4, 2, 3]\n            >>> lens[1].Norm(int).set('5')([1, 2, 3])\n            [1, 5, 3]", "id": "f12060:c0:m25"}
{"signature": "def Filter(self, predicate):<EOL>", "body": "return self._compose_optic(optics.FilteringPrism(predicate))<EOL>", "docstring": "A prism that only focuses a value if the predicate returns\n        `True` when called with that value as an argument. Best used\n        when composed after a traversal. It only prevents the traversal\n        from visiting foci, it does not filter out values the way that\n        python's regular `filter` function does.\n\n            >>> from lenses import lens\n            >>> lens.Filter(all)\n            UnboundLens(FilteringPrism(<built-in function all>))\n            >>> data = [[1, 2], [0], ['a'], ['', 'b']]\n            >>> lens.Each().Filter(all).collect()(data)\n            [[1, 2], ['a']]\n            >>> lens.Each().Filter(all).set(2)(data)\n            [2, [0], 2, ['', 'b']]\n\n        The filtering is done to foci before the lens' manipulation is\n        applied. This means that the resulting foci can still violate\n        the predicate if the manipulating function doesn't respect it:\n\n            >>> lens.Each().Filter(bool).set(None)(['', 2, ''])\n            ['', None, '']", "id": "f12060:c0:m8"}
{"signature": "def Values(self):<EOL>", "body": "return self._compose_optic(<EOL>optics.ItemsTraversal() & optics.GetitemLens(<NUM_LIT:1>)<EOL>)<EOL>", "docstring": "A traversal focusing the values of a dictionary. Analogous to\n        `dict.values`.\n\n            >>> from lenses import lens\n            >>> from collections import OrderedDict\n            >>> data = OrderedDict([(1, 10), (2, 20)])\n            >>> lens.Values()\n            UnboundLens(ItemsTraversal() & GetitemLens(1))\n            >>> lens.Values().collect()(data)\n            [10, 20]\n            >>> lens.Values().modify(lambda n: n + 1)(data)\n            OrderedDict([(1, 11), (2, 21)])", "id": "f12060:c0:m30"}
{"signature": "def ItemByValue(self, value):<EOL>", "body": "return self._compose_optic(optics.ItemByValueLens(value))<EOL>", "docstring": "A lens that focuses a single item (key-value pair) in a\n        dictionary by its value. Set an item to `None` to remove it\n        from the dictionary. This lens assumes that there will only be\n        a single key with that particular value. If you violate that\n        assumption then you're on your own.\n\n            >>> from lenses import lens\n            >>> from collections import OrderedDict\n            >>> data = OrderedDict([(1, 10), (2, 20)])\n            >>> lens.ItemByValue(10)\n            UnboundLens(ItemByValueLens(10))\n            >>> lens.ItemByValue(10).get()(data)\n            (1, 10)\n            >>> lens.ItemByValue(30).get()(data) is None\n            True\n            >>> lens.ItemByValue(10).set((3, 10))(data)\n            OrderedDict([(2, 20), (3, 10)])\n            >>> lens.ItemByValue(10).set(None)(data)\n            OrderedDict([(2, 20)])", "id": "f12060:c0:m19"}
{"signature": "def Lens(self, getter, setter):<EOL>", "body": "return self._compose_optic(optics.Lens(getter, setter))<EOL>", "docstring": "An optic that wraps a pair of getter and setter functions. A\n        getter function is one that takes a state and returns a value\n        derived from that state. A setter function takes an old state\n        and a new value and uses them to construct a new state.\n\n            >>> from lenses import lens\n            >>> def getter(state):\n            ...     'Get the average of a list'\n            ...     return sum(state) // len(state)\n            ...\n            >>> def setter(old_state, value):\n            ...     'Set the average of a list by changing the final value'\n            ...     target_sum = value * len(old_state)\n            ...     prefix = old_state[:-1]\n            ...     return prefix + [target_sum - sum(prefix)]\n            ...\n            >>> average_lens = lens.Lens(getter, setter)\n            >>> average_lens\n            UnboundLens(Lens(<function getter...>, <function setter...>))\n            >>> average_lens.get()([1, 2, 4, 5])\n            3\n            >>> average_lens.set(4)([1, 2, 3])\n            [1, 2, 9]\n            >>> (average_lens - 1)([1, 2, 3])\n            [1, 2, 0]", "id": "f12060:c0:m14"}
{"signature": "def F(self, getter):<EOL>", "body": "return self._compose_optic(optics.Getter(getter))<EOL>", "docstring": "An optic that wraps a getter function. A getter function is\n        one that takes a state and returns a value derived from that\n        state. The function is called on the focus before it is returned.\n\n            >>> from lenses import lens\n            >>> lens.F(abs)\n            UnboundLens(Getter(<built-in function abs>))\n            >>> lens.F(abs).get()(-1)\n            1\n            >>> lens.Each().F(abs).collect()([-1, 2, -3])\n            [1, 2, 3]\n\n        This optic cannot be used to set or modify values.", "id": "f12060:c0:m7"}
{"signature": "def modify(self, func):<EOL>", "body": "def modifier(state):<EOL><INDENT>return self._optic.over(state, func)<EOL><DEDENT>return modifier<EOL>", "docstring": "Apply a function to the focus.\n\n            >>> from lenses import lens\n            >>> convert_item_one_to_string = lens[1].modify(str)\n            >>> convert_item_one_to_string([1, 2, 3])\n            [1, '2', 3]\n            >>> add_ten_to_item_one = lens[1].modify(lambda n: n + 10)\n            >>> add_ten_to_item_one([1, 2, 3])\n            [1, 12, 3]", "id": "f12061:c0:m7"}
{"signature": "def collect(self):<EOL>", "body": "def getter(state):<EOL><INDENT>return self._optic.to_list_of(state)<EOL><DEDENT>return getter<EOL>", "docstring": "Get multiple values focused by the lens. Returns them as\n        a list.\n\n            >>> from lenses import lens\n            >>> collect_each_first = lens.Each()[0].collect()\n            >>> collect_each_first([(1, 2), (3, 4), (5, 6)])\n            [1, 3, 5]", "id": "f12061:c0:m3"}
{"signature": "def get(self):<EOL>", "body": "return self._optic.to_list_of(self._state)[<NUM_LIT:0>]<EOL>", "docstring": "Get the first value focused by the lens.\n\n            >>> from lenses import bind\n            >>> bind([1, 2, 3]).get()\n            [1, 2, 3]\n            >>> bind([1, 2, 3])[0].get()\n            1", "id": "f12061:c1:m2"}
{"signature": "def set(self, newvalue):<EOL>", "body": "def setter(state):<EOL><INDENT>return self._optic.set(state, newvalue)<EOL><DEDENT>return setter<EOL>", "docstring": "Set the focus to `newvalue`.\n\n            >>> from lenses import lens\n            >>> set_item_one_to_four = lens[1].set(4)\n            >>> set_item_one_to_four([1, 2, 3])\n            [1, 4, 3]", "id": "f12061:c0:m5"}
{"signature": "def kind(self):<EOL>", "body": "return self._optic.kind().__name__<EOL>", "docstring": "Returns the \"kind\" of the lens.", "id": "f12061:c0:m13"}
{"signature": "def kind(self):", "body": "optics = [<EOL>Equality,<EOL>Isomorphism,<EOL>Prism,<EOL>Review,<EOL>Lens,<EOL>Traversal,<EOL>Getter,<EOL>Setter,<EOL>Fold,<EOL>]<EOL>for optic in optics:<EOL><INDENT>if self._is_kind(optic):<EOL><INDENT>return optic<EOL><DEDENT><DEDENT>", "docstring": "Returns a class representing the 'kind' of optic.", "id": "f12063:c0:m10"}
{"signature": "def has(self, state):", "body": "return not self.unpack(state).is_nothing()<EOL>", "docstring": "Returns `True` when the state would be successfully focused\n        by this prism, otherwise `False`.\n\n            >>> from lenses.maybe import Nothing, Just\n            >>> def pack(focus):\n            ...     return focus\n            >>> def unpack(state):\n            ...     if state > 0:\n            ...         return Just(state)\n            ...     return Nothing()\n            >>> positive = Prism(unpack, pack)\n            >>> positive.has(-1)\n            False\n            >>> positive.has(1)\n            True", "id": "f12063:c7:m3"}
{"signature": "def set(self, state, value):<EOL>", "body": "if not self._is_kind(Setter):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>pure = lambda a: Identity(a)<EOL>func = lambda a: Identity(value)<EOL>return self.apply(func, pure, state).unwrap()<EOL>", "docstring": "Sets all the foci within `state` to `value`.\n\n        Requires kind Setter. This method will raise TypeError when the\n        optic has no way to set foci.", "id": "f12063:c0:m6"}
{"signature": "def to_list_of(self, state):<EOL>", "body": "if not self._is_kind(Fold):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>pure = lambda a: Const([])<EOL>func = lambda a: Const([a])<EOL>return self.apply(func, pure, state).unwrap()<EOL>", "docstring": "Returns a list of all the foci within `state`.\n\n        Requires kind Fold. This method will raise TypeError if the\n        optic has no way to get any foci.", "id": "f12063:c0:m4"}
{"signature": "def apply(self, f, pure, state):", "body": "return self.func(Functorisor(pure, f), state)<EOL>", "docstring": "Runs the lens over the `state` applying `f` to all the foci\n        collecting the results together using the applicative functor\n        functions defined in `lenses.typeclass`. `f` must return an\n        applicative functor. For the case when no focus exists you must\n        also provide a `pure` which should take a focus and return the\n        pure form of the functor returned by `f`.", "id": "f12063:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def random(cls):<DEDENT>", "body": "return cls((randint(<NUM_LIT:0>, MAXX), randint(<NUM_LIT:0>, MAXY)))<EOL>", "docstring": "produces a random vector inside the play area.", "id": "f12073:c0:m0"}
{"signature": "def main():", "body": "state = GameState()<EOL>print(state)<EOL>while state.running:<EOL><INDENT>input = get_single_char()<EOL>state, should_advance = state.handle_input(input)<EOL>if should_advance:<EOL><INDENT>state = state.advance_robots()<EOL>state = state.check_game_end()<EOL><DEDENT>print(state)<EOL><DEDENT>print(state.message)<EOL>", "docstring": "The main function. Instantiates a GameState object and then\n    enters a REPL-like main loop, waiting for input, updating the state\n    based on the input, then outputting the new state.", "id": "f12073:m2"}
{"signature": "def check_game_end(self):", "body": "if self.player in self.crashes.union(self.robots):<EOL><INDENT>return self.end_game('<STR_LIT>')<EOL><DEDENT>elif not self.robots:<EOL><INDENT>return self.end_game('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>return self<EOL><DEDENT>", "docstring": "Checks for the game's win/lose conditions and 'alters' the\n        game state to reflect the condition found. If the game has not\n        been won or lost then it just returns the game state\n        unaltered.", "id": "f12073:c1:m3"}
{"signature": "@property<EOL><INDENT>def player(self):<DEDENT>", "body": "return '<STR_LIT:X>' if self._count('<STR_LIT:X>') <= self._count('<STR_LIT:O>') else '<STR_LIT:O>'<EOL>", "docstring": "The player whose turn it currently is.", "id": "f12074:c1:m2"}
{"signature": "def make_move(self, x, y):", "body": "if self.board[y][x] == '<STR_LIT:U+0020>':<EOL><INDENT>return lens.board[y][x].set(self.player)(self)<EOL><DEDENT>return self<EOL>", "docstring": "Return a board with a cell filled in by the current player. If\n        the cell is already occupied then return the board unchanged.", "id": "f12074:c1:m1"}
{"signature": "def __init__(self, ptype='<STR_LIT>', legislature=None):", "body": "assert(ptype in ['<STR_LIT>', '<STR_LIT>'])<EOL>assert(legislature in ['<STR_LIT>', '<STR_LIT>', None])<EOL>self.legislature = legislature<EOL>self.ptype = ptype<EOL>self.ptype_plural = ptype + '<STR_LIT:s>'<EOL>self.base_url = '<STR_LIT>' % (legislature or '<STR_LIT>', self.ptype_plural)<EOL>", "docstring": "type: depute or senateur\nlegislature: 2007-2012 or None", "id": "f12079:c0:m0"}
{"signature": "def SayHello(self, request, context):", "body": "context.set_code(grpc.StatusCode.UNIMPLEMENTED)<EOL>context.set_details('<STR_LIT>')<EOL>raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Sends a greeting", "id": "f12092:c1:m0"}
{"signature": "def s(self, condition):", "body": "warnings.warn(\"<STR_LIT>\", DeprecationWarning)<EOL>return self.element_by(condition)<EOL>", "docstring": "Deprecated. Use element_by instead", "id": "f12202:c10:m28"}
{"signature": "def export_obj(filename, cutout, level=<NUM_LIT:0>):", "body": "if \"<STR_LIT>\" not in filename:<EOL><INDENT>filename = filename + \"<STR_LIT>\"<EOL><DEDENT>vs, fs = mcubes.marching_cubes(cutout, level)<EOL>mcubes.export_obj(vs, fs, filename)<EOL>", "docstring": "Converts a dense annotation to a obj, using Marching Cubes (PyMCubes).\n\nArguments:\n    filename (str): The filename to write out to\n    cutout (numpy.ndarray): The dense annotation\n    level (int): The level at which to run mcubes\n\nReturns:\n    boolean success", "id": "f12223:m1"}
{"signature": "def export_ply(filename, cutout, level=<NUM_LIT:0>):", "body": "if \"<STR_LIT>\" not in filename:<EOL><INDENT>filename = filename + \"<STR_LIT>\"<EOL><DEDENT>vs, fs = mcubes.marching_cubes(cutout, level)<EOL>with open(filename, '<STR_LIT:w>') as fh:<EOL><INDENT>lines = [<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\" + str(len(vs)),<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\" + str(len(fs)),<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\"<EOL>]<EOL>fh.writelines(lines)<EOL>for v in vs:<EOL><INDENT>fh.write(\"<STR_LIT>\".format(v[<NUM_LIT:0>], v[<NUM_LIT:1>], v[<NUM_LIT:2>]))<EOL><DEDENT>for f in fs:<EOL><INDENT>fh.write(\"<STR_LIT>\".format(f[<NUM_LIT:0>], f[<NUM_LIT:1>], f[<NUM_LIT:2>]))<EOL><DEDENT><DEDENT>", "docstring": "Converts a dense annotation to a .PLY, using Marching Cubes (PyMCubes).\n\nArguments:\n    filename (str): The filename to write out to\n    cutout (numpy.ndarray): The dense annotation\n    level (int): The level at which to run mcubes\n\nReturns:\n    boolean success", "id": "f12223:m2"}
{"signature": "def add_project(self, project_name, token_name=None, public=None):", "body": "self.project = (project_name.strip().replace(\"<STR_LIT:U+0020>\", \"<STR_LIT>\"),<EOL>token_name.strip().replace(\"<STR_LIT:U+0020>\", \"<STR_LIT>\"), public)<EOL>", "docstring": "Arguments:\n    project_name (str): Project name is the specific project within\n        a dataset's name. If there is only one project associated\n        with a dataset then standard convention is to name the\n        project the same as its associated dataset.\n    token_name (str): The token name is the default token. If you\n        do not wish to specify one, a default one will be created for\n        you with the same name as the project name. However, if the\n        project is private you must specify a token.\n    public (int): This option allows users to specify if they want\n        the project/channels to be publicly viewable/search-able.\n        (1, 0) = (TRUE, FALSE)\n\nReturns:\n    None", "id": "f12226:c0:m2"}
{"signature": "def nd_json_list(self, dataset, project, channel_list, metadata):", "body": "nd_dict = {}<EOL>nd_dict['<STR_LIT>'] = self.dataset_dict(*dataset)<EOL>nd_dict['<STR_LIT>'] = self.project_dict(*project)<EOL>nd_dict['<STR_LIT>'] = metadata<EOL>nd_dict['<STR_LIT>'] = {}<EOL>for channel_name, value in channel_list.items():<EOL><INDENT>nd_dict['<STR_LIT>'].append(self.channel_dict(*value))<EOL><DEDENT>return json.dumps(nd_dict, sort_keys=True, indent=<NUM_LIT:4>)<EOL>", "docstring": "Genarate ND json object.", "id": "f12226:c0:m6"}
{"signature": "def add_dataset(self, dataset_name, imagesize, voxelres, offset=None,<EOL>timerange=None, scalinglevels=None, scaling=None):", "body": "self.dataset = (dataset_name.strip().replace(\"<STR_LIT:U+0020>\", \"<STR_LIT>\"), imagesize,<EOL>voxelres, offset, timerange, scalinglevels, scaling)<EOL>", "docstring": "Add a new dataset to the ingest.\n\nArguments:\n    dataset_name (str): Dataset Name is the overarching name of the\n        research effort. Standard naming convention is to do\n        LabNamePublicationYear or LeadResearcherCurrentYear.\n    imagesize (int, int, int): Image size is the pixel count\n        dimensions of the data. For example is the data is stored\n        as a series of 100 slices each 2100x2000 pixel TIFF images,\n        the X,Y,Z dimensions are (2100, 2000, 100).\n    voxelres (float, float, float): Voxel Resolution is the number\n        of voxels per unit pixel. We store X,Y,Z voxel resolution\n        separately.\n    offset (int, int, int): If your data is not well aligned and\n        there is \"excess\" image data you do not wish to examine, but\n        are present in your images, offset is how you specify where\n        your actual image starts. Offset is provided a pixel\n        coordinate offset from origin which specifies the \"actual\"\n        origin of the image. The offset is for X,Y,Z dimensions.\n    timerange (int, int): Time Range is a parameter to support\n        storage of Time Series data, so the value of the tuple is a\n        0 to X range of how many images over time were taken. It\n        takes 2 inputs timeStepStart and timeStepStop.\n    scalinglevels (int): Scaling levels is the number of levels the\n        data is scalable to (how many zoom levels are present in the\n        data). The highest resolution of the data is at scaling level\n        0, and for each level up the data is down sampled by 2x2\n        (per slice). To learn more about the sampling service used,\n        visit the the propagation service page.\n    scaling (int): Scaling is the scaling method of the data being\n        stored. 0 corresponds to a Z-slice orientation (as in a\n        collection of tiff images in which each tiff is a slice on\n        the z plane) where data will be scaled only on the xy plane,\n        not the z plane. 1 corresponds to an isotropic orientation\n        (in which each tiff is a slice on the y plane) where data\n        is scaled along all axis.\n\nReturns:\n    None", "id": "f12226:c0:m3"}
{"signature": "def identify_imagesize(self, image_type, image_path='<STR_LIT>'):", "body": "dims = ()<EOL>try:<EOL><INDENT>if (image_type.lower() == '<STR_LIT>'):<EOL><INDENT>dims = np.shape(ndpng.load('<STR_LIT>'.format(<EOL>image_path, image_type<EOL>)))<EOL><DEDENT>elif (image_type.lower() == '<STR_LIT>' or image_type.lower() == '<STR_LIT>'):<EOL><INDENT>dims = np.shape(ndtiff.load('<STR_LIT>'.format(<EOL>image_path, image_type<EOL>)))<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>except:<EOL><INDENT>raise OSError('<STR_LIT>'.format(<EOL>image_path,<EOL>image_type<EOL>))<EOL><DEDENT>return dims[::-<NUM_LIT:1>]<EOL>", "docstring": "Identify the image size using the data location and other parameters", "id": "f12226:c0:m10"}
{"signature": "def post_data(self, file_name=None, legacy=False,<EOL>verifytype=VERIFY_BY_SLICE):", "body": "if (file_name is None):<EOL><INDENT>complete_example = (<EOL>self.dataset, self.project, self.channels, self.metadata)<EOL>data = json.loads(self.nd_json(*complete_example))<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>with open(file_name) as data_file:<EOL><INDENT>data = json.load(data_file)<EOL><DEDENT><DEDENT>except:<EOL><INDENT>raise OSError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>self.put_data(data)<EOL>", "docstring": "Arguments:\n    file_name (str): The file name of the json file to post (optional).\n        If this is left unspecified it is assumed the data is in the\n        AutoIngest object.\n    dev (bool): If pushing to a microns dev branch server set this\n        to True, if not leave False.\n    verifytype (enum): Set http verification type, by checking the\n        first slice is accessible or by checking channel folder.\n        NOTE: If verification occurs by folder there is NO image size\n        or type verification. Enum: [Folder, Slice]\n\nReturns:\n    None", "id": "f12226:c0:m13"}
{"signature": "def list_datasets(self, get_global_public):", "body": "return self.resources.list_datasets(get_global_public)<EOL>", "docstring": "Lists datasets in resources. Setting 'get_global_public' to 'True'\nwill retrieve all public datasets in cloud. 'False' will get user's\npublic datasets.\n\nArguments:\n    get_global_public (bool): True if user wants all public datasets in\n                              cloud. False if user wants only their\n                              public datasets.\n\nReturns:\n    dict: Returns datasets in JSON format", "id": "f12227:c0:m18"}
{"signature": "def list_projects(self, dataset_name):", "body": "return self.resources.list_projects(dataset_name)<EOL>", "docstring": "Lists a set of projects related to a dataset.\n\nArguments:\n    dataset_name (str): Dataset name to search projects for\n\nReturns:\n    dict: Projects found based on dataset query", "id": "f12227:c0:m15"}
{"signature": "def delete_token(self,<EOL>token_name,<EOL>project_name,<EOL>dataset_name):", "body": "return self.resources.delete_token(token_name,<EOL>project_name,<EOL>dataset_name)<EOL>", "docstring": "Delete a token with the given parameters.\nArguments:\n    project_name (str): Project name\n    dataset_name (str): Dataset name project is based on\n    token_name (str): Token name\n    channel_name (str): Channel name project is based on\nReturns:\n    bool: True if project deleted, false if not deleted.", "id": "f12227:c0:m13"}
{"signature": "def post_cutout(self, token, channel,<EOL>x_start,<EOL>y_start,<EOL>z_start,<EOL>data,<EOL>resolution=<NUM_LIT:0>):", "body": "return self.data.post_cutout(token, channel,<EOL>x_start,<EOL>y_start,<EOL>z_start,<EOL>data,<EOL>resolution)<EOL>", "docstring": "Post a cutout to the server.\n\nArguments:\n    token (str)\n    channel (str)\n    x_start (int)\n    y_start (int)\n    z_start (int)\n    data (numpy.ndarray): A numpy array of data. Pass in (x, y, z)\n    resolution (int : 0): Resolution at which to insert the data\n\nReturns:\n    bool: True on success\n\nRaises:\n    RemoteDataUploadError: if there's an issue during upload.", "id": "f12227:c0:m7"}
{"signature": "def get_dataset(self, name):", "body": "return self.resources.get_dataset(name)<EOL>", "docstring": "Returns info regarding a particular dataset.\n\nArugments:\n    name (str): Dataset name\n\nReturns:\n    dict: Dataset information", "id": "f12227:c0:m17"}
{"signature": "def url(self, endpoint='<STR_LIT>'):", "body": "if not endpoint.startswith('<STR_LIT:/>'):<EOL><INDENT>endpoint = \"<STR_LIT:/>\" + endpoint<EOL><DEDENT>return self.protocol + \"<STR_LIT>\" + self.hostname + endpoint<EOL>", "docstring": "Get the base URL of the Remote.\n\nArguments:\n    None\nReturns:\n    `str` base URL", "id": "f12228:c0:m1"}
{"signature": "def delete_token(self,<EOL>token_name,<EOL>project_name,<EOL>dataset_name):", "body": "url = self.url() + \"<STR_LIT>\".format(dataset_name)+ \"<STR_LIT>\".format(project_name)+ \"<STR_LIT>\".format(token_name)<EOL>req = self.remote_utils.delete_url(url)<EOL>if req.status_code is not <NUM_LIT>:<EOL><INDENT>raise RemoteDataUploadError(\"<STR_LIT>\".format(req.text))<EOL><DEDENT>if req.content == \"<STR_LIT>\" or req.content == b'<STR_LIT>':<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Delete a token with the given parameters.\nArguments:\n    project_name (str): Project name\n    dataset_name (str): Dataset name project is based on\n    token_name (str): Token name\n    channel_name (str): Channel name project is based on\nReturns:\n    bool: True if project deleted, false if not deleted.", "id": "f12229:c0:m7"}
{"signature": "def list_tokens(self):", "body": "url = self.url() + \"<STR_LIT>\"<EOL>req = self.remote_utils.get_url(url)<EOL>if req.status_code is not <NUM_LIT:200>:<EOL><INDENT>raise RemoteDataNotFoundError('<STR_LIT>'.format(req.text))<EOL><DEDENT>else:<EOL><INDENT>return req.json()<EOL><DEDENT>", "docstring": "Lists a set of tokens that are public in Neurodata.\nArguments:\nReturns:\n    dict: Public tokens found in Neurodata", "id": "f12229:c0:m8"}
{"signature": "def list_projects(self, dataset_name):", "body": "url = self.url() + \"<STR_LIT>\".format(dataset_name)+ \"<STR_LIT>\"<EOL>req = self.remote_utils.get_url(url)<EOL>if req.status_code is not <NUM_LIT:200>:<EOL><INDENT>raise RemoteDataNotFoundError('<STR_LIT>'.format(req.text))<EOL><DEDENT>else:<EOL><INDENT>return req.json()<EOL><DEDENT>", "docstring": "Lists a set of projects related to a dataset.\n\nArguments:\n    dataset_name (str): Dataset name to search projects for\n\nReturns:\n    dict: Projects found based on dataset query", "id": "f12229:c0:m4"}
{"signature": "def create_channel(self,<EOL>channel_name,<EOL>project_name,<EOL>dataset_name,<EOL>channel_type,<EOL>dtype,<EOL>startwindow,<EOL>endwindow,<EOL>readonly=<NUM_LIT:0>,<EOL>start_time=<NUM_LIT:0>,<EOL>end_time=<NUM_LIT:0>,<EOL>propagate=<NUM_LIT:0>,<EOL>resolution=<NUM_LIT:0>,<EOL>channel_description='<STR_LIT>'):", "body": "self._check_channel(channel_name)<EOL>if channel_type not in ['<STR_LIT:image>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>raise ValueError('<STR_LIT>' +<EOL>'<STR_LIT>')<EOL><DEDENT>if readonly * <NUM_LIT:1> not in [<NUM_LIT:0>, <NUM_LIT:1>]:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>url = self.url() + \"<STR_LIT>\".format(dataset_name)+ \"<STR_LIT>\".format(project_name) +\"<STR_LIT>\".format(channel_name)<EOL>json = {<EOL>\"<STR_LIT>\": channel_name,<EOL>\"<STR_LIT>\": channel_type,<EOL>\"<STR_LIT>\": dtype,<EOL>\"<STR_LIT>\": startwindow,<EOL>\"<STR_LIT>\": endwindow,<EOL>'<STR_LIT>': start_time,<EOL>'<STR_LIT>': end_time,<EOL>'<STR_LIT>': readonly,<EOL>'<STR_LIT>': propagate,<EOL>'<STR_LIT>': resolution,<EOL>'<STR_LIT>': channel_description<EOL>}<EOL>req = self.remote_utils.post_url(url, json=json)<EOL>if req.status_code is not <NUM_LIT>:<EOL><INDENT>raise RemoteDataUploadError('<STR_LIT>'.format(req.text))<EOL><DEDENT>if req.content == \"<STR_LIT>\" or req.content == b'<STR_LIT>':<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Create a new channel on the Remote, using channel_data.\n\nArguments:\n    channel_name (str): Channel name\n    project_name (str): Project name\n    dataset_name (str): Dataset name\n    channel_type (str): Type of the channel (e.g. `neurodata.IMAGE`)\n    dtype (str): The datatype of the channel's data (e.g. `uint8`)\n    startwindow (int): Window to start in\n    endwindow (int): Window to end in\n    readonly (int): Can others write to this channel?\n    propagate (int): Allow propogation? 1 is True, 0 is False\n    resolution (int): Resolution scaling\n    channel_description (str): Your description of the channel\n\nReturns:\n    bool: `True` if successful, `False` otherwise.\n\nRaises:\n    ValueError: If your args were bad :(\n    RemoteDataUploadError: If the channel data is valid but upload\n        fails for some other reason.", "id": "f12229:c0:m14"}
{"signature": "def get_propagate_status(self, token, channel):", "body": "url = self.url('<STR_LIT>'.format(token, channel))<EOL>req = self.remote_utils.get_url(url)<EOL>if req.status_code is not <NUM_LIT:200>:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(token, channel))<EOL><DEDENT>return req.text<EOL>", "docstring": "Get the propagate status for a token/channel pair.\n\nArguments:\n    token (str): The token to check\n    channel (str): The channel to check\n\nReturns:\n    str: The status code", "id": "f12230:c0:m11"}
{"signature": "def __repr__(self):", "body": "return \"<STR_LIT>\".format(<EOL>self.hostname,<EOL>self.protocol,<EOL>self.meta_url,<EOL>self.meta_protocol<EOL>)<EOL>", "docstring": "Return a string representation that can be used to reproduce this\ninstance. `eval(repr(this))` should return an identical copy.\n\nArguments:\n    None\n\nReturns:\n    str: Representation of reproducible instance.", "id": "f12230:c0:m6"}
{"signature": "def __init__(self, message):", "body": "super(Exception, self).__init__(message)<EOL>", "docstring": "Initialize the error.", "id": "f12231:c0:m0"}
{"signature": "def get_cutout(self, token, channel,<EOL>x_start, x_stop,<EOL>y_start, y_stop,<EOL>z_start, z_stop,<EOL>t_start=<NUM_LIT:0>, t_stop=<NUM_LIT:1>,<EOL>resolution=<NUM_LIT:1>,<EOL>block_size=DEFAULT_BLOCK_SIZE,<EOL>neariso=False):", "body": "if block_size is None:<EOL><INDENT>block_size = self.get_block_size(token, resolution)<EOL><DEDENT>origin = self.get_image_offset(token, resolution)<EOL>if (z_stop - z_start) < <NUM_LIT:16>:<EOL><INDENT>z_slices = <NUM_LIT:16><EOL><DEDENT>else:<EOL><INDENT>z_slices = z_stop - z_start<EOL><DEDENT>size = (x_stop - x_start) * (y_stop - y_start) * z_slices * <NUM_LIT:4><EOL>if six.PY2:<EOL><INDENT>dl_func = self._get_cutout_blosc_no_chunking<EOL><DEDENT>elif six.PY3:<EOL><INDENT>dl_func = self._get_cutout_no_chunking<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if size < self._chunk_threshold:<EOL><INDENT>vol = dl_func(token, channel, resolution,<EOL>x_start, x_stop,<EOL>y_start, y_stop,<EOL>z_start, z_stop,<EOL>t_start, t_stop,<EOL>neariso=neariso)<EOL>vol = numpy.rollaxis(vol, <NUM_LIT:1>)<EOL>vol = numpy.rollaxis(vol, <NUM_LIT:2>)<EOL>return vol<EOL><DEDENT>else:<EOL><INDENT>from ndio.utils.parallel import block_compute<EOL>blocks = block_compute(x_start, x_stop,<EOL>y_start, y_stop,<EOL>z_start, z_stop,<EOL>origin, block_size)<EOL>vol = numpy.zeros(((z_stop - z_start),<EOL>(y_stop - y_start),<EOL>(x_stop - x_start)))<EOL>for b in blocks:<EOL><INDENT>data = dl_func(token, channel, resolution,<EOL>b[<NUM_LIT:0>][<NUM_LIT:0>], b[<NUM_LIT:0>][<NUM_LIT:1>],<EOL>b[<NUM_LIT:1>][<NUM_LIT:0>], b[<NUM_LIT:1>][<NUM_LIT:1>],<EOL>b[<NUM_LIT:2>][<NUM_LIT:0>], b[<NUM_LIT:2>][<NUM_LIT:1>],<EOL><NUM_LIT:0>, <NUM_LIT:1>,<EOL>neariso=neariso)<EOL>if b == blocks[<NUM_LIT:0>]:  <EOL><INDENT>vol = numpy.zeros(((z_stop - z_start),<EOL>(y_stop - y_start),<EOL>(x_stop - x_start)), dtype=data.dtype)<EOL><DEDENT>vol[b[<NUM_LIT:2>][<NUM_LIT:0>] - z_start: b[<NUM_LIT:2>][<NUM_LIT:1>] - z_start,<EOL>b[<NUM_LIT:1>][<NUM_LIT:0>] - y_start: b[<NUM_LIT:1>][<NUM_LIT:1>] - y_start,<EOL>b[<NUM_LIT:0>][<NUM_LIT:0>] - x_start: b[<NUM_LIT:0>][<NUM_LIT:1>] - x_start] = data<EOL><DEDENT>vol = numpy.rollaxis(vol, <NUM_LIT:1>)<EOL>vol = numpy.rollaxis(vol, <NUM_LIT:2>)<EOL>return vol<EOL><DEDENT>", "docstring": "Get volumetric cutout data from the neurodata server.\n\nArguments:\n    token (str): Token to identify data to download\n    channel (str): Channel\n    resolution (int): Resolution level\n    Q_start (int): The lower bound of dimension 'Q'\n    Q_stop (int): The upper bound of dimension 'Q'\n    block_size (int[3]): Block size of this dataset. If not provided,\n        ndio uses the metadata of this tokenchannel to set. If you find\n        that your downloads are timing out or otherwise failing, it may\n        be wise to start off by making this smaller.\n    neariso (bool : False): Passes the 'neariso' param to the cutout.\n        If you don't know what this means, ignore it!\n\nReturns:\n    numpy.ndarray: Downloaded data.", "id": "f12232:c0:m7"}
{"signature": "def get_xy_slice(self, token, channel,<EOL>x_start, x_stop,<EOL>y_start, y_stop,<EOL>z_index,<EOL>resolution=<NUM_LIT:0>):", "body": "vol = self.get_cutout(token, channel, x_start, x_stop, y_start,<EOL>y_stop, z_index, z_index + <NUM_LIT:1>, resolution)<EOL>vol = numpy.squeeze(vol)  <EOL>return vol<EOL>", "docstring": "Return a binary-encoded, decompressed 2d image. You should\nspecify a 'token' and 'channel' pair.  For image data, users\nshould use the channel 'image.'\n\nArguments:\n    token (str): Token to identify data to download\n    channel (str): Channel\n    resolution (int): Resolution level\n    Q_start (int):` The lower bound of dimension 'Q'\n    Q_stop (int): The upper bound of dimension 'Q'\n    z_index (int): The z-slice to image\n\nReturns:\n    str: binary image data", "id": "f12232:c0:m4"}
{"signature": "def set_metadata(self, token, data):", "body": "req = requests.post(self.meta_url(\"<STR_LIT>\" + token),<EOL>json=data, verify=False)<EOL>if req.status_code != <NUM_LIT:200>:<EOL><INDENT>raise RemoteDataUploadError(<EOL>\"<STR_LIT>\" + req.json()['<STR_LIT:message>']<EOL>)<EOL><DEDENT>return req.json()<EOL>", "docstring": "Insert new metadata into the OCP metadata database.\n\nArguments:\n    token (str): Token of the datum to set\n    data (str): A dictionary to insert as metadata. Include `secret`.\n\nReturns:\n    json: Info of the inserted ID (convenience) or an error message.\n\nThrows:\n    RemoteDataUploadError: If the token is already populated, or if\n        there is an issue with your specified `secret` key.", "id": "f12234:c0:m9"}
{"signature": "def add_subvolume(self, token, channel, secret,<EOL>x_start, x_stop,<EOL>y_start, y_stop,<EOL>z_start, z_stop,<EOL>resolution, title, notes):", "body": "md = self.get_metadata(token)['<STR_LIT>']<EOL>if '<STR_LIT>' in md:<EOL><INDENT>subvols = md['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>subvols = []<EOL><DEDENT>subvols.append({<EOL>'<STR_LIT>': token,<EOL>'<STR_LIT>': channel,<EOL>'<STR_LIT>': x_start,<EOL>'<STR_LIT>': x_stop,<EOL>'<STR_LIT>': y_start,<EOL>'<STR_LIT>': y_stop,<EOL>'<STR_LIT>': z_start,<EOL>'<STR_LIT>': z_stop,<EOL>'<STR_LIT>': resolution,<EOL>'<STR_LIT:title>': title,<EOL>'<STR_LIT>': notes<EOL>})<EOL>return self.set_metadata(token, {<EOL>'<STR_LIT>': secret,<EOL>'<STR_LIT>': subvols<EOL>})<EOL>", "docstring": "Adds a new subvolume to a token/channel.\n\nArguments:\n    token (str): The token to write to in LIMS\n    channel (str): Channel to add in the subvolume. Can be `None`\n    x_start (int): Start in x dimension\n    x_stop (int): Stop in x dimension\n    y_start (int): Start in y dimension\n    y_stop (int): Stop in y dimension\n    z_start (int): Start in z dimension\n    z_stop (int): Stop in z dimension\n    resolution (int): The resolution at which this subvolume is seen\n    title (str): The title to set for the subvolume\n    notes (str): Optional extra thoughts on the subvolume\n\nReturns:\n    boolean: success", "id": "f12234:c0:m11"}
{"signature": "def get_public_tokens(self):", "body": "r = self.remote_utils.get_url(self.url() + \"<STR_LIT>\")<EOL>return r.json()<EOL>", "docstring": "Get a list of public tokens available on this server.\n\nArguments:\n    None\n\nReturns:\n    str[]: list of public tokens", "id": "f12234:c0:m1"}
{"signature": "def get_proj_info(self, token):", "body": "r = self.remote_utils.get_url(self.url() + \"<STR_LIT>\".format(token))<EOL>return r.json()<EOL>", "docstring": "Return the project info for a given token.\n\nArguments:\n    token (str): Token to return information for\n\nReturns:\n    JSON: representation of proj_info", "id": "f12234:c0:m5"}
{"signature": "def get_channels(self, token):", "body": "return self.get_proj_info(token)['<STR_LIT>']<EOL>", "docstring": "Wraps get_proj_info to return a dictionary of just the channels of\na given project.\n\nArguments:\n    token (str): Token to return channels for\n\nReturns:\n    JSON: dictionary of channels.", "id": "f12234:c0:m7"}
{"signature": "def get_subvolumes(self, token):", "body": "md = self.get_metadata(token)['<STR_LIT>']<EOL>if '<STR_LIT>' in md:<EOL><INDENT>return md['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Return a list of subvolumes taken from LIMS, if available.\n\nArguments:\n    token (str): The token to read from in LIMS\n\nReturns:\n    dict: or None if unavailable", "id": "f12234:c0:m10"}
{"signature": "def get_public_datasets(self):", "body": "return list(self.get_public_datasets_and_tokens().keys())<EOL>", "docstring": "NOTE: VERY SLOW!\nGet a list of public datasets. Different than public tokens!\n\nArguments:\n    None\n\nReturns:\n    str[]: list of public datasets", "id": "f12234:c0:m2"}
{"signature": "def __repr__(self):", "body": "return \"<STR_LIT>\".format(<EOL>self.hostname,<EOL>self.protocol,<EOL>self.email<EOL>)<EOL>", "docstring": "Returns a string representation that can be used to reproduce this\ninstance. `eval(repr(this))` should return an identical copy.\n\nArguments:\n    None\n\nReturns:\n    str: Representation of reproducible instance.", "id": "f12235:c2:m1"}
{"signature": "def convert_graph(self, graph_file, input_format, output_formats,<EOL>email=None, use_threads=False, callback=None):", "body": "if email is None:<EOL><INDENT>email = self.email<EOL><DEDENT>if input_format not in GraphFormats._any:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(input_format))<EOL><DEDENT>if not set(output_formats) <= set(GraphFormats._any):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if use_threads and callback is not None:<EOL><INDENT>if not hasattr(callback, '<STR_LIT>'):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if len(inspect.getargspec(callback).args) != <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if not (os.path.exists(graph_file)):<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(graph_file))<EOL><DEDENT>url = \"<STR_LIT>\".format(<EOL>email,<EOL>input_format,<EOL>'<STR_LIT:U+002C>'.join(output_formats)<EOL>)<EOL>if \"<STR_LIT:U+0020>\" in url:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if use_threads:<EOL><INDENT>convert_thread = threading.Thread(<EOL>target=self._run_convert_graph,<EOL>args=[url, graph_file, callback]<EOL>)<EOL>convert_thread.start()<EOL><DEDENT>else:<EOL><INDENT>return self._run_convert_graph(url, graph_file)<EOL><DEDENT>return<EOL>", "docstring": "Convert a graph from one GraphFormat to another.\n\nArguments:\n    graph_file (str): Filename of the file to convert\n    input_format (str): A grute.GraphFormats\n    output_formats (str[]): A grute.GraphFormats\n    email (str: self.email)*: The email to notify\n    use_threads (bool: False)*: Whether to use Python threads to run\n        computation in the background when waiting for the server\n    callback (function: None)*: The function to run upon completion of\n        the call, if using threads. (Will not be called if use_threads\n        is set to False.)\n\nReturns:\n    HTTP Response if use_threads=False. Else, no return value.\n\nRaises:\n    RemoteDataUploadError: If there's an issue uploading the data\n    RemoteError: If there's a server-side issue\n    ValueError: If there's a problem with the supplied arguments", "id": "f12235:c2:m9"}
{"signature": "def __init__(self,<EOL>hostname=DEFAULT_HOSTNAME,<EOL>protocol=DEFAULT_PROTOCOL,<EOL>email=DEFAULT_EMAIL):", "body": "super(grute, self).__init__(hostname, protocol)<EOL>self.email = email<EOL>", "docstring": "Initialize a new grute remote.\n\nArguments:\n    hostname (str: \"openconnecto.me\"): The hostname where grute lives\n    protocol (str: \"http\"): The protocol over which to access grute\n    email (str: \"\"): The email to which completion notifications should\n        be sent (unless overridden in individual calls). Note that the\n        completion URLs are also accessible via this Python API.", "id": "f12235:c2:m0"}
{"signature": "def from_json(json, cutout=None):", "body": "if type(json) is str:<EOL><INDENT>json = jsonlib.loads(json)<EOL><DEDENT>out_ramons = []<EOL>for (rid, rdata) in six.iteritems(json):<EOL><INDENT>_md = rdata['<STR_LIT>']<EOL>r = AnnotationType.RAMON(rdata['<STR_LIT:type>'])(<EOL>id=rid,<EOL>author=_md['<STR_LIT>'],<EOL>status=_md['<STR_LIT:status>'],<EOL>confidence=_md['<STR_LIT>'],<EOL>kvpairs=copy.deepcopy(_md['<STR_LIT>'])<EOL>)<EOL>if rdata['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>r.segmentclass = _md.get('<STR_LIT>')<EOL>r.neuron = _md.get('<STR_LIT>')<EOL>if '<STR_LIT>' in _md:<EOL><INDENT>r.synapses = _md['<STR_LIT>'][:]<EOL><DEDENT>if '<STR_LIT>' in _md:<EOL><INDENT>r.organelles = _md['<STR_LIT>'][:]<EOL><DEDENT><DEDENT>elif rdata['<STR_LIT:type>'] in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>if '<STR_LIT>' in _md:<EOL><INDENT>r.segments = _md['<STR_LIT>'][:]<EOL><DEDENT><DEDENT>elif rdata['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>r.organelle_class = _md['<STR_LIT>'][:]<EOL><DEDENT>elif rdata['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>r.synapse_type = _md.get('<STR_LIT>')<EOL>r.weight = _md.get('<STR_LIT>')<EOL><DEDENT>out_ramons.append(r)<EOL><DEDENT>return out_ramons<EOL>", "docstring": "Converts JSON to a python list of RAMON objects. if `cutout` is provided,\nthe `cutout` attribute of the RAMON object is populated. Otherwise, it's\nleft empty. `json` should be an ID-level dictionary, like so:\n\n    {\n        16: {\n            type: \"segment\",\n            metadata: {\n                . . .\n            }\n        },\n    }\n\nNOTE: If more than one item is in the dictionary, then a Python list of\nRAMON objects is returned instead of a single RAMON.\n\nArguments:\n    json (str or dict): The JSON to import to RAMON objects\n    cutout: Currently not supported.\n\nReturns:\n    [RAMON]", "id": "f12241:m2"}
{"signature": "def to_hdf5(ramon, hdf5=None):", "body": "if issubclass(type(ramon), RAMONBase) is False:<EOL><INDENT>raise InvalidRAMONError(\"<STR_LIT>\")<EOL><DEDENT>import h5py<EOL>import numpy<EOL>if hdf5 is None:<EOL><INDENT>tmpfile = tempfile.NamedTemporaryFile(delete=False)<EOL><DEDENT>else:<EOL><INDENT>tmpfile = hdf5<EOL><DEDENT>with h5py.File(tmpfile.name, \"<STR_LIT:a>\") as hdf5:<EOL><INDENT>grp = hdf5.create_group(str(ramon.id))<EOL>grp.create_dataset(\"<STR_LIT>\", (<NUM_LIT:1>,),<EOL>numpy.uint32,<EOL>data=AnnotationType.get_int(type(ramon)))<EOL>if hasattr(ramon, '<STR_LIT>'):<EOL><INDENT>if ramon.cutout is not None:<EOL><INDENT>grp.create_dataset('<STR_LIT>', ramon.cutout.shape,<EOL>ramon.cutout.dtype, data=ramon.cutout)<EOL>grp.create_dataset('<STR_LIT>', (<NUM_LIT:1>,),<EOL>numpy.uint32, data=ramon.resolution)<EOL>grp.create_dataset('<STR_LIT>', (<NUM_LIT:3>,),<EOL>numpy.uint32, data=ramon.xyz_offset)<EOL><DEDENT><DEDENT>metadata = grp.create_group('<STR_LIT>')<EOL>metadata.create_dataset('<STR_LIT>', (<NUM_LIT:1>,),<EOL>dtype=h5py.special_dtype(vlen=str),<EOL>data=ramon.author)<EOL>fstring = StringIO()<EOL>csvw = csv.writer(fstring, delimiter='<STR_LIT:U+002C>')<EOL>csvw.writerows([r for r in six.iteritems(ramon.kvpairs)])<EOL>metadata.create_dataset('<STR_LIT>', (<NUM_LIT:1>,),<EOL>dtype=h5py.special_dtype(vlen=str),<EOL>data=fstring.getvalue())<EOL>metadata.create_dataset('<STR_LIT>', (<NUM_LIT:1>,), numpy.float,<EOL>data=ramon.confidence)<EOL>metadata.create_dataset('<STR_LIT>', (<NUM_LIT:1>,), numpy.uint32,<EOL>data=ramon.status)<EOL>if hasattr(ramon, '<STR_LIT>'):<EOL><INDENT>metadata.create_dataset('<STR_LIT>',<EOL>data=numpy.asarray(ramon.segments,<EOL>dtype=numpy.uint32))<EOL><DEDENT>if hasattr(ramon, '<STR_LIT>'):<EOL><INDENT>metadata.create_dataset('<STR_LIT>', (<NUM_LIT:1>,), numpy.uint32,<EOL>data=ramon.synapse_type)<EOL><DEDENT>if hasattr(ramon, '<STR_LIT>'):<EOL><INDENT>metadata.create_dataset('<STR_LIT>', (<NUM_LIT:1>,),<EOL>numpy.float, data=ramon.weight)<EOL><DEDENT>if hasattr(ramon, '<STR_LIT>'):<EOL><INDENT>metadata.create_dataset('<STR_LIT>', (<NUM_LIT:1>,),<EOL>numpy.uint32, data=ramon.neuron)<EOL><DEDENT>if hasattr(ramon, '<STR_LIT>'):<EOL><INDENT>metadata.create_dataset('<STR_LIT>', (<NUM_LIT:1>,), numpy.uint32,<EOL>data=ramon.segmentclass)<EOL><DEDENT>if hasattr(ramon, '<STR_LIT>'):<EOL><INDENT>metadata.create_dataset('<STR_LIT>', (len(ramon.synapses),),<EOL>numpy.uint32, data=ramon.synapses)<EOL><DEDENT>if hasattr(ramon, '<STR_LIT>'):<EOL><INDENT>metadata.create_dataset('<STR_LIT>',<EOL>(len(ramon.organelles),),<EOL>numpy.uint32,<EOL>data=ramon.organelles)<EOL><DEDENT>if hasattr(ramon, '<STR_LIT>'):<EOL><INDENT>metadata.create_dataset('<STR_LIT>', (<NUM_LIT:1>,),<EOL>numpy.uint32,<EOL>data=ramon.organelle_class)<EOL><DEDENT>hdf5.flush()<EOL>tmpfile.seek(<NUM_LIT:0>)<EOL>return tmpfile<EOL><DEDENT>return False<EOL>", "docstring": "Exports a RAMON object to an HDF5 file object.\n\nArguments:\n    ramon (RAMON): A subclass of RAMONBase\n    hdf5 (str): Export filename\n\nReturns:\n    hdf5.File\n\nRaises:\n    InvalidRAMONError: if you pass a non-RAMON object", "id": "f12241:m4"}
{"signature": "def to_dict(ramons, flatten=False):", "body": "if type(ramons) is not list:<EOL><INDENT>ramons = [ramons]<EOL><DEDENT>out_ramons = {}<EOL>for r in ramons:<EOL><INDENT>out_ramons[r.id] = {<EOL>\"<STR_LIT:id>\": r.id,<EOL>\"<STR_LIT:type>\": _reverse_ramon_types[type(r)],<EOL>\"<STR_LIT>\": vars(r)<EOL>}<EOL><DEDENT>return out_ramons<EOL>", "docstring": "Converts a RAMON object list to a JSON-style dictionary. Useful for going\nfrom an array of RAMONs to a dictionary, indexed by ID.\n\nArguments:\n    ramons (RAMON[]): A list of RAMON objects\n    flatten (boolean: False): Not implemented\n\nReturns:\n    dict: A python dictionary of RAMON objects.", "id": "f12241:m0"}
{"signature": "def __init__(self,<EOL>xyz_offset=(<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>),<EOL>resolution=<NUM_LIT:0>,<EOL>cutout=None,<EOL>voxels=None,<EOL>id=DEFAULT_ID,<EOL>confidence=DEFAULT_CONFIDENCE,<EOL>kvpairs=DEFAULT_DYNAMIC_METADATA,<EOL>status=DEFAULT_STATUS,<EOL>author=DEFAULT_AUTHOR):", "body": "self.xyz_offset = xyz_offset<EOL>self.resolution = resolution<EOL>self.cutout = cutout<EOL>self.voxels = voxels<EOL>RAMONBase.__init__(self, id=id, confidence=confidence,<EOL>kvpairs=kvpairs,<EOL>status=status, author=author)<EOL>", "docstring": "Initialize a new RAMONVolume object. Inherits attributes from RAMONBase\nas well as:\n\nArguments:\n    xyz_offset (int[3] : (0, 0, 0)): x,y,z coordinates of the minimum\n        corner of the cube (if data is a cutout), otherwise empty\n    resolution (int : 0): level in the database resolution hierarchy\n    cutout (numpy.ndarray): dense matrix of data\n    voxels: Unused for now", "id": "f12243:c0:m0"}
{"signature": "def __init__(self, id=DEFAULT_ID,<EOL>confidence=DEFAULT_CONFIDENCE,<EOL>kvpairs=DEFAULT_DYNAMIC_METADATA,<EOL>status=DEFAULT_STATUS,<EOL>author=DEFAULT_AUTHOR):", "body": "self.id = id<EOL>self.confidence = confidence<EOL>self.kvpairs = kvpairs<EOL>self.status = status<EOL>self.author = author<EOL>", "docstring": "Initialize a new RAMONBase object with default attributes.\n\nArguments:\n    id (int): Unique 32-bit ID value assigned by OCP database\n    confidence (float): Value 0-1 indicating confidence in annotation\n    kvpairs (dict): A collection of key-value pairs\n    status (string): Status of annotation in database\n    author (string): Username of the person who created the annotation", "id": "f12244:c0:m0"}
{"signature": "def from_voxels(voxels):", "body": "dimensions = len(voxels[<NUM_LIT:0>])<EOL>for d in range(len(dimensions)):<EOL><INDENT>size.append(max([i[d] for i in voxels]))<EOL><DEDENT>result = numpy.zeros(dimensions)<EOL>for v in voxels:<EOL><INDENT>result[v] = <NUM_LIT:1><EOL><DEDENT>return result<EOL>", "docstring": "Converts a voxel list to an ndarray.\n\nArguments:\n    voxels (tuple[]): A list of coordinates indicating coordinates of\n        populated voxels in an ndarray.\n\nReturns:\n    numpy.ndarray The result of the transformation.", "id": "f12247:m1"}
{"signature": "def save(nifti_filename, numpy_data):", "body": "<EOL>nifti_filename = os.path.expanduser(nifti_filename)<EOL>try:<EOL><INDENT>nifti_img = nib.Nifti1Image(numpy_data, numpy.eye(<NUM_LIT:4>))<EOL>nib.save(nifti_img, nifti_filename)<EOL><DEDENT>except Exception as e:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(nifti_filename))<EOL><DEDENT>return nifti_filename<EOL>", "docstring": "Export a numpy array to a nifti file.  TODO: currently using dummy\nheaders and identity matrix affine transform. This can be expanded.\n\nArguments:\n    nifti_filename (str): A filename to which to save the nifti data\n    numpy_data (numpy.ndarray): The numpy array to save to nifti\n\nReturns:\n    String. The expanded filename that now holds the nifti data", "id": "f12249:m1"}
{"signature": "def load_collection(png_filename_base):", "body": "<EOL>files = glob.glob(png_filename_base)<EOL>files.sort()<EOL>numpy_data = []<EOL>for f in files:<EOL><INDENT>numpy_data.append(load(f))<EOL><DEDENT>return numpy.concatenate(numpy_data)<EOL>", "docstring": "Import all files matching the filename base given with `png_filename_base`.\nImages are ordered by alphabetical order, which means that you *MUST* 0-pad\nyour numbers if they span a power of ten (e.g. 0999-1000 or 09-10). This is\nhandled automatically by its complementary function, `png.save_collection`.\nAlso, look at how nicely these documentation lines are all the same length!\n\nArguments:\n    png_filename_base (str): An asterisk-wildcard string that should refer\n        to all PNGs in the stack. All *s are replaced according to regular\n        cmd-line expansion rules. See the 'glob' documentation for details\nReturns:\n    A numpy array holding a 3D dataset", "id": "f12251:m3"}
{"signature": "def load_collection(tiff_filename_base):", "body": "<EOL>files = glob.glob(tiff_filename_base)<EOL>files.sort()<EOL>numpy_data = []<EOL>for f in files:<EOL><INDENT>numpy_data.append(load(f))<EOL><DEDENT>return numpy.concatenate(numpy_data)<EOL>", "docstring": "Import all files matching the filename base given via `tiff_filename_base`.\nImages are ordered by alphabetical order, which means that you *MUST* 0-pad\nyour numbers if they span a power of ten (e.g. 0999-1000 or 09-10). This is\nhandled automatically by the complement function, `save_collection`.\nAlso, look at how nicely these documentation lines are all the same length!\n\nArguments:\n    tiff_filename_base:     An asterisk-wildcard string that should refer\n                            to all TIFFs in the stack. All * are replaced\n                            according to command-line expansion rules.\n\nReturns:\n    A numpy array holding a 3D dataset", "id": "f12254:m4"}
{"signature": "def _debug(sig, frame):", "body": "d={'<STR_LIT>':frame}         <EOL>d.update(frame.f_globals)  <EOL>d.update(frame.f_locals)<EOL>i = code.InteractiveConsole(d)<EOL>message  = \"<STR_LIT>\"<EOL>message += '<STR_LIT>'.join(traceback.format_stack(frame))<EOL>i.interact(message)<EOL>", "docstring": "Interrupt running process, and provide a python prompt for\n    interactive debugging.\n\n    source: http://stackoverflow.com/questions/132058/showing-the-stack-trace-from-a-running-python-application", "id": "f12266:m1"}
{"signature": "def add_task(self, func, *args, **kargs):", "body": "self.tasks.put((func, args, kargs))<EOL>", "docstring": "Add a task to the queue", "id": "f12273:c1:m1"}
{"signature": "def run_inside_another_thread(transport):", "body": "with get_default_tracer().zipkin_span(<EOL>service_name='<STR_LIT>',<EOL>span_name='<STR_LIT:index>',<EOL>transport_handler=transport,<EOL>sample_rate=<NUM_LIT>,<EOL>encoding=Encoding.V2_JSON,<EOL>):<EOL><INDENT>do_stuff()<EOL><DEDENT>", "docstring": "Run this function inside a different thread.\n\n    :param transport: transport handler. We need to pass it in since any\n        assertion we do inside this thread gets silently swallowed, so we\n        need a way to return the results to the main thread.\n    :type transport: MockTransportHandler", "id": "f12287:m1"}
{"signature": "def emit_spans(self):", "body": "<EOL>if self.firehose_handler:<EOL><INDENT>self._emit_spans_with_span_sender(<EOL>ZipkinBatchSender(self.firehose_handler,<EOL>self.max_span_batch_size,<EOL>self.encoder)<EOL>)<EOL><DEDENT>if not self.zipkin_attrs.is_sampled:<EOL><INDENT>self._get_tracer().clear()<EOL>return<EOL><DEDENT>span_sender = ZipkinBatchSender(self.transport_handler,<EOL>self.max_span_batch_size,<EOL>self.encoder)<EOL>self._emit_spans_with_span_sender(span_sender)<EOL>self._get_tracer().clear()<EOL>", "docstring": "Main function to log all the annotations stored during the entire\n        request. This is done if the request is sampled and the response was\n        a success. It also logs the service (`ss` and `sr`) or the client\n        ('cs' and 'cr') annotations.", "id": "f12302:c0:m3"}
{"signature": "def generate_random_64bit_string():", "body": "return '<STR_LIT>'.format(random.getrandbits(<NUM_LIT:64>))<EOL>", "docstring": "Returns a 64 bit UTF-8 encoded string. In the interests of simplicity,\n    this is always cast to a `str` instead of (in py2 land) a unicode string.\n    Certain clients (I'm looking at you, Twisted) don't enjoy unicode headers.\n\n    :returns: random 16-character string", "id": "f12303:m0"}
{"signature": "def push_zipkin_attrs(zipkin_attr):", "body": "from py_zipkin.storage import ThreadLocalStack<EOL>log.warning('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>return ThreadLocalStack().push(zipkin_attr)<EOL>", "docstring": "Stores the zipkin attributes to thread local.\n\n    .. deprecated::\n       Use the Tracer interface which offers better multi-threading support.\n       push_zipkin_attrs will be removed in version 1.0.\n\n    :param zipkin_attr: tuple containing zipkin related attrs\n    :type zipkin_attr: :class:`zipkin.ZipkinAttrs`", "id": "f12304:m4"}
{"signature": "def _get_current_context(self):", "body": "<EOL>if self._is_local_root_span:<EOL><INDENT>if self.sample_rate is not None:<EOL><INDENT>if self.zipkin_attrs_override andnot self.zipkin_attrs_override.is_sampled:<EOL><INDENT>return True, create_attrs_for_span(<EOL>sample_rate=self.sample_rate,<EOL>trace_id=self.zipkin_attrs_override.trace_id,<EOL>)<EOL><DEDENT>elif not self.zipkin_attrs_override:<EOL><INDENT>return True, create_attrs_for_span(<EOL>sample_rate=self.sample_rate,<EOL>use_128bit_trace_id=self.use_128bit_trace_id,<EOL>)<EOL><DEDENT><DEDENT>if self.firehose_handler and not self.zipkin_attrs_override:<EOL><INDENT>return True, create_attrs_for_span(<EOL>sample_rate=<NUM_LIT:0.0>,<EOL>use_128bit_trace_id=self.use_128bit_trace_id,<EOL>)<EOL><DEDENT>return False, self.zipkin_attrs_override<EOL><DEDENT>else:<EOL><INDENT>existing_zipkin_attrs = self.get_tracer().get_zipkin_attrs()<EOL>if existing_zipkin_attrs:<EOL><INDENT>return False, ZipkinAttrs(<EOL>trace_id=existing_zipkin_attrs.trace_id,<EOL>span_id=generate_random_64bit_string(),<EOL>parent_span_id=existing_zipkin_attrs.span_id,<EOL>flags=existing_zipkin_attrs.flags,<EOL>is_sampled=existing_zipkin_attrs.is_sampled,<EOL>)<EOL><DEDENT><DEDENT>return False, None<EOL>", "docstring": "Returns the current ZipkinAttrs and generates new ones if needed.\n\n        :returns: (report_root_timestamp, zipkin_attrs)\n        :rtype: (bool, ZipkinAttrs)", "id": "f12305:c0:m5"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "_validate_args(kwargs)<EOL>kwargs['<STR_LIT>'] = Kind.SERVER<EOL>super(zipkin_server_span, self).__init__(*args, **kwargs)<EOL>", "docstring": "Logs a zipkin span with server annotations.\n\n        See :class:`zipkin_span` for arguments", "id": "f12305:c2:m0"}
{"signature": "def override_span_name(self, name):", "body": "self.span_name = name<EOL>if self.logging_context:<EOL><INDENT>self.logging_context.span_name = name<EOL><DEDENT>", "docstring": "Overrides the current span name.\n\n        This is useful if you don't know the span name yet when you create the\n        zipkin_span object. i.e. pyramid_zipkin doesn't know which route the\n        request matched until the function wrapped by the context manager\n        completes.\n\n        :param name: New span name\n        :type name: str", "id": "f12305:c0:m11"}
{"signature": "def span_to_bytes(thrift_span):", "body": "transport = TMemoryBuffer()<EOL>protocol = TBinaryProtocol(transport)<EOL>thrift_span.write(protocol)<EOL>return bytes(transport.getvalue())<EOL>", "docstring": "Returns a TBinaryProtocol encoded Thrift span.\n\n:param thrift_span: thrift object to encode.\n:returns: thrift object in TBinaryProtocol format bytes.", "id": "f12306:m7"}
{"signature": "def binary_annotation_list_builder(binary_annotations, host):", "body": "<EOL>ann_type = zipkin_core.AnnotationType.STRING<EOL>return [<EOL>create_binary_annotation(key, str(value), ann_type, host)<EOL>for key, value in binary_annotations.items()<EOL>]<EOL>", "docstring": "Reformat binary annotations dict to return list of zipkin_core objects. The\nvalue of the binary annotations MUST be in string format.\n\n:param binary_annotations: dict with key, value being the name and value\n                           of the binary annotation being logged.\n:type host: :class:`zipkin_core.Endpoint`\n:returns: a list of binary annotation zipkin_core objects\n:rtype: list", "id": "f12306:m5"}
{"signature": "def __init__(<EOL>self,<EOL>trace_id,<EOL>name,<EOL>parent_id,<EOL>span_id,<EOL>kind,<EOL>timestamp,<EOL>duration,<EOL>local_endpoint=None,<EOL>remote_endpoint=None,<EOL>debug=False,<EOL>shared=False,<EOL>annotations=None,<EOL>tags=None,<EOL>):", "body": "self.trace_id = trace_id<EOL>self.name = name<EOL>self.parent_id = parent_id<EOL>self.span_id = span_id<EOL>self.kind = kind<EOL>self.timestamp = timestamp<EOL>self.duration = duration<EOL>self.local_endpoint = local_endpoint<EOL>self.remote_endpoint = remote_endpoint<EOL>self.debug = debug<EOL>self.shared = shared<EOL>self.annotations = annotations or {}<EOL>self.tags = tags or {}<EOL>if not isinstance(kind, Kind):<EOL><INDENT>raise ZipkinError(<EOL>'<STR_LIT>'.format(kind))<EOL><DEDENT>if local_endpoint and not isinstance(local_endpoint, Endpoint):<EOL><INDENT>raise ZipkinError(<EOL>'<STR_LIT>')<EOL><DEDENT>if remote_endpoint and not isinstance(remote_endpoint, Endpoint):<EOL><INDENT>raise ZipkinError(<EOL>'<STR_LIT>')<EOL><DEDENT>", "docstring": "Creates a new Span.\n\n        :param trace_id: Trace id.\n        :type trace_id: str\n        :param name: Name of the span.\n        :type name: str\n        :param parent_id: Parent span id.\n        :type parent_id: str\n        :param span_id: Span id.\n        :type span_id: str\n        :param kind: Span type (client, server, local, etc...)\n        :type kind: Kind\n        :param timestamp: start timestamp in seconds.\n        :type timestamp: float\n        :param duration: span duration in seconds.\n        :type duration: float\n        :param local_endpoint: the host that recorded this span.\n        :type local_endpoint: Endpoint\n        :param remote_endpoint: the remote service.\n        :type remote_endpoint: Endpoint\n        :param debug: True is a request to store this span even if it\n            overrides sampling policy.\n        :type debug: bool\n        :param shared: True if we are contributing to a span started by\n            another tracer (ex on a different host).\n        :type shared: bool\n        :param annotations: Optional dict of str -> timestamp annotations.\n        :type annotations: dict\n        :param tags: Optional dict of str -> str span tags.\n        :type tags: dict", "id": "f12308:c0:m0"}
{"signature": "def fits(self, current_count, current_size, max_size, new_span):", "body": "return current_size + len(new_span) <= max_size<EOL>", "docstring": "Checks if the new span fits in the max payload size.", "id": "f12309:c5:m0"}
{"signature": "def fits(self, current_count, current_size, max_size, new_span):", "body": "return <NUM_LIT:2> + current_count + current_size + len(new_span) <= max_size<EOL>", "docstring": "Checks if the new span fits in the max payload size.\n\n        Json lists only have a 2 bytes overhead from '[]' plus 1 byte from\n        ',' between elements", "id": "f12309:c2:m0"}
{"signature": "def encode_span(self, span):", "body": "json_span = {<EOL>'<STR_LIT>': span.trace_id,<EOL>'<STR_LIT:id>': span.span_id,<EOL>}<EOL>if span.name:<EOL><INDENT>json_span['<STR_LIT:name>'] = span.name<EOL><DEDENT>if span.parent_id:<EOL><INDENT>json_span['<STR_LIT>'] = span.parent_id<EOL><DEDENT>if span.timestamp:<EOL><INDENT>json_span['<STR_LIT>'] = int(span.timestamp * <NUM_LIT>)<EOL><DEDENT>if span.duration:<EOL><INDENT>json_span['<STR_LIT>'] = int(span.duration * <NUM_LIT>)<EOL><DEDENT>if span.shared is True:<EOL><INDENT>json_span['<STR_LIT>'] = True<EOL><DEDENT>if span.kind and span.kind.value is not None:<EOL><INDENT>json_span['<STR_LIT>'] = span.kind.value<EOL><DEDENT>if span.local_endpoint:<EOL><INDENT>json_span['<STR_LIT>'] = self._create_json_endpoint(<EOL>span.local_endpoint,<EOL>False,<EOL>)<EOL><DEDENT>if span.remote_endpoint:<EOL><INDENT>json_span['<STR_LIT>'] = self._create_json_endpoint(<EOL>span.remote_endpoint,<EOL>False,<EOL>)<EOL><DEDENT>if span.tags and len(span.tags) > <NUM_LIT:0>:<EOL><INDENT>json_span['<STR_LIT>'] = span.tags<EOL><DEDENT>if span.annotations:<EOL><INDENT>json_span['<STR_LIT>'] = [<EOL>{<EOL>'<STR_LIT>': int(timestamp * <NUM_LIT>),<EOL>'<STR_LIT:value>': key,<EOL>}<EOL>for key, timestamp in span.annotations.items()<EOL>]<EOL><DEDENT>encoded_span = json.dumps(json_span)<EOL>return encoded_span<EOL>", "docstring": "Encodes a single span to JSON.", "id": "f12309:c4:m0"}
{"signature": "def get_encoder(encoding):", "body": "if encoding == Encoding.V1_THRIFT:<EOL><INDENT>return _V1ThriftEncoder()<EOL><DEDENT>if encoding == Encoding.V1_JSON:<EOL><INDENT>return _V1JSONEncoder()<EOL><DEDENT>if encoding == Encoding.V2_JSON:<EOL><INDENT>return _V2JSONEncoder()<EOL><DEDENT>if encoding == Encoding.V2_PROTO3:<EOL><INDENT>return _V2ProtobufEncoder()<EOL><DEDENT>raise ZipkinError('<STR_LIT>'.format(encoding))<EOL>", "docstring": "Creates encoder object for the given encoding.\n\n    :param encoding: desired output encoding protocol.\n    :type encoding: Encoding\n    :return: corresponding IEncoder object\n    :rtype: IEncoder", "id": "f12309:m0"}
{"signature": "def detect_span_version_and_encoding(message):", "body": "<EOL>if isinstance(message, six.string_types):<EOL><INDENT>if six.PY2:<EOL><INDENT>message = six.b(message)  <EOL><DEDENT>else:<EOL><INDENT>message = message.encode('<STR_LIT:utf-8>')  <EOL><DEDENT><DEDENT>if len(message) < <NUM_LIT:2>:<EOL><INDENT>raise ZipkinError(\"<STR_LIT>\")<EOL><DEDENT>if six.byte2int(message) <= <NUM_LIT:16>:<EOL><INDENT>if six.byte2int(message) == <NUM_LIT:10> and six.byte2int(message[<NUM_LIT:1>:<NUM_LIT:2>]) != <NUM_LIT:0>:<EOL><INDENT>return Encoding.V2_PROTO3<EOL><DEDENT>return Encoding.V1_THRIFT<EOL><DEDENT>str_msg = message.decode('<STR_LIT:utf-8>')<EOL>if str_msg[<NUM_LIT:0>] == '<STR_LIT:[>':<EOL><INDENT>span_list = json.loads(str_msg)<EOL>if len(span_list) > <NUM_LIT:0>:<EOL><INDENT>for span in span_list:<EOL><INDENT>if any(word in span for word in _V2_ATTRIBUTES):<EOL><INDENT>return Encoding.V2_JSON<EOL><DEDENT>elif (<EOL>'<STR_LIT>' in span or<EOL>(<EOL>'<STR_LIT>' in span and<EOL>'<STR_LIT>' in span['<STR_LIT>']<EOL>)<EOL>):<EOL><INDENT>return Encoding.V1_JSON<EOL><DEDENT><DEDENT>return Encoding.V2_JSON<EOL><DEDENT><DEDENT>raise ZipkinError(\"<STR_LIT>\")<EOL>", "docstring": "Returns the span type and encoding for the message provided.\n\n    The logic in this function is a Python port of\n    https://github.com/openzipkin/zipkin/blob/master/zipkin/src/main/java/zipkin/internal/DetectingSpanDecoder.java\n\n    :param message: span to perform operations on.\n    :type message: byte array\n    :returns: span encoding.\n    :rtype: Encoding", "id": "f12311:m0"}
{"signature": "def decode_spans(self, spans):", "body": "raise NotImplementedError()<EOL>", "docstring": "Decodes an encoded list of spans.\n\n        :param spans: encoded list of spans\n        :type spans: bytes\n        :return: list of spans\n        :rtype: list of Span", "id": "f12312:c0:m0"}
{"signature": "def decode_spans(self, spans):", "body": "decoded_spans = []<EOL>transport = TMemoryBuffer(spans)<EOL>if six.byte2int(spans) == TType.STRUCT:<EOL><INDENT>_, size = read_list_begin(transport)<EOL><DEDENT>else:<EOL><INDENT>size = <NUM_LIT:1><EOL><DEDENT>for _ in range(size):<EOL><INDENT>span = zipkin_core.Span()<EOL>span.read(TBinaryProtocol(transport))<EOL>decoded_spans.append(self._decode_thrift_span(span))<EOL><DEDENT>return decoded_spans<EOL>", "docstring": "Decodes an encoded list of spans.\n\n        :param spans: encoded list of spans\n        :type spans: bytes\n        :return: list of spans\n        :rtype: list of Span", "id": "f12312:c1:m0"}
{"signature": "def _decode_thrift_span(self, thrift_span):", "body": "parent_id = None<EOL>local_endpoint = None<EOL>annotations = {}<EOL>tags = {}<EOL>kind = Kind.LOCAL<EOL>remote_endpoint = None<EOL>timestamp = None<EOL>duration = None<EOL>if thrift_span.parent_id:<EOL><INDENT>parent_id = self._convert_unsigned_long_to_lower_hex(<EOL>thrift_span.parent_id,<EOL>)<EOL><DEDENT>if thrift_span.annotations:<EOL><INDENT>annotations, local_endpoint, kind, timestamp, duration =self._decode_thrift_annotations(thrift_span.annotations)<EOL><DEDENT>if thrift_span.binary_annotations:<EOL><INDENT>tags, local_endpoint, remote_endpoint =self._convert_from_thrift_binary_annotations(<EOL>thrift_span.binary_annotations,<EOL>)<EOL><DEDENT>trace_id = self._convert_trace_id_to_string(<EOL>thrift_span.trace_id,<EOL>thrift_span.trace_id_high,<EOL>)<EOL>return Span(<EOL>trace_id=trace_id,<EOL>name=thrift_span.name,<EOL>parent_id=parent_id,<EOL>span_id=self._convert_unsigned_long_to_lower_hex(thrift_span.id),<EOL>kind=kind,<EOL>timestamp=self.seconds(timestamp or thrift_span.timestamp),<EOL>duration=self.seconds(duration or thrift_span.duration),<EOL>local_endpoint=local_endpoint,<EOL>remote_endpoint=remote_endpoint,<EOL>shared=(kind == Kind.SERVER and thrift_span.timestamp is None),<EOL>annotations=annotations,<EOL>tags=tags,<EOL>)<EOL>", "docstring": "Decodes a thrift span.\n\n        :param thrift_span: thrift span\n        :type thrift_span: thrift Span object\n        :returns: span builder representing this span\n        :rtype: Span", "id": "f12312:c1:m5"}
{"signature": "def _decode_thrift_annotations(self, thrift_annotations):", "body": "local_endpoint = None<EOL>kind = Kind.LOCAL<EOL>all_annotations = {}<EOL>timestamp = None<EOL>duration = None<EOL>for thrift_annotation in thrift_annotations:<EOL><INDENT>all_annotations[thrift_annotation.value] = thrift_annotation.timestamp<EOL>if thrift_annotation.host:<EOL><INDENT>local_endpoint = self._convert_from_thrift_endpoint(<EOL>thrift_annotation.host,<EOL>)<EOL><DEDENT><DEDENT>if '<STR_LIT>' in all_annotations and '<STR_LIT>' not in all_annotations:<EOL><INDENT>kind = Kind.CLIENT<EOL>timestamp = all_annotations['<STR_LIT>']<EOL>duration = all_annotations['<STR_LIT>'] - all_annotations['<STR_LIT>']<EOL><DEDENT>elif '<STR_LIT>' not in all_annotations and '<STR_LIT>' in all_annotations:<EOL><INDENT>kind = Kind.SERVER<EOL>timestamp = all_annotations['<STR_LIT>']<EOL>duration = all_annotations['<STR_LIT>'] - all_annotations['<STR_LIT>']<EOL><DEDENT>annotations = {<EOL>name: self.seconds(ts) for name, ts in all_annotations.items()<EOL>if name not in _DROP_ANNOTATIONS<EOL>}<EOL>return annotations, local_endpoint, kind, timestamp, duration<EOL>", "docstring": "Accepts a thrift annotation and converts it to a v1 annotation.\n\n        :param thrift_annotations: list of thrift annotations.\n        :type thrift_annotations: list of zipkin_core.Span.Annotation\n        :returns: (annotations, local_endpoint, kind)", "id": "f12312:c1:m2"}
{"signature": "def _convert_from_thrift_endpoint(self, thrift_endpoint):", "body": "ipv4 = None<EOL>ipv6 = None<EOL>port = struct.unpack('<STR_LIT:H>', struct.pack('<STR_LIT:h>', thrift_endpoint.port))[<NUM_LIT:0>]<EOL>if thrift_endpoint.ipv4 != <NUM_LIT:0>:<EOL><INDENT>ipv4 = socket.inet_ntop(<EOL>socket.AF_INET,<EOL>struct.pack('<STR_LIT>', thrift_endpoint.ipv4),<EOL>)<EOL><DEDENT>if thrift_endpoint.ipv6:<EOL><INDENT>ipv6 = socket.inet_ntop(socket.AF_INET6, thrift_endpoint.ipv6)<EOL><DEDENT>return Endpoint(<EOL>service_name=thrift_endpoint.service_name,<EOL>ipv4=ipv4,<EOL>ipv6=ipv6,<EOL>port=port,<EOL>)<EOL>", "docstring": "Accepts a thrift decoded endpoint and converts it to an Endpoint.\n\n        :param thrift_endpoint: thrift encoded endpoint\n        :type thrift_endpoint: thrift endpoint\n        :returns: decoded endpoint\n        :rtype: Encoding", "id": "f12312:c1:m1"}
{"signature": "def _get_protobuf_kind(kind):", "body": "if kind == Kind.CLIENT:<EOL><INDENT>return zipkin_pb2.Span.CLIENT<EOL><DEDENT>elif kind == Kind.SERVER:<EOL><INDENT>return zipkin_pb2.Span.SERVER<EOL><DEDENT>elif kind == Kind.PRODUCER:<EOL><INDENT>return zipkin_pb2.Span.PRODUCER<EOL><DEDENT>elif kind == Kind.CONSUMER:<EOL><INDENT>return zipkin_pb2.Span.CONSUMER<EOL><DEDENT>return None<EOL>", "docstring": "Converts py_zipkin's Kind to Protobuf's Kind.\n\n    :param kind: py_zipkin's Kind.\n    :type kind: py_zipkin.Kind\n    :return: correcponding protobuf's kind value.\n    :rtype: zipkin_pb2.Span.Kind", "id": "f12314:m4"}
{"signature": "def encode_pb_list(pb_spans):", "body": "pb_list = zipkin_pb2.ListOfSpans()<EOL>pb_list.spans.extend(pb_spans)<EOL>return pb_list.SerializeToString()<EOL>", "docstring": "Encode list of protobuf Spans to binary.\n\n    :param pb_spans: list of protobuf Spans.\n    :type pb_spans: list of zipkin_pb2.Span\n    :return: encoded list.\n    :rtype: bytes", "id": "f12314:m1"}
{"signature": "def _convert_annotations(annotations):", "body": "pb_annotations = []<EOL>for value, ts in annotations.items():<EOL><INDENT>pb_annotations.append(zipkin_pb2.Annotation(<EOL>timestamp=int(ts * <NUM_LIT:1000> * <NUM_LIT:1000>),<EOL>value=value,<EOL>))<EOL><DEDENT>return pb_annotations<EOL>", "docstring": "Converts py_zipkin's annotations dict to protobuf.\n\n    :param annotations: annotations dict.\n    :type annotations: dict\n    :return: corresponding protobuf's list of annotations.\n    :rtype: list", "id": "f12314:m6"}
{"signature": "def _convert_endpoint(endpoint):", "body": "pb_endpoint = zipkin_pb2.Endpoint()<EOL>if endpoint.service_name:<EOL><INDENT>pb_endpoint.service_name = endpoint.service_name<EOL><DEDENT>if endpoint.port and endpoint.port != <NUM_LIT:0>:<EOL><INDENT>pb_endpoint.port = endpoint.port<EOL><DEDENT>if endpoint.ipv4:<EOL><INDENT>pb_endpoint.ipv4 = socket.inet_pton(socket.AF_INET, endpoint.ipv4)<EOL><DEDENT>if endpoint.ipv6:<EOL><INDENT>pb_endpoint.ipv6 = socket.inet_pton(socket.AF_INET6, endpoint.ipv6)<EOL><DEDENT>return pb_endpoint<EOL>", "docstring": "Converts py_zipkin's Endpoint to Protobuf's Endpoint.\n\n    :param endpoint: py_zipkins' endpoint to convert.\n    :type endpoint: py_zipkin.encoding.Endpoint\n    :return: corresponding protobuf's endpoint.\n    :rtype: zipkin_pb2.Endpoint", "id": "f12314:m5"}
{"signature": "def send(self, payload):  ", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Sends the encoded payload over the transport.\n\n        :argument payload: encoded list of spans.", "id": "f12316:c0:m1"}
{"signature": "@nox.session(python=['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>@nox.parametrize('<STR_LIT>',<EOL>['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'])<EOL>def compatibility(session, install):", "body": "session.install('<STR_LIT>', '<STR_LIT>')<EOL>session.install(install)<EOL>_run_tests(session)<EOL>", "docstring": "Run the unit test suite with each support library and Python version.", "id": "f12321:m3"}
{"signature": "@nox.session<EOL>def lint(session):", "body": "session.install('<STR_LIT>')<EOL>session.run('<STR_LIT>',<EOL>'<STR_LIT>')<EOL>", "docstring": "Run flake8.\n    Returns a failure if flake8 finds linting errors or sufficiently\n    serious code quality issues.", "id": "f12321:m1"}
{"signature": "@nox.session(python=['<STR_LIT>'])<EOL>def type_check(session):", "body": "session.install('<STR_LIT>', '<STR_LIT>')<EOL>session.install('<STR_LIT>')<EOL>session.run(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>')<EOL>", "docstring": "Run type checking using pytype.", "id": "f12321:m4"}
{"signature": "def text_width(self, text: str) -> float:", "body": "width, _ = self._font.getsize(text)<EOL>return width<EOL>", "docstring": "Returns the width, in pixels, of a string in DejaVu Sans 110pt.", "id": "f12322:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def from_json(f: TextIO) -> '<STR_LIT>':<DEDENT>", "body": "o = json.load(f)<EOL>return PrecalculatedTextMeasurer(o['<STR_LIT>'],<EOL>o['<STR_LIT>'],<EOL>o['<STR_LIT>'])<EOL>", "docstring": "Return a PrecalculatedTextMeasurer given a JSON stream.\n\n        See precalculate_text.py for details on the required format.", "id": "f12323:c0:m2"}
{"signature": "def write_json(f: TextIO, deja_vu_sans_path: str,<EOL>measurer: text_measurer.TextMeasurer,<EOL>encodings: Iterable[str]) -> None:", "body": "supported_characters = list(<EOL>generate_supported_characters(deja_vu_sans_path))<EOL>kerning_characters = '<STR_LIT>'.join(<EOL>generate_encodeable_characters(supported_characters, encodings))<EOL>char_to_length = calculate_character_to_length_mapping(measurer,<EOL>supported_characters)<EOL>pair_to_kerning = calculate_pair_to_kern_mapping(measurer, char_to_length,<EOL>kerning_characters)<EOL>json.dump(<EOL>{'<STR_LIT>': statistics.mean(char_to_length.values()),<EOL>'<STR_LIT>': char_to_length,<EOL>'<STR_LIT>': kerning_characters,<EOL>'<STR_LIT>': pair_to_kerning},<EOL>f, sort_keys=True, indent=<NUM_LIT:1>)<EOL>", "docstring": "Write the data required by PrecalculatedTextMeasurer to a stream.", "id": "f12324:m4"}
{"signature": "def badge(left_text: str, right_text: str, left_link: Optional[str] = None,<EOL>right_link: Optional[str] = None,<EOL>whole_link: Optional[str] = None, logo: Optional[str] = None,<EOL>left_color: str = '<STR_LIT>', right_color: str = '<STR_LIT>',<EOL>measurer: Optional[text_measurer.TextMeasurer] = None,<EOL>embed_logo: bool = False) -> str:", "body": "if measurer is None:<EOL><INDENT>measurer = (<EOL>precalculated_text_measurer.PrecalculatedTextMeasurer<EOL>.default())<EOL><DEDENT>if (left_link or right_link) and whole_link:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>')<EOL><DEDENT>template = _JINJA2_ENVIRONMENT.get_template('<STR_LIT>')<EOL>if logo and embed_logo:<EOL><INDENT>logo = _embed_image(logo)<EOL><DEDENT>svg = template.render(<EOL>left_text=left_text,<EOL>right_text=right_text,<EOL>left_text_width=measurer.text_width(left_text) / <NUM_LIT>,<EOL>right_text_width=measurer.text_width(right_text) / <NUM_LIT>,<EOL>left_link=left_link,<EOL>right_link=right_link,<EOL>whole_link=whole_link,<EOL>logo=logo,<EOL>left_color=_NAME_TO_COLOR.get(left_color, left_color),<EOL>right_color=_NAME_TO_COLOR.get(right_color, right_color),<EOL>)<EOL>xml = minidom.parseString(svg)<EOL>_remove_blanks(xml)<EOL>xml.normalize()<EOL>return xml.documentElement.toxml()<EOL>", "docstring": "Creates a github-style badge as an SVG image.\n\n    >>> badge(left_text='coverage', right_text='23%', right_color='red')\n    '<svg...</svg>'\n    >>> badge(left_text='build', right_text='green', right_color='green',\n    ...       whole_link=\"http://www.example.com/\")\n    '<svg...</svg>'\n\n    Args:\n        left_text: The text that should appear on the left-hand-side of the\n            badge e.g. \"coverage\".\n        right_text: The text that should appear on the right-hand-side of the\n            badge e.g. \"23%\".\n        left_link: The URL that should be redirected to when the left-hand text\n            is selected.\n        right_link: The URL that should be redirected to when the right-hand\n            text is selected.\n        whole_link: The link that should be redirected to when the badge is\n            selected. If set then left_link and right_right may not be set.\n        logo: A url representing a logo that will be displayed inside the\n            badge. Can be a data URL e.g. \"data:image/svg+xml;utf8,<svg...\"\n        left_color: The color of the part of the badge containing the left-hand\n            text. Can be an valid CSS color\n            (see https://developer.mozilla.org/en-US/docs/Web/CSS/color) or a\n            color name defined here:\n            https://github.com/badges/shields/blob/master/lib/colorscheme.json\n        right_color: The color of the part of the badge containing the\n            right-hand text. Can be an valid CSS color\n            (see https://developer.mozilla.org/en-US/docs/Web/CSS/color) or a\n            color name defined here:\n            https://github.com/badges/shields/blob/master/lib/colorscheme.json\n        measurer: A text_measurer.TextMeasurer that can be used to measure the\n            width of left_text and right_text.\n        embed_logo: If True then embed the logo image directly in the badge.\n            This can prevent an HTTP request and some browsers will not render\n            external image referenced. When True, `logo` must be a HTTP/HTTPS\n            URI or a filesystem path. Also, the `badge` call may raise an\n            exception if the logo cannot be loaded, is not an image, etc.", "id": "f12326:m2"}
{"signature": "def split_clspath(clspath):", "body": "return clspath.rsplit('<STR_LIT:.>', <NUM_LIT:1>)<EOL>", "docstring": "Split of clspath into module and class name.\n\n    NOTE(willkg): This is really simple. Maybe we should use something more\n    sophisticated?", "id": "f12343:m3"}
{"signature": "def configure(backends, raise_errors=False):", "body": "good_backends = []<EOL>for backend in backends:<EOL><INDENT>clspath = backend['<STR_LIT:class>']<EOL>options = backend.get('<STR_LIT>', {})<EOL>if isinstance(clspath, str):<EOL><INDENT>modpath, clsname = split_clspath(clspath)<EOL>try:<EOL><INDENT>__import__(modpath)<EOL>module = sys.modules[modpath]<EOL>cls = getattr(module, clsname)<EOL><DEDENT>except Exception:<EOL><INDENT>logger.exception('<STR_LIT>', clspath)<EOL>if raise_errors:<EOL><INDENT>raise<EOL><DEDENT>continue<EOL><DEDENT><DEDENT>else:<EOL><INDENT>cls = clspath<EOL><DEDENT>try:<EOL><INDENT>good_backends.append(cls(options))<EOL><DEDENT>except Exception:<EOL><INDENT>logger.exception(<EOL>'<STR_LIT>',<EOL>clspath,<EOL>options<EOL>)<EOL>if raise_errors:<EOL><INDENT>raise<EOL><DEDENT><DEDENT><DEDENT>_change_metrics(good_backends)<EOL>", "docstring": "Instantiate and configures backends.\n\n    :arg list-of-dicts backends: the backend configuration as a list of dicts where\n        each dict specifies a separate backend.\n\n        Each backend dict consists of two things:\n\n        1. ``class`` with a value that is either a Python class or a dotted\n           Python path to one\n\n        2. ``options`` dict with options for the backend in question to\n           configure it\n\n        See the documentation for the backends you're using to know what is\n        configurable in the options dict.\n\n    :arg raise_errors bool: whether or not to raise an exception if something\n        happens in configuration; if it doesn't raise an exception, it'll log\n        the exception\n\n    For example, this sets up a\n    :py:class:`markus.backends.logging.LoggingMetrics` backend::\n\n        markus.configure([\n            {\n                'class': 'markus.backends.logging.LoggingMetrics',\n                'options': {\n                    'logger_name': 'metrics'\n                }\n            }\n        ])\n\n\n    You can set up as many backends as you like.\n\n    .. Note::\n\n       During application startup, Markus should get configured before the app\n       starts generating metrics. Any metrics generated before Markus is\n       configured will get dropped.\n\n       However, anything can call :py:func:`markus.get_metrics` and get a\n       :py:class:`markus.main.MetricsInterface` before Markus has been\n       configured including at module load time.", "id": "f12343:m4"}
{"signature": "def timer_decorator(self, stat, tags=None):", "body": "def _inner(fun):<EOL><INDENT>@wraps(fun)<EOL>def _timer_decorator(*args, **kwargs):<EOL><INDENT>with self.timer(stat, tags):<EOL><INDENT>return fun(*args, **kwargs)<EOL><DEDENT><DEDENT>return _timer_decorator<EOL><DEDENT>return _inner<EOL>", "docstring": "Timer decorator for easily computing timings.\n\n        :arg string stat: A period delimited alphanumeric key.\n\n        :arg list-of-strings tags: Each string in the tag consists of a key and\n            a value separated by a colon. Tags can make it easier to break down\n            metrics for analysis.\n\n            For example ``['env:stage', 'compressed:yes']``.\n\n        For example:\n\n        >>> mymetrics = get_metrics(__name__)\n\n        >>> @mymetrics.timer_decorator('long_function')\n        ... def long_function():\n        ...     # perform some thing we want to keep metrics on\n        ...     pass\n\n\n        .. Note::\n\n           All timings generated with this are in milliseconds.", "id": "f12343:c0:m7"}
{"signature": "def timing(self, stat, value, tags=None):", "body": "full_stat = self._full_stat(stat)<EOL>for backend in _get_metrics_backends():<EOL><INDENT>backend.timing(full_stat, value=value, tags=tags)<EOL><DEDENT>", "docstring": "Record a timing value.\n\n        Record the length of time of something to be added to a set of values from\n        which a statistical distribution is derived.\n\n        Depending on the backend, you might end up with count, average, median,\n        95% and max for a set of timing values.\n\n        This is useful for analyzing how long things take to occur. For\n        example, how long it takes for a function to run, to upload files, or\n        for a database query to execute.\n\n        :arg string stat: A period delimited alphanumeric key.\n\n        :arg int value: A timing in milliseconds.\n\n        :arg list-of-strings tags: Each string in the tag consists of a key and\n            a value separated by a colon. Tags can make it easier to break down\n            metrics for analysis.\n\n            For example ``['env:stage', 'compressed:yes']``.\n\n        For example:\n\n        >>> import time\n        >>> import markus\n\n        >>> metrics = markus.get_metrics('foo')\n        >>> def upload_file(payload):\n        ...     start_time = time.perf_counter()  # this is in seconds\n        ...     # upload the file\n        ...     timing = (time.perf_counter() - start_time) * 1000.0  # convert to ms\n        ...     metrics.timing('upload_file_time', value=timing)\n\n        .. Note::\n\n           If you're timing a function or a block of code, it's probably more\n           convenient to use :py:meth:`markus.main.MetricsInterface.timer` or\n           :py:meth:`markus.main.MetricsInterface.timer_decorator`.", "id": "f12343:c0:m4"}
{"signature": "def incr(self, stat, value=<NUM_LIT:1>, tags=None):", "body": "full_stat = self._full_stat(stat)<EOL>for backend in _get_metrics_backends():<EOL><INDENT>backend.incr(full_stat, value=value, tags=tags)<EOL><DEDENT>", "docstring": "Incr is used for counting things.\n\n        :arg string stat: A period delimited alphanumeric key.\n\n        :arg int value: A value to increment the count by. Usually this is 1.\n\n        :arg list-of-strings tags: Each string in the tag consists of a key and\n            a value separated by a colon. Tags can make it easier to break down\n            metrics for analysis.\n\n            For example ``['env:stage', 'compressed:yes']``.\n\n        For example:\n\n        >>> import markus\n\n        >>> metrics = markus.get_metrics('foo')\n        >>> def chop_vegetable(kind):\n        ...     # chop chop chop\n        ...     metrics.incr('vegetable', value=1)\n\n        You can also use incr to decrement by passing a negative value.", "id": "f12343:c0:m2"}
{"signature": "def has_record(self, fun_name=None, stat=None, value=None, tags=None):", "body": "return bool(<EOL>self.filter_records(<EOL>fun_name=fun_name,<EOL>stat=stat,<EOL>value=value,<EOL>tags=tags<EOL>)<EOL>)<EOL>", "docstring": "Return True/False regarding whether collected metrics match specified criteria.", "id": "f12344:c0:m10"}
{"signature": "def incr(self, stat, value=<NUM_LIT:1>, tags=None):", "body": "self._add_record(INCR, stat, value, tags)<EOL>", "docstring": "Increment a counter.", "id": "f12344:c0:m2"}
{"signature": "def timing(self, stat, value, tags=None):", "body": "self._add_record(TIMING, stat, value, tags)<EOL>", "docstring": "Measure a timing for statistical distribution.", "id": "f12344:c0:m4"}
{"signature": "def incr(self, stat, value=<NUM_LIT:1>, tags=None):", "body": "self._log('<STR_LIT:count>', stat, value, tags)<EOL>", "docstring": "Increment a counter.", "id": "f12346:c0:m1"}
{"signature": "def timing(self, stat, value, tags=None):", "body": "self.histogram(stat, value, tags)<EOL>", "docstring": "Measure a timing for statistical distribution.\n\n        Note: timing is a special case of histogram.", "id": "f12347:c1:m4"}
{"signature": "def incr(self, stat, value=<NUM_LIT:1>, tags=None):", "body": "self._log('<STR_LIT>', stat, value, tags)<EOL>", "docstring": "Increment a counter.", "id": "f12347:c0:m2"}
{"signature": "def gauge(self, stat, value, tags=None):", "body": "self.rollup()<EOL>self.gauge_stats.setdefault(stat, []).append(value)<EOL>", "docstring": "Set a gauge.", "id": "f12347:c1:m3"}
{"signature": "def incr(self, stat, value=<NUM_LIT:1>, tags=None):", "body": "self.rollup()<EOL>self.incr_stats.setdefault(stat, []).append(value)<EOL>", "docstring": "Increment a counter.", "id": "f12347:c1:m2"}
{"signature": "def timing(self, stat, value, tags=None):", "body": "raise NotImplementedError<EOL>", "docstring": "Implement this. This is a timing-type metric.", "id": "f12348:c0:m3"}
{"signature": "def incr(self, stat, value=<NUM_LIT:1>, tags=None):", "body": "self.client.incr(stat=stat, count=value)<EOL>", "docstring": "Increment a counter.", "id": "f12349:c0:m2"}
{"signature": "def gauge(self, stat, value, tags=None):", "body": "self.client.gauge(metric=stat, value=value, tags=tags)<EOL>", "docstring": "Set a gauge.", "id": "f12350:c0:m3"}
{"signature": "def histogram(self, stat, value, tags=None):", "body": "self.client.histogram(metric=stat, value=value, tags=tags)<EOL>", "docstring": "Measure a value for statistical distribution.", "id": "f12350:c0:m5"}
{"signature": "def incr(self, stat, value=<NUM_LIT:1>, tags=None):", "body": "self.client.increment(metric=stat, value=value, tags=tags)<EOL>", "docstring": "Increment a counter.", "id": "f12350:c0:m2"}
{"signature": "def generate_tag(key, value=None):", "body": "<EOL>if not isinstance(key, six.string_types):<EOL><INDENT>raise ValueError('<STR_LIT>' % key)<EOL><DEDENT>if not isinstance(value, six.string_types + (NONE_TYPE,)):<EOL><INDENT>raise ValueError('<STR_LIT>' % value)<EOL><DEDENT>key = BAD_TAG_CHAR_REGEXP.sub('<STR_LIT:_>', key).strip()<EOL>if value is None or not value.strip():<EOL><INDENT>tag = key<EOL><DEDENT>else:<EOL><INDENT>value = BAD_TAG_CHAR_REGEXP.sub('<STR_LIT:_>', value).strip()<EOL>tag = '<STR_LIT>' % (key, value)<EOL><DEDENT>if tag and not tag[<NUM_LIT:0>].isalpha():<EOL><INDENT>tag = '<STR_LIT:a>' + tag<EOL><DEDENT>tag = tag.lower()[:<NUM_LIT:200>]<EOL>if tag in ['<STR_LIT>', '<STR_LIT:host>', '<STR_LIT:source>']:<EOL><INDENT>tag = tag + '<STR_LIT:_>'<EOL><DEDENT>return tag<EOL>", "docstring": "Generate a tag for use with the tag backends.\n\n    The key and value (if there is one) are sanitized according to the\n    following rules:\n\n    1. after the first character, all characters must be alphanumeric,\n       underscore, minus, period, or slash--invalid characters are converted\n       to \"_\"\n    2. lowercase\n\n    If a value is provided, the final tag is `key:value`.\n\n    The final tag must start with a letter. If it doesn't, an \"a\" is prepended.\n\n    The final tag is truncated to 200 characters.\n\n    If the final tag is \"device\", \"host\", or \"source\", then a \"_\" will be\n    appended the end.\n\n    :arg str key: the key to use\n    :arg str value: the value (if any)\n\n    :returns: the final tag\n\n    Examples:\n\n    >>> generate_tag('yellow')\n    'yellow'\n    >>> generate_tag('rule', 'is_yellow')\n    'rule:is_yellow'\n\n    Example with ``incr``:\n\n    >>> import markus\n    >>> mymetrics = markus.get_metrics(__name__)\n\n    >>> mymetrics.incr('somekey', value=1,\n    ...                tags=[generate_tag('rule', 'is_yellow')])", "id": "f12351:m0"}
{"signature": "def __init__(self, shelve_file='<STR_LIT>'):", "body": "self.ds = shelve.open(shelve_file, writeback=True)<EOL>self.chains = ObjectLikeDbfilenameShelf(self.ds)<EOL>", "docstring": "Args:\n    shelve_file: path to shelve file on disk", "id": "f12388:c3:m0"}
{"signature": "def date(start, end):", "body": "stime = date_to_timestamp(start)<EOL>etime = date_to_timestamp(end)<EOL>ptime = stime + random.random() * (etime - stime)<EOL>return datetime.date.fromtimestamp(ptime)<EOL>", "docstring": "Get a random date between two dates", "id": "f12398:m1"}
{"signature": "def last_name(languages=None):", "body": "choices = []<EOL>languages = languages or ['<STR_LIT>']<EOL>for lang in languages:<EOL><INDENT>samples = _get_lastnames(lang)<EOL>choices.extend(samples)<EOL><DEDENT>return random.choice(choices).title()<EOL>", "docstring": "return a random last name\n\n>>> from mock import patch\n>>> with patch('%s._get_lastnames' % __name__, lambda *args: ['aaa']):\n...     last_name()\n'Aaa'\n>>> with patch('%s.get_lastnames' % __name__, lambda lang: ['%s_lastname'% lang]):\n...     last_name(['it'])\n'It_Lastname'", "id": "f12399:m9"}
{"signature": "def first_name(languages=None, genders=None):", "body": "choices = []<EOL>languages = languages or ['<STR_LIT>']<EOL>genders = genders or [GENDER_MALE, GENDER_FEMALE]<EOL>for lang in languages:<EOL><INDENT>for gender in genders:<EOL><INDENT>samples = _get_firstnames(lang, gender)<EOL>choices.extend(samples)<EOL><DEDENT><DEDENT>return random.choice(choices).title()<EOL>", "docstring": "return a random first name\n:return:\n\n>>> from mock import patch\n>>> with patch('%s._get_firstnamess' % __name__, lambda *args: ['aaa']):\n...     first_name()\n'Aaa'", "id": "f12399:m8"}
{"signature": "def person(languages=None, genders=None):", "body": "languages = languages or ['<STR_LIT>']<EOL>genders = genders or (GENDER_FEMALE, GENDER_MALE)<EOL>lang = random.choice(languages)<EOL>g = random.choice(genders)<EOL>t = title([lang], [g])<EOL>return first_name([lang], [g]), last_name([lang]), t, g<EOL>", "docstring": "returns a random tuple representing person information\n\n.. code-block:: python\n\n    >>> d.person()\n    (u'Derren', u'Powell', 'm')\n    >>> d.person(genders=['f'])\n    (u'Marge', u'Rodriguez', u'Mrs.', 'f')\n    >>> d.person(['es'],['m'])\n    (u'Jacinto', u'Delgado', u'El Sr.', 'm')\n\n:param language:\n:param genders:", "id": "f12399:m5"}
{"signature": "@memoize<EOL>def get_codes():", "body": "cache_filename = os.path.join(os.path.dirname(__file__), '<STR_LIT:data>', '<STR_LIT>')<EOL>data = []<EOL>for line in open(cache_filename, '<STR_LIT:r>'):<EOL><INDENT>if not line.startswith('<STR_LIT:#>'):<EOL><INDENT>data.append(line.split('<STR_LIT:\\t>'))<EOL><DEDENT><DEDENT>return data<EOL>", "docstring": ">> get_codes()\nISO\tISO3\tISO-Numeric\tfips\tCountry\tCapital\tArea(in sq km)\tPopulation\tContinent\ttld\tCurrencyCode\tCurrencyName\tPhone\tPostal Code Format\tPostal Code Regex\tLanguages\tgeonameid\tneighbours\tEquivalentFipsCode", "id": "f12401:m0"}
{"signature": "def ipaddress(not_valid=None):", "body": "not_valid_class_A = not_valid or []<EOL>class_a = [r for r in range(<NUM_LIT:1>, <NUM_LIT>) if r not in not_valid_class_A]<EOL>shuffle(class_a)<EOL>first = class_a.pop()<EOL>return \"<STR_LIT:.>\".join([str(first), str(randrange(<NUM_LIT:1>, <NUM_LIT>)),<EOL>str(randrange(<NUM_LIT:1>, <NUM_LIT>)), str(randrange(<NUM_LIT:1>, <NUM_LIT>))])<EOL>", "docstring": "returns a string representing a random ip address\n\n:param not_valid: if passed must be a list of integers representing valid class A netoworks that must be ignored", "id": "f12403:m0"}
{"signature": "def unique(func, num_args=<NUM_LIT:0>, max_attempts=<NUM_LIT:100>, cache=None):", "body": "if cache is None:<EOL><INDENT>cache = _cache_unique<EOL><DEDENT>@wraps(func)<EOL>def wrapper(*args):<EOL><INDENT>key = \"<STR_LIT>\" % (str(func.__name__), str(args[:num_args]))<EOL>attempt = <NUM_LIT:0><EOL>while attempt < max_attempts:<EOL><INDENT>attempt += <NUM_LIT:1><EOL>drawn = cache.get(key, [])<EOL>result = func(*args)<EOL>if result not in drawn:<EOL><INDENT>drawn.append(result)<EOL>cache[key] = drawn<EOL>return result<EOL><DEDENT><DEDENT>raise MaxAttemptException()<EOL><DEDENT>return wrapper<EOL>", "docstring": "wraps a function so that produce unique results\n\n:param func:\n:param num_args:\n\n>>> import random\n>>> choices = [1,2]\n>>> a = unique(random.choice, 1)\n>>> a,b = a(choices), a(choices)\n>>> a == b\nFalse", "id": "f12407:m4"}
{"signature": "def _get_memoized_value(func, args, kwargs):", "body": "key = (repr(args), repr(kwargs))<EOL>if not key in func._cache_dict:<EOL><INDENT>ret = func(*args, **kwargs)<EOL>func._cache_dict[key] = ret<EOL><DEDENT>return func._cache_dict[key]<EOL>", "docstring": "Used internally by memoize decorator to get/store function results", "id": "f12407:m2"}
{"signature": "def setup(app):", "body": "app.info('<STR_LIT>')<EOL>app.add_role('<STR_LIT>', ghissue_role)<EOL>app.add_role('<STR_LIT>', ghissue_role)<EOL>app.add_role('<STR_LIT>', ghuser_role)<EOL>app.add_role('<STR_LIT>', ghcommit_role)<EOL>app.add_config_value('<STR_LIT>', None, '<STR_LIT>')<EOL>return<EOL>", "docstring": "Install the plugin.\n\n    :param app: Sphinx application context.", "id": "f12413:m4"}
{"signature": "def ghcommit_role(name, rawtext, text, lineno, inliner, options={}, content=[]):", "body": "app = inliner.document.settings.env.app<EOL>try:<EOL><INDENT>base = app.config.github_project_url<EOL>if not base:<EOL><INDENT>raise AttributeError<EOL><DEDENT>if not base.endswith('<STR_LIT:/>'):<EOL><INDENT>base += '<STR_LIT:/>'<EOL><DEDENT><DEDENT>except AttributeError as err:<EOL><INDENT>raise ValueError('<STR_LIT>' % str(err))<EOL><DEDENT>ref = base + text<EOL>node = nodes.reference(rawtext, text[:<NUM_LIT:6>], refuri=ref, **options)<EOL>return [node], []<EOL>", "docstring": "Link to a GitHub commit.\n\n    Returns 2 part tuple containing list of nodes to insert into the\n    document and a list of system messages.  Both are allowed to be\n    empty.\n\n    :param name: The role name used in the document.\n    :param rawtext: The entire markup snippet, with role.\n    :param text: The text marked with the role.\n    :param lineno: The line number where rawtext appears in the input.\n    :param inliner: The inliner instance that called us.\n    :param options: Directive options for customization.\n    :param content: The directive content for customization.", "id": "f12413:m3"}
{"signature": "@st.composite<EOL>def lists_pairs_nodup(draw, elements=IMMUTABLES, min_size=<NUM_LIT:0>, max_size=LISTS_MAX_SIZE):", "body": "n = draw(st.integers(min_value=min_size, max_value=max_size))<EOL>size_n_sets = st.sets(elements, min_size=n, max_size=n)<EOL>keys = draw(size_n_sets)<EOL>vals = draw(size_n_sets)<EOL>return list(izip(keys, vals))<EOL>", "docstring": "Generate a list of pairs from the given elements with no duplication.", "id": "f12416:m1"}
{"signature": "def load_profile(name=getenv('<STR_LIT>') or '<STR_LIT:default>'):", "body": "settings.load_profile(name)<EOL>", "docstring": "Load the Hypothesis profile with the given name.", "id": "f12417:m0"}
{"signature": "@property<EOL><INDENT>def inverse(self):<DEDENT>", "body": "<EOL>if self._inv is not None:<EOL><INDENT>return self._inv<EOL><DEDENT>inv = self._invweak()<EOL>if inv is not None:<EOL><INDENT>return inv<EOL><DEDENT>self._init_inv()  <EOL>return self._inv<EOL>", "docstring": "The inverse of this bidict.\n\n        *See also* :attr:`inv`", "id": "f12423:c0:m4"}
{"signature": "def __len__(self):", "body": "return len(self._fwdm)<EOL>", "docstring": "The number of contained items.", "id": "f12423:c0:m21"}
{"signature": "@classmethod<EOL><INDENT>def _inv_cls(cls):<DEDENT>", "body": "if cls._fwdm_cls is cls._invm_cls:<EOL><INDENT>return cls<EOL><DEDENT>if not getattr(cls, '<STR_LIT>', None):<EOL><INDENT>class _Inv(cls):<EOL><INDENT>_fwdm_cls = cls._invm_cls<EOL>_invm_cls = cls._fwdm_cls<EOL>_inv_cls_ = cls<EOL><DEDENT>_Inv.__name__ = cls.__name__ + '<STR_LIT>'<EOL>cls._inv_cls_ = _Inv<EOL><DEDENT>return cls._inv_cls_<EOL>", "docstring": "The inverse of this bidict type, i.e. one with *_fwdm_cls* and *_invm_cls* swapped.", "id": "f12423:c0:m2"}
{"signature": "def __iter__(self):  ", "body": "<EOL>return iter(self._fwdm)<EOL>", "docstring": "Iterator over the contained items.", "id": "f12423:c0:m22"}
{"signature": "def __copy__(self):", "body": "return self.copy()<EOL>", "docstring": "Used for the copy protocol.\n\n        *See also* the :mod:`copy` module", "id": "f12423:c0:m20"}
{"signature": "def __init__(self, *args, **kw):  ", "body": "<EOL>self._fwdm = self._fwdm_cls()<EOL>self._invm = self._invm_cls()<EOL>self._init_inv()  <EOL>if args or kw:<EOL><INDENT>self._update(True, None, *args, **kw)<EOL><DEDENT>", "docstring": "Make a new bidirectional dictionary.\n        The signature is the same as that of regular dictionaries.\n        Items passed in are added in the order they are passed,\n        respecting the current duplication policies in the process.\n\n        *See also* :attr:`on_dup_key`, :attr:`on_dup_val`, :attr:`on_dup_kv`", "id": "f12423:c0:m0"}
{"signature": "def inverted(arg):", "body": "inv = getattr(arg, '<STR_LIT>', None)<EOL>if callable(inv):<EOL><INDENT>return inv()<EOL><DEDENT>return ((val, key) for (key, val) in _iteritems_mapping_or_iterable(arg))<EOL>", "docstring": "Yield the inverse items of the provided object.\n\n    If *arg* has a :func:`callable` ``__inverted__`` attribute,\n    return the result of calling it.\n\n    Otherwise, return an iterator over the items in `arg`,\n    inverting each item on the fly.\n\n    *See also* :attr:`bidict.BidirectionalMapping.__inverted__`", "id": "f12424:m2"}
{"signature": "def pop(self, key, default=_MISS):", "body": "try:<EOL><INDENT>return self._pop(key)<EOL><DEDENT>except KeyError:<EOL><INDENT>if default is _MISS:<EOL><INDENT>raise<EOL><DEDENT>return default<EOL><DEDENT>", "docstring": "u\"\"\"*x.pop(k[, d]) \u2192 v*\n\n        Remove specified key and return the corresponding value.\n\n        :raises KeyError: if *key* is not found and no *default* is provided.", "id": "f12430:c0:m5"}
{"signature": "def forceput(self, key, val):", "body": "self._put(key, val, self._ON_DUP_OVERWRITE)<EOL>", "docstring": "Associate *key* with *val* unconditionally.\n\nReplace any existing mappings containing key *key* or value *val*\nas necessary to preserve uniqueness.", "id": "f12430:c0:m3"}
{"signature": "def send_message(self, to=None, msg=None):", "body": "url = self.root_url + \"<STR_LIT>\"<EOL>values = {}<EOL>if to is not None:<EOL><INDENT>values[\"<STR_LIT:to>\"] = to<EOL><DEDENT>if msg is not None:<EOL><INDENT>values[\"<STR_LIT>\"] = msg<EOL><DEDENT>return self._query(url, values)<EOL>", "docstring": "method to send a message to a user\n\n            Parameters:\n                to -> recipient\n                msg -> message to send", "id": "f12448:c0:m3"}
{"signature": "def init_parser():", "body": "usage = \"<STR_LIT>\"<EOL>parser = OptionParser(usage, version=\"<STR_LIT>\" + notifo.__version__)<EOL>parser.add_option(\"<STR_LIT>\", \"<STR_LIT>\", action=\"<STR_LIT:store>\", dest=\"<STR_LIT:user>\",<EOL>help=\"<STR_LIT>\")<EOL>parser.add_option(\"<STR_LIT>\", \"<STR_LIT>\", action=\"<STR_LIT:store>\", dest=\"<STR_LIT>\",<EOL>help=\"<STR_LIT>\")<EOL>parser.add_option(\"<STR_LIT>\", \"<STR_LIT>\", action=\"<STR_LIT:store>\", dest=\"<STR_LIT:name>\",<EOL>help=\"<STR_LIT>\")<EOL>parser.add_option(\"<STR_LIT>\", \"<STR_LIT>\", action=\"<STR_LIT:store>\", dest=\"<STR_LIT:label>\",<EOL>help=\"<STR_LIT>\")<EOL>parser.add_option(\"<STR_LIT>\", \"<STR_LIT>\", action=\"<STR_LIT:store>\", dest=\"<STR_LIT:title>\",<EOL>help=\"<STR_LIT>\")<EOL>parser.add_option(\"<STR_LIT:-c>\", \"<STR_LIT>\", action=\"<STR_LIT:store>\", dest=\"<STR_LIT>\",<EOL>help=\"<STR_LIT>\")<EOL>parser.add_option(\"<STR_LIT>\", \"<STR_LIT>\", action=\"<STR_LIT:store_true>\", dest=\"<STR_LIT:message>\",<EOL>default=False, help=\"<STR_LIT>\")<EOL>(options, args) = parser.parse_args()<EOL>return (parser, options, args)<EOL>", "docstring": "function to init option parser", "id": "f12449:m0"}
{"signature": "def publish():", "body": "os.system(\"<STR_LIT>\")<EOL>", "docstring": "Publish to PyPi", "id": "f12450:m0"}
{"signature": "def selector_production(self, tokens):", "body": "validators = []<EOL>if self.peek(tokens, '<STR_LIT:type>'):<EOL><INDENT>type_ = self.match(tokens, '<STR_LIT:type>')<EOL>validators.append(self.type_production(type_))<EOL><DEDENT>if self.peek(tokens, '<STR_LIT>'):<EOL><INDENT>key = self.match(tokens, '<STR_LIT>')<EOL>validators.append(self.key_production(key))<EOL><DEDENT>if self.peek(tokens, '<STR_LIT>'):<EOL><INDENT>pclass = self.match(tokens, '<STR_LIT>')<EOL>validators.append(self.pclass_production(pclass))<EOL><DEDENT>if self.peek(tokens, '<STR_LIT>'):<EOL><INDENT>nth_func = self.match(tokens, '<STR_LIT>')<EOL>validators.append(self.nth_child_production(nth_func, tokens))<EOL><DEDENT>if self.peek(tokens, '<STR_LIT>'):<EOL><INDENT>pclass_func = self.match(tokens, '<STR_LIT>')<EOL>validators.append(self.pclass_func_production(pclass_func, tokens))<EOL><DEDENT>if not len(validators):<EOL><INDENT>raise SelectorSyntaxError('<STR_LIT>')<EOL><DEDENT>results = self._match_nodes(validators, self.obj)<EOL>if self.peek(tokens, '<STR_LIT>'):<EOL><INDENT>operator = self.match(tokens, '<STR_LIT>')<EOL>rvals = self.selector_production(tokens)<EOL>if operator == '<STR_LIT:U+002C>':<EOL><INDENT>results.extend(rvals)<EOL><DEDENT>elif operator == '<STR_LIT:>>':<EOL><INDENT>results = self.parents(results, rvals)<EOL><DEDENT>elif operator == '<STR_LIT>':<EOL><INDENT>results = self.siblings(results, rvals)<EOL><DEDENT>elif operator == '<STR_LIT:U+0020>':<EOL><INDENT>results = self.ancestors(results, rvals)<EOL><DEDENT>else:<EOL><INDENT>raise SelectorSyntaxError(\"<STR_LIT>\"<EOL>% operator)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if len(tokens):<EOL><INDENT>rvals = self.selector_production(tokens)<EOL>results = self.ancestors(results, rvals)<EOL><DEDENT><DEDENT>return results<EOL>", "docstring": "Production for a full selector.", "id": "f12459:c2:m2"}
{"signature": "def select(selector, obj):", "body": "parser = Parser(obj)<EOL>try:<EOL><INDENT>return parser.parse(selector)<EOL><DEDENT>except SelectorSyntaxError as e:<EOL><INDENT>log.exception(e)<EOL>return False<EOL><DEDENT>", "docstring": "Appy selector to obj and return matching nodes.\n\n    If only one node is found, return it, otherwise return a list of matches.\n    Returns False on syntax error. None if no results found.", "id": "f12459:m3"}
{"signature": "def _match_nodes(self, validators, obj):", "body": "results = []<EOL>for node in object_iter(obj):<EOL><INDENT>if all([validate(node) for validate in validators]):<EOL><INDENT>results.append(node)<EOL><DEDENT><DEDENT>return results<EOL>", "docstring": "Apply each validator in validators to each node in obj.\n\n        Return each node in obj which matches all validators.", "id": "f12459:c2:m13"}
{"signature": "def object_iter(obj, parent=None, parent_key=None, idx=None,<EOL>siblings=None):", "body": "obj_node = Node(value=obj, parent=parent, parent_key=parent_key,<EOL>siblings=siblings, idx=idx)<EOL>if isinstance(obj, list):<EOL><INDENT>_siblings = len(obj)<EOL>for i, elem in enumerate(obj):<EOL><INDENT>for node in object_iter(elem, obj_node, None, i + <NUM_LIT:1>, _siblings):<EOL><INDENT>yield node<EOL><DEDENT><DEDENT><DEDENT>elif isinstance(obj, collections.Mapping):<EOL><INDENT>for key in obj:<EOL><INDENT>for node in object_iter(obj[key], obj_node, key):<EOL><INDENT>yield node<EOL><DEDENT><DEDENT><DEDENT>yield obj_node<EOL>", "docstring": "Yields each node of object graph in postorder.", "id": "f12459:m0"}
{"signature": "def parents(self, lhs, rhs):", "body": "return [node for node in rhs if node.parent in lhs]<EOL>", "docstring": "Find nodes in rhs which have parents in lhs.", "id": "f12459:c2:m3"}
{"signature": "def siblings(self, lhs, rhs):", "body": "parents = [node.parent for node in lhs]<EOL>return [node for node in rhs if node.parent in parents]<EOL>", "docstring": "Find nodes in rhs having common parents in lhs.", "id": "f12459:c2:m5"}
{"signature": "def __hash__(self):", "body": "return self.__str__().__hash__()<EOL>", "docstring": "Since the IEML string for any proposition AST is unique, it can be used as a hash", "id": "f12464:c1:m4"}
{"signature": "def p_additive_path_p(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:2>]<EOL>", "docstring": "additive_path_p : LPAREN additive_path RPAREN", "id": "f12477:c0:m9"}
{"signature": "def p_ctx_coords(self, p):", "body": "if len(p) == <NUM_LIT:2>:<EOL><INDENT>p[<NUM_LIT:0>] = [p[<NUM_LIT:1>]]<EOL><DEDENT>else:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>] + [p[<NUM_LIT:3>]]<EOL><DEDENT>", "docstring": "ctx_coords : multiplicative_path\n                        | ctx_coords COLON multiplicative_path", "id": "f12477:c0:m6"}
{"signature": "def p_path_sum(self, p):", "body": "if len(p) == <NUM_LIT:2>:<EOL><INDENT>p[<NUM_LIT:0>] = [p[<NUM_LIT:1>]]<EOL><DEDENT>else:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>] + [p[<NUM_LIT:3>]]<EOL><DEDENT>", "docstring": "path_sum : ctx_path\n                  | path_sum PLUS ctx_path", "id": "f12477:c0:m4"}
{"signature": "def p_morpheme(self, p):", "body": "p[<NUM_LIT:0>] = sorted(p[<NUM_LIT:2>])<EOL>", "docstring": "morpheme : LPAREN word_sum RPAREN", "id": "f12480:c1:m6"}
{"signature": "def p_text(self, p):", "body": "p[<NUM_LIT:0>] = Text(p[<NUM_LIT:2>])<EOL>", "docstring": "text : SLASH closed_proposition_list SLASH", "id": "f12480:c1:m14"}
{"signature": "def p_literal_list(self, p):", "body": "if len(p) == <NUM_LIT:3>:<EOL><INDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>] + [p[<NUM_LIT:2>][<NUM_LIT:1>:-<NUM_LIT:1>]]<EOL><DEDENT>else:<EOL><INDENT>p[<NUM_LIT:0>] = [p[<NUM_LIT:1>][<NUM_LIT:1>:-<NUM_LIT:1>]]<EOL><DEDENT>", "docstring": "literal_list : literal_list LITERAL\n                        | LITERAL", "id": "f12480:c1:m3"}
{"signature": "def p_fact(self, p):", "body": "if len(p) == <NUM_LIT:4>:<EOL><INDENT>p[<NUM_LIT:0>] = Fact(p[<NUM_LIT:2>])<EOL><DEDENT>else:<EOL><INDENT>p[<NUM_LIT:0>] = Fact(p[<NUM_LIT:2>], literals=p[<NUM_LIT:4>])<EOL><DEDENT>", "docstring": "fact : LBRACKET clauses_sum RBRACKET\n                | LBRACKET clauses_sum RBRACKET literal_list", "id": "f12480:c1:m9"}
{"signature": "def pack_factorisation(facto_list):", "body": "_sum = []<EOL>for f in facto_list:<EOL><INDENT>if isinstance(f, Script):<EOL><INDENT>_sum.append(f)<EOL><DEDENT>else:<EOL><INDENT>_sum.append(MultiplicativeScript(children=(pack_factorisation(l_f) for l_f in f)))<EOL><DEDENT><DEDENT>if len(_sum) == <NUM_LIT:1>:<EOL><INDENT>return _sum[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>return AdditiveScript(children=_sum)<EOL><DEDENT>", "docstring": ":param facto_list: list of parser or tuple of factorisation\n:return:", "id": "f12509:m2"}
{"signature": "def p_additive_script_lvl_0(self, p):", "body": "p[<NUM_LIT:0>] = AdditiveScript(children=p[<NUM_LIT:1>])<EOL>", "docstring": "additive_script_lvl_0 : sum_lvl_0", "id": "f12511:c0:m5"}
{"signature": "def p_sum_lvl_1(self, p):", "body": "if len(p) == <NUM_LIT:4>:<EOL><INDENT>p[<NUM_LIT:3>].append(p[<NUM_LIT:1>])<EOL>p[<NUM_LIT:0>] = p[<NUM_LIT:3>]<EOL><DEDENT>else:<EOL><INDENT>p[<NUM_LIT:0>] = [p[<NUM_LIT:1>]]<EOL><DEDENT>", "docstring": "sum_lvl_1 : script_lvl_1\n                    |  script_lvl_1 PLUS sum_lvl_1", "id": "f12511:c0:m8"}
{"signature": "def project_usls_on_dictionary(usls, allowed_terms=None):", "body": "cells_to_usls = defaultdict(set)<EOL>tables = set()<EOL>for u in usls:<EOL><INDENT>for t in u.objects(Term):<EOL><INDENT>for c in t.singular_sequences:<EOL><INDENT>if not cells_to_usls[c]:<EOL><INDENT>tables.update(c.relations.contained)<EOL><DEDENT>cells_to_usls[c].add(u)<EOL><DEDENT><DEDENT><DEDENT>if allowed_terms:<EOL><INDENT>allowed_terms = set(allowed_terms)<EOL>tables = tables & allowed_terms<EOL>cells_to_usls = {c: l for c, l in cells_to_usls.items() if c in allowed_terms}<EOL><DEDENT>tables_to_usls = {<EOL>table: list(set(u for c in table.singular_sequences for u in cells_to_usls[c]))<EOL>for table in tables if not isinstance(table, TableSet)<EOL>}<EOL>return tables_to_usls<EOL>", "docstring": "`usls` is an iterable of usl.\n\n    return a mapping term -> usl list", "id": "f12523:m0"}
{"signature": "def project_usl_with_data(usls_data, metric=None):", "body": "projection = project_usls_on_dictionary(usls_data)<EOL>all_terms = set(c for u in usls_data for t in u.objects(Term) for c in t.singular_sequences)<EOL>if metric is None:<EOL><INDENT>metric = lambda e: len(e['<STR_LIT>']) * len(all_terms.intersection(e['<STR_LIT>'].singular_sequences))<EOL><DEDENT>return sorted(({<EOL>'<STR_LIT>': table,<EOL>'<STR_LIT>': usls,<EOL>'<STR_LIT>': list(set(chain.from_iterable(usls_data[u] for u in usls)))<EOL>} for table, usls in projection.items()), key=metric, reverse=True)<EOL>", "docstring": "usls_data: usl => data[]\n:param usls_data:\n:return:", "id": "f12523:m1"}
{"signature": "def diff(version0, version1):", "body": "version0.load()<EOL>version1.load()<EOL>deleted = set(version0.terms) - set(version1.terms)<EOL>added = set(version1.terms) - set(version0.terms)<EOL>print(\"<STR_LIT>\".format(str(version0)))<EOL>print(\"<STR_LIT:\\n>\".join((\"<STR_LIT>\".format(str(d), version0.translations['<STR_LIT>'][d]) for d in deleted)))<EOL>print(\"<STR_LIT>\".format(str(version1)))<EOL>print(\"<STR_LIT:\\n>\".join((\"<STR_LIT>\".format(str(d), version1.translations['<STR_LIT>'][d]) for d in added)))<EOL>", "docstring": "Display the terms added and removed between two versions\n:param version0:\n:param version1:\n:return:", "id": "f12529:m0"}
{"signature": "def get_derived_terms_from_wiktionnary(descriptor):", "body": "result = {}<EOL>try:<EOL><INDENT>response = urllib.request.urlopen('<STR_LIT>'+ quote_plus(descriptor.rstrip('<STR_LIT>')) + '<STR_LIT>')<EOL><DEDENT>except IOError:<EOL><INDENT>return result<EOL><DEDENT>else:<EOL><INDENT>html = response.read()<EOL>soup = BeautifulSoup(html, '<STR_LIT>')<EOL>for language in (\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\"):<EOL><INDENT>titles_list = [el.attrs[\"<STR_LIT:title>\"] for el in soup.select('<STR_LIT>'%language)if \"<STR_LIT:title>\" in el.attrs]<EOL>if titles_list:  <EOL><INDENT>result[language.lower()] = set(titles_list)<EOL><DEDENT><DEDENT><DEDENT>return result<EOL>", "docstring": ":param descriptor:\n:return: a dict language -> set of str representing the drived t$erm in that language", "id": "f12533:m0"}
{"signature": "def translate_competence_en_curr_data(s):", "body": "subst, attr, mode = s<EOL>attr_s, attr_a, attr_m = attr<EOL>assert isinstance(attr_m, NullScript)<EOL>subst_s, subst_a, subst_m = subst<EOL>assert isinstance(subst_m, NullScript)<EOL>first_M = subst_s.children[<NUM_LIT:0>].children[<NUM_LIT:0>]<EOL>return m(m(mode, m(attr_a)), m(m(m(m(first_M, attr_s.children[<NUM_LIT:0>].children[<NUM_LIT:0>])))), m(m(subst_a)))<EOL>", "docstring": "M:.-O:.-'M:.-wa.e.-'t.-x.-s.y.-',  => t.-x.-s.y.-' wa.e.-', M:M:.-',O:.-',_", "id": "f12534:m18"}
{"signature": "def translate_tisse_intl_col(s):", "body": "subst, attr, mode = s<EOL>return m(m(subst), m(attr), script(\"<STR_LIT>\"))<EOL>", "docstring": "O:M:.-O:M:.-we.h.-' => O:M:.-'O:M:.-'s.o.-k.o.-',", "id": "f12534:m21"}
{"signature": "def translate_formes_visuelles(s):", "body": "def set_bSU_subst(s):<EOL><INDENT>subst, attr, mode = s<EOL>return m(script(\"<STR_LIT>\"), attr, mode)<EOL><DEDENT>if isinstance(s, AdditiveScript):<EOL><INDENT>return AdditiveScript([set_bSU_subst(i) for i in s.children])<EOL><DEDENT>else:<EOL><INDENT>return set_bSU_subst(s)<EOL><DEDENT>", "docstring": "s.u.-'O:M:.-'O:.-',+s.u.-'M:O:.-O:.-'M:.-', => b.-S:.U:.-'O:M:.-'O:.-', + b.-S:.U:.-'M:O:.-O:.-'M:.-',", "id": "f12534:m22"}
{"signature": "def _remove_attr_f(s):", "body": "subst, attr, mode = s<EOL>return m(subst, mode)<EOL>", "docstring": "O:O:.f.F:.- -> O:O:.F:.-", "id": "f12534:m16"}
{"signature": "def _rotate_sc_additive(s):", "body": "if isinstance(s, AdditiveScript):<EOL><INDENT>return AdditiveScript([_rotate_sc(_s) for _s in s])<EOL><DEDENT>else:<EOL><INDENT>return _rotate_sc(s)<EOL><DEDENT>", "docstring": "s.-S:.U:.-'l.-S:.O:.-'n.-S:.U:.-',+M:.-'M:.-'n.-S:.U:.-',  =>\nn.-S:.U:.-'s.-S:.U:.-'l.-S:.O:.-',+n.-S:.U:.-\u2018M:.-\u2018M:.-\u2018,", "id": "f12534:m2"}
{"signature": "def translate_noetic(s):", "body": "subst, attr, mode = s<EOL>return m(script('<STR_LIT>'),<EOL>m(subst.children[<NUM_LIT:0>].children[<NUM_LIT:0>], subst.children[<NUM_LIT:1>].children[<NUM_LIT:0>]),<EOL>m(attr.children[<NUM_LIT:0>].children[<NUM_LIT:0>], attr.children[<NUM_LIT:1>].children[<NUM_LIT:0>]))<EOL>", "docstring": "M:.O:.-O:.O:.-B:.T:.n.-' => s.M:O:.O:O:.-", "id": "f12534:m20"}
{"signature": "def translate_ecosystem_intl_col_tern(s):", "body": "subst, attr, mode = s<EOL>return m(translate_ecosystem_intl_col(subst), m(m(attr)))<EOL>", "docstring": "O:.M:.-M:.-' => s.o.-k.o.-\u2018M:O:.-\u2018,M:.-',_", "id": "f12534:m25"}
{"signature": "def _transfer_substance(s):", "body": "subst, attr, mode = s<EOL>attr0, attr1, attr2 = attr<EOL>assert isinstance(attr1, NullScript) and isinstance(attr2, NullScript)<EOL>subst, subst1, subst2 = subst<EOL>assert isinstance(subst1, NullScript) and isinstance(subst2, NullScript)<EOL>subst0, subst1, subst2 = subst<EOL>assert isinstance(subst2, NullScript)<EOL>return m(m(m(subst0)), m(m(subst1), attr0), mode)<EOL>", "docstring": "E:O:.-M:O:.-t.o.-' => E:.-O:.M:O:.-t.o.-\u2018", "id": "f12534:m6"}
{"signature": "def get_function_url(self, function):", "body": "assert self._opened, \"<STR_LIT>\"<EOL>logging.debug(\"<STR_LIT>\" % repr(function))<EOL>if function in ~self._functions:<EOL><INDENT>functionid = self._functions[:function]<EOL><DEDENT>else:<EOL><INDENT>functionid = uuid.uuid1()<EOL>self._functions[functionid] = function<EOL><DEDENT>return \"<STR_LIT>\" % (self._connectionpool.ownid, functionid.hex)<EOL>", "docstring": "Registers the given callable in the system (if it isn't already)\nand returns the URL that can be used to invoke the given function from remote.", "id": "f12537:c1:m7"}
{"signature": "def pre_connect(self, peer):", "body": "if peer in self._connections:<EOL><INDENT>return defer.succeed(peer)<EOL><DEDENT>else:<EOL><INDENT>d = self._connect(peer, exact_peer=False)<EOL>def connected(p):<EOL><INDENT>return p.peer<EOL><DEDENT>d.addCallback(connected)<EOL>return d<EOL><DEDENT>", "docstring": "Ensures that we have an open connection to the given peer.\n\nReturns the peer id. This should be equal to the given one, but\nit might not if the given peer was, say, the IP and the peer\nactually identifies itself with a host name. The returned peer\nis the real one that should be used. This can be handy if we aren't\n100% sure of the peer's identity.", "id": "f12538:c0:m3"}
{"signature": "def __len__(self):", "body": "return self._len<EOL>", "docstring": "Returns the number of characters in the queue.", "id": "f12540:c0:m6"}
{"signature": "def enqueue(self, s):", "body": "self._parts.append(s)<EOL>self._len += len(s)<EOL>", "docstring": "Append `s` to the queue.\n\nEquivalent to::\n\n    queue += s\n\nif `queue` where a regular string.", "id": "f12540:c0:m1"}
{"signature": "def typehash(typename):", "body": "return binascii.crc32(typename) & <NUM_LIT><EOL>", "docstring": "Transforms a typename to a number.", "id": "f12544:m0"}
{"signature": "def bring_gpio_interrupt_into_userspace():  ", "body": "try:<EOL><INDENT>with open(GPIO_INTERRUPT_DEVICE_VALUE):<EOL><INDENT>return<EOL><DEDENT><DEDENT>except IOError:<EOL><INDENT>with open(GPIO_EXPORT_FILE, '<STR_LIT:w>') as export_file:<EOL><INDENT>export_file.write(str(GPIO_INTERRUPT_PIN))<EOL><DEDENT>wait_until_file_exists(GPIO_INTERRUPT_DEVICE_VALUE)<EOL><DEDENT>", "docstring": "Bring the interrupt pin on the GPIO into Linux userspace.", "id": "f12576:m3"}
{"signature": "def set_gpio_interrupt_edge(edge='<STR_LIT>'):", "body": "<EOL>start_time = time.time()<EOL>time_limit = start_time + FILE_IO_TIMEOUT<EOL>while time.time() < time_limit:<EOL><INDENT>try:<EOL><INDENT>with open(GPIO_INTERRUPT_DEVICE_EDGE, '<STR_LIT:w>') as gpio_edge:<EOL><INDENT>gpio_edge.write(edge)<EOL>return<EOL><DEDENT><DEDENT>except IOError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>", "docstring": "Set the interrupt edge on the userspace GPIO pin.\n\n    :param edge: The interrupt edge ('none', 'falling', 'rising').\n    :type edge: string", "id": "f12576:m5"}
{"signature": "def gpio_interrupts_enable(self):", "body": "try:<EOL><INDENT>bring_gpio_interrupt_into_userspace()<EOL>set_gpio_interrupt_edge()<EOL><DEDENT>except Timeout as e:<EOL><INDENT>raise InterruptEnableException(<EOL>\"<STR_LIT>\" %<EOL>(GPIO_INTERRUPT_PIN, e.message)<EOL>)<EOL><DEDENT>", "docstring": "Enables GPIO interrupts.", "id": "f12576:c6:m0"}
{"signature": "def wait_until_file_exists(filename):", "body": "start_time = time.time()<EOL>time_limit = start_time + FILE_IO_TIMEOUT<EOL>while time.time() < time_limit:<EOL><INDENT>try:<EOL><INDENT>with open(filename):<EOL><INDENT>return<EOL><DEDENT><DEDENT>except IOError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>raise Timeout(\"<STR_LIT>\" % filename)<EOL>", "docstring": "Wait until a file exists.\n\n    :param filename: The name of the file to wait for.\n    :type filename: string", "id": "f12576:m6"}
{"signature": "def __init__(self, bus=<NUM_LIT:0>, chip_select=<NUM_LIT:0>, spi_callback=None, speed_hz=<NUM_LIT>):", "body": "self.bus = bus<EOL>self.chip_select = chip_select<EOL>self.spi_callback = spi_callback<EOL>self.speed_hz = speed_hz<EOL>self.fd = None<EOL>spi_device = \"<STR_LIT>\" % (SPIDEV, self.bus, self.chip_select)<EOL>self.open_fd(spi_device)<EOL>", "docstring": "Initialises the SPI device file descriptor.\n\n        :param bus: The SPI device bus number\n        :type bus: int\n        :param chip_select: The SPI device chip_select number\n        :param chip_select: int\n        :raises: InitError", "id": "f12578:c1:m0"}
{"signature": "def _get_spi_control_byte(self, read_write_cmd):", "body": "<EOL>board_addr_pattern = (self.hardware_addr << <NUM_LIT:1>) & <NUM_LIT><EOL>rw_cmd_pattern = read_write_cmd & <NUM_LIT:1>  <EOL>return <NUM_LIT> | board_addr_pattern | rw_cmd_pattern<EOL>", "docstring": "Returns an SPI control byte.\n\n        The MCP23S17 is a slave SPI device. The slave address contains\n        four fixed bits and three user-defined hardware address bits\n        (if enabled via IOCON.HAEN) (pins A2, A1 and A0) with the\n        read/write bit filling out the control byte::\n\n            +--------------------+\n            |0|1|0|0|A2|A1|A0|R/W|\n            +--------------------+\n             7 6 5 4 3  2  1   0\n\n        :param read_write_cmd: Read or write command.\n        :type read_write_cmd: int", "id": "f12579:c0:m1"}
{"signature": "def read(self, address):", "body": "return self._pyver_read(address)<EOL>", "docstring": "Returns the value of the address specified.\n\n        :param address: The address to read from.\n        :type address: int", "id": "f12579:c0:m2"}
{"signature": "def write_bit(self, value, bit_num, address):", "body": "bit_mask = get_bit_mask(bit_num)<EOL>old_byte = self.read(address)<EOL>if value:<EOL><INDENT>new_byte = old_byte | bit_mask<EOL><DEDENT>else:<EOL><INDENT>new_byte = old_byte & ~bit_mask<EOL><DEDENT>self.write(new_byte, address)<EOL>", "docstring": "Writes the value given to the bit in the address specified.\n\n        :param value: The value to write.\n        :type value: int\n        :param bit_num: The bit number to write to.\n        :type bit_num: int\n        :param address: The address to write to.\n        :type address: int", "id": "f12579:c0:m9"}
{"signature": "def read_bit(self, bit_num, address):", "body": "value = self.read(address)<EOL>bit_mask = get_bit_mask(bit_num)<EOL>return <NUM_LIT:1> if value & bit_mask else <NUM_LIT:0><EOL>", "docstring": "Returns the bit specified from the address.\n\n        :param bit_num: The bit number to read from.\n        :type bit_num: int\n        :param address: The address to read from.\n        :type address: int\n        :returns: int -- the bit value from the address", "id": "f12579:c0:m8"}
{"signature": "def get_bit_num(bit_pattern):", "body": "if bit_pattern == <NUM_LIT:0>:<EOL><INDENT>return None<EOL><DEDENT>bit_num = <NUM_LIT:0>  <EOL>while (bit_pattern & <NUM_LIT:1>) == <NUM_LIT:0>:<EOL><INDENT>bit_pattern = bit_pattern >> <NUM_LIT:1><EOL>bit_num += <NUM_LIT:1><EOL>if bit_num > <NUM_LIT:7>:<EOL><INDENT>bit_num = <NUM_LIT:0><EOL>break<EOL><DEDENT><DEDENT>return bit_num<EOL>", "docstring": "Returns the lowest bit num from a given bit pattern. Returns None if no\n    bits set.\n\n    :param bit_pattern: The bit pattern.\n    :type bit_pattern: int\n    :returns: int -- the bit number\n    :returns: None -- no bits set\n\n    >>> pifacecommon.core.get_bit_num(0)\n    None\n    >>> pifacecommon.core.get_bit_num(0b1)\n    0\n    >>> pifacecommon.core.get_bit_num(0b11000)\n    3", "id": "f12582:m1"}
{"signature": "def get_bit_mask(bit_num):", "body": "return <NUM_LIT:1> << (bit_num)<EOL>", "docstring": "Returns as bit mask with bit_num set.\n\n    :param bit_num: The bit number.\n    :type bit_num: int\n    :returns: int -- the bit mask\n    :raises: RangeError\n\n    >>> bin(pifacecommon.core.get_bit_mask(0))\n    1\n    >>> pifacecommon.core.get_bit_mask(1)\n    2\n    >>> bin(pifacecommon.core.get_bit_mask(3))\n    '0b1000'", "id": "f12582:m0"}
{"signature": "def add_label(self, query_params=None):", "body": "list_json = self.fetch_json(<EOL>uri_path=self.base_uri + '<STR_LIT>',<EOL>http_method='<STR_LIT:POST>',<EOL>query_params=query_params or {}<EOL>)<EOL>return self.create_label(list_json)<EOL>", "docstring": "Create a label for a board. Returns a new Label object.", "id": "f12586:c0:m11"}
{"signature": "def get_organisation(self, **query_params):", "body": "organisation_json = self.get_organisations_json(<EOL>self.base_uri, query_params=query_params)<EOL>return self.create_organisation(organisation_json)<EOL>", "docstring": "Get the Organisation for this board. Returns Organisation object.\n\nReturns:\n    list(Organisation): The organisation attached to this board", "id": "f12586:c0:m8"}
{"signature": "def get_card(self, card_id, **query_params):", "body": "card_json = self.fetch_json(<EOL>uri_path=self.base_uri + '<STR_LIT>' + card_id<EOL>)<EOL>return self.create_card(card_json)<EOL>", "docstring": "Get a Card for a given card id. Returns a Card object.\n\nReturns:\n    Card: The card with the given card_id", "id": "f12586:c0:m5"}
{"signature": "def remove_member(self, member_id):", "body": "return self.fetch_json(<EOL>uri_path=self.base_uri + '<STR_LIT>' % member_id,<EOL>http_method='<STR_LIT>'<EOL>)<EOL>", "docstring": "Remove a member from the organisation.Returns JSON of all members if\nsuccessful or raises an Unauthorised exception if not.", "id": "f12586:c0:m14"}
{"signature": "def add_member(self, email, fullname, membership_type='<STR_LIT>'):", "body": "return self.fetch_json(<EOL>uri_path=self.base_uri + '<STR_LIT>',<EOL>http_method='<STR_LIT>',<EOL>query_params={<EOL>'<STR_LIT:email>': email,<EOL>'<STR_LIT>': fullname,<EOL>'<STR_LIT:type>': membership_type<EOL>}<EOL>)<EOL>", "docstring": "Add a member to the board. Membership type can be normal or admin.\nReturns JSON of all members if successful or raises an Unauthorised\nexception if not.", "id": "f12586:c0:m13"}
{"signature": "def get_checklists(self, **query_params):", "body": "checklists = self.get_checklist_json(self.base_uri,<EOL>query_params=query_params)<EOL>checklists_list = []<EOL>for checklist_json in checklists:<EOL><INDENT>checklists_list.append(self.create_checklist(checklist_json))<EOL><DEDENT>return checklists_list<EOL>", "docstring": "Get the checklists for this card. Returns a list of Checklist objects.\n\nReturns:\n    list(Checklist): The checklists attached to this card", "id": "f12587:c0:m4"}
{"signature": "def add_comment(self, comment_text):", "body": "return self.fetch_json(<EOL>uri_path=self.base_uri + '<STR_LIT>',<EOL>http_method='<STR_LIT:POST>',<EOL>query_params={'<STR_LIT:text>': comment_text}<EOL>)<EOL>", "docstring": "Adds a comment to this card by the current user.", "id": "f12587:c0:m7"}
{"signature": "@add_label.register(label.Label)<EOL><INDENT>def _add_label_from_class(self, label=None):<DEDENT>", "body": "return self.fetch_json(<EOL>uri_path=self.base_uri + '<STR_LIT>',<EOL>http_method='<STR_LIT:POST>',<EOL>query_params={'<STR_LIT:value>': label.id}<EOL>)<EOL>", "docstring": "Add an existing label to this card.", "id": "f12587:c0:m12"}
{"signature": "def add_attachment(self, filename, open_file):", "body": "fields = {<EOL>'<STR_LIT>': self.client.api_key,<EOL>'<STR_LIT>': self.client.user_auth_token<EOL>}<EOL>content_type, body = self.encode_multipart_formdata(<EOL>fields=fields,<EOL>filename=filename,<EOL>file_values=open_file<EOL>)<EOL>return self.fetch_json(<EOL>uri_path=self.base_uri + '<STR_LIT>',<EOL>http_method='<STR_LIT:POST>',<EOL>body=body,<EOL>headers={'<STR_LIT:Content-Type>': content_type},<EOL>)<EOL>", "docstring": "Adds an attachment to this card.", "id": "f12587:c0:m8"}
{"signature": "def get_members(self, **query_params):", "body": "members = self.get_members_json(self.base_uri,<EOL>query_params=query_params)<EOL>members_list = []<EOL>for member_json in members:<EOL><INDENT>members_list.append(self.create_member(member_json))<EOL><DEDENT>return members_list<EOL>", "docstring": "Get all members attached to this organisation. Returns a list of\nMember objects\n\nReturns:\n    list(Member): The members attached to this organisation", "id": "f12588:c0:m3"}
{"signature": "def remove_member(self, member_id):", "body": "return self.fetch_json(<EOL>uri_path=self.base_uri + '<STR_LIT>' % member_id,<EOL>http_method='<STR_LIT>'<EOL>)<EOL>", "docstring": "Remove a member from the organisation.Returns JSON of all members if\nsuccessful or raises an Unauthorised exception if not.", "id": "f12588:c0:m5"}
{"signature": "def get_items(self, query_params=None):", "body": "return self.fetch_json(<EOL>uri_path=self.base_uri + '<STR_LIT>',<EOL>query_params=query_params or {}<EOL>)<EOL>", "docstring": "Get all the items for this label. Returns a list of dictionaries.\nEach dictionary has the values for an item.", "id": "f12589:c0:m2"}
{"signature": "def get_label_information(self, query_params=None):", "body": "return self.fetch_json(<EOL>uri_path=self.base_uri,<EOL>query_params=query_params or {}<EOL>)<EOL>", "docstring": "Get all information for this Label. Returns a dictionary of values.", "id": "f12589:c0:m1"}
{"signature": "def create_list(self, list_json, **kwargs):", "body": "return self.client.create_list(list_json, **kwargs)<EOL>", "docstring": "Create List object from JSON object\n\nReturns:\n    List: The list from the given `list_json`.", "id": "f12590:c0:m16"}
{"signature": "def get_authorisation_url(self, application_name, token_expire='<STR_LIT>'):", "body": "query_params = {<EOL>'<STR_LIT:name>': application_name,<EOL>'<STR_LIT>': token_expire,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'<EOL>}<EOL>authorisation_url = self.build_uri(<EOL>path='<STR_LIT>',<EOL>query_params=self.add_authorisation(query_params)<EOL>)<EOL>print('<STR_LIT>'<EOL>'<STR_LIT>', authorisation_url)<EOL>return authorisation_url<EOL>", "docstring": "Returns a URL that needs to be opened in a browser to retrieve an\naccess token.", "id": "f12591:c0:m1"}
{"signature": "def singledispatchmethod(method):", "body": "dispatcher = singledispatch(method)<EOL>def wrapper(*args, **kw):<EOL><INDENT>return dispatcher.dispatch(args[<NUM_LIT:1>].__class__)(*args, **kw)<EOL><DEDENT>wrapper.register = dispatcher.register<EOL>update_wrapper(wrapper, dispatcher)<EOL>return wrapper<EOL>", "docstring": "Enable singledispatch for class methods.\n\nSee http://stackoverflow.com/a/24602374/274318", "id": "f12592:m0"}
{"signature": "def get_board(self):", "body": "board_json = self.get_board_json(self.base_uri)<EOL>return self.create_board(board_json)<EOL>", "docstring": "Get the board that this list belongs to. Returns a Board object.\n\nReturns:\n    Board: The board this list is attached to", "id": "f12593:c0:m2"}
{"signature": "def update_list(self, query_params=None):", "body": "list_json = self.fetch_json(<EOL>uri_path=self.base_uri,<EOL>http_method='<STR_LIT>',<EOL>query_params=query_params or {}<EOL>)<EOL>return self.create_list(list_json)<EOL>", "docstring": "Update information for this list. Returns a new List object.", "id": "f12593:c0:m4"}
{"signature": "def get_board(self, id, name=None):", "body": "return self.create_board(dict(id=id, name=name))<EOL>", "docstring": "Get a board\n\nReturns:\n    Board: The board with the given `id`", "id": "f12594:c0:m15"}
{"signature": "def clean_path(self, path):", "body": "if path[<NUM_LIT:0>] != '<STR_LIT:/>':<EOL><INDENT>path = '<STR_LIT:/>' + path<EOL><DEDENT>return path<EOL>", "docstring": "Ensure the path has a preceding /", "id": "f12594:c0:m2"}
{"signature": "def get_list(self, id, name=None):", "body": "return self.create_list(dict(id=id, name=name))<EOL>", "docstring": "Get a list\n\nReturns:\n    List: The list with the given `id`", "id": "f12594:c0:m16"}
{"signature": "def create_organisation(self, organisation_json):", "body": "return trolly.organisation.Organisation(<EOL>trello_client=self,<EOL>organisation_id=organisation_json['<STR_LIT:id>'],<EOL>name=organisation_json['<STR_LIT:name>'],<EOL>data=organisation_json,<EOL>)<EOL>", "docstring": "Create an Organisation object from a JSON object\n\nReturns:\n    Organisation: The organisation from the given `organisation_json`.", "id": "f12594:c0:m6"}
{"signature": "def check_errors(self, uri, response):", "body": "if response.status == <NUM_LIT>:<EOL><INDENT>raise trolly.Unauthorised(uri, response)<EOL><DEDENT>if response.status != <NUM_LIT:200>:<EOL><INDENT>raise trolly.ResourceUnavailable(uri, response)<EOL><DEDENT>", "docstring": "Check HTTP reponse for known errors", "id": "f12594:c0:m3"}
{"signature": "def create_board(self, board_json):", "body": "return trolly.board.Board(<EOL>trello_client=self,<EOL>board_id=board_json['<STR_LIT:id>'],<EOL>name=board_json['<STR_LIT:name>'],<EOL>data=board_json,<EOL>)<EOL>", "docstring": "Create Board object from a JSON object\n\nReturns:\n    Board: The board from the given `board_json`.", "id": "f12594:c0:m7"}
{"signature": "def get_checklist(self, id, name=None):", "body": "return self.create_checklist(dict(id=id, name=name))<EOL>", "docstring": "Get a checklist\n\nReturns:\n    Checklist: The checklist with the given `id`", "id": "f12594:c0:m18"}
{"signature": "def get_card(self, id, name=None):", "body": "return self.create_card(dict(id=id, name=name))<EOL>", "docstring": "Get a card\n\nReturns:\n    Card: The card with the given `id`", "id": "f12594:c0:m17"}
{"signature": "def create_checklist_item(self, card_id, checklist_id, checklistitem_json):", "body": "return trolly.checklist.ChecklistItem(<EOL>trello_client=self,<EOL>card_id=card_id,<EOL>checklist_id=checklist_id,<EOL>checklistitem_id=checklistitem_json['<STR_LIT:id>'].encode('<STR_LIT:utf-8>'),<EOL>name=checklistitem_json['<STR_LIT:name>'].encode('<STR_LIT:utf-8>'),<EOL>state=checklistitem_json['<STR_LIT:state>'].encode('<STR_LIT:utf-8>')<EOL>)<EOL>", "docstring": "Create a ChecklistItem object from JSON object", "id": "f12594:c0:m12"}
{"signature": "def create_new_board(self, query_params=None):", "body": "board_json = self.fetch_json(<EOL>uri_path='<STR_LIT>',<EOL>http_method='<STR_LIT:POST>',<EOL>query_params=query_params or {}<EOL>)<EOL>return self.create_board(board_json)<EOL>", "docstring": "Create a new board. name is required in query_params. Returns a Board\nobject.\n\nReturns:\n    Board: Returns the created board", "id": "f12595:c0:m5"}
{"signature": "def get_checklist_information(self, query_params=None):", "body": "<EOL>return self.fetch_json(<EOL>uri_path=self.base_uri,<EOL>query_params=query_params or {}<EOL>)<EOL>", "docstring": "Get all information for this Checklist. Returns a dictionary of values.", "id": "f12597:c0:m1"}
{"signature": "def add_item(self, query_params=None):", "body": "return self.fetch_json(<EOL>uri_path=self.base_uri + '<STR_LIT>',<EOL>http_method='<STR_LIT:POST>',<EOL>query_params=query_params or {}<EOL>)<EOL>", "docstring": "Add an item to this checklist. Returns a dictionary of values of new\nitem.", "id": "f12597:c0:m6"}
{"signature": "def update(self, data={}, options={}):", "body": "<EOL>for key in options:<EOL><INDENT>self[key] = options[key]<EOL><DEDENT>if isinstance(data, ConfigNode):<EOL><INDENT>data = data._get_value()<EOL><DEDENT>update_dict(self._get_value(), data)<EOL>", "docstring": "Update the configuration with new data.\n\nThis can be passed either or both `data` and `options`.\n\n`options` is a dict of keypath/value pairs like this (similar to\nCherryPy's config mechanism:\n\n    >>> c.update(options={\n    ...     'server.port': 8080,\n    ...     'server.host': 'localhost',\n    ...     'admin.email': 'admin@lol'\n    ... })\n\n`data` is a dict of actual config data, like this:\n\n    >>> c.update(data={\n    ...     'server': {\n    ...         'port': 8080,\n    ...         'host': 'localhost'\n    ...     },\n    ...     'admin': {\n    ...         'email': 'admin@lol'\n    ...     }\n    ... })", "id": "f12608:c0:m25"}
{"signature": "def update_dict(target, source):", "body": "for k,v in source.items():<EOL><INDENT>if isinstance(v, dict) and k in target and isinstance(source[k], dict):<EOL><INDENT>update_dict(target[k], v)<EOL><DEDENT>else:<EOL><INDENT>target[k] = v<EOL><DEDENT><DEDENT>", "docstring": "Recursively merge values from a nested dictionary into another nested\ndictionary.\n\nFor example:\n\n>>> target = {\n...     'thing': 123,\n...     'thang': {\n...         'a': 1,\n...         'b': 2\n...     }\n... }\n>>> source = {\n...     'thang': {\n...         'a': 666,\n...         'c': 777\n...     }\n... }\n>>> update_dict(target, source)\n>>> target\n{\n    'thing': 123,\n    'thang': {\n        'a': 666,\n        'b': 2,\n        'c': 777\n    }\n}", "id": "f12608:m0"}
{"signature": "def load(self, reload=False):", "body": "if reload or not self._loaded:<EOL><INDENT>if self._defaults_file and type(self._defaults_file) == str:<EOL><INDENT>self._defaults_file = File(self._defaults_file, parent=self._parent)<EOL><DEDENT>defaults = {}<EOL>if self._defaults_file:<EOL><INDENT>defaults = yaml.safe_load(self._defaults_file.read().replace('<STR_LIT:\\t>', '<STR_LIT:U+0020>'))<EOL><DEDENT>data = {}<EOL>if self.exists:<EOL><INDENT>data = yaml.safe_load(self.read().replace('<STR_LIT:\\t>', '<STR_LIT:U+0020>'))<EOL><DEDENT>self._defaults = defaults<EOL>self._data = copy.deepcopy(self._defaults)<EOL>self.update(data=data)<EOL>if self._apply_env:<EOL><INDENT>self.update(ConfigEnv(self._env_prefix))<EOL><DEDENT>self._loaded = True<EOL><DEDENT>return self<EOL>", "docstring": "Load the config and defaults from files.", "id": "f12608:c3:m1"}
{"signature": "def to_dict(self):", "body": "return self._get_value()<EOL>", "docstring": "Generate a plain dictionary.", "id": "f12608:c0:m27"}
{"signature": "@property<EOL><INDENT>def path(self):<DEDENT>", "body": "p = '<STR_LIT>'<EOL>if self._parent and self._parent.path:<EOL><INDENT>p = os.path.join(p, self._parent.path)<EOL><DEDENT>if self._base:<EOL><INDENT>p = os.path.join(p, self._base)<EOL><DEDENT>if self._path:<EOL><INDENT>p = os.path.join(p, self._path)<EOL><DEDENT>return p<EOL>", "docstring": "Return the path to this directory.", "id": "f12610:c6:m6"}
{"signature": "@property<EOL><INDENT>def exists(self):<DEDENT>", "body": "return os.path.exists(self.path)<EOL>", "docstring": "Check if the directory exists.", "id": "f12610:c6:m12"}
{"signature": "def prepare(self):", "body": "if self._create:<EOL><INDENT>self.create()<EOL><DEDENT>for k in self._children:<EOL><INDENT>self._children[k]._env = self._env<EOL>self._children[k].prepare()<EOL><DEDENT>", "docstring": "Prepare the Directory for use in an Environment.\n\nThis will create the directory if the create flag is set.", "id": "f12610:c6:m9"}
{"signature": "@property<EOL><INDENT>def content(self):<DEDENT>", "body": "return yaml.safe_load(self.read())<EOL>", "docstring": "Parse the file contents into a dictionary.", "id": "f12610:c3:m0"}
{"signature": "def write(self, filename, data, mode='<STR_LIT:w>'):", "body": "with open(self.path_to(str(filename)), mode) as f:<EOL><INDENT>f.write(data)<EOL><DEDENT>", "docstring": "Write to a file in the directory.", "id": "f12610:c6:m14"}
{"signature": "def add(self, *args, **kwargs):", "body": "for key in kwargs:<EOL><INDENT>if isinstance(kwargs[key], str):<EOL><INDENT>self._children[key] = File(kwargs[key])<EOL><DEDENT>else:<EOL><INDENT>self._children[key] = kwargs[key]<EOL><DEDENT>self._children[key]._parent = self<EOL>self._children[key]._env = self._env<EOL><DEDENT>added = []<EOL>for arg in args:<EOL><INDENT>if isinstance(arg, File):<EOL><INDENT>self._children[arg.name] = arg<EOL>self._children[arg.name]._parent = self<EOL>self._children[arg.name]._env = self._env<EOL><DEDENT>elif isinstance(arg, str):<EOL><INDENT>f = File(arg)<EOL>added.append(f)<EOL>self._children[arg] = f<EOL>self._children[arg]._parent = self<EOL>self._children[arg]._env = self._env<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(type(arg))<EOL><DEDENT><DEDENT>if len(added) == <NUM_LIT:1>:<EOL><INDENT>return added[<NUM_LIT:0>]<EOL><DEDENT>if len(args) == <NUM_LIT:1>:<EOL><INDENT>return args[<NUM_LIT:0>]<EOL><DEDENT>", "docstring": "Add objects to the directory.", "id": "f12610:c6:m16"}
{"signature": "def write(self, data, mode='<STR_LIT:w>'):", "body": "with open(self.path, mode) as f:<EOL><INDENT>f.write(data)<EOL><DEDENT>", "docstring": "Write data to the file.\n\n`data` is the data to write\n`mode` is the mode argument to pass to `open()`", "id": "f12610:c0:m15"}
{"signature": "def remove(self, recursive=True, ignore_error=True):", "body": "try:<EOL><INDENT>if recursive or self._cleanup == '<STR_LIT>':<EOL><INDENT>shutil.rmtree(self.path)<EOL><DEDENT>else:<EOL><INDENT>os.rmdir(self.path)<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>if not ignore_error:<EOL><INDENT>raise e<EOL><DEDENT><DEDENT>", "docstring": "Remove the directory.", "id": "f12610:c6:m8"}
{"signature": "def prepare(self):", "body": "super(PluginDirectory, self).prepare()<EOL>self.load()<EOL>", "docstring": "Preparing a plugin directory just loads the plugins.", "id": "f12610:c7:m0"}
{"signature": "def cleanup(self):", "body": "if self._cleanup:<EOL><INDENT>self.remove()<EOL><DEDENT>", "docstring": "Clean up the file after use in an Environment or Directory.\n\nThis will remove the file if the cleanup flag is set.", "id": "f12610:c0:m8"}
{"signature": "def cleanup(self):", "body": "for key in self._children:<EOL><INDENT>self._children[key].cleanup()<EOL><DEDENT>", "docstring": "Clean up the environment", "id": "f12611:c0:m7"}
{"signature": "def add(self, **kwargs):", "body": "for key in kwargs:<EOL><INDENT>if type(kwargs[key]) == str:<EOL><INDENT>self._children[key] = Directory(kwargs[key])<EOL><DEDENT>else:<EOL><INDENT>self._children[key] = kwargs[key]<EOL><DEDENT>self._children[key]._env = self<EOL>self._children[key].apply_config(ConfigApplicator(self.config))<EOL>self._children[key].prepare()<EOL><DEDENT>", "docstring": "Add objects to the environment.", "id": "f12611:c0:m6"}
{"signature": "def save(self):", "body": "with open(self.path, '<STR_LIT:w>') as f:<EOL><INDENT>f.write(yaml.dump(dict(self.d)))<EOL><DEDENT>", "docstring": "Save the state to a file.", "id": "f12612:c0:m6"}
{"signature": "@cli.command('<STR_LIT>')<EOL>@click.argument('<STR_LIT>', nargs=<NUM_LIT:1>, type=int)<EOL>def cmd_encode(integer):", "body": "encode(integer)<EOL>", "docstring": "Encode an integer up to 64 bit to Varint.", "id": "f12622:m1"}
{"signature": "def dump(ofp, *pb_objs, **kwargs):", "body": "mode = '<STR_LIT:wb>'<EOL>if isinstance(ofp, str):<EOL><INDENT>ostream = open(ofp, mode=mode, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>ostream = open(fileobj=ofp, mode=mode, **kwargs)<EOL><DEDENT>with ostream:<EOL><INDENT>ostream.write(*pb_objs)<EOL><DEDENT>", "docstring": "Write to a stream.\n\n    Args:\n        ofp (string or file-like object): output stream.\n        pb_objs (*protobuf.message.Message): list of protobuf message objects\n            to be written.", "id": "f12624:m1"}
{"signature": "def __enter__(self):", "body": "return self<EOL>", "docstring": "Enter the runtime context related to Stream class. It will be\n        automatically run by `with` statement.", "id": "f12624:c0:m1"}
{"signature": "def write(self, *pb2_obj):", "body": "base = len(self._write_buff)<EOL>for idx, obj in enumerate(pb2_obj):<EOL><INDENT>if self._buffer_size > <NUM_LIT:0> and(idx + base) != <NUM_LIT:0> and(idx + base) % self._buffer_size == <NUM_LIT:0>:<EOL><INDENT>self.flush()<EOL><DEDENT>self._write_buff.append(obj)<EOL><DEDENT>if self._buffer_size == <NUM_LIT:0>:<EOL><INDENT>self.flush()<EOL><DEDENT>", "docstring": "Write a group of one or more protobuf objects to the file. Multiple\n        object groups can be written by calling this method several times\n        before closing stream or exiting the runtime context.\n\n        The input protobuf objects get buffered and will be written down when\n        the number of buffered objects exceed the `self._buffer_size`.\n\n        Args:\n            pb2_obj (*protobuf.message.Message): list of protobuf messages.", "id": "f12624:c0:m8"}
{"signature": "def write_objs2(fpath, *objs_list, **kwargs):", "body": "mode = '<STR_LIT:wb>'<EOL>if kwargs.get('<STR_LIT>', True):<EOL><INDENT>ofs = gzip.open(fpath, mode)<EOL><DEDENT>else:<EOL><INDENT>ofs = open(fpath, mode)<EOL><DEDENT>with ofs:<EOL><INDENT>ostream = stream.open(fileobj=ofs, mode='<STR_LIT:wb>',<EOL>buffer_size=(len(objs_list)//<NUM_LIT:2>), **kwargs)<EOL>ostream.write(*objs_list)<EOL>ostream.close()<EOL><DEDENT>", "docstring": "Write protobuf message objects into the file w/o using `with` statement.\n\n    It writes half of them in one group, and then the other half in another one\n    by setting buffer size to half of the object list size.\n\n    NOTE: Does the same as `write_objs1`.\n\n    Args:\n        fpath (string): path of the file to be written.\n        objs_list (*protobuf.message.Message): list of objects to be written.", "id": "f12626:m3"}
{"signature": "def tearDown(self):", "body": "if os.path.exists(self.connection.cache_directory):<EOL><INDENT>shutil.rmtree(self.connection.cache_directory)<EOL><DEDENT>", "docstring": "Clean up by removing the test image that was downloaded.", "id": "f12630:c0:m2"}
{"signature": "def text_visible(self):", "body": "<EOL>words = self.read().split()<EOL>for word in words:<EOL><INDENT>if word.lstrip('<STR_LIT:->').replace('<STR_LIT:.>', '<STR_LIT>', <NUM_LIT:1>).isdigit():<EOL><INDENT>return True<EOL><DEDENT>if word.isalpha() and (len(word) > <NUM_LIT:1> or len(word) <= <NUM_LIT:20>):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Returns true or false based on if the OCR process has read\nactual words. This is needed to prevent non-words from being\nadded to the queue since the ocr process can sometimes return\nvalues that are not meaningfull.", "id": "f12633:c0:m2"}
{"signature": "def read(self):", "body": "<EOL>if self.connection.has_changed():<EOL><INDENT>image_path = self.connection.download_image()<EOL>image = Image.open(image_path)<EOL>self.text_cache = pytesseract.image_to_string(image)<EOL>image.close()<EOL><DEDENT>return self.text_cache<EOL>", "docstring": "Returns the text from an image at a given url.", "id": "f12633:c0:m1"}
{"signature": "def download_image(self):", "body": "split = urlsplit(self.url)<EOL>filename = split.path.split(\"<STR_LIT:/>\")[-<NUM_LIT:1>]<EOL>if not os.path.exists(self.cache_directory):<EOL><INDENT>os.makedirs(self.cache_directory)<EOL><DEDENT>filepath = os.path.join(self.cache_directory, filename)<EOL>data = urllib_request.urlopen(self.url)<EOL>with open(filepath, \"<STR_LIT:wb>\") as image:<EOL><INDENT>image.write(data.read())<EOL><DEDENT>return filepath<EOL>", "docstring": "Download the image and return the\nlocal path to the image file.", "id": "f12636:c0:m1"}
{"signature": "def get_version(package):", "body": "init_py = open(os.path.join(package, '<STR_LIT>')).read()<EOL>return re.search(\"<STR_LIT>\", init_py).group(<NUM_LIT:1>)<EOL>", "docstring": "Return package version as listed in `__version__` in `init.py`.", "id": "f12649:m0"}
{"signature": "def integrate_ivp(u0=<NUM_LIT:1.0>, v0=<NUM_LIT:0.0>, mu=<NUM_LIT:1.0>, tend=<NUM_LIT>, dt0=<NUM_LIT>, nt=<NUM_LIT:0>,<EOL>nsteps=<NUM_LIT>, t0=<NUM_LIT:0.0>, atol=<NUM_LIT>, rtol=<NUM_LIT>, plot=False,<EOL>savefig='<STR_LIT:None>', method='<STR_LIT>', dpi=<NUM_LIT:100>, verbose=False):", "body": "f, j = get_f_and_j(mu)<EOL>if nt > <NUM_LIT:1>:<EOL><INDENT>tout = np.linspace(t0, tend, nt)<EOL>yout, nfo = integrate_predefined(<EOL>f, j, [u0, v0], tout, dt0, atol, rtol, nsteps=nsteps,<EOL>check_indexing=False, method=method)<EOL><DEDENT>else:<EOL><INDENT>tout, yout, nfo = integrate_adaptive(<EOL>f, j, [u0, v0], t0, tend, dt0, atol, rtol, nsteps=nsteps,<EOL>check_indexing=False, method=method)  <EOL><DEDENT>if verbose:<EOL><INDENT>print(nfo)<EOL><DEDENT>if plot:<EOL><INDENT>import matplotlib.pyplot as plt<EOL>plt.plot(tout, yout[:, <NUM_LIT:1>], '<STR_LIT>')<EOL>plt.plot(tout, yout[:, <NUM_LIT:0>], '<STR_LIT>', linewidth=<NUM_LIT:2>)<EOL>if savefig == '<STR_LIT:None>':<EOL><INDENT>plt.show()<EOL><DEDENT>else:<EOL><INDENT>plt.savefig(savefig, dpi=dpi)<EOL><DEDENT><DEDENT>", "docstring": "Example program integrating an IVP problem of van der Pol oscillator", "id": "f12663:m1"}
{"signature": "def _gravity_f_j_jtimes(g):", "body": "def f(t, y, fout):<EOL><INDENT>x, v = y<EOL>fout[<NUM_LIT:0>] = v<EOL>fout[<NUM_LIT:1>] = -g<EOL><DEDENT>def jac(t, y, jmat_out, dfdx_out=None, fy=None):<EOL><INDENT>jmat_out[<NUM_LIT:0>, <NUM_LIT:0>] = <NUM_LIT:0><EOL>jmat_out[<NUM_LIT:0>, <NUM_LIT:1>] = <NUM_LIT:1><EOL>jmat_out[<NUM_LIT:1>, <NUM_LIT:0>] = <NUM_LIT:0><EOL>jmat_out[<NUM_LIT:0>, <NUM_LIT:1>] = <NUM_LIT:0><EOL><DEDENT>def jtimes(v, Jv, t, y, fy, user_data=None, tmp=None):<EOL><INDENT>Jv[<NUM_LIT:0>] = v[<NUM_LIT:1>]<EOL>Jv[<NUM_LIT:1>] = <NUM_LIT:0><EOL><DEDENT>return f, jac, jtimes<EOL>", "docstring": "RHS, jacobian, and jacobian-vector product for\n        particle falling under influence of gravity", "id": "f12666:m7"}
{"signature": "def get_duration(self, seconds):", "body": "duration = \"<STR_LIT>\"<EOL>minutes, seconds = divmod(seconds, <NUM_LIT>)<EOL>if minutes >= <NUM_LIT>:<EOL><INDENT>hours, minutes = divmod(minutes, <NUM_LIT>)<EOL>duration = \"<STR_LIT>\" % hours<EOL><DEDENT>duration += \"<STR_LIT>\" % (minutes, seconds)<EOL>return duration<EOL>", "docstring": "Transform duration into a human-readable form.", "id": "f12673:c0:m3"}
{"signature": "def to_basestring(value):", "body": "if isinstance(value, _BASESTRING_TYPES):<EOL><INDENT>return value<EOL><DEDENT>assert isinstance(value, bytes)<EOL>return value.decode(\"<STR_LIT:utf-8>\")<EOL>", "docstring": "Converts a string argument to a subclass of basestring.\n\n    In python2, byte and unicode strings are mostly interchangeable,\n    so functions that deal with a user-supplied argument in combination\n    with ascii string constants can use either and should return the type\n    the user supplied.  In python3, the two types are not interchangeable,\n    so this method is needed to convert byte strings to unicode.", "id": "f12678:m8"}
{"signature": "def xhtml_escape(value):", "body": "return _XHTML_ESCAPE_RE.sub(lambda match: _XHTML_ESCAPE_DICT[match.group(<NUM_LIT:0>)],<EOL>to_basestring(value))<EOL>", "docstring": "Escapes a string so it is valid within XML or XHTML.", "id": "f12678:m0"}
{"signature": "def xhtml_unescape(value):", "body": "return re.sub(r\"<STR_LIT>\", _convert_entity, _unicode(value))<EOL>", "docstring": "Un-escapes an XML-escaped string.", "id": "f12678:m1"}
{"signature": "def to_unicode(value):", "body": "if isinstance(value, _TO_UNICODE_TYPES):<EOL><INDENT>return value<EOL><DEDENT>assert isinstance(value, bytes)<EOL>return value.decode(\"<STR_LIT:utf-8>\")<EOL>", "docstring": "Converts a string argument to a unicode string.\n\n    If the argument is already a unicode string or None, it is returned\n    unchanged.  Otherwise it must be a byte string and is decoded as utf8.", "id": "f12678:m7"}
{"signature": "def facebook_request(self, method, callback, **args):", "body": "self.require_setting(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>self.require_setting(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>if not method.startswith(\"<STR_LIT>\"):<EOL><INDENT>method = \"<STR_LIT>\" + method<EOL><DEDENT>args[\"<STR_LIT>\"] = self.settings[\"<STR_LIT>\"]<EOL>args[\"<STR_LIT:v>\"] = \"<STR_LIT:1.0>\"<EOL>args[\"<STR_LIT>\"] = method<EOL>args[\"<STR_LIT>\"] = str(long(time.time() * <NUM_LIT>))<EOL>args[\"<STR_LIT>\"] = \"<STR_LIT>\"<EOL>args[\"<STR_LIT>\"] = self._signature(args)<EOL>url = \"<STR_LIT>\" +urllib.urlencode(args)<EOL>http = httpclient.AsyncHTTPClient()<EOL>http.fetch(url, callback=self.async_callback(<EOL>self._parse_response, callback))<EOL>", "docstring": "Makes a Facebook API REST request.\n\n        We automatically include the Facebook API key and signature, but\n        it is the callers responsibility to include 'session_key' and any\n        other required arguments to the method.\n\n        The available Facebook methods are documented here:\n        http://wiki.developers.facebook.com/index.php/API\n\n        Here is an example for the stream.get() method::\n\n            class MainHandler(tornado.web.RequestHandler,\n                              tornado.auth.FacebookMixin):\n                @tornado.web.authenticated\n                @tornado.web.asynchronous\n                def get(self):\n                    self.facebook_request(\n                        method=\"stream.get\",\n                        callback=self.async_callback(self._on_stream),\n                        session_key=self.current_user[\"session_key\"])\n\n                def _on_stream(self, stream):\n                    if stream is None:\n                       # Not authorized to read the stream yet?\n                       self.redirect(self.authorize_redirect(\"read_stream\"))\n                       return\n                    self.render(\"stream.html\", stream=stream)", "id": "f12679:c11:m3"}
{"signature": "def authenticate_redirect(self, callback_uri=None, cancel_uri=None,<EOL>extended_permissions=None):", "body": "self.require_setting(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>callback_uri = callback_uri or self.request.uri<EOL>args = {<EOL>\"<STR_LIT>\": self.settings[\"<STR_LIT>\"],<EOL>\"<STR_LIT:v>\": \"<STR_LIT:1.0>\",<EOL>\"<STR_LIT>\": \"<STR_LIT:true>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": urlparse.urljoin(self.request.full_url(), callback_uri),<EOL>\"<STR_LIT>\": \"<STR_LIT:true>\",<EOL>}<EOL>if cancel_uri:<EOL><INDENT>args[\"<STR_LIT>\"] = urlparse.urljoin(<EOL>self.request.full_url(), cancel_uri)<EOL><DEDENT>if extended_permissions:<EOL><INDENT>if isinstance(extended_permissions, (unicode, bytes_type)):<EOL><INDENT>extended_permissions = [extended_permissions]<EOL><DEDENT>args[\"<STR_LIT>\"] = \"<STR_LIT:U+002C>\".join(extended_permissions)<EOL><DEDENT>self.redirect(\"<STR_LIT>\" +<EOL>urllib.urlencode(args))<EOL>", "docstring": "Authenticates/installs this app for the current user.", "id": "f12679:c11:m0"}
{"signature": "def clear_cookie(self, name, path=\"<STR_LIT:/>\", domain=None):", "body": "assert self.cookie_monster, '<STR_LIT>'<EOL>self.cookie_monster.delete_cookie(name)<EOL>", "docstring": "Deletes the cookie with the given name.", "id": "f12679:c4:m9"}
{"signature": "def authorize_redirect(self, callback_uri=None, extra_params=None):", "body": "if callback_uri and getattr(self, \"<STR_LIT>\", False):<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>http = httpclient.AsyncHTTPClient()<EOL>if getattr(self, \"<STR_LIT>\", \"<STR_LIT>\") == \"<STR_LIT>\":<EOL><INDENT>http.fetch(self._oauth_request_token_url(callback_uri=callback_uri,<EOL>extra_params=extra_params),<EOL>self.async_callback(<EOL>self._on_request_token,<EOL>self._OAUTH_AUTHORIZE_URL,<EOL>callback_uri))<EOL><DEDENT>else:<EOL><INDENT>http.fetch(self._oauth_request_token_url(), self.async_callback(<EOL>self._on_request_token, self._OAUTH_AUTHORIZE_URL, callback_uri))<EOL><DEDENT>", "docstring": "Redirects the user to obtain OAuth authorization for this service.\n\n        Twitter and FriendFeed both require that you register a Callback\n        URL with your application. You should call this method to log the\n        user in, and then call get_authenticated_user() in the handler\n        you registered as your Callback URL to complete the authorization\n        process.\n\n        This method sets a cookie called _oauth_request_token which is\n        subsequently used (and cleared) in get_authenticated_user for\n        security purposes.", "id": "f12679:c6:m0"}
{"signature": "def decode_argument(self, value, name=None):", "body": "return _unicode(value)<EOL>", "docstring": "Decodes an argument from the request.\n\n        The argument has been percent-decoded and is now a byte string.\n        By default, this method decodes the argument as utf-8 and returns\n        a unicode string, but this may be overridden in subclasses.\n\n        This method is used as a filter for both get_argument() and for\n        values extracted from the url and passed to get()/post()/etc.\n\n        The name of the argument is provided if known, but may be None\n        (e.g. for unnamed groups in the url regex).", "id": "f12679:c4:m5"}
{"signature": "def _oauth10a_signature(consumer_token, method, url, parameters={}, token=None):", "body": "parts = urlparse.urlparse(url)<EOL>scheme, netloc, path = parts[:<NUM_LIT:3>]<EOL>normalized_url = scheme.lower() + \"<STR_LIT>\" + netloc.lower() + path<EOL>base_elems = []<EOL>base_elems.append(method.upper())<EOL>base_elems.append(normalized_url)<EOL>base_elems.append(\"<STR_LIT:&>\".join(\"<STR_LIT>\" % (k, _oauth_escape(str(v)))<EOL>for k, v in sorted(parameters.items())))<EOL>base_string =  \"<STR_LIT:&>\".join(_oauth_escape(e) for e in base_elems)<EOL>key_elems = [urllib.quote(consumer_token[\"<STR_LIT>\"], safe='<STR_LIT>')]<EOL>key_elems.append(urllib.quote(token[\"<STR_LIT>\"], safe='<STR_LIT>') if token else \"<STR_LIT>\")<EOL>key = \"<STR_LIT:&>\".join(key_elems)<EOL>hash = hmac.new(key, base_string, hashlib.sha1)<EOL>return binascii.b2a_base64(hash.digest())[:-<NUM_LIT:1>]<EOL>", "docstring": "Calculates the HMAC-SHA1 OAuth 1.0a signature for the given request.\n\n    See http://oauth.net/core/1.0a/#signing_process", "id": "f12679:m1"}
{"signature": "def _oauth_signature(consumer_token, method, url, parameters={}, token=None):", "body": "parts = urlparse.urlparse(url)<EOL>scheme, netloc, path = parts[:<NUM_LIT:3>]<EOL>normalized_url = scheme.lower() + \"<STR_LIT>\" + netloc.lower() + path<EOL>base_elems = []<EOL>base_elems.append(method.upper())<EOL>base_elems.append(normalized_url)<EOL>base_elems.append(\"<STR_LIT:&>\".join(\"<STR_LIT>\" % (k, _oauth_escape(str(v)))<EOL>for k, v in sorted(parameters.items())))<EOL>base_string =  \"<STR_LIT:&>\".join(_oauth_escape(e) for e in base_elems)<EOL>key_elems = [consumer_token[\"<STR_LIT>\"]]<EOL>key_elems.append(token[\"<STR_LIT>\"] if token else \"<STR_LIT>\")<EOL>key = \"<STR_LIT:&>\".join(key_elems)<EOL>hash = hmac.new(key, base_string, hashlib.sha1)<EOL>return binascii.b2a_base64(hash.digest())[:-<NUM_LIT:1>]<EOL>", "docstring": "Calculates the HMAC-SHA1 OAuth signature for the given request.\n\n    See http://oauth.net/core/1.0/#signing_process", "id": "f12679:m0"}
{"signature": "def require_setting(self, name, feature=\"<STR_LIT>\"):", "body": "if name not in self.settings:<EOL><INDENT>raise Exception(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (name, feature))<EOL><DEDENT>", "docstring": "Raises an exception if the given app setting is not defined.", "id": "f12679:c4:m2"}
{"signature": "def authenticate_redirect(self):", "body": "http = httpclient.AsyncHTTPClient()<EOL>http.fetch(self._oauth_request_token_url(), self.async_callback(<EOL>self._on_request_token, self._OAUTH_AUTHENTICATE_URL, None))<EOL>", "docstring": "Just like authorize_redirect(), but auto-redirects if authorized.\n\n        This is generally the right interface to use if you are using\n        Twitter for single-sign on.", "id": "f12679:c8:m0"}
{"signature": "def get_argument(self, name, default=_ARG_DEFAULT, strip=True):", "body": "args = self.get_arguments(name, strip=strip)<EOL>if not args:<EOL><INDENT>if default is self._ARG_DEFAULT:<EOL><INDENT>raise HTTPError(<NUM_LIT>, \"<STR_LIT>\" % name)<EOL><DEDENT>return default<EOL><DEDENT>return args[-<NUM_LIT:1>]<EOL>", "docstring": "Returns the value of the argument with the given name.\n\n        If default is not provided, the argument is considered to be\n        required, and we throw an HTTP 400 exception if it is missing.\n\n        If the argument appears in the url more than once, we return the\n        last value.\n\n        The returned value is always unicode.", "id": "f12679:c4:m3"}
{"signature": "def friendfeed_request(self, path, callback, access_token=None,<EOL>post_args=None, **args):", "body": "<EOL>url = \"<STR_LIT>\" + path<EOL>if access_token:<EOL><INDENT>all_args = {}<EOL>all_args.update(args)<EOL>all_args.update(post_args or {})<EOL>consumer_token = self._oauth_consumer_token()<EOL>method = \"<STR_LIT:POST>\" if post_args is not None else \"<STR_LIT:GET>\"<EOL>oauth = self._oauth_request_parameters(<EOL>url, access_token, all_args, method=method)<EOL>args.update(oauth)<EOL><DEDENT>if args: url += \"<STR_LIT:?>\" + urllib.urlencode(args)<EOL>callback = self.async_callback(self._on_friendfeed_request, callback)<EOL>http = httpclient.AsyncHTTPClient()<EOL>if post_args is not None:<EOL><INDENT>http.fetch(url, method=\"<STR_LIT:POST>\", body=urllib.urlencode(post_args),<EOL>callback=callback)<EOL><DEDENT>else:<EOL><INDENT>http.fetch(url, callback=callback)<EOL><DEDENT>", "docstring": "Fetches the given relative API path, e.g., \"/bret/friends\"\n\n        If the request is a POST, post_args should be provided. Query\n        string arguments should be given as keyword arguments.\n\n        All the FriendFeed methods are documented at\n        http://friendfeed.com/api/documentation.\n\n        Many methods require an OAuth access token which you can obtain\n        through authorize_redirect() and get_authenticated_user(). The\n        user returned through that process includes an 'access_token'\n        attribute that can be used to make authenticated requests via\n        this method. Example usage::\n\n            class MainHandler(tornado.web.RequestHandler,\n                              tornado.auth.FriendFeedMixin):\n                @tornado.web.authenticated\n                @tornado.web.asynchronous\n                def get(self):\n                    self.friendfeed_request(\n                        \"/entry\",\n                        post_args={\"body\": \"Testing Tornado Web Server\"},\n                        access_token=self.current_user[\"access_token\"],\n                        callback=self.async_callback(self._on_post))\n\n                def _on_post(self, new_entry):\n                    if not new_entry:\n                        # Call failed; perhaps missing permission?\n                        self.authorize_redirect()\n                        return\n                    self.finish(\"Posted a message!\")", "id": "f12679:c9:m0"}
{"signature": "def authenticate_redirect(<EOL>self, callback_uri=None, ax_attrs=[\"<STR_LIT:name>\", \"<STR_LIT:email>\", \"<STR_LIT>\",<EOL>\"<STR_LIT:username>\"]):", "body": "callback_uri = callback_uri or self.request.uri<EOL>args = self._openid_args(callback_uri, ax_attrs=ax_attrs)<EOL>self.redirect(self._OPENID_ENDPOINT + \"<STR_LIT:?>\" + urllib.urlencode(args))<EOL>", "docstring": "Returns the authentication URL for this service.\n\n        After authentication, the service will redirect back to the given\n        callback URI.\n\n        We request the given attributes for the authenticated user by\n        default (name, email, language, and username). If you don't need\n        all those attributes for your app, you can request fewer with\n        the ax_attrs keyword argument.", "id": "f12679:c5:m0"}
{"signature": "def get_authenticated_user(self, callback):", "body": "request_key = self.get_argument(\"<STR_LIT>\")<EOL>oauth_verifier = self.get_argument(\"<STR_LIT>\", None)<EOL>request_cookie = self.get_cookie(\"<STR_LIT>\")<EOL>if not request_cookie:<EOL><INDENT>log.warning(\"<STR_LIT>\")<EOL>callback(None)<EOL>return<EOL><DEDENT>self.clear_cookie(\"<STR_LIT>\")<EOL>cookie_key, cookie_secret = [base64.b64decode(i) for i in request_cookie.split(\"<STR_LIT:|>\")]<EOL>if cookie_key != request_key:<EOL><INDENT>log.warning(\"<STR_LIT>\")<EOL>callback(None)<EOL>return<EOL><DEDENT>token = dict(key=cookie_key, secret=cookie_secret)<EOL>if oauth_verifier:<EOL><INDENT>token[\"<STR_LIT>\"] = oauth_verifier<EOL><DEDENT>http = httpclient.AsyncHTTPClient()<EOL>http.fetch(self._oauth_access_token_url(token), self.async_callback(<EOL>self._on_access_token, callback))<EOL>", "docstring": "Gets the OAuth authorized user and access token on callback.\n\n        This method should be called from the handler for your registered\n        OAuth Callback URL to complete the registration process. We call\n        callback with the authenticated user, which in addition to standard\n        attributes like 'name' includes the 'access_key' attribute, which\n        contains the OAuth access you can use to make authorized requests\n        to this service on behalf of the user.", "id": "f12679:c6:m1"}
{"signature": "def makeMimi(upid):", "body": "strSeed = \"<STR_LIT>\"<EOL>prehash = upid + \"<STR_LIT:_>\" + strSeed<EOL>return md5(prehash.encode('<STR_LIT:utf-8>')).hexdigest()<EOL>", "docstring": "From http://cdn37.atwikiimg.com/sitescript/pub/dksitescript/FC2.site.js\n    Also com.hps.util.fc2.FC2EncrptUtil.makeMimiLocal\n    L110", "id": "f12701:m0"}
{"signature": "def get_playlist_id_from_url(url):", "body": "return parse_query_param(url, '<STR_LIT:list>') orparse_query_param(url, '<STR_LIT:p>')<EOL>", "docstring": "Extracts playlist ID from URL.", "id": "f12712:c0:m4"}
{"signature": "def sina_download_by_vid(vid, title=None, output_dir='<STR_LIT:.>', merge=True, info_only=False):", "body": "xml = api_req(vid)<EOL>urls, name, size = video_info(xml)<EOL>if urls is None:<EOL><INDENT>log.wtf(name)<EOL><DEDENT>title = name<EOL>print_info(site_info, title, '<STR_LIT>', size)<EOL>if not info_only:<EOL><INDENT>download_urls(urls, title, '<STR_LIT>', size, output_dir = output_dir, merge = merge)<EOL><DEDENT>", "docstring": "Downloads a Sina video by its unique vid.\n    http://video.sina.com.cn/", "id": "f12715:m2"}
{"signature": "def ckplayer_get_info_by_xml(ckinfo):", "body": "e = ET.XML(ckinfo)<EOL>video_dict = {'<STR_LIT:title>': '<STR_LIT>',<EOL>'<STR_LIT>': [],<EOL>'<STR_LIT:size>': <NUM_LIT:0>,<EOL>'<STR_LIT>': '<STR_LIT>',}<EOL>dictified = dictify(e)['<STR_LIT>']<EOL>if '<STR_LIT:info>' in dictified:<EOL><INDENT>if '<STR_LIT>' in dictified['<STR_LIT:info>'][<NUM_LIT:0>]['<STR_LIT:title>'][<NUM_LIT:0>]:  <EOL><INDENT>video_dict['<STR_LIT:title>'] = dictified['<STR_LIT:info>'][<NUM_LIT:0>]['<STR_LIT:title>'][<NUM_LIT:0>]['<STR_LIT>'].strip()<EOL><DEDENT><DEDENT>if '<STR_LIT>' in dictified['<STR_LIT>'][<NUM_LIT:0>]['<STR_LIT:size>'][<NUM_LIT:0>]:  <EOL><INDENT>video_dict['<STR_LIT:size>'] = sum([int(i['<STR_LIT:size>'][<NUM_LIT:0>]['<STR_LIT>']) for i in dictified['<STR_LIT>']])<EOL><DEDENT>if '<STR_LIT>' in dictified['<STR_LIT>'][<NUM_LIT:0>]['<STR_LIT:file>'][<NUM_LIT:0>]:  <EOL><INDENT>video_dict['<STR_LIT>'] = [i['<STR_LIT:file>'][<NUM_LIT:0>]['<STR_LIT>'].strip() for i in dictified['<STR_LIT>']]<EOL><DEDENT>if '<STR_LIT>' in dictified['<STR_LIT>'][<NUM_LIT:0>]:<EOL><INDENT>video_dict['<STR_LIT>'] = dictified['<STR_LIT>'][<NUM_LIT:0>]['<STR_LIT>'].strip()<EOL><DEDENT>return video_dict<EOL>", "docstring": "str->dict\n    Information for CKPlayer API content.", "id": "f12727:m0"}
{"signature": "def veoh_download(url, output_dir = '<STR_LIT:.>', merge = False, info_only = False, **kwargs):", "body": "if re.match(r'<STR_LIT>', url):<EOL><INDENT>item_id = match1(url, r'<STR_LIT>')<EOL><DEDENT>elif re.match(r'<STR_LIT>', url):<EOL><INDENT>item_id = match1(url, r'<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError('<STR_LIT>')<EOL><DEDENT>veoh_download_by_id(item_id, output_dir = '<STR_LIT:.>', merge = False, info_only = info_only, **kwargs)<EOL>", "docstring": "Get item_id", "id": "f12732:m0"}
{"signature": "def yixia_download(url, output_dir = '<STR_LIT:.>', merge = True, info_only = False, **kwargs):", "body": "hostname = urlparse(url).hostname<EOL>if '<STR_LIT>' == hostname: <EOL><INDENT>smid = match1(url, r'<STR_LIT>') <EOL>miaopai_download_by_smid(smid, output_dir, merge, info_only)<EOL>return<EOL><DEDENT>elif '<STR_LIT>' in hostname:  <EOL><INDENT>yixia_download_by_scid = yixia_miaopai_download_by_scid<EOL>site_info = \"<STR_LIT>\"<EOL>scid = match1(url, r'<STR_LIT>') ormatch1(url, r'<STR_LIT>') ormatch1(url, r'<STR_LIT>') ormatch1(url, r'<STR_LIT>')<EOL><DEDENT>elif '<STR_LIT>' in hostname:  <EOL><INDENT>yixia_download_by_scid = yixia_xiaokaxiu_download_by_scid<EOL>site_info = \"<STR_LIT>\"<EOL>if re.match(r'<STR_LIT>', url):  <EOL><INDENT>scid = match1(url, r'<STR_LIT>')<EOL><DEDENT>elif re.match(r'<STR_LIT>', url):  <EOL><INDENT>scid = match1(url, r'<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>yixia_download_by_scid(scid, output_dir, merge, info_only)<EOL>", "docstring": "wrapper", "id": "f12734:m3"}
{"signature": "@staticmethod<EOL><INDENT>def get_mgtv_real_url(url):<DEDENT>", "body": "content = loads(get_content(url))<EOL>m3u_url = content['<STR_LIT:info>']<EOL>split = urlsplit(m3u_url)<EOL>base_url = \"<STR_LIT>\".format(scheme = split[<NUM_LIT:0>],<EOL>netloc = split[<NUM_LIT:1>],<EOL>path = dirname(split[<NUM_LIT:2>]))<EOL>content = get_content(content['<STR_LIT:info>'])  <EOL>segment_list = []<EOL>segments_size = <NUM_LIT:0><EOL>for i in content.split():<EOL><INDENT>if not i.startswith('<STR_LIT:#>'):  <EOL><INDENT>segment_list.append(base_url + i)<EOL><DEDENT>elif i.startswith('<STR_LIT>'):<EOL><INDENT>segments_size += int(i[i.rfind('<STR_LIT::>')+<NUM_LIT:1>:])<EOL><DEDENT><DEDENT>return m3u_url, segments_size, segment_list<EOL>", "docstring": "str->list of str\n        Give you the real URLs.", "id": "f12737:c0:m1"}
{"signature": "def dailymotion_download(url, output_dir='<STR_LIT:.>', merge=True, info_only=False, **kwargs):", "body": "html = get_content(rebuilt_url(url))<EOL>info = json.loads(match1(html, r'<STR_LIT>'))<EOL>title = match1(html, r'<STR_LIT>') ormatch1(html, r'<STR_LIT>')<EOL>title = unicodize(title)<EOL>for quality in ['<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>']:<EOL><INDENT>try:<EOL><INDENT>real_url = info[quality][<NUM_LIT:1>][\"<STR_LIT:url>\"]<EOL>if real_url:<EOL><INDENT>break<EOL><DEDENT><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>mime, ext, size = url_info(real_url)<EOL>print_info(site_info, title, mime, size)<EOL>if not info_only:<EOL><INDENT>download_urls([real_url], title, ext, size, output_dir=output_dir, merge=merge)<EOL><DEDENT>", "docstring": "Downloads Dailymotion videos by URL.", "id": "f12740:m1"}
{"signature": "def _wanmen_get_json_api_content_by_courseID(courseID):", "body": "return loads(get_content('<STR_LIT>'.format(courseID = courseID)))<EOL>", "docstring": "int->JSON\n\n    Return a parsed JSON tree of WanMen's API.", "id": "f12775:m0"}
{"signature": "def wanmen_download_by_course_topic(json_api_content, tIndex, output_dir='<STR_LIT:.>', merge=True, info_only=False, **kwargs):", "body": "for pIndex in range(len(json_api_content[<NUM_LIT:0>]['<STR_LIT>'][tIndex]['<STR_LIT>'])):<EOL><INDENT>wanmen_download_by_course_topic_part(json_api_content,<EOL>tIndex,<EOL>pIndex, <EOL>output_dir=output_dir,<EOL>merge=merge,<EOL>info_only=info_only,<EOL>**kwargs)<EOL><DEDENT>", "docstring": "int, int->None\n\n    Download a TOPIC of a course.\n    Reuse the API call to save time.", "id": "f12775:m4"}
{"signature": "def wanmen_download_by_course(json_api_content, output_dir='<STR_LIT:.>', merge=True, info_only=False, **kwargs):", "body": "for tIndex in range(len(json_api_content[<NUM_LIT:0>]['<STR_LIT>'])):<EOL><INDENT>for pIndex in range(len(json_api_content[<NUM_LIT:0>]['<STR_LIT>'][tIndex]['<STR_LIT>'])):<EOL><INDENT>wanmen_download_by_course_topic_part(json_api_content,<EOL>tIndex,<EOL>pIndex,<EOL>output_dir=output_dir,<EOL>merge=merge,<EOL>info_only=info_only,<EOL>**kwargs)<EOL><DEDENT><DEDENT>", "docstring": "int->None\n\n    Download a WHOLE course.\n    Reuse the API call to save time.", "id": "f12775:m3"}
{"signature": "def vimeo_download_by_id(id, title=None, output_dir='<STR_LIT:.>', merge=True, info_only=False, **kwargs):", "body": "site = VimeoExtractor()<EOL>site.download_by_vid(id, info_only=info_only, output_dir=output_dir, merge=merge, **kwargs)<EOL>", "docstring": "try:\n    # normal Vimeo video\n    html = get_content('https://vimeo.com/' + id)\n    cfg_patt = r'clip_page_config\\s*=\\s*(\\{.+?\\});'\n    cfg = json.loads(match1(html, cfg_patt))\n    video_page = get_content(cfg['player']['config_url'], headers=fake_headers)\n    title = cfg['clip']['title']\n    info = loads(video_page)\nexcept:\n    # embedded player - referer may be required\n    if 'referer' in kwargs:\n        fake_headers['Referer'] = kwargs['referer']\n\n    video_page = get_content('http://player.vimeo.com/video/%s' % id, headers=fake_headers)\n    title = r1(r'<title>([^<]+)</title>', video_page)\n    info = loads(match1(video_page, r'var t=(\\{.+?\\});'))\n\nstreams = info['request']['files']['progressive']\nstreams = sorted(streams, key=lambda i: i['height'])\nurl = streams[-1]['url']\n\ntype, ext, size = url_info(url, faker=True)\n\nprint_info(site_info, title, type, size)\nif not info_only:\n    download_urls([url], title, ext, size, output_dir, merge=merge, faker=True)", "id": "f12778:m2"}
{"signature": "def parse_host(host):", "body": "if re.match(r'<STR_LIT>', host) is not None:<EOL><INDENT>return (\"<STR_LIT>\", int(host))<EOL><DEDENT>if re.match(r'<STR_LIT>', host) is None:<EOL><INDENT>host = \"<STR_LIT>\" + host<EOL><DEDENT>o = parse.urlparse(host)<EOL>hostname = o.hostname or \"<STR_LIT>\"<EOL>port = o.port or <NUM_LIT:0><EOL>return (hostname, port)<EOL>", "docstring": "Parses host name and port number from a string.", "id": "f12806:m35"}
{"signature": "def match1(text, *patterns):", "body": "if len(patterns) == <NUM_LIT:1>:<EOL><INDENT>pattern = patterns[<NUM_LIT:0>]<EOL>match = re.search(pattern, text)<EOL>if match:<EOL><INDENT>return match.group(<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>ret = []<EOL>for pattern in patterns:<EOL><INDENT>match = re.search(pattern, text)<EOL>if match:<EOL><INDENT>ret.append(match.group(<NUM_LIT:1>))<EOL><DEDENT><DEDENT>return ret<EOL><DEDENT>", "docstring": "Scans through a string for substrings matched some patterns (first-subgroups only).\n\n    Args:\n        text: A string to be scanned.\n        patterns: Arbitrary number of regex patterns.\n\n    Returns:\n        When only one pattern is given, returns a string (None if no match found).\n        When more than one pattern are given, returns a list of strings ([] if no match found).", "id": "f12806:m6"}
{"signature": "def parse_query_param(url, param):", "body": "try:<EOL><INDENT>return parse.parse_qs(parse.urlparse(url).query)[param][<NUM_LIT:0>]<EOL><DEDENT>except:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Parses the query string of a URL and returns the value of a parameter.\n\n    Args:\n        url: A URL.\n        param: A string representing the name of the parameter.\n\n    Returns:\n        The value of the parameter.", "id": "f12806:m9"}
{"signature": "def d(message):", "body": "print_log(message, BLUE)<EOL>", "docstring": "Print a debug log message.", "id": "f12811:m5"}
{"signature": "def e(message, exit_code=None):", "body": "print_log(message, YELLOW, BOLD)<EOL>if exit_code is not None:<EOL><INDENT>sys.exit(exit_code)<EOL><DEDENT>", "docstring": "Print an error log message.", "id": "f12811:m7"}
{"signature": "def legitimize(text, os=detect_os()):", "body": "<EOL>text = text.translate({<EOL><NUM_LIT:0>: None,<EOL>ord('<STR_LIT:/>'): '<STR_LIT:->',<EOL>ord('<STR_LIT:|>'): '<STR_LIT:->',<EOL>})<EOL>if os == '<STR_LIT>' or os == '<STR_LIT>' or os == '<STR_LIT>':<EOL><INDENT>text = text.translate({<EOL>ord('<STR_LIT::>'): '<STR_LIT:->',<EOL>ord('<STR_LIT:*>'): '<STR_LIT:->',<EOL>ord('<STR_LIT:?>'): '<STR_LIT:->',<EOL>ord('<STR_LIT:\\\\>'): '<STR_LIT:->',<EOL>ord('<STR_LIT>'): '<STR_LIT>',<EOL>ord('<STR_LIT:+>'): '<STR_LIT:->',<EOL>ord('<STR_LIT:<>'): '<STR_LIT:->',<EOL>ord('<STR_LIT:>>'): '<STR_LIT:->',<EOL>ord('<STR_LIT:[>'): '<STR_LIT:(>',<EOL>ord('<STR_LIT:]>'): '<STR_LIT:)>',<EOL>ord('<STR_LIT:\\t>'): '<STR_LIT:U+0020>',<EOL>})<EOL><DEDENT>else:<EOL><INDENT>if os == '<STR_LIT>':<EOL><INDENT>text = text.translate({<EOL>ord('<STR_LIT::>'): '<STR_LIT:->',<EOL>})<EOL><DEDENT>if text.startswith(\"<STR_LIT:.>\"):<EOL><INDENT>text = text[<NUM_LIT:1>:]<EOL><DEDENT><DEDENT>text = text[:<NUM_LIT>] <EOL>return text<EOL>", "docstring": "Converts a string to a valid filename.", "id": "f12812:m0"}
{"signature": "def turn_on_with_brightness(self, device_id, name, brightness):", "body": "brightness_value = round((brightness * <NUM_LIT>) / <NUM_LIT:255>) + <NUM_LIT:1><EOL>msg = '<STR_LIT>' % (<EOL>device_id, brightness_value, brightness_value, name)<EOL>\"\"\"<STR_LIT>\"\"\"<EOL>LWLink.registration_message_sent = False<EOL>self._send_message(msg)<EOL>", "docstring": "Scale brightness from 0..255 to 1..32.", "id": "f12815:c0:m4"}
{"signature": "def turn_on_with_brightness(self, device_id, name, brightness):", "body": "brightness_value = round((brightness * <NUM_LIT>) / <NUM_LIT:255>) + <NUM_LIT:1><EOL>msg = \"<STR_LIT>\" % (<EOL>device_id, brightness_value, brightness_value, name)<EOL>self._send_message(msg)<EOL>", "docstring": "Scale brightness from 0..255 to 1..32.", "id": "f12818:c0:m6"}
{"signature": "def turn_on_switch(self, device_id, name):", "body": "msg = \"<STR_LIT>\" % (device_id, name)<EOL>self._send_message(msg)<EOL>", "docstring": "Create the message to turn switch on.", "id": "f12818:c0:m5"}
{"signature": "def turn_off(self, device_id, name):", "body": "msg = \"<STR_LIT>\" % (device_id, name)<EOL>self._send_message(msg)<EOL>", "docstring": "Create the message to turn light or switch off.", "id": "f12818:c0:m7"}
{"signature": "def deregister_host():", "body": "pyblish.api.deregister_host(\"<STR_LIT>\")<EOL>pyblish.api.deregister_host(\"<STR_LIT>\")<EOL>pyblish.api.deregister_host(\"<STR_LIT>\")<EOL>", "docstring": "Register supported hosts", "id": "f12821:m6"}
{"signature": "@contextlib.contextmanager<EOL>def maintained_time():", "body": "ct = cmds.currentTime(query=True)<EOL>try:<EOL><INDENT>yield<EOL><DEDENT>finally:<EOL><INDENT>cmds.currentTime(ct, edit=True)<EOL><DEDENT>", "docstring": "Maintain current time during context\n\n    Example:\n        >>> with maintained_time():\n        ...    cmds.playblast()\n        >>> # Time restored", "id": "f12821:m12"}
{"signature": "def _add_to_filemenu():", "body": "import os<EOL>import pyblish<EOL>from maya import cmds<EOL>for item in (\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\"):<EOL><INDENT>if cmds.menuItem(item, exists=True):<EOL><INDENT>cmds.deleteUI(item, menuItem=True)<EOL><DEDENT><DEDENT>icon = os.path.dirname(pyblish.__file__)<EOL>icon = os.path.join(icon, \"<STR_LIT>\", \"<STR_LIT>\")<EOL>cmds.menuItem(\"<STR_LIT>\",<EOL>divider=True,<EOL>insertAfter=\"<STR_LIT>\",<EOL>parent=\"<STR_LIT>\")<EOL>cmds.menuItem(\"<STR_LIT>\",<EOL>insertAfter=\"<STR_LIT>\",<EOL>label=\"<STR_LIT>\",<EOL>parent=\"<STR_LIT>\",<EOL>image=icon,<EOL>command=\"<STR_LIT>\")<EOL>cmds.menuItem(\"<STR_LIT>\",<EOL>insertAfter=\"<STR_LIT>\",<EOL>parent=\"<STR_LIT>\",<EOL>divider=True)<EOL>", "docstring": "Helper function for the above :func:add_to_filemenu()\n\n    This function is serialised into a string and passed on\n    to evalDeferred above.", "id": "f12821:m10"}
{"signature": "def _maintain_backwards_compatibility(binding):", "body": "for member in (\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\"):<EOL><INDENT>setattr(binding, member, getattr(self, member))<EOL>self.__added__.append(member)<EOL><DEDENT>setattr(binding, \"<STR_LIT>\", self.__version__)<EOL>self.__added__.append(\"<STR_LIT>\")<EOL>", "docstring": "Add members found in prior versions up till the next major release\n\n    These members are to be considered deprecated. When a new major\n    release is made, these members are removed.", "id": "f12824:m10"}
{"signature": "@main.command()<EOL>@click.argument('<STR_LIT>', required=True, nargs=<NUM_LIT:2>, type=text)<EOL>@click.option('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', envvar='<STR_LIT>', type=text)<EOL>@click.option('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', type=text)<EOL>@click.option('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', default=False)<EOL>@click.pass_context<EOL>def similarity(ctx, app_id, json_flag, query_pair, request_id):<EOL>", "body": "app_id = clean_app_id(app_id)<EOL>api = GoolabsAPI(app_id)<EOL>ret = api.similarity(<EOL>query_pair=query_pair,<EOL>request_id=request_id<EOL>)<EOL>if json_flag:<EOL><INDENT>click.echo(format_json(api.response.json()))<EOL>return<EOL><DEDENT>click.echo('<STR_LIT>'.format(ret['<STR_LIT>']))<EOL>", "docstring": "Scoring the similarity of two words.", "id": "f12830:m9"}
{"signature": "@main.command()<EOL>@click.argument('<STR_LIT>', required=False, type=text)<EOL>@click.option('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', default='<STR_LIT>',<EOL>type=click.Choice(['<STR_LIT>', '<STR_LIT>']))<EOL>@click.option('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', envvar='<STR_LIT>', type=text)<EOL>@click.option('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', type=text)<EOL>@click.option('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', type=click.File('<STR_LIT:rb>'))<EOL>@click.option('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', default=False)<EOL>@click.pass_context<EOL>def hiragana(ctx, app_id, sentence_file,<EOL>json_flag, sentence, output_type, request_id):<EOL>", "body": "app_id = clean_app_id(app_id)<EOL>sentence = clean_sentence(sentence, sentence_file)<EOL>api = GoolabsAPI(app_id)<EOL>ret = api.hiragana(<EOL>sentence=sentence,<EOL>output_type=output_type,<EOL>request_id=request_id<EOL>)<EOL>if json_flag:<EOL><INDENT>click.echo(format_json(api.response.json()))<EOL>return<EOL><DEDENT>click.echo(ret['<STR_LIT>'])<EOL>", "docstring": "Convert the Japanese to Hiragana or Katakana.", "id": "f12830:m10"}
{"signature": "@main.command()<EOL>@click.argument('<STR_LIT:title>', required=True, type=text)<EOL>@click.argument('<STR_LIT:body>', required=False, type=text)<EOL>@click.option('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', envvar='<STR_LIT>', type=text)<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=click.INT)<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=click.Choice(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']))<EOL>@click.option('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', type=text)<EOL>@click.option('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', type=click.File('<STR_LIT:rb>'))<EOL>@click.option('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', default=False)<EOL>@click.pass_context<EOL>def keyword(ctx, app_id, body_file, json_flag,<EOL>title, body, max_num, forcus, request_id):<EOL>", "body": "app_id = clean_app_id(app_id)<EOL>body = clean_body(body, body_file)<EOL>api = GoolabsAPI(app_id)<EOL>ret = api.keyword(<EOL>title=title,<EOL>body=body,<EOL>max_num=max_num,<EOL>forcus=forcus,<EOL>request_id=request_id,<EOL>)<EOL>if json_flag:<EOL><INDENT>click.echo(format_json(api.response.json()))<EOL>return<EOL><DEDENT>for k in ret['<STR_LIT>']:<EOL><INDENT>k = dict((key.encode('<STR_LIT:utf-8>'), k[key]) for key in k.keys())<EOL>for keyword, score in six.iteritems(k):<EOL><INDENT>click.echo(u'<STR_LIT>'.format(text(keyword), score))<EOL><DEDENT><DEDENT>", "docstring": "Extract \"keywords\" from an input document.", "id": "f12830:m13"}
{"signature": "def decode(self, packet):", "body": "self.encoded = packet<EOL>lenLen = <NUM_LIT:1><EOL>while packet[lenLen] & <NUM_LIT>:<EOL><INDENT>lenLen += <NUM_LIT:1><EOL><DEDENT>packet_remaining = packet[lenLen+<NUM_LIT:1>:]<EOL>self.msgId   = decode16Int(packet_remaining[<NUM_LIT:0>:<NUM_LIT:2>])<EOL>self.topics = []<EOL>packet_remaining = packet_remaining[<NUM_LIT:2>:]<EOL>while len(packet_remaining):<EOL><INDENT>l = decode16Int(packet_remaining[<NUM_LIT:0>:<NUM_LIT:2>])<EOL>topic = packet_remaining[<NUM_LIT:2>:<NUM_LIT:2>+l].decode(encoding='<STR_LIT:utf-8>')<EOL>self.topics.append(topic)<EOL>packet_remaining = packet_remaining[<NUM_LIT:2>+l:]<EOL><DEDENT>", "docstring": "Decode a UNSUBACK control packet.", "id": "f12833:c7:m2"}
{"signature": "def encode(self):", "body": "header    = bytearray(<NUM_LIT:1>)<EOL>payload   = bytearray()<EOL>varHeader = encode16Int(self.msgId)<EOL>header[<NUM_LIT:0>] = <NUM_LIT>    <EOL>for topic in self.topics:<EOL><INDENT>payload.extend(encodeString(topic)) <EOL><DEDENT>header.extend(encodeLength(len(varHeader) + len(payload)))<EOL>header.extend(varHeader)<EOL>header.extend(payload)<EOL>self.encoded = header<EOL>return str(header) if PY2 else bytes(header)<EOL>", "docstring": "Encode and store an UNSUBCRIBE control packet\n@raise e: C{ValueError} if any encoded topic string exceeds 65535 bytes", "id": "f12833:c7:m1"}
{"signature": "def encodeLength(value):", "body": "encoded = bytearray()<EOL>while True:<EOL><INDENT>digit = value % <NUM_LIT><EOL>value //= <NUM_LIT><EOL>if value > <NUM_LIT:0>:<EOL><INDENT>digit |= <NUM_LIT><EOL><DEDENT>encoded.append(digit)<EOL>if value <= <NUM_LIT:0>:<EOL><INDENT>break<EOL><DEDENT><DEDENT>return encoded<EOL>", "docstring": "Encodes value into a multibyte sequence defined by MQTT protocol.\nUsed to encode packet length fields.", "id": "f12833:m4"}
{"signature": "def decode(self, packet):", "body": "self.encoded = packet<EOL>lenLen = <NUM_LIT:1><EOL>while packet[lenLen] & <NUM_LIT>:<EOL><INDENT>lenLen += <NUM_LIT:1><EOL><DEDENT>packet_remaining = packet[lenLen+<NUM_LIT:1>:]<EOL>version_str, packet_remaining = decodeString(packet_remaining)<EOL>version_id = int(packet_remaining[<NUM_LIT:0>])<EOL>if version_id == v31['<STR_LIT>']:<EOL><INDENT>self.version = v31<EOL><DEDENT>else:<EOL><INDENT>self.version = v311<EOL><DEDENT>flags = packet_remaining[<NUM_LIT:1>]<EOL>self.cleanStart = (flags & <NUM_LIT>) != <NUM_LIT:0><EOL>willFlag   = (flags & <NUM_LIT>) != <NUM_LIT:0><EOL>willQoS    = (flags >> <NUM_LIT:3>) & <NUM_LIT><EOL>willRetain = (flags & <NUM_LIT>) != <NUM_LIT:0><EOL>userFlag   = (flags & <NUM_LIT>)  != <NUM_LIT:0><EOL>passFlag   = (flags & <NUM_LIT>)  != <NUM_LIT:0><EOL>packet_remaining = packet_remaining[<NUM_LIT:2>:]<EOL>self.keepalive = decode16Int(packet_remaining)<EOL>packet_remaining = packet_remaining[<NUM_LIT:2>:]<EOL>self.clientId, packet_remaining = decodeString(packet_remaining)<EOL>if willFlag:<EOL><INDENT>self.willRetain = willRetain<EOL>self.willQoS    = willQoS<EOL>self.willTopic,  packet_remaining  = decodeString(packet_remaining)<EOL>self.willMessage, packet_remaining = decodeString(packet_remaining)<EOL><DEDENT>if userFlag:<EOL><INDENT>self.username, packet_remaining = decodeString(packet_remaining)<EOL><DEDENT>if passFlag:<EOL><INDENT>l = decode16Int(packet_remaining)<EOL>self.password = packet_remaining[<NUM_LIT:2>:<NUM_LIT:2>+l]<EOL><DEDENT>", "docstring": "Decode a CONNECT control packet.", "id": "f12833:c3:m2"}
{"signature": "def decode16Int(encoded):", "body": "return encoded[<NUM_LIT:0>]*<NUM_LIT> + encoded[<NUM_LIT:1>]<EOL>", "docstring": "Decodes a 16 bit unsigned integer from MQTT bytearray.", "id": "f12833:m3"}
{"signature": "def decode(self, packet):", "body": "self.encoded = packet<EOL>lenLen = <NUM_LIT:1><EOL>while packet[lenLen] & <NUM_LIT>:<EOL><INDENT>lenLen += <NUM_LIT:1><EOL><DEDENT>packet_remaining = packet[lenLen+<NUM_LIT:1>:]<EOL>self.msgId   = decode16Int(packet_remaining)<EOL>self.granted = [ (byte & <NUM_LIT>, byte & <NUM_LIT> == <NUM_LIT>) <EOL>for byte in packet_remaining[<NUM_LIT:2>:] ]<EOL>", "docstring": "Decode a SUBACK control packet.", "id": "f12833:c6:m2"}
{"signature": "def decode(self, packet):", "body": "self.encoded = packet<EOL>lenLen = <NUM_LIT:1><EOL>while packet[lenLen] & <NUM_LIT>:<EOL><INDENT>lenLen += <NUM_LIT:1><EOL><DEDENT>packet_remaining = packet[lenLen+<NUM_LIT:1>:]<EOL>self.session = (packet_remaining[<NUM_LIT:0>] & <NUM_LIT>) == <NUM_LIT> <EOL>self.resultCode  = int(packet_remaining[<NUM_LIT:1>])<EOL>", "docstring": "Decode a CONNACK control packet.", "id": "f12833:c4:m2"}
{"signature": "def decode(self, packet):", "body": "self.encoded = packet<EOL>lenLen = <NUM_LIT:1><EOL>while packet[lenLen] & <NUM_LIT>:<EOL><INDENT>lenLen += <NUM_LIT:1><EOL><DEDENT>packet_remaining = packet[lenLen+<NUM_LIT:1>:]<EOL>self.msgId = decode16Int(packet_remaining)<EOL>", "docstring": "Decode a PUBACK control packet.", "id": "f12833:c10:m2"}
{"signature": "def encode(self):", "body": "header    = bytearray(<NUM_LIT:1>)<EOL>varHeader = encode16Int(self.msgId)<EOL>header[<NUM_LIT:0>] = <NUM_LIT> <EOL>header.extend(encodeLength(len(varHeader)))<EOL>header.extend(varHeader)<EOL>self.encoded = header<EOL>return str(header) if PY2 else bytes(header)<EOL>", "docstring": "Encode and store an UNSUBACK control packet", "id": "f12833:c8:m1"}
{"signature": "def encode(self):", "body": "header    = bytearray(<NUM_LIT:1>)<EOL>varHeader = bytearray()<EOL>payload   = bytearray()<EOL>if self.qos:<EOL><INDENT>header[<NUM_LIT:0>] = <NUM_LIT> | self.retain | (self.qos << <NUM_LIT:1>) | (self.dup << <NUM_LIT:3>)<EOL>varHeader.extend(encodeString(self.topic)) <EOL>varHeader.extend(encode16Int(self.msgId))  <EOL><DEDENT>else:<EOL><INDENT>header[<NUM_LIT:0>] = <NUM_LIT> | self.retain<EOL>varHeader.extend(encodeString(self.topic)) <EOL><DEDENT>if isinstance(self.payload, bytearray):<EOL><INDENT>payload.extend(self.payload)<EOL><DEDENT>elif isinstance(self.payload, str):<EOL><INDENT>payload.extend(bytearray(self.payload, encoding='<STR_LIT:utf-8>'))<EOL><DEDENT>else:<EOL><INDENT>raise PayloadTypeError(type(self.payload))<EOL><DEDENT>totalLen = len(varHeader) + len(payload)<EOL>if totalLen > <NUM_LIT>:<EOL><INDENT>raise PayloadValueError(totalLen)<EOL><DEDENT>header.extend(encodeLength(totalLen))<EOL>header.extend(varHeader)<EOL>header.extend(payload)<EOL>self.encoded = header<EOL>return str(header) if PY2 else bytes(header)<EOL>", "docstring": "Encode and store a PUBLISH control packet.\n@raise e: C{ValueError} if encoded topic string exceeds 65535 bytes.\n@raise e: C{ValueError} if encoded packet size exceeds 268435455 bytes.\n@raise e: C{TypeError} if C{data} is not a string, bytearray, int, boolean or float.", "id": "f12833:c9:m1"}
{"signature": "def connect(clientId, keepalive=<NUM_LIT:0>, willTopic=None,<EOL>willMessage=None, willQoS=<NUM_LIT:0>, willRetain=False, <EOL>username=None, password=None, cleanStart=True, version=mqtt.v311):", "body": "", "docstring": "Abstract\n========\n\nSend a CONNECT control packet.\n\nDescription\n===========\n\nAfter a Network Connection is established by a Client to a Server, \nthe first Packet sent from the Client to the Server MUST be a CONNECT \nPacket [MQTT-3.1.0-1].\n\nA Client can only send the CONNECT Packet once over a \nNetwork Connection. The Server MUST process a second CONNECT Packet \nsent from a Client as a protocol violation and disconnect the Client.\n\nIf the Client does not receive a CONNACK Packet from the Server within\na reasonable amount of time, he Client SHOULD close the Network \nConnection. A \"reasonable\" amount of time depends on the type of \napplication and the communications infrastructure.\n\nSignature\n=========\n\n@param clientId: client ID for the connection (UTF-8 string)\n@param keepalive: connection keepalive period in seconds.\n@param willTopic:   last will topic  (UTF-8 string)\n@param willMessage: last will message  (UTF-8 string)\n@param willQoS:     last will qos message\n@param willRetain:  lass will retain flag.\n@param cleanStart:  session clean flag.\n@return: a Deferred whose callback will be called with a tuple\n    C{returnCode, sessionFlag)} when the connection completes. \n    The Deferred errback with a C{MQTTError} exception will be called \n    if no connection ack is received from the server within a keepalive\n    period. If no keepalive is used, a max of 10 seconds is used.", "id": "f12835:c0:m0"}
{"signature": "def subscribe(topicList):", "body": "", "docstring": "Abstract\n========\n\nSend a SUBSCRIBE control packet.\n\nDescription\n===========\n\nThe SUBSCRIBE Packet is sent from the Client to the Server to create \none or more Subscriptions. Each Subscription registers a Client's \ninterest in one or more Topics.\n\nSignature\n=========\n\n@param topicList: list of tuples C{(topic, QoS)}. Each topic is\n    an UTF-8 string. 0 <= QoS <= 3\n@return: a Deferred, with an extra C{msgId} attribute which you can \n    use to keep track of requests. \n    The callbacks will be invoked with a list of granted tuples (granted qos, failure flag)\n    where False in the failure flag means operation Ok)", "id": "f12835:c1:m0"}
{"signature": "def _processPacket(self, packet):", "body": "try:<EOL><INDENT>packet_type      = (packet[<NUM_LIT:0>] & <NUM_LIT>) >> <NUM_LIT:4><EOL>packet_flags     = (packet[<NUM_LIT:0>] & <NUM_LIT>)<EOL>packet_type_name = self.packetTypes[packet_type]<EOL><DEDENT>except KeyError as e:<EOL><INDENT>log.error(\"<STR_LIT>\" % packet_type)<EOL>self.transport.abortConnection()<EOL>return<EOL><DEDENT>packetDecoder = getattr(self, \"<STR_LIT>\" % packet_type_name, None)<EOL>if packetDecoder:<EOL><INDENT>packetDecoder(packet)<EOL><DEDENT>else:<EOL><INDENT>log.error(\"<STR_LIT>\" % packet_type_name)<EOL>self.transport.abortConnection()<EOL>return<EOL><DEDENT>", "docstring": "Generic MQTT packet decoder", "id": "f12836:c4:m2"}
{"signature": "def mqttConnectionMade(self):", "body": "pass<EOL>", "docstring": "Called when a CONNACK has been received.\nOverriden in subscriber/publisher to do additional session sync", "id": "f12836:c4:m21"}
{"signature": "def doDisconnect(self, request):", "body": "log.debug(\"<STR_LIT>\",packet=\"<STR_LIT>\")<EOL>self.transport.write(request.encode())<EOL>self.transport.loseConnection()<EOL>", "docstring": "Performs the actual work of disconnecting", "id": "f12836:c4:m22"}
{"signature": "def handlePINGRESP(self):", "body": "log.debug(\"<STR_LIT>\", packet=\"<STR_LIT>\")<EOL>self._pingReq.alarm.cancel()<EOL>self._pingReq.alarm = None<EOL>", "docstring": "Handles PINGRESP packet from the server", "id": "f12836:c4:m20"}
{"signature": "def disconnect(self, request):", "body": "self.protocol.doDisconnect(request)<EOL>", "docstring": "Send a DISCONNECT packet.", "id": "f12836:c3:m0"}
{"signature": "def handlePUBREC(self, response):", "body": "state = self.__class__.__name__<EOL>log.error(\"<STR_LIT>\", packet=\"<STR_LIT>\")<EOL>", "docstring": "Handles PUBREC packet from the server", "id": "f12836:c0:m12"}
{"signature": "def _handlePUBREC(self, packet):", "body": "response = PUBREC()<EOL>try:<EOL><INDENT>response.decode(packet)<EOL><DEDENT>except Exception as e:<EOL><INDENT>log.debug(\"<STR_LIT>\", excp=e)<EOL>log.error(\"<STR_LIT>\")<EOL>self.transport.abortConnection()<EOL><DEDENT>else:<EOL><INDENT>self.state.handlePUBREC(response)<EOL><DEDENT>", "docstring": "Decodes specific PUBREC data from Variable Header & Payload", "id": "f12836:c4:m10"}
{"signature": "def doConnect(self, request):", "body": "def connectError():<EOL><INDENT>request.deferred.errback(MQTTTimeoutError(\"<STR_LIT>\"))<EOL>request.deferred = None<EOL>self.transport.abortConnection()            <EOL><DEDENT>try:<EOL><INDENT>self._checkConnect(request)<EOL>pdu = request.encode()<EOL><DEDENT>except ValueError as e:<EOL><INDENT>return defer.fail(e)<EOL><DEDENT>log.debug(\"<STR_LIT>\", packet=\"<STR_LIT>\", id=request.clientId, keepalive=request.keepalive, clean=request.cleanStart)<EOL>self._cleanStart = request.cleanStart<EOL>self._version    = request.version<EOL>self.transport.write(pdu)<EOL>self.state = self.CONNECTING<EOL>request.alarm = self.callLater(request.keepalive or <NUM_LIT:10>, connectError)<EOL>request.deferred = defer.Deferred()<EOL>self.connReq = request  <EOL>return request.deferred<EOL>", "docstring": "Performs the actual work of connecting", "id": "f12836:c4:m23"}
{"signature": "def _connect(self, cleanStart=True):", "body": "ack = CONNACK()<EOL>ack.session = False<EOL>ack.resultCode = <NUM_LIT:0><EOL>ack.encode()<EOL>self.protocol.connect(\"<STR_LIT>\", keepalive=<NUM_LIT:0>, cleanStart=cleanStart, version=v31)<EOL>self.transport.clear()<EOL>self.protocol.dataReceived(ack.encoded)<EOL>", "docstring": "Go to connected state", "id": "f12837:c2:m1"}
{"signature": "def _connect(self, keepalive=<NUM_LIT:0>, cleanStart=True):", "body": "ack = CONNACK()<EOL>ack.session = False<EOL>ack.resultCode = <NUM_LIT:0><EOL>ack.encode()<EOL>self.protocol.connect(\"<STR_LIT>\", keepalive=keepalive, cleanStart=cleanStart, version=v31)<EOL>self.transport.clear()<EOL>self.protocol.dataReceived(ack.encoded)<EOL>", "docstring": "Go to connected state", "id": "f12839:c1:m2"}
{"signature": "def setUp(self):", "body": "self.transport = proto_helpers.StringTransportWithDisconnection()<EOL>self.clock     = task.Clock()<EOL>MQTTBaseProtocol.callLater = self.clock.callLater<EOL>self.factory   = MQTTFactory(MQTTFactory.SUBSCRIBER)<EOL>self._rebuild()<EOL>", "docstring": "Set up a conencted state", "id": "f12839:c1:m0"}
{"signature": "def _connect(self, cleanStart=True):", "body": "ack = CONNACK()<EOL>ack.session = False<EOL>ack.resultCode = <NUM_LIT:0><EOL>ack.encode()<EOL>self.protocol.connect(\"<STR_LIT>\", keepalive=<NUM_LIT:0>, cleanStart=cleanStart, version=v31)<EOL>self.transport.clear()<EOL>self.protocol.dataReceived(ack.encoded)<EOL>", "docstring": "Go to connected state", "id": "f12840:c0:m1"}
{"signature": "def setUp(self):", "body": "self.transport = proto_helpers.StringTransportWithDisconnection()<EOL>self.clock     = task.Clock()<EOL>MQTTBaseProtocol.callLater = self.clock.callLater<EOL>self.factory   = MQTTFactory(MQTTFactory.PUBLISHER)<EOL>self.addr = IPv4Address('<STR_LIT>','<STR_LIT:localhost>',<NUM_LIT>)<EOL>self._rebuild()<EOL>", "docstring": "Set up a conencted state", "id": "f12840:c3:m0"}
{"signature": "def _connect(self, cleanStart=True):", "body": "ack = CONNACK()<EOL>ack.session = False<EOL>ack.resultCode = <NUM_LIT:0><EOL>ack.encode()<EOL>self.protocol.connect(\"<STR_LIT>\", keepalive=<NUM_LIT:0>, cleanStart=cleanStart, version=v31)<EOL>self.transport.clear()<EOL>self.protocol.dataReceived(ack.encoded)<EOL>", "docstring": "Go to connected state", "id": "f12840:c2:m1"}
{"signature": "def setUp(self):", "body": "self.transport = proto_helpers.StringTransportWithDisconnection()<EOL>self.clock     = task.Clock()<EOL>MQTTBaseProtocol.callLater = self.clock.callLater<EOL>self.factory   = MQTTFactory(MQTTFactory.PUBLISHER | MQTTFactory.SUBSCRIBER)<EOL>self._rebuild()<EOL>self.disconnected = <NUM_LIT:0><EOL>", "docstring": "Set up a connencted state", "id": "f12841:c0:m0"}
{"signature": "def setUp(self):", "body": "self.transport = proto_helpers.StringTransportWithDisconnection()<EOL>self.clock     = task.Clock()<EOL>MQTTBaseProtocol.callLater = self.clock.callLater<EOL>self.factory   = MQTTFactory(MQTTFactory.PUBLISHER | MQTTFactory.SUBSCRIBER)<EOL>self._rebuild()<EOL>self.disconnected = <NUM_LIT:0><EOL>", "docstring": "Set up a connencted state", "id": "f12841:c1:m0"}
{"signature": "def handlePUBLISH(self, response):", "body": "if  response.qos == <NUM_LIT:0>:<EOL><INDENT>log.debug(\"<STR_LIT>\" , packet=\"<STR_LIT>\", response=response)<EOL>self._deliver(response)<EOL><DEDENT>elif response.qos == <NUM_LIT:1>:<EOL><INDENT>log.debug(\"<STR_LIT>\" , packet=\"<STR_LIT>\", response=response)<EOL>reply = PUBACK()<EOL>reply.msgId = response.msgId<EOL>log.debug(\"<STR_LIT>\" , packet=\"<STR_LIT>\", response=response)<EOL>self.transport.write(reply.encode())<EOL>self._deliver(response)<EOL><DEDENT>elif response.qos == <NUM_LIT:2>:<EOL><INDENT>log.debug(\"<STR_LIT>\" , packet=\"<STR_LIT>\", response=response)<EOL>self.factory.windowPubRx[self.addr][response.msgId] = response<EOL>reply = PUBREC()<EOL>reply.msgId = response.msgId<EOL>log.debug(\"<STR_LIT>\" , packet=\"<STR_LIT>\", response=response)<EOL>self.transport.write(reply.encode())<EOL><DEDENT>", "docstring": "Handle PUBLISH control packet received.", "id": "f12844:c4:m7"}
{"signature": "def _pubrelError(self, reply):", "body": "log.error(\"<STR_LIT>\", packet=\"<STR_LIT>\", timeout=\"<STR_LIT>\")<EOL>self._retryRelease(reply, dup=True)<EOL>", "docstring": "Handle the absence of PUBCOMP", "id": "f12844:c4:m28"}
{"signature": "def doConnectionLost(self, reason):", "body": "<EOL>for _, request in self.factory.windowSubscribe[self.addr].items():<EOL><INDENT>if request.alarm is not None:<EOL><INDENT>request.alarm.cancel()<EOL>request.alarm = None<EOL><DEDENT><DEDENT>for _, request in self.factory.windowUnsubscribe[self.addr].items():<EOL><INDENT>if request.alarm is not None:<EOL><INDENT>request.alarm.cancel()<EOL>request.alarm = None<EOL><DEDENT><DEDENT>for _, request in self.factory.windowPublish[self.addr].items():<EOL><INDENT>if request.alarm is not None:<EOL><INDENT>request.alarm.cancel()<EOL>request.alarm = None<EOL><DEDENT><DEDENT>for _, request in self.factory.windowPubRelease[self.addr].items():<EOL><INDENT>if request.alarm is not None:<EOL><INDENT>request.alarm.cancel()<EOL>request.alarm = None<EOL><DEDENT><DEDENT>if self._cleanStart:<EOL><INDENT>for k in list(self.factory.windowSubscribe[self.addr]):<EOL><INDENT>request = self.factory.windowSubscribe[self.addr][k]<EOL>del self.factory.windowSubscribe[self.addr][k]<EOL>request.deferred.errback(reason)<EOL><DEDENT>for k in list(self.factory.windowUnsubscribe[self.addr]):<EOL><INDENT>request = self.factory.windowUnsubscribe[self.addr][k]<EOL>del self.factory.windowUnsubscribe[self.addr][k]<EOL>request.deferred.errback(reason)<EOL><DEDENT>self._purgeSession(reason)<EOL><DEDENT>", "docstring": "Additional connection lost clean up.", "id": "f12844:c4:m32"}
{"signature": "def _retryPublish(self, request, dup):", "body": "request.encoded[<NUM_LIT:0>] |=  (dup << <NUM_LIT:3>)   <EOL>request.dup = dup<EOL>if request.interval:    <EOL><INDENT>request.alarm = self.callLater(request.interval(len(request.encoded)), self._publishError, request)<EOL><DEDENT>if request.msgId is None:<EOL><INDENT>log.debug(\"<STR_LIT>\", packet=\"<STR_LIT>\", request=request, dup=dup)<EOL><DEDENT>else:<EOL><INDENT>log.debug(\"<STR_LIT>\", packet=\"<STR_LIT>\", request=request, dup=dup)<EOL><DEDENT>self.transport.write(str(request.encoded) if PY2 else bytes(request.encoded))<EOL>", "docstring": "Transmit/Retransmit one PUBLISH packet", "id": "f12844:c4:m25"}
{"signature": "def _purgeSession(self, reason):", "body": "<EOL>for k in list(self.factory.windowPublish[self.addr]):<EOL><INDENT>request = self.factory.windowPublish[self.addr][k]<EOL>del self.factory.windowPublish[self.addr][k]<EOL>request.deferred.errback(reason)<EOL><DEDENT>for k in list(self.factory.windowPubRelease[self.addr]):<EOL><INDENT>request = self.factory.windowPubRelease[self.addr][k]<EOL>del self.factory.windowPubRelease[self.addr][k]<EOL>request.deferred.errback(reason)<EOL><DEDENT>", "docstring": "Purges the persistent state in the client", "id": "f12844:c4:m31"}
{"signature": "def _checkUnsubscribe(self, request):", "body": "if len(self.factory.windowUnsubscribe[self.addr]) == self._window:<EOL><INDENT>raise MQTTWindowError(\"<STR_LIT>\", self._window)<EOL><DEDENT>if not isinstance(request.topics, list):<EOL><INDENT>raise TopicTypeError(type(topic))<EOL><DEDENT>", "docstring": "Assert unsubscribe parameters", "id": "f12844:c4:m23"}
{"signature": "def mqttConnectionMade(self):", "body": "if self._cleanStart:<EOL><INDENT>self._purgeSession(MQTTSessionCleared())<EOL><DEDENT>else:<EOL><INDENT>self._syncSession()<EOL><DEDENT>if self.onMqttConnectionMade:<EOL><INDENT>self.onMqttConnectionMade()<EOL><DEDENT>", "docstring": "Called when a CONNACK has been received (publisher only).", "id": "f12844:c4:m12"}
{"signature": "def handlePUBREL(self, response):", "body": "try:<EOL><INDENT>msg = self.factory.windowPubRx[self.addr][response.msgId]<EOL><DEDENT>except KeyError as e:<EOL><INDENT>log.debug(\"<STR_LIT>\" , packet=\"<STR_LIT>\", response=response)<EOL><DEDENT>else:<EOL><INDENT>log.debug(\"<STR_LIT>\" , packet=\"<STR_LIT>\", response=response)<EOL>del self.factory.windowPubRx[self.addr][response.msgId]<EOL>self._deliver(msg)<EOL>reply = PUBCOMP()<EOL>reply.msgId = response.msgId<EOL>reply.encode()<EOL>log.debug(\"<STR_LIT>\" , packet=\"<STR_LIT>\", response=response)<EOL>self.transport.write(reply.encode())<EOL><DEDENT>", "docstring": "Handle PUBREL control packet received.", "id": "f12844:c4:m8"}
{"signature": "def doUnsubscribe(self, request):", "body": "request.msgId = self.factory.makeId()<EOL>if isinstance(request.topics, str):<EOL><INDENT>request.topics = [request.topics]<EOL><DEDENT>try:<EOL><INDENT>self._checkUnsubscribe(request)<EOL>request.msgId = self.factory.makeId()<EOL>request.encode() <EOL><DEDENT>except Exception as e:<EOL><INDENT>return defer.fail(e)<EOL><DEDENT>request.interval = Interval(initial=self._initialT)<EOL>request.deferred = defer.Deferred()<EOL>request.deferred.msgId = request.msgId<EOL>self.factory.windowUnsubscribe[self.addr][request.msgId] = request<EOL>self._retryUnsubscribe(request, dup=False)<EOL>return  request.deferred<EOL>", "docstring": "Send an UNSUBSCRIBE control packet", "id": "f12844:c4:m14"}
{"signature": "def handlePUBACK(self, response):", "body": "<EOL>try:<EOL><INDENT>request = self.factory.windowPublish[self.addr][response.msgId]<EOL><DEDENT>except KeyError as e:<EOL><INDENT>log.debug(\"<STR_LIT>\", packet=\"<STR_LIT>\", response=response)<EOL><DEDENT>else:<EOL><INDENT>log.debug(\"<STR_LIT>\", packet=\"<STR_LIT>\", response=response)<EOL>request.alarm.cancel()<EOL>request.deferred.callback(request.msgId)<EOL>del self.factory.windowPublish[self.addr][response.msgId]<EOL>self._refillPublish(dup=False)<EOL><DEDENT>", "docstring": "Handle PUBACK control packet received (QoS=1).", "id": "f12844:c4:m9"}
{"signature": "def _checkPublish(self, request):", "body": "if not ( <NUM_LIT:0><= request.qos < <NUM_LIT:3>):<EOL><INDENT>raise QoSValueError(\"<STR_LIT>\",request.qos)<EOL><DEDENT>", "docstring": "Assert publish parameters", "id": "f12844:c4:m29"}
{"signature": "def __call__(self, size):", "body": "self._value = self.initial + (self._k*size)/self.bandwith<EOL>self._k    *= self.factor<EOL>return self._value + random.random()<EOL>", "docstring": "Call the interval to produce a new delay time taking into account the bandwith", "id": "f12845:c1:m1"}
{"signature": "def __call__(self):", "body": "self._value *= self.factor<EOL>self._value = min(self._value, self.maxDelay)<EOL>return self._value + random.random()<EOL>", "docstring": "Call the interval to produce a new delay time", "id": "f12845:c0:m1"}
{"signature": "def onDisconnection(self, reason):", "body": "log.debug(\"<STR_LIT>\", r=reason)<EOL>self.whenConnected().addCallback(self.connectToBroker)<EOL>", "docstring": "get notfied of disconnections\nand get a deferred for a new protocol object (next retry)", "id": "f12851:c0:m3"}
{"signature": "def startLogging(console=True, filepath=None):", "body": "global logLevelFilterPredicate<EOL>observers = []<EOL>if console:<EOL><INDENT>observers.append( FilteringLogObserver(observer=textFileLogObserver(sys.stdout),  <EOL>predicates=[logLevelFilterPredicate] ))<EOL><DEDENT>if filepath is not None and filepath != \"<STR_LIT>\":<EOL><INDENT>observers.append( FilteringLogObserver(observer=textFileLogObserver(open(filepath,'<STR_LIT:a>')), <EOL>predicates=[logLevelFilterPredicate] ))<EOL><DEDENT>globalLogBeginner.beginLoggingTo(observers)<EOL>", "docstring": "Starts the global Twisted logger subsystem with maybe\nstdout and/or a file specified in the config file", "id": "f12851:m0"}
{"signature": "@inlineCallbacks<EOL><INDENT>def connectToBroker(self, protocol):<DEDENT>", "body": "self.protocol                 = protocol<EOL>self.protocol.onPublish       = self.onPublish<EOL>self.protocol.onDisconnection = self.onDisconnection<EOL>self.protocol.setWindowSize(<NUM_LIT:3>) <EOL>try:<EOL><INDENT>yield self.protocol.connect(\"<STR_LIT>\", keepalive=<NUM_LIT>)<EOL>yield self.subscribe()<EOL><DEDENT>except Exception as e:<EOL><INDENT>log.error(\"<STR_LIT>\", <EOL>broker=BROKER, excp=e)<EOL><DEDENT>else:<EOL><INDENT>log.info(\"<STR_LIT>\", broker=BROKER)<EOL><DEDENT>", "docstring": "Connect to MQTT broker", "id": "f12852:c0:m2"}
{"signature": "@inlineCallbacks<EOL><INDENT>def connectToBroker(self, protocol):<DEDENT>", "body": "self.protocol                 = protocol<EOL>self.protocol.onPublish       = self.onPublish<EOL>self.protocol.onDisconnection = self.onDisconnection<EOL>self.protocol.setWindowSize(<NUM_LIT:3>)<EOL>self.task = task.LoopingCall(self.publish)<EOL>self.task.start(<NUM_LIT>, now=False) <EOL>try:<EOL><INDENT>yield self.protocol.connect(\"<STR_LIT>\", keepalive=<NUM_LIT>)<EOL>yield self.subscribe()<EOL><DEDENT>except Exception as e:<EOL><INDENT>log.error(\"<STR_LIT>\", <EOL>broker=BROKER, excp=e)<EOL><DEDENT>else:<EOL><INDENT>log.info(\"<STR_LIT>\", broker=BROKER)<EOL><DEDENT>", "docstring": "Connect to MQTT broker", "id": "f12853:c0:m2"}
{"signature": "def startLogging(console=True, filepath=None):", "body": "global logLevelFilterPredicate<EOL>observers = []<EOL>if console:<EOL><INDENT>observers.append( FilteringLogObserver(observer=textFileLogObserver(sys.stdout),  <EOL>predicates=[logLevelFilterPredicate] ))<EOL><DEDENT>if filepath is not None and filepath != \"<STR_LIT>\":<EOL><INDENT>observers.append( FilteringLogObserver(observer=textFileLogObserver(open(filepath,'<STR_LIT:a>')), <EOL>predicates=[logLevelFilterPredicate] ))<EOL><DEDENT>globalLogBeginner.beginLoggingTo(observers)<EOL>", "docstring": "Starts the global Twisted logger subsystem with maybe\nstdout and/or a file specified in the config file", "id": "f12853:m0"}
{"signature": "def build_callback_url(request, urlname, message):", "body": "location = reverse(urlname, kwargs={\"<STR_LIT>\": message.pk})<EOL>callback_domain = getattr(settings, \"<STR_LIT>\", None)<EOL>if callback_domain:<EOL><INDENT>url = \"<STR_LIT>\".format(<EOL>\"<STR_LIT>\" if getattr(settings, \"<STR_LIT>\", False) else \"<STR_LIT:http>\",<EOL>callback_domain,<EOL>location<EOL>)<EOL><DEDENT>elif request is not None:<EOL><INDENT>url = request.build_absolute_uri(location)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>return url<EOL>", "docstring": "Build Twilio callback url for confirming message delivery status\n\n:type message: OutgoingSMS", "id": "f12860:m0"}
{"signature": "def send_sms(request, to_number, body, callback_urlname=\"<STR_LIT>\"):", "body": "client = TwilioRestClient(settings.TWILIO_ACCOUNT_SID, settings.TWILIO_AUTH_TOKEN)<EOL>from_number = settings.TWILIO_PHONE_NUMBER<EOL>message = OutgoingSMS.objects.create(<EOL>from_number=from_number,<EOL>to_number=to_number,<EOL>body=body,<EOL>)<EOL>status_callback = None<EOL>if callback_urlname:<EOL><INDENT>status_callback = build_callback_url(request, callback_urlname, message)<EOL><DEDENT>logger.debug(\"<STR_LIT>\",<EOL>to_number, status_callback, body)<EOL>if not getattr(settings, \"<STR_LIT>\", False):<EOL><INDENT>sent = client.sms.messages.create(<EOL>to=to_number,<EOL>from_=from_number,<EOL>body=body,<EOL>status_callback=status_callback<EOL>)<EOL>logger.debug(\"<STR_LIT>\", sent.__dict__)<EOL>message.sms_sid = sent.sid<EOL>message.account_sid = sent.account_sid<EOL>message.status = sent.status<EOL>message.to_parsed = sent.to<EOL>if sent.price:<EOL><INDENT>message.price = Decimal(force_text(sent.price))<EOL>message.price_unit = sent.price_unit<EOL><DEDENT>message.sent_at = sent.date_created<EOL>message.save(update_fields=[<EOL>\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT:status>\", \"<STR_LIT>\",<EOL>\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"<EOL>])<EOL><DEDENT>else:<EOL><INDENT>logger.info(\"<STR_LIT>\", from_number, to_number, body)<EOL><DEDENT>return message<EOL>", "docstring": "Create :class:`OutgoingSMS` object and send SMS using Twilio.", "id": "f12860:m1"}
{"signature": "def twilio_view(f):", "body": "@csrf_exempt<EOL>@wraps(f)<EOL>def decorator(request, *args, **kwargs):<EOL><INDENT>if request.method != \"<STR_LIT:POST>\":<EOL><INDENT>logger.error(\"<STR_LIT>\", extra={\"<STR_LIT>\": request})<EOL>return HttpResponseNotAllowed(request.method)<EOL><DEDENT>if not getattr(settings, \"<STR_LIT>\"):<EOL><INDENT>try:<EOL><INDENT>validator = RequestValidator(settings.TWILIO_AUTH_TOKEN)<EOL>url = request.build_absolute_uri()<EOL>if \"<STR_LIT>\" in request.META:<EOL><INDENT>protocol = \"<STR_LIT>\" if request.META[\"<STR_LIT>\"] == \"<STR_LIT>\" else \"<STR_LIT:http>\"<EOL>url = \"<STR_LIT>\".format(<EOL>protocol, request.META[\"<STR_LIT>\"], request.META[\"<STR_LIT>\"]<EOL>)<EOL><DEDENT>signature = request.META[\"<STR_LIT>\"]<EOL><DEDENT>except (AttributeError, KeyError) as e:<EOL><INDENT>logger.exception(\"<STR_LIT>\", extra={\"<STR_LIT>\": request})<EOL>return HttpResponseForbidden(\"<STR_LIT>\" % e)<EOL><DEDENT>if not validator.validate(url, request.POST, signature):<EOL><INDENT>logger.error(<EOL>\"<STR_LIT>\",<EOL>url, request.POST, signature, extra={\"<STR_LIT>\": request}<EOL>)<EOL>return HttpResponseForbidden(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>response = f(request, *args, **kwargs)<EOL>if isinstance(response, six.text_type):<EOL><INDENT>return HttpResponse(response, mimetype=\"<STR_LIT>\")<EOL><DEDENT>elif isinstance(response, Verb):<EOL><INDENT>return HttpResponse(force_text(response), mimetype=\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>return response<EOL><DEDENT><DEDENT>return decorator<EOL>", "docstring": "This decorator provides several helpful shortcuts for writing Twilio\n    views.\n\n        - It ensures that only requests from Twilio are passed through. This\n          helps protect you from forged requests.\n\n        - It ensures your view is exempt from CSRF checks via Django's\n          @csrf_exempt decorator. This is necessary for any view that accepts\n          POST requests from outside the local domain (eg: Twilio's servers).\n\n        - It allows your view to (optionally) return TwiML to pass back to\n          Twilio's servers instead of building a ``HttpResponse`` object\n          manually.\n\n        - It allows your view to (optionally) return any ``twilio.Verb`` object\n          instead of building a ``HttpResponse`` object manually.\n\n    Usage::\n\n        from twilio.twiml import Response\n\n        @twilio_view\n        def my_view(request):\n            r = Response()\n            r.sms(\"Thanks for the SMS message!\")\n            return r", "id": "f12862:m0"}
{"signature": "def pathMatches(path, urlName, **kwargs):", "body": "resolved = urlresolvers.resolve(path)<EOL>resolvedName = '<STR_LIT>'.format(r = resolved) if resolved.namespace else resolved.url_name<EOL>if urlName != resolvedName:<EOL><INDENT>return False<EOL><DEDENT>for key, value in kwargs.items():<EOL><INDENT>currentArg = resolved.kwargs.get(key)<EOL>if currentArg is None or str(value) != str(currentArg):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": ":param path: str\n:param urlName: str\n:returns: bool.", "id": "f12864:m1"}
{"signature": "def extendManager(mixinClass):", "body": "class MixinManager(models.Manager, mixinClass):<EOL><INDENT>class MixinQuerySet(models.query.QuerySet, mixinClass):<EOL><INDENT>pass<EOL><DEDENT>def get_queryset(self):<EOL><INDENT>return self.MixinQuerySet(self.model, using = self._db)<EOL><DEDENT><DEDENT>return MixinManager()<EOL>", "docstring": "Use as a class decorator to add extra methods to your model manager.\nExample usage:\n\n        class Article(django.db.models.Model):\n                published = models.DateTimeField()\n                ...\n\n                @extendManager\n                class objects(object):\n                        def getPublished(self):\n                                return self.filter(published__lte = django.utils.timezone.now()).order_by('-published')\n\n        ...\n\n        publishedArticles = Article.objects.getPublished()", "id": "f12869:m0"}
{"signature": "def is_glacier(s3_client, bucket, prefix):", "body": "response = s3_client.list_objects_v2(Bucket=bucket,<EOL>Prefix=prefix,<EOL>MaxKeys=<NUM_LIT:3>)  <EOL>for key in response['<STR_LIT>']:<EOL><INDENT>if key.get('<STR_LIT>', '<STR_LIT>') == '<STR_LIT>':<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Check if prefix is archived in Glacier, by checking storage class of\n    first object inside that prefix\n\n    Arguments:\n    s3_client - boto3 S3 client (not service)\n    bucket - valid extracted bucket (without protocol and prefix)\n             example: sowplow-events-data\n    prefix - valid S3 prefix (usually, run_id)\n             example: snowplow-archive/enriched/archive/", "id": "f12874:m3"}
{"signature": "def normalize_prefix(path):", "body": "if path is None or path is '<STR_LIT>' or path is '<STR_LIT:/>':<EOL><INDENT>return None<EOL><DEDENT>elif path.endswith('<STR_LIT:/>'):<EOL><INDENT>return path<EOL><DEDENT>else:<EOL><INDENT>return path + '<STR_LIT:/>'<EOL><DEDENT>", "docstring": "Add trailing slash to prefix if it is not present\n\n    >>> normalize_prefix(\"somepath\")\n    'somepath/'\n    >>> normalize_prefix(\"somepath/\")\n    'somepath/'", "id": "f12874:m5"}
{"signature": "def cli_run():", "body": "parser = argparse.ArgumentParser(description='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>', help=\"<STR_LIT>\", type=str, nargs='<STR_LIT:+>')<EOL>parser.add_argument('<STR_LIT>','<STR_LIT>', help='<STR_LIT>')<EOL>args = parser.parse_args()<EOL>main(args)<EOL>", "docstring": "docstring for argparse", "id": "f12880:m1"}
{"signature": "def hotspots(self):", "body": "rooted_leaf_samples, _ = self.live_data_copy()<EOL>line_samples = {}<EOL>for _, counts in rooted_leaf_samples.items():<EOL><INDENT>for key, count in counts.items():<EOL><INDENT>line_samples.setdefault(key, <NUM_LIT:0>)<EOL>line_samples[key] += count<EOL><DEDENT><DEDENT>return sorted(<EOL>line_samples.items(), key=lambda v: v[<NUM_LIT:1>], reverse=True)<EOL>", "docstring": "Get lines sampled accross all threads, in order\nfrom most to least sampled.", "id": "f12886:c0:m5"}
{"signature": "def samples_available(self):", "body": "return lib.lsl_samples_available(self.obj)<EOL>", "docstring": "Query whether samples are currently available for immediate pickup.\n\n        Note that it is not a good idea to use samples_available() to determine \n        whether a pull_*() call would block: to be sure, set the pull timeout \n        to 0.0 or an acceptably low value. If the underlying implementation \n        supports it, the value will be the number of samples available \n        (otherwise it will be 1 or 0).", "id": "f12888:c2:m8"}
{"signature": "def handle_error(errcode):", "body": "if type(errcode) is c_int:<EOL><INDENT>errcode = errcode.value<EOL><DEDENT>if errcode == <NUM_LIT:0>:<EOL><INDENT>pass  <EOL><DEDENT>elif errcode == -<NUM_LIT:1>:<EOL><INDENT>raise TimeoutError(\"<STR_LIT>\")<EOL><DEDENT>elif errcode == -<NUM_LIT:2>:<EOL><INDENT>raise LostError(\"<STR_LIT>\")<EOL><DEDENT>elif errcode == -<NUM_LIT:3>:<EOL><INDENT>raise InvalidArgumentError(\"<STR_LIT>\")<EOL><DEDENT>elif errcode == -<NUM_LIT:4>:<EOL><INDENT>raise InternalError(\"<STR_LIT>\")<EOL><DEDENT>elif errcode < <NUM_LIT:0>: <EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Error handler function. Translates an error code into an exception.", "id": "f12888:m8"}
{"signature": "def hostname(self):", "body": "return lib.lsl_get_hostname(self.obj).decode('<STR_LIT:utf-8>')<EOL>", "docstring": "Hostname of the providing machine.", "id": "f12888:c0:m12"}
{"signature": "def library_info():", "body": "return lib.lsl_library_info().decode('<STR_LIT:utf-8>')<EOL>", "docstring": "Get a string containing library information. The format of the string shouldn't be used\n    for anything important except giving a a debugging person a good idea which exact library\n    version is used.", "id": "f12888:m2"}
{"signature": "def resolve_streams(wait_time=<NUM_LIT:1.0>):", "body": "<EOL>buffer = (c_void_p*<NUM_LIT>)()<EOL>num_found = lib.lsl_resolve_all(byref(buffer), <NUM_LIT>, c_double(wait_time))<EOL>return [StreamInfo(handle=buffer[k]) for k in range(num_found)]<EOL>", "docstring": "Resolve all streams on the network.\n\n    This function returns all currently available streams from any outlet on \n    the network. The network is usually the subnet specified at the local \n    router, but may also include a group of machines visible to each other via \n    multicast packets (given that the network supports it), or list of \n    hostnames. These details may optionally be customized by the experimenter \n    in a configuration file (see Network Connectivity in the LSL wiki).  \n\n    Keyword arguments:\n    wait_time -- The waiting time for the operation, in seconds, to search for \n                 streams. Warning: If this is too short (<0.5s) only a subset \n                 (or none) of the outlets that are present on the network may \n                 be returned. (default 1.0)\n\n    Returns a list of StreamInfo objects (with empty desc field), any of which \n    can subsequently be used to open an inlet. The full description can be\n    retrieved from the inlet.", "id": "f12888:m4"}
{"signature": "def next_sibling(self, name=None):", "body": "if name is None:<EOL><INDENT>return XMLElement(lib.lsl_next_sibling(self.e))<EOL><DEDENT>else:<EOL><INDENT>return XMLElement(lib.lsl_next_sibling_n(self.e, str.encode(name)))<EOL><DEDENT>", "docstring": "Get the next sibling in the children list of the parent node.\n\n        If a name is provided, the next sibling with the given name is returned.", "id": "f12888:c3:m4"}
{"signature": "def time_correction(self, timeout=FOREVER):", "body": "errcode = c_int()<EOL>result = lib.lsl_time_correction(self.obj, c_double(timeout),<EOL>byref(errcode))<EOL>handle_error(errcode)<EOL>return result<EOL>", "docstring": "Retrieve an estimated time correction offset for the given stream.\n\n        The first call to this function takes several miliseconds until a \n        reliable first estimate is obtained. Subsequent calls are instantaneous \n        (and rely on periodic background updates). The precision of these \n        estimates should be below 1 ms (empirically within +/-0.2 ms).\n\n        Keyword arguments: \n        timeout -- Timeout to acquire the first time-correction estimate \n                   (default FOREVER).\n\n        Returns the current time correction estimate. This is the number that \n        needs to be added to a time stamp that was remotely generated via \n        local_clock() to map it into the local clock domain of this \n        machine.\n\n        Throws a TimeoutError (if the timeout expires), or LostError (if the \n        stream source has been lost).", "id": "f12888:c2:m5"}
{"signature": "def parent(self):", "body": "return XMLElement(lib.lsl_parent(self.e))<EOL>", "docstring": "Get the parent node.", "id": "f12888:c3:m6"}
{"signature": "def __del__(self):", "body": "<EOL>try:<EOL><INDENT>lib.lsl_destroy_inlet(self.obj)<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Destructor. The inlet will automatically disconnect if destroyed.", "id": "f12888:c2:m1"}
{"signature": "def pull_chunk(self, timeout=<NUM_LIT:0.0>, max_samples=<NUM_LIT>, dest_obj=None):", "body": "<EOL>num_channels = self.channel_count<EOL>max_values = max_samples*num_channels<EOL>if max_samples not in self.buffers:<EOL><INDENT>self.buffers[max_samples] = ((self.value_type*max_values)(),<EOL>(c_double*max_samples)())<EOL><DEDENT>if dest_obj is not None:<EOL><INDENT>data_buff = (self.value_type * max_values).from_buffer(dest_obj)<EOL><DEDENT>else:<EOL><INDENT>data_buff = self.buffers[max_samples][<NUM_LIT:0>]<EOL><DEDENT>ts_buff = self.buffers[max_samples][<NUM_LIT:1>]<EOL>errcode = c_int()<EOL>num_elements = self.do_pull_chunk(self.obj, byref(data_buff),<EOL>byref(ts_buff), max_values,<EOL>max_samples, c_double(timeout),<EOL>byref(errcode))<EOL>handle_error(errcode)<EOL>num_samples = num_elements/num_channels<EOL>if dest_obj is None:<EOL><INDENT>samples = [[data_buff[s*num_channels+c] for c in range(num_channels)]<EOL>for s in range(int(num_samples))]<EOL>if self.channel_format == cf_string:<EOL><INDENT>samples = [[v.decode('<STR_LIT:utf-8>') for v in s] for s in samples]<EOL>free_char_p_array_memory(data_buff, max_values)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>samples = None<EOL><DEDENT>timestamps = [ts_buff[s] for s in range(int(num_samples))]<EOL>return samples, timestamps<EOL>", "docstring": "Pull a chunk of samples from the inlet.\n\n        Keyword arguments:\n        timeout -- The timeout of the operation; if passed as 0.0, then only \n                   samples available for immediate pickup will be returned. \n                   (default 0.0)\n        max_samples -- Maximum number of samples to return. (default \n                       1024)\n        dest_obj -- A Python object that supports the buffer interface.\n                    If this is provided then the dest_obj will be updated in place\n                    and the samples list returned by this method will be empty.\n                    It is up to the caller to trim the buffer to the appropriate\n                    number of samples.\n                    A numpy buffer must be order='C'\n                    (default None)\n\n        Returns a tuple (samples,timestamps) where samples is a list of samples \n        (each itself a list of values), and timestamps is a list of time-stamps.\n\n        Throws a LostError if the stream source has been lost.", "id": "f12888:c2:m7"}
{"signature": "def pull_sample(self, timeout=FOREVER, sample=None):", "body": "<EOL>if type(timeout) is list:<EOL><INDENT>assign_to = timeout<EOL>timeout = sample if type(sample) is float else <NUM_LIT:0.0><EOL><DEDENT>else:<EOL><INDENT>assign_to = None<EOL><DEDENT>errcode = c_int()<EOL>timestamp = self.do_pull_sample(self.obj, byref(self.sample),<EOL>self.channel_count, c_double(timeout),<EOL>byref(errcode))<EOL>handle_error(errcode)<EOL>if timestamp:<EOL><INDENT>sample = [v for v in self.sample]<EOL>if self.channel_format == cf_string:<EOL><INDENT>sample = [v.decode('<STR_LIT:utf-8>') for v in sample]<EOL><DEDENT>if assign_to is not None:<EOL><INDENT>assign_to[:] = sample<EOL><DEDENT>return sample, timestamp<EOL><DEDENT>else:<EOL><INDENT>return None, None<EOL><DEDENT>", "docstring": "Pull a sample from the inlet and return it.\n\n        Keyword arguments:\n        timeout -- The timeout for this operation, if any. (default FOREVER)\n                   If this is passed as 0.0, then the function returns only a \n                   sample if one is buffered for immediate pickup.\n\n        Returns a tuple (sample,timestamp) where sample is a list of channel \n        values and timestamp is the capture time of the sample on the remote \n        machine, or (None,None) if no new sample was available. To remap this \n        time stamp to the local clock, add the value returned by \n        .time_correction() to it. \n\n        Throws a LostError if the stream source has been lost. Note that, if \n        the timeout expires, no TimeoutError is thrown (because this case is \n        not considered an error).", "id": "f12888:c2:m6"}
{"signature": "def child(self, name):", "body": "return XMLElement(lib.lsl_child(self.e, str.encode(name)))<EOL>", "docstring": "Get a child with a specified name.", "id": "f12888:c3:m3"}
{"signature": "def previous_sibling(self, name=None):", "body": "if name is None:<EOL><INDENT>return XMLElement(lib.lsl_previous_sibling(self.e))<EOL><DEDENT>else:<EOL><INDENT>return XMLElement(lib.lsl_previous_sibling_n(self.e,<EOL>str.encode(name)))<EOL><DEDENT>", "docstring": "Get the previous sibling in the children list of the parent node.\n\n        If a name is provided, the previous sibling with the given name is\n        returned.", "id": "f12888:c3:m5"}
{"signature": "def desc(self):", "body": "return XMLElement(lib.lsl_get_desc(self.obj))<EOL>", "docstring": "Extended description of the stream.\n\n        It is highly recommended that at least the channel labels are described \n        here. See code examples on the LSL wiki. Other information, such \n        as amplifier settings, measurement units if deviating from defaults, \n        setup information, subject information, etc., can be specified here, as \n        well. Meta-data recommendations follow the XDF file format project\n        (github.com/sccn/xdf/wiki/Meta-Data or web search for: XDF meta-data).\n\n        Important: if you use a stream content type for which meta-data \n        recommendations exist, please try to lay out your meta-data in \n        agreement with these recommendations for compatibility with other \n        applications.", "id": "f12888:c0:m13"}
{"signature": "def set_child_value(self, name, value):", "body": "return XMLElement(lib.lsl_set_child_value(self.e,<EOL>str.encode(name),<EOL>str.encode(value)))<EOL>", "docstring": "Set the text value of the (nameless) plain-text child of a named \n        child node.", "id": "f12888:c3:m14"}
{"signature": "def __init__(self, handle):", "body": "self.e = c_void_p(handle)<EOL>", "docstring": "Construct new XML element from existing handle.", "id": "f12888:c3:m0"}
{"signature": "def session_id(self):", "body": "return lib.lsl_get_session_id(self.obj).decode('<STR_LIT:utf-8>')<EOL>", "docstring": "Session ID for the given stream.\n\n        The session id is an optional human-assigned identifier of the \n        recording session. While it is rarely used, it can be used to prevent \n        concurrent recording activitites on the same sub-network (e.g., in \n        multiple experiment areas) from seeing each other's streams \n        (can be assigned in a configuration file read by liblsl, see also \n        Network Connectivity in the LSL wiki).", "id": "f12888:c0:m11"}
{"signature": "def name(self):", "body": "return lib.lsl_name(self.e).decode('<STR_LIT:utf-8>')<EOL>", "docstring": "Name of the element.", "id": "f12888:c3:m9"}
{"signature": "def __init__(self, class_list=[<NUM_LIT:1>, <NUM_LIT:3>], classes_rand=True, target_list=[<NUM_LIT:1>, <NUM_LIT:2>], targets_rand=True):", "body": "stream_name = '<STR_LIT>'<EOL>stream_type = '<STR_LIT>'<EOL>outlet_info = StreamInfo(name=stream_name, type=stream_type,<EOL>channel_count=<NUM_LIT:1>, nominal_srate=<NUM_LIT:0>,<EOL>channel_format='<STR_LIT:string>',<EOL>source_id='<STR_LIT>')<EOL>outlet_xml = outlet_info.desc()<EOL>channels_xml = outlet_xml.append_child(\"<STR_LIT>\")<EOL>chan_xml = channels_xml.append_child(\"<STR_LIT>\")<EOL>chan_xml.append_child_value(\"<STR_LIT:label>\", \"<STR_LIT>\")<EOL>chan_xml.append_child_value(\"<STR_LIT:type>\", \"<STR_LIT>\")<EOL>self.outlet = StreamOutlet(outlet_info)<EOL>print(\"<STR_LIT>\".format(stream_name, stream_type))<EOL>self.class_list = class_list<EOL>self.classes_rand = classes_rand<EOL>self.target_list = target_list<EOL>self.targets_rand = targets_rand<EOL>self.next_transition = -<NUM_LIT:1><EOL>self.in_phase = '<STR_LIT>'<EOL>self.trial_ix = <NUM_LIT:0><EOL>self.class_id = self.class_list[<NUM_LIT:0>]<EOL>self.target_id = self.target_list[<NUM_LIT:0>]<EOL>", "docstring": ":param class_list:  A list of integers comprising different class ids. Default: [1, 3]\n:param classes_rand: If True, classes are chosen randomly from list. If False, the list is cycled. Default: True\n:param target_list: A list of integers comprising different target ids. Default: [1, 2]\n:param targets_rand: If True, targets are chosen randomly from list. If False, the list is cycled. Default: True", "id": "f12892:c3:m0"}
{"signature": "def __init__(self, Fs=<NUM_LIT:2>**<NUM_LIT>, FreqBeta=<NUM_LIT>, AmpBeta=<NUM_LIT>, AmpNoise=<NUM_LIT>, NCyclesPerChunk=<NUM_LIT:4>,<EOL>channels=[\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]):", "body": "<EOL>self.FreqBeta = FreqBeta<EOL>self.AmpBeta = AmpBeta                                          <EOL>self.AmpNoise = AmpNoise                                        <EOL>self.channels = channels<EOL>chunk_dur = NCyclesPerChunk / self.FreqBeta           <EOL>chunk_len = int(Fs * chunk_dur)                  <EOL>self.tvec = <NUM_LIT:1.0> * (np.arange(chunk_len) + <NUM_LIT:1>) / Fs     <EOL>self.pinkNoiseGen = PinkNoiseGenerator(nSampsPerBlock=chunk_len)<EOL>raw_info = StreamInfo(name='<STR_LIT>', type='<STR_LIT>',<EOL>channel_count=len(self.channels), nominal_srate=Fs,<EOL>channel_format='<STR_LIT>', source_id='<STR_LIT>')<EOL>raw_xml = raw_info.desc()<EOL>chans = raw_xml.append_child(\"<STR_LIT>\")<EOL>for channame in self.channels:<EOL><INDENT>chn = chans.append_child(\"<STR_LIT>\")<EOL>chn.append_child_value(\"<STR_LIT:label>\", channame)<EOL>chn.append_child_value(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>chn.append_child_value(\"<STR_LIT:type>\", \"<STR_LIT>\")<EOL><DEDENT>self.eeg_outlet = StreamOutlet(raw_info)<EOL>print(\"<STR_LIT>\")<EOL>self.last_time = local_clock()<EOL>", "docstring": ":param Fs:              Sampling rate\n:param FreqBeta:        Central frequency of beta band\n:param AmpBeta:         Amplitude of beta (uV)\n:param AmpNoise:        Amplitude of pink noise (uV)\n:param NCyclesPerChunk: Minimum number of cycles of beta in a chunk.\n:param channels:        List of channel names", "id": "f12892:c1:m0"}
{"signature": "def normalize(y, x=None):", "body": "<EOL>if x is not None:<EOL><INDENT>x = ms(x)<EOL><DEDENT>else:<EOL><INDENT>x = <NUM_LIT:1.0><EOL><DEDENT>return y * np.sqrt( x / ms(y) )<EOL>", "docstring": "normalize power in y to a (standard normal) white noise signal.\n    Optionally normalize to power in signal `x`.\n    #The mean power of a Gaussian with :math:`\\\\mu=0` and :math:`\\\\sigma=1` is 1.", "id": "f12892:m1"}
{"signature": "def init_app(self, app):", "body": "if not hasattr(app, \"<STR_LIT>\"):  <EOL><INDENT>app.extensions = {}<EOL><DEDENT>app.extensions[\"<STR_LIT>\"] = self<EOL>@app.before_request<EOL>def start_context(*a, **k):<EOL><INDENT>self.overrides.push(Override())<EOL>self.additional.push(Additional())<EOL><DEDENT>@app.after_request<EOL>def cleanup(response):<EOL><INDENT>self.clear_all_overrides()<EOL>self.clear_all_additional()<EOL>return response<EOL><DEDENT>", "docstring": "Initializes the Flask-Allows object against the provided application", "id": "f12909:c0:m1"}
{"signature": "def run(<EOL>self,<EOL>requirements,<EOL>identity=None,<EOL>throws=None,<EOL>on_fail=None,<EOL>f_args=(),<EOL>f_kwargs=ImmutableDict(),  <EOL>use_on_fail_return=True,<EOL>):", "body": "throws = throws or self.throws<EOL>on_fail = _make_callable(on_fail) if on_fail is not None else self.on_fail<EOL>if not self.fulfill(requirements, identity):<EOL><INDENT>result = on_fail(*f_args, **f_kwargs)<EOL>if use_on_fail_return and result is not None:<EOL><INDENT>return result<EOL><DEDENT>raise throws<EOL><DEDENT>", "docstring": "Used to preform a full run of the requirements and the options given,\nthis method will invoke on_fail and/or throw the appropriate exception\ntype. Can be passed arguments to call on_fail with via f_args (which are\npassed positionally) and f_kwargs (which are passed as keyword).\n\n:param requirements: The requirements to check\n:param identity: Optional. A specific identity to use for the check\n:param throws: Optional. A specific exception to throw for this check\n:param on_fail: Optional. A callback to invoke after failure,\n    alternatively a value to return when failure happens\n:param f_args: Positional arguments to pass to the on_fail callback\n:param f_kwargs: Keyword arguments to pass to the on_fail callback\n:param use_on_fail_return: Boolean (default True) flag to determine\n    if the return value should be used. If true, the return value\n    will be considered, else failure will always progress to\n    exception raising.", "id": "f12909:c0:m7"}
{"signature": "@contextmanager<EOL><INDENT>def additional(self, additional, use_parent=False):<DEDENT>", "body": "self.push(additional, use_parent)<EOL>yield self.current<EOL>self.pop()<EOL>", "docstring": "Allows temporarily pushing an additional context, yields the new context\ninto the following block.", "id": "f12912:c1:m3"}
{"signature": "def wants_request(f):", "body": "@wraps(f)<EOL>def wrapper(user):<EOL><INDENT>return f(user, request)<EOL><DEDENT>return wrapper<EOL>", "docstring": "Helper decorator for transitioning to user-only requirements, this aids\nin situations where the request may be marked optional and causes an\nincorrect flow into user-only requirements.\n\nThis decorator causes the requirement to look like a user-only requirement\nbut passes the current request context internally to the requirement.\n\nThis decorator is intended only to assist during a transitionary phase\nand will be removed in flask-allows 1.0\n\nSee: :issue:`20,27`", "id": "f12913:m0"}
{"signature": "@abstractmethod<EOL><INDENT>def fulfill(self, user, request=None):<DEDENT>", "body": "return NotImplemented<EOL>", "docstring": "Abstract method called to verify the requirement against the current\nuser and request.\n\n.. versionchanged:: 0.5.0\n    Passing request is now deprecated, pending removal in version 1.0.0\n\n:param user: The current identity\n:param request: The current request.", "id": "f12913:c0:m0"}
{"signature": "@contextmanager<EOL><INDENT>def override(self, override, use_parent=False):<DEDENT>", "body": "self.push(override, use_parent)<EOL>yield self.current<EOL>self.pop()<EOL>", "docstring": "Allows temporarily pushing an override context, yields the new context\ninto the following block.", "id": "f12914:c1:m3"}
{"signature": "def remove(self, requirement, *requirements):", "body": "self._requirements.difference_update((requirement,) + requirements)<EOL>", "docstring": "Removes one or more requirements from the override context.", "id": "f12914:c0:m2"}
{"signature": "def is_overridden(self, requirement):", "body": "return requirement in self._requirements<EOL>", "docstring": "Checks if a particular requirement is current overridden. Can also\nbe used as ``in``::\n\n    override = Override()\n    override.add(is_admin)\n    override.is_overridden(is_admin)  # True\n    is_admin in override  # True", "id": "f12914:c0:m3"}
{"signature": "@property<EOL><INDENT>def current(self):<DEDENT>", "body": "try:<EOL><INDENT>return _override_ctx_stack.top[<NUM_LIT:1>]<EOL><DEDENT>except TypeError:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Returns the current override context if set otherwise None", "id": "f12914:c1:m2"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def extract_concepts(self, sentences=None, ids=None,<EOL>filename=None, composite_phrase=<NUM_LIT:4>, <EOL>file_format='<STR_LIT>', word_sense_disambiguation=True):<DEDENT>", "body": "", "docstring": "Extract concepts from a list of sentences using MetaMap.", "id": "f12919:c0:m1"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def extract_concepts(self, sentences=None, ids=None, filename=None):<DEDENT>", "body": "return<EOL>", "docstring": "Extract concepts from a list of sentences using MetaMapLite.", "id": "f12920:c0:m1"}
{"signature": "def __init__(self, metamap_filename):", "body": "MetaMapLite.__init__(self, metamap_filename=metamap_filename)<EOL>", "docstring": "Interface to MetaMap using subprocess. This creates a\n            command line call to a specified metamap process.", "id": "f12925:c0:m0"}
{"signature": "def extract_concepts(self, sentences=None, ids=None, filename=None,<EOL>restrict_to_sts=None, restrict_to_sources=None):", "body": "if (sentences is not None and filename is not None) or(sentences is None and filename is None):<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>input_file = None<EOL>if sentences is not None:<EOL><INDENT>input_file = tempfile.NamedTemporaryFile(mode=\"<STR_LIT:wb>\", delete=False)<EOL><DEDENT>else:<EOL><INDENT>input_file = open(filename, '<STR_LIT:r>')<EOL><DEDENT>output_file_name = None<EOL>error = None<EOL>try:<EOL><INDENT>if sentences is not None:<EOL><INDENT>if ids is not None:<EOL><INDENT>for identifier, sentence in zip(ids, sentences):<EOL><INDENT>input_file.write('<STR_LIT>'.format(identifier, sentence).encode('<STR_LIT:utf8>'))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for sentence in sentences:<EOL><INDENT>input_file.write('<STR_LIT>'.format(sentence).encode('<STR_LIT:utf8>'))<EOL><DEDENT><DEDENT>input_file.flush()<EOL><DEDENT>command = [\"<STR_LIT>\", os.path.join(self.metamap_filename, \"<STR_LIT>\")]<EOL>if restrict_to_sts:<EOL><INDENT>if isinstance(restrict_to_sts, str):<EOL><INDENT>restrict_to_sts = [restrict_to_sts]<EOL><DEDENT>if len(restrict_to_sts) > <NUM_LIT:0>:<EOL><INDENT>command.append('<STR_LIT>')<EOL>command.append(str('<STR_LIT:U+002C>'.join(restrict_to_sts)))<EOL><DEDENT><DEDENT>if restrict_to_sources:<EOL><INDENT>if isinstance(restrict_to_sources, str):<EOL><INDENT>restrict_to_sources = [restrict_to_sources]<EOL><DEDENT>if len(restrict_to_sources) > <NUM_LIT:0>:<EOL><INDENT>command.append('<STR_LIT>')<EOL>command.append(str('<STR_LIT:U+002C>'.join(restrict_to_sources)))<EOL><DEDENT><DEDENT>if ids is not None:<EOL><INDENT>command.append('<STR_LIT>')<EOL><DEDENT>command.append(input_file.name)<EOL>metamap_process = subprocess.Popen(command, stdout=subprocess.PIPE)<EOL>while metamap_process.poll() is None:<EOL><INDENT>stdout = str(metamap_process.stdout.readline())<EOL>if '<STR_LIT>' in stdout:<EOL><INDENT>metamap_process.terminate()<EOL>error = stdout.rstrip()<EOL><DEDENT><DEDENT>output_file_name, file_extension = os.path.splitext(input_file.name)<EOL>output_file_name += \"<STR_LIT:.>\" + \"<STR_LIT>\"<EOL>with open(output_file_name) as fd:<EOL><INDENT>output = fd.read()<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>if sentences is not None:<EOL><INDENT>os.remove(input_file.name)<EOL><DEDENT>else:<EOL><INDENT>input_file.close()<EOL><DEDENT>os.remove(output_file_name)<EOL><DEDENT>concepts = CorpusLite.load(output.splitlines())<EOL>return concepts, error<EOL>", "docstring": "extract_concepts takes a list of sentences and ids(optional)\n            then returns a list of Concept objects extracted via\n            MetaMapLite.\n\n            Supported Options:\n                Restrict to Semantic Types --restrict_to_sts\n                Restrict to Sources --restrict_to_sources\n\n            For information about the available options visit\n            http://metamap.nlm.nih.gov/.\n\n            Note: If an error is encountered the process will be closed\n                  and whatever was processed, if anything, will be\n                  returned along with the error found.", "id": "f12925:c0:m1"}
{"signature": "def set_bass(self, zone: int, bass: int):", "body": "raise NotImplemented()<EOL>", "docstring": "Set bass for zone\n:param zone: zone 11..16, 21..26, 31..36\n:param bass: integer from 0 to 14 inclusive, where 0 is -7 bass and 14 is +7", "id": "f12937:c1:m5"}
{"signature": "def set_volume(self, zone: int, volume: int):", "body": "raise NotImplemented()<EOL>", "docstring": "Set volume for zone\n:param zone: zone 11..16, 21..26, 31..36\n:param volume: integer from 0 to 38 inclusive", "id": "f12937:c1:m3"}
{"signature": "def restore_zone(self, status: ZoneStatus):", "body": "raise NotImplemented()<EOL>", "docstring": "Restores zone to it's previous state\n:param status: zone state to restore", "id": "f12937:c1:m8"}
{"signature": "@asyncio.coroutine<EOL>def get_async_monoprice(port_url, loop):", "body": "lock = asyncio.Lock()<EOL>def locked_coro(coro):<EOL><INDENT>@asyncio.coroutine<EOL>@wraps(coro)<EOL>def wrapper(*args, **kwargs):<EOL><INDENT>with (yield from lock):<EOL><INDENT>return (yield from coro(*args, **kwargs))<EOL><DEDENT><DEDENT>return wrapper<EOL><DEDENT>class MonopriceAsync(Monoprice):<EOL><INDENT>def __init__(self, monoprice_protocol):<EOL><INDENT>self._protocol = monoprice_protocol<EOL><DEDENT>@locked_coro<EOL>@asyncio.coroutine<EOL>def zone_status(self, zone: int):<EOL><INDENT>string = yield from self._protocol.send(_format_zone_status_request(zone), skip=<NUM_LIT:6>)<EOL>return ZoneStatus.from_string(string)<EOL><DEDENT>@locked_coro<EOL>@asyncio.coroutine<EOL>def set_power(self, zone: int, power: bool):<EOL><INDENT>yield from self._protocol.send(_format_set_power(zone, power))<EOL><DEDENT>@locked_coro<EOL>@asyncio.coroutine<EOL>def set_mute(self, zone: int, mute: bool):<EOL><INDENT>yield from self._protocol.send(_format_set_mute(zone, mute))<EOL><DEDENT>@locked_coro<EOL>@asyncio.coroutine<EOL>def set_volume(self, zone: int, volume: int):<EOL><INDENT>yield from self._protocol.send(_format_set_volume(zone, volume))<EOL><DEDENT>@locked_coro<EOL>@asyncio.coroutine<EOL>def set_treble(self, zone: int, treble: int):<EOL><INDENT>yield from self._protocol.send(_format_set_treble(zone, treble))<EOL><DEDENT>@locked_coro<EOL>@asyncio.coroutine<EOL>def set_bass(self, zone: int, bass: int):<EOL><INDENT>yield from self._protocol.send(_format_set_bass(zone, bass))<EOL><DEDENT>@locked_coro<EOL>@asyncio.coroutine<EOL>def set_balance(self, zone: int, balance: int):<EOL><INDENT>yield from self._protocol.send(_format_set_balance(zone, balance))<EOL><DEDENT>@locked_coro<EOL>@asyncio.coroutine<EOL>def set_source(self, zone: int, source: int):<EOL><INDENT>yield from self._protocol.send(_format_set_source(zone, source))<EOL><DEDENT>@locked_coro<EOL>@asyncio.coroutine<EOL>def restore_zone(self, status: ZoneStatus):<EOL><INDENT>yield from self._protocol.send(_format_set_power(status.zone, status.power))<EOL>yield from self._protocol.send(_format_set_mute(status.zone, status.mute))<EOL>yield from self._protocol.send(_format_set_volume(status.zone, status.volume))<EOL>yield from self._protocol.send(_format_set_treble(status.zone, status.treble))<EOL>yield from self._protocol.send(_format_set_bass(status.zone, status.bass))<EOL>yield from self._protocol.send(_format_set_balance(status.zone, status.balance))<EOL>yield from self._protocol.send(_format_set_source(status.zone, status.source))<EOL><DEDENT><DEDENT>class MonopriceProtocol(asyncio.Protocol):<EOL><INDENT>def __init__(self, loop):<EOL><INDENT>super().__init__()<EOL>self._loop = loop<EOL>self._lock = asyncio.Lock()<EOL>self._transport = None<EOL>self._connected = asyncio.Event(loop=loop)<EOL>self.q = asyncio.Queue(loop=loop)<EOL><DEDENT>def connection_made(self, transport):<EOL><INDENT>self._transport = transport<EOL>self._connected.set()<EOL>_LOGGER.debug('<STR_LIT>', self._transport)<EOL><DEDENT>def data_received(self, data):<EOL><INDENT>asyncio.ensure_future(self.q.put(data), loop=self._loop)<EOL><DEDENT>@asyncio.coroutine<EOL>def send(self, request: bytes, skip=<NUM_LIT:0>):<EOL><INDENT>yield from self._connected.wait()<EOL>result = bytearray()<EOL>with (yield from self._lock):<EOL><INDENT>self._transport.serial.reset_output_buffer()<EOL>self._transport.serial.reset_input_buffer()<EOL>while not self.q.empty():<EOL><INDENT>self.q.get_nowait()<EOL><DEDENT>self._transport.write(request)<EOL>try:<EOL><INDENT>while True:<EOL><INDENT>result += yield from asyncio.wait_for(self.q.get(), TIMEOUT, loop=self._loop)<EOL>if len(result) > skip and result[-LEN_EOL:] == EOL:<EOL><INDENT>ret = bytes(result)<EOL>_LOGGER.debug('<STR_LIT>', ret)<EOL>return ret.decode('<STR_LIT:ascii>')<EOL><DEDENT><DEDENT><DEDENT>except asyncio.TimeoutError:<EOL><INDENT>_LOGGER.error(\"<STR_LIT>\", request, result)<EOL>raise<EOL><DEDENT><DEDENT><DEDENT><DEDENT>_, protocol = yield from create_serial_connection(loop, functools.partial(MonopriceProtocol, loop),<EOL>port_url, baudrate=<NUM_LIT>)<EOL>return MonopriceAsync(protocol)<EOL>", "docstring": "Return asynchronous version of Monoprice interface\n:param port_url: serial port, i.e. '/dev/ttyUSB0'\n:return: asynchronous implementation of Monoprice interface", "id": "f12937:m9"}
{"signature": "def gcd(self, lon1, lat1, lon2, lat2):", "body": "<EOL>lon1, lat1, lon2, lat2 = map(math.radians, [lon1, lat1, lon2, lat2])<EOL>dlon = lon2 - lon1<EOL>dlat = lat2 - lat1<EOL>a = math.sin(dlat / <NUM_LIT:2>) ** <NUM_LIT:2> + math.cos(lat1) * math.cos(lat2) * math.sin(dlon / <NUM_LIT:2>) ** <NUM_LIT:2><EOL>c = <NUM_LIT:2> * math.asin(math.sqrt(a))<EOL>dis = E.R * c<EOL>return dis<EOL>", "docstring": "Calculate the great circle distance between two points\non the earth (specified in decimal degrees)", "id": "f12943:c6:m3"}
{"signature": "def url(regex, view, kwargs=None, name=None, prefix='<STR_LIT>'):", "body": "if isinstance(view, (list, tuple)):<EOL><INDENT>urlconf_module, app_name, namespace = view<EOL>return URLResolver(regex, urlconf_module, kwargs, app_name=app_name, namespace=namespace)<EOL><DEDENT>else:<EOL><INDENT>if isinstance(view, six.string_types):<EOL><INDENT>if not view:<EOL><INDENT>raise ImproperlyConfigured('<STR_LIT>' % regex)<EOL><DEDENT>if prefix:<EOL><INDENT>view = prefix + '<STR_LIT:.>' + view<EOL><DEDENT>view = get_callable(view)<EOL><DEDENT>return CBVRegexURLPattern(regex, view, kwargs, name)<EOL><DEDENT>", "docstring": "As url() in Django.", "id": "f12952:m1"}
{"signature": "def turn_off(self):", "body": "self._device.pow_off()<EOL>", "docstring": "Turn the device off.", "id": "f12965:c0:m9"}
{"signature": "def volume_up(self):", "body": "self._volume_level += self._volume_step / self._max_volume<EOL>self._device.vol_up(num=self._volume_step)<EOL>", "docstring": "Increasing volume of the device.", "id": "f12965:c0:m16"}
{"signature": "@property<EOL><INDENT>def state(self):<DEDENT>", "body": "return self._state<EOL>", "docstring": "Return the state of the device.", "id": "f12965:c0:m2"}
{"signature": "def mute_volume(self, mute):", "body": "if mute:<EOL><INDENT>self._device.mute_on()<EOL><DEDENT>else:<EOL><INDENT>self._device.mute_off()<EOL><DEDENT>", "docstring": "Mute the volume.", "id": "f12965:c0:m10"}
{"signature": "def select_source(self, source):", "body": "self._device.input_switch(source)<EOL>", "docstring": "Select input source.", "id": "f12965:c0:m15"}
{"signature": "def vg(self, wavelength):", "body": "return spc.c / self.ng(wavelength)<EOL>", "docstring": "The group velocities with respect to wavelength.\n\nArgs:\n    wavelength (float, list, None): The wavelength(s) the group\n        velocities will be evaluated at.\n\nReturns:\n    float, list: The group velocities at the target wavelength(s).", "id": "f12968:c0:m11"}
{"signature": "@abc.abstractproperty<EOL><INDENT>def _eps(self, wavelength=None):<DEDENT>", "body": "return NotImplementedError<EOL>", "docstring": "The permittivty of the desired material.\n\nEach new material needs this method implemented.\n\nArgs:\n    wavelength (float, list, None): The wavelength the permittivty\n        will be evaluated at.\n\nReturns:\n    float, list: The permittivty at the target wavelength.", "id": "f12968:c0:m3"}
{"signature": "def beta2(self, wavelength):", "body": "return self.gvd(wavelength)<EOL>", "docstring": "The second derivative of the propagation constant with respect to wavelength.\n\nArgs:\n    wavelength (float, list, None): The wavelength(s) the\n        propagation constant will be evaluated at.\n\nReturns:\n    float, list: The propagation constant at the target wavelength(s).", "id": "f12968:c0:m15"}
{"signature": "def nDer2(self, wavelength):", "body": "return self._nDer2(wavelength)<EOL>", "docstring": "The second derivative of the refractive index with respect to\nwavelength.\n\nArgs:\n    wavelength (float, list, None): The wavelength(s) the derivative\n        will be evaluated at.\n\nReturns:\n    float, list: The refractive index at the target wavelength(s).", "id": "f12968:c0:m9"}
{"signature": "def n(self, wavelength=None):", "body": "return self.eps(wavelength)**<NUM_LIT:0.5><EOL>", "docstring": "The refractive index of the desired material.\n\nArgs:\n    wavelength (float, list, None): The wavelength the refractive index\n        will be evaluated at.\n\nReturns:\n    float, list: The refractive index at the target wavelength.", "id": "f12968:c0:m7"}
{"signature": "@register.simple_tag<EOL>def gravatar_get_img(obj, size=<NUM_LIT>, default='<STR_LIT>'):", "body": "url = get_gravatar_url(obj, size=size, default=default)<EOL>if url:<EOL><INDENT>return safe('<STR_LIT>' % url)<EOL><DEDENT>return '<STR_LIT>'<EOL>", "docstring": "Returns Gravatar image HTML tag for a given string or UserModel.\n\n    Example:\n\n        {% load gravatar %}\n        {% gravatar_get_img user_model %}\n\n    :param UserModel, str obj:\n    :param int size:\n    :param str default:\n    :return:", "id": "f12979:m2"}
{"signature": "@register.tag('<STR_LIT>')<EOL>def include_(parser, token):", "body": "bits = token.split_contents()<EOL>dynamic = False<EOL>if len(bits) >= <NUM_LIT:2>:<EOL><INDENT>dynamic = '<STR_LIT>' in bits[<NUM_LIT:1>]<EOL>if dynamic:<EOL><INDENT>fallback = None<EOL>bits_new = []<EOL>for bit in bits:<EOL><INDENT>if fallback is True:<EOL><INDENT>fallback = bit<EOL>continue<EOL><DEDENT>if bit == '<STR_LIT>':<EOL><INDENT>fallback = True<EOL><DEDENT>else:<EOL><INDENT>bits_new.append(bit)<EOL><DEDENT><DEDENT>if fallback:<EOL><INDENT>fallback = parser.compile_filter(construct_relative_path_(parser, fallback))<EOL><DEDENT>token.contents = '<STR_LIT:U+0020>'.join(bits_new)<EOL><DEDENT><DEDENT>token.contents = token.contents.replace('<STR_LIT>', '<STR_LIT>')<EOL>include_node = do_include(parser, token)<EOL>if dynamic:<EOL><INDENT>include_node = DynamicIncludeNode(<EOL>include_node.template,<EOL>extra_context=include_node.extra_context,<EOL>isolated_context=include_node.isolated_context,<EOL>fallback=fallback or None,<EOL>)<EOL><DEDENT>return include_node<EOL>", "docstring": "Similar to built-in ``include`` template tag, but allowing\n    template variables to be used in template name and a fallback template,\n    thus making the tag more dynamic.\n\n    .. warning:: Requires Django 1.8+\n\n    Example:\n\n        {% load etc_misc %}\n        {% include_ \"sub_{{ postfix_var }}.html\" fallback \"default.html\" %}", "id": "f12981:m1"}
{"signature": "@register.tag<EOL>def model_field_verbose_name(parser, token):", "body": "return _get_model_field_attr('<STR_LIT>', '<STR_LIT>', token)<EOL>", "docstring": "Returns model field verbose name.\n    Two notations are acceptable:\n\n        1. Two arguments:\n           {% model_field_verbose_name from mymodel.myfield %}\n\n           Is used to render verbose name of `myfield`.\n\n        2. Four arguments:\n           {% model_field_verbose_name from mymodel.myfield as myvar %}\n\n           Is used to put `myfield` verbose name into `myvar` template variable.", "id": "f12982:m0"}
{"signature": "def set_form_widgets_attrs(form, attrs):", "body": "for _, field in form.fields.items():<EOL><INDENT>attrs_ = dict(attrs)<EOL>for name, val in attrs.items():<EOL><INDENT>if hasattr(val, '<STR_LIT>'):<EOL><INDENT>attrs_[name] = val(field)<EOL><DEDENT><DEDENT>field.widget.attrs = field.widget.build_attrs(attrs_)<EOL><DEDENT>", "docstring": "Applies a given HTML attributes to each field widget of a given form.\n\n    Example:\n\n        set_form_widgets_attrs(my_form, {'class': 'clickable'})", "id": "f12987:m2"}
{"signature": "def get_model_class_from_string(model_path):", "body": "try:<EOL><INDENT>app_name, model_name = model_path.split('<STR_LIT:.>')<EOL><DEDENT>except ValueError:<EOL><INDENT>raise ImproperlyConfigured('<STR_LIT>' % model_path)<EOL><DEDENT>if apps_get_model is None:<EOL><INDENT>model = get_model(app_name, model_name)<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>model = apps_get_model(app_name, model_name)<EOL><DEDENT>except (LookupError, ValueError):<EOL><INDENT>model = None<EOL><DEDENT><DEDENT>if model is None:<EOL><INDENT>raise ImproperlyConfigured('<STR_LIT>' % (model_path, model_name))<EOL><DEDENT>return model<EOL>", "docstring": "Returns a certain model as defined in a string formatted `<app_name>.<model_name>`.\n\n    Example:\n\n        model = get_model_class_from_string('myapp.MyModel')", "id": "f12987:m3"}
{"signature": "def get_site_url(request=None):", "body": "env = partial(environ.get)<EOL>settings_ = partial(getattr, settings)<EOL>domain = None<EOL>scheme = None<EOL>url = None<EOL>for src in (env, settings_):<EOL><INDENT>if url is None:<EOL><INDENT>url = src('<STR_LIT>', None)<EOL><DEDENT>if domain is None:<EOL><INDENT>domain = src('<STR_LIT>', None)<EOL><DEDENT>if scheme is None:<EOL><INDENT>scheme = src('<STR_LIT>', src('<STR_LIT>', None))<EOL><DEDENT><DEDENT>if domain is None and url is not None:<EOL><INDENT>scheme, domain = url.split('<STR_LIT>')[:<NUM_LIT:2>]<EOL><DEDENT>if domain is None:<EOL><INDENT>site = get_current_site(request or DomainGetter(domain))<EOL>domain = site.domain<EOL><DEDENT>if scheme is None and request:<EOL><INDENT>scheme = request.scheme<EOL><DEDENT>if domain is None:<EOL><INDENT>domain = '<STR_LIT>'<EOL><DEDENT>if scheme is None:<EOL><INDENT>scheme = '<STR_LIT:http>'<EOL><DEDENT>domain = domain.rstrip('<STR_LIT:/>')<EOL>return '<STR_LIT>' % (scheme, domain)<EOL>", "docstring": "Tries to get a site URL from environment and settings\n    in the following order:\n\n    1. (SITE_PROTO / SITE_SCHEME) + SITE_DOMAIN\n    2. SITE_URL\n    3. Django Sites contrib\n    4. Request object\n\n    :param HttpRequest request: Request object to deduce URL from.\n    :rtype: str", "id": "f12987:m5"}
{"signature": "def p_postpositions(p):", "body": "if len(p) > <NUM_LIT:2>:<EOL><INDENT>if p[<NUM_LIT:1>] == \"<STR_LIT>\":<EOL><INDENT>postposition = {<EOL>\"<STR_LIT>\": p[<NUM_LIT:2>]<EOL>}<EOL>rest = p[<NUM_LIT:3>] if p[<NUM_LIT:3>] else {}<EOL><DEDENT>elif p[<NUM_LIT:1>:<NUM_LIT:3>] == [\"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>postposition = {<EOL>\"<STR_LIT>\": p[<NUM_LIT:3>]<EOL>}<EOL>rest = p[<NUM_LIT:4>] if p[<NUM_LIT:4>] else {}<EOL><DEDENT>else:<EOL><INDENT>breakpoint()<EOL><DEDENT>p[<NUM_LIT:0>] = {**postposition, **rest}<EOL><DEDENT>else:<EOL><INDENT>p[<NUM_LIT:0>] = {}<EOL><DEDENT>", "docstring": "postpositions : LIMIT NUMBER postpositions\n              | ORDER BY colspec postpositions\n              | empty", "id": "f12990:m7"}
{"signature": "def p_colspec(p):", "body": "rest = p[<NUM_LIT:3>] if len(p) > <NUM_LIT:3> else []<EOL>if p[<NUM_LIT:1>] == \"<STR_LIT:*>\":<EOL><INDENT>p[<NUM_LIT:0>] = [{\"<STR_LIT:type>\": \"<STR_LIT>\"}]<EOL><DEDENT>elif isinstance(p[<NUM_LIT:1>], dict) and p[<NUM_LIT:1>].get(\"<STR_LIT:type>\") == \"<STR_LIT>\":<EOL><INDENT>p[<NUM_LIT:0>] = [p[<NUM_LIT:1>], *rest]<EOL><DEDENT>elif p[<NUM_LIT:1>]:<EOL><INDENT>p[<NUM_LIT:0>] = [<EOL>{<EOL>\"<STR_LIT:type>\": \"<STR_LIT:name>\",<EOL>\"<STR_LIT:value>\": p[<NUM_LIT:1>],<EOL>},<EOL>*rest,<EOL>]<EOL><DEDENT>else:<EOL><INDENT>p[<NUM_LIT:0>] = []<EOL><DEDENT>", "docstring": "colspec : STAR\n        | NAME\n        | function\n        | NAME COMMA colspec\n        | function COMMA colspec", "id": "f12990:m9"}
{"signature": "def p_value(p):", "body": "p[<NUM_LIT:0>] = {<EOL>\"<STR_LIT:type>\": \"<STR_LIT:name>\" if p.slice[<NUM_LIT:1>].type == \"<STR_LIT>\" else \"<STR_LIT>\",<EOL>\"<STR_LIT:value>\": p[<NUM_LIT:1>],<EOL>}<EOL>", "docstring": "value : NUMBER\n      | STRING\n      | NAME", "id": "f12990:m13"}
{"signature": "def _add_team(session_browser, field, team_name):", "body": "session_browser.find_by_id('<STR_LIT>' % field).click()<EOL>session_browser.windows.current = session_browser.windows[<NUM_LIT:1>]<EOL>session_browser.fill_form({'<STR_LIT:name>': team_name})<EOL>session_browser.find_by_css('<STR_LIT>').click()<EOL>session_browser.windows.current = session_browser.windows[<NUM_LIT:0>]<EOL>", "docstring": "Click the add-another button to add a new related Team object.", "id": "f13002:m3"}
{"signature": "def _get_value(session_browser, field):", "body": "return session_browser.evaluate_script('<STR_LIT>' % field)<EOL>", "docstring": "Get an input field's value.", "id": "f13002:m4"}
{"signature": "def invoke(published_func, *args, **kwargs):", "body": "for i in xrange(<NUM_LIT:100>):<EOL><INDENT>time.sleep(<NUM_LIT:5>)<EOL>try:<EOL><INDENT>return published_func(*args, **kwargs)<EOL>break<EOL><DEDENT>except Exception as e:<EOL><INDENT>traceback.print_exc()<EOL>print(e)<EOL><DEDENT><DEDENT>", "docstring": "helper to repeatedly invoke the function until it becomes available...", "id": "f13009:m0"}
{"signature": "def _dataframe_from_txt(reader):", "body": "return pd.read_csv(reader, header=None, sep=\"<STR_LIT:\\n>\", encoding='<STR_LIT>')<EOL>", "docstring": "Returns PlainText data as a pandas Dataframe object", "id": "f13016:m3"}
{"signature": "@property<EOL><INDENT>def description(self):<DEDENT>", "body": "return self._metadata['<STR_LIT>']<EOL>", "docstring": "Description for the dataset.", "id": "f13017:c2:m16"}
{"signature": "@property<EOL><INDENT>def promoted_from(self):<DEDENT>", "body": "return self._metadata['<STR_LIT>']<EOL>", "docstring": "TODO.", "id": "f13017:c2:m25"}
{"signature": "@property<EOL><INDENT>def size(self):<DEDENT>", "body": "return self._metadata['<STR_LIT>']<EOL>", "docstring": "Size in bytes of the serialized dataset contents.", "id": "f13017:c2:m19"}
{"signature": "@property<EOL><INDENT>def is_deprecated(self):<DEDENT>", "body": "return self._metadata['<STR_LIT>']<EOL>", "docstring": "TODO.", "id": "f13017:c2:m31"}
{"signature": "def read_as_binary(self):", "body": "return self.workspace._rest.read_dataset_contents_binary(self.contents_url)<EOL>", "docstring": "Read and return the dataset contents as binary.", "id": "f13017:c2:m4"}
{"signature": "@property<EOL><INDENT>def resource_upload_id(self):<DEDENT>", "body": "return self._metadata['<STR_LIT>']<EOL>", "docstring": "TODO.", "id": "f13017:c2:m17"}
{"signature": "@property<EOL><INDENT>def description(self):<DEDENT>", "body": "return self._metadata['<STR_LIT>']<EOL>", "docstring": "TODO.", "id": "f13017:c5:m4"}
{"signature": "@property<EOL><INDENT>def visualize_end_point(self):<DEDENT>", "body": "return SourceDataset.Location(self._metadata['<STR_LIT>'])<EOL>", "docstring": "TODO.", "id": "f13017:c2:m10"}
{"signature": "def open(self):", "body": "return self.workspace._rest.open_intermediate_dataset_contents(<EOL>self.workspace.workspace_id,<EOL>self.experiment.experiment_id,<EOL>self.node_id,<EOL>self.port_name<EOL>)<EOL>", "docstring": "Open and return a stream for the dataset contents.", "id": "f13017:c4:m1"}
{"signature": "@property<EOL><INDENT>def batch(self):<DEDENT>", "body": "return self._metadata['<STR_LIT>']<EOL>", "docstring": "TODO.", "id": "f13017:c2:m33"}
{"signature": "@property<EOL><INDENT>def name(self):<DEDENT>", "body": "return self._metadata['<STR_LIT:Name>']<EOL>", "docstring": "Unique name for the dataset.", "id": "f13017:c2:m14"}
{"signature": "def read_as_text(self):", "body": "return self.workspace._rest.read_intermediate_dataset_contents_text(<EOL>self.workspace.workspace_id,<EOL>self.experiment.experiment_id,<EOL>self.node_id,<EOL>self.port_name<EOL>)<EOL>", "docstring": "Read and return the dataset contents as text.", "id": "f13017:c4:m3"}
{"signature": "@property<EOL><INDENT>def creator(self):<DEDENT>", "body": "return self._metadata['<STR_LIT>']<EOL>", "docstring": "TODO.", "id": "f13017:c5:m5"}
{"signature": "@property<EOL><INDENT>def service_version(self):<DEDENT>", "body": "return self._metadata['<STR_LIT>']<EOL>", "docstring": "TODO.", "id": "f13017:c2:m27"}
{"signature": "@property<EOL><INDENT>def family_id(self):<DEDENT>", "body": "return self._metadata['<STR_LIT>']<EOL>", "docstring": "TODO.", "id": "f13017:c2:m18"}
{"signature": "@staticmethod<EOL><INDENT>def find_globals(code):<DEDENT>", "body": "cur_byte = <NUM_LIT:0><EOL>byte_code = code.co_code<EOL>names = set()<EOL>while cur_byte < len(byte_code):<EOL><INDENT>op = ord(byte_code[cur_byte])<EOL>if op >= dis.HAVE_ARGUMENT:<EOL><INDENT>if op == _LOAD_GLOBAL:<EOL><INDENT>oparg = ord(byte_code[cur_byte + <NUM_LIT:1>]) + (ord(byte_code[cur_byte + <NUM_LIT:2>]) << <NUM_LIT:8>)<EOL>name = code.co_names[oparg]<EOL>names.add(name)<EOL><DEDENT>cur_byte += <NUM_LIT:2><EOL><DEDENT>cur_byte += <NUM_LIT:1><EOL><DEDENT>return names<EOL>", "docstring": "walks the byte code to find the variables which are actually globals", "id": "f13019:c0:m3"}
{"signature": "def attach(name, contents = None):", "body": "def do_attach(func):<EOL><INDENT>if hasattr(func, '<STR_LIT>'):<EOL><INDENT>func.__attachments__.append((name, contents))<EOL><DEDENT>else:<EOL><INDENT>func.__attachments__ = [(name, contents)]<EOL><DEDENT>return func<EOL><DEDENT>return do_attach<EOL>", "docstring": "attaches a file to the payload to be uploaded.\n\nIf contents is omitted the file is read from disk.\nIf name is a tuple it specifies the on-disk filename and the destination filename.", "id": "f13019:m43"}
{"signature": "def service_id(id):", "body": "def l(func):<EOL><INDENT>func.__service_id__ = id<EOL>return func<EOL><DEDENT>return l<EOL>", "docstring": "Specifies the service ID to enable re-publishing to the same end point.\nCan be applied to the function which is being published:\n\n@publish(...)\n@service_id('e5dd3903-796f-4544-b7aa-f4e08b2cc639')\ndef myfunc():\n    return 42\n\nWhen the function is published it will replace any existing instances of the \nfunction.", "id": "f13019:m44"}
{"signature": "def types(**args):", "body": "def l(func):<EOL><INDENT>if hasattr(func, '<STR_LIT>'):<EOL><INDENT>func.__annotations__.update(args)<EOL><DEDENT>else:<EOL><INDENT>func.__annotations__ = args<EOL><DEDENT>return func<EOL><DEDENT>return l<EOL>", "docstring": "Specifies the types used for the arguments of a published service.\n\n@types(a=int, b = str)\ndef f(a, b):\n    pass", "id": "f13019:m41"}
{"signature": "def map(self, *args):", "body": "call_args = [self._map_args(*cur_args)  for cur_args in zip(*args)]<EOL>r = self._invoke(call_args)<EOL>ret_type = _get_annotation('<STR_LIT>', self.func)<EOL>output_name = getattr(self.func, '<STR_LIT>', '<STR_LIT>')<EOL>return [_decode_response(<EOL>r['<STR_LIT>'][output_name]['<STR_LIT:value>'].get(\"<STR_LIT>\"), <EOL>r['<STR_LIT>'][output_name]['<STR_LIT:value>'].get(\"<STR_LIT>\"), <EOL>x, <EOL>ret_type) <EOL>for x in r['<STR_LIT>']['<STR_LIT>']['<STR_LIT:value>']['<STR_LIT>']]<EOL>", "docstring": "maps the function onto multiple inputs.  The input should be multiple sequences.  The\nsequences will be zipped together forming the positional arguments for the call.  This is\nequivalent to map(func, ...) but is executed with a single network call.", "id": "f13019:c1:m5"}
{"signature": "def service(url, api_key, help_url = None):", "body": "def do_publish(func):<EOL><INDENT>return published(url, api_key, help_url, func, None)<EOL><DEDENT>return do_publish<EOL>", "docstring": "Marks a function as having been published and causes all invocations to go to the remote\noperationalized service.\n\n>>> @service(url, api_key)\n>>> def f(a, b):\n>>>     pass", "id": "f13019:m40"}
{"signature": "def createSOAPMessage(env):", "body": "if env.getAction() == ACTION_PROBE:<EOL><INDENT>return createProbeMessage(env)<EOL><DEDENT>if env.getAction() == ACTION_PROBE_MATCH:<EOL><INDENT>return createProbeMatchMessage(env)<EOL><DEDENT>if env.getAction() == ACTION_RESOLVE:<EOL><INDENT>return createResolveMessage(env)<EOL><DEDENT>if env.getAction() == ACTION_RESOLVE_MATCH:<EOL><INDENT>return createResolveMatchMessage(env)<EOL><DEDENT>if env.getAction() == ACTION_HELLO:<EOL><INDENT>return createHelloMessage(env)<EOL><DEDENT>if env.getAction() == ACTION_BYE:<EOL><INDENT>return createByeMessage(env)<EOL><DEDENT>", "docstring": "construct a a raw SOAP XML string, given a prepared SoapEnvelope object", "id": "f13037:m0"}
{"signature": "def start(self):", "body": "self._startThreads()<EOL>self._serverStarted = True<EOL>", "docstring": "start the discovery server - should be called before using other functions", "id": "f13038:c3:m14"}
{"signature": "def _sendPendingMessages(self):", "body": "if len(self._queue) == <NUM_LIT:0>:<EOL><INDENT>time.sleep(<NUM_LIT:0.1>)<EOL>return<EOL><DEDENT>msg = self._queue.pop(<NUM_LIT:0>)<EOL>if msg.canSend():<EOL><INDENT>self._sendMsg(msg)<EOL>msg.refresh()<EOL>if not (msg.isFinished()):<EOL><INDENT>self._queue.append(msg)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self._queue.append(msg)<EOL>time.sleep(<NUM_LIT>)<EOL><DEDENT>", "docstring": "Method sleeps, if nothing to do", "id": "f13038:c2:m11"}
{"signature": "def schedule_stop(self):", "body": "self._quitEvent.set()<EOL>", "docstring": "Schedule stopping the thread.\n        Use join() to wait, until thread really has been stopped", "id": "f13038:c0:m1"}
{"signature": "def setRemoteServiceByeCallback(self, cb):", "body": "self._remoteServiceByeCallback = cb<EOL>", "docstring": "Set callback, which will be called when new service appeared online\n        and sent Hi message\n        Service is passed as a parameter to the callback\n        Set None to disable callback", "id": "f13038:c3:m2"}
{"signature": "def stop(self):", "body": "self.clearRemoteServices()<EOL>self.clearLocalServices()<EOL>self._stopThreads()<EOL>self._serverStarted = False<EOL>", "docstring": "cleans up and stops the discovery server", "id": "f13038:c3:m15"}
{"signature": "def setRemoveServiceDisappearedCallback(self, cb):", "body": "self._remoteServiceDisppearedCallback = cb<EOL>", "docstring": "Set callback, which will be called when new service disappears\n        Service uuid is passed as a parameter to the callback\n        Set None to disable callback", "id": "f13038:c3:m3"}
{"signature": "def clearRemoteServices(self):", "body": "self._remoteServices.clear()<EOL>", "docstring": "clears remotely discovered services", "id": "f13038:c3:m24"}
{"signature": "def setRemoteServiceHelloCallback(self, cb, types=None, scopes=None):", "body": "self._remoteServiceHelloCallback = cb<EOL>self._remoteServiceHelloCallbackTypesFilter = types<EOL>self._remoteServiceHelloCallbackScopesFilter = scopes<EOL>", "docstring": "Set callback, which will be called when new service appeared online\n        and sent Hi message\n\n        typesFilter and scopesFilter might be list of types and scopes.\n        If filter is set, callback is called only for Hello messages,\n        which match filter\n\n        Set None to disable callback", "id": "f13038:c3:m1"}
{"signature": "def main(clargs=None):", "body": "from argparse import ArgumentParser<EOL>from librarian.library import Library<EOL>import sys<EOL>parser = ArgumentParser(<EOL>description=\"<STR_LIT>\")<EOL>parser.add_argument(\"<STR_LIT>\", help=\"<STR_LIT>\")<EOL>parser.add_argument(\"<STR_LIT>\", \"<STR_LIT>\", default=\"<STR_LIT>\",<EOL>help=\"<STR_LIT>\")<EOL>args = parser.parse_args(clargs)<EOL>descovery(args.tests)<EOL>library = Library(args.library)<EOL>cardcount, passes, failures = execute_tests(library)<EOL>print(RESULTS.format(len(SINGLES), len(TESTS), cardcount, passes,<EOL>failures))<EOL>sys.exit(failures)<EOL>", "docstring": "Command line entry point.", "id": "f13046:m4"}
{"signature": "def library(func):", "body": "@wraps(func)<EOL>def wrapped(*args, **kwargs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return func(*args, **kwargs)<EOL><DEDENT>SINGLES.append(wrapped)<EOL>return wrapped<EOL>", "docstring": "A decorator for providing a unittest with a library and have it called only\nonce.", "id": "f13046:m1"}
{"signature": "def add_parameter(self, parameter):", "body": "self._parameters.append(parameter)<EOL>return self<EOL>", "docstring": "Adds a data-filtering parameter to this token.\n\n        :param parameter(Parameter): The parameter to add.", "id": "f13054:c0:m3"}
{"signature": "def __init__(self, field, op, value):", "body": "self.field = field<EOL>self.op = op<EOL>self.value = value<EOL>", "docstring": "Creates a new data-filtering parameter.\n\n        :param field(string): The field name.\n        :param op(string): The operation to apply, one of the constants in this class.\n        :param value: The value(s) to test against.", "id": "f13055:c0:m0"}
{"signature": "def script_init(self, lease, state, prefix='<STR_LIT>', medium='<STR_LIT>'):", "body": "logger.debug('<STR_LIT>', self.scriptname)<EOL>if self.scriptname is not None:<EOL><INDENT>logger.debug('<STR_LIT>')<EOL>if isinstance(state, int):<EOL><INDENT>reason = STATES2REASONS[state]<EOL><DEDENT>else:<EOL><INDENT>reason = state<EOL><DEDENT>self.env['<STR_LIT>'] = str(reason)<EOL>self.env['<STR_LIT>'] = self.env.get('<STR_LIT>') or str(medium)<EOL>self.env['<STR_LIT>'] = str('<STR_LIT>')<EOL>self.env['<STR_LIT>'] = str(os.getpid())<EOL>for k in LEASEATTRS_SAMEAS_ENVKEYS:<EOL><INDENT>self.env[k] = str(lease.__getattribute__(k))<EOL><DEDENT>for k, v in LEASEATTRS2ENVKEYS.items():<EOL><INDENT>self.env[v] = str(lease.__getattribute__(k))<EOL><DEDENT>self.env.update(ENV_OPTIONS_REQ)<EOL><DEDENT>else:<EOL><INDENT>logger.debug('<STR_LIT>')<EOL><DEDENT>", "docstring": "Initialize environment to pass to the external script.", "id": "f13064:c0:m1"}
{"signature": "@ATMT.receive_condition(REBINDING)<EOL><INDENT>def receive_nak_rebinding(self, pkt):<DEDENT>", "body": "logger.debug(\"<STR_LIT>\")<EOL>if self.process_received_nak(pkt):<EOL><INDENT>logger.debug(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>raise self.INIT()<EOL><DEDENT>", "docstring": "Receive NAK in REBINDING state.", "id": "f13067:c0:m35"}
{"signature": "@ATMT.receive_condition(REQUESTING)<EOL><INDENT>def receive_ack_requesting(self, pkt):<DEDENT>", "body": "logger.debug(\"<STR_LIT>\")<EOL>if self.process_received_ack(pkt):<EOL><INDENT>logger.debug(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>raise self.BOUND()<EOL><DEDENT>", "docstring": "Receive ACK in REQUESTING state.", "id": "f13067:c0:m30"}
{"signature": "@ATMT.timeout(SELECTING, TIMEOUT_SELECTING)<EOL><INDENT>def timeout_selecting(self):<DEDENT>", "body": "logger.debug('<STR_LIT>',<EOL>self.current_state)<EOL>if len(self.offers) >= MAX_OFFERS_COLLECTED:<EOL><INDENT>logger.debug('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>raise self.REQUESTING()<EOL><DEDENT>if self.discover_attempts >= MAX_ATTEMPTS_DISCOVER:<EOL><INDENT>logger.debug('<STR_LIT>'<EOL>'<STR_LIT>',<EOL>MAX_ATTEMPTS_DISCOVER, self.discover_attempts)<EOL>if len(self.offers) <= <NUM_LIT:0>:<EOL><INDENT>logger.debug('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>raise self.ERROR()<EOL><DEDENT>logger.debug('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>raise self.REQUESTING()<EOL><DEDENT>logger.debug('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>raise self.SELECTING()<EOL>", "docstring": "Timeout of selecting on SELECTING state.\n\n        Not specifiyed in [:rfc:`7844`].\n        See comments in :func:`dhcpcapfsm.DHCPCAPFSM.timeout_request`.", "id": "f13067:c0:m22"}
{"signature": "@ATMT.timeout(REBINDING, TIMEOUT_REQUEST_REBINDING)<EOL><INDENT>def timeout_request_rebinding(self):<DEDENT>", "body": "logger.debug(\"<STR_LIT>\",<EOL>self.current_state)<EOL>if self.request_attempts >= MAX_ATTEMPTS_REQUEST:<EOL><INDENT>logger.debug('<STR_LIT>'<EOL>'<STR_LIT>',<EOL>MAX_ATTEMPTS_REQUEST, self.disover_requests)<EOL><DEDENT>logger.debug(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>raise self.REBINDING()<EOL>", "docstring": "Timeout of request rebinding on REBINDING state.\n\n        Same comments as in\n        :func:`dhcpcapfsm.DHCPCAPFSM.timeout_requesting`.", "id": "f13067:c0:m25"}
{"signature": "@ATMT.state()<EOL><INDENT>def REBINDING(self):<DEDENT>", "body": "logger.debug('<STR_LIT>')<EOL>self.current_state = STATE_REBINDING<EOL>if self.script is not None:<EOL><INDENT>self.script.script_init(self.client.lease, self.current_state)<EOL>self.script.script_go()<EOL><DEDENT>else:<EOL><INDENT>set_net(self.client.lease)<EOL><DEDENT>", "docstring": "REBINDING state.", "id": "f13067:c0:m18"}
{"signature": "def process_received_nak(self, pkt):", "body": "if isnak(pkt):<EOL><INDENT>logger.info('<STR_LIT>',<EOL>self.client.client_ip, self.client.server_ip)<EOL>return True<EOL><DEDENT>return False<EOL>", "docstring": "Process a received NAK packet.", "id": "f13067:c0:m12"}
{"signature": "@ATMT.action(timeout_requesting)<EOL><INDENT>@ATMT.action(timeout_request_rebinding)<EOL>@ATMT.action(rebinding_time_expires)<EOL>@ATMT.action(receive_offer)<EOL>@ATMT.action(timeout_request_renewing)<EOL>@ATMT.action(renewing_time_expires)<EOL>def action_transmit_request(self):<DEDENT>", "body": "logger.debug('<STR_LIT>'<EOL>'<STR_LIT>', self.current_state)<EOL>self.send_request()<EOL>", "docstring": "Action on X: send REQUEST.", "id": "f13067:c0:m37"}
{"signature": "@ATMT.action(receive_ack_rebinding)<EOL><INDENT>@ATMT.action(receive_ack_requesting)<EOL>def on_ack_requesting(self):<DEDENT>", "body": "<EOL>logger.debug('<STR_LIT>')<EOL>self.set_timers()<EOL>", "docstring": "Action on receive ACK requesting in REQUESTING state: set timers.", "id": "f13067:c0:m38"}
{"signature": "@ATMT.timeout(REBINDING, LEASE_TIME)<EOL><INDENT>def lease_expires(self):<DEDENT>", "body": "logger.debug(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>raise self.STATE_INIT()<EOL>", "docstring": "Timeout lease time, transition to INIT.\n\n        Not sending DHCPRELEASE to minimize deanonymization\n\n        [:rfc:`2131#section-4.4.6`]::\n\n            Note that the correct operation\n            of DHCP does not depend on the transmission of DHCPRELEASE.", "id": "f13067:c0:m28"}
{"signature": "@ATMT.receive_condition(REBINDING)<EOL><INDENT>def receive_ack_rebinding(self, pkt):<DEDENT>", "body": "logger.debug(\"<STR_LIT>\")<EOL>if self.process_received_ack(pkt):<EOL><INDENT>logger.debug(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>raise self.BOUND()<EOL><DEDENT>", "docstring": "Receive ACK in REBINDING state.", "id": "f13067:c0:m34"}
{"signature": "@ATMT.timeout(BOUND, RENEWING_TIME)<EOL><INDENT>def renewing_time_expires(self):<DEDENT>", "body": "logger.debug(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>raise self.RENEWING()<EOL>", "docstring": "Timeout renewing time (T1), transition to RENEWING.", "id": "f13067:c0:m26"}
{"signature": "def set_timers(self):", "body": "logger.debug('<STR_LIT>')<EOL>self.set_timeout(self.current_state,<EOL>self.renewing_time_expires,<EOL>self.client.lease.renewal_time)<EOL>self.set_timeout(self.current_state,<EOL>self.rebinding_time_expires,<EOL>self.client.lease.rebinding_time)<EOL>", "docstring": "Set renewal, rebinding times.", "id": "f13067:c0:m10"}
{"signature": "@ATMT.receive_condition(SELECTING)<EOL><INDENT>def receive_offer(self, pkt):<DEDENT>", "body": "logger.debug(\"<STR_LIT>\")<EOL>if isoffer(pkt):<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>self.offers.append(pkt)<EOL>if len(self.offers) >= MAX_OFFERS_COLLECTED:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>self.select_offer()<EOL>raise self.REQUESTING()<EOL><DEDENT>logger.debug(\"<STR_LIT>\")<EOL>raise self.SELECTING()<EOL><DEDENT>", "docstring": "Receive offer on SELECTING state.", "id": "f13067:c0:m29"}
{"signature": "def gen_delay_selecting():", "body": "delay = float(random.randint(<NUM_LIT:0>, MAX_DELAY_SELECTING))<EOL>logger.debug('<STR_LIT>', delay)<EOL>logger.debug('<STR_LIT>',<EOL>future_dt_str(nowutc(), delay))<EOL>return delay<EOL>", "docstring": "Generate the delay in seconds in which the DISCOVER will be sent.\n\n    [:rfc:`2131#section-4.4.1`]::\n\n        The client SHOULD wait a random time between one and ten seconds to\n        desynchronize the use of DHCP at startup.", "id": "f13069:m2"}
{"signature": "def gen_timeout_resend(attempts):", "body": "timeout = <NUM_LIT:2> ** (attempts + <NUM_LIT:1>) + random.uniform(-<NUM_LIT:1>, +<NUM_LIT:1>)<EOL>logger.debug('<STR_LIT>',<EOL>future_dt_str(nowutc(), timeout))<EOL>return timeout<EOL>", "docstring": "Generate the time in seconds in which DHCPDISCOVER wil be retransmited.\n\n    [:rfc:`2131#section-3.1`]::\n\n        might retransmit the\n        DHCPREQUEST message four times, for a total delay of 60 seconds\n\n    [:rfc:`2131#section-4.1`]::\n\n        For example, in a 10Mb/sec Ethernet\n        internetwork, the delay before the first retransmission SHOULD be 4\n        seconds randomized by the value of a uniform random number chosen\n        from the range -1 to +1.  Clients with clocks that provide resolution\n        granularity of less than one second may choose a non-integer\n        randomization value.  The delay before the next retransmission SHOULD\n        be 8 seconds randomized by the value of a uniform number chosen from\n        the range -1 to +1.  The retransmission delay SHOULD be doubled with\n        subsequent retransmissions up to a maximum of 64 seconds.", "id": "f13069:m3"}
{"signature": "def info_lease(self):", "body": "for k, v in LEASE_ATTRS2LEASE_LOG. items():<EOL><INDENT>logger.debug(\"<STR_LIT>\", v, getattr(self, k))<EOL><DEDENT>for k, v in ENV_OPTIONS_REQ.items():<EOL><INDENT>logger.debug(\"<STR_LIT>\", k)<EOL><DEDENT>logger.info('<STR_LIT>', self.address)<EOL>logger.info('<STR_LIT>', self.subnet_mask_cidr, self.subnet_mask)<EOL>logger.info('<STR_LIT>', self.router)<EOL>logger.info('<STR_LIT>', self.server_id)<EOL>logger.info('<STR_LIT>', self.name_server)<EOL>logger.info('<STR_LIT>', self.domain)<EOL>logger.info('<STR_LIT>', self.lease_time)<EOL>", "docstring": "Print lease information.", "id": "f13074:c0:m1"}
{"signature": "def gen_request_unicast(self):", "body": "dhcp_req = (<EOL>self.gen_ether_ip_unicast() /<EOL>self.gen_udp() /<EOL>self.gen_bootp_unicast() /<EOL>DHCP(options=[<EOL>(\"<STR_LIT>\", \"<STR_LIT>\"),<EOL>(\"<STR_LIT>\", mac2str(self.client_mac)),<EOL>(\"<STR_LIT>\", self.prl),<EOL>\"<STR_LIT:end>\"])<EOL>)<EOL>logger.debug('<STR_LIT>', dhcp_req.summary())<EOL>return dhcp_req<EOL>", "docstring": "Generate DHCP REQUEST unicast packet.\n\nSame comments as in gen_request apply.", "id": "f13075:c0:m8"}
{"signature": "def gen_ether_ip_unicast(self):", "body": "ether_ip = (Ether(src=self.client_mac, dst=self.server_mac) /<EOL>IP(src=self.client_ip, dst=self.server_ip))<EOL>return ether_ip<EOL>", "docstring": "Generates link layer and IP layer part of DHCP packet.\n\n        For unicast packets is:\n            Ether(src=client_mac, dst=server_mac) /\n            IP(src=client_ip?, dst=server_ip) /", "id": "f13075:c0:m2"}
{"signature": "def gen_bootp_unicast(self):", "body": "bootp = (<EOL>BOOTP(chaddr=[mac2str(self.client_mac)], xid=self.xid,<EOL>ciaddr=self.client_ip)<EOL>)<EOL>return bootp<EOL>", "docstring": "Generates BOOTP layer part of unicast DHCP packet.\n\n        Same comments as in gen_bootp", "id": "f13075:c0:m5"}
{"signature": "def gen_check_lease_attrs(self, attrs_dict):", "body": "<EOL>assert attrs_dict['<STR_LIT>']<EOL>assert attrs_dict['<STR_LIT:address>']<EOL>ipn = IPNetwork(attrs_dict['<STR_LIT:address>'] + '<STR_LIT:/>' +<EOL>attrs_dict['<STR_LIT>'])<EOL>if attrs_dict.get('<STR_LIT>') is None:<EOL><INDENT>attrs_dict['<STR_LIT>'] = self.server_ip<EOL><DEDENT>if attrs_dict.get('<STR_LIT>') is None:<EOL><INDENT>attrs_dict['<STR_LIT>'] = attrs_dict['<STR_LIT>']<EOL><DEDENT>ripn = IPNetwork(attrs_dict['<STR_LIT>'] + '<STR_LIT:/>' +<EOL>attrs_dict['<STR_LIT>'])<EOL>assert ripn.network == ipn.network<EOL>attrs_dict['<STR_LIT>'] = str(ipn.prefixlen)<EOL>attrs_dict['<STR_LIT>'] = str(ipn.network)<EOL>if attrs_dict.get('<STR_LIT>') is None:<EOL><INDENT>attrs_dict['<STR_LIT>'] = str(ipn.broadcast)<EOL><DEDENT>if attrs_dict.get('<STR_LIT>') is None:<EOL><INDENT>attrs_dict['<STR_LIT>'] = attrs_dict['<STR_LIT>']<EOL><DEDENT>if attrs_dict.get('<STR_LIT>') is None:<EOL><INDENT>attrs_dict['<STR_LIT>'] = attrs_dict['<STR_LIT>']<EOL><DEDENT>logger.debug('<STR_LIT>')<EOL>return attrs_dict<EOL>", "docstring": "Generate network mask in CIDR format and subnet.\n\n        Validate the given arguments. Otherwise AddrFormatError exception\n        will be raised and catched in the FSM.", "id": "f13075:c0:m12"}
{"signature": "def generate_rgb(number=<NUM_LIT:1>):", "body": "return tuple(fauxfactory.gen_integer(<NUM_LIT:0>, <NUM_LIT:255>) for _ in range(number))<EOL>", "docstring": "Generate random RGB values.", "id": "f13079:m0"}
{"signature": "def generate_rgb(number=<NUM_LIT:1>):", "body": "return tuple(fauxfactory.gen_integer(<NUM_LIT:0>, <NUM_LIT:255>) for _ in range(number))<EOL>", "docstring": "Generate random RGB values.", "id": "f13081:m17"}
{"signature": "def foo_generator():", "body": "yield '<STR_LIT:foo>'<EOL>yield [<NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:3>]<EOL>", "docstring": "Returns different values: first, a string 'foo'; second iteration, a\n    list of integers.", "id": "f13082:m7"}
{"signature": "def faux_callable(items, callable_func, *args, **kwargs):", "body": "if items is None:<EOL><INDENT>items = <NUM_LIT:1><EOL><DEDENT>for _ in range(items):<EOL><INDENT>yield callable_func(*args, **kwargs)<EOL><DEDENT>", "docstring": "Generate new values from callable object.", "id": "f13089:m0"}
{"signature": "def faux_string(items, str_type=None, *args, **kwargs):", "body": "item = <NUM_LIT:0><EOL>if not str_type:<EOL><INDENT>str_type = fauxfactory.gen_choice(STRING_TYPES)<EOL><DEDENT>if not isinstance(str_type, list):<EOL><INDENT>str_type = [str_type]<EOL><DEDENT>str_cycle = cycle(str_type)<EOL>length = kwargs.get('<STR_LIT>', None)<EOL>if not length:<EOL><INDENT>length = [None]<EOL><DEDENT>if not isinstance(length, list):<EOL><INDENT>length = [length]<EOL><DEDENT>length_cycle = cycle(length)<EOL>while item < items:<EOL><INDENT>str_type = next(str_cycle)<EOL>kwargs['<STR_LIT>'] = next(length_cycle)<EOL>yield fauxfactory.gen_string(str_type, *args, **kwargs)<EOL>item += <NUM_LIT:1><EOL><DEDENT>", "docstring": "Generate a new string type.", "id": "f13089:m2"}
{"signature": "@classmethod<EOL><INDENT>def get_start_datetime(cls):<DEDENT>", "body": "return settings.STATISTIC_DEFAULT_START_DATETIME<EOL>", "docstring": "Must return a date/time object indicating when the earliest\ndata available for this metric occurred.", "id": "f13095:c0:m5"}
{"signature": "def list_statistics():", "body": "for s in get_statistic_models():<EOL><INDENT>print(s.__name__, \"<STR_LIT>\" % s)<EOL><DEDENT>", "docstring": "Prints all of the available statistics.", "id": "f13099:m0"}
{"signature": "def get_statistic_by_name(stat_name):", "body": "if stat_name == '<STR_LIT>':<EOL><INDENT>return get_statistic_models()<EOL><DEDENT>for stat in get_statistic_models():<EOL><INDENT>if stat.__name__ == stat_name:<EOL><INDENT>return stat<EOL><DEDENT><DEDENT>raise Exception(_(\"<STR_LIT>\") % {'<STR_LIT>': stat_name})<EOL>", "docstring": "Fetches a statistics based on the given class name. Does a look-up\nin the gadgets' registered statistics to find the specified one.", "id": "f13099:m2"}
{"signature": "@geck_o_meter<EOL>def geckoboard_geckometer(request):", "body": "params = get_gecko_params(request, cumulative=True)<EOL>metric = Metric.objects.get(uid=params['<STR_LIT>'])<EOL>return (metric.latest_count(frequency=params['<STR_LIT>'], count=not params['<STR_LIT>'],<EOL>cumulative=params['<STR_LIT>']), params['<STR_LIT>'], params['<STR_LIT>'])<EOL>", "docstring": "Returns a Geck-o-Meter control for the specified metric.", "id": "f13103:m8"}
{"signature": "def get_GET_bool(request, var_name, default=True):", "body": "val = request.GET.get(var_name, default)<EOL>if isinstance(val, str) or isinstance(val, str):<EOL><INDENT>val = True if val[<NUM_LIT:0>] == '<STR_LIT:t>' else False<EOL><DEDENT>return val<EOL>", "docstring": "Tries to extract a boolean variable from the specified request.", "id": "f13103:m1"}
{"signature": "def get_next_colour():", "body": "colour = settings.GECKOBOARD_COLOURS[get_next_colour.cur_colour]<EOL>get_next_colour.cur_colour += <NUM_LIT:1><EOL>if get_next_colour.cur_colour >= len(settings.GECKOBOARD_COLOURS):<EOL><INDENT>get_next_colour.cur_colour = <NUM_LIT:0><EOL><DEDENT>return colour<EOL>", "docstring": "Gets the next colour in the Geckoboard colour list.", "id": "f13103:m2"}
{"signature": "def load(self):", "body": "if isinstance(self.application, str):<EOL><INDENT>return util.import_app(self.application)<EOL><DEDENT>else:<EOL><INDENT>return self.application<EOL><DEDENT>", "docstring": "Attempt an import of the specified application", "id": "f13107:c0:m2"}
{"signature": "def run(self):", "body": "self.app.run()<EOL>", "docstring": "Run our application", "id": "f13107:c1:m1"}
{"signature": "def setup_http_server(rate_limit=-<NUM_LIT:1>, reset_rate_limit=-<NUM_LIT:1>):", "body": "http_requests = []<EOL>events_bodies = [<EOL>read_file('<STR_LIT>', '<STR_LIT:rb>'),<EOL>read_file('<STR_LIT>', '<STR_LIT:rb>')<EOL>]<EOL>events_range_body = read_file('<STR_LIT>', '<STR_LIT:rb>')<EOL>events_empty_body = read_file('<STR_LIT>', '<STR_LIT:rb>')<EOL>event_comments_body = read_file('<STR_LIT>', '<STR_LIT:rb>')<EOL>event_rsvps_body = read_file('<STR_LIT>', '<STR_LIT:rb>')<EOL>def request_callback(method, uri, headers, too_many_requests=False):<EOL><INDENT>last_request = httpretty.last_request()<EOL>if uri.startswith(MEETUP_EVENT_1_COMMENTS_URL):<EOL><INDENT>body = event_comments_body<EOL><DEDENT>elif uri.startswith(MEETUP_EVENT_2_COMMENTS_URL):<EOL><INDENT>body = event_comments_body<EOL><DEDENT>elif uri.startswith(MEETUP_EVENT_3_COMMENTS_URL):<EOL><INDENT>body = event_comments_body<EOL><DEDENT>elif uri.startswith(MEETUP_EVENT_1_RSVPS_URL):<EOL><INDENT>body = event_rsvps_body<EOL><DEDENT>elif uri.startswith(MEETUP_EVENT_2_RSVPS_URL):<EOL><INDENT>body = event_rsvps_body<EOL><DEDENT>elif uri.startswith(MEETUP_EVENT_3_RSVPS_URL):<EOL><INDENT>body = event_rsvps_body<EOL><DEDENT>elif uri.startswith(MEETUP_EVENTS_URL):<EOL><INDENT>params = last_request.querystring<EOL>scroll = params.get('<STR_LIT>', None)<EOL>if scroll and scroll[<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>body = events_bodies[-<NUM_LIT:1>]<EOL><DEDENT>elif scroll and scroll[<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>body = events_range_body<EOL><DEDENT>elif scroll and scroll[<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>body = events_empty_body<EOL><DEDENT>else:<EOL><INDENT>body = events_bodies.pop(<NUM_LIT:0>)<EOL>if events_bodies:<EOL><INDENT>headers['<STR_LIT>'] = '<STR_LIT:<>' + MEETUP_EVENTS_URL + '<STR_LIT>'<EOL><DEDENT>if rate_limit != -<NUM_LIT:1>:<EOL><INDENT>headers['<STR_LIT>'] = str(rate_limit)<EOL><DEDENT>if reset_rate_limit != -<NUM_LIT:1>:<EOL><INDENT>headers['<STR_LIT>'] = str(reset_rate_limit)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT>if rate_limit == -<NUM_LIT:1>:<EOL><INDENT>headers['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>if reset_rate_limit == -<NUM_LIT:1>:<EOL><INDENT>headers['<STR_LIT>'] = '<STR_LIT:0>'<EOL><DEDENT>http_requests.append(last_request)<EOL>return (<NUM_LIT:200>, headers, body)<EOL><DEDENT>httpretty.register_uri(httpretty.GET,<EOL>MEETUP_EVENTS_URL,<EOL>responses=[<EOL>httpretty.Response(body=request_callback)<EOL>for _ in range(<NUM_LIT:2>)<EOL>])<EOL>for url in MEETUP_COMMENTS_URL:<EOL><INDENT>httpretty.register_uri(httpretty.GET,<EOL>url,<EOL>responses=[<EOL>httpretty.Response(body=request_callback)<EOL>])<EOL><DEDENT>for url in MEETUP_RSVPS_URL:<EOL><INDENT>httpretty.register_uri(httpretty.GET,<EOL>url,<EOL>responses=[<EOL>httpretty.Response(body=request_callback)<EOL>])<EOL><DEDENT>return http_requests<EOL>", "docstring": "Setup a mock HTTP server", "id": "f13119:m1"}
{"signature": "def setup_http_server():", "body": "http_requests = []<EOL>error_body = read_file('<STR_LIT>', '<STR_LIT:rb>')<EOL>tasks_body = read_file('<STR_LIT>', '<STR_LIT:rb>')<EOL>tasks_next_body = read_file('<STR_LIT>', '<STR_LIT:rb>')<EOL>tasks_empty_body = read_file('<STR_LIT>')<EOL>tasks_trans_body = read_file('<STR_LIT>', '<STR_LIT:rb>')<EOL>tasks_trans_next_body = read_file('<STR_LIT>', '<STR_LIT:rb>')<EOL>users_body = read_file('<STR_LIT>', '<STR_LIT:rb>')<EOL>jane_body = read_file('<STR_LIT>', '<STR_LIT:rb>')<EOL>janes_body = read_file('<STR_LIT>', '<STR_LIT:rb>')<EOL>jdoe_body = read_file('<STR_LIT>', '<STR_LIT:rb>')<EOL>jrae_body = read_file('<STR_LIT>', '<STR_LIT:rb>')<EOL>jsmith_body = read_file('<STR_LIT>', '<STR_LIT:rb>')<EOL>phids_body = read_file('<STR_LIT>', '<STR_LIT:rb>')<EOL>herald_body = read_file('<STR_LIT>', '<STR_LIT:rb>')<EOL>bugreport_body = read_file('<STR_LIT>', '<STR_LIT:rb>')<EOL>teamdevel_body = read_file('<STR_LIT>', '<STR_LIT:rb>')<EOL>phids_users = {<EOL>'<STR_LIT>': jane_body,<EOL>'<STR_LIT>': janes_body,<EOL>'<STR_LIT>': jdoe_body,<EOL>'<STR_LIT>': jrae_body,<EOL>'<STR_LIT>': jsmith_body<EOL>}<EOL>phids = {<EOL>'<STR_LIT>': herald_body,<EOL>'<STR_LIT>': bugreport_body,<EOL>'<STR_LIT>': teamdevel_body<EOL>}<EOL>def request_callback(method, uri, headers):<EOL><INDENT>last_request = httpretty.last_request()<EOL>params = json.loads(last_request.parsed_body['<STR_LIT>'][<NUM_LIT:0>])<EOL>if uri == PHABRICATOR_TASKS_URL:<EOL><INDENT>if params['<STR_LIT>']['<STR_LIT>'] == <NUM_LIT>:<EOL><INDENT>body = tasks_next_body<EOL><DEDENT>elif params['<STR_LIT>']['<STR_LIT>'] == <NUM_LIT>:<EOL><INDENT>body = tasks_empty_body<EOL><DEDENT>elif '<STR_LIT>' not in params:<EOL><INDENT>body = tasks_body<EOL><DEDENT>else:<EOL><INDENT>body = tasks_next_body<EOL><DEDENT><DEDENT>elif uri == PHABRICATOR_TRANSACTIONS_URL:<EOL><INDENT>if <NUM_LIT> in params['<STR_LIT>']:<EOL><INDENT>body = tasks_trans_body<EOL><DEDENT>else:<EOL><INDENT>body = tasks_trans_next_body<EOL><DEDENT><DEDENT>elif uri == PHABRICATOR_USERS_URL:<EOL><INDENT>if len(params['<STR_LIT>']) == <NUM_LIT:4>:<EOL><INDENT>body = users_body<EOL><DEDENT>else:<EOL><INDENT>body = phids_users[params['<STR_LIT>'][<NUM_LIT:0>]]<EOL><DEDENT><DEDENT>elif uri == PHABRICATOR_PHIDS_URL:<EOL><INDENT>if len(params['<STR_LIT>']) == <NUM_LIT:2>:<EOL><INDENT>body = phids_body<EOL><DEDENT>else:<EOL><INDENT>body = phids[params['<STR_LIT>'][<NUM_LIT:0>]]<EOL><DEDENT><DEDENT>elif uri == PHABRICATOR_API_ERROR_URL:<EOL><INDENT>body = error_body<EOL><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT>http_requests.append(last_request)<EOL>return (<NUM_LIT:200>, headers, body)<EOL><DEDENT>httpretty.register_uri(httpretty.POST,<EOL>PHABRICATOR_TASKS_URL,<EOL>responses=[<EOL>httpretty.Response(body=request_callback)<EOL>])<EOL>httpretty.register_uri(httpretty.POST,<EOL>PHABRICATOR_TRANSACTIONS_URL,<EOL>responses=[<EOL>httpretty.Response(body=request_callback)<EOL>])<EOL>httpretty.register_uri(httpretty.POST,<EOL>PHABRICATOR_USERS_URL,<EOL>responses=[<EOL>httpretty.Response(body=request_callback)<EOL>])<EOL>httpretty.register_uri(httpretty.POST,<EOL>PHABRICATOR_PHIDS_URL,<EOL>responses=[<EOL>httpretty.Response(body=request_callback)<EOL>])<EOL>httpretty.register_uri(httpretty.POST,<EOL>PHABRICATOR_API_ERROR_URL,<EOL>responses=[<EOL>httpretty.Response(body=request_callback)<EOL>])<EOL>return http_requests<EOL>", "docstring": "Setup a mock HTTP server", "id": "f13139:m1"}
{"signature": "def mock_check_ouput_empty_review(*args, **kwargs):", "body": "return None<EOL>", "docstring": "Mock subprocess.check_output", "id": "f13141:m3"}
{"signature": "def _search_files(self):", "body": "for root, _, files in os.walk(self.dirpath):<EOL><INDENT>for filename in files:<EOL><INDENT>location = os.path.join(root, filename)<EOL>yield location<EOL><DEDENT><DEDENT>", "docstring": "Retrieve the file paths stored under the base path.", "id": "f13148:c1:m5"}
{"signature": "def _count_table_rows(self, table_name):", "body": "cursor = self._db.cursor()<EOL>select_stmt = \"<STR_LIT>\" + table_name<EOL>try:<EOL><INDENT>cursor.execute(select_stmt)<EOL>row = cursor.fetchone()<EOL><DEDENT>except sqlite3.DatabaseError as e:<EOL><INDENT>msg = \"<STR_LIT>\" % str(e)<EOL>raise ArchiveError(cause=msg)<EOL><DEDENT>finally:<EOL><INDENT>cursor.close()<EOL><DEDENT>return row[<NUM_LIT:0>]<EOL>", "docstring": "Fetch the number of rows in a table", "id": "f13148:c0:m9"}
{"signature": "def store(self, uri, payload, headers, data):", "body": "hashcode = self.make_hashcode(uri, payload, headers)<EOL>payload_dump = pickle.dumps(payload, <NUM_LIT:0>)<EOL>headers_dump = pickle.dumps(headers, <NUM_LIT:0>)<EOL>data_dump = pickle.dumps(data, <NUM_LIT:0>)<EOL>logger.debug(\"<STR_LIT>\",<EOL>hashcode, uri, payload, headers, self.archive_path)<EOL>try:<EOL><INDENT>cursor = self._db.cursor()<EOL>insert_stmt = \"<STR_LIT>\" + self.ARCHIVE_TABLE + \"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"<EOL>cursor.execute(insert_stmt, (None, hashcode, uri,<EOL>payload_dump, headers_dump, data_dump))<EOL>self._db.commit()<EOL>cursor.close()<EOL><DEDENT>except sqlite3.IntegrityError as e:<EOL><INDENT>msg = \"<STR_LIT>\" % hashcode<EOL>raise ArchiveError(cause=msg)<EOL><DEDENT>except sqlite3.DatabaseError as e:<EOL><INDENT>msg = \"<STR_LIT>\" % str(e)<EOL>raise ArchiveError(cause=msg)<EOL><DEDENT>logger.debug(\"<STR_LIT>\", hashcode, self.archive_path)<EOL>", "docstring": "Store a raw item in this archive.\n\n        The method will store `data` content in this archive. The unique\n        identifier for that item will be generated using the rest of the\n        parameters.\n\n        :param uri: request URI\n        :param payload: request payload\n        :param headers: request headers\n        :param data: data to store in this archive\n\n        :raises ArchiveError: when an error occurs storing the given data", "id": "f13148:c0:m3"}
{"signature": "def fetch_items(self, category, **kwargs):", "body": "from_date = datetime_to_utc(kwargs['<STR_LIT>']).timestamp()<EOL>questions_groups = self.client.get_api_questions(AskbotClient.API_QUESTIONS)<EOL>for questions in questions_groups:<EOL><INDENT>for question in questions['<STR_LIT>']:<EOL><INDENT>updated_at = int(question['<STR_LIT>'])<EOL>if updated_at > from_date:<EOL><INDENT>html_question = self.__fetch_question(question)<EOL>if not html_question:<EOL><INDENT>continue<EOL><DEDENT>logger.debug(\"<STR_LIT>\", question['<STR_LIT:id>'])<EOL>comments = self.__fetch_comments(question)<EOL>question_obj = self.__build_question(html_question, question, comments)<EOL>question.update(question_obj)<EOL>yield question<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Fetch the questions\n\n        :param category: the category of items to fetch\n        :param kwargs: backend arguments\n\n        :returns: a generator of items", "id": "f13151:c0:m2"}
{"signature": "def get_api_questions(self, path):", "body": "npages = <NUM_LIT:1><EOL>next_request = True<EOL>path = urijoin(self.base_url, path)<EOL>while next_request:<EOL><INDENT>try:<EOL><INDENT>params = {<EOL>'<STR_LIT>': npages,<EOL>'<STR_LIT>': self.ORDER_API<EOL>}<EOL>response = self.fetch(path, payload=params)<EOL>whole_page = response.text<EOL>raw_questions = json.loads(whole_page)<EOL>tpages = raw_questions['<STR_LIT>']<EOL>logger.debug(\"<STR_LIT>\",<EOL>self.base_url, npages, tpages)<EOL>if npages == tpages:<EOL><INDENT>next_request = False<EOL><DEDENT>npages = npages + <NUM_LIT:1><EOL>yield raw_questions<EOL><DEDENT>except requests.exceptions.TooManyRedirects as e:<EOL><INDENT>logger.warning(\"<STR_LIT>\", e, path)<EOL>next_request = False<EOL><DEDENT><DEDENT>", "docstring": "Retrieve a question page using the API.\n\n        :param page: page to retrieve", "id": "f13151:c1:m1"}
{"signature": "def __fetch_question(self, question):", "body": "html_question_items = []<EOL>npages = <NUM_LIT:1><EOL>next_request = True<EOL>while next_request:<EOL><INDENT>try:<EOL><INDENT>html_question = self.client.get_html_question(question['<STR_LIT:id>'], npages)<EOL>html_question_items.append(html_question)<EOL>tpages = self.ab_parser.parse_number_of_html_pages(html_question)<EOL>if npages == tpages:<EOL><INDENT>next_request = False<EOL><DEDENT>npages = npages + <NUM_LIT:1><EOL><DEDENT>except requests.exceptions.TooManyRedirects as e:<EOL><INDENT>logger.warning(\"<STR_LIT>\", e, question['<STR_LIT:id>'])<EOL>next_request = False<EOL><DEDENT><DEDENT>return html_question_items<EOL>", "docstring": "Fetch an Askbot HTML question body.\n\n        The method fetchs the HTML question retrieving the\n        question body of the item question received\n\n        :param question: item with the question itself\n\n        :returns: a list of HTML page/s for the question", "id": "f13151:c0:m9"}
{"signature": "@staticmethod<EOL><INDENT>def parse_number_of_html_pages(html_question):<DEDENT>", "body": "bs_question = bs4.BeautifulSoup(html_question, \"<STR_LIT>\")<EOL>try:<EOL><INDENT>bs_question.select('<STR_LIT>')[<NUM_LIT:0>]<EOL><DEDENT>except IndexError:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>return int(bs_question.select('<STR_LIT>')[<NUM_LIT:0>].attrs['<STR_LIT>'])<EOL><DEDENT>", "docstring": "Parse number of answer pages to paginate over them.\n\n        :param html_question: raw HTML question element\n\n        :returns: an integer with the number of pages", "id": "f13151:c2:m2"}
{"signature": "def get_comments(self, post_id):", "body": "path = urijoin(self.base_url, self.COMMENTS if self._use_new_urls else self.COMMENTS_OLD)<EOL>params = {<EOL>'<STR_LIT>': post_id,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': <NUM_LIT:0><EOL>}<EOL>headers = {'<STR_LIT>': '<STR_LIT>'}<EOL>try:<EOL><INDENT>response = self.fetch(path, payload=params, headers=headers)<EOL>raw = response.text<EOL><DEDENT>except requests.exceptions.HTTPError as ex:<EOL><INDENT>if ex.response.status_code == <NUM_LIT>:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>self._use_new_urls = False<EOL>path = urijoin(self.base_url, self.COMMENTS_OLD)<EOL>response = self.fetch(path, payload=params, headers=headers)<EOL>raw = response.text<EOL><DEDENT>elif ex.response.status_code == <NUM_LIT>:<EOL><INDENT>logger.warning(\"<STR_LIT>\", ex)<EOL>raw = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>raise ex<EOL><DEDENT><DEDENT>return raw<EOL>", "docstring": "Retrieve a list of comments by a given id.\n\n        :param object_id: object identifiere", "id": "f13151:c1:m3"}
{"signature": "@staticmethod<EOL><INDENT>def metadata_id(item):<DEDENT>", "body": "return str(item['<STR_LIT:id>'])<EOL>", "docstring": "Extracts the identifier from an Askbot question item.", "id": "f13151:c0:m6"}
{"signature": "def _filter_message_by_chats(self, message, chats):", "body": "if chats is None:<EOL><INDENT>return True<EOL><DEDENT>chat_id = message['<STR_LIT:message>']['<STR_LIT>']['<STR_LIT:id>']<EOL>return chat_id in chats<EOL>", "docstring": "Check if a message can be filtered based in a list of chats.\n\n        This method returns `True` when the message was sent to a chat\n        of the given list. It also returns `True` when chats is `None`.\n\n        :param message: Telegram message\n        :param chats: list of chat, groups and channels identifiers\n\n        :returns: `True` when the message can be filtered; otherwise,\n            it returns `False`", "id": "f13152:c0:m11"}
{"signature": "def _call(self, method, params):", "body": "url = self.base_url % {'<STR_LIT>': self.bot_token, '<STR_LIT>': method}<EOL>logger.debug(\"<STR_LIT>\",<EOL>method, str(params))<EOL>r = self.fetch(url, payload=params)<EOL>return r.text<EOL>", "docstring": "Retrive the given resource.\n\n        :param resource: resource to retrieve\n        :param params: dict with the HTTP parameters needed to retrieve\n            the given resource", "id": "f13152:c2:m3"}
{"signature": "@staticmethod<EOL><INDENT>def metadata_category(item):<DEDENT>", "body": "return CATEGORY_MESSAGE<EOL>", "docstring": "Extracts the category from a Telegram item.\n\n        This backend only generates one type of item which is\n        'message'.", "id": "f13152:c0:m8"}
{"signature": "def fetch(self, category=CATEGORY_MESSAGE, offset=DEFAULT_OFFSET, chats=None):", "body": "if not offset:<EOL><INDENT>offset = DEFAULT_OFFSET<EOL><DEDENT>kwargs = {\"<STR_LIT>\": offset, \"<STR_LIT>\": chats}<EOL>items = super().fetch(category, **kwargs)<EOL>return items<EOL>", "docstring": "Fetch the messages the bot can read from the server.\n\n        The method retrieves, from the Telegram server, the messages\n        sent with an offset equal or greater than the given.\n\n        A list of chats, groups and channels identifiers can be set\n        using the parameter `chats`. When it is set, only those\n        messages sent to any of these will be returned. An empty list\n        will return no messages.\n\n        :param category: the category of items to fetch\n        :param offset: obtain messages from this offset\n        :param chats: list of chat names used to filter messages\n\n        :returns: a generator of messages\n\n        :raises ValueError: when `chats` is an empty list", "id": "f13152:c0:m1"}
{"signature": "def count_objects(self):", "body": "cmd_count = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>outs = self._exec(cmd_count, cwd=self.dirpath, env=self.gitenv)<EOL>outs = outs.decode('<STR_LIT:utf-8>', errors='<STR_LIT>').rstrip()<EOL>try:<EOL><INDENT>cobjs = {k: v for k, v in (x.split('<STR_LIT>') for x in outs.split('<STR_LIT:\\n>'))}<EOL>nobjs = int(cobjs['<STR_LIT:count>']) + int(cobjs['<STR_LIT>'])<EOL><DEDENT>except KeyError as e:<EOL><INDENT>error = \"<STR_LIT>\"% e.args[<NUM_LIT:0>]<EOL>raise RepositoryError(cause=error)<EOL><DEDENT>except ValueError as e:<EOL><INDENT>error = \"<STR_LIT>\" % str(e)<EOL>raise RepositoryError(cause=error)<EOL><DEDENT>logger.debug(\"<STR_LIT>\",<EOL>self.uri, str(nobjs))<EOL>return nobjs<EOL>", "docstring": "Count the objects of a repository.\n\n        The method returns the total number of objects (packed and unpacked)\n        available on the repository.\n\n        :raises RepositoryError: when an error occurs counting the objects\n            of a repository", "id": "f13153:c5:m2"}
{"signature": "@staticmethod<EOL><INDENT>def _exec(cmd, cwd=None, env=None, ignored_error_codes=None,<EOL>encoding='<STR_LIT:utf-8>'):<DEDENT>", "body": "if ignored_error_codes is None:<EOL><INDENT>ignored_error_codes = []<EOL><DEDENT>logger.debug(\"<STR_LIT>\",<EOL>'<STR_LIT:U+0020>'.join(cmd), cwd, str(env))<EOL>try:<EOL><INDENT>proc = subprocess.Popen(cmd, stdout=subprocess.PIPE,<EOL>stderr=subprocess.PIPE,<EOL>cwd=cwd, env=env)<EOL>(outs, errs) = proc.communicate()<EOL><DEDENT>except OSError as e:<EOL><INDENT>raise RepositoryError(cause=str(e))<EOL><DEDENT>if proc.returncode != <NUM_LIT:0> and proc.returncode not in ignored_error_codes:<EOL><INDENT>err = errs.decode(encoding, errors='<STR_LIT>')<EOL>cause = \"<STR_LIT>\" % err<EOL>raise RepositoryError(cause=cause)<EOL><DEDENT>else:<EOL><INDENT>logger.debug(errs.decode(encoding, errors='<STR_LIT>'))<EOL><DEDENT>return outs<EOL>", "docstring": "Run a command.\n\n        Execute `cmd` command in the directory set by `cwd`. Environment\n        variables can be set using the `env` dictionary. The output\n        data is returned as encoded bytes.\n\n        Commands which their returning status codes are non-zero will\n        be treated as failed. Error codes considered as valid can be\n        ignored giving them in the `ignored_error_codes` list.\n\n        :returns: the output of the command as encoded bytes\n\n        :raises RepositoryError: when an error occurs running the command", "id": "f13153:c5:m17"}
{"signature": "def _update_references(self, refs):", "body": "new_refs = [ref.refname for ref in refs]<EOL>for old_ref in self._discover_refs():<EOL><INDENT>if not old_ref.refname.startswith('<STR_LIT>'):<EOL><INDENT>continue<EOL><DEDENT>if old_ref.refname in new_refs:<EOL><INDENT>continue<EOL><DEDENT>self._update_ref(old_ref, delete=True)<EOL><DEDENT>for new_ref in refs:<EOL><INDENT>refname = new_ref.refname<EOL>if refname.endswith('<STR_LIT>'):<EOL><INDENT>logger.debug(\"<STR_LIT>\",<EOL>refname)<EOL>continue<EOL><DEDENT>elif not refname.startswith('<STR_LIT>') and not refname.startswith('<STR_LIT>'):<EOL><INDENT>logger.debug(\"<STR_LIT>\",<EOL>refname)<EOL>continue<EOL><DEDENT>else:<EOL><INDENT>self._update_ref(new_ref)<EOL><DEDENT><DEDENT>cmd = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>self._exec(cmd, cwd=self.dirpath, env=self.gitenv)<EOL>", "docstring": "Update references removing old ones.", "id": "f13153:c5:m12"}
{"signature": "@staticmethod<EOL><INDENT>def parse_git_log_from_file(filepath):<DEDENT>", "body": "with open(filepath, '<STR_LIT:r>', errors='<STR_LIT>',<EOL>newline=os.linesep) as f:<EOL><INDENT>parser = GitParser(f)<EOL>for commit in parser.parse():<EOL><INDENT>yield commit<EOL><DEDENT><DEDENT>", "docstring": "Parse a Git log file.\n\n        The method parses the Git log file and returns an iterator of\n        dictionaries. Each one of this, contains a commit.\n\n        :param filepath: path to the log file\n\n        :returns: a generator of parsed commits\n\n        :raises ParseError: raised when the format of the Git log file\n            is invalid\n        :raises OSError: raised when an error occurs reading the\n            given file", "id": "f13153:c0:m8"}
{"signature": "def _read_stderr(self, encoding='<STR_LIT:utf-8>'):", "body": "for line in self.proc.stderr:<EOL><INDENT>err_line = line.decode(encoding, errors='<STR_LIT>')<EOL>if self.proc.returncode != <NUM_LIT:0>:<EOL><INDENT>if self.failed_message is not None:<EOL><INDENT>logger.debug(\"<STR_LIT>\" + self.failed_message)<EOL><DEDENT>self.failed_message = err_line<EOL><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\" + err_line)<EOL><DEDENT><DEDENT>", "docstring": "Reads self.proc.stderr.\n\n        Usually, this should be read in a thread, to prevent blocking\n        the read from stdout of the stderr buffer is filled, and this\n        function is not called becuase the program is busy in the\n        stderr reading loop.\n\n        Reads self.proc.stderr (self.proc is the subprocess running\n        the git command), and reads / writes self.failed_message\n        (the message sent to stderr when git fails, usually one line).", "id": "f13153:c5:m16"}
{"signature": "def _pre_init(self):", "body": "if self.parsed_args.git_log:<EOL><INDENT>git_path = self.parsed_args.git_log<EOL><DEDENT>elif not self.parsed_args.git_path:<EOL><INDENT>base_path = os.path.expanduser('<STR_LIT>')<EOL>processed_uri = self.parsed_args.uri.lstrip('<STR_LIT:/>')<EOL>git_path = os.path.join(base_path, processed_uri) + '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>git_path = self.parsed_args.git_path<EOL><DEDENT>setattr(self.parsed_args, '<STR_LIT>', git_path)<EOL>", "docstring": "Initialize repositories directory path", "id": "f13153:c1:m0"}
{"signature": "def _exec_nb(self, cmd, cwd=None, env=None, encoding='<STR_LIT:utf-8>'):", "body": "self.failed_message = None<EOL>logger.debug(\"<STR_LIT>\",<EOL>'<STR_LIT:U+0020>'.join(cmd), cwd, str(env))<EOL>try:<EOL><INDENT>self.proc = subprocess.Popen(cmd,<EOL>stdout=subprocess.PIPE,<EOL>stderr=subprocess.PIPE,<EOL>cwd=cwd,<EOL>env=env)<EOL>err_thread = threading.Thread(target=self._read_stderr,<EOL>kwargs={'<STR_LIT>': encoding},<EOL>daemon=True)<EOL>err_thread.start()<EOL>for line in self.proc.stdout:<EOL><INDENT>yield line.decode(encoding, errors='<STR_LIT>')<EOL><DEDENT>err_thread.join()<EOL>self.proc.communicate()<EOL>self.proc.stdout.close()<EOL>self.proc.stderr.close()<EOL><DEDENT>except OSError as e:<EOL><INDENT>err_thread.join()<EOL>raise RepositoryError(cause=str(e))<EOL><DEDENT>if self.proc.returncode != <NUM_LIT:0>:<EOL><INDENT>cause = \"<STR_LIT>\" %(self.failed_message, self.proc.returncode)<EOL>raise RepositoryError(cause=cause)<EOL><DEDENT>", "docstring": "Run a command with a non blocking call.\n\n        Execute `cmd` command with a non blocking call. The command will\n        be run in the directory set by `cwd`. Enviroment variables can be\n        set using the `env` dictionary. The output data is returned\n        as encoded bytes in an iterator. Each item will be a line of the\n        output.\n\n        :returns: an iterator with the output of the command as encoded bytes\n\n        :raises RepositoryError: when an error occurs running the command", "id": "f13153:c5:m15"}
{"signature": "def show(self, commits=None, encoding='<STR_LIT:utf-8>'):", "body": "if self.is_empty():<EOL><INDENT>logger.warning(\"<STR_LIT>\",<EOL>self.uri)<EOL>raise EmptyRepositoryError(repository=self.uri)<EOL><DEDENT>if commits is None:<EOL><INDENT>commits = []<EOL><DEDENT>cmd_show = ['<STR_LIT>', '<STR_LIT>']<EOL>cmd_show.extend(self.GIT_PRETTY_OUTPUT_OPTS)<EOL>cmd_show.extend(commits)<EOL>for line in self._exec_nb(cmd_show, cwd=self.dirpath, env=self.gitenv):<EOL><INDENT>yield line<EOL><DEDENT>logger.debug(\"<STR_LIT>\",<EOL>self.uri, self.dirpath)<EOL>", "docstring": "Show the data of a set of commits.\n\n        The method returns the output of Git show command for a\n        set of commits using the following options:\n\n            git show --raw --numstat --pretty=fuller --decorate=full\n                --parents -M -C -c [<commit>...<commit>]\n\n        When the list of commits is empty, the command will return\n        data about the last commit, like the default behaviour of\n        `git show`.\n\n        :param commits: list of commits to show data\n        :param encoding: encode the output using this format\n\n        :returns: a generator where each item is a line from the show output\n\n        :raises EmptyRepositoryError: when the repository is empty and\n            the action cannot be performed\n        :raises RepositoryError: when an error occurs fetching the show output", "id": "f13153:c5:m9"}
{"signature": "@classmethod<EOL><INDENT>def setup_cmd_parser(cls):<DEDENT>", "body": "parser = BackendCommandArgumentParser(cls.BACKEND.CATEGORIES,<EOL>from_date=True,<EOL>to_date=True)<EOL>group = parser.parser.add_argument_group('<STR_LIT>')<EOL>group.add_argument('<STR_LIT>', dest='<STR_LIT>',<EOL>nargs='<STR_LIT:+>', type=str, default=None,<EOL>help=\"<STR_LIT>\")<EOL>exgroup = group.add_mutually_exclusive_group()<EOL>exgroup.add_argument('<STR_LIT>', dest='<STR_LIT>',<EOL>help=\"<STR_LIT>\")<EOL>exgroup.add_argument('<STR_LIT>', dest='<STR_LIT>',<EOL>help=\"<STR_LIT>\")<EOL>exgroup_fetch = group.add_mutually_exclusive_group()<EOL>exgroup_fetch.add_argument('<STR_LIT>', dest='<STR_LIT>',<EOL>action='<STR_LIT:store_true>',<EOL>help=\"<STR_LIT>\")<EOL>exgroup_fetch.add_argument('<STR_LIT>', dest='<STR_LIT>',<EOL>action='<STR_LIT:store_true>',<EOL>help=\"<STR_LIT>\")<EOL>parser.parser.add_argument('<STR_LIT>',<EOL>help=\"<STR_LIT>\")<EOL>return parser<EOL>", "docstring": "Returns the Git argument parser.", "id": "f13153:c1:m1"}
{"signature": "@staticmethod<EOL><INDENT>def metadata_updated_on(item):<DEDENT>", "body": "ts = item['<STR_LIT>']<EOL>ts = str_to_datetime(ts)<EOL>return ts.timestamp()<EOL>", "docstring": "Extracts the update time from a Git item.\n\n        The timestamp used is extracted from 'CommitDate' field.\n        This date is converted to UNIX timestamp format taking into\n        account the timezone of the date.\n\n        :param item: item generated by the backend\n\n        :returns: a UNIX timestamp", "id": "f13153:c0:m6"}
{"signature": "@classmethod<EOL><INDENT>def has_resuming(cls):<DEDENT>", "body": "return True<EOL>", "docstring": "Returns whether it supports to resume the fetch process.\n\n        :returns: this backend supports items resuming", "id": "f13154:c0:m4"}
{"signature": "def fetch(self, category=CATEGORY_DOCKERHUB_DATA):", "body": "kwargs = {}<EOL>items = super().fetch(category, **kwargs)<EOL>return items<EOL>", "docstring": "Fetch data from a Docker Hub repository.\n\n        The method retrieves, from a repository stored in Docker Hub,\n        its data which includes number of pulls, stars, description,\n        among other data.\n\n        :param category: the category of items to fetch\n\n        :returns: a generator of data", "id": "f13154:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def has_archiving(cls):<DEDENT>", "body": "return True<EOL>", "docstring": "Returns whether it supports archiving items on the fetch process.\n\n        :returns: this backend supports items archive", "id": "f13154:c0:m3"}
{"signature": "def fetch(self, category=CATEGORY_ISSUE, from_date=DEFAULT_DATETIME):", "body": "if not from_date:<EOL><INDENT>from_date = DEFAULT_DATETIME<EOL><DEDENT>from_date = datetime_to_utc(from_date)<EOL>kwargs = {'<STR_LIT>': from_date}<EOL>items = super().fetch(category, **kwargs)<EOL>return items<EOL>", "docstring": "Fetch the issues from the server.\n\n        This method fetches the issues stored on the server that were\n        updated since the given date. Data about attachments, journals\n        and watchers (among others) are included within each issue.\n\n        :param category: the category of items to fetch\n        :param from_date: obtain issues updated since this date\n\n        :returns: a generator of issues", "id": "f13155:c0:m1"}
{"signature": "def issues(self, from_date=DEFAULT_DATETIME,<EOL>offset=None, max_issues=MAX_ISSUES):", "body": "resource = self.RISSUES + self.CJSON<EOL>ts = datetime_to_utc(from_date)<EOL>ts = ts.strftime(\"<STR_LIT>\")<EOL>params = {<EOL>self.PSTATUS_ID: '<STR_LIT:*>',<EOL>self.PSORT: self.PUPDATED_ON,<EOL>self.PUPDATED_ON: '<STR_LIT>' + ts,<EOL>self.PLIMIT: max_issues<EOL>}<EOL>if offset is not None:<EOL><INDENT>params[self.POFFSET] = offset<EOL><DEDENT>response = self._call(resource, params)<EOL>return response<EOL>", "docstring": "Get the information of a list of issues.\n\n        :param from_date: retrieve issues that where updated from that date;\n            dates are converted to UTC\n        :param offset: starting position for the search\n        :param max_issues: maximum number of issues to reteurn per query", "id": "f13155:c2:m1"}
{"signature": "@classmethod<EOL><INDENT>def has_archiving(cls):<DEDENT>", "body": "return True<EOL>", "docstring": "Returns whether it supports archiving items on the fetch process.\n\n        :returns: this backend supports items archive", "id": "f13155:c0:m3"}
{"signature": "@staticmethod<EOL><INDENT>def parse_user_data(raw_json):<DEDENT>", "body": "result = json.loads(raw_json)<EOL>return result['<STR_LIT:user>']<EOL>", "docstring": "Parse a Redmine user JSON stream.\n\n        The method parses a JSON stream and returns a dictionary\n        with the parsed data for the given user.\n\n        :param raw_json: JSON string to parse\n\n        :returns: a dictionary with the parsed user data", "id": "f13155:c0:m10"}
{"signature": "@classmethod<EOL><INDENT>def setup_cmd_parser(cls):<DEDENT>", "body": "parser = BackendCommandArgumentParser(cls.BACKEND.CATEGORIES,<EOL>archive=True)<EOL>group = parser.parser.add_argument_group('<STR_LIT>')<EOL>group.add_argument('<STR_LIT>', dest='<STR_LIT>',<EOL>default=MAX_RETRIES, type=int,<EOL>help=\"<STR_LIT>\")<EOL>group.add_argument('<STR_LIT>', dest='<STR_LIT>',<EOL>default=DEFAULT_SLEEP_TIME, type=int,<EOL>help=\"<STR_LIT>\")<EOL>parser.parser.add_argument('<STR_LIT>', nargs='<STR_LIT:+>',<EOL>help=\"<STR_LIT>\")<EOL>return parser<EOL>", "docstring": "Returns the GoogleHits argument parser.", "id": "f13156:c2:m0"}
{"signature": "def fetch(self, category=CATEGORY_HITS):", "body": "kwargs = {}<EOL>items = super().fetch(category, **kwargs)<EOL>return items<EOL>", "docstring": "Fetch data from Google API.\n\n        The method retrieves a list of hits for some\n        given keywords using the Google API.\n\n        :param category: the category of items to fetch\n\n        :returns: a generator of data", "id": "f13156:c0:m1"}
{"signature": "def _init_client(self, from_archive=False):", "body": "return GoogleHitsClient(self.sleep_time, self.max_retries,<EOL>archive=self.archive, from_archive=from_archive)<EOL>", "docstring": "Init client", "id": "f13156:c0:m8"}
{"signature": "def fetch_items(self, category, **kwargs):", "body": "logger.info(\"<STR_LIT>\", self.keywords)<EOL>hits_raw = self.client.hits(self.keywords)<EOL>hits = self.__parse_hits(hits_raw)<EOL>yield hits<EOL>logger.info(\"<STR_LIT>\")<EOL>", "docstring": "Fetch Google hit items\n\n        :param category: the category of items to fetch\n        :param kwargs: backend arguments\n\n        :returns: a generator of items", "id": "f13156:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def has_resuming(cls):<DEDENT>", "body": "return True<EOL>", "docstring": "Returns whether it supports to resume the fetch process.\n\n        :returns: this backend supports items resuming", "id": "f13156:c0:m4"}
{"signature": "@classmethod<EOL><INDENT>def has_archiving(cls):<DEDENT>", "body": "return True<EOL>", "docstring": "Returns whether it supports archiving items on the fetch process.\n\n        :returns: this backend supports items archive", "id": "f13156:c0:m3"}
{"signature": "@classmethod<EOL><INDENT>def has_archiving(cls):<DEDENT>", "body": "return True<EOL>", "docstring": "Returns whether it supports archiving items on the fetch process.\n\n        :returns: this backend supports items archive", "id": "f13157:c0:m3"}
{"signature": "def fetch_items(self, category, **kwargs):", "body": "from_date = kwargs['<STR_LIT>']<EOL>logger.info(\"<STR_LIT>\",<EOL>self.url, self.channel, str(from_date))<EOL>fetching = True<EOL>page = <NUM_LIT:0><EOL>nposts = <NUM_LIT:0><EOL>since = int(from_date.timestamp() * <NUM_LIT:1000>)<EOL>while fetching:<EOL><INDENT>raw_posts = self.client.posts(self.channel, page=page)<EOL>posts_before = nposts<EOL>for post in self._parse_posts(raw_posts):<EOL><INDENT>if post['<STR_LIT>'] < since:<EOL><INDENT>fetching = False<EOL>break<EOL><DEDENT>user_id = post['<STR_LIT>']<EOL>user = self._get_or_fetch_user(user_id)<EOL>post['<STR_LIT>'] = user<EOL>yield post<EOL>nposts += <NUM_LIT:1><EOL><DEDENT>if fetching:<EOL><INDENT>if posts_before == nposts:<EOL><INDENT>fetching = False<EOL><DEDENT>else:<EOL><INDENT>page += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>logger.info(\"<STR_LIT>\", nposts)<EOL>", "docstring": "Fetch the messages.\n\n        :param category: the category of items to fetch\n        :param kwargs: backend arguments\n\n        :returns: a generator of items", "id": "f13157:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def setup_cmd_parser(cls):<DEDENT>", "body": "parser = BackendCommandArgumentParser(cls.BACKEND.CATEGORIES,<EOL>from_date=True,<EOL>token_auth=True,<EOL>archive=True)<EOL>group = parser.parser.add_argument_group('<STR_LIT>')<EOL>group.add_argument('<STR_LIT>', dest='<STR_LIT>',<EOL>type=int, default=MAX_ITEMS,<EOL>help=\"<STR_LIT>\")<EOL>group.add_argument('<STR_LIT>', dest='<STR_LIT>',<EOL>action='<STR_LIT:store_true>',<EOL>help=\"<STR_LIT>\")<EOL>group.add_argument('<STR_LIT>', dest='<STR_LIT>',<EOL>default=MIN_RATE_LIMIT, type=int,<EOL>help=\"<STR_LIT>\")<EOL>group.add_argument('<STR_LIT>', dest='<STR_LIT>',<EOL>default=DEFAULT_SLEEP_TIME, type=int,<EOL>help=\"<STR_LIT>\")<EOL>parser.parser.add_argument('<STR_LIT:url>',<EOL>help=\"<STR_LIT>\")<EOL>parser.parser.add_argument('<STR_LIT>',<EOL>help=\"<STR_LIT>\")<EOL>return parser<EOL>", "docstring": "Returns the Meetup argument parser.", "id": "f13157:c2:m0"}
{"signature": "def user(self, user):", "body": "entrypoint = self.RUSERS + '<STR_LIT:/>' + user<EOL>response = self._fetch(entrypoint, None)<EOL>return response<EOL>", "docstring": "Fetch user data.", "id": "f13157:c1:m2"}
{"signature": "def posts(self, channel, page=None):", "body": "entrypoint = self.RCHANNELS + '<STR_LIT:/>' + channel + '<STR_LIT:/>' + self.RPOSTS<EOL>params = {<EOL>self.PPER_PAGE: self.max_items<EOL>}<EOL>if page is not None:<EOL><INDENT>params[self.PPAGE] = page<EOL><DEDENT>response = self._fetch(entrypoint, params)<EOL>return response<EOL>", "docstring": "Fetch the history of a channel.", "id": "f13157:c1:m1"}
{"signature": "@classmethod<EOL><INDENT>def has_resuming(cls):<DEDENT>", "body": "return False<EOL>", "docstring": "Returns whether it supports to resume the fetch process.\n\n        :returns: this backend does not support items resuming", "id": "f13157:c0:m4"}
{"signature": "def bugs(self, from_date=DEFAULT_DATETIME, offset=None, max_bugs=MAX_BUGS):", "body": "date = datetime_to_utc(from_date)<EOL>date = date.strftime(\"<STR_LIT>\")<EOL>params = {<EOL>self.PLAST_CHANGE_TIME: date,<EOL>self.PLIMIT: max_bugs,<EOL>self.PORDER: self.VCHANGE_DATE_ORDER,<EOL>self.PINCLUDE_FIELDS: self.VINCLUDE_ALL<EOL>}<EOL>if offset:<EOL><INDENT>params[self.POFFSET] = offset<EOL><DEDENT>response = self.call(self.RBUG, params)<EOL>return response<EOL>", "docstring": "Get the information of a list of bugs.\n\n        :param from_date: retrieve bugs that where updated from that date;\n            dates are converted to UTC\n        :param offset: starting position for the search; i.e to return 11th\n            element, set this value to 10.\n        :param max_bugs: maximum number of bugs to reteurn per query", "id": "f13158:c2:m2"}
{"signature": "def _init_client(self, from_archive=False):", "body": "return BugzillaRESTClient(self.url, user=self.user, password=self.password, api_token=self.api_token,<EOL>archive=self.archive, from_archive=from_archive)<EOL>", "docstring": "Init client", "id": "f13158:c0:m8"}
{"signature": "@staticmethod<EOL><INDENT>def metadata_id(item):<DEDENT>", "body": "return str(item['<STR_LIT:id>'])<EOL>", "docstring": "Extracts the identifier from a Bugzilla item.", "id": "f13158:c0:m5"}
{"signature": "def fetch_items(self, category, **kwargs):", "body": "from_date = kwargs['<STR_LIT>']<EOL>logger.info(\"<STR_LIT>\",<EOL>self.url, str(from_date))<EOL>nbugs = <NUM_LIT:0><EOL>for bug in self.__fetch_and_parse_bugs(from_date):<EOL><INDENT>nbugs += <NUM_LIT:1><EOL>yield bug<EOL><DEDENT>logger.info(\"<STR_LIT>\", nbugs)<EOL>", "docstring": "Fetch the bugs\n\n        :param category: the category of items to fetch\n        :param kwargs: backend arguments\n\n        :returns: a generator of items", "id": "f13158:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def has_archiving(cls):<DEDENT>", "body": "return True<EOL>", "docstring": "Returns whether it supports archiving items on the fetch process.\n\n        :returns: this backend supports items archive", "id": "f13158:c0:m3"}
{"signature": "@staticmethod<EOL><INDENT>def metadata_updated_on(item):<DEDENT>", "body": "ts = item['<STR_LIT>']<EOL>ts = str_to_datetime(ts)<EOL>return ts.timestamp()<EOL>", "docstring": "Extracts the update time from a Bugzilla item.\n\n        The timestamp used is extracted from 'last_change_time' field.\n        This date is converted to UNIX timestamp format taking into\n        account the timezone of the date.\n\n        :param item: item generated by the backend\n\n        :returns: a UNIX timestamp", "id": "f13158:c0:m6"}
{"signature": "@classmethod<EOL><INDENT>def setup_cmd_parser(cls):<DEDENT>", "body": "parser = BackendCommandArgumentParser(cls.BACKEND.CATEGORIES,<EOL>from_date=True,<EOL>basic_auth=True,<EOL>token_auth=True,<EOL>archive=True)<EOL>group = parser.parser.add_argument_group('<STR_LIT>')<EOL>group.add_argument('<STR_LIT>', dest='<STR_LIT>',<EOL>type=int, default=MAX_BUGS,<EOL>help=\"<STR_LIT>\")<EOL>parser.parser.add_argument('<STR_LIT:url>',<EOL>help=\"<STR_LIT>\")<EOL>return parser<EOL>", "docstring": "Returns the BugzillaREST argument parser.", "id": "f13158:c3:m0"}
{"signature": "def __find_group_id(self):", "body": "group_subscriptions = self.subscriptions(self.auth)<EOL>for subscriptions in group_subscriptions:<EOL><INDENT>for sub in subscriptions:<EOL><INDENT>if sub['<STR_LIT>'] == self.group_name:<EOL><INDENT>return sub['<STR_LIT>']<EOL><DEDENT><DEDENT><DEDENT>msg = \"<STR_LIT>\" % self.group_name<EOL>raise BackendError(cause=msg)<EOL>", "docstring": "Find the id of a group given its name by iterating on the list of subscriptions", "id": "f13159:c1:m5"}
{"signature": "def fetch(self, category=CATEGORY_MESSAGE, from_date=DEFAULT_DATETIME):", "body": "items = super().fetch(category, from_date)<EOL>return items<EOL>", "docstring": "Fetch the messages from a Groups.io group.\n\n        The method fetches the mbox files from a remote Groups.io group\n        and retrieves the messages stored on them.\n\n        :param category: the category of items to fetch\n        :param from_date: obtain messages since this date\n\n        :returns: a generator of messages", "id": "f13159:c0:m1"}
{"signature": "def __fetch(self, url, payload):", "body": "r = requests.get(url, params=payload, auth=self.auth, verify=self.verify)<EOL>try:<EOL><INDENT>r.raise_for_status()<EOL><DEDENT>except requests.exceptions.HTTPError as e:<EOL><INDENT>raise e<EOL><DEDENT>return r<EOL>", "docstring": "Fetch requests from groupsio API", "id": "f13159:c1:m6"}
{"signature": "def issue_reactions(self, issue_number):", "body": "payload = {<EOL>'<STR_LIT>': PER_PAGE,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'<EOL>}<EOL>path = urijoin(\"<STR_LIT>\", str(issue_number), \"<STR_LIT>\")<EOL>return self.fetch_items(path, payload)<EOL>", "docstring": "Get reactions of an issue", "id": "f13160:c1:m2"}
{"signature": "def pulls(self, from_date=None):", "body": "issues_groups = self.issues(from_date=from_date)<EOL>for raw_issues in issues_groups:<EOL><INDENT>issues = json.loads(raw_issues)<EOL>for issue in issues:<EOL><INDENT>if \"<STR_LIT>\" not in issue:<EOL><INDENT>continue<EOL><DEDENT>pull_number = issue[\"<STR_LIT>\"]<EOL>path = urijoin(self.base_url, '<STR_LIT>', self.owner, self.repository, \"<STR_LIT>\", pull_number)<EOL>r = self.fetch(path)<EOL>pull = r.text<EOL>yield pull<EOL><DEDENT><DEDENT>", "docstring": "Fetch the pull requests from the repository.\n\n        The method retrieves, from a GitHub repository, the pull requests\n        updated since the given date.\n\n        :param from_date: obtain pull requests updated since this date\n\n        :returns: a generator of pull requests", "id": "f13160:c1:m6"}
{"signature": "def issue_comment_reactions(self, comment_id):", "body": "payload = {<EOL>'<STR_LIT>': PER_PAGE,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'<EOL>}<EOL>path = urijoin(\"<STR_LIT>\", \"<STR_LIT>\", str(comment_id), \"<STR_LIT>\")<EOL>return self.fetch_items(path, payload)<EOL>", "docstring": "Get reactions of an issue comment", "id": "f13160:c1:m3"}
{"signature": "@classmethod<EOL><INDENT>def setup_cmd_parser(cls):<DEDENT>", "body": "parser = BackendCommandArgumentParser(cls.BACKEND.CATEGORIES,<EOL>from_date=True,<EOL>to_date=True,<EOL>token_auth=False,<EOL>archive=True)<EOL>group = parser.parser.add_argument_group('<STR_LIT>')<EOL>group.add_argument('<STR_LIT>', dest='<STR_LIT>',<EOL>help=\"<STR_LIT>\")<EOL>group.add_argument('<STR_LIT>', dest='<STR_LIT>',<EOL>action='<STR_LIT:store_true>',<EOL>help=\"<STR_LIT>\")<EOL>group.add_argument('<STR_LIT>', dest='<STR_LIT>',<EOL>default=MIN_RATE_LIMIT, type=int,<EOL>help=\"<STR_LIT>\")<EOL>group.add_argument('<STR_LIT>', '<STR_LIT>', dest='<STR_LIT>',<EOL>nargs='<STR_LIT:+>',<EOL>default=[],<EOL>help=\"<STR_LIT>\")<EOL>group.add_argument('<STR_LIT>', dest='<STR_LIT>',<EOL>default=MAX_RETRIES, type=int,<EOL>help=\"<STR_LIT>\")<EOL>group.add_argument('<STR_LIT>', dest='<STR_LIT>',<EOL>default=DEFAULT_SLEEP_TIME, type=int,<EOL>help=\"<STR_LIT>\")<EOL>parser.parser.add_argument('<STR_LIT>',<EOL>help=\"<STR_LIT>\")<EOL>parser.parser.add_argument('<STR_LIT>',<EOL>help=\"<STR_LIT>\")<EOL>return parser<EOL>", "docstring": "Returns the GitHub argument parser.", "id": "f13160:c2:m0"}
{"signature": "def __fetch_repo_info(self):", "body": "raw_repo = self.client.repo()<EOL>repo = json.loads(raw_repo)<EOL>fetched_on = datetime_utcnow()<EOL>repo['<STR_LIT>'] = fetched_on.timestamp()<EOL>yield repo<EOL>", "docstring": "Get repo info about stars, watchers and forks", "id": "f13160:c0:m11"}
{"signature": "def __get_issue_assignee(self, raw_assignee):", "body": "assignee = self.__get_user(raw_assignee['<STR_LIT>'])<EOL>return assignee<EOL>", "docstring": "Get issue assignee", "id": "f13160:c0:m15"}
{"signature": "@classmethod<EOL><INDENT>def has_resuming(cls):<DEDENT>", "body": "return True<EOL>", "docstring": "Returns whether it supports to resume the fetch process.\n\n        :returns: this backend supports items resuming", "id": "f13160:c0:m4"}
{"signature": "def _need_check_tokens(self):", "body": "if self.n_tokens <= <NUM_LIT:1> or self.rate_limit is None:<EOL><INDENT>return False<EOL><DEDENT>elif self.last_rate_limit_checked is None:<EOL><INDENT>self.last_rate_limit_checked = self.rate_limit<EOL>return True<EOL><DEDENT>approaching_limit = float(self.min_rate_to_sleep) * (<NUM_LIT:1.0> + TOKEN_USAGE_BEFORE_SWITCH) + <NUM_LIT:1><EOL>if self.rate_limit <= approaching_limit:<EOL><INDENT>self.last_rate_limit_checked = self.rate_limit<EOL>return True<EOL><DEDENT>ratio = float(self.rate_limit) / float(self.last_rate_limit_checked)<EOL>if ratio < <NUM_LIT:1.0> - TOKEN_USAGE_BEFORE_SWITCH:<EOL><INDENT>self.last_rate_limit_checked = self.rate_limit<EOL>return True<EOL><DEDENT>elif ratio > <NUM_LIT:1.0>:<EOL><INDENT>self.last_rate_limit_checked = self.rate_limit<EOL>return False<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Check if we need to switch GitHub API tokens", "id": "f13160:c1:m19"}
{"signature": "def _get_token_rate_limit(self, token):", "body": "rate_url = urijoin(self.base_url, \"<STR_LIT>\")<EOL>self.session.headers.update({'<STR_LIT>': '<STR_LIT>' + token})<EOL>remaining = <NUM_LIT:0><EOL>try:<EOL><INDENT>headers = super().fetch(rate_url).headers<EOL>if self.rate_limit_header in headers:<EOL><INDENT>remaining = int(headers[self.rate_limit_header])<EOL><DEDENT><DEDENT>except requests.exceptions.HTTPError as error:<EOL><INDENT>logger.warning(\"<STR_LIT>\", error)<EOL><DEDENT>return remaining<EOL>", "docstring": "Return token's remaining API points", "id": "f13160:c1:m16"}
{"signature": "def __fetch_issues(self, from_date, to_date):", "body": "issues_groups = self.client.issues(from_date=from_date)<EOL>for raw_issues in issues_groups:<EOL><INDENT>issues = json.loads(raw_issues)<EOL>for issue in issues:<EOL><INDENT>if str_to_datetime(issue['<STR_LIT>']) > to_date:<EOL><INDENT>return<EOL><DEDENT>self.__init_extra_issue_fields(issue)<EOL>for field in TARGET_ISSUE_FIELDS:<EOL><INDENT>if not issue[field]:<EOL><INDENT>continue<EOL><DEDENT>if field == '<STR_LIT:user>':<EOL><INDENT>issue[field + '<STR_LIT>'] = self.__get_user(issue[field]['<STR_LIT>'])<EOL><DEDENT>elif field == '<STR_LIT>':<EOL><INDENT>issue[field + '<STR_LIT>'] = self.__get_issue_assignee(issue[field])<EOL><DEDENT>elif field == '<STR_LIT>':<EOL><INDENT>issue[field + '<STR_LIT>'] = self.__get_issue_assignees(issue[field])<EOL><DEDENT>elif field == '<STR_LIT>':<EOL><INDENT>issue[field + '<STR_LIT>'] = self.__get_issue_comments(issue['<STR_LIT>'])<EOL><DEDENT>elif field == '<STR_LIT>':<EOL><INDENT>issue[field + '<STR_LIT>'] =self.__get_issue_reactions(issue['<STR_LIT>'], issue['<STR_LIT>']['<STR_LIT>'])<EOL><DEDENT><DEDENT>yield issue<EOL><DEDENT><DEDENT>", "docstring": "Fetch the issues", "id": "f13160:c0:m9"}
{"signature": "def _init_client(self, from_archive=False):", "body": "return GitHubClient(self.owner, self.repository, self.api_token, self.base_url,<EOL>self.sleep_for_rate, self.min_rate_to_sleep,<EOL>self.sleep_time, self.max_retries,<EOL>self.archive, from_archive)<EOL>", "docstring": "Init client", "id": "f13160:c0:m8"}
{"signature": "def __fetch_pull_requests(self, from_date, to_date):", "body": "raw_pulls = self.client.pulls(from_date=from_date)<EOL>for raw_pull in raw_pulls:<EOL><INDENT>pull = json.loads(raw_pull)<EOL>if str_to_datetime(pull['<STR_LIT>']) > to_date:<EOL><INDENT>return<EOL><DEDENT>self.__init_extra_pull_fields(pull)<EOL>for field in TARGET_PULL_FIELDS:<EOL><INDENT>if not pull[field]:<EOL><INDENT>continue<EOL><DEDENT>if field == '<STR_LIT:user>':<EOL><INDENT>pull[field + '<STR_LIT>'] = self.__get_user(pull[field]['<STR_LIT>'])<EOL><DEDENT>elif field == '<STR_LIT>':<EOL><INDENT>pull[field + '<STR_LIT>'] = self.__get_user(pull[field]['<STR_LIT>'])<EOL><DEDENT>elif field == '<STR_LIT>':<EOL><INDENT>pull[field + '<STR_LIT>'] = self.__get_pull_review_comments(pull['<STR_LIT>'])<EOL><DEDENT>elif field == '<STR_LIT>':<EOL><INDENT>pull[field + '<STR_LIT>'] = self.__get_pull_requested_reviewers(pull['<STR_LIT>'])<EOL><DEDENT>elif field == '<STR_LIT>':<EOL><INDENT>pull[field + '<STR_LIT>'] = self.__get_pull_commits(pull['<STR_LIT>'])<EOL><DEDENT><DEDENT>yield pull<EOL><DEDENT>", "docstring": "Fetch the pull requests", "id": "f13160:c0:m10"}
{"signature": "@property<EOL><INDENT>def mboxes(self):<DEDENT>", "body": "archives = []<EOL>for mbox in super().mboxes:<EOL><INDENT>dt = self._parse_date_from_filepath(mbox.filepath)<EOL>archives.append((dt, mbox))<EOL><DEDENT>archives.sort(key=lambda x: x[<NUM_LIT:0>])<EOL>return [a[<NUM_LIT:1>] for a in archives]<EOL>", "docstring": "Get the mboxes managed by this mailing list.\n\n        Returns the archives sorted by date in ascending order.\n\n        :returns: a list of `.MBoxArchive` objects", "id": "f13161:c1:m2"}
{"signature": "def fetch(self, category=CATEGORY_MESSAGE, from_date=DEFAULT_DATETIME):", "body": "items = super().fetch(category, from_date)<EOL>return items<EOL>", "docstring": "Fetch the messages from the HyperKitty mailing list archiver.\n\n        The method fetches the mbox files from a remote HyperKitty\n        mailing list archiver and retrieves the messages stored on them.\n\n        Take into account that HyperKitty does not provide yet any kind\n        of info to know which is the first message on the mailing list.\n        For this reason, using a value in `from_date` previous to the\n        date where the first message was sent will make to download\n        empty mbox files.\n\n        :param category: the category of items to fetch\n        :param from_date: obtain messages since this date\n\n        :returns: a generator of messages", "id": "f13161:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def setup_cmd_parser(cls):<DEDENT>", "body": "parser = BackendCommandArgumentParser(cls.BACKEND.CATEGORIES,<EOL>from_date=True)<EOL>group = parser.parser.add_argument_group('<STR_LIT>')<EOL>group.add_argument('<STR_LIT>', dest='<STR_LIT>',<EOL>help=\"<STR_LIT>\")<EOL>parser.parser.add_argument('<STR_LIT:url>',<EOL>help=\"<STR_LIT>\")<EOL>return parser<EOL>", "docstring": "Returns the HyperKitty argument parser.", "id": "f13161:c2:m1"}
{"signature": "def _pre_init(self):", "body": "if not self.parsed_args.mboxes_path:<EOL><INDENT>base_path = os.path.expanduser('<STR_LIT>')<EOL>dirpath = os.path.join(base_path, self.parsed_args.url)<EOL><DEDENT>else:<EOL><INDENT>dirpath = self.parsed_args.mboxes_path<EOL><DEDENT>setattr(self.parsed_args, '<STR_LIT>', dirpath)<EOL>", "docstring": "Initialize mailing lists directory path", "id": "f13161:c2:m0"}
{"signature": "@classmethod<EOL><INDENT>def has_archiving(cls):<DEDENT>", "body": "return True<EOL>", "docstring": "Returns whether it supports archiving items on the fetch process.\n\n        :returns: this backend supports items archive", "id": "f13162:c0:m3"}
{"signature": "@staticmethod<EOL><INDENT>def metadata_id(item):<DEDENT>", "body": "return str(item['<STR_LIT>'])<EOL>", "docstring": "Extracts the identifier from a Twitter item.", "id": "f13162:c0:m5"}
{"signature": "@classmethod<EOL><INDENT>def setup_cmd_parser(cls):<DEDENT>", "body": "parser = BackendCommandArgumentParser(cls.BACKEND.CATEGORIES,<EOL>token_auth=True,<EOL>archive=True)<EOL>action = parser.parser._option_string_actions['<STR_LIT>']<EOL>action.required = True<EOL>group = parser.parser.add_argument_group('<STR_LIT>')<EOL>group.add_argument('<STR_LIT>', dest='<STR_LIT>',<EOL>type=int, default=MAX_ITEMS,<EOL>help=\"<STR_LIT>\")<EOL>group.add_argument('<STR_LIT>', dest='<STR_LIT>',<EOL>action='<STR_LIT>',<EOL>help=\"<STR_LIT>\")<EOL>group.add_argument('<STR_LIT>', dest='<STR_LIT>',<EOL>help=\"<STR_LIT>\")<EOL>group.add_argument('<STR_LIT>', dest='<STR_LIT>',<EOL>help=\"<STR_LIT>\")<EOL>group.add_argument('<STR_LIT>', dest='<STR_LIT>', default=TWEET_TYPE_MIXED,<EOL>help=\"<STR_LIT>\")<EOL>group.add_argument('<STR_LIT>', dest='<STR_LIT>',<EOL>action='<STR_LIT:store_true>',<EOL>help=\"<STR_LIT>\")<EOL>group.add_argument('<STR_LIT>', dest='<STR_LIT>',<EOL>default=MIN_RATE_LIMIT, type=int,<EOL>help=\"<STR_LIT>\")<EOL>group.add_argument('<STR_LIT>', dest='<STR_LIT>',<EOL>default=SLEEP_TIME, type=int,<EOL>help=\"<STR_LIT>\")<EOL>parser.parser.add_argument('<STR_LIT>',<EOL>help=\"<STR_LIT>\")<EOL>return parser<EOL>", "docstring": "Returns the Twitter argument parser.", "id": "f13162:c2:m0"}
{"signature": "def fetch_items(self, category, **kwargs):", "body": "since_id = kwargs['<STR_LIT>']<EOL>max_id = kwargs['<STR_LIT>']<EOL>geocode = kwargs['<STR_LIT>']<EOL>lang = kwargs['<STR_LIT>']<EOL>entities = kwargs['<STR_LIT>']<EOL>tweets_type = kwargs['<STR_LIT>']<EOL>logger.info(\"<STR_LIT>\",<EOL>self.query, str(since_id),<EOL>str(max_id) if max_id else '<STR_LIT>')<EOL>tweets_ids = []<EOL>min_date = None<EOL>max_date = None<EOL>group_tweets = self.client.tweets(self.query, since_id=since_id, max_id=max_id, geocode=geocode,<EOL>lang=lang, include_entities=entities, result_type=tweets_type)<EOL>for tweets in group_tweets:<EOL><INDENT>for i in range(len(tweets)):<EOL><INDENT>tweet = tweets[i]<EOL>tweets_ids.append(tweet['<STR_LIT:id>'])<EOL>if tweets[-<NUM_LIT:1>] == tweet:<EOL><INDENT>min_date = str_to_datetime(tweets[-<NUM_LIT:1>]['<STR_LIT>'])<EOL><DEDENT>if tweets[<NUM_LIT:0>] == tweet and not max_date:<EOL><INDENT>max_date = str_to_datetime(tweets[<NUM_LIT:0>]['<STR_LIT>'])<EOL><DEDENT>yield tweet<EOL><DEDENT><DEDENT>logger.info(\"<STR_LIT>\",<EOL>len(tweets_ids), len(list(set(tweets_ids))), min_date, max_date)<EOL>", "docstring": "Fetch the tweets\n\n        :param category: the category of items to fetch\n        :param kwargs: backend arguments\n\n        :returns: a generator of items", "id": "f13162:c0:m2"}
{"signature": "@staticmethod<EOL><INDENT>def metadata_category(item):<DEDENT>", "body": "return CATEGORY_TWEET<EOL>", "docstring": "Extracts the category from a Twitter item.\n\n        This backend only generates one type of item which is\n        'tweet'.", "id": "f13162:c0:m7"}
{"signature": "def _init_client(self, from_archive=False):", "body": "return MeetupClient(self.api_token, self.max_items,<EOL>self.sleep_for_rate, self.min_rate_to_sleep, self.sleep_time,<EOL>self.archive, from_archive)<EOL>", "docstring": "Init client", "id": "f13163:c0:m9"}
{"signature": "@staticmethod<EOL><INDENT>def metadata_id(item):<DEDENT>", "body": "return str(item['<STR_LIT:id>'])<EOL>", "docstring": "Extracts the identifier from a Meetup item.", "id": "f13163:c0:m5"}
{"signature": "@staticmethod<EOL><INDENT>def sanitize_for_archive(url, headers, payload):<DEDENT>", "body": "if MeetupClient.PKEY in payload:<EOL><INDENT>payload.pop(MeetupClient.PKEY)<EOL><DEDENT>if MeetupClient.PSIGN in payload:<EOL><INDENT>payload.pop(MeetupClient.PSIGN)<EOL><DEDENT>return url, headers, payload<EOL>", "docstring": "Sanitize payload of a HTTP request by removing the token information\n        before storing/retrieving archived items\n\n        :param: url: HTTP url request\n        :param: headers: HTTP headers request\n        :param: payload: HTTP payload request\n\n        :returns url, headers and the sanitized payload", "id": "f13163:c2:m5"}
{"signature": "@classmethod<EOL><INDENT>def has_archiving(cls):<DEDENT>", "body": "return True<EOL>", "docstring": "Returns whether it supports archiving items on the fetch process.\n\n        :returns: this backend supports items archive", "id": "f13164:c0:m3"}
{"signature": "def post(self, post_id):", "body": "params = {<EOL>self.PKEY: self.api_key<EOL>}<EOL>response = self._call(self.POSTS, post_id,<EOL>params=params)<EOL>return response<EOL>", "docstring": "Retrieve the post whit `post_id` identifier.\n\n        :param post_id: identifier of the post to retrieve", "id": "f13164:c1:m3"}
{"signature": "def _call(self, resource, params):", "body": "url = self.URL % {'<STR_LIT>': self.base_url, '<STR_LIT>': resource}<EOL>logger.debug(\"<STR_LIT>\",<EOL>resource, str(params))<EOL>while True:<EOL><INDENT>r = self.fetch(url, payload=params)<EOL>yield r.text<EOL>j = r.json()<EOL>if '<STR_LIT>' not in j:<EOL><INDENT>break<EOL><DEDENT>if '<STR_LIT>' not in j['<STR_LIT>']:<EOL><INDENT>break<EOL><DEDENT>url = urijoin(self.base_url, j['<STR_LIT>']['<STR_LIT>'])<EOL>params = {}<EOL><DEDENT>", "docstring": "Retrive the given resource.\n\n        :param resource: resource to retrieve\n        :param params: dict with the HTTP parameters needed to retrieve\n            the given resource", "id": "f13165:c2:m3"}
{"signature": "@staticmethod<EOL><INDENT>def parse_contents_summary(raw_json):<DEDENT>", "body": "summary = json.loads(raw_json)<EOL>contents = summary['<STR_LIT>']<EOL>for c in contents:<EOL><INDENT>yield c<EOL><DEDENT>", "docstring": "Parse a Confluence summary JSON list.\n\n        The method parses a JSON stream and returns an iterator\n        of diccionaries. Each dictionary is a content summary.\n\n        :param raw_json: JSON string to parse\n\n        :returns: a generator of parsed content summaries.", "id": "f13165:c0:m8"}
{"signature": "def _init_client(self, from_archive=False):", "body": "return ConfluenceClient(self.url, archive=self.archive, from_archive=from_archive)<EOL>", "docstring": "Init client", "id": "f13165:c0:m10"}
{"signature": "@staticmethod<EOL><INDENT>def parse_historical_content(raw_json):<DEDENT>", "body": "hc = json.loads(raw_json)<EOL>return hc<EOL>", "docstring": "Parse a Confluence historical content JSON stream.\n\n        This method parses a JSON stream and returns a dictionary\n        that contains the data of a historical content.\n\n        :param raw_json: JSON string to parse\n\n        :returns: a dict with historical content", "id": "f13165:c0:m9"}
{"signature": "def historical_content(self, content_id, version):", "body": "resource = self.RCONTENTS + '<STR_LIT:/>' + str(content_id)<EOL>params = {<EOL>self.PVERSION: version,<EOL>self.PSTATUS: self.VHISTORICAL,<EOL>self.PEXPAND: '<STR_LIT:U+002C>'.join(self.VEXPAND)<EOL>}<EOL>response = [response for response in self._call(resource, params)]<EOL>return response[<NUM_LIT:0>]<EOL>", "docstring": "Get the snapshot of a content for the given version.\n\n        :param content_id: fetch the snapshot of this content\n        :param version: snapshot version of the content", "id": "f13165:c2:m2"}
{"signature": "@staticmethod<EOL><INDENT>def metadata_category(item):<DEDENT>", "body": "return CATEGORY_ARTICLE<EOL>", "docstring": "Extracts the category from a NNTP item.\n\n        This backend only generates one type of item which is\n        'article'.", "id": "f13166:c0:m8"}
{"signature": "def _init_client(self, from_archive=False):", "body": "return NNTTPClient(self.host, self.archive, from_archive)<EOL>", "docstring": "Init client", "id": "f13166:c0:m10"}
{"signature": "@classmethod<EOL><INDENT>def setup_cmd_parser(cls):<DEDENT>", "body": "parser = BackendCommandArgumentParser(cls.BACKEND.CATEGORIES,<EOL>offset=True,<EOL>archive=True)<EOL>parser.parser.add_argument('<STR_LIT:host>',<EOL>help=\"<STR_LIT>\")<EOL>parser.parser.add_argument('<STR_LIT>',<EOL>help=\"<STR_LIT>\")<EOL>return parser<EOL>", "docstring": "Returns the NNTP argument parser.", "id": "f13166:c2:m0"}
{"signature": "@classmethod<EOL><INDENT>def has_resuming(cls):<DEDENT>", "body": "return True<EOL>", "docstring": "Returns whether it supports to resume the fetch process.\n\n        :returns: this backend supports items resuming", "id": "f13166:c0:m5"}
{"signature": "@staticmethod<EOL><INDENT>def parse_phids(results):<DEDENT>", "body": "for phid in results['<STR_LIT:result>'].values():<EOL><INDENT>yield phid<EOL><DEDENT>", "docstring": "Parse a Phabicator PHIDs JSON stream.\n\n        This method parses a JSON stream and returns a list iterator.\n        Each item is a dictionary that contains the PHID parsed data.\n\n        :param results: JSON to parse\n\n        :returns: a generator of parsed PHIDs", "id": "f13168:c0:m11"}
{"signature": "def tasks(self, from_date=DEFAULT_DATETIME):", "body": "<EOL>ts = int(datetime_to_utc(from_date).timestamp()) or <NUM_LIT:1><EOL>consts = {<EOL>self.PMODIFIED_START: ts<EOL>}<EOL>attachments = {<EOL>self. PPROJECTS: True<EOL>}<EOL>params = {<EOL>self.PCONSTRAINTS: consts,<EOL>self.PATTACHMENTS: attachments,<EOL>self.PORDER: self.VOUTDATED,<EOL>}<EOL>while True:<EOL><INDENT>r = self._call(self.MANIPHEST_TASKS, params)<EOL>yield r<EOL>j = json.loads(r)<EOL>after = j['<STR_LIT:result>']['<STR_LIT>']['<STR_LIT>']<EOL>if not after:<EOL><INDENT>break<EOL><DEDENT>params[self.PAFTER] = after<EOL><DEDENT>", "docstring": "Retrieve tasks.\n\n        :param from_date: retrieve tasks that where updated from that date;\n            dates are converted epoch time.", "id": "f13168:c2:m1"}
{"signature": "def fetch_items(self, category, **kwargs):", "body": "from_date = kwargs['<STR_LIT>']<EOL>logger.info(\"<STR_LIT>\", self.url, str(from_date))<EOL>ntasks = <NUM_LIT:0><EOL>for task in self.__fetch_tasks(from_date):<EOL><INDENT>yield task<EOL>ntasks += <NUM_LIT:1><EOL><DEDENT>logger.info(\"<STR_LIT>\", ntasks)<EOL>", "docstring": "Fetch the tasks\n\n        :param category: the category of items to fetch\n        :param kwargs: backend arguments\n\n        :returns: a generator of items", "id": "f13168:c0:m2"}
{"signature": "def _call(self, method, params):", "body": "url = self.URL % {'<STR_LIT>': self.base_url, '<STR_LIT>': method}<EOL>params['<STR_LIT>'] = {'<STR_LIT>': self.api_token}<EOL>data = {<EOL>'<STR_LIT>': json.dumps(params, sort_keys=True),<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': True<EOL>}<EOL>logger.debug(\"<STR_LIT>\",<EOL>method, str(data))<EOL>r = self.fetch(url, payload=data, method=HttpClient.POST, verify=False)<EOL>result = r.json()<EOL>if result['<STR_LIT>']:<EOL><INDENT>raise ConduitError(error=result['<STR_LIT>'],<EOL>code=result['<STR_LIT>'])<EOL><DEDENT>return r.text<EOL>", "docstring": "Call a method.\n\n        :param method: method to call\n        :param params: dict with the HTTP parameters needed to call\n            the given method\n\n        :raises ConduitError: when an error is returned by the server", "id": "f13168:c2:m6"}
{"signature": "@staticmethod<EOL><INDENT>def metadata_id(item):<DEDENT>", "body": "return str(item['<STR_LIT:id>'])<EOL>", "docstring": "Extracts the identifier from a Phabricator item.", "id": "f13168:c0:m5"}
{"signature": "@classmethod<EOL><INDENT>def setup_cmd_parser(cls):<DEDENT>", "body": "parser = BackendCommandArgumentParser(cls.BACKEND.CATEGORIES,<EOL>from_date=True,<EOL>token_auth=True,<EOL>archive=True)<EOL>group = parser.parser.add_argument_group('<STR_LIT>')<EOL>group.add_argument('<STR_LIT>', dest='<STR_LIT>',<EOL>default=MAX_RETRIES, type=int,<EOL>help=\"<STR_LIT>\")<EOL>group.add_argument('<STR_LIT>', dest='<STR_LIT>',<EOL>default=DEFAULT_SLEEP_TIME, type=int,<EOL>help=\"<STR_LIT>\")<EOL>parser.parser.add_argument('<STR_LIT:url>',<EOL>help=\"<STR_LIT>\")<EOL>return parser<EOL>", "docstring": "Returns the Phabricator argument parser.", "id": "f13168:c3:m0"}
{"signature": "@staticmethod<EOL><INDENT>def metadata_category(item):<DEDENT>", "body": "return CATEGORY_MESSAGE<EOL>", "docstring": "Extracts the category from a MBox item.\n\n        This backend only generates one type of item which is\n        'message'.", "id": "f13169:c0:m7"}
{"signature": "def _fetch_and_parse_messages(self, mailing_list, from_date):", "body": "from_date = datetime_to_utc(from_date)<EOL>nmsgs, imsgs, tmsgs = (<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>)<EOL>for mbox in mailing_list.mboxes:<EOL><INDENT>tmp_path = None<EOL>try:<EOL><INDENT>tmp_path = self._copy_mbox(mbox)<EOL>for message in self.parse_mbox(tmp_path):<EOL><INDENT>tmsgs += <NUM_LIT:1><EOL>if not self._validate_message(message):<EOL><INDENT>imsgs += <NUM_LIT:1><EOL>continue<EOL><DEDENT>dt = str_to_datetime(message[MBox.DATE_FIELD])<EOL>if dt < from_date:<EOL><INDENT>logger.debug(\"<STR_LIT>\",<EOL>message['<STR_LIT>'], str(from_date))<EOL>tmsgs -= <NUM_LIT:1><EOL>continue<EOL><DEDENT>message = self._casedict_to_dict(message)<EOL>nmsgs += <NUM_LIT:1><EOL>logger.debug(\"<STR_LIT>\", message['<STR_LIT>'])<EOL>yield message<EOL><DEDENT><DEDENT>except (OSError, EOFError) as e:<EOL><INDENT>logger.warning(\"<STR_LIT>\", mbox.filepath, str(e))<EOL><DEDENT>except Exception as e:<EOL><INDENT>if tmp_path and os.path.exists(tmp_path):<EOL><INDENT>os.remove(tmp_path)<EOL><DEDENT>raise e<EOL><DEDENT>finally:<EOL><INDENT>if tmp_path and os.path.exists(tmp_path):<EOL><INDENT>os.remove(tmp_path)<EOL><DEDENT><DEDENT><DEDENT>logger.info(\"<STR_LIT>\",<EOL>nmsgs, tmsgs, imsgs)<EOL>", "docstring": "Fetch and parse the messages from a mailing list", "id": "f13169:c0:m10"}
{"signature": "@classmethod<EOL><INDENT>def has_resuming(cls):<DEDENT>", "body": "return True<EOL>", "docstring": "Returns whether it supports to resume the fetch process.\n\n        :returns: this backend supports items resuming", "id": "f13169:c0:m4"}
{"signature": "@property<EOL><INDENT>def mboxes(self):<DEDENT>", "body": "archives = []<EOL>if os.path.isfile(self.dirpath):<EOL><INDENT>try:<EOL><INDENT>archives.append(MBoxArchive(self.dirpath))<EOL><DEDENT>except OSError as e:<EOL><INDENT>logger.warning(\"<STR_LIT>\", self.dirpath, str(e))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for root, _, files in os.walk(self.dirpath):<EOL><INDENT>for filename in sorted(files):<EOL><INDENT>try:<EOL><INDENT>location = os.path.join(root, filename)<EOL>archives.append(MBoxArchive(location))<EOL><DEDENT>except OSError as e:<EOL><INDENT>logger.warning(\"<STR_LIT>\", filename, str(e))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return archives<EOL>", "docstring": "Get the mboxes managed by this mailing list.\n\n        Returns the archives sorted by name.\n\n        :returns: a list of `.MBoxArchive` objects", "id": "f13169:c4:m1"}
{"signature": "@classmethod<EOL><INDENT>def has_archiving(cls):<DEDENT>", "body": "return False<EOL>", "docstring": "Returns whether it supports archiving items on the fetch process.\n\n        :returns: this backend does not support items archive", "id": "f13169:c0:m3"}
{"signature": "@classmethod<EOL><INDENT>def setup_cmd_parser(cls):<DEDENT>", "body": "parser = BackendCommandArgumentParser(cls.BACKEND.CATEGORIES,<EOL>from_date=True)<EOL>parser.parser.add_argument('<STR_LIT>',<EOL>help=\"<STR_LIT>\")<EOL>parser.parser.add_argument('<STR_LIT>',<EOL>help=\"<STR_LIT>\")<EOL>return parser<EOL>", "docstring": "Returns the MBox argument parser.", "id": "f13169:c2:m0"}
{"signature": "@staticmethod<EOL><INDENT>def sanitize_for_archive(cmd):<DEDENT>", "body": "sanitized_cmd = re.sub(r\"<STR_LIT>\", '<STR_LIT>', cmd)<EOL>return sanitized_cmd<EOL>", "docstring": "Sanitize the Gerrit command by removing username information\n        before storing/retrieving archived items\n\n        :param: cmd: Gerrit command\n\n        :returns the sanitized cmd", "id": "f13170:c1:m4"}
{"signature": "@classmethod<EOL><INDENT>def setup_cmd_parser(cls):<DEDENT>", "body": "parser = BackendCommandArgumentParser(cls.BACKEND.CATEGORIES,<EOL>from_date=True,<EOL>archive=True)<EOL>group = parser.parser.add_argument_group('<STR_LIT>')<EOL>group.add_argument('<STR_LIT>', dest='<STR_LIT:user>',<EOL>help=\"<STR_LIT>\")<EOL>group.add_argument('<STR_LIT>', dest='<STR_LIT>',<EOL>type=int, default=MAX_REVIEWS,<EOL>help=\"<STR_LIT>\")<EOL>group.add_argument('<STR_LIT>', dest='<STR_LIT>',<EOL>nargs='<STR_LIT:*>',<EOL>help=\"<STR_LIT>\")<EOL>group.add_argument('<STR_LIT>', dest='<STR_LIT>', action='<STR_LIT:store_true>',<EOL>help=\"<STR_LIT>\")<EOL>group.add_argument('<STR_LIT>', dest='<STR_LIT:port>',<EOL>default=PORT, type=int,<EOL>help=\"<STR_LIT>\")<EOL>parser.parser.add_argument('<STR_LIT>',<EOL>help=\"<STR_LIT>\")<EOL>return parser<EOL>", "docstring": "Returns the Gerrit argument parser.", "id": "f13170:c2:m0"}
{"signature": "@staticmethod<EOL><INDENT>def metadata_updated_on(item):<DEDENT>", "body": "return float(item['<STR_LIT>'])<EOL>", "docstring": "Extracts and converts the update time from a Gerrit item.\n\n        The timestamp is extracted from 'lastUpdated' field. This date is\n        a UNIX timestamp but needs to be converted to a float value.\n\n        :param item: item generated by the backend\n\n        :returns: a UNIX timestamp", "id": "f13170:c0:m6"}
{"signature": "@classmethod<EOL><INDENT>def has_archiving(cls):<DEDENT>", "body": "return True<EOL>", "docstring": "Returns whether it supports archiving items on the fetch process.\n\n        :returns: this backend supports items archive", "id": "f13170:c0:m3"}
{"signature": "@staticmethod<EOL><INDENT>def metadata_category(item):<DEDENT>", "body": "return CATEGORY_REVIEW<EOL>", "docstring": "Extracts the category from a Gerrit item.\n\n        This backend only generates one type of item which is\n        'review'.", "id": "f13170:c0:m7"}
{"signature": "@staticmethod<EOL><INDENT>def parse_reviews(raw_data):<DEDENT>", "body": "<EOL>items_raw = \"<STR_LIT:[>\" + raw_data.replace(\"<STR_LIT:\\n>\", \"<STR_LIT:U+002C>\") + \"<STR_LIT:]>\"<EOL>items_raw = items_raw.replace(\"<STR_LIT>\", \"<STR_LIT:]>\")<EOL>items = json.loads(items_raw)<EOL>reviews = []<EOL>for item in items:<EOL><INDENT>if '<STR_LIT>' in item.keys():<EOL><INDENT>reviews.append(item)<EOL><DEDENT><DEDENT>return reviews<EOL>", "docstring": "Parse a Gerrit reviews list.", "id": "f13170:c0:m8"}
{"signature": "@staticmethod<EOL><INDENT>def parse_questions(raw_page):<DEDENT>", "body": "raw_questions = json.loads(raw_page)<EOL>questions = raw_questions['<STR_LIT>']<EOL>for question in questions:<EOL><INDENT>yield question<EOL><DEDENT>", "docstring": "Parse a StackExchange API raw response.\n\n        The method parses the API response retrieving the\n        questions from the received items\n\n        :param items: items from where to parse the questions\n\n        :returns: a generator of questions", "id": "f13171:c0:m8"}
{"signature": "@staticmethod<EOL><INDENT>def metadata_updated_on(item):<DEDENT>", "body": "return float(item['<STR_LIT>'])<EOL>", "docstring": "Extracts the update time from a StackExchange item.\n\n        The timestamp is extracted from 'last_activity_date' field.\n        This date is a UNIX timestamp but needs to be converted to\n        a float value.\n\n        :param item: item generated by the backend\n\n        :returns: a UNIX timestamp", "id": "f13171:c0:m6"}
{"signature": "@staticmethod<EOL><INDENT>def metadata_updated_on(item):<DEDENT>", "body": "ts = str_to_datetime(item['<STR_LIT>'])<EOL>return ts.timestamp()<EOL>", "docstring": "Extracts the update time from a RSS item.\n\n        The timestamp is extracted from 'published' field.\n        This date is a datetime string that needs to be converted to\n        a UNIX timestamp float value.\n\n        :param item: item generated by the backend\n\n        :returns: a UNIX timestamp", "id": "f13172:c0:m7"}
{"signature": "def fetch_items(self, category, **kwargs):", "body": "logger.info(\"<STR_LIT>\", self.url)<EOL>nentries = <NUM_LIT:0>  <EOL>raw_entries = self.client.get_entries()<EOL>entries = self.parse_feed(raw_entries)['<STR_LIT>']<EOL>for item in entries:<EOL><INDENT>yield item<EOL>nentries += <NUM_LIT:1><EOL><DEDENT>logger.info(\"<STR_LIT>\", nentries)<EOL>", "docstring": "Fetch the entries\n\n        :param category: the category of items to fetch\n        :param kwargs: backend arguments\n\n        :returns: a generator of items", "id": "f13172:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def has_resuming(cls):<DEDENT>", "body": "return False<EOL>", "docstring": "Returns whether it supports to resume the fetch process.\n\n        :returns: this backend does not supports entries resuming", "id": "f13172:c0:m5"}
{"signature": "def get_namespaces(self):", "body": "params = {<EOL>\"<STR_LIT:action>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>}<EOL>return self.call(params)<EOL>", "docstring": "Retrieve all contents namespaces.", "id": "f13173:c1:m2"}
{"signature": "def fetch_items(self, category, **kwargs):", "body": "from_date = kwargs['<STR_LIT>']<EOL>reviews_api = kwargs['<STR_LIT>']<EOL>mediawiki_version = self.client.get_version()<EOL>logger.info(\"<STR_LIT>\", mediawiki_version)<EOL>if reviews_api:<EOL><INDENT>if ((mediawiki_version[<NUM_LIT:0>] == <NUM_LIT:1> and mediawiki_version[<NUM_LIT:1>] >= <NUM_LIT>) or mediawiki_version[<NUM_LIT:0>] > <NUM_LIT:1>):<EOL><INDENT>fetcher = self.__fetch_1_27(from_date)<EOL><DEDENT>else:<EOL><INDENT>logger.warning(\"<STR_LIT>\")<EOL>logger.warning(\"<STR_LIT>\")<EOL>fetcher = self.__fetch_pre1_27(from_date)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>fetcher = self.__fetch_pre1_27(from_date)<EOL><DEDENT>for page_reviews in fetcher:<EOL><INDENT>yield page_reviews<EOL><DEDENT>", "docstring": "Fetch the pages\n\n        :param category: the category of items to fetch\n        :param kwargs: backend arguments\n\n        :returns: a generator of items", "id": "f13173:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def setup_cmd_parser(cls):<DEDENT>", "body": "parser = BackendCommandArgumentParser(cls.BACKEND.CATEGORIES,<EOL>from_date=True,<EOL>archive=True)<EOL>group = parser.parser.add_argument_group('<STR_LIT>')<EOL>group.add_argument('<STR_LIT>', action='<STR_LIT:store_true>',<EOL>help=\"<STR_LIT>\")<EOL>parser.parser.add_argument('<STR_LIT:url>',<EOL>help=\"<STR_LIT>\")<EOL>return parser<EOL>", "docstring": "Returns the MediaWiki argument parser.", "id": "f13173:c2:m0"}
{"signature": "def call(self, params):", "body": "logger.debug(\"<STR_LIT>\",<EOL>self.base_url, str(params))<EOL>req = self.fetch(self.base_url, payload=params)<EOL>return req.text<EOL>", "docstring": "Run an API command.\n        :param cgi: cgi command to run on the server\n        :param params: dict with the HTTP parameters needed to run\n            the given command", "id": "f13173:c1:m1"}
{"signature": "@staticmethod<EOL><INDENT>def metadata_category(item):<DEDENT>", "body": "return CATEGORY_PAGE<EOL>", "docstring": "Extracts the category from a MediaWiki item.\n\n        This backend only generates one type of item which is\n        'page'.", "id": "f13173:c0:m7"}
{"signature": "@staticmethod<EOL><INDENT>def metadata_category(item):<DEDENT>", "body": "return CATEGORY_MESSAGE<EOL>", "docstring": "Extracts the category from a Slack item.\n\n        This backend only generates one type of item which is\n        'message'.", "id": "f13174:c0:m7"}
{"signature": "def user(self, user_id):", "body": "resource = self.RUSER_INFO<EOL>params = {<EOL>self.PUSER: user_id<EOL>}<EOL>response = self._fetch(resource, params)<EOL>return response<EOL>", "docstring": "Fetch user info.", "id": "f13174:c2:m4"}
{"signature": "def channel_info(self, channel):", "body": "resource = self.RCHANNEL_INFO<EOL>params = {<EOL>self.PCHANNEL: channel,<EOL>}<EOL>response = self._fetch(resource, params)<EOL>return response<EOL>", "docstring": "Fetch information about a channel.", "id": "f13174:c2:m2"}
{"signature": "@classmethod<EOL><INDENT>def has_archiving(cls):<DEDENT>", "body": "return True<EOL>", "docstring": "Returns whether it supports archiving items on the fetch process.\n\n        :returns: this backend supports items archive", "id": "f13174:c0:m3"}
{"signature": "@classmethod<EOL><INDENT>def setup_cmd_parser(cls):<DEDENT>", "body": "parser = BackendCommandArgumentParser(cls.BACKEND.CATEGORIES,<EOL>from_date=True,<EOL>token_auth=True,<EOL>archive=True)<EOL>action = parser.parser._option_string_actions['<STR_LIT>']<EOL>action.required = True<EOL>group = parser.parser.add_argument_group('<STR_LIT>')<EOL>group.add_argument('<STR_LIT>', dest='<STR_LIT>',<EOL>type=int, default=MAX_ITEMS,<EOL>help=\"<STR_LIT>\")<EOL>parser.parser.add_argument('<STR_LIT>',<EOL>help=\"<STR_LIT>\")<EOL>return parser<EOL>", "docstring": "Returns the Slack argument parser.", "id": "f13174:c3:m0"}
{"signature": "@staticmethod<EOL><INDENT>def parse_channel_info(raw_channel_info):<DEDENT>", "body": "result = json.loads(raw_channel_info)<EOL>return result['<STR_LIT>']<EOL>", "docstring": "Parse a channel info JSON stream.\n\n        This method parses a JSON stream, containing the information\n        from a channel, and returns a dict with the parsed data.\n\n        :param raw_channel_info\n\n        :returns: a dict with the parsed information about a channel", "id": "f13174:c0:m8"}
{"signature": "@staticmethod<EOL><INDENT>def parse_user(raw_user):<DEDENT>", "body": "result = json.loads(raw_user)<EOL>return result['<STR_LIT:user>']<EOL>", "docstring": "Parse a user's info JSON stream.\n\n        This method parses a JSON stream, containing the information\n        from a user, and returns a dict with the parsed data.\n\n        :param raw_user: JSON string to parse\n\n        :returns: a dict with the parsed user's information", "id": "f13174:c0:m10"}
{"signature": "@staticmethod<EOL><INDENT>def metadata_category(item):<DEDENT>", "body": "return CATEGORY_BUILD<EOL>", "docstring": "Extracts the category from a Jenkins item.\n\n        This backend only generates one type of item which is\n        'build'.", "id": "f13175:c0:m7"}
{"signature": "@staticmethod<EOL><INDENT>def metadata_id(item):<DEDENT>", "body": "return str(item['<STR_LIT:url>'])<EOL>", "docstring": "Extracts the identifier from a Build item.", "id": "f13175:c0:m5"}
{"signature": "def _parse_supybot_msg(self, line):", "body": "patterns = [(self.SUPYBOT_COMMENT_REGEX, self.TCOMMENT),<EOL>(self.SUPYBOT_COMMENT_ACTION_REGEX, self.TCOMMENT),<EOL>(self.SUPYBOT_SERVER_REGEX, self.TSERVER),<EOL>(self.SUPYBOT_BOT_REGEX, self.TCOMMENT)]<EOL>for p in patterns:<EOL><INDENT>m = p[<NUM_LIT:0>].match(line)<EOL>if not m:<EOL><INDENT>continue<EOL><DEDENT>return p[<NUM_LIT:1>], m.group('<STR_LIT>'), m.group('<STR_LIT:body>').strip()<EOL><DEDENT>msg = \"<STR_LIT>\" % (str(self.nline))<EOL>raise ParseError(cause=msg)<EOL>", "docstring": "Parse message section", "id": "f13176:c2:m3"}
{"signature": "@staticmethod<EOL><INDENT>def parse_supybot_log(filepath):<DEDENT>", "body": "with open(filepath, '<STR_LIT:r>', errors='<STR_LIT>',<EOL>newline=os.linesep) as f:<EOL><INDENT>parser = SupybotParser(f)<EOL>try:<EOL><INDENT>for message in parser.parse():<EOL><INDENT>yield message<EOL><DEDENT><DEDENT>except ParseError as e:<EOL><INDENT>cause = \"<STR_LIT>\" % (filepath, str(e))<EOL>raise ParseError(cause=cause)<EOL><DEDENT><DEDENT>", "docstring": "Parse a Supybot IRC log file.\n\n        The method parses the Supybot IRC log file and returns an iterator of\n        dictionaries. Each one of this, contains a message from the file.\n\n        :param filepath: path to the IRC log file\n\n        :returns: a generator of parsed messages\n\n        :raises ParseError: raised when the format of the Supybot log file\n            is invalid\n        :raises OSError: raised when an error occurs reading the\n            given file", "id": "f13176:c0:m8"}
{"signature": "def __retrieve_archives(self, from_date):", "body": "archives = []<EOL>candidates = self.__list_supybot_archives()<EOL>for candidate in candidates:<EOL><INDENT>dt = self.__parse_date_from_filepath(candidate)<EOL>if dt.date() >= from_date.date():<EOL><INDENT>archives.append((dt, candidate))<EOL><DEDENT>else:<EOL><INDENT>logger.debug(\"<STR_LIT>\",<EOL>candidate, str(from_date))<EOL><DEDENT><DEDENT>archives.sort(key=lambda x: x[<NUM_LIT:0>])<EOL>return [archive[<NUM_LIT:1>] for archive in archives]<EOL>", "docstring": "Retrieve the Supybot archives after the given date", "id": "f13176:c0:m10"}
{"signature": "@classmethod<EOL><INDENT>def has_resuming(cls):<DEDENT>", "body": "return True<EOL>", "docstring": "Returns whether it supports to resume the fetch process.\n\n        :returns: this backend supports items resuming", "id": "f13176:c0:m4"}
{"signature": "@classmethod<EOL><INDENT>def setup_cmd_parser(cls):<DEDENT>", "body": "aliases = {<EOL>'<STR_LIT>': '<STR_LIT>'<EOL>}<EOL>parser = BackendCommandArgumentParser(cls.BACKEND.CATEGORIES,<EOL>from_date=True,<EOL>aliases=aliases)<EOL>parser.parser.add_argument('<STR_LIT>',<EOL>help=\"<STR_LIT>\")<EOL>parser.parser.add_argument('<STR_LIT>',<EOL>help=\"<STR_LIT>\")<EOL>return parser<EOL>", "docstring": "Returns the Supybot argument parser.", "id": "f13176:c1:m0"}
{"signature": "@staticmethod<EOL><INDENT>def metadata_updated_on(item):<DEDENT>", "body": "ts = item['<STR_LIT>'][<NUM_LIT:0>]['<STR_LIT>']<EOL>ts = str_to_datetime(ts)<EOL>ts = ts.replace(tzinfo=dateutil.tz.tzutc())<EOL>return ts.timestamp()<EOL>", "docstring": "Extracts and coverts the update time from a Bugzilla item.\n\n        The timestamp is extracted from 'delta_ts' field. This date is\n        converted to UNIX timestamp format. Due Bugzilla servers ignore\n        the timezone on HTTP requests, it will be ignored during the\n        conversion, too.\n\n        :param item: item generated by the backend\n\n        :returns: a UNIX timestamp", "id": "f13177:c0:m6"}
{"signature": "@staticmethod<EOL><INDENT>def metadata_category(item):<DEDENT>", "body": "return CATEGORY_BUG<EOL>", "docstring": "Extracts the category from a Bugzilla item.\n\n        This backend only generates one type of item which is\n        'bug'.", "id": "f13177:c0:m7"}
{"signature": "def fetch(self, category=CATEGORY_BUG, from_date=DEFAULT_DATETIME):", "body": "if not from_date:<EOL><INDENT>from_date = DEFAULT_DATETIME<EOL><DEDENT>kwargs = {\"<STR_LIT>\": from_date}<EOL>items = super().fetch(category, **kwargs)<EOL>return items<EOL>", "docstring": "Fetch the bugs from the repository.\n\n        The method retrieves, from a Bugzilla repository, the bugs\n        updated since the given date.\n\n        :param category: the category of items to fetch\n        :param from_date: obtain bugs updated since this date\n\n        :returns: a generator of bugs", "id": "f13177:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def parse_bug_activity(raw_html):<DEDENT>", "body": "def is_activity_empty(bs):<EOL><INDENT>EMPTY_ACTIVITY = \"<STR_LIT>\"<EOL>tag = bs.find(text=re.compile(EMPTY_ACTIVITY))<EOL>return tag is not None<EOL><DEDENT>def find_activity_table(bs):<EOL><INDENT>tables = bs.find_all('<STR_LIT>')<EOL>for tb in tables:<EOL><INDENT>nheaders = len(tb.tr.find_all('<STR_LIT>', recursive=False))<EOL>if nheaders == <NUM_LIT:5>:<EOL><INDENT>return tb<EOL><DEDENT><DEDENT>raise ParseError(cause=\"<STR_LIT>\")<EOL><DEDENT>def remove_tags(bs):<EOL><INDENT>HTML_TAGS_TO_REMOVE = ['<STR_LIT:a>', '<STR_LIT:i>', '<STR_LIT>']<EOL>for tag in bs.find_all(HTML_TAGS_TO_REMOVE):<EOL><INDENT>tag.replaceWith(tag.text)<EOL><DEDENT><DEDENT>def format_text(bs):<EOL><INDENT>strings = [s.strip('<STR_LIT>') for s in bs.stripped_strings]<EOL>s = '<STR_LIT:U+0020>'.join(strings)<EOL>return s<EOL><DEDENT>bs = bs4.BeautifulSoup(raw_html, '<STR_LIT>')<EOL>if is_activity_empty(bs):<EOL><INDENT>fields = []<EOL><DEDENT>else:<EOL><INDENT>activity_tb = find_activity_table(bs)<EOL>remove_tags(activity_tb)<EOL>fields = activity_tb.find_all('<STR_LIT>')<EOL><DEDENT>while fields:<EOL><INDENT>who = fields.pop(<NUM_LIT:0>)<EOL>when = fields.pop(<NUM_LIT:0>)<EOL>n = int(who.get('<STR_LIT>'))<EOL>for _ in range(n):<EOL><INDENT>what = fields.pop(<NUM_LIT:0>)<EOL>removed = fields.pop(<NUM_LIT:0>)<EOL>added = fields.pop(<NUM_LIT:0>)<EOL>event = {'<STR_LIT>': format_text(who),<EOL>'<STR_LIT>': format_text(when),<EOL>'<STR_LIT>': format_text(what),<EOL>'<STR_LIT>': format_text(removed),<EOL>'<STR_LIT>': format_text(added)}<EOL>yield event<EOL><DEDENT><DEDENT>", "docstring": "Parse a Bugzilla bug activity HTML stream.\n\n        This method extracts the information about activity from the\n        given HTML stream. The bug activity is stored into a HTML\n        table. Each parsed activity event is returned into a dictionary.\n\n        If the given HTML is invalid, the method will raise a ParseError\n        exception.\n\n        :param raw_html: HTML string to parse\n\n        :returns: a generator of parsed activity events\n\n        :raises ParseError: raised when an error occurs parsing\n            the given HTML stream", "id": "f13177:c0:m10"}
{"signature": "def __fetch_user_data(self, tag_type, user_link):", "body": "user_name = self.client.user_name(user_link)<EOL>user = {}<EOL>if not user_name:<EOL><INDENT>return user<EOL><DEDENT>user_raw = self.client.user(user_name)<EOL>user = json.loads(user_raw)<EOL>return user<EOL>", "docstring": "Get data associated to an user", "id": "f13178:c0:m16"}
{"signature": "def issue(self, issue_id):", "body": "path = urijoin(\"<STR_LIT>\", str(issue_id))<EOL>url_issue = self.__get_url(path)<EOL>raw_text = self.__send_request(url_issue)<EOL>return raw_text<EOL>", "docstring": "Get the issue data by its ID", "id": "f13178:c1:m4"}
{"signature": "@staticmethod<EOL><INDENT>def metadata_category(item):<DEDENT>", "body": "return CATEGORY_ISSUE<EOL>", "docstring": "Extracts the category from a Launchpad item.\n\n        This backend only generates one type of item which is\n        'issue'.", "id": "f13178:c0:m7"}
{"signature": "@classmethod<EOL><INDENT>def has_resuming(cls):<DEDENT>", "body": "return True<EOL>", "docstring": "Returns whether it supports to resume the fetch process.\n\n        :returns: this backend supports items resuming", "id": "f13178:c0:m4"}
{"signature": "def __init_extra_issue_fields(self, issue):", "body": "issue['<STR_LIT>'] = {}<EOL>issue['<STR_LIT>'] = {}<EOL>issue['<STR_LIT>'] = {}<EOL>return issue<EOL>", "docstring": "Add fields to an issue", "id": "f13178:c0:m9"}
{"signature": "def __fetch_issue_messages(self, issue_id):", "body": "for messages_raw in self.client.issue_collection(issue_id, \"<STR_LIT>\"):<EOL><INDENT>messages = json.loads(messages_raw)<EOL>for msg in messages['<STR_LIT>']:<EOL><INDENT>msg['<STR_LIT>'] = self.__fetch_user_data('<STR_LIT>', msg['<STR_LIT>'])<EOL>yield msg<EOL><DEDENT><DEDENT>", "docstring": "Get messages of an issue", "id": "f13178:c0:m14"}
{"signature": "def __fetch_issue_data(self, issue_id):", "body": "raw_issue = self.client.issue(issue_id)<EOL>issue = json.loads(raw_issue)<EOL>return issue<EOL>", "docstring": "Get data associated to an issue", "id": "f13178:c0:m12"}
{"signature": "def fetch_items(self, category, **kwargs):", "body": "from_date = kwargs['<STR_LIT>']<EOL>logger.info(\"<STR_LIT>\",<EOL>self.distribution, str(from_date))<EOL>nissues = <NUM_LIT:0><EOL>for issue in self._fetch_issues(from_date):<EOL><INDENT>yield issue<EOL>nissues += <NUM_LIT:1><EOL><DEDENT>logger.info(\"<STR_LIT>\", nissues)<EOL>", "docstring": "Fetch the issues\n\n        :param category: the category of items to fetch\n        :param kwargs: backend arguments\n\n        :returns: a generator of items", "id": "f13178:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def has_archiving(cls):<DEDENT>", "body": "return False<EOL>", "docstring": "Returns whether it supports archiving items on the fetch process.\n\n        :returns: this backend does not support items archive", "id": "f13179:c0:m3"}
{"signature": "@staticmethod<EOL><INDENT>def parse_issues(raw_page):<DEDENT>", "body": "raw_issues = json.loads(raw_page)<EOL>issues = raw_issues['<STR_LIT>']<EOL>for issue in issues:<EOL><INDENT>yield issue<EOL><DEDENT>", "docstring": "Parse a JIRA API raw response.\n\n        The method parses the API response retrieving the\n        issues from the received items\n\n        :param items: items from where to parse the issues\n\n        :returns: a generator of issues", "id": "f13180:c0:m8"}
{"signature": "def fetch(self, category=CATEGORY_ISSUE, from_date=DEFAULT_DATETIME):", "body": "if not from_date:<EOL><INDENT>from_date = DEFAULT_DATETIME<EOL><DEDENT>from_date = datetime_to_utc(from_date)<EOL>kwargs = {'<STR_LIT>': from_date}<EOL>items = super().fetch(category, **kwargs)<EOL>return items<EOL>", "docstring": "Fetch the issues from the site.\n\n        The method retrieves, from a JIRA site, the\n        issues updated since the given date.\n\n        :param category: the category of items to fetch\n        :param from_date: retrieve issues updated from this date\n\n        :returns: a generator of issues", "id": "f13180:c0:m1"}
{"signature": "def get_fields(self):", "body": "url = urijoin(self.base_url, self.RESOURCE, self.VERSION_API, '<STR_LIT>')<EOL>req = self.fetch(url)<EOL>return req.text<EOL>", "docstring": "Retrieve all the fields available.", "id": "f13180:c1:m4"}
{"signature": "def fetch_items(self, category, **kwargs):", "body": "from_date = kwargs['<STR_LIT>']<EOL>logger.info(\"<STR_LIT>\",<EOL>self.url, self.project, str(from_date))<EOL>whole_pages = self.client.get_issues(from_date)<EOL>fields = json.loads(self.client.get_fields())<EOL>custom_fields = filter_custom_fields(fields)<EOL>for whole_page in whole_pages:<EOL><INDENT>issues = self.parse_issues(whole_page)<EOL>for issue in issues:<EOL><INDENT>mapping = map_custom_field(custom_fields, issue['<STR_LIT>'])<EOL>for k, v in mapping.items():<EOL><INDENT>issue['<STR_LIT>'][k] = v<EOL><DEDENT>comments_data = self.__get_issue_comments(issue['<STR_LIT:id>'])<EOL>issue['<STR_LIT>'] = comments_data<EOL>yield issue<EOL><DEDENT><DEDENT>", "docstring": "Fetch the issues\n\n        :param category: the category of items to fetch\n        :param kwargs: backend arguments\n\n        :returns: a generator of items", "id": "f13180:c0:m2"}
{"signature": "def get_items(self, from_date, url, expand_fields=True):", "body": "start_at = <NUM_LIT:0><EOL>req = self.fetch(url, payload=self.__build_payload(start_at, from_date, expand_fields))<EOL>issues = req.text<EOL>data = req.json()<EOL>titems = data['<STR_LIT>']<EOL>nitems = data['<STR_LIT>']<EOL>start_at += min(nitems, titems)<EOL>self.__log_status(start_at, titems, url)<EOL>while issues:<EOL><INDENT>yield issues<EOL>issues = None<EOL>if data['<STR_LIT>'] + nitems < titems:<EOL><INDENT>req = self.fetch(url, payload=self.__build_payload(start_at, from_date, expand_fields))<EOL>data = req.json()<EOL>start_at += nitems<EOL>issues = req.text<EOL>self.__log_status(start_at, titems, url)<EOL><DEDENT><DEDENT>", "docstring": "Retrieve all the items from a given date.\n\n        :param url: endpoint API url\n        :param from_date: obtain items updated since this date\n        :param expand_fields: if True, it includes the expand fields in the payload", "id": "f13180:c1:m1"}
{"signature": "@staticmethod<EOL><INDENT>def metadata_category(item):<DEDENT>", "body": "return CATEGORY_ISSUE<EOL>", "docstring": "Extracts the category from a Jira item.\n\n        This backend only generates one type of item which is\n        'issue'.", "id": "f13180:c0:m7"}
{"signature": "def _init_client(self, from_archive=False):", "body": "return JiraClient(self.url, self.project, self.user, self.password,<EOL>self.verify, self.cert, self.max_results,<EOL>self.archive, from_archive)<EOL>", "docstring": "Init client", "id": "f13180:c0:m9"}
{"signature": "def __fetch_issues(self, from_date):", "body": "issues_groups = self.client.issues(from_date=from_date)<EOL>for raw_issues in issues_groups:<EOL><INDENT>issues = json.loads(raw_issues)<EOL>for issue in issues:<EOL><INDENT>issue_id = issue['<STR_LIT>']<EOL>if self.blacklist_ids and issue_id in self.blacklist_ids:<EOL><INDENT>logger.warning(\"<STR_LIT>\", issue_id)<EOL>continue<EOL><DEDENT>self.__init_issue_extra_fields(issue)<EOL>issue['<STR_LIT>'] =self.__get_issue_notes(issue_id)<EOL>issue['<STR_LIT>'] =self.__get_award_emoji(GitLabClient.ISSUES, issue_id)<EOL>yield issue<EOL><DEDENT><DEDENT>", "docstring": "Fetch the issues", "id": "f13181:c0:m9"}
{"signature": "def fetch_items(self, path, payload):", "body": "page = <NUM_LIT:0>  <EOL>last_page = None  <EOL>url_next = urijoin(self.base_url, GitLabClient.PROJECTS, self.owner + '<STR_LIT>' + self.repository, path)<EOL>logger.debug(\"<STR_LIT>\" + url_next)<EOL>response = self.fetch(url_next, payload=payload)<EOL>items = response.text<EOL>page += <NUM_LIT:1><EOL>if '<STR_LIT>' in response.links:<EOL><INDENT>last_url = response.links['<STR_LIT>']['<STR_LIT:url>']<EOL>last_page = last_url.split('<STR_LIT>')[<NUM_LIT:1>].split('<STR_LIT:&>')[<NUM_LIT:0>]<EOL>last_page = int(last_page)<EOL>logger.debug(\"<STR_LIT>\" % (page, last_page))<EOL><DEDENT>while items:<EOL><INDENT>yield items<EOL>items = None<EOL>if '<STR_LIT>' in response.links:<EOL><INDENT>url_next = response.links['<STR_LIT>']['<STR_LIT:url>']  <EOL>response = self.fetch(url_next, payload=payload)<EOL>page += <NUM_LIT:1><EOL>items = response.text<EOL>logger.debug(\"<STR_LIT>\" % (page, last_page))<EOL><DEDENT><DEDENT>", "docstring": "Return the items from GitLab API using links pagination", "id": "f13181:c1:m11"}
{"signature": "def _init_client(self, from_archive=False):", "body": "return GitLabClient(self.owner, self.repository, self.api_token, self.base_url,<EOL>self.sleep_for_rate, self.min_rate_to_sleep,<EOL>self.sleep_time, self.max_retries,<EOL>self.archive, from_archive)<EOL>", "docstring": "Init client", "id": "f13181:c0:m8"}
{"signature": "def merge_version(self, merge_id, version_id):", "body": "path = urijoin(self.base_url,<EOL>GitLabClient.PROJECTS, self.owner + '<STR_LIT>' + self.repository,<EOL>GitLabClient.MERGES, merge_id, GitLabClient.VERSIONS, version_id)<EOL>response = self.fetch(path)<EOL>return response.text<EOL>", "docstring": "Get merge version detail", "id": "f13181:c1:m5"}
{"signature": "def note_emojis(self, item_type, item_id, note_id):", "body": "payload = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': PER_PAGE<EOL>}<EOL>path = urijoin(item_type, str(item_id), GitLabClient.NOTES,<EOL>str(note_id), GitLabClient.EMOJI)<EOL>return self.fetch_items(path, payload)<EOL>", "docstring": "Get emojis of a note", "id": "f13181:c1:m8"}
{"signature": "@classmethod<EOL><INDENT>def setup_cmd_parser(cls):<DEDENT>", "body": "parser = BackendCommandArgumentParser(cls.BACKEND.CATEGORIES,<EOL>from_date=True,<EOL>token_auth=True,<EOL>archive=True)<EOL>group = parser.parser.add_argument_group('<STR_LIT>')<EOL>group.add_argument('<STR_LIT>', dest='<STR_LIT>',<EOL>help=\"<STR_LIT>\")<EOL>group.add_argument('<STR_LIT>', dest='<STR_LIT>',<EOL>action='<STR_LIT:store_true>',<EOL>help=\"<STR_LIT>\")<EOL>group.add_argument('<STR_LIT>', dest='<STR_LIT>',<EOL>default=MIN_RATE_LIMIT, type=int,<EOL>help=\"<STR_LIT>\")<EOL>group.add_argument('<STR_LIT>', dest='<STR_LIT>',<EOL>nargs='<STR_LIT:*>', type=int,<EOL>help=\"<STR_LIT>\")<EOL>group.add_argument('<STR_LIT>', dest='<STR_LIT>',<EOL>default=MAX_RETRIES, type=int,<EOL>help=\"<STR_LIT>\")<EOL>group.add_argument('<STR_LIT>', dest='<STR_LIT>',<EOL>default=DEFAULT_SLEEP_TIME, type=int,<EOL>help=\"<STR_LIT>\")<EOL>parser.parser.add_argument('<STR_LIT>',<EOL>help=\"<STR_LIT>\")<EOL>parser.parser.add_argument('<STR_LIT>',<EOL>help=\"<STR_LIT>\")<EOL>return parser<EOL>", "docstring": "Returns the GitLab argument parser.", "id": "f13181:c2:m0"}
{"signature": "def __get_award_emoji(self, item_type, item_id):", "body": "emojis = []<EOL>group_emojis = self.client.emojis(item_type, item_id)<EOL>for raw_emojis in group_emojis:<EOL><INDENT>for emoji in json.loads(raw_emojis):<EOL><INDENT>emojis.append(emoji)<EOL><DEDENT><DEDENT>return emojis<EOL>", "docstring": "Get award emojis for issue/merge request", "id": "f13181:c0:m14"}
{"signature": "def __get_merge_versions(self, merge_id):", "body": "versions = []<EOL>group_versions = self.client.merge_versions(merge_id)<EOL>for raw_versions in group_versions:<EOL><INDENT>for version in json.loads(raw_versions):<EOL><INDENT>version_id = version['<STR_LIT:id>']<EOL>version_full_raw = self.client.merge_version(merge_id, version_id)<EOL>version_full = json.loads(version_full_raw)<EOL>version_full.pop('<STR_LIT>', None)<EOL>versions.append(version_full)<EOL><DEDENT><DEDENT>return versions<EOL>", "docstring": "Get merge versions", "id": "f13181:c0:m13"}
{"signature": "def merge(self, merge_id):", "body": "path = urijoin(self.base_url,<EOL>GitLabClient.PROJECTS, self.owner + '<STR_LIT>' + self.repository,<EOL>GitLabClient.MERGES, merge_id)<EOL>response = self.fetch(path)<EOL>return response.text<EOL>", "docstring": "Get the merge full data", "id": "f13181:c1:m3"}
{"signature": "def fetch(self, category=CATEGORY_ISSUE, from_date=DEFAULT_DATETIME):", "body": "if not from_date:<EOL><INDENT>from_date = DEFAULT_DATETIME<EOL><DEDENT>from_date = datetime_to_utc(from_date)<EOL>kwargs = {'<STR_LIT>': from_date}<EOL>items = super().fetch(category, **kwargs)<EOL>return items<EOL>", "docstring": "Fetch the issues/merge requests from the repository.\n\n        The method retrieves, from a GitLab repository, the issues/merge requests\n        updated since the given date.\n\n        :param category: the category of items to fetch\n        :param from_date: obtain issues updated since this date\n\n        :returns: a generator of issues", "id": "f13181:c0:m1"}
{"signature": "def __get_issue_notes(self, issue_id):", "body": "notes = []<EOL>group_notes = self.client.notes(GitLabClient.ISSUES, issue_id)<EOL>for raw_notes in group_notes:<EOL><INDENT>for note in json.loads(raw_notes):<EOL><INDENT>note_id = note['<STR_LIT:id>']<EOL>note['<STR_LIT>'] =self.__get_note_award_emoji(GitLabClient.ISSUES, issue_id, note_id)<EOL>notes.append(note)<EOL><DEDENT><DEDENT>return notes<EOL>", "docstring": "Get issue notes", "id": "f13181:c0:m10"}
{"signature": "def _set_auth_arguments(self, basic_auth=True, token_auth=False):", "body": "group = self.parser.add_argument_group('<STR_LIT>')<EOL>if basic_auth:<EOL><INDENT>group.add_argument('<STR_LIT>', '<STR_LIT>', dest='<STR_LIT:user>',<EOL>help=\"<STR_LIT>\")<EOL>group.add_argument('<STR_LIT>', '<STR_LIT>', dest='<STR_LIT:password>',<EOL>help=\"<STR_LIT>\")<EOL><DEDENT>if token_auth:<EOL><INDENT>group.add_argument('<STR_LIT>', '<STR_LIT>', dest='<STR_LIT>',<EOL>help=\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Activate authentication arguments parsing", "id": "f13183:c1:m2"}
{"signature": "def uuid(*args):", "body": "def check_value(v):<EOL><INDENT>if not isinstance(v, str):<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % str(v))<EOL><DEDENT>elif not v:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>return v<EOL><DEDENT><DEDENT>s = '<STR_LIT::>'.join(map(check_value, args))<EOL>sha1 = hashlib.sha1(s.encode('<STR_LIT:utf-8>', errors='<STR_LIT>'))<EOL>uuid_sha1 = sha1.hexdigest()<EOL>return uuid_sha1<EOL>", "docstring": "Generate a UUID based on the given parameters.\n\n    The UUID will be the SHA1 of the concatenation of the values\n    from the list. The separator bewteedn these values is ':'.\n    Each value must be a non-empty string, otherwise, the function\n    will raise an exception.\n\n    :param *args: list of arguments used to generate the UUID\n\n    :returns: a universal unique identifier\n\n    :raises ValueError: when anyone of the values is not a string,\n        is empty or `None`.", "id": "f13183:m1"}
{"signature": "def _post_init(self):", "body": "pass<EOL>", "docstring": "Override to execute after backend is initialized.", "id": "f13183:c2:m3"}
{"signature": "def fetch_from_archive(self):", "body": "if not self.archive:<EOL><INDENT>raise ArchiveError(cause=\"<STR_LIT>\")<EOL><DEDENT>self.client = self._init_client(from_archive=True)<EOL>for item in self.fetch_items(self.archive.category, **self.archive.backend_params):<EOL><INDENT>yield self.metadata(item)<EOL><DEDENT>", "docstring": "Fetch the questions from an archive.\n\n        It returns the items stored within an archive. If this method is called but\n        no archive was provided, the method will raise a `ArchiveError` exception.\n\n        :returns: a generator of items\n\n        :raises ArchiveError: raised when an error occurs accessing an archive", "id": "f13183:c0:m8"}
{"signature": "def fetch(self, category, filter_classified=False, **kwargs):", "body": "if category not in self.categories:<EOL><INDENT>cause = \"<STR_LIT>\" % (category, self.__class__.__name__)<EOL>raise BackendError(cause=cause)<EOL><DEDENT>if filter_classified and self.archive:<EOL><INDENT>cause = \"<STR_LIT>\"<EOL>raise BackendError(cause=cause)<EOL><DEDENT>if self.archive:<EOL><INDENT>self.archive.init_metadata(self.origin, self.__class__.__name__, self.version, category,<EOL>kwargs)<EOL><DEDENT>self.client = self._init_client()<EOL>for item in self.fetch_items(category, **kwargs):<EOL><INDENT>if filter_classified:<EOL><INDENT>item = self.filter_classified_data(item)<EOL><DEDENT>yield self.metadata(item, filter_classified=filter_classified)<EOL><DEDENT>", "docstring": "Fetch items from the repository.\n\n        The method retrieves items from a repository.\n\n        To removed classified fields from the resulting items, set\n        the parameter `filter_classified`. Take into account this\n        parameter is incompatible with archiving items. Raw client\n        data are archived before any other process. Therefore,\n        classified data  are stored within the archive. To prevent\n        from possible data leaks or security issues when users do\n        not need these fields, archiving and filtering are not\n        compatible.\n\n        :param category: the category of the items fetched\n        :param filter_classified: remove classified fields from the resulting items\n        :param kwargs: a list of other parameters (e.g., from_date, offset, etc.\n        specific for each backend)\n\n        :returns: a generator of items\n\n        :raises BackendError: either when the category is not valid or\n            'filter_classified' and 'archive' are active at the same time.", "id": "f13183:c0:m7"}
{"signature": "def merge_checkpoint(input_graph,<EOL>input_checkpoint,<EOL>output_node_names,<EOL>output_graph):", "body": "restore_op_name = \"<STR_LIT>\"<EOL>filename_tensor_name = \"<STR_LIT>\"<EOL>input_graph_def = graph_pb2.GraphDef()<EOL>mode = \"<STR_LIT:r>\"<EOL>with gfile.FastGFile(input_graph, mode) as f:<EOL><INDENT>text_format.Merge(f.read().decode(\"<STR_LIT:utf-8>\"), input_graph_def)<EOL><DEDENT>for node in input_graph_def.node:<EOL><INDENT>node.device = \"<STR_LIT>\"<EOL><DEDENT>_ = importer.import_graph_def(input_graph_def, name=\"<STR_LIT>\")<EOL>with session.Session() as sess:<EOL><INDENT>sess.run([restore_op_name], {filename_tensor_name: input_checkpoint})<EOL>output_graph_def = graph_util.convert_variables_to_constants(<EOL>sess,<EOL>input_graph_def,<EOL>output_node_names,<EOL>variable_names_blacklist=\"<STR_LIT>\")<EOL><DEDENT>with gfile.GFile(output_graph, \"<STR_LIT:wb>\") as f:<EOL><INDENT>f.write(output_graph_def.SerializeToString())<EOL><DEDENT>", "docstring": "merge the checkpoint file with the non-binary graph file to\ngenerate one GraphDef file with the variable values\nArgs:\n    input_graph: the GraphDef file, not in the binary form\n    input_checkpoint: the checkpoint file\n    output_node_names: A string of name of the output names, \n        use comma to seperate multi outputs\n    output_graph: String of the location and the name of the\n        output graph", "id": "f13186:m0"}
{"signature": "def main():", "body": "height, width = <NUM_LIT>, <NUM_LIT><EOL>inputs = tf.Variable(tf.random_uniform((<NUM_LIT:1>, height, width, <NUM_LIT:3>)), name='<STR_LIT:input>')<EOL>inputs = tf.identity(inputs, \"<STR_LIT>\")<EOL>with slim.arg_scope(overfeat.overfeat_arg_scope()):<EOL><INDENT>net, end_points = overfeat.overfeat(inputs, is_training = False)<EOL><DEDENT>print(\"<STR_LIT>\")<EOL>for n in end_points:<EOL><INDENT>print(n + \"<STR_LIT>\" + str(end_points[n]))<EOL><DEDENT>net_outputs = map(lambda x: tf.get_default_graph().get_tensor_by_name(x), argv[<NUM_LIT:2>].split('<STR_LIT:U+002C>'))<EOL>run_model(net_outputs, argv[<NUM_LIT:1>], '<STR_LIT>', argv[<NUM_LIT:3>] == '<STR_LIT:True>')<EOL>", "docstring": "You can also run these commands manually to generate the pb file\n1. git clone https://github.com/tensorflow/models.git\n2. export PYTHONPATH=Path_to_your_model_folder\n3. python alexnet.py", "id": "f13195:m0"}
{"signature": "def main():", "body": "tf.set_random_seed(<NUM_LIT:1>)<EOL>height, width = <NUM_LIT>, <NUM_LIT><EOL>inputs = tf.Variable(tf.random_uniform((<NUM_LIT:2>, height, width, <NUM_LIT:3>)), name='<STR_LIT:input>')<EOL>inputs = tf.identity(inputs, \"<STR_LIT>\")<EOL>net, end_points = inception_resnet_v2.inception_resnet_v2(inputs,is_training = False)<EOL>print(\"<STR_LIT>\")<EOL>for n in end_points:<EOL><INDENT>print(n + \"<STR_LIT>\" + str(end_points[n]))<EOL><DEDENT>net_outputs = map(lambda x: tf.get_default_graph().get_tensor_by_name(x), argv[<NUM_LIT:2>].split('<STR_LIT:U+002C>'))<EOL>run_model(net_outputs, argv[<NUM_LIT:1>], '<STR_LIT>', argv[<NUM_LIT:3>] == '<STR_LIT:True>')<EOL>", "docstring": "You can also run these commands manually to generate the pb file\n1. git clone https://github.com/tensorflow/models.git\n2. export PYTHONPATH=Path_to_your_model_folder\n3. python alexnet.py", "id": "f13200:m0"}
{"signature": "def main():", "body": "height, width = <NUM_LIT>, <NUM_LIT><EOL>inputs = tf.Variable(tf.random_uniform((<NUM_LIT:1>, height, width, <NUM_LIT:3>)), name='<STR_LIT:input>')<EOL>inputs = tf.identity(inputs, \"<STR_LIT>\")<EOL>net, end_points  = vgg.vgg_19(inputs, is_training = False)<EOL>print(\"<STR_LIT>\")<EOL>for n in end_points:<EOL><INDENT>print(n + \"<STR_LIT>\" + str(end_points[n]))<EOL><DEDENT>net_outputs = map(lambda x: tf.get_default_graph().get_tensor_by_name(x), argv[<NUM_LIT:2>].split('<STR_LIT:U+002C>'))<EOL>run_model(net_outputs, argv[<NUM_LIT:1>], '<STR_LIT>', argv[<NUM_LIT:3>] == '<STR_LIT:True>')<EOL>", "docstring": "You can also run these commands manually to generate the pb file\n1. git clone https://github.com/tensorflow/models.git\n2. export PYTHONPATH=Path_to_your_model_folder\n3. python alexnet.py", "id": "f13201:m0"}
{"signature": "def main():", "body": "tf.set_random_seed(<NUM_LIT>)<EOL>input_width = <NUM_LIT:32><EOL>input_channel = <NUM_LIT:3><EOL>inputs = tf.Variable(tf.random_uniform((<NUM_LIT:1>, input_width, input_channel)), name='<STR_LIT:input>')<EOL>inputs = tf.identity(inputs, \"<STR_LIT>\")<EOL>filter_width = <NUM_LIT:4><EOL>output_channels = <NUM_LIT:6><EOL>filters = tf.Variable(tf.random_uniform((filter_width, input_channel, output_channels)))<EOL>conv_out = tf.nn.conv1d(inputs, filters, stride=<NUM_LIT:1>, padding=\"<STR_LIT>\")<EOL>bias = tf.Variable(tf.zeros([output_channels]))<EOL>output = tf.nn.tanh(tf.nn.bias_add(conv_out, bias), name=\"<STR_LIT>\")<EOL>net_outputs = map(lambda x: tf.get_default_graph().get_tensor_by_name(x), argv[<NUM_LIT:2>].split('<STR_LIT:U+002C>'))<EOL>run_model(net_outputs, argv[<NUM_LIT:1>], backward=(argv[<NUM_LIT:3>] == '<STR_LIT:True>'))<EOL>", "docstring": "You can also run these commands manually to generate the pb file\n1. git clone https://github.com/tensorflow/models.git\n2. export PYTHONPATH=Path_to_your_model_folder\n3. python temporal_convolution.py", "id": "f13202:m0"}
{"signature": "def main():", "body": "height, width = <NUM_LIT>, <NUM_LIT><EOL>batchSize = <NUM_LIT:1><EOL>if len(argv) == <NUM_LIT:5>:<EOL><INDENT>batchSize = int(argv[<NUM_LIT:4>])<EOL><DEDENT>inputs = tf.Variable(tf.random_uniform((batchSize, <NUM_LIT:3>, height, width)), name = '<STR_LIT:input>')<EOL>inputs = tf.identity(inputs, \"<STR_LIT>\")<EOL>net, end_points = alexnet_v1(inputs, is_training=False, spatial_squeeze=False)<EOL>print(\"<STR_LIT>\")<EOL>for n in end_points:<EOL><INDENT>print(n + \"<STR_LIT>\" + str(end_points[n]))<EOL><DEDENT>net_outputs = map(lambda x: tf.get_default_graph().get_tensor_by_name(x), argv[<NUM_LIT:2>].split('<STR_LIT:U+002C>'))<EOL>run_model(net_outputs, argv[<NUM_LIT:1>], '<STR_LIT>', argv[<NUM_LIT:3>] == '<STR_LIT:True>')<EOL>", "docstring": "You can also run these commands manually to generate the pb file\n1. git clone https://github.com/tensorflow/models.git\n2. export PYTHONPATH=Path_to_your_model_folder\n3. python alexnet.py", "id": "f13206:m0"}
{"signature": "def extract_images(f):", "body": "print('<STR_LIT>', f.name)<EOL>with gzip.GzipFile(fileobj=f) as bytestream:<EOL><INDENT>magic = _read32(bytestream)<EOL>if magic != <NUM_LIT>:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>' %<EOL>(magic, f.name))<EOL><DEDENT>num_images = _read32(bytestream)<EOL>rows = _read32(bytestream)<EOL>cols = _read32(bytestream)<EOL>buf = bytestream.read(rows * cols * num_images)<EOL>data = numpy.frombuffer(buf, dtype=numpy.uint8)<EOL>data = data.reshape(num_images, rows, cols, <NUM_LIT:1>)<EOL>return data<EOL><DEDENT>", "docstring": "Extract the images into a 4D uint8 numpy array [index, y, x, depth].\n\n    :param: f: A file object that can be passed into a gzip reader.\n    :return: data: A 4D unit8 numpy array [index, y, x, depth].\n    :raise: ValueError: If the bytestream does not start with 2051.", "id": "f13227:m1"}
{"signature": "def getMaxEpoch(self):", "body": "return self.getOrDefault(self.maxEpoch)<EOL>", "docstring": "Gets the value of maxEpoch or its default value.", "id": "f13233:c1:m2"}
{"signature": "def transform(self, dataset):", "body": "self._transfer_params_to_java()<EOL>return callBigDlFunc(self.bigdl_type, \"<STR_LIT>\", self.value, dataset)<EOL>", "docstring": "Apply the transformer to the images in \"inputCol\" and store the transformed result\ninto \"outputCols\"", "id": "f13234:c0:m1"}
{"signature": "def get_mnist(data_type=\"<STR_LIT:train>\", location=\"<STR_LIT>\"):", "body": "X, Y = mnist.read_data_sets(location, data_type)<EOL>return X, Y + <NUM_LIT:1><EOL>", "docstring": "Get mnist dataset with features and label as ndarray.\nData would be downloaded automatically if it doesn't present at the specific location.\n\n:param data_type: \"train\" for training data and \"test\" for testing data.\n:param location: Location to store mnist dataset.\n:return: (features: ndarray, label: ndarray)", "id": "f13239:m0"}
{"signature": "def __init__(self, sc=None, layer=None, pickle_registry=None, path=None, bigdl_type=\"<STR_LIT:float>\"):", "body": "if layer is not None:<EOL><INDENT>self.bigdl_type = layer.bigdl_type<EOL><DEDENT>else:<EOL><INDENT>self.bigdl_type = bigdl_type<EOL><DEDENT>super(ModelBroadcast, self).__init__(sc, layer, pickle_registry, path)<EOL>", "docstring": "Should not be called directly by users -- use L{SparkContext.broadcast()}\ninstead.", "id": "f13240:c0:m0"}
{"signature": "def getBatchSize(self):", "body": "return self.getOrDefault(self.batchSize)<EOL>", "docstring": "Gets the value of batchSize or its default value.", "id": "f13241:c0:m2"}
{"signature": "@staticmethod<EOL><INDENT>def load_weights_from_hdf5(bmodel, kmodel, filepath, by_name=False):<DEDENT>", "body": "local_file_path = BCommon.get_local_file(filepath)<EOL>kmodel.load_weights(filepath=local_file_path, by_name=by_name)<EOL>WeightLoader.load_weights_from_kmodel(bmodel, kmodel)<EOL>", "docstring": "Loads all layer weights from a HDF5 save file.\n        filepath can be stored in a local file system, HDFS, S3,\n        or any Hadoop-supported file system.\n        If `by_name` is False (default) weights are loaded\n        based on the network's execution order topology,\n        meaning layers in the execution seq should be exactly the same\n        the architecture\n\n        If `by_name` is True, weights are loaded into layers\n        only if they share the same name. This is useful\n        for fine-tuning or transfer-learning models where\n        some of the layers have changed.", "id": "f13247:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def from_hdf5_path(cls, hdf5_path):<DEDENT>", "body": "from keras.models import load_model<EOL>hdf5_local_path = BCommon.get_local_file(hdf5_path)<EOL>kmodel = load_model(hdf5_local_path)<EOL>return kmodel, DefinitionLoader.from_kmodel(kmodel)<EOL>", "docstring": ":param hdf5_path: hdf5 path which can be stored in a local file system, HDFS, S3, or any Hadoop-supported file system.\n:return: BigDL Model", "id": "f13247:c2:m5"}
{"signature": "@staticmethod<EOL><INDENT>def __build_node_id_2_klayer(kmodel, node_id_to_config_layer):<DEDENT>", "body": "node_id_to_config_layer[kmodel.name] = kmodel  <EOL>def gather_result(layers):<EOL><INDENT>if layers:  <EOL><INDENT>for layer in layers:<EOL><INDENT>if layer.name not in node_id_to_config_layer:<EOL><INDENT>node_id_to_config_layer[layer.name] = layer<EOL>DefinitionLoader.__build_node_id_2_klayer(layer, node_id_to_config_layer)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if hasattr(kmodel, \"<STR_LIT>\"):<EOL><INDENT>gather_result(kmodel.layers)<EOL><DEDENT>if hasattr(kmodel, \"<STR_LIT>\"):<EOL><INDENT>gather_result(kmodel.flattened_layers)<EOL><DEDENT>", "docstring": "The result would contain all of the layers including nested layers.\n:param kmodel: a keras model which can be Sequential or Model\n:param node_id_to_config_layer: a container to store the result", "id": "f13247:c2:m0"}
{"signature": "def is_spark_below_2_2():", "body": "import pyspark<EOL>if(hasattr(pyspark,\"<STR_LIT:version>\")):<EOL><INDENT>full_version = pyspark.version.__version__<EOL>parts = full_version.split(\"<STR_LIT:.>\")<EOL>spark_version = parts[<NUM_LIT:0>] + \"<STR_LIT:.>\" + parts[<NUM_LIT:1>]<EOL>if(compare_version(spark_version, \"<STR_LIT>\")>=<NUM_LIT:0>):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Check if spark version is below 2.2", "id": "f13248:m6"}
{"signature": "def export_checkpoint(checkpoint_path):", "body": "reader = tf.train.NewCheckpointReader(checkpoint_path)<EOL>tensor_names = filter(lambda n: n!='<STR_LIT>',<EOL>reader.get_variable_to_shape_map().keys())<EOL>tensors = {}<EOL>for tn in tensor_names:<EOL><INDENT>tensors[tn] = reader.get_tensor(tn)<EOL><DEDENT>return tensors<EOL>", "docstring": "Export variable tensors from the checkpoint files.\n\n:param checkpoint_path: tensorflow checkpoint path\n:return: dictionary of tensor. The key is the variable name and the value is the numpy", "id": "f13249:m2"}
{"signature": "def merge_checkpoint(input_graph,<EOL>checkpoint,<EOL>output_node_names,<EOL>output_graph,<EOL>sess):", "body": "restore_op_name = \"<STR_LIT>\"<EOL>filename_tensor_name = \"<STR_LIT>\"<EOL>input_graph_def = graph_pb2.GraphDef()<EOL>with gfile.FastGFile(input_graph, \"<STR_LIT:r>\") as f:<EOL><INDENT>text_format.Merge(f.read().decode(\"<STR_LIT:utf-8>\"), input_graph_def)<EOL><DEDENT>for node in input_graph_def.node:<EOL><INDENT>node.device = \"<STR_LIT>\"<EOL><DEDENT>importer.import_graph_def(input_graph_def, name=\"<STR_LIT>\")<EOL>sess.run([restore_op_name], {filename_tensor_name: checkpoint})<EOL>output_graph_def = graph_util.convert_variables_to_constants(<EOL>sess,<EOL>input_graph_def,<EOL>output_node_names,<EOL>variable_names_blacklist=\"<STR_LIT>\"<EOL>)<EOL>with gfile.GFile(output_graph, \"<STR_LIT:wb>\") as f:<EOL><INDENT>f.write(output_graph_def.SerializeToString())<EOL><DEDENT>", "docstring": "Get the variable values from the checkpoint file, and merge them to the GraphDef file\nArgs:\n    input_graph: the GraphDef file, doesn't contain variable values\n    checkpoint: the checkpoint file\n    output_node_names: A list of string, the output names\n    output_graph: String of the location and the name of the\n        output graph", "id": "f13249:m5"}
{"signature": "def get_spark_context(conf=None):", "body": "if hasattr(SparkContext, \"<STR_LIT>\"):<EOL><INDENT>with SparkContext._lock:<EOL><INDENT>if SparkContext._active_spark_context is None:<EOL><INDENT>spark_conf = create_spark_conf() if conf is None else conf<EOL>return SparkContext.getOrCreate(spark_conf)<EOL><DEDENT>else:<EOL><INDENT>return SparkContext.getOrCreate()<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if SparkContext._active_spark_context is None:<EOL><INDENT>spark_conf = create_spark_conf() if conf is None else conf<EOL>return SparkContext(conf=spark_conf)<EOL><DEDENT>else:<EOL><INDENT>return SparkContext._active_spark_context<EOL><DEDENT><DEDENT>", "docstring": "Get the current active spark context and create one if no active instance\n:param conf: combining bigdl configs into spark conf\n:return: SparkContext", "id": "f13250:m11"}
{"signature": "def _py2java(gateway, obj):", "body": "if isinstance(obj, RDD):<EOL><INDENT>obj = _to_java_object_rdd(obj)<EOL><DEDENT>elif isinstance(obj, DataFrame):<EOL><INDENT>obj = obj._jdf<EOL><DEDENT>elif isinstance(obj, SparkContext):<EOL><INDENT>obj = obj._jsc<EOL><DEDENT>elif isinstance(obj, (list, tuple)):<EOL><INDENT>obj = ListConverter().convert([_py2java(gateway, x) for x in obj],<EOL>gateway._gateway_client)<EOL><DEDENT>elif isinstance(obj, dict):<EOL><INDENT>result = {}<EOL>for (key, value) in obj.items():<EOL><INDENT>result[key] = _py2java(gateway, value)<EOL><DEDENT>obj = MapConverter().convert(result, gateway._gateway_client)<EOL><DEDENT>elif isinstance(obj, JavaValue):<EOL><INDENT>obj = obj.value<EOL><DEDENT>elif isinstance(obj, JavaObject):<EOL><INDENT>pass<EOL><DEDENT>elif isinstance(obj, (int, long, float, bool, bytes, unicode)):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>data = bytearray(PickleSerializer().dumps(obj))<EOL>obj = gateway.jvm.org.apache.spark.bigdl.api.python.BigDLSerDe.loads(data)<EOL><DEDENT>return obj<EOL>", "docstring": "Convert Python object into Java", "id": "f13250:m19"}
{"signature": "@classmethod<EOL><INDENT>def sparse(cls, a_ndarray, i_ndarray, shape, bigdl_type=\"<STR_LIT:float>\"):<DEDENT>", "body": "if a_ndarray is None:<EOL><INDENT>return None<EOL><DEDENT>assert isinstance(a_ndarray, np.ndarray),\"<STR_LIT>\" % type(a_ndarray)<EOL>assert isinstance(i_ndarray, np.ndarray),\"<STR_LIT>\" % type(a_ndarray)<EOL>assert i_ndarray.size == a_ndarray.size * shape.size,\"<STR_LIT>\"<EOL>return cls(a_ndarray,<EOL>shape,<EOL>bigdl_type,<EOL>i_ndarray)<EOL>", "docstring": "Convert a three ndarray to SparseTensor which would be used in Java side.\nFor example:\na_ndarray = [1, 3, 2, 4]\ni_ndarray = [[0, 0, 1, 2],\n             [0, 3, 2, 1]]\nshape = [3, 4]\nPresent a dense tensor\n[[ 1,  0,  0,  3],\n [ 0,  0,  2,  0],\n [ 0,  4,  0,  0]]\n\n:param a_ndarray non-zero elements in this SparseTensor\n:param i_ndarray zero-based indices for non-zero element\n                 i_ndarray's shape should be (shape.size, a_ndarray.size)\n                 And the i-th non-zero elements indices is i_ndarray[:, 1],\n                 should be zero-based and ascending;\n:param shape     shape as a DenseTensor.\n\n>>> import numpy as np\n>>> from bigdl.util.common import JTensor\n>>> from bigdl.util.common import callBigDlFunc\n>>> np.random.seed(123)\n>>> data = np.arange(1, 7).astype(\"float32\")\n>>> indices = np.arange(1, 7)\n>>> shape = np.array([10])\n>>> result = JTensor.sparse(data, indices, shape)\n>>> expected_storage = np.array([1., 2., 3., 4., 5., 6.])\n>>> expected_shape = np.array([10])\n>>> expected_indices = np.array([1, 2, 3, 4, 5, 6])\n>>> np.testing.assert_allclose(result.storage, expected_storage)\n>>> np.testing.assert_allclose(result.shape, expected_shape)\n>>> np.testing.assert_allclose(result.indices, expected_indices)\n>>> tensor1 = callBigDlFunc(\"float\", \"testTensor\", result)  # noqa\n>>> array_from_tensor = tensor1.to_ndarray()\n>>> expected_ndarray = np.array([0, 1, 2, 3, 4, 5, 6, 0, 0, 0])\n>>> (array_from_tensor == expected_ndarray).all()\nTrue", "id": "f13250:c6:m2"}
{"signature": "def get_activation_by_name(activation_name, activation_id=None):", "body": "import bigdl.nn.layer as BLayer<EOL>activation = None<EOL>activation_name = activation_name.lower()<EOL>if activation_name == \"<STR_LIT>\":<EOL><INDENT>activation = BLayer.Tanh()<EOL><DEDENT>elif activation_name == \"<STR_LIT>\":<EOL><INDENT>activation = BLayer.Sigmoid()<EOL><DEDENT>elif activation_name == \"<STR_LIT>\":<EOL><INDENT>activation = BLayer.HardSigmoid()<EOL><DEDENT>elif activation_name == \"<STR_LIT:relu>\":<EOL><INDENT>activation = BLayer.ReLU()<EOL><DEDENT>elif activation_name == \"<STR_LIT>\":<EOL><INDENT>activation = BLayer.SoftMax()<EOL><DEDENT>elif activation_name == \"<STR_LIT>\":<EOL><INDENT>activation = BLayer.SoftPlus(beta=<NUM_LIT:1.0>)<EOL><DEDENT>elif activation_name == \"<STR_LIT>\":<EOL><INDENT>activation = BLayer.SoftSign()<EOL><DEDENT>elif activation_name == \"<STR_LIT>\":<EOL><INDENT>activation = BLayer.Identity()<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\" % activation_name)<EOL><DEDENT>if not activation_id:<EOL><INDENT>activation.set_name(activation_id)<EOL><DEDENT>return activation<EOL>", "docstring": "Convert to a bigdl activation layer\n        given the name of the activation as a string", "id": "f13250:m24"}
{"signature": "def _to_java_object_rdd(rdd):", "body": "rdd = rdd._reserialize(AutoBatchedSerializer(PickleSerializer()))<EOL>returnrdd.ctx._jvm.org.apache.spark.bigdl.api.python.BigDLSerDe.pythonToJava(<EOL>rdd._jrdd, True)<EOL>", "docstring": "Return a JavaRDD of Object by unpickling\n\n\n    It will convert each Python object into Java object by Pyrolite, whenever\n    the RDD is serialized in batch or not.", "id": "f13250:m18"}
{"signature": "def callJavaFunc(func, *args):", "body": "gateway = _get_gateway()<EOL>args = [_py2java(gateway, a) for a in args]<EOL>result = func(*args)<EOL>return _java2py(gateway, result)<EOL>", "docstring": "Call Java Function", "id": "f13250:m17"}
{"signature": "def callBigDlFunc(bigdl_type, name, *args):", "body": "gateway = _get_gateway()<EOL>error = Exception(\"<STR_LIT>\" % name)<EOL>for jinvoker in JavaCreator.instance(bigdl_type, gateway).value:<EOL><INDENT>try:<EOL><INDENT>api = getattr(jinvoker, name)<EOL>result = callJavaFunc(api, *args)<EOL><DEDENT>except Exception as e:<EOL><INDENT>error = e<EOL>if \"<STR_LIT>\" not in str(e):<EOL><INDENT>raise e<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return result<EOL><DEDENT><DEDENT>raise error<EOL>", "docstring": "Call API in PythonBigDL", "id": "f13250:m15"}
{"signature": "@classmethod<EOL><INDENT>def from_ndarray(cls, a_ndarray, bigdl_type=\"<STR_LIT:float>\"):<DEDENT>", "body": "if a_ndarray is None:<EOL><INDENT>return None<EOL><DEDENT>assert isinstance(a_ndarray, np.ndarray),\"<STR_LIT>\" % type(a_ndarray)<EOL>return cls(a_ndarray,<EOL>a_ndarray.shape if a_ndarray.shape else (a_ndarray.size),<EOL>bigdl_type)<EOL>", "docstring": "Convert a ndarray to a DenseTensor which would be used in Java side.\n\n>>> import numpy as np\n>>> from bigdl.util.common import JTensor\n>>> from bigdl.util.common import callBigDlFunc\n>>> np.random.seed(123)\n>>> data = np.random.uniform(0, 1, (2, 3)).astype(\"float32\")\n>>> result = JTensor.from_ndarray(data)\n>>> expected_storage = np.array([[0.69646919, 0.28613934, 0.22685145], [0.55131477, 0.71946895, 0.42310646]])\n>>> expected_shape = np.array([2, 3])\n>>> np.testing.assert_allclose(result.storage, expected_storage, rtol=1e-6, atol=1e-6)\n>>> np.testing.assert_allclose(result.shape, expected_shape)\n>>> data_back = result.to_ndarray()\n>>> (data == data_back).all()\nTrue\n>>> tensor1 = callBigDlFunc(\"float\", \"testTensor\", JTensor.from_ndarray(data))  # noqa\n>>> array_from_tensor = tensor1.to_ndarray()\n>>> (array_from_tensor == data).all()\nTrue", "id": "f13250:c6:m1"}
{"signature": "def to_ndarray(self):", "body": "assert self.indices is None, \"<STR_LIT>\"<EOL>return np.array(self.storage, dtype=get_dtype(self.bigdl_type)).reshape(self.shape)<EOL>", "docstring": "Transfer JTensor to ndarray.\nAs SparseTensor may generate an very big ndarray, so we don't support this function for SparseTensor.\n:return: a ndarray", "id": "f13250:c6:m3"}
{"signature": "def show_bigdl_info_logs(bigdl_type=\"<STR_LIT:float>\"):", "body": "callBigDlFunc(bigdl_type, \"<STR_LIT>\")<EOL>", "docstring": "Set BigDL log level to INFO.\n:param bigdl_type: \"double\" or \"float\"", "id": "f13250:m5"}
{"signature": "def load_imdb():", "body": "from keras.preprocessing import sequence<EOL>from keras.datasets import imdb<EOL>(X_train, y_train), (X_test, y_test) = imdb.load_data(nb_words=<NUM_LIT>)<EOL>X_train = sequence.pad_sequences(X_train, maxlen=<NUM_LIT:100>)<EOL>X_test = sequence.pad_sequences(X_test, maxlen=<NUM_LIT:100>)<EOL>return X_train, y_train, X_test, y_test<EOL>", "docstring": "Load IMDB dataset\nTransform input data into an RDD of Sample", "id": "f13253:m0"}
{"signature": "def compile(self, optimizer, loss, metrics=None):", "body": "if isinstance(optimizer, six.string_types):<EOL><INDENT>optimizer = self.__convert_optim_method(optimizer)<EOL><DEDENT>if isinstance(loss, six.string_types):<EOL><INDENT>loss = self.__convert_criterion(loss)<EOL><DEDENT>if all(isinstance(metric, six.string_types) for metric in metrics):<EOL><INDENT>metrics = self.__convert_metrics(metrics)<EOL><DEDENT>callBigDlFunc(self.bigdl_type, \"<STR_LIT>\",<EOL>self.value,<EOL>optimizer,<EOL>loss,<EOL>metrics)<EOL>", "docstring": "Configures the learning process. Must be called before fit or evaluate.\n\n# Arguments\noptimizer: Optimization method to be used. One can alternatively pass in the corresponding\n           string representation, such as 'sgd'.\nloss: Criterion to be used. One can alternatively pass in the corresponding string\n      representation, such as 'mse'.\nmetrics: List of validation methods to be used. Default is None. One can alternatively use ['accuracy'].", "id": "f13258:c0:m3"}
{"signature": "def predict(self, x, distributed=True):", "body": "if is_distributed:<EOL><INDENT>if isinstance(x, np.ndarray):<EOL><INDENT>features = to_sample_rdd(x, np.zeros([x.shape[<NUM_LIT:0>]]))<EOL><DEDENT>elif isinstance(x, RDD):<EOL><INDENT>features = x<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % type(x))<EOL><DEDENT>return self.predict_distributed(features)<EOL><DEDENT>else:<EOL><INDENT>if isinstance(x, np.ndarray):<EOL><INDENT>return self.predict_local(x)<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % type(x))<EOL><DEDENT><DEDENT>", "docstring": "Use a model to do prediction.\n\n# Arguments\nx: Input data. A Numpy array or RDD of Sample.\ndistributed: Boolean. Whether to do prediction in distributed mode or local mode.\n             Default is True. In local mode, x must be a Numpy array.", "id": "f13258:c0:m6"}
{"signature": "def set_running_std(self, running_std):", "body": "callBigDlFunc(self.bigdl_type, \"<STR_LIT>\",<EOL>self.value, JTensor.from_ndarray(running_std))<EOL>return self<EOL>", "docstring": "Set the running variance of the BatchNormalization layer.\n:param running_std: a Numpy array.", "id": "f13259:c8:m2"}
{"signature": "def set_running_mean(self, running_mean):", "body": "callBigDlFunc(self.bigdl_type, \"<STR_LIT>\",<EOL>self.value, JTensor.from_ndarray(running_mean))<EOL>return self<EOL>", "docstring": "Set the running mean of the BatchNormalization layer.\n:param running_mean: a Numpy array.", "id": "f13259:c8:m1"}
{"signature": "def get_running_std(self):", "body": "return callBigDlFunc(self.bigdl_type, \"<STR_LIT>\",<EOL>self.value).to_ndarray()<EOL>", "docstring": "Get the running variance of the BatchNormalization layer.", "id": "f13259:c8:m4"}
{"signature": "@staticmethod<EOL><INDENT>def load_torch(path, bigdl_type=\"<STR_LIT:float>\"):<DEDENT>", "body": "jmodel = callBigDlFunc(bigdl_type, \"<STR_LIT>\", path)<EOL>return Layer.of(jmodel)<EOL>", "docstring": "Load a pre-trained Torch model.\n\n:param path: The path containing the pre-trained model.\n:return: A pre-trained model.", "id": "f13262:c4:m4"}
{"signature": "def predict_class_local(self, X):", "body": "result = callBigDlFunc(self.bigdl_type,<EOL>\"<STR_LIT>\",<EOL>self.value,<EOL>self._to_jtensors(X))<EOL>return np.stack(result)<EOL>", "docstring": ":param X: X can be a ndarray or list of ndarray if the model has multiple inputs.\n          The first dimension of X should be batch.\n:return: a ndarray as the prediction result.", "id": "f13262:c2:m21"}
{"signature": "@staticmethod<EOL><INDENT>def load_caffe_model(defPath, modelPath, bigdl_type=\"<STR_LIT:float>\"):<DEDENT>", "body": "jmodel = callBigDlFunc(bigdl_type, \"<STR_LIT>\", defPath, modelPath)<EOL>return Layer.of(jmodel)<EOL>", "docstring": "Load a pre-trained Caffe model.\n\n\n:param defPath: The path containing the caffe model definition.\n:param modelPath: The path containing the pre-trained caffe model.\n:return: A pre-trained model.", "id": "f13262:c4:m7"}
{"signature": "@staticmethod<EOL><INDENT>def load_keras(json_path=None, hdf5_path=None, by_name=False):<DEDENT>", "body": "import os<EOL>try:<EOL><INDENT>import tensorflow<EOL><DEDENT>except ImportError:<EOL><INDENT>os.environ['<STR_LIT>'] = \"<STR_LIT>\"<EOL>try:<EOL><INDENT>from theano import ifelse<EOL><DEDENT>except ImportError:<EOL><INDENT>raise Exception(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT>from bigdl.keras.converter import DefinitionLoader, WeightLoader<EOL>if json_path and not hdf5_path:<EOL><INDENT>return DefinitionLoader.from_json_path(json_path)<EOL><DEDENT>elif json_path and hdf5_path:<EOL><INDENT>return WeightLoader.load_weights_from_json_hdf5(json_path, hdf5_path, by_name=by_name)<EOL><DEDENT>elif hdf5_path and not json_path:<EOL><INDENT>kmodel, bmodel = DefinitionLoader.from_hdf5_path(hdf5_path)<EOL>WeightLoader.load_weights_from_kmodel(bmodel, kmodel)<EOL>return bmodel<EOL><DEDENT>", "docstring": "Load a pre-trained Keras model.\n\n:param json_path: The json path containing the keras model definition.\n:param hdf5_path: The HDF5 path containing the pre-trained keras model weights with or without the model architecture.\n:return: A bigdl model.", "id": "f13262:c4:m5"}
{"signature": "@staticmethod<EOL><INDENT>def load_caffe(model, defPath, modelPath, match_all=True, bigdl_type=\"<STR_LIT:float>\"):<DEDENT>", "body": "jmodel = callBigDlFunc(bigdl_type, \"<STR_LIT>\", model, defPath, modelPath, match_all)<EOL>return Layer.of(jmodel)<EOL>", "docstring": "Load a pre-trained Caffe model.\n\n\n:param model: A bigdl model definition \\which equivalent to the pre-trained caffe model.\n:param defPath: The path containing the caffe model definition.\n:param modelPath: The path containing the pre-trained caffe model.\n:return: A pre-trained model.", "id": "f13262:c4:m6"}
{"signature": "def unfreeze(self, names=None):", "body": "callBigDlFunc(self.bigdl_type, \"<STR_LIT>\", self.value, names)<EOL>return self<EOL>", "docstring": "unfreeze module, if names is not None, unfreeze layers that match given names\n:param names: an array of layer names\n:return:", "id": "f13262:c2:m37"}
{"signature": "@staticmethod<EOL><INDENT>def from_jvalue(jvalue, bigdl_type=\"<STR_LIT:float>\"):<DEDENT>", "body": "model = Model([], [], jvalue=jvalue)<EOL>model.value = jvalue<EOL>return model<EOL>", "docstring": "Create a Python Model base on the given java value\n:param jvalue: Java object create by Py4j\n:return: A Python Model", "id": "f13262:c4:m1"}
{"signature": "@staticmethod<EOL><INDENT>def check_input(input):<DEDENT>", "body": "def to_jtensor(i):<EOL><INDENT>if isinstance(i, np.ndarray):<EOL><INDENT>return JTensor.from_ndarray(i)<EOL><DEDENT>elif isinstance(i, JTensor):<EOL><INDENT>return i<EOL><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\" % type(i))<EOL><DEDENT><DEDENT>if type(input) is list:<EOL><INDENT>if len(input) == <NUM_LIT:0>:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>return list(map(lambda i: to_jtensor(i), input)), True<EOL><DEDENT>else:<EOL><INDENT>return [to_jtensor(input)], False<EOL><DEDENT>", "docstring": ":param input: ndarray or list of ndarray or JTensor or list of JTensor.\n:return: (list of JTensor, isTable)", "id": "f13262:c2:m10"}
{"signature": "@staticmethod<EOL><INDENT>def load(path, bigdl_type=\"<STR_LIT:float>\"):<DEDENT>", "body": "jmodel = callBigDlFunc(bigdl_type, \"<STR_LIT>\", path)<EOL>return Layer.of(jmodel)<EOL>", "docstring": "Load a pre-trained Bigdl model.\n\n:param path: The path containing the pre-trained model.\n:return: A pre-trained model.", "id": "f13262:c1:m0"}
{"signature": "def evaluate(self, *args):", "body": "if len(args) == <NUM_LIT:0>:<EOL><INDENT>callBigDlFunc(self.bigdl_type,<EOL>\"<STR_LIT>\", self.value)<EOL>return self<EOL><DEDENT>elif len(args) == <NUM_LIT:3>:<EOL><INDENT>dataset, batch_size, val_methods = args<EOL>if (isinstance(dataset, ImageFrame)):<EOL><INDENT>return callBigDlFunc(self.bigdl_type,<EOL>\"<STR_LIT>\",<EOL>self.value,<EOL>dataset, batch_size, val_methods)<EOL><DEDENT>else:<EOL><INDENT>return callBigDlFunc(self.bigdl_type,<EOL>\"<STR_LIT>\",<EOL>self.value,<EOL>dataset, batch_size, val_methods)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "No argument passed in:\nEvaluate the model to set train = false, useful when doing test/forward\n:return: layer itself\n\nThree arguments passed in:\nA method to benchmark the model quality.\n\n:param dataset: the input data\n:param batch_size: batch size\n:param val_methods: a list of validation methods. i.e: Top1Accuracy,Top5Accuracy and Loss.\n:return: a list of the metrics result", "id": "f13262:c2:m18"}
{"signature": "def set_name(self, name):", "body": "callJavaFunc(self.value.setName, name)<EOL>return self<EOL>", "docstring": "Give this model a name. There would be a generated name\nconsist of class name and UUID if user doesn't set it.", "id": "f13262:c2:m6"}
{"signature": "def predict_class(self, features):", "body": "if isinstance(features, RDD):<EOL><INDENT>return self.predict_class_distributed(features)<EOL><DEDENT>else:<EOL><INDENT>return self.predict_class_local(features)<EOL><DEDENT>", "docstring": "Model inference base on the given data which returning label\n:param features: it can be a ndarray or list of ndarray for locally inference\n                 or RDD[Sample] for running in distributed fashion\n:return: ndarray or RDD[Sample] depend on the the type of features.", "id": "f13262:c2:m23"}
{"signature": "@staticmethod<EOL><INDENT>def loadModel(modelPath, weightPath =None, bigdl_type=\"<STR_LIT:float>\"):<DEDENT>", "body": "jmodel = callBigDlFunc(bigdl_type, \"<STR_LIT>\", modelPath, weightPath)<EOL>return Layer.of(jmodel)<EOL>", "docstring": "Load a pre-trained Bigdl model.\n\n:param path: The path containing the pre-trained model.\n:return: A pre-trained model.", "id": "f13262:c4:m3"}
{"signature": "def training(self, is_training=True):", "body": "if is_training:<EOL><INDENT>callJavaFunc(self.value.training)<EOL><DEDENT>else:<EOL><INDENT>callJavaFunc(self.value.evaluate)<EOL><DEDENT>return self<EOL>", "docstring": "Set this layer in the training mode or in predition mode if is_training=False", "id": "f13262:c2:m38"}
{"signature": "def setBRegularizer(self, bRegularizer):", "body": "self.value.bRegularizer = bRegularizer.value<EOL>", "docstring": "set bias regularizer\n:param wRegularizer: bias regularizer\n:return:", "id": "f13262:c2:m35"}
{"signature": "def __init__(self, max, bigdl_type=\"<STR_LIT:float>\"):", "body": "JavaValue.__init__(self, None, bigdl_type, max)<EOL>", "docstring": "Create a MaxIteration trigger.\n\n\n:param max: max", "id": "f13264:c7:m0"}
{"signature": "def __init__(self, bigdl_type=\"<STR_LIT:float>\"):", "body": "JavaValue.__init__(self, None, bigdl_type)<EOL>", "docstring": "Create a EveryEpoch trigger.", "id": "f13264:c9:m0"}
{"signature": "def set_val_summary(self, summary):", "body": "callBigDlFunc(self.bigdl_type, \"<STR_LIT>\", self.value,<EOL>summary)<EOL>return self<EOL>", "docstring": "Set validation summary. A ValidationSummary object contains information\nnecessary for the optimizer to know how often the logs are recorded,\nwhere to store the logs and how to retrieve them, etc. For details,\nrefer to the docs of ValidationSummary.\n\n\n:param summary: a ValidationSummary object", "id": "f13264:c33:m8"}
{"signature": "def set_traindata(self, training_rdd, batch_size):", "body": "callBigDlFunc(self.bigdl_type, \"<STR_LIT>\", self.value,<EOL>training_rdd, batch_size)<EOL>", "docstring": "Set new training dataset, for optimizer reuse\n\n:param training_rdd: the training dataset\n:param batch_size: training batch size\n:return:", "id": "f13264:c34:m3"}
{"signature": "def __init__(self, log_dir, app_name, bigdl_type=\"<STR_LIT:float>\"):", "body": "JavaValue.__init__(self, None, bigdl_type, log_dir, app_name)<EOL>", "docstring": "Create a TrainSummary. Logs will be saved to log_dir/app_name/train.\n\n\n:param log_dir: the root dir to store the logs\n:param app_name: the application name", "id": "f13264:c37:m0"}
{"signature": "def __init__(self, min, bigdl_type=\"<STR_LIT:float>\"):", "body": "JavaValue.__init__(self, None, bigdl_type, min)<EOL>", "docstring": "Create a MinLoss trigger.\n\n\n:param min: min loss", "id": "f13264:c12:m0"}
{"signature": "def set_model(self, model):", "body": "self.value.setModel(model.value)<EOL>", "docstring": "Set model.\n\n\n:param model: new model", "id": "f13264:c33:m0"}
{"signature": "def __init__(self, first, *other):", "body": "JavaValue.__init__(self, None, \"<STR_LIT:float>\", first, list(other))<EOL>", "docstring": "Create a And trigger.\n\n\n:param first: first Trigger\n:param other: other Trigger", "id": "f13264:c13:m0"}
{"signature": "@classmethod<EOL><INDENT>def read_parquet(cls, path, sc, bigdl_type=\"<STR_LIT:float>\"):<DEDENT>", "body": "return DistributedImageFrame(jvalue=callBigDlFunc(bigdl_type, \"<STR_LIT>\", path, sc))<EOL>", "docstring": "Read parquet file as DistributedImageFrame", "id": "f13265:c3:m2"}
{"signature": "def is_distributed(self):", "body": "return callBigDlFunc(self.bigdl_type, \"<STR_LIT>\", self.value)<EOL>", "docstring": "whether this is a DistributedImageFrame", "id": "f13265:c3:m5"}
{"signature": "def get_image(self, float_key=\"<STR_LIT>\", to_chw=True):", "body": "return self.image_frame.get_image(float_key, to_chw)<EOL>", "docstring": "get image from ImageFrame", "id": "f13265:c3:m7"}
{"signature": "def get_predict(self, key=\"<STR_LIT>\"):", "body": "return self.image_frame.get_predict(key)<EOL>", "docstring": "get prediction from ImageFrame", "id": "f13265:c3:m9"}
{"signature": "def set_label(self, label, bigdl_type=\"<STR_LIT:float>\"):", "body": "return callBigDlFunc(bigdl_type,<EOL>\"<STR_LIT>\", label, self.value)<EOL>", "docstring": "set label for imageframe", "id": "f13265:c3:m12"}
{"signature": "@classmethod<EOL><INDENT>def read(cls, path, sc=None, min_partitions=<NUM_LIT:1>, bigdl_type=\"<STR_LIT:float>\"):<DEDENT>", "body": "return ImageFrame(jvalue=callBigDlFunc(bigdl_type, \"<STR_LIT>\", path, sc, min_partitions))<EOL>", "docstring": "Read images as Image Frame\nif sc is defined, Read image as DistributedImageFrame from local file system or HDFS\nif sc is null, Read image as LocalImageFrame from local file system\n:param path path to read images\nif sc is defined, path can be local or HDFS. Wildcard character are supported.\nif sc is null, path is local directory/image file/image file with wildcard character\n:param sc SparkContext\n:param min_partitions A suggestion value of the minimal splitting number for input data.\n:return ImageFrame", "id": "f13265:c3:m1"}
{"signature": "def get_label(self):", "body": "label = callBigDlFunc(self.bigdl_type, \"<STR_LIT>\", self.value)<EOL>return label.to_ndarray()<EOL>", "docstring": "get label as ndarray from ImageFeature", "id": "f13265:c2:m2"}
{"signature": "def setup_method(self, method):", "body": "sparkConf = create_spark_conf().setMaster(\"<STR_LIT>\").setAppName(\"<STR_LIT>\")<EOL>self.sc = get_spark_context(sparkConf)<EOL>init_engine()<EOL>self.resource_path = os.path.join(os.path.split(__file__)[<NUM_LIT:0>], \"<STR_LIT>\")<EOL>", "docstring": "setup any state tied to the execution of the given method in a\nclass. setup_method is invoked for every test method of a class.", "id": "f13268:c0:m0"}
{"signature": "def teardown_method(self, method):", "body": "self.sc.stop()<EOL>", "docstring": "teardown any state that was previously setup with a setup_method\ncall.", "id": "f13268:c0:m1"}
{"signature": "def setup_method(self, method):", "body": "sparkConf = create_spark_conf().setMaster(\"<STR_LIT>\").setAppName(\"<STR_LIT>\")<EOL>self.sc = get_spark_context(sparkConf)<EOL>self.sqlContext = SQLContext(self.sc)<EOL>init_engine()<EOL>", "docstring": "setup any state tied to the execution of the given method in a\n        class.  setup_method is invoked for every test method of a class.", "id": "f13269:c0:m0"}
{"signature": "def setup_method(self, method):", "body": "sparkConf = create_spark_conf().setMaster(\"<STR_LIT>\").setAppName(\"<STR_LIT>\")<EOL>self.sc = get_spark_context(sparkConf)<EOL>init_engine()<EOL>resource_path = os.path.join(os.path.split(__file__)[<NUM_LIT:0>], \"<STR_LIT>\")<EOL>self.image_path = os.path.join(resource_path, \"<STR_LIT>\")<EOL>", "docstring": "setup any state tied to the execution of the given method in a\n        class.  setup_method is invoked for every test method of a class.", "id": "f13284:c0:m0"}
{"signature": "def teardown_method(self, method):", "body": "self.sc.stop()<EOL>", "docstring": "teardown any state that was previously setup with a setup_method\n        call.", "id": "f13284:c0:m1"}
{"signature": "def imports_on_separate_lines(logical_line):", "body": "line = logical_line<EOL>if line.startswith('<STR_LIT>'):<EOL><INDENT>found = line.find('<STR_LIT:U+002C>')<EOL>if -<NUM_LIT:1> < found and '<STR_LIT:;>' not in line[:found]:<EOL><INDENT>yield found, \"<STR_LIT>\"<EOL><DEDENT><DEDENT>", "docstring": "r\"\"\"Imports should usually be on separate lines.\n\n    Okay: import os\\nimport sys\n    E401: import sys, os\n\n    Okay: from subprocess import Popen, PIPE\n    Okay: from myclas import MyClass\n    Okay: from foo.bar.yourclass import YourClass\n    Okay: import myclass\n    Okay: import foo.bar.yourclass", "id": "f13285:m17"}
{"signature": "def run_check(self, check, argument_names):", "body": "arguments = []<EOL>for name in argument_names:<EOL><INDENT>arguments.append(getattr(self, name))<EOL><DEDENT>return check(*arguments)<EOL>", "docstring": "Run a check plugin.", "id": "f13285:c0:m3"}
{"signature": "def check_files(self, paths=None):", "body": "if paths is None:<EOL><INDENT>paths = self.paths<EOL><DEDENT>report = self.options.report<EOL>runner = self.runner<EOL>report.start()<EOL>try:<EOL><INDENT>for path in paths:<EOL><INDENT>if os.path.isdir(path):<EOL><INDENT>self.input_dir(path)<EOL><DEDENT>elif not self.excluded(path):<EOL><INDENT>runner(path)<EOL><DEDENT><DEDENT><DEDENT>except KeyboardInterrupt:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>report.stop()<EOL>return report<EOL>", "docstring": "Run all checks on the paths.", "id": "f13285:c5:m2"}
{"signature": "def get_file_results(self):", "body": "return self.file_errors<EOL>", "docstring": "Return the count of errors and warnings for this file.", "id": "f13285:c1:m6"}
{"signature": "def register_check(check, codes=None):", "body": "def _add_check(check, kind, codes, args):<EOL><INDENT>if check in _checks[kind]:<EOL><INDENT>_checks[kind][check][<NUM_LIT:0>].extend(codes or [])<EOL><DEDENT>else:<EOL><INDENT>_checks[kind][check] = (codes or ['<STR_LIT>'], args)<EOL><DEDENT><DEDENT>if inspect.isfunction(check):<EOL><INDENT>args = _get_parameters(check)<EOL>if args and args[<NUM_LIT:0>] in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>if codes is None:<EOL><INDENT>codes = ERRORCODE_REGEX.findall(check.__doc__ or '<STR_LIT>')<EOL><DEDENT>_add_check(check, args[<NUM_LIT:0>], codes, args)<EOL><DEDENT><DEDENT>elif inspect.isclass(check):<EOL><INDENT>if _get_parameters(check.__init__)[:<NUM_LIT:2>] == ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>_add_check(check, '<STR_LIT>', codes, None)<EOL><DEDENT><DEDENT>", "docstring": "Register a new check object.", "id": "f13285:m36"}
{"signature": "def expand_indent(line):", "body": "if '<STR_LIT:\\t>' not in line:<EOL><INDENT>return len(line) - len(line.lstrip())<EOL><DEDENT>result = <NUM_LIT:0><EOL>for char in line:<EOL><INDENT>if char == '<STR_LIT:\\t>':<EOL><INDENT>result = result // <NUM_LIT:8> * <NUM_LIT:8> + <NUM_LIT:8><EOL><DEDENT>elif char == '<STR_LIT:U+0020>':<EOL><INDENT>result += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "r\"\"\"Return the amount of indentation.\n\n    Tabs are expanded to the next multiple of 8.\n\n    >>> expand_indent('    ')\n    4\n    >>> expand_indent('\\t')\n    8\n    >>> expand_indent('       \\t')\n    8\n    >>> expand_indent('        \\t')\n    16", "id": "f13285:m29"}
{"signature": "def whitespace_around_operator(logical_line):", "body": "for match in OPERATOR_REGEX.finditer(logical_line):<EOL><INDENT>before, after = match.groups()<EOL>if '<STR_LIT:\\t>' in before:<EOL><INDENT>yield match.start(<NUM_LIT:1>), \"<STR_LIT>\"<EOL><DEDENT>elif len(before) > <NUM_LIT:1>:<EOL><INDENT>yield match.start(<NUM_LIT:1>), \"<STR_LIT>\"<EOL><DEDENT>if '<STR_LIT:\\t>' in after:<EOL><INDENT>yield match.start(<NUM_LIT:2>), \"<STR_LIT>\"<EOL><DEDENT>elif len(after) > <NUM_LIT:1>:<EOL><INDENT>yield match.start(<NUM_LIT:2>), \"<STR_LIT>\"<EOL><DEDENT><DEDENT>", "docstring": "r\"\"\"Avoid extraneous whitespace around an operator.\n\n    Okay: a = 12 + 3\n    E221: a = 4  + 5\n    E222: a = 4 +  5\n    E223: a = 4\\t+ 5\n    E224: a = 4 +\\t5", "id": "f13285:m12"}
{"signature": "def tabs_or_spaces(physical_line, indent_char):", "body": "indent = INDENT_REGEX.match(physical_line).group(<NUM_LIT:1>)<EOL>for offset, char in enumerate(indent):<EOL><INDENT>if char != indent_char:<EOL><INDENT>return offset, \"<STR_LIT>\"<EOL><DEDENT><DEDENT>", "docstring": "r\"\"\"Never mix tabs and spaces.\n\n    The most popular way of indenting Python is with spaces only.  The\n    second-most popular way is with tabs only.  Code indented with a mixture\n    of tabs and spaces should be converted to using spaces exclusively.  When\n    invoking the Python command line interpreter with the -t option, it issues\n    warnings about code that illegally mixes tabs and spaces.  When using -tt\n    these warnings become errors.  These options are highly recommended!\n\n    Okay: if a == 0:\\n        a = 1\\n        b = 1\n    E101: if a == 0:\\n        a = 1\\n\\tb = 1", "id": "f13285:m0"}
{"signature": "def init_checks_registry():", "body": "mod = inspect.getmodule(register_check)<EOL>for (name, function) in inspect.getmembers(mod, inspect.isfunction):<EOL><INDENT>register_check(function)<EOL><DEDENT>", "docstring": "Register all globally visible functions.\n\n    The first argument name is either 'physical_line' or 'logical_line'.", "id": "f13285:m37"}
{"signature": "def error(self, line_number, offset, text, check):", "body": "code = text[:<NUM_LIT:4>]<EOL>if self._ignore_code(code):<EOL><INDENT>return<EOL><DEDENT>if code in self.counters:<EOL><INDENT>self.counters[code] += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>self.counters[code] = <NUM_LIT:1><EOL>self.messages[code] = text[<NUM_LIT:5>:]<EOL><DEDENT>if code in self.expected:<EOL><INDENT>return<EOL><DEDENT>if self.print_filename and not self.file_errors:<EOL><INDENT>print(self.filename)<EOL><DEDENT>self.file_errors += <NUM_LIT:1><EOL>self.total_errors += <NUM_LIT:1><EOL>return code<EOL>", "docstring": "Report an error, according to options.", "id": "f13285:c1:m5"}
{"signature": "def whitespace_before_parameters(logical_line, tokens):", "body": "prev_type, prev_text, __, prev_end, __ = tokens[<NUM_LIT:0>]<EOL>for index in range(<NUM_LIT:1>, len(tokens)):<EOL><INDENT>token_type, text, start, end, __ = tokens[index]<EOL>if (token_type == tokenize.OP and<EOL>text in '<STR_LIT>' and<EOL>start != prev_end and<EOL>(prev_type == tokenize.NAME or prev_text in '<STR_LIT>') and<EOL>(index < <NUM_LIT:2> or tokens[index - <NUM_LIT:2>][<NUM_LIT:1>] != '<STR_LIT:class>') and<EOL>not keyword.iskeyword(prev_text)):<EOL><INDENT>yield prev_end, \"<STR_LIT>\" % text<EOL><DEDENT>prev_type = token_type<EOL>prev_text = text<EOL>prev_end = end<EOL><DEDENT>", "docstring": "r\"\"\"Avoid extraneous whitespace.\n\n    Avoid extraneous whitespace in the following situations:\n    - before the open parenthesis that starts the argument list of a\n      function call.\n    - before the open parenthesis that starts an indexing or slicing.\n\n    Okay: spam(1)\n    E211: spam (1)\n\n    Okay: dict['key'] = list[index]\n    E211: dict ['key'] = list[index]\n    E211: dict['key'] = list [index]", "id": "f13285:m11"}
{"signature": "def python_3000_not_equal(logical_line):", "body": "pos = logical_line.find('<STR_LIT>')<EOL>if pos > -<NUM_LIT:1>:<EOL><INDENT>yield pos, \"<STR_LIT>\"<EOL><DEDENT>", "docstring": "r\"\"\"New code should always use != instead of <>.\n\n    The older syntax is removed in Python 3.\n\n    Okay: if a != 'no':\n    W603: if a <> 'no':", "id": "f13285:m27"}
{"signature": "def readline(self):", "body": "if self.line_number >= self.total_lines:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>line = self.lines[self.line_number]<EOL>self.line_number += <NUM_LIT:1><EOL>if self.indent_char is None and line[:<NUM_LIT:1>] in WHITESPACE:<EOL><INDENT>self.indent_char = line[<NUM_LIT:0>]<EOL><DEDENT>return line<EOL>", "docstring": "Get the next line from the input buffer.", "id": "f13285:c0:m2"}
{"signature": "def increment_logical_line(self):", "body": "self.counters['<STR_LIT>'] += <NUM_LIT:1><EOL>", "docstring": "Signal a new logical line.", "id": "f13285:c1:m4"}
{"signature": "def input_dir(self, dirname):", "body": "dirname = dirname.rstrip('<STR_LIT:/>')<EOL>if self.excluded(dirname):<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>counters = self.options.report.counters<EOL>verbose = self.options.verbose<EOL>filepatterns = self.options.filename<EOL>runner = self.runner<EOL>for root, dirs, files in os.walk(dirname):<EOL><INDENT>if verbose:<EOL><INDENT>print('<STR_LIT>' + root)<EOL><DEDENT>counters['<STR_LIT>'] += <NUM_LIT:1><EOL>for subdir in sorted(dirs):<EOL><INDENT>if self.excluded(subdir, root):<EOL><INDENT>dirs.remove(subdir)<EOL><DEDENT><DEDENT>for filename in sorted(files):<EOL><INDENT>if ((filename_match(filename, filepatterns) and<EOL>not self.excluded(filename, root))):<EOL><INDENT>runner(os.path.join(root, filename))<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Check all files in this directory and all subdirectories.", "id": "f13285:c5:m4"}
{"signature": "def print_benchmark(self):", "body": "print('<STR_LIT>' % (self.elapsed, '<STR_LIT>'))<EOL>if self.elapsed:<EOL><INDENT>for key in self._benchmark_keys:<EOL><INDENT>print('<STR_LIT>' %<EOL>(self.counters[key] / self.elapsed, key,<EOL>self.counters[key]))<EOL><DEDENT><DEDENT>", "docstring": "Print benchmark numbers.", "id": "f13285:c1:m10"}
{"signature": "def print_statistics(self, prefix='<STR_LIT>'):", "body": "for line in self.get_statistics(prefix):<EOL><INDENT>print(line)<EOL><DEDENT>", "docstring": "Print overall statistics (number of errors and warnings).", "id": "f13285:c1:m9"}
{"signature": "def compound_statements(logical_line):", "body": "line = logical_line<EOL>last_char = len(line) - <NUM_LIT:1><EOL>found = line.find('<STR_LIT::>')<EOL>while -<NUM_LIT:1> < found < last_char:<EOL><INDENT>before = line[:found]<EOL>if ((before.count('<STR_LIT:{>') <= before.count('<STR_LIT:}>') and   <EOL>before.count('<STR_LIT:[>') <= before.count('<STR_LIT:]>') and   <EOL>before.count('<STR_LIT:(>') <= before.count('<STR_LIT:)>'))):    <EOL><INDENT>lambda_kw = LAMBDA_REGEX.search(before)<EOL>if lambda_kw:<EOL><INDENT>before = line[:lambda_kw.start()].rstrip()<EOL>if before[-<NUM_LIT:1>:] == '<STR_LIT:=>' and isidentifier(before[:-<NUM_LIT:1>].strip()):<EOL><INDENT>yield <NUM_LIT:0>, (\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>break<EOL><DEDENT>if before.startswith('<STR_LIT>'):<EOL><INDENT>yield <NUM_LIT:0>, \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>yield found, \"<STR_LIT>\"<EOL><DEDENT><DEDENT>found = line.find('<STR_LIT::>', found + <NUM_LIT:1>)<EOL><DEDENT>found = line.find('<STR_LIT:;>')<EOL>while -<NUM_LIT:1> < found:<EOL><INDENT>if found < last_char:<EOL><INDENT>yield found, \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>yield found, \"<STR_LIT>\"<EOL><DEDENT>found = line.find('<STR_LIT:;>', found + <NUM_LIT:1>)<EOL><DEDENT>", "docstring": "r\"\"\"Compound statements (on the same line) are generally discouraged.\n\n    While sometimes it's okay to put an if/for/while with a small body\n    on the same line, never do this for multi-clause statements.\n    Also avoid folding such long lines!\n\n    Always use a def statement instead of an assignment statement that\n    binds a lambda expression directly to a name.\n\n    Okay: if foo == 'blah':\\n    do_blah_thing()\n    Okay: do_one()\n    Okay: do_two()\n    Okay: do_three()\n\n    E701: if foo == 'blah': do_blah_thing()\n    E701: for x in lst: total += x\n    E701: while t < 10: t = delay()\n    E701: if foo == 'blah': do_blah_thing()\n    E701: else: do_non_blah_thing()\n    E701: try: something()\n    E701: finally: cleanup()\n    E701: if foo == 'blah': one(); two(); three()\n    E702: do_one(); do_two(); do_three()\n    E703: do_four();  # useless semicolon\n    E704: def f(x): return 2*x\n    E731: f = lambda x: 2*x", "id": "f13285:m19"}
{"signature": "def init_report(self, reporter=None):", "body": "self.options.report = (reporter or self.options.reporter)(self.options)<EOL>return self.options.report<EOL>", "docstring": "Initialize the report instance.", "id": "f13285:c5:m1"}
{"signature": "def break_around_binary_operator(logical_line, tokens):", "body": "def is_binary_operator(token_type, text):<EOL><INDENT>return ((token_type == tokenize.OP or text in ['<STR_LIT>', '<STR_LIT>']) and<EOL>text not in \"<STR_LIT>\")<EOL><DEDENT>line_break = False<EOL>unary_context = True<EOL>for token_type, text, start, end, line in tokens:<EOL><INDENT>if token_type == tokenize.COMMENT:<EOL><INDENT>continue<EOL><DEDENT>if ('<STR_LIT:\\n>' in text or '<STR_LIT:\\r>' in text) and token_type != tokenize.STRING:<EOL><INDENT>line_break = True<EOL><DEDENT>else:<EOL><INDENT>if (is_binary_operator(token_type, text) and line_break and<EOL>not unary_context):<EOL><INDENT>yield start, \"<STR_LIT>\"<EOL><DEDENT>unary_context = text in '<STR_LIT>'<EOL>line_break = False<EOL><DEDENT><DEDENT>", "docstring": "r\"\"\"\n    Avoid breaks before binary operators.\n\n    The preferred place to break around a binary operator is after the\n    operator, not before it.\n\n    W503: (width == 0\\n + height == 0)\n    W503: (width == 0\\n and height == 0)\n\n    Okay: (width == 0 +\\n height == 0)\n    Okay: foo(\\n    -x)\n    Okay: foo(x\\n    [])\n    Okay: x = '''\\n''' + ''\n    Okay: foo(x,\\n    -y)\n    Okay: foo(x,  # comment\\n    -y)", "id": "f13285:m21"}
{"signature": "def normalize_paths(value, parent=os.curdir):", "body": "if not value:<EOL><INDENT>return []<EOL><DEDENT>if isinstance(value, list):<EOL><INDENT>return value<EOL><DEDENT>paths = []<EOL>for path in value.split('<STR_LIT:U+002C>'):<EOL><INDENT>path = path.strip()<EOL>if '<STR_LIT:/>' in path:<EOL><INDENT>path = os.path.abspath(os.path.join(parent, path))<EOL><DEDENT>paths.append(path.rstrip('<STR_LIT:/>'))<EOL><DEDENT>return paths<EOL>", "docstring": "Parse a comma-separated list of paths.\n\n    Return a list of absolute paths.", "id": "f13285:m32"}
{"signature": "def whitespace_around_named_parameter_equals(logical_line, tokens):", "body": "parens = <NUM_LIT:0><EOL>no_space = False<EOL>prev_end = None<EOL>annotated_func_arg = False<EOL>in_def = logical_line.startswith('<STR_LIT>')<EOL>message = \"<STR_LIT>\"<EOL>for token_type, text, start, end, line in tokens:<EOL><INDENT>if token_type == tokenize.NL:<EOL><INDENT>continue<EOL><DEDENT>if no_space:<EOL><INDENT>no_space = False<EOL>if start != prev_end:<EOL><INDENT>yield (prev_end, message)<EOL><DEDENT><DEDENT>if token_type == tokenize.OP:<EOL><INDENT>if text == '<STR_LIT:(>':<EOL><INDENT>parens += <NUM_LIT:1><EOL><DEDENT>elif text == '<STR_LIT:)>':<EOL><INDENT>parens -= <NUM_LIT:1><EOL><DEDENT>elif in_def and text == '<STR_LIT::>' and parens == <NUM_LIT:1>:<EOL><INDENT>annotated_func_arg = True<EOL><DEDENT>elif parens and text == '<STR_LIT:U+002C>' and parens == <NUM_LIT:1>:<EOL><INDENT>annotated_func_arg = False<EOL><DEDENT>elif parens and text == '<STR_LIT:=>' and not annotated_func_arg:<EOL><INDENT>no_space = True<EOL>if start != prev_end:<EOL><INDENT>yield (prev_end, message)<EOL><DEDENT><DEDENT>if not parens:<EOL><INDENT>annotated_func_arg = False<EOL><DEDENT><DEDENT>prev_end = end<EOL><DEDENT>", "docstring": "r\"\"\"Don't use spaces around the '=' sign in function arguments.\n\n    Don't use spaces around the '=' sign when used to indicate a\n    keyword argument or a default parameter value.\n\n    Okay: def complex(real, imag=0.0):\n    Okay: return magic(r=real, i=imag)\n    Okay: boolean(a == b)\n    Okay: boolean(a != b)\n    Okay: boolean(a <= b)\n    Okay: boolean(a >= b)\n    Okay: def foo(arg: int = 42):\n\n    E251: def complex(real, imag = 0.0):\n    E251: return magic(r = real, i = imag)", "id": "f13285:m15"}
{"signature": "def filename_match(filename, patterns, default=True):", "body": "if not patterns:<EOL><INDENT>return default<EOL><DEDENT>return any(fnmatch(filename, pattern) for pattern in patterns)<EOL>", "docstring": "Check if patterns contains a pattern that matches filename.\n\n    If patterns is unspecified, this always returns True.", "id": "f13285:m33"}
{"signature": "def mute_string(text):", "body": "<EOL>start = text.index(text[-<NUM_LIT:1>]) + <NUM_LIT:1><EOL>end = len(text) - <NUM_LIT:1><EOL>if text[-<NUM_LIT:3>:] in ('<STR_LIT>', \"<STR_LIT>\"):<EOL><INDENT>start += <NUM_LIT:2><EOL>end -= <NUM_LIT:2><EOL><DEDENT>return text[:start] + '<STR_LIT:x>' * (end - start) + text[end:]<EOL>", "docstring": "Replace contents with 'xxx' to prevent syntax matching.\n\n    >>> mute_string('\"abc\"')\n    '\"xxx\"'\n    >>> mute_string(\"'''abc'''\")\n    \"'''xxx'''\"\n    >>> mute_string(\"r'abc'\")\n    \"r'xxx'\"", "id": "f13285:m30"}
{"signature": "def generate_tokens(self):", "body": "if self._io_error:<EOL><INDENT>self.report_error(<NUM_LIT:1>, <NUM_LIT:0>, '<STR_LIT>' % self._io_error, readlines)<EOL><DEDENT>tokengen = tokenize.generate_tokens(self.readline)<EOL>try:<EOL><INDENT>for token in tokengen:<EOL><INDENT>if token[<NUM_LIT:2>][<NUM_LIT:0>] > self.total_lines:<EOL><INDENT>return<EOL><DEDENT>self.maybe_check_physical(token)<EOL>yield token<EOL><DEDENT><DEDENT>except (SyntaxError, tokenize.TokenError):<EOL><INDENT>self.report_invalid_syntax()<EOL><DEDENT>", "docstring": "Tokenize the file, run physical line checks and yield tokens.", "id": "f13285:c0:m9"}
{"signature": "def init_file(self, filename, lines, expected, line_offset):", "body": "self.filename = filename<EOL>self.lines = lines<EOL>self.expected = expected or ()<EOL>self.line_offset = line_offset<EOL>self.file_errors = <NUM_LIT:0><EOL>self.counters['<STR_LIT>'] += <NUM_LIT:1><EOL>self.counters['<STR_LIT>'] += len(lines)<EOL>", "docstring": "Signal a new file.", "id": "f13285:c1:m3"}
{"signature": "def python_3000_raise_comma(logical_line):", "body": "match = RAISE_COMMA_REGEX.match(logical_line)<EOL>if match and not RERAISE_COMMA_REGEX.match(logical_line):<EOL><INDENT>yield match.end() - <NUM_LIT:1>, \"<STR_LIT>\"<EOL><DEDENT>", "docstring": "r\"\"\"When raising an exception, use \"raise ValueError('message')\".\n\n    The older form is removed in Python 3.\n\n    Okay: raise DummyError(\"Message\")\n    W602: raise DummyError, \"Message\"", "id": "f13285:m26"}
{"signature": "def timezone(zone):", "body": "if zone.upper() == '<STR_LIT>':<EOL><INDENT>return utc<EOL><DEDENT>try:<EOL><INDENT>zone = ascii(zone)<EOL><DEDENT>except UnicodeEncodeError:<EOL><INDENT>raise UnknownTimeZoneError(zone)<EOL><DEDENT>zone = _unmunge_zone(zone)<EOL>if zone not in _tzinfo_cache:<EOL><INDENT>if zone in all_timezones_set:<EOL><INDENT>fp = open_resource(zone)<EOL>try:<EOL>", "docstring": "r''' Return a datetime.tzinfo implementation for the given timezone \n\n    >>> from datetime import datetime, timedelta\n    >>> utc = timezone('UTC')\n    >>> eastern = timezone('US/Eastern')\n    >>> eastern.zone\n    'US/Eastern'\n    >>> timezone(unicode('US/Eastern')) is eastern\n    True\n    >>> utc_dt = datetime(2002, 10, 27, 6, 0, 0, tzinfo=utc)\n    >>> loc_dt = utc_dt.astimezone(eastern)\n    >>> fmt = '%Y-%m-%d %H:%M:%S %Z (%z)'\n    >>> loc_dt.strftime(fmt)\n    '2002-10-27 01:00:00 EST (-0500)'\n    >>> (loc_dt - timedelta(minutes=10)).strftime(fmt)\n    '2002-10-27 00:50:00 EST (-0500)'\n    >>> eastern.normalize(loc_dt - timedelta(minutes=10)).strftime(fmt)\n    '2002-10-27 01:50:00 EDT (-0400)'\n    >>> (loc_dt + timedelta(minutes=10)).strftime(fmt)\n    '2002-10-27 01:10:00 EST (-0500)'\n\n    Raises UnknownTimeZoneError if passed an unknown zone.\n\n    >>> try:\n    ...     timezone('Asia/Shangri-La')\n    ... except UnknownTimeZoneError:\n    ...     print('Unknown')\n    Unknown\n\n    >>> try:\n    ...     timezone(unicode('\\N{TRADE MARK SIGN}'))\n    ... except UnknownTimeZoneError:\n    ...     print('Unknown')\n    Unknown", "id": "f13299:m0"}
{"signature": "def _to_seconds(td):", "body": "return td.seconds + td.days * <NUM_LIT> * <NUM_LIT> * <NUM_LIT><EOL>", "docstring": "Convert a timedelta to seconds", "id": "f13300:m3"}
{"signature": "def utcoffset(self, dt, is_dst=None):", "body": "return self._utcoffset<EOL>", "docstring": "See datetime.tzinfo.utcoffset\n\n        is_dst is ignored for StaticTzInfo, and exists only to\n        retain compatibility with DstTzInfo.", "id": "f13300:c1:m1"}
{"signature": "def plexp_inv(P, xmin, alpha, guess=<NUM_LIT:1.>):", "body": "def equation(x,prob):<EOL><INDENT>return plexp_cdf(x, xmin, alpha)-prob<EOL><DEDENT>def solver(y, x0=guess):<EOL><INDENT>return scipy.optimize.fsolve(equation, guess, args=(y,))<EOL><DEDENT>f = np.vectorize(solver)<EOL>return f(P)<EOL>", "docstring": "Inverse CDF for a piecewise PDF as defined in eqn. 3.10\nof Clauset et al.\n\n(previous version was incorrect and lead to weird discontinuities in the\ndistribution function)", "id": "f13317:m6"}
{"signature": "def alphavsks(self,autozoom=True,**kwargs):", "body": "pylab.plot(self._alpha_values, self._xmin_kstest, '<STR_LIT:.>')<EOL>pylab.errorbar(self._alpha, self._ks, xerr=self._alphaerr, fmt='<STR_LIT:+>')<EOL>ax=pylab.gca()<EOL>if autozoom:<EOL><INDENT>ax.set_ylim(<NUM_LIT>*(self._ks),<NUM_LIT:3>*(self._ks))<EOL>ax.set_xlim((self._alpha)-<NUM_LIT:5>*self._alphaerr,(self._alpha)+<NUM_LIT:5>*self._alphaerr)<EOL><DEDENT>ax.set_ylabel(\"<STR_LIT>\")<EOL>ax.set_xlabel(r'<STR_LIT>')<EOL>pylab.draw()<EOL>return ax<EOL>", "docstring": "Plot alpha versus the ks value for derived alpha.  This plot can be used\nas a diagnostic of whether you have derived the 'best' fit: if there are\nmultiple local minima, your data set may be well suited to a broken\npowerlaw or a different function.", "id": "f13317:c0:m4"}
{"signature": "def plfit(self, nosmall=True, finite=False, quiet=False, silent=False,<EOL>usefortran=False, usecy=False, xmin=None, verbose=False,<EOL>discrete=None, discrete_approx=True, discrete_n_alpha=<NUM_LIT:1000>,<EOL>skip_consistency_check=False):", "body": "x = self.data<EOL>if any(x < <NUM_LIT:0>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>z = np.sort(x)<EOL>xmins,argxmins = np.unique(z,return_index=True)<EOL>self._nunique = len(xmins)<EOL>if self._nunique == len(x) and discrete is None:<EOL><INDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>discrete = False<EOL><DEDENT>elif self._nunique < len(x) and discrete is None:<EOL><INDENT>if verbose:<EOL><INDENT>print(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>discrete = True<EOL><DEDENT>t = time.time()<EOL>if xmin is None:<EOL><INDENT>if discrete:<EOL><INDENT>self.discrete_best_alpha(approximate=discrete_approx,<EOL>n_alpha=discrete_n_alpha,<EOL>verbose=verbose,<EOL>finite=finite)<EOL>return self._xmin,self._alpha<EOL><DEDENT>elif usefortran and fortranOK:<EOL><INDENT>kstest_values,alpha_values = fplfit.plfit(z, <NUM_LIT:0>)<EOL>if not quiet:<EOL><INDENT>print((\"<STR_LIT>\" % (time.time()-t)))<EOL><DEDENT><DEDENT>elif usecy and cyOK:<EOL><INDENT>kstest_values,alpha_values = cplfit.plfit_loop(z,<EOL>nosmall=False,<EOL>zunique=xmins,<EOL>argunique=argxmins)<EOL>if not quiet:<EOL><INDENT>print((\"<STR_LIT>\" % (time.time()-t)))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>f_alpha = alpha_gen(z)<EOL>f_kstest = kstest_gen(z)<EOL>alpha_values = np.asarray(list(map(f_alpha,xmins)),<EOL>dtype='<STR_LIT:float>')<EOL>kstest_values = np.asarray(list(map(f_kstest,xmins)),<EOL>dtype='<STR_LIT:float>')<EOL>if not quiet:<EOL><INDENT>print((\"<STR_LIT>\" % (time.time()-t)))<EOL><DEDENT><DEDENT>if not quiet:<EOL><INDENT>if usefortran and not fortranOK:<EOL><INDENT>raise ImportError(\"<STR_LIT>\")<EOL><DEDENT>if usecy and not cyOK:<EOL><INDENT>raise ImportError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>sigma = (alpha_values-<NUM_LIT:1>)/np.sqrt(len(z)-argxmins)<EOL>if nosmall:<EOL><INDENT>goodvals = sigma<<NUM_LIT:0.1><EOL>nmax = argmin(goodvals)<EOL>if nmax <= <NUM_LIT:0>:<EOL><INDENT>nmax = len(xmins) - <NUM_LIT:1><EOL>if not silent:<EOL><INDENT>print(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>nmax = len(xmins)-<NUM_LIT:1><EOL><DEDENT>best_ks_index = argmin(kstest_values[:nmax])<EOL>xmin = xmins[best_ks_index]<EOL>self._alpha_values = alpha_values<EOL>self._xmin_kstest = kstest_values<EOL>if scipyOK:<EOL><INDENT>self._ks_prob_all = np.array([scipy.stats.ksone.sf(D_stat,<EOL>len(kstest_values)-ii)<EOL>for ii,D_stat in<EOL>enumerate(kstest_values)])<EOL><DEDENT>self._sigma = sigma<EOL>n = np.count_nonzero(z>=xmin)<EOL>alpha = <NUM_LIT:1.> + float(n)/sum(log(z[z>=xmin]/xmin))<EOL>try:<EOL><INDENT>if not skip_consistency_check:<EOL><INDENT>np.testing.assert_almost_equal(alpha,<EOL>alpha_values[best_ks_index],<EOL>decimal=<NUM_LIT:4>)<EOL><DEDENT><DEDENT>except AssertionError:<EOL><INDENT>raise AssertionError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>.format(alpha,<EOL>alpha_values[best_ks_index]))<EOL><DEDENT><DEDENT>z = z[z>=xmin]<EOL>n = len(z)<EOL>alpha = <NUM_LIT:1.> + float(n) / sum(log(z/xmin))<EOL>if finite:<EOL><INDENT>alpha = alpha*(n-<NUM_LIT:1.>)/n+<NUM_LIT:1.>/n<EOL><DEDENT>if n < <NUM_LIT:50> and not finite and not silent:<EOL><INDENT>print(('<STR_LIT>' % n))<EOL><DEDENT>ks = max(abs( np.arange(n)/float(n) - (<NUM_LIT:1>-(xmin/z)**(alpha-<NUM_LIT:1>)) ))<EOL>L = n*log((alpha-<NUM_LIT:1>)/xmin) - alpha*sum(log(z/xmin))<EOL>self._likelihood = L<EOL>self._xmin = xmin<EOL>self._xmins = xmins<EOL>self._alpha= alpha<EOL>self._alphaerr = (alpha-<NUM_LIT:1>)/np.sqrt(n)<EOL>self._ks = ks<EOL>if scipyOK:<EOL><INDENT>self._ks_prob = scipy.stats.ksone.sf(ks, n)<EOL><DEDENT>self._ngtx = n<EOL>if n == <NUM_LIT:1>:<EOL><INDENT>if not silent:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>self._alpha = alpha = <NUM_LIT:0><EOL>self._alphaerr = <NUM_LIT:0><EOL>self._likelihood = L = <NUM_LIT:0><EOL>self._ks = <NUM_LIT:0><EOL>self._ks_prob = <NUM_LIT:0><EOL>self._xmin = xmin<EOL>return xmin,<NUM_LIT:0><EOL><DEDENT>if np.isnan(L) or np.isnan(xmin) or np.isnan(alpha):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not quiet:<EOL><INDENT>if verbose: print(\"<STR_LIT>\", end='<STR_LIT:U+0020>')<EOL>print(\"<STR_LIT>\" % xmin, end='<STR_LIT:U+0020>')<EOL>if verbose: print(\"<STR_LIT>\", end='<STR_LIT:U+0020>')<EOL>print(\"<STR_LIT>\" % n, end='<STR_LIT:U+0020>')<EOL>if verbose: print(\"<STR_LIT>\", end='<STR_LIT:U+0020>')<EOL>print(\"<STR_LIT>\" % (alpha,self._alphaerr), end='<STR_LIT:U+0020>')<EOL>if verbose: print(\"<STR_LIT>\", end='<STR_LIT:U+0020>')<EOL>print(\"<STR_LIT>\" % L, end='<STR_LIT:U+0020>')<EOL>if verbose: print(\"<STR_LIT>\", end='<STR_LIT:U+0020>')<EOL>print(\"<STR_LIT>\" % (ks), end='<STR_LIT:U+0020>')<EOL>if scipyOK:<EOL><INDENT>if verbose: print(\"<STR_LIT>\", end='<STR_LIT:U+0020>')<EOL>print(\"<STR_LIT>\" % (self._ks_prob))<EOL><DEDENT>else:<EOL><INDENT>print()<EOL><DEDENT><DEDENT>return xmin,alpha<EOL>", "docstring": "A Python implementation of the Matlab code\nhttp://www.santafe.edu/~aaronc/powerlaws/plfit.m\nfrom http://www.santafe.edu/~aaronc/powerlaws/\n\nSee A. Clauset, C.R. Shalizi, and M.E.J. Newman, \"Power-law distributions\nin empirical data\" SIAM Review, 51, 661-703 (2009). (arXiv:0706.1062)\nhttp://arxiv.org/abs/0706.1062\n\nThere are 3 implementations of xmin estimation.  The fortran version is\nfastest, the C (cython) version is ~10% slower, and the python version\nis ~3x slower than the fortran version.  Also, the cython code suffers\n~2% numerical error relative to the fortran and python for unknown\nreasons.\n\nThere is also a discrete version implemented in python - it is\ndifferent from the continous version!\n\nParameters\n----------\ndiscrete : bool or None\n    If *discrete* is None, the code will try to determine whether the\n    data set is discrete or continous based on the uniqueness of the\n    data; if your data set is continuous but you have any non-unique\n    data points (e.g., flagged \"bad\" data), the \"automatic\"\n    determination will fail.  If *discrete* is True or False, the\n    discrete or continuous fitter will be used, respectively.\nxmin : float or int\n    If you specify xmin, the fitter will only determine alpha assuming\n    the given xmin; the rest of the code (and most of the complexity)\n    is determining an estimate for xmin and alpha.\nnosmall : bool\n    When on, the code rejects low s/n points.  WARNING: This option,\n    which is on by default, may result in different answers than the\n    original Matlab code and the \"powerlaw\" python package\nfinite : bool\n    There is a 'finite-size bias' to the estimator.  The \"alpha\" the\n    code measures is \"alpha-hat\" s.t. \u03b1\u0342 = (n\u03b1-1)/(n-1), or \u03b1 = (1 + \u03b1\u0342\n    (n-1)) / n\nquiet : bool\n    If False, delivers messages about what fitter is used and the fit\n    results\nverbose : bool\n    Deliver descriptive messages about the fit parameters (only if\n    `quiet==False`)\nsilent : bool\n    If True, will print NO messages\nskip_consistency_check : bool\n    The code will normally perform a consistency check to make sure the\n    alpha value computed by the fitter matches the alpha value computed\n    directly in python.  It is possible for numerical differences to\n    creep in, usually at the 10^-6 or less level.  If you see an\n    exception reporting this type of error, skipping the check can be\n    the appropriate next step.\n\nReturns\n-------\n(xmin, alpha)\nThe best-fit xmin and alpha values", "id": "f13317:c0:m1"}
{"signature": "def __init__(self,x,**kwargs):", "body": "x = np.array(x) <EOL>if (x<<NUM_LIT:0>).sum() > <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\" % ((x<<NUM_LIT:0>).sum()))<EOL>x = x[x><NUM_LIT:0>]<EOL><DEDENT>self.data = x<EOL>self.plfit(**kwargs)<EOL>", "docstring": "Initializes and fits the power law.  Can pass \"quiet\" to turn off\noutput (except for warnings; \"silent\" turns off warnings)", "id": "f13317:c0:m0"}
{"signature": "def plot_lognormal_cdf(self,**kwargs):", "body": "if not hasattr(self,'<STR_LIT>'):<EOL><INDENT>return<EOL><DEDENT>x=np.sort(self.data)<EOL>n=len(x)<EOL>xcdf = np.arange(n,<NUM_LIT:0>,-<NUM_LIT:1>,dtype='<STR_LIT:float>')/float(n)<EOL>lcdf = self.lognormal_dist.sf(x)<EOL>D_location = argmax(xcdf-lcdf)<EOL>pylab.vlines(x[D_location],xcdf[D_location],lcdf[D_location],color='<STR_LIT:m>',linewidth=<NUM_LIT:2>)<EOL>pylab.plot(x, lcdf,'<STR_LIT:U+002C>',**kwargs)<EOL>", "docstring": "Plot the fitted lognormal distribution", "id": "f13317:c0:m11"}
{"signature": "def pl_inv(P,xm,a):", "body": "x = (<NUM_LIT:1>-P)**(<NUM_LIT:1>/(<NUM_LIT:1>-a)) * xm<EOL>return x<EOL>", "docstring": "Inverse CDF for a pure power-law", "id": "f13317:m7"}
{"signature": "def sigma(alpha, n):", "body": "return (alpha-<NUM_LIT:1.>) / n**<NUM_LIT:0.5><EOL>", "docstring": "Clauset et al 2007 equation 3.2:\n    sigma = (alpha-1)/sqrt(n)", "id": "f13317:m2"}
{"signature": "def xminvsks(self, **kwargs):", "body": "pylab.plot(self._xmins,self._xmin_kstest,'<STR_LIT:.>')<EOL>pylab.plot(self._xmin,self._ks,'<STR_LIT:s>')<EOL>ax=pylab.gca()<EOL>ax.set_ylabel(\"<STR_LIT>\")<EOL>ax.set_xlabel(\"<STR_LIT>\")<EOL>pylab.draw()<EOL>return ax<EOL>", "docstring": "Plot xmin versus the ks value for derived alpha.  This plot can be used\nas a diagnostic of whether you have derived the 'best' fit: if there are\nmultiple local minima, your data set may be well suited to a broken\npowerlaw or a different function.", "id": "f13317:c0:m3"}
{"signature": "def most_likely_alpha(data, xmin, alpharange=(<NUM_LIT>,<NUM_LIT>), n_alpha=<NUM_LIT>):", "body": "alpha_vector = np.linspace(alpharange[<NUM_LIT:0>],alpharange[<NUM_LIT:1>],n_alpha)<EOL>return alpha_vector[discrete_max_likelihood_arg(data, xmin,<EOL>alpharange=alpharange,<EOL>n_alpha=n_alpha)]<EOL>", "docstring": "Return the most likely alpha for the data given an xmin", "id": "f13317:m13"}
{"signature": "def plexp(x,xm=<NUM_LIT:1>,a=<NUM_LIT>):", "body": "C = <NUM_LIT:1>/(-xm/(<NUM_LIT:1> - a) - xm/a + math.exp(a)*xm/a)<EOL>Ppl = lambda X: <NUM_LIT:1>+C*(xm/(<NUM_LIT:1>-a)*(X/xm)**(<NUM_LIT:1>-a))<EOL>Pexp = lambda X: C*xm/a*math.exp(a)-C*(xm/a)*math.exp(-a*(X/xm-<NUM_LIT:1>))<EOL>d=Ppl(x)<EOL>d[x<xm]=Pexp(x)<EOL>return d<EOL>", "docstring": "CDF(x) for the piecewise distribution exponential x<xmin, powerlaw x>=xmin\nThis is the CDF version of the distributions drawn in fig 3.4a of Clauset et al.", "id": "f13318:m0"}
{"signature": "def pl_inv(P,xm,a):", "body": "x = (<NUM_LIT:1>-P)**(<NUM_LIT:1>/(<NUM_LIT:1>-a)) * xm<EOL>return x<EOL>", "docstring": "Inverse CDF for a pure power-law", "id": "f13318:m2"}
{"signature": "def plexp_inv(P,xm,a):", "body": "C = <NUM_LIT:1>/(-xm/(<NUM_LIT:1> - a) - xm/a + math.exp(a)*xm/a)<EOL>Pxm = <NUM_LIT:1>+C*(xm/(<NUM_LIT:1>-a))<EOL>pp = P<EOL>x = xm*(pp-<NUM_LIT:1>)*(<NUM_LIT:1>-a)/(C*xm)**(<NUM_LIT:1>/(<NUM_LIT:1>-a)) if pp >= Pxm else (math.log( ((C*xm/a)*math.exp(a)-pp)/(C*xm/a)) - a) * (-xm/a)<EOL>return x<EOL>", "docstring": "Inverse CDF for a piecewise PDF as defined in eqn. 3.10\nof Clauset et al.", "id": "f13318:m1"}
{"signature": "def __init__(self,x,**kwargs):", "body": "neg = [i<<NUM_LIT:0> for i in x]<EOL>if any(neg) > <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\" % (sum(neg)))<EOL>x = [i for i in x if i > <NUM_LIT:0>]<EOL><DEDENT>self.data = x<EOL>self.plfit(**kwargs)<EOL>", "docstring": "Initializes and fits the power law.  Can pass \"quiet\" to turn off \noutput (except for warnings; \"silent\" turns off warnings)", "id": "f13318:c0:m0"}
{"signature": "def alpha_(self,x):", "body": "def alpha(xmin,x=x):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>x = [i for i in x if i>=xmin]<EOL>n = sum(x)<EOL>divsum = sum([math.log(i/xmin) for i in x])<EOL>if divsum == <NUM_LIT:0>:<EOL><INDENT>return float('<STR_LIT>')<EOL><DEDENT>a = <NUM_LIT:1> + float(n) / divsum<EOL>return a<EOL><DEDENT>return alpha<EOL>", "docstring": "Create a mappable function alpha to apply to each xmin in a list of xmins.\n        This is essentially the slow version of fplfit/cplfit, though I bet it could\n        be speeded up with a clever use of parellel_map.  Not intended to be used by users.", "id": "f13318:c0:m1"}
{"signature": "def plfit(x,nosmall=False,finite=False):", "body": "xmins = unique(x)<EOL>xmins = xmins[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL>dat = xmins * <NUM_LIT:0> <EOL>z = sort(x)<EOL>for xm in arange(len(xmins)):<EOL><INDENT>xmin = xmins[xm]<EOL>z    = z[z>=xmin] <EOL>n    = float(len(z))<EOL>a    =  n / sum( log(z/xmin) )<EOL>if nosmall:<EOL><INDENT>if (a-<NUM_LIT:1>)/sqrt(n) > <NUM_LIT:0.1>:<EOL><INDENT>dat = dat[:xm]<EOL>xm = len(xmins)+<NUM_LIT:1><EOL>break<EOL><DEDENT><DEDENT>cx   = arange(n)/float(n)  <EOL>cf   = <NUM_LIT:1>-(xmin/z)**a  <EOL>dat[xm] = max( abs(cf-cx) )<EOL><DEDENT>D     = min(dat);<EOL>xmin  = xmins[argmin(dat)]<EOL>z     = x[x>=xmin]<EOL>n     = len(z)<EOL>alpha = <NUM_LIT:1> + n / sum( log(z/xmin) )<EOL>if finite:<EOL><INDENT>alpha = alpha*(n-<NUM_LIT:1>)/n+<NUM_LIT:1>/n<EOL><DEDENT>if n < <NUM_LIT:50> and ~finite:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>L = n*log((alpha-<NUM_LIT:1>)/xmin) - alpha*sum(log(z/xmin));<EOL>return xmin,alpha,L,dat<EOL>", "docstring": "A Python implementation of the Matlab code http://www.santafe.edu/~aaronc/powerlaws/plfit.m\nfrom http://www.santafe.edu/~aaronc/powerlaws/\n\nSee A. Clauset, C.R. Shalizi, and M.E.J. Newman, \"Power-law distributions\nin empirical data\" SIAM Review, to appear (2009). (arXiv:0706.1062)\nhttp://arxiv.org/abs/0706.1062", "id": "f13320:m1"}
{"signature": "async def on_application_shutdown(self, application: Application):", "body": "", "docstring": "Handler run at Application shutdown.\n\n        This must be a coroutine.\n\n        Subclasses can implement this to perform operations as part of\n        Application.on_shutdown handler.", "id": "f13328:c0:m5"}
{"signature": "def _configure_registry(self, include_process_stats: bool = False):", "body": "if include_process_stats:<EOL><INDENT>self.registry.register_additional_collector(<EOL>ProcessCollector(registry=None))<EOL><DEDENT>", "docstring": "Configure the MetricRegistry.", "id": "f13328:c0:m11"}
{"signature": "def _get_exporter(self, args: argparse.Namespace) -> PrometheusExporter:", "body": "exporter = PrometheusExporter(<EOL>self.name, self.description, args.host, args.port, self.registry)<EOL>exporter.app.on_startup.append(self.on_application_startup)<EOL>exporter.app.on_shutdown.append(self.on_application_shutdown)<EOL>return exporter<EOL>", "docstring": "Return a :class:`PrometheusExporter` configured with args.", "id": "f13328:c0:m12"}
{"signature": "def create_metrics(self,<EOL>configs: Iterable[MetricConfig]) -> Dict[str, Metric]:", "body": "metrics: Dict[str, Metric] = {<EOL>config.name: self._register_metric(config)<EOL>for config in configs<EOL>}<EOL>self._metrics.update(metrics)<EOL>return metrics<EOL>", "docstring": "Create Prometheus metrics from a list of MetricConfigs.", "id": "f13330:c3:m1"}
{"signature": "def get_metrics(self) -> Dict[str, Metric]:", "body": "return self._metrics.copy()<EOL>", "docstring": "Return a dict mapping names to metrics.", "id": "f13330:c3:m3"}
{"signature": "def run(self):", "body": "run_app(<EOL>self.app,<EOL>host=self.host,<EOL>port=self.port,<EOL>print=lambda *args, **kargs: None,<EOL>access_log_format='<STR_LIT>')<EOL>", "docstring": "Run the :class:`aiohttp.web.Application` for the exporter.", "id": "f13331:c0:m2"}
{"signature": "def set_metric_update_handler(self, handler: UpdateHandler):", "body": "self._update_handler = handler<EOL>", "docstring": "Set a handler to update metrics.\n\n        The provided coroutine function is called at every request with a dict\n        as argument, mapping metric names to metrics.  The signature is the\n        following:\n\n          async def update_handler(metrics):", "id": "f13331:c0:m1"}
{"signature": "def validate_json_request(required_fields):", "body": "def decorator(func):<EOL><INDENT>@wraps(func)<EOL>def wrapped_func(request, *args, **kwargs):<EOL><INDENT>try:<EOL><INDENT>request_dict = json.loads(request.raw_post_data)<EOL><DEDENT>except ValueError as e:<EOL><INDENT>return JsonResponseBadRequest('<STR_LIT>' % e)<EOL><DEDENT>for k in required_fields:<EOL><INDENT>if k not in request_dict:<EOL><INDENT>return JsonResponseBadRequest(<EOL>'<STR_LIT>' % k)<EOL><DEDENT><DEDENT>return func(request, request_dict, *args, **kwargs)<EOL><DEDENT>return wrapped_func<EOL><DEDENT>return decorator<EOL>", "docstring": "Return a decorator that ensures that the request passed to the view\nfunction/method has a valid JSON request body with the given required\nfields.  The dict parsed from the JSON is then passed as the second\nargument to the decorated function/method.  For example:\n\n@json_request({'name', 'date'})\ndef view_func(request, request_dict):\n    ...", "id": "f13334:m3"}
{"signature": "def api_accepts(fields):", "body": "def decorator(func):<EOL><INDENT>@wraps(func)<EOL>def wrapped_func(request, *args, **kwargs):<EOL><INDENT>if request.method not in ['<STR_LIT:GET>', '<STR_LIT:POST>']:<EOL><INDENT>return func(request, *args, **kwargs)<EOL><DEDENT>form_class = type('<STR_LIT>', (forms.Form,), fields.copy())<EOL>form = form_class(getattr(request, request.method))<EOL>if not form.is_valid():<EOL><INDENT>if settings.DEBUG:<EOL><INDENT>return JsonResponseBadRequest(<EOL>'<STR_LIT>' % dict(form.errors)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>logger.warn(<EOL>'<STR_LIT>',<EOL>request.path,<EOL>dict(form.errors)<EOL>)<EOL>return func(request, *args, **kwargs)<EOL><DEDENT><DEDENT>for (field_name, field_instance) in fields.items():<EOL><INDENT>if isinstance(field_instance, models.Model):<EOL><INDENT>field_type = type(field_instance)<EOL>field_id = '<STR_LIT>' % field_name<EOL>if field_id not in request.REQUEST:<EOL><INDENT>return JsonResponseBadRequest(<EOL>'<STR_LIT>' % field_name<EOL>)<EOL><DEDENT>field_pk = int(request.REQUEST[field_id])<EOL>try:<EOL><INDENT>field_value = field_type.objects.get(pk=field_pk)<EOL><DEDENT>except field_type.DoesNotExist:<EOL><INDENT>return JsonResponseNotFound(<EOL>'<STR_LIT>' % (<EOL>field_type, field_pk<EOL>)<EOL>)<EOL><DEDENT>form.cleaned_data[field_name] = field_value<EOL><DEDENT><DEDENT>validated_request = ValidatedRequest(request, form)<EOL>return func(validated_request, *args, **kwargs)<EOL><DEDENT>return wrapped_func<EOL><DEDENT>return decorator<EOL>", "docstring": "Define the accept schema of an API (GET or POST).\n\n'fields' is a dict of Django form fields keyed by field name that specifies\nthe form-urlencoded fields that the API accepts*.\n\nThe view function is then called with GET/POST data that has been cleaned\nby the Django form.\n\nIn debug and test modes, failure to validate the fields will result in a\n400 Bad Request response.\nIn production mode, failure to validate will just log a\nwarning, unless overwritten by a 'strict' setting.\n\nFor example:\n\n@api_accepts({\n    'x': forms.IntegerField(min_value=0),\n    'y': forms.IntegerField(min_value=0),\n})\ndef add(request, *args, **kwargs):\n    x = request.POST['x']\n    y = request.POST['y']\n\n    # x and y are integers already.\n    return HttpResponse('%d' % (x + y))\n\n\n*: 'fields' can also include Django models as {'key': Model()}. If present,\napi_accepts will look for the field keyed by '<key>-id'\nand pick the object that has that primary key. For example, if the entry is\n{'course': Course()}, it will search for the key course_id='course-id' in\nthe request object, and find the object Course.objects.get(pk=course_id)", "id": "f13334:m0"}
{"signature": "def listcoins(self):", "body": "url = self.API_PATH + '<STR_LIT>'<EOL>json_data = json.loads(self._getdata(url))<EOL>coins = []<EOL>for entry in json_data:<EOL><INDENT>coin = Coin()<EOL>coin.id = entry['<STR_LIT:id>']<EOL>coin.name = entry['<STR_LIT:name>']<EOL>coin.website = entry['<STR_LIT>']<EOL>coin.price_btc = entry['<STR_LIT>']<EOL>coin.volume_btc = entry['<STR_LIT>']<EOL>coins.append(coin)<EOL><DEDENT>return coins<EOL>", "docstring": "Use this function to list all coins with their data which are available on cryptocoincharts.\nUsage: http://api.cryptocoincharts.info/listCoins", "id": "f13342:c0:m0"}
{"signature": "def _getdata(self, url, data = \"<STR_LIT>\"):", "body": "request = Request(url)<EOL>if data != \"<STR_LIT>\":<EOL><INDENT>request = Request(url, urlencode(data))<EOL><DEDENT>try:<EOL><INDENT>response = urlopen(request)<EOL><DEDENT>except HTTPError as e:<EOL><INDENT>print('<STR_LIT>')<EOL>print('<STR_LIT>', e.code)<EOL><DEDENT>except URLError as e:<EOL><INDENT>print('<STR_LIT>')<EOL>print('<STR_LIT>', e.code)<EOL><DEDENT>else:<EOL><INDENT>return response.read()<EOL><DEDENT>", "docstring": "Wrapper method", "id": "f13342:c0:m4"}
{"signature": "def consistency(self, desired_version=None, include_package=False,<EOL>strictness=None):", "body": "keys_to_check = list(self.versions.keys())<EOL>if not include_package and '<STR_LIT>' in keys_to_check:<EOL><INDENT>keys_to_check.remove('<STR_LIT>')<EOL><DEDENT>if desired_version is None:<EOL><INDENT>try:<EOL><INDENT>desired_version = self.versions['<STR_LIT>']<EOL><DEDENT>except KeyError:<EOL><INDENT>desired_version = self.versions[keys_to_check[<NUM_LIT:0>]]<EOL><DEDENT><DEDENT>if strictness is None:<EOL><INDENT>strictness = self.strictness<EOL><DEDENT>desired = self._version(desired_version, strictness)<EOL>error_keys = []<EOL>for key in keys_to_check:<EOL><INDENT>test = self._version(self.versions[key], strictness)<EOL>if test != desired:<EOL><INDENT>error_keys += [key]<EOL><DEDENT><DEDENT>msg = \"<STR_LIT>\"<EOL>for key in error_keys:<EOL><INDENT>msg += \"<STR_LIT>\".format(<EOL>d=str(desired),<EOL>v=str(self.versions[key]),<EOL>k=str(key)<EOL>)<EOL><DEDENT>return msg<EOL>", "docstring": "Checks that the versions are consistent\n\n        Parameters\n        ----------\n        desired_version: str\n            optional; the version that all of these should match\n        include_package: bool\n            whether to check the special 'package' version for consistency\n            (default False)\n        strictness: str", "id": "f13346:c0:m2"}
{"signature": "def __call__(self, method, *args, **kwargs):", "body": "self.output.write(str(method.__name__) + \"<STR_LIT>\")<EOL>msg = method(*args, **kwargs)<EOL>fail = <NUM_LIT:0><EOL>if bool(msg):<EOL><INDENT>fail = <NUM_LIT:1><EOL>self.output.write(\"<STR_LIT>\")<EOL>self.output.write(self.wrapper.fill(msg) + '<STR_LIT:\\n>')<EOL><DEDENT>else:<EOL><INDENT>self.output.write(\"<STR_LIT>\")<EOL><DEDENT>return fail<EOL>", "docstring": "Generic method to turn other methods into tests.", "id": "f13349:c0:m1"}
{"signature": "async def user_from_token(self, token: str) -> User:", "body": "return await User.from_token(self, token)<EOL>", "docstring": "Create a user session from a token.\n\n        This code is equivelent to `User.from_token(client, token)`\n\n        Parameters\n        ----------\n        token : str\n            The token to attatch the user session to.\n\n        Returns\n        -------\n        user : User\n            The user from the ID", "id": "f13358:c0:m6"}
{"signature": "def oauth2_url(self, redirect_uri: str, scope: Optional[str] = None, state: Optional[str] = None) -> str:", "body": "return OAuth2.url_(self.http.client_id, redirect_uri, scope=scope, state=state)<EOL>", "docstring": "Generate an outh2 url for user authentication.\n\n        Parameters\n        ----------\n        redirect_uri : str\n            Where spotify should redirect the user to after authentication.\n        scope : Optional[str]\n            Space seperated spotify scopes for different levels of access.\n        state : Optional[str]\n            Using a state value can increase your assurance that an incoming connection is the result of an authentication request.\n\n        Returns\n        -------\n        url : str\n            The OAuth2 url.", "id": "f13358:c0:m4"}
{"signature": "async def get_tracks(self, *, limit=<NUM_LIT:20>, offset=<NUM_LIT:0>) -> List[Track]:", "body": "data = await self.user.http.saved_tracks(limit=limit, offset=offset)<EOL>return [Track(self.__client, item['<STR_LIT>']) for item in data['<STR_LIT>']]<EOL>", "docstring": "Get a list of the songs saved in the current Spotify user\u2019s \u2018Your Music\u2019 library.\n\n        Parameters\n        ----------\n        limit : Optional[int]\n            The maximum number of items to return. Default: 20. Minimum: 1. Maximum: 50.\n        offset : Optional[int]\n            The index of the first item to return. Default: 0", "id": "f13360:c0:m6"}
{"signature": "async def contains_albums(self, *albums: Sequence[Union[str, Album]]) -> List[bool]:", "body": "_albums = [(obj if isinstance(obj, str) else obj.id) for obj in albums]<EOL>return await self.user.http.is_saved_album(_albums)<EOL>", "docstring": "Check if one or more albums is already saved in the current Spotify user\u2019s \u2018Your Music\u2019 library.\n\n        Parameters\n        ----------\n        albums : Union[Album, str]\n            A sequence of artist objects or spotify IDs", "id": "f13360:c0:m4"}
{"signature": "def audio_analysis(self):", "body": "return self.__client.http.track_audio_analysis(self.id)<EOL>", "docstring": "Get a detailed audio analysis for the track.", "id": "f13361:c0:m2"}
{"signature": "async def set_repeat(self, state, *, device: Optional[SomeDevice] = None):", "body": "await self._user.http.repeat_playback(state, device_id=str(device))<EOL>", "docstring": "Set the repeat mode for the user\u2019s playback.\n\n        Parameters\n        ----------\n        state : str\n            Options are repeat-track, repeat-context, and off\n        device : Optional[:obj:`SomeDevice`]\n            The Device object or id of the device this command is targeting.\n            If not supplied, the user\u2019s currently active device is the target.", "id": "f13362:c0:m6"}
{"signature": "async def pause(self, *, device: Optional[SomeDevice] = None):", "body": "await self._user.http.pause_playback(device_id=str(device))<EOL>", "docstring": "Pause playback on the user\u2019s account.\n\n        Parameters\n        ----------\n        device : Optional[:obj:`SomeDevice`]\n            The Device object or id of the device this command is targeting.\n            If not supplied, the user\u2019s currently active device is the target.", "id": "f13362:c0:m3"}
{"signature": "async def set_volume(self, volume: int, *, device: Optional[SomeDevice] = None):", "body": "await self._user.http.set_playback_volume(volume, device_id=str(device))<EOL>", "docstring": "Set the volume for the user\u2019s current playback device.\n\n        Parameters\n        ----------\n        volume : int\n            The volume to set. Must be a value from 0 to 100 inclusive.\n        device : Optional[:obj:`SomeDevice`]\n            The Device object or id of the device this command is targeting.\n            If not supplied, the user\u2019s currently active device is the target.", "id": "f13362:c0:m7"}
{"signature": "async def resume(self, *, device: Optional[SomeDevice] = None):", "body": "await self._user.http.play_playback(None, device_id=str(device))<EOL>", "docstring": "Resume playback on the user's account.\n\n        Parameters\n        ----------\n        device : Optional[:obj:`SomeDevice`]\n            The Device object or id of the device this command is targeting.\n            If not supplied, the user\u2019s currently active device is the target.", "id": "f13362:c0:m4"}
{"signature": "async def get_all_tracks(self) -> List[PlaylistTrack]:", "body": "if isinstance(self._tracks, PartialTracks):<EOL><INDENT>return await self._tracks.build()<EOL><DEDENT>_tracks = []<EOL>offset = <NUM_LIT:0><EOL>while len(self.tracks) < self.total_tracks:<EOL><INDENT>data = await self.__client.http.get_playlist_tracks(self.owner.id, self.id, limit=<NUM_LIT:50>, offset=offset)<EOL>_tracks += [PlaylistTrack(self.__client, item) for item in data['<STR_LIT>']]<EOL>offset += <NUM_LIT:50><EOL><DEDENT>self.total_tracks = len(self._tracks)<EOL>return list(self._tracks)<EOL>", "docstring": "Get all playlist tracks from the playlist.\n\n        Returns\n        -------\n        tracks : List[PlaylistTrack]\n            The playlists tracks.", "id": "f13363:c1:m2"}
{"signature": "async def top_artists(self, **data) -> List[Artist]:", "body": "return await self._get_top(Artist, data)<EOL>", "docstring": "Get the current user\u2019s top artists based on calculated affinity.\n\n        Parameters\n        ----------\n        limit : Optional[int]\n            The number of entities to return. Default: 20. Minimum: 1. Maximum: 50.\n        offset : Optional[int]\n            The index of the first entity to return. Default: 0\n        time_range : Optional[str]\n            Over what time frame the affinities are computed. (long_term, short_term, medium_term)\n\n        Returns\n        -------\n        tracks : List[Artist]\n            The top artists for the user.", "id": "f13368:c0:m19"}
{"signature": "@ensure_http<EOL><INDENT>async def get_player(self) -> Player:<DEDENT>", "body": "self._player = player = Player(self.__client, self, await self.http.current_player())<EOL>return player<EOL>", "docstring": "Get information about the users current playback.\n\n        Returns\n        -------\n        player : Player\n            A player object representing the current playback.", "id": "f13368:c0:m9"}
{"signature": "async def get_playlists(self, *, limit=<NUM_LIT:20>, offset=<NUM_LIT:0>):", "body": "if hasattr(self, '<STR_LIT:http>'):<EOL><INDENT>http = self.http<EOL><DEDENT>else:<EOL><INDENT>http = self.__client.http<EOL><DEDENT>data = await http.get_playlists(self.id, limit=limit, offset=offset)<EOL>return [Playlist(self.__client, playlist_data) for playlist_data in data['<STR_LIT>']]<EOL>", "docstring": "get the users playlists from spotify.\n\n        Parameters\n        ----------\n         limit : Optional[int]\n             The limit on how many playlists to retrieve for this user (default is 20).\n         offset : Optional[int]\n             The offset from where the api should start from in the playlists.\n\n        Returns\n        -------\n        playlists : List[Playlist]\n            A list of the users playlists.", "id": "f13368:c0:m18"}
{"signature": "@ensure_http<EOL><INDENT>async def get_devices(self) -> List[Device]:<DEDENT>", "body": "data = await self.http.available_devices()<EOL>return [Device(item) for item in data['<STR_LIT>']]<EOL>", "docstring": "Get information about the users avaliable devices.\n\n        Returns\n        -------\n        devices : List[Device]\n            The devices the user has available.", "id": "f13368:c0:m10"}
{"signature": "async def top_tracks(self, **data) -> List[Track]:", "body": "return await self._get_top(Track, data)<EOL>", "docstring": "Get the current user\u2019s top tracks based on calculated affinity.\n\n        Parameters\n        ----------\n        limit : Optional[int]\n            The number of entities to return. Default: 20. Minimum: 1. Maximum: 50.\n        offset : Optional[int]\n            The index of the first entity to return. Default: 0\n        time_range : Optional[str]\n            Over what time frame the affinities are computed. (long_term, short_term, medium_term)\n\n        Returns\n        -------\n        tracks : List[Track]\n            The top tracks for the user.", "id": "f13368:c0:m20"}
{"signature": "async def get_albums(self, *, limit: Optional[int] = <NUM_LIT:20>, offset: Optional[int] = <NUM_LIT:0>, include_groups=None, market: Optional[str] = None) -> List[Album]:", "body": "from .album import Album<EOL>data = await self.__client.http.artist_albums(self.id, limit=limit, offset=offset, include_groups=include_groups, market=market)<EOL>return list(Album(self.__client, item) for item in data['<STR_LIT>'])<EOL>", "docstring": "Get the albums of a Spotify artist.\n\n        Parameters\n        ----------\n        limit : Optional[int]\n            The maximum number of items to return. Default: 20. Minimum: 1. Maximum: 50.\n        offset : Optiona[int]\n            The offset of which Spotify should start yielding from.\n        include_groups : INCLUDE_GROUPS_TP\n            INCLUDE_GROUPS\n        market : Optional[str]\n            An ISO 3166-1 alpha-2 country code.\n\n        Returns\n        -------\n        albums : List[Album]\n            The albums of the artist.", "id": "f13369:c0:m2"}
{"signature": "def following_artists_or_users(self, ids, *, type='<STR_LIT>'):", "body": "route = Route('<STR_LIT:GET>', '<STR_LIT>')<EOL>payload = {'<STR_LIT>': ids, '<STR_LIT:type>': type}<EOL>return self.request(route, params=payload)<EOL>", "docstring": "Check to see if the current user is following one or more artists or other Spotify users.\n\n        Parameters\n        ----------\n        ids : List[str]\n            A comma-separated list of the artist or the user Spotify IDs to check.\n            A maximum of 50 IDs can be sent in one request.\n        type : Optional[str]\n            The ID type: either \"artist\" or \"user\".\n            Default: \"artist\"", "id": "f13374:c1:m18"}
{"signature": "def category_playlists(self, category_id, limit=<NUM_LIT:20>, offset=<NUM_LIT:0>, country=None):", "body": "route = Route('<STR_LIT:GET>', '<STR_LIT>', category_id=category_id)<EOL>payload = {'<STR_LIT>': limit, '<STR_LIT>': offset}<EOL>if country:<EOL><INDENT>payload['<STR_LIT>'] = country<EOL><DEDENT>return self.request(route, params=payload)<EOL>", "docstring": "Get a list of Spotify playlists tagged with a particular category.\n\n        Parameters\n        ----------\n        category_id : str\n            The Spotify category ID for the category.\n        limit : Optional[int]\n            The maximum number of items to return. Default: 20. Minimum: 1. Maximum: 50.\n        offset : Optional[int]\n            The index of the first item to return. Default: 0\n        country : COUNTRY_TP\n            COUNTRY", "id": "f13374:c1:m13"}
{"signature": "def album(self, spotify_id, market='<STR_LIT>'):", "body": "route = Route('<STR_LIT:GET>', '<STR_LIT>', spotify_id=spotify_id)<EOL>payload = {}<EOL>if market:<EOL><INDENT>payload['<STR_LIT>'] = market<EOL><DEDENT>return self.request(route, params=payload)<EOL>", "docstring": "Get a spotify album by its ID.\n\n        Parameters\n        ----------\n        spotify_id : str\n            The spotify_id to search by.\n        market : Optional[str]\n            An ISO 3166-1 alpha-2 country code.\n\n        Returns\n        -------\n        album : Dict\n            The album object.", "id": "f13374:c1:m4"}
{"signature": "def album_tracks(self, spotify_id, limit=<NUM_LIT:20>, offset=<NUM_LIT:0>, market='<STR_LIT>'):", "body": "route = Route('<STR_LIT:GET>', '<STR_LIT>', spotify_id=spotify_id)<EOL>payload = {'<STR_LIT>': limit, '<STR_LIT>': offset}<EOL>if market:<EOL><INDENT>payload['<STR_LIT>'] = market<EOL><DEDENT>return self.request(route, params=payload)<EOL>", "docstring": "Get an albums tracks by an ID.\n\n        Parameters\n        ----------\n        spotify_id : str\n            The spotify_id to search by.\n        limit : Optional[int]\n            The maximum number of items to return. Default: 20. Minimum: 1. Maximum: 50.\n        offset : Optiona[int]\n            The offset of which Spotify should start yielding from.\n        market : Optional[str]\n            An ISO 3166-1 alpha-2 country code.", "id": "f13374:c1:m5"}
{"signature": "def categories(self, limit=<NUM_LIT:20>, offset=<NUM_LIT:0>, country=None, locale=None):", "body": "route = Route('<STR_LIT:GET>', '<STR_LIT>')<EOL>payload = {'<STR_LIT>': limit, '<STR_LIT>': offset}<EOL>if country:<EOL><INDENT>payload['<STR_LIT>'] = country<EOL><DEDENT>if locale:<EOL><INDENT>payload['<STR_LIT>'] = locale<EOL><DEDENT>return self.request(route, params=payload)<EOL>", "docstring": "Get a list of categories used to tag items in Spotify.\n\n        Parameters\n        ----------\n        limit : Optional[int]\n            The maximum number of items to return. Default: 20. Minimum: 1. Maximum: 50.\n        offset : Optional[int]\n            The index of the first item to return. Default: 0\n        country : COUNTRY_TP\n            COUNTRY\n        locale : LOCALE_TP\n            LOCALE", "id": "f13374:c1:m14"}
{"signature": "@staticmethod<EOL><INDENT>def url_only(*args, **kwargs):<DEDENT>", "body": "return OAuth2.url_(*args, **kwargs)<EOL>", "docstring": "Construct a OAuth2 URL instead of an OAuth2 object.", "id": "f13375:c0:m5"}
{"signature": "@property<EOL><INDENT>def url(self) -> str:<DEDENT>", "body": "return self._BASE.format(parameters=self.parameters)<EOL>", "docstring": "Return a URL for an OAuth2.", "id": "f13375:c0:m8"}
{"signature": "def assert_hasattr(attr: str, msg: str, tp: BaseException = SpotifyException) -> Callable:", "body": "def decorator(func: Callable) -> Callable:<EOL><INDENT>@functools.wraps(func)<EOL>def decorated(self, *args, **kwargs):<EOL><INDENT>if not hasattr(self, attr):<EOL><INDENT>raise tp(msg)<EOL><DEDENT>return func(self, *args, **kwargs)<EOL><DEDENT>if inspect.iscoroutinefunction(func):<EOL><INDENT>@functools.wraps(func)<EOL>async def decorated(*args, **kwargs):<EOL><INDENT>return await decorated(*args, **kwargs)<EOL><DEDENT><DEDENT>return decorated<EOL><DEDENT>return decorator<EOL>", "docstring": "decorator to assert an object has an attribute when run.", "id": "f13375:m2"}
{"signature": "def to_id(string: str) -> str:", "body": "string = string.strip()<EOL>match = _URI_RE.match(string)<EOL>if match is None:<EOL><INDENT>match = _OPEN_RE.match(string)<EOL>if match is None:<EOL><INDENT>return string<EOL><DEDENT>else:<EOL><INDENT>return match.group(<NUM_LIT:2>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return match.group(<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Get a spotify ID from a URI or open.spotify URL.\n\n    Paramters\n    ---------\n    string : str\n        The string to operate on.\n\n    Returns\n    -------\n    id : str\n        The Spotify ID from the string.", "id": "f13375:m1"}
{"signature": "@property<EOL><INDENT>def current_item(self):<DEDENT>", "body": "return self._get_current_item(self)<EOL>", "docstring": "Get the current active navigation Item if any.\n\n        .. versionadded:: 0.2.0", "id": "f13405:c0:m4"}
{"signature": "@property<EOL><INDENT>def is_internal(self):<DEDENT>", "body": "return self._url is None<EOL>", "docstring": "``True`` if the target url is internal of current app.", "id": "f13408:c0:m6"}
{"signature": "@property<EOL><INDENT>def ident(self):<DEDENT>", "body": "return ItemReference(self.endpoint, self.args)<EOL>", "docstring": "The identity of this item.\n\n        :type: :class:`~flask.ext.navigation.Navigation.ItemReference`", "id": "f13408:c0:m8"}
{"signature": "@property<EOL><INDENT>def is_active(self):<DEDENT>", "body": "return bool(request and self.is_current)<EOL>", "docstring": "``True`` if the item should be presented as active, and ``False``\n        always if the request context is not bound.", "id": "f13408:c0:m5"}
{"signature": "@property<EOL><INDENT>def is_current(self):<DEDENT>", "body": "if not self.is_internal:<EOL><INDENT>return False  <EOL><DEDENT>has_same_endpoint = (request.endpoint == self.endpoint)<EOL>has_same_args = (request.view_args == self.args)<EOL>return has_same_endpoint and has_same_args<EOL>", "docstring": "``True`` if current request has same endpoint with the item.\n\n        The property should be used in a bound request context, or the\n        :class:`RuntimeError` may be raised.", "id": "f13408:c0:m7"}
{"signature": "def freeze_dict(dict_):", "body": "pairs = dict_.items()<EOL>key_getter = operator.itemgetter(<NUM_LIT:0>)<EOL>return tuple(sorted(pairs, key=key_getter))<EOL>", "docstring": "Freezes ``dict`` into ``tuple``.\n\n    A typical usage is packing ``dict`` into hashable.\n\n    e.g.::\n\n        >>> freeze_dict({'a': 1, 'b': 2})\n        (('a', 1), ('b', 2))", "id": "f13409:m0"}
{"signature": "@app.command<EOL>def do_something():", "body": "print('<STR_LIT>')<EOL>return <NUM_LIT><EOL>", "docstring": "This description will show up in the --help. Try it!", "id": "f13428:m0"}
{"signature": "def _get(self, method, **kwargs):", "body": "payload = kwargs.copy()<EOL>payload['<STR_LIT>'] = self.api_key<EOL>payload['<STR_LIT>'] = self.api_secret<EOL>to = payload.pop('<STR_LIT:to>', None)<EOL>if to:<EOL><INDENT>if isinstance(to, basestring):<EOL><INDENT>payload['<STR_LIT:to>'] = to<EOL><DEDENT>else:<EOL><INDENT>for num_i, fax_num in enumerate(to):<EOL><INDENT>payload['<STR_LIT>' % num_i] = fax_num<EOL><DEDENT><DEDENT><DEDENT>files = payload.pop('<STR_LIT>', [])<EOL>if not isinstance(files, (list, tuple)): files = (files,)<EOL>req_files = {}<EOL>for file_i, f in enumerate(files):<EOL><INDENT>if isinstance(f, basestring):<EOL><INDENT>req_files['<STR_LIT>' % file_i] = open(f, '<STR_LIT:rb>')<EOL><DEDENT>else:<EOL><INDENT>f.seek(<NUM_LIT:0>)<EOL>req_files['<STR_LIT>' % file_i] = f<EOL><DEDENT><DEDENT>url = '<STR_LIT>' % (self.BASE_URL, self.VERSION, method)<EOL>r = requests.post(url, data=payload, files=req_files)<EOL>return self.parse_response(r)<EOL>", "docstring": "Builds the url for the specified method and arguments and returns\n        the response as a dictionary.", "id": "f13435:c0:m2"}
{"signature": "def closeSession(self):", "body": "rv = self.lib.C_CloseSession(self.session)<EOL>if rv != CKR_OK:<EOL><INDENT>raise PyKCS11Error(rv)<EOL><DEDENT>", "docstring": "C_CloseSession", "id": "f13454:c14:m2"}
{"signature": "def isAttributeList(self, type):", "body": "if type in (CKA_WRAP_TEMPLATE,<EOL>CKA_UNWRAP_TEMPLATE):<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "is the type a attribute list value?\n\n:param type: PKCS#11 type like `CKA_WRAP_TEMPLATE`\n:rtype: bool", "id": "f13454:c14:m22"}
{"signature": "def seedRandom(self, seed):", "body": "low_seed = ckbytelist(seed)<EOL>rv = self.lib.C_SeedRandom(self.session, low_seed)<EOL>if rv != CKR_OK:<EOL><INDENT>raise PyKCS11Error(rv)<EOL><DEDENT>", "docstring": "C_SeedRandom\n\n:param seed: seed material\n:type seed: iterable", "id": "f13454:c14:m29"}
{"signature": "def sign(self, key, data, mecha=MechanismRSAPKCS1):", "body": "m = mecha.to_native()<EOL>signature = ckbytelist()<EOL>data1 = ckbytelist(data)<EOL>rv = self.lib.C_SignInit(self.session, m, key)<EOL>if rv != CKR_OK:<EOL><INDENT>raise PyKCS11Error(rv)<EOL><DEDENT>rv = self.lib.C_Sign(self.session, data1, signature)<EOL>if rv != CKR_OK:<EOL><INDENT>raise PyKCS11Error(rv)<EOL><DEDENT>rv = self.lib.C_Sign(self.session, data1, signature)<EOL>if rv != CKR_OK:<EOL><INDENT>raise PyKCS11Error(rv)<EOL><DEDENT>return signature<EOL>", "docstring": "C_SignInit/C_Sign\n\n:param key: a key handle, obtained calling :func:`findObjects`.\n:type key: integer\n:param data: the data to be signed\n:type data:  (binary) string or list/tuple of bytes\n:param mecha: the signing mechanism to be used\n  (use `MechanismRSAPKCS1` for `CKM_RSA_PKCS`)\n:type mecha: :class:`Mechanism`\n:return: the computed signature\n:rtype: list of bytes\n\n:note: the returned value is an instance of :class:`ckbytelist`.\n  You can easly convert it to a binary string with:\n  ``bytes(ckbytelistSignature)``\n  or, for Python 2:\n  ``''.join(chr(i) for i in ckbytelistSignature)``", "id": "f13454:c14:m12"}
{"signature": "def __init__(self, pykcs11, session):", "body": "if not isinstance(pykcs11, PyKCS11Lib):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if not isinstance(session, LowLevel.CK_SESSION_HANDLE):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>self.pykcs11 = pykcs11<EOL>self.session = session<EOL>", "docstring": ":param pykcs11: PyKCS11 library object\n:type pykcs11: PyKCS11Lib\n:param session: session handle\n:type session: instance of :class:`CK_SESSION_HANDLE`", "id": "f13454:c14:m0"}
{"signature": "@property<EOL><INDENT>def lib(self):<DEDENT>", "body": "return self.pykcs11.lib<EOL>", "docstring": "Get the low level lib of the owning PyKCS11Lib", "id": "f13454:c14:m1"}
{"signature": "def __str__(self):", "body": "if self.value in CKR:<EOL><INDENT>if self.value < <NUM_LIT:0>:<EOL><INDENT>return CKR[self.value] + \"<STR_LIT>\" % self.text<EOL><DEDENT>else:<EOL><INDENT>return CKR[self.value] + \"<STR_LIT>\" % self.value<EOL><DEDENT><DEDENT>elif self.value & CKR_VENDOR_DEFINED:<EOL><INDENT>return \"<STR_LIT>\" % (self.value & <NUM_LIT> & ~CKR_VENDOR_DEFINED)<EOL><DEDENT>else:<EOL><INDENT>return \"<STR_LIT>\" % self.value<EOL><DEDENT>", "docstring": "The text representation of a PKCS#11 error is something like:\n\"CKR_DEVICE_ERROR (0x00000030)\"", "id": "f13454:c8:m1"}
{"signature": "def getAttributeValue_fragmented(self, obj_id, attr, allAsBinary=False):", "body": "<EOL>valTemplate = PyKCS11.LowLevel.ckattrlist(<NUM_LIT:1>)<EOL>res = []<EOL>for x in range(len(attr)):<EOL><INDENT>valTemplate[<NUM_LIT:0>].Reset()<EOL>valTemplate[<NUM_LIT:0>].SetType(attr[x])<EOL>rv = self.lib.C_GetAttributeValue(self.session, obj_id,<EOL>valTemplate)<EOL>if rv in (CKR_ATTRIBUTE_TYPE_INVALID,<EOL>CKR_ATTRIBUTE_SENSITIVE, CKR_ARGUMENTS_BAD):<EOL><INDENT>res.append(None)<EOL>continue<EOL><DEDENT>if rv != CKR_OK:<EOL><INDENT>raise PyKCS11Error(rv)<EOL><DEDENT>rv = self.lib.C_GetAttributeValue(self.session, obj_id,<EOL>valTemplate)<EOL>if rv != CKR_OK:<EOL><INDENT>raise PyKCS11Error(rv)<EOL><DEDENT>if allAsBinary:<EOL><INDENT>res.append(valTemplate[<NUM_LIT:0>].GetBin())<EOL><DEDENT>elif valTemplate[<NUM_LIT:0>].IsNum():<EOL><INDENT>res.append(valTemplate[<NUM_LIT:0>].GetNum())<EOL><DEDENT>elif valTemplate[<NUM_LIT:0>].IsBool():<EOL><INDENT>res.append(valTemplate[<NUM_LIT:0>].GetBool())<EOL><DEDENT>elif valTemplate[<NUM_LIT:0>].IsString():<EOL><INDENT>res.append(valTemplate[<NUM_LIT:0>].GetString())<EOL><DEDENT>elif valTemplate[<NUM_LIT:0>].IsBin():<EOL><INDENT>res.append(valTemplate[<NUM_LIT:0>].GetBin())<EOL><DEDENT>elif valTemplate[<NUM_LIT:0>].IsAttributeList():<EOL><INDENT>res.append(valTemplate[<NUM_LIT:0>].GetBin())<EOL><DEDENT>else:<EOL><INDENT>raise PyKCS11Error(-<NUM_LIT:2>)<EOL><DEDENT><DEDENT>return res<EOL>", "docstring": "Same as :func:`getAttributeValue` except that when some attribute\nis sensitive or unknown an empty value (None) is returned.\n\nNote: this is achived by getting attributes one by one.\n\n:see: :func:`getAttributeValue`", "id": "f13454:c14:m28"}
{"signature": "def __init__(self, hashAlg, mgf, label=None):", "body": "self._param = PyKCS11.LowLevel.CK_RSA_PKCS_OAEP_PARAMS()<EOL>self._param.hashAlg = hashAlg<EOL>self._param.mgf = mgf<EOL>self._source = None<EOL>self._param.src = CKZ_DATA_SPECIFIED<EOL>if label:<EOL><INDENT>self._source = ckbytelist(label)<EOL>self._param.ulSourceDataLen = len(self._source)<EOL><DEDENT>else:<EOL><INDENT>self._param.ulSourceDataLen = <NUM_LIT:0><EOL><DEDENT>self._param.pSourceData = self._source<EOL>self._mech = PyKCS11.LowLevel.CK_MECHANISM()<EOL>self._mech.mechanism = CKM_RSA_PKCS_OAEP<EOL>self._mech.pParameter = self._param<EOL>self._mech.ulParameterLen = PyKCS11.LowLevel.CK_RSA_PKCS_OAEP_PARAMS_LENGTH<EOL>", "docstring": ":param hashAlg: the hash algorithm to use (like `CKM_SHA256`)\n:param mgf: the mask generation function to use (like\n  `CKG_MGF1_SHA256`)\n:param label: the (optional) label to use", "id": "f13454:c11:m0"}
{"signature": "def generateRandom(self, size=<NUM_LIT:16>):", "body": "low_rand = ckbytelist([<NUM_LIT:0>] * size)<EOL>rv = self.lib.C_GenerateRandom(self.session, low_rand)<EOL>if rv != CKR_OK:<EOL><INDENT>raise PyKCS11Error(rv)<EOL><DEDENT>return low_rand<EOL>", "docstring": "C_GenerateRandom\n\n:param size: number of random bytes to get\n:type size: integer\n\n:note: the returned value is an instance of :class:`ckbytelist`.\n  You can easly convert it to a binary string with:\n  ``bytes(random)``\n  or, for Python 2:\n  ``''.join(chr(i) for i in random)``", "id": "f13454:c14:m30"}
{"signature": "def unwrapKey(self, unwrappingKey, wrappedKey, template,<EOL>mecha=MechanismRSAPKCS1):", "body": "m = mecha.to_native()<EOL>data1 = ckbytelist(wrappedKey)<EOL>handle = PyKCS11.LowLevel.CK_OBJECT_HANDLE()<EOL>attrs = self._template2ckattrlist(template)<EOL>rv = self.lib.C_UnwrapKey(self.session, m, unwrappingKey,<EOL>data1, attrs, handle)<EOL>if rv != CKR_OK:<EOL><INDENT>raise PyKCS11Error(rv)<EOL><DEDENT>return handle<EOL>", "docstring": "C_UnwrapKey\n\n:param unwrappingKey: the unwrapping key handle\n:type unwrappingKey: integer\n:param wrappedKey: the bytes of the wrapped key\n:type wrappedKey:  (binary) string or list/tuple of bytes\n:param template: template for the unwrapped key\n:param mecha: the decrypt mechanism to be used (use\n  `MechanismRSAPKCS1` for `CKM_RSA_PKCS`)\n:type mecha: :class:`Mechanism`\n:return: the unwrapped key object\n:rtype: integer", "id": "f13454:c14:m17"}
{"signature": "def isBin(self, type):", "body": "return (not self.isBool(type))and (not self.isString(type))and (not self.isNum(type))<EOL>", "docstring": "is the type a byte array value?\n\n:param type: PKCS#11 type like `CKA_MODULUS`\n:rtype: bool", "id": "f13454:c14:m21"}
{"signature": "def wrapKey(self, wrappingKey, key, mecha=MechanismRSAPKCS1):", "body": "wrapped = ckbytelist()<EOL>native = mecha.to_native()<EOL>rv = self.lib.C_WrapKey(self.session, native, wrappingKey, key,<EOL>wrapped)<EOL>if rv != CKR_OK:<EOL><INDENT>raise PyKCS11Error(rv)<EOL><DEDENT>rv = self.lib.C_WrapKey(self.session, native, wrappingKey, key,<EOL>wrapped)<EOL>if rv != CKR_OK:<EOL><INDENT>raise PyKCS11Error(rv)<EOL><DEDENT>return wrapped<EOL>", "docstring": "C_WrapKey\n\n:param wrappingKey: a wrapping key handle\n:type wrappingKey: integer\n:param key: a handle of the key to be wrapped\n:type key: integer\n:param mecha: the encrypt mechanism to be used\n  (use `MechanismRSAPKCS1` for `CKM_RSA_PKCS`)\n:type mecha: :class:`Mechanism`\n:return: the wrapped key bytes\n:rtype: list of bytes\n\n:note: the returned value is an instance of :class:`ckbytelist`.\n  You can easily convert it to a binary string with:\n  ``bytes(ckbytelistData)``\n  or, for Python 2:\n  ``''.join(chr(i) for i in ckbytelistData)``", "id": "f13454:c14:m16"}
{"signature": "def getTokenInfo(self, slot):", "body": "tokeninfo = PyKCS11.LowLevel.CK_TOKEN_INFO()<EOL>rv = self.lib.C_GetTokenInfo(slot, tokeninfo)<EOL>if rv != CKR_OK:<EOL><INDENT>raise PyKCS11Error(rv)<EOL><DEDENT>t = CK_TOKEN_INFO()<EOL>t.label = tokeninfo.GetLabel()<EOL>t.manufacturerID = tokeninfo.GetManufacturerID()<EOL>t.model = tokeninfo.GetModel()<EOL>t.serialNumber = tokeninfo.GetSerialNumber()<EOL>t.flags = tokeninfo.flags<EOL>t.ulMaxSessionCount = tokeninfo.ulMaxSessionCount<EOL>if t.ulMaxSessionCount == CK_UNAVAILABLE_INFORMATION:<EOL><INDENT>t.ulMaxSessionCount = -<NUM_LIT:1><EOL><DEDENT>t.ulSessionCount = tokeninfo.ulSessionCount<EOL>if t.ulSessionCount == CK_UNAVAILABLE_INFORMATION:<EOL><INDENT>t.ulSessionCount = -<NUM_LIT:1><EOL><DEDENT>t.ulMaxRwSessionCount = tokeninfo.ulMaxRwSessionCount<EOL>if t.ulMaxRwSessionCount == CK_UNAVAILABLE_INFORMATION:<EOL><INDENT>t.ulMaxRwSessionCount = -<NUM_LIT:1><EOL><DEDENT>t.ulRwSessionCount = tokeninfo.ulRwSessionCount<EOL>if t.ulRwSessionCount == CK_UNAVAILABLE_INFORMATION:<EOL><INDENT>t.ulRwSessionCount = -<NUM_LIT:1><EOL><DEDENT>t.ulMaxPinLen = tokeninfo.ulMaxPinLen<EOL>t.ulMinPinLen = tokeninfo.ulMinPinLen<EOL>t.ulTotalPublicMemory = tokeninfo.ulTotalPublicMemory<EOL>if t.ulTotalPublicMemory == CK_UNAVAILABLE_INFORMATION:<EOL><INDENT>t.ulTotalPublicMemory = -<NUM_LIT:1><EOL><DEDENT>t.ulFreePublicMemory = tokeninfo.ulFreePublicMemory<EOL>if t.ulFreePublicMemory == CK_UNAVAILABLE_INFORMATION:<EOL><INDENT>t.ulFreePublicMemory = -<NUM_LIT:1><EOL><DEDENT>t.ulTotalPrivateMemory = tokeninfo.ulTotalPrivateMemory<EOL>if t.ulTotalPrivateMemory == CK_UNAVAILABLE_INFORMATION:<EOL><INDENT>t.ulTotalPrivateMemory = -<NUM_LIT:1><EOL><DEDENT>t.ulFreePrivateMemory = tokeninfo.ulFreePrivateMemory<EOL>if t.ulFreePrivateMemory == CK_UNAVAILABLE_INFORMATION:<EOL><INDENT>t.ulFreePrivateMemory = -<NUM_LIT:1><EOL><DEDENT>t.hardwareVersion = (tokeninfo.hardwareVersion.major,<EOL>tokeninfo.hardwareVersion.minor)<EOL>t.firmwareVersion = (tokeninfo.firmwareVersion.major,<EOL>tokeninfo.firmwareVersion.minor)<EOL>t.utcTime = tokeninfo.GetUtcTime().replace('<STR_LIT>', '<STR_LIT:U+0020>')<EOL>return t<EOL>", "docstring": "C_GetTokenInfo\n\n:param slot: slot number returned by :func:`getSlotList`\n:type slot: integer\n:return: a :class:`CK_TOKEN_INFO` object", "id": "f13454:c9:m7"}
{"signature": "def __init__(self, mecha, hashAlg, mgf, sLen):", "body": "self._param = PyKCS11.LowLevel.CK_RSA_PKCS_PSS_PARAMS()<EOL>self._param.hashAlg = hashAlg<EOL>self._param.mgf = mgf<EOL>self._param.sLen = sLen<EOL>self._mech = PyKCS11.LowLevel.CK_MECHANISM()<EOL>self._mech.mechanism = mecha<EOL>self._mech.pParameter = self._param<EOL>self._mech.ulParameterLen = PyKCS11.LowLevel.CK_RSA_PKCS_PSS_PARAMS_LENGTH<EOL>", "docstring": ":param mecha: the mechanism to use (like\n  `CKM_SHA384_RSA_PKCS_PSS`)\n:param hashAlg: the hash algorithm to use (like `CKM_SHA384`)\n:param mgf: the mask generation function to use (like\n  `CKG_MGF1_SHA384`)\n:param sLen: length, in bytes, of the salt value used in the PSS\n  encoding (like 0 or the message length)", "id": "f13454:c12:m0"}
{"signature": "def add(self, new_oid):", "body": "if self._oid_set[<NUM_LIT:0>]:<EOL><INDENT>oid_ptr = None<EOL>if isinstance(new_oid, OID):<EOL><INDENT>oid_ptr = ffi.addressof(new_oid._oid)<EOL><DEDENT>elif isinstance(new_oid, ffi.CData):<EOL><INDENT>if ffi.typeof(new_oid) == ffi.typeof('<STR_LIT>'):<EOL><INDENT>oid_ptr = ffi.addressof(new_oid)<EOL><DEDENT>elif ffi.typeof(new_oid) == ffi.typeof('<STR_LIT>'):<EOL><INDENT>oid_ptr = new_oid<EOL><DEDENT><DEDENT>if oid_ptr is None:<EOL><INDENT>raise TypeError(\"<STR_LIT>\" + str(type(new_oid)))<EOL><DEDENT>minor_status = ffi.new('<STR_LIT>')<EOL>retval = C.gss_add_oid_set_member(minor_status, oid_ptr, self._oid_set)<EOL>if GSS_ERROR(retval):<EOL><INDENT>raise _exception_for_status(retval, minor_status[<NUM_LIT:0>])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise GSSException(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Adds another :class:`OID` to this set.\n\n:param new_oid: the OID to add.\n:type new_oid: :class:`OID`", "id": "f13483:c2:m0"}
{"signature": "def __init__(self, oid_set=None):", "body": "super(OIDSet, self).__init__()<EOL>if isinstance(oid_set, ffi.CData) and ffi.typeof(oid_set) == ffi.typeof('<STR_LIT>'):<EOL><INDENT>self._oid_set = ffi.gc(oid_set, _release_OID_set)<EOL><DEDENT>elif oid_set is None:<EOL><INDENT>self._oid_set = ffi.new('<STR_LIT>')<EOL>minor_status = ffi.new('<STR_LIT>')<EOL>try:<EOL><INDENT>retval = C.gss_create_empty_oid_set(minor_status, self._oid_set)<EOL>if GSS_ERROR(retval):<EOL><INDENT>raise _exception_for_status(retval, minor_status[<NUM_LIT:0>])<EOL><DEDENT>self._oid_set = ffi.gc(self._oid_set, _release_OID_set)<EOL><DEDENT>except:<EOL><INDENT>_release_OID_set(self._oid_set)<EOL>raise<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\" + str(type(oid_set)))<EOL><DEDENT>", "docstring": "Wraps a gss_OID_set. This can be returned from methods like gss_inquire_cred\n        where it shouldn't be modified by the caller, since it's immutable.", "id": "f13483:c1:m0"}
{"signature": "def get_all_mechs():", "body": "minor_status = ffi.new('<STR_LIT>')<EOL>mech_set = ffi.new('<STR_LIT>')<EOL>try:<EOL><INDENT>retval = C.gss_indicate_mechs(minor_status, mech_set)<EOL>if GSS_ERROR(retval):<EOL><INDENT>raise _exception_for_status(retval, minor_status[<NUM_LIT:0>])<EOL><DEDENT><DEDENT>except:<EOL><INDENT>_release_OID_set(mech_set)<EOL>raise<EOL><DEDENT>return OIDSet(oid_set=mech_set)<EOL>", "docstring": "Return an :class:`OIDSet` of all the mechanisms supported by the underlying GSSAPI\nimplementation.", "id": "f13483:m1"}
{"signature": "@property<EOL><INDENT>def lifetime(self):<DEDENT>", "body": "return self._inquire(False, True, False, False)[<NUM_LIT:1>]<EOL>", "docstring": "The lifetime in seconds for which this credential is valid.", "id": "f13485:c0:m2"}
{"signature": "def verify_mic(self, message, mic, supplementary=False):", "body": "if not (self.flags & C.GSS_C_INTEG_FLAG):<EOL><INDENT>raise GSSException(\"<STR_LIT>\")<EOL><DEDENT>if not (self.established or (self.flags & C.GSS_C_PROT_READY_FLAG)):<EOL><INDENT>raise GSSException(\"<STR_LIT>\")<EOL><DEDENT>minor_status = ffi.new('<STR_LIT>')<EOL>message_buffer = ffi.new('<STR_LIT>')<EOL>message_buffer[<NUM_LIT:0>].length = len(message)<EOL>c_str_message = ffi.new('<STR_LIT>', message)<EOL>message_buffer[<NUM_LIT:0>].value = c_str_message<EOL>mic_buffer = ffi.new('<STR_LIT>')<EOL>mic_buffer[<NUM_LIT:0>].length = len(mic)<EOL>c_str_mic = ffi.new('<STR_LIT>', mic)<EOL>mic_buffer[<NUM_LIT:0>].value = c_str_mic<EOL>qop_state = ffi.new('<STR_LIT>')<EOL>retval = C.gss_verify_mic(<EOL>minor_status,<EOL>self._ctx[<NUM_LIT:0>],<EOL>message_buffer,<EOL>mic_buffer,<EOL>qop_state<EOL>)<EOL>if GSS_ERROR(retval):<EOL><INDENT>if minor_status[<NUM_LIT:0>] and self.mech_type:<EOL><INDENT>raise _exception_for_status(retval, minor_status[<NUM_LIT:0>], self.mech_type)<EOL><DEDENT>else:<EOL><INDENT>raise _exception_for_status(retval, minor_status[<NUM_LIT:0>])<EOL><DEDENT><DEDENT>supp_bits = _status_bits(retval)<EOL>if supplementary:<EOL><INDENT>return qop_state[<NUM_LIT:0>], supp_bits<EOL><DEDENT>elif len(supp_bits) > <NUM_LIT:0>:<EOL><INDENT>raise _exception_for_status(retval, minor_status[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>return qop_state[<NUM_LIT:0>]<EOL><DEDENT>", "docstring": "Takes a message integrity code (MIC) that has been generated by the peer application for a\ngiven message, and verifies it against a message, using this security context's\ncryptographic keys.\n\nThe `supplementary` parameter determines how this method deals with replayed, unsequential,\ntoo-old or missing tokens, as follows:\n\nIf the `supplementary` parameter is False (the default), and if a replayed or otherwise\nout-of-sequence token is detected, this method raises a :exc:`~gssapi.error.GSSCException`.\nIf no replay or out-of-sequence token is detected, this method does not raise an exception\nand returns the ``qop_state`` only.\n\nIf `supplementary` is True, instead of raising an exception when a replayed or\nout-of-sequence token is detected, this method returns a tuple\n``(qop_state, supplementary_info)`` where ``supplementary_info`` is a tuple containing zero\nor more of the constants :const:`~gssapi.S_DUPLICATE_TOKEN`, :const:`~gssapi.S_OLD_TOKEN`,\n:const:`~gssapi.S_UNSEQ_TOKEN` and :const:`~gssapi.S_GAP_TOKEN`. The supplementary info\ntells the caller whether a replayed or out-of-sequence message was detected. The caller\nmust check this and decide how to handle the message if any of the flags are set. For a\nreference to the meaning of the flags, check\n`RFC 2744 Section 3.9.1 <http://tools.ietf.org/html/rfc2744#section-3.9.1>` for the\ncorresponding GSS_S_OLD_TOKEN, etc, constants.\n\n:param message: The message the MIC was calculated for\n:type message: bytes\n:param mic: The MIC calculated by the peer\n:type mic: bytes\n:param supplementary: Whether to also return supplementary info.\n:type supplementary: bool\n:returns: ``qop_state`` if `supplementary` is False, or ``(qop_state,\n    supplementary_info)`` if `supplementary` is True.\n:raises: :exc:`~gssapi.error.GSSException` if :attr:`integrity_negotiated` is false, or\n    :exc:`~gssapi.error.GSSCException` if the verification fails indicating the message was\n    modified, replayed or out-of-sequence.", "id": "f13490:c0:m11"}
{"signature": "@property<EOL><INDENT>def is_transferable(self):<DEDENT>", "body": "return bool(self.flags & C.GSS_C_TRANS_FLAG)<EOL>", "docstring": "True if the context can be transferred between processes using :meth:`export` and\n:meth:`imprt`, False otherwise.", "id": "f13490:c0:m9"}
{"signature": "@property<EOL><INDENT>def initiator_is_anonymous(self):<DEDENT>", "body": "return bool(self.flags & C.GSS_C_ANON_FLAG)<EOL>", "docstring": "After :meth:`step` has been called, this property will be set to\nTrue if the initiator did not reveal its name to the acceptor, False if the initiator's\nname is revealed and authenticated to the acceptor. If True, the\n:attr:`~AcceptContext.peer_name` property of the :class:`AcceptContext` will be an\nanonymous internal name.", "id": "f13490:c0:m8"}
{"signature": "def main(version=DEFAULT_VERSION):", "body": "options = _parse_args()<EOL>tarball = download_setuptools(download_base=options.download_base,<EOL>downloader_factory=options.downloader_factory)<EOL>return _install(tarball, _build_install_args(options))<EOL>", "docstring": "Install or upgrade setuptools and EasyInstall", "id": "f13493:m18"}
{"signature": "def _build_install_args(options):", "body": "install_args = []<EOL>if options.user_install:<EOL><INDENT>if sys.version_info < (<NUM_LIT:2>, <NUM_LIT:6>):<EOL><INDENT>log.warn(\"<STR_LIT>\")<EOL>raise SystemExit(<NUM_LIT:1>)<EOL><DEDENT>install_args.append('<STR_LIT>')<EOL><DEDENT>return install_args<EOL>", "docstring": "Build the arguments to 'python setup.py install' on the setuptools package", "id": "f13493:m16"}
{"signature": "def _parse_args():", "body": "parser = optparse.OptionParser()<EOL>parser.add_option(<EOL>'<STR_LIT>', dest='<STR_LIT>', action='<STR_LIT:store_true>', default=False,<EOL>help='<STR_LIT>')<EOL>parser.add_option(<EOL>'<STR_LIT>', dest='<STR_LIT>', metavar=\"<STR_LIT>\",<EOL>default=DEFAULT_URL,<EOL>help='<STR_LIT>')<EOL>parser.add_option(<EOL>'<STR_LIT>', dest='<STR_LIT>', action='<STR_LIT>',<EOL>const=lambda: download_file_insecure, default=get_best_downloader,<EOL>help='<STR_LIT>'<EOL>)<EOL>options, args = parser.parse_args()<EOL>return options<EOL>", "docstring": "Parse the command line for options", "id": "f13493:m17"}
{"signature": "def parse_token_stream(stream, soft_delimiter, hard_delimiter):", "body": "return [<EOL>[sum(len(token) for token in sentence_it) <EOL>for sentence_it in split_at(block_it, soft_delimiter)]<EOL>for block_it in split_at(stream, hard_delimiter)]<EOL>", "docstring": "Parses a stream of tokens and splits it into sentences (using C{soft_delimiter} tokens) \n    and blocks (using C{hard_delimiter} tokens) for use with the L{align_texts} function.", "id": "f13495:m7"}
{"signature": "def split_at(it, split_value):", "body": "def _chunk_iterator(first):<EOL><INDENT>v = first<EOL>while v != split_value:<EOL><INDENT>yield v<EOL>v = next(it)<EOL><DEDENT><DEDENT>while True:<EOL><INDENT>yield _chunk_iterator(next(it))<EOL><DEDENT>", "docstring": "Splits an iterator C{it} at values of C{split_value}. \n\n    Each instance of C{split_value} is swallowed. The iterator produces\n    subiterators which need to be consumed fully before the next subiterator\n    can be used.", "id": "f13495:m6"}
{"signature": "@staticmethod<EOL><INDENT>def status(s):<DEDENT>", "body": "print('<STR_LIT>'.format(s))<EOL>", "docstring": "Prints things in bold.", "id": "f13608:c0:m0"}
{"signature": "def export_mt_variants(variants, sample_id):", "body": "document_lines = []<EOL>for variant in variants:<EOL><INDENT>line = []<EOL>position = variant.get('<STR_LIT>')<EOL>change = '<STR_LIT:>>'.join([variant.get('<STR_LIT>'),variant.get('<STR_LIT>')])<EOL>line.append(position)<EOL>line.append(change)<EOL>line.append(str(position)+change)<EOL>genes = []<EOL>prot_effect = []<EOL>for gene in variant.get('<STR_LIT>'):<EOL><INDENT>genes.append(gene.get('<STR_LIT>','<STR_LIT>'))<EOL>for transcript in gene.get('<STR_LIT>'):<EOL><INDENT>if transcript.get('<STR_LIT>') and transcript.get('<STR_LIT>'):<EOL><INDENT>prot_effect.append(urllib.parse.unquote(transcript.get('<STR_LIT>')))<EOL><DEDENT><DEDENT><DEDENT>line.append('<STR_LIT:U+002C>'.join(prot_effect))<EOL>line.append('<STR_LIT:U+002C>'.join(genes))<EOL>ref_ad = '<STR_LIT>'<EOL>alt_ad = '<STR_LIT>'<EOL>for sample in variant['<STR_LIT>']:<EOL><INDENT>if sample.get('<STR_LIT>') == sample_id:<EOL><INDENT>ref_ad = sample['<STR_LIT>'][<NUM_LIT:0>]<EOL>alt_ad = sample['<STR_LIT>'][<NUM_LIT:1>]<EOL><DEDENT><DEDENT>line.append(ref_ad)<EOL>line.append(alt_ad)<EOL>document_lines.append(line)<EOL><DEDENT>return document_lines<EOL>", "docstring": "Export mitochondrial variants for a case to create a MT excel report\n\n    Args:\n        variants(list): all MT variants for a case, sorted by position\n        sample_id(str) : the id of a sample within the case\n\n    Returns:\n        document_lines(list): list of lines to include in the document", "id": "f13612:m2"}
{"signature": "def export_panels(adapter, panels, versions=None, build='<STR_LIT>'):", "body": "if versions and (len(versions) != len(panels)):<EOL><INDENT>raise SyntaxError(\"<STR_LIT>\")<EOL><DEDENT>headers = []<EOL>build_string = (\"<STR_LIT>\")<EOL>headers.append(build_string.format(build))<EOL>header_string = (\"<STR_LIT>\")<EOL>contig_string = (\"<STR_LIT>\")<EOL>bed_string = (\"<STR_LIT>\")<EOL>panel_geneids = set()<EOL>chromosomes_found = set()<EOL>hgnc_geneobjs = []<EOL>for i,panel_id in enumerate(panels):<EOL><INDENT>version = None<EOL>if versions:<EOL><INDENT>version = versions[i]<EOL><DEDENT>panel_obj = adapter.gene_panel(panel_id, version=version)<EOL>if not panel_obj:<EOL><INDENT>LOG.warning(\"<STR_LIT>\".format(panel_id, version))<EOL>continue<EOL><DEDENT>headers.append(header_string.format(<EOL>panel_obj['<STR_LIT>'],<EOL>panel_obj['<STR_LIT:version>'],<EOL>panel_obj['<STR_LIT:date>'].date(),<EOL>panel_obj['<STR_LIT>'],<EOL>))<EOL>for gene_obj in panel_obj['<STR_LIT>']:<EOL><INDENT>panel_geneids.add(gene_obj['<STR_LIT>'])<EOL><DEDENT><DEDENT>gene_objs = adapter.hgncid_to_gene(build=build)<EOL>for hgnc_id in panel_geneids:<EOL><INDENT>hgnc_geneobj = gene_objs.get(hgnc_id)<EOL>if hgnc_geneobj is None:<EOL><INDENT>LOG.warn(\"<STR_LIT>\", hgnc_id)<EOL>continue<EOL><DEDENT>chrom = hgnc_geneobj['<STR_LIT>']<EOL>start = hgnc_geneobj['<STR_LIT:start>']<EOL>chrom_int = CHROMOSOME_INTEGERS.get(chrom)<EOL>if not chrom_int:<EOL><INDENT>LOG.warn(\"<STR_LIT>\", chrom)<EOL>continue<EOL><DEDENT>hgnc_geneobjs.append((chrom_int, start, hgnc_geneobj))<EOL>chromosomes_found.add(chrom)<EOL><DEDENT>hgnc_geneobjs.sort(key=lambda tup: (tup[<NUM_LIT:0>], tup[<NUM_LIT:1>]))<EOL>for chrom in CHROMOSOMES:<EOL><INDENT>if chrom in chromosomes_found:<EOL><INDENT>headers.append(contig_string.format(chrom))<EOL><DEDENT><DEDENT>headers.append(\"<STR_LIT>\")<EOL>for header in headers:<EOL><INDENT>yield header<EOL><DEDENT>for hgnc_gene in hgnc_geneobjs:<EOL><INDENT>gene_obj = hgnc_gene[-<NUM_LIT:1>]<EOL>gene_line = bed_string.format(gene_obj['<STR_LIT>'], gene_obj['<STR_LIT:start>'],<EOL>gene_obj['<STR_LIT:end>'], gene_obj['<STR_LIT>'],<EOL>gene_obj['<STR_LIT>'])<EOL>yield gene_line<EOL><DEDENT>", "docstring": "Export all genes in gene panels\n\n    Exports the union of genes in one or several gene panels to a bed like format with coordinates.\n\n    Args:\n        adapter(scout.adapter.MongoAdapter)\n        panels(iterable(str)): Iterable with panel ids\n        bed(bool): If lines should be bed formated", "id": "f13613:m0"}
{"signature": "def export_genes(adapter, build='<STR_LIT>'):", "body": "LOG.info(\"<STR_LIT>\")<EOL>for gene_obj in adapter.all_genes(build=build):<EOL><INDENT>yield gene_obj<EOL><DEDENT>", "docstring": "Export all genes from the database", "id": "f13614:m0"}
{"signature": "def emit(self, record):", "body": "try:<EOL><INDENT>import smtplib<EOL>try:<EOL><INDENT>from email.utils import formatdate<EOL><DEDENT>except ImportError:<EOL><INDENT>formatdate = self.date_time<EOL><DEDENT>port = self.mailport<EOL>if not port:<EOL><INDENT>port = smtplib.SMTP_PORT<EOL><DEDENT>smtp = smtplib.SMTP(self.mailhost, port)<EOL>msg = self.format(record)<EOL>msg = \"<STR_LIT>\" % (<EOL>self.fromaddr,<EOL>'<STR_LIT:U+002C>'.join(self.toaddrs),<EOL>self.getSubject(record),<EOL>formatdate(), msg<EOL>)<EOL>if self.username:<EOL><INDENT>smtp.ehlo()  <EOL>smtp.starttls()  <EOL>smtp.ehlo()  <EOL>smtp.login(self.username, self.password)<EOL><DEDENT>smtp.sendmail(self.fromaddr, self.toaddrs, msg)<EOL>smtp.quit()<EOL><DEDENT>except (KeyboardInterrupt, SystemExit):<EOL><INDENT>raise<EOL><DEDENT>except:<EOL><INDENT>self.handleError(record)<EOL><DEDENT>", "docstring": "Emit a record.\n        Format the record and send it to the specified addressees.", "id": "f13618:c0:m0"}
{"signature": "def build_variant(variant, institute_id, gene_to_panels = None,<EOL>hgncid_to_gene=None, sample_info=None):", "body": "gene_to_panels = gene_to_panels or {}<EOL>hgncid_to_gene = hgncid_to_gene or {}<EOL>sample_info = sample_info or {}<EOL>variant_obj = dict(<EOL>_id = variant['<STR_LIT>']['<STR_LIT>'],<EOL>document_id=variant['<STR_LIT>']['<STR_LIT>'],<EOL>variant_id=variant['<STR_LIT>']['<STR_LIT>'],<EOL>display_name=variant['<STR_LIT>']['<STR_LIT>'],<EOL>variant_type=variant['<STR_LIT>'],<EOL>case_id=variant['<STR_LIT>'],<EOL>chromosome=variant['<STR_LIT>'],<EOL>reference=variant['<STR_LIT>'],<EOL>alternative=variant['<STR_LIT>'],<EOL>institute=institute_id,<EOL>)<EOL>variant_obj['<STR_LIT>'] = False<EOL>variant_obj['<STR_LIT>'] = int(variant['<STR_LIT>'])<EOL>variant_obj['<STR_LIT>'] = float(variant['<STR_LIT>'])<EOL>end = variant.get('<STR_LIT:end>')<EOL>if end:<EOL><INDENT>variant_obj['<STR_LIT:end>'] = int(end)<EOL><DEDENT>length = variant.get('<STR_LIT>')<EOL>if length:<EOL><INDENT>variant_obj['<STR_LIT>'] = int(length)<EOL><DEDENT>variant_obj['<STR_LIT>'] = variant['<STR_LIT>'].get('<STR_LIT>')<EOL>variant_obj['<STR_LIT>'] = float(variant['<STR_LIT>']) if variant['<STR_LIT>'] else None<EOL>variant_obj['<STR_LIT>'] = variant['<STR_LIT>']<EOL>variant_obj['<STR_LIT>'] = variant.get('<STR_LIT>')<EOL>variant_obj['<STR_LIT>'] = variant.get('<STR_LIT>')<EOL>variant_obj['<STR_LIT>'] = variant['<STR_LIT>']<EOL>variant_obj['<STR_LIT>'] = variant.get('<STR_LIT>')<EOL>if '<STR_LIT>' in variant:<EOL><INDENT>variant_obj['<STR_LIT>'] = variant['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in variant:<EOL><INDENT>variant_obj['<STR_LIT>'] = variant['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in variant:<EOL><INDENT>variant_obj['<STR_LIT>'] = variant['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in variant:<EOL><INDENT>variant_obj['<STR_LIT>'] = variant['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in variant:<EOL><INDENT>variant_obj['<STR_LIT>'] = variant['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in variant:<EOL><INDENT>variant_obj['<STR_LIT>'] = variant['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in variant:<EOL><INDENT>variant_obj['<STR_LIT>'] = variant['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in variant:<EOL><INDENT>variant_obj['<STR_LIT>'] = variant['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in variant:<EOL><INDENT>variant_obj['<STR_LIT>'] = variant['<STR_LIT>']<EOL><DEDENT>gt_types = []<EOL>for sample in variant.get('<STR_LIT>', []):<EOL><INDENT>gt_call = build_genotype(sample)<EOL>gt_types.append(gt_call)<EOL>if sample_info:<EOL><INDENT>sample_id = sample['<STR_LIT>']<EOL>if sample_info[sample_id] == '<STR_LIT>':<EOL><INDENT>key = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>key = '<STR_LIT>'<EOL><DEDENT>variant_obj[key] = {<EOL>'<STR_LIT>': sample['<STR_LIT>'],<EOL>'<STR_LIT>': sample['<STR_LIT>'],<EOL>'<STR_LIT>': sample['<STR_LIT>'],<EOL>'<STR_LIT>': sample['<STR_LIT>'],<EOL>'<STR_LIT>': sample_id<EOL>}<EOL><DEDENT><DEDENT>variant_obj['<STR_LIT>'] = gt_types<EOL>if '<STR_LIT>' in variant:<EOL><INDENT>variant_obj['<STR_LIT>'] = variant['<STR_LIT>']<EOL><DEDENT>compounds = []<EOL>for compound in variant.get('<STR_LIT>', []):<EOL><INDENT>compound_obj = build_compound(compound)<EOL>compounds.append(compound_obj)<EOL><DEDENT>if compounds:<EOL><INDENT>variant_obj['<STR_LIT>'] = compounds<EOL><DEDENT>genes = []<EOL>for index, gene in enumerate(variant.get('<STR_LIT>', [])):<EOL><INDENT>if gene.get('<STR_LIT>'):<EOL><INDENT>gene_obj = build_gene(gene, hgncid_to_gene)<EOL>genes.append(gene_obj)<EOL>if index > <NUM_LIT:30>:<EOL><INDENT>variant_obj['<STR_LIT>'] = True<EOL>break<EOL><DEDENT><DEDENT><DEDENT>if genes:<EOL><INDENT>variant_obj['<STR_LIT>'] = genes<EOL><DEDENT>if '<STR_LIT>' in variant:<EOL><INDENT>variant_obj['<STR_LIT>'] = [hgnc_id for hgnc_id in variant['<STR_LIT>'] if hgnc_id]<EOL><DEDENT>hgnc_symbols = []<EOL>for hgnc_id in variant_obj['<STR_LIT>']:<EOL><INDENT>gene_obj = hgncid_to_gene.get(hgnc_id)<EOL>if gene_obj:<EOL><INDENT>hgnc_symbols.append(gene_obj['<STR_LIT>'])<EOL><DEDENT><DEDENT>if hgnc_symbols:<EOL><INDENT>variant_obj['<STR_LIT>'] = hgnc_symbols<EOL><DEDENT>panel_names = set()<EOL>for hgnc_id in variant_obj['<STR_LIT>']:<EOL><INDENT>gene_panels = gene_to_panels.get(hgnc_id, set())<EOL>panel_names = panel_names.union(gene_panels)<EOL><DEDENT>if panel_names:<EOL><INDENT>variant_obj['<STR_LIT>'] = list(panel_names)<EOL><DEDENT>clnsig_objects = []<EOL>for entry in variant.get('<STR_LIT>', []):<EOL><INDENT>clnsig_obj = build_clnsig(entry)<EOL>clnsig_objects.append(clnsig_obj)<EOL><DEDENT>if clnsig_objects:<EOL><INDENT>variant_obj['<STR_LIT>'] = clnsig_objects<EOL><DEDENT>call_info = variant.get('<STR_LIT>', {})<EOL>for caller in call_info:<EOL><INDENT>if call_info[caller]:<EOL><INDENT>variant_obj[caller] = call_info[caller]<EOL><DEDENT><DEDENT>conservation_info = variant.get('<STR_LIT>', {})<EOL>if conservation_info.get('<STR_LIT>'):<EOL><INDENT>variant_obj['<STR_LIT>'] = conservation_info['<STR_LIT>']<EOL><DEDENT>if conservation_info.get('<STR_LIT>'):<EOL><INDENT>variant_obj['<STR_LIT>'] = conservation_info['<STR_LIT>']<EOL><DEDENT>if conservation_info.get('<STR_LIT>'):<EOL><INDENT>variant_obj['<STR_LIT>'] = conservation_info['<STR_LIT>']<EOL><DEDENT>if variant.get('<STR_LIT>'):<EOL><INDENT>variant_obj['<STR_LIT>'] = variant['<STR_LIT>']<EOL><DEDENT>if variant.get('<STR_LIT>'):<EOL><INDENT>variant_obj['<STR_LIT>'] = variant['<STR_LIT>']<EOL><DEDENT>frequencies = variant.get('<STR_LIT>', {})<EOL>if frequencies.get('<STR_LIT>'):<EOL><INDENT>variant_obj['<STR_LIT>'] = float(frequencies['<STR_LIT>'])<EOL><DEDENT>if frequencies.get('<STR_LIT>'):<EOL><INDENT>variant_obj['<STR_LIT>'] = float(frequencies['<STR_LIT>'])<EOL><DEDENT>if frequencies.get('<STR_LIT>'):<EOL><INDENT>variant_obj['<STR_LIT>'] = float(frequencies['<STR_LIT>'])<EOL><DEDENT>if frequencies.get('<STR_LIT>'):<EOL><INDENT>variant_obj['<STR_LIT>'] = float(frequencies['<STR_LIT>'])<EOL><DEDENT>if frequencies.get('<STR_LIT>'):<EOL><INDENT>variant_obj['<STR_LIT>'] = float(frequencies['<STR_LIT>'])<EOL><DEDENT>if frequencies.get('<STR_LIT>'):<EOL><INDENT>variant_obj['<STR_LIT>'] = float(frequencies['<STR_LIT>'])<EOL><DEDENT>if frequencies.get('<STR_LIT>'):<EOL><INDENT>variant_obj['<STR_LIT>'] = float(frequencies['<STR_LIT>'])<EOL><DEDENT>if frequencies.get('<STR_LIT>'):<EOL><INDENT>variant_obj['<STR_LIT>'] = float(frequencies['<STR_LIT>'])<EOL><DEDENT>if variant.get('<STR_LIT>'):<EOL><INDENT>variant_obj['<STR_LIT>'] =  variant['<STR_LIT>']<EOL><DEDENT>if variant.get('<STR_LIT>'):<EOL><INDENT>variant_obj['<STR_LIT>'] = variant['<STR_LIT>']<EOL><DEDENT>if frequencies.get('<STR_LIT>'):<EOL><INDENT>variant_obj['<STR_LIT>'] = frequencies['<STR_LIT>']<EOL><DEDENT>if frequencies.get('<STR_LIT>'):<EOL><INDENT>variant_obj['<STR_LIT>'] = frequencies['<STR_LIT>']<EOL><DEDENT>if frequencies.get('<STR_LIT>'):<EOL><INDENT>variant_obj['<STR_LIT>'] = frequencies['<STR_LIT>']<EOL><DEDENT>if frequencies.get('<STR_LIT>'):<EOL><INDENT>variant_obj['<STR_LIT>'] = frequencies['<STR_LIT>']<EOL><DEDENT>if frequencies.get('<STR_LIT>'):<EOL><INDENT>variant_obj['<STR_LIT>'] = frequencies['<STR_LIT>']<EOL><DEDENT>elif frequencies.get('<STR_LIT>'):<EOL><INDENT>variant_obj['<STR_LIT>'] = frequencies['<STR_LIT>']<EOL><DEDENT>if variant.get('<STR_LIT>'):<EOL><INDENT>variant_obj['<STR_LIT>'] = variant['<STR_LIT>']<EOL><DEDENT>if variant.get('<STR_LIT>'):<EOL><INDENT>variant_obj['<STR_LIT>'] = variant['<STR_LIT>']<EOL><DEDENT>rank_results = []<EOL>for category in variant.get('<STR_LIT>', []):<EOL><INDENT>rank_result = {<EOL>'<STR_LIT>': category,<EOL>'<STR_LIT>': variant['<STR_LIT>'][category]<EOL>}<EOL>rank_results.append(rank_result)<EOL><DEDENT>if rank_results:<EOL><INDENT>variant_obj['<STR_LIT>'] = rank_results<EOL><DEDENT>if variant.get('<STR_LIT>'):<EOL><INDENT>variant_obj['<STR_LIT>'] = True<EOL><DEDENT>return variant_obj<EOL>", "docstring": "Build a variant object based on parsed information\n\n        Args:\n            variant(dict)\n            institute_id(str)\n            gene_to_panels(dict): A dictionary with\n                {<hgnc_id>: {\n                    'panel_names': [<panel_name>, ..],\n                    'disease_associated_transcripts': [<transcript_id>, ..]\n                    }\n                    .\n                    .\n                }\n\n            hgncid_to_gene(dict): A dictionary with\n                {<hgnc_id>: <hgnc_gene info>\n                    .\n                    .\n                }\n            sample_info(dict): A dictionary with info about samples.\n                               Strictly for cancer to tell which is tumor\n\n\n        Returns:\n            variant_obj(dict)\n\n        variant = dict(\n            # document_id is a md5 string created by institute_genelist_caseid_variantid:\n            _id = str, # required, same as document_id\n            document_id = str, # required\n            # variant_id is a md5 string created by chrom_pos_ref_alt (simple_id)\n            variant_id = str, # required\n            # display name is variant_id (no md5)\n            display_name = str, # required\n\n            # chrom_pos_ref_alt\n            simple_id = str,\n            # The variant can be either research or clinical.\n            # For research variants we display all the available information while\n            # the clinical variants have limited annotation fields.\n            variant_type = str, # required, choices=('research', 'clinical'))\n\n            category = str, # choices=('sv', 'snv', 'str')\n            sub_category = str, # choices=('snv', 'indel', 'del', 'ins', 'dup', 'inv', 'cnv', 'bnd')\n            mate_id = str, # For SVs this identifies the other end\n\n            case_id = str, # case_id is a string like owner_caseid\n            chromosome = str, # required\n            position = int, # required\n            end = int, # required\n            length = int, # required\n            reference = str, # required\n            alternative = str, # required\n\n            rank_score = float, # required\n            variant_rank = int, # required\n            rank_score_results = list, # List if dictionaries\n            variant_rank = int, # required\n\n            institute = str, # institute_id, required\n\n            sanger_ordered = bool,\n            validation = str, # Sanger validation, choices=('True positive', 'False positive')\n\n            quality = float,\n            filters = list, # list of strings\n            samples = list, # list of dictionaries that are <gt_calls>\n            genetic_models = list, # list of strings choices=GENETIC_MODELS\n            compounds = list, # sorted list of <compound> ordering='combined_score'\n\n            genes = list, # list with <gene>\n            dbsnp_id = str,\n\n            # Gene ids:\n            hgnc_ids = list, # list of hgnc ids (int)\n            hgnc_symbols = list, # list of hgnc symbols (str)\n            panels = list, # list of panel names that the variant ovelapps\n\n            # Frequencies:\n            thousand_genomes_frequency = float,\n            thousand_genomes_frequency_left = float,\n            thousand_genomes_frequency_right = float,\n            exac_frequency = float,\n            max_thousand_genomes_frequency = float,\n            max_exac_frequency = float,\n            local_frequency = float,\n            local_obs_old = int,\n            local_obs_hom_old = int,\n            local_obs_total_old = int, # default=638\n\n            # Predicted deleteriousness:\n            cadd_score = float,\n            clnsig = list, # list of <clinsig>\n            spidex = float,\n\n            missing_data = bool, # default False\n\n            # STR specific information\n            str_repid = str, repeat id generally corresponds to gene symbol\n            str_ru = str, used e g in PanelApp naming of STRs\n            str_ref = int, reference copy number\n            str_len = int, number of repeats found in case\n            str_status = str, this indicates the severity of the expansion level\n\n            # Callers\n            gatk = str, # choices=VARIANT_CALL, default='Not Used'\n            samtools = str, # choices=VARIANT_CALL, default='Not Used'\n            freebayes = str, # choices=VARIANT_CALL, default='Not Used'\n\n            # Conservation:\n            phast_conservation = list, # list of str, choices=CONSERVATION\n            gerp_conservation = list, # list of str, choices=CONSERVATION\n            phylop_conservation = list, # list of str, choices=CONSERVATION\n            # Database options:\n            gene_lists = list,\n            manual_rank = int, # choices=[0, 1, 2, 3, 4, 5]\n            dismiss_variant = list,\n\n            acmg_evaluation = str, # choices=ACMG_TERMS\n        )", "id": "f13622:m0"}
{"signature": "def build_hpo_term(hpo_info):", "body": "try:<EOL><INDENT>hpo_id = hpo_info['<STR_LIT>']<EOL><DEDENT>except KeyError:<EOL><INDENT>raise KeyError(\"<STR_LIT>\")<EOL><DEDENT>LOG.debug(\"<STR_LIT>\", hpo_id)<EOL>try:<EOL><INDENT>description = hpo_info['<STR_LIT:description>']<EOL><DEDENT>except KeyError:<EOL><INDENT>raise KeyError(\"<STR_LIT>\")<EOL><DEDENT>hpo_obj = HpoTerm(<EOL>hpo_id = hpo_id,<EOL>description = description<EOL>)<EOL>hgnc_ids = hpo_info.get('<STR_LIT>', set())<EOL>if hgnc_ids:<EOL><INDENT>hpo_obj['<STR_LIT>'] = list(hgnc_ids)<EOL><DEDENT>return hpo_obj<EOL>", "docstring": "Build a hpo_term object\n\n    Check that the information is correct and add the correct hgnc ids to the \n    array of genes.\n\n        Args:\n            hpo_info(dict)\n\n        Returns:\n            hpo_obj(scout.models.HpoTerm): A dictionary with hpo information", "id": "f13638:m0"}
{"signature": "def generate_hgnc(genes):", "body": "LOG.info(\"<STR_LIT>\")<EOL>hgnc_gene_lines = fetch_hgnc() <EOL>header = None<EOL>genes_found = <NUM_LIT:0><EOL>for i,line in enumerate(hgnc_gene_lines):<EOL><INDENT>line = line.rstrip()<EOL>if not len(line) > <NUM_LIT:0>:<EOL><INDENT>continue<EOL><DEDENT>if i == <NUM_LIT:0>:<EOL><INDENT>header = line.split('<STR_LIT:\\t>')<EOL>yield line<EOL>continue<EOL><DEDENT>gene = parse_hgnc_line(line, header)<EOL>if not gene:<EOL><INDENT>continue<EOL><DEDENT>hgnc_id = int(gene['<STR_LIT>'])<EOL>if hgnc_id in genes:<EOL><INDENT>genes_found += <NUM_LIT:1><EOL>yield line<EOL><DEDENT><DEDENT>LOG.info(\"<STR_LIT>\", genes_found)<EOL>", "docstring": "Generate lines from a file with reduced hgnc information\n\n    Args:\n        genes(dict): A dictionary with hgnc_id as key and hgnc_symbol as value\n        outpath(str): Defaults to hgnc_reduced_path\n\n    Yields:\n        print_line(str): Lines from the reduced file", "id": "f13667:m2"}
{"signature": "@alignviewers_bp.route('<STR_LIT>')<EOL>def igv():", "body": "chrom = request.args.get('<STR_LIT>')<EOL>if chrom == '<STR_LIT>':<EOL><INDENT>chrom = '<STR_LIT:M>'<EOL><DEDENT>start = request.args.get('<STR_LIT:start>')<EOL>stop = request.args.get('<STR_LIT>')<EOL>locus = \"<STR_LIT>\".format(chrom,start,stop)<EOL>LOG.debug('<STR_LIT>', locus)<EOL>chromosome_build = request.args.get('<STR_LIT>')<EOL>LOG.debug('<STR_LIT>', chromosome_build)<EOL>samples = request.args.getlist('<STR_LIT>')<EOL>bam_files = request.args.getlist('<STR_LIT>')<EOL>bai_files = request.args.getlist('<STR_LIT>')<EOL>LOG.debug('<STR_LIT>', bam_files)<EOL>display_obj={}<EOL>fastaURL = '<STR_LIT>'<EOL>indexURL = '<STR_LIT>'<EOL>cytobandURL = '<STR_LIT>'<EOL>gene_track_format = '<STR_LIT>'<EOL>gene_track_URL = '<STR_LIT>'<EOL>gene_track_indexURL = '<STR_LIT>'<EOL>if chromosome_build == \"<STR_LIT>\" or chrom == '<STR_LIT:M>':<EOL><INDENT>fastaURL = '<STR_LIT>'<EOL>indexURL = '<STR_LIT>'<EOL>cytobandURL = '<STR_LIT>'<EOL>gene_track_format = '<STR_LIT>'<EOL>gene_track_URL = '<STR_LIT>'<EOL>gene_track_indexURL = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>fastaURL = '<STR_LIT>'<EOL>indexURL = '<STR_LIT>'<EOL>cytobandURL = '<STR_LIT>'<EOL>gene_track_format = '<STR_LIT>'<EOL>gene_track_URL = '<STR_LIT>'<EOL>gene_track_indexURL = '<STR_LIT>'<EOL><DEDENT>display_obj['<STR_LIT>'] = {<EOL>'<STR_LIT>' : fastaURL,<EOL>'<STR_LIT>' : indexURL,<EOL>'<STR_LIT>' : cytobandURL<EOL>}<EOL>display_obj['<STR_LIT>'] = {<EOL>'<STR_LIT:name>' : '<STR_LIT>',<EOL>'<STR_LIT:type>' : '<STR_LIT>',<EOL>'<STR_LIT>': gene_track_format,<EOL>'<STR_LIT>': '<STR_LIT:file>',<EOL>'<STR_LIT:url>' : gene_track_URL,<EOL>'<STR_LIT>' : gene_track_indexURL,<EOL>'<STR_LIT>' : '<STR_LIT>'<EOL>}<EOL>sample_tracks = []<EOL>counter = <NUM_LIT:0><EOL>for sample in samples:<EOL><INDENT>if bam_files[counter]:<EOL><INDENT>sample_tracks.append({ '<STR_LIT:name>' : sample, '<STR_LIT:url>' : bam_files[counter],<EOL>'<STR_LIT>' : bai_files[counter],<EOL>'<STR_LIT>' : <NUM_LIT>, '<STR_LIT>' : <NUM_LIT>})<EOL><DEDENT>counter += <NUM_LIT:1><EOL><DEDENT>display_obj['<STR_LIT>'] = sample_tracks<EOL>if request.args.get('<STR_LIT>'):<EOL><INDENT>display_obj['<STR_LIT>'] = True<EOL><DEDENT>else:<EOL><INDENT>display_obj['<STR_LIT>'] = False<EOL><DEDENT>return render_template('<STR_LIT>', locus=locus, **display_obj )<EOL>", "docstring": "Visualize BAM alignments using igv.js (https://github.com/igvteam/igv.js)", "id": "f13672:m2"}
{"signature": "def __init__(self, user_data):", "body": "self.roles = []<EOL>for key, value in user_data.items():<EOL><INDENT>setattr(self, key, value)<EOL><DEDENT>", "docstring": "Create a new user object.", "id": "f13677:c0:m0"}
{"signature": "def users(store):", "body": "user_objs = list(store.users())<EOL>total_events = store.user_events().count()<EOL>for user_obj in user_objs:<EOL><INDENT>if user_obj.get('<STR_LIT>'):<EOL><INDENT>user_obj['<STR_LIT>'] = [store.institute(inst_id) for inst_id in user_obj.get('<STR_LIT>')]<EOL><DEDENT>else:<EOL><INDENT>user_obj['<STR_LIT>'] = []<EOL><DEDENT>user_obj['<STR_LIT>'] = store.user_events(user_obj).count()<EOL>user_obj['<STR_LIT>'] = event_rank(user_obj['<STR_LIT>'])<EOL><DEDENT>return dict(<EOL>users=sorted(user_objs, key=lambda user: -user['<STR_LIT>']),<EOL>total_events=total_events,<EOL>)<EOL>", "docstring": "Display a list of all users and which institutes they belong to.", "id": "f13678:m1"}
{"signature": "def update_panel(store, panel_name, csv_lines, option):", "body": "new_genes= []<EOL>panel_obj = store.gene_panel(panel_name)<EOL>if panel_obj is None:<EOL><INDENT>return None<EOL><DEDENT>try:<EOL><INDENT>new_genes = parse_genes(csv_lines) <EOL><DEDENT>except SyntaxError as error:<EOL><INDENT>flash(error.args[<NUM_LIT:0>], '<STR_LIT>')<EOL>return None<EOL><DEDENT>if option == '<STR_LIT:replace>':<EOL><INDENT>for gene in panel_obj['<STR_LIT>']:<EOL><INDENT>gene['<STR_LIT>'] = gene['<STR_LIT>']<EOL>store.add_pending(panel_obj, gene, action='<STR_LIT>', info=None)<EOL><DEDENT><DEDENT>for new_gene in new_genes:<EOL><INDENT>if not new_gene['<STR_LIT>']:<EOL><INDENT>flash(\"<STR_LIT>\".format(new_gene['<STR_LIT>']),'<STR_LIT>')<EOL>continue<EOL><DEDENT>gene_obj = store.hgnc_gene(new_gene['<STR_LIT>'])<EOL>if gene_obj is None:<EOL><INDENT>flash(\"<STR_LIT>\".format(new_gene['<STR_LIT>'], new_gene['<STR_LIT>']),'<STR_LIT>')<EOL>continue<EOL><DEDENT>if new_gene['<STR_LIT>'] and gene_obj['<STR_LIT>'] != new_gene['<STR_LIT>']:<EOL><INDENT>flash(\"<STR_LIT>\".format(<EOL>gene_obj['<STR_LIT>'], new_gene['<STR_LIT>']), '<STR_LIT>')<EOL><DEDENT>info_data = {<EOL>'<STR_LIT>': new_gene['<STR_LIT>'],<EOL>'<STR_LIT>': new_gene['<STR_LIT>'],<EOL>'<STR_LIT>': new_gene['<STR_LIT>'],<EOL>'<STR_LIT>': new_gene['<STR_LIT>'],<EOL>'<STR_LIT>': new_gene['<STR_LIT>'],<EOL>}<EOL>if option == '<STR_LIT:replace>': <EOL><INDENT>action = '<STR_LIT>'<EOL><DEDENT>else: <EOL><INDENT>existing_genes = {gene['<STR_LIT>'] for gene in panel_obj['<STR_LIT>']}<EOL>action = '<STR_LIT>' if gene_obj['<STR_LIT>'] in existing_genes else '<STR_LIT>'<EOL><DEDENT>store.add_pending(panel_obj, gene_obj, action=action, info=info_data)<EOL><DEDENT>return panel_obj<EOL>", "docstring": "Update an existing gene panel with genes.\n\n    Args:\n        store(scout.adapter.MongoAdapter)\n        panel_name(str)\n        csv_lines(iterable(str)): Stream with genes\n        option(str): 'add' or 'replace'\n\n    Returns:\n        panel_obj(dict)", "id": "f13692:m2"}
{"signature": "@variants_bp.route('<STR_LIT>')<EOL>@templated('<STR_LIT>')<EOL>def sv_variant(institute_id, case_name, variant_id):", "body": "data = controllers.sv_variant(store, institute_id, case_name, variant_id)<EOL>return data<EOL>", "docstring": "Display a specific structural variant.", "id": "f13693:m4"}
{"signature": "@variants_bp.route('<STR_LIT>',<EOL>methods=['<STR_LIT:GET>','<STR_LIT:POST>'])<EOL>@templated('<STR_LIT>')<EOL>def sv_variants(institute_id, case_name):", "body": "page = int(request.form.get('<STR_LIT>', <NUM_LIT:1>))<EOL>variant_type = request.args.get('<STR_LIT>', '<STR_LIT>')<EOL>institute_obj, case_obj = institute_and_case(store, institute_id, case_name)<EOL>form = SvFiltersForm(request.form)<EOL>default_panels = []<EOL>for panel in case_obj['<STR_LIT>']:<EOL><INDENT>if panel['<STR_LIT>']:<EOL><INDENT>default_panels.append(panel['<STR_LIT>'])<EOL><DEDENT><DEDENT>request.form.get('<STR_LIT>')<EOL>if bool(request.form.get('<STR_LIT>')):<EOL><INDENT>clinical_filter = MultiDict({<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': ['<STR_LIT>','<STR_LIT>'],<EOL>'<STR_LIT>': SEVERE_SO_TERMS,<EOL>'<STR_LIT>': str(institute_obj['<STR_LIT>']),<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': <NUM_LIT:10>,<EOL>'<STR_LIT>': <NUM_LIT:10>,<EOL>'<STR_LIT:size>': <NUM_LIT:100>,<EOL>'<STR_LIT>': default_panels<EOL>})<EOL><DEDENT>if(request.method == \"<STR_LIT:POST>\"):<EOL><INDENT>if bool(request.form.get('<STR_LIT>')):<EOL><INDENT>form = SvFiltersForm(clinical_filter)<EOL>form.csrf_token = request.args.get('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>form = SvFiltersForm(request.form)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>form = SvFiltersForm(request.args)<EOL><DEDENT>available_panels = case_obj.get('<STR_LIT>', []) + [<EOL>{'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>'}]<EOL>panel_choices = [(panel['<STR_LIT>'], panel['<STR_LIT>'])<EOL>for panel in available_panels]<EOL>form.gene_panels.choices = panel_choices<EOL>if form.data['<STR_LIT>'] == ['<STR_LIT>']:<EOL><INDENT>hpo_symbols = list(set(term_obj['<STR_LIT>'] for term_obj in<EOL>case_obj['<STR_LIT>']))<EOL>form.hgnc_symbols.data = hpo_symbols<EOL><DEDENT>if case_obj['<STR_LIT:status>'] == '<STR_LIT>' and not current_user.is_admin:<EOL><INDENT>flash('<STR_LIT>', '<STR_LIT:info>')<EOL>user_obj = store.user(current_user.email)<EOL>case_link = url_for('<STR_LIT>', institute_id=institute_obj['<STR_LIT>'],<EOL>case_name=case_obj['<STR_LIT>'])<EOL>store.update_status(institute_obj, case_obj, user_obj, '<STR_LIT>', case_link)<EOL><DEDENT>variants_query = store.variants(case_obj['<STR_LIT>'], category='<STR_LIT>',<EOL>query=form.data)<EOL>data = {}<EOL>if request.form.get('<STR_LIT>'):<EOL><INDENT>document_header = controllers.variants_export_header(case_obj)<EOL>export_lines = []<EOL>export_lines = controllers.variant_export_lines(store, case_obj, variants_query.limit(<NUM_LIT>))<EOL>def generate(header, lines):<EOL><INDENT>yield header + '<STR_LIT:\\n>'<EOL>for line in lines:<EOL><INDENT>yield line + '<STR_LIT:\\n>'<EOL><DEDENT><DEDENT>headers = Headers()<EOL>headers.add('<STR_LIT>','<STR_LIT>', filename=str(case_obj['<STR_LIT>'])+'<STR_LIT>')<EOL>return Response(generate(\"<STR_LIT:U+002C>\".join(document_header), export_lines), mimetype='<STR_LIT>', headers=headers) <EOL><DEDENT>else:<EOL><INDENT>data = controllers.sv_variants(store, institute_obj, case_obj,<EOL>variants_query, page)<EOL><DEDENT>return dict(institute=institute_obj, case=case_obj, variant_type=variant_type,<EOL>form=form, severe_so_terms=SEVERE_SO_TERMS, page=page, **data)<EOL>", "docstring": "Display a list of structural variants.", "id": "f13693:m3"}
{"signature": "@variants_bp.route('<STR_LIT>', methods=['<STR_LIT:POST>'])<EOL>def upload_panel(institute_id, case_name):", "body": "file = form.symbol_file.data<EOL>if file.filename == '<STR_LIT>':<EOL><INDENT>flash('<STR_LIT>', '<STR_LIT>')<EOL>return redirect(request.referrer)<EOL><DEDENT>try:<EOL><INDENT>stream = io.StringIO(file.stream.read().decode('<STR_LIT:utf-8>'), newline=None)<EOL><DEDENT>except UnicodeDecodeError as error:<EOL><INDENT>flash(\"<STR_LIT>\", '<STR_LIT>')<EOL>return redirect(request.referrer)<EOL><DEDENT>category = request.args.get('<STR_LIT>')<EOL>if(category == '<STR_LIT>'):<EOL><INDENT>form = SvFiltersForm(request.args)<EOL><DEDENT>else:<EOL><INDENT>form = FiltersForm(request.args)<EOL><DEDENT>hgnc_symbols = set(form.hgnc_symbols.data)<EOL>new_hgnc_symbols = controllers.upload_panel(store, institute_id, case_name, stream)<EOL>hgnc_symbols.update(new_hgnc_symbols)<EOL>form.hgnc_symbols.data = '<STR_LIT:U+002C>'.join(hgnc_symbols)<EOL>form.gene_panels.data = '<STR_LIT>'<EOL>if(category == '<STR_LIT>'):<EOL><INDENT>return redirect(url_for('<STR_LIT>', institute_id=institute_id, case_name=case_name,<EOL>**form.data), code=<NUM_LIT>)<EOL><DEDENT>else:<EOL><INDENT>return redirect(url_for('<STR_LIT>', institute_id=institute_id, case_name=case_name,<EOL>**form.data), code=<NUM_LIT>)<EOL><DEDENT>", "docstring": "Parse gene panel file and fill in HGNC symbols for filter.", "id": "f13693:m13"}
{"signature": "@variants_bp.route('<STR_LIT>', methods=['<STR_LIT:GET>'])<EOL>def download_verified():", "body": "user_obj = store.user(current_user.email)<EOL>user_institutes = user_obj.get('<STR_LIT>')<EOL>temp_excel_dir = os.path.join(variants_bp.static_folder, '<STR_LIT>')<EOL>os.makedirs(temp_excel_dir, exist_ok=True)<EOL>written_files = controllers.verified_excel_file(store, user_institutes, temp_excel_dir)<EOL>if written_files:<EOL><INDENT>today = datetime.datetime.now().strftime('<STR_LIT>')<EOL>data = io.BytesIO()<EOL>with zipfile.ZipFile(data, mode='<STR_LIT:w>') as z:<EOL><INDENT>for f_name in pathlib.Path(temp_excel_dir).iterdir():<EOL><INDENT>zipfile.ZipFile<EOL>z.write(f_name, os.path.basename(f_name))<EOL><DEDENT><DEDENT>data.seek(<NUM_LIT:0>)<EOL>shutil.rmtree(temp_excel_dir)<EOL>return send_file(<EOL>data,<EOL>mimetype='<STR_LIT>',<EOL>as_attachment=True,<EOL>attachment_filename='<STR_LIT:_>'.join(['<STR_LIT>', '<STR_LIT>', today])+'<STR_LIT>'<EOL>)<EOL><DEDENT>else:<EOL><INDENT>flash(\"<STR_LIT>\", '<STR_LIT>')<EOL>return redirect(request.referrer)<EOL><DEDENT>", "docstring": "Download all verified variants for user's cases", "id": "f13693:m14"}
{"signature": "@variants_bp.route('<STR_LIT>')<EOL>@templated('<STR_LIT>')<EOL>def str_variant(institute_id, case_name, variant_id):", "body": "data = controllers.str_variant(store, institute_id, case_name, variant_id)<EOL>return data<EOL>", "docstring": "Display a specific STR variant.", "id": "f13693:m5"}
{"signature": "def clinsig_human(variant_obj):", "body": "for clinsig_obj in variant_obj['<STR_LIT>']:<EOL><INDENT>if isinstance(clinsig_obj['<STR_LIT>'], int):<EOL><INDENT>link = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>link = \"<STR_LIT>\"<EOL><DEDENT>human_str = '<STR_LIT>'<EOL>if clinsig_obj.get('<STR_LIT:value>'):<EOL><INDENT>try:<EOL><INDENT>int(clinsig_obj['<STR_LIT:value>'])<EOL>human_str = CLINSIG_MAP.get(clinsig_obj['<STR_LIT:value>'], '<STR_LIT>')<EOL><DEDENT>except ValueError:<EOL><INDENT>human_str = clinsig_obj['<STR_LIT:value>']<EOL><DEDENT><DEDENT>clinsig_obj['<STR_LIT>'] = human_str<EOL>clinsig_obj['<STR_LIT>'] = link.format(clinsig_obj['<STR_LIT>'])<EOL>yield clinsig_obj<EOL><DEDENT>", "docstring": "Convert to human readable version of CLINSIG evaluation.", "id": "f13696:m19"}
{"signature": "def variant_acmg(store, institute_id, case_name, variant_id):", "body": "institute_obj, case_obj = institute_and_case(store, institute_id, case_name)<EOL>variant_obj = store.variant(variant_id)<EOL>return dict(institute=institute_obj, case=case_obj, variant=variant_obj,<EOL>CRITERIA=ACMG_CRITERIA, ACMG_OPTIONS=ACMG_OPTIONS)<EOL>", "docstring": "Collect data relevant for rendering ACMG classification form.", "id": "f13696:m36"}
{"signature": "def parse_transcript(gene_obj, tx_obj, build=None):", "body": "build = build or <NUM_LIT><EOL>add_tx_links(tx_obj, build)<EOL>if tx_obj.get('<STR_LIT>'):<EOL><INDENT>gene_name = (gene_obj['<STR_LIT>']['<STR_LIT>'] if gene_obj['<STR_LIT>'] else<EOL>gene_obj['<STR_LIT>'])<EOL>tx_obj['<STR_LIT>'] = transcript_str(tx_obj, gene_name)<EOL><DEDENT>", "docstring": "Parse variant gene transcript (VEP).", "id": "f13696:m15"}
{"signature": "def get_variant_info(genes):", "body": "data = {'<STR_LIT>': []}<EOL>for gene_obj in genes:<EOL><INDENT>if not gene_obj.get('<STR_LIT>'):<EOL><INDENT>tx = gene_obj['<STR_LIT>'][<NUM_LIT:0>]<EOL>tx_id = tx['<STR_LIT>']<EOL>exon = tx.get('<STR_LIT>', '<STR_LIT:->')<EOL>c_seq = tx.get('<STR_LIT>', '<STR_LIT:->')<EOL><DEDENT>else:<EOL><INDENT>tx_id = gene_obj['<STR_LIT>']<EOL>exon = gene_obj.get('<STR_LIT>', '<STR_LIT:->')<EOL>c_seq = gene_obj.get('<STR_LIT>', '<STR_LIT:->')<EOL><DEDENT>if len(c_seq) > <NUM_LIT:20>:<EOL><INDENT>c_seq = c_seq[:<NUM_LIT:20>] + '<STR_LIT>'<EOL><DEDENT>if len(genes) == <NUM_LIT:1>:<EOL><INDENT>value = '<STR_LIT::>'.join([tx_id,exon,c_seq])<EOL><DEDENT>else:<EOL><INDENT>gene_id = gene_obj.get('<STR_LIT>') or str(gene_obj['<STR_LIT>'])<EOL>value = '<STR_LIT::>'.join([gene_id, tx_id,exon,c_seq])<EOL><DEDENT>data['<STR_LIT>'].append(value)<EOL><DEDENT>return data<EOL>", "docstring": "Get variant information", "id": "f13696:m8"}
{"signature": "def frequency(variant_obj):", "body": "most_common_frequency = max(variant_obj.get('<STR_LIT>') or <NUM_LIT:0>,<EOL>variant_obj.get('<STR_LIT>') or <NUM_LIT:0>)<EOL>if most_common_frequency > <NUM_LIT>:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>elif most_common_frequency > <NUM_LIT>:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>", "docstring": "Returns a judgement on the overall frequency of the variant.\n\n    Combines multiple metrics into a single call.", "id": "f13696:m18"}
{"signature": "def variant_export_lines(store, case_obj, variants_query):", "body": "export_variants = []<EOL>for variant in variants_query:<EOL><INDENT>variant_line = []<EOL>position = variant['<STR_LIT>']<EOL>change = variant['<STR_LIT>']+'<STR_LIT:>>'+variant['<STR_LIT>']<EOL>variant_line.append(variant['<STR_LIT>'])<EOL>variant_line.append(variant['<STR_LIT>'])<EOL>variant_line.append(position)<EOL>variant_line.append(change)<EOL>variant_line.append('<STR_LIT:_>'.join([str(position), change]))<EOL>gene_list = variant.get('<STR_LIT>') <EOL>gene_ids = []<EOL>gene_names = []<EOL>hgvs_c = []<EOL>if len(gene_list) > <NUM_LIT:0>:<EOL><INDENT>for gene_obj in gene_list:<EOL><INDENT>hgnc_id = gene_obj['<STR_LIT>']<EOL>gene_name = gene(store, hgnc_id)['<STR_LIT>']<EOL>gene_ids.append(hgnc_id)<EOL>gene_names.append(gene_name)<EOL>hgvs_nucleotide = '<STR_LIT:->'<EOL>transcripts_list = gene_obj.get('<STR_LIT>')<EOL>for transcript_obj in transcripts_list:<EOL><INDENT>if transcript_obj.get('<STR_LIT>') and transcript_obj.get('<STR_LIT>') is True:<EOL><INDENT>hgvs_nucleotide = str(transcript_obj.get('<STR_LIT>'))<EOL><DEDENT><DEDENT>hgvs_c.append(hgvs_nucleotide)<EOL><DEDENT>variant_line.append('<STR_LIT:;>'.join( str(x) for x in  gene_ids))<EOL>variant_line.append('<STR_LIT:;>'.join( str(x) for x in  gene_names))<EOL>variant_line.append('<STR_LIT:;>'.join( str(x) for x in  hgvs_c))<EOL><DEDENT>else:<EOL><INDENT>while i < <NUM_LIT:4>:<EOL><INDENT>variant_line.append('<STR_LIT:->') <EOL>i = i+<NUM_LIT:1><EOL><DEDENT><DEDENT>variant_gts = variant['<STR_LIT>'] <EOL>for individual in case_obj['<STR_LIT>']:<EOL><INDENT>for variant_gt in variant_gts:<EOL><INDENT>if individual['<STR_LIT>'] == variant_gt['<STR_LIT>']:<EOL><INDENT>variant_line.append(variant_gt['<STR_LIT>'][<NUM_LIT:0>]) <EOL>variant_line.append(variant_gt['<STR_LIT>'][<NUM_LIT:1>]) <EOL>variant_line.append(variant_gt['<STR_LIT>'])<EOL><DEDENT><DEDENT><DEDENT>variant_line = [str(i) for i in variant_line]<EOL>export_variants.append(\"<STR_LIT:U+002C>\".join(variant_line))<EOL><DEDENT>return export_variants<EOL>", "docstring": "Get variants info to be exported to file, one list (line) per variant.\n\n        Args:\n            store(scout.adapter.MongoAdapter)\n            case_obj(scout.models.Case)\n            variants_query: a list of variant objects, each one is a dictionary\n\n        Returns:\n            export_variants: a list of strings. Each string  of the list corresponding to the fields\n                             of a variant to be exported to file, separated by comma", "id": "f13696:m6"}
{"signature": "def clinvar_export(store, institute_id, case_name, variant_id):", "body": "institute_obj, case_obj = institute_and_case(store, institute_id, case_name)<EOL>pinned = [store.variant(variant_id) or variant_id for variant_id in<EOL>case_obj.get('<STR_LIT>', [])]<EOL>variant_obj = store.variant(variant_id)<EOL>return dict(<EOL>today = str(date.today()),<EOL>institute=institute_obj,<EOL>case=case_obj,<EOL>variant=variant_obj,<EOL>pinned_vars=pinned<EOL>)<EOL>", "docstring": "Gather the required data for creating the clinvar submission form\n\n        Args:\n            store(scout.adapter.MongoAdapter)\n            institute_id(str): Institute ID\n            case_name(str): case ID\n            variant_id(str): variant._id\n\n        Returns:\n            a dictionary with all the required data (case and variant level) to pre-fill in fields in the clinvar submission form", "id": "f13696:m34"}
{"signature": "def parse_variant(store, institute_obj, case_obj, variant_obj, update=False, genome_build='<STR_LIT>',<EOL>get_compounds = True):", "body": "has_changed = False<EOL>compounds = variant_obj.get('<STR_LIT>', [])<EOL>if compounds and get_compounds:<EOL><INDENT>if '<STR_LIT>' not in compounds[<NUM_LIT:0>]:<EOL><INDENT>new_compounds = store.update_variant_compounds(variant_obj)<EOL>variant_obj['<STR_LIT>'] = new_compounds<EOL>has_changed = True<EOL><DEDENT>variant_obj['<STR_LIT>'] = sorted(variant_obj['<STR_LIT>'],<EOL>key=lambda compound: -compound['<STR_LIT>'])<EOL><DEDENT>variant_genes = variant_obj.get('<STR_LIT>')<EOL>if variant_genes is not None:<EOL><INDENT>for gene_obj in variant_genes:<EOL><INDENT>if not gene_obj['<STR_LIT>']:<EOL><INDENT>continue<EOL><DEDENT>if gene_obj.get('<STR_LIT>') is None:<EOL><INDENT>hgnc_gene = store.hgnc_gene(gene_obj['<STR_LIT>'], build=genome_build)<EOL>if not hgnc_gene:<EOL><INDENT>continue<EOL><DEDENT>has_changed = True<EOL>gene_obj['<STR_LIT>'] = hgnc_gene['<STR_LIT>']<EOL><DEDENT><DEDENT><DEDENT>if update and has_changed:<EOL><INDENT>variant_obj = store.update_variant(variant_obj)<EOL><DEDENT>variant_obj['<STR_LIT>'] = store.events(institute_obj, case=case_obj,<EOL>variant_id=variant_obj['<STR_LIT>'], comments=True)<EOL>if variant_genes:<EOL><INDENT>variant_obj.update(get_predictions(variant_genes))<EOL>if variant_obj.get('<STR_LIT>') == '<STR_LIT>':<EOL><INDENT>variant_obj.update(get_variant_info(variant_genes))<EOL><DEDENT><DEDENT>for compound_obj in compounds:<EOL><INDENT>compound_obj.update(get_predictions(compound_obj.get('<STR_LIT>', [])))<EOL><DEDENT>if isinstance(variant_obj.get('<STR_LIT>'), int):<EOL><INDENT>acmg_code = ACMG_MAP[variant_obj['<STR_LIT>']]<EOL>variant_obj['<STR_LIT>'] = ACMG_COMPLETE_MAP[acmg_code]<EOL><DEDENT>variant_length = variant_obj.get('<STR_LIT>')<EOL>variant_obj['<STR_LIT>'] = {<NUM_LIT>: '<STR_LIT>', -<NUM_LIT:1>: '<STR_LIT>'}.get(variant_length, variant_length)<EOL>if not '<STR_LIT>' in variant_obj:<EOL><INDENT>variant_obj['<STR_LIT>'] = variant_obj['<STR_LIT>']<EOL><DEDENT>return variant_obj<EOL>", "docstring": "Parse information about variants.\n\n    - Adds information about compounds\n    - Updates the information about compounds if necessary and 'update=True'\n\n    Args:\n        store(scout.adapter.MongoAdapter)\n        institute_obj(scout.models.Institute)\n        case_obj(scout.models.Case)\n        variant_obj(scout.models.Variant)\n        update(bool): If variant should be updated in database\n        genome_build(str)", "id": "f13696:m5"}
{"signature": "def sv_variants(store, institute_obj, case_obj, variants_query, page=<NUM_LIT:1>, per_page=<NUM_LIT:50>):", "body": "skip_count = (per_page * max(page - <NUM_LIT:1>, <NUM_LIT:0>))<EOL>more_variants = True if variants_query.count() > (skip_count + per_page) else False<EOL>genome_build = case_obj.get('<STR_LIT>', '<STR_LIT>')<EOL>if genome_build not in ['<STR_LIT>','<STR_LIT>']:<EOL><INDENT>genome_build = '<STR_LIT>'<EOL><DEDENT>return {<EOL>'<STR_LIT>': (parse_variant(store, institute_obj, case_obj, variant, genome_build=genome_build) for variant in<EOL>variants_query.skip(skip_count).limit(per_page)),<EOL>'<STR_LIT>': more_variants,<EOL>}<EOL>", "docstring": "Pre-process list of SV variants.", "id": "f13696:m1"}
{"signature": "def get_predictions(genes):", "body": "data = {<EOL>'<STR_LIT>': [],<EOL>'<STR_LIT>': [],<EOL>'<STR_LIT>': [],<EOL>'<STR_LIT>': []<EOL>}<EOL>for gene_obj in genes:<EOL><INDENT>for pred_key in data:<EOL><INDENT>gene_key = pred_key[:-<NUM_LIT:1>]<EOL>if len(genes) == <NUM_LIT:1>:<EOL><INDENT>value = gene_obj.get(gene_key, '<STR_LIT:->')<EOL><DEDENT>else:<EOL><INDENT>gene_id = gene_obj.get('<STR_LIT>') or str(gene_obj['<STR_LIT>'])<EOL>value = '<STR_LIT::>'.join([gene_id, gene_obj.get(gene_key, '<STR_LIT:->')])<EOL><DEDENT>data[pred_key].append(value)<EOL><DEDENT><DEDENT>return data<EOL>", "docstring": "Get sift predictions from genes.", "id": "f13696:m9"}
{"signature": "def variant_verification(store, mail, institute_obj, case_obj, user_obj, variant_obj, sender, variant_url, order, comment, url_builder=url_for):", "body": "recipients = institute_obj['<STR_LIT>']<EOL>if len(recipients) == <NUM_LIT:0>:<EOL><INDENT>raise MissingSangerRecipientError()<EOL><DEDENT>view_type = None<EOL>email_subject = None<EOL>category = variant_obj.get('<STR_LIT>')<EOL>display_name = None<EOL>chromosome = variant_obj['<STR_LIT>']<EOL>end_chrom = variant_obj.get('<STR_LIT>', chromosome)<EOL>breakpoint_1 = '<STR_LIT::>'.join([chromosome, str(variant_obj['<STR_LIT>'])])<EOL>breakpoint_2 = '<STR_LIT::>'.join([end_chrom, str(variant_obj.get('<STR_LIT:end>'))])<EOL>variant_size = variant_obj.get('<STR_LIT>')<EOL>panels = '<STR_LIT:U+002CU+0020>'.join(variant_obj.get('<STR_LIT>', []))<EOL>hgnc_symbol = '<STR_LIT:U+002CU+0020>'.join(variant_obj['<STR_LIT>'])<EOL>email_subj_gene_symbol = None<EOL>if len(variant_obj['<STR_LIT>']) > <NUM_LIT:3>:<EOL><INDENT>email_subj_gene_symbol = '<STR_LIT:U+0020>'.join([ str(len(variant_obj['<STR_LIT>'])) + '<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>email_subj_gene_symbol = hgnc_symbol<EOL><DEDENT>gtcalls = [\"<STR_LIT>\".format(sample_obj['<STR_LIT>'],<EOL>sample_obj['<STR_LIT>'])<EOL>for sample_obj in variant_obj['<STR_LIT>']]<EOL>tx_changes = []<EOL>if category == '<STR_LIT>': <EOL><INDENT>view_type = '<STR_LIT>'<EOL>display_name = variant_obj.get('<STR_LIT>')<EOL>tx_changes = []<EOL>for gene_obj in variant_obj.get('<STR_LIT>', []):<EOL><INDENT>for tx_obj in gene_obj['<STR_LIT>']:<EOL><INDENT>parse_transcript(gene_obj, tx_obj)<EOL>if not tx_obj.get('<STR_LIT>'):<EOL><INDENT>continue<EOL><DEDENT>for refseq_id in tx_obj.get('<STR_LIT>'):<EOL><INDENT>transcript_line = []<EOL>if \"<STR_LIT>\" in gene_obj:<EOL><INDENT>transcript_line.append(gene_obj['<STR_LIT>']['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>transcript_line.append(gene_obj['<STR_LIT>'])<EOL><DEDENT>transcript_line.append('<STR_LIT:->'.join([refseq_id, tx_obj['<STR_LIT>']]))<EOL>if \"<STR_LIT>\" in tx_obj:<EOL><INDENT>transcript_line.append('<STR_LIT>'.join([ \"<STR_LIT>\", tx_obj[\"<STR_LIT>\"]]))<EOL><DEDENT>elif \"<STR_LIT>\" in tx_obj:<EOL><INDENT>transcript_line.append('<STR_LIT>'.join([ \"<STR_LIT>\", tx_obj[\"<STR_LIT>\"]]))<EOL><DEDENT>else:<EOL><INDENT>transcript_line.append('<STR_LIT>')<EOL><DEDENT>if \"<STR_LIT>\" in tx_obj:<EOL><INDENT>transcript_line.append(urllib.parse.unquote(tx_obj['<STR_LIT>']))<EOL><DEDENT>else:<EOL><INDENT>transcript_line.append('<STR_LIT>')<EOL><DEDENT>if \"<STR_LIT>\" in tx_obj:<EOL><INDENT>transcript_line.append(urllib.parse.unquote(tx_obj['<STR_LIT>']))<EOL><DEDENT>else:<EOL><INDENT>transcript_line.append('<STR_LIT>')<EOL><DEDENT>tx_changes.append(\"<STR_LIT>\".format('<STR_LIT::>'.join(transcript_line)))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>else: <EOL><INDENT>view_type = '<STR_LIT>'<EOL>display_name = '<STR_LIT:_>'.join([breakpoint_1, variant_obj.get('<STR_LIT>').upper()])<EOL><DEDENT>html = verification_email_body(<EOL>case_name = case_obj['<STR_LIT>'],<EOL>url = variant_url, <EOL>display_name = display_name,<EOL>category = category.upper(),<EOL>subcategory = variant_obj.get('<STR_LIT>').upper(),<EOL>breakpoint_1 = breakpoint_1,<EOL>breakpoint_2 = breakpoint_2,<EOL>hgnc_symbol = hgnc_symbol,<EOL>panels = panels,<EOL>gtcalls = '<STR_LIT>'.join(gtcalls),<EOL>tx_changes = '<STR_LIT>'.join(tx_changes) or '<STR_LIT>',<EOL>name = user_obj['<STR_LIT:name>'].encode('<STR_LIT:utf-8>'),<EOL>comment = comment<EOL>)<EOL>local_link = url_builder(view_type, institute_id=institute_obj['<STR_LIT>'],<EOL>case_name=case_obj['<STR_LIT>'],<EOL>variant_id=variant_obj['<STR_LIT>'])<EOL>if order == '<STR_LIT:True>': <EOL><INDENT>if case_obj.get('<STR_LIT>') is None or variant_obj['<STR_LIT>'] not in case_obj['<STR_LIT>']:<EOL><INDENT>store.pin_variant(institute_obj, case_obj, user_obj, local_link, variant_obj)<EOL><DEDENT>email_subject = \"<STR_LIT>\".format( category.upper(), display_name, email_subj_gene_symbol)<EOL>store.order_verification(institute=institute_obj, case=case_obj, user=user_obj, link=local_link, variant=variant_obj)<EOL><DEDENT>else: <EOL><INDENT>email_subject = \"<STR_LIT>\".format(category.upper(), display_name, email_subj_gene_symbol)<EOL>store.cancel_verification(institute=institute_obj, case=case_obj, user=user_obj, link=local_link, variant=variant_obj)<EOL><DEDENT>kwargs = dict(subject=email_subject, html=html, sender=sender, recipients=recipients,<EOL>cc=[user_obj['<STR_LIT:email>']])<EOL>message = Message(**kwargs)<EOL>mail.send(message)<EOL>", "docstring": "Sand a verification email and register the verification in the database\n\n        Args:\n            store(scout.adapter.MongoAdapter)\n            mail(scout.server.extensions.mail): an instance of flask_mail.Mail\n            institute_obj(dict): an institute object\n            case_obj(dict): a case object\n            user_obj(dict): a user object\n            variant_obj(dict): a variant object (snv or sv)\n            sender(str): current_app.config['MAIL_USERNAME']\n            variant_url(str): the complete url to the variant (snv or sv), a link that works from outside scout domain.\n            order(str): False == cancel order, True==order verification\n            comment(str): sender's entered comment from form\n            url_builder(flask.url_for): for testing purposes, otherwise test verification email fails because out of context", "id": "f13696:m31"}
{"signature": "@cases_bp.route('<STR_LIT>', methods=['<STR_LIT:POST>'])<EOL>@cases_bp.route('<STR_LIT>',<EOL>methods=['<STR_LIT:POST>'])<EOL>def phenotypes(institute_id, case_name, phenotype_id=None):", "body": "institute_obj, case_obj = institute_and_case(store, institute_id, case_name)<EOL>case_url = url_for('<STR_LIT>', institute_id=institute_id, case_name=case_name)<EOL>is_group = request.args.get('<STR_LIT>') == '<STR_LIT:yes>'<EOL>user_obj = store.user(current_user.email)<EOL>if phenotype_id:<EOL><INDENT>store.remove_phenotype(institute_obj, case_obj, user_obj, case_url,<EOL>phenotype_id, is_group=is_group)<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>phenotype_term = request.form['<STR_LIT>']<EOL>if phenotype_term.startswith('<STR_LIT>') or len(phenotype_term) == <NUM_LIT:7>:<EOL><INDENT>hpo_term = phenotype_term.split('<STR_LIT>', <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>store.add_phenotype(institute_obj, case_obj, user_obj, case_url,<EOL>hpo_term=hpo_term, is_group=is_group)<EOL><DEDENT>else:<EOL><INDENT>store.add_phenotype(institute_obj, case_obj, user_obj, case_url,<EOL>omim_term=phenotype_term)<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>return abort(<NUM_LIT>, (\"<STR_LIT>\".format(phenotype_term)))<EOL><DEDENT><DEDENT>return redirect(case_url)<EOL>", "docstring": "Handle phenotypes.", "id": "f13697:m15"}
{"signature": "@cases_bp.route('<STR_LIT>', methods=['<STR_LIT:GET>'])<EOL>@templated('<STR_LIT>')<EOL>def case_report(institute_id, case_name):", "body": "institute_obj, case_obj = institute_and_case(store, institute_id, case_name)<EOL>data = controllers.case_report_content(store, institute_obj, case_obj)<EOL>return dict(institute=institute_obj, case=case_obj, format='<STR_LIT:html>', **data)<EOL>", "docstring": "Visualize case report", "id": "f13697:m11"}
{"signature": "@cases_bp.route('<STR_LIT>')<EOL>@templated('<STR_LIT>')<EOL>def cases(institute_id):", "body": "institute_obj = institute_and_case(store, institute_id)<EOL>query = request.args.get('<STR_LIT>')<EOL>limit = <NUM_LIT:100><EOL>if request.args.get('<STR_LIT>'):<EOL><INDENT>limit = int(request.args.get('<STR_LIT>'))<EOL><DEDENT>skip_assigned = request.args.get('<STR_LIT>')<EOL>is_research = request.args.get('<STR_LIT>')<EOL>all_cases = store.cases(collaborator=institute_id, name_query=query,<EOL>skip_assigned=skip_assigned, is_research=is_research)<EOL>data = controllers.cases(store, all_cases, limit)<EOL>sanger_unevaluated = controllers.get_sanger_unevaluated(store, institute_id, current_user.email)<EOL>if len(sanger_unevaluated)> <NUM_LIT:0>:<EOL><INDENT>data['<STR_LIT>'] = sanger_unevaluated<EOL><DEDENT>return dict(institute=institute_obj, skip_assigned=skip_assigned,<EOL>is_research=is_research, query=query, **data)<EOL>", "docstring": "Display a list of cases for an institute.", "id": "f13697:m1"}
{"signature": "@cases_bp.route('<STR_LIT>', methods=['<STR_LIT:POST>'])<EOL>def pin_variant(institute_id, case_name, variant_id):", "body": "institute_obj, case_obj = institute_and_case(store, institute_id, case_name)<EOL>variant_obj = store.variant(variant_id)<EOL>user_obj = store.user(current_user.email)<EOL>link = url_for('<STR_LIT>', institute_id=institute_id, case_name=case_name,<EOL>variant_id=variant_id)<EOL>if request.form['<STR_LIT:action>'] == '<STR_LIT>':<EOL><INDENT>store.pin_variant(institute_obj, case_obj, user_obj, link, variant_obj)<EOL><DEDENT>elif request.form['<STR_LIT:action>'] == '<STR_LIT>':<EOL><INDENT>store.unpin_variant(institute_obj, case_obj, user_obj, link, variant_obj)<EOL><DEDENT>return redirect(request.referrer or link)<EOL>", "docstring": "Pin and unpin variants to/from the list of suspects.", "id": "f13697:m21"}
{"signature": "@cases_bp.route('<STR_LIT>', methods=['<STR_LIT:POST>'])<EOL>@cases_bp.route('<STR_LIT>', methods=['<STR_LIT:POST>'])<EOL>def events(institute_id, case_name, event_id=None):", "body": "institute_obj, case_obj = institute_and_case(store, institute_id, case_name)<EOL>link = request.form.get('<STR_LIT>')<EOL>content = request.form.get('<STR_LIT:content>')<EOL>variant_id = request.args.get('<STR_LIT>')<EOL>user_obj = store.user(current_user.email)<EOL>if event_id:<EOL><INDENT>store.delete_event(event_id)<EOL><DEDENT>else:<EOL><INDENT>if variant_id:<EOL><INDENT>variant_obj = store.variant(variant_id)<EOL>level = request.form.get('<STR_LIT>', '<STR_LIT>')<EOL>store.comment(institute_obj, case_obj, user_obj, link,<EOL>variant=variant_obj, content=content, comment_level=level)<EOL><DEDENT>else:<EOL><INDENT>store.comment(institute_obj, case_obj, user_obj, link, content=content)<EOL><DEDENT><DEDENT>return redirect(request.referrer)<EOL>", "docstring": "Handle events.", "id": "f13697:m17"}
{"signature": "@cases_bp.route('<STR_LIT>', methods=['<STR_LIT:POST>'])<EOL>def matchmaker_delete(institute_id, case_name):", "body": "<EOL>user_obj = store.user(current_user.email)<EOL>if '<STR_LIT>' not in user_obj['<STR_LIT>']:<EOL><INDENT>flash('<STR_LIT>', '<STR_LIT>')<EOL>return redirect(request.referrer)<EOL><DEDENT>institute_obj, case_obj = institute_and_case(store, institute_id, case_name)<EOL>mme_base_url = current_app.config.get('<STR_LIT>')<EOL>mme_token = current_app.config.get('<STR_LIT>')<EOL>if not mme_base_url or not mme_token:<EOL><INDENT>flash('<STR_LIT>', '<STR_LIT>')<EOL>return redirect(request.referrer)<EOL><DEDENT>delete_result = controllers.mme_delete(case_obj, mme_base_url, mme_token)<EOL>n_deleted = <NUM_LIT:0><EOL>category = '<STR_LIT>'<EOL>for resp in delete_result:<EOL><INDENT>if resp['<STR_LIT>'] == <NUM_LIT:200>:<EOL><INDENT>n_deleted += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>flash(resp['<STR_LIT:message>'], category)<EOL><DEDENT><DEDENT>if n_deleted:<EOL><INDENT>category = '<STR_LIT:success>'<EOL>user_obj = store.user(current_user.email)<EOL>store.case_mme_delete(case_obj=case_obj, user_obj=user_obj)<EOL><DEDENT>flash('<STR_LIT>'.format(n_deleted, len(delete_result)), category)<EOL>return redirect(request.referrer)<EOL>", "docstring": "Remove a case from MatchMaker", "id": "f13697:m7"}
{"signature": "def gene_variants(store, variants_query, page=<NUM_LIT:1>, per_page=<NUM_LIT:50>):", "body": "variant_count = variants_query.count()<EOL>skip_count = per_page * max(page - <NUM_LIT:1>, <NUM_LIT:0>)<EOL>more_variants = True if variant_count > (skip_count + per_page) else False<EOL>variant_res = variants_query.skip(skip_count).limit(per_page)<EOL>my_institutes = list(inst['<STR_LIT>'] for inst in user_institutes(store, current_user))<EOL>variants = []<EOL>for variant_obj in variant_res:<EOL><INDENT>if variant_obj['<STR_LIT>'] not in my_institutes:<EOL><INDENT>LOG.warning(\"<STR_LIT>\".format(variant_obj['<STR_LIT>']))<EOL>continue<EOL><DEDENT>variant_case_obj = store.case(case_id=variant_obj['<STR_LIT>'])<EOL>if not variant_case_obj:<EOL><INDENT>continue<EOL><DEDENT>case_display_name = variant_case_obj.get('<STR_LIT>')<EOL>variant_obj['<STR_LIT>'] = case_display_name<EOL>genome_build = variant_case_obj.get('<STR_LIT>', '<STR_LIT>')<EOL>if genome_build not in ['<STR_LIT>','<STR_LIT>']:<EOL><INDENT>genome_build = '<STR_LIT>'<EOL><DEDENT>variant_genes = variant_obj.get('<STR_LIT>')<EOL>if variant_genes is not None:<EOL><INDENT>for gene_obj in variant_genes:<EOL><INDENT>if not gene_obj['<STR_LIT>']:<EOL><INDENT>continue<EOL><DEDENT>if gene_obj.get('<STR_LIT>') is None or gene_obj.get('<STR_LIT:description>') is None:<EOL><INDENT>hgnc_gene = store.hgnc_gene(gene_obj['<STR_LIT>'], build=genome_build)<EOL>if not hgnc_gene:<EOL><INDENT>continue<EOL><DEDENT>gene_obj['<STR_LIT>'] = hgnc_gene['<STR_LIT>']<EOL>gene_obj['<STR_LIT:description>'] = hgnc_gene['<STR_LIT:description>']<EOL><DEDENT><DEDENT><DEDENT>gene_ids = []<EOL>gene_symbols = []<EOL>hgvs_c = []<EOL>hgvs_p = []<EOL>variant_genes = variant_obj.get('<STR_LIT>')<EOL>if variant_genes is not None:<EOL><INDENT>functional_annotation = '<STR_LIT>'<EOL>for gene_obj in variant_genes:<EOL><INDENT>hgnc_id = gene_obj['<STR_LIT>']<EOL>gene_symbol = gene(store, hgnc_id)['<STR_LIT>']<EOL>gene_ids.append(hgnc_id)<EOL>gene_symbols.append(gene_symbol)<EOL>hgvs_nucleotide = '<STR_LIT:->'<EOL>transcripts_list = gene_obj.get('<STR_LIT>')<EOL>for transcript_obj in transcripts_list:<EOL><INDENT>if transcript_obj.get('<STR_LIT>') and transcript_obj.get('<STR_LIT>') is True:<EOL><INDENT>hgvs_nucleotide = str(transcript_obj.get('<STR_LIT>'))<EOL>hgvs_protein = str(transcript_obj.get('<STR_LIT>'))<EOL><DEDENT><DEDENT>hgvs_c.append(hgvs_nucleotide)<EOL>hgvs_p.append(hgvs_protein)<EOL><DEDENT>if len(gene_symbols) == <NUM_LIT:1>:<EOL><INDENT>if(hgvs_p[<NUM_LIT:0>] != \"<STR_LIT:None>\"):<EOL><INDENT>hgvs = hgvs_p[<NUM_LIT:0>]<EOL><DEDENT>elif(hgvs_c[<NUM_LIT:0>] != \"<STR_LIT:None>\"):<EOL><INDENT>hgvs = hgvs_c[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>hgvs = \"<STR_LIT:->\"<EOL><DEDENT>variant_obj['<STR_LIT>'] = hgvs<EOL><DEDENT>variant_obj.update(get_predictions(variant_genes))<EOL><DEDENT>variants.append(variant_obj)<EOL><DEDENT>return {<EOL>'<STR_LIT>': variants,<EOL>'<STR_LIT>': more_variants,<EOL>}<EOL>", "docstring": "Pre-process list of variants.", "id": "f13700:m13"}
{"signature": "def mt_excel_files(store, case_obj, temp_excel_dir):", "body": "today = datetime.datetime.now().strftime('<STR_LIT>')<EOL>samples = case_obj.get('<STR_LIT>')<EOL>query = {'<STR_LIT>':'<STR_LIT>'}<EOL>mt_variants = list(store.variants(case_id=case_obj['<STR_LIT>'], query=query, nr_of_variants= -<NUM_LIT:1>, sort_key='<STR_LIT>'))<EOL>written_files = <NUM_LIT:0><EOL>for sample in samples:<EOL><INDENT>sample_id = sample['<STR_LIT>']<EOL>sample_lines = export_mt_variants(variants=mt_variants, sample_id=sample_id)<EOL>document_name = '<STR_LIT:.>'.join([case_obj['<STR_LIT>'], sample_id, today]) + '<STR_LIT>'<EOL>workbook = Workbook(os.path.join(temp_excel_dir,document_name))<EOL>Report_Sheet = workbook.add_worksheet()<EOL>row = <NUM_LIT:0><EOL>for col,field in enumerate(MT_EXPORT_HEADER):<EOL><INDENT>Report_Sheet.write(row,col,field)<EOL><DEDENT>for row, line in enumerate(sample_lines,<NUM_LIT:1>): <EOL><INDENT>for col, field in enumerate(line): <EOL><INDENT>Report_Sheet.write(row,col,field)<EOL><DEDENT><DEDENT>workbook.close()<EOL>if os.path.exists(os.path.join(temp_excel_dir,document_name)):<EOL><INDENT>written_files += <NUM_LIT:1><EOL><DEDENT><DEDENT>return written_files<EOL>", "docstring": "Collect MT variants and format line of a MT variant report\n    to be exported in excel format\n\n    Args:\n        store(adapter.MongoAdapter)\n        case_obj(models.Case)\n        temp_excel_dir(os.Path): folder where the temp excel files are written to\n\n    Returns:\n        written_files(int): the number of files written to temp_excel_dir", "id": "f13700:m7"}
{"signature": "def get_analysis_types(adapter, total_cases, institute_id=None, slice_query=None):", "body": "<EOL>query = {}<EOL>subquery = {}<EOL>if institute_id and slice_query:<EOL><INDENT>subquery = adapter.cases(owner=institute_id, name_query=slice_query,<EOL>yield_query=True)<EOL><DEDENT>elif institute_id:<EOL><INDENT>subquery = adapter.cases(owner=institute_id, yield_query=True)<EOL><DEDENT>elif slice_query:<EOL><INDENT>subquery = adapter.cases(name_query=slice_query, yield_query=True)<EOL><DEDENT>query = {'<STR_LIT>': subquery}<EOL>pipeline = []<EOL>if query:<EOL><INDENT>pipeline.append(query)<EOL><DEDENT>pipeline.append({'<STR_LIT>': '<STR_LIT>'})<EOL>pipeline.append({'<STR_LIT>': {'<STR_LIT>': '<STR_LIT>', '<STR_LIT:count>': {'<STR_LIT>': <NUM_LIT:1>}}})<EOL>analysis_query = adapter.case_collection.aggregate(pipeline)<EOL>analysis_types = [{'<STR_LIT:name>': group['<STR_LIT>'], '<STR_LIT:count>': group['<STR_LIT:count>']} for group in analysis_query]<EOL>return analysis_types<EOL>", "docstring": "Return information about analysis types.\n        Group cases based on analysis type for the individuals.\n    Args:\n        adapter(adapter.MongoAdapter)\n        total_cases(int): Total number of cases\n        institute_id(str)\n        slice_query(str): Query to filter cases to obtain statistics for.\n    Returns:\n        analysis_types array of hashes with name: analysis_type(str), count: count(int)", "id": "f13703:m3"}
{"signature": "def templated(template=None):", "body": "def decorator(f):<EOL><INDENT>@wraps(f)<EOL>def decorated_function(*args, **kwargs):<EOL><INDENT>template_name = template<EOL>if template_name is None:<EOL><INDENT>template_name = request.endpoint.replace('<STR_LIT:.>', '<STR_LIT:/>') + '<STR_LIT>'<EOL><DEDENT>context = f(*args, **kwargs)<EOL>if context is None:<EOL><INDENT>context = {}<EOL><DEDENT>elif not isinstance(context, dict):<EOL><INDENT>return context<EOL><DEDENT>return render_template(template_name, **context)<EOL><DEDENT>return decorated_function<EOL><DEDENT>return decorator<EOL>", "docstring": "Template decorator.\n\n    Ref: http://flask.pocoo.org/docs/patterns/viewdecorators/", "id": "f13706:m0"}
{"signature": "def parse_panel(csv_stream):", "body": "reader = csv.DictReader(csv_stream, delimiter='<STR_LIT:;>', quoting=csv.QUOTE_NONE)<EOL>genes = []<EOL>for gene_row in reader:<EOL><INDENT>if not gene_row['<STR_LIT>'].strip().isdigit():<EOL><INDENT>continue<EOL><DEDENT>transcripts_raw = gene_row.get('<STR_LIT>')<EOL>if transcripts_raw:<EOL><INDENT>transcripts_list = [tx.split('<STR_LIT::>', <NUM_LIT:1>)[-<NUM_LIT:1>].strip() for tx in transcripts_raw.split('<STR_LIT:U+002C>')]<EOL><DEDENT>else:<EOL><INDENT>transcripts_list = []<EOL><DEDENT>models_raw = gene_row.get('<STR_LIT>')<EOL>models_list = [model.strip() for model in models_raw.split('<STR_LIT:U+002C>')] if models_raw else []<EOL>panel_gene = dict(<EOL>symbol=gene_row['<STR_LIT>'].strip() if gene_row.get('<STR_LIT>') else None,<EOL>hgnc_id=int(gene_row['<STR_LIT>'].strip()),<EOL>disease_associated_transcripts=transcripts_list,<EOL>reduced_penetrance=True if gene_row.get('<STR_LIT>') else None,<EOL>mosaicism=True if gene_row.get('<STR_LIT>') else None,<EOL>inheritance_models=models_list,<EOL>database_entry_version=gene_row.get('<STR_LIT>'),<EOL>)<EOL>genes.append(panel_gene)<EOL><DEDENT>return genes<EOL>", "docstring": "Parse user submitted panel.", "id": "f13707:m0"}
{"signature": "def configure_coverage(app):", "body": "<EOL>app.config['<STR_LIT>'] = True if app.debug else False<EOL>if chanjo_api:<EOL><INDENT>chanjo_api.init_app(app)<EOL>configure_template_filters(app)<EOL>app.register_blueprint(report_bp, url_prefix='<STR_LIT>')<EOL><DEDENT>babel = Babel(app)<EOL>@babel.localeselector<EOL>def get_locale():<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>accept_languages = current_app.config.get('<STR_LIT>', ['<STR_LIT>'])<EOL>session_language = request.args.get('<STR_LIT>')<EOL>if session_language in accept_languages:<EOL><INDENT>current_app.logger.info(\"<STR_LIT>\", session_language)<EOL>return session_language<EOL><DEDENT>user_language = current_app.config.get('<STR_LIT>')<EOL>if user_language:<EOL><INDENT>return user_language<EOL><DEDENT>return request.accept_languages.best_match(accept_languages)<EOL><DEDENT>", "docstring": "Setup coverage related extensions.", "id": "f13709:m5"}
{"signature": "def configure_email_logging(app):", "body": "import logging<EOL>from scout.log import TlsSMTPHandler<EOL>mail_handler = TlsSMTPHandler(<EOL>mailhost=app.config['<STR_LIT>'],<EOL>fromaddr=app.config['<STR_LIT>'],<EOL>toaddrs=app.config['<STR_LIT>'],<EOL>subject=\"<STR_LIT>\".format(app.name),<EOL>credentials=(app.config['<STR_LIT>'], app.config['<STR_LIT>'])<EOL>)<EOL>mail_handler.setLevel(logging.ERROR)<EOL>mail_handler.setFormatter(logging.Formatter(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>)<EOL>app.logger.addHandler(mail_handler)<EOL>", "docstring": "Setup logging of error/exceptions to email.", "id": "f13709:m4"}
{"signature": "def get_file_handle(file_path):", "body": "if file_path.endswith('<STR_LIT>'):<EOL><INDENT>file_handle = getreader('<STR_LIT:utf-8>')(gzip.open(file_path, '<STR_LIT:r>'), errors='<STR_LIT:replace>')<EOL><DEDENT>else:<EOL><INDENT>file_handle = open(file_path, '<STR_LIT:r>', encoding='<STR_LIT:utf-8>')<EOL><DEDENT>return file_handle<EOL>", "docstring": "Return a opened file", "id": "f13710:m0"}
{"signature": "def get_request(url):", "body": "try:<EOL><INDENT>LOG.info(\"<STR_LIT>\", url)<EOL>response = urllib.request.urlopen(url)<EOL>if url.endswith('<STR_LIT>'):<EOL><INDENT>LOG.info(\"<STR_LIT>\")<EOL>data = gzip.decompress(response.read())      <EOL><DEDENT>else:<EOL><INDENT>data = response.read()      <EOL><DEDENT>decoded_data = data.decode('<STR_LIT:utf-8>')<EOL><DEDENT>except HTTPError as err:<EOL><INDENT>LOG.warning(\"<STR_LIT>\")<EOL>raise err<EOL><DEDENT>except URLError as err:<EOL><INDENT>LOG.warning(\"<STR_LIT>\")<EOL>raise err<EOL><DEDENT>if '<STR_LIT>' in decoded_data:<EOL><INDENT>raise URLError(\"<STR_LIT>\".format(url))<EOL><DEDENT>return decoded_data<EOL>", "docstring": "Return a requests response from url\n\n    Args:\n        url(str)\n\n    Returns:\n        decoded_data(str): Decoded response", "id": "f13711:m0"}
{"signature": "def fetch_ensembl_exons(build='<STR_LIT>'):", "body": "LOG.info(\"<STR_LIT>\", build)<EOL>if build == '<STR_LIT>':<EOL><INDENT>url = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>url = '<STR_LIT>'<EOL><DEDENT>dataset_name = '<STR_LIT>'<EOL>dataset = pybiomart.Dataset(name=dataset_name, host=url)<EOL>attributes = [<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'<EOL>]<EOL>filters = {<EOL>'<STR_LIT>': CHROMOSOMES,<EOL>}<EOL>result = dataset.query(<EOL>attributes = attributes,<EOL>filters = filters<EOL>)<EOL>return result<EOL>", "docstring": "Fetch the ensembl genes\n\n    Args:\n        build(str): ['37', '38']", "id": "f13711:m9"}
{"signature": "def fetch_mim_files(api_key, mim2genes=False, mimtitles=False, morbidmap=False, genemap2=False):", "body": "LOG.info(\"<STR_LIT>\")<EOL>mim2genes_url =  '<STR_LIT>'<EOL>mimtitles_url= '<STR_LIT>'.format(api_key)<EOL>morbidmap_url = '<STR_LIT>'.format(api_key)<EOL>genemap2_url =  '<STR_LIT>'.format(api_key)<EOL>mim_files = {}<EOL>mim_urls = {}<EOL>if mim2genes is True:<EOL><INDENT>mim_urls['<STR_LIT>'] = mim2genes_url<EOL><DEDENT>if mimtitles is True:<EOL><INDENT>mim_urls['<STR_LIT>'] = mimtitles_url<EOL><DEDENT>if morbidmap is True:<EOL><INDENT>mim_urls['<STR_LIT>'] = morbidmap_url<EOL><DEDENT>if genemap2 is True:<EOL><INDENT>mim_urls['<STR_LIT>'] = genemap2_url<EOL><DEDENT>for file_name in mim_urls:<EOL><INDENT>url = mim_urls[file_name]<EOL>mim_files[file_name] = fetch_resource(url)<EOL><DEDENT>return mim_files<EOL>", "docstring": "Fetch the necessary mim files using a api key\n\n    Args:\n        api_key(str): A api key necessary to fetch mim data\n\n    Returns:\n        mim_files(dict): A dictionary with the neccesary files", "id": "f13711:m2"}
{"signature": "def fetch_hpo_files(hpogenes=False, hpoterms=False, phenotype_to_terms=False, hpodisease=False):", "body": "LOG.info(\"<STR_LIT>\")<EOL>base_url = ('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>hpogenes_url =  base_url.format('<STR_LIT>')<EOL>hpoterms_url= base_url.format('<STR_LIT>')<EOL>hpo_phenotype_to_terms_url = base_url.format('<STR_LIT>')<EOL>hpodisease_url = base_url.format('<STR_LIT>')<EOL>hpo_files = {}<EOL>hpo_urls = {}<EOL>if hpogenes is True:<EOL><INDENT>hpo_urls['<STR_LIT>'] = hpogenes_url<EOL><DEDENT>if hpoterms is True:<EOL><INDENT>hpo_urls['<STR_LIT>'] = hpoterms_url<EOL><DEDENT>if phenotype_to_terms is True:<EOL><INDENT>hpo_urls['<STR_LIT>'] = hpo_phenotype_to_terms_url<EOL><DEDENT>if hpodisease is True:<EOL><INDENT>hpo_urls['<STR_LIT>'] = hpodisease_url<EOL><DEDENT>for file_name in hpo_urls:<EOL><INDENT>url = hpo_urls[file_name]<EOL>hpo_files[file_name] = request_file(url)<EOL><DEDENT>return hpo_files<EOL>", "docstring": "Fetch the necessary mim files using a api key\n\n    Args:\n        api_key(str): A api key necessary to fetch mim data\n\n    Returns:\n        mim_files(dict): A dictionary with the neccesary files", "id": "f13711:m12"}
{"signature": "def is_likely_benign(bs_terms, bp_terms):", "body": "if bs_terms:<EOL><INDENT>if bp_terms:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>if len(bp_terms) >= <NUM_LIT:2>:<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Check if criterias for Likely Benign are fullfilled\n\n    The following are descriptions of Likely Benign clasification from ACMG paper:\n\n    Likely Benign\n      (i) 1 Strong (BS1\u2013BS4) and 1 supporting (BP1\u2013 BP7) OR\n      (ii) \u22652 Supporting (BP1\u2013BP7)\n\n    Args:\n        bs_terms(list(str)): Terms that indicate strong evidence for benign variant\n        bp_terms(list(str)): Terms that indicate supporting evidence for benign variant\n\n    Returns:\n        bool: if classification indicates Benign level", "id": "f13712:m3"}
{"signature": "def is_par(chromosome, position, build='<STR_LIT>'):", "body": "chrom_match = CHR_PATTERN.match(chromosome)<EOL>chrom = chrom_match.group(<NUM_LIT:2>)<EOL>if not chrom in ['<STR_LIT:X>','<STR_LIT:Y>']:<EOL><INDENT>return False<EOL><DEDENT>if PAR_COORDINATES[build][chrom].search(position):<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Check if a variant is in the Pseudo Autosomal Region or not\n\n    Args:\n        chromosome(str)\n        position(int)\n        build(str): The genome build\n\n    Returns:\n        bool", "id": "f13713:m0"}
{"signature": "def get_date(date, date_format = None):", "body": "date_obj = datetime.datetime.now()<EOL>if date:<EOL><INDENT>if date_format:<EOL><INDENT>date_obj = datetime.datetime.strptime(date, date_format)<EOL><DEDENT>else:<EOL><INDENT>if match_date(date):<EOL><INDENT>if len(date.split('<STR_LIT:->')) == <NUM_LIT:3>:<EOL><INDENT>date = date.split('<STR_LIT:->')<EOL><DEDENT>elif len(date.split('<STR_LIT:U+0020>')) == <NUM_LIT:3>:<EOL><INDENT>date = date.split('<STR_LIT:U+0020>')<EOL><DEDENT>elif len(date.split('<STR_LIT:.>')) == <NUM_LIT:3>:<EOL><INDENT>date = date.split('<STR_LIT:.>')<EOL><DEDENT>else:<EOL><INDENT>date = date.split('<STR_LIT:/>')<EOL><DEDENT>date_obj = datetime.datetime(*(int(number) for number in date))<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % date)<EOL><DEDENT><DEDENT><DEDENT>return date_obj<EOL>", "docstring": "Return a datetime object if there is a valid date\n\n        Raise exception if date is not valid\n        Return todays date if no date where added\n\n        Args:\n            date(str)\n            date_format(str)\n\n        Returns:\n            date_obj(datetime.datetime)", "id": "f13715:m1"}
{"signature": "def genes_by_alias(hgnc_genes):", "body": "alias_genes = {}<EOL>for hgnc_id in hgnc_genes:<EOL><INDENT>gene = hgnc_genes[hgnc_id]<EOL>hgnc_symbol = gene['<STR_LIT>']<EOL>for alias in gene['<STR_LIT>']:<EOL><INDENT>true_id = None<EOL>if alias == hgnc_symbol:<EOL><INDENT>true_id = hgnc_id<EOL><DEDENT>if alias in alias_genes:<EOL><INDENT>alias_genes[alias.upper()]['<STR_LIT>'].add(hgnc_id)<EOL>if true_id:<EOL><INDENT>alias_genes[alias.upper()]['<STR_LIT>'] = hgnc_id<EOL><DEDENT><DEDENT>else:<EOL><INDENT>alias_genes[alias.upper()] = {<EOL>'<STR_LIT:true>': true_id,<EOL>'<STR_LIT>': set([hgnc_id])<EOL>}<EOL><DEDENT><DEDENT><DEDENT>return alias_genes<EOL>", "docstring": "Return a dictionary with hgnc symbols as keys\n\n    Value of the dictionaries are information about the hgnc ids for a symbol.\n    If the symbol is primary for a gene then 'true_id' will exist.\n    A list of hgnc ids that the symbol points to is in ids.\n\n    Args:\n        hgnc_genes(dict): a dictionary with hgnc_id as key and gene info as value\n\n    Returns:\n        alias_genes(dict):\n            {\n                'hgnc_symbol':{\n                    'true_id': int,\n                    'ids': list(int)\n                    }\n            }", "id": "f13716:m0"}
{"signature": "def link_genes(ensembl_lines, hgnc_lines, exac_lines, mim2gene_lines,<EOL>genemap_lines, hpo_lines):", "body": "genes = {}<EOL>LOG.info(\"<STR_LIT>\")<EOL>for hgnc_gene in parse_hgnc_genes(hgnc_lines):<EOL><INDENT>hgnc_id = hgnc_gene['<STR_LIT>']<EOL>genes[hgnc_id] = hgnc_gene<EOL><DEDENT>add_ensembl_info(genes, ensembl_lines)<EOL>symbol_to_id = genes_by_alias(genes)<EOL>add_exac_info(genes, symbol_to_id, exac_lines)<EOL>add_omim_info(genes, symbol_to_id, genemap_lines, mim2gene_lines)<EOL>add_incomplete_penetrance(genes, symbol_to_id, hpo_lines)<EOL>return genes<EOL>", "docstring": "Gather information from different sources and return a gene dict\n\n    Extract information collected from a number of sources and combine them\n    into a gene dict with HGNC symbols as keys.\n\n    hgnc_id works as the primary symbol and it is from this source we gather\n    as much information as possible (hgnc_complete_set.txt)\n\n    Coordinates are gathered from ensemble and the entries are linked from hgnc\n    to ensembl via ENSGID.\n\n    From exac the gene intolerance scores are collected, genes are linked to hgnc\n    via hgnc symbol. This is a unstable symbol since they often change.\n\n\n        Args:\n            ensembl_lines(iterable(str)): Strings with ensembl gene information\n            hgnc_lines(iterable(str)): Strings with hgnc gene information\n            exac_lines(iterable(str)): Strings with exac PLi score info\n            mim2gene_lines(iterable(str))\n            genemap_lines(iterable(str))\n            hpo_lines(iterable(str)): Strings with hpo gene information\n\n        Yields:\n            gene(dict): A dictionary with gene information", "id": "f13716:m6"}
{"signature": "def generate_md5_key(list_of_arguments):", "body": "for arg in list_of_arguments:<EOL><INDENT>if not isinstance(arg, string_types):<EOL><INDENT>raise SyntaxError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(arg, type(arg)))<EOL><DEDENT><DEDENT>hash = hashlib.md5()<EOL>hash.update('<STR_LIT:U+0020>'.join(list_of_arguments).encode('<STR_LIT:utf-8>'))<EOL>return hash.hexdigest()<EOL>", "docstring": "Generate an md5-key from a list of arguments.\n\nArgs:\n    list_of_arguments: A list of strings\n\nReturns:\n    A md5-key object generated from the list of strings.", "id": "f13717:m0"}
{"signature": "def matchmaker_request(url, token, method, content_type=None, accept=None, data=None):", "body": "headers = Headers()<EOL>headers = { '<STR_LIT>': token}<EOL>if content_type:<EOL><INDENT>headers['<STR_LIT:Content-Type>'] = content_type<EOL><DEDENT>if accept:<EOL><INDENT>headers['<STR_LIT>'] = accept<EOL><DEDENT>req_data = data or {'<STR_LIT>' : datetime.datetime.now().timestamp()}<EOL>json_response = None<EOL>try:<EOL><INDENT>LOG.info('<STR_LIT>'.format(<EOL>method, url, req_data))<EOL>resp = requests.request(<EOL>method = method,<EOL>url = url,<EOL>headers = headers,<EOL>data = json.dumps(req_data)<EOL>)<EOL>json_response = resp.json()<EOL>LOG.info('<STR_LIT>'.format(json_response))<EOL>if isinstance(json_response, str):<EOL><INDENT>json_response = {<EOL>'<STR_LIT:message>' : json_response,<EOL>}<EOL><DEDENT>elif isinstance(json_response, list): <EOL><INDENT>return json_response<EOL><DEDENT>json_response['<STR_LIT>'] = resp.status_code<EOL><DEDENT>except Exception as err:<EOL><INDENT>LOG.info('<STR_LIT>'.format(err))<EOL>json_response = {<EOL>'<STR_LIT:message>' : str(err)<EOL>}<EOL><DEDENT>return json_response<EOL>", "docstring": "Send a request to MatchMaker and return its response\n\n    Args:\n        url(str): url to send request to\n        token(str): MME server authorization token\n        method(str): 'GET', 'POST' or 'DELETE'\n        content_type(str): MME request Content-Type\n        accept(str): accepted response\n        data(dict): eventual data to send in request\n\n    Returns:\n        json_response(dict): server response", "id": "f13719:m0"}
{"signature": "def mme_nodes(mme_base_url, token):", "body": "nodes = []<EOL>if not mme_base_url or not token:<EOL><INDENT>return nodes<EOL><DEDENT>url = '<STR_LIT>'.join([mme_base_url, '<STR_LIT>'])<EOL>nodes = matchmaker_request(url=url, token=token, method='<STR_LIT:GET>')<EOL>LOG.info('<STR_LIT>'.format(nodes))<EOL>return nodes<EOL>", "docstring": "Return the available MatchMaker nodes\n\n    Args:\n        mme_base_url(str): base URL of MME service\n        token(str): MME server authorization token\n\n    Returns:\n        nodes(list): a list of node disctionaries", "id": "f13719:m1"}
{"signature": "def get_correct_gene(hgnc_symbol, genes):", "body": "for gene in genes:<EOL><INDENT>if hgnc_symbol == gene['<STR_LIT>']:<EOL><INDENT>return gene<EOL><DEDENT><DEDENT>", "docstring": "Check which of the genes in query result that is the correct one\n\n        If there result is ambigous, that is if non of the genes have the hgnc\n        symbol as the primary identifier and two or more genes have the symbol\n        as an alias, return all of those results.\n\n        Args:\n            hgnc_symbol(str)\n            genes(iterable[Gene])", "id": "f13720:m0"}
{"signature": "@click.command('<STR_LIT>', short_help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=click.Choice(['<STR_LIT>', '<STR_LIT>']))<EOL>@click.pass_context<EOL>def exons(context, build):", "body": "LOG.info(\"<STR_LIT>\")<EOL>adapter = context.obj['<STR_LIT>']<EOL>adapter.drop_exons(build)<EOL>", "docstring": "Delete all exons in the database", "id": "f13724:m4"}
{"signature": "@click.command('<STR_LIT>', short_help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', <EOL>help=\"<STR_LIT>\",<EOL>required=True<EOL>)<EOL>@click.option('<STR_LIT>', '<STR_LIT>',<EOL>type=float,<EOL>)<EOL>@click.pass_context<EOL>def panel(context, panel_id, version):", "body": "LOG.info(\"<STR_LIT>\")<EOL>adapter = context.obj['<STR_LIT>']<EOL>panel_objs = adapter.gene_panels(panel_id=panel_id, version=version)<EOL>if panel_objs.count() == <NUM_LIT:0>:<EOL><INDENT>LOG.info(\"<STR_LIT>\")<EOL><DEDENT>for panel_obj in panel_objs:<EOL><INDENT>adapter.delete_panel(panel_obj)<EOL><DEDENT>", "docstring": "Delete a version of a gene panel or all versions of a gene panel", "id": "f13724:m0"}
{"signature": "@click.command('<STR_LIT:index>', short_help='<STR_LIT>')<EOL>@click.pass_context<EOL>def index(context):", "body": "LOG.info(\"<STR_LIT>\")<EOL>adapter = context.obj['<STR_LIT>']<EOL>for collection in adapter.db.collection_names():<EOL><INDENT>adapter.db[collection].drop_indexes()<EOL><DEDENT>LOG.info(\"<STR_LIT>\")<EOL>", "docstring": "Delete all indexes in the database", "id": "f13724:m1"}
{"signature": "@click.command('<STR_LIT>', short_help='<STR_LIT>')<EOL>@click.option('<STR_LIT>',<EOL>help='<STR_LIT>'<EOL>)<EOL>@click.option('<STR_LIT>', '<STR_LIT>',<EOL>help='<STR_LIT>'<EOL>)<EOL>@click.option('<STR_LIT>', '<STR_LIT>',<EOL>is_flag=True,<EOL>help='<STR_LIT>'<EOL>)<EOL>@click.option('<STR_LIT>', '<STR_LIT>',<EOL>is_flag=True,<EOL>help='<STR_LIT>'<EOL>)<EOL>@click.option('<STR_LIT>',<EOL>is_flag=True,<EOL>help='<STR_LIT>'<EOL>)<EOL>@click.option('<STR_LIT>',<EOL>is_flag=True,<EOL>help='<STR_LIT>'<EOL>)<EOL>@click.option('<STR_LIT>',<EOL>is_flag=True,<EOL>help='<STR_LIT>'<EOL>)<EOL>@click.option('<STR_LIT>', '<STR_LIT>',<EOL>type=click.Choice(CASE_STATUSES),<EOL>help='<STR_LIT>'<EOL>)<EOL>@json_option<EOL>@click.pass_context<EOL>def cases(context, case_id, institute, reruns, finished, causatives, research_requested,<EOL>is_research, status, json):", "body": "adapter = context.obj['<STR_LIT>']<EOL>models = []<EOL>if case_id:<EOL><INDENT>case_obj = adapter.case(case_id=case_id)<EOL>if case_obj:<EOL><INDENT>models.append(case_obj)<EOL><DEDENT>else:<EOL><INDENT>LOG.info(\"<STR_LIT>\".format(case_id))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>models = adapter.cases(collaborator=institute, reruns=reruns,<EOL>finished=finished, has_causatives=causatives,<EOL>research_requested=research_requested,<EOL>is_research=is_research, status=status)<EOL>models = [case_obj for case_obj in models]<EOL>if len(models) == <NUM_LIT:0>:<EOL><INDENT>LOG.info(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if json:<EOL><INDENT>click.echo(dumps(models))<EOL>return<EOL><DEDENT>for model in models:<EOL><INDENT>pp(model)<EOL><DEDENT>", "docstring": "Interact with cases existing in the database.", "id": "f13726:m0"}
{"signature": "@click.group()<EOL>@click.pass_context<EOL>def export(ctx):", "body": "LOG.info(\"<STR_LIT>\")<EOL>", "docstring": "Export objects from the mongo database.", "id": "f13733:m0"}
{"signature": "@click.command('<STR_LIT>', short_help='<STR_LIT>')<EOL>@builds_option<EOL>@click.pass_context<EOL>def transcripts(context, build):", "body": "LOG.info(\"<STR_LIT>\")<EOL>adapter = context.obj['<STR_LIT>']<EOL>header = [\"<STR_LIT>\"]<EOL>for line in header:<EOL><INDENT>click.echo(line)<EOL><DEDENT>transcript_string = (\"<STR_LIT>\")<EOL>for tx_obj in export_transcripts(adapter):<EOL><INDENT>click.echo(transcript_string.format(<EOL>tx_obj['<STR_LIT>'],<EOL>tx_obj['<STR_LIT:start>'],<EOL>tx_obj['<STR_LIT:end>'],<EOL>tx_obj['<STR_LIT>'],<EOL>tx_obj.get('<STR_LIT>','<STR_LIT>'),<EOL>tx_obj['<STR_LIT>'],<EOL>)<EOL>)<EOL><DEDENT>", "docstring": "Export all transcripts to .bed like format", "id": "f13734:m0"}
{"signature": "@click.command('<STR_LIT>', short_help='<STR_LIT>')<EOL>@click.argument('<STR_LIT>',nargs=-<NUM_LIT:1>)<EOL>@click.pass_context<EOL>def hpo_genes(context, hpo_term):", "body": "LOG.info(\"<STR_LIT>\")<EOL>adapter = context.obj['<STR_LIT>']<EOL>header = [\"<STR_LIT>\"]<EOL>if not hpo_term:<EOL><INDENT>LOG.warning(\"<STR_LIT>\")<EOL>context.abort()<EOL><DEDENT>for line in header:<EOL><INDENT>click.echo(line)<EOL><DEDENT>for term in adapter.generate_hpo_gene_list(*hpo_term):<EOL><INDENT>click.echo(\"<STR_LIT>\".format(term[<NUM_LIT:0>], term[<NUM_LIT:1>]))<EOL><DEDENT>", "docstring": "Export a list of genes based on hpo terms", "id": "f13735:m0"}
{"signature": "@click.command('<STR_LIT>', short_help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', default='<STR_LIT>', type=click.Choice(['<STR_LIT>', '<STR_LIT>']))<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=int)<EOL>@click.option('<STR_LIT>', is_flag=True)<EOL>@click.pass_context<EOL>def transcripts(context, build, hgnc_id, json):", "body": "LOG.info(\"<STR_LIT>\")<EOL>adapter = context.obj['<STR_LIT>']<EOL>if not json:<EOL><INDENT>click.echo(\"<STR_LIT>\")<EOL><DEDENT>for tx_obj in adapter.transcripts(build=build, hgnc_id=hgnc_id):<EOL><INDENT>if json:<EOL><INDENT>pp(tx_obj)<EOL>continue<EOL><DEDENT>click.echo(\"<STR_LIT>\".format(<EOL>tx_obj['<STR_LIT>'],<EOL>tx_obj['<STR_LIT:start>'],<EOL>tx_obj['<STR_LIT:end>'],<EOL>tx_obj['<STR_LIT>'],<EOL>tx_obj['<STR_LIT>'],<EOL>tx_obj.get('<STR_LIT>', '<STR_LIT>'),<EOL>tx_obj.get('<STR_LIT>') or '<STR_LIT>',<EOL>))<EOL><DEDENT>", "docstring": "Show all transcripts in the database", "id": "f13739:m0"}
{"signature": "@click.command('<STR_LIT:index>', short_help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>')<EOL>@click.pass_context<EOL>def index(context, collection_name):", "body": "LOG.info(\"<STR_LIT>\")<EOL>adapter = context.obj['<STR_LIT>']<EOL>i = <NUM_LIT:0><EOL>click.echo(\"<STR_LIT>\")<EOL>for collection_name in adapter.collections():<EOL><INDENT>for index in adapter.indexes(collection_name):<EOL><INDENT>click.echo(\"<STR_LIT>\".format(collection_name, index))<EOL>i += <NUM_LIT:1><EOL><DEDENT><DEDENT>if i == <NUM_LIT:0>:<EOL><INDENT>LOG.info(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Show all indexes in the database", "id": "f13741:m0"}
{"signature": "@click.group()<EOL>@click.pass_context<EOL>def view(context):", "body": "pass<EOL>", "docstring": "View objects from the database. This command is used to get a overview of objects in the \ndatabase. To get serialisable things use `scout export`", "id": "f13743:m0"}
{"signature": "@click.command('<STR_LIT>', short_help='<STR_LIT>')<EOL>@click.pass_context<EOL>def whitelist(context):", "body": "LOG.info(\"<STR_LIT>\")<EOL>adapter = context.obj['<STR_LIT>']<EOL>for whitelist_obj in adapter.whitelist_collection.find():<EOL><INDENT>click.echo(whitelist_obj['<STR_LIT>'])<EOL><DEDENT>", "docstring": "Show all objects in the whitelist collection", "id": "f13744:m0"}
{"signature": "@click.command('<STR_LIT>', short_help='<STR_LIT>')<EOL>@click.pass_context<EOL>def diseases(context):", "body": "LOG.info(\"<STR_LIT>\")<EOL>adapter = context.obj['<STR_LIT>']<EOL>disease_objs = adapter.disease_terms()<EOL>nr_diseases = disease_objs.count()<EOL>if nr_diseases == <NUM_LIT:0>:<EOL><INDENT>click.echo(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>click.echo(\"<STR_LIT>\")<EOL>for disease_obj in adapter.disease_terms():<EOL><INDENT>click.echo(\"<STR_LIT>\".format(disease_obj['<STR_LIT>']))<EOL><DEDENT>LOG.info(\"<STR_LIT>\".format(nr_diseases))<EOL><DEDENT>", "docstring": "Show all diseases in the database", "id": "f13746:m0"}
{"signature": "@click.command('<STR_LIT>', short_help='<STR_LIT>')<EOL>@click.pass_context<EOL>def users(context):", "body": "LOG.info(\"<STR_LIT>\")<EOL>adapter = context.obj['<STR_LIT>']<EOL>user_objs = adapter.users()<EOL>if user_objs.count() == <NUM_LIT:0>:<EOL><INDENT>LOG.info(\"<STR_LIT>\")<EOL>context.abort()<EOL><DEDENT>click.echo(\"<STR_LIT>\")<EOL>for user_obj in user_objs:<EOL><INDENT>click.echo(\"<STR_LIT>\".format(<EOL>user_obj['<STR_LIT:name>'],<EOL>user_obj.get('<STR_LIT>', user_obj['<STR_LIT>']),<EOL>'<STR_LIT:U+002CU+0020>'.join(user_obj.get('<STR_LIT>', [])),<EOL>'<STR_LIT:U+002CU+0020>'.join(user_obj.get('<STR_LIT>', [])),<EOL>)<EOL>)<EOL><DEDENT>", "docstring": "Show all users in the database", "id": "f13747:m0"}
{"signature": "@click.command('<STR_LIT>', short_help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', help='<STR_LIT>')<EOL>@click.pass_context<EOL>def hpo(context, term, description):", "body": "LOG.info(\"<STR_LIT>\")<EOL>adapter = context.obj['<STR_LIT>']<EOL>if term:<EOL><INDENT>term = term.upper()<EOL>if not term.startswith('<STR_LIT>'):<EOL><INDENT>while len(term) < <NUM_LIT:7>:<EOL><INDENT>term = '<STR_LIT:0>' + term<EOL><DEDENT>term = '<STR_LIT>' + term<EOL><DEDENT>LOG.info(\"<STR_LIT>\", term)<EOL>hpo_terms = adapter.hpo_terms(hpo_term=term)<EOL><DEDENT>elif description:<EOL><INDENT>sorted_terms = sorted(adapter.hpo_terms(query=description), key=itemgetter('<STR_LIT>'))<EOL>for term in sorted_terms:<EOL><INDENT>term.pop('<STR_LIT>')<EOL>print(\"<STR_LIT>\".format(term['<STR_LIT>'], term['<STR_LIT:description>'], term['<STR_LIT>']))<EOL><DEDENT>context.abort()<EOL><DEDENT>else:<EOL><INDENT>hpo_terms = adapter.hpo_terms()<EOL><DEDENT>if hpo_terms.count() == <NUM_LIT:0>:<EOL><INDENT>LOG.warning(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>click.echo(\"<STR_LIT>\")<EOL>for hpo_obj in hpo_terms:<EOL><INDENT>click.echo(\"<STR_LIT>\".format(<EOL>hpo_obj['<STR_LIT>'],<EOL>hpo_obj['<STR_LIT:description>'],<EOL>len(hpo_obj.get('<STR_LIT>',[]))<EOL>))<EOL><DEDENT>", "docstring": "Show all hpo terms in the database", "id": "f13750:m0"}
{"signature": "@click.group()<EOL>@click.option('<STR_LIT>', '<STR_LIT>',<EOL>default='<STR_LIT>',<EOL>show_default=True,<EOL>help='<STR_LIT>',<EOL>)<EOL>@click.option('<STR_LIT>', '<STR_LIT>',<EOL>default='<STR_LIT>',<EOL>show_default=True,<EOL>help='<STR_LIT>',<EOL>)<EOL>@click.option('<STR_LIT>', '<STR_LIT>',<EOL>default='<STR_LIT>',<EOL>show_default=True,<EOL>help='<STR_LIT>',<EOL>)<EOL>@click.pass_context<EOL>def setup(context, institute, user_mail, user_name):", "body": "context.obj['<STR_LIT>'] = institute<EOL>context.obj['<STR_LIT>'] = user_name<EOL>context.obj['<STR_LIT>'] = user_mail<EOL>if context.invoked_subcommand == '<STR_LIT>':<EOL><INDENT>LOG.debug(\"<STR_LIT>\")<EOL>context.obj['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>LOG.info(\"<STR_LIT>\", context.obj['<STR_LIT>'])<EOL>LOG.debug(\"<STR_LIT>\", context.obj['<STR_LIT:host>'])<EOL>LOG.debug(\"<STR_LIT>\", context.obj['<STR_LIT:port>'])<EOL>try:<EOL><INDENT>client = get_connection(<EOL>host=context.obj['<STR_LIT:host>'],<EOL>port=context.obj['<STR_LIT:port>'],<EOL>username=context.obj['<STR_LIT:username>'],<EOL>password=context.obj['<STR_LIT:password>'],<EOL>mongodb = context.obj['<STR_LIT>']<EOL>)<EOL><DEDENT>except ConnectionFailure:<EOL><INDENT>context.abort()<EOL><DEDENT>LOG.info(\"<STR_LIT>\", context.obj['<STR_LIT>'])<EOL>database = client[context.obj['<STR_LIT>']]<EOL>LOG.info(\"<STR_LIT>\")<EOL>try:<EOL><INDENT>LOG.info(\"<STR_LIT>\")<EOL>database.test.find_one()<EOL><DEDENT>except ServerSelectionTimeoutError as err:<EOL><INDENT>LOG.warning(\"<STR_LIT>\")<EOL>LOG.warning(\"<STR_LIT>\")<EOL>context.abort()<EOL><DEDENT>LOG.info(\"<STR_LIT>\")<EOL>mongo_adapter = MongoAdapter(database)<EOL>context.obj['<STR_LIT>'] = mongo_adapter<EOL>", "docstring": "Setup scout instances.", "id": "f13753:m3"}
{"signature": "@click.command('<STR_LIT>', short_help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=str)<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=str)<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=str)<EOL>@click.option('<STR_LIT>', help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', <EOL>is_flag=True, <EOL>callback=abort_if_false,<EOL>expose_value=False,<EOL>prompt='<STR_LIT>')<EOL>@click.pass_context<EOL>def database(context, institute_name, user_name, user_mail, api_key):", "body": "LOG.info(\"<STR_LIT>\")<EOL>api_key = api_key or context.obj.get('<STR_LIT>')<EOL>if not api_key:<EOL><INDENT>LOG.warning(\"<STR_LIT>\")<EOL>context.abort()<EOL><DEDENT>institute_name = institute_name or context.obj['<STR_LIT>']<EOL>user_name = user_name or context.obj['<STR_LIT>']<EOL>user_mail = user_mail or context.obj['<STR_LIT>']<EOL>adapter = context.obj['<STR_LIT>']<EOL>LOG.info(\"<STR_LIT>\", context.obj['<STR_LIT>'])<EOL>setup_scout(<EOL>adapter=adapter,<EOL>institute_id=institute_name, <EOL>user_name=user_name, <EOL>user_mail = user_mail, <EOL>api_key=api_key<EOL>)<EOL>", "docstring": "Setup a scout database.", "id": "f13753:m1"}
{"signature": "@click.command(short_help='<STR_LIT>')<EOL>@click.argument('<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', is_flag=True, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', is_flag=True, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', is_flag=True, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', is_flag=True, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', is_flag=True, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', is_flag=True, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', is_flag=True, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', is_flag=True, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', type=int, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', type=int, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', type=int, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', default=<NUM_LIT:5>, help='<STR_LIT>',<EOL>show_default=True)<EOL>@click.pass_context<EOL>def variants(context, case_id, institute, force, cancer, cancer_research, sv, <EOL>sv_research, snv, snv_research, str_clinical, chrom, start, end, hgnc_id, <EOL>hgnc_symbol, rank_treshold):", "body": "LOG.info(\"<STR_LIT>\")<EOL>adapter = context.obj['<STR_LIT>']<EOL>if institute:<EOL><INDENT>case_id = \"<STR_LIT>\".format(institute, case_id)<EOL><DEDENT>else:<EOL><INDENT>institute = case_id.split('<STR_LIT:->')[<NUM_LIT:0>]<EOL><DEDENT>case_obj = adapter.case(case_id=case_id)<EOL>if case_obj is None:<EOL><INDENT>LOG.info(\"<STR_LIT>\")<EOL>context.abort()<EOL><DEDENT>files = [<EOL>{'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>', '<STR_LIT>': cancer},<EOL>{'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>', '<STR_LIT>': cancer_research},<EOL>{'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>', '<STR_LIT>': sv},<EOL>{'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>', '<STR_LIT>': sv_research},<EOL>{'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>', '<STR_LIT>': snv},<EOL>{'<STR_LIT>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>', '<STR_LIT>': snv_research},<EOL>{'<STR_LIT>': '<STR_LIT:str>', '<STR_LIT>': '<STR_LIT>', '<STR_LIT>': str_clinical},<EOL>]<EOL>gene_obj = None<EOL>if (hgnc_id or hgnc_symbol):<EOL><INDENT>if hgnc_id:<EOL><INDENT>gene_obj = adapter.hgnc_gene(hgnc_id)<EOL><DEDENT>if hgnc_symbol:<EOL><INDENT>for res in adapter.gene_by_alias(hgnc_symbol):<EOL><INDENT>gene_obj = res<EOL><DEDENT><DEDENT>if not gene_obj:<EOL><INDENT>LOG.warning(\"<STR_LIT>\")<EOL>context.abort()<EOL><DEDENT><DEDENT>i = <NUM_LIT:0><EOL>for file_type in files:<EOL><INDENT>variant_type = file_type['<STR_LIT>']<EOL>category = file_type['<STR_LIT>']<EOL>if file_type['<STR_LIT>']:<EOL><INDENT>i += <NUM_LIT:1><EOL>if variant_type == '<STR_LIT>':<EOL><INDENT>if not (force or case_obj['<STR_LIT>']):<EOL><INDENT>LOG.warn(\"<STR_LIT>\")<EOL>context.abort()<EOL><DEDENT><DEDENT>LOG.info(\"<STR_LIT>\".format(<EOL>variant_type, category, case_id))<EOL>adapter.delete_variants(case_id=case_obj['<STR_LIT>'], <EOL>variant_type=variant_type,<EOL>category=category)<EOL>LOG.info(\"<STR_LIT>\".format(<EOL>variant_type, category, case_id))<EOL>try:<EOL><INDENT>adapter.load_variants(<EOL>case_obj=case_obj, <EOL>variant_type=variant_type, <EOL>category=category,<EOL>rank_threshold=rank_treshold, <EOL>chrom=chrom, <EOL>start=start, <EOL>end=end,<EOL>gene_obj=gene_obj<EOL>)<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOG.warning(e)<EOL>context.abort()<EOL><DEDENT><DEDENT><DEDENT>if i == <NUM_LIT:0>:<EOL><INDENT>LOG.info(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Upload variants to a case\n\n        Note that the files has to be linked with the case, \n        if they are not use 'scout update case'.", "id": "f13756:m0"}
{"signature": "@click.command('<STR_LIT>', short_help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', type=int,<EOL>help=\"<STR_LIT>\", )<EOL>@click.option('<STR_LIT>', required=True, help=\"<STR_LIT>\")<EOL>@click.option('<STR_LIT:-c>', '<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=int)<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=int)<EOL>@click.pass_context<EOL>def region(context, hgnc_id, case_id, chromosome, start, end):", "body": "adapter = context.obj['<STR_LIT>']<EOL>load_region(<EOL>adapter=adapter, case_id=case_id, hgnc_id=hgnc_id, chrom=chromosome, start=start, end=end<EOL>)<EOL>", "docstring": "Load all variants in a region to a existing case", "id": "f13758:m0"}
{"signature": "@click.command('<STR_LIT>')<EOL>@click.argument('<STR_LIT>')<EOL>@click.argument('<STR_LIT>', type=click.Path(exists=True))<EOL>@click.option('<STR_LIT>', '<STR_LIT>', is_flag=True, help='<STR_LIT>')<EOL>@click.pass_context<EOL>def delivery_report(context, case_id, report_path,<EOL>update):", "body": "adapter = context.obj['<STR_LIT>']<EOL>try:<EOL><INDENT>load_delivery_report(adapter=adapter, case_id=case_id,<EOL>report_path=report_path, update=update)<EOL>LOG.info(\"<STR_LIT>\")<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOG.error(e)<EOL>context.abort()<EOL><DEDENT>", "docstring": "Add delivery report to an existing case.", "id": "f13765:m0"}
{"signature": "@click.command('<STR_LIT:user>', short_help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>',<EOL>required=True,<EOL>multiple=True<EOL>)<EOL>@click.option('<STR_LIT>', '<STR_LIT>', required=True)<EOL>@click.option('<STR_LIT>', '<STR_LIT>', required=True)<EOL>@click.option('<STR_LIT>',<EOL>is_flag=True,<EOL>help=\"<STR_LIT>\",<EOL>)<EOL>@click.pass_context<EOL>def user(context, institute_id, user_name, user_mail, admin):", "body": "adapter = context.obj['<STR_LIT>']<EOL>institutes = []<EOL>for institute in institute_id:<EOL><INDENT>institute_obj = adapter.institute(institute_id=institute)<EOL>if not institute_obj:<EOL><INDENT>LOG.warning(\"<STR_LIT>\", institute)<EOL>context.abort()<EOL><DEDENT>institutes.append(institute)<EOL><DEDENT>roles = []<EOL>if admin:<EOL><INDENT>LOG.info(\"<STR_LIT>\")<EOL>roles.append('<STR_LIT>')<EOL><DEDENT>user_info = dict(email=user_mail.lower(), name=user_name, roles=roles, institutes=institutes)<EOL>user_obj = build_user(user_info)<EOL>try:<EOL><INDENT>adapter.add_user(user_obj)<EOL><DEDENT>except Exception as err:<EOL><INDENT>LOG.warning(err)<EOL>context.abort()<EOL><DEDENT>", "docstring": "Add a user to the database.", "id": "f13766:m0"}
{"signature": "@click.command('<STR_LIT>', short_help='<STR_LIT>')<EOL>@click.argument('<STR_LIT>', required=False)<EOL>@click.option('<STR_LIT>', '<STR_LIT>',<EOL>help=\"<STR_LIT>\",<EOL>)<EOL>@click.option('<STR_LIT>', '<STR_LIT>',<EOL>help=\"<STR_LIT>\",<EOL>)<EOL>@click.option('<STR_LIT>', '<STR_LIT:-c>',<EOL>help=\"<STR_LIT>\",<EOL>)<EOL>@click.option('<STR_LIT>', type=click.Path(exists=True),<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', type=click.Path(exists=True),<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', type=click.Path(exists=True),<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', type=click.Path(exists=True),<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', type=click.Path(exists=True),<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', type=click.Path(exists=True),<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', type=click.Path(exists=True),<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', is_flag=True,<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>@click.pass_context<EOL>def case(context, case_id, case_name, institute, collaborator, vcf, vcf_sv,<EOL>vcf_cancer, vcf_research, vcf_sv_research, vcf_cancer_research, peddy_ped,<EOL>reupload_sv, rankscore_treshold, rankmodel_version):", "body": "adapter = context.obj['<STR_LIT>']<EOL>if not case_id:<EOL><INDENT>if not (case_name and institute):<EOL><INDENT>LOG.info(\"<STR_LIT>\")<EOL>context.abort<EOL><DEDENT>case_id = \"<STR_LIT>\".format(institute, case_name)<EOL><DEDENT>case_obj = adapter.case(case_id)<EOL>if not case_obj:<EOL><INDENT>LOG.warning(\"<STR_LIT>\", case_id)<EOL>context.abort()<EOL><DEDENT>case_changed = False<EOL>if collaborator:<EOL><INDENT>if not adapter.institute(collaborator):<EOL><INDENT>LOG.warning(\"<STR_LIT>\", collaborator)<EOL>context.abort()<EOL><DEDENT>if not collaborator in case_obj['<STR_LIT>']:<EOL><INDENT>case_changed = True<EOL>case_obj['<STR_LIT>'].append(collaborator)<EOL>LOG.info(\"<STR_LIT>\", collaborator)<EOL><DEDENT><DEDENT>if vcf:<EOL><INDENT>LOG.info(\"<STR_LIT>\", vcf)<EOL>case_obj['<STR_LIT>']['<STR_LIT>'] = vcf<EOL>case_changed = True<EOL><DEDENT>if vcf_sv:<EOL><INDENT>LOG.info(\"<STR_LIT>\", vcf_sv)<EOL>case_obj['<STR_LIT>']['<STR_LIT>'] = vcf_sv<EOL>case_changed = True<EOL><DEDENT>if vcf_cancer:<EOL><INDENT>LOG.info(\"<STR_LIT>\", vcf_cancer)<EOL>case_obj['<STR_LIT>']['<STR_LIT>'] = vcf_cancer<EOL>case_changed = True<EOL><DEDENT>if vcf_research:<EOL><INDENT>LOG.info(\"<STR_LIT>\", vcf_research)<EOL>case_obj['<STR_LIT>']['<STR_LIT>'] = vcf_research<EOL>case_changed = True<EOL><DEDENT>if vcf_sv_research:<EOL><INDENT>LOG.info(\"<STR_LIT>\", vcf_sv_research)<EOL>case_obj['<STR_LIT>']['<STR_LIT>'] = vcf_sv_research<EOL>case_changed = True<EOL><DEDENT>if vcf_cancer_research:<EOL><INDENT>LOG.info(\"<STR_LIT>\", vcf_cancer_research)<EOL>case_obj['<STR_LIT>']['<STR_LIT>'] = vcf_cancer_research<EOL>case_changed = True<EOL><DEDENT>if case_changed:<EOL><INDENT>adapter.update_case(case_obj)<EOL><DEDENT>if reupload_sv:<EOL><INDENT>LOG.info(\"<STR_LIT>\", case_id)<EOL>updates = {'<STR_LIT>': True}<EOL>if rankscore_treshold:<EOL><INDENT>updates['<STR_LIT>'] = rankmodel_version<EOL><DEDENT>if vcf_sv:<EOL><INDENT>updates['<STR_LIT>'] = vcf_sv<EOL><DEDENT>if vcf_sv:<EOL><INDENT>updates['<STR_LIT>'] = vcf_sv_research<EOL><DEDENT>updated_case = adapter.case_collection.find_one_and_update(<EOL>{'<STR_LIT>':case_id}, <EOL>{'<STR_LIT>': updates<EOL>},<EOL>return_document=pymongo.ReturnDocument.AFTER<EOL>)<EOL>rankscore_treshold = rankscore_treshold or updated_case.get(\"<STR_LIT>\", <NUM_LIT:5>)<EOL>if updated_case['<STR_LIT>'].get('<STR_LIT>'):<EOL><INDENT>adapter.delete_variants(case_id, variant_type='<STR_LIT>', category='<STR_LIT>')<EOL>adapter.load_variants(updated_case, variant_type='<STR_LIT>', <EOL>category='<STR_LIT>', rank_threshold=rankscore_treshold)<EOL><DEDENT>if updated_case['<STR_LIT>'].get('<STR_LIT>'):<EOL><INDENT>adapter.delete_variants(case_id, variant_type='<STR_LIT>', category='<STR_LIT>')<EOL>if updated_case.get('<STR_LIT>'):<EOL><INDENT>adapter.load_variants(updated_case, variant_type='<STR_LIT>', <EOL>category='<STR_LIT>', rank_threshold=rankscore_treshold)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Update a case in the database", "id": "f13767:m0"}
{"signature": "@click.command('<STR_LIT>', short_help='<STR_LIT>')<EOL>@click.option('<STR_LIT>',<EOL>type=click.Choice(['<STR_LIT>', '<STR_LIT>']),<EOL>help=\"<STR_LIT>\"<EOL>)<EOL>@click.option('<STR_LIT>', help='<STR_LIT>')<EOL>@click.pass_context<EOL>def genes(context, build, api_key):", "body": "LOG.info(\"<STR_LIT>\")<EOL>adapter = context.obj['<STR_LIT>']<EOL>api_key = api_key or context.obj.get('<STR_LIT>')<EOL>if not api_key:<EOL><INDENT>LOG.warning(\"<STR_LIT>\")<EOL>context.abort()<EOL><DEDENT>try:<EOL><INDENT>mim_files = fetch_mim_files(api_key, mim2genes=True, morbidmap=True, genemap2=True)<EOL><DEDENT>except Exception as err:<EOL><INDENT>LOG.warning(err)<EOL>context.abort()<EOL><DEDENT>LOG.warning(\"<STR_LIT>\")<EOL>adapter.drop_genes(build)<EOL>LOG.info(\"<STR_LIT>\")<EOL>LOG.warning(\"<STR_LIT>\")<EOL>adapter.drop_transcripts(build)<EOL>LOG.info(\"<STR_LIT>\")<EOL>hpo_genes = fetch_hpo_genes()<EOL>if build:<EOL><INDENT>builds = [build]<EOL><DEDENT>else:<EOL><INDENT>builds = ['<STR_LIT>', '<STR_LIT>']<EOL><DEDENT>hgnc_lines = fetch_hgnc()<EOL>exac_lines = fetch_exac_constraint()<EOL>for build in builds:<EOL><INDENT>ensembl_genes = fetch_ensembl_genes(build=build)<EOL>hgnc_genes = load_hgnc_genes(<EOL>adapter=adapter,<EOL>ensembl_lines=ensembl_genes,<EOL>hgnc_lines=hgnc_lines,<EOL>exac_lines=exac_lines,<EOL>mim2gene_lines=mim_files['<STR_LIT>'],<EOL>genemap_lines=mim_files['<STR_LIT>'],<EOL>hpo_lines=hpo_genes,<EOL>build=build,<EOL>)<EOL>ensembl_genes = {}<EOL>for gene_obj in hgnc_genes:<EOL><INDENT>ensembl_id = gene_obj['<STR_LIT>']<EOL>ensembl_genes[ensembl_id] = gene_obj<EOL><DEDENT>ensembl_transcripts = fetch_ensembl_transcripts(build=build)<EOL>transcripts = load_transcripts(adapter, ensembl_transcripts, build, ensembl_genes)<EOL><DEDENT>adapter.update_indexes()<EOL>LOG.info(\"<STR_LIT>\")<EOL>", "docstring": "Load the hgnc aliases to the mongo database.", "id": "f13771:m0"}
{"signature": "@click.command('<STR_LIT>', short_help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', <EOL>help='<STR_LIT>',<EOL>default='<STR_LIT>',<EOL>show_default=True,<EOL>)<EOL>@click.pass_context<EOL>def omim(context, api_key, institute):", "body": "LOG.info(\"<STR_LIT>\")<EOL>adapter = context.obj['<STR_LIT>']<EOL>api_key = api_key or context.obj.get('<STR_LIT>')<EOL>if not api_key:<EOL><INDENT>LOG.warning(\"<STR_LIT>\")<EOL>context.abort()<EOL><DEDENT>institute_obj = adapter.institute(institute)<EOL>if not institute_obj:<EOL><INDENT>LOG.info(\"<STR_LIT>\", institute)<EOL>LOG.warning(\"<STR_LIT>\")<EOL>context.abort()<EOL><DEDENT>try:<EOL><INDENT>adapter.load_omim_panel(api_key, institute=institute)<EOL><DEDENT>except Exception as err:<EOL><INDENT>LOG.error(err)<EOL>context.abort()<EOL><DEDENT>", "docstring": "Update the automate generated omim gene panel in the database.", "id": "f13772:m0"}
{"signature": "@click.command('<STR_LIT:user>', short_help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>',<EOL>help=\"<STR_LIT>\",<EOL>required=True<EOL>)<EOL>@click.option('<STR_LIT>', '<STR_LIT>',<EOL>type=click.Choice(['<STR_LIT>', '<STR_LIT>']),<EOL>help=\"<STR_LIT>\",<EOL>)<EOL>@click.option('<STR_LIT>',<EOL>is_flag=True,<EOL>help=\"<STR_LIT>\",<EOL>)<EOL>@click.option('<STR_LIT>', '<STR_LIT>',<EOL>multiple=True,<EOL>help=\"<STR_LIT>\",<EOL>)<EOL>@click.option('<STR_LIT>',<EOL>multiple=True,<EOL>help=\"<STR_LIT>\",<EOL>)<EOL>@click.pass_context<EOL>def user(context, user_id, update_role, add_institute, remove_admin, remove_institute):", "body": "adapter = context.obj['<STR_LIT>']<EOL>user_obj = adapter.user(user_id)<EOL>if not user_obj:<EOL><INDENT>LOG.warning(\"<STR_LIT>\", user_id)<EOL>context.abort()<EOL><DEDENT>existing_roles = set(user_obj.get('<STR_LIT>',[]))<EOL>if update_role:<EOL><INDENT>if not update_role in user_obj['<STR_LIT>']:<EOL><INDENT>existing_roles = set(user_obj['<STR_LIT>'])<EOL>existing_roles.add(update_role)<EOL>LOG.info(\"<STR_LIT>\", update_role)<EOL><DEDENT>else:<EOL><INDENT>LOG.warning(\"<STR_LIT>\", update_role)<EOL><DEDENT><DEDENT>if remove_admin:<EOL><INDENT>try:<EOL><INDENT>existing_roles.remove('<STR_LIT>')<EOL>LOG.info(\"<STR_LIT>\", user_id)<EOL><DEDENT>except KeyError as err:<EOL><INDENT>LOG.info(\"<STR_LIT>\", user_id)<EOL><DEDENT><DEDENT>user_obj['<STR_LIT>'] = list(existing_roles)<EOL>existing_institutes = set(user_obj.get('<STR_LIT>',[]))<EOL>for institute_id in add_institute:<EOL><INDENT>institute_obj = adapter.institute(institute_id)<EOL>if not institute_obj:<EOL><INDENT>LOG.warning(\"<STR_LIT>\", institute_id)<EOL><DEDENT>else:<EOL><INDENT>existing_institutes.add(institute_id)<EOL>LOG.info(\"<STR_LIT>\", institute_id)<EOL><DEDENT><DEDENT>for institute_id in remove_institute:<EOL><INDENT>try:<EOL><INDENT>existing_institutes.remove(institute_id)<EOL>LOG.info(\"<STR_LIT>\", institute_id)<EOL><DEDENT>except KeyError as err:<EOL><INDENT>LOG.info(\"<STR_LIT>\", institute_id)<EOL><DEDENT><DEDENT>user_obj['<STR_LIT>'] = list(existing_institutes)<EOL>updated_user = adapter.update_user(user_obj)<EOL>", "docstring": "Update a user in the database", "id": "f13776:m0"}
{"signature": "@click.command()<EOL>@click.option('<STR_LIT:-c>', '<STR_LIT>', type=click.Path(exists=True), envvar='<STR_LIT>',<EOL>help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', default='<STR_LIT:localhost>', help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', default=<NUM_LIT>, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', is_flag=True, help='<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', is_flag=True, help='<STR_LIT>')<EOL>@click.pass_context<EOL>def serve(context, config, host, port, debug, livereload):", "body": "pymongo_config = dict(<EOL>MONGO_HOST=context.obj['<STR_LIT:host>'],<EOL>MONGO_PORT=context.obj['<STR_LIT:port>'],<EOL>MONGO_DBNAME=context.obj['<STR_LIT>'],<EOL>MONGO_USERNAME=context.obj['<STR_LIT:username>'],<EOL>MONGO_PASSWORD=context.obj['<STR_LIT:password>'],<EOL>)<EOL>valid_connection = check_connection(<EOL>host=pymongo_config['<STR_LIT>'], <EOL>port=pymongo_config['<STR_LIT>'], <EOL>username=pymongo_config['<STR_LIT>'], <EOL>password=pymongo_config['<STR_LIT>'],<EOL>authdb=context.obj['<STR_LIT>'],<EOL>)<EOL>log.info(\"<STR_LIT>\")<EOL>if not valid_connection:<EOL><INDENT>log.warning(\"<STR_LIT>\")<EOL>log.info(\"<STR_LIT>\")<EOL>context.abort()<EOL><DEDENT>config = os.path.abspath(config) if config else None<EOL>app = create_app(config=pymongo_config, config_file=config)<EOL>if livereload:<EOL><INDENT>server = Server(app.wsgi_app)<EOL>server.serve(host=host, port=port, debug=debug)<EOL><DEDENT>else:<EOL><INDENT>app.run(host=host, port=port, debug=debug)<EOL><DEDENT>", "docstring": "Start the web server.", "id": "f13780:m0"}
{"signature": "def get_variantid(variant_obj, family_id):", "body": "new_id = parse_document_id(<EOL>chrom=variant_obj['<STR_LIT>'],<EOL>pos=str(variant_obj['<STR_LIT>']),<EOL>ref=variant_obj['<STR_LIT>'],<EOL>alt=variant_obj['<STR_LIT>'],<EOL>variant_type=variant_obj['<STR_LIT>'],<EOL>case_id=family_id,<EOL>)<EOL>return new_id<EOL>", "docstring": "Create a new variant id.\n\n    Args:\n        variant_obj(dict)\n        family_id(str)\n\n    Returns:\n        new_id(str): The new variant id", "id": "f13782:m0"}
{"signature": "def update_caseid(self, case_obj, family_id):", "body": "new_case = deepcopy(case_obj)<EOL>new_case['<STR_LIT>'] = family_id<EOL>for case_variants in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>new_variantids = []<EOL>for variant_id in case_obj.get(case_variants, []):<EOL><INDENT>case_variant = self.variant(variant_id)<EOL>if not case_variant:<EOL><INDENT>continue<EOL><DEDENT>new_variantid = get_variantid(case_variant, family_id)<EOL>new_variantids.append(new_variantid)<EOL><DEDENT>new_case[case_variants] = new_variantids<EOL><DEDENT>for acmg_obj in self.acmg_collection.find({'<STR_LIT>': case_obj['<STR_LIT>']}):<EOL><INDENT>LOG.info(\"<STR_LIT>\", acmg_obj['<STR_LIT>'])<EOL>acmg_variant = self.variant(acmg_obj['<STR_LIT>'])<EOL>new_specific_id = get_variantid(acmg_variant, family_id)<EOL>self.acmg_collection.find_one_and_update(<EOL>{'<STR_LIT>': acmg_obj['<STR_LIT>']},<EOL>{'<STR_LIT>': {'<STR_LIT>': family_id, '<STR_LIT>': new_specific_id}},<EOL>)<EOL><DEDENT>institute_obj = self.institute(case_obj['<STR_LIT>'])<EOL>for event_obj in self.events(institute_obj, case=case_obj):<EOL><INDENT>LOG.info(\"<STR_LIT>\", event_obj['<STR_LIT>'])<EOL>self.event_collection.find_one_and_update(<EOL>{'<STR_LIT>': event_obj['<STR_LIT>']},<EOL>{'<STR_LIT>': {'<STR_LIT>': family_id}},<EOL>)<EOL><DEDENT>self.case_collection.insert_one(new_case)<EOL>self.case_collection.find_one_and_delete({'<STR_LIT>': case_obj['<STR_LIT>']})<EOL>return new_case<EOL>", "docstring": "Update case id for a case across the database.\n\n        This function is used when a case is a rerun or updated for another reason.\n\n        Args:\n            case_obj(dict)\n            family_id(str): The new family id\n\n        Returns:\n            new_case(dict): The updated case object", "id": "f13782:c0:m10"}
{"signature": "def nr_cases(self, institute_id=None):", "body": "query = {}<EOL>if institute_id:<EOL><INDENT>query['<STR_LIT>'] = institute_id<EOL><DEDENT>LOG.debug(\"<STR_LIT>\".format(query))<EOL>nr_cases = self.case_collection.find(query).count()<EOL>return nr_cases<EOL>", "docstring": "Return the number of cases\n\n        This function will change when we migrate to 3.7.1\n\n        Args:\n            collaborator(str): Institute id\n\n        Returns:\n            nr_cases(int)", "id": "f13782:c0:m1"}
{"signature": "def case_ind(self, ind_id):", "body": "return self.case_collection.find({'<STR_LIT>': ind_id})<EOL>", "docstring": "Fetch cases based on an individual id.\n\n        Args:\n            ind_id(str)\n\n        Returns:\n            cases(pymongo.cursor): The cases with a matching ind_id", "id": "f13782:c0:m4"}
{"signature": "def update_case(self, case_obj):", "body": "<EOL>LOG.info(\"<STR_LIT>\".format(case_obj['<STR_LIT>']))<EOL>old_case = self.case_collection.find_one(<EOL>{'<STR_LIT>': case_obj['<STR_LIT>']}<EOL>)<EOL>updated_case = self.case_collection.find_one_and_update(<EOL>{'<STR_LIT>': case_obj['<STR_LIT>']},<EOL>{<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': {'<STR_LIT>': case_obj['<STR_LIT>']},<EOL>'<STR_LIT>': {<EOL>'<STR_LIT:date>': old_case['<STR_LIT>'],<EOL>'<STR_LIT>': old_case.get('<STR_LIT>')<EOL>}<EOL>},<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': case_obj['<STR_LIT>'],<EOL>'<STR_LIT>': case_obj.get('<STR_LIT>'),<EOL>'<STR_LIT>': case_obj['<STR_LIT>'],<EOL>'<STR_LIT>': datetime.datetime.now(),<EOL>'<STR_LIT>': False,<EOL>'<STR_LIT>': case_obj.get('<STR_LIT>', []),<EOL>'<STR_LIT>': case_obj.get('<STR_LIT>', '<STR_LIT>'),<EOL>'<STR_LIT>': case_obj.get('<STR_LIT>'),<EOL>'<STR_LIT>': case_obj.get('<STR_LIT>'),<EOL>'<STR_LIT>': case_obj.get('<STR_LIT>'),<EOL>'<STR_LIT>': case_obj.get('<STR_LIT>'),<EOL>'<STR_LIT>': case_obj.get('<STR_LIT>'),<EOL>'<STR_LIT>': case_obj.get('<STR_LIT>'),<EOL>'<STR_LIT>': case_obj.get('<STR_LIT>', False),<EOL>'<STR_LIT>': case_obj.get('<STR_LIT>', False),<EOL>'<STR_LIT>': case_obj.get('<STR_LIT>'),<EOL>'<STR_LIT>': case_obj.get('<STR_LIT>'),<EOL>}<EOL>},<EOL>return_document=pymongo.ReturnDocument.AFTER<EOL>)<EOL>LOG.info(\"<STR_LIT>\")<EOL>return updated_case<EOL>", "docstring": "Update a case in the database\n\n        The following will be updated:\n            - collaborators: If new collaborators these will be added to the old ones\n            - analysis_date: Is updated to the new date\n            - analyses: The new analysis date will be added to old runs\n            - individuals: There could be new individuals\n            - updated_at: When the case was updated in the database\n            - rerun_requested: Is set to False since that is probably what happened\n            - panels: The new gene panels are added\n            - genome_build: If there is a new genome build\n            - genome_version: - || -\n            - rank_model_version: If there is a new rank model\n            - madeline_info: If there is a new pedigree\n            - vcf_files: paths to the new files\n            - has_svvariants: If there are new svvariants\n            - has_strvariants: If there are new strvariants\n            - multiqc: If there's an updated multiqc report location\n            - mme_submission: If case was submitted to MatchMaker Exchange\n\n            Args:\n                case_obj(dict): The new case information\n\n            Returns:\n                updated_case(dict): The updated case information", "id": "f13782:c0:m8"}
{"signature": "def get_evaluations(self, variant_obj):", "body": "query = dict(variant_id=variant_obj['<STR_LIT>'])<EOL>res = self.acmg_collection.find(query).sort([('<STR_LIT>', pymongo.DESCENDING)])<EOL>return res<EOL>", "docstring": "Return all evaluations for a certain variant.\n\n        Args:\n            variant_obj (dict): variant dict from the database\n\n        Returns:\n            pymongo.cursor: database cursor", "id": "f13783:c0:m4"}
{"signature": "def unassign(self, institute, case, user, link):", "body": "LOG.info(\"<STR_LIT>\".format(<EOL>user['<STR_LIT:name>'], case['<STR_LIT>']))<EOL>self.create_event(<EOL>institute=institute,<EOL>case=case,<EOL>user=user,<EOL>link=link,<EOL>category='<STR_LIT>',<EOL>verb='<STR_LIT>',<EOL>subject=case['<STR_LIT>']<EOL>)<EOL>LOG.info(\"<STR_LIT>\".format(<EOL>case['<STR_LIT>'], user['<STR_LIT:name>']))<EOL>updated_case = self.case_collection.find_one_and_update(<EOL>{'<STR_LIT>': case['<STR_LIT>']},<EOL>{'<STR_LIT>': {'<STR_LIT>': user['<STR_LIT>']}},<EOL>return_document=pymongo.ReturnDocument.AFTER<EOL>)<EOL>LOG.debug(\"<STR_LIT>\")<EOL>return updated_case<EOL>", "docstring": "Unassign a user from a case.\n\n        This function will create an Event to log that a person has been\n        unassigned from a case. Also the user will be removed from case\n        \"assignees\".\n\n        Arguments:\n            institute (dict): A Institute object\n            case (dict): A Case object\n            user (dict): A User object (Should this be a user id?)\n            link (dict): The url to be used in the event\n\n        Returns:\n            updated_case (dict): The updated case", "id": "f13784:c0:m1"}
{"signature": "def add_cohort(self, institute, case, user, link, tag):", "body": "self.create_event(<EOL>institute=institute,<EOL>case=case,<EOL>user=user,<EOL>link=link,<EOL>category='<STR_LIT>',<EOL>verb='<STR_LIT>',<EOL>subject=link<EOL>)<EOL>LOG.info(\"<STR_LIT>\"<EOL>.format(tag, case['<STR_LIT>']))<EOL>updated_case = self.case_collection.find_one_and_update(<EOL>{'<STR_LIT>': case['<STR_LIT>']},<EOL>{<EOL>'<STR_LIT>': {'<STR_LIT>': tag},<EOL>},<EOL>return_document=pymongo.ReturnDocument.AFTER<EOL>)<EOL>LOG.debug(\"<STR_LIT>\")<EOL>return updated_case<EOL>", "docstring": "Add a cohort tag to case\n\n        Arguments:\n            institute (dict): A Institute object\n            case (dict): Case object\n            user (dict): A User object\n            link (str): The url to be used in the event\n            tag (str): The cohort tag to be added\n\n        Return:\n            updated_case(dict)", "id": "f13784:c0:m10"}
{"signature": "def share(self, institute, case, collaborator_id, user, link):", "body": "if collaborator_id in case.get('<STR_LIT>', []):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>self.create_event(<EOL>institute=institute,<EOL>case=case,<EOL>user=user,<EOL>link=link,<EOL>category='<STR_LIT>',<EOL>verb='<STR_LIT>',<EOL>subject=collaborator_id<EOL>)<EOL>updated_case = self.case_collection.find_one_and_update(<EOL>{'<STR_LIT>': case['<STR_LIT>']},<EOL>{<EOL>'<STR_LIT>': {'<STR_LIT>': collaborator_id}<EOL>},<EOL>return_document=pymongo.ReturnDocument.AFTER<EOL>)<EOL>LOG.debug(\"<STR_LIT>\")<EOL>return updated_case<EOL>", "docstring": "Share a case with a new institute.\n\n        Arguments:\n            institute (dict): A Institute object\n            case (dict): Case object\n            collaborator_id (str): A instute id\n            user (dict): A User object\n            link (str): The url to be used in the event\n\n        Return:\n            updated_case", "id": "f13784:c0:m7"}
{"signature": "def update_status(self, institute, case, user, status, link):", "body": "if status not in CASE_STATUSES:<EOL><INDENT>LOG.warning(\"<STR_LIT>\".format(status))<EOL>return None<EOL><DEDENT>LOG.info(\"<STR_LIT>\".format(<EOL>case['<STR_LIT>'], status))<EOL>self.create_event(<EOL>institute=institute,<EOL>case=case,<EOL>user=user,<EOL>link=link,<EOL>category='<STR_LIT>',<EOL>verb='<STR_LIT:status>',<EOL>subject=case['<STR_LIT>']<EOL>)<EOL>LOG.info(\"<STR_LIT>\".format(case['<STR_LIT>'], status))<EOL>updated_case = self.case_collection.find_one_and_update(<EOL>{'<STR_LIT>': case['<STR_LIT>']},<EOL>{'<STR_LIT>': {'<STR_LIT:status>': status}},<EOL>return_document=pymongo.ReturnDocument.AFTER<EOL>)<EOL>LOG.debug(\"<STR_LIT>\")<EOL>return updated_case<EOL>", "docstring": "Update the status of a case.\n\n        This function will create an Event to log that a user have updated the\n        status of a case. Also the status of the case will be updated.\n        Status could be anyone of:\n            (\"prioritized\", \"inactive\", \"active\", \"solved\", \"archived\")\n\n        Arguments:\n            institute (dict): A Institute object\n            case (dict): A Case object\n            user (dict): A User object\n            status (str): The new status of the case\n            link (str): The url to be used in the event\n\n        Returns:\n            updated_case", "id": "f13784:c0:m2"}
{"signature": "def remove_cohort(self, institute, case, user, link, tag):", "body": "self.create_event(<EOL>institute=institute,<EOL>case=case,<EOL>user=user,<EOL>link=link,<EOL>category='<STR_LIT>',<EOL>verb='<STR_LIT>',<EOL>subject=case['<STR_LIT>'],<EOL>)<EOL>LOG.info(\"<STR_LIT>\"<EOL>.format(tag, case['<STR_LIT>']))<EOL>updated_case = self.case_collection.find_one_and_update(<EOL>{'<STR_LIT>': case['<STR_LIT>']},<EOL>{<EOL>'<STR_LIT>': {'<STR_LIT>': tag},<EOL>},<EOL>return_document=pymongo.ReturnDocument.AFTER<EOL>)<EOL>LOG.debug(\"<STR_LIT>\")<EOL>return updated_case<EOL>", "docstring": "Remove a cohort tag from case\n\n        Arguments:\n            institute (dict): A Institute object\n            case (dict): Case object\n            user (dict): A User object\n            link (str): The url to be used in the event\n            tag (str): The cohort tag to be removed\n\n        Return:\n            updated_case(dict)", "id": "f13784:c0:m11"}
{"signature": "def mark_checked(self, institute, case, user, link,<EOL>unmark=False):", "body": "LOG.info(\"<STR_LIT>\"<EOL>.format(case['<STR_LIT>']))<EOL>status = '<STR_LIT>' if unmark else '<STR_LIT>'<EOL>self.create_event(<EOL>institute=institute,<EOL>case=case,<EOL>user=user,<EOL>link=link,<EOL>category='<STR_LIT>',<EOL>verb='<STR_LIT>',<EOL>subject=status<EOL>)<EOL>LOG.info(\"<STR_LIT>\"<EOL>.format(case['<STR_LIT>'], status))<EOL>analysis_checked = False if unmark else True<EOL>updated_case = self.case_collection.find_one_and_update(<EOL>{'<STR_LIT>': case['<STR_LIT>']},<EOL>{<EOL>'<STR_LIT>': {'<STR_LIT>': analysis_checked}<EOL>},<EOL>return_document=pymongo.ReturnDocument.AFTER<EOL>)<EOL>LOG.debug(\"<STR_LIT>\")<EOL>return updated_case<EOL>", "docstring": "Mark a case as checked from an analysis point of view.\n\n        Arguments:\n            institute (dict): A Institute object\n            case (dict): Case object\n            user (dict): A User object\n            link (str): The url to be used in the event\n            unmark (bool): If case should ve unmarked\n\n        Return:\n            updated_case", "id": "f13784:c0:m12"}
{"signature": "def request_rerun(self, institute, case, user, link):", "body": "if case.get('<STR_LIT>'):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>self.create_event(<EOL>institute=institute,<EOL>case=case,<EOL>user=user,<EOL>link=link,<EOL>category='<STR_LIT>',<EOL>verb='<STR_LIT>',<EOL>subject=case['<STR_LIT>']<EOL>)<EOL>updated_case = self.case_collection.find_one_and_update(<EOL>{'<STR_LIT>': case['<STR_LIT>']},<EOL>{<EOL>'<STR_LIT>': {'<STR_LIT>': True}<EOL>},<EOL>return_document=pymongo.ReturnDocument.AFTER<EOL>)<EOL>LOG.debug(\"<STR_LIT>\")<EOL>return updated_case<EOL>", "docstring": "Request a case to be re-analyzed.\n\n        Arguments:\n            institute (dict): A Institute object\n            case (dict): Case object\n            user (dict): A User object\n            link (str): The url to be used in the event\n\n        Return:\n            updated_case", "id": "f13784:c0:m6"}
{"signature": "def sample_variants(self, variants, sample_name, category = '<STR_LIT>'):", "body": "LOG.info('<STR_LIT>'.format(sample_name))<EOL>has_allele = re.compile('<STR_LIT>') <EOL>query = {<EOL>'<STR_LIT>': [<EOL>{'<STR_LIT>' : { '<STR_LIT>' : variants}},<EOL>{'<STR_LIT>' : category},<EOL>{'<STR_LIT>': {<EOL>'<STR_LIT>': { '<STR_LIT>' : sample_name, '<STR_LIT>': { '<STR_LIT>' : has_allele } }<EOL>}}<EOL>]<EOL>}<EOL>result = self.variant_collection.find(query)<EOL>return result<EOL>", "docstring": "Given a list of variants get variant objects found in a specific patient\n\n        Args:\n            variants(list): a list of variant ids\n            sample_name(str): a sample display name\n            category(str): 'snv', 'sv' ..\n\n        Returns:\n            result(iterable(Variant))", "id": "f13785:c0:m13"}
{"signature": "def delete_variants(self, case_id, variant_type, category=None):", "body": "category = category or '<STR_LIT>'<EOL>LOG.info(\"<STR_LIT>\".format(<EOL>variant_type, category, case_id))<EOL>query = {'<STR_LIT>': case_id, '<STR_LIT>': variant_type}<EOL>if category:<EOL><INDENT>query['<STR_LIT>'] = category<EOL><DEDENT>result = self.variant_collection.delete_many(query)<EOL>LOG.info(\"<STR_LIT>\".format(result.deleted_count))<EOL>", "docstring": "Delete variants of one type for a case\n\n            This is used when a case is reanalyzed\n\n            Args:\n                case_id(str): The case id\n                variant_type(str): 'research' or 'clinical'\n                category(str): 'snv', 'sv' or 'cancer'", "id": "f13785:c0:m9"}
{"signature": "def load_indexes(self):", "body": "for collection_name in INDEXES:<EOL><INDENT>existing_indexes = self.indexes(collection_name)<EOL>indexes = INDEXES[collection_name]<EOL>for index in indexes:<EOL><INDENT>index_name = index.document.get('<STR_LIT:name>')<EOL>if index_name in existing_indexes:<EOL><INDENT>LOG.info(\"<STR_LIT>\" % index_name)<EOL>self.db[collection_name].drop_index(index_name)<EOL><DEDENT><DEDENT>LOG.info(\"<STR_LIT>\".format(<EOL>collection_name,<EOL>'<STR_LIT:U+002CU+0020>'.join([index.document.get('<STR_LIT:name>') for index in indexes])<EOL>))<EOL>self.db[collection_name].create_indexes(indexes)<EOL><DEDENT>", "docstring": "Add the proper indexes to the scout instance.\n\n        All indexes are specified in scout/constants/indexes.py\n\n        If this method is utilised when new indexes are defined those should be added", "id": "f13786:c0:m1"}
{"signature": "def gene_to_panels(self, case_obj):", "body": "LOG.info(\"<STR_LIT>\")<EOL>gene_dict = {}<EOL>for panel_info in case_obj.get('<STR_LIT>', []):<EOL><INDENT>panel_name = panel_info['<STR_LIT>']<EOL>panel_version = panel_info['<STR_LIT:version>']<EOL>panel_obj = self.gene_panel(panel_name, version=panel_version)<EOL>if not panel_obj:<EOL><INDENT>LOG.warning(\"<STR_LIT>\".format(panel_name, panel_version))<EOL><DEDENT>for gene in panel_obj['<STR_LIT>']:<EOL><INDENT>hgnc_id = gene['<STR_LIT>']<EOL>if hgnc_id not in gene_dict:<EOL><INDENT>gene_dict[hgnc_id] = set([panel_name])<EOL>continue<EOL><DEDENT>gene_dict[hgnc_id].add(panel_name)<EOL><DEDENT><DEDENT>LOG.info(\"<STR_LIT>\")<EOL>return gene_dict<EOL>", "docstring": "Fetch all gene panels and group them by gene\n\n            Args:\n                case_obj(scout.models.Case)\n            Returns:\n                gene_dict(dict): A dictionary with gene as keys and a set of\n                                 panel names as value", "id": "f13787:c0:m10"}
{"signature": "def add_gene_panel(self, panel_obj):", "body": "panel_name = panel_obj['<STR_LIT>']<EOL>panel_version = panel_obj['<STR_LIT:version>']<EOL>display_name = panel_obj.get('<STR_LIT>', panel_name)<EOL>if self.gene_panel(panel_name, panel_version):<EOL><INDENT>raise IntegrityError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(panel_name, panel_version))<EOL><DEDENT>LOG.info(\"<STR_LIT>\".format(<EOL>display_name, panel_version<EOL>))<EOL>result = self.panel_collection.insert_one(panel_obj)<EOL>LOG.debug(\"<STR_LIT>\")<EOL>return result.inserted_id<EOL>", "docstring": "Add a gene panel to the database\n\n            Args:\n                panel_obj(dict)", "id": "f13787:c0:m4"}
{"signature": "def setup(self, database):", "body": "self.db = database<EOL>self.hgnc_collection = database.hgnc_gene<EOL>self.user_collection = database.user<EOL>self.whitelist_collection = database.whitelist<EOL>self.institute_collection = database.institute<EOL>self.event_collection = database.event<EOL>self.case_collection = database.case<EOL>self.panel_collection = database.gene_panel<EOL>self.hpo_term_collection = database.hpo_term<EOL>self.disease_term_collection = database.disease_term<EOL>self.variant_collection = database.variant<EOL>self.acmg_collection = database.acmg<EOL>self.clinvar_collection = database.clinvar<EOL>self.clinvar_submission_collection = database.clinvar_submission<EOL>self.exon_collection = database.exon<EOL>self.transcript_collection = database.transcript<EOL>", "docstring": "Setup connection to database.", "id": "f13788:c0:m2"}
{"signature": "def get_clinvar_id(self, submission_id):", "body": "submission_obj = self.clinvar_submission_collection.find_one({'<STR_LIT>': ObjectId(submission_id)})<EOL>clinvar_subm_id = submission_obj.get('<STR_LIT>') <EOL>return clinvar_subm_id<EOL>", "docstring": "Returns the official Clinvar submission ID for a submission object\n\n            Args:\n                submission_id(str): submission_id(str) : id of the submission\n\n            Returns:\n                clinvar_subm_id(str): a string with a format: SUB[0-9]. It is obtained from clinvar portal when starting a new submission", "id": "f13789:c0:m4"}
{"signature": "def clinvar_submissions(self, user_id, institute_id):", "body": "LOG.info(\"<STR_LIT>\", user_id, institute_id)<EOL>query = dict(user_id=user_id, institute_id=institute_id)<EOL>results = list(self.clinvar_submission_collection.find(query))<EOL>submissions = []<EOL>for result in results:<EOL><INDENT>submission = {}<EOL>submission['<STR_LIT>'] =  result.get('<STR_LIT>')<EOL>submission['<STR_LIT:status>'] = result.get('<STR_LIT:status>')<EOL>submission['<STR_LIT>'] = result.get('<STR_LIT>')<EOL>submission['<STR_LIT>'] = result.get('<STR_LIT>')<EOL>submission['<STR_LIT>'] = result.get('<STR_LIT>')<EOL>submission['<STR_LIT>'] = result.get('<STR_LIT>')<EOL>if '<STR_LIT>' in result:<EOL><INDENT>submission['<STR_LIT>'] = result['<STR_LIT>']<EOL><DEDENT>if result.get('<STR_LIT>'):<EOL><INDENT>submission['<STR_LIT>'] = self.clinvar_collection.find({'<STR_LIT>': { \"<STR_LIT>\": result['<STR_LIT>'] } })<EOL><DEDENT>if result.get('<STR_LIT>'):<EOL><INDENT>submission['<STR_LIT>'] = self.clinvar_collection.find({'<STR_LIT>' : { \"<STR_LIT>\": result['<STR_LIT>'] } })<EOL><DEDENT>submissions.append(submission)<EOL><DEDENT>return submissions<EOL>", "docstring": "Collect all open and closed clinvar submission created by a user for an institute\n\n            Args:\n                user_id(str): a user ID\n                institute_id(str): an institute ID\n\n            Returns:\n                submissions(list): a list of clinvar submission objects", "id": "f13789:c0:m7"}
{"signature": "def coordinate_filter(self, query, mongo_query):", "body": "LOG.debug('<STR_LIT>')<EOL>chromosome = query['<STR_LIT>']<EOL>mongo_query['<STR_LIT>'] = chromosome<EOL>if (query.get('<STR_LIT:start>') and query.get('<STR_LIT:end>')):<EOL><INDENT>mongo_query['<STR_LIT>'] = {'<STR_LIT>': int(query['<STR_LIT:end>'])}<EOL>mongo_query['<STR_LIT:end>'] = {'<STR_LIT>': int(query['<STR_LIT:start>'])}<EOL><DEDENT>return mongo_query<EOL>", "docstring": "Adds genomic coordinated-related filters to the query object\n\n        Args:\n            query(dict): a dictionary of query filters specified by the users\n            mongo_query(dict): the query that is going to be submitted to the database\n\n        Returns:\n            mongo_query(dict): returned object contains coordinate filters", "id": "f13790:c0:m3"}
{"signature": "def user(self, email):", "body": "LOG.info(\"<STR_LIT>\", email)<EOL>user_obj = self.user_collection.find_one({'<STR_LIT>': email})<EOL>return user_obj<EOL>", "docstring": "Fetch a user from the database.\n\n            Args:\n                email(str)\n\n            Returns:\n                user_obj(dict)", "id": "f13793:c0:m3"}
{"signature": "def delete_user(self, email):", "body": "LOG.info(\"<STR_LIT>\", email)<EOL>user_obj = self.user_collection.delete_one({'<STR_LIT>': email})<EOL>return user_obj<EOL>", "docstring": "Delete a user from the database\n\n        Args:\n            email(str)\n\n        Returns:\n            user_obj(dict)", "id": "f13793:c0:m4"}
{"signature": "def load_variants(self, case_obj, variant_type='<STR_LIT>', category='<STR_LIT>',<EOL>rank_threshold=None, chrom=None, start=None, end=None,<EOL>gene_obj=None, build='<STR_LIT>'):", "body": "<EOL>institute_id = self.institute(institute_id=case_obj['<STR_LIT>'])['<STR_LIT>']<EOL>nr_inserted = <NUM_LIT:0><EOL>variant_file = None<EOL>if variant_type == '<STR_LIT>':<EOL><INDENT>if category == '<STR_LIT>':<EOL><INDENT>variant_file = case_obj['<STR_LIT>'].get('<STR_LIT>')<EOL><DEDENT>elif category == '<STR_LIT>':<EOL><INDENT>variant_file = case_obj['<STR_LIT>'].get('<STR_LIT>')<EOL><DEDENT>elif category == '<STR_LIT:str>':<EOL><INDENT>LOG.debug('<STR_LIT>')<EOL>variant_file = case_obj['<STR_LIT>'].get('<STR_LIT>')<EOL><DEDENT>elif category == '<STR_LIT>':<EOL><INDENT>variant_file = case_obj['<STR_LIT>'].get('<STR_LIT>')<EOL><DEDENT><DEDENT>elif variant_type == '<STR_LIT>':<EOL><INDENT>if category == '<STR_LIT>':<EOL><INDENT>variant_file = case_obj['<STR_LIT>'].get('<STR_LIT>')<EOL><DEDENT>elif category == '<STR_LIT>':<EOL><INDENT>variant_file = case_obj['<STR_LIT>'].get('<STR_LIT>')<EOL><DEDENT>elif category == '<STR_LIT>':<EOL><INDENT>variant_file = case_obj['<STR_LIT>'].get('<STR_LIT>')<EOL><DEDENT><DEDENT>if not variant_file:<EOL><INDENT>raise SyntaxError(\"<STR_LIT>\")<EOL><DEDENT>try:<EOL><INDENT>vcf_obj = VCF(variant_file)<EOL>var = next(vcf_obj)<EOL><DEDENT>except StopIteration as err:<EOL><INDENT>LOG.warning(\"<STR_LIT>\", variant_file)<EOL>return nr_inserted<EOL><DEDENT>vcf_obj = VCF(variant_file)<EOL>rank_results_header = parse_rank_results_header(vcf_obj)<EOL>vep_header = parse_vep_header(vcf_obj)<EOL>individual_positions = {}<EOL>for i, ind in enumerate(vcf_obj.samples):<EOL><INDENT>individual_positions[ind] = i<EOL><DEDENT>sample_info = {}<EOL>if category == '<STR_LIT>':<EOL><INDENT>for ind in case_obj['<STR_LIT>']:<EOL><INDENT>if ind['<STR_LIT>'] == <NUM_LIT:2>:<EOL><INDENT>sample_info[ind['<STR_LIT>']] = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>sample_info[ind['<STR_LIT>']] = '<STR_LIT>'<EOL><DEDENT><DEDENT><DEDENT>region = \"<STR_LIT>\"<EOL>if gene_obj:<EOL><INDENT>chrom = gene_obj['<STR_LIT>']<EOL>start = max(gene_obj['<STR_LIT:start>'] - <NUM_LIT>, <NUM_LIT:0>)<EOL>end = gene_obj['<STR_LIT:end>'] + <NUM_LIT><EOL><DEDENT>if chrom:<EOL><INDENT>rank_threshold = rank_threshold or -<NUM_LIT:1000><EOL>if not (start and end):<EOL><INDENT>raise SyntaxError(\"<STR_LIT>\")<EOL><DEDENT>region = \"<STR_LIT>\".format(chrom, start, end)<EOL><DEDENT>else:<EOL><INDENT>rank_threshold = rank_threshold or <NUM_LIT:0><EOL><DEDENT>variants = vcf_obj(region)<EOL>try:<EOL><INDENT>nr_inserted = self._load_variants(<EOL>variants=variants,<EOL>variant_type=variant_type,<EOL>case_obj=case_obj,<EOL>individual_positions=individual_positions,<EOL>rank_threshold=rank_threshold,<EOL>institute_id=institute_id,<EOL>build=build,<EOL>rank_results_header=rank_results_header,<EOL>vep_header=vep_header,<EOL>category=category,<EOL>sample_info = sample_info<EOL>)<EOL><DEDENT>except Exception as error:<EOL><INDENT>LOG.exception('<STR_LIT>')<EOL>LOG.warning(\"<STR_LIT>\")<EOL>self.delete_variants(case_obj['<STR_LIT>'], variant_type)<EOL>raise error<EOL><DEDENT>self.update_variant_rank(case_obj, variant_type, category=category)<EOL>return nr_inserted<EOL>", "docstring": "Load variants for a case into scout.\n\n        Load the variants for a specific analysis type and category into scout.\n        If no region is specified, load all variants above rank score threshold\n        If region or gene is specified, load all variants from that region\n        disregarding variant rank(if not specified)\n\n        Args:\n            case_obj(dict): A case from the scout database\n            variant_type(str): 'clinical' or 'research'. Default: 'clinical'\n            category(str): 'snv', 'str' or 'sv'. Default: 'snv'\n            rank_threshold(float): Only load variants above this score. Default: 0\n            chrom(str): Load variants from a certain chromosome\n            start(int): Specify the start position\n            end(int): Specify the end position\n            gene_obj(dict): A gene object from the database\n\n        Returns:\n            nr_inserted(int)", "id": "f13794:c0:m10"}
{"signature": "def load_variant_bulk(self, variants):", "body": "if not len(variants) > <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>LOG.debug(\"<STR_LIT>\")<EOL>try:<EOL><INDENT>result = self.variant_collection.insert_many(variants)<EOL><DEDENT>except (DuplicateKeyError, BulkWriteError) as err:<EOL><INDENT>for var_obj in variants:<EOL><INDENT>try:<EOL><INDENT>self.upsert_variant(var_obj)<EOL><DEDENT>except IntegrityError as err:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>return<EOL>", "docstring": "Load a bulk of variants\n\n        Args:\n            variants(iterable(scout.models.Variant))\n\n        Returns:\n            object_ids", "id": "f13794:c0:m8"}
{"signature": "def update_mongo_compound_variants(self, bulk):", "body": "requests = []<EOL>for var_id in bulk:<EOL><INDENT>var_obj = bulk[var_id]<EOL>if not var_obj.get('<STR_LIT>'):<EOL><INDENT>continue<EOL><DEDENT>operation = pymongo.UpdateOne(<EOL>{'<STR_LIT>': var_obj['<STR_LIT>']},<EOL>{<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': var_obj['<STR_LIT>']<EOL>}<EOL>})<EOL>requests.append(operation)<EOL><DEDENT>if not requests:<EOL><INDENT>return<EOL><DEDENT>try:<EOL><INDENT>self.variant_collection.bulk_write(requests, ordered=False)<EOL><DEDENT>except BulkWriteError as err:<EOL><INDENT>LOG.warning(\"<STR_LIT>\")<EOL>raise err<EOL><DEDENT>", "docstring": "Update the compound information for a bulk of variants in the database\n\n            Args:\n                bulk(dict): {'_id': scout.models.Variant}", "id": "f13794:c0:m4"}
{"signature": "def load_variant(self, variant_obj):", "body": "<EOL>try:<EOL><INDENT>result = self.variant_collection.insert_one(variant_obj)<EOL><DEDENT>except DuplicateKeyError as err:<EOL><INDENT>raise IntegrityError(\"<STR_LIT>\", variant_obj['<STR_LIT>'])<EOL><DEDENT>return result<EOL>", "docstring": "Load a variant object\n\n        Args:\n            variant_obj(dict)\n\n        Returns:\n            inserted_id", "id": "f13794:c0:m6"}
{"signature": "def sanger_ordered(self, institute_id=None, user_id=None):", "body": "query = {'<STR_LIT>': {<EOL>'<STR_LIT>': [<EOL>{'<STR_LIT>': '<STR_LIT>'},<EOL>],<EOL>}}<EOL>if institute_id:<EOL><INDENT>query['<STR_LIT>']['<STR_LIT>'].append({'<STR_LIT>': institute_id})<EOL><DEDENT>if user_id:<EOL><INDENT>query['<STR_LIT>']['<STR_LIT>'].append({'<STR_LIT>': user_id})<EOL><DEDENT>results = self.event_collection.aggregate([<EOL>query,<EOL>{'<STR_LIT>': {<EOL>'<STR_LIT>': \"<STR_LIT>\",<EOL>'<STR_LIT>': {'<STR_LIT>' : '<STR_LIT>'}<EOL>}}<EOL>])<EOL>sanger_ordered =  [item for item in results]<EOL>return sanger_ordered<EOL>", "docstring": "Get all variants with validations ever ordered.\n\n        Args:\n            institute_id(str) : The id of an institute\n            user_id(str) : The id of an user\n\n        Returns:\n            sanger_ordered(list) : a list of dictionaries, each with \"case_id\" as keys and list of variant ids as values", "id": "f13796:c0:m4"}
{"signature": "def update_mosaic_tags(self, institute, case, user, link, variant,<EOL>mosaic_tags):", "body": "LOG.info(\"<STR_LIT>\", variant['<STR_LIT>'])<EOL>self.create_event(<EOL>institute=institute,<EOL>case=case,<EOL>user=user,<EOL>link=link,<EOL>category='<STR_LIT>',<EOL>verb='<STR_LIT>',<EOL>variant=variant,<EOL>subject=variant['<STR_LIT>'],<EOL>)<EOL>if mosaic_tags:<EOL><INDENT>LOG.info(\"<STR_LIT>\"<EOL>.format(mosaic_tags, variant['<STR_LIT>']))<EOL>action = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>LOG.info(\"<STR_LIT>\"<EOL>.format(variant['<STR_LIT>'], variant['<STR_LIT>']))<EOL>action = '<STR_LIT>'<EOL><DEDENT>updated_variant = self.variant_collection.find_one_and_update(<EOL>{'<STR_LIT>': variant['<STR_LIT>']},<EOL>{action: {'<STR_LIT>': mosaic_tags}},<EOL>return_document=pymongo.ReturnDocument.AFTER<EOL>)<EOL>LOG.debug(\"<STR_LIT>\")<EOL>return updated_variant<EOL>", "docstring": "Create an event for updating the mosaicism tags for a variant\n\n          This function will create a event and update the mosaicism tags of the variant.\n\n        Arguments:\n            institute (dict): A Institute object\n            case (dict): Case object\n            user (dict): A User object\n            link (str): The url to be used in the event\n            variant (dict): A variant object\n            mosaic_tags (list): The new mosaic tags list\n\n        Return:\n            updated_variant", "id": "f13796:c0:m10"}
{"signature": "def unpin_variant(self, institute, case, user, link, variant):", "body": "LOG.info(\"<STR_LIT>\".format(<EOL>variant['<STR_LIT>']))<EOL>LOG.info(\"<STR_LIT>\"\"<STR_LIT>\")<EOL>updated_case = self.case_collection.find_one_and_update(<EOL>{'<STR_LIT>': case['<STR_LIT>']},<EOL>{'<STR_LIT>': {'<STR_LIT>': variant['<STR_LIT>']}},<EOL>return_document=pymongo.ReturnDocument.AFTER<EOL>)<EOL>self.create_event(<EOL>institute=institute,<EOL>case=case,<EOL>user=user,<EOL>link=link,<EOL>category='<STR_LIT>',<EOL>verb='<STR_LIT>',<EOL>variant=variant,<EOL>subject=variant['<STR_LIT>'],<EOL>)<EOL>return updated_case<EOL>", "docstring": "Create an event for unpinning a variant.\n\n        Arguments:\n            institute (dict): A Institute object\n            case (dict): Case object\n            user (dict): A User object\n            link (str): The url to be used in the event\n            variant (dict): A variant object\n\n        Returns:\n            updated_case(dict)", "id": "f13796:c0:m1"}
{"signature": "def hgncsymbol_to_gene(self, build='<STR_LIT>', genes=None):", "body": "hgnc_dict = {}<EOL>LOG.info(\"<STR_LIT>\")<EOL>if not genes:<EOL><INDENT>genes = self.hgnc_collection.find({'<STR_LIT>':build})<EOL><DEDENT>for gene_obj in genes:<EOL><INDENT>hgnc_dict[gene_obj['<STR_LIT>']] = gene_obj<EOL><DEDENT>LOG.info(\"<STR_LIT>\")<EOL>return hgnc_dict<EOL>", "docstring": "Return a dictionary with hgnc_symbol as key and gene_obj as value\n\n        The result will have ONE entry for each gene in the database.\n        (For a specific build)\n\n        Args:\n            build(str)\n            genes(iterable(scout.models.HgncGene)):\n\n        Returns:\n            hgnc_dict(dict): {<hgnc_symbol(str)>: <gene(dict)>}", "id": "f13798:c0:m16"}
{"signature": "def get_coding_intervals(self, build='<STR_LIT>', genes=None):", "body": "intervals = {}<EOL>if not genes:<EOL><INDENT>genes = self.all_genes(build=build)<EOL><DEDENT>LOG.info(\"<STR_LIT>\")<EOL>for i,hgnc_obj in enumerate(genes):<EOL><INDENT>chrom = hgnc_obj['<STR_LIT>']<EOL>start = max((hgnc_obj['<STR_LIT:start>'] - <NUM_LIT>), <NUM_LIT:1>)<EOL>end = hgnc_obj['<STR_LIT:end>'] + <NUM_LIT><EOL>if chrom not in intervals:<EOL><INDENT>intervals[chrom] = intervaltree.IntervalTree()<EOL>intervals[chrom].addi(start, end, i)<EOL>continue<EOL><DEDENT>res = intervals[chrom].search(start, end)<EOL>if not res:<EOL><INDENT>intervals[chrom].addi(start, end, i)<EOL>continue<EOL><DEDENT>for interval in res:<EOL><INDENT>if interval.begin < start:<EOL><INDENT>start = interval.begin<EOL><DEDENT>if interval.end > end:<EOL><INDENT>end = interval.end<EOL><DEDENT>intervals[chrom].remove(interval)<EOL><DEDENT>intervals[chrom].addi(start, end, i)<EOL><DEDENT>return intervals<EOL>", "docstring": "Return a dictionary with chromosomes as keys and interval trees as values\n\n        Each interval represents a coding region of overlapping genes.\n\n        Args:\n            build(str): The genome build\n            genes(iterable(scout.models.HgncGene)):\n\n        Returns:\n            intervals(dict): A dictionary with chromosomes as keys and overlapping genomic intervals as values", "id": "f13798:c0:m26"}
{"signature": "def load_transcript_bulk(self, transcript_objs):", "body": "LOG.info(\"<STR_LIT>\")<EOL>try:<EOL><INDENT>result = self.transcript_collection.insert_many(transcript_objs)<EOL><DEDENT>except (DuplicateKeyError, BulkWriteError) as err:<EOL><INDENT>raise IntegrityError(err)<EOL><DEDENT>return result<EOL>", "docstring": "Load a bulk of transcript objects to the database\n\n        Arguments:\n            transcript_objs(iterable(scout.models.hgnc_transcript))", "id": "f13798:c0:m3"}
{"signature": "def id_transcripts_by_gene(self, build='<STR_LIT>'):", "body": "hgnc_id_transcripts = {}<EOL>LOG.info(\"<STR_LIT>\")<EOL>for gene_obj in self.hgnc_collection.find({'<STR_LIT>': build}):<EOL><INDENT>hgnc_id = gene_obj['<STR_LIT>']<EOL>id_transcripts = self.get_id_transcripts(hgnc_id=hgnc_id, build=build)<EOL>hgnc_id_transcripts[hgnc_id] = id_transcripts<EOL><DEDENT>return hgnc_id_transcripts<EOL>", "docstring": "Return a dictionary with hgnc_id as keys and a set of id transcripts as value\n\n        Args:\n            build(str)\n\n        Returns:\n            hgnc_id_transcripts(dict)", "id": "f13798:c0:m21"}
{"signature": "def hgncid_to_gene(self, build='<STR_LIT>', genes=None):", "body": "hgnc_dict = {}<EOL>LOG.info(\"<STR_LIT>\")<EOL>if not genes:<EOL><INDENT>genes = self.hgnc_collection.find({'<STR_LIT>':build})<EOL><DEDENT>for gene_obj in genes:<EOL><INDENT>hgnc_dict[gene_obj['<STR_LIT>']] = gene_obj<EOL><DEDENT>return hgnc_dict<EOL>", "docstring": "Return a dictionary with hgnc_id as key and gene_obj as value\n\n        The result will have ONE entry for each gene in the database.\n        (For a specific build)\n\n        Args:\n            build(str):\n            genes(iterable(scout.models.HgncGene)):\n\n        Returns:\n            hgnc_dict(dict): {<hgnc_id(int)>: <gene(dict)>}", "id": "f13798:c0:m15"}
{"signature": "def transcripts(self, build='<STR_LIT>', hgnc_id=None):", "body": "query = {'<STR_LIT>': build}<EOL>if hgnc_id:<EOL><INDENT>query['<STR_LIT>'] = hgnc_id<EOL><DEDENT>return self.transcript_collection.find(query)<EOL>", "docstring": "Return all transcripts.\n\n            If a gene is specified return all transcripts for the gene\n\n        Args:\n            build(str)\n            hgnc_id(int)\n\n        Returns:\n            iterable(transcript)", "id": "f13798:c0:m23"}
{"signature": "def hgnc_gene(self, hgnc_identifier, build='<STR_LIT>'):", "body": "if not build in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>build = '<STR_LIT>'<EOL><DEDENT>query = {}<EOL>try:<EOL><INDENT>hgnc_identifier = int(hgnc_identifier)<EOL>query['<STR_LIT>'] = hgnc_identifier<EOL><DEDENT>except ValueError:<EOL><INDENT>query['<STR_LIT>'] = hgnc_identifier<EOL><DEDENT>query['<STR_LIT>'] = build<EOL>LOG.debug(\"<STR_LIT>\" % hgnc_identifier)<EOL>gene_obj = self.hgnc_collection.find_one(query)<EOL>if not gene_obj:<EOL><INDENT>return None<EOL><DEDENT>transcripts = []<EOL>tx_objs = self.transcripts(build=build, hgnc_id=gene_obj['<STR_LIT>'])<EOL>if tx_objs.count() > <NUM_LIT:0>:<EOL><INDENT>for tx in tx_objs:<EOL><INDENT>transcripts.append(tx)<EOL><DEDENT><DEDENT>gene_obj['<STR_LIT>'] = transcripts<EOL>return gene_obj<EOL>", "docstring": "Fetch a hgnc gene\n\n            Args:\n                hgnc_identifier(int)\n\n            Returns:\n                gene_obj(HgncGene)", "id": "f13798:c0:m6"}
{"signature": "def get_id_transcripts(self, hgnc_id, build='<STR_LIT>'):", "body": "transcripts = self.transcripts(build=build, hgnc_id=hgnc_id)<EOL>identifier_transcripts = set()<EOL>longest = None<EOL>nr = []<EOL>xm = []<EOL>for tx in transcripts:<EOL><INDENT>enst_id = tx['<STR_LIT>']<EOL>if not longest:<EOL><INDENT>longest = enst_id<EOL><DEDENT>refseq_id = tx.get('<STR_LIT>')<EOL>if not refseq_id:<EOL><INDENT>continue<EOL><DEDENT>if '<STR_LIT>' in refseq_id:<EOL><INDENT>identifier_transcripts.add(enst_id)<EOL><DEDENT>elif '<STR_LIT>' in refseq_id:<EOL><INDENT>nr.append(enst_id)<EOL><DEDENT>elif '<STR_LIT>' in refseq_id:<EOL><INDENT>xm.append(enst_id)<EOL><DEDENT><DEDENT>if identifier_transcripts:<EOL><INDENT>return identifier_transcripts<EOL><DEDENT>if nr:<EOL><INDENT>return set([nr[<NUM_LIT:0>]])<EOL><DEDENT>if xm:<EOL><INDENT>return set([xm[<NUM_LIT:0>]])<EOL><DEDENT>return set([longest])<EOL>", "docstring": "Return a set with identifier transcript(s)\n\n        Choose all refseq transcripts with NM symbols, if none where found choose ONE with NR,\n        if no NR choose ONE with XM. If there are no RefSeq transcripts identifiers choose the \n        longest ensembl transcript.\n\n        Args:\n            hgnc_id(int)\n            build(str)\n\n        Returns:\n            identifier_transcripts(set)", "id": "f13798:c0:m19"}
{"signature": "def hgnc_id(self, hgnc_symbol, build='<STR_LIT>'):", "body": "<EOL>query = {'<STR_LIT>':hgnc_symbol, '<STR_LIT>':build}<EOL>projection = {'<STR_LIT>':<NUM_LIT:1>, '<STR_LIT>':<NUM_LIT:0>}<EOL>res = self.hgnc_collection.find(query, projection)<EOL>if res.count() > <NUM_LIT:0>:<EOL><INDENT>return res[<NUM_LIT:0>]['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Query the genes with a hgnc symbol and return the hgnc id\n\n        Args:\n            hgnc_symbol(str)\n            build(str)\n\n        Returns:\n            hgnc_id(int)", "id": "f13798:c0:m7"}
{"signature": "def load_hgnc_transcript(self, transcript_obj):", "body": "res = self.transcript_collection.insert_one(transcript_obj)<EOL>return res<EOL>", "docstring": "Add a transcript object to the database\n\n        Arguments:\n            transcript_obj(dict)", "id": "f13798:c0:m2"}
{"signature": "def disease_terms(self, hgnc_id=None):", "body": "query = {}<EOL>if hgnc_id:<EOL><INDENT>LOG.debug(\"<STR_LIT>\", hgnc_id)<EOL>query['<STR_LIT>'] = hgnc_id<EOL><DEDENT>else:<EOL><INDENT>LOG.info(\"<STR_LIT>\")<EOL><DEDENT>return list(self.disease_term_collection.find(query))<EOL>", "docstring": "Return all disease terms that overlaps a gene\n\n            If no gene, return all disease terms\n\n        Args:\n            hgnc_id(int)\n\n        Returns:\n            iterable(dict): A list with all disease terms that match", "id": "f13799:c0:m5"}
{"signature": "def get_connection(host='<STR_LIT:localhost>', port=<NUM_LIT>, username=None, password=None,<EOL>uri=None, mongodb=None, authdb=None, timeout=<NUM_LIT:20>, *args, **kwargs):", "body": "authdb = authdb or mongodb<EOL>if uri is None:<EOL><INDENT>if username and password:<EOL><INDENT>uri = (\"<STR_LIT>\"<EOL>.format(quote_plus(username), quote_plus(password), host, port, authdb))<EOL>log_uri = (\"<STR_LIT>\"<EOL>.format(quote_plus(username), host, port, authdb))<EOL><DEDENT>else:<EOL><INDENT>log_uri = uri = \"<STR_LIT>\" % (host, port)<EOL><DEDENT><DEDENT>LOG.info(\"<STR_LIT>\" % log_uri)<EOL>try:<EOL><INDENT>client = MongoClient(uri, serverSelectionTimeoutMS=timeout)<EOL><DEDENT>except ServerSelectionTimeoutError as err:<EOL><INDENT>LOG.warning(\"<STR_LIT>\")<EOL>raise ConnectionFailure<EOL><DEDENT>LOG.info(\"<STR_LIT>\")<EOL>return client<EOL>", "docstring": "Get a client to the mongo database\n\n        host(str): Host of database\n        port(int): Port of database\n        username(str)\n        password(str)\n        uri(str)\n        authdb (str): database to use for authentication\n        timeout(int): How long should the client try to connect", "id": "f13800:m0"}
{"signature": "def check_connection(host='<STR_LIT:localhost>', port=<NUM_LIT>, username=None, password=None,<EOL>authdb=None, max_delay=<NUM_LIT:1>):", "body": "<EOL>if username and password:<EOL><INDENT>uri = (\"<STR_LIT>\"<EOL>.format(quote_plus(username), quote_plus(password), host, port, authdb))<EOL>log_uri = (\"<STR_LIT>\"<EOL>.format(quote_plus(username), host, port, authdb))<EOL><DEDENT>else:<EOL><INDENT>log_uri = uri = \"<STR_LIT>\" % (host, port)<EOL><DEDENT>LOG.info(\"<STR_LIT>\", log_uri)<EOL>client = MongoClient(uri, serverSelectionTimeoutMS=max_delay)<EOL>try:<EOL><INDENT>client.server_info()<EOL><DEDENT>except (ServerSelectionTimeoutError,OperationFailure) as err:<EOL><INDENT>LOG.warning(err)<EOL>return False<EOL><DEDENT>return True<EOL>", "docstring": "Check if a connection could be made to the mongo process specified\n\n    Args:\n        host(str)\n        port(int)\n        username(str)\n        password(str)\n        authdb (str): database to to for authentication\n        max_delay(int): Number of milliseconds to wait for connection\n\n    Returns:\n        bool: If connection could be established", "id": "f13802:m0"}
{"signature": "def load_case(adapter, case_obj, update=False):", "body": "logger.info('<STR_LIT>'.format(case_obj['<STR_LIT>']))<EOL>existing_case = adapter.case(case_obj['<STR_LIT>'])<EOL>if existing_case:<EOL><INDENT>if update:<EOL><INDENT>adapter.update_case(case_obj)<EOL><DEDENT>else:<EOL><INDENT>raise IntegrityError(\"<STR_LIT>\".format(case_obj['<STR_LIT>']))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>adapter.add_case(case_obj)<EOL><DEDENT>return case_obj<EOL>", "docstring": "Load a case into the database\n\n    If the case already exists the function will exit.\n    If the user want to load a case that is already in the database\n    'update' has to be 'True'\n\n    Args:\n        adapter (MongoAdapter): connection to the database\n        case_obj (dict): case object to persist to the database\n        update(bool): If existing case should be updated\n\n    Returns:\n        case_obj(dict): A dictionary with the builded case", "id": "f13804:m0"}
{"signature": "def load_panel_app(adapter, panel_id=None, institute='<STR_LIT>'):", "body": "base_url = '<STR_LIT>'<EOL>hgnc_map = adapter.genes_by_alias()<EOL>if panel_id:<EOL><INDENT>panel_ids = [panel_id]<EOL><DEDENT>if not panel_id:<EOL><INDENT>LOG.info(\"<STR_LIT>\")<EOL>data = get_request(base_url.format('<STR_LIT>'))<EOL>json_lines = json.loads(data)<EOL>panel_ids = [panel_info['<STR_LIT>'] for panel_info in json_lines['<STR_LIT:result>']]<EOL><DEDENT>for panel_id in panel_ids:<EOL><INDENT>panel_data = get_request(base_url.format('<STR_LIT>') + panel_id)<EOL>parsed_panel = parse_panel_app_panel(<EOL>panel_info = json.loads(panel_data)['<STR_LIT:result>'], <EOL>hgnc_map=hgnc_map,<EOL>institute=institute<EOL>)<EOL>parsed_panel['<STR_LIT>'] = panel_id<EOL>if len(parsed_panel['<STR_LIT>']) == <NUM_LIT:0>:<EOL><INDENT>LOG.warning(\"<STR_LIT>\".format(parsed_panel['<STR_LIT>']))<EOL>continue<EOL><DEDENT>try:<EOL><INDENT>adapter.load_panel(parsed_panel=parsed_panel)<EOL><DEDENT>except Exception as err:<EOL><INDENT>raise err<EOL><DEDENT><DEDENT>", "docstring": "Load PanelApp panels into scout database\n\n    If no panel_id load all PanelApp panels \n\n    Args:\n        adapter(scout.adapter.MongoAdapter)\n        panel_id(str): The panel app panel id", "id": "f13807:m1"}
{"signature": "def load_panel(panel_path, adapter, date=None, display_name=None, version=None, panel_type=None, <EOL>panel_id=None, institute=None):", "body": "panel_lines = get_file_handle(panel_path)<EOL>try:<EOL><INDENT>panel_info = get_panel_info(<EOL>panel_lines=panel_lines,<EOL>panel_id=panel_id,<EOL>institute=institute,<EOL>version=version,<EOL>date=date,<EOL>display_name=display_name<EOL>)<EOL><DEDENT>except Exception as err:<EOL><INDENT>raise err<EOL><DEDENT>version = None<EOL>if panel_info.get('<STR_LIT:version>'):<EOL><INDENT>version = float(panel_info['<STR_LIT:version>'])<EOL><DEDENT>panel_id = panel_info['<STR_LIT>']<EOL>display_name = panel_info['<STR_LIT>'] or panel_id<EOL>institute = panel_info['<STR_LIT>']<EOL>date = panel_info['<STR_LIT:date>']<EOL>if not institute:<EOL><INDENT>raise SyntaxError(\"<STR_LIT>\")<EOL><DEDENT>if not adapter.institute(institute):<EOL><INDENT>raise SyntaxError(\"<STR_LIT>\".format(institute))<EOL><DEDENT>if not panel_id:<EOL><INDENT>raise SyntaxError(\"<STR_LIT>\")<EOL><DEDENT>if version:<EOL><INDENT>existing_panel = adapter.gene_panel(panel_id, version)<EOL><DEDENT>else:<EOL><INDENT>existing_panel = adapter.gene_panel(panel_id)<EOL>version = <NUM_LIT:1.0><EOL>LOG.info(\"<STR_LIT>\", version)<EOL><DEDENT>if existing_panel:<EOL><INDENT>LOG.info(\"<STR_LIT>\")<EOL>if version == existing_panel['<STR_LIT:version>']:<EOL><INDENT>LOG.warning(\"<STR_LIT>\")<EOL>LOG.info(\"<STR_LIT>\")<EOL>raise SyntaxError()<EOL><DEDENT>display_name = display_name or existing_panel['<STR_LIT>']<EOL>institute = institute or existing_panel['<STR_LIT>']<EOL><DEDENT>parsed_panel = parse_gene_panel(<EOL>path=panel_path,<EOL>institute=institute,<EOL>panel_type=panel_type,<EOL>date=date,<EOL>version=version,<EOL>panel_id=panel_id,<EOL>display_name=display_name,<EOL>)<EOL>try:<EOL><INDENT>adapter.load_panel(parsed_panel=parsed_panel)<EOL><DEDENT>except Exception as err:<EOL><INDENT>raise err<EOL><DEDENT>", "docstring": "Load a manually curated gene panel into scout\n\n    Args:\n        panel_path(str): path to gene panel file\n        adapter(scout.adapter.MongoAdapter)\n        date(str): date of gene panel on format 2017-12-24\n        display_name(str)\n        version(float)\n        panel_type(str)\n        panel_id(str)\n        institute(str)", "id": "f13807:m0"}
{"signature": "def setup_scout(adapter, institute_id='<STR_LIT>', user_name='<STR_LIT>',<EOL>user_mail='<STR_LIT>', api_key=None, demo=False):", "body": "<EOL>LOG.info(\"<STR_LIT>\")<EOL>for collection_name in adapter.db.collection_names():<EOL><INDENT>if not collection_name.startswith('<STR_LIT>'):<EOL><INDENT>LOG.info(\"<STR_LIT>\", collection_name)<EOL>adapter.db.drop_collection(collection_name)<EOL><DEDENT><DEDENT>LOG.info(\"<STR_LIT>\")<EOL>institute_obj = build_institute(<EOL>internal_id=institute_id,<EOL>display_name=institute_id,<EOL>sanger_recipients=[user_mail]<EOL>)<EOL>adapter.add_institute(institute_obj)<EOL>user_obj = dict(<EOL>_id=user_mail,<EOL>email=user_mail,<EOL>name=user_name,<EOL>roles=['<STR_LIT>'],<EOL>institutes=[institute_id]<EOL>)<EOL>adapter.add_user(user_obj)<EOL>if not demo:<EOL><INDENT>try:<EOL><INDENT>mim_files = fetch_mim_files(api_key, mim2genes=True, morbidmap=True, genemap2=True)<EOL><DEDENT>except Exception as err:<EOL><INDENT>LOG.warning(err)<EOL>raise err<EOL><DEDENT>mim2gene_lines = mim_files['<STR_LIT>']<EOL>genemap_lines = mim_files['<STR_LIT>']<EOL>hpo_gene_lines = fetch_hpo_genes()<EOL>hgnc_lines = fetch_hgnc()<EOL>exac_lines = fetch_exac_constraint()<EOL><DEDENT>else:<EOL><INDENT>mim2gene_lines = [line for line in get_file_handle(mim2gene_reduced_path)]<EOL>genemap_lines = [line for line in get_file_handle(genemap2_reduced_path)]<EOL>hpo_gene_lines = [line for line in get_file_handle(hpogenes_reduced_path)]<EOL>hgnc_lines = [line for line in get_file_handle(hgnc_reduced_path)]<EOL>exac_lines = [line for line in get_file_handle(exac_reduced_path)]<EOL><DEDENT>builds = ['<STR_LIT>', '<STR_LIT>']<EOL>for build in builds:<EOL><INDENT>if not demo:<EOL><INDENT>ensembl_genes = fetch_ensembl_genes(build=build)<EOL><DEDENT>else:<EOL><INDENT>ensembl_genes = get_file_handle(genes37_reduced_path)<EOL><DEDENT>hgnc_genes = load_hgnc_genes(<EOL>adapter=adapter,<EOL>ensembl_lines=ensembl_genes,<EOL>hgnc_lines=hgnc_lines,<EOL>exac_lines=exac_lines,<EOL>mim2gene_lines=mim2gene_lines,<EOL>genemap_lines=genemap_lines,<EOL>hpo_lines=hpo_gene_lines,<EOL>build=build,<EOL>)<EOL>ensembl_genes = {}<EOL>for gene_obj in hgnc_genes:<EOL><INDENT>ensembl_id = gene_obj['<STR_LIT>']<EOL>ensembl_genes[ensembl_id] = gene_obj<EOL><DEDENT>if not demo:<EOL><INDENT>ensembl_transcripts = fetch_ensembl_transcripts(build=build)<EOL><DEDENT>else:<EOL><INDENT>ensembl_transcripts = get_file_handle(transcripts37_reduced_path)<EOL><DEDENT>transcripts = load_transcripts(adapter, ensembl_transcripts, build, ensembl_genes)<EOL><DEDENT>hpo_terms_handle = None<EOL>hpo_to_genes_handle = None<EOL>hpo_disease_handle = None<EOL>if demo:<EOL><INDENT>hpo_terms_handle = get_file_handle(hpoterms_reduced_path)<EOL>hpo_to_genes_handle = get_file_handle(hpo_to_genes_reduced_path)<EOL>hpo_disease_handle = get_file_handle(hpo_phenotype_to_terms_reduced_path)<EOL><DEDENT>load_hpo(<EOL>adapter=adapter,<EOL>hpo_lines=hpo_terms_handle,<EOL>hpo_gene_lines=hpo_to_genes_handle,<EOL>disease_lines=genemap_lines,<EOL>hpo_disease_lines=hpo_disease_handle<EOL>)<EOL>if demo:<EOL><INDENT>parsed_panel = parse_gene_panel(<EOL>path=panel_path,<EOL>institute='<STR_LIT>',<EOL>panel_id='<STR_LIT>',<EOL>version=<NUM_LIT:1.0>,<EOL>display_name='<STR_LIT>'<EOL>)<EOL>adapter.load_panel(parsed_panel)<EOL>case_handle = get_file_handle(load_path)<EOL>case_data = yaml.load(case_handle)<EOL>adapter.load_case(case_data)<EOL><DEDENT>LOG.info(\"<STR_LIT>\")<EOL>adapter.load_indexes()<EOL>LOG.info(\"<STR_LIT>\")<EOL>", "docstring": "docstring for setup_scout", "id": "f13812:m0"}
{"signature": "def update_panel(adapter, panel_name, panel_version, new_version=None, new_date=None):", "body": "panel_obj = adapter.gene_panel(panel_name, panel_version)<EOL>if not panel_obj:<EOL><INDENT>raise IntegrityError(\"<STR_LIT>\" % (panel_name, panel_version))<EOL><DEDENT>updated_panel = adapter.update_panel(panel_obj, new_version, new_date)<EOL>panel_id = updated_panel['<STR_LIT>']<EOL>update = {'<STR_LIT>': {}}<EOL>if new_version:<EOL><INDENT>update['<STR_LIT>']['<STR_LIT>'] = updated_panel['<STR_LIT:version>']<EOL><DEDENT>if new_date:<EOL><INDENT>update['<STR_LIT>']['<STR_LIT>'] = updated_panel['<STR_LIT:date>']<EOL><DEDENT>LOG.info('<STR_LIT>'.format(update))<EOL>query = {'<STR_LIT>': { '<STR_LIT>': {'<STR_LIT>': panel_name}}}<EOL>adapter.case_collection.update_many(query, update)<EOL>return updated_panel<EOL>", "docstring": "Update a gene panel in the database\n\n    We need to update the actual gene panel and then all cases that refers to the panel.\n\n    Args:\n        adapter(scout.adapter.MongoAdapter)\n        panel_name(str): Unique name for a gene panel\n        panel_version(float)\n        new_version(float)\n        new_date(datetime.datetime)\n\n    Returns:\n        updated_panel(scout.models.GenePanel): The updated gene panel object", "id": "f13821:m0"}
{"signature": "def parse_ensembl_line(line, header):", "body": "line = line.rstrip().split('<STR_LIT:\\t>')<EOL>header = [head.lower() for head in header]<EOL>raw_info = dict(zip(header, line))<EOL>ensembl_info = {}<EOL>for word in raw_info:<EOL><INDENT>value = raw_info[word]<EOL>if not value:<EOL><INDENT>continue<EOL><DEDENT>if '<STR_LIT>' in word:<EOL><INDENT>ensembl_info['<STR_LIT>'] = value<EOL><DEDENT>if '<STR_LIT>' in word:<EOL><INDENT>if '<STR_LIT:id>' in word:<EOL><INDENT>ensembl_info['<STR_LIT>'] = value<EOL><DEDENT>elif '<STR_LIT:start>' in word:<EOL><INDENT>ensembl_info['<STR_LIT>'] = int(value)<EOL><DEDENT>elif '<STR_LIT:end>' in word:<EOL><INDENT>ensembl_info['<STR_LIT>'] = int(value)<EOL><DEDENT><DEDENT>if '<STR_LIT>' in word:<EOL><INDENT>ensembl_info['<STR_LIT>'] = value<EOL><DEDENT>if \"<STR_LIT>\" in word:<EOL><INDENT>ensembl_info['<STR_LIT>'] = value<EOL><DEDENT>if '<STR_LIT>' in word:<EOL><INDENT>ensembl_info['<STR_LIT>'] = int(value.split('<STR_LIT::>')[-<NUM_LIT:1>])<EOL><DEDENT>if '<STR_LIT>' in word:<EOL><INDENT>if '<STR_LIT:id>' in word:<EOL><INDENT>ensembl_info['<STR_LIT>'] = value<EOL><DEDENT>elif '<STR_LIT:start>' in word:<EOL><INDENT>ensembl_info['<STR_LIT>'] = int(value)<EOL><DEDENT>elif '<STR_LIT:end>' in word:<EOL><INDENT>ensembl_info['<STR_LIT>'] = int(value)<EOL><DEDENT><DEDENT>if '<STR_LIT>' in word:<EOL><INDENT>if '<STR_LIT:start>' in word:<EOL><INDENT>ensembl_info['<STR_LIT>'] = int(value)<EOL><DEDENT>elif '<STR_LIT:end>' in word:<EOL><INDENT>ensembl_info['<STR_LIT>'] = int(value)<EOL><DEDENT>elif '<STR_LIT>' in word:<EOL><INDENT>ensembl_info['<STR_LIT>'] = int(value)<EOL><DEDENT><DEDENT>if '<STR_LIT>' in word:<EOL><INDENT>if '<STR_LIT:start>' in word:<EOL><INDENT>if '<STR_LIT:5>' in word:<EOL><INDENT>ensembl_info['<STR_LIT>'] = int(value)<EOL><DEDENT>elif '<STR_LIT:3>' in word:<EOL><INDENT>ensembl_info['<STR_LIT>'] = int(value)<EOL><DEDENT><DEDENT>elif '<STR_LIT:end>' in word:<EOL><INDENT>if '<STR_LIT:5>' in word:<EOL><INDENT>ensembl_info['<STR_LIT>'] = int(value)<EOL><DEDENT>elif '<STR_LIT:3>' in word:<EOL><INDENT>ensembl_info['<STR_LIT>'] = int(value)<EOL><DEDENT><DEDENT><DEDENT>if '<STR_LIT>' in word:<EOL><INDENT>ensembl_info['<STR_LIT>'] = int(value)<EOL><DEDENT>if '<STR_LIT>' in word:<EOL><INDENT>if '<STR_LIT>' in word:<EOL><INDENT>if '<STR_LIT>' in word:<EOL><INDENT>ensembl_info['<STR_LIT>'] = value<EOL><DEDENT>else:<EOL><INDENT>ensembl_info['<STR_LIT>'] = value<EOL><DEDENT><DEDENT>if '<STR_LIT>' in word:<EOL><INDENT>ensembl_info['<STR_LIT>'] = value<EOL><DEDENT><DEDENT><DEDENT>return ensembl_info<EOL>", "docstring": "Parse an ensembl formated line\n\n        Args:\n            line(list): A list with ensembl gene info\n            header(list): A list with the header info\n\n        Returns:\n            ensembl_info(dict): A dictionary with the relevant info", "id": "f13823:m3"}
{"signature": "def parse_callers(variant, category='<STR_LIT>'):", "body": "relevant_callers = CALLERS[category]<EOL>callers = {caller['<STR_LIT:id>']: None for caller in relevant_callers}<EOL>raw_info = variant.INFO.get('<STR_LIT>')<EOL>if raw_info:<EOL><INDENT>info = raw_info.split('<STR_LIT:->')<EOL>for call in info:<EOL><INDENT>if call == '<STR_LIT>':<EOL><INDENT>for caller in callers:<EOL><INDENT>callers[caller] = '<STR_LIT>'<EOL><DEDENT><DEDENT>elif call == '<STR_LIT>':<EOL><INDENT>for caller in callers:<EOL><INDENT>callers[caller] = '<STR_LIT>'<EOL><DEDENT><DEDENT>elif '<STR_LIT>' in call:<EOL><INDENT>for caller in callers:<EOL><INDENT>if caller in call:<EOL><INDENT>callers[caller] = '<STR_LIT>'<EOL><DEDENT><DEDENT><DEDENT>elif call in set(callers.keys()):<EOL><INDENT>callers[call] = '<STR_LIT>'<EOL><DEDENT><DEDENT><DEDENT>other_info = variant.INFO.get('<STR_LIT>')<EOL>if other_info:<EOL><INDENT>for info in other_info.split('<STR_LIT:U+002C>'):<EOL><INDENT>called_by = info.split('<STR_LIT:|>')[<NUM_LIT:0>]<EOL>callers[called_by] = '<STR_LIT>'<EOL><DEDENT><DEDENT>return callers<EOL>", "docstring": "Parse how the different variant callers have performed\n\n        Args:\n            variant (cyvcf2.Variant): A variant object\n\n        Returns:\n            callers (dict): A dictionary on the format\n            {'gatk': <filter>,'freebayes': <filter>,'samtools': <filter>}", "id": "f13825:m0"}
{"signature": "def parse_display_name(chrom, pos, ref, alt, variant_type):", "body": "return '<STR_LIT:_>'.join([chrom, pos, ref, alt, variant_type])<EOL>", "docstring": "Parse the variant id for a variant\n\n    This is used to display the variant in scout.\n\n    Args:\n        chrom(str)\n        pos(str)\n        ref(str)\n        alt(str)\n        variant_type(str): 'clinical' or 'research'\n\n    Returns:\n        variant_id(str): The variant id in human readable format", "id": "f13826:m3"}
{"signature": "def parse_simple_id(chrom, pos, ref, alt):", "body": "return '<STR_LIT:_>'.join([chrom, pos, ref, alt])<EOL>", "docstring": "Parse the simple id for a variant\n\n    Simple id is used as a human readable reference for a position, it is\n    in no way unique.\n\n    Args:\n        chrom(str)\n        pos(str)\n        ref(str)\n        alt(str)\n\n    Returns:\n        simple_id(str): The simple human readable variant id", "id": "f13826:m1"}
{"signature": "def parse_document_id(chrom, pos, ref, alt, variant_type, case_id):", "body": "return generate_md5_key([chrom, pos, ref, alt, variant_type, case_id])<EOL>", "docstring": "Parse the unique document id for a variant.\n\n    This will always be unique in the database.\n\n    Args:\n        chrom(str)\n        pos(str)\n        ref(str)\n        alt(str)\n        variant_type(str): 'clinical' or 'research'\n        case_id(str): unqiue family id\n\n    Returns:\n        document_id(str): The unique document id in an md5 string", "id": "f13826:m4"}
{"signature": "def get_sub_category(alt_len, ref_len, category, svtype=None):", "body": "subcategory = '<STR_LIT>'<EOL>if category in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>if ref_len == alt_len:<EOL><INDENT>subcategory = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>subcategory = '<STR_LIT>'<EOL><DEDENT><DEDENT>elif category == '<STR_LIT>':<EOL><INDENT>subcategory = svtype<EOL><DEDENT>return subcategory<EOL>", "docstring": "Get the subcategory for a VCF variant\n\n    The sub categories are:\n        'snv', 'indel', 'del', 'ins', 'dup', 'bnd', 'inv'\n\n    Args:\n        alt_len(int)\n        ref_len(int)\n        category(str)\n        svtype(str)\n\n    Returns:\n        subcategory(str)", "id": "f13827:m1"}
{"signature": "def parse_variant(variant, case, variant_type='<STR_LIT>',<EOL>rank_results_header=None, vep_header=None,<EOL>individual_positions=None, category=None):", "body": "<EOL>rank_results_header = rank_results_header or []<EOL>vep_header = vep_header or []<EOL>parsed_variant = {}<EOL>case_id = case['<STR_LIT>']<EOL>if '<STR_LIT:->' in case_id:<EOL><INDENT>logger.debug('<STR_LIT>')<EOL>genmod_key = case['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>genmod_key = case['<STR_LIT>']<EOL><DEDENT>chrom_match = CHR_PATTERN.match(variant.CHROM)<EOL>chrom = chrom_match.group(<NUM_LIT:2>)<EOL>if variant.ALT:<EOL><INDENT>alt=variant.ALT[<NUM_LIT:0>]<EOL><DEDENT>elif not variant.ALT and category == \"<STR_LIT:str>\":<EOL><INDENT>alt='<STR_LIT:.>'<EOL><DEDENT>parsed_variant['<STR_LIT>'] = parse_ids(<EOL>chrom=chrom,<EOL>pos=variant.POS,<EOL>ref=variant.REF,<EOL>alt=alt,<EOL>case_id=case_id,<EOL>variant_type=variant_type,<EOL>)<EOL>parsed_variant['<STR_LIT>'] = case_id<EOL>parsed_variant['<STR_LIT>'] = variant_type<EOL>if not category:<EOL><INDENT>category = variant.var_type<EOL>if category == '<STR_LIT>':<EOL><INDENT>category = '<STR_LIT>'<EOL><DEDENT>if category == '<STR_LIT>':<EOL><INDENT>category = '<STR_LIT>'<EOL><DEDENT><DEDENT>parsed_variant['<STR_LIT>'] = category<EOL>parsed_variant['<STR_LIT>'] = variant.REF<EOL>if len(variant.ALT) > <NUM_LIT:1>:<EOL><INDENT>raise VcfError(\"<STR_LIT>\")<EOL><DEDENT>parsed_variant['<STR_LIT>'] = alt<EOL>parsed_variant['<STR_LIT>'] = variant.QUAL<EOL>if variant.FILTER:<EOL><INDENT>parsed_variant['<STR_LIT>'] = variant.FILTER.split('<STR_LIT:;>')<EOL><DEDENT>else:<EOL><INDENT>parsed_variant['<STR_LIT>'] = ['<STR_LIT>']<EOL><DEDENT>parsed_variant['<STR_LIT>'] = variant.ID<EOL>parsed_variant['<STR_LIT>'] = None<EOL>parsed_variant['<STR_LIT>'] = chrom<EOL>coordinates = parse_coordinates(variant, category)<EOL>parsed_variant['<STR_LIT>'] = coordinates['<STR_LIT>']<EOL>parsed_variant['<STR_LIT>'] = coordinates['<STR_LIT>']<EOL>parsed_variant['<STR_LIT>'] = coordinates['<STR_LIT>']<EOL>parsed_variant['<STR_LIT:end>'] = coordinates['<STR_LIT:end>']<EOL>parsed_variant['<STR_LIT>'] = coordinates['<STR_LIT>']<EOL>parsed_variant['<STR_LIT>'] = coordinates['<STR_LIT>']<EOL>parsed_variant['<STR_LIT>'] = coordinates['<STR_LIT>']<EOL>parsed_variant['<STR_LIT>'] = coordinates['<STR_LIT>']<EOL>rank_score = parse_rank_score(variant.INFO.get('<STR_LIT>', '<STR_LIT>'), genmod_key)<EOL>parsed_variant['<STR_LIT>'] = rank_score or <NUM_LIT:0><EOL>if individual_positions and case['<STR_LIT>']:<EOL><INDENT>parsed_variant['<STR_LIT>'] = parse_genotypes(variant, case['<STR_LIT>'],<EOL>individual_positions)<EOL><DEDENT>else:<EOL><INDENT>parsed_variant['<STR_LIT>'] = []<EOL><DEDENT>compounds = parse_compounds(compound_info=variant.INFO.get('<STR_LIT>'),<EOL>case_id=genmod_key,<EOL>variant_type=variant_type)<EOL>if compounds:<EOL><INDENT>parsed_variant['<STR_LIT>'] = compounds<EOL><DEDENT>genetic_models = parse_genetic_models(variant.INFO.get('<STR_LIT>'), genmod_key)<EOL>if genetic_models:<EOL><INDENT>parsed_variant['<STR_LIT>'] = genetic_models<EOL><DEDENT>azlength = variant.INFO.get('<STR_LIT>')<EOL>if azlength:<EOL><INDENT>parsed_variant['<STR_LIT>'] = int(azlength)<EOL><DEDENT>azqual = variant.INFO.get('<STR_LIT>')<EOL>if azqual:<EOL><INDENT>parsed_variant['<STR_LIT>'] = float(azqual)<EOL><DEDENT>repeat_id = variant.INFO.get('<STR_LIT>')<EOL>if repeat_id:<EOL><INDENT>parsed_variant['<STR_LIT>'] = str(repeat_id)<EOL><DEDENT>repeat_unit = variant.INFO.get('<STR_LIT>')<EOL>if repeat_unit:<EOL><INDENT>parsed_variant['<STR_LIT>'] = str(repeat_unit)<EOL><DEDENT>repeat_ref = variant.INFO.get('<STR_LIT>')<EOL>if repeat_ref:<EOL><INDENT>parsed_variant['<STR_LIT>'] = int(repeat_ref)<EOL><DEDENT>repeat_len = variant.INFO.get('<STR_LIT>')<EOL>if repeat_len:<EOL><INDENT>parsed_variant['<STR_LIT>'] = int(repeat_len)<EOL><DEDENT>str_status = variant.INFO.get('<STR_LIT>')<EOL>if str_status:<EOL><INDENT>parsed_variant['<STR_LIT>'] = str(str_status)<EOL><DEDENT>raw_transcripts = []<EOL>if vep_header:<EOL><INDENT>vep_info = variant.INFO.get('<STR_LIT>')<EOL>if vep_info:<EOL><INDENT>raw_transcripts = (dict(zip(vep_header, transcript_info.split('<STR_LIT:|>')))<EOL>for transcript_info in vep_info.split('<STR_LIT:U+002C>'))<EOL><DEDENT><DEDENT>parsed_transcripts = []<EOL>dbsnp_ids = set()<EOL>cosmic_ids = set()<EOL>for parsed_transcript in parse_transcripts(raw_transcripts, parsed_variant['<STR_LIT>']):<EOL><INDENT>parsed_transcripts.append(parsed_transcript)<EOL>for dbsnp in parsed_transcript.get('<STR_LIT>', []):<EOL><INDENT>dbsnp_ids.add(dbsnp)<EOL><DEDENT>for cosmic in parsed_transcript.get('<STR_LIT>', []):<EOL><INDENT>cosmic_ids.add(cosmic)<EOL><DEDENT><DEDENT>cosmic_tag = variant.INFO.get('<STR_LIT>')<EOL>if cosmic_tag:<EOL><INDENT>cosmic_ids.add(cosmic_tag[<NUM_LIT:4>:])<EOL><DEDENT>if (dbsnp_ids and not parsed_variant['<STR_LIT>']):<EOL><INDENT>parsed_variant['<STR_LIT>'] = '<STR_LIT:;>'.join(dbsnp_ids)<EOL><DEDENT>if cosmic_ids:<EOL><INDENT>parsed_variant['<STR_LIT>'] = list(cosmic_ids)<EOL><DEDENT>gene_info = parse_genes(parsed_transcripts)<EOL>parsed_variant['<STR_LIT>'] = gene_info<EOL>hgnc_ids = set([])<EOL>for gene in parsed_variant['<STR_LIT>']:<EOL><INDENT>hgnc_ids.add(gene['<STR_LIT>'])<EOL><DEDENT>parsed_variant['<STR_LIT>'] = list(hgnc_ids)<EOL>if variant.INFO.get('<STR_LIT>'):<EOL><INDENT>acc = variant.INFO.get('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>acc = variant.INFO.get('<STR_LIT>')<EOL><DEDENT>clnsig_predictions = parse_clnsig(<EOL>acc=acc,<EOL>sig=variant.INFO.get('<STR_LIT>'),<EOL>revstat=variant.INFO.get('<STR_LIT>'),<EOL>transcripts=parsed_transcripts<EOL>)<EOL>if clnsig_predictions:<EOL><INDENT>parsed_variant['<STR_LIT>'] = clnsig_predictions<EOL><DEDENT>frequencies = parse_frequencies(variant, parsed_transcripts)<EOL>parsed_variant['<STR_LIT>'] = frequencies<EOL>local_obs_old = variant.INFO.get('<STR_LIT>')<EOL>if local_obs_old:<EOL><INDENT>parsed_variant['<STR_LIT>'] = int(local_obs_old)<EOL><DEDENT>local_obs_hom_old = variant.INFO.get('<STR_LIT>')<EOL>if local_obs_hom_old:<EOL><INDENT>parsed_variant['<STR_LIT>'] = int(local_obs_hom_old)<EOL><DEDENT>cadd = parse_cadd(variant, parsed_transcripts)<EOL>if cadd:<EOL><INDENT>parsed_variant['<STR_LIT>'] = cadd<EOL><DEDENT>spidex = variant.INFO.get('<STR_LIT>')<EOL>if spidex:<EOL><INDENT>parsed_variant['<STR_LIT>'] = float(spidex)<EOL><DEDENT>parsed_variant['<STR_LIT>'] = parse_conservations(variant)<EOL>parsed_variant['<STR_LIT>'] = parse_callers(variant, category=category)<EOL>rank_result = variant.INFO.get('<STR_LIT>')<EOL>if rank_result:<EOL><INDENT>results = [int(i) for i in rank_result.split('<STR_LIT:|>')]<EOL>parsed_variant['<STR_LIT>'] = dict(zip(rank_results_header, results))<EOL><DEDENT>sv_frequencies = parse_sv_frequencies(variant)<EOL>for key in sv_frequencies:<EOL><INDENT>parsed_variant['<STR_LIT>'][key] = sv_frequencies[key]<EOL><DEDENT>mvl_tag = variant.INFO.get('<STR_LIT>')<EOL>if mvl_tag:<EOL><INDENT>parsed_variant['<STR_LIT>'] = True<EOL><DEDENT>return parsed_variant<EOL>", "docstring": "Return a parsed variant\n\n        Get all the necessary information to build a variant object\n\n    Args:\n        variant(cyvcf2.Variant)\n        case(dict)\n        variant_type(str): 'clinical' or 'research'\n        rank_results_header(list)\n        vep_header(list)\n        individual_positions(dict): Explain what position each individual has\n                                    in vcf\n        category(str): 'snv', 'sv', 'str' or 'cancer'\n\n    Returns:\n        parsed_variant(dict): Parsed variant", "id": "f13828:m0"}
{"signature": "def parse_compounds(compound_info, case_id, variant_type):", "body": "<EOL>compounds = []<EOL>if compound_info:<EOL><INDENT>for family_info in compound_info.split('<STR_LIT:U+002C>'):<EOL><INDENT>splitted_entry = family_info.split('<STR_LIT::>')<EOL>if splitted_entry[<NUM_LIT:0>] == case_id:<EOL><INDENT>for compound in splitted_entry[<NUM_LIT:1>].split('<STR_LIT:|>'):<EOL><INDENT>splitted_compound = compound.split('<STR_LIT:>>')<EOL>compound_obj = {}<EOL>compound_name = splitted_compound[<NUM_LIT:0>]<EOL>compound_obj['<STR_LIT>'] = generate_md5_key(compound_name.split('<STR_LIT:_>') +<EOL>[variant_type, case_id])<EOL>try:<EOL><INDENT>compound_score = float(splitted_compound[<NUM_LIT:1>])<EOL><DEDENT>except (TypeError, IndexError):<EOL><INDENT>compound_score = <NUM_LIT:0.0><EOL><DEDENT>compound_obj['<STR_LIT>'] = compound_score<EOL>compound_obj['<STR_LIT>'] = compound_name<EOL>compounds.append(compound_obj)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return compounds<EOL>", "docstring": "Get a list with compounds objects for this variant.\n\n        Arguments:\n            compound_info(str): A Variant dictionary\n            case_id (str): unique family id\n            variant_type(str): 'research' or 'clinical'\n\n        Returns:\n            compounds(list(dict)): A list of compounds", "id": "f13835:m0"}
{"signature": "def parse_genes(transcripts):", "body": "<EOL>genes_to_transcripts = {}<EOL>genes = []<EOL>hgvs_identifier = None<EOL>canonical_transcript = None<EOL>exon = None<EOL>for transcript in transcripts:<EOL><INDENT>hgnc_id = transcript['<STR_LIT>']<EOL>hgnc_symbol = transcript['<STR_LIT>']<EOL>if (transcript['<STR_LIT>'] and transcript.get('<STR_LIT>')):<EOL><INDENT>hgvs_identifier = transcript.get('<STR_LIT>')<EOL>canonical_transcript = transcript['<STR_LIT>']<EOL>exon = transcript['<STR_LIT>']<EOL><DEDENT>if hgnc_id:<EOL><INDENT>if hgnc_id in genes_to_transcripts:<EOL><INDENT>genes_to_transcripts[hgnc_id].append(transcript)<EOL><DEDENT>else:<EOL><INDENT>genes_to_transcripts[hgnc_id] = [transcript]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if hgnc_symbol:<EOL><INDENT>if hgnc_symbol in genes_to_transcripts:<EOL><INDENT>genes_to_transcripts[hgnc_symbol].append(transcript)<EOL><DEDENT>else:<EOL><INDENT>genes_to_transcripts[hgnc_symbol] = [transcript]<EOL><DEDENT><DEDENT><DEDENT><DEDENT>for gene_id in genes_to_transcripts:<EOL><INDENT>gene_transcripts = genes_to_transcripts[gene_id]<EOL>most_severe_consequence = None<EOL>most_severe_rank = float('<STR_LIT>')<EOL>most_severe_transcript = None<EOL>most_severe_region = None<EOL>most_severe_sift = None<EOL>most_severe_polyphen = None<EOL>for transcript in gene_transcripts:<EOL><INDENT>hgnc_id = transcript['<STR_LIT>']<EOL>hgnc_symbol = transcript['<STR_LIT>']<EOL>for consequence in transcript['<STR_LIT>']:<EOL><INDENT>new_rank = SO_TERMS[consequence]['<STR_LIT>']<EOL>if new_rank < most_severe_rank:<EOL><INDENT>most_severe_rank = new_rank<EOL>most_severe_consequence = consequence<EOL>most_severe_transcript = transcript<EOL>most_severe_sift = transcript['<STR_LIT>']<EOL>most_severe_polyphen = transcript['<STR_LIT>']<EOL>most_severe_region = SO_TERMS[consequence]['<STR_LIT>']<EOL><DEDENT><DEDENT><DEDENT>gene = {<EOL>'<STR_LIT>': gene_transcripts,<EOL>'<STR_LIT>': most_severe_transcript,<EOL>'<STR_LIT>': most_severe_consequence,<EOL>'<STR_LIT>': most_severe_sift,<EOL>'<STR_LIT>': most_severe_polyphen,<EOL>'<STR_LIT>': hgnc_id,<EOL>'<STR_LIT>': hgnc_symbol,<EOL>'<STR_LIT>': most_severe_region,<EOL>'<STR_LIT>': transcript['<STR_LIT>'],<EOL>'<STR_LIT>': transcript['<STR_LIT>'],<EOL>'<STR_LIT>': transcript['<STR_LIT>'],<EOL>}<EOL>genes.append(gene)    <EOL><DEDENT>return genes<EOL>", "docstring": "Parse transcript information and get the gene information from there.\n\n    Use hgnc_id as identifier for genes and ensembl transcript id to identify transcripts\n\n    Args:\n        transcripts(iterable(dict))\n\n    Returns:\n      genes (list(dict)): A list with dictionaries that represents genes", "id": "f13838:m0"}
{"signature": "def parse_peddy_ped_check(lines):", "body": "ped_check = []<EOL>header = []<EOL>for i,line in enumerate(lines):<EOL><INDENT>line = line.rstrip()<EOL>if i == <NUM_LIT:0>:<EOL><INDENT>header = line.lstrip('<STR_LIT:#>').split('<STR_LIT:U+002C>')<EOL><DEDENT>else:<EOL><INDENT>pair_info = dict(zip(header, line.split('<STR_LIT:U+002C>')))<EOL>pair_info['<STR_LIT>'] = convert_number(pair_info['<STR_LIT>'])<EOL>pair_info['<STR_LIT>'] = convert_number(pair_info['<STR_LIT>'])<EOL>pair_info['<STR_LIT>'] = convert_number(pair_info['<STR_LIT>'])<EOL>pair_info['<STR_LIT>'] = convert_number(pair_info['<STR_LIT>'])<EOL>pair_info['<STR_LIT:n>'] = convert_number(pair_info['<STR_LIT:n>'])<EOL>pair_info['<STR_LIT>'] = convert_number(pair_info['<STR_LIT>'])<EOL>pair_info['<STR_LIT>'] = convert_number(pair_info['<STR_LIT>'])<EOL>pair_info['<STR_LIT>'] = convert_number(pair_info['<STR_LIT>'])<EOL>pair_info['<STR_LIT>'] = convert_number(pair_info['<STR_LIT>'])<EOL>pair_info['<STR_LIT>'] = make_bool(pair_info.get('<STR_LIT>'))<EOL>pair_info['<STR_LIT>'] = make_bool(pair_info.get('<STR_LIT>'))<EOL>pair_info['<STR_LIT>'] = make_bool(pair_info.get('<STR_LIT>'))<EOL>pair_info['<STR_LIT>'] = make_bool(pair_info.get('<STR_LIT>'))<EOL>ped_check.append(pair_info)<EOL><DEDENT><DEDENT>return ped_check<EOL>", "docstring": "Parse a .ped_check.csv file\n\n    Args:\n        lines(iterable(str))\n\n    Returns:\n        ped_check(list(dict))", "id": "f13840:m1"}
{"signature": "def parse_genes(gene_lines):", "body": "genes = []<EOL>header = []<EOL>hgnc_identifiers = set()<EOL>delimiter = '<STR_LIT:\\t>'<EOL>delimiters = ['<STR_LIT:\\t>', '<STR_LIT:U+0020>', '<STR_LIT:;>']<EOL>for i,line in enumerate(gene_lines):<EOL><INDENT>line = line.rstrip()<EOL>if not len(line) > <NUM_LIT:0>:<EOL><INDENT>continue<EOL><DEDENT>if line.startswith('<STR_LIT:#>'):<EOL><INDENT>if not line.startswith('<STR_LIT>'):<EOL><INDENT>line_length = <NUM_LIT:0><EOL>delimiter = None<EOL>for alt in delimiters:<EOL><INDENT>head_line = line.split(alt)<EOL>if len(head_line) > line_length:<EOL><INDENT>line_length = len(head_line)<EOL>delimiter = alt<EOL><DEDENT><DEDENT>header = [word.lower() for word in line[<NUM_LIT:1>:].split(delimiter)]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if i == <NUM_LIT:0>:<EOL><INDENT>line_length = <NUM_LIT:0><EOL>for alt in delimiters:<EOL><INDENT>head_line = line.split(alt)<EOL>if len(head_line) > line_length:<EOL><INDENT>line_length = len(head_line)<EOL>delimiter = alt<EOL><DEDENT><DEDENT>if ('<STR_LIT>' in line or '<STR_LIT>' in line):<EOL><INDENT>header = [word.lower() for word in line.split(delimiter)]<EOL>continue<EOL><DEDENT>if line.split(delimiter)[<NUM_LIT:0>].isdigit():<EOL><INDENT>header = ['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>header = ['<STR_LIT>']<EOL><DEDENT><DEDENT>splitted_line = line.split(delimiter)<EOL>gene_info = dict(zip(header, splitted_line))<EOL>info_found = False<EOL>for key in gene_info:<EOL><INDENT>if gene_info[key]:<EOL><INDENT>info_found = True<EOL>break<EOL><DEDENT><DEDENT>if not info_found:<EOL><INDENT>continue<EOL><DEDENT>try:<EOL><INDENT>gene = parse_gene(gene_info)<EOL><DEDENT>except Exception as e:<EOL><INDENT>LOG.warning(e)<EOL>raise SyntaxError(\"<STR_LIT>\".format(i + <NUM_LIT:1>))<EOL><DEDENT>identifier = gene.pop('<STR_LIT>')<EOL>if not identifier in hgnc_identifiers:<EOL><INDENT>hgnc_identifiers.add(identifier)<EOL>genes.append(gene)<EOL><DEDENT><DEDENT><DEDENT>return genes<EOL>", "docstring": "Parse a file with genes and return the hgnc ids\n\n    Args:\n        gene_lines(iterable(str)): Stream with genes\n\n    Returns:\n        genes(list(dict)): Dictionaries with relevant gene info", "id": "f13841:m2"}
{"signature": "def clinvar_submission_lines(submission_objs, submission_header):", "body": "submission_lines = []<EOL>for submission_obj in submission_objs: <EOL><INDENT>csv_line = []<EOL>for header_key, header_value in submission_header.items(): <EOL><INDENT>if header_key in submission_obj: <EOL><INDENT>csv_line.append('<STR_LIT:\">'+submission_obj.get(header_key)+'<STR_LIT:\">')<EOL><DEDENT>else: <EOL><INDENT>csv_line.append('<STR_LIT>')<EOL><DEDENT><DEDENT>submission_lines.append('<STR_LIT:U+002C>'.join(csv_line))<EOL><DEDENT>return submission_lines<EOL>", "docstring": "Create the lines to include in a Clinvar submission csv file from a list of submission objects and a custom document header\n\n        Args:\n            submission_objs(list): a list of objects (variants or casedata) to include in a csv file\n            submission_header(dict) : as in constants CLINVAR_HEADER and CASEDATA_HEADER, but with required fields only\n\n        Returns:\n            submission_lines(list) a list of strings, each string represents a line of the clinvar csv file to be doenloaded", "id": "f13842:m4"}
{"signature": "def parse_omim_line(line, header):", "body": "omim_info = dict(zip(header, line.split('<STR_LIT:\\t>')))<EOL>return omim_info<EOL>", "docstring": "docstring for parse_omim_2_line", "id": "f13844:m0"}
{"signature": "def get_mim_phenotypes(genemap_lines):", "body": "<EOL>phenotype_mims = set()<EOL>phenotypes_found = {}<EOL>for entry in parse_genemap2(genemap_lines):<EOL><INDENT>hgnc_symbol = entry['<STR_LIT>']<EOL>for phenotype in entry['<STR_LIT>']:<EOL><INDENT>mim_nr = phenotype['<STR_LIT>']<EOL>if mim_nr in phenotypes_found:<EOL><INDENT>phenotype_entry = phenotypes_found[mim_nr]<EOL>phenotype_entry['<STR_LIT>'] = phenotype_entry['<STR_LIT>'].union(phenotype['<STR_LIT>'])<EOL>phenotype_entry['<STR_LIT>'].add(hgnc_symbol)<EOL><DEDENT>else:<EOL><INDENT>phenotype['<STR_LIT>'] = set([hgnc_symbol])<EOL>phenotypes_found[mim_nr] = phenotype<EOL><DEDENT><DEDENT><DEDENT>return phenotypes_found<EOL>", "docstring": "Get a dictionary with phenotypes\n\n    Use the mim numbers for phenotypes as keys and phenotype information as \n    values.\n\n    Args:\n        genemap_lines(iterable(str))\n\n    Returns:\n        phenotypes_found(dict): A dictionary with mim_numbers as keys and \n        dictionaries with phenotype information as values.\n\n        {\n             'description': str, # Description of the phenotype\n             'hgnc_symbols': set(), # Associated hgnc symbols\n             'inheritance': set(),  # Associated phenotypes\n             'mim_number': int, # mim number of phenotype\n        }", "id": "f13844:m6"}
{"signature": "def get_mim_genes(genemap_lines, mim2gene_lines):", "body": "LOG.info(\"<STR_LIT>\")<EOL>genes = {}<EOL>hgnc_genes = {}<EOL>gene_nr = <NUM_LIT:0><EOL>no_hgnc = <NUM_LIT:0><EOL>for entry in parse_mim2gene(mim2gene_lines):<EOL><INDENT>if '<STR_LIT>' in entry['<STR_LIT>']:<EOL><INDENT>mim_nr = entry['<STR_LIT>']<EOL>gene_nr += <NUM_LIT:1><EOL>if not '<STR_LIT>' in entry:<EOL><INDENT>no_hgnc += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>genes[mim_nr] = entry<EOL><DEDENT><DEDENT><DEDENT>LOG.info(\"<STR_LIT>\", str(no_hgnc))<EOL>for entry in parse_genemap2(genemap_lines):<EOL><INDENT>mim_number = entry['<STR_LIT>']<EOL>inheritance = entry['<STR_LIT>']<EOL>phenotype_info = entry['<STR_LIT>']<EOL>hgnc_symbol = entry['<STR_LIT>']<EOL>hgnc_symbols = entry['<STR_LIT>']<EOL>if mim_number in genes:<EOL><INDENT>genes[mim_number]['<STR_LIT>'] = inheritance<EOL>genes[mim_number]['<STR_LIT>'] = phenotype_info<EOL>genes[mim_number]['<STR_LIT>'] = hgnc_symbols<EOL><DEDENT><DEDENT>for mim_nr in genes:<EOL><INDENT>gene_info = genes[mim_nr]<EOL>hgnc_symbol = gene_info['<STR_LIT>']<EOL>if hgnc_symbol in hgnc_genes:<EOL><INDENT>existing_info = hgnc_genes[hgnc_symbol]<EOL>if not existing_info['<STR_LIT>']:<EOL><INDENT>hgnc_genes[hgnc_symbol] = gene_info<EOL><DEDENT><DEDENT>else:<EOL><INDENT>hgnc_genes[hgnc_symbol] = gene_info<EOL><DEDENT><DEDENT>return hgnc_genes<EOL>", "docstring": "Get a dictionary with genes and their omim information\n\n    Args:\n        genemap_lines(iterable(str))\n        mim2gene_lines(iterable(str))\n\n    Returns.\n        hgnc_genes(dict): A dictionary with hgnc_symbol as keys", "id": "f13844:m5"}
{"signature": "def parse_matches(patient_id, match_objs):", "body": "LOG.info('<STR_LIT>'.format(patient_id))<EOL>parsed_matches = []<EOL>for match_obj in match_objs:<EOL><INDENT>milliseconds_date = match_obj['<STR_LIT>']['<STR_LIT>']<EOL>mdate = datetime.datetime.fromtimestamp(milliseconds_date/<NUM_LIT>)<EOL>match_type = '<STR_LIT>'<EOL>matching_patients = []<EOL>parsed_match = {<EOL>'<STR_LIT>' : match_obj['<STR_LIT>']['<STR_LIT>'],<EOL>'<STR_LIT>' : mdate<EOL>}<EOL>if match_obj['<STR_LIT:data>']['<STR_LIT>']['<STR_LIT:id>'] == patient_id:<EOL><INDENT>match_results = match_obj['<STR_LIT>'] <EOL>for node_result in match_results:<EOL><INDENT>if match_obj['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>match_type = '<STR_LIT>'<EOL><DEDENT>for patient in node_result['<STR_LIT>']:<EOL><INDENT>match_patient = {<EOL>'<STR_LIT>' : patient['<STR_LIT>']['<STR_LIT:id>'],<EOL>'<STR_LIT>' : patient['<STR_LIT>'],<EOL>'<STR_LIT>' : patient['<STR_LIT>'],<EOL>'<STR_LIT>' : node_result['<STR_LIT>']<EOL>}<EOL>matching_patients.append(match_patient)<EOL><DEDENT><DEDENT><DEDENT>else: <EOL><INDENT>m_patient = match_obj['<STR_LIT:data>']['<STR_LIT>']<EOL>contact_institution = m_patient['<STR_LIT>'].get('<STR_LIT>')<EOL>if contact_institution and '<STR_LIT>' in contact_institution:<EOL><INDENT>match_type = '<STR_LIT>'<EOL><DEDENT>score = None<EOL>for res in match_obj['<STR_LIT>']:<EOL><INDENT>for patient in res['<STR_LIT>']:<EOL><INDENT>LOG.info('<STR_LIT>'.format(patient['<STR_LIT>']['<STR_LIT:id>']))<EOL>if patient['<STR_LIT>']['<STR_LIT:id>'] == patient_id:<EOL><INDENT>score = patient['<STR_LIT>']<EOL>match_patient = {<EOL>'<STR_LIT>' : m_patient['<STR_LIT:id>'],<EOL>'<STR_LIT>' : score,<EOL>'<STR_LIT>' : m_patient,<EOL>'<STR_LIT>' : res['<STR_LIT>']<EOL>}<EOL>matching_patients.append(match_patient)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>parsed_match['<STR_LIT>'] = match_type<EOL>parsed_match['<STR_LIT>'] = matching_patients<EOL>parsed_matches.append(parsed_match)<EOL><DEDENT>parsed_matches = sorted(parsed_matches, key=lambda k: k['<STR_LIT>'], reverse=True)<EOL>return parsed_matches<EOL>", "docstring": "Parse a list of matchmaker matches objects and returns\n       a readable list of matches to display in matchmaker matches view.\n\n    Args:\n        patient_id(str): id of a mme patient\n        match_objs(list): list of match objs returned by MME server for the patient\n                # match_objs looks like this:\n                    [\n                        {\n                            'node' : { id : node_id , label: node_label},\n                            'patients' : [\n                                { 'patient': {patient1_data} },\n                                { 'patient': {patient2_data} },\n                                ..\n                            ]\n                        },\n                        ..\n                    ]\n\n    Returns:\n        parsed_matches(list): a list of parsed match objects", "id": "f13845:m3"}
{"signature": "def genomic_features(store, case_obj, sample_name, genes_only):", "body": "g_features = []<EOL>build = case_obj['<STR_LIT>']<EOL>if not build in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>build = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>build = '<STR_LIT>'+build<EOL><DEDENT>individual_pinned_snvs = list(store.sample_variants( variants=case_obj.get('<STR_LIT>'),<EOL>sample_name=sample_name))<EOL>gene_set = set()<EOL>for var in individual_pinned_snvs:<EOL><INDENT>hgnc_genes = var.get('<STR_LIT>')<EOL>if not hgnc_genes:<EOL><INDENT>continue<EOL><DEDENT>for hgnc_id in hgnc_genes:<EOL><INDENT>gene_obj = store.hgnc_gene(hgnc_id)<EOL>if not gene_obj:<EOL><INDENT>continue<EOL><DEDENT>g_feature = {<EOL>'<STR_LIT>': {'<STR_LIT:id>': gene_obj.get('<STR_LIT>')}<EOL>}<EOL>if genes_only and not hgnc_id in gene_set: <EOL><INDENT>gene_set.add(hgnc_id)<EOL>g_features.append(g_feature)<EOL>continue<EOL><DEDENT>g_feature['<STR_LIT>'] = {<EOL>'<STR_LIT>' : var['<STR_LIT>'],<EOL>'<STR_LIT:start>' : var['<STR_LIT>'],<EOL>'<STR_LIT:end>' : var['<STR_LIT:end>'],<EOL>'<STR_LIT>' : build,<EOL>'<STR_LIT>' :var['<STR_LIT>'],<EOL>'<STR_LIT>' : var['<STR_LIT>'],<EOL>'<STR_LIT>' : True<EOL>}<EOL>zygosity = None<EOL>zygosities = var['<STR_LIT>'] <EOL>for zyg in zygosities:<EOL><INDENT>if zyg.get('<STR_LIT>') == sample_name: <EOL><INDENT>zygosity = zyg['<STR_LIT>'].count('<STR_LIT:1>') + zyg['<STR_LIT>'].count('<STR_LIT:2>')<EOL><DEDENT><DEDENT>g_feature['<STR_LIT>'] = zygosity<EOL>g_features.append(g_feature)<EOL><DEDENT><DEDENT>return g_features<EOL>", "docstring": "Extract and parse matchmaker-like genomic features from pinned variants\n        of a patient\n    Args:\n        store(MongoAdapter) : connection to the database\n        case_obj(dict): a scout case object\n        sample_name(str): sample display name\n        genes_only(bool): if True only gene names will be included in genomic features\n\n    Returns:\n        g_features(list): a list of genomic feature objects that looks like this:\n            [\n              {\n                \"gene\": {\n                  \"id\": \"LIMS2\"\n                },\n                \"variant\": {\n                  \"alternateBases\": \"C\",\n                  \"assembly\": \"GRCh37\",\n                  \"end\": 128412081,\n                  \"referenceBases\": \"G\",\n                  \"referenceName\": \"2\",\n                  \"start\": 128412080\n                },\n                \"zygosity\": 1\n              },\n              ....\n            ]", "id": "f13845:m2"}
{"signature": "def parse_hgnc_genes(lines):", "body": "header = []<EOL>logger.info(\"<STR_LIT>\")<EOL>for index, line in enumerate(lines):<EOL><INDENT>if index == <NUM_LIT:0>:<EOL><INDENT>header = line.split('<STR_LIT:\\t>')<EOL><DEDENT>elif len(line) > <NUM_LIT:1>:<EOL><INDENT>hgnc_gene = parse_hgnc_line(line=line, header=header)<EOL>if hgnc_gene:<EOL><INDENT>yield hgnc_gene<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Parse lines with hgnc formated genes\n\n        This is designed to take a dump with genes from HGNC.\n        This is downloaded from:\n        ftp://ftp.ebi.ac.uk/pub/databases/genenames/new/tsv/hgnc_complete_set.txt\n\n        Args:\n            lines(iterable(str)): An iterable with HGNC formated genes\n        Yields:\n            hgnc_gene(dict): A dictionary with the relevant information", "id": "f13846:m1"}
{"signature": "def parse_hpo_phenotypes(hpo_lines):", "body": "hpo_terms = {}<EOL>LOG.info(\"<STR_LIT>\")<EOL>for index, line in enumerate(hpo_lines):<EOL><INDENT>if index > <NUM_LIT:0> and len(line) > <NUM_LIT:0>:<EOL><INDENT>hpo_info = parse_hpo_phenotype(line)<EOL>hpo_term = hpo_info['<STR_LIT>']<EOL>hgnc_symbol = hpo_info['<STR_LIT>']<EOL>if hpo_term in hpo_terms:<EOL><INDENT>hpo_terms[hpo_term]['<STR_LIT>'].append(hgnc_symbol)<EOL><DEDENT>else:<EOL><INDENT>hpo_terms[hpo_term] = {<EOL>'<STR_LIT>':hpo_term,<EOL>'<STR_LIT:description>': hpo_info['<STR_LIT:description>'],<EOL>'<STR_LIT>': [hgnc_symbol]<EOL>}<EOL><DEDENT><DEDENT><DEDENT>LOG.info(\"<STR_LIT>\")<EOL>return hpo_terms<EOL>", "docstring": "Parse hpo phenotypes\n\n        Group the genes that a phenotype is associated to in 'genes'\n\n    Args:\n        hpo_lines(iterable(str)): A file handle to the hpo phenotypes file\n\n    Returns:\n        hpo_terms(dict): A dictionary with hpo_ids as keys and terms as values\n\n        {\n            <hpo_id>: {\n                'hpo_id':str,\n                'description': str,\n                'hgnc_symbols': list(str), # [<hgnc_symbol>, ...]\n                }\n        }", "id": "f13848:m3"}
{"signature": "def check_paths(paths):", "body": "<EOL>for path in paths:<EOL><INDENT>if is_binary(path):<EOL><INDENT>continue<EOL><DEDENT>for line in open(path, \"<STR_LIT:r>\"):<EOL><INDENT>match = RE_OBJ.search(line)<EOL>msg = \"<STR_LIT>\"<EOL>assert match is None, msg.format(path)<EOL><DEDENT><DEDENT>", "docstring": "Method to check all paths have correct substitutions,\n    used by other tests cases", "id": "f13850:m3"}
{"signature": "def run(parser, command_string, kwargs=None, exit=False):", "body": "kwargs = kwargs or {}<EOL>try:<EOL><INDENT>return call_cmd(parser, command_string, **kwargs)<EOL><DEDENT>except SystemExit as error:<EOL><INDENT>if exit:<EOL><INDENT>if error.args == (None,):<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>return str(error)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if exit:<EOL><INDENT>raise AssertionError('<STR_LIT>')<EOL><DEDENT><DEDENT>", "docstring": "Calls the command and returns result.\n\n    If SystemExit is raised, it propagates.\n\n    :exit:\n        if set to `True`, then any SystemExit exception is caught and its\n        string representation is returned; if the exception is not raised,\n        an AssertionError is raised.  In other words, this parameter inverts\n        the function's behaviour and expects SystemExit as the correct event.", "id": "f13878:m2"}
{"signature": "def autocomplete(parser):", "body": "if COMPLETION_ENABLED:<EOL><INDENT>argcomplete.autocomplete(parser)<EOL><DEDENT>elif '<STR_LIT>' in os.getenv('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>logger.debug('<STR_LIT>')<EOL><DEDENT>", "docstring": "Adds support for shell completion via argcomplete_ by patching given\n`argparse.ArgumentParser` (sub)class.\n\nIf completion is not enabled, logs a debug-level message.", "id": "f13884:m0"}
{"signature": "def getargspec_permissive(func):", "body": "if inspect.ismethod(func):<EOL><INDENT>func = func.im_func<EOL><DEDENT>if not (hasattr(func, \"<STR_LIT>\") and hasattr(func, \"<STR_LIT>\")):<EOL><INDENT>raise TypeError('<STR_LIT>'.format(func))<EOL><DEDENT>args, varargs, varkw = inspect.getargs(func.func_code)<EOL>return inspect.ArgSpec(args, varargs, varkw, func.func_defaults)<EOL>", "docstring": "An `inspect.getargspec` with a relaxed sanity check to support Cython.\n\nMotivation:\n\n    A Cython-compiled function is *not* an instance of Python's\n    types.FunctionType.  That is the sanity check the standard Py2\n    library uses in `inspect.getargspec()`.  So, an exception is raised\n    when calling `argh.dispatch_command(cythonCompiledFunc)`.  However,\n    the CyFunctions do have perfectly usable `.func_code` and\n    `.func_defaults` which is all `inspect.getargspec` needs.\n\n    This function just copies `inspect.getargspec()` from the standard\n    library but relaxes the test to a more duck-typing one of having\n    both `.func_code` and `.func_defaults` attributes.", "id": "f13886:m0"}
{"signature": "def add_subcommands(parser, namespace, functions, **namespace_kwargs):", "body": "add_commands(parser, functions, namespace=namespace,<EOL>namespace_kwargs=namespace_kwargs)<EOL>", "docstring": "A wrapper for :func:`add_commands`.\n\nThese examples are equivalent::\n\n    add_commands(parser, [get, put], namespace='db',\n                 namespace_kwargs={\n                     'title': 'database commands',\n                     'help': 'CRUD for our silly database'\n                 })\n\n    add_subcommands(parser, 'db', [get, put],\n                    title='database commands',\n                    help='CRUD for our silly database')", "id": "f13888:m10"}
{"signature": "def add_commands(parser, functions, namespace=None, namespace_kwargs=None,<EOL>func_kwargs=None,<EOL>title=None, description=None, help=None):", "body": "<EOL>if DEST_FUNCTION in parser._defaults:<EOL><INDENT>_require_support_for_default_command_with_subparsers()<EOL><DEDENT>namespace_kwargs = namespace_kwargs or {}<EOL>if title:<EOL><INDENT>warnings.warn('<STR_LIT>'<EOL>'<STR_LIT>', DeprecationWarning)<EOL>namespace_kwargs['<STR_LIT:description>'] = title<EOL><DEDENT>if help:<EOL><INDENT>warnings.warn('<STR_LIT>'<EOL>'<STR_LIT>', DeprecationWarning)<EOL>namespace_kwargs['<STR_LIT>'] = help<EOL><DEDENT>if description:<EOL><INDENT>warnings.warn('<STR_LIT>'<EOL>'<STR_LIT>', DeprecationWarning)<EOL>namespace_kwargs['<STR_LIT:description>'] = description<EOL><DEDENT>subparsers_action = get_subparsers(parser, create=True)<EOL>if namespace:<EOL><INDENT>subsubparser_kw = {<EOL>'<STR_LIT>': namespace_kwargs.get('<STR_LIT:title>'),<EOL>}<EOL>subsubparser = subparsers_action.add_parser(namespace, **subsubparser_kw)<EOL>subparsers_action = subsubparser.add_subparsers(**namespace_kwargs)<EOL><DEDENT>else:<EOL><INDENT>assert not namespace_kwargs, ('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>for func in functions:<EOL><INDENT>cmd_name, func_parser_kwargs = _extract_command_meta_from_func(func)<EOL>if func_kwargs:<EOL><INDENT>func_parser_kwargs.update(func_kwargs)<EOL><DEDENT>command_parser = subparsers_action.add_parser(cmd_name, **func_parser_kwargs)<EOL>set_default_command(command_parser, func)<EOL><DEDENT>", "docstring": "Adds given functions as commands to given parser.\n\n:param parser:\n\n    an :class:`argparse.ArgumentParser` instance.\n\n:param functions:\n\n    a list of functions. A subparser is created for each of them.\n    If the function is decorated with :func:`~argh.decorators.arg`, the\n    arguments are passed to :class:`argparse.ArgumentParser.add_argument`.\n    See also :func:`~argh.dispatching.dispatch` for requirements\n    concerning function signatures. The command name is inferred from the\n    function name. Note that the underscores in the name are replaced with\n    hyphens, i.e. function name \"foo_bar\" becomes command name \"foo-bar\".\n\n:param namespace:\n\n    an optional string representing the group of commands. For example, if\n    a command named \"hello\" is added without the namespace, it will be\n    available as \"prog.py hello\"; if the namespace if specified as \"greet\",\n    then the command will be accessible as \"prog.py greet hello\". The\n    namespace itself is not callable, so \"prog.py greet\" will fail and only\n    display a help message.\n\n:param func_kwargs:\n\n    a `dict` of keyword arguments to be passed to each nested ArgumentParser\n    instance created per command (i.e. per function).  Members of this\n    dictionary have the highest priority, so a function's docstring is\n    overridden by a `help` in `func_kwargs` (if present).\n\n:param namespace_kwargs:\n\n    a `dict` of keyword arguments to be passed to the nested ArgumentParser\n    instance under given `namespace`.\n\nDeprecated params that should be moved into `namespace_kwargs`:\n\n:param title:\n\n    passed to :meth:`argparse.ArgumentParser.add_subparsers` as `title`.\n\n    .. deprecated:: 0.26.0\n\n       Please use `namespace_kwargs` instead.\n\n:param description:\n\n    passed to :meth:`argparse.ArgumentParser.add_subparsers` as\n    `description`.\n\n    .. deprecated:: 0.26.0\n\n       Please use `namespace_kwargs` instead.\n\n:param help:\n\n    passed to :meth:`argparse.ArgumentParser.add_subparsers` as `help`.\n\n    .. deprecated:: 0.26.0\n\n       Please use `namespace_kwargs` instead.\n\n.. note::\n\n    This function modifies the parser object. Generally side effects are\n    bad practice but we don't seem to have any choice as ArgumentParser is\n    pretty opaque.\n    You may prefer :class:`~argh.helpers.ArghParser.add_commands` for a bit\n    more predictable API.\n\n.. note::\n\n   An attempt to add commands to a parser which already has a default\n   function (e.g. added with :func:`~argh.assembling.set_default_command`)\n   results in `AssemblingError`.", "id": "f13888:m8"}
{"signature": "def set_default_command(self, *args, **kwargs):", "body": "return set_default_command(self, *args, **kwargs)<EOL>", "docstring": "Wrapper for :func:`~argh.assembling.set_default_command`.", "id": "f13890:c0:m1"}
{"signature": "def dispatch(parser, argv=None, add_help_command=True,<EOL>completion=True, pre_call=None,<EOL>output_file=sys.stdout, errors_file=sys.stderr,<EOL>raw_output=False, namespace=None,<EOL>skip_unknown_args=False):", "body": "if completion:<EOL><INDENT>autocomplete(parser)<EOL><DEDENT>if argv is None:<EOL><INDENT>argv = sys.argv[<NUM_LIT:1>:]<EOL><DEDENT>if add_help_command:<EOL><INDENT>if argv and argv[<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>argv.pop(<NUM_LIT:0>)<EOL>argv.append('<STR_LIT>')<EOL><DEDENT><DEDENT>if skip_unknown_args:<EOL><INDENT>parse_args = parser.parse_known_args<EOL><DEDENT>else:<EOL><INDENT>parse_args = parser.parse_args<EOL><DEDENT>if not namespace:<EOL><INDENT>namespace = ArghNamespace()<EOL><DEDENT>namespace_obj = parse_args(argv, namespace=namespace)<EOL>function = _get_function_from_namespace_obj(namespace_obj)<EOL>if function:<EOL><INDENT>lines = _execute_command(function, namespace_obj, errors_file,<EOL>pre_call=pre_call)<EOL><DEDENT>else:<EOL><INDENT>lines = [parser.format_usage()]<EOL><DEDENT>if output_file is None:<EOL><INDENT>if sys.version_info < (<NUM_LIT:3>,<NUM_LIT:0>):<EOL><INDENT>f = compat.BytesIO()<EOL><DEDENT>else:<EOL><INDENT>f = compat.StringIO()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>f = output_file<EOL><DEDENT>for line in lines:<EOL><INDENT>io.dump(line, f)<EOL>if not raw_output:<EOL><INDENT>io.dump('<STR_LIT:\\n>', f)<EOL><DEDENT><DEDENT>if output_file is None:<EOL><INDENT>f.seek(<NUM_LIT:0>)<EOL>return f.read()<EOL><DEDENT>", "docstring": "Parses given list of arguments using given parser, calls the relevant\nfunction and prints the result.\n\nThe target function should expect one positional argument: the\n:class:`argparse.Namespace` object. However, if the function is decorated with\n:func:`~argh.decorators.plain_signature`, the positional and named\narguments from the namespace object are passed to the function instead\nof the object itself.\n\n:param parser:\n\n    the ArgumentParser instance.\n\n:param argv:\n\n    a list of strings representing the arguments. If `None`, ``sys.argv``\n    is used instead. Default is `None`.\n\n:param add_help_command:\n\n    if `True`, converts first positional argument \"help\" to a keyword\n    argument so that ``help foo`` becomes ``foo --help`` and displays usage\n    information for \"foo\". Default is `True`.\n\n:param output_file:\n\n    A file-like object for output. If `None`, the resulting lines are\n    collected and returned as a string. Default is ``sys.stdout``.\n\n:param errors_file:\n\n    Same as `output_file` but for ``sys.stderr``.\n\n:param raw_output:\n\n    If `True`, results are written to the output file raw, without adding\n    whitespaces or newlines between yielded strings. Default is `False`.\n\n:param completion:\n\n    If `True`, shell tab completion is enabled. Default is `True`. (You\n    will also need to install it.)  See :mod:`argh.completion`.\n\n:param skip_unknown_args:\n\n    If `True`, unknown arguments do not cause an error\n    (`ArgumentParser.parse_known_args` is used).\n\n:param namespace:\n\n    An `argparse.Namespace`-like object.  By default an\n    :class:`ArghNamespace` object is used.  Please note that support for\n    combined default and nested functions may be broken if a different\n    type of object is forced.\n\nBy default the exceptions are not wrapped and will propagate. The only\nexception that is always wrapped is :class:`~argh.exceptions.CommandError`\nwhich is interpreted as an expected event so the traceback is hidden.\nYou can also mark arbitrary exceptions as \"wrappable\" by using the\n:func:`~argh.decorators.wrap_errors` decorator.", "id": "f13891:m0"}
{"signature": "def get_subparsers(parser, create=False):", "body": "<EOL>if parser._subparsers:<EOL><INDENT>actions = [a for a in parser._actions<EOL>if isinstance(a, argparse._SubParsersAction)]<EOL>assert len(actions) == <NUM_LIT:1><EOL>return actions[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>if create:<EOL><INDENT>return parser.add_subparsers()<EOL><DEDENT><DEDENT>", "docstring": "Returns the :class:`argparse._SubParsersAction` instance for given\n:class:`ArgumentParser` instance as would have been returned by\n:meth:`ArgumentParser.add_subparsers`. The problem with the latter is that\nit only works once and raises an exception on the second attempt, and the\npublic API seems to lack a method to get *existing* subparsers.\n\n:param create:\n    If `True`, creates the subparser if it does not exist. Default if\n    `False`.", "id": "f13892:m0"}
{"signature": "def wrap_errors(errors=None, processor=None, *args):", "body": "def wrapper(func):<EOL><INDENT>if errors:<EOL><INDENT>setattr(func, ATTR_WRAPPED_EXCEPTIONS, errors)<EOL><DEDENT>if processor:<EOL><INDENT>setattr(func, ATTR_WRAPPED_EXCEPTIONS_PROCESSOR, processor)<EOL><DEDENT>return func<EOL><DEDENT>return wrapper<EOL>", "docstring": "Decorator. Wraps given exceptions into\n:class:`~argh.exceptions.CommandError`. Usage::\n\n    @wrap_errors([AssertionError])\n    def foo(x=None, y=None):\n        assert x or y, 'x or y must be specified'\n\nIf the assertion fails, its message will be correctly printed and the\nstack hidden. This helps to avoid boilerplate code.\n\n:param errors:\n    A list of exception classes to catch.\n:param processor:\n    A callable that expects the exception object and returns a string.\n    For example, this renders all wrapped errors in red colour::\n\n        from termcolor import colored\n\n        def failure(err):\n            return colored(str(err), 'red')\n\n        @wrap_errors(processor=failure)\n        def my_command(...):\n            ...", "id": "f13893:m3"}
{"signature": "def arg(*args, **kwargs):", "body": "def wrapper(func):<EOL><INDENT>declared_args = getattr(func, ATTR_ARGS, [])<EOL>declared_args.insert(<NUM_LIT:0>, dict(option_strings=args, **kwargs))<EOL>setattr(func, ATTR_ARGS, declared_args)<EOL>return func<EOL><DEDENT>return wrapper<EOL>", "docstring": "Declares an argument for given function. Does not register the function\nanywhere, nor does it modify the function in any way.\n\nThe signature of the decorator matches that of\n:meth:`argparse.ArgumentParser.add_argument`, only some keywords are not\nrequired if they can be easily guessed (e.g. you don't have to specify type\nor action when an `int` or `bool` default value is supplied).\n\nTypical use cases:\n\n- In combination with :func:`expects_obj` (which is not recommended);\n- in combination with ordinary function signatures to add details that\n  cannot be expressed with that syntax (e.g. help message).\n\nUsage::\n\n    from argh import arg\n\n    @arg('path', help='path to the file to load')\n    @arg('--format', choices=['yaml','json'])\n    @arg('-v', '--verbosity', choices=range(0,3), default=2)\n    def load(path, something=None, format='json', dry_run=False, verbosity=1):\n        loaders = {'json': json.load, 'yaml': yaml.load}\n        loader = loaders[args.format]\n        data = loader(args.path)\n        if not args.dry_run:\n            if verbosity < 1:\n                print('saving to the database')\n            put_to_database(data)\n\nIn this example:\n\n- `path` declaration is extended with `help`;\n- `format` declaration is extended with `choices`;\n- `dry_run` declaration is not duplicated;\n- `verbosity` is extended with `choices` and the default value is\n  overridden.  (If both function signature and `@arg` define a default\n  value for an argument, `@arg` wins.)\n\n.. note::\n\n    It is recommended to avoid using this decorator unless there's no way\n    to tune the argument's behaviour or presentation using ordinary\n    function signatures.  Readability counts, don't repeat yourself.", "id": "f13893:m2"}
{"signature": "def expects_obj(func):", "body": "setattr(func, ATTR_EXPECTS_NAMESPACE_OBJECT, True)<EOL>return func<EOL>", "docstring": "Marks given function as expecting a namespace object.\n\nUsage::\n\n    @arg('bar')\n    @arg('--quux', default=123)\n    @expects_obj\n    def foo(args):\n        yield args.bar, args.quux\n\nThis is equivalent to::\n\n    def foo(bar, quux=123):\n        yield bar, quux\n\nIn most cases you don't need this decorator.", "id": "f13893:m4"}
{"signature": "def safe_input(prompt):", "body": "if sys.version_info < (<NUM_LIT:3>,<NUM_LIT:0>):<EOL><INDENT>if isinstance(prompt, compat.text_type):<EOL><INDENT>encoding = locale.getpreferredencoding() or '<STR_LIT:utf-8>'<EOL>prompt = prompt.encode(encoding)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if not isinstance(prompt, compat.text_type):<EOL><INDENT>prompt = prompt.decode()<EOL><DEDENT><DEDENT>return _input(prompt)<EOL>", "docstring": "Prompts user for input. Correctly handles prompt message encoding.", "id": "f13895:m1"}
{"signature": "def encode_output(value, output_file):", "body": "if sys.version_info > (<NUM_LIT:3>,<NUM_LIT:0>):<EOL><INDENT>return compat.text_type(value)<EOL><DEDENT>else:<EOL><INDENT>stream_encoding = getattr(output_file, '<STR_LIT>', None)<EOL>if stream_encoding:<EOL><INDENT>if stream_encoding.upper() == '<STR_LIT>':<EOL><INDENT>return compat.text_type(value)<EOL><DEDENT>else:<EOL><INDENT>return value.encode(stream_encoding, '<STR_LIT:ignore>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if isinstance(value, compat.text_type):<EOL><INDENT>return value.encode('<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>return str(value)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Encodes given value so it can be written to given file object.\n\nValue may be Unicode, binary string or any other data type.\n\nThe exact behaviour depends on the Python version:\n\nPython 3.x\n\n    `sys.stdout` is a `_io.TextIOWrapper` instance that accepts `str`\n    (unicode) and breaks on `bytes`.\n\n    It is OK to simply assume that everything is Unicode unless special\n    handling is introduced in the client code.\n\n    Thus, no additional processing is performed.\n\nPython 2.x\n\n    `sys.stdout` is a file-like object that accepts `str` (bytes)\n    and breaks when `unicode` is passed to `sys.stdout.write()`.\n\n    We can expect both Unicode and bytes. They need to be encoded so as\n    to match the file object encoding.\n\n    The output is binary if the object doesn't explicitly require Unicode.", "id": "f13895:m2"}
{"signature": "def reg_on_status(self, callable_object, *args, **kwargs):", "body": "persistent = kwargs.pop('<STR_LIT>', False)<EOL>event = self._create_event(callable_object, '<STR_LIT:status>', persistent, *args, **kwargs)<EOL>self.status_callbacks.append(event)<EOL>return event<EOL>", "docstring": "Register a function/method to be called when a user or another\n        program asks for an update, when status is done it will start running\n        any tasks registered with the reg_on_resume method", "id": "f13898:c0:m20"}
{"signature": "def status(self, signum):", "body": "self.log.debug('<STR_LIT>')<EOL>new_status_callbacks = []<EOL>for status_call in self.status_callbacks:<EOL><INDENT>try:<EOL><INDENT>self.log.debug(\"<STR_LIT>\".format(status_call['<STR_LIT>'].__name__, status_call['<STR_LIT:args>'], status_call['<STR_LIT>']))<EOL><DEDENT>except AttributeError:<EOL><INDENT>self.log.debug(\"<STR_LIT>\".format(str(status_call)))<EOL><DEDENT>apply(status_call['<STR_LIT>'], status_call['<STR_LIT:args>'], status_call['<STR_LIT>'])<EOL>if status_call['<STR_LIT>']:<EOL><INDENT>new_status_callbacks.append(status_call)<EOL><DEDENT><DEDENT>self.status_callbacks = new_status_callbacks<EOL>self._resume(signum)<EOL>", "docstring": "Run all status tasks, then run all tasks in the resume queue", "id": "f13898:c0:m6"}
{"signature": "def default_handler(self, signum, frame):", "body": "self.log.debug(\"<STR_LIT>\".format(signum))<EOL>if signum in self.restart_signals:<EOL><INDENT>self.set_handler(self.handled_signals, self.pseudo_handler)<EOL>self._cleanup()<EOL>os.execl('<STR_LIT>', '<STR_LIT>', * sys.argv)<EOL><DEDENT>elif signum in self.abort_signals:<EOL><INDENT>self.abort(signum)<EOL><DEDENT>elif signum in self.pause_signals:<EOL><INDENT>self.pause(signum)<EOL><DEDENT>elif signum in self.resume_signals:<EOL><INDENT>self.resume(signum)<EOL><DEDENT>elif signum in self.status_signals:<EOL><INDENT>self.status(signum)<EOL><DEDENT>elif signum in self.error_signals:<EOL><INDENT>self.log.error('<STR_LIT>')<EOL>self.abort(signum)<EOL><DEDENT>else:<EOL><INDENT>self.log.error(\"<STR_LIT>\".format(signum))<EOL>raise<EOL><DEDENT>", "docstring": "Default handler, a generic callback method for signal processing", "id": "f13898:c0:m3"}
{"signature": "def run(self, command, *args):", "body": "self.log.debug(\"<STR_LIT>\", '<STR_LIT:U+0020>'.join([command] + list(args)))<EOL>self.external_running_process = subprocess.Popen([command] + list(args),<EOL>stdout=subprocess.PIPE,<EOL>stderr=subprocess.STDOUT)<EOL>result = '<STR_LIT>'<EOL>while True:<EOL><INDENT>line = self.external_running_process.stdout.readline()<EOL>if not line:<EOL><INDENT>break<EOL><DEDENT>line = line.strip()<EOL>result += line<EOL>self.log.debug('<STR_LIT>' + line)<EOL><DEDENT>self.external_running_process.wait()<EOL>if self.external_running_process.returncode != <NUM_LIT:0> and self.user_aborted is False:<EOL><INDENT>raise subprocess.CalledProcessError(self.external_running_process.returncode, command)<EOL><DEDENT>self.user_aborted = False<EOL>return result<EOL>", "docstring": "Run a command on the local system.\nRaises an exception on non-zero exit status, except when aborted\nusing the kill method.\nReturns the output generated by the command.", "id": "f13902:c0:m4"}
{"signature": "async def get_neighbourhood(postcode_like: PostCodeLike) -> Optional[Neighbourhood]:", "body": "try:<EOL><INDENT>postcode = await get_postcode(postcode_like)<EOL><DEDENT>except CachingError as e:<EOL><INDENT>raise e<EOL><DEDENT>else:<EOL><INDENT>if postcode is None:<EOL><INDENT>return None<EOL><DEDENT>elif postcode.neighbourhood is not None:<EOL><INDENT>return postcode.neighbourhood<EOL><DEDENT><DEDENT>try:<EOL><INDENT>data = await fetch_neighbourhood(postcode.lat, postcode.long)<EOL><DEDENT>except ApiError as e:<EOL><INDENT>raise CachingError(f\"<STR_LIT>\")<EOL><DEDENT>if data is not None:<EOL><INDENT>neighbourhood = Neighbourhood.from_dict(data)<EOL>locations = [Location.from_dict(neighbourhood, postcode, location) for location in data[\"<STR_LIT>\"]]<EOL>links = [Link.from_dict(neighbourhood, link) for link in data[\"<STR_LIT>\"]]<EOL>with Neighbourhood._meta.database.atomic():<EOL><INDENT>neighbourhood.save()<EOL>postcode.neighbourhood = neighbourhood<EOL>postcode.save()<EOL>for location in locations:<EOL><INDENT>location.save()<EOL><DEDENT>for link in links:<EOL><INDENT>link.save()<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>neighbourhood = None<EOL><DEDENT>return neighbourhood<EOL>", "docstring": "Gets a police neighbourhood from the database.\nActs as a middleware between us and the API, caching results.\n:param postcode_like: The UK postcode to look up.\n:return: The Neighbourhood or None if the postcode does not exist.\n:raises CachingError: If the needed neighbourhood is not in cache, and the fetch isn't responding.\n\ntodo save locations/links", "id": "f13905:m6"}
{"signature": "@middleware<EOL>async def normalize_postcode_middleware(request, handler):", "body": "postcode: Optional[str] = request.match_info.get('<STR_LIT>', None)<EOL>if postcode is None or postcode == \"<STR_LIT>\":<EOL><INDENT>return await handler(request)<EOL><DEDENT>elif not is_uk_postcode(postcode):<EOL><INDENT>raise web.HTTPNotFound(text=\"<STR_LIT>\")<EOL><DEDENT>postcode_processed = postcode.upper().replace(\"<STR_LIT:U+0020>\", \"<STR_LIT>\")<EOL>if postcode_processed == postcode:<EOL><INDENT>return await handler(request)<EOL><DEDENT>else:<EOL><INDENT>url_name = request.match_info.route.name<EOL>url = request.app.router[url_name]<EOL>params = dict(request.match_info)<EOL>params['<STR_LIT>'] = postcode_processed<EOL>raise web.HTTPMovedPermanently(str(url.url_for(**params)))<EOL><DEDENT>", "docstring": "If there is a postcode in the url it validates and normalizes it.", "id": "f13912:m0"}
{"signature": "async def api_postcode(request):", "body": "postcode: Optional[str] = request.match_info.get('<STR_LIT>', None)<EOL>try:<EOL><INDENT>coroutine = get_postcode_random() if postcode == \"<STR_LIT>\" else get_postcode(postcode)<EOL>postcode: Optional[Postcode] = await coroutine<EOL><DEDENT>except CachingError as e:<EOL><INDENT>return web.HTTPInternalServerError(body=e.status)<EOL><DEDENT>except CircuitBreakerError as e:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>if postcode is not None:<EOL><INDENT>return str_json_response(postcode.serialize())<EOL><DEDENT>else:<EOL><INDENT>return web.HTTPNotFound(body=\"<STR_LIT>\")<EOL><DEDENT><DEDENT>", "docstring": "Gets data from a postcode.\n:param request: The aiohttp request.", "id": "f13913:m0"}
{"signature": "def partition(condition, collection) -> Tuple[List, List]:", "body": "succeed, fail = [], []<EOL>for x in collection:<EOL><INDENT>if condition(x):<EOL><INDENT>succeed.append(x)<EOL><DEDENT>else:<EOL><INDENT>fail.append(x)<EOL><DEDENT><DEDENT>return succeed, fail<EOL>", "docstring": "Partitions a list into two based on a condition.", "id": "f13923:m0"}
{"signature": "@twitrss_breaker<EOL>async def fetch_twitter(handle: str) -> List:", "body": "async with ClientSession() as session:<EOL><INDENT>try:<EOL><INDENT>async with session.get(f\"<STR_LIT>\") as request:<EOL><INDENT>text = await request.text()<EOL><DEDENT><DEDENT>except ClientConnectionError as con_err:<EOL><INDENT>logger.debug(f\"<STR_LIT>\")<EOL>raise ApiError(f\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>feed = parse(text)<EOL>for x in feed.entries:<EOL><INDENT>x[\"<STR_LIT:image>\"] = feed.feed[\"<STR_LIT:image>\"][\"<STR_LIT>\"]<EOL><DEDENT>return feed.entries<EOL><DEDENT><DEDENT>", "docstring": "Gets the twitter feed for a given handle.\n:param handle: The twitter handle.\n:return: A list of entries in a user's feed.\n:raises ApiError: When the api couldn't connect.\n:raises CircuitBreakerError: When the circuit breaker is open.", "id": "f13927:m0"}
{"signature": "def get_description(self):", "body": "if self.description:<EOL><INDENT>return self.description<EOL><DEDENT>elif self.__doc__ and self.__doc__.strip():<EOL><INDENT>return self.__doc__.strip().split('<STR_LIT:.>')[<NUM_LIT:0>] + '<STR_LIT:.>'<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>", "docstring": "Gets the description of the command. If its not supplied the first sentence of the doc string is used.", "id": "f13942:c0:m8"}
{"signature": "def add_args(self, parser):", "body": "pass<EOL>", "docstring": "Adds arguments to the argument parser. This is used to modify which arguments are processed by the command.\n\nFor a full description of the argument parser see https://docs.python.org/3/library/argparse.html.\n\n:param parser: The argument parser object", "id": "f13942:c0:m4"}
{"signature": "def get_formatter_class(self):", "body": "return self.formatter_class<EOL>", "docstring": "Gets the formatter class for formatting help text", "id": "f13942:c0:m10"}
{"signature": "def register_sub_commands(self, parser):", "body": "sub_commands = self.get_sub_commands()<EOL>if sub_commands:<EOL><INDENT>sub_parsers = parser.add_subparsers(dest=self.sub_parser_dest_name)<EOL>for name, cls in sub_commands.items():<EOL><INDENT>cmd = cls(name)<EOL>sub_parser = sub_parsers.add_parser(name, help=name, description=cmd.get_help(), formatter_class=cmd.get_formatter_class())<EOL>cmd.add_args(sub_parser)<EOL>cmd.register_sub_commands(sub_parser)<EOL><DEDENT><DEDENT>", "docstring": "Add any sub commands to the argument parser.\n\n:param parser: The argument parser object", "id": "f13942:c0:m5"}
{"signature": "def get_root_argparser(self):", "body": "return self.arg_parse_class(description=self.get_help(), formatter_class=self.get_formatter_class())<EOL>", "docstring": "Gets the root argument parser object.", "id": "f13942:c0:m6"}
{"signature": "def to_underscore(string):", "body": "new_string = re.sub(r'<STR_LIT>', r'<STR_LIT>', string)<EOL>new_string = re.sub(r'<STR_LIT>', r'<STR_LIT>', new_string)<EOL>return new_string.lower()<EOL>", "docstring": "Converts a given string from CamelCase to under_score.\n\n    >>> to_underscore('FooBar')\n    'foo_bar'", "id": "f13947:m0"}
{"signature": "def remove(self):", "body": "return self.collection.remove(self._id)<EOL>", "docstring": "Remove this object from the database.", "id": "f13947:c2:m3"}
{"signature": "def find(self, *args, **kwargs):", "body": "return Cursor(self, *args, wrap=self.document_class, **kwargs)<EOL>", "docstring": "Same as :meth:`pymongo.collection.Collection.find`, except\n        it returns the right document class.", "id": "f13952:c1:m1"}
{"signature": "@state.setter<EOL><INDENT>def state(self, state):<DEDENT>", "body": "self._state = state<EOL>", "docstring": "Set the state for this instance of search method", "id": "f13972:c0:m7"}
{"signature": "def run(self):", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "Ensure that any subclass implements this method", "id": "f13972:c0:m3"}
{"signature": "@property<EOL><INDENT>def inputs(self):<DEDENT>", "body": "return self._inputs<EOL>", "docstring": "Return the input search parameters for this instance of search\n        method", "id": "f13972:c0:m5"}
{"signature": "def _check_inputs(self):", "body": "try:<EOL><INDENT>_ = self._inputs[<NUM_LIT:0>]<EOL><DEDENT>except TypeError:<EOL><INDENT>raise RuntimeError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(type(self._inputs), str(self._inputs)))<EOL><DEDENT>from melody.inputs import Input<EOL>for check_input in self._inputs:<EOL><INDENT>if not isinstance(check_input, Input):<EOL><INDENT>raise RuntimeError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(type(check_input),<EOL>str(check_input)))<EOL><DEDENT><DEDENT>", "docstring": "make some basic checks on the inputs to make sure they are valid", "id": "f13972:c0:m1"}
{"signature": "def _check_function(self):", "body": "<EOL>if not callable(self._function):<EOL><INDENT>raise RuntimeError(<EOL>\"<STR_LIT>\".<EOL>format(str(self._function)))<EOL><DEDENT>from inspect import getargspec<EOL>arg_info = getargspec(self._function)<EOL>if len(arg_info.args) != <NUM_LIT:1>:<EOL><INDENT>print(str(arg_info))<EOL>raise RuntimeError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(len(arg_info.args)))<EOL><DEDENT>", "docstring": "make some basic checks on the function to make sure it is valid", "id": "f13972:c0:m2"}
{"signature": "def _recurse(self, inputs, output):", "body": "if inputs:<EOL><INDENT>my_input = inputs[<NUM_LIT:0>]<EOL>name = my_input.name<EOL>if my_input.state:<EOL><INDENT>my_options = my_input.options(self.state)<EOL><DEDENT>else:<EOL><INDENT>my_options = my_input.options<EOL><DEDENT>for option in my_options:<EOL><INDENT>my_output = list(output)<EOL>my_output.append({name: option})<EOL>self._recurse(inputs[<NUM_LIT:1>:], my_output)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>valid, result = self._function(output)<EOL><DEDENT>except ValueError:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>print(output, valid, result)<EOL><DEDENT>", "docstring": "internal recursion routine called by the run method that generates\n        all input combinations", "id": "f13972:c1:m2"}
{"signature": "@property<EOL><INDENT>def inputs(self):<DEDENT>", "body": "return self._inputs<EOL>", "docstring": "Return the input search parameters for the associated function", "id": "f13973:c0:m5"}
{"signature": "@function.setter<EOL><INDENT>def function(self, function):<DEDENT>", "body": "self._function = function<EOL>", "docstring": "Set the function associated with this instance of melody", "id": "f13973:c0:m2"}
{"signature": "@method.setter<EOL><INDENT>def method(self, method):<DEDENT>", "body": "self._method = method<EOL>", "docstring": "Set the optimisation/search method associated with this instance of\nmelody", "id": "f13973:c0:m4"}
{"signature": "@property<EOL><INDENT>def function(self):<DEDENT>", "body": "return self._function<EOL>", "docstring": "Return the function associated with this instance of melody", "id": "f13973:c0:m1"}
{"signature": "def setUp(self):", "body": "self.setup_loop()<EOL>self._serial = Serial(self._loop, PORT, baudrate=BAUD)<EOL>", "docstring": "Initializes eventloop and serial", "id": "f13978:c0:m0"}
{"signature": "@property<EOL><INDENT>@abstractmethod<EOL>def is_open(self) -> bool:<DEDENT>", "body": "pass<EOL>", "docstring": "True if the connection is open, false otherwise", "id": "f13979:c0:m3"}
{"signature": "async def abort(self):", "body": "self._serial_instance.close()<EOL>", "docstring": "Closes the serial connection immediately, output queue will be discarded", "id": "f13981:c0:m6"}
{"signature": "@property<EOL><INDENT>def serial_instance(self) -> serial.Serial:<DEDENT>", "body": "return self._serial_instance<EOL>", "docstring": "Serial instance", "id": "f13981:c0:m3"}
{"signature": "@property<EOL><INDENT>def out_waiting(self) -> int:<DEDENT>", "body": "return self._serial_instance.out_waiting<EOL>", "docstring": "Number of not yet written bytes", "id": "f13981:c0:m4"}
{"signature": "@property<EOL><INDENT>def is_open(self) -> bool:<DEDENT>", "body": "return self._serial_instance.isOpen()<EOL>", "docstring": "True if the connection is open, false otherwise", "id": "f13981:c0:m2"}
{"signature": "def get_resolver(schema):", "body": "store = {}<EOL>for file in schemas.values():<EOL><INDENT>s = load_json_from_file(file)<EOL>store[s[\"<STR_LIT:id>\"]] = s<EOL><DEDENT>return jsonschema.RefResolver.from_schema(schema, store=store)<EOL>", "docstring": "Return a jsonschema.RefResolver for the schemas.\n\n    All schemas returned be get_schemas() are resolved locally.", "id": "f13984:m1"}
{"signature": "def basic(username, password):", "body": "none()<EOL>_config.username = username<EOL>_config.password = password<EOL>", "docstring": "Add basic authentication to the requests of the clients.", "id": "f13985:m1"}
{"signature": "def auth_settings(self):", "body": "if self.api_key:<EOL><INDENT>return {<EOL>'<STR_LIT>':<EOL>{<EOL>'<STR_LIT:type>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:key>': '<STR_LIT>',<EOL>'<STR_LIT:value>': self.get_api_key_with_prefix('<STR_LIT>')<EOL>}<EOL>}<EOL><DEDENT>if self.username is not None:<EOL><INDENT>return {<EOL>'<STR_LIT>':<EOL>{<EOL>'<STR_LIT:type>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:key>': '<STR_LIT>',<EOL>'<STR_LIT:value>': self.get_basic_auth_token()<EOL>},<EOL>}<EOL><DEDENT>return {}<EOL>", "docstring": "Gets Auth Settings dict for api client.\n\n:return: The Auth Settings information dict.\n\nThis function has been changed from the auto-generated content.", "id": "f13987:c0:m9"}
{"signature": "def get_basic_auth_token(self):", "body": "return urllib3.util.make_headers(basic_auth=self.username + '<STR_LIT::>' + self.password).get('<STR_LIT>')<EOL>", "docstring": "Gets HTTP basic authentication header (string).\n\n:return: The token for basic HTTP authentication.", "id": "f13987:c0:m8"}
{"signature": "@property<EOL><INDENT>def logger_format(self):<DEDENT>", "body": "return self.__logger_format<EOL>", "docstring": "Gets the logger_format.", "id": "f13987:c0:m5"}
{"signature": "@logger_format.setter<EOL><INDENT>def logger_format(self, value):<DEDENT>", "body": "self.__logger_format = value<EOL>self.logger_formatter = logging.Formatter(self.__logger_format)<EOL>", "docstring": "Sets the logger_format.\n\nThe logger_formatter will be updated when sets logger_format.\n\n:param value: The format string.\n:type: str", "id": "f13987:c0:m6"}
{"signature": "def __init__(self):", "body": "<EOL>self.host = \"<STR_LIT>\"<EOL>self.api_client = None<EOL>self.temp_folder_path = None<EOL>self.api_key = {}<EOL>self.api_key_prefix = {}<EOL>self.username = \"<STR_LIT>\"<EOL>self.password = \"<STR_LIT>\"<EOL>self.logger = {}<EOL>self.logger[\"<STR_LIT>\"] = logging.getLogger(\"<STR_LIT>\")<EOL>self.logger[\"<STR_LIT>\"] = logging.getLogger(\"<STR_LIT>\")<EOL>self.logger_format = '<STR_LIT>'<EOL>self.logger_stream_handler = None<EOL>self.logger_file_handler = None<EOL>self.logger_file = None<EOL>self.debug = False<EOL>self.verify_ssl = True<EOL>self.ssl_ca_cert = None<EOL>self.cert_file = None<EOL>self.key_file = None<EOL>", "docstring": "Constructor", "id": "f13987:c0:m0"}
{"signature": "def to_debug_report(self):", "body": "return \"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\".format(env=sys.platform, pyversion=sys.version)<EOL>", "docstring": "Gets the essential information for debugging.\n\n:return: The report for debugging.", "id": "f13987:c0:m10"}
{"signature": "@property<EOL><INDENT>def logger_file(self):<DEDENT>", "body": "return self.__logger_file<EOL>", "docstring": "Gets the logger_file.", "id": "f13987:c0:m1"}
{"signature": "def get_schemas():", "body": "schemas = {}<EOL>for name in os.listdir(JSON_PATH):<EOL><INDENT>if name not in NO_SCHEMA:<EOL><INDENT>schemas[name] = Schema(name)<EOL><DEDENT><DEDENT>return schemas<EOL>", "docstring": "Return a dict of schema names mapping to a Schema.\n\n    The schema is of type schul_cloud_resources_api_v1.schema.Schema", "id": "f13988:m1"}
{"signature": "def is_valid(self, object):", "body": "try:<EOL><INDENT>self.validate(object)<EOL><DEDENT>except ValidationFailed:<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "Return whether an object matches the schema.", "id": "f13988:c0:m6"}
{"signature": "def get_resolver(self):", "body": "store = {}<EOL>for schema in get_schemas().values():<EOL><INDENT>store[schema.get_uri()] = schema.get_schema()<EOL><DEDENT>schema = self.get_schema()<EOL>return jsonschema.RefResolver.from_schema(schema, store=store)<EOL>", "docstring": "Return a jsonschema.RefResolver for the schemas.\n\n        All schemas returned be get_schemas() are resolved locally.", "id": "f13988:c0:m4"}
{"signature": "def validate(self, object):", "body": "resolver=self.get_resolver()<EOL>jsonschema.validate(object, self.get_schema(), resolver=resolver)<EOL>", "docstring": "Validate an object against the schema.\n\n        This function just passes if the schema matches the object.\n        If the object does not match the schema, a ValidationException is raised.\n        This error allows debugging.", "id": "f13988:c0:m5"}
{"signature": "def get_invalid_examples(self):", "body": "path = os.path.join(self._get_schema_folder(), \"<STR_LIT>\", \"<STR_LIT>\")<EOL>return list(_get_json_content_from_folder(path))<EOL>", "docstring": "Return a list of examples which violate the schema.", "id": "f13988:c0:m8"}
{"signature": "def __init__(self, name):", "body": "self._name = name<EOL>", "docstring": "Create a schema with a given name.", "id": "f13988:c0:m0"}
{"signature": "def setUp(self):", "body": "auth.none()<EOL>self.config = Configuration()<EOL>", "docstring": "Create the default state.\n\n        We have global state so we want to remove the side effects.", "id": "f13989:c0:m0"}
{"signature": "@property<EOL><INDENT>def last_error(self):<DEDENT>", "body": "return self._err<EOL>", "docstring": "Returns the last error which may have occured.", "id": "f14034:c3:m24"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def close(self):<DEDENT>", "body": "yield from self._close(Client.CLOSED)<EOL>", "docstring": "Closes the socket to which we are connected and\nsets the client to be in the CLOSED state.\nNo further reconnections occur once reaching this point.", "id": "f14034:c3:m3"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def flush(self, timeout=<NUM_LIT>):<DEDENT>", "body": "if timeout <= <NUM_LIT:0>:<EOL><INDENT>raise ErrBadTimeout<EOL><DEDENT>if self.is_closed:<EOL><INDENT>raise ErrConnectionClosed<EOL><DEDENT>future = asyncio.Future(loop=self._loop)<EOL>try:<EOL><INDENT>yield from self._send_ping(future)<EOL>yield from asyncio.wait_for(future, timeout, loop=self._loop)<EOL><DEDENT>except asyncio.TimeoutError:<EOL><INDENT>future.cancel()<EOL>raise ErrTimeout<EOL><DEDENT>", "docstring": "Sends a ping to the server expecting a pong back ensuring\nwhat we have written so far has made it to the server and\nalso enabling measuring of roundtrip time.\nIn case a pong is not returned within the allowed timeout,\nthen it will raise ErrTimeout.", "id": "f14034:c3:m19"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def _process_connect_init(self):<DEDENT>", "body": "self._status = Client.CONNECTING<EOL>connection_completed = self._io_reader.readline()<EOL>info_line = yield from asyncio.wait_for(connection_completed, self.options[\"<STR_LIT>\"])<EOL>if INFO_OP not in info_line:<EOL><INDENT>raise NatsError(\"<STR_LIT>\")<EOL><DEDENT>_, info = info_line.split(INFO_OP + _SPC_, <NUM_LIT:1>)<EOL>try:<EOL><INDENT>srv_info = json.loads(info.decode())<EOL><DEDENT>except:<EOL><INDENT>raise NatsError(\"<STR_LIT>\")<EOL><DEDENT>self._process_info(srv_info)<EOL>self._server_info = srv_info<EOL>if '<STR_LIT>' in self._server_info:<EOL><INDENT>self._max_payload = self._server_info[\"<STR_LIT>\"]<EOL><DEDENT>if '<STR_LIT>' in self._server_info and self._server_info['<STR_LIT>']:<EOL><INDENT>ssl_context = None<EOL>if \"<STR_LIT>\" in self.options:<EOL><INDENT>ssl_context = self.options.get('<STR_LIT>')<EOL><DEDENT>elif self._current_server.uri.scheme == '<STR_LIT>':<EOL><INDENT>ssl_context = ssl.create_default_context()<EOL><DEDENT>else:<EOL><INDENT>raise NatsError('<STR_LIT>')<EOL><DEDENT>transport = self._io_writer.transport<EOL>sock = transport.get_extra_info('<STR_LIT>')<EOL>if not sock:<EOL><INDENT>raise NatsError('<STR_LIT>')<EOL><DEDENT>yield from self._io_writer.drain()  <EOL>self._io_reader, self._io_writer =yield from asyncio.open_connection(<EOL>loop=self._loop,<EOL>limit=DEFAULT_BUFFER_SIZE,<EOL>sock=sock,<EOL>ssl=ssl_context,<EOL>server_hostname=self._current_server.uri.hostname,<EOL>)<EOL><DEDENT>if self.is_reconnecting:<EOL><INDENT>self._ps.reset()<EOL><DEDENT>connect_cmd = self._connect_command()<EOL>self._io_writer.write(connect_cmd)<EOL>self._io_writer.write(PING_PROTO)<EOL>yield from self._io_writer.drain()<EOL>next_op = yield from self._io_reader.readline()<EOL>if self.options[\"<STR_LIT>\"] and OK_OP in next_op:<EOL><INDENT>next_op = yield from self._io_reader.readline()<EOL><DEDENT>if ERR_OP in next_op:<EOL><INDENT>err_line = next_op.decode()<EOL>_, err_msg = err_line.split(\"<STR_LIT:U+0020>\", <NUM_LIT:1>)<EOL>raise NatsError(\"<STR_LIT>\" + err_msg.rstrip('<STR_LIT:\\r\\n>'))<EOL><DEDENT>if PONG_PROTO in next_op:<EOL><INDENT>self._status = Client.CONNECTED<EOL><DEDENT>self._reading_task = self._loop.create_task(self._read_loop())<EOL>self._pongs = []<EOL>self._pings_outstanding = <NUM_LIT:0><EOL>self._ping_interval_task = self._loop.create_task(<EOL>self._ping_interval())<EOL>self._flusher_task = self._loop.create_task(self._flusher())<EOL>", "docstring": "Process INFO received from the server and CONNECT to the server\nwith authentication.  It is also responsible of setting up the\nreading and ping interval tasks from the client.", "id": "f14034:c3:m46"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def request(self, subject, payload, timeout=<NUM_LIT:0.5>, expected=<NUM_LIT:1>, cb=None):<DEDENT>", "body": "if self.is_draining_pubs:<EOL><INDENT>raise ErrConnectionDraining<EOL><DEDENT>if cb is not None:<EOL><INDENT>next_inbox = INBOX_PREFIX[:]<EOL>next_inbox.extend(self._nuid.next())<EOL>inbox = next_inbox.decode()<EOL>sid = yield from self.subscribe(inbox, cb=cb)<EOL>yield from self.auto_unsubscribe(sid, expected)<EOL>yield from self.publish_request(subject, inbox, payload)<EOL>return sid<EOL><DEDENT>if self._resp_sub_prefix is None:<EOL><INDENT>self._resp_map = {}<EOL>self._resp_sub_prefix = INBOX_PREFIX[:]<EOL>self._resp_sub_prefix.extend(self._nuid.next())<EOL>self._resp_sub_prefix.extend(b'<STR_LIT:.>')<EOL>resp_mux_subject = self._resp_sub_prefix[:]<EOL>resp_mux_subject.extend(b'<STR_LIT:*>')<EOL>sub = Subscription(subject=resp_mux_subject.decode())<EOL>sub.pending_msgs_limit = DEFAULT_SUB_PENDING_MSGS_LIMIT<EOL>sub.pending_bytes_limit = DEFAULT_SUB_PENDING_BYTES_LIMIT<EOL>sub.pending_queue = asyncio.Queue(<EOL>maxsize=sub.pending_msgs_limit,<EOL>loop=self._loop,<EOL>)<EOL>@asyncio.coroutine<EOL>def wait_for_msgs():<EOL><INDENT>nonlocal sub<EOL>while True:<EOL><INDENT>try:<EOL><INDENT>msg = yield from sub.pending_queue.get()<EOL>token = msg.subject[INBOX_PREFIX_LEN:]<EOL>try:<EOL><INDENT>fut = self._resp_map[token]<EOL>fut.set_result(msg)<EOL>del self._resp_map[token]<EOL><DEDENT>except (asyncio.CancelledError, asyncio.InvalidStateError):<EOL><INDENT>del self._resp_map[token]<EOL>continue<EOL><DEDENT>except KeyError:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>except asyncio.CancelledError:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>sub.wait_for_msgs_task = self._loop.create_task(<EOL>wait_for_msgs())<EOL>self._ssid += <NUM_LIT:1><EOL>ssid = self._ssid<EOL>self._subs[ssid] = sub<EOL>yield from self._subscribe(sub, ssid)<EOL><DEDENT>token = self._nuid.next()<EOL>inbox = self._resp_sub_prefix[:]<EOL>inbox.extend(token)<EOL>future = asyncio.Future(loop=self._loop)<EOL>self._resp_map[token.decode()] = future<EOL>yield from self.publish_request(subject, inbox.decode(), payload)<EOL>try:<EOL><INDENT>msg = yield from asyncio.wait_for(future, timeout, loop=self._loop)<EOL>return msg<EOL><DEDENT>except asyncio.TimeoutError:<EOL><INDENT>future.cancel()<EOL>raise ErrTimeout<EOL><DEDENT>", "docstring": "Implements the request/response pattern via pub/sub\nusing a single wildcard subscription that handles\nthe responses.", "id": "f14034:c3:m15"}
{"signature": "def _process_info(self, info):", "body": "if '<STR_LIT>' in info:<EOL><INDENT>if info['<STR_LIT>']:<EOL><INDENT>connect_urls = []<EOL>for connect_url in info['<STR_LIT>']:<EOL><INDENT>uri = urlparse(\"<STR_LIT>\" % connect_url)<EOL>srv = Srv(uri)<EOL>srv.discovered = True<EOL>should_add = True<EOL>for s in self._server_pool:<EOL><INDENT>if uri.netloc == s.uri.netloc:<EOL><INDENT>should_add = False<EOL><DEDENT><DEDENT>if should_add:<EOL><INDENT>connect_urls.append(srv)<EOL><DEDENT><DEDENT>if self.options[\"<STR_LIT>\"] is not True:<EOL><INDENT>shuffle(connect_urls)<EOL><DEDENT>for srv in connect_urls:<EOL><INDENT>self._server_pool.append(srv)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Process INFO lines sent by the server to reconfigure client\nwith latest updates from cluster to enable server discovery.", "id": "f14034:c3:m45"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def timed_request(self, subject, payload, timeout=<NUM_LIT:0.5>):<DEDENT>", "body": "next_inbox = INBOX_PREFIX[:]<EOL>next_inbox.extend(self._nuid.next())<EOL>inbox = next_inbox.decode()<EOL>future = asyncio.Future(loop=self._loop)<EOL>sid = yield from self.subscribe(inbox, future=future, max_msgs=<NUM_LIT:1>)<EOL>yield from self.auto_unsubscribe(sid, <NUM_LIT:1>)<EOL>yield from self.publish_request(subject, inbox, payload)<EOL>try:<EOL><INDENT>msg = yield from asyncio.wait_for(future, timeout, loop=self._loop)<EOL>return msg<EOL><DEDENT>except asyncio.TimeoutError:<EOL><INDENT>future.cancel()<EOL>raise ErrTimeout<EOL><DEDENT>", "docstring": "Implements the request/response pattern via pub/sub\nusing an ephemeral subscription which will be published\nwith a limited interest of 1 reply returning the response\nor raising a Timeout error.\n\n  ->> SUB _INBOX.2007314fe0fcb2cdc2a2914c1 90\n  ->> UNSUB 90 1\n  ->> PUB hello _INBOX.2007314fe0fcb2cdc2a2914c1 5\n  ->> MSG_PAYLOAD: world\n  <<- MSG hello 2 _INBOX.2007314fe0fcb2cdc2a2914c1 5", "id": "f14034:c3:m16"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def _select_next_server(self):<DEDENT>", "body": "while True:<EOL><INDENT>if len(self._server_pool) == <NUM_LIT:0>:<EOL><INDENT>self._current_server = None<EOL>raise ErrNoServers<EOL><DEDENT>now = time.monotonic()<EOL>s = self._server_pool.pop(<NUM_LIT:0>)<EOL>if self.options[\"<STR_LIT>\"] > <NUM_LIT:0>:<EOL><INDENT>if s.reconnects > self.options[\"<STR_LIT>\"]:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>self._server_pool.append(s)<EOL>if s.last_attempt is not None and now < s.last_attempt + self.options[\"<STR_LIT>\"]:<EOL><INDENT>yield from asyncio.sleep(self.options[\"<STR_LIT>\"], loop=self._loop)<EOL><DEDENT>try:<EOL><INDENT>s.last_attempt = time.monotonic()<EOL>r, w = yield from asyncio.open_connection(<EOL>s.uri.hostname,<EOL>s.uri.port,<EOL>loop=self._loop,<EOL>limit=DEFAULT_BUFFER_SIZE)<EOL>self._current_server = s<EOL>self._bare_io_reader = self._io_reader = r<EOL>self._bare_io_writer = self._io_writer = w<EOL>break<EOL><DEDENT>except Exception as e:<EOL><INDENT>s.last_attempt = time.monotonic()<EOL>s.reconnects += <NUM_LIT:1><EOL>self._err = e<EOL>if self._error_cb is not None:<EOL><INDENT>yield from self._error_cb(e)<EOL><DEDENT>continue<EOL><DEDENT><DEDENT>", "docstring": "Looks up in the server pool for an available server\nand attempts to connect.", "id": "f14034:c3:m35"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def _process_msg(self, sid, subject, reply, data):<DEDENT>", "body": "payload_size = len(data)<EOL>self.stats['<STR_LIT>'] += <NUM_LIT:1><EOL>self.stats['<STR_LIT>'] += payload_size<EOL>sub = self._subs.get(sid)<EOL>if sub is None:<EOL><INDENT>return<EOL><DEDENT>sub.received += <NUM_LIT:1><EOL>if sub.max_msgs > <NUM_LIT:0> and sub.received >= sub.max_msgs:<EOL><INDENT>self._subs.pop(sid, None)<EOL><DEDENT>msg = self._build_message(subject, reply, data)<EOL>if sub.future is not None:<EOL><INDENT>if sub.future.cancelled():<EOL><INDENT>return<EOL><DEDENT>sub.future.set_result(msg)<EOL>return<EOL><DEDENT>try:<EOL><INDENT>sub.pending_size += payload_size<EOL>if sub.pending_size >= sub.pending_bytes_limit:<EOL><INDENT>sub.pending_size -= payload_size<EOL>if self._error_cb is not None:<EOL><INDENT>yield from self._error_cb(<EOL>ErrSlowConsumer(subject=subject, sid=sid))<EOL><DEDENT>return<EOL><DEDENT>sub.pending_queue.put_nowait(msg)<EOL><DEDENT>except asyncio.QueueFull:<EOL><INDENT>if self._error_cb is not None:<EOL><INDENT>yield from self._error_cb(<EOL>ErrSlowConsumer(subject=subject, sid=sid))<EOL><DEDENT><DEDENT>", "docstring": "Process MSG sent by server.", "id": "f14034:c3:m42"}
{"signature": "def _process_disconnect(self):", "body": "self._status = Client.DISCONNECTED<EOL>", "docstring": "Process disconnection from the server and set client status\nto DISCONNECTED.", "id": "f14034:c3:m44"}
{"signature": "@asyncio.coroutine<EOL><INDENT>def drain(self, sid=None):<DEDENT>", "body": "if self.is_draining:<EOL><INDENT>return<EOL><DEDENT>if self.is_closed:<EOL><INDENT>raise ErrConnectionClosed<EOL><DEDENT>if self.is_connecting or self.is_reconnecting:<EOL><INDENT>raise ErrConnectionReconnecting<EOL><DEDENT>if sid is not None:<EOL><INDENT>return self._drain_sub(sid)<EOL><DEDENT>self._status = Client.DRAINING_SUBS<EOL>drain_tasks = []<EOL>for ssid, sub in self._subs.items():<EOL><INDENT>task = self._drain_sub(ssid)<EOL>drain_tasks.append(task)<EOL><DEDENT>drain_is_done = asyncio.gather(*drain_tasks)<EOL>try:<EOL><INDENT>yield from asyncio.wait_for(drain_is_done, self.options[\"<STR_LIT>\"])<EOL><DEDENT>except asyncio.TimeoutError:<EOL><INDENT>drain_is_done.exception()<EOL>drain_is_done.cancel()<EOL>if self._error_cb is not None:<EOL><INDENT>yield from self._error_cb(ErrDrainTimeout)<EOL><DEDENT><DEDENT>except asyncio.CancelledError:<EOL><INDENT>pass<EOL><DEDENT>finally:<EOL><INDENT>self._status = Client.DRAINING_PUBS<EOL>yield from self.flush()<EOL>yield from self._close(Client.CLOSED)<EOL><DEDENT>", "docstring": "Drain will put a connection into a drain state. All subscriptions will\nimmediately be put into a drain state. Upon completion, the publishers\nwill be drained and can not publish any additional messages. Upon draining\nof the publishers, the connection will be closed. Use the `closed_cb'\noption to know when the connection has moved from draining to closed.\n\nIf a sid is passed, just the subscription with that sid will be drained\nwithout closing the connection.", "id": "f14034:c3:m5"}
{"signature": "@contextlib.contextmanager<EOL>def _create_file():", "body": "f = wave.open('<STR_LIT>', mode='<STR_LIT:wb>')<EOL>f.setnchannels(<NUM_LIT:2>)<EOL>p = pyaudio.PyAudio()<EOL>f.setsampwidth(p.get_sample_size(pyaudio.paInt16))<EOL>f.setframerate(p.get_default_input_device_info()['<STR_LIT>'])<EOL>try:<EOL><INDENT>yield f<EOL><DEDENT>finally:<EOL><INDENT>f.close()<EOL><DEDENT>", "docstring": "Returns a file handle which is used to record audio", "id": "f14041:m0"}
{"signature": "def add(self, name, value):", "body": "clone = self._clone()<EOL>clone._qsl = [p for p in self._qsl<EOL>if not(p[<NUM_LIT:0>] == name and p[<NUM_LIT:1>] == value)]<EOL>clone._qsl.append((name, value,))<EOL>return clone<EOL>", "docstring": "Append a value to multiple value parameter.", "id": "f14051:c0:m2"}
{"signature": "def decompose(hangul_letter):", "body": "from . import checker<EOL>if len(hangul_letter) < <NUM_LIT:1>:<EOL><INDENT>raise NotLetterException('<STR_LIT>')<EOL><DEDENT>elif not checker.is_hangul(hangul_letter):<EOL><INDENT>raise NotHangulException('<STR_LIT>')<EOL><DEDENT>if hangul_letter in CHO:<EOL><INDENT>return hangul_letter, '<STR_LIT>', '<STR_LIT>'<EOL><DEDENT>if hangul_letter in JOONG:<EOL><INDENT>return '<STR_LIT>', hangul_letter, '<STR_LIT>'<EOL><DEDENT>if hangul_letter in JONG:<EOL><INDENT>return '<STR_LIT>', '<STR_LIT>', hangul_letter<EOL><DEDENT>code = hangul_index(hangul_letter)<EOL>cho, joong, jong = decompose_index(code)<EOL>if cho < <NUM_LIT:0>:<EOL><INDENT>cho = <NUM_LIT:0><EOL><DEDENT>try:<EOL><INDENT>return CHO[cho], JOONG[joong], JONG[jong]<EOL><DEDENT>except:<EOL><INDENT>print(\"<STR_LIT>\"%(cho, joong, jong))<EOL>print(\"<STR_LIT>\" %( JOONG[joong].encode(\"<STR_LIT:utf8>\"), JONG[jong].encode('<STR_LIT:utf8>')))<EOL>raise Exception()<EOL><DEDENT>", "docstring": "This function returns letters by decomposing the specified Hangul letter.", "id": "f14071:m3"}
{"signature": "def compose(chosung, joongsung, jongsung=u'<STR_LIT>'):", "body": "if jongsung is None: jongsung = u'<STR_LIT>'<EOL>try:<EOL><INDENT>chosung_index = CHO.index(chosung)<EOL>joongsung_index = JOONG.index(joongsung)<EOL>jongsung_index = JONG.index(jongsung)<EOL><DEDENT>except Exception:<EOL><INDENT>raise NotHangulException('<STR_LIT>')<EOL><DEDENT>return unichr(<NUM_LIT> + chosung_index * NUM_JOONG * NUM_JONG + joongsung_index * NUM_JONG + jongsung_index)<EOL>", "docstring": "This function returns a Hangul letter by composing the specified chosung, joongsung, and jongsung.\n    @param chosung\n    @param joongsung\n    @param jongsung the terminal Hangul letter. This is optional if you do not need a jongsung.", "id": "f14071:m0"}
{"signature": "def has_jongsung(letter):", "body": "if len(letter) != <NUM_LIT:1>:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>if not is_hangul(letter):<EOL><INDENT>raise NotHangulException('<STR_LIT>')<EOL><DEDENT>code = lt.hangul_index(letter)<EOL>return code % NUM_JONG > <NUM_LIT:0><EOL>", "docstring": "Check whether this letter contains Jongsung", "id": "f14073:m4"}
{"signature": "def kill_friend(pid, delay=<NUM_LIT:0>):", "body": "sleep(delay)<EOL>try:<EOL><INDENT>os.kill(pid, SIGKILL)<EOL><DEDENT>except (PermissionError, ProcessLookupError) as e:<EOL><INDENT>if psutil.pid_exists(pid):<EOL><INDENT>util.debug(\"<STR_LIT>\")<EOL>raise e<EOL><DEDENT>util.debug(\"<STR_LIT>\".format(pid))<EOL><DEDENT>", "docstring": "Function that send SIGKILL at process pid", "id": "f14082:m6"}
{"signature": "def clean_warning_registry():", "body": "warnings.resetwarnings()<EOL>reg = \"<STR_LIT>\"<EOL>for mod_name, mod in list(sys.modules.items()):<EOL><INDENT>if hasattr(mod, reg):<EOL><INDENT>getattr(mod, reg).clear()<EOL><DEDENT><DEDENT>", "docstring": "Safe way to reset warnings.", "id": "f14082:m0"}
{"signature": "def return_instance(cls):", "body": "return cls()<EOL>", "docstring": "Function that returns a instance of cls", "id": "f14082:m8"}
{"signature": "def raise_error(etype=UnpicklingError, message=None):", "body": "raise etype(message)<EOL>", "docstring": "Function that raises an Exception in process", "id": "f14082:m7"}
{"signature": "def check_pids_exist_then_sleep(arg):", "body": "time, pids = arg<EOL>sleep(time)<EOL>res = True<EOL>for p in pids:<EOL><INDENT>res &= psutil.pid_exists(p)<EOL><DEDENT>return res<EOL>", "docstring": "Sleep for some time before returning\n    and check if all the passed pid exist", "id": "f14082:m5"}
{"signature": "def initializer_event(event):", "body": "global _test_event<EOL>_test_event = event<EOL>", "docstring": "Initializer that set a global test event for test synchronization", "id": "f14089:m0"}
{"signature": "def captured_stderr():", "body": "return captured_output(\"<STR_LIT>\")<EOL>", "docstring": "Capture the output of sys.stderr:\n\n       with captured_stderr() as stderr:\n           print(\"hello\", file=sys.stderr)\n       self.assertEqual(stderr.getvalue(), \"hello\\\\n\")", "id": "f14090:m1"}
{"signature": "def _sendback_result(result_queue, work_id, result=None, exception=None):", "body": "try:<EOL><INDENT>result_queue.put(_ResultItem(work_id, result=result,<EOL>exception=exception))<EOL><DEDENT>except BaseException as e:<EOL><INDENT>exc = _ExceptionWithTraceback(e)<EOL>result_queue.put(_ResultItem(work_id, exception=exc))<EOL><DEDENT>", "docstring": "Safely send back the given result or exception", "id": "f14108:m4"}
{"signature": "def map(self, fn, *iterables, **kwargs):", "body": "timeout = kwargs.get('<STR_LIT>', None)<EOL>chunksize = kwargs.get('<STR_LIT>', <NUM_LIT:1>)<EOL>if chunksize < <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>results = super(ProcessPoolExecutor, self).map(<EOL>partial(_process_chunk, fn), _get_chunks(chunksize, *iterables),<EOL>timeout=timeout)<EOL>return _chain_from_iterable_of_lists(results)<EOL>", "docstring": "Returns an iterator equivalent to map(fn, iter).\n\n        Args:\n            fn: A callable that will take as many arguments as there are\n                passed iterables.\n            timeout: The maximum number of seconds to wait. If None, then there\n                is no limit on the wait time.\n            chunksize: If greater than one, the iterables will be chopped into\n                chunks of size chunksize and submitted to the process pool.\n                If set to one, the items in the list will be sent one at a\n                time.\n\n        Returns:\n            An iterator equivalent to: map(func, *iterables) but the calls may\n            be evaluated out-of-order.\n\n        Raises:\n            TimeoutError: If the entire result iterator could not be generated\n                before the given timeout.\n            Exception: If fn(*args) raises for any values.", "id": "f14108:c12:m6"}
{"signature": "def dump(obj, file, reducers=None, protocol=None):", "body": "global _LokyPickler<EOL>_LokyPickler(file, reducers=reducers, protocol=protocol).dump(obj)<EOL>", "docstring": "Replacement for pickle.dump() using _LokyPickler.", "id": "f14112:m7"}
{"signature": "def ensure_running(self):", "body": "with self._lock:<EOL><INDENT>if self._fd is not None:<EOL><INDENT>if self._check_alive():<EOL><INDENT>return<EOL><DEDENT>os.close(self._fd)<EOL>try:<EOL><INDENT>os.waitpid(self._pid, <NUM_LIT:0>)<EOL><DEDENT>except OSError:<EOL><INDENT>pass<EOL><DEDENT>self._fd = None<EOL>self._pid = None<EOL>warnings.warn('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>fds_to_pass = []<EOL>try:<EOL><INDENT>fds_to_pass.append(sys.stderr.fileno())<EOL><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT>r, w = os.pipe()<EOL>cmd = '<STR_LIT>'.format(<EOL>main.__module__, r, VERBOSE)<EOL>try:<EOL><INDENT>fds_to_pass.append(r)<EOL>exe = spawn.get_executable()<EOL>args = [exe] + util._args_from_interpreter_flags()<EOL>if sys.version_info[:<NUM_LIT:2>] <= (<NUM_LIT:3>, <NUM_LIT:3>):<EOL><INDENT>import re<EOL>for i in range(<NUM_LIT:1>, len(args)):<EOL><INDENT>args[i] = re.sub(\"<STR_LIT>\", \"<STR_LIT>\", args[i])<EOL><DEDENT><DEDENT>args += ['<STR_LIT:-c>', cmd]<EOL>util.debug(\"<STR_LIT>\".format(args))<EOL>try:<EOL><INDENT>if _HAVE_SIGMASK:<EOL><INDENT>signal.pthread_sigmask(signal.SIG_BLOCK,<EOL>_IGNORED_SIGNALS)<EOL><DEDENT>pid = spawnv_passfds(exe, args, fds_to_pass)<EOL><DEDENT>finally:<EOL><INDENT>if _HAVE_SIGMASK:<EOL><INDENT>signal.pthread_sigmask(signal.SIG_UNBLOCK,<EOL>_IGNORED_SIGNALS)<EOL><DEDENT><DEDENT><DEDENT>except BaseException:<EOL><INDENT>os.close(w)<EOL>raise<EOL><DEDENT>else:<EOL><INDENT>self._fd = w<EOL>self._pid = pid<EOL><DEDENT>finally:<EOL><INDENT>os.close(r)<EOL><DEDENT><DEDENT>", "docstring": "Make sure that semaphore tracker process is running.\n\n        This can be run from any process.  Usually a child process will use\n        the semaphore created by its parent.", "id": "f14118:c0:m2"}
{"signature": "def start(self, initializer=None, initargs=()):", "body": "assert self._state.value == State.INITIAL<EOL>if (initializer is not None<EOL>and not hasattr(initializer, '<STR_LIT>')):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>reader, writer = mp.Pipe(duplex=False)<EOL>self._process = Process(<EOL>target=type(self)._run_server,<EOL>args=(self._registry, self._address, bytes(self._authkey),<EOL>self._serializer, writer, initializer, initargs),<EOL>)<EOL>ident = '<STR_LIT::>'.join(str(i) for i in self._process._identity)<EOL>self._process.name = type(self).__name__ + '<STR_LIT:->' + ident<EOL>self._process.start()<EOL>writer.close()<EOL>self._address = reader.recv()<EOL>reader.close()<EOL>self._state.value = State.STARTED<EOL>self.shutdown = mp.util.Finalize(<EOL>self, type(self)._finalize_manager,<EOL>args=(self._process, self._address, self._authkey,<EOL>self._state, self._Client),<EOL>exitpriority=<NUM_LIT:0><EOL>)<EOL>", "docstring": "Spawn a server process for this manager object", "id": "f14120:c0:m0"}
{"signature": "def get_preparation_data(name, init_main_module=True):", "body": "_check_not_importing_main()<EOL>d = dict(<EOL>log_to_stderr=util._log_to_stderr,<EOL>authkey=bytes(process.current_process().authkey),<EOL>)<EOL>if util._logger is not None:<EOL><INDENT>d['<STR_LIT>'] = util._logger.getEffectiveLevel()<EOL>if len(util._logger.handlers) > <NUM_LIT:0>:<EOL><INDENT>h = util._logger.handlers[<NUM_LIT:0>]<EOL>d['<STR_LIT>'] = h.formatter._fmt<EOL><DEDENT><DEDENT>sys_path = [p for p in sys.path]<EOL>try:<EOL><INDENT>i = sys_path.index('<STR_LIT>')<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>sys_path[i] = process.ORIGINAL_DIR<EOL><DEDENT>d.update(<EOL>name=name,<EOL>sys_path=sys_path,<EOL>sys_argv=sys.argv,<EOL>orig_dir=process.ORIGINAL_DIR,<EOL>dir=os.getcwd()<EOL>)<EOL>if sys.platform != \"<STR_LIT:win32>\":<EOL><INDENT>from . import semaphore_tracker<EOL>semaphore_tracker.ensure_running()<EOL>d['<STR_LIT>'] = semaphore_tracker._semaphore_tracker._pid<EOL><DEDENT>if init_main_module:<EOL><INDENT>main_module = sys.modules['<STR_LIT:__main__>']<EOL>try:<EOL><INDENT>main_mod_name = getattr(main_module.__spec__, \"<STR_LIT:name>\", None)<EOL><DEDENT>except BaseException:<EOL><INDENT>main_mod_name = None<EOL><DEDENT>if main_mod_name is not None:<EOL><INDENT>d['<STR_LIT>'] = main_mod_name<EOL><DEDENT>elif sys.platform != '<STR_LIT:win32>' or (not WINEXE and not WINSERVICE):<EOL><INDENT>main_path = getattr(main_module, '<STR_LIT>', None)<EOL>if main_path is not None:<EOL><INDENT>if (not os.path.isabs(main_path) and<EOL>process.ORIGINAL_DIR is not None):<EOL><INDENT>main_path = os.path.join(process.ORIGINAL_DIR, main_path)<EOL><DEDENT>d['<STR_LIT>'] = os.path.normpath(main_path)<EOL>d['<STR_LIT>'] = d['<STR_LIT>']<EOL><DEDENT><DEDENT><DEDENT>return d<EOL>", "docstring": "Return info about parent needed by child to unpickle process object", "id": "f14121:m2"}
{"signature": "def _recursive_terminate_without_psutil(process):", "body": "try:<EOL><INDENT>_recursive_terminate(process.pid)<EOL><DEDENT>except OSError as e:<EOL><INDENT>warnings.warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>process.terminate()<EOL><DEDENT>process.join()<EOL>", "docstring": "Terminate a process and its descendants.", "id": "f14125:m3"}
{"signature": "def _recursive_terminate(pid):", "body": "if sys.platform == \"<STR_LIT:win32>\":<EOL><INDENT>try:<EOL><INDENT>subprocess.check_output(<EOL>[\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", str(pid)],<EOL>stderr=None)<EOL><DEDENT>except subprocess.CalledProcessError as e:<EOL><INDENT>if e.returncode not in [<NUM_LIT:1>, <NUM_LIT>, <NUM_LIT:255>]:<EOL><INDENT>raise<EOL><DEDENT>elif e.returncode == <NUM_LIT:1>:<EOL><INDENT>try:<EOL><INDENT>os.kill(pid, signal.SIGTERM)<EOL><DEDENT>except OSError as e:<EOL><INDENT>if e.errno != errno.ESRCH:<EOL><INDENT>raise<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>children_pids = subprocess.check_output(<EOL>[\"<STR_LIT>\", \"<STR_LIT>\", str(pid)],<EOL>stderr=None<EOL>)<EOL><DEDENT>except subprocess.CalledProcessError as e:<EOL><INDENT>if e.returncode == <NUM_LIT:1>:<EOL><INDENT>children_pids = b'<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>children_pids = children_pids.decode().split('<STR_LIT:\\n>')[:-<NUM_LIT:1>]<EOL>for cpid in children_pids:<EOL><INDENT>cpid = int(cpid)<EOL>_recursive_terminate(cpid)<EOL><DEDENT>try:<EOL><INDENT>os.kill(pid, signal.SIGTERM)<EOL><DEDENT>except OSError as e:<EOL><INDENT>if e.errno != errno.ESRCH:<EOL><INDENT>raise<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Recursively kill the descendants of a process before killing it.", "id": "f14125:m4"}
{"signature": "def wait(object_list, timeout=None):", "body": "if timeout is not None:<EOL><INDENT>if timeout <= <NUM_LIT:0>:<EOL><INDENT>return _poll(object_list, <NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>deadline = monotonic() + timeout<EOL><DEDENT><DEDENT>while True:<EOL><INDENT>try:<EOL><INDENT>return _poll(object_list, timeout)<EOL><DEDENT>except (OSError, IOError, socket.error) as e:  <EOL><INDENT>if e.errno != errno.EINTR:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>if timeout is not None:<EOL><INDENT>timeout = deadline - monotonic()<EOL><DEDENT><DEDENT>", "docstring": "Wait till an object in object_list is ready/readable.\nReturns list of those objects which are ready/readable.", "id": "f14126:m0"}
{"signature": "def get_reusable_executor(max_workers=None, context=None, timeout=<NUM_LIT:10>,<EOL>kill_workers=False, reuse=\"<STR_LIT>\",<EOL>job_reducers=None, result_reducers=None,<EOL>initializer=None, initargs=()):", "body": "with _executor_lock:<EOL><INDENT>global _executor, _executor_kwargs<EOL>executor = _executor<EOL>if max_workers is None:<EOL><INDENT>if reuse is True and executor is not None:<EOL><INDENT>max_workers = executor._max_workers<EOL><DEDENT>else:<EOL><INDENT>max_workers = cpu_count()<EOL><DEDENT><DEDENT>elif max_workers <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>.format(max_workers))<EOL><DEDENT>if isinstance(context, STRING_TYPE):<EOL><INDENT>context = get_context(context)<EOL><DEDENT>if context is not None and context.get_start_method() == \"<STR_LIT>\":<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>kwargs = dict(context=context, timeout=timeout,<EOL>job_reducers=job_reducers,<EOL>result_reducers=result_reducers,<EOL>initializer=initializer, initargs=initargs)<EOL>if executor is None:<EOL><INDENT>mp.util.debug(\"<STR_LIT>\"<EOL>.format(max_workers))<EOL>executor_id = _get_next_executor_id()<EOL>_executor_kwargs = kwargs<EOL>_executor = executor = _ReusablePoolExecutor(<EOL>_executor_lock, max_workers=max_workers,<EOL>executor_id=executor_id, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>if reuse == '<STR_LIT>':<EOL><INDENT>reuse = kwargs == _executor_kwargs<EOL><DEDENT>if (executor._flags.broken or executor._flags.shutdown<EOL>or not reuse):<EOL><INDENT>if executor._flags.broken:<EOL><INDENT>reason = \"<STR_LIT>\"<EOL><DEDENT>elif executor._flags.shutdown:<EOL><INDENT>reason = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>reason = \"<STR_LIT>\"<EOL><DEDENT>mp.util.debug(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>.format(max_workers, reason))<EOL>executor.shutdown(wait=True, kill_workers=kill_workers)<EOL>_executor = executor = _executor_kwargs = None<EOL>return get_reusable_executor(max_workers=max_workers,<EOL>**kwargs)<EOL><DEDENT>else:<EOL><INDENT>mp.util.debug(\"<STR_LIT>\"<EOL>.format(executor._max_workers))<EOL>executor._resize(max_workers)<EOL><DEDENT><DEDENT><DEDENT>return executor<EOL>", "docstring": "Return the current ReusableExectutor instance.\n\n    Start a new instance if it has not been started already or if the previous\n    instance was left in a broken state.\n\n    If the previous instance does not have the requested number of workers, the\n    executor is dynamically resized to adjust the number of workers prior to\n    returning.\n\n    Reusing a singleton instance spares the overhead of starting new worker\n    processes and importing common python packages each time.\n\n    ``max_workers`` controls the maximum number of tasks that can be running in\n    parallel in worker processes. By default this is set to the number of\n    CPUs on the host.\n\n    Setting ``timeout`` (in seconds) makes idle workers automatically shutdown\n    so as to release system resources. New workers are respawn upon submission\n    of new tasks so that ``max_workers`` are available to accept the newly\n    submitted tasks. Setting ``timeout`` to around 100 times the time required\n    to spawn new processes and import packages in them (on the order of 100ms)\n    ensures that the overhead of spawning workers is negligible.\n\n    Setting ``kill_workers=True`` makes it possible to forcibly interrupt\n    previously spawned jobs to get a new instance of the reusable executor\n    with new constructor argument values.\n\n    The ``job_reducers`` and ``result_reducers`` are used to customize the\n    pickling of tasks and results send to the executor.\n\n    When provided, the ``initializer`` is run first in newly spawned\n    processes with argument ``initargs``.", "id": "f14130:m1"}
{"signature": "def process_item(self, item, spider):", "body": "self.items.append(item)<EOL>if len(self.items) >= self.max_chunk_size:<EOL><INDENT>self._upload_chunk(spider)<EOL><DEDENT>return item<EOL>", "docstring": "Process single item. Add item to items and then upload to S3 if size of items\n>= max_chunk_size.", "id": "f14135:c0:m2"}
{"signature": "def __repr__(self):", "body": "p = self.__class__(self)  <EOL>if len(p['<STR_LIT:body>']) > <NUM_LIT>:<EOL><INDENT>p['<STR_LIT:body>'] = p['<STR_LIT:body>'][:<NUM_LIT:100>] + '<STR_LIT>' + p['<STR_LIT:body>'][-<NUM_LIT:100>:]<EOL><DEDENT>return super(Page, p).__repr__()<EOL>", "docstring": "Omit body to shorten logs.", "id": "f14137:c0:m0"}
{"signature": "def delete(self, url, params=None, **kwargs):", "body": "return self.call_api(<EOL>\"<STR_LIT>\",<EOL>url,<EOL>params=params,<EOL>**kwargs<EOL>)<EOL>", "docstring": "Call the API with a DELETE request.\n\n        Args:\n            url (str): Resource location relative to the base URL.\n            params (dict or None): Query-string parameters.\n\n        Returns:\n            ResultParser or ErrorParser.", "id": "f14142:c0:m6"}
{"signature": "@staticmethod<EOL><INDENT>def decode(response):<DEDENT>", "body": "try:<EOL><INDENT>return response.json()<EOL><DEDENT>except ValueError as e:<EOL><INDENT>return e.message<EOL><DEDENT>", "docstring": "Decode the returned data in the response.\n\n        Should be overridden by subclasses if something else than JSON is\n        expected.\n\n        Args:\n            response (HTTPResponse): The response object.\n\n        Returns:\n            dict or None.", "id": "f14142:c0:m2"}
{"signature": "def call_api(<EOL>self,<EOL>method,<EOL>url,<EOL>headers=None,<EOL>params=None,<EOL>data=None,<EOL>files=None,<EOL>timeout=None,<EOL>):", "body": "method = method.upper()<EOL>headers = deepcopy(headers) or {}<EOL>headers['<STR_LIT>'] = self.accept_type<EOL>params = deepcopy(params) or {}<EOL>data = data or {}<EOL>files = files or {}<EOL>if self.username and self.api_key:<EOL><INDENT>params.update(self.get_credentials())<EOL><DEDENT>url = urljoin(self.base_url, url)<EOL>r = requests.request(<EOL>method,<EOL>url,<EOL>headers=headers,<EOL>params=params,<EOL>files=files,<EOL>data=data,<EOL>timeout=timeout,<EOL>)<EOL>return r, r.status_code<EOL>", "docstring": "Call API.\n\n        This returns object containing data, with error details if applicable.\n\n        Args:\n            method (str): The HTTP method to use.\n            url (str): Resource location relative to the base URL.\n            headers (dict or None): Extra request headers to set.\n            params (dict or None): Query-string parameters.\n            data (dict or None): Request body contents for POST or PUT requests.\n            files (dict or None: Files to be passed to the request.\n            timeout (int): Maximum time before timing out.\n\n        Returns:\n            ResultParser or ErrorParser.", "id": "f14142:c0:m4"}
{"signature": "def _process_query(self, query, prepared=False):", "body": "<EOL>if prepared is True:<EOL><INDENT>files = {'<STR_LIT>': str(query)}<EOL>logger.debug('<STR_LIT>'.format(query))<EOL>res, status = self.post(<EOL>self.disambiguate_service,<EOL>files=files,<EOL>headers={'<STR_LIT>': '<STR_LIT:application/json>'},<EOL>)<EOL>if status == <NUM_LIT:200>:<EOL><INDENT>return self.decode(res), status<EOL><DEDENT>else:<EOL><INDENT>logger.debug('<STR_LIT>')<EOL>return None, status<EOL><DEDENT><DEDENT>text = query['<STR_LIT:text>']<EOL>sentence_coordinates = [<EOL>{<EOL>\"<STR_LIT>\": <NUM_LIT:0>,<EOL>\"<STR_LIT>\": len(text)<EOL>}<EOL>]<EOL>total_nb_sentences = len(sentence_coordinates)  <EOL>sentences_groups = []<EOL>if len(text) > self.max_text_length:<EOL><INDENT>res, status_code = self.segment(text)<EOL>if status_code == <NUM_LIT:200>:<EOL><INDENT>sentence_coordinates = res['<STR_LIT>']<EOL>total_nb_sentences = len(sentence_coordinates)<EOL><DEDENT>else:<EOL><INDENT>logger.error('<STR_LIT>')<EOL><DEDENT>logger.debug(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>total_nb_sentences, self.sentences_per_group<EOL>)<EOL>)<EOL>sentences_groups = self._group_sentences(<EOL>total_nb_sentences,<EOL>self.sentences_per_group<EOL>)<EOL><DEDENT>else:<EOL><INDENT>query['<STR_LIT>'] = \"<STR_LIT:true>\"<EOL><DEDENT>if total_nb_sentences > <NUM_LIT:1>:<EOL><INDENT>query['<STR_LIT>'] = sentence_coordinates<EOL><DEDENT>if len(sentences_groups) > <NUM_LIT:0>:<EOL><INDENT>for group in sentences_groups:<EOL><INDENT>query['<STR_LIT>'] = group<EOL>res, status_code = self._process_query(query, prepared=True)<EOL>if status_code == <NUM_LIT:200>:<EOL><INDENT>if '<STR_LIT>' in res:<EOL><INDENT>query['<STR_LIT>'] = res[u'<STR_LIT>']<EOL><DEDENT>query['<STR_LIT>'] = res[u'<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>logger.error(<EOL>\"<STR_LIT>\".format(query)<EOL>)<EOL>return None, status_code<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>res, status_code = self._process_query(query, prepared=True)<EOL>if status_code == <NUM_LIT:200>:<EOL><INDENT>query['<STR_LIT>'] = res[u'<STR_LIT>']<EOL>if '<STR_LIT>' in res:<EOL><INDENT>query['<STR_LIT>'] = res[u'<STR_LIT>']<EOL><DEDENT><DEDENT>else:<EOL><INDENT>logger.error(\"<STR_LIT>\".format(query))<EOL>return None, status_code<EOL><DEDENT><DEDENT>return query, status_code<EOL>", "docstring": "Process query recursively, if the text is too long,\n        it is split and processed bit a bit.\n\n        Args:\n            query (sdict): Text to be processed.\n            prepared (bool): True when the query is ready to be submitted via\n            POST request.\n        Returns:\n            str: Body ready to be submitted to the API.", "id": "f14143:c0:m1"}
{"signature": "def read_file(filename):", "body": "path = os.path.abspath(os.path.dirname(__file__))<EOL>filepath = os.path.join(path, filename)<EOL>try:<EOL><INDENT>return open(filepath).read()<EOL><DEDENT>except IOError:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>", "docstring": "Read a file into a string", "id": "f14152:m0"}
{"signature": "def decode(string):", "body": "if not string:<EOL><INDENT>raise IncompleteData(string)<EOL><DEDENT>if string[<NUM_LIT:0>] != <NUM_LIT>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % string[<NUM_LIT:0>])<EOL><DEDENT>if string[<NUM_LIT:1>:<NUM_LIT:2>] == b'<STR_LIT:P>':<EOL><INDENT>if len(string) < <NUM_LIT:16>:<EOL><INDENT>raise IncompleteData(string)<EOL><DEDENT>d = decompressobj()<EOL>term_string = d.decompress(string[<NUM_LIT:6>:]) + d.flush()<EOL>uncompressed_size, = _int4_unpack(string[<NUM_LIT:2>:<NUM_LIT:6>])<EOL>if len(term_string) != uncompressed_size:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (uncompressed_size, len(term_string)))<EOL><DEDENT>term, _tail = decode_term(term_string)<EOL>return term, d.unused_data<EOL><DEDENT>return decode_term(string[<NUM_LIT:1>:])<EOL>", "docstring": "Decode Erlang external term.", "id": "f14160:m0"}
{"signature": "def encode(term, compressed=False):", "body": "encoded_term = encode_term(term)<EOL>if compressed:<EOL><INDENT>if compressed is True:<EOL><INDENT>compressed = <NUM_LIT:6><EOL><DEDENT>elif compressed < <NUM_LIT:0> or compressed > <NUM_LIT:9>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % (compressed,))<EOL><DEDENT>zlib_term = compress(encoded_term, compressed)<EOL>ln = len(encoded_term)<EOL>if len(zlib_term) + <NUM_LIT:5> <= ln:<EOL><INDENT>return b\"<STR_LIT>\" + _int4_pack(ln) + zlib_term<EOL><DEDENT><DEDENT>return b\"<STR_LIT>\" + encoded_term<EOL>", "docstring": "Encode Erlang external term.", "id": "f14160:m2"}
{"signature": "def close(self):", "body": "os.close(self.in_d)<EOL>os.close(self.out_d)<EOL>", "docstring": "Close port.", "id": "f14165:c0:m4"}
{"signature": "def write(self, message):", "body": "data = encode(message, compressed=self.compressed)<EOL>length = len(data)<EOL>data = self.__pack(length) + data<EOL>with self.__write_lock:<EOL><INDENT>while data:<EOL><INDENT>try:<EOL><INDENT>n = os.write(self.out_d, data)<EOL><DEDENT>except OSError as why:<EOL><INDENT>if why.errno in (errno.EPIPE, errno.EINVAL):<EOL><INDENT>raise EOFError()<EOL><DEDENT>raise<EOL><DEDENT>if not n:<EOL><INDENT>raise EOFError()<EOL><DEDENT>data = data[n:]<EOL><DEDENT><DEDENT>return length + self.packet<EOL>", "docstring": "Write outgoing message.", "id": "f14165:c0:m3"}
{"signature": "def read(self):", "body": "packet = self.packet<EOL>with self.__read_lock:<EOL><INDENT>buffer = self.__buffer<EOL>while len(buffer) < packet:<EOL><INDENT>buffer += self._read_data()<EOL><DEDENT>length = self.__unpack(buffer[:packet])[<NUM_LIT:0>] + packet<EOL>while len(buffer) < length:<EOL><INDENT>buffer += self._read_data()<EOL><DEDENT>term, self.__buffer = decode(buffer[packet:])<EOL><DEDENT>return term<EOL>", "docstring": "Read incoming message.", "id": "f14172:c0:m2"}
{"signature": "def close(self):", "body": "os.close(self.in_d)<EOL>os.close(self.out_d)<EOL>", "docstring": "Close port.", "id": "f14172:c0:m4"}
{"signature": "def generate_uid(self):", "body": "return urlsafe_base64_encode(force_bytes(self.pk))<EOL>", "docstring": "Generate user uid for password reset.", "id": "f14186:c9:m2"}
{"signature": "def generate_token(self):", "body": "return default_token_generator.make_token(self)<EOL>", "docstring": "Generate user token for password reset.", "id": "f14186:c9:m1"}
{"signature": "def generate_validation_token(self):", "body": "data = {'<STR_LIT:email>': self.email}<EOL>return signing.dumps(data)<EOL>", "docstring": "Generate user token for account validation.", "id": "f14186:c9:m0"}
{"signature": "def send_password_reset(self):", "body": "site = Site.objects.get_current()<EOL>self.password_reset_notification(user=self, site=site).notify()<EOL>", "docstring": "Send a password reset to the user's email address.", "id": "f14186:c9:m4"}
{"signature": "def clean_password(self):", "body": "return self.initial['<STR_LIT:password>']<EOL>", "docstring": "Regardless of what the user provides, return the initial value.\n\nThis is done here, rather than on the field, because the field does\nnot have access to the initial value.", "id": "f14196:c1:m0"}
{"signature": "def validation_email_handler(notification):", "body": "base_subject = _('<STR_LIT>').format(domain=notification.site.domain)<EOL>subject = getattr(settings, '<STR_LIT>', base_subject)<EOL>notification.email_subject = subject<EOL>email_handler(notification, validation_email_context)<EOL>", "docstring": "Validation email handler.", "id": "f14204:m4"}
{"signature": "def validation_email_context(notification):", "body": "return {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': notification.user.generate_validation_token(),<EOL>'<STR_LIT>': notification.site,<EOL>}<EOL>", "docstring": "Email context to verify a user email.", "id": "f14204:m1"}
{"signature": "def filter_queryset(self, value, queryset):", "body": "return super(UniqueEmailValidator, self).filter_queryset(<EOL>value.lower(),<EOL>queryset,<EOL>)<EOL>", "docstring": "Check lower-cased email is unique.", "id": "f14214:c0:m0"}
{"signature": "def authenticate(self, request):", "body": "try:<EOL><INDENT>key = request.data['<STR_LIT>']<EOL><DEDENT>except KeyError:<EOL><INDENT>return<EOL><DEDENT>try:<EOL><INDENT>token = AuthToken.objects.get(key=key)<EOL><DEDENT>except AuthToken.DoesNotExist:<EOL><INDENT>return<EOL><DEDENT>return (token.user, token)<EOL>", "docstring": "Authenticate a user from a token form field\n\nErrors thrown here will be swallowed by django-rest-framework, and it\nexpects us to return None if authentication fails.", "id": "f14215:c0:m0"}
{"signature": "def post(self, request):", "body": "serializer = self.serializer_class(data=request.data)<EOL>if serializer.is_valid():<EOL><INDENT>user = serializer.validated_data['<STR_LIT:user>']<EOL>signals.user_logged_in.send(type(self), user=user, request=request)<EOL>token = self.model.objects.create(user=user)<EOL>token.update_expiry()<EOL>return response.Response({'<STR_LIT>': token.key})<EOL><DEDENT>return response.Response(<EOL>serializer.errors, status=status.HTTP_400_BAD_REQUEST)<EOL>", "docstring": "Create auth token. Differs from DRF that it always creates new token\n        but not re-using them.", "id": "f14216:c0:m0"}
{"signature": "def update_expiry(self, commit=True):", "body": "self.expires = update_expiry(self.created)<EOL>if commit:<EOL><INDENT>self.save()<EOL><DEDENT>", "docstring": "Update token's expiration datetime on every auth action.", "id": "f14225:c0:m3"}
{"signature": "@schema(responses={<NUM_LIT:200>: UserSerializer})<EOL><INDENT>def list(self, request):<DEDENT>", "body": "serializer = self.get_serializer(request.user)<EOL>return Response(serializer.data, status=status.HTTP_200_OK)<EOL>", "docstring": "Retrieve logged in user info", "id": "f14251:c3:m0"}
{"signature": "def register(view):  ", "body": "meta = view.get_admin_meta()<EOL>prefix = meta.basename.replace(\"<STR_LIT:.>\", \"<STR_LIT:/>\")<EOL>router.register(prefix, view, meta.basename)<EOL>", "docstring": "Register the API view class in the bananas router.\n\n:param BananasAPI view:", "id": "f14255:m0"}
{"signature": "def get_secret(secret_name, default=None):", "body": "secrets_dir = get_secrets_dir()<EOL>secret_path = os.path.join(secrets_dir, secret_name)<EOL>try:<EOL><INDENT>with open(secret_path, \"<STR_LIT:r>\") as secret_file:<EOL><INDENT>return secret_file.read()<EOL><DEDENT><DEDENT>except OSError:<EOL><INDENT>return default<EOL><DEDENT>", "docstring": "Gets contents of secret file\n\n:param secret_name: The name of the secret present in BANANAS_SECRETS_DIR\n:param default: Default value to return if no secret was found\n:return: The secret or default if not found", "id": "f14265:m0"}
{"signature": "@classmethod<EOL><INDENT>def from_model(cls, model, *fields, **named_fields):<DEDENT>", "body": "d = ModelDict()<EOL>if not (fields or named_fields):<EOL><INDENT>fields = [f.attname for f in model._meta.concrete_fields]<EOL><DEDENT>not_found = object()<EOL>for name, field in chain(zip(fields, fields), named_fields.items()):<EOL><INDENT>_fields = field.split(\"<STR_LIT>\")<EOL>value = model<EOL>for i, _field in enumerate(_fields, start=<NUM_LIT:1>):<EOL><INDENT>previous_value = value<EOL>value = getattr(previous_value, _field, not_found)<EOL>if value is not_found:<EOL><INDENT>if _field in dir(previous_value):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\".format(<EOL>previous_value, _field<EOL>)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\".format(<EOL>previous_value, _field<EOL>)<EOL>)<EOL><DEDENT><DEDENT>elif value is None:<EOL><INDENT>if name not in named_fields:<EOL><INDENT>name = \"<STR_LIT>\".join(_fields[:i])<EOL><DEDENT>break<EOL><DEDENT><DEDENT>d[name] = value<EOL><DEDENT>return d<EOL>", "docstring": "Work-in-progress constructor,\nconsuming fields and values from django model instance.", "id": "f14270:c0:m3"}
{"signature": "def database_conf_from_url(url):", "body": "return {key.upper(): val for key, val in parse_database_url(url)._asdict().items()}<EOL>", "docstring": "Return a django-style database configuration based on ``url``.\n\n:param url: Database URL\n:return: Django-style database configuration dict\n\nExample:\n>>> conf = database_conf_from_url(\n...     'pgsql://joar:hunter2@5monkeys.se:4242/tweets/tweetschema'\n...     '?hello=world')\n>>> sorted(conf.items())  # doctest: +NORMALIZE_WHITESPACE\n[('ENGINE', 'django.db.backends.postgresql_psycopg2'),\n ('HOST', '5monkeys.se'),\n ('NAME', 'tweets'),\n ('PARAMS', {'hello': 'world'}),\n ('PASSWORD', 'hunter2'),\n ('PORT', 4242),\n ('SCHEMA', 'tweetschema'),\n ('USER', 'joar')]", "id": "f14271:m4"}
{"signature": "def parse_database_url(url):", "body": "if url == \"<STR_LIT>\":<EOL><INDENT>raise Exception(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>url_parts = urlsplit(url)<EOL>engine = get_engine(url_parts.scheme)<EOL>database, schema = parse_path(url_parts.path)<EOL>port = url_parts.port<EOL>host = url_parts.hostname<EOL>user = url_parts.username<EOL>password = url_parts.password<EOL>params = {key: val.pop() for key, val in parse_qs(url_parts.query).items()}<EOL>return DatabaseInfo(<EOL>engine=engine,<EOL>name=database,<EOL>schema=schema,<EOL>user=user,<EOL>password=password,<EOL>host=host,<EOL>port=port,<EOL>params=params,<EOL>)<EOL>", "docstring": "Parse a database URL and return a DatabaseInfo named tuple.\n\n:param url: Database URL\n:return: DatabaseInfo instance\n\nExample:\n>>> conf = parse_database_url(\n...     'pgsql://joar:hunter2@5monkeys.se:4242/tweets/tweetschema'\n...     '?hello=world')\n>>> conf  # doctest: +NORMALIZE_WHITESPACE\nDatabaseInfo(engine='django.db.backends.postgresql_psycopg2',\n             name='tweets',\n             schema='tweetschema',\n             user='joar',\n             password='hunter2',\n             host='5monkeys.se',\n             port=4242,\n             params={'hello': 'world'})", "id": "f14271:m5"}
{"signature": "def register_engine(scheme, module):", "body": "ENGINE_MAPPING.update({scheme: module})<EOL>", "docstring": "Register a new engine.\n\n:param scheme: The scheme that should be matched\n:param module:\n:return:", "id": "f14271:m0"}
{"signature": "def parse_path(path):", "body": "if path is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>parts = path.strip(\"<STR_LIT:/>\").split(\"<STR_LIT:/>\")<EOL>database = unquote_plus(parts[<NUM_LIT:0>]) if len(parts) else None<EOL>schema = parts[<NUM_LIT:1>] if len(parts) > <NUM_LIT:1> else None<EOL>return database, schema<EOL>", "docstring": "Get database name and database schema from path.\n\n:param path: \"/\"-delimited path, parsed as\n \"/<database name>/<database schema>\"\n:return: tuple with (database or None, schema or None)", "id": "f14271:m3"}
{"signature": "def build_url_field(self, field_name, model_class):", "body": "field, kwargs = super().build_url_field(field_name, model_class)<EOL>view = self.root.context[\"<STR_LIT>\"]<EOL>kwargs[\"<STR_LIT>\"] = view.get_url_name(\"<STR_LIT>\")<EOL>return field, kwargs<EOL>", "docstring": "This is needed due to DRF's model serializer uses the queryset to build url name\n\n# TODO: Move this to own serializer mixin or fix problem elsewhere?", "id": "f14291:c0:m1"}
{"signature": "def __init__(self, *args, **kwargs):", "body": "locators = []<EOL>for locatorClass in self._locatorClasses:<EOL><INDENT>locator = locatorClass(*args, **kwargs)<EOL>locator._composer = self<EOL>locators.append(locator)<EOL><DEDENT>ComposedLocator.__init__(self, locators)<EOL>", "docstring": "Initializes all of the component locators with the given arguments.", "id": "f14295:c1:m0"}
{"signature": "def toBox(self, name, strings, objects, proto):", "body": "", "docstring": "A no-op.\n\n        The exposed value is specific to the local connection. It\n        can't be serialized back to the other side, so this method\n        does nothing.", "id": "f14297:c0:m0"}
{"signature": "def toString(self, value):", "body": "self._checkConstraints(value)<EOL>return self.baseArgument.toString(value)<EOL>", "docstring": "If all of the constraints are satisfied with the given value, defers\nto the composed AMP argument's ``toString`` method.", "id": "f14298:c0:m2"}
{"signature": "def getLocalProtocol(self, connectionIdentifier):", "body": "for factory in self.localFactories:<EOL><INDENT>try:<EOL><INDENT>return factory.protocols[connectionIdentifier]<EOL><DEDENT>except KeyError:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>raise NoSuchConnection()<EOL>", "docstring": "Attempts to get a local protocol by connection identifier.", "id": "f14300:c10:m1"}
{"signature": "@Transmit.responder<EOL><INDENT>def receiveData(self, connection, data):<DEDENT>", "body": "try:<EOL><INDENT>protocol = self._protocols[connection]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise NoSuchConnection()<EOL><DEDENT>protocol.dataReceived(data)<EOL>return {}<EOL>", "docstring": "Receives some data for the given protocol.", "id": "f14300:c6:m5"}
{"signature": "def removeFactory(self, identifier):", "body": "factory = self._factories.pop(identifier)<EOL>factory.doStop()<EOL>return factory<EOL>", "docstring": "Removes a factory.\n\n        After calling this method, remote clients will no longer be\n        able to connect to it.\n\n        This will call the factory's ``doStop`` method.", "id": "f14300:c6:m2"}
{"signature": "def _getCommandAndResponder(self, commandName):", "body": "<EOL>locator = self._remote.boxReceiver.locator<EOL>responder = locator.locateResponder(commandName)<EOL>responderFunction = responder.func_closure[<NUM_LIT:1>].cell_contents<EOL>command = responder.func_closure[<NUM_LIT:2>].cell_contents<EOL>return command, responderFunction<EOL>", "docstring": "Gets the command class and matching responder function for the\n        given command name.", "id": "f14312:c0:m2"}
{"signature": "def _writeResponse(self, response):", "body": "encoded = dumps(response, default=_default)<EOL>self.transport.write(encoded)<EOL>", "docstring": "Serializes the response to JSON, and writes it to the transport.", "id": "f14312:c0:m5"}
{"signature": "def store_name(self, name, val):", "body": "self._locals[name] = val<EOL>", "docstring": "Implementation of the STORE_NAME operation\nin global scope, locals and globals should reference the same dict so this would also\nset the global", "id": "f14353:c4:m13"}
{"signature": "def load_name(self, name):", "body": "if name in self.globals_:<EOL><INDENT>return self.globals_[name]<EOL><DEDENT>b = self.globals_['<STR_LIT>']<EOL>if isinstance(b, dict):<EOL><INDENT>return b[name]<EOL><DEDENT>else:<EOL><INDENT>return getattr(b, name)<EOL><DEDENT>", "docstring": "Implementation of the LOAD_NAME operation", "id": "f14353:c4:m12"}
{"signature": "def pop(self, n):", "body": "poped = self.__stack[len(self.__stack) - n:]<EOL>del self.__stack[len(self.__stack) - n:]<EOL>return poped<EOL>", "docstring": "Pop the **n** topmost items from the stack and return them as a ``list``.", "id": "f14353:c4:m14"}
{"signature": "@contextmanager<EOL><INDENT>def _suppress_output(self):<DEDENT>", "body": "STDOUT_FILENO = <NUM_LIT:1><EOL>STDERR_FILENO = <NUM_LIT:2><EOL>with open(os.devnull, \"<STR_LIT:w>\") as null:<EOL><INDENT>stdout = os.dup(STDOUT_FILENO)<EOL>stderr = os.dup(STDERR_FILENO)<EOL>os.dup2(null.fileno(), STDOUT_FILENO)<EOL>os.dup2(null.fileno(), STDERR_FILENO)<EOL><DEDENT>try:<EOL><INDENT>yield<EOL><DEDENT>finally:<EOL><INDENT>os.dup2(stdout, STDOUT_FILENO)<EOL>os.dup2(stderr, STDERR_FILENO)<EOL>os.close(stdout)<EOL>os.close(stderr)<EOL><DEDENT>", "docstring": "Silence error messages from the \"patch\" command", "id": "f14363:c0:m7"}
{"signature": "def apply_next_patch(self, force=False, quiet=False):", "body": "self._check()<EOL>top = self.db.top_patch()<EOL>if not top:<EOL><INDENT>patch = self.series.first_patch()<EOL><DEDENT>else:<EOL><INDENT>patch = self.series.patch_after(top)<EOL><DEDENT>if not patch:<EOL><INDENT>raise AllPatchesApplied(self.series, top)<EOL><DEDENT>self.applying(patch)<EOL>self._apply_patch(patch, force, quiet)<EOL>self.db.save()<EOL>self.applied(self.db.top_patch())<EOL>", "docstring": "Apply next patch in series file", "id": "f14374:c0:m4"}
{"signature": "def add_file(self, filename, patch_name=None, ignore=False):", "body": "file = File(filename)<EOL>if patch_name:<EOL><INDENT>patch = Patch(patch_name)<EOL><DEDENT>else:<EOL><INDENT>patch = self.db.top_patch()<EOL>if not patch:<EOL><INDENT>raise NoAppliedPatch(self.db)<EOL><DEDENT><DEDENT>exists = self._file_in_patch(filename, patch, ignore)<EOL>if exists:<EOL><INDENT>return<EOL><DEDENT>self._file_in_next_patches(filename, patch)<EOL>if file.is_link():<EOL><INDENT>raise QuiltError(\"<STR_LIT>\" % filename)<EOL><DEDENT>self._backup_file(file, patch)<EOL>if file.exists():<EOL><INDENT>os.chmod(filename, file.get_mode() | stat.S_IWUSR | stat.S_IRUSR)<EOL><DEDENT>self.file_added(file, patch)<EOL>", "docstring": "Add file to the patch with patch_name.\n        If patch_name is None or empty the topmost patch will be used.\n        Adding an already added patch will raise an QuiltError if ignore is\n        False.", "id": "f14375:c0:m4"}
{"signature": "def create(self, patchname):", "body": "patch = Patch(patchname)<EOL>if self.series.is_patch(patch):<EOL><INDENT>raise PatchAlreadyExists(self.series, patchname)<EOL><DEDENT>patch_dir = self.quilt_patches<EOL>patch_dir.create()<EOL>patchfile = patch_dir + File(patchname)<EOL>patchfile.touch()<EOL>pc_dir = self.quilt_pc + patchname<EOL>if pc_dir.exists():<EOL><INDENT>pc_dir.delete()<EOL><DEDENT>pc_dir.create()<EOL>top = self.db.top_patch()<EOL>self.series.add_patches([patch], top)<EOL>self.db.add_patch(patch)<EOL>self.series.save()<EOL>self.db.save()<EOL>self.patch_created(patch)<EOL>", "docstring": "Adds a new patch with patchname to the queue\n\n        The new patch will be added as the topmost applied patch.", "id": "f14377:c0:m1"}
{"signature": "def unapply_all(self, force=False):", "body": "self._check(force)<EOL>for patch in reversed(self.db.applied_patches()):<EOL><INDENT>self._unapply_patch(patch)<EOL><DEDENT>self.db.save()<EOL>self.unapplied(self.db.top_patch())<EOL>", "docstring": "Unapply all patches", "id": "f14379:c0:m5"}
{"signature": "def is_empty(self):", "body": "return len(self.patch2line) == <NUM_LIT:0><EOL>", "docstring": "Returns true if no patch is in the series", "id": "f14382:c2:m22"}
{"signature": "def is_patch(self, patch):", "body": "return patch in self.patch2line<EOL>", "docstring": "Returns True if patch is in the list of patches. Otherwise it\n            returns False.", "id": "f14382:c2:m21"}
{"signature": "def add_patch(self, patch):", "body": "patchline = PatchLine(patch)<EOL>patch = patchline.get_patch()<EOL>if patch:<EOL><INDENT>self.patch2line[patch] = patchline<EOL><DEDENT>self.patchlines.append(patchline)<EOL>", "docstring": "Add a patch to the patches list", "id": "f14382:c2:m5"}
{"signature": "def insert_patches(self, patches):", "body": "patchlines = []<EOL>for patch_name in patches:<EOL><INDENT>patchline = PatchLine(patch_name)<EOL>patch = patchline.get_patch()<EOL>if patch:<EOL><INDENT>self.patch2line[patch] = patchline<EOL><DEDENT>patchlines.append(patchline)<EOL><DEDENT>patchlines.extend(self.patchlines)<EOL>self.patchlines = patchlines<EOL>", "docstring": "Insert list of patches at the front of the curent patches list", "id": "f14382:c2:m7"}
{"signature": "def add_patches(self, patches, after=None):", "body": "if after is None:<EOL><INDENT>self.insert_patches(patches)<EOL><DEDENT>else:<EOL><INDENT>self._check_patch(after)<EOL>patchlines = self._patchlines_before(after)<EOL>patchlines.append(self.patch2line[after])<EOL>for patch in patches:<EOL><INDENT>patchline = PatchLine(patch)<EOL>patchlines.append(patchline)<EOL>self.patch2line[patchline.get_patch()] = patchline<EOL><DEDENT>patchlines.extend(self._patchlines_after(after))<EOL>self.patchlines = patchlines<EOL><DEDENT>", "docstring": "Add a list of patches to the patches list", "id": "f14382:c2:m8"}
{"signature": "def top_patch(self):", "body": "patches = self.patches()<EOL>if not patches:<EOL><INDENT>return None<EOL><DEDENT>return patches[-<NUM_LIT:1>]<EOL>", "docstring": "Returns the last patch from the patches list or None if the list\n            is empty", "id": "f14382:c2:m10"}
{"signature": "def create(self):", "body": "if not os.path.exists(self.dirname):<EOL><INDENT>os.makedirs(self.dirname)<EOL><DEDENT>self._create_version(self.version_file)<EOL>", "docstring": "Creates the dirname and inserts a .version file", "id": "f14382:c3:m2"}
{"signature": "def replace(self, old_patch, new_patch):", "body": "self._check_patch(old_patch)<EOL>old_patchline = self.patch2line[old_patch]<EOL>index = self.patchlines.index(old_patchline)<EOL>self.patchlines.pop(index)<EOL>new_patchline = PatchLine(new_patch)<EOL>new_patchline.set_comment(old_patchline.get_comment())<EOL>self.patchlines.insert(index, new_patchline)<EOL>del self.patch2line[old_patch]<EOL>self.patch2line[new_patch] = new_patchline<EOL>", "docstring": "Replace old_patch with new_patch\n        The method only replaces the patch and doesn't change any comments.", "id": "f14382:c2:m23"}
{"signature": "def read(self):", "body": "self.patchlines = []<EOL>self.patch2line = dict()<EOL>if self.exists():<EOL><INDENT>with open(self.series_file, \"<STR_LIT:r>\") as f:<EOL><INDENT>for line in f:<EOL><INDENT>self.add_patch(line)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Reads all patches from the series file", "id": "f14382:c2:m3"}
{"signature": "def add_subparsers(self, parser):", "body": "sgroup = getattr(self, \"<STR_LIT>\", None)<EOL>if sgroup:<EOL><INDENT>sgroup.add_to_parser(self)<EOL><DEDENT>if not self.subparsers:<EOL><INDENT>return<EOL><DEDENT>args = self.subparsers_args or self.get_default_subparsers_args()<EOL>kwargs = self.subparsers_kwargs or self.get_default_subparsers_kwargs()<EOL>subs = parser.add_subparsers(*args, **kwargs)<EOL>for subparser in self.subparsers:<EOL><INDENT>subparser.add_to_parser(subs)<EOL><DEDENT>", "docstring": "Adds the subparsers to an argparse.ArgumentParser\n\n@param parser An argparse.ArgumentParser instance", "id": "f14387:c6:m5"}
{"signature": "def add_to_parser(self, parser):", "body": "self.group = parser.add_argument_group(self.title, self.description)<EOL>for arg in self.arguments:<EOL><INDENT>arg.add_to_parser(self.group)<EOL><DEDENT>", "docstring": "Adds the group and its arguments to a argparse.ArgumentParser instance\n\n@param parser A argparse.ArgumentParser instance", "id": "f14387:c1:m1"}
{"signature": "def get_default_subparsers_kwargs(self):", "body": "return self.default_subparsers_kwargs<EOL>", "docstring": "Returns the default kwargs to be passed to\nargparse.ArgumentParser.add_subparsers", "id": "f14387:c6:m3"}
{"signature": "def add_argument(self, arg):", "body": "self.arguments.append(arg)<EOL>", "docstring": "Adds a Argument to this group.\nNormally this method should not be called directly.\nIt is used by the ArgumentsCollectorMetaClass.\n\n@parma arg An Argument instance to be added to this group.", "id": "f14387:c1:m3"}
{"signature": "def touch(self):", "body": "open(self.filename, \"<STR_LIT:w>\").close()<EOL>", "docstring": "Touch' a file. Creates an empty file.", "id": "f14404:c5:m4"}
{"signature": "def content(self):", "body": "return self._content(self.dirname)<EOL>", "docstring": "Returns all directories and files in this directory and its\n            subdirectories", "id": "f14404:c3:m5"}
{"signature": "def is_empty(self):", "body": "st = os.stat(self.filename)<EOL>return st.st_size == <NUM_LIT:0><EOL>", "docstring": "Returns True if the size of the file is 0", "id": "f14404:c5:m7"}
{"signature": "def get_name(self):", "body": "return self.dirname<EOL>", "docstring": "Returns the name of the directory", "id": "f14404:c3:m7"}
{"signature": "def _file_in_patch(self, filename, patch):", "body": "pc_dir = self.quilt_pc + patch.get_name()<EOL>file = pc_dir + File(filename)<EOL>if not file.exists():<EOL><INDENT>raise QuiltError(\"<STR_LIT>\" % (filename,<EOL>patch.get_name()))<EOL><DEDENT>", "docstring": "Checks if a backup file of the filename in the current patch\n        exists and raises a QuiltError if not.", "id": "f14407:c0:m1"}
{"signature": "def success(value: Any):", "body": "return SuccessParser(value)<EOL>", "docstring": "Always succeed in matching and return a value.\n\n    This parser always succeeds and returns the given ``value``. No input is\n    consumed. This is useful for inserting arbitrary values into complex\n    parsers.\n\n    Args:\n        value: Any value", "id": "f14418:m8"}
{"signature": "def recursion_error(self, repeated_parser: str):", "body": "if self.finished:<EOL><INDENT>return super().recursion_error(repeated_parser)<EOL><DEDENT>else:<EOL><INDENT>line_index, character_index, line, pointer = self.current_line()<EOL>return '<STR_LIT>''<STR_LIT>'.format(repeated_parser, line_index, character_index, line, pointer)<EOL><DEDENT>", "docstring": "Generate an error to indicate that infinite recursion was encountered.\n\n        A parser can supply a representation of itself to this method and the\n        reader will supply the context, including the location where the\n        parser stalled.\n\n        Args:\n            repeated_parser: A representation of the repeated parser\n\n        Returns:\n            A full error message", "id": "f14420:c2:m8"}
{"signature": "def recursion_error(self, repeated_parser: str):", "body": "if self.finished:<EOL><INDENT>return '<STR_LIT>''<STR_LIT>'.format(repeated_parser)<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT>''<STR_LIT>'.format(repeated_parser, self.position, self.next_token())<EOL><DEDENT>", "docstring": "Generate an error to indicate that infinite recursion was encountered.\n\n        A parser can supply a representation of itself to this method and the\n        reader will supply the context, including the location where the\n        parser stalled.\n\n        Args:\n            repeated_parser: A representation of the repeated parser\n\n        Returns:\n            A full error message", "id": "f14420:c0:m2"}
{"signature": "def encode_pretty_printed_json(json_object):", "body": "return _pretty_encoder.encode(json_object).encode(\"<STR_LIT:ascii>\")<EOL>", "docstring": "Encodes the JSON object dict as human readable ascii bytes.", "id": "f14426:m3"}
{"signature": "def exec_file(path_segments, name):", "body": "result = {}<EOL>code = read_file(path_segments)<EOL>lines = [line for line in code.split('<STR_LIT:\\n>') if line.startswith(name)]<EOL>exec(\"<STR_LIT:\\n>\".join(lines), result)<EOL>return result[name]<EOL>", "docstring": "Extract a constant from a python file by looking for a line defining\n    the constant and executing it.", "id": "f14427:m1"}
{"signature": "def make_federation_entity(config, eid='<STR_LIT>', httpcli=None, verify_ssl=True):", "body": "args = {}<EOL>if not eid:<EOL><INDENT>try:<EOL><INDENT>eid = config['<STR_LIT>']<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if '<STR_LIT>' in config:<EOL><INDENT>self_signer = make_internal_signing_service(config['<STR_LIT>'],<EOL>eid)<EOL>args['<STR_LIT>'] = self_signer<EOL><DEDENT>try:<EOL><INDENT>bundle_cnf = config['<STR_LIT>']<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>_args = dict([(k, v) for k, v in bundle_cnf.items() if k in KJ_SPECS])<EOL>if _args:<EOL><INDENT>_kj = init_key_jar(**_args)<EOL><DEDENT>else:<EOL><INDENT>_kj = None<EOL><DEDENT>if '<STR_LIT>' in bundle_cnf:<EOL><INDENT>jb = FSJWKSBundle(eid, _kj, bundle_cnf['<STR_LIT>'],<EOL>key_conv={'<STR_LIT:to>': quote_plus, '<STR_LIT>': unquote_plus})<EOL><DEDENT>else:<EOL><INDENT>jb = JWKSBundle(eid, _kj)<EOL><DEDENT>args['<STR_LIT>'] = jb<EOL><DEDENT>for item in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>try:<EOL><INDENT>args[item] = config[item]<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if '<STR_LIT>' not in args:<EOL><INDENT>args['<STR_LIT>'] = eid<EOL><DEDENT>if '<STR_LIT>' in config:<EOL><INDENT>args['<STR_LIT>'] = config['<STR_LIT>']<EOL>return FederationEntityOOB(httpcli, iss=eid, **args)<EOL><DEDENT>elif '<STR_LIT>' in config:<EOL><INDENT>args['<STR_LIT>'] = verify_ssl<EOL>args['<STR_LIT>'] = config['<STR_LIT>']<EOL>return FederationEntityAMS(httpcli, iss=eid, **args)<EOL><DEDENT>elif '<STR_LIT>' in config:<EOL><INDENT>args['<STR_LIT>'] = verify_ssl<EOL>for key in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>args[key] = config[key]<EOL><DEDENT>return FederationEntitySwamid(httpcli, iss=eid, **args)<EOL><DEDENT>", "docstring": "Construct a :py:class:`fedoidcmsg.entity.FederationEntity` instance based\non given configuration.\n\n:param config: Federation entity configuration\n:param eid: Entity ID\n:param httpcli: A http client instance to use when sending HTTP requests\n:param verify_ssl: Whether TLS/SSL certificates should be verified\n:return: A :py:class:`fedoidcmsg.entity.FederationEntity` instance", "id": "f14439:m0"}
{"signature": "def pick_signed_metadata_statements(self, fo, context):", "body": "sms_dict = self.signer.metadata_statements[context]<EOL>res = []<EOL>for iss, vals in sms_dict.items():<EOL><INDENT>if iss == fo:<EOL><INDENT>res.extend((iss, vals))<EOL><DEDENT><DEDENT>return res<EOL>", "docstring": "Pick signed metadata statements based on ISS pattern matching\n\n:param fo: Federation operators ID\n:param context: In connect with which operation (one of the values in \n    :py:data:`fedoidc.CONTEXTS`). \n:return: list of tuples (FO ID, signed metadata statement)", "id": "f14439:c0:m3"}
{"signature": "def get_metadata_statement(self, input, cls=MetadataStatement,<EOL>context='<STR_LIT>'):", "body": "logger.debug('<STR_LIT>'.format(input))<EOL>if isinstance(input, dict):<EOL><INDENT>data = input<EOL><DEDENT>else:<EOL><INDENT>if isinstance(input, Message):<EOL><INDENT>data = input.to_dict()<EOL><DEDENT>else:<EOL><INDENT>data = json.loads(input)<EOL><DEDENT><DEDENT>_pi = self.unpack_metadata_statement(ms_dict=data, cls=cls)<EOL>if not _pi.result:<EOL><INDENT>return []<EOL><DEDENT>logger.debug('<STR_LIT>')<EOL>if context:<EOL><INDENT>_cms = self.correct_usage(_pi.result, context)<EOL><DEDENT>else:<EOL><INDENT>_cms = _pi.result<EOL><DEDENT>logger.debug('<STR_LIT>'.format(_cms))<EOL>if _cms:<EOL><INDENT>return self.evaluate_metadata_statement(_cms)<EOL><DEDENT>else:<EOL><INDENT>return []<EOL><DEDENT>", "docstring": "Unpack and evaluate a compound metadata statement. Goes through the\nnecessary three steps.\n* unpack the metadata statement\n* verify that the given statements are expected to be used in this context\n* evaluate the metadata statements (= flatten)\n\n:param input: The metadata statement as a JSON document or a\n    dictionary\n:param cls: The class the response should be typed into\n:param context: In which context the metadata statement should be used.\n:return: A list of :py:class:`fedoidc.operator.LessOrEqual` instances", "id": "f14439:c0:m4"}
{"signature": "def add_sms_spec_to_request(self, req, federation='<STR_LIT>', loes=None,<EOL>context='<STR_LIT>', url='<STR_LIT>'):", "body": "<EOL>if federation:<EOL><INDENT>if not isinstance(federation, list):<EOL><INDENT>federation = [federation]<EOL><DEDENT><DEDENT>if not url:<EOL><INDENT>url = \"<STR_LIT>\".format(self.mdss_endpoint, context,<EOL>quote_plus(self.entity_id))<EOL><DEDENT>http_resp = self.httpcli(method='<STR_LIT:GET>', url=url, verify=self.verify_ssl)<EOL>if http_resp.status_code >= <NUM_LIT>:<EOL><INDENT>raise ConnectionError('<STR_LIT>'.format(http_resp.text))<EOL><DEDENT>msg = JsonWebToken().from_jwt(http_resp.text, keyjar=self.mdss_keys)<EOL>if msg['<STR_LIT>'] != self.mdss_owner:<EOL><INDENT>raise KeyError('<STR_LIT>')<EOL><DEDENT>if federation:<EOL><INDENT>_sms = dict(<EOL>[(fo, _ms) for fo, _ms in msg.items() if fo in federation])<EOL><DEDENT>else:<EOL><INDENT>_sms = msg.extra()<EOL>try:<EOL><INDENT>del _sms['<STR_LIT>']<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>req.update({'<STR_LIT>': _sms})<EOL>return req<EOL>", "docstring": "Add signed metadata statements to the request\n\n:param req: The request so far\n:param federation: If only signed metadata statements from a specific\n    set of federations should be included this is the set.\n:param loes: - not used -\n:param context: What kind of request/response it is: 'registration',\n    'discovery' or 'response'. The later being registration response.\n:param url: Just for testing !!\n:return: A possibly augmented request.", "id": "f14439:c3:m1"}
{"signature": "def add_signing_keys(self, statement):", "body": "statement['<STR_LIT>'] = self.self_signer.export_jwks_as_json()<EOL>return statement<EOL>", "docstring": "Adding signing keys by value to a statement.\n\n:param statement: Metadata statement to be extended\n:return: The extended statement", "id": "f14439:c0:m6"}
{"signature": "def get_bundle(iss, ver_keys, bundle_file):", "body": "fp = open(bundle_file, '<STR_LIT:r>')<EOL>signed_bundle = fp.read()<EOL>fp.close()<EOL>return JWKSBundle(iss, None).upload_signed_bundle(signed_bundle, ver_keys)<EOL>", "docstring": "Read a signed JWKS bundle from disc, verify the signature and\ninstantiate a JWKSBundle instance with the information from the file.\n\n:param iss:\n:param ver_keys:\n:param bundle_file:\n:return:", "id": "f14440:m1"}
{"signature": "def dumps(self, iss_list=None):", "body": "return json.dumps(self.dict(iss_list))<EOL>", "docstring": "Dumps a bundle of keys into a string. If iss_list is empty then all\navailable issuers are included\n\n:param iss_list: List of issuers who's keys should be dumped\n:return: A JSON document", "id": "f14440:c0:m6"}
{"signature": "def keyjar_to_jwks(keyjar):", "body": "return k_to_j(keyjar)<EOL>", "docstring": "Convert a KeyJar instance to a JWKS (JSON document).\n\n:param keyjar: A :py:class:`oidcmsg.key_jar.KeyJar` instance", "id": "f14440:m5"}
{"signature": "def keys(self):", "body": "return self.bundle.keys()<EOL>", "docstring": "Return a list of all issuers kept in this bundle.\n\n:return: List of Issuer IDs", "id": "f14440:c0:m8"}
{"signature": "def __delitem__(self, key):", "body": "del self.bundle[key]<EOL>", "docstring": "Remove the KeyJar that belong to a specific issuer\n\n:param key: Issuer ID", "id": "f14440:c0:m3"}
{"signature": "def make_internal_signing_service(config, entity_id):", "body": "_args = dict([(k, v) for k, v in config.items() if k in KJ_SPECS])<EOL>_kj = init_key_jar(**_args)<EOL>return InternalSigningService(entity_id, _kj)<EOL>", "docstring": "Given configuration initiate an InternalSigningService instance\n\n:param config: The signing service configuration\n:param entity_id: The entity identifier\n:return: A InternalSigningService instance", "id": "f14441:m0"}
{"signature": "def pack(self, req, receiver='<STR_LIT>', iss='<STR_LIT>', lifetime=<NUM_LIT:0>, sign=True,<EOL>sign_alg='<STR_LIT>', encrypt=False, enc_enc=\"<STR_LIT>\",<EOL>enc_alg=\"<STR_LIT>\", aud=None):", "body": "if not iss:<EOL><INDENT>iss = self.iss<EOL><DEDENT>if not lifetime:<EOL><INDENT>lifetime = self.lifetime<EOL><DEDENT>keyjar = self.keyjar<EOL>_metadata = copy.deepcopy(req)<EOL>if self.add_ons:<EOL><INDENT>_metadata.update(self.add_ons)<EOL><DEDENT>args = {}<EOL>if sign:<EOL><INDENT>if sign_alg:<EOL><INDENT>args['<STR_LIT>'] = sign_alg<EOL><DEDENT>else:<EOL><INDENT>args['<STR_LIT>'] = self.alg<EOL><DEDENT><DEDENT>if encrypt:<EOL><INDENT>args['<STR_LIT>'] = enc_enc<EOL>args['<STR_LIT>'] = enc_alg<EOL><DEDENT>_jwt = JWT(keyjar, iss=iss, msg_cls=_metadata.__class__,<EOL>lifetime=lifetime, **args)<EOL>if iss in keyjar.issuer_keys:<EOL><INDENT>owner = iss<EOL><DEDENT>else:<EOL><INDENT>owner = '<STR_LIT>'<EOL><DEDENT>return _jwt.pack(payload=_metadata.to_dict(), owner=owner,<EOL>recv=receiver, aud=aud)<EOL>", "docstring": ":param req: Original metadata statement as a \n    :py:class:`MetadataStatement` instance\n:param receiver: The immediate receiver of the JWS\n:param iss:\n:param lifetime:\n:param sign:\n:param sign_alg:\n:param encrypt:\n:param enc_alg:\n:param enc_enc:\n:param aud: The audience, a list of receivers.\n:return: A dictionary with a signed JWT as value with the key 'sms'", "id": "f14441:c2:m5"}
{"signature": "def encrypt(self, req, receiver='<STR_LIT>', iss='<STR_LIT>', lifetime=<NUM_LIT:0>,<EOL>enc_enc=\"<STR_LIT>\", enc_alg=\"<STR_LIT>\", aud=None):", "body": "return self.pack(req=req, receiver=receiver, iss=iss, lifetime=lifetime,<EOL>sign=False, encrypt=True, enc_enc=enc_enc,<EOL>enc_alg=enc_alg)<EOL>", "docstring": ":param req: Original metadata statement as a\n    :py:class:`MetadataStatement` instance\n:param receiver: The intended audience for the JWS\n:param iss:\n:param lifetime:\n:param enc_alg:\n:param enc_enc:\n:param aud: The audience, a list of receivers.\n:return: A dictionary with a signed JWT as value with the key 'sms'", "id": "f14441:c2:m4"}
{"signature": "def __init__(self, fdir, key_conv=None, value_conv=None, c_size=<NUM_LIT:0>):", "body": "self.fdir = fdir<EOL>self.fmtime = {}<EOL>self.db = {}<EOL>self.key_conv = key_conv or {}<EOL>self.value_conv = value_conv or {}<EOL>if not os.path.isdir(fdir):<EOL><INDENT>os.makedirs(fdir)<EOL><DEDENT>", "docstring": ":param fdir: The root of the directory\n:param key_conv: Converts to/from the key displayed by this class to\nusers of it to something that can be used as a file name.\nThe value of key_conv is a dictionary with to keys ['to', 'from']\nwhere the value of 'to' is a function that can be used to convert\nthe instance key value to the file name. The value of 'from' is a\nfunction that can be used to convert a file name to a key value.\n:type key_conv: Dictionary\n:param value_conv: As with key_conv you can convert/translate\nthe value bound to a key in the database to something that can easily\nbe stored in a file. Like with key_conv the value of this parameter\nis a dictionary with the keys ['to', 'from'].\n:type value_conv: dictionary", "id": "f14442:c0:m0"}
{"signature": "def clear(self):", "body": "if not os.path.isdir(self.fdir):<EOL><INDENT>os.makedirs(self.fdir, exist_ok=True)<EOL>return<EOL><DEDENT>for f in os.listdir(self.fdir):<EOL><INDENT>del self[f]<EOL><DEDENT>", "docstring": "Completely resets the database. This means that all information in\nthe local cache and on disc will be erased.", "id": "f14442:c0:m10"}
{"signature": "def _parse_remote_response(self, response):", "body": "<EOL>try:<EOL><INDENT>if response.headers[\"<STR_LIT:Content-Type>\"] == '<STR_LIT:application/json>':<EOL><INDENT>logger.debug(<EOL>\"<STR_LIT>\" % (response.text, self.source))<EOL>try:<EOL><INDENT>return json.loads(response.text)<EOL><DEDENT>except ValueError:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>elif response.headers[\"<STR_LIT:Content-Type>\"] == '<STR_LIT>':<EOL><INDENT>logger.debug(<EOL>\"<STR_LIT>\" % (response.text, self.source))<EOL>_jws = factory(response.text)<EOL>_resp = _jws.verify_compact(<EOL>response.text, keys=self.verify_keys.get_signing_key())<EOL>return _resp<EOL><DEDENT>else:<EOL><INDENT>logger.error('<STR_LIT>'.format(<EOL>response.headers['<STR_LIT:Content-Type>']))<EOL>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Parse simple JWKS or signed JWKS from the HTTP response.\n\n:param response: HTTP response from the 'jwks_uri' or 'signed_jwks_uri'\n    endpoint\n:return: response parsed as JSON or None", "id": "f14443:c7:m1"}
{"signature": "def create_compounded_metadata_statement(entity_id, entity_dict, statement,<EOL>context='<STR_LIT>', lifetime=<NUM_LIT>):", "body": "n = len(entity_id)<EOL>i = n-<NUM_LIT:1><EOL>fo = entity_dict[entity_id[i]].iss<EOL>sms = None<EOL>i -= <NUM_LIT:1><EOL>while i >= <NUM_LIT:0>:<EOL><INDENT>cms = statement[entity_id[i]]<EOL>ent = entity_dict[entity_id[i]]<EOL>ent.add_signing_keys(cms)<EOL>sup = entity_dict[entity_id[i+<NUM_LIT:1>]]<EOL>sup.add_sms_spec_to_request(cms, context=context)<EOL>sms = sup.self_signer.sign(cms, ent.iss, lifetime=lifetime)<EOL>try:<EOL><INDENT>ent.metadata_statements[context][fo] = sms<EOL><DEDENT>except KeyError:<EOL><INDENT>ent.metadata_statements[context] = {fo: sms}<EOL><DEDENT>i -= <NUM_LIT:1><EOL><DEDENT>return sms<EOL>", "docstring": ":param entity_id:\n:param entity_dict:\n:param statement:\n:param context:\n:param lifetime:\n:return:", "id": "f14444:m3"}
{"signature": "def verify_self_signed_jwks(sjwt):", "body": "_jws = factory(sjwt)<EOL>_json = _jws.jwt.part[<NUM_LIT:1>]<EOL>_body = json.loads(as_unicode(_json))<EOL>iss = _body['<STR_LIT>']<EOL>_jwks = _body['<STR_LIT>']<EOL>_kj = jwks_to_keyjar(_jwks, iss)<EOL>try:<EOL><INDENT>_kid = _jws.jwt.headers['<STR_LIT>']<EOL><DEDENT>except KeyError:<EOL><INDENT>_keys = _kj.get_signing_key(owner=iss)<EOL><DEDENT>else:<EOL><INDENT>_keys = _kj.get_signing_key(owner=iss, kid=_kid)<EOL><DEDENT>_ver = _jws.verify_compact(sjwt, _keys)<EOL>return {'<STR_LIT>': _ver['<STR_LIT>'], '<STR_LIT>': iss}<EOL>", "docstring": "Verify the signature of a signed JWT containing a JWKS.\nThe JWT is signed by one of the keys in the JWKS. \nIn the JWT the JWKS is stored using this format ::\n\n    'jwks': {\n        'keys': [ ]\n    }\n\n:param sjwt: Signed Jason Web Token\n:return: Dictionary containing 'jwks' (the JWKS) and 'iss' (the issuer of \n    the JWT)", "id": "f14445:m1"}
{"signature": "def self_sign_jwks(keyjar, iss, kid='<STR_LIT>', lifetime=<NUM_LIT>):", "body": "<EOL>_jwt = JWT(keyjar, iss=iss, lifetime=lifetime)<EOL>jwks = keyjar.export_jwks(issuer=iss)<EOL>return _jwt.pack(payload={'<STR_LIT>': jwks}, owner=iss, kid=kid)<EOL>", "docstring": "Create a signed JWT containing a JWKS. The JWT is signed by one of the\nkeys in the JWKS.\n\n:param keyjar: A KeyJar instance with at least one private signing key\n:param iss: issuer of the JWT, should be the owner of the keys\n:param kid: A key ID if a special key should be used otherwise one\n    is picked at random.\n:param lifetime: The lifetime of the signed JWT\n:return: A signed JWT", "id": "f14445:m0"}
{"signature": "def evaluate_metadata_statement(self, metadata, keyjar=None):", "body": "<EOL>res = dict([(k, v) for k, v in metadata.items() if k not in IgnoreKeys])<EOL>les = []<EOL>if '<STR_LIT>' in metadata:<EOL><INDENT>for fo, ms in metadata['<STR_LIT>'].items():<EOL><INDENT>if isinstance(ms, str):<EOL><INDENT>ms = json.loads(ms)<EOL><DEDENT>for _le in self.evaluate_metadata_statement(ms):<EOL><INDENT>if isinstance(ms, Message):<EOL><INDENT>le = LessOrEqual(sup=_le, **ms.to_dict())<EOL><DEDENT>else:  <EOL><INDENT>le = LessOrEqual(sup=_le, **ms)<EOL><DEDENT>if le.is_expired():<EOL><INDENT>logger.error(<EOL>'<STR_LIT>'.format(ms)<EOL>)<EOL>logger.info('<STR_LIT>'.format(utc_time_sans_frac()))<EOL>continue<EOL><DEDENT>le.eval(res)<EOL>les.append(le)<EOL><DEDENT><DEDENT>return les<EOL><DEDENT>else:  <EOL><INDENT>try:<EOL><INDENT>_iss = metadata['<STR_LIT>']<EOL><DEDENT>except:<EOL><INDENT>le = LessOrEqual()<EOL>le.eval(res)<EOL><DEDENT>else:<EOL><INDENT>le = LessOrEqual(iss=_iss, exp=metadata['<STR_LIT>'])<EOL>le.eval(res)<EOL><DEDENT>les.append(le)<EOL>return les<EOL><DEDENT>", "docstring": "Computes the resulting metadata statement from a compounded metadata\nstatement.\nIf something goes wrong during the evaluation an exception is raised\n\n:param metadata: The compounded metadata statement as a dictionary\n:return: A list of :py:class:`fedoidc.operator.LessOrEqual` \n    instances, one per FO.", "id": "f14447:c3:m8"}
{"signature": "def unprotected_and_protected_claims(self):", "body": "if self.sup:<EOL><INDENT>res = {}<EOL>for k, v in self.le.items():<EOL><INDENT>if k not in self.sup.le:<EOL><INDENT>res[k] = v<EOL><DEDENT>else:<EOL><INDENT>res[k] = self.sup.le[k]<EOL><DEDENT><DEDENT>return res<EOL><DEDENT>else:<EOL><INDENT>return self.le<EOL><DEDENT>", "docstring": "This is both verified and self asserted information. As expected \nverified information beats self-asserted so if there is both \nself-asserted and verified values for a claim then only the verified\nwill be returned.", "id": "f14447:c2:m9"}
{"signature": "def __init__(self,<EOL>inplanes,<EOL>planes,<EOL>stride=<NUM_LIT:1>,<EOL>dilation=<NUM_LIT:1>,<EOL>downsample=None,<EOL>style='<STR_LIT>',<EOL>with_cp=False):", "body": "super(Bottleneck, self).__init__()<EOL>assert style in ['<STR_LIT>', '<STR_LIT>']<EOL>if style == '<STR_LIT>':<EOL><INDENT>conv1_stride = <NUM_LIT:1><EOL>conv2_stride = stride<EOL><DEDENT>else:<EOL><INDENT>conv1_stride = stride<EOL>conv2_stride = <NUM_LIT:1><EOL><DEDENT>self.conv1 = nn.Conv2d(<EOL>inplanes, planes, kernel_size=<NUM_LIT:1>, stride=conv1_stride, bias=False)<EOL>self.conv2 = nn.Conv2d(<EOL>planes,<EOL>planes,<EOL>kernel_size=<NUM_LIT:3>,<EOL>stride=conv2_stride,<EOL>padding=dilation,<EOL>dilation=dilation,<EOL>bias=False)<EOL>self.bn1 = nn.BatchNorm2d(planes)<EOL>self.bn2 = nn.BatchNorm2d(planes)<EOL>self.conv3 = nn.Conv2d(<EOL>planes, planes * self.expansion, kernel_size=<NUM_LIT:1>, bias=False)<EOL>self.bn3 = nn.BatchNorm2d(planes * self.expansion)<EOL>self.relu = nn.ReLU(inplace=True)<EOL>self.downsample = downsample<EOL>self.stride = stride<EOL>self.dilation = dilation<EOL>self.with_cp = with_cp<EOL>", "docstring": "Bottleneck block.\n\n        If style is \"pytorch\", the stride-two layer is the 3x3 conv layer,\n        if it is \"caffe\", the stride-two layer is the first 1x1 conv layer.", "id": "f14470:c1:m0"}
{"signature": "def conv3x3(in_planes, out_planes, dilation=<NUM_LIT:1>):", "body": "return nn.Conv2d(<EOL>in_planes,<EOL>out_planes,<EOL>kernel_size=<NUM_LIT:3>,<EOL>padding=dilation,<EOL>dilation=dilation)<EOL>", "docstring": "3x3 convolution with padding", "id": "f14472:m0"}
{"signature": "def quantize_flow(flow, max_val=<NUM_LIT>, norm=True):", "body": "h, w, _ = flow.shape<EOL>dx = flow[..., <NUM_LIT:0>]<EOL>dy = flow[..., <NUM_LIT:1>]<EOL>if norm:<EOL><INDENT>dx = dx / w  <EOL>dy = dy / h<EOL><DEDENT>flow_comps = [<EOL>quantize(d, -max_val, max_val, <NUM_LIT:255>, np.uint8) for d in [dx, dy]<EOL>]<EOL>return tuple(flow_comps)<EOL>", "docstring": "Quantize flow to [0, 255].\n\n    After this step, the size of flow will be much smaller, and can be\n    dumped as jpeg images.\n\n    Args:\n        flow (ndarray): (h, w, 2) array of optical flow.\n        max_val (float): Maximum value of flow, values beyond\n                        [-max_val, max_val] will be truncated.\n        norm (bool): Whether to divide flow values by image width/height.\n\n    Returns:\n        tuple[ndarray]: Quantized dx and dy.", "id": "f14474:m2"}
{"signature": "@requires_executable('<STR_LIT>')<EOL>def cut_video(in_file,<EOL>out_file,<EOL>start=None,<EOL>end=None,<EOL>vcodec=None,<EOL>acodec=None,<EOL>log_level='<STR_LIT:info>',<EOL>print_cmd=False,<EOL>**kwargs):", "body": "options = {'<STR_LIT>': log_level}<EOL>if vcodec is None:<EOL><INDENT>options['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>if acodec is None:<EOL><INDENT>options['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>if start:<EOL><INDENT>options['<STR_LIT>'] = start<EOL><DEDENT>else:<EOL><INDENT>start = <NUM_LIT:0><EOL><DEDENT>if end:<EOL><INDENT>options['<STR_LIT:t>'] = end - start<EOL><DEDENT>convert_video(in_file, out_file, print_cmd, **options)<EOL>", "docstring": "Cut a clip from a video.\n\n    Args:\n        in_file (str): Input video filename.\n        out_file (str): Output video filename.\n        start (None or float): Start time (in seconds).\n        end (None or float): End time (in seconds).\n        vcodec (None or str): Output video codec, None for unchanged.\n        acodec (None or str): Output audio codec, None for unchanged.\n        log_level (str): Logging level of ffmpeg.\n        print_cmd (bool): Whether to print the final ffmpeg command.", "id": "f14476:m2"}
{"signature": "@property<EOL><INDENT>def fps(self):<DEDENT>", "body": "return self._fps<EOL>", "docstring": "float: FPS of the video.", "id": "f14477:c1:m6"}
{"signature": "def cvt2frames(self,<EOL>frame_dir,<EOL>file_start=<NUM_LIT:0>,<EOL>filename_tmpl='<STR_LIT>',<EOL>start=<NUM_LIT:0>,<EOL>max_num=<NUM_LIT:0>,<EOL>show_progress=True):", "body": "mkdir_or_exist(frame_dir)<EOL>if max_num == <NUM_LIT:0>:<EOL><INDENT>task_num = self.frame_cnt - start<EOL><DEDENT>else:<EOL><INDENT>task_num = min(self.frame_cnt - start, max_num)<EOL><DEDENT>if task_num <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if start > <NUM_LIT:0>:<EOL><INDENT>self._set_real_position(start)<EOL><DEDENT>def write_frame(file_idx):<EOL><INDENT>img = self.read()<EOL>filename = osp.join(frame_dir, filename_tmpl.format(file_idx))<EOL>cv2.imwrite(filename, img)<EOL><DEDENT>if show_progress:<EOL><INDENT>track_progress(write_frame, range(file_start,<EOL>file_start + task_num))<EOL><DEDENT>else:<EOL><INDENT>for i in range(task_num):<EOL><INDENT>img = self.read()<EOL>if img is None:<EOL><INDENT>break<EOL><DEDENT>filename = osp.join(frame_dir,<EOL>filename_tmpl.format(i + file_start))<EOL>cv2.imwrite(filename, img)<EOL><DEDENT><DEDENT>", "docstring": "Convert a video to frame images\n\n        Args:\n            frame_dir (str): Output directory to store all the frame images.\n            file_start (int): Filenames will start from the specified number.\n            filename_tmpl (str): Filename template with the index as the\n                placeholder.\n            start (int): The starting frame index.\n            max_num (int): Maximum number of frames to be written.\n            show_progress (bool): Whether to show a progress bar.", "id": "f14477:c1:m15"}
{"signature": "def read(self):", "body": "<EOL>if self._cache:<EOL><INDENT>img = self._cache.get(self._position)<EOL>if img is not None:<EOL><INDENT>ret = True<EOL><DEDENT>else:<EOL><INDENT>if self._position != self._get_real_position():<EOL><INDENT>self._set_real_position(self._position)<EOL><DEDENT>ret, img = self._vcap.read()<EOL>if ret:<EOL><INDENT>self._cache.put(self._position, img)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>ret, img = self._vcap.read()<EOL><DEDENT>if ret:<EOL><INDENT>self._position += <NUM_LIT:1><EOL><DEDENT>return img<EOL>", "docstring": "Read the next frame.\n\n        If the next frame have been decoded before and in the cache, then\n        return it directly, otherwise decode, cache and return it.\n\n        Returns:\n            ndarray or None: Return the frame if successful, otherwise None.", "id": "f14477:c1:m12"}
{"signature": "def load_state_dict(module, state_dict, strict=False, logger=None):", "body": "unexpected_keys = []<EOL>own_state = module.state_dict()<EOL>for name, param in state_dict.items():<EOL><INDENT>if name not in own_state:<EOL><INDENT>unexpected_keys.append(name)<EOL>continue<EOL><DEDENT>if isinstance(param, torch.nn.Parameter):<EOL><INDENT>param = param.data<EOL><DEDENT>try:<EOL><INDENT>own_state[name].copy_(param)<EOL><DEDENT>except Exception:<EOL><INDENT>raise RuntimeError('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>.format(name, own_state[name].size(),<EOL>param.size()))<EOL><DEDENT><DEDENT>missing_keys = set(own_state.keys()) - set(state_dict.keys())<EOL>err_msg = []<EOL>if unexpected_keys:<EOL><INDENT>err_msg.append('<STR_LIT>'.format(<EOL>'<STR_LIT:U+002CU+0020>'.join(unexpected_keys)))<EOL><DEDENT>if missing_keys:<EOL><INDENT>err_msg.append('<STR_LIT>'.format(<EOL>'<STR_LIT:U+002CU+0020>'.join(missing_keys)))<EOL><DEDENT>err_msg = '<STR_LIT:\\n>'.join(err_msg)<EOL>if err_msg:<EOL><INDENT>if strict:<EOL><INDENT>raise RuntimeError(err_msg)<EOL><DEDENT>elif logger is not None:<EOL><INDENT>logger.warn(err_msg)<EOL><DEDENT>else:<EOL><INDENT>print(err_msg)<EOL><DEDENT><DEDENT>", "docstring": "Load state_dict to a module.\n\n    This method is modified from :meth:`torch.nn.Module.load_state_dict`.\n    Default value for ``strict`` is set to ``False`` and the message for\n    param mismatch will be shown even if strict is False.\n\n    Args:\n        module (Module): Module that receives the state_dict.\n        state_dict (OrderedDict): Weights.\n        strict (bool): whether to strictly enforce that the keys\n            in :attr:`state_dict` match the keys returned by this module's\n            :meth:`~torch.nn.Module.state_dict` function. Default: ``False``.\n        logger (:obj:`logging.Logger`, optional): Logger to log the error\n            message. If not specified, print function will be used.", "id": "f14493:m0"}
{"signature": "@property<EOL><INDENT>def rank(self):<DEDENT>", "body": "return self._rank<EOL>", "docstring": "int: Rank of current process. (distributed training)", "id": "f14497:c0:m2"}
{"signature": "@property<EOL><INDENT>def hooks(self):<DEDENT>", "body": "return self._hooks<EOL>", "docstring": "list[:obj:`Hook`]: A list of registered hooks.", "id": "f14497:c0:m4"}
{"signature": "def run(self, data_loaders, workflow, max_epochs, **kwargs):", "body": "assert isinstance(data_loaders, list)<EOL>assert mmcv.is_list_of(workflow, tuple)<EOL>assert len(data_loaders) == len(workflow)<EOL>self._max_epochs = max_epochs<EOL>work_dir = self.work_dir if self.work_dir is not None else '<STR_LIT>'<EOL>self.logger.info('<STR_LIT>',<EOL>get_host_info(), work_dir)<EOL>self.logger.info('<STR_LIT>', workflow, max_epochs)<EOL>self.call_hook('<STR_LIT>')<EOL>while self.epoch < max_epochs:<EOL><INDENT>for i, flow in enumerate(workflow):<EOL><INDENT>mode, epochs = flow<EOL>if isinstance(mode, str):  <EOL><INDENT>if not hasattr(self, mode):<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'.<EOL>format(mode))<EOL><DEDENT>epoch_runner = getattr(self, mode)<EOL><DEDENT>elif callable(mode):  <EOL><INDENT>epoch_runner = mode<EOL><DEDENT>else:<EOL><INDENT>raise TypeError('<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>type(mode)))<EOL><DEDENT>for _ in range(epochs):<EOL><INDENT>if mode == '<STR_LIT:train>' and self.epoch >= max_epochs:<EOL><INDENT>return<EOL><DEDENT>epoch_runner(data_loaders[i], **kwargs)<EOL><DEDENT><DEDENT><DEDENT>time.sleep(<NUM_LIT:1>)  <EOL>self.call_hook('<STR_LIT>')<EOL>", "docstring": "Start running.\n\n        Args:\n            data_loaders (list[:obj:`DataLoader`]): Dataloaders for training\n                and validation.\n            workflow (list[tuple]): A list of (phase, epochs) to specify the\n                running order and epochs. E.g, [('train', 2), ('val', 1)] means\n                running 2 epochs for training and 1 epoch for validation,\n                iteratively.\n            max_epochs (int): Total training epochs.", "id": "f14497:c0:m22"}
{"signature": "@property<EOL><INDENT>def max_iters(self):<DEDENT>", "body": "return self._max_iters<EOL>", "docstring": "int: Maximum training iterations.", "id": "f14497:c0:m9"}
{"signature": "def is_seq_of(seq, expected_type, seq_type=None):", "body": "if seq_type is None:<EOL><INDENT>exp_seq_type = collections_abc.Sequence<EOL><DEDENT>else:<EOL><INDENT>assert isinstance(seq_type, type)<EOL>exp_seq_type = seq_type<EOL><DEDENT>if not isinstance(seq, exp_seq_type):<EOL><INDENT>return False<EOL><DEDENT>for item in seq:<EOL><INDENT>if not isinstance(item, expected_type):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Check whether it is a sequence of some type.\n\n    Args:\n        seq (Sequence): The sequence to be checked.\n        expected_type (type): Expected type of sequence items.\n        seq_type (type, optional): Expected sequence type.\n\n    Returns:\n        bool: Whether the sequence is valid.", "id": "f14501:m4"}
{"signature": "def tuple_cast(inputs, dst_type):", "body": "return iter_cast(inputs, dst_type, return_type=tuple)<EOL>", "docstring": "Cast elements of an iterable object into a tuple of some type.\n\n    A partial method of :func:`iter_cast`.", "id": "f14501:m3"}
{"signature": "def requires_executable(prerequisites):", "body": "return check_prerequisites(prerequisites, checker=_check_executable)<EOL>", "docstring": "A decorator to check if some executable files are installed.\n\n    Example:\n        >>> @requires_executable('ffmpeg')\n        >>> func(arg1, args):\n        >>>     print(1)\n        1", "id": "f14501:m13"}
{"signature": "def is_str(x):", "body": "return isinstance(x, six.string_types)<EOL>", "docstring": "Whether the input is an string instance.", "id": "f14501:m0"}
{"signature": "def concat_list(in_list):", "body": "return list(itertools.chain(*in_list))<EOL>", "docstring": "Concatenate a list of list into a single list.\n\n    Args:\n        in_list (list): The list of list to be merged.\n\n    Returns:\n        list: The concatenated flat list.", "id": "f14501:m8"}
{"signature": "def is_list_of(seq, expected_type):", "body": "return is_seq_of(seq, expected_type, seq_type=list)<EOL>", "docstring": "Check whether it is a list of some type.\n\n    A partial method of :func:`is_seq_of`.", "id": "f14501:m5"}
{"signature": "def is_tuple_of(seq, expected_type):", "body": "return is_seq_of(seq, expected_type, seq_type=tuple)<EOL>", "docstring": "Check whether it is a tuple of some type.\n\n    A partial method of :func:`is_seq_of`.", "id": "f14501:m6"}
{"signature": "def check_time(timer_id):", "body": "if timer_id not in _g_timers:<EOL><INDENT>_g_timers[timer_id] = Timer()<EOL>return <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>return _g_timers[timer_id].since_last_check()<EOL><DEDENT>", "docstring": "Add check points in a single line.\n\n    This method is suitable for running a task on a list of items. A timer will\n    be registered when the method is called for the first time.\n\n    :Example:\n\n    >>> import time\n    >>> import mmcv\n    >>> for i in range(1, 6):\n    >>>     # simulate a code block\n    >>>     time.sleep(i)\n    >>>     mmcv.check_time('task1')\n    2.000\n    3.000\n    4.000\n    5.000\n\n    Args:\n        timer_id (str): Timer identifier.", "id": "f14502:m0"}
{"signature": "def imshow_det_bboxes(img,<EOL>bboxes,<EOL>labels,<EOL>class_names=None,<EOL>score_thr=<NUM_LIT:0>,<EOL>bbox_color='<STR_LIT>',<EOL>text_color='<STR_LIT>',<EOL>thickness=<NUM_LIT:1>,<EOL>font_scale=<NUM_LIT:0.5>,<EOL>show=True,<EOL>win_name='<STR_LIT>',<EOL>wait_time=<NUM_LIT:0>,<EOL>out_file=None):", "body": "assert bboxes.ndim == <NUM_LIT:2><EOL>assert labels.ndim == <NUM_LIT:1><EOL>assert bboxes.shape[<NUM_LIT:0>] == labels.shape[<NUM_LIT:0>]<EOL>assert bboxes.shape[<NUM_LIT:1>] == <NUM_LIT:4> or bboxes.shape[<NUM_LIT:1>] == <NUM_LIT:5><EOL>img = imread(img)<EOL>if score_thr > <NUM_LIT:0>:<EOL><INDENT>assert bboxes.shape[<NUM_LIT:1>] == <NUM_LIT:5><EOL>scores = bboxes[:, -<NUM_LIT:1>]<EOL>inds = scores > score_thr<EOL>bboxes = bboxes[inds, :]<EOL>labels = labels[inds]<EOL><DEDENT>bbox_color = color_val(bbox_color)<EOL>text_color = color_val(text_color)<EOL>for bbox, label in zip(bboxes, labels):<EOL><INDENT>bbox_int = bbox.astype(np.int32)<EOL>left_top = (bbox_int[<NUM_LIT:0>], bbox_int[<NUM_LIT:1>])<EOL>right_bottom = (bbox_int[<NUM_LIT:2>], bbox_int[<NUM_LIT:3>])<EOL>cv2.rectangle(<EOL>img, left_top, right_bottom, bbox_color, thickness=thickness)<EOL>label_text = class_names[<EOL>label] if class_names is not None else '<STR_LIT>'.format(label)<EOL>if len(bbox) > <NUM_LIT:4>:<EOL><INDENT>label_text += '<STR_LIT>'.format(bbox[-<NUM_LIT:1>])<EOL><DEDENT>cv2.putText(img, label_text, (bbox_int[<NUM_LIT:0>], bbox_int[<NUM_LIT:1>] - <NUM_LIT:2>),<EOL>cv2.FONT_HERSHEY_COMPLEX, font_scale, text_color)<EOL><DEDENT>if show:<EOL><INDENT>imshow(img, win_name, wait_time)<EOL><DEDENT>if out_file is not None:<EOL><INDENT>imwrite(img, out_file)<EOL><DEDENT>", "docstring": "Draw bboxes and class labels (with scores) on an image.\n\n    Args:\n        img (str or ndarray): The image to be displayed.\n        bboxes (ndarray): Bounding boxes (with scores), shaped (n, 4) or\n            (n, 5).\n        labels (ndarray): Labels of bboxes.\n        class_names (list[str]): Names of each classes.\n        score_thr (float): Minimum score of bboxes to be shown.\n        bbox_color (str or tuple or :obj:`Color`): Color of bbox lines.\n        text_color (str or tuple or :obj:`Color`): Color of texts.\n        thickness (int): Thickness of lines.\n        font_scale (float): Font scales of texts.\n        show (bool): Whether to show the image.\n        win_name (str): The window name.\n        wait_time (int): Value of waitKey param.\n        out_file (str or None): The filename to write the image.", "id": "f14506:m2"}
{"signature": "def _register_handler(handler, file_formats):", "body": "if not isinstance(handler, BaseFileHandler):<EOL><INDENT>raise TypeError(<EOL>'<STR_LIT>'.format(<EOL>type(handler)))<EOL><DEDENT>if isinstance(file_formats, str):<EOL><INDENT>file_formats = [file_formats]<EOL><DEDENT>if not is_list_of(file_formats, str):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>for ext in file_formats:<EOL><INDENT>file_handlers[ext] = handler<EOL><DEDENT>", "docstring": "Register a handler for some file extensions.\n\n    Args:\n        handler (:obj:`BaseFileHandler`): Handler to be registered.\n        file_formats (str or list[str]): File formats to be handled by this\n            handler.", "id": "f14517:m2"}
{"signature": "def imresize(img, size, return_scale=False, interpolation='<STR_LIT>'):", "body": "h, w = img.shape[:<NUM_LIT:2>]<EOL>resized_img = cv2.resize(<EOL>img, size, interpolation=interp_codes[interpolation])<EOL>if not return_scale:<EOL><INDENT>return resized_img<EOL><DEDENT>else:<EOL><INDENT>w_scale = size[<NUM_LIT:0>] / w<EOL>h_scale = size[<NUM_LIT:1>] / h<EOL>return resized_img, w_scale, h_scale<EOL><DEDENT>", "docstring": "Resize image to a given size.\n\n    Args:\n        img (ndarray): The input image.\n        size (tuple): Target (w, h).\n        return_scale (bool): Whether to return `w_scale` and `h_scale`.\n        interpolation (str): Interpolation method, accepted values are\n            \"nearest\", \"bilinear\", \"bicubic\", \"area\", \"lanczos\".\n\n    Returns:\n        tuple or ndarray: (`resized_img`, `w_scale`, `h_scale`) or\n            `resized_img`.", "id": "f14519:m1"}
{"signature": "def imrescale(img, scale, return_scale=False, interpolation='<STR_LIT>'):", "body": "h, w = img.shape[:<NUM_LIT:2>]<EOL>if isinstance(scale, (float, int)):<EOL><INDENT>if scale <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'.format(scale))<EOL><DEDENT>scale_factor = scale<EOL><DEDENT>elif isinstance(scale, tuple):<EOL><INDENT>max_long_edge = max(scale)<EOL>max_short_edge = min(scale)<EOL>scale_factor = min(max_long_edge / max(h, w),<EOL>max_short_edge / min(h, w))<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(<EOL>'<STR_LIT>'.format(<EOL>type(scale)))<EOL><DEDENT>new_size = _scale_size((w, h), scale_factor)<EOL>rescaled_img = imresize(img, new_size, interpolation=interpolation)<EOL>if return_scale:<EOL><INDENT>return rescaled_img, scale_factor<EOL><DEDENT>else:<EOL><INDENT>return rescaled_img<EOL><DEDENT>", "docstring": "Resize image while keeping the aspect ratio.\n\n    Args:\n        img (ndarray): The input image.\n        scale (float or tuple[int]): The scaling factor or maximum size.\n            If it is a float number, then the image will be rescaled by this\n            factor, else if it is a tuple of 2 integers, then the image will\n            be rescaled as large as possible within the scale.\n        return_scale (bool): Whether to return the scaling factor besides the\n            rescaled image.\n        interpolation (str): Same as :func:`resize`.\n\n    Returns:\n        ndarray: The rescaled image.", "id": "f14519:m3"}
{"signature": "def impad(img, shape, pad_val=<NUM_LIT:0>):", "body": "if not isinstance(pad_val, (int, float)):<EOL><INDENT>assert len(pad_val) == img.shape[-<NUM_LIT:1>]<EOL><DEDENT>if len(shape) < len(img.shape):<EOL><INDENT>shape = shape + (img.shape[-<NUM_LIT:1>], )<EOL><DEDENT>assert len(shape) == len(img.shape)<EOL>for i in range(len(shape) - <NUM_LIT:1>):<EOL><INDENT>assert shape[i] >= img.shape[i]<EOL><DEDENT>pad = np.empty(shape, dtype=img.dtype)<EOL>pad[...] = pad_val<EOL>pad[:img.shape[<NUM_LIT:0>], :img.shape[<NUM_LIT:1>], ...] = img<EOL>return pad<EOL>", "docstring": "Pad an image to a certain shape.\n\n    Args:\n        img (ndarray): Image to be padded.\n        shape (tuple): Expected padding shape.\n        pad_val (number or sequence): Values to be filled in padding areas.\n\n    Returns:\n        ndarray: The padded image.", "id": "f14520:m5"}
{"signature": "def imrotate(img,<EOL>angle,<EOL>center=None,<EOL>scale=<NUM_LIT:1.0>,<EOL>border_value=<NUM_LIT:0>,<EOL>auto_bound=False):", "body": "if center is not None and auto_bound:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>h, w = img.shape[:<NUM_LIT:2>]<EOL>if center is None:<EOL><INDENT>center = ((w - <NUM_LIT:1>) * <NUM_LIT:0.5>, (h - <NUM_LIT:1>) * <NUM_LIT:0.5>)<EOL><DEDENT>assert isinstance(center, tuple)<EOL>matrix = cv2.getRotationMatrix2D(center, -angle, scale)<EOL>if auto_bound:<EOL><INDENT>cos = np.abs(matrix[<NUM_LIT:0>, <NUM_LIT:0>])<EOL>sin = np.abs(matrix[<NUM_LIT:0>, <NUM_LIT:1>])<EOL>new_w = h * sin + w * cos<EOL>new_h = h * cos + w * sin<EOL>matrix[<NUM_LIT:0>, <NUM_LIT:2>] += (new_w - w) * <NUM_LIT:0.5><EOL>matrix[<NUM_LIT:1>, <NUM_LIT:2>] += (new_h - h) * <NUM_LIT:0.5><EOL>w = int(np.round(new_w))<EOL>h = int(np.round(new_h))<EOL><DEDENT>rotated = cv2.warpAffine(img, matrix, (w, h), borderValue=border_value)<EOL>return rotated<EOL>", "docstring": "Rotate an image.\n\n    Args:\n        img (ndarray): Image to be rotated.\n        angle (float): Rotation angle in degrees, positive values mean\n            clockwise rotation.\n        center (tuple): Center of the rotation in the source image, by default\n            it is the center of the image.\n        scale (float): Isotropic scale factor.\n        border_value (int): Border value.\n        auto_bound (bool): Whether to adjust the image size to cover the whole\n            rotated image.\n\n    Returns:\n        ndarray: The rotated image.", "id": "f14520:m1"}
{"signature": "def bgr2gray(img, keepdim=False):", "body": "out_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)<EOL>if keepdim:<EOL><INDENT>out_img = out_img[..., None]<EOL><DEDENT>return out_img<EOL>", "docstring": "Convert a BGR image to grayscale image.\n\n    Args:\n        img (ndarray): The input image.\n        keepdim (bool): If False (by default), then return the grayscale image\n            with 2 dims, otherwise 3 dims.\n\n    Returns:\n        ndarray: The converted grayscale image.", "id": "f14521:m1"}
{"signature": "def imfrombytes(content, flag='<STR_LIT>'):", "body": "img_np = np.frombuffer(content, np.uint8)<EOL>flag = imread_flags[flag] if is_str(flag) else flag<EOL>img = cv2.imdecode(img_np, flag)<EOL>return img<EOL>", "docstring": "Read an image from bytes.\n\n    Args:\n        content (bytes): Image bytes got from files or other streams.\n        flag (str): Same as :func:`imread`.\n\n    Returns:\n        ndarray: Loaded image array.", "id": "f14524:m1"}
{"signature": "def scatter_kwargs(inputs, kwargs, target_gpus, dim=<NUM_LIT:0>):", "body": "inputs = scatter(inputs, target_gpus, dim) if inputs else []<EOL>kwargs = scatter(kwargs, target_gpus, dim) if kwargs else []<EOL>if len(inputs) < len(kwargs):<EOL><INDENT>inputs.extend([() for _ in range(len(kwargs) - len(inputs))])<EOL><DEDENT>elif len(kwargs) < len(inputs):<EOL><INDENT>kwargs.extend([{} for _ in range(len(inputs) - len(kwargs))])<EOL><DEDENT>inputs = tuple(inputs)<EOL>kwargs = tuple(kwargs)<EOL>return inputs, kwargs<EOL>", "docstring": "Scatter with support for kwargs dictionary", "id": "f14528:m1"}
{"signature": "def scatter(input, devices, streams=None):", "body": "if streams is None:<EOL><INDENT>streams = [None] * len(devices)<EOL><DEDENT>if isinstance(input, list):<EOL><INDENT>chunk_size = (len(input) - <NUM_LIT:1>) // len(devices) + <NUM_LIT:1><EOL>outputs = [<EOL>scatter(input[i], [devices[i // chunk_size]],<EOL>[streams[i // chunk_size]]) for i in range(len(input))<EOL>]<EOL>return outputs<EOL><DEDENT>elif isinstance(input, torch.Tensor):<EOL><INDENT>output = input.contiguous()<EOL>stream = streams[<NUM_LIT:0>] if output.numel() > <NUM_LIT:0> else None<EOL>with torch.cuda.device(devices[<NUM_LIT:0>]), torch.cuda.stream(stream):<EOL><INDENT>output = output.cuda(devices[<NUM_LIT:0>], non_blocking=True)<EOL><DEDENT>return output<EOL><DEDENT>else:<EOL><INDENT>raise Exception('<STR_LIT>'.format(type(input)))<EOL><DEDENT>", "docstring": "Scatters tensor across multiple GPUs.", "id": "f14529:m0"}
{"signature": "def collate(batch, samples_per_gpu=<NUM_LIT:1>):", "body": "if not isinstance(batch, collections.Sequence):<EOL><INDENT>raise TypeError(\"<STR_LIT>\".format(batch.dtype))<EOL><DEDENT>if isinstance(batch[<NUM_LIT:0>], DataContainer):<EOL><INDENT>assert len(batch) % samples_per_gpu == <NUM_LIT:0><EOL>stacked = []<EOL>if batch[<NUM_LIT:0>].cpu_only:<EOL><INDENT>for i in range(<NUM_LIT:0>, len(batch), samples_per_gpu):<EOL><INDENT>stacked.append(<EOL>[sample.data for sample in batch[i:i + samples_per_gpu]])<EOL><DEDENT>return DataContainer(<EOL>stacked, batch[<NUM_LIT:0>].stack, batch[<NUM_LIT:0>].padding_value, cpu_only=True)<EOL><DEDENT>elif batch[<NUM_LIT:0>].stack:<EOL><INDENT>for i in range(<NUM_LIT:0>, len(batch), samples_per_gpu):<EOL><INDENT>assert isinstance(batch[i].data, torch.Tensor)<EOL>assert batch[i].dim() == <NUM_LIT:3><EOL>c, h, w = batch[i].size()<EOL>for sample in batch[i:i + samples_per_gpu]:<EOL><INDENT>assert c == sample.size(<NUM_LIT:0>)<EOL>h = max(h, sample.size(<NUM_LIT:1>))<EOL>w = max(w, sample.size(<NUM_LIT:2>))<EOL><DEDENT>padded_samples = [<EOL>F.pad(<EOL>sample.data,<EOL>(<NUM_LIT:0>, w - sample.size(<NUM_LIT:2>), <NUM_LIT:0>, h - sample.size(<NUM_LIT:1>)),<EOL>value=sample.padding_value)<EOL>for sample in batch[i:i + samples_per_gpu]<EOL>]<EOL>stacked.append(default_collate(padded_samples))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for i in range(<NUM_LIT:0>, len(batch), samples_per_gpu):<EOL><INDENT>stacked.append(<EOL>[sample.data for sample in batch[i:i + samples_per_gpu]])<EOL><DEDENT><DEDENT>return DataContainer(stacked, batch[<NUM_LIT:0>].stack, batch[<NUM_LIT:0>].padding_value)<EOL><DEDENT>elif isinstance(batch[<NUM_LIT:0>], collections.Sequence):<EOL><INDENT>transposed = zip(*batch)<EOL>return [collate(samples, samples_per_gpu) for samples in transposed]<EOL><DEDENT>elif isinstance(batch[<NUM_LIT:0>], collections.Mapping):<EOL><INDENT>return {<EOL>key: collate([d[key] for d in batch], samples_per_gpu)<EOL>for key in batch[<NUM_LIT:0>]<EOL>}<EOL><DEDENT>else:<EOL><INDENT>return default_collate(batch)<EOL><DEDENT>", "docstring": "Puts each data field into a tensor/DataContainer with outer dimension\n    batch size.\n\n    Extend default_collate to add support for\n    :type:`~mmcv.parallel.DataContainer`. There are 3 cases.\n\n    1. cpu_only = True, e.g., meta data\n    2. cpu_only = False, stack = True, e.g., images tensors\n    3. cpu_only = False, stack = False, e.g., gt bboxes", "id": "f14531:m0"}
{"signature": "def _request(self, method, url, **kwargs):", "body": "resp = self._session.request(method,<EOL>'<STR_LIT>'.format(self._base_url, url),<EOL>headers=self._headers,<EOL>**kwargs)<EOL>try:<EOL><INDENT>resp.raise_for_status()<EOL><DEDENT>except HTTPError as e:<EOL><INDENT>logging.error(resp.content)<EOL>raise RestClientError(e)<EOL><DEDENT>return resp<EOL>", "docstring": "Make HTTP request and return response object\n\n            Args:\n                method (str): GET, POST, PUT, DELETE\n                url (str): path appended to the base_url to create request\n                **kwargs: passed directly to a requests.request object", "id": "f14545:c1:m2"}
{"signature": "def dict_to_object(item, object_name):", "body": "fields = item.keys()<EOL>values = item.values()<EOL>return json.loads(json.dumps(item),<EOL>object_hook=lambda d:<EOL>namedtuple(object_name, fields)(*values))<EOL>", "docstring": "Converts a python dict to a namedtuple, saving memory.", "id": "f14548:m2"}
{"signature": "def _invalid_frequency(self, frequency):", "body": "is_valid = self._is_eod_frequency(frequency) or re.match(self._frequency_pattern, frequency)<EOL>return not is_valid<EOL>", "docstring": "Check to see that frequency was specified correctly\n:param frequency (string): frequency string\n:return (boolean):", "id": "f14548:c3:m8"}
{"signature": "@register.tag<EOL>def plot(parser, token):", "body": "tokens = token.split_contents()<EOL>tokens.pop(<NUM_LIT:0>)<EOL>graph = tokens.pop(<NUM_LIT:0>)<EOL>attrs = dict([token.split(\"<STR_LIT:=>\") for token in tokens])<EOL>if '<STR_LIT:id>' not in attrs.keys():<EOL><INDENT>attrs['<STR_LIT:id>'] = '<STR_LIT>'.join([chr(choice(range(<NUM_LIT>, <NUM_LIT>))) for i in range(<NUM_LIT:0>, <NUM_LIT:5>)])<EOL><DEDENT>else:<EOL><INDENT>attrs['<STR_LIT:id>'] = attrs['<STR_LIT:id>'][<NUM_LIT:1>:len(attrs['<STR_LIT:id>'])-<NUM_LIT:1>]<EOL><DEDENT>attr_string = '<STR_LIT>'.join([\"<STR_LIT>\" % (k, v) for k, v in attrs.iteritems()])<EOL>return GraphRenderer(graph, attr_string, attrs['<STR_LIT:id>'])<EOL>", "docstring": "Tag to plot graphs into the template", "id": "f14559:m0"}
{"signature": "def _get_axis_mode(self, axis):", "body": "if all([isinstance(getattr(s, axis), TimeVariable) for s in self._series]):<EOL><INDENT>return '<STR_LIT:time>'<EOL><DEDENT>return None<EOL>", "docstring": "will get the axis mode for the current series", "id": "f14560:c14:m1"}
{"signature": "def _set_data(self):", "body": "if getattr(self, '<STR_LIT:data>', False) and not getattr(self, '<STR_LIT>', False) and not getattr(self, '<STR_LIT>', False):<EOL><INDENT>_x = XVariable()<EOL>_y = YVariable()<EOL>_x.contribute_to_class(self, '<STR_LIT:X>', self.data)<EOL>_y.contribute_to_class(self, '<STR_LIT:Y>', self.data)<EOL>self['<STR_LIT:data>'] = zip(self._x.points, self._y.points)<EOL><DEDENT>else: <EOL><INDENT>for axis in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>axis_obj = getattr(self, axis, False)<EOL>if not axis_obj:<EOL><INDENT>raise exception.MissingAxisException(\"<STR_LIT>\" % axis)<EOL><DEDENT>if not getattr(axis_obj, '<STR_LIT>', False):<EOL><INDENT>raise exception.MissingDataException()<EOL><DEDENT><DEDENT>self['<STR_LIT:data>'] = zip(self._x.points, self._y.points)<EOL><DEDENT>", "docstring": "This method will be called to set Series data", "id": "f14560:c13:m0"}
{"signature": "def atomize(f, lock=None):", "body": "lock = lock or threading.RLock()<EOL>@functools.wraps(f)<EOL>def exec_atomic(*args, **kwargs):<EOL><INDENT>lock.acquire()<EOL>try:<EOL><INDENT>return f(*args, **kwargs)<EOL><DEDENT>finally:<EOL><INDENT>lock.release()<EOL><DEDENT><DEDENT>return exec_atomic<EOL>", "docstring": "Decorate a function with a reentrant lock to prevent multiple\nthreads from calling said thread simultaneously.", "id": "f14582:m0"}
{"signature": "def __getitem__(self, index: int) -> Tuple:", "body": "<EOL>indexes = self.indexes[index*self.bs:(index+<NUM_LIT:1>)*self.bs]<EOL>X, y = self.__negative_sampling(indexes)<EOL>return X, y<EOL>", "docstring": "Generate one batch of data", "id": "f14585:c0:m2"}
{"signature": "def set_cleaner(self, func: Callable) -> None:", "body": "self.cleaner = func<EOL>", "docstring": "Set the cleaner you wish to use.\n\nThis is a function that f(str) -> str", "id": "f14586:c0:m2"}
{"signature": "def __init__(self,<EOL>cleaner: Callable = None,<EOL>tokenizer: Callable = None) -> None:", "body": "if cleaner is None:<EOL><INDENT>self.cleaner = textacy_cleaner<EOL><DEDENT>if tokenizer is None:<EOL><INDENT>self.tokenizer = text_to_word_sequence<EOL><DEDENT>", "docstring": "cleaner: function that takes as input string and outputs a string\ntokenizer: function that takes as input a list of strings and outputs\n           a list of lists of tokens.", "id": "f14586:c0:m0"}
{"signature": "def set_num_processes(self, n):", "body": "self.num_cores = min(int(n), cpu_count())<EOL>", "docstring": "Set the number of processes for process bases threading.", "id": "f14586:c1:m2"}
{"signature": "@check_yo.setter<EOL><INDENT>def check_yo(self, value):<DEDENT>", "body": "self._check_yo = value<EOL>", "docstring": "Set check_yo", "id": "f14591:c1:m12"}
{"signature": "@dictionary.setter<EOL><INDENT>def dictionary(self, value):<DEDENT>", "body": "self._dictionary = value or {}<EOL>if not isinstance(self._dictionary, dict):<EOL><INDENT>raise BadArgumentError(\"<STR_LIT>\".format(<EOL>self._dictionary))<EOL><DEDENT>", "docstring": "Set dictionary", "id": "f14591:c1:m8"}
{"signature": "@property<EOL><INDENT>def flag_latin(self):<DEDENT>", "body": "return self._flag_latin<EOL>", "docstring": "Get flag_latin", "id": "f14591:c1:m29"}
{"signature": "@property<EOL><INDENT>def is_debug(self):<DEDENT>", "body": "return self._is_debug<EOL>", "docstring": "Get is_debug", "id": "f14591:c1:m35"}
{"signature": "@property<EOL><INDENT>def ignore_urls(self):<DEDENT>", "body": "return self._ignore_urls<EOL>", "docstring": "Get ignore_urls", "id": "f14591:c1:m13"}
{"signature": "@property<EOL><INDENT>def dictionary(self):<DEDENT>", "body": "return self._dictionary<EOL>", "docstring": "Get dictionary", "id": "f14591:c1:m7"}
{"signature": "@property<EOL><INDENT>def api_options(self):<DEDENT>", "body": "options = <NUM_LIT:0><EOL>if self._ignore_uppercase:<EOL><INDENT>options |= <NUM_LIT:1><EOL><DEDENT>if self._ignore_digits:<EOL><INDENT>options |= <NUM_LIT:2><EOL><DEDENT>if self._ignore_urls:<EOL><INDENT>options |= <NUM_LIT:4><EOL><DEDENT>if self._find_repeat_words:<EOL><INDENT>options |= <NUM_LIT:8><EOL><DEDENT>if self._ignore_latin:<EOL><INDENT>options |= <NUM_LIT:16><EOL><DEDENT>if self._flag_latin:<EOL><INDENT>options |= <NUM_LIT><EOL><DEDENT>if self._by_words:<EOL><INDENT>options |= <NUM_LIT><EOL><DEDENT>if self._ignore_capitalization:<EOL><INDENT>options |= <NUM_LIT><EOL><DEDENT>if self._ignore_roman_numerals:<EOL><INDENT>options |= <NUM_LIT><EOL><DEDENT>return options<EOL>", "docstring": "current spelling settings\n:return: api options as number", "id": "f14591:c1:m38"}
{"signature": "@property<EOL><INDENT>def find_repeat_words(self):<DEDENT>", "body": "return self._find_repeat_words<EOL>", "docstring": "Get find_repeat_words", "id": "f14591:c1:m27"}
{"signature": "@ignore_tags.setter<EOL><INDENT>def ignore_tags(self, value):<DEDENT>", "body": "self._ignore_tags = value<EOL>", "docstring": "Set ignore_tags", "id": "f14591:c1:m16"}
{"signature": "@ignore_roman_numerals.setter<EOL><INDENT>def ignore_roman_numerals(self, value):<DEDENT>", "body": "self._ignore_roman_numerals = value<EOL>", "docstring": "Set ignore_roman_numerals", "id": "f14591:c1:m24"}
{"signature": "@report_type.setter<EOL><INDENT>def report_type(self, value):<DEDENT>", "body": "self._report_type = value or '<STR_LIT>'<EOL>", "docstring": "Set report_type", "id": "f14591:c1:m10"}
{"signature": "@ignore_uppercase.setter<EOL><INDENT>def ignore_uppercase(self, value):<DEDENT>", "body": "self._ignore_uppercase = value<EOL>", "docstring": "Set ignore_uppercase", "id": "f14591:c1:m26"}
{"signature": "@property<EOL><INDENT>def lang(self):<DEDENT>", "body": "return self._lang<EOL>", "docstring": "Get lang", "id": "f14591:c1:m3"}
{"signature": "@flag_latin.setter<EOL><INDENT>def flag_latin(self, value):<DEDENT>", "body": "self._flag_latin = value<EOL>", "docstring": "Set flag_latin", "id": "f14591:c1:m30"}
{"signature": "@lang.setter<EOL><INDENT>def lang(self, language):<DEDENT>", "body": "if isinstance(language, str):<EOL><INDENT>self._lang = [language]<EOL><DEDENT>elif isinstance(language, collections.Iterable):<EOL><INDENT>self._lang = list(language)<EOL><DEDENT>if any(lang not in self._supported_langs for lang in self._lang):<EOL><INDENT>raise BadArgumentError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Set lang", "id": "f14591:c1:m4"}
{"signature": "@property<EOL><INDENT>def report_type(self):<DEDENT>", "body": "return self._report_type<EOL>", "docstring": "Get report_type", "id": "f14591:c1:m9"}
{"signature": "@is_debug.setter<EOL><INDENT>def is_debug(self, value):<DEDENT>", "body": "self._is_debug = value<EOL>", "docstring": "Set is_debug", "id": "f14591:c1:m36"}
{"signature": "def timestamp_a__d_b_Y_H_M_S_z(value):", "body": "a, d, b, Y, t, z = value.split()<EOL>H, M, S = t.split(\"<STR_LIT::>\")<EOL>return int(calendar.timegm((<EOL>int(Y), _months[b.lower()], int(d), int(H), int(M), int(S), <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0><EOL>))) - _offset(z)<EOL>", "docstring": "Convert timestamp string to time in seconds since epoch.\n\n    Timestamps strings like 'Tue, 18 Jun 2013 22:00:00 +1000' are able to be\n    converted by this function.\n\n    Args:\n        value: A timestamp string in the format '%a, %d %b %Y %H:%M:%S %z'.\n\n    Returns:\n        The time in seconds since epoch as an integer.\n\n    Raises:\n        ValueError: If timestamp is invalid.\n        KeyError: If the abbrieviated month is invalid.", "id": "f14597:m3"}
{"signature": "def timestamp(value, fmt=None):", "body": "if fmt:<EOL><INDENT>return _timestamp_formats.get(fmt,<EOL>lambda v: timestamp_fmt(v, fmt)<EOL>)(value)<EOL><DEDENT>l = len(value)<EOL>if <NUM_LIT> <= l <= <NUM_LIT> and value[<NUM_LIT:3>] == \"<STR_LIT:U+0020>\":<EOL><INDENT>try:<EOL><INDENT>return timestamp_d_b_Y_H_M_S(value)<EOL><DEDENT>except (KeyError, ValueError, OverflowError):<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if <NUM_LIT:30> <= l <= <NUM_LIT>:<EOL><INDENT>try:<EOL><INDENT>return timestamp_a__d_b_Y_H_M_S_z(value)<EOL><DEDENT>except (KeyError, ValueError, OverflowError):<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if l == <NUM_LIT>:<EOL><INDENT>try:<EOL><INDENT>return timestamp_YmdHMS(value)<EOL><DEDENT>except (ValueError, OverflowError):<EOL><INDENT>pass<EOL><DEDENT><DEDENT>try:<EOL><INDENT>return timestamp_epoch(value)<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT>return timestamp_any(value)<EOL>", "docstring": "Parse a datetime to a unix timestamp.\n\n    Uses fast custom parsing for common datetime formats or the slow dateutil\n    parser for other formats. This is a trade off between ease of use and speed\n    and is very useful for fast parsing of timestamp strings whose format may\n    standard but varied or unknown prior to parsing.\n\n    Common formats include:\n        1 Feb 2010 12:00:00 GMT\n        Mon, 1 Feb 2010 22:00:00 +1000\n        20100201120000\n        1383470155 (seconds since epoch)\n\n    See the other timestamp_*() functions for more details.\n\n    Args:\n        value: A string representing a datetime.\n        fmt: A timestamp format string like for time.strptime().\n\n    Returns:\n        The time in seconds since epoch as and integer for the value specified.", "id": "f14597:m13"}
{"signature": "def timestamp_fmt(value, fmt):", "body": "return int(calendar.timegm(<EOL>datetime.datetime.strptime(value, fmt).utctimetuple()<EOL>))<EOL>", "docstring": "Convert timestamp string to time in seconds since epoch.\n\n    Wraps the datetime.datetime.strptime(). This is slow use the other\n    timestamp_*() functions if possible.\n\n    Args:\n        value: A timestamp string.\n        fmt: A timestamp format string.\n\n    Returns:\n        The time in seconds since epoch as an integer.", "id": "f14597:m9"}
{"signature": "def datetimeobj(value, fmt=None):", "body": "if fmt:<EOL><INDENT>return _datetimeobj_formats.get(fmt,<EOL>lambda v: datetimeobj_fmt(v, fmt)<EOL>)(value)<EOL><DEDENT>l = len(value)<EOL>if <NUM_LIT> <= l <= <NUM_LIT> and value[<NUM_LIT:3>] == \"<STR_LIT:U+0020>\":<EOL><INDENT>try:<EOL><INDENT>return datetimeobj_d_b_Y_H_M_S(value)<EOL><DEDENT>except (KeyError, ValueError):<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if <NUM_LIT:30> <= l <= <NUM_LIT>:<EOL><INDENT>try:<EOL><INDENT>return datetimeobj_a__d_b_Y_H_M_S_z(value)<EOL><DEDENT>except (KeyError, ValueError):<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if l == <NUM_LIT>:<EOL><INDENT>try:<EOL><INDENT>return datetimeobj_YmdHMS(value)<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>try:<EOL><INDENT>return datetimeobj_epoch(value)<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT>return datetimeobj_any(value)<EOL>", "docstring": "Parse a datetime to a datetime object.\n\n    Uses fast custom parsing for common datetime formats or the slow dateutil\n    parser for other formats. This is a trade off between ease of use and speed\n    and is very useful for fast parsing of timestamp strings whose format may\n    standard but varied or unknown prior to parsing.\n\n    Common formats include:\n        1 Feb 2010 12:00:00 GMT\n        Mon, 1 Feb 2010 22:00:00 +1000\n        20100201120000\n        1383470155 (seconds since epoch)\n\n    See the other datetimeobj_*() functions for more details.\n\n    Args:\n        value: A string representing a datetime.\n\n    Returns:\n        A datetime object.", "id": "f14597:m14"}
{"signature": "def datetimeobj_any(value):", "body": "return dateutil.parser.parse(value)<EOL>", "docstring": "Convert timestamp string to a datetime object.\n\n    Most timestamps strings are supported in fact this is a wrapper for the\n    dateutil.parser.parse() method. This is SLOW use the other datetimeobj_*()\n    functions if possible.\n\n    Args:\n        value: A timestamp string.\n\n    Returns:\n        A datetime object.", "id": "f14597:m12"}
{"signature": "def article(self, msgid_article=None, decode=None):", "body": "args = None<EOL>if msgid_article is not None:<EOL><INDENT>args = utils.unparse_msgid_article(msgid_article)<EOL><DEDENT>code, message = self.command(\"<STR_LIT>\", args)<EOL>if code != <NUM_LIT>:<EOL><INDENT>raise NNTPReplyError(code, message)<EOL><DEDENT>parts = message.split(None, <NUM_LIT:1>)<EOL>try:<EOL><INDENT>articleno = int(parts[<NUM_LIT:0>])<EOL><DEDENT>except ValueError:<EOL><INDENT>raise NNTPProtocolError(message)<EOL><DEDENT>headers = utils.parse_headers(self.info_gen(code, message))<EOL>decode = \"<STR_LIT>\" in headers.get(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>escape = <NUM_LIT:0><EOL>crc32 = <NUM_LIT:0><EOL>body = []<EOL>for line in self.info_gen(code, message):<EOL><INDENT>if decode:<EOL><INDENT>if line.startswith(\"<STR_LIT>\"):<EOL><INDENT>continue<EOL><DEDENT>line, escape, crc32 = yenc.decode(line, escape, crc32)<EOL><DEDENT>body.append(line)<EOL><DEDENT>return articleno, headers, \"<STR_LIT>\".join(body)<EOL>", "docstring": "ARTICLE command.", "id": "f14598:c8:m29"}
{"signature": "def newgroups(self, timestamp):", "body": "return [x for x in self.newgroups_gen(timestamp)]<EOL>", "docstring": "NEWGROUPS command.\n\n        Retreives a list of newsgroups created on the server since the specified\n        timestamp. See newgroups_gen() for more details.\n\n        See <http://tools.ietf.org/html/rfc3977#section-7.3>\n\n        Args:\n            timestamp: Datetime object giving 'created since' datetime.\n\n        Returns:\n            A list of tuples in the format given by newgroups_gen()", "id": "f14598:c8:m7"}
{"signature": "def list_headers(self, arg=None):", "body": "return [x for x in self.list_headers_gen(arg)]<EOL>", "docstring": "LIST HEADERS command.", "id": "f14598:c8:m17"}
{"signature": "def status(self):", "body": "line = next(self.__line_gen()).rstrip()<EOL>parts = line.split(None, <NUM_LIT:1>)<EOL>try:<EOL><INDENT>code, message = int(parts[<NUM_LIT:0>]), \"<STR_LIT>\"<EOL><DEDENT>except ValueError:<EOL><INDENT>raise NNTPProtocolError(line)<EOL><DEDENT>if code < <NUM_LIT:100> or code >= <NUM_LIT>:<EOL><INDENT>raise NNTPProtocolError(line)<EOL><DEDENT>if len(parts) > <NUM_LIT:1>:<EOL><INDENT>message = parts[<NUM_LIT:1>]<EOL><DEDENT>if <NUM_LIT> <= code <= <NUM_LIT>:<EOL><INDENT>raise NNTPTemporaryError(code, message)<EOL><DEDENT>if <NUM_LIT> <= code <= <NUM_LIT>:<EOL><INDENT>raise NNTPPermanentError(code, message)<EOL><DEDENT>return code, message<EOL>", "docstring": "Reads a command response status.\n\n        If there is no response message then the returned status message will\n        be an empty string.\n\n        Raises:\n            NNTPError: If data is required to be read from the socket and fails.\n            NNTPProtocolError: If the status line can't be parsed.\n            NNTPTemporaryError: For status code 400-499\n            NNTPPermanentError: For status code 500-599\n\n        Returns:\n            A tuple of status code (as an integer) and status message.", "id": "f14598:c7:m4"}
{"signature": "def info_gen(self, code, message, compressed=False):", "body": "if \"<STR_LIT>\" in message:<EOL><INDENT>return self.__info_gzip_gen()<EOL><DEDENT>if compressed:<EOL><INDENT>return self.__info_yenczlib_gen()<EOL><DEDENT>return self.__info_plain_gen()<EOL>", "docstring": "Dispatcher for the info generators.\n\n        Determines which __info_*_gen() should be used based on the supplied\n        parameters.\n\n        Args:\n            code: The status code for the command response.\n            message: The status message for the command reponse.\n            compressed: Force decompression. Useful for xz* commands.\n\n        Returns:\n            An info generator.", "id": "f14598:c7:m8"}
{"signature": "def __init__(self, host, port=<NUM_LIT>, username=\"<STR_LIT>\", password=\"<STR_LIT>\", timeout=<NUM_LIT:30>, use_ssl=False):", "body": "self.socket = socket.socket()<EOL>if use_ssl:<EOL><INDENT>self.socket = ssl.wrap_socket(self.socket)<EOL><DEDENT>self.socket.settimeout(timeout)<EOL>self.__buffer = fifo.Fifo()<EOL>self.__generating = False<EOL>self.username = username<EOL>self.password = password<EOL>self.socket.connect((host, port))<EOL>code, message = self.status()<EOL>if not code in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise NNTPReplyError(code, message)<EOL><DEDENT>", "docstring": "Constructor for BasicNNTPClient.\n\n        Connects to usenet server and enters reader mode.\n\n        Args:\n            host: Hostname for usenet server.\n            port: Port for usenet server.\n            username: Username for usenet account (default \"anonymous\")\n            password: Password for usenet account (default \"anonymous\")\n            timeout: Connection timeout (default 30 seconds)\n            use_ssl: Should we use ssl (default False)\n\n        Raises:\n            IOError (socket.error): On error in underlying socket and/or ssl\n                wrapper. See socket and ssl modules for further details.\n            NNTPReplyError: On bad response code from server.", "id": "f14598:c7:m0"}
{"signature": "def list(self, keyword=None, arg=None):", "body": "return [x for x in self.list_gen(keyword, arg)]<EOL>", "docstring": "LIST command.\n\n        A wrapper for all of the other list commands. The output of this command\n        depends on the keyword specified. The output format for each keyword can\n        be found in the list function that corresponds to the keyword.\n\n        Args:\n            keyword: Information requested.\n            arg: Pattern or keyword specific argument.\n\n        Note: Keywords supported by this function are include ACTIVE,\n            ACTIVE.TIMES, DISTRIB.PATS, HEADERS, NEWSGROUPS, OVERVIEW.FMT and\n            EXTENSIONS.\n\n        Raises:\n            NotImplementedError: For unsupported keywords.", "id": "f14598:c8:m25"}
{"signature": "def xzver(self, range=None):", "body": "return [x for x in self.xzver_gen(range)]<EOL>", "docstring": "XZVER command.\n\n        The XZVER command returns information from the overview database for\n        the article(s) specified. It is part of the compressed headers\n        extensions that are supported by some usenet servers. It is the\n        compressed version of the XOVER command.\n\n        <http://helpdesk.astraweb.com/index.php?_m=news&_a=viewnews&newsid=9>\n\n        Args:\n            range: An article number as an integer, or a tuple of specifying a\n                range of article numbers in the form (first, [last]). If last is\n                omitted then all articles after first are included. A range of\n                None (the default) uses the current article.\n\n        Returns:\n            A list of fields as given by the overview database for each\n            available article in the specified range. The fields that are\n            returned can be determined using the LIST OVERVIEW.FMT command if\n            the server supports it.\n\n        Raises:\n            NNTPTemporaryError: If no such article exists or the currently\n                selected newsgroup is invalid.\n            NNTPDataError: If the compressed response cannot be decoded.", "id": "f14598:c8:m38"}
{"signature": "def xover(self, range=None):", "body": "return [x for x in self.xover_gen(range)]<EOL>", "docstring": "The XOVER command.\n\n        The XOVER command returns information from the overview database for\n        the article(s) specified.\n\n        <http://tools.ietf.org/html/rfc2980#section-2.8>\n\n        Args:\n            range: An article number as an integer, or a tuple of specifying a\n                range of article numbers in the form (first, [last]). If last is\n                omitted then all articles after first are included. A range of\n                None (the default) uses the current article.\n\n        Returns:\n            A table (list of lists) of articles and their fields as given by the\n            overview database for each available article in the specified range.\n            The fields that are given can be determined using the LIST\n            OVERVIEW.FMT command if the server supports it.\n\n        Raises:\n            NNTPReplyError: If no such article exists or the currently selected\n                newsgroup is invalid.", "id": "f14598:c8:m36"}
{"signature": "def xover_gen(self, range=None):", "body": "args = None<EOL>if range is not None:<EOL><INDENT>args = utils.unparse_range(range)<EOL><DEDENT>code, message = self.command(\"<STR_LIT>\", args)<EOL>if code != <NUM_LIT>:<EOL><INDENT>raise NNTPReplyError(code, message)<EOL><DEDENT>for line in self.info_gen(code, message):<EOL><INDENT>yield line.rstrip().split(\"<STR_LIT:\\t>\")<EOL><DEDENT>", "docstring": "Generator for the XOVER command.\n\n        The XOVER command returns information from the overview database for\n        the article(s) specified.\n\n        <http://tools.ietf.org/html/rfc2980#section-2.8>\n\n        Args:\n            range: An article number as an integer, or a tuple of specifying a\n                range of article numbers in the form (first, [last]). If last is\n                omitted then all articles after first are included. A range of\n                None (the default) uses the current article.\n\n        Returns:\n            A list of fields as given by the overview database for each\n            available article in the specified range. The fields that are\n            returned can be determined using the LIST OVERVIEW.FMT command if\n            the server supports it.\n\n        Raises:\n            NNTPReplyError: If no such article exists or the currently selected\n                newsgroup is invalid.", "id": "f14598:c8:m35"}
{"signature": "def close(self):", "body": "self.socket.close()<EOL>", "docstring": "Closes the connection at the client.\n\n        Once this method has been called, no other methods of the NNTPClient object\n        should be called.", "id": "f14598:c7:m11"}
{"signature": "def __line_gen(self):", "body": "while True:<EOL><INDENT>line = self.__buffer.readline()<EOL>if not line:<EOL><INDENT>self.__recv()<EOL>continue<EOL><DEDENT>yield line<EOL><DEDENT>", "docstring": "Generator that reads a line of data from the server.\n\n        It first attempts to read from the internal buffer. If there is not\n        enough data to read a line it then requests more data from the server\n        and adds it to the buffer. This process repeats until a line of data\n        can be read from the internal buffer.\n\n        Yields:\n            A line of data when it becomes available.", "id": "f14598:c7:m2"}
{"signature": "def xgtitle(self, pattern=None):", "body": "args = pattern<EOL>code, message = self.command(\"<STR_LIT>\", args)<EOL>if code != <NUM_LIT>:<EOL><INDENT>raise NNTPReplyError(code, message)<EOL><DEDENT>return self.info(code, message)<EOL>", "docstring": "XGTITLE command.", "id": "f14598:c8:m32"}
{"signature": "def __buf_gen(self, length=<NUM_LIT:0>):", "body": "while True:<EOL><INDENT>buf = self.__buffer.read(length)<EOL>if not buf:<EOL><INDENT>self.__recv()<EOL>continue<EOL><DEDENT>yield buf<EOL><DEDENT>", "docstring": "Generator that reads a block of data from the server.\n\n        It first attempts to read from the internal buffer. If there is not\n        enough data in the internal buffer it then requests more data from the\n        server and adds it to the buffer.\n\n        Args:\n            length: An optional amount of data to retrieve. A length of 0 (the\n                default) will retrieve a least one buffer of data.\n\n        Yields:\n            A block of data when enough data becomes available.\n\n        Note:\n            If a length of 0 is supplied then the size of the yielded buffer can\n            vary. If there is data in the internal buffer it will yield all of\n            that data otherwise it will yield the the data returned by a recv\n            on the socket.", "id": "f14598:c7:m3"}
{"signature": "def xhdr(self, header, msgid_range=None):", "body": "args = header<EOL>if range is not None:<EOL><INDENT>args += \"<STR_LIT:U+0020>\" + utils.unparse_msgid_range(msgid_range)<EOL><DEDENT>code, message = self.command(\"<STR_LIT>\", args)<EOL>if code != <NUM_LIT>:<EOL><INDENT>raise NNTPReplyError(code, message)<EOL><DEDENT>return self.info(code, message)<EOL>", "docstring": "XHDR command.", "id": "f14598:c8:m33"}
{"signature": "def quit(self):", "body": "code, message = self.command(\"<STR_LIT>\")<EOL>if code != <NUM_LIT>:<EOL><INDENT>raise NNTPReplyError(code, message)<EOL><DEDENT>self.socket.close()<EOL>", "docstring": "QUIT command.\n\n        Tells the server to close the connection. After the server acknowledges\n        the request to quit the connection is closed both at the server and\n        client. Only useful for graceful shutdown. If you are in a generator\n        use close() instead.\n\n        Once this method has been called, no other methods of the NNTPClient\n        object should be called.\n\n        See <http://tools.ietf.org/html/rfc3977#section-5.4>", "id": "f14598:c8:m3"}
{"signature": "def list_overview_fmt(self):", "body": "return [x for x in self.list_overview_fmt_gen()]<EOL>", "docstring": "LIST OVERVIEW.FMT command.", "id": "f14598:c8:m21"}
{"signature": "def newnews(self, pattern, timestamp):", "body": "return [x for x in self.newnews_gen(pattern, timestamp)]<EOL>", "docstring": "NEWNEWS command.\n\n        Retrieves a list of message-ids for articles created since the specified\n        timestamp for newsgroups with names that match the given pattern. See\n        newnews_gen() for more details.\n\n        See <http://tools.ietf.org/html/rfc3977#section-7.4>\n\n        Args:\n            pattern: Glob matching newsgroups of intrest.\n            timestamp: Datetime object giving 'created since' datetime.\n\n        Returns:\n            A list of message-ids as given by newnews_gen()", "id": "f14598:c8:m9"}
{"signature": "def xpat_gen(self, header, msgid_range, *pattern):", "body": "args = \"<STR_LIT:U+0020>\".join(<EOL>[header, utils.unparse_msgid_range(msgid_range)] + list(pattern)<EOL>)<EOL>code, message = self.command(\"<STR_LIT>\", args)<EOL>if code != <NUM_LIT>:<EOL><INDENT>raise NNTPReplyError(code, message)<EOL><DEDENT>for line in self.info_gen(code, message):<EOL><INDENT>yield line.strip()<EOL><DEDENT>", "docstring": "Generator for the XPAT command.", "id": "f14598:c8:m39"}
{"signature": "def xzhdr(self, header, msgid_range=None):", "body": "args = header<EOL>if msgid_range is not None:<EOL><INDENT>args += \"<STR_LIT:U+0020>\" + utils.unparse_msgid_range(msgid_range)<EOL><DEDENT>code, message = self.command(\"<STR_LIT>\", args)<EOL>if code != <NUM_LIT>:<EOL><INDENT>raise NNTPReplyError(code, message)<EOL><DEDENT>return self.info(code, message, compressed=True)<EOL>", "docstring": "XZHDR command.\n\n        Args:\n            msgid_range: A message-id as a string, or an article number as an\n                integer, or a tuple of specifying a range of article numbers in\n                the form (first, [last]) - if last is omitted then all articles\n                after first are included. A msgid_range of None (the default)\n                uses the current article.", "id": "f14598:c8:m34"}
{"signature": "def info(self, code, message, compressed=False):", "body": "return \"<STR_LIT>\".join([x for x in self.info_gen(code, message, compressed)])<EOL>", "docstring": "The complete content of an info response.\n\n        This should only used for commands that return small or known amounts of\n        data.\n\n        Returns:\n            A the complete content of a textual response.", "id": "f14598:c7:m9"}
{"signature": "def group(self, name):", "body": "args = name<EOL>code, message = self.command(\"<STR_LIT>\", args)<EOL>if code != <NUM_LIT>:<EOL><INDENT>raise NNTPReplyError(code, message)<EOL><DEDENT>parts = message.split(None, <NUM_LIT:4>)<EOL>try:<EOL><INDENT>total = int(parts[<NUM_LIT:0>])<EOL>first = int(parts[<NUM_LIT:1>])<EOL>last  = int(parts[<NUM_LIT:2>])<EOL>group = parts[<NUM_LIT:3>]<EOL><DEDENT>except (IndexError, ValueError):<EOL><INDENT>raise NNTPDataError(\"<STR_LIT>\" % message)<EOL><DEDENT>return total, first, last, group<EOL>", "docstring": "GROUP command.", "id": "f14598:c8:m26"}
{"signature": "def head(self, msgid_article=None):", "body": "args = None<EOL>if msgid_article is not None:<EOL><INDENT>args = utils.unparse_msgid_article(msgid_article)<EOL><DEDENT>code, message = self.command(\"<STR_LIT>\", args)<EOL>if code != <NUM_LIT>:<EOL><INDENT>raise NNTPReplyError(code, message)<EOL><DEDENT>return utils.parse_headers(self.info_gen(code, message))<EOL>", "docstring": "HEAD command.", "id": "f14598:c8:m30"}
{"signature": "def list_active_times_gen(self):", "body": "code, message = self.command(\"<STR_LIT>\")<EOL>if code != <NUM_LIT>:<EOL><INDENT>raise NNTPReplyError(code, message)<EOL><DEDENT>for line in self.info_gen(code, message):<EOL><INDENT>parts = line.split()<EOL>try:<EOL><INDENT>name = parts[<NUM_LIT:0>]<EOL>timestamp = date.datetimeobj_epoch(parts[<NUM_LIT:1>])<EOL>creator = parts[<NUM_LIT:2>]<EOL><DEDENT>except (IndexError, ValueError):<EOL><INDENT>raise NNTPDataError(\"<STR_LIT>\")<EOL><DEDENT>yield name, timestamp, creator<EOL><DEDENT>", "docstring": "Generator for the LIST ACTIVE.TIMES command.\n\n        Generates a list of newsgroups including the creation time and who\n        created them.\n\n        See <http://tools.ietf.org/html/rfc3977#section-7.6.4>\n\n        Yields:\n            A tuple containing the name, creation date as a datetime object and\n            creator as a string for the newsgroup.", "id": "f14598:c8:m12"}
{"signature": "def unparse_msgid_article(obj):", "body": "return str(obj)<EOL>", "docstring": "Unparse a message-id or article number argument.\n\n    Args:\n        obj: A messsage id or an article number.\n\n    Returns:\n        The message id or article number as a string.", "id": "f14601:m0"}
{"signature": "def _lower(v):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>return v.lower()<EOL><DEDENT>if isinstance(v, (list, tuple)):<EOL><INDENT>return v.__class__(_lower(x) for x in v)<EOL><DEDENT>if isinstance(v, dict):<EOL><INDENT>return v.__class__(_lower(v.items()))<EOL><DEDENT>return v<EOL>", "docstring": "assumes that classes that inherit list, tuple or dict have a constructor\n    that is compatible with those base classes. If you are using classes that\n    don't satisfy this requirement you can subclass them and add a lower()\n    method for the class", "id": "f14602:m0"}
{"signature": "def __eq__(self, other):", "body": "if len(self) != len(other) or not isinstance(other, dict):<EOL><INDENT>return False<EOL><DEDENT>so = OrderedDict(zip(_lower(self.keys()), self.values()))<EOL>oo = other.__class__(zip(_lower(other.keys()), other.values()))<EOL>return so == oo<EOL>", "docstring": "assumes that classes that inherit dict have a constructor that is\n        compatible with the dict class.", "id": "f14602:c0:m8"}
{"signature": "@property<EOL><INDENT>def exc_level(self) -> int:<DEDENT>", "body": "return self.__exc_level<EOL>", "docstring": "Log level for exceptions.", "id": "f14610:c0:m13"}
{"signature": "@log_traceback.setter<EOL><INDENT>def log_traceback(self, value: bool) -> None:<DEDENT>", "body": "self.__log_traceback = value<EOL>", "docstring": "Log traceback on exceptions.", "id": "f14610:c0:m20"}
{"signature": "def __init__(<EOL>self,<EOL>fget: typing.Optional[typing.Callable[[typing.Any], typing.Any]] = None,<EOL>fset: typing.Optional[typing.Callable[[typing.Any, typing.Any], None]] = None,<EOL>fdel: typing.Optional[typing.Callable[[typing.Any], None]] = None,<EOL>doc: typing.Optional[str] = None,<EOL>*,<EOL>logger: typing.Optional[typing.Union[logging.Logger, str]] = None,<EOL>log_object_repr: bool = True,<EOL>log_level: int = logging.DEBUG,<EOL>exc_level: int = logging.DEBUG,<EOL>log_success: bool = True,<EOL>log_failure: bool = True,<EOL>log_traceback: bool = True,<EOL>override_name: typing.Optional[str] = None,<EOL>) -> None:", "body": "warnings.warn(\"<STR_LIT>\", PendingDeprecationWarning)<EOL>super(LogOnAccess, self).__init__(fget=fget, fset=fset, fdel=fdel, doc=doc)<EOL>if logger is None or isinstance(logger, logging.Logger):<EOL><INDENT>self.__logger: typing.Optional[logging.Logger] = logger<EOL><DEDENT>else:<EOL><INDENT>self.__logger = logging.getLogger(logger)<EOL><DEDENT>self.__log_object_repr: bool = log_object_repr<EOL>self.__log_level: int = log_level<EOL>self.__exc_level: int = exc_level<EOL>self.__log_success: bool = log_success<EOL>self.__log_failure: bool = log_failure<EOL>self.__log_traceback: bool = log_traceback<EOL>self.__override_name: typing.Optional[str] = override_name<EOL>", "docstring": "Advanced property main entry point.\n\n        :param fget: normal getter.\n        :type fget: typing.Optional[typing.Callable[[typing.Any, ], typing.Any]]\n        :param fset: normal setter.\n        :type fset: typing.Optional[typing.Callable[[typing.Any, typing.Any], None]]\n        :param fdel: normal deleter.\n        :type fdel: typing.Optional[typing.Callable[[typing.Any, ], None]]\n        :param doc: docstring override\n        :type doc: typing.Optional[str]\n        :param logger: logger instance or name to use as override\n        :type logger: typing.Optional[typing.Union[logging.Logger, str]]\n        :param log_object_repr: use `repr` over object to describe owner if True else owner class name and id\n        :type log_object_repr: bool\n        :param log_level: log level for successful operations\n        :type log_level: int\n        :param exc_level: log level for exceptions\n        :type exc_level: int\n        :param log_success: log successful operations\n        :type log_success: bool\n        :param log_failure: log exceptions\n        :type log_failure: bool\n        :param log_traceback: Log traceback on exceptions\n        :type log_traceback: bool\n        :param override_name: override property name if not None else use getter/setter/deleter name\n        :type override_name: typing.Optional[str]\n\n        Usage examples:\n\n        >>> import logging\n        >>> import io\n\n        >>> log = io.StringIO()\n        >>> logging.basicConfig(level=logging.DEBUG, stream=log)\n\n        >>> class Test:\n        ...     def __init__(self, val = 'ok'):\n        ...         self.val = val\n        ...     def __repr__(self):\n        ...         return f'{self.__class__.__name__}(val={self.val})'\n        ...     @LogOnAccess\n        ...     def ok(self):\n        ...         return self.val\n        ...     @ok.setter\n        ...     def ok(self, val):\n        ...         self.val = val\n        ...     @ok.deleter\n        ...     def ok(self):\n        ...         self.val = ''\n        ...     @LogOnAccess\n        ...     def fail_get(self):\n        ...         raise RuntimeError()\n        ...     @LogOnAccess\n        ...     def fail_set_del(self):\n        ...         return self.val\n        ...     @fail_set_del.setter\n        ...     def fail_set_del(self, value):\n        ...         raise ValueError(value)\n        ...     @fail_set_del.deleter\n        ...     def fail_set_del(self):\n        ...         raise RuntimeError()\n\n        >>> test = Test()\n        >>> test.ok\n        'ok'\n        >>> test.ok = 'OK'\n        >>> del test.ok\n        >>> test.ok = 'fail_get'\n\n        >>> test.fail_get\n        Traceback (most recent call last):\n        ...\n        RuntimeError\n\n        >>> test.ok = 'fail_set_del'\n        >>> test.fail_set_del\n        'fail_set_del'\n\n        >>> test.fail_set_del = 'fail'\n        Traceback (most recent call last):\n        ...\n        ValueError: fail\n\n        >>> del test.fail_set_del\n        Traceback (most recent call last):\n        ...\n        RuntimeError\n\n        >>> test.fail_set_del\n        'fail_set_del'\n\n        >>> logs = log.getvalue().splitlines()\n        >>> logs[0] == \"DEBUG:log_on_access:Test(val=ok).ok -> 'ok'\"\n        True\n        >>> logs[1] == \"DEBUG:log_on_access:Test(val=ok).ok = 'OK'\"\n        True\n        >>> logs[2] == \"DEBUG:log_on_access:del Test(val=OK).ok\"\n        True\n        >>> logs[3] == \"DEBUG:log_on_access:Test(val=).ok = 'fail_get'\"\n        True\n        >>> logs[4:6]\n        ['DEBUG:log_on_access:Failed Test(val=fail_get).fail_get', 'Traceback (most recent call last):']\n        >>> logs[14] == \"DEBUG:log_on_access:Test(val=fail_get).ok = 'fail_set_del'\"\n        True\n        >>> logs[16] == \"DEBUG:log_on_access:Failed Test(val=fail_set_del).fail_set_del = 'fail'\"\n        True\n        >>> logs[17] == 'Traceback (most recent call last):'\n        True\n        >>> logs[26] == 'DEBUG:log_on_access:Test(val=fail_set_del): failed to delete fail_set_del'\n        True\n        >>> logs[27] == 'Traceback (most recent call last):'\n        True", "id": "f14610:c0:m0"}
{"signature": "def __set__(self, instance: typing.Any, value: typing.Any) -> None:", "body": "if self.fset is None:<EOL><INDENT>raise AttributeError()<EOL><DEDENT>source: str = self.__get_obj_source(instance)<EOL>logger: logging.Logger = self._get_logger_for_instance(instance)<EOL>try:<EOL><INDENT>super(LogOnAccess, self).__set__(instance, value)<EOL>if self.log_success:<EOL><INDENT>logger.log(self.log_level, f\"<STR_LIT>\")<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>if self.log_failure:<EOL><INDENT>logger.log(<EOL>self.exc_level, f\"<STR_LIT>\", exc_info=False<EOL>)<EOL><DEDENT>raise<EOL><DEDENT>", "docstring": "Set descriptor.\n\n        :param instance: Owner class instance. Filled only if instance created, else None.\n        :type instance: typing.Optional\n        :param value: Value for setter\n        :raises AttributeError: Setter is not available\n        :raises Exception: Something goes wrong", "id": "f14610:c0:m5"}
{"signature": "@log_level.setter<EOL><INDENT>def log_level(self, value: int) -> None:<DEDENT>", "body": "self.__log_level = value<EOL>", "docstring": "Log level for successful operations.", "id": "f14610:c0:m12"}
{"signature": "@log_success.setter<EOL><INDENT>def log_success(self, value: bool) -> None:<DEDENT>", "body": "self.__log_success = value<EOL>", "docstring": "Log successful operations.", "id": "f14610:c0:m16"}
{"signature": "def cgetter(self, fcget: typing.Optional[typing.Callable[[typing.Any], typing.Any]]) -> \"<STR_LIT>\":", "body": "self.__fcget = fcget<EOL>return self<EOL>", "docstring": "Descriptor to change the class wide getter on a property.\n\n        :param fcget: new class-wide getter.\n        :type fcget: typing.Optional[typing.Callable[[typing.Any, ], typing.Any]]\n        :return: AdvancedProperty\n        :rtype: AdvancedProperty", "id": "f14611:c0:m3"}
{"signature": "@property<EOL><INDENT>def __name__(self) -> str:  <DEDENT>", "body": "return self.__name<EOL>", "docstring": "Read-only name.", "id": "f14613:c0:m4"}
{"signature": "def __get__(self, instance: typing.Optional[typing.Any], owner: typing.Any) -> typing.Callable[..., typing.Any]:", "body": "if instance is None or self.__instance_method is None:<EOL><INDENT>if self.__class_method is None:<EOL><INDENT>raise AttributeError()<EOL><DEDENT>@functools.wraps(self.__class_method)<EOL>def class_method(*args: typing.Any, **kwargs: typing.Any) -> typing.Any:<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return self.__class_method(owner, *args, **kwargs)  <EOL><DEDENT>return class_method<EOL><DEDENT>@functools.wraps(self.__instance_method)<EOL>def instance_method(*args: typing.Any, **kwargs: typing.Any) -> typing.Any:<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return self.__instance_method(instance, *args, **kwargs)  <EOL><DEDENT>return instance_method<EOL>", "docstring": "Get descriptor.\n\n        :return: class method or instance method depends on call behavior\n        :rtype: typing.Callable\n        :raises AttributeError: Not implemented getter for class method and called class context.", "id": "f14613:c0:m2"}
{"signature": "def __set_name__(self, owner: typing.Any, name: str) -> None:", "body": "self.__owner = owner<EOL>self.__name = name<EOL>", "docstring": "Set __name__ and __objclass__ property.", "id": "f14613:c0:m1"}
{"signature": "def get(self, k, wait=False, wait_index=False, timeout='<STR_LIT>'):", "body": "k = k.lstrip('<STR_LIT:/>')<EOL>url = '<STR_LIT>'.format(self.endpoint, k)<EOL>params = {}<EOL>if wait:<EOL><INDENT>params['<STR_LIT:index>'] = wait_index<EOL>params['<STR_LIT>'] = timeout<EOL><DEDENT>r = requests.get(url, params=params)<EOL>if r.status_code == <NUM_LIT>:<EOL><INDENT>raise KeyDoesNotExist(\"<STR_LIT>\" + k + \"<STR_LIT>\")<EOL><DEDENT>if r.status_code != <NUM_LIT:200>:<EOL><INDENT>raise KVStoreError('<STR_LIT>'.format(r.status_code))<EOL><DEDENT>try:<EOL><INDENT>return base64.b64decode(r.json()[<NUM_LIT:0>]['<STR_LIT>'])<EOL><DEDENT>except TypeError as e:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>", "docstring": "Get the value of a given key", "id": "f14614:c0:m2"}
{"signature": "def authenticate(device, data, facet, check_only=False):", "body": "if isinstance(data, string_types):<EOL><INDENT>data = json.loads(data)<EOL><DEDENT>if data['<STR_LIT:version>'] != VERSION:<EOL><INDENT>raise ValueError('<STR_LIT>' % data['<STR_LIT:version>'])<EOL><DEDENT>app_id = data.get('<STR_LIT>', facet)<EOL>verify_facet(app_id, facet)<EOL>app_param = sha256(app_id.encode('<STR_LIT:utf8>')).digest()<EOL>key_handle = websafe_decode(data['<STR_LIT>'])<EOL>client_data = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': data['<STR_LIT>'],<EOL>'<STR_LIT>': facet<EOL>}<EOL>client_data = json.dumps(client_data)<EOL>client_param = sha256(client_data.encode('<STR_LIT:utf8>')).digest()<EOL>request = client_param + app_param + int2byte(<EOL>len(key_handle)) + key_handle<EOL>p1 = <NUM_LIT> if check_only else <NUM_LIT><EOL>p2 = <NUM_LIT:0><EOL>response = device.send_apdu(INS_SIGN, p1, p2, request)<EOL>return {<EOL>'<STR_LIT>': websafe_encode(client_data),<EOL>'<STR_LIT>': websafe_encode(response),<EOL>'<STR_LIT>': data['<STR_LIT>']<EOL>}<EOL>", "docstring": "Signs an authentication challenge\n\ndata = {\n    'version': \"U2F_V2\",\n    'challenge': websafe_encode(self.challenge),\n    'appId': self.binding.app_id,\n    'keyHandle': websafe_encode(self.binding.key_handle)\n}", "id": "f14622:m1"}
{"signature": "def register(device, data, facet):", "body": "if isinstance(data, string_types):<EOL><INDENT>data = json.loads(data)<EOL><DEDENT>if data['<STR_LIT:version>'] != VERSION:<EOL><INDENT>raise ValueError('<STR_LIT>' % data['<STR_LIT:version>'])<EOL><DEDENT>app_id = data.get('<STR_LIT>', facet)<EOL>verify_facet(app_id, facet)<EOL>app_param = sha256(app_id.encode('<STR_LIT:utf8>')).digest()<EOL>client_data = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': data['<STR_LIT>'],<EOL>'<STR_LIT>': facet<EOL>}<EOL>client_data = json.dumps(client_data)<EOL>client_param = sha256(client_data.encode('<STR_LIT:utf8>')).digest()<EOL>request = client_param + app_param<EOL>p1 = <NUM_LIT><EOL>p2 = <NUM_LIT:0><EOL>response = device.send_apdu(INS_ENROLL, p1, p2, request)<EOL>return {<EOL>'<STR_LIT>': websafe_encode(response),<EOL>'<STR_LIT>': websafe_encode(client_data)<EOL>}<EOL>", "docstring": "Register a U2F device\n\ndata = {\n    \"version\": \"U2F_V2\",\n    \"challenge\": string, //b64 encoded challenge\n    \"appId\": string, //app_id\n}", "id": "f14622:m0"}
{"signature": "def u2str(data):", "body": "if isinstance(data, dict):<EOL><INDENT>return {u2str(k): u2str(v) for k, v in data.items()}<EOL><DEDENT>elif isinstance(data, list):<EOL><INDENT>return [u2str(x) for x in data]<EOL><DEDENT>elif isinstance(data, text_type):<EOL><INDENT>return data.encode('<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>return data<EOL><DEDENT>", "docstring": "Recursively converts unicode objects to UTF-8 encoded byte strings.", "id": "f14626:m0"}
{"signature": "def get_supported_versions(self):", "body": "if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>try:<EOL><INDENT>self._versions = [self.send_apdu(INS_GET_VERSION).decode()]<EOL><DEDENT>except exc.APDUError as e:<EOL><INDENT>self._versions = ['<STR_LIT>'] if e.code == <NUM_LIT> else []<EOL><DEDENT><DEDENT>return self._versions<EOL>", "docstring": "Gets a list of supported U2F versions from the device.", "id": "f14627:c0:m5"}
{"signature": "def close(self):", "body": "pass<EOL>", "docstring": "Closes the device, making it available for use by others.", "id": "f14627:c0:m4"}
{"signature": "def follow(self):", "body": "trailing = True       <EOL>while True:<EOL><INDENT>where = self.file.tell()<EOL>if where > os.fstat(self.file.fileno()).st_size:<EOL><INDENT>where = <NUM_LIT:0><EOL>self.file.seek(where)<EOL><DEDENT>line = self.file.readline()<EOL>if line:    <EOL><INDENT>if trailing and line in self.LINE_TERMINATORS:<EOL><INDENT>trailing = False<EOL>continue<EOL><DEDENT>terminator = self.suffix_line_terminator(line)<EOL>if terminator:<EOL><INDENT>line = line[:-len(terminator)]<EOL><DEDENT>trailing = False<EOL>yield line<EOL><DEDENT>else:<EOL><INDENT>trailing = True<EOL>self.file.seek(where)<EOL>yield None<EOL><DEDENT><DEDENT>", "docstring": "Iterator generator that returns lines as data is added to the file.\n\nNone will be yielded if no new line is available.\nCaller may either wait and re-try or end iteration.", "id": "f14709:c0:m9"}
{"signature": "def tail(self, lines=<NUM_LIT:10>):", "body": "self.file.seek(<NUM_LIT:0>, SEEK_END)<EOL>for i in range(lines):<EOL><INDENT>if self.seek_previous_line() == -<NUM_LIT:1>:<EOL><INDENT>break<EOL><DEDENT><DEDENT>data = self.file.read()<EOL>for t in self.LINE_TERMINATORS:<EOL><INDENT>if data.endswith(t):<EOL><INDENT>data = data[:-len(t)]<EOL>break<EOL><DEDENT><DEDENT>if data:<EOL><INDENT>return self.splitlines(data)<EOL><DEDENT>else:<EOL><INDENT>return []<EOL><DEDENT>", "docstring": "Return the last lines of the file.", "id": "f14709:c0:m7"}
{"signature": "def seek_previous_line(self):", "body": "where = self.file.tell()<EOL>offset = <NUM_LIT:0><EOL>while True:<EOL><INDENT>if offset == where:<EOL><INDENT>break<EOL><DEDENT>read_size = self.read_size if self.read_size <= where else where<EOL>self.file.seek(where - offset - read_size, SEEK_SET)<EOL>data_len, data = self.read(read_size)<EOL>if b'<STR_LIT:\\r\\n>' in self.LINE_TERMINATORS and data[<NUM_LIT:0>] == b'<STR_LIT:\\n>'[<NUM_LIT:0>]:<EOL><INDENT>terminator_where = self.file.tell()<EOL>if terminator_where > data_len + <NUM_LIT:1>:<EOL><INDENT>self.file.seek(where - offset - data_len - <NUM_LIT:1>, SEEK_SET)<EOL>terminator_len, terminator_data = self.read(<NUM_LIT:1>)<EOL>if terminator_data[<NUM_LIT:0>] == b'<STR_LIT:\\r>'[<NUM_LIT:0>]:<EOL><INDENT>data_len += <NUM_LIT:1><EOL>data = b'<STR_LIT:\\r>' + data<EOL><DEDENT>self.file.seek(terminator_where)<EOL><DEDENT><DEDENT>data_where = data_len<EOL>while data_where > <NUM_LIT:0>:<EOL><INDENT>terminator = self.suffix_line_terminator(data[:data_where])<EOL>if terminator and offset == <NUM_LIT:0> and data_where == data_len:<EOL><INDENT>data_where -= len(terminator)<EOL><DEDENT>elif terminator:<EOL><INDENT>self.file.seek(where - offset - (data_len - data_where))<EOL>return self.file.tell()<EOL><DEDENT>else:<EOL><INDENT>data_where -= <NUM_LIT:1><EOL><DEDENT><DEDENT>offset += data_len<EOL><DEDENT>if where == <NUM_LIT:0>:<EOL><INDENT>return -<NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>self.file.seek(<NUM_LIT:0>)<EOL>return <NUM_LIT:0><EOL><DEDENT>", "docstring": "Seek previous line relative to the current file position.\n\n:return: Position of the line or -1 if previous line was not found.", "id": "f14709:c0:m6"}
{"signature": "def follow(file):", "body": "return Tailer(file, end=True).follow()<EOL>", "docstring": "Generator that returns lines as data is added to the file.\n\nReturned generator yields bytes.\n\n>>> import io\n>>> import os\n>>> f = io.open('test_follow.txt', 'w+')\n>>> fo = io.open('test_follow.txt', 'rb')\n>>> generator = follow(fo)\n>>> _ = f.write('Line 1\\\\n')\n>>> f.flush()\n>>> print(next(generator).decode('utf-8'))\nLine 1\n>>> _ = f.write('Line 2\\\\n')\n>>> f.flush()\n>>> print(next(generator).decode('utf-8'))\nLine 2\n>>> _ = f.truncate(0)\n>>> _ = f.seek(0)\n>>> _ = f.write('Line 3\\\\n')\n>>> f.flush()\n>>> print(next(generator).decode('utf-8'))\nLine 3\n>>> print(next(generator))\nNone\n>>> f.close()\n>>> fo.close()\n>>> os.remove('test_follow.txt')", "id": "f14709:m2"}
{"signature": "def tail(file, lines=<NUM_LIT:10>, read_size=<NUM_LIT>):", "body": "return Tailer(file, read_size).tail(lines)<EOL>", "docstring": "Return the last lines of the file.\n\n>>> import io\n>>>\n... with io.open('test_tail.txt', 'w+') as fw:\n...     with io.open('test_tail.txt', 'rb') as fr:\n...         _ = fw.write('\\\\r')\n...         _ = fw.write('Line 1\\\\r\\\\n')\n...         _ = fw.write('Line 2\\\\n')\n...         _ = fw.write('Line 3\\\\r')\n...         _ = fw.write('Line 4\\\\r\\\\n')\n...         _ = fw.write('\\\\n')\n...         _ = fw.write('\\\\r\\\\n')\n...         _ = fw.write('\\\\r\\\\n')\n...         fw.flush()\n...         tail(fr, 6, 1)  # doctest: +ELLIPSIS\n[...'Line 2', ...'Line 3', ...'Line 4', ...'', ...'', ...'']\n>>> os.remove('test_tail.txt')\n\n>>> import io\n>>>\n... with io.open('test_tail.txt', 'w+') as fw:\n...     with io.open('test_tail.txt', 'rb') as fr:\n...         _ = fw.write('Line 1')\n...         fw.flush()\n...         tail(fr, 6, 1)  # doctest: +ELLIPSIS\n[...'Line 1']\n>>> os.remove('test_tail.txt')", "id": "f14709:m0"}
{"signature": "def prefix_line_terminator(self, data):", "body": "for t in self.LINE_TERMINATORS:<EOL><INDENT>if data.startswith(t):<EOL><INDENT>return t<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Return line terminator data begins with or None.", "id": "f14709:c0:m3"}
{"signature": "def load_docstring(fn):", "body": "def load_wrapper(self, *args, **kwargs):<EOL><INDENT>try:<EOL><INDENT>loader = xtuml.ModelLoader()<EOL>loader.input(fn.__doc__)<EOL>res = loader.build_metamodel()<EOL><DEDENT>except Exception as ex:<EOL><INDENT>res = ex<EOL><DEDENT>fn(self, res)<EOL><DEDENT>return load_wrapper<EOL>", "docstring": "Decorator for loading a meta model from a test case doc string", "id": "f14736:m0"}
{"signature": "def delete(self, instance, disconnect=True):", "body": "if instance in self.storage:<EOL><INDENT>self.storage.remove(instance)<EOL><DEDENT>else:<EOL><INDENT>raise DeleteException(\"<STR_LIT>\")<EOL><DEDENT>if not disconnect:<EOL><INDENT>return<EOL><DEDENT>for link in self.links.values():<EOL><INDENT>if instance not in link:<EOL><INDENT>continue<EOL><DEDENT>for other in link[instance]:<EOL><INDENT>unrelate(instance, other, link.rel_id, link.phrase)<EOL><DEDENT><DEDENT>", "docstring": "Delete an *instance* from the instance pool and optionally *disconnect*\nit from any links it might be connected to. If the *instance* is not\npart of the metaclass, a *MetaException* is thrown.", "id": "f14739:c11:m11"}
{"signature": "def formalize(self):", "body": "source_class = self.source_link.to_metaclass<EOL>target_class = self.target_link.to_metaclass<EOL>source_class.referential_attributes |= set(self.source_keys)<EOL>target_class.identifying_attributes |= set(self.target_keys)<EOL>def fget(inst, ref_name, alt_prop):<EOL><INDENT>other_inst = self.target_link.navigate_one(inst)<EOL>if other_inst is None and alt_prop:<EOL><INDENT>return alt_prop.fget(inst)<EOL><DEDENT>return getattr(other_inst, ref_name, None)<EOL><DEDENT>def fset(inst, value, name, ref_name, alt_prop):<EOL><INDENT>kind = get_metaclass(inst).kind<EOL>raise MetaException('<STR_LIT>''<STR_LIT>'% (kind, name))<EOL><DEDENT>for ref_key, primary_key in zip(self.source_keys, self.target_keys):<EOL><INDENT>prop = getattr(source_class.clazz, ref_key, None)<EOL>prop = property(partial(fget, ref_name=primary_key, alt_prop=prop), <EOL>partial(fset, name=ref_key, ref_name=primary_key, alt_prop=prop))<EOL>setattr(source_class.clazz, ref_key, prop)<EOL><DEDENT>", "docstring": "Formalize the association and expose referential attributes\non instances.", "id": "f14739:c7:m3"}
{"signature": "def find_class(self, kind):", "body": "return self.find_metaclass(kind).clazz<EOL>", "docstring": "Find a class of some *kind* in the metamodel.", "id": "f14739:c16:m3"}
{"signature": "def define_class(self, kind, attributes, doc='<STR_LIT>'):", "body": "ukind = kind.upper()<EOL>if ukind in self.metaclasses:<EOL><INDENT>raise MetaModelException('<STR_LIT>' % kind)<EOL><DEDENT>metaclass = MetaClass(kind, self)<EOL>for name, ty in attributes:<EOL><INDENT>metaclass.append_attribute(name, ty)<EOL><DEDENT>self.metaclasses[ukind] = metaclass<EOL>return metaclass<EOL>", "docstring": "Define a new class in the metamodel, and return its metaclass.", "id": "f14739:c16:m2"}
{"signature": "def define_association(self, rel_id, source_kind, source_keys, source_many,<EOL>source_conditional, source_phrase, target_kind, <EOL>target_keys, target_many, target_conditional, <EOL>target_phrase):", "body": "if isinstance(rel_id, int):<EOL><INDENT>rel_id = '<STR_LIT>' % rel_id<EOL><DEDENT>source_metaclass = self.find_metaclass(source_kind)<EOL>target_metaclass = self.find_metaclass(target_kind)<EOL>source_link = target_metaclass.add_link(source_metaclass, rel_id,<EOL>many=source_many,<EOL>phrase=target_phrase,<EOL>conditional=source_conditional)<EOL>target_link = source_metaclass.add_link(target_metaclass, rel_id,<EOL>many=target_many,<EOL>phrase=source_phrase,<EOL>conditional=target_conditional)<EOL>ass = Association(rel_id,<EOL>source_keys, source_link,<EOL>target_keys, target_link)<EOL>source_link.key_map = dict(zip(source_keys, target_keys))<EOL>target_link.key_map = dict(zip(target_keys, source_keys))<EOL>self.associations.append(ass)<EOL>return ass<EOL>", "docstring": "Define and return an association from one kind of class (the source \nkind) to some other kind of class (the target kind).", "id": "f14739:c16:m7"}
{"signature": "def delete_attribute(self, name):", "body": "for idx, attr in enumerate(self.attributes):<EOL><INDENT>attr_name, _ = attr<EOL>if attr_name == name:<EOL><INDENT>del self.attributes[idx]<EOL>return<EOL><DEDENT><DEDENT>", "docstring": "Delete an attribute with a given *name* from the list of attributes.", "id": "f14739:c11:m7"}
{"signature": "def _is_null(instance, name):", "body": "if name in instance.__dict__:<EOL><INDENT>value = instance.__dict__[name]<EOL><DEDENT>else:<EOL><INDENT>value = getattr(instance, name)<EOL><DEDENT>if value:<EOL><INDENT>return False<EOL><DEDENT>elif value is None:<EOL><INDENT>return True<EOL><DEDENT>name = name.upper()<EOL>metaclass = get_metaclass(instance)<EOL>for attr_name, attr_ty in metaclass.attributes:<EOL><INDENT>if attr_name.upper() != name:<EOL><INDENT>continue<EOL><DEDENT>attr_ty = attr_ty.upper()<EOL>if attr_ty == '<STR_LIT>':<EOL><INDENT>return value == <NUM_LIT:0><EOL><DEDENT>elif attr_ty == '<STR_LIT>':<EOL><INDENT>return len(value) == <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>", "docstring": "Determine if an attribute of an *instance* with a specific *name* \nis null.", "id": "f14739:m0"}
{"signature": "def default_value(self, type_name):", "body": "uname = type_name.upper()<EOL>if   uname == '<STR_LIT>':<EOL><INDENT>return False<EOL><DEDENT>elif uname == '<STR_LIT>':<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>elif uname == '<STR_LIT>':<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>elif uname == '<STR_LIT>':<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>elif uname == '<STR_LIT>':<EOL><INDENT>if self.metamodel:<EOL><INDENT>return next(self.metamodel.id_generator)<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise MetaException(\"<STR_LIT>\" % type_name)<EOL><DEDENT>", "docstring": "Obtain the default value for some *type name*.", "id": "f14739:c11:m8"}
{"signature": "def navigate(self, inst, kind, rel_id, phrase='<STR_LIT>'):", "body": "key = (kind.upper(), rel_id, phrase)<EOL>if key in self.links:<EOL><INDENT>link = self.links[key]<EOL>return link.navigate(inst)<EOL><DEDENT>link1, link2 = self._find_assoc_links(kind, rel_id, phrase)<EOL>inst_set = xtuml.OrderedSet()<EOL>for inst in link1.navigate(inst):<EOL><INDENT>inst_set |= link2.navigate(inst)<EOL><DEDENT>return inst_set<EOL>", "docstring": "Navigate across a link with some *rel_id* and *phrase* that yields\ninstances of some *kind*.", "id": "f14739:c11:m15"}
{"signature": "@property<EOL><INDENT>def kind(self):<DEDENT>", "body": "return self.to_metaclass.kind<EOL>", "docstring": "Obtain the resulting kind when the link is navigated.", "id": "f14739:c8:m2"}
{"signature": "def navigate_one(self, instance):", "body": "return next(iter(self.navigate(instance)), None)<EOL>", "docstring": "Navigate from *instance* across the link.", "id": "f14739:c8:m6"}
{"signature": "def get_metaclass(class_or_instance):", "body": "if isinstance(class_or_instance, Class):<EOL><INDENT>return class_or_instance.__metaclass__<EOL><DEDENT>elif issubclass(class_or_instance, Class):<EOL><INDENT>return class_or_instance.__metaclass__<EOL><DEDENT>raise MetaException(\"<STR_LIT>\")<EOL>", "docstring": "Get the metaclass for a *class_or_instance*.", "id": "f14739:m11"}
{"signature": "def clone(self, instance):", "body": "metaclass = get_metaclass(instance)<EOL>metaclass = self.find_metaclass(metaclass.kind)<EOL>return metaclass.clone(instance)<EOL>", "docstring": "Create a shallow clone of an *instance*.\n\n**Note:** the clone and the original instance **does not** have to be\npart of the same metaclass.", "id": "f14739:c16:m6"}
{"signature": "def compute_index_key(self, to_instance):", "body": "kwargs = dict()<EOL>for attr in self.key_map.values():<EOL><INDENT>if _is_null(to_instance, attr):<EOL><INDENT>return None<EOL><DEDENT>if attr in to_instance.__dict__:<EOL><INDENT>kwargs[attr] = to_instance.__dict__[attr]<EOL><DEDENT>else:<EOL><INDENT>kwargs[attr] = getattr(to_instance, attr)<EOL><DEDENT><DEDENT>return frozenset(tuple(kwargs.items()))<EOL>", "docstring": "Compute the index key that can be used to identify an instance\non the link.", "id": "f14739:c8:m8"}
{"signature": "def pretty_from_link(inst, link):", "body": "values = '<STR_LIT>'<EOL>prefix = '<STR_LIT>'<EOL>metaclass = xtuml.get_metaclass(inst)<EOL>for name, ty in metaclass.attributes:<EOL><INDENT>if name in link.key_map:<EOL><INDENT>value = getattr(inst, name)<EOL>value = xtuml.serialize_value(value, ty)<EOL>values += '<STR_LIT>' % (prefix, name, value)<EOL>prefix = '<STR_LIT:U+002CU+0020>'<EOL><DEDENT><DEDENT>return '<STR_LIT>' % (metaclass.kind, values)<EOL>", "docstring": "Create a human-readable representation of a link on the 'FROM'-side", "id": "f14740:m1"}
{"signature": "def default_render(self, node):", "body": "return type(node).__name__<EOL>", "docstring": "The default behaviour when rendering a *node* if no other rendering\nmethod is defined by a subclass is to render the class name.", "id": "f14742:c6:m4"}
{"signature": "def __init__(self):", "body": "self._current = self.readfunc()<EOL>", "docstring": "Initialize an id generator with a start value.", "id": "f14742:c0:m0"}
{"signature": "def accept(self, node, **kwargs):", "body": "if node is None:<EOL><INDENT>return<EOL><DEDENT>for v in self.visitors:<EOL><INDENT>v.enter(node)<EOL><DEDENT>name = '<STR_LIT>' + node.__class__.__name__<EOL>fn = getattr(self, name, self.default_accept)<EOL>r = fn(node, **kwargs)<EOL>for v in self.visitors:<EOL><INDENT>v.leave(node)<EOL><DEDENT>return r<EOL>", "docstring": "Invoke the visitors before and after decending down the tree. \nThe walker will also try to invoke a method matching the pattern \n*accept_<type name>*, where <type name> is the name of the accepted\n*node*.", "id": "f14742:c5:m1"}
{"signature": "def default_leave(self, node):", "body": "pass<EOL>", "docstring": "The default behaviour when leaving a *node* if no other action is\ndefined by a subclass is to do nothing.", "id": "f14742:c3:m3"}
{"signature": "def serialize_instance(instance):", "body": "attr_count = <NUM_LIT:0><EOL>metaclass = xtuml.get_metaclass(instance)<EOL>s = '<STR_LIT>' % metaclass.kind<EOL>for name, ty in metaclass.attributes:<EOL><INDENT>value = getattr(instance, name)<EOL>s += '<STR_LIT>'<EOL>s += serialize_value(value, ty)<EOL>attr_count += <NUM_LIT:1><EOL>if attr_count < len(metaclass.attributes):<EOL><INDENT>s += '<STR_LIT>' % (name, ty)<EOL><DEDENT>else:<EOL><INDENT>s += '<STR_LIT>' % (name, ty)<EOL><DEDENT><DEDENT>s += '<STR_LIT>'<EOL>return s<EOL>", "docstring": "Serialize an *instance* from a metamodel.", "id": "f14743:m1"}
{"signature": "def persist_instances(metamodel, path, mode='<STR_LIT:w>'):", "body": "with open(path, mode) as f:<EOL><INDENT>for inst in metamodel.instances:<EOL><INDENT>s = serialize_instance(inst)<EOL>f.write(s)<EOL><DEDENT><DEDENT>", "docstring": "Persist all instances in a *metamodel* by serializing them and saving to a \n*path* on disk.", "id": "f14743:m9"}
{"signature": "def serialize(resource):", "body": "if isinstance(resource, xtuml.MetaModel):<EOL><INDENT>return serialize_database(resource)<EOL><DEDENT>elif isinstance(resource, type) and issubclass(resource, xtuml.Class):<EOL><INDENT>return serialize_class(resource)<EOL><DEDENT>elif isinstance(resource, xtuml.Association):<EOL><INDENT>return serialize_association(resource)<EOL><DEDENT>elif isinstance(resource, xtuml.Class):<EOL><INDENT>return serialize_instance(resource)<EOL><DEDENT>", "docstring": "Serialize some xtuml *resource*, e.g. an instance or a complete metamodel.", "id": "f14743:m8"}
{"signature": "def p_statement_sequence(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>p[<NUM_LIT:0>].append(p[<NUM_LIT:2>])<EOL>", "docstring": "statement_sequence : statement_sequence statement", "id": "f14744:c6:m31"}
{"signature": "def input(self, data, name='<STR_LIT>'):", "body": "lexer = lex.lex(debuglog=logger,<EOL>errorlog=logger,<EOL>optimize=<NUM_LIT:1>,<EOL>module=self,<EOL>outputdir=os.path.dirname(__file__),<EOL>lextab=\"<STR_LIT>\")<EOL>lexer.filename = name<EOL>logger.debug('<STR_LIT>' % name)<EOL>s = self.parser.parse(lexer=lexer, input=data, tracking=<NUM_LIT:1>)<EOL>self.statements.extend(s)<EOL>", "docstring": "Parse *data* directly from a string. The *name* is used when reporting\npositional information if the parser encounter syntax errors.", "id": "f14744:c6:m1"}
{"signature": "def deserialize_value(ty, value):", "body": "uty = ty.upper()<EOL>if uty == '<STR_LIT>':<EOL><INDENT>if value.isdigit():<EOL><INDENT>return bool(int(value))<EOL><DEDENT>elif value.upper() == '<STR_LIT>':<EOL><INDENT>return False<EOL><DEDENT>elif value.upper() == '<STR_LIT>':<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>elif uty == '<STR_LIT>': <EOL><INDENT>if '<STR_LIT:\">' in value:<EOL><INDENT>return uuid.UUID(value[<NUM_LIT:1>:-<NUM_LIT:1>]).int<EOL><DEDENT>else:<EOL><INDENT>return int(value)<EOL><DEDENT><DEDENT>elif uty == '<STR_LIT>': <EOL><INDENT>return float(value)<EOL><DEDENT>elif uty == '<STR_LIT>': <EOL><INDENT>return value[<NUM_LIT:1>:-<NUM_LIT:1>].replace(\"<STR_LIT>\", \"<STR_LIT:'>\")<EOL><DEDENT>elif uty == '<STR_LIT>': <EOL><INDENT>if '<STR_LIT:\">' in value:<EOL><INDENT>return uuid.UUID(value[<NUM_LIT:1>:-<NUM_LIT:1>]).int<EOL><DEDENT>else:<EOL><INDENT>return int(value)<EOL><DEDENT><DEDENT>", "docstring": "Deserialize a value of some type", "id": "f14744:m1"}
{"signature": "def p_cardinality_many(self, p):", "body": "if p[<NUM_LIT:1>] not in ['<STR_LIT:M>', '<STR_LIT>']:<EOL><INDENT>raise ParsingException(\"<STR_LIT>\" % (p[<NUM_LIT:1>],<EOL>p.lexer.filename, p.lineno(<NUM_LIT:1>)))<EOL><DEDENT>p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "cardinality : ID", "id": "f14744:c6:m50"}
{"signature": "def t_GUID(self, t):", "body": "t.endlexpos = t.lexpos + len(t.value)<EOL>return t<EOL>", "docstring": "r'\\\"([^\\\\\\n]|(\\\\.))*?\\", "id": "f14744:c6:m26"}
{"signature": "def p_empty_translation_unit(self, p):", "body": "p[<NUM_LIT:0>] = list()<EOL>", "docstring": "translation_unit :", "id": "f14744:c6:m29"}
{"signature": "def p_value_sequence(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>p[<NUM_LIT:0>].append(p[<NUM_LIT:3>])<EOL>", "docstring": "value_sequence : value_sequence COMMA value", "id": "f14744:c6:m42"}
{"signature": "@staticmethod<EOL><INDENT>def _populate_instance_with_positional_arguments(metamodel, stmt):<DEDENT>", "body": "if stmt.kind.upper() not in metamodel.metaclasses:<EOL><INDENT>names = ['<STR_LIT>' % idx for idx in range(len(stmt.values))]<EOL>ModelLoader._populate_matching_class(metamodel, stmt.kind, <EOL>names, stmt.values)<EOL><DEDENT>metaclass = metamodel.find_metaclass(stmt.kind)<EOL>if len(metaclass.attributes) != len(stmt.values):<EOL><INDENT>logger.warn('<STR_LIT>' % (stmt.filename, stmt.lineno))<EOL><DEDENT>inst = metamodel.new(stmt.kind)<EOL>for attr, value in zip(metaclass.attributes, stmt.values):<EOL><INDENT>name, ty = attr<EOL>py_value = deserialize_value(ty, value)<EOL>if py_value is None:<EOL><INDENT>raise ParsingException(\"<STR_LIT>\"\"<STR_LIT>\" % (stmt.filename,<EOL>stmt.lineno,<EOL>value,<EOL>ty))<EOL><DEDENT>inst.__dict__[name] = py_value<EOL><DEDENT>return inst<EOL>", "docstring": "Populate a *metamodel* with an instance previously encountered from \ninput that was defined using positional arguments.", "id": "f14744:c6:m8"}
{"signature": "def p_attribute_sequence_endpoint(self, p):", "body": "p[<NUM_LIT:0>] = [p[<NUM_LIT:1>]]<EOL>", "docstring": "attribute_sequence : attribute", "id": "f14744:c6:m36"}
{"signature": "def p_statement_sequence_endpoint(self, p):", "body": "p[<NUM_LIT:0>] = [p[<NUM_LIT:1>]]<EOL>", "docstring": "statement_sequence : statement", "id": "f14744:c6:m32"}
{"signature": "def t_LPAREN(self, t):", "body": "t.endlexpos = t.lexpos + len(t.value)<EOL>return t<EOL>", "docstring": "r'\\(", "id": "f14744:c6:m20"}
{"signature": "def t_STRING(self, t):", "body": "t.lexer.lineno += (t.value.count(\"<STR_LIT:\\n>\"))<EOL>t.endlexpos = t.lexpos + len(t.value)<EOL>return t<EOL>", "docstring": "r'\\'((\\'\\')|[^\\'])*\\", "id": "f14744:c6:m25"}
{"signature": "def p_empty_attribute_sequence(self, p):", "body": "p[<NUM_LIT:0>] = []<EOL>", "docstring": "attribute_sequence :", "id": "f14744:c6:m35"}
{"signature": "def p_identifier_sequence_endpoint(self, p):", "body": "p[<NUM_LIT:0>] = [p[<NUM_LIT:1>]]<EOL>", "docstring": "identifier_sequence : identifier", "id": "f14744:c6:m54"}
{"signature": "def t_comment(self, t):", "body": "t.lexer.lineno += (t.value.count(\"<STR_LIT:\\n>\"))<EOL>t.endlexpos = t.lexpos + len(t.value)<EOL>", "docstring": "r'\\-\\-([^\\n]*\\n?)", "id": "f14744:c6:m14"}
{"signature": "def accept_C_C(self, inst):", "body": "for child in many(inst).PE_PE[<NUM_LIT>]():<EOL><INDENT>self.accept(child)<EOL><DEDENT>", "docstring": "A Component contains packageable elements", "id": "f14748:c0:m2"}
{"signature": "def render_PE_PE(self, inst):", "body": "pass<EOL>", "docstring": "suppress instances of PE_PE", "id": "f14748:c1:m0"}
{"signature": "def get_refered_attribute(o_attr):", "body": "o_attr_ref = nav_one(o_attr).O_RATTR[<NUM_LIT>].O_BATTR[<NUM_LIT>].O_ATTR[<NUM_LIT>]()<EOL>if o_attr_ref:<EOL><INDENT>return get_refered_attribute(o_attr_ref)<EOL><DEDENT>else:<EOL><INDENT>return o_attr<EOL><DEDENT>", "docstring": "Get the the referred attribute.", "id": "f14751:m1"}
{"signature": "def build_schema(m, c_c):", "body": "schema = ET.Element('<STR_LIT>')<EOL>schema.set('<STR_LIT>', '<STR_LIT>')<EOL>global_filter = lambda selected: ooaofooa.is_global(selected)<EOL>for s_dt in m.select_many('<STR_LIT>', global_filter):<EOL><INDENT>datatype = build_type(s_dt)<EOL>if datatype is not None:<EOL><INDENT>schema.append(datatype)<EOL><DEDENT><DEDENT>scope_filter = lambda selected: ooaofooa.is_contained_in(selected, c_c)<EOL>for s_dt in m.select_many('<STR_LIT>', scope_filter):<EOL><INDENT>datatype = build_type(s_dt)<EOL>if datatype is not None:<EOL><INDENT>schema.append(datatype)<EOL><DEDENT><DEDENT>component = build_component(m, c_c)<EOL>schema.append(component)<EOL>return schema<EOL>", "docstring": "Build an xsd schema from a bridgepoint component.", "id": "f14751:m9"}
{"signature": "def prettify(xml_string):", "body": "reparsed = xml.dom.minidom.parseString(xml_string)<EOL>return reparsed.toprettyxml(indent=\"<STR_LIT:U+0020>\")<EOL>", "docstring": "Indent an xml string with four spaces, and add an additional line break after each node.", "id": "f14751:m10"}
{"signature": "def build_class(o_obj):", "body": "cls = ET.Element('<STR_LIT>', name=o_obj.key_lett, minOccurs='<STR_LIT:0>', maxOccurs='<STR_LIT>')<EOL>attributes = ET.SubElement(cls, '<STR_LIT>')<EOL>for o_attr in nav_many(o_obj).O_ATTR[<NUM_LIT>]():<EOL><INDENT>o_attr_ref = get_refered_attribute(o_attr)<EOL>s_dt = nav_one(o_attr_ref).S_DT[<NUM_LIT>]()<EOL>while nav_one(s_dt).S_UDT[<NUM_LIT>]():<EOL><INDENT>s_dt = nav_one(s_dt).S_UDT[<NUM_LIT>].S_DT[<NUM_LIT>]()<EOL><DEDENT>type_name = get_type_name(s_dt)<EOL>if type_name and not nav_one(o_attr).O_BATTR[<NUM_LIT>].O_DBATTR[<NUM_LIT>]():<EOL><INDENT>ET.SubElement(attributes, '<STR_LIT>', name=o_attr.name, type=type_name)<EOL><DEDENT>else:<EOL><INDENT>logger.warning('<STR_LIT>' % (o_obj.key_lett, o_attr.Name))<EOL><DEDENT><DEDENT>return cls<EOL>", "docstring": "Build an xsd complex element out of a O_OBJ, including its O_ATTR.", "id": "f14751:m7"}
{"signature": "@track_production<EOL><INDENT>def p_namespace(self, p):<DEDENT>", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "namespace : NAMESPACE", "id": "f14752:c65:m134"}
{"signature": "@track_production<EOL><INDENT>def p_while_statement(self, p):<DEDENT>", "body": "p[<NUM_LIT:0>] = WhileNode(expression=p[<NUM_LIT:2>],<EOL>block=p[<NUM_LIT:3>])<EOL>", "docstring": "statement : WHILE expression block END_WHILE", "id": "f14752:c65:m89"}
{"signature": "@track_production<EOL><INDENT>def p_create_assigner_event_statement(self, p):<DEDENT>", "body": "p[<NUM_LIT:0>] = CreateClassEventNode(variable_name=p[<NUM_LIT:4>],<EOL>event_specification=p[<NUM_LIT:6>],<EOL>key_letter=p[<NUM_LIT:8>])<EOL>", "docstring": "statement : CREATE EVENT INSTANCE variable_name OF event_specification TO identifier ASSIGNER", "id": "f14752:c65:m68"}
{"signature": "@track_production<EOL><INDENT>def p_parameter(self, p):<DEDENT>", "body": "p[<NUM_LIT:0>] = ParameterNode(name=p[<NUM_LIT:1>],<EOL>expression=p[<NUM_LIT:3>])<EOL>", "docstring": "parameter : identifier COLON expression", "id": "f14752:c65:m123"}
{"signature": "@track_production<EOL><INDENT>def p_port_event_generation(self, p):<DEDENT>", "body": "p[<NUM_LIT:0>] = GeneratePortEventNode(port_name=p[<NUM_LIT:2>],<EOL>action_name=p[<NUM_LIT:4>],<EOL>parameter_list=p[<NUM_LIT:6>],<EOL>expression=p[<NUM_LIT:9>])<EOL>", "docstring": "statement : SEND namespace DOUBLECOLON identifier LPAREN parameter_list RPAREN TO expression", "id": "f14752:c65:m61"}
{"signature": "def t_LSQBR(self, t):", "body": "t.endlexpos = t.lexpos + len(t.value)<EOL>return t<EOL>", "docstring": "r\"\\[", "id": "f14752:c65:m27"}
{"signature": "@track_production<EOL><INDENT>def p_variable_access_3(self, p):<DEDENT>", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "variable_access : index_access", "id": "f14752:c65:m154"}
{"signature": "@track_production<EOL><INDENT>def p_navigation_chain_2(self, p):<DEDENT>", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:2>]<EOL>p[<NUM_LIT:0>].children.insert(<NUM_LIT:0>, p[<NUM_LIT:1>])<EOL>", "docstring": "navigation_chain : navigation_step navigation_chain", "id": "f14752:c65:m113"}
{"signature": "@track_production<EOL><INDENT>def p_generate_instance_event_statement_2(self, p):<DEDENT>", "body": "p[<NUM_LIT:0>] = GenerateInstanceEventNode(event_specification=p[<NUM_LIT:2>],<EOL>variable_access=p[<NUM_LIT:4>])<EOL>", "docstring": "statement : GENERATE event_specification TO self_access", "id": "f14752:c65:m66"}
{"signature": "@track_production<EOL><INDENT>def p_unrelate_statement_using_2(self, p):<DEDENT>", "body": "p[<NUM_LIT:0>] = UnrelateUsingNode(from_variable_name=p[<NUM_LIT:2>],<EOL>to_variable_name=p[<NUM_LIT:4>],<EOL>rel_id=p[<NUM_LIT:6>],<EOL>phrase=p[<NUM_LIT:8>],<EOL>using_variable_name=p[<NUM_LIT:10>])<EOL>", "docstring": "statement : UNRELATE instance_name FROM instance_name ACROSS rel_id DOT phrase USING instance_name", "id": "f14752:c65:m104"}
{"signature": "@track_production<EOL><INDENT>def p_select_from_where_statement_1(self, p):<DEDENT>", "body": "p[<NUM_LIT:0>] = SelectFromWhereNode(cardinality=p[<NUM_LIT:2>],<EOL>variable_name=p[<NUM_LIT:3>],<EOL>key_letter=p[<NUM_LIT:7>],<EOL>where_clause=p[<NUM_LIT:9>])<EOL>", "docstring": "statement : SELECT ANY variable_name FROM INSTANCES OF identifier WHERE expression\n          | SELECT MANY variable_name FROM INSTANCES OF identifier WHERE expression", "id": "f14752:c65:m107"}
{"signature": "@track_production<EOL><INDENT>def p_class_invocation_statement(self, p):<DEDENT>", "body": "p[<NUM_LIT:2>].__class__ = ClassInvocationNode<EOL>p[<NUM_LIT:0>] = InvocationStatementNode(p[<NUM_LIT:2>])<EOL>", "docstring": "statement : TRANSFORM implicit_invocation", "id": "f14752:c65:m57"}
{"signature": "@track_production<EOL><INDENT>def p_implicit_invocation(self, p):<DEDENT>", "body": "p[<NUM_LIT:0>] = ImplicitInvocationNode(namespace=p[<NUM_LIT:1>],<EOL>action_name=p[<NUM_LIT:3>],<EOL>parameter_list=p[<NUM_LIT:5>])<EOL>", "docstring": "implicit_invocation : namespace DOUBLECOLON identifier LPAREN parameter_list RPAREN", "id": "f14752:c65:m117"}
{"signature": "@track_production<EOL><INDENT>def p_variable_access_1(self, p):<DEDENT>", "body": "p[<NUM_LIT:0>] = VariableAccessNode(variable_name=p[<NUM_LIT:1>])<EOL>", "docstring": "variable_access : variable_name", "id": "f14752:c65:m152"}
{"signature": "@track_production<EOL><INDENT>def p_constant_fraction(self, p):<DEDENT>", "body": "p[<NUM_LIT:0>] = RealNode(value=p[<NUM_LIT:1>])<EOL>", "docstring": "constant : FRACTION", "id": "f14752:c65:m156"}
{"signature": "def t_DIV(self, t):", "body": "t.endlexpos = t.lexpos + len(t.value)<EOL>return t<EOL>", "docstring": "r\"/", "id": "f14752:c65:m34"}
{"signature": "@track_production<EOL><INDENT>def p_select_from_statement_2(self, p):<DEDENT>", "body": "p[<NUM_LIT:0>] = SelectFromNode(cardinality=p[<NUM_LIT:2>],<EOL>variable_name=p[<NUM_LIT:3>],<EOL>key_letter=p[<NUM_LIT:5>])<EOL>", "docstring": "statement : SELECT ANY variable_name FROM identifier\n          | SELECT MANY variable_name FROM identifier", "id": "f14752:c65:m106"}
{"signature": "@track_production<EOL><INDENT>def p_create_class_event_statement(self, p):<DEDENT>", "body": "p[<NUM_LIT:0>] = CreateClassEventNode(variable_name=p[<NUM_LIT:4>],<EOL>event_specification=p[<NUM_LIT:6>],<EOL>key_letter=p[<NUM_LIT:8>])<EOL>", "docstring": "statement : CREATE EVENT INSTANCE variable_name OF event_specification TO identifier CLASS", "id": "f14752:c65:m67"}
{"signature": "@track_production<EOL><INDENT>def p_instance_name(self, p):<DEDENT>", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "instance_name : variable_name\n                         | SELF", "id": "f14752:c65:m140"}
{"signature": "@track_production<EOL><INDENT>def p_event_parameter_list_1(self, p):<DEDENT>", "body": "p[<NUM_LIT:0>] = EventDataListNode()<EOL>p[<NUM_LIT:0>].children.append(p[<NUM_LIT:1>])<EOL>", "docstring": "event_parameter_list : event_parameter", "id": "f14752:c65:m81"}
{"signature": "@track_production<EOL><INDENT>def p_create_instance_event_statement_2(self, p):<DEDENT>", "body": "p[<NUM_LIT:0>] = CreateInstanceEventNode(variable_name=p[<NUM_LIT:4>],<EOL>event_specification=p[<NUM_LIT:6>],<EOL>to_variable_access=p[<NUM_LIT:8>])<EOL>", "docstring": "statement : CREATE EVENT INSTANCE variable_name OF event_specification TO self_access", "id": "f14752:c65:m71"}
{"signature": "@track_production<EOL><INDENT>def p_limited_identifier(self, p):<DEDENT>", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "limited_identifier : ID\n                   | kw_as_identifier_1", "id": "f14752:c65:m133"}
{"signature": "def t_MINUS(self, t):", "body": "t.endlexpos = t.lexpos + len(t.value)<EOL>return t<EOL>", "docstring": "r\"\\-", "id": "f14752:c65:m33"}
{"signature": "@track_production<EOL><INDENT>def p_create_creator_event_statement(self, p):<DEDENT>", "body": "p[<NUM_LIT:0>] = CreateCreatorEventNode(variable_name=p[<NUM_LIT:4>],<EOL>event_specification=p[<NUM_LIT:6>],<EOL>key_letter=p[<NUM_LIT:8>])<EOL>", "docstring": "statement : CREATE EVENT INSTANCE variable_name OF event_specification TO identifier CREATOR", "id": "f14752:c65:m69"}
{"signature": "def t_GT(self, t):", "body": "t.endlexpos = t.lexpos + len(t.value)<EOL>return t<EOL>", "docstring": "r\"\\>", "id": "f14752:c65:m31"}
{"signature": "@track_production<EOL><INDENT>def p_select_from_statement_1(self, p):<DEDENT>", "body": "p[<NUM_LIT:0>] = SelectFromNode(cardinality=p[<NUM_LIT:2>],<EOL>variable_name=p[<NUM_LIT:3>],<EOL>key_letter=p[<NUM_LIT:7>])<EOL>", "docstring": "statement : SELECT ANY variable_name FROM INSTANCES OF identifier\n          | SELECT MANY variable_name FROM INSTANCES OF identifier", "id": "f14752:c65:m105"}
{"signature": "@track_production<EOL><INDENT>def p_bridge_assignment_statement(self, p):<DEDENT>", "body": "p[<NUM_LIT:4>].__class__ = BridgeInvocationNode<EOL>p[<NUM_LIT:0>] = AssignmentNode(variable_access=p[<NUM_LIT:2>],<EOL>expression=p[<NUM_LIT:4>])<EOL>", "docstring": "statement : BRIDGE variable_access EQUAL implicit_invocation", "id": "f14752:c65:m53"}
{"signature": "@track_production<EOL><INDENT>def p_constant_boolean(self, p):<DEDENT>", "body": "p[<NUM_LIT:0>] = BooleanNode(value=p[<NUM_LIT:1>])<EOL>", "docstring": "constant : TRUE\n         | FALSE", "id": "f14752:c65:m159"}
{"signature": "@track_production<EOL><INDENT>def p_parameter_list_2(self, p):<DEDENT>", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:3>]<EOL>p[<NUM_LIT:0>].children.insert(<NUM_LIT:0>, p[<NUM_LIT:1>])<EOL>", "docstring": "parameter_list : parameter COMMA parameter_list", "id": "f14752:c65:m121"}
{"signature": "@track_production<EOL><INDENT>def p_block(self, p):<DEDENT>", "body": "p[<NUM_LIT:0>] = BlockNode(statement_list=p[<NUM_LIT:1>])<EOL>", "docstring": "block : statement_list", "id": "f14752:c65:m40"}
{"signature": "@track_production<EOL><INDENT>def p_explicit_assignment_statement(self, p):<DEDENT>", "body": "p[<NUM_LIT:0>] = AssignmentNode(variable_access=p[<NUM_LIT:2>],<EOL>expression=p[<NUM_LIT:4>])<EOL>", "docstring": "statement : ASSIGN variable_access EQUAL expression", "id": "f14752:c65:m50"}
{"signature": "@track_production<EOL><INDENT>def p_expression_1(self, p):<DEDENT>", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "expression : constant", "id": "f14752:c65:m124"}
{"signature": "def t_ID(self, t):", "body": "t.endlexpos = t.lexpos + len(t.value)<EOL>value = t.value.upper()<EOL>if value in self.keywords:<EOL><INDENT>t.type = value<EOL><DEDENT>return t<EOL>", "docstring": "r\"[a-zA-Z_][0-9a-zA-Z_]*|[a-zA-Z][0-9a-zA-Z_]*[0-9a-zA-Z_]+", "id": "f14752:c65:m10"}
{"signature": "@track_production<EOL><INDENT>def p_variable_access_2(self, p):<DEDENT>", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "variable_access : field_access", "id": "f14752:c65:m153"}
{"signature": "@track_production<EOL><INDENT>def p_instance_invocation_assignment_statement(self, p):<DEDENT>", "body": "p[<NUM_LIT:0>] = AssignmentNode(variable_access=p[<NUM_LIT:2>],<EOL>expression=p[<NUM_LIT:4>])<EOL>", "docstring": "statement : TRANSFORM variable_access EQUAL instance_invocation", "id": "f14752:c65:m56"}
{"signature": "def t_FRACTION(self, t):", "body": "t.endlexpos = t.lexpos + len(t.value)<EOL>return t<EOL>", "docstring": "r\"(((\\d*\\.\\d+)|(\\d+\\.)([eE][-+]?\\d+)?)|(\\d+([eE][-+]?\\d+)))[FfLl]?", "id": "f14752:c65:m11"}
{"signature": "@track_production<EOL><INDENT>def p_create_object_statement(self, p):<DEDENT>", "body": "p[<NUM_LIT:0>] = CreateObjectNode(variable_name=p[<NUM_LIT:4>],<EOL>key_letter=p[<NUM_LIT:6>])<EOL>", "docstring": "statement : CREATE OBJECT INSTANCE variable_name OF identifier", "id": "f14752:c65:m85"}
{"signature": "@track_production<EOL><INDENT>def p_kw_as_identifier_4(self, p):<DEDENT>", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "kw_as_identifier_4 : AND\n                   | ELIF\n                   | ELSE\n                   | IF\n                   | OR\n                   | RETURN\n                   | WHILE", "id": "f14752:c65:m138"}
{"signature": "@track_production<EOL><INDENT>def p_instance_invocation_statement(self, p):<DEDENT>", "body": "p[<NUM_LIT:0>] = InvocationStatementNode(p[<NUM_LIT:2>])<EOL>", "docstring": "statement : TRANSFORM instance_invocation", "id": "f14752:c65:m55"}
{"signature": "def t_TIMES(self, t):", "body": "t.endlexpos = t.lexpos + len(t.value)<EOL>return t<EOL>", "docstring": "r\"\\*", "id": "f14752:c65:m24"}
{"signature": "@track_production<EOL><INDENT>def p_identifier(self, p):<DEDENT>", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "identifier : limited_identifier\n      | kw_as_identifier_2\n      | kw_as_identifier_3\n      | kw_as_identifier_4", "id": "f14752:c65:m141"}
{"signature": "def p_phrase_1(self, p):", "body": "p[<NUM_LIT:0>] = p[<NUM_LIT:1>]<EOL>", "docstring": "phrase : TICKED_PHRASE", "id": "f14752:c65:m75"}
{"signature": "@track_production<EOL><INDENT>def p_selected_access_1(self, p):<DEDENT>", "body": "p[<NUM_LIT:0>] = SelectedAccessNode()<EOL>", "docstring": "selected_access : SELECTED", "id": "f14752:c65:m151"}
{"signature": "def t_newline(self, t):", "body": "t.lexer.lineno += len(t.value)<EOL>t.endlexpos = t.lexpos + len(t.value)<EOL>", "docstring": "r'\\n+", "id": "f14752:c65:m36"}
{"signature": "def t_DOUBLECOLON(self, t):", "body": "t.endlexpos = t.lexpos + len(t.value)<EOL>return t<EOL>", "docstring": "r\"::", "id": "f14752:c65:m13"}
{"signature": "def main():", "body": "parser = optparse.OptionParser(usage=\"<STR_LIT>\",<EOL>version=xtuml.version.complete_string,<EOL>formatter=optparse.TitledHelpFormatter())<EOL>parser.set_description(__doc__.strip())<EOL>parser.add_option(\"<STR_LIT:-c>\", \"<STR_LIT>\", dest=\"<STR_LIT>\", metavar=\"<STR_LIT>\",<EOL>help=\"<STR_LIT>\",<EOL>action=\"<STR_LIT:store>\", default=None)<EOL>parser.add_option(\"<STR_LIT>\", \"<STR_LIT>\", dest=\"<STR_LIT>\",<EOL>help=\"<STR_LIT>\",<EOL>action=\"<STR_LIT:store_true>\", default=False)<EOL>parser.add_option(\"<STR_LIT>\", \"<STR_LIT>\", dest='<STR_LIT>', metavar=\"<STR_LIT>\",<EOL>help=\"<STR_LIT>\",<EOL>action=\"<STR_LIT:store>\", default=None)<EOL>parser.add_option(\"<STR_LIT>\", \"<STR_LIT>\", dest='<STR_LIT>', action=\"<STR_LIT:count>\", <EOL>help=\"<STR_LIT>\", default=<NUM_LIT:2>)<EOL>(opts, args) = parser.parse_args()<EOL>if len(args) == <NUM_LIT:0> or opts.output is None:<EOL><INDENT>parser.print_help()<EOL>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>levels = {<EOL><NUM_LIT:0>: logging.ERROR,<EOL><NUM_LIT:1>: logging.WARNING,<EOL><NUM_LIT:2>: logging.INFO,<EOL><NUM_LIT:3>: logging.DEBUG,<EOL>}<EOL>logging.basicConfig(level=levels.get(opts.verbosity, logging.DEBUG))<EOL>loader = ooaofooa.Loader()<EOL>for filename in args:<EOL><INDENT>loader.filename_input(filename)<EOL><DEDENT>c = loader.build_component(opts.component, opts.derived)<EOL>xtuml.persist_database(c, opts.output)<EOL>", "docstring": "Parse argv for options and arguments, and start schema generation.", "id": "f14753:m0"}
{"signature": "def _get_data_type_name(s_dt):", "body": "s_cdt = one(s_dt).S_CDT[<NUM_LIT>]()<EOL>if s_cdt and s_cdt.Core_Typ in range(<NUM_LIT:1>, <NUM_LIT:6>):<EOL><INDENT>return s_dt.Name.upper()<EOL><DEDENT>if one(s_dt).S_EDT[<NUM_LIT>]():<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>s_dt = one(s_dt).S_UDT[<NUM_LIT>].S_DT[<NUM_LIT>]()<EOL>if s_dt:<EOL><INDENT>return _get_data_type_name(s_dt)<EOL><DEDENT>", "docstring": "Convert a BridgePoint data type to a pyxtuml meta model type.", "id": "f14754:m4"}
{"signature": "def _get_related_attributes(r_rgo, r_rto):", "body": "l1 = list()<EOL>l2 = list()<EOL>ref_filter = lambda ref: ref.OIR_ID == r_rgo.OIR_ID<EOL>for o_ref in many(r_rto).O_RTIDA[<NUM_LIT>].O_REF[<NUM_LIT>](ref_filter):<EOL><INDENT>o_attr = one(o_ref).O_RATTR[<NUM_LIT>].O_ATTR[<NUM_LIT>]()<EOL>l1.append(o_attr.Name)<EOL>o_attr = one(o_ref).O_RTIDA[<NUM_LIT>].O_OIDA[<NUM_LIT>].O_ATTR[<NUM_LIT>]()<EOL>l2.append(o_attr.Name)<EOL><DEDENT>return l1, l2<EOL>", "docstring": "The two lists of attributes which relates two classes in an association.", "id": "f14754:m5"}
{"signature": "def filename_input(self, path_or_filename):", "body": "if os.path.isdir(path_or_filename):<EOL><INDENT>for path, _, files in os.walk(path_or_filename):<EOL><INDENT>for name in files:<EOL><INDENT>if name.endswith('<STR_LIT>'):<EOL><INDENT>xtuml.ModelLoader.filename_input(self, os.path.join(path, name))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>xtuml.ModelLoader.filename_input(self, path_or_filename)<EOL><DEDENT>", "docstring": "Open and read input from a *path or filename*, and parse its content.\n\nIf the filename is a directory, files that ends with .xtuml located\nsomewhere in the directory or sub directories will be loaded as well.", "id": "f14754:c2:m1"}
{"signature": "def mk_derived_association(m, r_comp):", "body": "pass<EOL>", "docstring": "Create a pyxtuml association from a derived association in BridgePoint.", "id": "f14754:m17"}
{"signature": "def mk_function(metamodel, s_sync):", "body": "action = s_sync.Action_Semantics_internal<EOL>label = s_sync.Name<EOL>return lambda **kwargs: interpret.run_function(metamodel, label, <EOL>action, kwargs)<EOL>", "docstring": "Create a python function from a BridgePoint function.", "id": "f14754:m9"}
{"signature": "def mk_constant(cnst_syc):", "body": "s_dt = one(cnst_syc).S_DT[<NUM_LIT>]()<EOL>cnst_lsc = one(cnst_syc).CNST_LFSC[<NUM_LIT>].CNST_LSC[<NUM_LIT>]()<EOL>if s_dt.Name == '<STR_LIT>':<EOL><INDENT>return cnst_lsc.Value.lower() == '<STR_LIT:true>'<EOL><DEDENT>if s_dt.Name == '<STR_LIT>':<EOL><INDENT>return int(cnst_lsc.Value)<EOL><DEDENT>if s_dt.Name == '<STR_LIT>':<EOL><INDENT>return float(cnst_lsc.Value)<EOL><DEDENT>if s_dt.Name == '<STR_LIT:string>':<EOL><INDENT>return str(cnst_lsc.Value)<EOL><DEDENT>", "docstring": "Create a python value from a BridgePoint constant.", "id": "f14754:m10"}
{"signature": "def is_contained_in(pe_pe, root):", "body": "if not pe_pe:<EOL><INDENT>return False<EOL><DEDENT>if type(pe_pe).__name__ != '<STR_LIT>':<EOL><INDENT>pe_pe = one(pe_pe).PE_PE[<NUM_LIT>]()<EOL><DEDENT>ep_pkg = one(pe_pe).EP_PKG[<NUM_LIT>]()<EOL>c_c = one(pe_pe).C_C[<NUM_LIT>]()<EOL>if root in [ep_pkg, c_c]:<EOL><INDENT>return True<EOL><DEDENT>elif is_contained_in(ep_pkg, root):<EOL><INDENT>return True<EOL><DEDENT>elif is_contained_in(c_c, root):<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Determine if a PE_PE is contained within a EP_PKG or a C_C.", "id": "f14754:m0"}
{"signature": "def mk_linked_association(m, r_assoc):", "body": "r_rel = one(r_assoc).R_REL[<NUM_LIT>]()<EOL>r_rgo = one(r_assoc).R_ASSR[<NUM_LIT>].R_RGO[<NUM_LIT>]()<EOL>source_o_obj = one(r_rgo).R_OIR[<NUM_LIT>].O_OBJ[<NUM_LIT>]()<EOL>def _mk_assoc(side1, side2):<EOL><INDENT>r_rto = one(side1).R_RTO[<NUM_LIT>]()<EOL>target_o_obj = one(r_rto).R_OIR[<NUM_LIT>].O_OBJ[<NUM_LIT>]()<EOL>source_ids, target_ids = _get_related_attributes(r_rgo, r_rto)<EOL>if side1.Obj_ID != side2.Obj_ID:<EOL><INDENT>source_phrase = target_phrase = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>source_phrase = side1.Txt_Phrs<EOL>target_phrase = side2.Txt_Phrs<EOL><DEDENT>m.define_association(rel_id=r_rel.Numb, <EOL>source_kind=source_o_obj.Key_Lett,<EOL>target_kind=target_o_obj.Key_Lett,<EOL>source_keys=source_ids,<EOL>target_keys=target_ids,<EOL>source_conditional=side2.Cond,<EOL>target_conditional=False,<EOL>source_phrase=source_phrase,<EOL>target_phrase=target_phrase,<EOL>source_many=side2.Mult,<EOL>target_many=False)<EOL><DEDENT>r_aone = one(r_assoc).R_AONE[<NUM_LIT>]()<EOL>r_aoth = one(r_assoc).R_AOTH[<NUM_LIT>]()<EOL>_mk_assoc(r_aone, r_aoth)<EOL>_mk_assoc(r_aoth, r_aone)<EOL>", "docstring": "Create pyxtuml associations from a linked association in BridgePoint.", "id": "f14754:m15"}
{"signature": "def build_component(self, name=None, derived_attributes=False):", "body": "mm = self.build_metamodel()<EOL>c_c = mm.select_any('<STR_LIT>', where(Name=name))<EOL>if c_c:<EOL><INDENT>return mk_component(mm, c_c, derived_attributes)<EOL><DEDENT>elif name:<EOL><INDENT>raise OoaOfOoaException('<STR_LIT>' % name)<EOL><DEDENT>else:<EOL><INDENT>return mk_component(mm, c_c, derived_attributes)<EOL><DEDENT>", "docstring": "Instantiate and build a component from ooaofooa named *name* as a\npyxtuml model. Classes, associations, attributes and unique identifers,\ni.e. O_OBJ, R_REL, O_ATTR in ooaofooa, are defined in the resulting\npyxtuml model.\n\nOptionally, control whether *derived attributes* shall be mapped into\nthe resulting pyxtuml model as attributes or not.\n\nFuthermore, if no *name* is provided, the entire content of the ooaofooa\nmodel is instantiated into the pyxtuml model.", "id": "f14754:c2:m2"}
{"signature": "def prebuild_action(instance):", "body": "walker_map = {<EOL>'<STR_LIT>': FunctionPrebuilder,<EOL>'<STR_LIT>': BridgePrebuilder,<EOL>'<STR_LIT>': OperationPrebuilder,<EOL>'<STR_LIT>': DerivedAttributePrebuilder,<EOL>'<STR_LIT>': TransitionPrebuilder,<EOL>'<STR_LIT>': RequiredOperationPrebuilder,<EOL>'<STR_LIT>': RequiredSignalPrebuilder,<EOL>'<STR_LIT>': ProvidedOperationPrebuilder,<EOL>'<STR_LIT>': ProvidedSignalPrebuilder<EOL>}<EOL>metaclass = xtuml.get_metaclass(instance)<EOL>walker = walker_map[metaclass.kind](metaclass.metamodel, instance)<EOL>logger.info('<STR_LIT>' % walker.label)<EOL>root = oal.parse(instance.Action_Semantics_internal)<EOL>return walker.accept(root)<EOL>", "docstring": "Transform textual OAL actions of an *instance* to instances in the ooaofooa\nsubsystems Value and Body. The provided *instance* must be an instance of \none of the following classes:\n\n- S_SYNC\n- S_BRG\n- O_TFR\n- O_DBATTR\n- SM_ACT\n- SPR_RO\n- SPR_RS\n- SPR_PO\n- SPR_PS", "id": "f14757:m3"}
{"signature": "def find_symbol(self, name=None, kind=None):", "body": "for s in reversed(self.stack):<EOL><INDENT>for symbol_name, handle in s.symbols.items():<EOL><INDENT>symbol_kind = handle.__class__.__name__<EOL>if name == symbol_name and kind == symbol_kind:<EOL><INDENT>return handle<EOL><DEDENT>elif name is None and kind == handle.__class__.__name__:<EOL><INDENT>return handle<EOL><DEDENT>elif name == symbol_name and kind is None:<EOL><INDENT>return handle<EOL><DEDENT><DEDENT>if name is None and kind == s.handle.__class__.__name__:<EOL><INDENT>return s.handle<EOL><DEDENT><DEDENT>", "docstring": "Find a symbol in the symbol table by name, kind, or both.", "id": "f14757:c1:m4"}
{"signature": "def forceLogCompaction(self):", "body": "self.__forceLogCompaction = True<EOL>", "docstring": "Force to start log compaction (without waiting required time or required number of entries)", "id": "f14788:c5:m25"}
{"signature": "def destroy(self):", "body": "if self.__conf.autoTick:<EOL><INDENT>self.__destroying = True<EOL><DEDENT>else:<EOL><INDENT>self._doDestroy()<EOL><DEDENT>", "docstring": "Correctly destroy SyncObj. Stop autoTickThread, close connections, etc.", "id": "f14788:c5:m1"}
{"signature": "@replicated<EOL><INDENT>def setdefault(self, key, default):<DEDENT>", "body": "return self.__data.setdefault(key, default)<EOL>", "docstring": "Return value for specified key, set default value if key not exist", "id": "f14799:c2:m4"}
{"signature": "def isAcquired(self, lockID):", "body": "return self.__lockImpl.isAcquired(lockID, self.__selfID, time.time())<EOL>", "docstring": "Check if lock is acquired by ourselves.\n\n        :param lockID: unique lock identifier.\n        :type lockID: str\n        :return True if lock is acquired by ourselves.", "id": "f14799:c7:m5"}
{"signature": "@replicated<EOL><INDENT>def reset(self, newData):<DEDENT>", "body": "assert isinstance(newData, dict)<EOL>self.__data = newData<EOL>", "docstring": "Replace dict with a new one", "id": "f14799:c2:m1"}
{"signature": "def __len__(self):", "body": "return len(self.__data)<EOL>", "docstring": "Return size of queue", "id": "f14799:c4:m3"}
{"signature": "def __init__(self):", "body": "super(ReplSet, self).__init__()<EOL>self.__data = set()<EOL>", "docstring": "Distributed set - it has an interface similar to a regular set.", "id": "f14799:c3:m0"}
{"signature": "@replicated<EOL><INDENT>def get(self, default=None):<DEDENT>", "body": "try:<EOL><INDENT>return self.__data.popleft()<EOL><DEDENT>except:<EOL><INDENT>return default<EOL><DEDENT>", "docstring": "Extract item from queue.\n        Return default if queue is empty.", "id": "f14799:c4:m6"}
{"signature": "@replicated<EOL><INDENT>def sub(self, value):<DEDENT>", "body": "self.__counter -= value<EOL>return self.__counter<EOL>", "docstring": "Subtracts a value from counter.\n\n:param value: value to subtract\n:return: new counter value", "id": "f14799:c0:m3"}
{"signature": "@replicated<EOL><INDENT>def discard(self, item):<DEDENT>", "body": "self.__data.discard(item)<EOL>", "docstring": "Remove an element from a set if it is a member.\nIf the element is not a member, do nothing.", "id": "f14799:c3:m4"}
{"signature": "@replicated<EOL><INDENT>def pop(self, key, default=None):<DEDENT>", "body": "return self.__data.pop(key, default)<EOL>", "docstring": "Remove and return value for given key, return default if key not exist", "id": "f14799:c2:m6"}
{"signature": "def qsize(self):", "body": "return len(self.__data)<EOL>", "docstring": "Return size of queue", "id": "f14799:c4:m1"}
{"signature": "@replicated<EOL><INDENT>def reset(self, newData):<DEDENT>", "body": "assert isinstance(newData, set)<EOL>self.__data = newData<EOL>", "docstring": "Replace set with a new one", "id": "f14799:c3:m1"}
{"signature": "@replicated<EOL><INDENT>def put(self, item):<DEDENT>", "body": "if self.__maxsize and len(self.__data) >= self.__maxsize:<EOL><INDENT>return False<EOL><DEDENT>self.__data.append(item)<EOL>return True<EOL>", "docstring": "Put an item into the queue.\n        True - if item placed in queue.\n        False - if queue is full and item can not be placed.", "id": "f14799:c4:m5"}
{"signature": "@replicated<EOL><INDENT>def __setitem__(self, key, value):<DEDENT>", "body": "self.__data[key] = value<EOL>", "docstring": "Set value for specified key", "id": "f14799:c2:m2"}
{"signature": "def __getitem__(self, key):", "body": "return self.__data[key]<EOL>", "docstring": "Return value for given key", "id": "f14799:c2:m8"}
{"signature": "@replicated<EOL><INDENT>def extend(self, other):<DEDENT>", "body": "self.__data.extend(other)<EOL>", "docstring": "Extend list by appending elements from the iterable", "id": "f14799:c1:m4"}
{"signature": "def keys(self):", "body": "return self.__data.keys()<EOL>", "docstring": "Return all keys", "id": "f14799:c2:m12"}
{"signature": "@replicated<EOL><INDENT>def remove(self, item):<DEDENT>", "body": "self.__data.remove(item)<EOL>", "docstring": "Remove an element from a set; it must be a member.\nIf the element is not a member, raise a KeyError.", "id": "f14799:c3:m3"}
{"signature": "def empty(self):", "body": "return len(self.__data) == <NUM_LIT:0><EOL>", "docstring": "True if queue is empty", "id": "f14799:c5:m2"}
{"signature": "@replicated<EOL><INDENT>def append(self, item):<DEDENT>", "body": "self.__data.append(item)<EOL>", "docstring": "Append item to end", "id": "f14799:c1:m3"}
{"signature": "@replicated<EOL><INDENT>def inc(self):<DEDENT>", "body": "self.__counter += <NUM_LIT:1><EOL>return self.__counter<EOL>", "docstring": "Increments counter value by one.\n\n:return: new counter value", "id": "f14799:c0:m4"}
{"signature": "def full(self):", "body": "return len(self.__data) == self.__maxsize<EOL>", "docstring": "True if queue is full", "id": "f14799:c4:m4"}
{"signature": "def _createServer(self):", "body": "conf = self._syncObj.conf<EOL>bindAddr = conf.bindAddress or getattr(self._selfNode, '<STR_LIT:address>')<EOL>if not bindAddr:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>host, port = bindAddr.rsplit('<STR_LIT::>', <NUM_LIT:1>)<EOL>host = globalDnsResolver().resolve(host)<EOL>self._server = TcpServer(self._syncObj._poller, host, port, onNewConnection = self._onNewIncomingConnection,<EOL>sendBufferSize = conf.sendBufferSize,<EOL>recvBufferSize = conf.recvBufferSize,<EOL>connectionTimeout = conf.connectionTimeout)<EOL>", "docstring": "Create the TCP server (but don't bind yet)", "id": "f14802:c2:m4"}
{"signature": "def waitReady(self):", "body": "self._bindOverEvent.wait()<EOL>if not self._ready:<EOL><INDENT>raise TransportNotReadyError<EOL><DEDENT>", "docstring": "Wait for the TCP transport to become ready for operation, i.e. the server to be bound.\nThis method should be called from a different thread than used for the SyncObj ticks.\n\n:raises TransportNotReadyError: if the number of bind tries exceeds the configured limit", "id": "f14802:c2:m16"}
{"signature": "def destroy(self):", "body": "", "docstring": "Destroy the transport", "id": "f14802:c1:m17"}
{"signature": "def _onNewIncomingConnection(self, conn):", "body": "self._unknownConnections.add(conn)<EOL>encryptor = self._syncObj.encryptor<EOL>if encryptor:<EOL><INDENT>conn.encryptor = encryptor<EOL><DEDENT>conn.setOnMessageReceivedCallback(functools.partial(self._onIncomingMessageReceived, conn))<EOL>conn.setOnDisconnectedCallback(functools.partial(self._onDisconnected, conn))<EOL>", "docstring": "Callback for connections initiated by the other side\n\n:param conn: connection object\n:type conn: TcpConnection", "id": "f14802:c2:m7"}
{"signature": "def addNode(self, node):", "body": "self._nodes.add(node)<EOL>self._nodeAddrToNode[node.address] = node<EOL>if self._shouldConnect(node):<EOL><INDENT>conn = TcpConnection(poller = self._syncObj._poller,<EOL>timeout = self._syncObj.conf.connectionTimeout,<EOL>sendBufferSize = self._syncObj.conf.sendBufferSize,<EOL>recvBufferSize = self._syncObj.conf.recvBufferSize)<EOL>conn.encryptor = self._syncObj.encryptor<EOL>conn.setOnConnectedCallback(functools.partial(self._onOutgoingConnected, conn))<EOL>conn.setOnMessageReceivedCallback(functools.partial(self._onMessageReceived, node))<EOL>conn.setOnDisconnectedCallback(functools.partial(self._onDisconnected, conn))<EOL>self._connections[node] = conn<EOL><DEDENT>", "docstring": "Add a node to the network\n\n:param node: node to add\n:type node: TCPNode", "id": "f14802:c2:m17"}
{"signature": "def _utilityCallback(self, res, err, conn, cmd, arg):", "body": "cmdResult = '<STR_LIT>'<EOL>if err == FAIL_REASON.SUCCESS:<EOL><INDENT>cmdResult = '<STR_LIT>'<EOL><DEDENT>conn.send(cmdResult + '<STR_LIT:U+0020>' + cmd + '<STR_LIT:U+0020>' + arg)<EOL>", "docstring": "Callback for the utility messages\n\n:param res: result of the command\n:param err: error code (one of pysyncobj.config.FAIL_REASON)\n:param conn: utility connection\n:param cmd: command\n:param arg: command arguments", "id": "f14802:c2:m9"}
{"signature": "def destroy(self):", "body": "self.setOnMessageReceivedCallback(None)<EOL>self.setOnNodeConnectedCallback(None)<EOL>self.setOnNodeDisconnectedCallback(None)<EOL>self.setOnReadonlyNodeConnectedCallback(None)<EOL>self.setOnReadonlyNodeDisconnectedCallback(None)<EOL>for node in self._nodes | self._readonlyNodes:<EOL><INDENT>self.dropNode(node)<EOL><DEDENT>if self._server is not None:<EOL><INDENT>self._server.unbind()<EOL><DEDENT>for conn in self._unknownConnections:<EOL><INDENT>conn.disconnect()<EOL><DEDENT>self._unknownConnections = set()<EOL>", "docstring": "Destroy this transport", "id": "f14802:c2:m20"}
{"signature": "def tryGetReady(self):", "body": "self._maybeBind()<EOL>", "docstring": "Try to bind the server if necessary.\n\n:raises TransportNotReadyError if the server could not be bound", "id": "f14802:c2:m2"}
{"signature": "@property<EOL><INDENT>def ready(self):<DEDENT>", "body": "return True<EOL>", "docstring": "Whether the transport is ready for operation.\n\n:rtype bool", "id": "f14802:c1:m12"}
{"signature": "def update(self, allow_partial=True, force=False, **kwargs):", "body": "if kwargs:<EOL><INDENT>self.__init__(partial=allow_partial, force=force, **kwargs)<EOL>return not self._partial<EOL><DEDENT>if not force and CACHE.get(hash(self)):<EOL><INDENT>cached = CACHE[hash(self)]<EOL>for field in self._SIMPLE_FIELDS | self._COMPLEX_FIELDS:<EOL><INDENT>v = getattr(cached, field)<EOL>setattr(self, field, v)<EOL><DEDENT>self._partial = False<EOL>logging.info(f'<STR_LIT>')<EOL>return True<EOL><DEDENT>resp_dict = element_lookup_by_id(self.type, self.id)<EOL>self.__init__(partial=False, **resp_dict)<EOL>return True<EOL>", "docstring": "Updates record and returns True if record is complete after update, else False.", "id": "f14825:c0:m6"}
{"signature": "def po_to_csv_merge(languages, locale_root, po_files_path,<EOL>local_trans_csv, local_meta_csv,<EOL>gdocs_trans_csv, gdocs_meta_csv):", "body": "msgids = []<EOL>trans_reader = UnicodeReader(gdocs_trans_csv)<EOL>meta_reader = UnicodeReader(gdocs_meta_csv)<EOL>try:<EOL><INDENT>trans_title = trans_reader.next()<EOL>meta_title = meta_reader.next()<EOL><DEDENT>except StopIteration:<EOL><INDENT>trans_title = ['<STR_LIT:file>', '<STR_LIT>', '<STR_LIT>']<EOL>trans_title += map(lambda s: s + '<STR_LIT>', languages)<EOL>meta_title = ['<STR_LIT>']<EOL><DEDENT>trans_writer, meta_writer = _get_new_csv_writers(<EOL>trans_title, meta_title, local_trans_csv, local_meta_csv)<EOL>for trans_row, meta_row in izip_longest(trans_reader, meta_reader):<EOL><INDENT>msgids.append(trans_row[<NUM_LIT:2>])<EOL>trans_writer.writerow(trans_row)<EOL>meta_writer.writerow(meta_row if meta_row else [METADATA_EMPTY])<EOL><DEDENT>trans_reader.close()<EOL>meta_reader.close()<EOL>po_files = _get_all_po_filenames(locale_root, languages[<NUM_LIT:0>], po_files_path)<EOL>new_trans = False<EOL>for po_filename in po_files:<EOL><INDENT>new_msgstrs = {}<EOL>for lang in languages[<NUM_LIT:1>:]:<EOL><INDENT>po_file_path = os.path.join(locale_root, lang,<EOL>po_files_path, po_filename)<EOL>if not os.path.exists(po_file_path):<EOL><INDENT>open(po_file_path, '<STR_LIT:a>').close()<EOL><DEDENT>new_msgstrs[lang] = _get_new_msgstrs(po_file_path, msgids)<EOL><DEDENT>if len(new_msgstrs[languages[<NUM_LIT:1>]].keys()) > <NUM_LIT:0>:<EOL><INDENT>new_trans = True<EOL>po_file_path = os.path.join(locale_root, languages[<NUM_LIT:0>],<EOL>po_files_path, po_filename)<EOL>_write_new_messages(po_file_path, trans_writer, meta_writer,<EOL>msgids, new_msgstrs, languages)<EOL><DEDENT><DEDENT>trans_writer.close()<EOL>meta_writer.close()<EOL>return new_trans<EOL>", "docstring": "Converts po file to csv GDocs spreadsheet readable format.\nMerges them if some msgid aren't in the spreadsheet.\n:param languages: list of language codes\n:param locale_root: path to locale root folder containing directories\n                    with languages\n:param po_files_path: path from lang directory to po file\n:param local_trans_csv: path where local csv with translations\n                        will be created\n:param local_meta_csv: path where local csv with metadata will be created\n:param gdocs_trans_csv: path to gdoc csv with translations", "id": "f14830:m8"}
{"signature": "def _get_all_po_filenames(locale_root, lang, po_files_path):", "body": "all_files = os.listdir(os.path.join(locale_root, lang, po_files_path))<EOL>return filter(lambda s: s.endswith('<STR_LIT>'), all_files)<EOL>", "docstring": "Get all po filenames from locale folder and return list of them.\nAssumes a directory structure:\n<locale_root>/<lang>/<po_files_path>/<filename>.", "id": "f14830:m0"}
{"signature": "def _prepare_locale_dirs(languages, locale_root):", "body": "trans_languages = []<EOL>for i, t in enumerate(languages):<EOL><INDENT>lang = t.split('<STR_LIT::>')[<NUM_LIT:0>]<EOL>trans_languages.append(lang)<EOL>lang_path = os.path.join(locale_root, lang)<EOL>if not os.path.exists(lang_path):<EOL><INDENT>os.makedirs(lang_path)<EOL><DEDENT><DEDENT>return trans_languages<EOL>", "docstring": "Prepare locale dirs for writing po files.\nCreate new directories if they doesn't exist.", "id": "f14830:m2"}
{"signature": "def synchronize(self):", "body": "gdocs_trans_csv = os.path.join(self.temp_path, GDOCS_TRANS_CSV)<EOL>gdocs_meta_csv = os.path.join(self.temp_path, GDOCS_META_CSV)<EOL>local_trans_csv = os.path.join(self.temp_path, LOCAL_TRANS_CSV)<EOL>local_meta_csv = os.path.join(self.temp_path, LOCAL_META_CSV)<EOL>try:<EOL><INDENT>entry = self._download_csv_from_gdocs(gdocs_trans_csv,<EOL>gdocs_meta_csv)<EOL><DEDENT>except PODocsError as e:<EOL><INDENT>if '<STR_LIT>' in str(e)or '<STR_LIT>' in str(e):<EOL><INDENT>self.upload()<EOL><DEDENT>else:<EOL><INDENT>raise PODocsError(e)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self._merge_local_and_gdoc(entry, local_trans_csv, local_meta_csv,<EOL>gdocs_trans_csv, gdocs_meta_csv)<EOL>try:<EOL><INDENT>csv_to_po(local_trans_csv, local_meta_csv,<EOL>self.locale_root, self.po_files_path, self.header)<EOL><DEDENT>except IOError as e:<EOL><INDENT>raise PODocsError(e)<EOL><DEDENT><DEDENT>self._clear_temp()<EOL>", "docstring": "Synchronize local po files with translations on GDocs Spreadsheet.\nDownloads two csv files, merges them and converts into po files\nstructure. If new msgids appeared in po files, this method creates\nnew ods with appended content and sends it to GDocs.", "id": "f14833:c1:m8"}
{"signature": "def git_checkout(git_branch=None, locale_root=None):", "body": "if git_branch is None:<EOL><INDENT>git_branch = settings.GIT_BRANCH<EOL><DEDENT>if locale_root is None:<EOL><INDENT>locale_root = settings.LOCALE_ROOT<EOL><DEDENT>proc = Popen('<STR_LIT>' + git_branch + '<STR_LIT>' + locale_root,<EOL>shell=True, stdout=PIPE, stderr=PIPE)<EOL>stdout, stderr = proc.communicate()<EOL>return stdout, stderr<EOL>", "docstring": "Checkouts branch to last commit\n:param git_branch: branch to checkout\n:param locale_root: locale folder path\n:return: tuple stdout, stderr of completed command", "id": "f14833:m1"}
{"signature": "def get_linked_files(self):", "body": "return self.media_descriptors<EOL>", "docstring": "Give all linked files.", "id": "f14843:c0:m43"}
{"signature": "def get_tier_names(self):", "body": "return self.tiers.keys()<EOL>", "docstring": "List all the tier names.\n\n        :returns: List of all tier names", "id": "f14843:c0:m56"}
{"signature": "def generate_ts_id(self, time=None):", "body": "if time and time < <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if not self.maxts:<EOL><INDENT>valid_ts = [int('<STR_LIT>'.join(filter(str.isdigit, a)))<EOL>for a in self.timeslots]<EOL>self.maxts = max(valid_ts + [<NUM_LIT:1>])+<NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>self.maxts += <NUM_LIT:1><EOL><DEDENT>ts = '<STR_LIT>'.format(self.maxts)<EOL>self.timeslots[ts] = time<EOL>return ts<EOL>", "docstring": "Generate the next timeslot id, this function is mainly used\n        internally\n\n        :param int time: Initial time to assign to the timeslot.\n        :raises ValueError: If the time is negative.", "id": "f14843:c0:m23"}
{"signature": "def get_cv_entries(self, cv_id):", "body": "return self.controlled_vocabularies[cv_id][<NUM_LIT:1>]<EOL>", "docstring": "Gives all the controlled vocabulary entries names.\n\n        :param str cv_id: Name of the controlled vocabulary.\n        :throws KeyError: If there is no controlled vocabulary with that id.", "id": "f14843:c0:m34"}
{"signature": "def get_tier_ids_for_linguistic_type(self, ling_type, parent=None):", "body": "return [t for t in self.tiers if<EOL>self.tiers[t][<NUM_LIT:2>]['<STR_LIT>'] == ling_type and<EOL>(parent is None or self.tiers[t][<NUM_LIT:2>]['<STR_LIT>'] == parent)]<EOL>", "docstring": "Give a list of all tiers matching a linguistic type.\n\n        :param str ling_type: Name of the linguistic type.\n        :param str parent: Only match tiers from this parent, when ``None``\n                           this option will be ignored.\n        :returns: List of tiernames.\n        :raises KeyError: If a tier or linguistic type is non existent.", "id": "f14843:c0:m55"}
{"signature": "def remove_license(self, name=None, url=None):", "body": "for k, v in self.licenses[:]:<EOL><INDENT>if (name is None or name == k) and (url is None or url == v):<EOL><INDENT>del(self.licenses[self.licenses.index((k, v))])<EOL><DEDENT><DEDENT>", "docstring": "Remove all licenses matching both key and value.\n\n        :param str name: Name of the license.\n        :param str url: URL of the license.", "id": "f14843:c0:m68"}
{"signature": "def get_licenses(self):", "body": "return self.licenses<EOL>", "docstring": "Gives all the licenses in the format: ``[(name, url)]``", "id": "f14843:c0:m41"}
{"signature": "def remove_linked_files(self, file_path=None, relpath=None, mimetype=None,<EOL>time_origin=None, ex_from=None):", "body": "for attrib in self.media_descriptors[:]:<EOL><INDENT>if file_path is not None and attrib['<STR_LIT>'] != file_path:<EOL><INDENT>continue<EOL><DEDENT>if relpath is not None and attrib['<STR_LIT>'] != relpath:<EOL><INDENT>continue<EOL><DEDENT>if mimetype is not None and attrib['<STR_LIT>'] != mimetype:<EOL><INDENT>continue<EOL><DEDENT>if time_origin is not None andattrib['<STR_LIT>'] != time_origin:<EOL><INDENT>continue<EOL><DEDENT>if ex_from is not None and attrib['<STR_LIT>'] != ex_from:<EOL><INDENT>continue<EOL><DEDENT>del(self.media_descriptors[self.media_descriptors.index(attrib)])<EOL><DEDENT>", "docstring": "Remove all linked files that match all the criteria, criterias that\n        are ``None`` are ignored.\n\n        :param str file_path: Path of the file.\n        :param str relpath: Relative filepath.\n        :param str mimetype: Mimetype of the file.\n        :param int time_origin: Time origin.\n        :param str ex_from: Extracted from.", "id": "f14843:c0:m70"}
{"signature": "def remove_tiers(self, tiers):", "body": "for a in tiers:<EOL><INDENT>self.remove_tier(a, clean=False)<EOL><DEDENT>self.clean_time_slots()<EOL>", "docstring": "Remove multiple tiers, note that this is a lot faster then removing\n        them individually because of the delayed cleaning of timeslots.\n\n        :param list tiers: Names of the tier to remove.\n        :raises KeyError: If a tier is non existent.", "id": "f14843:c0:m76"}
{"signature": "def get_full_time_interval(self):", "body": "return (<NUM_LIT:0>, <NUM_LIT:0>) if not self.timeslots else(min(self.timeslots.values()), max(self.timeslots.values()))<EOL>", "docstring": "Give the full time interval of the file. Note that the real interval\n        can be longer because the sound file attached can be longer.\n\n        :returns: Tuple of the form: ``(min_time, max_time)``.", "id": "f14843:c0:m30"}
{"signature": "def add_lexicon_ref(self, lrid, name, lrtype, url, lexicon_id,<EOL>lexicon_name, datcat_id=None, datcat_name=None):", "body": "self.lexicon_refs[lrid] = {<EOL>'<STR_LIT>': lrid,<EOL>'<STR_LIT>': name,<EOL>'<STR_LIT>': lrtype,<EOL>'<STR_LIT>': url,<EOL>'<STR_LIT>': lexicon_id,<EOL>'<STR_LIT>': lexicon_name,<EOL>'<STR_LIT>': datcat_id,<EOL>'<STR_LIT>': datcat_name<EOL>}<EOL>", "docstring": "Add lexicon reference.\n\n        :param str lrid: Lexicon reference internal ID.\n        :param str name: Lexicon reference display name.\n        :param str lrtype: Lexicon reference service type.\n        :param str url: Lexicon reference service location\n        :param str lexicon_id: Lexicon reference service id.\n        :param str lexicon_name: Lexicon reference service name.\n        :param str datacat_id: Lexicon reference identifier of data category.\n        :param str datacat_name: Lexicon reference name of data category.", "id": "f14843:c0:m7"}
{"signature": "def get_parameters_for_tier(self, id_tier):", "body": "return self.tiers[id_tier][<NUM_LIT:2>]<EOL>", "docstring": "Give the parameter dictionary, this is useable in :func:`add_tier`.\n\n        :param str id_tier: Name of the tier.\n        :returns: Dictionary of parameters.\n        :raises KeyError: If the tier is non existent.", "id": "f14843:c0:m46"}
{"signature": "def __init__(self, file_path=None, author='<STR_LIT>'):", "body": "ctz = -time.altzone if time.localtime(time.time()).tm_isdst andtime.daylight else -time.timezone<EOL>self.maxts = <NUM_LIT:1><EOL>self.maxaid = <NUM_LIT:1><EOL>self.adocument = {<EOL>'<STR_LIT>': author,<EOL>'<STR_LIT>': time.strftime('<STR_LIT>').format(<EOL>ctz // <NUM_LIT>, ctz % <NUM_LIT>),<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>':<EOL>'<STR_LIT>'}<EOL>self.annotations = {}<EOL>self.constraints = {}<EOL>self.controlled_vocabularies = {}<EOL>self.external_refs = {}<EOL>self.header = {}<EOL>self.languages = {}<EOL>self.lexicon_refs = {}<EOL>self.linguistic_types = {}<EOL>self.locales = {}<EOL>self.tiers = {}<EOL>self.timeslots = {}<EOL>self.licenses = []<EOL>self.linked_file_descriptors = []<EOL>self.media_descriptors = []<EOL>self.properties = []<EOL>if file_path is None:<EOL><INDENT>self.add_linguistic_type('<STR_LIT>')<EOL>self.constraints = self.CONSTRAINTS.copy()<EOL>self.properties.append(('<STR_LIT>', <NUM_LIT:0>))<EOL>self.add_tier('<STR_LIT:default>')<EOL><DEDENT>else:<EOL><INDENT>parse_eaf(file_path, self)<EOL><DEDENT>", "docstring": "Construct either a new Eaf file or read on from a file/stream.\n\n        :param str file_path: Path to read from, - for stdin. If ``None`` an\n            empty Eaf file will be created.\n        :param str author: Author of the file.", "id": "f14843:c0:m0"}
{"signature": "def to_textgrid(self, filtin=[], filtex=[], regex=False):", "body": "from pympi.Praat import TextGrid<EOL>_, end = self.get_full_time_interval()<EOL>tgout = TextGrid(xmax=end/<NUM_LIT>)<EOL>func = (lambda x, y: re.match(x, y)) if regex else lambda x, y: x == y<EOL>for tier in self.tiers:<EOL><INDENT>if (filtin and not any(func(f, tier) for f in filtin)) or(filtex and any(func(f, tier) for f in filtex)):<EOL><INDENT>continue<EOL><DEDENT>ctier = tgout.add_tier(tier)<EOL>for intv in self.get_annotation_data_for_tier(tier):<EOL><INDENT>try:<EOL><INDENT>ctier.add_interval(intv[<NUM_LIT:0>]/<NUM_LIT>, intv[<NUM_LIT:1>]/<NUM_LIT>, intv[<NUM_LIT:2>])<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>return tgout<EOL>", "docstring": "Convert the object to a :class:`pympi.Praat.TextGrid` object.\n\n        :param list filtin: Include only tiers in this list, if empty\n            all tiers are included.\n        :param list filtex: Exclude all tiers in this list.\n        :param bool regex: If this flag is set the filters are seen as regexes.\n        :returns: :class:`pympi.Praat.TextGrid` representation.\n        :raises ImportError: If the pympi.Praat module can't be loaded.", "id": "f14843:c0:m80"}
{"signature": "def get_ref_annotation_data_before_time(self, id_tier, time):", "body": "befores = self.get_ref_annotation_data_between_times(id_tier, <NUM_LIT:0>, time)<EOL>if befores:<EOL><INDENT>return [max(befores, key=lambda x: x[<NUM_LIT:0>])]<EOL><DEDENT>else:<EOL><INDENT>return []<EOL><DEDENT>", "docstring": "Give the ref annotation before a time. If an annotation overlaps\n        with ``time`` that annotation will be returned.\n\n        :param str id_tier: Name of the tier.\n        :param int time: Time to get the annotation before.\n        :returns: Annotation before that time in a list\n        :raises KeyError: If the tier is non existent.", "id": "f14843:c0:m50"}
{"signature": "def get_external_ref_names(self):", "body": "return self.external_refs.keys()<EOL>", "docstring": "Gives all the external reference names.", "id": "f14843:c0:m37"}
{"signature": "def insert_annotation(self, id_tier, start, end, value='<STR_LIT>', svg_ref=None):", "body": "return self.add_annotation(id_tier, start, end, value, svg_ref)<EOL>", "docstring": ".. deprecated:: 1.2\n\n        Use :func:`add_annotation` instead.", "id": "f14843:c0:m57"}
{"signature": "def add_external_ref(self, eid, etype, value):", "body": "if etype not in self.ETYPES:<EOL><INDENT>raise KeyError('<STR_LIT>'.format(self.ETYPES))<EOL><DEDENT>self.external_refs[eid] = (etype, value)<EOL>", "docstring": "Add an external reference.\n\n        :param str eid: Name of the external reference.\n        :param str etype: Type of the external reference, has to be in\n            ``['iso12620', 'ecv', 'cve_id', 'lexen_id', 'resource_url']``.\n        :param str value: Value of the external reference.\n        :throws KeyError: if etype is not in the list of possible types.", "id": "f14843:c0:m5"}
{"signature": "def remove_external_ref(self, eid):", "body": "del(self.external_refs[eid])<EOL>", "docstring": "Remove an external reference.\n\n        :param str eid: Name of the external reference.\n        :throws KeyError: If there is no external reference with that id.", "id": "f14843:c0:m65"}
{"signature": "def add_locale(self, language_code, country_code=None, variant=None):", "body": "self.locales[language_code] = (country_code, variant)<EOL>", "docstring": "Add a locale.\n\n        :param str language_code: The language code of the locale.\n        :param str country_code: The country code of the locale.\n        :param str variant: The variant of the locale.", "id": "f14843:c0:m11"}
{"signature": "def remove_lexicon_ref(self, reid):", "body": "del(self.lexicon_refs[reid])<EOL>", "docstring": "Remove a lexicon reference matching the id.\n\n        :param str reid: Lexicon reference id.\n        :throws KeyError: If there is no lexicon reference matching the id.", "id": "f14843:c0:m67"}
{"signature": "def remove_locale(self, language_code):", "body": "del(self.locales[language_code])<EOL>", "docstring": "Remove the locale matching the language code.\n\n        :param str language_code: Language code of the locale.\n        :throws KeyError: If there is no locale matching the language code.", "id": "f14843:c0:m71"}
{"signature": "def copy_tier(self, eaf_obj, tier_name):", "body": "if tier_name in eaf_obj.get_tier_names():<EOL><INDENT>eaf_obj.remove_tier(tier_name)<EOL><DEDENT>eaf_obj.add_tier(tier_name,<EOL>tier_dict=self.get_parameters_for_tier(tier_name))<EOL>for ann in self.get_annotation_data_for_tier(tier_name):<EOL><INDENT>eaf_obj.insert_annotation(tier_name, ann[<NUM_LIT:0>], ann[<NUM_LIT:1>], ann[<NUM_LIT:2>])<EOL><DEDENT>", "docstring": "Copies a tier to another :class:`pympi.Elan.Eaf` object.\n\n        :param pympi.Elan.Eaf eaf_obj: Target Eaf object.\n        :param str tier_name: Name of the tier.\n        :raises KeyError: If the tier doesn't exist.", "id": "f14843:c0:m18"}
{"signature": "def get_gaps_and_overlaps2(self, tier1, tier2, maxlen=-<NUM_LIT:1>):", "body": "ad = sorted(((a, i+<NUM_LIT:1>) for i, t in enumerate([tier1, tier2]) for a in<EOL>self.get_annotation_data_for_tier(t)), reverse=True)<EOL>if ad:<EOL><INDENT>last = (lambda x: (x[<NUM_LIT:0>][<NUM_LIT:0>], x[<NUM_LIT:0>][<NUM_LIT:1>], x[<NUM_LIT:1>]))(ad.pop())<EOL>def thr(x, y):<EOL><INDENT>return maxlen == -<NUM_LIT:1> or abs(x-y) < maxlen<EOL><DEDENT>while ad:<EOL><INDENT>(begin, end, _), current = ad.pop()<EOL>if last[<NUM_LIT:2>] == current and thr(begin, last[<NUM_LIT:1>]):<EOL><INDENT>yield (last[<NUM_LIT:1>], begin, '<STR_LIT>'.format(current))<EOL><DEDENT>elif last[<NUM_LIT:0>] < begin and last[<NUM_LIT:1>] > end:<EOL><INDENT>yield (begin, end, '<STR_LIT>'.format(last[<NUM_LIT:2>], current))<EOL>continue<EOL><DEDENT>elif last[<NUM_LIT:1>] > begin:<EOL><INDENT>yield (begin, last[<NUM_LIT:1>], '<STR_LIT>'.format(last[<NUM_LIT:2>], current))<EOL><DEDENT>elif last[<NUM_LIT:1>] < begin and thr(begin, last[<NUM_LIT:1>]):<EOL><INDENT>yield (last[<NUM_LIT:1>], begin, '<STR_LIT>'.format(last[<NUM_LIT:2>], current))<EOL><DEDENT>last = (begin, end, current)<EOL><DEDENT><DEDENT>", "docstring": "Faster variant of :func:`get_gaps_and_overlaps`. Faster in this case\n        means almost 100 times faster...\n\n        :param str tier1: Name of the first tier.\n        :param str tier2: Name of the second tier.\n        :param int maxlen: Maximum length of gaps (skip longer ones), if ``-1``\n                           no maximum will be used.\n        :yields: Tuples of the form ``[(start, end, type)]``.\n        :raises KeyError: If a tier is non existent.", "id": "f14843:c0:m32"}
{"signature": "def remove_tier(self, name_num):", "body": "if isinstance(name_num, int):<EOL><INDENT>del(self.tiers[name_num-<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>self.tiers = [i for i in self.tiers if i.name != name_num]<EOL><DEDENT>", "docstring": "Remove a tier, when multiple tiers exist with that name only the\n        first is removed.\n\n        :param name_num: Name or number of the tier to remove.\n        :type name_num: int or str\n        :raises IndexError: If there is no tier with that number.", "id": "f14844:c0:m4"}
{"signature": "def add_tier(self, name, tier_type='<STR_LIT>', number=None):", "body": "if number is None:<EOL><INDENT>number = <NUM_LIT:1> if not self.tiers else len(self.tiers)+<NUM_LIT:1><EOL><DEDENT>elif number < <NUM_LIT:1> or number > len(self.tiers):<EOL><INDENT>raise ValueError('<STR_LIT>'.format(len(self.tiers)))<EOL><DEDENT>elif tier_type not in Tier.P_TIERS:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(self.P_TIERS))<EOL><DEDENT>self.tiers.insert(number-<NUM_LIT:1>,<EOL>Tier(self.xmin, self.xmax, name, tier_type))<EOL>return self.tiers[number-<NUM_LIT:1>]<EOL>", "docstring": "Add an IntervalTier or a TextTier on the specified location.\n\n        :param str name: Name of the tier, duplicate names is allowed.\n        :param str tier_type: Type of the tier.\n        :param int number: Place to insert the tier, when ``None`` the number\n            is generated and the tier will be placed on the bottom.\n        :returns: The created tier.\n        :raises ValueError: If the number is out of bounds.", "id": "f14844:c0:m3"}
{"signature": "def get_intervals(self, sort=False):", "body": "for i in sorted(self.intervals) if sort else self.intervals:<EOL><INDENT>yield i<EOL><DEDENT>", "docstring": "Give all the intervals or points.\n\n        :param bool sort: Flag for yielding the intervals or points sorted.\n        :yields: All the intervals", "id": "f14844:c1:m5"}
{"signature": "def __init__(self, file_path=None, xmin=<NUM_LIT:0>, xmax=None, codec='<STR_LIT:utf-8>'):", "body": "self.tiers = []<EOL>self.codec = codec<EOL>if not file_path:<EOL><INDENT>if xmax is None:<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>self.tier_num = <NUM_LIT:0><EOL>self.xmin = xmin<EOL>self.xmax = xmax<EOL><DEDENT>else:<EOL><INDENT>with open(file_path, '<STR_LIT:rb>') as f:<EOL><INDENT>self.from_file(f, codec)<EOL><DEDENT><DEDENT>", "docstring": "Construct either a new TextGrid object or read one from a\n        file/stream. When you create an empty TextGrid you must at least\n        specify the xmax. When you want to load a TextGrid from file you need\n        to specify at least the file_path and optionally the codec. Binary,\n        short and normal TextGrids are supported.\n\n        :param str file_path: Path to read from, - for stdin. If ``None`` an\n                              empty TextGrid will be created.\n        :param int xmin: Xmin value, only needed when not loading from file.\n        :param int xmax: Xmax value, needed when not loading from file.\n        :param str codec: Text encoding for the input. Note that this will be\n            ignored for binary TextGrids.\n        :raises Exception: If filepath is not specified but no xmax", "id": "f14844:c0:m0"}
{"signature": "def sort_tiers(self, key=lambda x: x.name):", "body": "self.tiers.sort(key=key)<EOL>", "docstring": "Sort the tiers given the key. Example key functions:\n\n        Sort according to the tiername in a list:\n\n        ``lambda x: ['name1', 'name2' ... 'namen'].index(x.name)``.\n\n        Sort according to the number of annotations:\n\n        ``lambda x: len(list(x.get_intervals()))``\n\n        :param func key: A key function. Default sorts alphabetically.", "id": "f14844:c0:m2"}
{"signature": "def get_tiers(self):", "body": "for tier in self.tiers:<EOL><INDENT>yield tier<EOL><DEDENT>", "docstring": "Give all tiers.\n\n        :yields: All tiers", "id": "f14844:c0:m7"}
{"signature": "def get_all_intervals(self):", "body": "ints = sorted(self.get_intervals(True))<EOL>if self.tier_type == '<STR_LIT>':<EOL><INDENT>if not ints:<EOL><INDENT>ints.append((self.xmin, self.xmax, '<STR_LIT>'))<EOL><DEDENT>else:<EOL><INDENT>if ints[<NUM_LIT:0>][<NUM_LIT:0>] > self.xmin:<EOL><INDENT>ints.insert(<NUM_LIT:0>, (self.xmin, ints[<NUM_LIT:0>][<NUM_LIT:0>], '<STR_LIT>'))<EOL><DEDENT>if ints[-<NUM_LIT:1>][<NUM_LIT:1>] < self.xmax:<EOL><INDENT>ints.append((ints[-<NUM_LIT:1>][<NUM_LIT:1>], self.xmax, '<STR_LIT>'))<EOL><DEDENT>p = ints[-<NUM_LIT:1>]<EOL>for index, i in reversed(list(enumerate(ints[:-<NUM_LIT:1>], <NUM_LIT:1>))):<EOL><INDENT>if p[<NUM_LIT:0>] - i[<NUM_LIT:1>] != <NUM_LIT:0>:<EOL><INDENT>ints.insert(index, (i[<NUM_LIT:1>], p[<NUM_LIT:0>], '<STR_LIT>'))<EOL><DEDENT>p = i<EOL><DEDENT><DEDENT><DEDENT>return ints<EOL>", "docstring": "Returns the true list of intervals including the empty intervals.", "id": "f14844:c1:m7"}
{"signature": "def get_tier_name_num(self):", "body": "return enumerate((s.name for s in self.tiers), <NUM_LIT:1>)<EOL>", "docstring": "Give all tiers with their numbers.\n\n        :yield: Enumerate of the form ``[(num1, tier1),  ... (numn, tiern)]``", "id": "f14844:c0:m8"}
{"signature": "@register.assignment_tag()<EOL>def sizeof(collection):", "body": "size = len(collection)<EOL>return size<EOL>", "docstring": "Usage:\n{% sizeof mylist as mylistsize %}", "id": "f14851:m0"}
{"signature": "@register.filter<EOL>def roundplus(number):", "body": "num = str(number)<EOL>if not num.isdigit():<EOL><INDENT>return num<EOL><DEDENT>num = str(number)<EOL>digits = len(num)<EOL>rounded = '<STR_LIT>'<EOL>if digits < <NUM_LIT:3>:<EOL><INDENT>rounded = num<EOL><DEDENT>elif digits == <NUM_LIT:3>:<EOL><INDENT>rounded = num[<NUM_LIT:0>] + '<STR_LIT>'<EOL><DEDENT>elif digits == <NUM_LIT:4>:<EOL><INDENT>rounded = num[<NUM_LIT:0>] + '<STR_LIT>'<EOL><DEDENT>elif digits == <NUM_LIT:5>:<EOL><INDENT>rounded = num[:<NUM_LIT:1>] + '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>rounded = '<STR_LIT>'<EOL><DEDENT>return rounded<EOL>", "docstring": "given an number, this fuction rounds the number as the following examples:\n87 -> 87, 100 -> 100+, 188 -> 100+, 999 -> 900+, 1001 -> 1000+, ...etc", "id": "f14852:m0"}
{"signature": "@register.filter()<EOL>def str2tokens(string, delimiter):", "body": "token_list = [token.strip() for token in string.split(delimiter)]<EOL>return token_list<EOL>", "docstring": "Usage:\n{% with 'this, is a, string'|str2tokens:',' as token_list %}do something{% endwith %}", "id": "f14855:m1"}
{"signature": "@register.filter()<EOL>def string2var(string):", "body": "return string<EOL>", "docstring": "{% with user.full_name|truncatechars:16|string2var as truncated_name %}\n    {{ truncated_name|highlight:search_kw }} # need to truncated and then highlight\n{% endwith %}", "id": "f14857:m1"}
{"signature": "def get_days_ago(days=<NUM_LIT:0>):", "body": "return (timezone.now() - datetime.timedelta(days))<EOL>", "docstring": "Return X 'days' ago in datetime format", "id": "f14860:m3"}
{"signature": "def get_unique_key_from_post(post_dict):", "body": "post_dict = remove_csrf_from_params_dict(post_dict)<EOL>return get_unique_key_from_get(post_dict)<EOL>", "docstring": "Build a unique key from post data", "id": "f14860:m9"}
{"signature": "def get_uuid(length=<NUM_LIT:32>, version=<NUM_LIT:1>):", "body": "if version == <NUM_LIT:1>:<EOL><INDENT>return uuid.uuid1().hex[:length]<EOL><DEDENT>else:<EOL><INDENT>return uuid.uuid4().hex[:length]<EOL><DEDENT>", "docstring": "Returns a unique ID of a given length.\nUser `version=2` for cross-systems uniqueness.", "id": "f14860:m0"}
{"signature": "def parts_to_uri(base_uri, uri_parts):", "body": "uri = \"<STR_LIT:/>\".join(map(lambda x: str(x).rstrip('<STR_LIT:/>'), [base_uri] + uri_parts))<EOL>return uri<EOL>", "docstring": "Converts uri parts to valid uri.\nExample: /memebers, ['profile', 'view'] => /memembers/profile/view", "id": "f14861:m3"}
{"signature": "def get_text_query(query_string, search_fields):", "body": "include_terms, exclude_terms = get_text_tokenizer(query_string)<EOL>include_q = get_query_includes(include_terms, search_fields)<EOL>exclude_q = get_query_excludes(exclude_terms, search_fields)<EOL>query = None<EOL>if include_q and exclude_q:<EOL><INDENT>query = include_q & ~exclude_q<EOL><DEDENT>elif not exclude_q:<EOL><INDENT>query = include_q<EOL><DEDENT>else:<EOL><INDENT>query = ~exclude_q<EOL><DEDENT>return query<EOL>", "docstring": "Builds a query for both included & excluded terms in a text search.", "id": "f14864:m5"}
{"signature": "def get_blank_query(field=None):", "body": "if not field:<EOL><INDENT>return field<EOL><DEDENT>blank_q = Q(**{field: '<STR_LIT>'})<EOL>return blank_q<EOL>", "docstring": ".\n    Query for blank field.", "id": "f14864:m9"}
{"signature": "def case_insensitive(self, fields_dict):", "body": "if hasattr(self.model, '<STR_LIT>'):<EOL><INDENT>for field in self.model.CASE_INSENSITIVE_FIELDS:<EOL><INDENT>if field in fields_dict:<EOL><INDENT>fields_dict[field + '<STR_LIT>'] = fields_dict[field]<EOL>del fields_dict[field]<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Converts queries to case insensitive for special fields.", "id": "f14864:c0:m0"}
{"signature": "def get_text_tokenizer(query_string):", "body": "<EOL>split_pattern = re.compile('<STR_LIT>')<EOL>space_cleanup_pattern = re.compile('<STR_LIT>')<EOL>dash_cleanup_pattern = re.compile('<STR_LIT>')<EOL>keywords = [dash_cleanup_pattern.sub('<STR_LIT:->', space_cleanup_pattern.sub('<STR_LIT:U+0020>', t.strip('<STR_LIT>')))<EOL>for t in split_pattern.findall(query_string) if len(t.strip('<STR_LIT>')) > <NUM_LIT:0>]<EOL>include = [word for word in keywords if not word.startswith('<STR_LIT:->')]<EOL>exclude = [word.lstrip('<STR_LIT:->') for word in keywords if word.startswith('<STR_LIT:->')]<EOL>return include, exclude<EOL>", "docstring": "Tokenize the input string and return two lists, exclude list is for words that\nstart with a dash (ex: -word) and include list is for all other words", "id": "f14864:m2"}
{"signature": "def get_not_null_and_not_blank_query(field=None):", "body": "return ~ get_null_or_blank_query(field)<EOL>", "docstring": "Query for not null and not blank fields.", "id": "f14864:m11"}
{"signature": "def get_date_greater_query(days, date_field):", "body": "query = None<EOL>days = get_integer(days)<EOL>if days:<EOL><INDENT>past = get_days_ago(days)<EOL>query = Q(**{\"<STR_LIT>\" % date_field: past.isoformat()})<EOL><DEDENT>return query<EOL>", "docstring": "Query for if date_field is within number of \"days\" ago.", "id": "f14864:m6"}
{"signature": "def get_query_includes(tokenized_terms, search_fields):", "body": "query = None<EOL>for term in tokenized_terms:<EOL><INDENT>or_query = None<EOL>for field_name in search_fields:<EOL><INDENT>q = Q(**{\"<STR_LIT>\" % field_name: term})<EOL>if or_query is None:<EOL><INDENT>or_query = q<EOL><DEDENT>else:<EOL><INDENT>or_query = or_query | q<EOL><DEDENT><DEDENT>if query is None:<EOL><INDENT>query = or_query<EOL><DEDENT>else:<EOL><INDENT>query = query & or_query<EOL><DEDENT><DEDENT>return query<EOL>", "docstring": "Builds a query for included terms in a text search.", "id": "f14864:m3"}
{"signature": "def render_template(content, context):", "body": "rendered = Template(content).render(Context(context))<EOL>return rendered<EOL>", "docstring": "renders context aware template", "id": "f14866:m0"}
{"signature": "def _onDeviceCommand(self, client, userdata, pahoMessage):", "body": "try:<EOL><INDENT>command = Command(pahoMessage, self._messageCodecs)<EOL><DEDENT>except InvalidEventException as e:<EOL><INDENT>self.logger.critical(str(e))<EOL><DEDENT>else:<EOL><INDENT>self.logger.debug(\"<STR_LIT>\" % (command.command))<EOL>if self.deviceCommandCallback:<EOL><INDENT>self.deviceCommandCallback(command)<EOL><DEDENT><DEDENT>", "docstring": "Internal callback for gateway command messages, parses source device from topic string and\npasses the information on to the registered device command callback", "id": "f14897:c0:m7"}
{"signature": "def __init__(self, config, logHandlers=None, deviceInfo=None):", "body": "if config[\"<STR_LIT>\"][\"<STR_LIT>\"] == \"<STR_LIT>\":<EOL><INDENT>raise ConfigurationException(\"<STR_LIT>\")<EOL><DEDENT>self._config = GatewayClientConfig(**config)<EOL>AbstractClient.__init__(<EOL>self,<EOL>domain=self._config.domain,<EOL>organization=self._config.orgId,<EOL>clientId=self._config.clientId,<EOL>username=self._config.username,<EOL>password=self._config.password,<EOL>port=self._config.port,<EOL>transport=self._config.transport,<EOL>cleanStart=self._config.cleanStart,<EOL>sessionExpiry=self._config.sessionExpiry,<EOL>keepAlive=self._config.keepAlive,<EOL>caFile=self._config.caFile,<EOL>logLevel=self._config.logLevel,<EOL>logHandlers=logHandlers,<EOL>)<EOL>self.COMMAND_TOPIC = \"<STR_LIT>\" + self._config.typeId + \"<STR_LIT>\" + self._config.deviceId + \"<STR_LIT>\"<EOL>gatewayCommandTopic = \"<STR_LIT>\" + self._config.typeId + \"<STR_LIT>\" + self._config.deviceId + \"<STR_LIT>\"<EOL>deviceCommandTopic = \"<STR_LIT>\"<EOL>messageNotificationTopic = \"<STR_LIT>\" + self._config.typeId + \"<STR_LIT>\" + self._config.deviceId + \"<STR_LIT>\"<EOL>self.client.message_callback_add(gatewayCommandTopic, self._onCommand)<EOL>self.client.message_callback_add(deviceCommandTopic, self._onDeviceCommand)<EOL>self.client.message_callback_add(messageNotificationTopic, self._onMessageNotification)<EOL>self.deviceCommandCallback = None<EOL>self.notificationCallback = None<EOL>self.readyForDeviceMgmt = threading.Event()<EOL>self.client.message_callback_add(\"<STR_LIT>\", self.__onDeviceMgmtResponse)<EOL>self._deviceMgmtRequestsPendingLock = threading.Lock()<EOL>self._deviceMgmtRequestsPending = {}<EOL>self._deviceMgmtObservationsLock = threading.Lock()<EOL>self._deviceMgmtObservations = []<EOL>self.metadata = {}<EOL>if deviceInfo is not None:<EOL><INDENT>self._deviceInfo = deviceInfo<EOL><DEDENT>else:<EOL><INDENT>self._deviceInfo = DeviceInfo()<EOL><DEDENT>self._location = None<EOL>self._errorCode = None<EOL>self._subscriptions[self.DM_RESPONSE_TOPIC_TEMPLATE % (self._config.typeId, self._config.deviceId)] = <NUM_LIT:1><EOL>self._subscriptions[self.DM_OBSERVE_TOPIC_TEMPLATE % (self._config.typeId, self._config.deviceId)] = <NUM_LIT:1><EOL>self._subscriptions[self.COMMAND_TOPIC] = <NUM_LIT:1><EOL>", "docstring": "Override the constructor", "id": "f14899:c0:m0"}
{"signature": "def _onPublish(self, mqttc, obj, mid):", "body": "with self._messagesLock:<EOL><INDENT>if mid in self._onPublishCallbacks:<EOL><INDENT>midOnPublish = self._onPublishCallbacks.get(mid)<EOL>del self._onPublishCallbacks[mid]<EOL>if midOnPublish != None:<EOL><INDENT>midOnPublish()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self._onPublishCallbacks[mid] = None<EOL><DEDENT><DEDENT>", "docstring": "Called when a message from the client has been successfully sent to IBM Watson IoT Platform.\n\nSee [paho.mqtt.python#on_publish](https://github.com/eclipse/paho.mqtt.python#on_publish) for more information\n\n# Parameters\nmqttc (paho.mqtt.client.Client): The client instance for this callback\nobj (object): The private user data as set in Client() or user_data_set()\nmid (int): Gives the message id of the successfully published message.", "id": "f14908:c0:m9"}
{"signature": "def setMessageCodec(self, messageFormat, codec):", "body": "self._messageCodecs[messageFormat] = codec<EOL>", "docstring": "Set a Python class as the encoder/decoder for a specified message format.\n\n# Arguments\nmessageFormat (string): The message format to retreive the encoder for\ncodec (class): The Python class (subclass of `wiotp.common.MessageCodec` to set as the encoder/decoder for `messageFormat`", "id": "f14908:c0:m2"}
{"signature": "def parseConfigFile(configFilePath):", "body": "try:<EOL><INDENT>with open(configFilePath) as f:<EOL><INDENT>data = yaml.load(f)<EOL><DEDENT><DEDENT>except (OSError, IOError) as e:<EOL><INDENT>reason = \"<STR_LIT>\" % (configFilePath, e)<EOL>raise ConfigurationException(reason)<EOL><DEDENT>if \"<STR_LIT>\" in data and \"<STR_LIT>\" in data[\"<STR_LIT>\"]:<EOL><INDENT>if data[\"<STR_LIT>\"][\"<STR_LIT>\"] not in [\"<STR_LIT:error>\", \"<STR_LIT>\", \"<STR_LIT:info>\", \"<STR_LIT>\"]:<EOL><INDENT>raise ConfigurationException(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>data[\"<STR_LIT>\"][\"<STR_LIT>\"] = logging.getLevelName(data[\"<STR_LIT>\"][\"<STR_LIT>\"].upper())<EOL><DEDENT><DEDENT>return data<EOL>", "docstring": "Parse a yaml configuration file into a Python dictionary suitable for passing to the \ndevice client constructor as the `options` parameter\n\n# Example Configuration File\n\nidentity:\n  appId: myApp\nauth:\n  key: a-23gh56-sdsdajhjnee\n  token: Ab$76s)asj8_s5\noptions:\n  domain: internetofthings.ibmcloud.com\n  logLevel: error|warning|info|debug\n  mqtt:\n    port: 8883\n    transport: tcp\n    cleanStart: false\n    sessionExpiry: 3600\n    keepAlive: 60\n    sharedSubscription: false\n    caFile: /path/to/certificateAuthorityFile.pem\n  http:\n    verify: true", "id": "f14910:m1"}
{"signature": "def subscribeToDeviceStatus(self, typeId=\"<STR_LIT:+>\", deviceId=\"<STR_LIT:+>\"):", "body": "if self._config.isQuickstart() and deviceId == \"<STR_LIT:+>\":<EOL><INDENT>self.logger.warning(\"<STR_LIT>\")<EOL>return <NUM_LIT:0><EOL><DEDENT>topic = \"<STR_LIT>\" % (typeId, deviceId)<EOL>return self._subscribe(topic, <NUM_LIT:0>)<EOL>", "docstring": "Subscribe to device status messages\n\n# Parameters\ntypeId (string): typeId for the subscription, optional.  Defaults to all device types (MQTT `+` wildcard)\ndeviceId (string): deviceId for the subscription, optional.  Defaults to all devices (MQTT `+` wildcard)\n\n# Returns\nint: If the subscription was successful then the return Message ID (mid) for the subscribe request\n    will be returned. The mid value can be used to track the subscribe request by checking against\n    the mid argument if you register a subscriptionCallback method.\n    If the subscription fails then the return value will be `0`", "id": "f14911:c0:m2"}
{"signature": "def get(self, deviceUid, eventId):", "body": "if not isinstance(deviceUid, DeviceUid) and isinstance(deviceUid, dict):<EOL><INDENT>deviceUid = DeviceUid(**deviceUid)<EOL><DEDENT>url = \"<STR_LIT>\" % (deviceUid.typeId, deviceUid.deviceId, eventId)<EOL>r = self._apiClient.get(url)<EOL>if r.status_code == <NUM_LIT:200>:<EOL><INDENT>return LastEvent(**r.json())<EOL><DEDENT>else:<EOL><INDENT>raise ApiException(r)<EOL><DEDENT>", "docstring": "Retrieves the last cached message for specified event from a specific device.", "id": "f14914:c1:m1"}
{"signature": "def __iter__(self, *args, **kwargs):", "body": "<EOL>logsUrl = \"<STR_LIT>\" % (self.typeId, self.deviceId)<EOL>r = self._apiClient.get(logsUrl)<EOL>if r.status_code == <NUM_LIT:200>:<EOL><INDENT>logArray = []<EOL>for logEntry in r.json():<EOL><INDENT>logArray.append(DeviceLog(**logEntry))<EOL><DEDENT>return iter(logArray)<EOL><DEDENT>else:<EOL><INDENT>raise ApiException(r)<EOL><DEDENT>", "docstring": "Iterate through all devices", "id": "f14916:c3:m6"}
{"signature": "def __setitem__(self, key, value):", "body": "raise Exception(\"<STR_LIT>\")<EOL>", "docstring": "Logs are immutable", "id": "f14916:c3:m3"}
{"signature": "def __setitem__(self, key, value):", "body": "raise Exception(\"<STR_LIT>\")<EOL>", "docstring": "Register a new device - not currently supported via this interface, use: `registry.devices.create()`", "id": "f14917:c8:m3"}
{"signature": "def __contains__(self, key):", "body": "if self.typeId is None:<EOL><INDENT>(classIdentifier, orgId, typeId, deviceId) = key.split(\"<STR_LIT::>\")<EOL>deviceUrl = \"<STR_LIT>\" % (typeId, deviceId)<EOL><DEDENT>else:<EOL><INDENT>deviceUrl = \"<STR_LIT>\" % (self.typeId, key)<EOL><DEDENT>r = self._apiClient.get(deviceUrl)<EOL>if r.status_code == <NUM_LIT:200>:<EOL><INDENT>return True<EOL><DEDENT>elif r.status_code == <NUM_LIT>:<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>raise ApiException(r)<EOL><DEDENT>", "docstring": "Does a device exist?", "id": "f14917:c8:m1"}
{"signature": "def __delitem__(self, key):", "body": "if self.typeId is None:<EOL><INDENT>(classIdentifier, orgId, typeId, deviceId) = key.split(\"<STR_LIT::>\")<EOL>deviceUrl = \"<STR_LIT>\" % (typeId, deviceId)<EOL><DEDENT>else:<EOL><INDENT>deviceUrl = \"<STR_LIT>\" % (self.typeId, key)<EOL><DEDENT>r = self._apiClient.delete(deviceUrl)<EOL>if r.status_code == <NUM_LIT>:<EOL><INDENT>self.__missing__(key)<EOL><DEDENT>elif r.status_code != <NUM_LIT>:<EOL><INDENT>raise ApiException(r)<EOL><DEDENT>", "docstring": "Delete a device", "id": "f14917:c8:m4"}
{"signature": "def __iter__(self, *args, **kwargs):", "body": "return IterableDeviceTypeList(self._apiClient)<EOL>", "docstring": "iterate through all devices", "id": "f14918:c2:m6"}
{"signature": "def __getitem__(self, key):", "body": "url = \"<STR_LIT>\" % (key)<EOL>r = self._apiClient.get(url)<EOL>if r.status_code == <NUM_LIT:200>:<EOL><INDENT>return DeviceType(apiClient=self._apiClient, **r.json())<EOL><DEDENT>elif r.status_code == <NUM_LIT>:<EOL><INDENT>self.__missing__(key)<EOL><DEDENT>else:<EOL><INDENT>raise ApiException(r)<EOL><DEDENT>", "docstring": "get a device type from the registry", "id": "f14918:c2:m2"}
{"signature": "def find(self, status=None, connectedAfter=None):", "body": "queryParms = {}<EOL>if status:<EOL><INDENT>queryParms[\"<STR_LIT:status>\"] = status<EOL><DEDENT>if connectedAfter:<EOL><INDENT>queryParms[\"<STR_LIT>\"] = connectedAfter<EOL><DEDENT>return IterableClientStatusList(self._apiClient, filters=queryParms)<EOL>", "docstring": "Iterate through all Connectors", "id": "f14920:c2:m7"}
{"signature": "def get(self, bundleId):", "body": "url = \"<STR_LIT>\" % (bundleId)<EOL>r = self._apiClient.get(url)<EOL>if r.status_code == <NUM_LIT:200>:<EOL><INDENT>return r.json()<EOL><DEDENT>else:<EOL><INDENT>raise ApiException(r)<EOL><DEDENT>", "docstring": "Get a specific device management extension package\nIt accepts bundleId (string) as parameters\nIn case of failure it throws APIException", "id": "f14923:c0:m4"}
{"signature": "def update(self, bundleId, dmeData):", "body": "url = \"<STR_LIT>\" % (bundleId)<EOL>r = self._apiClient.put(url, dmeData)<EOL>if r.status_code == <NUM_LIT:200>:<EOL><INDENT>return r.json()<EOL><DEDENT>else:<EOL><INDENT>raise ApiException(r)<EOL><DEDENT>", "docstring": "Update a device management extension package\nIt accepts bundleId (string) as parameters\nIn case of failure it throws APIException", "id": "f14923:c0:m5"}
{"signature": "def list(self):", "body": "url = \"<STR_LIT>\"<EOL>r = self._apiClient.get(url)<EOL>if r.status_code == <NUM_LIT:200>:<EOL><INDENT>return r.json()<EOL><DEDENT>else:<EOL><INDENT>raise ApiException(r)<EOL><DEDENT>", "docstring": "List all device management extension packages", "id": "f14923:c0:m1"}
{"signature": "def delete(self, requestId):", "body": "url = MgmtRequests.mgmtSingleRequest % (requestId)<EOL>r = self._apiClient.delete(url)<EOL>if r.status_code == <NUM_LIT>:<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>raise ApiException(r)<EOL><DEDENT>", "docstring": "Clears the status of a device management request.\nYou can use this operation to clear the status for a completed request, or for an in-progress request which may never complete due to a problem.\nIt accepts requestId (string) as parameters\nIn case of failure it throws APIException", "id": "f14924:c0:m3"}
{"signature": "def serviceStatus(self):", "body": "r = self._apiClient.get(\"<STR_LIT>\")<EOL>if r.status_code == <NUM_LIT:200>:<EOL><INDENT>return ServiceStatus(**r.json())<EOL><DEDENT>else:<EOL><INDENT>raise ApiException(r)<EOL><DEDENT>", "docstring": "Retrieve the organization-specific status of each of the services offered by the IBM Watson IoT Platform.\nIn case of failure it throws APIException", "id": "f14926:c1:m1"}
{"signature": "def find(self, nameFilter=None, typeFilter=None, bindingModeFilter=None, boundFilter=None):", "body": "queryParms = {}<EOL>if nameFilter:<EOL><INDENT>queryParms[\"<STR_LIT:name>\"] = nameFilter<EOL><DEDENT>if typeFilter:<EOL><INDENT>queryParms[\"<STR_LIT:type>\"] = typeFilter<EOL><DEDENT>if bindingModeFilter:<EOL><INDENT>queryParms[\"<STR_LIT>\"] = bindingModeFilter<EOL><DEDENT>if boundFilter:<EOL><INDENT>queryParms[\"<STR_LIT>\"] = boundFilter<EOL><DEDENT>return IterableServiceBindingsList(self._apiClient, filters=queryParms)<EOL>", "docstring": "Gets the list of services that the Watson IoT Platform can connect to. \nThe list can include a mixture of services that are either bound or unbound.\n\nParameters:\n\n    - nameFilter(string) - Filter the results by the specified name\n    - typeFilter(string) - Filter the results by the specified type, Available values : cloudant, eventstreams\n    - bindingModeFilter(string) - Filter the results by the specified binding mode, Available values : automatic, manual\n    - boundFilter(boolean) - Filter the results by the bound flag \n\nThrows APIException on failure.", "id": "f14928:c5:m7"}
{"signature": "def update(self, serviceId, serviceName, credentials, description):", "body": "url = \"<STR_LIT>\" % (serviceId)<EOL>serviceBody = {}<EOL>serviceBody[\"<STR_LIT:name>\"] = serviceName<EOL>serviceBody[\"<STR_LIT:description>\"] = description<EOL>serviceBody[\"<STR_LIT>\"] = credentials<EOL>r = self._apiClient.put(url, data=serviceBody)<EOL>if r.status_code == <NUM_LIT:200>:<EOL><INDENT>return ServiceBinding(**r.json())<EOL><DEDENT>else:<EOL><INDENT>raise ApiException(r)<EOL><DEDENT>", "docstring": "Updates the service with the specified id.\nif description is empty, the existing description will be removed.\nParameters:\n    - serviceId (String), Service Id which is a UUID\n    - serviceName (string), name of service\n    - credentials (json), json object of credentials\n    - description - description of the service\nThrows APIException on failure.", "id": "f14928:c5:m9"}
{"signature": "def __iter__(self, *args, **kwargs):", "body": "return IterableConnectorList(self._apiClient)<EOL>", "docstring": "Iterate through all Connectors", "id": "f14932:c2:m6"}
{"signature": "def __missing__(self, key):", "body": "raise KeyError(\"<STR_LIT>\" % (key))<EOL>", "docstring": "Device does not exist", "id": "f14932:c2:m5"}
{"signature": "def create(self, name, serviceId, timezone, description, enabled):", "body": "connector = {<EOL>\"<STR_LIT:name>\": name,<EOL>\"<STR_LIT:description>\": description,<EOL>\"<STR_LIT>\": serviceId,<EOL>\"<STR_LIT>\": timezone,<EOL>\"<STR_LIT>\": enabled,<EOL>}<EOL>url = \"<STR_LIT>\"<EOL>r = self._apiClient.post(url, data=connector)<EOL>if r.status_code == <NUM_LIT>:<EOL><INDENT>return Connector(apiClient=self._apiClient, **r.json())<EOL><DEDENT>else:<EOL><INDENT>raise ApiException(r)<EOL><DEDENT>", "docstring": "Create a connector for the organization in the Watson IoT Platform. \nThe connector must reference the target service that the Watson IoT Platform will store the IoT data in.\nParameters:\n    - name (string) - Name of the service\n    - serviceId (string) - must be either eventstreams or cloudant\n    - timezone (string) - \n    - description (string) - description of the service\n    - enabled (boolean) - enabled\nThrows APIException on failure", "id": "f14932:c2:m8"}
{"signature": "def find(self, nameFilter=None, typeFilter=None, enabledFilter=None, serviceId=None):", "body": "queryParms = {}<EOL>if nameFilter:<EOL><INDENT>queryParms[\"<STR_LIT:name>\"] = nameFilter<EOL><DEDENT>if typeFilter:<EOL><INDENT>queryParms[\"<STR_LIT:type>\"] = typeFilter<EOL><DEDENT>if enabledFilter:<EOL><INDENT>queryParms[\"<STR_LIT>\"] = enabledFilter<EOL><DEDENT>if serviceId:<EOL><INDENT>queryParms[\"<STR_LIT>\"] = serviceId<EOL><DEDENT>return IterableConnectorList(self._apiClient, filters=queryParms)<EOL>", "docstring": "Gets the list of Historian connectors, they are used to configure the Watson IoT Platform to store IoT data in compatible services.\n\nParameters:\n\n    - nameFilter(string) -      Filter the results by the specified name\n    - typeFilter(string) -      Filter the results by the specified type, Available values : cloudant, eventstreams\n    - enabledFilter(boolean) -  Filter the results by the enabled flag \n    - serviceId(string) -       Filter the results by the service id\n    - limit(number) -           Max number of results returned, defaults 25\n    - bookmark(string) -        used for paging through results\n\nThrows APIException on failure.", "id": "f14932:c2:m7"}
{"signature": "def prefixed_by(prefix):", "body": "def prefixed_by_(name, value=None):<EOL><INDENT>return name.startswith(prefix)<EOL><DEDENT>prefixed_by_.__name__ += prefix<EOL>return prefixed_by_<EOL>", "docstring": "Make a callable returning True for names starting with the given prefix.\n\nThe returned callable takes two arguments, the attribute or name of\nthe object, and possibly its corresponding value (which is ignored),\nas suitable for use with :meth:`ObjectLocator.is_test_module` and\n:meth:`ObjectLocator.is_test_method`\\ .", "id": "f14963:m0"}
{"signature": "def __init__(self, certificate_type, value, masks=None,<EOL>name='<STR_LIT>'):", "body": "super(DummyCertificate, self).__init__(<EOL>certificate_type, value, masks, name)<EOL>", "docstring": "Create a DummyCertificate.", "id": "f14979:c0:m0"}
{"signature": "def __init__(self, object_type=None):", "body": "super(DummyManagedObject, self).__init__()<EOL>self._object_type = object_type<EOL>", "docstring": "Create a DummyManagedObject\n\nArgs:\n    object_type (any): A value to test the setting of the object_type\n        attribute. Optional, defaults to None.", "id": "f14980:c0:m0"}
{"signature": "def __init__(self):", "body": "super(DummyKey, self).__init__()<EOL>", "docstring": "Create a DummyKey", "id": "f14985:c0:m0"}
{"signature": "def build_certificate(<EOL>common_names,<EOL>include_extension=True,<EOL>bad_extension=False<EOL>):", "body": "names = []<EOL>for common_name in common_names:<EOL><INDENT>names.append(<EOL>x509.NameAttribute(x509.oid.NameOID.COMMON_NAME, common_name)<EOL>)<EOL><DEDENT>name = x509.Name(names)<EOL>t = datetime.datetime.now()<EOL>delta = datetime.timedelta(days=<NUM_LIT:30>)<EOL>not_valid_before = t - delta<EOL>not_valid_after = t + delta<EOL>private_key = rsa.generate_private_key(<EOL>public_exponent=<NUM_LIT>,<EOL>key_size=<NUM_LIT>,<EOL>backend=default_backend()<EOL>)<EOL>builder = x509.CertificateBuilder().serial_number(<EOL><NUM_LIT:1><EOL>).issuer_name(<EOL>name<EOL>).subject_name(<EOL>name<EOL>).not_valid_before(<EOL>not_valid_before<EOL>).not_valid_after(<EOL>not_valid_after<EOL>).public_key(<EOL>private_key.public_key()<EOL>)extended_key_usage_values = []<EOL>if bad_extension:<EOL><INDENT>extended_key_usage_values.append(<EOL>x509.oid.ExtendedKeyUsageOID.SERVER_AUTH<EOL>)<EOL><DEDENT>else:<EOL><INDENT>extended_key_usage_values.append(<EOL>x509.oid.ExtendedKeyUsageOID.CLIENT_AUTH<EOL>)<EOL><DEDENT>if include_extension:<EOL><INDENT>builder = builder.add_extension(<EOL>x509.ExtendedKeyUsage(extended_key_usage_values),<EOL>True<EOL>)<EOL><DEDENT>return builder.sign(private_key, hashes.SHA256(), default_backend())<EOL>", "docstring": "Programmatically generate a self-signed certificate for testing purposes.\n\nArgs:\n    common_names (list): A list of strings for the common names of the\n        cert.\n    include_extension (boolean): A flag enabling/disabling the inclusion\n        of certificate extensions.\n    bad_extension (boolean): A flag enabling/disabling the setting of\n        invalid certificate extension values.\n\nReturns:\n    x509.Certificate: The newly generated certificate object.", "id": "f15050:m0"}
{"signature": "def _check_attribute_value(self, attribute_value, attribute_value_type,<EOL>attribute_value_value):", "body": "expected = attribute_value_type<EOL>observed = type(attribute_value.value)<EOL>self.assertEqual(expected, observed)<EOL>expected = attribute_value_value<EOL>observed = attribute_value.value<EOL>self.assertEqual(expected, observed)<EOL>", "docstring": "Checks the attribute value for a given attribute\n:param attribute_value:\n:param attribute_value_type:\n:param attribute_value_value:", "id": "f15062:c0:m10"}
{"signature": "def _check_uuid(self, uuid, uuid_type):", "body": "<EOL>not_expected = None<EOL>self.assertNotEqual(not_expected, uuid)<EOL>expected = uuid_type<EOL>self.assertEqual(expected, type(uuid))<EOL>", "docstring": "Helper function for checking UUID type and value for errors\n:param uuid: UUID of a created key\n:param uuid_type: UUID type\n:return:", "id": "f15062:c0:m5"}
{"signature": "def _check_result_status(self, result, result_status_type,<EOL>result_status_value):", "body": "result_status = result.result_status.value<EOL>expected = result_status_type<EOL>self.assertIsInstance(result_status, expected)<EOL>expected = result_status_value<EOL>if result_status is ResultStatus.OPERATION_FAILED:<EOL><INDENT>self.logger.error(result)<EOL>self.logger.error(result.result_reason)<EOL>self.logger.error(result.result_message)<EOL><DEDENT>self.assertEqual(expected, result_status)<EOL>", "docstring": "Helper function for checking the status of KMIP appliance actions.\nVerifies the result status type and value.\n:param result: result object\n:param result_status_type: type of result status received\n:param result_status_value: value of the result status", "id": "f15062:c0:m4"}
{"signature": "def process_result_value(self, value, dialect):", "body": "masks = list()<EOL>if value:<EOL><INDENT>for e in enums.CryptographicUsageMask:<EOL><INDENT>if e.value & value:<EOL><INDENT>masks.append(e)<EOL><DEDENT><DEDENT><DEDENT>return masks<EOL>", "docstring": "Returns a new list of enums.CryptographicUsageMask Enums. This converts\nthe integer value into the list of enums.\n\nArgs:\n    value(int): The integer value stored in the database that is used\n        to create the list of enums.CryptographicUsageMask Enums.\n    dialect(string): SQL dialect", "id": "f15065:c0:m1"}
{"signature": "@property<EOL><INDENT>def key_wrapping_data(self):<DEDENT>", "body": "key_wrapping_data = {}<EOL>encryption_key_info = {<EOL>'<STR_LIT>': self._kdw_eki_unique_identifier,<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': self._kdw_eki_cp_block_cipher_mode,<EOL>'<STR_LIT>': self._kdw_eki_cp_padding_method,<EOL>'<STR_LIT>': self._kdw_eki_cp_hashing_algorithm,<EOL>'<STR_LIT>': self._kdw_eki_cp_key_role_type,<EOL>'<STR_LIT>':<EOL>self._kdw_eki_cp_digital_signature_algorithm,<EOL>'<STR_LIT>':<EOL>self._kdw_eki_cp_cryptographic_algorithm,<EOL>'<STR_LIT>': self._kdw_eki_cp_random_iv,<EOL>'<STR_LIT>': self._kdw_eki_cp_iv_length,<EOL>'<STR_LIT>': self._kdw_eki_cp_tag_length,<EOL>'<STR_LIT>': self._kdw_eki_cp_fixed_field_length,<EOL>'<STR_LIT>':<EOL>self._kdw_eki_cp_invocation_field_length,<EOL>'<STR_LIT>': self._kdw_eki_cp_counter_length,<EOL>'<STR_LIT>':<EOL>self._kdw_eki_cp_initial_counter_value<EOL>}<EOL>}<EOL>if not any(encryption_key_info['<STR_LIT>'].values()):<EOL><INDENT>encryption_key_info['<STR_LIT>'] = {}<EOL><DEDENT>if not any(encryption_key_info.values()):<EOL><INDENT>encryption_key_info = {}<EOL><DEDENT>mac_sign_key_info = {<EOL>'<STR_LIT>': self._kdw_mski_unique_identifier,<EOL>'<STR_LIT>': {<EOL>'<STR_LIT>': self._kdw_mski_cp_block_cipher_mode,<EOL>'<STR_LIT>': self._kdw_mski_cp_padding_method,<EOL>'<STR_LIT>': self._kdw_mski_cp_hashing_algorithm,<EOL>'<STR_LIT>': self._kdw_mski_cp_key_role_type,<EOL>'<STR_LIT>':<EOL>self._kdw_mski_cp_digital_signature_algorithm,<EOL>'<STR_LIT>':<EOL>self._kdw_mski_cp_cryptographic_algorithm,<EOL>'<STR_LIT>': self._kdw_mski_cp_random_iv,<EOL>'<STR_LIT>': self._kdw_mski_cp_iv_length,<EOL>'<STR_LIT>': self._kdw_mski_cp_tag_length,<EOL>'<STR_LIT>': self._kdw_mski_cp_fixed_field_length,<EOL>'<STR_LIT>':<EOL>self._kdw_mski_cp_invocation_field_length,<EOL>'<STR_LIT>': self._kdw_mski_cp_counter_length,<EOL>'<STR_LIT>':<EOL>self._kdw_mski_cp_initial_counter_value<EOL>}<EOL>}<EOL>if not any(mac_sign_key_info['<STR_LIT>'].values()):<EOL><INDENT>mac_sign_key_info['<STR_LIT>'] = {}<EOL><DEDENT>if not any(mac_sign_key_info.values()):<EOL><INDENT>mac_sign_key_info = {}<EOL><DEDENT>key_wrapping_data['<STR_LIT>'] = self._kdw_wrapping_method<EOL>key_wrapping_data['<STR_LIT>'] = encryption_key_info<EOL>key_wrapping_data['<STR_LIT>'] = mac_sign_key_info<EOL>key_wrapping_data['<STR_LIT>'] = self._kdw_mac_signature<EOL>key_wrapping_data['<STR_LIT>'] = self._kdw_iv_counter_nonce<EOL>key_wrapping_data['<STR_LIT>'] = self._kdw_encoding_option<EOL>if not any(key_wrapping_data.values()):<EOL><INDENT>key_wrapping_data = {}<EOL><DEDENT>return key_wrapping_data<EOL>", "docstring": "Retrieve all of the relevant key wrapping data fields and return them\nas a dictionary.", "id": "f15066:c2:m1"}
{"signature": "@abstractmethod<EOL><INDENT>def __init__(self):<DEDENT>", "body": "super(CryptographicObject, self).__init__()<EOL>self.cryptographic_usage_masks = list()<EOL>self.state = enums.State.PRE_ACTIVE<EOL>self._digests = list()<EOL>self._activation_date = None<EOL>self._compromise_date = None<EOL>self._compromise_occurrence_date = None<EOL>self._deactivation_date = None<EOL>self._destroy_date = None<EOL>self._fresh = None<EOL>self._lease_time = None<EOL>self._links = list()<EOL>self._revocation_reason = None<EOL>", "docstring": "Create a CryptographicObject.", "id": "f15066:c1:m0"}
{"signature": "def validate(self):", "body": "if not isinstance(self.value, bytes):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>elif not isinstance(self.cryptographic_algorithm,<EOL>enums.CryptographicAlgorithm):<EOL><INDENT>raise TypeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>elif not isinstance(self.cryptographic_length, six.integer_types):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>elif not isinstance(self.key_format_type, enums.KeyFormatType):<EOL><INDENT>raise TypeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>elif self.key_format_type not in self._valid_formats:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(<EOL>self._valid_formats))<EOL><DEDENT>mask_count = len(self.cryptographic_usage_masks)<EOL>for i in range(mask_count):<EOL><INDENT>mask = self.cryptographic_usage_masks[i]<EOL>if not isinstance(mask, enums.CryptographicUsageMask):<EOL><INDENT>position = \"<STR_LIT>\".format(i)<EOL>raise TypeError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(position))<EOL><DEDENT><DEDENT>name_count = len(self.names)<EOL>for i in range(name_count):<EOL><INDENT>name = self.names[i]<EOL>if not isinstance(name, six.string_types):<EOL><INDENT>position = \"<STR_LIT>\".format(i)<EOL>raise TypeError(\"<STR_LIT>\".format(<EOL>position))<EOL><DEDENT><DEDENT>", "docstring": "Verify that the contents of the PublicKey object are valid.\n\nRaises:\n    TypeError: if the types of any PublicKey attributes are invalid.", "id": "f15066:c4:m1"}
{"signature": "def __init__(self, value, data_type, masks=None, name='<STR_LIT>'):", "body": "super(SecretData, self).__init__()<EOL>self._object_type = enums.ObjectType.SECRET_DATA<EOL>self.value = value<EOL>self.data_type = data_type<EOL>self.names = [name]<EOL>if masks:<EOL><INDENT>self.cryptographic_usage_masks = masks<EOL><DEDENT>self.validate()<EOL>", "docstring": "Create a SecretData object.\n\nArgs:\n    value(bytes): The bytes representing secret data.\n    data_type(SecretDataType): An enumeration defining the type of the\n        secret value.\n    masks(list): A list of CryptographicUsageMask enumerations\n        defining how the key will be used.\n    name(string): The string name of the key.", "id": "f15066:c8:m0"}
{"signature": "@is_connected<EOL><INDENT>def locate(self, maximum_items=None, storage_status_mask=None,<EOL>object_group_member=None, attributes=None):<DEDENT>", "body": "<EOL>if maximum_items is not None:<EOL><INDENT>if not isinstance(maximum_items, six.integer_types):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if storage_status_mask is not None:<EOL><INDENT>if not isinstance(storage_status_mask, six.integer_types):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if object_group_member is not None:<EOL><INDENT>if not isinstance(object_group_member, enums.ObjectGroupMember):<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if attributes is not None:<EOL><INDENT>if not isinstance(attributes, list) orall(isinstance(item, cobjects.Attribute)<EOL>for item in attributes) is False:<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT>result = self.proxy.locate(<EOL>maximum_items, storage_status_mask,<EOL>object_group_member, attributes)<EOL>status = result.result_status.value<EOL>if status == enums.ResultStatus.SUCCESS:<EOL><INDENT>return result.uuids<EOL><DEDENT>else:<EOL><INDENT>reason = result.result_reason.value<EOL>message = result.result_message.value<EOL>raise exceptions.KmipOperationFailure(status, reason, message)<EOL><DEDENT>", "docstring": "Search for managed objects, depending on the attributes specified in\nthe request.\n\nArgs:\n    maximum_items (integer): Maximum number of object identifiers the\n        server MAY return.\n    storage_status_mask (integer): A bit mask that indicates whether\n        on-line or archived objects are to be searched.\n    object_group_member (ObjectGroupMember): An enumeration that\n        indicates the object group member type.\n    attributes (list): Attributes the are REQUIRED to match those in a\n        candidate object.\n\nReturns:\n    list: The Unique Identifiers of the located objects\n\nRaises:\n    ClientConnectionNotOpen: if the client connection is unusable\n    KmipOperationFailure: if the operation result is a failure\n    TypeError: if the input arguments are invalid", "id": "f15067:c0:m10"}
{"signature": "@is_connected<EOL><INDENT>def destroy(self, uid=None):<DEDENT>", "body": "<EOL>if uid is not None:<EOL><INDENT>if not isinstance(uid, six.string_types):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>result = self.proxy.destroy(uid)<EOL>status = result.result_status.value<EOL>if status == enums.ResultStatus.SUCCESS:<EOL><INDENT>return<EOL><DEDENT>else:<EOL><INDENT>reason = result.result_reason.value<EOL>message = result.result_message.value<EOL>raise exceptions.KmipOperationFailure(status, reason, message)<EOL><DEDENT>", "docstring": "Destroy a managed object stored by a KMIP appliance.\n\nArgs:\n    uid (string): The unique ID of the managed object to destroy.\n\nReturns:\n    None\n\nRaises:\n    ClientConnectionNotOpen: if the client connection is unusable\n    KmipOperationFailure: if the operation result is a failure\n    TypeError: if the input argument is invalid", "id": "f15067:c0:m17"}
{"signature": "@is_connected<EOL><INDENT>def derive_key(self,<EOL>object_type,<EOL>unique_identifiers,<EOL>derivation_method,<EOL>derivation_parameters,<EOL>**kwargs):<DEDENT>", "body": "<EOL>if not isinstance(object_type, enums.ObjectType):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if not isinstance(unique_identifiers, list):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>for unique_identifier in unique_identifiers:<EOL><INDENT>if not isinstance(unique_identifier, six.string_types):<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT><DEDENT><DEDENT>if not isinstance(derivation_method, enums.DerivationMethod):<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if not isinstance(derivation_parameters, dict):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>derivation_parameters = DerivationParameters(<EOL>cryptographic_parameters=self._build_cryptographic_parameters(<EOL>derivation_parameters.get('<STR_LIT>')<EOL>),<EOL>initialization_vector=derivation_parameters.get(<EOL>'<STR_LIT>'<EOL>),<EOL>derivation_data=derivation_parameters.get('<STR_LIT>'),<EOL>salt=derivation_parameters.get('<STR_LIT>'),<EOL>iteration_count=derivation_parameters.get('<STR_LIT>')<EOL>)<EOL>attributes = []<EOL>if kwargs.get('<STR_LIT>'):<EOL><INDENT>attributes.append(<EOL>self.attribute_factory.create_attribute(<EOL>enums.AttributeType.CRYPTOGRAPHIC_LENGTH,<EOL>kwargs.get('<STR_LIT>')<EOL>)<EOL>)<EOL><DEDENT>if kwargs.get('<STR_LIT>'):<EOL><INDENT>attributes.append(<EOL>self.attribute_factory.create_attribute(<EOL>enums.AttributeType.CRYPTOGRAPHIC_ALGORITHM,<EOL>kwargs.get('<STR_LIT>')<EOL>)<EOL>)<EOL><DEDENT>if kwargs.get('<STR_LIT>'):<EOL><INDENT>attributes.append(<EOL>self.attribute_factory.create_attribute(<EOL>enums.AttributeType.CRYPTOGRAPHIC_USAGE_MASK,<EOL>kwargs.get('<STR_LIT>')<EOL>)<EOL>)<EOL><DEDENT>template_attribute = cobjects.TemplateAttribute(<EOL>attributes=attributes<EOL>)<EOL>result = self.proxy.derive_key(<EOL>object_type,<EOL>unique_identifiers,<EOL>derivation_method,<EOL>derivation_parameters,<EOL>template_attribute<EOL>)<EOL>status = result.get('<STR_LIT>')<EOL>if status == enums.ResultStatus.SUCCESS:<EOL><INDENT>return result.get('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>raise exceptions.KmipOperationFailure(<EOL>status,<EOL>result.get('<STR_LIT>'),<EOL>result.get('<STR_LIT>')<EOL>)<EOL><DEDENT>", "docstring": "Derive a new key or secret data from existing managed objects.\n\nArgs:\n    object_type (ObjectType): An ObjectType enumeration specifying\n        what type of object to derive. Only SymmetricKeys and\n        SecretData can be specified. Required.\n    unique_identifiers (list): A list of strings specifying the\n        unique IDs of the existing managed objects to use for\n        derivation. Multiple objects can be specified to fit the\n        requirements of the given derivation method. Required.\n    derivation_method (DerivationMethod): A DerivationMethod\n        enumeration specifying how key derivation should be done.\n        Required.\n    derivation_parameters (dict): A dictionary containing various\n        settings for the key derivation process. See Note below.\n        Required.\n    **kwargs (various): A placeholder for object attributes that\n        should be set on the newly derived object. Currently\n        supported attributes include:\n            cryptographic_algorithm (enums.CryptographicAlgorithm)\n            cryptographic_length (int)\n\nReturns:\n    string: The unique ID of the newly derived object.\n\nRaises:\n    ClientConnectionNotOpen: if the client connection is unusable\n    KmipOperationFailure: if the operation result is a failure\n    TypeError: if the input arguments are invalid\n\nNotes:\n    The derivation_parameters argument is a dictionary that can\n    contain the following key/value pairs:\n\n    Key                        | Value\n    ---------------------------|---------------------------------------\n    'cryptographic_parameters' | A dictionary containing additional\n                               | cryptographic settings. See the\n                               | decrypt method for more information.\n    'initialization_vector'    | Bytes to be used to initialize the key\n                               | derivation function, if needed.\n    'derivation_data'          | Bytes to be used as the basis for the\n                               | key derivation process (e.g., the\n                               | bytes to be encrypted, hashed, etc).\n    'salt'                     | Bytes to used as a salt value for the\n                               | key derivation function, if needed.\n                               | Usually used with PBKDF2.\n    'iteration_count'          | An integer defining how many\n                               | iterations should be used with the key\n                               | derivation function, if needed.\n                               | Usually used with PBKDF2.", "id": "f15067:c0:m9"}
{"signature": "def _build_cryptographic_parameters(self, value):", "body": "if value is None:<EOL><INDENT>return None<EOL><DEDENT>elif not isinstance(value, dict):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>cryptographic_parameters = CryptographicParameters(<EOL>block_cipher_mode=value.get('<STR_LIT>'),<EOL>padding_method=value.get('<STR_LIT>'),<EOL>hashing_algorithm=value.get('<STR_LIT>'),<EOL>key_role_type=value.get('<STR_LIT>'),<EOL>digital_signature_algorithm=value.get(<EOL>'<STR_LIT>'<EOL>),<EOL>cryptographic_algorithm=value.get('<STR_LIT>'),<EOL>random_iv=value.get('<STR_LIT>'),<EOL>iv_length=value.get('<STR_LIT>'),<EOL>tag_length=value.get('<STR_LIT>'),<EOL>fixed_field_length=value.get('<STR_LIT>'),<EOL>invocation_field_length=value.get('<STR_LIT>'),<EOL>counter_length=value.get('<STR_LIT>'),<EOL>initial_counter_value=value.get('<STR_LIT>')<EOL>)<EOL>return cryptographic_parameters<EOL>", "docstring": "Build a CryptographicParameters struct from a dictionary.\n\nArgs:\n    value (dict): A dictionary containing the key/value pairs for a\n        CryptographicParameters struct.\n\nReturns:\n    None: if value is None\n    CryptographicParameters: a CryptographicParameters struct\n\nRaises:\n    TypeError: if the input argument is invalid", "id": "f15067:c0:m24"}
{"signature": "@is_connected<EOL><INDENT>def create_key_pair(self,<EOL>algorithm,<EOL>length,<EOL>operation_policy_name=None,<EOL>public_name=None,<EOL>public_usage_mask=None,<EOL>private_name=None,<EOL>private_usage_mask=None):<DEDENT>", "body": "<EOL>if not isinstance(algorithm, enums.CryptographicAlgorithm):<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>elif not isinstance(length, six.integer_types) or length <= <NUM_LIT:0>:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>common_attributes = self._build_common_attributes(<EOL>operation_policy_name<EOL>)<EOL>algorithm_attribute = self.attribute_factory.create_attribute(<EOL>enums.AttributeType.CRYPTOGRAPHIC_ALGORITHM,<EOL>algorithm<EOL>)<EOL>length_attribute = self.attribute_factory.create_attribute(<EOL>enums.AttributeType.CRYPTOGRAPHIC_LENGTH,<EOL>length<EOL>)<EOL>common_attributes.extend([algorithm_attribute, length_attribute])<EOL>template = cobjects.TemplateAttribute(<EOL>attributes=common_attributes,<EOL>tag=enums.Tags.COMMON_TEMPLATE_ATTRIBUTE<EOL>)<EOL>public_template = None<EOL>names = None<EOL>if public_name:<EOL><INDENT>names = self._build_name_attribute(name=public_name)<EOL><DEDENT>attrs = []<EOL>if public_usage_mask:<EOL><INDENT>attrs = [<EOL>self.attribute_factory.create_attribute(<EOL>enums.AttributeType.CRYPTOGRAPHIC_USAGE_MASK,<EOL>public_usage_mask<EOL>)<EOL>]<EOL><DEDENT>if names or attrs:<EOL><INDENT>public_template = cobjects.TemplateAttribute(<EOL>names=names,<EOL>attributes=attrs,<EOL>tag=enums.Tags.PUBLIC_KEY_TEMPLATE_ATTRIBUTE<EOL>)<EOL><DEDENT>private_template = None<EOL>names = None<EOL>if private_name:<EOL><INDENT>names = self._build_name_attribute(name=private_name)<EOL><DEDENT>attrs = []<EOL>if private_usage_mask:<EOL><INDENT>attrs = [<EOL>self.attribute_factory.create_attribute(<EOL>enums.AttributeType.CRYPTOGRAPHIC_USAGE_MASK,<EOL>private_usage_mask<EOL>)<EOL>]<EOL><DEDENT>if names or attrs:<EOL><INDENT>private_template = cobjects.TemplateAttribute(<EOL>names=names,<EOL>attributes=attrs,<EOL>tag=enums.Tags.PRIVATE_KEY_TEMPLATE_ATTRIBUTE<EOL>)<EOL><DEDENT>result = self.proxy.create_key_pair(<EOL>common_template_attribute=template,<EOL>private_key_template_attribute=private_template,<EOL>public_key_template_attribute=public_template)<EOL>status = result.result_status.value<EOL>if status == enums.ResultStatus.SUCCESS:<EOL><INDENT>public_uid = result.public_key_uuid<EOL>private_uid = result.private_key_uuid<EOL>return public_uid, private_uid<EOL><DEDENT>else:<EOL><INDENT>reason = result.result_reason.value<EOL>message = result.result_message.value<EOL>raise exceptions.KmipOperationFailure(status, reason, message)<EOL><DEDENT>", "docstring": "Create an asymmetric key pair on a KMIP appliance.\n\nArgs:\n    algorithm (CryptographicAlgorithm): An enumeration defining the\n        algorithm to use to generate the key pair.\n    length (int): The length in bits for the key pair.\n    operation_policy_name (string): The name of the operation policy\n        to use for the new key pair. Optional, defaults to None.\n    public_name (string): The name to give the public key. Optional,\n        defaults to None.\n    public_usage_mask (list): A list of CryptographicUsageMask\n        enumerations indicating how the public key should be used.\n        Optional, defaults to None.\n    private_name (string): The name to give the public key. Optional,\n        defaults to None.\n    private_usage_mask (list): A list of CryptographicUsageMask\n        enumerations indicating how the private key should be used.\n        Optional, defaults to None.\n\nReturns:\n    string: The uid of the newly created public key.\n    string: The uid of the newly created private key.\n\nRaises:\n    ClientConnectionNotOpen: if the client connection is unusable\n    KmipOperationFailure: if the operation result is a failure\n    TypeError: if the input arguments are invalid", "id": "f15067:c0:m6"}
{"signature": "def _build_common_attributes(self, operation_policy_name=None):", "body": "common_attributes = []<EOL>if operation_policy_name:<EOL><INDENT>common_attributes.append(<EOL>self.attribute_factory.create_attribute(<EOL>enums.AttributeType.OPERATION_POLICY_NAME,<EOL>operation_policy_name<EOL>)<EOL>)<EOL><DEDENT>return common_attributes<EOL>", "docstring": "Build a list of common attributes that are shared across\nsymmetric as well as asymmetric objects", "id": "f15067:c0:m28"}
{"signature": "def _build_key_wrapping_specification(self, value):", "body": "if value is None:<EOL><INDENT>return None<EOL><DEDENT>if not isinstance(value, dict):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>encryption_key_info = self._build_encryption_key_information(<EOL>value.get('<STR_LIT>')<EOL>)<EOL>mac_signature_key_info = self._build_mac_signature_key_information(<EOL>value.get('<STR_LIT>')<EOL>)<EOL>key_wrapping_specification = cobjects.KeyWrappingSpecification(<EOL>wrapping_method=value.get('<STR_LIT>'),<EOL>encryption_key_information=encryption_key_info,<EOL>mac_signature_key_information=mac_signature_key_info,<EOL>attribute_names=value.get('<STR_LIT>'),<EOL>encoding_option=value.get('<STR_LIT>')<EOL>)<EOL>return key_wrapping_specification<EOL>", "docstring": "Build a KeyWrappingSpecification struct from a dictionary.\n\nArgs:\n    value (dict): A dictionary containing the key/value pairs for a\n        KeyWrappingSpecification struct.\n\nReturns:\n    KeyWrappingSpecification: a KeyWrappingSpecification struct\n\nRaises:\n    TypeError: if the input argument is invalid", "id": "f15067:c0:m27"}
{"signature": "@is_connected<EOL><INDENT>def encrypt(self, data, uid=None, cryptographic_parameters=None,<EOL>iv_counter_nonce=None):<DEDENT>", "body": "<EOL>if not isinstance(data, six.binary_type):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if uid is not None:<EOL><INDENT>if not isinstance(uid, six.string_types):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if cryptographic_parameters is not None:<EOL><INDENT>if not isinstance(cryptographic_parameters, dict):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if iv_counter_nonce is not None:<EOL><INDENT>if not isinstance(iv_counter_nonce, six.binary_type):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>cryptographic_parameters = self._build_cryptographic_parameters(<EOL>cryptographic_parameters<EOL>)<EOL>result = self.proxy.encrypt(<EOL>data,<EOL>uid,<EOL>cryptographic_parameters,<EOL>iv_counter_nonce<EOL>)<EOL>status = result.get('<STR_LIT>')<EOL>if status == enums.ResultStatus.SUCCESS:<EOL><INDENT>return result.get('<STR_LIT:data>'), result.get('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>raise exceptions.KmipOperationFailure(<EOL>status,<EOL>result.get('<STR_LIT>'),<EOL>result.get('<STR_LIT>')<EOL>)<EOL><DEDENT>", "docstring": "Encrypt data using the specified encryption key and parameters.\n\nArgs:\n    data (bytes): The bytes to encrypt. Required.\n    uid (string): The unique ID of the encryption key to use.\n        Optional, defaults to None.\n    cryptographic_parameters (dict): A dictionary containing various\n        cryptographic settings to be used for the encryption.\n        Optional, defaults to None.\n    iv_counter_nonce (bytes): The bytes to use for the IV/counter/\n        nonce, if needed by the encryption algorithm and/or cipher\n        mode. Optional, defaults to None.\n\nReturns:\n    bytes: The encrypted data.\n    bytes: The IV/counter/nonce used with the encryption algorithm,\n        only if it was autogenerated by the server.\n\nRaises:\n    ClientConnectionNotOpen: if the client connection is unusable\n    KmipOperationFailure: if the operation result is a failure\n    TypeError: if the input arguments are invalid\n\nNotes:\n    The cryptographic_parameters argument is a dictionary that can\n    contain the following key/value pairs:\n\n    Keys                          | Value\n    ------------------------------|-----------------------------------\n    'block_cipher_mode'           | A BlockCipherMode enumeration\n                                  | indicating the cipher mode to use\n                                  | with the encryption algorithm.\n    'padding_method'              | A PaddingMethod enumeration\n                                  | indicating which padding method to\n                                  | use with the encryption algorithm.\n    'hashing_algorithm'           | A HashingAlgorithm enumeration\n                                  | indicating which hashing algorithm\n                                  | to use.\n    'key_role_type'               | A KeyRoleType enumeration\n                                  | indicating the intended use of the\n                                  | associated cryptographic key.\n    'digital_signature_algorithm' | A DigitalSignatureAlgorithm\n                                  | enumeration indicating which\n                                  | digital signature algorithm to\n                                  | use.\n    'cryptographic_algorithm'     | A CryptographicAlgorithm\n                                  | enumeration indicating which\n                                  | encryption algorithm to use.\n    'random_iv'                   | A boolean indicating whether the\n                                  | server should autogenerate an IV.\n    'iv_length'                   | An integer representing the length\n                                  | of the initialization vector (IV)\n                                  | in bits.\n    'tag_length'                  | An integer representing the length\n                                  | of the authenticator tag in bytes.\n    'fixed_field_length'          | An integer representing the length\n                                  | of the fixed field portion of the\n                                  | IV in bits.\n    'invocation_field_length'     | An integer representing the length\n                                  | of the invocation field portion of\n                                  | the IV in bits.\n    'counter_length'              | An integer representing the length\n                                  | of the coutner portion of the IV\n                                  | in bits.\n    'initial_counter_value'       | An integer representing the\n                                  | starting counter value for CTR\n                                  | mode (typically 1).", "id": "f15067:c0:m18"}
{"signature": "@is_connected<EOL><INDENT>def check(self,<EOL>uid=None,<EOL>usage_limits_count=None,<EOL>cryptographic_usage_mask=None,<EOL>lease_time=None):<DEDENT>", "body": "if uid is not None:<EOL><INDENT>if not isinstance(uid, six.string_types):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if usage_limits_count is not None:<EOL><INDENT>if not isinstance(usage_limits_count, six.integer_types):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if cryptographic_usage_mask is not None:<EOL><INDENT>if not isinstance(cryptographic_usage_mask, list) ornot all(isinstance(<EOL>x,<EOL>enums.CryptographicUsageMask<EOL>) for x in cryptographic_usage_mask):<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT><DEDENT>if lease_time is not None:<EOL><INDENT>if not isinstance(lease_time, six.integer_types):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>result = self.proxy.check(<EOL>uid,<EOL>usage_limits_count,<EOL>cryptographic_usage_mask,<EOL>lease_time<EOL>)<EOL>status = result.get('<STR_LIT>')<EOL>if status == enums.ResultStatus.SUCCESS:<EOL><INDENT>return result.get('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>raise exceptions.KmipOperationFailure(<EOL>status,<EOL>result.get('<STR_LIT>'),<EOL>result.get('<STR_LIT>')<EOL>)<EOL><DEDENT>", "docstring": "Check the constraints for a managed object.\n\nArgs:\n    uid (string): The unique ID of the managed object to check.\n        Optional, defaults to None.\n    usage_limits_count (int): The number of items that can be secured\n        with the specified managed object. Optional, defaults to None.\n    cryptographic_usage_mask (list): A list of CryptographicUsageMask\n        enumerations specifying the operations possible with the\n        specified managed object. Optional, defaults to None.\n    lease_time (int): The number of seconds that can be leased for the\n        specified managed object. Optional, defaults to None.", "id": "f15067:c0:m11"}
{"signature": "def __init__(self):", "body": "super(ClientConnectionNotOpen, self).__init__(<EOL>\"<STR_LIT>\")<EOL>", "docstring": "Construct the closed client connection error message.", "id": "f15069:c1:m0"}
{"signature": "def __init__(self, value=None):", "body": "super(QueryFunction, self).__init__(<EOL>QueryFunctionEnum, value, Tags.QUERY_FUNCTION)<EOL>", "docstring": "Construct a QueryFunction object.\n\nArgs:\n    value (QueryFunction enum): A QueryFunction enumeration value,\n        (e.g., QueryFunction.QUERY_OPERATIONS). Optional, default to\n        None.", "id": "f15071:c2:m0"}
{"signature": "def __init__(self, value=b'<STR_LIT>'):", "body": "super(CertificateValue, self).__init__(value, Tags.CERTIFICATE_VALUE)<EOL>", "docstring": "Construct a CertificateValue byte string.\n\nArgs:\n    value (bytes): A byte string (e.g., b'\\x00\\x01...') containing the\n        certificate bytes to store. Optional, defaults to the empty\n        byte string.", "id": "f15071:c0:m0"}
{"signature": "def read(self, input_stream, kmip_version=enums.KMIPVersion.KMIP_1_0):", "body": "super(DeviceCredential, self).read(<EOL>input_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL>local_stream = BytearrayStream(input_stream.read(self.length))<EOL>if self.is_tag_next(enums.Tags.DEVICE_SERIAL_NUMBER, local_stream):<EOL><INDENT>self._device_serial_number = primitives.TextString(<EOL>tag=enums.Tags.DEVICE_SERIAL_NUMBER<EOL>)<EOL>self._device_serial_number.read(<EOL>local_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>if self.is_tag_next(enums.Tags.PASSWORD, local_stream):<EOL><INDENT>self._password = primitives.TextString(<EOL>tag=enums.Tags.PASSWORD<EOL>)<EOL>self._password.read(local_stream, kmip_version=kmip_version)<EOL><DEDENT>if self.is_tag_next(enums.Tags.DEVICE_IDENTIFIER, local_stream):<EOL><INDENT>self._device_identifier = primitives.TextString(<EOL>tag=enums.Tags.DEVICE_IDENTIFIER<EOL>)<EOL>self._device_identifier.read(<EOL>local_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>if self.is_tag_next(enums.Tags.NETWORK_IDENTIFIER, local_stream):<EOL><INDENT>self._network_identifier = primitives.TextString(<EOL>tag=enums.Tags.NETWORK_IDENTIFIER<EOL>)<EOL>self._network_identifier.read(<EOL>local_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>if self.is_tag_next(enums.Tags.MACHINE_IDENTIFIER, local_stream):<EOL><INDENT>self._machine_identifier = primitives.TextString(<EOL>tag=enums.Tags.MACHINE_IDENTIFIER<EOL>)<EOL>self._machine_identifier.read(<EOL>local_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>if self.is_tag_next(enums.Tags.MEDIA_IDENTIFIER, local_stream):<EOL><INDENT>self._media_identifier = primitives.TextString(<EOL>tag=enums.Tags.MEDIA_IDENTIFIER<EOL>)<EOL>self._media_identifier.read(<EOL>local_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>self.is_oversized(local_stream)<EOL>", "docstring": "Read the data encoding the DeviceCredential struct and decode it into\nits constituent parts.\n\nArgs:\n    input_stream (stream): A data stream containing encoded object\n        data, supporting a read method; usually a BytearrayStream\n        object.\n    kmip_version (KMIPVersion): An enumeration defining the KMIP\n        version with which the object will be decoded. Optional,\n        defaults to KMIP 1.0.", "id": "f15080:c6:m13"}
{"signature": "def __init__(self, value='<STR_LIT>'):", "body": "super(ExtensionName, self).__init__(value, Tags.EXTENSION_NAME)<EOL>", "docstring": "Construct an ExtensionName object.\n\nArgs:\n    value (str): The string data representing the extension name.\n        Optional, defaults to the empty string.", "id": "f15080:c21:m0"}
{"signature": "def write(self, output_buffer, kmip_version=enums.KMIPVersion.KMIP_1_3):", "body": "if kmip_version < enums.KMIPVersion.KMIP_1_3:<EOL><INDENT>raise exceptions.VersionNotSupported(<EOL>\"<STR_LIT>\".format(<EOL>kmip_version.value<EOL>)<EOL>)<EOL><DEDENT>local_buffer = BytearrayStream()<EOL>if self._rng_algorithm:<EOL><INDENT>self._rng_algorithm.write(local_buffer, kmip_version=kmip_version)<EOL><DEDENT>else:<EOL><INDENT>raise exceptions.InvalidField(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if self._cryptographic_algorithm:<EOL><INDENT>self._cryptographic_algorithm.write(<EOL>local_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>if self._cryptographic_length:<EOL><INDENT>self._cryptographic_length.write(<EOL>local_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>if self._hashing_algorithm:<EOL><INDENT>self._hashing_algorithm.write(<EOL>local_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>if self._drbg_algorithm:<EOL><INDENT>self._drbg_algorithm.write(<EOL>local_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>if self._recommended_curve:<EOL><INDENT>self._recommended_curve.write(<EOL>local_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>if self._fips186_variation:<EOL><INDENT>self._fips186_variation.write(<EOL>local_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>if self._prediction_resistance:<EOL><INDENT>self._prediction_resistance.write(<EOL>local_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>self.length = local_buffer.length()<EOL>super(RNGParameters, self).write(<EOL>output_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL>output_buffer.write(local_buffer.buffer)<EOL>", "docstring": "Write the RNGParameters structure encoding to the data stream.\n\nArgs:\n    output_buffer (stream): A data stream in which to encode\n        Attributes structure data, supporting a write method.\n    kmip_version (enum): A KMIPVersion enumeration defining the KMIP\n        version with which the object will be encoded. Optional,\n        defaults to KMIP 2.0.\n\nRaises:\n    InvalidField: Raised if the RNG algorithm field is not defined.\n    VersionNotSupported: Raised when a KMIP version is provided that\n        does not support the RNGParameters structure.", "id": "f15080:c31:m18"}
{"signature": "def read(self, input_buffer, kmip_version=enums.KMIPVersion.KMIP_2_0):", "body": "if kmip_version < enums.KMIPVersion.KMIP_2_0:<EOL><INDENT>raise exceptions.VersionNotSupported(<EOL>\"<STR_LIT>\".format(<EOL>kmip_version.value<EOL>)<EOL>)<EOL><DEDENT>super(ObjectDefaults, self).read(<EOL>input_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL>local_buffer = utils.BytearrayStream(input_buffer.read(self.length))<EOL>if self.is_tag_next(enums.Tags.OBJECT_TYPE, local_buffer):<EOL><INDENT>self._object_type = primitives.Enumeration(<EOL>enums.ObjectType,<EOL>tag=enums.Tags.OBJECT_TYPE<EOL>)<EOL>self._object_type.read(local_buffer, kmip_version=kmip_version)<EOL><DEDENT>else:<EOL><INDENT>raise exceptions.InvalidKmipEncoding(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if self.is_tag_next(enums.Tags.ATTRIBUTES, local_buffer):<EOL><INDENT>self._attributes = Attributes()<EOL>self._attributes.read(local_buffer, kmip_version=kmip_version)<EOL><DEDENT>else:<EOL><INDENT>raise exceptions.InvalidKmipEncoding(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>self.is_oversized(local_buffer)<EOL>", "docstring": "Read the data encoding the ObjectDefaults structure and decode it into\nits constituent parts.\n\nArgs:\n    input_buffer (stream): A data stream containing encoded object\n        data, supporting a read method; usually a BytearrayStream\n        object.\n    kmip_version (KMIPVersion): An enumeration defining the KMIP\n        version with which the object will be decoded. Optional,\n        defaults to KMIP 2.0.\n\nRaises:\n    InvalidKmipEncoding: Raised if the object type or attributes are\n        missing from the encoding.\n    VersionNotSupported: Raised when a KMIP version is provided that\n        does not support the ObjectDefaults structure.", "id": "f15080:c29:m5"}
{"signature": "def write(self, ostream, kmip_version=enums.KMIPVersion.KMIP_1_0):", "body": "tstream = BytearrayStream()<EOL>self.revocation_code.write(tstream, kmip_version=kmip_version)<EOL>if self.revocation_message is not None:<EOL><INDENT>self.revocation_message.write(tstream, kmip_version=kmip_version)<EOL><DEDENT>self.length = tstream.length()<EOL>super(RevocationReason, self).write(ostream, kmip_version=kmip_version)<EOL>ostream.write(tstream.buffer)<EOL>", "docstring": "Write the data encoding the RevocationReason object to a stream.\n\nArgs:\n    ostream (Stream): A data stream in which to encode object data,\n        supporting a write method; usually a BytearrayStream object.\n    kmip_version (KMIPVersion): An enumeration defining the KMIP\n        version with which the object will be encoded. Optional,\n        defaults to KMIP 1.0.", "id": "f15080:c28:m2"}
{"signature": "def write(self, output_stream, kmip_version=enums.KMIPVersion.KMIP_1_0):", "body": "local_stream = BytearrayStream()<EOL>if self._unique_identifier:<EOL><INDENT>self._unique_identifier.write(<EOL>local_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if self._cryptographic_parameters:<EOL><INDENT>self._cryptographic_parameters.write(<EOL>local_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>self.length = local_stream.length()<EOL>super(MACSignatureKeyInformation, self).write(<EOL>output_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL>output_stream.write(local_stream.buffer)<EOL>", "docstring": "Write the data encoding the MACSignatureKeyInformation struct to a\nstream.\n\nArgs:\n    output_stream (stream): A data stream in which to encode object\n        data, supporting a write method; usually a BytearrayStream\n        object.\n    kmip_version (KMIPVersion): An enumeration defining the KMIP\n        version with which the object will be encoded. Optional,\n        defaults to KMIP 1.0.", "id": "f15080:c14:m6"}
{"signature": "def __init__(self, attributes=None, tag=enums.Tags.ATTRIBUTES):", "body": "super(Attributes, self).__init__(tag=tag)<EOL>self._factory = AttributeValueFactory()<EOL>self._attributes = []<EOL>self.attributes = attributes<EOL>", "docstring": "Construct an Attributes structure.\n\nArgs:\n    attributes (list): A list of attribute objects. Each object must\n        be some form of primitive, derived from Base. Optional,\n        defaults to None which is interpreted as an empty list.\n    tag (enum): A Tags enumeration specifying what type of Attributes\n        structure is in use. Valid values include:\n            * Tags.ATTRIBUTES\n            * Tags.COMMON_ATTRIBUTES\n            * Tags.PRIVATE_KEY_ATTRIBUTES\n            * Tags.PUBLIC_KEY_ATTRIBUTES\n        Optional, defaults to Tags.ATTRIBUTES.", "id": "f15080:c2:m0"}
{"signature": "def __init__(self,<EOL>wrapping_method=None,<EOL>encryption_key_information=None,<EOL>mac_signature_key_information=None,<EOL>attribute_names=None,<EOL>encoding_option=None):", "body": "super(KeyWrappingSpecification, self).__init__(<EOL>tag=Tags.KEY_WRAPPING_SPECIFICATION<EOL>)<EOL>self._wrapping_method = None<EOL>self._encryption_key_information = None<EOL>self._mac_signature_key_information = None<EOL>self._attribute_names = None<EOL>self._encoding_option = None<EOL>self.wrapping_method = wrapping_method<EOL>self.encryption_key_information = encryption_key_information<EOL>self.mac_signature_key_information = mac_signature_key_information<EOL>self.attribute_names = attribute_names<EOL>self.encoding_option = encoding_option<EOL>", "docstring": "Construct a KeyWrappingSpecification struct.\n\nArgs:\n    wrapping_method (WrappingMethod): An enumeration value that\n        specifies the method to use to wrap the key value. Optional,\n        defaults to None. Required for encoding and decoding.\n    encryption_key_information (EncryptionKeyInformation): A struct\n        containing the unique identifier of the encryption key and\n        associated cryptographic parameters. Optional, defaults to\n        None.\n    mac_signature_key_information (MACSignatureKeyInformation): A\n        struct containing the unique identifier of the MAC/signature\n        key and associated cryptographic parameters. Optional,\n        defaults to None.\n    attribute_names (list): A list of strings representing the names\n        of attributes that should be wrapped with the key material.\n        Optional, defaults to None.\n    encoding_option (EncodingOption): An enumeration value that\n        specifies the encoding of the key value before it is wrapped.\n        Optional, defaults to None.", "id": "f15080:c16:m0"}
{"signature": "def write(self, output_buffer, kmip_version=enums.KMIPVersion.KMIP_2_0):", "body": "if kmip_version < enums.KMIPVersion.KMIP_2_0:<EOL><INDENT>raise exceptions.VersionNotSupported(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(<EOL>kmip_version.value<EOL>)<EOL>)<EOL><DEDENT>local_buffer = BytearrayStream()<EOL>if self._vendor_identification:<EOL><INDENT>self._vendor_identification.write(<EOL>local_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>else:<EOL><INDENT>raise exceptions.InvalidField(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if self._attribute_name:<EOL><INDENT>self._attribute_name.write(<EOL>local_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>else:<EOL><INDENT>raise exceptions.InvalidField(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>self.length = local_buffer.length()<EOL>super(AttributeReference, self).write(<EOL>output_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL>output_buffer.write(local_buffer.buffer)<EOL>", "docstring": "Write the AttributeReference structure encoding to the data stream.\n\nArgs:\n    output_buffer (stream): A data stream in which to encode\n        Attributes structure data, supporting a write method.\n    kmip_version (enum): A KMIPVersion enumeration defining the KMIP\n        version with which the object will be encoded. Optional,\n        defaults to KMIP 2.0.\n\nRaises:\n    InvalidField: Raised if the vendor identification or attribute name\n        fields are not defined.\n    VersionNotSupported: Raised when a KMIP version is provided that\n        does not support the AttributeReference structure.", "id": "f15080:c1:m6"}
{"signature": "def __init__(self, code=None, message=None):", "body": "super(RevocationReason, self).__init__(tag=Tags.REVOCATION_REASON)<EOL>if code is not None:<EOL><INDENT>self.revocation_code = RevocationReasonCode(value=code)<EOL><DEDENT>else:<EOL><INDENT>self.revocation_code = RevocationReasonCode()<EOL><DEDENT>if message is not None:<EOL><INDENT>self.revocation_message = TextString(<EOL>value=message,<EOL>tag=Tags.REVOCATION_MESSAGE)<EOL><DEDENT>else:<EOL><INDENT>self.revocation_message = None<EOL><DEDENT>self.validate()<EOL>", "docstring": "Construct a RevocationReason object.\n\nParameters:\n    code(RevocationReasonCode): revocation reason code\n    message(string): An optional revocation message", "id": "f15080:c28:m0"}
{"signature": "def __init__(self,<EOL>unique_identifier=None,<EOL>cryptographic_parameters=None):", "body": "super(EncryptionKeyInformation, self).__init__(<EOL>tag=Tags.ENCRYPTION_KEY_INFORMATION<EOL>)<EOL>self._unique_identifier = None<EOL>self._cryptographic_parameters = None<EOL>self.unique_identifier = unique_identifier<EOL>self.cryptographic_parameters = cryptographic_parameters<EOL>", "docstring": "Construct an EncryptionKeyInformation struct.\n\nArgs:\n    unique_identifier (string): The ID of the managed object (e.g.,\n        a symmetric key) used for encryption. Required for encoding\n        and decoding.\n    cryptographic_parameters (CryptographicParameters): A\n        CryptographicParameters struct containing the settings for\n        the encryption process. Optional, defaults to None. If not\n        included, the CryptographicParameters associated with the\n        managed object will be used instead.", "id": "f15080:c13:m0"}
{"signature": "def read(self, input_buffer, kmip_version=enums.KMIPVersion.KMIP_1_3):", "body": "if kmip_version < enums.KMIPVersion.KMIP_1_3:<EOL><INDENT>raise exceptions.VersionNotSupported(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(<EOL>kmip_version.value<EOL>)<EOL>)<EOL><DEDENT>super(ProfileInformation, self).read(<EOL>input_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL>local_buffer = utils.BytearrayStream(input_buffer.read(self.length))<EOL>if self.is_tag_next(enums.Tags.PROFILE_NAME, local_buffer):<EOL><INDENT>profile_name = primitives.Enumeration(<EOL>enums.ProfileName,<EOL>tag=enums.Tags.PROFILE_NAME<EOL>)<EOL>profile_name.read(local_buffer, kmip_version=kmip_version)<EOL>self._profile_name = profile_name<EOL><DEDENT>else:<EOL><INDENT>raise exceptions.InvalidKmipEncoding(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if self.is_tag_next(enums.Tags.SERVER_URI, local_buffer):<EOL><INDENT>server_uri = primitives.TextString(tag=enums.Tags.SERVER_URI)<EOL>server_uri.read(local_buffer, kmip_version=kmip_version)<EOL>self._server_uri = server_uri<EOL><DEDENT>if self.is_tag_next(enums.Tags.SERVER_PORT, local_buffer):<EOL><INDENT>server_port = primitives.Integer(tag=enums.Tags.SERVER_PORT)<EOL>server_port.read(local_buffer, kmip_version=kmip_version)<EOL>self._server_port = server_port<EOL><DEDENT>self.is_oversized(local_buffer)<EOL>", "docstring": "Read the data encoding the ProfileInformation structure and decode it\ninto its constituent parts.\n\nArgs:\n    input_buffer (stream): A data stream containing encoded object\n        data, supporting a read method; usually a BytearrayStream\n        object.\n    kmip_version (KMIPVersion): An enumeration defining the KMIP\n        version with which the object will be decoded. Optional,\n        defaults to KMIP 2.0.\n\nRaises:\n    InvalidKmipEncoding: Raised if the profile name is missing from\n        the encoding.\n    VersionNotSupported: Raised when a KMIP version is provided that\n        does not support the ProfileInformation structure.", "id": "f15080:c32:m7"}
{"signature": "def __init__(self, value=None):", "body": "super(ExtensionType, self).__init__(value, Tags.EXTENSION_TYPE)<EOL>", "docstring": "Construct an ExtensionType object.\n\nArgs:\n    value (Types): A number representing a Types enumeration value,\n        indicating the type of the extended Object. Optional, defaults\n        to None.", "id": "f15080:c23:m0"}
{"signature": "def __init__(self, object_type=None, attributes=None):", "body": "super(ObjectDefaults, self).__init__(tag=enums.Tags.OBJECT_DEFAULTS)<EOL>self._object_type = None<EOL>self._attributes = None<EOL>self.object_type = object_type<EOL>self.attributes = attributes<EOL>", "docstring": "Construct an ObjectDefaults structure.\n\nArgs:\n    object_type (enum): An ObjectType enumeration identifying the type\n        to which the defaults pertain. Optional, defaults to None.\n        Required for read/write.\n    attributes (structure): An Attributes structure containing\n        attribute values that are defaults for an object type.\n        Optional, defaults to None. Required for read/write.", "id": "f15080:c29:m0"}
{"signature": "def __init__(self, nonce_id=None, nonce_value=None):", "body": "super(Nonce, self).__init__(tag=enums.Tags.NONCE)<EOL>self._nonce_id = None<EOL>self._nonce_value = None<EOL>self.nonce_id = nonce_id<EOL>self.nonce_value = nonce_value<EOL>", "docstring": "Construct a Nonce struct.\n\nArgs:\n    nonce_id (bytes): A binary string representing the ID of the nonce\n        value. Optional, defaults to None. Required for encoding and\n        decoding.\n    nonce_value (bytes): A binary string representing a random value.\n        Optional, defaults to None. Required for encoding and decoding.", "id": "f15080:c3:m0"}
{"signature": "def write(self, output_stream, kmip_version=enums.KMIPVersion.KMIP_2_0):", "body": "if kmip_version < enums.KMIPVersion.KMIP_2_0:<EOL><INDENT>raise exceptions.VersionNotSupported(<EOL>\"<STR_LIT>\".format(<EOL>kmip_version.value<EOL>)<EOL>)<EOL><DEDENT>local_stream = BytearrayStream()<EOL>for attribute in self._attributes:<EOL><INDENT>tag = attribute.tag<EOL>if not enums.is_attribute(tag, kmip_version=kmip_version):<EOL><INDENT>raise exceptions.AttributeNotSupported(<EOL>\"<STR_LIT>\".format(<EOL>tag.name,<EOL>kmip_version.value<EOL>)<EOL>)<EOL><DEDENT>attribute.write(local_stream, kmip_version=kmip_version)<EOL><DEDENT>self.length = local_stream.length()<EOL>super(Attributes, self).write(output_stream, kmip_version=kmip_version)<EOL>output_stream.write(local_stream.buffer)<EOL>", "docstring": "Write the Attributes structure encoding to the data stream.\n\nArgs:\n    output_stream (stream): A data stream in which to encode\n        Attributes structure data, supporting a write method.\n    kmip_version (enum): A KMIPVersion enumeration defining the KMIP\n        version with which the object will be encoded. Optional,\n        defaults to KMIP 2.0.\n\nRaises:\n    AttributeNotSupported: Raised if an unsupported attribute is\n        found in the attribute list while encoding.\n    VersionNotSupported: Raised when a KMIP version is provided that\n        does not support the Attributes object.", "id": "f15080:c2:m4"}
{"signature": "def read(self, istream, kmip_version=enums.KMIPVersion.KMIP_1_0):", "body": "super(LongInteger, self).read(istream, kmip_version=kmip_version)<EOL>if self.length is not LongInteger.LENGTH:<EOL><INDENT>raise exceptions.InvalidPrimitiveLength(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(<EOL>LongInteger.LENGTH, self.length))<EOL><DEDENT>self.value = unpack('<STR_LIT>', istream.read(self.length))[<NUM_LIT:0>]<EOL>self.validate()<EOL>", "docstring": "Read the encoding of the LongInteger from the input stream.\n\nArgs:\n    istream (stream): A buffer containing the encoded bytes of a\n        LongInteger. Usually a BytearrayStream object. Required.\n    kmip_version (KMIPVersion): An enumeration defining the KMIP\n        version with which the object will be decoded. Optional,\n        defaults to KMIP 1.0.\n\nRaises:\n    InvalidPrimitiveLength: if the long integer encoding read in has\n        an invalid encoded length.", "id": "f15081:c3:m1"}
{"signature": "def read_value(self, istream, kmip_version=enums.KMIPVersion.KMIP_1_0):", "body": "try:<EOL><INDENT>value = unpack('<STR_LIT>', istream.read(self.LENGTH))[<NUM_LIT:0>]<EOL><DEDENT>except Exception:<EOL><INDENT>self.logger.error(\"<STR_LIT>\")<EOL>raise<EOL><DEDENT>if value == <NUM_LIT:1>:<EOL><INDENT>self.value = True<EOL><DEDENT>elif value == <NUM_LIT:0>:<EOL><INDENT>self.value = False<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(value))<EOL><DEDENT>self.validate()<EOL>", "docstring": "Read the value of the Boolean object from the input stream.\n\nArgs:\n    istream (Stream): A buffer containing the encoded bytes of the\n        value of a Boolean object. Usually a BytearrayStream object.\n        Required.\n    kmip_version (KMIPVersion): An enumeration defining the KMIP\n        version with which the object will be decoded. Optional,\n        defaults to KMIP 1.0.\n\nRaises:\n    ValueError: if the read boolean value is not a 0 or 1.", "id": "f15081:c6:m1"}
{"signature": "def read(self, istream, kmip_version=enums.KMIPVersion.KMIP_1_0):", "body": "super(Enumeration, self).read(istream, kmip_version=kmip_version)<EOL>if self.length != Enumeration.LENGTH:<EOL><INDENT>raise exceptions.InvalidPrimitiveLength(<EOL>\"<STR_LIT>\".format(Enumeration.LENGTH))<EOL><DEDENT>value = unpack('<STR_LIT>', istream.read(Enumeration.LENGTH))[<NUM_LIT:0>]<EOL>self.value = self.enum(value)<EOL>pad = unpack('<STR_LIT>', istream.read(Enumeration.LENGTH))[<NUM_LIT:0>]<EOL>if pad != <NUM_LIT:0>:<EOL><INDENT>raise exceptions.InvalidPaddingBytes(\"<STR_LIT>\")<EOL><DEDENT>self.validate()<EOL>", "docstring": "Read the encoding of the Enumeration from the input stream.\n\nArgs:\n    istream (stream): A buffer containing the encoded bytes of an\n        Enumeration. Usually a BytearrayStream object. Required.\n    kmip_version (KMIPVersion): An enumeration defining the KMIP\n        version with which the object will be decoded. Optional,\n        defaults to KMIP 1.0.\n\nRaises:\n    InvalidPrimitiveLength: if the Enumeration encoding read in has an\n        invalid encoded length.\n    InvalidPaddingBytes: if the Enumeration encoding read in does not\n        use zeroes for its padding bytes.", "id": "f15081:c5:m1"}
{"signature": "def read(self, istream, kmip_version=enums.KMIPVersion.KMIP_1_0):", "body": "super(Boolean, self).read(istream, kmip_version=kmip_version)<EOL>self.read_value(istream, kmip_version=kmip_version)<EOL>", "docstring": "Read the encoding of the Boolean object from the input stream.\n\nArgs:\n    istream (Stream): A buffer containing the encoded bytes of a\n        Boolean object. Usually a BytearrayStream object. Required.\n    kmip_version (KMIPVersion): An enumeration defining the KMIP\n        version with which the object will be decoded. Optional,\n        defaults to KMIP 1.0.", "id": "f15081:c6:m2"}
{"signature": "def __init__(self, enum, value=None, tag=enums.Tags.DEFAULT):", "body": "super(Enumeration, self).__init__(tag, enums.Types.ENUMERATION)<EOL>self.value = value<EOL>self.enum = enum<EOL>self.length = Enumeration.LENGTH<EOL>self.validate()<EOL>", "docstring": "Create an Enumeration.\n\nArgs:\n    enum (class): The enumeration class of which value is a member\n        (e.g., Tags). Required.\n    value (int): The value of the Enumeration, must be an integer\n        (e.g., Tags.DEFAULT). Optional, defaults to None.\n    tag (Tags): An enumeration defining the tag of the Enumeration.\n        Optional, defaults to Tags.DEFAULT.", "id": "f15081:c5:m0"}
{"signature": "def validate(self):", "body": "if self.value is not None:<EOL><INDENT>if not isinstance(self.value, six.integer_types):<EOL><INDENT>raise TypeError('<STR_LIT>'.format(<EOL>six.integer_types, type(self.value)))<EOL><DEDENT><DEDENT>", "docstring": "Verify that the value of the BigInteger is valid.\n\nRaises:\n    TypeError: if the value is not of type int or long", "id": "f15081:c4:m3"}
{"signature": "def __init__(self, value=None, tag=enums.Tags.DEFAULT):", "body": "if value is None:<EOL><INDENT>value = int(time.time())<EOL><DEDENT>super(DateTime, self).__init__(value, tag)<EOL>self.type = enums.Types.DATE_TIME<EOL>", "docstring": "Create a DateTime.\n\nArgs:\n    value (int): The value of the DateTime in number of seconds since\n        the Epoch. See the time package for additional information.\n        Optional, defaults to the current time.\n    tag (Tags): An enumeration defining the tag of the LongInteger.\n        Optional, defaults to Tags.DEFAULT.", "id": "f15081:c9:m0"}
{"signature": "def read(self, istream, kmip_version=enums.KMIPVersion.KMIP_1_0):", "body": "super(BigInteger, self).read(istream, kmip_version=kmip_version)<EOL>if self.length % <NUM_LIT:8>:<EOL><INDENT>raise exceptions.InvalidPrimitiveLength(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(self.length))<EOL><DEDENT>sign = <NUM_LIT:1><EOL>binary = '<STR_LIT>'<EOL>for _ in range(self.length):<EOL><INDENT>byte = struct.unpack('<STR_LIT>', istream.read(<NUM_LIT:1>))[<NUM_LIT:0>]<EOL>bits = \"<STR_LIT>\".format(byte)<EOL>pad = len(bits) % <NUM_LIT:8><EOL>if pad:<EOL><INDENT>bits = ('<STR_LIT:0>' * (<NUM_LIT:8> - pad)) + bits<EOL><DEDENT>binary += bits<EOL><DEDENT>if binary[<NUM_LIT:0>] == '<STR_LIT:1>':<EOL><INDENT>sign = -<NUM_LIT:1><EOL>binary = binary.replace('<STR_LIT:1>', '<STR_LIT:i>')<EOL>binary = binary.replace('<STR_LIT:0>', '<STR_LIT:1>')<EOL>binary = binary.replace('<STR_LIT:i>', '<STR_LIT:0>')<EOL>pivot = binary.rfind('<STR_LIT:0>')<EOL>binary = binary[<NUM_LIT:0>:pivot] + '<STR_LIT:1>' + ('<STR_LIT:0>' * len(binary[pivot + <NUM_LIT:1>:]))<EOL><DEDENT>self.value = int(binary, <NUM_LIT:2>) * sign<EOL>", "docstring": "Read the encoding of the BigInteger from the input stream.\n\nArgs:\n    istream (stream): A buffer containing the encoded bytes of the\n        value of a BigInteger. Usually a BytearrayStream object.\n        Required.\n    kmip_version (KMIPVersion): An enumeration defining the KMIP\n        version with which the object will be decoded. Optional,\n        defaults to KMIP 1.0.\n\nRaises:\n    InvalidPrimitiveLength: if the big integer encoding read in has\n        an invalid encoded length.", "id": "f15081:c4:m1"}
{"signature": "def write(self, ostream, kmip_version=enums.KMIPVersion.KMIP_1_0):", "body": "super(Boolean, self).write(ostream, kmip_version=kmip_version)<EOL>self.write_value(ostream, kmip_version=kmip_version)<EOL>", "docstring": "Write the encoding of the Boolean object to the output stream.\n\nArgs:\n    ostream (Stream): A buffer to contain the encoded bytes of a\n        Boolean object. Usually a BytearrayStream object. Required.\n    kmip_version (KMIPVersion): An enumeration defining the KMIP\n        version with which the object will be encoded. Optional,\n        defaults to KMIP 1.0.", "id": "f15081:c6:m4"}
{"signature": "def validate(self):", "body": "if not isinstance(self.enum, enumeration.EnumMeta):<EOL><INDENT>raise TypeError(<EOL>'<STR_LIT>'.format(<EOL>self.enum))<EOL><DEDENT>if self.value is not None:<EOL><INDENT>if not isinstance(self.value, self.enum):<EOL><INDENT>raise TypeError(<EOL>'<STR_LIT>'.format(<EOL>self.value, self.enum))<EOL><DEDENT>if type(self.value.value) not in six.integer_types:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>if self.value.value > Enumeration.MAX:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>')<EOL><DEDENT>elif self.value.value < Enumeration.MIN:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Verify that the value of the Enumeration is valid.\n\nRaises:\n    TypeError: if the enum is not of type Enum\n    ValueError: if the value is not of the expected Enum subtype or if\n        the value cannot be represented by an unsigned 32-bit integer", "id": "f15081:c5:m3"}
{"signature": "def convert_attribute_tag_to_name(value):", "body": "if not isinstance(value, Tags):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>for entry in attribute_name_tag_table:<EOL><INDENT>if value == entry[<NUM_LIT:1>]:<EOL><INDENT>return entry[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>raise ValueError(\"<STR_LIT>\".format(value))<EOL>", "docstring": "A utility function that converts an attribute tag into the corresponding\nattribute name string.\n\nFor example: enums.Tags.STATE -> 'State'\n\nArgs:\n    value (enum): The Tags enumeration value of the attribute.\n\nReturns:\n    string: The attribute name string that corresponds to the attribute\n        tag.\n\nRaises:\n    ValueError: if the attribute tag is not a Tags enumeration or if it\n        is unrecognized attribute tag", "id": "f15082:m1"}
{"signature": "def __init__(self,<EOL>certificate_type=None,<EOL>certificate_value=None):", "body": "super(Certificate, self).__init__(Tags.CERTIFICATE)<EOL>if certificate_type is None:<EOL><INDENT>self.certificate_type = CertificateType()<EOL><DEDENT>else:<EOL><INDENT>self.certificate_type = CertificateType(certificate_type)<EOL><DEDENT>if certificate_value is None:<EOL><INDENT>self.certificate_value = CertificateValue()<EOL><DEDENT>else:<EOL><INDENT>self.certificate_value = CertificateValue(certificate_value)<EOL><DEDENT>", "docstring": "Construct a Certificate object.\n\nArgs:\n    certificate_type (CertificateType): The type of the\n        certificate. Optional, defaults to None.\n    certificate_value (bytes): The bytes of the certificate. Optional,\n        defaults to None.", "id": "f15084:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def create(cls, name_value, name_type):<DEDENT>", "body": "if isinstance(name_value, Name.NameValue):<EOL><INDENT>value = name_value<EOL><DEDENT>elif isinstance(name_value, str):<EOL><INDENT>value = cls.NameValue(name_value)<EOL><DEDENT>else:<EOL><INDENT>name = '<STR_LIT:Name>'<EOL>msg = exceptions.ErrorStrings.BAD_EXP_RECV<EOL>member = '<STR_LIT>'<EOL>raise TypeError(msg.format('<STR_LIT>'.format(name, member),<EOL>'<STR_LIT>', type(Name.NameValue),<EOL>type(name_value)))<EOL><DEDENT>if isinstance(name_type, Name.NameType):<EOL><INDENT>n_type = name_type<EOL><DEDENT>elif isinstance(name_type, Enum):<EOL><INDENT>n_type = cls.NameType(name_type)<EOL><DEDENT>else:<EOL><INDENT>name = '<STR_LIT:Name>'<EOL>msg = exceptions.ErrorStrings.BAD_EXP_RECV<EOL>member = '<STR_LIT>'<EOL>raise TypeError(msg.format('<STR_LIT>'.format(name, member),<EOL>'<STR_LIT>', type(Name.NameType),<EOL>type(name_type)))<EOL><DEDENT>return Name(name_value=value,<EOL>name_type=n_type)<EOL>", "docstring": "Returns a Name object, populated with the given value and type", "id": "f15085:c3:m5"}
{"signature": "def __init__(self,<EOL>hashing_algorithm=None,<EOL>digest_value=None,<EOL>key_format_type=None):", "body": "super(Digest, self).__init__(Tags.DIGEST)<EOL>if hashing_algorithm is None:<EOL><INDENT>self.hashing_algorithm = HashingAlgorithm()<EOL><DEDENT>else:<EOL><INDENT>self.hashing_algorithm = hashing_algorithm<EOL><DEDENT>if digest_value is None:<EOL><INDENT>self.digest_value = DigestValue()<EOL><DEDENT>else:<EOL><INDENT>self.digest_value = digest_value<EOL><DEDENT>if key_format_type is None:<EOL><INDENT>self.key_format_type = KeyFormatType()<EOL><DEDENT>else:<EOL><INDENT>self.key_format_type = key_format_type<EOL><DEDENT>self.validate()<EOL>", "docstring": "Construct a Digest object.\n\nArgs:\n    hashing_algorithm (HashingAlgorithm): The hash algorithm used to\n        compute the value of the digest. Optional, defaults to None.\n    digest_value (DigestValue): The byte string representing the\n        value of the hash digest. Optional, defaults to None.\n    key_format_type (KeyFormatType): The format type of the key the\n        hash was computed for, if the object in question is a key.\n        Optional, defaults to None.", "id": "f15085:c11:m0"}
{"signature": "def validate(self):", "body": "self.__validate()<EOL>", "docstring": "Error check the attributes of the Digest object.", "id": "f15085:c11:m3"}
{"signature": "def __init__(self, unique_identifier=None, usage_limits_count=None):", "body": "super(GetUsageAllocationRequestPayload, self).__init__(<EOL>enums.Tags.REQUEST_PAYLOAD<EOL>)<EOL>self._unique_identifier = None<EOL>self._usage_limits_count = None<EOL>self.unique_identifier = unique_identifier<EOL>self.usage_limits_count = usage_limits_count<EOL>", "docstring": "Construct a GetUsageAllocation request payload struct.\n\nArgs:\n    unique_identifier (string): The ID of the managed object (e.g.,\n        a public key) to obtain a usage allocation for. Optional,\n        defaults to None.\n    usage_limits_count (int): The number of usage limits units that\n        should be reserved for the object. Optional, defaults to None.", "id": "f15089:c0:m0"}
{"signature": "def __init__(self, unique_identifier=None):", "body": "super(GetUsageAllocationResponsePayload, self).__init__(<EOL>enums.Tags.RESPONSE_PAYLOAD<EOL>)<EOL>self._unique_identifier = None<EOL>self.unique_identifier = unique_identifier<EOL>", "docstring": "Construct a GetUsageAllocation response payload struct.\n\nArgs:\n    unique_identifier (string): The ID of the managed object (e.g.,\n        a public key) that was allocated. Optional, defaults to None.", "id": "f15089:c1:m0"}
{"signature": "def read(self, input_stream, kmip_version=enums.KMIPVersion.KMIP_1_0):", "body": "super(GetUsageAllocationRequestPayload, self).read(<EOL>input_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL>local_stream = utils.BytearrayStream(input_stream.read(self.length))<EOL>if self.is_tag_next(enums.Tags.UNIQUE_IDENTIFIER, local_stream):<EOL><INDENT>self._unique_identifier = primitives.TextString(<EOL>tag=enums.Tags.UNIQUE_IDENTIFIER<EOL>)<EOL>self._unique_identifier.read(<EOL>local_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>if self.is_tag_next(enums.Tags.USAGE_LIMITS_COUNT, local_stream):<EOL><INDENT>self._usage_limits_count = primitives.LongInteger(<EOL>tag=enums.Tags.USAGE_LIMITS_COUNT<EOL>)<EOL>self._usage_limits_count.read(<EOL>local_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>self.is_oversized(local_stream)<EOL>", "docstring": "Read the data encoding the GetUsageAllocation request payload and\ndecode it into its constituent parts.\n\nArgs:\n    input_stream (stream): A data stream containing encoded object\n        data, supporting a read method; usually a BytearrayStream\n        object.\n    kmip_version (KMIPVersion): An enumeration defining the KMIP\n        version with which the object will be decoded. Optional,\n        defaults to KMIP 1.0.\n\nRaises:\n    ValueError: Raised if the data attribute is missing from the\n        encoded payload.", "id": "f15089:c0:m5"}
{"signature": "def __init__(self,<EOL>object_type=None,<EOL>unique_identifier=None,<EOL>template_attribute=None):", "body": "super(CreateResponsePayload, self).__init__(<EOL>tag=enums.Tags.RESPONSE_PAYLOAD<EOL>)<EOL>self._object_type = None<EOL>self._unique_identifier = None<EOL>self._template_attribute = None<EOL>self.object_type = object_type<EOL>self.unique_identifier = unique_identifier<EOL>self.template_attribute = template_attribute<EOL>", "docstring": "Construct a Create response payload structure.\n\nArgs:\n    object_type (enum): An ObjectType enumeration specifying the type\n        of object created. Optional, defaults to None. Required for\n        read/write.\n    unique_identifier (string): The ID of the new object. Optional,\n        defaults to None. Required for read/write.\n    template_attribute (TemplateAttribute): A TemplateAttribute\n        structure containing a set of attributes that were set on the\n        new object. Optional, defaults to None.", "id": "f15090:c1:m0"}
{"signature": "def __init__(self,<EOL>unique_identifier=None,<EOL>lease_time=None,<EOL>last_change_date=None):", "body": "super(ObtainLeaseResponsePayload, self).__init__(<EOL>enums.Tags.RESPONSE_PAYLOAD<EOL>)<EOL>self._unique_identifier = None<EOL>self._lease_time = None<EOL>self._last_change_date = None<EOL>self.unique_identifier = unique_identifier<EOL>self.lease_time = lease_time<EOL>self.last_change_date = last_change_date<EOL>", "docstring": "Construct an ObtainLease response payload struct.\n\nArgs:\n    unique_identifier (string): The ID of the managed object (e.g.,\n        a public key) a lease was obtained for. Optional, defaults to\n        None.\n    lease_time (int): The amount of time, in seconds, that the object\n        lease is in effect for. Optional, defaults to None.\n    last_change_date (int): The date, in seconds since the epoch,\n        when the last change was made to the object or one of its\n        attributes. Optional, defaults to None.", "id": "f15093:c1:m0"}
{"signature": "def read(self, input_stream, kmip_version=enums.KMIPVersion.KMIP_1_0):", "body": "super(ObtainLeaseRequestPayload, self).read(<EOL>input_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL>local_stream = utils.BytearrayStream(input_stream.read(self.length))<EOL>if self.is_tag_next(enums.Tags.UNIQUE_IDENTIFIER, local_stream):<EOL><INDENT>self._unique_identifier = primitives.TextString(<EOL>tag=enums.Tags.UNIQUE_IDENTIFIER<EOL>)<EOL>self._unique_identifier.read(<EOL>local_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>self.is_oversized(local_stream)<EOL>", "docstring": "Read the data encoding the ObtainLease request payload and decode it\ninto its constituent parts.\n\nArgs:\n    input_stream (stream): A data stream containing encoded object\n        data, supporting a read method; usually a BytearrayStream\n        object.\n    kmip_version (KMIPVersion): An enumeration defining the KMIP\n        version with which the object will be decoded. Optional,\n        defaults to KMIP 1.0.\n\nRaises:\n    ValueError: Raised if the data attribute is missing from the\n        encoded payload.", "id": "f15093:c0:m3"}
{"signature": "def __init__(self, unique_identifier=None):", "body": "super(GetAttributeListRequestPayload, self).__init__(<EOL>enums.Tags.REQUEST_PAYLOAD)<EOL>self._unique_identifier = None<EOL>self.unique_identifier = unique_identifier<EOL>", "docstring": "Construct a GetAttributeList request payload.\n\nArgs:\n    unique_identifier (string): The ID of the managed object with\n        which the retrieved attribute names should be associated.\n        Optional, defaults to None.", "id": "f15094:c0:m0"}
{"signature": "def write(self, output_buffer, kmip_version=enums.KMIPVersion.KMIP_1_0):", "body": "local_buffer = utils.BytearrayStream()<EOL>if self._unique_identifier:<EOL><INDENT>self._unique_identifier.write(<EOL>local_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>else:<EOL><INDENT>raise exceptions.InvalidField(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if self._attribute_names:<EOL><INDENT>if kmip_version < enums.KMIPVersion.KMIP_2_0:<EOL><INDENT>for attribute_name in self._attribute_names:<EOL><INDENT>attribute_name.write(<EOL>local_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for attribute_name in self._attribute_names:<EOL><INDENT>t = enums.convert_attribute_name_to_tag(<EOL>attribute_name.value<EOL>)<EOL>e = primitives.Enumeration(<EOL>enums.Tags,<EOL>value=t,<EOL>tag=enums.Tags.ATTRIBUTE_REFERENCE<EOL>)<EOL>e.write(local_buffer, kmip_version=kmip_version)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>raise exceptions.InvalidField(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>self.length = local_buffer.length()<EOL>super(GetAttributeListResponsePayload, self).write(<EOL>output_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL>output_buffer.write(local_buffer.buffer)<EOL>", "docstring": "Write the data encoding the GetAttributeList response payload to a\nstream.\n\nArgs:\n    output_buffer (stream): A data stream in which to encode object\n        data, supporting a write method; usually a BytearrayStream\n        object.\n    kmip_version (KMIPVersion): An enumeration defining the KMIP\n        version with which the object will be encoded. Optional,\n        defaults to KMIP 1.0.\n\nRaises:\n    InvalidField: Raised if the unique identifier or attribute name\n        are not defined.", "id": "f15094:c1:m6"}
{"signature": "def __init__(self,<EOL>unique_identifier=None,<EOL>cryptographic_parameters=None,<EOL>data=None,<EOL>iv_counter_nonce=None):", "body": "super(DecryptRequestPayload, self).__init__(<EOL>enums.Tags.REQUEST_PAYLOAD<EOL>)<EOL>self._unique_identifier = None<EOL>self._cryptographic_parameters = None<EOL>self._data = None<EOL>self._iv_counter_nonce = None<EOL>self.unique_identifier = unique_identifier<EOL>self.cryptographic_parameters = cryptographic_parameters<EOL>self.data = data<EOL>self.iv_counter_nonce = iv_counter_nonce<EOL>", "docstring": "Construct a Decrypt request payload struct.\n\nArgs:\n    unique_identifier (string): The ID of the managed object (e.g.,\n        a symmetric key) to be used for decryption. Optional, defaults\n        to None. If not included, the ID placeholder will be used.\n    cryptographic_parameters (CryptographicParameters): A\n        CryptographicParameters struct containing the settings for\n        the decryption algorithm. Optional, defaults to None. If not\n        included, the CryptographicParameters associated with the\n        managed object will be used instead.\n    data (bytes): The data to decrypt in binary form. Required for\n        encoding and decoding.\n    iv_counter_nonce (bytes): The IV/counter/nonce value to be used\n        with the decryption algorithm. Optional, defaults to None.", "id": "f15095:c0:m0"}
{"signature": "def write(self, output_stream, kmip_version=enums.KMIPVersion.KMIP_1_0):", "body": "local_stream = utils.BytearrayStream()<EOL>if self._unique_identifier:<EOL><INDENT>self._unique_identifier.write(<EOL>local_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if self._data:<EOL><INDENT>self._data.write(local_stream, kmip_version=kmip_version)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self.length = local_stream.length()<EOL>super(DecryptResponsePayload, self).write(<EOL>output_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL>output_stream.write(local_stream.buffer)<EOL>", "docstring": "Write the data encoding the Decrypt response payload to a stream.\n\nArgs:\n    output_stream (stream): A data stream in which to encode object\n        data, supporting a write method; usually a BytearrayStream\n        object.\n    kmip_version (KMIPVersion): An enumeration defining the KMIP\n        version with which the object will be encoded. Optional,\n        defaults to KMIP 1.0.\n\nRaises:\n    ValueError: Raised if the unique_identifier or data attributes\n        are not defined.", "id": "f15095:c1:m6"}
{"signature": "def read(self, input_stream, kmip_version=enums.KMIPVersion.KMIP_1_0):", "body": "super(DecryptRequestPayload, self).read(<EOL>input_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL>local_stream = utils.BytearrayStream(input_stream.read(self.length))<EOL>if self.is_tag_next(enums.Tags.UNIQUE_IDENTIFIER, local_stream):<EOL><INDENT>self._unique_identifier = primitives.TextString(<EOL>tag=enums.Tags.UNIQUE_IDENTIFIER<EOL>)<EOL>self._unique_identifier.read(<EOL>local_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>if self.is_tag_next(<EOL>enums.Tags.CRYPTOGRAPHIC_PARAMETERS,<EOL>local_stream<EOL>):<EOL><INDENT>self._cryptographic_parameters =attributes.CryptographicParameters()<EOL>self._cryptographic_parameters.read(<EOL>local_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>if self.is_tag_next(enums.Tags.DATA, local_stream):<EOL><INDENT>self._data = primitives.ByteString(tag=enums.Tags.DATA)<EOL>self._data.read(local_stream, kmip_version=kmip_version)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if self.is_tag_next(enums.Tags.IV_COUNTER_NONCE, local_stream):<EOL><INDENT>self._iv_counter_nonce = primitives.ByteString(<EOL>tag=enums.Tags.IV_COUNTER_NONCE<EOL>)<EOL>self._iv_counter_nonce.read(<EOL>local_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>self.is_oversized(local_stream)<EOL>", "docstring": "Read the data encoding the Decrypt request payload and decode it\ninto its constituent parts.\n\nArgs:\n    input_stream (stream): A data stream containing encoded object\n        data, supporting a read method; usually a BytearrayStream\n        object.\n    kmip_version (KMIPVersion): An enumeration defining the KMIP\n        version with which the object will be decoded. Optional,\n        defaults to KMIP 1.0.\n\nRaises:\n    ValueError: Raised if the data attribute is missing from the\n        encoded payload.", "id": "f15095:c0:m9"}
{"signature": "def read(self, input_buffer, kmip_version=enums.KMIPVersion.KMIP_1_0):", "body": "super(DeriveKeyResponsePayload, self).read(<EOL>input_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL>local_buffer = utils.BytearrayStream(input_buffer.read(self.length))<EOL>if self.is_tag_next(enums.Tags.UNIQUE_IDENTIFIER, local_buffer):<EOL><INDENT>self._unique_identifier = primitives.TextString(<EOL>tag=enums.Tags.UNIQUE_IDENTIFIER<EOL>)<EOL>self._unique_identifier.read(<EOL>local_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>else:<EOL><INDENT>raise exceptions.InvalidKmipEncoding(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if kmip_version < enums.KMIPVersion.KMIP_2_0:<EOL><INDENT>if self.is_tag_next(enums.Tags.TEMPLATE_ATTRIBUTE, local_buffer):<EOL><INDENT>self._template_attribute = objects.TemplateAttribute()<EOL>self._template_attribute.read(<EOL>local_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT><DEDENT>self.is_oversized(local_buffer)<EOL>", "docstring": "Read the data encoding the DeriveKey response payload and decode it\ninto its constituent parts.\n\nArgs:\n    input_buffer (stream): A data stream containing encoded object\n        data, supporting a read method; usually a BytearrayStream\n        object.\n    kmip_version (KMIPVersion): An enumeration defining the KMIP\n        version with which the object will be decoded. Optional,\n        defaults to KMIP 1.0.\n\nRaises:\n    ValueError: Raised if the data attribute is missing from the\n        encoded payload.", "id": "f15096:c1:m5"}
{"signature": "def __init__(self,<EOL>unique_identifier=None,<EOL>key_format_type=None,<EOL>key_compression_type=None,<EOL>key_wrapping_specification=None):", "body": "super(GetRequestPayload, self).__init__(<EOL>enums.Tags.REQUEST_PAYLOAD<EOL>)<EOL>self._unique_identifier = None<EOL>self._key_format_type = None<EOL>self._key_compression_type = None<EOL>self._key_wrapping_specification = None<EOL>self.unique_identifier = unique_identifier<EOL>self.key_format_type = key_format_type<EOL>self.key_compression_type = key_compression_type<EOL>self.key_wrapping_specification = key_wrapping_specification<EOL>", "docstring": "Construct a Get request payload struct.\n\nArgs:\n    unique_identifier (string): The ID of the managed object (e.g., a\n        symmetric key) to retrieve. Optional, defaults to None.\n    key_format_type (KeyFormatType): A KeyFormatType enumeration that\n        specifies the format in which the object should be returned.\n        Optional, defaults to None.\n    key_compression_type (KeyCompressionType): A KeyCompressionType\n        enumeration that specifies the compression method to be used\n        when returning elliptic curve public keys. Optional, defaults\n        to None.\n    key_wrapping_specification (KeyWrappingSpecification): A\n        KeyWrappingSpecification struct that specifies keys and other\n        information for wrapping the returned object. Optional,\n        defaults to None.", "id": "f15097:c0:m0"}
{"signature": "def read(self, input_stream, kmip_version=enums.KMIPVersion.KMIP_1_0):", "body": "super(EncryptRequestPayload, self).read(<EOL>input_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL>local_stream = utils.BytearrayStream(input_stream.read(self.length))<EOL>if self.is_tag_next(enums.Tags.UNIQUE_IDENTIFIER, local_stream):<EOL><INDENT>self._unique_identifier = primitives.TextString(<EOL>tag=enums.Tags.UNIQUE_IDENTIFIER<EOL>)<EOL>self._unique_identifier.read(<EOL>local_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>if self.is_tag_next(<EOL>enums.Tags.CRYPTOGRAPHIC_PARAMETERS,<EOL>local_stream<EOL>):<EOL><INDENT>self._cryptographic_parameters =attributes.CryptographicParameters()<EOL>self._cryptographic_parameters.read(<EOL>local_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>if self.is_tag_next(enums.Tags.DATA, local_stream):<EOL><INDENT>self._data = primitives.ByteString(tag=enums.Tags.DATA)<EOL>self._data.read(local_stream, kmip_version=kmip_version)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if self.is_tag_next(enums.Tags.IV_COUNTER_NONCE, local_stream):<EOL><INDENT>self._iv_counter_nonce = primitives.ByteString(<EOL>tag=enums.Tags.IV_COUNTER_NONCE<EOL>)<EOL>self._iv_counter_nonce.read(<EOL>local_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>self.is_oversized(local_stream)<EOL>", "docstring": "Read the data encoding the Encrypt request payload and decode it\ninto its constituent parts.\n\nArgs:\n    input_stream (stream): A data stream containing encoded object\n        data, supporting a read method; usually a BytearrayStream\n        object.\n    kmip_version (KMIPVersion): An enumeration defining the KMIP\n        version with which the object will be decoded. Optional,\n        defaults to KMIP 1.0.\n\nRaises:\n    ValueError: Raised if the data attribute is missing from the\n        encoded payload.", "id": "f15098:c0:m9"}
{"signature": "def write(self, output_buffer, kmip_version=enums.KMIPVersion.KMIP_1_0):", "body": "local_buffer = utils.BytearrayStream()<EOL>if self._located_items:<EOL><INDENT>self._located_items.write(local_buffer, kmip_version=kmip_version)<EOL><DEDENT>if self._unique_identifiers:<EOL><INDENT>for unique_identifier in self._unique_identifiers:<EOL><INDENT>unique_identifier.write(<EOL>local_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT><DEDENT>self.length = local_buffer.length()<EOL>super(LocateResponsePayload, self).write(<EOL>output_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL>output_buffer.write(local_buffer.buffer)<EOL>", "docstring": "Write the data encoding the Locate response payload to a buffer.\n\nArgs:\n    output_buffer (stream): A data buffer in which to encode object\n        data, supporting a write method.\n    kmip_version (KMIPVersion): An enumeration defining the KMIP\n        version with which the object will be encoded. Optional,\n        defaults to KMIP 1.0.", "id": "f15099:c1:m6"}
{"signature": "def write(self, output_buffer, kmip_version=enums.KMIPVersion.KMIP_1_0):", "body": "local_buffer = utils.BytearrayStream()<EOL>if self._maximum_items:<EOL><INDENT>self._maximum_items.write(local_buffer, kmip_version=kmip_version)<EOL><DEDENT>if self._offset_items:<EOL><INDENT>self._offset_items.write(local_buffer, kmip_version=kmip_version)<EOL><DEDENT>if self._storage_status_mask:<EOL><INDENT>self._storage_status_mask.write(<EOL>local_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>if self._object_group_member:<EOL><INDENT>self._object_group_member.write(<EOL>local_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>if kmip_version < enums.KMIPVersion.KMIP_2_0:<EOL><INDENT>if self._attributes:<EOL><INDENT>for attribute in self.attributes:<EOL><INDENT>attribute.write(<EOL>local_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if self._attributes:<EOL><INDENT>template_attribute = objects.TemplateAttribute(<EOL>attributes=self.attributes<EOL>)<EOL>attributes = objects.convert_template_attribute_to_attributes(<EOL>template_attribute<EOL>)<EOL>attributes.write(local_buffer, kmip_version=kmip_version)<EOL><DEDENT>else:<EOL><INDENT>raise exceptions.InvalidField(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT><DEDENT>self.length = local_buffer.length()<EOL>super(LocateRequestPayload, self).write(<EOL>output_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL>output_buffer.write(local_buffer.buffer)<EOL>", "docstring": "Write the data encoding the Locate request payload to a buffer.\n\nArgs:\n    output_buffer (stream): A data buffer in which to encode object\n        data, supporting a write method.\n    kmip_version (KMIPVersion): An enumeration defining the KMIP\n        version with which the object will be encoded. Optional,\n        defaults to KMIP 1.0.", "id": "f15099:c0:m12"}
{"signature": "def __init__(self, unique_identifier=None):", "body": "super(ArchiveResponsePayload, self).__init__(<EOL>enums.Tags.RESPONSE_PAYLOAD<EOL>)<EOL>self._unique_identifier = None<EOL>self.unique_identifier = unique_identifier<EOL>", "docstring": "Construct an Archive response payload struct.\n\nArgs:\n    unique_identifier (string): The ID of the managed object (e.g.,\n        a public key) that was archived. Optional, defaults to None.", "id": "f15102:c1:m0"}
{"signature": "def read(self, input_stream, kmip_version=enums.KMIPVersion.KMIP_1_0):", "body": "super(ArchiveRequestPayload, self).read(<EOL>input_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL>local_stream = utils.BytearrayStream(input_stream.read(self.length))<EOL>if self.is_tag_next(enums.Tags.UNIQUE_IDENTIFIER, local_stream):<EOL><INDENT>self._unique_identifier = primitives.TextString(<EOL>tag=enums.Tags.UNIQUE_IDENTIFIER<EOL>)<EOL>self._unique_identifier.read(<EOL>local_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>self.is_oversized(local_stream)<EOL>", "docstring": "Read the data encoding the Archive request payload and decode it into\nits constituent parts.\n\nArgs:\n    input_stream (stream): A data stream containing encoded object\n        data, supporting a read method; usually a BytearrayStream\n        object.\n    kmip_version (KMIPVersion): An enumeration defining the KMIP\n        version with which the object will be decoded. Optional,\n        defaults to KMIP 1.0.\n\nRaises:\n    ValueError: Raised if the data attribute is missing from the\n        encoded payload.", "id": "f15102:c0:m3"}
{"signature": "def write(self, output_stream, kmip_version=enums.KMIPVersion.KMIP_1_0):", "body": "local_stream = utils.BytearrayStream()<EOL>if self._unique_identifier:<EOL><INDENT>self._unique_identifier.write(<EOL>local_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>self.length = local_stream.length()<EOL>super(ArchiveRequestPayload, self).write(<EOL>output_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL>output_stream.write(local_stream.buffer)<EOL>", "docstring": "Write the data encoding the Archive request payload to a stream.\n\nArgs:\n    output_stream (stream): A data stream in which to encode object\n        data, supporting a write method; usually a BytearrayStream\n        object.\n    kmip_version (KMIPVersion): An enumeration defining the KMIP\n        version with which the object will be encoded. Optional,\n        defaults to KMIP 1.0.\n\nRaises:\n    ValueError: Raised if the data attribute is not defined.", "id": "f15102:c0:m4"}
{"signature": "def write(self, output_buffer, kmip_version=enums.KMIPVersion.KMIP_1_0):", "body": "local_buffer = utils.BytearrayStream()<EOL>if self._query_functions:<EOL><INDENT>for query_function in self._query_functions:<EOL><INDENT>query_function.write(local_buffer, kmip_version=kmip_version)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise exceptions.InvalidField(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>self.length = local_buffer.length()<EOL>super(QueryRequestPayload, self).write(<EOL>output_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL>output_buffer.write(local_buffer.buffer)<EOL>", "docstring": "Write the data encoding the QueryRequestPayload object to a stream.\n\nArgs:\n    output_buffer (Stream): A data stream in which to encode object\n        data, supporting a write method; usually a BytearrayStream\n        object.\n    kmip_version (KMIPVersion): An enumeration defining the KMIP\n        version with which the object will be encoded. Optional,\n        defaults to KMIP 1.0.\n\nRaises:\n    InvalidField: Raised if the query functions are not defined.", "id": "f15106:c0:m4"}
{"signature": "def read(self, input_buffer, kmip_version=enums.KMIPVersion.KMIP_1_0):", "body": "super(QueryResponsePayload, self).read(<EOL>input_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL>local_buffer = utils.BytearrayStream(input_buffer.read(self.length))<EOL>operations = []<EOL>while(self.is_tag_next(enums.Tags.OPERATION, local_buffer)):<EOL><INDENT>operation = primitives.Enumeration(<EOL>enums.Operation,<EOL>tag=enums.Tags.OPERATION<EOL>)<EOL>operation.read(local_buffer, kmip_version=kmip_version)<EOL>operations.append(operation)<EOL><DEDENT>self._operations = operations<EOL>object_types = []<EOL>while(self.is_tag_next(enums.Tags.OBJECT_TYPE, local_buffer)):<EOL><INDENT>object_type = primitives.Enumeration(<EOL>enums.ObjectType,<EOL>tag=enums.Tags.OBJECT_TYPE<EOL>)<EOL>object_type.read(local_buffer, kmip_version=kmip_version)<EOL>object_types.append(object_type)<EOL><DEDENT>self._object_types = object_types<EOL>if self.is_tag_next(enums.Tags.VENDOR_IDENTIFICATION, local_buffer):<EOL><INDENT>vendor_identification = primitives.TextString(<EOL>tag=enums.Tags.VENDOR_IDENTIFICATION<EOL>)<EOL>vendor_identification.read(<EOL>local_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL>self._vendor_identification = vendor_identification<EOL><DEDENT>if self.is_tag_next(enums.Tags.SERVER_INFORMATION, local_buffer):<EOL><INDENT>server_information = misc.ServerInformation()<EOL>server_information.read(<EOL>local_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL>self._server_information = server_information<EOL><DEDENT>application_namespaces = []<EOL>while(self.is_tag_next(<EOL>enums.Tags.APPLICATION_NAMESPACE,<EOL>local_buffer<EOL>)<EOL>):<EOL><INDENT>application_namespace = primitives.TextString(<EOL>tag=enums.Tags.APPLICATION_NAMESPACE<EOL>)<EOL>application_namespace.read(local_buffer, kmip_version=kmip_version)<EOL>application_namespaces.append(application_namespace)<EOL><DEDENT>self._application_namespaces = application_namespaces<EOL>if kmip_version >= enums.KMIPVersion.KMIP_1_1:<EOL><INDENT>extensions_information = []<EOL>while(self.is_tag_next(<EOL>enums.Tags.EXTENSION_INFORMATION,<EOL>local_buffer<EOL>)<EOL>):<EOL><INDENT>extension_information = objects.ExtensionInformation()<EOL>extension_information.read(<EOL>local_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL>extensions_information.append(extension_information)<EOL><DEDENT>self._extension_information = extensions_information<EOL><DEDENT>if kmip_version >= enums.KMIPVersion.KMIP_1_2:<EOL><INDENT>attestation_types = []<EOL>while(self.is_tag_next(enums.Tags.ATTESTATION_TYPE, local_buffer)):<EOL><INDENT>attestation_type = primitives.Enumeration(<EOL>enums.AttestationType,<EOL>tag=enums.Tags.ATTESTATION_TYPE<EOL>)<EOL>attestation_type.read(local_buffer, kmip_version=kmip_version)<EOL>attestation_types.append(attestation_type)<EOL><DEDENT>self._attestation_types = attestation_types<EOL><DEDENT>if kmip_version >= enums.KMIPVersion.KMIP_1_3:<EOL><INDENT>rngs_parameters = []<EOL>while(self.is_tag_next(enums.Tags.RNG_PARAMETERS, local_buffer)):<EOL><INDENT>rng_parameters = objects.RNGParameters()<EOL>rng_parameters.read(local_buffer, kmip_version=kmip_version)<EOL>rngs_parameters.append(rng_parameters)<EOL><DEDENT>self._rng_parameters = rngs_parameters<EOL>profiles_information = []<EOL>while(self.is_tag_next(<EOL>enums.Tags.PROFILE_INFORMATION,<EOL>local_buffer<EOL>)<EOL>):<EOL><INDENT>profile_information = objects.ProfileInformation()<EOL>profile_information.read(<EOL>local_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL>profiles_information.append(profile_information)<EOL><DEDENT>self._profile_information = profiles_information<EOL>validations_information = []<EOL>while(self.is_tag_next(<EOL>enums.Tags.VALIDATION_INFORMATION,<EOL>local_buffer<EOL>)<EOL>):<EOL><INDENT>validation_information = objects.ValidationInformation()<EOL>validation_information.read(<EOL>local_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL>validations_information.append(validation_information)<EOL><DEDENT>self._validation_information = validations_information<EOL>capabilities_information = []<EOL>while(self.is_tag_next(<EOL>enums.Tags.CAPABILITY_INFORMATION,<EOL>local_buffer<EOL>)<EOL>):<EOL><INDENT>capability_information = objects.CapabilityInformation()<EOL>capability_information.read(<EOL>local_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL>capabilities_information.append(capability_information)<EOL><DEDENT>self._capability_information = capabilities_information<EOL>client_registration_methods = []<EOL>while(self.is_tag_next(<EOL>enums.Tags.CLIENT_REGISTRATION_METHOD,<EOL>local_buffer<EOL>)<EOL>):<EOL><INDENT>client_registration_method = primitives.Enumeration(<EOL>enums.ClientRegistrationMethod,<EOL>tag=enums.Tags.CLIENT_REGISTRATION_METHOD<EOL>)<EOL>client_registration_method.read(<EOL>local_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL>client_registration_methods.append(client_registration_method)<EOL><DEDENT>self._client_registration_methods = client_registration_methods<EOL><DEDENT>if kmip_version >= enums.KMIPVersion.KMIP_2_0:<EOL><INDENT>if self.is_tag_next(enums.Tags.DEFAULTS_INFORMATION, local_buffer):<EOL><INDENT>defaults_information = objects.DefaultsInformation()<EOL>defaults_information.read(<EOL>local_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL>self._defaults_information = defaults_information<EOL><DEDENT>storage_protection_masks = []<EOL>while(self.is_tag_next(<EOL>enums.Tags.PROTECTION_STORAGE_MASK,<EOL>local_buffer<EOL>)<EOL>):<EOL><INDENT>storage_protection_mask = primitives.Integer(<EOL>tag=enums.Tags.PROTECTION_STORAGE_MASK<EOL>)<EOL>storage_protection_mask.read(<EOL>local_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL>storage_protection_masks.append(storage_protection_mask)<EOL><DEDENT>self._storage_protection_masks = storage_protection_masks<EOL><DEDENT>self.is_oversized(local_buffer)<EOL>", "docstring": "Read the data encoding the QueryResponsePayload object and decode it\ninto its constituent parts.\n\nArgs:\n    input_buffer (Stream): A data stream containing encoded object\n        data, supporting a read method; usually a BytearrayStream\n        object.\n    kmip_version (KMIPVersion): An enumeration defining the KMIP\n        version with which the object will be decoded. Optional,\n        defaults to KMIP 1.0.", "id": "f15106:c1:m29"}
{"signature": "def read(self, input_buffer, kmip_version=enums.KMIPVersion.KMIP_1_0):", "body": "super(QueryRequestPayload, self).read(<EOL>input_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL>local_buffer = utils.BytearrayStream(input_buffer.read(self.length))<EOL>query_functions = []<EOL>while(self.is_tag_next(enums.Tags.QUERY_FUNCTION, local_buffer)):<EOL><INDENT>query_function = primitives.Enumeration(<EOL>enums.QueryFunction,<EOL>tag=enums.Tags.QUERY_FUNCTION<EOL>)<EOL>query_function.read(local_buffer, kmip_version=kmip_version)<EOL>query_functions.append(query_function)<EOL><DEDENT>if query_functions:<EOL><INDENT>self._query_functions = query_functions<EOL><DEDENT>else:<EOL><INDENT>raise exceptions.InvalidKmipEncoding(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>self.is_oversized(local_buffer)<EOL>", "docstring": "Read the data encoding the QueryRequestPayload object and decode it\ninto its constituent parts.\n\nArgs:\n    input_buffer (Stream): A data stream containing encoded object\n        data, supporting a read method; usually a BytearrayStream\n        object.\n    kmip_version (KMIPVersion): An enumeration defining the KMIP\n        version with which the object will be decoded. Optional,\n        defaults to KMIP 1.0.\n\nRaises:\n    InvalidKmipEncoding: Raised if the query functions are missing\n        from the encoded payload.", "id": "f15106:c0:m3"}
{"signature": "def write(self, output_stream, kmip_version=enums.KMIPVersion.KMIP_1_0):", "body": "local_stream = utils.BytearrayStream()<EOL>if self._unique_identifier:<EOL><INDENT>self._unique_identifier.write(<EOL>local_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>if self._cryptographic_parameters:<EOL><INDENT>self._cryptographic_parameters.write(<EOL>local_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>if self._data:<EOL><INDENT>self._data.write(local_stream, kmip_version=kmip_version)<EOL><DEDENT>if self._digested_data:<EOL><INDENT>self._digested_data.write(local_stream, kmip_version=kmip_version)<EOL><DEDENT>if self._signature_data:<EOL><INDENT>self._signature_data.write(<EOL>local_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>if self._correlation_value:<EOL><INDENT>self._correlation_value.write(<EOL>local_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>if self._init_indicator:<EOL><INDENT>self._init_indicator.write(<EOL>local_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>if self._final_indicator:<EOL><INDENT>self._final_indicator.write(<EOL>local_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>self.length = local_stream.length()<EOL>super(SignatureVerifyRequestPayload, self).write(<EOL>output_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL>output_stream.write(local_stream.buffer)<EOL>", "docstring": "Write the data encoding the SignatureVerify request payload to a\nstream.\n\nArgs:\n    output_stream (stream): A data stream in which to encode object\n        data, supporting a write method; usually a BytearrayStream\n        object.\n    kmip_version (KMIPVersion): An enumeration defining the KMIP\n        version with which the object will be encoded. Optional,\n        defaults to KMIP 1.0.\n\nRaises:\n    ValueError: Raised if the data attribute is not defined.", "id": "f15107:c0:m18"}
{"signature": "def read(self, input_stream, kmip_version=enums.KMIPVersion.KMIP_1_0):", "body": "super(SignatureVerifyRequestPayload, self).read(<EOL>input_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL>local_stream = utils.BytearrayStream(input_stream.read(self.length))<EOL>if self.is_tag_next(enums.Tags.UNIQUE_IDENTIFIER, local_stream):<EOL><INDENT>self._unique_identifier = primitives.TextString(<EOL>tag=enums.Tags.UNIQUE_IDENTIFIER<EOL>)<EOL>self._unique_identifier.read(<EOL>local_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>if self.is_tag_next(enums.Tags.CRYPTOGRAPHIC_PARAMETERS, local_stream):<EOL><INDENT>self._cryptographic_parameters =attributes.CryptographicParameters()<EOL>self._cryptographic_parameters.read(<EOL>local_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>if self.is_tag_next(enums.Tags.DATA, local_stream):<EOL><INDENT>self._data = primitives.ByteString(tag=enums.Tags.DATA)<EOL>self._data.read(local_stream, kmip_version=kmip_version)<EOL><DEDENT>if self.is_tag_next(enums.Tags.DIGESTED_DATA, local_stream):<EOL><INDENT>self._digested_data = primitives.ByteString(<EOL>tag=enums.Tags.DIGESTED_DATA<EOL>)<EOL>self._digested_data.read(local_stream, kmip_version=kmip_version)<EOL><DEDENT>if self.is_tag_next(enums.Tags.SIGNATURE_DATA, local_stream):<EOL><INDENT>self._signature_data = primitives.ByteString(<EOL>tag=enums.Tags.SIGNATURE_DATA<EOL>)<EOL>self._signature_data.read(local_stream, kmip_version=kmip_version)<EOL><DEDENT>if self.is_tag_next(enums.Tags.CORRELATION_VALUE, local_stream):<EOL><INDENT>self._correlation_value = primitives.ByteString(<EOL>tag=enums.Tags.CORRELATION_VALUE<EOL>)<EOL>self._correlation_value.read(<EOL>local_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>if self.is_tag_next(enums.Tags.INIT_INDICATOR, local_stream):<EOL><INDENT>self._init_indicator = primitives.Boolean(<EOL>tag=enums.Tags.INIT_INDICATOR<EOL>)<EOL>self._init_indicator.read(local_stream, kmip_version=kmip_version)<EOL><DEDENT>if self.is_tag_next(enums.Tags.FINAL_INDICATOR, local_stream):<EOL><INDENT>self._final_indicator = primitives.Boolean(<EOL>tag=enums.Tags.FINAL_INDICATOR<EOL>)<EOL>self._final_indicator.read(local_stream, kmip_version=kmip_version)<EOL><DEDENT>self.is_oversized(local_stream)<EOL>", "docstring": "Read the data encoding the SignatureVerify request payload and decode\nit into its constituent parts.\n\nArgs:\n    input_stream (stream): A data stream containing encoded object\n        data, supporting a read method; usually a BytearrayStream\n        object.\n    kmip_version (KMIPVersion): An enumeration defining the KMIP\n        version with which the object will be decoded. Optional,\n        defaults to KMIP 1.0.\n\nRaises:\n    ValueError: Raised if the data attribute is missing from the\n        encoded payload.", "id": "f15107:c0:m17"}
{"signature": "def __init__(self,<EOL>unique_identifier=None,<EOL>validity_indicator=None,<EOL>data=None,<EOL>correlation_value=None):", "body": "super(SignatureVerifyResponsePayload, self).__init__(<EOL>enums.Tags.RESPONSE_PAYLOAD<EOL>)<EOL>self._unique_identifier = None<EOL>self._validity_indicator = None<EOL>self._data = None<EOL>self._correlation_value = None<EOL>self.unique_identifier = unique_identifier<EOL>self.validity_indicator = validity_indicator<EOL>self.data = data<EOL>self.correlation_value = correlation_value<EOL>", "docstring": "Construct a SignatureVerify response payload struct.\n\nArgs:\n    unique_identifier (string): The ID of the managed object (e.g.,\n        a public key) used for signature verification. Optional,\n        defaults to None. Required for read/write.\n    validity_indicator (ValidityIndicator): A ValidityIndicator\n        enumeration that specifies the validity of the signature.\n        Optional, defaults to None. Required for read/write.\n    data (bytes): The bytes representing any data recovered during the\n        signature verification process. Optional, defaults to None.\n    correlation_value (bytes): The bytes representing a correlation\n        value, allowing the linking together of individual payloads\n        for a single overarching operation. Optional, defaults to None.", "id": "f15107:c1:m0"}
{"signature": "def write(self, output_stream, kmip_version=enums.KMIPVersion.KMIP_1_0):", "body": "local_stream = utils.BytearrayStream()<EOL>if self._unique_identifier:<EOL><INDENT>self._unique_identifier.write(<EOL>local_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>if self._usage_limits_count:<EOL><INDENT>self._usage_limits_count.write(<EOL>local_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>if self._cryptographic_usage_mask:<EOL><INDENT>self._cryptographic_usage_mask.write(<EOL>local_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>if self._lease_time:<EOL><INDENT>self._lease_time.write(<EOL>local_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>self.length = local_stream.length()<EOL>super(CheckResponsePayload, self).write(<EOL>output_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL>output_stream.write(local_stream.buffer)<EOL>", "docstring": "Write the data encoding the Check response payload to a stream.\n\nArgs:\n    output_stream (stream): A data stream in which to encode object\n        data, supporting a write method; usually a BytearrayStream\n        object.\n    kmip_version (KMIPVersion): An enumeration defining the KMIP\n        version with which the object will be encoded. Optional,\n        defaults to KMIP 1.0.\n\nRaises:\n    ValueError: Raised if the data attribute is not defined.", "id": "f15108:c1:m10"}
{"signature": "def write(self, output_stream, kmip_version=enums.KMIPVersion.KMIP_1_0):", "body": "local_stream = utils.BytearrayStream()<EOL>if self._unique_identifier:<EOL><INDENT>self._unique_identifier.write(<EOL>local_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>if self._usage_limits_count:<EOL><INDENT>self._usage_limits_count.write(<EOL>local_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>if self._cryptographic_usage_mask:<EOL><INDENT>self._cryptographic_usage_mask.write(<EOL>local_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>if self._lease_time:<EOL><INDENT>self._lease_time.write(<EOL>local_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>self.length = local_stream.length()<EOL>super(CheckRequestPayload, self).write(<EOL>output_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL>output_stream.write(local_stream.buffer)<EOL>", "docstring": "Write the data encoding the Check request payload to a stream.\n\nArgs:\n    output_stream (stream): A data stream in which to encode object\n        data, supporting a write method; usually a BytearrayStream\n        object.\n    kmip_version (KMIPVersion): An enumeration defining the KMIP\n        version with which the object will be encoded. Optional,\n        defaults to KMIP 1.0.\n\nRaises:\n    ValueError: Raised if the data attribute is not defined.", "id": "f15108:c0:m10"}
{"signature": "def read(self, input_buffer, kmip_version=enums.KMIPVersion.KMIP_1_0):", "body": "super(RegisterResponsePayload, self).read(<EOL>input_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL>local_buffer = utils.BytearrayStream(input_buffer.read(self.length))<EOL>if self.is_tag_next(enums.Tags.UNIQUE_IDENTIFIER, local_buffer):<EOL><INDENT>self._unique_identifier = primitives.TextString(<EOL>tag=enums.Tags.UNIQUE_IDENTIFIER<EOL>)<EOL>self._unique_identifier.read(<EOL>local_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>else:<EOL><INDENT>raise exceptions.InvalidKmipEncoding(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if kmip_version < enums.KMIPVersion.KMIP_2_0:<EOL><INDENT>if self.is_tag_next(enums.Tags.TEMPLATE_ATTRIBUTE, local_buffer):<EOL><INDENT>self._template_attribute = objects.TemplateAttribute()<EOL>self._template_attribute.read(<EOL>local_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT><DEDENT>self.is_oversized(local_buffer)<EOL>", "docstring": "Read the data encoding the Register response payload and decode it\ninto its constituent parts.\n\nArgs:\n    input_buffer (stream): A data buffer containing encoded object\n        data, supporting a read method.\n    kmip_version (KMIPVersion): An enumeration defining the KMIP\n        version with which the object will be decoded. Optional,\n        defaults to KMIP 1.0.\n\nRaises:\n    InvalidKmipEncoding: Raised if the unique identifier is missing\n        from the encoded payload.", "id": "f15110:c1:m5"}
{"signature": "def write(self, output_buffer, kmip_version=enums.KMIPVersion.KMIP_1_0):", "body": "local_buffer = utils.BytearrayStream()<EOL>if self._unique_identifier:<EOL><INDENT>self._unique_identifier.write(<EOL>local_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>if kmip_version < enums.KMIPVersion.KMIP_2_0:<EOL><INDENT>for attribute_name in self._attribute_names:<EOL><INDENT>attribute_name.write(local_buffer, kmip_version=kmip_version)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for attribute_name in self._attribute_names:<EOL><INDENT>t = enums.convert_attribute_name_to_tag(attribute_name.value)<EOL>e = primitives.Enumeration(<EOL>enums.Tags,<EOL>value=t,<EOL>tag=enums.Tags.ATTRIBUTE_REFERENCE<EOL>)<EOL>e.write(local_buffer, kmip_version=kmip_version)<EOL><DEDENT><DEDENT>self.length = local_buffer.length()<EOL>super(GetAttributesRequestPayload, self).write(<EOL>output_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL>output_buffer.write(local_buffer.buffer)<EOL>", "docstring": "Write the data encoding the GetAttributes request payload to a\nstream.\n\nArgs:\n    output_buffer (stream): A data stream in which to encode object\n        data, supporting a write method; usually a BytearrayStream\n        object.\n    kmip_version (KMIPVersion): An enumeration defining the KMIP\n        version with which the object will be encoded. Optional,\n        defaults to KMIP 1.0.", "id": "f15111:c0:m6"}
{"signature": "def __init__(self, unique_identifier=None, attributes=None):", "body": "super(GetAttributesResponsePayload, self).__init__(<EOL>enums.Tags.RESPONSE_PAYLOAD)<EOL>self._unique_identifier = None<EOL>self._attributes = list()<EOL>self.unique_identifier = unique_identifier<EOL>self.attributes = attributes<EOL>", "docstring": "Construct a GetAttributes response payload.\n\nArgs:\n    unique_identifier (string): The ID of the managed object with\n        which the retrieved attributes should be associated. Optional,\n        defaults to None.\n    attributes (list): A list of attribute structures associated with\n        the managed object. Optional, defaults to None.", "id": "f15111:c1:m0"}
{"signature": "def read(self, input_buffer, kmip_version=enums.KMIPVersion.KMIP_1_0):", "body": "super(GetAttributesRequestPayload, self).read(<EOL>input_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL>local_buffer = utils.BytearrayStream(input_buffer.read(self.length))<EOL>if self.is_tag_next(enums.Tags.UNIQUE_IDENTIFIER, local_buffer):<EOL><INDENT>self._unique_identifier = primitives.TextString(<EOL>tag=enums.Tags.UNIQUE_IDENTIFIER<EOL>)<EOL>self._unique_identifier.read(<EOL>local_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>else:<EOL><INDENT>self._unique_identifier = None<EOL><DEDENT>names = list()<EOL>if kmip_version < enums.KMIPVersion.KMIP_2_0:<EOL><INDENT>while self.is_tag_next(enums.Tags.ATTRIBUTE_NAME, local_buffer):<EOL><INDENT>name = primitives.TextString(tag=enums.Tags.ATTRIBUTE_NAME)<EOL>name.read(local_buffer, kmip_version=kmip_version)<EOL>names.append(name)<EOL><DEDENT>self._attribute_names = names<EOL><DEDENT>else:<EOL><INDENT>while self.is_tag_next(<EOL>enums.Tags.ATTRIBUTE_REFERENCE,<EOL>local_buffer<EOL>):<EOL><INDENT>if self.is_type_next(enums.Types.STRUCTURE, local_buffer):<EOL><INDENT>reference = objects.AttributeReference()<EOL>reference.read(local_buffer, kmip_version=kmip_version)<EOL>names.append(<EOL>primitives.TextString(<EOL>value=reference.attribute_name,<EOL>tag=enums.Tags.ATTRIBUTE_NAME<EOL>)<EOL>)<EOL><DEDENT>elif self.is_type_next(enums.Types.ENUMERATION, local_buffer):<EOL><INDENT>reference = primitives.Enumeration(<EOL>enums.Tags,<EOL>tag=enums.Tags.ATTRIBUTE_REFERENCE<EOL>)<EOL>reference.read(local_buffer, kmip_version=kmip_version)<EOL>name = enums.convert_attribute_tag_to_name(reference.value)<EOL>names.append(<EOL>primitives.TextString(<EOL>value=name,<EOL>tag=enums.Tags.ATTRIBUTE_NAME<EOL>)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>raise exceptions.InvalidKmipEncoding(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT><DEDENT>self._attribute_names = names<EOL><DEDENT>self.is_oversized(local_buffer)<EOL>", "docstring": "Read the data encoding the GetAttributes request payload and decode\nit into its constituent parts.\n\nArgs:\n    input_buffer (stream): A data stream containing encoded object\n        data, supporting a read method; usually a BytearrayStream\n        object.\n    kmip_version (KMIPVersion): An enumeration defining the KMIP\n        version with which the object will be decoded. Optional,\n        defaults to KMIP 1.0.\n\nRaises:\n    InvalidKmipEncoding: Raised if an invalid type is found for the\n        AttributeReference encoding for KMIP 2.0+ encodings.", "id": "f15111:c0:m5"}
{"signature": "def read(self, input_buffer, kmip_version=enums.KMIPVersion.KMIP_1_0):", "body": "super(CreateKeyPairRequestPayload, self).read(<EOL>input_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL>local_buffer = utils.BytearrayStream(input_buffer.read(self.length))<EOL>if kmip_version < enums.KMIPVersion.KMIP_2_0:<EOL><INDENT>if self.is_tag_next(<EOL>enums.Tags.COMMON_TEMPLATE_ATTRIBUTE,<EOL>local_buffer<EOL>):<EOL><INDENT>self._common_template_attribute = objects.TemplateAttribute(<EOL>tag=enums.Tags.COMMON_TEMPLATE_ATTRIBUTE<EOL>)<EOL>self._common_template_attribute.read(<EOL>local_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if self.is_tag_next(enums.Tags.COMMON_ATTRIBUTES, local_buffer):<EOL><INDENT>attributes = objects.Attributes(<EOL>tag=enums.Tags.COMMON_ATTRIBUTES<EOL>)<EOL>attributes.read(local_buffer, kmip_version=kmip_version)<EOL>self._common_template_attribute =objects.convert_attributes_to_template_attribute(<EOL>attributes<EOL>)<EOL><DEDENT><DEDENT>if kmip_version < enums.KMIPVersion.KMIP_2_0:<EOL><INDENT>if self.is_tag_next(<EOL>enums.Tags.PRIVATE_KEY_TEMPLATE_ATTRIBUTE,<EOL>local_buffer<EOL>):<EOL><INDENT>self._private_key_template_attribute =objects.TemplateAttribute(<EOL>tag=enums.Tags.PRIVATE_KEY_TEMPLATE_ATTRIBUTE<EOL>)<EOL>self._private_key_template_attribute.read(<EOL>local_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if self.is_tag_next(<EOL>enums.Tags.PRIVATE_KEY_ATTRIBUTES,<EOL>local_buffer<EOL>):<EOL><INDENT>attributes = objects.Attributes(<EOL>tag=enums.Tags.PRIVATE_KEY_ATTRIBUTES<EOL>)<EOL>attributes.read(local_buffer, kmip_version=kmip_version)<EOL>self._private_key_template_attribute =objects.convert_attributes_to_template_attribute(<EOL>attributes<EOL>)<EOL><DEDENT><DEDENT>if kmip_version < enums.KMIPVersion.KMIP_2_0:<EOL><INDENT>if self.is_tag_next(<EOL>enums.Tags.PUBLIC_KEY_TEMPLATE_ATTRIBUTE,<EOL>local_buffer<EOL>):<EOL><INDENT>self._public_key_template_attribute =objects.TemplateAttribute(<EOL>tag=enums.Tags.PUBLIC_KEY_TEMPLATE_ATTRIBUTE<EOL>)<EOL>self._public_key_template_attribute.read(<EOL>local_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if self.is_tag_next(<EOL>enums.Tags.PUBLIC_KEY_ATTRIBUTES,<EOL>local_buffer<EOL>):<EOL><INDENT>attributes = objects.Attributes(<EOL>tag=enums.Tags.PUBLIC_KEY_ATTRIBUTES<EOL>)<EOL>attributes.read(local_buffer, kmip_version=kmip_version)<EOL>self._public_key_template_attribute =objects.convert_attributes_to_template_attribute(<EOL>attributes<EOL>)<EOL><DEDENT><DEDENT>self.is_oversized(local_buffer)<EOL>", "docstring": "Read the data encoding the CreateKeyPair request payload and decode it\ninto its constituent parts.\n\nArgs:\n    input_buffer (stream): A data buffer containing encoded object\n        data, supporting a read method.\n    kmip_version (KMIPVersion): An enumeration defining the KMIP\n        version with which the object will be decoded. Optional,\n        defaults to KMIP 1.0.", "id": "f15112:c0:m7"}
{"signature": "def write(self, output_buffer, kmip_version=enums.KMIPVersion.KMIP_1_0):", "body": "local_buffer = utils.BytearrayStream()<EOL>if self._private_key_unique_identifier:<EOL><INDENT>self._private_key_unique_identifier.write(<EOL>local_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>else:<EOL><INDENT>raise exceptions.InvalidField(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if self._public_key_unique_identifier:<EOL><INDENT>self._public_key_unique_identifier.write(<EOL>local_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>else:<EOL><INDENT>raise exceptions.InvalidField(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if self._private_key_template_attribute:<EOL><INDENT>self._private_key_template_attribute.write(<EOL>local_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>if self._public_key_template_attribute:<EOL><INDENT>self._public_key_template_attribute.write(<EOL>local_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL><DEDENT>self.length = local_buffer.length()<EOL>super(CreateKeyPairResponsePayload, self).write(<EOL>output_buffer,<EOL>kmip_version=kmip_version<EOL>)<EOL>output_buffer.write(local_buffer.buffer)<EOL>", "docstring": "Write the data encoding the CreateKeyPair response payload to a buffer.\n\nArgs:\n    output_buffer (stream): A data buffer in which to encode object\n        data, supporting a write method.\n    kmip_version (KMIPVersion): An enumeration defining the KMIP\n        version with which the object will be encoded. Optional,\n        defaults to KMIP 1.0.\n\nRaises:\n    InvalidField: Raised if the private key unique identifier or the\n        public key unique identifier is not defined.", "id": "f15112:c1:m10"}
{"signature": "def read(self, istream, kmip_version=enums.KMIPVersion.KMIP_1_0):", "body": "super(ActivateResponsePayload, self).read(<EOL>istream,<EOL>kmip_version=kmip_version<EOL>)<EOL>tstream = BytearrayStream(istream.read(self.length))<EOL>self.unique_identifier = attributes.UniqueIdentifier()<EOL>self.unique_identifier.read(tstream, kmip_version=kmip_version)<EOL>self.is_oversized(tstream)<EOL>self.validate()<EOL>", "docstring": "Read the data encoding the ActivateResponsePayload object and decode it\ninto its constituent parts.\n\nArgs:\n    istream (Stream): A data stream containing encoded object data,\n        supporting a read method; usually a BytearrayStream object.\n    kmip_version (KMIPVersion): An enumeration defining the KMIP\n        version with which the object will be decoded. Optional,\n        defaults to KMIP 1.0.", "id": "f15113:c1:m1"}
{"signature": "def write(self, ostream, kmip_version=enums.KMIPVersion.KMIP_1_0):", "body": "tstream = BytearrayStream()<EOL>if self.unique_identifier is not None:<EOL><INDENT>self.unique_identifier.write(tstream, kmip_version=kmip_version)<EOL><DEDENT>self.length = tstream.length()<EOL>super(ActivateRequestPayload, self).write(<EOL>ostream,<EOL>kmip_version=kmip_version<EOL>)<EOL>ostream.write(tstream.buffer)<EOL>", "docstring": "Write the data encoding the ActivateRequestPayload object to a stream.\nArgs:\n    ostream (Stream): A data stream in which to encode object data,\n        supporting a write method; usually a BytearrayStream object.\n    kmip_version (KMIPVersion): An enumeration defining the KMIP\n        version with which the object will be encoded. Optional,\n        defaults to KMIP 1.0.", "id": "f15113:c0:m2"}
{"signature": "def read(self, input_stream, kmip_version=enums.KMIPVersion.KMIP_1_0):", "body": "super(Authentication, self).read(<EOL>input_stream,<EOL>kmip_version=kmip_version<EOL>)<EOL>local_stream = utils.BytearrayStream(input_stream.read(self.length))<EOL>credentials = []<EOL>while self.is_tag_next(enums.Tags.CREDENTIAL, local_stream):<EOL><INDENT>credential = objects.Credential()<EOL>credential.read(local_stream, kmip_version=kmip_version)<EOL>credentials.append(credential)<EOL><DEDENT>if len(credentials) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self._credentials = credentials<EOL>self.is_oversized(local_stream)<EOL>", "docstring": "Read the data encoding the Authentication struct and decode it into\nits constituent parts.\n\nArgs:\n    input_stream (stream): A data stream containing encoded object\n        data, supporting a read method; usually a BytearrayStream\n        object.\n    kmip_version (KMIPVersion): An enumeration defining the KMIP\n        version with which the object will be decoded. Optional,\n        defaults to KMIP 1.0.", "id": "f15118:c5:m3"}
{"signature": "def __init__(self, message):", "body": "super(KeyFormatTypeNotSupported, self).__init__(<EOL>reason=enums.ResultReason.KEY_FORMAT_TYPE_NOT_SUPPORTED,<EOL>message=message<EOL>)<EOL>", "docstring": "Create a KeyFormatTypeNotSupported exception.\n\nArgs:\n    message (string): A string containing information about the error.", "id": "f15119:c9:m0"}
{"signature": "def __init__(self, message):", "body": "super(IllegalOperation, self).__init__(<EOL>reason=enums.ResultReason.ILLEGAL_OPERATION,<EOL>message=message<EOL>)<EOL>", "docstring": "Create an IllegalOperation exception.\n\nArgs:\n    message (string): A string containing information about the error.", "id": "f15119:c3:m0"}
{"signature": "def __init__(self, message):", "body": "super(InvalidMessage, self).__init__(<EOL>reason=enums.ResultReason.INVALID_MESSAGE,<EOL>message=message<EOL>)<EOL>", "docstring": "Create an InvalidMessage exception.\n\nArgs:\n    message (string): A string containing information about the error.", "id": "f15119:c6:m0"}
{"signature": "def __init__(self, message):", "body": "super(PermissionDenied, self).__init__(<EOL>reason=enums.ResultReason.PERMISSION_DENIED,<EOL>message=message<EOL>)<EOL>", "docstring": "Create a PermissionDenied exception.\n\nArgs:\n    message (string): A string containing information about the error.", "id": "f15119:c11:m0"}
{"signature": "def __init__(self, cipher_suites=None):", "body": "super(TLS12AuthenticationSuite, self).__init__(cipher_suites)<EOL>self._protocol = ssl.PROTOCOL_TLSv1_2<EOL>", "docstring": "Create a TLS12AuthenticationSuite object.\n\nArgs:\n    cipher_suites (list): A list of strings representing the names of\n        cipher suites to use. Overrides the default set of cipher\n        suites. Optional, defaults to None.", "id": "f15152:c2:m0"}
{"signature": "def __init__(self, cipher_suites=None):", "body": "super(BasicAuthenticationSuite, self).__init__(cipher_suites)<EOL>self._protocol = ssl.PROTOCOL_TLSv1<EOL>", "docstring": "Create a BasicAuthenticationSuite object.\n\nArgs:\n    cipher_suites (list): A list of strings representing the names of\n        cipher suites to use. Overrides the default set of cipher\n        suites. Optional, defaults to None.", "id": "f15152:c1:m0"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def __init__(self, cipher_suites=None):<DEDENT>", "body": "self._custom_suites = []<EOL>if cipher_suites:<EOL><INDENT>for cipher_suite in cipher_suites:<EOL><INDENT>if cipher_suite in self.openssl_cipher_suite_map.keys():<EOL><INDENT>suite = self.openssl_cipher_suite_map.get(cipher_suite)<EOL>if suite:<EOL><INDENT>self._custom_suites.append(suite)<EOL><DEDENT><DEDENT>elif cipher_suite in self.openssl_cipher_suite_map.values():<EOL><INDENT>if cipher_suite:<EOL><INDENT>self._custom_suites.append(cipher_suite)<EOL><DEDENT><DEDENT><DEDENT>self._custom_suites = list(set(self._custom_suites))<EOL><DEDENT>suites = []<EOL>if self._custom_suites:<EOL><INDENT>for suite in self._custom_suites:<EOL><INDENT>if suite in self._default_cipher_suites:<EOL><INDENT>suites.append(suite)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>suites = self._default_cipher_suites<EOL><DEDENT>self._cipher_suites = '<STR_LIT::>'.join(suites)<EOL>if self._cipher_suites == '<STR_LIT>':<EOL><INDENT>self._cipher_suites = '<STR_LIT::>'.join(self._default_cipher_suites)<EOL><DEDENT>", "docstring": "Create an AuthenticationSuite object.\n\nArgs:\n    cipher_suites (list): A list of strings representing the names of\n        cipher suites to use. Overrides the default set of cipher\n        suites. Optional, defaults to None.", "id": "f15152:c0:m0"}
{"signature": "@property<EOL><INDENT>def protocol(self):<DEDENT>", "body": "return self._protocol<EOL>", "docstring": "Get the authentication suite protocol.\n\nReturns:\n    int: The value of the ssl.PROTOCOL_* setting for this suite.", "id": "f15152:c0:m1"}
{"signature": "def set_setting(self, setting, value):", "body": "if setting not in self._expected_settings + self._optional_settings:<EOL><INDENT>raise exceptions.ConfigurationError(<EOL>\"<STR_LIT>\".format(setting)<EOL>)<EOL><DEDENT>if setting == '<STR_LIT>':<EOL><INDENT>self._set_hostname(value)<EOL><DEDENT>elif setting == '<STR_LIT:port>':<EOL><INDENT>self._set_port(value)<EOL><DEDENT>elif setting == '<STR_LIT>':<EOL><INDENT>self._set_certificate_path(value)<EOL><DEDENT>elif setting == '<STR_LIT>':<EOL><INDENT>self._set_key_path(value)<EOL><DEDENT>elif setting == '<STR_LIT>':<EOL><INDENT>self._set_ca_path(value)<EOL><DEDENT>elif setting == '<STR_LIT>':<EOL><INDENT>self._set_auth_suite(value)<EOL><DEDENT>elif setting == '<STR_LIT>':<EOL><INDENT>self._set_policy_path(value)<EOL><DEDENT>elif setting == '<STR_LIT>':<EOL><INDENT>self._set_enable_tls_client_auth(value)<EOL><DEDENT>elif setting == '<STR_LIT>':<EOL><INDENT>self._set_tls_cipher_suites(value)<EOL><DEDENT>elif setting == '<STR_LIT>':<EOL><INDENT>self._set_logging_level(value)<EOL><DEDENT>else:<EOL><INDENT>self._set_database_path(value)<EOL><DEDENT>", "docstring": "Set a specific setting value.\n\nThis will overwrite the current setting value for the specified\nsetting.\n\nArgs:\n    setting (string): The name of the setting to set (e.g.,\n        'certificate_path', 'hostname'). Required.\n    value (misc): The value of the setting to set. Type varies based\n        on setting. Required.\nRaises:\n    ConfigurationError: Raised if the setting is not supported or if\n        the setting value is invalid.", "id": "f15153:c0:m1"}
{"signature": "def is_attribute_multivalued(self, attribute):", "body": "<EOL>rule_set = self._attribute_rule_sets.get(attribute)<EOL>return rule_set.multiple_instances_permitted<EOL>", "docstring": "Check if the attribute is allowed to have multiple instances.\n\nArgs:\n    attribute (string): The name of the attribute\n        (e.g., 'State'). Required.", "id": "f15154:c1:m4"}
{"signature": "def is_attribute_applicable_to_object_type(self, attribute, object_type):", "body": "<EOL>rule_set = self._attribute_rule_sets.get(attribute)<EOL>if object_type in rule_set.applies_to_object_types:<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Check if the attribute is supported by the given object type.\n\nArgs:\n    attribute (string): The name of the attribute (e.g., 'Name').\n        Required.\n    object_type (ObjectType): An ObjectType enumeration\n        (e.g., ObjectType.SYMMETRIC_KEY). Required.\nReturns:\n    bool: True if the attribute is applicable to the object type.\n        False otherwise.", "id": "f15154:c1:m3"}
{"signature": "def _set_attributes_on_managed_object(self, managed_object, attributes):", "body": "for attribute_name, attribute_value in six.iteritems(attributes):<EOL><INDENT>object_type = managed_object._object_type<EOL>if self._attribute_policy.is_attribute_applicable_to_object_type(<EOL>attribute_name,<EOL>object_type):<EOL><INDENT>self._set_attribute_on_managed_object(<EOL>managed_object,<EOL>(attribute_name, attribute_value)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>name = object_type.name<EOL>raise exceptions.InvalidField(<EOL>\"<STR_LIT>\".format(<EOL>attribute_name,<EOL>'<STR_LIT>'.join([x.capitalize() for x in name.split('<STR_LIT:_>')])<EOL>)<EOL>)<EOL><DEDENT><DEDENT>", "docstring": "Given a kmip.pie object and a dictionary of attributes, attempt to set\nthe attribute values on the object.", "id": "f15155:c0:m15"}
{"signature": "@_synchronize<EOL><INDENT>def process_request(self, request, credential=None):<DEDENT>", "body": "self._client_identity = [None, None]<EOL>header = request.request_header<EOL>self._set_protocol_version(header.protocol_version)<EOL>max_response_size = None<EOL>if header.maximum_response_size:<EOL><INDENT>max_response_size = header.maximum_response_size.value<EOL><DEDENT>now = int(time.time())<EOL>if header.time_stamp:<EOL><INDENT>then = header.time_stamp.value<EOL>if (now >= then) and ((now - then) < <NUM_LIT>):<EOL><INDENT>self._logger.info(\"<STR_LIT>\".format(<EOL>time.strftime(<EOL>\"<STR_LIT>\",<EOL>time.gmtime(then)<EOL>)<EOL>))<EOL><DEDENT>else:<EOL><INDENT>if now < then:<EOL><INDENT>self._logger.warning(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(<EOL>then,<EOL>now<EOL>)<EOL>)<EOL>raise exceptions.InvalidMessage(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>else:<EOL><INDENT>self._logger.warning(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(then, now)<EOL>)<EOL>raise exceptions.InvalidMessage(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>self._logger.info(\"<STR_LIT>\".format(<EOL>time.strftime(<EOL>\"<STR_LIT>\",<EOL>time.gmtime(now)<EOL>)<EOL>))<EOL><DEDENT>self.is_asynchronous = False<EOL>if header.asynchronous_indicator is not None:<EOL><INDENT>self.is_asynchronous = header.asynchronous_indicator.value<EOL><DEDENT>if self.is_asynchronous:<EOL><INDENT>raise exceptions.InvalidMessage(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>if header.authentication:<EOL><INDENT>if header.authentication.credentials:<EOL><INDENT>auth_credentials = header.authentication.credentials[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>auth_credentials = None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>auth_credentials = None<EOL><DEDENT>self._verify_credential(auth_credentials, credential)<EOL>batch_error_option = enums.BatchErrorContinuationOption.STOP<EOL>if header.batch_error_cont_option is not None:<EOL><INDENT>batch_error_option = header.batch_error_cont_option.value<EOL><DEDENT>if batch_error_option == enums.BatchErrorContinuationOption.UNDO:<EOL><INDENT>raise exceptions.InvalidMessage(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>batch_order_option = False<EOL>if header.batch_order_option:<EOL><INDENT>batch_order_option = header.batch_order_option.value<EOL><DEDENT>response_batch = self._process_batch(<EOL>request.batch_items,<EOL>batch_error_option,<EOL>batch_order_option<EOL>)<EOL>response = self._build_response(<EOL>header.protocol_version,<EOL>response_batch<EOL>)<EOL>return response, max_response_size, header.protocol_version<EOL>", "docstring": "Process a KMIP request message.\n\nThis routine is the main driver of the KmipEngine. It breaks apart and\nprocesses the request header, handles any message errors that may\nresult, and then passes the set of request batch items on for\nprocessing. This routine is thread-safe, allowing multiple client\nconnections to use the same KmipEngine.\n\nArgs:\n    request (RequestMessage): The request message containing the batch\n        items to be processed.\n    credential (string): Identifying information about the client\n        obtained from the client certificate. Optional, defaults to\n        None.\n\nReturns:\n    ResponseMessage: The response containing all of the results from\n        the request batch items.", "id": "f15155:c0:m6"}
{"signature": "def __init__(self, policies=None, database_path=None):", "body": "self._logger = logging.getLogger('<STR_LIT>')<EOL>self._cryptography_engine = engine.CryptographyEngine()<EOL>self.database_path = '<STR_LIT>'.format(database_path)<EOL>if not database_path:<EOL><INDENT>self.database_path = '<STR_LIT>'<EOL><DEDENT>self._data_store = sqlalchemy.create_engine(<EOL>self.database_path,<EOL>echo=False,<EOL>connect_args={'<STR_LIT>': False}<EOL>)<EOL>sqltypes.Base.metadata.create_all(self._data_store)<EOL>self._data_store_session_factory = sqlalchemy.orm.sessionmaker(<EOL>bind=self._data_store<EOL>)<EOL>self._lock = threading.RLock()<EOL>self._id_placeholder = None<EOL>self._protocol_versions = [<EOL>contents.ProtocolVersion(<NUM_LIT:1>, <NUM_LIT:4>),<EOL>contents.ProtocolVersion(<NUM_LIT:1>, <NUM_LIT:3>),<EOL>contents.ProtocolVersion(<NUM_LIT:1>, <NUM_LIT:2>),<EOL>contents.ProtocolVersion(<NUM_LIT:1>, <NUM_LIT:1>),<EOL>contents.ProtocolVersion(<NUM_LIT:1>, <NUM_LIT:0>)<EOL>]<EOL>self.default_protocol_version = self._protocol_versions[<NUM_LIT:2>]<EOL>self._protocol_version = self._protocol_versions[<NUM_LIT:2>]<EOL>self._object_map = {<EOL>enums.ObjectType.CERTIFICATE: objects.X509Certificate,<EOL>enums.ObjectType.SYMMETRIC_KEY: objects.SymmetricKey,<EOL>enums.ObjectType.PUBLIC_KEY: objects.PublicKey,<EOL>enums.ObjectType.PRIVATE_KEY: objects.PrivateKey,<EOL>enums.ObjectType.SPLIT_KEY: None,<EOL>enums.ObjectType.TEMPLATE: None,<EOL>enums.ObjectType.SECRET_DATA: objects.SecretData,<EOL>enums.ObjectType.OPAQUE_DATA: objects.OpaqueObject<EOL>}<EOL>self._attribute_policy = policy.AttributePolicy(self._protocol_version)<EOL>self._operation_policies = policies<EOL>self._client_identity = [None, None]<EOL>", "docstring": "Create a KmipEngine.\n\nArgs:\n    policy_path (string): The path to the filesystem directory\n        containing PyKMIP server operation policy JSON files.\n        Optional, defaults to None.\n    database_path (string): The path to the SQLite database file\n        used to store all server data. Optional, defaults to None.\n        If none, database path defaults to '/tmp/pykmip.database'.", "id": "f15155:c0:m0"}
{"signature": "def _set_attribute_on_managed_object(self, managed_object, attribute):", "body": "attribute_name = attribute[<NUM_LIT:0>]<EOL>attribute_value = attribute[<NUM_LIT:1>]<EOL>if self._attribute_policy.is_attribute_multivalued(attribute_name):<EOL><INDENT>if attribute_name == '<STR_LIT:Name>':<EOL><INDENT>managed_object.names.extend(<EOL>[x.name_value.value for x in attribute_value]<EOL>)<EOL>for name in managed_object.names:<EOL><INDENT>if managed_object.names.count(name) > <NUM_LIT:1>:<EOL><INDENT>raise exceptions.InvalidField(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>raise exceptions.InvalidField(<EOL>\"<STR_LIT>\".format(attribute_name)<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>field = None<EOL>value = attribute_value.value<EOL>if attribute_name == '<STR_LIT>':<EOL><INDENT>field = '<STR_LIT>'<EOL><DEDENT>elif attribute_name == '<STR_LIT>':<EOL><INDENT>field = '<STR_LIT>'<EOL><DEDENT>elif attribute_name == '<STR_LIT>':<EOL><INDENT>field = '<STR_LIT>'<EOL>value = list()<EOL>for e in enums.CryptographicUsageMask:<EOL><INDENT>if e.value & attribute_value.value:<EOL><INDENT>value.append(e)<EOL><DEDENT><DEDENT><DEDENT>elif attribute_name == '<STR_LIT>':<EOL><INDENT>field = '<STR_LIT>'<EOL><DEDENT>if field:<EOL><INDENT>existing_value = getattr(managed_object, field)<EOL>if existing_value:<EOL><INDENT>if existing_value != value:<EOL><INDENT>raise exceptions.InvalidField(<EOL>\"<STR_LIT>\".format(<EOL>attribute_name<EOL>)<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>setattr(managed_object, field, value)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise exceptions.InvalidField(<EOL>\"<STR_LIT>\".format(attribute_name)<EOL>)<EOL><DEDENT><DEDENT>", "docstring": "Set the attribute value on the kmip.pie managed object.", "id": "f15155:c0:m16"}
{"signature": "def _get_attributes_from_managed_object(self, managed_object, attr_names):", "body": "attr_factory = attribute_factory.AttributeFactory()<EOL>retrieved_attributes = list()<EOL>if not attr_names:<EOL><INDENT>attr_names = self._attribute_policy.get_all_attribute_names()<EOL><DEDENT>for attribute_name in attr_names:<EOL><INDENT>object_type = managed_object._object_type<EOL>if not self._attribute_policy.is_attribute_supported(<EOL>attribute_name<EOL>):<EOL><INDENT>continue<EOL><DEDENT>if self._attribute_policy.is_attribute_applicable_to_object_type(<EOL>attribute_name,<EOL>object_type<EOL>):<EOL><INDENT>try:<EOL><INDENT>attribute_value = self._get_attribute_from_managed_object(<EOL>managed_object,<EOL>attribute_name<EOL>)<EOL><DEDENT>except Exception:<EOL><INDENT>attribute_value = None<EOL><DEDENT>if attribute_value is not None:<EOL><INDENT>if self._attribute_policy.is_attribute_multivalued(<EOL>attribute_name<EOL>):<EOL><INDENT>for count, value in enumerate(attribute_value):<EOL><INDENT>attribute = attr_factory.create_attribute(<EOL>enums.AttributeType(attribute_name),<EOL>value,<EOL>count<EOL>)<EOL>retrieved_attributes.append(attribute)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>attribute = attr_factory.create_attribute(<EOL>enums.AttributeType(attribute_name),<EOL>attribute_value<EOL>)<EOL>retrieved_attributes.append(attribute)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return retrieved_attributes<EOL>", "docstring": "Given a kmip.pie object and a list of attribute names, attempt to get\nall of the existing attribute values from the object.", "id": "f15155:c0:m13"}
{"signature": "def build_error_response(self, version, reason, message):", "body": "batch_item = messages.ResponseBatchItem(<EOL>result_status=contents.ResultStatus(<EOL>enums.ResultStatus.OPERATION_FAILED<EOL>),<EOL>result_reason=contents.ResultReason(reason),<EOL>result_message=contents.ResultMessage(message)<EOL>)<EOL>return self._build_response(version, [batch_item])<EOL>", "docstring": "Build a simple ResponseMessage with a single error result.\n\nArgs:\n    version (ProtocolVersion): The protocol version the response\n        should be addressed with.\n    reason (ResultReason): An enumeration classifying the type of\n        error occurred.\n    message (str): A string providing additional information about\n        the error.\n\nReturns:\n    ResponseMessage: The simple ResponseMessage containing a\n        single error result.", "id": "f15155:c0:m8"}
{"signature": "def sign(self,<EOL>digital_signature_algorithm,<EOL>crypto_alg,<EOL>hash_algorithm,<EOL>padding,<EOL>signing_key,<EOL>data):", "body": "if digital_signature_algorithm:<EOL><INDENT>(hash_alg, crypto_alg) = self._digital_signature_algorithms.get(<EOL>digital_signature_algorithm,<EOL>(None, None)<EOL>)<EOL><DEDENT>elif crypto_alg and hash_algorithm:<EOL><INDENT>hash_alg = self._encryption_hash_algorithms.get(<EOL>hash_algorithm, None<EOL>)<EOL><DEDENT>else:<EOL><INDENT>raise exceptions.InvalidField(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>if crypto_alg == enums.CryptographicAlgorithm.RSA:<EOL><INDENT>try:<EOL><INDENT>key = self._create_RSA_private_key(signing_key)<EOL><DEDENT>except Exception:<EOL><INDENT>raise exceptions.InvalidField('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise exceptions.InvalidField(<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>if padding:<EOL><INDENT>padding_method = self._asymmetric_padding_methods.get(<EOL>padding, None<EOL>)<EOL><DEDENT>else:<EOL><INDENT>raise exceptions.InvalidField(<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>if padding == enums.PaddingMethod.PSS:<EOL><INDENT>signature = key.sign(<EOL>data,<EOL>asymmetric_padding.PSS(<EOL>mgf=asymmetric_padding.MGF1(hash_alg()),<EOL>salt_length=asymmetric_padding.PSS.MAX_LENGTH<EOL>),<EOL>hash_alg()<EOL>)<EOL><DEDENT>elif padding == enums.PaddingMethod.PKCS1v15:<EOL><INDENT>signature = key.sign(<EOL>data,<EOL>padding_method(),<EOL>hash_alg()<EOL>)<EOL><DEDENT>else:<EOL><INDENT>raise exceptions.InvalidField(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(padding)<EOL>)<EOL><DEDENT>return signature<EOL>", "docstring": "Args:\n    digital_signature_algorithm (DigitalSignatureAlgorithm): An\n        enumeration specifying the asymmetric cryptographic algorithm\n        and hashing algorithm to use for the signature operation. Can\n        be None if cryptographic_algorithm and hash_algorithm are set.\n    crypto_alg (CryptographicAlgorithm): An enumeration\n        specifying the asymmetric cryptographic algorithm to use for\n        the signature operation. Can be None if\n        digital_signature_algorithm is set.\n    hash_algorithm (HashingAlgorithm): An enumeration specifying the\n        hash algorithm to use for the signature operation. Can be None\n        if digital_signature_algorithm is set.\n    padding (PaddingMethod): An enumeration specifying the asymmetric\n        padding method to use for the signature operation.\n    signing_key (bytes): The bytes of the private key to use for the\n        signature operation.\n    data (bytes): The data to be signed.\n\nReturns:\n    signature (bytes): the bytes of the signature data\n\nRaises:\n    CryptographicFailure: Raised when an error occurs during signature\n        creation.\n    InvalidField: Raised when an unsupported hashing or cryptographic\n        algorithm is specified.", "id": "f15156:c0:m15"}
{"signature": "def _create_rsa_key_pair(self, length, public_exponent=<NUM_LIT>):", "body": "self.logger.info(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(<EOL>length, public_exponent<EOL>)<EOL>)<EOL>try:<EOL><INDENT>private_key = rsa.generate_private_key(<EOL>public_exponent=public_exponent,<EOL>key_size=length,<EOL>backend=default_backend())<EOL>public_key = private_key.public_key()<EOL>private_bytes = private_key.private_bytes(<EOL>serialization.Encoding.DER,<EOL>serialization.PrivateFormat.PKCS8,<EOL>serialization.NoEncryption())<EOL>public_bytes = public_key.public_bytes(<EOL>serialization.Encoding.DER,<EOL>serialization.PublicFormat.PKCS1)<EOL><DEDENT>except Exception as e:<EOL><INDENT>self.logger.exception(e)<EOL>raise exceptions.CryptographicFailure(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>public_key = {<EOL>'<STR_LIT:value>': public_bytes,<EOL>'<STR_LIT>': enums.KeyFormatType.PKCS_1,<EOL>'<STR_LIT>': public_exponent<EOL>}<EOL>private_key = {<EOL>'<STR_LIT:value>': private_bytes,<EOL>'<STR_LIT>': enums.KeyFormatType.PKCS_8,<EOL>'<STR_LIT>': public_exponent<EOL>}<EOL>return public_key, private_key<EOL>", "docstring": "Create an RSA key pair.\n\nArgs:\n    length(int): The length of the keys to be created. This value must\n        be compliant with the constraints of the provided algorithm.\n    public_exponent(int): The value of the public exponent needed to\n        generate the keys. Usually a small Fermat prime number.\n        Optional, defaults to 65537.\n\nReturns:\n    dict: A dictionary containing the public key data, with the\n        following key/value fields:\n        * value - the bytes of the key\n        * format - a KeyFormatType enumeration for the bytes format\n        * public_exponent - the public exponent integer\n    dict: A dictionary containing the private key data, identical in\n        structure to the one above.\n\nRaises:\n    CryptographicFailure: Raised when the key generation process\n        fails.", "id": "f15156:c0:m11"}
{"signature": "def encrypt(self,<EOL>encryption_algorithm,<EOL>encryption_key,<EOL>plain_text,<EOL>cipher_mode=None,<EOL>padding_method=None,<EOL>iv_nonce=None,<EOL>hashing_algorithm=None):", "body": "if encryption_algorithm is None:<EOL><INDENT>raise exceptions.InvalidField(\"<STR_LIT>\")<EOL><DEDENT>if encryption_algorithm == enums.CryptographicAlgorithm.RSA:<EOL><INDENT>return self._encrypt_asymmetric(<EOL>encryption_algorithm,<EOL>encryption_key,<EOL>plain_text,<EOL>padding_method,<EOL>hashing_algorithm=hashing_algorithm<EOL>)<EOL><DEDENT>else:<EOL><INDENT>return self._encrypt_symmetric(<EOL>encryption_algorithm,<EOL>encryption_key,<EOL>plain_text,<EOL>cipher_mode=cipher_mode,<EOL>padding_method=padding_method,<EOL>iv_nonce=iv_nonce<EOL>)<EOL><DEDENT>", "docstring": "Encrypt data using symmetric or asymmetric encryption.\n\nArgs:\n    encryption_algorithm (CryptographicAlgorithm): An enumeration\n        specifying the encryption algorithm to use for encryption.\n    encryption_key (bytes): The bytes of the encryption key to use for\n        encryption.\n    plain_text (bytes): The bytes to be encrypted.\n    cipher_mode (BlockCipherMode): An enumeration specifying the\n        block cipher mode to use with the encryption algorithm.\n        Required in the general case. Optional if the encryption\n        algorithm is RC4 (aka ARC4). If optional, defaults to None.\n    padding_method (PaddingMethod): An enumeration specifying the\n        padding method to use on the data before encryption. Required\n        if the cipher mode is for block ciphers (e.g., CBC, ECB).\n        Optional otherwise, defaults to None.\n    iv_nonce (bytes): The IV/nonce value to use to initialize the mode\n        of the encryption algorithm. Optional, defaults to None. If\n        required and not provided, it will be autogenerated and\n        returned with the cipher text.\n    hashing_algorithm (HashingAlgorithm): An enumeration specifying\n        the hashing algorithm to use with the encryption algorithm,\n        if needed. Required for OAEP-based asymmetric encryption.\n        Optional, defaults to None.\n\nReturns:\n    dict: A dictionary containing the encrypted data, with at least\n        the following key/value fields:\n        * cipher_text - the bytes of the encrypted data\n        * iv_nonce - the bytes of the IV/counter/nonce used if it\n            was needed by the encryption scheme and if it was\n            automatically generated for the encryption\n\nRaises:\n    InvalidField: Raised when the algorithm is unsupported or the\n        length is incompatible with the algorithm.\n    CryptographicFailure: Raised when the key generation process\n        fails.\n\nExample:\n    >>> engine = CryptographyEngine()\n    >>> result = engine.encrypt(\n    ...     encryption_algorithm=CryptographicAlgorithm.AES,\n    ...     encryption_key=(\n    ...         b'\\xF3\\x96\\xE7\\x1C\\xCF\\xCD\\xEC\\x1F'\n    ...         b'\\xFC\\xE2\\x8E\\xA6\\xF8\\x74\\x28\\xB0'\n    ...     ),\n    ...     plain_text=(\n    ...         b'\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07'\n    ...         b'\\x08\\x09\\x0A\\x0B\\x0C\\x0D\\x0E\\x0F'\n    ...     ),\n    ...     cipher_mode=BlockCipherMode.CBC,\n    ...     padding_method=PaddingMethod.ANSI_X923,\n    ... )\n    >>> result.get('cipher_text')\n    b'\\x18[\\xb9y\\x1bL\\xd1\\x8f\\x9a\\xa0e\\x02b\\xa3=c'\n    >>> result.iv_counter_nonce\n    b'8qA\\x05\\xc4\\x86\\x03\\xd9=\\xef\\xdf\\xb8ke\\x9a\\xa2'", "id": "f15156:c0:m4"}
{"signature": "def __init__(self):", "body": "self.logger = logging.getLogger('<STR_LIT>')<EOL>self._symmetric_key_algorithms = {<EOL>enums.CryptographicAlgorithm.TRIPLE_DES: algorithms.TripleDES,<EOL>enums.CryptographicAlgorithm.AES:        algorithms.AES,<EOL>enums.CryptographicAlgorithm.BLOWFISH:   algorithms.Blowfish,<EOL>enums.CryptographicAlgorithm.CAMELLIA:   algorithms.Camellia,<EOL>enums.CryptographicAlgorithm.CAST5:      algorithms.CAST5,<EOL>enums.CryptographicAlgorithm.IDEA:       algorithms.IDEA,<EOL>enums.CryptographicAlgorithm.RC4:        algorithms.ARC4<EOL>}<EOL>self._asymmetric_key_algorithms = {<EOL>enums.CryptographicAlgorithm.RSA: self._create_rsa_key_pair<EOL>}<EOL>self._hash_algorithms = {<EOL>enums.CryptographicAlgorithm.HMAC_SHA1: hashes.SHA1,<EOL>enums.CryptographicAlgorithm.HMAC_SHA224: hashes.SHA224,<EOL>enums.CryptographicAlgorithm.HMAC_SHA256: hashes.SHA256,<EOL>enums.CryptographicAlgorithm.HMAC_SHA384: hashes.SHA384,<EOL>enums.CryptographicAlgorithm.HMAC_SHA512: hashes.SHA512,<EOL>enums.CryptographicAlgorithm.HMAC_MD5: hashes.MD5<EOL>}<EOL>self._encryption_hash_algorithms = {<EOL>enums.HashingAlgorithm.MD5:     hashes.MD5,<EOL>enums.HashingAlgorithm.SHA_1:   hashes.SHA1,<EOL>enums.HashingAlgorithm.SHA_224: hashes.SHA224,<EOL>enums.HashingAlgorithm.SHA_256: hashes.SHA256,<EOL>enums.HashingAlgorithm.SHA_384: hashes.SHA384,<EOL>enums.HashingAlgorithm.SHA_512: hashes.SHA512<EOL>}<EOL>self._modes = {<EOL>enums.BlockCipherMode.CBC: modes.CBC,<EOL>enums.BlockCipherMode.ECB: modes.ECB,<EOL>enums.BlockCipherMode.OFB: modes.OFB,<EOL>enums.BlockCipherMode.CFB: modes.CFB,<EOL>enums.BlockCipherMode.CTR: modes.CTR<EOL>}<EOL>self._asymmetric_padding_methods = {<EOL>enums.PaddingMethod.OAEP:     asymmetric_padding.OAEP,<EOL>enums.PaddingMethod.PKCS1v15: asymmetric_padding.PKCS1v15,<EOL>enums.PaddingMethod.PSS:      asymmetric_padding.PSS<EOL>}<EOL>self._symmetric_padding_methods = {<EOL>enums.PaddingMethod.ANSI_X923: symmetric_padding.ANSIX923,<EOL>enums.PaddingMethod.PKCS5:     symmetric_padding.PKCS7<EOL>}<EOL>self._no_mode_needed = [<EOL>enums.CryptographicAlgorithm.RC4<EOL>]<EOL>self._no_padding_needed = [<EOL>enums.BlockCipherMode.CTR,<EOL>enums.BlockCipherMode.OFB,<EOL>enums.BlockCipherMode.CFB,<EOL>enums.BlockCipherMode.GCM<EOL>]<EOL>self._digital_signature_algorithms = {<EOL>enums.DigitalSignatureAlgorithm.MD5_WITH_RSA_ENCRYPTION:<EOL>(hashes.MD5, enums.CryptographicAlgorithm.RSA),<EOL>enums.DigitalSignatureAlgorithm.SHA1_WITH_RSA_ENCRYPTION:<EOL>(hashes.SHA1, enums.CryptographicAlgorithm.RSA),<EOL>enums.DigitalSignatureAlgorithm.SHA224_WITH_RSA_ENCRYPTION:<EOL>(hashes.SHA224, enums.CryptographicAlgorithm.RSA),<EOL>enums.DigitalSignatureAlgorithm.SHA256_WITH_RSA_ENCRYPTION:<EOL>(hashes.SHA256, enums.CryptographicAlgorithm.RSA),<EOL>enums.DigitalSignatureAlgorithm.SHA384_WITH_RSA_ENCRYPTION:<EOL>(hashes.SHA384, enums.CryptographicAlgorithm.RSA),<EOL>enums.DigitalSignatureAlgorithm.SHA512_WITH_RSA_ENCRYPTION:<EOL>(hashes.SHA512, enums.CryptographicAlgorithm.RSA)<EOL>}<EOL>", "docstring": "Construct a CryptographyEngine.", "id": "f15156:c0:m0"}
{"signature": "def __init__(self, policy_directory, policy_store, live_monitoring=True):", "body": "super(PolicyDirectoryMonitor, self).__init__()<EOL>self.halt_trigger = multiprocessing.Event()<EOL>self.policy_directory = policy_directory<EOL>self.live_monitoring = live_monitoring<EOL>self.file_timestamps = None<EOL>self.policy_cache = None<EOL>self.policy_files = None<EOL>self.policy_map = None<EOL>self.policy_store = policy_store<EOL>self.reserved_policies = ['<STR_LIT:default>', '<STR_LIT>']<EOL>def interrupt_handler(trigger, frame):<EOL><INDENT>self.stop()<EOL><DEDENT>signal.signal(signal.SIGINT, interrupt_handler)<EOL>signal.signal(signal.SIGTERM, interrupt_handler)<EOL>self.logger = logging.getLogger(\"<STR_LIT>\")<EOL>self.initialize_tracking_structures()<EOL>", "docstring": "Set up the file monitor with the policy directory to track.\n\nArgs:\n    policy_directory (string): The system path of the policy directory\n        that should be monitored. Required.\n    policy_store (DictProxy): A dictionary proxy created by the server\n        multiprocessing resource manager. Used to store and share the\n        policy information across server processes and threads.\n        Required.\n    live_monitoring (boolean): A boolean indicating whether or not\n        live monitoring should continue indefinitely. Optional,\n        defaults to True.", "id": "f15161:c0:m0"}
{"signature": "def get_json_files(p):", "body": "f = [os.path.join(p, x) for x in os.listdir(p) if x.endswith(\"<STR_LIT>\")]<EOL>return sorted(f)<EOL>", "docstring": "Scan the provided policy directory for all JSON policy files.", "id": "f15161:m0"}
{"signature": "def run(self):", "body": "self._logger.info(\"<STR_LIT>\".format(self.name))<EOL>try:<EOL><INDENT>self._connection.do_handshake()<EOL><DEDENT>except Exception as e:<EOL><INDENT>self._logger.info(\"<STR_LIT>\")<EOL>self._logger.exception(e)<EOL><DEDENT>else:<EOL><INDENT>while True:<EOL><INDENT>try:<EOL><INDENT>self._handle_message_loop()<EOL><DEDENT>except exceptions.ConnectionClosed as e:<EOL><INDENT>break<EOL><DEDENT>except Exception as e:<EOL><INDENT>self._logger.info(\"<STR_LIT>\")<EOL>self._logger.exception(e)<EOL><DEDENT><DEDENT><DEDENT>self._connection.shutdown(socket.SHUT_RDWR)<EOL>self._connection.close()<EOL>self._logger.info(\"<STR_LIT>\".format(self.name))<EOL>", "docstring": "The main thread routine executed by invoking thread.start.\n\nThis method manages the new client connection, running a message\nhandling loop. Once this method completes, the thread is finished.", "id": "f15162:c0:m1"}
{"signature": "def decrypt(self,<EOL>data,<EOL>unique_identifier=None,<EOL>cryptographic_parameters=None,<EOL>iv_counter_nonce=None,<EOL>credential=None):", "body": "operation = Operation(OperationEnum.DECRYPT)<EOL>request_payload = payloads.DecryptRequestPayload(<EOL>unique_identifier=unique_identifier,<EOL>data=data,<EOL>cryptographic_parameters=cryptographic_parameters,<EOL>iv_counter_nonce=iv_counter_nonce<EOL>)<EOL>batch_item = messages.RequestBatchItem(<EOL>operation=operation,<EOL>request_payload=request_payload<EOL>)<EOL>request = self._build_request_message(credential, [batch_item])<EOL>response = self._send_and_receive_message(request)<EOL>batch_item = response.batch_items[<NUM_LIT:0>]<EOL>payload = batch_item.response_payload<EOL>result = {}<EOL>if payload:<EOL><INDENT>result['<STR_LIT>'] = payload.unique_identifier<EOL>result['<STR_LIT:data>'] = payload.data<EOL><DEDENT>result['<STR_LIT>'] = batch_item.result_status.value<EOL>try:<EOL><INDENT>result['<STR_LIT>'] = batch_item.result_reason.value<EOL><DEDENT>except Exception:<EOL><INDENT>result['<STR_LIT>'] = batch_item.result_reason<EOL><DEDENT>try:<EOL><INDENT>result['<STR_LIT>'] = batch_item.result_message.value<EOL><DEDENT>except Exception:<EOL><INDENT>result['<STR_LIT>'] = batch_item.result_message<EOL><DEDENT>return result<EOL>", "docstring": "Decrypt data using the specified decryption key and parameters.\n\nArgs:\n    data (bytes): The bytes to decrypt. Required.\n    unique_identifier (string): The unique ID of the decryption key\n        to use. Optional, defaults to None.\n    cryptographic_parameters (CryptographicParameters): A structure\n        containing various cryptographic settings to be used for the\n        decryption. Optional, defaults to None.\n    iv_counter_nonce (bytes): The bytes to use for the IV/counter/\n        nonce, if needed by the decryption algorithm and/or cipher\n        mode. Optional, defaults to None.\n    credential (Credential): A credential object containing a set of\n        authorization parameters for the operation. Optional, defaults\n        to None.\n\nReturns:\n    dict: The results of the decrypt operation, containing the\n        following key/value pairs:\n\n        Key                 | Value\n        --------------------|-----------------------------------------\n        'unique_identifier' | (string) The unique ID of the decryption\n                            | key used to decrypt the data.\n        'data'              | (bytes) The decrypted data.\n        'result_status'     | (ResultStatus) An enumeration indicating\n                            | the status of the operation result.\n        'result_reason'     | (ResultReason) An enumeration providing\n                            | context for the result status.\n        'result_message'    | (string) A message providing additional\n                            | context for the operation result.", "id": "f15167:c0:m29"}
{"signature": "def is_authentication_suite_supported(self, authentication_suite):", "body": "return authentication_suite in self.authentication_suites<EOL>", "docstring": "Check if an AuthenticationSuite is supported by the client.\n\nArgs:\n    authentication_suite (AuthenticationSuite): An AuthenticationSuite\n        enumeration to check against the list of supported\n        AuthenticationSuites.\n\nReturns:\n    bool: True if the AuthenticationSuite is supported, False\n        otherwise.\n\nExample:\n    >>> suite = AuthenticationSuite.BASIC\n    >>> client.is_authentication_suite_supported(suite)\n    True\n    >>> suite = AuthenticationSuite.TLS12\n    >>> client.is_authentication_suite_supported(suite)\n    False", "id": "f15167:c0:m6"}
{"signature": "def signature_verify(self,<EOL>message,<EOL>signature,<EOL>unique_identifier=None,<EOL>cryptographic_parameters=None,<EOL>credential=None):", "body": "operation = Operation(OperationEnum.SIGNATURE_VERIFY)<EOL>request_payload = payloads.SignatureVerifyRequestPayload(<EOL>unique_identifier=unique_identifier,<EOL>cryptographic_parameters=cryptographic_parameters,<EOL>data=message,<EOL>signature_data=signature<EOL>)<EOL>batch_item = messages.RequestBatchItem(<EOL>operation=operation,<EOL>request_payload=request_payload<EOL>)<EOL>request = self._build_request_message(credential, [batch_item])<EOL>response = self._send_and_receive_message(request)<EOL>batch_item = response.batch_items[<NUM_LIT:0>]<EOL>payload = batch_item.response_payload<EOL>result = {}<EOL>if payload:<EOL><INDENT>result['<STR_LIT>'] = payload.unique_identifier<EOL>result['<STR_LIT>'] = payload.validity_indicator<EOL><DEDENT>result['<STR_LIT>'] = batch_item.result_status.value<EOL>try:<EOL><INDENT>result['<STR_LIT>'] = batch_item.result_reason.value<EOL><DEDENT>except Exception:<EOL><INDENT>result['<STR_LIT>'] = batch_item.result_reason<EOL><DEDENT>try:<EOL><INDENT>result['<STR_LIT>'] = batch_item.result_message.value<EOL><DEDENT>except Exception:<EOL><INDENT>result['<STR_LIT>'] = batch_item.result_message<EOL><DEDENT>return result<EOL>", "docstring": "Verify a message signature using the specified signing key.\n\nArgs:\n    message (bytes): The bytes of the signed message. Required.\n    signature (bytes): The bytes of the message signature. Required.\n    unique_identifier (string): The unique ID of the signing key to\n        use. Optional, defaults to None.\n    cryptographic_parameters (CryptographicParameters): A structure\n        containing various cryptographic settings to be used for\n        signature verification. Optional, defaults to None.\n    credential (Credential): A credential object containing a set of\n        authorization parameters for the operation. Optional, defaults\n        to None.\n\nReturns:\n    dict: The results of the signature verify operation, containing the\n        following key/value pairs:\n\n        Key                  | Value\n        ---------------------|-----------------------------------------\n        'unique_identifier'  | (string) The unique ID of the signing\n                             | key used to verify the signature.\n        'validity_indicator' | (ValidityIndicator) An enumeration\n                             | indicating the result of signature\n                             | verification.\n        'result_status'      | (ResultStatus) An enumeration indicating\n                             | the status of the operation result.\n        'result_reason'      | (ResultReason) An enumeration providing\n                             | context for the result status.\n        'result_message'     | (string) A message providing additional\n                             | context for the operation result.", "id": "f15167:c0:m30"}
{"signature": "def get_attribute_list(self, uid=None):", "body": "batch_item = self._build_get_attribute_list_batch_item(uid)<EOL>request = self._build_request_message(None, [batch_item])<EOL>response = self._send_and_receive_message(request)<EOL>results = self._process_batch_items(response)<EOL>return results[<NUM_LIT:0>]<EOL>", "docstring": "Send a GetAttributeList request to the server.\n\nArgs:\n    uid (string): The ID of the managed object with which the retrieved\n        attribute names should be associated.\n\nReturns:\n    result (GetAttributeListResult): A structure containing the results\n        of the operation.", "id": "f15167:c0:m20"}
{"signature": "@property<EOL><INDENT>def rtype(self):<DEDENT>", "body": "return int if self._type == AggrType.count else float<EOL>", "docstring": "r\"\"\"Return type.\n\n        * \"count\": :py:class:`int`\n        * \"other\": :py:class:`float`", "id": "f15172:c3:m7"}
{"signature": "@abstractproperty<EOL><INDENT>def header(self):<DEDENT>", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "Header of warning message.\n\n        Returns:\n            str", "id": "f15173:c0:m6"}
{"signature": "def register_json(self, obj):", "body": "if not isinstance(obj, list):<EOL><INDENT>obj = [obj]<EOL><DEDENT>self.register(Descriptor.from_json(j) for j in obj)<EOL>", "docstring": "Register Descriptors from json descriptor objects.\n\n        Parameters:\n            obj(list or dict): descriptors to register", "id": "f15177:c0:m2"}
{"signature": "@contextmanager<EOL><INDENT>def rethrow_na(self, exception):<DEDENT>", "body": "try:<EOL><INDENT>yield<EOL><DEDENT>except exception as e:<EOL><INDENT>self.fail(e)<EOL><DEDENT>", "docstring": "[contextmanager] treat any exceptions as known exception.", "id": "f15182:c2:m19"}
{"signature": "def is_descriptor_class(desc, include_abstract=False):", "body": "return (<EOL>isinstance(desc, type)<EOL>and issubclass(desc, Descriptor)<EOL>and (True if include_abstract else not inspect.isabstract(desc))<EOL>)<EOL>", "docstring": "r\"\"\"Check calculatable descriptor class or not.\n\n    Returns:\n        bool", "id": "f15182:m0"}
{"signature": "def fail(self, exception):", "body": "raise MissingValueException(exception)<EOL>", "docstring": "Raise known exception and return missing value.\n\n        Raises:\n            MissingValueException", "id": "f15182:c2:m17"}
{"signature": "def items(self):", "body": "return ((k, v) for k, v in zip(self.keys(), self.values()))<EOL>", "docstring": "r\"\"\"Get items.\n\n        Returns:\n            Iterable[(Descriptor, value)]", "id": "f15183:c0:m5"}
{"signature": "@property<EOL><INDENT>def ix(self):<DEDENT>", "body": "return GetValueByIndex(self._values)<EOL>", "docstring": "r\"\"\"Access descriptor value by index.\n\n        >>> from mordred import Calculator, Lipinski\n        >>> from rdkit import Chem\n        >>> result = Calculator(Lipinski.Lipinski)(Chem.MolFromSmiles(\"C1CCCCC1\"))\n        >>> result.ix[0]\n        True", "id": "f15183:c0:m10"}
{"signature": "@classmethod<EOL><INDENT>def from_mol(cls, mol, conformer=-<NUM_LIT:1>, solvent_radius=<NUM_LIT>, level=<NUM_LIT:4>):<DEDENT>", "body": "rs = atoms_to_numpy(lambda a: vdw_radii[a.GetAtomicNum()] + solvent_radius, mol)<EOL>conf = mol.GetConformer(conformer)<EOL>ps = np.array([list(conf.GetAtomPosition(i)) for i in range(mol.GetNumAtoms())])<EOL>return cls(rs, ps, level)<EOL>", "docstring": "r\"\"\"Construct SurfaceArea from rdkit Mol type.\n\n        :type mol: rdkit.Chem.Mol\n        :param mol: input molecule\n\n        :type conformer: int\n        :param conformer: conformer id\n\n        :type solvent_radius: float\n        :param solvent_radius: solvent radius\n\n        :type level: int\n        :param level: mesh level\n\n        :rtype: SurfaceArea", "id": "f15253:c0:m4"}
{"signature": "def __init__(self, url, access_token, index,<EOL>source=\"<STR_LIT>\", verify=True, timeout=<NUM_LIT>):", "body": "url = urlparse(url)<EOL>self.url = \"<STR_LIT>\".format(url.scheme,<EOL>url.netloc)<EOL>self.access_token = access_token.lstrip(\"<STR_LIT>\")<EOL>self.index = index<EOL>self.host = socket.getfqdn()<EOL>self.source = source<EOL>self.session = requests.Session()<EOL>self.timeout = timeout<EOL>self.session.verify = verify<EOL>self._common_data = dict(host=self.host, source=self.source,<EOL>index=self.index)<EOL>self.session.headers = {<EOL>\"<STR_LIT>\": \"<STR_LIT>\".format(__version__),<EOL>\"<STR_LIT>\": \"<STR_LIT>\".format(self.access_token)<EOL>}<EOL>", "docstring": "Initializes the HECClient\nArgs:\n    url (str): The URL of the HEC\n    access_token (str): The HEC access token\n    index (str): The name of the index\n    source (str): The source name\n    verify (bool): Verify SSL certificates\n    timeout (float): Number of seconds to wait for the server to send\n    data before giving up", "id": "f15284:c1:m0"}
{"signature": "def save_aggregate_reports_to_splunk(self, aggregate_reports):", "body": "logger.debug(\"<STR_LIT>\")<EOL>if type(aggregate_reports) == dict:<EOL><INDENT>aggregate_reports = [aggregate_reports]<EOL><DEDENT>if len(aggregate_reports) < <NUM_LIT:1>:<EOL><INDENT>return<EOL><DEDENT>data = self._common_data.copy()<EOL>json_str = \"<STR_LIT>\"<EOL>for report in aggregate_reports:<EOL><INDENT>for record in report[\"<STR_LIT>\"]:<EOL><INDENT>new_report = dict()<EOL>for metadata in report[\"<STR_LIT>\"]:<EOL><INDENT>new_report[metadata] = report[\"<STR_LIT>\"][metadata]<EOL><DEDENT>new_report[\"<STR_LIT>\"] = report[\"<STR_LIT>\"]<EOL>new_report[\"<STR_LIT>\"] = record[\"<STR_LIT:source>\"][<EOL>\"<STR_LIT>\"]<EOL>new_report[\"<STR_LIT>\"] = record[\"<STR_LIT:source>\"][\"<STR_LIT>\"]<EOL>new_report[\"<STR_LIT>\"] = record[\"<STR_LIT:source>\"][<EOL>\"<STR_LIT>\"]<EOL>new_report[\"<STR_LIT>\"] = record[\"<STR_LIT:source>\"][<EOL>\"<STR_LIT>\"]<EOL>new_report[\"<STR_LIT>\"] = record[\"<STR_LIT:count>\"]<EOL>new_report[\"<STR_LIT>\"] = record[\"<STR_LIT>\"][<EOL>\"<STR_LIT>\"<EOL>]<EOL>new_report[\"<STR_LIT>\"] = record[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>new_report[\"<STR_LIT>\"] = record[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>new_report[\"<STR_LIT>\"] = record[\"<STR_LIT>\"][\"<STR_LIT>\"]<EOL>new_report[\"<STR_LIT>\"] = record[\"<STR_LIT>\"][<EOL>\"<STR_LIT>\"]<EOL>new_report[\"<STR_LIT>\"] = record[\"<STR_LIT>\"][<EOL>\"<STR_LIT>\"]<EOL>if \"<STR_LIT>\" in record[\"<STR_LIT>\"]:<EOL><INDENT>new_report[\"<STR_LIT>\"] = record[\"<STR_LIT>\"][<EOL>\"<STR_LIT>\"]<EOL><DEDENT>if \"<STR_LIT>\" in record[\"<STR_LIT>\"]:<EOL><INDENT>new_report[\"<STR_LIT>\"] = record[\"<STR_LIT>\"][<EOL>\"<STR_LIT>\"]<EOL><DEDENT>data[\"<STR_LIT>\"] = \"<STR_LIT>\"<EOL>timestamp = human_timestamp_to_timestamp(<EOL>new_report[\"<STR_LIT>\"])<EOL>data[\"<STR_LIT:time>\"] = timestamp<EOL>data[\"<STR_LIT>\"] = new_report.copy()<EOL>json_str += \"<STR_LIT>\".format(json.dumps(data))<EOL><DEDENT><DEDENT>if not self.session.verify:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL><DEDENT>try:<EOL><INDENT>response = self.session.post(self.url, data=json_str,<EOL>timeout=self.timeout)<EOL>response = response.json()<EOL><DEDENT>except Exception as e:<EOL><INDENT>raise SplunkError(e.__str__())<EOL><DEDENT>if response[\"<STR_LIT:code>\"] != <NUM_LIT:0>:<EOL><INDENT>raise SplunkError(response[\"<STR_LIT:text>\"])<EOL><DEDENT>", "docstring": "Saves aggregate DMARC reports to Splunk\n\nArgs:\n    aggregate_reports: A list of aggregate report dictionaries\n    to save in Splunk", "id": "f15284:c1:m1"}
{"signature": "def set_hosts(hosts, use_ssl=False, ssl_cert_path=None):", "body": "if type(hosts) != list:<EOL><INDENT>hosts = [hosts]<EOL><DEDENT>conn_params = {<EOL>\"<STR_LIT>\": hosts,<EOL>\"<STR_LIT>\": <NUM_LIT:20><EOL>}<EOL>if use_ssl:<EOL><INDENT>conn_params['<STR_LIT>'] = True<EOL>if ssl_cert_path:<EOL><INDENT>conn_params['<STR_LIT>'] = True<EOL>conn_params['<STR_LIT>'] = ssl_cert_path<EOL><DEDENT>else:<EOL><INDENT>conn_params['<STR_LIT>'] = False<EOL><DEDENT><DEDENT>connections.create_connection(**conn_params)<EOL>", "docstring": "Sets the Elasticsearch hosts to use\n\nArgs:\n    hosts (str): A single hostname or URL, or list of hostnames or URLs\n    use_ssl (bool): Use a HTTPS connection to the server\n    ssl_cert_path (str): Path to the certificate chain", "id": "f15287:m0"}
{"signature": "def get_base_domain(domain, use_fresh_psl=False):", "body": "psl_path = os.path.join(tempdir, \"<STR_LIT>\")<EOL>def download_psl():<EOL><INDENT>url = \"<STR_LIT>\"<EOL>headers = {\"<STR_LIT>\": USER_AGENT}<EOL>fresh_psl = requests.get(url, headers=headers).text<EOL>with open(psl_path, \"<STR_LIT:w>\", encoding=\"<STR_LIT:utf-8>\") as fresh_psl_file:<EOL><INDENT>fresh_psl_file.write(fresh_psl)<EOL><DEDENT><DEDENT>if use_fresh_psl:<EOL><INDENT>if not os.path.exists(psl_path):<EOL><INDENT>download_psl()<EOL><DEDENT>else:<EOL><INDENT>psl_age = datetime.now() - datetime.fromtimestamp(<EOL>os.stat(psl_path).st_mtime)<EOL>if psl_age > timedelta(hours=<NUM_LIT>):<EOL><INDENT>try:<EOL><INDENT>download_psl()<EOL><DEDENT>except Exception as error:<EOL><INDENT>logger.warning(<EOL>\"<STR_LIT>\".format(error))<EOL><DEDENT><DEDENT><DEDENT>with open(psl_path, encoding=\"<STR_LIT:utf-8>\") as psl_file:<EOL><INDENT>psl = publicsuffix2.PublicSuffixList(psl_file)<EOL><DEDENT>return psl.get_public_suffix(domain)<EOL><DEDENT>else:<EOL><INDENT>return publicsuffix2.get_public_suffix(domain)<EOL><DEDENT>", "docstring": "Gets the base domain name for the given domain\n\n.. note::\n    Results are based on a list of public domain suffixes at\n    https://publicsuffix.org/list/public_suffix_list.dat.\n\nArgs:\n    domain (str): A domain or subdomain\n    use_fresh_psl (bool): Download a fresh Public Suffix List\n\nReturns:\n    str: The base domain of the given domain", "id": "f15289:m2"}
{"signature": "def get_filename_safe_string(string):", "body": "invalid_filename_chars = ['<STR_LIT:\\\\>', '<STR_LIT:/>', '<STR_LIT::>', '<STR_LIT:\">', '<STR_LIT:*>', '<STR_LIT:?>', '<STR_LIT:|>', '<STR_LIT:\\n>',<EOL>'<STR_LIT:\\r>']<EOL>if string is None:<EOL><INDENT>string = \"<STR_LIT:None>\"<EOL><DEDENT>for char in invalid_filename_chars:<EOL><INDENT>string = string.replace(char, \"<STR_LIT>\")<EOL><DEDENT>string = string.rstrip(\"<STR_LIT:.>\")<EOL>return string<EOL>", "docstring": "Converts a string to a string that is safe for a filename\nArgs:\n    string (str): A string to make safe for a filename\n\nReturns:\n    str: A string safe for a filename", "id": "f15289:m12"}
{"signature": "def as_future(self, query):", "body": "<EOL>if not self._pool:<EOL><INDENT>self._pool = ThreadPoolExecutor(max_workers=self._max_workers)<EOL><DEDENT>old_future = self._pool.submit(query)<EOL>new_future = Future()<EOL>IOLoop.current().add_future(<EOL>old_future, lambda f: chain_future(f, new_future)<EOL>)<EOL>return new_future<EOL>", "docstring": "Wrap a `sqlalchemy.orm.query.Query` object into a\n        `concurrent.futures.Future` so that it can be yielded.\n\n        Parameters\n        ----------\n        query : sqlalchemy.orm.query.Query\n            SQLAlchemy query object to execute\n\n        Returns\n        -------\n            tornado.concurrent.Future\n                A `Future` object wrapping the given query so that tornado can\n                await/yield on it", "id": "f15300:c1:m2"}
{"signature": "def __exit__(self, exc_type, exc_val, exc_tbf):", "body": "self.run_time = time.time() - self._start_time<EOL>signal.setitimer(signal.ITIMER_PROF, <NUM_LIT:0>)<EOL>", "docstring": "Disables statistical profiler.", "id": "f15314:c0:m2"}
{"signature": "def _profile_module(self):", "body": "with open(self._run_object, '<STR_LIT:rb>') as srcfile, _StatProfiler() as prof:<EOL><INDENT>code = compile(srcfile.read(), self._run_object, '<STR_LIT>')<EOL>prof.base_frame = inspect.currentframe()<EOL>try:<EOL><INDENT>exec(code, self._globs, None)<EOL><DEDENT>except SystemExit:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>call_tree = prof.call_tree<EOL>return {<EOL>'<STR_LIT>': self._object_name,<EOL>'<STR_LIT>': _SAMPLE_INTERVAL,<EOL>'<STR_LIT>': prof.run_time,<EOL>'<STR_LIT>': call_tree,<EOL>'<STR_LIT>': call_tree.get('<STR_LIT>', <NUM_LIT:0>),<EOL>'<STR_LIT>': int(time.time())<EOL>}<EOL>", "docstring": "Runs statistical profiler on a module.", "id": "f15314:c1:m2"}
{"signature": "@staticmethod<EOL><INDENT>def _handle_root():<DEDENT>", "body": "res_filename = os.path.join(<EOL>os.path.dirname(__file__), _PROFILE_HTML)<EOL>with io.open(res_filename, '<STR_LIT:rb>') as res_file:<EOL><INDENT>content = res_file.read()<EOL><DEDENT>return content, '<STR_LIT>'<EOL>", "docstring": "Handles index.html requests.", "id": "f15315:c1:m1"}
{"signature": "def _format_obj_count(objects):", "body": "result = []<EOL>regex = re.compile(r'<STR_LIT>')<EOL>for obj_type, obj_count in objects.items():<EOL><INDENT>if obj_count != <NUM_LIT:0>:<EOL><INDENT>match = re.findall(regex, repr(obj_type))<EOL>if match:<EOL><INDENT>obj_type, obj_name = match[<NUM_LIT:0>]<EOL>result.append((\"<STR_LIT>\" % (obj_type, obj_name), obj_count))<EOL><DEDENT><DEDENT><DEDENT>return sorted(result, key=operator.itemgetter(<NUM_LIT:1>), reverse=True)<EOL>", "docstring": "Formats object count.", "id": "f15316:m5"}
{"signature": "def __exit__(self, exc_type, exc_val, exc_tbf):", "body": "sys.settrace(self.original_trace_function)<EOL>if self.prev_timestamp:<EOL><INDENT>runtime = time.time() - self.prev_timestamp<EOL>self.lines.append([self.prev_path, self.prev_lineno, runtime])<EOL><DEDENT>", "docstring": "Disables heatmap calculator.", "id": "f15318:c0:m2"}
{"signature": "def _format_heatmap(self, filename, heatmap, execution_count):", "body": "with open(filename) as src_file:<EOL><INDENT>file_source = src_file.read().split('<STR_LIT:\\n>')<EOL>skip_map = self._calc_skips(heatmap, len(file_source))<EOL><DEDENT>run_time = sum(time for time in heatmap.values())<EOL>return {<EOL>'<STR_LIT:name>': filename,<EOL>'<STR_LIT>': heatmap,<EOL>'<STR_LIT>': execution_count,<EOL>'<STR_LIT>': self._skip_lines(file_source, skip_map),<EOL>'<STR_LIT>': run_time<EOL>}<EOL>", "docstring": "Formats heatmap for UI.", "id": "f15318:c1:m4"}
{"signature": "@property<EOL><INDENT>def lines_without_stdlib(self):<DEDENT>", "body": "prev_line = None<EOL>current_module_path = inspect.getabsfile(inspect.currentframe())<EOL>for module_path, lineno, runtime in self.lines:<EOL><INDENT>module_abspath = os.path.abspath(module_path)<EOL>if not prev_line:<EOL><INDENT>prev_line = [module_abspath, lineno, runtime]<EOL><DEDENT>else:<EOL><INDENT>if (not check_standard_dir(module_path) and<EOL>module_abspath != current_module_path):<EOL><INDENT>yield prev_line<EOL>prev_line = [module_abspath, lineno, runtime]<EOL><DEDENT>else:<EOL><INDENT>prev_line[<NUM_LIT:2>] += runtime<EOL><DEDENT><DEDENT><DEDENT>yield prev_line<EOL>", "docstring": "Filters code from standard library from self.lines.", "id": "f15318:c0:m4"}
{"signature": "def profile_function(self):", "body": "with _CodeHeatmapCalculator() as prof:<EOL><INDENT>result = self._run_object(*self._run_args, **self._run_kwargs)<EOL><DEDENT>code_lines, start_line = inspect.getsourcelines(self._run_object)<EOL>source_lines = []<EOL>for line in code_lines:<EOL><INDENT>source_lines.append(('<STR_LIT>', start_line, line))<EOL>start_line += <NUM_LIT:1><EOL><DEDENT>filename = os.path.abspath(inspect.getsourcefile(self._run_object))<EOL>heatmap = prof.heatmap[filename]<EOL>run_time = sum(time for time in heatmap.values())<EOL>return {<EOL>'<STR_LIT>': self._object_name,<EOL>'<STR_LIT>': run_time,<EOL>'<STR_LIT:result>': result,<EOL>'<STR_LIT>': int(time.time()),<EOL>'<STR_LIT>': [{<EOL>'<STR_LIT:name>': self._object_name,<EOL>'<STR_LIT>': heatmap,<EOL>'<STR_LIT>': prof.execution_count[filename],<EOL>'<STR_LIT>': source_lines,<EOL>'<STR_LIT>': run_time<EOL>}]<EOL>}<EOL>", "docstring": "Calculates heatmap for function.", "id": "f15318:c1:m7"}
{"signature": "@property<EOL><INDENT>def heatmap(self):<DEDENT>", "body": "if not self._heatmap:<EOL><INDENT>self.fill_heatmap()<EOL><DEDENT>return self._heatmap<EOL>", "docstring": "Returns heatmap with absolute path names.", "id": "f15318:c0:m6"}
{"signature": "def record_line(self, frame, event, arg):  ", "body": "if event == '<STR_LIT>':<EOL><INDENT>if self.prev_timestamp:<EOL><INDENT>runtime = time.time() - self.prev_timestamp<EOL>self.lines.append([self.prev_path, self.prev_lineno, runtime])<EOL><DEDENT>self.prev_lineno = frame.f_lineno<EOL>self.prev_path = frame.f_code.co_filename<EOL>self.prev_timestamp = time.time()<EOL><DEDENT>return self.record_line<EOL>", "docstring": "Records line execution time.", "id": "f15318:c0:m3"}
{"signature": "@staticmethod<EOL><INDENT>def _transform_stats(prof):<DEDENT>", "body": "records = []<EOL>for info, params in prof.stats.items():<EOL><INDENT>filename, lineno, funcname = info<EOL>cum_calls, num_calls, time_per_call, cum_time, _ = params<EOL>if prof.total_tt == <NUM_LIT:0>:<EOL><INDENT>percentage = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>percentage = round(<NUM_LIT:100> * (cum_time / prof.total_tt), <NUM_LIT:4>)<EOL><DEDENT>cum_time = round(cum_time, <NUM_LIT:4>)<EOL>func_name = '<STR_LIT>' % (funcname, filename)<EOL>color_hash = base_profiler.hash_name(func_name)<EOL>records.append(<EOL>(filename, lineno, funcname, cum_time, percentage, num_calls,<EOL>cum_calls, time_per_call, filename, color_hash))<EOL><DEDENT>return sorted(records, key=operator.itemgetter(<NUM_LIT:4>), reverse=True)<EOL>", "docstring": "Processes collected stats for UI.", "id": "f15319:c0:m0"}
{"signature": "def profile_function(self):", "body": "prof = cProfile.Profile()<EOL>prof.enable()<EOL>result = self._run_object(*self._run_args, **self._run_kwargs)<EOL>prof.disable()<EOL>prof_stats = pstats.Stats(prof)<EOL>prof_stats.calc_callees()<EOL>return {<EOL>'<STR_LIT>': self._object_name,<EOL>'<STR_LIT>': self._transform_stats(prof_stats),<EOL>'<STR_LIT>': prof_stats.total_tt,<EOL>'<STR_LIT>': prof_stats.prim_calls,<EOL>'<STR_LIT>': prof_stats.total_calls,<EOL>'<STR_LIT:result>': result,<EOL>'<STR_LIT>': int(time.time())<EOL>}<EOL>", "docstring": "Runs cProfile on a function.", "id": "f15319:c0:m5"}
{"signature": "def profile_package(self):", "body": "return base_profiler.run_in_separate_process(self._profile_package)<EOL>", "docstring": "Runs package profiler in separate process.", "id": "f15319:c0:m2"}
{"signature": "@property<EOL><INDENT>def output(self):<DEDENT>", "body": "return self.result._getvalue()<EOL>", "docstring": "Returns target function output.", "id": "f15320:c0:m3"}
{"signature": "def profile_function(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Profiles function.\n\n        Runs object self._run_object as a Python function.\n        Must be overridden.", "id": "f15320:c1:m8"}
{"signature": "def hash_name(name):", "body": "return zlib.adler32(name.encode('<STR_LIT:utf-8>'))<EOL>", "docstring": "Computes hash of the name.", "id": "f15320:m1"}
{"signature": "def run_in_separate_process(func, *args, **kwargs):", "body": "manager = multiprocessing.Manager()<EOL>manager_dict = manager.dict()<EOL>process = ProcessWithException(<EOL>manager_dict, target=func, args=args, kwargs=kwargs)<EOL>process.start()<EOL>process.join()<EOL>exc = process.exception<EOL>if exc:<EOL><INDENT>raise exc<EOL><DEDENT>return process.output<EOL>", "docstring": "Runs function in separate process.\n\n    This function is used instead of a decorator, since Python multiprocessing\n    module can't serialize decorated function on all platforms.", "id": "f15320:m2"}
{"signature": "def __init__(self, run_object):", "body": "run_obj_type = self.get_run_object_type(run_object)<EOL>if run_obj_type == '<STR_LIT>':<EOL><INDENT>self.init_module(run_object)<EOL><DEDENT>elif run_obj_type == '<STR_LIT>':<EOL><INDENT>self.init_package(run_object)<EOL><DEDENT>else:<EOL><INDENT>self.init_function(run_object)<EOL><DEDENT>", "docstring": "Initializes profiler.\n\n        Args:\n            run_object: object to be profiled.", "id": "f15320:c1:m0"}
{"signature": "def run_profilers(run_object, prof_config, verbose=False):", "body": "if len(prof_config) > len(set(prof_config)):<EOL><INDENT>raise AmbiguousConfigurationError(<EOL>'<STR_LIT>' % prof_config)<EOL><DEDENT>available_profilers = {opt for opt, _ in _PROFILERS}<EOL>for option in prof_config:<EOL><INDENT>if option not in available_profilers:<EOL><INDENT>raise BadOptionError('<STR_LIT>' % option)<EOL><DEDENT><DEDENT>run_stats = OrderedDict()<EOL>present_profilers = ((o, p) for o, p in _PROFILERS if o in prof_config)<EOL>for option, prof in present_profilers:<EOL><INDENT>curr_profiler = prof(run_object)<EOL>if verbose:<EOL><INDENT>print('<STR_LIT>' % curr_profiler.__class__.__name__)<EOL><DEDENT>run_stats[option] = curr_profiler.run()<EOL><DEDENT>return run_stats<EOL>", "docstring": "Runs profilers on run_object.\n\n    Args:\n        run_object: An object (string or tuple) for profiling.\n        prof_config: A string with profilers configuration.\n        verbose: True if info about running profilers should be shown.\n    Returns:\n        An ordered dictionary with collected stats.\n    Raises:\n        AmbiguousConfigurationError: when prof_config is ambiguous.\n        BadOptionError: when unknown options are present in configuration.", "id": "f15321:m0"}
{"signature": "@app.route('<STR_LIT>', methods=['<STR_LIT:GET>', '<STR_LIT:POST>'])<EOL>def profiler_handler(uri):", "body": "<EOL>if uri == '<STR_LIT>':<EOL><INDENT>runner.run(show_guestbook, '<STR_LIT>')<EOL><DEDENT>elif uri == '<STR_LIT>':<EOL><INDENT>runner.run(add_entry, '<STR_LIT>')<EOL><DEDENT>return flask.redirect('<STR_LIT:/>')<EOL>", "docstring": "Profiler handler.", "id": "f15322:m6"}
{"signature": "@app.route('<STR_LIT>', methods=['<STR_LIT:POST>'])<EOL>def add_entry():", "body": "name, msg = flask.request.form['<STR_LIT:name>'], flask.request.form['<STR_LIT:message>']<EOL>flask.g.db.execute(<EOL>'<STR_LIT>', (name, msg))<EOL>flask.g.db.commit()<EOL>return flask.redirect('<STR_LIT:/>')<EOL>", "docstring": "Adds single guestbook record.", "id": "f15322:m5"}
{"signature": "def connect_to_db():", "body": "return sqlite3.connect(DB)<EOL>", "docstring": "Establishes connection to SQLite.", "id": "f15322:m0"}
{"signature": "def init_db():", "body": "with contextlib.closing(connect_to_db()) as db:<EOL><INDENT>db.cursor().executescript(DB_SCHEMA)<EOL>db.commit()<EOL><DEDENT>", "docstring": "Initializes DB.", "id": "f15322:m1"}
{"signature": "@app.route('<STR_LIT:/>')<EOL>def show_guestbook():", "body": "cursor = flask.g.db.execute(<EOL>'<STR_LIT>')<EOL>entries = [{'<STR_LIT:name>': row[<NUM_LIT:0>], '<STR_LIT:message>': row[<NUM_LIT:1>]} for row in cursor.fetchall()]<EOL>return jinja2.Template(LAYOUT).render(entries=entries)<EOL>", "docstring": "Returns all existing guestbook records.", "id": "f15322:m4"}
{"signature": "def get_description():", "body": "with open('<STR_LIT>') as readme_file:<EOL><INDENT>return readme_file.read()<EOL><DEDENT>", "docstring": "Reads README.md file.", "id": "f15324:m1"}
{"signature": "def random_adjspecies_pair(maxlen=None, prevent_stutter=True):", "body": "while True:<EOL><INDENT>pair = _random_adjspecies_pair()<EOL>if maxlen and len('<STR_LIT>'.join(pair)) > maxlen:<EOL><INDENT>continue<EOL><DEDENT>if prevent_stutter and pair[<NUM_LIT:0>][-<NUM_LIT:1>] == pair[<NUM_LIT:1>][<NUM_LIT:0>]:<EOL><INDENT>continue<EOL><DEDENT>return pair<EOL><DEDENT>", "docstring": "Return an ordered 2-tuple containing a species and a describer.\nThe letter-count of the pair is guarantee to not exceed `maxlen` if\nit is given. If `prevent_stutter` is True, the last letter of the\nfirst item of the pair will be different from the first letter of\nthe second item.", "id": "f15325:m5"}
{"signature": "def random_describer():", "body": "return choice(get_describers())<EOL>", "docstring": "Return a 2-tuple, matching a describer to 'prefix' or 'suffix'.", "id": "f15325:m3"}
{"signature": "def random_adjspecies(sep='<STR_LIT>', maxlen=<NUM_LIT:8>, prevent_stutter=True):", "body": "pair = random_adjspecies_pair(maxlen, prevent_stutter)<EOL>return pair[<NUM_LIT:0>] + sep + pair[<NUM_LIT:1>]<EOL>", "docstring": "Return a random adjective/species, separated by `sep`. The keyword\narguments `maxlen` and `prevent_stutter` are the same as for\n`random_adjspecies_pair`, but note that the maximum length argument is\nnot affected by the separator.", "id": "f15325:m6"}
{"signature": "def random_species():", "body": "return choice(get_file_lines('<STR_LIT>'))<EOL>", "docstring": "Return the name of a species at random.", "id": "f15325:m1"}
{"signature": "def get_file_lines(file_name):", "body": "file_path = path.join(path.dirname(path.abspath(__file__)), file_name)<EOL>with open(file_path) as file_obj:<EOL><INDENT>return [line for line in file_obj.read().splitlines() if line]<EOL><DEDENT>", "docstring": "Return a list of non-empty lines from `file_path`.", "id": "f15325:m0"}
{"signature": "@staticmethod<EOL><INDENT>def read_param_file_to_dict(file_name):<DEDENT>", "body": "data = loadtxt(file_name, delimiter='<STR_LIT:=>', dtype=scipy.string0)<EOL>data_dict = dict(data)<EOL>for key in data_dict.keys():<EOL><INDENT>data_dict[key] = data_dict[key].strip()<EOL>data_dict[key.strip()] = data_dict[key]<EOL>del data_dict[key]<EOL><DEDENT>return data_dict<EOL>", "docstring": "Loads a text file to a python dictionary using '=' as the delimiter\n\n        :param file_name: the name and path of the text file", "id": "f15328:c3:m1"}
{"signature": "def run(self):", "body": "done = False<EOL>dir_list = []<EOL>tic = time.clock()<EOL>lg.info('<STR_LIT>' + str(tic))<EOL>if self.run_params.num_cpus == -<NUM_LIT:1>:  <EOL><INDENT>self.run_params.num_cpus = os.sysconf(\"<STR_LIT>\")<EOL>lg.info('<STR_LIT>' + str(self.run_params.num_cpus) + '<STR_LIT>')<EOL><DEDENT>tmp_dir_list = os.listdir(self.batch_output)<EOL>for direc in tmp_dir_list:<EOL><INDENT>dir_list.append(os.path.join(self.batch_output, direc))<EOL><DEDENT>num_dirs = len(dir_list)<EOL>lg.info('<STR_LIT>' + str(num_dirs) + '<STR_LIT>' + self.batch_output)<EOL>sub = scipy.floor(num_dirs / self.run_params.num_cpus)<EOL>remainder = num_dirs - (sub * self.run_params.num_cpus)<EOL>if remainder > <NUM_LIT:0>:<EOL><INDENT>lg.warning('<STR_LIT>')<EOL>lg.warning('<STR_LIT>')<EOL>lg.warning('<STR_LIT>' + str(remainder))<EOL><DEDENT>while not done:<EOL><INDENT>for l in range(<NUM_LIT:0>, int(sub)):<EOL><INDENT>lg.info('<STR_LIT>' + str(self.run_params.num_cpus) + '<STR_LIT>')<EOL>for m in range(<NUM_LIT:0>, self.run_params.num_cpus):<EOL><INDENT>_dir = dir_list.pop()<EOL>report_dir, report_file_name = os.path.split(self.run_params.report_file)<EOL>lg.debug(report_file_name)<EOL>lg.debug(os.path.join(_dir, report_file_name))<EOL>try:<EOL><INDENT>rep_size = os.path.getsize(os.path.join(_dir, report_file_name.strip('<STR_LIT:\\n>')))<EOL>lg.debug('<STR_LIT>' + str(rep_size))<EOL><DEDENT>except:<EOL><INDENT>rep_size = <NUM_LIT:0><EOL><DEDENT>if rep_size < <NUM_LIT:1.0>:  <EOL><INDENT>lg.info('<STR_LIT>')<EOL>p = Process(target=self._run, args=(_dir,))<EOL><DEDENT>else:<EOL><INDENT>lg.warning('<STR_LIT>' + os.path.join(_dir, report_file_name.strip(<EOL>'<STR_LIT:\\n>')) + '<STR_LIT>')<EOL>p = Process(target=self._dummy, args=(_dir,))<EOL><DEDENT>p.start()<EOL>lg.info('<STR_LIT>' + str(p.pid))<EOL><DEDENT>p.join()<EOL><DEDENT>self.run_params.num_cpus = remainder<EOL>remainder = <NUM_LIT:0><EOL>lg.info('<STR_LIT>')<EOL>sub = <NUM_LIT:1><EOL>if remainder == <NUM_LIT:0>:<EOL><INDENT>done = True<EOL><DEDENT><DEDENT>toc = time.clock()  <EOL>lg.info('<STR_LIT>' + str(toc))<EOL>timeTaken = toc - tic<EOL>lg.info('<STR_LIT>' + str(timeTaken))<EOL>", "docstring": "Distributes the work across the CPUs.  It actually uses _run()", "id": "f15328:c2:m1"}
{"signature": "def write_surf_params_to_file(self):", "body": "inp_file = self.water_surface_file + '<STR_LIT>'<EOL>lg.info('<STR_LIT>' + inp_file)<EOL>if self.surf_state == '<STR_LIT>':  <EOL><INDENT>lg.info('<STR_LIT>')<EOL>f = open(inp_file, '<STR_LIT:w>')<EOL>f.write('<STR_LIT>' + str(self.verbose) + '<STR_LIT:\\n>')<EOL>f.write('<STR_LIT>' + str(self.num_bands) + '<STR_LIT:\\n>')<EOL>f.write('<STR_LIT>')<EOL>f.write(\"<STR_LIT:U+002C>\".join([str(wave) for wave in self.wavelengths]) + '<STR_LIT:\\n>')<EOL>f.write('<STR_LIT>' + self.partition + '<STR_LIT:\\n>')<EOL>f.write('<STR_LIT>' + str(self.vn) + '<STR_LIT:\\n>')<EOL>f.write('<STR_LIT>' + str(self.hn) + '<STR_LIT:\\n>')<EOL>f.write('<STR_LIT>')<EOL>f.write(\"<STR_LIT:U+002C>\".join([str(theta) for theta in self.theta_points]) + '<STR_LIT:\\n>')<EOL>f.write('<STR_LIT>' + self.iface_type + '<STR_LIT:\\n>')<EOL>f.write('<STR_LIT>' + str(self.iface_0_ri) + '<STR_LIT:\\n>')<EOL>f.write('<STR_LIT>' + str(self.iface_1_ri) + '<STR_LIT:\\n>')<EOL>f.write('<STR_LIT>' + str(self.wind_speed) + '<STR_LIT:\\n>')<EOL>f.write('<STR_LIT>' + str(self.wind_direc) + '<STR_LIT:\\n>')<EOL>f.write('<STR_LIT>' + str(self.crosswind_vertices) + '<STR_LIT:\\n>')<EOL>f.write('<STR_LIT>' + str(self.upwind_vertices) + '<STR_LIT:\\n>')<EOL>f.write('<STR_LIT>' + str(self.surface_size) + '<STR_LIT:\\n>')<EOL>f.write('<STR_LIT>' + str(self.surface_radius) + '<STR_LIT:\\n>')<EOL>f.write('<STR_LIT>' + str(self.target_size) + '<STR_LIT:\\n>')<EOL>f.write('<STR_LIT>' + str(self.rays_per_quad) + '<STR_LIT:\\n>')<EOL>f.write('<STR_LIT>' + str(self.surface_count) + '<STR_LIT:\\n>')<EOL>f.write('<STR_LIT>' + str(self.azimuthally_average) + '<STR_LIT:\\n>')<EOL>f.write('<STR_LIT>' + inp_file.strip('<STR_LIT>') + '<STR_LIT:\\n>')<EOL>f.flush()<EOL>f.close()<EOL><DEDENT>", "docstring": "Write the params to file that surftool_Free needs to generate the surface facets", "id": "f15328:c0:m3"}
{"signature": "def build_b(self, scattering_fraction=<NUM_LIT>):", "body": "lg.info('<STR_LIT>' + str(scattering_fraction))<EOL>self.b = (self.b_b + self.b_water / <NUM_LIT>) / scattering_fraction<EOL>", "docstring": "Calculates the total scattering from back-scattering\n\n        :param scattering_fraction: the fraction of back-scattering to total scattering default = 0.01833\n\n        b = ( bb[sea water] + bb[p] ) /0.01833", "id": "f15328:c1:m12"}
{"signature": "def write_sky_params_to_file(self):", "body": "inp_file = self.sky_file + '<STR_LIT>'<EOL>lg.info('<STR_LIT>' + inp_file)<EOL>f = open(inp_file, '<STR_LIT:w>')<EOL>f.write('<STR_LIT>' + str(self.verbose) + '<STR_LIT:\\n>')<EOL>f.write('<STR_LIT>' + str(self.num_bands) + '<STR_LIT:\\n>')<EOL>f.write('<STR_LIT>')<EOL>f.write(\"<STR_LIT:U+002C>\".join([str(wave) for wave in self.wavelengths]) + '<STR_LIT:\\n>')<EOL>f.write('<STR_LIT>' + self.partition + '<STR_LIT:\\n>')<EOL>f.write('<STR_LIT>' + str(self.vn) + '<STR_LIT:\\n>')<EOL>f.write('<STR_LIT>' + str(self.hn) + '<STR_LIT:\\n>')<EOL>f.write('<STR_LIT>' + str(self.sky_r_dif) + '<STR_LIT:\\n>')<EOL>f.write('<STR_LIT>')<EOL>f.write(\"<STR_LIT:U+002C>\".join([str(theta) for theta in self.theta_points]) + '<STR_LIT:\\n>')<EOL>f.write('<STR_LIT>' + self.sky_type + '<STR_LIT:\\n>')<EOL>f.write('<STR_LIT>' + str(self.sky_azimuth) + '<STR_LIT:\\n>')<EOL>f.write('<STR_LIT>' + str(self.sky_zenith) + '<STR_LIT:\\n>')<EOL>f.write('<STR_LIT>' + inp_file.strip('<STR_LIT>') + '<STR_LIT:\\n>')<EOL>f.write('<STR_LIT>' + self.sky_file + '<STR_LIT>' + '<STR_LIT:\\n>')<EOL>f.write('<STR_LIT>' + '<STR_LIT:\\n>')<EOL>if self.sky_type == '<STR_LIT>':<EOL><INDENT>f.write('<STR_LIT>' + str(self.sky_c) + '<STR_LIT:\\n>')<EOL>f.write('<STR_LIT>' + str(self.sky_r_dif) + '<STR_LIT:\\n>')<EOL><DEDENT>f.flush()<EOL>f.close()<EOL>", "docstring": "Writes the params to file that skytool_Free needs to generate the sky radiance distribution.", "id": "f15328:c0:m2"}
{"signature": "def __init__(self, wavelengths):", "body": "self.wavelengths = scipy.asarray([wavelengths])<EOL>self.b_bp = scipy.asarray([])<EOL>self.a_cdom = scipy.asarray([])<EOL>self.a_phi = scipy.asarray([])<EOL>self.a_water = scipy.asarray([])<EOL>self.b_water = scipy.asarray([])<EOL>self.b_b = scipy.asarray([])<EOL>self.b = scipy.asarray([])<EOL>self.a = scipy.asarray([])<EOL>self.c = scipy.asarray([])<EOL>", "docstring": "Constructor\n\n        :param wavelengths: list of wavelengths all IOPs will be interpolated to", "id": "f15328:c1:m0"}
{"signature": "def _read_iop_from_file(self, file_name):", "body": "lg.info('<STR_LIT>' + file_name + '<STR_LIT>' + str(self.wavelengths))<EOL>if os.path.isfile(file_name):<EOL><INDENT>iop_reader = csv.reader(open(file_name), delimiter='<STR_LIT:U+002C>', quotechar='<STR_LIT:\">')<EOL>wave = iop_reader.next()<EOL>iop = iop_reader.next()<EOL><DEDENT>else:<EOL><INDENT>lg.exception('<STR_LIT>' + file_name)<EOL>raise IOError<EOL><DEDENT>try:<EOL><INDENT>wave = map(float, wave)<EOL>iop = map(float, iop)<EOL>return scipy.interp(self.wavelengths, wave, iop)<EOL><DEDENT>except IOError:<EOL><INDENT>lg.exception('<STR_LIT>')<EOL>return -<NUM_LIT:1><EOL><DEDENT>", "docstring": "Generic IOP reader that interpolates the iop to the common wavelengths defined in the constructor\n\n:param file_name: filename and path of the csv file\n:returns interpolated iop", "id": "f15328:c1:m7"}
{"signature": "def write_phase_params_to_file(self):", "body": "inp_file = os.path.join(os.path.join(self.input_path, '<STR_LIT>'), self.phase_function_file) + '<STR_LIT>'<EOL>lg.info('<STR_LIT>' + inp_file)<EOL>if self.iop_type == '<STR_LIT>' or '<STR_LIT>' or '<STR_LIT>' or '<STR_LIT>':<EOL><INDENT>lg.info('<STR_LIT>' + self.iop_type)<EOL>f = open(inp_file, '<STR_LIT:w>')<EOL>f.write('<STR_LIT>' + str(self.verbose) + '<STR_LIT:\\n>')<EOL>f.write('<STR_LIT>' + str(self.num_bands) + '<STR_LIT:\\n>')<EOL>f.write('<STR_LIT>')<EOL>f.write(\"<STR_LIT:U+002C>\".join([str(wave) for wave in self.wavelengths]) + '<STR_LIT:\\n>')<EOL>f.write('<STR_LIT>' + self.partition + '<STR_LIT:\\n>')<EOL>f.write('<STR_LIT>' + str(self.vn) + '<STR_LIT:\\n>')<EOL>f.write('<STR_LIT>' + str(self.hn) + '<STR_LIT:\\n>')<EOL>f.write('<STR_LIT>')<EOL>f.write(\"<STR_LIT:U+002C>\".join([str(theta) for theta in self.theta_points]) + '<STR_LIT:\\n>')<EOL>f.write('<STR_LIT>' + self.iop_type + '<STR_LIT:\\n>')<EOL>f.write('<STR_LIT>' + inp_file.strip('<STR_LIT>') + '<STR_LIT:\\n>')<EOL>f.flush()<EOL>f.close()<EOL><DEDENT>", "docstring": "Write the params to file that surftool_Free needs to generate the surface facets", "id": "f15328:c0:m4"}
{"signature": "@staticmethod<EOL><INDENT>def dict_to_object(data_object, data_dict):<DEDENT>", "body": "data_object.__dict__ = data_dict<EOL>return data_object<EOL>", "docstring": "Maps a dictionary to an object.  Variable names become the key in the dict\n\n        :param data_object: Is an instantiated class\n        :param data_dict: is the python dictionary\n        :returns data_object:", "id": "f15328:c3:m2"}
{"signature": "def display_graphic(self, flag_curves, ui):", "body": "ui.graphic_widget.canvas.picture.clear()<EOL>x = scipy.linspace(self.x_data[<NUM_LIT:0>], self.x_data[-<NUM_LIT:1>], len(self.x_data))  <EOL>curve_wanted = <NUM_LIT:0>  <EOL>for curve in self.y_data:<EOL><INDENT>if flag_curves:<EOL><INDENT>if curve_wanted == self.num_plot:  <EOL><INDENT>ui.graphic_widget.canvas.picture.plot(x, curve, '<STR_LIT>',<EOL>label='<STR_LIT>'.format(str(curve_wanted + <NUM_LIT:1>),<EOL>str(len(self.y_data))),<EOL>linewidth=<NUM_LIT:4>)<EOL><DEDENT>else:<EOL><INDENT>ui.graphic_widget.canvas.picture.plot(x, curve, '<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if curve_wanted == self.num_plot:<EOL><INDENT>ui.graphic_widget.canvas.picture.plot(x, curve, '<STR_LIT>',<EOL>label='<STR_LIT>'.format(str(curve_wanted + <NUM_LIT:1>),<EOL>str(len(self.y_data))))<EOL><DEDENT><DEDENT>curve_wanted += <NUM_LIT:1><EOL><DEDENT>ui.graphic_widget.canvas.picture.set_title('<STR_LIT>')<EOL>ui.graphic_widget.canvas.picture.set_xlabel('<STR_LIT>')<EOL>ui.graphic_widget.canvas.picture.set_ylabel('<STR_LIT>')<EOL>self.legend = ui.graphic_widget.canvas.picture.legend()  <EOL>ui.graphic_widget.canvas.picture.legend(bbox_to_anchor=(<NUM_LIT>, <NUM_LIT>))<EOL>ui.graphic_widget.canvas.draw()<EOL>", "docstring": "This function plots results of a file into the canvas.\nInputs : flag_curves : A boolean to know with we have to plot all curves or not.\n         ui : The main_Window.", "id": "f15341:c0:m2"}
{"signature": "def open_about(self):", "body": "self.aboutWindow.show()<EOL>", "docstring": "This function opens the default browser and go on the web page about planarRad and its GUI.", "id": "f15342:c0:m23"}
{"signature": "def write_to_file(self):", "body": "bt = BatchFile(self.batch_name_value, self.p_values, self.x_value, self.y_value, self.g_value, self.s_value,<EOL>self.z_value, self.wavelength_values, self.verbose_value, self.phytoplankton_path,<EOL>self.bottom_path, self.nb_cpu, self.executive_path, self.saa_values,<EOL>self.sza_values, self.report_parameter_value)<EOL>bt.write_batch_to_file(str(self.batch_name_value + \"<STR_LIT>\"))<EOL>", "docstring": "This function calls \"gui_batch.py\" with inputs values to write the batch file.", "id": "f15342:c0:m7"}
{"signature": "def display_the_graphic(self, num_line, wavelength, data_wanted, information):", "body": "self.nb_case = num_line - <NUM_LIT:1>  <EOL>self.graphic_slider(self.nb_case)<EOL>self.mpl_canvas.update_fields(wavelength, data_wanted, self.slider_value)<EOL>if self.ui.show_grid.checkState() == <NUM_LIT:2>:<EOL><INDENT>grid = True<EOL><DEDENT>else:<EOL><INDENT>grid = False<EOL><DEDENT>if self.ui.show_all_curves.checkState() == <NUM_LIT:2>:<EOL><INDENT>self.flag_curves = True<EOL>self.mpl_canvas.display_graphic(self.flag_curves, self.ui, grid)<EOL>self.print_graphic_information(self.slider_value, information)<EOL><DEDENT>else:<EOL><INDENT>self.flag_curves = False<EOL>self.mpl_canvas.display_graphic(self.flag_curves, self.ui, grid)<EOL>self.print_graphic_information(self.slider_value, information)<EOL><DEDENT>", "docstring": "This function calls the class \"MplCanvas\" of \"gui_matplotlibwidgetFile.py\" to plot results.\nInputs : num_line : The number of cases.\n         wavelength : The wavelengths.\n         data_wanted : The data for wavelengths.\n         information : The array which contains the information, of all curves to display.", "id": "f15342:c0:m9"}
{"signature": "def graphic_context_menu(self, pos):", "body": "menu = QtGui.QMenu()<EOL>self.actionSave_bis = menu.addAction(\"<STR_LIT>\")<EOL>self.actionSave_as_bis = menu.addAction(\"<STR_LIT>\")<EOL>action = menu.exec_(self.table_widget.mapFromGlobal(pos))<EOL>if action == self.actionSave_bis:<EOL><INDENT>self.save_figure()<EOL><DEDENT>elif action == self.actionSave_as_bis:<EOL><INDENT>self.save_figure_as()<EOL><DEDENT>", "docstring": "This function will open a context menu on the graphic to save it.\nInputs : pos : The position of the mouse cursor.", "id": "f15342:c0:m30"}
{"signature": "def check_values(self):", "body": "error_color = '<STR_LIT>'<EOL>no_error_color = '<STR_LIT>'  <EOL>self.error_batch_name = False<EOL>self.error_report_parameter = False<EOL>self.error_saa_result = False<EOL>self.error_sza_result = False<EOL>self.error_p_result = False<EOL>self.error_wavelength_result = False<EOL>self.error_x_result = False<EOL>self.error_y_result = False<EOL>self.error_g_result = False<EOL>self.error_s_result = False<EOL>self.error_z_result = False<EOL>self.error_verbose_result = False<EOL>self.error_phytoplankton_path_result = False<EOL>self.error_bottom_path_result = False<EOL>self.error_executive_path_result = False<EOL>\"\"\"<STR_LIT>\"\"\"<EOL>if self.ui.tabWidget.currentIndex() == TabWidget.NORMAL_MODE:<EOL><INDENT>check_num = '<STR_LIT>'  <EOL>self.prog = re.compile(check_num)  <EOL>batch_name_result = self.prog.search(<EOL>self.batch_name_value)  <EOL>report_parameter_result = self.prog.search(self.report_parameter_value)<EOL>try:<EOL><INDENT>if (self.ui.batch_name_value.text().isEmpty()) | (<EOL>batch_name_result.group() != self.ui.batch_name_value.text()):<EOL><INDENT>self.ui.batch_name_label.setStyleSheet(error_color)<EOL>self.error_batch_name = True<EOL><DEDENT>else:<EOL><INDENT>self.ui.batch_name_label.setStyleSheet(no_error_color)<EOL>self.error_batch_name = False<EOL><DEDENT><DEDENT>except AttributeError:<EOL><INDENT>self.ui.batch_name_label.setStyleSheet(error_color)<EOL>self.error_batch_name = True<EOL><DEDENT>try:<EOL><INDENT>if (self.ui.report_parameter_value.text().isEmpty()) | (<EOL>report_parameter_result.group() != self.ui.report_parameter_value.text()):<EOL><INDENT>self.ui.report_parameter_label.setStyleSheet(error_color)<EOL>self.error_report_parameter = True<EOL><DEDENT>else:<EOL><INDENT>self.ui.report_parameter_label.setStyleSheet(no_error_color)<EOL>self.error_report_parameter = False<EOL><DEDENT><DEDENT>except AttributeError:<EOL><INDENT>self.ui.report_parameter_label.setStyleSheet(error_color)<EOL>self.error_report_parameter = True<EOL><DEDENT>\"\"\"<STR_LIT>\"\"\"<EOL>check_num_2 = '<STR_LIT>'<EOL>self.prog_2 = re.compile(check_num_2)<EOL>x_result = self.prog_2.search(self.x_value)<EOL>y_result = self.prog_2.search(self.y_value)<EOL>g_result = self.prog_2.search(self.g_value)<EOL>s_result = self.prog_2.search(self.s_value)<EOL>z_result = self.prog_2.search(self.z_value)<EOL>try:<EOL><INDENT>if x_result.group() != self.ui.x_value.text():<EOL><INDENT>self.ui.particles_label.setStyleSheet(error_color)<EOL>self.ui.x_label.setStyleSheet(error_color)<EOL>self.error_x_result = True<EOL><DEDENT>else:<EOL><INDENT>self.ui.particles_label.setStyleSheet(no_error_color)<EOL>self.ui.x_label.setStyleSheet(no_error_color)<EOL>self.error_x_result = False<EOL><DEDENT><DEDENT>except AttributeError:<EOL><INDENT>self.ui.particles_label.setStyleSheet(no_error_color)<EOL>self.ui.x_label.setStyleSheet(error_color)<EOL>self.error_x_result = True<EOL><DEDENT>try:<EOL><INDENT>if y_result.group() != self.ui.y_value.text():<EOL><INDENT>self.ui.particles_label.setStyleSheet(error_color)<EOL>self.ui.y_label.setStyleSheet(error_color)<EOL>self.error_y_result = True<EOL><DEDENT>else:<EOL><INDENT>self.ui.particles_label.setStyleSheet(no_error_color)<EOL>self.ui.y_label.setStyleSheet(no_error_color)<EOL>self.error_y_result = False<EOL><DEDENT><DEDENT>except AttributeError:<EOL><INDENT>self.ui.particles_label.setStyleSheet(error_color)<EOL>self.ui.y_label.setStyleSheet(error_color)<EOL>self.error_y_result = True<EOL><DEDENT>try:<EOL><INDENT>if g_result.group() != self.ui.g_value.text():<EOL><INDENT>self.ui.organic_label.setStyleSheet(error_color)<EOL>self.ui.g_label.setStyleSheet(error_color)<EOL>self.error_g_result = True<EOL><DEDENT>else:<EOL><INDENT>self.ui.organic_label.setStyleSheet(no_error_color)<EOL>self.ui.g_label.setStyleSheet(no_error_color)<EOL>self.error_g_result = False<EOL><DEDENT><DEDENT>except AttributeError:<EOL><INDENT>self.ui.organic_label.setStyleSheet(error_color)<EOL>self.ui.g_label.setStyleSheet(error_color)<EOL>self.error_g_result = True<EOL><DEDENT>try:<EOL><INDENT>if s_result.group() != self.ui.s_value.text():<EOL><INDENT>self.ui.organic_label.setStyleSheet(error_color)<EOL>self.ui.s_label.setStyleSheet(error_color)<EOL>self.error_s_result = True<EOL><DEDENT>else:<EOL><INDENT>self.ui.organic_label.setStyleSheet(no_error_color)<EOL>self.ui.s_label.setStyleSheet(no_error_color)<EOL>self.error_x_result = False<EOL><DEDENT><DEDENT>except AttributeError:<EOL><INDENT>self.ui.organic_label.setStyleSheet(error_color)<EOL>self.ui.s_label.setStyleSheet(error_color)<EOL>self.error_x_result = True<EOL><DEDENT>try:<EOL><INDENT>if z_result.group() != self.ui.z_value.text():<EOL><INDENT>self.ui.z_label.setStyleSheet(error_color)<EOL>self.error_z_result = True<EOL><DEDENT>else:<EOL><INDENT>self.ui.z_label.setStyleSheet(no_error_color)<EOL>self.error_z_result = False<EOL><DEDENT><DEDENT>except AttributeError:<EOL><INDENT>self.ui.z_label.setStyleSheet(error_color)<EOL>self.error_z_result = True<EOL><DEDENT>check_num_3 = '<STR_LIT>'<EOL>self.prog_3 = re.compile(check_num_3)<EOL>verbose_result = self.prog_3.search(self.verbose_value)<EOL>try:<EOL><INDENT>if verbose_result.group() != self.ui.verbose_value.text():<EOL><INDENT>self.ui.verbose_label.setStyleSheet(error_color)<EOL>self.error_verbose_result = True<EOL><DEDENT>else:<EOL><INDENT>self.ui.verbose_label.setStyleSheet(no_error_color)<EOL>self.error_verbose_result = False<EOL><DEDENT><DEDENT>except AttributeError:<EOL><INDENT>self.ui.verbose_label.setStyleSheet(error_color)<EOL>self.error_verbose_result = True<EOL><DEDENT>\"\"\"<STR_LIT>\"\"\"<EOL>check_num_4 = '<STR_LIT>'  <EOL>self.prog_4 = re.compile(check_num_4)<EOL>phytoplankton_path_result = self.prog_4.search(self.phytoplankton_path)<EOL>bottom_path_result = self.prog_4.search(self.bottom_path)<EOL>executive_path_result = self.prog_4.search(self.executive_path)<EOL>try:<EOL><INDENT>if phytoplankton_path_result.group() != self.ui.phyto_path.text():<EOL><INDENT>self.ui.phyto_label.setStyleSheet(error_color)<EOL>self.error_phytoplankton_path_result = True<EOL><DEDENT>else:<EOL><INDENT>self.ui.phyto_label.setStyleSheet(no_error_color)<EOL>self.error_phytoplankton_path_result = False<EOL><DEDENT><DEDENT>except AttributeError:<EOL><INDENT>self.ui.phyto_label.setStyleSheet(error_color)<EOL>self.error_phytoplankton_path_result = True<EOL><DEDENT>try:<EOL><INDENT>if bottom_path_result.group() != self.ui.bottom_path.text():<EOL><INDENT>self.ui.bottom_label.setStyleSheet(error_color)<EOL>self.error_bottom_path_result = True<EOL><DEDENT>else:<EOL><INDENT>self.ui.bottom_label.setStyleSheet(no_error_color)<EOL>self.error_bottom_path_result = False<EOL><DEDENT><DEDENT>except AttributeError:<EOL><INDENT>self.ui.bottom_label.setStyleSheet(error_color)<EOL>self.error_bottom_path_result = True<EOL><DEDENT>try:<EOL><INDENT>if executive_path_result.group() != self.ui.exec_path.text():<EOL><INDENT>self.ui.execPath_label.setStyleSheet(error_color)<EOL>self.error_executive_path_result = True<EOL><DEDENT>else:<EOL><INDENT>self.ui.execPath_label.setStyleSheet(no_error_color)<EOL>self.error_executive_path_result = False<EOL><DEDENT><DEDENT>except AttributeError:<EOL><INDENT>self.ui.execPath_label.setStyleSheet(error_color)<EOL>self.error_executive_path_result = True<EOL><DEDENT><DEDENT>if (self.error_batch_name == True) | (self.error_report_parameter == True) | (<EOL>self.error_saa_result == True) | (self.error_sza_result == True) | (<EOL>self.error_p_result == True) | (self.error_wavelength_result == True) | (<EOL>self.error_x_result == True) | (self.error_y_result == True) | (<EOL>self.error_g_result == True) | (self.error_s_result == True) | (<EOL>self.error_z_result == True) | (self.error_verbose_result == True) | (<EOL>self.error_phytoplankton_path_result == True) | (self.error_bottom_path_result == True) | (<EOL>self.error_executive_path_result == True):<EOL><INDENT>self.without_error = False<EOL><DEDENT>else:<EOL><INDENT>self.without_error = True<EOL><DEDENT>", "docstring": "This function checks if there is no problem about values given.\nIf there is a problem with a or some values, their label's color is changed to red,\nand call a function to display an error message.\nIf there is no problem, their label, if it is necessary, is changed to grey (default color).", "id": "f15342:c0:m6"}
{"signature": "def prerequisite_actions(self):", "body": "self.hide_error_message()<EOL>self.ui.show_all_curves.setDisabled(True)<EOL>self.ui.sens.setDisabled(True)<EOL>self.ui.show_grid.setDisabled(True)<EOL>pathname = os.path.dirname(sys.argv[<NUM_LIT:0>])<EOL>path = os.path.abspath(pathname)<EOL>self.verbose_value = self.ui.verbose_value.setText(\"<STR_LIT>\")<EOL>self.report_parameter_value = self.ui.report_parameter_value.setText(\"<STR_LIT>\")<EOL>self.ui.progressBar.reset()<EOL>", "docstring": "This function does all required actions at the beginning when we run the GUI.", "id": "f15342:c0:m26"}
{"signature": "def click(self, event):", "body": "if event.button == <NUM_LIT:3>:<EOL><INDENT>if self.ui.tabWidget.currentIndex() == TabWidget.NORMAL_MODE:<EOL><INDENT>self.pos = QtGui.QCursor().pos()<EOL>self.graphic_context_menu(self.pos)<EOL><DEDENT><DEDENT>", "docstring": "This function intercepts the mouse's right click and its position.", "id": "f15342:c0:m28"}
{"signature": "def closeEvent(self, event):", "body": "reply = QtGui.QMessageBox.question(self, '<STR_LIT>',<EOL>\"<STR_LIT>\", QtGui.QMessageBox.Yes, QtGui.QMessageBox.No)<EOL>if reply == QtGui.QMessageBox.Yes:<EOL><INDENT>event.accept()<EOL><DEDENT>else:<EOL><INDENT>event.ignore()<EOL><DEDENT>", "docstring": "The following asks to the user if he is sure to quit the GUI.", "id": "f15342:c0:m27"}
{"signature": "def run(self):", "body": "\"\"\"<STR_LIT>\"\"\"<EOL>print('<STR_LIT>')<EOL>if self.ui.tabWidget.currentIndex() == TabWidget.NORMAL_MODE:<EOL><INDENT>self.data()<EOL>self.check_values()<EOL>if self.without_error == False:<EOL><INDENT>self.display_error_message()<EOL><DEDENT>elif self.without_error == True:<EOL><INDENT>self.is_running = True<EOL>self.hide_error_message()<EOL>self.write_to_file()<EOL>os.chdir('<STR_LIT>')<EOL>self.progress_bar()<EOL>this_dir = os.path.dirname(os.path.realpath(__file__)).rstrip('<STR_LIT>')<EOL>batch_file = os.path.join(this_dir, \"<STR_LIT>\" + str(self.batch_name_value) + \"<STR_LIT>\")<EOL>print(batch_file)<EOL>self.p = subprocess.Popen(<EOL>[\"<STR_LIT>\" + batch_file],<EOL>shell=True)<EOL>if self.ui.progressBar.value() == <NUM_LIT:100>:<EOL><INDENT>self.display_the_graphic(self.num_line, self.wavelength, self.data_wanted, self.information)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "This function executes planarRad using the batch file.", "id": "f15342:c0:m15"}
{"signature": "def hide_error_message(self):", "body": "self.ui.error_label.setScaledContents(False)  <EOL>self.ui.error_text_label.hide()<EOL>", "docstring": "This function hides the error message when all values are correct.", "id": "f15342:c0:m14"}
{"signature": "def save_figure(self):", "body": "\"\"\"<STR_LIT>\"\"\"<EOL>default_name = '<STR_LIT>'<EOL>self.ui.graphic_widget.canvas.print_figure(default_name)<EOL>src = '<STR_LIT>' + default_name<EOL>dst = '<STR_LIT>'<EOL>os.system(\"<STR_LIT>\" + \"<STR_LIT:U+0020>\" + src + \"<STR_LIT:U+0020>\" + dst)<EOL>", "docstring": "This function programs the button to save the figure displayed\nand save it in a png file in the current repository.", "id": "f15342:c0:m21"}
{"signature": "def cancel_planarrad(self):", "body": "\"\"\"<STR_LIT>\"\"\"<EOL>if (self.is_running == True) & (self.ui.tabWidget.currentIndex() == TabWidget.NORMAL_MODE):<EOL><INDENT>cancel = QtGui.QMessageBox.question(self.ui.cancel, '<STR_LIT>', \"<STR_LIT>\",<EOL>QtGui.QMessageBox.Yes,<EOL>QtGui.QMessageBox.No)<EOL>if cancel == QtGui.QMessageBox.Yes:<EOL><INDENT>self.is_running = False<EOL>os.kill(self.p.pid, signal.SIGTERM)<EOL>print(\"<STR_LIT>\")<EOL>self.ui.progressBar.reset()<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>", "docstring": "This function cancels PlanarRad.", "id": "f15342:c0:m19"}
{"signature": "def graphic_target(self, x, y):", "body": "if self.authorized_display == True:<EOL><INDENT>try:<EOL><INDENT>self.display_the_graphic(self.num_line, self.wavelength, self.data_wanted, self.information)<EOL>self.ui.mouse_coordinate.setText(\"<STR_LIT>\" % (x, y))<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>", "docstring": "The following update labels about mouse coordinates.", "id": "f15342:c0:m31"}
{"signature": "def parse_old_menu(menu_data):", "body": "menu_title = menu_data['<STR_LIT:title>']<EOL>menu = CursesMenu(menu_title)<EOL>for item in menu_data[\"<STR_LIT>\"]:<EOL><INDENT>item_type = item[\"<STR_LIT:type>\"]<EOL>item_title = item[\"<STR_LIT:title>\"]<EOL>if item_type == menuItem.COMMAND:<EOL><INDENT>item_command = item[\"<STR_LIT>\"]<EOL>menu.append_item(CommandItem(item_title, item_command, menu))<EOL><DEDENT>elif item_type == menuItem.FUNCTION:<EOL><INDENT>item_function = item[\"<STR_LIT>\"]<EOL>menu.append_item(FunctionItem(item_title, item_function, menu))<EOL><DEDENT>elif item_type == menuItem.EXITMENU:<EOL><INDENT>menu.append_item(ExitItem(item_title, menu))<EOL><DEDENT>elif item_type == menuItem.NUMBER:<EOL><INDENT>menu.append_item(SelectionItem(item_title, menu))<EOL><DEDENT>elif item_type == menuItem.MENU:<EOL><INDENT>new_menu = parse_old_menu(item)<EOL>menu.append_item(SubmenuItem(item_title, menu, new_menu))<EOL><DEDENT><DEDENT>return menu<EOL>", "docstring": "Take an old-style menuData dictionary and return a CursesMenu\n\n:param dict menu_data:\n:return: A new CursesMenu\n:rtype: CursesMenu", "id": "f15362:m0"}
{"signature": "def append_item(self, item):", "body": "did_remove = self.remove_exit()<EOL>item.menu = self<EOL>self.items.append(item)<EOL>if did_remove:<EOL><INDENT>self.add_exit()<EOL><DEDENT>if self.screen:<EOL><INDENT>max_row, max_cols = self.screen.getmaxyx()<EOL>if max_row < <NUM_LIT:6> + len(self.items):<EOL><INDENT>self.screen.resize(<NUM_LIT:6> + len(self.items), max_cols)<EOL><DEDENT>self.draw()<EOL><DEDENT>", "docstring": "Add an item to the end of the menu before the exit item\n\n:param MenuItem item: The item to be added", "id": "f15363:c0:m4"}
{"signature": "def go_to(self, option):", "body": "self.current_option = option<EOL>self.draw()<EOL>", "docstring": "Go to the option entered by the user as a number\n\n:param option: the option to go to\n:type option: int", "id": "f15363:c0:m20"}
{"signature": "def process_user_input(self):", "body": "user_input = self.get_input()<EOL>go_to_max = ord(\"<STR_LIT>\") if len(self.items) >= <NUM_LIT:9> else ord(str(len(self.items)))<EOL>if ord('<STR_LIT:1>') <= user_input <= go_to_max:<EOL><INDENT>self.go_to(user_input - ord('<STR_LIT:0>') - <NUM_LIT:1>)<EOL><DEDENT>elif user_input == curses.KEY_DOWN:<EOL><INDENT>self.go_down()<EOL><DEDENT>elif user_input == curses.KEY_UP:<EOL><INDENT>self.go_up()<EOL><DEDENT>elif user_input == ord(\"<STR_LIT:\\n>\"):<EOL><INDENT>self.select()<EOL><DEDENT>return user_input<EOL>", "docstring": "Gets the next single character and decides what to do with it", "id": "f15363:c0:m19"}
{"signature": "def set_up(self):", "body": "pass<EOL>", "docstring": "Override to add any setup actions necessary for the item", "id": "f15363:c1:m3"}
{"signature": "def __init__(self, text, menu=None, should_exit=False):", "body": "self.text = text<EOL>self.menu = menu<EOL>self.should_exit = should_exit<EOL>", "docstring": ":ivar str text: The text shown for this menu item\n:ivar CursesMenu menu: The menu to which this item belongs\n:ivar bool should_exit: Whether the menu should exit once this item's action is done", "id": "f15363:c1:m0"}
{"signature": "def show(self, index):", "body": "return \"<STR_LIT>\" % (index + <NUM_LIT:1>, self.text)<EOL>", "docstring": "How this item should be displayed in the menu. Can be overridden, but should keep the same signature.\n\nDefault is:\n\n    1 - Item 1\n\n    2 - Another Item\n\n:param int index: The index of the item in the items list of the menu\n:return: The representation of the item to be shown in a menu\n:rtype: str", "id": "f15363:c1:m2"}
{"signature": "def is_running(self):", "body": "return self._running.is_set()<EOL>", "docstring": ":return: True if the menu is started and hasn't been paused", "id": "f15363:c0:m12"}
{"signature": "def start(self, show_exit_option=None):", "body": "self.previous_active_menu = CursesMenu.currently_active_menu<EOL>CursesMenu.currently_active_menu = None<EOL>self.should_exit = False<EOL>if show_exit_option is None:<EOL><INDENT>show_exit_option = self.show_exit_option<EOL><DEDENT>if show_exit_option:<EOL><INDENT>self.add_exit()<EOL><DEDENT>else:<EOL><INDENT>self.remove_exit()<EOL><DEDENT>try:<EOL><INDENT>self._main_thread = threading.Thread(target=self._wrap_start, daemon=True)<EOL><DEDENT>except TypeError:<EOL><INDENT>self._main_thread = threading.Thread(target=self._wrap_start)<EOL>self._main_thread.daemon = True<EOL><DEDENT>self._main_thread.start()<EOL>", "docstring": "Start the menu in a new thread and allow the user to interact with it.\nThe thread is a daemon, so :meth:`join()<cursesmenu.CursesMenu.join>` should be called if there's a possibility\\\nthat the main thread will exit before the menu is done\n\n:param bool show_exit_option: Whether the exit item should be shown, defaults to\\\nthe value set in the constructor", "id": "f15363:c0:m8"}
{"signature": "def action(self):", "body": "self.return_value = self.function(*self.args, **self.kwargs)<EOL>", "docstring": "This class overrides this method", "id": "f15366:c0:m1"}
{"signature": "def __init__(self, text, command, arguments=None, menu=None, should_exit=False):", "body": "super(CommandItem, self).__init__(text=text, menu=menu, should_exit=should_exit)<EOL>self.command = command<EOL>if arguments:<EOL><INDENT>self.arguments = arguments<EOL><DEDENT>else:<EOL><INDENT>self.arguments = []<EOL><DEDENT>self.exit_status = None<EOL>", "docstring": ":ivar str command: The console command to be executed\n:ivar list[str] arguments: An optional list of string arguments to be passed to the command\n:ivar int exit_status: the exit status of the command, None if it hasn't been run yet", "id": "f15367:c0:m0"}
{"signature": "def __init__(self, text, submenu, menu=None, should_exit=False):", "body": "super(SubmenuItem, self).__init__(text=text, menu=menu, should_exit=should_exit)<EOL>self.submenu = submenu<EOL>if menu:<EOL><INDENT>self.submenu.parent = menu<EOL><DEDENT>", "docstring": ":ivar CursesMenu self.submenu: The submenu to be opened when this item is selected", "id": "f15371:c0:m0"}
{"signature": "def _prepare_args(log_likelihood_fn, state,<EOL>log_likelihood=None, description='<STR_LIT>'):", "body": "state_parts = list(state) if mcmc_util.is_list_like(state) else [state]<EOL>state_parts = [tf.convert_to_tensor(s, name='<STR_LIT>')<EOL>for s in state_parts]<EOL>log_likelihood = _maybe_call_fn(<EOL>log_likelihood_fn,<EOL>state_parts,<EOL>log_likelihood,<EOL>description)<EOL>return [state_parts, log_likelihood]<EOL>", "docstring": "Processes input args to meet list-like assumptions.", "id": "f15374:m3"}
{"signature": "def one_step(self, current_state, previous_kernel_results):", "body": "with tf.compat.v1.name_scope(<EOL>name=mcmc_util.make_name(self.name, '<STR_LIT>', '<STR_LIT>'),<EOL>values=[self._seed_stream,<EOL>current_state,<EOL>previous_kernel_results.log_likelihood]):<EOL><INDENT>with tf.compat.v1.name_scope('<STR_LIT>'):<EOL><INDENT>[<EOL>init_state_parts,<EOL>init_log_likelihood<EOL>] = _prepare_args(<EOL>self.log_likelihood_fn,<EOL>current_state,<EOL>previous_kernel_results.log_likelihood)<EOL><DEDENT>normal_samples = self.normal_sampler_fn(self._seed_stream())  <EOL>normal_samples = list(normal_samples) if mcmc_util.is_list_like(<EOL>normal_samples) else [normal_samples]<EOL>u = tf.random.uniform(<EOL>shape=tf.shape(init_log_likelihood),<EOL>seed=self._seed_stream(),<EOL>dtype=init_log_likelihood.dtype.base_dtype,<EOL>)<EOL>threshold = init_log_likelihood + tf.math.log(u)<EOL>starting_angle = tf.random.uniform(<EOL>shape=tf.shape(init_log_likelihood),<EOL>minval=<NUM_LIT:0.>,<EOL>maxval=<NUM_LIT:2> * np.pi,<EOL>name='<STR_LIT>',<EOL>seed=self._seed_stream(),<EOL>dtype=init_log_likelihood.dtype.base_dtype,<EOL>)<EOL>starting_angle_min = starting_angle - <NUM_LIT:2> * np.pi<EOL>starting_angle_max = starting_angle<EOL>starting_state_parts = _rotate_on_ellipse(<EOL>init_state_parts, normal_samples, starting_angle)<EOL>starting_log_likelihood = self.log_likelihood_fn(*starting_state_parts)  <EOL>def chain_not_done(<EOL>angle,<EOL>angle_min,<EOL>angle_max,<EOL>current_state_parts,<EOL>current_log_likelihood):<EOL><INDENT>del angle, angle_min, angle_max, current_state_parts<EOL>return tf.reduce_any(current_log_likelihood < threshold)<EOL><DEDENT>def sample_next_angle(<EOL>angle,<EOL>angle_min,<EOL>angle_max,<EOL>current_state_parts,<EOL>current_log_likelihood):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>chain_not_done = current_log_likelihood < threshold<EOL>angle_min = tf.where(<EOL>tf.math.logical_and(angle < <NUM_LIT:0>, chain_not_done),<EOL>angle,<EOL>angle_min)<EOL>angle_max = tf.where(<EOL>tf.math.logical_and(angle >= <NUM_LIT:0>, chain_not_done),<EOL>angle,<EOL>angle_max)<EOL>new_angle = tf.random.uniform(<EOL>shape=tf.shape(current_log_likelihood),<EOL>minval=angle_min,<EOL>maxval=angle_max,<EOL>seed=self._seed_stream(),<EOL>dtype=angle.dtype.base_dtype<EOL>)<EOL>angle = tf.where(chain_not_done, new_angle, angle)<EOL>next_state_parts = _rotate_on_ellipse(<EOL>init_state_parts, normal_samples, angle)<EOL>new_state_parts = []<EOL>broadcasted_chain_not_done = _right_pad_with_ones(<EOL>chain_not_done, tf.rank(next_state_parts[<NUM_LIT:0>]))<EOL>for n_state, c_state in zip(next_state_parts, current_state_parts):<EOL><INDENT>new_state_part = tf.where(<EOL>tf.broadcast_to(<EOL>broadcasted_chain_not_done,<EOL>tf.shape(n_state)),<EOL>n_state,<EOL>c_state)<EOL>new_state_parts.append(new_state_part)<EOL><DEDENT>return (<EOL>angle,<EOL>angle_min,<EOL>angle_max,<EOL>new_state_parts,<EOL>self.log_likelihood_fn(*new_state_parts)  <EOL>)<EOL><DEDENT>[<EOL>next_angle,<EOL>_,<EOL>_,<EOL>next_state_parts,<EOL>next_log_likelihood,<EOL>] = tf.while_loop(<EOL>cond=chain_not_done,<EOL>body=sample_next_angle,<EOL>loop_vars=[<EOL>starting_angle,<EOL>starting_angle_min,<EOL>starting_angle_max,<EOL>starting_state_parts,<EOL>starting_log_likelihood<EOL>])<EOL>return [<EOL>next_state_parts if mcmc_util.is_list_like(<EOL>current_state) else next_state_parts[<NUM_LIT:0>],<EOL>EllipticalSliceSamplerKernelResults(<EOL>log_likelihood=next_log_likelihood,<EOL>angle=next_angle,<EOL>normal_samples=normal_samples,<EOL>),<EOL>]<EOL><DEDENT>", "docstring": "Runs one iteration of the Elliptical Slice Sampler.\n\n        Args:\n          current_state: `Tensor` or Python `list` of `Tensor`s representing the\n            current state(s) of the Markov chain(s). The first `r` dimensions\n            index independent chains,\n            `r = tf.rank(log_likelihood_fn(*normal_sampler_fn()))`.\n          previous_kernel_results: `collections.namedtuple` containing `Tensor`s\n            representing values from previous calls to this function (or from the\n            `bootstrap_results` function.)\n\n        Returns:\n          next_state: Tensor or Python list of `Tensor`s representing the state(s)\n            of the Markov chain(s) after taking exactly one step. Has same type and\n            shape as `current_state`.\n          kernel_results: `collections.namedtuple` of internal calculations used to\n            advance the chain.\n\n        Raises:\n          TypeError: if `not log_likelihood.dtype.is_floating`.", "id": "f15374:c0:m7"}
{"signature": "def kernel(target_log_prob_fn,<EOL>current_state,<EOL>step_size,<EOL>seed=None,<EOL>current_target_log_prob=None,<EOL>current_grads_target_log_prob=None,<EOL>name=None):", "body": "if not tf.executing_eagerly():<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\")<EOL><DEDENT>with tf.compat.v1.name_scope(<EOL>name,<EOL>default_name=\"<STR_LIT>\",<EOL>values=[<EOL>current_state, step_size, seed, current_target_log_prob,<EOL>current_grads_target_log_prob<EOL>]):<EOL><INDENT>with tf.compat.v1.name_scope(\"<STR_LIT>\"):<EOL><INDENT>current_state = [tf.convert_to_tensor(value=s) for s in current_state]<EOL>step_size = [tf.convert_to_tensor(value=s) for s in step_size]<EOL>value_and_gradients_fn = lambda *args: tfp.math.value_and_gradient(  <EOL>target_log_prob_fn, args)<EOL>value_and_gradients_fn = _embed_no_none_gradient_check(<EOL>value_and_gradients_fn)<EOL>if (current_target_log_prob is None or<EOL>current_grads_target_log_prob is None):<EOL><INDENT>(current_target_log_prob,<EOL>current_grads_target_log_prob) = value_and_gradients_fn(*current_state)<EOL><DEDENT>seed_stream = tfd.SeedStream(seed, \"<STR_LIT>\")<EOL>current_momentum = []<EOL>for state_tensor in current_state:<EOL><INDENT>momentum_tensor = tf.random.normal(<EOL>shape=tf.shape(input=state_tensor),<EOL>dtype=state_tensor.dtype,<EOL>seed=seed_stream())<EOL>current_momentum.append(momentum_tensor)<EOL><DEDENT>log_slice_sample = tf.math.log(tf.random.uniform([], seed=seed_stream()))<EOL>log_slice_sample += _log_joint(current_target_log_prob,<EOL>current_momentum)<EOL>reverse_state = current_state<EOL>reverse_target_log_prob = current_target_log_prob<EOL>reverse_grads_target_log_prob = current_grads_target_log_prob<EOL>reverse_momentum = current_momentum<EOL>forward_state = current_state<EOL>forward_target_log_prob = current_target_log_prob<EOL>forward_grads_target_log_prob = current_grads_target_log_prob<EOL>forward_momentum = current_momentum<EOL>next_state = current_state<EOL>next_target_log_prob = current_target_log_prob<EOL>next_grads_target_log_prob = current_grads_target_log_prob<EOL>depth = <NUM_LIT:0><EOL>num_states = <NUM_LIT:1><EOL>continue_trajectory = True<EOL><DEDENT>while continue_trajectory:<EOL><INDENT>direction = tfp.math.random_rademacher([], seed=seed_stream())<EOL>if direction < <NUM_LIT:0>:<EOL><INDENT>[<EOL>reverse_state,<EOL>reverse_target_log_prob,<EOL>reverse_grads_target_log_prob,<EOL>reverse_momentum,<EOL>_,<EOL>_,<EOL>_,<EOL>_,<EOL>next_state_in_subtree,<EOL>next_target_log_prob_in_subtree,<EOL>next_grads_target_log_prob_in_subtree,<EOL>num_states_in_subtree,<EOL>continue_trajectory,<EOL>] = _build_tree(<EOL>value_and_gradients_fn=value_and_gradients_fn,<EOL>current_state=reverse_state,<EOL>current_target_log_prob=reverse_target_log_prob,<EOL>current_grads_target_log_prob=reverse_grads_target_log_prob,<EOL>current_momentum=reverse_momentum,<EOL>direction=direction,<EOL>depth=depth,<EOL>step_size=step_size,<EOL>log_slice_sample=log_slice_sample,<EOL>seed=seed_stream())<EOL><DEDENT>else:<EOL><INDENT>[<EOL>_,<EOL>_,<EOL>_,<EOL>_,<EOL>forward_state,<EOL>forward_target_log_prob,<EOL>forward_grads_target_log_prob,<EOL>forward_momentum,<EOL>next_state_in_subtree,<EOL>next_target_log_prob_in_subtree,<EOL>next_grads_target_log_prob_in_subtree,<EOL>num_states_in_subtree,<EOL>continue_trajectory,<EOL>] = _build_tree(<EOL>value_and_gradients_fn=value_and_gradients_fn,<EOL>current_state=forward_state,<EOL>current_target_log_prob=forward_target_log_prob,<EOL>current_grads_target_log_prob=forward_grads_target_log_prob,<EOL>current_momentum=forward_momentum,<EOL>direction=direction,<EOL>depth=depth,<EOL>step_size=step_size,<EOL>log_slice_sample=log_slice_sample,<EOL>seed=seed_stream())<EOL><DEDENT>if continue_trajectory:<EOL><INDENT>accept_state_in_subtree = _random_bernoulli(<EOL>[],<EOL>probs=tf.minimum(<NUM_LIT:1.>, num_states_in_subtree / num_states),<EOL>dtype=tf.bool,<EOL>seed=seed_stream())<EOL>if accept_state_in_subtree:<EOL><INDENT>next_state = next_state_in_subtree<EOL>next_target_log_prob = next_target_log_prob_in_subtree<EOL>next_grads_target_log_prob = next_grads_target_log_prob_in_subtree<EOL><DEDENT><DEDENT>has_no_u_turn = tf.logical_and(<EOL>_has_no_u_turn(forward_state, reverse_state, forward_momentum),<EOL>_has_no_u_turn(forward_state, reverse_state, reverse_momentum))<EOL>continue_trajectory = continue_trajectory and has_no_u_turn<EOL>num_states += num_states_in_subtree<EOL>depth += <NUM_LIT:1><EOL><DEDENT>return next_state, next_target_log_prob, next_grads_target_log_prob<EOL><DEDENT>", "docstring": "Simulates a No-U-Turn Sampler (NUTS) trajectory.\n\n    Args:\n      target_log_prob_fn: Python callable which takes an argument like\n        `*current_state` and returns its (possibly unnormalized) log-density under\n        the target distribution.\n      current_state: List of `Tensor`s representing the states to simulate from.\n      step_size: List of `Tensor`s representing the step sizes for the leapfrog\n        integrator. Must have same shape as `current_state`.\n      seed: Integer to seed the random number generator.\n      current_target_log_prob: Scalar `Tensor` representing the value of\n        `target_log_prob_fn` at the `current_state`.\n      current_grads_target_log_prob: List of `Tensor`s representing gradient of\n        `current_target_log_prob` with respect to `current_state`. Must have same\n        shape as `current_state`.\n      name: A name for the operation.\n\n    Returns:\n      next_state: List of `Tensor`s representing the next states of the NUTS\n        trajectory. Has same shape as `current_state`.\n      next_target_log_prob: Scalar `Tensor` representing the value of\n        `target_log_prob_fn` at `next_state`.\n      next_grads_target_log_prob: List of `Tensor`s representing the gradient of\n        `next_target_log_prob` with respect to `next_state`.\n\n    Raises:\n      NotImplementedError: If the execution mode is not eager.", "id": "f15377:m0"}
{"signature": "def metropolis_hastings_step(current_state: State,<EOL>proposed_state: State,<EOL>energy_change: FloatTensor,<EOL>seed=None) -> Tuple[State, tf.Tensor, tf.Tensor]:", "body": "flat_current = tf.nest.flatten(current_state)<EOL>flat_proposed = nest.flatten_up_to(current_state, proposed_state)<EOL>flat_current = [<EOL>p if c is None else c for p, c in zip(flat_proposed, flat_current)<EOL>]<EOL>current_state = tf.nest.pack_sequence_as(current_state, flat_current)<EOL>current_state = tf.nest.map_structure(tf.convert_to_tensor, current_state)<EOL>proposed_state = tf.nest.map_structure(tf.convert_to_tensor, proposed_state)<EOL>energy_change = tf.convert_to_tensor(value=energy_change)<EOL>log_accept_ratio = -energy_change<EOL>log_uniform = tf.math.log(<EOL>tf.random.uniform(<EOL>shape=tf.shape(input=log_accept_ratio),<EOL>dtype=log_accept_ratio.dtype.base_dtype,<EOL>seed=seed))<EOL>is_accepted = log_uniform < log_accept_ratio<EOL>next_state = mcmc_util.choose(<EOL>is_accepted, proposed_state, current_state, name='<STR_LIT>')<EOL>return next_state, is_accepted, log_uniform<EOL>", "docstring": "Metropolis-Hastings step.\n\n    This probabilistically chooses between `current_state` and `proposed_state`\n    based on the `energy_change` so as to preserve detailed balance.\n\n    Energy change is the negative of `log_accept_ratio`.\n\n    Args:\n      current_state: Current state.\n      proposed_state: Proposed state.\n      energy_change: E(proposed_state) - E(previous_state).\n      seed: For reproducibility.\n\n    Returns:\n      new_state: The chosen state.\n      is_accepted: Whether the proposed state was accepted.\n      log_uniform: The random number that was used to select between the two\n        states.", "id": "f15382:m6"}
{"signature": "def leapfrog_step(leapfrog_step_state: LeapFrogStepState,<EOL>step_size: FloatTensor, target_log_prob_fn: PotentialFn,<EOL>kinetic_energy_fn: PotentialFn<EOL>) -> Tuple[LeapFrogStepState, LeapFrogStepExtras]:", "body": "state = leapfrog_step_state.state<EOL>state_grads = leapfrog_step_state.state_grads<EOL>momentum = leapfrog_step_state.momentum<EOL>step_size = maybe_broadcast_structure(step_size, state)<EOL>state = tf.nest.map_structure(tf.convert_to_tensor, state)<EOL>momentum = tf.nest.map_structure(tf.convert_to_tensor, momentum)<EOL>state = tf.nest.map_structure(tf.convert_to_tensor, state)<EOL>if state_grads is None:<EOL><INDENT>_, _, state_grads = call_and_grads(target_log_prob_fn, state)<EOL><DEDENT>else:<EOL><INDENT>state_grads = tf.nest.map_structure(tf.convert_to_tensor, state_grads)<EOL><DEDENT>momentum = tf.nest.map_structure(lambda m, sg, s: m + <NUM_LIT:0.5> * sg * s, momentum,<EOL>state_grads, step_size)<EOL>kinetic_energy, kinetic_energy_extra, momentum_grads = call_and_grads(<EOL>kinetic_energy_fn, momentum)<EOL>state = tf.nest.map_structure(lambda x, mg, s: x + mg * s, state,<EOL>momentum_grads, step_size)<EOL>target_log_prob, state_extra, state_grads = call_and_grads(<EOL>target_log_prob_fn, state)<EOL>momentum = tf.nest.map_structure(lambda m, sg, s: m + <NUM_LIT:0.5> * sg * s, momentum,<EOL>state_grads, step_size)<EOL>return LeapFrogStepState(state, state_grads, momentum), LeapFrogStepExtras(<EOL>target_log_prob, state_extra, kinetic_energy, kinetic_energy_extra)<EOL>", "docstring": "Leapfrog `TransitionOperator`.\n\n    Args:\n      leapfrog_step_state: LeapFrogStepState.\n      step_size: Step size, structure broadcastable to the `target_log_prob_fn`\n        state.\n      target_log_prob_fn: Target log prob fn.\n      kinetic_energy_fn: Kinetic energy fn.\n\n    Returns:\n      leapfrog_step_state: LeapFrogStepState.\n      leapfrog_step_extras: LeapFrogStepExtras.", "id": "f15382:m5"}
{"signature": "def maybe_broadcast_structure(from_structure: Any, to_structure: Any) -> Any:", "body": "flat_from = tf.nest.flatten(from_structure)<EOL>flat_to = tf.nest.flatten(to_structure)<EOL>if len(flat_from) == <NUM_LIT:1>:<EOL><INDENT>flat_from *= len(flat_to)<EOL><DEDENT>return tf.nest.pack_sequence_as(to_structure, flat_from)<EOL>", "docstring": "Maybe broadcasts `from_structure` to `to_structure`.\n\n    If `from_structure` is a singleton, it is tiled to match the structure of\n    `to_structure`. Note that the elements in `from_structure` are not copied if\n    this tiling occurs.\n\n    Args:\n      from_structure: A structure.\n      to_structure: A structure.\n\n    Returns:\n      new_from_structure: Same structure as `to_structure`.", "id": "f15382:m3"}
{"signature": "@property<EOL><INDENT>def shift(self):<DEDENT>", "body": "return self._shift<EOL>", "docstring": "The `shift` `Tensor` in `Y = scale @ X + shift`.", "id": "f15395:c0:m1"}
{"signature": "def __init__(self, validate_args=False, name=\"<STR_LIT>\"):", "body": "self._name = name<EOL>super(Square, self).__init__(<EOL>forward_min_event_ndims=<NUM_LIT:0>,<EOL>validate_args=validate_args,<EOL>name=name)<EOL>", "docstring": "Instantiates the `Square` bijector.\n\n        Args:\n          validate_args: Python `bool` indicating whether arguments should be\n            checked for correctness.\n          name: Python `str` name given to ops managed by this object.", "id": "f15402:c0:m0"}
{"signature": "def _replace_event_shape_in_shape_tensor(<EOL>input_shape, event_shape_in, event_shape_out, validate_args):", "body": "output_tensorshape, is_validated = _replace_event_shape_in_tensorshape(<EOL>tensorshape_util.constant_value_as_shape(input_shape),<EOL>event_shape_in,<EOL>event_shape_out)<EOL>validation_dependencies = (<EOL>map(tf.identity, (event_shape_in, event_shape_out))<EOL>if validate_args else ())<EOL>if (tensorshape_util.is_fully_defined(output_tensorshape) and<EOL>(is_validated or not validate_args)):<EOL><INDENT>with tf.control_dependencies(validation_dependencies):<EOL><INDENT>output_shape = tf.convert_to_tensor(<EOL>value=output_tensorshape, name='<STR_LIT>', dtype_hint=tf.int32)<EOL><DEDENT>return output_shape, output_tensorshape<EOL><DEDENT>with tf.control_dependencies(validation_dependencies):<EOL><INDENT>event_shape_in_ndims = (<EOL>tf.size(input=event_shape_in)<EOL>if tensorshape_util.num_elements(event_shape_in.shape) is None else<EOL>tensorshape_util.num_elements(event_shape_in.shape))<EOL>input_non_event_shape, input_event_shape = tf.split(<EOL>input_shape, num_or_size_splits=[-<NUM_LIT:1>, event_shape_in_ndims])<EOL><DEDENT>additional_assertions = []<EOL>if is_validated:<EOL><INDENT>pass<EOL><DEDENT>elif validate_args:<EOL><INDENT>mask = event_shape_in >= <NUM_LIT:0><EOL>explicit_input_event_shape = tf.boolean_mask(<EOL>tensor=input_event_shape, mask=mask)<EOL>explicit_event_shape_in = tf.boolean_mask(<EOL>tensor=event_shape_in, mask=mask)<EOL>additional_assertions.append(<EOL>assert_util.assert_equal(<EOL>explicit_input_event_shape,<EOL>explicit_event_shape_in,<EOL>message='<STR_LIT>'))<EOL><DEDENT>with tf.control_dependencies(additional_assertions):<EOL><INDENT>output_shape = tf.concat([input_non_event_shape, event_shape_out], axis=<NUM_LIT:0>,<EOL>name='<STR_LIT>')<EOL><DEDENT>return output_shape, output_tensorshape<EOL>", "docstring": "Replaces the rightmost dims in a `Tensor` representing a shape.\n\n    Args:\n      input_shape: a rank-1 `Tensor` of integers\n      event_shape_in: the event shape expected to be present in rightmost dims\n        of `shape_in`.\n      event_shape_out: the event shape with which to replace `event_shape_in` in\n        the rightmost dims of `input_shape`.\n      validate_args: Python `bool` indicating whether arguments should\n        be checked for correctness.\n\n    Returns:\n      output_shape: A rank-1 integer `Tensor` with the same contents as\n        `input_shape` except for the event dims, which are replaced with\n        `event_shape_out`.", "id": "f15403:m0"}
{"signature": "def __init__(self, event_shape_out, event_shape_in=(-<NUM_LIT:1>,),<EOL>validate_args=False, name=None):", "body": "with tf.name_scope(name or '<STR_LIT>'):<EOL><INDENT>event_shape_out = tf.convert_to_tensor(<EOL>value=event_shape_out, name='<STR_LIT>', dtype_hint=tf.int32)<EOL>event_shape_in = tf.convert_to_tensor(<EOL>value=event_shape_in, name='<STR_LIT>', dtype_hint=tf.int32)<EOL>forward_min_event_ndims_ = tensorshape_util.num_elements(<EOL>event_shape_in.shape)<EOL>if forward_min_event_ndims_ is None:<EOL><INDENT>raise NotImplementedError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>inverse_min_event_ndims_ = tensorshape_util.num_elements(<EOL>event_shape_out.shape)<EOL>if inverse_min_event_ndims_ is None:<EOL><INDENT>raise NotImplementedError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>assertions = []<EOL>assertions.extend(_maybe_check_valid_shape(<EOL>event_shape_out, validate_args))<EOL>assertions.extend(_maybe_check_valid_shape(<EOL>event_shape_in, validate_args))<EOL>if assertions:<EOL><INDENT>with tf.control_dependencies(assertions):<EOL><INDENT>event_shape_in = tf.identity(<EOL>event_shape_in, name='<STR_LIT>')<EOL>event_shape_out = tf.identity(<EOL>event_shape_out, name='<STR_LIT>')<EOL><DEDENT><DEDENT>self._event_shape_in = event_shape_in<EOL>self._event_shape_out = event_shape_out<EOL>super(Reshape, self).__init__(<EOL>forward_min_event_ndims=forward_min_event_ndims_,<EOL>inverse_min_event_ndims=inverse_min_event_ndims_,<EOL>is_constant_jacobian=True,<EOL>validate_args=validate_args,<EOL>name=name or '<STR_LIT>')<EOL><DEDENT>", "docstring": "Creates a `Reshape` bijector.\n\n        Args:\n          event_shape_out: An `int`-like vector-shaped `Tensor`\n            representing the event shape of the transformed output.\n          event_shape_in: An optional `int`-like vector-shape `Tensor`\n            representing the event shape of the input. This is required in\n            order to define inverse operations; the default of (-1,)\n            assumes a vector-shaped input.\n          validate_args: Python `bool` indicating whether arguments should\n            be checked for correctness.\n          name: Python `str`, name given to ops managed by this object.\n\n        Raises:\n          TypeError: if either `event_shape_in` or `event_shape_out` has\n            non-integer `dtype`.\n          ValueError: if either of `event_shape_in` or `event_shape_out`\n           has non-vector shape (`rank > 1`), or if their sizes do not\n           match.", "id": "f15403:c0:m0"}
{"signature": "def _validate_block_sizes(block_sizes, bijectors, validate_args):", "body": "block_sizes_shape = block_sizes.shape<EOL>if tensorshape_util.is_fully_defined(block_sizes_shape):<EOL><INDENT>if (tensorshape_util.rank(block_sizes_shape) != <NUM_LIT:1> or<EOL>(tensorshape_util.num_elements(block_sizes_shape) != len(bijectors))):<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(block_sizes_shape, len(bijectors)))<EOL><DEDENT>return block_sizes<EOL><DEDENT>elif validate_args:<EOL><INDENT>message = ('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>with tf.control_dependencies([<EOL>assert_util.assert_equal(<EOL>tf.size(input=block_sizes), len(bijectors), message=message),<EOL>assert_util.assert_equal(tf.rank(block_sizes), <NUM_LIT:1>)<EOL>]):<EOL><INDENT>return tf.identity(block_sizes)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return block_sizes<EOL><DEDENT>", "docstring": "Helper to validate block sizes.", "id": "f15408:m0"}
{"signature": "def vector_size_to_square_matrix_size(d, validate_args, name=None):", "body": "if isinstance(d, (float, int, np.generic, np.ndarray)):<EOL><INDENT>n = (-<NUM_LIT:1> + np.sqrt(<NUM_LIT:1> + <NUM_LIT:8> * d)) / <NUM_LIT><EOL>if float(int(n)) != n:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return int(n)<EOL><DEDENT>else:<EOL><INDENT>with tf.name_scope(name or \"<STR_LIT>\") as name:<EOL><INDENT>n = (-<NUM_LIT:1.> + tf.sqrt(<NUM_LIT:1> + <NUM_LIT> * tf.cast(d, dtype=tf.float32))) / <NUM_LIT><EOL>if validate_args:<EOL><INDENT>with tf.control_dependencies([<EOL>assert_util.assert_equal(<EOL>tf.cast(tf.cast(n, dtype=tf.int32), dtype=tf.float32),<EOL>n,<EOL>message=\"<STR_LIT>\")<EOL>]):<EOL><INDENT>n = tf.identity(n)<EOL><DEDENT><DEDENT>return tf.cast(n, d.dtype)<EOL><DEDENT><DEDENT>", "docstring": "Convert a vector size to a matrix size.", "id": "f15411:m0"}
{"signature": "def distribution_filter_for(bijector):", "body": "if isinstance(bijector, tfb.CholeskyToInvCholesky):<EOL><INDENT>def additional_check(dist):<EOL><INDENT>return (tensorshape_util.rank(dist.event_shape) == <NUM_LIT:2> and<EOL>int(dist.event_shape[<NUM_LIT:0>]) == int(dist.event_shape[<NUM_LIT:1>]))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>additional_check = lambda dist: True<EOL><DEDENT>def distribution_filter(dist):<EOL><INDENT>if not dtype_util.is_floating(dist.dtype):<EOL><INDENT>return False<EOL><DEDENT>if bijector.forward_min_event_ndims > tensorshape_util.rank(<EOL>dist.event_shape):<EOL><INDENT>return False<EOL><DEDENT>return additional_check(dist)<EOL><DEDENT>return distribution_filter<EOL>", "docstring": "Returns filter function f s.t. f(dist)=True => bijector can act on dist.", "id": "f15414:m3"}
{"signature": "def _maybe_assert_valid_concentration(self, concentration, validate_args):", "body": "if not validate_args:<EOL><INDENT>return concentration<EOL><DEDENT>return distribution_util.with_dependencies([<EOL>assert_util.assert_positive(<EOL>concentration, message=\"<STR_LIT>\"),<EOL>], concentration)<EOL>", "docstring": "Checks the validity of a concentration parameter.", "id": "f15419:c0:m6"}
{"signature": "def __init__(self,<EOL>forward_fn=None,<EOL>inverse_fn=None,<EOL>inverse_log_det_jacobian_fn=None,<EOL>forward_log_det_jacobian_fn=None,<EOL>forward_event_shape_fn=None,<EOL>forward_event_shape_tensor_fn=None,<EOL>inverse_event_shape_fn=None,<EOL>inverse_event_shape_tensor_fn=None,<EOL>is_constant_jacobian=False,<EOL>validate_args=False,<EOL>forward_min_event_ndims=None,<EOL>inverse_min_event_ndims=None,<EOL>name=\"<STR_LIT>\"):", "body": "super(Inline, self).__init__(<EOL>forward_min_event_ndims=forward_min_event_ndims,<EOL>inverse_min_event_ndims=inverse_min_event_ndims,<EOL>is_constant_jacobian=is_constant_jacobian,<EOL>validate_args=validate_args,<EOL>name=name)<EOL>self._forward_fn = forward_fn<EOL>self._inverse_fn = inverse_fn<EOL>self._inverse_log_det_jacobian_fn = inverse_log_det_jacobian_fn<EOL>self._forward_log_det_jacobian_fn = forward_log_det_jacobian_fn<EOL>self._forward_event_shape_fn = forward_event_shape_fn<EOL>self._forward_event_shape_tensor_fn = forward_event_shape_tensor_fn<EOL>self._inverse_event_shape_fn = inverse_event_shape_fn<EOL>self._inverse_event_shape_tensor_fn = inverse_event_shape_tensor_fn<EOL>", "docstring": "Creates a `Bijector` from callables.\n\n        Args:\n          forward_fn: Python callable implementing the forward transformation.\n          inverse_fn: Python callable implementing the inverse transformation.\n          inverse_log_det_jacobian_fn: Python callable implementing the\n            log o det o jacobian of the inverse transformation.\n          forward_log_det_jacobian_fn: Python callable implementing the\n            log o det o jacobian of the forward transformation.\n          forward_event_shape_fn: Python callable implementing non-identical\n            static event shape changes. Default: shape is assumed unchanged.\n          forward_event_shape_tensor_fn: Python callable implementing non-identical\n            event shape changes. Default: shape is assumed unchanged.\n          inverse_event_shape_fn: Python callable implementing non-identical\n            static event shape changes. Default: shape is assumed unchanged.\n          inverse_event_shape_tensor_fn: Python callable implementing non-identical\n            event shape changes. Default: shape is assumed unchanged.\n          is_constant_jacobian: Python `bool` indicating that the Jacobian is\n            constant for all input arguments.\n          validate_args: Python `bool` indicating whether arguments should be\n            checked for correctness.\n          forward_min_event_ndims: Python `int` indicating the minimal\n            dimensionality this bijector acts on.\n          inverse_min_event_ndims: Python `int` indicating the minimal\n            dimensionality this bijector acts on.\n          name: Python `str`, name given to ops managed by this object.", "id": "f15425:c0:m0"}
{"signature": "def _lookup(self, x=None, y=None, kwargs=None):", "body": "mapping = _Mapping(x=x, y=y, kwargs=kwargs)<EOL>subkey = mapping.subkey<EOL>if x is not None:<EOL><INDENT>mapping = self._from_x[x].get(subkey, mapping).merge(x=x)<EOL><DEDENT>if y is not None:<EOL><INDENT>mapping = self._from_y[y].get(subkey, mapping).merge(y=y)<EOL><DEDENT>return mapping<EOL>", "docstring": "Helper which retrieves mapping info from forward/inverse dicts.", "id": "f15431:c3:m36"}
{"signature": "@property<EOL><INDENT>def subkey(self):<DEDENT>", "body": "return self._deep_tuple(self.kwargs)<EOL>", "docstring": "Returns subkey used for caching (nested under either `x` or `y`).", "id": "f15431:c0:m1"}
{"signature": "def merge(self, x=None, y=None, ildj=None, kwargs=None, mapping=None):", "body": "if mapping is None:<EOL><INDENT>mapping = _Mapping(x=x, y=y, ildj=ildj, kwargs=kwargs)<EOL><DEDENT>elif any(arg is not None for arg in [x, y, ildj, kwargs]):<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>return _Mapping(<EOL>x=self._merge(self.x, mapping.x),<EOL>y=self._merge(self.y, mapping.y),<EOL>ildj=self._merge(self.ildj, mapping.ildj),<EOL>kwargs=self._merge(self.kwargs, mapping.kwargs, use_equals=True))<EOL>", "docstring": "Returns new _Mapping with args merged with self.\n\n        Args:\n          x: `Tensor` or None. Input to forward; output of inverse.\n          y: `Tensor` or None. Input to inverse; output of forward.\n          ildj: `Tensor`. This is the (un-reduce_sum'ed) inverse log det jacobian.\n          kwargs: Python dictionary. Extra args supplied to forward/inverse/etc\n            functions.\n          mapping: Instance of _Mapping to merge. Can only be specified if no other\n            arg is specified.\n\n        Returns:\n          mapping: New instance of `_Mapping` which has inputs merged with self.\n\n        Raises:\n          ValueError: if mapping and any other arg is not `None`.", "id": "f15431:c0:m2"}
{"signature": "def forward(self, x, name=\"<STR_LIT>\", **kwargs):", "body": "return self._call_forward(x, name, **kwargs)<EOL>", "docstring": "Returns the forward `Bijector` evaluation, i.e., X = g(Y).\n\n        Args:\n          x: `Tensor`. The input to the \"forward\" evaluation.\n          name: The name to give this op.\n          **kwargs: Named arguments forwarded to subclass implementation.\n\n        Returns:\n          `Tensor`.\n\n        Raises:\n          TypeError: if `self.dtype` is specified and `x.dtype` is not\n            `self.dtype`.\n          NotImplementedError: if `_forward` is not implemented.", "id": "f15431:c3:m20"}
{"signature": "def forward_event_shape_tensor(self,<EOL>input_shape,<EOL>name=\"<STR_LIT>\"):", "body": "with self._name_scope(name):<EOL><INDENT>input_shape = tf.convert_to_tensor(<EOL>value=input_shape, dtype=tf.int32, name=\"<STR_LIT>\")<EOL>return self._forward_event_shape_tensor(input_shape)<EOL><DEDENT>", "docstring": "Shape of a single sample from a single batch as an `int32` 1D `Tensor`.\n\n        Args:\n          input_shape: `Tensor`, `int32` vector indicating event-portion shape\n            passed into `forward` function.\n          name: name to give to the op\n\n        Returns:\n          forward_event_shape_tensor: `Tensor`, `int32` vector indicating\n            event-portion shape after applying `forward`.", "id": "f15431:c3:m11"}
{"signature": "def __call__(self, value, name=None, **kwargs):", "body": "<EOL>from tensorflow_probability.python.bijectors import chain  <EOL>from tensorflow_probability.python.distributions import distribution  <EOL>from tensorflow_probability.python.distributions import transformed_distribution  <EOL>if type(value) is transformed_distribution.TransformedDistribution:  <EOL><INDENT>new_kwargs = value.parameters<EOL>new_kwargs.update(kwargs)<EOL>new_kwargs[\"<STR_LIT:name>\"] = name or new_kwargs.get(\"<STR_LIT:name>\", None)<EOL>new_kwargs[\"<STR_LIT>\"] = self(value.bijector)<EOL>return transformed_distribution.TransformedDistribution(**new_kwargs)<EOL><DEDENT>if isinstance(value, distribution.Distribution):<EOL><INDENT>return transformed_distribution.TransformedDistribution(<EOL>distribution=value,<EOL>bijector=self,<EOL>name=name,<EOL>**kwargs)<EOL><DEDENT>if isinstance(value, chain.Chain):<EOL><INDENT>new_kwargs = kwargs.copy()<EOL>new_kwargs[\"<STR_LIT>\"] = [self] + ([] if value.bijectors is None<EOL>else list(value.bijectors))<EOL>if \"<STR_LIT>\" not in new_kwargs:<EOL><INDENT>new_kwargs[\"<STR_LIT>\"] = value.validate_args<EOL><DEDENT>new_kwargs[\"<STR_LIT:name>\"] = name or value.name<EOL>return chain.Chain(**new_kwargs)<EOL><DEDENT>if isinstance(value, Bijector):<EOL><INDENT>return chain.Chain([self, value], name=name, **kwargs)<EOL><DEDENT>return self._call_forward(value, name=name or \"<STR_LIT>\", **kwargs)<EOL>", "docstring": "Applies or composes the `Bijector`, depending on input type.\n\n        This is a convenience function which applies the `Bijector` instance in\n        three different ways, depending on the input:\n\n        1. If the input is a `tfd.Distribution` instance, return\n           `tfd.TransformedDistribution(distribution=input, bijector=self)`.\n        2. If the input is a `tfb.Bijector` instance, return\n           `tfb.Chain([self, input])`.\n        3. Otherwise, return `self.forward(input)`\n\n        Args:\n          value: A `tfd.Distribution`, `tfb.Bijector`, or a `Tensor`.\n          name: Python `str` name given to ops created by this function.\n          **kwargs: Additional keyword arguments passed into the created\n            `tfd.TransformedDistribution`, `tfb.Bijector`, or `self.forward`.\n\n        Returns:\n          composition: A `tfd.TransformedDistribution` if the input was a\n            `tfd.Distribution`, a `tfb.Chain` if the input was a `tfb.Bijector`, or\n            a `Tensor` computed by `self.forward`.\n\n        #### Examples\n\n        ```python\n        sigmoid = tfb.Reciprocal()(\n            tfb.AffineScalar(shift=1.)(\n              tfb.Exp()(\n                tfb.AffineScalar(scale=-1.))))\n        # ==> `tfb.Chain([\n        #         tfb.Reciprocal(),\n        #         tfb.AffineScalar(shift=1.),\n        #         tfb.Exp(),\n        #         tfb.AffineScalar(scale=-1.),\n        #      ])`  # ie, `tfb.Sigmoid()`\n\n        log_normal = tfb.Exp()(tfd.Normal(0, 1))\n        # ==> `tfd.TransformedDistribution(tfd.Normal(0, 1), tfb.Exp())`\n\n        tfb.Exp()([-1., 0., 1.])\n        # ==> tf.exp([-1., 0., 1.])\n        ```", "id": "f15431:c3:m9"}
{"signature": "@contextlib.contextmanager<EOL><INDENT>def _name_scope(self, name=None):<DEDENT>", "body": "with tf.compat.v2.name_scope(self.name):<EOL><INDENT>with tf.compat.v2.name_scope(name) as scope:<EOL><INDENT>yield scope<EOL><DEDENT><DEDENT>", "docstring": "Helper function to standardize op scope.", "id": "f15431:c3:m31"}
{"signature": "def forward_log_det_jacobian(self,<EOL>x,<EOL>event_ndims,<EOL>name=\"<STR_LIT>\",<EOL>**kwargs):", "body": "return self._call_forward_log_det_jacobian(x, event_ndims, name, **kwargs)<EOL>", "docstring": "Returns both the forward_log_det_jacobian.\n\n        Args:\n          x: `Tensor`. The input to the \"forward\" Jacobian determinant evaluation.\n          event_ndims: Number of dimensions in the probabilistic events being\n            transformed. Must be greater than or equal to\n            `self.forward_min_event_ndims`. The result is summed over the final\n            dimensions to produce a scalar Jacobian determinant for each event, i.e.\n            it has shape `rank(x) - event_ndims` dimensions.\n          name: The name to give this op.\n          **kwargs: Named arguments forwarded to subclass implementation.\n\n        Returns:\n          `Tensor`, if this bijector is injective.\n            If not injective this is not implemented.\n\n        Raises:\n          TypeError: if `self.dtype` is specified and `y.dtype` is not\n            `self.dtype`.\n          NotImplementedError: if neither `_forward_log_det_jacobian`\n            nor {`_inverse`, `_inverse_log_det_jacobian`} are implemented, or\n            this is a non-injective bijector.", "id": "f15431:c3:m30"}
{"signature": "def _forward_event_shape_tensor(self, input_shape):", "body": "<EOL>return input_shape<EOL>", "docstring": "Subclass implementation for `forward_event_shape_tensor` function.", "id": "f15431:c3:m10"}
{"signature": "def _cache_update(self, mapping):", "body": "if mapping.x is not None and mapping.subkey in self._from_x[mapping.x]:<EOL><INDENT>self._cache_by_x(mapping)<EOL><DEDENT>if mapping.y is not None and mapping.subkey in self._from_y[mapping.y]:<EOL><INDENT>self._cache_by_y(mapping)<EOL><DEDENT>", "docstring": "Helper which updates only those cached entries that already exist.", "id": "f15431:c3:m35"}
{"signature": "def _inverse(self, y):", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "Subclass implementation for `inverse` public function.", "id": "f15431:c3:m21"}
{"signature": "@property<EOL><INDENT>def adjoint(self):<DEDENT>", "body": "return self._adjoint<EOL>", "docstring": "`bool` indicating `scale` should be used as conjugate transpose.", "id": "f15432:c0:m4"}
{"signature": "def __init__(self,<EOL>shift=None,<EOL>scale_identity_multiplier=None,<EOL>scale_diag=None,<EOL>scale_tril=None,<EOL>scale_perturb_factor=None,<EOL>scale_perturb_diag=None,<EOL>adjoint=False,<EOL>validate_args=False,<EOL>name=\"<STR_LIT>\",<EOL>dtype=None):", "body": "self._graph_parents = []<EOL>self._name = name<EOL>self._validate_args = validate_args<EOL>if scale_perturb_diag is not None and scale_perturb_factor is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>self._is_only_identity_multiplier = (scale_tril is None and<EOL>scale_diag is None and<EOL>scale_perturb_factor is None)<EOL>with self._name_scope(\"<STR_LIT>\"):<EOL><INDENT>if dtype is None:<EOL><INDENT>dtype = dtype_util.common_dtype([<EOL>shift, scale_identity_multiplier, scale_diag, scale_tril,<EOL>scale_perturb_diag, scale_perturb_factor<EOL>], tf.float32)<EOL><DEDENT>if shift is not None:<EOL><INDENT>shift = tf.convert_to_tensor(value=shift, name=\"<STR_LIT>\", dtype=dtype)<EOL><DEDENT>self._shift = shift<EOL>if (self._is_only_identity_multiplier and<EOL>scale_identity_multiplier is None):<EOL><INDENT>scale_identity_multiplier = tf.convert_to_tensor(value=<NUM_LIT:1.>, dtype=dtype)<EOL><DEDENT>scale = self._create_scale_operator(<EOL>identity_multiplier=scale_identity_multiplier,<EOL>diag=scale_diag,<EOL>tril=scale_tril,<EOL>perturb_diag=scale_perturb_diag,<EOL>perturb_factor=scale_perturb_factor,<EOL>shift=shift,<EOL>validate_args=validate_args,<EOL>dtype=dtype)<EOL>if scale is not None and not self._is_only_identity_multiplier:<EOL><INDENT>if (shift is not None and<EOL>not dtype_util.base_equal(shift.dtype, scale.dtype)):<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\".format(<EOL>shift.dtype, scale.dtype))<EOL><DEDENT><DEDENT>self._scale = scale<EOL>self._adjoint = adjoint<EOL>super(Affine, self).__init__(<EOL>forward_min_event_ndims=<NUM_LIT:1>,<EOL>graph_parents=([self._scale] if tf.is_tensor(<EOL>self._scale) else self._scale.graph_parents +<EOL>[self._shift] if self._shift is not None else []),<EOL>is_constant_jacobian=True,<EOL>dtype=dtype,<EOL>validate_args=validate_args,<EOL>name=name)<EOL><DEDENT>", "docstring": "Instantiates the `Affine` bijector.\n\n        This `Bijector` is initialized with `shift` `Tensor` and `scale` arguments,\n        giving the forward operation:\n\n        ```none\n        Y = g(X) = scale @ X + shift\n        ```\n\n        where the `scale` term is logically equivalent to:\n\n        ```python\n        scale = (\n          scale_identity_multiplier * tf.diag(tf.ones(d)) +\n          tf.diag(scale_diag) +\n          scale_tril +\n          scale_perturb_factor @ diag(scale_perturb_diag) @\n            tf.transpose([scale_perturb_factor])\n        )\n        ```\n\n        If none of `scale_identity_multiplier`, `scale_diag`, or `scale_tril` are\n        specified then `scale += IdentityMatrix`. Otherwise specifying a\n        `scale` argument has the semantics of `scale += Expand(arg)`, i.e.,\n        `scale_diag != None` means `scale += tf.diag(scale_diag)`.\n\n        Args:\n          shift: Floating-point `Tensor`. If this is set to `None`, no shift is\n            applied.\n          scale_identity_multiplier: floating point rank 0 `Tensor` representing a\n            scaling done to the identity matrix.\n            When `scale_identity_multiplier = scale_diag = scale_tril = None` then\n            `scale += IdentityMatrix`. Otherwise no scaled-identity-matrix is added\n            to `scale`.\n          scale_diag: Floating-point `Tensor` representing the diagonal matrix.\n            `scale_diag` has shape `[N1, N2, ...  k]`, which represents a k x k\n            diagonal matrix.\n            When `None` no diagonal term is added to `scale`.\n          scale_tril: Floating-point `Tensor` representing the lower triangular\n            matrix. `scale_tril` has shape `[N1, N2, ...  k, k]`, which represents a\n            k x k lower triangular matrix.\n            When `None` no `scale_tril` term is added to `scale`.\n            The upper triangular elements above the diagonal are ignored.\n          scale_perturb_factor: Floating-point `Tensor` representing factor matrix\n            with last two dimensions of shape `(k, r)`. When `None`, no rank-r\n            update is added to `scale`.\n          scale_perturb_diag: Floating-point `Tensor` representing the diagonal\n            matrix. `scale_perturb_diag` has shape `[N1, N2, ...  r]`, which\n            represents an `r x r` diagonal matrix. When `None` low rank updates will\n            take the form `scale_perturb_factor * scale_perturb_factor.T`.\n          adjoint: Python `bool` indicating whether to use the `scale` matrix as\n            specified or its adjoint.\n            Default value: `False`.\n          validate_args: Python `bool` indicating whether arguments should be\n            checked for correctness.\n          name: Python `str` name given to ops managed by this object.\n          dtype: `tf.DType` to prefer when converting args to `Tensor`s. Else, we\n            fall back to a common dtype inferred from the args, finally falling back\n            to float32.\n\n        Raises:\n          ValueError: if `perturb_diag` is specified but not `perturb_factor`.\n          TypeError: if `shift` has different `dtype` from `scale` arguments.", "id": "f15432:c0:m0"}
{"signature": "def _make_columnar(self, x):", "body": "if tensorshape_util.rank(x.shape) is not None:<EOL><INDENT>if tensorshape_util.rank(x.shape) == <NUM_LIT:1>:<EOL><INDENT>x = x[tf.newaxis, :]<EOL><DEDENT>return x<EOL><DEDENT>shape = tf.shape(input=x)<EOL>maybe_expanded_shape = tf.concat([<EOL>shape[:-<NUM_LIT:1>],<EOL>distribution_util.pick_vector(<EOL>tf.equal(tf.rank(x), <NUM_LIT:1>), [<NUM_LIT:1>], np.array([], dtype=np.int32)),<EOL>shape[-<NUM_LIT:1>:],<EOL>], <NUM_LIT:0>)<EOL>return tf.reshape(x, maybe_expanded_shape)<EOL>", "docstring": "Ensures non-scalar input has at least one column.\n\n        Example:\n          If `x = [1, 2, 3]` then the output is `[[1], [2], [3]]`.\n\n          If `x = [[1, 2, 3], [4, 5, 6]]` then the output is unchanged.\n\n          If `x = 1` then the output is unchanged.\n\n        Args:\n          x: `Tensor`.\n\n        Returns:\n          columnar_x: `Tensor` with at least two dimensions.", "id": "f15436:c0:m4"}
{"signature": "def __init__(self,<EOL>diag_bijector,<EOL>validate_args=False,<EOL>name=\"<STR_LIT>\"):", "body": "self._diag_bijector = diag_bijector<EOL>super(TransformDiagonal, self).__init__(<EOL>forward_min_event_ndims=<NUM_LIT:2>,<EOL>inverse_min_event_ndims=<NUM_LIT:2>,<EOL>validate_args=validate_args,<EOL>dtype=diag_bijector.dtype,<EOL>name=name)<EOL>", "docstring": "Instantiates the `TransformDiagonal` bijector.\n\n        Args:\n          diag_bijector: `Bijector` instance used to transform the diagonal.\n          validate_args: Python `bool` indicating whether arguments should be\n            checked for correctness.\n          name: Python `str` name given to ops managed by this object.", "id": "f15440:c0:m0"}
{"signature": "def __init__(self,<EOL>validate_args=False,<EOL>name=\"<STR_LIT>\"):", "body": "<EOL>super(Exp, self).__init__(<EOL>validate_args=validate_args,<EOL>name=name)<EOL>", "docstring": "Instantiates the `Exp` bijector.\n\n        Args:\n          validate_args: Python `bool` indicating whether arguments should be\n            checked for correctness.\n          name: Python `str` name given to ops managed by this object.", "id": "f15451:c0:m0"}
{"signature": "def _makeScale(self,<EOL>x,<EOL>scale_identity_multiplier=None,<EOL>scale_diag=None,<EOL>scale_tril=None,<EOL>scale_perturb_factor=None,<EOL>scale_perturb_diag=None):", "body": "c = scale_identity_multiplier<EOL>d1 = scale_diag<EOL>tril = scale_tril<EOL>v = scale_perturb_factor<EOL>d2 = scale_perturb_diag<EOL>if v is None and d2 is not None:<EOL><INDENT>return None<EOL><DEDENT>if c is None and d1 is None and tril is None:<EOL><INDENT>c = <NUM_LIT:1.><EOL><DEDENT>matrix = np.float32(<NUM_LIT:0.>)<EOL>if c is not None:<EOL><INDENT>matrix += c * self._matrix_diag(np.ones_like(x))<EOL><DEDENT>if d1 is not None:<EOL><INDENT>matrix += self._matrix_diag(np.array(d1, dtype=np.float32))<EOL><DEDENT>if tril is not None:<EOL><INDENT>matrix += np.array(tril, dtype=np.float32)<EOL><DEDENT>if v is not None:<EOL><INDENT>v = np.array(v, dtype=np.float32)<EOL>if v.ndim < <NUM_LIT:2>:<EOL><INDENT>vt = v.T<EOL><DEDENT>else:<EOL><INDENT>vt = np.swapaxes(v, axis1=v.ndim - <NUM_LIT:2>, axis2=v.ndim - <NUM_LIT:1>)<EOL><DEDENT>if d2 is not None:<EOL><INDENT>d2 = self._matrix_diag(np.array(d2, dtype=np.float32))<EOL>right = np.matmul(d2, vt)<EOL><DEDENT>else:<EOL><INDENT>right = vt<EOL><DEDENT>matrix += np.matmul(v, right)<EOL><DEDENT>return matrix<EOL>", "docstring": "Create a scale matrix. Return None if it can not be created.", "id": "f15455:c0:m16"}
{"signature": "def _sqrtx2p1(x):", "body": "sqrt_eps = np.sqrt(np.finfo(dtype_util.as_numpy_dtype(x.dtype)).eps)<EOL>return tf.where(<EOL>tf.abs(x) * sqrt_eps <= <NUM_LIT:1.>,<EOL>tf.sqrt(x**<NUM_LIT> + <NUM_LIT:1.>),<EOL>tf.abs(x))<EOL>", "docstring": "Implementation of `sqrt(1 + x**2)` which is stable despite large `x`.", "id": "f15457:m0"}
{"signature": "@property<EOL><INDENT>def shift(self):<DEDENT>", "body": "return self._shift<EOL>", "docstring": "The `shift` `Tensor` in `Y = scale @ X + shift`.", "id": "f15469:c0:m1"}
{"signature": "def masked_autoregressive_default_template(hidden_layers,<EOL>shift_only=False,<EOL>activation=tf.nn.relu,<EOL>log_scale_min_clip=-<NUM_LIT>,<EOL>log_scale_max_clip=<NUM_LIT>,<EOL>log_scale_clip_gradient=False,<EOL>name=None,<EOL>*args,  <EOL>**kwargs):", "body": "name = name or \"<STR_LIT>\"<EOL>with tf.compat.v2.name_scope(name):<EOL><INDENT>def _fn(x):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>input_depth = tf.compat.dimension_value(<EOL>tensorshape_util.with_rank_at_least(x.shape, <NUM_LIT:1>)[-<NUM_LIT:1>])<EOL>if input_depth is None:<EOL><INDENT>raise NotImplementedError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>input_shape = (<EOL>np.int32(tensorshape_util.as_list(x.shape))<EOL>if tensorshape_util.is_fully_defined(x.shape) else tf.shape(input=x))<EOL>if tensorshape_util.rank(x.shape) == <NUM_LIT:1>:<EOL><INDENT>x = x[tf.newaxis, ...]<EOL><DEDENT>for i, units in enumerate(hidden_layers):<EOL><INDENT>x = masked_dense(<EOL>inputs=x,<EOL>units=units,<EOL>num_blocks=input_depth,<EOL>exclusive=True if i == <NUM_LIT:0> else False,<EOL>activation=activation,<EOL>*args,  <EOL>**kwargs)<EOL><DEDENT>x = masked_dense(<EOL>inputs=x,<EOL>units=(<NUM_LIT:1> if shift_only else <NUM_LIT:2>) * input_depth,<EOL>num_blocks=input_depth,<EOL>activation=None,<EOL>*args,  <EOL>**kwargs)<EOL>if shift_only:<EOL><INDENT>x = tf.reshape(x, shape=input_shape)<EOL>return x, None<EOL><DEDENT>x = tf.reshape(x, shape=tf.concat([input_shape, [<NUM_LIT:2>]], axis=<NUM_LIT:0>))<EOL>shift, log_scale = tf.unstack(x, num=<NUM_LIT:2>, axis=-<NUM_LIT:1>)<EOL>which_clip = (<EOL>tf.clip_by_value<EOL>if log_scale_clip_gradient else clip_by_value_preserve_gradient)<EOL>log_scale = which_clip(log_scale, log_scale_min_clip, log_scale_max_clip)<EOL>return shift, log_scale<EOL><DEDENT>return tf.compat.v1.make_template(name, _fn)<EOL><DEDENT>", "docstring": "Build the Masked Autoregressive Density Estimator (Germain et al., 2015).\n\n    This will be wrapped in a make_template to ensure the variables are only\n    created once. It takes the input and returns the `loc` (\"mu\" in [Germain et\n    al. (2015)][1]) and `log_scale` (\"alpha\" in [Germain et al. (2015)][1]) from\n    the MADE network.\n\n    Warning: This function uses `masked_dense` to create randomly initialized\n    `tf.Variables`. It is presumed that these will be fit, just as you would any\n    other neural architecture which uses `tf.layers.dense`.\n\n    #### About Hidden Layers\n\n    Each element of `hidden_layers` should be greater than the `input_depth`\n    (i.e., `input_depth = tf.shape(input)[-1]` where `input` is the input to the\n    neural network). This is necessary to ensure the autoregressivity property.\n\n    #### About Clipping\n\n    This function also optionally clips the `log_scale` (but possibly not its\n    gradient). This is useful because if `log_scale` is too small/large it might\n    underflow/overflow making it impossible for the `MaskedAutoregressiveFlow`\n    bijector to implement a bijection. Additionally, the `log_scale_clip_gradient`\n    `bool` indicates whether the gradient should also be clipped. The default does\n    not clip the gradient; this is useful because it still provides gradient\n    information (for fitting) yet solves the numerical stability problem. I.e.,\n    `log_scale_clip_gradient = False` means\n    `grad[exp(clip(x))] = grad[x] exp(clip(x))` rather than the usual\n    `grad[clip(x)] exp(clip(x))`.\n\n    Args:\n      hidden_layers: Python `list`-like of non-negative integer, scalars\n        indicating the number of units in each hidden layer. Default: `[512, 512].\n      shift_only: Python `bool` indicating if only the `shift` term shall be\n        computed. Default: `False`.\n      activation: Activation function (callable). Explicitly setting to `None`\n        implies a linear activation.\n      log_scale_min_clip: `float`-like scalar `Tensor`, or a `Tensor` with the\n        same shape as `log_scale`. The minimum value to clip by. Default: -5.\n      log_scale_max_clip: `float`-like scalar `Tensor`, or a `Tensor` with the\n        same shape as `log_scale`. The maximum value to clip by. Default: 3.\n      log_scale_clip_gradient: Python `bool` indicating that the gradient of\n        `tf.clip_by_value` should be preserved. Default: `False`.\n      name: A name for ops managed by this function. Default:\n        \"masked_autoregressive_default_template\".\n      *args: `tf.layers.dense` arguments.\n      **kwargs: `tf.layers.dense` keyword arguments.\n\n    Returns:\n      shift: `Float`-like `Tensor` of shift terms (the \"mu\" in\n        [Germain et al.  (2015)][1]).\n      log_scale: `Float`-like `Tensor` of log(scale) terms (the \"alpha\" in\n        [Germain et al. (2015)][1]).\n\n    Raises:\n      NotImplementedError: if rightmost dimension of `inputs` is unknown prior to\n        graph execution.\n\n    #### References\n\n    [1]: Mathieu Germain, Karol Gregor, Iain Murray, and Hugo Larochelle. MADE:\n         Masked Autoencoder for Distribution Estimation. In _International\n         Conference on Machine Learning_, 2015. https://arxiv.org/abs/1502.03509", "id": "f15471:m3"}
{"signature": "def _make_masked_initializer(mask, initializer):", "body": "initializer = tf.keras.initializers.get(initializer)<EOL>def masked_initializer(shape, dtype=None, partition_info=None):<EOL><INDENT>if partition_info is None:<EOL><INDENT>x = initializer(shape, dtype)<EOL><DEDENT>else:<EOL><INDENT>x = initializer(shape, dtype, partition_info)<EOL><DEDENT>return tf.cast(mask, x.dtype) * x<EOL><DEDENT>return masked_initializer<EOL>", "docstring": "Returns a masked version of the given initializer.", "id": "f15471:m8"}
{"signature": "def _create_degrees(input_size,<EOL>hidden_units=None,<EOL>input_order=\"<STR_LIT>\",<EOL>hidden_degrees=\"<STR_LIT>\"):", "body": "input_order = _create_input_order(input_size, input_order)<EOL>degrees = [input_order]<EOL>if hidden_units is None:<EOL><INDENT>hidden_units = []<EOL><DEDENT>for units in hidden_units:<EOL><INDENT>if isinstance(hidden_degrees, six.string_types):<EOL><INDENT>if hidden_degrees == \"<STR_LIT>\":<EOL><INDENT>degrees.append(<EOL>np.random.randint(low=min(np.min(degrees[-<NUM_LIT:1>]), input_size - <NUM_LIT:1>),<EOL>high=input_size,<EOL>size=units))<EOL><DEDENT>elif hidden_degrees == \"<STR_LIT>\":<EOL><INDENT>min_degree = min(np.min(degrees[-<NUM_LIT:1>]), input_size - <NUM_LIT:1>)<EOL>degrees.append(np.maximum(<EOL>min_degree,<EOL>np.ceil(np.arange(<NUM_LIT:1>, units + <NUM_LIT:1>)<EOL>* (input_size - <NUM_LIT:1>) / float(units + <NUM_LIT:1>)).astype(np.int32)))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(hidden_degrees))<EOL><DEDENT><DEDENT>return degrees<EOL>", "docstring": "Returns a list of degree vectors, one for each input and hidden layer.\n\n    A unit with degree d can only receive input from units with degree < d. Output\n    units always have the same degree as their associated input unit.\n\n    Args:\n      input_size: Number of inputs.\n      hidden_units: list with the number of hidden units per layer. It does not\n        include the output layer. Each hidden unit size must be at least the size\n        of length (otherwise autoregressivity is not possible).\n      input_order: Order of degrees to the input units: 'random', 'left-to-right',\n        'right-to-left', or an array of an explicit order. For example,\n        'left-to-right' builds an autoregressive model\n        p(x) = p(x1) p(x2 | x1) ... p(xD | x<D).\n      hidden_degrees: Method for assigning degrees to the hidden units:\n        'equal', 'random'.  If 'equal', hidden units in each layer are allocated\n        equally (up to a remainder term) to each degree.  Default: 'equal'.\n\n    Raises:\n      ValueError: invalid input order.\n      ValueError: invalid hidden degrees.", "id": "f15471:m6"}
{"signature": "def _gen_slices(num_blocks, n_in, n_out, mask_type=MASK_EXCLUSIVE):", "body": "<EOL>slices = []<EOL>col = <NUM_LIT:0><EOL>d_in = n_in // num_blocks<EOL>d_out = n_out // num_blocks<EOL>row = d_out if mask_type == MASK_EXCLUSIVE else <NUM_LIT:0><EOL>for _ in range(num_blocks):<EOL><INDENT>row_slice = slice(row, None)<EOL>col_slice = slice(col, col + d_in)<EOL>slices.append([row_slice, col_slice])<EOL>col += d_in<EOL>row += d_out<EOL><DEDENT>return slices<EOL>", "docstring": "Generate the slices for building an autoregressive mask.", "id": "f15471:m0"}
{"signature": "def assert_bijective_and_finite(bijector,<EOL>x,<EOL>y,<EOL>event_ndims,<EOL>eval_func,<EOL>inverse_event_ndims=None,<EOL>atol=<NUM_LIT:0>,<EOL>rtol=<NUM_LIT>):", "body": "if inverse_event_ndims is None:<EOL><INDENT>inverse_event_ndims = event_ndims<EOL><DEDENT>assert_finite(x)<EOL>assert_finite(y)<EOL>f_x = bijector.forward(x)<EOL>g_y = bijector.inverse(y)<EOL>[<EOL>x_from_x,<EOL>y_from_y,<EOL>ildj_f_x,<EOL>fldj_x,<EOL>ildj_y,<EOL>fldj_g_y,<EOL>f_x_v,<EOL>g_y_v,<EOL>] = eval_func([<EOL>bijector.inverse(f_x),<EOL>bijector.forward(g_y),<EOL>bijector.inverse_log_det_jacobian(f_x, event_ndims=inverse_event_ndims),<EOL>bijector.forward_log_det_jacobian(x, event_ndims=event_ndims),<EOL>bijector.inverse_log_det_jacobian(y, event_ndims=inverse_event_ndims),<EOL>bijector.forward_log_det_jacobian(g_y, event_ndims=event_ndims),<EOL>f_x,<EOL>g_y,<EOL>])<EOL>assert_finite(x_from_x)<EOL>assert_finite(y_from_y)<EOL>assert_finite(ildj_f_x)<EOL>assert_finite(fldj_x)<EOL>assert_finite(ildj_y)<EOL>assert_finite(fldj_g_y)<EOL>assert_finite(f_x_v)<EOL>assert_finite(g_y_v)<EOL>np.testing.assert_allclose(x_from_x, x, atol=atol, rtol=rtol)<EOL>np.testing.assert_allclose(y_from_y, y, atol=atol, rtol=rtol)<EOL>np.testing.assert_allclose(-ildj_f_x, fldj_x, atol=atol, rtol=rtol)<EOL>np.testing.assert_allclose(-ildj_y, fldj_g_y, atol=atol, rtol=rtol)<EOL>", "docstring": "Assert that forward/inverse (along with jacobians) are inverses and finite.\n\n    It is recommended to use x and y values that are very very close to the edge\n    of the Bijector's domain.\n\n    Args:\n      bijector:  A Bijector instance.\n      x:  np.array of values in the domain of bijector.forward.\n      y:  np.array of values in the domain of bijector.inverse.\n      event_ndims: Integer describing the number of event dimensions this bijector\n        operates on.\n      eval_func: Function to evaluate any intermediate results.\n      inverse_event_ndims: Integer describing the number of event dimensions for\n        the bijector codomain. If None, then the value of `event_ndims` is used.\n      atol:  Absolute tolerance.\n      rtol:  Relative tolerance.\n\n    Raises:\n      AssertionError:  If tests fail.", "id": "f15473:m5"}
{"signature": "def assert_scalar_congruency(bijector,<EOL>lower_x,<EOL>upper_x,<EOL>eval_func,<EOL>n=int(<NUM_LIT>),<EOL>rtol=<NUM_LIT>):", "body": "<EOL>ten_x_pts = np.linspace(lower_x, upper_x, num=<NUM_LIT:10>).astype(np.float32)<EOL>if bijector.dtype is not None:<EOL><INDENT>ten_x_pts = ten_x_pts.astype(dtype_util.as_numpy_dtype(bijector.dtype))<EOL><DEDENT>forward_on_10_pts = bijector.forward(ten_x_pts)<EOL>lower_y, upper_y = eval_func(<EOL>[bijector.forward(lower_x),<EOL>bijector.forward(upper_x)])<EOL>if upper_y < lower_y:  <EOL><INDENT>lower_y, upper_y = upper_y, lower_y<EOL><DEDENT>uniform_x_samps = uniform_distribution.Uniform(<EOL>low=lower_x, high=upper_x).sample(<EOL>n, seed=<NUM_LIT:0>)<EOL>uniform_y_samps = uniform_distribution.Uniform(<EOL>low=lower_y, high=upper_y).sample(<EOL>n, seed=<NUM_LIT:1>)<EOL>inverse_forward_x = bijector.inverse(bijector.forward(uniform_x_samps))<EOL>forward_inverse_y = bijector.forward(bijector.inverse(uniform_y_samps))<EOL>dy_dx = tf.exp(<EOL>bijector.inverse_log_det_jacobian(uniform_y_samps, event_ndims=<NUM_LIT:0>))<EOL>expectation_of_dy_dx_under_uniform = tf.reduce_mean(input_tensor=dy_dx)<EOL>change_measure_dy_dx = (<EOL>(upper_y - lower_y) * expectation_of_dy_dx_under_uniform)<EOL>dx_dy = tf.exp(<EOL>bijector.forward_log_det_jacobian(<EOL>bijector.inverse(uniform_y_samps), event_ndims=<NUM_LIT:0>))<EOL>[<EOL>forward_on_10_pts_v,<EOL>dy_dx_v,<EOL>dx_dy_v,<EOL>change_measure_dy_dx_v,<EOL>uniform_x_samps_v,<EOL>uniform_y_samps_v,<EOL>inverse_forward_x_v,<EOL>forward_inverse_y_v,<EOL>] = eval_func([<EOL>forward_on_10_pts,<EOL>dy_dx,<EOL>dx_dy,<EOL>change_measure_dy_dx,<EOL>uniform_x_samps,<EOL>uniform_y_samps,<EOL>inverse_forward_x,<EOL>forward_inverse_y,<EOL>])<EOL>assert_strictly_monotonic(forward_on_10_pts_v)<EOL>np.testing.assert_allclose(<EOL>inverse_forward_x_v, uniform_x_samps_v, atol=<NUM_LIT>, rtol=<NUM_LIT>)<EOL>np.testing.assert_allclose(<EOL>forward_inverse_y_v, uniform_y_samps_v, atol=<NUM_LIT>, rtol=<NUM_LIT>)<EOL>np.testing.assert_allclose(<EOL>upper_x - lower_x, change_measure_dy_dx_v, atol=<NUM_LIT:0>, rtol=rtol)<EOL>np.testing.assert_allclose(<EOL>dy_dx_v, np.divide(<NUM_LIT:1.>, dx_dy_v), atol=<NUM_LIT>, rtol=<NUM_LIT>)<EOL>", "docstring": "Assert `bijector`'s forward/inverse/inverse_log_det_jacobian are congruent.\n\n    We draw samples `X ~ U(lower_x, upper_x)`, then feed these through the\n    `bijector` in order to check that:\n\n    1. the forward is strictly monotonic.\n    2. the forward/inverse methods are inverses of each other.\n    3. the jacobian is the correct change of measure.\n\n    This can only be used for a Bijector mapping open subsets of the real line\n    to themselves.  This is due to the fact that this test compares the `prob`\n    before/after transformation with the Lebesgue measure on the line.\n\n    Args:\n      bijector:  Instance of Bijector\n      lower_x:  Python scalar.\n      upper_x:  Python scalar.  Must have `lower_x < upper_x`, and both must be in\n        the domain of the `bijector`.  The `bijector` should probably not produce\n        huge variation in values in the interval `(lower_x, upper_x)`, or else the\n        variance based check of the Jacobian will require small `rtol` or huge\n        `n`.\n      eval_func: Function to evaluate any intermediate results.\n      n:  Number of samples to draw for the checks.\n      rtol:  Positive number.  Used for the Jacobian check.\n\n    Raises:\n      AssertionError:  If tests fail.", "id": "f15473:m4"}
{"signature": "@property<EOL><INDENT>def slope_scale(self):<DEDENT>", "body": "return self._slope_scale<EOL>", "docstring": "Standard deviation of the slope transitions.", "id": "f15478:c0:m2"}
{"signature": "@property<EOL><INDENT>def observation_noise_scale(self):<DEDENT>", "body": "return self._observation_noise_scale<EOL>", "docstring": "Standard deviation of the observation noise.", "id": "f15478:c0:m3"}
{"signature": "def _build_placeholder(self, ndarray):", "body": "ndarray = np.asarray(ndarray).astype(self.dtype)<EOL>return tf.compat.v1.placeholder_with_default(<EOL>input=ndarray, shape=ndarray.shape if self.use_static_shape else None)<EOL>", "docstring": "Convert a numpy array to a TF placeholder.\n\n        Args:\n          ndarray: any object convertible to a numpy array via `np.asarray()`.\n\n        Returns:\n          placeholder: a TensorFlow `placeholder` with default value given by the\n          provided `ndarray`, dtype given by `self.dtype`, and shape specified\n          statically only if `self.use_static_shape` is `True`.", "id": "f15480:c0:m4"}
{"signature": "def make_ar_transition_matrix(coefficients):", "body": "top_row = tf.expand_dims(coefficients, -<NUM_LIT:2>)<EOL>coef_shape = dist_util.prefer_static_shape(coefficients)<EOL>batch_shape, order = coef_shape[:-<NUM_LIT:1>], coef_shape[-<NUM_LIT:1>]<EOL>remaining_rows = tf.concat([<EOL>tf.eye(order - <NUM_LIT:1>, dtype=coefficients.dtype, batch_shape=batch_shape),<EOL>tf.zeros(tf.concat([batch_shape, (order - <NUM_LIT:1>, <NUM_LIT:1>)], axis=<NUM_LIT:0>),<EOL>dtype=coefficients.dtype)<EOL>], axis=-<NUM_LIT:1>)<EOL>ar_matrix = tf.concat([top_row, remaining_rows], axis=-<NUM_LIT:2>)<EOL>return ar_matrix<EOL>", "docstring": "Build transition matrix for an autoregressive StateSpaceModel.\n\n    When applied to a vector of previous values, this matrix computes\n    the expected new value (summing the previous states according to the\n    autoregressive coefficients) in the top dimension of the state space,\n    and moves all previous values down by one dimension, 'forgetting' the\n    final (least recent) value. That is, it looks like this:\n\n    ```\n    ar_matrix = [ coefs[0], coefs[1], ..., coefs[order]\n                  1.,       0 ,       ..., 0.\n                  0.,       1.,       ..., 0.\n                  ...\n                  0.,       0.,  ..., 1.,  0.            ]\n    ```\n\n    Args:\n      coefficients: float `Tensor` of shape `concat([batch_shape, [order]])`.\n\n    Returns:\n      ar_matrix: float `Tensor` with shape `concat([batch_shape,\n      [order, order]])`.", "id": "f15482:m0"}
{"signature": "def __init__(self,<EOL>order,<EOL>coefficients_prior=None,<EOL>level_scale_prior=None,<EOL>initial_state_prior=None,<EOL>coefficient_constraining_bijector=None,<EOL>observed_time_series=None,<EOL>name=None):", "body": "with tf.compat.v1.name_scope(<EOL>name, '<STR_LIT>', values=[observed_time_series]) as name:<EOL><INDENT>masked_time_series = None<EOL>if observed_time_series is not None:<EOL><INDENT>masked_time_series = (<EOL>sts_util.canonicalize_observed_time_series_with_mask(<EOL>observed_time_series))<EOL><DEDENT>dtype = dtype_util.common_dtype(<EOL>[(masked_time_series.time_series<EOL>if masked_time_series is not None else None),<EOL>coefficients_prior,<EOL>level_scale_prior,<EOL>initial_state_prior], preferred_dtype=tf.float32)<EOL>if observed_time_series is not None:<EOL><INDENT>_, observed_stddev, observed_initial = sts_util.empirical_statistics(<EOL>masked_time_series)<EOL><DEDENT>else:<EOL><INDENT>observed_stddev, observed_initial = (<EOL>tf.convert_to_tensor(value=<NUM_LIT:1.>, dtype=dtype),<EOL>tf.convert_to_tensor(value=<NUM_LIT:0.>, dtype=dtype))<EOL><DEDENT>batch_ones = tf.ones(tf.concat([<EOL>tf.shape(input=observed_initial),  <EOL>[order]], axis=<NUM_LIT:0>), dtype=dtype)<EOL>if coefficients_prior is None:<EOL><INDENT>coefficients_prior = tfd.MultivariateNormalDiag(<EOL>scale_diag=batch_ones)<EOL><DEDENT>if level_scale_prior is None:<EOL><INDENT>level_scale_prior = tfd.LogNormal(<EOL>loc=tf.math.log(<NUM_LIT> *  observed_stddev), scale=<NUM_LIT>)<EOL><DEDENT>if (coefficients_prior.event_shape.is_fully_defined() and<EOL>order != coefficients_prior.event_shape[<NUM_LIT:0>]):<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(<EOL>coefficients_prior.event_shape[<NUM_LIT:0>], order))<EOL><DEDENT>if initial_state_prior is None:<EOL><INDENT>initial_state_prior = tfd.MultivariateNormalDiag(<EOL>loc=observed_initial[..., tf.newaxis] * batch_ones,<EOL>scale_diag=(tf.abs(observed_initial) +<EOL>observed_stddev)[..., tf.newaxis] * batch_ones)<EOL><DEDENT>self._order = order<EOL>self._coefficients_prior = coefficients_prior<EOL>self._level_scale_prior = level_scale_prior<EOL>self._initial_state_prior = initial_state_prior<EOL>if coefficient_constraining_bijector is None:<EOL><INDENT>coefficient_constraining_bijector = tfb.Tanh()<EOL><DEDENT>super(Autoregressive, self).__init__(<EOL>parameters=[<EOL>Parameter('<STR_LIT>',<EOL>coefficients_prior,<EOL>coefficient_constraining_bijector),<EOL>Parameter('<STR_LIT>', level_scale_prior, tfb.Softplus())<EOL>],<EOL>latent_size=order,<EOL>name=name)<EOL><DEDENT>", "docstring": "Specify an autoregressive model.\n\n        Args:\n          order: scalar Python positive `int` specifying the number of past\n            timesteps to regress on.\n          coefficients_prior: optional `tfd.Distribution` instance specifying a\n            prior on the `coefficients` parameter. If `None`, a default standard\n            normal (`tfd.MultivariateNormalDiag(scale_diag=tf.ones([order]))`) prior\n            is used.\n            Default value: `None`.\n          level_scale_prior: optional `tfd.Distribution` instance specifying a prior\n            on the `level_scale` parameter. If `None`, a heuristic default prior is\n            constructed based on the provided `observed_time_series`.\n            Default value: `None`.\n          initial_state_prior: optional `tfd.Distribution` instance specifying a\n            prior on the initial state, corresponding to the values of the process\n            at a set of size `order` of imagined timesteps before the initial step.\n            If `None`, a heuristic default prior is constructed based on the\n            provided `observed_time_series`.\n            Default value: `None`.\n          coefficient_constraining_bijector: optional `tfb.Bijector` instance\n            representing a constraining mapping for the autoregressive coefficients.\n            For example, `tfb.Tanh()` constrains the coefficients to lie in\n            `(-1, 1)`, while `tfb.Softplus()` constrains them to be positive, and\n            `tfb.Identity()` implies no constraint. If `None`, the default behavior\n            constrains the coefficients to lie in `(-1, 1)` using a `Tanh` bijector.\n            Default value: `None`.\n          observed_time_series: optional `float` `Tensor` of shape\n            `batch_shape + [T, 1]` (omitting the trailing unit dimension is also\n            supported when `T > 1`), specifying an observed time series.\n            Any priors not explicitly set will be given default values according to\n            the scale of the observed time series (or batch of time series). May\n            optionally be an instance of `tfp.sts.MaskedTimeSeries`, which includes\n            a mask `Tensor` to specify timesteps with missing observations.\n            Default value: `None`.\n          name: the name of this model component.\n            Default value: 'Autoregressive'.", "id": "f15482:c1:m0"}
{"signature": "def _maybe_expand_trailing_dim(observed_time_series_tensor):", "body": "with tf.compat.v1.name_scope(<EOL>'<STR_LIT>', values=[observed_time_series_tensor]):<EOL><INDENT>if (observed_time_series_tensor.shape.ndims is not None and<EOL>tf.compat.dimension_value(<EOL>observed_time_series_tensor.shape[-<NUM_LIT:1>]) is not None):<EOL><INDENT>expanded_time_series = (<EOL>observed_time_series_tensor<EOL>if observed_time_series_tensor.shape[-<NUM_LIT:1>] == <NUM_LIT:1><EOL>else observed_time_series_tensor[..., tf.newaxis])<EOL><DEDENT>else:<EOL><INDENT>expanded_time_series = tf.cond(<EOL>pred=tf.equal(tf.shape(input=observed_time_series_tensor)[-<NUM_LIT:1>], <NUM_LIT:1>),<EOL>true_fn=lambda: observed_time_series_tensor,<EOL>false_fn=lambda: observed_time_series_tensor[..., tf.newaxis])<EOL><DEDENT>return expanded_time_series<EOL><DEDENT>", "docstring": "Ensures `observed_time_series_tensor` has a trailing dimension of size 1.\n\n    The `tfd.LinearGaussianStateSpaceModel` Distribution has event shape of\n    `[num_timesteps, observation_size]`, but canonical BSTS models\n    are univariate, so their observation_size is always `1`. The extra trailing\n    dimension gets annoying, so this method allows arguments with or without the\n    extra dimension. There is no ambiguity except in the trivial special case\n    where  `num_timesteps = 1`; this can be avoided by specifying any unit-length\n    series in the explicit `[num_timesteps, 1]` style.\n\n    Most users should not call this method directly, and instead call\n    `canonicalize_observed_time_series_with_mask`, which handles converting\n    to `Tensor` and specifying an optional missingness mask.\n\n    Args:\n      observed_time_series_tensor: `Tensor` of shape\n        `batch_shape + [num_timesteps, 1]` or `batch_shape + [num_timesteps]`,\n        where `num_timesteps > 1`.\n\n    Returns:\n      expanded_time_series: `Tensor` of shape `batch_shape + [num_timesteps, 1]`.", "id": "f15484:m5"}
{"signature": "def sum_mvns(distributions):", "body": "graph_parents = [tensor for distribution in distributions<EOL>for tensor in distribution._graph_parents]  <EOL>with tf.compat.v1.name_scope('<STR_LIT>', values=graph_parents):<EOL><INDENT>if all([isinstance(mvn, tfd.MultivariateNormalDiag)<EOL>for mvn in distributions]):<EOL><INDENT>return tfd.MultivariateNormalDiag(<EOL>loc=sum([mvn.mean() for mvn in distributions]),<EOL>scale_diag=tf.sqrt(sum([<EOL>mvn.scale.diag**<NUM_LIT:2> for mvn in distributions])))<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(distributions))<EOL><DEDENT><DEDENT>", "docstring": "Attempt to sum MultivariateNormal distributions.\n\n    The sum of (multivariate) normal random variables is itself (multivariate)\n    normal, with mean given by the sum of means and (co)variance given by the\n    sum of (co)variances. This method exploits this fact to compute the\n    sum of a list of `tfd.MultivariateNormalDiag` objects.\n\n    It may in the future be extended to support summation of other forms of\n    (Multivariate)Normal distributions.\n\n    Args:\n      distributions: Python `iterable` of `tfd.MultivariateNormalDiag`\n        distribution instances. These must all have the same event\n        shape, and broadcast to a consistent batch shape.\n\n    Returns:\n      sum_distribution: A `tfd.MultivariateNormalDiag` instance with mean\n        equal to the sum of input means and covariance equal to the sum of\n        input covariances.", "id": "f15484:m3"}
{"signature": "def canonicalize_observed_time_series_with_mask(<EOL>maybe_masked_observed_time_series):", "body": "with tf.compat.v1.name_scope('<STR_LIT>'):<EOL><INDENT>if hasattr(maybe_masked_observed_time_series, '<STR_LIT>'):<EOL><INDENT>observed_time_series = (<EOL>maybe_masked_observed_time_series.time_series)<EOL>is_missing = maybe_masked_observed_time_series.is_missing<EOL><DEDENT>else:<EOL><INDENT>observed_time_series = maybe_masked_observed_time_series<EOL>is_missing = None<EOL><DEDENT>observed_time_series = tf.convert_to_tensor(value=observed_time_series,<EOL>name='<STR_LIT>')<EOL>observed_time_series = _maybe_expand_trailing_dim(observed_time_series)<EOL>if is_missing is not None:<EOL><INDENT>is_missing = tf.convert_to_tensor(<EOL>value=is_missing, name='<STR_LIT>', dtype_hint=tf.bool)<EOL><DEDENT>return missing_values_util.MaskedTimeSeries(observed_time_series,<EOL>is_missing=is_missing)<EOL><DEDENT>", "docstring": "Extract a Tensor with canonical shape and optional mask.\n\n    Args:\n      maybe_masked_observed_time_series: a `Tensor`-like object with shape\n        `[..., num_timesteps]` or `[..., num_timesteps, 1]`, or a\n        `tfp.sts.MaskedTimeSeries` containing such an object.\n    Returns:\n      masked_time_series: a `tfp.sts.MaskedTimeSeries` namedtuple, in which\n        the `observed_time_series` is converted to `Tensor` with canonical shape\n        `[..., num_timesteps, 1]`, and `is_missing` is either `None` or a boolean\n        `Tensor`.", "id": "f15484:m6"}
{"signature": "def _build_tensor(self, ndarray):", "body": "ndarray = np.asarray(ndarray).astype(self.dtype)<EOL>return tf.compat.v1.placeholder_with_default(<EOL>input=ndarray, shape=ndarray.shape if self.use_static_shape else None)<EOL>", "docstring": "Convert a numpy array to a TF placeholder.\n\n        Args:\n          ndarray: any object convertible to a numpy array via `np.asarray()`.\n\n        Returns:\n          placeholder: a TensorFlow `placeholder` with default value given by the\n          provided `ndarray`, dtype given by `self.dtype`, and shape specified\n          statically only if `self.use_static_shape` is `True`.", "id": "f15485:c1:m7"}
{"signature": "def fit_with_hmc(model,<EOL>observed_time_series,<EOL>num_results=<NUM_LIT:100>,<EOL>num_warmup_steps=<NUM_LIT:50>,<EOL>num_leapfrog_steps=<NUM_LIT:15>,<EOL>initial_state=None,<EOL>initial_step_size=None,<EOL>chain_batch_shape=(),<EOL>num_variational_steps=<NUM_LIT>,<EOL>variational_optimizer=None,<EOL>seed=None,<EOL>name=None):", "body": "with tf.compat.v1.name_scope(<EOL>name, '<STR_LIT>', values=[observed_time_series]) as name:<EOL><INDENT>seed = tfd.SeedStream(seed, salt='<STR_LIT>')<EOL>if initial_step_size is None or initial_state is None:<EOL><INDENT>def make_variational():<EOL><INDENT>return build_factored_variational_loss(<EOL>model, observed_time_series,<EOL>init_batch_shape=chain_batch_shape, seed=seed())<EOL><DEDENT>make_variational = tf.compat.v1.make_template('<STR_LIT>',<EOL>make_variational)<EOL>_, variational_distributions = make_variational()<EOL>minimize_op = _minimize_in_graph(<EOL>build_loss_fn=lambda: make_variational()[<NUM_LIT:0>],  <EOL>num_steps=num_variational_steps,<EOL>optimizer=variational_optimizer)<EOL>with tf.control_dependencies([minimize_op]):<EOL><INDENT>if initial_state is None:<EOL><INDENT>initial_state = [tf.stop_gradient(d.sample())<EOL>for d in variational_distributions.values()]<EOL><DEDENT>if initial_step_size is None:<EOL><INDENT>initial_step_size = [<EOL>transformed_q.distribution.stddev()<EOL>for transformed_q in variational_distributions.values()]<EOL><DEDENT><DEDENT><DEDENT>observed_time_series = sts_util.pad_batch_dimension_for_multiple_chains(<EOL>observed_time_series, model, chain_batch_shape=chain_batch_shape)<EOL>samples, kernel_results = mcmc.sample_chain(<EOL>num_results=num_results,<EOL>current_state=initial_state,<EOL>num_burnin_steps=num_warmup_steps,<EOL>kernel=mcmc.SimpleStepSizeAdaptation(<EOL>inner_kernel=mcmc.TransformedTransitionKernel(<EOL>inner_kernel=mcmc.HamiltonianMonteCarlo(<EOL>target_log_prob_fn=model.joint_log_prob(<EOL>observed_time_series),<EOL>step_size=initial_step_size,<EOL>num_leapfrog_steps=num_leapfrog_steps,<EOL>state_gradients_are_stopped=True,<EOL>seed=seed()),<EOL>bijector=[param.bijector for param in model.parameters]),<EOL>num_adaptation_steps=int(num_warmup_steps * <NUM_LIT>),<EOL>adaptation_rate=tf.convert_to_tensor(<EOL>value=<NUM_LIT:0.1>, dtype=initial_state[<NUM_LIT:0>].dtype)),<EOL>parallel_iterations=<NUM_LIT:1> if seed is not None else <NUM_LIT:10>)<EOL>return samples, kernel_results<EOL><DEDENT>", "docstring": "Draw posterior samples using Hamiltonian Monte Carlo (HMC).\n\n    Markov chain Monte Carlo (MCMC) methods are considered the gold standard of\n    Bayesian inference; under suitable conditions and in the limit of infinitely\n    many draws they generate samples from the true posterior distribution. HMC [1]\n    uses gradients of the model's log-density function to propose samples,\n    allowing it to exploit posterior geometry. However, it is computationally more\n    expensive than variational inference and relatively sensitive to tuning.\n\n    This method attempts to provide a sensible default approach for fitting\n    StructuralTimeSeries models using HMC. It first runs variational inference as\n    a fast posterior approximation, and initializes the HMC sampler from the\n    variational posterior, using the posterior standard deviations to set\n    per-variable step sizes (equivalently, a diagonal mass matrix). During the\n    warmup phase, it adapts the step size to target an acceptance rate of 0.75,\n    which is thought to be in the desirable range for optimal mixing [2].\n\n\n    Args:\n      model: An instance of `StructuralTimeSeries` representing a\n        time-series model. This represents a joint distribution over\n        time-series and their parameters with batch shape `[b1, ..., bN]`.\n      observed_time_series: `float` `Tensor` of shape\n        `concat([sample_shape, model.batch_shape, [num_timesteps, 1]]) where\n        `sample_shape` corresponds to i.i.d. observations, and the trailing `[1]`\n        dimension may (optionally) be omitted if `num_timesteps > 1`. May\n        optionally be an instance of `tfp.sts.MaskedTimeSeries`, which includes\n        a mask `Tensor` to specify timesteps with missing observations.\n      num_results: Integer number of Markov chain draws.\n        Default value: `100`.\n      num_warmup_steps: Integer number of steps to take before starting to\n        collect results. The warmup steps are also used to adapt the step size\n        towards a target acceptance rate of 0.75.\n        Default value: `50`.\n      num_leapfrog_steps: Integer number of steps to run the leapfrog integrator\n        for. Total progress per HMC step is roughly proportional to\n        `step_size * num_leapfrog_steps`.\n        Default value: `15`.\n      initial_state: Optional Python `list` of `Tensor`s, one for each model\n        parameter, representing the initial state(s) of the Markov chain(s). These\n        should have shape `concat([chain_batch_shape, param.prior.batch_shape,\n        param.prior.event_shape])`. If `None`, the initial state is set\n        automatically using a sample from a variational posterior.\n        Default value: `None`.\n      initial_step_size: Python `list` of `Tensor`s, one for each model parameter,\n        representing the step size for the leapfrog integrator. Must\n        broadcast with the shape of `initial_state`. Larger step sizes lead to\n        faster progress, but too-large step sizes make rejection exponentially\n        more likely. If `None`, the step size is set automatically using the\n        standard deviation of a variational posterior.\n        Default value: `None`.\n      chain_batch_shape: Batch shape (Python `tuple`, `list`, or `int`) of chains\n        to run in parallel.\n        Default value: `[]` (i.e., a single chain).\n      num_variational_steps: Python `int` number of steps to run the variational\n        optimization to determine the initial state and step sizes.\n        Default value: `150`.\n      variational_optimizer: Optional `tf.train.Optimizer` instance to use in\n        the variational optimization. If `None`, defaults to\n        `tf.train.AdamOptimizer(0.1)`.\n        Default value: `None`.\n      seed: Python integer to seed the random number generator.\n      name: Python `str` name prefixed to ops created by this function.\n        Default value: `None` (i.e., 'fit_with_hmc').\n\n    Returns:\n      samples: Python `list` of `Tensors` representing posterior samples of model\n        parameters, with shapes `[concat([[num_results], chain_batch_shape,\n        param.prior.batch_shape, param.prior.event_shape]) for param in\n        model.parameters]`.\n      kernel_results: A (possibly nested) `tuple`, `namedtuple` or `list` of\n        `Tensor`s representing internal calculations made within the HMC sampler.\n\n    #### Examples\n\n    Assume we've built a structural time-series model:\n\n    ```python\n      day_of_week = tfp.sts.Seasonal(\n          num_seasons=7,\n          observed_time_series=observed_time_series,\n          name='day_of_week')\n      local_linear_trend = tfp.sts.LocalLinearTrend(\n          observed_time_series=observed_time_series,\n          name='local_linear_trend')\n      model = tfp.sts.Sum(components=[day_of_week, local_linear_trend],\n                          observed_time_series=observed_time_series)\n    ```\n\n    To draw posterior samples using HMC under default settings:\n\n    ```python\n    samples, kernel_results = tfp.sts.fit_with_hmc(model, observed_time_series)\n\n    with tf.Session() as sess:\n      sess.run(tf.global_variables_initializer())\n      samples_, kernel_results_ = sess.run((samples, kernel_results))\n\n    print(\"acceptance rate: {}\".format(\n      np.mean(kernel_results_.inner_results.is_accepted, axis=0)))\n    print(\"posterior means: {}\".format(\n      {param.name: np.mean(param_draws, axis=0)\n       for (param, param_draws) in zip(model.parameters, samples_)}))\n    ```\n\n    We can also run multiple chains. This may help diagnose convergence issues\n    and allows us to exploit vectorization to draw samples more quickly, although\n    warmup still requires the same number of sequential steps.\n\n    ```python\n    from matplotlib import pylab as plt\n\n    samples, kernel_results = tfp.sts.fit_with_hmc(\n      model, observed_time_series, chain_batch_shape=[10])\n\n    with tf.Session() as sess:\n      sess.run(tf.global_variables_initializer())\n      samples_, kernel_results_ = sess.run((samples, kernel_results))\n\n    print(\"acceptance rate: {}\".format(\n      np.mean(kernel_results_.inner_results.inner_results.is_accepted, axis=0)))\n\n    # Plot the sampled traces for each parameter. If the chains have mixed, their\n    # traces should all cover the same region of state space, frequently crossing\n    # over each other.\n    for (param, param_draws) in zip(model.parameters, samples_):\n      if param.prior.event_shape.ndims > 0:\n        print(\"Only plotting traces for scalar parameters, skipping {}\".format(\n          param.name))\n        continue\n      plt.figure(figsize=[10, 4])\n      plt.title(param.name)\n      plt.plot(param_draws)\n      plt.ylabel(param.name)\n      plt.xlabel(\"HMC step\")\n\n    # Combining the samples from multiple chains into a single dimension allows\n    # us to easily pass sampled parameters to downstream forecasting methods.\n    combined_samples_ = [np.reshape(param_draws,\n                                    [-1] + list(param_draws.shape[2:]))\n                         for param_draws in samples_]\n    ```\n\n    For greater flexibility, you may prefer to implement your own sampler using\n    the TensorFlow Probability primitives in `tfp.mcmc`. The following recipe\n    constructs a basic HMC sampler, using a `TransformedTransitionKernel` to\n    incorporate constraints on the parameter space.\n\n    ```python\n    transformed_hmc_kernel = mcmc.TransformedTransitionKernel(\n        inner_kernel=mcmc.SimpleStepSizeAdaptation(\n            inner_kernel=mcmc.HamiltonianMonteCarlo(\n                target_log_prob_fn=model.joint_log_prob(observed_time_series),\n                step_size=step_size,\n                num_leapfrog_steps=num_leapfrog_steps,\n                state_gradients_are_stopped=True,\n                seed=seed),\n            num_adaptation_steps = int(0.8 * num_warmup_steps)),\n        bijector=[param.bijector for param in model.parameters])\n\n    # Initialize from a Uniform[-2, 2] distribution in unconstrained space.\n    initial_state = [tfp.sts.sample_uniform_initial_state(\n      param, return_constrained=True) for param in model.parameters]\n\n    samples, kernel_results = tfp.mcmc.sample_chain(\n      kernel=transformed_hmc_kernel,\n      num_results=num_results,\n      current_state=initial_state,\n      num_burnin_steps=num_warmup_steps)\n    ```\n\n    #### References\n\n    [1]: Radford Neal. MCMC Using Hamiltonian Dynamics. _Handbook of Markov Chain\n         Monte Carlo_, 2011. https://arxiv.org/abs/1206.1901\n    [2]  M.J. Betancourt, Simon Byrne, and Mark Girolami. Optimizing The\n         Integrator Step Size for Hamiltonian Monte Carlo.\n         https://arxiv.org/abs/1411.6669", "id": "f15494:m4"}
{"signature": "def _build_placeholder(self, ndarray):", "body": "ndarray = np.asarray(ndarray).astype(self.dtype)<EOL>return tf.compat.v1.placeholder_with_default(<EOL>input=ndarray, shape=ndarray.shape if self.use_static_shape else None)<EOL>", "docstring": "Convert a numpy array to a TF placeholder.\n\n        Args:\n          ndarray: any object convertible to a numpy array via `np.asarray()`.\n\n        Returns:\n          placeholder: a TensorFlow `placeholder` with default value given by the\n          provided `ndarray`, dtype given by `self.dtype`, and shape specified\n          statically only if `self.use_static_shape` is `True`.", "id": "f15495:c4:m1"}
{"signature": "@property<EOL><INDENT>def observation_noise_scale(self):<DEDENT>", "body": "return self._observation_noise_scale<EOL>", "docstring": "Standard deviation of the observation noise.", "id": "f15498:c0:m2"}
{"signature": "@property<EOL><INDENT>def initial_state_prior(self):<DEDENT>", "body": "return self._initial_state_prior<EOL>", "docstring": "Prior distribution on the initial latent state (level and scale).", "id": "f15498:c1:m1"}
{"signature": "@property<EOL><INDENT>def components(self):<DEDENT>", "body": "return self._components<EOL>", "docstring": "List of component `StructuralTimeSeries` models.", "id": "f15500:c1:m1"}
{"signature": "def __init__(self,<EOL>components,<EOL>constant_offset=None,<EOL>observation_noise_scale_prior=None,<EOL>observed_time_series=None,<EOL>name=None):", "body": "with tf.compat.v1.name_scope(<EOL>name, '<STR_LIT>', values=[observed_time_series]) as name:<EOL><INDENT>if observed_time_series is not None:<EOL><INDENT>observed_mean, observed_stddev, _ = (<EOL>sts_util.empirical_statistics(observed_time_series))<EOL><DEDENT>else:<EOL><INDENT>observed_mean, observed_stddev = <NUM_LIT:0.>, <NUM_LIT:1.><EOL><DEDENT>if observation_noise_scale_prior is None:<EOL><INDENT>observation_noise_scale_prior = tfd.LogNormal(<EOL>loc=tf.math.log(<NUM_LIT> * observed_stddev), scale=<NUM_LIT>)<EOL><DEDENT>if constant_offset is None:<EOL><INDENT>constant_offset = observed_mean<EOL><DEDENT>component_names = [c.name for c in components]<EOL>if len(component_names) != len(set(component_names)):<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'.format(component_names))<EOL><DEDENT>components_by_name = collections.OrderedDict(<EOL>[(c.name, c) for c in components])<EOL>parameters = [<EOL>Parameter('<STR_LIT>', observation_noise_scale_prior,<EOL>tfb.Softplus()),<EOL>] + [Parameter(name='<STR_LIT>'.format(component.name, parameter.name),<EOL>prior=parameter.prior,<EOL>bijector=parameter.bijector)<EOL>for component in components for parameter in component.parameters]<EOL>self._components = components<EOL>self._components_by_name = components_by_name<EOL>self._constant_offset = constant_offset<EOL>super(Sum, self).__init__(<EOL>parameters=parameters,<EOL>latent_size=sum(<EOL>[component.latent_size for component in components]),<EOL>name=name)<EOL><DEDENT>", "docstring": "Specify a structural time series model representing a sum of components.\n\n        Args:\n          components: Python `list` of one or more StructuralTimeSeries instances.\n            These must have unique names.\n          constant_offset: optional scalar `float` `Tensor`, or batch of scalars,\n            specifying a constant value added to the sum of outputs from the\n            component models. This allows the components to model the shifted series\n            `observed_time_series - constant_offset`. If `None`, this is set to the\n            mean of the provided `observed_time_series`.\n            Default value: `None`.\n          observation_noise_scale_prior: optional `tfd.Distribution` instance\n            specifying a prior on `observation_noise_scale`. If `None`, a heuristic\n            default prior is constructed based on the provided\n            `observed_time_series`.\n            Default value: `None`.\n          observed_time_series: optional `float` `Tensor` of shape\n            `batch_shape + [T, 1]` (omitting the trailing unit dimension is also\n            supported when `T > 1`), specifying an observed time series. This is\n            used to set the constant offset, if not provided, and to construct a\n            default heuristic `observation_noise_scale_prior` if not provided. May\n            optionally be an instance of `tfp.sts.MaskedTimeSeries`, which includes\n            a mask `Tensor` to specify timesteps with missing observations.\n            Default value: `None`.\n          name: Python `str` name of this model component; used as `name_scope`\n            for ops created by this class.\n            Default value: 'Sum'.\n\n        Raises:\n          ValueError: if components do not have unique names.", "id": "f15500:c1:m0"}
{"signature": "@property<EOL><INDENT>def num_seasons(self):<DEDENT>", "body": "return self._num_seasons<EOL>", "docstring": "Number of seasons.", "id": "f15501:c2:m2"}
{"signature": "@property<EOL><INDENT>def num_steps_per_season(self):<DEDENT>", "body": "return self._num_steps_per_season<EOL>", "docstring": "Number of steps per season.", "id": "f15501:c2:m3"}
{"signature": "@property<EOL><INDENT>def constrain_mean_effect_to_zero(self):<DEDENT>", "body": "return self._constrain_mean_effect_to_zero<EOL>", "docstring": "Whether to constrain the mean effect to zero.", "id": "f15501:c2:m1"}
{"signature": "def __init__(self,<EOL>num_timesteps,<EOL>num_seasons,<EOL>drift_scale,<EOL>initial_state_prior,<EOL>observation_noise_scale=<NUM_LIT>,  <EOL>num_steps_per_season=<NUM_LIT:1>,<EOL>initial_step=<NUM_LIT:0>,<EOL>validate_args=False,<EOL>allow_nan_stats=True,<EOL>name=None):  ", "body": "with tf.compat.v1.name_scope(<EOL>name, '<STR_LIT>',<EOL>values=[drift_scale, observation_noise_scale]) as name:<EOL><INDENT>dtype = initial_state_prior.dtype<EOL>drift_scale = tf.convert_to_tensor(<EOL>value=drift_scale, name='<STR_LIT>', dtype=dtype)<EOL>observation_noise_scale = tf.convert_to_tensor(<EOL>value=observation_noise_scale,<EOL>name='<STR_LIT>',<EOL>dtype=dtype)<EOL>num_steps_per_season = np.squeeze(np.asarray(num_steps_per_season))<EOL>if num_steps_per_season.ndim == <NUM_LIT:0>:  <EOL><INDENT>num_steps_per_season = np.tile(num_steps_per_season, num_seasons)<EOL><DEDENT>elif ((num_steps_per_season.ndim <= <NUM_LIT:2>)  <EOL>and (num_steps_per_season.shape[-<NUM_LIT:1>] != num_seasons)):<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>num_seasons, num_steps_per_season.shape))<EOL><DEDENT>is_last_day_of_season = build_is_last_day_of_season(num_steps_per_season)<EOL>[<EOL>effects_to_residuals,<EOL>residuals_to_effects<EOL>] = build_effects_to_residuals_matrix(num_seasons, dtype=dtype)<EOL>seasonal_transition_matrix = build_seasonal_transition_matrix(<EOL>num_seasons=num_seasons,<EOL>is_last_day_of_season=is_last_day_of_season,<EOL>dtype=dtype,<EOL>basis_change_matrix=effects_to_residuals,<EOL>basis_change_matrix_inv=residuals_to_effects)<EOL>seasonal_transition_noise = build_constrained_seasonal_transition_noise(<EOL>drift_scale, num_seasons, is_last_day_of_season)<EOL>observation_matrix = tf.concat(<EOL>[tf.ones([<NUM_LIT:1>, <NUM_LIT:1>], dtype=dtype),<EOL>tf.zeros([<NUM_LIT:1>, num_seasons-<NUM_LIT:1>], dtype=dtype)], axis=-<NUM_LIT:1>)<EOL>observation_matrix = tf.matmul(observation_matrix, residuals_to_effects)<EOL>self._drift_scale = drift_scale<EOL>self._observation_noise_scale = observation_noise_scale<EOL>self._num_seasons = num_seasons<EOL>self._num_steps_per_season = num_steps_per_season<EOL>super(ConstrainedSeasonalStateSpaceModel, self).__init__(<EOL>num_timesteps=num_timesteps,<EOL>transition_matrix=seasonal_transition_matrix,<EOL>transition_noise=seasonal_transition_noise,<EOL>observation_matrix=observation_matrix,<EOL>observation_noise=tfd.MultivariateNormalDiag(<EOL>scale_diag=observation_noise_scale[..., tf.newaxis]),<EOL>initial_state_prior=initial_state_prior,<EOL>initial_step=initial_step,<EOL>allow_nan_stats=allow_nan_stats,<EOL>validate_args=validate_args,<EOL>name=name)<EOL><DEDENT>", "docstring": "Build a seasonal effect state space model with a zero-sum constraint.\n\n        {seasonal_init_args}", "id": "f15501:c1:m0"}
{"signature": "def batch_shape_tensor(self):", "body": "batch_shape = tf.constant([], dtype=tf.int32)<EOL>for param in self.parameters:<EOL><INDENT>batch_shape = tf.broadcast_dynamic_shape(<EOL>batch_shape, param.prior.batch_shape_tensor())<EOL><DEDENT>return batch_shape<EOL>", "docstring": "Runtime batch shape of models represented by this component.\n\n        Returns:\n          batch_shape: `int` `Tensor` giving the broadcast batch shape of\n            all model parameters. This should match the batch shape of\n            derived state space models, i.e.,\n            `self.make_state_space_model(...).batch_shape_tensor()`.", "id": "f15502:c0:m5"}
{"signature": "@property<EOL><INDENT>def batch_shape(self):<DEDENT>", "body": "batch_shape = tf.TensorShape([])<EOL>for param in self.parameters:<EOL><INDENT>batch_shape = tf.broadcast_static_shape(<EOL>batch_shape, param.prior.batch_shape)<EOL><DEDENT>return batch_shape<EOL>", "docstring": "Static batch shape of models represented by this component.\n\n        Returns:\n          batch_shape: A `tf.TensorShape` giving the broadcast batch shape of\n            all model parameters. This should match the batch shape of\n            derived state space models, i.e.,\n            `self.make_state_space_model(...).batch_shape`. It may be partially\n            defined or unknown.", "id": "f15502:c0:m4"}
{"signature": "@property<EOL><INDENT>def parameters(self):<DEDENT>", "body": "return self._parameters<EOL>", "docstring": "List of Parameter(name, prior, bijector) namedtuples for this model.", "id": "f15502:c0:m1"}
{"signature": "@property<EOL><INDENT>def latent_size(self):<DEDENT>", "body": "return self._latent_size<EOL>", "docstring": "Python `int` dimensionality of the latent space in this model.", "id": "f15502:c0:m2"}
{"signature": "def prior_sample(self,<EOL>num_timesteps,<EOL>initial_step=<NUM_LIT:0>,<EOL>params_sample_shape=(),<EOL>trajectories_sample_shape=(),<EOL>seed=None):", "body": "seed = distributions.SeedStream(<EOL>seed, salt='<STR_LIT>')<EOL>with tf.compat.v1.name_scope(<EOL>'<STR_LIT>',<EOL>values=[num_timesteps, params_sample_shape, trajectories_sample_shape]):<EOL><INDENT>param_samples = [<EOL>p.prior.sample(params_sample_shape, seed=seed(), name=p.name)<EOL>for p in self.parameters<EOL>]<EOL>model = self.make_state_space_model(<EOL>num_timesteps=num_timesteps,<EOL>initial_step=initial_step,<EOL>param_vals=param_samples)<EOL>return model.sample(trajectories_sample_shape, seed=seed()), param_samples<EOL><DEDENT>", "docstring": "Sample from the joint prior over model parameters and trajectories.\n\n        Args:\n          num_timesteps: Scalar `int` `Tensor` number of timesteps to model.\n          initial_step: Optional scalar `int` `Tensor` specifying the starting\n            timestep.\n              Default value: 0.\n          params_sample_shape: Number of possible worlds to sample iid from the\n            parameter prior, or more generally, `Tensor` `int` shape to fill with\n            iid samples.\n              Default value: [] (i.e., draw a single sample and don't expand the\n              shape).\n          trajectories_sample_shape: For each sampled set of parameters, number\n            of trajectories to sample, or more generally, `Tensor` `int` shape to\n            fill with iid samples.\n            Default value: [] (i.e., draw a single sample and don't expand the\n              shape).\n          seed: Python `int` random seed.\n\n        Returns:\n          trajectories: `float` `Tensor` of shape\n            `trajectories_sample_shape + params_sample_shape + [num_timesteps, 1]`\n            containing all sampled trajectories.\n          param_samples: list of sampled parameter value `Tensor`s, in order\n            corresponding to `self.parameters`, each of shape\n            `params_sample_shape + prior.batch_shape + prior.event_shape`.", "id": "f15502:c0:m8"}
{"signature": "@property<EOL><INDENT>def name(self):<DEDENT>", "body": "return self._name<EOL>", "docstring": "Name of this model component.", "id": "f15502:c0:m3"}
{"signature": "def joint_log_prob(self, observed_time_series):", "body": "with tf.compat.v1.name_scope(<EOL>'<STR_LIT>', values=[observed_time_series]):<EOL><INDENT>[<EOL>observed_time_series,<EOL>mask<EOL>] = sts_util.canonicalize_observed_time_series_with_mask(<EOL>observed_time_series)<EOL>num_timesteps = distribution_util.prefer_static_value(<EOL>tf.shape(input=observed_time_series))[-<NUM_LIT:2>]<EOL>def log_joint_fn(*param_vals):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>param_lp = sum([<EOL>param.prior.log_prob(param_val)<EOL>for (param, param_val) in zip(self.parameters, param_vals)<EOL>])<EOL>lgssm = self.make_state_space_model(<EOL>param_vals=param_vals, num_timesteps=num_timesteps)<EOL>observation_lp = lgssm.log_prob(observed_time_series, mask=mask)<EOL>sample_ndims = tf.maximum(<NUM_LIT:0>,<EOL>tf.rank(observation_lp) - tf.rank(param_lp))<EOL>observation_lp = tf.reduce_sum(<EOL>input_tensor=observation_lp, axis=tf.range(sample_ndims))<EOL>return param_lp + observation_lp<EOL><DEDENT><DEDENT>return log_joint_fn<EOL>", "docstring": "Build the joint density `log p(params) + log p(y|params)` as a callable.\n\n        Args:\n          observed_time_series: Observed `Tensor` trajectories of shape\n            `sample_shape + batch_shape + [num_timesteps, 1]` (the trailing\n            `1` dimension is optional if `num_timesteps > 1`), where\n            `batch_shape` should match `self.batch_shape` (the broadcast batch\n            shape of all priors on parameters for this structural time series\n            model). May optionally be an instance of `tfp.sts.MaskedTimeSeries`,\n            which includes a mask `Tensor` to specify timesteps with missing\n            observations.\n\n        Returns:\n         log_joint_fn: A function taking a `Tensor` argument for each model\n           parameter, in canonical order, and returning a `Tensor` log probability\n           of shape `batch_shape`. Note that, *unlike* `tfp.Distributions`\n           `log_prob` methods, the `log_joint` sums over the `sample_shape` from y,\n           so that `sample_shape` does not appear in the output log_prob. This\n           corresponds to viewing multiple samples in `y` as iid observations from a\n           single model, which is typically the desired behavior for parameter\n           inference.", "id": "f15502:c0:m9"}
{"signature": "def _decompose_from_posterior_marginals(<EOL>model, posterior_means, posterior_covs, parameter_samples):", "body": "try:<EOL><INDENT>model.components<EOL><DEDENT>except AttributeError:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>'.format(model))<EOL><DEDENT>with tf.compat.v1.name_scope('<STR_LIT>'):<EOL><INDENT>latent_sizes = [component.latent_size for component in model.components]<EOL>component_means = tf.split(posterior_means, latent_sizes, axis=-<NUM_LIT:1>)<EOL>component_covs = _split_covariance_into_marginals(<EOL>posterior_covs, latent_sizes)<EOL>num_timesteps = dist_util.prefer_static_value(<EOL>tf.shape(input=posterior_means))[-<NUM_LIT:2>]<EOL>component_ssms = model.make_component_state_space_models(<EOL>num_timesteps=num_timesteps,<EOL>param_vals=parameter_samples)<EOL>component_predictive_dists = collections.OrderedDict()<EOL>for (component, component_ssm,<EOL>component_mean, component_cov) in zip(model.components, component_ssms,<EOL>component_means, component_covs):<EOL><INDENT>component_obs_mean, component_obs_cov = (<EOL>component_ssm.latents_to_observations(<EOL>latent_means=component_mean,<EOL>latent_covs=component_cov))<EOL>component_predictive_dists[component] = sts_util.mix_over_posterior_draws(<EOL>means=component_obs_mean[..., <NUM_LIT:0>],<EOL>variances=component_obs_cov[..., <NUM_LIT:0>, <NUM_LIT:0>])<EOL><DEDENT><DEDENT>return component_predictive_dists<EOL>", "docstring": "Utility method to decompose a joint posterior into components.\n\n    Args:\n      model: `tfp.sts.Sum` instance defining an additive STS model.\n      posterior_means: float `Tensor` of shape `concat(\n        [[num_posterior_draws], batch_shape, num_timesteps, latent_size])`\n        representing the posterior mean over latents in an\n        `AdditiveStateSpaceModel`.\n      posterior_covs: float `Tensor` of shape `concat(\n        [[num_posterior_draws], batch_shape, num_timesteps,\n        latent_size, latent_size])`\n        representing the posterior marginal covariances over latents in an\n        `AdditiveStateSpaceModel`.\n      parameter_samples: Python `list` of `Tensors` representing posterior\n        samples of model parameters, with shapes `[concat([\n        [num_posterior_draws], param.prior.batch_shape,\n        param.prior.event_shape]) for param in model.parameters]`. This may\n        optionally also be a map (Python `dict`) of parameter names to\n        `Tensor` values.\n\n    Returns:\n      component_dists: A `collections.OrderedDict` instance mapping\n        component StructuralTimeSeries instances (elements of `model.components`)\n        to `tfd.Distribution` instances representing the posterior marginal\n        distributions on the process modeled by each component. Each distribution\n        has batch shape matching that of `posterior_means`/`posterior_covs`, and\n        event shape of `[num_timesteps]`.", "id": "f15504:m1"}
{"signature": "def __init__(self,<EOL>design_matrix,<EOL>drift_scale_prior=None,<EOL>initial_weights_prior=None,<EOL>observed_time_series=None,<EOL>name=None):", "body": "with tf.compat.v1.name_scope(<EOL>name, '<STR_LIT>', values=[observed_time_series]) as name:<EOL><INDENT>dtype = dtype_util.common_dtype(<EOL>[design_matrix, drift_scale_prior, initial_weights_prior])<EOL>num_features = prefer_static.shape(design_matrix)[-<NUM_LIT:1>]<EOL>if initial_weights_prior is None:<EOL><INDENT>initial_weights_prior = tfd.MultivariateNormalDiag(<EOL>scale_diag=<NUM_LIT> * tf.ones([num_features], dtype=dtype))<EOL><DEDENT>if drift_scale_prior is None:<EOL><INDENT>if observed_time_series is None:<EOL><INDENT>observed_stddev = tf.constant(<NUM_LIT:1.0>, dtype=dtype)<EOL><DEDENT>else:<EOL><INDENT>_, observed_stddev, _ = sts_util.empirical_statistics(<EOL>observed_time_series)<EOL><DEDENT>drift_scale_prior = tfd.LogNormal(<EOL>loc=tf.math.log(<NUM_LIT> * observed_stddev),<EOL>scale=<NUM_LIT>,<EOL>name='<STR_LIT>')<EOL><DEDENT>self._initial_state_prior = initial_weights_prior<EOL>self._design_matrix = design_matrix<EOL>super(DynamicLinearRegression, self).__init__(<EOL>parameters=[<EOL>Parameter('<STR_LIT>', drift_scale_prior, tfb.Softplus())<EOL>],<EOL>latent_size=num_features,<EOL>name=name)<EOL><DEDENT>", "docstring": "Specify a dynamic linear regression.\n\n        Args:\n          design_matrix: float `Tensor` of shape `concat([batch_shape,\n            [num_timesteps, num_features]])`.\n          drift_scale_prior: instance of `tfd.Distribution` specifying a prior on\n            the `drift_scale` parameter. If `None`, a heuristic default prior is\n            constructed based on the provided `observed_time_series`.\n            Default value: `None`.\n          initial_weights_prior: instance of `tfd.MultivariateNormal` representing\n            the prior distribution on the latent states (the regression weights).\n            Must have event shape `[num_features]`. If `None`, a weakly-informative\n            Normal(0., 10.) prior is used.\n            Default value: `None`.\n          observed_time_series: `float` `Tensor` of shape `batch_shape + [T, 1]`\n            (omitting the trailing unit dimension is also supported when `T > 1`),\n            specifying an observed time series. Any priors not explicitly set will\n            be given default values according to the scale of the observed time\n            series (or batch of time series). May optionally be an instance of\n            `tfp.sts.MaskedTimeSeries`, which includes a mask `Tensor` to specify\n            timesteps with missing observations.\n            Default value: `None`.\n          name: Python `str` for the name of this component.\n            Default value: 'DynamicLinearRegression'.", "id": "f15505:c1:m0"}
{"signature": "@property<EOL><INDENT>def observation_noise_scale(self):<DEDENT>", "body": "return self._observation_noise_scale<EOL>", "docstring": "Standard deviation of the observation noise.", "id": "f15505:c0:m2"}
{"signature": "@property<EOL><INDENT>def design_matrix(self):<DEDENT>", "body": "return self._design_matrix<EOL>", "docstring": "Tensor representing the design matrix.", "id": "f15505:c1:m2"}
{"signature": "def _build_placeholder(self, ndarray, dtype=None):", "body": "dtype = dtype if dtype is not None else self.dtype<EOL>ndarray = np.asarray(ndarray).astype(dtype)<EOL>return tf.compat.v1.placeholder_with_default(<EOL>input=ndarray, shape=ndarray.shape if self.use_static_shape else None)<EOL>", "docstring": "Convert a numpy array to a TF placeholder.\n\n        Args:\n          ndarray: any object convertible to a numpy array via `np.asarray()`.\n          dtype: numpy `dtype` of the returned placeholder. If `None`, uses\n            the default `self.dtype`.\n\n        Returns:\n          placeholder: a TensorFlow `placeholder` with default value given by the\n          provided `ndarray`, dtype given by `self.dtype`, and shape specified\n          statically only if `self.use_static_shape` is `True`.", "id": "f15506:c0:m12"}
{"signature": "def _broadcast_maybelist_arg(states, secondary_arg, name):", "body": "if _is_list_like(secondary_arg):<EOL><INDENT>if len(secondary_arg) != len(states):<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>'.format(name, len(states)))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>secondary_arg = [secondary_arg] * len(states)<EOL><DEDENT>return secondary_arg<EOL>", "docstring": "Broadcast a listable secondary_arg to that of states.", "id": "f15511:m7"}
{"signature": "def inverse_transform_fn(bijector):", "body": "if not mcmc_util.is_list_like(bijector):<EOL><INDENT>bijector = [bijector]<EOL><DEDENT>def fn(state_parts):<EOL><INDENT>return [b.inverse(sp)<EOL>for b, sp in zip(bijector, state_parts)]<EOL><DEDENT>return fn<EOL>", "docstring": "Makes a function which applies a list of Bijectors' `inverse`s.", "id": "f15515:m2"}
{"signature": "@property<EOL><INDENT>def parameters(self):<DEDENT>", "body": "return self._parameters<EOL>", "docstring": "Return `dict` of ``__init__`` arguments and their values.", "id": "f15515:c0:m4"}
{"signature": "def maybe_call_fn_and_grads(fn,<EOL>fn_arg_list,<EOL>result=None,<EOL>grads=None,<EOL>check_non_none_grads=True,<EOL>name=None):", "body": "with tf.compat.v1.name_scope(name, '<STR_LIT>',<EOL>[fn_arg_list, result, grads]):<EOL><INDENT>fn_arg_list = (list(fn_arg_list) if is_list_like(fn_arg_list)<EOL>else [fn_arg_list])<EOL>result, grads = _value_and_gradients(fn, fn_arg_list, result, grads)<EOL>if not all(r.dtype.is_floating<EOL>for r in (result if is_list_like(result) else [result])):  <EOL><INDENT>raise TypeError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>if len(fn_arg_list) != len(grads):<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>if check_non_none_grads and any(g is None for g in grads):<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(fn_arg_list, grads))<EOL><DEDENT>return result, grads<EOL><DEDENT>", "docstring": "Calls `fn` and computes the gradient of the result wrt `args_list`.", "id": "f15516:m8"}
{"signature": "def _value_and_gradients(fn, fn_arg_list, result=None, grads=None, name=None):", "body": "with tf.compat.v1.name_scope(name, '<STR_LIT>',<EOL>[fn_arg_list, result, grads]):<EOL><INDENT>def _convert_to_tensor(x, name):<EOL><INDENT>ctt = lambda x_: x_ if x_ is None else tf.convert_to_tensor(<EOL>value=x_, name=name)<EOL>return [ctt(x_) for x_ in x] if is_list_like(x) else ctt(x)<EOL><DEDENT>fn_arg_list = (list(fn_arg_list) if is_list_like(fn_arg_list)<EOL>else [fn_arg_list])<EOL>fn_arg_list = _convert_to_tensor(fn_arg_list, '<STR_LIT>')<EOL>if result is None:<EOL><INDENT>result = fn(*fn_arg_list)<EOL>if grads is None and tf.executing_eagerly():<EOL><INDENT>fn_arg_list = [<NUM_LIT:0> + x for x in fn_arg_list]<EOL><DEDENT><DEDENT>result = _convert_to_tensor(result, '<STR_LIT>')<EOL>if grads is not None:<EOL><INDENT>grads = _convert_to_tensor(grads, '<STR_LIT>')<EOL>return result, grads<EOL><DEDENT>if is_list_like(result) and len(result) == len(fn_arg_list):<EOL><INDENT>def fn_slice(i):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return lambda x: fn(*(fn_arg_list[:i] + [x] + fn_arg_list[i+<NUM_LIT:1>:]))<EOL><DEDENT>grads = [<EOL>tfp_math_value_and_gradients(fn_slice(i), fn_arg_list[i])[<NUM_LIT:1>]<EOL>for i in range(len(result))<EOL>]<EOL><DEDENT>else:<EOL><INDENT>_, grads = tfp_math_value_and_gradients(fn, fn_arg_list)<EOL><DEDENT>return result, grads<EOL><DEDENT>", "docstring": "Helper to `maybe_call_fn_and_grads`.", "id": "f15516:m7"}
{"signature": "def slice_sampler_one_dim(target_log_prob, x_initial, step_size=<NUM_LIT>,<EOL>max_doublings=<NUM_LIT:30>, seed=None, name=None):", "body": "with tf.compat.v1.name_scope(name, '<STR_LIT>',<EOL>[x_initial, step_size, max_doublings]):<EOL><INDENT>x_initial = tf.convert_to_tensor(value=x_initial)<EOL>dtype = x_initial.dtype.base_dtype<EOL>log_slice_heights = target_log_prob(x_initial) - tf.random.gamma(<EOL>tf.shape(input=x_initial), alpha=<NUM_LIT:1>, dtype=dtype, seed=seed)<EOL>upper_bounds, lower_bounds, bounds_satisfied = slice_bounds_by_doubling(<EOL>x_initial, target_log_prob, log_slice_heights, max_doublings, step_size,<EOL>seed=seed)<EOL>retval = _sample_with_shrinkage(x_initial, target_log_prob=target_log_prob,<EOL>log_slice_heights=log_slice_heights,<EOL>step_size=step_size,<EOL>lower_bounds=lower_bounds,<EOL>upper_bounds=upper_bounds, seed=seed)<EOL>return (retval, target_log_prob(retval), bounds_satisfied,<EOL>upper_bounds, lower_bounds)<EOL><DEDENT>", "docstring": "For a given x position in each Markov chain, returns the next x.\n\n    Applies the one dimensional slice sampling algorithm as defined in Neal (2003)\n    to an input tensor x of shape (num_chains,) where num_chains is the number of\n    simulataneous Markov chains, and returns the next tensor x of shape\n    (num_chains,) when these chains are evolved by the slice sampling algorithm.\n\n    Args:\n      target_log_prob: Callable accepting a tensor like `x_initial` and returning\n        a tensor containing the log density at that point of the same shape.\n      x_initial: A tensor of any shape. The initial positions of the chains. This\n        function assumes that all the dimensions of `x_initial` are batch\n        dimensions (i.e. the event shape is `[]`).\n      step_size: A tensor of shape and dtype compatible with `x_initial`. The min\n        interval size in the doubling algorithm.\n      max_doublings: Scalar tensor of dtype `tf.int32`. The maximum number of\n        doublings to try to find the slice bounds.\n      seed: (Optional) positive int. The random seed. If None, no seed is set.\n      name: Python `str` name prefixed to Ops created by this function.\n        Default value: `None` (i.e., 'find_slice_bounds').\n\n    Returns:\n      retval: A tensor of the same shape and dtype as `x_initial`. The next state\n        of the Markov chain.\n      next_target_log_prob: The target log density evaluated at `retval`.\n      bounds_satisfied: A tensor of bool dtype and shape batch dimensions.\n      upper_bounds: Tensor of the same shape and dtype as `x_initial`. The upper\n        bounds for the slice found.\n      lower_bounds: Tensor of the same shape and dtype as `x_initial`. The lower\n        bounds for the slice found.", "id": "f15518:m5"}
{"signature": "def mvn(*args, **kwargs):", "body": "<EOL>return tfd.Independent(tfd.Normal(*args, **kwargs),<EOL>reinterpreted_batch_ndims=<NUM_LIT:1>)<EOL>", "docstring": "Convenience function to efficiently construct a MultivariateNormalDiag.", "id": "f15520:m0"}
{"signature": "def benchmark_eight_schools_hmc(<EOL>num_results=int(<NUM_LIT>),<EOL>num_burnin_steps=int(<NUM_LIT>),<EOL>num_leapfrog_steps=<NUM_LIT:3>,<EOL>step_size=<NUM_LIT>):", "body": "num_schools = <NUM_LIT:8><EOL>treatment_effects = tf.constant(<EOL>[<NUM_LIT>, <NUM_LIT:8>, -<NUM_LIT:3>, <NUM_LIT:7>, -<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT>, <NUM_LIT:12>],<EOL>dtype=np.float32,<EOL>name='<STR_LIT>')<EOL>treatment_stddevs = tf.constant(<EOL>[<NUM_LIT:15>, <NUM_LIT:10>, <NUM_LIT:16>, <NUM_LIT:11>, <NUM_LIT:9>, <NUM_LIT:11>, <NUM_LIT:10>, <NUM_LIT>],<EOL>dtype=np.float32,<EOL>name='<STR_LIT>')<EOL>def unnormalized_posterior_log_prob(<EOL>avg_effect, avg_stddev, school_effects_standard):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return eight_schools_joint_log_prob(<EOL>treatment_effects, treatment_stddevs,<EOL>avg_effect, avg_stddev, school_effects_standard)<EOL><DEDENT>if tf.executing_eagerly():<EOL><INDENT>sample_chain = tf.function(tfp.mcmc.sample_chain)<EOL><DEDENT>else:<EOL><INDENT>sample_chain = tfp.mcmc.sample_chain<EOL><DEDENT>def computation():<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>_, kernel_results = sample_chain(<EOL>num_results=num_results,<EOL>num_burnin_steps=num_burnin_steps,<EOL>current_state=(<EOL>tf.zeros([], name='<STR_LIT>'),<EOL>tf.zeros([], name='<STR_LIT>'),<EOL>tf.ones([num_schools], name='<STR_LIT>'),<EOL>),<EOL>kernel=tfp.mcmc.HamiltonianMonteCarlo(<EOL>target_log_prob_fn=unnormalized_posterior_log_prob,<EOL>step_size=step_size,<EOL>num_leapfrog_steps=num_leapfrog_steps))<EOL>return kernel_results.is_accepted<EOL><DEDENT>is_accepted_tensor = computation()<EOL>if not tf.executing_eagerly():<EOL><INDENT>session = tf.compat.v1.Session()<EOL>session.run(is_accepted_tensor)<EOL><DEDENT>start_time = time.time()<EOL>if tf.executing_eagerly():<EOL><INDENT>is_accepted = computation()<EOL><DEDENT>else:<EOL><INDENT>is_accepted = session.run(is_accepted_tensor)<EOL><DEDENT>wall_time = time.time() - start_time<EOL>num_accepted = np.sum(is_accepted)<EOL>acceptance_rate = np.float32(num_accepted) / np.float32(num_results)<EOL>return dict(<EOL>iters=(num_results + num_burnin_steps) * num_leapfrog_steps,<EOL>extras={'<STR_LIT>': acceptance_rate},<EOL>wall_time=wall_time)<EOL>", "docstring": "Runs HMC on the eight-schools unnormalized posterior.", "id": "f15520:m2"}
{"signature": "def _log_gamma_log_prob(self, x, event_dims=()):", "body": "return tf.reduce_sum(<EOL>input_tensor=self._shape_param * x - self._rate_param * tf.exp(x),<EOL>axis=event_dims)<EOL>", "docstring": "Computes unnormalized log-pdf of a log-gamma random variable.\n\n        Args:\n          x: Value of the random variable.\n          event_dims: Dimensions not to treat as independent.\n\n        Returns:\n          log_prob: The log-pdf up to a normalizing constant.", "id": "f15521:c0:m1"}
{"signature": "def _ais_gets_correct_log_normalizer_wrapper(self, independent_chain_ndims):", "body": "initial_draws = np.random.normal(size=[<NUM_LIT:30>, <NUM_LIT:2>, <NUM_LIT:1>])<EOL>x_ph = tf.compat.v1.placeholder_with_default(<EOL>np.float32(initial_draws), shape=initial_draws.shape, name='<STR_LIT>')<EOL>self._ais_gets_correct_log_normalizer(x_ph, independent_chain_ndims)<EOL>", "docstring": "Tests that AIS yields reasonable estimates of normalizers.", "id": "f15521:c0:m3"}
{"signature": "def _euler_method(random_draw_parts,<EOL>state_parts,<EOL>drift_parts,<EOL>step_size_parts,<EOL>volatility_parts,<EOL>name=None):", "body": "with tf.compat.v1.name_scope(name, '<STR_LIT>', [<EOL>random_draw_parts, state_parts, drift_parts, step_size_parts,<EOL>volatility_parts<EOL>]):<EOL><INDENT>proposed_state_parts = []<EOL>for random_draw, state, drift, step_size, volatility in zip(<EOL>random_draw_parts,<EOL>state_parts,<EOL>drift_parts,<EOL>step_size_parts,<EOL>volatility_parts):<EOL><INDENT>proposal = state + drift + volatility * tf.sqrt(step_size) * random_draw<EOL>proposed_state_parts.append(proposal)<EOL><DEDENT>return proposed_state_parts<EOL><DEDENT>", "docstring": "Applies one step of Euler-Maruyama method.\n\n    Generates proposal of the form:\n\n    ```python\n    tfd.Normal(loc=state_parts + _get_drift(state_parts, ...),\n               scale=tf.sqrt(step_size * volatility_fn(current_state)))\n    ```\n\n    `_get_drift(state_parts, ..)` is a diffusion drift value at `state_parts`.\n\n\n    Args:\n      random_draw_parts: Python `list` of `Tensor`s containing the value(s) of the\n        random perturbation variable(s). Must broadcast with the shape of\n        `state_parts`.\n      state_parts: Python `list` of `Tensor`s representing the current\n        state(s) of the Markov chain(s).\n      drift_parts: Python `list` of `Tensor`s representing value of the drift\n        `_get_drift(*state_parts, ..)`. Must broadcast with the shape of\n        `state_parts`.\n      step_size_parts: Python `list` of `Tensor`s representing the step size for\n        the Euler-Maruyama method. Must broadcast with the shape of\n        `state_parts`.  Larger step sizes lead to faster progress, but\n        too-large step sizes make rejection exponentially more likely. When\n        possible, it's often helpful to match per-variable step sizes to the\n        standard deviations of the target distribution in each variable.\n      volatility_parts: Python `list` of `Tensor`s representing the value of\n        `volatility_fn(*state_parts)`. Must broadcast with the shape of\n        `state_parts`.\n      name: Python `str` name prefixed to Ops created by this function.\n        Default value: `None` (i.e., 'mala_euler_method').\n\n    Returns:\n      proposed_state_parts: Tensor or Python list of `Tensor`s representing the\n        state(s) of the Markov chain(s) at each result step. Has same shape as\n        input `current_state_parts`.", "id": "f15524:m0"}
{"signature": "@property<EOL><INDENT>def parameters(self):<DEDENT>", "body": "return self._parameters<EOL>", "docstring": "Return `dict` of ``__init__`` arguments and their values.", "id": "f15524:c0:m7"}
{"signature": "def bootstrap_results(self, init_state):", "body": "return self._impl.bootstrap_results(init_state)<EOL>", "docstring": "Creates initial `previous_kernel_results` using a supplied `state`.", "id": "f15524:c0:m10"}
{"signature": "@abc.abstractproperty<EOL><INDENT>def is_calibrated(self):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "Returns `True` if Markov chain converges to specified distribution.\n\n        `TransitionKernel`s which are \"uncalibrated\" are often calibrated by\n        composing them with the `tfp.mcmc.MetropolisHastings` `TransitionKernel`.", "id": "f15525:c0:m1"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def one_step(self, current_state, previous_kernel_results):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "Takes one step of the TransitionKernel.\n\n        Must be overridden by subclasses.\n\n        Args:\n          current_state: `Tensor` or Python `list` of `Tensor`s representing the\n            current state(s) of the Markov chain(s).\n          previous_kernel_results: A (possibly nested) `tuple`, `namedtuple` or\n            `list` of `Tensor`s representing internal calculations made within the\n            previous call to this function (or as returned by `bootstrap_results`).\n\n        Returns:\n          next_state: `Tensor` or Python `list` of `Tensor`s representing the\n            next state(s) of the Markov chain(s).\n          kernel_results: A (possibly nested) `tuple`, `namedtuple` or `list` of\n            `Tensor`s representing internal calculations made within this function.", "id": "f15525:c0:m0"}
{"signature": "def _set_seed(seed):", "body": "<EOL>if tf.executing_eagerly():<EOL><INDENT>return None<EOL><DEDENT>return seed<EOL>", "docstring": "Helper which uses graph seed if using TFE.", "id": "f15527:m0"}
{"signature": "def mvn(*args, **kwargs):", "body": "<EOL>return tfd.Independent(tfd.Normal(*args, **kwargs),<EOL>reinterpreted_batch_ndims=<NUM_LIT:1>)<EOL>", "docstring": "Convenience function to efficiently construct a MultivariateNormalDiag.", "id": "f15530:m0"}
{"signature": "def benchmark_text_messages_hmc(<EOL>num_results=int(<NUM_LIT>),<EOL>num_burnin_steps=int(<NUM_LIT>),<EOL>num_leapfrog_steps=<NUM_LIT:3>):", "body": "if not tf.executing_eagerly():<EOL><INDENT>tf.compat.v1.reset_default_graph()<EOL><DEDENT>count_data = tf.cast(<EOL>tf.concat(<EOL>[tfd.Poisson(rate=<NUM_LIT>).sample(<NUM_LIT>),<EOL>tfd.Poisson(rate=<NUM_LIT>).sample(<NUM_LIT>)],<EOL>axis=<NUM_LIT:0>),<EOL>dtype=tf.float32)<EOL>if tf.executing_eagerly():<EOL><INDENT>count_data = count_data.numpy()<EOL><DEDENT>else:<EOL><INDENT>with tf.compat.v1.Session():<EOL><INDENT>count_data = count_data.eval()<EOL><DEDENT><DEDENT>def unnormalized_log_posterior(lambda1, lambda2, tau):<EOL><INDENT>return text_messages_joint_log_prob(count_data, lambda1, lambda2, tau)<EOL><DEDENT>if tf.executing_eagerly():<EOL><INDENT>sample_chain = tf.function(tfp.mcmc.sample_chain)<EOL><DEDENT>else:<EOL><INDENT>sample_chain = tfp.mcmc.sample_chain<EOL><DEDENT>step_size = tf.compat.v2.Variable(<EOL>name='<STR_LIT>',<EOL>initial_value=tf.constant(<NUM_LIT>, dtype=tf.float32),<EOL>trainable=False)<EOL>def computation():<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>initial_chain_state = [<EOL>tf.constant(count_data.mean(), name='<STR_LIT>'),<EOL>tf.constant(count_data.mean(), name='<STR_LIT>'),<EOL>tf.constant(<NUM_LIT:0.5>, name='<STR_LIT>'),<EOL>]<EOL>unconstraining_bijectors = [<EOL>tfp.bijectors.Exp(),       <EOL>tfp.bijectors.Exp(),       <EOL>tfp.bijectors.Sigmoid(),   <EOL>]<EOL>_, kernel_results = sample_chain(<EOL>num_results=num_results,<EOL>num_burnin_steps=num_burnin_steps,<EOL>current_state=initial_chain_state,<EOL>kernel=tfp.mcmc.TransformedTransitionKernel(<EOL>inner_kernel=tfp.mcmc.HamiltonianMonteCarlo(<EOL>target_log_prob_fn=unnormalized_log_posterior,<EOL>num_leapfrog_steps=num_leapfrog_steps,<EOL>step_size=step_size,<EOL>step_size_update_fn=<EOL>tfp.mcmc.make_simple_step_size_update_policy(num_burnin_steps),<EOL>state_gradients_are_stopped=True),<EOL>bijector=unconstraining_bijectors))<EOL>return kernel_results.inner_results.is_accepted<EOL><DEDENT>is_accepted_tensor = computation()<EOL>if not tf.executing_eagerly():<EOL><INDENT>session = tf.compat.v1.Session()<EOL>session.run(tf.compat.v1.global_variables_initializer())<EOL>session.run(is_accepted_tensor)<EOL><DEDENT>start_time = time.time()<EOL>if tf.executing_eagerly():<EOL><INDENT>is_accepted = computation()<EOL><DEDENT>else:<EOL><INDENT>is_accepted = session.run(is_accepted_tensor)<EOL><DEDENT>wall_time = time.time() - start_time<EOL>num_accepted = np.sum(is_accepted)<EOL>acceptance_rate = np.float32(num_accepted) / np.float32(num_results)<EOL>return dict(<EOL>iters=(num_results + num_burnin_steps) * num_leapfrog_steps,<EOL>extras={'<STR_LIT>': acceptance_rate},<EOL>wall_time=wall_time)<EOL>", "docstring": "Runs HMC on the text-messages unnormalized posterior.", "id": "f15530:m2"}
{"signature": "def text_messages_joint_log_prob(count_data, lambda_1, lambda_2, tau):", "body": "alpha = (<NUM_LIT:1.> / tf.reduce_mean(input_tensor=count_data))<EOL>rv_lambda = tfd.Exponential(rate=alpha)<EOL>rv_tau = tfd.Uniform()<EOL>lambda_ = tf.gather(<EOL>[lambda_1, lambda_2],<EOL>indices=tf.cast(<EOL>tau * tf.cast(tf.size(input=count_data), dtype=tf.float32) <= tf.cast(<EOL>tf.range(tf.size(input=count_data)), dtype=tf.float32),<EOL>dtype=tf.int32))<EOL>rv_observation = tfd.Poisson(rate=lambda_)<EOL>return (rv_lambda.log_prob(lambda_1) + rv_lambda.log_prob(lambda_2) +<EOL>rv_tau.log_prob(tau) +<EOL>tf.reduce_sum(input_tensor=rv_observation.log_prob(count_data)))<EOL>", "docstring": "Joint log probability function.", "id": "f15530:m1"}
{"signature": "def iid_normal_chains_should_pass_wrapper(self,<EOL>sample_shape,<EOL>independent_chain_shape,<EOL>other_shape,<EOL>dtype=np.float32):", "body": "state_shape = sample_shape + independent_chain_shape + other_shape<EOL>state_ = rng.randn(*state_shape).astype(dtype)<EOL>if other_shape:<EOL><INDENT>state_ *= rng.rand(*other_shape).astype(dtype)<EOL><DEDENT>self.check_results(state_, independent_chain_shape, should_pass=True)<EOL>", "docstring": "Check results with iid normal chains.", "id": "f15531:c3:m3"}
{"signature": "@property<EOL><INDENT>def parameters(self):<DEDENT>", "body": "return self._parameters<EOL>", "docstring": "Return `dict` of ``__init__`` arguments and their values.", "id": "f15535:c0:m7"}
{"signature": "def _get_exchanged_states(self, old_states, exchange_proposed,<EOL>exchange_proposed_n, sampled_replica_states,<EOL>sampled_replica_results):", "body": "with tf.compat.v1.name_scope('<STR_LIT>'):<EOL><INDENT>target_log_probs = []<EOL>for replica in range(self.num_replica):<EOL><INDENT>replica_log_prob = _get_field(sampled_replica_results[replica],<EOL>'<STR_LIT>')<EOL>inverse_temp = self.inverse_temperatures[replica]<EOL>target_log_probs.append(replica_log_prob / inverse_temp)<EOL><DEDENT>target_log_probs = tf.stack(target_log_probs, axis=<NUM_LIT:0>)<EOL>dtype = target_log_probs.dtype<EOL>num_state_parts = len(sampled_replica_states[<NUM_LIT:0>])<EOL>exchanged_states = [<EOL>tf.TensorArray(<EOL>dtype,<EOL>size=self.num_replica,<EOL>dynamic_size=False,<EOL>tensor_array_name='<STR_LIT>',<EOL>element_shape=sampled_replica_states[<NUM_LIT:0>][k].shape)<EOL>for k in range(num_state_parts)<EOL>]<EOL>sample_shape = tf.concat(<EOL>([self.num_replica // <NUM_LIT:2>], tf.shape(input=target_log_probs)[<NUM_LIT:1>:]),<EOL>axis=<NUM_LIT:0>)<EOL>log_uniforms = tf.math.log(<EOL>tf.random.uniform(<EOL>shape=sample_shape, dtype=dtype, seed=self._seed_stream()))<EOL>def _swap(is_exchange_accepted, x, y):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>with tf.compat.v1.name_scope('<STR_LIT>'):<EOL><INDENT>new_x = mcmc_util.choose(is_exchange_accepted, y, x)<EOL>new_y = mcmc_util.choose(is_exchange_accepted, x, y)<EOL><DEDENT>return new_x, new_y<EOL><DEDENT>def cond(i, unused_exchanged_states):<EOL><INDENT>return i < exchange_proposed_n<EOL><DEDENT>def body(i, exchanged_states):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>m, n = tf.unstack(exchange_proposed[i])<EOL>temp_diff = self.inverse_temperatures[m] - self.inverse_temperatures[n]<EOL>log_accept_ratio = mcmc_util.safe_sum(<EOL>[-temp_diff * target_log_probs[m], temp_diff * target_log_probs[n]])<EOL>is_exchange_accepted = log_uniforms[i] < log_accept_ratio<EOL>for k in range(num_state_parts):<EOL><INDENT>new_m, new_n = _swap(is_exchange_accepted, old_states[k].read(m),<EOL>old_states[k].read(n))<EOL>exchanged_states[k] = exchanged_states[k].write(m, new_m)<EOL>exchanged_states[k] = exchanged_states[k].write(n, new_n)<EOL><DEDENT>return i + <NUM_LIT:1>, exchanged_states<EOL><DEDENT>return tf.while_loop(<EOL>cond=cond, body=body, loop_vars=[tf.constant(<NUM_LIT:0>),<EOL>exchanged_states])[<NUM_LIT:1>]<EOL><DEDENT>", "docstring": "Get list of TensorArrays holding exchanged states, and zeros.", "id": "f15535:c0:m10"}
{"signature": "def one_step(self, current_state, previous_kernel_results):", "body": "<EOL>with tf.compat.v1.name_scope(<EOL>name=mcmc_util.make_name(self.name, '<STR_LIT>', '<STR_LIT>'),<EOL>values=[current_state, previous_kernel_results]):<EOL><INDENT>sampled_replica_states, sampled_replica_results = zip(*[<EOL>rk.one_step(previous_kernel_results.replica_states[i],<EOL>previous_kernel_results.replica_results[i])<EOL>for i, rk in enumerate(self.replica_kernels)<EOL>])<EOL>sampled_replica_states = list(sampled_replica_states)<EOL>sampled_replica_results = list(sampled_replica_results)<EOL>states_are_lists = mcmc_util.is_list_like(sampled_replica_states[<NUM_LIT:0>])<EOL>if not states_are_lists:<EOL><INDENT>sampled_replica_states = [[s] for s in sampled_replica_states]<EOL><DEDENT>num_state_parts = len(sampled_replica_states[<NUM_LIT:0>])<EOL>dtype = sampled_replica_states[<NUM_LIT:0>][<NUM_LIT:0>].dtype<EOL>old_states = [<EOL>tf.TensorArray(<EOL>dtype,<EOL>size=self.num_replica,<EOL>dynamic_size=False,<EOL>clear_after_read=False,<EOL>tensor_array_name='<STR_LIT>',<EOL>element_shape=sampled_replica_states[<NUM_LIT:0>][k].shape)<EOL>for k in range(num_state_parts)<EOL>]<EOL>for k in range(num_state_parts):<EOL><INDENT>for i in range(self.num_replica):<EOL><INDENT>old_states[k] = old_states[k].write(i, sampled_replica_states[i][k])<EOL><DEDENT><DEDENT>exchange_proposed = self.exchange_proposed_fn(<EOL>self.num_replica, seed=self._seed_stream())<EOL>exchange_proposed_n = tf.shape(input=exchange_proposed)[<NUM_LIT:0>]<EOL>exchanged_states = self._get_exchanged_states(<EOL>old_states, exchange_proposed, exchange_proposed_n,<EOL>sampled_replica_states, sampled_replica_results)<EOL>no_exchange_proposed, _ = tf.compat.v1.setdiff1d(<EOL>tf.range(self.num_replica), tf.reshape(exchange_proposed, [-<NUM_LIT:1>]))<EOL>exchanged_states = self._insert_old_states_where_no_exchange_was_proposed(<EOL>no_exchange_proposed, old_states, exchanged_states)<EOL>next_replica_states = []<EOL>for i in range(self.num_replica):<EOL><INDENT>next_replica_states_i = []<EOL>for k in range(num_state_parts):<EOL><INDENT>next_replica_states_i.append(exchanged_states[k].read(i))<EOL><DEDENT>next_replica_states.append(next_replica_states_i)<EOL><DEDENT>if not states_are_lists:<EOL><INDENT>next_replica_states = [s[<NUM_LIT:0>] for s in next_replica_states]<EOL>sampled_replica_states = [s[<NUM_LIT:0>] for s in sampled_replica_states]<EOL><DEDENT>next_replica_results = [<EOL>rk.bootstrap_results(state)<EOL>for rk, state in zip(self.replica_kernels, next_replica_states)<EOL>]<EOL>next_state = next_replica_states[<NUM_LIT:0>]  <EOL>kernel_results = ReplicaExchangeMCKernelResults(<EOL>replica_states=next_replica_states,<EOL>replica_results=next_replica_results,<EOL>sampled_replica_states=sampled_replica_states,<EOL>sampled_replica_results=sampled_replica_results,<EOL>)<EOL>return next_state, kernel_results<EOL><DEDENT>", "docstring": "Takes one step of the TransitionKernel.\n\n        Args:\n          current_state: `Tensor` or Python `list` of `Tensor`s representing the\n            current state(s) of the Markov chain(s).\n          previous_kernel_results: A (possibly nested) `tuple`, `namedtuple` or\n            `list` of `Tensor`s representing internal calculations made within the\n            previous call to this function (or as returned by `bootstrap_results`).\n\n        Returns:\n          next_state: `Tensor` or Python `list` of `Tensor`s representing the\n            next state(s) of the Markov chain(s).\n          kernel_results: A (possibly nested) `tuple`, `namedtuple` or `list` of\n            `Tensor`s representing internal calculations made within this function.\n            This inculdes replica states.", "id": "f15535:c0:m9"}
{"signature": "def _replica_log_prob_fn(inverse_temperature, target_log_prob_fn):", "body": "def _replica_log_prob_fn_(*x):<EOL><INDENT>return inverse_temperature * target_log_prob_fn(*x)<EOL><DEDENT>return _replica_log_prob_fn_<EOL>", "docstring": "Return a log probability function made considering temperature.", "id": "f15535:m1"}
{"signature": "@property<EOL><INDENT>def num_leapfrog_steps(self):<DEDENT>", "body": "return self._parameters['<STR_LIT>']<EOL>", "docstring": "Returns the num_leapfrog_steps parameter.\n\n        If `store_parameters_in_results` argument to the initializer was set to\n        `True`, this only returns the value of the `num_leapfrog_steps` placed in\n        the kernel results by the `bootstrap_results` method. The actual\n        `num_leapfrog_steps` in that situation is governed by the\n        `previous_kernel_results` argument to `one_step` method.\n\n        Returns:\n          num_leapfrog_steps: An integer `Tensor`.", "id": "f15536:c1:m3"}
{"signature": "@property<EOL><INDENT>def parameters(self):<DEDENT>", "body": "return self._parameters<EOL>", "docstring": "Return `dict` of ``__init__`` arguments and their values.", "id": "f15537:c0:m4"}
{"signature": "def __init__(self,<EOL>inner_kernel,<EOL>num_adaptation_steps,<EOL>target_accept_prob=<NUM_LIT>,<EOL>adaptation_rate=<NUM_LIT>,<EOL>step_size_setter_fn=_hmc_like_step_size_setter_fn,<EOL>step_size_getter_fn=_hmc_like_step_size_getter_fn,<EOL>log_accept_prob_getter_fn=_hmc_like_log_accept_prob_getter_fn,<EOL>validate_args=False,<EOL>name=None):", "body": "inner_kernel = mcmc_util.enable_store_parameters_in_results(inner_kernel)<EOL>with tf.compat.v1.name_scope(<EOL>mcmc_util.make_name(name, '<STR_LIT>', '<STR_LIT>'),<EOL>values=[target_accept_prob, adaptation_rate,<EOL>num_adaptation_steps]) as name:<EOL><INDENT>dtype = dtype_util.common_dtype([target_accept_prob, adaptation_rate],<EOL>tf.float32)<EOL>target_accept_prob = tf.convert_to_tensor(<EOL>value=target_accept_prob, dtype=dtype, name='<STR_LIT>')<EOL>adaptation_rate = tf.convert_to_tensor(<EOL>value=adaptation_rate, dtype=dtype, name='<STR_LIT>')<EOL>num_adaptation_steps = tf.convert_to_tensor(<EOL>value=num_adaptation_steps,<EOL>dtype=tf.int32,<EOL>name='<STR_LIT>')<EOL>target_accept_prob = _maybe_validate_target_accept_prob(<EOL>target_accept_prob, validate_args)<EOL><DEDENT>self._parameters = dict(<EOL>inner_kernel=inner_kernel,<EOL>num_adaptation_steps=num_adaptation_steps,<EOL>target_accept_prob=target_accept_prob,<EOL>adaptation_rate=adaptation_rate,<EOL>step_size_setter_fn=step_size_setter_fn,<EOL>step_size_getter_fn=step_size_getter_fn,<EOL>log_accept_prob_getter_fn=log_accept_prob_getter_fn,<EOL>name=name,<EOL>)<EOL>", "docstring": "Creates the step size adaptation kernel.\n\n        The default setter_fn and the getter_fn callbacks assume that the inner\n        kernel produces kernel results structurally the same as the\n        `HamiltonianMonteCarlo` kernel.\n\n        Args:\n          inner_kernel: `TransitionKernel`-like object.\n          num_adaptation_steps: Scalar `int` `Tensor` number of initial steps to\n            during which to adjust the step size. This may be greater, less than, or\n            equal to the number of burnin steps.\n          target_accept_prob: A floating point `Tensor` representing desired\n            acceptance probability. Must be a positive number less than 1. This can\n            either be a scalar, or have shape [num_chains]. Default value: `0.75`\n            (the [center of asymptotically optimal rate for HMC][1]).\n          adaptation_rate: `Tensor` representing amount to scale the current\n            `step_size`.\n          step_size_setter_fn: A callable with the signature\n            `(kernel_results, new_step_size) -> new_kernel_results` where\n            `kernel_results` are the results of the `inner_kernel`, `new_step_size`\n            is a `Tensor` or a nested collection of `Tensor`s with the same\n            structure as returned by the `step_size_getter_fn`, and\n            `new_kernel_results` are a copy of `kernel_results` with the step\n            size(s) set.\n          step_size_getter_fn: A callable with the signature\n            `(kernel_results) -> step_size` where `kernel_results` are the results\n            of the `inner_kernel`, and `step_size` is a floating point `Tensor` or a\n            nested collection of such `Tensor`s.\n          log_accept_prob_getter_fn: A callable with the signature\n            `(kernel_results) -> log_accept_prob` where `kernel_results` are the\n            results of the `inner_kernel`, and `log_accept_prob` is a floating point\n            `Tensor`. `log_accept_prob` can either be a scalar, or have shape\n            [num_chains]. If it's the latter, `step_size` should also have the same\n            leading dimension.\n          validate_args: Python `bool`. When `True` kernel parameters are checked\n            for validity. When `False` invalid inputs may silently render incorrect\n            outputs.\n          name: Python `str` name prefixed to Ops created by this class. Default:\n            'simple_step_size_adaptation'.\n\n        #### References\n\n        [1]: Betancourt, M. J., Byrne, S., & Girolami, M. (2014). _Optimizing The\n             Integrator Step Size for Hamiltonian Monte Carlo_.\n             http://arxiv.org/abs/1411.6669", "id": "f15540:c1:m0"}
{"signature": "@property<EOL><INDENT>def parameters(self):<DEDENT>", "body": "return self._impl.inner_kernel.parameters<EOL>", "docstring": "Return `dict` of ``__init__`` arguments and their values.", "id": "f15544:c0:m6"}
{"signature": "def _prepare_args(target_log_prob_fn, state, step_size,<EOL>target_log_prob=None, maybe_expand=False,<EOL>description='<STR_LIT>'):", "body": "state_parts = list(state) if mcmc_util.is_list_like(state) else [state]<EOL>state_parts = [<EOL>tf.convert_to_tensor(value=s, name='<STR_LIT>') for s in state_parts<EOL>]<EOL>target_log_prob = _maybe_call_fn(<EOL>target_log_prob_fn,<EOL>state_parts,<EOL>target_log_prob,<EOL>description)<EOL>step_sizes = (list(step_size) if mcmc_util.is_list_like(step_size)<EOL>else [step_size])<EOL>step_sizes = [<EOL>tf.convert_to_tensor(<EOL>value=s, name='<STR_LIT>', dtype=target_log_prob.dtype)<EOL>for s in step_sizes<EOL>]<EOL>if len(step_sizes) == <NUM_LIT:1>:<EOL><INDENT>step_sizes *= len(state_parts)<EOL><DEDENT>if len(state_parts) != len(step_sizes):<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>def maybe_flatten(x):<EOL><INDENT>return x if maybe_expand or mcmc_util.is_list_like(state) else x[<NUM_LIT:0>]<EOL><DEDENT>return [<EOL>maybe_flatten(state_parts),<EOL>maybe_flatten(step_sizes),<EOL>target_log_prob<EOL>]<EOL>", "docstring": "Processes input args to meet list-like assumptions.", "id": "f15545:m4"}
{"signature": "def __init__(self,<EOL>target_log_prob_fn,<EOL>step_size,<EOL>max_doublings,<EOL>seed=None,<EOL>name=None):", "body": "self._seed_stream = distributions.SeedStream(<EOL>seed, salt='<STR_LIT>')<EOL>self._parameters = dict(<EOL>target_log_prob_fn=target_log_prob_fn,<EOL>step_size=step_size,<EOL>max_doublings=max_doublings,<EOL>seed=seed,<EOL>name=name)<EOL>", "docstring": "Initializes this transition kernel.\n\n        Args:\n          target_log_prob_fn: Python callable which takes an argument like\n            `current_state` (or `*current_state` if it is a list) and returns its\n            (possibly unnormalized) log-density under the target distribution.\n          step_size: Scalar or `tf.Tensor` with same dtype as and shape compatible\n            with `x_initial`. The size of the initial interval.\n          max_doublings: Scalar positive int32 `tf.Tensor`. The maximum number of\n          doublings to consider.\n          seed: Python integer to seed the random number generator.\n          name: Python `str` name prefixed to Ops created by this function.\n            Default value: `None` (i.e., 'slice_sampler_kernel').\n\n        Returns:\n          next_state: Tensor or Python list of `Tensor`s representing the state(s)\n            of the Markov chain(s) at each result step. Has same shape as\n            `current_state`.\n          kernel_results: `collections.namedtuple` of internal calculations used to\n            advance the chain.", "id": "f15545:c0:m0"}
{"signature": "def one_step(self, current_state, previous_kernel_results):", "body": "with tf.compat.v1.name_scope(<EOL>name=mcmc_util.make_name(self.name, '<STR_LIT>', '<STR_LIT>'),<EOL>values=[<EOL>self.step_size, self.max_doublings, self._seed_stream,<EOL>current_state, previous_kernel_results.target_log_prob<EOL>]):<EOL><INDENT>with tf.compat.v1.name_scope('<STR_LIT>'):<EOL><INDENT>[<EOL>current_state_parts,<EOL>step_sizes,<EOL>current_target_log_prob<EOL>] = _prepare_args(<EOL>self.target_log_prob_fn,<EOL>current_state,<EOL>self.step_size,<EOL>previous_kernel_results.target_log_prob,<EOL>maybe_expand=True)<EOL>max_doublings = tf.convert_to_tensor(<EOL>value=self.max_doublings, dtype=tf.int32, name='<STR_LIT>')<EOL><DEDENT>independent_chain_ndims = distribution_util.prefer_static_rank(<EOL>current_target_log_prob)<EOL>[<EOL>next_state_parts,<EOL>next_target_log_prob,<EOL>bounds_satisfied,<EOL>direction,<EOL>upper_bounds,<EOL>lower_bounds<EOL>] = _sample_next(<EOL>self.target_log_prob_fn,<EOL>current_state_parts,<EOL>step_sizes,<EOL>max_doublings,<EOL>current_target_log_prob,<EOL>independent_chain_ndims,<EOL>seed=self._seed_stream()<EOL>)<EOL>def maybe_flatten(x):<EOL><INDENT>return x if mcmc_util.is_list_like(current_state) else x[<NUM_LIT:0>]<EOL><DEDENT>return [<EOL>maybe_flatten(next_state_parts),<EOL>SliceSamplerKernelResults(<EOL>target_log_prob=next_target_log_prob,<EOL>bounds_satisfied=bounds_satisfied,<EOL>direction=direction,<EOL>upper_bounds=upper_bounds,<EOL>lower_bounds=lower_bounds<EOL>),<EOL>]<EOL><DEDENT>", "docstring": "Runs one iteration of Slice Sampler.\n\n        Args:\n          current_state: `Tensor` or Python `list` of `Tensor`s representing the\n            current state(s) of the Markov chain(s). The first `r` dimensions\n            index independent chains,\n            `r = tf.rank(target_log_prob_fn(*current_state))`.\n          previous_kernel_results: `collections.namedtuple` containing `Tensor`s\n            representing values from previous calls to this function (or from the\n            `bootstrap_results` function.)\n\n        Returns:\n          next_state: Tensor or Python list of `Tensor`s representing the state(s)\n            of the Markov chain(s) after taking exactly one step. Has same type and\n            shape as `current_state`.\n          kernel_results: `collections.namedtuple` of internal calculations used to\n            advance the chain.\n\n        Raises:\n          ValueError: if there isn't one `step_size` or a list with same length as\n            `current_state`.\n          TypeError: if `not target_log_prob.dtype.is_floating`.", "id": "f15545:c0:m8"}
{"signature": "def tridiag(d, diag_value, offdiag_value):", "body": "diag_mat = tf.eye(d) * (diag_value - offdiag_value)<EOL>three_bands = tf.linalg.band_part(tf.fill([d, d], offdiag_value), <NUM_LIT:1>, <NUM_LIT:1>)<EOL>return diag_mat + three_bands<EOL>", "docstring": "d x d matrix with given value on diag, and one super/sub diag.", "id": "f15546:m0"}
{"signature": "def _csiszar_vimco_helper(self, logu):", "body": "<EOL>logu = np.float128(logu)<EOL>n = logu.shape[<NUM_LIT:0>]<EOL>u = np.exp(logu)<EOL>loogeoavg_u = []  <EOL>for j in range(n):<EOL><INDENT>loogeoavg_u.append(np.exp(np.mean(<EOL>[logu[i, ...] for i in range(n) if i != j],<EOL>axis=<NUM_LIT:0>)))<EOL><DEDENT>loogeoavg_u = np.array(loogeoavg_u)<EOL>loosum_u = []  <EOL>for j in range(n):<EOL><INDENT>loosum_u.append(np.sum(<EOL>[u[i, ...] for i in range(n) if i != j],<EOL>axis=<NUM_LIT:0>))<EOL><DEDENT>loosum_u = np.array(loosum_u)<EOL>log_sooavg_u = np.log(loosum_u + loogeoavg_u) - np.log(n)<EOL>log_avg_u = np.log(np.mean(u, axis=<NUM_LIT:0>))<EOL>return log_avg_u, log_sooavg_u<EOL>", "docstring": "Numpy implementation of `csiszar_vimco_helper`.", "id": "f15546:c17:m0"}
{"signature": "def arithmetic_geometric(logu, self_normalized=False, name=None):", "body": "with tf.compat.v1.name_scope(name, \"<STR_LIT>\", [logu]):<EOL><INDENT>logu = tf.convert_to_tensor(value=logu, name=\"<STR_LIT>\")<EOL>y = tf.nn.softplus(logu) - <NUM_LIT:0.5> * logu<EOL>if self_normalized:<EOL><INDENT>y -= np.log(<NUM_LIT>).astype(logu.dtype.as_numpy_dtype)<EOL><DEDENT>return (<NUM_LIT:1.> + tf.exp(logu)) * y<EOL><DEDENT>", "docstring": "The Arithmetic-Geometric Csiszar-function in log-space.\n\n    A Csiszar-function is a member of,\n\n    ```none\n    F = { f:R_+ to R : f convex }.\n    ```\n\n    When `self_normalized = True` the Arithmetic-Geometric Csiszar-function is:\n\n    ```none\n    f(u) = (1 + u) log( (1 + u) / sqrt(u) ) - (1 + u) log(2)\n    ```\n\n    When `self_normalized = False` the `(1 + u) log(2)` term is omitted.\n\n    Observe that as an f-Divergence, this Csiszar-function implies:\n\n    ```none\n    D_f[p, q] = KL[m, p] + KL[m, q]\n    m(x) = 0.5 p(x) + 0.5 q(x)\n    ```\n\n    In a sense, this divergence is the \"reverse\" of the Jensen-Shannon\n    f-Divergence.\n\n    This Csiszar-function induces a symmetric f-Divergence, i.e.,\n    `D_f[p, q] = D_f[q, p]`.\n\n    Warning: this function makes non-log-space calculations and may therefore be\n    numerically unstable for `|logu| >> 0`.\n\n    Args:\n      logu: `float`-like `Tensor` representing `log(u)` from above.\n      self_normalized: Python `bool` indicating whether `f'(u=1)=0`. When\n        `f'(u=1)=0` the implied Csiszar f-Divergence remains non-negative even\n        when `p, q` are unnormalized measures.\n      name: Python `str` name prefixed to Ops created by this function.\n\n    Returns:\n      arithmetic_geometric_of_u: `float`-like `Tensor` of the\n        Csiszar-function evaluated at `u = exp(logu)`.", "id": "f15548:m4"}
{"signature": "def modified_gan(logu, self_normalized=False, name=None):", "body": "with tf.compat.v1.name_scope(name, \"<STR_LIT>\", [logu]):<EOL><INDENT>logu = tf.convert_to_tensor(value=logu, name=\"<STR_LIT>\")<EOL>y = tf.nn.softplus(logu) - logu<EOL>if self_normalized:<EOL><INDENT>y += <NUM_LIT:0.5> * tf.math.expm1(logu)<EOL><DEDENT>return y<EOL><DEDENT>", "docstring": "The Modified-GAN Csiszar-function in log-space.\n\n    A Csiszar-function is a member of,\n\n    ```none\n    F = { f:R_+ to R : f convex }.\n    ```\n\n    When `self_normalized = True` the modified-GAN (Generative/Adversarial\n    Network) Csiszar-function is:\n\n    ```none\n    f(u) = log(1 + u) - log(u) + 0.5 (u - 1)\n    ```\n\n    When `self_normalized = False` the `0.5 (u - 1)` is omitted.\n\n    The unmodified GAN Csiszar-function is identical to Jensen-Shannon (with\n    `self_normalized = False`).\n\n    Warning: this function makes non-log-space calculations and may therefore be\n    numerically unstable for `|logu| >> 0`.\n\n    Args:\n      logu: `float`-like `Tensor` representing `log(u)` from above.\n      self_normalized: Python `bool` indicating whether `f'(u=1)=0`. When\n        `f'(u=1)=0` the implied Csiszar f-Divergence remains non-negative even\n        when `p, q` are unnormalized measures.\n      name: Python `str` name prefixed to Ops created by this function.\n\n    Returns:\n      chi_square_of_u: `float`-like `Tensor` of the Csiszar-function evaluated\n        at `u = exp(logu)`.", "id": "f15548:m13"}
{"signature": "def jeffreys(logu, name=None):", "body": "with tf.compat.v1.name_scope(name, \"<STR_LIT>\", [logu]):<EOL><INDENT>logu = tf.convert_to_tensor(value=logu, name=\"<STR_LIT>\")<EOL>return <NUM_LIT:0.5> * tf.math.expm1(logu) * logu<EOL><DEDENT>", "docstring": "The Jeffreys Csiszar-function in log-space.\n\n    A Csiszar-function is a member of,\n\n    ```none\n    F = { f:R_+ to R : f convex }.\n    ```\n\n    The Jeffreys Csiszar-function is:\n\n    ```none\n    f(u) = 0.5 ( u log(u) - log(u) )\n         = 0.5 kl_forward + 0.5 kl_reverse\n         = symmetrized_csiszar_function(kl_reverse)\n         = symmetrized_csiszar_function(kl_forward)\n    ```\n\n    This Csiszar-function induces a symmetric f-Divergence, i.e.,\n    `D_f[p, q] = D_f[q, p]`.\n\n    Warning: this function makes non-log-space calculations and may therefore be\n    numerically unstable for `|logu| >> 0`.\n\n    Args:\n      logu: `float`-like `Tensor` representing `log(u)` from above.\n      name: Python `str` name prefixed to Ops created by this function.\n\n    Returns:\n      jeffreys_of_u: `float`-like `Tensor` of the Csiszar-function evaluated\n        at `u = exp(logu)`.", "id": "f15548:m11"}
{"signature": "def kl_reverse(logu, self_normalized=False, name=None):", "body": "with tf.compat.v1.name_scope(name, \"<STR_LIT>\", [logu]):<EOL><INDENT>return amari_alpha(logu, alpha=<NUM_LIT:0.>, self_normalized=self_normalized)<EOL><DEDENT>", "docstring": "The reverse Kullback-Leibler Csiszar-function in log-space.\n\n    A Csiszar-function is a member of,\n\n    ```none\n    F = { f:R_+ to R : f convex }.\n    ```\n\n    When `self_normalized = True`, the KL-reverse Csiszar-function is:\n\n    ```none\n    f(u) = -log(u) + (u - 1)\n    ```\n\n    When `self_normalized = False` the `(u - 1)` term is omitted.\n\n    Observe that as an f-Divergence, this Csiszar-function implies:\n\n    ```none\n    D_f[p, q] = KL[q, p]\n    ```\n\n    The KL is \"reverse\" because in maximum likelihood we think of minimizing `q`\n    as in `KL[p, q]`.\n\n    Warning: when self_normalized = True` this function makes non-log-space\n    calculations and may therefore be numerically unstable for `|logu| >> 0`.\n\n    Args:\n      logu: `float`-like `Tensor` representing `log(u)` from above.\n      self_normalized: Python `bool` indicating whether `f'(u=1)=0`. When\n        `f'(u=1)=0` the implied Csiszar f-Divergence remains non-negative even\n        when `p, q` are unnormalized measures.\n      name: Python `str` name prefixed to Ops created by this function.\n\n    Returns:\n      kl_reverse_of_u: `float`-like `Tensor` of the Csiszar-function evaluated at\n        `u = exp(logu)`.\n\n    Raises:\n      TypeError: if `self_normalized` is `None` or a `Tensor`.", "id": "f15548:m1"}
{"signature": "def t_power(logu, t, self_normalized=False, name=None):", "body": "with tf.compat.v1.name_scope(name, \"<STR_LIT>\", [logu, t]):<EOL><INDENT>logu = tf.convert_to_tensor(value=logu, name=\"<STR_LIT>\")<EOL>t = tf.convert_to_tensor(value=t, dtype=logu.dtype.base_dtype, name=\"<STR_LIT:t>\")<EOL>fu = tf.math.expm1(t * logu)<EOL>if self_normalized:<EOL><INDENT>fu -= t * tf.math.expm1(logu)<EOL><DEDENT>fu *= tf.where(tf.logical_and(<NUM_LIT:0.> < t, t < <NUM_LIT:1.>),<EOL>-tf.ones_like(t),<EOL>tf.ones_like(t))<EOL>return fu<EOL><DEDENT>", "docstring": "The T-Power Csiszar-function in log-space.\n\n    A Csiszar-function is a member of,\n\n    ```none\n    F = { f:R_+ to R : f convex }.\n    ```\n\n    When `self_normalized = True` the T-Power Csiszar-function is:\n\n    ```none\n    f(u) = s [ u**t - 1 - t(u - 1) ]\n    s = { -1   0 < t < 1\n        { +1   otherwise\n    ```\n\n    When `self_normalized = False` the `- t(u - 1)` term is omitted.\n\n    This is similar to the `amari_alpha` Csiszar-function, with the associated\n    divergence being the same up to factors depending only on `t`.\n\n    Args:\n      logu: `float`-like `Tensor` representing `log(u)` from above.\n      t:  `Tensor` of same `dtype` as `logu` and broadcastable shape.\n      self_normalized: Python `bool` indicating whether `f'(u=1)=0`.\n      name: Python `str` name prefixed to Ops created by this function.\n\n    Returns:\n      t_power_of_u: `float`-like `Tensor` of the Csiszar-function evaluated\n        at `u = exp(logu)`.", "id": "f15548:m9"}
{"signature": "def jensen_shannon(logu, self_normalized=False, name=None):", "body": "with tf.compat.v1.name_scope(name, \"<STR_LIT>\", [logu]):<EOL><INDENT>logu = tf.convert_to_tensor(value=logu, name=\"<STR_LIT>\")<EOL>npdt = logu.dtype.as_numpy_dtype<EOL>y = tf.nn.softplus(logu)<EOL>if self_normalized:<EOL><INDENT>y -= np.log(<NUM_LIT:2>).astype(npdt)<EOL><DEDENT>return tf.exp(logu) * logu - (<NUM_LIT:1.> + tf.exp(logu)) * y<EOL><DEDENT>", "docstring": "The Jensen-Shannon Csiszar-function in log-space.\n\n    A Csiszar-function is a member of,\n\n    ```none\n    F = { f:R_+ to R : f convex }.\n    ```\n\n    When `self_normalized = True`, the Jensen-Shannon Csiszar-function is:\n\n    ```none\n    f(u) = u log(u) - (1 + u) log(1 + u) + (u + 1) log(2)\n    ```\n\n    When `self_normalized = False` the `(u + 1) log(2)` term is omitted.\n\n    Observe that as an f-Divergence, this Csiszar-function implies:\n\n    ```none\n    D_f[p, q] = KL[p, m] + KL[q, m]\n    m(x) = 0.5 p(x) + 0.5 q(x)\n    ```\n\n    In a sense, this divergence is the \"reverse\" of the Arithmetic-Geometric\n    f-Divergence.\n\n    This Csiszar-function induces a symmetric f-Divergence, i.e.,\n    `D_f[p, q] = D_f[q, p]`.\n\n    Warning: this function makes non-log-space calculations and may therefore be\n    numerically unstable for `|logu| >> 0`.\n\n    For more information, see:\n      Lin, J. \"Divergence measures based on the Shannon entropy.\" IEEE Trans.\n      Inf. Th., 37, 145-151, 1991.\n\n    Args:\n      logu: `float`-like `Tensor` representing `log(u)` from above.\n      self_normalized: Python `bool` indicating whether `f'(u=1)=0`. When\n        `f'(u=1)=0` the implied Csiszar f-Divergence remains non-negative even\n        when `p, q` are unnormalized measures.\n      name: Python `str` name prefixed to Ops created by this function.\n\n    Returns:\n      jensen_shannon_of_u: `float`-like `Tensor` of the Csiszar-function\n        evaluated at `u = exp(logu)`.", "id": "f15548:m3"}
{"signature": "def _binary_crossover(population,<EOL>population_size,<EOL>mutants,<EOL>crossover_prob,<EOL>seed):", "body": "sizes = [tf.cast(tf.size(input=x), dtype=tf.float64) for x in population]<EOL>seed_stream = distributions.SeedStream(seed, salt='<STR_LIT>')<EOL>force_crossover_group = distributions.Categorical(sizes).sample(<EOL>[population_size, <NUM_LIT:1>], seed=seed_stream())<EOL>recombinants = []<EOL>for i, population_part in enumerate(population):<EOL><INDENT>pop_part_flat = tf.reshape(population_part, [population_size, -<NUM_LIT:1>])<EOL>mutant_part_flat = tf.reshape(mutants[i], [population_size, -<NUM_LIT:1>])<EOL>part_size = tf.size(input=population_part) // population_size<EOL>force_crossovers = tf.one_hot(<EOL>tf.random.uniform([population_size],<EOL>minval=<NUM_LIT:0>,<EOL>maxval=part_size,<EOL>dtype=tf.int32,<EOL>seed=seed_stream()),<EOL>part_size,<EOL>on_value=True,<EOL>off_value=False,<EOL>dtype=tf.bool)  <EOL>group_mask = tf.math.equal(force_crossover_group, i)<EOL>force_crossovers &= group_mask<EOL>do_binary_crossover = tf.random.uniform(<EOL>[population_size, part_size],<EOL>dtype=crossover_prob.dtype.base_dtype,<EOL>seed=seed_stream()) < crossover_prob<EOL>do_binary_crossover |= force_crossovers<EOL>recombinant_flat = tf.where(<EOL>do_binary_crossover,<EOL>x=mutant_part_flat,<EOL>y=pop_part_flat)<EOL>recombinant = tf.reshape(recombinant_flat, tf.shape(input=population_part))<EOL>recombinants.append(recombinant)<EOL><DEDENT>return recombinants<EOL>", "docstring": "Performs recombination by binary crossover for the current population.\n\n    Let v_i denote the i'th component of the member v and m_i the corresponding\n    component of the mutant vector corresponding to v. Then the crossed over\n    vector w_i is determined by setting w_i =\n    (m_i with probability=crossover_prob else v_i). In addition, DE requires that\n    at least one of the components is crossed over (otherwise we end\n    up with no change). This is done by choosing on index say k randomly where\n    a force crossover is performed (i.e. w_k = m_k). This is the scheme\n    implemented in this function.\n\n    Args:\n      population: A Python list of `Tensor`s where each `Tensor` in the list\n        must be of rank at least 1 and all the elements must have a common\n        first dimension. The base population to cross over.\n      population_size: A scalar integer `Tensor`. The number of elements in the\n        population (i.e. size of the first dimension of any member of\n        `population`).\n      mutants: A Python list of `Tensor`s with the same structure as `population`.\n        The mutated population.\n      crossover_prob: A postive real scalar `Tensor` bounded above by 1.0. The\n        probability of a crossover being performed for each axis.\n      seed: `int` or None. The random seed for this `Op`. If `None`, no seed is\n        applied.\n\n    Returns:\n      A list of `Tensor`s of the same structure, dtype and shape as `population`.\n      The recombined population.", "id": "f15549:m7"}
{"signature": "def _check_failure(population_values):", "body": "return tf.math.reduce_all(input_tensor=tf.math.is_inf(population_values))<EOL>", "docstring": "Checks if all the population values are NaN/infinite.", "id": "f15549:m3"}
{"signature": "def _batch_transpose(mat):", "body": "n = distribution_util.prefer_static_rank(mat)<EOL>perm = tf.range(n)<EOL>perm = tf.concat([perm[:-<NUM_LIT:2>], [perm[-<NUM_LIT:1>], perm[-<NUM_LIT:2>]]], axis=<NUM_LIT:0>)<EOL>return tf.transpose(a=mat, perm=perm)<EOL>", "docstring": "Transpose a possibly batched matrix.\n\n    Args:\n      mat: A `tf.Tensor` of shape `[..., n, m]`.\n\n    Returns:\n      A tensor of shape `[..., m, n]` with matching batch dimensions.", "id": "f15550:m7"}
{"signature": "def _update_inv_hessian(prev_state, next_state):", "body": "<EOL>should_update = ~next_state.converged & ~next_state.failed<EOL>gradient_delta = next_state.objective_gradient - prev_state.objective_gradient<EOL>position_delta = next_state.position - prev_state.position<EOL>normalization_factor = tf.reduce_sum(<EOL>input_tensor=gradient_delta * position_delta, axis=-<NUM_LIT:1>)<EOL>should_update = should_update & ~tf.equal(normalization_factor, <NUM_LIT:0>)<EOL>def _do_update_inv_hessian():<EOL><INDENT>next_inv_hessian = _bfgs_inv_hessian_update(<EOL>gradient_delta, position_delta, normalization_factor,<EOL>prev_state.inverse_hessian_estimate)<EOL>return bfgs_utils.update_fields(<EOL>next_state,<EOL>inverse_hessian_estimate=tf.where(should_update,<EOL>next_inv_hessian,<EOL>prev_state.inverse_hessian_estimate))<EOL><DEDENT>return prefer_static.cond(<EOL>tf.reduce_any(input_tensor=should_update),<EOL>_do_update_inv_hessian,<EOL>lambda: next_state)<EOL>", "docstring": "Update the BGFS state by computing the next inverse hessian estimate.", "id": "f15550:m3"}
{"signature": "def _tensor_product(t1, t2):", "body": "return tf.matmul(tf.expand_dims(t1, axis=-<NUM_LIT:1>), tf.expand_dims(t2, axis=-<NUM_LIT:2>))<EOL>", "docstring": "Computes the outer product of two possibly batched vectors.\n\n    Args:\n      t1: A `tf.Tensor` of shape `[..., n]`.\n      t2: A `tf.Tensor` of shape `[..., m]`.\n\n    Returns:\n      A tensor of shape `[..., n, m]` with matching batch dimensions, let's call\n      it `r`, whose components are:\n\n      ```None\n        r[..., i, j] = t1[..., i] * t2[..., j]\n      ```", "id": "f15550:m6"}
{"signature": "def bisect(value_and_gradients_function,<EOL>initial_left,<EOL>initial_right,<EOL>f_lim):", "body": "failed = ~is_finite(initial_left, initial_right)<EOL>needs_bisect = (initial_right.df < <NUM_LIT:0>) & (initial_right.f > f_lim)<EOL>bisect_args = _IntermediateResult(<EOL>iteration=tf.convert_to_tensor(value=<NUM_LIT:0>),<EOL>stopped=failed | ~needs_bisect,<EOL>failed=failed,<EOL>num_evals=tf.convert_to_tensor(value=<NUM_LIT:0>),<EOL>left=initial_left,<EOL>right=initial_right)<EOL>return _bisect(value_and_gradients_function, bisect_args, f_lim)<EOL>", "docstring": "Bisects an interval and updates to satisfy opposite slope conditions.\n\n    Corresponds to the step U3 in [Hager and Zhang (2006)][2].\n\n    Args:\n      value_and_gradients_function: A Python callable that accepts a real scalar\n        tensor and returns a namedtuple containing the value filed `f` of the\n        function and its derivative value field `df` at that point.\n        Alternatively, the function may representthe batching of `n` such line\n        functions (e.g. projecting a single multivariate objective function along\n        `n` distinct directions at once) accepting n points as input, i.e. a\n        tensor of shape [n], and return a tuple of two tensors of shape [n], the\n        function values and the corresponding derivatives at the input points.\n      initial_left: Return value of value_and_gradients_function at the left end\n        point of the current bracketing interval.\n      initial_right: Return value of value_and_gradients_function at the right end\n        point of the current bracketing interval.\n      f_lim: real `Tensor` of shape [n]. The function value threshold for\n        the approximate Wolfe conditions to be checked for each batch member.\n\n    Returns:\n      A namedtuple containing the following fields:\n        iteration: An int32 scalar `Tensor`. The number of iterations performed.\n          Bounded above by `max_iterations` parameter.\n        stopped: A boolean scalar `Tensor`. True if the bisect algorithm\n          terminated.\n        failed: A scalar boolean tensor. Indicates whether the objective function\n          failed to produce a finite value.\n        num_evals: A scalar int32 tensor. The number of value and gradients\n          function evaluations.\n        left: Return value of value_and_gradients_function at the left end\n          point of the bracketing interval found.\n        right: Return value of value_and_gradients_function at the right end\n          point of the bracketing interval found.", "id": "f15552:m6"}
{"signature": "def val_where(cond, tval, fval):", "body": "if isinstance(tval, tf.Tensor):<EOL><INDENT>return tf.where(cond, tval, fval)<EOL><DEDENT>elif isinstance(tval, tuple):<EOL><INDENT>cls = type(tval)<EOL>return cls(*(val_where(cond, t, f) for t, f in zip(tval, fval)))<EOL><DEDENT>else:<EOL><INDENT>raise Exception(TypeError)<EOL><DEDENT>", "docstring": "Like tf.where but works on namedtuples.", "id": "f15552:m0"}
{"signature": "def _bisect(value_and_gradients_function, initial_args, f_lim):", "body": "def _loop_cond(curr):<EOL><INDENT>return ~tf.reduce_all(input_tensor=curr.stopped)<EOL><DEDENT>def _loop_body(curr):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>mid = value_and_gradients_function((curr.left.x + curr.right.x) / <NUM_LIT:2>)<EOL>failed = (curr.failed | ~is_finite(mid) |<EOL>tf.equal(mid.x, curr.left.x) | tf.equal(mid.x, curr.right.x))<EOL>to_update = ~(curr.stopped | failed)<EOL>update_left = (mid.df < <NUM_LIT:0>) & (mid.f <= f_lim)<EOL>left = val_where(to_update & update_left, mid, curr.left)<EOL>right = val_where(to_update & ~update_left, mid, curr.right)<EOL>stopped = curr.stopped | failed | (right.df >= <NUM_LIT:0>)<EOL>return [_IntermediateResult(<EOL>iteration=curr.iteration,<EOL>stopped=stopped,<EOL>failed=failed,<EOL>num_evals=curr.num_evals + <NUM_LIT:1>,<EOL>left=left,<EOL>right=right)]<EOL><DEDENT>return tf.while_loop(<EOL>cond=_loop_cond, body=_loop_body, loop_vars=[initial_args])[<NUM_LIT:0>]<EOL>", "docstring": "Actual implementation of bisect given initial_args in a _BracketResult.", "id": "f15552:m7"}
{"signature": "def _bracket_and_search(<EOL>value_and_gradients_function,<EOL>init_interval,<EOL>f_lim,<EOL>max_iterations,<EOL>shrinkage_param,<EOL>expansion_param,<EOL>sufficient_decrease_param,<EOL>curvature_param):", "body": "bracket_result = hzl.bracket(value_and_gradients_function, init_interval,<EOL>f_lim, max_iterations, expansion_param)<EOL>converged = init_interval.converged | _very_close(<EOL>bracket_result.left.x, bracket_result.right.x)<EOL>exhausted_iterations = ~converged & tf.greater_equal(<EOL>bracket_result.iteration, max_iterations)<EOL>line_search_args = HagerZhangLineSearchResult(<EOL>converged=converged,<EOL>failed=bracket_result.failed | exhausted_iterations,<EOL>iterations=bracket_result.iteration,<EOL>func_evals=bracket_result.num_evals,<EOL>left=bracket_result.left,<EOL>right=bracket_result.right)<EOL>return _line_search_after_bracketing(<EOL>value_and_gradients_function, line_search_args, init_interval.left,<EOL>f_lim, max_iterations, sufficient_decrease_param, curvature_param,<EOL>shrinkage_param)<EOL>", "docstring": "Brackets the minimum and performs a line search.\n\n    Args:\n      value_and_gradients_function: A Python callable that accepts a real scalar\n        tensor and returns a namedtuple with the fields 'x', 'f', and 'df' that\n        correspond to scalar tensors of real dtype containing the point at which\n        the function was evaluated, the value of the function, and its\n        derivative at that point. The other namedtuple fields, if present,\n        should be tensors or sequences (possibly nested) of tensors.\n        In usual optimization application, this function would be generated by\n        projecting the multivariate objective function along some specific\n        direction. The direction is determined by some other procedure but should\n        be a descent direction (i.e. the derivative of the projected univariate\n        function must be negative at 0.).\n        Alternatively, the function may represent the batching of `n` such line\n        functions (e.g. projecting a single multivariate objective function along\n        `n` distinct directions at once) accepting n points as input, i.e. a\n        tensor of shape [n], and the fields 'x', 'f' and 'df' in the returned\n        namedtuple should each be a tensor of shape [n], with the corresponding\n        input points, function values, and derivatives at those input points.\n      init_interval: Instance of `HagerZhangLineSearchResults` containing\n        the initial line search interval. The gradient of init_interval.left must\n        be negative (i.e. must be a descent direction), while init_interval.right\n        must be positive and finite.\n      f_lim: Scalar `Tensor` of float dtype.\n      max_iterations: Positive scalar `Tensor` of integral dtype. The maximum\n        number of iterations to perform in the line search. The number of\n        iterations used to bracket the minimum are also counted against this\n        parameter.\n      shrinkage_param: Scalar positive Tensor of real dtype. Must be less than\n        `1.`. Corresponds to the parameter `gamma` in [Hager and Zhang (2006)][2].\n      expansion_param: Scalar positive `Tensor` of real dtype. Must be greater\n        than `1.`. Used to expand the initial interval in case it does not bracket\n        a minimum. Corresponds to `rho` in [Hager and Zhang (2006)][2].\n      sufficient_decrease_param: Positive scalar `Tensor` of real dtype.\n        Bounded above by the curvature param. Corresponds to `delta` in the\n        terminology of [Hager and Zhang (2006)][2].\n      curvature_param: Positive scalar `Tensor` of real dtype. Bounded above\n        by `1.`. Corresponds to 'sigma' in the terminology of\n        [Hager and Zhang (2006)][2].\n\n    Returns:\n      A namedtuple containing the following fields.\n        converged: Boolean `Tensor` of shape [n]. Whether a point satisfying\n          Wolfe/Approx wolfe was found.\n        failed: Boolean `Tensor` of shape [n]. Whether line search failed e.g.\n          if either the objective function or the gradient are not finite at\n          an evaluation point.\n        iterations: Scalar int32 `Tensor`. Number of line search iterations made.\n        func_evals: Scalar int32 `Tensor`. Number of function evaluations made.\n        left: A namedtuple, as returned by value_and_gradients_function,\n          of the left end point of the updated bracketing interval.\n        right: A namedtuple, as returned by value_and_gradients_function,\n          of the right end point of the updated bracketing interval.", "id": "f15554:m3"}
{"signature": "def _line_search_inner_bisection(<EOL>value_and_gradients_function,<EOL>search_interval,<EOL>active,<EOL>f_lim):", "body": "midpoint = (search_interval.left.x + search_interval.right.x) / <NUM_LIT:2><EOL>val_mid = value_and_gradients_function(midpoint)<EOL>is_valid_mid = hzl.is_finite(val_mid)<EOL>still_active = active & is_valid_mid<EOL>new_failed = active & ~is_valid_mid<EOL>next_inteval = search_interval._replace(<EOL>failed=search_interval.failed | new_failed,<EOL>func_evals=search_interval.func_evals + <NUM_LIT:1>)<EOL>def _apply_update():<EOL><INDENT>update_result = hzl.update(<EOL>value_and_gradients_function, next_inteval.left, next_inteval.right,<EOL>val_mid, f_lim, active=still_active)<EOL>return HagerZhangLineSearchResult(<EOL>converged=next_inteval.converged,<EOL>failed=next_inteval.failed | update_result.failed,<EOL>iterations=next_inteval.iterations + update_result.iteration,<EOL>func_evals=next_inteval.func_evals + update_result.num_evals,<EOL>left=update_result.left,<EOL>right=update_result.right)<EOL><DEDENT>return prefer_static.cond(<EOL>tf.reduce_any(input_tensor=still_active),<EOL>_apply_update,<EOL>lambda: next_inteval)<EOL>", "docstring": "Performs bisection and updates the interval.", "id": "f15554:m5"}
{"signature": "def _fix_step_size(value_and_gradients_function,<EOL>val_c_input,<EOL>active,<EOL>step_size_shrink_param):", "body": "<EOL>iter_max = np.ceil(-np.log2(_machine_eps(val_c_input.x.dtype)))<EOL>def _cond(i, val_c, to_fix):<EOL><INDENT>del val_c  <EOL>return (i < iter_max) & tf.reduce_any(input_tensor=to_fix)<EOL><DEDENT>def _body(i, val_c, to_fix):<EOL><INDENT>next_c = tf.where(to_fix, val_c.x * step_size_shrink_param, val_c.x)<EOL>next_val_c = value_and_gradients_function(next_c)<EOL>still_to_fix = to_fix & ~hzl.is_finite(next_val_c)<EOL>return (i + <NUM_LIT:1>, next_val_c, still_to_fix)<EOL><DEDENT>to_fix = active & ~hzl.is_finite(val_c_input)<EOL>return tf.while_loop(<EOL>cond=_cond, body=_body, loop_vars=(<NUM_LIT:0>, val_c_input, to_fix))<EOL>", "docstring": "Shrinks the input step size until the value and grad become finite.", "id": "f15554:m2"}
{"signature": "def _accept_reflected_fn(simplex,<EOL>objective_values,<EOL>worst_index,<EOL>reflected,<EOL>objective_at_reflected):", "body": "def _replace_worst_with_reflected():<EOL><INDENT>next_simplex = _replace_at_index(simplex, worst_index, reflected)<EOL>next_objective_values = _replace_at_index(objective_values, worst_index,<EOL>objective_at_reflected)<EOL>return False, next_simplex, next_objective_values, <NUM_LIT:0><EOL><DEDENT>return _replace_worst_with_reflected<EOL>", "docstring": "Creates the condition function pair for a reflection to be accepted.", "id": "f15567:m2"}
{"signature": "def _evaluate_objective_multiple(objective_function, arg_batch,<EOL>batch_evaluate_objective):", "body": "n_points = tf.shape(input=arg_batch)[<NUM_LIT:0>]<EOL>if batch_evaluate_objective:<EOL><INDENT>return objective_function(arg_batch), n_points<EOL><DEDENT>return tf.map_fn(objective_function, arg_batch), n_points<EOL>", "docstring": "Evaluates the objective function on a batch of points.\n\n    If `batch_evaluate_objective` is True, returns\n    `objective function(arg_batch)` else it maps the `objective_function`\n    across the `arg_batch`.\n\n    Args:\n      objective_function: A Python callable that accepts a single `Tensor` of\n        rank 'R > 1' and any shape 's' and returns a scalar `Tensor` of real dtype\n        containing the value of the function at that point. If\n        `batch a `Tensor` of shape `[batch_size] + s ` where `batch_size` is the\n        size of the batch of args. In this case, the expected return value is a\n        `Tensor` of shape `[batch_size]`.\n      arg_batch: A `Tensor` of real dtype. The batch of arguments at which to\n        evaluate the `objective_function`. If `batch_evaluate_objective` is False,\n        `arg_batch` will be unpacked along the zeroth axis and the\n        `objective_function` will be applied to each element.\n      batch_evaluate_objective: `bool`. Whether the `objective_function` can\n        evaluate a batch of arguments at once.\n\n    Returns:\n      A tuple containing:\n        objective_values: A `Tensor` of real dtype and shape `[batch_size]`.\n          The value of the objective function evaluated at the supplied\n          `arg_batch`.\n        num_evaluations: An `int32` scalar `Tensor`containing the number of\n          points on which the objective function was evaluated (i.e `batch_size`).", "id": "f15567:m14"}
{"signature": "def _shrink_towards_best(objective_function,<EOL>simplex,<EOL>best_index,<EOL>shrinkage,<EOL>batch_evaluate_objective):", "body": "<EOL>best_vertex = simplex[best_index]<EOL>shrunk_simplex = best_vertex + shrinkage * (simplex - best_vertex)<EOL>objective_at_shrunk_simplex, evals = _evaluate_objective_multiple(<EOL>objective_function,<EOL>shrunk_simplex,<EOL>batch_evaluate_objective)<EOL>return (False,<EOL>shrunk_simplex,<EOL>objective_at_shrunk_simplex,<EOL>evals)<EOL>", "docstring": "Shrinks the simplex around the best vertex.", "id": "f15567:m6"}
{"signature": "def _check_convergence(simplex,<EOL>best_vertex,<EOL>best_objective,<EOL>worst_objective,<EOL>func_tolerance,<EOL>position_tolerance):", "body": "objective_convergence = tf.abs(worst_objective -<EOL>best_objective) < func_tolerance<EOL>simplex_degeneracy = tf.reduce_max(<EOL>input_tensor=tf.abs(simplex - best_vertex)) < position_tolerance<EOL>return objective_convergence | simplex_degeneracy<EOL>", "docstring": "Returns True if the simplex has converged.\n\n    If the simplex size is smaller than the `position_tolerance` or the variation\n    of the function value over the vertices of the simplex is smaller than the\n    `func_tolerance` return True else False.\n\n    Args:\n      simplex: `Tensor` of real dtype. The simplex to test for convergence. For\n        more details, see the docstring for `initial_simplex` argument\n        of `minimize`.\n      best_vertex: `Tensor` of real dtype and rank one less than `simplex`. The\n        vertex with the best (i.e. smallest) objective value.\n      best_objective: Scalar `Tensor` of real dtype. The best (i.e. smallest)\n        value of the objective function at a vertex.\n      worst_objective: Scalar `Tensor` of same dtype as `best_objective`. The\n        worst (i.e. largest) value of the objective function at a vertex.\n      func_tolerance: Scalar positive `Tensor`. The tolerance for the variation\n        of the objective function value over the simplex. If the variation over\n        the simplex vertices is below this threshold, convergence is True.\n      position_tolerance: Scalar positive `Tensor`. The algorithm stops if the\n        lengths (under the supremum norm) of edges connecting to the best vertex\n        are below this threshold.\n\n    Returns:\n      has_converged: A scalar boolean `Tensor` indicating whether the algorithm\n        is deemed to have converged.", "id": "f15567:m8"}
{"signature": "def _prepare_args_with_initial_simplex(objective_function,<EOL>initial_simplex,<EOL>objective_at_initial_simplex,<EOL>batch_evaluate_objective):", "body": "initial_simplex = tf.convert_to_tensor(value=initial_simplex)<EOL>num_vertices = tf.shape(input=initial_simplex)[<NUM_LIT:0>]<EOL>dim = num_vertices - <NUM_LIT:1><EOL>num_evaluations = <NUM_LIT:0><EOL>if objective_at_initial_simplex is None:<EOL><INDENT>objective_at_initial_simplex, n_evals = _evaluate_objective_multiple(<EOL>objective_function, initial_simplex, batch_evaluate_objective)<EOL>num_evaluations += n_evals<EOL><DEDENT>objective_at_initial_simplex = tf.convert_to_tensor(<EOL>value=objective_at_initial_simplex)<EOL>return (dim,<EOL>num_vertices,<EOL>initial_simplex,<EOL>objective_at_initial_simplex,<EOL>num_evaluations)<EOL>", "docstring": "Evaluates the objective function at the specified initial simplex.", "id": "f15567:m11"}
{"signature": "def _broadcast(value, target):", "body": "return tf.broadcast_to(<EOL>tf.convert_to_tensor(value=value, dtype=target.dtype),<EOL>distribution_util.prefer_static_shape(target)[:-<NUM_LIT:1>])<EOL>", "docstring": "Broadcast a value to match the batching dimensions of a target.\n\n    If necessary the value is converted into a tensor. Both value and target\n    should be of the same dtype.\n\n    Args:\n      value: A value to broadcast.\n      target: A `Tensor` of shape [b1, ..., bn, d].\n\n    Returns:\n      A `Tensor` of shape [b1, ..., bn] and same dtype as the target.", "id": "f15568:m9"}
{"signature": "def _check_convergence(current_position,<EOL>next_position,<EOL>current_objective,<EOL>next_objective,<EOL>next_gradient,<EOL>grad_tolerance,<EOL>f_relative_tolerance,<EOL>x_tolerance):", "body": "grad_converged = norm(next_gradient, dims=<NUM_LIT:1>) <= grad_tolerance<EOL>x_converged = norm(next_position - current_position, dims=<NUM_LIT:1>) <= x_tolerance<EOL>f_converged = (norm(next_objective - current_objective, dims=<NUM_LIT:0>) <=<EOL>f_relative_tolerance * current_objective)<EOL>return grad_converged | x_converged | f_converged<EOL>", "docstring": "Checks if the algorithm satisfies the convergence criteria.", "id": "f15568:m8"}
{"signature": "def get_initial_state_args(value_and_gradients_function,<EOL>initial_position,<EOL>grad_tolerance,<EOL>control_inputs=None):", "body": "if control_inputs:<EOL><INDENT>with tf.control_dependencies(control_inputs):<EOL><INDENT>f0, df0 = value_and_gradients_function(initial_position)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>f0, df0 = value_and_gradients_function(initial_position)<EOL><DEDENT>converged = norm(df0, dims=<NUM_LIT:1>) < grad_tolerance<EOL>return dict(<EOL>converged=converged,<EOL>failed=tf.zeros_like(converged),  <EOL>num_iterations=tf.convert_to_tensor(value=<NUM_LIT:0>),<EOL>num_objective_evaluations=tf.convert_to_tensor(value=<NUM_LIT:1>),<EOL>position=initial_position,<EOL>objective_value=f0,<EOL>objective_gradient=df0)<EOL>", "docstring": "Returns a dictionary to populate the initial state of the search procedure.\n\n    Performs an initial convergence check and the first evaluation of the\n    objective function.\n\n    Args:\n      value_and_gradients_function: A Python callable that accepts a tensor and\n        returns a tuple of two tensors: the objective function value and its\n        derivative.\n      initial_position: The starting point of the search procedure.\n      grad_tolerance: The gradient tolerance for the procedure.\n      control_inputs: Optional ops used to assert the validity of inputs, these\n        are added as control dependencies to execute before the objective\n        function is evaluated for the first time.\n\n    Returns:\n      An dictionary with values for the following keys:\n        converged: True if the convergence check finds that the initial position\n          is already an argmin of the objective function.\n        failed: Initialized to False.\n        num_objective_evaluations: Initialized to 1.\n        position: Initialized to the initial position.\n        objective_value: Initialized to the value of the objective function at\n          the initial position.\n        objective_gradient: Initialized to the gradient of the objective\n          function at the initial position.", "id": "f15568:m2"}
{"signature": "def converged_all(converged, failed):", "body": "return tf.reduce_all(input_tensor=converged | failed)<EOL>", "docstring": "Condition to stop when all batch members have converged or failed.", "id": "f15568:m1"}
{"signature": "def _make_grid(dtype, grid_spec):", "body": "rng = np.random.RandomState(<NUM_LIT:0>)<EOL>num_points = np.prod(grid_spec.shape)<EOL>grid = np.linspace(grid_spec.min, grid_spec.max, num=num_points).astype(dtype)<EOL>grid_spacing = (grid_spec.max - grid_spec.min) / num_points<EOL>grid += <NUM_LIT:0.1> * grid_spacing * rng.randn(*grid.shape)<EOL>grid = np.sort(grid)<EOL>return np.reshape(grid, grid_spec.shape)<EOL>", "docstring": "Returns a uniform grid + noise, reshaped to shape argument.", "id": "f15571:m2"}
{"signature": "def _baseNdtriFiniteGradientTest(self, dtype):", "body": "<EOL>p = tf.constant(<EOL>np.array([<EOL><NUM_LIT:0.>,<EOL>np.exp(-<NUM_LIT>),<EOL>np.exp(-<NUM_LIT>),<EOL><NUM_LIT:1.> - np.exp(-<NUM_LIT>),<EOL><NUM_LIT:1.> - np.exp(-<NUM_LIT>),<EOL><NUM_LIT:1.>,<EOL>]).astype(dtype))<EOL>_, grads = value_and_gradient(special_math.ndtri, p)<EOL>self.assertAllFinite(self.evaluate(grads[<NUM_LIT:0>]))<EOL>", "docstring": "Verifies that ndtri has finite gradients at interesting points.", "id": "f15571:c0:m3"}
{"signature": "def gen_new_seed(seed, salt):", "body": "if seed is None:<EOL><INDENT>return None<EOL><DEDENT>string = (str(seed) + salt).encode(\"<STR_LIT:utf-8>\")<EOL>return int(hashlib.md5(string).hexdigest()[:<NUM_LIT:8>], <NUM_LIT:16>) & <NUM_LIT><EOL>", "docstring": "Generate a new seed, from the given seed and salt.", "id": "f15574:m34"}
{"signature": "def _largest_integer_by_dtype(dt):", "body": "if not _is_known_dtype(dt):<EOL><INDENT>raise TypeError(\"<STR_LIT>\".format(dt.name))<EOL><DEDENT>if dt.is_floating:<EOL><INDENT>return int(<NUM_LIT:2>**(np.finfo(dt.as_numpy_dtype).nmant + <NUM_LIT:1>))<EOL><DEDENT>if dt.is_integer:<EOL><INDENT>return np.iinfo(dt.as_numpy_dtype).max<EOL><DEDENT>if dt.base_dtype == tf.bool:<EOL><INDENT>return int(<NUM_LIT:1>)<EOL><DEDENT>raise TypeError(\"<STR_LIT>\".format(dt.name))<EOL>", "docstring": "Helper returning the largest integer exactly representable by dtype.", "id": "f15574:m21"}
{"signature": "def pad(x, axis, front=False, back=False, value=<NUM_LIT:0>, count=<NUM_LIT:1>, name=None):", "body": "with tf.name_scope(name or \"<STR_LIT>\"):<EOL><INDENT>x = tf.convert_to_tensor(value=x, name=\"<STR_LIT:x>\")<EOL>value = tf.convert_to_tensor(value=value, dtype=x.dtype, name=\"<STR_LIT:value>\")<EOL>count = tf.convert_to_tensor(value=count, name=\"<STR_LIT:count>\")<EOL>if not dtype_util.is_integer(count.dtype):<EOL><INDENT>raise TypeError(\"<STR_LIT>\".format(<EOL>dtype_util.name(count.dtype)))<EOL><DEDENT>if not front and not back:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>ndims = (<EOL>tensorshape_util.rank(x.shape)<EOL>if tensorshape_util.rank(x.shape) is not None else tf.rank(<EOL>x, name=\"<STR_LIT>\"))<EOL>axis = tf.convert_to_tensor(value=axis, name=\"<STR_LIT>\")<EOL>axis_ = tf.get_static_value(axis)<EOL>if axis_ is not None:<EOL><INDENT>axis = axis_<EOL>if axis < <NUM_LIT:0>:<EOL><INDENT>axis = ndims + axis<EOL><DEDENT>count_ = tf.get_static_value(count)<EOL>if axis_ >= <NUM_LIT:0> or tensorshape_util.rank(x.shape) is not None:<EOL><INDENT>head = x.shape[:axis]<EOL>mid_dim_value = tf.compat.dimension_value(x.shape[axis])<EOL>if count_ is None or mid_dim_value is None:<EOL><INDENT>middle = tf.TensorShape(None)<EOL><DEDENT>else:<EOL><INDENT>middle = tf.TensorShape(mid_dim_value + count_ * (front + back))<EOL><DEDENT>tail = x.shape[axis + <NUM_LIT:1>:]<EOL>final_shape = head.concatenate(middle.concatenate(tail))<EOL><DEDENT>else:<EOL><INDENT>final_shape = None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>axis = tf.where(axis < <NUM_LIT:0>, ndims + axis, axis)<EOL>final_shape = None<EOL><DEDENT>x = tf.pad(<EOL>tensor=x,<EOL>paddings=tf.one_hot(<EOL>indices=tf.stack([axis if front else -<NUM_LIT:1>, axis if back else -<NUM_LIT:1>]),<EOL>depth=ndims,<EOL>axis=<NUM_LIT:0>,<EOL>on_value=count,<EOL>dtype=tf.int32),<EOL>constant_values=value)<EOL>if final_shape is not None:<EOL><INDENT>tensorshape_util.set_shape(x, final_shape)<EOL><DEDENT>return x<EOL><DEDENT>", "docstring": "Pads `value` to the front and/or back of a `Tensor` dim, `count` times.\n\n    Args:\n      x: `Tensor` input.\n      axis: Scalar `int`-like `Tensor` representing the single dimension to pad.\n        (Negative indexing is supported.)\n      front: Python `bool`; if `True` the beginning of the `axis` dimension is\n        padded with `value`, `count` times. If `False` no front padding is made.\n      back: Python `bool`; if `True` the end of the `axis` dimension is padded\n        with `value`, `count` times. If `False` no end padding is made.\n      value: Scalar `int`-like `Tensor` representing the actual value added to the\n        front and/or back of the `axis` dimension of `x`.\n      count: Scalar `int`-like `Tensor` representing number of elements added to\n        the front and/or back of the `axis` dimension of `x`. E.g., if `front =\n        back = True` then `2 * count` elements are added.\n      name: Python `str` name prefixed to Ops created by this function.\n\n    Returns:\n      pad: The padded version of input `x`.\n\n    Raises:\n      ValueError: if both `front` and `back` are `False`.\n      TypeError: if `count` is not `int`-like.", "id": "f15574:m42"}
{"signature": "def prefer_static_broadcast_shape(shape1,<EOL>shape2,<EOL>name=\"<STR_LIT>\"):", "body": "with tf.name_scope(name):<EOL><INDENT>def make_shape_tensor(x):<EOL><INDENT>return tf.convert_to_tensor(value=x, name=\"<STR_LIT>\", dtype=tf.int32)<EOL><DEDENT>def get_tensor_shape(s):<EOL><INDENT>if isinstance(s, tf.TensorShape):<EOL><INDENT>return s<EOL><DEDENT>s_ = tf.get_static_value(make_shape_tensor(s))<EOL>if s_ is not None:<EOL><INDENT>return tf.TensorShape(s_)<EOL><DEDENT>return None<EOL><DEDENT>def get_shape_tensor(s):<EOL><INDENT>if not isinstance(s, tf.TensorShape):<EOL><INDENT>return make_shape_tensor(s)<EOL><DEDENT>if tensorshape_util.is_fully_defined(s):<EOL><INDENT>return make_shape_tensor(tensorshape_util.as_list(s))<EOL><DEDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>shape1_ = get_tensor_shape(shape1)<EOL>shape2_ = get_tensor_shape(shape2)<EOL>if shape1_ is not None and shape2_ is not None:<EOL><INDENT>return tf.broadcast_static_shape(shape1_, shape2_)<EOL><DEDENT>shape1_ = get_shape_tensor(shape1)<EOL>shape2_ = get_shape_tensor(shape2)<EOL>return tf.broadcast_dynamic_shape(shape1_, shape2_)<EOL><DEDENT>", "docstring": "Convenience function which statically broadcasts shape when possible.\n\n    Args:\n      shape1:  `1-D` integer `Tensor`.  Already converted to tensor!\n      shape2:  `1-D` integer `Tensor`.  Already converted to tensor!\n      name:  A string name to prepend to created ops.\n\n    Returns:\n      The broadcast shape, either as `TensorShape` (if broadcast can be done\n        statically), or as a `Tensor`.", "id": "f15574:m30"}
{"signature": "def same_dynamic_shape(a, b):", "body": "a = tf.convert_to_tensor(value=a, name=\"<STR_LIT:a>\")<EOL>b = tf.convert_to_tensor(value=b, name=\"<STR_LIT:b>\")<EOL>def all_shapes_equal():<EOL><INDENT>return tf.reduce_all(<EOL>input_tensor=tf.equal(<EOL>tf.concat([tf.shape(input=a), tf.shape(input=b)], <NUM_LIT:0>),<EOL>tf.concat([tf.shape(input=b), tf.shape(input=a)], <NUM_LIT:0>)))<EOL><DEDENT>return tf.cond(<EOL>pred=tf.equal(tf.rank(a), tf.rank(b)),<EOL>true_fn=all_shapes_equal,<EOL>false_fn=lambda: tf.constant(False))<EOL>", "docstring": "Returns whether a and b have the same dynamic shape.\n\n    Args:\n      a: `Tensor`\n      b: `Tensor`\n\n    Returns:\n      `bool` `Tensor` representing if both tensors have the same shape.", "id": "f15574:m15"}
{"signature": "def make_non_negative_axis(axis, rank):", "body": "axis = tf.convert_to_tensor(value=axis, name=\"<STR_LIT>\")<EOL>rank = tf.convert_to_tensor(value=rank, name=\"<STR_LIT>\")<EOL>axis_ = tf.get_static_value(axis)<EOL>rank_ = tf.get_static_value(rank)<EOL>if axis_ is not None and rank_ is not None:<EOL><INDENT>is_scalar = axis_.ndim == <NUM_LIT:0><EOL>if is_scalar:<EOL><INDENT>axis_ = [axis_]<EOL><DEDENT>positive_axis = []<EOL>for a_ in axis_:<EOL><INDENT>if a_ < <NUM_LIT:0>:<EOL><INDENT>positive_axis.append(rank_ + a_)<EOL><DEDENT>else:<EOL><INDENT>positive_axis.append(a_)<EOL><DEDENT><DEDENT>if is_scalar:<EOL><INDENT>positive_axis = positive_axis[<NUM_LIT:0>]<EOL><DEDENT>return tf.convert_to_tensor(value=positive_axis, dtype=axis.dtype)<EOL><DEDENT>return tf.where(axis < <NUM_LIT:0>, rank + axis, axis)<EOL>", "docstring": "Make (possibly negatively indexed) `axis` argument non-negative.", "id": "f15574:m10"}
{"signature": "def get_broadcast_shape(*tensors):", "body": "<EOL>s_shape = tensors[<NUM_LIT:0>].shape<EOL>for t in tensors[<NUM_LIT:1>:]:<EOL><INDENT>s_shape = tf.broadcast_static_shape(s_shape, t.shape)<EOL><DEDENT>if tensorshape_util.is_fully_defined(s_shape):<EOL><INDENT>return tensorshape_util.as_list(s_shape)<EOL><DEDENT>d_shape = tf.shape(input=tensors[<NUM_LIT:0>])<EOL>for t in tensors[<NUM_LIT:1>:]:<EOL><INDENT>d_shape = tf.broadcast_dynamic_shape(d_shape, tf.shape(input=t))<EOL><DEDENT>return d_shape<EOL>", "docstring": "Get broadcast shape as a Python list of integers (preferred) or `Tensor`.\n\n    Args:\n      *tensors:  One or more `Tensor` objects (already converted!).\n\n    Returns:\n      broadcast shape:  Python list (if shapes determined statically), otherwise\n        an `int32` `Tensor`.", "id": "f15574:m5"}
{"signature": "def _is_known_unsigned_by_dtype(dt):", "body": "return {<EOL>tf.bool: True,<EOL>tf.uint8: True,<EOL>tf.uint16: True,<EOL>}.get(dt.base_dtype, False)<EOL>", "docstring": "Helper returning True if dtype is known to be unsigned.", "id": "f15574:m18"}
{"signature": "def make_tril_scale(loc=None,<EOL>scale_tril=None,<EOL>scale_diag=None,<EOL>scale_identity_multiplier=None,<EOL>shape_hint=None,<EOL>validate_args=False,<EOL>assert_positive=False,<EOL>name=None):", "body": "def _maybe_attach_assertion(x):<EOL><INDENT>if not validate_args:<EOL><INDENT>return x<EOL><DEDENT>if assert_positive:<EOL><INDENT>return with_dependencies([<EOL>assert_util.assert_positive(<EOL>tf.linalg.diag_part(x), message=\"<STR_LIT>\"),<EOL>], x)<EOL><DEDENT>return with_dependencies([<EOL>assert_util.assert_none_equal(<EOL>tf.linalg.diag_part(x),<EOL>tf.zeros([], x.dtype),<EOL>message=\"<STR_LIT>\"),<EOL>], x)<EOL><DEDENT>with tf.name_scope(name or \"<STR_LIT>\"):<EOL><INDENT>dtype = dtype_util.common_dtype(<EOL>[loc, scale_tril, scale_diag, scale_identity_multiplier],<EOL>preferred_dtype=tf.float32)<EOL>loc = _convert_to_tensor(loc, name=\"<STR_LIT>\", dtype=dtype)<EOL>scale_tril = _convert_to_tensor(scale_tril, name=\"<STR_LIT>\", dtype=dtype)<EOL>scale_diag = _convert_to_tensor(scale_diag, name=\"<STR_LIT>\", dtype=dtype)<EOL>scale_identity_multiplier = _convert_to_tensor(<EOL>scale_identity_multiplier,<EOL>name=\"<STR_LIT>\",<EOL>dtype=dtype)<EOL><DEDENT>if scale_tril is not None:<EOL><INDENT>scale_tril = tf.linalg.band_part(scale_tril, -<NUM_LIT:1>, <NUM_LIT:0>)  <EOL>tril_diag = tf.linalg.diag_part(scale_tril)<EOL>if scale_diag is not None:<EOL><INDENT>tril_diag += scale_diag<EOL><DEDENT>if scale_identity_multiplier is not None:<EOL><INDENT>tril_diag += scale_identity_multiplier[..., tf.newaxis]<EOL><DEDENT>scale_tril = tf.linalg.set_diag(scale_tril, tril_diag)<EOL>return tf.linalg.LinearOperatorLowerTriangular(<EOL>tril=_maybe_attach_assertion(scale_tril),<EOL>is_non_singular=True,<EOL>is_self_adjoint=False,<EOL>is_positive_definite=assert_positive)<EOL><DEDENT>return make_diag_scale(<EOL>loc=loc,<EOL>scale_diag=scale_diag,<EOL>scale_identity_multiplier=scale_identity_multiplier,<EOL>shape_hint=shape_hint,<EOL>validate_args=validate_args,<EOL>assert_positive=assert_positive,<EOL>name=name)<EOL>", "docstring": "Creates a LinearOperator representing a lower triangular matrix.\n\n    Args:\n      loc: Floating-point `Tensor`. This is used for inferring shape in the case\n        where only `scale_identity_multiplier` is set.\n      scale_tril: Floating-point `Tensor` representing the diagonal matrix.\n        `scale_diag` has shape [N1, N2, ...  k, k], which represents a k x k lower\n        triangular matrix. When `None` no `scale_tril` term is added to the\n        LinearOperator. The upper triangular elements above the diagonal are\n        ignored.\n      scale_diag: Floating-point `Tensor` representing the diagonal matrix.\n        `scale_diag` has shape [N1, N2, ...  k], which represents a k x k diagonal\n        matrix. When `None` no diagonal term is added to the LinearOperator.\n      scale_identity_multiplier: floating point rank 0 `Tensor` representing a\n        scaling done to the identity matrix. When `scale_identity_multiplier =\n        scale_diag = scale_tril = None` then `scale += IdentityMatrix`. Otherwise\n        no scaled-identity-matrix is added to `scale`.\n      shape_hint: scalar integer `Tensor` representing a hint at the dimension of\n        the identity matrix when only `scale_identity_multiplier` is set.\n      validate_args: Python `bool` indicating whether arguments should be checked\n        for correctness.\n      assert_positive: Python `bool` indicating whether LinearOperator should be\n        checked for being positive definite.\n      name: Python `str` name given to ops managed by this object.\n\n    Returns:\n      `LinearOperator` representing a lower triangular matrix.\n\n    Raises:\n      ValueError:  If only `scale_identity_multiplier` is set and `loc` and\n        `shape_hint` are both None.", "id": "f15574:m2"}
{"signature": "def prefer_static_value(x):", "body": "static_x = tf.get_static_value(x)<EOL>if static_x is not None:<EOL><INDENT>return static_x<EOL><DEDENT>return x<EOL>", "docstring": "Return static value of tensor `x` if available, else `x`.\n\n    Args:\n      x: `Tensor` (already converted).\n\n    Returns:\n      Numpy array (if static value is obtainable), else `Tensor`.", "id": "f15574:m33"}
{"signature": "def softplus_inverse(x, name=None):", "body": "with tf.name_scope(name or \"<STR_LIT>\"):<EOL><INDENT>x = tf.convert_to_tensor(value=x, name=\"<STR_LIT:x>\")<EOL>threshold = np.log(np.finfo(dtype_util.as_numpy_dtype(x.dtype)).eps) + <NUM_LIT><EOL>is_too_small = tf.less(x, np.exp(threshold))<EOL>is_too_large = tf.greater(x, -threshold)<EOL>too_small_value = tf.math.log(x)<EOL>too_large_value = x<EOL>x = tf.where(tf.logical_or(is_too_small, is_too_large), tf.ones_like(x), x)<EOL>y = x + tf.math.log(-tf.math.expm1(-x))  <EOL>return tf.where(is_too_small, too_small_value,<EOL>tf.where(is_too_large, too_large_value, y))<EOL><DEDENT>", "docstring": "Computes the inverse softplus, i.e., x = softplus_inverse(softplus(x)).\n\n    Mathematically this op is equivalent to:\n\n    ```none\n    softplus_inverse = log(exp(x) - 1.)\n    ```\n\n    Args:\n      x: `Tensor`. Non-negative (not enforced), floating-point.\n      name: A name for the operation (optional).\n\n    Returns:\n      `Tensor`. Has the same type/shape as input `x`.", "id": "f15574:m39"}
{"signature": "def get_logits_and_probs(logits=None,<EOL>probs=None,<EOL>multidimensional=False,<EOL>validate_args=False,<EOL>name=\"<STR_LIT>\",<EOL>dtype=None):", "body": "if dtype is None:<EOL><INDENT>dtype = dtype_util.common_dtype([probs, logits], preferred_dtype=tf.float32)<EOL><DEDENT>with tf.name_scope(name):<EOL><INDENT>if (probs is None) == (logits is None):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if probs is None:<EOL><INDENT>logits = tf.convert_to_tensor(value=logits, name=\"<STR_LIT>\", dtype=dtype)<EOL>if not dtype_util.is_floating(logits.dtype):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if multidimensional:<EOL><INDENT>if validate_args:<EOL><INDENT>logits = embed_check_categorical_event_shape(logits)<EOL><DEDENT>return logits, tf.nn.softmax(logits, name=\"<STR_LIT>\")<EOL><DEDENT>return logits, tf.sigmoid(logits, name=\"<STR_LIT>\")<EOL><DEDENT>probs = tf.convert_to_tensor(value=probs, name=\"<STR_LIT>\", dtype=dtype)<EOL>if not dtype_util.is_floating(probs.dtype):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if validate_args:<EOL><INDENT>with tf.name_scope(\"<STR_LIT>\"):<EOL><INDENT>one = tf.constant(<NUM_LIT:1.>, probs.dtype)<EOL>dependencies = [assert_util.assert_non_negative(probs)]<EOL>if multidimensional:<EOL><INDENT>probs = embed_check_categorical_event_shape(probs)<EOL>dependencies += [<EOL>assert_util.assert_near(<EOL>tf.reduce_sum(input_tensor=probs, axis=-<NUM_LIT:1>),<EOL>one,<EOL>message=\"<STR_LIT>\")<EOL>]<EOL><DEDENT>else:<EOL><INDENT>dependencies += [<EOL>assert_util.assert_less_equal(<EOL>probs, one, message=\"<STR_LIT>\")<EOL>]<EOL><DEDENT>probs = with_dependencies(dependencies, probs)<EOL><DEDENT><DEDENT>with tf.name_scope(\"<STR_LIT>\"):<EOL><INDENT>if multidimensional:<EOL><INDENT>return tf.math.log(probs), probs<EOL><DEDENT>return tf.math.log(probs) - tf.math.log1p(-<NUM_LIT:1.> * probs), probs<EOL><DEDENT><DEDENT>", "docstring": "Converts logit to probabilities (or vice-versa), and returns both.\n\n    Args:\n      logits: Floating-point `Tensor` representing log-odds.\n      probs: Floating-point `Tensor` representing probabilities.\n      multidimensional: Python `bool`, default `False`. If `True`, represents\n        whether the last dimension of `logits` or `probs`, a `[N1, N2, ...  k]`\n        dimensional tensor, representing the logit or probability of `shape[-1]`\n        classes.\n      validate_args: Python `bool`, default `False`. When `True`, either assert `0\n        <= probs <= 1` (if not `multidimensional`) or that the last dimension of\n        `probs` sums to one.\n      name: A name for this operation (optional).\n      dtype: `tf.DType` to prefer when converting args to `Tensor`s.\n\n    Returns:\n      logits, probs: Tuple of `Tensor`s. If `probs` has an entry that is `0` or\n        `1`, then the corresponding entry in the returned logit will be `-Inf` and\n        `Inf` respectively.\n\n    Raises:\n      ValueError: if neither `probs` nor `logits` were passed in, or both were.", "id": "f15574:m17"}
{"signature": "@hps.composite<EOL>def broadcasting_shapes(draw, target_shape, n):", "body": "target_shape = tf.TensorShape(target_shape)<EOL>target_rank = target_shape.ndims<EOL>result = []<EOL>current_shape = tf.TensorShape([])<EOL>for is_last in [False] * (n-<NUM_LIT:1>) + [True]:<EOL><INDENT>next_rank, force_fullsize_dim = _compute_rank_and_fullsize_reqd(<EOL>draw, target_shape, current_shape, is_last=is_last)<EOL>next_shape = target_shape[target_rank - next_rank:].as_list()<EOL>for i, force_fullsize in enumerate(force_fullsize_dim):<EOL><INDENT>if not force_fullsize and draw(hps.booleans()):<EOL><INDENT>next_shape[i] = <NUM_LIT:1><EOL><DEDENT><DEDENT>next_shape = tf.TensorShape(next_shape)<EOL>current_shape = tf.broadcast_static_shape(current_shape, next_shape)<EOL>result.append(next_shape)<EOL><DEDENT>return result<EOL>", "docstring": "Draws a set of `n` shapes that broadcast to `target_shape`.\n\n    For each shape we need to choose its rank, and whether or not each axis i is 1\n    or target_shape[i]. This function chooses a set of `n` shapes that have\n    possibly mismatched ranks, and possibly broadcasting axes, with the promise\n    that the broadcast of the set of all shapes matches `target_shape`.\n\n    Args:\n      draw: Hypothesis sampler.\n      target_shape: The target (fully-defined) batch shape.\n      n: `int`, the number of shapes to draw.\n\n    Returns:\n      shapes: Sequence of `tf.TensorShape` such that the set of shapes broadcast\n        to `target_shape`. The shapes are fully defined.", "id": "f15575:m2"}
{"signature": "def dims(x):", "body": "if isinstance(x, tf.TensorShape):<EOL><INDENT>return x.dims<EOL><DEDENT>r = tf.TensorShape(x).dims<EOL>return None if r is None else list(map(tf.compat.dimension_value, r))<EOL>", "docstring": "Returns a list of dimension sizes, or `None` if `rank` is unknown.\n\n    For more details, see `help(tf.TensorShape.dims)`.\n\n    Args:\n      x: object representing a shape; convertible to `tf.TensorShape`.\n\n    Returns:\n      shape_as_list: list of sizes or `None` values representing each\n        dimensions size if known. A size is `tf.Dimension` if input is a\n        `tf.TensorShape` and an `int` otherwise.", "id": "f15576:m5"}
{"signature": "def constant_value_as_shape(tensor):  ", "body": "shape = tf.get_static_value(tensor)<EOL>if shape is not None:<EOL><INDENT>return [None if dim == -<NUM_LIT:1> else dim for dim in shape]<EOL><DEDENT>return tensor_util.constant_value_as_shape(tensor)<EOL>", "docstring": "A version of `constant_value()` that returns a `TensorShape`.\n\n    This version should be used when a constant tensor value is\n    interpreted as a (possibly partial) shape, e.g. in the shape\n    function for `tf.reshape()`. By explicitly requesting a\n    `TensorShape` as the return value, it is possible to represent\n    unknown dimensions; by contrast, `constant_value()` is\n    all-or-nothing.\n\n    Args:\n      tensor: The rank-0 or rank-1 Tensor to be evaluated.\n\n    Returns:\n      A `TensorShape` based on the constant value of the given `tensor`.\n\n    Raises:\n      ValueError: If the shape is rank-0 and is not statically known to be -1.", "id": "f15576:m4"}
{"signature": "def rank(x):", "body": "return tf.TensorShape(x).rank<EOL>", "docstring": "Returns the rank of this shape, or `None` if it is unspecified.\n\n    For more details, see `help(tf.TensorShape.rank)`.\n\n    Args:\n      x: object representing a shape; convertible to `tf.TensorShape`.\n\n    Returns:\n      rank: `int` representing the number of shape dimensions.", "id": "f15576:m10"}
{"signature": "def assert_is_compatible_with(x, other):", "body": "tf.TensorShape(x).assert_is_compatible_with(other)<EOL>", "docstring": "Raises exception if `x` and `other` do not represent the same shape.\n\n    This method can be used to assert that there exists a shape that both\n    `x` and `other` represent.\n\n    For more details, see `help(tf.TensorShape.assert_is_compatible_with)`.\n\n    Args:\n      x: object representing a shape; convertible to `tf.TensorShape`.\n      other: object representing a shape; convertible to `tf.TensorShape`.\n\n    Returns:\n      None\n\n    Raises:\n      ValueError: If `x` and `other` do not represent the same shape.", "id": "f15576:m2"}
{"signature": "def assertAllNan(self, a):", "body": "is_nan = np.isnan(self._GetNdArray(a))<EOL>all_true = np.ones_like(is_nan, dtype=np.bool)<EOL>self.assertAllEqual(all_true, is_nan)<EOL>", "docstring": "Assert that every entry in a `Tensor` is NaN.\n\n        Args:\n          a: A `Tensor` whose entries must be verified as NaN.", "id": "f15579:c0:m1"}
{"signature": "def base_equal(a, b):", "body": "return base_dtype(a) == base_dtype(b)<EOL>", "docstring": "Returns `True` if base dtypes are identical.", "id": "f15581:m2"}
{"signature": "def max(dtype):  ", "body": "dtype = tf.as_dtype(dtype)<EOL>if hasattr(dtype, '<STR_LIT>'):<EOL><INDENT>return dtype.max<EOL><DEDENT>use_finfo = is_floating(dtype) or is_complex(dtype)<EOL>return np.finfo(dtype).max if use_finfo else np.iinfo(dtype).max<EOL>", "docstring": "Returns the maximum representable value in this data type.", "id": "f15581:m8"}
{"signature": "def is_bool(dtype):", "body": "dtype = tf.as_dtype(dtype)<EOL>if hasattr(dtype, '<STR_LIT>'):<EOL><INDENT>return dtype.is_bool<EOL><DEDENT>return np.dtype(dtype).kind == '<STR_LIT:b>'<EOL>", "docstring": "Returns whether this is a boolean data type.", "id": "f15581:m4"}
{"signature": "def erfinv(x, name=\"<STR_LIT>\"):", "body": "with tf.name_scope(name):<EOL><INDENT>x = tf.convert_to_tensor(value=x, name=\"<STR_LIT:x>\")<EOL>if dtype_util.as_numpy_dtype(x.dtype) not in [np.float32, np.float64]:<EOL><INDENT>raise TypeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(dtype_util.name(x.dtype)))<EOL><DEDENT>return ndtri((x + <NUM_LIT:1.>) / <NUM_LIT>) / np.sqrt(<NUM_LIT>)<EOL><DEDENT>", "docstring": "The inverse function for erf, the error function.\n\n    Args:\n      x: `Tensor` of type `float32`, `float64`.\n      name: Python string. A name for the operation (default=\"erfinv\").\n\n    Returns:\n      x: `Tensor` with `dtype=x.dtype`.\n\n    Raises:\n      TypeError: if `x` is not floating-type.", "id": "f15582:m7"}
{"signature": "def log_cdf_laplace(x, name=\"<STR_LIT>\"):", "body": "with tf.name_scope(name):<EOL><INDENT>x = tf.convert_to_tensor(value=x, name=\"<STR_LIT:x>\")<EOL>lower_solution = -np.log(<NUM_LIT>) + x<EOL>safe_exp_neg_x = tf.exp(-tf.abs(x))<EOL>upper_solution = tf.math.log1p(-<NUM_LIT:0.5> * safe_exp_neg_x)<EOL>return tf.where(x < <NUM_LIT:0.>, lower_solution, upper_solution)<EOL><DEDENT>", "docstring": "Log Laplace distribution function.\n\n    This function calculates `Log[L(x)]`, where `L(x)` is the cumulative\n    distribution function of the Laplace distribution, i.e.\n\n    ```L(x) := 0.5 * int_{-infty}^x e^{-|t|} dt```\n\n    For numerical accuracy, `L(x)` is computed in different ways depending on `x`,\n\n    ```\n    x <= 0:\n      Log[L(x)] = Log[0.5] + x, which is exact\n\n    0 < x:\n      Log[L(x)] = Log[1 - 0.5 * e^{-x}], which is exact\n    ```\n\n    Args:\n      x: `Tensor` of type `float32`, `float64`.\n      name: Python string. A name for the operation (default=\"log_ndtr\").\n\n    Returns:\n      `Tensor` with `dtype=x.dtype`.\n\n    Raises:\n      TypeError: if `x.dtype` is not handled.", "id": "f15582:m9"}
{"signature": "def log_ndtr(x, series_order=<NUM_LIT:3>, name=\"<STR_LIT>\"):", "body": "if not isinstance(series_order, int):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if series_order < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if series_order > <NUM_LIT:30>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>with tf.name_scope(name):<EOL><INDENT>x = tf.convert_to_tensor(value=x, name=\"<STR_LIT:x>\")<EOL>if dtype_util.base_equal(x.dtype, tf.float64):<EOL><INDENT>lower_segment = LOGNDTR_FLOAT64_LOWER<EOL>upper_segment = LOGNDTR_FLOAT64_UPPER<EOL><DEDENT>elif dtype_util.base_equal(x.dtype, tf.float32):<EOL><INDENT>lower_segment = LOGNDTR_FLOAT32_LOWER<EOL>upper_segment = LOGNDTR_FLOAT32_UPPER<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % x.dtype)<EOL><DEDENT>return tf.where(<EOL>tf.greater(x, upper_segment),<EOL>-_ndtr(-x),  <EOL>tf.where(<EOL>tf.greater(x, lower_segment),<EOL>tf.math.log(_ndtr(tf.maximum(x, lower_segment))),<EOL>_log_ndtr_lower(tf.minimum(x, lower_segment), series_order)))<EOL><DEDENT>", "docstring": "Log Normal distribution function.\n\n    For details of the Normal distribution function see `ndtr`.\n\n    This function calculates `(log o ndtr)(x)` by either calling `log(ndtr(x))` or\n    using an asymptotic series. Specifically:\n    - For `x > upper_segment`, use the approximation `-ndtr(-x)` based on\n      `log(1-x) ~= -x, x << 1`.\n    - For `lower_segment < x <= upper_segment`, use the existing `ndtr` technique\n      and take a log.\n    - For `x <= lower_segment`, we use the series approximation of erf to compute\n      the log CDF directly.\n\n    The `lower_segment` is set based on the precision of the input:\n\n    ```\n    lower_segment = { -20,  x.dtype=float64\n                    { -10,  x.dtype=float32\n    upper_segment = {   8,  x.dtype=float64\n                    {   5,  x.dtype=float32\n    ```\n\n    When `x < lower_segment`, the `ndtr` asymptotic series approximation is:\n\n    ```\n       ndtr(x) = scale * (1 + sum) + R_N\n       scale   = exp(-0.5 x**2) / (-x sqrt(2 pi))\n       sum     = Sum{(-1)^n (2n-1)!! / (x**2)^n, n=1:N}\n       R_N     = O(exp(-0.5 x**2) (2N+1)!! / |x|^{2N+3})\n    ```\n\n    where `(2n-1)!! = (2n-1) (2n-3) (2n-5) ...  (3) (1)` is a\n    [double-factorial](https://en.wikipedia.org/wiki/Double_factorial).\n\n\n    Args:\n      x: `Tensor` of type `float32`, `float64`.\n      series_order: Positive Python `integer`. Maximum depth to\n        evaluate the asymptotic expansion. This is the `N` above.\n      name: Python string. A name for the operation (default=\"log_ndtr\").\n\n    Returns:\n      log_ndtr: `Tensor` with `dtype=x.dtype`.\n\n    Raises:\n      TypeError: if `x.dtype` is not handled.\n      TypeError: if `series_order` is a not Python `integer.`\n      ValueError:  if `series_order` is not in `[0, 30]`.", "id": "f15582:m4"}
{"signature": "def _double_factorial(n):", "body": "return np.prod(np.arange(n, <NUM_LIT:1>, -<NUM_LIT:2>))<EOL>", "docstring": "The double factorial function for small Python integer `n`.", "id": "f15582:m8"}
{"signature": "def _log_ndtr_lower(x, series_order):", "body": "x_2 = tf.square(x)<EOL>log_scale = -<NUM_LIT:0.5> * x_2 - tf.math.log(-x) - <NUM_LIT:0.5> * np.log(<NUM_LIT> * np.pi)<EOL>return log_scale + tf.math.log(_log_ndtr_asymptotic_series(x, series_order))<EOL>", "docstring": "Asymptotic expansion version of `Log[cdf(x)]`, appropriate for `x<<-1`.", "id": "f15582:m5"}
{"signature": "def expectation_importance_sampler_logspace(<EOL>log_f,<EOL>log_p,<EOL>sampling_dist_q,<EOL>z=None,<EOL>n=None,<EOL>seed=None,<EOL>name='<STR_LIT>'):", "body": "q = sampling_dist_q<EOL>with tf.name_scope(name):<EOL><INDENT>z = _get_samples(q, z, n, seed)<EOL>log_values = log_f(z) + log_p(z) - q.log_prob(z)<EOL>return _logspace_mean(log_values)<EOL><DEDENT>", "docstring": "r\"\"\"Importance sampling with a positive function, in log-space.\n\n    With \\\\(p(z) := exp^{log_p(z)}\\\\), and \\\\(f(z) = exp{log_f(z)}\\\\),\n    this `Op` returns\n\n    \\\\(Log[ n^{-1} sum_{i=1}^n [ f(z_i) p(z_i) / q(z_i) ] ],  z_i ~ q,\\\\)\n    \\\\(\\approx Log[ E_q[ f(Z) p(Z) / q(Z) ] ]\\\\)\n    \\\\(=       Log[E_p[f(Z)]]\\\\)\n\n    This integral is done in log-space with max-subtraction to better handle the\n    often extreme values that `f(z) p(z) / q(z)` can take on.\n\n    In contrast to `expectation_importance_sampler`, this `Op` returns values in\n    log-space.\n\n\n    User supplies either `Tensor` of samples `z`, or number of samples to draw `n`\n\n    Args:\n      log_f: Callable mapping samples from `sampling_dist_q` to `Tensors` with\n        shape broadcastable to `q.batch_shape`.\n        For example, `log_f` works \"just like\" `sampling_dist_q.log_prob`.\n      log_p:  Callable mapping samples from `sampling_dist_q` to `Tensors` with\n        shape broadcastable to `q.batch_shape`.\n        For example, `log_p` works \"just like\" `q.log_prob`.\n      sampling_dist_q:  The sampling distribution.\n        `tfp.distributions.Distribution`.\n        `float64` `dtype` recommended.\n        `log_p` and `q` should be supported on the same set.\n      z:  `Tensor` of samples from `q`, produced by `q.sample` for some `n`.\n      n:  Integer `Tensor`.  Number of samples to generate if `z` is not provided.\n      seed:  Python integer to seed the random number generator.\n      name:  A name to give this `Op`.\n\n    Returns:\n      Logarithm of the importance sampling estimate.  `Tensor` with `shape` equal\n        to batch shape of `q`, and `dtype` = `q.dtype`.", "id": "f15583:m1"}
{"signature": "def common_dtype(args_list, preferred_dtype=None):", "body": "dtype = None<EOL>preferred_dtype = (None if preferred_dtype is None<EOL>else tf.as_dtype(preferred_dtype))<EOL>for a in tf.nest.flatten(args_list):<EOL><INDENT>if hasattr(a, '<STR_LIT>'):<EOL><INDENT>dt = tf.as_dtype(a.dtype)<EOL><DEDENT>else:<EOL><INDENT>continue<EOL><DEDENT>if dtype is None:<EOL><INDENT>dtype = dt<EOL><DEDENT>elif dtype != dt:<EOL><INDENT>raise TypeError('<STR_LIT>'.format(dtype, dt))<EOL><DEDENT><DEDENT>if dtype is None and preferred_dtype is None:<EOL><INDENT>return None<EOL><DEDENT>return (preferred_dtype if dtype is None else dtype).as_numpy_dtype<EOL>", "docstring": "Returns explict dtype from `args_list` if exists, else preferred_dtype.", "id": "f15589:m2"}
{"signature": "def _reduce_logsumexp(input_tensor, axis=None, keepdims=False, name=None):  ", "body": "try:<EOL><INDENT>return scipy_special.logsumexp(<EOL>input_tensor, axis=_astuple(axis), keepdims=keepdims)<EOL><DEDENT>except NotImplementedError:<EOL><INDENT>m = _max_mask_non_finite(input_tensor, axis=axis, keepdims=True)<EOL>y = input_tensor - m<EOL>y = np.exp(y, out=y)<EOL>return m + np.log(np.sum(y, axis=_astuple(axis), keepdims=keepdims))<EOL><DEDENT>", "docstring": "Computes `log(sum(exp(input_tensor))) along the specified axis.", "id": "f15590:m5"}
{"signature": "@contextlib.contextmanager<EOL><INDENT>def assertRaisesWithPredicateMatch(self,<EOL>exception_type,<EOL>expected_err_re_or_predicate):<EOL><DEDENT>", "body": "<EOL>if not tf.executing_eagerly():<EOL><INDENT>yield<EOL>return<EOL><DEDENT>with super(TestCase, self).assertRaisesWithPredicateMatch(<EOL>exception_type, expected_err_re_or_predicate):<EOL><INDENT>yield<EOL><DEDENT>", "docstring": "Returns a context manager to enclose code expected to raise an exception.\n\n        If the exception is an OpError, the op stack is also included in the message\n        predicate search.\n\n        Args:\n          exception_type: The expected type of exception that should be raised.\n          expected_err_re_or_predicate: If this is callable, it should be a function\n            of one argument that inspects the passed-in exception and returns True\n            (success) or False (please fail the test). Otherwise, the error message\n            is expected to match this regular expression partially.\n\n        Returns:\n          A context manager to surround code that is expected to raise an\n          exception.", "id": "f15595:c0:m2"}
{"signature": "def _copy_docstring(original_fn, new_fn):", "body": "original_spec = tf_inspect.getfullargspec(original_fn)<EOL>new_spec = tf_inspect.getfullargspec(new_fn)<EOL>if original_spec != new_spec:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'.format(<EOL>original_spec, new_spec, original_fn))<EOL><DEDENT>@decorator.decorator<EOL>def wrap(wrapped_fn, *args, **kwargs):<EOL><INDENT>del wrapped_fn<EOL>return new_fn(*args, **kwargs)<EOL><DEDENT>return wrap(original_fn)<EOL>", "docstring": "Wraps new_fn with the doc of original_fn.", "id": "f15604:m2"}
{"signature": "def case(pred_fn_pairs, default=None, exclusive=False, name='<STR_LIT>'):", "body": "return control_flow_ops._case_helper(  <EOL>cond, pred_fn_pairs, default, exclusive, name, allow_python_preds=True)<EOL>", "docstring": "Like tf.case, except attempts to statically evaluate predicates.\n\n    If any predicate in `pred_fn_pairs` is a bool or has a constant value, the\n    associated callable will be called or omitted depending on its value.\n    Otherwise this functions like tf.case.\n\n    Args:\n      pred_fn_pairs: Dict or list of pairs of a boolean scalar tensor and a\n                     callable which returns a list of tensors.\n      default: Optional callable that returns a list of tensors.\n      exclusive: True iff at most one predicate is allowed to evaluate to `True`.\n      name: A name for this operation (optional).\n\n    Returns:\n      The tensors returned by the first pair whose predicate evaluated to True, or\n      those returned by `default` if none does.\n\n    Raises:\n      TypeError: If `pred_fn_pairs` is not a list/dictionary.\n      TypeError: If `pred_fn_pairs` is a list but does not contain 2-tuples.\n      TypeError: If `fns[i]` is not callable for any i, or `default` is not\n                 callable.", "id": "f15604:m7"}
{"signature": "def _finish_prob_for_one_fiber(self, y, x, ildj, event_ndims,<EOL>**distribution_kwargs):", "body": "x = self._maybe_rotate_dims(x, rotate_right=True)<EOL>prob = self.distribution.prob(x, **distribution_kwargs)<EOL>if self._is_maybe_event_override:<EOL><INDENT>prob = tf.reduce_prod(input_tensor=prob, axis=self._reduce_event_indices)<EOL><DEDENT>prob *= tf.exp(tf.cast(ildj, prob.dtype))<EOL>if self._is_maybe_event_override and isinstance(event_ndims, int):<EOL><INDENT>tensorshape_util.set_shape(<EOL>prob,<EOL>tf.broadcast_static_shape(<EOL>tensorshape_util.with_rank_at_least(y.shape, <NUM_LIT:1>)[:-event_ndims],<EOL>self.batch_shape))<EOL><DEDENT>return prob<EOL>", "docstring": "Finish computation of prob on one element of the inverse image.", "id": "f15607:c0:m13"}
{"signature": "def _pick_scalar_condition(pred, cond_true, cond_false):", "body": "<EOL>pred_ = tf.get_static_value(tf.convert_to_tensor(value=pred))<EOL>if pred_ is None:<EOL><INDENT>return tf.where(pred, cond_true, cond_false)<EOL><DEDENT>return cond_true if pred_ else cond_false<EOL>", "docstring": "Convenience function which chooses the condition based on the predicate.", "id": "f15607:m0"}
{"signature": "def _default_kwargs_split_fn(kwargs):", "body": "return (kwargs.get(\"<STR_LIT>\", {}),<EOL>kwargs.get(\"<STR_LIT>\", {}))<EOL>", "docstring": "Default `kwargs` `dict` getter.", "id": "f15607:m2"}
{"signature": "def range(self, name=\"<STR_LIT>\"):", "body": "with self._name_scope(name):<EOL><INDENT>return self.high - self.low<EOL><DEDENT>", "docstring": "`high - low`.", "id": "f15612:c0:m5"}
{"signature": "def _compute_non_batch_kl(mu_a, sigma_a, mu_b, sigma_b):", "body": "<EOL>sigma_b_inv = np.linalg.inv(sigma_b)<EOL>t = np.trace(sigma_b_inv.dot(sigma_a))<EOL>q = (mu_b - mu_a).dot(sigma_b_inv).dot(mu_b - mu_a)<EOL>k = mu_a.shape[<NUM_LIT:0>]<EOL>l = np.log(np.linalg.det(sigma_b) / np.linalg.det(sigma_a))<EOL>return <NUM_LIT:0.5> * (t + q - k + l)<EOL>", "docstring": "Non-batch KL for N(mu_a, sigma_a), N(mu_b, sigma_b).", "id": "f15614:m0"}
{"signature": "def _extend_support(self, x, f, alt):", "body": "<EOL>scale = self.scale + tf.zeros_like(self.concentration)<EOL>is_invalid = x < scale<EOL>scale = scale + tf.zeros_like(x)<EOL>x = x + tf.zeros_like(scale)<EOL>y = f(tf.where(is_invalid, scale, x))<EOL>if alt == <NUM_LIT:0.>:<EOL><INDENT>alt = tf.zeros_like(y)<EOL><DEDENT>elif alt == <NUM_LIT:1.>:<EOL><INDENT>alt = tf.ones_like(y)<EOL><DEDENT>else:<EOL><INDENT>alt = tf.fill(<EOL>dims=tf.shape(input=y),<EOL>value=dtype_util.as_numpy_dtype(self.dtype)(alt))<EOL><DEDENT>return tf.where(is_invalid, alt, y)<EOL>", "docstring": "Returns `f(x)` if x is in the support, and `alt` otherwise.\n\n        Given `f` which is defined on the support of this distribution\n        (e.g. x > scale), extend the function definition to the real line\n        by defining `f(x) = alt` for `x < scale`.\n\n        Args:\n          x: Floating-point Tensor to evaluate `f` at.\n          f: Lambda that takes in a tensor and returns a tensor. This represents\n            the function who we want to extend the domain of definition.\n          alt: Python or numpy literal representing the value to use for extending\n            the domain.\n        Returns:\n          Tensor representing an extension of `f(x)`.", "id": "f15617:c0:m16"}
{"signature": "@property<EOL><INDENT>def scale(self):<DEDENT>", "body": "return self._scale<EOL>", "docstring": "Scale parameter and also the lower bound of the support.", "id": "f15617:c0:m2"}
{"signature": "def _z(self, x):", "body": "with tf.name_scope(\"<STR_LIT>\"):<EOL><INDENT>return (x - self.loc) / self.scale<EOL><DEDENT>", "docstring": "Standardize input `x` to a unit normal.", "id": "f15618:c0:m22"}
{"signature": "def __init__(self,<EOL>loc=None,<EOL>scale_diag=None,<EOL>scale_identity_multiplier=None,<EOL>validate_args=False,<EOL>allow_nan_stats=True,<EOL>name=\"<STR_LIT>\"):", "body": "parameters = dict(locals())<EOL>with tf.name_scope(name) as name:<EOL><INDENT>with tf.name_scope(\"<STR_LIT>\"):<EOL><INDENT>scale = distribution_util.make_diag_scale(<EOL>loc=loc,<EOL>scale_diag=scale_diag,<EOL>scale_identity_multiplier=scale_identity_multiplier,<EOL>validate_args=False,<EOL>assert_positive=False)<EOL><DEDENT><DEDENT>super(MultivariateNormalDiag, self).__init__(<EOL>loc=loc,<EOL>scale=scale,<EOL>validate_args=validate_args,<EOL>allow_nan_stats=allow_nan_stats,<EOL>name=name)<EOL>self._parameters = parameters<EOL>", "docstring": "Construct Multivariate Normal distribution on `R^k`.\n\n        The `batch_shape` is the broadcast shape between `loc` and `scale`\n        arguments.\n\n        The `event_shape` is given by last dimension of the matrix implied by\n        `scale`. The last dimension of `loc` (if provided) must broadcast with this.\n\n        Recall that `covariance = scale @ scale.T`. A (non-batch) `scale` matrix is:\n\n        ```none\n        scale = diag(scale_diag + scale_identity_multiplier * ones(k))\n        ```\n\n        where:\n\n        * `scale_diag.shape = [k]`, and,\n        * `scale_identity_multiplier.shape = []`.\n\n        Additional leading dimensions (if any) will index batches.\n\n        If both `scale_diag` and `scale_identity_multiplier` are `None`, then\n        `scale` is the Identity matrix.\n\n        Args:\n          loc: Floating-point `Tensor`. If this is set to `None`, `loc` is\n            implicitly `0`. When specified, may have shape `[B1, ..., Bb, k]` where\n            `b >= 0` and `k` is the event size.\n          scale_diag: Non-zero, floating-point `Tensor` representing a diagonal\n            matrix added to `scale`. May have shape `[B1, ..., Bb, k]`, `b >= 0`,\n            and characterizes `b`-batches of `k x k` diagonal matrices added to\n            `scale`. When both `scale_identity_multiplier` and `scale_diag` are\n            `None` then `scale` is the `Identity`.\n          scale_identity_multiplier: Non-zero, floating-point `Tensor` representing\n            a scaled-identity-matrix added to `scale`. May have shape\n            `[B1, ..., Bb]`, `b >= 0`, and characterizes `b`-batches of scaled\n            `k x k` identity matrices added to `scale`. When both\n            `scale_identity_multiplier` and `scale_diag` are `None` then `scale` is\n            the `Identity`.\n          validate_args: Python `bool`, default `False`. When `True` distribution\n            parameters are checked for validity despite possibly degrading runtime\n            performance. When `False` invalid inputs may silently render incorrect\n            outputs.\n          allow_nan_stats: Python `bool`, default `True`. When `True`,\n            statistics (e.g., mean, mode, variance) use the value \"`NaN`\" to\n            indicate the result is undefined. When `False`, an exception is raised\n            if one or more of the statistic's batch members are undefined.\n          name: Python `str` name prefixed to Ops created by this class.\n\n        Raises:\n          ValueError: if at most `scale_identity_multiplier` is specified.", "id": "f15619:c0:m0"}
{"signature": "@property<EOL><INDENT>def logits(self):<DEDENT>", "body": "return self._logits<EOL>", "docstring": "Log-odds of a `1` outcome (vs `0`).", "id": "f15622:c0:m3"}
{"signature": "@property<EOL><INDENT>def probs(self):<DEDENT>", "body": "return self._probs<EOL>", "docstring": "Probability of a `1` outcome (vs `0`).", "id": "f15622:c0:m4"}
{"signature": "@property<EOL><INDENT>def concentration(self):<DEDENT>", "body": "return self._concentration<EOL>", "docstring": "Concentration parameter.", "id": "f15623:c0:m3"}
{"signature": "@property<EOL><INDENT>@deprecation.deprecated(<EOL>\"<STR_LIT>\", \"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>def rate(self):<DEDENT>", "body": "return self._scale<EOL>", "docstring": "Scale parameter.", "id": "f15623:c0:m4"}
{"signature": "@property<EOL><INDENT>def high(self):<DEDENT>", "body": "return self._high<EOL>", "docstring": "Upper boundary of the interval.", "id": "f15625:c0:m3"}
{"signature": "@property<EOL><INDENT>def peak(self):<DEDENT>", "body": "return self._peak<EOL>", "docstring": "Peak of the distribution. Lies in the interval.", "id": "f15625:c0:m4"}
{"signature": "def _pdf_at_peak(self):", "body": "return (self.peak - self.low) / (self.high - self.low)<EOL>", "docstring": "Pdf evaluated at the peak.", "id": "f15625:c0:m5"}
{"signature": "def __init__(self,<EOL>concentration1,<EOL>concentration0,<EOL>validate_args=False,<EOL>allow_nan_stats=True,<EOL>name=\"<STR_LIT>\"):", "body": "parameters = dict(locals())<EOL>with tf.name_scope(name) as name:<EOL><INDENT>dtype = dtype_util.common_dtype([concentration1, concentration0],<EOL>tf.float32)<EOL>self._concentration1 = self._maybe_assert_valid_concentration(<EOL>tf.convert_to_tensor(<EOL>value=concentration1, name=\"<STR_LIT>\", dtype=dtype),<EOL>validate_args)<EOL>self._concentration0 = self._maybe_assert_valid_concentration(<EOL>tf.convert_to_tensor(<EOL>value=concentration0, name=\"<STR_LIT>\", dtype=dtype),<EOL>validate_args)<EOL>self._total_concentration = self._concentration1 + self._concentration0<EOL><DEDENT>super(Beta, self).__init__(<EOL>dtype=dtype,<EOL>validate_args=validate_args,<EOL>allow_nan_stats=allow_nan_stats,<EOL>reparameterization_type=reparameterization.FULLY_REPARAMETERIZED,<EOL>parameters=parameters,<EOL>graph_parents=[<EOL>self._concentration1, self._concentration0,<EOL>self._total_concentration<EOL>],<EOL>name=name)<EOL>", "docstring": "Initialize a batch of Beta distributions.\n\n        Args:\n          concentration1: Positive floating-point `Tensor` indicating mean\n            number of successes; aka \"alpha\". Implies `self.dtype` and\n            `self.batch_shape`, i.e.,\n            `concentration1.shape = [N1, N2, ..., Nm] = self.batch_shape`.\n          concentration0: Positive floating-point `Tensor` indicating mean\n            number of failures; aka \"beta\". Otherwise has same semantics as\n            `concentration1`.\n          validate_args: Python `bool`, default `False`. When `True` distribution\n            parameters are checked for validity despite possibly degrading runtime\n            performance. When `False` invalid inputs may silently render incorrect\n            outputs.\n          allow_nan_stats: Python `bool`, default `True`. When `True`, statistics\n            (e.g., mean, mode, variance) use the value \"`NaN`\" to indicate the\n            result is undefined. When `False`, an exception is raised if one or\n            more of the statistic's batch members are undefined.\n          name: Python `str` name prefixed to Ops created by this class.", "id": "f15628:c0:m0"}
{"signature": "@kullback_leibler.RegisterKL(Beta, Beta)<EOL>def _kl_beta_beta(d1, d2, name=None):", "body": "def delta(fn, is_property=True):<EOL><INDENT>fn1 = getattr(d1, fn)<EOL>fn2 = getattr(d2, fn)<EOL>return (fn2 - fn1) if is_property else (fn2() - fn1())<EOL><DEDENT>with tf.name_scope(name or \"<STR_LIT>\"):<EOL><INDENT>return (delta(\"<STR_LIT>\", is_property=False) -<EOL>tf.math.digamma(d1.concentration1) * delta(\"<STR_LIT>\") -<EOL>tf.math.digamma(d1.concentration0) * delta(\"<STR_LIT>\") +<EOL>(tf.math.digamma(d1.total_concentration) *<EOL>delta(\"<STR_LIT>\")))<EOL><DEDENT>", "docstring": "Calculate the batchwise KL divergence KL(d1 || d2) with d1 and d2 Beta.\n\n    Args:\n      d1: instance of a Beta distribution object.\n      d2: instance of a Beta distribution object.\n      name: (optional) Name to use for created operations.\n        default is \"kl_beta_beta\".\n\n    Returns:\n      Batchwise KL(d1 || d2)", "id": "f15628:m0"}
{"signature": "@property<EOL><INDENT>def logits(self):<DEDENT>", "body": "return self._logits<EOL>", "docstring": "Log-odds of a `1` outcome (vs `0`).", "id": "f15630:c0:m2"}
{"signature": "def __init__(self,<EOL>logits=None,<EOL>probs=None,<EOL>validate_args=False,<EOL>allow_nan_stats=True,<EOL>name=\"<STR_LIT>\"):", "body": "parameters = dict(locals())<EOL>with tf.name_scope(name) as name:<EOL><INDENT>self._logits, self._probs = distribution_util.get_logits_and_probs(<EOL>logits, probs, validate_args=validate_args, name=name)<EOL>with tf.control_dependencies(<EOL>[assert_util.assert_positive(self._probs)] if validate_args else []):<EOL><INDENT>self._probs = tf.identity(self._probs, name=\"<STR_LIT>\")<EOL><DEDENT><DEDENT>super(Geometric, self).__init__(<EOL>dtype=self._probs.dtype,<EOL>reparameterization_type=reparameterization.NOT_REPARAMETERIZED,<EOL>validate_args=validate_args,<EOL>allow_nan_stats=allow_nan_stats,<EOL>parameters=parameters,<EOL>graph_parents=[self._probs, self._logits],<EOL>name=name)<EOL>", "docstring": "Construct Geometric distributions.\n\n        Args:\n          logits: Floating-point `Tensor` with shape `[B1, ..., Bb]` where `b >= 0`\n            indicates the number of batch dimensions. Each entry represents logits\n            for the probability of success for independent Geometric distributions\n            and must be in the range `(-inf, inf]`. Only one of `logits` or `probs`\n            should be specified.\n          probs: Positive floating-point `Tensor` with shape `[B1, ..., Bb]`\n            where `b >= 0` indicates the number of batch dimensions. Each entry\n            represents the probability of success for independent Geometric\n            distributions and must be in the range `(0, 1]`. Only one of `logits`\n            or `probs` should be specified.\n          validate_args: Python `bool`, default `False`. When `True` distribution\n            parameters are checked for validity despite possibly degrading runtime\n            performance. When `False` invalid inputs may silently render incorrect\n            outputs.\n          allow_nan_stats: Python `bool`, default `True`. When `True`, statistics\n            (e.g., mean, mode, variance) use the value \"`NaN`\" to indicate the\n            result is undefined. When `False`, an exception is raised if one or\n            more of the statistic's batch members are undefined.\n          name: Python `str` name prefixed to Ops created by this class.", "id": "f15630:c0:m0"}
{"signature": "def __init__(self,<EOL>distribution_fn,<EOL>sample0=None,<EOL>num_steps=None,<EOL>validate_args=False,<EOL>allow_nan_stats=True,<EOL>name=\"<STR_LIT>\"):", "body": "parameters = dict(locals())<EOL>with tf.name_scope(name) as name:<EOL><INDENT>self._distribution_fn = distribution_fn<EOL>self._sample0 = sample0<EOL>self._distribution0 = (distribution_fn() if sample0 is None<EOL>else distribution_fn(sample0))<EOL>if num_steps is None:<EOL><INDENT>num_steps = tensorshape_util.num_elements(<EOL>self._distribution0.event_shape)<EOL>if num_steps is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if num_steps < <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(num_steps))<EOL><DEDENT>self._num_steps = num_steps<EOL><DEDENT>super(Autoregressive, self).__init__(<EOL>dtype=self._distribution0.dtype,<EOL>reparameterization_type=self._distribution0.reparameterization_type,<EOL>validate_args=validate_args,<EOL>allow_nan_stats=allow_nan_stats,<EOL>parameters=parameters,<EOL>graph_parents=self._distribution0._graph_parents,  <EOL>name=name)<EOL>", "docstring": "Construct an `Autoregressive` distribution.\n\n        Args:\n          distribution_fn: Python `callable` which constructs a\n            `tfd.Distribution`-like instance from a `Tensor` (e.g.,\n            `sample0`). The function must respect the \"autoregressive property\",\n            i.e., there exists a permutation of event such that each coordinate is a\n            diffeomorphic function of on preceding coordinates.\n          sample0: Initial input to `distribution_fn`; used to\n            build the distribution in `__init__` which in turn specifies this\n            distribution's properties, e.g., `event_shape`, `batch_shape`, `dtype`.\n            If unspecified, then `distribution_fn` should be default constructable.\n          num_steps: Number of times `distribution_fn` is composed from samples,\n            e.g., `num_steps=2` implies\n            `distribution_fn(distribution_fn(sample0).sample(n)).sample()`.\n          validate_args: Python `bool`.  Whether to validate input with asserts.\n            If `validate_args` is `False`, and the inputs are invalid,\n            correct behavior is not guaranteed.\n          allow_nan_stats: Python `bool`, default `True`. When `True`, statistics\n            (e.g., mean, mode, variance) use the value \"`NaN`\" to indicate the\n            result is undefined. When `False`, an exception is raised if one or\n            more of the statistic's batch members are undefined.\n          name: Python `str` name prefixed to Ops created by this class.\n            Default value: \"Autoregressive\".\n\n        Raises:\n          ValueError: if `num_steps` and\n            `num_elements(distribution_fn(sample0).event_shape)` are both `None`.\n          ValueError: if `num_steps < 1`.", "id": "f15631:c0:m0"}
{"signature": "def _det_large_enough_mask(x, det_bounds):", "body": "<EOL>return tf.cast(tf.linalg.det(x) > det_bounds, dtype=x.dtype)<EOL>", "docstring": "Returns whether the input matches the given determinant limit.\n\n    Args:\n      x: A floating-point `Tensor` of shape `[B1, ..., Bn, M, M]`.\n      det_bounds: A floating-point `Tensor` that must broadcast to shape\n        `[B1, ..., Bn]`, giving the desired lower bound on the\n        determinants in `x`.\n\n    Returns:\n      mask: A floating-point `Tensor` of shape [B1, ..., Bn].  Each\n        scalar is 1 if the corresponding matrix had determinant above\n        the corresponding bound, otherwise 0.", "id": "f15636:m2"}
{"signature": "def _minimum_mean(samples, envelope, low, name=None):", "body": "with tf.compat.v1.name_scope(name, '<STR_LIT>', [samples, envelope, low]):<EOL><INDENT>dtype = dtype_util.common_dtype([samples, envelope, low], tf.float32)<EOL>samples = tf.convert_to_tensor(value=samples, name='<STR_LIT>', dtype=dtype)<EOL>envelope = tf.convert_to_tensor(<EOL>value=envelope, name='<STR_LIT>', dtype=dtype)<EOL>low = tf.convert_to_tensor(value=low, name='<STR_LIT>', dtype=dtype)<EOL>xmin = tf.reduce_min(input_tensor=samples, axis=[<NUM_LIT:0>])<EOL>msg = '<STR_LIT>'<EOL>check_op = tf.compat.v1.assert_greater_equal(xmin, low, message=msg)<EOL>with tf.control_dependencies([check_op]):<EOL><INDENT>return - _do_maximum_mean(-samples, envelope, -low)<EOL><DEDENT><DEDENT>", "docstring": "Returns a stochastic lower bound on the mean of a scalar distribution.\n\n    The idea is that if the true CDF is within an `eps`-envelope of the\n    empirical CDF of the samples, and the support is bounded below, then\n    the mean is bounded below as well.  In symbols,\n\n    ```none\n    sup_x(|F_n(x) - F(x)|) < eps\n    ```\n\n    The 0th dimension of `samples` is interpreted as independent and\n    identically distributed samples.  The remaining dimensions are\n    broadcast together with `envelope` and `low`, and operated on\n    separately.\n\n    Args:\n      samples: Floating-point `Tensor` of samples from the distribution(s)\n        of interest.  Entries are assumed IID across the 0th dimension.\n        The other dimensions must broadcast with `envelope` and `low`.\n      envelope: Floating-point `Tensor` of sizes of admissible CDF\n        envelopes (i.e., the `eps` above).\n      low: Floating-point `Tensor` of lower bounds on the distributions'\n        supports.  `samples >= low`.\n      name: A name for this operation (optional).\n\n    Returns:\n      bound: Floating-point `Tensor` of lower bounds on the true means.\n\n    Raises:\n      InvalidArgumentError: If some `sample` is found to be smaller than\n        the corresponding `low`.", "id": "f15639:m13"}
{"signature": "def assert_true_mean_in_interval_by_dkwm(<EOL>samples, low, high, expected_low, expected_high,<EOL>false_fail_rate=<NUM_LIT>, name=None):", "body": "args_list = [samples, low, high, expected_low, expected_high, false_fail_rate]<EOL>with tf.compat.v1.name_scope(name, '<STR_LIT>',<EOL>args_list):<EOL><INDENT>dtype = dtype_util.common_dtype(args_list, tf.float32)<EOL>samples = tf.convert_to_tensor(value=samples, name='<STR_LIT>', dtype=dtype)<EOL>low = tf.convert_to_tensor(value=low, name='<STR_LIT>', dtype=dtype)<EOL>high = tf.convert_to_tensor(value=high, name='<STR_LIT>', dtype=dtype)<EOL>expected_low = tf.convert_to_tensor(<EOL>value=expected_low, name='<STR_LIT>', dtype=dtype)<EOL>expected_high = tf.convert_to_tensor(<EOL>value=expected_high, name='<STR_LIT>', dtype=dtype)<EOL>false_fail_rate = tf.convert_to_tensor(<EOL>value=false_fail_rate, name='<STR_LIT>', dtype=dtype)<EOL>samples = _check_shape_dominates(<EOL>samples, [low, high, expected_low, expected_high])<EOL>min_mean, max_mean = true_mean_confidence_interval_by_dkwm(<EOL>samples, low, high, false_fail_rate)<EOL>check_confidence_interval_can_intersect = tf.compat.v1.assert_greater_equal(<EOL>max_mean,<EOL>expected_low,<EOL>message='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>with tf.control_dependencies([check_confidence_interval_can_intersect]):<EOL><INDENT>return tf.compat.v1.assert_less_equal(<EOL>min_mean,<EOL>expected_high,<EOL>message='<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>", "docstring": "Asserts the mean of the given distribution is in the given interval.\n\n    More precisely, fails if there is enough evidence (using the\n    [Dvoretzky-Kiefer-Wolfowitz-Massart inequality]\n    (https://en.wikipedia.org/wiki/CDF-based_nonparametric_confidence_interval))\n    that the mean of the distribution from which the given samples are\n    drawn is _outside_ the given interval with statistical significance\n    `false_fail_rate` or stronger, otherwise passes.  If you also want\n    to check that you are gathering enough evidence that a pass is not\n    spurious, see `min_num_samples_for_dkwm_mean_test` and\n    `min_discrepancy_of_true_means_detectable_by_dkwm`.\n\n    Note that `false_fail_rate` is a total false failure rate for all\n    the assertions in the batch.  As such, if the batch is nontrivial,\n    the assertion will insist on stronger evidence to fail any one member.\n\n    Args:\n      samples: Floating-point `Tensor` of samples from the distribution(s)\n        of interest.  Entries are assumed IID across the 0th dimension.\n        The other dimensions must broadcast with `low` and `high`.\n        The support is bounded: `low <= samples <= high`.\n      low: Floating-point `Tensor` of lower bounds on the distributions'\n        supports.\n      high: Floating-point `Tensor` of upper bounds on the distributions'\n        supports.\n      expected_low: Floating-point `Tensor` of lower bounds on the\n        expected true means.\n      expected_high: Floating-point `Tensor` of upper bounds on the\n        expected true means.\n      false_fail_rate: *Scalar* floating-point `Tensor` admissible total\n        rate of mistakes.\n      name: A name for this operation (optional).\n\n    Returns:\n      check: Op that raises `InvalidArgumentError` if any expected mean\n        interval does not overlap with the corresponding confidence\n        interval.", "id": "f15639:m21"}
{"signature": "def assert_multivariate_true_cdf_equal_on_projections_two_sample(<EOL>samples1, samples2, num_projections, event_ndims=<NUM_LIT:1>,<EOL>false_fail_rate=<NUM_LIT>, seed=<NUM_LIT>, name=None):", "body": "<EOL>args_list = (<EOL>[samples1, samples2, num_projections, event_ndims, false_fail_rate])<EOL>strm = seed_stream.SeedStream(salt='<STR_LIT>', seed=seed)<EOL>with tf.compat.v1.name_scope(<EOL>name,<EOL>'<STR_LIT>',<EOL>args_list):<EOL><INDENT>dtype = dtype_util.common_dtype(<EOL>[samples1, samples2, false_fail_rate], tf.float32)<EOL>samples1 = tf.convert_to_tensor(<EOL>value=samples1, name='<STR_LIT>', dtype=dtype)<EOL>samples2 = tf.convert_to_tensor(<EOL>value=samples2, name='<STR_LIT>', dtype=dtype)<EOL>num_projections = tf.convert_to_tensor(<EOL>value=num_projections, name='<STR_LIT>')<EOL>false_fail_rate = tf.convert_to_tensor(<EOL>value=false_fail_rate, name='<STR_LIT>', dtype=dtype)<EOL>tf.compat.v1.assert_scalar(false_fail_rate)  <EOL>compatible_samples = tf.compat.v1.assert_equal(<EOL>tf.shape(input=samples1)[<NUM_LIT:1>:],<EOL>tf.shape(input=samples2)[<NUM_LIT:1>:])<EOL>with tf.control_dependencies([compatible_samples]):<EOL><INDENT>event_shape = tf.shape(input=samples1)[-event_ndims:]<EOL>random_projections = _random_unit_hypersphere(<EOL>[num_projections], event_shape, dtype=dtype, seed=strm())<EOL>last_axes = list(range(-<NUM_LIT:1>, -(event_ndims+<NUM_LIT:1>), -<NUM_LIT:1>))<EOL>proj1 = tf.tensordot(samples1, random_projections, [last_axes, last_axes])<EOL>proj2 = tf.tensordot(samples2, random_projections, [last_axes, last_axes])<EOL>return assert_true_cdf_equal_by_dkwm_two_sample(<EOL>proj1, proj2, false_fail_rate=false_fail_rate)<EOL><DEDENT><DEDENT>", "docstring": "Asserts the given multivariate distributions are equal.\n\n    The test is a 1-D DKWM-style test of equality in distribution along the given\n    number of random projections.  This is of course imperfect, but can behave\n    reasonably, especially if `num_projections` is significantly more than the\n    dimensionality of the sample space.\n\n    More precisely, the test\n    (i) assumes the event shape is given by the trailing `event_ndims` dimensions\n        in each `samples` Tensor;\n    (ii) generates `num_projections` random projections from this space to scalar;\n    (iii) fails if there is enough evidence (using the\n        [Dvoretzky-Kiefer-Wolfowitz-Massart inequality]\n        (https://en.wikipedia.org/wiki/CDF-based_nonparametric_confidence_interval))\n        along any of these projections that `samples1` and `samples2` come from\n        different true distributions.\n\n    This test works as written even if the distribution in question has atoms\n    (e.g., is discrete).\n\n    Note that the top dimension of each `samples` is treated as iid, and the\n    bottom `event_ndims` dimensions are projected to scalar.  The remaining\n    dimensions, if any, are treated as batch dimensions, and `false_fail_rate` is\n    a total false failure rate for all the assertions in the batch (and all\n    projections).  As such, if the batch is nontrivial, the assertion will insist\n    on stronger evidence to fail any one member.\n\n    A note on experiment design: This test boils down to `num_projections`\n    two-sample CDF equality tests.  As such, one can compute the number of samples\n    to draw or the detectable discrepancy (along any projection) using\n    `min_num_samples_for_dkwm_cdf_two_sample_test` and\n    `min_discrepancy_of_true_cdfs_detectable_by_dkwm_two_sample` respectively,\n    just being sure to divide the false failure rate by the number of projections\n    requested (no need to adjust the false pass rate).\n\n    Args:\n      samples1: Tensor of shape [n] + B + E.  Samples from some (batch of)\n        distribution(s) of interest.  Assumed IID across the 0 dimension.\n      samples2: Tensor of shape [m] + B + E.  Samples from some (batch of)\n        distribution(s) of interest.  Assumed IID across the 0 dimension.\n      num_projections: Scalar integer Tensor.  Number of projections to use.  Each\n        projection will be a random direction on the unit hypershpere of shape E.\n      event_ndims: Number of trailing dimensions forming the event shape.\n        `rank(E) == event_ndims`.\n      false_fail_rate: *Scalar* floating-point `Tensor` admissible total\n        rate of mistakes.\n      seed: Optional PRNG seed to use for generating the random projections.\n        Changing this from the default should generally not be necessary.\n      name: A name for this operation (optional).\n\n    Returns:\n      check: Op that raises `InvalidArgumentError` if the two samples do not match\n        along any of the generated projections.", "id": "f15639:m26"}
{"signature": "def _maximum_mean(samples, envelope, high, name=None):", "body": "with tf.compat.v1.name_scope(name, '<STR_LIT>', [samples, envelope, high]):<EOL><INDENT>dtype = dtype_util.common_dtype([samples, envelope, high], tf.float32)<EOL>samples = tf.convert_to_tensor(value=samples, name='<STR_LIT>', dtype=dtype)<EOL>envelope = tf.convert_to_tensor(<EOL>value=envelope, name='<STR_LIT>', dtype=dtype)<EOL>high = tf.convert_to_tensor(value=high, name='<STR_LIT>', dtype=dtype)<EOL>xmax = tf.reduce_max(input_tensor=samples, axis=[<NUM_LIT:0>])<EOL>msg = '<STR_LIT>'<EOL>check_op = tf.compat.v1.assert_less_equal(xmax, high, message=msg)<EOL>with tf.control_dependencies([check_op]):<EOL><INDENT>return tf.identity(_do_maximum_mean(samples, envelope, high))<EOL><DEDENT><DEDENT>", "docstring": "Returns a stochastic upper bound on the mean of a scalar distribution.\n\n    The idea is that if the true CDF is within an `eps`-envelope of the\n    empirical CDF of the samples, and the support is bounded above, then\n    the mean is bounded above as well.  In symbols,\n\n    ```none\n    sup_x(|F_n(x) - F(x)|) < eps\n    ```\n\n    The 0th dimension of `samples` is interpreted as independent and\n    identically distributed samples.  The remaining dimensions are\n    broadcast together with `envelope` and `high`, and operated on\n    separately.\n\n    Args:\n      samples: Floating-point `Tensor` of samples from the distribution(s)\n        of interest.  Entries are assumed IID across the 0th dimension.\n        The other dimensions must broadcast with `envelope` and `high`.\n      envelope: Floating-point `Tensor` of sizes of admissible CDF\n        envelopes (i.e., the `eps` above).\n      high: Floating-point `Tensor` of upper bounds on the distributions'\n        supports.  `samples <= high`.\n      name: A name for this operation (optional).\n\n    Returns:\n      bound: Floating-point `Tensor` of upper bounds on the true means.\n\n    Raises:\n      InvalidArgumentError: If some `sample` is found to be larger than\n        the corresponding `high`.", "id": "f15639:m12"}
{"signature": "def empirical_cdfs(samples, positions, continuity='<STR_LIT:right>',<EOL>dtype=tf.float32, name=None):", "body": "if continuity not in ['<STR_LIT:left>', '<STR_LIT:right>']:<EOL><INDENT>msg = '<STR_LIT>'.format(<EOL>continuity)<EOL>raise ValueError(msg)<EOL><DEDENT>with tf.compat.v1.name_scope(name, '<STR_LIT>', [samples, positions]):<EOL><INDENT>n = tf.cast(tf.shape(input=samples)[-<NUM_LIT:1>], dtype=dtype)<EOL>indexes = tf.searchsorted(<EOL>sorted_sequence=samples, values=positions, side=continuity)<EOL>return tf.cast(indexes, dtype=dtype) / n<EOL><DEDENT>", "docstring": "Evaluates the empirical CDF of a batch of samples at a batch of positions.\n\n    If elements of `positions` might be exactly equal to elements of `samples`\n    (e.g., if the underlying distribution of interest is discrete), there is a\n    difference between the conventional, right-continuous CDF (Pr[X <= x]) and a\n    left-continuous variant (Pr[X < x]).  The latter can be accessed by setting\n    `continuity='left'`.  The difference between the right-continuous and\n    left-continuous CDFs is the empirical pmf at each point, i.e., how many times\n    each element of `positions` occurs in its batch of `samples`.\n\n    Note: Returns results parallel to `positions`, i.e., the values of the\n    empirical CDF at those points.\n\n    Note: The sample dimension is _last_, and the samples must be _sorted_ within\n    each batch.\n\n    Args:\n      samples: Tensor of shape `batch + [num_samples]` of samples.  The samples\n        must be in ascending order within each batch member.\n      positions: Tensor of shape `batch + [m]` of positions where to evaluate the\n        CDFs.  The positions need not be sorted.\n      continuity: Whether to return a conventional, right-continuous CDF\n        (`continuity = 'right'`, default) or a left-continuous CDF (`continuity =\n        'left'`).  The value at each point `x` will be `F_n(X <= x)` or\n        `F_n(X < x)`, respectively.\n      dtype: dtype at which to evaluate the desired empirical CDFs.\n      name: A name for this operation (optional).\n\n    Returns:\n      cdf: Tensor parallel to `positions`.  For each x in `positions`, gives the\n        (right- or left-continuous, per the `continuity` argument) cdf at that\n        position.  If `positions` contains duplicates, `cdf` will give each the\n        same value.", "id": "f15639:m7"}
{"signature": "def assert_true_mean_equal_by_dkwm(<EOL>samples, low, high, expected, false_fail_rate=<NUM_LIT>, name=None):", "body": "with tf.compat.v1.name_scope(name, '<STR_LIT>',<EOL>[samples, low, high, expected, false_fail_rate]):<EOL><INDENT>return assert_true_mean_in_interval_by_dkwm(<EOL>samples, low, high, expected, expected, false_fail_rate)<EOL><DEDENT>", "docstring": "Asserts the mean of the given distribution is as expected.\n\n    More precisely, fails if there is enough evidence (using the\n    [Dvoretzky-Kiefer-Wolfowitz-Massart inequality]\n    (https://en.wikipedia.org/wiki/CDF-based_nonparametric_confidence_interval))\n    that the true mean of some distribution from which the given samples are\n    drawn is _not_ the given expected mean with statistical significance\n    `false_fail_rate` or stronger, otherwise passes.  If you also want to\n    check that you are gathering enough evidence that a pass is not\n    spurious, see `min_num_samples_for_dkwm_mean_test` and\n    `min_discrepancy_of_true_means_detectable_by_dkwm`.\n\n    Note that `false_fail_rate` is a total false failure rate for all\n    the assertions in the batch.  As such, if the batch is nontrivial,\n    the assertion will insist on stronger evidence to fail any one member.\n\n    Args:\n      samples: Floating-point `Tensor` of samples from the distribution(s)\n        of interest.  Entries are assumed IID across the 0th dimension.\n        The other dimensions must broadcast with `low` and `high`.\n        The support is bounded: `low <= samples <= high`.\n      low: Floating-point `Tensor` of lower bounds on the distributions'\n        supports.\n      high: Floating-point `Tensor` of upper bounds on the distributions'\n        supports.\n      expected: Floating-point `Tensor` of expected true means.\n      false_fail_rate: *Scalar* floating-point `Tensor` admissible total\n        rate of mistakes.\n      name: A name for this operation (optional).\n\n    Returns:\n      check: Op that raises `InvalidArgumentError` if any expected mean is\n        outside the corresponding confidence interval.", "id": "f15639:m18"}
{"signature": "def min_discrepancy_of_true_cdfs_detectable_by_dkwm(<EOL>n, false_fail_rate, false_pass_rate, name=None):", "body": "with tf.compat.v1.name_scope(<EOL>name, '<STR_LIT>',<EOL>[n, false_fail_rate, false_pass_rate]):<EOL><INDENT>dtype = dtype_util.common_dtype(<EOL>[n, false_fail_rate, false_pass_rate], tf.float32)<EOL>n = tf.convert_to_tensor(value=n, name='<STR_LIT:n>', dtype=dtype)<EOL>false_fail_rate = tf.convert_to_tensor(<EOL>value=false_fail_rate, name='<STR_LIT>', dtype=dtype)<EOL>false_pass_rate = tf.convert_to_tensor(<EOL>value=false_pass_rate, name='<STR_LIT>', dtype=dtype)<EOL>sampling_envelope = _dkwm_cdf_envelope(n, false_pass_rate)<EOL>itemwise_false_fail_rate = _itemwise_error_rate(<EOL>total_rate=false_fail_rate, param_tensors=[n])<EOL>analysis_envelope = _dkwm_cdf_envelope(n, itemwise_false_fail_rate)<EOL>return sampling_envelope + analysis_envelope<EOL><DEDENT>", "docstring": "Returns the minimum CDF discrepancy that a DKWM-based test can detect.\n\n    DKWM is the [Dvoretzky-Kiefer-Wolfowitz-Massart inequality]\n    (https://en.wikipedia.org/wiki/CDF-based_nonparametric_confidence_interval).\n\n    Note that `false_fail_rate` is a total false failure rate for all\n    the tests in the batch.  As such, if the batch is nontrivial, each\n    member will demand more samples.  The `false_pass_rate` is also\n    interpreted as a total, but is treated asymmetrically: If each test\n    in the batch detects its corresponding discrepancy with probability\n    at least `1 - false_pass_rate`, then running all those tests and\n    failing if any one fails will jointly detect all those discrepancies\n    with the same `false_pass_rate`.\n\n    Args:\n      n: `Tensor` of numbers of samples to be drawn from the distributions\n        of interest.\n      false_fail_rate: *Scalar* floating-point `Tensor` admissible total\n        rate of false failures.\n      false_pass_rate: *Scalar* floating-point `Tensor` admissible rate\n        of false passes.\n      name: A name for this operation (optional).\n\n    Returns:\n      discr: `Tensor` of lower bounds on the K-S distances between true\n         CDFs detectable by a DKWM-based test.\n\n    For each batch member `i`, of `K` total, drawing `n[i]` samples from some\n    scalar distribution is enough to detect a K-S distance in CDFs of size\n    `discr[i]` or more.  Specifically, we guarantee that (a) if the true CDF is\n    the expected CDF, then `assert_true_cdf_equal_by_dkwm` will fail with\n    probability at most `false_fail_rate / K` (which amounts to `false_fail_rate`\n    if applied to the whole batch at once), and (b) if the true CDF differs from\n    the expected CDF by at least `discr[i]`, `assert_true_cdf_equal_by_dkwm` will\n    pass with probability at most `false_pass_rate`.\n\n    The detectable discrepancy scales as\n\n    - `O(1 / sqrt(n[i]))`,\n    - `O(-log(false_fail_rate/K))`, and\n    - `O(-log(false_pass_rate))`.", "id": "f15639:m1"}
{"signature": "def __init__(self,<EOL>scale,<EOL>validate_args=False,<EOL>allow_nan_stats=True,<EOL>name=\"<STR_LIT>\"):", "body": "parameters = dict(locals())<EOL>with tf.name_scope(name) as name:<EOL><INDENT>scale = tf.convert_to_tensor(<EOL>value=scale,<EOL>name=\"<STR_LIT>\",<EOL>dtype=dtype_util.common_dtype([scale], preferred_dtype=tf.float32))<EOL>with tf.control_dependencies(<EOL>[assert_util.assert_positive(scale)] if validate_args else []):<EOL><INDENT>self._scale = tf.identity(scale, name=\"<STR_LIT>\")<EOL><DEDENT><DEDENT>super(HalfNormal, self).__init__(<EOL>dtype=self._scale.dtype,<EOL>reparameterization_type=reparameterization.FULLY_REPARAMETERIZED,<EOL>validate_args=validate_args,<EOL>allow_nan_stats=allow_nan_stats,<EOL>parameters=parameters,<EOL>graph_parents=[self._scale],<EOL>name=name)<EOL>", "docstring": "Construct HalfNormals with scale `scale`.\n\n        Args:\n          scale: Floating point tensor; the scales of the distribution(s).\n            Must contain only positive values.\n          validate_args: Python `bool`, default `False`. When `True` distribution\n            parameters are checked for validity despite possibly degrading runtime\n            performance. When `False` invalid inputs may silently render incorrect\n            outputs.\n          allow_nan_stats: Python `bool`, default `True`. When `True`,\n            statistics (e.g., mean, mode, variance) use the value \"`NaN`\" to\n            indicate the result is undefined. When `False`, an exception is raised\n            if one or more of the statistic's batch members are undefined.\n          name: Python `str` name prefixed to Ops created by this class.", "id": "f15643:c0:m0"}
{"signature": "def _compute_non_batch_kl(self, loc_a, scale_a, loc_b, scale_b):", "body": "<EOL>covariance_a = np.dot(scale_a, scale_a.T)<EOL>covariance_b = np.dot(scale_b, scale_b.T)<EOL>covariance_b_inv = np.linalg.inv(covariance_b)<EOL>t = np.trace(covariance_b_inv.dot(covariance_a))<EOL>q = (loc_b - loc_a).dot(covariance_b_inv).dot(loc_b - loc_a)<EOL>k = loc_a.shape[<NUM_LIT:0>]<EOL>l = np.log(np.linalg.det(covariance_b) / np.linalg.det(covariance_a))<EOL>return <NUM_LIT:0.5> * (t + q - k + l)<EOL>", "docstring": "Non-batch KL for N(loc_a, scale_a), N(loc_b, scale_b).", "id": "f15645:c0:m10"}
{"signature": "@hps.composite<EOL>def broadcasting_shapes(draw, batch_shape, param_names):", "body": "n = len(param_names)<EOL>return dict(zip(draw(hps.permutations(param_names)),<EOL>draw(tfp_test_util.broadcasting_shapes(batch_shape, n))))<EOL>", "docstring": "Draws a set of parameter batch shapes that broadcast to `batch_shape`.\n\n    For each parameter we need to choose its batch rank, and whether or not each\n    axis i is 1 or batch_shape[i]. This function chooses a set of shapes that\n    have possibly mismatched ranks, and possibly broadcasting axes, with the\n    promise that the broadcast of the set of all shapes matches `batch_shape`.\n\n    Args:\n      draw: Hypothesis sampler.\n      batch_shape: `tf.TensorShape`, the target (fully-defined) batch shape .\n      param_names: Iterable of `str`, the parameters whose batch shapes need\n        determination.\n\n    Returns:\n      param_batch_shapes: `dict` of `str->tf.TensorShape` where the set of\n          shapes broadcast to `batch_shape`. The shapes are fully defined.", "id": "f15647:m2"}
{"signature": "@kullback_leibler.RegisterKL(Laplace, Laplace)<EOL>def _kl_laplace_laplace(a, b, name=None):", "body": "with tf.name_scope(name or \"<STR_LIT>\"):<EOL><INDENT>distance = tf.abs(a.loc - b.loc)<EOL>ratio = a.scale / b.scale<EOL>return (-tf.math.log(ratio) - <NUM_LIT:1> + distance / b.scale +<EOL>ratio * tf.exp(-distance / a.scale))<EOL><DEDENT>", "docstring": "Calculate the batched KL divergence KL(a || b) with a and b Laplace.\n\n    Args:\n      a: instance of a Laplace distribution object.\n      b: instance of a Laplace distribution object.\n      name: (optional) Name to use for created operations.\n        default is \"kl_laplace_laplace\".\n\n    Returns:\n      Batchwise KL(a || b)", "id": "f15649:m0"}
{"signature": "def __init__(self,<EOL>distributions,<EOL>dtype_override=None,<EOL>validate_args=False,<EOL>allow_nan_stats=False,<EOL>name='<STR_LIT>'):", "body": "parameters = dict(locals())<EOL>with tf.name_scope(name) as name:<EOL><INDENT>self._assertions = _maybe_validate_distributions(<EOL>distributions, dtype_override, validate_args)<EOL>if dtype_override is not None:<EOL><INDENT>dtype = dtype_override<EOL><DEDENT>else:<EOL><INDENT>dtype = set(<EOL>dtype_util.base_dtype(d.dtype)<EOL>for d in distributions<EOL>if d.dtype is not None)<EOL>if len(dtype) == <NUM_LIT:0>:  <EOL><INDENT>dtype = tf.float32<EOL><DEDENT>elif len(dtype) == <NUM_LIT:1>:<EOL><INDENT>dtype = dtype.pop()<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>reparameterization_type = set(d.reparameterization_type<EOL>for d in distributions)<EOL>reparameterization_type = (reparameterization_type.pop()<EOL>if len(reparameterization_type) == <NUM_LIT:1><EOL>else reparameterization.NOT_REPARAMETERIZED)<EOL>self._distributions = distributions<EOL>super(Blockwise, self).__init__(<EOL>dtype=dtype,<EOL>validate_args=validate_args,<EOL>allow_nan_stats=allow_nan_stats,<EOL>reparameterization_type=reparameterization_type,<EOL>parameters=parameters,<EOL>graph_parents=_flatten(d._graph_parents for d in distributions),  <EOL>name=name)<EOL><DEDENT>", "docstring": "Construct the `Blockwise` distribution.\n\n        Args:\n          distributions: Python `list` of `tfp.distributions.Distribution`\n            instances. All distribution instances must have the same `batch_shape`\n            and all must have `event_ndims==1`, i.e., be vector-variate\n            distributions.\n          dtype_override: samples of `distributions` will be cast to this `dtype`.\n            If unspecified, all `distributions` must have the same `dtype`.\n            Default value: `None` (i.e., do not cast).\n          validate_args: Python `bool`, default `False`. When `True` distribution\n            parameters are checked for validity despite possibly degrading runtime\n            performance. When `False` invalid inputs may silently render incorrect\n            outputs.\n          allow_nan_stats: Python `bool`, default `True`. When `True`, statistics\n            (e.g., mean, mode, variance) use the value \"`NaN`\" to indicate the\n            result is undefined. When `False`, an exception is raised if one or\n            more of the statistic's batch members are undefined.\n          name: Python `str` name prefixed to Ops created by this class.", "id": "f15650:c0:m0"}
{"signature": "@kullback_leibler.RegisterKL(Blockwise, Blockwise)<EOL>def _kl_blockwise_blockwise(b0, b1, name=None):", "body": "if len(b0.distributions) != len(b1.distributions):<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>b0_event_sizes = [_event_size(d) for d in b0.distributions]<EOL>b1_event_sizes = [_event_size(d) for d in b1.distributions]<EOL>assertions = []<EOL>message = ('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>if (all(isinstance(event_size, int) for event_size in b0_event_sizes) and<EOL>all(isinstance(event_size, int) for event_size in b1_event_sizes)):<EOL><INDENT>if b0_event_sizes != b1_event_sizes:<EOL><INDENT>raise ValueError(message)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if b0.validate_args or b1.validate_args:<EOL><INDENT>assertions.extend(<EOL>assert_util.assert_equal(  <EOL>e1, e2, message=message)<EOL>for e1, e2 in zip(b0_event_sizes, b1_event_sizes))<EOL><DEDENT><DEDENT>with tf.name_scope(name or '<STR_LIT>'):<EOL><INDENT>with tf.control_dependencies(assertions):<EOL><INDENT>return sum([<EOL>kullback_leibler.kl_divergence(d1, d2) for d1, d2 in zip(<EOL>b0.distributions, b1.distributions)])<EOL><DEDENT><DEDENT>", "docstring": "Calculate the batched KL divergence KL(b0 || b1) with b0 and b1 Blockwise distributions.\n\n    Args:\n      b0: instance of a Blockwise distribution object.\n      b1: instance of a Blockwise distribution object.\n      name: (optional) Name to use for created operations. Default is\n        \"kl_blockwise_blockwise\".\n\n    Returns:\n      kl_blockwise_blockwise: `Tensor`. The batchwise KL(b0 || b1).", "id": "f15650:m3"}
{"signature": "def kalman_transition(filtered_mean, filtered_cov,<EOL>transition_matrix, transition_noise):", "body": "predicted_mean = _propagate_mean(filtered_mean,<EOL>transition_matrix,<EOL>transition_noise)<EOL>predicted_cov = _propagate_cov(filtered_cov,<EOL>transition_matrix,<EOL>transition_noise)<EOL>return predicted_mean, predicted_cov<EOL>", "docstring": "Propagate a filtered distribution through a transition model.", "id": "f15652:m7"}
{"signature": "def build_kalman_filter_step(get_transition_matrix_for_timestep,<EOL>get_transition_noise_for_timestep,<EOL>get_observation_matrix_for_timestep,<EOL>get_observation_noise_for_timestep):", "body": "def kalman_filter_step(state, elems_t):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if isinstance(elems_t, tuple):<EOL><INDENT>x_t, mask_t = elems_t<EOL><DEDENT>else:<EOL><INDENT>x_t = elems_t<EOL>mask_t = None<EOL><DEDENT>observation_matrix = get_observation_matrix_for_timestep(state.timestep)<EOL>observation_noise = get_observation_noise_for_timestep(state.timestep)<EOL>if mask_t is not None:<EOL><INDENT>x_expected = _propagate_mean(state.predicted_mean,<EOL>observation_matrix,<EOL>observation_noise) * tf.ones_like(x_t)<EOL>x_t = tf.where(<EOL>tf.broadcast_to(mask_t, tf.shape(input=x_expected)), x_expected,<EOL>tf.broadcast_to(x_t, tf.shape(input=x_expected)))<EOL><DEDENT>(filtered_mean,<EOL>filtered_cov,<EOL>observation_dist) = linear_gaussian_update(<EOL>state.predicted_mean, state.predicted_cov,<EOL>observation_matrix, observation_noise,<EOL>x_t)<EOL>log_marginal_likelihood = observation_dist.log_prob(x_t[..., <NUM_LIT:0>])<EOL>if mask_t is not None:<EOL><INDENT>filtered_mean = tf.where(<EOL>tf.broadcast_to(mask_t, tf.shape(input=filtered_mean)),<EOL>state.predicted_mean, filtered_mean)<EOL>filtered_cov = tf.where(<EOL>tf.broadcast_to(mask_t, tf.shape(input=filtered_cov)),<EOL>state.predicted_cov, filtered_cov)<EOL>log_marginal_likelihood = tf.where(<EOL>tf.broadcast_to(mask_t[..., <NUM_LIT:0>, <NUM_LIT:0>],<EOL>tf.shape(input=log_marginal_likelihood)),<EOL>tf.zeros_like(log_marginal_likelihood),<EOL>log_marginal_likelihood)<EOL><DEDENT>predicted_mean, predicted_cov = kalman_transition(<EOL>filtered_mean,<EOL>filtered_cov,<EOL>get_transition_matrix_for_timestep(state.timestep),<EOL>get_transition_noise_for_timestep(state.timestep))<EOL>return KalmanFilterState(<EOL>filtered_mean, filtered_cov,<EOL>predicted_mean, predicted_cov,<EOL>observation_dist.mean()[..., tf.newaxis],<EOL>observation_dist.covariance(),<EOL>log_marginal_likelihood,<EOL>state.timestep+<NUM_LIT:1>)<EOL><DEDENT>return kalman_filter_step<EOL>", "docstring": "Build a callable that performs one step of Kalman filtering.\n\n    Args:\n      get_transition_matrix_for_timestep: callable taking a timestep\n        as an integer `Tensor` argument, and returning a `LinearOperator`\n        of shape `[latent_size, latent_size]`.\n      get_transition_noise_for_timestep: callable taking a timestep as\n        an integer `Tensor` argument, and returning a\n        `MultivariateNormalLinearOperator` of event shape\n        `[latent_size]`.\n      get_observation_matrix_for_timestep: callable taking a timestep\n        as an integer `Tensor` argument, and returning a `LinearOperator`\n        of shape `[observation_size, observation_size]`.\n      get_observation_noise_for_timestep: callable taking a timestep as\n        an integer `Tensor` argument, and returning a\n        `MultivariateNormalLinearOperator` of event shape\n        `[observation_size]`.\n\n    Returns:\n      kalman_filter_step: a callable that updates a KalmanFilterState\n        from timestep `t-1` to `t`.", "id": "f15652:m5"}
{"signature": "@property<EOL><INDENT>def scale(self):<DEDENT>", "body": "return self._scale<EOL>", "docstring": "Distribution parameter for the scale.", "id": "f15657:c0:m9"}
{"signature": "@property<EOL><INDENT>def logits(self):<DEDENT>", "body": "return self._logits<EOL>", "docstring": "Log-odds of drawing a `1`.", "id": "f15658:c0:m3"}
{"signature": "def _bdtr(k, n, p):", "body": "<EOL>ones = tf.ones_like(n - k)<EOL>k_eq_n = tf.equal(k, n)<EOL>safe_dn = tf.where(k_eq_n, ones, n - k)<EOL>dk = tf.math.betainc(a=safe_dn, b=k + <NUM_LIT:1>, x=<NUM_LIT:1> - p)<EOL>return tf.where(k_eq_n, ones, dk)<EOL>", "docstring": "The binomial cumulative distribution function.\n\n    Args:\n      k: floating point `Tensor`.\n      n: floating point `Tensor`.\n      p: floating point `Tensor`.\n\n    Returns:\n      `sum_{j=0}^k p^j (1 - p)^(n - j)`.", "id": "f15658:m0"}
{"signature": "def _logsum_expbig_minus_expsmall(big, small):", "body": "with tf.name_scope(\"<STR_LIT>\"):<EOL><INDENT>return tf.math.log1p(-tf.exp(small - big)) + big<EOL><DEDENT>", "docstring": "Stable evaluation of `Log[exp{big} - exp{small}]`.\n\n    To work correctly, we should have the pointwise relation:  `small <= big`.\n\n    Args:\n      big: Floating-point `Tensor`\n      small: Floating-point `Tensor` with same `dtype` as `big` and broadcastable\n        shape.\n\n    Returns:\n      `Tensor` of same `dtype` of `big` and broadcast shape.", "id": "f15663:m0"}
{"signature": "def _log_prob_with_logsf_and_logcdf(self, y):", "body": "<EOL>logsf_y = self.log_survival_function(y)<EOL>logsf_y_minus_1 = self.log_survival_function(y - <NUM_LIT:1>)<EOL>logcdf_y = self.log_cdf(y)<EOL>logcdf_y_minus_1 = self.log_cdf(y - <NUM_LIT:1>)<EOL>big = tf.where(logsf_y < logcdf_y, logsf_y_minus_1, logcdf_y)<EOL>small = tf.where(logsf_y < logcdf_y, logsf_y, logcdf_y_minus_1)<EOL>return _logsum_expbig_minus_expsmall(big, small)<EOL>", "docstring": "Compute log_prob(y) using log survival_function and cdf together.", "id": "f15663:c0:m11"}
{"signature": "@property<EOL><INDENT>def distribution(self):<DEDENT>", "body": "return self._dist<EOL>", "docstring": "Base distribution, p(x).", "id": "f15663:c0:m1"}
{"signature": "def __init__(self,<EOL>rate=None,<EOL>log_rate=None,<EOL>interpolate_nondiscrete=True,<EOL>validate_args=False,<EOL>allow_nan_stats=True,<EOL>name=\"<STR_LIT>\"):", "body": "parameters = dict(locals())<EOL>with tf.name_scope(name) as name:<EOL><INDENT>if (rate is None) == (log_rate is None):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>elif log_rate is None:<EOL><INDENT>rate = tf.convert_to_tensor(<EOL>value=rate,<EOL>name=\"<STR_LIT>\",<EOL>dtype=dtype_util.common_dtype([rate], preferred_dtype=tf.float32))<EOL>if not dtype_util.is_floating(rate.dtype):<EOL><INDENT>raise TypeError(\"<STR_LIT>\".format(<EOL>dtype_util.name(rate.dtype)))<EOL><DEDENT>with tf.control_dependencies(<EOL>[assert_util.assert_positive(rate)] if validate_args else []):<EOL><INDENT>self._rate = tf.identity(rate, name=\"<STR_LIT>\")<EOL>self._log_rate = tf.math.log(rate, name=\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>log_rate = tf.convert_to_tensor(<EOL>value=log_rate,<EOL>name=\"<STR_LIT>\",<EOL>dtype=dtype_util.common_dtype([log_rate], tf.float32))<EOL>if not dtype_util.is_floating(log_rate.dtype):<EOL><INDENT>raise TypeError(\"<STR_LIT>\".format(<EOL>dtype_util.name(log_rate.dtype)))<EOL><DEDENT>self._rate = tf.exp(log_rate, name=\"<STR_LIT>\")<EOL>self._log_rate = tf.convert_to_tensor(value=log_rate, name=\"<STR_LIT>\")<EOL><DEDENT><DEDENT>self._interpolate_nondiscrete = interpolate_nondiscrete<EOL>super(Poisson, self).__init__(<EOL>dtype=self._rate.dtype,<EOL>reparameterization_type=reparameterization.NOT_REPARAMETERIZED,<EOL>validate_args=validate_args,<EOL>allow_nan_stats=allow_nan_stats,<EOL>parameters=parameters,<EOL>graph_parents=[self._rate],<EOL>name=name)<EOL>", "docstring": "Initialize a batch of Poisson distributions.\n\n        Args:\n          rate: Floating point tensor, the rate parameter. `rate` must be positive.\n            Must specify exactly one of `rate` and `log_rate`.\n          log_rate: Floating point tensor, the log of the rate parameter.\n            Must specify exactly one of `rate` and `log_rate`.\n          interpolate_nondiscrete: Python `bool`. When `False`,\n            `log_prob` returns `-inf` (and `prob` returns `0`) for non-integer\n            inputs. When `True`, `log_prob` evaluates the continuous function\n            `k * log_rate - lgamma(k+1) - rate`, which matches the Poisson pmf\n            at integer arguments `k` (note that this function is not itself\n            a normalized probability log-density).\n            Default value: `True`.\n          validate_args: Python `bool`. When `True` distribution\n            parameters are checked for validity despite possibly degrading runtime\n            performance. When `False` invalid inputs may silently render incorrect\n            outputs.\n            Default value: `False`.\n          allow_nan_stats: Python `bool`. When `True`, statistics\n            (e.g., mean, mode, variance) use the value \"`NaN`\" to indicate the\n            result is undefined. When `False`, an exception is raised if one or\n            more of the statistic's batch members are undefined.\n            Default value: `True`.\n          name: Python `str` name prefixed to Ops created by this class.\n\n        Raises:\n          ValueError: if none or both of `rate`, `log_rate` are specified.\n          TypeError: if `rate` is not a float-type.\n          TypeError: if `log_rate` is not a float-type.", "id": "f15664:c0:m0"}
{"signature": "@property<EOL><INDENT>def rate(self):<DEDENT>", "body": "return self._rate<EOL>", "docstring": "Rate parameter.", "id": "f15664:c0:m2"}
{"signature": "def _flat_sample_distributions(self, sample_shape=(), seed=None, value=None):", "body": "ds = []<EOL>values_out = []<EOL>seed = seed_stream.SeedStream('<STR_LIT>', seed)<EOL>gen = self._model()<EOL>index = <NUM_LIT:0><EOL>d = next(gen)<EOL>try:<EOL><INDENT>while True:<EOL><INDENT>actual_distribution = d.distribution if isinstance(d, self.Root) else d<EOL>ds.append(actual_distribution)<EOL>if (value is not None and len(value) > index and<EOL>value[index] is not None):<EOL><INDENT>seed()<EOL>next_value = value[index]<EOL><DEDENT>else:<EOL><INDENT>next_value = actual_distribution.sample(<EOL>sample_shape=sample_shape if isinstance(d, self.Root) else (),<EOL>seed=seed())<EOL><DEDENT>values_out.append(next_value)<EOL>index += <NUM_LIT:1><EOL>d = gen.send(next_value)<EOL><DEDENT><DEDENT>except StopIteration:<EOL><INDENT>pass<EOL><DEDENT>return ds, values_out<EOL>", "docstring": "Executes `model`, creating both samples and distributions.", "id": "f15666:c0:m1"}
{"signature": "def _verifyPdfWithNumpy(self, vmf, atol=<NUM_LIT>):", "body": "dim = tf.compat.dimension_value(vmf.event_shape[-<NUM_LIT:1>])<EOL>nsamples = <NUM_LIT:10><EOL>sample_shape = [nsamples] + tensorshape_util.as_list(<EOL>vmf.batch_shape) + [dim]<EOL>uniforms = np.random.randn(*sample_shape)<EOL>uniforms /= np.linalg.norm(uniforms, axis=-<NUM_LIT:1>, keepdims=True)<EOL>uniforms = uniforms.astype(dtype_util.as_numpy_dtype(vmf.dtype))<EOL>vmf_samples = vmf.sample(<EOL>sample_shape=[nsamples], seed=tfp_test_util.test_seed())<EOL>samples = tf.concat([uniforms, vmf_samples], axis=<NUM_LIT:0>)<EOL>samples = tf.debugging.check_numerics(samples, '<STR_LIT>')<EOL>samples = self.evaluate(samples)<EOL>log_prob = vmf.log_prob(samples)<EOL>log_prob = tf.debugging.check_numerics(log_prob, '<STR_LIT>')<EOL>try:<EOL><INDENT>from scipy.special import gammaln  <EOL>from scipy.special import ive  <EOL><DEDENT>except ImportError:<EOL><INDENT>tf.compat.v1.logging.warn('<STR_LIT>')<EOL>return<EOL><DEDENT>conc = self.evaluate(vmf.concentration)<EOL>mean_dir = self.evaluate(vmf.mean_direction)<EOL>log_true_sphere_surface_area = (<EOL>np.log(<NUM_LIT:2>) + (dim / <NUM_LIT:2>) * np.log(np.pi) - gammaln(dim / <NUM_LIT:2>))<EOL>expected = (<EOL>conc * np.sum(samples * mean_dir, axis=-<NUM_LIT:1>) +<EOL>np.where(conc > <NUM_LIT:0>,<EOL>(dim / <NUM_LIT:2> - <NUM_LIT:1>) * np.log(conc) -<EOL>(dim / <NUM_LIT:2>) * np.log(<NUM_LIT:2> * np.pi) -<EOL>np.log(ive(dim / <NUM_LIT:2> - <NUM_LIT:1>, conc)) -<EOL>np.abs(conc),<EOL>-log_true_sphere_surface_area))<EOL>self.assertAllClose(expected, self.evaluate(log_prob),<EOL>atol=atol)<EOL>", "docstring": "Verifies log_prob evaluations with numpy/scipy.\n\n        Both uniform random points and sampled points are evaluated.\n\n        Args:\n          vmf: A `tfp.distributions.VonMisesFisher` instance.\n          atol: Absolute difference tolerable.", "id": "f15668:c0:m3"}
{"signature": "@property<EOL><INDENT>def concentration0(self):<DEDENT>", "body": "return self.bijector.concentration0<EOL>", "docstring": "Concentration parameter associated with a `0` outcome.", "id": "f15670:c0:m3"}
{"signature": "@kullback_leibler.RegisterKL(Categorical, Categorical)<EOL>def _kl_categorical_categorical(a, b, name=None):", "body": "with tf.name_scope(name or \"<STR_LIT>\"):<EOL><INDENT>delta_log_probs1 = (tf.nn.log_softmax(a.logits) -<EOL>tf.nn.log_softmax(b.logits))<EOL>return tf.reduce_sum(<EOL>input_tensor=tf.nn.softmax(a.logits) * delta_log_probs1, axis=-<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Calculate the batched KL divergence KL(a || b) with a and b Categorical.\n\n    Args:\n      a: instance of a Categorical distribution object.\n      b: instance of a Categorical distribution object.\n      name: (optional) Name to use for created operations.\n        default is \"kl_categorical_categorical\".\n\n    Returns:\n      Batchwise KL(a || b)", "id": "f15671:m1"}
{"signature": "def _broadcast_cat_event_and_params(event, params, base_dtype):", "body": "if dtype_util.is_integer(event.dtype):<EOL><INDENT>pass<EOL><DEDENT>elif dtype_util.is_floating(event.dtype):<EOL><INDENT>event = tf.cast(event, dtype=tf.int32)<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(base_dtype))<EOL><DEDENT>shape_known_statically = (<EOL>tensorshape_util.rank(params.shape) is not None and<EOL>tensorshape_util.is_fully_defined(params.shape[:-<NUM_LIT:1>]) and<EOL>tensorshape_util.is_fully_defined(event.shape))<EOL>if not shape_known_statically or params.shape[:-<NUM_LIT:1>] != event.shape:<EOL><INDENT>params *= tf.ones_like(event[..., tf.newaxis],<EOL>dtype=params.dtype)<EOL>params_shape = tf.shape(input=params)[:-<NUM_LIT:1>]<EOL>event *= tf.ones(params_shape, dtype=event.dtype)<EOL>if tensorshape_util.rank(params.shape) is not None:<EOL><INDENT>tensorshape_util.set_shape(event, params.shape[:-<NUM_LIT:1>])<EOL><DEDENT><DEDENT>return event, params<EOL>", "docstring": "Broadcasts the event or distribution parameters.", "id": "f15671:m0"}
{"signature": "def _build(self, model):", "body": "if not isinstance(model, collections.Sequence):<EOL><INDENT>raise TypeError('<STR_LIT>'.format(<EOL>type(model).__name__))<EOL><DEDENT>self._dist_fn = model<EOL>self._dist_fn_wrapped, self._dist_fn_args = zip(*[<EOL>_unify_call_signature(i, dist_fn)<EOL>for i, dist_fn in enumerate(model)])<EOL>", "docstring": "Creates `dist_fn`, `dist_fn_wrapped`, `dist_fn_args`.", "id": "f15674:c0:m1"}
{"signature": "def _resolve_distribution_names(dist_fn_args, dist_names, leaf_name):", "body": "if dist_names is None:<EOL><INDENT>dist_names = []<EOL><DEDENT>else:<EOL><INDENT>dist_names = dist_names.copy()<EOL><DEDENT>n = len(dist_fn_args)<EOL>dist_names.extend([None]*(n - len(dist_names)))<EOL>for i_, args in enumerate(reversed(dist_fn_args)):<EOL><INDENT>if not args:<EOL><INDENT>continue  <EOL><DEDENT>i = n - i_ - <NUM_LIT:1><EOL>for j, arg_name in enumerate(args):<EOL><INDENT>dist_names[i - j - <NUM_LIT:1>] = arg_name<EOL><DEDENT><DEDENT>j = <NUM_LIT:0><EOL>for i_ in range(len(dist_names)):<EOL><INDENT>i = n - i_ - <NUM_LIT:1><EOL>if dist_names[i] is None:<EOL><INDENT>dist_names[i] = leaf_name if j == <NUM_LIT:0> else leaf_name + str(j)<EOL>j += <NUM_LIT:1><EOL><DEDENT><DEDENT>return tuple(dist_names)<EOL>", "docstring": "Uses arg names to resolve distribution names.", "id": "f15674:m2"}
{"signature": "@kullback_leibler.RegisterKL(JointDistributionSequential,<EOL>JointDistributionSequential)<EOL>def _kl_joint_joint(d0, d1, name=None):", "body": "if len(d0._dist_fn_wrapped) != len(d1._dist_fn_wrapped):  <EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>if (not all(a is None for a in d0._dist_fn_args) or  <EOL>not all(a is None for a in d1._dist_fn_args)):  <EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>with tf.name_scope(name or '<STR_LIT>'):<EOL><INDENT>return sum(kullback_leibler.kl_divergence(d0_(), d1_())<EOL>for d0_, d1_ in zip(d0._dist_fn_wrapped, d1._dist_fn_wrapped))<EOL><DEDENT>", "docstring": "Calculate the KL divergence between two `JointDistributionSequential`s.\n\n    Args:\n      d0: instance of a `JointDistributionSequential` object.\n      d1: instance of a `JointDistributionSequential` object.\n      name: (optional) Name to use for created operations.\n        Default value: `\"kl_joint_joint\"`.\n\n    Returns:\n      kl_joint_joint: `Tensor` The sum of KL divergences between elemental\n        distributions of two joint distributions.\n\n    Raises:\n      ValueError: when joint distributions have a different number of elemental\n        distributions.\n      ValueError: when either joint distribution has a distribution with dynamic\n        dependency, i.e., when either joint distribution is not a collection of\n        independent distributions.", "id": "f15674:m4"}
{"signature": "def _get_required_args(fn):", "body": "argspec = tf_inspect.getfullargspec(fn)<EOL>args = argspec.args<EOL>if tf_inspect.isclass(fn):<EOL><INDENT>args = args[<NUM_LIT:1>:]  <EOL><DEDENT>if argspec.defaults:<EOL><INDENT>args = args[:-len(argspec.defaults)]<EOL><DEDENT>return tuple(args)<EOL>", "docstring": "Returns the distribution's required args.", "id": "f15674:m3"}
{"signature": "def _resolve_graph(self, distribution_names=None, leaf_name='<STR_LIT:x>'):", "body": "<EOL>if distribution_names is None or any(self._dist_fn_args):<EOL><INDENT>distribution_names = _resolve_distribution_names(<EOL>self._dist_fn_args, distribution_names, leaf_name)<EOL><DEDENT>if len(set(distribution_names)) != len(distribution_names):<EOL><INDENT>raise ValueError('<STR_LIT>'.format(<EOL>distribution_names))<EOL><DEDENT>if len(distribution_names) != len(self._dist_fn_wrapped):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return tuple(zip(distribution_names,<EOL>tuple(() if a is None else a for a in self._dist_fn_args)))<EOL>", "docstring": "Creates a `tuple` of `tuple`s of dependencies.\n\n        This function is **experimental**. That said, we encourage its use\n        and ask that you report problems to `tfprobability@tensorflow.org`.\n\n        Args:\n          distribution_names: `list` of `str` or `None` names corresponding to each\n            of `model` elements. (`None`s are expanding into the\n            appropriate `str`.)\n          leaf_name: `str` used when no maker depends on a particular\n            `model` element.\n\n        Returns:\n          graph: `tuple` of `(str tuple)` pairs representing the name of each\n            distribution (maker) and the names of its dependencies.\n\n        #### Example\n\n        ```python\n        d = tfd.JointDistributionSequential([\n                         tfd.Independent(tfd.Exponential(rate=[100, 120]), 1),\n            lambda    e: tfd.Gamma(concentration=e[..., 0], rate=e[..., 1]),\n                         tfd.Normal(loc=0, scale=2.),\n            lambda n, g: tfd.Normal(loc=n, scale=g),\n        ])\n        d._resolve_graph()\n        # ==> (\n        #       ('e', ()),\n        #       ('g', ('e',)),\n        #       ('n', ()),\n        #       ('x', ('n', 'g')),\n        #     )\n        ```", "id": "f15674:c0:m6"}
{"signature": "def _unify_call_signature(i, dist_fn):", "body": "if distribution_util.is_distribution_instance(dist_fn):<EOL><INDENT>return (lambda *_: dist_fn), None<EOL><DEDENT>if not callable(dist_fn):<EOL><INDENT>raise TypeError('<STR_LIT>'<EOL>'<STR_LIT>'.format(dist_fn))<EOL><DEDENT>args = _get_required_args(dist_fn)<EOL>if not args:<EOL><INDENT>return (lambda *_: dist_fn()), ()<EOL><DEDENT>@functools.wraps(dist_fn)<EOL>def dist_fn_wrapped(*xs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if i != len(xs):<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>i, dist_fn, i, len(xs)))<EOL><DEDENT>if len(xs) < len(args):<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>i, dist_fn, len(args), len(xs)))<EOL><DEDENT>return dist_fn(*reversed(xs[-len(args):]))<EOL><DEDENT>return dist_fn_wrapped, args<EOL>", "docstring": "Creates `dist_fn_wrapped` which calls `dist_fn` with all prev nodes.\n\n    Args:\n      i: Python `int` corresponding to position in topologically sorted DAG.\n      dist_fn: Python `callable` which takes a subset of previously constructed\n        distributions (in reverse order) and produces a new distribution instance.\n\n    Returns:\n      dist_fn_wrapped: Python `callable` which takes all previous distributions\n        (in non reverse order) and produces a  new distribution instance.\n      args: `tuple` of `str` representing the arg names of `dist_fn` (and in non\n        wrapped, \"natural\" order). `None` is returned only if the input is not a\n        `callable`.", "id": "f15674:m1"}
{"signature": "def _make_summary_statistic(attr):", "body": "def _fn(self):<EOL><INDENT>if any(self._dist_fn_args):  <EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>' + attr + '<STR_LIT>'<EOL>'<STR_LIT>'.format(self.model))<EOL><DEDENT>return self._unflatten(getattr(d(), attr)() for d in self._dist_fn_wrapped)  <EOL><DEDENT>return _fn<EOL>", "docstring": "Factory for making summary statistics, eg, mean, mode, stddev.", "id": "f15674:m0"}
{"signature": "def __init__(self,<EOL>total_count,<EOL>logits=None,<EOL>probs=None,<EOL>validate_args=False,<EOL>allow_nan_stats=True,<EOL>name=\"<STR_LIT>\"):", "body": "parameters = dict(locals())<EOL>with tf.name_scope(name) as name:<EOL><INDENT>dtype = dtype_util.common_dtype([total_count, logits, probs], tf.float32)<EOL>self._total_count = tf.convert_to_tensor(<EOL>value=total_count, name=\"<STR_LIT>\", dtype=dtype)<EOL>if validate_args:<EOL><INDENT>self._total_count = (<EOL>distribution_util.embed_check_nonnegative_integer_form(<EOL>self._total_count))<EOL><DEDENT>self._logits, self._probs = distribution_util.get_logits_and_probs(<EOL>logits=logits,<EOL>probs=probs,<EOL>multidimensional=True,<EOL>validate_args=validate_args,<EOL>name=name,<EOL>dtype=dtype)<EOL>self._mean_val = self._total_count[..., tf.newaxis] * self._probs<EOL><DEDENT>super(Multinomial, self).__init__(<EOL>dtype=dtype,<EOL>reparameterization_type=reparameterization.NOT_REPARAMETERIZED,<EOL>validate_args=validate_args,<EOL>allow_nan_stats=allow_nan_stats,<EOL>parameters=parameters,<EOL>graph_parents=[self._total_count, self._logits, self._probs],<EOL>name=name)<EOL>", "docstring": "Initialize a batch of Multinomial distributions.\n\n        Args:\n          total_count: Non-negative floating point tensor with shape broadcastable\n            to `[N1,..., Nm]` with `m >= 0`. Defines this as a batch of\n            `N1 x ... x Nm` different Multinomial distributions. Its components\n            should be equal to integer values.\n          logits: Floating point tensor representing unnormalized log-probabilities\n            of a positive event with shape broadcastable to\n            `[N1,..., Nm, K]` `m >= 0`, and the same dtype as `total_count`. Defines\n            this as a batch of `N1 x ... x Nm` different `K` class Multinomial\n            distributions. Only one of `logits` or `probs` should be passed in.\n          probs: Positive floating point tensor with shape broadcastable to\n            `[N1,..., Nm, K]` `m >= 0` and same dtype as `total_count`. Defines\n            this as a batch of `N1 x ... x Nm` different `K` class Multinomial\n            distributions. `probs`'s components in the last portion of its shape\n            should sum to `1`. Only one of `logits` or `probs` should be passed in.\n          validate_args: Python `bool`, default `False`. When `True` distribution\n            parameters are checked for validity despite possibly degrading runtime\n            performance. When `False` invalid inputs may silently render incorrect\n            outputs.\n          allow_nan_stats: Python `bool`, default `True`. When `True`, statistics\n            (e.g., mean, mode, variance) use the value \"`NaN`\" to indicate the\n            result is undefined. When `False`, an exception is raised if one or\n            more of the statistic's batch members are undefined.\n          name: Python `str` name prefixed to Ops created by this class.", "id": "f15675:c0:m0"}
{"signature": "def __init__(self,<EOL>distribution,<EOL>batch_shape,<EOL>validate_args=False,<EOL>allow_nan_stats=True,<EOL>name=None):", "body": "parameters = dict(locals())<EOL>name = name or \"<STR_LIT>\" + distribution.name<EOL>with tf.name_scope(name) as name:<EOL><INDENT>self._batch_shape_unexpanded = tf.convert_to_tensor(<EOL>value=batch_shape, dtype=tf.int32, name=\"<STR_LIT>\")<EOL>validate_init_args_statically(distribution, self._batch_shape_unexpanded)<EOL>batch_shape, batch_shape_static, runtime_assertions = calculate_reshape(<EOL>distribution.batch_shape_tensor(), self._batch_shape_unexpanded,<EOL>validate_args)<EOL>self._distribution = distribution<EOL>self._batch_shape_ = batch_shape<EOL>self._batch_shape_static = batch_shape_static<EOL>self._runtime_assertions = runtime_assertions<EOL>super(BatchReshape, self).__init__(<EOL>dtype=distribution.dtype,<EOL>reparameterization_type=distribution.reparameterization_type,<EOL>validate_args=validate_args,<EOL>allow_nan_stats=allow_nan_stats,<EOL>parameters=parameters,<EOL>graph_parents=(<EOL>[self._batch_shape_unexpanded] + distribution._graph_parents),  <EOL>name=name)<EOL><DEDENT>", "docstring": "Construct BatchReshape distribution.\n\n        Args:\n          distribution: The base distribution instance to reshape. Typically an\n            instance of `Distribution`.\n          batch_shape: Positive `int`-like vector-shaped `Tensor` representing\n            the new shape of the batch dimensions. Up to one dimension may contain\n            `-1`, meaning the remainder of the batch size.\n          validate_args: Python `bool`, default `False`. When `True` distribution\n            parameters are checked for validity despite possibly degrading runtime\n            performance. When `False` invalid inputs may silently render incorrect\n            outputs.\n          allow_nan_stats: Python `bool`, default `True`. When `True`, statistics\n            (e.g., mean, mode, variance) use the value \"`NaN`\" to indicate the\n            result is undefined. When `False`, an exception is raised if one or\n            more of the statistic's batch members are undefined.\n          name: The name to give Ops created by the initializer.\n            Default value: `\"BatchReshape\" + distribution.name`.\n\n        Raises:\n          ValueError: if `batch_shape` is not a vector.\n          ValueError: if `batch_shape` has non-positive elements.\n          ValueError: if `batch_shape` size is not the same as a\n            `distribution.batch_shape` size.", "id": "f15679:c0:m0"}
{"signature": "def __init__(self,<EOL>power,<EOL>dtype=tf.int32,<EOL>interpolate_nondiscrete=True,<EOL>sample_maximum_iterations=<NUM_LIT:100>,<EOL>validate_args=False,<EOL>allow_nan_stats=False,<EOL>name=\"<STR_LIT>\"):", "body": "parameters = dict(locals())<EOL>with tf.name_scope(name) as name:<EOL><INDENT>power = tf.convert_to_tensor(<EOL>value=power,<EOL>name=\"<STR_LIT>\",<EOL>dtype=dtype_util.common_dtype([power], preferred_dtype=tf.float32))<EOL>if (not dtype_util.is_floating(power.dtype) or<EOL>dtype_util.base_equal(power.dtype, tf.float16)):<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\".format(<EOL>dtype_util.name(power.dtype)))<EOL><DEDENT>runtime_assertions = []<EOL>if validate_args:<EOL><INDENT>runtime_assertions.append(assert_util.assert_greater(<EOL>power, np.ones([], power.dtype.as_numpy_dtype)))<EOL><DEDENT>with tf.control_dependencies(runtime_assertions):<EOL><INDENT>self._power = tf.identity(power, name=\"<STR_LIT>\")<EOL><DEDENT><DEDENT>self._interpolate_nondiscrete = interpolate_nondiscrete<EOL>self._sample_maximum_iterations = sample_maximum_iterations<EOL>super(Zipf, self).__init__(<EOL>dtype=dtype,<EOL>reparameterization_type=reparameterization.NOT_REPARAMETERIZED,<EOL>validate_args=validate_args,<EOL>allow_nan_stats=allow_nan_stats,<EOL>parameters=parameters,<EOL>graph_parents=[self._power],<EOL>name=name)<EOL>", "docstring": "Initialize a batch of Zipf distributions.\n\n        Args:\n          power: `Float` like `Tensor` representing the power parameter. Must be\n            strictly greater than `1`.\n          dtype: The `dtype` of `Tensor` returned by `sample`.\n            Default value: `tf.int32`.\n          interpolate_nondiscrete: Python `bool`. When `False`, `log_prob` returns\n            `-inf` (and `prob` returns `0`) for non-integer inputs. When `True`,\n            `log_prob` evaluates the continuous function `-power log(k) -\n            log(zeta(power))` , which matches the Zipf pmf at integer arguments `k`\n            (note that this function is not itself a normalized probability\n            log-density).\n            Default value: `True`.\n          sample_maximum_iterations: Maximum number of iterations of allowable\n            iterations in `sample`. When `validate_args=True`, samples which fail to\n            reach convergence (subject to this cap) are masked out with\n            `self.dtype.min` or `nan` depending on `self.dtype.is_integer`.\n            Default value: `100`.\n          validate_args: Python `bool`, default `False`. When `True` distribution\n            parameters are checked for validity despite possibly degrading runtime\n            performance. When `False` invalid inputs may silently render incorrect\n            outputs.\n            Default value: `False`.\n          allow_nan_stats: Python `bool`, default `True`. When `True`, statistics\n            (e.g., mean, mode, variance) use the value \"`NaN`\" to indicate the\n            result is undefined. When `False`, an exception is raised if one or more\n            of the statistic's batch members are undefined.\n            Default value: `False`.\n          name: Python `str` name prefixed to Ops created by this class.\n            Default value: `'Zipf'`.\n\n        Raises:\n          TypeError: if `power` is not `float` like.", "id": "f15682:c0:m0"}
{"signature": "@property<EOL><INDENT>def power(self):<DEDENT>", "body": "return self._power<EOL>", "docstring": "Exponent parameter.", "id": "f15682:c0:m2"}
{"signature": "def __init__(self,<EOL>loc=None,<EOL>scale_diag=None,<EOL>scale_identity_multiplier=None,<EOL>validate_args=False,<EOL>allow_nan_stats=True,<EOL>name=\"<STR_LIT>\"):", "body": "parameters = dict(locals())<EOL>with tf.name_scope(name):<EOL><INDENT>with tf.name_scope(\"<STR_LIT>\"):<EOL><INDENT>dtype = dtype_util.common_dtype(<EOL>[loc, scale_diag, scale_identity_multiplier], tf.float32)<EOL>scale = distribution_util.make_diag_scale(<EOL>loc=loc,<EOL>scale_diag=scale_diag,<EOL>scale_identity_multiplier=scale_identity_multiplier,<EOL>validate_args=False,<EOL>assert_positive=False,<EOL>dtype=dtype)<EOL><DEDENT><DEDENT>super(VectorLaplaceDiag, self).__init__(<EOL>loc=loc,<EOL>scale=scale,<EOL>validate_args=validate_args,<EOL>allow_nan_stats=allow_nan_stats,<EOL>name=name)<EOL>self._parameters = parameters<EOL>", "docstring": "Construct Vector Laplace distribution on `R^k`.\n\n        The `batch_shape` is the broadcast shape between `loc` and `scale`\n        arguments.\n\n        The `event_shape` is given by last dimension of the matrix implied by\n        `scale`. The last dimension of `loc` (if provided) must broadcast with this.\n\n        Recall that `covariance = 2 * scale @ scale.T`.\n\n        ```none\n        scale = diag(scale_diag + scale_identity_multiplier * ones(k))\n        ```\n\n        where:\n\n        * `scale_diag.shape = [k]`, and,\n        * `scale_identity_multiplier.shape = []`.\n\n        Additional leading dimensions (if any) will index batches.\n\n        If both `scale_diag` and `scale_identity_multiplier` are `None`, then\n        `scale` is the Identity matrix.\n\n        Args:\n          loc: Floating-point `Tensor`. If this is set to `None`, `loc` is\n            implicitly `0`. When specified, may have shape `[B1, ..., Bb, k]` where\n            `b >= 0` and `k` is the event size.\n          scale_diag: Non-zero, floating-point `Tensor` representing a diagonal\n            matrix added to `scale`. May have shape `[B1, ..., Bb, k]`, `b >= 0`,\n            and characterizes `b`-batches of `k x k` diagonal matrices added to\n            `scale`. When both `scale_identity_multiplier` and `scale_diag` are\n            `None` then `scale` is the `Identity`.\n          scale_identity_multiplier: Non-zero, floating-point `Tensor` representing\n            a scaled-identity-matrix added to `scale`. May have shape\n            `[B1, ..., Bb]`, `b >= 0`, and characterizes `b`-batches of scaled\n            `k x k` identity matrices added to `scale`. When both\n            `scale_identity_multiplier` and `scale_diag` are `None` then `scale` is\n            the `Identity`.\n          validate_args: Python `bool`, default `False`. When `True` distribution\n            parameters are checked for validity despite possibly degrading runtime\n            performance. When `False` invalid inputs may silently render incorrect\n            outputs.\n          allow_nan_stats: Python `bool`, default `True`. When `True`,\n            statistics (e.g., mean, mode, variance) use the value \"`NaN`\" to\n            indicate the result is undefined. When `False`, an exception is raised\n            if one or more of the statistic's batch members are undefined.\n          name: Python `str` name prefixed to Ops created by this class.\n\n        Raises:\n          ValueError: if at most `scale_identity_multiplier` is specified.", "id": "f15683:c0:m0"}
{"signature": "def variational_loss(self,<EOL>observations,<EOL>observation_index_points=None,<EOL>kl_weight=<NUM_LIT:1.>,<EOL>name='<STR_LIT>'):", "body": "with tf.name_scope(name or '<STR_LIT>'):<EOL><INDENT>if observation_index_points is None:<EOL><INDENT>observation_index_points = self._index_points<EOL><DEDENT>observation_index_points = tf.convert_to_tensor(<EOL>value=observation_index_points, dtype=self._dtype,<EOL>name='<STR_LIT>')<EOL>observations = tf.convert_to_tensor(<EOL>value=observations, dtype=self._dtype, name='<STR_LIT>')<EOL>kl_weight = tf.convert_to_tensor(<EOL>value=kl_weight, dtype=self._dtype,<EOL>name='<STR_LIT>')<EOL>kzx = self.kernel.matrix(self._inducing_index_points,<EOL>observation_index_points)<EOL>kzx_linop = tf.linalg.LinearOperatorFullMatrix(kzx)<EOL>loc = (self._mean_fn(observation_index_points) +<EOL>kzx_linop.matvec(self._kzz_inv_varloc, adjoint=True))<EOL>likelihood = independent.Independent(<EOL>normal.Normal(<EOL>loc=loc,<EOL>scale=tf.sqrt(self._observation_noise_variance + self._jitter),<EOL>name='<STR_LIT>'),<EOL>reinterpreted_batch_ndims=<NUM_LIT:1>)<EOL>obs_ll = likelihood.log_prob(observations)<EOL>chol_kzz_linop = tf.linalg.LinearOperatorLowerTriangular(self._chol_kzz)<EOL>chol_kzz_inv_kzx = chol_kzz_linop.solve(kzx)<EOL>kzz_inv_kzx = chol_kzz_linop.solve(chol_kzz_inv_kzx, adjoint=True)<EOL>kxx_diag = tf.linalg.diag_part(<EOL>self.kernel.matrix(<EOL>observation_index_points, observation_index_points))<EOL>ktilde_trace_term = (<EOL>tf.reduce_sum(input_tensor=kxx_diag, axis=-<NUM_LIT:1>) -<EOL>tf.reduce_sum(input_tensor=chol_kzz_inv_kzx ** <NUM_LIT:2>, axis=[-<NUM_LIT:2>, -<NUM_LIT:1>]))<EOL>other_trace_term = tf.reduce_sum(<EOL>input_tensor=(<EOL>self._variational_inducing_observations_posterior.scale.matmul(<EOL>kzz_inv_kzx) ** <NUM_LIT:2>),<EOL>axis=[-<NUM_LIT:2>, -<NUM_LIT:1>])<EOL>trace_term = (<NUM_LIT> * (ktilde_trace_term + other_trace_term) /<EOL>self._observation_noise_variance)<EOL>inducing_prior = gaussian_process.GaussianProcess(<EOL>kernel=self._kernel,<EOL>mean_fn=self._mean_fn,<EOL>index_points=self._inducing_index_points,<EOL>observation_noise_variance=self._observation_noise_variance)<EOL>kl_term = kl_weight * kullback_leibler.kl_divergence(<EOL>self._variational_inducing_observations_posterior,<EOL>inducing_prior)<EOL>lower_bound = (obs_ll - trace_term - kl_term)<EOL>return -tf.reduce_mean(input_tensor=lower_bound)<EOL><DEDENT>", "docstring": "Variational loss for the VGP.\n\n        Given `observations` and `observation_index_points`, compute the\n        negative variational lower bound as specified in [Hensman, 2013][1].\n\n        Args:\n          observations: `float` `Tensor` representing collection, or batch of\n            collections, of observations corresponding to\n            `observation_index_points`. Shape has the form `[b1, ..., bB, e]`, which\n            must be brodcastable with the batch and example shapes of\n            `observation_index_points`. The batch shape `[b1, ..., bB]` must be\n            broadcastable with the shapes of all other batched parameters\n            (`kernel.batch_shape`, `observation_index_points`, etc.).\n          observation_index_points: `float` `Tensor` representing finite (batch of)\n            vector(s) of points where observations are defined. Shape has the\n            form `[b1, ..., bB, e1, f1, ..., fF]` where `F` is the number of feature\n            dimensions and must equal `kernel.feature_ndims` and `e1` is the number\n            (size) of index points in each batch (we denote it `e1` to distinguish\n            it from the numer of inducing index points, denoted `e2` below). If\n            set to `None` uses `index_points` as the origin for observations.\n            Default value: None.\n          kl_weight: Amount by which to scale the KL divergence loss between prior\n            and posterior.\n            Default value: 1.\n          name: Python `str` name prefixed to Ops created by this class.\n            Default value: \"GaussianProcess\".\n        Returns:\n          loss: Scalar tensor representing the negative variational lower bound.\n            Can be directly used in a `tf.Optimizer`.\n        Raises:\n          ValueError: if `mean_fn` is not `None` and is not callable.\n\n        #### References\n\n        [1]: Hensman, J., Lawrence, N. \"Gaussian Processes for Big Data\", 2013\n             https://arxiv.org/abs/1309.6835", "id": "f15684:c0:m12"}
{"signature": "@property<EOL><INDENT>def scale(self):<DEDENT>", "body": "return self.bijector.scale<EOL>", "docstring": "The `scale` `LinearOperator` in `Y = scale @ X + loc`.", "id": "f15686:c0:m2"}
{"signature": "@property<EOL><INDENT>def total_concentration(self):<DEDENT>", "body": "return self._total_concentration<EOL>", "docstring": "Sum of last dim of concentration parameter.", "id": "f15689:c0:m4"}
{"signature": "def _variance_scale_term(self):", "body": "<EOL>c0 = self.total_concentration[..., tf.newaxis]<EOL>return tf.sqrt((<NUM_LIT:1.> + c0 / self.total_count[..., tf.newaxis]) / (<NUM_LIT:1.> + c0))<EOL>", "docstring": "Helper to `_covariance` and `_variance` which computes a shared scale.", "id": "f15689:c0:m15"}
{"signature": "def _set_seed(seed):", "body": "<EOL>if tf.executing_eagerly():<EOL><INDENT>tf.compat.v1.set_random_seed(seed)<EOL>return None<EOL><DEDENT>return seed<EOL>", "docstring": "Helper which uses graph seed if using TFE.", "id": "f15690:m1"}
{"signature": "def _mixture_stddev_np(pi_vector, mu_vector, sigma_vector):", "body": "pi_vector = np.expand_dims(pi_vector, axis=<NUM_LIT:1>)<EOL>mean_wa = np.matmul(pi_vector, np.expand_dims(mu_vector, axis=<NUM_LIT:2>))<EOL>var_wa = np.matmul(pi_vector, np.expand_dims(sigma_vector**<NUM_LIT:2>, axis=<NUM_LIT:2>))<EOL>mid_term = np.matmul(pi_vector, np.expand_dims(mu_vector**<NUM_LIT:2>, axis=<NUM_LIT:2>))<EOL>mixture_variance = (<EOL>np.squeeze(var_wa) + np.squeeze(mid_term) - np.squeeze(mean_wa**<NUM_LIT:2>))<EOL>return np.sqrt(mixture_variance)<EOL>", "docstring": "Computes the standard deviation of a univariate mixture distribution.\n\n    Acts upon `np.array`s (not `tf.Tensor`s).\n\n    Args:\n      pi_vector: A `np.array` of mixture weights. Shape `[batch, components]`.\n      mu_vector: A `np.array` of means. Shape `[batch, components]`\n      sigma_vector: A `np.array` of stddevs. Shape `[batch, components]`.\n\n    Returns:\n      A `np.array` containing the batch of standard deviations.", "id": "f15690:m2"}
{"signature": "def sample_distributions(self, sample_shape=(), seed=None, value=None,<EOL>name='<STR_LIT>'):", "body": "with self._name_scope(name):<EOL><INDENT>ds, xs = self._call_flat_sample_distributions(sample_shape, seed, value)<EOL>return self._unflatten(ds), self._unflatten(xs)<EOL><DEDENT>", "docstring": "Generate samples and the (random) distributions.\n\n        Note that a call to `sample()` without arguments will generate a single\n        sample.\n\n        Args:\n          sample_shape: 0D or 1D `int32` `Tensor`. Shape of the generated samples.\n          seed: Python integer seed for generating random numbers.\n          value: `list` of `Tensor`s in `distribution_fn` order to use to\n            parameterize other (\"downstream\") distribution makers.\n            Default value: `None` (i.e., draw a sample from each distribution).\n          name: name prepended to ops created by this function.\n            Default value: `\"sample_distributions\"`.\n\n        Returns:\n          distributions: a `tuple` of `Distribution` instances for each of\n            `distribution_fn`.\n          samples: a `tuple` of `Tensor`s with prepended dimensions `sample_shape`\n            for each of `distribution_fn`.", "id": "f15691:c0:m10"}
{"signature": "@property<EOL><INDENT>def event_shape(self):<DEDENT>", "body": "<EOL>if self._most_recently_built_distributions is None:<EOL><INDENT>return None<EOL><DEDENT>return self._unflatten(<EOL>tf.TensorShape(None) if d is None else d.event_shape<EOL>for d in self._most_recently_built_distributions)<EOL>", "docstring": "Shape of a single sample from a single batch as a `TensorShape`.\n\n        May be partially defined or unknown.\n\n        Returns:\n          event_shape: `tuple` of `TensorShape`s representing the `event_shape` for\n            each distribution in `model`.", "id": "f15691:c0:m8"}
{"signature": "def is_scalar_event(self, name='<STR_LIT>'):", "body": "with self._name_scope(name):<EOL><INDENT>return self._unflatten(self._map_attr_over_dists('<STR_LIT>')[<NUM_LIT:1>])<EOL><DEDENT>", "docstring": "Indicates that `event_shape == []`.\n\n        Args:\n          name: Python `str` prepended to names of ops created by this function.\n\n        Returns:\n          is_scalar_event: `bool` scalar `Tensor` for each distribution in `model`.", "id": "f15691:c0:m13"}
{"signature": "@property<EOL><INDENT>def input_output_cholesky(self):<DEDENT>", "body": "return self._input_output_cholesky<EOL>", "docstring": "Boolean indicating if `Tensor` input/outputs are Cholesky factorized.", "id": "f15693:c0:m5"}
{"signature": "def log_normalization(self, name=\"<STR_LIT>\"):", "body": "with self._name_scope(name):<EOL><INDENT>return (self.df * self.scale_operator.log_abs_determinant() +<EOL><NUM_LIT:0.5> * self.df * self.dimension * math.log(<NUM_LIT>) +<EOL>self._multi_lgamma(<NUM_LIT:0.5> * self.df, self.dimension))<EOL><DEDENT>", "docstring": "Computes the log normalizing constant, log(Z).", "id": "f15693:c0:m19"}
{"signature": "@property<EOL><INDENT>def df(self):<DEDENT>", "body": "return self._df<EOL>", "docstring": "Wishart distribution degree(s) of freedom.", "id": "f15693:c0:m1"}
{"signature": "def __init__(self,<EOL>df,<EOL>scale_operator,<EOL>input_output_cholesky=False,<EOL>validate_args=False,<EOL>allow_nan_stats=True,<EOL>name=None):", "body": "parameters = dict(locals())<EOL>self._input_output_cholesky = input_output_cholesky<EOL>with tf.name_scope(name) as name:<EOL><INDENT>with tf.name_scope(\"<STR_LIT>\"):<EOL><INDENT>if not dtype_util.is_floating(scale_operator.dtype):<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\" %<EOL>scale_operator.dtype)<EOL><DEDENT>if not scale_operator.is_square:<EOL><INDENT>print(scale_operator.to_dense().eval())<EOL>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self._scale_operator = scale_operator<EOL>self._df = tf.convert_to_tensor(<EOL>value=df, dtype=scale_operator.dtype, name=\"<STR_LIT>\")<EOL>dtype_util.assert_same_float_dtype([self._df, self._scale_operator])<EOL>if tf.compat.dimension_value(self._scale_operator.shape[-<NUM_LIT:1>]) is None:<EOL><INDENT>self._dimension = tf.cast(<EOL>self._scale_operator.domain_dimension_tensor(),<EOL>dtype=self._scale_operator.dtype,<EOL>name=\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>self._dimension = tf.convert_to_tensor(<EOL>value=tf.compat.dimension_value(self._scale_operator.shape[-<NUM_LIT:1>]),<EOL>dtype=self._scale_operator.dtype,<EOL>name=\"<STR_LIT>\")<EOL><DEDENT>df_val = tf.get_static_value(self._df)<EOL>dim_val = tf.get_static_value(self._dimension)<EOL>if df_val is not None and dim_val is not None:<EOL><INDENT>df_val = np.asarray(df_val)<EOL>if not df_val.shape:<EOL><INDENT>df_val = [df_val]<EOL><DEDENT>if np.any(df_val < dim_val):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>% (df_val, dim_val))<EOL><DEDENT><DEDENT>elif validate_args:<EOL><INDENT>assertions = assert_util.assert_less_equal(<EOL>self._dimension,<EOL>self._df,<EOL>message=(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (self._dimension, self._df)))<EOL>self._df = distribution_util.with_dependencies(<EOL>[assertions], self._df)<EOL><DEDENT><DEDENT><DEDENT>super(_WishartLinearOperator, self).__init__(<EOL>dtype=self._scale_operator.dtype,<EOL>validate_args=validate_args,<EOL>allow_nan_stats=allow_nan_stats,<EOL>reparameterization_type=reparameterization.FULLY_REPARAMETERIZED,<EOL>parameters=parameters,<EOL>graph_parents=(<EOL>[self._df, self._dimension] + self._scale_operator.graph_parents),<EOL>name=name)<EOL>", "docstring": "Construct Wishart distributions.\n\n        Args:\n          df: `float` or `double` tensor, the degrees of freedom of the\n            distribution(s). `df` must be greater than or equal to `k`.\n          scale_operator: `float` or `double` instance of `LinearOperator`.\n          input_output_cholesky: Python `bool`. If `True`, functions whose input or\n            output have the semantics of samples assume inputs are in Cholesky form\n            and return outputs in Cholesky form. In particular, if this flag is\n            `True`, input to `log_prob` is presumed of Cholesky form and output from\n            `sample`, `mean`, and `mode` are of Cholesky form.  Setting this\n            argument to `True` is purely a computational optimization and does not\n            change the underlying distribution; for instance, `mean` returns the\n            Cholesky of the mean, not the mean of Cholesky factors. The `variance`\n            and `stddev` methods are unaffected by this flag.\n            Default value: `False` (i.e., input/output does not have Cholesky\n            semantics).\n          validate_args: Python `bool`, default `False`. When `True` distribution\n            parameters are checked for validity despite possibly degrading runtime\n            performance. When `False` invalid inputs may silently render incorrect\n            outputs.\n          allow_nan_stats: Python `bool`, default `True`. When `True`, statistics\n            (e.g., mean, mode, variance) use the value \"`NaN`\" to indicate the\n            result is undefined. When `False`, an exception is raised if one or\n            more of the statistic's batch members are undefined.\n          name: Python `str` name prefixed to Ops created by this class.\n\n        Raises:\n          TypeError: if scale is not floating-type\n          TypeError: if scale.dtype != df.dtype\n          ValueError: if df < k, where scale operator event shape is\n            `(k, k)`", "id": "f15693:c0:m0"}
{"signature": "def _multi_digamma(self, a, p, name=\"<STR_LIT>\"):", "body": "with self._name_scope(name):<EOL><INDENT>seq = self._multi_gamma_sequence(a, p)<EOL>return tf.reduce_sum(input_tensor=tf.math.digamma(seq), axis=[-<NUM_LIT:1>])<EOL><DEDENT>", "docstring": "Computes the multivariate digamma function; Psi_p(a).", "id": "f15693:c0:m22"}
{"signature": "@property<EOL><INDENT>def scale_operator(self):<DEDENT>", "body": "return self._scale_operator<EOL>", "docstring": "Wishart distribution scale matrix as an Linear Operator.", "id": "f15693:c0:m4"}
{"signature": "def __init__(self,<EOL>loc,<EOL>scale,<EOL>validate_args=False,<EOL>allow_nan_stats=True,<EOL>name=\"<STR_LIT>\"):", "body": "parameters = dict(locals())<EOL>with tf.name_scope(name) as name:<EOL><INDENT>dtype = dtype_util.common_dtype([loc, scale], preferred_dtype=tf.float32)<EOL>loc = tf.convert_to_tensor(value=loc, name=\"<STR_LIT>\", dtype=dtype)<EOL>scale = tf.convert_to_tensor(value=scale, name=\"<STR_LIT>\", dtype=dtype)<EOL>with tf.control_dependencies(<EOL>[assert_util.assert_positive(scale)] if validate_args else []):<EOL><INDENT>self._loc = tf.identity(loc, name=\"<STR_LIT>\")<EOL>self._scale = tf.identity(scale, name=\"<STR_LIT>\")<EOL><DEDENT>dtype_util.assert_same_float_dtype([self._loc, self._scale])<EOL><DEDENT>super(HalfCauchy, self).__init__(<EOL>dtype=self._scale.dtype,<EOL>reparameterization_type=reparameterization.FULLY_REPARAMETERIZED,<EOL>validate_args=validate_args,<EOL>allow_nan_stats=allow_nan_stats,<EOL>parameters=parameters,<EOL>graph_parents=[self._loc, self._scale],<EOL>name=name)<EOL>", "docstring": "Construct a half-Cauchy distribution with `loc` and `scale`.\n\n        Args:\n          loc: Floating-point `Tensor`; the location(s) of the distribution(s).\n          scale: Floating-point `Tensor`; the scale(s) of the distribution(s).\n            Must contain only positive values.\n          validate_args: Python `bool`, default `False`. When `True` distribution\n            parameters are checked for validity despite possibly degrading runtime\n            performance. When `False` invalid inputs may silently render incorrect\n            outputs. Default value: `False` (i.e. do not validate args).\n          allow_nan_stats: Python `bool`, default `True`. When `True`, statistics\n            (e.g., mean, mode, variance) use the value \"`NaN`\" to indicate the\n            result is undefined. When `False`, an exception is raised if one or\n            more of the statistic's batch members are undefined.\n            Default value: `True`.\n          name: Python `str` name prefixed to Ops created by this class.\n            Default value: 'HalfCauchy'.\n\n        Raises:\n          TypeError: if `loc` and `scale` have different `dtype`.", "id": "f15697:c0:m0"}
{"signature": "def _inv_z(self, z):", "body": "with tf.name_scope(\"<STR_LIT>\"):<EOL><INDENT>return z * self.scale + self.loc<EOL><DEDENT>", "docstring": "Reconstruct input `x` from a its normalized version.", "id": "f15697:c0:m13"}
{"signature": "def _extend_support_with_default_value(self, x, f, default_value):", "body": "with tf.name_scope(\"<STR_LIT>\"):<EOL><INDENT>x = tf.convert_to_tensor(value=x, dtype=self.dtype, name=\"<STR_LIT:x>\")<EOL>loc = self.loc + tf.zeros_like(self.scale) + tf.zeros_like(x)<EOL>x = x + tf.zeros_like(loc)<EOL>y = f(tf.where(x < loc, self._inv_z(<NUM_LIT:0.5>) + tf.zeros_like(x), x))<EOL>if default_value == <NUM_LIT:0.>:<EOL><INDENT>default_value = tf.zeros_like(y)<EOL><DEDENT>elif default_value == <NUM_LIT:1.>:<EOL><INDENT>default_value = tf.ones_like(y)<EOL><DEDENT>else:<EOL><INDENT>default_value = tf.fill(<EOL>dims=tf.shape(input=y),<EOL>value=dtype_util.as_numpy_dtype(self.dtype)(default_value))<EOL><DEDENT>return tf.where(x < loc, default_value, y)<EOL><DEDENT>", "docstring": "Returns `f(x)` if x is in the support, and `default_value` otherwise.\n\n        Given `f` which is defined on the support of this distribution\n        (`x >= loc`), extend the function definition to the real line\n        by defining `f(x) = default_value` for `x < loc`.\n\n        Args:\n          x: Floating-point `Tensor` to evaluate `f` at.\n          f: Callable that takes in a `Tensor` and returns a `Tensor`. This\n            represents the function whose domain of definition we want to extend.\n          default_value: Python or numpy literal representing the value to use for\n            extending the domain.\n        Returns:\n          `Tensor` representing an extension of `f(x)`.", "id": "f15697:c0:m20"}
{"signature": "@property<EOL><INDENT>def scale(self):<DEDENT>", "body": "return self._scale<EOL>", "docstring": "Distribution parameter for the scale.", "id": "f15697:c0:m4"}
{"signature": "def check_arg_in_support(f):", "body": "@functools.wraps(f)<EOL>def _check_arg_and_apply_f(*args, **kwargs):<EOL><INDENT>dist = args[<NUM_LIT:0>]<EOL>x = args[<NUM_LIT:1>]<EOL>with tf.control_dependencies([<EOL>assert_util.assert_greater_equal(<EOL>x, dist.loc, message=\"<STR_LIT>\")<EOL>] if dist.validate_args else []):<EOL><INDENT>return f(*args, **kwargs)<EOL><DEDENT><DEDENT>return _check_arg_and_apply_f<EOL>", "docstring": "Decorator function for argument bounds checking.\n\n    This decorator is meant to be used with methods that require the first\n    argument to be in the support of the distribution. If `validate_args` is\n    `True`, the method is wrapped with an assertion that the first argument is\n    greater than or equal to `loc`, since the support of the half-Cauchy\n    distribution is given by `[loc, infinity)`.\n\n\n    Args:\n      f: method to be decorated.\n\n    Returns:\n      Returns a decorated method that, when `validate_args` attribute of the class\n      is `True`, will assert that all elements in the first argument are within\n      the support of the distribution before executing the original method.", "id": "f15697:m0"}
{"signature": "@property<EOL><INDENT>def probs(self):<DEDENT>", "body": "return self._probs<EOL>", "docstring": "Vector of coordinatewise probabilities.", "id": "f15698:c0:m4"}
{"signature": "@kullback_leibler.RegisterKL(OneHotCategorical, OneHotCategorical)<EOL>def _kl_categorical_categorical(a, b, name=None):", "body": "with tf.name_scope(name or \"<STR_LIT>\"):<EOL><INDENT>return tf.reduce_sum(<EOL>input_tensor=tf.nn.softmax(a.logits) *<EOL>(tf.nn.log_softmax(a.logits) - tf.nn.log_softmax(b.logits)),<EOL>axis=-<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Calculate the batched KL divergence KL(a || b) with a, b OneHotCategorical.\n\n    Args:\n      a: instance of a OneHotCategorical distribution object.\n      b: instance of a OneHotCategorical distribution object.\n      name: (optional) Name to use for created operations.\n        default is \"kl_categorical_categorical\".\n\n    Returns:\n      Batchwise KL(a || b)", "id": "f15698:m0"}
{"signature": "def _depth(g):", "body": "def _explore(v):<EOL><INDENT>if v.depth < <NUM_LIT:0>:<EOL><INDENT>v.depth = ((<NUM_LIT:1> + max([-<NUM_LIT:1>] + [_explore(annotated_graph[u])<EOL>for u in v.parents]))<EOL>if v.parents else <NUM_LIT:0>)<EOL><DEDENT>return v.depth<EOL><DEDENT>annotated_graph = {k: _Node(k, v) for k, v in g.items()}<EOL>for v in annotated_graph.values():<EOL><INDENT>_explore(v)<EOL><DEDENT>return annotated_graph<EOL>", "docstring": "Computes the number of edges on longest path from node to root.", "id": "f15701:m0"}
{"signature": "def _build(self, model):", "body": "if not _is_dict_like(model):<EOL><INDENT>raise TypeError('<STR_LIT>'.format(<EOL>type(model).__name__))<EOL><DEDENT>[<EOL>self._dist_fn,<EOL>self._dist_fn_wrapped,<EOL>self._dist_fn_args,<EOL>self._dist_fn_name,  <EOL>] = _prob_chain_rule_flatten(model)<EOL>", "docstring": "Creates `dist_fn`, `dist_fn_wrapped`, `dist_fn_args`, `dist_fn_name`.", "id": "f15701:c0:m1"}
{"signature": "def _log_unnorm_prob(self, x, name=None):", "body": "with tf.name_scope(name or '<STR_LIT>'):<EOL><INDENT>x = tf.convert_to_tensor(value=x, name='<STR_LIT:x>')<EOL>if self.input_output_cholesky:<EOL><INDENT>logdet = <NUM_LIT> * tf.reduce_sum(<EOL>input_tensor=tf.math.log(tf.linalg.diag_part(x)), axis=[-<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>_, logdet = tf.linalg.slogdet(x)<EOL><DEDENT>answer = (self.concentration - <NUM_LIT:1.>) * logdet<EOL>return answer<EOL><DEDENT>", "docstring": "Returns the unnormalized log density of an LKJ distribution.\n\n        Args:\n          x: `float` or `double` `Tensor` of correlation matrices.  The shape of `x`\n            must be `B + [D, D]`, where `B` broadcasts with the shape of\n            `concentration`.\n          name: Python `str` name prefixed to Ops created by this function.\n\n        Returns:\n          log_p: A Tensor of the unnormalized log density of each matrix element of\n            `x`, with respect to an LKJ distribution with parameter the\n            corresponding element of `concentration`.", "id": "f15704:c0:m13"}
{"signature": "@property<EOL><INDENT>def concentration(self):<DEDENT>", "body": "return self._concentration<EOL>", "docstring": "Concentration parameter.", "id": "f15704:c0:m3"}
{"signature": "def _sample_n(self, num_samples, seed=None, name=None):", "body": "if self.dimension < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>')<EOL><DEDENT>seed = seed_stream.SeedStream(seed, '<STR_LIT>')<EOL>with tf.name_scope('<STR_LIT>' or name):<EOL><INDENT>if not dtype_util.is_floating(self.concentration.dtype):<EOL><INDENT>raise TypeError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT:{}>'.format(dtype_util.name(self.concentration.dtype)))<EOL><DEDENT>concentration = _replicate(num_samples, self.concentration)<EOL>concentration_shape = tf.shape(input=concentration)<EOL>if self.dimension <= <NUM_LIT:1>:<EOL><INDENT>shape = tf.concat([<EOL>concentration_shape, [self.dimension, self.dimension]], axis=<NUM_LIT:0>)<EOL>return tf.ones(shape=shape, dtype=self.concentration.dtype)<EOL><DEDENT>beta_conc = concentration + (self.dimension - <NUM_LIT>) / <NUM_LIT><EOL>beta_dist = beta.Beta(concentration1=beta_conc, concentration0=beta_conc)<EOL>corr12 = <NUM_LIT> * beta_dist.sample(seed=seed()) - <NUM_LIT:1.><EOL>first_row = tf.concat([<EOL>tf.ones_like(corr12)[..., tf.newaxis],<EOL>tf.zeros_like(corr12)[..., tf.newaxis]], axis=-<NUM_LIT:1>)<EOL>second_row = tf.concat([<EOL>corr12[..., tf.newaxis],<EOL>tf.sqrt(<NUM_LIT:1> - corr12**<NUM_LIT:2>)[..., tf.newaxis]], axis=-<NUM_LIT:1>)<EOL>chol_result = tf.concat([<EOL>first_row[..., tf.newaxis, :],<EOL>second_row[..., tf.newaxis, :]], axis=-<NUM_LIT:2>)<EOL>for n in range(<NUM_LIT:2>, self.dimension):<EOL><INDENT>beta_conc -= <NUM_LIT:0.5><EOL>norm = beta.Beta(<EOL>concentration1=n/<NUM_LIT>,<EOL>concentration0=beta_conc<EOL>).sample(seed=seed())<EOL>distance = tf.sqrt(norm)[..., tf.newaxis]<EOL>direction = _uniform_unit_norm(<EOL>n, concentration_shape, self.concentration.dtype, seed)<EOL>raw_correlation = distance * direction  <EOL>new_row = tf.concat(<EOL>[raw_correlation, tf.sqrt(<NUM_LIT:1.> - norm[..., tf.newaxis])], axis=-<NUM_LIT:1>)<EOL>chol_result = tf.concat([<EOL>chol_result,<EOL>tf.zeros_like(chol_result[..., <NUM_LIT:0>][..., tf.newaxis])], axis=-<NUM_LIT:1>)<EOL>chol_result = tf.concat(<EOL>[chol_result, new_row[..., tf.newaxis, :]], axis=-<NUM_LIT:2>)<EOL><DEDENT>if self.input_output_cholesky:<EOL><INDENT>return chol_result<EOL><DEDENT>result = tf.matmul(chol_result, chol_result, transpose_b=True)<EOL>result = tf.linalg.set_diag(<EOL>result,<EOL>tf.ones(shape=tf.shape(input=result)[:-<NUM_LIT:1>], dtype=result.dtype))<EOL>return result<EOL><DEDENT>", "docstring": "Returns a Tensor of samples from an LKJ distribution.\n\n        Args:\n          num_samples: Python `int`. The number of samples to draw.\n          seed: Python integer seed for RNG\n          name: Python `str` name prefixed to Ops created by this function.\n\n        Returns:\n          samples: A Tensor of correlation matrices with shape `[n, B, D, D]`,\n            where `B` is the shape of the `concentration` parameter, and `D`\n            is the `dimension`.\n\n        Raises:\n          ValueError: If `dimension` is negative.", "id": "f15704:c0:m9"}
{"signature": "@property<EOL><INDENT>def input_output_cholesky(self):<DEDENT>", "body": "return self._input_output_cholesky<EOL>", "docstring": "Boolean indicating if `Tensor` input/outputs are Cholesky factorized.", "id": "f15704:c0:m4"}
{"signature": "def _get_index_points(self, index_points=None):", "body": "if self._index_points is None and index_points is None:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>return index_points if index_points is not None else self._index_points<EOL>", "docstring": "Return `index_points` if not None, else `self._index_points`.\n\n        Args:\n          index_points: if given, this is what is returned; else,\n          `self._index_points`\n\n        Returns:\n          index_points: the given arg, if not None, else the class member\n          `self._index_points`.\n\n        Rases:\n          ValueError: if `index_points` and `self._index_points` are both `None`.", "id": "f15706:c0:m9"}
{"signature": "@kullback_leibler.RegisterKL(GaussianProcess, normal.Normal)<EOL>def _kl_gp_normal(gp, n, name=None):", "body": "return _kl_gp_compatible(gp, n, name or '<STR_LIT>')<EOL>", "docstring": "Calculate the batched KL divergence KL(gp || n).\n\n    Args:\n      gp: instance of a GaussianProcess distribution object.\n      n: instance of a Normal distribution object.\n      name: (optional) Name to use for created operations.\n        default is 'kl_gp_normal'.\n\n    Returns:\n      Batchwise KL(gp || n)", "id": "f15706:m4"}
{"signature": "def __init__(self,<EOL>loc=None,<EOL>scale_tril=None,<EOL>validate_args=False,<EOL>allow_nan_stats=True,<EOL>name=\"<STR_LIT>\"):", "body": "parameters = dict(locals())<EOL>def _convert_to_tensor(x, name, dtype):<EOL><INDENT>return None if x is None else tf.convert_to_tensor(<EOL>value=x, name=name, dtype=dtype)<EOL><DEDENT>if loc is None and scale_tril is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>with tf.name_scope(name) as name:<EOL><INDENT>with tf.name_scope(\"<STR_LIT>\"):<EOL><INDENT>dtype = dtype_util.common_dtype([loc, scale_tril], tf.float32)<EOL>loc = _convert_to_tensor(loc, name=\"<STR_LIT>\", dtype=dtype)<EOL>scale_tril = _convert_to_tensor(<EOL>scale_tril, name=\"<STR_LIT>\", dtype=dtype)<EOL>if scale_tril is None:<EOL><INDENT>scale = tf.linalg.LinearOperatorIdentity(<EOL>num_rows=distribution_util.dimension_size(loc, -<NUM_LIT:1>),<EOL>dtype=loc.dtype,<EOL>is_self_adjoint=True,<EOL>is_positive_definite=True,<EOL>assert_proper_shapes=validate_args)<EOL><DEDENT>else:<EOL><INDENT>scale = tf.linalg.LinearOperatorLowerTriangular(<EOL>scale_tril,<EOL>is_non_singular=True,<EOL>is_self_adjoint=False,<EOL>is_positive_definite=False)<EOL><DEDENT><DEDENT><DEDENT>super(MultivariateNormalTriL, self).__init__(<EOL>loc=loc,<EOL>scale=scale,<EOL>validate_args=validate_args,<EOL>allow_nan_stats=allow_nan_stats,<EOL>name=name)<EOL>self._parameters = parameters<EOL>", "docstring": "Construct Multivariate Normal distribution on `R^k`.\n\n        The `batch_shape` is the broadcast shape between `loc` and `scale`\n        arguments.\n\n        The `event_shape` is given by last dimension of the matrix implied by\n        `scale`. The last dimension of `loc` (if provided) must broadcast with this.\n\n        Recall that `covariance = scale @ scale.T`. A (non-batch) `scale` matrix is:\n\n        ```none\n        scale = scale_tril\n        ```\n\n        where `scale_tril` is lower-triangular `k x k` matrix with non-zero\n        diagonal, i.e., `tf.diag_part(scale_tril) != 0`.\n\n        Additional leading dimensions (if any) will index batches.\n\n        Args:\n          loc: Floating-point `Tensor`. If this is set to `None`, `loc` is\n            implicitly `0`. When specified, may have shape `[B1, ..., Bb, k]` where\n            `b >= 0` and `k` is the event size.\n          scale_tril: Floating-point, lower-triangular `Tensor` with non-zero\n            diagonal elements. `scale_tril` has shape `[B1, ..., Bb, k, k]` where\n            `b >= 0` and `k` is the event size.\n          validate_args: Python `bool`, default `False`. When `True` distribution\n            parameters are checked for validity despite possibly degrading runtime\n            performance. When `False` invalid inputs may silently render incorrect\n            outputs.\n          allow_nan_stats: Python `bool`, default `True`. When `True`,\n            statistics (e.g., mean, mode, variance) use the value \"`NaN`\" to\n            indicate the result is undefined. When `False`, an exception is raised\n            if one or more of the statistic's batch members are undefined.\n          name: Python `str` name prefixed to Ops created by this class.\n\n        Raises:\n          ValueError: if neither `loc` nor `scale_tril` are specified.", "id": "f15707:c0:m0"}
{"signature": "def quadrature_scheme_softmaxnormal_gauss_hermite(<EOL>normal_loc, normal_scale, quadrature_size,<EOL>validate_args=False, name=None):", "body": "with tf.name_scope(<EOL>name or \"<STR_LIT>\"):<EOL><INDENT>normal_loc = tf.convert_to_tensor(value=normal_loc, name=\"<STR_LIT>\")<EOL>npdt = dtype_util.as_numpy_dtype(normal_loc.dtype)<EOL>normal_scale = tf.convert_to_tensor(<EOL>value=normal_scale, dtype=npdt, name=\"<STR_LIT>\")<EOL>normal_scale = maybe_check_quadrature_param(<EOL>normal_scale, \"<STR_LIT>\", validate_args)<EOL>grid, probs = np.polynomial.hermite.hermgauss(deg=quadrature_size)<EOL>grid = grid.astype(npdt)<EOL>probs = probs.astype(npdt)<EOL>probs /= np.linalg.norm(probs, ord=<NUM_LIT:1>, keepdims=True)<EOL>probs = tf.convert_to_tensor(value=probs, name=\"<STR_LIT>\", dtype=npdt)<EOL>grid = softmax(<EOL>-distribution_util.pad(<EOL>(normal_loc[..., tf.newaxis] +<EOL>np.sqrt(<NUM_LIT>) * normal_scale[..., tf.newaxis] * grid),<EOL>axis=-<NUM_LIT:2>,<EOL>front=True),<EOL>axis=-<NUM_LIT:2>)  <EOL>return grid, probs<EOL><DEDENT>", "docstring": "Use Gauss-Hermite quadrature to form quadrature on `K - 1` simplex.\n\n    A `SoftmaxNormal` random variable `Y` may be generated via\n\n    ```\n    Y = SoftmaxCentered(X),\n    X = Normal(normal_loc, normal_scale)\n    ```\n\n    Note: for a given `quadrature_size`, this method is generally less accurate\n    than `quadrature_scheme_softmaxnormal_quantiles`.\n\n    Args:\n      normal_loc: `float`-like `Tensor` with shape `[b1, ..., bB, K-1]`, B>=0.\n        The location parameter of the Normal used to construct the SoftmaxNormal.\n      normal_scale: `float`-like `Tensor`. Broadcastable with `normal_loc`.\n        The scale parameter of the Normal used to construct the SoftmaxNormal.\n      quadrature_size: Python `int` scalar representing the number of quadrature\n        points.\n      validate_args: Python `bool`, default `False`. When `True` distribution\n        parameters are checked for validity despite possibly degrading runtime\n        performance. When `False` invalid inputs may silently render incorrect\n        outputs.\n      name: Python `str` name prefixed to Ops created by this class.\n\n    Returns:\n      grid: Shape `[b1, ..., bB, K, quadrature_size]` `Tensor` representing the\n        convex combination of affine parameters for `K` components.\n        `grid[..., :, n]` is the `n`-th grid point, living in the `K - 1` simplex.\n      probs:  Shape `[b1, ..., bB, K, quadrature_size]` `Tensor` representing the\n        associated with each grid point.", "id": "f15712:m0"}
{"signature": "@property<EOL><INDENT>def interpolated_affine(self):<DEDENT>", "body": "return self._interpolated_affine<EOL>", "docstring": "Affine transformation for each convex combination of `K` components.", "id": "f15712:c0:m5"}
{"signature": "def add(x, y):", "body": "if x is None:<EOL><INDENT>return y<EOL><DEDENT>if y is None:<EOL><INDENT>return x<EOL><DEDENT>return x + y<EOL>", "docstring": "Adds inputs; interprets `None` as zero.", "id": "f15712:m8"}
{"signature": "def interpolate_scale(grid, scale):", "body": "if len(scale) != <NUM_LIT:2>:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(len(scale)))<EOL><DEDENT>deg = tf.compat.dimension_value(<EOL>tensorshape_util.with_rank_at_least(grid.shape, <NUM_LIT:1>)[-<NUM_LIT:1>])<EOL>if deg is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>with tf.name_scope(\"<STR_LIT>\"):<EOL><INDENT>return [linop_add_lib.add_operators([<EOL>linop_scale(grid[..., k, q], s)<EOL>for k, s in enumerate(scale)<EOL>])[<NUM_LIT:0>] for q in range(deg)]<EOL><DEDENT>", "docstring": "Helper which interpolates between two scales.", "id": "f15712:m5"}
{"signature": "@property<EOL><INDENT>def endpoint_affine(self):<DEDENT>", "body": "return self._endpoint_affine<EOL>", "docstring": "Affine transformation for each of `K` components.", "id": "f15712:c0:m4"}
{"signature": "@property<EOL><INDENT>def grid(self):<DEDENT>", "body": "return self._grid<EOL>", "docstring": "Grid of mixing probabilities, one for each grid point.", "id": "f15712:c0:m3"}
{"signature": "def quadrature_scheme_softmaxnormal_quantiles(<EOL>normal_loc, normal_scale, quadrature_size,<EOL>validate_args=False, name=None):", "body": "with tf.name_scope(name or \"<STR_LIT>\"):<EOL><INDENT>normal_loc = tf.convert_to_tensor(value=normal_loc, name=\"<STR_LIT>\")<EOL>dt = dtype_util.base_dtype(normal_loc.dtype)<EOL>normal_scale = tf.convert_to_tensor(<EOL>value=normal_scale, dtype=dt, name=\"<STR_LIT>\")<EOL>normal_scale = maybe_check_quadrature_param(<EOL>normal_scale, \"<STR_LIT>\", validate_args)<EOL>dist = normal.Normal(loc=normal_loc, scale=normal_scale)<EOL>def _get_batch_ndims():<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>ndims = tensorshape_util.rank(dist.batch_shape)<EOL>if ndims is None:<EOL><INDENT>ndims = tf.shape(input=dist.batch_shape_tensor())[<NUM_LIT:0>]<EOL><DEDENT>return ndims<EOL><DEDENT>batch_ndims = _get_batch_ndims()<EOL>def _get_final_shape(qs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>bs = tensorshape_util.with_rank_at_least(dist.batch_shape, <NUM_LIT:1>)<EOL>num_components = tf.compat.dimension_value(bs[-<NUM_LIT:1>])<EOL>if num_components is not None:<EOL><INDENT>num_components += <NUM_LIT:1><EOL><DEDENT>tail = tf.TensorShape([num_components, qs])<EOL>return bs[:-<NUM_LIT:1>].concatenate(tail)<EOL><DEDENT>def _compute_quantiles():<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>zero = tf.zeros([], dtype=dist.dtype)<EOL>edges = tf.linspace(zero, <NUM_LIT:1.>, quadrature_size + <NUM_LIT:3>)[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL>edges = tf.reshape(<EOL>edges,<EOL>shape=tf.concat(<EOL>[[-<NUM_LIT:1>], tf.ones([batch_ndims], dtype=tf.int32)], axis=<NUM_LIT:0>))<EOL>quantiles = dist.quantile(edges)<EOL>quantiles = softmax_centered_bijector.SoftmaxCentered().forward(quantiles)<EOL>perm = tf.concat([tf.range(<NUM_LIT:1>, <NUM_LIT:1> + batch_ndims), [<NUM_LIT:0>]], axis=<NUM_LIT:0>)<EOL>quantiles = tf.transpose(a=quantiles, perm=perm)<EOL>tensorshape_util.set_shape(<EOL>quantiles, _get_final_shape(quadrature_size + <NUM_LIT:1>))<EOL>return quantiles<EOL><DEDENT>quantiles = _compute_quantiles()<EOL>grid = (quantiles[..., :-<NUM_LIT:1>] + quantiles[..., <NUM_LIT:1>:]) / <NUM_LIT><EOL>tensorshape_util.set_shape(grid, _get_final_shape(quadrature_size))<EOL>probs = tf.fill(<EOL>dims=[quadrature_size], value=<NUM_LIT:1.> / tf.cast(quadrature_size, dist.dtype))<EOL>return grid, probs<EOL><DEDENT>", "docstring": "Use SoftmaxNormal quantiles to form quadrature on `K - 1` simplex.\n\n    A `SoftmaxNormal` random variable `Y` may be generated via\n\n    ```\n    Y = SoftmaxCentered(X),\n    X = Normal(normal_loc, normal_scale)\n    ```\n\n    Args:\n      normal_loc: `float`-like `Tensor` with shape `[b1, ..., bB, K-1]`, B>=0.\n        The location parameter of the Normal used to construct the SoftmaxNormal.\n      normal_scale: `float`-like `Tensor`. Broadcastable with `normal_loc`.\n        The scale parameter of the Normal used to construct the SoftmaxNormal.\n      quadrature_size: Python `int` scalar representing the number of quadrature\n        points.\n      validate_args: Python `bool`, default `False`. When `True` distribution\n        parameters are checked for validity despite possibly degrading runtime\n        performance. When `False` invalid inputs may silently render incorrect\n        outputs.\n      name: Python `str` name prefixed to Ops created by this class.\n\n    Returns:\n      grid: Shape `[b1, ..., bB, K, quadrature_size]` `Tensor` representing the\n        convex combination of affine parameters for `K` components.\n        `grid[..., :, n]` is the `n`-th grid point, living in the `K - 1` simplex.\n      probs:  Shape `[b1, ..., bB, K, quadrature_size]` `Tensor` representing the\n        associated with each grid point.", "id": "f15712:m1"}
{"signature": "@property<EOL><INDENT>def df(self):<DEDENT>", "body": "return self._df<EOL>", "docstring": "The degrees of freedom of the distribution.\n\n        This controls the degrees of freedom of the distribution. The tails of the\n        distribution get more heavier the smaller `df` is. As `df` goes to\n        infinitiy, the distribution approaches the Multivariate Normal with the same\n        `loc` and `scale`.\n\n        Returns:\n          The `df` `Tensor`.", "id": "f15714:c0:m3"}
{"signature": "def _std_var_helper(self, statistic, statistic_name, statistic_ndims,<EOL>df_factor_fn):", "body": "df = tf.reshape(<EOL>self.df,<EOL>tf.concat([<EOL>tf.shape(input=self.df),<EOL>tf.ones([statistic_ndims], dtype=tf.int32)<EOL>], -<NUM_LIT:1>))<EOL>df = _broadcast_to_shape(df, tf.shape(input=statistic))<EOL>denom = tf.where(df > <NUM_LIT>, df - <NUM_LIT>, tf.ones_like(df))<EOL>statistic = statistic * df_factor_fn(df / denom)<EOL>inf = dtype_util.as_numpy_dtype(self.dtype)(np.inf)<EOL>result_where_defined = tf.where(<EOL>df > <NUM_LIT>, statistic, tf.fill(tf.shape(input=statistic), inf, name=\"<STR_LIT>\"))<EOL>if self.allow_nan_stats:<EOL><INDENT>nan = dtype_util.as_numpy_dtype(self.dtype)(np.nan)<EOL>return tf.where(df > <NUM_LIT:1.>, result_where_defined,<EOL>tf.fill(tf.shape(input=statistic), nan, name=\"<STR_LIT>\"))<EOL><DEDENT>else:<EOL><INDENT>with tf.control_dependencies([<EOL>assert_util.assert_less(<EOL>tf.cast(<NUM_LIT:1.>, self.dtype),<EOL>df,<EOL>message=statistic_name +<EOL>\"<STR_LIT>\"),<EOL>]):<EOL><INDENT>return tf.identity(result_where_defined)<EOL><DEDENT><DEDENT>", "docstring": "Helper to compute stddev, covariance and variance.", "id": "f15714:c0:m15"}
{"signature": "def __init__(self,<EOL>outcomes,<EOL>logits=None,<EOL>probs=None,<EOL>rtol=None,<EOL>atol=None,<EOL>validate_args=False,<EOL>allow_nan_stats=True,<EOL>name='<STR_LIT>'):", "body": "parameters = dict(locals())<EOL>with tf.compat.v1.name_scope(<EOL>name, values=[outcomes, logits, probs]) as name:<EOL><INDENT>self._outcomes = tf.convert_to_tensor(value=outcomes, name='<STR_LIT>')<EOL>if validate_args:<EOL><INDENT>assertions = _maybe_validate_args(self._outcomes, logits, probs,<EOL>validate_args)<EOL>with tf.control_dependencies(assertions):<EOL><INDENT>self._outcomes = tf.identity(self._outcomes)<EOL><DEDENT><DEDENT>if dtype_util.is_floating(self._outcomes.dtype):<EOL><INDENT>eps = np.finfo(dtype_util.as_numpy_dtype(self._outcomes.dtype)).eps<EOL>self._rtol = <NUM_LIT:10> * eps if rtol is None else rtol<EOL>self._atol = <NUM_LIT:10> * eps if atol is None else atol<EOL><DEDENT>else:<EOL><INDENT>self._rtol = None<EOL>self._atol = None<EOL><DEDENT>self._categorical = categorical.Categorical(<EOL>logits=logits,<EOL>probs=probs,<EOL>dtype=tf.int32,<EOL>validate_args=validate_args,<EOL>allow_nan_stats=allow_nan_stats)<EOL><DEDENT>super(FiniteDiscrete, self).__init__(<EOL>dtype=self._outcomes.dtype,<EOL>reparameterization_type=reparameterization.NOT_REPARAMETERIZED,<EOL>validate_args=validate_args,<EOL>allow_nan_stats=allow_nan_stats,<EOL>parameters=parameters,<EOL>graph_parents=[<EOL>self._outcomes, self._categorical.logits, self._categorical.probs<EOL>],<EOL>name=name)<EOL>", "docstring": "Construct a finite discrete contribution.\n\n        Args:\n          outcomes: A 1-D floating or integer `Tensor`, representing a list of\n            possible outcomes in strictly ascending order.\n          logits: A floating N-D `Tensor`, `N >= 1`, representing the log\n            probabilities of a set of FiniteDiscrete distributions. The first `N -\n            1` dimensions index into a batch of independent distributions and the\n            last dimension represents a vector of logits for each discrete value.\n            Only one of `logits` or `probs` should be passed in.\n          probs: A floating  N-D `Tensor`, `N >= 1`, representing the probabilities\n            of a set of FiniteDiscrete distributions. The first `N - 1` dimensions\n            index into a batch of independent distributions and the last dimension\n            represents a vector of probabilities for each discrete value. Only one\n            of `logits` or `probs` should be passed in.\n          rtol: `Tensor` with same `dtype` as `outcomes`. The relative tolerance for\n            floating number comparison. Only effective when `outcomes` is a floating\n            `Tensor`. Default is `10 * eps`.\n          atol: `Tensor` with same `dtype` as `outcomes`. The absolute tolerance for\n            floating number comparison. Only effective when `outcomes` is a floating\n            `Tensor`. Default is `10 * eps`.\n          validate_args:  Python `bool`, default `False`. When `True` distribution\n            parameters are checked for validity despite possibly degrading runtime\n            performance. When `False` invalid inputs may render incorrect outputs.\n          allow_nan_stats: Python `bool`, default `True`. When `True`, statistics\n            (e.g., mean, mode, variance) use the value '`NaN`' to indicate the\n            result is undefined. When `False`, an exception is raised if one or more\n            of the statistic's batch members are undefined.\n          name: Python `str` name prefixed to Ops created by this class.", "id": "f15716:c0:m0"}
{"signature": "def __init__(self,<EOL>loc=None,<EOL>scale=None,<EOL>validate_args=False,<EOL>allow_nan_stats=True,<EOL>name=\"<STR_LIT>\"):", "body": "parameters = dict(locals())<EOL>if scale is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not dtype_util.is_floating(scale.dtype):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>with tf.name_scope(name) as name:<EOL><INDENT>loc = loc if loc is None else tf.convert_to_tensor(<EOL>value=loc, name=\"<STR_LIT>\", dtype=scale.dtype)<EOL>batch_shape, event_shape = distribution_util.shapes_from_loc_and_scale(<EOL>loc, scale)<EOL><DEDENT>super(MultivariateNormalLinearOperator, self).__init__(<EOL>distribution=normal.Normal(<EOL>loc=tf.zeros([], dtype=scale.dtype),<EOL>scale=tf.ones([], dtype=scale.dtype)),<EOL>bijector=affine_linear_operator_bijector.AffineLinearOperator(<EOL>shift=loc, scale=scale, validate_args=validate_args),<EOL>batch_shape=batch_shape,<EOL>event_shape=event_shape,<EOL>validate_args=validate_args,<EOL>name=name)<EOL>self._parameters = parameters<EOL>", "docstring": "Construct Multivariate Normal distribution on `R^k`.\n\n        The `batch_shape` is the broadcast shape between `loc` and `scale`\n        arguments.\n\n        The `event_shape` is given by last dimension of the matrix implied by\n        `scale`. The last dimension of `loc` (if provided) must broadcast with this.\n\n        Recall that `covariance = scale @ scale.T`.\n\n        Additional leading dimensions (if any) will index batches.\n\n        Args:\n          loc: Floating-point `Tensor`. If this is set to `None`, `loc` is\n            implicitly `0`. When specified, may have shape `[B1, ..., Bb, k]` where\n            `b >= 0` and `k` is the event size.\n          scale: Instance of `LinearOperator` with same `dtype` as `loc` and shape\n            `[B1, ..., Bb, k, k]`.\n          validate_args: Python `bool`, default `False`. Whether to validate input\n            with asserts. If `validate_args` is `False`, and the inputs are\n            invalid, correct behavior is not guaranteed.\n          allow_nan_stats: Python `bool`, default `True`. If `False`, raise an\n            exception if a statistic (e.g. mean/mode/etc...) is undefined for any\n            batch member If `True`, batch members with valid parameters leading to\n            undefined statistics will return NaN for this statistic.\n          name: The name to give Ops created by the initializer.\n\n        Raises:\n          ValueError: if `scale` is unspecified.\n          TypeError: if not `scale.dtype.is_floating`", "id": "f15717:c0:m0"}
{"signature": "def _call_prob(self, value, name, **kwargs):", "body": "with self._name_scope(name):<EOL><INDENT>value = _convert_to_tensor(<EOL>value, name=\"<STR_LIT:value>\", dtype_hint=self.dtype)<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>return self._prob(value, **kwargs)<EOL><DEDENT>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>return tf.exp(self._log_prob(value, **kwargs))<EOL><DEDENT>raise NotImplementedError(\"<STR_LIT>\".format(<EOL>type(self).__name__))<EOL><DEDENT>", "docstring": "Wrapper around _prob.", "id": "f15721:c2:m29"}
{"signature": "def _is_scalar_helper(self, static_shape, dynamic_shape_fn):", "body": "if tensorshape_util.rank(static_shape) is not None:<EOL><INDENT>return tensorshape_util.rank(static_shape) == <NUM_LIT:0><EOL><DEDENT>shape = dynamic_shape_fn()<EOL>if tf.compat.dimension_value(shape.shape[<NUM_LIT:0>]) is not None:<EOL><INDENT>return tensorshape_util.as_list(shape.shape) == [<NUM_LIT:0>]<EOL><DEDENT>return tf.equal(tf.shape(input=shape)[<NUM_LIT:0>], <NUM_LIT:0>)<EOL>", "docstring": "Implementation for `is_scalar_batch` and `is_scalar_event`.", "id": "f15721:c2:m65"}
{"signature": "@property<EOL><INDENT>def parameters(self):<DEDENT>", "body": "<EOL>if (not hasattr(self, \"<STR_LIT>\") or<EOL>not self._parameters_sanitized):<EOL><INDENT>if callable(self._parameters):<EOL><INDENT>self._parameters = self._parameters()<EOL><DEDENT>self._parameters = {<EOL>k: v for k, v in self._parameters.items()<EOL>if not k.startswith(\"<STR_LIT>\") and v is not self}<EOL>self._parameters_sanitized = True<EOL><DEDENT>return self._parameters<EOL>", "docstring": "Dictionary of parameters used to instantiate this `Distribution`.", "id": "f15721:c2:m6"}
{"signature": "@property<EOL><INDENT>def batch_shape(self):<DEDENT>", "body": "return tf.TensorShape(self._batch_shape())<EOL>", "docstring": "Shape of a single sample from a single event index as a `TensorShape`.\n\n        May be partially defined or unknown.\n\n        The batch dimensions are indexes into independent, non-identical\n        parameterizations of this distribution.\n\n        Returns:\n          batch_shape: `TensorShape`, possibly unknown.", "id": "f15721:c2:m17"}
{"signature": "def log_prob(self, value, name=\"<STR_LIT>\", **kwargs):", "body": "return self._call_log_prob(value, name, **kwargs)<EOL>", "docstring": "Log probability density/mass function.\n\n        Args:\n          value: `float` or `double` `Tensor`.\n          name: Python `str` prepended to names of ops created by this function.\n          **kwargs: Named arguments forwarded to subclass implementation.\n\n        Returns:\n          log_prob: a `Tensor` of shape `sample_shape(x) + self.batch_shape` with\n            values of type `self.dtype`.", "id": "f15721:c2:m28"}
{"signature": "def _call_survival_function(self, value, name, **kwargs):", "body": "with self._name_scope(name):<EOL><INDENT>value = _convert_to_tensor(<EOL>value, name=\"<STR_LIT:value>\", dtype_hint=self.dtype)<EOL>try:<EOL><INDENT>return self._survival_function(value, **kwargs)<EOL><DEDENT>except NotImplementedError as original_exception:<EOL><INDENT>try:<EOL><INDENT>return <NUM_LIT:1.> - self.cdf(value, **kwargs)<EOL><DEDENT>except NotImplementedError:<EOL><INDENT>raise original_exception<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Wrapper around _survival_function.", "id": "f15721:c2:m39"}
{"signature": "def covariance(self, name=\"<STR_LIT>\", **kwargs):", "body": "with self._name_scope(name):<EOL><INDENT>return self._covariance(**kwargs)<EOL><DEDENT>", "docstring": "Covariance.\n\n        Covariance is (possibly) defined only for non-scalar-event distributions.\n\n        For example, for a length-`k`, vector-valued distribution, it is calculated\n        as,\n\n        ```none\n        Cov[i, j] = Covariance(X_i, X_j) = E[(X_i - E[X_i]) (X_j - E[X_j])]\n        ```\n\n        where `Cov` is a (batch of) `k x k` matrix, `0 <= (i, j) < k`, and `E`\n        denotes expectation.\n\n        Alternatively, for non-vector, multivariate distributions (e.g.,\n        matrix-valued, Wishart), `Covariance` shall return a (batch of) matrices\n        under some vectorization of the events, i.e.,\n\n        ```none\n        Cov[i, j] = Covariance(Vec(X)_i, Vec(X)_j) = [as above]\n        ```\n\n        where `Cov` is a (batch of) `k' x k'` matrices,\n        `0 <= (i, j) < k' = reduce_prod(event_shape)`, and `Vec` is some function\n        mapping indices of this distribution's event dimensions to indices of a\n        length-`k'` vector.\n\n        Args:\n          name: Python `str` prepended to names of ops created by this function.\n          **kwargs: Named arguments forwarded to subclass implementation.\n\n        Returns:\n          covariance: Floating-point `Tensor` with shape `[B1, ..., Bn, k', k']`\n            where the first `n` dimensions are batch coordinates and\n            `k' = reduce_prod(self.event_shape)`.", "id": "f15721:c2:m53"}
{"signature": "def _convert_to_tensor(value, dtype=None, dtype_hint=None, name=None):", "body": "if (tf.nest.is_nested(dtype) or<EOL>tf.nest.is_nested(dtype_hint)):<EOL><INDENT>if dtype is None:<EOL><INDENT>fn = lambda v, pd: tf.convert_to_tensor(v, dtype_hint=pd, name=name)<EOL>return tf.nest.map_structure(fn, value, dtype_hint)<EOL><DEDENT>elif dtype_hint is None:<EOL><INDENT>fn = lambda v, d: tf.convert_to_tensor(v, dtype=d, name=name)<EOL>return tf.nest.map_structure(fn, value, dtype_hint)<EOL><DEDENT>else:<EOL><INDENT>fn = lambda v, d, pd: tf.convert_to_tensor(  <EOL>v, dtype=d, dtype_hint=pd, name=name)<EOL>return tf.nest.map_structure(fn, value, dtype, dtype_hint)<EOL><DEDENT><DEDENT>return tf.convert_to_tensor(<EOL>value=value, dtype=dtype, dtype_hint=dtype_hint, name=name)<EOL>", "docstring": "Converts the given `value` to a (structure of) `Tensor`.\n\n    This function converts Python objects of various types to a (structure of)\n    `Tensor` objects. It accepts `Tensor` objects, numpy arrays, Python lists, and\n    Python scalars. For example:\n\n    Args:\n      value: An object whose structure matches that of `dtype ` and/or\n        `dtype_hint` and for which each leaf has a registered `Tensor` conversion\n        function.\n      dtype: Optional (structure of) element type for the returned tensor. If\n        missing, the type is inferred from the type of `value`.\n      dtype_hint: Optional (structure of) element type for the returned tensor,\n        used when dtype is None. In some cases, a caller may not have a dtype in\n        mind when converting to a tensor, so dtype_hint can be used as a soft\n        preference.  If the conversion to `dtype_hint` is not possible, this\n        argument has no effect.\n      name: Optional name to use if a new `Tensor` is created.\n\n    Returns:\n      tensor: A (structure of) `Tensor` based on `value`.\n\n    Raises:\n      TypeError: If no conversion function is registered for `value` to `dtype`.\n      RuntimeError: If a registered conversion function returns an invalid value.\n      ValueError: If the `value` is a tensor not of given `dtype` in graph mode.", "id": "f15721:m2"}
{"signature": "def mean(self, name=\"<STR_LIT>\", **kwargs):", "body": "with self._name_scope(name):<EOL><INDENT>return self._mean(**kwargs)<EOL><DEDENT>", "docstring": "Mean.", "id": "f15721:c2:m44"}
{"signature": "def _call_cdf(self, value, name, **kwargs):", "body": "with self._name_scope(name):<EOL><INDENT>value = _convert_to_tensor(<EOL>value, name=\"<STR_LIT:value>\", dtype_hint=self.dtype)<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>return self._cdf(value, **kwargs)<EOL><DEDENT>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>return tf.exp(self._log_cdf(value, **kwargs))<EOL><DEDENT>raise NotImplementedError(\"<STR_LIT>\".format(<EOL>type(self).__name__))<EOL><DEDENT>", "docstring": "Wrapper around _cdf.", "id": "f15721:c2:m33"}
{"signature": "def variance(self, name=\"<STR_LIT>\", **kwargs):", "body": "with self._name_scope(name):<EOL><INDENT>try:<EOL><INDENT>return self._variance(**kwargs)<EOL><DEDENT>except NotImplementedError as original_exception:<EOL><INDENT>try:<EOL><INDENT>return tf.square(self._stddev(**kwargs))<EOL><DEDENT>except NotImplementedError:<EOL><INDENT>raise original_exception<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Variance.\n\n        Variance is defined as,\n\n        ```none\n        Var = E[(X - E[X])**2]\n        ```\n\n        where `X` is the random variable associated with this distribution, `E`\n        denotes expectation, and `Var.shape = batch_shape + event_shape`.\n\n        Args:\n          name: Python `str` prepended to names of ops created by this function.\n          **kwargs: Named arguments forwarded to subclass implementation.\n\n        Returns:\n          variance: Floating-point `Tensor` with shape identical to\n            `batch_shape + event_shape`, i.e., the same shape as `self.mean()`.", "id": "f15721:c2:m49"}
{"signature": "def _call_log_cdf(self, value, name, **kwargs):", "body": "with self._name_scope(name):<EOL><INDENT>value = _convert_to_tensor(<EOL>value, name=\"<STR_LIT:value>\", dtype_hint=self.dtype)<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>return self._log_cdf(value, **kwargs)<EOL><DEDENT>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>return tf.math.log(self._cdf(value, **kwargs))<EOL><DEDENT>raise NotImplementedError(\"<STR_LIT>\".format(<EOL>type(self).__name__))<EOL><DEDENT>", "docstring": "Wrapper around _log_cdf.", "id": "f15721:c2:m31"}
{"signature": "def stddev(self, name=\"<STR_LIT>\", **kwargs):", "body": "with self._name_scope(name):<EOL><INDENT>try:<EOL><INDENT>return self._stddev(**kwargs)<EOL><DEDENT>except NotImplementedError as original_exception:<EOL><INDENT>try:<EOL><INDENT>return tf.sqrt(self._variance(**kwargs))<EOL><DEDENT>except NotImplementedError:<EOL><INDENT>raise original_exception<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Standard deviation.\n\n        Standard deviation is defined as,\n\n        ```none\n        stddev = E[(X - E[X])**2]**0.5\n        ```\n\n        where `X` is the random variable associated with this distribution, `E`\n        denotes expectation, and `stddev.shape = batch_shape + event_shape`.\n\n        Args:\n          name: Python `str` prepended to names of ops created by this function.\n          **kwargs: Named arguments forwarded to subclass implementation.\n\n        Returns:\n          stddev: Floating-point `Tensor` with shape identical to\n            `batch_shape + event_shape`, i.e., the same shape as `self.mean()`.", "id": "f15721:c2:m51"}
{"signature": "def __new__(mcs, classname, baseclasses, attrs):", "body": "if not baseclasses:  <EOL><INDENT>raise TypeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>which_base = [<EOL>base for base in baseclasses<EOL>if base == _BaseDistribution or issubclass(base, Distribution)]<EOL>base = which_base[<NUM_LIT:0>] if which_base else None<EOL>if base is None or base == _BaseDistribution:<EOL><INDENT>return super(_DistributionMeta, mcs).__new__(<EOL>mcs, classname, baseclasses, attrs)<EOL><DEDENT>if not issubclass(base, Distribution):<EOL><INDENT>raise TypeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(<EOL>classname, base.__name__))<EOL><DEDENT>for attr in _DISTRIBUTION_PUBLIC_METHOD_WRAPPERS:<EOL><INDENT>if attr in attrs:<EOL><INDENT>continue<EOL><DEDENT>special_attr = \"<STR_LIT>\".format(attr)<EOL>class_attr_value = attrs.get(attr, None)<EOL>base_attr_value = getattr(base, attr, None)<EOL>if not base_attr_value:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(base.__name__, attr))<EOL><DEDENT>class_special_attr_value = attrs.get(special_attr, None)<EOL>if class_special_attr_value is None:<EOL><INDENT>continue<EOL><DEDENT>class_special_attr_docstring = tf_inspect.getdoc(class_special_attr_value)<EOL>if not class_special_attr_docstring:<EOL><INDENT>continue<EOL><DEDENT>class_attr_value = _copy_fn(base_attr_value)<EOL>class_attr_docstring = tf_inspect.getdoc(base_attr_value)<EOL>if class_attr_docstring is None:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\".format(<EOL>base.__name__, attr))<EOL><DEDENT>class_attr_value.__doc__ = _update_docstring(<EOL>class_attr_value.__doc__,<EOL>\"<STR_LIT>\".format(<EOL>classname, class_special_attr_docstring))<EOL>attrs[attr] = class_attr_value<EOL><DEDENT>default_init = attrs.get(\"<STR_LIT>\", None)<EOL>if default_init is None:<EOL><INDENT>return super(_DistributionMeta, mcs).__new__(<EOL>mcs, classname, baseclasses, attrs)<EOL><DEDENT>@decorator.decorator<EOL>def wrapped_init(wrapped, self_, *args, **kwargs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>del wrapped<EOL>self_._parameters = None<EOL>default_init(self_, *args, **kwargs)<EOL>if self_._parameters is None:<EOL><INDENT>dummy_self = tuple()<EOL>self_._parameters = lambda: (  <EOL>_remove_dict_keys_with_value(<EOL>inspect.getcallargs(default_init, dummy_self, *args, **kwargs),<EOL>dummy_self))<EOL><DEDENT>elif hasattr(self_._parameters, \"<STR_LIT>\"):<EOL><INDENT>self_._parameters = _remove_dict_keys_with_value(<EOL>self_._parameters, self_)<EOL><DEDENT><DEDENT>attrs[\"<STR_LIT>\"] = wrapped_init(default_init)  <EOL>return super(_DistributionMeta, mcs).__new__(<EOL>mcs, classname, baseclasses, attrs)<EOL>", "docstring": "Control the creation of subclasses of the Distribution class.\n\n        The main purpose of this method is to properly propagate docstrings\n        from private Distribution methods, like `_log_prob`, into their\n        public wrappers as inherited by the Distribution base class\n        (e.g. `log_prob`).\n\n        Args:\n          classname: The name of the subclass being created.\n          baseclasses: A tuple of parent classes.\n          attrs: A dict mapping new attributes to their values.\n\n        Returns:\n          The class object.\n\n        Raises:\n          TypeError: If `Distribution` is not a subclass of `BaseDistribution`, or\n            the new class is derived via multiple inheritance and the first\n            parent class is not a subclass of `BaseDistribution`.\n          AttributeError:  If `Distribution` does not implement e.g. `log_prob`.\n          ValueError:  If a `Distribution` public method lacks a docstring.", "id": "f15721:c1:m0"}
{"signature": "def entropy(self, name=\"<STR_LIT>\", **kwargs):", "body": "with self._name_scope(name):<EOL><INDENT>return self._entropy(**kwargs)<EOL><DEDENT>", "docstring": "Shannon entropy in nats.", "id": "f15721:c2:m42"}
{"signature": "def _extract_log_probs(num_states, dist):", "body": "states = tf.reshape(tf.range(num_states),<EOL>tf.concat([[num_states],<EOL>tf.ones_like(dist.batch_shape_tensor())],<EOL>axis=<NUM_LIT:0>))<EOL>return distribution_util.move_dimension(dist.log_prob(states), <NUM_LIT:0>, -<NUM_LIT:1>)<EOL>", "docstring": "Tabulate log probabilities from a batch of distributions.", "id": "f15726:m3"}
{"signature": "def posterior_marginals(self, observations, name=None):", "body": "with tf.name_scope(name or \"<STR_LIT>\"):<EOL><INDENT>with tf.control_dependencies(self._runtime_assertions):<EOL><INDENT>observation_tensor_shape = tf.shape(input=observations)<EOL>with self._observation_shape_preconditions(observation_tensor_shape):<EOL><INDENT>observation_batch_shape = observation_tensor_shape[<EOL>:-<NUM_LIT:1> - self._underlying_event_rank]<EOL>observation_event_shape = observation_tensor_shape[<EOL>-<NUM_LIT:1> - self._underlying_event_rank:]<EOL>batch_shape = tf.broadcast_dynamic_shape(observation_batch_shape,<EOL>self.batch_shape_tensor())<EOL>log_init = tf.broadcast_to(self._log_init,<EOL>tf.concat([batch_shape,<EOL>[self._num_states]],<EOL>axis=<NUM_LIT:0>))<EOL>log_transition = self._log_trans<EOL>observations = tf.broadcast_to(observations,<EOL>tf.concat([batch_shape,<EOL>observation_event_shape],<EOL>axis=<NUM_LIT:0>))<EOL>observation_rank = tf.rank(observations)<EOL>underlying_event_rank = self._underlying_event_rank<EOL>observations = distribution_util.move_dimension(<EOL>observations, observation_rank - underlying_event_rank - <NUM_LIT:1>, <NUM_LIT:0>)<EOL>observations = tf.expand_dims(<EOL>observations,<EOL>observation_rank - underlying_event_rank)<EOL>observation_log_probs = self._observation_distribution.log_prob(<EOL>observations)<EOL>log_adjoint_prob = tf.zeros_like(log_init)<EOL>def forward_step(log_previous_step, log_prob_observation):<EOL><INDENT>return _log_vector_matrix(log_previous_step,<EOL>log_transition) + log_prob_observation<EOL><DEDENT>log_prob = log_init + observation_log_probs[<NUM_LIT:0>]<EOL>forward_log_probs = tf.scan(forward_step, observation_log_probs[<NUM_LIT:1>:],<EOL>initializer=log_prob,<EOL>name=\"<STR_LIT>\")<EOL>forward_log_probs = tf.concat([[log_prob], forward_log_probs], axis=<NUM_LIT:0>)<EOL>def backward_step(log_previous_step, log_prob_observation):<EOL><INDENT>return _log_matrix_vector(log_transition,<EOL>log_prob_observation + log_previous_step)<EOL><DEDENT>backward_log_adjoint_probs = tf.scan(<EOL>backward_step,<EOL>observation_log_probs[<NUM_LIT:1>:],<EOL>initializer=log_adjoint_prob,<EOL>reverse=True,<EOL>name=\"<STR_LIT>\")<EOL>total_log_prob = tf.reduce_logsumexp(<EOL>input_tensor=forward_log_probs[-<NUM_LIT:1>], axis=-<NUM_LIT:1>)<EOL>backward_log_adjoint_probs = tf.concat([backward_log_adjoint_probs,<EOL>[log_adjoint_prob]], axis=<NUM_LIT:0>)<EOL>log_likelihoods = forward_log_probs + backward_log_adjoint_probs<EOL>marginal_log_probs = distribution_util.move_dimension(<EOL>log_likelihoods - total_log_prob[..., tf.newaxis], <NUM_LIT:0>, -<NUM_LIT:2>)<EOL>return categorical.Categorical(logits=marginal_log_probs)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Compute marginal posterior distribution for each state.\n\n        This function computes, for each time step, the marginal\n        conditional probability that the hidden Markov model was in\n        each possible state given the observations that were made\n        at each time step.\n        So if the hidden states are `z[0],...,z[num_steps - 1]` and\n        the observations are `x[0], ..., x[num_steps - 1]`, then\n        this function computes `P(z[i] | x[0], ..., x[num_steps - 1])`\n        for all `i` from `0` to `num_steps - 1`.\n\n        This operation is sometimes called smoothing. It uses a form\n        of the forward-backward algorithm.\n\n        Note: the behavior of this function is undefined if the\n        `observations` argument represents impossible observations\n        from the model.\n\n        Args:\n          observations: A tensor representing a batch of observations\n            made on the hidden Markov model.  The rightmost dimension of this tensor\n            gives the steps in a sequence of observations from a single sample from\n            the hidden Markov model. The size of this dimension should match the\n            `num_steps` parameter of the hidden Markov model object. The other\n            dimensions are the dimensions of the batch and these are broadcast with\n            the hidden Markov model's parameters.\n          name: Python `str` name prefixed to Ops created by this class.\n            Default value: \"HiddenMarkovModel\".\n\n        Returns:\n          posterior_marginal: A `Categorical` distribution object representing the\n            marginal probability of the hidden Markov model being in each state at\n            each step. The rightmost dimension of the `Categorical` distributions\n            batch will equal the `num_steps` parameter providing one marginal\n            distribution for each step. The other dimensions are the dimensions\n            corresponding to the batch of observations.\n\n        Raises:\n          ValueError: if rightmost dimension of `observations` does not\n          have size `num_steps`.", "id": "f15726:c0:m16"}
{"signature": "@property<EOL><INDENT>def scale(self):<DEDENT>", "body": "return self._scale<EOL>", "docstring": "Distribution parameter for the scale.", "id": "f15727:c0:m4"}
{"signature": "@property<EOL><INDENT>def scale(self):<DEDENT>", "body": "return self.bijector.scale<EOL>", "docstring": "Dense (batch) covariance matrix, if available.", "id": "f15728:c0:m3"}
{"signature": "def __init__(self,<EOL>df,<EOL>loc=None,<EOL>scale_identity_multiplier=None,<EOL>scale_diag=None,<EOL>scale_tril=None,<EOL>scale_perturb_factor=None,<EOL>scale_perturb_diag=None,<EOL>validate_args=False,<EOL>allow_nan_stats=True,<EOL>name=\"<STR_LIT>\"):", "body": "parameters = dict(locals())<EOL>graph_parents = [df, loc, scale_identity_multiplier, scale_diag,<EOL>scale_tril, scale_perturb_factor, scale_perturb_diag]<EOL>with tf.name_scope(name) as name:<EOL><INDENT>with tf.name_scope(\"<STR_LIT>\"):<EOL><INDENT>dtype = dtype_util.common_dtype(graph_parents, tf.float32)<EOL>df = tf.convert_to_tensor(value=df, name=\"<STR_LIT>\", dtype=dtype)<EOL>affine = affine_bijector.Affine(<EOL>shift=loc,<EOL>scale_identity_multiplier=scale_identity_multiplier,<EOL>scale_diag=scale_diag,<EOL>scale_tril=scale_tril,<EOL>scale_perturb_factor=scale_perturb_factor,<EOL>scale_perturb_diag=scale_perturb_diag,<EOL>validate_args=validate_args,<EOL>dtype=dtype)<EOL>distribution = student_t.StudentT(<EOL>df=df,<EOL>loc=tf.zeros([], dtype=affine.dtype),<EOL>scale=tf.ones([], dtype=affine.dtype))<EOL>batch_shape, override_event_shape = (<EOL>distribution_util.shapes_from_loc_and_scale(<EOL>affine.shift, affine.scale))<EOL>override_batch_shape = distribution_util.pick_vector(<EOL>distribution.is_scalar_batch(), batch_shape,<EOL>tf.constant([], dtype=tf.int32))<EOL>super(_VectorStudentT, self).__init__(<EOL>distribution=distribution,<EOL>bijector=affine,<EOL>batch_shape=override_batch_shape,<EOL>event_shape=override_event_shape,<EOL>validate_args=validate_args,<EOL>name=name)<EOL>self._parameters = parameters<EOL><DEDENT><DEDENT>", "docstring": "Instantiates the vector Student's t-distributions on `R^k`.\n\n        The `batch_shape` is the broadcast between `df.batch_shape` and\n        `Affine.batch_shape` where `Affine` is constructed from `loc` and\n        `scale_*` arguments.\n\n        The `event_shape` is the event shape of `Affine.event_shape`.\n\n        Args:\n          df: Floating-point `Tensor`. The degrees of freedom of the\n            distribution(s). `df` must contain only positive values. Must be\n            scalar if `loc`, `scale_*` imply non-scalar batch_shape or must have the\n            same `batch_shape` implied by `loc`, `scale_*`.\n          loc: Floating-point `Tensor`. If this is set to `None`, no `loc` is\n            applied.\n          scale_identity_multiplier: floating point rank 0 `Tensor` representing a\n            scaling done to the identity matrix. When `scale_identity_multiplier =\n            scale_diag=scale_tril = None` then `scale += IdentityMatrix`. Otherwise\n            no scaled-identity-matrix is added to `scale`.\n          scale_diag: Floating-point `Tensor` representing the diagonal matrix.\n            `scale_diag` has shape [N1, N2, ..., k], which represents a k x k\n            diagonal matrix. When `None` no diagonal term is added to `scale`.\n          scale_tril: Floating-point `Tensor` representing the diagonal matrix.\n            `scale_diag` has shape [N1, N2, ..., k, k], which represents a k x k\n            lower triangular matrix. When `None` no `scale_tril` term is added to\n            `scale`. The upper triangular elements above the diagonal are ignored.\n          scale_perturb_factor: Floating-point `Tensor` representing factor matrix\n            with last two dimensions of shape `(k, r)`. When `None`, no rank-r\n            update is added to `scale`.\n          scale_perturb_diag: Floating-point `Tensor` representing the diagonal\n            matrix. `scale_perturb_diag` has shape [N1, N2, ..., r], which\n            represents an r x r Diagonal matrix. When `None` low rank updates will\n            take the form `scale_perturb_factor * scale_perturb_factor.T`.\n          validate_args: Python `bool`, default `False`. When `True` distribution\n            parameters are checked for validity despite possibly degrading runtime\n            performance. When `False` invalid inputs may silently render incorrect\n            outputs.\n          allow_nan_stats: Python `bool`, default `True`. When `True`,\n            statistics (e.g., mean, mode, variance) use the value \"`NaN`\" to\n            indicate the result is undefined. When `False`, an exception is raised\n            if one or more of the statistic's batch members are undefined.\n          name: Python `str` name prefixed to Ops created by this class.", "id": "f15728:c0:m0"}
{"signature": "@property<EOL><INDENT>def loc(self):<DEDENT>", "body": "return self.bijector.shift<EOL>", "docstring": "Locations of these Student's t distribution(s).", "id": "f15728:c0:m2"}
{"signature": "def normal_conjugates_known_scale_predictive(prior, scale, s, n):", "body": "if not isinstance(prior, normal.Normal):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if s.dtype != prior.dtype:<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\"<EOL>% (s.dtype, prior.dtype))<EOL><DEDENT>n = tf.cast(n, prior.dtype)<EOL>scale0_2 = tf.square(prior.scale)<EOL>scale_2 = tf.square(scale)<EOL>scalep_2 = <NUM_LIT:1.0>/(<NUM_LIT:1>/scale0_2 + n/scale_2)<EOL>return normal.Normal(<EOL>loc=(prior.loc / scale0_2 + s / scale_2) * scalep_2,<EOL>scale=tf.sqrt(scalep_2 + scale_2))<EOL>", "docstring": "Posterior predictive Normal distribution w. conjugate prior on the mean.\n\n    This model assumes that `n` observations (with sum `s`) come from a\n    Normal with unknown mean `loc` (described by the Normal `prior`)\n    and known variance `scale**2`. The \"known scale predictive\"\n    is the distribution of new observations, conditioned on the existing\n    observations and our prior.\n\n    Accepts a prior Normal distribution object, having parameters\n    `loc0` and `scale0`, as well as known `scale` values of the predictive\n    distribution(s) (also assumed Normal),\n    and statistical estimates `s` (the sum(s) of the observations) and\n    `n` (the number(s) of observations).\n\n    Calculates the Normal distribution(s) `p(x | sigma**2)`:\n\n    ```\n    p(x | sigma**2) = int N(x | mu, sigma**2)N(mu | prior.loc, prior.scale**2) dmu\n                    = N(x | prior.loc, 1 / (sigma**2 + prior.scale**2))\n    ```\n\n    Returns the predictive posterior distribution object, with parameters\n    `(loc', scale'**2)`, where:\n\n    ```\n    sigma_n**2 = 1/(1/sigma0**2 + n/sigma**2),\n    mu' = (mu0/sigma0**2 + s/sigma**2) * sigma_n**2.\n    sigma'**2 = sigma_n**2 + sigma**2,\n    ```\n\n    Distribution parameters from `prior`, as well as `scale`, `s`, and `n`.\n    will broadcast in the case of multidimensional sets of parameters.\n\n    Args:\n      prior: `Normal` object of type `dtype`:\n        the prior distribution having parameters `(loc0, scale0)`.\n      scale: tensor of type `dtype`, taking values `scale > 0`.\n        The known stddev parameter(s).\n      s: Tensor of type `dtype`. The sum(s) of observations.\n      n: Tensor of type `int`. The number(s) of observations.\n\n    Returns:\n      A new Normal predictive distribution object.\n\n    Raises:\n      TypeError: if dtype of `s` does not match `dtype`, or `prior` is not a\n        Normal object.", "id": "f15730:m1"}
{"signature": "@property<EOL><INDENT>def tailweight(self):<DEDENT>", "body": "return self._tailweight<EOL>", "docstring": "Controls the tail decay.  `tailweight > 1` means faster than Normal.", "id": "f15735:c0:m3"}
{"signature": "@property<EOL><INDENT>def scale(self):<DEDENT>", "body": "return self._scale<EOL>", "docstring": "Scaling factors of these Student's t distribution(s).", "id": "f15737:c0:m5"}
{"signature": "def _variance_scale_term(self):", "body": "return tf.math.rsqrt(<NUM_LIT:1.> + self.total_concentration[..., tf.newaxis])<EOL>", "docstring": "Helper to `_covariance` and `_variance` which computes a shared scale.", "id": "f15740:c0:m17"}
{"signature": "def _maybe_assert_valid_sample(self, x):", "body": "if not self.validate_args:<EOL><INDENT>return x<EOL><DEDENT>return distribution_util.with_dependencies([<EOL>assert_util.assert_positive(x, message=\"<STR_LIT>\"),<EOL>assert_util.assert_near(<EOL>tf.ones([], dtype=self.dtype),<EOL>tf.reduce_sum(input_tensor=x, axis=-<NUM_LIT:1>),<EOL>message=\"<STR_LIT>\"),<EOL>], x)<EOL>", "docstring": "Checks the validity of a sample.", "id": "f15740:c0:m20"}
{"signature": "@property<EOL><INDENT>def concentration(self):<DEDENT>", "body": "return self._concentration<EOL>", "docstring": "Concentration parameter; expected counts for that coordinate.", "id": "f15740:c0:m2"}
{"signature": "def __init__(self,<EOL>kernel,<EOL>index_points=None,<EOL>observation_index_points=None,<EOL>observations=None,<EOL>observation_noise_variance=<NUM_LIT:0.>,<EOL>predictive_noise_variance=None,<EOL>mean_fn=None,<EOL>jitter=<NUM_LIT>,<EOL>validate_args=False,<EOL>allow_nan_stats=False,<EOL>name='<STR_LIT>'):", "body": "parameters = dict(locals())<EOL>with tf.name_scope(name) as name:<EOL><INDENT>dtype = dtype_util.common_dtype([<EOL>index_points, observation_index_points, observations,<EOL>observation_noise_variance, predictive_noise_variance, jitter<EOL>], tf.float32)<EOL>if index_points is not None:<EOL><INDENT>index_points = tf.convert_to_tensor(<EOL>value=index_points, dtype=dtype, name='<STR_LIT>')<EOL><DEDENT>observation_index_points = (None if observation_index_points is None else<EOL>tf.convert_to_tensor(<EOL>value=observation_index_points,<EOL>dtype=dtype,<EOL>name='<STR_LIT>'))<EOL>observations = (None if observations is None else tf.convert_to_tensor(<EOL>value=observations, dtype=dtype, name='<STR_LIT>'))<EOL>observation_noise_variance = tf.convert_to_tensor(<EOL>value=observation_noise_variance,<EOL>dtype=dtype,<EOL>name='<STR_LIT>')<EOL>predictive_noise_variance = (<EOL>observation_noise_variance<EOL>if predictive_noise_variance is None else tf.convert_to_tensor(<EOL>value=predictive_noise_variance,<EOL>dtype=dtype,<EOL>name='<STR_LIT>'))<EOL>jitter = tf.convert_to_tensor(value=jitter, dtype=dtype, name='<STR_LIT>')<EOL>if (observation_index_points is None) != (observations is None):<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>observations, observation_index_points))<EOL><DEDENT>if mean_fn is None:<EOL><INDENT>mean_fn = lambda x: tf.zeros([<NUM_LIT:1>], dtype=dtype)<EOL><DEDENT>else:<EOL><INDENT>if not callable(mean_fn):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>self._name = name<EOL>self._observation_index_points = observation_index_points<EOL>self._observations = observations<EOL>self._observation_noise_variance = observation_noise_variance<EOL>self._predictive_noise_variance = predictive_noise_variance<EOL>self._jitter = jitter<EOL>self._validate_args = validate_args<EOL>with tf.name_scope('<STR_LIT>'):<EOL><INDENT>conditional_kernel = tfpk.SchurComplement(<EOL>base_kernel=kernel,<EOL>fixed_inputs=observation_index_points,<EOL>diag_shift=jitter + observation_noise_variance)<EOL>if _is_empty_observation_data(<EOL>feature_ndims=kernel.feature_ndims,<EOL>observation_index_points=observation_index_points,<EOL>observations=observations):<EOL><INDENT>conditional_mean_fn = mean_fn<EOL><DEDENT>else:<EOL><INDENT>_validate_observation_data(<EOL>kernel=kernel,<EOL>observation_index_points=observation_index_points,<EOL>observations=observations)<EOL>def conditional_mean_fn(x):<EOL><INDENT>k_x_obs_linop = tf.linalg.LinearOperatorFullMatrix(<EOL>kernel.matrix(x, observation_index_points))<EOL>chol_linop = tf.linalg.LinearOperatorLowerTriangular(<EOL>conditional_kernel.divisor_matrix_cholesky)<EOL>diff = observations - mean_fn(observation_index_points)<EOL>return mean_fn(x) + k_x_obs_linop.matvec(<EOL>chol_linop.solvevec(chol_linop.solvevec(diff), adjoint=True))<EOL><DEDENT><DEDENT>graph_parents = [observation_noise_variance, jitter]<EOL>def _maybe_append(x):<EOL><INDENT>if x is not None:<EOL><INDENT>graph_parents.append(x)<EOL><DEDENT><DEDENT>_maybe_append(index_points)<EOL>_maybe_append(observation_index_points)<EOL>_maybe_append(observations)<EOL>super(GaussianProcessRegressionModel, self).__init__(<EOL>kernel=conditional_kernel,<EOL>mean_fn=conditional_mean_fn,<EOL>index_points=index_points,<EOL>jitter=jitter,<EOL>observation_noise_variance=predictive_noise_variance,<EOL>validate_args=validate_args,<EOL>allow_nan_stats=allow_nan_stats, name=name)<EOL>self._parameters = parameters<EOL>self._graph_parents = graph_parents<EOL><DEDENT><DEDENT>", "docstring": "Construct a GaussianProcessRegressionModel instance.\n\n        Args:\n          kernel: `PositiveSemidefiniteKernel`-like instance representing the\n            GP's covariance function.\n          index_points: `float` `Tensor` representing finite collection, or batch of\n            collections, of points in the index set over which the GP is defined.\n            Shape has the form `[b1, ..., bB, e, f1, ..., fF]` where `F` is the\n            number of feature dimensions and must equal `kernel.feature_ndims` and\n            `e` is the number (size) of index points in each batch. Ultimately this\n            distribution corresponds to an `e`-dimensional multivariate normal. The\n            batch shape must be broadcastable with `kernel.batch_shape` and any\n            batch dims yielded by `mean_fn`.\n          observation_index_points: `float` `Tensor` representing finite collection,\n            or batch of collections, of points in the index set for which some data\n            has been observed. Shape has the form `[b1, ..., bB, e, f1, ..., fF]`\n            where `F` is the number of feature dimensions and must equal\n            `kernel.feature_ndims`, and `e` is the number (size) of index points in\n            each batch. `[b1, ..., bB, e]` must be broadcastable with the shape of\n            `observations`, and `[b1, ..., bB]` must be broadcastable with the\n            shapes of all other batched parameters (`kernel.batch_shape`,\n            `index_points`, etc). The default value is `None`, which corresponds to\n            the empty set of observations, and simply results in the prior\n            predictive model (a GP with noise of variance\n            `predictive_noise_variance`).\n          observations: `float` `Tensor` representing collection, or batch of\n            collections, of observations corresponding to\n            `observation_index_points`. Shape has the form `[b1, ..., bB, e]`, which\n            must be brodcastable with the batch and example shapes of\n            `observation_index_points`. The batch shape `[b1, ..., bB]` must be\n            broadcastable with the shapes of all other batched parameters\n            (`kernel.batch_shape`, `index_points`, etc.). The default value is\n            `None`, which corresponds to the empty set of observations, and simply\n            results in the prior predictive model (a GP with noise of variance\n            `predictive_noise_variance`).\n          observation_noise_variance: `float` `Tensor` representing the variance\n            of the noise in the Normal likelihood distribution of the model. May be\n            batched, in which case the batch shape must be broadcastable with the\n            shapes of all other batched parameters (`kernel.batch_shape`,\n            `index_points`, etc.).\n            Default value: `0.`\n          predictive_noise_variance: `float` `Tensor` representing the variance in\n            the posterior predictive model. If `None`, we simply re-use\n            `observation_noise_variance` for the posterior predictive noise. If set\n            explicitly, however, we use this value. This allows us, for example, to\n            omit predictive noise variance (by setting this to zero) to obtain\n            noiseless posterior predictions of function values, conditioned on noisy\n            observations.\n          mean_fn: Python `callable` that acts on `index_points` to produce a\n            collection, or batch of collections, of mean values at `index_points`.\n            Takes a `Tensor` of shape `[b1, ..., bB, f1, ..., fF]` and returns a\n            `Tensor` whose shape is broadcastable with `[b1, ..., bB]`.\n            Default value: `None` implies the constant zero function.\n          jitter: `float` scalar `Tensor` added to the diagonal of the covariance\n            matrix to ensure positive definiteness of the covariance matrix.\n            Default value: `1e-6`.\n          validate_args: Python `bool`, default `False`. When `True` distribution\n            parameters are checked for validity despite possibly degrading runtime\n            performance. When `False` invalid inputs may silently render incorrect\n            outputs.\n            Default value: `False`.\n          allow_nan_stats: Python `bool`, default `True`. When `True`,\n            statistics (e.g., mean, mode, variance) use the value `NaN` to\n            indicate the result is undefined. When `False`, an exception is raised\n            if one or more of the statistic's batch members are undefined.\n            Default value: `False`.\n          name: Python `str` name prefixed to Ops created by this class.\n            Default value: 'GaussianProcessRegressionModel'.\n\n        Raises:\n          ValueError: if either\n            - only one of `observations` and `observation_index_points` is given, or\n            - `mean_fn` is not `None` and not callable.", "id": "f15742:c0:m0"}
{"signature": "def _validate_observation_data(<EOL>kernel, observation_index_points, observations):", "body": "<EOL>ndims = kernel.feature_ndims<EOL>if (tensorshape_util.is_fully_defined(<EOL>observation_index_points.shape[:-ndims]) and<EOL>tensorshape_util.is_fully_defined(observations.shape)):<EOL><INDENT>index_point_count = observation_index_points.shape[:-ndims]<EOL>observation_count = observations.shape<EOL>try:<EOL><INDENT>tf.broadcast_static_shape(index_point_count, observation_count)<EOL><DEDENT>except ValueError:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'.format(<EOL>index_point_count, observation_count))<EOL><DEDENT><DEDENT>", "docstring": "Ensure that observation data and locations have consistent shapes.\n\n    This basically means that the batch shapes are broadcastable. We can only\n    ensure this when those shapes are fully statically defined.\n\n\n    Args:\n      kernel: The GP kernel.\n      observation_index_points: the observation data locations in the index set.\n      observations: the observation data.\n\n    Raises:\n      ValueError: if the observations' batch shapes are not broadcastable.", "id": "f15742:m2"}
{"signature": "def _sample_3d(self, n, seed=None):", "body": "seed = seed_stream.SeedStream(seed, salt='<STR_LIT>')<EOL>u_shape = tf.concat([[n], self._batch_shape_tensor()], axis=<NUM_LIT:0>)<EOL>z = tf.random.uniform(u_shape, seed=seed(), dtype=self.dtype)<EOL>safe_conc = tf.where(self.concentration > <NUM_LIT:0>,<EOL>self.concentration,<EOL>tf.ones_like(self.concentration))<EOL>safe_z = tf.where(z > <NUM_LIT:0>, z, tf.ones_like(z))<EOL>safe_u = <NUM_LIT:1> + tf.reduce_logsumexp(<EOL>input_tensor=[<EOL>tf.math.log(safe_z),<EOL>tf.math.log1p(-safe_z) - <NUM_LIT:2> * safe_conc<EOL>],<EOL>axis=<NUM_LIT:0>) / safe_conc<EOL>u = tf.where(self.concentration > tf.zeros_like(safe_u), safe_u,<EOL><NUM_LIT:2> * z - <NUM_LIT:1>)<EOL>u = tf.where(tf.equal(z, <NUM_LIT:0>), -tf.ones_like(u), u)<EOL>if not self._allow_nan_stats:<EOL><INDENT>u = tf.debugging.check_numerics(u, '<STR_LIT>')<EOL><DEDENT>return u[..., tf.newaxis]<EOL>", "docstring": "Specialized inversion sampler for 3D.", "id": "f15744:c0:m16"}
{"signature": "def __init__(self,<EOL>loc,<EOL>atol=None,<EOL>rtol=None,<EOL>validate_args=False,<EOL>allow_nan_stats=True,<EOL>name=\"<STR_LIT>\"):", "body": "parameters = dict(locals())<EOL>super(VectorDeterministic, self).__init__(<EOL>loc,<EOL>atol=atol,<EOL>rtol=rtol,<EOL>is_vector=True,<EOL>validate_args=validate_args,<EOL>allow_nan_stats=allow_nan_stats,<EOL>parameters=parameters,<EOL>name=name)<EOL>", "docstring": "Initialize a `VectorDeterministic` distribution on `R^k`, for `k >= 0`.\n\n        Note that there is only one point in `R^0`, the \"point\" `[]`.  So if `k = 0`\n        then `self.prob([]) == 1`.\n\n        The `atol` and `rtol` parameters allow for some slack in `pmf`\n        computations, e.g. due to floating-point error.\n\n        ```\n        pmf(x; loc)\n          = 1, if All[Abs(x - loc) <= atol + rtol * Abs(loc)],\n          = 0, otherwise\n        ```\n\n        Args:\n          loc: Numeric `Tensor` of shape `[B1, ..., Bb, k]`, with `b >= 0`, `k >= 0`\n            The point (or batch of points) on which this distribution is supported.\n          atol:  Non-negative `Tensor` of same `dtype` as `loc` and broadcastable\n            shape.  The absolute tolerance for comparing closeness to `loc`.\n            Default is `0`.\n          rtol:  Non-negative `Tensor` of same `dtype` as `loc` and broadcastable\n            shape.  The relative tolerance for comparing closeness to `loc`.\n            Default is `0`.\n          validate_args: Python `bool`, default `False`. When `True` distribution\n            parameters are checked for validity despite possibly degrading runtime\n            performance. When `False` invalid inputs may silently render incorrect\n            outputs.\n          allow_nan_stats: Python `bool`, default `True`. When `True`, statistics\n            (e.g., mean, mode, variance) use the value \"`NaN`\" to indicate the\n            result is undefined. When `False`, an exception is raised if one or\n            more of the statistic's batch members are undefined.\n          name: Python `str` name prefixed to Ops created by this class.", "id": "f15748:c2:m0"}
{"signature": "def __init__(<EOL>self,<EOL>temperature,<EOL>logits=None,<EOL>probs=None,<EOL>validate_args=False,<EOL>allow_nan_stats=True,<EOL>name=\"<STR_LIT>\"):", "body": "parameters = dict(locals())<EOL>with tf.name_scope(name) as name:<EOL><INDENT>dtype = dtype_util.common_dtype([logits, probs, temperature], tf.float32)<EOL>self._logits, self._probs = distribution_util.get_logits_and_probs(<EOL>name=name,<EOL>logits=logits,<EOL>probs=probs,<EOL>validate_args=validate_args,<EOL>multidimensional=True,<EOL>dtype=dtype)<EOL>with tf.control_dependencies(<EOL>[assert_util.assert_positive(temperature)] if validate_args else []):<EOL><INDENT>self._temperature = tf.convert_to_tensor(<EOL>value=temperature, name=\"<STR_LIT>\", dtype=dtype)<EOL>self._temperature_2d = tf.reshape(<EOL>self._temperature, [-<NUM_LIT:1>, <NUM_LIT:1>], name=\"<STR_LIT>\")<EOL><DEDENT>logits_shape_static = tensorshape_util.with_rank_at_least(<EOL>self._logits.shape, <NUM_LIT:1>)<EOL>if tensorshape_util.rank(logits_shape_static) is not None:<EOL><INDENT>self._batch_rank = tf.convert_to_tensor(<EOL>value=tensorshape_util.rank(logits_shape_static) - <NUM_LIT:1>,<EOL>dtype=tf.int32,<EOL>name=\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>with tf.name_scope(\"<STR_LIT>\"):<EOL><INDENT>self._batch_rank = tf.rank(self._logits) - <NUM_LIT:1><EOL><DEDENT><DEDENT>with tf.name_scope(\"<STR_LIT>\"):<EOL><INDENT>self._event_size = tf.shape(input=self._logits)[-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>super(ExpRelaxedOneHotCategorical, self).__init__(<EOL>dtype=dtype,<EOL>reparameterization_type=reparameterization.FULLY_REPARAMETERIZED,<EOL>validate_args=validate_args,<EOL>allow_nan_stats=allow_nan_stats,<EOL>parameters=parameters,<EOL>graph_parents=[self._logits, self._probs, self._temperature],<EOL>name=name)<EOL>", "docstring": "Initialize ExpRelaxedOneHotCategorical using class log-probabilities.\n\n        Args:\n          temperature: An 0-D `Tensor`, representing the temperature\n            of a set of ExpRelaxedCategorical distributions. The temperature should\n            be positive.\n          logits: An N-D `Tensor`, `N >= 1`, representing the log probabilities\n            of a set of ExpRelaxedCategorical distributions. The first\n            `N - 1` dimensions index into a batch of independent distributions and\n            the last dimension represents a vector of logits for each class. Only\n            one of `logits` or `probs` should be passed in.\n          probs: An N-D `Tensor`, `N >= 1`, representing the probabilities\n            of a set of ExpRelaxedCategorical distributions. The first\n            `N - 1` dimensions index into a batch of independent distributions and\n            the last dimension represents a vector of probabilities for each\n            class. Only one of `logits` or `probs` should be passed in.\n          validate_args: Python `bool`, default `False`. When `True` distribution\n            parameters are checked for validity despite possibly degrading runtime\n            performance. When `False` invalid inputs may silently render incorrect\n            outputs.\n          allow_nan_stats: Python `bool`, default `True`. When `True`, statistics\n            (e.g., mean, mode, variance) use the value \"`NaN`\" to indicate the\n            result is undefined. When `False`, an exception is raised if one or\n            more of the statistic's batch members are undefined.\n          name: Python `str` name prefixed to Ops created by this class.", "id": "f15751:c0:m0"}
{"signature": "def __init__(self,<EOL>concentration,<EOL>rate,<EOL>validate_args=False,<EOL>allow_nan_stats=True,<EOL>name=\"<STR_LIT>\"):", "body": "parameters = dict(locals())<EOL>with tf.name_scope(name) as name:<EOL><INDENT>dtype = dtype_util.common_dtype([concentration, rate], tf.float32)<EOL>concentration = tf.convert_to_tensor(<EOL>value=concentration, name=\"<STR_LIT>\", dtype=dtype)<EOL>rate = tf.convert_to_tensor(value=rate, name=\"<STR_LIT>\", dtype=dtype)<EOL>with tf.control_dependencies([<EOL>assert_util.assert_positive(concentration),<EOL>assert_util.assert_positive(rate),<EOL>] if validate_args else []):<EOL><INDENT>self._concentration = tf.identity(concentration)<EOL>self._rate = tf.identity(rate)<EOL>dtype_util.assert_same_float_dtype([self._concentration, self._rate])<EOL><DEDENT><DEDENT>super(Gamma, self).__init__(<EOL>dtype=dtype,<EOL>validate_args=validate_args,<EOL>allow_nan_stats=allow_nan_stats,<EOL>reparameterization_type=reparameterization.FULLY_REPARAMETERIZED,<EOL>parameters=parameters,<EOL>graph_parents=[self._concentration, self._rate],<EOL>name=name)<EOL>", "docstring": "Construct Gamma with `concentration` and `rate` parameters.\n\n        The parameters `concentration` and `rate` must be shaped in a way that\n        supports broadcasting (e.g. `concentration + rate` is a valid operation).\n\n        Args:\n          concentration: Floating point tensor, the concentration params of the\n            distribution(s). Must contain only positive values.\n          rate: Floating point tensor, the inverse scale params of the\n            distribution(s). Must contain only positive values.\n          validate_args: Python `bool`, default `False`. When `True` distribution\n            parameters are checked for validity despite possibly degrading runtime\n            performance. When `False` invalid inputs may silently render incorrect\n            outputs.\n          allow_nan_stats: Python `bool`, default `True`. When `True`, statistics\n            (e.g., mean, mode, variance) use the value \"`NaN`\" to indicate the\n            result is undefined. When `False`, an exception is raised if one or\n            more of the statistic's batch members are undefined.\n          name: Python `str` name prefixed to Ops created by this class.\n\n        Raises:\n          TypeError: if `concentration` and `rate` are different dtypes.", "id": "f15756:c0:m0"}
{"signature": "@property<EOL><INDENT>def scale(self):<DEDENT>", "body": "return self.distribution.scale<EOL>", "docstring": "Distribution parameter for the pre-transformed standard deviation.", "id": "f15757:c0:m3"}
{"signature": "def _distributional_transform(self, x):", "body": "if tensorshape_util.rank(x.shape) is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>if isinstance(self._components_distribution, independent.Independent):<EOL><INDENT>univariate_components = self._components_distribution.distribution<EOL><DEDENT>else:<EOL><INDENT>univariate_components = self._components_distribution<EOL><DEDENT>with tf.control_dependencies([<EOL>assert_util.assert_equal(<EOL>univariate_components.is_scalar_event(),<EOL>True,<EOL>message=\"<STR_LIT>\")<EOL>]):<EOL><INDENT>x_padded = self._pad_sample_dims(x)  <EOL>log_prob_x = univariate_components.log_prob(x_padded)  <EOL>cdf_x = univariate_components.cdf(x_padded)  <EOL>cumsum_log_prob_x = tf.reshape(<EOL>tf.math.cumsum(<EOL>tf.reshape(log_prob_x, [-<NUM_LIT:1>, self._event_size]),<EOL>exclusive=True,<EOL>axis=-<NUM_LIT:1>),<EOL>tf.shape(input=log_prob_x))  <EOL>logits_mix_prob = distribution_utils.pad_mixture_dimensions(<EOL>self.mixture_distribution.logits, self, self.mixture_distribution,<EOL>self._event_ndims)  <EOL>log_posterior_weights_x = logits_mix_prob + cumsum_log_prob_x<EOL>component_axis = tensorshape_util.rank(x.shape) - self._event_ndims<EOL>posterior_weights_x = tf.nn.softmax(log_posterior_weights_x,<EOL>axis=component_axis)<EOL>return tf.reduce_sum(<EOL>input_tensor=posterior_weights_x * cdf_x, axis=component_axis)<EOL><DEDENT>", "docstring": "Performs distributional transform of the mixture samples.\n\n        Distributional transform removes the parameters from samples of a\n        multivariate distribution by applying conditional CDFs:\n          (F(x_1), F(x_2 | x1_), ..., F(x_d | x_1, ..., x_d-1))\n        (the indexing is over the \"flattened\" event dimensions).\n        The result is a sample of product of Uniform[0, 1] distributions.\n\n        We assume that the components are factorized, so the conditional CDFs become\n          F(x_i | x_1, ..., x_i-1) = sum_k w_i^k F_k (x_i),\n        where w_i^k is the posterior mixture weight: for i > 0\n          w_i^k = w_k prob_k(x_1, ..., x_i-1) / sum_k' w_k' prob_k'(x_1, ..., x_i-1)\n        and w_0^k = w_k is the mixture probability of the k-th component.\n\n        Arguments:\n          x: Sample of mixture distribution\n\n        Returns:\n          Result of the distributional transform", "id": "f15758:c0:m16"}
{"signature": "@tf.custom_gradient<EOL>def _prevent_2nd_derivative(x):", "body": "def grad(dy):<EOL><INDENT>return array_ops.prevent_gradient(<EOL>dy, message=\"<STR_LIT>\")<EOL><DEDENT>return tf.identity(x), grad<EOL>", "docstring": "Disables computation of the second derivatives for a tensor.\n\n    NB: you need to apply a non-identity function to the output tensor for the\n    exception to be raised.\n\n    Arguments:\n      x: A tensor.\n\n    Returns:\n      A tensor with the same value and the same derivative as x, but that raises\n      LookupError when trying to compute the second derivatives.", "id": "f15758:m2"}
{"signature": "def concat_vectors(*args):", "body": "args_ = [tf.get_static_value(x) for x in args]<EOL>if any(vec is None for vec in args_):<EOL><INDENT>return tf.concat(args, axis=<NUM_LIT:0>)<EOL><DEDENT>return [val for vec in args_ for val in vec]<EOL>", "docstring": "Concatenates input vectors, statically if possible.", "id": "f15768:m2"}
{"signature": "def __init__(self,<EOL>loc,<EOL>scale,<EOL>quadrature_size=<NUM_LIT:8>,<EOL>quadrature_fn=quadrature_scheme_lognormal_quantiles,<EOL>validate_args=False,<EOL>allow_nan_stats=True,<EOL>name=\"<STR_LIT>\"):", "body": "parameters = dict(locals())<EOL>with tf.name_scope(name) as name:<EOL><INDENT>dtype = dtype_util.common_dtype([loc, scale], tf.float32)<EOL>if loc is not None:<EOL><INDENT>loc = tf.convert_to_tensor(value=loc, name=\"<STR_LIT>\", dtype=dtype)<EOL><DEDENT>if scale is not None:<EOL><INDENT>scale = tf.convert_to_tensor(value=scale, dtype=dtype, name=\"<STR_LIT>\")<EOL><DEDENT>self._quadrature_grid, self._quadrature_probs = tuple(quadrature_fn(<EOL>loc, scale, quadrature_size, validate_args))<EOL>dt = self._quadrature_grid.dtype<EOL>if not dtype_util.base_equal(dt, self._quadrature_probs.dtype):<EOL><INDENT>raise TypeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(<EOL>dtype_util.name(dt),<EOL>dtype_util.name(self._quadrature_probs.dtype)))<EOL><DEDENT>self._distribution = poisson.Poisson(<EOL>log_rate=self._quadrature_grid,<EOL>validate_args=validate_args,<EOL>allow_nan_stats=allow_nan_stats)<EOL>self._mixture_distribution = categorical.Categorical(<EOL>logits=tf.math.log(self._quadrature_probs),<EOL>validate_args=validate_args,<EOL>allow_nan_stats=allow_nan_stats)<EOL>self._loc = loc<EOL>self._scale = scale<EOL>self._quadrature_size = quadrature_size<EOL>super(PoissonLogNormalQuadratureCompound, self).__init__(<EOL>dtype=dt,<EOL>reparameterization_type=reparameterization.NOT_REPARAMETERIZED,<EOL>validate_args=validate_args,<EOL>allow_nan_stats=allow_nan_stats,<EOL>parameters=parameters,<EOL>graph_parents=[loc, scale],<EOL>name=name)<EOL><DEDENT>", "docstring": "Constructs the PoissonLogNormalQuadratureCompound`.\n\n        Note: `probs` returned by (optional) `quadrature_fn` are presumed to be\n        either a length-`quadrature_size` vector or a batch of vectors in 1-to-1\n        correspondence with the returned `grid`. (I.e., broadcasting is only\n        partially supported.)\n\n        Args:\n          loc: `float`-like (batch of) scalar `Tensor`; the location parameter of\n            the LogNormal prior.\n          scale: `float`-like (batch of) scalar `Tensor`; the scale parameter of\n            the LogNormal prior.\n          quadrature_size: Python `int` scalar representing the number of quadrature\n            points.\n          quadrature_fn: Python callable taking `loc`, `scale`,\n            `quadrature_size`, `validate_args` and returning `tuple(grid, probs)`\n            representing the LogNormal grid and corresponding normalized weight.\n            normalized) weight.\n            Default value: `quadrature_scheme_lognormal_quantiles`.\n          validate_args: Python `bool`, default `False`. When `True` distribution\n            parameters are checked for validity despite possibly degrading runtime\n            performance. When `False` invalid inputs may silently render incorrect\n            outputs.\n          allow_nan_stats: Python `bool`, default `True`. When `True`,\n            statistics (e.g., mean, mode, variance) use the value \"`NaN`\" to\n            indicate the result is undefined. When `False`, an exception is raised\n            if one or more of the statistic's batch members are undefined.\n          name: Python `str` name prefixed to Ops created by this class.\n\n        Raises:\n          TypeError: if `quadrature_grid` and `quadrature_probs` have different base\n            `dtype`.", "id": "f15768:c0:m0"}
{"signature": "@property<EOL><INDENT>def scale(self):<DEDENT>", "body": "return self._scale<EOL>", "docstring": "Scale parameter of the LogNormal prior.", "id": "f15768:c0:m4"}
{"signature": "def _expand_to_event_rank(self, x):", "body": "expanded_x = x<EOL>for _ in range(tensorshape_util.rank(self.event_shape)):<EOL><INDENT>expanded_x = tf.expand_dims(expanded_x, -<NUM_LIT:1>)<EOL><DEDENT>return expanded_x<EOL>", "docstring": "Expand the rank of x up to static_event_rank times for broadcasting.\n\n        The static event rank was checked to not be None at construction time.\n\n        Args:\n          x: A tensor to expand.\n        Returns:\n          The expanded tensor.", "id": "f15772:c0:m8"}
{"signature": "def entropy_lower_bound(self, name=\"<STR_LIT>\"):", "body": "with self._name_scope(name):<EOL><INDENT>with tf.control_dependencies(self._assertions):<EOL><INDENT>distribution_entropies = [d.entropy() for d in self.components]<EOL>cat_probs = self._cat_probs(log_probs=False)<EOL>partial_entropies = [<EOL>c_p * m for (c_p, m) in zip(cat_probs, distribution_entropies)<EOL>]<EOL>return tf.add_n(partial_entropies)<EOL><DEDENT><DEDENT>", "docstring": "r\"\"\"A lower bound on the entropy of this mixture model.\n\n        The bound below is not always very tight, and its usefulness depends\n        on the mixture probabilities and the components in use.\n\n        A lower bound is useful for ELBO when the `Mixture` is the variational\n        distribution:\n\n        \\\\(\n        \\log p(x) >= ELBO = \\int q(z) \\log p(x, z) dz + H[q]\n        \\\\)\n\n        where \\\\( p \\\\) is the prior distribution, \\\\( q \\\\) is the variational,\n        and \\\\( H[q] \\\\) is the entropy of \\\\( q \\\\). If there is a lower bound\n        \\\\( G[q] \\\\) such that \\\\( H[q] \\geq G[q] \\\\) then it can be used in\n        place of \\\\( H[q] \\\\).\n\n        For a mixture of distributions \\\\( q(Z) = \\sum_i c_i q_i(Z) \\\\) with\n        \\\\( \\sum_i c_i = 1 \\\\), by the concavity of \\\\( f(x) = -x \\log x \\\\), a\n        simple lower bound is:\n\n        \\\\(\n        \\begin{align}\n        H[q] & = - \\int q(z) \\log q(z) dz \\\\\\\n           & = - \\int (\\sum_i c_i q_i(z)) \\log(\\sum_i c_i q_i(z)) dz \\\\\\\n           & \\geq - \\sum_i c_i \\int q_i(z) \\log q_i(z) dz \\\\\\\n           & = \\sum_i c_i H[q_i]\n        \\end{align}\n        \\\\)\n\n        This is the term we calculate below for \\\\( G[q] \\\\).\n\n        Args:\n          name: A name for this operation (optional).\n\n        Returns:\n          A lower bound on the Mixture's entropy.", "id": "f15772:c0:m14"}
{"signature": "def _mode_mean_shape(self):", "body": "shape = tensorshape_util.concatenate(self.batch_shape, self.event_shape)<EOL>has_static_shape = tensorshape_util.is_fully_defined(shape)<EOL>if not has_static_shape:<EOL><INDENT>shape = tf.concat([<EOL>self.batch_shape_tensor(),<EOL>self.event_shape_tensor(),<EOL>], <NUM_LIT:0>)<EOL><DEDENT>return shape<EOL>", "docstring": "Shape for the mode/mean Tensors.", "id": "f15774:c0:m10"}
{"signature": "@property<EOL><INDENT>def scale(self):<DEDENT>", "body": "return self._scale<EOL>", "docstring": "Distribution parameter for scale.", "id": "f15776:c0:m4"}
{"signature": "def __init__(self,<EOL>loc=None,<EOL>scale_diag=None,<EOL>scale_identity_multiplier=None,<EOL>scale_perturb_factor=None,<EOL>scale_perturb_diag=None,<EOL>validate_args=False,<EOL>allow_nan_stats=True,<EOL>name=\"<STR_LIT>\"):", "body": "parameters = dict(locals())<EOL>def _convert_to_tensor(x, name, dtype=None):<EOL><INDENT>return None if x is None else tf.convert_to_tensor(<EOL>value=x, name=name, dtype=dtype)<EOL><DEDENT>with tf.name_scope(name) as name:<EOL><INDENT>with tf.name_scope(\"<STR_LIT>\"):<EOL><INDENT>dtype = dtype_util.common_dtype([<EOL>loc, scale_diag, scale_identity_multiplier, scale_perturb_factor,<EOL>scale_perturb_diag<EOL>], tf.float32)<EOL>has_low_rank = (scale_perturb_factor is not None or<EOL>scale_perturb_diag is not None)<EOL>scale = distribution_util.make_diag_scale(<EOL>loc=loc,<EOL>scale_diag=scale_diag,<EOL>scale_identity_multiplier=scale_identity_multiplier,<EOL>validate_args=validate_args,<EOL>assert_positive=has_low_rank,<EOL>dtype=dtype)<EOL>scale_perturb_factor = _convert_to_tensor(<EOL>scale_perturb_factor, name=\"<STR_LIT>\", dtype=dtype)<EOL>scale_perturb_diag = _convert_to_tensor(<EOL>scale_perturb_diag, name=\"<STR_LIT>\", dtype=dtype)<EOL>if has_low_rank:<EOL><INDENT>scale = tf.linalg.LinearOperatorLowRankUpdate(<EOL>scale,<EOL>u=scale_perturb_factor,<EOL>diag_update=scale_perturb_diag,<EOL>is_diag_update_positive=scale_perturb_diag is None,<EOL>is_non_singular=True,  <EOL>is_self_adjoint=True,<EOL>is_positive_definite=True,<EOL>is_square=True)<EOL><DEDENT><DEDENT><DEDENT>super(MultivariateNormalDiagPlusLowRank, self).__init__(<EOL>loc=loc,<EOL>scale=scale,<EOL>validate_args=validate_args,<EOL>allow_nan_stats=allow_nan_stats,<EOL>name=name)<EOL>self._parameters = parameters<EOL>", "docstring": "Construct Multivariate Normal distribution on `R^k`.\n\n        The `batch_shape` is the broadcast shape between `loc` and `scale`\n        arguments.\n\n        The `event_shape` is given by last dimension of the matrix implied by\n        `scale`. The last dimension of `loc` (if provided) must broadcast with this.\n\n        Recall that `covariance = scale @ scale.T`. A (non-batch) `scale` matrix is:\n\n        ```none\n        scale = diag(scale_diag + scale_identity_multiplier ones(k)) +\n            scale_perturb_factor @ diag(scale_perturb_diag) @ scale_perturb_factor.T\n        ```\n\n        where:\n\n        * `scale_diag.shape = [k]`,\n        * `scale_identity_multiplier.shape = []`,\n        * `scale_perturb_factor.shape = [k, r]`, typically `k >> r`, and,\n        * `scale_perturb_diag.shape = [r]`.\n\n        Additional leading dimensions (if any) will index batches.\n\n        If both `scale_diag` and `scale_identity_multiplier` are `None`, then\n        `scale` is the Identity matrix.\n\n        Args:\n          loc: Floating-point `Tensor`. If this is set to `None`, `loc` is\n            implicitly `0`. When specified, may have shape `[B1, ..., Bb, k]` where\n            `b >= 0` and `k` is the event size.\n          scale_diag: Non-zero, floating-point `Tensor` representing a diagonal\n            matrix added to `scale`. May have shape `[B1, ..., Bb, k]`, `b >= 0`,\n            and characterizes `b`-batches of `k x k` diagonal matrices added to\n            `scale`. When both `scale_identity_multiplier` and `scale_diag` are\n            `None` then `scale` is the `Identity`.\n          scale_identity_multiplier: Non-zero, floating-point `Tensor` representing\n            a scaled-identity-matrix added to `scale`. May have shape\n            `[B1, ..., Bb]`, `b >= 0`, and characterizes `b`-batches of scaled\n            `k x k` identity matrices added to `scale`. When both\n            `scale_identity_multiplier` and `scale_diag` are `None` then `scale` is\n            the `Identity`.\n          scale_perturb_factor: Floating-point `Tensor` representing a rank-`r`\n            perturbation added to `scale`. May have shape `[B1, ..., Bb, k, r]`,\n            `b >= 0`, and characterizes `b`-batches of rank-`r` updates to `scale`.\n            When `None`, no rank-`r` update is added to `scale`.\n          scale_perturb_diag: Floating-point `Tensor` representing a diagonal matrix\n            inside the rank-`r` perturbation added to `scale`. May have shape\n            `[B1, ..., Bb, r]`, `b >= 0`, and characterizes `b`-batches of `r x r`\n            diagonal matrices inside the perturbation added to `scale`. When\n            `None`, an identity matrix is used inside the perturbation. Can only be\n            specified if `scale_perturb_factor` is also specified.\n          validate_args: Python `bool`, default `False`. When `True` distribution\n            parameters are checked for validity despite possibly degrading runtime\n            performance. When `False` invalid inputs may silently render incorrect\n            outputs.\n          allow_nan_stats: Python `bool`, default `True`. When `True`,\n            statistics (e.g., mean, mode, variance) use the value \"`NaN`\" to\n            indicate the result is undefined. When `False`, an exception is raised\n            if one or more of the statistic's batch members are undefined.\n          name: Python `str` name prefixed to Ops created by this class.\n\n        Raises:\n          ValueError: if at most `scale_identity_multiplier` is specified.", "id": "f15777:c0:m0"}
{"signature": "def _build_iid_normal_model(self, num_timesteps, latent_size,<EOL>observation_size, transition_variance,<EOL>observation_variance):", "body": "transition_variance = self._build_placeholder(transition_variance)<EOL>observation_variance = self._build_placeholder(observation_variance)<EOL>random_orthogonal_matrix = lambda: np.linalg.qr(<EOL>np.random.randn(latent_size, latent_size))[<NUM_LIT:0>][:observation_size, :]<EOL>observation_matrix = self._build_placeholder(random_orthogonal_matrix())<EOL>model = tfd.LinearGaussianStateSpaceModel(<EOL>num_timesteps=num_timesteps,<EOL>transition_matrix=self._build_placeholder(<EOL>np.zeros([latent_size, latent_size])),<EOL>transition_noise=tfd.MultivariateNormalDiag(<EOL>scale_diag=tf.sqrt(transition_variance) *<EOL>tf.ones([latent_size], dtype=self.dtype)),<EOL>observation_matrix=observation_matrix,<EOL>observation_noise=tfd.MultivariateNormalDiag(<EOL>scale_diag=tf.sqrt(observation_variance) *<EOL>tf.ones([observation_size], dtype=self.dtype)),<EOL>initial_state_prior=tfd.MultivariateNormalDiag(<EOL>scale_diag=tf.sqrt(transition_variance) *<EOL>tf.ones([latent_size], dtype=self.dtype)),<EOL>validate_args=True)<EOL>return model<EOL>", "docstring": "Build a model whose outputs are IID normal by construction.", "id": "f15779:c0:m1"}
{"signature": "def pad_shape_right_with_ones(x, ndims):", "body": "if not (isinstance(ndims, int) and ndims >= <NUM_LIT:0>):<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>.format(ndims))<EOL><DEDENT>if ndims == <NUM_LIT:0>:<EOL><INDENT>return x<EOL><DEDENT>x = tf.convert_to_tensor(value=x)<EOL>original_shape = x.shape<EOL>new_shape = distribution_util.pad(<EOL>tf.shape(input=x), axis=<NUM_LIT:0>, back=True, value=<NUM_LIT:1>, count=ndims)<EOL>x = tf.reshape(x, new_shape)<EOL>x.set_shape(original_shape.concatenate([<NUM_LIT:1>]*ndims))<EOL>return x<EOL>", "docstring": "Maybe add `ndims` ones to `x.shape` on the right.\n\n    If `ndims` is zero, this is a no-op; otherwise, we will create and return a\n    new `Tensor` whose shape is that of `x` with `ndims` ones concatenated on the\n    right side. If the shape of `x` is known statically, the shape of the return\n    value will be as well.\n\n    Args:\n      x: The `Tensor` we'll return a reshaping of.\n      ndims: Python `integer` number of ones to pad onto `x.shape`.\n    Returns:\n      If `ndims` is zero, `x`; otherwise, a `Tensor` whose shape is that of `x`\n      with `ndims` ones concatenated on the right side. If possible, returns a\n      `Tensor` whose shape is known statically.\n    Raises:\n      ValueError: if `ndims` is not a Python `integer` greater than or equal to\n      zero.", "id": "f15784:m0"}
{"signature": "def __init__(self, kernels, name=None):", "body": "if not kernels:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if len(set([k.feature_ndims for k in kernels])) > <NUM_LIT:1>:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\" %<EOL>str([k.feature_ndims for k in kernels]))<EOL><DEDENT>self._kernels = _flatten_summand_list(kernels)<EOL>if name is None:<EOL><INDENT>name = '<STR_LIT>'<EOL><DEDENT>super(_SumKernel, self).__init__(<EOL>feature_ndims=kernels[<NUM_LIT:0>].feature_ndims,<EOL>dtype=util.maybe_get_common_dtype(<EOL>[None if k.dtype is None else k for k in kernels]),<EOL>name=name)<EOL>", "docstring": "Create a kernel which is the sum of `kernels`.\n\n        The input list is 'flattened' in the sense that any entries which are also\n        of type `_SumKernel` will have their list of kernels appended to this\n        instance's list of kernels. This will reduce the stack depth when actually\n        evaluating the sum over kernel applications.\n\n        Args:\n          kernels: Python `list` of `PositiveSemidefiniteKernel` instances.\n          name: Python `str` name prefixed to Ops created by this class.\n        Raises:\n          ValueError: `kernels` is an empty list, or `kernels` don't all have the\n          same `feature_ndims`.", "id": "f15786:c1:m0"}
{"signature": "def __init__(self, feature_ndims, dtype=None, name=None):", "body": "if not (isinstance(feature_ndims, int) and feature_ndims > <NUM_LIT:0>):<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>' +<EOL>'<STR_LIT>'.format(feature_ndims))<EOL><DEDENT>self._feature_ndims = feature_ndims<EOL>self._dtype = dtype<EOL>if not name or name[-<NUM_LIT:1>] != '<STR_LIT:/>':  <EOL><INDENT>name = tf.compat.v1.name_scope(name or type(self).__name__).name<EOL><DEDENT>self._name = name<EOL>", "docstring": "Construct a PositiveSemidefiniteKernel (subclass) instance.\n\n        Args:\n          feature_ndims: Python `integer` indicating the number of dims (the rank)\n            of the feature space this kernel acts on.\n          dtype: `DType` on which this kernel operates.\n          name: Python `str` name prefixed to Ops created by this class. Default:\n            subclass name.\n\n        Raises:\n          ValueError: if `feature_ndims` is not an integer greater than 0\n        Inputs to PositiveSemidefiniteKernel methods partition into 3 pieces:\n\n        ```none\n        [b1, ..., bB, e, f1, ..., fF]\n        '----------'  |  '---------'\n             |        |       '-- Feature dimensions\n             |        '-- Example dimension (`matrix`-only)\n             '-- Batch dimensions\n        ```\n\n        The `feature_ndims` argument declares how many of the right-most shape\n        dimensions belong to the feature dimensions. This enables us to predict\n        which shape dimensions will be 'reduced' away during kernel computation.", "id": "f15786:c0:m0"}
{"signature": "def _apply(self, x1, x2, param_expansion_ndims=<NUM_LIT:0>):", "body": "raise NotImplementedError(<EOL>'<STR_LIT>')<EOL>", "docstring": "Apply the kernel function to a pair of (batches of) inputs.\n\n        Args:\n          x1: `Tensor` input to the first positional parameter of the kernel, of\n            shape `[b1, ..., bB, f1, ..., fF]`, where `B` may be zero (no batching)\n            and `F` (number of feature dimensions) must equal the kernel's\n            `feature_ndims` property. Batch shape must broadcast with the batch\n            shape of `x2` and with the kernel's parameters *after* parameter\n            expansion (see `param_expansion_ndims` argument).\n          x2: `Tensor` input to the second positional parameter of the kernel,\n            shape `[c1, ..., cC, f1, ..., fF]`, where `C` may be zero (no batching)\n            and `F` (number of feature dimensions) must equal the kernel's\n            `feature_ndims` property. Batch shape must broadcast with the batch\n            shape of `x1` and with the kernel's parameters *after* parameter\n            expansion (see `param_expansion_ndims` argument).\n          param_expansion_ndims: Python `integer` enabling reshaping of kernel\n            parameters by concatenating a list of 1's to the param shapes. This\n            allows the caller to control how the parameters broadcast across the\n            inputs.\n\n        Returns:\n          `Tensor` containing the (batch of) results of applying the kernel function\n          to inputs `x1` and `x2`. If the kernel parameters' batch shape *after*\n          parameter expansion (ie, concatenating `param_expansion_ndims` 1's onto\n          the parameters' shapes) is `[k1, ..., kK, 1, ..., 1]` then the shape of\n          the `Tensor` resulting from this method call is\n          `broadcast([b1, ..., bB], [c1, ..., cC], [k1, ..., kK, 1, ..., 1])`.", "id": "f15786:c0:m8"}
{"signature": "@property<EOL><INDENT>def kernels(self):<DEDENT>", "body": "return self._kernels<EOL>", "docstring": "The list of kernels this _SumKernel sums over.", "id": "f15786:c1:m1"}
{"signature": "def __init__(self, kernels, name=None):", "body": "if not kernels:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if len(set([k.feature_ndims for k in kernels])) > <NUM_LIT:1>:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\" %<EOL>str([k.feature_ndims for k in kernels]))<EOL><DEDENT>self._kernels = _flatten_multiplicand_list(kernels)<EOL>if name is None:<EOL><INDENT>name = '<STR_LIT>'<EOL><DEDENT>super(_ProductKernel, self).__init__(<EOL>feature_ndims=kernels[<NUM_LIT:0>].feature_ndims,<EOL>dtype=util.maybe_get_common_dtype(<EOL>[None if k.dtype is None else k for k in kernels]),<EOL>name=name)<EOL>", "docstring": "Create a kernel which is the product of `kernels`.\n\n        The input list is 'flattened' in the sense that any entries which are also\n        of type `_ProductKernel` will have their list of kernels appended to this\n        instance's list of kernels. This will reduce the stack depth when actually\n        evaluating the product over kernel applications.\n\n        Args:\n          kernels: Python `list` of `PositiveSemidefiniteKernel` instances.\n          name: Python `str` name prefixed to Ops created by this class.\n        Raises:\n          ValueError: `kernels` is an empty list, or `kernels` don't all have the\n          same `feature_ndims`.", "id": "f15786:c2:m0"}
{"signature": "@property<EOL><INDENT>def kernels(self):<DEDENT>", "body": "return self._kernels<EOL>", "docstring": "The list of kernels this _ProductKernel multiplies over.", "id": "f15786:c2:m1"}
{"signature": "@property<EOL><INDENT>def name(self):<DEDENT>", "body": "return self._name<EOL>", "docstring": "Name prepended to all ops created by this class.", "id": "f15786:c0:m3"}
{"signature": "def matrix(self, x1, x2):", "body": "with self._name_scope(self._name, values=[x1, x2]):<EOL><INDENT>x1 = tf.convert_to_tensor(value=x1, name='<STR_LIT>')<EOL>x2 = tf.convert_to_tensor(value=x2, name='<STR_LIT>')<EOL>x1 = tf.expand_dims(x1, -(self.feature_ndims + <NUM_LIT:1>))<EOL>x2 = tf.expand_dims(x2, -(self.feature_ndims + <NUM_LIT:2>))<EOL>return self._apply(x1, x2, param_expansion_ndims=<NUM_LIT:2>)<EOL><DEDENT>", "docstring": "Construct (batched) matrices from (batches of) collections of inputs.\n\n        Args:\n          x1: `Tensor` input to the first positional parameter of the kernel, of\n            shape `[b1, ..., bB, e1, f1, ..., fF]`, where `B` may be zero (ie, no\n            batching), e1 is an integer greater than zero, and `F` (number of\n            feature dimensions) must equal the kernel's `feature_ndims` property.\n            Batch shape must broadcast with the batch shape of `x2` and with the\n            kernel's parameters *after* parameter expansion (see\n            `param_expansion_ndims` argument).\n          x2: `Tensor` input to the second positional parameter of the kernel,\n            shape `[c1, ..., cC, e2, f1, ..., fF]`, where `C` may be zero (ie, no\n            batching), e2 is an integer greater than zero,  and `F` (number of\n            feature dimensions) must equal the kernel's `feature_ndims` property.\n            Batch shape must broadcast with the batch shape of `x1` and with the\n            kernel's parameters *after* parameter expansion (see\n            `param_expansion_ndims` argument).\n\n        Returns:\n          `Tensor containing (batch of) matrices of kernel applications to pairs\n          from inputs `x1` and `x2`. If the kernel parameters' batch shape is\n          `[k1, ..., kK]`, then the shape of the resulting `Tensor` is\n          `broadcast([b1, ..., bB], [c1, ..., cC], [k1, ..., kK]) + [e1, e2]`.\n\n        Given inputs `x1` and `x2` of shapes\n\n        ```none\n        [b1, ..., bB, e1, f1, ..., fF]\n        ```\n\n        and\n\n        ```none\n        [c1, ..., cC, e2, f1, ..., fF]\n        ```\n\n        This method computes the batch of `e1 x e2` matrices resulting from applying\n        the kernel function to all pairs of inputs from `x1` and `x2`. The shape\n        of the batch of matrices is the result of broadcasting the batch shapes of\n        `x1`, `x2`, and the kernel parameters (see examples below). As such, it's\n        required that these shapes all be broadcast compatible. However, the kernel\n        parameter batch shapes need not broadcast against the 'example shapes' (`e1`\n        and `e2` above).\n\n        When the two inputs are the (batches of) identical collections, the\n        resulting matrix is the so-called Gram (or Gramian) matrix\n        (https://en.wikipedia.org/wiki/Gramian_matrix).\n\n        N.B., this method can only be used to compute the pairwise application of\n        the kernel function on rank-1 collections. E.g., it *does* support inputs of\n        shape `[e1, f]` and `[e2, f]`, yielding a matrix of shape `[e1, e2]`. It\n        *does not* support inputs of shape `[e1, e2, f]` and `[e3, e4, f]`, yielding\n        a `Tensor` of shape `[e1, e2, e3, e4]`. To do this, one should instead\n        reshape the inputs and pass them to `apply`, e.g.:\n\n        ```python\n        k = tfpk.SomeKernel()\n        t1 = tf.placeholder([4, 4, 3], tf.float32)\n        t2 = tf.placeholder([5, 5, 3], tf.float32)\n        k.apply(\n            tf.reshape(t1, [4, 4, 1, 1, 3]),\n            tf.reshape(t2, [1, 1, 5, 5, 3])).shape\n        # ==> [4, 4, 5, 5, 3]\n        ```\n\n        `matrix` is a special case of the above, where there is only one example\n        dimension; indeed, its implementation looks almost exactly like the above\n        (reshaped inputs passed to the private version of `_apply`).\n\n        #### Examples\n\n        First, consider a kernel with a single scalar parameter.\n\n        ```python\n        import tensorflow_probability as tfp\n\n        scalar_kernel = tfp.positive_semidefinite_kernels.SomeKernel(param=.5)\n        scalar_kernel.batch_shape\n        # ==> []\n\n        # Our inputs are two lists of 3-D vectors\n        x = np.ones([5, 3], np.float32)\n        y = np.ones([4, 3], np.float32)\n        scalar_kernel.matrix(x, y).shape\n        # ==> [5, 4]\n        ```\n\n        The result comes from applying the kernel to the entries in `x` and `y`\n        pairwise, across all pairs:\n\n          ```none\n          | k(x[0], y[0])    k(x[0], y[1])  ...  k(x[0], y[3]) |\n          | k(x[1], y[0])    k(x[1], y[1])  ...  k(x[1], y[3]) |\n          |      ...              ...                 ...      |\n          | k(x[4], y[0])    k(x[4], y[1])  ...  k(x[4], y[3]) |\n          ```\n\n        Now consider a kernel with batched parameters with the same inputs\n\n        ```python\n        batch_kernel = tfp.positive_semidefinite_kernels.SomeKernel(param=[1., .5])\n        batch_kernel.batch_shape\n        # ==> [2]\n\n        batch_kernel.matrix(x, y).shape\n        # ==> [2, 5, 4]\n        ```\n\n        This results in a batch of 2 matrices, one computed from the kernel with\n        `param = 1.` and the other with `param = .5`.\n\n        We also support batching of the inputs. First, let's look at that with\n        the scalar kernel again.\n\n        ```python\n        # Batch of 10 lists of 5 vectors of dimension 3\n        x = np.ones([10, 5, 3], np.float32)\n\n        # Batch of 10 lists of 4 vectors of dimension 3\n        y = np.ones([10, 4, 3], np.float32)\n\n        scalar_kernel.matrix(x, y).shape\n        # ==> [10, 5, 4]\n        ```\n\n        The result is a batch of 10 matrices built from the batch of 10 lists of\n        input vectors. These batch shapes have to be broadcastable. The following\n        will *not* work:\n\n        ```python\n        x = np.ones([10, 5, 3], np.float32)\n        y = np.ones([20, 4, 3], np.float32)\n        scalar_kernel.matrix(x, y).shape\n        # ==> Error! [10] and [20] can't broadcast.\n        ```\n\n        Now let's consider batches of inputs in conjunction with batches of kernel\n        parameters. We require that the input batch shapes be broadcastable with\n        the kernel parameter batch shapes, otherwise we get an error:\n\n        ```python\n        x = np.ones([10, 5, 3], np.float32)\n        y = np.ones([10, 4, 3], np.float32)\n\n        batch_kernel = tfp.positive_semidefinite_kernels.SomeKernel(params=[1., .5])\n        batch_kernel.batch_shape\n        # ==> [2]\n        batch_kernel.matrix(x, y).shape\n        # ==> Error! [2] and [10] can't broadcast.\n        ```\n\n        The fix is to make the kernel parameter shape broadcastable with `[10]` (or\n        reshape the inputs to be broadcastable!):\n\n        ```python\n        x = np.ones([10, 5, 3], np.float32)\n        y = np.ones([10, 4, 3], np.float32)\n\n        batch_kernel = tfp.positive_semidefinite_kernels.SomeKernel(\n            params=[[1.], [.5]])\n        batch_kernel.batch_shape\n        # ==> [2, 1]\n        batch_kernel.matrix(x, y).shape\n        # ==> [2, 10, 5, 4]\n\n        # Or, make the inputs broadcastable:\n        x = np.ones([10, 1, 5, 3], np.float32)\n        y = np.ones([10, 1, 4, 3], np.float32)\n\n        batch_kernel = tfp.positive_semidefinite_kernels.SomeKernel(\n            params=[1., .5])\n        batch_kernel.batch_shape\n        # ==> [2]\n        batch_kernel.matrix(x, y).shape\n        # ==> [10, 2, 5, 4]\n\n        ```\n\n        Here, we have the result of applying the kernel, with 2 different\n        parameters, to each of a batch of 10 pairs of input lists.", "id": "f15786:c0:m9"}
{"signature": "@contextlib.contextmanager<EOL><INDENT>def _name_scope(self, name=None, values=None):<DEDENT>", "body": "with tf.compat.v1.name_scope(self.name):<EOL><INDENT>values = [] if values is None else values<EOL>with tf.compat.v1.name_scope(name, values=values) as scope:<EOL><INDENT>yield scope<EOL><DEDENT><DEDENT>", "docstring": "Helper function to standardize op scope.", "id": "f15786:c0:m6"}
{"signature": "def __init__(self,<EOL>amplitude=None,<EOL>length_scale=None,<EOL>feature_ndims=<NUM_LIT:1>,<EOL>validate_args=False,<EOL>name='<STR_LIT>'):", "body": "with tf.compat.v1.name_scope(<EOL>name, values=[amplitude, length_scale]) as name:<EOL><INDENT>dtype = super(MaternFiveHalves, self)._init_params(<EOL>amplitude, length_scale, validate_args)<EOL><DEDENT>super(MaternFiveHalves, self).__init__(<EOL>feature_ndims, dtype=dtype, name=name)<EOL>", "docstring": "Construct a MaternFiveHalves kernel instance.\n\n        Args:\n          amplitude: Positive floating point `Tensor` that controls the maximum\n            value of the kernel. Must be broadcastable with `length_scale` and\n            inputs to `apply` and `matrix` methods. A value of `None` is treated\n            like 1.\n          length_scale: Positive floating point `Tensor` that controls how sharp or\n            wide the kernel shape is. This provides a characteristic \"unit\" of\n            length against which `||x - y||` can be compared for scale. Must be\n            broadcastable with `amplitude`, and inputs to `apply` and `matrix`\n            methods. A value of `None` is treated like 1.\n          feature_ndims: Python `int` number of rightmost dims to include in the\n            squared difference norm in the exponential.\n          validate_args: If `True`, parameters are checked for validity despite\n            possibly degrading runtime performance\n          name: Python `str` name prefixed to Ops created by this class.", "id": "f15792:c3:m0"}
{"signature": "@property<EOL><INDENT>def amplitude(self):<DEDENT>", "body": "return self._amplitude<EOL>", "docstring": "Amplitude parameter.", "id": "f15792:c0:m1"}
{"signature": "@property<EOL><INDENT>def shift(self):<DEDENT>", "body": "return self._shift<EOL>", "docstring": "Shift of linear function that is exponentiated.", "id": "f15795:c0:m3"}
{"signature": "@property<EOL><INDENT>def slope_variance(self):<DEDENT>", "body": "return self._slope_variance<EOL>", "docstring": "Variance on slope parameter.", "id": "f15795:c0:m2"}
{"signature": "def _make_random_variable(distribution_cls):", "body": "@interceptable<EOL>@functools.wraps(distribution_cls, assigned=('<STR_LIT>', '<STR_LIT>'))<EOL>@docstring_util.expand_docstring(<EOL>cls=distribution_cls.__name__,<EOL>doc=inspect.cleandoc(distribution_cls.__init__.__doc__ or '<STR_LIT>'))<EOL>def func(*args, **kwargs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>sample_shape = kwargs.pop('<STR_LIT>', ())<EOL>value = kwargs.pop('<STR_LIT:value>', None)<EOL>return RandomVariable(distribution=distribution_cls(*args, **kwargs),<EOL>sample_shape=sample_shape,<EOL>value=value)<EOL><DEDENT>return func<EOL>", "docstring": "Factory function to make random variable given distribution class.", "id": "f15799:m3"}
{"signature": "@interceptable<EOL>def _build_custom_rv(distribution, sample_shape, value, name):", "body": "<EOL>del name  <EOL>return RandomVariable(distribution=distribution,<EOL>sample_shape=sample_shape,<EOL>value=value)<EOL>", "docstring": "RandomVariable constructor with a dummy name argument.", "id": "f15799:m1"}
{"signature": "def _simple_name(distribution):", "body": "simple_name = distribution.name<EOL>if simple_name.endswith('<STR_LIT:/>'):<EOL><INDENT>simple_name = simple_name.split('<STR_LIT:/>')[-<NUM_LIT:2>]<EOL><DEDENT>parts = simple_name.split('<STR_LIT:_>')<EOL>if parts[-<NUM_LIT:1>].isdigit():<EOL><INDENT>simple_name = '<STR_LIT:_>'.join(parts[:-<NUM_LIT:1>])<EOL><DEDENT>return simple_name<EOL>", "docstring": "Infer the original name passed into a distribution constructor.\n\n    Distributions typically follow the pattern of\n    with.name_scope(name) as name:\n      super(name=name)\n    so we attempt to reverse the name-scope transformation to allow\n    addressing of RVs by the distribution's original, user-visible\n    name kwarg.\n\n    Args:\n      distribution: a tfd.Distribution instance.\n    Returns:\n      simple_name: the original name passed into the Distribution.\n\n    #### Example\n\n    ```\n    d1 = tfd.Normal(0., 1., name='x') # d1.name = 'x/'\n    d2 = tfd.Normal(0., 1., name='x') # d2.name = 'x_2/'\n    _simple_name(d2) # returns 'x'\n\n    ```", "id": "f15799:m0"}
{"signature": "@property<EOL><INDENT>def shape(self):<DEDENT>", "body": "return self.value.shape<EOL>", "docstring": "Shape of random variable.", "id": "f15804:c0:m5"}
{"signature": "@property<EOL><INDENT>def value(self):<DEDENT>", "body": "if self._value is None:<EOL><INDENT>try:<EOL><INDENT>self._value = self.distribution.sample(self.sample_shape_tensor())<EOL><DEDENT>except NotImplementedError:<EOL><INDENT>raise NotImplementedError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>.format(self.distribution.__class__.__name__))<EOL><DEDENT><DEDENT>return self._value<EOL>", "docstring": "Get tensor that the random variable corresponds to.", "id": "f15804:c0:m6"}
{"signature": "@property<EOL><INDENT>def distribution(self):<DEDENT>", "body": "return self._distribution<EOL>", "docstring": "Distribution of random variable.", "id": "f15804:c0:m1"}
{"signature": "def eval(self, session=None, feed_dict=None):", "body": "return self.value.eval(session=session, feed_dict=feed_dict)<EOL>", "docstring": "In a session, computes and returns the value of this random variable.\n\n        This is not a graph construction method, it does not add ops to the graph.\n\n        This convenience method requires a session where the graph\n        containing this variable has been launched. If no session is\n        passed, the default session is used.\n\n        Args:\n          session: tf.BaseSession.\n            The `tf.Session` to use to evaluate this random variable. If\n            none, the default session is used.\n          feed_dict: dict.\n            A dictionary that maps `tf.Tensor` objects to feed values. See\n            `tf.Session.run()` for a description of the valid feed values.\n\n        Returns:\n          Value of the random variable.\n\n        #### Examples\n\n        ```python\n        x = Normal(0.0, 1.0)\n        with tf.Session() as sess:\n          # Usage passing the session explicitly.\n          print(x.eval(sess))\n          # Usage with the default session.  The 'with' block\n          # above makes 'sess' the default session.\n          print(x.eval())\n        ```", "id": "f15804:c0:m12"}
{"signature": "def make_value_setter(**model_kwargs):", "body": "def set_values(f, *args, **kwargs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>name = kwargs.get(\"<STR_LIT:name>\")<EOL>if name in model_kwargs:<EOL><INDENT>kwargs[\"<STR_LIT:value>\"] = model_kwargs[name]<EOL><DEDENT>return interceptable(f)(*args, **kwargs)<EOL><DEDENT>return set_values<EOL>", "docstring": "Creates a value-setting interceptor.\n\n    This function creates an interceptor that sets values of Edward2 random\n    variable objects. This is useful for a range of tasks, including conditioning\n    on observed data, sampling from posterior predictive distributions, and as a\n    building block of inference primitives such as computing log joint\n    probabilities (see examples below).\n\n    Args:\n      **model_kwargs: dict of str to Tensor. Keys are the names of random\n        variables in the model to which this interceptor is being applied. Values\n        are Tensors to set their value to. Variables not included in this dict\n        will not be set and will maintain their existing value semantics (by\n        default, a sample from the parent-conditional distribution).\n\n    Returns:\n      set_values: function that sets the value of intercepted ops.\n\n    #### Examples\n\n    Consider for illustration a model with latent `z` and\n    observed `x`, and a corresponding trainable posterior model:\n\n    ```python\n    num_observations = 10\n    def model():\n      z = ed.Normal(loc=0, scale=1., name='z')  # log rate\n      x = ed.Poisson(rate=tf.exp(z) * tf.ones(num_observations), name='x')\n      return x\n\n    def variational_model():\n      return ed.Normal(loc=tf.Variable(0.),\n                       scale=tf.nn.softplus(tf.Variable(-4.)),\n                       name='z')  # for simplicity, match name of the model RV.\n    ```\n\n    We can use a value-setting interceptor to condition the model on observed\n    data. This approach is slightly more cumbersome than that of partially\n    evaluating the complete log-joint function, but has the potential advantage\n    that it returns a new model callable, which may be used to sample downstream\n    variables, passed into additional transformations, etc.\n\n    ```python\n    x_observed = np.array([6, 3, 1, 8, 7, 0, 6, 4, 7, 5])\n    def observed_model():\n      with ed.interception(make_value_setter(x=x_observed)):\n        model()\n    observed_log_joint_fn = ed.make_log_joint_fn(observed_model)\n\n    # After fixing 'x', the observed log joint is now only a function of 'z'.\n    # This enables us to define a variational lower bound,\n    # `E_q[ log p(x, z) - log q(z)]`, simply by evaluating the observed and\n    # variational log joints at variational samples.\n    variational_log_joint_fn = ed.make_log_joint_fn(variational_model)\n    with ed.tape() as variational_sample:  # Sample trace from variational model.\n      variational_model()\n    elbo_loss = -(observed_log_joint_fn(**variational_sample) -\n                  variational_log_joint_fn(**variational_sample))\n    ```\n\n    After performing inference by minimizing the variational loss, a value-setting\n    interceptor enables simulation from the posterior predictive distribution:\n\n    ```python\n    with ed.tape() as posterior_samples:  # tape is a map {rv.name : rv}\n      variational_model()\n    with ed.interception(ed.make_value_setter(**posterior_samples)):\n      x = model()\n    # x is a sample from p(X | Z = z') where z' ~ q(z) (the variational model)\n    ```\n\n    As another example, using a value setter inside of `ed.tape` enables\n    computing the log joint probability, by setting all variables to\n    posterior values and then accumulating the log probs of those values under\n    the induced parent-conditional distributions. This is one way that we could\n    have implemented `ed.make_log_joint_fn`:\n\n    ```python\n    def make_log_joint_fn_demo(model):\n      def log_joint_fn(**model_kwargs):\n        with ed.tape() as model_tape:\n          with ed.make_value_setter(**model_kwargs):\n            model()\n\n        # accumulate sum_i log p(X_i = x_i | X_{:i-1} = x_{:i-1})\n        log_prob = 0.\n        for rv in model_tape.values():\n          log_prob += tf.reduce_sum(rv.log_prob(rv.value))\n\n        return log_prob\n      return log_joint_fn\n    ```", "id": "f15805:m0"}
{"signature": "def _wrap_method(cls, attr):", "body": "fn = getattr(cls, attr)<EOL>is_property = isinstance(fn, property)<EOL>if is_property:<EOL><INDENT>fn = fn.fget<EOL><DEDENT>@functools.wraps(fn)<EOL>def wrapped(self, *args, **kwargs):<EOL><INDENT>return fn(self._value(), *args, **kwargs)  <EOL><DEDENT>return property(wrapped) if is_property else wrapped<EOL>", "docstring": "Replaces member function's first arg, `self`, to `self._value()`.\n\n    This function is used by `_get_tensor_like_attributes` to take existing\n    `Tensor` member functions and make them operate on `self._value()`, i.e., the\n    concretization of a `Distribution`.\n\n    Args:\n      cls: The `class` from which we will look up the `attr`.\n      attr: Python `str` representing the `attr` to inject a new notion of `self`.\n\n    Returns:\n      dependency_injected_function: Python `callable` (or `property`)\n        corresponding to `cls.attr` with `self` replaced as `self._value()`.", "id": "f15814:m0"}
{"signature": "def _get_tensor_like_attributes():", "body": "<EOL>attrs = dict()<EOL>attrs.update((attr, _wrap_method(tf.Tensor, attr))<EOL>for attr in tf.Tensor.OVERLOADABLE_OPERATORS.union({'<STR_LIT>'}))<EOL>attrs.update((attr, getattr(tf.Tensor, attr))<EOL>for attr in {'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'})<EOL>return attrs<EOL>", "docstring": "Returns `Tensor` attributes related to shape and Python builtins.", "id": "f15814:m1"}
{"signature": "def __init__(self, initializers, sizes, validate_args=False):", "body": "self._initializers = initializers<EOL>self._sizes = sizes<EOL>self._validate_args = validate_args<EOL>", "docstring": "Creates the `BlockwiseInitializer`.\n\n        Arguments:\n          initializers: `list` of Keras initializers, e.g., `\"glorot_uniform\"` or\n            `tf.keras.initializers.Constant(0.5413)`.\n          sizes: `list` of `int` scalars representing the number of elements\n            associated with each initializer in `initializers`.\n          validate_args: Python `bool` indicating we should do (possibly expensive)\n            graph-time assertions, if necessary.", "id": "f15815:c0:m0"}
{"signature": "def get_config(self):", "body": "return {<EOL>'<STR_LIT>': [<EOL>tf.compat.v2.initializers.serialize(<EOL>tf.keras.initializers.get(init))<EOL>for init in self.initializers<EOL>],<EOL>'<STR_LIT>': self.sizes,<EOL>'<STR_LIT>': self.validate_args,<EOL>}<EOL>", "docstring": "Returns initializer configuration as a JSON-serializable dict.", "id": "f15815:c0:m5"}
{"signature": "def __init__(self,<EOL>event_size,<EOL>num_components,<EOL>convert_to_tensor_fn=tfd.Distribution.sample,<EOL>sample_dtype=None,<EOL>validate_args=False,<EOL>**kwargs):", "body": "super(CategoricalMixtureOfOneHotCategorical, self).__init__(<EOL>lambda t: CategoricalMixtureOfOneHotCategorical.new(<EOL>t, event_size, num_components, sample_dtype, validate_args),<EOL>convert_to_tensor_fn,<EOL>**kwargs)<EOL>", "docstring": "Initialize the `CategoricalMixtureOfOneHotCategorical` layer.\n\n        Args:\n          event_size: Scalar `int` representing the size of single draw from this\n            distribution.\n          num_components: Scalar `int` representing the number of mixture\n            components. Must be at least 1. (If `num_components=1`, it's more\n            efficient to use the `OneHotCategorical` layer.)\n          convert_to_tensor_fn: Python `callable` that takes a `tfd.Distribution`\n            instance and returns a `tf.Tensor`-like object. For examples, see\n            `class` docstring.\n            Default value: `tfd.Distribution.sample`.\n          sample_dtype: `dtype` of samples produced by this distribution.\n            Default value: `None` (i.e., previous layer's `dtype`).\n          validate_args: Python `bool`, default `False`. When `True` distribution\n            parameters are checked for validity despite possibly degrading runtime\n            performance. When `False` invalid inputs may silently render incorrect\n            outputs.\n            Default value: `False`.\n          **kwargs: Additional keyword arguments passed to `tf.keras.Layer`.", "id": "f15817:c3:m0"}
{"signature": "@staticmethod<EOL><INDENT>def new(params, event_size, validate_args=False, name=None):<DEDENT>", "body": "with tf.compat.v1.name_scope(name, '<STR_LIT>',<EOL>[params, event_size]):<EOL><INDENT>params = tf.convert_to_tensor(value=params, name='<STR_LIT>')<EOL>scale_tril = tfb.ScaleTriL(<EOL>diag_shift=np.array(<NUM_LIT>, params.dtype.as_numpy_dtype()),<EOL>validate_args=validate_args)<EOL>return tfd.MultivariateNormalTriL(<EOL>loc=params[..., :event_size],<EOL>scale_tril=scale_tril(params[..., event_size:]),<EOL>validate_args=validate_args)<EOL><DEDENT>", "docstring": "Create the distribution instance from a `params` vector.", "id": "f15817:c1:m1"}
{"signature": "@staticmethod<EOL><INDENT>def new(params, event_shape=(), validate_args=False, name=None):<DEDENT>", "body": "with tf.compat.v1.name_scope(name, '<STR_LIT>',<EOL>[params, event_shape]):<EOL><INDENT>params = tf.convert_to_tensor(value=params, name='<STR_LIT>')<EOL>event_shape = dist_util.expand_to_vector(<EOL>tf.convert_to_tensor(<EOL>value=event_shape, name='<STR_LIT>', dtype_hint=tf.int32),<EOL>tensor_name='<STR_LIT>')<EOL>output_shape = tf.concat([<EOL>tf.shape(input=params)[:-<NUM_LIT:1>],<EOL>event_shape,<EOL>],<EOL>axis=<NUM_LIT:0>)<EOL>loc_params, scale_params = tf.split(params, <NUM_LIT:2>, axis=-<NUM_LIT:1>)<EOL>return tfd.Independent(<EOL>tfd.Logistic(<EOL>loc=tf.reshape(loc_params, output_shape),<EOL>scale=tf.math.softplus(tf.reshape(scale_params, output_shape)),<EOL>validate_args=validate_args),<EOL>reinterpreted_batch_ndims=tf.size(input=event_shape),<EOL>validate_args=validate_args)<EOL><DEDENT>", "docstring": "Create the distribution instance from a `params` vector.", "id": "f15817:c5:m1"}
{"signature": "@staticmethod<EOL><INDENT>def params_size(event_shape=(), name=None):<DEDENT>", "body": "with tf.compat.v1.name_scope(name, '<STR_LIT>',<EOL>[event_shape]):<EOL><INDENT>event_shape = tf.convert_to_tensor(<EOL>value=event_shape, name='<STR_LIT>', dtype_hint=tf.int32)<EOL>return <NUM_LIT:2> * _event_size(<EOL>event_shape, name=name or '<STR_LIT>')<EOL><DEDENT>", "docstring": "The number of `params` needed to create a single distribution.", "id": "f15817:c6:m2"}
{"signature": "def get_config(self):", "body": "config = {<EOL>'<STR_LIT>': self._event_shape,<EOL>'<STR_LIT>': _serialize(self._convert_to_tensor_fn),<EOL>'<STR_LIT>': self._sample_dtype,<EOL>'<STR_LIT>': self._validate_args<EOL>}<EOL>base_config = super(IndependentBernoulli, self).get_config()<EOL>return dict(list(base_config.items()) + list(config.items()))<EOL>", "docstring": "Returns the config of this layer.\n\n        NOTE: At the moment, this configuration can only be serialized if the\n        Layer's `convert_to_tensor_fn` is a serializable Keras object (i.e.,\n        implements `get_config`) or one of the standard values:\n         - `Distribution.sample` (or `\"sample\"`)\n         - `Distribution.mean` (or `\"mean\"`)\n         - `Distribution.mode` (or `\"mode\"`)\n         - `Distribution.stddev` (or `\"stddev\"`)\n         - `Distribution.variance` (or `\"variance\"`)", "id": "f15817:c4:m3"}
{"signature": "def __init__(self,<EOL>event_shape=(),<EOL>convert_to_tensor_fn=tfd.Distribution.sample,<EOL>validate_args=False,<EOL>**kwargs):", "body": "convert_to_tensor_fn = _get_convert_to_tensor_fn(convert_to_tensor_fn)<EOL>kwargs.pop('<STR_LIT>', None)<EOL>super(IndependentLogistic, self).__init__(<EOL>lambda t: IndependentLogistic.new(t, event_shape, validate_args),<EOL>convert_to_tensor_fn,<EOL>**kwargs)<EOL>self._event_shape = event_shape<EOL>self._convert_to_tensor_fn = convert_to_tensor_fn<EOL>self._validate_args = validate_args<EOL>", "docstring": "Initialize the `IndependentLogistic` layer.\n\n        Args:\n          event_shape: integer vector `Tensor` representing the shape of single\n            draw from this distribution.\n          convert_to_tensor_fn: Python `callable` that takes a `tfd.Distribution`\n            instance and returns a `tf.Tensor`-like object.\n            Default value: `tfd.Distribution.sample`.\n          validate_args: Python `bool`, default `False`. When `True` distribution\n            parameters are checked for validity despite possibly degrading runtime\n            performance. When `False` invalid inputs may silently render incorrect\n            outputs.\n            Default value: `False`.\n          **kwargs: Additional keyword arguments passed to `tf.keras.Layer`.", "id": "f15817:c5:m0"}
{"signature": "@staticmethod<EOL><INDENT>def new(params, event_shape=(), validate_args=False, name=None):<DEDENT>", "body": "with tf.compat.v1.name_scope(name, '<STR_LIT>',<EOL>[params, event_shape]):<EOL><INDENT>params = tf.convert_to_tensor(value=params, name='<STR_LIT>')<EOL>event_shape = dist_util.expand_to_vector(<EOL>tf.convert_to_tensor(<EOL>value=event_shape, name='<STR_LIT>', dtype_hint=tf.int32),<EOL>tensor_name='<STR_LIT>')<EOL>output_shape = tf.concat([<EOL>tf.shape(input=params)[:-<NUM_LIT:1>],<EOL>event_shape,<EOL>],<EOL>axis=<NUM_LIT:0>)<EOL>return tfd.Independent(<EOL>tfd.Poisson(<EOL>log_rate=tf.reshape(params, output_shape),<EOL>validate_args=validate_args),<EOL>reinterpreted_batch_ndims=tf.size(input=event_shape),<EOL>validate_args=validate_args)<EOL><DEDENT>", "docstring": "Create the distribution instance from a `params` vector.", "id": "f15817:c7:m1"}
{"signature": "@staticmethod<EOL><INDENT>def params_size(num_components, event_shape=(), name=None):<DEDENT>", "body": "return MixtureSameFamily.params_size(<EOL>num_components,<EOL>IndependentNormal.params_size(event_shape, name=name),<EOL>name=name)<EOL>", "docstring": "The number of `params` needed to create a single distribution.", "id": "f15817:c11:m2"}
{"signature": "def __init__(self,<EOL>event_shape=(),<EOL>convert_to_tensor_fn=tfd.Distribution.sample,<EOL>validate_args=False,<EOL>**kwargs):", "body": "convert_to_tensor_fn = _get_convert_to_tensor_fn(convert_to_tensor_fn)<EOL>kwargs.pop('<STR_LIT>', None)<EOL>super(IndependentPoisson, self).__init__(<EOL>lambda t: IndependentPoisson.new(t, event_shape, validate_args),<EOL>convert_to_tensor_fn,<EOL>**kwargs)<EOL>self._event_shape = event_shape<EOL>self._convert_to_tensor_fn = convert_to_tensor_fn<EOL>self._validate_args = validate_args<EOL>", "docstring": "Initialize the `IndependentPoisson` layer.\n\n        Args:\n          event_shape: integer vector `Tensor` representing the shape of single\n            draw from this distribution.\n          convert_to_tensor_fn: Python `callable` that takes a `tfd.Distribution`\n            instance and returns a `tf.Tensor`-like object.\n            Default value: `tfd.Distribution.sample`.\n          validate_args: Python `bool`, default `False`. When `True` distribution\n            parameters are checked for validity despite possibly degrading runtime\n            performance. When `False` invalid inputs may silently render incorrect\n            outputs.\n            Default value: `False`.\n          **kwargs: Additional keyword arguments passed to `tf.keras.Layer`.", "id": "f15817:c7:m0"}
{"signature": "def __init__(self,<EOL>event_shape=(),<EOL>convert_to_tensor_fn=tfd.Distribution.sample,<EOL>sample_dtype=None,<EOL>validate_args=False,<EOL>**kwargs):", "body": "convert_to_tensor_fn = _get_convert_to_tensor_fn(convert_to_tensor_fn)<EOL>kwargs.pop('<STR_LIT>', None)<EOL>super(IndependentBernoulli, self).__init__(<EOL>lambda t: IndependentBernoulli.new(  <EOL>t, event_shape, sample_dtype, validate_args),<EOL>convert_to_tensor_fn,<EOL>**kwargs)<EOL>self._event_shape = event_shape<EOL>self._convert_to_tensor_fn = convert_to_tensor_fn<EOL>self._sample_dtype = sample_dtype<EOL>self._validate_args = validate_args<EOL>", "docstring": "Initialize the `IndependentBernoulli` layer.\n\n        Args:\n          event_shape: integer vector `Tensor` representing the shape of single\n            draw from this distribution.\n          convert_to_tensor_fn: Python `callable` that takes a `tfd.Distribution`\n            instance and returns a `tf.Tensor`-like object. For examples, see\n            `class` docstring.\n            Default value: `tfd.Distribution.sample`.\n          sample_dtype: `dtype` of samples produced by this distribution.\n            Default value: `None` (i.e., previous layer's `dtype`).\n          validate_args: Python `bool`, default `False`. When `True` distribution\n            parameters are checked for validity despite possibly degrading runtime\n            performance. When `False` invalid inputs may silently render incorrect\n            outputs.\n            Default value: `False`.\n          **kwargs: Additional keyword arguments passed to `tf.keras.Layer`.", "id": "f15817:c4:m0"}
{"signature": "@staticmethod<EOL><INDENT>def new(params, event_size, dtype=None, validate_args=False, name=None):<DEDENT>", "body": "with tf.compat.v1.name_scope(name, '<STR_LIT>',<EOL>[params, event_size]):<EOL><INDENT>return tfd.OneHotCategorical(<EOL>logits=params,<EOL>dtype=dtype or params.dtype.base_dtype,<EOL>validate_args=validate_args)<EOL><DEDENT>", "docstring": "Create the distribution instance from a `params` vector.", "id": "f15817:c2:m1"}
{"signature": "def get_config(self):", "body": "config = {<EOL>'<STR_LIT>': self._event_shape,<EOL>'<STR_LIT>': _serialize(self._convert_to_tensor_fn),<EOL>'<STR_LIT>': self._validate_args<EOL>}<EOL>base_config = super(IndependentPoisson, self).get_config()<EOL>return dict(list(base_config.items()) + list(config.items()))<EOL>", "docstring": "Returns the config of this layer.\n\n        NOTE: At the moment, this configuration can only be serialized if the\n        Layer's `convert_to_tensor_fn` is a serializable Keras object (i.e.,\n        implements `get_config`) or one of the standard values:\n         - `Distribution.sample` (or `\"sample\"`)\n         - `Distribution.mean` (or `\"mean\"`)\n         - `Distribution.mode` (or `\"mode\"`)\n         - `Distribution.stddev` (or `\"stddev\"`)\n         - `Distribution.variance` (or `\"variance\"`)", "id": "f15817:c7:m3"}
{"signature": "@staticmethod<EOL><INDENT>def params_size(event_shape=(), name=None):<DEDENT>", "body": "with tf.compat.v1.name_scope(name, '<STR_LIT>',<EOL>[event_shape]):<EOL><INDENT>event_shape = tf.convert_to_tensor(<EOL>value=event_shape, name='<STR_LIT>', dtype_hint=tf.int32)<EOL>return _event_size(<EOL>event_shape, name=name or '<STR_LIT>')<EOL><DEDENT>", "docstring": "The number of `params` needed to create a single distribution.", "id": "f15817:c4:m2"}
{"signature": "@staticmethod<EOL><INDENT>def new(params, num_components, component_layer,<EOL>validate_args=False, name=None):<DEDENT>", "body": "with tf.compat.v1.name_scope(name, '<STR_LIT>',<EOL>[params, num_components, component_layer]):<EOL><INDENT>params = tf.convert_to_tensor(value=params, name='<STR_LIT>')<EOL>num_components = tf.convert_to_tensor(<EOL>value=num_components, name='<STR_LIT>', dtype_hint=tf.int32)<EOL>components_dist = component_layer(<EOL>tf.reshape(<EOL>params[..., num_components:],<EOL>tf.concat([tf.shape(input=params)[:-<NUM_LIT:1>], [num_components, -<NUM_LIT:1>]],<EOL>axis=<NUM_LIT:0>)))<EOL>mixture_dist = tfd.Categorical(logits=params[..., :num_components])<EOL>return tfd.MixtureSameFamily(<EOL>mixture_dist,<EOL>components_dist,<EOL>validate_args=False)<EOL><DEDENT>", "docstring": "Create the distribution instance from a `params` vector.", "id": "f15817:c10:m1"}
{"signature": "@docstring_util.expand_docstring(args=doc_args)<EOL><INDENT>def __init__(<EOL>self,<EOL>filters,<EOL>kernel_size,<EOL>strides=<NUM_LIT:1>,<EOL>padding='<STR_LIT>',<EOL>data_format='<STR_LIT>',<EOL>dilation_rate=<NUM_LIT:1>,<EOL>activation=None,<EOL>activity_regularizer=None,<EOL>kernel_posterior_fn=tfp_layers_util.default_mean_field_normal_fn(),<EOL>kernel_posterior_tensor_fn=lambda d: d.sample(),<EOL>kernel_prior_fn=tfp_layers_util.default_multivariate_normal_fn,<EOL>kernel_divergence_fn=lambda q, p, ignore: tfd.kl_divergence(q, p),<EOL>bias_posterior_fn=tfp_layers_util.default_mean_field_normal_fn(is_singular=True),  <EOL>bias_posterior_tensor_fn=lambda d: d.sample(),<EOL>bias_prior_fn=None,<EOL>bias_divergence_fn=lambda q, p, ignore: tfd.kl_divergence(q, p),<EOL>seed=None,<EOL>**kwargs):<EOL><DEDENT>", "body": "<EOL>super(Conv1DFlipout, self).__init__(<EOL>rank=<NUM_LIT:1>,<EOL>filters=filters,<EOL>kernel_size=kernel_size,<EOL>strides=strides,<EOL>padding=padding,<EOL>data_format=data_format,<EOL>dilation_rate=dilation_rate,<EOL>activation=tf.keras.activations.get(activation),<EOL>activity_regularizer=activity_regularizer,<EOL>kernel_posterior_fn=kernel_posterior_fn,<EOL>kernel_posterior_tensor_fn=kernel_posterior_tensor_fn,<EOL>kernel_prior_fn=kernel_prior_fn,<EOL>kernel_divergence_fn=kernel_divergence_fn,<EOL>bias_posterior_fn=bias_posterior_fn,<EOL>bias_posterior_tensor_fn=bias_posterior_tensor_fn,<EOL>bias_prior_fn=bias_prior_fn,<EOL>bias_divergence_fn=bias_divergence_fn,<EOL>seed=seed,<EOL>**kwargs)<EOL>", "docstring": "Construct layer.\n\n        Args:\n          filters: Integer, the dimensionality of the output space (i.e. the number\n            of filters in the convolution).\n          kernel_size: An integer or tuple/list of a single integer, specifying the\n            length of the 1D convolution window.\n          strides: An integer or tuple/list of a single integer,\n            specifying the stride length of the convolution.\n            Specifying any stride value != 1 is incompatible with specifying\n            any `dilation_rate` value != 1.\n          padding: One of `\"valid\"` or `\"same\"` (case-insensitive).\n          data_format: A string, one of `channels_last` (default) or\n            `channels_first`. The ordering of the dimensions in the inputs.\n            `channels_last` corresponds to inputs with shape `(batch, length,\n            channels)` while `channels_first` corresponds to inputs with shape\n            `(batch, channels, length)`.\n          dilation_rate: An integer or tuple/list of a single integer, specifying\n            the dilation rate to use for dilated convolution.\n            Currently, specifying any `dilation_rate` value != 1 is\n            incompatible with specifying any `strides` value != 1.\n          ${args}\n          seed: Python scalar `int` which initializes the random number\n            generator. Default value: `None` (i.e., use global seed).", "id": "f15818:c6:m0"}
{"signature": "@docstring_util.expand_docstring(args=doc_args)<EOL><INDENT>def __init__(<EOL>self,<EOL>filters,<EOL>kernel_size,<EOL>strides=(<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>),<EOL>padding='<STR_LIT>',<EOL>data_format='<STR_LIT>',<EOL>dilation_rate=(<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>),<EOL>activation=None,<EOL>activity_regularizer=None,<EOL>kernel_posterior_fn=tfp_layers_util.default_mean_field_normal_fn(),<EOL>kernel_posterior_tensor_fn=lambda d: d.sample(),<EOL>kernel_prior_fn=tfp_layers_util.default_multivariate_normal_fn,<EOL>kernel_divergence_fn=lambda q, p, ignore: tfd.kl_divergence(q, p),<EOL>bias_posterior_fn=tfp_layers_util.default_mean_field_normal_fn(is_singular=True),  <EOL>bias_posterior_tensor_fn=lambda d: d.sample(),<EOL>bias_prior_fn=None,<EOL>bias_divergence_fn=lambda q, p, ignore: tfd.kl_divergence(q, p),<EOL>seed=None,<EOL>**kwargs):<EOL><DEDENT>", "body": "<EOL>super(Conv3DFlipout, self).__init__(<EOL>rank=<NUM_LIT:3>,<EOL>filters=filters,<EOL>kernel_size=kernel_size,<EOL>strides=strides,<EOL>padding=padding,<EOL>data_format=data_format,<EOL>dilation_rate=dilation_rate,<EOL>activation=tf.keras.activations.get(activation),<EOL>activity_regularizer=activity_regularizer,<EOL>kernel_posterior_fn=kernel_posterior_fn,<EOL>kernel_posterior_tensor_fn=kernel_posterior_tensor_fn,<EOL>kernel_prior_fn=kernel_prior_fn,<EOL>kernel_divergence_fn=kernel_divergence_fn,<EOL>bias_posterior_fn=bias_posterior_fn,<EOL>bias_posterior_tensor_fn=bias_posterior_tensor_fn,<EOL>bias_prior_fn=bias_prior_fn,<EOL>bias_divergence_fn=bias_divergence_fn,<EOL>seed=seed,<EOL>**kwargs)<EOL>", "docstring": "Construct layer.\n\n        Args:\n          filters: Integer, the dimensionality of the output space (i.e. the number\n            of filters in the convolution).\n          kernel_size: An integer or tuple/list of 3 integers, specifying the\n            depth, height and width of the 3D convolution window.\n            Can be a single integer to specify the same value for\n            all spatial dimensions.\n          strides: An integer or tuple/list of 3 integers,\n            specifying the strides of the convolution along the depth,\n            height and width.\n            Can be a single integer to specify the same value for\n            all spatial dimensions.\n            Specifying any stride value != 1 is incompatible with specifying\n            any `dilation_rate` value != 1.\n          padding: One of `\"valid\"` or `\"same\"` (case-insensitive).\n          data_format: A string, one of `channels_last` (default) or\n            `channels_first`. The ordering of the dimensions in the inputs.\n            `channels_last` corresponds to inputs with shape `(batch, depth,\n            height, width, channels)` while `channels_first` corresponds to inputs\n            with shape `(batch, channels, depth, height, width)`.\n          dilation_rate: An integer or tuple/list of 3 integers, specifying\n            the dilation rate to use for dilated convolution.\n            Can be a single integer to specify the same value for\n            all spatial dimensions.\n            Currently, specifying any `dilation_rate` value != 1 is\n            incompatible with specifying any stride value != 1.\n          ${args}\n          seed: Python scalar `int` which initializes the random number\n            generator. Default value: `None` (i.e., use global seed).", "id": "f15818:c8:m0"}
{"signature": "@docstring_util.expand_docstring(args=doc_args)<EOL><INDENT>def __init__(<EOL>self,<EOL>filters,<EOL>kernel_size,<EOL>strides=(<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>),<EOL>padding='<STR_LIT>',<EOL>data_format='<STR_LIT>',<EOL>dilation_rate=(<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>),<EOL>activation=None,<EOL>activity_regularizer=None,<EOL>kernel_posterior_fn=tfp_layers_util.default_mean_field_normal_fn(),<EOL>kernel_posterior_tensor_fn=lambda d: d.sample(),<EOL>kernel_prior_fn=tfp_layers_util.default_multivariate_normal_fn,<EOL>kernel_divergence_fn=lambda q, p, ignore: tfd.kl_divergence(q, p),<EOL>bias_posterior_fn=tfp_layers_util.default_mean_field_normal_fn(is_singular=True),  <EOL>bias_posterior_tensor_fn=lambda d: d.sample(),<EOL>bias_prior_fn=None,<EOL>bias_divergence_fn=lambda q, p, ignore: tfd.kl_divergence(q, p),<EOL>**kwargs):<EOL><DEDENT>", "body": "<EOL>super(Conv3DReparameterization, self).__init__(<EOL>rank=<NUM_LIT:3>,<EOL>filters=filters,<EOL>kernel_size=kernel_size,<EOL>strides=strides,<EOL>padding=padding,<EOL>data_format=data_format,<EOL>dilation_rate=dilation_rate,<EOL>activation=tf.keras.activations.get(activation),<EOL>activity_regularizer=activity_regularizer,<EOL>kernel_posterior_fn=kernel_posterior_fn,<EOL>kernel_posterior_tensor_fn=kernel_posterior_tensor_fn,<EOL>kernel_prior_fn=kernel_prior_fn,<EOL>kernel_divergence_fn=kernel_divergence_fn,<EOL>bias_posterior_fn=bias_posterior_fn,<EOL>bias_posterior_tensor_fn=bias_posterior_tensor_fn,<EOL>bias_prior_fn=bias_prior_fn,<EOL>bias_divergence_fn=bias_divergence_fn,<EOL>**kwargs)<EOL>", "docstring": "Construct layer.\n\n        Args:\n          filters: Integer, the dimensionality of the output space (i.e. the number\n            of filters in the convolution).\n          kernel_size: An integer or tuple/list of 3 integers, specifying the\n            depth, height and width of the 3D convolution window.\n            Can be a single integer to specify the same value for\n            all spatial dimensions.\n          strides: An integer or tuple/list of 3 integers,\n            specifying the strides of the convolution along the depth,\n            height and width.\n            Can be a single integer to specify the same value for\n            all spatial dimensions.\n            Specifying any stride value != 1 is incompatible with specifying\n            any `dilation_rate` value != 1.\n          padding: One of `\"valid\"` or `\"same\"` (case-insensitive).\n          data_format: A string, one of `channels_last` (default) or\n            `channels_first`. The ordering of the dimensions in the inputs.\n            `channels_last` corresponds to inputs with shape `(batch, depth,\n            height, width, channels)` while `channels_first` corresponds to inputs\n            with shape `(batch, channels, depth, height, width)`.\n          dilation_rate: An integer or tuple/list of 3 integers, specifying\n            the dilation rate to use for dilated convolution.\n            Can be a single integer to specify the same value for\n            all spatial dimensions.\n            Currently, specifying any `dilation_rate` value != 1 is\n            incompatible with specifying any stride value != 1.\n          ${args}", "id": "f15818:c4:m0"}
{"signature": "def compute_output_shape(self, input_shape):", "body": "input_shape = tf.TensorShape(input_shape).as_list()<EOL>if self.data_format == '<STR_LIT>':<EOL><INDENT>space = input_shape[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL>new_space = []<EOL>for i in range(len(space)):<EOL><INDENT>new_dim = tf_layers_util.conv_output_length(<EOL>space[i],<EOL>self.kernel_size[i],<EOL>padding=self.padding,<EOL>stride=self.strides[i],<EOL>dilation=self.dilation_rate[i])<EOL>new_space.append(new_dim)<EOL><DEDENT>return tf.TensorShape([input_shape[<NUM_LIT:0>]] + new_space + [self.filters])<EOL><DEDENT>else:<EOL><INDENT>space = input_shape[<NUM_LIT:2>:]<EOL>new_space = []<EOL>for i in range(len(space)):<EOL><INDENT>new_dim = tf_layers_util.conv_output_length(<EOL>space[i],<EOL>self.kernel_size[i],<EOL>padding=self.padding,<EOL>stride=self.strides[i],<EOL>dilation=self.dilation_rate[i])<EOL>new_space.append(new_dim)<EOL><DEDENT>return tf.TensorShape([input_shape[<NUM_LIT:0>], self.filters] + new_space)<EOL><DEDENT>", "docstring": "Computes the output shape of the layer.\n\n        Args:\n          input_shape: Shape tuple (tuple of integers) or list of shape tuples\n            (one per output tensor of the layer). Shape tuples can include None for\n            free dimensions, instead of an integer.\n\n        Returns:\n          output_shape: A tuple representing the output shape.", "id": "f15818:c0:m3"}
{"signature": "def _distribution_to_params(self, distribution, batch_shape):", "body": "params_shape = tf.concat([batch_shape, [-<NUM_LIT:1>]], axis=<NUM_LIT:0>)<EOL>batch_and_n_shape = tf.concat(<EOL>[tf.shape(input=distribution.mixture_distribution.logits), [-<NUM_LIT:1>]],<EOL>axis=<NUM_LIT:0>)<EOL>cd = distribution.components_distribution.distribution<EOL>return tf.concat([<EOL>distribution.mixture_distribution.logits,<EOL>tf.reshape(tf.concat([<EOL>tf.reshape(cd.loc, batch_and_n_shape),<EOL>tf.reshape(tfd.softplus_inverse(cd.scale), batch_and_n_shape)<EOL>], axis=-<NUM_LIT:1>), params_shape),<EOL>], axis=-<NUM_LIT:1>)<EOL>", "docstring": "Given a self.layer_class instance, return a tensor of its parameters.", "id": "f15819:c21:m0"}
{"signature": "def _distribution_to_params(self, distribution, batch_shape):", "body": "params_shape = tf.concat([batch_shape, [-<NUM_LIT:1>]], axis=<NUM_LIT:0>)<EOL>batch_and_n_shape = tf.concat(<EOL>[tf.shape(input=distribution.mixture_distribution.logits), [-<NUM_LIT:1>]],<EOL>axis=<NUM_LIT:0>)<EOL>cd = distribution.components_distribution.distribution<EOL>return tf.concat([<EOL>distribution.mixture_distribution.logits,<EOL>tf.reshape(tf.concat([<EOL>tf.reshape(cd.loc, batch_and_n_shape),<EOL>tf.reshape(tfd.softplus_inverse(cd.scale), batch_and_n_shape)<EOL>], axis=-<NUM_LIT:1>), params_shape),<EOL>], axis=-<NUM_LIT:1>)<EOL>", "docstring": "Given a self.layer_class instance, return a tensor of its parameters.", "id": "f15819:c24:m0"}
{"signature": "def assertExportable(self, model, batch_size=<NUM_LIT:1>):", "body": "batch_shape = [batch_size]<EOL>input_shape = batch_shape + model.input.shape[<NUM_LIT:1>:].as_list()<EOL>dtype = model.input.dtype.as_numpy_dtype()<EOL>model_dir = self.create_tempdir()<EOL>tfk.experimental.export_saved_model(model, model_dir.full_path)<EOL>model_copy = tfk.experimental.load_from_saved_model(model_dir.full_path)<EOL>x = np.random.uniform(-<NUM_LIT>, <NUM_LIT>, input_shape).astype(dtype)<EOL>self.assertAllEqual(self.evaluate(model(x)), self.evaluate(model_copy(x)))<EOL>self.assertAllEqual(model.predict(x), model_copy.predict(x))<EOL>", "docstring": "Assert a Keras model supports export_saved_model/load_from_saved_model.\n\n        Arguments:\n          model: A Keras model with Tensor output.\n          batch_size: The batch size to use when checking that the model produces\n            the same results as a serialized/deserialized copy.  Default value: 1.", "id": "f15819:c1:m1"}
{"signature": "def assertSerializable(self, model, batch_size=<NUM_LIT:1>):", "body": "batch_shape = [batch_size]<EOL>input_shape = batch_shape + model.input.shape[<NUM_LIT:1>:].as_list()<EOL>dtype = model.input.dtype.as_numpy_dtype()<EOL>model_file = self.create_tempfile()<EOL>model.save(model_file.full_path)<EOL>model_copy = tfk.models.load_model(model_file.full_path)<EOL>x = np.random.uniform(-<NUM_LIT>, <NUM_LIT>, input_shape).astype(dtype)<EOL>model_x_mean = self.evaluate(model(x).mean())<EOL>self.assertAllEqual(model_x_mean, self.evaluate(model_copy(x).mean()))<EOL>output_shape = model_x_mean.shape<EOL>y = np.random.uniform(<NUM_LIT:0.>, <NUM_LIT:1.>, output_shape).astype(dtype)<EOL>self.assertAllEqual(self.evaluate(model(x).log_prob(y)),<EOL>self.evaluate(model_copy(x).log_prob(y)))<EOL>", "docstring": "Assert that a model can be saved/loaded via Keras Model.save/load_model.\n\n        Arguments:\n          model: A Keras model that outputs a `tfd.Distribution`.\n          batch_size: The batch size to use when checking that the model produces\n            the same results as a serialized/deserialized copy.  Default value: 1.", "id": "f15819:c1:m0"}
{"signature": "def get_config(self):", "body": "config = {<EOL>'<STR_LIT>': self.seed,<EOL>}<EOL>base_config = super(DenseFlipout, self).get_config()<EOL>return dict(list(base_config.items()) + list(config.items()))<EOL>", "docstring": "Returns the config of the layer.\n\n        A layer config is a Python dictionary (serializable) containing the\n        configuration of a layer. The same layer can be reinstantiated later\n        (without its trained weights) from this configuration.\n\n        Returns:\n          config: A Python dictionary of class keyword arguments and their\n            serialized values.", "id": "f15822:c3:m2"}
{"signature": "@docstring_util.expand_docstring(args=doc_args)<EOL><INDENT>def __init__(<EOL>self,<EOL>units,<EOL>activation=None,<EOL>activity_regularizer=None,<EOL>kernel_posterior_fn=tfp_layers_util.default_mean_field_normal_fn(),<EOL>kernel_posterior_tensor_fn=lambda d: d.sample(),<EOL>kernel_prior_fn=tfp_layers_util.default_multivariate_normal_fn,<EOL>kernel_divergence_fn=lambda q, p, ignore: tfd.kl_divergence(q, p),<EOL>bias_posterior_fn=tfp_layers_util.default_mean_field_normal_fn(is_singular=True),  <EOL>bias_posterior_tensor_fn=lambda d: d.sample(),<EOL>bias_prior_fn=None,<EOL>bias_divergence_fn=lambda q, p, ignore: tfd.kl_divergence(q, p),<EOL>**kwargs):<EOL><DEDENT>", "body": "<EOL>super(_DenseVariational, self).__init__(<EOL>activity_regularizer=activity_regularizer,<EOL>**kwargs)<EOL>self.units = units<EOL>self.activation = tf.keras.activations.get(activation)<EOL>self.input_spec = tf.keras.layers.InputSpec(min_ndim=<NUM_LIT:2>)<EOL>self.kernel_posterior_fn = kernel_posterior_fn<EOL>self.kernel_posterior_tensor_fn = kernel_posterior_tensor_fn<EOL>self.kernel_prior_fn = kernel_prior_fn<EOL>self.kernel_divergence_fn = kernel_divergence_fn<EOL>self.bias_posterior_fn = bias_posterior_fn<EOL>self.bias_posterior_tensor_fn = bias_posterior_tensor_fn<EOL>self.bias_prior_fn = bias_prior_fn<EOL>self.bias_divergence_fn = bias_divergence_fn<EOL>", "docstring": "Construct layer.\n\n        Args:\n          ${args}", "id": "f15822:c0:m0"}
{"signature": "def get_config(self):", "body": "config = {<EOL>'<STR_LIT>': self.units,<EOL>'<STR_LIT>': (tf.keras.activations.serialize(self.activation)<EOL>if self.activation else None),<EOL>'<STR_LIT>':<EOL>tf.keras.initializers.serialize(self.activity_regularizer),<EOL>}<EOL>function_keys = [<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>]<EOL>for function_key in function_keys:<EOL><INDENT>function = getattr(self, function_key)<EOL>if function is None:<EOL><INDENT>function_name = None<EOL>function_type = None<EOL><DEDENT>else:<EOL><INDENT>function_name, function_type = tfp_layers_util.serialize_function(<EOL>function)<EOL><DEDENT>config[function_key] = function_name<EOL>config[function_key + '<STR_LIT>'] = function_type<EOL><DEDENT>base_config = super(_DenseVariational, self).get_config()<EOL>return dict(list(base_config.items()) + list(config.items()))<EOL>", "docstring": "Returns the config of the layer.\n\n        A layer config is a Python dictionary (serializable) containing the\n        configuration of a layer. The same layer can be reinstantiated later\n        (without its trained weights) from this configuration.\n\n        Returns:\n          config: A Python dictionary of class keyword arguments and their\n            serialized values.", "id": "f15822:c0:m4"}
{"signature": "def fit(<EOL>model_matrix,<EOL>response,<EOL>model,<EOL>model_coefficients_start=None,<EOL>predicted_linear_response_start=None,<EOL>l2_regularizer=None,<EOL>dispersion=None,<EOL>offset=None,<EOL>convergence_criteria_fn=None,<EOL>learning_rate=None,<EOL>fast_unsafe_numerics=True,<EOL>maximum_iterations=None,<EOL>name=None):", "body": "graph_deps = [model_matrix, response, model_coefficients_start,<EOL>predicted_linear_response_start, dispersion, offset,<EOL>learning_rate, maximum_iterations]<EOL>with tf.compat.v1.name_scope(name, '<STR_LIT>', graph_deps):<EOL><INDENT>[<EOL>model_matrix,<EOL>response,<EOL>model_coefficients_start,<EOL>predicted_linear_response_start,<EOL>offset,<EOL>] = prepare_args(<EOL>model_matrix,<EOL>response,<EOL>model_coefficients_start,<EOL>predicted_linear_response_start,<EOL>offset)<EOL>if convergence_criteria_fn is None:<EOL><INDENT>convergence_criteria_fn = (<EOL>convergence_criteria_small_relative_norm_weights_change())<EOL><DEDENT>def _body(<EOL>is_converged_previous,<EOL>iter_,<EOL>model_coefficients_previous,<EOL>predicted_linear_response_previous):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>model_coefficients_next, predicted_linear_response_next = fit_one_step(<EOL>model_matrix,<EOL>response,<EOL>model,<EOL>model_coefficients_previous,<EOL>predicted_linear_response_previous,<EOL>l2_regularizer,<EOL>dispersion,<EOL>offset,<EOL>learning_rate,<EOL>fast_unsafe_numerics)<EOL>is_converged_next = convergence_criteria_fn(<EOL>is_converged_previous=is_converged_previous,<EOL>iter_=iter_,<EOL>model_coefficients_previous=model_coefficients_previous,<EOL>predicted_linear_response_previous=predicted_linear_response_previous,<EOL>model_coefficients_next=model_coefficients_next,<EOL>predicted_linear_response_next=predicted_linear_response_next,<EOL>response=response,<EOL>model=model,<EOL>dispersion=dispersion)<EOL>return [<EOL>is_converged_next,<EOL>iter_ + <NUM_LIT:1>,<EOL>model_coefficients_next,<EOL>predicted_linear_response_next,<EOL>]<EOL><DEDENT>[<EOL>is_converged,<EOL>iter_,<EOL>model_coefficients,<EOL>predicted_linear_response,<EOL>] = tf.while_loop(<EOL>cond=lambda is_converged, *args: tf.logical_not(is_converged),<EOL>body=_body,<EOL>loop_vars=[<EOL>tf.zeros([], np.bool),   <EOL>tf.zeros([], np.int32),  <EOL>model_coefficients_start,<EOL>predicted_linear_response_start,<EOL>],<EOL>maximum_iterations=maximum_iterations)<EOL>return [<EOL>model_coefficients,<EOL>predicted_linear_response,<EOL>is_converged,<EOL>iter_<EOL>]<EOL><DEDENT>", "docstring": "Runs multiple Fisher scoring steps.\n\n    Args:\n      model_matrix: (Batch of) `float`-like, matrix-shaped `Tensor` where each row\n        represents a sample's features.\n      response: (Batch of) vector-shaped `Tensor` where each element represents a\n        sample's observed response (to the corresponding row of features). Must\n        have same `dtype` as `model_matrix`.\n      model: `tfp.glm.ExponentialFamily`-like instance which implicitly\n        characterizes a negative log-likelihood loss by specifying the\n        distribuion's `mean`, `gradient_mean`, and `variance`.\n      model_coefficients_start: Optional (batch of) vector-shaped `Tensor`\n        representing the initial model coefficients, one for each column in\n        `model_matrix`. Must have same `dtype` as `model_matrix`.\n        Default value: Zeros.\n      predicted_linear_response_start: Optional `Tensor` with `shape`, `dtype`\n        matching `response`; represents `offset` shifted initial linear\n        predictions based on `model_coefficients_start`.\n        Default value: `offset` if `model_coefficients is None`, and\n        `tf.linalg.matvec(model_matrix, model_coefficients_start) + offset`\n        otherwise.\n      l2_regularizer: Optional scalar `Tensor` representing L2 regularization\n        penalty, i.e.,\n        `loss(w) = sum{-log p(y[i]|x[i],w) : i=1..n} + l2_regularizer ||w||_2^2`.\n        Default value: `None` (i.e., no L2 regularization).\n      dispersion: Optional (batch of) `Tensor` representing `response` dispersion,\n        i.e., as in, `p(y|theta) := exp((y theta - A(theta)) / dispersion)`.\n        Must broadcast with rows of `model_matrix`.\n        Default value: `None` (i.e., \"no dispersion\").\n      offset: Optional `Tensor` representing constant shift applied to\n        `predicted_linear_response`.  Must broadcast to `response`.\n        Default value: `None` (i.e., `tf.zeros_like(response)`).\n      convergence_criteria_fn: Python `callable` taking:\n        `is_converged_previous`, `iter_`, `model_coefficients_previous`,\n        `predicted_linear_response_previous`, `model_coefficients_next`,\n        `predicted_linear_response_next`, `response`, `model`, `dispersion` and\n        returning a `bool` `Tensor` indicating that Fisher scoring has converged.\n        See `convergence_criteria_small_relative_norm_weights_change` as an\n        example function.\n        Default value: `None` (i.e.,\n        `convergence_criteria_small_relative_norm_weights_change`).\n      learning_rate: Optional (batch of) scalar `Tensor` used to dampen iterative\n        progress. Typically only needed if optimization diverges, should be no\n        larger than `1` and typically very close to `1`.\n        Default value: `None` (i.e., `1`).\n      fast_unsafe_numerics: Optional Python `bool` indicating if faster, less\n        numerically accurate methods can be employed for computing the weighted\n        least-squares solution.\n        Default value: `True` (i.e., \"fast but possibly diminished accuracy\").\n      maximum_iterations: Optional maximum number of iterations of Fisher scoring\n        to run; \"and-ed\" with result of `convergence_criteria_fn`.\n        Default value: `None` (i.e., `infinity`).\n      name: Python `str` used as name prefix to ops created by this function.\n        Default value: `\"fit\"`.\n\n    Returns:\n      model_coefficients: (Batch of) vector-shaped `Tensor`; represents the\n        fitted model coefficients, one for each column in `model_matrix`.\n      predicted_linear_response: `response`-shaped `Tensor` representing linear\n        predictions based on new `model_coefficients`, i.e.,\n        `tf.linalg.matvec(model_matrix, model_coefficients) + offset`.\n      is_converged: `bool` `Tensor` indicating that the returned\n        `model_coefficients` met the `convergence_criteria_fn` criteria within the\n        `maximum_iterations` limit.\n      iter_: `int32` `Tensor` indicating the number of iterations taken.\n\n    #### Example\n\n    ```python\n    from __future__ import print_function\n    import numpy as np\n    import tensorflow as tf\n    import tensorflow_probability as tfp\n    tfd = tfp.distributions\n\n    def make_dataset(n, d, link, scale=1., dtype=np.float32):\n      model_coefficients = tfd.Uniform(\n          low=np.array(-1, dtype),\n          high=np.array(1, dtype)).sample(d, seed=42)\n      radius = np.sqrt(2.)\n      model_coefficients *= radius / tf.linalg.norm(model_coefficients)\n      model_matrix = tfd.Normal(\n          loc=np.array(0, dtype),\n          scale=np.array(1, dtype)).sample([n, d], seed=43)\n      scale = tf.convert_to_tensor(scale, dtype)\n      linear_response = tf.tensordot(\n          model_matrix, model_coefficients, axes=[[1], [0]])\n      if link == 'linear':\n        response = tfd.Normal(loc=linear_response, scale=scale).sample(seed=44)\n      elif link == 'probit':\n        response = tf.cast(\n            tfd.Normal(loc=linear_response, scale=scale).sample(seed=44) > 0,\n            dtype)\n      elif link == 'logit':\n        response = tfd.Bernoulli(logits=linear_response).sample(seed=44)\n      else:\n        raise ValueError('unrecognized true link: {}'.format(link))\n      return model_matrix, response, model_coefficients\n\n    X, Y, w_true = make_dataset(n=int(1e6), d=100, link='probit')\n\n    w, linear_response, is_converged, num_iter = tfp.glm.fit(\n        model_matrix=X,\n        response=Y,\n        model=tfp.glm.BernoulliNormalCDF())\n    log_likelihood = tfp.glm.BernoulliNormalCDF().log_prob(Y, linear_response)\n\n    with tf.Session() as sess:\n      [w_, linear_response_, is_converged_, num_iter_, Y_, w_true_,\n       log_likelihood_] = sess.run([\n          w, linear_response, is_converged, num_iter, Y, w_true,\n          log_likelihood])\n\n    print('is_converged: ', is_converged_)\n    print('    num_iter: ', num_iter_)\n    print('    accuracy: ', np.mean((linear_response_ > 0.) == Y_))\n    print('    deviance: ', 2. * np.mean(log_likelihood_))\n    print('||w0-w1||_2 / (1+||w0||_2): ', (np.linalg.norm(w_true_ - w_, ord=2) /\n                                           (1. + np.linalg.norm(w_true_, ord=2))))\n\n    # ==>\n    # is_converged:  True\n    #     num_iter:  6\n    #     accuracy:  0.804382\n    #     deviance:  -0.820746600628\n    # ||w0-w1||_2 / (1+||w0||_2):  0.00619245105309\n    ```", "id": "f15831:m0"}
{"signature": "def _log_prob(self, response, predicted_linear_response):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Implements the log-probability computation.", "id": "f15833:c0:m5"}
{"signature": "def log_prob(self, response, predicted_linear_response, name=None):", "body": "with self._name_scope(<EOL>name, '<STR_LIT>', [response, predicted_linear_response]):<EOL><INDENT>dtype = dtype_util.common_dtype([response, predicted_linear_response])<EOL>response = tf.convert_to_tensor(<EOL>value=response, dtype=dtype, name='<STR_LIT>')<EOL>predicted_linear_response = tf.convert_to_tensor(<EOL>value=predicted_linear_response, name='<STR_LIT>')<EOL>return self._log_prob(response, predicted_linear_response)<EOL><DEDENT>", "docstring": "Computes `D(param=mean(r)).log_prob(response)` for linear response, `r`.\n\n        Args:\n          response: `float`-like `Tensor` representing observed (\"actual\")\n            responses.\n          predicted_linear_response: `float`-like `Tensor` corresponding to\n            `tf.matmul(model_matrix, weights)`.\n          name: Python `str` used as TF namescope for ops created by member\n            functions. Default value: `None` (i.e., 'log_prob').\n\n        Returns:\n          log_prob: `Tensor` with shape and dtype of `predicted_linear_response`\n            representing the distribution prescribed log-probability of the observed\n            `response`s.", "id": "f15833:c0:m6"}
{"signature": "def tril_with_diag_softplus_and_shift(x, diag_shift=<NUM_LIT>, name=None):", "body": "with tf.compat.v1.name_scope(name, '<STR_LIT>',<EOL>[x, diag_shift]):<EOL><INDENT>x = tf.convert_to_tensor(value=x, name='<STR_LIT:x>')<EOL>x = tfd.fill_triangular(x)<EOL>diag = softplus_and_shift(tf.linalg.diag_part(x), diag_shift)<EOL>x = tf.linalg.set_diag(x, diag)<EOL>return x<EOL><DEDENT>", "docstring": "Converts (batch of) vectors to (batch of) lower-triangular scale matrices.\n\n    Args:\n      x: (Batch of) `float`-like `Tensor` representing vectors which will be\n        transformed into lower-triangular scale matrices with positive diagonal\n        elements. Rightmost shape `n` must be such that\n        `n = dims * (dims + 1) / 2` for some positive, integer `dims`.\n      diag_shift: `Tensor` added to `softplus` transformation of diagonal\n        elements.\n        Default value: `1e-5`.\n      name: A `name_scope` name for operations created by this function.\n        Default value: `None` (i.e., \"tril_with_diag_softplus_and_shift\").\n\n    Returns:\n      scale_tril: (Batch of) lower-triangular `Tensor` with `x.dtype` and\n        rightmost shape `[dims, dims]` where `n = dims * (dims + 1) / 2` where\n        `n = x.shape[-1]`.", "id": "f15838:m1"}
{"signature": "def normal(x,<EOL>layer_fn=tf.compat.v1.layers.dense,<EOL>loc_fn=lambda x: x,<EOL>scale_fn=<NUM_LIT:1.>,<EOL>name=None):", "body": "with tf.compat.v1.name_scope(name, '<STR_LIT>', [x]):<EOL><INDENT>x = tf.convert_to_tensor(value=x, name='<STR_LIT:x>')<EOL>if callable(scale_fn):<EOL><INDENT>y = layer_fn(x, <NUM_LIT:2>)<EOL>loc = loc_fn(y[..., <NUM_LIT:0>])<EOL>scale = scale_fn(y[..., <NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>y = tf.squeeze(layer_fn(x, <NUM_LIT:1>), axis=-<NUM_LIT:1>)<EOL>loc = loc_fn(y)<EOL>scale = tf.cast(scale_fn, loc.dtype.base_dtype)<EOL><DEDENT>return tfd.Normal(loc=loc, scale=scale)<EOL><DEDENT>", "docstring": "Constructs a trainable `tfd.Normal` distribution.\n\n\n    This function creates a Normal distribution parameterized by loc and scale.\n    Using default args, this function is mathematically equivalent to:\n\n    ```none\n    Y = Normal(loc=matmul(W, x) + b, scale=1)\n\n    where,\n      W in R^[d, n]\n      b in R^d\n    ```\n\n    #### Examples\n\n    This function can be used as a [linear regression](\n    https://en.wikipedia.org/wiki/Linear_regression) loss.\n\n    ```python\n    # This example fits a linear regression loss.\n    import tensorflow as tf\n    import tensorflow_probability as tfp\n\n    # Create fictitious training data.\n    dtype = np.float32\n    n = 3000    # number of samples\n    x_size = 4  # size of single x\n    def make_training_data():\n      np.random.seed(142)\n      x = np.random.randn(n, x_size).astype(dtype)\n      w = np.random.randn(x_size).astype(dtype)\n      b = np.random.randn(1).astype(dtype)\n      true_mean = np.tensordot(x, w, axes=[[-1], [-1]]) + b\n      noise = np.random.randn(n).astype(dtype)\n      y = true_mean + noise\n      return y, x\n    y, x = make_training_data()\n\n    # Build TF graph for fitting Normal maximum likelihood estimator.\n    normal = tfp.trainable_distributions.normal(x)\n    loss = -tf.reduce_mean(normal.log_prob(y))\n    train_op = tf.train.AdamOptimizer(learning_rate=2.**-5).minimize(loss)\n    mse = tf.reduce_mean(tf.squared_difference(y, normal.mean()))\n    init_op = tf.global_variables_initializer()\n\n    # Run graph 1000 times.\n    num_steps = 1000\n    loss_ = np.zeros(num_steps)   # Style: `_` to indicate sess.run result.\n    mse_ = np.zeros(num_steps)\n    with tf.Session() as sess:\n      sess.run(init_op)\n      for it in xrange(loss_.size):\n        _, loss_[it], mse_[it] = sess.run([train_op, loss, mse])\n        if it % 200 == 0 or it == loss_.size - 1:\n          print(\"iteration:{}  loss:{}  mse:{}\".format(it, loss_[it], mse_[it]))\n\n    # ==> iteration:0    loss:6.34114170074  mse:10.8444051743\n    #     iteration:200  loss:1.40146839619  mse:0.965059816837\n    #     iteration:400  loss:1.40052902699  mse:0.963181257248\n    #     iteration:600  loss:1.40052902699  mse:0.963181257248\n    #     iteration:800  loss:1.40052902699  mse:0.963181257248\n    #     iteration:999  loss:1.40052902699  mse:0.963181257248\n    ```\n\n    Args:\n      x: `Tensor` with floating type. Must have statically defined rank and\n        statically known right-most dimension.\n      layer_fn: Python `callable` which takes input `x` and `int` scalar `d` and\n        returns a transformation of `x` with shape\n        `tf.concat([tf.shape(x)[:-1], [1]], axis=0)`.\n        Default value: `tf.layers.dense`.\n      loc_fn: Python `callable` which transforms the `loc` parameter. Takes a\n        (batch of) length-`dims` vectors and returns a `Tensor` of same shape and\n        `dtype`.\n        Default value: `lambda x: x`.\n      scale_fn: Python `callable` or `Tensor`. If a `callable` transforms the\n        `scale` parameters; if `Tensor` is the `tfd.Normal` `scale` argument.\n        Takes a (batch of) length-`dims` vectors and returns a `Tensor` of same\n        size. (Taking a `callable` or `Tensor` is how `tf.Variable` intializers\n        behave.)\n        Default value: `1`.\n      name: A `name_scope` name for operations created by this function.\n        Default value: `None` (i.e., \"normal\").\n\n    Returns:\n      normal: An instance of `tfd.Normal`.", "id": "f15838:m4"}
{"signature": "def bernoulli(x, layer_fn=tf.compat.v1.layers.dense, name=None):", "body": "with tf.compat.v1.name_scope(name, '<STR_LIT>', [x]):<EOL><INDENT>x = tf.convert_to_tensor(value=x, name='<STR_LIT:x>')<EOL>logits = tf.squeeze(layer_fn(x, <NUM_LIT:1>), axis=-<NUM_LIT:1>)<EOL>return tfd.Bernoulli(logits=logits)<EOL><DEDENT>", "docstring": "Constructs a trainable `tfd.Bernoulli` distribution.\n\n    This function creates a Bernoulli distribution parameterized by logits.\n    Using default args, this function is mathematically equivalent to:\n\n    ```none\n    Y = Bernoulli(logits=matmul(W, x) + b)\n\n    where,\n      W in R^[d, n]\n      b in R^d\n    ```\n\n    #### Examples\n\n    This function can be used as a [logistic regression](\n    https://en.wikipedia.org/wiki/Logistic_regression) loss.\n\n    ```python\n    # This example fits a logistic regression loss.\n    import tensorflow as tf\n    import tensorflow_probability as tfp\n\n    # Create fictitious training data.\n    dtype = np.float32\n    n = 3000    # number of samples\n    x_size = 4  # size of single x\n    def make_training_data():\n      np.random.seed(142)\n      x = np.random.randn(n, x_size).astype(dtype)\n      w = np.random.randn(x_size).astype(dtype)\n      b = np.random.randn(1).astype(dtype)\n      true_logits = np.tensordot(x, w, axes=[[-1], [-1]]) + b\n      noise = np.random.logistic(size=n).astype(dtype)\n      y = dtype(true_logits + noise > 0.)\n      return y, x\n    y, x = make_training_data()\n\n    # Build TF graph for fitting Bernoulli maximum likelihood estimator.\n    bernoulli = tfp.trainable_distributions.bernoulli(x)\n    loss = -tf.reduce_mean(bernoulli.log_prob(y))\n    train_op = tf.train.AdamOptimizer(learning_rate=2.**-5).minimize(loss)\n    mse = tf.reduce_mean(tf.squared_difference(y, bernoulli.mean()))\n    init_op = tf.global_variables_initializer()\n\n    # Run graph 1000 times.\n    num_steps = 1000\n    loss_ = np.zeros(num_steps)   # Style: `_` to indicate sess.run result.\n    mse_ = np.zeros(num_steps)\n    with tf.Session() as sess:\n      sess.run(init_op)\n      for it in xrange(loss_.size):\n        _, loss_[it], mse_[it] = sess.run([train_op, loss, mse])\n        if it % 200 == 0 or it == loss_.size - 1:\n          print(\"iteration:{}  loss:{}  mse:{}\".format(it, loss_[it], mse_[it]))\n\n    # ==> iteration:0    loss:0.635675370693  mse:0.222526371479\n    #     iteration:200  loss:0.440077394247  mse:0.143687799573\n    #     iteration:400  loss:0.440077394247  mse:0.143687844276\n    #     iteration:600  loss:0.440077394247  mse:0.143687844276\n    #     iteration:800  loss:0.440077424049  mse:0.143687844276\n    #     iteration:999  loss:0.440077424049  mse:0.143687844276\n    ```\n\n    Args:\n      x: `Tensor` with floating type. Must have statically defined rank and\n        statically known right-most dimension.\n      layer_fn: Python `callable` which takes input `x` and `int` scalar `d` and\n        returns a transformation of `x` with shape\n        `tf.concat([tf.shape(x)[:-1], [1]], axis=0)`.\n        Default value: `tf.layers.dense`.\n      name: A `name_scope` name for operations created by this function.\n        Default value: `None` (i.e., \"bernoulli\").\n\n    Returns:\n      bernoulli: An instance of `tfd.Bernoulli`.", "id": "f15838:m3"}
{"signature": "def _maybe_validate_matrix(a, validate_args):", "body": "assertions = []<EOL>if not a.dtype.is_floating:<EOL><INDENT>raise TypeError('<STR_LIT>'<EOL>'<STR_LIT>'.format(a.dtype.name))<EOL><DEDENT>if a.shape.ndims is not None:<EOL><INDENT>if a.shape.ndims < <NUM_LIT:2>:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>'.format(a.shape.ndims))<EOL><DEDENT><DEDENT>elif validate_args:<EOL><INDENT>assertions.append(tf.compat.v1.assert_rank_at_least(<EOL>a, rank=<NUM_LIT:2>, message='<STR_LIT>'))<EOL><DEDENT>return assertions<EOL>", "docstring": "Checks that input is a `float` matrix.", "id": "f15841:m16"}
{"signature": "def _swap_m_with_i(vecs, m, i):", "body": "vecs = tf.convert_to_tensor(value=vecs, dtype=tf.int64, name='<STR_LIT>')<EOL>m = tf.convert_to_tensor(value=m, dtype=tf.int64, name='<STR_LIT:m>')<EOL>i = tf.convert_to_tensor(value=i, dtype=tf.int64, name='<STR_LIT:i>')<EOL>trailing_elts = tf.broadcast_to(<EOL>tf.range(m + <NUM_LIT:1>,<EOL>prefer_static.shape(vecs, out_type=tf.int64)[-<NUM_LIT:1>]),<EOL>prefer_static.shape(vecs[..., m + <NUM_LIT:1>:]))<EOL>shp = prefer_static.shape(trailing_elts)<EOL>trailing_elts = tf.where(<EOL>tf.equal(trailing_elts, tf.broadcast_to(i, shp)),<EOL>tf.broadcast_to(tf.gather(vecs, [m], axis=-<NUM_LIT:1>), shp),<EOL>tf.broadcast_to(vecs[..., m + <NUM_LIT:1>:], shp))<EOL>vecs_shape = vecs.shape<EOL>vecs = tf.concat([<EOL>vecs[..., :m],<EOL>tf.gather(vecs, i, batch_dims=prefer_static.rank(vecs) - <NUM_LIT:1>), trailing_elts<EOL>], axis=-<NUM_LIT:1>)<EOL>tensorshape_util.set_shape(vecs, vecs_shape)<EOL>return vecs<EOL>", "docstring": "Swaps `m` and `i` on axis -1. (Helper for pivoted_cholesky.)\n\n    Given a batch of int64 vectors `vecs`, scalar index `m`, and compatibly shaped\n    per-vector indices `i`, this function swaps elements `m` and `i` in each\n    vector. For the use-case below, these are permutation vectors.\n\n    Args:\n      vecs: Vectors on which we perform the swap, int64 `Tensor`.\n      m: Scalar int64 `Tensor`, the index into which the `i`th element is going.\n      i: Batch int64 `Tensor`, shaped like vecs.shape[:-1] + [1]; the index into\n        which the `m`th element is going.\n\n    Returns:\n      vecs: The updated vectors.", "id": "f15841:m2"}
{"signature": "def pivoted_cholesky(matrix, max_rank, diag_rtol=<NUM_LIT>, name=None):", "body": "with tf.compat.v2.name_scope(name or '<STR_LIT>'):<EOL><INDENT>dtype = dtype_util.common_dtype([matrix, diag_rtol],<EOL>preferred_dtype=tf.float32)<EOL>matrix = tf.convert_to_tensor(value=matrix, name='<STR_LIT>', dtype=dtype)<EOL>if tensorshape_util.rank(matrix.shape) is None:<EOL><INDENT>raise NotImplementedError('<STR_LIT>')<EOL><DEDENT>max_rank = tf.convert_to_tensor(<EOL>value=max_rank, name='<STR_LIT>', dtype=tf.int64)<EOL>max_rank = tf.minimum(max_rank,<EOL>prefer_static.shape(matrix, out_type=tf.int64)[-<NUM_LIT:1>])<EOL>diag_rtol = tf.convert_to_tensor(<EOL>value=diag_rtol, dtype=dtype, name='<STR_LIT>')<EOL>matrix_diag = tf.linalg.diag_part(matrix)<EOL>orig_error = tf.reduce_max(input_tensor=matrix_diag, axis=-<NUM_LIT:1>)<EOL>def cond(m, pchol, perm, matrix_diag):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>del pchol<EOL>del perm<EOL>error = tf.linalg.norm(tensor=matrix_diag, ord=<NUM_LIT:1>, axis=-<NUM_LIT:1>)<EOL>max_err = tf.reduce_max(input_tensor=error / orig_error)<EOL>return (m < max_rank) & (tf.equal(m, <NUM_LIT:0>) | (max_err > diag_rtol))<EOL><DEDENT>batch_dims = tensorshape_util.rank(matrix.shape) - <NUM_LIT:2><EOL>def batch_gather(params, indices, axis=-<NUM_LIT:1>):<EOL><INDENT>return tf.gather(params, indices, axis=axis, batch_dims=batch_dims)<EOL><DEDENT>def body(m, pchol, perm, matrix_diag):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>permuted_diag = batch_gather(matrix_diag, perm[..., m:])<EOL>maxi = tf.argmax(<EOL>input=permuted_diag, axis=-<NUM_LIT:1>, output_type=tf.int64)[..., tf.newaxis]<EOL>maxval = batch_gather(permuted_diag, maxi)<EOL>maxi = maxi + m<EOL>maxval = maxval[..., <NUM_LIT:0>]<EOL>perm = _swap_m_with_i(perm, m, maxi)<EOL>row = batch_gather(matrix, perm[..., m:m + <NUM_LIT:1>], axis=-<NUM_LIT:2>)<EOL>row = batch_gather(row, perm[..., m + <NUM_LIT:1>:])<EOL>prev_rows = pchol[..., :m, :]<EOL>prev_rows_perm_m_onward = batch_gather(prev_rows, perm[..., m + <NUM_LIT:1>:])<EOL>prev_rows_pivot_col = batch_gather(prev_rows, perm[..., m:m + <NUM_LIT:1>])<EOL>row -= tf.reduce_sum(<EOL>input_tensor=prev_rows_perm_m_onward * prev_rows_pivot_col,<EOL>axis=-<NUM_LIT:2>)[..., tf.newaxis, :]<EOL>pivot = tf.sqrt(maxval)[..., tf.newaxis, tf.newaxis]<EOL>row = tf.concat([pivot, row / pivot], axis=-<NUM_LIT:1>)<EOL>paddings = tf.concat([<EOL>tf.zeros([prefer_static.rank(pchol) - <NUM_LIT:1>, <NUM_LIT:2>], dtype=tf.int32),<EOL>[[tf.cast(m, tf.int32), <NUM_LIT:0>]]], axis=<NUM_LIT:0>)<EOL>diag_update = tf.pad(tensor=row**<NUM_LIT:2>, paddings=paddings)[..., <NUM_LIT:0>, :]<EOL>reverse_perm = _invert_permutation(perm)<EOL>matrix_diag -= batch_gather(diag_update, reverse_perm)<EOL>row = tf.pad(tensor=row, paddings=paddings)<EOL>row = batch_gather(row, reverse_perm)<EOL>pchol_shape = pchol.shape<EOL>pchol = tf.concat([pchol[..., :m, :], row, pchol[..., m + <NUM_LIT:1>:, :]],<EOL>axis=-<NUM_LIT:2>)<EOL>tensorshape_util.set_shape(pchol, pchol_shape)<EOL>return m + <NUM_LIT:1>, pchol, perm, matrix_diag<EOL><DEDENT>m = np.int64(<NUM_LIT:0>)<EOL>pchol = tf.zeros_like(matrix[..., :max_rank, :])<EOL>matrix_shape = prefer_static.shape(matrix, out_type=tf.int64)<EOL>perm = tf.broadcast_to(<EOL>prefer_static.range(matrix_shape[-<NUM_LIT:1>]), matrix_shape[:-<NUM_LIT:1>])<EOL>_, pchol, _, _ = tf.while_loop(<EOL>cond=cond, body=body, loop_vars=(m, pchol, perm, matrix_diag))<EOL>pchol = tf.linalg.matrix_transpose(pchol)<EOL>tensorshape_util.set_shape(<EOL>pchol, tensorshape_util.concatenate(matrix_diag.shape, [None]))<EOL>return pchol<EOL><DEDENT>", "docstring": "Computes the (partial) pivoted cholesky decomposition of `matrix`.\n\n    The pivoted Cholesky is a low rank approximation of the Cholesky decomposition\n    of `matrix`, i.e. as described in [(Harbrecht et al., 2012)][1]. The\n    currently-worst-approximated diagonal element is selected as the pivot at each\n    iteration. This yields from a `[B1...Bn, N, N]` shaped `matrix` a `[B1...Bn,\n    N, K]` shaped rank-`K` approximation `lr` such that `lr @ lr.T ~= matrix`.\n    Note that, unlike the Cholesky decomposition, `lr` is not triangular even in\n    a rectangular-matrix sense. However, under a permutation it could be made\n    triangular (it has one more zero in each column as you move to the right).\n\n    Such a matrix can be useful as a preconditioner for conjugate gradient\n    optimization, i.e. as in [(Wang et al. 2019)][2], as matmuls and solves can be\n    cheaply done via the Woodbury matrix identity, as implemented by\n    `tf.linalg.LinearOperatorLowRankUpdate`.\n\n    Args:\n      matrix: Floating point `Tensor` batch of symmetric, positive definite\n        matrices.\n      max_rank: Scalar `int` `Tensor`, the rank at which to truncate the\n        approximation.\n      diag_rtol: Scalar floating point `Tensor` (same dtype as `matrix`). If the\n        errors of all diagonal elements of `lr @ lr.T` are each lower than\n        `element * diag_rtol`, iteration is permitted to terminate early.\n      name: Optional name for the op.\n\n    Returns:\n      lr: Low rank pivoted Cholesky approximation of `matrix`.\n\n    #### References\n\n    [1]: H Harbrecht, M Peters, R Schneider. On the low-rank approximation by the\n         pivoted Cholesky decomposition. _Applied numerical mathematics_,\n         62(4):428-440, 2012.\n\n    [2]: K. A. Wang et al. Exact Gaussian Processes on a Million Data Points.\n         _arXiv preprint arXiv:1903.08114_, 2019. https://arxiv.org/abs/1903.08114", "id": "f15841:m4"}
{"signature": "def sparse_or_dense_matvecmul(sparse_or_dense_matrix,<EOL>dense_vector,<EOL>validate_args=False,<EOL>name=None,<EOL>**kwargs):", "body": "with tf.compat.v1.name_scope(name, '<STR_LIT>',<EOL>[sparse_or_dense_matrix, dense_vector]):<EOL><INDENT>dense_vector = tf.convert_to_tensor(<EOL>value=dense_vector, dtype_hint=tf.float32, name='<STR_LIT>')<EOL>return tf.squeeze(<EOL>sparse_or_dense_matmul(<EOL>sparse_or_dense_matrix,<EOL>dense_vector[..., tf.newaxis],<EOL>validate_args=validate_args,<EOL>**kwargs),<EOL>axis=[-<NUM_LIT:1>])<EOL><DEDENT>", "docstring": "Returns (batched) matmul of a (sparse) matrix with a column vector.\n\n    Args:\n      sparse_or_dense_matrix: `SparseTensor` or `Tensor` representing a (batch of)\n        matrices.\n      dense_vector: `Tensor` representing a (batch of) vectors, with the same\n        batch shape as `sparse_or_dense_matrix`. The shape must be compatible with\n        the shape of `sparse_or_dense_matrix` and kwargs.\n      validate_args: When `True`, additional assertions might be embedded in the\n        graph.\n        Default value: `False` (i.e., no graph assertions are added).\n      name: Python `str` prefixed to ops created by this function.\n        Default value: \"sparse_or_dense_matvecmul\".\n      **kwargs: Keyword arguments to `tf.sparse_tensor_dense_matmul` or\n        `tf.matmul`.\n\n    Returns:\n      product: A dense (batch of) vector-shaped Tensor of the same batch shape and\n      dtype as `sparse_or_dense_matrix` and `dense_vector`.", "id": "f15841:m12"}
{"signature": "def _lu_solve_assertions(lower_upper, perm, rhs, validate_args):", "body": "assertions = _lu_reconstruct_assertions(lower_upper, perm, validate_args)<EOL>message = '<STR_LIT>'<EOL>if rhs.shape.ndims is not None:<EOL><INDENT>if rhs.shape.ndims < <NUM_LIT:2>:<EOL><INDENT>raise ValueError(message)<EOL><DEDENT><DEDENT>elif validate_args:<EOL><INDENT>assertions.append(<EOL>tf.compat.v1.assert_rank_at_least(rhs, rank=<NUM_LIT:2>, message=message))<EOL><DEDENT>message = '<STR_LIT>'<EOL>if (tf.compat.dimension_value(lower_upper.shape[-<NUM_LIT:1>]) is not None and<EOL>tf.compat.dimension_value(rhs.shape[-<NUM_LIT:2>]) is not None):<EOL><INDENT>if lower_upper.shape[-<NUM_LIT:1>] != rhs.shape[-<NUM_LIT:2>]:<EOL><INDENT>raise ValueError(message)<EOL><DEDENT><DEDENT>elif validate_args:<EOL><INDENT>assertions.append(<EOL>tf.compat.v1.assert_equal(<EOL>tf.shape(input=lower_upper)[-<NUM_LIT:1>],<EOL>tf.shape(input=rhs)[-<NUM_LIT:2>],<EOL>message=message))<EOL><DEDENT>return assertions<EOL>", "docstring": "Returns list of assertions related to `lu_solve` assumptions.", "id": "f15841:m10"}
{"signature": "def _sparse_block_diag(sp_a):", "body": "<EOL>sp_a_shape = tf.convert_to_tensor(value=_get_shape(sp_a, tf.int64))<EOL>ind_mat = tf.concat([[sp_a_shape[-<NUM_LIT:2>:]], tf.eye(<NUM_LIT:2>, dtype=tf.int64)], axis=<NUM_LIT:0>)<EOL>indices = tf.matmul(sp_a.indices, ind_mat)<EOL>dense_shape = sp_a_shape[<NUM_LIT:0>] * sp_a_shape[<NUM_LIT:1>:]<EOL>return tf.SparseTensor(<EOL>indices=indices, values=sp_a.values, dense_shape=dense_shape)<EOL>", "docstring": "Returns a block diagonal rank 2 SparseTensor from a batch of SparseTensors.\n\n    Args:\n      sp_a: A rank 3 `SparseTensor` representing a batch of matrices.\n\n    Returns:\n      sp_block_diag_a: matrix-shaped, `float` `SparseTensor` with the same dtype\n      as `sparse_or_matrix`, of shape [B * M, B * N] where `sp_a` has shape\n      [B, M, N]. Each [M, N] batch of `sp_a` is lined up along the diagonal.", "id": "f15841:m15"}
{"signature": "def _assert_ndims_statically(x,<EOL>expect_ndims=None,<EOL>expect_ndims_at_least=None,<EOL>expect_static=False):", "body": "ndims = x.shape.ndims<EOL>if ndims is None:<EOL><INDENT>if expect_static:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(x))<EOL><DEDENT>return<EOL><DEDENT>if expect_ndims is not None and ndims != expect_ndims:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(expect_ndims, ndims))<EOL><DEDENT>if expect_ndims_at_least is not None and ndims < expect_ndims_at_least:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(<EOL>expect_ndims_at_least, ndims))<EOL><DEDENT>", "docstring": "Assert that Tensor x has expected number of dimensions.", "id": "f15848:m5"}
{"signature": "def batch_interp_regular_1d_grid(x,<EOL>x_ref_min,<EOL>x_ref_max,<EOL>y_ref,<EOL>axis=-<NUM_LIT:1>,<EOL>fill_value='<STR_LIT>',<EOL>fill_value_below=None,<EOL>fill_value_above=None,<EOL>grid_regularizing_transform=None,<EOL>name=None):", "body": "return _interp_regular_1d_grid_impl(<EOL>x,<EOL>x_ref_min,<EOL>x_ref_max,<EOL>y_ref,<EOL>axis=axis,<EOL>batch_y_ref=True,<EOL>fill_value=fill_value,<EOL>fill_value_below=fill_value_below,<EOL>fill_value_above=fill_value_above,<EOL>grid_regularizing_transform=grid_regularizing_transform,<EOL>name=name or '<STR_LIT>')<EOL>", "docstring": "Linear `1-D` interpolation on a regular (constant spacing) grid.\n\n    Given [batch of] reference values, this function computes a piecewise linear\n    interpolant and evaluates it on a [batch of] of new `x` values.\n\n    The interpolant is built from `C` reference values indexed by one dimension\n    of `y_ref` (specified by the `axis` kwarg).\n\n    If `y_ref` is a vector, then each value `y_ref[i]` is considered to be equal\n    to `f(x_ref[i])`, for `C` (implicitly defined) reference values between\n    `x_ref_min` and `x_ref_max`:\n\n    ```none\n    x_ref[i] = x_ref_min + i * (x_ref_max - x_ref_min) / (C - 1),\n    i = 0, ..., C - 1.\n    ```\n\n    In the general case, dimensions to the left of `axis` in `y_ref` are broadcast\n    with leading dimensions in `x`, `x_ref_min`, `x_ref_max`.\n\n    Args:\n      x: Numeric `Tensor` The x-coordinates of the interpolated output values for\n        each batch.  Shape broadcasts with `[A1, ..., AN, D]`, `N >= 0`.\n      x_ref_min:  `Tensor` of same `dtype` as `x`.  The minimum value of the each\n        batch of the (implicitly defined) reference `x_ref`. Shape broadcasts with\n        `[A1, ..., AN]`, `N >= 0`.\n      x_ref_max:  `Tensor` of same `dtype` as `x`.  The maximum value of the each\n        batch of the (implicitly defined) reference `x_ref`. Shape broadcasts with\n        `[A1, ..., AN]`, `N >= 0`.\n      y_ref:  `Tensor` of same `dtype` as `x`.  The reference output values.\n        `y_ref.shape[:axis]` broadcasts with the batch shape `[A1, ..., AN]`, and\n        `y_ref.shape[axis:]` is `[C, B1, ..., BM]`, so the trailing dimensions\n          index `C` reference values of a rank `M` `Tensor` (`M >= 0`).\n      axis:  Scalar `Tensor` designating the dimension of `y_ref` that indexes\n        values of the interpolation table.\n        Default value: `-1`, the rightmost axis.\n      fill_value:  Determines what values output should take for `x` values that\n        are below `x_ref_min` or above `x_ref_max`. `Tensor` or one of the strings\n        \"constant_extension\" ==> Extend as constant function. \"extrapolate\" ==>\n        Extrapolate in a linear fashion.\n        Default value: `\"constant_extension\"`\n      fill_value_below:  Optional override of `fill_value` for `x < x_ref_min`.\n      fill_value_above:  Optional override of `fill_value` for `x > x_ref_max`.\n      grid_regularizing_transform:  Optional transformation `g` which regularizes\n        the implied spacing of the x reference points.  In other words, if\n        provided, we assume `g(x_ref_i)` is a regular grid between `g(x_ref_min)`\n        and `g(x_ref_max)`.\n      name:  A name to prepend to created ops.\n        Default value: `\"batch_interp_regular_1d_grid\"`.\n\n    Returns:\n      y_interp:  Interpolation between members of `y_ref`, at points `x`.\n        `Tensor` of same `dtype` as `x`, and shape `[A1, ..., AN, D, B1, ..., BM]`\n\n    Raises:\n      ValueError:  If `fill_value` is not an allowed string.\n      ValueError:  If `axis` is not a scalar.\n\n    #### Examples\n\n    Interpolate a function of one variable:\n\n    ```python\n    y_ref = tf.exp(tf.linspace(start=0., stop=10., 20))\n\n    batch_interp_regular_1d_grid(\n        x=[6.0, 0.5, 3.3], x_ref_min=0., x_ref_max=1., y_ref=y_ref)\n    ==> approx [exp(6.0), exp(0.5), exp(3.3)]\n    ```\n\n    Interpolate a batch of functions of one variable.\n\n    ```python\n    # First batch member is an exponential function, second is a log.\n    implied_x_ref = [tf.linspace(-3., 3.2, 200), tf.linspace(0.5, 3., 200)]\n    y_ref = tf.stack(  # Shape [2, 200], 2 batches, 200 reference values per batch\n        [tf.exp(implied_x_ref[0]), tf.log(implied_x_ref[1])], axis=0)\n\n    x = [[-1., 1., 0.],  # Shape [2, 3], 2 batches, 3 values per batch.\n         [1., 2., 3.]]\n\n    y = tfp.math.batch_interp_regular_1d_grid(  # Shape [2, 3]\n        x,\n        x_ref_min=[-3., 0.5],\n        x_ref_max=[3.2, 3.],\n        y_ref=y_ref,\n        axis=-1)\n\n    # y[0] approx tf.exp(x[0])\n    # y[1] approx tf.log(x[1])\n    ```\n\n    Interpolate a function of one variable on a log-spaced grid:\n\n    ```python\n    x_ref = tf.exp(tf.linspace(tf.log(1.), tf.log(100000.), num_pts))\n    y_ref = tf.log(x_ref + x_ref**2)\n\n    batch_interp_regular_1d_grid(x=[1.1, 2.2], x_ref_min=1., x_ref_max=100000.,\n        y_ref, grid_regularizing_transform=tf.log)\n    ==> [tf.log(1.1 + 1.1**2), tf.log(2.2 + 2.2**2)]\n    ```", "id": "f15848:m2"}
{"signature": "def random_rademacher(shape, dtype=tf.float32, seed=None, name=None):", "body": "with tf.compat.v1.name_scope(name, '<STR_LIT>', [shape, seed]):<EOL><INDENT>generation_dtype = tf.int64 if tf.as_dtype(dtype) != tf.int32 else tf.int32<EOL>random_bernoulli = tf.random.uniform(<EOL>shape, minval=<NUM_LIT:0>, maxval=<NUM_LIT:2>, dtype=generation_dtype, seed=seed)<EOL>return tf.cast(<NUM_LIT:2> * random_bernoulli - <NUM_LIT:1>, dtype)<EOL><DEDENT>", "docstring": "Generates `Tensor` consisting of `-1` or `+1`, chosen uniformly at random.\n\n    For more details, see [Rademacher distribution](\n    https://en.wikipedia.org/wiki/Rademacher_distribution).\n\n    Args:\n      shape: Vector-shaped, `int` `Tensor` representing shape of output.\n      dtype: (Optional) TF `dtype` representing `dtype` of output.\n      seed: (Optional) Python integer to seed the random number generator.\n      name: Python `str` name prefixed to Ops created by this function.\n        Default value: `None` (i.e., 'random_rademacher').\n\n    Returns:\n      rademacher: `Tensor` with specified `shape` and `dtype` consisting of `-1`\n        or `+1` chosen uniformly-at-random.", "id": "f15850:m0"}
{"signature": "def value_and_gradient(f, xs, use_gradient_tape=False, name=None):", "body": "with tf.compat.v1.name_scope(name, '<STR_LIT>', [xs]):<EOL><INDENT>is_xs_list_like = isinstance(xs, (tuple, list))<EOL>if not is_xs_list_like:<EOL><INDENT>xs = [xs]<EOL><DEDENT>xs = [tf.convert_to_tensor(value=x, name='<STR_LIT>'.format(i))<EOL>for i, x in enumerate(xs)]<EOL>if tf.executing_eagerly() or use_gradient_tape:<EOL><INDENT>with tf.GradientTape(watch_accessed_variables=False) as tape:<EOL><INDENT>for x in xs:<EOL><INDENT>tape.watch(x)<EOL><DEDENT>y = f(*xs)<EOL><DEDENT>dydx = tape.gradient(y, xs)<EOL><DEDENT>else:<EOL><INDENT>y = f(*xs)<EOL>dydx = tf.gradients(ys=y, xs=xs)<EOL><DEDENT>if not is_xs_list_like:<EOL><INDENT>dydx = dydx[<NUM_LIT:0>]<EOL><DEDENT>return y, dydx<EOL><DEDENT>", "docstring": "Computes `f(*xs)` and its gradients wrt to `*xs`.\n\n    Args:\n      f: Python `callable` to be differentiated. If `f` returns a scalar, this\n        scalar will be differentiated. If `f` returns a tensor or list of tensors,\n        by default a scalar will be computed by adding all their values to produce\n        a single scalar. If desired, the tensors can be elementwise multiplied by\n        the tensors passed as the `dy` keyword argument to the returned gradient\n        function.\n      xs: Python list of parameters of f for which to differentiate. (Can also\n        be single `Tensor`.)\n      use_gradient_tape: Python `bool` indicating that `tf.GradientTape`\n        should be used regardless of `tf.executing_eagerly()` status.\n        Default value: `False`.\n      name: Python `str` name prefixed to ops created by this function.\n        Default value: `None` (i.e., `'value_and_gradient'`).\n\n    Returns:\n      y: `y = f(*xs)`.\n      dydx: Gradient of `y` wrt each of `xs`.", "id": "f15855:m0"}
{"signature": "@abc.abstractmethod<EOL><INDENT>def solve(<EOL>self,<EOL>ode_fn,<EOL>initial_state,<EOL>initial_time=<NUM_LIT:0.>,<EOL>final_time=None,<EOL>solution_times=None,<EOL>jacobian_fn=None,<EOL>jacobian_sparsity=None,<EOL>batch_ndims=None,<EOL>previous_results=None,<EOL>):<DEDENT>", "body": "", "docstring": "Solves an initial value problem.\n\n        An initial value problem consists of a system of ODEs and an initial\n        condition:\n\n        ```none\n        dy/dt(t) = ode_fn(t, y(t))\n        y(initial_time) = initial_state\n        ```\n\n        Here, `t` (also called time) is a scalar `Tensor` of real `dtype` and `y(t)`\n        (also called the state at time `t`) is an N-D float or complex `Tensor`.\n\n        Args:\n          ode_fn: Function of the form `ode_fn(t, y)`. The input `t` is a scalar\n            `Tensor` of real `dtype`. The input `y` and output are both `Tensor`s\n            with the same shape and `dtype` as `initial_state`.\n          initial_state: N-D float or complex `Tensor` specifying the initial state.\n            The `dtype` of `initial_state` must be complex for problems with\n            complex-valued states (even if the initial state is real).\n          initial_time: Scalar `Tensor` of real `dtype` specifying the initial time.\n            Default value: `0.`.\n          final_time: Optional scalar `Tensor` of real `dtype` specifying the final\n            time to integrate up to. Must satisfy `initial_time < final_time`. If\n            unspecified, the solver will use `solution_times[-1]` (see below) as the\n            final time. Therefore, at least one of `final_time` or `solution_times`\n            must be specified.\n            Default value: `None` (i.e., `solution_times[-1]` or error).\n          solution_times: Optional 1-D float `Tensor` specifying a list of times. If\n            specified, the solver stores the computed state at each of these times\n            in the returned `Solution` object. If unspecified, the solver will\n            choose this list of times automatically. Must satisfy `initial_time <=\n            solution_times[0]`, `solution_times[i] < solution_times[i+1]`, and\n            `solution_times[-1] <= final_time` if `final_time` is specified.\n            Default value: `None`.\n          jacobian_fn: Optional function of the form `jacobian_fn(t, y)`. The input\n            `t` is a scalar `Tensor` of real `dtype`. The input `y` has the same\n            shape and `dtype` as `initial_state`. The output is a 2N-D `Tensor`\n            whose shape is `initial_state.shape + initial_state.shape` and whose\n            `dtype` is the same as `initial_state`. In particular, the `(i1, ...,\n            iN, j1, ..., jN)`-th entry of `jacobian_fn(t, y)` is the derivative of\n            the `(i1, ..., iN)`-th entry of `ode_fn(t, y)` with respect to the `(j1,\n            ..., jN)`-th entry of `y`. If this argument is left unspecified, the\n            solver will automatically compute the Jacobian if and when it is needed.\n            Default value: `None`.\n          jacobian_sparsity: Optional 2N-D boolean `Tensor` whose shape is\n            `initial_state.shape + initial_state.shape` specifying the sparsity\n            pattern of the Jacobian. This argument is ignored if `jacobian_fn` is\n            specified.\n            Default value: `None`.\n          batch_ndims: Optional nonnegative integer. When specified, the first\n            `batch_ndims` dimensions of `initial_state` are batch dimensions.\n            Default value: `None`.\n          previous_results: Optional solver-specific argument used to warm-start\n            this invocation of `solve`.\n            Default value: `None`.\n\n        Returns:\n          solution: Object of type `Solution` containing the solution.\n          diagnostics: Object of type `Diagnostics` containing performance\n            information.\n          results: Solver-specific object which can be used to warm-start the solver\n            on a future invocation of `solve`.", "id": "f15857:c0:m0"}
{"signature": "def _insert_back_keep_dims(x, axis):", "body": "for i in sorted(axis):<EOL><INDENT>x = tf.expand_dims(x, axis=i)<EOL><DEDENT>return x<EOL>", "docstring": "Insert the dims in `axis` back as singletons after being removed.\n\n    Args:\n      x:  `Tensor`.\n      axis:  Python list of integers.\n\n    Returns:\n      `Tensor` with same values as `x`, but additional singleton dimensions.", "id": "f15865:m7"}
{"signature": "def quantiles(x,<EOL>num_quantiles,<EOL>axis=None,<EOL>interpolation=None,<EOL>keep_dims=False,<EOL>validate_args=False,<EOL>name=None):", "body": "with tf.compat.v1.name_scope(<EOL>name, '<STR_LIT>', values=[x, num_quantiles, axis]):<EOL><INDENT>x = tf.convert_to_tensor(value=x, name='<STR_LIT:x>')<EOL>return percentile(<EOL>x,<EOL>q=tf.linspace(<EOL>tf.convert_to_tensor(value=<NUM_LIT:0>, dtype=tf.float64),<EOL>tf.convert_to_tensor(value=<NUM_LIT:100>, dtype=tf.float64),<EOL>num=num_quantiles + <NUM_LIT:1>),<EOL>axis=axis,<EOL>interpolation=interpolation,<EOL>keep_dims=keep_dims,<EOL>validate_args=validate_args,<EOL>preserve_gradients=False)<EOL><DEDENT>", "docstring": "Compute quantiles of `x` along `axis`.\n\n    The quantiles of a distribution are cut points dividing the range into\n    intervals with equal probabilities.\n\n    Given a vector `x` of samples, this function estimates the cut points by\n    returning `num_quantiles + 1` cut points, `(c0, ..., cn)`, such that, roughly\n    speaking, equal number of sample points lie in the `num_quantiles` intervals\n    `[c0, c1), [c1, c2), ..., [c_{n-1}, cn]`.  That is,\n\n    * About `1 / n` fraction of the data lies in `[c_{k-1}, c_k)`, `k = 1, ..., n`\n    * About `k / n` fraction of the data lies below `c_k`.\n    * `c0` is the sample minimum and `cn` is the maximum.\n\n    The exact number of data points in each interval depends on the size of\n    `x` (e.g. whether the size is divisible by `n`) and the `interpolation` kwarg.\n\n    Args:\n      x:  Numeric `N-D` `Tensor` with `N > 0`.  If `axis` is not `None`,\n        `x` must have statically known number of dimensions.\n      num_quantiles:  Scalar `integer` `Tensor`.  The number of intervals the\n        returned `num_quantiles + 1` cut points divide the range into.\n      axis:  Optional `0-D` or `1-D` integer `Tensor` with constant values. The\n        axis that index independent samples over which to return the desired\n        percentile.  If `None` (the default), treat every dimension as a sample\n        dimension, returning a scalar.\n      interpolation : {'nearest', 'linear', 'lower', 'higher', 'midpoint'}.\n        Default value: 'nearest'.  This specifies the interpolation method to\n        use when the fractions `k / n` lie between two data points `i < j`:\n          * linear: i + (j - i) * fraction, where fraction is the fractional part\n            of the index surrounded by i and j.\n          * lower: `i`.\n          * higher: `j`.\n          * nearest: `i` or `j`, whichever is nearest.\n          * midpoint: (i + j) / 2. `linear` and `midpoint` interpolation do not\n            work with integer dtypes.\n      keep_dims:  Python `bool`. If `True`, the last dimension is kept with size 1\n        If `False`, the last dimension is removed from the output shape.\n      validate_args:  Whether to add runtime checks of argument validity. If\n        False, and arguments are incorrect, correct behavior is not guaranteed.\n      name:  A Python string name to give this `Op`.  Default is 'percentile'\n\n    Returns:\n      cut_points:  A `rank(x) + 1 - len(axis)` dimensional `Tensor` with same\n      `dtype` as `x` and shape `[num_quantiles + 1, ...]` where the trailing shape\n      is that of `x` without the dimensions in `axis` (unless `keep_dims is True`)\n\n    Raises:\n      ValueError:  If argument 'interpolation' is not an allowed type.\n      ValueError:  If interpolation type not compatible with `dtype`.\n\n    #### Examples\n\n    ```python\n    # Get quartiles of x with various interpolation choices.\n    x = [0.,  1.,   2.,   3.,   4.,   5.,   6.,   7.,   8.,   9.,  10.]\n\n    tfp.stats.quantiles(x, num_quantiles=4, interpolation='nearest')\n    ==> [  0.,   2.,   5.,   8.,  10.]\n\n    tfp.stats.quantiles(x, num_quantiles=4, interpolation='linear')\n    ==> [  0. ,   2.5,   5. ,   7.5,  10. ]\n\n    tfp.stats.quantiles(x, num_quantiles=4, interpolation='lower')\n    ==> [  0.,   2.,   5.,   7.,  10.]\n\n    # Get deciles of columns of an R x C data set.\n    data = load_my_columnar_data(...)\n    tfp.stats.quantiles(data, num_quantiles=10)\n    ==> Shape [11, C] Tensor\n    ```", "id": "f15865:m4"}
{"signature": "def correlation(x,<EOL>y=None,<EOL>sample_axis=<NUM_LIT:0>,<EOL>event_axis=-<NUM_LIT:1>,<EOL>keepdims=False,<EOL>name=None):", "body": "with tf.compat.v1.name_scope(<EOL>name, '<STR_LIT>', values=[x, y, event_axis, sample_axis]):<EOL><INDENT>x /= stddev(x, sample_axis=sample_axis, keepdims=True)<EOL>if y is not None:<EOL><INDENT>y /= stddev(y, sample_axis=sample_axis, keepdims=True)<EOL><DEDENT>return covariance(<EOL>x=x,<EOL>y=y,<EOL>event_axis=event_axis,<EOL>sample_axis=sample_axis,<EOL>keepdims=keepdims)<EOL><DEDENT>", "docstring": "Sample correlation (Pearson) between observations indexed by `event_axis`.\n\n    Given `N` samples of scalar random variables `X` and `Y`, correlation may be\n    estimated as\n\n    ```none\n    Corr[X, Y] := Cov[X, Y] / Sqrt(Cov[X, X] * Cov[Y, Y]),\n    where\n    Cov[X, Y] := N^{-1} sum_{n=1}^N (X_n - Xbar) Conj{(Y_n - Ybar)}\n    Xbar := N^{-1} sum_{n=1}^N X_n\n    Ybar := N^{-1} sum_{n=1}^N Y_n\n    ```\n\n    Correlation is always in the interval `[-1, 1]`, and `Corr[X, X] == 1`.\n\n    For vector-variate random variables `X = (X1, ..., Xd)`, `Y = (Y1, ..., Yd)`,\n    one is often interested in the correlation matrix, `C_{ij} := Corr[Xi, Yj]`.\n\n    ```python\n    x = tf.random_normal(shape=(100, 2, 3))\n    y = tf.random_normal(shape=(100, 2, 3))\n\n    # corr[i, j] is the sample correlation between x[:, i, j] and y[:, i, j].\n    corr = tfp.stats.correlation(x, y, sample_axis=0, event_axis=None)\n\n    # corr_matrix[i, m, n] is the sample correlation of x[:, i, m] and y[:, i, n]\n    corr_matrix = tfp.stats.correlation(x, y, sample_axis=0, event_axis=-1)\n    ```\n\n    Notice we divide by `N` (the numpy default), which does not create `NaN`\n    when `N = 1`, but is slightly biased.\n\n    Args:\n      x:  A numeric `Tensor` holding samples.\n      y:  Optional `Tensor` with same `dtype` and `shape` as `x`.\n        Default value: `None` (`y` is effectively set to `x`).\n      sample_axis: Scalar or vector `Tensor` designating axis holding samples, or\n        `None` (meaning all axis hold samples).\n        Default value: `0` (leftmost dimension).\n      event_axis:  Scalar or vector `Tensor`, or `None` (scalar events).\n        Axis indexing random events, whose correlation we are interested in.\n        If a vector, entries must form a contiguous block of dims. `sample_axis`\n        and `event_axis` should not intersect.\n        Default value: `-1` (rightmost axis holds events).\n      keepdims:  Boolean.  Whether to keep the sample axis as singletons.\n      name: Python `str` name prefixed to Ops created by this function.\n            Default value: `None` (i.e., `'correlation'`).\n\n    Returns:\n      corr: A `Tensor` of same `dtype` as the `x`, and rank equal to\n        `rank(x) - len(sample_axis) + 2 * len(event_axis)`.\n\n    Raises:\n      AssertionError:  If `x` and `y` are found to have different shape.\n      ValueError:  If `sample_axis` and `event_axis` are found to overlap.\n      ValueError:  If `event_axis` is found to not be contiguous.", "id": "f15866:m3"}
{"signature": "def build_fake_data(num_examples=<NUM_LIT:10>):", "body": "class Dummy(object):<EOL><INDENT>pass<EOL><DEDENT>num_examples = <NUM_LIT:10><EOL>mnist_data = Dummy()<EOL>mnist_data.train = Dummy()<EOL>mnist_data.train.images = np.float32(np.random.randn(<EOL>num_examples, np.prod(IMAGE_SHAPE)))<EOL>mnist_data.train.labels = np.int32(np.random.permutation(<EOL>np.arange(num_examples)))<EOL>mnist_data.train.num_examples = num_examples<EOL>mnist_data.validation = Dummy()<EOL>mnist_data.validation.images = np.float32(np.random.randn(<EOL>num_examples, np.prod(IMAGE_SHAPE)))<EOL>mnist_data.validation.labels = np.int32(np.random.permutation(<EOL>np.arange(num_examples)))<EOL>mnist_data.validation.num_examples = num_examples<EOL>return mnist_data<EOL>", "docstring": "Builds fake MNIST-style data for unit testing.", "id": "f15868:m5"}
{"signature": "def visualize_training(images_val,<EOL>reconstructed_images_val,<EOL>random_images_val,<EOL>log_dir, prefix, viz_n=<NUM_LIT:10>):", "body": "save_imgs(images_val[:viz_n],<EOL>os.path.join(log_dir, \"<STR_LIT>\".format(prefix)))<EOL>save_imgs(reconstructed_images_val[:viz_n],<EOL>os.path.join(log_dir,<EOL>\"<STR_LIT>\".format(prefix)))<EOL>if random_images_val is not None:<EOL><INDENT>save_imgs(random_images_val[:viz_n],<EOL>os.path.join(log_dir,<EOL>\"<STR_LIT>\".format(prefix)))<EOL><DEDENT>", "docstring": "Helper method to save images visualizing model reconstructions.\n\n    Args:\n      images_val: Numpy array containing a batch of input images.\n      reconstructed_images_val: Numpy array giving the expected output\n        (mean) of the decoder.\n      random_images_val: Optionally, a Numpy array giving the expected output\n        (mean) of decoding samples from the prior, or `None`.\n      log_dir: The directory to write images (Python `str`).\n      prefix: A specific label for the saved visualizations, which\n        determines their filenames (Python `str`).\n      viz_n: The number of images from each batch to visualize (Python `int`).", "id": "f15868:m4"}
{"signature": "def call(self, inputs):", "body": "out = self.dense(inputs)  <EOL>out = self.output_layer(out)  <EOL>loc = out[..., :self.latent_size]<EOL>scale_diag = tf.nn.softplus(out[..., self.latent_size:]) + <NUM_LIT>  <EOL>return tfd.MultivariateNormalDiag(loc=loc, scale_diag=scale_diag)<EOL>", "docstring": "Runs the model to generate a distribution `q(z_{1:T} | x_{1:T})`.\n\n        Args:\n          inputs: A batch of intermediate representations of image frames\n            across all timesteps, of shape [..., batch_size, timesteps,\n            hidden_size].\n\n        Returns:\n          A batch of MultivariateNormalDiag distributions with event shape\n          [latent_size], batch shape [..., batch_size, timesteps], and\n          sample shape [sample_shape, ..., batch_size, timesteps,\n          latent_size].", "id": "f15869:c5:m1"}
{"signature": "def visualize_qualitative_analysis(inputs, model, samples=<NUM_LIT:1>, batch_size=<NUM_LIT:3>,<EOL>length=<NUM_LIT:8>):", "body": "average = lambda dist: tf.reduce_mean(<EOL>input_tensor=dist.mean(), axis=<NUM_LIT:0>)  <EOL>with tf.compat.v1.name_scope(\"<STR_LIT>\"):<EOL><INDENT>reconstruct = functools.partial(model.reconstruct, inputs=inputs,<EOL>samples=samples)<EOL>visualize_reconstruction(inputs, average(reconstruct()))<EOL>visualize_reconstruction(inputs, average(reconstruct(sample_static=True)),<EOL>name=\"<STR_LIT>\")<EOL>visualize_reconstruction(inputs, average(reconstruct(sample_dynamic=True)),<EOL>name=\"<STR_LIT>\")<EOL>visualize_reconstruction(inputs, average(reconstruct(swap_static=True)),<EOL>name=\"<STR_LIT>\")<EOL>visualize_reconstruction(inputs, average(reconstruct(swap_dynamic=True)),<EOL>name=\"<STR_LIT>\")<EOL><DEDENT>with tf.compat.v1.name_scope(\"<STR_LIT>\"):<EOL><INDENT>generate = functools.partial(model.generate, batch_size=batch_size,<EOL>length=length, samples=samples)<EOL>image_summary(average(generate(fix_static=True)), \"<STR_LIT>\")<EOL>image_summary(average(generate(fix_dynamic=True)), \"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Visualizes a qualitative analysis of a given model.\n\n    Args:\n      inputs: A tensor of the original inputs, of shape [batch, timesteps,\n        h, w, c].\n      model: A DisentangledSequentialVAE model.\n      samples: Number of samples to draw from the latent distributions.\n      batch_size: Number of sequences to generate.\n      length: Number of timesteps to generate for each sequence.", "id": "f15869:m2"}
{"signature": "def call(self, inputs):", "body": "<EOL>features, static_sample = inputs<EOL>length = tf.shape(input=features)[-<NUM_LIT:2>]<EOL>static_sample = static_sample[..., tf.newaxis, :] + tf.zeros([length, <NUM_LIT:1>])<EOL>sample_shape_static = tf.shape(input=static_sample)[:-<NUM_LIT:3>]<EOL>sample_shape_inputs = tf.shape(input=features)[:-<NUM_LIT:3>]<EOL>broadcast_shape_inputs = tf.concat((sample_shape_static, [<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>]), <NUM_LIT:0>)<EOL>broadcast_shape_static = tf.concat((sample_shape_inputs, [<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>]), <NUM_LIT:0>)<EOL>features = features + tf.zeros(broadcast_shape_inputs)<EOL>static_sample = static_sample + tf.zeros(broadcast_shape_static)<EOL>combined = tf.concat((features, static_sample), axis=-<NUM_LIT:1>)<EOL>collapsed_shape = tf.concat(([-<NUM_LIT:1>], tf.shape(input=combined)[-<NUM_LIT:2>:]), axis=<NUM_LIT:0>)<EOL>out = tf.reshape(combined, collapsed_shape)<EOL>out = self.bilstm(out)  <EOL>out = self.rnn(out)  <EOL>expanded_shape = tf.concat(<EOL>(tf.shape(input=combined)[:-<NUM_LIT:2>], tf.shape(input=out)[<NUM_LIT:1>:]), axis=<NUM_LIT:0>)<EOL>out = tf.reshape(out, expanded_shape)  <EOL>out = self.output_layer(out)  <EOL>loc = out[..., :self.latent_size]<EOL>scale_diag = tf.nn.softplus(out[..., self.latent_size:]) + <NUM_LIT>  <EOL>return tfd.MultivariateNormalDiag(loc=loc, scale_diag=scale_diag)<EOL>", "docstring": "Runs the model to generate a distribution `q(z_{1:T} | x_{1:T}, f)`.\n\n        This generates a list of batched MultivariateNormalDiag\n        distributions using the output of the recurrent model at each\n        timestep to parameterize each distribution.\n\n        Args:\n          inputs: A tuple of a batch of intermediate representations of\n            image frames across all timesteps of shape [..., batch_size,\n            timesteps, dimensions], and a sample of the static latent\n            variable `f` of shape [..., batch_size, latent_size].\n\n        Returns:\n          A batch of MultivariateNormalDiag distributions with event shape\n          [latent_size], batch shape [broadcasted_shape, batch_size,\n          timesteps], and sample shape [sample_shape, broadcasted_shape,\n          batch_size, timesteps, latent_size], where `broadcasted_shape` is\n          the broadcasted sampled shape between the inputs and static\n          sample.", "id": "f15869:c6:m1"}
{"signature": "@property<EOL><INDENT>def scale_diag(self):<DEDENT>", "body": "return tf.nn.softplus(self._untransformed_stddev) + <NUM_LIT><EOL>", "docstring": "The diagonal standard deviation of the normal distribution.", "id": "f15869:c0:m4"}
{"signature": "def call(self, inputs):", "body": "del inputs  <EOL>with tf.compat.v1.name_scope(self._name):<EOL><INDENT>return tfd.MultivariateNormalDiag(self.loc, self.scale_diag)<EOL><DEDENT>", "docstring": "Runs the model to generate multivariate normal distribution.\n\n        Args:\n          inputs: Unused.\n\n        Returns:\n          A MultivariateNormalDiag distribution with event shape\n          [dimensions], batch shape [], and sample shape [sample_shape,\n          dimensions].", "id": "f15869:c0:m2"}
{"signature": "def __init__(self, dimensions, hidden_size):", "body": "super(LearnableMultivariateNormalDiagCell, self).__init__()<EOL>self.dimensions = dimensions<EOL>self.hidden_size = hidden_size<EOL>self.lstm_cell = tf.keras.layers.LSTMCell(hidden_size)<EOL>self.output_layer = tf.keras.layers.Dense(<NUM_LIT:2>*dimensions)<EOL>", "docstring": "Constructs a learnable multivariate diagonal normal cell.\n\n        Args:\n          dimensions: An integer corresponding to the dimensionality of the\n            distribution.\n          hidden_size: Dimensionality of the LSTM function parameters.", "id": "f15869:c1:m0"}
{"signature": "def sample_dynamic_prior(self, samples, batch_size, length, fixed=False):", "body": "if fixed:<EOL><INDENT>sample_batch_size = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>sample_batch_size = batch_size<EOL><DEDENT>sample, state = self.dynamic_prior.zero_state([samples, sample_batch_size])<EOL>locs = []<EOL>scale_diags = []<EOL>sample_list = []<EOL>for _ in range(length):<EOL><INDENT>dist, state = self.dynamic_prior(sample, state)<EOL>sample = dist.sample()<EOL>locs.append(dist.parameters[\"<STR_LIT>\"])<EOL>scale_diags.append(dist.parameters[\"<STR_LIT>\"])<EOL>sample_list.append(sample)<EOL><DEDENT>sample = tf.stack(sample_list, axis=<NUM_LIT:2>)<EOL>loc = tf.stack(locs, axis=<NUM_LIT:2>)<EOL>scale_diag = tf.stack(scale_diags, axis=<NUM_LIT:2>)<EOL>if fixed:  <EOL><INDENT>sample = sample + tf.zeros([batch_size, <NUM_LIT:1>, <NUM_LIT:1>])<EOL><DEDENT>return sample, tfd.MultivariateNormalDiag(loc=loc, scale_diag=scale_diag)<EOL>", "docstring": "Sample the dynamic latent prior.\n\n        Args:\n          samples: Number of samples to draw from the latent distribution.\n          batch_size: Number of sequences to sample.\n          length: Number of timesteps to sample for each sequence.\n          fixed: Boolean for whether or not to share the same random\n            sample across all sequences.\n\n        Returns:\n          A tuple of a sample tensor of shape [samples, batch_size, length\n          latent_size], and a MultivariateNormalDiag distribution from which\n          the tensor was sampled, with event shape [latent_size], and batch\n          shape [samples, 1, length] if fixed or [samples, batch_size,\n          length] otherwise.", "id": "f15869:c7:m5"}
{"signature": "def zero_state(self, sample_batch_shape=()):", "body": "h0 = tf.zeros([<NUM_LIT:1>, self.hidden_size])<EOL>c0 = tf.zeros([<NUM_LIT:1>, self.hidden_size])<EOL>combined_shape = tf.concat((tf.convert_to_tensor(<EOL>value=sample_batch_shape, dtype=tf.int32), [self.dimensions]),<EOL>axis=-<NUM_LIT:1>)<EOL>previous_output = tf.zeros(combined_shape)<EOL>return previous_output, (h0, c0)<EOL>", "docstring": "Returns an initial state for the LSTM cell.\n\n        Args:\n          sample_batch_shape: A 0D or 1D tensor of the combined sample and\n            batch shape.\n\n        Returns:\n          A tuple of the initial previous output at timestep 0 of shape\n          [sample_batch_shape, dimensions], and the cell state.", "id": "f15869:c1:m1"}
{"signature": "def _resnet_block(x, filters, kernel, stride, kernel_posterior_fn):", "body": "x = tf.keras.layers.BatchNormalization()(x)<EOL>x = tf.keras.layers.Activation('<STR_LIT:relu>')(x)<EOL>if stride != <NUM_LIT:1> or filters != x.shape[<NUM_LIT:1>]:<EOL><INDENT>shortcut = _projection_shortcut(x, filters, stride, kernel_posterior_fn)<EOL><DEDENT>else:<EOL><INDENT>shortcut = x<EOL><DEDENT>x = tfp.layers.Convolution2DFlipout(<EOL>filters,<EOL>kernel,<EOL>strides=stride,<EOL>padding='<STR_LIT>',<EOL>kernel_posterior_fn=kernel_posterior_fn)(x)<EOL>x = tf.keras.layers.BatchNormalization()(x)<EOL>x = tf.keras.layers.Activation('<STR_LIT:relu>')(x)<EOL>x = tfp.layers.Convolution2DFlipout(<EOL>filters,<EOL>kernel,<EOL>strides=<NUM_LIT:1>,<EOL>padding='<STR_LIT>',<EOL>kernel_posterior_fn=kernel_posterior_fn)(x)<EOL>x = tf.keras.layers.add([x, shortcut])<EOL>return x<EOL>", "docstring": "Network block for ResNet.", "id": "f15871:m1"}
{"signature": "def newsgroups_dataset(directory, split_name, num_words, shuffle_and_repeat):", "body": "data = np.load(download(directory, FILE_TEMPLATE.format(split=split_name)))<EOL>data = data[:-<NUM_LIT:1>]<EOL>num_documents = data.shape[<NUM_LIT:0>]<EOL>indices = np.array([(row_idx, column_idx)<EOL>for row_idx, row in enumerate(data)<EOL>for column_idx in row])<EOL>sparse_matrix = scipy.sparse.coo_matrix(<EOL>(np.ones(indices.shape[<NUM_LIT:0>]), (indices[:, <NUM_LIT:0>], indices[:, <NUM_LIT:1>])),<EOL>shape=(num_documents, num_words),<EOL>dtype=np.float32)<EOL>sparse_matrix = sparse_matrix.tocsr()<EOL>dataset = tf.data.Dataset.range(num_documents)<EOL>if shuffle_and_repeat:<EOL><INDENT>dataset = dataset.shuffle(num_documents).repeat()<EOL><DEDENT>def get_row_py_func(idx):<EOL><INDENT>def get_row_python(idx_py):<EOL><INDENT>return np.squeeze(np.array(sparse_matrix[idx_py].todense()), axis=<NUM_LIT:0>)<EOL><DEDENT>py_func = tf.compat.v1.py_func(<EOL>get_row_python, [idx], tf.float32, stateful=False)<EOL>py_func.set_shape((num_words,))<EOL>return py_func<EOL><DEDENT>dataset = dataset.map(get_row_py_func)<EOL>return dataset<EOL>", "docstring": "Return 20 newsgroups tf.data.Dataset.", "id": "f15872:m7"}
{"signature": "def build_fake_input_fns(batch_size):", "body": "num_words = <NUM_LIT:1000><EOL>vocabulary = [str(i) for i in range(num_words)]<EOL>random_sample = np.random.randint(<EOL><NUM_LIT:10>, size=(batch_size, num_words)).astype(np.float32)<EOL>def train_input_fn():<EOL><INDENT>dataset = tf.data.Dataset.from_tensor_slices(random_sample)<EOL>dataset = dataset.batch(batch_size)<EOL>return tf.compat.v1.data.make_one_shot_iterator(dataset.repeat()).get_next()<EOL><DEDENT>def eval_input_fn():<EOL><INDENT>dataset = tf.data.Dataset.from_tensor_slices(random_sample)<EOL>dataset = dataset.batch(batch_size)<EOL>return tf.compat.v1.data.make_one_shot_iterator(dataset).get_next()<EOL><DEDENT>return train_input_fn, eval_input_fn, vocabulary<EOL>", "docstring": "Build fake data for unit testing.", "id": "f15872:m8"}
{"signature": "def latent_dirichlet_allocation(concentration, topics_words):", "body": "topics = ed.Dirichlet(concentration=concentration, name=\"<STR_LIT>\")<EOL>word_probs = tf.matmul(topics, topics_words)<EOL>bag_of_words = ed.OneHotCategorical(probs=word_probs, name=\"<STR_LIT>\")<EOL>return bag_of_words<EOL>", "docstring": "Latent Dirichlet Allocation in terms of its generative process.\n\n    The model posits a distribution over bags of words and is parameterized by\n    a concentration and the topic-word probabilities. It collapses per-word\n    topic assignments.\n\n    Args:\n      concentration: A Tensor of shape [1, num_topics], which parameterizes the\n        Dirichlet prior over topics.\n      topics_words: A Tensor of shape [num_topics, num_words], where each row\n        (topic) denotes the probability of each word being in that topic.\n\n    Returns:\n      bag_of_words: A random variable capturing a sample from the model, of shape\n        [1, num_words]. It represents one generated document as a bag of words.", "id": "f15874:m2"}
{"signature": "def build_input_fns(data_dir, batch_size):", "body": "with open(download(data_dir, \"<STR_LIT>\"), \"<STR_LIT:r>\") as f:<EOL><INDENT>words_to_idx = pickle.load(f)<EOL><DEDENT>num_words = len(words_to_idx)<EOL>vocabulary = [None] * num_words<EOL>for word, idx in words_to_idx.items():<EOL><INDENT>vocabulary[idx] = word<EOL><DEDENT>def train_input_fn():<EOL><INDENT>dataset = newsgroups_dataset(<EOL>data_dir, \"<STR_LIT:train>\", num_words, shuffle_and_repeat=True)<EOL>dataset = dataset.batch(batch_size).prefetch(<NUM_LIT:32>)<EOL>return tf.compat.v1.data.make_one_shot_iterator(dataset).get_next()<EOL><DEDENT>def eval_input_fn():<EOL><INDENT>dataset = newsgroups_dataset(<EOL>data_dir, \"<STR_LIT:test>\", num_words, shuffle_and_repeat=False)<EOL>dataset = dataset.batch(batch_size)<EOL>return tf.compat.v1.data.make_one_shot_iterator(dataset).get_next()<EOL><DEDENT>return train_input_fn, eval_input_fn, vocabulary<EOL>", "docstring": "Builds iterators for train and evaluation data.\n\n    Each object is represented as a bag-of-words vector.\n\n    Arguments:\n      data_dir: Folder in which to store the data.\n      batch_size: Batch size for both train and evaluation.\n\n    Returns:\n      train_input_fn: A function that returns an iterator over the training data.\n      eval_input_fn: A function that returns an iterator over the evaluation data.\n      vocabulary: A mapping of word's integer index to the corresponding string.", "id": "f15874:m10"}
{"signature": "def make_value_setter(**model_kwargs):", "body": "def set_values(f, *args, **kwargs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>name = kwargs.get(\"<STR_LIT:name>\")<EOL>if name in model_kwargs:<EOL><INDENT>kwargs[\"<STR_LIT:value>\"] = model_kwargs[name]<EOL><DEDENT>return ed.interceptable(f)(*args, **kwargs)<EOL><DEDENT>return set_values<EOL>", "docstring": "Creates a value-setting interceptor.\n\n    Args:\n      **model_kwargs: dict of str to Tensor. Keys are the names of random variable\n        in the model to which this interceptor is being applied. Values are\n        Tensors to set their value to.\n\n    Returns:\n      set_values: Function which sets the value of intercepted ops.", "id": "f15874:m4"}
{"signature": "def get_topics_strings(topics_words, alpha, vocabulary,<EOL>topics_to_print=<NUM_LIT:10>, words_per_topic=<NUM_LIT:10>):", "body": "alpha = np.squeeze(alpha, axis=<NUM_LIT:0>)<EOL>highest_weight_topics = np.argsort(-alpha, kind=\"<STR_LIT>\")<EOL>top_words = np.argsort(-topics_words, axis=<NUM_LIT:1>)<EOL>res = []<EOL>for topic_idx in highest_weight_topics[:topics_to_print]:<EOL><INDENT>l = [\"<STR_LIT>\".format(topic_idx, alpha[topic_idx])]<EOL>l += [vocabulary[word] for word in top_words[topic_idx, :words_per_topic]]<EOL>res.append(\"<STR_LIT:U+0020>\".join(l))<EOL><DEDENT>return np.array(res)<EOL>", "docstring": "Returns the summary of the learned topics.\n\n    Arguments:\n      topics_words: KxV tensor with topics as rows and words as columns.\n      alpha: 1xK tensor of prior Dirichlet concentrations for the\n          topics.\n      vocabulary: A mapping of word's integer index to the corresponding string.\n      topics_to_print: The number of topics with highest prior weight to\n          summarize.\n      words_per_topic: Number of wodrs per topic to return.\n\n    Returns:\n      summary: A np.array with strings.", "id": "f15874:m6"}
{"signature": "def build_fake_input_fns(batch_size):", "body": "num_words = <NUM_LIT:1000><EOL>vocabulary = [str(i) for i in range(num_words)]<EOL>random_sample = np.random.randint(<EOL><NUM_LIT:10>, size=(batch_size, num_words)).astype(np.float32)<EOL>def train_input_fn():<EOL><INDENT>dataset = tf.data.Dataset.from_tensor_slices(random_sample)<EOL>dataset = dataset.batch(batch_size).repeat()<EOL>return tf.compat.v1.data.make_one_shot_iterator(dataset).get_next()<EOL><DEDENT>def eval_input_fn():<EOL><INDENT>dataset = tf.data.Dataset.from_tensor_slices(random_sample)<EOL>dataset = dataset.batch(batch_size)<EOL>return tf.compat.v1.data.make_one_shot_iterator(dataset).get_next()<EOL><DEDENT>return train_input_fn, eval_input_fn, vocabulary<EOL>", "docstring": "Builds fake data for unit testing.", "id": "f15874:m9"}
{"signature": "def newsgroups_dataset(directory, split_name, num_words, shuffle_and_repeat):", "body": "data = np.load(download(directory, FILE_TEMPLATE.format(split=split_name)))<EOL>data = data[:-<NUM_LIT:1>]<EOL>num_documents = data.shape[<NUM_LIT:0>]<EOL>indices = np.array([(row_idx, column_idx)<EOL>for row_idx, row in enumerate(data)<EOL>for column_idx in row])<EOL>sparse_matrix = scipy.sparse.coo_matrix(<EOL>(np.ones(indices.shape[<NUM_LIT:0>]), (indices[:, <NUM_LIT:0>], indices[:, <NUM_LIT:1>])),<EOL>shape=(num_documents, num_words),<EOL>dtype=np.float32)<EOL>sparse_matrix = sparse_matrix.tocsr()<EOL>dataset = tf.data.Dataset.range(num_documents)<EOL>if shuffle_and_repeat:<EOL><INDENT>dataset = dataset.shuffle(num_documents).repeat()<EOL><DEDENT>def get_row_py_func(idx):<EOL><INDENT>def get_row_python(idx_py):<EOL><INDENT>return np.squeeze(np.array(sparse_matrix[idx_py].todense()), axis=<NUM_LIT:0>)<EOL><DEDENT>py_func = tf.compat.v1.py_func(<EOL>get_row_python, [idx], tf.float32, stateful=False)<EOL>py_func.set_shape((num_words,))<EOL>return py_func<EOL><DEDENT>dataset = dataset.map(get_row_py_func)<EOL>return dataset<EOL>", "docstring": "20 newsgroups as a tf.data.Dataset.", "id": "f15874:m8"}
{"signature": "def make_mixture_prior(latent_size, mixture_components):", "body": "if mixture_components == <NUM_LIT:1>:<EOL><INDENT>return tfd.MultivariateNormalDiag(<EOL>loc=tf.zeros([latent_size]),<EOL>scale_identity_multiplier=<NUM_LIT:1.0>)<EOL><DEDENT>loc = tf.compat.v1.get_variable(<EOL>name=\"<STR_LIT>\", shape=[mixture_components, latent_size])<EOL>raw_scale_diag = tf.compat.v1.get_variable(<EOL>name=\"<STR_LIT>\", shape=[mixture_components, latent_size])<EOL>mixture_logits = tf.compat.v1.get_variable(<EOL>name=\"<STR_LIT>\", shape=[mixture_components])<EOL>return tfd.MixtureSameFamily(<EOL>components_distribution=tfd.MultivariateNormalDiag(<EOL>loc=loc,<EOL>scale_diag=tf.nn.softplus(raw_scale_diag)),<EOL>mixture_distribution=tfd.Categorical(logits=mixture_logits),<EOL>name=\"<STR_LIT>\")<EOL>", "docstring": "Creates the mixture of Gaussians prior distribution.\n\n    Args:\n      latent_size: The dimensionality of the latent representation.\n      mixture_components: Number of elements of the mixture.\n\n    Returns:\n      random_prior: A `tfd.Distribution` instance representing the distribution\n        over encodings in the absence of any evidence.", "id": "f15878:m3"}
{"signature": "def download(directory, filename):", "body": "filepath = os.path.join(directory, filename)<EOL>if tf.io.gfile.exists(filepath):<EOL><INDENT>return filepath<EOL><DEDENT>if not tf.io.gfile.exists(directory):<EOL><INDENT>tf.io.gfile.makedirs(directory)<EOL><DEDENT>url = os.path.join(ROOT_PATH, filename)<EOL>print(\"<STR_LIT>\" % (url, filepath))<EOL>urllib.request.urlretrieve(url, filepath)<EOL>return filepath<EOL>", "docstring": "Downloads a file.", "id": "f15878:m7"}
{"signature": "def _softplus_inverse(x):", "body": "return tf.math.log(tf.math.expm1(x))<EOL>", "docstring": "Helper which computes the function inverse of `tf.nn.softplus`.", "id": "f15878:m0"}
{"signature": "def build_input_fns(data_dir, batch_size):", "body": "<EOL>def train_input_fn():<EOL><INDENT>dataset = static_mnist_dataset(data_dir, \"<STR_LIT:train>\")<EOL>dataset = dataset.shuffle(<NUM_LIT>).repeat().batch(batch_size)<EOL>return tf.compat.v1.data.make_one_shot_iterator(dataset).get_next()<EOL><DEDENT>def eval_input_fn():<EOL><INDENT>eval_dataset = static_mnist_dataset(data_dir, \"<STR_LIT>\")<EOL>eval_dataset = eval_dataset.batch(batch_size)<EOL>return tf.compat.v1.data.make_one_shot_iterator(eval_dataset).get_next()<EOL><DEDENT>return train_input_fn, eval_input_fn<EOL>", "docstring": "Builds an Iterator switching between train and heldout data.", "id": "f15878:m10"}
{"signature": "def make_decoder(activation, latent_size, output_shape, base_depth):", "body": "deconv = functools.partial(<EOL>tf.keras.layers.Conv2DTranspose, padding=\"<STR_LIT>\", activation=activation)<EOL>conv = functools.partial(<EOL>tf.keras.layers.Conv2D, padding=\"<STR_LIT>\", activation=activation)<EOL>decoder_net = tf.keras.Sequential([<EOL>deconv(<NUM_LIT:2> * base_depth, <NUM_LIT:7>, padding=\"<STR_LIT>\"),<EOL>deconv(<NUM_LIT:2> * base_depth, <NUM_LIT:5>),<EOL>deconv(<NUM_LIT:2> * base_depth, <NUM_LIT:5>, <NUM_LIT:2>),<EOL>deconv(base_depth, <NUM_LIT:5>),<EOL>deconv(base_depth, <NUM_LIT:5>, <NUM_LIT:2>),<EOL>deconv(base_depth, <NUM_LIT:5>),<EOL>conv(output_shape[-<NUM_LIT:1>], <NUM_LIT:5>, activation=None),<EOL>])<EOL>def decoder(codes):<EOL><INDENT>original_shape = tf.shape(input=codes)<EOL>codes = tf.reshape(codes, (-<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>, latent_size))<EOL>logits = decoder_net(codes)<EOL>logits = tf.reshape(<EOL>logits, shape=tf.concat([original_shape[:-<NUM_LIT:1>], output_shape], axis=<NUM_LIT:0>))<EOL>return tfd.Independent(tfd.Bernoulli(logits=logits),<EOL>reinterpreted_batch_ndims=len(output_shape),<EOL>name=\"<STR_LIT:image>\")<EOL><DEDENT>return decoder<EOL>", "docstring": "Creates the decoder function.\n\n    Args:\n      activation: Activation function in hidden layers.\n      latent_size: Dimensionality of the encoding.\n      output_shape: The output image shape.\n      base_depth: Smallest depth for a layer.\n\n    Returns:\n      decoder: A `callable` mapping a `Tensor` of encodings to a\n        `tfd.Distribution` instance over images.", "id": "f15878:m2"}
{"signature": "def build_fake_data(num_examples=<NUM_LIT:10>):", "body": "class Dummy(object):<EOL><INDENT>pass<EOL><DEDENT>num_examples = <NUM_LIT:10><EOL>mnist_data = Dummy()<EOL>mnist_data.train = Dummy()<EOL>mnist_data.train.images = np.float32(np.random.randn(<EOL>num_examples, *IMAGE_SHAPE))<EOL>mnist_data.train.labels = np.int32(np.random.permutation(<EOL>np.arange(num_examples)))<EOL>mnist_data.train.num_examples = num_examples<EOL>mnist_data.validation = Dummy()<EOL>mnist_data.validation.images = np.float32(np.random.randn(<EOL>num_examples, *IMAGE_SHAPE))<EOL>mnist_data.validation.labels = np.int32(np.random.permutation(<EOL>np.arange(num_examples)))<EOL>mnist_data.validation.num_examples = num_examples<EOL>return mnist_data<EOL>", "docstring": "Build fake MNIST-style data for unit testing.", "id": "f15880:m3"}
{"signature": "def trainable_gamma(shape, min_concentration=<NUM_LIT>, min_scale=<NUM_LIT>, name=None):", "body": "with tf.compat.v1.variable_scope(None, default_name=\"<STR_LIT>\"):<EOL><INDENT>unconstrained_concentration = tf.compat.v1.get_variable(<EOL>\"<STR_LIT>\",<EOL>shape,<EOL>initializer=tf.compat.v1.initializers.random_normal(<EOL>mean=<NUM_LIT:0.5>, stddev=<NUM_LIT:0.1>))<EOL>unconstrained_scale = tf.compat.v1.get_variable(<EOL>\"<STR_LIT>\",<EOL>shape,<EOL>initializer=tf.compat.v1.initializers.random_normal(stddev=<NUM_LIT:0.1>))<EOL>concentration = tf.maximum(tf.nn.softplus(unconstrained_concentration),<EOL>min_concentration)<EOL>rate = tf.maximum(<NUM_LIT:1.> / tf.nn.softplus(unconstrained_scale), <NUM_LIT:1.> / min_scale)<EOL>rv = ed.Gamma(concentration=concentration, rate=rate, name=name)<EOL>return rv<EOL><DEDENT>", "docstring": "Learnable Gamma via concentration and scale parameterization.", "id": "f15881:m2"}
{"signature": "def make_value_setter(**model_kwargs):", "body": "def set_values(f, *args, **kwargs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>name = kwargs.get(\"<STR_LIT:name>\")<EOL>if name in model_kwargs:<EOL><INDENT>kwargs[\"<STR_LIT:value>\"] = model_kwargs[name]<EOL><DEDENT>return ed.interceptable(f)(*args, **kwargs)<EOL><DEDENT>return set_values<EOL>", "docstring": "Creates a value-setting interceptor.\n\n    Args:\n      **model_kwargs: dict of str to Tensor. Keys are the names of random variable\n        in the model to which this interceptor is being applied. Values are\n        Tensors to set their value to.\n\n    Returns:\n      set_values: Function which sets the value of intercepted ops.", "id": "f15881:m4"}
{"signature": "def move(self, state=None):", "body": "state = self.state if state is None else state<EOL>route = state<EOL>a = random.randint(self.locked_range, len(route) - <NUM_LIT:1>)<EOL>b = random.randint(self.locked_range, len(route) - <NUM_LIT:1>)<EOL>route[a], route[b] = route[b], route[a]<EOL>", "docstring": "Swaps two cities in the route.\n\n        :type state: TSPState", "id": "f15885:c0:m2"}
{"signature": "def energy(self, state=None):", "body": "state = self.state if state is None else state<EOL>route = state<EOL>e = <NUM_LIT:0><EOL>if self.distance_matrix:<EOL><INDENT>for i in range(len(route)):<EOL><INDENT>e += self.distance_matrix[\"<STR_LIT>\".format(route[i-<NUM_LIT:1>], route[i])]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for i in range(len(route)):<EOL><INDENT>e += distance(self.cities[route[i-<NUM_LIT:1>]], self.cities[route[i]])<EOL><DEDENT><DEDENT>return e<EOL>", "docstring": "Calculates the length of the route.", "id": "f15885:c0:m3"}
{"signature": "def chunks(l, n):", "body": "for i in range(<NUM_LIT:0>, len(l), n):<EOL><INDENT>yield l[i:i+n]<EOL><DEDENT>", "docstring": "Yield successive n-sized chunks from l.", "id": "f15885:m2"}
{"signature": "@classmethod<EOL><INDENT>def divide(cls, divisions, problem_data):<DEDENT>", "body": "tspp = TSPProblem(**problem_data)<EOL>def routes_for_subgroup(cs):<EOL><INDENT>for city in cs:<EOL><INDENT>if city == tspp.start_city:<EOL><INDENT>continue<EOL><DEDENT>cities = tspp.cities.keys()<EOL>cities.remove(tspp.start_city)<EOL>cities.remove(city)<EOL>random.shuffle(cities)<EOL>route = [tspp.start_city, city] + cities<EOL>assert len(set(route)) == len(route)<EOL>assert len(route) == len(tspp.cities)<EOL>yield json.dumps(route)<EOL><DEDENT><DEDENT>if divisions:<EOL><INDENT>chunk_size = int(math.ceil(len(tspp.cities) / divisions))<EOL><DEDENT>else:<EOL><INDENT>chunk_size = <NUM_LIT:1><EOL><DEDENT>for subgroup in chunks(tspp.cities.keys(), chunk_size):<EOL><INDENT>routes = list(routes_for_subgroup(subgroup))<EOL>if routes:<EOL><INDENT>yield routes<EOL><DEDENT><DEDENT>", "docstring": "divide\n\n        :type problem_data: dict", "id": "f15885:c0:m4"}
{"signature": "def get_grading_standards_for_course(self, course_id):", "body": "url = COURSES_API.format(course_id) + \"<STR_LIT>\"<EOL>standards = []<EOL>for data in self._get_resource(url):<EOL><INDENT>standards.append(GradingStandard(data=data))<EOL><DEDENT>return standards<EOL>", "docstring": "List the grading standards available to a course\nhttps://canvas.instructure.com/doc/api/grading_standards.html#method.grading_standards_api.context_index", "id": "f15889:c0:m0"}
{"signature": "def get_section(self, section_id, params={}):", "body": "url = SECTIONS_API.format(section_id)<EOL>return CanvasSection(data=self._get_resource(url, params=params))<EOL>", "docstring": "Return section resource for given canvas section id.\n\nhttps://canvas.instructure.com/doc/api/sections.html#method.sections.show", "id": "f15910:c0:m0"}
{"signature": "def get_report_data(self, report):", "body": "if report.report_id is None or report.status is None:<EOL><INDENT>raise ReportFailureException(report)<EOL><DEDENT>interval = getattr(settings, '<STR_LIT>', <NUM_LIT:5>)<EOL>while report.status != \"<STR_LIT>\":<EOL><INDENT>if report.status == \"<STR_LIT:error>\":<EOL><INDENT>raise ReportFailureException(report)<EOL><DEDENT>sleep(interval)<EOL>report = self.get_report_status(report)<EOL><DEDENT>if report.attachment is None or report.attachment.url is None:<EOL><INDENT>return<EOL><DEDENT>data = self._get_report_file(report.attachment.url)<EOL>return data.split(\"<STR_LIT:\\n>\")<EOL>", "docstring": "Returns a completed report as a list of csv strings.", "id": "f15911:c1:m9"}
{"signature": "def create_report(self, report_type, account_id, term_id=None, params={}):", "body": "if term_id is not None:<EOL><INDENT>params[\"<STR_LIT>\"] = term_id<EOL><DEDENT>url = ACCOUNTS_API.format(account_id) + \"<STR_LIT>\".format(<EOL>report_type)<EOL>body = {\"<STR_LIT>\": params}<EOL>data = self._post_resource(url, body)<EOL>data[\"<STR_LIT>\"] = account_id<EOL>return Report(data=data)<EOL>", "docstring": "Generates a report instance for the canvas account id.\n\nhttps://canvas.instructure.com/doc/api/account_reports.html#method.account_reports.create", "id": "f15911:c1:m2"}
{"signature": "def get_report_status(self, report):", "body": "if (report.account_id is None or report.type is None or<EOL>report.report_id is None):<EOL><INDENT>raise ReportFailureException(report)<EOL><DEDENT>url = ACCOUNTS_API.format(report.account_id) + \"<STR_LIT>\".format(<EOL>report.type, report.report_id)<EOL>data = self._get_resource(url)<EOL>data[\"<STR_LIT>\"] = report.account_id<EOL>return Report(data=data)<EOL>", "docstring": "Returns the status of a report.\n\nhttps://canvas.instructure.com/doc/api/account_reports.html#method.account_reports.show", "id": "f15911:c1:m10"}
{"signature": "def get_available_reports(self, account_id):", "body": "url = ACCOUNTS_API.format(account_id) + \"<STR_LIT>\"<EOL>report_types = []<EOL>for datum in self._get_resource(url):<EOL><INDENT>report_types.append(ReportType(data=datum, account_id=account_id))<EOL><DEDENT>return report_types<EOL>", "docstring": "Returns the list of reports for the canvas account id.\n\nhttps://canvas.instructure.com/doc/api/account_reports.html#method.account_reports.available_reports", "id": "f15911:c1:m0"}
{"signature": "def get_statistics_by_account(self, account_id, term_id):", "body": "url = (\"<STR_LIT>\"<EOL>\"<STR_LIT>\") % (account_id, term_id)<EOL>return self._get_resource(url)<EOL>", "docstring": "Returns statistics for the given account_id and term_id.\n\nhttps://canvas.instructure.com/doc/api/analytics.html#method.analytics_api.department_statistics", "id": "f15915:c0:m2"}
{"signature": "def get_roles_in_account(self, account_id, params={}):", "body": "url = ACCOUNTS_API.format(account_id) + \"<STR_LIT>\"<EOL>roles = []<EOL>for datum in self._get_resource(url, params=params):<EOL><INDENT>roles.append(CanvasRole(data=datum))<EOL><DEDENT>return roles<EOL>", "docstring": "List the roles for an account, for the passed Canvas account ID.\n\nhttps://canvas.instructure.com/doc/api/roles.html#method.role_overrides.api_index", "id": "f15916:c0:m0"}
{"signature": "def get_role_by_account_sis_id(self, account_sis_id, role_id):", "body": "return self.get_role(self._sis_id(account_sis_id, sis_field=\"<STR_LIT>\"),<EOL>role_id)<EOL>", "docstring": "Get information about a single role, for the passed account SIS ID.", "id": "f15916:c0:m4"}
{"signature": "def get_account_by_sis_id(self, sis_id):", "body": "return self.get_account(self._sis_id(sis_id))<EOL>", "docstring": "Return account resource for given sis id.", "id": "f15917:c0:m1"}
{"signature": "def get_sub_accounts_by_sis_id(self, sis_id):", "body": "return self.get_sub_accounts(self._sis_id(sis_id), params={})<EOL>", "docstring": "Return list of subaccounts within the account with the passed sis id.", "id": "f15917:c0:m3"}
{"signature": "def update_auth_settings(self, account_id, auth_settings):", "body": "url = ACCOUNTS_API.format(account_id) + \"<STR_LIT>\"<EOL>data = self._put_resource(url, auth_settings.json_data())<EOL>return CanvasSSOSettings(data=data)<EOL>", "docstring": "Update the authentication settings for the passed account_id.\n\nhttps://canvas.instructure.com/doc/api/authentication_providers.html#method.account_authorization_configs.update_sso_settings", "id": "f15917:c0:m9"}
{"signature": "def _get_sessionless_launch_url(self, context, context_id, tool_id):", "body": "url = context.format(context_id) + \"<STR_LIT>\"<EOL>params = {\"<STR_LIT:id>\": tool_id}<EOL>return self._get_resource(url, params)<EOL>", "docstring": "Get a sessionless launch url for an external tool.\n\nhttps://canvas.instructure.com/doc/api/external_tools.html#method.external_tools.generate_sessionless_launch", "id": "f15920:c1:m13"}
{"signature": "def get_external_tools_in_account(self, account_id, params={}):", "body": "url = ACCOUNTS_API.format(account_id) + \"<STR_LIT>\"<EOL>external_tools = []<EOL>for data in self._get_paged_resource(url, params=params):<EOL><INDENT>external_tools.append(data)<EOL><DEDENT>return external_tools<EOL>", "docstring": "Return external tools for the passed canvas account id.\n\nhttps://canvas.instructure.com/doc/api/external_tools.html#method.external_tools.index", "id": "f15920:c1:m0"}
{"signature": "def _update_external_tool(self, context, context_id, external_tool_id,<EOL>json_data):", "body": "url = context.format(context_id) + \"<STR_LIT>\".format(<EOL>external_tool_id)<EOL>return self._put_resource(url, body=json_data)<EOL>", "docstring": "Update the external tool identified by external_tool_id with the passed\njson data.\n\ncontext is either COURSES_API or ACCOUNTS_API.\ncontext_id is the course_id or account_id, depending on context\n\nhttps://canvas.instructure.com/doc/api/external_tools.html#method.external_tools.update", "id": "f15920:c1:m9"}
{"signature": "def _delete_resource(self, url):", "body": "params = {}<EOL>self._set_as_user(params)<EOL>headers = {'<STR_LIT>': '<STR_LIT:application/json>',<EOL>'<STR_LIT>': '<STR_LIT>'}<EOL>url = url + self._params(params)<EOL>response = DAO.deleteURL(url, headers)<EOL>if not (response.status == <NUM_LIT:200> or response.status == <NUM_LIT>):<EOL><INDENT>raise DataFailureException(url, response.status, response.data)<EOL><DEDENT>return response<EOL>", "docstring": "Canvas DELETE method.", "id": "f15923:c1:m19"}
{"signature": "def __init__(self, per_page=DEFAULT_PAGINATION, as_user=MASQUERADING_USER):", "body": "self._per_page = per_page<EOL>self._as_user = as_user<EOL>self._re_canvas_id = re.compile(r'<STR_LIT>')<EOL>self._canvas_account_id = getattr(<EOL>settings, '<STR_LIT>', None)<EOL>", "docstring": "Prepares for paginated responses", "id": "f15923:c1:m0"}
{"signature": "def _sis_id(self, sis_id, sis_field='<STR_LIT>'):", "body": "return quote('<STR_LIT>'.format(sis_field, sis_id))<EOL>", "docstring": "generate sis_id object reference", "id": "f15923:c1:m10"}
{"signature": "def _post_resource(self, url, body):", "body": "params = {}<EOL>self._set_as_user(params)<EOL>headers = {'<STR_LIT:Content-Type>': '<STR_LIT:application/json>',<EOL>'<STR_LIT>': '<STR_LIT:application/json>',<EOL>'<STR_LIT>': '<STR_LIT>'}<EOL>url = url + self._params(params)<EOL>response = DAO.postURL(url, headers, json.dumps(body))<EOL>if not (response.status == <NUM_LIT:200> or response.status == <NUM_LIT>):<EOL><INDENT>raise DataFailureException(url, response.status, response.data)<EOL><DEDENT>return json.loads(response.data)<EOL>", "docstring": "Canvas POST method.", "id": "f15923:c1:m18"}
{"signature": "def get_users_for_sis_course_id(self, sis_course_id, params={}):", "body": "return self.get_users_for_course(<EOL>self._sis_id(sis_course_id, sis_field=\"<STR_LIT>\"), params)<EOL>", "docstring": "Returns a list of users for the given sis course id.", "id": "f15926:c0:m3"}
{"signature": "def create_user(self, user, account_id=None):", "body": "if account_id is None:<EOL><INDENT>account_id = self._canvas_account_id<EOL>if account_id is None:<EOL><INDENT>raise MissingAccountID()<EOL><DEDENT><DEDENT>url = ACCOUNTS_API.format(account_id) + \"<STR_LIT>\"<EOL>data = self._post_resource(url, user.post_data())<EOL>return CanvasUser(data=data)<EOL>", "docstring": "Create and return a new user and pseudonym for an account.\n\nhttps://canvas.instructure.com/doc/api/users.html#method.users.create", "id": "f15926:c0:m4"}
{"signature": "def get_user_by_sis_id(self, sis_user_id):", "body": "return self.get_user(self._sis_id(sis_user_id, sis_field=\"<STR_LIT:user>\"))<EOL>", "docstring": "Returns user profile data for the passed user sis id.\n\nhttps://canvas.instructure.com/doc/api/courses.html#method.courses.users", "id": "f15926:c0:m1"}
{"signature": "def update_user_login(self, login, account_id=None):", "body": "if account_id is None:<EOL><INDENT>account_id = self._canvas_account_id<EOL>if account_id is None:<EOL><INDENT>raise MissingAccountID<EOL><DEDENT><DEDENT>login_id = login.login_id<EOL>url = ACCOUNTS_API.format(account_id) + \"<STR_LIT>\".format(login_id)<EOL>data = self._put_resource(url, login.put_data())<EOL>return Login(data=data)<EOL>", "docstring": "Update an existing login for a user in the given account.\n\nhttps://canvas.instructure.com/doc/api/logins.html#method.pseudonyms.update", "id": "f15926:c0:m7"}
{"signature": "def get_user(self, user_id):", "body": "url = USERS_API.format(user_id) + \"<STR_LIT>\"<EOL>return CanvasUser(data=self._get_resource(url))<EOL>", "docstring": "Returns user profile data.\n\nhttps://canvas.instructure.com/doc/api/users.html#method.profile.settings", "id": "f15926:c0:m0"}
{"signature": "def get_enrollments_for_regid(self, regid, params={},<EOL>include_courses=True):", "body": "sis_user_id = self._sis_id(regid, sis_field=\"<STR_LIT:user>\")<EOL>url = USERS_API.format(sis_user_id) + \"<STR_LIT>\"<EOL>courses = Courses() if include_courses else None<EOL>enrollments = []<EOL>for datum in self._get_paged_resource(url, params=params):<EOL><INDENT>enrollment = CanvasEnrollment(data=datum)<EOL>if include_courses:<EOL><INDENT>course_id = datum[\"<STR_LIT>\"]<EOL>course = courses.get_course(course_id)<EOL>if course.sis_course_id is not None:<EOL><INDENT>enrollment.course = course<EOL>enrollment.course_url = course.course_url<EOL>enrollment.course_name = course.name<EOL>enrollment.sis_course_id = course.sis_course_id<EOL><DEDENT><DEDENT>else:<EOL><INDENT>enrollment.course_url = re.sub(<EOL>r'<STR_LIT>', '<STR_LIT>', enrollment.html_url)<EOL><DEDENT>enrollments.append(enrollment)<EOL><DEDENT>return enrollments<EOL>", "docstring": "Return a list of enrollments for the passed user regid.\n\nhttps://canvas.instructure.com/doc/api/enrollments.html#method.enrollments_api.index", "id": "f15927:c0:m4"}
{"signature": "def get_enrollments_for_section(self, section_id, params={}):", "body": "url = SECTIONS_API.format(section_id) + \"<STR_LIT>\"<EOL>enrollments = []<EOL>for datum in self._get_paged_resource(url, params=params):<EOL><INDENT>enrollments.append(CanvasEnrollment(data=datum))<EOL><DEDENT>return enrollments<EOL>", "docstring": "Return a list of all enrollments for the passed section_id.\n\nhttps://canvas.instructure.com/doc/api/enrollments.html#method.enrollments_api.index", "id": "f15927:c0:m2"}
{"signature": "def enroll_user(self, course_id, user_id, enrollment_type, params=None):", "body": "url = COURSES_API.format(course_id) + \"<STR_LIT>\"<EOL>if not params:<EOL><INDENT>params = {}<EOL><DEDENT>params[\"<STR_LIT>\"] = user_id<EOL>params[\"<STR_LIT:type>\"] = enrollment_type<EOL>data = self._post_resource(url, {\"<STR_LIT>\": params})<EOL>return CanvasEnrollment(data=data)<EOL>", "docstring": "Enroll a user into a course.\n\nhttps://canvas.instructure.com/doc/api/enrollments.html#method.enrollments_api.create", "id": "f15927:c0:m5"}
{"signature": "def get_course_by_sis_id(self, sis_course_id, params={}):", "body": "return self.get_course(self._sis_id(sis_course_id, sis_field=\"<STR_LIT>\"),<EOL>params)<EOL>", "docstring": "Return course resource for given sis id.", "id": "f15929:c0:m1"}
{"signature": "def get_courses_in_account(self, account_id, params={}):", "body": "if \"<STR_LIT>\" in params:<EOL><INDENT>params[\"<STR_LIT>\"] = \"<STR_LIT:true>\" if params[\"<STR_LIT>\"] else \"<STR_LIT>\"<EOL><DEDENT>url = ACCOUNTS_API.format(account_id) + \"<STR_LIT>\"<EOL>courses = []<EOL>for data in self._get_paged_resource(url, params=params):<EOL><INDENT>courses.append(CanvasCourse(data=data))<EOL><DEDENT>return courses<EOL>", "docstring": "Returns a list of courses for the passed account ID.\n\nhttps://canvas.instructure.com/doc/api/accounts.html#method.accounts.courses_api", "id": "f15929:c0:m2"}
{"signature": "def create_admin(self, account_id, user_id, role):", "body": "url = ADMINS_API.format(account_id)<EOL>body = {\"<STR_LIT>\": unquote(str(user_id)),<EOL>\"<STR_LIT>\": role,<EOL>\"<STR_LIT>\": False}<EOL>return CanvasAdmin(data=self._post_resource(url, body))<EOL>", "docstring": "Flag an existing user as an admin within the account.\n\nhttps://canvas.instructure.com/doc/api/admins.html#method.admins.create", "id": "f15931:c0:m2"}
{"signature": "def delete_admin_by_sis_id(self, sis_account_id, user_id, role):", "body": "return self.delete_admin(self._sis_id(sis_account_id), user_id, role)<EOL>", "docstring": "Remove an account admin role from a user for the account sis id.", "id": "f15931:c0:m5"}
{"signature": "def mult(p, n):", "body": "np = P()<EOL>while n >= <NUM_LIT:1>:<EOL><INDENT>if n % <NUM_LIT:2>:<EOL><INDENT>np = np + p<EOL><DEDENT>p = p + p<EOL>n = n // <NUM_LIT:2><EOL><DEDENT>return np<EOL>", "docstring": "Returns a Pattern that matches exactly n repetitions of Pattern p.", "id": "f15957:m3"}
{"signature": "def main():", "body": "help_ =", "docstring": "Command line entry point.", "id": "f15960:m11"}
{"signature": "def _arguments_as_list(arguments):", "body": "try:<EOL><INDENT>arguments_list = shlex.split(arguments)<EOL><DEDENT>except ValueError:<EOL><INDENT>arguments_list = arguments<EOL><DEDENT>return arguments_list<EOL>", "docstring": "Return the arguments as a list as expected by subprocess.Popen.\n\nThe arguments can be provided as a string that will be spitted to a list.\nThey can also be provided as a list, then the list will be returned\nuntouched.", "id": "f15960:m0"}
{"signature": "@contextlib.contextmanager<EOL>def tempdir():", "body": "dirpath = tempfile.mkdtemp()<EOL>try:<EOL><INDENT>with in_directory(dirpath):<EOL><INDENT>yield dirpath<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>shutil.rmtree(dirpath)<EOL><DEDENT>", "docstring": "Context manager that moves in a temporary directory.\n\n.. code::\n\n    # We are in the initial working directory\n    with tempdir():\n        # We are now in a temporary directory\n        ...\n    # We are back to the initial working directory.\n    # The temporary does not exist anymore.", "id": "f15962:m1"}
{"signature": "def assert_gro_equal(path, ref_path):", "body": "diff_out = StringIO()<EOL>with open(path) as stream, open(ref_path) as ref_stream:<EOL><INDENT>differences = compare_gro(stream, ref_stream)<EOL>format_gro_diff(differences, outstream=diff_out)<EOL>assert len(differences) == <NUM_LIT:0>, '<STR_LIT:\\n>' + diff_out.getvalue()<EOL><DEDENT>", "docstring": "Raise an AssertionError if two GRO files are not semantically identical.", "id": "f15962:m7"}
{"signature": "def realpath(*args):", "body": "if None in args:<EOL><INDENT>return None<EOL><DEDENT>return os.path.realpath(<EOL>os.path.expanduser(os.path.expandvars(os.path.join(*args)))<EOL>)<EOL>", "docstring": "Join all args and return the real path, rooted at /.\n    Expands '~', '~user', and environment variables such as :envvar`$HOME`.\n    Returns ``None`` if any of the args is ``None``.", "id": "f15962:m2"}
{"signature": "def _open_if_needed(handle):", "body": "if isinstance(handle, ContextStringIO):<EOL><INDENT>return handle<EOL><DEDENT>return open(handle)<EOL>", "docstring": "Return handle if it is a ContextStringIO instance else try to open it.", "id": "f15962:m8"}
{"signature": "def which(program):", "body": "def is_exe(fpath):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return os.path.isfile(fpath) and os.access(fpath, os.X_OK)<EOL><DEDENT>fpath, _ = os.path.split(program)<EOL>if fpath:<EOL><INDENT>real_program = realpath(program)<EOL>if is_exe(real_program):<EOL><INDENT>return real_program<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for path in os.environ[\"<STR_LIT>\"].split(os.pathsep):<EOL><INDENT>exe_file = os.path.join(path, program)<EOL>if is_exe(exe_file):<EOL><INDENT>return exe_file<EOL><DEDENT><DEDENT><DEDENT>return None<EOL>", "docstring": "Determine full path of executable *program* on :envvar:`PATH`.\n\n    (Jay at http://stackoverflow.com/questions/377017/test-if-executable-exists-in-python)", "id": "f15962:m3"}
{"signature": "def occupancy(grid, points, spacing=<NUM_LIT>):", "body": "distances = ((grid[:,None,:] - points[None,:,:])**<NUM_LIT:2>).sum(axis=<NUM_LIT:2>)<EOL>occupied = (distances < spacing).sum(axis=<NUM_LIT:1>)<EOL>return occupied<EOL>", "docstring": "Return a vector with the occupancy of each grid point for \n    given array of points", "id": "f15972:m0"}
{"signature": "def write_pdb(outfile, title, atoms, box):", "body": "<EOL>print('<STR_LIT>' + title, file=outfile)<EOL>print(pdbBoxString(box), file=outfile)<EOL>for idx, atname, resname, resid, x, y, z in atoms:<EOL><INDENT>print(pdbline % (idx % <NUM_LIT>, atname[:<NUM_LIT:4>], resname[:<NUM_LIT:3>], \"<STR_LIT>\",<EOL>resid % <NUM_LIT>, '<STR_LIT>', <NUM_LIT:10>*x, <NUM_LIT:10>*y, <NUM_LIT:10>*z, <NUM_LIT:0>, <NUM_LIT:0>, '<STR_LIT>'),<EOL>file=outfile)<EOL><DEDENT>", "docstring": "Write a PDB file.\n\nParameters\n----------\noutfile\n    The stream to write in.\ntitle\n    The title of the GRO file. Must be a single line.\natoms\n    An instance of Structure containing the atoms to write.\nbox\n    The periodic box as a 3x3 matrix.", "id": "f15972:m8"}
{"signature": "def proc_exit_cb(self, exit_status):", "body": "sys.exit(exit_status)<EOL>", "docstring": "When child exits we use the same exit status code", "id": "f15983:c2:m1"}
{"signature": "def process_pid(self):", "body": "if self.sprocess:<EOL><INDENT>return self.sprocess.pid<EOL><DEDENT>return -<NUM_LIT:1><EOL>", "docstring": "\\\n        when we are restarting, we want to keep sending heart beat, so any other single-beat\n        node will not pick it up.\n        hence we need a process-id as an identifier - even for a short period of time.\n        :return:", "id": "f15983:c2:m9"}
{"signature": "def cli_command_restart(self, msg):", "body": "info = '<STR_LIT>'<EOL>if self.state == State.RUNNING and self.sprocess and self.sprocess.proc:<EOL><INDENT>self.state = State.RESTARTING<EOL>self.sprocess.set_exit_callback(self.proc_exit_cb_restart)<EOL>self.sprocess.proc.kill()<EOL>info = '<STR_LIT>'<EOL><DEDENT>return info<EOL>", "docstring": "\\\n        restart the subprocess\n        i. we set our state to RESTARTING - on restarting we still send heartbeat\n        ii. we kill the subprocess\n        iii. we start again\n        iv. if its started we set our state to RUNNING, else we set it to WAITING\n\n        :param msg:\n        :return:", "id": "f15983:c2:m22"}
{"signature": "def source(target, inputstream=sys.stdin):", "body": "for line in inputstream:<EOL><INDENT>while len(line) > <NUM_LIT>:<EOL><INDENT>init, sep, line = line.partition('<STR_LIT:U+0020>')<EOL>assert len(init) <= <NUM_LIT><EOL>target.send('<STR_LIT>'.join([init, sep]))<EOL><DEDENT>target.send(line)<EOL><DEDENT>inputstream.close()<EOL>return target.close()<EOL>", "docstring": "Coroutine starting point. Produces text stream and forwards to consumers\n\n:param target: Target coroutine consumer\n:type target: Coroutine\n\n:param inputstream: Input Source\n:type inputstream: BufferedTextIO Object", "id": "f15992:m5"}
{"signature": "def accumulator(init, update):", "body": "return (<EOL>init + len(update)<EOL>if isinstance(init, int) else<EOL>init + update<EOL>)<EOL>", "docstring": "Generic accumulator function.\n\n.. code-block:: python\n\n    # Simplest Form\n    >>> a = 'this' + ' '\n    >>> b = 'that'\n    >>> c = functools.reduce(accumulator, a, b)\n    >>> c\n    'this that'\n\n    # The type of the initial value determines output type.\n    >>> a = 5\n    >>> b = Hello\n    >>> c = functools.reduce(accumulator, a, b)\n    >>> c\n    10\n\n:param init:  Initial Value\n:param update: Value to accumulate\n\n:return: Combined Values", "id": "f15992:m1"}
{"signature": "def run_migrations_online():", "body": "engine = engine_from_config(<EOL>config.get_section(config.config_ini_section),<EOL>prefix='<STR_LIT>',<EOL>poolclass=pool.NullPool<EOL>)<EOL>connection = engine.connect()<EOL>context.configure(<EOL>connection=connection,<EOL>target_metadata=target_metadata<EOL>)<EOL>try:<EOL><INDENT>with context.begin_transaction():<EOL><INDENT>context.run_migrations()<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>connection.close()<EOL><DEDENT>", "docstring": "Run migrations in 'online' mode.\n\n    In this scenario we need to create an Engine\n    and associate a connection with the context.", "id": "f16024:m1"}
{"signature": "def run_migrations_offline():", "body": "url = config.get_main_option(\"<STR_LIT>\")<EOL>context.configure(url=url, target_metadata=target_metadata)<EOL>with context.begin_transaction():<EOL><INDENT>context.run_migrations()<EOL><DEDENT>", "docstring": "Run migrations in 'offline' mode.\n\n    This configures the context with just a URL\n    and not an Engine, though an Engine is acceptable\n    here as well.  By skipping the Engine creation\n    we don't even need a DBAPI to be available.\n\n    Calls to context.execute() here emit the given string to the\n    script output.", "id": "f16024:m0"}
{"signature": "async def set_autoconnect_mode(mode):", "body": "jar = aiohttp.CookieJar(unsafe=True)<EOL>websession = aiohttp.ClientSession(cookie_jar=jar)<EOL>try:<EOL><INDENT>modem = eternalegypt.Modem(hostname=sys.argv[<NUM_LIT:1>], websession=websession)<EOL>await modem.login(password=sys.argv[<NUM_LIT:2>])<EOL>await modem.set_autoconnect_mode(mode)<EOL>await modem.logout()<EOL><DEDENT>except eternalegypt.Error:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>await websession.close()<EOL>", "docstring": "Example of printing the current upstream.", "id": "f16040:m0"}
{"signature": "async def logout(self):", "body": "self.websession = None<EOL>self.token = None<EOL>", "docstring": "Cleanup resources.", "id": "f16044:c3:m3"}
{"signature": "@autologin<EOL><INDENT>async def set_autoconnect_mode(self, mode):<DEDENT>", "body": "modes = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>}<EOL>if mode not in modes.keys():<EOL><INDENT>_LOGGER.error(\"<STR_LIT>\", mode, \"<STR_LIT:/>\".join(modes.keys()))<EOL>return<EOL><DEDENT>async with self._config_call('<STR_LIT>', modes[mode]) as response:<EOL><INDENT>_LOGGER.debug(\"<STR_LIT>\", mode)<EOL><DEDENT>", "docstring": "Set autoconnect mode.", "id": "f16044:c3:m10"}
{"signature": "@autologin<EOL><INDENT>async def set_failover_mode(self, mode):<DEDENT>", "body": "modes = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>}<EOL>if mode not in modes.keys():<EOL><INDENT>_LOGGER.error(\"<STR_LIT>\", mode, \"<STR_LIT:/>\".join(modes.keys()))<EOL>return<EOL><DEDENT>async with self._config_call('<STR_LIT>', modes[mode]) as response:<EOL><INDENT>_LOGGER.debug(\"<STR_LIT>\", mode)<EOL><DEDENT>", "docstring": "Set failover mode.", "id": "f16044:c3:m9"}
{"signature": "@autologin<EOL><INDENT>async def sms(self, phone, message):<DEDENT>", "body": "_LOGGER.debug(\"<STR_LIT>\",<EOL>phone, self._baseurl, len(message))<EOL>url = self._url('<STR_LIT>')<EOL>data = {<EOL>'<STR_LIT>': phone,<EOL>'<STR_LIT>': message,<EOL>'<STR_LIT>': __name__,<EOL>'<STR_LIT:action>': '<STR_LIT>',<EOL>'<STR_LIT>': self.token<EOL>}<EOL>async with self.websession.post(url, data=data) as response:<EOL><INDENT>_LOGGER.debug(\"<STR_LIT>\", response.status)<EOL><DEDENT>", "docstring": "Send a message.", "id": "f16044:c3:m5"}
{"signature": "@autologin<EOL><INDENT>async def delete_sms(self, sms_id):<DEDENT>", "body": "async with self._config_call('<STR_LIT>', sms_id) as response:<EOL><INDENT>_LOGGER.debug(\"<STR_LIT>\", sms_id, response.status)<EOL><DEDENT>", "docstring": "Delete a message.", "id": "f16044:c3:m8"}
{"signature": "@autologin<EOL><INDENT>async def connect_lte(self):<DEDENT>", "body": "async with self._config_call('<STR_LIT>', '<STR_LIT>') as response:<EOL><INDENT>_LOGGER.debug(\"<STR_LIT>\", response.status)<EOL><DEDENT>", "docstring": "Do an LTE reconnect.", "id": "f16044:c3:m7"}
{"signature": "def generate_changeset(old, new, comment=None):", "body": "rrsets_tag = '<STR_LIT>' % R53_XMLNS<EOL>if rrsets_tag not in (old.tag, new.tag):<EOL><INDENT>log.error('<STR_LIT>' % (old.tag, new.tag))<EOL>raise InvalidArgumentException()<EOL><DEDENT>if comment is None:<EOL><INDENT>comment = '<STR_LIT>' % (<EOL>__file__,<EOL>os.environ['<STR_LIT>'],<EOL>socket.gethostname(),<EOL>time.strftime('<STR_LIT>'))<EOL><DEDENT>root = lxml.etree.XML(\"\"\"<STR_LIT>\"\"\" % (<EOL>R53_XMLNS, comment), parser=XML_PARSER)<EOL>changesroot = root.find('<STR_LIT>' % R53_XMLNS)<EOL>old = normalize_rrs(old)<EOL>new = normalize_rrs(new)<EOL>oldset = set([lxml.etree.tostring(x).rstrip() for x in old])<EOL>newset = set([lxml.etree.tostring(x).rstrip() for x in new])<EOL>if oldset == newset:<EOL><INDENT>return None<EOL><DEDENT>for rrs in old:<EOL><INDENT>rrsst = lxml.etree.tostring(rrs).rstrip()<EOL>if rrsst not in newset:<EOL><INDENT>log.debug(\"<STR_LIT>\")<EOL>log.debug(rrsst)<EOL>change = lxml.etree.XML('<STR_LIT>' % R53_XMLNS, parser=XML_PARSER)<EOL>change.append(rrs)<EOL>changesroot.append(change)<EOL><DEDENT><DEDENT>for rrs in new:<EOL><INDENT>rrsst = lxml.etree.tostring(rrs).rstrip()<EOL>if rrsst not in oldset:<EOL><INDENT>log.debug(\"<STR_LIT>\")<EOL>log.debug(rrsst)<EOL>change = lxml.etree.XML('<STR_LIT>' % R53_XMLNS, parser=XML_PARSER)<EOL>change.append(rrs)<EOL>changesroot.append(change)<EOL><DEDENT><DEDENT>return root<EOL>", "docstring": "Diff two XML configs and return an object with changes to be written.\n\n    Args: old, new: lxml.etree.Element (<ResourceRecordSets>).\n    Returns: lxml.etree.ETree (<ChangeResourceRecordSetsRequest>) or None", "id": "f16052:m4"}
{"signature": "@validate(addr=int, cmd=int, vals=list)<EOL><INDENT>def write_block_data(self, addr, cmd, vals):<DEDENT>", "body": "self._set_addr(addr)<EOL>data = ffi.new(\"<STR_LIT>\")<EOL>list_to_smbus_data(data, vals)<EOL>if SMBUS.i2c_smbus_access(self._fd,<EOL>int2byte(SMBUS.I2C_SMBUS_WRITE),<EOL>ffi.cast(\"<STR_LIT>\", cmd),<EOL>SMBUS.I2C_SMBUS_BLOCK_DATA,<EOL>data):<EOL><INDENT>raise IOError(ffi.errno)<EOL><DEDENT>", "docstring": "write_block_data(addr, cmd, vals)\n\n        Perform SMBus Write Block Data transaction.", "id": "f16062:c0:m14"}
{"signature": "@validate(addr=int, cmd=int)<EOL><INDENT>def read_byte_data(self, addr, cmd):<DEDENT>", "body": "self._set_addr(addr)<EOL>res = SMBUS.i2c_smbus_read_byte_data(self._fd, ffi.cast(\"<STR_LIT>\", cmd))<EOL>if res == -<NUM_LIT:1>:<EOL><INDENT>raise IOError(ffi.errno)<EOL><DEDENT>return res<EOL>", "docstring": "read_byte_data(addr, cmd) -> result\n\n        Perform SMBus Read Byte Data transaction.", "id": "f16062:c0:m8"}
{"signature": "@validate(addr=int, val=int)<EOL><INDENT>def write_byte(self, addr, val):<DEDENT>", "body": "self._set_addr(addr)<EOL>if SMBUS.i2c_smbus_write_byte(self._fd, ffi.cast(\"<STR_LIT>\", val)) == -<NUM_LIT:1>:<EOL><INDENT>raise IOError(ffi.errno)<EOL><DEDENT>", "docstring": "write_byte(addr, val)\n\n        Perform SMBus Write Byte transaction.", "id": "f16062:c0:m7"}
{"signature": "@validate(addr=int, cmd=int)<EOL><INDENT>def read_block_data(self, addr, cmd):<DEDENT>", "body": "<EOL>self._set_addr(addr)<EOL>data = ffi.new(\"<STR_LIT>\")<EOL>if SMBUS.i2c_smbus_access(self._fd,<EOL>int2byte(SMBUS.I2C_SMBUS_READ),<EOL>ffi.cast(\"<STR_LIT>\", cmd),<EOL>SMBUS.I2C_SMBUS_BLOCK_DATA,<EOL>data):<EOL><INDENT>raise IOError(ffi.errno)<EOL><DEDENT>return smbus_data_to_list(data)<EOL>", "docstring": "read_block_data(addr, cmd) -> results\n\n        Perform SMBus Read Block Data transaction.", "id": "f16062:c0:m13"}
{"signature": "def _redis(self, **kwargs):", "body": "kwargs.update(dict(<EOL>host=self._config('<STR_LIT>', '<STR_LIT:localhost>'),<EOL>port=self._config('<STR_LIT>', <NUM_LIT>),<EOL>password=self._config('<STR_LIT>', None),<EOL>db=self._config('<STR_LIT>', <NUM_LIT:0>),<EOL>key_prefix=self._config('<STR_LIT>', None),<EOL>))<EOL>return RedisCache(**kwargs)<EOL>", "docstring": "Returns a :class:`RedisCache` instance", "id": "f16081:c0:m6"}
{"signature": "def authorize(self, callback_uri, code=<NUM_LIT>):", "body": "raise NotImplementedError<EOL>", "docstring": "Redirects to third-part URL and authorizes.\n\n        :param callback_uri: the callback URI. if you generate it with the\n                             :func:`~flask.url_for`, don't forget to use the\n                             ``_external=True`` keyword argument.\n        :param code: default is 302. the HTTP code for redirection.\n        :returns: the redirection response.", "id": "f16084:c0:m6"}
{"signature": "def make_client(self, token):", "body": "if isinstance(token, dict):<EOL><INDENT>access_token = token['<STR_LIT>']<EOL>access_token_secret = token['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>access_token, access_token_secret = token<EOL><DEDENT>return self.make_oauth_session(<EOL>resource_owner_key=access_token,<EOL>resource_owner_secret=access_token_secret)<EOL>", "docstring": "Creates a client with specific access token pair.\n\n        :param token: a tuple of access token pair ``(token, token_secret)``\n                      or a dictionary of access token response.\n        :returns: a :class:`requests_oauthlib.oauth1_session.OAuth1Session`\n                  object.", "id": "f16084:c1:m0"}
{"signature": "def remote_app(self, name, version=None, **kwargs):", "body": "if version is None:<EOL><INDENT>if '<STR_LIT>' in kwargs:<EOL><INDENT>version = '<STR_LIT:1>'<EOL><DEDENT>else:<EOL><INDENT>version = '<STR_LIT:2>'<EOL><DEDENT><DEDENT>if version == '<STR_LIT:1>':<EOL><INDENT>remote_app = OAuth1Application(name, clients=cached_clients)<EOL><DEDENT>elif version == '<STR_LIT:2>':<EOL><INDENT>remote_app = OAuth2Application(name, clients=cached_clients)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' % version)<EOL><DEDENT>return self.add_remote_app(remote_app, **kwargs)<EOL>", "docstring": "Creates and adds new remote application.\n\n        :param name: the remote application's name.\n        :param version: '1' or '2', the version code of OAuth protocol.\n        :param kwargs: the attributes of remote application.", "id": "f16085:c0:m3"}
{"signature": "def kwargs_processor(self, fn):", "body": "self._kwargs_processor = fn<EOL>return fn<EOL>", "docstring": "Sets a function to process kwargs before creating any app.", "id": "f16088:c0:m3"}
{"signature": "def set(self, token, request, *args, **kwargs):", "body": "if hasattr(request, '<STR_LIT:user>') and request.user:<EOL><INDENT>user = request.user<EOL><DEDENT>elif self.current_user:<EOL><INDENT>user = self.current_user()<EOL><DEDENT>client = request.client<EOL>tokens = self.query.filter_by(<EOL>client_id=client.client_id,<EOL>user_id=user.id).all()<EOL>if tokens:<EOL><INDENT>for tk in tokens:<EOL><INDENT>self.session.delete(tk)<EOL><DEDENT>self.session.commit()<EOL><DEDENT>expires_in = token.get('<STR_LIT>')<EOL>expires = datetime.utcnow() + timedelta(seconds=expires_in)<EOL>tok = self.model(**token)<EOL>tok.expires = expires<EOL>tok.client_id = client.client_id<EOL>tok.user_id = user.id<EOL>self.session.add(tok)<EOL>self.session.commit()<EOL>return tok<EOL>", "docstring": "Creates a Token object and removes all expired tokens that belong\n        to the user\n\n        :param token: token object\n        :param request: OAuthlib request object", "id": "f16089:c4:m2"}
{"signature": "def get(self, client_id, code):", "body": "return self.query.filter_by(client_id=client_id, code=code).first()<EOL>", "docstring": "Get the Grant object with the given client ID and code\n\n        :param client_id: ID of the client\n        :param code:", "id": "f16089:c5:m2"}
{"signature": "def set(self, client_id, code, request, *args, **kwargs):", "body": "expires = datetime.utcnow() + timedelta(seconds=<NUM_LIT:100>)<EOL>grant = self.model(<EOL>client_id=request.client.client_id,<EOL>code=code['<STR_LIT:code>'],<EOL>redirect_uri=request.redirect_uri,<EOL>scope='<STR_LIT:U+0020>'.join(request.scopes),<EOL>user=self.current_user(),<EOL>expires=expires<EOL>)<EOL>self.session.add(grant)<EOL>self.session.commit()<EOL>", "docstring": "Creates Grant object with the given params\n\n        :param client_id: ID of the client\n        :param code:\n        :param request: OAuthlib request object", "id": "f16089:c5:m1"}
{"signature": "def authorized_handler(self, f):", "body": "@wraps(f)<EOL>def decorated(*args, **kwargs):<EOL><INDENT>log.warn(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL>data = self.authorized_response()<EOL>return f(*((data,) + args), **kwargs)<EOL><DEDENT>return decorated<EOL>", "docstring": "Handles an OAuth callback.\n\n        .. versionchanged:: 0.7\n           @authorized_handler is deprecated in favor of authorized_response.", "id": "f16091:c3:m33"}
{"signature": "@property<EOL><INDENT>def status(self):<DEDENT>", "body": "return self._resp.code<EOL>", "docstring": "The status code of the response.", "id": "f16091:c1:m1"}
{"signature": "def init_app(self, app):", "body": "self.app = app<EOL>app.extensions = getattr(app, '<STR_LIT>', {})<EOL>app.extensions[self.state_key] = self<EOL>", "docstring": "Init app with Flask instance.\n\n        You can also pass the instance of Flask later::\n\n            oauth = OAuth()\n            oauth.init_app(app)", "id": "f16091:c0:m1"}
{"signature": "def parse_response(resp, content, strict=False, content_type=None):", "body": "if not content_type:<EOL><INDENT>content_type = resp.headers.get('<STR_LIT>', '<STR_LIT:application/json>')<EOL><DEDENT>ct, options = parse_options_header(content_type)<EOL>if ct in ('<STR_LIT:application/json>', '<STR_LIT>'):<EOL><INDENT>if not content:<EOL><INDENT>return {}<EOL><DEDENT>return json.loads(content)<EOL><DEDENT>if ct in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>return get_etree().fromstring(content)<EOL><DEDENT>if ct != '<STR_LIT>' and strict:<EOL><INDENT>return content<EOL><DEDENT>charset = options.get('<STR_LIT>', '<STR_LIT:utf-8>')<EOL>return url_decode(content, charset=charset).to_dict()<EOL>", "docstring": "Parse the response returned by :meth:`OAuthRemoteApp.http_request`.\n\n    :param resp: response of http_request\n    :param content: content of the response\n    :param strict: strict mode for form urlencoded content\n    :param content_type: assign a content type manually", "id": "f16091:m1"}
{"signature": "def remote_app(self, name, register=True, **kwargs):", "body": "remote = OAuthRemoteApp(self, name, **kwargs)<EOL>if register:<EOL><INDENT>assert name not in self.remote_apps<EOL>self.remote_apps[name] = remote<EOL><DEDENT>return remote<EOL>", "docstring": "Registers a new remote application.\n\n        :param name: the name of the remote application\n        :param register: whether the remote app will be registered\n\n        Find more parameters from :class:`OAuthRemoteApp`.", "id": "f16091:c0:m2"}
{"signature": "def put(self, *args, **kwargs):", "body": "kwargs['<STR_LIT>'] = '<STR_LIT>'<EOL>return self.request(*args, **kwargs)<EOL>", "docstring": "Sends a ``PUT`` request. Accepts the same parameters as\n        :meth:`request`.", "id": "f16091:c3:m20"}
{"signature": "def handle_oauth1_response(self, args):", "body": "client = self.make_client()<EOL>client.verifier = args.get('<STR_LIT>')<EOL>tup = session.get('<STR_LIT>' % self.name)<EOL>if not tup:<EOL><INDENT>raise OAuthException(<EOL>'<STR_LIT>',<EOL>type='<STR_LIT>'<EOL>)<EOL><DEDENT>client.resource_owner_key = tup[<NUM_LIT:0>]<EOL>client.resource_owner_secret = tup[<NUM_LIT:1>]<EOL>uri, headers, data = client.sign(<EOL>self.expand_url(self.access_token_url),<EOL>_encode(self.access_token_method)<EOL>)<EOL>headers.update(self._access_token_headers)<EOL>resp, content = self.http_request(<EOL>uri, headers, to_bytes(data, self.encoding),<EOL>method=self.access_token_method<EOL>)<EOL>data = parse_response(resp, content)<EOL>if resp.code not in (<NUM_LIT:200>, <NUM_LIT>):<EOL><INDENT>raise OAuthException(<EOL>'<STR_LIT>' % self.name,<EOL>type='<STR_LIT>', data=data<EOL>)<EOL><DEDENT>return data<EOL>", "docstring": "Handles an oauth1 authorization response.", "id": "f16091:c3:m29"}
{"signature": "def to_bytes(text, encoding='<STR_LIT:utf-8>'):", "body": "if not text:<EOL><INDENT>return text<EOL><DEDENT>if not isinstance(text, bytes_type):<EOL><INDENT>text = text.encode(encoding)<EOL><DEDENT>return text<EOL>", "docstring": "Make sure text is bytes type.", "id": "f16093:m2"}
{"signature": "def decode_base64(text, encoding='<STR_LIT:utf-8>'):", "body": "text = to_bytes(text, encoding)<EOL>return to_unicode(base64.b64decode(text), encoding)<EOL>", "docstring": "Decode base64 string.", "id": "f16093:m3"}
{"signature": "def _get_uri_from_request(request):", "body": "uri = request.base_url<EOL>if request.query_string:<EOL><INDENT>uri += '<STR_LIT:?>' + request.query_string.decode('<STR_LIT:utf-8>')<EOL><DEDENT>return uri<EOL>", "docstring": "The uri returned from request.uri is not properly urlencoded\n(sometimes it's partially urldecoded) This is a weird hack to get\nwerkzeug to return the proper urlencoded string uri", "id": "f16093:m0"}
{"signature": "def validate_client_id(self, client_id, request, *args, **kwargs):", "body": "log.debug('<STR_LIT>', client_id)<EOL>client = request.client or self._clientgetter(client_id)<EOL>if client:<EOL><INDENT>request.client = client<EOL>return True<EOL><DEDENT>return False<EOL>", "docstring": "Ensure client_id belong to a valid and active client.", "id": "f16094:c1:m14"}
{"signature": "def authenticate_client(self, request, *args, **kwargs):", "body": "client_id, client_secret = self._get_client_creds_from_request(request)<EOL>log.debug('<STR_LIT>', client_id)<EOL>client = self._clientgetter(client_id)<EOL>if not client:<EOL><INDENT>log.debug('<STR_LIT>')<EOL>return False<EOL><DEDENT>request.client = client<EOL>if hasattr(client, '<STR_LIT>') and client.client_secret != client_secret:<EOL><INDENT>log.debug('<STR_LIT>')<EOL>return False<EOL><DEDENT>log.debug('<STR_LIT>')<EOL>return True<EOL>", "docstring": "Authenticate itself in other means.\n\n        Other means means is described in `Section 3.2.1`_.\n\n        .. _`Section 3.2.1`: http://tools.ietf.org/html/rfc6749#section-3.2.1", "id": "f16094:c1:m3"}
{"signature": "def after_request(self, f):", "body": "self._after_request_funcs.append(f)<EOL>return f<EOL>", "docstring": "Register functions to be invoked after accessing the resource.\n\n        The function accepts ``valid`` and ``request`` as parameters,\n        and it should return a tuple of them::\n\n            @oauth.after_request\n            def valid_after_request(valid, oauth):\n                if oauth.user in black_list:\n                    return False, oauth\n                return valid, oauth", "id": "f16094:c0:m6"}
{"signature": "def usergetter(self, f):", "body": "self._usergetter = f<EOL>return f<EOL>", "docstring": "Register a function as the user getter.\n\n        This decorator is only required for **password credential**\n        authorization::\n\n            @oauth.usergetter\n            def get_user(username, password, client, request,\n                         *args, **kwargs):\n                # client: current request client\n                if not client.has_password_credential_permission:\n                    return None\n                user = User.get_user_by_username(username)\n                if not user.validate_password(password):\n                    return None\n\n                # parameter `request` is an OAuthlib Request object.\n                # maybe you will need it somewhere\n                return user", "id": "f16094:c0:m10"}
{"signature": "def require_oauth(self, *scopes):", "body": "def wrapper(f):<EOL><INDENT>@wraps(f)<EOL>def decorated(*args, **kwargs):<EOL><INDENT>for func in self._before_request_funcs:<EOL><INDENT>func()<EOL><DEDENT>if hasattr(request, '<STR_LIT>') and request.oauth:<EOL><INDENT>return f(*args, **kwargs)<EOL><DEDENT>valid, req = self.verify_request(scopes)<EOL>for func in self._after_request_funcs:<EOL><INDENT>valid, req = func(valid, req)<EOL><DEDENT>if not valid:<EOL><INDENT>if self._invalid_response:<EOL><INDENT>return self._invalid_response(req)<EOL><DEDENT>return abort(<NUM_LIT>)<EOL><DEDENT>request.oauth = req<EOL>return f(*args, **kwargs)<EOL><DEDENT>return decorated<EOL><DEDENT>return wrapper<EOL>", "docstring": "Protect resource with specified scopes.", "id": "f16094:c0:m20"}
{"signature": "def tokensetter(self, f):", "body": "self._tokensetter = f<EOL>return f<EOL>", "docstring": "Register a function to save the bearer token.\n\n        The setter accepts two parameters at least, one is token,\n        the other is request::\n\n            @oauth.tokensetter\n            def set_token(token, request, *args, **kwargs):\n                save_token(token, request.client, request.user)\n\n        The parameter token is a dict, that looks like::\n\n            {\n                u'access_token': u'6JwgO77PApxsFCU8Quz0pnL9s23016',\n                u'token_type': u'Bearer',\n                u'expires_in': 3600,\n                u'scope': u'email address'\n            }\n\n        The request is an object, that contains an user object and a\n        client object.", "id": "f16094:c0:m12"}
{"signature": "def grantgetter(self, f):", "body": "self._grantgetter = f<EOL>return f<EOL>", "docstring": "Register a function as the grant getter.\n\n        The function accepts `client_id`, `code` and more::\n\n            @oauth.grantgetter\n            def grant(client_id, code):\n                return get_grant(client_id, code)\n\n        It returns a grant object with at least these information:\n\n            - delete: A function to delete itself", "id": "f16094:c0:m13"}
{"signature": "def validate_refresh_token(self, refresh_token, client, request,<EOL>*args, **kwargs):", "body": "token = self._tokengetter(refresh_token=refresh_token)<EOL>if token and token.client_id == client.client_id:<EOL><INDENT>request.client_id = token.client_id<EOL>request.user = token.user<EOL>return True<EOL><DEDENT>return False<EOL>", "docstring": "Ensure the token is valid and belongs to the client\n\n        This method is used by the authorization code grant indirectly by\n        issuing refresh tokens, resource owner password credentials grant\n        (also indirectly) and the refresh token grant.", "id": "f16094:c1:m18"}
{"signature": "def get_default_scopes(self, client_id, request, *args, **kwargs):", "body": "request.client = request.client or self._clientgetter(client_id)<EOL>scopes = request.client.default_scopes<EOL>log.debug('<STR_LIT>', scopes)<EOL>return scopes<EOL>", "docstring": "Default scopes for the given client.", "id": "f16094:c1:m9"}
{"signature": "def confirm_redirect_uri(self, client_id, code, redirect_uri, client,<EOL>*args, **kwargs):", "body": "client = client or self._clientgetter(client_id)<EOL>log.debug('<STR_LIT>',<EOL>client.client_id, code)<EOL>grant = self._grantgetter(client_id=client.client_id, code=code)<EOL>if not grant:<EOL><INDENT>log.debug('<STR_LIT>')<EOL>return False<EOL><DEDENT>if hasattr(grant, '<STR_LIT>'):<EOL><INDENT>return grant.validate_redirect_uri(redirect_uri)<EOL><DEDENT>log.debug('<STR_LIT>',<EOL>grant.redirect_uri, redirect_uri)<EOL>testing = '<STR_LIT>' in os.environ<EOL>if testing and redirect_uri is None:<EOL><INDENT>return True<EOL><DEDENT>return grant.redirect_uri == redirect_uri<EOL>", "docstring": "Ensure client is authorized to redirect to the redirect_uri.\n\n        This method is used in the authorization code grant flow. It will\n        compare redirect_uri and the one in grant token strictly, you can\n        add a `validate_redirect_uri` function on grant for a customized\n        validation.", "id": "f16094:c1:m5"}
{"signature": "def get_original_scopes(self, refresh_token, request, *args, **kwargs):", "body": "log.debug('<STR_LIT>')<EOL>tok = self._tokengetter(refresh_token=refresh_token)<EOL>return tok.scopes<EOL>", "docstring": "Get the list of scopes associated with the refresh token.\n\n        This method is used in the refresh token grant flow.  We return\n        the scope of the token to be refreshed so it can be applied to the\n        new access token.", "id": "f16094:c1:m6"}
{"signature": "def confirm_authorization_request(self):", "body": "server = self.server<EOL>uri, http_method, body, headers = extract_params()<EOL>try:<EOL><INDENT>realms, credentials = server.get_realms_and_credentials(<EOL>uri, http_method=http_method, body=body, headers=headers<EOL>)<EOL>ret = server.create_authorization_response(<EOL>uri, http_method, body, headers, realms, credentials<EOL>)<EOL>log.debug('<STR_LIT>')<EOL>return create_response(*ret)<EOL><DEDENT>except errors.OAuth1Error as e:<EOL><INDENT>return redirect(e.in_uri(self.error_uri))<EOL><DEDENT>except errors.InvalidClientError as e:<EOL><INDENT>return redirect(e.in_uri(self.error_uri))<EOL><DEDENT>", "docstring": "When consumer confirm the authrozation.", "id": "f16096:c0:m16"}
{"signature": "@cached_property<EOL><INDENT>def server(self):<DEDENT>", "body": "if hasattr(self, '<STR_LIT>'):<EOL><INDENT>return Server(self._validator)<EOL><DEDENT>if hasattr(self, '<STR_LIT>') andhasattr(self, '<STR_LIT>') andhasattr(self, '<STR_LIT>') andhasattr(self, '<STR_LIT>') andhasattr(self, '<STR_LIT>') andhasattr(self, '<STR_LIT>') andhasattr(self, '<STR_LIT>') andhasattr(self, '<STR_LIT>') andhasattr(self, '<STR_LIT>'):<EOL><INDENT>validator = OAuth1RequestValidator(<EOL>clientgetter=self._clientgetter,<EOL>tokengetter=self._tokengetter,<EOL>tokensetter=self._tokensetter,<EOL>grantgetter=self._grantgetter,<EOL>grantsetter=self._grantsetter,<EOL>noncegetter=self._noncegetter,<EOL>noncesetter=self._noncesetter,<EOL>verifiergetter=self._verifiergetter,<EOL>verifiersetter=self._verifiersetter,<EOL>config=self.app.config,<EOL>)<EOL>self._validator = validator<EOL>server = Server(validator)<EOL>if self.app.testing:<EOL><INDENT>server._check_signature = lambda *args, **kwargs: True<EOL><DEDENT>return server<EOL><DEDENT>raise RuntimeError(<EOL>'<STR_LIT>'<EOL>)<EOL>", "docstring": "All in one endpoints. This property is created automaticly\nif you have implemented all the getters and setters.", "id": "f16096:c0:m3"}
{"signature": "@property<EOL><INDENT>def allowed_signature_methods(self):<DEDENT>", "body": "return self._config.get(<EOL>'<STR_LIT>',<EOL>SIGNATURE_METHODS,<EOL>)<EOL>", "docstring": "Allowed signature methods.\n\n        Default value: SIGNATURE_HMAC and SIGNATURE_RSA.\n\n        You can customize with Flask Config:\n\n            - OAUTH1_PROVIDER_SIGNATURE_METHODS", "id": "f16096:c1:m1"}
{"signature": "@property<EOL><INDENT>def enforce_ssl(self):<DEDENT>", "body": "return self._config.get('<STR_LIT>', True)<EOL>", "docstring": "Enforce SSL request.\n\n        Default is True. You can customize with:\n\n            - OAUTH1_PROVIDER_ENFORCE_SSL", "id": "f16096:c1:m8"}
{"signature": "def verifiergetter(self, f):", "body": "self._verifiergetter = f<EOL>return f<EOL>", "docstring": "Register a function as the verifier getter.\n\n        The return verifier object should at least contain a user object\n        which is the current user.\n\n        The implemented code looks like::\n\n            @oauth.verifiergetter\n            def load_verifier(verifier, token):\n                data = Verifier.get(verifier)\n                if data.request_token == token:\n                    # check verifier for safety\n                    return data\n                return data", "id": "f16096:c0:m13"}
{"signature": "@cached_property<EOL><INDENT>def error_uri(self):<DEDENT>", "body": "error_uri = self.app.config.get('<STR_LIT>')<EOL>if error_uri:<EOL><INDENT>return error_uri<EOL><DEDENT>error_endpoint = self.app.config.get('<STR_LIT>')<EOL>if error_endpoint:<EOL><INDENT>return url_for(error_endpoint)<EOL><DEDENT>return '<STR_LIT>'<EOL>", "docstring": "The error page URI.\n\n        When something turns error, it will redirect to this error page.\n        You can configure the error page URI with Flask config::\n\n            OAUTH1_PROVIDER_ERROR_URI = '/error'\n\n        You can also define the error page by a named endpoint::\n\n            OAUTH1_PROVIDER_ERROR_ENDPOINT = 'oauth.error'", "id": "f16096:c0:m2"}
{"signature": "def get_client_secret(self, client_key, request):", "body": "log.debug('<STR_LIT>', client_key)<EOL>if not request.client:<EOL><INDENT>request.client = self._clientgetter(client_key=client_key)<EOL><DEDENT>if request.client:<EOL><INDENT>return request.client.client_secret<EOL><DEDENT>return None<EOL>", "docstring": "Get client secret.\n\n        The client object must has ``client_secret`` attribute.", "id": "f16096:c1:m12"}
{"signature": "def validate_timestamp_and_nonce(self, client_key, timestamp, nonce,<EOL>request, request_token=None,<EOL>access_token=None):", "body": "log.debug('<STR_LIT>', client_key)<EOL>nonce_exists = self._noncegetter(<EOL>client_key=client_key, timestamp=timestamp,<EOL>nonce=nonce, request_token=request_token,<EOL>access_token=access_token<EOL>)<EOL>if nonce_exists:<EOL><INDENT>return False<EOL><DEDENT>self._noncesetter(<EOL>client_key=client_key, timestamp=timestamp,<EOL>nonce=nonce, request_token=request_token,<EOL>access_token=access_token<EOL>)<EOL>return True<EOL>", "docstring": "Validate the timestamp and nonce is used or not.", "id": "f16096:c1:m23"}
{"signature": "def clientgetter(self, f):", "body": "self._clientgetter = f<EOL>return f<EOL>", "docstring": "Register a function as the client getter.\n\n        The function accepts one parameter `client_key`, and it returns\n        a client object with at least these information:\n\n            - client_key: A random string\n            - client_secret: A random string\n            - redirect_uris: A list of redirect uris\n            - default_realms: Default scopes of the client\n\n        The client may contain more information, which is suggested:\n\n            - default_redirect_uri: One of the redirect uris\n\n        Implement the client getter::\n\n            @oauth.clientgetter\n            def get_client(client_key):\n                client = get_client_model(client_key)\n                # Client is an object\n                return client", "id": "f16096:c0:m6"}
{"signature": "def get_redirect_uri(self, token, request):", "body": "log.debug('<STR_LIT>', token)<EOL>tok = request.request_token or self._grantgetter(token=token)<EOL>return tok.redirect_uri<EOL>", "docstring": "Redirect uri for this request token.", "id": "f16096:c1:m17"}
{"signature": "def on_click(self, element, event):", "body": "return False<EOL>", "docstring": "Override this method in subclass to process\n        click events. Note that element can be None\n        (click on empty space).", "id": "f16117:c0:m28"}
{"signature": "def copy(self):", "body": "pen = Pen()<EOL>pen.__dict__ = self.__dict__.copy()<EOL>return pen<EOL>", "docstring": "Create a copy of this pen.", "id": "f16120:c0:m1"}
{"signature": "def load_and_parse(self):", "body": "f = open(self.file_path, \"<STR_LIT:r>\")<EOL>metrics_json = f.read()<EOL>self.metrics = json.loads(metrics_json)<EOL>", "docstring": "Load the metrics file from the given path", "id": "f16189:c0:m3"}
{"signature": "def extract_fields(self, metric):", "body": "m = {}<EOL>if '<STR_LIT:name>' in metric:<EOL><INDENT>m['<STR_LIT:name>'] = metric['<STR_LIT:name>']<EOL><DEDENT>if '<STR_LIT:description>' in metric:<EOL><INDENT>m['<STR_LIT:description>'] = metric['<STR_LIT:description>']<EOL><DEDENT>if '<STR_LIT>' in metric:<EOL><INDENT>m['<STR_LIT>'] = metric['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in metric:<EOL><INDENT>m['<STR_LIT>'] = metric['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in metric:<EOL><INDENT>m['<STR_LIT>'] = metric['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in metric:<EOL><INDENT>m['<STR_LIT>'] = metric['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in metric:<EOL><INDENT>m['<STR_LIT>'] = metric['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in metric:<EOL><INDENT>m['<STR_LIT>'] = metric['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' in metric:<EOL><INDENT>m['<STR_LIT>'] = metric['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT:type>' in metric:<EOL><INDENT>m['<STR_LIT:type>'] = metric['<STR_LIT:type>']<EOL><DEDENT>return m<EOL>", "docstring": "Extract only the required fields for the create/update API call", "id": "f16190:c2:m1"}
{"signature": "def _call_api(self):", "body": "<EOL>sockobj = socket(AF_INET, SOCK_STREAM)<EOL>sockobj.connect((self.rpc_host, self.rpc_port))<EOL>self.get_json()<EOL>message = [self.rpc_message.encode('<STR_LIT:utf-8>')]<EOL>for line in message:<EOL><INDENT>sockobj.send(line)<EOL>data = sockobj.recv(self.MAX_LINE)<EOL>print(data)<EOL>self.rpc_data.append(data)<EOL><DEDENT>sockobj.close()<EOL>", "docstring": "Make a call to the meter via JSON RPC", "id": "f16191:c0:m7"}
{"signature": "def get_description(self):", "body": "return '<STR_LIT>'.format(self.product_name)<EOL>", "docstring": "Text describing this command", "id": "f16191:c0:m1"}
{"signature": "def get_arguments(self):", "body": "ApiCli.get_arguments(self)<EOL>self._alarm_id = self.args.alarm_id if self.args.alarm_id is not None else None<EOL>", "docstring": "Extracts the specific arguments of this CLI", "id": "f16193:c0:m2"}
{"signature": "def read(self):", "body": "f = open(self.path, \"<STR_LIT:r>\")<EOL>self.manifest_json = f.read()<EOL>", "docstring": "Load the metrics file from the given path", "id": "f16198:c0:m2"}
{"signature": "def get_arguments(self):", "body": "ApiCli.get_arguments(self)<EOL>if self.args.host_group_name is not None:<EOL><INDENT>self.host_group_name = self.args.host_group_name<EOL><DEDENT>if self.args.sources is not None:<EOL><INDENT>self.sources = self.args.sources<EOL><DEDENT>payload = {}<EOL>if self.host_group_name is not None:<EOL><INDENT>payload['<STR_LIT:name>'] = self.host_group_name<EOL><DEDENT>if self.sources is not None:<EOL><INDENT>source_list = str.split(self.sources, '<STR_LIT:U+002C>')<EOL>if '<STR_LIT>' not in payload:<EOL><INDENT>payload['<STR_LIT>'] = []<EOL><DEDENT>for s in source_list:<EOL><INDENT>payload['<STR_LIT>'].append(s)<EOL><DEDENT><DEDENT>self.data = json.dumps(payload, sort_keys=True)<EOL>self.headers = {'<STR_LIT:Content-Type>': '<STR_LIT:application/json>', \"<STR_LIT>\": \"<STR_LIT:application/json>\"}<EOL>", "docstring": "Extracts the specific arguments of this CLI", "id": "f16201:c0:m1"}
{"signature": "def get_arguments(self):", "body": "<EOL>self._configure_logging()<EOL>if self.args.api_host is not None:<EOL><INDENT>self._api_host = self.args.api_host<EOL><DEDENT>if self.args.email is not None:<EOL><INDENT>self._email = self.args.email<EOL><DEDENT>if self.args.api_token is not None:<EOL><INDENT>self._api_token = self.args.api_token<EOL><DEDENT>self._curl = self.args.curl<EOL>logging.debug(\"<STR_LIT>\".format(self._api_host))<EOL>logging.debug(\"<STR_LIT>\".format(self._email))<EOL>logging.debug(\"<STR_LIT>\".format(self._api_token))<EOL>", "docstring": "CLIs get called back so that they can process any command line arguments\nthat are given. This method handles the standard command line arguments for:\nAPI Host, user, password, etc.", "id": "f16202:c0:m7"}
{"signature": "def _parse_args(self):", "body": "<EOL>self.args = self.parser.parse_args()<EOL>", "docstring": "Handles the parse of the command line arguments", "id": "f16202:c0:m5"}
{"signature": "def _do_post(self):", "body": "return requests.post(self._url, data=self._data, headers=self._headers, auth=(self._email, self._api_token))<EOL>", "docstring": "HTTP Post Request", "id": "f16204:c0:m18"}
{"signature": "def good_response(self, status_code):", "body": "return status_code == requests.codes.ok<EOL>", "docstring": "Determines what status codes represent a good response from an API call.", "id": "f16204:c0:m20"}
{"signature": "def _do_put(self):", "body": "return requests.put(self._url, data=self._data, headers=self._headers, auth=(self._email, self._api_token))<EOL>", "docstring": "HTTP Put Request", "id": "f16204:c0:m19"}
{"signature": "def get_arguments(self):", "body": "ApiCli.get_arguments(self)<EOL>if self.args.plugin_name is not None:<EOL><INDENT>self.plugin_name = self.args.plugin_name<EOL><DEDENT>self.path = \"<STR_LIT>\".format(self.plugin_name)<EOL>", "docstring": "Extracts the specific arguments of this CLI", "id": "f16209:c0:m2"}
{"signature": "def get_arguments(self):", "body": "ApiCli.get_arguments(self)<EOL>if self.args.hostGroupId is not None:<EOL><INDENT>self.hostGroupId = self.args.hostGroupId<EOL><DEDENT>self.path = \"<STR_LIT>\".format(str(self.hostGroupId))<EOL>", "docstring": "Extracts the specific arguments of this CLI", "id": "f16214:c0:m2"}
{"signature": "def get_arguments(self):", "body": "ApiCli.get_arguments(self)<EOL>if self.args.sources is not None:<EOL><INDENT>self._sources = self.args.sources<EOL><DEDENT>payload = {}<EOL>if self._sources is not None:<EOL><INDENT>source_list = str.split(self._sources, '<STR_LIT:U+002C>')<EOL>for s in source_list:<EOL><INDENT>payload['<STR_LIT>'].append(s)<EOL><DEDENT><DEDENT>self.data = json.dumps(payload, sort_keys=True)<EOL>self.headers = {'<STR_LIT:Content-Type>': '<STR_LIT:application/json>', \"<STR_LIT>\": \"<STR_LIT:application/json>\"}<EOL>", "docstring": "Extracts the specific arguments of this CLI", "id": "f16217:c0:m2"}
{"signature": "def generateMarkdown(self):", "body": "self.generateMetricDefinitions()<EOL>self.generateFieldDefinitions()<EOL>self.generateDashboardDefinitions()<EOL>self.outputMarkdown()<EOL>", "docstring": "Look up each of the metrics and then output in Markdown", "id": "f16218:c0:m22"}
{"signature": "def printFields(self, f, d):", "body": "for field in self.fields:<EOL><INDENT>fstr = field[\"<STR_LIT:title>\"]<EOL>dstr = field[\"<STR_LIT:description>\"]<EOL>flen = f - len(fstr)<EOL>dlen = d - len(dstr)<EOL>print(\"<STR_LIT>\".format(fstr, '<STR_LIT:U+0020>' * flen, dstr, '<STR_LIT:U+0020>' * dlen))<EOL><DEDENT>", "docstring": "Prints out table rows based on the size of the data in columns", "id": "f16218:c0:m14"}
{"signature": "def outputMarkdown(self):", "body": "self.outputFieldMarkdown()<EOL>self.outputMetricMarkdown()<EOL>self.outputDashboardMarkdown()<EOL>", "docstring": "Sends the markdown to standard out", "id": "f16218:c0:m21"}
{"signature": "def _validate_arguments(self):", "body": "return ApiCli._validate_arguments(self)<EOL>", "docstring": "TODO: Implement validation of event creation arguments", "id": "f16222:c1:m3"}
{"signature": "def get_arguments(self):", "body": "HostgroupModify.get_arguments(self)<EOL>if self.args.host_group_id is not None:<EOL><INDENT>self.host_group_id = self.args.host_group_id<EOL><DEDENT>self.path = \"<STR_LIT>\" + str(self.host_group_id)<EOL>", "docstring": "Extracts the specific arguments of this CLI", "id": "f16226:c0:m2"}
{"signature": "def add_arguments(self):", "body": "MetricCommon.add_arguments(self)<EOL>self.parser.add_argument('<STR_LIT>', '<STR_LIT>', dest='<STR_LIT>', action='<STR_LIT:store>',<EOL>required=True, metavar='<STR_LIT>', help='<STR_LIT>')<EOL>self.parser.add_argument('<STR_LIT>', '<STR_LIT>', dest='<STR_LIT>', action='<STR_LIT:store>',<EOL>required=True, metavar='<STR_LIT>', help='<STR_LIT>')<EOL>self.parser.add_argument('<STR_LIT>', '<STR_LIT>', dest='<STR_LIT>', action='<STR_LIT:store>',<EOL>required=True, metavar='<STR_LIT>', help='<STR_LIT>')<EOL>self.parser.add_argument('<STR_LIT>', '<STR_LIT>', dest='<STR_LIT:description>', action='<STR_LIT:store>',<EOL>required=not self.update, metavar='<STR_LIT:description>', help='<STR_LIT>')<EOL>self.parser.add_argument('<STR_LIT>', '<STR_LIT>', dest='<STR_LIT>', action='<STR_LIT:store>',<EOL>required=True, choices=['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'],<EOL>help='<STR_LIT>')<EOL>self.parser.add_argument('<STR_LIT>', '<STR_LIT>', dest='<STR_LIT>', action='<STR_LIT:store>',<EOL>required=False, choices=['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'],<EOL>help='<STR_LIT>')<EOL>self.parser.add_argument('<STR_LIT>', '<STR_LIT>', dest='<STR_LIT>', action='<STR_LIT:store>', metavar='<STR_LIT>',<EOL>required=False, help='<STR_LIT>')<EOL>self.parser.add_argument('<STR_LIT>', '<STR_LIT>', dest='<STR_LIT:type>', action='<STR_LIT:store>', default=None,<EOL>required=False, metavar='<STR_LIT:type>', help='<STR_LIT>')<EOL>self.parser.add_argument('<STR_LIT>', '<STR_LIT>', dest='<STR_LIT>', action='<STR_LIT:store>', default=None,<EOL>required=False,<EOL>choices=['<STR_LIT:true>', '<STR_LIT:false>'], help='<STR_LIT>')<EOL>", "docstring": "Add the specific arguments of this CLI", "id": "f16235:c0:m1"}
{"signature": "def get_arguments(self):", "body": "MetricCommon.get_arguments(self)<EOL>if self.args.metricName is not None:<EOL><INDENT>self.metricName = self.args.metricName<EOL><DEDENT>if self.args.displayName is not None:<EOL><INDENT>self.displayName = self.args.displayName<EOL><DEDENT>if self.args.displayNameShort is not None:<EOL><INDENT>self.displayNameShort = self.args.displayNameShort<EOL><DEDENT>if self.args.description is not None:<EOL><INDENT>self.description = self.args.description<EOL><DEDENT>if self.args.aggregate is not None:<EOL><INDENT>self.aggregate = self.args.aggregate<EOL><DEDENT>if self.args.unit is not None:<EOL><INDENT>self.unit = self.args.unit<EOL><DEDENT>if self.args.resolution is not None:<EOL><INDENT>self.resolution = self.args.resolution<EOL><DEDENT>if self.args.isDisabled is not None:<EOL><INDENT>self.isDisabled = self.args.isDisabled<EOL><DEDENT>if self.args.type is not None:<EOL><INDENT>self.type = self.args.type<EOL><DEDENT>data = {}<EOL>if self.metricName is not None:<EOL><INDENT>data['<STR_LIT:name>'] = self.metricName<EOL><DEDENT>if self.displayName is not None:<EOL><INDENT>data['<STR_LIT>'] = self.displayName<EOL><DEDENT>if self.displayNameShort is not None:<EOL><INDENT>data['<STR_LIT>'] = self.displayNameShort<EOL><DEDENT>if self.description is not None:<EOL><INDENT>data['<STR_LIT:description>'] = self.description<EOL><DEDENT>if self.aggregate is not None:<EOL><INDENT>data['<STR_LIT>'] = self.aggregate<EOL><DEDENT>if self.unit is not None:<EOL><INDENT>data['<STR_LIT>'] = self.unit<EOL><DEDENT>if self.resolution is not None:<EOL><INDENT>data['<STR_LIT>'] = self.resolution<EOL><DEDENT>if self.isDisabled is not None:<EOL><INDENT>data['<STR_LIT>'] = True if self.isDisabled == '<STR_LIT:yes>' else False<EOL><DEDENT>if self.type is not None:<EOL><INDENT>data['<STR_LIT:type>'] =  self.type<EOL><DEDENT>self.path = \"<STR_LIT>\".format(self.metricName)<EOL>self.data = json.dumps(data, sort_keys=True)<EOL>self.headers = {'<STR_LIT:Content-Type>': '<STR_LIT:application/json>', \"<STR_LIT>\": \"<STR_LIT:application/json>\"}<EOL>", "docstring": "Extracts the specific arguments of this CLI", "id": "f16235:c0:m2"}
{"signature": "def get_arguments(self):", "body": "MetricModify.get_arguments(self)<EOL>self.path = \"<STR_LIT>\"<EOL>", "docstring": "Extracts the specific arguments of this CLI", "id": "f16236:c0:m1"}
{"signature": "def filter(self):", "body": "if self.filter_expression is not None:<EOL><INDENT>new_metrics = []<EOL>metrics = self.metrics['<STR_LIT:result>']<EOL>for m in metrics:<EOL><INDENT>if self.filter_expression.search(m['<STR_LIT:name>']):<EOL><INDENT>new_metrics.append(m)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>new_metrics = self.metrics['<STR_LIT:result>']<EOL><DEDENT>self.metrics = self.extract_dictionary(new_metrics)<EOL>", "docstring": "Apply the criteria to filter out on the metrics required", "id": "f16237:c0:m5"}
{"signature": "def _handle_results(self):", "body": "<EOL>if self._api_result.status_code == requests.codes.ok:<EOL><INDENT>self.metrics = json.loads(self._api_result.text)<EOL>self.filter()<EOL>out = json.dumps(self.metrics, sort_keys=True, indent=<NUM_LIT:4>, separators=('<STR_LIT:U+002C>', '<STR_LIT>'))<EOL>print(self.colorize_json(out))<EOL><DEDENT>", "docstring": "Call back function to be implemented by the CLI.", "id": "f16237:c0:m6"}
{"signature": "def __init__(self):", "body": "MetricCommon.__init__(self)<EOL>self.method = \"<STR_LIT:GET>\"<EOL>self.path = \"<STR_LIT>\"<EOL>self.metrics = None<EOL>self.patterns = None<EOL>self.filter_expression = None<EOL>", "docstring": "Initialize the instance", "id": "f16237:c0:m0"}
{"signature": "def get_arguments(self):", "body": "ApiCli.get_arguments(self)<EOL>if self.args.metricName is not None:<EOL><INDENT>self.metricName = self.args.metricName<EOL><DEDENT>if self.args.measurement is not None:<EOL><INDENT>self.measurement = self.args.measurement<EOL><DEDENT>if self.args.source is not None:<EOL><INDENT>self.source = self.args.source<EOL><DEDENT>else:<EOL><INDENT>self.source = socket.gethostname()<EOL><DEDENT>if self.args.timestamp is not None:<EOL><INDENT>self.timestamp = int(self.args.timestamp)<EOL><DEDENT>m = {'<STR_LIT>': self.metricName,<EOL>'<STR_LIT>': self.measurement}<EOL>if self.source is not None:<EOL><INDENT>m['<STR_LIT:source>'] = self.source<EOL><DEDENT>if self.timestamp is not None:<EOL><INDENT>m['<STR_LIT>'] = int(self.timestamp)<EOL><DEDENT>self._process_properties()<EOL>if self._properties is not None:<EOL><INDENT>m['<STR_LIT>'] = self._properties<EOL><DEDENT>self.data = json.dumps(m, sort_keys=True)<EOL>self.headers = {'<STR_LIT:Content-Type>': '<STR_LIT:application/json>', \"<STR_LIT>\": \"<STR_LIT:application/json>\"}<EOL>", "docstring": "Extracts the specific arguments of this CLI", "id": "f16239:c0:m3"}
{"signature": "def get_arguments(self):", "body": "PluginBase.get_arguments(self)<EOL>if self.args.organizationName is not None:<EOL><INDENT>self.organizationName = self.args.organizationName<EOL><DEDENT>if self.args.repositoryName is not None:<EOL><INDENT>self.repositoryName = self.args.repositoryName<EOL><DEDENT>self.path = \"<STR_LIT>\".format(self.pluginName, self.organizationName, self.repositoryName)<EOL>", "docstring": "Extracts the specific arguments of this CLI", "id": "f16240:c0:m2"}
{"signature": "def output_json(self, text):", "body": "payload = json.loads(text)<EOL>data = []<EOL>metric_name = self._metric_name<EOL>for r in payload['<STR_LIT:result>']['<STR_LIT>']['<STR_LIT:key>']:<EOL><INDENT>timestamp = self._format_timestamp(r[<NUM_LIT:0>][<NUM_LIT:0>])<EOL>for s in r[<NUM_LIT:1>]:<EOL><INDENT>data.append({<EOL>\"<STR_LIT>\": timestamp,<EOL>\"<STR_LIT>\": metric_name,<EOL>\"<STR_LIT>\": self.aggregate,<EOL>\"<STR_LIT:source>\": s[<NUM_LIT:0>],<EOL>\"<STR_LIT:value>\": s[<NUM_LIT:1>],<EOL>})<EOL><DEDENT><DEDENT>payload = {\"<STR_LIT:data>\": data}<EOL>out = json.dumps(payload, indent=self._indent, separators=('<STR_LIT:U+002C>', '<STR_LIT>'))<EOL>print(self.colorize_json(out))<EOL>", "docstring": "Output results in structured JSON format", "id": "f16243:c0:m7"}
{"signature": "def output_raw(self, text):", "body": "payload = json.loads(text)<EOL>out = json.dumps(payload, sort_keys=True, indent=self._indent, separators=('<STR_LIT:U+002C>', '<STR_LIT>'))<EOL>print(self.colorize_json(out))<EOL>", "docstring": "Output results in raw JSON format", "id": "f16243:c0:m8"}
{"signature": "def _handle_results(self):", "body": "<EOL>if self._api_result.status_code == requests.codes.ok:<EOL><INDENT>self._relay_output = json.loads(self._api_result.text)<EOL>if self._raw:<EOL><INDENT>self._dump_json()<EOL><DEDENT>else:<EOL><INDENT>self._dump_text()<EOL><DEDENT><DEDENT>", "docstring": "Call back function to be implemented by the CLI.", "id": "f16244:c0:m6"}
{"signature": "def _dump_json(self):", "body": "out = json.dumps(self._relay_output, sort_keys=True, indent=<NUM_LIT:4>, separators=('<STR_LIT:U+002C>', '<STR_LIT>'))<EOL>print(self.colorize_json(out))<EOL>", "docstring": "Send raw JSON output", "id": "f16244:c0:m5"}
{"signature": "def wkhtmltopdf(pages, output=None, **kwargs):", "body": "if isinstance(pages, six.string_types):<EOL><INDENT>pages = [pages]<EOL><DEDENT>if output is None:<EOL><INDENT>output = '<STR_LIT:->'<EOL><DEDENT>has_cover = kwargs.pop('<STR_LIT>', False)<EOL>options = getattr(settings, '<STR_LIT>', None)<EOL>if options is None:<EOL><INDENT>options = {'<STR_LIT>': True}<EOL><DEDENT>else:<EOL><INDENT>options = copy(options)<EOL><DEDENT>options.update(kwargs)<EOL>options.setdefault('<STR_LIT>', '<STR_LIT:utf8>')<EOL>env = getattr(settings, '<STR_LIT>', None)<EOL>if env is not None:<EOL><INDENT>env = dict(os.environ, **env)<EOL><DEDENT>cmd = '<STR_LIT>'<EOL>cmd = getattr(settings, cmd, os.environ.get(cmd, '<STR_LIT>'))<EOL>if has_cover:<EOL><INDENT>pages.insert(<NUM_LIT:0>, '<STR_LIT>')<EOL><DEDENT>ck_args = list(chain(shlex.split(cmd),<EOL>_options_to_args(**options),<EOL>list(pages),<EOL>[output]))<EOL>ck_kwargs = {'<STR_LIT>': env}<EOL>try:<EOL><INDENT>i = sys.stderr.fileno()<EOL>ck_kwargs['<STR_LIT>'] = sys.stderr<EOL><DEDENT>except (AttributeError, IOError):<EOL><INDENT>pass<EOL><DEDENT>return check_output(ck_args, **ck_kwargs)<EOL>", "docstring": "Converts html to PDF using http://wkhtmltopdf.org/.\n\npages: List of file paths or URLs of the html to be converted.\noutput: Optional output file path. If None, the output is returned.\n**kwargs: Passed to wkhtmltopdf via _extra_args() (See\n          https://github.com/antialize/wkhtmltopdf/blob/master/README_WKHTMLTOPDF\n          for acceptable args.)\n          Kwargs is passed through as arguments. e.g.:\n              {'footer_html': 'http://example.com/foot.html'}\n          becomes\n              '--footer-html http://example.com/foot.html'\n\n          Where there is no value passed, use True. e.g.:\n              {'disable_javascript': True}\n          becomes:\n              '--disable-javascript'\n\n          To disable a default option, use None. e.g:\n              {'quiet': None'}\n          becomes:\n              ''\n\nexample usage:\n    wkhtmltopdf(pages=['/tmp/example.html'],\n                dpi=300,\n                orientation='Landscape',\n                disable_javascript=True)", "id": "f16253:m1"}
{"signature": "def _options_to_args(**options):", "body": "flags = []<EOL>for name in sorted(options):<EOL><INDENT>value = options[name]<EOL>formatted_flag = '<STR_LIT>' % name if len(name) > <NUM_LIT:1> else '<STR_LIT>' % name<EOL>formatted_flag = formatted_flag.replace('<STR_LIT:_>', '<STR_LIT:->')<EOL>accepts_no_arguments = formatted_flag in NO_ARGUMENT_OPTIONS<EOL>if value is None or (value is False and accepts_no_arguments):<EOL><INDENT>continue<EOL><DEDENT>flags.append(formatted_flag)<EOL>if accepts_no_arguments:<EOL><INDENT>continue<EOL><DEDENT>flags.append(six.text_type(value))<EOL><DEDENT>return flags<EOL>", "docstring": "Converts ``options`` into a list of command-line arguments.\nSkip arguments where no value is provided\nFor flag-type (No argument) variables, pass only the name and only then if the value is True", "id": "f16253:m0"}
{"signature": "def expand(self, short):", "body": "data = dict(action='<STR_LIT>', shorturl=short)<EOL>jsondata = self._api_request(params=data)<EOL>return jsondata['<STR_LIT>']<EOL>", "docstring": "Expand short URL or keyword to long URL.\n\n        Parameters:\n            short: Short URL (``http://example.com/abc``) or keyword (abc).\n\n        :return: Expanded/long URL, e.g.\n                 ``https://www.youtube.com/watch?v=dQw4w9WgXcQ``\n\n        Raises:\n            ~yourls.exceptions.YOURLSHTTPError: HTTP error with response from\n                YOURLS API.\n            requests.exceptions.HTTPError: Generic HTTP error.", "id": "f16263:c1:m1"}
{"signature": "def stats(self, filter, limit, start=None):", "body": "<EOL>if filter == '<STR_LIT>':<EOL><INDENT>filter = '<STR_LIT>'<EOL><DEDENT>valid_filters = ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>if filter not in valid_filters:<EOL><INDENT>msg = '<STR_LIT>'.format('<STR_LIT:U+002CU+0020>'.join(valid_filters))<EOL>raise ValueError(msg)<EOL><DEDENT>data = dict(action='<STR_LIT>', filter=filter, limit=limit, start=start)<EOL>jsondata = self._api_request(params=data)<EOL>stats = DBStats(total_clicks=int(jsondata['<STR_LIT>']['<STR_LIT>']),<EOL>total_links=int(jsondata['<STR_LIT>']['<STR_LIT>']))<EOL>links = []<EOL>if '<STR_LIT>' in jsondata:<EOL><INDENT>for i in range(<NUM_LIT:1>, limit + <NUM_LIT:1>):<EOL><INDENT>key = '<STR_LIT>'.format(i)<EOL>links.append(_json_to_shortened_url(jsondata['<STR_LIT>'][key]))<EOL><DEDENT><DEDENT>return links, stats<EOL>", "docstring": "Get stats about links.\n\n        Parameters:\n            filter: 'top', 'bottom', 'rand', or 'last'.\n            limit: Number of links to return from filter.\n            start: Optional start number.\n\n        Returns:\n            Tuple containing list of ShortenedURLs and DBStats.\n\n        Example:\n\n            .. code-block:: python\n\n                links, stats = yourls.stats(filter='top', limit=10)\n\n        Raises:\n            ValueError: Incorrect value for filter parameter.\n            requests.exceptions.HTTPError: Generic HTTP Error", "id": "f16263:c1:m3"}
{"signature": "def check_staged(filename=None):", "body": "retcode, _, stdout = git['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>filename].run(retcode=None)<EOL>if retcode == <NUM_LIT:1>:<EOL><INDENT>return True<EOL><DEDENT>elif retcode == <NUM_LIT:0>:<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(stdout)<EOL><DEDENT>", "docstring": "Check if there are 'changes to be committed' in the index.", "id": "f16265:m1"}
{"signature": "def check_unstaged(filename):", "body": "retcode, _, stdout = git['<STR_LIT>', '<STR_LIT>',<EOL>filename].run(retcode=None)<EOL>if retcode == <NUM_LIT:1>:<EOL><INDENT>return True<EOL><DEDENT>elif retcode == <NUM_LIT:0>:<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(stdout)<EOL><DEDENT>", "docstring": "Check if there are 'changes not staged for commit' in the working\n    directory.", "id": "f16265:m2"}
{"signature": "def check_git_unchanged(filename, yes=False):", "body": "if check_staged(filename):<EOL><INDENT>s = '<STR_LIT>'.format(filename)<EOL>if yes or input(s) in ('<STR_LIT:y>', '<STR_LIT:yes>'):<EOL><INDENT>return<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>'<EOL>'<STR_LIT>'.format(filename))<EOL><DEDENT><DEDENT>if check_unstaged(filename):<EOL><INDENT>s = '<STR_LIT>'.format(filename)<EOL>if yes or input(s) in ('<STR_LIT:y>', '<STR_LIT:yes>'):<EOL><INDENT>return<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError('<STR_LIT>'<EOL>'<STR_LIT>'.format(filename))<EOL><DEDENT><DEDENT>", "docstring": "Check git to avoid overwriting user changes.", "id": "f16265:m0"}
{"signature": "@task<EOL>def watch():", "body": "<EOL>sphinx_build['<STR_LIT>', '<STR_LIT:html>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'] & FG<EOL>handler = ShellCommandTrick(<EOL>shell_command='<STR_LIT>',<EOL>patterns=['<STR_LIT>', '<STR_LIT>'],<EOL>ignore_patterns=['<STR_LIT>'],<EOL>ignore_directories=['<STR_LIT>'],<EOL>drop_during_process=True)<EOL>observer = Observer()<EOL>observe_with(observer, handler, pathnames=['<STR_LIT:.>'], recursive=True)<EOL>", "docstring": "Renerate documentation when it changes.", "id": "f16266:m0"}
{"signature": "def _request_activity_list(self, athlete):", "body": "response = self._get_request(self._athlete_endpoint(athlete))<EOL>response_buffer = StringIO(response.text)<EOL>activity_list = pd.read_csv(<EOL>filepath_or_buffer=response_buffer,<EOL>parse_dates={'<STR_LIT>': ['<STR_LIT:date>', '<STR_LIT:time>']},<EOL>sep='<STR_LIT>',<EOL>engine='<STR_LIT>'<EOL>)<EOL>activity_list.rename(columns=lambda x: x.lower(), inplace=True)<EOL>activity_list.rename(<EOL>columns=lambda x: '<STR_LIT:_>' + x if x[<NUM_LIT:0>].isdigit() else x, inplace=True)<EOL>activity_list['<STR_LIT>'] = activity_list.average_heart_rate.map(bool)<EOL>activity_list['<STR_LIT>'] = activity_list.average_speed.map(bool)<EOL>activity_list['<STR_LIT>'] = activity_list.average_power.map(bool)<EOL>activity_list['<STR_LIT>'] = activity_list.average_heart_rate.map(bool)<EOL>activity_list['<STR_LIT:data>'] = pd.Series(dtype=np.dtype(\"<STR_LIT:object>\"))<EOL>return activity_list<EOL>", "docstring": "Actually do the request for activity list\n        This call is slow and therefore this method is memory cached.\n\n        Keyword arguments:\n        athlete -- Full name of athlete", "id": "f16273:c0:m8"}
{"signature": "def get_last_activity(self):", "body": "last_activities = self.get_last_activities(n=<NUM_LIT:1>)<EOL>return last_activities[<NUM_LIT:0>]<EOL>", "docstring": "Get all activity data for the last activity\n\n        Keyword arguments:", "id": "f16273:c0:m7"}
{"signature": "def _athlete_endpoint(self, athlete):", "body": "return '<STR_LIT>'.format(<EOL>host=self.host,<EOL>athlete=quote_plus(athlete)<EOL>)<EOL>", "docstring": "Construct athlete endpoint from host and athlete name\n\n        Keyword arguments:\n        athlete -- Full athlete name", "id": "f16273:c0:m10"}
{"signature": "@main.command()<EOL>@click.argument('<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=click.File('<STR_LIT:w>'))<EOL>@click.option('<STR_LIT>', '<STR_LIT>', help=\"<STR_LIT>\".format(BASE_URL))<EOL>def labels(ontology, output, ols_base):", "body": "for label in get_labels(ontology=ontology, ols_base=ols_base):<EOL><INDENT>click.echo(label, file=output)<EOL><DEDENT>", "docstring": "Output the names to the given file", "id": "f16277:m1"}
{"signature": "@main.command()<EOL>@click.argument('<STR_LIT>')<EOL>@click.option('<STR_LIT>', '<STR_LIT>', type=click.File('<STR_LIT:w>'))<EOL>@click.option('<STR_LIT>', '<STR_LIT>', help=\"<STR_LIT>\".format(BASE_URL))<EOL>def tree(ontology, output, ols_base):", "body": "for parent, child in get_hierarchy(ontology=ontology, ols_base=ols_base):<EOL><INDENT>click.echo('<STR_LIT>'.format(parent, child), file=output)<EOL><DEDENT>", "docstring": "Output the parent-child relations to the given file", "id": "f16277:m2"}
{"signature": "@main.command()<EOL>@click.argument('<STR_LIT>')<EOL>def set_base(base):", "body": "config = get_config()<EOL>config['<STR_LIT>'] = base<EOL>write_config(config)<EOL>", "docstring": "Sets the default OLS base url", "id": "f16277:m3"}
{"signature": "def suggest(self, name, ontology=None):", "body": "params = {'<STR_LIT:q>': name}<EOL>if ontology:<EOL><INDENT>params['<STR_LIT>'] = '<STR_LIT:U+002C>'.join(ontology)<EOL><DEDENT>response = requests.get(self.ontology_suggest, params=params)<EOL>return response.json()<EOL>", "docstring": "Suggest terms from an optional list of ontologies\n\n        :param str name:\n        :param list[str] ontology:\n        :rtype: dict\n\n        .. seealso:: https://www.ebi.ac.uk/ols/docs/api#_suggest_term", "id": "f16279:c0:m4"}
{"signature": "def iter_hierarchy(self, ontology, size=None, sleep=None):", "body": "for term in self.iter_terms(ontology=ontology, size=size, sleep=sleep):<EOL><INDENT>try:<EOL><INDENT>hierarchy_children_link = term['<STR_LIT>'][HIERARCHICAL_CHILDREN]['<STR_LIT>']<EOL><DEDENT>except KeyError:  <EOL><INDENT>continue<EOL><DEDENT>response = requests.get(hierarchy_children_link).json()<EOL>for child_term in response['<STR_LIT>']['<STR_LIT>']:<EOL><INDENT>yield term['<STR_LIT:label>'], child_term['<STR_LIT:label>']<EOL><DEDENT><DEDENT>", "docstring": "Iterates over parent-child relations\n\n        :param str ontology: The name of the ontology\n        :param int size: The size of each page. Defaults to 500, which is the maximum allowed by the EBI.\n        :param int sleep: The amount of time to sleep between pages. Defaults to 0 seconds.\n        :rtype: iter[tuple[str,str]]", "id": "f16279:c0:m10"}
{"signature": "def get_ontology(self, ontology):", "body": "url = self.ontology_metadata_fmt.format(ontology=ontology)<EOL>response = requests.get(url)<EOL>return response.json()<EOL>", "docstring": "Gets the metadata for a given ontology\n\n        :param str ontology: The name of the ontology\n        :return: The dictionary representing the JSON from the OLS\n        :rtype: dict", "id": "f16279:c0:m1"}
{"signature": "def iter_descendants(self, ontology, iri, size=None, sleep=None):", "body": "url = self.ontology_term_descendants_fmt.format(ontology=ontology, iri=iri)<EOL>log.info('<STR_LIT>', url)<EOL>for term in self._iter_terms_helper(url, size=size, sleep=sleep):<EOL><INDENT>yield term<EOL><DEDENT>", "docstring": "Iterates over the descendants of a given term\n\n        :param str ontology: The name of the ontology\n        :param str iri: The IRI of a term\n        :param int size: The size of each page. Defaults to 500, which is the maximum allowed by the EBI.\n        :param int sleep: The amount of time to sleep between pages. Defaults to 0 seconds.\n        :rtype: iter[dict]", "id": "f16279:c0:m7"}
{"signature": "def iter_terms(self, ontology, size=None, sleep=None):", "body": "url = self.ontology_terms_fmt.format(ontology=ontology)<EOL>for term in self._iter_terms_helper(url, size=size, sleep=sleep):<EOL><INDENT>yield term<EOL><DEDENT>", "docstring": "Iterates over all terms, lazily with paging\n\n        :param str ontology: The name of the ontology\n        :param int size: The size of each page. Defaults to 500, which is the maximum allowed by the EBI.\n        :param int sleep: The amount of time to sleep between pages. Defaults to 0 seconds.\n        :rtype: iter[dict]", "id": "f16279:c0:m6"}
{"signature": "def get_term(self, ontology, iri):", "body": "url = self.ontology_term_fmt.format(ontology, iri)<EOL>response = requests.get(url)<EOL>return response.json()<EOL>", "docstring": "Gets the data for a given term\n\n        :param str ontology: The name of the ontology\n        :param str iri: The IRI of a term\n        :rtype: dict", "id": "f16279:c0:m2"}
{"signature": "def find_meta(meta):", "body": "meta_match = re.search(<EOL>r'<STR_LIT>'.format(meta=meta),<EOL>META_FILE, re.M<EOL>)<EOL>if meta_match:<EOL><INDENT>return meta_match.group(<NUM_LIT:1>)<EOL><DEDENT>raise RuntimeError('<STR_LIT>'.format(meta=meta))<EOL>", "docstring": "Extract __*meta*__ from META_FILE", "id": "f16284:m1"}
{"signature": "def __init__(self, default=None, **engines):", "body": "if default is not None:<EOL><INDENT>engines['<STR_LIT:default>'] = default<EOL><DEDENT>self.engines = engines<EOL>self.uses = set()<EOL>self.needs = set()<EOL>self.provides = set(self._provides)<EOL>for name, engine in engines.items():<EOL><INDENT>if not getattr(engine, '<STR_LIT>', None):<EOL><INDENT>engine.alias = name  <EOL><DEDENT>self.uses.update(getattr(engine, '<STR_LIT>', ()))<EOL>self.needs.update(getattr(engine, '<STR_LIT>', ()))<EOL>self.provides.update(getattr(engine, '<STR_LIT>', ()))<EOL><DEDENT>super(DatabaseExtension, self).__init__()<EOL>", "docstring": "Configure the database management extension.", "id": "f16292:c0:m0"}
{"signature": "def stop(self, context):", "body": "self.engine.dispose()<EOL>", "docstring": "Disconnect any hanging connections in the pool.", "id": "f16295:c0:m5"}
{"signature": "def start(self, context):", "body": "if __debug__:<EOL><INDENT>log.info(\"<STR_LIT>\", extra=dict(<EOL>uri = redact_uri(self.uri),<EOL>config = self.config,<EOL>alias = self.alias,<EOL>))<EOL><DEDENT>engine = self.engine = create_engine(self.uri, **self.config)<EOL>self.Session = scoped_session(sessionmaker(bind=engine))<EOL>engine.connect().close()<EOL>context.db[self.alias] = engine<EOL>", "docstring": "Construct the SQLAlchemy engine and session factory.", "id": "f16295:c0:m2"}
{"signature": "def prepare(self, context):", "body": "<EOL>context.db[self.alias] = self.Session<EOL>", "docstring": "Prepare a sqlalchemy session on the WebCore context", "id": "f16295:c0:m3"}
{"signature": "def __init__(self, uri, alias=None, **config):", "body": "<EOL>config.setdefault('<STR_LIT>', <NUM_LIT>)<EOL>self.uri = uri<EOL>self.alias = alias<EOL>self.config = config<EOL>self.engine = None<EOL>self.Session = None<EOL>", "docstring": "Prepare SQLAlchemy configuration.", "id": "f16295:c0:m0"}
{"signature": "def render_grid_file(context, f):", "body": "f.seek(<NUM_LIT:0>)  <EOL>response = context.response  <EOL>if __debug__:  <EOL><INDENT>response.headers['<STR_LIT>'] = str(f._id)  <EOL>log.debug(\"<STR_LIT>\", extra=dict(<EOL>identifier = str(f._id),<EOL>filename = f.filename,<EOL>length = f.length,<EOL>mimetype = f.content_type<EOL>))<EOL><DEDENT>response.conditional_response = True<EOL>response.accept_ranges = '<STR_LIT>'  <EOL>response.content_type = f.content_type  <EOL>response.content_length = f.length  <EOL>response.content_md5 = response.etag = f.md5  <EOL>response.last_modified = f.metadata.get('<STR_LIT>', None)  <EOL>response.content_disposition = '<STR_LIT>' + f.name  <EOL>if context.request.if_range.match_response(response):<EOL><INDENT>response.body_file = f  <EOL><DEDENT>else:<EOL><INDENT>response.app_iter = iter(f)  <EOL><DEDENT>return True<EOL>", "docstring": "Allow direct use of GridOut GridFS file wrappers as endpoint responses.", "id": "f16296:m0"}
{"signature": "def stop(self, context):", "body": "disconnect(self.alias)<EOL>del self.connection<EOL>", "docstring": "Close the connection pool and clean up references in MongoEngine.", "id": "f16298:c1:m3"}
{"signature": "def start(self, context):", "body": "self.config['<STR_LIT>'] = self.alias<EOL>safe_config = dict(self.config)<EOL>del safe_config['<STR_LIT:host>']<EOL>log.info(\"<STR_LIT>\", extra=dict(<EOL>uri = redact_uri(self.config['<STR_LIT:host>']),<EOL>config = self.config,<EOL>))<EOL>self.connection = connect(**self.config)<EOL>", "docstring": "Initialize the database connection.", "id": "f16298:c1:m1"}
{"signature": "def __init__(self, uri, alias=None, **kw):", "body": "kw['<STR_LIT:host>'] = uri<EOL>self.alias = alias<EOL>self.config = kw<EOL>", "docstring": "Prepare configuration options.", "id": "f16298:c1:m0"}
{"signature": "def select_header_content_type(self, content_types):", "body": "if not content_types:<EOL><INDENT>return '<STR_LIT:application/json>'<EOL><DEDENT>content_types = list(map(lambda x: x.lower(), content_types))<EOL>if '<STR_LIT:application/json>' in content_types:<EOL><INDENT>return '<STR_LIT:application/json>'<EOL><DEDENT>else:<EOL><INDENT>return content_types[<NUM_LIT:0>]<EOL><DEDENT>", "docstring": "Returns `Content-Type` based on an array of content_types provided.\n\n:param content_types: List of content-types.\n:return: Content-Type (e.g. application/json).", "id": "f16302:c0:m13"}
{"signature": "def prepare_post_parameters(self, post_params=None, files=None):", "body": "params = {}<EOL>if post_params:<EOL><INDENT>params.update(post_params)<EOL><DEDENT>if files:<EOL><INDENT>for k, v in iteritems(files):<EOL><INDENT>if not v:<EOL><INDENT>continue<EOL><DEDENT>with open(v, '<STR_LIT:rb>') as f:<EOL><INDENT>filename = os.path.basename(f.name)<EOL>filedata = f.read()<EOL>mimetype = mimetypes.guess_type(filename)[<NUM_LIT:0>] or '<STR_LIT>'<EOL>params[k] = tuple([filename, filedata, mimetype])<EOL><DEDENT><DEDENT><DEDENT>return params<EOL>", "docstring": "Builds form parameters.\n\n:param post_params: Normal form parameters.\n:param files: File parameters.\n:return: Form parameters with files.", "id": "f16302:c0:m11"}
{"signature": "def __deserialize_primitive(self, data, klass):", "body": "try:<EOL><INDENT>value = klass(data)<EOL><DEDENT>except UnicodeEncodeError:<EOL><INDENT>value = unicode(data)<EOL><DEDENT>except TypeError:<EOL><INDENT>value = data<EOL><DEDENT>return value<EOL>", "docstring": "Deserializes string to primitive type.\n\n:param data: str.\n:param klass: class literal.\n\n:return: int, float, str, bool.", "id": "f16302:c0:m16"}
{"signature": "@property<EOL><INDENT>def user_agent(self):<DEDENT>", "body": "return self.default_headers['<STR_LIT>']<EOL>", "docstring": "Gets user agent.", "id": "f16302:c0:m1"}
{"signature": "def __deserialize_date(self, string):", "body": "try:<EOL><INDENT>from dateutil.parser import parse<EOL>return parse(string).date()<EOL><DEDENT>except ImportError:<EOL><INDENT>return string<EOL><DEDENT>except ValueError:<EOL><INDENT>raise ApiException(<EOL>status=<NUM_LIT:0>,<EOL>reason=\"<STR_LIT>\"<EOL>.format(string)<EOL>)<EOL><DEDENT>", "docstring": "Deserializes string to date.\n\n:param string: str.\n:return: date.", "id": "f16302:c0:m18"}
{"signature": "def __deserialize_model(self, data, klass):", "body": "instance = klass()<EOL>for attr, attr_type in iteritems(instance.swagger_types):<EOL><INDENT>if data is not Noneand instance.attribute_map[attr] in dataand isinstance(data, (list, dict)):<EOL><INDENT>value = data[instance.attribute_map[attr]]<EOL>setattr(instance, attr, self.__deserialize(value, attr_type))<EOL><DEDENT><DEDENT>return instance<EOL>", "docstring": "Deserializes list or dict to model.\n\n:param data: dict, list.\n:param klass: class literal.\n:return: model object.", "id": "f16302:c0:m20"}
{"signature": "@property<EOL><INDENT>def other_current_liabilities_and_provisions(self):<DEDENT>", "body": "return self._other_current_liabilities_and_provisions<EOL>", "docstring": "Gets the other_current_liabilities_and_provisions of this YearlyFinancials.\n\n\n:return: The other_current_liabilities_and_provisions of this YearlyFinancials.\n:rtype: float", "id": "f16303:c0:m31"}
{"signature": "@depreciation.setter<EOL><INDENT>def depreciation(self, depreciation):<DEDENT>", "body": "self._depreciation = depreciation<EOL>", "docstring": "Sets the depreciation of this YearlyFinancials.\n\n\n:param depreciation: The depreciation of this YearlyFinancials.\n:type: float", "id": "f16303:c0:m44"}
{"signature": "@property<EOL><INDENT>def year(self):<DEDENT>", "body": "return self._year<EOL>", "docstring": "Gets the year of this YearlyFinancials.\nYear-end of the balancesheet\n\n:return: The year of this YearlyFinancials.\n:rtype: date", "id": "f16303:c0:m1"}
{"signature": "@trade_payables.setter<EOL><INDENT>def trade_payables(self, trade_payables):<DEDENT>", "body": "self._trade_payables = trade_payables<EOL>", "docstring": "Sets the trade_payables of this YearlyFinancials.\n\n\n:param trade_payables: The trade_payables of this YearlyFinancials.\n:type: float", "id": "f16303:c0:m36"}
{"signature": "@property<EOL><INDENT>def profit_before_interest_and_tax(self):<DEDENT>", "body": "return self._profit_before_interest_and_tax<EOL>", "docstring": "Gets the profit_before_interest_and_tax of this YearlyFinancials.\n\n\n:return: The profit_before_interest_and_tax of this YearlyFinancials.\n:rtype: float", "id": "f16303:c0:m59"}
{"signature": "def to_str(self):", "body": "return pformat(self.to_dict())<EOL>", "docstring": "Returns the string representation of the model", "id": "f16303:c0:m66"}
{"signature": "@property<EOL><INDENT>def investments(self):<DEDENT>", "body": "return self._investments<EOL>", "docstring": "Gets the investments of this YearlyFinancials.\n\n\n:return: The investments of this YearlyFinancials.\n:rtype: float", "id": "f16303:c0:m11"}
{"signature": "@property<EOL><INDENT>def share_capital(self):<DEDENT>", "body": "return self._share_capital<EOL>", "docstring": "Gets the share_capital of this YearlyFinancials.\n\n\n:return: The share_capital of this YearlyFinancials.\n:rtype: float", "id": "f16303:c0:m23"}
{"signature": "@property<EOL><INDENT>def other_long_term_liabilities_and_provisions(self):<DEDENT>", "body": "return self._other_long_term_liabilities_and_provisions<EOL>", "docstring": "Gets the other_long_term_liabilities_and_provisions of this YearlyFinancials.\n\n\n:return: The other_long_term_liabilities_and_provisions of this YearlyFinancials.\n:rtype: float", "id": "f16303:c0:m33"}
{"signature": "@short_term_borrowings.setter<EOL><INDENT>def short_term_borrowings(self, short_term_borrowings):<DEDENT>", "body": "self._short_term_borrowings = short_term_borrowings<EOL>", "docstring": "Sets the short_term_borrowings of this YearlyFinancials.\n\n\n:param short_term_borrowings: The short_term_borrowings of this YearlyFinancials.\n:type: float", "id": "f16303:c0:m38"}
{"signature": "@property<EOL><INDENT>def depreciation(self):<DEDENT>", "body": "return self._depreciation<EOL>", "docstring": "Gets the depreciation of this YearlyFinancials.\n\n\n:return: The depreciation of this YearlyFinancials.\n:rtype: float", "id": "f16303:c0:m43"}
{"signature": "@net_income.setter<EOL><INDENT>def net_income(self, net_income):<DEDENT>", "body": "self._net_income = net_income<EOL>", "docstring": "Sets the net_income of this YearlyFinancials.\n\n\n:param net_income: The net_income of this YearlyFinancials.\n:type: float", "id": "f16303:c0:m52"}
{"signature": "@share_capital.setter<EOL><INDENT>def share_capital(self, share_capital):<DEDENT>", "body": "self._share_capital = share_capital<EOL>", "docstring": "Sets the share_capital of this YearlyFinancials.\n\n\n:param share_capital: The share_capital of this YearlyFinancials.\n:type: float", "id": "f16303:c0:m24"}
{"signature": "@property<EOL><INDENT>def total_equity(self):<DEDENT>", "body": "return self._total_equity<EOL>", "docstring": "Gets the total_equity of this YearlyFinancials.\n\n\n:return: The total_equity of this YearlyFinancials.\n:rtype: float", "id": "f16303:c0:m39"}
{"signature": "def __ne__(self, other):", "body": "return not self == other<EOL>", "docstring": "Returns true if both objects are not equal", "id": "f16303:c0:m69"}
{"signature": "@property<EOL><INDENT>def trade_payables(self):<DEDENT>", "body": "return self._trade_payables<EOL>", "docstring": "Gets the trade_payables of this YearlyFinancials.\n\n\n:return: The trade_payables of this YearlyFinancials.\n:rtype: float", "id": "f16303:c0:m35"}
{"signature": "@others.setter<EOL><INDENT>def others(self, others):<DEDENT>", "body": "self._others = others<EOL>", "docstring": "Sets the others of this YearlyFinancials.\n\n\n:param others: The others of this YearlyFinancials.\n:type: float", "id": "f16303:c0:m28"}
{"signature": "@capital_wip.setter<EOL><INDENT>def capital_wip(self, capital_wip):<DEDENT>", "body": "self._capital_wip = capital_wip<EOL>", "docstring": "Sets the capital_wip of this YearlyFinancials.\nCapital work in progress\n\n:param capital_wip: The capital_wip of this YearlyFinancials.\n:type: float", "id": "f16303:c0:m8"}
{"signature": "@income_tax.setter<EOL><INDENT>def income_tax(self, income_tax):<DEDENT>", "body": "self._income_tax = income_tax<EOL>", "docstring": "Sets the income_tax of this YearlyFinancials.\n\n\n:param income_tax: The income_tax of this YearlyFinancials.\n:type: float", "id": "f16303:c0:m48"}
{"signature": "@long_term_borrowings.setter<EOL><INDENT>def long_term_borrowings(self, long_term_borrowings):<DEDENT>", "body": "self._long_term_borrowings = long_term_borrowings<EOL>", "docstring": "Sets the long_term_borrowings of this YearlyFinancials.\n\n\n:param long_term_borrowings: The long_term_borrowings of this YearlyFinancials.\n:type: float", "id": "f16303:c0:m30"}
{"signature": "def to_str(self):", "body": "return pformat(self.to_dict())<EOL>", "docstring": "Returns the string representation of the model", "id": "f16304:c0:m6"}
{"signature": "def to_str(self):", "body": "return pformat(self.to_dict())<EOL>", "docstring": "Returns the string representation of the model", "id": "f16305:c0:m6"}
{"signature": "@meta.setter<EOL><INDENT>def meta(self, meta):<DEDENT>", "body": "self._meta = meta<EOL>", "docstring": "Sets the meta of this InlineResponse200.\n\n\n:param meta: The meta of this InlineResponse200.\n:type: Metadata", "id": "f16305:c0:m4"}
{"signature": "def __ne__(self, other):", "body": "return not self == other<EOL>", "docstring": "Returns true if both objects are not equal", "id": "f16305:c0:m9"}
{"signature": "def __repr__(self):", "body": "return self.to_str()<EOL>", "docstring": "For `print` and `pprint`", "id": "f16305:c0:m7"}
{"signature": "def __init__(self):", "body": "self.swagger_types = {<EOL>'<STR_LIT:data>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'<EOL>}<EOL>self.attribute_map = {<EOL>'<STR_LIT:data>': '<STR_LIT:data>',<EOL>'<STR_LIT>': '<STR_LIT>'<EOL>}<EOL>self._data = None<EOL>self._meta = None<EOL>", "docstring": "InlineResponse200 - a model defined in Swagger\n\n:param dict swaggerTypes: The key is attribute name\n                          and the value is attribute type.\n:param dict attributeMap: The key is attribute name\n                          and the value is json key in definition.", "id": "f16305:c0:m0"}
{"signature": "def __eq__(self, other):", "body": "return self.__dict__ == other.__dict__<EOL>", "docstring": "Returns true if both objects are equal", "id": "f16305:c0:m8"}
{"signature": "@meta.setter<EOL><INDENT>def meta(self, meta):<DEDENT>", "body": "self._meta = meta<EOL>", "docstring": "Sets the meta of this InlineResponse2006.\n\n\n:param meta: The meta of this InlineResponse2006.\n:type: Metadata", "id": "f16306:c0:m4"}
{"signature": "def __ne__(self, other):", "body": "return not self == other<EOL>", "docstring": "Returns true if both objects are not equal", "id": "f16306:c0:m9"}
{"signature": "def __repr__(self):", "body": "return self.to_str()<EOL>", "docstring": "For `print` and `pprint`", "id": "f16307:c0:m23"}
{"signature": "@property<EOL><INDENT>def legal_name(self):<DEDENT>", "body": "return self._legal_name<EOL>", "docstring": "Gets the legal_name of this CompanyDetailCompany.\nLegal name of the company\n\n:return: The legal_name of this CompanyDetailCompany.\n:rtype: str", "id": "f16307:c0:m1"}
{"signature": "@legal_name.setter<EOL><INDENT>def legal_name(self, legal_name):<DEDENT>", "body": "self._legal_name = legal_name<EOL>", "docstring": "Sets the legal_name of this CompanyDetailCompany.\nLegal name of the company\n\n:param legal_name: The legal_name of this CompanyDetailCompany.\n:type: str", "id": "f16307:c0:m2"}
{"signature": "@property<EOL><INDENT>def efiling_status(self):<DEDENT>", "body": "return self._efiling_status<EOL>", "docstring": "Gets the efiling_status of this CompanyDetailCompany.\nStatus of EFiling.\n\n:return: The efiling_status of this CompanyDetailCompany.\n:rtype: str", "id": "f16307:c0:m17"}
{"signature": "@property<EOL><INDENT>def paid_up_capital(self):<DEDENT>", "body": "return self._paid_up_capital<EOL>", "docstring": "Gets the paid_up_capital of this CompanyDetailCompany.\nPaid up capital\n\n:return: The paid_up_capital of this CompanyDetailCompany.\n:rtype: int", "id": "f16307:c0:m11"}
{"signature": "def to_dict(self):", "body": "result = {}<EOL>for attr, _ in iteritems(self.swagger_types):<EOL><INDENT>value = getattr(self, attr)<EOL>if isinstance(value, list):<EOL><INDENT>result[attr] = list(map(<EOL>lambda x: x.to_dict() if hasattr(x, \"<STR_LIT>\") else x,<EOL>value<EOL>))<EOL><DEDENT>elif hasattr(value, \"<STR_LIT>\"):<EOL><INDENT>result[attr] = value.to_dict()<EOL><DEDENT>else:<EOL><INDENT>result[attr] = value<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Returns the model properties as a dict", "id": "f16307:c0:m21"}
{"signature": "@property<EOL><INDENT>def incorporation_date(self):<DEDENT>", "body": "return self._incorporation_date<EOL>", "docstring": "Gets the incorporation_date of this CompanyDetailCompany.\nDate of incorporation of the company.\n\n:return: The incorporation_date of this CompanyDetailCompany.\n:rtype: str", "id": "f16307:c0:m5"}
{"signature": "@property<EOL><INDENT>def classification(self):<DEDENT>", "body": "return self._classification<EOL>", "docstring": "Gets the classification of this CompanyDetailCompany.\nClassification of Company\n\n:return: The classification of this CompanyDetailCompany.\n:rtype: str", "id": "f16307:c0:m9"}
{"signature": "@date_of_cessation.setter<EOL><INDENT>def date_of_cessation(self, date_of_cessation):<DEDENT>", "body": "self._date_of_cessation = date_of_cessation<EOL>", "docstring": "Sets the date_of_cessation of this AuthorizedSignatory.\n\n\n:param date_of_cessation: The date_of_cessation of this AuthorizedSignatory.\n:type: str", "id": "f16308:c0:m18"}
{"signature": "def __ne__(self, other):", "body": "return not self == other<EOL>", "docstring": "Returns true if both objects are not equal", "id": "f16308:c0:m23"}
{"signature": "@property<EOL><INDENT>def pan(self):<DEDENT>", "body": "return self._pan<EOL>", "docstring": "Gets the pan of this AuthorizedSignatory.\nPAN number of the Authorized Signatory\n\n:return: The pan of this AuthorizedSignatory.\n:rtype: str", "id": "f16308:c0:m3"}
{"signature": "def __repr__(self):", "body": "return self.to_str()<EOL>", "docstring": "For `print` and `pprint`", "id": "f16308:c0:m21"}
{"signature": "@pan.setter<EOL><INDENT>def pan(self, pan):<DEDENT>", "body": "self._pan = pan<EOL>", "docstring": "Sets the pan of this AuthorizedSignatory.\nPAN number of the Authorized Signatory\n\n:param pan: The pan of this AuthorizedSignatory.\n:type: str", "id": "f16308:c0:m4"}
{"signature": "def to_dict(self):", "body": "result = {}<EOL>for attr, _ in iteritems(self.swagger_types):<EOL><INDENT>value = getattr(self, attr)<EOL>if isinstance(value, list):<EOL><INDENT>result[attr] = list(map(<EOL>lambda x: x.to_dict() if hasattr(x, \"<STR_LIT>\") else x,<EOL>value<EOL>))<EOL><DEDENT>elif hasattr(value, \"<STR_LIT>\"):<EOL><INDENT>result[attr] = value.to_dict()<EOL><DEDENT>else:<EOL><INDENT>result[attr] = value<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Returns the model properties as a dict", "id": "f16308:c0:m19"}
{"signature": "@property<EOL><INDENT>def name(self):<DEDENT>", "body": "return self._name<EOL>", "docstring": "Gets the name of this AuthorizedSignatory.\nName of the Authorized Signatory\n\n:return: The name of this AuthorizedSignatory.\n:rtype: str", "id": "f16308:c0:m1"}
{"signature": "@name.setter<EOL><INDENT>def name(self, name):<DEDENT>", "body": "self._name = name<EOL>", "docstring": "Sets the name of this AuthorizedSignatory.\nName of the Authorized Signatory\n\n:param name: The name of this AuthorizedSignatory.\n:type: str", "id": "f16308:c0:m2"}
{"signature": "def __repr__(self):", "body": "return self.to_str()<EOL>", "docstring": "For `print` and `pprint`", "id": "f16309:c0:m7"}
{"signature": "@property<EOL><INDENT>def data(self):<DEDENT>", "body": "return self._data<EOL>", "docstring": "Gets the data of this InlineResponse2001.\n\n\n:return: The data of this InlineResponse2001.\n:rtype: Companies", "id": "f16309:c0:m1"}
{"signature": "def __ne__(self, other):", "body": "return not self == other<EOL>", "docstring": "Returns true if both objects are not equal", "id": "f16309:c0:m9"}
{"signature": "@property<EOL><INDENT>def meta(self):<DEDENT>", "body": "return self._meta<EOL>", "docstring": "Gets the meta of this InlineResponse2003.\n\n\n:return: The meta of this InlineResponse2003.\n:rtype: Metadata", "id": "f16311:c0:m3"}
{"signature": "def __init__(self):", "body": "self.swagger_types = {<EOL>'<STR_LIT:data>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'<EOL>}<EOL>self.attribute_map = {<EOL>'<STR_LIT:data>': '<STR_LIT:data>',<EOL>'<STR_LIT>': '<STR_LIT>'<EOL>}<EOL>self._data = None<EOL>self._meta = None<EOL>", "docstring": "InlineResponse2003 - a model defined in Swagger\n\n:param dict swaggerTypes: The key is attribute name\n                          and the value is attribute type.\n:param dict attributeMap: The key is attribute name\n                          and the value is json key in definition.", "id": "f16311:c0:m0"}
{"signature": "def __repr__(self):", "body": "return self.to_str()<EOL>", "docstring": "For `print` and `pprint`", "id": "f16311:c0:m7"}
{"signature": "@cin.setter<EOL><INDENT>def cin(self, cin):<DEDENT>", "body": "self._cin = cin<EOL>", "docstring": "Sets the cin of this CompanyBrief.\nUnique identifier representing the company - Company Identification number\n\n:param cin: The cin of this CompanyBrief.\n:type: str", "id": "f16312:c0:m4"}
{"signature": "@property<EOL><INDENT>def authorized_signatories(self):<DEDENT>", "body": "return self._authorized_signatories<EOL>", "docstring": "Gets the authorized_signatories of this CompanyAuthorizedSignatories.\n\n\n:return: The authorized_signatories of this CompanyAuthorizedSignatories.\n:rtype: list[AuthorizedSignatory]", "id": "f16313:c0:m1"}
{"signature": "def __repr__(self):", "body": "return self.to_str()<EOL>", "docstring": "For `print` and `pprint`", "id": "f16313:c0:m5"}
{"signature": "@property<EOL><INDENT>def data_status(self):<DEDENT>", "body": "return self._data_status<EOL>", "docstring": "Gets the data_status of this FinancialDataStatus.\n\n\n:return: The data_status of this FinancialDataStatus.\n:rtype: FinancialDataStatusDatastatus", "id": "f16314:c0:m1"}
{"signature": "@metadata.setter<EOL><INDENT>def metadata(self, metadata):<DEDENT>", "body": "self._metadata = metadata<EOL>", "docstring": "Sets the metadata of this InlineResponse2004.\n\n\n:param metadata: The metadata of this InlineResponse2004.\n:type: Metadata", "id": "f16315:c0:m4"}
{"signature": "@data.setter<EOL><INDENT>def data(self, data):<DEDENT>", "body": "self._data = data<EOL>", "docstring": "Sets the data of this InlineResponse2004.\n\n\n:param data: The data of this InlineResponse2004.\n:type: Charges", "id": "f16315:c0:m2"}
{"signature": "def __ne__(self, other):", "body": "return not self == other<EOL>", "docstring": "Returns true if both objects are not equal", "id": "f16316:c0:m9"}
{"signature": "def __init__(self):", "body": "self.swagger_types = {<EOL>'<STR_LIT>': '<STR_LIT:date>',<EOL>'<STR_LIT>': '<STR_LIT:date>'<EOL>}<EOL>self.attribute_map = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'<EOL>}<EOL>self._last_updated = None<EOL>self._last_fin_year_end = None<EOL>", "docstring": "FinancialDataStatusDatastatus - a model defined in Swagger\n\n:param dict swaggerTypes: The key is attribute name\n                          and the value is attribute type.\n:param dict attributeMap: The key is attribute name\n                          and the value is json key in definition.", "id": "f16316:c0:m0"}
{"signature": "@data.setter<EOL><INDENT>def data(self, data):<DEDENT>", "body": "self._data = data<EOL>", "docstring": "Sets the data of this InlineResponse2005.\n\n\n:param data: The data of this InlineResponse2005.\n:type: FinancialDataStatus", "id": "f16317:c0:m2"}
{"signature": "def __init__(self):", "body": "self.swagger_types = {<EOL>'<STR_LIT:data>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'<EOL>}<EOL>self.attribute_map = {<EOL>'<STR_LIT:data>': '<STR_LIT:data>',<EOL>'<STR_LIT>': '<STR_LIT>'<EOL>}<EOL>self._data = None<EOL>self._meta = None<EOL>", "docstring": "InlineResponse2005 - a model defined in Swagger\n\n:param dict swaggerTypes: The key is attribute name\n                          and the value is attribute type.\n:param dict attributeMap: The key is attribute name\n                          and the value is json key in definition.", "id": "f16317:c0:m0"}
{"signature": "def to_dict(self):", "body": "result = {}<EOL>for attr, _ in iteritems(self.swagger_types):<EOL><INDENT>value = getattr(self, attr)<EOL>if isinstance(value, list):<EOL><INDENT>result[attr] = list(map(<EOL>lambda x: x.to_dict() if hasattr(x, \"<STR_LIT>\") else x,<EOL>value<EOL>))<EOL><DEDENT>elif hasattr(value, \"<STR_LIT>\"):<EOL><INDENT>result[attr] = value.to_dict()<EOL><DEDENT>else:<EOL><INDENT>result[attr] = value<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Returns the model properties as a dict", "id": "f16317:c0:m5"}
{"signature": "@meta.setter<EOL><INDENT>def meta(self, meta):<DEDENT>", "body": "self._meta = meta<EOL>", "docstring": "Sets the meta of this InlineResponse2005.\n\n\n:param meta: The meta of this InlineResponse2005.\n:type: Metadata", "id": "f16317:c0:m4"}
{"signature": "def __repr__(self):", "body": "return self.to_str()<EOL>", "docstring": "For `print` and `pprint`", "id": "f16319:c0:m5"}
{"signature": "def to_str(self):", "body": "return pformat(self.to_dict())<EOL>", "docstring": "Returns the string representation of the model", "id": "f16319:c0:m4"}
{"signature": "@property<EOL><INDENT>def charges(self):<DEDENT>", "body": "return self._charges<EOL>", "docstring": "Gets the charges of this Charges.\n\n\n:return: The charges of this Charges.\n:rtype: list[Charge]", "id": "f16320:c0:m1"}
{"signature": "def to_dict(self):", "body": "result = {}<EOL>for attr, _ in iteritems(self.swagger_types):<EOL><INDENT>value = getattr(self, attr)<EOL>if isinstance(value, list):<EOL><INDENT>result[attr] = list(map(<EOL>lambda x: x.to_dict() if hasattr(x, \"<STR_LIT>\") else x,<EOL>value<EOL>))<EOL><DEDENT>elif hasattr(value, \"<STR_LIT>\"):<EOL><INDENT>result[attr] = value.to_dict()<EOL><DEDENT>else:<EOL><INDENT>result[attr] = value<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Returns the model properties as a dict", "id": "f16321:c0:m3"}
{"signature": "def to_str(self):", "body": "return pformat(self.to_dict())<EOL>", "docstring": "Returns the string representation of the model", "id": "f16321:c0:m4"}
{"signature": "def __eq__(self, other):", "body": "return self.__dict__ == other.__dict__<EOL>", "docstring": "Returns true if both objects are equal", "id": "f16321:c0:m6"}
{"signature": "def __ne__(self, other):", "body": "return not self == other<EOL>", "docstring": "Returns true if both objects are not equal", "id": "f16321:c0:m7"}
{"signature": "@property<EOL><INDENT>def address_line1(self):<DEDENT>", "body": "return self._address_line1<EOL>", "docstring": "Gets the address_line1 of this Address.\nLine 1 of Address\n\n:return: The address_line1 of this Address.\n:rtype: str", "id": "f16322:c0:m1"}
{"signature": "@state.setter<EOL><INDENT>def state(self, state):<DEDENT>", "body": "self._state = state<EOL>", "docstring": "Sets the state of this Address.\nState\n\n:param state: The state of this Address.\n:type: str", "id": "f16322:c0:m10"}
{"signature": "@property<EOL><INDENT>def pincode(self):<DEDENT>", "body": "return self._pincode<EOL>", "docstring": "Gets the pincode of this Address.\nPincode\n\n:return: The pincode of this Address.\n:rtype: str", "id": "f16322:c0:m7"}
{"signature": "@city.setter<EOL><INDENT>def city(self, city):<DEDENT>", "body": "self._city = city<EOL>", "docstring": "Sets the city of this Address.\nCity\n\n:param city: The city of this Address.\n:type: str", "id": "f16322:c0:m6"}
{"signature": "@property<EOL><INDENT>def state(self):<DEDENT>", "body": "return self._state<EOL>", "docstring": "Gets the state of this Address.\nState\n\n:return: The state of this Address.\n:rtype: str", "id": "f16322:c0:m9"}
{"signature": "@property<EOL><INDENT>def address_line2(self):<DEDENT>", "body": "return self._address_line2<EOL>", "docstring": "Gets the address_line2 of this Address.\nLine 2 of Addresss\n\n:return: The address_line2 of this Address.\n:rtype: str", "id": "f16322:c0:m3"}
{"signature": "def to_str(self):", "body": "return pformat(self.to_dict())<EOL>", "docstring": "Returns the string representation of the model", "id": "f16322:c0:m12"}
{"signature": "@address_line1.setter<EOL><INDENT>def address_line1(self, address_line1):<DEDENT>", "body": "self._address_line1 = address_line1<EOL>", "docstring": "Sets the address_line1 of this Address.\nLine 1 of Address\n\n:param address_line1: The address_line1 of this Address.\n:type: str", "id": "f16322:c0:m2"}
{"signature": "def __repr__(self):", "body": "return self.to_str()<EOL>", "docstring": "For `print` and `pprint`", "id": "f16323:c0:m17"}
{"signature": "def to_dict(self):", "body": "result = {}<EOL>for attr, _ in iteritems(self.swagger_types):<EOL><INDENT>value = getattr(self, attr)<EOL>if isinstance(value, list):<EOL><INDENT>result[attr] = list(map(<EOL>lambda x: x.to_dict() if hasattr(x, \"<STR_LIT>\") else x,<EOL>value<EOL>))<EOL><DEDENT>elif hasattr(value, \"<STR_LIT>\"):<EOL><INDENT>result[attr] = value.to_dict()<EOL><DEDENT>else:<EOL><INDENT>result[attr] = value<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Returns the model properties as a dict", "id": "f16323:c0:m15"}
{"signature": "@property<EOL><INDENT>def address(self):<DEDENT>", "body": "return self._address<EOL>", "docstring": "Gets the address of this AuthorizedSignatoryWithCompanies.\n\n\n:return: The address of this AuthorizedSignatoryWithCompanies.\n:rtype: Address", "id": "f16323:c0:m11"}
{"signature": "@property<EOL><INDENT>def authorized_signatories(self):<DEDENT>", "body": "return self._authorized_signatories<EOL>", "docstring": "Gets the authorized_signatories of this AuthorizedSignatories.\nArray of Authorized Signatories\n\n:return: The authorized_signatories of this AuthorizedSignatories.\n:rtype: list[AuthorizedSignatoryWithCompanies]", "id": "f16324:c0:m1"}
{"signature": "def to_str(self):", "body": "return pformat(self.to_dict())<EOL>", "docstring": "Returns the string representation of the model", "id": "f16324:c0:m8"}
{"signature": "def to_str(self):", "body": "return pformat(self.to_dict())<EOL>", "docstring": "Returns the string representation of the model", "id": "f16325:c0:m10"}
{"signature": "@amount.setter<EOL><INDENT>def amount(self, amount):<DEDENT>", "body": "self._amount = amount<EOL>", "docstring": "Sets the amount of this Charge.\nAmount of charges\n\n:param amount: The amount of this Charge.\n:type: int", "id": "f16325:c0:m2"}
{"signature": "def __ne__(self, other):", "body": "return not self == other<EOL>", "docstring": "Returns true if both objects are not equal", "id": "f16325:c0:m13"}
{"signature": "def __repr__(self):", "body": "return self.to_str()<EOL>", "docstring": "For `print` and `pprint`", "id": "f16325:c0:m11"}
{"signature": "def __eq__(self, other):", "body": "return self.__dict__ == other.__dict__<EOL>", "docstring": "Returns true if both objects are equal", "id": "f16325:c0:m12"}
{"signature": "def to_dict(self):", "body": "result = {}<EOL>for attr, _ in iteritems(self.swagger_types):<EOL><INDENT>value = getattr(self, attr)<EOL>if isinstance(value, list):<EOL><INDENT>result[attr] = list(map(<EOL>lambda x: x.to_dict() if hasattr(x, \"<STR_LIT>\") else x,<EOL>value<EOL>))<EOL><DEDENT>elif hasattr(value, \"<STR_LIT>\"):<EOL><INDENT>result[attr] = value.to_dict()<EOL><DEDENT>else:<EOL><INDENT>result[attr] = value<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Returns the model properties as a dict", "id": "f16326:c0:m7"}
{"signature": "def __repr__(self):", "body": "return self.to_str()<EOL>", "docstring": "For `print` and `pprint`", "id": "f16326:c0:m9"}
{"signature": "@property<EOL><INDENT>def companies(self):<DEDENT>", "body": "return self._companies<EOL>", "docstring": "Gets the companies of this Companies.\nArray of Companies\n\n:return: The companies of this Companies.\n:rtype: list[CompanyBrief]", "id": "f16326:c0:m1"}
{"signature": "def __eq__(self, other):", "body": "return self.__dict__ == other.__dict__<EOL>", "docstring": "Returns true if both objects are equal", "id": "f16326:c0:m10"}
{"signature": "@property<EOL><INDENT>def logger_file(self):<DEDENT>", "body": "return self.__logger_file<EOL>", "docstring": "Gets the logger_file.", "id": "f16327:c0:m1"}
{"signature": "def auth_settings(self):", "body": "return {<EOL>'<STR_LIT>':<EOL>{<EOL>'<STR_LIT:type>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT:key>': '<STR_LIT>',<EOL>'<STR_LIT:value>': self.get_api_key_with_prefix('<STR_LIT>')<EOL>},<EOL>}<EOL>", "docstring": "Gets Auth Settings dict for api client.\n\n:return: The Auth Settings information dict.", "id": "f16327:c0:m9"}
{"signature": "@property<EOL><INDENT>def debug(self):<DEDENT>", "body": "return self.__debug<EOL>", "docstring": "Gets the debug status.", "id": "f16327:c0:m3"}
{"signature": "def companies_cin_authorized_signatories_get(self, x_api_version, cin, **kwargs):", "body": "all_params = ['<STR_LIT>', '<STR_LIT>']<EOL>all_params.append('<STR_LIT>')<EOL>params = locals()<EOL>for key, val in iteritems(params['<STR_LIT>']):<EOL><INDENT>if key not in all_params:<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % key<EOL>)<EOL><DEDENT>params[key] = val<EOL><DEDENT>del params['<STR_LIT>']<EOL>if ('<STR_LIT>' not in params) or (params['<STR_LIT>'] is None):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if ('<STR_LIT>' not in params) or (params['<STR_LIT>'] is None):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>resource_path = '<STR_LIT>'.replace('<STR_LIT>', '<STR_LIT>')<EOL>method = '<STR_LIT:GET>'<EOL>path_params = {}<EOL>if '<STR_LIT>' in params:<EOL><INDENT>path_params['<STR_LIT>'] = params['<STR_LIT>']<EOL><DEDENT>query_params = {}<EOL>header_params = {}<EOL>if '<STR_LIT>' in params:<EOL><INDENT>header_params['<STR_LIT>'] = params['<STR_LIT>']<EOL><DEDENT>form_params = {}<EOL>files = {}<EOL>body_params = None<EOL>header_params['<STR_LIT>'] = self.api_client.select_header_accept(['<STR_LIT:application/json>'])<EOL>if not header_params['<STR_LIT>']:<EOL><INDENT>del header_params['<STR_LIT>']<EOL><DEDENT>header_params['<STR_LIT:Content-Type>'] = self.api_client.select_header_content_type([])<EOL>auth_settings = ['<STR_LIT>']<EOL>response = self.api_client.call_api(resource_path, method,<EOL>path_params,<EOL>query_params,<EOL>header_params,<EOL>body=body_params,<EOL>post_params=form_params,<EOL>files=files,<EOL>response_type='<STR_LIT>',<EOL>auth_settings=auth_settings,<EOL>callback=params.get('<STR_LIT>'))<EOL>return response<EOL>", "docstring": "Authorized Signatories\nReturns the Authorized Signatories which includes the Directors given a Company's CIN\n\nThis method makes a synchronous HTTP request by default. To make an\nasynchronous HTTP request, please define a `callback` function\nto be invoked when receiving the response.\n>>> def callback_function(response):\n>>>     pprint(response)\n>>>\n>>> thread = api.companies_cin_authorized_signatories_get(x_api_version, cin, callback=callback_function)\n\n:param callback function: The callback function\n    for asynchronous request. (optional)\n:param str x_api_version: api version (required)\n:param str cin: cin of the company to fetch (required)\n:return: InlineResponse2003\n         If the method is called asynchronously,\n         returns the request thread.", "id": "f16329:c0:m2"}
{"signature": "def companies_cin_charges_get(self, x_api_version, cin, **kwargs):", "body": "all_params = ['<STR_LIT>', '<STR_LIT>']<EOL>all_params.append('<STR_LIT>')<EOL>params = locals()<EOL>for key, val in iteritems(params['<STR_LIT>']):<EOL><INDENT>if key not in all_params:<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % key<EOL>)<EOL><DEDENT>params[key] = val<EOL><DEDENT>del params['<STR_LIT>']<EOL>if ('<STR_LIT>' not in params) or (params['<STR_LIT>'] is None):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if ('<STR_LIT>' not in params) or (params['<STR_LIT>'] is None):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>resource_path = '<STR_LIT>'.replace('<STR_LIT>', '<STR_LIT>')<EOL>method = '<STR_LIT:GET>'<EOL>path_params = {}<EOL>if '<STR_LIT>' in params:<EOL><INDENT>path_params['<STR_LIT>'] = params['<STR_LIT>']<EOL><DEDENT>query_params = {}<EOL>header_params = {}<EOL>if '<STR_LIT>' in params:<EOL><INDENT>header_params['<STR_LIT>'] = params['<STR_LIT>']<EOL><DEDENT>form_params = {}<EOL>files = {}<EOL>body_params = None<EOL>header_params['<STR_LIT>'] = self.api_client.select_header_accept(['<STR_LIT:application/json>'])<EOL>if not header_params['<STR_LIT>']:<EOL><INDENT>del header_params['<STR_LIT>']<EOL><DEDENT>header_params['<STR_LIT:Content-Type>'] = self.api_client.select_header_content_type([])<EOL>auth_settings = ['<STR_LIT>']<EOL>response = self.api_client.call_api(resource_path, method,<EOL>path_params,<EOL>query_params,<EOL>header_params,<EOL>body=body_params,<EOL>post_params=form_params,<EOL>files=files,<EOL>response_type='<STR_LIT>',<EOL>auth_settings=auth_settings,<EOL>callback=params.get('<STR_LIT>'))<EOL>return response<EOL>", "docstring": "Charges\nReturns the Charge details given a Company's CIN\n\nThis method makes a synchronous HTTP request by default. To make an\nasynchronous HTTP request, please define a `callback` function\nto be invoked when receiving the response.\n>>> def callback_function(response):\n>>>     pprint(response)\n>>>\n>>> thread = api.companies_cin_charges_get(x_api_version, cin, callback=callback_function)\n\n:param callback function: The callback function\n    for asynchronous request. (optional)\n:param str x_api_version: api version (required)\n:param str cin: cin of the company to fetch (required)\n:return: InlineResponse2004\n         If the method is called asynchronously,\n         returns the request thread.", "id": "f16329:c0:m3"}
{"signature": "def companies_cin_update_post(self, x_api_version, cin, **kwargs):", "body": "all_params = ['<STR_LIT>', '<STR_LIT>']<EOL>all_params.append('<STR_LIT>')<EOL>params = locals()<EOL>for key, val in iteritems(params['<STR_LIT>']):<EOL><INDENT>if key not in all_params:<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % key<EOL>)<EOL><DEDENT>params[key] = val<EOL><DEDENT>del params['<STR_LIT>']<EOL>if ('<STR_LIT>' not in params) or (params['<STR_LIT>'] is None):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if ('<STR_LIT>' not in params) or (params['<STR_LIT>'] is None):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>resource_path = '<STR_LIT>'.replace('<STR_LIT>', '<STR_LIT>')<EOL>method = '<STR_LIT:POST>'<EOL>path_params = {}<EOL>if '<STR_LIT>' in params:<EOL><INDENT>path_params['<STR_LIT>'] = params['<STR_LIT>']<EOL><DEDENT>query_params = {}<EOL>header_params = {}<EOL>if '<STR_LIT>' in params:<EOL><INDENT>header_params['<STR_LIT>'] = params['<STR_LIT>']<EOL><DEDENT>form_params = {}<EOL>files = {}<EOL>body_params = None<EOL>header_params['<STR_LIT>'] = self.api_client.select_header_accept(['<STR_LIT:application/json>'])<EOL>if not header_params['<STR_LIT>']:<EOL><INDENT>del header_params['<STR_LIT>']<EOL><DEDENT>header_params['<STR_LIT:Content-Type>'] = self.api_client.select_header_content_type([])<EOL>auth_settings = ['<STR_LIT>']<EOL>response = self.api_client.call_api(resource_path, method,<EOL>path_params,<EOL>query_params,<EOL>header_params,<EOL>body=body_params,<EOL>post_params=form_params,<EOL>files=files,<EOL>response_type=None,<EOL>auth_settings=auth_settings,<EOL>callback=params.get('<STR_LIT>'))<EOL>return response<EOL>", "docstring": "Update Company data\nThis is an asynchronous call, where the request to update the company data is queued.\\nYou will have to call the financial-datastatus to see if the update has happened.\n\nThis method makes a synchronous HTTP request by default. To make an\nasynchronous HTTP request, please define a `callback` function\nto be invoked when receiving the response.\n>>> def callback_function(response):\n>>>     pprint(response)\n>>>\n>>> thread = api.companies_cin_update_post(x_api_version, cin, callback=callback_function)\n\n:param callback function: The callback function\n    for asynchronous request. (optional)\n:param str x_api_version: api version (required)\n:param str cin: cin of the company to update (required)\n:return: None\n         If the method is called asynchronously,\n         returns the request thread.", "id": "f16329:c0:m6"}
{"signature": "def companies_cin_financial_datastatus_get(self, x_api_version, cin, **kwargs):", "body": "all_params = ['<STR_LIT>', '<STR_LIT>']<EOL>all_params.append('<STR_LIT>')<EOL>params = locals()<EOL>for key, val in iteritems(params['<STR_LIT>']):<EOL><INDENT>if key not in all_params:<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % key<EOL>)<EOL><DEDENT>params[key] = val<EOL><DEDENT>del params['<STR_LIT>']<EOL>if ('<STR_LIT>' not in params) or (params['<STR_LIT>'] is None):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if ('<STR_LIT>' not in params) or (params['<STR_LIT>'] is None):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>resource_path = '<STR_LIT>'.replace('<STR_LIT>', '<STR_LIT>')<EOL>method = '<STR_LIT:GET>'<EOL>path_params = {}<EOL>if '<STR_LIT>' in params:<EOL><INDENT>path_params['<STR_LIT>'] = params['<STR_LIT>']<EOL><DEDENT>query_params = {}<EOL>header_params = {}<EOL>if '<STR_LIT>' in params:<EOL><INDENT>header_params['<STR_LIT>'] = params['<STR_LIT>']<EOL><DEDENT>form_params = {}<EOL>files = {}<EOL>body_params = None<EOL>header_params['<STR_LIT>'] = self.api_client.select_header_accept(['<STR_LIT:application/json>'])<EOL>if not header_params['<STR_LIT>']:<EOL><INDENT>del header_params['<STR_LIT>']<EOL><DEDENT>header_params['<STR_LIT:Content-Type>'] = self.api_client.select_header_content_type([])<EOL>auth_settings = ['<STR_LIT>']<EOL>response = self.api_client.call_api(resource_path, method,<EOL>path_params,<EOL>query_params,<EOL>header_params,<EOL>body=body_params,<EOL>post_params=form_params,<EOL>files=files,<EOL>response_type='<STR_LIT>',<EOL>auth_settings=auth_settings,<EOL>callback=params.get('<STR_LIT>'))<EOL>return response<EOL>", "docstring": "Financial Data Status\nReturns the financial status of the company - years for which balancesheet is present\n\nThis method makes a synchronous HTTP request by default. To make an\nasynchronous HTTP request, please define a `callback` function\nto be invoked when receiving the response.\n>>> def callback_function(response):\n>>>     pprint(response)\n>>>\n>>> thread = api.companies_cin_financial_datastatus_get(x_api_version, cin, callback=callback_function)\n\n:param callback function: The callback function\n    for asynchronous request. (optional)\n:param str x_api_version: api version (required)\n:param str cin: cin of the company to fetch (required)\n:return: InlineResponse2005\n         If the method is called asynchronously,\n         returns the request thread.", "id": "f16329:c0:m4"}
{"signature": "def Counter64(a, b, delta):", "body": "if b < a:<EOL><INDENT>c = <NUM_LIT> - a<EOL>return (c + b) / float(delta)<EOL><DEDENT>return (b - a) / float(delta)<EOL>", "docstring": "64bit counter aggregator with wrapping", "id": "f16357:m1"}
{"signature": "@defer.inlineCallbacks<EOL><INDENT>def stop_service(self, service):<DEDENT>", "body": "yield wait(<NUM_LIT:0.1>)<EOL>yield service.stopService()<EOL>yield wait(<NUM_LIT:0.1>)<EOL>", "docstring": "Wait a little bit before and after stopping the service for things to\nhappen in the right order. :-(", "id": "f16359:c4:m3"}
{"signature": "def startTimer(self):", "body": "self.td = self.t.start(self.inter)<EOL>if self.use_ssh and self.ssh_connector:<EOL><INDENT>self.ssh_client.connect()<EOL><DEDENT>", "docstring": "Starts the timer for this source", "id": "f16366:c2:m3"}
{"signature": "def encodeMessage(self, events):", "body": "message = proto_pb2.Msg(<EOL>events=[self.encodeEvent(e) for e in events if e._type=='<STR_LIT>']<EOL>)<EOL>return message.SerializeToString()<EOL>", "docstring": "Encode a list of Tensor events with protobuf", "id": "f16368:c0:m1"}
{"signature": "def ping(dst, count, inter=<NUM_LIT>, maxwait=<NUM_LIT:1000>, size=<NUM_LIT:64>):", "body": "def _then(result, p):<EOL><INDENT>p.stopListening()<EOL>return result<EOL><DEDENT>d = defer.Deferred()<EOL>p = ICMPPort(<NUM_LIT:0>, ICMPPing(d, dst, count, inter, maxwait, size), \"<STR_LIT>\", <NUM_LIT>, reactor)<EOL>p.startListening()<EOL>return d.addCallback(_then, p)<EOL>", "docstring": "Sends ICMP echo requests to destination `dst` `count` times.\n    Returns a deferred which fires when responses are finished.", "id": "f16376:m0"}
{"signature": "def get(self, max_lines=None):", "body": "rows = []<EOL>self.get_fn(lambda row: rows.append(row), max_lines=max_lines)<EOL>return rows<EOL>", "docstring": "Returns a big list of all log lines since the last run", "id": "f16379:c0:m5"}
{"signature": "def get(self, k):", "body": "if self._changed():<EOL><INDENT>self._read()<EOL><DEDENT>if k in self.store:<EOL><INDENT>return tuple(self.store[k])<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Returns key contents, and modify time", "id": "f16381:c7:m9"}
{"signature": "def expire(self, age):", "body": "now = time.time()<EOL>cache = self._acquire_cache()<EOL>expired = [k for k, v in cache.items() if (now - v[<NUM_LIT:0>]) > age]<EOL>for k in expired:<EOL><INDENT>if k in cache:<EOL><INDENT>del cache[k]<EOL><DEDENT>if k in self.store:<EOL><INDENT>del self.store[k]<EOL><DEDENT><DEDENT>self._write_cache(cache)<EOL>", "docstring": "Expire any items in the cache older than `age` seconds", "id": "f16381:c7:m7"}
{"signature": "def fork(executable, args=(), env={}, path=None, timeout=<NUM_LIT>):", "body": "d = defer.Deferred()<EOL>p = ProcessProtocol(d, timeout)<EOL>reactor.spawnProcess(p, executable, (executable,)+tuple(args), env, path)<EOL>return d<EOL>", "docstring": "fork\n    Provides a deferred wrapper function with a timeout function\n\n    :param executable: Executable\n    :type executable: str.\n    :param args: Tupple of arguments\n    :type args: tupple.\n    :param env: Environment dictionary\n    :type env: dict.\n    :param timeout: Kill the child process if timeout is exceeded\n    :type timeout: int.", "id": "f16381:m0"}
{"signature": "def getBody(self, url, method='<STR_LIT:GET>', headers={}, data=None, socket=None):", "body": "if not '<STR_LIT>' in headers:<EOL><INDENT>headers['<STR_LIT>'] = ['<STR_LIT>']<EOL><DEDENT>return self.request(url, method, headers, data, socket)<EOL>", "docstring": "Make an HTTP request and return the body", "id": "f16381:c6:m4"}
{"signature": "@defer.inlineCallbacks<EOL><INDENT>def getJson(self, url, method='<STR_LIT:GET>', headers={}, data=None, socket=None):<DEDENT>", "body": "if not '<STR_LIT:Content-Type>' in headers:<EOL><INDENT>headers['<STR_LIT:Content-Type>'] = ['<STR_LIT:application/json>']<EOL><DEDENT>body = yield self.getBody(url, method, headers, data, socket)<EOL>defer.returnValue(json.loads(body))<EOL>", "docstring": "Fetch a JSON result via HTTP", "id": "f16381:c6:m5"}
{"signature": "def contains(self, k):", "body": "if self._changed():<EOL><INDENT>self._read()<EOL><DEDENT>return k in self.store.keys()<EOL>", "docstring": "Return True if key `k` exists", "id": "f16381:c7:m10"}
{"signature": "def createClient(self):", "body": "server = self.config.get('<STR_LIT>', '<STR_LIT:127.0.0.1>')<EOL>port = self.config.get('<STR_LIT:port>', <NUM_LIT>)<EOL>def connect(ip):<EOL><INDENT>self.protocol = riemann.RiemannUDP(ip, port)<EOL>self.endpoint = reactor.listenUDP(<NUM_LIT:0>, self.protocol)<EOL><DEDENT>d = reactor.resolve(server)<EOL>d.addCallback(connect)<EOL>return d<EOL>", "docstring": "Create a UDP connection to Riemann", "id": "f16382:c1:m1"}
{"signature": "def stop(self):", "body": "self.t.stop()<EOL>", "docstring": "Stop this client.", "id": "f16383:c0:m2"}
{"signature": "def setupOutputs(self, config):", "body": "if self.proto == '<STR_LIT>':<EOL><INDENT>defaultOutput = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': self.server,<EOL>'<STR_LIT:port>': self.port<EOL>}<EOL><DEDENT>else:<EOL><INDENT>defaultOutput = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': self.server,<EOL>'<STR_LIT:port>': self.port<EOL>}<EOL><DEDENT>outputs = config.get('<STR_LIT>', [defaultOutput])<EOL>for output in outputs:<EOL><INDENT>if not ('<STR_LIT>' in output):<EOL><INDENT>output['<STR_LIT>'] = self.debug<EOL><DEDENT>cl = output['<STR_LIT>'].split('<STR_LIT:.>')[-<NUM_LIT:1>]                <EOL>path = '<STR_LIT:.>'.join(output['<STR_LIT>'].split('<STR_LIT:.>')[:-<NUM_LIT:1>])   <EOL>outputObj = getattr(<EOL>importlib.import_module(path), cl)(output, self)<EOL>name = output.get('<STR_LIT:name>', None)<EOL>if name in self.outputs:<EOL><INDENT>self.outputs[name].append(outputObj)<EOL><DEDENT>else:<EOL><INDENT>self.outputs[name] = [outputObj]<EOL><DEDENT>reactor.callLater(<NUM_LIT:0>, outputObj.createClient)<EOL><DEDENT>", "docstring": "Setup output processors", "id": "f16384:c0:m1"}
{"signature": "def to_child(self, append_message=\"<STR_LIT>\", node_name=\"<STR_LIT>\", **kwargs):", "body": "base_kwargs = {<EOL>attr: getattr(self, attr)<EOL>for attr in self.params<EOL>if attr not in [\"<STR_LIT>\"]<EOL>}<EOL>if not isinstance(append_message, dict):<EOL><INDENT>append_message = {\"<STR_LIT>\": append_message, \"<STR_LIT>\": {}}<EOL><DEDENT>kwargs[\"<STR_LIT>\"] = [*self.messages, append_message]<EOL>kwargs[\"<STR_LIT>\"] = self<EOL>for kwarg in [\"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>if kwarg in kwargs and not kwargs[kwarg]:<EOL><INDENT>kwargs.pop(kwarg, None)<EOL><DEDENT><DEDENT>def update_kwarg(name, func):<EOL><INDENT>kwargs[name] = func(kwargs[name])<EOL><DEDENT>def update_context(name):<EOL><INDENT>update_kwarg(name, getattr(self, name).update_ctx)<EOL><DEDENT>if isinstance(kwargs.get(\"<STR_LIT>\", None), list):<EOL><INDENT>update_kwarg(\"<STR_LIT>\", wrap_in_module)<EOL><DEDENT>if isinstance(kwargs.get(\"<STR_LIT>\", None), list):<EOL><INDENT>update_kwarg(\"<STR_LIT>\", wrap_in_module)<EOL><DEDENT>if \"<STR_LIT>\" in kwargs:<EOL><INDENT>kwargs[\"<STR_LIT>\"] = self.student_ast_tokens.get_text(<EOL>kwargs[\"<STR_LIT>\"]<EOL>)<EOL><DEDENT>if \"<STR_LIT>\" in kwargs:<EOL><INDENT>kwargs[\"<STR_LIT>\"] = self.solution_ast_tokens.get_text(<EOL>kwargs[\"<STR_LIT>\"]<EOL>)<EOL><DEDENT>if \"<STR_LIT>\" in kwargs:<EOL><INDENT>update_context(\"<STR_LIT>\")<EOL><DEDENT>if \"<STR_LIT>\" in kwargs:<EOL><INDENT>update_context(\"<STR_LIT>\")<EOL><DEDENT>if \"<STR_LIT>\" in kwargs:<EOL><INDENT>update_context(\"<STR_LIT>\")<EOL><DEDENT>if \"<STR_LIT>\" in kwargs:<EOL><INDENT>update_context(\"<STR_LIT>\")<EOL><DEDENT>klass = self.SUBCLASSES[node_name] if node_name else State<EOL>child = klass(**{**base_kwargs, **kwargs})<EOL>return child<EOL>", "docstring": "Dive into nested tree.\n\n        Set the current state as a state with a subtree of this syntax tree as\n        student tree and solution tree. This is necessary when testing if statements or\n        for loops for example.", "id": "f16430:c1:m2"}
{"signature": "def check_object(<EOL>state, index, missing_msg=None, expand_msg=None, typestr=\"<STR_LIT>\"<EOL>):", "body": "<EOL>if v2_only():<EOL><INDENT>extra_msg = \"<STR_LIT>\"<EOL>state.assert_root(\"<STR_LIT>\", extra_msg=extra_msg)<EOL><DEDENT>if missing_msg is None:<EOL><INDENT>missing_msg = \"<STR_LIT>\"<EOL><DEDENT>if expand_msg is None:<EOL><INDENT>expand_msg = \"<STR_LIT>\"<EOL><DEDENT>if (<EOL>not isDefinedInProcess(index, state.solution_process)<EOL>and state.has_different_processes()<EOL>):<EOL><INDENT>raise InstructorError(<EOL>\"<STR_LIT>\"<EOL>% index<EOL>)<EOL><DEDENT>append_message = {\"<STR_LIT>\": expand_msg, \"<STR_LIT>\": {\"<STR_LIT:index>\": index, \"<STR_LIT>\": typestr}}<EOL>fallback = lambda: ObjectAssignmentParser.get_part(index)<EOL>stu_part = state.ast_dispatcher(\"<STR_LIT>\", state.student_ast).get(index, fallback())<EOL>sol_part = state.ast_dispatcher(\"<STR_LIT>\", state.solution_ast).get(index, fallback())<EOL>_msg = state.build_message(missing_msg, append_message[\"<STR_LIT>\"])<EOL>state.do_test(DefinedProcessTest(index, state.student_process, Feedback(_msg)))<EOL>child = part_to_child(<EOL>stu_part, sol_part, append_message, state, node_name=\"<STR_LIT>\"<EOL>)<EOL>return child<EOL>", "docstring": "Check object existence (and equality)\n\n    Check whether an object is defined in the student's process, and zoom in on its value in both\n    student and solution process to inspect quality (with has_equal_value().\n\n    In ``pythonbackend``, both the student's submission as well as the solution code are executed, in separate processes.\n    ``check_object()`` looks at these processes and checks if the referenced object is available in the student process.\n    Next, you can use ``has_equal_value()`` to check whether the objects in the student and solution process correspond.\n\n    Args:\n        index (str): the name of the object which value has to be checked.\n        missing_msg (str): feedback message when the object is not defined in the student process.\n        expand_msg (str): If specified, this overrides any messages that are prepended by previous SCT chains.\n\n    :Example:\n\n        Suppose you want the student to create a variable ``x``, equal to 15: ::\n\n            x = 15\n\n        The following SCT will verify this: ::\n\n            Ex().check_object(\"x\").has_equal_value()\n\n        - ``check_object()`` will check if the variable ``x`` is defined in the student process.\n        - ``has_equal_value()`` will check whether the value of ``x`` in the solution process is the same as in the student process.\n\n        Note that ``has_equal_value()`` only looks at **end result** of a variable in the student process.\n        In the example, how the object ``x`` came about in the student's submission, does not matter.    \n        This means that all of the following submission will also pass the above SCT: ::\n\n            x = 15\n            x = 12 + 3\n            x = 3; x += 12\n\n    :Example:\n\n        As the previous example mentioned, ``has_equal_value()`` only looks at the **end result**. If your exercise is\n        first initializing and object and further down the script is updating the object, you can only look at the final value!\n\n        Suppose you want the student to initialize and populate a list `my_list` as follows: ::\n\n            my_list = []\n            for i in range(20):\n                if i % 3 == 0:\n                    my_list.append(i)\n\n        There is no robust way to verify whether `my_list = [0]` was coded correctly in a separate way.\n        The best SCT would look something like this: ::\n\n            msg = \"Have you correctly initialized `my_list`?\"\n            Ex().check_correct(\n                check_object('my_list').has_equal_value(),\n                multi(\n                    # check initialization: [] or list()\n                    check_or(\n                        has_equal_ast(code = \"[]\", incorrect_msg = msg),\n                        check_function('list')\n                    ),\n                    check_for_loop().multi(\n                        check_iter().has_equal_value(),\n                        check_body().check_if_else().multi(\n                            check_test().multi(\n                                set_context(2).has_equal_value(),\n                                set_context(3).has_equal_value()\n                            ),\n                            check_body().set_context(3).\\\\\n                                set_env(my_list = [0]).\\\\\n                                has_equal_value(name = 'my_list')\n                        )\n                    )\n                )\n            )\n\n        - ``check_correct()`` is used to robustly check whether ``my_list`` was built correctly.\n        - If ``my_list`` is not correct, **both** the initialization and the population code are checked.\n\n    :Example:\n\n        Because checking object correctness incorrectly is such a common misconception, we're adding another example: ::\n\n            import pandas as pd\n            df = pd.DataFrame({'a': [1, 2, 3], 'b': [4, 5, 6]})\n            df['c'] = [7, 8, 9]\n\n        The following SCT would be **wrong**, as it does not factor in the possibility that the 'add column ``c``' step could've been wrong: ::\n\n            Ex().check_correct(\n                check_object('df').has_equal_value(),\n                check_function('pandas.DataFrame').check_args(0).has_equal_value()\n            )\n\n        The following SCT would be better, as it is specific to the steps: ::\n\n            # verify the df = pd.DataFrame(...) step\n            Ex().check_correct(\n                check_df('df').multi(\n                    check_keys('a').has_equal_value(),\n                    check_keys('b').has_equal_value()\n                ),\n                check_function('pandas.DataFrame').check_args(0).has_equal_value()\n            )\n\n            # verify the df['c'] = [...] step\n            Ex().check_df('df').check_keys('c').has_equal_value()\n\n    :Example:\n\n        pythonwhat compares the objects in the student and solution process with the ``==`` operator.\n        For basic objects, this ``==`` is operator is properly implemented, so that the objects can be effectively compared.\n        For more complex objects that are produced by third-party packages, however, it's possible that this equality operator is not implemented in a way you'd expect.\n        Often, for these object types the ``==`` will compare the actual object instances: ::\n\n            # pre exercise code\n            class Number():\n                def __init__(self, n):\n                    self.n = n\n\n            # solution\n            x = Number(1)\n\n            # sct that won't work\n            Ex().check_object().has_equal_value()\n\n            # sct\n            Ex().check_object().has_equal_value(expr_code = 'x.n')\n\n            # submissions that will pass this sct\n            x = Number(1)\n            x = Number(2 - 1)\n\n        The basic SCT like in the previous example will notwork here.\n        Notice how we used the ``expr_code`` argument to _override_ which value `has_equal_value()` is checking.\n        Instead of checking whether `x` corresponds between student and solution process, it's now executing the expression ``x.n``\n        and seeing if the result of running this expression in both student and solution process match.", "id": "f16435:m0"}
{"signature": "def has_output(state, text, pattern=True, no_output_msg=None):", "body": "if not no_output_msg:<EOL><INDENT>no_output_msg = \"<STR_LIT>\"<EOL><DEDENT>_msg = state.build_message(no_output_msg)<EOL>state.do_test(StringContainsTest(state.raw_student_output, text, pattern, _msg))<EOL>return state<EOL>", "docstring": "Search student output for a pattern.\n\n    Among the student and solution process, the student submission and solution code as a string,\n    the ``Ex()`` state also contains the output that a student generated with his or her submission.\n\n    With ``has_output()``, you can access this output and match it against a regular or fixed expression.\n\n    Args:\n        text (str): the text that is searched for\n        pattern (bool): if True (default), the text is treated as a pattern. If False, it is treated as plain text.\n        no_output_msg (str): feedback message to be displayed if the output is not found.\n\n    :Example:\n\n        As an example, suppose we want a student to print out a sentence: ::\n\n            # Print the \"This is some ... stuff\"\n            print(\"This is some weird stuff\")\n\n        The following SCT tests whether the student prints out ``This is some weird stuff``: ::\n\n            # Using exact string matching\n            Ex().has_output(\"This is some weird stuff\", pattern = False)\n\n            # Using a regular expression (more robust)\n            # pattern = True is the default\n            msg = \"Print out ``This is some ... stuff`` to the output, \" + \\\\\n                  \"fill in ``...`` with a word you like.\"\n            Ex().has_output(r\"This is some \\w* stuff\", no_output_msg = msg)", "id": "f16437:m7"}
{"signature": "def has_import(<EOL>state,<EOL>name,<EOL>same_as=False,<EOL>not_imported_msg=\"<STR_LIT>\",<EOL>incorrect_as_msg=\"<STR_LIT>\",<EOL>):", "body": "student_imports = state.ast_dispatcher(\"<STR_LIT>\", state.student_ast)<EOL>solution_imports = state.ast_dispatcher(\"<STR_LIT>\", state.solution_ast)<EOL>if name not in solution_imports:<EOL><INDENT>raise InstructorError(<EOL>\"<STR_LIT>\"<EOL>% name<EOL>)<EOL><DEDENT>fmt_kwargs = {\"<STR_LIT>\": name, \"<STR_LIT>\": solution_imports[name]}<EOL>_msg = state.build_message(not_imported_msg, fmt_kwargs)<EOL>state.do_test(DefinedCollTest(name, student_imports, _msg))<EOL>if same_as:<EOL><INDENT>_msg = state.build_message(incorrect_as_msg, fmt_kwargs)<EOL>state.do_test(EqualTest(solution_imports[name], student_imports[name], _msg))<EOL><DEDENT>return state<EOL>", "docstring": "Checks whether student imported a package or function correctly.\n\n    Python features many ways to import packages.\n    All of these different methods revolve around the ``import``, ``from`` and ``as`` keywords.\n    ``has_import()`` provides a robust way to check whether a student correctly imported a certain package.\n\n    By default, ``has_import()`` allows for different ways of aliasing the imported package or function.\n    If you want to make sure the correct alias was used to refer to the package or function that was imported,\n    set ``same_as=True``.\n\n    Args:\n        name (str): the name of the package that has to be checked.\n        same_as (bool): if True, the alias of the package or function has to be the same. Defaults to False.\n        not_imported_msg (str): feedback message when the package is not imported.\n        incorrect_as_msg (str): feedback message if the alias is wrong.\n\n    :Example:\n\n        Example 1, where aliases don't matter (defaut): ::\n\n            # solution\n            import matplotlib.pyplot as plt\n\n            # sct\n            Ex().has_import(\"matplotlib.pyplot\")\n\n            # passing submissions\n            import matplotlib.pyplot as plt\n            from matplotlib import pyplot as plt\n            import matplotlib.pyplot as pltttt\n\n            # failing submissions\n            import matplotlib as mpl\n\n        Example 2, where the SCT is coded so aliases do matter: ::\n\n            # solution\n            import matplotlib.pyplot as plt\n\n            # sct\n            Ex().has_import(\"matplotlib.pyplot\", same_as=True)\n\n            # passing submissions\n            import matplotlib.pyplot as plt\n            from matplotlib import pyplot as plt\n\n            # failing submissions\n            import matplotlib.pyplot as pltttt", "id": "f16437:m6"}
{"signature": "def has_equal_part_len(state, name, unequal_msg):", "body": "d = dict(<EOL>stu_len=len(state.student_parts[name]), sol_len=len(state.solution_parts[name])<EOL>)<EOL>if d[\"<STR_LIT>\"] != d[\"<STR_LIT>\"]:<EOL><INDENT>_msg = state.build_message(unequal_msg, d)<EOL>state.report(Feedback(_msg, state))<EOL><DEDENT>return state<EOL>", "docstring": "Verify that a part that is zoomed in on has equal length.\n\n    Typically used in the context of ``check_function_def()``\n\n    Arguments:\n        name (str): name of the part for which to check the length to the corresponding part in the solution.\n        unequal_msg (str): Message in case the lengths do not match.\n        state (State): state as passed by the SCT chain. Don't specify this explicitly.\n\n    :Examples:\n\n        Student and solution code::\n\n            def shout(word):\n                return word + '!!!'\n\n        SCT that checks number of arguments::\n\n            Ex().check_function_def('shout').has_equal_part_len('args', 'not enough args!')", "id": "f16437:m2"}
{"signature": "def check_function(<EOL>state,<EOL>name,<EOL>index=<NUM_LIT:0>,<EOL>missing_msg=None,<EOL>params_not_matched_msg=None,<EOL>expand_msg=None,<EOL>signature=True,<EOL>):", "body": "append_missing = missing_msg is None<EOL>append_params_not_matched = params_not_matched_msg is None<EOL>if missing_msg is None:<EOL><INDENT>missing_msg = MISSING_MSG<EOL><DEDENT>if expand_msg is None:<EOL><INDENT>expand_msg = PREPEND_MSG<EOL><DEDENT>if params_not_matched_msg is None:<EOL><INDENT>params_not_matched_msg = SIG_ISSUE_MSG<EOL><DEDENT>stu_out = state.ast_dispatcher(\"<STR_LIT>\", state.student_ast)<EOL>sol_out = state.ast_dispatcher(\"<STR_LIT>\", state.solution_ast)<EOL>student_mappings = state.ast_dispatcher(\"<STR_LIT>\", state.student_ast)<EOL>fmt_kwargs = {<EOL>\"<STR_LIT>\": get_times(index + <NUM_LIT:1>),<EOL>\"<STR_LIT>\": get_ord(index + <NUM_LIT:1>),<EOL>\"<STR_LIT:index>\": index,<EOL>\"<STR_LIT>\": get_mapped_name(name, student_mappings),<EOL>}<EOL>try:<EOL><INDENT>sol_parts = {**sol_out[name][index]}<EOL><DEDENT>except KeyError:<EOL><INDENT>raise InstructorError(<EOL>\"<STR_LIT>\"<EOL>% name<EOL>)<EOL><DEDENT>except IndexError:<EOL><INDENT>raise InstructorError(<EOL>\"<STR_LIT>\"<EOL>% (index + <NUM_LIT:1>, name)<EOL>)<EOL><DEDENT>try:<EOL><INDENT>stu_parts = {**stu_out[name][index]}<EOL><DEDENT>except (KeyError, IndexError):<EOL><INDENT>_msg = state.build_message(missing_msg, fmt_kwargs, append=append_missing)<EOL>state.report(Feedback(_msg, state))<EOL><DEDENT>if signature:<EOL><INDENT>signature = None if isinstance(signature, bool) else signature<EOL>get_sig = partial(<EOL>getSignatureInProcess,<EOL>name=name,<EOL>signature=signature,<EOL>manual_sigs=state.get_manual_sigs(),<EOL>)<EOL>try:<EOL><INDENT>sol_sig = get_sig(<EOL>mapped_name=sol_parts[\"<STR_LIT:name>\"], process=state.solution_process<EOL>)<EOL>sol_parts[\"<STR_LIT:args>\"] = bind_args(sol_sig, sol_parts[\"<STR_LIT:args>\"])<EOL><DEDENT>except Exception as e:<EOL><INDENT>raise InstructorError(<EOL>\"<STR_LIT>\"<EOL>% (get_ord(index + <NUM_LIT:1>), name, e)<EOL>)<EOL><DEDENT>try:<EOL><INDENT>stu_sig = get_sig(<EOL>mapped_name=stu_parts[\"<STR_LIT:name>\"], process=state.student_process<EOL>)<EOL>stu_parts[\"<STR_LIT:args>\"] = bind_args(stu_sig, stu_parts[\"<STR_LIT:args>\"])<EOL><DEDENT>except Exception:<EOL><INDENT>_msg = state.build_message(<EOL>params_not_matched_msg, fmt_kwargs, append=append_params_not_matched<EOL>)<EOL>state.report(<EOL>Feedback(<EOL>_msg, StubState(stu_parts[\"<STR_LIT>\"], state.highlighting_disabled)<EOL>)<EOL>)<EOL><DEDENT><DEDENT>append_message = {\"<STR_LIT>\": expand_msg, \"<STR_LIT>\": fmt_kwargs}<EOL>child = part_to_child(<EOL>stu_parts, sol_parts, append_message, state, node_name=\"<STR_LIT>\"<EOL>)<EOL>return child<EOL>", "docstring": "Check whether a particular function is called.\n\n    ``check_function()`` is typically followed by:\n\n    - ``check_args()`` to check whether the arguments were specified.\n      In turn, ``check_args()`` can be followed by ``has_equal_value()`` or ``has_equal_ast()``\n      to assert that the arguments were correctly specified.\n    - ``has_equal_value()`` to check whether rerunning the function call coded by the student\n      gives the same result as calling the function call as in the solution.\n\n    Checking function calls is a tricky topic. Please visit the\n    `dedicated article <articles/checking_function_calls.html>`_ for more explanation,\n    edge cases and best practices.\n\n    Args:\n        name (str): the name of the function to be tested. When checking functions in packages, always\n            use the 'full path' of the function.\n        index (int): index of the function call to be checked. Defaults to 0.\n        missing_msg (str): If specified, this overrides an automatically generated feedback message in case\n            the student did not call the function correctly.\n        params_not_matched_msg (str): If specified, this overrides an automatically generated feedback message\n            in case the function parameters were not successfully matched.\n        expand_msg (str): If specified, this overrides any messages that are prepended by previous SCT chains.\n        signature (Signature): Normally, check_function() can figure out what the function signature is,\n            but it might be necessary to use ``sig_from_params()`` to manually build a signature and pass this along.\n        state (State): State object that is passed from the SCT Chain (don't specify this).\n\n    :Examples:\n\n        Student code and solution code::\n\n            import numpy as np\n            arr = np.array([1, 2, 3, 4, 5])\n            np.mean(arr)\n\n        SCT::\n\n            # Verify whether arr was correctly set in np.mean\n            Ex().check_function('numpy.mean').check_args('a').has_equal_value()\n\n            # Verify whether np.mean(arr) produced the same result\n            Ex().check_function('numpy.mean').has_equal_value()", "id": "f16438:m2"}
{"signature": "def generic_visit(self, node):", "body": "pass<EOL>", "docstring": "This function is called when all other nodes are encountered when traversing the tree.\nWhen inheriting form this standard parser, this function will make the parser ignore\nall nodes that are not relevant.\n\nArgs:\n    node (ast.Node): The node which is visited.", "id": "f16441:c3:m3"}
{"signature": "def __init__(self, string, search_string, pattern, feedback):", "body": "super().__init__(feedback)<EOL>self.string = string<EOL>self.search_string = search_string<EOL>self.pattern = pattern<EOL>", "docstring": "Initialize with a string to look for, a string to search and whether or not to look for a pattern.\n\nArgs:\n    string (regex/str):  The string to look for will be set to this.\n    search_string (str): The string to search in will be set to this.\n    pattern (bool): The pattern boolean will be set to this.\n    feedback (str): The failure message will be set to this.", "id": "f16442:c6:m0"}
{"signature": "def success_msg(message):", "body": "State.root_state.reporter.success_msg = message<EOL>", "docstring": "Set the succes message of the sct. This message will be the feedback if all tests pass.\nArgs:\n        message (str): A string containing the feedback message.", "id": "f16444:m1"}
{"signature": "def descend(self, include_me=True):", "body": "if include_me:<EOL><INDENT>yield self<EOL><DEDENT>for child in self.child_list:<EOL><INDENT>yield child<EOL>yield from child.descend()<EOL><DEDENT>", "docstring": "Descend depth first into all child nodes", "id": "f16447:c1:m8"}
{"signature": "def partial(self):", "body": "ba = self.data[\"<STR_LIT>\"]<EOL>return state_partial(self.data[\"<STR_LIT>\"], *ba.args[<NUM_LIT:1>:], **ba.kwargs)<EOL>", "docstring": "Return partial of original function call", "id": "f16447:c1:m4"}
{"signature": "def delete_shared_pin(self, pin_id):", "body": "if not self.api_key:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>response = _request('<STR_LIT>',<EOL>url=self.url_v1('<STR_LIT>' + pin_id),<EOL>user_agent=self.user_agent,<EOL>api_key=self.api_key,<EOL>)<EOL>_raise_for_status(response)<EOL>", "docstring": "Delete a shared pin.\n\n:param str pin_id: The id of the pin to delete.\n:raises `requests.exceptions.HTTPError`: If an HTTP error occurred.", "id": "f16456:c0:m5"}
{"signature": "def create_from_array(self, blockname, array, Nfile=None, memorylimit=<NUM_LIT> * <NUM_LIT> * <NUM_LIT>):", "body": "size = len(array)<EOL>sizeperfile = <NUM_LIT:32> * <NUM_LIT> * <NUM_LIT><EOL>if Nfile is None:<EOL><INDENT>Nfile = (size + sizeperfile - <NUM_LIT:1>) // sizeperfile<EOL><DEDENT>dtype = numpy.dtype((array.dtype, array.shape[<NUM_LIT:1>:]))<EOL>itemsize = dtype.itemsize<EOL>itemlimit = memorylimit // dtype.itemsize // <NUM_LIT> * <NUM_LIT><EOL>with self.create(blockname, dtype, size, Nfile) as b:<EOL><INDENT>for i in range(<NUM_LIT:0>, len(array), itemlimit):<EOL><INDENT>b.write(i, numpy.array(array[i:i+itemlimit]))<EOL><DEDENT><DEDENT>return self.open(blockname)<EOL>", "docstring": "create a block from array like objects\n            The operation is well defined only if array is at most 2d.\n\n            Parameters\n            ----------\n            array : array_like,\n                array shall have a scalar dtype. \n            blockname : string\n                name of the block\n            Nfile : int or None\n                number of physical files. if None, 32M items per file\n                is used.\n            memorylimit : int\n                number of bytes to use for the buffering. relevant only if\n                indexing on array returns a copy (e.g. IO or dask array)", "id": "f16461:c2:m4"}
{"signature": "def _apply_transform(self, mol, rule):", "body": "mols = [mol]<EOL>for n in six.moves.range(<NUM_LIT:20>):<EOL><INDENT>products = {}<EOL>for mol in mols:<EOL><INDENT>for product in [x[<NUM_LIT:0>] for x in rule.RunReactants((mol,))]:<EOL><INDENT>if Chem.SanitizeMol(product, catchErrors=True) == <NUM_LIT:0>:<EOL><INDENT>products[Chem.MolToSmiles(product, isomericSmiles=True)] = product<EOL><DEDENT><DEDENT><DEDENT>if products:<EOL><INDENT>mols = [products[s] for s in sorted(products)]<EOL><DEDENT>else:<EOL><INDENT>return mols[<NUM_LIT:0>] if n > <NUM_LIT:0> else None<EOL><DEDENT><DEDENT>", "docstring": "Repeatedly apply normalization transform to molecule until no changes occur.\n\n        It is possible for multiple products to be produced when a rule is applied. The rule is applied repeatedly to\n        each of the products, until no further changes occur or after 20 attempts. If there are multiple unique products\n        after the final application, the first product (sorted alphabetically by SMILES) is chosen.", "id": "f16464:c1:m4"}
{"signature": "def __init__(self, normalizations=NORMALIZATIONS, max_restarts=MAX_RESTARTS):", "body": "log.debug('<STR_LIT>')<EOL>self.normalizations = normalizations<EOL>self.max_restarts = max_restarts<EOL>", "docstring": "Initialize a Normalizer with an optional custom list of :class:`~molvs.normalize.Normalization` transforms.\n\n        :param normalizations: A list of  :class:`~molvs.normalize.Normalization` transforms to apply.\n        :param int max_restarts: The maximum number of times to attempt to apply the series of normalizations (default\n                                 200).", "id": "f16464:c1:m0"}
{"signature": "def normalize(self, mol):", "body": "log.debug('<STR_LIT>')<EOL>fragments = []<EOL>for fragment in Chem.GetMolFrags(mol, asMols=True):<EOL><INDENT>fragments.append(self._normalize_fragment(fragment))<EOL><DEDENT>outmol = fragments.pop()<EOL>for fragment in fragments:<EOL><INDENT>outmol = Chem.CombineMols(outmol, fragment)<EOL><DEDENT>Chem.SanitizeMol(outmol)<EOL>return outmol<EOL>", "docstring": "Apply a series of Normalization transforms to correct functional groups and recombine charges.\n\n        A series of transforms are applied to the molecule. For each Normalization, the transform is applied repeatedly\n        until no further changes occur. If any changes occurred, we go back and start from the first Normalization\n        again, in case the changes mean an earlier transform is now applicable. The molecule is returned once the entire\n        series of Normalizations cause no further changes or if max_restarts (default 200) is reached.\n\n        :param mol: The molecule to normalize.\n        :type mol: rdkit.Chem.rdchem.Mol\n        :return: The normalized fragment.\n        :rtype: rdkit.Chem.rdchem.Mol", "id": "f16464:c1:m2"}
{"signature": "@memoized_property<EOL><INDENT>def disconnect_metals(self):<DEDENT>", "body": "return MetalDisconnector()<EOL>", "docstring": ":returns: A callable :class:`~molvs.metal.MetalDisconnector` instance.", "id": "f16466:c0:m10"}
{"signature": "def __init__(self, normalizations=NORMALIZATIONS, acid_base_pairs=ACID_BASE_PAIRS,<EOL>charge_corrections=CHARGE_CORRECTIONS, tautomer_transforms=TAUTOMER_TRANSFORMS,<EOL>tautomer_scores=TAUTOMER_SCORES, max_restarts=MAX_RESTARTS, max_tautomers=MAX_TAUTOMERS,<EOL>prefer_organic=PREFER_ORGANIC):", "body": "log.debug('<STR_LIT>')<EOL>self.normalizations = normalizations<EOL>self.acid_base_pairs = acid_base_pairs<EOL>self.charge_corrections = charge_corrections<EOL>self.tautomer_transforms = tautomer_transforms<EOL>self.tautomer_scores = tautomer_scores<EOL>self.max_restarts = max_restarts<EOL>self.max_tautomers = max_tautomers<EOL>self.prefer_organic = prefer_organic<EOL>", "docstring": "Initialize a Standardizer with optional custom parameters.\n\n        :param normalizations: A list of Normalizations to apply (default: :data:`~molvs.normalize.NORMALIZATIONS`).\n        :param acid_base_pairs: A list of AcidBasePairs for competitive reionization (default:\n                                :data:`~molvs.charge.ACID_BASE_PAIRS`).\n        :param charge_corrections: A list of ChargeCorrections to apply (default:\n                                :data:`~molvs.charge.CHARGE_CORRECTIONS`).\n        :param tautomer_transforms: A list of TautomerTransforms to apply (default:\n                                    :data:`~molvs.tautomer.TAUTOMER_TRANSFORMS`).\n        :param tautomer_scores: A list of TautomerScores used to determine canonical tautomer (default:\n                                :data:`~molvs.tautomer.TAUTOMER_SCORES`).\n        :param max_restarts: The maximum number of times to attempt to apply the series of normalizations (default 200).\n        :param max_tautomers: The maximum number of tautomers to enumerate (default 1000).\n        :param prefer_organic: Whether to prioritize organic fragments when choosing fragment parent (default False).", "id": "f16466:c0:m0"}
{"signature": "@memoized_property<EOL><INDENT>def reionize(self):<DEDENT>", "body": "return Reionizer(acid_base_pairs=self.acid_base_pairs, charge_corrections=self.charge_corrections)<EOL>", "docstring": ":returns: A callable :class:`~molvs.charge.Reionizer` instance.", "id": "f16466:c0:m12"}
{"signature": "def fragment_parent(self, mol, skip_standardize=False):", "body": "if not skip_standardize:<EOL><INDENT>mol = self.standardize(mol)<EOL><DEDENT>fragment = self.largest_fragment(mol)<EOL>return fragment<EOL>", "docstring": "Return the fragment parent of a given molecule.\n\n        The fragment parent is the largest organic covalent unit in the molecule.\n\n        :param mol: The input molecule.\n        :type mol: rdkit.Chem.rdchem.Mol\n        :param bool skip_standardize: Set to True if mol has already been standardized.\n        :returns: The fragment parent molecule.\n        :rtype: rdkit.Chem.rdchem.Mol", "id": "f16466:c0:m4"}
{"signature": "@memoized_property<EOL><INDENT>def uncharge(self):<DEDENT>", "body": "return Uncharger(acid_base_pairs=self.acid_base_pairs)<EOL>", "docstring": ":returns: A callable :class:`~molvs.charge.Uncharger` instance.", "id": "f16466:c0:m13"}
{"signature": "def standardize(self, mol):", "body": "mol = copy.deepcopy(mol)<EOL>Chem.SanitizeMol(mol)<EOL>mol = Chem.RemoveHs(mol)<EOL>mol = self.disconnect_metals(mol)<EOL>mol = self.normalize(mol)<EOL>mol = self.reionize(mol)<EOL>Chem.AssignStereochemistry(mol, force=True, cleanIt=True)<EOL>return mol<EOL>", "docstring": "Return a standardized version the given molecule.\n\n        The standardization process consists of the following stages: RDKit\n        :py:func:`~rdkit.Chem.rdmolops.RemoveHs`, RDKit :py:func:`~rdkit.Chem.rdmolops.SanitizeMol`,\n        :class:`~molvs.metal.MetalDisconnector`, :class:`~molvs.normalize.Normalizer`,\n        :class:`~molvs.charge.Reionizer`, RDKit :py:func:`~rdkit.Chem.rdmolops.AssignStereochemistry`.\n\n        :param mol: The molecule to standardize.\n        :type mol: rdkit.Chem.rdchem.Mol\n        :returns: The standardized molecule.\n        :rtype: rdkit.Chem.rdchem.Mol", "id": "f16466:c0:m2"}
{"signature": "def stereo_parent(self, mol, skip_standardize=False):", "body": "if not skip_standardize:<EOL><INDENT>mol = self.standardize(mol)<EOL><DEDENT>else:<EOL><INDENT>mol = copy.deepcopy(mol)<EOL><DEDENT>Chem.RemoveStereochemistry(mol)<EOL>return mol<EOL>", "docstring": "Return the stereo parent of a given molecule.\n\n        The stereo parent has all stereochemistry information removed from tetrahedral centers and double bonds.\n\n        :param mol: The input molecule.\n        :type mol: rdkit.Chem.rdchem.Mol\n        :param bool skip_standardize: Set to True if mol has already been standardized.\n        :returns: The stereo parent molecule.\n        :rtype: rdkit.Chem.rdchem.Mol", "id": "f16466:c0:m5"}
{"signature": "def isotope_parent(self, mol, skip_standardize=False):", "body": "if not skip_standardize:<EOL><INDENT>mol = self.standardize(mol)<EOL><DEDENT>else:<EOL><INDENT>mol = copy.deepcopy(mol)<EOL><DEDENT>for atom in mol.GetAtoms():<EOL><INDENT>atom.SetIsotope(<NUM_LIT:0>)<EOL><DEDENT>return mol<EOL>", "docstring": "Return the isotope parent of a given molecule.\n\n        The isotope parent has all atoms replaced with the most abundant isotope for that element.\n\n        :param mol: The input molecule.\n        :type mol: rdkit.Chem.rdchem.Mol\n        :param bool skip_standardize: Set to True if mol has already been standardized.\n        :returns: The isotope parent molecule.\n        :rtype: rdkit.Chem.rdchem.Mol", "id": "f16466:c0:m6"}
{"signature": "def __call__(self, mol):", "body": "return self.remove(mol)<EOL>", "docstring": "Calling a FragmentRemover instance like a function is the same as calling its remove(mol) method.", "id": "f16469:c1:m1"}
{"signature": "def choose(self, mol):", "body": "log.debug('<STR_LIT>')<EOL>fragments = Chem.GetMolFrags(mol, asMols=True)<EOL>largest = None<EOL>for f in fragments:<EOL><INDENT>smiles = Chem.MolToSmiles(f, isomericSmiles=True)<EOL>log.debug('<STR_LIT>', smiles)<EOL>organic = is_organic(f)<EOL>if self.prefer_organic:<EOL><INDENT>if largest and largest['<STR_LIT>'] and not organic:<EOL><INDENT>continue<EOL><DEDENT>if largest and organic and not largest['<STR_LIT>']:<EOL><INDENT>largest = None<EOL><DEDENT><DEDENT>atoms = <NUM_LIT:0><EOL>for a in f.GetAtoms():<EOL><INDENT>atoms += <NUM_LIT:1> + a.GetTotalNumHs()<EOL><DEDENT>if largest and atoms < largest['<STR_LIT>']:<EOL><INDENT>continue<EOL><DEDENT>weight = rdMolDescriptors.CalcExactMolWt(f)<EOL>if largest and atoms == largest['<STR_LIT>'] and weight < largest['<STR_LIT>']:<EOL><INDENT>continue<EOL><DEDENT>if largest and atoms == largest['<STR_LIT>'] and weight == largest['<STR_LIT>'] and smiles > largest['<STR_LIT>']:<EOL><INDENT>continue<EOL><DEDENT>log.debug('<STR_LIT>', smiles, atoms)<EOL>largest = {'<STR_LIT>': smiles, '<STR_LIT>': f, '<STR_LIT>': atoms, '<STR_LIT>': weight, '<STR_LIT>': organic}<EOL><DEDENT>return largest['<STR_LIT>']<EOL>", "docstring": "Return the largest covalent unit.\n\n        The largest fragment is determined by number of atoms (including hydrogens). Ties are broken by taking the\n        fragment with the higher molecular weight, and then by taking the first alphabetically by SMILES if needed.\n\n        :param mol: The molecule to choose the largest fragment from.\n        :type mol: rdkit.Chem.rdchem.Mol\n        :return: The largest fragment.\n        :rtype: rdkit.Chem.rdchem.Mol", "id": "f16469:c2:m2"}
{"signature": "def is_organic(fragment):", "body": "<EOL>for a in fragment.GetAtoms():<EOL><INDENT>if a.GetAtomicNum() == <NUM_LIT:6>:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Return true if fragment contains at least one carbon atom.\n\n    :param fragment: The fragment as an RDKit Mol object.", "id": "f16469:m0"}
{"signature": "def disconnect(self, mol):", "body": "log.debug('<STR_LIT>')<EOL>for smarts in [self._metal_nof, self._metal_non]:<EOL><INDENT>pairs = mol.GetSubstructMatches(smarts)<EOL>rwmol = Chem.RWMol(mol)<EOL>orders = []<EOL>for i, j in pairs:<EOL><INDENT>orders.append(int(mol.GetBondBetweenAtoms(i, j).GetBondTypeAsDouble()))<EOL>rwmol.RemoveBond(i, j)<EOL><DEDENT>mol = rwmol.GetMol()<EOL>for n, (i, j) in enumerate(pairs):<EOL><INDENT>chg = orders[n]<EOL>atom1 = mol.GetAtomWithIdx(i)<EOL>atom1.SetFormalCharge(atom1.GetFormalCharge() + chg)<EOL>atom2 = mol.GetAtomWithIdx(j)<EOL>atom2.SetFormalCharge(atom2.GetFormalCharge() - chg)<EOL>log.info('<STR_LIT>', atom1.GetSymbol(), atom2.GetSymbol())<EOL><DEDENT><DEDENT>Chem.SanitizeMol(mol)<EOL>return mol<EOL>", "docstring": "Break covalent bonds between metals and organic atoms under certain conditions.\n\n        The algorithm works as follows:\n\n        - Disconnect N, O, F from any metal.\n        - Disconnect other non-metals from transition metals + Al (but not Hg, Ga, Ge, In, Sn, As, Tl, Pb, Bi, Po).\n        - For every bond broken, adjust the charges of the begin and end atoms accordingly.\n\n        :param mol: The input molecule.\n        :type mol: rdkit.Chem.rdchem.Mol\n        :return: The molecule with metals disconnected.\n        :rtype: rdkit.Chem.rdchem.Mol", "id": "f16470:c0:m2"}
{"signature": "def __init__(self, validations=VALIDATIONS, log_format=SIMPLE_FORMAT, level=logging.INFO, stdout=False, raw=False):", "body": "self.raw = raw<EOL>self.log = logging.getLogger(type(self).__name__)<EOL>self.log.setLevel(level)<EOL>self.handler = LogHandler()<EOL>self.handler.setFormatter(logging.Formatter(log_format))<EOL>self.log.addHandler(self.handler)<EOL>if stdout:<EOL><INDENT>strhdlr = logging.StreamHandler(sys.stdout)<EOL>strhdlr.setFormatter(logging.Formatter(log_format))<EOL>self.log.addHandler(strhdlr)<EOL><DEDENT>self.validations = [validation(self.log) for validation in validations]<EOL>", "docstring": "Initialize a Validator with the following parameters:\n\n        :param validations: A list of Validations to apply (default: :data:`~molvs.validations.VALIDATIONS`).\n        :param string log_format: A string format (default: :data:`~molvs.validate.SIMPLE_FORMAT`).\n        :param level: The minimum logging level to output.\n        :param bool stdout: Whether to send log messages to standard output.\n        :param bool raw: Whether to return raw :class:`~logging.LogRecord` objects instead of formatted log strings.", "id": "f16473:c1:m0"}
{"signature": "def __call__(self, mol):", "body": "return self.validate(mol)<EOL>", "docstring": "Calling a Validator instance like a function is the same as calling its\n        :meth:`~molvs.validate.Validator.validate` method.", "id": "f16473:c1:m1"}
{"signature": "def memoized_property(fget):", "body": "attr_name = '<STR_LIT>'.format(fget.__name__)<EOL>@functools.wraps(fget)<EOL>def fget_memoized(self):<EOL><INDENT>if not hasattr(self, attr_name):<EOL><INDENT>setattr(self, attr_name, fget(self))<EOL><DEDENT>return getattr(self, attr_name)<EOL><DEDENT>return property(fget_memoized)<EOL>", "docstring": "Decorator to create memoized properties.", "id": "f16474:m0"}
{"signature": "def __call__(self, mol):", "body": "return self.canonicalize(mol)<EOL>", "docstring": "Calling a TautomerCanonicalizer instance like a function is the same as calling its canonicalize(mol) method.", "id": "f16475:c2:m1"}
{"signature": "def enumerate(self, mol):", "body": "smiles = Chem.MolToSmiles(mol, isomericSmiles=True)<EOL>tautomers = {smiles: copy.deepcopy(mol)}<EOL>kekulized = copy.deepcopy(mol)<EOL>Chem.Kekulize(kekulized)<EOL>kekulized = {smiles: kekulized}<EOL>done = set()<EOL>while len(tautomers) < self.max_tautomers:<EOL><INDENT>for tsmiles in sorted(tautomers):<EOL><INDENT>if tsmiles in done:<EOL><INDENT>continue<EOL><DEDENT>for transform in self.transforms:<EOL><INDENT>for match in kekulized[tsmiles].GetSubstructMatches(transform.tautomer):<EOL><INDENT>product = copy.deepcopy(kekulized[tsmiles])<EOL>first = product.GetAtomWithIdx(match[<NUM_LIT:0>])<EOL>last = product.GetAtomWithIdx(match[-<NUM_LIT:1>])<EOL>first.SetNumExplicitHs(max(<NUM_LIT:0>, first.GetTotalNumHs() - <NUM_LIT:1>))<EOL>last.SetNumExplicitHs(last.GetTotalNumHs() + <NUM_LIT:1>)<EOL>first.SetNoImplicit(True)<EOL>last.SetNoImplicit(True)<EOL>for bi, pair in enumerate(pairwise(match)):<EOL><INDENT>if transform.bonds:<EOL><INDENT>product.GetBondBetweenAtoms(*pair).SetBondType(transform.bonds[bi])<EOL><DEDENT>else:<EOL><INDENT>current_bond_type = product.GetBondBetweenAtoms(*pair).GetBondType()<EOL>product.GetBondBetweenAtoms(*pair).SetBondType(BondType.DOUBLE if current_bond_type == BondType.SINGLE else BondType.SINGLE)<EOL><DEDENT><DEDENT>if transform.charges:<EOL><INDENT>for ci, idx in enumerate(match):<EOL><INDENT>atom = product.GetAtomWithIdx(idx)<EOL>atom.SetFormalCharge(atom.GetFormalCharge() + transform.charges[ci])<EOL><DEDENT><DEDENT>try:<EOL><INDENT>Chem.SanitizeMol(product)<EOL>smiles = Chem.MolToSmiles(product, isomericSmiles=True)<EOL>log.debug('<STR_LIT>', transform.name, tsmiles)<EOL>if smiles not in tautomers:<EOL><INDENT>log.debug('<STR_LIT>' % smiles)<EOL>kekulized_product = copy.deepcopy(product)<EOL>Chem.Kekulize(kekulized_product)<EOL>tautomers[smiles] = product<EOL>kekulized[smiles] = kekulized_product<EOL><DEDENT>else:<EOL><INDENT>log.debug('<STR_LIT>' % smiles)<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>log.debug('<STR_LIT>', transform.name)<EOL><DEDENT><DEDENT><DEDENT>done.add(tsmiles)<EOL><DEDENT>if len(tautomers) == len(done):<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>log.warning('<STR_LIT>', self.max_tautomers)<EOL><DEDENT>for tautomer in tautomers.values():<EOL><INDENT>Chem.AssignStereochemistry(tautomer, force=True, cleanIt=True)<EOL>for bond in tautomer.GetBonds():<EOL><INDENT>if bond.GetBondType() == BondType.DOUBLE and bond.GetStereo() > BondStereo.STEREOANY:<EOL><INDENT>begin = bond.GetBeginAtomIdx()<EOL>end = bond.GetEndAtomIdx()<EOL>for othertautomer in tautomers.values():<EOL><INDENT>if not othertautomer.GetBondBetweenAtoms(begin, end).GetBondType() == BondType.DOUBLE:<EOL><INDENT>neighbours = tautomer.GetAtomWithIdx(begin).GetBonds() + tautomer.GetAtomWithIdx(end).GetBonds()<EOL>for otherbond in neighbours:<EOL><INDENT>if otherbond.GetBondDir() in {BondDir.ENDUPRIGHT, BondDir.ENDDOWNRIGHT}:<EOL><INDENT>otherbond.SetBondDir(BondDir.NONE)<EOL><DEDENT><DEDENT>Chem.AssignStereochemistry(tautomer, force=True, cleanIt=True)<EOL>log.debug('<STR_LIT>')<EOL>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>return list(tautomers.values())<EOL>", "docstring": "Enumerate all possible tautomers and return them as a list.\n\n        :param mol: The input molecule.\n        :type mol: rdkit.Chem.rdchem.Mol\n        :return: A list of all possible tautomers of the molecule.\n        :rtype: list of rdkit.Chem.rdchem.Mol", "id": "f16475:c3:m2"}
{"signature": "def __call__(self, mol):", "body": "return self.uncharge(mol)<EOL>", "docstring": "Calling an Uncharger instance like a function is the same as calling its uncharge(mol) method.", "id": "f16476:c3:m1"}
{"signature": "def __init__(self, name, acid, base):", "body": "log.debug('<STR_LIT>', name)<EOL>self.name = name<EOL>self.acid_str = acid<EOL>self.base_str = base<EOL>", "docstring": "Initialize an AcidBasePair with the following parameters:\n\n        :param string name: A name for this AcidBasePair.\n        :param string acid: SMARTS pattern for the protonated acid.\n        :param string base: SMARTS pattern for the conjugate ionized base.", "id": "f16476:c0:m0"}
{"signature": "def reionize(self, mol):", "body": "log.debug('<STR_LIT>')<EOL>start_charge = Chem.GetFormalCharge(mol)<EOL>for cc in self.charge_corrections:<EOL><INDENT>for match in mol.GetSubstructMatches(cc.smarts):<EOL><INDENT>atom = mol.GetAtomWithIdx(match[<NUM_LIT:0>])<EOL>log.info('<STR_LIT>', cc.name, atom.GetSymbol(), cc.charge)<EOL>atom.SetFormalCharge(cc.charge)<EOL><DEDENT><DEDENT>current_charge = Chem.GetFormalCharge(mol)<EOL>charge_diff = Chem.GetFormalCharge(mol) - start_charge<EOL>if not current_charge == <NUM_LIT:0>:<EOL><INDENT>while charge_diff > <NUM_LIT:0>:<EOL><INDENT>ppos, poccur = self._strongest_protonated(mol)<EOL>if ppos is None:<EOL><INDENT>break<EOL><DEDENT>log.info('<STR_LIT>', self.acid_base_pairs[ppos].name)<EOL>patom = mol.GetAtomWithIdx(poccur[-<NUM_LIT:1>])<EOL>patom.SetFormalCharge(patom.GetFormalCharge() - <NUM_LIT:1>)<EOL>if patom.GetNumExplicitHs() > <NUM_LIT:0>:<EOL><INDENT>patom.SetNumExplicitHs(patom.GetNumExplicitHs() - <NUM_LIT:1>)<EOL><DEDENT>patom.UpdatePropertyCache()<EOL>charge_diff -= <NUM_LIT:1><EOL><DEDENT><DEDENT>already_moved = set()<EOL>while True:<EOL><INDENT>ppos, poccur = self._strongest_protonated(mol)<EOL>ipos, ioccur = self._weakest_ionized(mol)<EOL>if ioccur and poccur and ppos < ipos:<EOL><INDENT>if poccur[-<NUM_LIT:1>] == ioccur[-<NUM_LIT:1>]:<EOL><INDENT>log.warning('<STR_LIT>')<EOL>break<EOL><DEDENT>key = tuple(sorted([poccur[-<NUM_LIT:1>], ioccur[-<NUM_LIT:1>]]))<EOL>if key in already_moved:<EOL><INDENT>log.warning('<STR_LIT>')<EOL>break<EOL><DEDENT>already_moved.add(key)<EOL>log.info('<STR_LIT>', self.acid_base_pairs[ppos].name, self.acid_base_pairs[ipos].name)<EOL>patom = mol.GetAtomWithIdx(poccur[-<NUM_LIT:1>])<EOL>patom.SetFormalCharge(patom.GetFormalCharge() - <NUM_LIT:1>)<EOL>if patom.GetNumImplicitHs() == <NUM_LIT:0> and patom.GetNumExplicitHs() > <NUM_LIT:0>:<EOL><INDENT>patom.SetNumExplicitHs(patom.GetNumExplicitHs() - <NUM_LIT:1>)<EOL><DEDENT>patom.UpdatePropertyCache()<EOL>iatom = mol.GetAtomWithIdx(ioccur[-<NUM_LIT:1>])<EOL>iatom.SetFormalCharge(iatom.GetFormalCharge() + <NUM_LIT:1>)<EOL>if (iatom.GetNoImplicit() or<EOL>((patom.GetAtomicNum() == <NUM_LIT:7> or patom.GetAtomicNum() == <NUM_LIT:15>) and patom.GetIsAromatic()) or<EOL>iatom.GetTotalValence() not in list(Chem.GetPeriodicTable().GetValenceList(iatom.GetAtomicNum()))):<EOL><INDENT>iatom.SetNumExplicitHs(iatom.GetNumExplicitHs() + <NUM_LIT:1>)<EOL><DEDENT>iatom.UpdatePropertyCache()<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>Chem.SanitizeMol(mol)<EOL>return mol<EOL>", "docstring": "Enforce charges on certain atoms, then perform competitive reionization.\n\n        First, charge corrections are applied to ensure, for example, that free metals are correctly ionized. Then, if\n        a molecule with multiple acid groups is partially ionized, ensure the strongest acids ionize first.\n\n        The algorithm works as follows:\n\n        - Use SMARTS to find the strongest protonated acid and the weakest ionized acid.\n        - If the ionized acid is weaker than the protonated acid, swap proton and repeat.\n\n        :param mol: The molecule to reionize.\n        :type mol: rdkit.Chem.rdchem.Mol\n        :return: The reionized molecule.\n        :rtype: rdkit.Chem.rdchem.Mol", "id": "f16476:c2:m2"}
{"signature": "def __init__(self, name, smarts, charge):", "body": "log.debug('<STR_LIT>', name)<EOL>self.name = name<EOL>self.smarts_str = smarts<EOL>self.charge = charge<EOL>", "docstring": "Initialize a ChargeCorrection with the following parameters:\n\n        :param string name: A name for this ForcedAtomCharge.\n        :param string smarts: SMARTS pattern to match. Charge is applied to the first atom.\n        :param int charge: The charge to apply.", "id": "f16476:c1:m0"}
{"signature": "def fragment_parent_smiles(smiles, prefer_organic=False):", "body": "mol = Chem.MolFromSmiles(smiles, sanitize=False)<EOL>mol = Standardizer(prefer_organic=prefer_organic).fragment_parent(mol)<EOL>return Chem.MolToSmiles(mol, isomericSmiles=True)<EOL>", "docstring": "Utility function that returns the fragment parent SMILES for given a SMILES string.", "id": "f16477:m0"}
{"signature": "def uncharge_smiles(smiles):", "body": "mol = Chem.MolFromSmiles(smiles)<EOL>u = Uncharger()<EOL>mol = u.uncharge(mol)<EOL>if mol:<EOL><INDENT>return Chem.MolToSmiles(mol, isomericSmiles=True)<EOL><DEDENT>", "docstring": "Utility function that returns the uncharged SMILES for a given SMILES string.", "id": "f16484:m1"}
{"signature": "def translate(self, word):", "body": "if (word not in self.transmissions):<EOL><INDENT>raise NoMatchError('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>trans = self.transmissions[word]<EOL>return sorted(((k, v) for k, v in trans.items() if v != <NUM_LIT:0>), <EOL>reverse=True)<EOL><DEDENT>", "docstring": "pass in a word string that you\nwould like to see probable matches for.", "id": "f16487:c0:m2"}
{"signature": "def iterateEM(self, count):", "body": "for iter in range(count):<EOL><INDENT>countef = {}<EOL>totalf = {}<EOL>for word in self.en_words:<EOL><INDENT>if(word not in self.probs):<EOL><INDENT>continue<EOL><DEDENT>word_probs = self.probs[word]<EOL>count = dict([(w, <NUM_LIT:0>) for w in word_probs])<EOL>countef[word] = count<EOL>totalf[word] = <NUM_LIT:0><EOL><DEDENT>self.countef = countef<EOL>self.totalf = totalf<EOL>for (es, ds) in self.sent_pairs:<EOL><INDENT>es_split = es.split()<EOL>ds_split = ds.split()<EOL>for d in ds_split:<EOL><INDENT>self.totals[d] = <NUM_LIT:0><EOL>for e in es_split:<EOL><INDENT>if (e not in self.transmissions):<EOL><INDENT>continue<EOL><DEDENT>e_trans = self.transmissions[e]<EOL>if (d not in e_trans):<EOL><INDENT>continue<EOL><DEDENT>self.totals[d] += e_trans[d]<EOL><DEDENT>for e in es_split:<EOL><INDENT>if(e not in self.transmissions):<EOL><INDENT>continue<EOL><DEDENT>if (d not in self.transmissions[e]):<EOL><INDENT>continue<EOL><DEDENT>self.countef[e][<EOL>d] += self.transmissions[e][d] / self.totals[d]<EOL>self.totalf[<EOL>e] += self.transmissions[e][d] / self.totals[d]<EOL><DEDENT><DEDENT><DEDENT>for e in self.en_words:<EOL><INDENT>if (e not in self.probs):<EOL><INDENT>continue<EOL><DEDENT>e_prob = self.probs[e]<EOL>for d in e_prob:<EOL><INDENT>self.transmissions[e][d] = self.countef[<EOL>e][d] / self.totalf[e]<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Iterate through all transmissions of english to\nforeign words. keep count of repeated occurences\n do until convergence\n   set count(e|f) to 0 for all e,f\n   set total(f) to 0 for all f\n   for all sentence pairs (e_s,f_s)\n     set total_s(e) = 0 for all e\n     for all words e in e_s\n       for all words f in f_s\n         total_s(e) += t(e|f)\n     for all words e in e_s\n       for all words f in f_s\n         count(e|f) += t(e|f) / total_s(e)\n         total(f)   += t(e|f) / total_s(e)\n   for all f\n     for all e\n       t(e|f) = count(e|f) / total(f)", "id": "f16487:c0:m5"}
{"signature": "def flush(self):", "body": "<EOL>while len(self._batches) > <NUM_LIT:0>:<EOL><INDENT>self._socket.sendall(self._batches[<NUM_LIT:0>])<EOL>self._batches.popleft()<EOL><DEDENT>return self<EOL>", "docstring": "Send buffered metrics in batch requests over TCP", "id": "f16500:c1:m1"}
{"signature": "def unit_client(self):<EOL>", "body": "client = TCPClient(self.host, self.port, self.prefix)<EOL>self._configure_client(client)<EOL>return client<EOL>", "docstring": "Return a TCPClient with same settings of the batch TCP client", "id": "f16500:c1:m2"}
{"signature": "def time_callable(self, name, target, rate=None, args=(), kwargs={}):<EOL>", "body": "assert callable(target)<EOL>if rate is None:<EOL><INDENT>rate = self._rate<EOL><DEDENT>else:<EOL><INDENT>assert_sample_rate(rate)<EOL><DEDENT>start_time = time()  <EOL>result = target(*args, **kwargs)<EOL>self.since(name, start_time, rate)<EOL>return result<EOL>", "docstring": "Send a Timer metric calculating duration of execution of the provided callable", "id": "f16501:c2:m2"}
{"signature": "def batch_client(self, size=<NUM_LIT>):<EOL>", "body": "batch_client = BatchClient(self.host, self.port, self.prefix, size)<EOL>self._configure_client(batch_client)<EOL>return batch_client<EOL>", "docstring": "Return a batch client with same settings of the client", "id": "f16502:c3:m0"}
{"signature": "def set(self, name, value, rate=<NUM_LIT:1>):<EOL>", "body": "if self._should_send_metric(name, rate):<EOL><INDENT>value = str(value)<EOL>self._request(<EOL>Set(<EOL>self._create_metric_name_for_request(name),<EOL>value,<EOL>rate<EOL>).to_request()<EOL>)<EOL><DEDENT>", "docstring": "Send a Set metric with the specified unique value", "id": "f16502:c1:m11"}
{"signature": "def flush(self):<EOL>", "body": "address = self.remote_address<EOL>while len(self._batches) > <NUM_LIT:0>:<EOL><INDENT>self._socket.sendto(self._batches[<NUM_LIT:0>], address)<EOL>self._batches.popleft()<EOL><DEDENT>return self<EOL>", "docstring": "Send buffered metrics in batch requests", "id": "f16502:c4:m2"}
{"signature": "def flush(self):<EOL>", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "Send buffered metrics in batch requests", "id": "f16502:c2:m3"}
{"signature": "def hessian(f, delta=DELTA):", "body": "def hessian_f(*args, **kwargs):<EOL><INDENT>if len(args) == <NUM_LIT:1>:<EOL><INDENT>x, = args<EOL>hessianf_x = (<EOL>f(x+delta) + f(x-delta) - <NUM_LIT:2>*f(x)<EOL>)/delta**<NUM_LIT:2><EOL>return hessianf_x<EOL><DEDENT>elif len(args) == <NUM_LIT:2>:<EOL><INDENT>x, y = args<EOL>if type(x) in [float, int] and type(y) in [float, int]:<EOL><INDENT>hess_xx = (<EOL>f(x + delta, y) + f(x - delta, y) - <NUM_LIT:2>*f(x, y)<EOL>)/delta**<NUM_LIT:2><EOL>hess_yy = (<EOL>f(x, y + delta) + f(x, y - delta) - <NUM_LIT:2>*f(x, y)<EOL>)/delta**<NUM_LIT:2><EOL>hess_xy = (<EOL>+ f(x+delta/<NUM_LIT:2>, y+delta/<NUM_LIT:2>)<EOL>+ f(x-delta/<NUM_LIT:2>, y-delta/<NUM_LIT:2>)<EOL>- f(x+delta/<NUM_LIT:2>, y-delta/<NUM_LIT:2>)<EOL>- f(x-delta/<NUM_LIT:2>, y+delta/<NUM_LIT:2>)<EOL>)/delta**<NUM_LIT:2><EOL>return hess_xx, hess_xy, hess_yy<EOL><DEDENT><DEDENT><DEDENT>return hessian_f<EOL>", "docstring": "Returns numerical hessian function of given input function\nInput: f, scalar function of one or two variables\n       delta(optional), finite difference step\nOutput: hessian function object", "id": "f16518:m1"}
{"signature": "def clmixhess(obj, exe, arg1, arg2, delta=DELTA):", "body": "f, x = get_method_and_copy_of_attribute(obj, exe, arg1)<EOL>_, y = get_method_and_copy_of_attribute(obj, exe, arg2)<EOL>def hess_f(*args, **kwargs):<EOL><INDENT>hess_val = numpy.zeros(x.shape + y.shape)<EOL>it = numpy.nditer(x, op_flags=['<STR_LIT>'], flags=['<STR_LIT>'])<EOL>for xi in it:<EOL><INDENT>i = it.multi_index<EOL>jt = numpy.nditer(y, op_flags=['<STR_LIT>'], flags=['<STR_LIT>'])<EOL>for yj in jt:<EOL><INDENT>j = jt.multi_index<EOL>xi += delta/<NUM_LIT:2><EOL>yj += delta/<NUM_LIT:2><EOL>fpp = f(*args, **kwargs)<EOL>yj -= delta<EOL>fpm = f(*args, **kwargs)<EOL>xi -= delta<EOL>fmm = f(*args, **kwargs)<EOL>yj += delta<EOL>fmp = f(*args, **kwargs)<EOL>xi += delta/<NUM_LIT:2><EOL>yj -= delta/<NUM_LIT:2><EOL>hess_val[i + j] = (fpp + fmm - fpm - fmp)/delta**<NUM_LIT:2><EOL><DEDENT><DEDENT>return hess_val<EOL><DEDENT>return hess_f<EOL>", "docstring": "Returns numerical mixed Hessian function of given class method\nwith respect to two class attributes\nInput: obj, general object\n       exe (str), name of object method\n       arg1(str), name of object attribute\n       arg2(str), name of object attribute\n       delta(float, optional), finite difference step\nOutput: Hessian function object", "id": "f16518:m6"}
{"signature": "def clgrad(obj, exe, arg, delta=DELTA):", "body": "f, x = get_method_and_copy_of_attribute(obj, exe, arg)<EOL>def grad_f(*args, **kwargs):<EOL><INDENT>grad_val = numpy.zeros(x.shape)<EOL>it = numpy.nditer(x, op_flags=['<STR_LIT>'], flags=['<STR_LIT>'])<EOL>for xi in it:<EOL><INDENT>i = it.multi_index<EOL>xi += delta/<NUM_LIT:2><EOL>fp = f(*args, **kwargs)<EOL>xi -= delta<EOL>fm = f(*args, **kwargs)<EOL>xi += delta/<NUM_LIT:2><EOL>grad_val[i] = (fp - fm)/delta<EOL><DEDENT>return grad_val<EOL><DEDENT>return grad_f<EOL>", "docstring": "Returns numerical gradient function of given class method\nwith respect to a class attribute\nInput: obj, general object\n       exe (str), name of object method\n       arg (str), name of object atribute\n       delta(float, optional), finite difference step\nOutput: gradient function object", "id": "f16518:m4"}
{"signature": "def ndgrad(f, delta=DELTA):", "body": "def grad_f(*args, **kwargs):<EOL><INDENT>x = args[<NUM_LIT:0>]<EOL>grad_val = numpy.zeros(x.shape)<EOL>it = numpy.nditer(x, op_flags=['<STR_LIT>'], flags=['<STR_LIT>'])<EOL>for xi in it:<EOL><INDENT>i = it.multi_index<EOL>xi += delta/<NUM_LIT:2><EOL>fp = f(*args, **kwargs)<EOL>xi -= delta<EOL>fm = f(*args, **kwargs)<EOL>xi += delta/<NUM_LIT:2><EOL>grad_val[i] = (fp - fm)/delta<EOL><DEDENT>return grad_val<EOL><DEDENT>return grad_f<EOL>", "docstring": "Returns numerical gradient function of given input function\nInput: f, scalar function of an numpy array object\n       delta(optional), finite difference step\nOutput: gradient function object", "id": "f16518:m2"}
{"signature": "def calculate(directory):", "body": "<EOL>if sys.platform == '<STR_LIT>':<EOL><INDENT>slash = '<STR_LIT:\\\\>'<EOL><DEDENT>elif sys.platform == '<STR_LIT>':<EOL><INDENT>slash = '<STR_LIT:/>'<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>')<EOL>return<EOL><DEDENT>print('<STR_LIT>')<EOL>for i in range(len(directory[<NUM_LIT:2>])):  <EOL><INDENT>full_path = directory[<NUM_LIT:0>]+slash+directory[<NUM_LIT:2>][i]<EOL>print(full_path)  <EOL>size(full_path)<EOL>print(md5(full_path))<EOL><DEDENT>", "docstring": "Split the tuple (obtained from scan) to separate files.\n       Alternately send full paths to the files in md5 and call it.\n       :param directory: tuple of files in the directory.", "id": "f16523:m2"}
{"signature": "def md5(file_path):", "body": "hasher = hashlib.md5()<EOL>with open(file_path, '<STR_LIT:rb>') as f:<EOL><INDENT>while True:<EOL><INDENT>buf = f.read(BLOCKSIZE)<EOL>if not buf:<EOL><INDENT>break<EOL><DEDENT>while len(buf) > <NUM_LIT:0>:<EOL><INDENT>hasher.update(buf)<EOL>buf = f.read(BLOCKSIZE)<EOL><DEDENT><DEDENT><DEDENT>md5_hash = hasher.hexdigest().upper()<EOL>return md5_hash<EOL>", "docstring": "Calculates the md5-hash of the file.\n    :param file_path: full path to the file.", "id": "f16523:m0"}
{"signature": "def print_upload_processors(self):", "body": "for p in self.processors():<EOL><INDENT>if p['<STR_LIT:name>'].startswith('<STR_LIT>'):<EOL><INDENT>print(p['<STR_LIT:name>'])<EOL><DEDENT><DEDENT>", "docstring": "Print all upload processor names.", "id": "f16525:c0:m5"}
{"signature": "def processors(self, processor_name=None):", "body": "if processor_name:<EOL><INDENT>return self.api.processor.get(name=processor_name)['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>return self.api.processor.get()['<STR_LIT>']<EOL><DEDENT>", "docstring": "Return a list of Processor objects.\n\n        :param project_id: ObjectId of Genesis project\n        :type project_id: string\n        :rtype: list of Processor objects", "id": "f16525:c0:m4"}
{"signature": "def data(self, **query):", "body": "objects = self.cache['<STR_LIT>']<EOL>data = self.api.data.get(**query)['<STR_LIT>']<EOL>data_objects = []<EOL>for d in data:<EOL><INDENT>_id = d['<STR_LIT:id>']<EOL>if _id in objects:<EOL><INDENT>objects[_id].update(d)<EOL><DEDENT>else:<EOL><INDENT>objects[_id] = GenData(d, self)<EOL><DEDENT>data_objects.append(objects[_id])<EOL><DEDENT>for d in data_objects:<EOL><INDENT>count += <NUM_LIT:1><EOL>while True:<EOL><INDENT>ref_annotation = {}<EOL>remove_annotation = []<EOL>for path, ann in d.annotation.items():<EOL><INDENT>if ann['<STR_LIT:type>'].startswith('<STR_LIT>'):<EOL><INDENT>_id = ann['<STR_LIT:value>']<EOL>if _id not in objects:<EOL><INDENT>try:<EOL><INDENT>d_tmp = self.api.data(_id).get()<EOL><DEDENT>except slumber.exceptions.HttpClientError as ex:<EOL><INDENT>if ex.response.status_code == <NUM_LIT>:<EOL><INDENT>continue<EOL><DEDENT>else:<EOL><INDENT>raise ex<EOL><DEDENT><DEDENT>objects[_id] = GenData(d_tmp, self)<EOL><DEDENT>annotation = objects[_id].annotation<EOL>ref_annotation.update({path + '<STR_LIT:.>' + k: v for k, v in annotation.items()})<EOL>remove_annotation.append(path)<EOL><DEDENT><DEDENT>if ref_annotation:<EOL><INDENT>d.annotation.update(ref_annotation)<EOL>for path in remove_annotation:<EOL><INDENT>del d.annotation[path]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>return data_objects<EOL>", "docstring": "Query for Data object annotation.", "id": "f16525:c0:m3"}
{"signature": "def _upload_file(self, fn):", "body": "size = os.path.getsize(fn)<EOL>counter = <NUM_LIT:0><EOL>base_name = os.path.basename(fn)<EOL>session_id = str(uuid.uuid4())<EOL>with open(fn, '<STR_LIT:rb>') as f:<EOL><INDENT>while True:<EOL><INDENT>response = None<EOL>chunk = f.read(CHUNK_SIZE)<EOL>if not chunk:<EOL><INDENT>break<EOL><DEDENT>for i in range(<NUM_LIT:5>):<EOL><INDENT>content_range = '<STR_LIT>'.format(counter * CHUNK_SIZE,<EOL>counter * CHUNK_SIZE + len(chunk) - <NUM_LIT:1>, size)<EOL>if i > <NUM_LIT:0> and response is not None:<EOL><INDENT>print(\"<STR_LIT>\"<EOL>.format(response.status_code, content_range))<EOL><DEDENT>response = requests.post(urlparse.urljoin(self.url, '<STR_LIT>'),<EOL>auth=self.auth,<EOL>data=chunk,<EOL>headers={<EOL>'<STR_LIT>': '<STR_LIT>'.format(base_name),<EOL>'<STR_LIT>': size,<EOL>'<STR_LIT>': content_range,<EOL>'<STR_LIT:Content-Type>': '<STR_LIT>',<EOL>'<STR_LIT>': session_id})<EOL>if response.status_code in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>progress = <NUM_LIT> * (counter * CHUNK_SIZE + len(chunk)) / size<EOL>sys.stdout.write(\"<STR_LIT>\".format(progress, fn))<EOL>sys.stdout.flush()<EOL>counter += <NUM_LIT:1><EOL><DEDENT><DEDENT>print()<EOL>return session_id<EOL>", "docstring": "Upload a single file on the platform.\n\n        File is uploaded in chunks of 1,024 bytes.\n\n        :param fn: File path\n        :type fn: string", "id": "f16525:c0:m10"}
{"signature": "def print_downloads(self):", "body": "for path, ann in self.annotation.items():<EOL><INDENT>if path.startswith('<STR_LIT>') and ann['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>print(\"<STR_LIT>\".format(path, ann['<STR_LIT:value>']['<STR_LIT:file>']))<EOL><DEDENT><DEDENT>", "docstring": "Print file fields to standard output.", "id": "f16527:c0:m4"}
{"signature": "def data_types(self):", "body": "data = self.gencloud.project_data(self.id)<EOL>return sorted(set(d.type for d in data))<EOL>", "docstring": "Return a list of data types.", "id": "f16530:c0:m1"}
{"signature": "def reset(self):", "body": "pass<EOL>", "docstring": "Resets the driver.", "id": "f16549:c0:m28"}
{"signature": "def open_new_window(self):", "body": "raise NotImplementedError()<EOL>", "docstring": "Opens a new window.", "id": "f16549:c0:m14"}
{"signature": "def go_back(self):", "body": "raise NotImplementedError()<EOL>", "docstring": "Move back a single entry in the browser's history.", "id": "f16549:c0:m19"}
{"signature": "@contextmanager<EOL><INDENT>def accept_modal(self, modal_type, text=None, response=None, wait=None):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "Accepts the modal that appears matching the given type and, optionally, text.\n\nArgs:\n    modal_type (str): The type of modal that should be accepted.\n    text (str | RegexObject, optional): Text that is expected to appear in the modal.\n    response (str, optional): Text to enter for a response, if applicable.\n    wait (int, optional): The number of seconds to wait for the modal to appear.", "id": "f16549:c0:m25"}
{"signature": "def evaluate_async_script(self, script, *args):", "body": "raise NotImplementedError()<EOL>", "docstring": "Evaluates the given JavaScript and obtains the result from a callback function.\n\nArgs:\n    script (str): A string of JavaScript to evaluate.\n    *args: Variable length argument list to pass to the executed JavaScript string.\n\nReturns:\n    object: The result of the evaluated JavaScript.", "id": "f16549:c0:m23"}
{"signature": "@property<EOL><INDENT>def current_url(self):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "str: The current URL.", "id": "f16549:c0:m1"}
{"signature": "@property<EOL><INDENT>def invalid_element_errors(self):<DEDENT>", "body": "return ()<EOL>", "docstring": "Tuple[Exception]: A tuple of exceptions that indicate an element is invalid.", "id": "f16549:c0:m27"}
{"signature": "@property<EOL><INDENT>def frame_url(self):<DEDENT>", "body": "try:<EOL><INDENT>return self.evaluate_script(\"<STR_LIT>\")<EOL><DEDENT>except NotImplementedError:<EOL><INDENT>raise NotImplementedError()<EOL><DEDENT>", "docstring": "str: The URL for the current frame.", "id": "f16549:c0:m6"}
{"signature": "def go_forward(self):", "body": "raise NotImplementedError()<EOL>", "docstring": "Move forward a single entry in the browser's history.", "id": "f16549:c0:m20"}
{"signature": "@property<EOL><INDENT>def value(self):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "str: The value of the node.", "id": "f16550:c0:m5"}
{"signature": "@property<EOL><INDENT>def disabled(self):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "bool: Whether this node is disabled.", "id": "f16550:c0:m25"}
{"signature": "@property<EOL><INDENT>def path(self):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "str: An XPath expression describing where on the page the node can be found.", "id": "f16550:c0:m10"}
{"signature": "def double_click(self, *keys, **offset):", "body": "raise NotImplementedError()<EOL>", "docstring": "Double-click the node.", "id": "f16550:c0:m15"}
{"signature": "def send_keys(self, *args):", "body": "raise NotImplementedError()<EOL>", "docstring": "Send keystrokes to the node.\n\nExamples::\n\n    from selenium.webdriver.common.keys import Keys\n\n    element.send_keys(\"foo\")                  # => value: \"foo\"\n    element.send_keys(\"tet\", Keys.LEFT, \"s\")  # => value: \"test\"\n\nArgs:\n    *args: Variable length list of keys to send.", "id": "f16550:c0:m20"}
{"signature": "@property<EOL><INDENT>def selected(self):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "bool: Whether this node is selected.", "id": "f16550:c0:m24"}
{"signature": "def unselect_option(self):", "body": "raise NotImplementedError()<EOL>", "docstring": "Deselects this option node.", "id": "f16550:c0:m22"}
{"signature": "def hover(self):", "body": "raise NotImplementedError()<EOL>", "docstring": "Hover on the node.", "id": "f16550:c0:m17"}
{"signature": "def description(self, options):", "body": "return \"<STR_LIT>\".join([describe(options) for describe in self.descriptions])<EOL>", "docstring": "Returns a description of the given filter options relevant to this selector.\n\nArgs:\n    options (Dict[str, Any]): The filter options to describe.\n\nReturns:\n    str: A description of the filter options.", "id": "f16551:c0:m2"}
{"signature": "def filter_set(self, name):", "body": "filter_set = filter_sets[name]<EOL>for name, filter in iter(filter_set.filters.items()):<EOL><INDENT>self.filters[name] = filter<EOL><DEDENT>self.descriptions += filter_set.descriptions<EOL>", "docstring": "Adds filters from a particular global :class:`FilterSet`.\n\nArgs:\n    name (str): The name of the set whose filters should be added.", "id": "f16551:c1:m6"}
{"signature": "def description(self, options):", "body": "return \"<STR_LIT>\".join([describe(options) for describe in self.descriptions])<EOL>", "docstring": "Returns a description of the given filter options relevant to this filter set.\n\nArgs:\n    options (Dict[str, Any]): The filter options to describe.\n\nReturns:\n    str: A description of the filter options.", "id": "f16552:c0:m1"}
{"signature": "def build_filter_set(self):", "body": "return FilterSet(self.name, self.descriptions, self.filters)<EOL>", "docstring": "FilterSet: Returns a new :class:`FilterSet` with the current factory config.", "id": "f16552:c1:m4"}
{"signature": "def describe(self, func):", "body": "self.descriptions.append(func)<EOL>", "docstring": "Decorates a function that builds a description of some filter set options.\n\nArgs:\n    func (Callable[[Dict[str, Any]], str]): The description builder function.", "id": "f16552:c1:m1"}
{"signature": "def _valid_value(self, value):", "body": "if not self.valid_values:<EOL><INDENT>return True<EOL><DEDENT>valid_values = (self.valid_values if isinstance(self.valid_values, list)<EOL>else list(self.valid_values))<EOL>return value in valid_values<EOL>", "docstring": "bool: Whether the given value is valid.", "id": "f16554:c0:m4"}
{"signature": "@property<EOL><INDENT>def has_skip_if(self):<DEDENT>", "body": "return self.skip_if is not None<EOL>", "docstring": "bool: Whether this rule has a value for which it should be skipped.", "id": "f16554:c0:m2"}
{"signature": "def assert_current_path(self, path, **kwargs):", "body": "query = CurrentPathQuery(path, **kwargs)<EOL>@self.document.synchronize<EOL>def assert_current_path():<EOL><INDENT>if not query.resolves_for(self):<EOL><INDENT>raise ExpectationNotMet(query.failure_message)<EOL><DEDENT><DEDENT>assert_current_path()<EOL>return True<EOL>", "docstring": "Asserts that the page has the given path. By default this will compare against the\npath+query portion of the full URL.\n\nArgs:\n    path (str | RegexObject): The string or regex that the current \"path\" should match.\n    **kwargs: Arbitrary keyword arguments for :class:`CurrentPathQuery`.\n\nReturns:\n    True\n\nRaises:\n    ExpectationNotMet: If the assertion hasn't succeeded during the wait time.", "id": "f16559:c0:m0"}
{"signature": "def _build_config_for_path(path):", "body": "<EOL>for rootdir in path.parts(reverse=True):<EOL><INDENT>if rootdir.join(\"<STR_LIT>\").exists():<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>rootdir = path<EOL><DEDENT>pluginmanager = PytestPluginManager()<EOL>for spec in default_plugins:<EOL><INDENT>pluginmanager.import_plugin(spec)<EOL><DEDENT>config = Config(pluginmanager)<EOL>args = [rootdir]<EOL>config.parse(args)<EOL>return config<EOL>", "docstring": "Builds and returns a basic test configuration rooted at the given path.\n\nArgs:\n    path (LocalPath): The path to the files under test.\n\nReturns:\n    Config: The generated test configuration.", "id": "f16643:m0"}
{"signature": "def ismarionettelt(version, session):", "body": "return ismarionette(session) and int(session.driver.browser.capabilities['<STR_LIT>'].split(\"<STR_LIT:.>\")[<NUM_LIT:0>]) < version<EOL>", "docstring": "Whether the session is using Marionette with Firefox less than the given version.\n\nArgs:\n    version (int): The Firefox version to test.\n    session (Session): The Capybara session.\n\nReturns:\n    bool: Whether the session is using Marionette with Firefox less than the given version.", "id": "f16648:m3"}
{"signature": "def isselenium(session):", "body": "try:<EOL><INDENT>from capybara.selenium.driver import Driver<EOL><DEDENT>except ImportError:<EOL><INDENT>return False<EOL><DEDENT>return isinstance(session.driver, Driver)<EOL>", "docstring": "bool: Whether the session is using Selenium.", "id": "f16648:m4"}
{"signature": "@property<EOL><INDENT>def negative_failure_message(self):<DEDENT>", "body": "return self._build_message(\"<STR_LIT>\")<EOL>", "docstring": "str: A message describing the negative query failure.", "id": "f16650:c0:m4"}
{"signature": "def resolves_for(self, node):", "body": "self.node = node<EOL>self.actual_styles = node.style(*self.expected_styles.keys())<EOL>return all(<EOL>toregex(value).search(self.actual_styles[style])<EOL>for style, value in iter(self.expected_styles.items()))<EOL>", "docstring": "Resolves this query relative to the given node.\n\nArgs:\n    node (node.Base): The node to be evaluated.\n\nReturns:\n    int: The number of matches found.", "id": "f16651:c0:m2"}
{"signature": "@property<EOL><INDENT>def failure_message(self):<DEDENT>", "body": "return (<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\").format(<EOL>expected=desc(self.expected_styles),<EOL>actual=desc(self.actual_styles))<EOL>", "docstring": "str: A message describing the query failure.", "id": "f16651:c0:m3"}
{"signature": "@property<EOL><INDENT>def exact(self):<DEDENT>", "body": "if self.options[\"<STR_LIT>\"] is not None:<EOL><INDENT>return self.options[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>return capybara.exact<EOL><DEDENT>", "docstring": "bool: Whether to exactly match the locator string.", "id": "f16652:c0:m5"}
{"signature": "@property<EOL><INDENT>def description(self):<DEDENT>", "body": "description = self.label<EOL>if self.locator:<EOL><INDENT>description += \"<STR_LIT>\".format(desc(self.locator))<EOL><DEDENT>if self.options[\"<STR_LIT:text>\"] is not None:<EOL><INDENT>description += \"<STR_LIT>\".format(desc(self.options[\"<STR_LIT:text>\"]))<EOL><DEDENT>description += self.selector.description(self.filter_options)<EOL>return description<EOL>", "docstring": "str: A long description of this query.", "id": "f16652:c0:m4"}
{"signature": "def matches_filters(self, node):", "body": "visible = self.visible<EOL>if self.options[\"<STR_LIT:text>\"]:<EOL><INDENT>if isregex(self.options[\"<STR_LIT:text>\"]):<EOL><INDENT>regex = self.options[\"<STR_LIT:text>\"]<EOL><DEDENT>elif self.exact_text is True:<EOL><INDENT>regex = re.compile(r\"<STR_LIT>\".format(re.escape(self.options[\"<STR_LIT:text>\"])))<EOL><DEDENT>else:<EOL><INDENT>regex = toregex(self.options[\"<STR_LIT:text>\"])<EOL><DEDENT>text = normalize_text(<EOL>node.all_text if visible == \"<STR_LIT:all>\" else node.visible_text)<EOL>if not regex.search(text):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>if isinstance(self.exact_text, (bytes_, str_)):<EOL><INDENT>regex = re.compile(r\"<STR_LIT>\".format(re.escape(self.exact_text)))<EOL>text = normalize_text(<EOL>node.all_text if visible == \"<STR_LIT:all>\" else node.visible_text)<EOL>if not regex.search(text):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>if visible == \"<STR_LIT>\":<EOL><INDENT>if not node.visible:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>elif visible == \"<STR_LIT>\":<EOL><INDENT>if node.visible:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>for name, node_filter in iter(self._node_filters.items()):<EOL><INDENT>if name in self.filter_options:<EOL><INDENT>if not node_filter.matches(node, self.filter_options[name]):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>elif node_filter.has_default:<EOL><INDENT>if not node_filter.matches(node, node_filter.default):<EOL><INDENT>return False<EOL><DEDENT><DEDENT><DEDENT>if self.options[\"<STR_LIT>\"] and not self.options[\"<STR_LIT>\"](node):<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "Returns whether the given node matches all filters.\n\nArgs:\n    node (Element): The node to evaluate.\n\nReturns:\n    bool: Whether the given node matches.", "id": "f16652:c0:m13"}
{"signature": "@property<EOL><INDENT>def failure_message(self):<DEDENT>", "body": "return self._build_message()<EOL>", "docstring": "str: A description of this query's failure.", "id": "f16654:c0:m2"}
{"signature": "@property<EOL><INDENT>def negative_failure_message(self):<DEDENT>", "body": "return self._build_message(\"<STR_LIT>\")<EOL>", "docstring": "str: A description of this query's negative failure.", "id": "f16654:c0:m3"}
{"signature": "def resolves_for(self, session):", "body": "if self.url:<EOL><INDENT>self.actual_path = session.current_url<EOL><DEDENT>else:<EOL><INDENT>result = urlparse(session.current_url)<EOL>if self.only_path:<EOL><INDENT>self.actual_path = result.path<EOL><DEDENT>else:<EOL><INDENT>request_uri = result.path<EOL>if result.query:<EOL><INDENT>request_uri += \"<STR_LIT>\".format(result.query)<EOL><DEDENT>self.actual_path = request_uri<EOL><DEDENT><DEDENT>if isregex(self.expected_path):<EOL><INDENT>return self.expected_path.search(self.actual_path)<EOL><DEDENT>else:<EOL><INDENT>return normalize_url(self.actual_path) == normalize_url(self.expected_path)<EOL><DEDENT>", "docstring": "Returns whether this query resolves for the given session.\n\nArgs:\n    session (Session): The session for which this query should be executed.\n\nReturns:\n    bool: Whether this query resolves.", "id": "f16654:c0:m1"}
{"signature": "def resolve_for(self, node):", "body": "self.node = node<EOL>self.actual_text = normalize_text(<EOL>node.visible_text if self.query_type == \"<STR_LIT>\" else node.all_text)<EOL>self.count = len(re.findall(self.search_regexp, self.actual_text))<EOL>return self.count<EOL>", "docstring": "Resolves this query relative to the given node.\n\nArgs:\n    node (node.Base): The node to be evaluated.\n\nReturns:\n    int: The number of matches found.", "id": "f16656:c0:m2"}
{"signature": "@property<EOL><INDENT>def current(self):<DEDENT>", "body": "try:<EOL><INDENT>return self.driver.current_window_handle == self.handle<EOL><DEDENT>except self.driver.no_such_window_error:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "bool: Whether this window is the window in which commands are being executed.", "id": "f16658:c0:m7"}
{"signature": "def close(self):", "body": "self.driver.close_window(self.handle)<EOL>", "docstring": "Close window.\n\nIf this method was called for the window that is current, then after calling this method\nfuture invocations of other Capybara methods should raise\n``session.driver.no_such_window_error`` until another window is switched to.\n\nIf this method was called for a window that is not current, then after calling this method\nthe current window should remain the same as it was before calling this method.", "id": "f16658:c0:m10"}
{"signature": "def boot(self):", "body": "if not self.responsive:<EOL><INDENT>type(self)._ports[self.port_key] = self.port<EOL>init_func = capybara.servers[capybara.server_name]<EOL>init_args = (self.middleware, self.port, self.host)<EOL>self.server_thread = Thread(target=init_func, args=init_args)<EOL>self.server_thread.daemon = True<EOL>self.server_thread.start()<EOL>timer = Timer(<NUM_LIT>)<EOL>while not self.responsive:<EOL><INDENT>if timer.expired:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>self.server_thread.join(<NUM_LIT:0.1>)<EOL><DEDENT><DEDENT>return self<EOL>", "docstring": "Boots a server for the app, if it isn't already booted.\n\nReturns:\n    Server: This server.", "id": "f16664:c0:m6"}
{"signature": "def use_default_driver():", "body": "global current_driver<EOL>current_driver = None<EOL>", "docstring": "Use the default driver as the current driver.", "id": "f16666:m3"}
{"signature": "def desc(value):", "body": "def normalize_strings(value):<EOL><INDENT>if isinstance(value, list):<EOL><INDENT>value = [normalize_strings(e) for e in value]<EOL><DEDENT>if isinstance(value, dict):<EOL><INDENT>value = {normalize_strings(k): normalize_strings(v) for k, v in iter(value.items())}<EOL><DEDENT>if isregex(value):<EOL><INDENT>value = value.pattern<EOL><DEDENT>if isbytes(value):<EOL><INDENT>value = decode_bytes(value)<EOL><DEDENT>if PY2:<EOL><INDENT>if isstring(value):<EOL><INDENT>value = encode_string(value)<EOL><DEDENT><DEDENT>return value<EOL><DEDENT>value = normalize_strings(value)<EOL>return repr(value)<EOL>", "docstring": "str: A normalized representation for a user-provided value.", "id": "f16668:m1"}
{"signature": "def expects_none(options):", "body": "if any(options.get(key) is not None for key in [\"<STR_LIT:count>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]):<EOL><INDENT>return matches_count(<NUM_LIT:0>, options)<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Returns whether the given query options expect a possible count of zero.\n\nArgs:\n    options (Dict[str, int | Iterable[int]]): A dictionary of query options.\n\nReturns:\n    bool: Whether a possible count of zero is expected.", "id": "f16668:m2"}
{"signature": "@property<EOL><INDENT>def expired(self):<DEDENT>", "body": "return monotonic() - self._start >= self._expire_in<EOL>", "docstring": "bool: Whether this timer has expired.", "id": "f16668:c0:m1"}
{"signature": "@property<EOL><INDENT>def text(self):<DEDENT>", "body": "return self.find(\"<STR_LIT>\", \"<STR_LIT>\").text<EOL>", "docstring": "str: The text of the document.", "id": "f16669:c0:m2"}
{"signature": "@property<EOL><INDENT>def checked(self):<DEDENT>", "body": "return \"<STR_LIT>\" in self.native.attrib<EOL>", "docstring": "bool: Whether or not the element is checked.", "id": "f16670:c0:m7"}
{"signature": "@property<EOL><INDENT>def disabled(self):<DEDENT>", "body": "return \"<STR_LIT>\" in self.native.attrib<EOL>", "docstring": "bool: Whether or not the element is disabled.", "id": "f16670:c0:m8"}
{"signature": "@property<EOL><INDENT>def visible(self):<DEDENT>", "body": "return self._visible()<EOL>", "docstring": "bool: Whether or not the element is visible.", "id": "f16670:c0:m6"}
{"signature": "@property<EOL><INDENT>def text(self):<DEDENT>", "body": "return self.native.text<EOL>", "docstring": "str: The text of the element.", "id": "f16670:c0:m4"}
{"signature": "@property<EOL><INDENT>def selected(self):<DEDENT>", "body": "return \"<STR_LIT>\" in self.native.attrib<EOL>", "docstring": "bool: Whether or not the element is selected.", "id": "f16670:c0:m11"}
{"signature": "@property<EOL><INDENT>def text(self):<DEDENT>", "body": "raise NotImplementedError()<EOL>", "docstring": "str: The text of the node.", "id": "f16671:c0:m7"}
{"signature": "def has_unchecked_field(self, locator, **kwargs):", "body": "kwargs[\"<STR_LIT>\"] = False<EOL>return self.has_selector(\"<STR_LIT>\", locator, **kwargs)<EOL>", "docstring": "Checks if the page or current node has a radio button or checkbox with the given label,\nvalue, or id, that is currently unchecked.\n\nArgs:\n    locator (str): The label, name, or id of an unchecked field.\n    **kwargs: Arbitrary keyword arguments for :class:`SelectorQuery`.\n\nReturns:\n    bool: Whether it exists.", "id": "f16672:c0:m34"}
{"signature": "@predicate<EOL><INDENT>def has_text(self, *args, **kwargs):<DEDENT>", "body": "return self.assert_text(*args, **kwargs)<EOL>", "docstring": "Checks if the page or current node has the given text content, ignoring any HTML tags.\n\nWhitespaces are normalized in both the node's text and the passed text parameter. Note that\nwhitespace isn't normalized in a passed regular expression as normalizing whitespace in a\nregular expression isn't easy and doesn't seem to be worth it.\n\nBy default it will check if the text occurs at least once, but a different number can be\nspecified. ::\n\n    page.has_text(\"lorem ipsum\", between=range(2, 5))\n\nArgs:\n    *args: Variable length argument list for :class:`TextQuery`.\n    **kwargs: Arbitrary keyword arguments for :class:`TextQuery`.\n\nReturns:\n    bool: Whether it exists.", "id": "f16672:c0:m38"}
{"signature": "def assert_matches_selector(self, *args, **kwargs):", "body": "query = SelectorQuery(*args, **kwargs)<EOL>@self.synchronize(wait=query.wait)<EOL>def assert_matches_selector():<EOL><INDENT>result = query.resolve_for(self.find_first(\"<STR_LIT>\", \"<STR_LIT>\", minimum=<NUM_LIT:0>) or self.query_scope)<EOL>if self not in result:<EOL><INDENT>raise ExpectationNotMet(\"<STR_LIT>\")<EOL><DEDENT>return True<EOL><DEDENT>return assert_matches_selector()<EOL>", "docstring": "Asserts that the current node matches a given selector. ::\n\n    node.assert_matches_selector(\"p#foo\")\n    node.assert_matches_selector(\"xpath\", \"//p[@id='foo']\")\n\nIt also accepts all options that :meth:`find_all` accepts, such as ``text`` and\n``visible``. ::\n\n    node.assert_matches_selector(\"li\", text=\"Horse\", visible=True)\n\nArgs:\n    *args: Variable length argument list for :class:`SelectorQuery`.\n    **kwargs: Arbitrary keyword arguments for :class:`SelectorQuery`.\n\nReturns:\n    True\n\nRaises:\n    ExpectationNotMet: If the selector does not match.", "id": "f16672:c0:m12"}
{"signature": "def matches_css(self, css, **kwargs):", "body": "return self.matches_selector(\"<STR_LIT>\", css, **kwargs)<EOL>", "docstring": "Checks if the current node matches the given CSS selector.\n\nArgs:\n    css (str): The CSS selector to match against the current node.\n    **kwargs: Arbitrary keyword arguments for :class:`SelectorQuery`.\n\nReturn:\n    bool: Whether it matches.", "id": "f16672:c0:m16"}
{"signature": "def has_xpath(self, query, **kwargs):", "body": "return self.has_selector(\"<STR_LIT>\", query, **kwargs)<EOL>", "docstring": "Checks if a given XPath expression is on the page or a descendant of the current node. ::\n\n    session.has_xpath(\".//p[@id='foo']\")\n\n``has_xpath`` can also accept XPath expressions generated by the ``xpath-py`` package::\n\n    from xpath import dsl as x\n\n    session.has_xpath(x.descendant(\"p\"))\n\nArgs:\n    query (str): An XPath expression.\n    **kwargs: Arbitrary keyword arguments for :class:`SelectorQuery`.\n\nReturn:\n    bool: If the expression exists.", "id": "f16672:c0:m18"}
{"signature": "def assert_text(self, *args, **kwargs):", "body": "query = TextQuery(*args, **kwargs)<EOL>@self.synchronize(wait=query.wait)<EOL>def assert_text():<EOL><INDENT>count = query.resolve_for(self)<EOL>if not (matches_count(count, query.options) and<EOL>(count > <NUM_LIT:0> or expects_none(query.options))):<EOL><INDENT>raise ExpectationNotMet(query.failure_message)<EOL><DEDENT>return True<EOL><DEDENT>return assert_text()<EOL>", "docstring": "Asserts that the page or current node has the given text content, ignoring any HTML tags.\n\nArgs:\n    *args: Variable length argument list for :class:`TextQuery`.\n    **kwargs: Arbitrary keyword arguments for :class:`TextQuery`.\n\nReturns:\n    True\n\nRaises:\n    ExpectationNotMet: If the assertion hasn't succeeded during the wait time.", "id": "f16672:c0:m36"}
{"signature": "@predicate<EOL><INDENT>def matches_selector(self, *args, **kwargs):<DEDENT>", "body": "return self.assert_matches_selector(*args, **kwargs)<EOL>", "docstring": "Checks if the current node matches the given selector.\n\nArgs:\n    *args: Variable length argument list for :class:`SelectorQuery`.\n    **kwargs: Arbitrary keyword arguments for :class:`SelectorQuery`.\n\nReturns:\n    bool: Whether it matches.", "id": "f16672:c0:m5"}
{"signature": "def find(self, *args, **kwargs):", "body": "return self._synchronized_resolve(SelectorQuery(*args, **kwargs))<EOL>", "docstring": "Find an :class:`Element` based on the given arguments. ``find`` will raise an error if the\nelement is not found.\n\n``find`` takes the same options as :meth:`find_all`. ::\n\n    page.find(\"#foo\").find(\".bar\")\n    page.find(\"xpath\", \"//div[contains(., 'bar')]\")\n    page.find(\"li\", text=\"Quox\").click_link(\"Delete\")\n\nArgs:\n    *args: Variable length argument list for :class:`SelectorQuery`.\n    **kwargs: Arbitrary keyword arguments for :class:`SelectorQuery`.\n\nReturns:\n    Element: The found element.\n\nRaises:\n    Ambiguous: If more than one element matching element is found.\n    ElementNotFound: If the element can't be found before time expires.", "id": "f16673:c0:m0"}
{"signature": "def check(self, locator=None, allow_label_click=None, **kwargs):", "body": "self._check_with_label(<EOL>\"<STR_LIT>\", True, locator=locator, allow_label_click=allow_label_click, **kwargs)<EOL>", "docstring": "Find a check box and mark it as checked. The check box can be found via name, id, or label\ntext. ::\n\n    page.check(\"German\")\n\nArgs:\n    locator (str, optional): Which check box to check.\n    allow_label_click (bool, optional): Attempt to click the label to toggle state if\n        element is non-visible. Defaults to :data:`capybara.automatic_label_click`.\n    **kwargs: Arbitrary keyword arguments for :class:`SelectorQuery`.", "id": "f16674:c0:m1"}
{"signature": "def _check_with_label(self, selector, checked, locator=None, allow_label_click=None, visible=None, wait=None,<EOL>**kwargs):", "body": "if allow_label_click is None:<EOL><INDENT>allow_label_click = capybara.automatic_label_click<EOL><DEDENT>@self.synchronize(wait=BaseQuery.normalize_wait(wait))<EOL>def check_with_label():<EOL><INDENT>element = None<EOL>try:<EOL><INDENT>element = self.find(selector, locator, visible=visible, **kwargs)<EOL>element.set(checked)<EOL><DEDENT>except Exception as e:<EOL><INDENT>if not allow_label_click or not self._should_catch_error(e):<EOL><INDENT>raise<EOL><DEDENT>try:<EOL><INDENT>if not element:<EOL><INDENT>element = self.find(selector, locator, visible=\"<STR_LIT:all>\", **kwargs)<EOL><DEDENT>label = self.find(\"<STR_LIT:label>\", field=element, visible=True)<EOL>if element.checked != checked:<EOL><INDENT>label.click()<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>raise e<EOL><DEDENT><DEDENT><DEDENT>check_with_label()<EOL>", "docstring": "Args:\n    selector (str): The selector for the type of element that should be checked/unchecked.\n    checked (bool): Whether the element should be checked.\n    locator (str, optional): Which element to check.\n    allow_label_click (bool, optional): Attempt to click the label to toggle state if\n        element is non-visible. Defaults to :data:`capybara.automatic_label_click`.\n    visible (bool | str, optional): The desired element visibility. Defaults to\n        :data:`capybara.ignore_hidden_elements`.\n    wait (int | float, optional): The number of seconds to wait to check the element.\n        Defaults to :data:`capybara.default_max_wait_time`.\n    **kwargs: Arbitrary keyword arguments for :class:`SelectorQuery`.", "id": "f16674:c0:m10"}
{"signature": "def click_link(self, locator=None, **kwargs):", "body": "return self.find(\"<STR_LIT>\", locator, **kwargs).click()<EOL>", "docstring": "Finds a link by id, text, or title and clicks it. Also looks at image alt text inside the\nlink.\n\nArgs:\n    locator (str, optional): Text, id, title, or nested image's alt attribute.\n    **kwargs: Arbitrary keyword arguments for :class:`SelectorQuery`.", "id": "f16674:c0:m4"}
{"signature": "def has_no_title(self, title, **kwargs):", "body": "try:<EOL><INDENT>self.assert_no_title(title, **kwargs)<EOL>return True<EOL><DEDENT>except ExpectationNotMet:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Checks if the page doesn't have the given title.\n\nArgs:\n    title (str | RegexObject): The string that the title should include.\n    **kwargs: Arbitrary keyword arguments for :class:`TitleQuery`.\n\nReturns:\n    bool: Whether it doesn't match.", "id": "f16675:c0:m3"}
{"signature": "def assert_title(self, title, **kwargs):", "body": "query = TitleQuery(title, **kwargs)<EOL>@self.synchronize(wait=query.wait)<EOL>def assert_title():<EOL><INDENT>if not query.resolves_for(self):<EOL><INDENT>raise ExpectationNotMet(query.failure_message)<EOL><DEDENT>return True<EOL><DEDENT>return assert_title()<EOL>", "docstring": "Asserts that the page has the given title.\n\nArgs:\n    title (str | RegexObject): The string or regex that the title should match.\n    **kwargs: Arbitrary keyword arguments for :class:`TitleQuery`.\n\nReturns:\n    True\n\nRaises:\n    ExpectationNotMet: If the assertion hasn't succeeded during the wait time.", "id": "f16675:c0:m0"}
{"signature": "@synchronize<EOL><INDENT>def drag_to(self, node):<DEDENT>", "body": "self.base.drag_to(node.base)<EOL>", "docstring": "Drag the element to the given other element. ::\n\n    source = page.find(\"#foo\")\n    target = page.find(\"#bar\")\n    source.drag_to(target)\n\nArgs:\n    node (Element): The element to drag to.", "id": "f16676:c0:m23"}
{"signature": "@property<EOL><INDENT>@synchronize<EOL>def readonly(self):<DEDENT>", "body": "return self.base.readonly<EOL>", "docstring": "bool: Whether or not the element is readonly.", "id": "f16676:c0:m17"}
{"signature": "@property<EOL><INDENT>@synchronize<EOL>def multiple(self):<DEDENT>", "body": "return self.base.multiple<EOL>", "docstring": "bool: Whether or not the element supports multiple results.", "id": "f16676:c0:m18"}
{"signature": "@synchronize<EOL><INDENT>def click(self, *keys, **offset):<DEDENT>", "body": "self.base.click(*keys, **offset)<EOL>", "docstring": "Click the element.\n\nBoth ``x`` and ``y`` must be specified if an offset is wanted. If not specified, the click\nwill occur at the middle of the element.\n\nArgs:\n    keys (List[Keys], optional): Keys to be held down when clicking.\n    offset (Dict[str, int], optional): X- and Y-coordinates to offset the click location\n        from the toop left corner of the element.", "id": "f16676:c0:m21"}
{"signature": "@synchronize<EOL><INDENT>def right_click(self, *keys, **offset):<DEDENT>", "body": "self.base.right_click(*keys, **offset)<EOL>", "docstring": "Right-click the element.\n\nBoth ``x`` and ``y`` must be specified if an offset is wanted. If not specified, the click\nwill occur at the middle of the element.\n\nArgs:\n    keys (List[Keys], optional): Keys to be held down when clicking.\n    offset (Dict[str, int], optional): X- and Y-coordinates to offset the click location\n        from the toop left corner of the element.", "id": "f16676:c0:m26"}
{"signature": "@synchronize<EOL><INDENT>def send_keys(self, *args):<DEDENT>", "body": "self.base.send_keys(*args)<EOL>", "docstring": "Send keystrokes to the element.\n\nExamples::\n\n    from selenium.webdriver.common.keys import Keys\n\n    element.send_keys(\"foo\")                  # => value: \"foo\"\n    element.send_keys(\"tet\", Keys.LEFT, \"s\")  # => value: \"test\"\n\nArgs:\n    *args: Variable length list of keys to send.", "id": "f16676:c0:m24"}
{"signature": "@synchronize<EOL><INDENT>def set(self, value, **options):<DEDENT>", "body": "self.base.set(value, **options)<EOL>", "docstring": "Set the value of the form element to the given value.\n\nArgs:\n    value (bool | str): The new value.\n    **options: Driver-specific options for how to set the value.", "id": "f16676:c0:m28"}
{"signature": "@property<EOL><INDENT>@synchronize<EOL>def selected(self):<DEDENT>", "body": "return self.base.selected<EOL>", "docstring": "bool: Whether or not the element is selected.", "id": "f16676:c0:m15"}
{"signature": "@synchronize<EOL><INDENT>def unselect_option(self):<DEDENT>", "body": "self.base.unselect_option()<EOL>", "docstring": "Unselect this node if it is an option element inside a multiple select tag.", "id": "f16676:c0:m29"}
{"signature": "@property<EOL><INDENT>def matches_count(self):<DEDENT>", "body": "return self.compare_count == <NUM_LIT:0><EOL>", "docstring": "bool: Whether the result count matches the query options.", "id": "f16677:c0:m6"}
{"signature": "@property<EOL><INDENT>def compare_count(self):<DEDENT>", "body": "if self.query.options[\"<STR_LIT:count>\"] is not None:<EOL><INDENT>count_opt = int(self.query.options[\"<STR_LIT:count>\"])<EOL>self._cache_at_least(count_opt + <NUM_LIT:1>)<EOL>return cmp(len(self._result_cache), count_opt)<EOL><DEDENT>if self.query.options[\"<STR_LIT>\"] is not None:<EOL><INDENT>min_opt = int(self.query.options[\"<STR_LIT>\"])<EOL>if not self._cache_at_least(min_opt):<EOL><INDENT>return -<NUM_LIT:1><EOL><DEDENT><DEDENT>if self.query.options[\"<STR_LIT>\"] is not None:<EOL><INDENT>max_opt = int(self.query.options[\"<STR_LIT>\"])<EOL>if self._cache_at_least(max_opt + <NUM_LIT:1>):<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT><DEDENT>if self.query.options[\"<STR_LIT>\"] is not None:<EOL><INDENT>between = self.query.options[\"<STR_LIT>\"]<EOL>min_opt, max_opt = between[<NUM_LIT:0>], between[-<NUM_LIT:1>]<EOL>if not self._cache_at_least(min_opt):<EOL><INDENT>return -<NUM_LIT:1><EOL><DEDENT>if self._cache_at_least(max_opt + <NUM_LIT:1>):<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>return <NUM_LIT:0><EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Returns how the result count compares to the query options.\n\nThe return value is negative if too few results were found, zero if enough were found, and\npositive if too many were found.\n\nReturns:\n    int: -1, 0, or 1.", "id": "f16677:c0:m5"}
{"signature": "def isregex(possible_regex):", "body": "return hasattr(possible_regex, \"<STR_LIT>\") and callable(possible_regex.search)<EOL>", "docstring": "Returns whether the given object is (probably) a regular expression object.\n\nArgs:\n    possible_regex (object): An object which may or may not be a regular expression.\n\nReturns:\n    bool: Whether the given object is (probably) a regular expression object.", "id": "f16678:m6"}
{"signature": "def decode_bytes(value):", "body": "return value.decode(\"<STR_LIT:utf-8>\") if isbytes(value) else value<EOL>", "docstring": "str: Decodes the given byte sequence.", "id": "f16678:m0"}
{"signature": "@property<EOL><INDENT>def value(self):<DEDENT>", "body": "return self._value<EOL>", "docstring": "int: The current value of the counter.", "id": "f16678:c1:m1"}
{"signature": "def get_browser(browser_name, capabilities=None, **options):", "body": "if browser_name == \"<STR_LIT>\":<EOL><INDENT>return webdriver.Chrome(desired_capabilities=capabilities, **options)<EOL><DEDENT>if browser_name == \"<STR_LIT>\":<EOL><INDENT>return webdriver.Edge(capabilities=capabilities, **options)<EOL><DEDENT>if browser_name in [\"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>return webdriver.Firefox(capabilities=capabilities, **options)<EOL><DEDENT>if browser_name in [\"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>return webdriver.Ie(capabilities=capabilities, **options)<EOL><DEDENT>if browser_name == \"<STR_LIT>\":<EOL><INDENT>return webdriver.PhantomJS(desired_capabilities=capabilities, **options)<EOL><DEDENT>if browser_name == \"<STR_LIT>\":<EOL><INDENT>return webdriver.Remote(desired_capabilities=capabilities, **options)<EOL><DEDENT>if browser_name == \"<STR_LIT>\":<EOL><INDENT>return webdriver.Safari(desired_capabilities=capabilities, **options)<EOL><DEDENT>raise ValueError(\"<STR_LIT>\".format(repr(browser_name)))<EOL>", "docstring": "Returns an instance of the given browser with the given capabilities.\n\nArgs:\n    browser_name (str): The name of the desired browser.\n    capabilities (Dict[str, str | bool], optional): The desired capabilities of the browser.\n        Defaults to None.\n    options: Arbitrary keyword arguments for the browser-specific subclass of\n        :class:`webdriver.Remote`.\n\nReturns:\n    WebDriver: An instance of the desired browser.", "id": "f16679:m0"}
{"signature": "def visit(self, visit_uri):", "body": "self.raise_server_error()<EOL>visit_uri = urlparse(visit_uri)<EOL>if capybara.app_host:<EOL><INDENT>uri_base = urlparse(capybara.app_host)<EOL><DEDENT>elif self.server:<EOL><INDENT>uri_base = urlparse(\"<STR_LIT>\".format(self.server.host, self.server.port))<EOL><DEDENT>else:<EOL><INDENT>uri_base = None<EOL><DEDENT>visit_uri = ParseResult(<EOL>scheme=visit_uri.scheme or (uri_base.scheme if uri_base else \"<STR_LIT>\"),<EOL>netloc=visit_uri.netloc or (uri_base.netloc if uri_base else \"<STR_LIT>\"),<EOL>path=visit_uri.path,<EOL>params=visit_uri.params,<EOL>query=visit_uri.query,<EOL>fragment=visit_uri.fragment)<EOL>self.driver.visit(visit_uri.geturl())<EOL>", "docstring": "Navigate to the given URL. The URL can either be a relative URL or an absolute URL. The\nbehavior of either depends on the driver. ::\n\n    session.visit(\"/foo\")\n    session.visit(\"http://google.com\")\n\nFor drivers which can run against an external application, such as the Selenium driver,\ngiving an absolute URL will navigate to that page. This allows testing applications running\non remote servers. For these drivers, setting :data:`capybara.app_host` will make the\nremote server the default. For example::\n\n    capybara.app_host = \"http://google.com\"\n    session.visit(\"/\")  # visits the Google homepage\n\nArgs:\n    visit_uri (str): The URL to navigate to.", "id": "f16683:c0:m8"}
{"signature": "@contextmanager<EOL><INDENT>def frame(self, locator=None, *args, **kwargs):<DEDENT>", "body": "self.switch_to_frame(self._find_frame(locator, *args, **kwargs))<EOL>try:<EOL><INDENT>yield<EOL><DEDENT>finally:<EOL><INDENT>self.switch_to_frame(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Execute the wrapped code within the given iframe using the given frame or frame name/id.\nMay not be supported by all drivers.\n\nArgs:\n    locator (str | Element, optional): The name/id of the frame or the frame's element.\n        Defaults to the only frame in the document.", "id": "f16683:c0:m15"}
{"signature": "@property<EOL><INDENT>def html(self):<DEDENT>", "body": "return self.driver.html<EOL>", "docstring": "str: A snapshot of the DOM of the current document, as it looks right now.", "id": "f16683:c0:m4"}
{"signature": "def switch_to_window(self, window, wait=None):", "body": "if len(self._scopes) > <NUM_LIT:1>:<EOL><INDENT>raise ScopeError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>if isinstance(window, Window):<EOL><INDENT>self.driver.switch_to_window(window.handle)<EOL>return window<EOL><DEDENT>else:<EOL><INDENT>@self.document.synchronize(errors=(WindowError,), wait=wait)<EOL>def switch_and_get_matching_window():<EOL><INDENT>original_window_handle = self.driver.current_window_handle<EOL>try:<EOL><INDENT>for handle in self.driver.window_handles:<EOL><INDENT>self.driver.switch_to_window(handle)<EOL>result = window()<EOL>if result:<EOL><INDENT>return Window(self, handle)<EOL><DEDENT><DEDENT><DEDENT>except Exception:<EOL><INDENT>self.driver.switch_to_window(original_window_handle)<EOL>raise<EOL><DEDENT>self.driver.switch_to_window(original_window_handle)<EOL>raise WindowError(\"<STR_LIT>\")<EOL><DEDENT>return switch_and_get_matching_window()<EOL><DEDENT>", "docstring": "If ``window`` is a lambda, it switches to the first window for which ``window`` returns a\nvalue other than False or None. If a window that matches can't be found, the window will be\nswitched back and :exc:`WindowError` will be raised.\n\nArgs:\n    window (Window | lambda): The window that should be switched to, or a filtering lambda.\n    wait (int | float, optional): The number of seconds to wait to find the window.\n\nReturns:\n    Window: The new current window.\n\nRaises:\n    ScopeError: If this method is invoked inside :meth:`scope, :meth:`frame`, or\n        :meth:`window`.\n    WindowError: If no window matches the given lambda.", "id": "f16683:c0:m21"}
{"signature": "@contextmanager<EOL><INDENT>def accept_confirm(self, text=None, wait=None):<DEDENT>", "body": "with self.driver.accept_modal(\"<STR_LIT>\", text=text, wait=wait):<EOL><INDENT>yield<EOL><DEDENT>", "docstring": "Execute the wrapped code, accepting a confirm.\n\nArgs:\n    text (str | RegexObject, optional): Text to match against the text in the modal.\n    wait (int | float, optional): Maximum time to wait for the modal to appear after\n        executing the wrapped code.\n\nRaises:\n    ModalNotFound: If a modal dialog hasn't been found.", "id": "f16683:c0:m28"}
{"signature": "def save_page(self, path=None):", "body": "path = _prepare_path(path, \"<STR_LIT:html>\")<EOL>with open(path, \"<STR_LIT:wb>\") as f:<EOL><INDENT>f.write(encode_string(self.body))<EOL><DEDENT>return path<EOL>", "docstring": "Save a snapshot of the page.\n\nIf invoked without arguments, it will save a file to :data:`capybara.save_path` and the\nfile will be given a randomly generated filename. If invoked with a relative path, the path\nwill be relative to :data:`capybara.save_path`.\n\nArgs:\n    path (str, optional): The path to where it should be saved.\n\nReturns:\n    str: The path to which the file was saved.", "id": "f16683:c0:m32"}
{"signature": "@contextmanager<EOL><INDENT>def fieldset(self, locator):<DEDENT>", "body": "with self.scope(\"<STR_LIT>\", locator):<EOL><INDENT>yield<EOL><DEDENT>", "docstring": "Execute the wrapped code within a specific fieldset given the id or legend of that\nfieldset.\n\nArgs:\n    locator (str): The id or legend of the fieldset.", "id": "f16683:c0:m13"}
{"signature": "@property<EOL><INDENT>def current_host(self):<DEDENT>", "body": "if not self.current_url:<EOL><INDENT>return<EOL><DEDENT>result = urlparse(self.current_url)<EOL>scheme, netloc = result.scheme, result.netloc<EOL>host = netloc.split(\"<STR_LIT::>\")[<NUM_LIT:0>] if netloc else None<EOL>return \"<STR_LIT>\".format(scheme, host) if host else None<EOL>", "docstring": "str: Host of the current page.", "id": "f16683:c0:m6"}
{"signature": "@contextmanager<EOL><INDENT>def dismiss_prompt(self, text=None, wait=None):<DEDENT>", "body": "with self.driver.dismiss_modal(\"<STR_LIT>\", text=text, wait=wait):<EOL><INDENT>yield<EOL><DEDENT>", "docstring": "Execute the wrapped code, dismissing a prompt.\n\nArgs:\n    text (str | RegexObject, optional): Text to match against the text in the modal.\n    wait (int | float, optional): Maximum time to wait for the modal to appear after\n        executing the wrapped code.\n\nRaises:\n    ModalNotFound: If a modal dialog hasn't been found.", "id": "f16683:c0:m31"}
{"signature": "@contextmanager<EOL><INDENT>def window(self, window):<DEDENT>", "body": "original = self.current_window<EOL>if window != original:<EOL><INDENT>self.switch_to_window(window)<EOL><DEDENT>self._scopes.append(None)<EOL>try:<EOL><INDENT>yield<EOL><DEDENT>finally:<EOL><INDENT>self._scopes.pop()<EOL>if original != window:<EOL><INDENT>self.switch_to_window(original)<EOL><DEDENT><DEDENT>", "docstring": "This method does the following:\n\n1. Switches to the given window (it can be located by window instance/lambda/string).\n2. Executes the given block (within window located at previous step).\n3. Switches back (this step will be invoked even if exception happens at second step).\n\nArgs:\n    window (Window | lambda): The desired :class:`Window`, or a lambda that will be run in\n        the context of each open window and returns ``True`` for the desired window.", "id": "f16683:c0:m22"}
{"signature": "@contextmanager<EOL><INDENT>def scope(self, *args, **kwargs):<DEDENT>", "body": "new_scope = args[<NUM_LIT:0>] if isinstance(args[<NUM_LIT:0>], Base) else self.find(*args, **kwargs)<EOL>self._scopes.append(new_scope)<EOL>try:<EOL><INDENT>yield<EOL><DEDENT>finally:<EOL><INDENT>self._scopes.pop()<EOL><DEDENT>", "docstring": "Executes the wrapped code within the context of a node. ``scope`` takes the same options\nas :meth:`find`. For the duration of the context, any command to Capybara will be handled\nas though it were scoped to the given element. ::\n\n    with scope(\"xpath\", \"//div[@id='delivery-address']\"):\n        fill_in(\"Street\", value=\"12 Main Street\")\n\nJust as with :meth:`find`, if multiple elements match the selector given to ``scope``, an\nerror will be raised, and just as with :meth:`find`, this behavior can be controlled\nthrough the ``match`` and ``exact`` options.\n\nIt is possible to omit the first argument, in that case, the selector is assumed to be of\nthe type set in :data:`capybara.default_selector`. ::\n\n    with scope(\"div#delivery-address\"):\n        fill_in(\"Street\", value=\"12 Main Street\")\n\nNote that a lot of uses of ``scope`` can be replaced more succinctly with chaining::\n\n    find(\"div#delivery-address\").fill_in(\"Street\", value=\"12 Main Street\")\n\nArgs:\n    *args: Variable length argument list for the call to :meth:`find`.\n    **kwargs: Arbitrary keywords arguments for the call to :meth:`find`.", "id": "f16683:c0:m12"}
{"signature": "def switch_to_frame(self, frame):", "body": "if isinstance(frame, Element):<EOL><INDENT>self.driver.switch_to_frame(frame)<EOL>self._scopes.append(\"<STR_LIT>\")<EOL><DEDENT>elif frame == \"<STR_LIT>\":<EOL><INDENT>if self._scopes[-<NUM_LIT:1>] != \"<STR_LIT>\":<EOL><INDENT>raise ScopeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>self._scopes.pop()<EOL>self.driver.switch_to_frame(\"<STR_LIT>\")<EOL><DEDENT>elif frame == \"<STR_LIT>\":<EOL><INDENT>if \"<STR_LIT>\" in self._scopes:<EOL><INDENT>idx = self._scopes.index(\"<STR_LIT>\")<EOL>if any([scope not in [\"<STR_LIT>\", None] for scope in self._scopes[idx:]]):<EOL><INDENT>raise ScopeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>self._scopes = self._scopes[:idx]<EOL>self.driver.switch_to_frame(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Switch to the given frame.\n\nIf you use this method you are responsible for making sure you switch back to the parent\nframe when done in the frame changed to. :meth:`frame` is preferred over this method and\nshould be used when possible. May not be supported by all drivers.\n\nArgs:\n    frame (Element | str): The iframe/frame element to switch to.", "id": "f16683:c0:m20"}
{"signature": "@property<EOL><INDENT>def current_path(self):<DEDENT>", "body": "if not self.current_url:<EOL><INDENT>return<EOL><DEDENT>path = urlparse(self.current_url).path<EOL>return path if path else None<EOL>", "docstring": "str: Path of the current page, without any domain information.", "id": "f16683:c0:m5"}
{"signature": "def serialize(tokens):", "body": "ret = []<EOL>for tok in tokens:<EOL><INDENT>if \"<STR_LIT:U+0020>\" in tok:<EOL><INDENT>tok = '<STR_LIT>' % tok<EOL><DEDENT>if \"<STR_LIT:;>\" in tok:<EOL><INDENT>tok = tok.replace(\"<STR_LIT:;>\", \"<STR_LIT>\")<EOL><DEDENT>ret.append(tok)<EOL><DEDENT>return \"<STR_LIT:U+0020>\".join(ret)<EOL>", "docstring": "Serialize tokens:\n* quote whitespace-containing tokens\n* escape semicolons", "id": "f16689:m4"}
{"signature": "def parse_lines(text, ignore_invalid=False):", "body": "json_zone_file = defaultdict(list)<EOL>record_lines = text.split(\"<STR_LIT:\\n>\")<EOL>parser = make_parser()<EOL>for record_line in record_lines:<EOL><INDENT>record_token = tokenize_line(record_line)<EOL>try:<EOL><INDENT>json_zone_file = parse_line(parser, record_token, json_zone_file)<EOL><DEDENT>except InvalidLineException:<EOL><INDENT>if ignore_invalid:<EOL><INDENT>continue<EOL><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT><DEDENT>return json_zone_file<EOL>", "docstring": "Parse a zonefile into a dict.\n@text must be flattened--each record must be on one line.\nAlso, all comments must be removed.", "id": "f16689:m10"}
{"signature": "def remove_class(text):", "body": "<EOL>lines = text.split(\"<STR_LIT:\\n>\")<EOL>ret = []<EOL>for line in lines:<EOL><INDENT>tokens = tokenize_line(line)<EOL>tokens_upper = [t.upper() for t in tokens]<EOL>if \"<STR_LIT>\" in tokens_upper:<EOL><INDENT>tokens.remove(\"<STR_LIT>\")<EOL><DEDENT>elif \"<STR_LIT>\" in tokens_upper:<EOL><INDENT>tokens.remove(\"<STR_LIT>\")<EOL><DEDENT>elif \"<STR_LIT>\" in tokens_upper:<EOL><INDENT>tokens.remove(\"<STR_LIT>\")<EOL><DEDENT>elif \"<STR_LIT>\" in tokens_upper:<EOL><INDENT>tokens.remove(\"<STR_LIT>\")<EOL><DEDENT>ret.append(serialize(tokens))<EOL><DEDENT>return \"<STR_LIT:\\n>\".join(ret)<EOL>", "docstring": "Remove the CLASS from each DNS record, if present.\nThe only class that gets used today (for all intents\nand purposes) is 'IN'.", "id": "f16689:m7"}
{"signature": "def process_cname(data, template):", "body": "return process_rr(data, \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", template)<EOL>", "docstring": "Replace {cname} in template with the serialized CNAME records", "id": "f16692:m8"}
{"signature": "def process_txt(data, template):", "body": "if data is None:<EOL><INDENT>to_process = None<EOL><DEDENT>else:<EOL><INDENT>to_process = copy.deepcopy(data)<EOL>for datum in to_process:<EOL><INDENT>if isinstance(datum[\"<STR_LIT>\"], list):<EOL><INDENT>datum[\"<STR_LIT>\"] = \"<STR_LIT:U+0020>\".join(['<STR_LIT>' % entry.replace(\"<STR_LIT:;>\", \"<STR_LIT>\")<EOL>for entry in datum[\"<STR_LIT>\"]])<EOL><DEDENT>else:<EOL><INDENT>datum[\"<STR_LIT>\"] = '<STR_LIT>' % datum[\"<STR_LIT>\"].replace(\"<STR_LIT:;>\", \"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>return process_rr(to_process, \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", template)<EOL>", "docstring": "Replace {txt} in template with the serialized TXT records", "id": "f16692:m12"}
{"signature": "def process_ns(data, template):", "body": "return process_rr(data, \"<STR_LIT>\", \"<STR_LIT:host>\", \"<STR_LIT>\", template)<EOL>", "docstring": "Replace {ns} in template with the serialized NS records", "id": "f16692:m5"}
{"signature": "def unload_fixture(apps, schema_editor):", "body": "Resource = apps.get_model(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>Resource.objects.all().delete()<EOL>TypeResource = apps.get_model(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>TypeResource.objects.all().delete()<EOL>", "docstring": "Brutally deleting all entries for this model...", "id": "f16711:m1"}
{"signature": "def parse_args_kwargs(parser, token):", "body": "bits = token.contents.split('<STR_LIT:U+0020>')<EOL>if len(bits) <= <NUM_LIT:1>:<EOL><INDENT>raise template.TemplateSyntaxError(\"<STR_LIT>\" % bits[<NUM_LIT:0>])<EOL><DEDENT>if token.contents[<NUM_LIT>] == '<STR_LIT:\">':<EOL><INDENT>end_quote = token.contents.index('<STR_LIT:\">', <NUM_LIT>) + <NUM_LIT:1><EOL>args = [template.Variable(token.contents[<NUM_LIT>:end_quote])]<EOL>kwargs_start = end_quote<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>next_space = token.contents.index('<STR_LIT:U+0020>', <NUM_LIT>)<EOL>kwargs_start = next_space + <NUM_LIT:1><EOL><DEDENT>except ValueError:<EOL><INDENT>next_space = None<EOL>kwargs_start = None<EOL><DEDENT>args = [template.Variable(token.contents[<NUM_LIT>:next_space])]<EOL><DEDENT>kwargs = {}<EOL>kwargs_list = token.contents[kwargs_start:].split('<STR_LIT:U+002C>')<EOL>for kwargs_item in kwargs_list:<EOL><INDENT>if '<STR_LIT:=>' in kwargs_item:<EOL><INDENT>k, v = kwargs_item.split('<STR_LIT:=>', <NUM_LIT:1>)<EOL>k = k.strip()<EOL>kwargs[k] = template.Variable(v)<EOL><DEDENT><DEDENT>return args, kwargs<EOL>", "docstring": "Parse uniformly args and kwargs from a templatetag\n\nUsage::\n\n  For parsing a template like this:\n\n  {% footag my_contents,height=10,zoom=20 as myvar %}\n\n  You simply do this:\n\n  @register.tag\n  def footag(parser, token):\n      args, kwargs = parse_args_kwargs(parser, token)", "id": "f16723:m0"}
{"signature": "def prepare_context(self, args, kwargs, context):", "body": "return context<EOL>", "docstring": "Hook for overriding in subclasses.\n\nNote that \"args\" and \"kwargs\" parameters are already resolved with context", "id": "f16723:c0:m1"}
{"signature": "def get_admin_static_url():", "body": "return getattr(settings, '<STR_LIT>', get_static_url() + \"<STR_LIT>\")<EOL>", "docstring": "Return the ADMIN_MEDIA_PREFIX if it is in the settings.py else get\nthe static url from the previous function and add /admin/.", "id": "f16730:m5"}
{"signature": "def get_dict_from_obj(obj):", "body": "obj_dict = obj.__dict__<EOL>obj_dict_result = obj_dict.copy()<EOL>for key, value in obj_dict.items():<EOL><INDENT>if key.endswith('<STR_LIT>'):<EOL><INDENT>key2 = key.replace('<STR_LIT>', '<STR_LIT>')<EOL>try:<EOL><INDENT>field, model, direct, m2m = obj._meta.get_field_by_name(key2)<EOL>if isinstance(field, ForeignKey):<EOL><INDENT>obj_dict_result[key2] = obj_dict_result[key]<EOL>del obj_dict_result[key]<EOL><DEDENT><DEDENT>except FieldDoesNotExist:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>manytomany_list = obj._meta.many_to_many<EOL>for manytomany in manytomany_list:<EOL><INDENT>pks = [obj_rel.pk for obj_rel in manytomany.value_from_object(obj).select_related()]<EOL>if pks:<EOL><INDENT>obj_dict_result[manytomany.name] = pks<EOL><DEDENT><DEDENT>return obj_dict_result<EOL>", "docstring": "Edit to get the dict even when the object is a GenericRelatedObjectManager.\nAdded the try except.", "id": "f16730:m0"}
{"signature": "def remove_whitespace(sentences):", "body": "return [[w.rstrip() for w in sent] for sent in sentences]<EOL>", "docstring": "Clear out spaces and newlines\nfrom the list of list of strings.\n\nArguments:\n----------\n    sentences : list<list<str>>\n\nReturns:\n--------\n    list<list<str>> : same strings as input,\n        without spaces or newlines.", "id": "f16733:m2"}
{"signature": "def protect_shorthand(text, split_locations):", "body": "word_matches = list(re.finditer(word_with_period, text))<EOL>total_words = len(word_matches)<EOL>for i, match in enumerate(word_matches):<EOL><INDENT>match_start = match.start()<EOL>match_end = match.end()<EOL>for char_pos in range(match_start, match_end):<EOL><INDENT>if split_locations[char_pos] == SHOULD_SPLIT and match_end - char_pos > <NUM_LIT:1>:<EOL><INDENT>match_start = char_pos<EOL><DEDENT><DEDENT>word = text[match_start:match_end]<EOL>if not word.endswith('<STR_LIT:.>'):<EOL><INDENT>if (not word[<NUM_LIT:0>].isdigit() and<EOL>split_locations[match_start] == UNDECIDED):<EOL><INDENT>split_locations[match_start] = SHOULD_SPLIT<EOL><DEDENT>continue<EOL><DEDENT>period_pos = match_end - <NUM_LIT:1><EOL>word_is_in_abbr = word[:-<NUM_LIT:1>].lower() in ABBR<EOL>is_abbr_like = (<EOL>word_is_in_abbr or<EOL>one_letter_long_or_repeating.match(word[:-<NUM_LIT:1>]) is not None<EOL>)<EOL>is_digit = False if is_abbr_like else word[:-<NUM_LIT:1>].isdigit()<EOL>is_last_word = i == (total_words - <NUM_LIT:1>)<EOL>is_ending = is_last_word and (match_end == len(text) or text[match_end:].isspace())<EOL>is_not_ending = not is_ending<EOL>abbreviation_and_not_end = (<EOL>len(word) > <NUM_LIT:1> and<EOL>is_abbr_like and<EOL>is_not_ending<EOL>)<EOL>if abbreviation_and_not_end and (<EOL>(not is_last_word and word_matches[i+<NUM_LIT:1>].group(<NUM_LIT:0>)[<NUM_LIT:0>].islower()) or<EOL>(not is_last_word and word_matches[i+<NUM_LIT:1>].group(<NUM_LIT:0>) in PUNCT_SYMBOLS) or<EOL>word[<NUM_LIT:0>].isupper() or<EOL>word_is_in_abbr or<EOL>len(word) == <NUM_LIT:2>):<EOL><INDENT>if split_locations[period_pos] == SHOULD_SPLIT and period_pos + <NUM_LIT:1> < len(split_locations):<EOL><INDENT>split_locations[period_pos + <NUM_LIT:1>] = SHOULD_SPLIT<EOL><DEDENT>split_locations[period_pos] = SHOULD_NOT_SPLIT<EOL><DEDENT>elif (is_digit and<EOL>len(word[:-<NUM_LIT:1>]) <= <NUM_LIT:2> and<EOL>not is_last_word and<EOL>word_matches[i+<NUM_LIT:1>].group(<NUM_LIT:0>).lower() in MONTHS):<EOL><INDENT>if split_locations[period_pos] == SHOULD_SPLIT and period_pos + <NUM_LIT:1> < len(split_locations):<EOL><INDENT>split_locations[period_pos + <NUM_LIT:1>] = SHOULD_SPLIT<EOL><DEDENT>split_locations[period_pos] = SHOULD_NOT_SPLIT<EOL><DEDENT>elif split_locations[period_pos] == UNDECIDED:<EOL><INDENT>split_locations[period_pos] = SHOULD_SPLIT<EOL><DEDENT><DEDENT>", "docstring": "Annotate locations in a string that contain\nperiods as being true periods or periods\nthat are a part of shorthand (and thus should\nnot be treated as punctuation marks).\n\nArguments:\n----------\n    text : str\n    split_locations : list<int>, same length as text.", "id": "f16736:m0"}
{"signature": "def mark_begin_end_regex(regex, text, split_locations):", "body": "for match in regex.finditer(text):<EOL><INDENT>end_match = match.end()<EOL>begin_match = match.start()<EOL>for i in range(begin_match+<NUM_LIT:1>, end_match):<EOL><INDENT>split_locations[i] = SHOULD_NOT_SPLIT<EOL><DEDENT>if end_match < len(split_locations):<EOL><INDENT>if split_locations[end_match] == UNDECIDED:<EOL><INDENT>split_locations[end_match] = SHOULD_SPLIT<EOL><DEDENT><DEDENT>if split_locations[begin_match] == UNDECIDED:<EOL><INDENT>split_locations[begin_match] = SHOULD_SPLIT<EOL><DEDENT><DEDENT>", "docstring": "Regex that adds a 'SHOULD_SPLIT' marker at the end\nlocation of each matching group of the given regex,\nand adds a 'SHOULD_SPLIT' at the beginning of the\nmatching group. Each character within the matching\ngroup will be marked as 'SHOULD_NOT_SPLIT'.\n\nArguments\n---------\n    regex : re.Expression\n    text : str, same length as split_locations\n    split_locations : list<int>, split decisions.", "id": "f16736:m3"}
{"signature": "@log_calls<EOL><INDENT>def delete(self, source):<DEDENT>", "body": "s3url = S3URL(source)<EOL>message('<STR_LIT>', source)<EOL>if not self.opt.dry_run:<EOL><INDENT>self.s3.delete_object(Bucket=s3url.bucket, Key=s3url.path)<EOL><DEDENT>", "docstring": "Thread worker for download operation.", "id": "f16741:c10:m15"}
{"signature": "@log_calls<EOL><INDENT>def batch_delete(self, sources):<DEDENT>", "body": "assert(type(sources) == list)<EOL>if len(sources) == <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>elif len(sources) == <NUM_LIT:1>:<EOL><INDENT>self.delete(sources[<NUM_LIT:0>])<EOL><DEDENT>elif len(sources) > self.opt.batch_delete_size:<EOL><INDENT>for i in range(<NUM_LIT:0>, len(sources), self.opt.batch_delete_size):<EOL><INDENT>self.pool.batch_delete(sources[i:i+self.opt.batch_delete_size])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>bucket = S3URL(sources[<NUM_LIT:0>]).bucket<EOL>deletes = []<EOL>for source in sources:<EOL><INDENT>s3url = S3URL(source)<EOL>if s3url.bucket != bucket:<EOL><INDENT>raise Failure('<STR_LIT>' % (s3url.bucket, bucket))<EOL><DEDENT>deletes.append({'<STR_LIT>': s3url.path})<EOL><DEDENT>response = self.s3.delete_objects(Bucket=bucket, Delete={'<STR_LIT>': deletes})<EOL>for res in response.get('<STR_LIT>') or []:<EOL><INDENT>message('<STR_LIT>', S3URL.combine('<STR_LIT>', bucket, res['<STR_LIT>']))<EOL><DEDENT>for err in response.get('<STR_LIT>') or []:<EOL><INDENT>message('<STR_LIT>', S3URL.combine('<STR_LIT>', bucket, res['<STR_LIT>']), err['<STR_LIT>'], err['<STR_LIT>'])<EOL><DEDENT>if response.get('<STR_LIT>') is not None:<EOL><INDENT>raise RetryFailure('<STR_LIT>' % len(response.get('<STR_LIT>')))<EOL><DEDENT><DEDENT>", "docstring": "Delete a list of files in batch of batch_delete_size (default=1000).", "id": "f16741:c10:m16"}
{"signature": "@log_calls<EOL><INDENT>def lookup(self, s3url):<DEDENT>", "body": "try:<EOL><INDENT>return self.s3.head_object(Bucket=s3url.bucket, Key=s3url.path)<EOL><DEDENT>except BotoClient.ClientError as e:<EOL><INDENT>if e.response['<STR_LIT>']['<STR_LIT>'] == <NUM_LIT>:<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>raise e<EOL><DEDENT><DEDENT>", "docstring": "Get the s3 object with the S3 URL. Return None if not exist.", "id": "f16741:c10:m8"}
{"signature": "def __init__(self, filename):", "body": "self.filename = filename<EOL>self.md5 = None<EOL>", "docstring": "Initialize md5 cache object.", "id": "f16741:c9:m0"}
{"signature": "@log_calls<EOL><INDENT>def get_files(self, source, target):<DEDENT>", "body": "pool = ThreadPool(ThreadUtil, self.opt)<EOL>source = self.source_expand(source)<EOL>if os.path.isdir(target):<EOL><INDENT>for src in source:<EOL><INDENT>self.get_single_file(pool, src, os.path.join(target, self.get_basename(S3URL(src).path)))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if len(source) > <NUM_LIT:1>:<EOL><INDENT>raise Failure('<STR_LIT>' % target)<EOL><DEDENT>elif len(source) == <NUM_LIT:1>:<EOL><INDENT>self.get_single_file(pool, source[<NUM_LIT:0>], target)<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>pool.join()<EOL>", "docstring": "Download files.\n           This function can handle multiple files if source S3 URL has wildcard\n           characters. It also handles recursive mode by download all files and\n           keep the directory structure.", "id": "f16741:c8:m18"}
{"signature": "def __str__(self):", "body": "return S3URL.combine(self.proto, self.bucket, self.path)<EOL>", "docstring": "Return the original S3 URL", "id": "f16741:c4:m1"}
{"signature": "@log_calls<EOL><INDENT>def get_basename(self, path):<DEDENT>", "body": "if path[-<NUM_LIT:1>] == PATH_SEP:<EOL><INDENT>path = path[<NUM_LIT:0>:-<NUM_LIT:1>]<EOL><DEDENT>return os.path.basename(path)<EOL>", "docstring": "Unix style basename.\n           This fuction will return 'bar' for '/foo/bar/' instead of empty string.\n           It is used to normalize the input trailing slash.", "id": "f16741:c8:m10"}
{"signature": "@log_calls<EOL><INDENT>def write_file_chunk(self, target, pos, chunk, body):<DEDENT>", "body": "fd = os.open(target, os.O_CREAT | os.O_WRONLY)<EOL>try:<EOL><INDENT>os.lseek(fd, pos, os.SEEK_SET)<EOL>data = body.read(chunk)<EOL>num_bytes_written = os.write(fd, data)<EOL>if(num_bytes_written != len(data)):<EOL><INDENT>raise RetryFailure('<STR_LIT>' % (num_bytes_written, sys.getsizeof(data)))<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>os.close(fd)<EOL><DEDENT>", "docstring": "Write local file chunk", "id": "f16741:c10:m12"}
{"signature": "@log_calls<EOL><INDENT>def relative_dir_walk(self, dir):<DEDENT>", "body": "result = []<EOL>if S3URL.is_valid(dir):<EOL><INDENT>basepath = S3URL(dir).path<EOL>for f in (f for f in self.s3walk(dir) if not f['<STR_LIT>']):<EOL><INDENT>result.append(os.path.relpath(S3URL(f['<STR_LIT:name>']).path, basepath))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for f in (f for f in self.local_walk(dir) if not os.path.isdir(f)):<EOL><INDENT>result.append(os.path.relpath(f, dir))<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Generic version of directory walk. Return file list without base path\n           for comparison.", "id": "f16741:c8:m23"}
{"signature": "@log_calls<EOL><INDENT>def ls_handler(self, args):<DEDENT>", "body": "if len(args) == <NUM_LIT:1>:<EOL><INDENT>self.pretty_print(self.s3handler().list_buckets())<EOL>return<EOL><DEDENT>self.validate('<STR_LIT>', args)<EOL>self.pretty_print(self.s3handler().s3walk(args[<NUM_LIT:1>]))<EOL>", "docstring": "Handler for ls command", "id": "f16741:c11:m5"}
{"signature": "def merge_opt_params(self, method, kargs):", "body": "for key in self.legal_params[method]:<EOL><INDENT>if not hasattr(self.opt, key) or getattr(self.opt, key) is None:<EOL><INDENT>continue<EOL><DEDENT>if key in kargs and type(kargs[key]) == dict:<EOL><INDENT>assert(type(getattr(self.opt, key)) == dict)<EOL>for k, v in getattr(self.opt, key).iteritems():<EOL><INDENT>kargs[key][k] = v<EOL><DEDENT><DEDENT>else:<EOL><INDENT>kargs[key] = getattr(self.opt, key)<EOL><DEDENT><DEDENT>return kargs<EOL>", "docstring": "Combine existing parameters with extra options supplied from command line\n           options. Carefully merge special type of parameter if needed.", "id": "f16741:c5:m3"}
{"signature": "@log_calls<EOL><INDENT>def download(self, source, target, mpi=None, pos=<NUM_LIT:0>, chunk=<NUM_LIT:0>, part=<NUM_LIT:0>):<DEDENT>", "body": "s3url = S3URL(source)<EOL>obj = self.lookup(s3url)<EOL>if obj is None:<EOL><INDENT>raise Failure('<STR_LIT>' % (s3url.path,))<EOL><DEDENT>if not mpi:<EOL><INDENT>if self.opt.dry_run:<EOL><INDENT>message('<STR_LIT>', source, target)<EOL>return<EOL><DEDENT>elif self.opt.sync_check and self.sync_check(LocalMD5Cache(target), obj):<EOL><INDENT>message('<STR_LIT>', source, target)<EOL>return<EOL><DEDENT>elif not self.opt.force and os.path.exists(target):<EOL><INDENT>raise Failure('<STR_LIT>' % target)<EOL><DEDENT>fsize = int(obj['<STR_LIT>'])<EOL>if fsize < self.opt.max_singlepart_download_size:<EOL><INDENT>mpi = ThreadUtil.MultipartItem(tempfile_get(target))<EOL>mpi.total = <NUM_LIT:1><EOL>pos = <NUM_LIT:0><EOL>chunk = fsize<EOL><DEDENT>else:<EOL><INDENT>for args in self.get_file_splits(tempfile_get(target), source, target, fsize, self.opt.multipart_split_size):<EOL><INDENT>self.pool.download(*args)<EOL><DEDENT>return<EOL><DEDENT><DEDENT>tempfile = mpi.id<EOL>if self.opt.recursive:<EOL><INDENT>self.mkdirs(tempfile)<EOL><DEDENT>response = self.s3.get_object(Bucket=s3url.bucket, Key=s3url.path, Range='<STR_LIT>' % (pos, pos + chunk - <NUM_LIT:1>))<EOL>self.write_file_chunk(tempfile, pos, chunk, response['<STR_LIT>'])<EOL>if mpi.complete({'<STR_LIT>': part}):<EOL><INDENT>try:<EOL><INDENT>self.update_privilege(obj, tempfile)<EOL>self._verify_file_size(obj, tempfile)<EOL>tempfile_set(tempfile, target)<EOL>message('<STR_LIT>', source, target)<EOL><DEDENT>except Exception as e:<EOL><INDENT>tempfile_set(tempfile, None)<EOL>raise Failure('<STR_LIT>' % (e.message, source))<EOL><DEDENT><DEDENT>", "docstring": "Thread worker for download operation.", "id": "f16741:c10:m13"}
{"signature": "@log_calls<EOL><INDENT>def create_bucket(self, source):<DEDENT>", "body": "s3url = S3URL(source)<EOL>message('<STR_LIT>', source)<EOL>if not self.opt.dry_run:<EOL><INDENT>resp = self.s3.create_bucket(Bucket=s3url.bucket)<EOL>if resp['<STR_LIT>'][\"<STR_LIT>\"] == <NUM_LIT:200>:<EOL><INDENT>message('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>raise Failure('<STR_LIT>' % source)<EOL><DEDENT><DEDENT>", "docstring": "Use the create_bucket API to create a new bucket", "id": "f16741:c8:m14"}
{"signature": "def __init__(self, opt):", "body": "self.opt = opt<EOL>", "docstring": "Constructor", "id": "f16741:c11:m0"}
{"signature": "@log_calls<EOL><INDENT>def _verify_file_size(self, obj, downloaded_file):<DEDENT>", "body": "file_size = os.path.getsize(downloaded_file)<EOL>if int(obj['<STR_LIT>']) != file_size:<EOL><INDENT>raise RetryFailure('<STR_LIT>' % (repr(obj)))<EOL><DEDENT>", "docstring": "Verify the file size of the downloaded file.", "id": "f16741:c10:m11"}
{"signature": "@log_calls<EOL><INDENT>def local_walk(self, basedir):<DEDENT>", "body": "result = []<EOL>for root, dirs, files in os.walk(basedir):<EOL><INDENT>for f in files:<EOL><INDENT>result.append(os.path.join(root, f))<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Walk through local directories from root basedir", "id": "f16741:c8:m9"}
{"signature": "def synchronized(func):", "body": "func.__lock__ = threading.Lock()<EOL>def synced_func(*args, **kargs):<EOL><INDENT>with func.__lock__:<EOL><INDENT>return func(*args, **kargs)<EOL><DEDENT><DEDENT>return synced_func<EOL>", "docstring": "Decorator to synchronize function.", "id": "f16741:m2"}
{"signature": "@log_calls<EOL><INDENT>def get_handler(self, args):<DEDENT>", "body": "<EOL>if len(args) == <NUM_LIT:2>:<EOL><INDENT>args += ['<STR_LIT:.>']<EOL><DEDENT>self.validate('<STR_LIT>', args)<EOL>source = args[<NUM_LIT:1>]<EOL>target = args[<NUM_LIT:2>]<EOL>self.s3handler().get_files(source, target)<EOL>", "docstring": "Handler for get command", "id": "f16741:c11:m8"}
{"signature": "@synchronized<EOL>def progress(msg, *args):", "body": "<EOL>if not (sys.stdout.isatty() and sys.stderr.isatty()):<EOL><INDENT>return<EOL><DEDENT>text = (msg % args)<EOL>if progress.prev_message:<EOL><INDENT>sys.stderr.write('<STR_LIT:U+0020>' * len(progress.prev_message) + '<STR_LIT:\\r>')<EOL><DEDENT>sys.stderr.write(text + '<STR_LIT:\\r>')<EOL>progress.prev_message = text<EOL>", "docstring": "Show current progress message to stderr.\n       This function will remember the previous message so that next time,\n       it will clear the previous message before showing next one.", "id": "f16741:m4"}
{"signature": "@log_calls<EOL><INDENT>def sync_files(self, source, target):<DEDENT>", "body": "src_s3_url = S3URL.is_valid(source)<EOL>dst_s3_url = S3URL.is_valid(target)<EOL>if src_s3_url and not dst_s3_url:<EOL><INDENT>self.get_files(source, target)<EOL><DEDENT>elif not src_s3_url and dst_s3_url:<EOL><INDENT>self.put_files(source, target)<EOL>if self.opt.delete_removed:<EOL><INDENT>self.delete_removed_files(source, target)<EOL><DEDENT><DEDENT>elif src_s3_url and dst_s3_url:<EOL><INDENT>self.cp_files(source, target)<EOL><DEDENT>else:<EOL><INDENT>raise InvalidArgument('<STR_LIT>')<EOL><DEDENT>", "docstring": "Sync files to S3. Does implement deletions if syncing TO s3.\n           Currently identical to get/put -r -f --sync-check with exception of deletions.", "id": "f16741:c8:m25"}
{"signature": "def match_time(self, value):", "body": "m = self.REGEX_TIME.search(value)<EOL>time = datetime.datetime.utcnow().time()<EOL>if m:<EOL><INDENT>time = datetime.time(int(m.group(<NUM_LIT:1>)), int(m.group(<NUM_LIT:2>)))<EOL>value = self.REGEX_TIME.sub('<STR_LIT>', value)<EOL><DEDENT>return (time, value)<EOL>", "docstring": "Search for time information in the string", "id": "f16741:c12:m1"}
{"signature": "@log_calls<EOL><INDENT>def del_handler(self, args):<DEDENT>", "body": "self.validate('<STR_LIT>', args)<EOL>source = args[<NUM_LIT:1>]<EOL>self.s3handler().del_files(source)<EOL>", "docstring": "Handler for del command", "id": "f16741:c11:m14"}
{"signature": "@log_calls<EOL><INDENT>def cat_handler(self, args):<DEDENT>", "body": "self.validate('<STR_LIT>', args)<EOL>source = args[<NUM_LIT:1>]<EOL>self.s3handler().print_files(source)<EOL>", "docstring": "Handler for cat command", "id": "f16741:c11:m9"}
{"signature": "def __init__(self, thread_class, opt):", "body": "self.opt = opt<EOL>self.tasks = TaskQueue()<EOL>self.processed_tasks = <NUM_LIT:0><EOL>self.thread_class = thread_class<EOL>self.workers = []<EOL>for i in range(opt.num_threads):<EOL><INDENT>self.workers.append(thread_class(self))<EOL><DEDENT>", "docstring": "Constructor of ThreadPool.\n           Create workers and pool will automatically inherit all methods from\n           thread_class by redirecting calls through __getattribute__().", "id": "f16741:c7:m0"}
{"signature": "@staticmethod<EOL><INDENT>def combine(proto, bucket, path):<DEDENT>", "body": "return '<STR_LIT>' % (proto, bucket, path)<EOL>", "docstring": "Combine each component and general a S3 url string, no path normalization\n           here. The path should not start with slash.", "id": "f16741:c4:m3"}
{"signature": "def __init__(self, opt):", "body": "self.s3 = None<EOL>self.opt = opt<EOL>self.connect()<EOL>", "docstring": "Constructor, connect to S3 store", "id": "f16741:c8:m4"}
{"signature": "def conditional(self, result, obj):", "body": "fileonly = (self.opt.last_modified_before is not None) or (self.opt.last_modified_after is not None)<EOL>if obj['<STR_LIT>']:<EOL><INDENT>if not fileonly:<EOL><INDENT>result.append(obj)<EOL><DEDENT>return<EOL><DEDENT>if (self.opt.last_modified_before is not None) and obj['<STR_LIT>'] >= self.opt.last_modified_before:<EOL><INDENT>return<EOL><DEDENT>if (self.opt.last_modified_after is not None) and obj['<STR_LIT>'] <= self.opt.last_modified_after:<EOL><INDENT>return<EOL><DEDENT>result.append(obj)<EOL>", "docstring": "Check all file item with given conditions.", "id": "f16741:c10:m5"}
{"signature": "@log_calls<EOL><INDENT>def pretty_print(self, objlist):<DEDENT>", "body": "def normalize_time(timestamp):<EOL><INDENT>'''<STR_LIT>'''<EOL>if timestamp is None:<EOL><INDENT>return '<STR_LIT:U+0020>' * <NUM_LIT:16><EOL><DEDENT>return TIMESTAMP_FORMAT % (timestamp.year, timestamp.month, timestamp.day, timestamp.hour, timestamp.minute)<EOL><DEDENT>cwidth = [<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>]<EOL>format = '<STR_LIT>'<EOL>result = []<EOL>for obj in objlist:<EOL><INDENT>last_modified = normalize_time(obj['<STR_LIT>'])<EOL>size = str(obj['<STR_LIT:size>']) if not obj['<STR_LIT>'] else '<STR_LIT>'<EOL>name = obj['<STR_LIT:name>']<EOL>item = (last_modified, size, name)<EOL>for i, value in enumerate(item):<EOL><INDENT>if cwidth[i] < len(value):<EOL><INDENT>cwidth[i] = len(value)<EOL><DEDENT><DEDENT>result.append(item)<EOL><DEDENT>for item in result:<EOL><INDENT>text = (format % tuple(cwidth)) % item<EOL>message('<STR_LIT:%s>', text.rstrip())<EOL><DEDENT>", "docstring": "Pretty print the result of s3walk. Here we calculate the maximum width\n           of each column and align them.", "id": "f16741:c11:m4"}
{"signature": "@log_calls<EOL><INDENT>def dsync_files(self, source, target):<DEDENT>", "body": "src_s3_url = S3URL.is_valid(source)<EOL>dst_s3_url = S3URL.is_valid(target)<EOL>source_list = self.relative_dir_walk(source)<EOL>if len(source_list) == <NUM_LIT:0> or '<STR_LIT:.>' in source_list:<EOL><INDENT>raise Failure('<STR_LIT>')<EOL><DEDENT>sync_list = [(os.path.join(source, f), os.path.join(target, f)) for f in source_list]<EOL>pool = ThreadPool(ThreadUtil, self.opt)<EOL>if src_s3_url and not dst_s3_url:<EOL><INDENT>for src, dest in sync_list:<EOL><INDENT>pool.download(src, dest)<EOL><DEDENT><DEDENT>elif not src_s3_url and dst_s3_url:<EOL><INDENT>for src, dest in sync_list:<EOL><INDENT>pool.upload(src, dest)<EOL><DEDENT><DEDENT>elif src_s3_url and dst_s3_url:<EOL><INDENT>for src, dest in sync_list:<EOL><INDENT>pool.copy(src, dest)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise InvalidArgument('<STR_LIT>')<EOL><DEDENT>pool.join()<EOL>if self.opt.delete_removed:<EOL><INDENT>target_list = self.relative_dir_walk(target)<EOL>remove_list = [os.path.join(target, f) for f in (set(target_list) - set(source_list))]<EOL>if S3URL.is_valid(target):<EOL><INDENT>pool = ThreadPool(ThreadUtil, self.opt)<EOL>pool.batch_delete(remove_list)<EOL>pool.join()<EOL><DEDENT>else:<EOL><INDENT>for f in remove_list:<EOL><INDENT>try:<EOL><INDENT>os.unlink(f)<EOL>message('<STR_LIT>', f)<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Sync directory to directory.", "id": "f16741:c8:m24"}
{"signature": "@log_calls<EOL><INDENT>def cp_single_file(self, pool, source, target, delete_source):<DEDENT>", "body": "if source[-<NUM_LIT:1>] == PATH_SEP:<EOL><INDENT>if self.opt.recursive:<EOL><INDENT>basepath = S3URL(source).path<EOL>for f in (f for f in self.s3walk(source) if not f['<STR_LIT>']):<EOL><INDENT>pool.copy(f['<STR_LIT:name>'], os.path.join(target, os.path.relpath(S3URL(f['<STR_LIT:name>']).path, basepath)), delete_source=delete_source)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>message('<STR_LIT>' % source)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>pool.copy(source, target, delete_source=delete_source)<EOL><DEDENT>", "docstring": "Copy a single file or a directory by adding a task into queue", "id": "f16741:c8:m20"}
{"signature": "@log_calls<EOL><INDENT>def delete_removed_files(self, source, target):<DEDENT>", "body": "message(\"<STR_LIT>\", source, target)<EOL>if os.path.isdir(source):<EOL><INDENT>unecessary = []<EOL>basepath = S3URL(target).path<EOL>for f in [f for f in self.s3walk(target) if not f['<STR_LIT>']]:<EOL><INDENT>local_name = os.path.join(source, os.path.relpath(S3URL(f['<STR_LIT:name>']).path, basepath))<EOL>if not os.path.isfile(local_name):<EOL><INDENT>message(\"<STR_LIT>\", local_name)<EOL>unecessary.append(f['<STR_LIT:name>'])<EOL><DEDENT><DEDENT>if len(unecessary) > <NUM_LIT:0>:<EOL><INDENT>pool = ThreadPool(ThreadUtil, self.opt)<EOL>for del_file in unecessary:<EOL><INDENT>pool.delete(del_file)<EOL><DEDENT>pool.join()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise Failure('<STR_LIT>' % target)<EOL><DEDENT>", "docstring": "Remove remote files that are not present in the local source.\n           (Obsolete) It is used for old sync command now.", "id": "f16741:c8:m19"}
{"signature": "@log_calls<EOL><INDENT>def read_file_chunk(self, source, pos, chunk):<DEDENT>", "body": "if chunk==<NUM_LIT:0>:<EOL><INDENT>return StringIO()<EOL><DEDENT>data = None<EOL>with open(source, '<STR_LIT:rb>') as f:<EOL><INDENT>f.seek(pos)<EOL>data = f.read(chunk)<EOL><DEDENT>if not data:<EOL><INDENT>raise Failure('<STR_LIT>' % source)<EOL><DEDENT>return StringIO(data)<EOL>", "docstring": "Read local file chunk", "id": "f16741:c10:m9"}
{"signature": "@log_calls<EOL><INDENT>def sync_check(self, md5cache, remoteKey):<DEDENT>", "body": "if not remoteKey:<EOL><INDENT>return False<EOL><DEDENT>if not os.path.exists(md5cache.filename):<EOL><INDENT>return False<EOL><DEDENT>localmd5 = md5cache.get_md5()<EOL>return ('<STR_LIT>' in remoteKey and remoteKey['<STR_LIT>'] == '<STR_LIT>' % localmd5) or('<STR_LIT>' in remoteKey and remoteKey['<STR_LIT>'] == localmd5) or('<STR_LIT>' in remoteKey['<STR_LIT>'] and remoteKey['<STR_LIT>']['<STR_LIT>'] == localmd5)<EOL>", "docstring": "Check MD5 for a local file and a remote file.\n           Return True if they have the same md5 hash, otherwise False.", "id": "f16741:c10:m2"}
{"signature": "def Parse(self,song_name,website):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "It will search for \"song_name website\"  in the Search Engine results \nand return the url of website", "id": "f16749:c0:m0"}
{"signature": "def file_download_using_requests(self,url):", "body": "file_name=url.split('<STR_LIT:/>')[-<NUM_LIT:1>]<EOL>if os.path.exists(os.path.join(os.getcwd(),file_name)):<EOL><INDENT>print('<STR_LIT>')<EOL>return<EOL><DEDENT>try:<EOL><INDENT>r=requests.get(url,stream=True,timeout=<NUM_LIT:200>)<EOL><DEDENT>except requests.exceptions.SSLError:<EOL><INDENT>try:<EOL><INDENT>response=requests.get(url,stream=True,verify=False,timeout=<NUM_LIT:200>)<EOL><DEDENT>except requests.exceptions.RequestException as e:<EOL><INDENT>print(e)<EOL>quit()  <EOL><DEDENT><DEDENT>except requests.exceptions.RequestException as e:<EOL><INDENT>print(e)<EOL>quit() <EOL><DEDENT>chunk_size = <NUM_LIT><EOL>total_size = int(r.headers['<STR_LIT>'])<EOL>total_chunks = total_size/chunk_size<EOL>file_iterable = r.iter_content(chunk_size = chunk_size)<EOL>tqdm_iter = tqdm(iterable = file_iterable,total = total_chunks,unit = '<STR_LIT>',<EOL>leave = False<EOL>)  <EOL>with open(file_name,'<STR_LIT:wb>') as f:<EOL><INDENT>for data in tqdm_iter:<EOL><INDENT>f.write(data)<EOL><DEDENT><DEDENT>'''<STR_LIT>'''<EOL>print('<STR_LIT>'%file_name)<EOL>", "docstring": "It will download file specified by url using requests module", "id": "f16755:c0:m1"}
{"signature": "def _spark_predict(self, cls, X, *args, **kwargs):", "body": "return X.map(lambda X: super(cls, self).predict(X, *args, **kwargs))<EOL>", "docstring": "Wraps a Scikit-learn Linear model's predict method to use with RDD\n        input.\n\n        Parameters\n        ----------\n        cls : class object\n            The sklearn linear model's class to wrap.\n        Z : ArrayRDD\n            The distributed data to predict in a DictRDD.\n\n        Returns\n        -------\n        self: the wrapped class", "id": "f16764:c0:m4"}
{"signature": "def __radd__(self, other):", "body": "return self if other == <NUM_LIT:0> else self.__add__(other)<EOL>", "docstring": "Reverse add method for Linear models.\n\n        Parameters\n        ----------\n        other : fitted sklearn linear model\n            Model to add.\n\n        Returns\n        -------\n        model : Linear model\n            Model with updated coefficients.", "id": "f16764:c0:m1"}
{"signature": "def __div__(self, other):", "body": "self.coef_ /= other<EOL>self.intercept_ /= other<EOL>return self<EOL>", "docstring": "Division method for Linear models. Used for averaging.\n\n        Parameters\n        ----------\n        other : integer\n            Integer to divide with.\n\n        Returns\n        -------\n        model : Linear model\n            Model with updated coefficients.", "id": "f16764:c0:m2"}
{"signature": "def __add__(self, other):", "body": "model = copy.deepcopy(self)<EOL>model.coef_ += other.coef_<EOL>model.intercept_ += other.intercept_<EOL>return model<EOL>", "docstring": "Add method for Linear models with coef and intercept attributes.\n\n        Parameters\n        ----------\n        other : fitted sklearn linear model\n            Model to add.\n\n        Returns\n        -------\n        model : Linear model\n            Model with updated coefficients.", "id": "f16764:c0:m0"}
{"signature": "def _spark_fit(self, cls, Z, *args, **kwargs):", "body": "mapper = lambda X_y: super(cls, self).fit(<EOL>X_y[<NUM_LIT:0>], X_y[<NUM_LIT:1>], *args, **kwargs<EOL>)<EOL>models = Z.map(mapper)<EOL>avg = models.reduce(operator.add) / models.count()<EOL>self.__dict__.update(avg.__dict__)<EOL>return self<EOL>", "docstring": "Wraps a Scikit-learn Linear model's fit method to use with RDD\n        input.\n\n        Parameters\n        ----------\n        cls : class object\n            The sklearn linear model's class to wrap.\n        Z : TupleRDD or DictRDD\n            The distributed train data in a DictRDD.\n\n        Returns\n        -------\n        self: the wrapped class", "id": "f16764:c0:m3"}
{"signature": "def predict(self, X):", "body": "check_rdd(X, (sp.spmatrix, np.ndarray))<EOL>return self._spark_predict(SparkSGDClassifier, X)<EOL>", "docstring": "Distributed method to predict class labels for samples in X.\n\n        Parameters\n        ----------\n        X : ArrayRDD containing {array-like, sparse matrix}\n            Samples.\n\n        Returns\n        -------\n        C : ArrayRDD\n            Predicted class label per sample.", "id": "f16766:c0:m4"}
{"signature": "def fit(self, Z, classes=None):", "body": "check_rdd(Z, {'<STR_LIT:X>': (sp.spmatrix, np.ndarray)})<EOL>self._classes_ = np.unique(classes)<EOL>return self._spark_fit(SparkLogisticRegression, Z)<EOL>", "docstring": "Fit the model according to the given training data.\n\n        Parameters\n        ----------\n        Z : DictRDD containing (X, y) pairs\n            X - Training vector\n            y - Target labels\n        classes : iterable\n            The set of available classes\n\n        Returns\n        -------\n        self : object\n            Returns self.", "id": "f16767:c0:m2"}
{"signature": "def svd(blocked_rdd, k):", "body": "<EOL>c = blocked_rdd.map(lambda x: (x.T.dot(x), x.shape[<NUM_LIT:0>]))<EOL>prod, n = c.reduce(lambda x, y: (x[<NUM_LIT:0>] + y[<NUM_LIT:0>], x[<NUM_LIT:1>] + y[<NUM_LIT:1>]))<EOL>w, v = ln.eig(prod / n)<EOL>w = np.real(w)<EOL>v = np.real(v)<EOL>inds = np.argsort(w)[::-<NUM_LIT:1>]<EOL>s = np.sqrt(w[inds[<NUM_LIT:0>:k]]) * np.sqrt(n)<EOL>v = v[:, inds[<NUM_LIT:0>:k]].T<EOL>u = blocked_rdd.map(lambda x: np.inner(x, v) / s)<EOL>return u, s, v<EOL>", "docstring": "Calculate the SVD of a blocked RDD directly, returning only the leading k\nsingular vectors. Assumes n rows and d columns, efficient when n >> d\nMust be able to fit d^2 within the memory of a single machine.\nParameters\n----------\nblocked_rdd : RDD\n    RDD with data points in numpy array blocks\nk : Int\n    Number of singular vectors to return\nReturns\n----------\nu : RDD of blocks\n    Left eigenvectors\ns : numpy array\n    Singular values\nv : numpy array\n    Right eigenvectors", "id": "f16768:m0"}
{"signature": "def fit(self, Z):", "body": "self.fit_transform(Z)<EOL>return self<EOL>", "docstring": "Fit LSI model on training data X.\n\n        Parameters\n        ----------\n        X : {array-like, sparse matrix}, shape (n_samples, n_features)\n            Training data.\n\n        Returns\n        -------\n        self : object\n            Returns the transformer object.", "id": "f16768:c0:m1"}
{"signature": "def predict(self, X):", "body": "check_rdd(X, (np.ndarray, sp.spmatrix))<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>if isinstance(X, ArrayRDD):<EOL><INDENT>X = X.unblock()<EOL><DEDENT>return X.map(lambda x: self._mllib_model.predict(x))<EOL><DEDENT>else:<EOL><INDENT>rdd = X.map(lambda X: super(SparkKMeans, self).predict(X))<EOL>return ArrayRDD(rdd)<EOL><DEDENT>", "docstring": "Predict the closest cluster each sample in X belongs to.\n\n        In the vector quantization literature, `cluster_centers_` is called\n        the code book and each value returned by `predict` is the index of\n        the closest code in the code book.\n\n        Parameters\n        ----------\n        X : ArrayRDD containing array-like, sparse matrix\n            New data to predict.\n\n        Returns\n        -------\n        labels : ArrayRDD with predictions\n            Index of the cluster each sample belongs to.", "id": "f16777:c0:m2"}
{"signature": "def fit(self, Z):", "body": "X = Z[:, '<STR_LIT:X>'] if isinstance(Z, DictRDD) else Z<EOL>check_rdd(X, (np.ndarray, sp.spmatrix))<EOL>if self.init == '<STR_LIT>':<EOL><INDENT>self._mllib_model = MLlibKMeans.train(<EOL>X.unblock(),<EOL>self.n_clusters,<EOL>maxIterations=self.max_iter,<EOL>initializationMode=\"<STR_LIT>\")<EOL>self.cluster_centers_ = self._mllib_model.centers<EOL><DEDENT>else:<EOL><INDENT>models = X.map(lambda X: super(SparkKMeans, self).fit(X))<EOL>models = models.map(lambda model: model.cluster_centers_).collect()<EOL>return super(SparkKMeans, self).fit(np.concatenate(models))<EOL><DEDENT>", "docstring": "Compute k-means clustering.\n\n        Parameters\n        ----------\n        Z : ArrayRDD or DictRDD containing array-like or sparse matrix\n            Train data.\n\n        Returns\n        -------\n        self", "id": "f16777:c0:m1"}
{"signature": "def fit_transform(self, Z):", "body": "return self.fit(Z).transform(Z)<EOL>", "docstring": "Learn a list of feature name -> indices mappings and transform Z.\n        Like fit(Z) followed by transform(Z).\n\n        Parameters\n        ----------\n        Z : Z : ArrayRDD or DictRDD with column 'X' containing Mapping or\n            iterable over Mappings\n            Dict(s) or Mapping(s) from feature names (arbitrary Python\n            objects) to feature values (strings or convertible to dtype).\n\n        Returns\n        -------\n        Z : transformed, containing {array, sparse matrix}\n            Feature vectors; always 2-d.", "id": "f16784:c0:m2"}
{"signature": "def transform(self, Z):", "body": "if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._validate_vocabulary()<EOL><DEDENT>self._check_vocabulary()<EOL>analyze = self.build_analyzer()<EOL>mapper = self.broadcast(self._count_vocab, Z.context)<EOL>Z = Z.transform(lambda X: list(map(analyze, X)), column='<STR_LIT:X>').transform(mapper, column='<STR_LIT:X>', dtype=sp.spmatrix)<EOL>return Z<EOL>", "docstring": "Transform documents to document-term matrix.\n\n        Extract token counts out of raw text documents using the vocabulary\n        fitted with fit or the one provided to the constructor.\n\n        Parameters\n        ----------\n        raw_documents : iterable\n            An iterable which yields either str, unicode or file objects.\n\n        Returns\n        -------\n        X : sparse matrix, [n_samples, n_features]\n            Document-term matrix.", "id": "f16785:c0:m7"}
{"signature": "def fit(self, Z, **fit_params):", "body": "fit_params_steps = dict((step, {})<EOL>for step, _ in self.transformer_list)<EOL>for pname, pval in six.iteritems(fit_params):<EOL><INDENT>step, param = pname.split('<STR_LIT>', <NUM_LIT:1>)<EOL>fit_params_steps[step][param] = pval<EOL><DEDENT>transformers = Parallel(n_jobs=self.n_jobs, backend=\"<STR_LIT>\")(<EOL>delayed(_fit_one_transformer)(trans, Z, **fit_params_steps[name])<EOL>for name, trans in self.transformer_list)<EOL>self._update_transformer_list(transformers)<EOL>return self<EOL>", "docstring": "TODO: rewrite docstring\n        Fit all transformers using X.\n        Parameters\n        ----------\n        X : array-like or sparse matrix, shape (n_samples, n_features)\n            Input data, used to fit transformers.", "id": "f16791:c1:m0"}
{"signature": "def transform(self, fn, dtype=None, *args, **kwargs):", "body": "rdd = self._rdd.map(fn)<EOL>if dtype is None:<EOL><INDENT>return self.__class__(rdd, noblock=True, **self.get_params())<EOL><DEDENT>if dtype is np.ndarray:<EOL><INDENT>return ArrayRDD(rdd, bsize=self.bsize, noblock=True)<EOL><DEDENT>elif dtype is sp.spmatrix:<EOL><INDENT>return SparseRDD(rdd, bsize=self.bsize, noblock=True)<EOL><DEDENT>else:<EOL><INDENT>return BlockRDD(rdd, bsize=self.bsize, dtype=dtype, noblock=True)<EOL><DEDENT>", "docstring": "Equivalent to map, compatibility purpose only.\n        Column parameter ignored.", "id": "f16797:c0:m13"}
{"signature": "def __len__(self):", "body": "return self._rdd.map(len).sum()<EOL>", "docstring": "Returns the number of elements in all blocks.", "id": "f16797:c0:m6"}
{"signature": "def unblock(self):", "body": "return self._rdd.flatMap(lambda cols: list(zip(*cols)))<EOL>", "docstring": "Flattens the blocks.", "id": "f16797:c4:m7"}
{"signature": "def unblock(self):", "body": "return self._rdd.flatMap(lambda x: list(x))<EOL>", "docstring": "Flattens the blocks. Returns as list.", "id": "f16797:c0:m10"}
{"signature": "def fit(self, Z, classes=None):", "body": "check_rdd(Z, {'<STR_LIT:X>': (sp.spmatrix, np.ndarray)})<EOL>self._classes_ = np.unique(classes)<EOL>return self._spark_fit(SparkLinearSVC, Z)<EOL>", "docstring": "Fit the model according to the given training data.\n\n        Parameters\n        ----------\n        Z : DictRDD containing (X, y) pairs\n            X - Training vector\n            y - Target labels\n        classes : iterable\n            The set of available classes\n\n        Returns\n        -------\n        self : object\n            Returns self.", "id": "f16803:c0:m2"}
{"signature": "def predict_proba(self, X):", "body": "check_rdd(X, (sp.spmatrix, np.ndarray))<EOL>return X.map(<EOL>lambda X: super(SparkBaseNB, self).predict_proba(X))<EOL>", "docstring": "Return probability estimates for the RDD containing test vector X.\n\nParameters\n----------\nX : RDD containing array-like items, shape = [m_samples, n_features]\n\nReturns\n-------\nC : RDD with array-like items , shape = [n_samples, n_classes]\n    Returns the probability of the samples for each class in\n    the models for each RDD block. The columns correspond to the classes\n    in sorted order, as they appear in the attribute `classes_`.", "id": "f16805:c0:m2"}
{"signature": "def fit(self, Z):", "body": "<EOL>self._reset()<EOL>X = Z[:, '<STR_LIT:X>'] if isinstance(Z, DictRDD) else Z<EOL>check_rdd(X, (np.ndarray, sp.spmatrix))<EOL>def mapper(X):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>X = check_array(X, ('<STR_LIT>', '<STR_LIT>'), dtype=np.float64)<EOL>if hasattr(X, \"<STR_LIT>\"):   <EOL><INDENT>mean, var = mean_variance_axis(X, axis=<NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>mean, var = np.mean(X, axis=<NUM_LIT:0>), np.var(X, axis=<NUM_LIT:0>)<EOL><DEDENT>return X.shape[<NUM_LIT:0>], mean, var<EOL><DEDENT>def reducer(a, b):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>n_a, mean_a, var_a = a<EOL>n_b, mean_b, var_b = b<EOL>n_ab = n_a + n_b<EOL>mean_ab = ((mean_a * n_a) + (mean_b * n_b)) / n_ab<EOL>var_ab = (((n_a * var_a) + (n_b * var_b)) / n_ab) +((n_a * n_b) * ((mean_b - mean_a) / n_ab) ** <NUM_LIT:2>)<EOL>return (n_ab, mean_ab, var_ab)<EOL><DEDENT>if check_rdd_dtype(X, (sp.spmatrix)):<EOL><INDENT>if self.with_mean:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT>self.n_samples_seen_, self.mean_, self.var_ = X.map(mapper).treeReduce(reducer)<EOL>if self.with_std:<EOL><INDENT>self.scale_ = _handle_zeros_in_scale(np.sqrt(self.var_))<EOL><DEDENT>else:<EOL><INDENT>self.scale_ = None<EOL><DEDENT>return self<EOL>", "docstring": "Compute the mean and std to be used for later scaling.\n        Parameters\n        ----------\n        Z : DictRDD containing (X, y) pairs\n            X - Training vector.\n                {array-like, sparse matrix}, shape [n_samples, n_features]\n                The data used to compute the mean and standard deviation\n                used for later scaling along the features axis.\n            y - Target labels\n                Passthrough for ``Pipeline`` compatibility.", "id": "f16809:c0:m0"}
{"signature": "def auth_required(realm, auth_func):", "body": "def auth_decorator(func):<EOL><INDENT>def inner(self, *args, **kw):<EOL><INDENT>if self.get_authenticated_user(auth_func, realm):<EOL><INDENT>return func(self, *args, **kw)<EOL><DEDENT><DEDENT>return inner<EOL><DEDENT>return auth_decorator<EOL>", "docstring": "Decorator that protect methods with HTTP authentication.", "id": "f16813:m2"}
{"signature": "def depart_snippet_latex(self, node):", "body": "pass<EOL>", "docstring": "Latex document generator depart handler.", "id": "f16828:m5"}
{"signature": "@classmethod<EOL><INDENT>def run_tasks(cls):<DEDENT>", "body": "now = timezone.now()<EOL>tasks = cls.objects.filter(enabled=True)<EOL>for task in tasks:<EOL><INDENT>if task.next_run == HAS_NOT_RUN:<EOL><INDENT>task.calc_next_run()<EOL><DEDENT>if task.next_run < now:<EOL><INDENT>if (task.start_running < now):<EOL><INDENT>if (task.end_running > now):<EOL><INDENT>task.run_asap()<EOL><DEDENT>else:<EOL><INDENT>task.enabled = False<EOL>task.save()<EOL>Channel(KILL_TASK_CHANNEL).send({'<STR_LIT:id>': task.pk})<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Internal task-runner class method, called by :py:func:`sisy.consumers.run_heartbeat`", "id": "f16836:c0:m6"}
{"signature": "def taskinfo_with_label(label):", "body": "task = Task.objects.get(label=label)<EOL>info = json.loads(task._func_info)<EOL>return info<EOL>", "docstring": "Return task info dictionary from task label.  Internal function,\n    pretty much only used in migrations since the model methods aren't there.", "id": "f16836:m6"}
{"signature": "@classmethod<EOL><INDENT>def run_iterations(cls, the_callable, iterations=<NUM_LIT:1>, label=None, schedule='<STR_LIT>', userdata = None, run_immediately=False, delay_until=None):<DEDENT>", "body": "task = task_with_callable(the_callable, label=label, schedule=schedule, userdata=userdata)<EOL>task.iterations = iterations<EOL>if delay_until is not None:<EOL><INDENT>if isinstance(delay_until, datetime):<EOL><INDENT>if delay_until > timezone.now():<EOL><INDENT>task.start_running = delay_until<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if run_immediately:<EOL><INDENT>task.next_run = timezone.now()<EOL><DEDENT>else:<EOL><INDENT>task.calc_next_run()<EOL><DEDENT>task.save()<EOL>", "docstring": "Class method to run a callable with a specified number of iterations", "id": "f16836:c0:m11"}
{"signature": "def get_member(thing_obj, member_string):", "body": "mems = {x[<NUM_LIT:0>]: x[<NUM_LIT:1>] for x in inspect.getmembers(thing_obj)}<EOL>if member_string in mems:<EOL><INDENT>return mems[member_string]<EOL><DEDENT>", "docstring": "Get a member from an object by (string) name", "id": "f16836:m0"}
{"signature": "def run_heartbeat(message):", "body": "then = arrow.get(message['<STR_LIT:time>'])<EOL>now = arrow.get()<EOL>if (now - then) > timezone.timedelta(seconds=(TICK_FREQ+<NUM_LIT:1>)):<EOL><INDENT>pass <EOL><DEDENT>else:<EOL><INDENT>Task.run_tasks()<EOL><DEDENT>", "docstring": "Internal ``CLOCK_CHANNEL`` consumer to process task runs", "id": "f16838:m0"}
{"signature": "def imap(requests, stream=True, pool=None, size=<NUM_LIT:2>, exception_handler=None):", "body": "def send(r):<EOL><INDENT>return r.send(stream=stream)<EOL><DEDENT>pool = pool if pool else Pool(size)<EOL>for request in pool.imap(send, requests):<EOL><INDENT>if request.response is not None:<EOL><INDENT>yield request.response<EOL><DEDENT>elif exception_handler:<EOL><INDENT>exception_handler(request, request.exception)<EOL><DEDENT><DEDENT>if not pool:<EOL><INDENT>pool.close()<EOL><DEDENT>", "docstring": "Concurrently converts a generator object of Requests to\n    a generator of Responses.\n\n    :param requests: a generator of Request objects.\n    :param stream: If False, the content will not be downloaded immediately.\n    :param size: Specifies the number of requests to make at a time. default is 2\n    :param exception_handler: Callback function, called when exception occured. Params: Request, Exception", "id": "f16850:m3"}
{"signature": "def send(self, **kwargs):", "body": "merged_kwargs = {}<EOL>merged_kwargs.update(self.kwargs)<EOL>merged_kwargs.update(kwargs)<EOL>try:<EOL><INDENT>self.response = self.session.request(<EOL>self.method, self.url, **merged_kwargs)<EOL><DEDENT>except Exception as e:<EOL><INDENT>self.exception = e<EOL>self.traceback = traceback.format_exc()<EOL><DEDENT>return self<EOL>", "docstring": "Prepares request based on parameter passed to constructor and optional\n``kwargs```. Then sends request and saves response to :attr:`response`.\n\n:returns: ``Response``", "id": "f16850:c0:m1"}
{"signature": "def computed_displaywidth():", "body": "try:<EOL><INDENT>width = int(os.environ['<STR_LIT>'])<EOL><DEDENT>except (KeyError, ValueError):<EOL><INDENT>width = get_terminal_size().columns<EOL><DEDENT>return width or <NUM_LIT><EOL>", "docstring": "Figure out a reasonable default with. Use os.environ['COLUMNS'] if possible,\n    and failing that use 80.", "id": "f16857:m0"}
{"signature": "def restore_from_checkpoint(sess, input_checkpoint):", "body": "saver = tf.train.import_meta_graph('<STR_LIT>'.format(input_checkpoint))<EOL>saver.restore(sess, input_checkpoint)<EOL>return saver<EOL>", "docstring": "Return a TensorFlow saver from a checkpoint containing the metagraph.", "id": "f16865:m1"}
{"signature": "def freeze(sess, output_file_path, output_node_names):", "body": "with TemporaryDirectory() as temp_dir_name:<EOL><INDENT>checkpoint_path = os.path.join(temp_dir_name, '<STR_LIT>')<EOL>tf.train.Saver().save(sess, checkpoint_path)<EOL>freeze_from_checkpoint(checkpoint_path, output_file_path, output_node_names)<EOL><DEDENT>", "docstring": "Freeze and shrink the graph based on a session and the output node names.", "id": "f16868:m1"}
{"signature": "def fit_transform(self, features, targets):", "body": "self.fit(features, targets)<EOL>return self.transform(features)<EOL>", "docstring": "Convenience function that fits the provided data then constructs a new feature from the provided features.\n\n        Parameters\n        ----------\n        features: array-like {n_samples, n_features}\n            Feature matrix\n        targets: array-like {n_samples}\n            List of true target values\n\n        Returns\n        ----------\n        array-like: {n_samples}\n            Constructed features from the provided feature matrix", "id": "f16870:c0:m3"}
{"signature": "def plot_mdr_grid(mdr_instance):", "body": "var1_levels = list(set([variables[<NUM_LIT:0>] for variables in mdr_instance.feature_map]))<EOL>var2_levels = list(set([variables[<NUM_LIT:1>] for variables in mdr_instance.feature_map]))<EOL>max_count = np.array(list(mdr_instance.class_count_matrix.values())).flatten().max()<EOL>\"\"\"<STR_LIT>\"\"\"<EOL>fig, splots = plt.subplots(ncols=len(var1_levels), nrows=len(var2_levels), sharey=True, sharex=True)<EOL>fig.set_figwidth(<NUM_LIT:6>)<EOL>fig.set_figheight(<NUM_LIT:6>)<EOL>for (var1, var2) in itertools.product(var1_levels, var2_levels):<EOL><INDENT>class_counts = mdr_instance.class_count_matrix[(var1, var2)]<EOL>splot = splots[var2_levels.index(var2)][var1_levels.index(var1)]<EOL>splot.set_yticks([])<EOL>splot.set_xticks([])<EOL>splot.set_ylim(<NUM_LIT:0>, max_count * <NUM_LIT>)<EOL>splot.set_xlim(-<NUM_LIT:0.5>, <NUM_LIT>)<EOL>if var2_levels.index(var2) == <NUM_LIT:0>:<EOL><INDENT>splot.set_title('<STR_LIT>'.format(var1), fontsize=<NUM_LIT:12>)<EOL><DEDENT>if var1_levels.index(var1) == <NUM_LIT:0>:<EOL><INDENT>splot.set_ylabel('<STR_LIT>'.format(var2), fontsize=<NUM_LIT:12>)<EOL><DEDENT>bars = splot.bar(left=range(class_counts.shape[<NUM_LIT:0>]),<EOL>height=class_counts, width=<NUM_LIT:0.5>,<EOL>color='<STR_LIT>', align='<STR_LIT>')<EOL>bgcolor = '<STR_LIT>' if mdr_instance.feature_map[(var1, var2)] == <NUM_LIT:0> else '<STR_LIT>'<EOL>splot.set_axis_bgcolor(bgcolor)<EOL>for index, bar in enumerate(bars):<EOL><INDENT>splot.text(index, class_counts[index] + (max_count * <NUM_LIT:0.1>), class_counts[index], ha='<STR_LIT>')<EOL><DEDENT><DEDENT>fig.tight_layout()<EOL>return fig<EOL>", "docstring": "Visualizes the MDR grid of a given fitted MDR instance. Only works for 2-way MDR models.\n\n    This function is currently incomplete.\n\n    Parameters\n    ----------\n    mdr_instance: object\n        A fitted instance of the MDR type to visualize.\n\n    Returns\n    ----------\n    fig: matplotlib.figure\n        Figure object for the visualized MDR grid.", "id": "f16873:m11"}
{"signature": "def entropy(X, base=<NUM_LIT:2>):", "body": "return scipy.stats.entropy(list(Counter(X).values()), base=base)<EOL>", "docstring": "Calculates the entropy, H(X), in the given base\n\n    Parameters\n    ----------\n    X: array-like (# samples)\n        An array of values for which to compute the entropy\n    base: integer (default: 2)\n        The base in which to calculate entropy\n\n    Returns\n    ----------\n    entropy: float\n        The entropy calculated according to the equation H(X) = -sum(p_x * log p_x) for all states of X", "id": "f16873:m0"}
{"signature": "def _mdr_predict(X, Y, labels):", "body": "return MDR().fit_predict(np.column_stack((X, Y)), labels)<EOL>", "docstring": "Fits a MDR model to variables X and Y with the given labels, then returns the resulting predictions\n\n    This is a convenience method that should only be used internally.\n\n    Parameters\n    ----------\n    X: array-like (# samples)\n        An array of values corresponding to one feature in the MDR model\n    Y: array-like (# samples)\n        An array of values corresponding to one feature in the MDR model\n    labels: array-like (# samples)\n        The class labels corresponding to features X and Y\n\n    Returns\n    ----------\n    predictions: array-like (# samples)\n        The predictions from the fitted MDR model", "id": "f16873:m6"}
{"signature": "def predict(self, features):", "body": "return self.ensemble.predict(features)<EOL>", "docstring": "Uses the MDR ensemble to construct a new feature from the provided features\n\n        Parameters\n        ----------\n        features: array-like {n_samples, n_features}\n            Feature matrix to transform\n\n        Returns\n        ----------\n        array-like: {n_samples}\n            Constructed features from the provided feature matrix", "id": "f16874:c0:m2"}
{"signature": "def fit_predict(self, features, class_labels):", "body": "self.fit(features, class_labels)<EOL>return self.predict(features)<EOL>", "docstring": "Convenience function that fits the provided data then constructs predictions from the provided features.\n\n        Parameters\n        ----------\n        features: array-like {n_samples, n_features}\n            Feature matrix\n        class_labels: array-like {n_samples}\n            List of true class labels\n\n        Returns\n        ----------\n        array-like: {n_samples}\n            Constructed features from the provided feature matrix", "id": "f16876:c2:m1"}
{"signature": "def my_permission_factory(record, *args, **kwargs):", "body": "def can(self):<EOL><INDENT>rec = Record.get_record(record.id)<EOL>return rec.get('<STR_LIT>', '<STR_LIT>') == '<STR_LIT>'<EOL><DEDENT>return type('<STR_LIT>', (), {'<STR_LIT>': can})()<EOL>", "docstring": "My permission factory.", "id": "f16884:m0"}
{"signature": "@app.cli.group()<EOL>def fixtures():", "body": "", "docstring": "Command for working with test data.", "id": "f16885:m0"}
{"signature": "def create_url_rule(endpoint, route=None, pid_type=None, template=None,<EOL>permission_factory_imp=None, view_imp=None,<EOL>record_class=None, methods=None):", "body": "assert route<EOL>assert pid_type<EOL>permission_factory = import_string(permission_factory_imp) ifpermission_factory_imp else None<EOL>view_method = import_string(view_imp) if view_imp else default_view_method<EOL>record_class = import_string(record_class) if record_class else Record<EOL>methods = methods or ['<STR_LIT:GET>']<EOL>view_func = partial(<EOL>record_view,<EOL>resolver=Resolver(pid_type=pid_type, object_type='<STR_LIT>',<EOL>getter=record_class.get_record),<EOL>template=template or '<STR_LIT>',<EOL>permission_factory=permission_factory,<EOL>view_method=view_method)<EOL>view_func.__module__ = record_view.__module__<EOL>view_func.__name__ = record_view.__name__<EOL>return dict(<EOL>endpoint=endpoint,<EOL>rule=route,<EOL>view_func=view_func,<EOL>methods=methods,<EOL>)<EOL>", "docstring": "Create Werkzeug URL rule for a specific endpoint.\n\n    The method takes care of creating a persistent identifier resolver\n    for the given persistent identifier type.\n\n    :param endpoint: Name of endpoint.\n    :param route: URL route (must include ``<pid_value>`` pattern). Required.\n    :param pid_type: Persistent identifier type for endpoint. Required.\n    :param template: Template to render.\n        (Default: ``invenio_records_ui/detail.html``)\n    :param permission_factory_imp: Import path to factory that creates a\n        permission object for a given record.\n    :param view_imp: Import path to view function. (Default: ``None``)\n    :param record_class: Name of the record API class.\n    :param methods: Method allowed for the endpoint.\n    :returns: A dictionary that can be passed as keywords arguments to\n        ``Blueprint.add_url_rule``.", "id": "f16889:m2"}
{"signature": "def __init__(self, app=None):", "body": "if app:<EOL><INDENT>self.init_app(app)<EOL><DEDENT>", "docstring": "Extension initialization.\n\n        :param app: The Flask application. (Default: ``None``)", "id": "f16890:c1:m0"}
{"signature": "def init_app(self, app):", "body": "self.init_config(app)<EOL>app.extensions['<STR_LIT>'] = _RecordUIState(app)<EOL>", "docstring": "Flask application initialization.\n\n        :param app: The Flask application.", "id": "f16890:c1:m1"}
{"signature": "def run():", "body": "config_option_help = \"<STR_LIT>\"<EOL>parser = OptionParser()<EOL>parser.add_option(\"<STR_LIT>\", \"<STR_LIT>\", action=\"<STR_LIT:store>\",<EOL>type=\"<STR_LIT:string>\", dest=\"<STR_LIT>\", help=\"<STR_LIT>\")<EOL>parser.add_option(\"<STR_LIT:-c>\", \"<STR_LIT>\", action=\"<STR_LIT:store>\",<EOL>type=\"<STR_LIT:string>\", dest=\"<STR_LIT>\", help=config_option_help)<EOL>parser.add_option(\"<STR_LIT>\", \"<STR_LIT>\", action=\"<STR_LIT:store>\",<EOL>type=\"<STR_LIT:string>\", dest=\"<STR_LIT>\", help=\"<STR_LIT>\")<EOL>parser.add_option(\"<STR_LIT>\", \"<STR_LIT>\", action=\"<STR_LIT:store>\",<EOL>type=\"<STR_LIT:string>\", dest=\"<STR_LIT>\", help=\"<STR_LIT>\")<EOL>parser.add_option(\"<STR_LIT>\", \"<STR_LIT>\", action=\"<STR_LIT:store>\",<EOL>type=\"<STR_LIT:string>\", dest=\"<STR_LIT>\", help=\"<STR_LIT>\")<EOL>options, args = parser.parse_args()<EOL>if options.config:<EOL><INDENT>if options.config == \"<STR_LIT>\":<EOL><INDENT>config_option_list = '<STR_LIT>'<EOL>config_sections = config.sections()<EOL>for section in config_sections:<EOL><INDENT>config_option_list = config_option_list+section+\"<STR_LIT:\\n>\"<EOL>section_items = config.items(section)<EOL>for item in section_items:<EOL><INDENT>config_option_list = config_option_list +\"<STR_LIT:U+0020>\"+item[<NUM_LIT:0>]+\"<STR_LIT:U+0020>\"+item[<NUM_LIT:1>]+\"<STR_LIT:\\n>\"<EOL><DEDENT><DEDENT>print(config_option_list)<EOL>quit()<EOL><DEDENT><DEDENT>def add_notes(note_name, existing_tags):<EOL><INDENT>call([editor, environ[\"<STR_LIT>\"] + \"<STR_LIT>\"+note_name+\"<STR_LIT>\"])<EOL>definedtags = input(\"<STR_LIT>\").split(\"<STR_LIT:U+0020>\")<EOL>definedtags.append(note_name)<EOL>print(definedtags)<EOL>print(existing_tags)<EOL>definedtags = list(set(definedtags)-set(existing_tags))<EOL>print(definedtags)<EOL>if len(definedtags) > <NUM_LIT:0>:<EOL><INDENT>modify_tags_xml(note_name, definedtags, files,<EOL>rootfiles, tags, roottags, tree, TAGS_XML_DIR)<EOL><DEDENT><DEDENT>def get_tags_from_file(note_name):<EOL><INDENT>fil = get_file_from_files(note_name)<EOL>filetags = fil.iter('<STR_LIT>')<EOL>filetaglist = []<EOL>for tag in filetags:<EOL><INDENT>filetaglist.append(tag.text)<EOL><DEDENT>return filetaglist<EOL><DEDENT>if options.addfile:<EOL><INDENT>existing_tags = []<EOL>if isFile(options.addfile, files):<EOL><INDENT>existing_tags = get_tags_from_file(options.addfile)<EOL>input(\"<STR_LIT>\"+\"<STR_LIT:U+0020>\".join(existing_tags) +<EOL>\"<STR_LIT>\")<EOL><DEDENT>add_notes(options.addfile, existing_tags)<EOL>quit()<EOL><DEDENT>if options.editfile:<EOL><INDENT>if isFile(options.editfile, files):<EOL><INDENT>add_notes(note_name, [])<EOL><DEDENT>else:<EOL><INDENT>input(<EOL>\"<STR_LIT>\")<EOL>add_notes(note_name)<EOL><DEDENT><DEDENT>if options.remove:<EOL><INDENT>pass<EOL><DEDENT>if len(args) != <NUM_LIT:1>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>quit()<EOL><DEDENT>_key_File = \"<STR_LIT>\"<EOL>_key_Results = \"<STR_LIT>\"<EOL>table = {_key_Results: []}<EOL>for tag in tags:<EOL><INDENT>if tag.attrib[\"<STR_LIT:value>\"] == args[<NUM_LIT:0>]:<EOL><INDENT>fileelements = tag.iter(\"<STR_LIT:file>\")<EOL>for fileelement in fileelements:<EOL><INDENT>f = open(<EOL>environ[\"<STR_LIT>\"] + \"<STR_LIT>\" + fileelement.text+\"<STR_LIT>\", \"<STR_LIT:r>\")<EOL>table[_key_Results].append(<EOL>f.read()+\"<STR_LIT>\"+fileelement.text+\"<STR_LIT>\")<EOL>f.close()<EOL><DEDENT><DEDENT><DEDENT>print(tabulate(table, headers=[], tablefmt=\"<STR_LIT>\"))<EOL>", "docstring": "Main method where all logic is defined", "id": "f16897:m0"}
{"signature": "def execle(file, *args):", "body": "env = args[-<NUM_LIT:1>]<EOL>execve(file, args[:-<NUM_LIT:1>], env)<EOL>", "docstring": "execle(file, *args, env)\n\n    Execute the executable file with argument list args and\n    environment env, replacing the current process.", "id": "f16906:m6"}
{"signature": "def makedirs(name, mode=<NUM_LIT>):", "body": "head, tail = path.split(name)<EOL>if not tail:<EOL><INDENT>head, tail = path.split(head)<EOL><DEDENT>if head and tail and not path.exists(head):<EOL><INDENT>try:<EOL><INDENT>makedirs(head, mode)<EOL><DEDENT>except OSError as e:<EOL><INDENT>if e.errno != errno.EEXIST:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>if tail == curdir:           <EOL><INDENT>return<EOL><DEDENT><DEDENT>mkdir(name, mode)<EOL>", "docstring": "makedirs(path [, mode=0777])\n\n    Super-mkdir; create a leaf directory and all intermediate ones.\n    Works like mkdir, except that any intermediate path segment (not\n    just the rightmost) will be created if it does not exist.  This is\n    recursive.", "id": "f16906:m1"}
{"signature": "def removedirs(name):", "body": "rmdir(name)<EOL>head, tail = path.split(name)<EOL>if not tail:<EOL><INDENT>head, tail = path.split(head)<EOL><DEDENT>while head and tail:<EOL><INDENT>try:<EOL><INDENT>rmdir(head)<EOL><DEDENT>except error:<EOL><INDENT>break<EOL><DEDENT>head, tail = path.split(head)<EOL><DEDENT>", "docstring": "removedirs(path)\n\n    Super-rmdir; remove a leaf directory and all empty intermediate\n    ones.  Works like rmdir except that, if the leaf directory is\n    successfully removed, directories corresponding to rightmost path\n    segments will be pruned away until either the whole path is\n    consumed or an error occurs.  Errors during this latter phase are\n    ignored -- they generally mean that a directory was not empty.", "id": "f16906:m2"}
{"signature": "def execlpe(file, *args):", "body": "env = args[-<NUM_LIT:1>]<EOL>execvpe(file, args[:-<NUM_LIT:1>], env)<EOL>", "docstring": "execlpe(file, *args, env)\n\n    Execute the executable file (which is searched for along $PATH)\n    with argument list args and environment env, replacing the current\n    process.", "id": "f16906:m8"}
{"signature": "def getenv(key, default=None):", "body": "return environ.get(key, default)<EOL>", "docstring": "Get an environment variable, return None if it doesn't exist.\n    The optional second argument can specify an alternate default.", "id": "f16906:m12"}
{"signature": "def execvpe(file, args, env):", "body": "_execvpe(file, args, env)<EOL>", "docstring": "execvpe(file, args, env)\n\n    Execute the executable file (which is searched for along $PATH)\n    with argument list args and environment env , replacing the\n    current process.\n    args may be a list or tuple of strings.", "id": "f16906:m10"}
{"signature": "def atoi(str):", "body": "return atof(str, int)<EOL>", "docstring": "Converts a string to an integer according to the locale settings.", "id": "f16907:m10"}
{"signature": "def _print_locale():", "body": "categories = {}<EOL>def _init_categories(categories=categories):<EOL><INDENT>for k,v in list(globals().items()):<EOL><INDENT>if k[:<NUM_LIT:3>] == '<STR_LIT>':<EOL><INDENT>categories[k] = v<EOL><DEDENT><DEDENT><DEDENT>_init_categories()<EOL>del categories['<STR_LIT>']<EOL>print('<STR_LIT>')<EOL>print('<STR_LIT:->'*<NUM_LIT>)<EOL>lang, enc = getdefaultlocale()<EOL>print('<STR_LIT>', lang or '<STR_LIT>')<EOL>print('<STR_LIT>', enc or '<STR_LIT>')<EOL>print()<EOL>print('<STR_LIT>')<EOL>print('<STR_LIT:->'*<NUM_LIT>)<EOL>for name,category in list(categories.items()):<EOL><INDENT>print(name, '<STR_LIT>')<EOL>lang, enc = getlocale(category)<EOL>print('<STR_LIT>', lang or '<STR_LIT>')<EOL>print('<STR_LIT>', enc or '<STR_LIT>')<EOL>print()<EOL><DEDENT>print()<EOL>print('<STR_LIT>')<EOL>print('<STR_LIT:->'*<NUM_LIT>)<EOL>resetlocale()<EOL>for name,category in list(categories.items()):<EOL><INDENT>print(name, '<STR_LIT>')<EOL>lang, enc = getlocale(category)<EOL>print('<STR_LIT>', lang or '<STR_LIT>')<EOL>print('<STR_LIT>', enc or '<STR_LIT>')<EOL>print()<EOL><DEDENT>try:<EOL><INDENT>setlocale(LC_ALL, \"<STR_LIT>\")<EOL><DEDENT>except:<EOL><INDENT>print('<STR_LIT>')<EOL>print('<STR_LIT>')<EOL>print('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>print()<EOL>print('<STR_LIT>')<EOL>print('<STR_LIT:->'*<NUM_LIT>)<EOL>for name,category in list(categories.items()):<EOL><INDENT>print(name, '<STR_LIT>')<EOL>lang, enc = getlocale(category)<EOL>print('<STR_LIT>', lang or '<STR_LIT>')<EOL>print('<STR_LIT>', enc or '<STR_LIT>')<EOL>print()<EOL><DEDENT><DEDENT>", "docstring": "Test function.", "id": "f16907:m20"}
{"signature": "def format_string(f, val, grouping=False):", "body": "percents = list(_percent_re.finditer(f))<EOL>new_f = _percent_re.sub('<STR_LIT:%s>', f)<EOL>if isinstance(val, collections.abc.Mapping):<EOL><INDENT>new_val = []<EOL>for perc in percents:<EOL><INDENT>if perc.group()[-<NUM_LIT:1>]=='<STR_LIT:%>':<EOL><INDENT>new_val.append('<STR_LIT:%>')<EOL><DEDENT>else:<EOL><INDENT>new_val.append(format(perc.group(), val, grouping))<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if not isinstance(val, tuple):<EOL><INDENT>val = (val,)<EOL><DEDENT>new_val = []<EOL>i = <NUM_LIT:0><EOL>for perc in percents:<EOL><INDENT>if perc.group()[-<NUM_LIT:1>]=='<STR_LIT:%>':<EOL><INDENT>new_val.append('<STR_LIT:%>')<EOL><DEDENT>else:<EOL><INDENT>starcount = perc.group('<STR_LIT>').count('<STR_LIT:*>')<EOL>new_val.append(_format(perc.group(),<EOL>val[i],<EOL>grouping,<EOL>False,<EOL>*val[i+<NUM_LIT:1>:i+<NUM_LIT:1>+starcount]))<EOL>i += (<NUM_LIT:1> + starcount)<EOL><DEDENT><DEDENT><DEDENT>val = tuple(new_val)<EOL>return new_f % val<EOL>", "docstring": "Formats a string in the same way that the % formatting would use,\n    but takes the current locale into account.\n    Grouping is applied if the third parameter is true.", "id": "f16907:m6"}
{"signature": "def atof(string, func=float):", "body": "<EOL>ts = localeconv()['<STR_LIT>']<EOL>if ts:<EOL><INDENT>string = string.replace(ts, '<STR_LIT>')<EOL><DEDENT>dd = localeconv()['<STR_LIT>']<EOL>if dd:<EOL><INDENT>string = string.replace(dd, '<STR_LIT:.>')<EOL><DEDENT>return func(string)<EOL>", "docstring": "Parses a string as a float according to the locale settings.", "id": "f16907:m9"}
{"signature": "def _parse_localename(localename):", "body": "code = normalize(localename)<EOL>if '<STR_LIT:@>' in code:<EOL><INDENT>code, modifier = code.split('<STR_LIT:@>', <NUM_LIT:1>)<EOL>if modifier == '<STR_LIT>' and '<STR_LIT:.>' not in code:<EOL><INDENT>return code, '<STR_LIT>'<EOL><DEDENT><DEDENT>if '<STR_LIT:.>' in code:<EOL><INDENT>return tuple(code.split('<STR_LIT:.>')[:<NUM_LIT:2>])<EOL><DEDENT>elif code == '<STR_LIT:C>':<EOL><INDENT>return None, None<EOL><DEDENT>raise ValueError('<STR_LIT>' % localename)<EOL>", "docstring": "Parses the locale code for localename and returns the\n        result as tuple (language code, encoding).\n\n        The localename is normalized and passed through the locale\n        alias engine. A ValueError is raised in case the locale name\n        cannot be parsed.\n\n        The language code corresponds to RFC 1766.  code and encoding\n        can be None in case the values cannot be determined or are\n        unknown to this implementation.", "id": "f16907:m14"}
{"signature": "def setlocale(category, locale=None):", "body": "if locale and not isinstance(locale, (_str, _unicode)):<EOL><INDENT>locale = normalize(_build_localename(locale))<EOL><DEDENT>return _setlocale(category, locale)<EOL>", "docstring": "Set the locale for the given category.  The locale can be\n        a string, an iterable of two strings (language code and encoding),\n        or None.\n\n        Iterables are converted to strings using the locale aliasing\n        engine.  Locale strings are passed directly to the C lib.\n\n        category may be given as one of the LC_* values.", "id": "f16907:m18"}
{"signature": "def execusercustomize():", "body": "try:<EOL><INDENT>import usercustomize<EOL><DEDENT>except ImportError:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Run custom user specific code, if available.", "id": "f16908:m21"}
{"signature": "def check_enableusersite():", "body": "if hasattr(sys, '<STR_LIT>') and getattr(sys.flags, '<STR_LIT>', False):<EOL><INDENT>return False<EOL><DEDENT>if hasattr(os, \"<STR_LIT>\") and hasattr(os, \"<STR_LIT>\"):<EOL><INDENT>if os.geteuid() != os.getuid():<EOL><INDENT>return None<EOL><DEDENT><DEDENT>if hasattr(os, \"<STR_LIT>\") and hasattr(os, \"<STR_LIT>\"):<EOL><INDENT>if os.getegid() != os.getgid():<EOL><INDENT>return None<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Check if user site directory is safe for inclusion\n\n    The function tests for the command line flag (including environment var),\n    process uid/gid equal to effective uid/gid.\n\n    None: Disabled for security reasons\n    False: Disabled by user (command line option)\n    True: Safe and enabled", "id": "f16908:m8"}
{"signature": "def abs__file__():", "body": "for m in sys.modules.values():<EOL><INDENT>if ((_is_jython and not isinstance(m, ModuleType)) or<EOL>hasattr(m, '<STR_LIT>')):<EOL><INDENT>continue<EOL><DEDENT>f = getattr(m, '<STR_LIT>', None)<EOL>if f is None:<EOL><INDENT>continue<EOL><DEDENT>m.__file__ = os.path.abspath(f)<EOL><DEDENT>", "docstring": "Set all module' __file__ attribute to an absolute path", "id": "f16908:m1"}
{"signature": "def aliasmbcs():", "body": "if sys.platform == '<STR_LIT:win32>':<EOL><INDENT>import locale, codecs<EOL>enc = locale.getdefaultlocale()[<NUM_LIT:1>]<EOL>if enc.startswith('<STR_LIT>'):            <EOL><INDENT>try:<EOL><INDENT>codecs.lookup(enc)<EOL><DEDENT>except LookupError:<EOL><INDENT>import encodings<EOL>encodings._cache[enc] = encodings._unknown<EOL>encodings.aliases.aliases[enc] = '<STR_LIT>'<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "On Windows, some default encodings are not provided by Python,\n    while they are always available as \"mbcs\" in each locale. Make\n    them usable by aliasing to \"mbcs\" in such a case.", "id": "f16908:m14"}
{"signature": "def _slotnames(cls):", "body": "<EOL>names = cls.__dict__.get(\"<STR_LIT>\")<EOL>if names is not None:<EOL><INDENT>return names<EOL><DEDENT>names = []<EOL>if not hasattr(cls, \"<STR_LIT>\"):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>for c in cls.__mro__:<EOL><INDENT>if \"<STR_LIT>\" in c.__dict__:<EOL><INDENT>slots = c.__dict__['<STR_LIT>']<EOL>if isinstance(slots, str):<EOL><INDENT>slots = (slots,)<EOL><DEDENT>for name in slots:<EOL><INDENT>if name in (\"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>continue<EOL><DEDENT>elif name.startswith('<STR_LIT>') and not name.endswith('<STR_LIT>'):<EOL><INDENT>stripped = c.__name__.lstrip('<STR_LIT:_>')<EOL>if stripped:<EOL><INDENT>names.append('<STR_LIT>' % (stripped, name))<EOL><DEDENT>else:<EOL><INDENT>names.append(name)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>names.append(name)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>try:<EOL><INDENT>cls.__slotnames__ = names<EOL><DEDENT>except:<EOL><INDENT>pass <EOL><DEDENT>return names<EOL>", "docstring": "Return a list of slot names for a given class.\n\n    This needs to find slots defined by the class and its bases, so we\n    can't simply return the __slots__ attribute.  We must walk down\n    the Method Resolution Order and concatenate the __slots__ of each\n    class found there.  (This assumes classes don't modify their\n    __slots__ attribute to misrepresent their slots after the class is\n    defined.)", "id": "f16909:m5"}
{"signature": "def walk(top, func, arg):", "body": "warnings.warnpy3k(\"<STR_LIT>\",<EOL>stacklevel=<NUM_LIT:2>)<EOL>try:<EOL><INDENT>names = os.listdir(top)<EOL><DEDENT>except os.error:<EOL><INDENT>return<EOL><DEDENT>func(arg, top, names)<EOL>for name in names:<EOL><INDENT>name = join(top, name)<EOL>try:<EOL><INDENT>st = os.lstat(name)<EOL><DEDENT>except os.error:<EOL><INDENT>continue<EOL><DEDENT>if stat.S_ISDIR(st.st_mode):<EOL><INDENT>walk(name, func, arg)<EOL><DEDENT><DEDENT>", "docstring": "Directory tree walk with callback function.\n\n    For each directory in the directory tree rooted at top (including top\n    itself, but excluding '.' and '..'), call func(arg, dirname, fnames).\n    dirname is the name of the directory, and fnames a list of the names of\n    the files and subdirectories in dirname (excluding '.' and '..').  func\n    may modify the fnames list in-place (e.g. via del or slice assignment),\n    and walk will only recurse into the subdirectories whose names remain in\n    fnames; this can be used to implement a filter, or to impose a specific\n    order of visiting.  No semantics are defined for, or required of, arg,\n    beyond that arg is always passed to func.  It can be used, e.g., to pass\n    a filename pattern, or a mutable object designed to accumulate\n    statistics.  Passing None for arg is common.", "id": "f16910:m14"}
{"signature": "def abspath(path):", "body": "if not isabs(path):<EOL><INDENT>if isinstance(path, _unicode):<EOL><INDENT>cwd = os.getcwd()<EOL><DEDENT>else:<EOL><INDENT>cwd = os.getcwd()<EOL><DEDENT>path = join(cwd, path)<EOL><DEDENT>return normpath(path)<EOL>", "docstring": "Return an absolute path.", "id": "f16910:m18"}
{"signature": "def splitdrive(p):", "body": "return '<STR_LIT>', p<EOL>", "docstring": "Split a pathname into drive and path. On Posix, drive is always\n    empty.", "id": "f16910:m5"}
{"signature": "def relpath(path, start=curdir):", "body": "if not path:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>start_list = [x for x in abspath(start).split(sep) if x]<EOL>path_list = [x for x in abspath(path).split(sep) if x]<EOL>i = len(commonprefix([start_list, path_list]))<EOL>rel_list = [pardir] * (len(start_list)-i) + path_list[i:]<EOL>if not rel_list:<EOL><INDENT>return curdir<EOL><DEDENT>return join(*rel_list)<EOL>", "docstring": "Return a relative version of a path", "id": "f16910:m21"}
{"signature": "def islink(path):", "body": "try:<EOL><INDENT>st = os.lstat(path)<EOL><DEDENT>except (os.error, AttributeError):<EOL><INDENT>return False<EOL><DEDENT>return stat.S_ISLNK(st.st_mode)<EOL>", "docstring": "Test whether a path is a symbolic link", "id": "f16910:m8"}
{"signature": "def split(p):", "body": "i = p.rfind('<STR_LIT:/>') + <NUM_LIT:1><EOL>head, tail = p[:i], p[i:]<EOL>if head and head != '<STR_LIT:/>'*len(head):<EOL><INDENT>head = head.rstrip('<STR_LIT:/>')<EOL><DEDENT>return head, tail<EOL>", "docstring": "Split a pathname.  Returns tuple \"(head, tail)\" where \"tail\" is\n    everything after the final slash.  Either part may be empty.", "id": "f16910:m3"}
{"signature": "def updatecache(filename, module_globals=None):", "body": "if filename in cache:<EOL><INDENT>del cache[filename]<EOL><DEDENT>if not filename or (filename.startswith('<STR_LIT:<>') and filename.endswith('<STR_LIT:>>')):<EOL><INDENT>return []<EOL><DEDENT>fullname = filename<EOL>try:<EOL><INDENT>stat = os.stat(fullname)<EOL><DEDENT>except OSError:<EOL><INDENT>basename = filename<EOL>if module_globals and '<STR_LIT>' in module_globals:<EOL><INDENT>name = module_globals.get('<STR_LIT>')<EOL>loader = module_globals['<STR_LIT>']<EOL>get_source = getattr(loader, '<STR_LIT>', None)<EOL>if name and get_source:<EOL><INDENT>try:<EOL><INDENT>data = get_source(name)<EOL><DEDENT>except (ImportError, IOError):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>if data is None:<EOL><INDENT>return []<EOL><DEDENT>cache[filename] = (<EOL>len(data), None,<EOL>[line+'<STR_LIT:\\n>' for line in data.splitlines()], fullname<EOL>)<EOL>return cache[filename][<NUM_LIT:2>]<EOL><DEDENT><DEDENT><DEDENT>if os.path.isabs(filename):<EOL><INDENT>return []<EOL><DEDENT>for dirname in sys.path:<EOL><INDENT>try:<EOL><INDENT>fullname = os.path.join(dirname, basename)<EOL><DEDENT>except (TypeError, AttributeError):<EOL><INDENT>continue<EOL><DEDENT>try:<EOL><INDENT>stat = os.stat(fullname)<EOL>break<EOL><DEDENT>except os.error:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return []<EOL><DEDENT><DEDENT>try:<EOL><INDENT>with open(fullname, '<STR_LIT>') as fp:<EOL><INDENT>lines = fp.readlines()<EOL><DEDENT><DEDENT>except IOError:<EOL><INDENT>return []<EOL><DEDENT>if lines and not lines[-<NUM_LIT:1>].endswith('<STR_LIT:\\n>'):<EOL><INDENT>lines[-<NUM_LIT:1>] += '<STR_LIT:\\n>'<EOL><DEDENT>size, mtime = stat.st_size, stat.st_mtime<EOL>cache[filename] = size, mtime, lines, fullname<EOL>return lines<EOL>", "docstring": "Update a cache entry and return its list of lines.\n    If something's wrong, print a message, discard the cache entry,\n    and return an empty list.", "id": "f16911:m4"}
{"signature": "def checkcache(filename=None):", "body": "if filename is None:<EOL><INDENT>filenames = cache.keys()<EOL><DEDENT>else:<EOL><INDENT>if filename in cache:<EOL><INDENT>filenames = [filename]<EOL><DEDENT>else:<EOL><INDENT>return<EOL><DEDENT><DEDENT>for filename in filenames:<EOL><INDENT>size, mtime, lines, fullname = cache[filename]<EOL>if mtime is None:<EOL><INDENT>continue   <EOL><DEDENT>try:<EOL><INDENT>stat = os.stat(fullname)<EOL><DEDENT>except os.error:<EOL><INDENT>del cache[filename]<EOL>continue<EOL><DEDENT>if size != stat.st_size or mtime != stat.st_mtime:<EOL><INDENT>del cache[filename]<EOL><DEDENT><DEDENT>", "docstring": "Discard cache entries that are out of date.\n    (This is not checked upon each call!)", "id": "f16911:m3"}
{"signature": "def clearcache():", "body": "global cache<EOL>cache = {}<EOL>", "docstring": "Clear the cache entirely.", "id": "f16911:m1"}
{"signature": "def make_identity_dict(rng):", "body": "res = {}<EOL>for i in rng:<EOL><INDENT>res[i]=i<EOL><DEDENT>return res<EOL>", "docstring": "make_identity_dict(rng) -> dict\n\n        Return a dictionary where elements of the rng sequence are\n        mapped to themselves.", "id": "f16912:m10"}
{"signature": "def __next__(self):", "body": "return next(self.reader)<EOL>", "docstring": "Return the next decoded line from the input stream.", "id": "f16912:c8:m4"}
{"signature": "def make_encoding_map(decoding_map):", "body": "m = {}<EOL>for k,v in list(decoding_map.items()):<EOL><INDENT>if not v in m:<EOL><INDENT>m[v] = k<EOL><DEDENT>else:<EOL><INDENT>m[v] = None<EOL><DEDENT><DEDENT>return m<EOL>", "docstring": "Creates an encoding map from a decoding map.\n\n        If a target mapping in the decoding map occurs multiple\n        times, then that target is mapped to None (undefined mapping),\n        causing an exception when encountered by the charmap codec\n        during translation.\n\n        One example where this happens is cp875.py which decodes\n        multiple character to \\\\u001a.", "id": "f16912:m11"}
{"signature": "def writelines(self, list):", "body": "self.write('<STR_LIT>'.join(list))<EOL>", "docstring": "Writes the concatenated list of strings to the stream\n            using .write().", "id": "f16912:c6:m2"}
{"signature": "def getencoder(encoding):", "body": "return lookup(encoding).encode<EOL>", "docstring": "Lookup up the codec for the given encoding and return\n        its encoder function.\n\n        Raises a LookupError in case the encoding cannot be found.", "id": "f16912:m2"}
{"signature": "def readlines(self, sizehint=None, keepends=True):", "body": "data = self.read()<EOL>return data.splitlines(keepends)<EOL>", "docstring": "Read all lines available on the input stream\n            and return them as list of lines.\n\n            Line breaks are implemented using the codec's decoder\n            method and are included in the list entries.\n\n            sizehint, if given, is ignored since there is no efficient\n            way to finding the true end-of-line.", "id": "f16912:c7:m4"}
{"signature": "def decode(self, input, errors='<STR_LIT:strict>'):", "body": "raise NotImplementedError<EOL>", "docstring": "Decodes the object input and returns a tuple (output\n            object, length consumed).\n\n            input must be an object which provides the bf_getreadbuf\n            buffer slot. Python strings, buffer objects and memory\n            mapped files are examples of objects providing this slot.\n\n            errors defines the error handling to apply. It defaults to\n            'strict' handling.\n\n            The method may not store state in the Codec instance. Use\n            StreamReader for codecs which have to keep state in order to\n            make decoding efficient.\n\n            The decoder must be able to handle zero length input and\n            return an empty object of the output object type in this\n            situation.", "id": "f16912:c1:m1"}
{"signature": "def __init__(self, stream, errors='<STR_LIT:strict>'):", "body": "self.stream = stream<EOL>self.errors = errors<EOL>self.bytebuffer = \"<STR_LIT>\"<EOL>self.charbuffer = \"<STR_LIT>\"<EOL>self.linebuffer = None<EOL>", "docstring": "Creates a StreamReader instance.\n\n            stream must be a file-like object open for reading\n            (binary) data.\n\n            The StreamReader may use different error handling\n            schemes by providing the errors keyword argument. These\n            parameters are predefined:\n\n             'strict' - raise a ValueError (or a subclass)\n             'ignore' - ignore the character and continue with the next\n             'replace'- replace with a suitable replacement character;\n\n            The set of allowed parameter values can be extended via\n            register_error.", "id": "f16912:c7:m0"}
{"signature": "def __init__(self, stream, errors='<STR_LIT:strict>'):", "body": "self.stream = stream<EOL>self.errors = errors<EOL>", "docstring": "Creates a StreamWriter instance.\n\n            stream must be a file-like object open for writing\n            (binary) data.\n\n            The StreamWriter may use different error handling\n            schemes by providing the errors keyword argument. These\n            parameters are predefined:\n\n             'strict' - raise a ValueError (or a subclass)\n             'ignore' - ignore the character and continue with the next\n             'replace'- replace with a suitable replacement character\n             'xmlcharrefreplace' - Replace with the appropriate XML\n                                   character reference.\n             'backslashreplace'  - Replace with backslashed escape\n                                   sequences (only for encoding).\n\n            The set of allowed parameter values can be extended via\n            register_error.", "id": "f16912:c6:m0"}
{"signature": "def __init__(self, stream, Reader, Writer, errors='<STR_LIT:strict>'):", "body": "self.stream = stream<EOL>self.reader = Reader(stream, errors)<EOL>self.writer = Writer(stream, errors)<EOL>self.errors = errors<EOL>", "docstring": "Creates a StreamReaderWriter instance.\n\n            stream must be a Stream-like object.\n\n            Reader, Writer must be factory functions or classes\n            providing the StreamReader, StreamWriter interface resp.\n\n            Error handling is done in the same way as defined for the\n            StreamWriter/Readers.", "id": "f16912:c8:m0"}
{"signature": "def iterdecode(iterator, encoding, errors='<STR_LIT:strict>', **kwargs):", "body": "decoder = getincrementaldecoder(encoding)(errors, **kwargs)<EOL>for input in iterator:<EOL><INDENT>output = decoder.decode(input)<EOL>if output:<EOL><INDENT>yield output<EOL><DEDENT><DEDENT>output = decoder.decode(\"<STR_LIT>\", True)<EOL>if output:<EOL><INDENT>yield output<EOL><DEDENT>", "docstring": "Decoding iterator.\n\nDecodes the input strings from the iterator using an IncrementalDecoder.\n\nerrors and kwargs are passed through to the IncrementalDecoder\nconstructor.", "id": "f16912:m9"}
{"signature": "def setstate(self, state):", "body": "", "docstring": "Set the current state of the encoder. state must have been\nreturned by getstate().", "id": "f16912:c2:m4"}
{"signature": "def write(self, object):", "body": "data, consumed = self.encode(object, self.errors)<EOL>self.stream.write(data)<EOL>", "docstring": "Writes the object's contents encoded to self.stream.", "id": "f16912:c6:m1"}
{"signature": "def open(filename, mode='<STR_LIT:rb>', encoding=None, errors='<STR_LIT:strict>', buffering=<NUM_LIT:1>):", "body": "if encoding is not None:<EOL><INDENT>if '<STR_LIT>' in mode:<EOL><INDENT>mode = mode.strip().replace('<STR_LIT>', '<STR_LIT>')<EOL>if mode[:<NUM_LIT:1>] not in set('<STR_LIT>'):<EOL><INDENT>mode = '<STR_LIT:r>' + mode<EOL><DEDENT><DEDENT>if '<STR_LIT:b>' not in mode:<EOL><INDENT>mode = mode + '<STR_LIT:b>'<EOL><DEDENT><DEDENT>file = builtins.open(filename, mode, buffering)<EOL>if encoding is None:<EOL><INDENT>return file<EOL><DEDENT>info = lookup(encoding)<EOL>srw = StreamReaderWriter(file, info.streamreader, info.streamwriter, errors)<EOL>srw.encoding = encoding<EOL>return srw<EOL>", "docstring": "Open an encoded file using the given mode and return\n        a wrapped version providing transparent encoding/decoding.\n\n        Note: The wrapped version will only accept the object format\n        defined by the codecs, i.e. Unicode objects for most builtin\n        codecs. Output is also codec dependent and will usually be\n        Unicode as well.\n\n        Files are always opened in binary mode, even if no binary mode\n        was specified. This is done to avoid data loss due to encodings\n        using 8-bit values. The default file mode is 'rb' meaning to\n        open the file in binary read mode.\n\n        encoding specifies the encoding which is to be used for the\n        file.\n\n        errors may be given to define the error handling. It defaults\n        to 'strict' which causes ValueErrors to be raised in case an\n        encoding error occurs.\n\n        buffering has the same meaning as for the builtin open() API.\n        It defaults to line buffered.\n\n        The returned wrapped file object provides an extra attribute\n        .encoding which allows querying the used encoding. This\n        attribute is only available if an encoding was specified as\n        parameter.", "id": "f16912:m0"}
{"signature": "def getstate(self):", "body": "return (b\"<STR_LIT>\", <NUM_LIT:0>)<EOL>", "docstring": "Return the current state of the decoder.\n\nThis must be a (buffered_input, additional_state_info) tuple.\nbuffered_input must be a bytes object containing bytes that\nwere passed to decode() that have not yet been converted.\nadditional_state_info must be a non-negative integer\nrepresenting the state of the decoder WITHOUT yet having\nprocessed the contents of buffered_input.  In the initial state\nand after reset(), getstate() must return (b\"\", 0).", "id": "f16912:c4:m3"}
{"signature": "def __init__(self, errors='<STR_LIT:strict>'):", "body": "self.errors = errors<EOL>", "docstring": "Creates an IncrementalDecoder instance.\n\nThe IncrementalDecoder may use different error handling schemes by\nproviding the errors keyword argument. See the module docstring\nfor a list of possible values.", "id": "f16912:c4:m0"}
{"signature": "def seek(self, offset, whence=<NUM_LIT:0>):", "body": "self.stream.seek(offset, whence)<EOL>self.reset()<EOL>", "docstring": "Set the input stream's current position.\n\n            Resets the codec buffers used for keeping state.", "id": "f16912:c7:m6"}
{"signature": "def __init__(self, stream, encode, decode, Reader, Writer,<EOL>errors='<STR_LIT:strict>'):", "body": "self.stream = stream<EOL>self.encode = encode<EOL>self.decode = decode<EOL>self.reader = Reader(stream, errors)<EOL>self.writer = Writer(stream, errors)<EOL>self.errors = errors<EOL>", "docstring": "Creates a StreamRecoder instance which implements a two-way\n            conversion: encode and decode work on the frontend (the\n            input to .read() and output of .write()) while\n            Reader and Writer work on the backend (reading and\n            writing to the stream).\n\n            You can use these objects to do transparent direct\n            recodings from e.g. latin-1 to utf-8 and back.\n\n            stream must be a file-like object.\n\n            encode, decode must adhere to the Codec interface, Reader,\n            Writer must be factory functions or classes providing the\n            StreamReader, StreamWriter interface resp.\n\n            encode and decode are needed for the frontend translation,\n            Reader and Writer for the backend translation. Unicode is\n            used as intermediate encoding.\n\n            Error handling is done in the same way as defined for the\n            StreamWriter/Readers.", "id": "f16912:c9:m0"}
{"signature": "def safe_repr(obj, short=False):", "body": "try:<EOL><INDENT>result = repr(obj)<EOL><DEDENT>except Exception:<EOL><INDENT>result = object.__repr__(obj)<EOL><DEDENT>if not short or len(result) < pkg_resources._MAX_LENGTH:<EOL><INDENT>return result<EOL><DEDENT>return result[:pkg_resources._MAX_LENGTH] + '<STR_LIT>'<EOL>", "docstring": "copied from Python2.7", "id": "f16915:m0"}
{"signature": "@classmethod<EOL><INDENT>def setup_class(cls):<DEDENT>", "body": "egg = tempfile.NamedTemporaryFile(suffix='<STR_LIT>', delete=False)<EOL>zip_egg = zipfile.ZipFile(egg, '<STR_LIT:w>')<EOL>zip_info = zipfile.ZipInfo()<EOL>zip_info.filename = '<STR_LIT>'<EOL>zip_info.date_time = cls.ref_time.timetuple()<EOL>zip_egg.writestr(zip_info, '<STR_LIT>')<EOL>zip_info = zipfile.ZipInfo()<EOL>zip_info.filename = '<STR_LIT>'<EOL>zip_info.date_time = cls.ref_time.timetuple()<EOL>zip_egg.writestr(zip_info, '<STR_LIT>')<EOL>zip_egg.close()<EOL>egg.close()<EOL>sys.path.append(egg.name)<EOL>cls.finalizers.append(EggRemover(egg.name))<EOL>", "docstring": "create a zip egg and add it to sys.path", "id": "f16916:c1:m0"}
{"signature": "@abc.abstractproperty<EOL><INDENT>def prereleases(self):<DEDENT>", "body": "", "docstring": "Returns whether or not pre-releases as a whole are allowed by this\nspecifier.", "id": "f16918:c1:m4"}
{"signature": "def __new__(cls, *args, **kwargs):", "body": "if hasattr(zipfile.ZipFile, '<STR_LIT>'):<EOL><INDENT>return zipfile.ZipFile(*args, **kwargs)<EOL><DEDENT>return super(ContextualZipFile, cls).__new__(cls)<EOL>", "docstring": "Construct a ZipFile or ContextualZipFile as appropriate", "id": "f16923:c22:m2"}
{"signature": "def find_eggs_in_zip(importer, path_item, only=False):", "body": "if importer.archive.endswith('<STR_LIT>'):<EOL><INDENT>return<EOL><DEDENT>metadata = EggMetadata(importer)<EOL>if metadata.has_metadata('<STR_LIT>'):<EOL><INDENT>yield Distribution.from_filename(path_item, metadata=metadata)<EOL><DEDENT>if only:<EOL><INDENT>return<EOL><DEDENT>for subitem in metadata.resource_listdir('<STR_LIT:/>'):<EOL><INDENT>if subitem.endswith('<STR_LIT>'):<EOL><INDENT>subpath = os.path.join(path_item, subitem)<EOL>for dist in find_eggs_in_zip(zipimport.zipimporter(subpath), subpath):<EOL><INDENT>yield dist<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Find eggs in zip files; possibly multiple nested eggs.", "id": "f16923:m27"}
{"signature": "def get_entry_info(dist, group, name):", "body": "return get_distribution(dist).get_entry_info(group, name)<EOL>", "docstring": "Return the EntryPoint object for `group`+`name`, or ``None``", "id": "f16923:m19"}
{"signature": "def safe_extra(extra):", "body": "return re.sub('<STR_LIT>', '<STR_LIT:_>', extra).lower()<EOL>", "docstring": "Convert an arbitrary string to a standard 'extra' name\n\n    Any runs of non-alphanumeric characters are replaced with a single '_',\n    and the result is always lowercased.", "id": "f16923:m23"}
{"signature": "def register_finder(importer_type, distribution_finder):", "body": "_distribution_finders[importer_type] = distribution_finder<EOL>", "docstring": "Register `distribution_finder` to find distributions in sys.path items\n\n    `importer_type` is the type or class of a PEP 302 \"Importer\" (sys.path item\n    handler), and `distribution_finder` is a callable that, passed a path\n    item and the importer instance, yields ``Distribution`` instances found on\n    that path item.  See ``pkg_resources.find_on_path`` for an example.", "id": "f16923:m25"}
{"signature": "def get_provider(moduleOrReq):", "body": "if isinstance(moduleOrReq, Requirement):<EOL><INDENT>return working_set.find(moduleOrReq) or require(str(moduleOrReq))[<NUM_LIT:0>]<EOL><DEDENT>try:<EOL><INDENT>module = sys.modules[moduleOrReq]<EOL><DEDENT>except KeyError:<EOL><INDENT>__import__(moduleOrReq)<EOL>module = sys.modules[moduleOrReq]<EOL><DEDENT>loader = getattr(module, '<STR_LIT>', None)<EOL>return _find_adapter(_provider_factories, loader)(module)<EOL>", "docstring": "Return an IResourceProvider for the named module or requirement", "id": "f16923:m10"}
{"signature": "@classmethod<EOL><INDENT>def parse_map(cls, data, dist=None):<DEDENT>", "body": "if isinstance(data, dict):<EOL><INDENT>data = data.items()<EOL><DEDENT>else:<EOL><INDENT>data = split_sections(data)<EOL><DEDENT>maps = {}<EOL>for group, lines in data:<EOL><INDENT>if group is None:<EOL><INDENT>if not lines:<EOL><INDENT>continue<EOL><DEDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>group = group.strip()<EOL>if group in maps:<EOL><INDENT>raise ValueError(\"<STR_LIT>\", group)<EOL><DEDENT>maps[group] = cls.parse_group(group, lines, dist)<EOL><DEDENT>return maps<EOL>", "docstring": "Parse a map of entry point groups", "id": "f16923:c27:m9"}
{"signature": "def _handle_ns(packageName, path_item):", "body": "importer = get_importer(path_item)<EOL>if importer is None:<EOL><INDENT>return None<EOL><DEDENT>loader = importer.find_module(packageName)<EOL>if loader is None:<EOL><INDENT>return None<EOL><DEDENT>module = sys.modules.get(packageName)<EOL>if module is None:<EOL><INDENT>module = sys.modules[packageName] = imp.new_module(packageName)<EOL>module.__path__ = []<EOL>_set_parent_ns(packageName)<EOL><DEDENT>elif not hasattr(module,'<STR_LIT>'):<EOL><INDENT>raise TypeError(\"<STR_LIT>\", packageName)<EOL><DEDENT>handler = _find_adapter(_namespace_handlers, importer)<EOL>subpath = handler(importer, path_item, packageName, module)<EOL>if subpath is not None:<EOL><INDENT>path = module.__path__<EOL>path.append(subpath)<EOL>loader.load_module(packageName)<EOL>for path_item in path:<EOL><INDENT>if path_item not in module.__path__:<EOL><INDENT>module.__path__.append(path_item)<EOL><DEDENT><DEDENT><DEDENT>return subpath<EOL>", "docstring": "Ensure that named package includes a subpath of path_item (if needed)", "id": "f16923:m31"}
{"signature": "def __init__(self, importer):", "body": "self.zip_pre = importer.archive+os.sep<EOL>self.loader = importer<EOL>if importer.prefix:<EOL><INDENT>self.module_path = os.path.join(importer.archive, importer.prefix)<EOL><DEDENT>else:<EOL><INDENT>self.module_path = importer.archive<EOL><DEDENT>self._setup_prefix()<EOL>", "docstring": "Create a metadata provider from a zipimporter", "id": "f16923:c26:m0"}
{"signature": "def find_plugins(self, plugin_env, full_env=None, installer=None,<EOL>fallback=True):", "body": "plugin_projects = list(plugin_env)<EOL>plugin_projects.sort()<EOL>error_info = {}<EOL>distributions = {}<EOL>if full_env is None:<EOL><INDENT>env = Environment(self.entries)<EOL>env += plugin_env<EOL><DEDENT>else:<EOL><INDENT>env = full_env + plugin_env<EOL><DEDENT>shadow_set = self.__class__([])<EOL>list(map(shadow_set.add, self))<EOL>for project_name in plugin_projects:<EOL><INDENT>for dist in plugin_env[project_name]:<EOL><INDENT>req = [dist.as_requirement()]<EOL>try:<EOL><INDENT>resolvees = shadow_set.resolve(req, env, installer)<EOL><DEDENT>except ResolutionError as v:<EOL><INDENT>error_info[dist] = v<EOL>if fallback:<EOL><INDENT>continue<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>list(map(shadow_set.add, resolvees))<EOL>distributions.update(dict.fromkeys(resolvees))<EOL>break<EOL><DEDENT><DEDENT><DEDENT>distributions = list(distributions)<EOL>distributions.sort()<EOL>return distributions, error_info<EOL>", "docstring": "Find all activatable distributions in `plugin_env`\n\n        Example usage::\n\n            distributions, errors = working_set.find_plugins(\n                Environment(plugin_dirlist)\n            )\n            # add plugins+libs to sys.path\n            map(working_set.add, distributions)\n            # display errors\n            print('Could not load', errors)\n\n        The `plugin_env` should be an ``Environment`` instance that contains\n        only distributions that are in the project's \"plugin directory\" or\n        directories. The `full_env`, if supplied, should be an ``Environment``\n        contains all currently-available distributions.  If `full_env` is not\n        supplied, one is created automatically from the ``WorkingSet`` this\n        method is called on, which will typically mean that every directory on\n        ``sys.path`` will be scanned for distributions.\n\n        `installer` is a standard installer callback as used by the\n        ``resolve()`` method. The `fallback` flag indicates whether we should\n        attempt to resolve older versions of a plugin if the newest version\n        cannot be resolved.\n\n        This method returns a 2-tuple: (`distributions`, `error_info`), where\n        `distributions` is a list of the distributions found in `plugin_env`\n        that were loadable, along with any other distributions that are needed\n        to resolve their dependencies.  `error_info` is a dictionary mapping\n        unloadable plugin distributions to an exception instance describing the\n        error that occurred. Usually this will be a ``DistributionNotFound`` or\n        ``VersionConflict`` instance.", "id": "f16923:c11:m11"}
{"signature": "def yield_lines(strs):", "body": "if isinstance(strs, string_types):<EOL><INDENT>for s in strs.splitlines():<EOL><INDENT>s = s.strip()<EOL>if s and not s.startswith('<STR_LIT:#>'):<EOL><INDENT>yield s<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for ss in strs:<EOL><INDENT>for s in yield_lines(ss):<EOL><INDENT>yield s<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Yield non-empty/non-comment lines of a string or sequence", "id": "f16923:m39"}
{"signature": "def __getitem__(self, project_name):", "body": "distribution_key = project_name.lower()<EOL>return self._distmap.get(distribution_key, [])<EOL>", "docstring": "Return a newest-to-oldest list of distributions for `project_name`\n\n        Uses case-insensitive `project_name` comparison, assuming all the\n        project's distributions use their project's name converted to all\n        lowercase as their key.", "id": "f16923:c12:m4"}
{"signature": "def resource_isdir(self, package_or_requirement, resource_name):", "body": "return get_provider(package_or_requirement).resource_isdir(<EOL>resource_name<EOL>)<EOL>", "docstring": "Is the named resource an existing directory?", "id": "f16923:c14:m2"}
{"signature": "def register_namespace_handler(importer_type, namespace_handler):", "body": "_namespace_handlers[importer_type] = namespace_handler<EOL>", "docstring": "Register `namespace_handler` to declare namespace packages\n\n    `importer_type` is the type or class of a PEP 302 \"Importer\" (sys.path item\n    handler), and `namespace_handler` is a callable like this::\n\n        def namespace_handler(importer, path_entry, moduleName, module):\n            # return a path_entry to use for child packages\n\n    Namespace handlers are only called if the importer object has already\n    agreed that it can handle the relevant path item, and they should only\n    return a subpath if the module __path__ does not already contain an\n    equivalent subpath.  For an example namespace handler, see\n    ``pkg_resources.file_ns_handler``.", "id": "f16923:m30"}
{"signature": "def run_script(dist_spec, script_name):", "body": "ns = sys._getframe(<NUM_LIT:1>).f_globals<EOL>name = ns['<STR_LIT>']<EOL>ns.clear()<EOL>ns['<STR_LIT>'] = name<EOL>require(dist_spec)[<NUM_LIT:0>].run_script(script_name, ns)<EOL>", "docstring": "Locate distribution `dist_spec` and run its `script_name` script", "id": "f16923:m15"}
{"signature": "def add(self, dist, entry=None, insert=True, replace=False):", "body": "if insert:<EOL><INDENT>dist.insert_on(self.entries, entry)<EOL><DEDENT>if entry is None:<EOL><INDENT>entry = dist.location<EOL><DEDENT>keys = self.entry_keys.setdefault(entry,[])<EOL>keys2 = self.entry_keys.setdefault(dist.location,[])<EOL>if not replace and dist.key in self.by_key:<EOL><INDENT>return<EOL><DEDENT>self.by_key[dist.key] = dist<EOL>if dist.key not in keys:<EOL><INDENT>keys.append(dist.key)<EOL><DEDENT>if dist.key not in keys2:<EOL><INDENT>keys2.append(dist.key)<EOL><DEDENT>self._added_new(dist)<EOL>", "docstring": "Add `dist` to working set, associated with `entry`\n\n        If `entry` is unspecified, it defaults to the ``.location`` of `dist`.\n        On exit from this routine, `entry` is added to the end of the working\n        set's ``.entries`` (if it wasn't already present).\n\n        `dist` is only added to the working set if it's for a project that\n        doesn't already have a distribution in the set, unless `replace=True`.\n        If it's added, any callbacks registered with the ``subscribe()`` method\n        will be called.", "id": "f16923:c11:m9"}
{"signature": "@classmethod<EOL><INDENT>def _build_master(cls):<DEDENT>", "body": "ws = cls()<EOL>try:<EOL><INDENT>from __main__ import __requires__<EOL><DEDENT>except ImportError:<EOL><INDENT>return ws<EOL><DEDENT>try:<EOL><INDENT>ws.require(__requires__)<EOL><DEDENT>except VersionConflict:<EOL><INDENT>return cls._build_from_requirements(__requires__)<EOL><DEDENT>return ws<EOL>", "docstring": "Prepare the master working set.", "id": "f16923:c11:m1"}
{"signature": "def get_default_cache():", "body": "try:<EOL><INDENT>return os.environ['<STR_LIT>']<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>if os.name!='<STR_LIT>':<EOL><INDENT>return os.path.expanduser('<STR_LIT>')<EOL><DEDENT>app_data = '<STR_LIT>'<EOL>app_homes = [<EOL>(('<STR_LIT>',), None),<EOL>(('<STR_LIT>',), app_data),<EOL>(('<STR_LIT>','<STR_LIT>'), app_data),<EOL>(('<STR_LIT>',), app_data),<EOL>(('<STR_LIT>',), None),<EOL>(('<STR_LIT>',), app_data),<EOL>]<EOL>for keys, subdir in app_homes:<EOL><INDENT>dirname = '<STR_LIT>'<EOL>for key in keys:<EOL><INDENT>if key in os.environ:<EOL><INDENT>dirname = os.path.join(dirname, os.environ[key])<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if subdir:<EOL><INDENT>dirname = os.path.join(dirname, subdir)<EOL><DEDENT>return os.path.join(dirname, '<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise RuntimeError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>", "docstring": "Determine the default cache location\n\n    This returns the ``PYTHON_EGG_CACHE`` environment variable, if set.\n    Otherwise, on Windows, it returns a \"Python-Eggs\" subdirectory of the\n    \"Application Data\" directory.  On all other systems, it's \"~/.python-eggs\".", "id": "f16923:m20"}
{"signature": "def resource_listdir(resource_name):", "body": "", "docstring": "List of resource names in the directory (like ``os.listdir()``)", "id": "f16923:c10:m5"}
{"signature": "def get_resource_stream(manager, resource_name):", "body": "", "docstring": "Return a readable file-like object for `resource_name`\n\n        `manager` must be an ``IResourceManager``", "id": "f16923:c10:m1"}
{"signature": "def _bypass_ensure_directory(path, mode=<NUM_LIT>):", "body": "if not WRITE_SUPPORT:<EOL><INDENT>raise IOError('<STR_LIT>')<EOL><DEDENT>dirname, filename = split(path)<EOL>if dirname and filename and not isdir(dirname):<EOL><INDENT>_bypass_ensure_directory(dirname)<EOL>mkdir(dirname, mode)<EOL><DEDENT>", "docstring": "Sandbox-bypassing version of ensure_directory()", "id": "f16923:m46"}
{"signature": "def get_build_platform():", "body": "try:<EOL><INDENT>from sysconfig import get_platform<EOL><DEDENT>except ImportError:<EOL><INDENT>from distutils.util import get_platform<EOL><DEDENT>plat = get_platform()<EOL>if sys.platform == \"<STR_LIT>\" and not plat.startswith('<STR_LIT>'):<EOL><INDENT>try:<EOL><INDENT>version = _macosx_vers()<EOL>machine = os.uname()[<NUM_LIT:4>].replace(\"<STR_LIT:U+0020>\", \"<STR_LIT:_>\")<EOL>return \"<STR_LIT>\" % (int(version[<NUM_LIT:0>]), int(version[<NUM_LIT:1>]),<EOL>_macosx_arch(machine))<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return plat<EOL>", "docstring": "Return this platform's string for platform-specific distributions\n\n    XXX Currently this is the same as ``distutils.util.get_platform()``, but it\n    needs some hacks for Linux and Mac OS X.", "id": "f16923:m13"}
{"signature": "def as_requirement(self):", "body": "if isinstance(self.parsed_version, packaging.version.Version):<EOL><INDENT>spec = \"<STR_LIT>\" % (self.project_name, self.parsed_version)<EOL><DEDENT>else:<EOL><INDENT>spec = \"<STR_LIT>\" % (self.project_name, self.parsed_version)<EOL><DEDENT>return Requirement.parse(spec)<EOL>", "docstring": "Return a ``Requirement`` that matches this distribution exactly", "id": "f16923:c28:m22"}
{"signature": "def __iter__(self):", "body": "for key in self._distmap.keys():<EOL><INDENT>if self[key]:<EOL><INDENT>yield key<EOL><DEDENT><DEDENT>", "docstring": "Yield the unique project names of the available distributions", "id": "f16923:c12:m8"}
{"signature": "def file_ns_handler(importer, path_item, packageName, module):", "body": "subpath = os.path.join(path_item, packageName.split('<STR_LIT:.>')[-<NUM_LIT:1>])<EOL>normalized = _normalize_cached(subpath)<EOL>for item in module.__path__:<EOL><INDENT>if _normalize_cached(item)==normalized:<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return subpath<EOL><DEDENT>", "docstring": "Compute an ns-package subpath for a filesystem or zipfile importer", "id": "f16923:m34"}
{"signature": "def require(self, *requirements):", "body": "needed = self.resolve(parse_requirements(requirements))<EOL>for dist in needed:<EOL><INDENT>self.add(dist)<EOL><DEDENT>return needed<EOL>", "docstring": "Ensure that distributions matching `requirements` are activated\n\n        `requirements` must be a string or a (possibly-nested) sequence\n        thereof, specifying the distributions and versions required.  The\n        return value is a sequence of the distributions that needed to be\n        activated to fulfill the requirements; all relevant distributions are\n        included, even if they were already activated in this working set.", "id": "f16923:c11:m12"}
{"signature": "def load(self, require=True, *args, **kwargs):", "body": "if not require or args or kwargs:<EOL><INDENT>warnings.warn(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>DeprecationWarning,<EOL>stacklevel=<NUM_LIT:2>,<EOL>)<EOL><DEDENT>if require:<EOL><INDENT>self.require(*args, **kwargs)<EOL><DEDENT>return self.resolve()<EOL>", "docstring": "Require packages for this EntryPoint, then resolve it.", "id": "f16923:c27:m3"}
{"signature": "def resource_listdir(self, package_or_requirement, resource_name):", "body": "return get_provider(package_or_requirement).resource_listdir(<EOL>resource_name<EOL>)<EOL>", "docstring": "List the contents of the named resource directory", "id": "f16923:c14:m6"}
{"signature": "def can_add(self, dist):", "body": "return (self.python is None or dist.py_version is None<EOL>or dist.py_version==self.python)and compatible_platforms(dist.platform, self.platform)<EOL>", "docstring": "Is distribution `dist` acceptable for this environment?\n\n        The distribution must match the platform and python version\n        requirements specified when this environment was created, or False\n        is returned.", "id": "f16923:c12:m1"}
{"signature": "def resolve(self):", "body": "module = __import__(self.module_name, fromlist=['<STR_LIT>'], level=<NUM_LIT:0>)<EOL>try:<EOL><INDENT>return functools.reduce(getattr, self.attrs, module)<EOL><DEDENT>except AttributeError as exc:<EOL><INDENT>raise ImportError(str(exc))<EOL><DEDENT>", "docstring": "Resolve the entry point from its module and attrs.", "id": "f16923:c27:m4"}
{"signature": "def register_loader_type(loader_type, provider_factory):", "body": "_provider_factories[loader_type] = provider_factory<EOL>", "docstring": "Register `provider_factory` to make providers for `loader_type`\n\n    `loader_type` is the type or class of a PEP 302 ``module.__loader__``,\n    and `provider_factory` is a function that, passed a *module* object,\n    returns an ``IResourceProvider`` for that module.", "id": "f16923:m9"}
{"signature": "def has_metadata(name):", "body": "", "docstring": "Does the package's distribution contain the named metadata?", "id": "f16923:c9:m0"}
{"signature": "def values(self):", "body": "return list(self.itervalues())<EOL>", "docstring": "Dict-like values() that returns a list of values of cookies from the\n        jar. See keys() and items().", "id": "f16925:c3:m5"}
{"signature": "def merge_cookies(cookiejar, cookies):", "body": "if not isinstance(cookiejar, cookielib.CookieJar):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if isinstance(cookies, dict):<EOL><INDENT>cookiejar = cookiejar_from_dict(<EOL>cookies, cookiejar=cookiejar, overwrite=False)<EOL><DEDENT>elif isinstance(cookies, cookielib.CookieJar):<EOL><INDENT>try:<EOL><INDENT>cookiejar.update(cookies)<EOL><DEDENT>except AttributeError:<EOL><INDENT>for cookie_in_jar in cookies:<EOL><INDENT>cookiejar.set_cookie(cookie_in_jar)<EOL><DEDENT><DEDENT><DEDENT>return cookiejar<EOL>", "docstring": "Add cookies to cookiejar and returns a merged CookieJar.\n\n    :param cookiejar: CookieJar object to add the cookies to.\n    :param cookies: Dictionary or CookieJar object to be added.", "id": "f16925:m6"}
{"signature": "def get_dict(self, domain=None, path=None):", "body": "dictionary = {}<EOL>for cookie in iter(self):<EOL><INDENT>if (domain is None or cookie.domain == domain) and (path is None<EOL>or cookie.path == path):<EOL><INDENT>dictionary[cookie.name] = cookie.value<EOL><DEDENT><DEDENT>return dictionary<EOL>", "docstring": "Takes as an argument an optional domain and path and returns a plain\n        old Python dict of name-value pairs of cookies that meet the\n        requirements.", "id": "f16925:c3:m11"}
{"signature": "def __delitem__(self, name):", "body": "remove_cookie_by_name(self, name)<EOL>", "docstring": "Deletes a cookie given a name. Wraps ``cookielib.CookieJar``'s\n        ``remove_cookie_by_name()``.", "id": "f16925:c3:m14"}
{"signature": "def copy(self):", "body": "new_cj = RequestsCookieJar()<EOL>new_cj.update(self)<EOL>return new_cj<EOL>", "docstring": "Return a copy of this RequestsCookieJar.", "id": "f16925:c3:m21"}
{"signature": "def morsel_to_cookie(morsel):", "body": "expires = None<EOL>if morsel['<STR_LIT>']:<EOL><INDENT>expires = time.time() + morsel['<STR_LIT>']<EOL><DEDENT>elif morsel['<STR_LIT>']:<EOL><INDENT>time_template = '<STR_LIT>'<EOL>expires = time.mktime(<EOL>time.strptime(morsel['<STR_LIT>'], time_template)) - time.timezone<EOL><DEDENT>return create_cookie(<EOL>comment=morsel['<STR_LIT>'],<EOL>comment_url=bool(morsel['<STR_LIT>']),<EOL>discard=False,<EOL>domain=morsel['<STR_LIT>'],<EOL>expires=expires,<EOL>name=morsel.key,<EOL>path=morsel['<STR_LIT:path>'],<EOL>port=None,<EOL>rest={'<STR_LIT>': morsel['<STR_LIT>']},<EOL>rfc2109=False,<EOL>secure=bool(morsel['<STR_LIT>']),<EOL>value=morsel.value,<EOL>version=morsel['<STR_LIT:version>'] or <NUM_LIT:0>,<EOL>)<EOL>", "docstring": "Convert a Morsel object into a Cookie containing the one k/v pair.", "id": "f16925:m4"}
{"signature": "def __setstate__(self, state):", "body": "self.__dict__.update(state)<EOL>if '<STR_LIT>' not in self.__dict__:<EOL><INDENT>self._cookies_lock = threading.RLock()<EOL><DEDENT>", "docstring": "Unlike a normal CookieJar, this class is pickleable.", "id": "f16925:c3:m20"}
{"signature": "def feed(self, aBuf, aCharLen):", "body": "if aCharLen == <NUM_LIT:2>:<EOL><INDENT>order = self.get_order(aBuf)<EOL><DEDENT>else:<EOL><INDENT>order = -<NUM_LIT:1><EOL><DEDENT>if order >= <NUM_LIT:0>:<EOL><INDENT>self._mTotalChars += <NUM_LIT:1><EOL>if order < self._mTableSize:<EOL><INDENT>if <NUM_LIT> > self._mCharToFreqOrder[order]:<EOL><INDENT>self._mFreqChars += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>", "docstring": "feed a character with known length", "id": "f16929:c0:m2"}
{"signature": "def main(argv=None):", "body": "<EOL>parser = argparse.ArgumentParser(<EOL>description=\"<STR_LIT>\",<EOL>formatter_class=argparse.ArgumentDefaultsHelpFormatter,<EOL>conflict_handler='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT:input>',<EOL>help='<STR_LIT>',<EOL>type=argparse.FileType('<STR_LIT:rb>'), nargs='<STR_LIT:*>',<EOL>default=[sys.stdin])<EOL>parser.add_argument('<STR_LIT>', action='<STR_LIT:version>',<EOL>version='<STR_LIT>'.format(__version__))<EOL>args = parser.parse_args(argv)<EOL>for f in args.input:<EOL><INDENT>if f.isatty():<EOL><INDENT>print(\"<STR_LIT>\" +<EOL>\"<STR_LIT>\" +<EOL>\"<STR_LIT>\" +<EOL>\"<STR_LIT>\", file=sys.stderr)<EOL><DEDENT>print(description_of(f, f.name))<EOL><DEDENT>", "docstring": "Handles command line arguments and gets things started.\n\n:param argv: List of arguments, as if specified on the command-line.\n             If None, ``sys.argv[1:]`` is used instead.\n:type argv: list of str", "id": "f16938:m1"}
{"signature": "def inject_into_urllib3():", "body": "connection.ssl_wrap_socket = ssl_wrap_socket<EOL>util.HAS_SNI = HAS_SNI<EOL>", "docstring": "Monkey-patch urllib3 with PyOpenSSL-backed SSL-support.", "id": "f16966:m0"}
{"signature": "def _make_request(self, conn, method, url, timeout=_Default,<EOL>**httplib_request_kw):", "body": "self.num_requests += <NUM_LIT:1><EOL>timeout_obj = self._get_timeout(timeout)<EOL>timeout_obj.start_connect()<EOL>conn.timeout = timeout_obj.connect_timeout<EOL>try:<EOL><INDENT>self._validate_conn(conn)<EOL><DEDENT>except (SocketTimeout, BaseSSLError) as e:<EOL><INDENT>self._raise_timeout(err=e, url=url, timeout_value=conn.timeout)<EOL>raise<EOL><DEDENT>conn.request(method, url, **httplib_request_kw)<EOL>read_timeout = timeout_obj.read_timeout<EOL>if getattr(conn, '<STR_LIT>', None):<EOL><INDENT>if read_timeout == <NUM_LIT:0>:<EOL><INDENT>raise ReadTimeoutError(<EOL>self, url, \"<STR_LIT>\" % read_timeout)<EOL><DEDENT>if read_timeout is Timeout.DEFAULT_TIMEOUT:<EOL><INDENT>conn.sock.settimeout(socket.getdefaulttimeout())<EOL><DEDENT>else:  <EOL><INDENT>conn.sock.settimeout(read_timeout)<EOL><DEDENT><DEDENT>try:<EOL><INDENT>try:  <EOL><INDENT>httplib_response = conn.getresponse(buffering=True)<EOL><DEDENT>except TypeError:  <EOL><INDENT>httplib_response = conn.getresponse()<EOL><DEDENT><DEDENT>except (SocketTimeout, BaseSSLError, SocketError) as e:<EOL><INDENT>self._raise_timeout(err=e, url=url, timeout_value=read_timeout)<EOL>raise<EOL><DEDENT>http_version = getattr(conn, '<STR_LIT>', '<STR_LIT>')<EOL>log.debug(\"<STR_LIT>\" % (method, url, http_version,<EOL>httplib_response.status,<EOL>httplib_response.length))<EOL>return httplib_response<EOL>", "docstring": "Perform a request on a given urllib connection object taken from our\npool.\n\n:param conn:\n    a connection from one of our connection pools\n\n:param timeout:\n    Socket timeout in seconds for the request. This can be a\n    float or integer, which will set the same timeout value for\n    the socket connect and the socket read, or an instance of\n    :class:`urllib3.util.Timeout`, which gives you more fine-grained\n    control over your timeouts.", "id": "f16969:c1:m8"}
{"signature": "def _prepare_proxy(self, conn):", "body": "<EOL>try:<EOL><INDENT>set_tunnel = conn.set_tunnel<EOL><DEDENT>except AttributeError:  <EOL><INDENT>set_tunnel = conn._set_tunnel<EOL><DEDENT>if sys.version_info <= (<NUM_LIT:2>, <NUM_LIT:6>, <NUM_LIT:4>) and not self.proxy_headers:   <EOL><INDENT>set_tunnel(self.host, self.port)<EOL><DEDENT>else:<EOL><INDENT>set_tunnel(self.host, self.port, self.proxy_headers)<EOL><DEDENT>conn.connect()<EOL>", "docstring": "Establish tunnel connection early, because otherwise httplib\nwould improperly set Host: header to proxy's IP:port.", "id": "f16969:c2:m2"}
{"signature": "def _get_timeout(self, timeout):", "body": "if timeout is _Default:<EOL><INDENT>return self.timeout.clone()<EOL><DEDENT>if isinstance(timeout, Timeout):<EOL><INDENT>return timeout.clone()<EOL><DEDENT>else:<EOL><INDENT>return Timeout.from_float(timeout)<EOL><DEDENT>", "docstring": "Helper that always returns a :class:`urllib3.util.Timeout`", "id": "f16969:c1:m6"}
{"signature": "def clear(self):", "body": "try:<EOL><INDENT>for node in self.__map.itervalues():<EOL><INDENT>del node[:]<EOL><DEDENT>root = self.__root<EOL>root[:] = [root, root, None]<EOL>self.__map.clear()<EOL><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT>dict.clear(self)<EOL>", "docstring": "od.clear() -> None.  Remove all items from od.", "id": "f16971:c0:m5"}
{"signature": "def setdefault(self, key, default=None):", "body": "if key in self:<EOL><INDENT>return self[key]<EOL><DEDENT>self[key] = default<EOL>return default<EOL>", "docstring": "od.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in od", "id": "f16971:c0:m15"}
{"signature": "def __reversed__(self):", "body": "root = self.__root<EOL>curr = root[<NUM_LIT:0>]<EOL>while curr is not root:<EOL><INDENT>yield curr[<NUM_LIT:2>]<EOL>curr = curr[<NUM_LIT:0>]<EOL><DEDENT>", "docstring": "od.__reversed__() <==> reversed(od)", "id": "f16971:c0:m4"}
{"signature": "def items(self):", "body": "return [(key, self[key]) for key in self]<EOL>", "docstring": "od.items() -> list of (key, value) pairs in od", "id": "f16971:c0:m9"}
{"signature": "def keys(self):", "body": "return list(self)<EOL>", "docstring": "od.keys() -> list of keys in od", "id": "f16971:c0:m7"}
{"signature": "def __eq__(self, other):", "body": "if isinstance(other, OrderedDict):<EOL><INDENT>return len(self)==len(other) and self.items() == other.items()<EOL><DEDENT>return dict.__eq__(self, other)<EOL>", "docstring": "od.__eq__(y) <==> od==y.  Comparison to another OD is order-sensitive\n        while comparison to a regular mapping is order-insensitive.", "id": "f16971:c0:m20"}
{"signature": "def match_hostname(cert, hostname):", "body": "if not cert:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>dnsnames = []<EOL>san = cert.get('<STR_LIT>', ())<EOL>for key, value in san:<EOL><INDENT>if key == '<STR_LIT>':<EOL><INDENT>if _dnsname_match(value, hostname):<EOL><INDENT>return<EOL><DEDENT>dnsnames.append(value)<EOL><DEDENT><DEDENT>if not dnsnames:<EOL><INDENT>for sub in cert.get('<STR_LIT>', ()):<EOL><INDENT>for key, value in sub:<EOL><INDENT>if key == '<STR_LIT>':<EOL><INDENT>if _dnsname_match(value, hostname):<EOL><INDENT>return<EOL><DEDENT>dnsnames.append(value)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if len(dnsnames) > <NUM_LIT:1>:<EOL><INDENT>raise CertificateError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>% (hostname, '<STR_LIT:U+002CU+0020>'.join(map(repr, dnsnames))))<EOL><DEDENT>elif len(dnsnames) == <NUM_LIT:1>:<EOL><INDENT>raise CertificateError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>% (hostname, dnsnames[<NUM_LIT:0>]))<EOL><DEDENT>else:<EOL><INDENT>raise CertificateError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Verify that *cert* (in decoded format as returned by\n    SSLSocket.getpeercert()) matches the *hostname*.  RFC 2818 and RFC 6125\n    rules are followed, but IP addresses are not accepted for *hostname*.\n\n    CertificateError is raised on failure. On success, the function\n    returns nothing.", "id": "f16972:m1"}
{"signature": "def iter_field_objects(fields):", "body": "if isinstance(fields, dict):<EOL><INDENT>i = six.iteritems(fields)<EOL><DEDENT>else:<EOL><INDENT>i = iter(fields)<EOL><DEDENT>for field in i:<EOL><INDENT>if isinstance(field, RequestField):<EOL><INDENT>yield field<EOL><DEDENT>else:<EOL><INDENT>yield RequestField.from_tuples(*field)<EOL><DEDENT><DEDENT>", "docstring": "Iterate over fields.\n\nSupports list of (k, v) tuples and dicts, and lists of\n:class:`~urllib3.fields.RequestField`.", "id": "f16976:m1"}
{"signature": "def guess_content_type(filename, default='<STR_LIT>'):", "body": "if filename:<EOL><INDENT>return mimetypes.guess_type(filename)[<NUM_LIT:0>] or default<EOL><DEDENT>return default<EOL>", "docstring": "Guess the \"Content-Type\" of a file.\n\n:param filename:\n    The filename to guess the \"Content-Type\" of using :mod:`mimetypes`.\n:param default:\n    If no \"Content-Type\" can be guessed, default to `default`.", "id": "f16977:m0"}
{"signature": "def render_headers(self):", "body": "lines = []<EOL>sort_keys = ['<STR_LIT>', '<STR_LIT:Content-Type>', '<STR_LIT>']<EOL>for sort_key in sort_keys:<EOL><INDENT>if self.headers.get(sort_key, False):<EOL><INDENT>lines.append('<STR_LIT>' % (sort_key, self.headers[sort_key]))<EOL><DEDENT><DEDENT>for header_name, header_value in self.headers.items():<EOL><INDENT>if header_name not in sort_keys:<EOL><INDENT>if header_value:<EOL><INDENT>lines.append('<STR_LIT>' % (header_name, header_value))<EOL><DEDENT><DEDENT><DEDENT>lines.append('<STR_LIT:\\r\\n>')<EOL>return '<STR_LIT:\\r\\n>'.join(lines)<EOL>", "docstring": "Renders the headers for this request field.", "id": "f16977:c0:m4"}
{"signature": "def make_multipart(self, content_disposition=None, content_type=None,<EOL>content_location=None):", "body": "self.headers['<STR_LIT>'] = content_disposition or '<STR_LIT>'<EOL>self.headers['<STR_LIT>'] += '<STR_LIT>'.join([<EOL>'<STR_LIT>', self._render_parts(<EOL>(('<STR_LIT:name>', self._name), ('<STR_LIT:filename>', self._filename))<EOL>)<EOL>])<EOL>self.headers['<STR_LIT:Content-Type>'] = content_type<EOL>self.headers['<STR_LIT>'] = content_location<EOL>", "docstring": "Makes this request field into a multipart request field.\n\nThis method overrides \"Content-Disposition\", \"Content-Type\" and\n\"Content-Location\" headers to the request parameter.\n\n:param content_type:\n    The 'Content-Type' of the request body.\n:param content_location:\n    The 'Content-Location' of the request body.", "id": "f16977:c0:m5"}
{"signature": "def assert_fingerprint(cert, fingerprint):", "body": "<EOL>hashfunc_map = {<EOL><NUM_LIT:16>: md5,<EOL><NUM_LIT:20>: sha1,<EOL><NUM_LIT:32>: sha256,<EOL>}<EOL>fingerprint = fingerprint.replace('<STR_LIT::>', '<STR_LIT>').lower()<EOL>digest_length, odd = divmod(len(fingerprint), <NUM_LIT:2>)<EOL>if odd or digest_length not in hashfunc_map:<EOL><INDENT>raise SSLError('<STR_LIT>')<EOL><DEDENT>fingerprint_bytes = unhexlify(fingerprint.encode())<EOL>hashfunc = hashfunc_map[digest_length]<EOL>cert_digest = hashfunc(cert).digest()<EOL>if not cert_digest == fingerprint_bytes:<EOL><INDENT>raise SSLError('<STR_LIT>'<EOL>.format(hexlify(fingerprint_bytes),<EOL>hexlify(cert_digest)))<EOL><DEDENT>", "docstring": "Checks if given fingerprint matches the supplied certificate.\n\n:param cert:\n    Certificate as bytes object.\n:param fingerprint:\n    Fingerprint as string of hexdigits, can be interspersed by colons.", "id": "f16979:m0"}
{"signature": "def ssl_wrap_socket(sock, keyfile=None, certfile=None, cert_reqs=None,<EOL>ca_certs=None, server_hostname=None,<EOL>ssl_version=None, ciphers=None, ssl_context=None):", "body": "context = ssl_context<EOL>if context is None:<EOL><INDENT>context = create_urllib3_context(ssl_version, cert_reqs,<EOL>ciphers=ciphers)<EOL><DEDENT>if ca_certs:<EOL><INDENT>try:<EOL><INDENT>context.load_verify_locations(ca_certs)<EOL><DEDENT>except IOError as e:  <EOL><INDENT>raise SSLError(e)<EOL><DEDENT>except OSError as e:  <EOL><INDENT>if e.errno == errno.ENOENT:<EOL><INDENT>raise SSLError(e)<EOL><DEDENT>raise<EOL><DEDENT><DEDENT>if certfile:<EOL><INDENT>context.load_cert_chain(certfile, keyfile)<EOL><DEDENT>if HAS_SNI:  <EOL><INDENT>return context.wrap_socket(sock, server_hostname=server_hostname)<EOL><DEDENT>return context.wrap_socket(sock)<EOL>", "docstring": "All arguments except for server_hostname and ssl_context have the same\nmeaning as they do when using :func:`ssl.wrap_socket`.\n\n:param server_hostname:\n    When SNI is supported, the expected hostname of the certificate\n:param ssl_context:\n    A pre-made :class:`SSLContext` object. If none is provided, one will\n    be created using :func:`create_urllib3_context`.\n:param ciphers:\n    A string of ciphers we wish the client to support. This is not\n    supported on Python 2.6 as the ssl module does not support it.", "id": "f16979:m4"}
{"signature": "def resolve_ssl_version(candidate):", "body": "if candidate is None:<EOL><INDENT>return PROTOCOL_SSLv23<EOL><DEDENT>if isinstance(candidate, str):<EOL><INDENT>res = getattr(ssl, candidate, None)<EOL>if res is None:<EOL><INDENT>res = getattr(ssl, '<STR_LIT>' + candidate)<EOL><DEDENT>return res<EOL><DEDENT>return candidate<EOL>", "docstring": "like resolve_cert_reqs", "id": "f16979:m2"}
{"signature": "def get_backoff_time(self):", "body": "if self._observed_errors <= <NUM_LIT:1>:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>backoff_value = self.backoff_factor * (<NUM_LIT:2> ** (self._observed_errors - <NUM_LIT:1>))<EOL>return min(self.BACKOFF_MAX, backoff_value)<EOL>", "docstring": "Formula for computing the current backoff\n\n        :rtype: float", "id": "f16980:c0:m3"}
{"signature": "@property<EOL><INDENT>def read_timeout(self):<DEDENT>", "body": "if (self.total is not None and<EOL>self.total is not self.DEFAULT_TIMEOUT and<EOL>self._read is not None and<EOL>self._read is not self.DEFAULT_TIMEOUT):<EOL><INDENT>if self._start_connect is None:<EOL><INDENT>return self._read<EOL><DEDENT>return max(<NUM_LIT:0>, min(self.total - self.get_connect_duration(),<EOL>self._read))<EOL><DEDENT>elif self.total is not None and self.total is not self.DEFAULT_TIMEOUT:<EOL><INDENT>return max(<NUM_LIT:0>, self.total - self.get_connect_duration())<EOL><DEDENT>else:<EOL><INDENT>return self._read<EOL><DEDENT>", "docstring": "Get the value for the read timeout.\n\n        This assumes some time has elapsed in the connection timeout and\n        computes the read timeout appropriately.\n\n        If self.total is set, the read timeout is dependent on the amount of\n        time taken by the connect timeout. If the connection time has not been\n        established, a :exc:`~urllib3.exceptions.TimeoutStateError` will be\n        raised.\n\n        :return: Value to use for the read timeout.\n        :rtype: int, float, :attr:`Timeout.DEFAULT_TIMEOUT` or None\n        :raises urllib3.exceptions.TimeoutStateError: If :meth:`start_connect`\n            has not yet been called on this object.", "id": "f16982:c0:m8"}
{"signature": "def get_connect_duration(self):", "body": "if self._start_connect is None:<EOL><INDENT>raise TimeoutStateError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>return current_time() - self._start_connect<EOL>", "docstring": "Gets the time elapsed since the call to :meth:`start_connect`.\n\n        :return: Elapsed time.\n        :rtype: float\n        :raises urllib3.exceptions.TimeoutStateError: if you attempt\n            to get duration for a timer that hasn't been started.", "id": "f16982:c0:m6"}
{"signature": "@property<EOL><INDENT>def connect_timeout(self):<DEDENT>", "body": "if self.total is None:<EOL><INDENT>return self._connect<EOL><DEDENT>if self._connect is None or self._connect is self.DEFAULT_TIMEOUT:<EOL><INDENT>return self.total<EOL><DEDENT>return min(self._connect, self.total)<EOL>", "docstring": "Get the value to use when setting a connection timeout.\n\n        This will be a positive float or integer, the value None\n        (never timeout), or the default system timeout.\n\n        :return: Connect timeout.\n        :rtype: int, float, :attr:`Timeout.DEFAULT_TIMEOUT` or None", "id": "f16982:c0:m7"}
{"signature": "def get_host(url):", "body": "p = parse_url(url)<EOL>return p.scheme or '<STR_LIT:http>', p.hostname, p.port<EOL>", "docstring": "Deprecated. Use :func:`.parse_url` instead.", "id": "f16984:m2"}
{"signature": "def split_first(s, delims):", "body": "min_idx = None<EOL>min_delim = None<EOL>for d in delims:<EOL><INDENT>idx = s.find(d)<EOL>if idx < <NUM_LIT:0>:<EOL><INDENT>continue<EOL><DEDENT>if min_idx is None or idx < min_idx:<EOL><INDENT>min_idx = idx<EOL>min_delim = d<EOL><DEDENT><DEDENT>if min_idx is None or min_idx < <NUM_LIT:0>:<EOL><INDENT>return s, '<STR_LIT>', None<EOL><DEDENT>return s[:min_idx], s[min_idx+<NUM_LIT:1>:], min_delim<EOL>", "docstring": "Given a string and an iterable of delimiters, split on the first found\ndelimiter. Return two split parts and the matched delimiter.\n\nIf not found, then the first part is the full input string.\n\nExample::\n\n    >>> split_first('foo/bar?baz', '?/=')\n    ('foo', 'bar?baz', '/')\n    >>> split_first('foo/bar?baz', '123')\n    ('foo/bar?baz', '', None)\n\nScales linearly with number of delims. Not ideal for large number of delims.", "id": "f16984:m0"}
{"signature": "def is_fp_closed(obj):", "body": "try:<EOL><INDENT>return obj.closed<EOL><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>return obj.fp is None<EOL><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT>raise ValueError(\"<STR_LIT>\")<EOL>", "docstring": "Checks whether a given file-like object is closed.\n\n:param obj:\n    The file-like object to check.", "id": "f16985:m0"}
{"signature": "def urlopen(self, method, url, redirect=True, **kw):", "body": "u = parse_url(url)<EOL>if u.scheme == \"<STR_LIT:http>\":<EOL><INDENT>headers = kw.get('<STR_LIT>', self.headers)<EOL>kw['<STR_LIT>'] = self._set_proxy_headers(url, headers)<EOL><DEDENT>return super(ProxyManager, self).urlopen(method, url, redirect=redirect, **kw)<EOL>", "docstring": "Same as HTTP(S)ConnectionPool.urlopen, ``url`` must be absolute.", "id": "f16986:c1:m3"}
{"signature": "def clear(self):", "body": "self.pools.clear()<EOL>", "docstring": "Empty our store of pools and direct them all to close.\n\nThis will not affect in-flight connections, but they will not be\nre-used after completion.", "id": "f16986:c0:m4"}
{"signature": "def connection_from_host(self, host, port=None, scheme='<STR_LIT:http>'):", "body": "if not host:<EOL><INDENT>raise LocationValueError(\"<STR_LIT>\")<EOL><DEDENT>scheme = scheme or '<STR_LIT:http>'<EOL>port = port or port_by_scheme.get(scheme, <NUM_LIT>)<EOL>pool_key = (scheme, host, port)<EOL>with self.pools.lock:<EOL><INDENT>pool = self.pools.get(pool_key)<EOL>if pool:<EOL><INDENT>return pool<EOL><DEDENT>pool = self._new_pool(scheme, host, port)<EOL>self.pools[pool_key] = pool<EOL><DEDENT>return pool<EOL>", "docstring": "Get a :class:`ConnectionPool` based on the host, port, and scheme.\n\nIf ``port`` isn't given, it will be derived from the ``scheme`` using\n``urllib3.connectionpool.port_by_scheme``.", "id": "f16986:c0:m5"}
{"signature": "def urlopen(self, method, url, redirect=True, **kw):", "body": "u = parse_url(url)<EOL>conn = self.connection_from_host(u.host, port=u.port, scheme=u.scheme)<EOL>kw['<STR_LIT>'] = False<EOL>kw['<STR_LIT>'] = False<EOL>if '<STR_LIT>' not in kw:<EOL><INDENT>kw['<STR_LIT>'] = self.headers<EOL><DEDENT>if self.proxy is not None and u.scheme == \"<STR_LIT:http>\":<EOL><INDENT>response = conn.urlopen(method, url, **kw)<EOL><DEDENT>else:<EOL><INDENT>response = conn.urlopen(method, u.request_uri, **kw)<EOL><DEDENT>redirect_location = redirect and response.get_redirect_location()<EOL>if not redirect_location:<EOL><INDENT>return response<EOL><DEDENT>redirect_location = urljoin(url, redirect_location)<EOL>if response.status == <NUM_LIT>:<EOL><INDENT>method = '<STR_LIT:GET>'<EOL><DEDENT>retries = kw.get('<STR_LIT>')<EOL>if not isinstance(retries, Retry):<EOL><INDENT>retries = Retry.from_int(retries, redirect=redirect)<EOL><DEDENT>try:<EOL><INDENT>retries = retries.increment(method, url, response=response, _pool=conn)<EOL><DEDENT>except MaxRetryError:<EOL><INDENT>if retries.raise_on_redirect:<EOL><INDENT>raise<EOL><DEDENT>return response<EOL><DEDENT>kw['<STR_LIT>'] = retries<EOL>kw['<STR_LIT>'] = redirect<EOL>log.info(\"<STR_LIT>\" % (url, redirect_location))<EOL>return self.urlopen(method, redirect_location, **kw)<EOL>", "docstring": "Same as :meth:`urllib3.connectionpool.HTTPConnectionPool.urlopen`\nwith custom cross-host redirect logic and only sends the request-uri\nportion of the ``url``.\n\nThe given ``url`` parameter must be absolute, such that an appropriate\n:class:`urllib3.connectionpool.ConnectionPool` can be chosen for it.", "id": "f16986:c0:m7"}
{"signature": "def add_stderr_logger(level=logging.DEBUG):", "body": "<EOL>logger = logging.getLogger(__name__)<EOL>handler = logging.StreamHandler()<EOL>handler.setFormatter(logging.Formatter('<STR_LIT>'))<EOL>logger.addHandler(handler)<EOL>logger.setLevel(level)<EOL>logger.debug('<STR_LIT>' % __name__)<EOL>return handler<EOL>", "docstring": "Helper for quickly adding a StreamHandler to the logger. Useful for\ndebugging.\n\nReturns the handler after adding it.", "id": "f16987:m0"}
{"signature": "def pop(self, key, default=__marker):", "body": "<EOL>try:<EOL><INDENT>value = self[key]<EOL><DEDENT>except KeyError:<EOL><INDENT>if default is self.__marker:<EOL><INDENT>raise<EOL><DEDENT>return default<EOL><DEDENT>else:<EOL><INDENT>del self[key]<EOL>return value<EOL><DEDENT>", "docstring": "D.pop(k[,d]) -> v, remove specified key and return the corresponding value.\n          If key is not found, d is returned if given, otherwise KeyError is raised.", "id": "f16988:c1:m7"}
{"signature": "def read(self, amt=None, decode_content=None, cache_content=False):", "body": "<EOL>content_encoding = self.headers.get('<STR_LIT>', '<STR_LIT>').lower()<EOL>if self._decoder is None:<EOL><INDENT>if content_encoding in self.CONTENT_DECODERS:<EOL><INDENT>self._decoder = _get_decoder(content_encoding)<EOL><DEDENT><DEDENT>if decode_content is None:<EOL><INDENT>decode_content = self.decode_content<EOL><DEDENT>if self._fp is None:<EOL><INDENT>return<EOL><DEDENT>flush_decoder = False<EOL>try:<EOL><INDENT>try:<EOL><INDENT>if amt is None:<EOL><INDENT>data = self._fp.read()<EOL>flush_decoder = True<EOL><DEDENT>else:<EOL><INDENT>cache_content = False<EOL>data = self._fp.read(amt)<EOL>if amt != <NUM_LIT:0> and not data:  <EOL><INDENT>self._fp.close()<EOL>flush_decoder = True<EOL><DEDENT><DEDENT><DEDENT>except SocketTimeout:<EOL><INDENT>raise ReadTimeoutError(self._pool, None, '<STR_LIT>')<EOL><DEDENT>except BaseSSLError as e:<EOL><INDENT>if '<STR_LIT>' not in str(e):  <EOL><INDENT>raise<EOL><DEDENT>raise ReadTimeoutError(self._pool, None, '<STR_LIT>')<EOL><DEDENT>except HTTPException as e:<EOL><INDENT>raise ProtocolError('<STR_LIT>' % e, e)<EOL><DEDENT>self._fp_bytes_read += len(data)<EOL>try:<EOL><INDENT>if decode_content and self._decoder:<EOL><INDENT>data = self._decoder.decompress(data)<EOL><DEDENT><DEDENT>except (IOError, zlib.error) as e:<EOL><INDENT>raise DecodeError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % content_encoding, e)<EOL><DEDENT>if flush_decoder and decode_content and self._decoder:<EOL><INDENT>buf = self._decoder.decompress(binary_type())<EOL>data += buf + self._decoder.flush()<EOL><DEDENT>if cache_content:<EOL><INDENT>self._body = data<EOL><DEDENT>return data<EOL><DEDENT>finally:<EOL><INDENT>if self._original_response and self._original_response.isclosed():<EOL><INDENT>self.release_conn()<EOL><DEDENT><DEDENT>", "docstring": "Similar to :meth:`httplib.HTTPResponse.read`, but with two additional\nparameters: ``decode_content`` and ``cache_content``.\n\n:param amt:\n    How much of the content to read. If specified, caching is skipped\n    because it doesn't make sense to cache partial content as the full\n    response.\n\n:param decode_content:\n    If True, will attempt to decode the body based on the\n    'content-encoding' header.\n\n:param cache_content:\n    If True, will save the returned data such that the same result is\n    returned despite of the state of the underlying file object. This\n    is useful if you want the ``.data`` property to continue working\n    after having ``.read()`` the file object. (Overridden if ``amt`` is\n    set.)", "id": "f16990:c2:m5"}
{"signature": "@classmethod<EOL><INDENT>def from_httplib(ResponseCls, r, **response_kw):<DEDENT>", "body": "headers = r.msg<EOL>if not isinstance(headers, HTTPHeaderDict):<EOL><INDENT>if PY3: <EOL><INDENT>headers = HTTPHeaderDict(headers.items())<EOL><DEDENT>else: <EOL><INDENT>headers = HTTPHeaderDict.from_httplib(headers)<EOL><DEDENT><DEDENT>strict = getattr(r, '<STR_LIT:strict>', <NUM_LIT:0>)<EOL>resp = ResponseCls(body=r,<EOL>headers=headers,<EOL>status=r.status,<EOL>version=r.version,<EOL>reason=r.reason,<EOL>strict=strict,<EOL>original_response=r,<EOL>**response_kw)<EOL>return resp<EOL>", "docstring": "Given an :class:`httplib.HTTPResponse` instance ``r``, return a\ncorresponding :class:`urllib3.response.HTTPResponse` object.\n\nRemaining parameters are passed to the HTTPResponse constructor, along\nwith ``original_response=r``.", "id": "f16990:c2:m7"}
{"signature": "def get_connection(self, url, proxies=None):", "body": "proxies = proxies or {}<EOL>proxy = proxies.get(urlparse(url.lower()).scheme)<EOL>if proxy:<EOL><INDENT>proxy = prepend_scheme_if_needed(proxy, '<STR_LIT:http>')<EOL>proxy_manager = self.proxy_manager_for(proxy)<EOL>conn = proxy_manager.connection_from_url(url)<EOL><DEDENT>else:<EOL><INDENT>parsed = urlparse(url)<EOL>url = parsed.geturl()<EOL>conn = self.poolmanager.connection_from_url(url)<EOL><DEDENT>return conn<EOL>", "docstring": "Returns a urllib3 connection for the given URL. This should not be\n        called from user code, and is only exposed for use when subclassing the\n        :class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.\n\n        :param url: The URL to connect to.\n        :param proxies: (optional) A Requests-style dictionary of proxies used on this request.", "id": "f16994:c1:m7"}
{"signature": "def request_url(self, request, proxies):", "body": "proxies = proxies or {}<EOL>scheme = urlparse(request.url).scheme<EOL>proxy = proxies.get(scheme)<EOL>if proxy and scheme != '<STR_LIT>':<EOL><INDENT>url = urldefragauth(request.url)<EOL><DEDENT>else:<EOL><INDENT>url = request.path_url<EOL><DEDENT>return url<EOL>", "docstring": "Obtain the url to use when making the final request.\n\n        If the message is being sent through a HTTP proxy, the full URL has to\n        be used. Otherwise, we should only use the path portion of the URL.\n\n        This should not be called from user code, and is only exposed for use\n        when subclassing the\n        :class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.\n\n        :param request: The :class:`PreparedRequest <PreparedRequest>` being sent.\n        :param proxies: A dictionary of schemes to proxy URLs.", "id": "f16994:c1:m9"}
{"signature": "def cert_verify(self, conn, url, verify, cert):", "body": "if url.lower().startswith('<STR_LIT>') and verify:<EOL><INDENT>cert_loc = None<EOL>if verify is not True:<EOL><INDENT>cert_loc = verify<EOL><DEDENT>if not cert_loc:<EOL><INDENT>cert_loc = DEFAULT_CA_BUNDLE_PATH<EOL><DEDENT>if not cert_loc:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>conn.cert_reqs = '<STR_LIT>'<EOL>conn.ca_certs = cert_loc<EOL><DEDENT>else:<EOL><INDENT>conn.cert_reqs = '<STR_LIT>'<EOL>conn.ca_certs = None<EOL><DEDENT>if cert:<EOL><INDENT>if not isinstance(cert, basestring):<EOL><INDENT>conn.cert_file = cert[<NUM_LIT:0>]<EOL>conn.key_file = cert[<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>conn.cert_file = cert<EOL><DEDENT><DEDENT>", "docstring": "Verify a SSL certificate. This method should not be called from user\n        code, and is only exposed for use when subclassing the\n        :class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.\n\n        :param conn: The urllib3 connection object associated with the cert.\n        :param url: The requested URL.\n        :param verify: Whether we should actually verify the certificate.\n        :param cert: The SSL certificate to verify.", "id": "f16994:c1:m5"}
{"signature": "def default_user_agent(name=\"<STR_LIT>\"):", "body": "_implementation = platform.python_implementation()<EOL>if _implementation == '<STR_LIT>':<EOL><INDENT>_implementation_version = platform.python_version()<EOL><DEDENT>elif _implementation == '<STR_LIT>':<EOL><INDENT>_implementation_version = '<STR_LIT>' % (sys.pypy_version_info.major,<EOL>sys.pypy_version_info.minor,<EOL>sys.pypy_version_info.micro)<EOL>if sys.pypy_version_info.releaselevel != '<STR_LIT>':<EOL><INDENT>_implementation_version = '<STR_LIT>'.join([_implementation_version, sys.pypy_version_info.releaselevel])<EOL><DEDENT><DEDENT>elif _implementation == '<STR_LIT>':<EOL><INDENT>_implementation_version = platform.python_version()  <EOL><DEDENT>elif _implementation == '<STR_LIT>':<EOL><INDENT>_implementation_version = platform.python_version()  <EOL><DEDENT>else:<EOL><INDENT>_implementation_version = '<STR_LIT>'<EOL><DEDENT>try:<EOL><INDENT>p_system = platform.system()<EOL>p_release = platform.release()<EOL><DEDENT>except IOError:<EOL><INDENT>p_system = '<STR_LIT>'<EOL>p_release = '<STR_LIT>'<EOL><DEDENT>return \"<STR_LIT:U+0020>\".join(['<STR_LIT>' % (name, __version__),<EOL>'<STR_LIT>' % (_implementation, _implementation_version),<EOL>'<STR_LIT>' % (p_system, p_release)])<EOL>", "docstring": "Return a string representing the default user agent.", "id": "f16996:m24"}
{"signature": "def is_valid_cidr(string_network):", "body": "if string_network.count('<STR_LIT:/>') == <NUM_LIT:1>:<EOL><INDENT>try:<EOL><INDENT>mask = int(string_network.split('<STR_LIT:/>')[<NUM_LIT:1>])<EOL><DEDENT>except ValueError:<EOL><INDENT>return False<EOL><DEDENT>if mask < <NUM_LIT:1> or mask > <NUM_LIT:32>:<EOL><INDENT>return False<EOL><DEDENT>try:<EOL><INDENT>socket.inet_aton(string_network.split('<STR_LIT:/>')[<NUM_LIT:0>])<EOL><DEDENT>except socket.error:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "Very simple check of the cidr format in no_proxy variable", "id": "f16996:m21"}
{"signature": "def get_encoding_from_headers(headers):", "body": "content_type = headers.get('<STR_LIT>')<EOL>if not content_type:<EOL><INDENT>return None<EOL><DEDENT>content_type, params = cgi.parse_header(content_type)<EOL>if '<STR_LIT>' in params:<EOL><INDENT>return params['<STR_LIT>'].strip(\"<STR_LIT>\")<EOL><DEDENT>if '<STR_LIT:text>' in content_type:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>", "docstring": "Returns encodings from given HTTP Header Dict.\n\n    :param headers: dictionary to extract encoding from.", "id": "f16996:m12"}
{"signature": "def dict_from_cookiejar(cj):", "body": "cookie_dict = {}<EOL>for cookie in cj:<EOL><INDENT>cookie_dict[cookie.name] = cookie.value<EOL><DEDENT>return cookie_dict<EOL>", "docstring": "Returns a key/value dictionary from a CookieJar.\n\n    :param cj: CookieJar object to extract cookies from.", "id": "f16996:m9"}
{"signature": "def iter_slices(string, slice_length):", "body": "pos = <NUM_LIT:0><EOL>while pos < len(string):<EOL><INDENT>yield string[pos:pos + slice_length]<EOL>pos += slice_length<EOL><DEDENT>", "docstring": "Iterate over slices of a string.", "id": "f16996:m14"}
{"signature": "def urldefragauth(url):", "body": "scheme, netloc, path, params, query, fragment = urlparse(url)<EOL>if not netloc:<EOL><INDENT>netloc, path = path, netloc<EOL><DEDENT>netloc = netloc.rsplit('<STR_LIT:@>', <NUM_LIT:1>)[-<NUM_LIT:1>]<EOL>return urlunparse((scheme, netloc, path, params, query, '<STR_LIT>'))<EOL>", "docstring": "Given a url remove the fragment and the authentication part", "id": "f16996:m31"}
{"signature": "def parse_dict_header(value):", "body": "result = {}<EOL>for item in _parse_list_header(value):<EOL><INDENT>if '<STR_LIT:=>' not in item:<EOL><INDENT>result[item] = None<EOL>continue<EOL><DEDENT>name, value = item.split('<STR_LIT:=>', <NUM_LIT:1>)<EOL>if value[:<NUM_LIT:1>] == value[-<NUM_LIT:1>:] == '<STR_LIT:\">':<EOL><INDENT>value = unquote_header_value(value[<NUM_LIT:1>:-<NUM_LIT:1>])<EOL><DEDENT>result[name] = value<EOL><DEDENT>return result<EOL>", "docstring": "Parse lists of key, value pairs as described by RFC 2068 Section 2 and\n    convert them into a python dict:\n\n    >>> d = parse_dict_header('foo=\"is a fish\", bar=\"as well\"')\n    >>> type(d) is dict\n    True\n    >>> sorted(d.items())\n    [('bar', 'as well'), ('foo', 'is a fish')]\n\n    If there is no value for a key it will be `None`:\n\n    >>> parse_dict_header('key_without_value')\n    {'key_without_value': None}\n\n    To create a header from the :class:`dict` again, use the\n    :func:`dump_header` function.\n\n    :param value: a string with a dict header.\n    :return: :class:`dict`", "id": "f16996:m7"}
{"signature": "def stream_decode_response_unicode(iterator, r):", "body": "if r.encoding is None:<EOL><INDENT>for item in iterator:<EOL><INDENT>yield item<EOL><DEDENT>return<EOL><DEDENT>decoder = codecs.getincrementaldecoder(r.encoding)(errors='<STR_LIT:replace>')<EOL>for chunk in iterator:<EOL><INDENT>rv = decoder.decode(chunk)<EOL>if rv:<EOL><INDENT>yield rv<EOL><DEDENT><DEDENT>rv = decoder.decode(b'<STR_LIT>', final=True)<EOL>if rv:<EOL><INDENT>yield rv<EOL><DEDENT>", "docstring": "Stream decodes a iterator.", "id": "f16996:m13"}
{"signature": "def prepare_cookies(self, cookies):", "body": "if isinstance(cookies, cookielib.CookieJar):<EOL><INDENT>self._cookies = cookies<EOL><DEDENT>else:<EOL><INDENT>self._cookies = cookiejar_from_dict(cookies)<EOL><DEDENT>cookie_header = get_cookie_header(self._cookies, self)<EOL>if cookie_header is not None:<EOL><INDENT>self.headers['<STR_LIT>'] = cookie_header<EOL><DEDENT>", "docstring": "Prepares the given HTTP cookie data.", "id": "f16997:c3:m10"}
{"signature": "def __iter__(self):", "body": "return self.iter_content(<NUM_LIT>)<EOL>", "docstring": "Allows you to use a response as an iterator.", "id": "f16997:c4:m6"}
{"signature": "@property<EOL><INDENT>def is_redirect(self):<DEDENT>", "body": "return ('<STR_LIT:location>' in self.headers and self.status_code in REDIRECT_STATI)<EOL>", "docstring": "True if this Response is a well-formed HTTP redirect that could have\n        been processed automatically (by :meth:`Session.resolve_redirects`).", "id": "f16997:c4:m8"}
{"signature": "def __bool__(self):", "body": "return self.ok<EOL>", "docstring": "Returns true if :attr:`status_code` is 'OK'.", "id": "f16997:c4:m4"}
{"signature": "def __nonzero__(self):", "body": "return self.ok<EOL>", "docstring": "Returns true if :attr:`status_code` is 'OK'.", "id": "f16997:c4:m5"}
{"signature": "@property<EOL><INDENT>def is_permanent_redirect(self):<DEDENT>", "body": "return ('<STR_LIT:location>' in self.headers and self.status_code in (codes.moved_permanently, codes.permanent_redirect))<EOL>", "docstring": "True if this Response one of the permanant versions of redirect", "id": "f16997:c4:m9"}
{"signature": "def get(url, **kwargs):", "body": "kwargs.setdefault('<STR_LIT>', True)<EOL>return request('<STR_LIT>', url, **kwargs)<EOL>", "docstring": "Sends a GET request.\n\n    :param url: URL for the new :class:`Request` object.\n    :param \\*\\*kwargs: Optional arguments that ``request`` takes.\n    :return: :class:`Response <Response>` object\n    :rtype: requests.Response", "id": "f16998:m1"}
{"signature": "def head(url, **kwargs):", "body": "kwargs.setdefault('<STR_LIT>', False)<EOL>return request('<STR_LIT>', url, **kwargs)<EOL>", "docstring": "Sends a HEAD request.\n\n    :param url: URL for the new :class:`Request` object.\n    :param \\*\\*kwargs: Optional arguments that ``request`` takes.\n    :return: :class:`Response <Response>` object\n    :rtype: requests.Response", "id": "f16998:m3"}
{"signature": "def put(url, data=None, **kwargs):", "body": "return request('<STR_LIT>', url, data=data, **kwargs)<EOL>", "docstring": "Sends a PUT request.\n\n    :param url: URL for the new :class:`Request` object.\n    :param data: (optional) Dictionary, bytes, or file-like object to send in the body of the :class:`Request`.\n    :param \\*\\*kwargs: Optional arguments that ``request`` takes.\n    :return: :class:`Response <Response>` object\n    :rtype: requests.Response", "id": "f16998:m5"}
{"signature": "def request(method, url, **kwargs):", "body": "session = sessions.Session()<EOL>response = session.request(method=method, url=url, **kwargs)<EOL>session.close()<EOL>return response<EOL>", "docstring": "Constructs and sends a :class:`Request <Request>`.\n\n    :param method: method for the new :class:`Request` object.\n    :param url: URL for the new :class:`Request` object.\n    :param params: (optional) Dictionary or bytes to be sent in the query string for the :class:`Request`.\n    :param data: (optional) Dictionary, bytes, or file-like object to send in the body of the :class:`Request`.\n    :param json: (optional) json data to send in the body of the :class:`Request`.\n    :param headers: (optional) Dictionary of HTTP Headers to send with the :class:`Request`.\n    :param cookies: (optional) Dict or CookieJar object to send with the :class:`Request`.\n    :param files: (optional) Dictionary of ``'name': file-like-objects`` (or ``{'name': ('filename', fileobj)}``) for multipart encoding upload.\n    :param auth: (optional) Auth tuple to enable Basic/Digest/Custom HTTP Auth.\n    :param timeout: (optional) How long to wait for the server to send data\n        before giving up, as a float, or a (`connect timeout, read timeout\n        <user/advanced.html#timeouts>`_) tuple.\n    :type timeout: float or tuple\n    :param allow_redirects: (optional) Boolean. Set to True if POST/PUT/DELETE redirect following is allowed.\n    :type allow_redirects: bool\n    :param proxies: (optional) Dictionary mapping protocol to the URL of the proxy.\n    :param verify: (optional) if ``True``, the SSL cert will be verified. A CA_BUNDLE path can also be provided.\n    :param stream: (optional) if ``False``, the response content will be immediately downloaded.\n    :param cert: (optional) if String, path to ssl client cert file (.pem). If Tuple, ('cert', 'key') pair.\n    :return: :class:`Response <Response>` object\n    :rtype: requests.Response\n\n    Usage::\n\n      >>> import requests\n      >>> req = requests.request('GET', 'http://httpbin.org/get')\n      <Response [200]>", "id": "f16998:m0"}
{"signature": "def delete(self, url, **kwargs):", "body": "return self.request('<STR_LIT>', url, **kwargs)<EOL>", "docstring": "Sends a DELETE request. Returns :class:`Response` object.\n\n        :param url: URL for the new :class:`Request` object.\n        :param \\*\\*kwargs: Optional arguments that ``request`` takes.", "id": "f16999:c1:m11"}
{"signature": "def options(self, url, **kwargs):", "body": "kwargs.setdefault('<STR_LIT>', True)<EOL>return self.request('<STR_LIT>', url, **kwargs)<EOL>", "docstring": "Sends a OPTIONS request. Returns :class:`Response` object.\n\n        :param url: URL for the new :class:`Request` object.\n        :param \\*\\*kwargs: Optional arguments that ``request`` takes.", "id": "f16999:c1:m6"}
{"signature": "def head(self, url, **kwargs):", "body": "kwargs.setdefault('<STR_LIT>', False)<EOL>return self.request('<STR_LIT>', url, **kwargs)<EOL>", "docstring": "Sends a HEAD request. Returns :class:`Response` object.\n\n        :param url: URL for the new :class:`Request` object.\n        :param \\*\\*kwargs: Optional arguments that ``request`` takes.", "id": "f16999:c1:m7"}
{"signature": "def rebuild_proxies(self, prepared_request, proxies):", "body": "headers = prepared_request.headers<EOL>url = prepared_request.url<EOL>scheme = urlparse(url).scheme<EOL>new_proxies = proxies.copy() if proxies is not None else {}<EOL>if self.trust_env and not should_bypass_proxies(url):<EOL><INDENT>environ_proxies = get_environ_proxies(url)<EOL>proxy = environ_proxies.get(scheme)<EOL>if proxy:<EOL><INDENT>new_proxies.setdefault(scheme, environ_proxies[scheme])<EOL><DEDENT><DEDENT>if '<STR_LIT>' in headers:<EOL><INDENT>del headers['<STR_LIT>']<EOL><DEDENT>try:<EOL><INDENT>username, password = get_auth_from_url(new_proxies[scheme])<EOL><DEDENT>except KeyError:<EOL><INDENT>username, password = None, None<EOL><DEDENT>if username and password:<EOL><INDENT>headers['<STR_LIT>'] = _basic_auth_str(username, password)<EOL><DEDENT>return new_proxies<EOL>", "docstring": "This method re-evaluates the proxy configuration by considering the\nenvironment variables. If we are redirected to a URL covered by\nNO_PROXY, we strip the proxy configuration. Otherwise, we set missing\nproxy keys for this URL (in case they were stripped by a previous\nredirect).\n\nThis method also replaces the Proxy-Authorization header where\nnecessary.", "id": "f16999:c0:m2"}
{"signature": "def merge_environment_settings(self, url, proxies, stream, verify, cert):", "body": "<EOL>if self.trust_env:<EOL><INDENT>env_proxies = get_environ_proxies(url) or {}<EOL>for (k, v) in env_proxies.items():<EOL><INDENT>proxies.setdefault(k, v)<EOL><DEDENT>if verify is True or verify is None:<EOL><INDENT>verify = (os.environ.get('<STR_LIT>') or<EOL>os.environ.get('<STR_LIT>'))<EOL><DEDENT><DEDENT>proxies = merge_setting(proxies, self.proxies)<EOL>stream = merge_setting(stream, self.stream)<EOL>verify = merge_setting(verify, self.verify)<EOL>cert = merge_setting(cert, self.cert)<EOL>return {'<STR_LIT>': verify, '<STR_LIT>': proxies, '<STR_LIT>': stream,<EOL>'<STR_LIT>': cert}<EOL>", "docstring": "Check the environment and merge it with some settings.", "id": "f16999:c1:m13"}
{"signature": "def close(self):", "body": "for v in self.adapters.values():<EOL><INDENT>v.close()<EOL><DEDENT>", "docstring": "Closes all adapters and as such the session", "id": "f16999:c1:m15"}
{"signature": "def session():", "body": "return Session()<EOL>", "docstring": "Returns a :class:`Session` for context-management.", "id": "f16999:m2"}
{"signature": "@contextlib.contextmanager<EOL>def quiet():", "body": "old_stdout = sys.stdout<EOL>old_stderr = sys.stderr<EOL>new_stdout = sys.stdout = StringIO()<EOL>new_stderr = sys.stderr = StringIO()<EOL>try:<EOL><INDENT>yield new_stdout, new_stderr<EOL><DEDENT>finally:<EOL><INDENT>new_stdout.seek(<NUM_LIT:0>)<EOL>new_stderr.seek(<NUM_LIT:0>)<EOL>sys.stdout = old_stdout<EOL>sys.stderr = old_stderr<EOL><DEDENT>", "docstring": "Redirect stdout/stderr to StringIO objects to prevent console output from\ndistutils commands.", "id": "f17008:m3"}
{"signature": "def run_setup_py(cmd, pypath=None, path=None,<EOL>data_stream=<NUM_LIT:0>, env=None):", "body": "if env is None:<EOL><INDENT>env = dict()<EOL>for envname in os.environ:<EOL><INDENT>env[envname] = os.environ[envname]<EOL><DEDENT><DEDENT>if pypath is not None:<EOL><INDENT>env[\"<STR_LIT>\"] = pypath<EOL><DEDENT>if path is not None:<EOL><INDENT>env[\"<STR_LIT>\"] = path<EOL><DEDENT>if not env.get(\"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>env[\"<STR_LIT>\"] = _which_dirs(\"<STR_LIT>\").union(_which_dirs(\"<STR_LIT>\"))<EOL>env[\"<STR_LIT>\"] = os.pathsep.join(env[\"<STR_LIT>\"])<EOL><DEDENT>cmd = [sys.executable, \"<STR_LIT>\"] + list(cmd)<EOL>shell = sys.platform == '<STR_LIT:win32>'<EOL>try:<EOL><INDENT>proc = _Popen(<EOL>cmd, stdout=_PIPE, stderr=_PIPE, shell=shell, env=env,<EOL>)<EOL>data = proc.communicate()[data_stream]<EOL><DEDENT>except OSError:<EOL><INDENT>return <NUM_LIT:1>, '<STR_LIT>'<EOL><DEDENT>if hasattr(data,  \"<STR_LIT>\"):<EOL><INDENT>data = data.decode()<EOL>data = unicodedata.normalize('<STR_LIT>', data)<EOL><DEDENT>return proc.returncode, data<EOL>", "docstring": "Execution command for tests, separate from those used by the\ncode directly to prevent accidental behavior issues", "id": "f17016:m1"}
{"signature": "def get_all_headers(message, key):", "body": "return message.get_all(key)<EOL>", "docstring": "Given an HTTPMessage, return all headers matching a given key.", "id": "f17028:m0"}
{"signature": "def unpack_zipfile(filename, extract_dir, progress_filter=default_filter):", "body": "if not zipfile.is_zipfile(filename):<EOL><INDENT>raise UnrecognizedFormat(\"<STR_LIT>\" % (filename,))<EOL><DEDENT>with ContextualZipFile(filename) as z:<EOL><INDENT>for info in z.infolist():<EOL><INDENT>name = info.filename<EOL>if name.startswith('<STR_LIT:/>') or '<STR_LIT:..>' in name.split('<STR_LIT:/>'):<EOL><INDENT>continue<EOL><DEDENT>target = os.path.join(extract_dir, *name.split('<STR_LIT:/>'))<EOL>target = progress_filter(name, target)<EOL>if not target:<EOL><INDENT>continue<EOL><DEDENT>if name.endswith('<STR_LIT:/>'):<EOL><INDENT>ensure_directory(target)<EOL><DEDENT>else:<EOL><INDENT>ensure_directory(target)<EOL>data = z.read(info.filename)<EOL>with open(target, '<STR_LIT:wb>') as f:<EOL><INDENT>f.write(data)<EOL><DEDENT><DEDENT>unix_attributes = info.external_attr >> <NUM_LIT:16><EOL>if unix_attributes:<EOL><INDENT>os.chmod(target, unix_attributes)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Unpack zip `filename` to `extract_dir`\n\n    Raises ``UnrecognizedFormat`` if `filename` is not a zipfile (as determined\n    by ``zipfile.is_zipfile()``).  See ``unpack_archive()`` for an explanation\n    of the `progress_filter` argument.", "id": "f17029:m3"}
{"signature": "def default_filter(src,dst):", "body": "return dst<EOL>", "docstring": "The default progress/filter callback; returns True for all files", "id": "f17029:m0"}
{"signature": "def unique_everseen(iterable, key=None):", "body": "<EOL>seen = set()<EOL>seen_add = seen.add<EOL>if key is None:<EOL><INDENT>for element in filterfalse(seen.__contains__, iterable):<EOL><INDENT>seen_add(element)<EOL>yield element<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for element in iterable:<EOL><INDENT>k = key(element)<EOL>if k not in seen:<EOL><INDENT>seen_add(k)<EOL>yield element<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "List unique elements, preserving order. Remember all elements ever seen.", "id": "f17034:m6"}
{"signature": "@unique_values<EOL>def find_external_links(url, page):", "body": "for match in REL.finditer(page):<EOL><INDENT>tag, rel = match.groups()<EOL>rels = set(map(str.strip, rel.lower().split('<STR_LIT:U+002C>')))<EOL>if '<STR_LIT>' in rels or '<STR_LIT>' in rels:<EOL><INDENT>for match in HREF.finditer(tag):<EOL><INDENT>yield urljoin(url, htmldecode(match.group(<NUM_LIT:1>)))<EOL><DEDENT><DEDENT><DEDENT>for tag in (\"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>pos = page.find(tag)<EOL>if pos!=-<NUM_LIT:1>:<EOL><INDENT>match = HREF.search(page,pos)<EOL>if match:<EOL><INDENT>yield urljoin(url, htmldecode(match.group(<NUM_LIT:1>)))<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Find rel=\"homepage\" and rel=\"download\" links in `page`, yielding URLs", "id": "f17034:m8"}
{"signature": "def report(self, reporter, template):", "body": "return<EOL>", "docstring": "Call reporter with information about the checker (hash name)\nsubstituted into the template.", "id": "f17034:c0:m2"}
{"signature": "def _encode_auth(auth):", "body": "auth_s = unquote(auth)<EOL>auth_bytes = auth_s.encode()<EOL>encoded_bytes = base64.encodestring(auth_bytes)<EOL>encoded = encoded_bytes.decode()<EOL>return encoded.replace('<STR_LIT:\\n>','<STR_LIT>')<EOL>", "docstring": "A function compatible with Python 2.3-3.3 that will encode\nauth from a URL suitable for an HTTP header.\n>>> str(_encode_auth('username%3Apassword'))\n'dXNlcm5hbWU6cGFzc3dvcmQ='\n\nLong auth strings should not cause a newline to be inserted.\n>>> long_auth = 'username:' + 'password'*10\n>>> chr(10) in str(_encode_auth(long_auth))\nFalse", "id": "f17034:m13"}
{"signature": "def distros_for_url(url, metadata=None):", "body": "base, fragment = egg_info_for_url(url)<EOL>for dist in distros_for_location(url, base, metadata): yield dist<EOL>if fragment:<EOL><INDENT>match = EGG_FRAGMENT.match(fragment)<EOL>if match:<EOL><INDENT>for dist in interpret_distro_name(<EOL>url, match.group(<NUM_LIT:1>), metadata, precedence = CHECKOUT_DIST<EOL>):<EOL><INDENT>yield dist<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Yield egg or source distribution objects that might be found at a URL", "id": "f17034:m2"}
{"signature": "def download(self, spec, tmpdir):", "body": "if not isinstance(spec,Requirement):<EOL><INDENT>scheme = URL_SCHEME(spec)<EOL>if scheme:<EOL><INDENT>found = self._download_url(scheme.group(<NUM_LIT:1>), spec, tmpdir)<EOL>base, fragment = egg_info_for_url(spec)<EOL>if base.endswith('<STR_LIT>'):<EOL><INDENT>found = self.gen_setup(found,fragment,tmpdir)<EOL><DEDENT>return found<EOL><DEDENT>elif os.path.exists(spec):<EOL><INDENT>return spec<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>spec = Requirement.parse(spec)<EOL><DEDENT>except ValueError:<EOL><INDENT>raise DistutilsError(<EOL>\"<STR_LIT>\" %<EOL>(spec,)<EOL>)<EOL><DEDENT><DEDENT><DEDENT>return getattr(self.fetch_distribution(spec, tmpdir),'<STR_LIT:location>',None)<EOL>", "docstring": "Locate and/or download `spec` to `tmpdir`, returning a local path\n\n        `spec` may be a ``Requirement`` object, or a string containing a URL,\n        an existing local filename, or a project/version requirement spec\n        (i.e. the string form of a ``Requirement`` object).  If it is the URL\n        of a .py file with an unambiguous ``#egg=name-version`` tag (i.e., one\n        that escapes ``-`` as ``_`` throughout), a trivial ``setup.py`` is\n        automatically created alongside the downloaded file.\n\n        If `spec` is a ``Requirement`` object or a string containing a\n        project/version requirement spec, this method returns the location of\n        a matching distribution (possibly after downloading it to `tmpdir`).\n        If `spec` is a locally existing file or directory name, it is simply\n        returned unchanged.  If `spec` is a URL, it is downloaded to a subpath\n        of `tmpdir`, and the local filename is returned.  Various errors may be\n        raised if a problem occurs during downloading.", "id": "f17034:c2:m15"}
{"signature": "def find_credential(self, url):", "body": "for repository, cred in self.creds_by_repository.items():<EOL><INDENT>if url.startswith(repository):<EOL><INDENT>return cred<EOL><DEDENT><DEDENT>", "docstring": "If the URL indicated appears to be a repository defined in this\nconfig, return the credential for that repository.", "id": "f17034:c4:m3"}
{"signature": "def local_open(url):", "body": "scheme, server, path, param, query, frag = urlparse(url)<EOL>filename = url2pathname(path)<EOL>if os.path.isfile(filename):<EOL><INDENT>return urllib2.urlopen(url)<EOL><DEDENT>elif path.endswith('<STR_LIT:/>') and os.path.isdir(filename):<EOL><INDENT>files = []<EOL>for f in os.listdir(filename):<EOL><INDENT>if f=='<STR_LIT>':<EOL><INDENT>with open(os.path.join(filename,f),'<STR_LIT:r>') as fp:<EOL><INDENT>body = fp.read()<EOL><DEDENT>break<EOL><DEDENT>elif os.path.isdir(os.path.join(filename,f)):<EOL><INDENT>f+='<STR_LIT:/>'<EOL><DEDENT>files.append(\"<STR_LIT>\" % (f,f))<EOL><DEDENT>else:<EOL><INDENT>body = (\"<STR_LIT>\" % url) +\"<STR_LIT>\" % '<STR_LIT:\\n>'.join(files)<EOL><DEDENT>status, message = <NUM_LIT:200>, \"<STR_LIT:OK>\"<EOL><DEDENT>else:<EOL><INDENT>status, message, body = <NUM_LIT>, \"<STR_LIT>\", \"<STR_LIT>\"<EOL><DEDENT>headers = {'<STR_LIT>': '<STR_LIT>'}<EOL>return HTTPError(url, status, message, headers, StringIO(body))<EOL>", "docstring": "Read a local path, with special support for directories", "id": "f17034:m16"}
{"signature": "def feed(self, block):", "body": "return<EOL>", "docstring": "Feed a block of data to the hash.", "id": "f17034:c0:m0"}
{"signature": "def run(self):", "body": "old_inplace, self.inplace = self.inplace, <NUM_LIT:0><EOL>_build_ext.run(self)<EOL>self.inplace = old_inplace<EOL>if old_inplace:<EOL><INDENT>self.copy_extensions_to_source()<EOL><DEDENT>", "docstring": "Build extensions in build directory, then copy if --inplace", "id": "f17037:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def from_param(cls, param):<DEDENT>", "body": "if isinstance(param, cls):<EOL><INDENT>return param<EOL><DEDENT>if isinstance(param, list):<EOL><INDENT>return cls(param)<EOL><DEDENT>if param is None:<EOL><INDENT>return cls.from_environment()<EOL><DEDENT>return cls.from_string(param)<EOL>", "docstring": "Construct a CommandSpec from a parameter to build_scripts, which may\nbe None.", "id": "f17038:c2:m2"}
{"signature": "def rmtree(path, ignore_errors=False, onerror=auto_chmod):", "body": "if ignore_errors:<EOL><INDENT>def onerror(*args):<EOL><INDENT>pass<EOL><DEDENT><DEDENT>elif onerror is None:<EOL><INDENT>def onerror(*args):<EOL><INDENT>raise<EOL><DEDENT><DEDENT>names = []<EOL>try:<EOL><INDENT>names = os.listdir(path)<EOL><DEDENT>except os.error:<EOL><INDENT>onerror(os.listdir, path, sys.exc_info())<EOL><DEDENT>for name in names:<EOL><INDENT>fullname = os.path.join(path, name)<EOL>try:<EOL><INDENT>mode = os.lstat(fullname).st_mode<EOL><DEDENT>except os.error:<EOL><INDENT>mode = <NUM_LIT:0><EOL><DEDENT>if stat.S_ISDIR(mode):<EOL><INDENT>rmtree(fullname, ignore_errors, onerror)<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>os.remove(fullname)<EOL><DEDENT>except os.error:<EOL><INDENT>onerror(os.remove, fullname, sys.exc_info())<EOL><DEDENT><DEDENT><DEDENT>try:<EOL><INDENT>os.rmdir(path)<EOL><DEDENT>except os.error:<EOL><INDENT>onerror(os.rmdir, path, sys.exc_info())<EOL><DEDENT>", "docstring": "Recursively delete a directory tree.\n\n    This code is taken from the Python 2.4 version of 'shutil', because\n    the 2.3 version doesn't really work right.", "id": "f17038:m22"}
{"signature": "@classmethod<EOL><INDENT>def get_header(cls, script_text=\"<STR_LIT>\", executable=None):<DEDENT>", "body": "cmd = cls.command_spec_class.best().from_param(executable)<EOL>cmd.install_options(script_text)<EOL>return cmd.as_header()<EOL>", "docstring": "Create a #! line, getting options (if any) from script_text", "id": "f17038:c5:m6"}
{"signature": "@staticmethod<EOL><INDENT>def _adjust_header(type_, orig_header):<DEDENT>", "body": "pattern = '<STR_LIT>'<EOL>repl = '<STR_LIT>'<EOL>if type_ == '<STR_LIT>':<EOL><INDENT>pattern, repl = repl, pattern<EOL><DEDENT>pattern_ob = re.compile(re.escape(pattern), re.IGNORECASE)<EOL>new_header = pattern_ob.sub(string=orig_header, repl=repl)<EOL>clean_header = new_header[<NUM_LIT:2>:-<NUM_LIT:1>].strip('<STR_LIT:\">')<EOL>if sys.platform == '<STR_LIT:win32>' and not os.path.exists(clean_header):<EOL><INDENT>return orig_header<EOL><DEDENT>return new_header<EOL>", "docstring": "Make sure 'pythonw' is used for gui and and 'python' is used for\nconsole (regardless of what sys.executable is).", "id": "f17038:c6:m3"}
{"signature": "def installation_report(self, req, dist, what=\"<STR_LIT>\"):", "body": "msg = \"<STR_LIT>\"<EOL>if self.multi_version and not self.no_report:<EOL><INDENT>msg += '<STR_LIT:\\n>' + self.__mv_warning<EOL>if self.install_dir not in map(normalize_path, sys.path):<EOL><INDENT>msg += '<STR_LIT:\\n>' + self.__id_warning<EOL><DEDENT><DEDENT>eggloc = dist.location<EOL>name = dist.project_name<EOL>version = dist.version<EOL>extras = '<STR_LIT>'  <EOL>return msg % locals()<EOL>", "docstring": "Helpful installation message for display to package users", "id": "f17038:c0:m31"}
{"signature": "def install_site_py(self):", "body": "if self.sitepy_installed:<EOL><INDENT>return  <EOL><DEDENT>sitepy = os.path.join(self.install_dir, \"<STR_LIT>\")<EOL>source = resource_string(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>current = \"<STR_LIT>\"<EOL>if os.path.exists(sitepy):<EOL><INDENT>log.debug(\"<STR_LIT>\", self.install_dir)<EOL>f = open(sitepy, '<STR_LIT:rb>')<EOL>current = f.read()<EOL>if PY3:<EOL><INDENT>current = current.decode()<EOL><DEDENT>f.close()<EOL>if not current.startswith('<STR_LIT>'):<EOL><INDENT>raise DistutilsError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % sitepy<EOL>)<EOL><DEDENT><DEDENT>if current != source:<EOL><INDENT>log.info(\"<STR_LIT>\", sitepy)<EOL>if not self.dry_run:<EOL><INDENT>ensure_directory(sitepy)<EOL>f = open(sitepy, '<STR_LIT:wb>')<EOL>f.write(source)<EOL>f.close()<EOL><DEDENT>self.byte_compile([sitepy])<EOL><DEDENT>self.sitepy_installed = True<EOL>", "docstring": "Make sure there's a site.py in the target dir, if needed", "id": "f17038:c0:m41"}
{"signature": "def _collect_zipimporter_cache_entries(normalized_path, cache):", "body": "result = []<EOL>prefix_len = len(normalized_path)<EOL>for p in cache:<EOL><INDENT>np = normalize_path(p)<EOL>if (np.startswith(normalized_path) and<EOL>np[prefix_len:prefix_len + <NUM_LIT:1>] in (os.sep, '<STR_LIT>')):<EOL><INDENT>result.append(p)<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Return zipimporter cache entry keys related to a given normalized path.\n\nAlternative path spellings (e.g. those using different character case or\nthose using alternative path separators) related to the same path are\nincluded. Any sub-path entries are included as well, i.e. those\ncorresponding to zip archives embedded in other zip archives.", "id": "f17038:m10"}
{"signature": "@classmethod<EOL><INDENT>def best(cls):<DEDENT>", "body": "return WindowsScriptWriter.best() if sys.platform == '<STR_LIT:win32>' else cls<EOL>", "docstring": "Select the best ScriptWriter for this environment.", "id": "f17038:c5:m4"}
{"signature": "def expand_basedirs(self):", "body": "self._expand_attrs(['<STR_LIT>', '<STR_LIT>', '<STR_LIT:root>'])<EOL>", "docstring": "Calls `os.path.expanduser` on install_base, install_platbase and\n        root.", "id": "f17038:c0:m4"}
{"signature": "@classmethod<EOL><INDENT>def _get_script_args(cls, type_, name, header, script_text):<DEDENT>", "body": "if type_ == '<STR_LIT>':<EOL><INDENT>launcher_type = '<STR_LIT>'<EOL>ext = '<STR_LIT>'<EOL>old = ['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>launcher_type = '<STR_LIT>'<EOL>ext = '<STR_LIT>'<EOL>old = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL><DEDENT>hdr = cls._adjust_header(type_, header)<EOL>blockers = [name + x for x in old]<EOL>yield (name + ext, hdr + script_text, '<STR_LIT:t>', blockers)<EOL>yield (<EOL>name + '<STR_LIT>', get_win_launcher(launcher_type),<EOL>'<STR_LIT:b>'  <EOL>)<EOL>if not is_64bit():<EOL><INDENT>m_name = name + '<STR_LIT>'<EOL>yield (m_name, load_launcher_manifest(name), '<STR_LIT:t>')<EOL><DEDENT>", "docstring": "For Windows, add a .py extension and an .exe launcher", "id": "f17038:c7:m0"}
{"signature": "@classmethod<EOL><INDENT>def best(cls):<DEDENT>", "body": "return cls if not JythonCommandSpec.relevant() else JythonCommandSpec<EOL>", "docstring": "Choose the best CommandSpec class based on environmental conditions.", "id": "f17038:c2:m0"}
{"signature": "def add(self, dist):", "body": "new_path = (<EOL>dist.location not in self.paths and (<EOL>dist.location not in self.sitedirs or<EOL>dist.location == os.getcwd()<EOL>)<EOL>)<EOL>if new_path:<EOL><INDENT>self.paths.append(dist.location)<EOL>self.dirty = True<EOL><DEDENT>Environment.add(self, dist)<EOL>", "docstring": "Add `dist` to the distribution map", "id": "f17038:c1:m3"}
{"signature": "def check_site_dir(self):", "body": "instdir = normalize_path(self.install_dir)<EOL>pth_file = os.path.join(instdir, '<STR_LIT>')<EOL>is_site_dir = instdir in self.all_site_dirs<EOL>if not is_site_dir and not self.multi_version:<EOL><INDENT>is_site_dir = self.check_pth_processing()<EOL><DEDENT>else:<EOL><INDENT>testfile = self.pseudo_tempname() + '<STR_LIT>'<EOL>test_exists = os.path.exists(testfile)<EOL>try:<EOL><INDENT>if test_exists:<EOL><INDENT>os.unlink(testfile)<EOL><DEDENT>open(testfile, '<STR_LIT:w>').close()<EOL>os.unlink(testfile)<EOL><DEDENT>except (OSError, IOError):<EOL><INDENT>self.cant_write_to_target()<EOL><DEDENT><DEDENT>if not is_site_dir and not self.multi_version:<EOL><INDENT>raise DistutilsError(self.no_default_version_msg())<EOL><DEDENT>if is_site_dir:<EOL><INDENT>if self.pth_file is None:<EOL><INDENT>self.pth_file = PthDistributions(pth_file, self.all_site_dirs)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.pth_file = None<EOL><DEDENT>PYTHONPATH = os.environ.get('<STR_LIT>', '<STR_LIT>').split(os.pathsep)<EOL>if instdir not in map(normalize_path, [_f for _f in PYTHONPATH if _f]):<EOL><INDENT>self.sitepy_installed = True<EOL><DEDENT>elif self.multi_version and not os.path.exists(pth_file):<EOL><INDENT>self.sitepy_installed = True  <EOL>self.pth_file = None  <EOL><DEDENT>self.install_dir = instdir<EOL>", "docstring": "Verify that self.install_dir is .pth-capable dir, if needed", "id": "f17038:c0:m9"}
{"signature": "def extract_wininst_cfg(dist_filename):", "body": "f = open(dist_filename, '<STR_LIT:rb>')<EOL>try:<EOL><INDENT>endrec = zipfile._EndRecData(f)<EOL>if endrec is None:<EOL><INDENT>return None<EOL><DEDENT>prepended = (endrec[<NUM_LIT:9>] - endrec[<NUM_LIT:5>]) - endrec[<NUM_LIT:6>]<EOL>if prepended < <NUM_LIT:12>:  <EOL><INDENT>return None<EOL><DEDENT>f.seek(prepended - <NUM_LIT:12>)<EOL>from setuptools.compat import StringIO, ConfigParser<EOL>import struct<EOL>tag, cfglen, bmlen = struct.unpack(\"<STR_LIT>\", f.read(<NUM_LIT:12>))<EOL>if tag not in (<NUM_LIT>, <NUM_LIT>):<EOL><INDENT>return None  <EOL><DEDENT>f.seek(prepended - (<NUM_LIT:12> + cfglen))<EOL>cfg = ConfigParser.RawConfigParser(<EOL>{'<STR_LIT:version>': '<STR_LIT>', '<STR_LIT>': '<STR_LIT>'})<EOL>try:<EOL><INDENT>part = f.read(cfglen)<EOL>if sys.version_info >= (<NUM_LIT:2>, <NUM_LIT:6>):<EOL><INDENT>null_byte = bytes([<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>null_byte = chr(<NUM_LIT:0>)<EOL><DEDENT>config = part.split(null_byte, <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>config = config.decode(sys.getfilesystemencoding())<EOL>cfg.readfp(StringIO(config))<EOL><DEDENT>except ConfigParser.Error:<EOL><INDENT>return None<EOL><DEDENT>if not cfg.has_section('<STR_LIT>') or not cfg.has_section('<STR_LIT>'):<EOL><INDENT>return None<EOL><DEDENT>return cfg<EOL><DEDENT>finally:<EOL><INDENT>f.close()<EOL><DEDENT>", "docstring": "Extract configuration data from a bdist_wininst .exe\n\n    Returns a ConfigParser.RawConfigParser, or None", "id": "f17038:m4"}
{"signature": "def read_manifest(self):", "body": "log.info(\"<STR_LIT>\", self.manifest)<EOL>manifest = open(self.manifest, '<STR_LIT>')<EOL>for line in manifest:<EOL><INDENT>if PY3:<EOL><INDENT>try:<EOL><INDENT>line = line.decode('<STR_LIT>')<EOL><DEDENT>except UnicodeDecodeError:<EOL><INDENT>log.warn(\"<STR_LIT>\" % line)<EOL>continue<EOL><DEDENT><DEDENT>line = line.strip()<EOL>if line.startswith('<STR_LIT:#>') or not line:<EOL><INDENT>continue<EOL><DEDENT>self.filelist.append(line)<EOL><DEDENT>manifest.close()<EOL>", "docstring": "Read the manifest file (named by 'self.manifest') and use it to\n        fill in 'self.filelist', the list of files to include in the source\n        distribution.", "id": "f17039:c0:m6"}
{"signature": "def scan_module(egg_dir, base, name, stubs):", "body": "filename = os.path.join(base, name)<EOL>if filename[:-<NUM_LIT:1>] in stubs:<EOL><INDENT>return True  <EOL><DEDENT>pkg = base[len(egg_dir) + <NUM_LIT:1>:].replace(os.sep, '<STR_LIT:.>')<EOL>module = pkg + (pkg and '<STR_LIT:.>' or '<STR_LIT>') + os.path.splitext(name)[<NUM_LIT:0>]<EOL>if sys.version_info < (<NUM_LIT:3>, <NUM_LIT:3>):<EOL><INDENT>skip = <NUM_LIT:8>  <EOL><DEDENT>else:<EOL><INDENT>skip = <NUM_LIT:12>  <EOL><DEDENT>f = open(filename, '<STR_LIT:rb>')<EOL>f.read(skip)<EOL>code = marshal.load(f)<EOL>f.close()<EOL>safe = True<EOL>symbols = dict.fromkeys(iter_symbols(code))<EOL>for bad in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>if bad in symbols:<EOL><INDENT>log.warn(\"<STR_LIT>\", module, bad)<EOL>safe = False<EOL><DEDENT><DEDENT>if '<STR_LIT>' in symbols:<EOL><INDENT>for bad in [<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'<EOL>]:<EOL><INDENT>if bad in symbols:<EOL><INDENT>log.warn(\"<STR_LIT>\", module, bad)<EOL>safe = False<EOL><DEDENT><DEDENT><DEDENT>if '<STR_LIT>' in symbols and '<STR_LIT:__main__>' in symbols and '<STR_LIT:.>' not in module:<EOL><INDENT>if sys.version[:<NUM_LIT:3>] == \"<STR_LIT>\":  <EOL><INDENT>log.warn(\"<STR_LIT>\", module)<EOL>safe = False<EOL><DEDENT><DEDENT>return safe<EOL>", "docstring": "Check whether module possibly uses unsafe-for-zipfile stuff", "id": "f17040:m5"}
{"signature": "def loadTestsFromModule(self, module):", "body": "tests = []<EOL>tests.append(TestLoader.loadTestsFromModule(self, module))<EOL>if hasattr(module, \"<STR_LIT>\"):<EOL><INDENT>tests.append(module.additional_tests())<EOL><DEDENT>if hasattr(module, '<STR_LIT>'):<EOL><INDENT>for file in resource_listdir(module.__name__, '<STR_LIT>'):<EOL><INDENT>if file.endswith('<STR_LIT>') and file != '<STR_LIT>':<EOL><INDENT>submodule = module.__name__ + '<STR_LIT:.>' + file[:-<NUM_LIT:3>]<EOL><DEDENT>else:<EOL><INDENT>if resource_exists(module.__name__, file + '<STR_LIT>'):<EOL><INDENT>submodule = module.__name__ + '<STR_LIT:.>' + file<EOL><DEDENT>else:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>tests.append(self.loadTestsFromName(submodule))<EOL><DEDENT><DEDENT>if len(tests) != <NUM_LIT:1>:<EOL><INDENT>return self.suiteClass(tests)<EOL><DEDENT>else:<EOL><INDENT>return tests[<NUM_LIT:0>]<EOL><DEDENT>", "docstring": "Return a suite of all tests cases contained in the given module\n\n        If the module is a package, load tests from all the modules in it.\n        If the module has an ``additional_tests`` function, call it and add\n        the return value to the tests.", "id": "f17045:c0:m0"}
{"signature": "def _repair(self):", "body": "self.files = list(filter(self._safe_path, self.files))<EOL>", "docstring": "Replace self.files with only safe paths\n\nBecause some owners of FileList manipulate the underlying\n``files`` attribute directly, this method must be called to\nrepair those paths.", "id": "f17047:c1:m2"}
{"signature": "def find_sources(self):", "body": "manifest_filename = os.path.join(self.egg_info, \"<STR_LIT>\")<EOL>mm = manifest_maker(self.distribution)<EOL>mm.manifest = manifest_filename<EOL>mm.run()<EOL>self.filelist = mm.filelist<EOL>", "docstring": "Generate SOURCES.txt manifest file", "id": "f17047:c0:m10"}
{"signature": "def shquote(arg):", "body": "for c in '<STR_LIT:\">', \"<STR_LIT:'>\", \"<STR_LIT:\\\\>\", \"<STR_LIT:#>\":<EOL><INDENT>if c in arg:<EOL><INDENT>return repr(arg)<EOL><DEDENT><DEDENT>if arg.split() != [arg]:<EOL><INDENT>return repr(arg)<EOL><DEDENT>return arg<EOL>", "docstring": "Quote an argument for later parsing by shlex.split()", "id": "f17052:m0"}
{"signature": "def config_file(kind=\"<STR_LIT>\"):", "body": "if kind == '<STR_LIT>':<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>if kind == '<STR_LIT>':<EOL><INDENT>return os.path.join(<EOL>os.path.dirname(distutils.__file__), '<STR_LIT>'<EOL>)<EOL><DEDENT>if kind == '<STR_LIT:user>':<EOL><INDENT>dot = os.name == '<STR_LIT>' and '<STR_LIT:.>' or '<STR_LIT>'<EOL>return os.path.expanduser(convert_path(\"<STR_LIT>\" % dot))<EOL><DEDENT>raise ValueError(<EOL>\"<STR_LIT>\", kind<EOL>)<EOL>", "docstring": "Get the filename of the distutils, local, global, or per-user config\n\n    `kind` must be one of \"local\", \"global\", or \"user\"", "id": "f17053:m0"}
{"signature": "def edit_config(filename, settings, dry_run=False):", "body": "from setuptools.compat import ConfigParser<EOL>log.debug(\"<STR_LIT>\", filename)<EOL>opts = ConfigParser.RawConfigParser()<EOL>opts.read([filename])<EOL>for section, options in settings.items():<EOL><INDENT>if options is None:<EOL><INDENT>log.info(\"<STR_LIT>\", section, filename)<EOL>opts.remove_section(section)<EOL><DEDENT>else:<EOL><INDENT>if not opts.has_section(section):<EOL><INDENT>log.debug(\"<STR_LIT>\", section, filename)<EOL>opts.add_section(section)<EOL><DEDENT>for option, value in options.items():<EOL><INDENT>if value is None:<EOL><INDENT>log.debug(<EOL>\"<STR_LIT>\",<EOL>section, option, filename<EOL>)<EOL>opts.remove_option(section, option)<EOL>if not opts.options(section):<EOL><INDENT>log.info(\"<STR_LIT>\",<EOL>section, filename)<EOL>opts.remove_section(section)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>log.debug(<EOL>\"<STR_LIT>\",<EOL>section, option, value, filename<EOL>)<EOL>opts.set(section, option, value)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>log.info(\"<STR_LIT>\", filename)<EOL>if not dry_run:<EOL><INDENT>with open(filename, '<STR_LIT:w>') as f:<EOL><INDENT>opts.write(f)<EOL><DEDENT><DEDENT>", "docstring": "Edit a configuration file to include `settings`\n\n    `settings` is a dictionary of dictionaries or ``None`` values, keyed by\n    command/section name.  A ``None`` value means to delete the entire section,\n    while a dictionary lists settings to be changed or deleted in that section.\n    A setting of ``None`` means to delete that setting.", "id": "f17053:m1"}
{"signature": "def findall(dir = os.curdir):", "body": "all_files = []<EOL>for base, dirs, files in os.walk(dir, followlinks=True):<EOL><INDENT>if base==os.curdir or base.startswith(os.curdir+os.sep):<EOL><INDENT>base = base[<NUM_LIT:2>:]<EOL><DEDENT>if base:<EOL><INDENT>files = [os.path.join(base, f) for f in files]<EOL><DEDENT>all_files.extend(filter(os.path.isfile, files))<EOL><DEDENT>return all_files<EOL>", "docstring": "Find all files under 'dir' and return the list of full filenames\n    (relative to 'dir').", "id": "f17056:m0"}
{"signature": "def filesys_decode(path):", "body": "fs_enc = sys.getfilesystemencoding()<EOL>if isinstance(path, decoded_string):<EOL><INDENT>return path<EOL><DEDENT>for enc in (fs_enc, \"<STR_LIT:utf-8>\"):<EOL><INDENT>try:<EOL><INDENT>return path.decode(enc)<EOL><DEDENT>except UnicodeDecodeError:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>", "docstring": "Ensure that the given path is decoded,\nNONE when no expected encoding works", "id": "f17057:m1"}
{"signature": "def _remap_input(self, operation, path, *args, **kw):", "body": "if operation in self.write_ops and not self._ok(path):<EOL><INDENT>self._violation(operation, os.path.realpath(path), *args, **kw)<EOL><DEDENT>return path<EOL>", "docstring": "Called for path inputs", "id": "f17058:c3:m6"}
{"signature": "@classmethod<EOL><INDENT>def dump(cls, type, exc):<DEDENT>", "body": "try:<EOL><INDENT>return pickle.dumps(type), pickle.dumps(exc)<EOL><DEDENT>except Exception:<EOL><INDENT>return cls.dump(cls, cls(repr(exc)))<EOL><DEDENT>", "docstring": "Always return a dumped (pickled) type and exc. If exc can't be pickled,\nwrap it in UnpickleableException first.", "id": "f17058:c0:m0"}
{"signature": "def run_setup(setup_script, args):", "body": "setup_dir = os.path.abspath(os.path.dirname(setup_script))<EOL>with setup_context(setup_dir):<EOL><INDENT>try:<EOL><INDENT>sys.argv[:] = [setup_script]+list(args)<EOL>sys.path.insert(<NUM_LIT:0>, setup_dir)<EOL>working_set.__init__()<EOL>working_set.callbacks.append(lambda dist:dist.activate())<EOL>def runner():<EOL><INDENT>ns = dict(__file__=setup_script, __name__='<STR_LIT:__main__>')<EOL>_execfile(setup_script, ns)<EOL><DEDENT>DirectorySandbox(setup_dir).run(runner)<EOL><DEDENT>except SystemExit as v:<EOL><INDENT>if v.args and v.args[<NUM_LIT:0>]:<EOL><INDENT>raise<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Run a distutils setup script, sandboxed in its directory", "id": "f17058:m11"}
{"signature": "@contextlib.contextmanager<EOL>def override_temp(replacement):", "body": "if not os.path.isdir(replacement):<EOL><INDENT>os.makedirs(replacement)<EOL><DEDENT>saved = tempfile.tempdir<EOL>tempfile.tempdir = replacement<EOL>try:<EOL><INDENT>yield<EOL><DEDENT>finally:<EOL><INDENT>tempfile.tempdir = saved<EOL><DEDENT>", "docstring": "Monkey-patch tempfile.tempdir with replacement, ensuring it exists", "id": "f17058:m3"}
{"signature": "def _remap_pair(self,operation,src,dst,*args,**kw):", "body": "return (<EOL>self._remap_input(operation+'<STR_LIT>',src,*args,**kw),<EOL>self._remap_input(operation+'<STR_LIT>',dst,*args,**kw)<EOL>)<EOL>", "docstring": "Called for path pairs like rename, link, and symlink operations", "id": "f17058:c2:m10"}
{"signature": "def _remap_output(self,operation,path):", "body": "return self._validate_path(path)<EOL>", "docstring": "Called for path outputs", "id": "f17058:c2:m9"}
{"signature": "def _set_feature(self,name,status):", "body": "setattr(self,self._feature_attrname(name),status)<EOL>", "docstring": "Set feature's inclusion status", "id": "f17059:c0:m12"}
{"signature": "def check_nsp(dist, attr, value):", "body": "assert_string_list(dist,attr,value)<EOL>for nsp in value:<EOL><INDENT>if not dist.has_contents_for(nsp):<EOL><INDENT>raise DistutilsSetupError(<EOL>\"<STR_LIT>\" +<EOL>\"<STR_LIT>\" % nsp<EOL>)<EOL><DEDENT>if '<STR_LIT:.>' in nsp:<EOL><INDENT>parent = '<STR_LIT:.>'.join(nsp.split('<STR_LIT:.>')[:-<NUM_LIT:1>])<EOL>if parent not in value:<EOL><INDENT>distutils.log.warn(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\", nsp, parent<EOL>)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Verify that namespace packages are valid", "id": "f17059:m4"}
{"signature": "def parse_command_line(self):", "body": "result = _Distribution.parse_command_line(self)<EOL>if self.features:<EOL><INDENT>self._finalize_features()<EOL><DEDENT>return result<EOL>", "docstring": "Process features after parsing command line options", "id": "f17059:c0:m2"}
{"signature": "def get_command_class(self, command):", "body": "if command in self.cmdclass:<EOL><INDENT>return self.cmdclass[command]<EOL><DEDENT>for ep in pkg_resources.iter_entry_points('<STR_LIT>',command):<EOL><INDENT>ep.require(installer=self.fetch_build_egg)<EOL>self.cmdclass[command] = cmdclass = ep.load()<EOL>return cmdclass<EOL><DEDENT>else:<EOL><INDENT>return _Distribution.get_command_class(self, command)<EOL><DEDENT>", "docstring": "Pluggable version of get_command_class()", "id": "f17059:c0:m10"}
{"signature": "def include_feature(self,name):", "body": "if self.feature_is_included(name)==<NUM_LIT:0>:<EOL><INDENT>descr = self.features[name].description<EOL>raise DistutilsOptionError(<EOL>descr + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>self.features[name].include_in(self)<EOL>self._set_feature(name,<NUM_LIT:1>)<EOL>", "docstring": "Request inclusion of feature named 'name", "id": "f17059:c0:m14"}
{"signature": "def check_requirements(dist, attr, value):", "body": "try:<EOL><INDENT>list(pkg_resources.parse_requirements(value))<EOL><DEDENT>except (TypeError,ValueError):<EOL><INDENT>raise DistutilsSetupError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (attr,)<EOL>)<EOL><DEDENT>", "docstring": "Verify that install_requires is a valid requirements list", "id": "f17059:m7"}
{"signature": "def include_in(self,dist):", "body": "if not self.available:<EOL><INDENT>raise DistutilsPlatformError(<EOL>self.description+\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>dist.include(**self.extras)<EOL>for f in self.require_features:<EOL><INDENT>dist.include_feature(f)<EOL><DEDENT>", "docstring": "Ensure feature and its requirements are included in distribution\n\n        You may override this in a subclass to perform additional operations on\n        the distribution.  Note that this method may be called more than once\n        per feature, and so should be idempotent.", "id": "f17059:c1:m3"}
{"signature": "def _convert_pyx_sources_to_lang(self):", "body": "if have_pyrex():<EOL><INDENT>return<EOL><DEDENT>lang = self.language or '<STR_LIT>'<EOL>target_ext = '<STR_LIT>' if lang.lower() == '<STR_LIT>' else '<STR_LIT>'<EOL>sub = functools.partial(re.sub, '<STR_LIT>', target_ext)<EOL>self.sources = list(map(sub, self.sources))<EOL>", "docstring": "Replace sources with .pyx extensions to sources with the target\nlanguage extension. This mechanism allows language authors to supply\npre-converted sources but to prefer the .pyx sources.", "id": "f17062:c0:m1"}
{"signature": "def is_current(self, paths=None):", "body": "version = self.get_version(paths)<EOL>if version is None:<EOL><INDENT>return False<EOL><DEDENT>return self.version_ok(version)<EOL>", "docstring": "Return true if dependency is present and up-to-date on 'paths", "id": "f17063:c0:m5"}
{"signature": "def _update_globals():", "body": "if not sys.platform.startswith('<STR_LIT>') and sys.platform != '<STR_LIT>':<EOL><INDENT>return<EOL><DEDENT>incompatible = '<STR_LIT>', '<STR_LIT>'<EOL>for name in incompatible:<EOL><INDENT>del globals()[name]<EOL>__all__.remove(name)<EOL><DEDENT>", "docstring": "Patch the globals to remove the objects not available on some platforms.\n\nXXX it'd be better to test assertions about bytecode instead.", "id": "f17063:m4"}
{"signature": "def get_module_constant(module, symbol, default=-<NUM_LIT:1>, paths=None):", "body": "try:<EOL><INDENT>f, path, (suffix, mode, kind) = find_module(module, paths)<EOL><DEDENT>except ImportError:<EOL><INDENT>return None<EOL><DEDENT>try:<EOL><INDENT>if kind==PY_COMPILED:<EOL><INDENT>f.read(<NUM_LIT:8>)   <EOL>code = marshal.load(f)<EOL><DEDENT>elif kind==PY_FROZEN:<EOL><INDENT>code = imp.get_frozen_object(module)<EOL><DEDENT>elif kind==PY_SOURCE:<EOL><INDENT>code = compile(f.read(), path, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>if module not in sys.modules:<EOL><INDENT>imp.load_module(module, f, path, (suffix, mode, kind))<EOL><DEDENT>return getattr(sys.modules[module], symbol, None)<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>if f:<EOL><INDENT>f.close()<EOL><DEDENT><DEDENT>return extract_constant(code, symbol, default)<EOL>", "docstring": "Find 'module' by searching 'paths', and extract 'symbol'\n\n    Return 'None' if 'module' does not exist on 'paths', or it does not define\n    'symbol'.  If the module defines 'symbol' as a constant, return the\n    constant.  Otherwise, return 'default'.", "id": "f17063:m2"}
{"signature": "def compile(marker):", "body": "try:<EOL><INDENT>return _cache[marker]<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>if not marker.strip():<EOL><INDENT>def marker_fn(environment=None, override=None):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return True<EOL><DEDENT><DEDENT>else:<EOL><INDENT>compiled_marker = compile_marker(parse_marker(marker))<EOL>def marker_fn(environment=None, override=None):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if override is None:<EOL><INDENT>override = {}<EOL><DEDENT>if environment is None:<EOL><INDENT>environment = default_environment()<EOL><DEDENT>environment.update(override)<EOL>return eval(compiled_marker, environment)<EOL><DEDENT><DEDENT>marker_fn.__doc__ = marker<EOL>_cache[marker] = marker_fn<EOL>return _cache[marker]<EOL>", "docstring": "Return compiled marker as a function accepting an environment dict.", "id": "f17067:m3"}
{"signature": "def visit_Attribute(self, node):", "body": "new_node = ast.Name(\"<STR_LIT>\" % (node.value.id, node.attr), node.ctx)<EOL>return ast.copy_location(new_node, node)<EOL>", "docstring": "Flatten one level of attribute access.", "id": "f17067:c0:m2"}
{"signature": "def start(self):", "body": "if self.run_suffix:<EOL><INDENT>self.data_suffix = self.run_suffix<EOL><DEDENT>if self.auto_data:<EOL><INDENT>self.load()<EOL><DEDENT>if self.source or self.source_pkgs:<EOL><INDENT>self.source_match = TreeMatcher(self.source)<EOL><DEDENT>else:<EOL><INDENT>if self.cover_dir:<EOL><INDENT>self.cover_match = TreeMatcher([self.cover_dir])<EOL><DEDENT>if self.pylib_dirs:<EOL><INDENT>self.pylib_match = TreeMatcher(self.pylib_dirs)<EOL><DEDENT><DEDENT>if self.include:<EOL><INDENT>self.include_match = FnmatchMatcher(self.include)<EOL><DEDENT>if self.omit:<EOL><INDENT>self.omit_match = FnmatchMatcher(self.omit)<EOL><DEDENT>if self.debug.should('<STR_LIT>'):<EOL><INDENT>self.debug.write(\"<STR_LIT>\")<EOL>config_info = sorted(self.config.__dict__.items())<EOL>self.debug.write_formatted_info(config_info)<EOL><DEDENT>if self.debug.should('<STR_LIT>'):<EOL><INDENT>self.debug.write(\"<STR_LIT>\")<EOL>self.debug.write_formatted_info(self.sysinfo())<EOL><DEDENT>self.collector.start()<EOL>self._started = True<EOL>self._measured = True<EOL>", "docstring": "Start measuring code coverage.\n\n        Coverage measurement actually occurs in functions called after `start`\n        is invoked.  Statements in the same scope as `start` won't be measured.\n\n        Once you invoke `start`, you must also call `stop` eventually, or your\n        process might not shut down cleanly.", "id": "f17076:c0:m9"}
{"signature": "def _should_trace_with_reason(self, filename, frame):", "body": "if not filename:<EOL><INDENT>return None, \"<STR_LIT>\"<EOL><DEDENT>if filename.startswith('<STR_LIT:<>'):<EOL><INDENT>return None, \"<STR_LIT>\"<EOL><DEDENT>self._check_for_packages()<EOL>dunder_file = frame.f_globals.get('<STR_LIT>')<EOL>if dunder_file:<EOL><INDENT>filename = self._source_for_file(dunder_file)<EOL><DEDENT>if filename.endswith(\"<STR_LIT>\"):<EOL><INDENT>filename = filename[:-<NUM_LIT:9>] + \"<STR_LIT>\"<EOL><DEDENT>canonical = self.file_locator.canonical_filename(filename)<EOL>if self.source_match:<EOL><INDENT>if not self.source_match.match(canonical):<EOL><INDENT>return None, \"<STR_LIT>\"<EOL><DEDENT><DEDENT>elif self.include_match:<EOL><INDENT>if not self.include_match.match(canonical):<EOL><INDENT>return None, \"<STR_LIT>\"<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if self.pylib_match and self.pylib_match.match(canonical):<EOL><INDENT>return None, \"<STR_LIT>\"<EOL><DEDENT>if self.cover_match and self.cover_match.match(canonical):<EOL><INDENT>return None, \"<STR_LIT>\"<EOL><DEDENT><DEDENT>if self.omit_match and self.omit_match.match(canonical):<EOL><INDENT>return None, \"<STR_LIT>\"<EOL><DEDENT>return canonical, \"<STR_LIT>\"<EOL>", "docstring": "Decide whether to trace execution in `filename`, with a reason.\n\n        This function is called from the trace function.  As each new file name\n        is encountered, this function determines whether it is traced or not.\n\n        Returns a pair of values:  the first indicates whether the file should\n        be traced: it's a canonicalized filename if it should be traced, None\n        if it should not.  The second value is a string, the resason for the\n        decision.", "id": "f17076:c0:m3"}
{"signature": "def _atexit(self):", "body": "if self._started:<EOL><INDENT>self.stop()<EOL><DEDENT>if self.auto_data:<EOL><INDENT>self.save()<EOL><DEDENT>", "docstring": "Clean up on process shutdown.", "id": "f17076:c0:m11"}
{"signature": "def combine(self):", "body": "aliases = None<EOL>if self.config.paths:<EOL><INDENT>aliases = PathAliases(self.file_locator)<EOL>for paths in self.config.paths.values():<EOL><INDENT>result = paths[<NUM_LIT:0>]<EOL>for pattern in paths[<NUM_LIT:1>:]:<EOL><INDENT>aliases.add(pattern, result)<EOL><DEDENT><DEDENT><DEDENT>self.data.combine_parallel_data(aliases=aliases)<EOL>", "docstring": "Combine together a number of similarly-named coverage data files.\n\n        All coverage data files whose name starts with `data_file` (from the\n        coverage() constructor) will be read, and combined together into the\n        current measurements.", "id": "f17076:c0:m19"}
{"signature": "def analysis2(self, morf):", "body": "analysis = self._analyze(morf)<EOL>return (<EOL>analysis.filename,<EOL>sorted(analysis.statements),<EOL>sorted(analysis.excluded),<EOL>sorted(analysis.missing),<EOL>analysis.missing_formatted(),<EOL>)<EOL>", "docstring": "Analyze a module.\n\n        `morf` is a module or a filename.  It will be analyzed to determine\n        its coverage statistics.  The return value is a 5-tuple:\n\n        * The filename for the module.\n        * A list of line numbers of executable statements.\n        * A list of line numbers of excluded statements.\n        * A list of line numbers of statements not run (missing from\n          execution).\n        * A readable formatted string of the missing line numbers.\n\n        The analysis uses the source file itself and the current measured\n        coverage data.", "id": "f17076:c0:m22"}
{"signature": "def sysinfo(self):", "body": "import coverage as covmod<EOL>import platform, re<EOL>try:<EOL><INDENT>implementation = platform.python_implementation()<EOL><DEDENT>except AttributeError:<EOL><INDENT>implementation = \"<STR_LIT>\"<EOL><DEDENT>info = [<EOL>('<STR_LIT:version>', covmod.__version__),<EOL>('<STR_LIT>', covmod.__file__),<EOL>('<STR_LIT>', self.cover_dir),<EOL>('<STR_LIT>', self.pylib_dirs),<EOL>('<STR_LIT>', self.collector.tracer_name()),<EOL>('<STR_LIT>', self.config.attempted_config_files),<EOL>('<STR_LIT>', self.config.config_files),<EOL>('<STR_LIT>', self.data.filename),<EOL>('<STR_LIT>', sys.version.replace('<STR_LIT:\\n>', '<STR_LIT>')),<EOL>('<STR_LIT>', platform.platform()),<EOL>('<STR_LIT>', implementation),<EOL>('<STR_LIT>', sys.executable),<EOL>('<STR_LIT>', os.getcwd()),<EOL>('<STR_LIT:path>', sys.path),<EOL>('<STR_LIT>', sorted([<EOL>(\"<STR_LIT>\" % (k, v)) for k, v in iitems(os.environ)<EOL>if re.search(r\"<STR_LIT>\", k)<EOL>])),<EOL>('<STR_LIT>', \"<STR_LIT:U+0020>\".join(getattr(sys, '<STR_LIT>', ['<STR_LIT>']))),<EOL>]<EOL>if self.source_match:<EOL><INDENT>info.append(('<STR_LIT>', self.source_match.info()))<EOL><DEDENT>if self.include_match:<EOL><INDENT>info.append(('<STR_LIT>', self.include_match.info()))<EOL><DEDENT>if self.omit_match:<EOL><INDENT>info.append(('<STR_LIT>', self.omit_match.info()))<EOL><DEDENT>if self.cover_match:<EOL><INDENT>info.append(('<STR_LIT>', self.cover_match.info()))<EOL><DEDENT>if self.pylib_match:<EOL><INDENT>info.append(('<STR_LIT>', self.pylib_match.info()))<EOL><DEDENT>return info<EOL>", "docstring": "Return a list of (key, value) pairs showing internal information.", "id": "f17076:c0:m28"}
{"signature": "def html_report(self, morfs=None, directory=None, ignore_errors=None,<EOL>omit=None, include=None, extra_css=None, title=None):", "body": "self._harvest_data()<EOL>self.config.from_args(<EOL>ignore_errors=ignore_errors, omit=omit, include=include,<EOL>html_dir=directory, extra_css=extra_css, html_title=title,<EOL>)<EOL>reporter = HtmlReporter(self, self.config)<EOL>return reporter.report(morfs)<EOL>", "docstring": "Generate an HTML report.\n\n        The HTML is written to `directory`.  The file \"index.html\" is the\n        overview starting point, with links to more detailed pages for\n        individual modules.\n\n        `extra_css` is a path to a file of other CSS to apply on the page.\n        It will be copied into the HTML directory.\n\n        `title` is a text string (not HTML) to use as the title of the HTML\n        report.\n\n        See `coverage.report()` for other arguments.\n\n        Returns a float, the total percentage covered.", "id": "f17076:c0:m26"}
{"signature": "def get_exclude_list(self, which='<STR_LIT>'):", "body": "return getattr(self.config, which + \"<STR_LIT>\")<EOL>", "docstring": "Return a list of excluded regex patterns.\n\n        `which` indicates which list is desired.  See `exclude` for the lists\n        that are available, and their meaning.", "id": "f17076:c0:m17"}
{"signature": "def dedent(self):", "body": "self.indent_amount -= <NUM_LIT:4><EOL>", "docstring": "Decrease the current indent for following lines.", "id": "f17077:c0:m4"}
{"signature": "def do_dots(self, value, *dots):", "body": "for dot in dots:<EOL><INDENT>try:<EOL><INDENT>value = getattr(value, dot)<EOL><DEDENT>except AttributeError:<EOL><INDENT>value = value[dot]<EOL><DEDENT>if hasattr(value, '<STR_LIT>'):<EOL><INDENT>value = value()<EOL><DEDENT><DEDENT>return value<EOL>", "docstring": "Evaluate dotted expressions at runtime.", "id": "f17077:c1:m3"}
{"signature": "def render(self, context=None):", "body": "<EOL>ctx = dict(self.context)<EOL>if context:<EOL><INDENT>ctx.update(context)<EOL><DEDENT>return self.render_function(ctx, self.do_dots)<EOL>", "docstring": "Render this template by applying it to `context`.\n\n        `context` is a dictionary of values to use in this rendering.", "id": "f17077:c1:m2"}
{"signature": "def __init__(self, text, *contexts):", "body": "self.text = text<EOL>self.context = {}<EOL>for context in contexts:<EOL><INDENT>self.context.update(context)<EOL><DEDENT>code = CodeBuilder()<EOL>code.add_line(\"<STR_LIT>\")<EOL>code.indent()<EOL>vars_code = code.add_section()<EOL>self.all_vars = set()<EOL>self.loop_vars = set()<EOL>code.add_line(\"<STR_LIT>\")<EOL>code.add_line(\"<STR_LIT>\")<EOL>code.add_line(\"<STR_LIT>\")<EOL>code.add_line(\"<STR_LIT>\")<EOL>buffered = []<EOL>def flush_output():<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if len(buffered) == <NUM_LIT:1>:<EOL><INDENT>code.add_line(\"<STR_LIT>\" % buffered[<NUM_LIT:0>])<EOL><DEDENT>elif len(buffered) > <NUM_LIT:1>:<EOL><INDENT>code.add_line(\"<STR_LIT>\" % \"<STR_LIT:U+002C>\".join(buffered))<EOL><DEDENT>del buffered[:]<EOL><DEDENT>toks = re.split(r\"<STR_LIT>\", text)<EOL>ops_stack = []<EOL>for tok in toks:<EOL><INDENT>if tok.startswith('<STR_LIT>'):<EOL><INDENT>buffered.append(\"<STR_LIT>\" % self.expr_code(tok[<NUM_LIT:2>:-<NUM_LIT:2>].strip()))<EOL><DEDENT>elif tok.startswith('<STR_LIT>'):<EOL><INDENT>continue<EOL><DEDENT>elif tok.startswith('<STR_LIT>'):<EOL><INDENT>flush_output()<EOL>words = tok[<NUM_LIT:2>:-<NUM_LIT:2>].strip().split()<EOL>if words[<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>assert len(words) == <NUM_LIT:2><EOL>ops_stack.append('<STR_LIT>')<EOL>code.add_line(\"<STR_LIT>\" % self.expr_code(words[<NUM_LIT:1>]))<EOL>code.indent()<EOL><DEDENT>elif words[<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>assert len(words) == <NUM_LIT:4> and words[<NUM_LIT:2>] == '<STR_LIT>'<EOL>ops_stack.append('<STR_LIT>')<EOL>self.loop_vars.add(words[<NUM_LIT:1>])<EOL>code.add_line(<EOL>\"<STR_LIT>\" % (<EOL>words[<NUM_LIT:1>],<EOL>self.expr_code(words[<NUM_LIT:3>])<EOL>)<EOL>)<EOL>code.indent()<EOL><DEDENT>elif words[<NUM_LIT:0>].startswith('<STR_LIT:end>'):<EOL><INDENT>end_what = words[<NUM_LIT:0>][<NUM_LIT:3>:]<EOL>if ops_stack[-<NUM_LIT:1>] != end_what:<EOL><INDENT>raise SyntaxError(\"<STR_LIT>\" % end_what)<EOL><DEDENT>ops_stack.pop()<EOL>code.dedent()<EOL><DEDENT>else:<EOL><INDENT>raise SyntaxError(\"<STR_LIT>\" % words[<NUM_LIT:0>])<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if tok:<EOL><INDENT>buffered.append(\"<STR_LIT>\" % tok)<EOL><DEDENT><DEDENT><DEDENT>flush_output()<EOL>for var_name in self.all_vars - self.loop_vars:<EOL><INDENT>vars_code.add_line(\"<STR_LIT>\" % (var_name, var_name))<EOL><DEDENT>if ops_stack:<EOL><INDENT>raise SyntaxError(\"<STR_LIT>\" % ops_stack[-<NUM_LIT:1>])<EOL><DEDENT>code.add_line(\"<STR_LIT>\")<EOL>code.dedent()<EOL>self.render_function = code.get_function('<STR_LIT>')<EOL>", "docstring": "Construct a Templite with the given `text`.\n\n        `contexts` are dictionaries of values to use for future renderings.\n        These are good for filters and global values.", "id": "f17077:c1:m0"}
{"signature": "def __init__(self):", "body": "<EOL>self.attempted_config_files = []<EOL>self.config_files = []<EOL>self.branch = False<EOL>self.cover_pylib = False<EOL>self.data_file = \"<STR_LIT>\"<EOL>self.parallel = False<EOL>self.timid = False<EOL>self.source = None<EOL>self.debug = []<EOL>self.exclude_list = DEFAULT_EXCLUDE[:]<EOL>self.ignore_errors = False<EOL>self.include = None<EOL>self.omit = None<EOL>self.partial_list = DEFAULT_PARTIAL[:]<EOL>self.partial_always_list = DEFAULT_PARTIAL_ALWAYS[:]<EOL>self.precision = <NUM_LIT:0><EOL>self.show_missing = False<EOL>self.html_dir = \"<STR_LIT>\"<EOL>self.extra_css = None<EOL>self.html_title = \"<STR_LIT>\"<EOL>self.xml_output = \"<STR_LIT>\"<EOL>self.paths = {}<EOL>", "docstring": "Initialize the configuration attributes to their defaults.", "id": "f17078:c1:m0"}
{"signature": "def from_args(self, **kwargs):", "body": "for k, v in iitems(kwargs):<EOL><INDENT>if v is not None:<EOL><INDENT>if k in self.MUST_BE_LIST and isinstance(v, string_class):<EOL><INDENT>v = [v]<EOL><DEDENT>setattr(self, k, v)<EOL><DEDENT><DEDENT>", "docstring": "Read config values from `kwargs`.", "id": "f17078:c1:m2"}
{"signature": "def from_file(self, filename):", "body": "self.attempted_config_files.append(filename)<EOL>cp = HandyConfigParser()<EOL>files_read = cp.read(filename)<EOL>if files_read is not None:  <EOL><INDENT>self.config_files.extend(files_read)<EOL><DEDENT>for option_spec in self.CONFIG_FILE_OPTIONS:<EOL><INDENT>self.set_attr_from_config_option(cp, *option_spec)<EOL><DEDENT>if cp.has_section('<STR_LIT>'):<EOL><INDENT>for option in cp.options('<STR_LIT>'):<EOL><INDENT>self.paths[option] = cp.getlist('<STR_LIT>', option)<EOL><DEDENT><DEDENT>", "docstring": "Read configuration from a .rc file.\n\n        `filename` is a file name to read.", "id": "f17078:c1:m3"}
{"signature": "def nice_pair(pair):", "body": "start, end = pair<EOL>if start == end:<EOL><INDENT>return \"<STR_LIT>\" % start<EOL><DEDENT>else:<EOL><INDENT>return \"<STR_LIT>\" % (start, end)<EOL><DEDENT>", "docstring": "Make a nice string representation of a pair of numbers.\n\n    If the numbers are equal, just return the number, otherwise return the pair\n    with a dash between them, indicating the range.", "id": "f17079:m0"}
{"signature": "def child_parsers(self):", "body": "children = CodeObjects(self.code)<EOL>return [ByteParser(code=c, text=self.text) for c in children]<EOL>", "docstring": "Iterate over all the code objects nested within this one.\n\n        The iteration includes `self` as its first value.", "id": "f17081:c1:m1"}
{"signature": "def first_lines(self, lines, *ignores):", "body": "ignore = set()<EOL>for ign in ignores:<EOL><INDENT>ignore.update(ign)<EOL><DEDENT>lset = set()<EOL>for l in lines:<EOL><INDENT>if l in ignore:<EOL><INDENT>continue<EOL><DEDENT>new_l = self.first_line(l)<EOL>if new_l not in ignore:<EOL><INDENT>lset.add(new_l)<EOL><DEDENT><DEDENT>return lset<EOL>", "docstring": "Map the line numbers in `lines` to the correct first line of the\n        statement.\n\n        Skip any line mentioned in any of the sequences in `ignores`.\n\n        Returns a set of the first lines.", "id": "f17081:c0:m5"}
{"signature": "def arcs(self):", "body": "all_arcs = []<EOL>for l1, l2 in self.byte_parser._all_arcs():<EOL><INDENT>fl1 = self.first_line(l1)<EOL>fl2 = self.first_line(l2)<EOL>if fl1 != fl2:<EOL><INDENT>all_arcs.append((fl1, fl2))<EOL><DEDENT><DEDENT>return sorted(all_arcs)<EOL>", "docstring": "Get information about the arcs available in the code.\n\n        Returns a sorted list of line number pairs.  Line numbers have been\n        normalized to the first line of multiline statements.", "id": "f17081:c0:m7"}
{"signature": "def _split_into_chunks(self):", "body": "<EOL>chunks = []<EOL>chunk = None<EOL>bytes_lines_map = dict(self._bytes_lines())<EOL>block_stack = []<EOL>ignore_branch = <NUM_LIT:0><EOL>ult = penult = None<EOL>jump_to = set()<EOL>bytecodes = list(ByteCodes(self.code.co_code))<EOL>for bc in bytecodes:<EOL><INDENT>if bc.jump_to >= <NUM_LIT:0>:<EOL><INDENT>jump_to.add(bc.jump_to)<EOL><DEDENT><DEDENT>chunk_lineno = <NUM_LIT:0><EOL>for bc in bytecodes:<EOL><INDENT>start_new_chunk = False<EOL>first_chunk = False<EOL>if bc.offset in bytes_lines_map:<EOL><INDENT>start_new_chunk = True<EOL>chunk_lineno = bytes_lines_map[bc.offset]<EOL>first_chunk = True<EOL><DEDENT>elif bc.offset in jump_to:<EOL><INDENT>start_new_chunk = True<EOL><DEDENT>elif bc.op in OPS_CHUNK_BEGIN:<EOL><INDENT>start_new_chunk = True<EOL><DEDENT>if not chunk or start_new_chunk:<EOL><INDENT>if chunk:<EOL><INDENT>chunk.exits.add(bc.offset)<EOL><DEDENT>chunk = Chunk(bc.offset, chunk_lineno, first_chunk)<EOL>chunks.append(chunk)<EOL><DEDENT>if bc.jump_to >= <NUM_LIT:0> and bc.op not in OPS_NO_JUMP:<EOL><INDENT>if ignore_branch:<EOL><INDENT>ignore_branch -= <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>chunk.exits.add(bc.jump_to)<EOL><DEDENT><DEDENT>if bc.op in OPS_CODE_END:<EOL><INDENT>chunk.exits.add(-self.code.co_firstlineno)<EOL><DEDENT>if bc.op in OPS_PUSH_BLOCK:<EOL><INDENT>block_stack.append((bc.op, bc.jump_to))<EOL><DEDENT>if bc.op in OPS_POP_BLOCK:<EOL><INDENT>block_stack.pop()<EOL><DEDENT>if bc.op in OPS_CHUNK_END:<EOL><INDENT>if bc.op == OP_BREAK_LOOP:<EOL><INDENT>chunk.exits.add(block_stack[-<NUM_LIT:1>][<NUM_LIT:1>])<EOL><DEDENT>chunk = None<EOL><DEDENT>if bc.op == OP_END_FINALLY:<EOL><INDENT>for block in reversed(block_stack):<EOL><INDENT>if block[<NUM_LIT:0>] in OPS_EXCEPT_BLOCKS:<EOL><INDENT>chunk.exits.add(block[<NUM_LIT:1>])<EOL>break<EOL><DEDENT><DEDENT><DEDENT>if bc.op == OP_COMPARE_OP and bc.arg == COMPARE_EXCEPTION:<EOL><INDENT>ignore_branch += <NUM_LIT:1><EOL><DEDENT>penult = ult<EOL>ult = bc<EOL><DEDENT>if chunks:<EOL><INDENT>if ult and penult:<EOL><INDENT>if penult.op == OP_LOAD_CONST and ult.op == OP_RETURN_VALUE:<EOL><INDENT>if self.code.co_consts[penult.arg] is None:<EOL><INDENT>if chunks[-<NUM_LIT:1>].byte != penult.offset:<EOL><INDENT>ex = -self.code.co_firstlineno<EOL>last_chunk = chunks[-<NUM_LIT:1>]<EOL>last_chunk.exits.remove(ex)<EOL>last_chunk.exits.add(penult.offset)<EOL>chunk = Chunk(<EOL>penult.offset, last_chunk.line, False<EOL>)<EOL>chunk.exits.add(ex)<EOL>chunks.append(chunk)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>chunks[-<NUM_LIT:1>].length = bc.next_offset - chunks[-<NUM_LIT:1>].byte <EOL>for i in range(len(chunks)-<NUM_LIT:1>):<EOL><INDENT>chunks[i].length = chunks[i+<NUM_LIT:1>].byte - chunks[i].byte<EOL><DEDENT><DEDENT>return chunks<EOL>", "docstring": "Split the code object into a list of `Chunk` objects.\n\n        Each chunk is only entered at its first instruction, though there can\n        be many exits from a chunk.\n\n        Returns a list of `Chunk` objects.", "id": "f17081:c1:m5"}
{"signature": "def parse_source(self):", "body": "try:<EOL><INDENT>self._raw_parse()<EOL><DEDENT>except (tokenize.TokenError, IndentationError):<EOL><INDENT>_, tokerr, _ = sys.exc_info()<EOL>msg, lineno = tokerr.args<EOL>raise NotPython(<EOL>\"<STR_LIT>\" %<EOL>(self.filename, msg, lineno)<EOL>)<EOL><DEDENT>excluded_lines = self.first_lines(self.excluded)<EOL>lines = self.first_lines(<EOL>self.statement_starts,<EOL>excluded_lines,<EOL>self.docstrings<EOL>)<EOL>return lines, excluded_lines<EOL>", "docstring": "Parse source text to find executable lines, excluded lines, etc.\n\n        Return values are 1) a set of executable line numbers, and 2) a set of\n        excluded line numbers.\n\n        Reported line numbers are normalized to the first line of multi-line\n        statements.", "id": "f17081:c0:m6"}
{"signature": "def _bytes_lines(self):", "body": "<EOL>byte_increments = bytes_to_ints(self.code.co_lnotab[<NUM_LIT:0>::<NUM_LIT:2>])<EOL>line_increments = bytes_to_ints(self.code.co_lnotab[<NUM_LIT:1>::<NUM_LIT:2>])<EOL>last_line_num = None<EOL>line_num = self.code.co_firstlineno<EOL>byte_num = <NUM_LIT:0><EOL>for byte_incr, line_incr in zip(byte_increments, line_increments):<EOL><INDENT>if byte_incr:<EOL><INDENT>if line_num != last_line_num:<EOL><INDENT>yield (byte_num, line_num)<EOL>last_line_num = line_num<EOL><DEDENT>byte_num += byte_incr<EOL><DEDENT>line_num += line_incr<EOL><DEDENT>if line_num != last_line_num:<EOL><INDENT>yield (byte_num, line_num)<EOL><DEDENT>", "docstring": "Map byte offsets to line numbers in `code`.\n\n        Uses co_lnotab described in Python/compile.c to map byte offsets to\n        line numbers.  Produces a sequence: (b0, l0), (b1, l1), ...\n\n        Only byte offsets that correspond to line numbers are included in the\n        results.", "id": "f17081:c1:m2"}
{"signature": "def _opcode_set(*names):", "body": "s = set()<EOL>for name in names:<EOL><INDENT>try:<EOL><INDENT>s.add(_opcode(name))<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return s<EOL>", "docstring": "Return a set of opcodes by the names in `names`.", "id": "f17081:m1"}
{"signature": "def _opcode(name):", "body": "return dis.opmap[name]<EOL>", "docstring": "Return the opcode by name from the dis module.", "id": "f17081:m0"}
{"signature": "def isabs_anywhere(filename):", "body": "return ntpath.isabs(filename) or posixpath.isabs(filename)<EOL>", "docstring": "Is `filename` an absolute path on any OS?", "id": "f17082:m1"}
{"signature": "def relative_filename(self, filename):", "body": "fnorm = os.path.normcase(filename)<EOL>if fnorm.startswith(self.relative_dir):<EOL><INDENT>filename = filename[len(self.relative_dir):]<EOL><DEDENT>return filename<EOL>", "docstring": "Return the relative form of `filename`.\n\n        The filename will be relative to the current directory when the\n        `FileLocator` was constructed.", "id": "f17082:c0:m1"}
{"signature": "def info(self):", "body": "return self.pats<EOL>", "docstring": "A list of strings for displaying when dumping state.", "id": "f17082:c2:m2"}
{"signature": "def abs_file(filename):", "body": "path = os.path.expandvars(os.path.expanduser(filename))<EOL>path = os.path.abspath(os.path.realpath(path))<EOL>path = actual_path(path)<EOL>return path<EOL>", "docstring": "Return the absolute normalized form of `filename`.", "id": "f17082:m0"}
{"signature": "def missing_formatted(self):", "body": "return format_lines(self.statements, self.missing)<EOL>", "docstring": "The missing line numbers, formatted nicely.\n\n        Returns a string like \"1-2, 5-11, 13-14\".", "id": "f17084:c0:m2"}
{"signature": "def total_branches(self):", "body": "exit_counts = self.parser.exit_counts()<EOL>return sum([count for count in exit_counts.values() if count > <NUM_LIT:1>])<EOL>", "docstring": "How many total branches are there?", "id": "f17084:c0:m9"}
{"signature": "def arc_possibilities(self):", "body": "arcs = self.parser.arcs()<EOL>return arcs<EOL>", "docstring": "Returns a sorted list of the arcs in the code.", "id": "f17084:c0:m4"}
{"signature": "def _get_pc_covered_str(self):", "body": "pc = self.pc_covered<EOL>if <NUM_LIT:0> < pc < self._near0:<EOL><INDENT>pc = self._near0<EOL><DEDENT>elif self._near100 < pc < <NUM_LIT:100>:<EOL><INDENT>pc = self._near100<EOL><DEDENT>else:<EOL><INDENT>pc = round(pc, self._precision)<EOL><DEDENT>return \"<STR_LIT>\" % (self._precision, pc)<EOL>", "docstring": "Returns the percent covered, as a string, without a percent sign.\n\n        Note that \"0\" is only returned when the value is truly zero, and \"100\"\n        is only returned when the value is truly 100.  Rounding can never\n        result in either \"0\" or \"100\".", "id": "f17084:c1:m5"}
{"signature": "def has_arcs(self):", "body": "return self.coverage.data.has_arcs()<EOL>", "docstring": "Were arcs measured in this result?", "id": "f17084:c0:m3"}
{"signature": "def arcs_unpredicted(self):", "body": "possible = self.arc_possibilities()<EOL>executed = self.arcs_executed()<EOL>unpredicted = [<EOL>e for e in executed<EOL>if e not in possible<EOL>and e[<NUM_LIT:0>] != e[<NUM_LIT:1>]<EOL>]<EOL>return sorted(unpredicted)<EOL>", "docstring": "Returns a sorted list of the executed arcs missing from the code.", "id": "f17084:c0:m7"}
{"signature": "def _get_pc_covered(self):", "body": "if self.n_statements > <NUM_LIT:0>:<EOL><INDENT>pc_cov = (<NUM_LIT> * (self.n_executed + self.n_executed_branches) /<EOL>(self.n_statements + self.n_branches))<EOL><DEDENT>else:<EOL><INDENT>pc_cov = <NUM_LIT><EOL><DEDENT>return pc_cov<EOL>", "docstring": "Returns a single percentage value for coverage.", "id": "f17084:c1:m4"}
{"signature": "def help(self, error=None, topic=None, parser=None):", "body": "assert error or topic or parser<EOL>if error:<EOL><INDENT>print(error)<EOL>print(\"<STR_LIT>\")<EOL><DEDENT>elif parser:<EOL><INDENT>print(parser.format_help().strip())<EOL><DEDENT>else:<EOL><INDENT>help_msg = HELP_TOPICS.get(topic, '<STR_LIT>').strip()<EOL>if help_msg:<EOL><INDENT>print(help_msg % self.covpkg.__dict__)<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\" % topic)<EOL><DEDENT><DEDENT>", "docstring": "Display an error message, or the named topic.", "id": "f17085:c4:m2"}
{"signature": "def help_noop(self, error=None, topic=None, parser=None):", "body": "pass<EOL>", "docstring": "No-op help function.", "id": "f17085:c1:m1"}
{"signature": "def do_help(self, options, args, parser):", "body": "<EOL>if options.help:<EOL><INDENT>if self.classic:<EOL><INDENT>self.help_fn(topic='<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>self.help_fn(parser=parser)<EOL><DEDENT>return True<EOL><DEDENT>if \"<STR_LIT>\" in options.actions:<EOL><INDENT>if args:<EOL><INDENT>for a in args:<EOL><INDENT>parser = CMDS.get(a)<EOL>if parser:<EOL><INDENT>self.help_fn(parser=parser)<EOL><DEDENT>else:<EOL><INDENT>self.help_fn(topic=a)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>self.help_fn(topic='<STR_LIT>')<EOL><DEDENT>return True<EOL><DEDENT>if options.version:<EOL><INDENT>self.help_fn(topic='<STR_LIT:version>')<EOL>return True<EOL><DEDENT>return False<EOL>", "docstring": "Deal with help requests.\n\n        Return True if it handled the request, False if not.", "id": "f17085:c4:m3"}
{"signature": "def _append_action(self, option, opt_unused, value_unused, parser):", "body": "parser.values.actions.append(option.action_code)<EOL>", "docstring": "Callback for an option that adds to the `actions` list.", "id": "f17085:c2:m2"}
{"signature": "def tracer_name(self):", "body": "return self._trace_class.__name__<EOL>", "docstring": "Return the class name of the tracer we're using.", "id": "f17086:c1:m2"}
{"signature": "def _installation_trace(self, frame_unused, event_unused, arg_unused):", "body": "<EOL>sys.settrace(None)<EOL>fn = self._start_tracer()<EOL>if fn:<EOL><INDENT>fn = fn(frame_unused, event_unused, arg_unused)<EOL><DEDENT>return fn<EOL>", "docstring": "Called on new threads, installs the real tracer.", "id": "f17086:c1:m5"}
{"signature": "def get_line_data(self):", "body": "if self.branch:<EOL><INDENT>line_data = {}<EOL>for f, arcs in self.data.items():<EOL><INDENT>line_data[f] = ldf = {}<EOL>for l1, _ in list(arcs.keys()):<EOL><INDENT>if l1:<EOL><INDENT>ldf[l1] = None<EOL><DEDENT><DEDENT><DEDENT>return line_data<EOL><DEDENT>else:<EOL><INDENT>return self.data<EOL><DEDENT>", "docstring": "Return the line data collected.\n\n        Data is { filename: { lineno: None, ...}, ...}", "id": "f17086:c1:m10"}
{"signature": "def reset(self):", "body": "<EOL>self.data = {}<EOL>self.should_trace_cache = {}<EOL>self.tracers = []<EOL>", "docstring": "Clear collected data, and prepare to collect more.", "id": "f17086:c1:m3"}
{"signature": "def stop(self):", "body": "self.stopped = True<EOL>if self.thread != threading.currentThread():<EOL><INDENT>return<EOL><DEDENT>if hasattr(sys, \"<STR_LIT>\") and self.warn:<EOL><INDENT>if sys.gettrace() != self._trace:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>self.warn(msg % (sys.gettrace(),))<EOL><DEDENT><DEDENT>sys.settrace(None)<EOL>", "docstring": "Stop this Tracer.", "id": "f17086:c0:m3"}
{"signature": "def report(self, morfs, outfile=None):", "body": "self.find_code_units(morfs)<EOL>max_name = max([len(cu.name) for cu in self.code_units] + [<NUM_LIT:5>])<EOL>fmt_name = \"<STR_LIT>\" % max_name<EOL>fmt_err = \"<STR_LIT>\"<EOL>header = (fmt_name % \"<STR_LIT:Name>\") + \"<STR_LIT>\"<EOL>fmt_coverage = fmt_name + \"<STR_LIT>\"<EOL>if self.branches:<EOL><INDENT>header += \"<STR_LIT>\"<EOL>fmt_coverage += \"<STR_LIT>\"<EOL><DEDENT>width100 = Numbers.pc_str_width()<EOL>header += \"<STR_LIT>\" % (width100+<NUM_LIT:4>, \"<STR_LIT>\")<EOL>fmt_coverage += \"<STR_LIT>\" % (width100+<NUM_LIT:3>,)<EOL>if self.config.show_missing:<EOL><INDENT>header += \"<STR_LIT>\"<EOL>fmt_coverage += \"<STR_LIT>\"<EOL><DEDENT>rule = \"<STR_LIT:->\" * len(header) + \"<STR_LIT:\\n>\"<EOL>header += \"<STR_LIT:\\n>\"<EOL>fmt_coverage += \"<STR_LIT:\\n>\"<EOL>if not outfile:<EOL><INDENT>outfile = sys.stdout<EOL><DEDENT>outfile.write(header)<EOL>outfile.write(rule)<EOL>total = Numbers()<EOL>for cu in self.code_units:<EOL><INDENT>try:<EOL><INDENT>analysis = self.coverage._analyze(cu)<EOL>nums = analysis.numbers<EOL>args = (cu.name, nums.n_statements, nums.n_missing)<EOL>if self.branches:<EOL><INDENT>args += (nums.n_branches, nums.n_missing_branches)<EOL><DEDENT>args += (nums.pc_covered_str,)<EOL>if self.config.show_missing:<EOL><INDENT>args += (analysis.missing_formatted(),)<EOL><DEDENT>outfile.write(fmt_coverage % args)<EOL>total += nums<EOL><DEDENT>except KeyboardInterrupt:                   <EOL><INDENT>raise<EOL><DEDENT>except:<EOL><INDENT>report_it = not self.config.ignore_errors<EOL>if report_it:<EOL><INDENT>typ, msg = sys.exc_info()[:<NUM_LIT:2>]<EOL>if typ is NotPython and not cu.should_be_python():<EOL><INDENT>report_it = False<EOL><DEDENT><DEDENT>if report_it:<EOL><INDENT>outfile.write(fmt_err % (cu.name, typ.__name__, msg))<EOL><DEDENT><DEDENT><DEDENT>if total.n_files > <NUM_LIT:1>:<EOL><INDENT>outfile.write(rule)<EOL>args = (\"<STR_LIT>\", total.n_statements, total.n_missing)<EOL>if self.branches:<EOL><INDENT>args += (total.n_branches, total.n_missing_branches)<EOL><DEDENT>args += (total.pc_covered_str,)<EOL>if self.config.show_missing:<EOL><INDENT>args += (\"<STR_LIT>\",)<EOL><DEDENT>outfile.write(fmt_coverage % args)<EOL><DEDENT>return total.pc_covered<EOL>", "docstring": "Writes a report summarizing coverage statistics per module.\n\n        `outfile` is a file object to write the summary to.", "id": "f17087:c0:m1"}
{"signature": "def summary(self, fullpath=False):", "body": "summ = {}<EOL>if fullpath:<EOL><INDENT>filename_fn = lambda f: f<EOL><DEDENT>else:<EOL><INDENT>filename_fn = os.path.basename<EOL><DEDENT>for filename, lines in iitems(self.lines):<EOL><INDENT>summ[filename_fn(filename)] = len(lines)<EOL><DEDENT>return summ<EOL>", "docstring": "Return a dict summarizing the coverage data.\n\n        Keys are based on the filenames, and values are the number of executed\n        lines.  If `fullpath` is true, then the keys are the full pathnames of\n        the files, otherwise they are the basenames of the files.", "id": "f17088:c0:m19"}
{"signature": "def add_arc_data(self, arc_data):", "body": "for filename, arcs in iitems(arc_data):<EOL><INDENT>self.arcs.setdefault(filename, {}).update(arcs)<EOL><DEDENT>", "docstring": "Add measured arc data.\n\n        `arc_data` is { filename: { (l1,l2): None, ... }, ...}", "id": "f17088:c0:m13"}
{"signature": "def read_file(self, filename):", "body": "self.lines, self.arcs = self._read_file(filename)<EOL>", "docstring": "Read the coverage data from `filename`.", "id": "f17088:c0:m8"}
{"signature": "def arc_data(self):", "body": "return dict(<EOL>[(f, sorted(amap.keys())) for f, amap in iitems(self.arcs)]<EOL>)<EOL>", "docstring": "Return the map from filenames to lists of line number pairs.", "id": "f17088:c0:m6"}
{"signature": "def code_unit_factory(morfs, file_locator):", "body": "<EOL>if not isinstance(morfs, (list, tuple)):<EOL><INDENT>morfs = [morfs]<EOL><DEDENT>globbed = []<EOL>for morf in morfs:<EOL><INDENT>if isinstance(morf, string_class) and ('<STR_LIT:?>' in morf or '<STR_LIT:*>' in morf):<EOL><INDENT>globbed.extend(glob.glob(morf))<EOL><DEDENT>else:<EOL><INDENT>globbed.append(morf)<EOL><DEDENT><DEDENT>morfs = globbed<EOL>code_units = [CodeUnit(morf, file_locator) for morf in morfs]<EOL>return code_units<EOL>", "docstring": "Construct a list of CodeUnits from polymorphic inputs.\n\n    `morfs` is a module or a filename, or a list of same.\n\n    `file_locator` is a FileLocator that can help resolve filenames.\n\n    Returns a list of CodeUnit objects.", "id": "f17089:m0"}
{"signature": "def should_be_python(self):", "body": "<EOL>_, ext = os.path.splitext(self.filename)<EOL>if ext.startswith('<STR_LIT>'):<EOL><INDENT>return True<EOL><DEDENT>if not ext:<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Does it seem like this file should contain Python?\n\n        This is used to decide if a file reported as part of the exection of\n        a program was really likely to have contained Python in the first\n        place.", "id": "f17089:c0:m10"}
{"signature": "def write(self, directory):", "body": "status_file = os.path.join(directory, self.STATUS_FILE)<EOL>status = {<EOL>'<STR_LIT>': self.STATUS_FORMAT,<EOL>'<STR_LIT:version>': coverage.__version__,<EOL>'<STR_LIT>': self.settings,<EOL>'<STR_LIT>': self.files,<EOL>}<EOL>fout = open(status_file, \"<STR_LIT:wb>\")<EOL>try:<EOL><INDENT>pickle.dump(status, fout)<EOL><DEDENT>finally:<EOL><INDENT>fout.close()<EOL><DEDENT>", "docstring": "Write the current status to `directory`.", "id": "f17093:c1:m3"}
{"signature": "def index_file(self):", "body": "index_tmpl = Templite(<EOL>data(\"<STR_LIT>\"), self.template_globals<EOL>)<EOL>self.totals = sum([f['<STR_LIT>'] for f in self.files])<EOL>html = index_tmpl.render({<EOL>'<STR_LIT>': self.arcs,<EOL>'<STR_LIT>': self.extra_css,<EOL>'<STR_LIT>': self.files,<EOL>'<STR_LIT>': self.totals,<EOL>})<EOL>if sys.version_info < (<NUM_LIT:3>, <NUM_LIT:0>):<EOL><INDENT>html = html.decode(\"<STR_LIT:utf-8>\")<EOL><DEDENT>self.write_html(<EOL>os.path.join(self.directory, \"<STR_LIT>\"),<EOL>html<EOL>)<EOL>self.status.write(self.directory)<EOL>", "docstring": "Write the index.html file for this report.", "id": "f17093:c0:m6"}
{"signature": "def data_filename(fname, pkgdir=\"<STR_LIT>\"):", "body": "for static_dir in STATIC_PATH:<EOL><INDENT>static_filename = os.path.join(static_dir, fname)<EOL>if os.path.exists(static_filename):<EOL><INDENT>return static_filename<EOL><DEDENT>if pkgdir:<EOL><INDENT>static_filename = os.path.join(static_dir, pkgdir, fname)<EOL>if os.path.exists(static_filename):<EOL><INDENT>return static_filename<EOL><DEDENT><DEDENT><DEDENT>raise CoverageException(\"<STR_LIT>\" % fname)<EOL>", "docstring": "Return the path to a data file of ours.\n\n    The file is searched for on `STATIC_PATH`, and the first place it's found,\n    is returned.\n\n    Each directory in `STATIC_PATH` is searched as-is, and also, if `pkgdir`\n    is provided, at that subdirectory.", "id": "f17093:m0"}
{"signature": "def html_file(self, cu, analysis):", "body": "source_file = cu.source_file()<EOL>try:<EOL><INDENT>source = source_file.read()<EOL><DEDENT>finally:<EOL><INDENT>source_file.close()<EOL><DEDENT>flat_rootname = cu.flat_rootname()<EOL>this_hash = self.file_hash(source, cu)<EOL>that_hash = self.status.file_hash(flat_rootname)<EOL>if this_hash == that_hash:<EOL><INDENT>self.files.append(self.status.index_info(flat_rootname))<EOL>return<EOL><DEDENT>self.status.set_file_hash(flat_rootname, this_hash)<EOL>if sys.version_info < (<NUM_LIT:3>, <NUM_LIT:0>):<EOL><INDENT>encoding = source_encoding(source)<EOL>if encoding.startswith(\"<STR_LIT:utf-8>\") and source[:<NUM_LIT:3>] == \"<STR_LIT>\":<EOL><INDENT>source = source[<NUM_LIT:3>:]<EOL>encoding = \"<STR_LIT:utf-8>\"<EOL><DEDENT><DEDENT>nums = analysis.numbers<EOL>if self.arcs:<EOL><INDENT>missing_branch_arcs = analysis.missing_branch_arcs()<EOL><DEDENT>c_run = \"<STR_LIT>\"<EOL>c_exc = \"<STR_LIT>\"<EOL>c_mis = \"<STR_LIT>\"<EOL>c_par = \"<STR_LIT>\" + c_run<EOL>lines = []<EOL>for lineno, line in enumerate(source_token_lines(source)):<EOL><INDENT>lineno += <NUM_LIT:1>     <EOL>line_class = []<EOL>annotate_html = \"<STR_LIT>\"<EOL>annotate_title = \"<STR_LIT>\"<EOL>if lineno in analysis.statements:<EOL><INDENT>line_class.append(\"<STR_LIT>\")<EOL><DEDENT>if lineno in analysis.excluded:<EOL><INDENT>line_class.append(c_exc)<EOL><DEDENT>elif lineno in analysis.missing:<EOL><INDENT>line_class.append(c_mis)<EOL><DEDENT>elif self.arcs and lineno in missing_branch_arcs:<EOL><INDENT>line_class.append(c_par)<EOL>annlines = []<EOL>for b in missing_branch_arcs[lineno]:<EOL><INDENT>if b < <NUM_LIT:0>:<EOL><INDENT>annlines.append(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>annlines.append(str(b))<EOL><DEDENT><DEDENT>annotate_html = \"<STR_LIT>\".join(annlines)<EOL>if len(annlines) > <NUM_LIT:1>:<EOL><INDENT>annotate_title = \"<STR_LIT>\"<EOL><DEDENT>elif len(annlines) == <NUM_LIT:1>:<EOL><INDENT>annotate_title = \"<STR_LIT>\"<EOL><DEDENT><DEDENT>elif lineno in analysis.statements:<EOL><INDENT>line_class.append(c_run)<EOL><DEDENT>html = []<EOL>for tok_type, tok_text in line:<EOL><INDENT>if tok_type == \"<STR_LIT>\":<EOL><INDENT>html.append(escape(tok_text))<EOL><DEDENT>else:<EOL><INDENT>tok_html = escape(tok_text) or '<STR_LIT>'<EOL>html.append(<EOL>\"<STR_LIT>\" % (tok_type, tok_html)<EOL>)<EOL><DEDENT><DEDENT>lines.append({<EOL>'<STR_LIT:html>': '<STR_LIT>'.join(html),<EOL>'<STR_LIT>': lineno,<EOL>'<STR_LIT:class>': '<STR_LIT:U+0020>'.join(line_class) or \"<STR_LIT>\",<EOL>'<STR_LIT>': annotate_html,<EOL>'<STR_LIT>': annotate_title,<EOL>})<EOL><DEDENT>html = spaceless(self.source_tmpl.render({<EOL>'<STR_LIT>': c_exc, '<STR_LIT>': c_mis, '<STR_LIT>': c_par, '<STR_LIT>': c_run,<EOL>'<STR_LIT>': self.arcs, '<STR_LIT>': self.extra_css,<EOL>'<STR_LIT>': cu, '<STR_LIT>': nums, '<STR_LIT>': lines,<EOL>}))<EOL>if sys.version_info < (<NUM_LIT:3>, <NUM_LIT:0>):<EOL><INDENT>html = html.decode(encoding)<EOL><DEDENT>html_filename = flat_rootname + \"<STR_LIT>\"<EOL>html_path = os.path.join(self.directory, html_filename)<EOL>self.write_html(html_path, html)<EOL>index_info = {<EOL>'<STR_LIT>': nums,<EOL>'<STR_LIT>': html_filename,<EOL>'<STR_LIT:name>': cu.name,<EOL>}<EOL>self.files.append(index_info)<EOL>self.status.set_index_info(flat_rootname, index_info)<EOL>", "docstring": "Generate an HTML file for one source file.", "id": "f17093:c0:m5"}
{"signature": "def set_file_hash(self, fname, val):", "body": "self.files.setdefault(fname, {})['<STR_LIT>'] = val<EOL>", "docstring": "Set the hash of `fname`'s contents.", "id": "f17093:c1:m7"}
{"signature": "def __init__(self, coverage, config):", "body": "self.coverage = coverage<EOL>self.config = config<EOL>self.code_units = []<EOL>self.directory = None<EOL>", "docstring": "Create a reporter.\n\n        `coverage` is the coverage instance. `config` is an instance  of\n        CoverageConfig, for controlling all sorts of behavior.", "id": "f17095:c0:m0"}
{"signature": "def find_code_units(self, morfs):", "body": "morfs = morfs or self.coverage.data.measured_files()<EOL>file_locator = self.coverage.file_locator<EOL>self.code_units = code_unit_factory(morfs, file_locator)<EOL>if self.config.include:<EOL><INDENT>patterns = prep_patterns(self.config.include)<EOL>filtered = []<EOL>for cu in self.code_units:<EOL><INDENT>for pattern in patterns:<EOL><INDENT>if fnmatch.fnmatch(cu.filename, pattern):<EOL><INDENT>filtered.append(cu)<EOL>break<EOL><DEDENT><DEDENT><DEDENT>self.code_units = filtered<EOL><DEDENT>if self.config.omit:<EOL><INDENT>patterns = prep_patterns(self.config.omit)<EOL>filtered = []<EOL>for cu in self.code_units:<EOL><INDENT>for pattern in patterns:<EOL><INDENT>if fnmatch.fnmatch(cu.filename, pattern):<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>filtered.append(cu)<EOL><DEDENT><DEDENT>self.code_units = filtered<EOL><DEDENT>self.code_units.sort()<EOL>", "docstring": "Find the code units we'll report on.\n\n        `morfs` is a list of modules or filenames.", "id": "f17095:c0:m1"}
{"signature": "def __init__(self, options, output):", "body": "self.options = options<EOL>self.output = output<EOL>", "docstring": "Configure the options and output file for debugging.", "id": "f17096:c0:m0"}
{"signature": "def source_encoding(source):", "body": "<EOL>assert sys.version_info < (<NUM_LIT:3>, <NUM_LIT:0>)<EOL>cookie_re = re.compile(r\"<STR_LIT>\")<EOL>readline = iter(source.splitlines(True)).next<EOL>def _get_normal_name(orig_enc):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>enc = orig_enc[:<NUM_LIT:12>].lower().replace(\"<STR_LIT:_>\", \"<STR_LIT:->\")<EOL>if re.match(r\"<STR_LIT>\", enc):<EOL><INDENT>return \"<STR_LIT:utf-8>\"<EOL><DEDENT>if re.match(r\"<STR_LIT>\", enc):<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>return orig_enc<EOL><DEDENT>if sys.version_info <= (<NUM_LIT:2>, <NUM_LIT:4>):<EOL><INDENT>default = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>default = '<STR_LIT:ascii>'<EOL><DEDENT>bom_found = False<EOL>encoding = None<EOL>def read_or_stop():<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>try:<EOL><INDENT>return readline()<EOL><DEDENT>except StopIteration:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT><DEDENT>def find_cookie(line):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>try:<EOL><INDENT>line_string = line.decode('<STR_LIT:ascii>')<EOL><DEDENT>except UnicodeDecodeError:<EOL><INDENT>return None<EOL><DEDENT>matches = cookie_re.findall(line_string)<EOL>if not matches:<EOL><INDENT>return None<EOL><DEDENT>encoding = _get_normal_name(matches[<NUM_LIT:0>])<EOL>try:<EOL><INDENT>codec = codecs.lookup(encoding)<EOL><DEDENT>except LookupError:<EOL><INDENT>raise SyntaxError(\"<STR_LIT>\" + encoding)<EOL><DEDENT>if bom_found:<EOL><INDENT>codec_name = getattr(codec, '<STR_LIT:name>', encoding)<EOL>if codec_name != '<STR_LIT:utf-8>':<EOL><INDENT>raise SyntaxError('<STR_LIT>')<EOL><DEDENT>encoding += '<STR_LIT>'<EOL><DEDENT>return encoding<EOL><DEDENT>first = read_or_stop()<EOL>if first.startswith(codecs.BOM_UTF8):<EOL><INDENT>bom_found = True<EOL>first = first[<NUM_LIT:3>:]<EOL>default = '<STR_LIT>'<EOL><DEDENT>if not first:<EOL><INDENT>return default<EOL><DEDENT>encoding = find_cookie(first)<EOL>if encoding:<EOL><INDENT>return encoding<EOL><DEDENT>second = read_or_stop()<EOL>if not second:<EOL><INDENT>return default<EOL><DEDENT>encoding = find_cookie(second)<EOL>if encoding:<EOL><INDENT>return encoding<EOL><DEDENT>return default<EOL>", "docstring": "Determine the encoding for `source` (a string), according to PEP 263.\n\n    Returns a string, the name of the encoding.", "id": "f17097:m2"}
{"signature": "def source_token_lines(source):", "body": "ws_tokens = set([token.INDENT, token.DEDENT, token.NEWLINE, tokenize.NL])<EOL>line = []<EOL>col = <NUM_LIT:0><EOL>source = source.expandtabs(<NUM_LIT:8>).replace('<STR_LIT:\\r\\n>', '<STR_LIT:\\n>')<EOL>tokgen = generate_tokens(source)<EOL>for ttype, ttext, (_, scol), (_, ecol), _ in phys_tokens(tokgen):<EOL><INDENT>mark_start = True<EOL>for part in re.split('<STR_LIT>', ttext):<EOL><INDENT>if part == '<STR_LIT:\\n>':<EOL><INDENT>yield line<EOL>line = []<EOL>col = <NUM_LIT:0><EOL>mark_end = False<EOL><DEDENT>elif part == '<STR_LIT>':<EOL><INDENT>mark_end = False<EOL><DEDENT>elif ttype in ws_tokens:<EOL><INDENT>mark_end = False<EOL><DEDENT>else:<EOL><INDENT>if mark_start and scol > col:<EOL><INDENT>line.append((\"<STR_LIT>\", \"<STR_LIT:U+0020>\" * (scol - col)))<EOL>mark_start = False<EOL><DEDENT>tok_class = tokenize.tok_name.get(ttype, '<STR_LIT>').lower()[:<NUM_LIT:3>]<EOL>if ttype == token.NAME and keyword.iskeyword(ttext):<EOL><INDENT>tok_class = \"<STR_LIT:key>\"<EOL><DEDENT>line.append((tok_class, part))<EOL>mark_end = True<EOL><DEDENT>scol = <NUM_LIT:0><EOL><DEDENT>if mark_end:<EOL><INDENT>col = ecol<EOL><DEDENT><DEDENT>if line:<EOL><INDENT>yield line<EOL><DEDENT>", "docstring": "Generate a series of lines, one for each line in `source`.\n\n    Each line is a list of pairs, each pair is a token::\n\n        [('key', 'def'), ('ws', ' '), ('nam', 'hello'), ('op', '('), ... ]\n\n    Each pair has a token class, and the token text.\n\n    If you concatenate all the token texts, and then join them with newlines,\n    you should have your original `source` back, with two differences:\n    trailing whitespace is not preserved, and a final line with no newline\n    is indistinguishable from a final line with a newline.", "id": "f17097:m1"}
{"signature": "def phys_tokens(toks):", "body": "last_line = None<EOL>last_lineno = -<NUM_LIT:1><EOL>last_ttype = None<EOL>for ttype, ttext, (slineno, scol), (elineno, ecol), ltext in toks:<EOL><INDENT>if last_lineno != elineno:<EOL><INDENT>if last_line and last_line.endswith(\"<STR_LIT>\"):<EOL><INDENT>inject_backslash = True<EOL>if last_ttype == tokenize.COMMENT:<EOL><INDENT>inject_backslash = False<EOL><DEDENT>elif ttype == token.STRING:<EOL><INDENT>if \"<STR_LIT:\\n>\" in ttext and ttext.split('<STR_LIT:\\n>', <NUM_LIT:1>)[<NUM_LIT:0>][-<NUM_LIT:1>] == '<STR_LIT:\\\\>':<EOL><INDENT>inject_backslash = False<EOL><DEDENT><DEDENT>if inject_backslash:<EOL><INDENT>ccol = len(last_line.split(\"<STR_LIT:\\n>\")[-<NUM_LIT:2>]) - <NUM_LIT:1><EOL>yield (<EOL><NUM_LIT>, \"<STR_LIT>\",<EOL>(slineno, ccol), (slineno, ccol+<NUM_LIT:2>),<EOL>last_line<EOL>)<EOL><DEDENT><DEDENT>last_line = ltext<EOL>last_ttype = ttype<EOL><DEDENT>yield ttype, ttext, (slineno, scol), (elineno, ecol), ltext<EOL>last_lineno = elineno<EOL><DEDENT>", "docstring": "Return all physical tokens, even line continuations.\n\n    tokenize.generate_tokens() doesn't return a token for the backslash that\n    continues lines.  This wrapper provides those tokens so that we can\n    re-create a faithful representation of the original source.\n\n    Returns the same values as generate_tokens()", "id": "f17097:m0"}
{"signature": "def rate(hit, num):", "body": "return \"<STR_LIT>\" % (float(hit) / (num or <NUM_LIT:1.0>))<EOL>", "docstring": "Return the fraction of `hit`/`num`, as a string.", "id": "f17099:m0"}
{"signature": "def report(self, morfs, outfile=None):", "body": "<EOL>outfile = outfile or sys.stdout<EOL>impl = xml.dom.minidom.getDOMImplementation()<EOL>docType = impl.createDocumentType(<EOL>\"<STR_LIT>\", None,<EOL>\"<STR_LIT>\"<EOL>)<EOL>self.xml_out = impl.createDocument(None, \"<STR_LIT>\", docType)<EOL>xcoverage = self.xml_out.documentElement<EOL>xcoverage.setAttribute(\"<STR_LIT:version>\", __version__)<EOL>xcoverage.setAttribute(\"<STR_LIT>\", str(int(time.time()*<NUM_LIT:1000>)))<EOL>xcoverage.appendChild(self.xml_out.createComment(<EOL>\"<STR_LIT>\" % __url__<EOL>))<EOL>xpackages = self.xml_out.createElement(\"<STR_LIT>\")<EOL>xcoverage.appendChild(xpackages)<EOL>self.packages = {}<EOL>self.report_files(self.xml_file, morfs)<EOL>lnum_tot, lhits_tot = <NUM_LIT:0>, <NUM_LIT:0><EOL>bnum_tot, bhits_tot = <NUM_LIT:0>, <NUM_LIT:0><EOL>for pkg_name in sorted(self.packages.keys()):<EOL><INDENT>pkg_data = self.packages[pkg_name]<EOL>class_elts, lhits, lnum, bhits, bnum = pkg_data<EOL>xpackage = self.xml_out.createElement(\"<STR_LIT>\")<EOL>xpackages.appendChild(xpackage)<EOL>xclasses = self.xml_out.createElement(\"<STR_LIT>\")<EOL>xpackage.appendChild(xclasses)<EOL>for class_name in sorted(class_elts.keys()):<EOL><INDENT>xclasses.appendChild(class_elts[class_name])<EOL><DEDENT>xpackage.setAttribute(\"<STR_LIT:name>\", pkg_name.replace(os.sep, '<STR_LIT:.>'))<EOL>xpackage.setAttribute(\"<STR_LIT>\", rate(lhits, lnum))<EOL>xpackage.setAttribute(\"<STR_LIT>\", rate(bhits, bnum))<EOL>xpackage.setAttribute(\"<STR_LIT>\", \"<STR_LIT:0>\")<EOL>lnum_tot += lnum<EOL>lhits_tot += lhits<EOL>bnum_tot += bnum<EOL>bhits_tot += bhits<EOL><DEDENT>xcoverage.setAttribute(\"<STR_LIT>\", rate(lhits_tot, lnum_tot))<EOL>xcoverage.setAttribute(\"<STR_LIT>\", rate(bhits_tot, bnum_tot))<EOL>outfile.write(self.xml_out.toprettyxml())<EOL>denom = lnum_tot + bnum_tot<EOL>if denom == <NUM_LIT:0>:<EOL><INDENT>pct = <NUM_LIT:0.0><EOL><DEDENT>else:<EOL><INDENT>pct = <NUM_LIT> * (lhits_tot + bhits_tot) / denom<EOL><DEDENT>return pct<EOL>", "docstring": "Generate a Cobertura-compatible XML report for `morfs`.\n\n        `morfs` is a list of modules or filenames.\n\n        `outfile` is a file object to write the XML to.", "id": "f17099:c0:m1"}
{"signature": "def get_vcs_files():", "body": "vcs = detect_vcs()<EOL>return normalize_names(vcs.get_versioned_files())<EOL>", "docstring": "List all files under version control in the current directory.", "id": "f17100:m18"}
{"signature": "def read_manifest():", "body": "<EOL>if not os.path.isfile('<STR_LIT>'):<EOL><INDENT>return<EOL><DEDENT>with open('<STR_LIT>') as manifest:<EOL><INDENT>contents = manifest.read()<EOL><DEDENT>ignore, ignore_regexps = _get_ignore_from_manifest(contents)<EOL>IGNORE.extend(ignore)<EOL>IGNORE_REGEXPS.extend(ignore_regexps)<EOL>", "docstring": "Read existing configuration from MANIFEST.in.\n\n    We use that to ignore anything the MANIFEST.in ignores.", "id": "f17100:m22"}
{"signature": "@contextmanager<EOL>def mkdtemp(hint='<STR_LIT>'):", "body": "dirname = tempfile.mkdtemp(prefix='<STR_LIT>', suffix=hint)<EOL>try:<EOL><INDENT>yield dirname<EOL><DEDENT>finally:<EOL><INDENT>shutil.rmtree(dirname)<EOL><DEDENT>", "docstring": "Create a temporary directory, then clean it up.\n\n    Use as a context manager: with mkdtemp('-purpose'): ...", "id": "f17100:m11"}
{"signature": "def check_manifest(source_tree='<STR_LIT:.>', create=False, update=False,<EOL>python=sys.executable):", "body": "all_ok = True<EOL>python = os.path.abspath(python)  <EOL>with cd(source_tree):<EOL><INDENT>if not is_package():<EOL><INDENT>raise Failure('<STR_LIT>')<EOL><DEDENT>read_config()<EOL>read_manifest()<EOL>info_begin(\"<STR_LIT>\")<EOL>all_source_files = sorted(get_vcs_files())<EOL>source_files = strip_sdist_extras(all_source_files)<EOL>info_continue(\"<STR_LIT>\" % len(source_files))<EOL>info_begin(\"<STR_LIT>\")<EOL>with mkdtemp('<STR_LIT>') as tempdir:<EOL><INDENT>run([python, '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', tempdir])<EOL>sdist_filename = get_one_file_in(tempdir)<EOL>info_continue(\"<STR_LIT>\" % os.path.basename(sdist_filename))<EOL>sdist_files = sorted(normalize_names(strip_sdist_extras(<EOL>strip_toplevel_name(get_archive_file_list(sdist_filename)))))<EOL>info_continue(\"<STR_LIT>\" % len(sdist_files))<EOL><DEDENT>existing_source_files = list(filter(os.path.exists, all_source_files))<EOL>missing_source_files = sorted(set(all_source_files) - set(existing_source_files))<EOL>if missing_source_files:<EOL><INDENT>warning(\"<STR_LIT>\"<EOL>% format_list(missing_source_files))<EOL><DEDENT>info_begin(\"<STR_LIT>\")<EOL>with mkdtemp('<STR_LIT>') as tempsourcedir:<EOL><INDENT>copy_files(existing_source_files, tempsourcedir)<EOL>if os.path.exists('<STR_LIT>') and '<STR_LIT>' not in source_files:<EOL><INDENT>copy_files(['<STR_LIT>'], tempsourcedir)<EOL><DEDENT>if '<STR_LIT>' not in source_files:<EOL><INDENT>copy_files(['<STR_LIT>'], tempsourcedir)<EOL><DEDENT>info_begin(\"<STR_LIT>\")<EOL>with cd(tempsourcedir):<EOL><INDENT>with mkdtemp('<STR_LIT>') as tempdir:<EOL><INDENT>run([python, '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', tempdir])<EOL>sdist_filename = get_one_file_in(tempdir)<EOL>info_continue(\"<STR_LIT>\" % os.path.basename(sdist_filename))<EOL>clean_sdist_files = sorted(normalize_names(strip_sdist_extras(<EOL>strip_toplevel_name(get_archive_file_list(sdist_filename)))))<EOL>info_continue(\"<STR_LIT>\" % len(clean_sdist_files))<EOL><DEDENT><DEDENT><DEDENT>missing_from_manifest = set(source_files) - set(clean_sdist_files)<EOL>missing_from_VCS = set(sdist_files + clean_sdist_files) - set(source_files)<EOL>if not missing_from_manifest and not missing_from_VCS:<EOL><INDENT>info(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>error(\"<STR_LIT>\"<EOL>% format_missing(missing_from_VCS, missing_from_manifest,<EOL>\"<STR_LIT>\", \"<STR_LIT>\"))<EOL>suggestions, unknowns = find_suggestions(missing_from_manifest)<EOL>user_asked_for_help = update or (create and not<EOL>os.path.exists('<STR_LIT>'))<EOL>if '<STR_LIT>' not in existing_source_files:<EOL><INDENT>if suggestions and not user_asked_for_help:<EOL><INDENT>info(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>info(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if suggestions:<EOL><INDENT>info(\"<STR_LIT>\"<EOL>% format_list(suggestions))<EOL>if user_asked_for_help:<EOL><INDENT>existed = os.path.exists('<STR_LIT>')<EOL>with open('<STR_LIT>', '<STR_LIT:a>') as f:<EOL><INDENT>if not existed:<EOL><INDENT>info(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>info(\"<STR_LIT>\")<EOL>f.write('<STR_LIT>')<EOL><DEDENT>f.write('<STR_LIT:\\n>'.join(suggestions) + '<STR_LIT:\\n>')<EOL><DEDENT>if unknowns:<EOL><INDENT>info(\"<STR_LIT>\"<EOL>% format_list(unknowns))<EOL><DEDENT><DEDENT><DEDENT>elif user_asked_for_help:<EOL><INDENT>info(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>all_ok = False<EOL><DEDENT>bad_ideas = find_bad_ideas(all_source_files)<EOL>if bad_ideas:<EOL><INDENT>warning(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>% bad_ideas[<NUM_LIT:0>])<EOL>if len(bad_ideas) > <NUM_LIT:1>:<EOL><INDENT>warning(\"<STR_LIT>\"<EOL>% format_list(bad_ideas[<NUM_LIT:1>:]))<EOL><DEDENT>all_ok = False<EOL><DEDENT><DEDENT>return all_ok<EOL>", "docstring": "Compare a generated source distribution with list of files in a VCS.\n\n    Returns True if the manifest is fine.", "id": "f17100:m31"}
{"signature": "def file_matches(filename, patterns):", "body": "return any(fnmatch.fnmatch(filename, pat) for pat in patterns)<EOL>", "docstring": "Does this filename match any of the patterns?", "id": "f17100:m25"}
{"signature": "@contextmanager<EOL>def cd(directory):", "body": "old_dir = os.getcwd()<EOL>try:<EOL><INDENT>os.chdir(directory)<EOL>yield<EOL><DEDENT>finally:<EOL><INDENT>os.chdir(old_dir)<EOL><DEDENT>", "docstring": "Change the current working directory, temporarily.\n\n    Use as a context manager: with cd(d): ...", "id": "f17100:m10"}
{"signature": "def find_suggestions(filelist):", "body": "suggestions = set()<EOL>unknowns = []<EOL>for filename in filelist:<EOL><INDENT>if os.path.isdir(filename):<EOL><INDENT>continue<EOL><DEDENT>for pattern, suggestion in SUGGESTIONS:<EOL><INDENT>m = pattern.match(filename)<EOL>if m is not None:<EOL><INDENT>suggestions.add(pattern.sub(suggestion, filename))<EOL>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>unknowns.append(filename)<EOL><DEDENT><DEDENT>return sorted(suggestions), unknowns<EOL>", "docstring": "Suggest MANIFEST.in patterns for missing files.", "id": "f17100:m29"}
{"signature": "def urlsafe_b64encode(data):", "body": "return base64.urlsafe_b64encode(data).rstrip(binary('<STR_LIT:=>'))<EOL>", "docstring": "urlsafe_b64encode without padding", "id": "f17101:m0"}
{"signature": "def urlsafe_b64decode(data):", "body": "pad = b'<STR_LIT:=>' * (<NUM_LIT:4> - (len(data) & <NUM_LIT:3>))<EOL>return base64.urlsafe_b64decode(data + pad)<EOL>", "docstring": "urlsafe_b64decode without padding", "id": "f17101:m1"}
{"signature": "def matches_requirement(req, wheels):", "body": "try:<EOL><INDENT>from pkg_resources import Distribution, Requirement<EOL><DEDENT>except ImportError:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>req = Requirement.parse(req)<EOL>selected = []<EOL>for wf in wheels:<EOL><INDENT>f = wf.parsed_filename<EOL>dist = Distribution(project_name=f.group(\"<STR_LIT:name>\"), version=f.group(\"<STR_LIT>\"))<EOL>if dist in req:<EOL><INDENT>selected.append(wf)<EOL><DEDENT><DEDENT>return selected<EOL>", "docstring": "List of wheels matching a requirement.\n\n    :param req: The requirement to satisfy\n    :param wheels: List of wheels to search.", "id": "f17101:m5"}
{"signature": "def parse_info(wininfo_name, egginfo_name):", "body": "egginfo = None<EOL>if egginfo_name:<EOL><INDENT>egginfo = egg_info_re.search(egginfo_name)<EOL>if not egginfo:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" %<EOL>(egginfo_name,))<EOL><DEDENT><DEDENT>w_name, sep, rest = wininfo_name.partition('<STR_LIT:->')<EOL>if not sep:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" %<EOL>(wininfo_name,))<EOL><DEDENT>rest = rest[:-<NUM_LIT:4>]<EOL>rest2, sep, w_pyver = rest.rpartition('<STR_LIT:->')<EOL>if sep and w_pyver.startswith('<STR_LIT>'):<EOL><INDENT>rest = rest2<EOL>w_pyver = w_pyver.replace('<STR_LIT:.>', '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>w_pyver = '<STR_LIT>'<EOL><DEDENT>w_ver, sep, w_arch = rest.rpartition('<STR_LIT:.>')<EOL>if not sep:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" %<EOL>(wininfo_name,))<EOL><DEDENT>if egginfo:<EOL><INDENT>w_name = egginfo.group('<STR_LIT:name>')<EOL>w_ver = egginfo.group('<STR_LIT>')<EOL><DEDENT>return dict(name=w_name, ver=w_ver, arch=w_arch, pyver=w_pyver)<EOL>", "docstring": "Extract metadata from filenames.\n\n    Extracts the 4 metadataitems needed (name, version, pyversion, arch) from\n    the installer filename and the name of the egg-info directory embedded in\n    the zipfile (if any).\n\n    The egginfo filename has the format::\n\n        name-ver(-pyver)(-arch).egg-info\n\n    The installer filename has the format::\n\n        name-ver.arch(-pyver).exe\n\n    Some things to note:\n\n    1. The installer filename is not definitive. An installer can be renamed\n       and work perfectly well as an installer. So more reliable data should\n       be used whenever possible.\n    2. The egg-info data should be preferred for the name and version, because\n       these come straight from the distutils metadata, and are mandatory.\n    3. The pyver from the egg-info data should be ignored, as it is\n       constructed from the version of Python used to build the installer,\n       which is irrelevant - the installer filename is correct here (even to\n       the point that when it's not there, any version is implied).\n    4. The architecture must be taken from the installer filename, as it is\n       not included in the egg-info data.\n    5. Architecture-neutral installers still have an architecture because the\n       installer format itself (being executable) is architecture-specific. We\n       should therefore ignore the architecture if the content is pure-python.", "id": "f17102:m0"}
{"signature": "def add_requirements(self, metadata_path):", "body": "additional = list(self.setupcfg_requirements())<EOL>if not additional: return<EOL>pkg_info = read_pkg_info(metadata_path)<EOL>if '<STR_LIT>' in pkg_info or '<STR_LIT>' in pkg_info:<EOL><INDENT>warnings.warn('<STR_LIT>')<EOL>del pkg_info['<STR_LIT>']<EOL>del pkg_info['<STR_LIT>']<EOL><DEDENT>for k, v in additional:<EOL><INDENT>pkg_info[k] = v<EOL><DEDENT>write_pkg_info(metadata_path, pkg_info)<EOL>", "docstring": "Add additional requirements from setup.cfg to file metadata_path", "id": "f17104:c0:m11"}
{"signature": "def egg2dist(self, egginfo_path, distinfo_path):", "body": "def adios(p):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if os.path.exists(p) and not os.path.islink(p) and os.path.isdir(p):<EOL><INDENT>shutil.rmtree(p)<EOL><DEDENT>elif os.path.exists(p):<EOL><INDENT>os.unlink(p)<EOL><DEDENT><DEDENT>adios(distinfo_path)<EOL>if not os.path.exists(egginfo_path):<EOL><INDENT>import glob<EOL>pat = os.path.join(os.path.dirname(egginfo_path), '<STR_LIT>')<EOL>possible = glob.glob(pat)<EOL>err = \"<STR_LIT>\" % (egginfo_path,)<EOL>if possible:<EOL><INDENT>alt = os.path.basename(possible[<NUM_LIT:0>])<EOL>err += \"<STR_LIT>\" % (alt,)<EOL><DEDENT>raise ValueError(err)<EOL><DEDENT>if os.path.isfile(egginfo_path):<EOL><INDENT>pkginfo_path = egginfo_path<EOL>pkg_info = self._pkginfo_to_metadata(egginfo_path, egginfo_path)<EOL>os.mkdir(distinfo_path)<EOL><DEDENT>else:<EOL><INDENT>pkginfo_path = os.path.join(egginfo_path, '<STR_LIT>')<EOL>pkg_info = self._pkginfo_to_metadata(egginfo_path, pkginfo_path)<EOL>shutil.copytree(egginfo_path, distinfo_path,<EOL>ignore=lambda x, y: set(('<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',)))<EOL>dependency_links = os.path.join(distinfo_path, '<STR_LIT>')<EOL>if not open(dependency_links, '<STR_LIT:r>').read().strip():<EOL><INDENT>adios(dependency_links)<EOL><DEDENT><DEDENT>write_pkg_info(os.path.join(distinfo_path, '<STR_LIT>'), pkg_info)<EOL>metadata_path = os.path.join(distinfo_path, '<STR_LIT>')<EOL>self.add_requirements(metadata_path)<EOL>metadata_json_path = os.path.join(distinfo_path, '<STR_LIT>')<EOL>pymeta = pkginfo_to_dict(metadata_path,<EOL>distribution=self.distribution)<EOL>if '<STR_LIT:description>' in pymeta:<EOL><INDENT>description_filename = '<STR_LIT>'<EOL>description_text = pymeta.pop('<STR_LIT:description>')<EOL>description_path = os.path.join(distinfo_path,<EOL>description_filename)<EOL>with open(description_path, \"<STR_LIT:wb>\") as description_file:<EOL><INDENT>description_file.write(description_text.encode('<STR_LIT:utf-8>'))<EOL><DEDENT>pymeta['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT:description>'] = description_filename<EOL><DEDENT>license = self.license_file()<EOL>if license:<EOL><INDENT>license_filename = '<STR_LIT>'<EOL>shutil.copy(license, os.path.join(self.distinfo_dir, license_filename))<EOL>pymeta['<STR_LIT>']['<STR_LIT>']['<STR_LIT>']['<STR_LIT>'] = license_filename<EOL><DEDENT>with open(metadata_json_path, \"<STR_LIT:w>\") as metadata_json:<EOL><INDENT>json.dump(pymeta, metadata_json)<EOL><DEDENT>adios(egginfo_path)<EOL>", "docstring": "Convert an .egg-info directory into a .dist-info directory", "id": "f17104:c0:m12"}
{"signature": "@property<EOL><INDENT>def rank(self):<DEDENT>", "body": "return self.compatibility_rank(self.context())<EOL>", "docstring": "Lowest index of any of this wheel's tags in self.context(), and the\narity e.g. (0, 1)", "id": "f17122:c1:m8"}
{"signature": "@property<EOL><INDENT>def tags(self):<DEDENT>", "body": "tags = self.parsed_filename.groupdict()<EOL>for pyver in tags['<STR_LIT>'].split('<STR_LIT:.>'):<EOL><INDENT>for abi in tags['<STR_LIT>'].split('<STR_LIT:.>'):<EOL><INDENT>for plat in tags['<STR_LIT>'].split('<STR_LIT:.>'):<EOL><INDENT>yield (pyver, abi, plat)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "A wheel file is compatible with the Cartesian product of the\n        period-delimited tags in its filename.\n        To choose a wheel file among several candidates having the same\n        distribution version 'ver', an installer ranks each triple of\n        (pyver, abi, plat) that its Python installation can run, sorting\n        the wheels by the best-ranked tag it supports and then by their\n        arity which is just len(list(compatibility_tags)).", "id": "f17122:c1:m6"}
{"signature": "@reify<EOL><INDENT>def parsed_wheel_info(self):<DEDENT>", "body": "return read_pkg_info_bytes(self.zipfile.read(self.wheelinfo_name))<EOL>", "docstring": "Parse wheel metadata (the .data/WHEEL file)", "id": "f17122:c1:m20"}
{"signature": "def parse_version(version):", "body": "global parse_version<EOL>try:<EOL><INDENT>from pkg_resources import parse_version<EOL><DEDENT>except ImportError:<EOL><INDENT>from distutils.version import LooseVersion as parse_version<EOL><DEDENT>return parse_version(version)<EOL>", "docstring": "Use parse_version from pkg_resources or distutils as available.", "id": "f17122:m0"}
{"signature": "def compatibility_rank(self, supported):", "body": "preferences = []<EOL>for tag in self.compatibility_tags:<EOL><INDENT>try:<EOL><INDENT>preferences.append(supported.index(tag))<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if len(preferences):<EOL><INDENT>return (min(preferences), self.arity)<EOL><DEDENT>return (_big_number, <NUM_LIT:0>)<EOL>", "docstring": "Rank the wheel against the supported tags. Smaller ranks are more\n        compatible!\n\n        :param supported: A list of compatibility tags that the current\n            Python implemenation can run.", "id": "f17122:c1:m10"}
{"signature": "@property<EOL><INDENT>def arity(self):<DEDENT>", "body": "return len(list(self.compatibility_tags))<EOL>", "docstring": "The number of compatibility tags the wheel declares.", "id": "f17122:c1:m7"}
{"signature": "def convert_requirements(requirements):", "body": "for req in requirements:<EOL><INDENT>parsed_requirement = pkg_resources.Requirement.parse(req)<EOL>spec = requires_to_requires_dist(parsed_requirement)<EOL>extras = \"<STR_LIT:U+002C>\".join(parsed_requirement.extras)<EOL>if extras:<EOL><INDENT>extras = \"<STR_LIT>\" % extras<EOL><DEDENT>yield (parsed_requirement.project_name + extras + spec)<EOL><DEDENT>", "docstring": "Yield Requires-Dist: strings for parsed requirements strings.", "id": "f17126:m4"}
{"signature": "def dedent_description(pkg_info):", "body": "description = pkg_info['<STR_LIT>']<EOL>surrogates = False<EOL>if not isinstance(description, str):<EOL><INDENT>surrogates = True<EOL>description = pkginfo_unicode(pkg_info, '<STR_LIT>')<EOL><DEDENT>description_lines = description.splitlines()<EOL>description_dedent = '<STR_LIT:\\n>'.join(<EOL>(description_lines[<NUM_LIT:0>].lstrip(),<EOL>textwrap.dedent('<STR_LIT:\\n>'.join(description_lines[<NUM_LIT:1>:])),<EOL>'<STR_LIT:\\n>'))<EOL>if surrogates:<EOL><INDENT>description_dedent = description_dedent.encode(\"<STR_LIT:utf8>\").decode(\"<STR_LIT:ascii>\", \"<STR_LIT>\")<EOL><DEDENT>return description_dedent<EOL>", "docstring": "Dedent and convert pkg_info['Description'] to Unicode.", "id": "f17126:m7"}
{"signature": "def requires_to_requires_dist(requirement):", "body": "requires_dist = []<EOL>for op, ver in requirement.specs:<EOL><INDENT>requires_dist.append(op + ver)<EOL><DEDENT>if not requires_dist:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>return \"<STR_LIT>\" % '<STR_LIT:U+002C>'.join(requires_dist)<EOL>", "docstring": "Compose the version predicates for requirement in PEP 345 fashion.", "id": "f17126:m3"}
{"signature": "def trusted(self, scope=None):", "body": "trust = [(x['<STR_LIT>'], x['<STR_LIT>']) for x in self.data['<STR_LIT>'] if x['<STR_LIT>'] in (scope, '<STR_LIT:+>')]<EOL>trust.sort(key=lambda x: x[<NUM_LIT:0>])<EOL>trust.reverse()<EOL>return trust<EOL>", "docstring": "Return list of [(scope, trusted key), ...] for given scope.", "id": "f17128:c0:m5"}
{"signature": "def untrust(self, scope, vk):", "body": "self.data['<STR_LIT>'].remove({'<STR_LIT>':scope, '<STR_LIT>':vk})<EOL>return self<EOL>", "docstring": "Stop trusting a particular key for given scope.", "id": "f17128:c0:m4"}
{"signature": "def crypto_sign(msg, sk):", "body": "if len(sk) != SECRETKEYBYTES:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % len(sk))<EOL><DEDENT>vkbytes = sk[PUBLICKEYBYTES:]<EOL>skbytes = sk[:PUBLICKEYBYTES]<EOL>sig = djbec.signature(msg, skbytes, vkbytes)<EOL>return sig + msg<EOL>", "docstring": "Return signature+message given message and secret key.\n    The signature is the first SIGNATUREBYTES bytes of the return value.\n    A copy of msg is in the remainder.", "id": "f17131:m1"}
{"signature": "def crypto_sign_keypair(seed=None):", "body": "if seed is None:<EOL><INDENT>seed = os.urandom(PUBLICKEYBYTES)<EOL><DEDENT>else:<EOL><INDENT>warnings.warn(\"<STR_LIT>\",<EOL>RuntimeWarning)<EOL><DEDENT>if len(seed) != <NUM_LIT:32>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>skbytes = seed<EOL>vkbytes = djbec.publickey(skbytes)<EOL>return Keypair(vkbytes, skbytes+vkbytes)<EOL>", "docstring": "Return (verifying, secret) key from a given seed, or os.urandom(32)", "id": "f17131:m0"}
{"signature": "def get_url_rev(self):", "body": "if '<STR_LIT>' not in self.url:<EOL><INDENT>assert '<STR_LIT>' not in self.url<EOL>self.url = self.url.replace('<STR_LIT>', '<STR_LIT>')<EOL>url, rev = super(Git, self).get_url_rev()<EOL>url = url.replace('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>url, rev = super(Git, self).get_url_rev()<EOL><DEDENT>return url, rev<EOL>", "docstring": "Prefixes stub URLs like 'user@hostname:user/repo.git' with 'ssh://'.\nThat's required because although they use SSH they sometimes doesn't\nwork with a ssh:// scheme (e.g. Github). But we need a scheme for\nparsing. Hence we remove it again afterwards and return it as a stub.", "id": "f17154:c0:m10"}
{"signature": "def get_info(self, location):", "body": "assert not location.rstrip('<STR_LIT:/>').endswith(self.dirname),'<STR_LIT>' % location<EOL>output = call_subprocess(<EOL>[self.cmd, '<STR_LIT:info>', location],<EOL>show_stdout=False,<EOL>extra_environ={'<STR_LIT>': '<STR_LIT:C>'},<EOL>)<EOL>match = _svn_url_re.search(output)<EOL>if not match:<EOL><INDENT>logger.warning(<EOL>'<STR_LIT>',<EOL>display_path(location),<EOL>)<EOL>logger.debug('<STR_LIT>', output)<EOL>return None, None<EOL><DEDENT>url = match.group(<NUM_LIT:1>).strip()<EOL>match = _svn_revision_re.search(output)<EOL>if not match:<EOL><INDENT>logger.warning(<EOL>'<STR_LIT>',<EOL>display_path(location),<EOL>)<EOL>logger.debug('<STR_LIT>', output)<EOL>return url, None<EOL><DEDENT>return url, match.group(<NUM_LIT:1>)<EOL>", "docstring": "Returns (url, revision), where both are strings", "id": "f17155:c0:m0"}
{"signature": "def get_revision(self, location):", "body": "<EOL>revision = <NUM_LIT:0><EOL>for base, dirs, files in os.walk(location):<EOL><INDENT>if self.dirname not in dirs:<EOL><INDENT>dirs[:] = []<EOL>continue    <EOL><DEDENT>dirs.remove(self.dirname)<EOL>entries_fn = os.path.join(base, self.dirname, '<STR_LIT>')<EOL>if not os.path.exists(entries_fn):<EOL><INDENT>continue<EOL><DEDENT>dirurl, localrev = self._get_svn_url_rev(base)<EOL>if base == location:<EOL><INDENT>base_url = dirurl + '<STR_LIT:/>'   <EOL><DEDENT>elif not dirurl or not dirurl.startswith(base_url):<EOL><INDENT>dirs[:] = []<EOL>continue    <EOL><DEDENT>revision = max(revision, localrev)<EOL><DEDENT>return revision<EOL>", "docstring": "Return the maximum revision for all files under a given location", "id": "f17155:c0:m6"}
{"signature": "def export(self, location):", "body": "raise NotImplementedError<EOL>", "docstring": "Export the repository at the url to the destination location\ni.e. only download the files, without vcs informations", "id": "f17157:c1:m5"}
{"signature": "def get_revision(self, location):", "body": "raise NotImplementedError<EOL>", "docstring": "Return the current revision of the files at location\nUsed in get_info", "id": "f17157:c1:m17"}
{"signature": "def normalize_url(self, url):", "body": "return urllib_parse.unquote(url).rstrip('<STR_LIT:/>')<EOL>", "docstring": "Normalize a URL for comparison by unquoting it and removing any\ntrailing slash.", "id": "f17157:c1:m8"}
{"signature": "def get_src_requirement(self, dist, location, find_tags=False):", "body": "raise NotImplementedError<EOL>", "docstring": "Return a string representing the requirement needed to\nredownload the files currently present in location, something\nlike:\n  {repository_url}@{revision}#egg={project_name}-{version_identifier}\nIf find_tags is True, try to find a tag matching the revision", "id": "f17157:c1:m15"}
{"signature": "def get_url_rev(self):", "body": "error_message = (<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL>assert '<STR_LIT:+>' in self.url, error_message % self.url<EOL>url = self.url.split('<STR_LIT:+>', <NUM_LIT:1>)[<NUM_LIT:1>]<EOL>scheme, netloc, path, query, frag = urllib_parse.urlsplit(url)<EOL>rev = None<EOL>if '<STR_LIT:@>' in path:<EOL><INDENT>path, rev = path.rsplit('<STR_LIT:@>', <NUM_LIT:1>)<EOL><DEDENT>url = urllib_parse.urlunsplit((scheme, netloc, path, query, '<STR_LIT>'))<EOL>return url, rev<EOL>", "docstring": "Returns the correct repository URL and revision by parsing the given\nrepository URL", "id": "f17157:c1:m6"}
{"signature": "def export(self, location):", "body": "temp_dir = tempfile.mkdtemp('<STR_LIT>', '<STR_LIT>')<EOL>self.unpack(temp_dir)<EOL>if os.path.exists(location):<EOL><INDENT>rmtree(location)<EOL><DEDENT>try:<EOL><INDENT>call_subprocess([self.cmd, '<STR_LIT>', location], cwd=temp_dir,<EOL>filter_stdout=self._filter, show_stdout=False)<EOL><DEDENT>finally:<EOL><INDENT>rmtree(temp_dir)<EOL><DEDENT>", "docstring": "Export the Bazaar repository at the url to the destination location", "id": "f17158:c0:m1"}
{"signature": "def path_to_url(path):", "body": "path = os.path.normpath(os.path.abspath(path))<EOL>url = urllib_parse.urljoin('<STR_LIT>', urllib_request.pathname2url(path))<EOL>return url<EOL>", "docstring": "Convert a path to a file: URL.  The path will be made absolute and have\nquoted path parts.", "id": "f17159:m4"}
{"signature": "def is_archive_file(name):", "body": "archives = (<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'<EOL>)<EOL>ext = splitext(name)[<NUM_LIT:1>].lower()<EOL>if ext in archives:<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Return True if `name` is a considered as an archive file.", "id": "f17159:m5"}
{"signature": "def url_to_path(url):", "body": "assert url.startswith('<STR_LIT>'), (<EOL>\"<STR_LIT>\" % url)<EOL>_, netloc, path, _, _ = urllib_parse.urlsplit(url)<EOL>if netloc:<EOL><INDENT>netloc = '<STR_LIT>' + netloc<EOL><DEDENT>path = urllib_request.url2pathname(netloc + path)<EOL>return path<EOL>", "docstring": "Convert a file: URL to a path.", "id": "f17159:m3"}
{"signature": "def _download_http_url(link, session, temp_dir):", "body": "target_url = link.url.split('<STR_LIT:#>', <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>try:<EOL><INDENT>resp = session.get(<EOL>target_url,<EOL>headers={\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>stream=True,<EOL>)<EOL>resp.raise_for_status()<EOL><DEDENT>except requests.HTTPError as exc:<EOL><INDENT>logger.critical(<EOL>\"<STR_LIT>\", exc.response.status_code, link,<EOL>)<EOL>raise<EOL><DEDENT>content_type = resp.headers.get('<STR_LIT>', '<STR_LIT>')<EOL>filename = link.filename  <EOL>content_disposition = resp.headers.get('<STR_LIT>')<EOL>if content_disposition:<EOL><INDENT>type, params = cgi.parse_header(content_disposition)<EOL>filename = params.get('<STR_LIT:filename>') or filename<EOL><DEDENT>ext = splitext(filename)[<NUM_LIT:1>]<EOL>if not ext:<EOL><INDENT>ext = mimetypes.guess_extension(content_type)<EOL>if ext:<EOL><INDENT>filename += ext<EOL><DEDENT><DEDENT>if not ext and link.url != resp.url:<EOL><INDENT>ext = os.path.splitext(resp.url)[<NUM_LIT:1>]<EOL>if ext:<EOL><INDENT>filename += ext<EOL><DEDENT><DEDENT>file_path = os.path.join(temp_dir, filename)<EOL>with open(file_path, '<STR_LIT:wb>') as content_file:<EOL><INDENT>_download_url(resp, link, content_file)<EOL><DEDENT>return file_path, content_type<EOL>", "docstring": "Download link url into temp_dir using provided session", "id": "f17159:m17"}
{"signature": "def cfg_convert(self, value):", "body": "rest = value<EOL>m = self.WORD_PATTERN.match(rest)<EOL>if m is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % value)<EOL><DEDENT>else:<EOL><INDENT>rest = rest[m.end():]<EOL>d = self.config[m.groups()[<NUM_LIT:0>]]<EOL>while rest:<EOL><INDENT>m = self.DOT_PATTERN.match(rest)<EOL>if m:<EOL><INDENT>d = d[m.groups()[<NUM_LIT:0>]]<EOL><DEDENT>else:<EOL><INDENT>m = self.INDEX_PATTERN.match(rest)<EOL>if m:<EOL><INDENT>idx = m.groups()[<NUM_LIT:0>]<EOL>if not self.DIGIT_PATTERN.match(idx):<EOL><INDENT>d = d[idx]<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>n = int(idx)  <EOL>d = d[n]<EOL><DEDENT>except TypeError:<EOL><INDENT>d = d[idx]<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if m:<EOL><INDENT>rest = rest[m.end():]<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>' % (value, rest))<EOL><DEDENT><DEDENT><DEDENT>return d<EOL>", "docstring": "Default converter for the cfg:// protocol.", "id": "f17160:c3:m3"}
{"signature": "def as_tuple(self, value):", "body": "if isinstance(value, list):<EOL><INDENT>value = tuple(value)<EOL><DEDENT>return value<EOL>", "docstring": "Utility function which converts lists to tuples.", "id": "f17160:c3:m6"}
{"signature": "def configure_custom(self, config):", "body": "c = config.pop('<STR_LIT>')<EOL>if not hasattr(c, '<STR_LIT>') and hasattr(types, '<STR_LIT>') and type(c) != types.ClassType:<EOL><INDENT>c = self.resolve(c)<EOL><DEDENT>props = config.pop('<STR_LIT:.>', None)<EOL>kwargs = dict((k, config[k]) for k in config if valid_ident(k))<EOL>result = c(**kwargs)<EOL>if props:<EOL><INDENT>for name, value in props.items():<EOL><INDENT>setattr(result, name, value)<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Configure an object with a user-supplied factory.", "id": "f17160:c3:m5"}
{"signature": "def add_filters(self, filterer, filters):", "body": "for f in filters:<EOL><INDENT>try:<EOL><INDENT>filterer.addFilter(self.config['<STR_LIT>'][f])<EOL><DEDENT>except StandardError as e:<EOL><INDENT>raise ValueError('<STR_LIT>' % (f, e))<EOL><DEDENT><DEDENT>", "docstring": "Add filters to a filterer from a list of names.", "id": "f17160:c4:m3"}
{"signature": "def explicit_rel_links(self, rels=('<STR_LIT>', '<STR_LIT>')):", "body": "rels = set(rels)<EOL>for anchor in self.parsed.findall(\"<STR_LIT>\"):<EOL><INDENT>if anchor.get(\"<STR_LIT>\") and anchor.get(\"<STR_LIT>\"):<EOL><INDENT>found_rels = set(anchor.get(\"<STR_LIT>\").split())<EOL>if found_rels & rels:<EOL><INDENT>href = anchor.get(\"<STR_LIT>\")<EOL>url = self.clean_link(<EOL>urllib_parse.urljoin(self.base_url, href)<EOL>)<EOL>yield Link(url, self, trusted=False)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Yields all links with the given relations", "id": "f17162:c1:m9"}
{"signature": "def _link_package_versions(self, link, search_name):", "body": "platform = get_platform()<EOL>version = None<EOL>if link.egg_fragment:<EOL><INDENT>egg_info = link.egg_fragment<EOL><DEDENT>else:<EOL><INDENT>egg_info, ext = link.splitext()<EOL>if not ext:<EOL><INDENT>if link not in self.logged_links:<EOL><INDENT>logger.debug('<STR_LIT>', link)<EOL>self.logged_links.add(link)<EOL><DEDENT>return<EOL><DEDENT>if egg_info.endswith('<STR_LIT>'):<EOL><INDENT>egg_info = egg_info[:-<NUM_LIT:4>]<EOL>ext = '<STR_LIT>' + ext<EOL><DEDENT>if ext not in self._known_extensions():<EOL><INDENT>if link not in self.logged_links:<EOL><INDENT>logger.debug(<EOL>'<STR_LIT>',<EOL>link,<EOL>ext,<EOL>)<EOL>self.logged_links.add(link)<EOL><DEDENT>return<EOL><DEDENT>if \"<STR_LIT>\" in link.path and ext == '<STR_LIT>':<EOL><INDENT>if link not in self.logged_links:<EOL><INDENT>logger.debug('<STR_LIT>', link)<EOL>self.logged_links.add(link)<EOL><DEDENT>return<EOL><DEDENT>if ext == wheel_ext:<EOL><INDENT>try:<EOL><INDENT>wheel = Wheel(link.filename)<EOL><DEDENT>except InvalidWheelFilename:<EOL><INDENT>logger.debug(<EOL>'<STR_LIT>',<EOL>link<EOL>)<EOL>return<EOL><DEDENT>if (pkg_resources.safe_name(wheel.name).lower()<EOL>!= pkg_resources.safe_name(search_name).lower()):<EOL><INDENT>logger.debug(<EOL>'<STR_LIT>',<EOL>link,<EOL>search_name,<EOL>)<EOL>return<EOL><DEDENT>if not wheel.supported():<EOL><INDENT>logger.debug(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>link,<EOL>)<EOL>return<EOL><DEDENT>comes_from = getattr(link, \"<STR_LIT>\", None)<EOL>if (<EOL>(<EOL>not platform.startswith('<STR_LIT>')<EOL>and not platform.startswith('<STR_LIT>')<EOL>and not platform == '<STR_LIT>'<EOL>)<EOL>and comes_from is not None<EOL>and urllib_parse.urlparse(<EOL>comes_from.url<EOL>).netloc.endswith(PyPI.netloc)):<EOL><INDENT>if not wheel.supported(tags=supported_tags_noarch):<EOL><INDENT>logger.debug(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>link,<EOL>)<EOL>return<EOL><DEDENT><DEDENT>version = wheel.version<EOL><DEDENT><DEDENT>if not version:<EOL><INDENT>version = self._egg_info_matches(egg_info, search_name, link)<EOL><DEDENT>if version is None:<EOL><INDENT>logger.debug(<EOL>'<STR_LIT>',<EOL>link,<EOL>search_name,<EOL>)<EOL>return<EOL><DEDENT>if (link.internal is not None<EOL>and not link.internal<EOL>and not normalize_name(search_name).lower()<EOL>in self.allow_external<EOL>and not self.allow_all_external):<EOL><INDENT>logger.debug(\"<STR_LIT>\", link)<EOL>self.need_warn_external = True<EOL>return<EOL><DEDENT>if (link.verifiable is not None<EOL>and not link.verifiable<EOL>and not (normalize_name(search_name).lower()<EOL>in self.allow_unverified)):<EOL><INDENT>logger.debug(<EOL>\"<STR_LIT>\",<EOL>link,<EOL>)<EOL>self.need_warn_unverified = True<EOL>return<EOL><DEDENT>match = self._py_version_re.search(version)<EOL>if match:<EOL><INDENT>version = version[:match.start()]<EOL>py_version = match.group(<NUM_LIT:1>)<EOL>if py_version != sys.version[:<NUM_LIT:3>]:<EOL><INDENT>logger.debug(<EOL>'<STR_LIT>', link<EOL>)<EOL>return<EOL><DEDENT><DEDENT>logger.debug('<STR_LIT>', link, version)<EOL>return InstallationCandidate(search_name, version, link)<EOL>", "docstring": "Return an iterable of triples (pkg_resources_version_key,\nlink, python_version) that can be extracted from the given\nlink.\n\nMeant to be overridden by subclasses, not called by clients.", "id": "f17162:c0:m12"}
{"signature": "def _sort_locations(self, locations):", "body": "files = []<EOL>urls = []<EOL>def sort_path(path):<EOL><INDENT>url = path_to_url(path)<EOL>if mimetypes.guess_type(url, strict=False)[<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>urls.append(url)<EOL><DEDENT>else:<EOL><INDENT>files.append(url)<EOL><DEDENT><DEDENT>for url in locations:<EOL><INDENT>is_local_path = os.path.exists(url)<EOL>is_file_url = url.startswith('<STR_LIT>')<EOL>is_find_link = url in self.find_links<EOL>if is_local_path or is_file_url:<EOL><INDENT>if is_local_path:<EOL><INDENT>path = url<EOL><DEDENT>else:<EOL><INDENT>path = url_to_path(url)<EOL><DEDENT>if is_find_link and os.path.isdir(path):<EOL><INDENT>path = os.path.realpath(path)<EOL>for item in os.listdir(path):<EOL><INDENT>sort_path(os.path.join(path, item))<EOL><DEDENT><DEDENT>elif is_file_url and os.path.isdir(path):<EOL><INDENT>urls.append(url)<EOL><DEDENT>elif os.path.isfile(path):<EOL><INDENT>sort_path(path)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>urls.append(url)<EOL><DEDENT><DEDENT>return files, urls<EOL>", "docstring": "Sort locations into \"files\" (archives) and \"urls\", and return\na pair of lists (files,urls)", "id": "f17162:c0:m2"}
{"signature": "def _sort_links(self, links):", "body": "eggs, no_eggs = [], []<EOL>seen = set()<EOL>for link in links:<EOL><INDENT>if link not in seen:<EOL><INDENT>seen.add(link)<EOL>if link.egg_fragment:<EOL><INDENT>eggs.append(link)<EOL><DEDENT>else:<EOL><INDENT>no_eggs.append(link)<EOL><DEDENT><DEDENT><DEDENT>return no_eggs + eggs<EOL>", "docstring": "Returns elements of links in order, non-egg links first, egg links\nsecond, while eliminating duplicates", "id": "f17162:c0:m9"}
{"signature": "def check_compatibility(version, name):", "body": "if not version:<EOL><INDENT>raise UnsupportedWheel(<EOL>\"<STR_LIT>\" % name<EOL>)<EOL><DEDENT>if version[<NUM_LIT:0>] > VERSION_COMPATIBLE[<NUM_LIT:0>]:<EOL><INDENT>raise UnsupportedWheel(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (name, '<STR_LIT:.>'.join(map(str, version)))<EOL>)<EOL><DEDENT>elif version > VERSION_COMPATIBLE:<EOL><INDENT>logger.warning(<EOL>'<STR_LIT>',<EOL>'<STR_LIT:.>'.join(map(str, version)),<EOL>)<EOL><DEDENT>", "docstring": "Raises errors or warns if called with an incompatible Wheel-Version.\n\nPip should refuse to install a Wheel-Version that's a major series\nahead of what it's compatible with (e.g 2.0 > 1.1); and warn when\ninstalling a version only minor version ahead (e.g 1.2 > 1.1).\n\nversion: a 2-tuple representing a Wheel-Version (Major, Minor)\nname: name of wheel or package to raise exception about\n\n:raises UnsupportedWheel: when an incompatible Wheel-Version is given", "id": "f17165:m9"}
{"signature": "def move_wheel_files(name, req, wheeldir, user=False, home=None, root=None,<EOL>pycompile=True, scheme=None, isolated=False):", "body": "if not scheme:<EOL><INDENT>scheme = distutils_scheme(<EOL>name, user=user, home=home, root=root, isolated=isolated<EOL>)<EOL><DEDENT>if root_is_purelib(name, wheeldir):<EOL><INDENT>lib_dir = scheme['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>lib_dir = scheme['<STR_LIT>']<EOL><DEDENT>info_dir = []<EOL>data_dirs = []<EOL>source = wheeldir.rstrip(os.path.sep) + os.path.sep<EOL>installed = {}<EOL>changed = set()<EOL>generated = []<EOL>if pycompile:<EOL><INDENT>with captured_stdout() as stdout:<EOL><INDENT>compileall.compile_dir(source, force=True, quiet=True)<EOL><DEDENT>logger.info(remove_tracebacks(stdout.getvalue()))<EOL><DEDENT>def normpath(src, p):<EOL><INDENT>return make_path_relative(src, p).replace(os.path.sep, '<STR_LIT:/>')<EOL><DEDENT>def record_installed(srcfile, destfile, modified=False):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>oldpath = normpath(srcfile, wheeldir)<EOL>newpath = normpath(destfile, lib_dir)<EOL>installed[oldpath] = newpath<EOL>if modified:<EOL><INDENT>changed.add(destfile)<EOL><DEDENT><DEDENT>def clobber(source, dest, is_base, fixer=None, filter=None):<EOL><INDENT>if not os.path.exists(dest):  <EOL><INDENT>os.makedirs(dest)<EOL><DEDENT>for dir, subdirs, files in os.walk(source):<EOL><INDENT>basedir = dir[len(source):].lstrip(os.path.sep)<EOL>destdir = os.path.join(dest, basedir)<EOL>if is_base and basedir.split(os.path.sep, <NUM_LIT:1>)[<NUM_LIT:0>].endswith('<STR_LIT>'):<EOL><INDENT>continue<EOL><DEDENT>for s in subdirs:<EOL><INDENT>destsubdir = os.path.join(dest, basedir, s)<EOL>if is_base and basedir == '<STR_LIT>' and destsubdir.endswith('<STR_LIT>'):<EOL><INDENT>data_dirs.append(s)<EOL>continue<EOL><DEDENT>elif (is_base<EOL>and s.endswith('<STR_LIT>')<EOL>and s.lower().startswith(<EOL>req.project_name.replace('<STR_LIT:->', '<STR_LIT:_>').lower())):<EOL><INDENT>assert not info_dir, '<STR_LIT>'<EOL>info_dir.append(destsubdir)<EOL><DEDENT><DEDENT>for f in files:<EOL><INDENT>if filter and filter(f):<EOL><INDENT>continue<EOL><DEDENT>srcfile = os.path.join(dir, f)<EOL>destfile = os.path.join(dest, basedir, f)<EOL>if not os.path.exists(destdir):<EOL><INDENT>os.makedirs(destdir)<EOL><DEDENT>shutil.copyfile(srcfile, destfile)<EOL>st = os.stat(srcfile)<EOL>if hasattr(os, \"<STR_LIT>\"):<EOL><INDENT>os.utime(destfile, (st.st_atime, st.st_mtime))<EOL><DEDENT>if os.access(srcfile, os.X_OK):<EOL><INDENT>st = os.stat(srcfile)<EOL>permissions = (<EOL>st.st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH<EOL>)<EOL>os.chmod(destfile, permissions)<EOL><DEDENT>changed = False<EOL>if fixer:<EOL><INDENT>changed = fixer(destfile)<EOL><DEDENT>record_installed(srcfile, destfile, changed)<EOL><DEDENT><DEDENT><DEDENT>clobber(source, lib_dir, True)<EOL>assert info_dir, \"<STR_LIT>\" % req<EOL>ep_file = os.path.join(info_dir[<NUM_LIT:0>], '<STR_LIT>')<EOL>console, gui = get_entrypoints(ep_file)<EOL>def is_entrypoint_wrapper(name):<EOL><INDENT>if name.lower().endswith('<STR_LIT>'):<EOL><INDENT>matchname = name[:-<NUM_LIT:4>]<EOL><DEDENT>elif name.lower().endswith('<STR_LIT>'):<EOL><INDENT>matchname = name[:-<NUM_LIT:10>]<EOL><DEDENT>elif name.lower().endswith(\"<STR_LIT>\"):<EOL><INDENT>matchname = name[:-<NUM_LIT:4>]<EOL><DEDENT>else:<EOL><INDENT>matchname = name<EOL><DEDENT>return (matchname in console or matchname in gui)<EOL><DEDENT>for datadir in data_dirs:<EOL><INDENT>fixer = None<EOL>filter = None<EOL>for subdir in os.listdir(os.path.join(wheeldir, datadir)):<EOL><INDENT>fixer = None<EOL>if subdir == '<STR_LIT>':<EOL><INDENT>fixer = fix_script<EOL>filter = is_entrypoint_wrapper<EOL><DEDENT>source = os.path.join(wheeldir, datadir, subdir)<EOL>dest = scheme[subdir]<EOL>clobber(source, dest, False, fixer=fixer, filter=filter)<EOL><DEDENT><DEDENT>maker = ScriptMaker(None, scheme['<STR_LIT>'])<EOL>maker.clobber = True<EOL>maker.variants = set(('<STR_LIT>', ))<EOL>maker.set_mode = True<EOL>def _get_script_text(entry):<EOL><INDENT>return maker.script_template % {<EOL>\"<STR_LIT>\": entry.prefix,<EOL>\"<STR_LIT>\": entry.suffix.split(\"<STR_LIT:.>\")[<NUM_LIT:0>],<EOL>\"<STR_LIT>\": entry.suffix,<EOL>}<EOL><DEDENT>maker._get_script_text = _get_script_text<EOL>maker.script_template =", "docstring": "Install a wheel", "id": "f17165:m5"}
{"signature": "def build(self):", "body": "<EOL>self.requirement_set.prepare_files(self.finder)<EOL>reqset = self.requirement_set.requirements.values()<EOL>buildset = []<EOL>for req in reqset:<EOL><INDENT>if req.is_wheel:<EOL><INDENT>logger.info(<EOL>'<STR_LIT>', req.name,<EOL>)<EOL><DEDENT>elif req.editable:<EOL><INDENT>logger.info(<EOL>'<STR_LIT>', req.name,<EOL>)<EOL><DEDENT>else:<EOL><INDENT>buildset.append(req)<EOL><DEDENT><DEDENT>if not buildset:<EOL><INDENT>return True<EOL><DEDENT>logger.info(<EOL>'<STR_LIT>',<EOL>'<STR_LIT:U+002CU+0020>'.join([req.name for req in buildset]),<EOL>)<EOL>with indent_log():<EOL><INDENT>build_success, build_failure = [], []<EOL>for req in buildset:<EOL><INDENT>if self._build_one(req):<EOL><INDENT>build_success.append(req)<EOL><DEDENT>else:<EOL><INDENT>build_failure.append(req)<EOL><DEDENT><DEDENT><DEDENT>if build_success:<EOL><INDENT>logger.info(<EOL>'<STR_LIT>',<EOL>'<STR_LIT:U+0020>'.join([req.name for req in build_success]),<EOL>)<EOL><DEDENT>if build_failure:<EOL><INDENT>logger.info(<EOL>'<STR_LIT>',<EOL>'<STR_LIT:U+0020>'.join([req.name for req in build_failure]),<EOL>)<EOL><DEDENT>return len(build_failure) == <NUM_LIT:0><EOL>", "docstring": "Build wheels.", "id": "f17165:c1:m2"}
{"signature": "def remove_temporary_source(self):", "body": "if self.source_dir and os.path.exists(<EOL>os.path.join(self.source_dir, PIP_DELETE_MARKER_FILENAME)):<EOL><INDENT>logger.debug('<STR_LIT>', self.source_dir)<EOL>rmtree(self.source_dir)<EOL><DEDENT>self.source_dir = None<EOL>if self._temp_build_dir and os.path.exists(self._temp_build_dir):<EOL><INDENT>rmtree(self._temp_build_dir)<EOL><DEDENT>self._temp_build_dir = None<EOL>", "docstring": "Remove the source files from this requirement, if they are marked\n        for deletion", "id": "f17171:c0:m25"}
{"signature": "def correct_build_location(self):", "body": "if self.source_dir is not None:<EOL><INDENT>return<EOL><DEDENT>assert self.req is not None<EOL>assert self._temp_build_dir<EOL>old_location = self._temp_build_dir<EOL>new_build_dir = self._ideal_build_dir<EOL>del self._ideal_build_dir<EOL>if self.editable:<EOL><INDENT>name = self.name.lower()<EOL><DEDENT>else:<EOL><INDENT>name = self.name<EOL><DEDENT>new_location = os.path.join(new_build_dir, name)<EOL>if not os.path.exists(new_build_dir):<EOL><INDENT>logger.debug('<STR_LIT>', new_build_dir)<EOL>_make_build_dir(new_build_dir)<EOL><DEDENT>if os.path.exists(new_location):<EOL><INDENT>raise InstallationError(<EOL>'<STR_LIT>'<EOL>% display_path(new_location))<EOL><DEDENT>logger.debug(<EOL>'<STR_LIT>',<EOL>self, display_path(old_location), display_path(new_location),<EOL>)<EOL>shutil.move(old_location, new_location)<EOL>self._temp_build_dir = new_location<EOL>self.source_dir = new_location<EOL>self._egg_info_path = None<EOL>", "docstring": "If the build location was a temporary directory, this will move it\n        to a new more permanent location", "id": "f17171:c0:m7"}
{"signature": "def read_text_file(filename):", "body": "with open(filename, '<STR_LIT:rb>') as fp:<EOL><INDENT>data = fp.read()<EOL><DEDENT>encodings = ['<STR_LIT:utf-8>', locale.getpreferredencoding(False), '<STR_LIT>']<EOL>for enc in encodings:<EOL><INDENT>try:<EOL><INDENT>data = data.decode(enc)<EOL><DEDENT>except UnicodeDecodeError:<EOL><INDENT>continue<EOL><DEDENT>break<EOL><DEDENT>assert type(data) != bytes  <EOL>return data<EOL>", "docstring": "Return the contents of *filename*.\n\n    Try to decode the file contents with utf-8, the preferred system encoding\n    (e.g., cp1252 on some Windows machines), and latin1, in that order.\n    Decoding a byte string with latin1 will never raise an error. In the worst\n    case, the returned string will contain some garbage characters.", "id": "f17179:m35"}
{"signature": "def captured_stdout():", "body": "return captured_output('<STR_LIT>')<EOL>", "docstring": "Capture the output of sys.stdout:\n\n       with captured_stdout() as stdout:\n           print('hello')\n       self.assertEqual(stdout.getvalue(), 'hello\\n')\n\n    Taken from Lib/support/__init__.py in the CPython repo.", "id": "f17179:m38"}
{"signature": "def is_local(path):", "body": "if not running_under_virtualenv():<EOL><INDENT>return True<EOL><DEDENT>return normalize_path(path).startswith(normalize_path(sys.prefix))<EOL>", "docstring": "Return True if path is within sys.prefix, if we're running in a virtualenv.\n\nIf we're not in a virtualenv, all paths are considered \"local.\"", "id": "f17179:m20"}
{"signature": "def untar_file(filename, location):", "body": "if not os.path.exists(location):<EOL><INDENT>os.makedirs(location)<EOL><DEDENT>if filename.lower().endswith('<STR_LIT>') or filename.lower().endswith('<STR_LIT>'):<EOL><INDENT>mode = '<STR_LIT>'<EOL><DEDENT>elif (filename.lower().endswith('<STR_LIT>')<EOL>or filename.lower().endswith('<STR_LIT>')):<EOL><INDENT>mode = '<STR_LIT>'<EOL><DEDENT>elif filename.lower().endswith('<STR_LIT>'):<EOL><INDENT>mode = '<STR_LIT:r>'<EOL><DEDENT>else:<EOL><INDENT>logger.warning(<EOL>'<STR_LIT>', filename,<EOL>)<EOL>mode = '<STR_LIT>'<EOL><DEDENT>tar = tarfile.open(filename, mode)<EOL>try:<EOL><INDENT>leading = has_leading_dir([<EOL>member.name for member in tar.getmembers()<EOL>if member.name != '<STR_LIT>'<EOL>])<EOL>for member in tar.getmembers():<EOL><INDENT>fn = member.name<EOL>if fn == '<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>if leading:<EOL><INDENT>fn = split_leading_dir(fn)[<NUM_LIT:1>]<EOL><DEDENT>path = os.path.join(location, fn)<EOL>if member.isdir():<EOL><INDENT>if not os.path.exists(path):<EOL><INDENT>os.makedirs(path)<EOL><DEDENT><DEDENT>elif member.issym():<EOL><INDENT>try:<EOL><INDENT>tar._extract_member(member, path)<EOL><DEDENT>except Exception as exc:<EOL><INDENT>logger.warning(<EOL>'<STR_LIT>',<EOL>filename, member.name, exc,<EOL>)<EOL>continue<EOL><DEDENT><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>fp = tar.extractfile(member)<EOL><DEDENT>except (KeyError, AttributeError) as exc:<EOL><INDENT>logger.warning(<EOL>'<STR_LIT>',<EOL>filename, member.name, exc,<EOL>)<EOL>continue<EOL><DEDENT>if not os.path.exists(os.path.dirname(path)):<EOL><INDENT>os.makedirs(os.path.dirname(path))<EOL><DEDENT>destfp = open(path, '<STR_LIT:wb>')<EOL>try:<EOL><INDENT>shutil.copyfileobj(fp, destfp)<EOL><DEDENT>finally:<EOL><INDENT>destfp.close()<EOL><DEDENT>fp.close()<EOL>if member.mode & <NUM_LIT>:<EOL><INDENT>os.chmod(path, (<NUM_LIT> - current_umask() | <NUM_LIT>))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>finally:<EOL><INDENT>tar.close()<EOL><DEDENT>", "docstring": "Untar the file (with path `filename`) to the destination `location`.\nAll files are written based on system defaults and umask (i.e. permissions\nare not preserved), except that regular file members with any execute\npermissions (user, group, or world) have \"chmod +x\" applied after being\nwritten.  Note that for windows, any execute changes using os.chmod are\nno-ops per the python docs.", "id": "f17179:m31"}
{"signature": "def rmtree_errorhandler(func, path, exc_info):", "body": "<EOL>if os.stat(path).st_mode & stat.S_IREAD:<EOL><INDENT>os.chmod(path, stat.S_IWRITE)<EOL>func(path)<EOL>return<EOL><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT>", "docstring": "On Windows, the files in .svn are read-only, so when rmtree() tries to\n    remove them, an exception is thrown.  We catch that here, remove the\n    read-only attribute, and hopefully continue without problems.", "id": "f17179:m2"}
{"signature": "def run(self, options, args):", "body": "shells = COMPLETION_SCRIPTS.keys()<EOL>shell_options = ['<STR_LIT>' + shell for shell in sorted(shells)]<EOL>if options.shell in shells:<EOL><INDENT>script = COMPLETION_SCRIPTS.get(options.shell, '<STR_LIT>')<EOL>print(BASE_COMPLETION % {'<STR_LIT>': script, '<STR_LIT>': options.shell})<EOL><DEDENT>else:<EOL><INDENT>sys.stderr.write(<EOL>'<STR_LIT>' % '<STR_LIT>'.join(shell_options)<EOL>)<EOL><DEDENT>", "docstring": "Prints the completion code of the given shell", "id": "f17182:c0:m1"}
{"signature": "def transform_hits(hits):", "body": "packages = {}<EOL>for hit in hits:<EOL><INDENT>name = hit['<STR_LIT:name>']<EOL>summary = hit['<STR_LIT>']<EOL>version = hit['<STR_LIT:version>']<EOL>score = hit['<STR_LIT>']<EOL>if score is None:<EOL><INDENT>score = <NUM_LIT:0><EOL><DEDENT>if name not in packages.keys():<EOL><INDENT>packages[name] = {<EOL>'<STR_LIT:name>': name,<EOL>'<STR_LIT>': summary,<EOL>'<STR_LIT>': [version],<EOL>'<STR_LIT>': score,<EOL>}<EOL><DEDENT>else:<EOL><INDENT>packages[name]['<STR_LIT>'].append(version)<EOL>if version == highest_version(packages[name]['<STR_LIT>']):<EOL><INDENT>packages[name]['<STR_LIT>'] = summary<EOL>packages[name]['<STR_LIT>'] = score<EOL><DEDENT><DEDENT><DEDENT>package_list = sorted(<EOL>packages.values(),<EOL>key=lambda x: x['<STR_LIT>'],<EOL>reverse=True,<EOL>)<EOL>return package_list<EOL>", "docstring": "The list from pypi is really a list of versions. We want a list of\npackages with the list of versions stored inline. This converts the\nlist from pypi into one we can use.", "id": "f17186:m0"}
{"signature": "def _build_package_finder(self, options, index_urls, session):", "body": "return PackageFinder(<EOL>find_links=options.find_links,<EOL>index_urls=index_urls,<EOL>use_wheel=options.use_wheel,<EOL>allow_external=options.allow_external,<EOL>allow_unverified=options.allow_unverified,<EOL>allow_all_external=options.allow_all_external,<EOL>trusted_hosts=options.trusted_hosts,<EOL>allow_all_prereleases=options.pre,<EOL>process_dependency_links=options.process_dependency_links,<EOL>session=session,<EOL>)<EOL>", "docstring": "Create a package finder appropriate to this install command.\nThis method is meant to be overridden by subclasses, not\ncalled directly.", "id": "f17190:c0:m1"}
{"signature": "def get_similar_commands(name):", "body": "from difflib import get_close_matches<EOL>name = name.lower()<EOL>close_commands = get_close_matches(name, commands_dict.keys())<EOL>if close_commands:<EOL><INDENT>return close_commands[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Command name auto-correct.", "id": "f17191:m1"}
{"signature": "def should_wrap(self):", "body": "return self.convert or self.strip or self.autoreset<EOL>", "docstring": "True if this class is actually needed. If false, then the output\nstream will not be affected, nor will win32 calls be issued, so\nwrapping stdout is not actually required. This will generally be\nFalse on non-Windows platforms, unless optional functionality like\nautoreset has been requested using kwargs to init()", "id": "f17194:c1:m1"}
{"signature": "def write_and_convert(self, text):", "body": "cursor = <NUM_LIT:0><EOL>text = self.convert_osc(text)<EOL>for match in self.ANSI_CSI_RE.finditer(text):<EOL><INDENT>start, end = match.span()<EOL>self.write_plain_text(text, cursor, start)<EOL>self.convert_ansi(*match.groups())<EOL>cursor = end<EOL><DEDENT>self.write_plain_text(text, cursor, len(text))<EOL>", "docstring": "Write the given text to our wrapped stream, stripping any ANSI\nsequences from the text, and optionally converting them into win32\ncalls.", "id": "f17194:c1:m5"}
{"signature": "def parseFragment(self, stream, container=\"<STR_LIT>\", encoding=None,<EOL>parseMeta=False, useChardet=True):", "body": "self._parse(stream, True, container=container, encoding=encoding)<EOL>return self.tree.getFragment()<EOL>", "docstring": "Parse a HTML fragment into a well-formed tree fragment\n\n        container - name of the element we're setting the innerHTML property\n        if set to None, default to 'div'\n\n        stream - a filelike object or string containing the HTML to be parsed\n\n        The optional encoding parameter must be a string that indicates\n        the encoding.  If specified, that encoding will be used,\n        regardless of any BOM or later declaration (such as in a meta\n        element)", "id": "f17201:c0:m8"}
{"signature": "def parse(doc, treebuilder=\"<STR_LIT>\", encoding=None,<EOL>namespaceHTMLElements=True):", "body": "tb = treebuilders.getTreeBuilder(treebuilder)<EOL>p = HTMLParser(tb, namespaceHTMLElements=namespaceHTMLElements)<EOL>return p.parse(doc, encoding=encoding)<EOL>", "docstring": "Parse a string or file-like object into a tree", "id": "f17201:m0"}
{"signature": "def __init__(self, tree=None, tokenizer=tokenizer.HTMLTokenizer,<EOL>strict=False, namespaceHTMLElements=True, debug=False):", "body": "<EOL>self.strict = strict<EOL>if tree is None:<EOL><INDENT>tree = treebuilders.getTreeBuilder(\"<STR_LIT>\")<EOL><DEDENT>self.tree = tree(namespaceHTMLElements)<EOL>self.tokenizer_class = tokenizer<EOL>self.errors = []<EOL>self.phases = dict([(name, cls(self, self.tree)) for name, cls in<EOL>getPhases(debug).items()])<EOL>", "docstring": "strict - raise an exception when a parse error is encountered\n\ntree - a treebuilder class controlling the type of tree that will be\nreturned. Built in treebuilders can be accessed through\nhtml5lib.treebuilders.getTreeBuilder(treeType)\n\ntokenizer - a class that provides a stream of tokens to the treebuilder.\nThis may be replaced for e.g. a sanitizer which converts some tags to\ntext", "id": "f17201:c0:m0"}
{"signature": "def cloneNode(self):", "body": "raise NotImplementedError<EOL>", "docstring": "Return a shallow copy of the current node i.e. a node with the same\n        name and attributes but with no parent or child nodes", "id": "f17205:c0:m8"}
{"signature": "def appendChild(self, node):", "body": "raise NotImplementedError<EOL>", "docstring": "Insert node as a child of the current node", "id": "f17205:c0:m3"}
{"signature": "def createElement(self, token):", "body": "name = token[\"<STR_LIT:name>\"]<EOL>namespace = token.get(\"<STR_LIT>\", self.defaultNamespace)<EOL>element = self.elementClass(name, namespace)<EOL>element.attributes = token[\"<STR_LIT:data>\"]<EOL>return element<EOL>", "docstring": "Create an element but don't insert it anywhere", "id": "f17205:c2:m9"}
{"signature": "def insertText(self, data, parent=None):", "body": "if parent is None:<EOL><INDENT>parent = self.openElements[-<NUM_LIT:1>]<EOL><DEDENT>if (not self.insertFromTable or (self.insertFromTable and<EOL>self.openElements[-<NUM_LIT:1>].name<EOL>not in tableInsertModeElements)):<EOL><INDENT>parent.insertText(data)<EOL><DEDENT>else:<EOL><INDENT>parent, insertBefore = self.getTableMisnestedNodePosition()<EOL>parent.insertText(data, insertBefore)<EOL><DEDENT>", "docstring": "Insert text data.", "id": "f17205:c2:m14"}
{"signature": "def _setInsertFromTable(self, value):", "body": "self._insertFromTable = value<EOL>if value:<EOL><INDENT>self.insertElement = self.insertElementTable<EOL><DEDENT>else:<EOL><INDENT>self.insertElement = self.insertElementNormal<EOL><DEDENT>", "docstring": "Switch the function used to insert an element from the\n        normal one to the misnested table one and back again", "id": "f17205:c2:m11"}
{"signature": "def insertBefore(self, node, refNode):", "body": "raise NotImplementedError<EOL>", "docstring": "Insert node as a child of the current node, before refNode in the\n        list of child nodes. Raises ValueError if refNode is not a child of\n        the current node", "id": "f17205:c0:m5"}
{"signature": "def tostring(element):", "body": "rv = []<EOL>finalText = None<EOL>def serializeElement(element):<EOL><INDENT>if not hasattr(element, \"<STR_LIT>\"):<EOL><INDENT>if element.docinfo.internalDTD:<EOL><INDENT>if element.docinfo.doctype:<EOL><INDENT>dtd_str = element.docinfo.doctype<EOL><DEDENT>else:<EOL><INDENT>dtd_str = \"<STR_LIT>\" % element.docinfo.root_name<EOL><DEDENT>rv.append(dtd_str)<EOL><DEDENT>serializeElement(element.getroot())<EOL><DEDENT>elif element.tag == comment_type:<EOL><INDENT>rv.append(\"<STR_LIT>\" % (element.text,))<EOL><DEDENT>else:<EOL><INDENT>if not element.attrib:<EOL><INDENT>rv.append(\"<STR_LIT>\" % (element.tag,))<EOL><DEDENT>else:<EOL><INDENT>attr = \"<STR_LIT:U+0020>\".join([\"<STR_LIT>\" % (name, value)<EOL>for name, value in element.attrib.items()])<EOL>rv.append(\"<STR_LIT>\" % (element.tag, attr))<EOL><DEDENT>if element.text:<EOL><INDENT>rv.append(element.text)<EOL><DEDENT>for child in element:<EOL><INDENT>serializeElement(child)<EOL><DEDENT>rv.append(\"<STR_LIT>\" % (element.tag,))<EOL><DEDENT>if hasattr(element, \"<STR_LIT>\") and element.tail:<EOL><INDENT>rv.append(element.tail)<EOL><DEDENT><DEDENT>serializeElement(element)<EOL>if finalText is not None:<EOL><INDENT>rv.append(\"<STR_LIT>\" % ('<STR_LIT:U+0020>' * <NUM_LIT:2>, finalText))<EOL><DEDENT>return \"<STR_LIT>\".join(rv)<EOL>", "docstring": "Serialize an element and its child nodes to a string", "id": "f17206:m1"}
{"signature": "def matchBytes(self, bytes):", "body": "p = self.position<EOL>data = self[p:p + len(bytes)]<EOL>rv = data.startswith(bytes)<EOL>if rv:<EOL><INDENT>self.position += len(bytes)<EOL><DEDENT>return rv<EOL>", "docstring": "Look for a sequence of bytes at the start of a string. If the bytes\n        are found return True and advance the position to the byte after the\n        match. Otherwise return False and leave the position alone", "id": "f17224:c3:m11"}
{"signature": "def openStream(self, source):", "body": "<EOL>if hasattr(source, '<STR_LIT>'):<EOL><INDENT>stream = source<EOL><DEDENT>else:<EOL><INDENT>stream = StringIO(source)<EOL><DEDENT>return stream<EOL>", "docstring": "Produces a file object from source.\n\n        source can be either a file object, local filename or a string.", "id": "f17224:c1:m2"}
{"signature": "def SerializeError(Exception):", "body": "pass<EOL>", "docstring": "Error in serialized tree", "id": "f17226:m0"}
{"signature": "def resource_listdir(resource_name):", "body": "", "docstring": "List of resource names in the directory (like ``os.listdir()``)", "id": "f17242:c9:m5"}
{"signature": "def add_entry(self, entry):", "body": "self.entry_keys.setdefault(entry, [])<EOL>self.entries.append(entry)<EOL>for dist in find_distributions(entry, True):<EOL><INDENT>self.add(dist, entry, False)<EOL><DEDENT>", "docstring": "Add a path item to ``.entries``, finding any distributions on it\n\n        ``find_distributions(entry, True)`` is used to find distributions\n        corresponding to the path entry, and they are added.  `entry` is\n        always appended to ``.entries``, even if it is already present.\n        (This is because ``sys.path`` can contain the same value more than\n        once, and the ``.entries`` of the ``sys.path`` WorkingSet should always\n        equal ``sys.path``.)", "id": "f17242:c10:m3"}
{"signature": "def _preparse_requirement(self, requires_dist):", "body": "parts = requires_dist.split('<STR_LIT:;>', <NUM_LIT:1>) + ['<STR_LIT>']<EOL>distvers = parts[<NUM_LIT:0>].strip()<EOL>mark = parts[<NUM_LIT:1>].strip()<EOL>distvers = re.sub(self.EQEQ, r\"<STR_LIT>\", distvers)<EOL>distvers = distvers.replace('<STR_LIT:(>', '<STR_LIT>').replace('<STR_LIT:)>', '<STR_LIT>')<EOL>return (distvers, mark)<EOL>", "docstring": "Convert 'Foobar (1); baz' to ('Foobar ==1', 'baz')\n        Split environment marker, add == prefix to version specifiers as\n        necessary, and remove parenthesis.", "id": "f17242:c28:m2"}
{"signature": "@classmethod<EOL><INDENT>def _build_master(cls):<DEDENT>", "body": "ws = cls()<EOL>try:<EOL><INDENT>from __main__ import __requires__<EOL><DEDENT>except ImportError:<EOL><INDENT>return ws<EOL><DEDENT>try:<EOL><INDENT>ws.require(__requires__)<EOL><DEDENT>except VersionConflict:<EOL><INDENT>return cls._build_from_requirements(__requires__)<EOL><DEDENT>return ws<EOL>", "docstring": "Prepare the master working set.", "id": "f17242:c10:m1"}
{"signature": "def find_distributions(path_item, only=False):", "body": "importer = get_importer(path_item)<EOL>finder = _find_adapter(_distribution_finders, importer)<EOL>return finder(importer, path_item, only)<EOL>", "docstring": "Yield distributions accessible via `path_item`", "id": "f17242:m26"}
{"signature": "def egg_name(self):", "body": "filename = \"<STR_LIT>\" % (<EOL>to_filename(self.project_name), to_filename(self.version),<EOL>self.py_version or PY_MAJOR<EOL>)<EOL>if self.platform:<EOL><INDENT>filename += '<STR_LIT:->' + self.platform<EOL><DEDENT>return filename<EOL>", "docstring": "Return what this distribution's standard .egg filename should be", "id": "f17242:c27:m17"}
{"signature": "def has_resource(resource_name):", "body": "", "docstring": "Does the package contain the named resource?", "id": "f17242:c9:m3"}
{"signature": "def get_default_cache():", "body": "try:<EOL><INDENT>return os.environ['<STR_LIT>']<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>if os.name!='<STR_LIT>':<EOL><INDENT>return os.path.expanduser('<STR_LIT>')<EOL><DEDENT>app_data = '<STR_LIT>'<EOL>app_homes = [<EOL>(('<STR_LIT>',), None),<EOL>(('<STR_LIT>',), app_data),<EOL>(('<STR_LIT>','<STR_LIT>'), app_data),<EOL>(('<STR_LIT>',), app_data),<EOL>(('<STR_LIT>',), None),<EOL>(('<STR_LIT>',), app_data),<EOL>]<EOL>for keys, subdir in app_homes:<EOL><INDENT>dirname = '<STR_LIT>'<EOL>for key in keys:<EOL><INDENT>if key in os.environ:<EOL><INDENT>dirname = os.path.join(dirname, os.environ[key])<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if subdir:<EOL><INDENT>dirname = os.path.join(dirname, subdir)<EOL><DEDENT>return os.path.join(dirname, '<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise RuntimeError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>", "docstring": "Determine the default cache location\n\n    This returns the ``PYTHON_EGG_CACHE`` environment variable, if set.\n    Otherwise, on Windows, it returns a \"Python-Eggs\" subdirectory of the\n    \"Application Data\" directory.  On all other systems, it's \"~/.python-eggs\".", "id": "f17242:m20"}
{"signature": "def _is_current(self, file_path, zip_path):", "body": "timestamp, size = self._get_date_and_size(self.zipinfo[zip_path])<EOL>if not os.path.isfile(file_path):<EOL><INDENT>return False<EOL><DEDENT>stat = os.stat(file_path)<EOL>if stat.st_size!=size or stat.st_mtime!=timestamp:<EOL><INDENT>return False<EOL><DEDENT>zip_contents = self.loader.get_data(zip_path)<EOL>with open(file_path, '<STR_LIT:rb>') as f:<EOL><INDENT>file_contents = f.read()<EOL><DEDENT>return zip_contents == file_contents<EOL>", "docstring": "Return True if the file_path is current for this zip_path", "id": "f17242:c22:m7"}
{"signature": "def resource_stream(self, package_or_requirement, resource_name):", "body": "return get_provider(package_or_requirement).get_resource_stream(<EOL>self, resource_name<EOL>)<EOL>", "docstring": "Return a readable file-like object for specified resource", "id": "f17242:c13:m4"}
{"signature": "def find_plugins(self, plugin_env, full_env=None, installer=None,<EOL>fallback=True):", "body": "plugin_projects = list(plugin_env)<EOL>plugin_projects.sort()<EOL>error_info = {}<EOL>distributions = {}<EOL>if full_env is None:<EOL><INDENT>env = Environment(self.entries)<EOL>env += plugin_env<EOL><DEDENT>else:<EOL><INDENT>env = full_env + plugin_env<EOL><DEDENT>shadow_set = self.__class__([])<EOL>list(map(shadow_set.add, self))<EOL>for project_name in plugin_projects:<EOL><INDENT>for dist in plugin_env[project_name]:<EOL><INDENT>req = [dist.as_requirement()]<EOL>try:<EOL><INDENT>resolvees = shadow_set.resolve(req, env, installer)<EOL><DEDENT>except ResolutionError:<EOL><INDENT>v = sys.exc_info()[<NUM_LIT:1>]<EOL>error_info[dist] = v<EOL>if fallback:<EOL><INDENT>continue<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>list(map(shadow_set.add, resolvees))<EOL>distributions.update(dict.fromkeys(resolvees))<EOL>break<EOL><DEDENT><DEDENT><DEDENT>distributions = list(distributions)<EOL>distributions.sort()<EOL>return distributions, error_info<EOL>", "docstring": "Find all activatable distributions in `plugin_env`\n\n        Example usage::\n\n            distributions, errors = working_set.find_plugins(\n                Environment(plugin_dirlist)\n            )\n            # add plugins+libs to sys.path\n            map(working_set.add, distributions)\n            # display errors\n            print('Could not load', errors)\n\n        The `plugin_env` should be an ``Environment`` instance that contains\n        only distributions that are in the project's \"plugin directory\" or\n        directories. The `full_env`, if supplied, should be an ``Environment``\n        contains all currently-available distributions.  If `full_env` is not\n        supplied, one is created automatically from the ``WorkingSet`` this\n        method is called on, which will typically mean that every directory on\n        ``sys.path`` will be scanned for distributions.\n\n        `installer` is a standard installer callback as used by the\n        ``resolve()`` method. The `fallback` flag indicates whether we should\n        attempt to resolve older versions of a plugin if the newest version\n        cannot be resolved.\n\n        This method returns a 2-tuple: (`distributions`, `error_info`), where\n        `distributions` is a list of the distributions found in `plugin_env`\n        that were loadable, along with any other distributions that are needed\n        to resolve their dependencies.  `error_info` is a dictionary mapping\n        unloadable plugin distributions to an exception instance describing the\n        error that occurred. Usually this will be a ``DistributionNotFound`` or\n        ``VersionConflict`` instance.", "id": "f17242:c10:m11"}
{"signature": "def __iter__(self):", "body": "for key in self._distmap.keys():<EOL><INDENT>if self[key]:<EOL><INDENT>yield key<EOL><DEDENT><DEDENT>", "docstring": "Yield the unique project names of the available distributions", "id": "f17242:c11:m8"}
{"signature": "def __getattr__(self, attr):", "body": "if attr.startswith('<STR_LIT:_>'):<EOL><INDENT>raise AttributeError(attr)<EOL><DEDENT>return getattr(self._provider, attr)<EOL>", "docstring": "Delegate all unrecognized public attributes to .metadata provider", "id": "f17242:c27:m20"}
{"signature": "def _find_adapter(registry, ob):", "body": "for t in _get_mro(getattr(ob, '<STR_LIT>', type(ob))):<EOL><INDENT>if t in registry:<EOL><INDENT>return registry[t]<EOL><DEDENT><DEDENT>", "docstring": "Return an adapter factory for `ob` from `registry`", "id": "f17242:m44"}
{"signature": "def __init__(self, search_path=None, platform=get_supported_platform(),<EOL>python=PY_MAJOR):", "body": "self._distmap = {}<EOL>self.platform = platform<EOL>self.python = python<EOL>self.scan(search_path)<EOL>", "docstring": "Snapshot distributions available on a search path\n\n        Any distributions found on `search_path` are added to the environment.\n        `search_path` should be a sequence of ``sys.path`` items.  If not\n        supplied, ``sys.path`` is used.\n\n        `platform` is an optional string specifying the name of the platform\n        that platform-specific distributions must be compatible with.  If\n        unspecified, it defaults to the current platform.  `python` is an\n        optional string naming the desired version of Python (e.g. ``'3.3'``);\n        it defaults to the current version.\n\n        You may explicitly set `platform` (and/or `python`) to ``None`` if you\n        wish to map *all* distributions, not just those compatible with the\n        running platform or Python version.", "id": "f17242:c11:m0"}
{"signature": "def find_on_path(importer, path_item, only=False):", "body": "path_item = _normalize_cached(path_item)<EOL>if os.path.isdir(path_item) and os.access(path_item, os.R_OK):<EOL><INDENT>if path_item.lower().endswith('<STR_LIT>'):<EOL><INDENT>yield Distribution.from_filename(<EOL>path_item, metadata=PathMetadata(<EOL>path_item, os.path.join(path_item,'<STR_LIT>')<EOL>)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>for entry in os.listdir(path_item):<EOL><INDENT>lower = entry.lower()<EOL>if lower.endswith('<STR_LIT>') or lower.endswith('<STR_LIT>'):<EOL><INDENT>fullpath = os.path.join(path_item, entry)<EOL>if os.path.isdir(fullpath):<EOL><INDENT>metadata = PathMetadata(path_item, fullpath)<EOL><DEDENT>else:<EOL><INDENT>metadata = FileMetadata(fullpath)<EOL><DEDENT>yield Distribution.from_location(<EOL>path_item, entry, metadata, precedence=DEVELOP_DIST<EOL>)<EOL><DEDENT>elif not only and lower.endswith('<STR_LIT>'):<EOL><INDENT>dists = find_distributions(os.path.join(path_item, entry))<EOL>for dist in dists:<EOL><INDENT>yield dist<EOL><DEDENT><DEDENT>elif not only and lower.endswith('<STR_LIT>'):<EOL><INDENT>with open(os.path.join(path_item, entry)) as entry_file:<EOL><INDENT>entry_lines = entry_file.readlines()<EOL><DEDENT>for line in entry_lines:<EOL><INDENT>if not line.strip():<EOL><INDENT>continue<EOL><DEDENT>path = os.path.join(path_item, line.rstrip())<EOL>dists = find_distributions(path)<EOL>for item in dists:<EOL><INDENT>yield item<EOL><DEDENT>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Yield distributions accessible on a sys.path directory", "id": "f17242:m29"}
{"signature": "def get_entry_info(dist, group, name):", "body": "return get_distribution(dist).get_entry_info(group, name)<EOL>", "docstring": "Return the EntryPoint object for `group`+`name`, or ``None``", "id": "f17242:m19"}
{"signature": "def find_eggs_in_zip(importer, path_item, only=False):", "body": "if importer.archive.endswith('<STR_LIT>'):<EOL><INDENT>return<EOL><DEDENT>metadata = EggMetadata(importer)<EOL>if metadata.has_metadata('<STR_LIT>'):<EOL><INDENT>yield Distribution.from_filename(path_item, metadata=metadata)<EOL><DEDENT>if only:<EOL><INDENT>return<EOL><DEDENT>for subitem in metadata.resource_listdir('<STR_LIT:/>'):<EOL><INDENT>if subitem.endswith('<STR_LIT>'):<EOL><INDENT>subpath = os.path.join(path_item, subitem)<EOL>for dist in find_eggs_in_zip(zipimport.zipimporter(subpath), subpath):<EOL><INDENT>yield dist<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Find eggs in zip files; possibly multiple nested eggs.", "id": "f17242:m27"}
{"signature": "def add(self, dist, entry=None, insert=True, replace=False):", "body": "if insert:<EOL><INDENT>dist.insert_on(self.entries, entry)<EOL><DEDENT>if entry is None:<EOL><INDENT>entry = dist.location<EOL><DEDENT>keys = self.entry_keys.setdefault(entry,[])<EOL>keys2 = self.entry_keys.setdefault(dist.location,[])<EOL>if not replace and dist.key in self.by_key:<EOL><INDENT>return<EOL><DEDENT>self.by_key[dist.key] = dist<EOL>if dist.key not in keys:<EOL><INDENT>keys.append(dist.key)<EOL><DEDENT>if dist.key not in keys2:<EOL><INDENT>keys2.append(dist.key)<EOL><DEDENT>self._added_new(dist)<EOL>", "docstring": "Add `dist` to working set, associated with `entry`\n\n        If `entry` is unspecified, it defaults to the ``.location`` of `dist`.\n        On exit from this routine, `entry` is added to the end of the working\n        set's ``.entries`` (if it wasn't already present).\n\n        `dist` is only added to the working set if it's for a project that\n        doesn't already have a distribution in the set, unless `replace=True`.\n        If it's added, any callbacks registered with the ``subscribe()`` method\n        will be called.", "id": "f17242:c10:m9"}
{"signature": "def clone(self,**kw):", "body": "names = '<STR_LIT>'<EOL>for attr in names.split():<EOL><INDENT>kw.setdefault(attr, getattr(self, attr, None))<EOL><DEDENT>kw.setdefault('<STR_LIT>', self._provider)<EOL>return self.__class__(**kw)<EOL>", "docstring": "Copy this distribution, substituting in any changed keyword args", "id": "f17242:c27:m29"}
{"signature": "def normalize_path(filename):", "body": "return os.path.normcase(os.path.realpath(filename))<EOL>", "docstring": "Normalize a file/dir name for comparison purposes", "id": "f17242:m36"}
{"signature": "def to_filename(name):", "body": "return name.replace('<STR_LIT:->','<STR_LIT:_>')<EOL>", "docstring": "Convert a project or version name to its filename-escaped form\n\n    Any '-' characters are currently replaced with '_'.", "id": "f17242:m24"}
{"signature": "def extraction_error(self):", "body": "old_exc = sys.exc_info()[<NUM_LIT:1>]<EOL>cache_path = self.extraction_path or get_default_cache()<EOL>err = ExtractionError(", "docstring": "Give an error message for problems extracting file(s)", "id": "f17242:c13:m7"}
{"signature": "def register_namespace_handler(importer_type, namespace_handler):", "body": "_namespace_handlers[importer_type] = namespace_handler<EOL>", "docstring": "Register `namespace_handler` to declare namespace packages\n\n    `importer_type` is the type or class of a PEP 302 \"Importer\" (sys.path item\n    handler), and `namespace_handler` is a callable like this::\n\n        def namespace_handler(importer, path_entry, moduleName, module):\n            # return a path_entry to use for child packages\n\n    Namespace handlers are only called if the importer object has already\n    agreed that it can handle the relevant path item, and they should only\n    return a subpath if the module __path__ does not already contain an\n    equivalent subpath.  For an example namespace handler, see\n    ``pkg_resources.file_ns_handler``.", "id": "f17242:m30"}
{"signature": "def has_metadata(name):", "body": "", "docstring": "Does the package's distribution contain the named metadata?", "id": "f17242:c8:m0"}
{"signature": "def run_script(script_name, namespace):", "body": "", "docstring": "Execute the named script in the supplied namespace dictionary", "id": "f17242:c8:m5"}
{"signature": "@staticmethod<EOL><INDENT>def normalize_exception(exc):<DEDENT>", "body": "subs = {<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>}<EOL>exc.filename = None<EOL>exc.lineno = None<EOL>exc.msg = subs.get(exc.msg, exc.msg)<EOL>return exc<EOL>", "docstring": "Given a SyntaxError from a marker evaluation, normalize the error\nmessage:\n - Remove indications of filename and line number.\n - Replace platform-specific error messages with standard error\n   messages.", "id": "f17242:c14:m1"}
{"signature": "def load_entry_point(dist, group, name):", "body": "return get_distribution(dist).load_entry_point(group, name)<EOL>", "docstring": "Return `name` entry point of `group` for `dist` or raise ImportError", "id": "f17242:m17"}
{"signature": "def remove(self, dist):", "body": "self._distmap[dist.key].remove(dist)<EOL>", "docstring": "Remove `dist` from the environment", "id": "f17242:c11:m2"}
{"signature": "def resource_string(self, package_or_requirement, resource_name):", "body": "return get_provider(package_or_requirement).get_resource_string(<EOL>self, resource_name<EOL>)<EOL>", "docstring": "Return specified resource as a string", "id": "f17242:c13:m5"}
{"signature": "def load_entry_point(self, group, name):", "body": "ep = self.get_entry_info(group, name)<EOL>if ep is None:<EOL><INDENT>raise ImportError(\"<STR_LIT>\" % ((group, name),))<EOL><DEDENT>return ep.load()<EOL>", "docstring": "Return the `name` entry point of `group` or raise ImportError", "id": "f17242:c27:m23"}
{"signature": "def register_finder(importer_type, distribution_finder):", "body": "_distribution_finders[importer_type] = distribution_finder<EOL>", "docstring": "Register `distribution_finder` to find distributions in sys.path items\n\n    `importer_type` is the type or class of a PEP 302 \"Importer\" (sys.path item\n    handler), and `distribution_finder` is a callable that, passed a path\n    item and the importer instance, yields ``Distribution`` instances found on\n    that path item.  See ``pkg_resources.find_on_path`` for an example.", "id": "f17242:m25"}
{"signature": "def ensure_directory(path):", "body": "dirname = os.path.dirname(path)<EOL>if not os.path.isdir(dirname):<EOL><INDENT>os.makedirs(dirname)<EOL><DEDENT>", "docstring": "Ensure that the parent directory of `path` exists", "id": "f17242:m45"}
{"signature": "def get_metadata_lines(name):", "body": "", "docstring": "Yield named metadata resource as list of non-blank non-comment lines\n\n       Leading and trailing whitespace is stripped from each line, and lines\n       with ``#`` as the first non-blank character are omitted.", "id": "f17242:c8:m2"}
{"signature": "def get_resource_stream(manager, resource_name):", "body": "", "docstring": "Return a readable file-like object for `resource_name`\n\n        `manager` must be an ``IResourceManager``", "id": "f17242:c9:m1"}
{"signature": "def metadata_listdir(name):", "body": "", "docstring": "List of metadata names in the directory (like ``os.listdir()``)", "id": "f17242:c8:m4"}
{"signature": "def create_cookie(name, value, **kwargs):", "body": "result = dict(<EOL>version=<NUM_LIT:0>,<EOL>name=name,<EOL>value=value,<EOL>port=None,<EOL>domain='<STR_LIT>',<EOL>path='<STR_LIT:/>',<EOL>secure=False,<EOL>expires=None,<EOL>discard=True,<EOL>comment=None,<EOL>comment_url=None,<EOL>rest={'<STR_LIT>': None},<EOL>rfc2109=False,)<EOL>badargs = set(kwargs) - set(result)<EOL>if badargs:<EOL><INDENT>err = '<STR_LIT>'<EOL>raise TypeError(err % list(badargs))<EOL><DEDENT>result.update(kwargs)<EOL>result['<STR_LIT>'] = bool(result['<STR_LIT:port>'])<EOL>result['<STR_LIT>'] = bool(result['<STR_LIT>'])<EOL>result['<STR_LIT>'] = result['<STR_LIT>'].startswith('<STR_LIT:.>')<EOL>result['<STR_LIT>'] = bool(result['<STR_LIT:path>'])<EOL>return cookielib.Cookie(**result)<EOL>", "docstring": "Make a cookie from underspecified parameters.\n\n    By default, the pair of `name` and `value` will be set for the domain ''\n    and sent on every request (this is sometimes called a \"supercookie\").", "id": "f17244:m3"}
{"signature": "def set(self, name, value, **kwargs):", "body": "<EOL>if value is None:<EOL><INDENT>remove_cookie_by_name(self, name, domain=kwargs.get('<STR_LIT>'), path=kwargs.get('<STR_LIT:path>'))<EOL>return<EOL><DEDENT>if isinstance(value, Morsel):<EOL><INDENT>c = morsel_to_cookie(value)<EOL><DEDENT>else:<EOL><INDENT>c = create_cookie(name, value, **kwargs)<EOL><DEDENT>self.set_cookie(c)<EOL>return c<EOL>", "docstring": "Dict-like set() that also supports optional domain and path args in\n        order to resolve naming collisions from using one cookie jar over\n        multiple domains.", "id": "f17244:c3:m1"}
{"signature": "def keys(self):", "body": "return list(self.iterkeys())<EOL>", "docstring": "Dict-like keys() that returns a list of names of cookies from the jar.\n        See values() and items().", "id": "f17244:c3:m3"}
{"signature": "def copy(self):", "body": "new_cj = RequestsCookieJar()<EOL>new_cj.update(self)<EOL>return new_cj<EOL>", "docstring": "Return a copy of this RequestsCookieJar.", "id": "f17244:c3:m21"}
{"signature": "def extract_cookies_to_jar(jar, request, response):", "body": "if not (hasattr(response, '<STR_LIT>') and<EOL>response._original_response):<EOL><INDENT>return<EOL><DEDENT>req = MockRequest(request)<EOL>res = MockResponse(response._original_response.msg)<EOL>jar.extract_cookies(res, req)<EOL>", "docstring": "Extract the cookies from the response into a CookieJar.\n\n    :param jar: cookielib.CookieJar (not necessarily a RequestsCookieJar)\n    :param request: our own requests.Request object\n    :param response: urllib3.HTTPResponse object", "id": "f17244:m0"}
{"signature": "def get(self, name, default=None, domain=None, path=None):", "body": "try:<EOL><INDENT>return self._find_no_duplicates(name, domain, path)<EOL><DEDENT>except KeyError:<EOL><INDENT>return default<EOL><DEDENT>", "docstring": "Dict-like get() that also supports optional domain and path args in\n        order to resolve naming collisions from using one cookie jar over\n        multiple domains. Caution: operation is O(n), not O(1).", "id": "f17244:c3:m0"}
{"signature": "def _find(self, name, domain=None, path=None):", "body": "for cookie in iter(self):<EOL><INDENT>if cookie.name == name:<EOL><INDENT>if domain is None or cookie.domain == domain:<EOL><INDENT>if path is None or cookie.path == path:<EOL><INDENT>return cookie.value<EOL><DEDENT><DEDENT><DEDENT><DEDENT>raise KeyError('<STR_LIT>' % (name, domain, path))<EOL>", "docstring": "Requests uses this method internally to get cookie values. Takes as args name\n        and optional domain and path. Returns a cookie.value. If there are conflicting cookies,\n        _find arbitrarily chooses one. See _find_no_duplicates if you want an exception thrown\n        if there are conflicting cookies.", "id": "f17244:c3:m17"}
{"signature": "def iteritems(self):", "body": "for cookie in iter(self):<EOL><INDENT>yield cookie.name, cookie.value<EOL><DEDENT>", "docstring": "Dict-like iteritems() that returns an iterator of name-value tuples from the jar.\n        See iterkeys() and itervalues().", "id": "f17244:c3:m6"}
{"signature": "def __delitem__(self, name):", "body": "remove_cookie_by_name(self, name)<EOL>", "docstring": "Deletes a cookie given a name. Wraps cookielib.CookieJar's remove_cookie_by_name().", "id": "f17244:c3:m14"}
{"signature": "def is_same_host(self, url):", "body": "if url.startswith('<STR_LIT:/>'):<EOL><INDENT>return True<EOL><DEDENT>scheme, host, port = get_host(url)<EOL>if self.port and not port:<EOL><INDENT>port = port_by_scheme.get(scheme)<EOL><DEDENT>elif not self.port and port == port_by_scheme.get(scheme):<EOL><INDENT>port = None<EOL><DEDENT>return (scheme, host, port) == (self.scheme, self.host, self.port)<EOL>", "docstring": "Check if the given ``url`` is a member of the same host as this\nconnection pool.", "id": "f17247:c1:m9"}
{"signature": "def _validate_conn(self, conn):", "body": "pass<EOL>", "docstring": "Called right before a request is made, after the socket is created.", "id": "f17247:c1:m4"}
{"signature": "def _validate_conn(self, conn):", "body": "super(HTTPSConnectionPool, self)._validate_conn(conn)<EOL>if not getattr(conn, '<STR_LIT>', None):  <EOL><INDENT>conn.connect()<EOL><DEDENT>if not conn.is_verified:<EOL><INDENT>warnings.warn((<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'),<EOL>InsecureRequestWarning)<EOL><DEDENT>", "docstring": "Called right before a request is made, after the socket is created.", "id": "f17247:c2:m3"}
{"signature": "def urlopen(self, method, url, body=None, headers=None, retries=None,<EOL>redirect=True, assert_same_host=True, timeout=_Default,<EOL>pool_timeout=None, release_conn=None, **response_kw):", "body": "if headers is None:<EOL><INDENT>headers = self.headers<EOL><DEDENT>if not isinstance(retries, Retry):<EOL><INDENT>retries = Retry.from_int(retries, redirect=redirect, default=self.retries)<EOL><DEDENT>if release_conn is None:<EOL><INDENT>release_conn = response_kw.get('<STR_LIT>', True)<EOL><DEDENT>if assert_same_host and not self.is_same_host(url):<EOL><INDENT>raise HostChangedError(self, url, retries)<EOL><DEDENT>conn = None<EOL>if self.scheme == '<STR_LIT:http>':<EOL><INDENT>headers = headers.copy()<EOL>headers.update(self.proxy_headers)<EOL><DEDENT>err = None<EOL>try:<EOL><INDENT>conn = self._get_conn(timeout=pool_timeout)<EOL>httplib_response = self._make_request(conn, method, url,<EOL>timeout=timeout,<EOL>body=body, headers=headers)<EOL>response_conn = not release_conn and conn<EOL>response = HTTPResponse.from_httplib(httplib_response,<EOL>pool=self,<EOL>connection=response_conn,<EOL>**response_kw)<EOL><DEDENT>except Empty:<EOL><INDENT>raise EmptyPoolError(self, \"<STR_LIT>\")<EOL><DEDENT>except (BaseSSLError, CertificateError) as e:<EOL><INDENT>if conn:<EOL><INDENT>conn.close()<EOL>conn = None<EOL><DEDENT>raise SSLError(e)<EOL><DEDENT>except (TimeoutError, HTTPException, SocketError, ConnectionError) as e:<EOL><INDENT>if conn:<EOL><INDENT>conn.close()<EOL>conn = None<EOL><DEDENT>stacktrace = sys.exc_info()[<NUM_LIT:2>]<EOL>if isinstance(e, SocketError) and self.proxy:<EOL><INDENT>e = ProxyError('<STR_LIT>', e)<EOL><DEDENT>elif isinstance(e, (SocketError, HTTPException)):<EOL><INDENT>e = ProtocolError('<STR_LIT>', e)<EOL><DEDENT>retries = retries.increment(method, url, error=e,<EOL>_pool=self, _stacktrace=stacktrace)<EOL>retries.sleep()<EOL>err = e<EOL><DEDENT>finally:<EOL><INDENT>if release_conn:<EOL><INDENT>self._put_conn(conn)<EOL><DEDENT><DEDENT>if not conn:<EOL><INDENT>log.warning(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (retries, err, url))<EOL>return self.urlopen(method, url, body, headers, retries,<EOL>redirect, assert_same_host,<EOL>timeout=timeout, pool_timeout=pool_timeout,<EOL>release_conn=release_conn, **response_kw)<EOL><DEDENT>redirect_location = redirect and response.get_redirect_location()<EOL>if redirect_location:<EOL><INDENT>if response.status == <NUM_LIT>:<EOL><INDENT>method = '<STR_LIT:GET>'<EOL><DEDENT>try:<EOL><INDENT>retries = retries.increment(method, url, response=response, _pool=self)<EOL><DEDENT>except MaxRetryError:<EOL><INDENT>if retries.raise_on_redirect:<EOL><INDENT>raise<EOL><DEDENT>return response<EOL><DEDENT>log.info(\"<STR_LIT>\" % (url, redirect_location))<EOL>return self.urlopen(method, redirect_location, body, headers,<EOL>retries=retries, redirect=redirect,<EOL>assert_same_host=assert_same_host,<EOL>timeout=timeout, pool_timeout=pool_timeout,<EOL>release_conn=release_conn, **response_kw)<EOL><DEDENT>if retries.is_forced_retry(method, status_code=response.status):<EOL><INDENT>retries = retries.increment(method, url, response=response, _pool=self)<EOL>retries.sleep()<EOL>log.info(\"<STR_LIT>\" % url)<EOL>return self.urlopen(method, url, body, headers,<EOL>retries=retries, redirect=redirect,<EOL>assert_same_host=assert_same_host,<EOL>timeout=timeout, pool_timeout=pool_timeout,<EOL>release_conn=release_conn, **response_kw)<EOL><DEDENT>return response<EOL>", "docstring": "Get a connection from the pool and perform an HTTP request. This is the\nlowest level call for making a request, so you'll need to specify all\nthe raw details.\n\n.. note::\n\n   More commonly, it's appropriate to use a convenience method provided\n   by :class:`.RequestMethods`, such as :meth:`request`.\n\n.. note::\n\n   `release_conn` will only behave as expected if\n   `preload_content=False` because we want to make\n   `preload_content=False` the default behaviour someday soon without\n   breaking backwards compatibility.\n\n:param method:\n    HTTP request method (such as GET, POST, PUT, etc.)\n\n:param body:\n    Data to send in the request body (useful for creating\n    POST requests, see HTTPConnectionPool.post_url for\n    more convenience).\n\n:param headers:\n    Dictionary of custom headers to send, such as User-Agent,\n    If-None-Match, etc. If None, pool headers are used. If provided,\n    these headers completely replace any pool-specific headers.\n\n:param retries:\n    Configure the number of retries to allow before raising a\n    :class:`~urllib3.exceptions.MaxRetryError` exception.\n\n    Pass ``None`` to retry until you receive a response. Pass a\n    :class:`~urllib3.util.retry.Retry` object for fine-grained control\n    over different types of retries.\n    Pass an integer number to retry connection errors that many times,\n    but no other types of errors. Pass zero to never retry.\n\n    If ``False``, then retries are disabled and any exception is raised\n    immediately. Also, instead of raising a MaxRetryError on redirects,\n    the redirect response will be returned.\n\n:type retries: :class:`~urllib3.util.retry.Retry`, False, or an int.\n\n:param redirect:\n    If True, automatically handle redirects (status codes 301, 302,\n    303, 307, 308). Each redirect counts as a retry. Disabling retries\n    will disable redirect, too.\n\n:param assert_same_host:\n    If ``True``, will make sure that the host of the pool requests is\n    consistent else will raise HostChangedError. When False, you can\n    use the pool on an HTTP proxy and request foreign hosts.\n\n:param timeout:\n    If specified, overrides the default timeout for this one\n    request. It may be a float (in seconds) or an instance of\n    :class:`urllib3.util.Timeout`.\n\n:param pool_timeout:\n    If set and the pool is set to block=True, then this method will\n    block for ``pool_timeout`` seconds and raise EmptyPoolError if no\n    connection is available within the time period.\n\n:param release_conn:\n    If False, then the urlopen call will not release the connection\n    back into the pool once a response is received (but will release if\n    you read the entire contents of the response such as when\n    `preload_content=True`). This is useful if you're not preloading\n    the response's content immediately. You will need to call\n    ``r.release_conn()`` on the response ``r`` to return the connection\n    back into the pool. If None, it takes the value of\n    ``response_kw.get('preload_content', True)``.\n\n:param \\**response_kw:\n    Additional parameters are passed to\n    :meth:`urllib3.response.HTTPResponse.from_httplib`", "id": "f17247:c1:m10"}
{"signature": "def _new_conn(self):", "body": "self.num_connections += <NUM_LIT:1><EOL>log.info(\"<STR_LIT>\"<EOL>% (self.num_connections, self.host))<EOL>if not self.ConnectionCls or self.ConnectionCls is DummyConnection:<EOL><INDENT>raise SSLError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>actual_host = self.host<EOL>actual_port = self.port<EOL>if self.proxy is not None:<EOL><INDENT>actual_host = self.proxy.host<EOL>actual_port = self.proxy.port<EOL><DEDENT>conn = self.ConnectionCls(host=actual_host, port=actual_port,<EOL>timeout=self.timeout.connect_timeout,<EOL>strict=self.strict, **self.conn_kw)<EOL>return self._prepare_conn(conn)<EOL>", "docstring": "Return a fresh :class:`httplib.HTTPSConnection`.", "id": "f17247:c2:m2"}
{"signature": "def assert_fingerprint(cert, fingerprint):", "body": "<EOL>hashfunc_map = {<EOL><NUM_LIT:16>: md5,<EOL><NUM_LIT:20>: sha1<EOL>}<EOL>fingerprint = fingerprint.replace('<STR_LIT::>', '<STR_LIT>').lower()<EOL>digest_length, odd = divmod(len(fingerprint), <NUM_LIT:2>)<EOL>if odd or digest_length not in hashfunc_map:<EOL><INDENT>raise SSLError('<STR_LIT>')<EOL><DEDENT>fingerprint_bytes = unhexlify(fingerprint.encode())<EOL>hashfunc = hashfunc_map[digest_length]<EOL>cert_digest = hashfunc(cert).digest()<EOL>if not cert_digest == fingerprint_bytes:<EOL><INDENT>raise SSLError('<STR_LIT>'<EOL>.format(hexlify(fingerprint_bytes),<EOL>hexlify(cert_digest)))<EOL><DEDENT>", "docstring": "Checks if given fingerprint matches the supplied certificate.\n\n:param cert:\n    Certificate as bytes object.\n:param fingerprint:\n    Fingerprint as string of hexdigits, can be interspersed by colons.", "id": "f17249:m0"}
{"signature": "@classmethod<EOL><INDENT>def from_int(cls, retries, redirect=True, default=None):<DEDENT>", "body": "if retries is None:<EOL><INDENT>retries = default if default is not None else cls.DEFAULT<EOL><DEDENT>if isinstance(retries, Retry):<EOL><INDENT>return retries<EOL><DEDENT>redirect = bool(redirect) and None<EOL>new_retries = cls(retries, redirect=redirect)<EOL>log.debug(\"<STR_LIT>\" % (retries, new_retries))<EOL>return new_retries<EOL>", "docstring": "Backwards-compatibility for the old retries format.", "id": "f17250:c0:m2"}
{"signature": "def _is_read_error(self, err):", "body": "return isinstance(err, (ReadTimeoutError, ProtocolError))<EOL>", "docstring": "Errors that occur after the request has been started, so we should\n        assume that the server began processing it.", "id": "f17250:c0:m6"}
{"signature": "def _is_connection_error(self, err):", "body": "return isinstance(err, ConnectTimeoutError)<EOL>", "docstring": "Errors when we're fairly sure that the server did not receive the\n        request, so it should be safe to retry.", "id": "f17250:c0:m5"}
{"signature": "def connection_from_url(self, url):", "body": "u = parse_url(url)<EOL>return self.connection_from_host(u.host, port=u.port, scheme=u.scheme)<EOL>", "docstring": "Similar to :func:`urllib3.connectionpool.connection_from_url` but\ndoesn't pass any additional parameters to the\n:class:`urllib3.connectionpool.ConnectionPool` constructor.\n\nAdditional parameters are taken from the :class:`.PoolManager`\nconstructor.", "id": "f17251:c0:m4"}
{"signature": "def connection_from_host(self, host, port=None, scheme='<STR_LIT:http>'):", "body": "if not host:<EOL><INDENT>raise LocationValueError(\"<STR_LIT>\")<EOL><DEDENT>scheme = scheme or '<STR_LIT:http>'<EOL>port = port or port_by_scheme.get(scheme, <NUM_LIT>)<EOL>pool_key = (scheme, host, port)<EOL>with self.pools.lock:<EOL><INDENT>pool = self.pools.get(pool_key)<EOL>if pool:<EOL><INDENT>return pool<EOL><DEDENT>pool = self._new_pool(scheme, host, port)<EOL>self.pools[pool_key] = pool<EOL><DEDENT>return pool<EOL>", "docstring": "Get a :class:`ConnectionPool` based on the host, port, and scheme.\n\nIf ``port`` isn't given, it will be derived from the ``scheme`` using\n``urllib3.connectionpool.port_by_scheme``.", "id": "f17251:c0:m3"}
{"signature": "def disable_warnings(category=exceptions.HTTPWarning):", "body": "warnings.simplefilter('<STR_LIT:ignore>', category)<EOL>", "docstring": "Helper for quickly disabling all urllib3 warnings.", "id": "f17252:m1"}
{"signature": "def add(self, key, value):", "body": "self._data.setdefault(key.lower(), []).append((key, value))<EOL>", "docstring": "Adds a (name, value) pair, doesn't overwrite the value if it already\n        exists.\n\n        >>> headers = HTTPHeaderDict(foo='bar')\n        >>> headers.add('Foo', 'baz')\n        >>> headers['foo']\n        'bar, baz'", "id": "f17253:c1:m1"}
{"signature": "def read(self, amt=None, decode_content=None, cache_content=False):", "body": "<EOL>content_encoding = self.headers.get('<STR_LIT>', '<STR_LIT>').lower()<EOL>if self._decoder is None:<EOL><INDENT>if content_encoding in self.CONTENT_DECODERS:<EOL><INDENT>self._decoder = _get_decoder(content_encoding)<EOL><DEDENT><DEDENT>if decode_content is None:<EOL><INDENT>decode_content = self.decode_content<EOL><DEDENT>if self._fp is None:<EOL><INDENT>return<EOL><DEDENT>flush_decoder = False<EOL>try:<EOL><INDENT>try:<EOL><INDENT>if amt is None:<EOL><INDENT>data = self._fp.read()<EOL>flush_decoder = True<EOL><DEDENT>else:<EOL><INDENT>cache_content = False<EOL>data = self._fp.read(amt)<EOL>if amt != <NUM_LIT:0> and not data:  <EOL><INDENT>self._fp.close()<EOL>flush_decoder = True<EOL><DEDENT><DEDENT><DEDENT>except SocketTimeout:<EOL><INDENT>raise ReadTimeoutError(self._pool, None, '<STR_LIT>')<EOL><DEDENT>except BaseSSLError as e:<EOL><INDENT>if not '<STR_LIT>' in str(e):  <EOL><INDENT>raise<EOL><DEDENT>raise ReadTimeoutError(self._pool, None, '<STR_LIT>')<EOL><DEDENT>except HTTPException as e:<EOL><INDENT>raise ProtocolError('<STR_LIT>' % e, e)<EOL><DEDENT>self._fp_bytes_read += len(data)<EOL>try:<EOL><INDENT>if decode_content and self._decoder:<EOL><INDENT>data = self._decoder.decompress(data)<EOL><DEDENT><DEDENT>except (IOError, zlib.error) as e:<EOL><INDENT>raise DecodeError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % content_encoding, e)<EOL><DEDENT>if flush_decoder and decode_content and self._decoder:<EOL><INDENT>buf = self._decoder.decompress(binary_type())<EOL>data += buf + self._decoder.flush()<EOL><DEDENT>if cache_content:<EOL><INDENT>self._body = data<EOL><DEDENT>return data<EOL><DEDENT>finally:<EOL><INDENT>if self._original_response and self._original_response.isclosed():<EOL><INDENT>self.release_conn()<EOL><DEDENT><DEDENT>", "docstring": "Similar to :meth:`httplib.HTTPResponse.read`, but with two additional\nparameters: ``decode_content`` and ``cache_content``.\n\n:param amt:\n    How much of the content to read. If specified, caching is skipped\n    because it doesn't make sense to cache partial content as the full\n    response.\n\n:param decode_content:\n    If True, will attempt to decode the body based on the\n    'content-encoding' header.\n\n:param cache_content:\n    If True, will save the returned data such that the same result is\n    returned despite of the state of the underlying file object. This\n    is useful if you want the ``.data`` property to continue working\n    after having ``.read()`` the file object. (Overridden if ``amt`` is\n    set.)", "id": "f17255:c1:m5"}
{"signature": "def handle_401(self, r, **kwargs):", "body": "if self.pos is not None:<EOL><INDENT>r.request.body.seek(self.pos)<EOL><DEDENT>num_401_calls = getattr(self, '<STR_LIT>', <NUM_LIT:1>)<EOL>s_auth = r.headers.get('<STR_LIT>', '<STR_LIT>')<EOL>if '<STR_LIT>' in s_auth.lower() and num_401_calls < <NUM_LIT:2>:<EOL><INDENT>self.num_401_calls += <NUM_LIT:1><EOL>pat = re.compile(r'<STR_LIT>', flags=re.IGNORECASE)<EOL>self.chal = parse_dict_header(pat.sub('<STR_LIT>', s_auth, count=<NUM_LIT:1>))<EOL>r.content<EOL>r.raw.release_conn()<EOL>prep = r.request.copy()<EOL>extract_cookies_to_jar(prep._cookies, r.request, r.raw)<EOL>prep.prepare_cookies(prep._cookies)<EOL>prep.headers['<STR_LIT>'] = self.build_digest_header(<EOL>prep.method, prep.url)<EOL>_r = r.connection.send(prep, **kwargs)<EOL>_r.history.append(r)<EOL>_r.request = prep<EOL>return _r<EOL><DEDENT>self.num_401_calls = <NUM_LIT:1><EOL>return r<EOL>", "docstring": "Takes the given response and tries digest-auth, if needed.", "id": "f17257:c3:m3"}
{"signature": "def send(self, request, stream=False, timeout=None, verify=True, cert=None, proxies=None):", "body": "conn = self.get_connection(request.url, proxies)<EOL>self.cert_verify(conn, request.url, verify, cert)<EOL>url = self.request_url(request, proxies)<EOL>self.add_headers(request)<EOL>chunked = not (request.body is None or '<STR_LIT>' in request.headers)<EOL>if isinstance(timeout, tuple):<EOL><INDENT>try:<EOL><INDENT>connect, read = timeout<EOL>timeout = TimeoutSauce(connect=connect, read=read)<EOL><DEDENT>except ValueError as e:<EOL><INDENT>err = (\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(timeout))<EOL>raise ValueError(err)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>timeout = TimeoutSauce(connect=timeout, read=timeout)<EOL><DEDENT>try:<EOL><INDENT>if not chunked:<EOL><INDENT>resp = conn.urlopen(<EOL>method=request.method,<EOL>url=url,<EOL>body=request.body,<EOL>headers=request.headers,<EOL>redirect=False,<EOL>assert_same_host=False,<EOL>preload_content=False,<EOL>decode_content=False,<EOL>retries=self.max_retries,<EOL>timeout=timeout<EOL>)<EOL><DEDENT>else:<EOL><INDENT>if hasattr(conn, '<STR_LIT>'):<EOL><INDENT>conn = conn.proxy_pool<EOL><DEDENT>low_conn = conn._get_conn(timeout=timeout)<EOL>try:<EOL><INDENT>low_conn.putrequest(request.method,<EOL>url,<EOL>skip_accept_encoding=True)<EOL>for header, value in request.headers.items():<EOL><INDENT>low_conn.putheader(header, value)<EOL><DEDENT>low_conn.endheaders()<EOL>for i in request.body:<EOL><INDENT>low_conn.send(hex(len(i))[<NUM_LIT:2>:].encode('<STR_LIT:utf-8>'))<EOL>low_conn.send(b'<STR_LIT:\\r\\n>')<EOL>low_conn.send(i)<EOL>low_conn.send(b'<STR_LIT:\\r\\n>')<EOL><DEDENT>low_conn.send(b'<STR_LIT>')<EOL>r = low_conn.getresponse()<EOL>resp = HTTPResponse.from_httplib(<EOL>r,<EOL>pool=conn,<EOL>connection=low_conn,<EOL>preload_content=False,<EOL>decode_content=False<EOL>)<EOL><DEDENT>except:<EOL><INDENT>low_conn.close()<EOL>raise<EOL><DEDENT>else:<EOL><INDENT>conn._put_conn(low_conn)<EOL><DEDENT><DEDENT><DEDENT>except (ProtocolError, socket.error) as err:<EOL><INDENT>raise ConnectionError(err, request=request)<EOL><DEDENT>except MaxRetryError as e:<EOL><INDENT>if isinstance(e.reason, ConnectTimeoutError):<EOL><INDENT>raise ConnectTimeout(e, request=request)<EOL><DEDENT>if isinstance(e.reason, ResponseError):<EOL><INDENT>raise RetryError(e, request=request)<EOL><DEDENT>raise ConnectionError(e, request=request)<EOL><DEDENT>except _ProxyError as e:<EOL><INDENT>raise ProxyError(e)<EOL><DEDENT>except (_SSLError, _HTTPError) as e:<EOL><INDENT>if isinstance(e, _SSLError):<EOL><INDENT>raise SSLError(e, request=request)<EOL><DEDENT>elif isinstance(e, ReadTimeoutError):<EOL><INDENT>raise ReadTimeout(e, request=request)<EOL><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>return self.build_response(request, resp)<EOL>", "docstring": "Sends PreparedRequest object. Returns Response object.\n\n        :param request: The :class:`PreparedRequest <PreparedRequest>` being sent.\n        :param stream: (optional) Whether to stream the request content.\n        :param timeout: (optional) How long to wait for the server to send\n            data before giving up, as a float, or a (`connect timeout, read\n            timeout <user/advanced.html#timeouts>`_) tuple.\n        :type timeout: float or tuple\n        :param verify: (optional) Whether to verify SSL certificates.\n        :param cert: (optional) Any user-provided SSL certificate to be trusted.\n        :param proxies: (optional) The proxies dictionary to apply to the request.", "id": "f17258:c1:m12"}
{"signature": "def cert_verify(self, conn, url, verify, cert):", "body": "if url.lower().startswith('<STR_LIT>') and verify:<EOL><INDENT>cert_loc = None<EOL>if verify is not True:<EOL><INDENT>cert_loc = verify<EOL><DEDENT>if not cert_loc:<EOL><INDENT>cert_loc = DEFAULT_CA_BUNDLE_PATH<EOL><DEDENT>if not cert_loc:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>conn.cert_reqs = '<STR_LIT>'<EOL>conn.ca_certs = cert_loc<EOL><DEDENT>else:<EOL><INDENT>conn.cert_reqs = '<STR_LIT>'<EOL>conn.ca_certs = None<EOL><DEDENT>if cert:<EOL><INDENT>if not isinstance(cert, basestring):<EOL><INDENT>conn.cert_file = cert[<NUM_LIT:0>]<EOL>conn.key_file = cert[<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>conn.cert_file = cert<EOL><DEDENT><DEDENT>", "docstring": "Verify a SSL certificate. This method should not be called from user\n        code, and is only exposed for use when subclassing the\n        :class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.\n\n        :param conn: The urllib3 connection object associated with the cert.\n        :param url: The requested URL.\n        :param verify: Whether we should actually verify the certificate.\n        :param cert: The SSL certificate to verify.", "id": "f17258:c1:m5"}
{"signature": "def to_native_string(string, encoding='<STR_LIT:ascii>'):", "body": "out = None<EOL>if isinstance(string, builtin_str):<EOL><INDENT>out = string<EOL><DEDENT>else:<EOL><INDENT>if is_py2:<EOL><INDENT>out = string.encode(encoding)<EOL><DEDENT>else:<EOL><INDENT>out = string.decode(encoding)<EOL><DEDENT><DEDENT>return out<EOL>", "docstring": "Given a string object, regardless of type, returns a representation of that\nstring in the native string type, encoding and decoding where necessary.\nThis assumes ASCII unless told otherwise.", "id": "f17260:m30"}
{"signature": "def get_environ_proxies(url):", "body": "if should_bypass_proxies(url):<EOL><INDENT>return {}<EOL><DEDENT>else:<EOL><INDENT>return getproxies()<EOL><DEDENT>", "docstring": "Return a dict of environment proxies.", "id": "f17260:m23"}
{"signature": "def urldefragauth(url):", "body": "scheme, netloc, path, params, query, fragment = urlparse(url)<EOL>if not netloc:<EOL><INDENT>netloc, path = path, netloc<EOL><DEDENT>netloc = netloc.rsplit('<STR_LIT:@>', <NUM_LIT:1>)[-<NUM_LIT:1>]<EOL>return urlunparse((scheme, netloc, path, params, query, '<STR_LIT>'))<EOL>", "docstring": "Given a url remove the fragment and the authentication part", "id": "f17260:m31"}
{"signature": "def unquote_header_value(value, is_filename=False):", "body": "if value and value[<NUM_LIT:0>] == value[-<NUM_LIT:1>] == '<STR_LIT:\">':<EOL><INDENT>value = value[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL>if not is_filename or value[:<NUM_LIT:2>] != '<STR_LIT>':<EOL><INDENT>return value.replace('<STR_LIT>', '<STR_LIT:\\\\>').replace('<STR_LIT>', '<STR_LIT:\">')<EOL><DEDENT><DEDENT>return value<EOL>", "docstring": "r\"\"\"Unquotes a header value.  (Reversal of :func:`quote_header_value`).\n    This does not use the real unquoting but what browsers are actually\n    using for quoting.\n\n    :param value: the header value to unquote.", "id": "f17260:m8"}
{"signature": "def parse_list_header(value):", "body": "result = []<EOL>for item in _parse_list_header(value):<EOL><INDENT>if item[:<NUM_LIT:1>] == item[-<NUM_LIT:1>:] == '<STR_LIT:\">':<EOL><INDENT>item = unquote_header_value(item[<NUM_LIT:1>:-<NUM_LIT:1>])<EOL><DEDENT>result.append(item)<EOL><DEDENT>return result<EOL>", "docstring": "Parse lists as described by RFC 2068 Section 2.\n\n    In particular, parse comma-separated lists where the elements of\n    the list may include quoted-strings.  A quoted-string could\n    contain a comma.  A non-quoted string could have quotes in the\n    middle.  Quotes are removed automatically after parsing.\n\n    It basically works like :func:`parse_set_header` just that items\n    may appear multiple times and case sensitivity is preserved.\n\n    The return value is a standard :class:`list`:\n\n    >>> parse_list_header('token, \"quoted value\"')\n    ['token', 'quoted value']\n\n    To create a header from the :class:`list` again, use the\n    :func:`dump_header` function.\n\n    :param value: a string with a list header.\n    :return: :class:`list`", "id": "f17260:m6"}
{"signature": "def requote_uri(uri):", "body": "<EOL>return quote(unquote_unreserved(uri), safe=\"<STR_LIT>\")<EOL>", "docstring": "Re-quote the given URI.\n\n    This function passes the given URI through an unquote/quote cycle to\n    ensure that it is fully and consistently quoted.", "id": "f17260:m17"}
{"signature": "@staticmethod<EOL><INDENT>def _encode_files(files, data):<DEDENT>", "body": "if (not files):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>elif isinstance(data, basestring):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>new_fields = []<EOL>fields = to_key_val_list(data or {})<EOL>files = to_key_val_list(files or {})<EOL>for field, val in fields:<EOL><INDENT>if isinstance(val, basestring) or not hasattr(val, '<STR_LIT>'):<EOL><INDENT>val = [val]<EOL><DEDENT>for v in val:<EOL><INDENT>if v is not None:<EOL><INDENT>if not isinstance(v, bytes):<EOL><INDENT>v = str(v)<EOL><DEDENT>new_fields.append(<EOL>(field.decode('<STR_LIT:utf-8>') if isinstance(field, bytes) else field,<EOL>v.encode('<STR_LIT:utf-8>') if isinstance(v, str) else v))<EOL><DEDENT><DEDENT><DEDENT>for (k, v) in files:<EOL><INDENT>ft = None<EOL>fh = None<EOL>if isinstance(v, (tuple, list)):<EOL><INDENT>if len(v) == <NUM_LIT:2>:<EOL><INDENT>fn, fp = v<EOL><DEDENT>elif len(v) == <NUM_LIT:3>:<EOL><INDENT>fn, fp, ft = v<EOL><DEDENT>else:<EOL><INDENT>fn, fp, ft, fh = v<EOL><DEDENT><DEDENT>else:<EOL><INDENT>fn = guess_filename(v) or k<EOL>fp = v<EOL><DEDENT>if isinstance(fp, str):<EOL><INDENT>fp = StringIO(fp)<EOL><DEDENT>if isinstance(fp, bytes):<EOL><INDENT>fp = BytesIO(fp)<EOL><DEDENT>rf = RequestField(name=k, data=fp.read(),<EOL>filename=fn, headers=fh)<EOL>rf.make_multipart(content_type=ft)<EOL>new_fields.append(rf)<EOL><DEDENT>body, content_type = encode_multipart_formdata(new_fields)<EOL>return body, content_type<EOL>", "docstring": "Build the body for a multipart/form-data request.\n\n        Will successfully encode files when passed as a dict or a list of\n        2-tuples. Order is retained if data is a list of 2-tuples but arbitrary\n        if parameters are supplied as a dict.", "id": "f17261:c0:m2"}
{"signature": "def prepare_auth(self, auth, url='<STR_LIT>'):", "body": "<EOL>if auth is None:<EOL><INDENT>url_auth = get_auth_from_url(self.url)<EOL>auth = url_auth if any(url_auth) else None<EOL><DEDENT>if auth:<EOL><INDENT>if isinstance(auth, tuple) and len(auth) == <NUM_LIT:2>:<EOL><INDENT>auth = HTTPBasicAuth(*auth)<EOL><DEDENT>r = auth(self)<EOL>self.__dict__.update(r.__dict__)<EOL>self.prepare_content_length(self.body)<EOL><DEDENT>", "docstring": "Prepares the given HTTP auth data.", "id": "f17261:c3:m9"}
{"signature": "def json(self, **kwargs):", "body": "if not self.encoding and len(self.content) > <NUM_LIT:3>:<EOL><INDENT>encoding = guess_json_utf(self.content)<EOL>if encoding is not None:<EOL><INDENT>try:<EOL><INDENT>return json.loads(self.content.decode(encoding), **kwargs)<EOL><DEDENT>except UnicodeDecodeError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>return json.loads(self.text, **kwargs)<EOL>", "docstring": "Returns the json-encoded content of a response, if any.\n\n        :param \\*\\*kwargs: Optional arguments that ``json.loads`` takes.", "id": "f17261:c4:m15"}
{"signature": "def get(url, **kwargs):", "body": "kwargs.setdefault('<STR_LIT>', True)<EOL>return request('<STR_LIT>', url, **kwargs)<EOL>", "docstring": "Sends a GET request. Returns :class:`Response` object.\n\n    :param url: URL for the new :class:`Request` object.\n    :param \\*\\*kwargs: Optional arguments that ``request`` takes.", "id": "f17262:m1"}
{"signature": "def head(url, **kwargs):", "body": "kwargs.setdefault('<STR_LIT>', False)<EOL>return request('<STR_LIT>', url, **kwargs)<EOL>", "docstring": "Sends a HEAD request. Returns :class:`Response` object.\n\n    :param url: URL for the new :class:`Request` object.\n    :param \\*\\*kwargs: Optional arguments that ``request`` takes.", "id": "f17262:m3"}
{"signature": "def request(method, url, **kwargs):", "body": "session = sessions.Session()<EOL>response = session.request(method=method, url=url, **kwargs)<EOL>session.close()<EOL>return response<EOL>", "docstring": "Constructs and sends a :class:`Request <Request>`.\n    Returns :class:`Response <Response>` object.\n\n    :param method: method for the new :class:`Request` object.\n    :param url: URL for the new :class:`Request` object.\n    :param params: (optional) Dictionary or bytes to be sent in the query string for the :class:`Request`.\n    :param data: (optional) Dictionary, bytes, or file-like object to send in the body of the :class:`Request`.\n    :param json: (optional) json data to send in the body of the :class:`Request`.\n    :param headers: (optional) Dictionary of HTTP Headers to send with the :class:`Request`.\n    :param cookies: (optional) Dict or CookieJar object to send with the :class:`Request`.\n    :param files: (optional) Dictionary of ``'name': file-like-objects`` (or ``{'name': ('filename', fileobj)}``) for multipart encoding upload.\n    :param auth: (optional) Auth tuple to enable Basic/Digest/Custom HTTP Auth.\n    :param timeout: (optional) How long to wait for the server to send data\n        before giving up, as a float, or a (`connect timeout, read timeout\n        <user/advanced.html#timeouts>`_) tuple.\n    :type timeout: float or tuple\n    :param allow_redirects: (optional) Boolean. Set to True if POST/PUT/DELETE redirect following is allowed.\n    :type allow_redirects: bool\n    :param proxies: (optional) Dictionary mapping protocol to the URL of the proxy.\n    :param verify: (optional) if ``True``, the SSL cert will be verified. A CA_BUNDLE path can also be provided.\n    :param stream: (optional) if ``False``, the response content will be immediately downloaded.\n    :param cert: (optional) if String, path to ssl client cert file (.pem). If Tuple, ('cert', 'key') pair.\n\n    Usage::\n\n      >>> import requests\n      >>> req = requests.request('GET', 'http://httpbin.org/get')\n      <Response [200]>", "id": "f17262:m0"}
{"signature": "def mount(self, prefix, adapter):", "body": "self.adapters[prefix] = adapter<EOL>keys_to_move = [k for k in self.adapters if len(k) < len(prefix)]<EOL>for key in keys_to_move:<EOL><INDENT>self.adapters[key] = self.adapters.pop(key)<EOL><DEDENT>", "docstring": "Registers a connection adapter to a prefix.\n\n        Adapters are sorted in descending order by key length.", "id": "f17263:c1:m16"}
{"signature": "def delete(self, url, **kwargs):", "body": "return self.request('<STR_LIT>', url, **kwargs)<EOL>", "docstring": "Sends a DELETE request. Returns :class:`Response` object.\n\n        :param url: URL for the new :class:`Request` object.\n        :param \\*\\*kwargs: Optional arguments that ``request`` takes.", "id": "f17263:c1:m11"}
{"signature": "def prepare_request(self, request):", "body": "cookies = request.cookies or {}<EOL>if not isinstance(cookies, cookielib.CookieJar):<EOL><INDENT>cookies = cookiejar_from_dict(cookies)<EOL><DEDENT>merged_cookies = merge_cookies(<EOL>merge_cookies(RequestsCookieJar(), self.cookies), cookies)<EOL>auth = request.auth<EOL>if self.trust_env and not auth and not self.auth:<EOL><INDENT>auth = get_netrc_auth(request.url)<EOL><DEDENT>p = PreparedRequest()<EOL>p.prepare(<EOL>method=request.method.upper(),<EOL>url=request.url,<EOL>files=request.files,<EOL>data=request.data,<EOL>json=request.json,<EOL>headers=merge_setting(request.headers, self.headers, dict_class=CaseInsensitiveDict),<EOL>params=merge_setting(request.params, self.params),<EOL>auth=merge_setting(auth, self.auth),<EOL>cookies=merged_cookies,<EOL>hooks=merge_hooks(request.hooks, self.hooks),<EOL>)<EOL>return p<EOL>", "docstring": "Constructs a :class:`PreparedRequest <PreparedRequest>` for\n        transmission and returns it. The :class:`PreparedRequest` has settings\n        merged from the :class:`Request <Request>` instance and those of the\n        :class:`Session`.\n\n        :param request: :class:`Request` instance to prepare with this\n            session's settings.", "id": "f17263:c1:m3"}
{"signature": "def request(self, method, url,<EOL>params=None,<EOL>data=None,<EOL>headers=None,<EOL>cookies=None,<EOL>files=None,<EOL>auth=None,<EOL>timeout=None,<EOL>allow_redirects=True,<EOL>proxies=None,<EOL>hooks=None,<EOL>stream=None,<EOL>verify=None,<EOL>cert=None,<EOL>json=None):", "body": "method = to_native_string(method)<EOL>req = Request(<EOL>method = method.upper(),<EOL>url = url,<EOL>headers = headers,<EOL>files = files,<EOL>data = data or {},<EOL>json = json,<EOL>params = params or {},<EOL>auth = auth,<EOL>cookies = cookies,<EOL>hooks = hooks,<EOL>)<EOL>prep = self.prepare_request(req)<EOL>proxies = proxies or {}<EOL>settings = self.merge_environment_settings(<EOL>prep.url, proxies, stream, verify, cert<EOL>)<EOL>send_kwargs = {<EOL>'<STR_LIT>': timeout,<EOL>'<STR_LIT>': allow_redirects,<EOL>}<EOL>send_kwargs.update(settings)<EOL>resp = self.send(prep, **send_kwargs)<EOL>return resp<EOL>", "docstring": "Constructs a :class:`Request <Request>`, prepares it and sends it.\n        Returns :class:`Response <Response>` object.\n\n        :param method: method for the new :class:`Request` object.\n        :param url: URL for the new :class:`Request` object.\n        :param params: (optional) Dictionary or bytes to be sent in the query\n            string for the :class:`Request`.\n        :param data: (optional) Dictionary or bytes to send in the body of the\n            :class:`Request`.\n        :param json: (optional) json to send in the body of the\n            :class:`Request`.\n        :param headers: (optional) Dictionary of HTTP Headers to send with the\n            :class:`Request`.\n        :param cookies: (optional) Dict or CookieJar object to send with the\n            :class:`Request`.\n        :param files: (optional) Dictionary of ``'filename': file-like-objects``\n            for multipart encoding upload.\n        :param auth: (optional) Auth tuple or callable to enable\n            Basic/Digest/Custom HTTP Auth.\n        :param timeout: (optional) How long to wait for the server to send\n            data before giving up, as a float, or a (`connect timeout, read\n            timeout <user/advanced.html#timeouts>`_) tuple.\n        :type timeout: float or tuple\n        :param allow_redirects: (optional) Set to True by default.\n        :type allow_redirects: bool\n        :param proxies: (optional) Dictionary mapping protocol to the URL of\n            the proxy.\n        :param stream: (optional) whether to immediately download the response\n            content. Defaults to ``False``.\n        :param verify: (optional) if ``True``, the SSL cert will be verified.\n            A CA_BUNDLE path can also be provided.\n        :param cert: (optional) if String, path to ssl client cert file (.pem).\n            If Tuple, ('cert', 'key') pair.", "id": "f17263:c1:m4"}
{"signature": "def rebuild_auth(self, prepared_request, response):", "body": "headers = prepared_request.headers<EOL>url = prepared_request.url<EOL>if '<STR_LIT>' in headers:<EOL><INDENT>original_parsed = urlparse(response.request.url)<EOL>redirect_parsed = urlparse(url)<EOL>if (original_parsed.hostname != redirect_parsed.hostname):<EOL><INDENT>del headers['<STR_LIT>']<EOL><DEDENT><DEDENT>new_auth = get_netrc_auth(url) if self.trust_env else None<EOL>if new_auth is not None:<EOL><INDENT>prepared_request.prepare_auth(new_auth)<EOL><DEDENT>return<EOL>", "docstring": "When being redirected we may want to strip authentication from the\nrequest to avoid leaking credentials. This method intelligently removes\nand reapplies authentication where possible to avoid credential loss.", "id": "f17263:c0:m1"}
{"signature": "def resolve_redirects(self, resp, req, stream=False, timeout=None,<EOL>verify=True, cert=None, proxies=None):", "body": "i = <NUM_LIT:0><EOL>hist = [] <EOL>while resp.is_redirect:<EOL><INDENT>prepared_request = req.copy()<EOL>if i > <NUM_LIT:0>:<EOL><INDENT>hist.append(resp)<EOL>new_hist = list(hist)<EOL>resp.history = new_hist<EOL><DEDENT>try:<EOL><INDENT>resp.content  <EOL><DEDENT>except (ChunkedEncodingError, ContentDecodingError, RuntimeError):<EOL><INDENT>resp.raw.read(decode_content=False)<EOL><DEDENT>if i >= self.max_redirects:<EOL><INDENT>raise TooManyRedirects('<STR_LIT>' % self.max_redirects)<EOL><DEDENT>resp.close()<EOL>url = resp.headers['<STR_LIT:location>']<EOL>method = req.method<EOL>if url.startswith('<STR_LIT>'):<EOL><INDENT>parsed_rurl = urlparse(resp.url)<EOL>url = '<STR_LIT>' % (parsed_rurl.scheme, url)<EOL><DEDENT>parsed = urlparse(url)<EOL>url = parsed.geturl()<EOL>if not parsed.netloc:<EOL><INDENT>url = urljoin(resp.url, requote_uri(url))<EOL><DEDENT>else:<EOL><INDENT>url = requote_uri(url)<EOL><DEDENT>prepared_request.url = to_native_string(url)<EOL>if resp.is_permanent_redirect and req.url != prepared_request.url:<EOL><INDENT>self.redirect_cache[req.url] = prepared_request.url<EOL><DEDENT>if (resp.status_code == codes.see_other and<EOL>method != '<STR_LIT>'):<EOL><INDENT>method = '<STR_LIT:GET>'<EOL><DEDENT>if resp.status_code == codes.found and method != '<STR_LIT>':<EOL><INDENT>method = '<STR_LIT:GET>'<EOL><DEDENT>if resp.status_code == codes.moved and method == '<STR_LIT:POST>':<EOL><INDENT>method = '<STR_LIT:GET>'<EOL><DEDENT>prepared_request.method = method<EOL>if resp.status_code not in (codes.temporary_redirect, codes.permanent_redirect):<EOL><INDENT>if '<STR_LIT>' in prepared_request.headers:<EOL><INDENT>del prepared_request.headers['<STR_LIT>']<EOL><DEDENT>prepared_request.body = None<EOL><DEDENT>headers = prepared_request.headers<EOL>try:<EOL><INDENT>del headers['<STR_LIT>']<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>extract_cookies_to_jar(prepared_request._cookies, prepared_request, resp.raw)<EOL>prepared_request._cookies.update(self.cookies)<EOL>prepared_request.prepare_cookies(prepared_request._cookies)<EOL>proxies = self.rebuild_proxies(prepared_request, proxies)<EOL>self.rebuild_auth(prepared_request, resp)<EOL>req = prepared_request<EOL>resp = self.send(<EOL>req,<EOL>stream=stream,<EOL>timeout=timeout,<EOL>verify=verify,<EOL>cert=cert,<EOL>proxies=proxies,<EOL>allow_redirects=False,<EOL>)<EOL>extract_cookies_to_jar(self.cookies, prepared_request, resp.raw)<EOL>i += <NUM_LIT:1><EOL>yield resp<EOL><DEDENT>", "docstring": "Receives a Response. Returns a generator of Responses.", "id": "f17263:c0:m0"}
{"signature": "def merge_setting(request_setting, session_setting, dict_class=OrderedDict):", "body": "if session_setting is None:<EOL><INDENT>return request_setting<EOL><DEDENT>if request_setting is None:<EOL><INDENT>return session_setting<EOL><DEDENT>if not (<EOL>isinstance(session_setting, Mapping) and<EOL>isinstance(request_setting, Mapping)<EOL>):<EOL><INDENT>return request_setting<EOL><DEDENT>merged_setting = dict_class(to_key_val_list(session_setting))<EOL>merged_setting.update(to_key_val_list(request_setting))<EOL>for (k, v) in request_setting.items():<EOL><INDENT>if v is None:<EOL><INDENT>del merged_setting[k]<EOL><DEDENT><DEDENT>merged_setting = dict((k, v) for (k, v) in merged_setting.items() if v is not None)<EOL>return merged_setting<EOL>", "docstring": "Determines appropriate setting for a given request, taking into account the\nexplicit setting on that request, and the setting in the session. If a\nsetting is a dictionary, they will be merged together using `dict_class`", "id": "f17263:m0"}
{"signature": "def patch(self, url, data=None, **kwargs):", "body": "return self.request('<STR_LIT>', url,  data=data, **kwargs)<EOL>", "docstring": "Sends a PATCH request. Returns :class:`Response` object.\n\n        :param url: URL for the new :class:`Request` object.\n        :param data: (optional) Dictionary, bytes, or file-like object to send in the body of the :class:`Request`.\n        :param \\*\\*kwargs: Optional arguments that ``request`` takes.", "id": "f17263:c1:m10"}
{"signature": "def put(self, url, data=None, **kwargs):", "body": "return self.request('<STR_LIT>', url, data=data, **kwargs)<EOL>", "docstring": "Sends a PUT request. Returns :class:`Response` object.\n\n        :param url: URL for the new :class:`Request` object.\n        :param data: (optional) Dictionary, bytes, or file-like object to send in the body of the :class:`Request`.\n        :param \\*\\*kwargs: Optional arguments that ``request`` takes.", "id": "f17263:c1:m9"}
{"signature": "def add_move(move):", "body": "setattr(_MovedItems, move.name, move)<EOL>", "docstring": "Add an item to six.moves.", "id": "f17265:m2"}
{"signature": "def add_metaclass(metaclass):", "body": "def wrapper(cls):<EOL><INDENT>orig_vars = cls.__dict__.copy()<EOL>slots = orig_vars.get('<STR_LIT>')<EOL>if slots is not None:<EOL><INDENT>if isinstance(slots, str):<EOL><INDENT>slots = [slots]<EOL><DEDENT>for slots_var in slots:<EOL><INDENT>orig_vars.pop(slots_var)<EOL><DEDENT><DEDENT>orig_vars.pop('<STR_LIT>', None)<EOL>orig_vars.pop('<STR_LIT>', None)<EOL>return metaclass(cls.__name__, cls.__bases__, orig_vars)<EOL><DEDENT>return wrapper<EOL>", "docstring": "Class decorator for creating a class with a metaclass.", "id": "f17265:m8"}
{"signature": "def _add_doc(func, doc):", "body": "func.__doc__ = doc<EOL>", "docstring": "Add documentation to a function.", "id": "f17265:m0"}
{"signature": "def get_code(self, fullname):", "body": "self.__get_module(fullname)  <EOL>return None<EOL>", "docstring": "Return None\n\n        Required, if is_package is implemented", "id": "f17265:c4:m7"}
{"signature": "def remove_move(name):", "body": "try:<EOL><INDENT>delattr(_MovedItems, name)<EOL><DEDENT>except AttributeError:<EOL><INDENT>try:<EOL><INDENT>del moves.__dict__[name]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise AttributeError(\"<STR_LIT>\" % (name,))<EOL><DEDENT><DEDENT>", "docstring": "Remove item from six.moves.", "id": "f17265:m3"}
{"signature": "def fixed_sleep(self, previous_attempt_number, delay_since_first_attempt_ms):", "body": "return self._wait_fixed<EOL>", "docstring": "Sleep a fixed amount of time between each retry.", "id": "f17266:c0:m4"}
{"signature": "def incrementing_sleep(self, previous_attempt_number, delay_since_first_attempt_ms):", "body": "result = self._wait_incrementing_start + (self._wait_incrementing_increment * (previous_attempt_number - <NUM_LIT:1>))<EOL>if result < <NUM_LIT:0>:<EOL><INDENT>result = <NUM_LIT:0><EOL><DEDENT>return result<EOL>", "docstring": "Sleep an incremental amount of time after each attempt, starting at\nwait_incrementing_start and incrementing by wait_incrementing_increment", "id": "f17266:c0:m6"}
{"signature": "def random_sleep(self, previous_attempt_number, delay_since_first_attempt_ms):", "body": "return random.randint(self._wait_random_min, self._wait_random_max)<EOL>", "docstring": "Sleep a random amount of time between wait_random_min and wait_random_max", "id": "f17266:c0:m5"}
{"signature": "def stop_after_attempt(self, previous_attempt_number, delay_since_first_attempt_ms):", "body": "return previous_attempt_number >= self._stop_max_attempt_number<EOL>", "docstring": "Stop after the previous attempt >= stop_max_attempt_number.", "id": "f17266:c0:m1"}
{"signature": "def add(self, event, subscriber, append=True):", "body": "subs = self._subscribers<EOL>if event not in subs:<EOL><INDENT>subs[event] = deque([subscriber])<EOL><DEDENT>else:<EOL><INDENT>sq = subs[event]<EOL>if append:<EOL><INDENT>sq.append(subscriber)<EOL><DEDENT>else:<EOL><INDENT>sq.appendleft(subscriber)<EOL><DEDENT><DEDENT>", "docstring": "Add a subscriber for an event.\n\n:param event: The name of an event.\n:param subscriber: The subscriber to be added (and called when the\n                   event is published).\n:param append: Whether to append or prepend the subscriber to an\n               existing subscriber list for the event.", "id": "f17267:c4:m1"}
{"signature": "def inc_convert(self, value):", "body": "if not os.path.isabs(value):<EOL><INDENT>value = os.path.join(self.base, value)<EOL><DEDENT>with codecs.open(value, '<STR_LIT:r>', encoding='<STR_LIT:utf-8>') as f:<EOL><INDENT>result = json.load(f)<EOL><DEDENT>return result<EOL>", "docstring": "Default converter for the inc:// protocol.", "id": "f17267:c16:m3"}
{"signature": "def _conn_maker(self, *args, **kwargs):", "body": "result = HTTPSConnection(*args, **kwargs)<EOL>if self.ca_certs:<EOL><INDENT>result.ca_certs = self.ca_certs<EOL>result.check_domain = self.check_domain<EOL><DEDENT>return result<EOL>", "docstring": "This is called to create a connection instance. Normally you'd\npass a connection class to do_open, but it doesn't actually check for\na class, and just expects a callable. As long as we behave just as a\nconstructor would have, we should be OK. If it ever changes so that\nwe *must* pass a class, we'll create an UnsafeHTTPSConnection class\nwhich just sets check_domain to False in the class definition, and\nchoose which one to pass to do_open.", "id": "f17267:c8:m1"}
{"signature": "def convert_path(pathname):", "body": "if os.sep == '<STR_LIT:/>':<EOL><INDENT>return pathname<EOL><DEDENT>if not pathname:<EOL><INDENT>return pathname<EOL><DEDENT>if pathname[<NUM_LIT:0>] == '<STR_LIT:/>':<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % pathname)<EOL><DEDENT>if pathname[-<NUM_LIT:1>] == '<STR_LIT:/>':<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % pathname)<EOL><DEDENT>paths = pathname.split('<STR_LIT:/>')<EOL>while os.curdir in paths:<EOL><INDENT>paths.remove(os.curdir)<EOL><DEDENT>if not paths:<EOL><INDENT>return os.curdir<EOL><DEDENT>return os.path.join(*paths)<EOL>", "docstring": "Return 'pathname' as a name that will work on the native filesystem.\n\n    The path is split on '/' and put back together again using the current\n    directory separator.  Needed because filenames in the setup script are\n    always supplied in Unix style, and have to be converted to the local\n    convention before we can actually use them in the filesystem.  Raises\n    ValueError on non-Unix-ish systems if 'pathname' either starts or\n    ends with a slash.", "id": "f17267:m11"}
{"signature": "def iglob(path_glob):", "body": "if _CHECK_RECURSIVE_GLOB.search(path_glob):<EOL><INDENT>msg = \"\"\"<STR_LIT>\"\"\"<EOL>raise ValueError(msg % path_glob)<EOL><DEDENT>if _CHECK_MISMATCH_SET.search(path_glob):<EOL><INDENT>msg = \"\"\"<STR_LIT>\"\"\"<EOL>raise ValueError(msg % path_glob)<EOL><DEDENT>return _iglob(path_glob)<EOL>", "docstring": "Extended globbing function that supports ** and {opt1,opt2,opt3}.", "id": "f17267:m28"}
{"signature": "def reader(self, stream, context):", "body": "progress = self.progress<EOL>verbose = self.verbose<EOL>while True:<EOL><INDENT>s = stream.readline()<EOL>if not s:<EOL><INDENT>break<EOL><DEDENT>if progress is not None:<EOL><INDENT>progress(s, context)<EOL><DEDENT>else:<EOL><INDENT>if not verbose:<EOL><INDENT>sys.stderr.write('<STR_LIT:.>')<EOL><DEDENT>else:<EOL><INDENT>sys.stderr.write(s.decode('<STR_LIT:utf-8>'))<EOL><DEDENT>sys.stderr.flush()<EOL><DEDENT><DEDENT>stream.close()<EOL>", "docstring": "Read lines from a subprocess' output stream and either pass to a progress\ncallable (if specified) or write progress information to sys.stderr.", "id": "f17267:c17:m1"}
{"signature": "def finder_for_path(path):", "body": "result = None<EOL>pkgutil.get_importer(path)<EOL>loader = sys.path_importer_cache.get(path)<EOL>finder = _finder_registry.get(type(loader))<EOL>if finder:<EOL><INDENT>module = _dummy_module<EOL>module.__file__ = os.path.join(path, '<STR_LIT>')<EOL>module.__loader__ = loader<EOL>result = finder(module)<EOL><DEDENT>return result<EOL>", "docstring": "Return a resource finder for a path, which should represent a container.\n\n:param path: The path.\n:return: A :class:`ResourceFinder` instance for the path.", "id": "f17268:m2"}
{"signature": "def is_stale(self, resource, path):", "body": "<EOL>return True<EOL>", "docstring": "Is the cache stale for the given resource?\n\n:param resource: The :class:`Resource` being cached.\n:param path: The path of the resource in the cache.\n:return: True if the cache is stale.", "id": "f17268:c0:m1"}
{"signature": "def _suggest_semantic_version(s):", "body": "result = s.strip().lower()<EOL>for pat, repl in _REPLACEMENTS:<EOL><INDENT>result = pat.sub(repl, result)<EOL><DEDENT>if not result:<EOL><INDENT>result = '<STR_LIT>'<EOL><DEDENT>m = _NUMERIC_PREFIX.match(result)<EOL>if not m:<EOL><INDENT>prefix = '<STR_LIT>'<EOL>suffix = result<EOL><DEDENT>else:<EOL><INDENT>prefix = m.groups()[<NUM_LIT:0>].split('<STR_LIT:.>')<EOL>prefix = [int(i) for i in prefix]<EOL>while len(prefix) < <NUM_LIT:3>:<EOL><INDENT>prefix.append(<NUM_LIT:0>)<EOL><DEDENT>if len(prefix) == <NUM_LIT:3>:<EOL><INDENT>suffix = result[m.end():]<EOL><DEDENT>else:<EOL><INDENT>suffix = '<STR_LIT:.>'.join([str(i) for i in prefix[<NUM_LIT:3>:]]) + result[m.end():]<EOL>prefix = prefix[:<NUM_LIT:3>]<EOL><DEDENT>prefix = '<STR_LIT:.>'.join([str(i) for i in prefix])<EOL>suffix = suffix.strip()<EOL><DEDENT>if suffix:<EOL><INDENT>for pat, repl in _SUFFIX_REPLACEMENTS:<EOL><INDENT>suffix = pat.sub(repl, suffix)<EOL><DEDENT><DEDENT>if not suffix:<EOL><INDENT>result = prefix<EOL><DEDENT>else:<EOL><INDENT>sep = '<STR_LIT:->' if '<STR_LIT>' in suffix else '<STR_LIT:+>'<EOL>result = prefix + sep + suffix<EOL><DEDENT>if not is_semver(result):<EOL><INDENT>result = None<EOL><DEDENT>return result<EOL>", "docstring": "Try to suggest a semantic form for a version for which\n_suggest_normalized_version couldn't come up with anything.", "id": "f17269:m2"}
{"signature": "def match(self, version):", "body": "if isinstance(version, string_types):<EOL><INDENT>version = self.version_class(version)<EOL><DEDENT>for operator, constraint, prefix in self._parts:<EOL><INDENT>f = self._operators.get(operator)<EOL>if isinstance(f, string_types):<EOL><INDENT>f = getattr(self, f)<EOL><DEDENT>if not f:<EOL><INDENT>msg = ('<STR_LIT>'<EOL>'<STR_LIT>' % (operator, self.__class__.__name__))<EOL>raise NotImplementedError(msg)<EOL><DEDENT>if not f(version, constraint, prefix):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Check if the provided version matches the constraints.\n\n:param version: The version to match against this instance.\n:type version: Strring or :class:`Version` instance.", "id": "f17269:c2:m1"}
{"signature": "def _suggest_normalized_version(s):", "body": "try:<EOL><INDENT>_normalized_key(s)<EOL>return s   <EOL><DEDENT>except UnsupportedVersionError:<EOL><INDENT>pass<EOL><DEDENT>rs = s.lower()<EOL>for orig, repl in (('<STR_LIT>', '<STR_LIT:a>'), ('<STR_LIT>', '<STR_LIT:b>'), ('<STR_LIT>', '<STR_LIT:a>'),<EOL>('<STR_LIT>', '<STR_LIT:b>'), ('<STR_LIT>', '<STR_LIT:c>'), ('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT:c>'),<EOL>('<STR_LIT>', '<STR_LIT>'), ('<STR_LIT>', '<STR_LIT>'), ('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT:+>', '<STR_LIT:.>'), ('<STR_LIT:_>', '<STR_LIT:.>'), ('<STR_LIT:U+0020>', '<STR_LIT>'), ('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>')):<EOL><INDENT>rs = rs.replace(orig, repl)<EOL><DEDENT>rs = re.sub(r\"<STR_LIT>\", r\"<STR_LIT>\", rs)<EOL>rs = re.sub(r\"<STR_LIT>\", r\"<STR_LIT>\", rs)<EOL>rs = re.sub(r\"<STR_LIT>\", r\"<STR_LIT>\", rs)<EOL>rs = re.sub(r\"<STR_LIT>\", r\"<STR_LIT>\", rs)<EOL>rs = re.sub(r\"<STR_LIT>\", r\"<STR_LIT>\", rs)<EOL>if rs.startswith('<STR_LIT:v>'):<EOL><INDENT>rs = rs[<NUM_LIT:1>:]<EOL><DEDENT>rs = re.sub(r\"<STR_LIT>\", r\"<STR_LIT>\", rs)<EOL>rs = re.sub(r\"<STR_LIT>\", r\"<STR_LIT>\", rs)<EOL>rs = re.sub(r\"<STR_LIT>\", r\"<STR_LIT>\", rs)<EOL>rs = re.sub(r\"<STR_LIT>\", r\"<STR_LIT>\", rs)<EOL>rs = re.sub(r\"<STR_LIT>\", r\"<STR_LIT>\", rs)<EOL>rs = re.sub(r\"<STR_LIT>\", r\"<STR_LIT>\", rs)<EOL>rs = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", rs)<EOL>rs = re.sub(r\"<STR_LIT>\", r\"<STR_LIT>\", rs)<EOL>rs = re.sub(r\"<STR_LIT>\", r\"<STR_LIT>\", rs)<EOL>rs = re.sub(r\"<STR_LIT>\", r\"<STR_LIT>\", rs)<EOL>rs = re.sub(r\"<STR_LIT>\", r\"<STR_LIT>\", rs)<EOL>try:<EOL><INDENT>_normalized_key(rs)<EOL><DEDENT>except UnsupportedVersionError:<EOL><INDENT>rs = None<EOL><DEDENT>return rs<EOL>", "docstring": "Suggest a normalized version close to the given version string.\n\n    If you have a version string that isn't rational (i.e. NormalizedVersion\n    doesn't like it) then you might be able to get an equivalent (or close)\n    rational version from this function.\n\n    This does a number of simple normalizations to the given string, based\n    on observation of versions currently in use on PyPI. Given a dump of\n    those version during PyCon 2009, 4287 of them:\n    - 2312 (53.93%) match NormalizedVersion without change\n      with the automatic suggestion\n    - 3474 (81.04%) match when using this suggestion method\n\n    @param s {str} An irrational version string.\n    @returns A rational version string, or None, if couldn't determine one.", "id": "f17269:m3"}
{"signature": "def read_configuration(self):", "body": "<EOL>c = self._get_pypirc_command()<EOL>c.repository = self.url<EOL>cfg = c._read_pypirc()<EOL>self.username = cfg.get('<STR_LIT:username>')<EOL>self.password = cfg.get('<STR_LIT:password>')<EOL>self.realm = cfg.get('<STR_LIT>', '<STR_LIT>')<EOL>self.url = cfg.get('<STR_LIT>', self.url)<EOL>", "docstring": "Read the PyPI access configuration as supported by distutils, getting\nPyPI to do the acutal work. This populates ``username``, ``password``,\n``realm`` and ``url`` attributes from the configuration.", "id": "f17271:c0:m2"}
{"signature": "def upload_file(self, metadata, filename, signer=None, sign_password=None,<EOL>filetype='<STR_LIT>', pyversion='<STR_LIT:source>', keystore=None):", "body": "self.check_credentials()<EOL>if not os.path.exists(filename):<EOL><INDENT>raise DistlibException('<STR_LIT>' % filename)<EOL><DEDENT>metadata.validate()<EOL>d = metadata.todict()<EOL>sig_file = None<EOL>if signer:<EOL><INDENT>if not self.gpg:<EOL><INDENT>logger.warning('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>sig_file = self.sign_file(filename, signer, sign_password,<EOL>keystore)<EOL><DEDENT><DEDENT>with open(filename, '<STR_LIT:rb>') as f:<EOL><INDENT>file_data = f.read()<EOL><DEDENT>md5_digest = hashlib.md5(file_data).hexdigest()<EOL>sha256_digest = hashlib.sha256(file_data).hexdigest()<EOL>d.update({<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT:1>',<EOL>'<STR_LIT>': filetype,<EOL>'<STR_LIT>': pyversion,<EOL>'<STR_LIT>': md5_digest,<EOL>'<STR_LIT>': sha256_digest,<EOL>})<EOL>files = [('<STR_LIT:content>', os.path.basename(filename), file_data)]<EOL>if sig_file:<EOL><INDENT>with open(sig_file, '<STR_LIT:rb>') as f:<EOL><INDENT>sig_data = f.read()<EOL><DEDENT>files.append(('<STR_LIT>', os.path.basename(sig_file),<EOL>sig_data))<EOL>shutil.rmtree(os.path.dirname(sig_file))<EOL><DEDENT>request = self.encode_request(d.items(), files)<EOL>return self.send_request(request)<EOL>", "docstring": "Upload a release file to the index.\n\n:param metadata: A :class:`Metadata` instance defining at least a name\n                 and version number for the file to be uploaded.\n:param filename: The pathname of the file to be uploaded.\n:param signer: The identifier of the signer of the file.\n:param sign_password: The passphrase for the signer's\n                      private key used for signing.\n:param filetype: The type of the file being uploaded. This is the\n                distutils command which produced that file, e.g.\n                ``sdist`` or ``bdist_wheel``.\n:param pyversion: The version of Python which the release relates\n                  to. For code compatible with any Python, this would\n                  be ``source``, otherwise it would be e.g. ``3.2``.\n:param keystore: The path to a directory which contains the keys\n                 used in signing. If not specified, the instance's\n                 ``gpg_home`` attribute is used instead.\n:return: The HTTP response received from PyPI upon submission of the\n        request.", "id": "f17271:c0:m10"}
{"signature": "def get_sign_command(self, filename, signer, sign_password,<EOL>keystore=None):", "body": "cmd = [self.gpg, '<STR_LIT>', '<STR_LIT:2>', '<STR_LIT>']<EOL>if keystore is None:<EOL><INDENT>keystore = self.gpg_home<EOL><DEDENT>if keystore:<EOL><INDENT>cmd.extend(['<STR_LIT>', keystore])<EOL><DEDENT>if sign_password is not None:<EOL><INDENT>cmd.extend(['<STR_LIT>', '<STR_LIT>', '<STR_LIT:0>'])<EOL><DEDENT>td = tempfile.mkdtemp()<EOL>sf = os.path.join(td, os.path.basename(filename) + '<STR_LIT>')<EOL>cmd.extend(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>signer, '<STR_LIT>', sf, filename])<EOL>logger.debug('<STR_LIT>', '<STR_LIT:U+0020>'.join(cmd))<EOL>return cmd, sf<EOL>", "docstring": "Return a suitable command for signing a file.\n\n:param filename: The pathname to the file to be signed.\n:param signer: The identifier of the signer of the file.\n:param sign_password: The passphrase for the signer's\n                      private key used for signing.\n:param keystore: The path to a directory which contains the keys\n                 used in verification. If not specified, the\n                 instance's ``gpg_home`` attribute is used instead.\n:return: The signing command as a list suitable to be\n         passed to :class:`subprocess.Popen`.", "id": "f17271:c0:m7"}
{"signature": "def compatible_tags():", "body": "versions = [VER_SUFFIX]<EOL>major = VER_SUFFIX[<NUM_LIT:0>]<EOL>for minor in range(sys.version_info[<NUM_LIT:1>] - <NUM_LIT:1>, - <NUM_LIT:1>, -<NUM_LIT:1>):<EOL><INDENT>versions.append('<STR_LIT>'.join([major, str(minor)]))<EOL><DEDENT>abis = []<EOL>for suffix, _, _ in imp.get_suffixes():<EOL><INDENT>if suffix.startswith('<STR_LIT>'):<EOL><INDENT>abis.append(suffix.split('<STR_LIT:.>', <NUM_LIT:2>)[<NUM_LIT:1>])<EOL><DEDENT><DEDENT>abis.sort()<EOL>if ABI != '<STR_LIT:none>':<EOL><INDENT>abis.insert(<NUM_LIT:0>, ABI)<EOL><DEDENT>abis.append('<STR_LIT:none>')<EOL>result = []<EOL>arches = [ARCH]<EOL>if sys.platform == '<STR_LIT>':<EOL><INDENT>m = re.match('<STR_LIT>', ARCH)<EOL>if m:<EOL><INDENT>name, major, minor, arch = m.groups()<EOL>minor = int(minor)<EOL>matches = [arch]<EOL>if arch in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>matches.append('<STR_LIT>')<EOL><DEDENT>if arch in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>matches.append('<STR_LIT>')<EOL><DEDENT>if arch in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>matches.append('<STR_LIT>')<EOL><DEDENT>if arch in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>matches.append('<STR_LIT>')<EOL><DEDENT>if arch in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>matches.append('<STR_LIT>')<EOL><DEDENT>while minor >= <NUM_LIT:0>:<EOL><INDENT>for match in matches:<EOL><INDENT>s = '<STR_LIT>' % (name, major, minor, match)<EOL>if s != ARCH:   <EOL><INDENT>arches.append(s)<EOL><DEDENT><DEDENT>minor -= <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>for abi in abis:<EOL><INDENT>for arch in arches:<EOL><INDENT>result.append(('<STR_LIT>'.join((IMP_PREFIX, versions[<NUM_LIT:0>])), abi, arch))<EOL><DEDENT><DEDENT>for i, version in enumerate(versions):<EOL><INDENT>result.append(('<STR_LIT>'.join((IMP_PREFIX, version)), '<STR_LIT:none>', '<STR_LIT>'))<EOL>if i == <NUM_LIT:0>:<EOL><INDENT>result.append(('<STR_LIT>'.join((IMP_PREFIX, version[<NUM_LIT:0>])), '<STR_LIT:none>', '<STR_LIT>'))<EOL><DEDENT><DEDENT>for i, version in enumerate(versions):<EOL><INDENT>result.append(('<STR_LIT>'.join(('<STR_LIT>', version)), '<STR_LIT:none>', '<STR_LIT>'))<EOL>if i == <NUM_LIT:0>:<EOL><INDENT>result.append(('<STR_LIT>'.join(('<STR_LIT>', version[<NUM_LIT:0>])), '<STR_LIT:none>', '<STR_LIT>'))<EOL><DEDENT><DEDENT>return set(result)<EOL>", "docstring": "Return (pyver, abi, arch) tuples compatible with this Python.", "id": "f17272:m0"}
{"signature": "def build(self, paths, tags=None, wheel_version=None):", "body": "if tags is None:<EOL><INDENT>tags = {}<EOL><DEDENT>libkey = list(filter(lambda o: o in paths, ('<STR_LIT>', '<STR_LIT>')))[<NUM_LIT:0>]<EOL>if libkey == '<STR_LIT>':<EOL><INDENT>is_pure = '<STR_LIT:false>'<EOL>default_pyver = [IMPVER]<EOL>default_abi = [ABI]<EOL>default_arch = [ARCH]<EOL><DEDENT>else:<EOL><INDENT>is_pure = '<STR_LIT:true>'<EOL>default_pyver = [PYVER]<EOL>default_abi = ['<STR_LIT:none>']<EOL>default_arch = ['<STR_LIT>']<EOL><DEDENT>self.pyver = tags.get('<STR_LIT>', default_pyver)<EOL>self.abi = tags.get('<STR_LIT>', default_abi)<EOL>self.arch = tags.get('<STR_LIT>', default_arch)<EOL>libdir = paths[libkey]<EOL>name_ver = '<STR_LIT>' % (self.name, self.version)<EOL>data_dir = '<STR_LIT>' % name_ver<EOL>info_dir = '<STR_LIT>' % name_ver<EOL>archive_paths = []<EOL>for key in ('<STR_LIT:data>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>if key not in paths:<EOL><INDENT>continue<EOL><DEDENT>path = paths[key]<EOL>if os.path.isdir(path):<EOL><INDENT>for root, dirs, files in os.walk(path):<EOL><INDENT>for fn in files:<EOL><INDENT>p = fsdecode(os.path.join(root, fn))<EOL>rp = os.path.relpath(p, path)<EOL>ap = to_posix(os.path.join(data_dir, key, rp))<EOL>archive_paths.append((ap, p))<EOL>if key == '<STR_LIT>' and not p.endswith('<STR_LIT>'):<EOL><INDENT>with open(p, '<STR_LIT:rb>') as f:<EOL><INDENT>data = f.read()<EOL><DEDENT>data = self.process_shebang(data)<EOL>with open(p, '<STR_LIT:wb>') as f:<EOL><INDENT>f.write(data)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>path = libdir<EOL>distinfo = None<EOL>for root, dirs, files in os.walk(path):<EOL><INDENT>if root == path:<EOL><INDENT>for i, dn in enumerate(dirs):<EOL><INDENT>dn = fsdecode(dn)<EOL>if dn.endswith('<STR_LIT>'):<EOL><INDENT>distinfo = os.path.join(root, dn)<EOL>del dirs[i]<EOL>break<EOL><DEDENT><DEDENT>assert distinfo, '<STR_LIT>'<EOL><DEDENT>for fn in files:<EOL><INDENT>if fsdecode(fn).endswith(('<STR_LIT>', '<STR_LIT>')):<EOL><INDENT>continue<EOL><DEDENT>p = os.path.join(root, fn)<EOL>rp = to_posix(os.path.relpath(p, path))<EOL>archive_paths.append((rp, p))<EOL><DEDENT><DEDENT>files = os.listdir(distinfo)<EOL>for fn in files:<EOL><INDENT>if fn not in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>p = fsdecode(os.path.join(distinfo, fn))<EOL>ap = to_posix(os.path.join(info_dir, fn))<EOL>archive_paths.append((ap, p))<EOL><DEDENT><DEDENT>wheel_metadata = [<EOL>'<STR_LIT>' % (wheel_version or self.wheel_version),<EOL>'<STR_LIT>' % __version__,<EOL>'<STR_LIT>' % is_pure,<EOL>]<EOL>for pyver, abi, arch in self.tags:<EOL><INDENT>wheel_metadata.append('<STR_LIT>' % (pyver, abi, arch))<EOL><DEDENT>p = os.path.join(distinfo, '<STR_LIT>')<EOL>with open(p, '<STR_LIT:w>') as f:<EOL><INDENT>f.write('<STR_LIT:\\n>'.join(wheel_metadata))<EOL><DEDENT>ap = to_posix(os.path.join(info_dir, '<STR_LIT>'))<EOL>archive_paths.append((ap, p))<EOL>self.write_records((distinfo, info_dir), libdir, archive_paths)<EOL>pathname = os.path.join(self.dirname, self.filename)<EOL>self.build_zip(pathname, archive_paths)<EOL>return pathname<EOL>", "docstring": "Build a wheel from files in specified paths, and use any specified tags\nwhen determining the name of the wheel.", "id": "f17272:c1:m12"}
{"signature": "def is_mountable(self):", "body": "return True<EOL>", "docstring": "Determine if a wheel is asserted as mountable by its metadata.", "id": "f17272:c1:m17"}
{"signature": "def remove_distribution(self, dist):", "body": "logger.debug('<STR_LIT>', dist)<EOL>name = dist.key<EOL>del self.dists_by_name[name]<EOL>del self.dists[(name, dist.version)]<EOL>for p in dist.provides:<EOL><INDENT>name, version = parse_name_and_version(p)<EOL>logger.debug('<STR_LIT>', name, version, dist)<EOL>s = self.provided[name]<EOL>s.remove((version, dist))<EOL>if not s:<EOL><INDENT>del self.provided[name]<EOL><DEDENT><DEDENT>", "docstring": "Remove a distribution from the finder. This will update internal\ninformation about who provides what.\n:param dist: The distribution to remove.", "id": "f17273:c10:m2"}
{"signature": "def _should_queue(self, link, referrer, rel):", "body": "scheme, netloc, path, _, _, _ = urlparse(link)<EOL>if path.endswith(self.source_extensions + self.binary_extensions +<EOL>self.excluded_extensions):<EOL><INDENT>result = False<EOL><DEDENT>elif self.skip_externals and not link.startswith(self.base_url):<EOL><INDENT>result = False<EOL><DEDENT>elif not referrer.startswith(self.base_url):<EOL><INDENT>result = False<EOL><DEDENT>elif rel not in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>result = False<EOL><DEDENT>elif scheme not in ('<STR_LIT:http>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>result = False<EOL><DEDENT>elif self._is_platform_dependent(link):<EOL><INDENT>result = False<EOL><DEDENT>else:<EOL><INDENT>host = netloc.split('<STR_LIT::>', <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>if host.lower() == '<STR_LIT:localhost>':<EOL><INDENT>result = False<EOL><DEDENT>else:<EOL><INDENT>result = True<EOL><DEDENT><DEDENT>logger.debug('<STR_LIT>', link, rel,<EOL>referrer, result)<EOL>return result<EOL>", "docstring": "Determine whether a link URL from a referring page and with a\nparticular \"rel\" attribute should be queued for scraping.", "id": "f17273:c5:m6"}
{"signature": "def get_project(self, name):", "body": "if self._cache is None:<EOL><INDENT>result = self._get_project(name)<EOL><DEDENT>elif name in self._cache:<EOL><INDENT>result = self._cache[name]<EOL><DEDENT>else:<EOL><INDENT>result = self._get_project(name)<EOL>self._cache[name] = result<EOL><DEDENT>return result<EOL>", "docstring": "For a given project, get a dictionary mapping available versions to Distribution\ninstances.\n\nThis calls _get_project to do all the work, and just implements a caching layer on top.", "id": "f17273:c1:m6"}
{"signature": "def __init__(self, url, **kwargs):", "body": "super(PyPIRPCLocator, self).__init__(**kwargs)<EOL>self.base_url = url<EOL>self.client = ServerProxy(url, timeout=<NUM_LIT>)<EOL>", "docstring": "Initialise an instance.\n\n:param url: The URL to use for XML-RPC.\n:param kwargs: Passed to the superclass constructor.", "id": "f17273:c2:m0"}
{"signature": "def __init__(self, locator=None):", "body": "self.locator = locator or default_locator<EOL>self.scheme = get_scheme(self.locator.scheme)<EOL>", "docstring": "Initialise an instance, using the specified locator\nto locate distributions.", "id": "f17273:c10:m0"}
{"signature": "def get_distribution_names(self):", "body": "result = set()<EOL>page = self.get_page(self.base_url)<EOL>if not page:<EOL><INDENT>raise DistlibException('<STR_LIT>' % self.base_url)<EOL><DEDENT>for match in self._distname_re.finditer(page.data):<EOL><INDENT>result.add(match.group(<NUM_LIT:1>))<EOL><DEDENT>return result<EOL>", "docstring": "Return all the distribution names known to this locator.", "id": "f17273:c5:m9"}
{"signature": "def get_page(self, url):", "body": "<EOL>scheme, netloc, path, _, _, _ = urlparse(url)<EOL>if scheme == '<STR_LIT:file>' and os.path.isdir(url2pathname(path)):<EOL><INDENT>url = urljoin(ensure_slash(url), '<STR_LIT>')<EOL><DEDENT>if url in self._page_cache:<EOL><INDENT>result = self._page_cache[url]<EOL>logger.debug('<STR_LIT>', url, result)<EOL><DEDENT>else:<EOL><INDENT>host = netloc.split('<STR_LIT::>', <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>result = None<EOL>if host in self._bad_hosts:<EOL><INDENT>logger.debug('<STR_LIT>', url, host)<EOL><DEDENT>else:<EOL><INDENT>req = Request(url, headers={'<STR_LIT>': '<STR_LIT>'})<EOL>try:<EOL><INDENT>logger.debug('<STR_LIT>', url)<EOL>resp = self.opener.open(req, timeout=self.timeout)<EOL>logger.debug('<STR_LIT>', url)<EOL>headers = resp.info()<EOL>content_type = headers.get('<STR_LIT:Content-Type>', '<STR_LIT>')<EOL>if HTML_CONTENT_TYPE.match(content_type):<EOL><INDENT>final_url = resp.geturl()<EOL>data = resp.read()<EOL>encoding = headers.get('<STR_LIT>')<EOL>if encoding:<EOL><INDENT>decoder = self.decoders[encoding]   <EOL>data = decoder(data)<EOL><DEDENT>encoding = '<STR_LIT:utf-8>'<EOL>m = CHARSET.search(content_type)<EOL>if m:<EOL><INDENT>encoding = m.group(<NUM_LIT:1>)<EOL><DEDENT>try:<EOL><INDENT>data = data.decode(encoding)<EOL><DEDENT>except UnicodeError:<EOL><INDENT>data = data.decode('<STR_LIT>')    <EOL><DEDENT>result = Page(data, final_url)<EOL>self._page_cache[final_url] = result<EOL><DEDENT><DEDENT>except HTTPError as e:<EOL><INDENT>if e.code != <NUM_LIT>:<EOL><INDENT>logger.exception('<STR_LIT>', url, e)<EOL><DEDENT><DEDENT>except URLError as e:<EOL><INDENT>logger.exception('<STR_LIT>', url, e)<EOL>with self._lock:<EOL><INDENT>self._bad_hosts.add(host)<EOL><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>logger.exception('<STR_LIT>', url, e)<EOL><DEDENT>finally:<EOL><INDENT>self._page_cache[url] = result   <EOL><DEDENT><DEDENT><DEDENT>return result<EOL>", "docstring": "Get the HTML for an URL, possibly from an in-memory cache.\n\nXXX TODO Note: this cache is never actually cleared. It's assumed that\nthe data won't get stale over the lifetime of a locator instance (not\nnecessarily true for the default_locator).", "id": "f17273:c5:m8"}
{"signature": "def _process_download(self, url):", "body": "if self._is_platform_dependent(url):<EOL><INDENT>info = None<EOL><DEDENT>else:<EOL><INDENT>info = self.convert_url_to_download_info(url, self.project_name)<EOL><DEDENT>logger.debug('<STR_LIT>', url, info)<EOL>if info:<EOL><INDENT>with self._lock:    <EOL><INDENT>self._update_version_data(self.result, info)<EOL><DEDENT><DEDENT>return info<EOL>", "docstring": "See if an URL is a suitable download for a project.\n\nIf it is, register information in the result dictionary (for\n_get_project) about the specific version it's for.\n\nNote that the return value isn't actually used other than as a boolean\nvalue.", "id": "f17273:c5:m5"}
{"signature": "def get_distribution_names(self):", "body": "return set(self.client.list_packages())<EOL>", "docstring": "Return all the distribution names known to this locator.", "id": "f17273:c2:m1"}
{"signature": "def __init__(self, data, url):", "body": "self.data = data<EOL>self.base_url = self.url = url<EOL>m = self._base.search(self.data)<EOL>if m:<EOL><INDENT>self.base_url = m.group(<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Initialise an instance with the Unicode page contents and the URL they\ncame from.", "id": "f17273:c4:m0"}
{"signature": "def get_fragment(self, offset):", "body": "fragment_len = <NUM_LIT:10><EOL>s = '<STR_LIT>' % (self.source[offset:offset + fragment_len])<EOL>if offset + fragment_len < len(self.source):<EOL><INDENT>s += '<STR_LIT>'<EOL><DEDENT>return s<EOL>", "docstring": "Get the part of the source which is causing a problem.", "id": "f17275:c0:m1"}
{"signature": "def interpret(marker, execution_context=None):", "body": "return Evaluator(execution_context).evaluate(marker.strip())<EOL>", "docstring": "Interpret a marker and return a result depending on environment.\n\n:param marker: The marker to interpret.\n:type marker: str\n:param execution_context: The context used for name lookup.\n:type execution_context: mapping", "id": "f17275:m0"}
{"signature": "def get_requirements(self, reqts, extras=None, env=None):", "body": "if self._legacy:<EOL><INDENT>result = reqts<EOL><DEDENT>else:<EOL><INDENT>result = []<EOL>extras = get_extras(extras or [], self.extras)<EOL>for d in reqts:<EOL><INDENT>if '<STR_LIT>' not in d and '<STR_LIT>' not in d:<EOL><INDENT>include = True<EOL><DEDENT>else:<EOL><INDENT>if '<STR_LIT>' not in d:<EOL><INDENT>include = True<EOL><DEDENT>else:<EOL><INDENT>include = d.get('<STR_LIT>') in extras<EOL><DEDENT>if include:<EOL><INDENT>marker = d.get('<STR_LIT>')<EOL>if marker:<EOL><INDENT>include = interpret(marker, env)<EOL><DEDENT><DEDENT><DEDENT>if include:<EOL><INDENT>result.extend(d['<STR_LIT>'])<EOL><DEDENT><DEDENT>for key in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT:test>'):<EOL><INDENT>e = '<STR_LIT>' % key<EOL>if e in extras:<EOL><INDENT>extras.remove(e)<EOL>reqts = self._data.get('<STR_LIT>' % key, [])<EOL>result.extend(self.get_requirements(reqts, extras=extras,<EOL>env=env))<EOL><DEDENT><DEDENT><DEDENT>return result<EOL>", "docstring": "Base method to get dependencies, given a set of extras\nto satisfy and an optional environment context.\n:param reqts: A list of sometimes-wanted dependencies,\n              perhaps dependent on extras and environment.\n:param extras: A list of optional components being requested.\n:param env: An optional environment for marker evaluation.", "id": "f17276:c5:m7"}
{"signature": "def read_file(self, fileob):", "body": "msg = message_from_file(fileob)<EOL>self._fields['<STR_LIT>'] = msg['<STR_LIT>']<EOL>for field in _ALL_FIELDS:<EOL><INDENT>if field not in msg:<EOL><INDENT>continue<EOL><DEDENT>if field in _LISTFIELDS:<EOL><INDENT>values = msg.get_all(field)<EOL>if field in _LISTTUPLEFIELDS and values is not None:<EOL><INDENT>values = [tuple(value.split('<STR_LIT:U+002C>')) for value in values]<EOL><DEDENT>self.set(field, values)<EOL><DEDENT>else:<EOL><INDENT>value = msg[field]<EOL>if value is not None and value != '<STR_LIT>':<EOL><INDENT>self.set(field, value)<EOL><DEDENT><DEDENT><DEDENT>self.set_metadata_version()<EOL>", "docstring": "Read the metadata values from a file object.", "id": "f17276:c4:m15"}
{"signature": "def _best_version(fields):", "body": "def _has_marker(keys, markers):<EOL><INDENT>for marker in markers:<EOL><INDENT>if marker in keys:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL><DEDENT>keys = []<EOL>for key, value in fields.items():<EOL><INDENT>if value in ([], '<STR_LIT>', None):<EOL><INDENT>continue<EOL><DEDENT>keys.append(key)<EOL><DEDENT>possible_versions = ['<STR_LIT:1.0>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>for key in keys:<EOL><INDENT>if key not in _241_FIELDS and '<STR_LIT:1.0>' in possible_versions:<EOL><INDENT>possible_versions.remove('<STR_LIT:1.0>')<EOL><DEDENT>if key not in _314_FIELDS and '<STR_LIT>' in possible_versions:<EOL><INDENT>possible_versions.remove('<STR_LIT>')<EOL><DEDENT>if key not in _345_FIELDS and '<STR_LIT>' in possible_versions:<EOL><INDENT>possible_versions.remove('<STR_LIT>')<EOL><DEDENT>if key not in _426_FIELDS and '<STR_LIT>' in possible_versions:<EOL><INDENT>possible_versions.remove('<STR_LIT>')<EOL><DEDENT><DEDENT>if len(possible_versions) == <NUM_LIT:1>:<EOL><INDENT>return possible_versions[<NUM_LIT:0>]   <EOL><DEDENT>elif len(possible_versions) == <NUM_LIT:0>:<EOL><INDENT>raise MetadataConflictError('<STR_LIT>')<EOL><DEDENT>is_1_1 = '<STR_LIT>' in possible_versions and _has_marker(keys, _314_MARKERS)<EOL>is_1_2 = '<STR_LIT>' in possible_versions and _has_marker(keys, _345_MARKERS)<EOL>is_2_0 = '<STR_LIT>' in possible_versions and _has_marker(keys, _426_MARKERS)<EOL>if int(is_1_1) + int(is_1_2) + int(is_2_0) > <NUM_LIT:1>:<EOL><INDENT>raise MetadataConflictError('<STR_LIT>')<EOL><DEDENT>if not is_1_1 and not is_1_2 and not is_2_0:<EOL><INDENT>if PKG_INFO_PREFERRED_VERSION in possible_versions:<EOL><INDENT>return PKG_INFO_PREFERRED_VERSION<EOL><DEDENT><DEDENT>if is_1_1:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>if is_1_2:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>return '<STR_LIT>'<EOL>", "docstring": "Detect the best version depending on the fields used.", "id": "f17276:m1"}
{"signature": "def todict(self, skip_missing=False):", "body": "self.set_metadata_version()<EOL>mapping_1_0 = (<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT:name>', '<STR_LIT:Name>'),<EOL>('<STR_LIT:version>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT:description>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>)<EOL>data = {}<EOL>for key, field_name in mapping_1_0:<EOL><INDENT>if not skip_missing or field_name in self._fields:<EOL><INDENT>data[key] = self[field_name]<EOL><DEDENT><DEDENT>if self['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>mapping_1_2 = (<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>)<EOL>for key, field_name in mapping_1_2:<EOL><INDENT>if not skip_missing or field_name in self._fields:<EOL><INDENT>if key != '<STR_LIT>':<EOL><INDENT>data[key] = self[field_name]<EOL><DEDENT>else:<EOL><INDENT>data[key] = ['<STR_LIT:U+002C>'.join(u) for u in self[field_name]]<EOL><DEDENT><DEDENT><DEDENT><DEDENT>elif self['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>mapping_1_1 = (<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>)<EOL>for key, field_name in mapping_1_1:<EOL><INDENT>if not skip_missing or field_name in self._fields:<EOL><INDENT>data[key] = self[field_name]<EOL><DEDENT><DEDENT><DEDENT>return data<EOL>", "docstring": "Return fields as a dict.\n\n        Field names will be converted to use the underscore-lowercase style\n        instead of hyphen-mixed case (i.e. home_page instead of Home-page).", "id": "f17276:c4:m22"}
{"signature": "def write_shared_locations(self, paths, dry_run=False):", "body": "shared_path = os.path.join(self.path, '<STR_LIT>')<EOL>logger.info('<STR_LIT>', shared_path)<EOL>if dry_run:<EOL><INDENT>return None<EOL><DEDENT>lines = []<EOL>for key in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:data>'):<EOL><INDENT>path = paths[key]<EOL>if os.path.isdir(paths[key]):<EOL><INDENT>lines.append('<STR_LIT>' % (key,  path))<EOL><DEDENT><DEDENT>for ns in paths.get('<STR_LIT>', ()):<EOL><INDENT>lines.append('<STR_LIT>' % ns)<EOL><DEDENT>with codecs.open(shared_path, '<STR_LIT:w>', encoding='<STR_LIT:utf-8>') as f:<EOL><INDENT>f.write('<STR_LIT:\\n>'.join(lines))<EOL><DEDENT>return shared_path<EOL>", "docstring": "Write shared location information to the SHARED file in .dist-info.\n:param paths: A dictionary as described in the documentation for\n:meth:`shared_locations`.\n:param dry_run: If True, the action is logged but no file is actually\n                written.\n:return: The path of the file written to.", "id": "f17277:c4:m12"}
{"signature": "def get_file_path(self, name, relative_path):", "body": "dist = self.get_distribution(name)<EOL>if dist is None:<EOL><INDENT>raise LookupError('<STR_LIT>' % name)<EOL><DEDENT>return dist.get_resource_path(relative_path)<EOL>", "docstring": "Return the path to a resource file.", "id": "f17277:c1:m10"}
{"signature": "def list_distinfo_files(self):", "body": "base = os.path.dirname(self.path)<EOL>for path, checksum, size in self._get_records():<EOL><INDENT>if not os.path.isabs(path):<EOL><INDENT>path = os.path.join(base, path)<EOL><DEDENT>if path.startswith(self.path):<EOL><INDENT>yield path<EOL><DEDENT><DEDENT>", "docstring": "Iterates over the ``RECORD`` entries and returns paths for each line if\nthe path is pointing to a file located in the ``.dist-info`` directory\nor one of its subdirectories.\n\n:returns: iterator of paths", "id": "f17277:c4:m15"}
{"signature": "def get_distinfo_file(self, path):", "body": "<EOL>if path.find(os.sep) >= <NUM_LIT:0>:<EOL><INDENT>distinfo_dirname, path = path.split(os.sep)[-<NUM_LIT:2>:]<EOL>if distinfo_dirname != self.path.split(os.sep)[-<NUM_LIT:1>]:<EOL><INDENT>raise DistlibException(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % (path, self.name, self.version))<EOL><DEDENT><DEDENT>if path not in DIST_FILES:<EOL><INDENT>raise DistlibException('<STR_LIT>'<EOL>'<STR_LIT>' % (path, self.path))<EOL><DEDENT>return os.path.join(self.path, path)<EOL>", "docstring": "Returns a path located under the ``.dist-info`` directory. Returns a\nstring representing the path.\n\n:parameter path: a ``'/'``-separated path relative to the\n                 ``.dist-info`` directory or an absolute path;\n                 If *path* is an absolute path and doesn't start\n                 with the ``.dist-info`` directory path,\n                 a :class:`DistlibException` is raised\n:type path: str\n:rtype: str", "id": "f17277:c4:m14"}
{"signature": "def provides_distribution(self, name, version=None):", "body": "matcher = None<EOL>if not version is None:<EOL><INDENT>try:<EOL><INDENT>matcher = self._scheme.matcher('<STR_LIT>' % (name, version))<EOL><DEDENT>except ValueError:<EOL><INDENT>raise DistlibException('<STR_LIT>' %<EOL>(name, version))<EOL><DEDENT><DEDENT>for dist in self.get_distributions():<EOL><INDENT>provided = dist.provides<EOL>for p in provided:<EOL><INDENT>p_name, p_ver = parse_name_and_version(p)<EOL>if matcher is None:<EOL><INDENT>if p_name == name:<EOL><INDENT>yield dist<EOL>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if p_name == name and matcher.match(p_ver):<EOL><INDENT>yield dist<EOL>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Iterates over all distributions to find which distributions provide *name*.\nIf a *version* is provided, it will be used to filter the results.\n\nThis function only returns the first result found, since no more than\none values are expected. If the directory is not found, returns ``None``.\n\n:parameter version: a version specifier that indicates the version\n                    required, conforming to the format in ``PEP-345``\n\n:type name: string\n:type version: string", "id": "f17277:c1:m9"}
{"signature": "@property<EOL><INDENT>def source_url(self):<DEDENT>", "body": "return self.metadata.source_url<EOL>", "docstring": "The source archive download URL for this distribution.", "id": "f17277:c2:m1"}
{"signature": "def read_exports(self):", "body": "result = {}<EOL>r = self.get_distinfo_resource(EXPORTS_FILENAME)<EOL>if r:<EOL><INDENT>with contextlib.closing(r.as_stream()) as stream:<EOL><INDENT>result = read_exports(stream)<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Read exports data from a file in .ini format.\n\n:return: A dictionary of exports, mapping an export category to a list\n         of :class:`ExportEntry` instances describing the individual\n         export entries.", "id": "f17277:c4:m5"}
{"signature": "def get_hash(self, data, hasher=None):", "body": "if hasher is None:<EOL><INDENT>hasher = self.hasher<EOL><DEDENT>if hasher is None:<EOL><INDENT>hasher = hashlib.md5<EOL>prefix = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>hasher = getattr(hashlib, hasher)<EOL>prefix = '<STR_LIT>' % self.hasher<EOL><DEDENT>digest = hasher(data).digest()<EOL>digest = base64.urlsafe_b64encode(digest).rstrip(b'<STR_LIT:=>').decode('<STR_LIT:ascii>')<EOL>return '<STR_LIT>' % (prefix, digest)<EOL>", "docstring": "Get the hash of some data, using a particular hash algorithm, if\nspecified.\n\n:param data: The data to be hashed.\n:type data: bytes\n:param hasher: The name of a hash implementation, supported by hashlib,\n               or ``None``. Examples of valid values are ``'sha1'``,\n               ``'sha224'``, ``'sha384'``, '``sha256'``, ``'md5'`` and\n               ``'sha512'``. If no hasher is specified, the ``hasher``\n               attribute of the :class:`InstalledDistribution` instance\n               is used. If the hasher is determined to be ``None``, MD5\n               is used as the hashing algorithm.\n:returns: The hash of the data. If a hasher was explicitly specified,\n          the returned hash will be prefixed with the specified hasher\n          followed by '='.\n:rtype: str", "id": "f17277:c3:m1"}
{"signature": "def check_installed_files(self):", "body": "mismatches = []<EOL>base = os.path.dirname(self.path)<EOL>record_path = self.get_distinfo_file('<STR_LIT>')<EOL>for path, hash_value, size in self.list_installed_files():<EOL><INDENT>if not os.path.isabs(path):<EOL><INDENT>path = os.path.join(base, path)<EOL><DEDENT>if path == record_path:<EOL><INDENT>continue<EOL><DEDENT>if not os.path.exists(path):<EOL><INDENT>mismatches.append((path, '<STR_LIT>', True, False))<EOL><DEDENT>elif os.path.isfile(path):<EOL><INDENT>actual_size = str(os.path.getsize(path))<EOL>if size and actual_size != size:<EOL><INDENT>mismatches.append((path, '<STR_LIT:size>', size, actual_size))<EOL><DEDENT>elif hash_value:<EOL><INDENT>if '<STR_LIT:=>' in hash_value:<EOL><INDENT>hasher = hash_value.split('<STR_LIT:=>', <NUM_LIT:1>)[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>hasher = None<EOL><DEDENT>with open(path, '<STR_LIT:rb>') as f:<EOL><INDENT>actual_hash = self.get_hash(f.read(), hasher)<EOL>if actual_hash != hash_value:<EOL><INDENT>mismatches.append((path, '<STR_LIT>', hash_value, actual_hash))<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>return mismatches<EOL>", "docstring": "Checks that the hashes and sizes of the files in ``RECORD`` are\nmatched by the files themselves. Returns a (possibly empty) list of\nmismatches. Each entry in the mismatch list will be a tuple consisting\nof the path, 'exists', 'size' or 'hash' according to what didn't match\n(existence is checked first, then size, then hash), the expected\nvalue and the actual value.", "id": "f17277:c4:m10"}
{"signature": "@classmethod<EOL><INDENT>def distinfo_dirname(cls, name, version):<DEDENT>", "body": "name = name.replace('<STR_LIT:->', '<STR_LIT:_>')<EOL>return '<STR_LIT:->'.join([name, version]) + DISTINFO_EXT<EOL>", "docstring": "The *name* and *version* parameters are converted into their\nfilename-escaped form, i.e. any ``'-'`` characters are replaced\nwith ``'_'`` other than the one in ``'dist-info'`` and the one\nseparating the name from the version number.\n\n:parameter name: is converted to a standard distribution name by replacing\n                 any runs of non- alphanumeric characters with a single\n                 ``'-'``.\n:type name: string\n:parameter version: is converted to a standard version string. Spaces\n                    become dots, and all other non-alphanumeric characters\n                    (except dots) become dashes, with runs of multiple\n                    dashes condensed to a single dash.\n:type version: string\n:returns: directory name\n:rtype: string", "id": "f17277:c1:m6"}
{"signature": "def _get_records(self):", "body": "results = []<EOL>r = self.get_distinfo_resource('<STR_LIT>')<EOL>with contextlib.closing(r.as_stream()) as stream:<EOL><INDENT>with CSVReader(stream=stream) as record_reader:<EOL><INDENT>for row in record_reader:<EOL><INDENT>missing = [None for i in range(len(row), <NUM_LIT:3>)]<EOL>path, checksum, size = row + missing<EOL>results.append((path, checksum, size))<EOL><DEDENT><DEDENT><DEDENT>return results<EOL>", "docstring": "Get the list of installed files for the distribution\n:return: A list of tuples of path, hash and size. Note that hash and\n         size might be ``None`` for some entries. The path is exactly\n         as stored in the file (which is as in PEP 376).", "id": "f17277:c4:m3"}
{"signature": "def get_dependent_dists(dists, dist):", "body": "if dist not in dists:<EOL><INDENT>raise DistlibException('<STR_LIT>'<EOL>'<STR_LIT>' % dist.name)<EOL><DEDENT>graph = make_graph(dists)<EOL>dep = [dist]  <EOL>todo = graph.reverse_list[dist]  <EOL>while todo:<EOL><INDENT>d = todo.pop()<EOL>dep.append(d)<EOL>for succ in graph.reverse_list[d]:<EOL><INDENT>if succ not in dep:<EOL><INDENT>todo.append(succ)<EOL><DEDENT><DEDENT><DEDENT>dep.pop(<NUM_LIT:0>)  <EOL>return dep<EOL>", "docstring": "Recursively generate a list of distributions from *dists* that are\n    dependent on *dist*.\n\n    :param dists: a list of distributions\n    :param dist: a distribution, member of *dists* for which we are interested", "id": "f17277:m1"}
{"signature": "def make_graph(dists, scheme='<STR_LIT:default>'):", "body": "scheme = get_scheme(scheme)<EOL>graph = DependencyGraph()<EOL>provided = {}  <EOL>for dist in dists:<EOL><INDENT>graph.add_distribution(dist)<EOL>for p in dist.provides:<EOL><INDENT>name, version = parse_name_and_version(p)<EOL>logger.debug('<STR_LIT>', name, version, dist)<EOL>provided.setdefault(name, []).append((version, dist))<EOL><DEDENT><DEDENT>for dist in dists:<EOL><INDENT>requires = (dist.run_requires | dist.meta_requires |<EOL>dist.build_requires | dist.dev_requires)<EOL>for req in requires:<EOL><INDENT>try:<EOL><INDENT>matcher = scheme.matcher(req)<EOL><DEDENT>except UnsupportedVersionError:<EOL><INDENT>logger.warning('<STR_LIT>',<EOL>req)<EOL>name = req.split()[<NUM_LIT:0>]<EOL>matcher = scheme.matcher(name)<EOL><DEDENT>name = matcher.key   <EOL>matched = False<EOL>if name in provided:<EOL><INDENT>for version, provider in provided[name]:<EOL><INDENT>try:<EOL><INDENT>match = matcher.match(version)<EOL><DEDENT>except UnsupportedVersionError:<EOL><INDENT>match = False<EOL><DEDENT>if match:<EOL><INDENT>graph.add_edge(dist, provider, req)<EOL>matched = True<EOL>break<EOL><DEDENT><DEDENT><DEDENT>if not matched:<EOL><INDENT>graph.add_missing(dist, req)<EOL><DEDENT><DEDENT><DEDENT>return graph<EOL>", "docstring": "Makes a dependency graph from the given distributions.\n\n    :parameter dists: a list of distributions\n    :type dists: list of :class:`distutils2.database.InstalledDistribution` and\n                 :class:`distutils2.database.EggInfoDistribution` instances\n    :rtype: a :class:`DependencyGraph` instance", "id": "f17277:m0"}
{"signature": "def __init__(self, metadata):", "body": "self.metadata = metadata<EOL>self.name = metadata.name<EOL>self.key = self.name.lower()    <EOL>self.version = metadata.version<EOL>self.locator = None<EOL>self.digest = None<EOL>self.extras = None      <EOL>self.context = None     <EOL>self.download_urls = set()<EOL>self.digests = {}<EOL>", "docstring": "Initialise an instance.\n:param metadata: The instance of :class:`Metadata` describing this\ndistribution.", "id": "f17277:c2:m0"}
{"signature": "@cached_property<EOL><INDENT>def shared_locations(self):<DEDENT>", "body": "result = {}<EOL>shared_path = os.path.join(self.path, '<STR_LIT>')<EOL>if os.path.isfile(shared_path):<EOL><INDENT>with codecs.open(shared_path, '<STR_LIT:r>', encoding='<STR_LIT:utf-8>') as f:<EOL><INDENT>lines = f.read().splitlines()<EOL><DEDENT>for line in lines:<EOL><INDENT>key, value = line.split('<STR_LIT:=>', <NUM_LIT:1>)<EOL>if key == '<STR_LIT>':<EOL><INDENT>result.setdefault(key, []).append(value)<EOL><DEDENT>else:<EOL><INDENT>result[key] = value<EOL><DEDENT><DEDENT><DEDENT>return result<EOL>", "docstring": "A dictionary of shared locations whose keys are in the set 'prefix',\n'purelib', 'platlib', 'scripts', 'headers', 'data' and 'namespace'.\nThe corresponding value is the absolute path of that category for\nthis distribution, and takes into account any paths selected by the\nuser at installation time (e.g. via command-line arguments). In the\ncase of the 'namespace' key, this would be a list of absolute paths\nfor the roots of namespace packages in this distribution.\n\nThe first time this property is accessed, the relevant information is\nread from the SHARED file in the .dist-info directory.", "id": "f17277:c4:m11"}
{"signature": "def __hash__(self):", "body": "return hash(self.name) + hash(self.version) + hash(self.source_url)<EOL>", "docstring": "Compute hash in a way which matches the equality test.", "id": "f17277:c2:m13"}
{"signature": "def __init__(self, base=None):", "body": "self.base = os.path.abspath(os.path.normpath(base or os.getcwd()))<EOL>self.prefix = self.base + os.sep<EOL>self.allfiles = None<EOL>self.files = set()<EOL>", "docstring": "Initialise an instance.\n\n:param base: The base directory to explore under.", "id": "f17278:c0:m0"}
{"signature": "def process_directive(self, directive):", "body": "<EOL>action, patterns, thedir, dirpattern = self._parse_directive(directive)<EOL>if action == '<STR_LIT>':<EOL><INDENT>for pattern in patterns:<EOL><INDENT>if not self._include_pattern(pattern, anchor=True):<EOL><INDENT>logger.warning('<STR_LIT>', pattern)<EOL><DEDENT><DEDENT><DEDENT>elif action == '<STR_LIT>':<EOL><INDENT>for pattern in patterns:<EOL><INDENT>found = self._exclude_pattern(pattern, anchor=True)<EOL><DEDENT><DEDENT>elif action == '<STR_LIT>':<EOL><INDENT>for pattern in patterns:<EOL><INDENT>if not self._include_pattern(pattern, anchor=False):<EOL><INDENT>logger.warning('<STR_LIT>'<EOL>'<STR_LIT>', pattern)<EOL><DEDENT><DEDENT><DEDENT>elif action == '<STR_LIT>':<EOL><INDENT>for pattern in patterns:<EOL><INDENT>found = self._exclude_pattern(pattern, anchor=False)<EOL><DEDENT><DEDENT>elif action == '<STR_LIT>':<EOL><INDENT>for pattern in patterns:<EOL><INDENT>if not self._include_pattern(pattern, prefix=thedir):<EOL><INDENT>logger.warning('<STR_LIT>'<EOL>'<STR_LIT>', pattern, thedir)<EOL><DEDENT><DEDENT><DEDENT>elif action == '<STR_LIT>':<EOL><INDENT>for pattern in patterns:<EOL><INDENT>found = self._exclude_pattern(pattern, prefix=thedir)<EOL><DEDENT><DEDENT>elif action == '<STR_LIT>':<EOL><INDENT>if not self._include_pattern(None, prefix=dirpattern):<EOL><INDENT>logger.warning('<STR_LIT>',<EOL>dirpattern)<EOL><DEDENT><DEDENT>elif action == '<STR_LIT>':<EOL><INDENT>if not self._exclude_pattern(None, prefix=dirpattern):<EOL><INDENT>logger.warning('<STR_LIT>'<EOL>'<STR_LIT>', dirpattern)<EOL><DEDENT><DEDENT>else:   <EOL><INDENT>raise DistlibException(<EOL>'<STR_LIT>' % action)<EOL><DEDENT>", "docstring": "Process a directive which either adds some files from ``allfiles`` to\n``files``, or removes some files from ``files``.\n\n:param directive: The directive to process. This should be in a format\n             compatible with distutils ``MANIFEST.in`` files:\n\n             http://docs.python.org/distutils/sourcedist.html#commands", "id": "f17278:c0:m6"}
{"signature": "def _exclude_pattern(self, pattern, anchor=True, prefix=None,<EOL>is_regex=False):", "body": "found = False<EOL>pattern_re = self._translate_pattern(pattern, anchor, prefix, is_regex)<EOL>for f in list(self.files):<EOL><INDENT>if pattern_re.search(f):<EOL><INDENT>self.files.remove(f)<EOL>found = True<EOL><DEDENT><DEDENT>return found<EOL>", "docstring": "Remove strings (presumably filenames) from 'files' that match\n        'pattern'.\n\n        Other parameters are the same as for 'include_pattern()', above.\n        The list 'self.files' is modified in place. Return True if files are\n        found.\n\n        This API is public to allow e.g. exclusion of SCM subdirs, e.g. when\n        packaging source distributions", "id": "f17278:c0:m9"}
{"signature": "def unpack_archive(filename, extract_dir=None, format=None):", "body": "if extract_dir is None:<EOL><INDENT>extract_dir = os.getcwd()<EOL><DEDENT>if format is not None:<EOL><INDENT>try:<EOL><INDENT>format_info = _UNPACK_FORMATS[format]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise ValueError(\"<STR_LIT>\".format(format))<EOL><DEDENT>func = format_info[<NUM_LIT:1>]<EOL>func(filename, extract_dir, **dict(format_info[<NUM_LIT:2>]))<EOL><DEDENT>else:<EOL><INDENT>format = _find_unpack_format(filename)<EOL>if format is None:<EOL><INDENT>raise ReadError(\"<STR_LIT>\".format(filename))<EOL><DEDENT>func = _UNPACK_FORMATS[format][<NUM_LIT:1>]<EOL>kwargs = dict(_UNPACK_FORMATS[format][<NUM_LIT:2>])<EOL>func(filename, extract_dir, **kwargs)<EOL><DEDENT>", "docstring": "Unpack an archive.\n\n    `filename` is the name of the archive.\n\n    `extract_dir` is the name of the target directory, where the archive\n    is unpacked. If not provided, the current working directory is used.\n\n    `format` is the archive format: one of \"zip\", \"tar\", or \"gztar\". Or any\n    other registered format. If not provided, unpack_archive will use the\n    filename extension and see if an unpacker was registered for that\n    extension.\n\n    In case none is found, a ValueError is raised.", "id": "f17281:m30"}
{"signature": "def _ensure_directory(path):", "body": "dirname = os.path.dirname(path)<EOL>if not os.path.isdir(dirname):<EOL><INDENT>os.makedirs(dirname)<EOL><DEDENT>", "docstring": "Ensure that the parent directory of `path` exists", "id": "f17281:m26"}
{"signature": "def copyfileobj(fsrc, fdst, length=<NUM_LIT:16>*<NUM_LIT>):", "body": "while <NUM_LIT:1>:<EOL><INDENT>buf = fsrc.read(length)<EOL>if not buf:<EOL><INDENT>break<EOL><DEDENT>fdst.write(buf)<EOL><DEDENT>", "docstring": "copy data from file-like object fsrc to file-like object fdst", "id": "f17281:m0"}
{"signature": "def _make_zipfile(base_name, base_dir, verbose=<NUM_LIT:0>, dry_run=<NUM_LIT:0>, logger=None):", "body": "zip_filename = base_name + \"<STR_LIT>\"<EOL>archive_dir = os.path.dirname(base_name)<EOL>if not os.path.exists(archive_dir):<EOL><INDENT>if logger is not None:<EOL><INDENT>logger.info(\"<STR_LIT>\", archive_dir)<EOL><DEDENT>if not dry_run:<EOL><INDENT>os.makedirs(archive_dir)<EOL><DEDENT><DEDENT>try:<EOL><INDENT>import zipfile<EOL><DEDENT>except ImportError:<EOL><INDENT>zipfile = None<EOL><DEDENT>if zipfile is None:<EOL><INDENT>_call_external_zip(base_dir, zip_filename, verbose, dry_run)<EOL><DEDENT>else:<EOL><INDENT>if logger is not None:<EOL><INDENT>logger.info(\"<STR_LIT>\",<EOL>zip_filename, base_dir)<EOL><DEDENT>if not dry_run:<EOL><INDENT>zip = zipfile.ZipFile(zip_filename, \"<STR_LIT:w>\",<EOL>compression=zipfile.ZIP_DEFLATED)<EOL>for dirpath, dirnames, filenames in os.walk(base_dir):<EOL><INDENT>for name in filenames:<EOL><INDENT>path = os.path.normpath(os.path.join(dirpath, name))<EOL>if os.path.isfile(path):<EOL><INDENT>zip.write(path, path)<EOL>if logger is not None:<EOL><INDENT>logger.info(\"<STR_LIT>\", path)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>zip.close()<EOL><DEDENT><DEDENT>return zip_filename<EOL>", "docstring": "Create a zip file from all the files under 'base_dir'.\n\n    The output zip file will be named 'base_name' + \".zip\".  Uses either the\n    \"zipfile\" Python module (if available) or the InfoZIP \"zip\" utility\n    (if installed and found on the default search path).  If neither tool is\n    available, raises ExecError.  Returns the name of the output zip\n    file.", "id": "f17281:m17"}
{"signature": "def copystat(src, dst):", "body": "st = os.stat(src)<EOL>mode = stat.S_IMODE(st.st_mode)<EOL>if hasattr(os, '<STR_LIT>'):<EOL><INDENT>os.utime(dst, (st.st_atime, st.st_mtime))<EOL><DEDENT>if hasattr(os, '<STR_LIT>'):<EOL><INDENT>os.chmod(dst, mode)<EOL><DEDENT>if hasattr(os, '<STR_LIT>') and hasattr(st, '<STR_LIT>'):<EOL><INDENT>try:<EOL><INDENT>os.chflags(dst, st.st_flags)<EOL><DEDENT>except OSError as why:<EOL><INDENT>if (not hasattr(errno, '<STR_LIT>') or<EOL>why.errno != errno.EOPNOTSUPP):<EOL><INDENT>raise<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Copy all stat info (mode bits, atime, mtime, flags) from src to dst", "id": "f17281:m4"}
{"signature": "def copy(src, dst):", "body": "if os.path.isdir(dst):<EOL><INDENT>dst = os.path.join(dst, os.path.basename(src))<EOL><DEDENT>copyfile(src, dst)<EOL>copymode(src, dst)<EOL>", "docstring": "Copy data and mode bits (\"cp src dst\").\n\n    The destination may be a directory.", "id": "f17281:m5"}
{"signature": "def make_archive(base_name, format, root_dir=None, base_dir=None, verbose=<NUM_LIT:0>,<EOL>dry_run=<NUM_LIT:0>, owner=None, group=None, logger=None):", "body": "save_cwd = os.getcwd()<EOL>if root_dir is not None:<EOL><INDENT>if logger is not None:<EOL><INDENT>logger.debug(\"<STR_LIT>\", root_dir)<EOL><DEDENT>base_name = os.path.abspath(base_name)<EOL>if not dry_run:<EOL><INDENT>os.chdir(root_dir)<EOL><DEDENT><DEDENT>if base_dir is None:<EOL><INDENT>base_dir = os.curdir<EOL><DEDENT>kwargs = {'<STR_LIT>': dry_run, '<STR_LIT>': logger}<EOL>try:<EOL><INDENT>format_info = _ARCHIVE_FORMATS[format]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % format)<EOL><DEDENT>func = format_info[<NUM_LIT:0>]<EOL>for arg, val in format_info[<NUM_LIT:1>]:<EOL><INDENT>kwargs[arg] = val<EOL><DEDENT>if format != '<STR_LIT>':<EOL><INDENT>kwargs['<STR_LIT>'] = owner<EOL>kwargs['<STR_LIT>'] = group<EOL><DEDENT>try:<EOL><INDENT>filename = func(base_name, base_dir, **kwargs)<EOL><DEDENT>finally:<EOL><INDENT>if root_dir is not None:<EOL><INDENT>if logger is not None:<EOL><INDENT>logger.debug(\"<STR_LIT>\", save_cwd)<EOL><DEDENT>os.chdir(save_cwd)<EOL><DEDENT><DEDENT>return filename<EOL>", "docstring": "Create an archive file (eg. zip or tar).\n\n    'base_name' is the name of the file to create, minus any format-specific\n    extension; 'format' is the archive format: one of \"zip\", \"tar\", \"bztar\"\n    or \"gztar\".\n\n    'root_dir' is a directory that will be the root directory of the\n    archive; ie. we typically chdir into 'root_dir' before creating the\n    archive.  'base_dir' is the directory where we start archiving from;\n    ie. 'base_dir' will be the common prefix of all files and\n    directories in the archive.  'root_dir' and 'base_dir' both default\n    to the current directory.  Returns the name of the archive file.\n\n    'owner' and 'group' are used when creating a tar archive. By default,\n    uses the current owner and group.", "id": "f17281:m21"}
{"signature": "def copytree(src, dst, symlinks=False, ignore=None, copy_function=copy2,<EOL>ignore_dangling_symlinks=False):", "body": "names = os.listdir(src)<EOL>if ignore is not None:<EOL><INDENT>ignored_names = ignore(src, names)<EOL><DEDENT>else:<EOL><INDENT>ignored_names = set()<EOL><DEDENT>os.makedirs(dst)<EOL>errors = []<EOL>for name in names:<EOL><INDENT>if name in ignored_names:<EOL><INDENT>continue<EOL><DEDENT>srcname = os.path.join(src, name)<EOL>dstname = os.path.join(dst, name)<EOL>try:<EOL><INDENT>if os.path.islink(srcname):<EOL><INDENT>linkto = os.readlink(srcname)<EOL>if symlinks:<EOL><INDENT>os.symlink(linkto, dstname)<EOL><DEDENT>else:<EOL><INDENT>if not os.path.exists(linkto) and ignore_dangling_symlinks:<EOL><INDENT>continue<EOL><DEDENT>copy_function(srcname, dstname)<EOL><DEDENT><DEDENT>elif os.path.isdir(srcname):<EOL><INDENT>copytree(srcname, dstname, symlinks, ignore, copy_function)<EOL><DEDENT>else:<EOL><INDENT>copy_function(srcname, dstname)<EOL><DEDENT><DEDENT>except Error as err:<EOL><INDENT>errors.extend(err.args[<NUM_LIT:0>])<EOL><DEDENT>except EnvironmentError as why:<EOL><INDENT>errors.append((srcname, dstname, str(why)))<EOL><DEDENT><DEDENT>try:<EOL><INDENT>copystat(src, dst)<EOL><DEDENT>except OSError as why:<EOL><INDENT>if WindowsError is not None and isinstance(why, WindowsError):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>errors.extend((src, dst, str(why)))<EOL><DEDENT><DEDENT>if errors:<EOL><INDENT>raise Error(errors)<EOL><DEDENT>", "docstring": "Recursively copy a directory tree.\n\n    The destination directory must not already exist.\n    If exception(s) occur, an Error is raised with a list of reasons.\n\n    If the optional symlinks flag is true, symbolic links in the\n    source tree result in symbolic links in the destination tree; if\n    it is false, the contents of the files pointed to by symbolic\n    links are copied. If the file pointed by the symlink doesn't\n    exist, an exception will be added in the list of errors raised in\n    an Error exception at the end of the copy process.\n\n    You can set the optional ignore_dangling_symlinks flag to true if you\n    want to silence this exception. Notice that this has no effect on\n    platforms that don't support os.symlink.\n\n    The optional ignore argument is a callable. If given, it\n    is called with the `src` parameter, which is the directory\n    being visited by copytree(), and `names` which is the list of\n    `src` contents, as returned by os.listdir():\n\n        callable(src, names) -> ignored_names\n\n    Since copytree() is called recursively, the callable will be\n    called once for each directory that is copied. It returns a\n    list of names relative to the `src` directory that should\n    not be copied.\n\n    The optional copy_function argument is a callable that will be used\n    to copy each file. It will be called with the source path and the\n    destination path as arguments. By default, copy2() is used, but any\n    function that supports the same signature (like copy()) can be used.", "id": "f17281:m8"}
{"signature": "def copymode(src, dst):", "body": "if hasattr(os, '<STR_LIT>'):<EOL><INDENT>st = os.stat(src)<EOL>mode = stat.S_IMODE(st.st_mode)<EOL>os.chmod(dst, mode)<EOL><DEDENT>", "docstring": "Copy mode bits from src to dst", "id": "f17281:m3"}
{"signature": "def _unpack_zipfile(filename, extract_dir):", "body": "try:<EOL><INDENT>import zipfile<EOL><DEDENT>except ImportError:<EOL><INDENT>raise ReadError('<STR_LIT>')<EOL><DEDENT>if not zipfile.is_zipfile(filename):<EOL><INDENT>raise ReadError(\"<STR_LIT>\" % filename)<EOL><DEDENT>zip = zipfile.ZipFile(filename)<EOL>try:<EOL><INDENT>for info in zip.infolist():<EOL><INDENT>name = info.filename<EOL>if name.startswith('<STR_LIT:/>') or '<STR_LIT:..>' in name:<EOL><INDENT>continue<EOL><DEDENT>target = os.path.join(extract_dir, *name.split('<STR_LIT:/>'))<EOL>if not target:<EOL><INDENT>continue<EOL><DEDENT>_ensure_directory(target)<EOL>if not name.endswith('<STR_LIT:/>'):<EOL><INDENT>data = zip.read(info.filename)<EOL>f = open(target, '<STR_LIT:wb>')<EOL>try:<EOL><INDENT>f.write(data)<EOL><DEDENT>finally:<EOL><INDENT>f.close()<EOL>del data<EOL><DEDENT><DEDENT><DEDENT><DEDENT>finally:<EOL><INDENT>zip.close()<EOL><DEDENT>", "docstring": "Unpack zip `filename` to `extract_dir`", "id": "f17281:m27"}
{"signature": "def get_scheme_names():", "body": "return tuple(sorted(_SCHEMES.sections()))<EOL>", "docstring": "Return a tuple containing the schemes names.", "id": "f17282:m16"}
{"signature": "def _main():", "body": "print('<STR_LIT>' % get_platform())<EOL>print('<STR_LIT>' % get_python_version())<EOL>print('<STR_LIT>' % _get_default_scheme())<EOL>print()<EOL>_print_dict('<STR_LIT>', get_paths())<EOL>print()<EOL>_print_dict('<STR_LIT>', get_config_vars())<EOL>", "docstring": "Display all information sysconfig detains.", "id": "f17282:m25"}
{"signature": "def get_makefile_filename():", "body": "if _PYTHON_BUILD:<EOL><INDENT>return os.path.join(_PROJECT_BASE, \"<STR_LIT>\")<EOL><DEDENT>if hasattr(sys, '<STR_LIT>'):<EOL><INDENT>config_dir_name = '<STR_LIT>' % (_PY_VERSION_SHORT, sys.abiflags)<EOL><DEDENT>else:<EOL><INDENT>config_dir_name = '<STR_LIT>'<EOL><DEDENT>return os.path.join(get_path('<STR_LIT>'), config_dir_name, '<STR_LIT>')<EOL>", "docstring": "Return the path of the Makefile.", "id": "f17282:m11"}
{"signature": "def get_path_names():", "body": "<EOL>return _SCHEMES.options('<STR_LIT>')<EOL>", "docstring": "Return a tuple containing the paths names.", "id": "f17282:m17"}
{"signature": "def parse_config_h(fp, vars=None):", "body": "if vars is None:<EOL><INDENT>vars = {}<EOL><DEDENT>define_rx = re.compile(\"<STR_LIT>\")<EOL>undef_rx = re.compile(\"<STR_LIT>\")<EOL>while True:<EOL><INDENT>line = fp.readline()<EOL>if not line:<EOL><INDENT>break<EOL><DEDENT>m = define_rx.match(line)<EOL>if m:<EOL><INDENT>n, v = m.group(<NUM_LIT:1>, <NUM_LIT:2>)<EOL>try:<EOL><INDENT>v = int(v)<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT>vars[n] = v<EOL><DEDENT>else:<EOL><INDENT>m = undef_rx.match(line)<EOL>if m:<EOL><INDENT>vars[m.group(<NUM_LIT:1>)] = <NUM_LIT:0><EOL><DEDENT><DEDENT><DEDENT>return vars<EOL>", "docstring": "Parse a config.h-style file.\n\n    A dictionary containing name/value pairs is returned.  If an\n    optional dictionary is passed in as the second argument, it is\n    used instead of a new dictionary.", "id": "f17282:m14"}
{"signature": "def _init_posix(vars):", "body": "<EOL>makefile = get_makefile_filename()<EOL>try:<EOL><INDENT>_parse_makefile(makefile, vars)<EOL><DEDENT>except IOError as e:<EOL><INDENT>msg = \"<STR_LIT>\" % makefile<EOL>if hasattr(e, \"<STR_LIT>\"):<EOL><INDENT>msg = msg + \"<STR_LIT>\" % e.strerror<EOL><DEDENT>raise IOError(msg)<EOL><DEDENT>config_h = get_config_h_filename()<EOL>try:<EOL><INDENT>with open(config_h) as f:<EOL><INDENT>parse_config_h(f, vars)<EOL><DEDENT><DEDENT>except IOError as e:<EOL><INDENT>msg = \"<STR_LIT>\" % config_h<EOL>if hasattr(e, \"<STR_LIT>\"):<EOL><INDENT>msg = msg + \"<STR_LIT>\" % e.strerror<EOL><DEDENT>raise IOError(msg)<EOL><DEDENT>if _PYTHON_BUILD:<EOL><INDENT>vars['<STR_LIT>'] = vars['<STR_LIT>']<EOL><DEDENT>", "docstring": "Initialize the module as appropriate for POSIX systems.", "id": "f17282:m12"}
{"signature": "@classmethod<EOL><INDENT>def taropen(cls, name, mode=\"<STR_LIT:r>\", fileobj=None, **kwargs):<DEDENT>", "body": "if len(mode) > <NUM_LIT:1> or mode not in \"<STR_LIT>\":<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return cls(name, mode, fileobj, **kwargs)<EOL>", "docstring": "Open uncompressed tar archive name for reading or writing.", "id": "f17283:c18:m2"}
{"signature": "def makedir(self, tarinfo, targetpath):", "body": "try:<EOL><INDENT>os.mkdir(targetpath, <NUM_LIT>)<EOL><DEDENT>except EnvironmentError as e:<EOL><INDENT>if e.errno != errno.EEXIST:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>", "docstring": "Make a directory called targetpath.", "id": "f17283:c18:m17"}
{"signature": "def getmember(self, name):", "body": "tarinfo = self._getmember(name)<EOL>if tarinfo is None:<EOL><INDENT>raise KeyError(\"<STR_LIT>\" % name)<EOL><DEDENT>return tarinfo<EOL>", "docstring": "Return a TarInfo object for member `name'. If `name' can not be\n           found in the archive, KeyError is raised. If a member occurs more\n           than once in the archive, its last occurrence is assumed to be the\n           most up-to-date version.", "id": "f17283:c18:m6"}
{"signature": "def makedev(self, tarinfo, targetpath):", "body": "if not hasattr(os, \"<STR_LIT>\") or not hasattr(os, \"<STR_LIT>\"):<EOL><INDENT>raise ExtractError(\"<STR_LIT>\")<EOL><DEDENT>mode = tarinfo.mode<EOL>if tarinfo.isblk():<EOL><INDENT>mode |= stat.S_IFBLK<EOL><DEDENT>else:<EOL><INDENT>mode |= stat.S_IFCHR<EOL><DEDENT>os.mknod(targetpath, mode,<EOL>os.makedev(tarinfo.devmajor, tarinfo.devminor))<EOL>", "docstring": "Make a character or block device called targetpath.", "id": "f17283:c18:m21"}
{"signature": "def close(self):", "body": "self.closed = True<EOL>", "docstring": "Close the file object.", "id": "f17283:c16:m9"}
{"signature": "@classmethod<EOL><INDENT>def fromtarfile(cls, tarfile):<DEDENT>", "body": "buf = tarfile.fileobj.read(BLOCKSIZE)<EOL>obj = cls.frombuf(buf, tarfile.encoding, tarfile.errors)<EOL>obj.offset = tarfile.fileobj.tell() - BLOCKSIZE<EOL>return obj._proc_member(tarfile)<EOL>", "docstring": "Return the next TarInfo object from TarFile object\n           tarfile.", "id": "f17283:c17:m18"}
{"signature": "def _proc_member(self, tarfile):", "body": "if self.type in (GNUTYPE_LONGNAME, GNUTYPE_LONGLINK):<EOL><INDENT>return self._proc_gnulong(tarfile)<EOL><DEDENT>elif self.type == GNUTYPE_SPARSE:<EOL><INDENT>return self._proc_sparse(tarfile)<EOL><DEDENT>elif self.type in (XHDTYPE, XGLTYPE, SOLARIS_XHDTYPE):<EOL><INDENT>return self._proc_pax(tarfile)<EOL><DEDENT>else:<EOL><INDENT>return self._proc_builtin(tarfile)<EOL><DEDENT>", "docstring": "Choose the right processing method depending on\n           the type and call it.", "id": "f17283:c17:m19"}
{"signature": "def tobuf(self, format=DEFAULT_FORMAT, encoding=ENCODING, errors=\"<STR_LIT>\"):", "body": "info = self.get_info()<EOL>if format == USTAR_FORMAT:<EOL><INDENT>return self.create_ustar_header(info, encoding, errors)<EOL><DEDENT>elif format == GNU_FORMAT:<EOL><INDENT>return self.create_gnu_header(info, encoding, errors)<EOL><DEDENT>elif format == PAX_FORMAT:<EOL><INDENT>return self.create_pax_header(info, encoding)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Return a tar header as a string of 512 byte blocks.", "id": "f17283:c17:m7"}
{"signature": "def _proc_pax(self, tarfile):", "body": "<EOL>buf = tarfile.fileobj.read(self._block(self.size))<EOL>if self.type == XGLTYPE:<EOL><INDENT>pax_headers = tarfile.pax_headers<EOL><DEDENT>else:<EOL><INDENT>pax_headers = tarfile.pax_headers.copy()<EOL><DEDENT>match = re.search(br\"<STR_LIT>\", buf)<EOL>if match is not None:<EOL><INDENT>pax_headers[\"<STR_LIT>\"] = match.group(<NUM_LIT:1>).decode(\"<STR_LIT:utf8>\")<EOL><DEDENT>hdrcharset = pax_headers.get(\"<STR_LIT>\")<EOL>if hdrcharset == \"<STR_LIT>\":<EOL><INDENT>encoding = tarfile.encoding<EOL><DEDENT>else:<EOL><INDENT>encoding = \"<STR_LIT:utf8>\"<EOL><DEDENT>regex = re.compile(br\"<STR_LIT>\")<EOL>pos = <NUM_LIT:0><EOL>while True:<EOL><INDENT>match = regex.match(buf, pos)<EOL>if not match:<EOL><INDENT>break<EOL><DEDENT>length, keyword = match.groups()<EOL>length = int(length)<EOL>value = buf[match.end(<NUM_LIT:2>) + <NUM_LIT:1>:match.start(<NUM_LIT:1>) + length - <NUM_LIT:1>]<EOL>keyword = self._decode_pax_field(keyword, \"<STR_LIT:utf8>\", \"<STR_LIT:utf8>\",<EOL>tarfile.errors)<EOL>if keyword in PAX_NAME_FIELDS:<EOL><INDENT>value = self._decode_pax_field(value, encoding, tarfile.encoding,<EOL>tarfile.errors)<EOL><DEDENT>else:<EOL><INDENT>value = self._decode_pax_field(value, \"<STR_LIT:utf8>\", \"<STR_LIT:utf8>\",<EOL>tarfile.errors)<EOL><DEDENT>pax_headers[keyword] = value<EOL>pos += length<EOL><DEDENT>try:<EOL><INDENT>next = self.fromtarfile(tarfile)<EOL><DEDENT>except HeaderError:<EOL><INDENT>raise SubsequentHeaderError(\"<STR_LIT>\")<EOL><DEDENT>if \"<STR_LIT>\" in pax_headers:<EOL><INDENT>self._proc_gnusparse_01(next, pax_headers)<EOL><DEDENT>elif \"<STR_LIT>\" in pax_headers:<EOL><INDENT>self._proc_gnusparse_00(next, pax_headers, buf)<EOL><DEDENT>elif pax_headers.get(\"<STR_LIT>\") == \"<STR_LIT:1>\" and pax_headers.get(\"<STR_LIT>\") == \"<STR_LIT:0>\":<EOL><INDENT>self._proc_gnusparse_10(next, pax_headers, tarfile)<EOL><DEDENT>if self.type in (XHDTYPE, SOLARIS_XHDTYPE):<EOL><INDENT>next._apply_pax_info(pax_headers, tarfile.encoding, tarfile.errors)<EOL>next.offset = self.offset<EOL>if \"<STR_LIT:size>\" in pax_headers:<EOL><INDENT>offset = next.offset_data<EOL>if next.isreg() or next.type not in SUPPORTED_TYPES:<EOL><INDENT>offset += next._block(next.size)<EOL><DEDENT>tarfile.offset = offset<EOL><DEDENT><DEDENT>return next<EOL>", "docstring": "Process an extended or global header as described in\n           POSIX.1-2008.", "id": "f17283:c17:m23"}
{"signature": "def _extract_member(self, tarinfo, targetpath, set_attrs=True):", "body": "<EOL>targetpath = targetpath.rstrip(\"<STR_LIT:/>\")<EOL>targetpath = targetpath.replace(\"<STR_LIT:/>\", os.sep)<EOL>upperdirs = os.path.dirname(targetpath)<EOL>if upperdirs and not os.path.exists(upperdirs):<EOL><INDENT>os.makedirs(upperdirs)<EOL><DEDENT>if tarinfo.islnk() or tarinfo.issym():<EOL><INDENT>self._dbg(<NUM_LIT:1>, \"<STR_LIT>\" % (tarinfo.name, tarinfo.linkname))<EOL><DEDENT>else:<EOL><INDENT>self._dbg(<NUM_LIT:1>, tarinfo.name)<EOL><DEDENT>if tarinfo.isreg():<EOL><INDENT>self.makefile(tarinfo, targetpath)<EOL><DEDENT>elif tarinfo.isdir():<EOL><INDENT>self.makedir(tarinfo, targetpath)<EOL><DEDENT>elif tarinfo.isfifo():<EOL><INDENT>self.makefifo(tarinfo, targetpath)<EOL><DEDENT>elif tarinfo.ischr() or tarinfo.isblk():<EOL><INDENT>self.makedev(tarinfo, targetpath)<EOL><DEDENT>elif tarinfo.islnk() or tarinfo.issym():<EOL><INDENT>self.makelink(tarinfo, targetpath)<EOL><DEDENT>elif tarinfo.type not in SUPPORTED_TYPES:<EOL><INDENT>self.makeunknown(tarinfo, targetpath)<EOL><DEDENT>else:<EOL><INDENT>self.makefile(tarinfo, targetpath)<EOL><DEDENT>if set_attrs:<EOL><INDENT>self.chown(tarinfo, targetpath)<EOL>if not tarinfo.issym():<EOL><INDENT>self.chmod(tarinfo, targetpath)<EOL>self.utime(tarinfo, targetpath)<EOL><DEDENT><DEDENT>", "docstring": "Extract the TarInfo object tarinfo to a physical\n           file called targetpath.", "id": "f17283:c18:m16"}
{"signature": "def create_ustar_header(self, info, encoding, errors):", "body": "info[\"<STR_LIT>\"] = POSIX_MAGIC<EOL>if len(info[\"<STR_LIT>\"]) > LENGTH_LINK:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if len(info[\"<STR_LIT:name>\"]) > LENGTH_NAME:<EOL><INDENT>info[\"<STR_LIT>\"], info[\"<STR_LIT:name>\"] = self._posix_split_name(info[\"<STR_LIT:name>\"])<EOL><DEDENT>return self._create_header(info, USTAR_FORMAT, encoding, errors)<EOL>", "docstring": "Return the object as a ustar header block.", "id": "f17283:c17:m8"}
{"signature": "def _proc_sparse(self, tarfile):", "body": "<EOL>structs, isextended, origsize = self._sparse_structs<EOL>del self._sparse_structs<EOL>while isextended:<EOL><INDENT>buf = tarfile.fileobj.read(BLOCKSIZE)<EOL>pos = <NUM_LIT:0><EOL>for i in range(<NUM_LIT>):<EOL><INDENT>try:<EOL><INDENT>offset = nti(buf[pos:pos + <NUM_LIT:12>])<EOL>numbytes = nti(buf[pos + <NUM_LIT:12>:pos + <NUM_LIT>])<EOL><DEDENT>except ValueError:<EOL><INDENT>break<EOL><DEDENT>if offset and numbytes:<EOL><INDENT>structs.append((offset, numbytes))<EOL><DEDENT>pos += <NUM_LIT><EOL><DEDENT>isextended = bool(buf[<NUM_LIT>])<EOL><DEDENT>self.sparse = structs<EOL>self.offset_data = tarfile.fileobj.tell()<EOL>tarfile.offset = self.offset_data + self._block(self.size)<EOL>self.size = origsize<EOL>return self<EOL>", "docstring": "Process a GNU sparse header plus extra headers.", "id": "f17283:c17:m22"}
{"signature": "def create_pax_header(self, info, encoding):", "body": "info[\"<STR_LIT>\"] = POSIX_MAGIC<EOL>pax_headers = self.pax_headers.copy()<EOL>for name, hname, length in (<EOL>(\"<STR_LIT:name>\", \"<STR_LIT:path>\", LENGTH_NAME), (\"<STR_LIT>\", \"<STR_LIT>\", LENGTH_LINK),<EOL>(\"<STR_LIT>\", \"<STR_LIT>\", <NUM_LIT:32>), (\"<STR_LIT>\", \"<STR_LIT>\", <NUM_LIT:32>)):<EOL><INDENT>if hname in pax_headers:<EOL><INDENT>continue<EOL><DEDENT>try:<EOL><INDENT>info[name].encode(\"<STR_LIT:ascii>\", \"<STR_LIT:strict>\")<EOL><DEDENT>except UnicodeEncodeError:<EOL><INDENT>pax_headers[hname] = info[name]<EOL>continue<EOL><DEDENT>if len(info[name]) > length:<EOL><INDENT>pax_headers[hname] = info[name]<EOL><DEDENT><DEDENT>for name, digits in ((\"<STR_LIT>\", <NUM_LIT:8>), (\"<STR_LIT>\", <NUM_LIT:8>), (\"<STR_LIT:size>\", <NUM_LIT:12>), (\"<STR_LIT>\", <NUM_LIT:12>)):<EOL><INDENT>if name in pax_headers:<EOL><INDENT>info[name] = <NUM_LIT:0><EOL>continue<EOL><DEDENT>val = info[name]<EOL>if not <NUM_LIT:0> <= val < <NUM_LIT:8> ** (digits - <NUM_LIT:1>) or isinstance(val, float):<EOL><INDENT>pax_headers[name] = str(val)<EOL>info[name] = <NUM_LIT:0><EOL><DEDENT><DEDENT>if pax_headers:<EOL><INDENT>buf = self._create_pax_generic_header(pax_headers, XHDTYPE, encoding)<EOL><DEDENT>else:<EOL><INDENT>buf = b\"<STR_LIT>\"<EOL><DEDENT>return buf + self._create_header(info, USTAR_FORMAT, \"<STR_LIT:ascii>\", \"<STR_LIT:replace>\")<EOL>", "docstring": "Return the object as a ustar header block. If it cannot be\n           represented this way, prepend a pax extended header sequence\n           with supplement information.", "id": "f17283:c17:m10"}
{"signature": "def gettarinfo(self, name=None, arcname=None, fileobj=None):", "body": "self._check(\"<STR_LIT>\")<EOL>if fileobj is not None:<EOL><INDENT>name = fileobj.name<EOL><DEDENT>if arcname is None:<EOL><INDENT>arcname = name<EOL><DEDENT>drv, arcname = os.path.splitdrive(arcname)<EOL>arcname = arcname.replace(os.sep, \"<STR_LIT:/>\")<EOL>arcname = arcname.lstrip(\"<STR_LIT:/>\")<EOL>tarinfo = self.tarinfo()<EOL>tarinfo.tarfile = self<EOL>if fileobj is None:<EOL><INDENT>if hasattr(os, \"<STR_LIT>\") and not self.dereference:<EOL><INDENT>statres = os.lstat(name)<EOL><DEDENT>else:<EOL><INDENT>statres = os.stat(name)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>statres = os.fstat(fileobj.fileno())<EOL><DEDENT>linkname = \"<STR_LIT>\"<EOL>stmd = statres.st_mode<EOL>if stat.S_ISREG(stmd):<EOL><INDENT>inode = (statres.st_ino, statres.st_dev)<EOL>if not self.dereference and statres.st_nlink > <NUM_LIT:1> andinode in self.inodes and arcname != self.inodes[inode]:<EOL><INDENT>type = LNKTYPE<EOL>linkname = self.inodes[inode]<EOL><DEDENT>else:<EOL><INDENT>type = REGTYPE<EOL>if inode[<NUM_LIT:0>]:<EOL><INDENT>self.inodes[inode] = arcname<EOL><DEDENT><DEDENT><DEDENT>elif stat.S_ISDIR(stmd):<EOL><INDENT>type = DIRTYPE<EOL><DEDENT>elif stat.S_ISFIFO(stmd):<EOL><INDENT>type = FIFOTYPE<EOL><DEDENT>elif stat.S_ISLNK(stmd):<EOL><INDENT>type = SYMTYPE<EOL>linkname = os.readlink(name)<EOL><DEDENT>elif stat.S_ISCHR(stmd):<EOL><INDENT>type = CHRTYPE<EOL><DEDENT>elif stat.S_ISBLK(stmd):<EOL><INDENT>type = BLKTYPE<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>tarinfo.name = arcname<EOL>tarinfo.mode = stmd<EOL>tarinfo.uid = statres.st_uid<EOL>tarinfo.gid = statres.st_gid<EOL>if type == REGTYPE:<EOL><INDENT>tarinfo.size = statres.st_size<EOL><DEDENT>else:<EOL><INDENT>tarinfo.size = <NUM_LIT:0><EOL><DEDENT>tarinfo.mtime = statres.st_mtime<EOL>tarinfo.type = type<EOL>tarinfo.linkname = linkname<EOL>if pwd:<EOL><INDENT>try:<EOL><INDENT>tarinfo.uname = pwd.getpwuid(tarinfo.uid)[<NUM_LIT:0>]<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if grp:<EOL><INDENT>try:<EOL><INDENT>tarinfo.gname = grp.getgrgid(tarinfo.gid)[<NUM_LIT:0>]<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if type in (CHRTYPE, BLKTYPE):<EOL><INDENT>if hasattr(os, \"<STR_LIT>\") and hasattr(os, \"<STR_LIT>\"):<EOL><INDENT>tarinfo.devmajor = os.major(statres.st_rdev)<EOL>tarinfo.devminor = os.minor(statres.st_rdev)<EOL><DEDENT><DEDENT>return tarinfo<EOL>", "docstring": "Create a TarInfo object for either the file `name' or the file\n           object `fileobj' (using os.fstat on its file descriptor). You can\n           modify some of the TarInfo's attributes before you add it using\n           addfile(). If given, `arcname' specifies an alternative name for the\n           file in the archive.", "id": "f17283:c18:m9"}
{"signature": "def _read(self, size):", "body": "if self.comptype == \"<STR_LIT>\":<EOL><INDENT>return self.__read(size)<EOL><DEDENT>c = len(self.dbuf)<EOL>while c < size:<EOL><INDENT>buf = self.__read(self.bufsize)<EOL>if not buf:<EOL><INDENT>break<EOL><DEDENT>try:<EOL><INDENT>buf = self.cmp.decompress(buf)<EOL><DEDENT>except IOError:<EOL><INDENT>raise ReadError(\"<STR_LIT>\")<EOL><DEDENT>self.dbuf += buf<EOL>c += len(buf)<EOL><DEDENT>buf = self.dbuf[:size]<EOL>self.dbuf = self.dbuf[size:]<EOL>return buf<EOL>", "docstring": "Return size bytes from the stream.", "id": "f17283:c12:m10"}
{"signature": "def _dbg(self, level, msg):", "body": "if level <= self.debug:<EOL><INDENT>print(msg, file=sys.stderr)<EOL><DEDENT>", "docstring": "Write debugging output to sys.stderr.", "id": "f17283:c18:m32"}
{"signature": "def close(self):", "body": "if self.closed:<EOL><INDENT>return<EOL><DEDENT>if self.mode == \"<STR_LIT:w>\" and self.comptype != \"<STR_LIT>\":<EOL><INDENT>self.buf += self.cmp.flush()<EOL><DEDENT>if self.mode == \"<STR_LIT:w>\" and self.buf:<EOL><INDENT>self.fileobj.write(self.buf)<EOL>self.buf = b\"<STR_LIT>\"<EOL>if self.comptype == \"<STR_LIT>\":<EOL><INDENT>self.fileobj.write(struct.pack(\"<STR_LIT>\", self.crc & <NUM_LIT>))<EOL>self.fileobj.write(struct.pack(\"<STR_LIT>\", self.pos & <NUM_LIT>))<EOL><DEDENT><DEDENT>if not self._extfileobj:<EOL><INDENT>self.fileobj.close()<EOL><DEDENT>self.closed = True<EOL>", "docstring": "Close the _Stream object. No operation should be\n           done on it afterwards.", "id": "f17283:c12:m5"}
{"signature": "def read(self, size=None):", "body": "if self.closed:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>buf = b\"<STR_LIT>\"<EOL>if self.buffer:<EOL><INDENT>if size is None:<EOL><INDENT>buf = self.buffer<EOL>self.buffer = b\"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>buf = self.buffer[:size]<EOL>self.buffer = self.buffer[size:]<EOL><DEDENT><DEDENT>if size is None:<EOL><INDENT>buf += self.fileobj.read()<EOL><DEDENT>else:<EOL><INDENT>buf += self.fileobj.read(size - len(buf))<EOL><DEDENT>self.position += len(buf)<EOL>return buf<EOL>", "docstring": "Read at most size bytes from the file. If size is not\n           present or None, read all data until EOF is reached.", "id": "f17283:c16:m4"}
{"signature": "def seek(self, pos=<NUM_LIT:0>):", "body": "if pos - self.pos >= <NUM_LIT:0>:<EOL><INDENT>blocks, remainder = divmod(pos - self.pos, self.bufsize)<EOL>for i in range(blocks):<EOL><INDENT>self.read(self.bufsize)<EOL><DEDENT>self.read(remainder)<EOL><DEDENT>else:<EOL><INDENT>raise StreamError(\"<STR_LIT>\")<EOL><DEDENT>return self.pos<EOL>", "docstring": "Set the stream's file pointer to pos. Negative seeking\n           is forbidden.", "id": "f17283:c12:m8"}
{"signature": "def extractall(self, path=\"<STR_LIT:.>\", members=None):", "body": "directories = []<EOL>if members is None:<EOL><INDENT>members = self<EOL><DEDENT>for tarinfo in members:<EOL><INDENT>if tarinfo.isdir():<EOL><INDENT>directories.append(tarinfo)<EOL>tarinfo = copy.copy(tarinfo)<EOL>tarinfo.mode = <NUM_LIT><EOL><DEDENT>self.extract(tarinfo, path, set_attrs=not tarinfo.isdir())<EOL><DEDENT>directories.sort(key=lambda a: a.name)<EOL>directories.reverse()<EOL>for tarinfo in directories:<EOL><INDENT>dirpath = os.path.join(path, tarinfo.name)<EOL>try:<EOL><INDENT>self.chown(tarinfo, dirpath)<EOL>self.utime(tarinfo, dirpath)<EOL>self.chmod(tarinfo, dirpath)<EOL><DEDENT>except ExtractError as e:<EOL><INDENT>if self.errorlevel > <NUM_LIT:1>:<EOL><INDENT>raise<EOL><DEDENT>else:<EOL><INDENT>self._dbg(<NUM_LIT:1>, \"<STR_LIT>\" % e)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Extract all members from the archive to the current working\n           directory and set owner, modification time and permissions on\n           directories afterwards. `path' specifies a different directory\n           to extract to. `members' is optional and must be a subset of the\n           list returned by getmembers().", "id": "f17283:c18:m13"}
{"signature": "def tell(self):", "body": "return self.position<EOL>", "docstring": "Return the current file position.", "id": "f17283:c15:m2"}
{"signature": "def addfile(self, tarinfo, fileobj=None):", "body": "self._check(\"<STR_LIT>\")<EOL>tarinfo = copy.copy(tarinfo)<EOL>buf = tarinfo.tobuf(self.format, self.encoding, self.errors)<EOL>self.fileobj.write(buf)<EOL>self.offset += len(buf)<EOL>if fileobj is not None:<EOL><INDENT>copyfileobj(fileobj, self.fileobj, tarinfo.size)<EOL>blocks, remainder = divmod(tarinfo.size, BLOCKSIZE)<EOL>if remainder > <NUM_LIT:0>:<EOL><INDENT>self.fileobj.write(NUL * (BLOCKSIZE - remainder))<EOL>blocks += <NUM_LIT:1><EOL><DEDENT>self.offset += blocks * BLOCKSIZE<EOL><DEDENT>self.members.append(tarinfo)<EOL>", "docstring": "Add the TarInfo object `tarinfo' to the archive. If `fileobj' is\n           given, tarinfo.size bytes are read from it and added to the archive.\n           You can create TarInfo objects using gettarinfo().\n           On Windows platforms, `fileobj' should always be opened with mode\n           'rb' to avoid irritation about the file size.", "id": "f17283:c18:m12"}
{"signature": "def add(self, name, arcname=None, recursive=True, exclude=None, filter=None):", "body": "self._check(\"<STR_LIT>\")<EOL>if arcname is None:<EOL><INDENT>arcname = name<EOL><DEDENT>if exclude is not None:<EOL><INDENT>import warnings<EOL>warnings.warn(\"<STR_LIT>\",<EOL>DeprecationWarning, <NUM_LIT:2>)<EOL>if exclude(name):<EOL><INDENT>self._dbg(<NUM_LIT:2>, \"<STR_LIT>\" % name)<EOL>return<EOL><DEDENT><DEDENT>if self.name is not None and os.path.abspath(name) == self.name:<EOL><INDENT>self._dbg(<NUM_LIT:2>, \"<STR_LIT>\" % name)<EOL>return<EOL><DEDENT>self._dbg(<NUM_LIT:1>, name)<EOL>tarinfo = self.gettarinfo(name, arcname)<EOL>if tarinfo is None:<EOL><INDENT>self._dbg(<NUM_LIT:1>, \"<STR_LIT>\" % name)<EOL>return<EOL><DEDENT>if filter is not None:<EOL><INDENT>tarinfo = filter(tarinfo)<EOL>if tarinfo is None:<EOL><INDENT>self._dbg(<NUM_LIT:2>, \"<STR_LIT>\" % name)<EOL>return<EOL><DEDENT><DEDENT>if tarinfo.isreg():<EOL><INDENT>f = bltn_open(name, \"<STR_LIT:rb>\")<EOL>self.addfile(tarinfo, f)<EOL>f.close()<EOL><DEDENT>elif tarinfo.isdir():<EOL><INDENT>self.addfile(tarinfo)<EOL>if recursive:<EOL><INDENT>for f in os.listdir(name):<EOL><INDENT>self.add(os.path.join(name, f), os.path.join(arcname, f),<EOL>recursive, exclude, filter=filter)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>self.addfile(tarinfo)<EOL><DEDENT>", "docstring": "Add the file `name' to the archive. `name' may be any type of file\n           (directory, fifo, symbolic link, etc.). If given, `arcname'\n           specifies an alternative name for the file in the archive.\n           Directories are added recursively by default. This can be avoided by\n           setting `recursive' to False. `exclude' is a function that should\n           return True for each filename to be excluded. `filter' is a function\n           that expects a TarInfo object argument and returns the changed\n           TarInfo object, if it returns None the TarInfo object will be\n           excluded from the archive.", "id": "f17283:c18:m11"}
{"signature": "def tell(self):", "body": "return self.pos<EOL>", "docstring": "Return the stream's file pointer position.", "id": "f17283:c12:m7"}
{"signature": "def getnames(self):", "body": "return [tarinfo.name for tarinfo in self.getmembers()]<EOL>", "docstring": "Return the members of the archive as a list of their names. It has\n           the same order as the list returned by getmembers().", "id": "f17283:c18:m8"}
{"signature": "def __exit__(self, *_exc):", "body": "self.release()<EOL>", "docstring": "Context manager support.", "id": "f17290:c8:m7"}
{"signature": "def __enter__(self):", "body": "self.acquire()<EOL>return self<EOL>", "docstring": "Context manager support.", "id": "f17290:c8:m6"}
{"signature": "def MkdirFileLock(*args, **kwds):", "body": "from . import mkdirlockfile<EOL>return _fl_helper(mkdirlockfile.MkdirLockFile, \"<STR_LIT>\",<EOL>*args, **kwds)<EOL>", "docstring": "Factory function provided for backwards compatibility.\n\n    Do not use in new code.  Instead, import MkdirLockFile from the\n    lockfile.mkdirlockfile module.", "id": "f17290:m2"}
{"signature": "def LinkFileLock(*args, **kwds):", "body": "from . import linklockfile<EOL>return _fl_helper(linklockfile.LinkLockFile, \"<STR_LIT>\",<EOL>*args, **kwds)<EOL>", "docstring": "Factory function provided for backwards compatibility.\n\n    Do not use in new code.  Instead, import LinkLockFile from the\n    lockfile.linklockfile module.", "id": "f17290:m1"}
{"signature": "def read_pid_from_pidfile(pidfile_path):", "body": "pid = None<EOL>try:<EOL><INDENT>pidfile = open(pidfile_path, '<STR_LIT:r>')<EOL><DEDENT>except IOError:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>line = pidfile.readline().strip()<EOL>try:<EOL><INDENT>pid = int(line)<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT>pidfile.close()<EOL><DEDENT>return pid<EOL>", "docstring": "Read the PID recorded in the named PID file.\n\n        Read and return the numeric PID recorded as text in the named\n        PID file. If the PID file cannot be read, or if the content is\n        not a valid PID, return ``None``.", "id": "f17291:m0"}
{"signature": "def release(self):", "body": "if not self.is_locked():<EOL><INDENT>raise NotLocked(\"<STR_LIT>\" % self.path)<EOL><DEDENT>if not self.i_am_locking():<EOL><INDENT>raise NotMyLock(\"<STR_LIT>\" % self.path)<EOL><DEDENT>remove_existing_pidfile(self.path)<EOL>", "docstring": "Release the lock.\n\n            Removes the PID file to release the lock, or raises an\n            error if the current process does not hold the lock.", "id": "f17291:c0:m5"}
{"signature": "def is_locked(self):", "body": "return os.path.exists(self.path)<EOL>", "docstring": "Test if the lock is currently held.\n\n            The lock is held if the PID file for this lock exists.", "id": "f17291:c0:m2"}
{"signature": "def parse_cache_control(self, headers):", "body": "retval = {}<EOL>cc_header = '<STR_LIT>'<EOL>if '<STR_LIT>' in headers:<EOL><INDENT>cc_header = '<STR_LIT>'<EOL><DEDENT>if cc_header in headers:<EOL><INDENT>parts = headers[cc_header].split('<STR_LIT:U+002C>')<EOL>parts_with_args = [<EOL>tuple([x.strip().lower() for x in part.split(\"<STR_LIT:=>\", <NUM_LIT:1>)])<EOL>for part in parts if -<NUM_LIT:1> != part.find(\"<STR_LIT:=>\")<EOL>]<EOL>parts_wo_args = [<EOL>(name.strip().lower(), <NUM_LIT:1>)<EOL>for name in parts if -<NUM_LIT:1> == name.find(\"<STR_LIT:=>\")<EOL>]<EOL>retval = dict(parts_with_args + parts_wo_args)<EOL><DEDENT>return retval<EOL>", "docstring": "Parse the cache control headers returning a dictionary with values\nfor the different directives.", "id": "f17294:c0:m3"}
{"signature": "def parse_uri(uri):", "body": "groups = URI.match(uri).groups()<EOL>return (groups[<NUM_LIT:1>], groups[<NUM_LIT:3>], groups[<NUM_LIT:4>], groups[<NUM_LIT:6>], groups[<NUM_LIT:8>])<EOL>", "docstring": "Parses a URI using the regex given in Appendix B of RFC 3986.\n\n        (scheme, authority, path, query, fragment) = parse_uri(uri)", "id": "f17294:m0"}
{"signature": "def send(self, request, **kw):", "body": "if request.method == '<STR_LIT:GET>':<EOL><INDENT>cached_response = self.controller.cached_request(request)<EOL>if cached_response:<EOL><INDENT>return self.build_response(request, cached_response, from_cache=True)<EOL><DEDENT>request.headers.update(self.controller.conditional_headers(request))<EOL><DEDENT>resp = super(CacheControlAdapter, self).send(request, **kw)<EOL>return resp<EOL>", "docstring": "Send a request. Use the request information to see if it\nexists in the cache and cache the response if we need to and can.", "id": "f17296:c0:m1"}
{"signature": "def build_response(self, request, response, from_cache=False):", "body": "if not from_cache and request.method == '<STR_LIT:GET>':<EOL><INDENT>if response.status == <NUM_LIT>:<EOL><INDENT>cached_response = self.controller.update_cached_response(<EOL>request, response<EOL>)<EOL>if cached_response is not response:<EOL><INDENT>from_cache = True<EOL><DEDENT>response.read(decode_content=False)<EOL>response.release_conn()<EOL>response = cached_response<EOL><DEDENT>else:<EOL><INDENT>if self.heuristic:<EOL><INDENT>response = self.heuristic.apply(response)<EOL><DEDENT>response._fp = CallbackFileWrapper(<EOL>response._fp,<EOL>functools.partial(<EOL>self.controller.cache_response,<EOL>request,<EOL>response,<EOL>)<EOL>)<EOL><DEDENT><DEDENT>resp = super(CacheControlAdapter, self).build_response(<EOL>request, response<EOL>)<EOL>if request.method in self.invalidating_methods and resp.ok:<EOL><INDENT>cache_url = self.controller.cache_url(request.url)<EOL>self.cache.delete(cache_url)<EOL><DEDENT>resp.from_cache = from_cache<EOL>return resp<EOL>", "docstring": "Build a response by making a request or using the cache.\n\nThis will end up calling send and returning a potentially\ncached response", "id": "f17296:c0:m2"}
{"signature": "def clear(self):", "body": "for key in self.conn.keys():<EOL><INDENT>self.conn.delete(key)<EOL><DEDENT>", "docstring": "Helper for clearing all the keys in a database. Use with\n        caution!", "id": "f17298:c0:m4"}
{"signature": "def _prefix_from_ip_int(self, ip_int, mask=<NUM_LIT:32>):", "body": "return mask - _count_righthand_zero_bits(ip_int, mask)<EOL>", "docstring": "Return prefix length from the decimal netmask.\n\n        Args:\n            ip_int: An integer, the IP address.\n            mask: The netmask.  Defaults to 32.\n\n        Returns:\n            An integer, the prefix length.", "id": "f17305:c3:m6"}
{"signature": "def __init__(self, address):", "body": "_BaseAddress.__init__(self, address)<EOL>_BaseV6.__init__(self, address)<EOL>if isinstance(address, _compat_int_types):<EOL><INDENT>self._check_int_address(address)<EOL>self._ip = address<EOL>return<EOL><DEDENT>if isinstance(address, bytes):<EOL><INDENT>self._check_packed_address(address, <NUM_LIT:16>)<EOL>bvs = _compat_bytes_to_byte_vals(address)<EOL>self._ip = _compat_int_from_byte_vals(bvs, '<STR_LIT>')<EOL>return<EOL><DEDENT>addr_str = _compat_str(address)<EOL>self._ip = self._ip_int_from_string(addr_str)<EOL>", "docstring": "Instantiate a new IPv6 address object.\n\n        Args:\n            address: A string or integer representing the IP\n\n              Additionally, an integer can be passed, so\n              IPv6Address('2001:db8::') ==\n                IPv6Address(42540766411282592856903984951653826560)\n              or, more generally\n              IPv6Address(int(IPv6Address('2001:db8::'))) ==\n                IPv6Address('2001:db8::')\n\n        Raises:\n            AddressValueError: If address isn't a valid IPv6 address.", "id": "f17305:c11:m0"}
{"signature": "def _parse_octet(self, octet_str):", "body": "if not octet_str:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not self._DECIMAL_DIGITS.issuperset(octet_str):<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValueError(msg % octet_str)<EOL><DEDENT>if len(octet_str) > <NUM_LIT:3>:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValueError(msg % octet_str)<EOL><DEDENT>octet_int = int(octet_str, <NUM_LIT:10>)<EOL>if octet_int > <NUM_LIT:7> and octet_str[<NUM_LIT:0>] == '<STR_LIT:0>':<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValueError(msg % octet_str)<EOL><DEDENT>if octet_int > <NUM_LIT:255>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % octet_int)<EOL><DEDENT>return octet_int<EOL>", "docstring": "Convert a decimal octet into an integer.\n\n        Args:\n            octet_str: A string, the number to parse.\n\n        Returns:\n            The octet as an integer.\n\n        Raises:\n            ValueError: if the octet isn't strictly a decimal from [0..255].", "id": "f17305:c6:m3"}
{"signature": "@property<EOL><INDENT>def compressed(self):<DEDENT>", "body": "return _compat_str(self)<EOL>", "docstring": "Return the shorthand version of the IP address as a string.", "id": "f17305:c3:m1"}
{"signature": "def summarize_address_range(first, last):", "body": "if (not (isinstance(first, _BaseAddress) and<EOL>isinstance(last, _BaseAddress))):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if first.version != last.version:<EOL><INDENT>raise TypeError(\"<STR_LIT>\" %<EOL>(first, last))<EOL><DEDENT>if first > last:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if first.version == <NUM_LIT:4>:<EOL><INDENT>ip = IPv4Network<EOL><DEDENT>elif first.version == <NUM_LIT:6>:<EOL><INDENT>ip = IPv6Network<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>ip_bits = first._max_prefixlen<EOL>first_int = first._ip<EOL>last_int = last._ip<EOL>while first_int <= last_int:<EOL><INDENT>nbits = min(_count_righthand_zero_bits(first_int, ip_bits),<EOL>_compat_bit_length(last_int - first_int + <NUM_LIT:1>) - <NUM_LIT:1>)<EOL>net = ip('<STR_LIT>' % (first, ip_bits - nbits))<EOL>yield net<EOL>first_int += <NUM_LIT:1> << nbits<EOL>if first_int - <NUM_LIT:1> == ip._ALL_ONES:<EOL><INDENT>break<EOL><DEDENT>first = first.__class__(first_int)<EOL><DEDENT>", "docstring": "Summarize a network range given the first and last IP addresses.\n\n    Example:\n        >>> list(summarize_address_range(IPv4Address('192.0.2.0'),\n        ...                              IPv4Address('192.0.2.130')))\n        ...                                #doctest: +NORMALIZE_WHITESPACE\n        [IPv4Network('192.0.2.0/25'), IPv4Network('192.0.2.128/31'),\n         IPv4Network('192.0.2.130/32')]\n\n    Args:\n        first: the first IPv4Address or IPv6Address in the range.\n        last: the last IPv4Address or IPv6Address in the range.\n\n    Returns:\n        An iterator of the summarized IPv(4|6) network objects.\n\n    Raise:\n        TypeError:\n            If the first and last objects are not IP addresses.\n            If the first and last objects are not the same version.\n        ValueError:\n            If the last object is not greater than the first.\n            If the version of the first address is not 4 or 6.", "id": "f17305:m10"}
{"signature": "@property<EOL><INDENT>def is_unspecified(self):<DEDENT>", "body": "return self._ip == <NUM_LIT:0><EOL>", "docstring": "Test if the address is unspecified.\n\n        Returns:\n            A boolean, True if this is the unspecified address as defined in\n            RFC 2373 2.5.2.", "id": "f17305:c11:m7"}
{"signature": "def _parse_hextet(self, hextet_str):", "body": "<EOL>if not self._HEX_DIGITS.issuperset(hextet_str):<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % hextet_str)<EOL><DEDENT>if len(hextet_str) > <NUM_LIT:4>:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValueError(msg % hextet_str)<EOL><DEDENT>return int(hextet_str, <NUM_LIT:16>)<EOL>", "docstring": "Convert an IPv6 hextet string into an integer.\n\n        Args:\n            hextet_str: A string, the number to parse.\n\n        Returns:\n            The hextet as an integer.\n\n        Raises:\n            ValueError: if the input isn't strictly a hex number from\n              [0..FFFF].", "id": "f17305:c10:m2"}
{"signature": "@property<EOL><INDENT>def is_site_local(self):<DEDENT>", "body": "return (self.network_address.is_site_local and<EOL>self.broadcast_address.is_site_local)<EOL>", "docstring": "Test if the address is reserved for site-local.\n\n        Note that the site-local address space has been deprecated by RFC 3879.\n        Use is_private to test if this address is in the space of unique local\n        addresses as defined by RFC 4193.\n\n        Returns:\n            A boolean, True if the address is reserved per RFC 3513 2.5.6.", "id": "f17305:c13:m2"}
{"signature": "def __init__(self, address, strict=True):", "body": "_BaseV4.__init__(self, address)<EOL>_BaseNetwork.__init__(self, address)<EOL>if isinstance(address, bytes):<EOL><INDENT>self.network_address = IPv4Address(address)<EOL>self._prefixlen = self._max_prefixlen<EOL>self.netmask = IPv4Address(self._ALL_ONES)<EOL>return<EOL><DEDENT>if isinstance(address, _compat_int_types):<EOL><INDENT>self.network_address = IPv4Address(address)<EOL>self._prefixlen = self._max_prefixlen<EOL>self.netmask = IPv4Address(self._ALL_ONES)<EOL>return<EOL><DEDENT>addr = _split_optional_netmask(address)<EOL>self.network_address = IPv4Address(self._ip_int_from_string(addr[<NUM_LIT:0>]))<EOL>if len(addr) == <NUM_LIT:2>:<EOL><INDENT>mask = addr[<NUM_LIT:1>].split('<STR_LIT:.>')<EOL>if len(mask) == <NUM_LIT:4>:<EOL><INDENT>if self._is_valid_netmask(addr[<NUM_LIT:1>]):<EOL><INDENT>self.netmask = IPv4Address(self._ip_int_from_string(<EOL>addr[<NUM_LIT:1>]))<EOL><DEDENT>elif self._is_hostmask(addr[<NUM_LIT:1>]):<EOL><INDENT>self.netmask = IPv4Address(<EOL>self._ip_int_from_string(addr[<NUM_LIT:1>]) ^ self._ALL_ONES)<EOL><DEDENT>else:<EOL><INDENT>raise NetmaskValueError('<STR_LIT>'<EOL>% addr[<NUM_LIT:1>])<EOL><DEDENT>self._prefixlen = self._prefix_from_ip_int(int(self.netmask))<EOL><DEDENT>else:<EOL><INDENT>if not self._is_valid_netmask(addr[<NUM_LIT:1>]):<EOL><INDENT>raise NetmaskValueError('<STR_LIT>'<EOL>% addr[<NUM_LIT:1>])<EOL><DEDENT>self._prefixlen = int(addr[<NUM_LIT:1>])<EOL>self.netmask = IPv4Address(self._ip_int_from_prefix(<EOL>self._prefixlen))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self._prefixlen = self._max_prefixlen<EOL>self.netmask = IPv4Address(self._ip_int_from_prefix(<EOL>self._prefixlen))<EOL><DEDENT>if strict:<EOL><INDENT>if (IPv4Address(int(self.network_address) & int(self.netmask)) !=<EOL>self.network_address):<EOL><INDENT>raise ValueError('<STR_LIT>' % self)<EOL><DEDENT><DEDENT>self.network_address = IPv4Address(int(self.network_address) &<EOL>int(self.netmask))<EOL>if self._prefixlen == (self._max_prefixlen - <NUM_LIT:1>):<EOL><INDENT>self.hosts = self.__iter__<EOL><DEDENT>", "docstring": "Instantiate a new IPv4 network object.\n\n        Args:\n            address: A string or integer representing the IP [& network].\n              '192.0.2.0/24'\n              '192.0.2.0/255.255.255.0'\n              '192.0.0.2/0.0.0.255'\n              are all functionally the same in IPv4. Similarly,\n              '192.0.2.1'\n              '192.0.2.1/255.255.255.255'\n              '192.0.2.1/32'\n              are also functionaly equivalent. That is to say, failing to\n              provide a subnetmask will create an object with a mask of /32.\n\n              If the mask (portion after the / in the argument) is given in\n              dotted quad form, it is treated as a netmask if it starts with a\n              non-zero field (e.g. /255.0.0.0 == /8) and as a hostmask if it\n              starts with a zero field (e.g. 0.255.255.255 == /8), with the\n              single exception of an all-zero mask which is treated as a\n              netmask == /0. If no mask is given, a default of /32 is used.\n\n              Additionally, an integer can be passed, so\n              IPv4Network('192.0.2.1') == IPv4Network(3221225985)\n              or, more generally\n              IPv4Interface(int(IPv4Interface('192.0.2.1'))) ==\n                IPv4Interface('192.0.2.1')\n\n        Raises:\n            AddressValueError: If ipaddress isn't a valid IPv4 address.\n            NetmaskValueError: If the netmask isn't valid for\n              an IPv4 address.\n            ValueError: If strict is True and a network address is not\n              supplied.", "id": "f17305:c9:m0"}
{"signature": "@property<EOL><INDENT>def is_loopback(self):<DEDENT>", "body": "return (self.network_address.is_loopback and<EOL>self.broadcast_address.is_loopback)<EOL>", "docstring": "Test if the address is a loopback address.\n\n        Returns:\n            A boolean, True if the address is a loopback address as defined in\n            RFC 2373 2.5.3.", "id": "f17305:c5:m29"}
{"signature": "def _explode_shorthand_ip_string(self):", "body": "if isinstance(self, IPv6Network):<EOL><INDENT>ip_str = _compat_str(self.network_address)<EOL><DEDENT>elif isinstance(self, IPv6Interface):<EOL><INDENT>ip_str = _compat_str(self.ip)<EOL><DEDENT>else:<EOL><INDENT>ip_str = _compat_str(self)<EOL><DEDENT>ip_int = self._ip_int_from_string(ip_str)<EOL>hex_str = '<STR_LIT>' % ip_int<EOL>parts = [hex_str[x:x + <NUM_LIT:4>] for x in range(<NUM_LIT:0>, <NUM_LIT:32>, <NUM_LIT:4>)]<EOL>if isinstance(self, (_BaseNetwork, IPv6Interface)):<EOL><INDENT>return '<STR_LIT>' % ('<STR_LIT::>'.join(parts), self._prefixlen)<EOL><DEDENT>return '<STR_LIT::>'.join(parts)<EOL>", "docstring": "Expand a shortened IPv6 address.\n\n        Args:\n            ip_str: A string, the IPv6 address.\n\n        Returns:\n            A string, the expanded IPv6 address.", "id": "f17305:c10:m5"}
{"signature": "def collapse_addresses(addresses):", "body": "i = <NUM_LIT:0><EOL>addrs = []<EOL>ips = []<EOL>nets = []<EOL>for ip in addresses:<EOL><INDENT>if isinstance(ip, _BaseAddress):<EOL><INDENT>if ips and ips[-<NUM_LIT:1>]._version != ip._version:<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % (<EOL>ip, ips[-<NUM_LIT:1>]))<EOL><DEDENT>ips.append(ip)<EOL><DEDENT>elif ip._prefixlen == ip._max_prefixlen:<EOL><INDENT>if ips and ips[-<NUM_LIT:1>]._version != ip._version:<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % (<EOL>ip, ips[-<NUM_LIT:1>]))<EOL><DEDENT>try:<EOL><INDENT>ips.append(ip.ip)<EOL><DEDENT>except AttributeError:<EOL><INDENT>ips.append(ip.network_address)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if nets and nets[-<NUM_LIT:1>]._version != ip._version:<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % (<EOL>ip, nets[-<NUM_LIT:1>]))<EOL><DEDENT>nets.append(ip)<EOL><DEDENT><DEDENT>ips = sorted(set(ips))<EOL>nets = sorted(set(nets))<EOL>while i < len(ips):<EOL><INDENT>(first, last) = _find_address_range(ips[i:])<EOL>i = ips.index(last) + <NUM_LIT:1><EOL>addrs.extend(summarize_address_range(first, last))<EOL><DEDENT>return iter(_collapse_addresses_recursive(sorted(<EOL>addrs + nets, key=_BaseNetwork._get_networks_key)))<EOL>", "docstring": "Collapse a list of IP objects.\n\n    Example:\n        collapse_addresses([IPv4Network('192.0.2.0/25'),\n                            IPv4Network('192.0.2.128/25')]) ->\n                           [IPv4Network('192.0.2.0/24')]\n\n    Args:\n        addresses: An iterator of IPv4Network or IPv6Network objects.\n\n    Returns:\n        An iterator of the collapsed IPv(4|6)Network objects.\n\n    Raises:\n        TypeError: If passed a list of mixed version objects.", "id": "f17305:m12"}
{"signature": "def _is_valid_netmask(self, prefixlen):", "body": "try:<EOL><INDENT>prefixlen = int(prefixlen)<EOL><DEDENT>except ValueError:<EOL><INDENT>return False<EOL><DEDENT>return <NUM_LIT:0> <= prefixlen <= self._max_prefixlen<EOL>", "docstring": "Verify that the netmask/prefixlen is valid.\n\n        Args:\n            prefixlen: A string, the netmask in prefix length format.\n\n        Returns:\n            A boolean, True if the prefix represents a valid IPv6\n            netmask.", "id": "f17305:c13:m1"}
{"signature": "def _format_option_strings(self, option, mvarfmt='<STR_LIT>', optsep='<STR_LIT:U+002CU+0020>'):", "body": "opts = []<EOL>if option._short_opts:<EOL><INDENT>opts.append(option._short_opts[<NUM_LIT:0>])<EOL><DEDENT>if option._long_opts:<EOL><INDENT>opts.append(option._long_opts[<NUM_LIT:0>])<EOL><DEDENT>if len(opts) > <NUM_LIT:1>:<EOL><INDENT>opts.insert(<NUM_LIT:1>, optsep)<EOL><DEDENT>if option.takes_value():<EOL><INDENT>metavar = option.metavar or option.dest.lower()<EOL>opts.append(mvarfmt % metavar.lower())<EOL><DEDENT>return '<STR_LIT>'.join(opts)<EOL>", "docstring": "Return a comma-separated list of option strings and metavars.\n\n:param option:  tuple of (short opt, long opt), e.g: ('-f', '--format')\n:param mvarfmt: metavar format string - evaluated as mvarfmt % metavar\n:param optsep:  separator", "id": "f17309:c0:m2"}
{"signature": "def get_environ_vars(self):", "body": "for key, val in os.environ.items():<EOL><INDENT>if _environ_prefix_re.search(key):<EOL><INDENT>yield (_environ_prefix_re.sub(\"<STR_LIT>\", key).lower(), val)<EOL><DEDENT><DEDENT>", "docstring": "Returns a generator with all environmental vars with prefix PIP_", "id": "f17309:c3:m6"}
{"signature": "def update_defaults(self, defaults):", "body": "<EOL>config = {}<EOL>for section in ('<STR_LIT>', self.name):<EOL><INDENT>config.update(<EOL>self.normalize_keys(self.get_config_section(section))<EOL>)<EOL><DEDENT>if not self.isolated:<EOL><INDENT>config.update(self.normalize_keys(self.get_environ_vars()))<EOL><DEDENT>for key, val in config.items():<EOL><INDENT>option = self.get_option(key)<EOL>if option is not None:<EOL><INDENT>if not val:<EOL><INDENT>continue<EOL><DEDENT>if option.action in ('<STR_LIT:store_true>', '<STR_LIT>', '<STR_LIT:count>'):<EOL><INDENT>val = strtobool(val)<EOL><DEDENT>if option.action == '<STR_LIT>':<EOL><INDENT>val = val.split()<EOL>val = [self.check_default(option, key, v) for v in val]<EOL><DEDENT>else:<EOL><INDENT>val = self.check_default(option, key, val)<EOL><DEDENT>defaults[option.dest] = val<EOL><DEDENT><DEDENT>return defaults<EOL>", "docstring": "Updates the given defaults with values from the config files and\n        the environ. Does a little special handling for certain types of\n        options (lists).", "id": "f17309:c3:m3"}
{"signature": "@property<EOL><INDENT>def option_list_all(self):<DEDENT>", "body": "res = self.option_list[:]<EOL>for i in self.option_groups:<EOL><INDENT>res.extend(i.option_list)<EOL><DEDENT>return res<EOL>", "docstring": "Get a list of all options, including those in option groups.", "id": "f17309:c2:m1"}
{"signature": "def get_platform():", "body": "<EOL>return distutils.util.get_platform().replace('<STR_LIT:.>', '<STR_LIT:_>').replace('<STR_LIT:->', '<STR_LIT:_>')<EOL>", "docstring": "Return our platform name 'win32', 'linux_x86_64", "id": "f17311:m2"}
{"signature": "def get_impl_ver():", "body": "return '<STR_LIT>'.join(map(str, sys.version_info[:<NUM_LIT:2>]))<EOL>", "docstring": "Return implementation version.", "id": "f17311:m1"}
{"signature": "def islink(path):", "body": "return False<EOL>", "docstring": "Test for symbolic link.\n    On WindowsNT/95 and OS/2 always returns false", "id": "f17316:m9"}
{"signature": "def expandvars(path):", "body": "if '<STR_LIT:$>' not in path and '<STR_LIT:%>' not in path:<EOL><INDENT>return path<EOL><DEDENT>import string<EOL>varchars = string.ascii_letters + string.digits + '<STR_LIT>'<EOL>if isinstance(path, _unicode):<EOL><INDENT>encoding = sys.getfilesystemencoding()<EOL>def getenv(var):<EOL><INDENT>return os.environ[var.encode(encoding)].decode(encoding)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>def getenv(var):<EOL><INDENT>return os.environ[var]<EOL><DEDENT><DEDENT>res = '<STR_LIT>'<EOL>index = <NUM_LIT:0><EOL>pathlen = len(path)<EOL>while index < pathlen:<EOL><INDENT>c = path[index]<EOL>if c == '<STR_LIT>':   <EOL><INDENT>path = path[index + <NUM_LIT:1>:]<EOL>pathlen = len(path)<EOL>try:<EOL><INDENT>index = path.index('<STR_LIT>')<EOL>res = res + '<STR_LIT>' + path[:index + <NUM_LIT:1>]<EOL><DEDENT>except ValueError:<EOL><INDENT>res = res + c + path<EOL>index = pathlen - <NUM_LIT:1><EOL><DEDENT><DEDENT>elif c == '<STR_LIT:%>':  <EOL><INDENT>if path[index + <NUM_LIT:1>:index + <NUM_LIT:2>] == '<STR_LIT:%>':<EOL><INDENT>res = res + c<EOL>index = index + <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>path = path[index+<NUM_LIT:1>:]<EOL>pathlen = len(path)<EOL>try:<EOL><INDENT>index = path.index('<STR_LIT:%>')<EOL><DEDENT>except ValueError:<EOL><INDENT>res = res + '<STR_LIT:%>' + path<EOL>index = pathlen - <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>var = path[:index]<EOL>try:<EOL><INDENT>res = res + getenv(var)<EOL><DEDENT>except KeyError:<EOL><INDENT>res = res + '<STR_LIT:%>' + var + '<STR_LIT:%>'<EOL><DEDENT><DEDENT><DEDENT><DEDENT>elif c == '<STR_LIT:$>':  <EOL><INDENT>if path[index + <NUM_LIT:1>:index + <NUM_LIT:2>] == '<STR_LIT:$>':<EOL><INDENT>res = res + c<EOL>index = index + <NUM_LIT:1><EOL><DEDENT>elif path[index + <NUM_LIT:1>:index + <NUM_LIT:2>] == '<STR_LIT:{>':<EOL><INDENT>path = path[index+<NUM_LIT:2>:]<EOL>pathlen = len(path)<EOL>try:<EOL><INDENT>index = path.index('<STR_LIT:}>')<EOL>var = path[:index]<EOL>try:<EOL><INDENT>res = res + getenv(var)<EOL><DEDENT>except KeyError:<EOL><INDENT>res = res + '<STR_LIT>' + var + '<STR_LIT:}>'<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>res = res + '<STR_LIT>' + path<EOL>index = pathlen - <NUM_LIT:1><EOL><DEDENT><DEDENT>else:<EOL><INDENT>var = '<STR_LIT>'<EOL>index = index + <NUM_LIT:1><EOL>c = path[index:index + <NUM_LIT:1>]<EOL>while c != '<STR_LIT>' and c in varchars:<EOL><INDENT>var = var + c<EOL>index = index + <NUM_LIT:1><EOL>c = path[index:index + <NUM_LIT:1>]<EOL><DEDENT>try:<EOL><INDENT>res = res + getenv(var)<EOL><DEDENT>except KeyError:<EOL><INDENT>res = res + '<STR_LIT:$>' + var<EOL><DEDENT>if c != '<STR_LIT>':<EOL><INDENT>index = index - <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>res = res + c<EOL><DEDENT>index = index + <NUM_LIT:1><EOL><DEDENT>return res<EOL>", "docstring": "Expand shell variables of the forms $var, ${var} and %var%.\n\n    Unknown variables are left unchanged.", "id": "f17316:m13"}
{"signature": "def expanduser(path):", "body": "if path[:<NUM_LIT:1>] != '<STR_LIT>':<EOL><INDENT>return path<EOL><DEDENT>i, n = <NUM_LIT:1>, len(path)<EOL>while i < n and path[i] not in '<STR_LIT>':<EOL><INDENT>i = i + <NUM_LIT:1><EOL><DEDENT>if '<STR_LIT>' in os.environ:<EOL><INDENT>userhome = os.environ['<STR_LIT>']<EOL><DEDENT>elif '<STR_LIT>' in os.environ:<EOL><INDENT>userhome = os.environ['<STR_LIT>']<EOL><DEDENT>elif not '<STR_LIT>' in os.environ:<EOL><INDENT>return path<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>drive = os.environ['<STR_LIT>']<EOL><DEDENT>except KeyError:<EOL><INDENT>drive = '<STR_LIT>'<EOL><DEDENT>userhome = join(drive, os.environ['<STR_LIT>'])<EOL><DEDENT>if i != <NUM_LIT:1>: <EOL><INDENT>userhome = join(dirname(userhome), path[<NUM_LIT:1>:i])<EOL><DEDENT>return userhome + path[i:]<EOL>", "docstring": "Expand ~ and ~user constructs.\n\n    If user or $HOME is unknown, do nothing.", "id": "f17316:m12"}
{"signature": "def walk(top, func, arg):", "body": "warnings.warnpy3k(\"<STR_LIT>\",<EOL>stacklevel=<NUM_LIT:2>)<EOL>try:<EOL><INDENT>names = os.listdir(top)<EOL><DEDENT>except os.error:<EOL><INDENT>return<EOL><DEDENT>func(arg, top, names)<EOL>for name in names:<EOL><INDENT>name = join(top, name)<EOL>if isdir(name):<EOL><INDENT>walk(name, func, arg)<EOL><DEDENT><DEDENT>", "docstring": "Directory tree walk with callback function.\n\n    For each directory in the directory tree rooted at top (including top\n    itself, but excluding '.' and '..'), call func(arg, dirname, fnames).\n    dirname is the name of the directory, and fnames a list of the names of\n    the files and subdirectories in dirname (excluding '.' and '..').  func\n    may modify the fnames list in-place (e.g. via del or slice assignment),\n    and walk will only recurse into the subdirectories whose names remain in\n    fnames; this can be used to implement a filter, or to impose a specific\n    order of visiting.  No semantics are defined for, or required of, arg,\n    beyond that arg is always passed to func.  It can be used, e.g., to pass\n    a filename pattern, or a mutable object designed to accumulate\n    statistics.  Passing None for arg is common.", "id": "f17316:m11"}
{"signature": "def normcase(s):", "body": "return s.replace(\"<STR_LIT:/>\", \"<STR_LIT:\\\\>\").lower()<EOL>", "docstring": "Normalize case of pathname.\n\n    Makes all characters lowercase and all slashes into backslashes.", "id": "f17316:m0"}
{"signature": "def isdir(s):", "body": "try:<EOL><INDENT>st = os.stat(s)<EOL><DEDENT>except os.error:<EOL><INDENT>return False<EOL><DEDENT>return stat.S_ISDIR(st.st_mode)<EOL>", "docstring": "Return true if the pathname refers to an existing directory.", "id": "f17318:m2"}
{"signature": "def count(self, value):", "body": "return sum(<NUM_LIT:1> for v in self if v == value)<EOL>", "docstring": "S.count(value) -> integer -- return number of occurrences of value", "id": "f17319:c14:m5"}
{"signature": "def values(self):", "body": "return [self[key] for key in self]<EOL>", "docstring": "D.values() -> list of D's values", "id": "f17319:c8:m8"}
{"signature": "@abstractmethod<EOL><INDENT>def next(self):<DEDENT>", "body": "raise StopIteration<EOL>", "docstring": "Return the next item from the iterator. When exhausted, raise StopIteration", "id": "f17319:c2:m0"}
{"signature": "def _hash(self):", "body": "MAX = sys.maxint<EOL>MASK = <NUM_LIT:2> * MAX + <NUM_LIT:1><EOL>n = len(self)<EOL>h = <NUM_LIT> * (n + <NUM_LIT:1>)<EOL>h &= MASK<EOL>for x in self:<EOL><INDENT>hx = hash(x)<EOL>h ^= (hx ^ (hx << <NUM_LIT:16>) ^ <NUM_LIT>)  * <NUM_LIT><EOL>h &= MASK<EOL><DEDENT>h = h * <NUM_LIT> + <NUM_LIT><EOL>h &= MASK<EOL>if h > MAX:<EOL><INDENT>h -= MASK + <NUM_LIT:1><EOL><DEDENT>if h == -<NUM_LIT:1>:<EOL><INDENT>h = <NUM_LIT><EOL><DEDENT>return h<EOL>", "docstring": "Compute the hash value of a set.\n\n        Note that we don't define __hash__: not all sets are hashable.\n        But if you define a hashable set type, its __hash__ should\n        call this function.\n\n        This must be compatible __eq__.\n\n        All sets ought to compare equal if they contain the same\n        elements, regardless of how they are implemented, and\n        regardless of the order of the elements; so there's not much\n        freedom for __eq__ or __hash__.  We match the algorithm used\n        by the built-in frozenset type.", "id": "f17319:c6:m13"}
{"signature": "def items(self):", "body": "return [(key, self[key]) for key in self]<EOL>", "docstring": "D.items() -> list of D's (key, value) pairs, as 2-tuples", "id": "f17319:c8:m7"}
{"signature": "def clear(self):", "body": "try:<EOL><INDENT>while True:<EOL><INDENT>self.pop()<EOL><DEDENT><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "This is slow (creates N new iterators!) but effective.", "id": "f17319:c7:m4"}
{"signature": "def extend(self, values):", "body": "for v in values:<EOL><INDENT>self.append(v)<EOL><DEDENT>", "docstring": "S.extend(iterable) -- extend sequence by appending elements from the iterable", "id": "f17319:c15:m5"}
{"signature": "def iteritems(self):", "body": "for key in self:<EOL><INDENT>yield (key, self[key])<EOL><DEDENT>", "docstring": "D.iteritems() -> an iterator over the (key, value) items of D", "id": "f17319:c8:m5"}
{"signature": "def remove(self, value):", "body": "if value not in self:<EOL><INDENT>raise KeyError(value)<EOL><DEDENT>self.discard(value)<EOL>", "docstring": "Remove an element. If not a member, raise a KeyError.", "id": "f17319:c7:m2"}
{"signature": "def remove(self, value):", "body": "del self[self.index(value)]<EOL>", "docstring": "S.remove(value) -- remove first occurrence of value.\n           Raise ValueError if the value is not present.", "id": "f17319:c15:m7"}
{"signature": "def purge():", "body": "_cache.clear()<EOL>_cache_repl.clear()<EOL>", "docstring": "Clear the regular expression cache", "id": "f17322:m7"}
{"signature": "def sub(pattern, repl, string, count=<NUM_LIT:0>, flags=<NUM_LIT:0>):", "body": "return _compile(pattern, flags).sub(repl, string, count)<EOL>", "docstring": "Return the string obtained by replacing the leftmost\n    non-overlapping occurrences of the pattern in string by the\n    replacement repl.  repl can be either a string or a callable;\n    if a string, backslash escapes in it are processed.  If it is\n    a callable, it's passed the match object and must return\n    a replacement string to be used.", "id": "f17322:m2"}
{"signature": "def findall(pattern, string, flags=<NUM_LIT:0>):", "body": "return _compile(pattern, flags).findall(string)<EOL>", "docstring": "Return a list of all non-overlapping matches in the string.\n\n    If one or more groups are present in the pattern, return a\n    list of groups; this will be a list of tuples if the pattern\n    has more than one group.\n\n    Empty matches are included in the result.", "id": "f17322:m5"}
{"signature": "def search(pattern, string, flags=<NUM_LIT:0>):", "body": "return _compile(pattern, flags).search(string)<EOL>", "docstring": "Scan through string looking for a match to the pattern, returning\n    a match object, or None if no match was found.", "id": "f17322:m1"}
{"signature": "def split(pattern, string, maxsplit=<NUM_LIT:0>, flags=<NUM_LIT:0>):", "body": "return _compile(pattern, flags).split(string, maxsplit)<EOL>", "docstring": "Split the source string by the occurrences of the pattern,\n    returning a list containing the resulting substrings.", "id": "f17322:m4"}
{"signature": "def template(pattern, flags=<NUM_LIT:0>):", "body": "return _compile(pattern, flags|T)<EOL>", "docstring": "Compile a template pattern, returning a pattern object", "id": "f17322:m8"}
{"signature": "def warn(message, category=None, stacklevel=<NUM_LIT:1>):", "body": "<EOL>if isinstance(message, Warning):<EOL><INDENT>category = message.__class__<EOL><DEDENT>if category is None:<EOL><INDENT>category = UserWarning<EOL><DEDENT>assert issubclass(category, Warning)<EOL>try:<EOL><INDENT>caller = sys._getframe(stacklevel)<EOL><DEDENT>except ValueError:<EOL><INDENT>globals = sys.__dict__<EOL>lineno = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>globals = caller.f_globals<EOL>lineno = caller.f_lineno<EOL><DEDENT>if '<STR_LIT>' in globals:<EOL><INDENT>module = globals['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>module = \"<STR_LIT>\"<EOL><DEDENT>filename = globals.get('<STR_LIT>')<EOL>if filename:<EOL><INDENT>fnl = filename.lower()<EOL>if fnl.endswith((\"<STR_LIT>\", \"<STR_LIT>\")):<EOL><INDENT>filename = filename[:-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if module == \"<STR_LIT:__main__>\":<EOL><INDENT>try:<EOL><INDENT>filename = sys.argv[<NUM_LIT:0>]<EOL><DEDENT>except AttributeError:<EOL><INDENT>filename = '<STR_LIT:__main__>'<EOL><DEDENT><DEDENT>if not filename:<EOL><INDENT>filename = module<EOL><DEDENT><DEDENT>registry = globals.setdefault(\"<STR_LIT>\", {})<EOL>warn_explicit(message, category, filename, lineno, module, registry,<EOL>globals)<EOL>", "docstring": "Issue a warning, or maybe ignore it or raise an exception.", "id": "f17324:m10"}
{"signature": "def formatwarning(message, category, filename, lineno, line=None):", "body": "try:<EOL><INDENT>unicodetype = str<EOL><DEDENT>except NameError:<EOL><INDENT>unicodetype = ()<EOL><DEDENT>try:<EOL><INDENT>message = str(message)<EOL><DEDENT>except UnicodeEncodeError:<EOL><INDENT>pass<EOL><DEDENT>s =  \"<STR_LIT>\" % (lineno, category.__name__, message)<EOL>line = linecache.getline(filename, lineno) if line is None else line<EOL>if line:<EOL><INDENT>line = line.strip()<EOL>if isinstance(s, unicodetype) and isinstance(line, str):<EOL><INDENT>line = str(line, '<STR_LIT>')<EOL><DEDENT>s += \"<STR_LIT>\" % line<EOL><DEDENT>if isinstance(s, unicodetype) and isinstance(filename, str):<EOL><INDENT>enc = sys.getfilesystemencoding()<EOL>if enc:<EOL><INDENT>try:<EOL><INDENT>filename = str(filename, enc)<EOL><DEDENT>except UnicodeDecodeError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>s = \"<STR_LIT>\" % (filename, s)<EOL>return s<EOL>", "docstring": "Function to format a warning the standard way.", "id": "f17324:m2"}
{"signature": "def filter(names, pat):", "body": "import os,posixpath<EOL>result=[]<EOL>pat=os.path.normcase(pat)<EOL>try:<EOL><INDENT>re_pat = _cache[pat]<EOL><DEDENT>except KeyError:<EOL><INDENT>res = translate(pat)<EOL>if len(_cache) >= _MAXCACHE:<EOL><INDENT>_cache.clear()<EOL><DEDENT>_cache[pat] = re_pat = re.compile(res)<EOL><DEDENT>match = re_pat.match<EOL>if os.path is posixpath:<EOL><INDENT>for name in names:<EOL><INDENT>if match(name):<EOL><INDENT>result.append(name)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for name in names:<EOL><INDENT>if match(os.path.normcase(name)):<EOL><INDENT>result.append(name)<EOL><DEDENT><DEDENT><DEDENT>return result<EOL>", "docstring": "Return the subset of the list NAMES that match PAT", "id": "f17327:m2"}
{"signature": "def _purge():", "body": "_cache.clear()<EOL>", "docstring": "Clear the pattern cache", "id": "f17327:m0"}
{"signature": "def SIMPLE(val):", "body": "if not val:<EOL><INDENT>return None<EOL><DEDENT>if not isinstance(val, six.string_types):<EOL><INDENT>if six.PY3 and isinstance(val, bytes):<EOL><INDENT>val = val.decode('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>val = str(val)<EOL><DEDENT><DEDENT>return {'<STR_LIT>': _prefix_score(val)}<EOL>", "docstring": "This is a basic case-sensitive \"sorted order\" index keygen function for\nstrings. This will return a value that is suitable to be used for ordering\nby a 7-byte prefix of a string (that is 7 characters from a byte-string, and\n1.75-7 characters from a unicode string, depending on character -> encoding\nlength).\n\n.. warning:: Case sensitivity is based on the (encoded) byte prefixes of the\n    strings/text being indexed, so ordering *may be different* than a native\n    comparison ordering (especially if an order is different based on\n    characters past the 7th encoded byte).", "id": "f17328:m6"}
{"signature": "def flush(self, full=False, all=False, force=False):", "body": "self._init()<EOL>return self.save(*self.known.values(), full=full, all=all, force=force)<EOL>", "docstring": "Call ``.save()`` on all modified entities in the session. Use when you\nwant to flush changes to Redis, but don't want to lose your local\nsession cache.\n\nSee the ``.commit()`` method for arguments and their meanings.", "id": "f17328:c1:m9"}
{"signature": "def SIMPLE_CI(val):", "body": "return SIMPLE(val.lower())<EOL>", "docstring": "The same as SIMPLE, only case-insensitive.", "id": "f17328:m7"}
{"signature": "def clean_old_index(model, block_size=<NUM_LIT:100>, **kwargs):", "body": "conn = _connect(model)<EOL>version = list(map(int, conn.info()['<STR_LIT>'].split('<STR_LIT:.>')[:<NUM_LIT:2>]))<EOL>has_hscan = version >= [<NUM_LIT:2>, <NUM_LIT:8>]<EOL>pipe = conn.pipeline(True)<EOL>prefix = '<STR_LIT>'%model._namespace<EOL>index = prefix + '<STR_LIT::>'<EOL>block_size = max(block_size, <NUM_LIT:10>)<EOL>force_hscan = kwargs.get('<STR_LIT>', False)<EOL>if (has_hscan or force_hscan) and force_hscan is not None:<EOL><INDENT>max_id = conn.hlen(index)<EOL>cursor = None<EOL>scanned = <NUM_LIT:0><EOL>while cursor != b'<STR_LIT:0>':<EOL><INDENT>cursor, remove = _scan_index_lua(conn, [index, prefix], [cursor or '<STR_LIT:0>', block_size, <NUM_LIT:0>, <NUM_LIT:0>])<EOL>if remove:<EOL><INDENT>_clean_index_lua(conn, [model._namespace], remove)<EOL><DEDENT>scanned += block_size<EOL>if scanned > max_id:<EOL><INDENT>max_id = scanned + <NUM_LIT:1><EOL><DEDENT>yield scanned, max_id<EOL><DEDENT>for uniq in chain(model._unique, model._cunique):<EOL><INDENT>name = uniq if isinstance(uniq, six.string_types) else '<STR_LIT::>'.join(uniq)<EOL>idx = prefix + name + '<STR_LIT>'<EOL>cursor = None<EOL>while cursor != b'<STR_LIT:0>':<EOL><INDENT>cursor, remove = _scan_index_lua(conn, [idx, prefix], [cursor or '<STR_LIT:0>', block_size, <NUM_LIT:1>, <NUM_LIT:0>])<EOL>if remove:<EOL><INDENT>conn.hdel(idx, *remove)<EOL><DEDENT>scanned += block_size<EOL>if scanned > max_id:<EOL><INDENT>max_id = scanned + <NUM_LIT:1><EOL><DEDENT>yield scanned, max_id<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if model._unique or model._cunique:<EOL><INDENT>if has_hscan:<EOL><INDENT>warnings.warn(\"<STR_LIT>\", stacklevel=<NUM_LIT:2>)<EOL><DEDENT>else:<EOL><INDENT>warnings.warn(\"<STR_LIT>\", stacklevel=<NUM_LIT:2>)<EOL><DEDENT><DEDENT>max_id = int(conn.get('<STR_LIT>'%(prefix, model._pkey)) or '<STR_LIT:0>')<EOL>for i in range(<NUM_LIT:1>, max_id+<NUM_LIT:1>, block_size):<EOL><INDENT>ids = list(range(i, min(i+block_size, max_id+<NUM_LIT:1>)))<EOL>for id in ids:<EOL><INDENT>pipe.exists(prefix + str(id))<EOL>pipe.hexists(index, id)<EOL><DEDENT>result = iter(pipe.execute())<EOL>remove = [id for id, ent, ind in zip(ids, result, result) if ind and not ent]<EOL>if remove:<EOL><INDENT>_clean_index_lua(conn, [model._namespace], remove)<EOL><DEDENT>yield min(i+block_size, max_id-<NUM_LIT:1>), max_id<EOL><DEDENT><DEDENT>yield max_id, max_id<EOL>", "docstring": "This utility function will clean out old index data that was accidentally\nleft during item deletion in rom versions <= 0.27.0 . You should run this\nafter you have upgraded all of your clients to version 0.28.0 or later.\n\nArguments:\n\n    * *model* - the model whose entities you want to reindex\n    * *block_size* - the maximum number of items to check at a time\n      defaulting to 100\n\nThis function will yield its progression through re-checking all of the\ndata that could be left over.\n\nExample use::\n\n    for progress, total in clean_old_index(MyModel, block_size=200):\n        print \"%s of %s\"%(progress, total)", "id": "f17328:m23"}
{"signature": "def FULL_TEXT(val):", "body": "if isinstance(val, float):<EOL><INDENT>val = repr(val)<EOL><DEDENT>elif val in (None, '<STR_LIT>'):<EOL><INDENT>return None<EOL><DEDENT>elif not isinstance(val, six.string_types):<EOL><INDENT>if six.PY3 and isinstance(val, bytes):<EOL><INDENT>val = val.decode('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>val = str(val)<EOL><DEDENT><DEDENT>r = sorted(set([x for x in [s.lower().strip(string.punctuation) for s in val.split()] if x]))<EOL>if not isinstance(val, str):  <EOL><INDENT>return [s.encode('<STR_LIT:utf-8>') for s in r]<EOL><DEDENT>return r<EOL>", "docstring": "This is a basic full-text index keygen function. Words are lowercased, split\nby whitespace, and stripped of punctuation from both ends before an inverted\nindex is created for term searching.", "id": "f17328:m5"}
{"signature": "def save(self, *objects, **kwargs):", "body": "from rom import Model<EOL>full = kwargs.get('<STR_LIT>')<EOL>all = kwargs.get('<STR_LIT:all>')<EOL>force = kwargs.get('<STR_LIT>')<EOL>changes = <NUM_LIT:0><EOL>items = deque()<EOL>items.extend(objects)<EOL>while items:<EOL><INDENT>o = items.popleft()<EOL>if isinstance(o, (list, tuple)):<EOL><INDENT>items.extendleft(reversed(o))<EOL><DEDENT>elif isinstance(o, Model):<EOL><INDENT>if not o._deleted and (all or o._modified):<EOL><INDENT>changes += o.save(full, force)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ORMError(<EOL>\"<STR_LIT>\"%(<EOL>o,))<EOL><DEDENT><DEDENT>return changes<EOL>", "docstring": "This method is an alternate API for saving many entities (possibly not\ntracked by the session). You can call::\n\n    session.save(obj)\n    session.save(obj1, obj2, ...)\n    session.save([obj1, obj2, ...])\n\nAnd the entities will be flushed to Redis.\n\nYou can pass the keyword arguments ``full``, ``all``, and ``force`` with\nthe same meaning and semantics as the ``.commit()`` method.", "id": "f17328:c1:m11"}
{"signature": "def get(self, pk):", "body": "self._init()<EOL>return self.known.get(pk) or self.wknown.get(pk)<EOL>", "docstring": "Fetches an entity from the session based on primary key.", "id": "f17328:c1:m7"}
{"signature": "def IDENTITY(val):", "body": "if not val:<EOL><INDENT>return None<EOL><DEDENT>if not isinstance(val, six.string_types_ex):<EOL><INDENT>val = str(val)<EOL><DEDENT>return [val]<EOL>", "docstring": "This is a basic \"equality\" index keygen, primarily meant to be used for\nthings like::\n\n    Model.query.filter(col='value')\n\nWhere ``FULL_TEXT`` would transform a sentence like \"A Simple Sentence\" into\nan inverted index searchable by the words \"a\", \"simple\", and/or \"sentence\",\n``IDENTITY`` will only be searchable by the orginal full sentence with the\nsame capitalization - \"A Simple Sentence\". See ``IDENTITY_CI`` for the\nsame function, only case-insensitive.", "id": "f17328:m9"}
{"signature": "def _script_load(script):", "body": "script = script.encode('<STR_LIT:utf-8>') if isinstance(script, six.text_type) else script<EOL>sha = [None, sha1(script).hexdigest()]<EOL>def call(conn, keys=[], args=[], force_eval=False):<EOL><INDENT>keys = tuple(keys)<EOL>args = tuple(args)<EOL>if not force_eval:<EOL><INDENT>if not sha[<NUM_LIT:0>]:<EOL><INDENT>try:<EOL><INDENT>return conn.execute_command(<EOL>'<STR_LIT>', script, len(keys), *(keys + args))<EOL><DEDENT>finally:<EOL><INDENT>del sha[:-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>try:<EOL><INDENT>return conn.execute_command(<EOL>\"<STR_LIT>\", sha[<NUM_LIT:0>], len(keys), *(keys+args))<EOL><DEDENT>except redis.exceptions.ResponseError as msg:<EOL><INDENT>if not any(msg.args[<NUM_LIT:0>].startswith(nsm) for nsm in NO_SCRIPT_MESSAGES):<EOL><INDENT>raise<EOL><DEDENT><DEDENT><DEDENT>return conn.execute_command(<EOL>\"<STR_LIT>\", script, len(keys), *(keys+args))<EOL><DEDENT>return call<EOL>", "docstring": "Borrowed/modified from my book, Redis in Action:\nhttps://github.com/josiahcarlson/redis-in-action/blob/master/python/ch11_listing_source.py\n\nUsed for Lua scripting support when writing against Redis 2.6+ to allow\nfor multiple unique columns per model.", "id": "f17328:m25"}
{"signature": "@ClassProperty<EOL><INDENT>def query(cls):<DEDENT>", "body": "return Query(cls)<EOL>", "docstring": "Returns a ``Query`` object that refers to this model to handle\nsubsequent filtering.", "id": "f17329:c2:m17"}
{"signature": "def redis_prefix_lua(conn, dest, index, prefix, is_first, pattern=None):", "body": "tkey = '<STR_LIT>'%(index.partition('<STR_LIT::>')[<NUM_LIT:0>], uuid.uuid4())<EOL>start, end = _start_end(prefix)<EOL>return _redis_prefix_lua(conn,<EOL>[dest, tkey, index],<EOL>[start, end, pattern or prefix, int(pattern is not None), int(bool(is_first))]<EOL>)<EOL>", "docstring": "Performs the actual prefix, suffix, and pattern match operations.", "id": "f17330:m3"}
{"signature": "def count(self, conn, filters):", "body": "pipe, intersect, temp_id = self._prepare(conn, filters)<EOL>pipe.zcard(temp_id)<EOL>pipe.delete(temp_id)<EOL>return pipe.execute()[-<NUM_LIT:2>]<EOL>", "docstring": "Returns the count of the items that match the provided filters.\n\nFor the meaning of what the ``filters`` argument means, see the\n``.search()`` method docs.", "id": "f17330:c0:m3"}
{"signature": "def all(self):", "body": "return self.execute()<EOL>", "docstring": "Alias for ``execute()``.", "id": "f17331:c0:m21"}
{"signature": "def like(self, **kwargs):", "body": "new = []<EOL>for k, v in kwargs.items():<EOL><INDENT>v = self._check(k, v, '<STR_LIT>')<EOL>new.append(Pattern(k, v))<EOL><DEDENT>return self.replace(filters=self._filters+tuple(new))<EOL>", "docstring": "When provided with keyword arguments of the form ``col=pattern``, this\nwill limit the entities returned to those that include the provided\npattern. Note that 'like' queries require that the ``prefix=True``\noption must have been provided as part of the column definition.\n\nPatterns allow for 4 wildcard characters, whose semantics are as\nfollows:\n\n    * *?* - will match 0 or 1 of any character\n    * *\\** - will match 0 or more of any character\n    * *+* - will match 1 or more of any character\n    * *!* - will match exactly 1 of any character\n\nAs an example, imagine that you have enabled the required prefix\nmatching on your ``User.email`` column. And lets say that you want to\nfind everyone with an email address that contains the name 'frank'\nbefore the ``@`` sign. You can use either of the following patterns\nto discover those users.\n\n    * *\\*frank\\*@*\n    * *\\*frank\\*@*\n\n.. note:: Like queries implicitly start at the beginning of strings\n  checked, so if you want to match a pattern that doesn't start at\n  the beginning of a string, you should prefix it with one of the\n  wildcard characters (like ``*`` as we did with the 'frank' pattern).", "id": "f17331:c0:m7"}
{"signature": "def GetParam(tag, param, default=__SENTINEL):", "body": "if tag.HasParam(param):<EOL><INDENT>return tag.GetParam(param)<EOL><DEDENT>else:<EOL><INDENT>if default == __SENTINEL:<EOL><INDENT>raise KeyError<EOL><DEDENT>else:<EOL><INDENT>return default<EOL><DEDENT><DEDENT>", "docstring": "Convenience function for accessing tag parameters", "id": "f17349:m0"}
{"signature": "def migrate_window(bg):", "body": "ret = {}<EOL>for k, v in bg.items():<EOL><INDENT>if k == '<STR_LIT:type>':<EOL><INDENT>v = WIN_MAP[v]._meta.name<EOL><DEDENT>elif k == '<STR_LIT>':<EOL><INDENT>menus = v['<STR_LIT>']<EOL>v = [migrate_control(menu) for menu in menus]<EOL><DEDENT>elif k == '<STR_LIT>':<EOL><INDENT>v = [migrate_control(comp) for comp in v]<EOL><DEDENT>else:<EOL><INDENT>k = SPEC_MAP['<STR_LIT>'].get(k, k)<EOL><DEDENT>ret[k] = v<EOL><DEDENT>return ret<EOL>", "docstring": "Take a pythoncard background resource and convert to a gui2py window", "id": "f17354:m0"}
{"signature": "def update(self, obj, **kwargs):", "body": "<EOL>child = self.tree.FindItem(self.root, kwargs['<STR_LIT:name>'])<EOL>if DEBUG: print(\"<STR_LIT>\", child, kwargs)<EOL>if child:<EOL><INDENT>self.tree.ScrollTo(child)<EOL>self.tree.SetCurrentItem(child)<EOL>self.tree.SelectItem(child)<EOL>child.Selected = True<EOL>self.tree.SetItemText(child, obj.name, <NUM_LIT:0>)<EOL><DEDENT>", "docstring": "Update the tree item when the object name changes", "id": "f17355:c0:m7"}
{"signature": "def activate_item(self, child, edit_prop=False, select=False):", "body": "d = self.tree.GetItemData(child)<EOL>if d:<EOL><INDENT>o = d.GetData()<EOL>self.selected_obj = o<EOL>callback = lambda o=o, **kwargs: self.update(o, **kwargs)<EOL>self.propeditor.load_object(o, callback)<EOL>if edit_prop:<EOL><INDENT>wx.CallAfter(self.propeditor.edit)<EOL><DEDENT>if select and self.designer:<EOL><INDENT>self.designer.select(o)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.selected_obj = None<EOL><DEDENT>", "docstring": "load the selected item in the property editor", "id": "f17355:c0:m6"}
{"signature": "def show_context_menu(self, item, mouse_pos=None):", "body": "if item:<EOL><INDENT>d = self.tree.GetItemData(item)<EOL>if d:<EOL><INDENT>obj = d.GetData()<EOL>if obj:<EOL><INDENT>self.highlight(obj.wx_obj)<EOL>self.obj = obj<EOL>menu = wx.Menu()<EOL>id_del, id_dup, id_raise, id_lower = [wx.NewId() for i<EOL>in range(<NUM_LIT:4>)]<EOL>menu.Append(id_del, \"<STR_LIT>\")<EOL>menu.Append(id_dup, \"<STR_LIT>\")<EOL>menu.Append(id_raise, \"<STR_LIT>\")<EOL>menu.Append(id_lower, \"<STR_LIT>\")<EOL>sm = wx.Menu()<EOL>for ctrl in sorted(obj._meta.valid_children,<EOL>key=lambda c: <EOL>registry.ALL.index(c._meta.name)):<EOL><INDENT>new_id = wx.NewId()<EOL>sm.Append(new_id, ctrl._meta.name)<EOL>self.Bind(wx.EVT_MENU, <EOL>lambda evt, ctrl=ctrl: self.add_child(ctrl, mouse_pos), <EOL>id=new_id)<EOL><DEDENT>menu.AppendMenu(wx.NewId(), \"<STR_LIT>\", sm)<EOL>self.Bind(wx.EVT_MENU, self.delete, id=id_del)<EOL>self.Bind(wx.EVT_MENU, self.duplicate, id=id_dup)<EOL>self.Bind(wx.EVT_MENU, self.bring_to_front, id=id_raise)<EOL>self.Bind(wx.EVT_MENU, self.send_to_back, id=id_lower)<EOL>self.PopupMenu(menu)<EOL>menu.Destroy()<EOL>self.load_object(self.root_obj)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Open a popup menu with options regarding the selected object", "id": "f17355:c0:m13"}
{"signature": "def set_default_tlw(self, tlw, designer, inspector):", "body": "self.designer = designer<EOL>self.inspector = inspector<EOL>", "docstring": "track default top level window for toolbox menu default action", "id": "f17356:c0:m3"}
{"signature": "def save(evt, designer):", "body": "<EOL>ok = gui.confirm(\"<STR_LIT>\", \"<STR_LIT>\", <EOL>cancel=True, default=True)<EOL>if ok:<EOL><INDENT>wx_obj = evt.GetEventObject()<EOL>w = wx_obj.obj<EOL>try:<EOL><INDENT>if DEBUG: print(\"<STR_LIT>\")<EOL>fin = open(designer.filename, \"<STR_LIT:r>\")<EOL>fout = open(designer.filename + \"<STR_LIT>\", \"<STR_LIT:w>\")<EOL>fout.write(fin.read())<EOL>fout.close()<EOL>fin.close()<EOL>if designer.filename.endswith(\"<STR_LIT>\"):<EOL><INDENT>gui.save(designer.filename, [gui.dump(w)])<EOL><DEDENT>else:<EOL><INDENT>fin = open(designer.filename + \"<STR_LIT>\", \"<STR_LIT:r>\")<EOL>fout = open(designer.filename, \"<STR_LIT:w>\")<EOL>copy = True<EOL>newlines = fin.newlines or \"<STR_LIT:\\n>\"<EOL>def dump(obj, indent=<NUM_LIT:1>):<EOL><INDENT>\"<STR_LIT>\"<EOL>for ctl in obj[:]:<EOL><INDENT>write(ctl, indent)<EOL><DEDENT><DEDENT>def write(ctl, indent):<EOL><INDENT>if ctl[:]:<EOL><INDENT>fout.write(\"<STR_LIT:U+0020>\" * indent * <NUM_LIT:4>)<EOL>fout.write(\"<STR_LIT>\" % ctl.__repr__(parent=None, indent=indent, context=True))<EOL>fout.write(newlines)<EOL>dump(ctl, indent + <NUM_LIT:1>)                <EOL><DEDENT>else:<EOL><INDENT>fout.write(\"<STR_LIT:U+0020>\" * indent * <NUM_LIT:4>)<EOL>fout.write(ctl.__repr__(parent=None, indent=indent))<EOL>fout.write(newlines)<EOL><DEDENT><DEDENT>dumped = False<EOL>for line in fin:<EOL><INDENT>if line.startswith(\"<STR_LIT>\"):<EOL><INDENT>fout.write(line)<EOL>fout.write(newlines)<EOL>write(w, indent=<NUM_LIT:0>)<EOL>fout.write(newlines)<EOL>dumped = True<EOL>copy = False<EOL><DEDENT>if line.startswith(\"<STR_LIT>\"):<EOL><INDENT>copy = True<EOL><DEDENT>if copy:<EOL><INDENT>fout.write(line)<EOL><DEDENT><DEDENT>if not dumped:<EOL><INDENT>gui.alert(\"<STR_LIT>\"<EOL>\"<STR_LIT>\", <EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT>fout.close()<EOL>fin.close()<EOL><DEDENT>except Exception as e:<EOL><INDENT>import traceback<EOL>print((traceback.print_exc()))<EOL>ok = gui.confirm(\"<STR_LIT>\" % str(e), '<STR_LIT>', <EOL>ok=True, cancel=True)<EOL><DEDENT><DEDENT>if ok is not None:<EOL><INDENT>wx.CallAfter(exit)    <EOL><DEDENT>return ok                 <EOL>", "docstring": "Basic save functionality: just replaces the gui code", "id": "f17357:m0"}
{"signature": "def duplicate(self, event):", "body": "<EOL>new_selection = []<EOL>for obj in self.selection:<EOL><INDENT>if obj:<EOL><INDENT>if DEBUG: print(\"<STR_LIT>\", obj.name)<EOL>obj.sel_marker.destroy()<EOL>obj.sel_marker = None<EOL>obj2 = obj.duplicate()<EOL>obj2.sel_marker = SelectionMarker(obj2)<EOL>obj2.sel_marker.show(True)<EOL>new_selection.append(obj2)<EOL><DEDENT><DEDENT>self.selection = new_selection              <EOL>self.inspector.load_object()                <EOL>", "docstring": "create a copy of each selected object", "id": "f17357:c0:m8"}
{"signature": "def do_resize(self, evt, wx_obj, xxx_todo_changeme):", "body": "(n, w, s, e) = xxx_todo_changeme<EOL>pos = wx_obj.ScreenToClient(wx.GetMousePosition())<EOL>x, y = pos<EOL>if evt.ShiftDown():     <EOL><INDENT>x = x / GRID_SIZE[<NUM_LIT:0>] * GRID_SIZE[<NUM_LIT:0>]<EOL>y = y / GRID_SIZE[<NUM_LIT:1>] * GRID_SIZE[<NUM_LIT:1>]<EOL><DEDENT>pos = wx.Point(x, y)<EOL>if not self.resizing or self.resizing != (wx_obj, (n, w, s, e)):<EOL><INDENT>self.pos = list(pos)                        <EOL>self.resizing = (wx_obj, (n, w, s, e))      <EOL><DEDENT>else:<EOL><INDENT>delta = pos - self.pos <EOL>if DEBUG: print(\"<STR_LIT>\", n, w, s, e)<EOL>if n or w or s or e:<EOL><INDENT>x = wx_obj.Position[<NUM_LIT:0>] + e * delta[<NUM_LIT:0>]<EOL>y = wx_obj.Position[<NUM_LIT:1>] + n * delta[<NUM_LIT:1>]<EOL>if w or e:<EOL><INDENT>if not isinstance(wx_obj, wx.TopLevelWindow):<EOL><INDENT>width = wx_obj.Size[<NUM_LIT:0>] + (w - e) * delta[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>width = wx_obj.ClientSize[<NUM_LIT:0>] + (w - e) * delta[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>width = None<EOL><DEDENT>if n or s:<EOL><INDENT>height = wx_obj.Size[<NUM_LIT:1>] + (s - n) * delta[<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>height = None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>x = wx_obj.Position[<NUM_LIT:0>] + delta[<NUM_LIT:0>]<EOL>y = wx_obj.Position[<NUM_LIT:1>] + delta[<NUM_LIT:1>]<EOL>width = height = None<EOL><DEDENT>new_pos = (x, y)<EOL>new_size = (width, height)<EOL>if new_size != wx_obj.GetSize() or new_pos != wx_obj.GetPosition():<EOL><INDENT>wx_obj.obj.margin_left = <NUM_LIT:0><EOL>wx_obj.obj.margin_right = <NUM_LIT:0><EOL>wx_obj.obj.margin_top = <NUM_LIT:0><EOL>wx_obj.obj.margin_bottom = <NUM_LIT:0><EOL>wx_obj.obj.pos = new_pos      <EOL>if width is not None and height is not None:<EOL><INDENT>wx_obj.obj.width = width<EOL>wx_obj.obj.height = height<EOL><DEDENT>elif width is not None:<EOL><INDENT>wx_obj.obj.width = width<EOL><DEDENT>elif height is not None:<EOL><INDENT>wx_obj.obj.height = height<EOL><DEDENT>if w:<EOL><INDENT>self.pos[<NUM_LIT:0>] = pos[<NUM_LIT:0>]        <EOL><DEDENT>if s:<EOL><INDENT>self.pos[<NUM_LIT:1>] = pos[<NUM_LIT:1>]        <EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Called by SelectionTag", "id": "f17357:c0:m4"}
{"signature": "def set_parent(self, new_parent, init=False):", "body": "<EOL>self.wx_obj.SetOwner(new_parent.wx_obj.GetEventHandler())<EOL>", "docstring": "Re-parent a child control with the new wx_obj parent (owner)", "id": "f17358:c0:m1"}
{"signature": "def connect(component, controller=None):", "body": "<EOL>if not controller or isinstance(controller, dict):<EOL><INDENT>if not controller:<EOL><INDENT>controller = util.get_caller_module_dict()<EOL><DEDENT>controller_name = controller['<STR_LIT>']<EOL>controller_dict = controller<EOL><DEDENT>else:<EOL><INDENT>controller_name = controller.__class__.__name__<EOL>controller_dict = dict([(k, getattr(controller, k)) for k <EOL>in dir(controller) if k.startswith(\"<STR_LIT>\")])<EOL><DEDENT>for fn in [n for n in controller_dict if n.startswith(\"<STR_LIT>\")]:<EOL><INDENT>names = fn.split(\"<STR_LIT:_>\")<EOL>event_name = names.pop(<NUM_LIT:0>) + names.pop(-<NUM_LIT:1>)<EOL>obj = component<EOL>for name in names:<EOL><INDENT>try:<EOL><INDENT>obj = obj[name]<EOL><DEDENT>except KeyError:<EOL><INDENT>obj = None<EOL>break<EOL><DEDENT><DEDENT>if not obj:<EOL><INDENT>from .component import COMPONENTS<EOL>for key, obj in list(COMPONENTS.items()):<EOL><INDENT>if obj.name == name:<EOL><INDENT>print(\"<STR_LIT>\" % (name, key.replace(\"<STR_LIT:.>\", \"<STR_LIT:_>\")))<EOL>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise NameError(\"<STR_LIT>\" % <EOL>(name, controller_name, fn))<EOL><DEDENT><DEDENT>if event_name in PYTHONCARD_EVENT_MAP:<EOL><INDENT>new_name = PYTHONCARD_EVENT_MAP[event_name]<EOL>print(\"<STR_LIT>\" % (event_name, new_name, fn))<EOL>event_name = new_name<EOL><DEDENT>if not hasattr(obj, event_name):<EOL><INDENT>raise NameError(\"<STR_LIT>\" % <EOL>(event_name, controller_name, fn))<EOL><DEDENT>setattr(obj, event_name, controller_dict[fn])<EOL><DEDENT>", "docstring": "Associate event handlers", "id": "f17359:m6"}
{"signature": "def save(filename, rsrc):", "body": "s = pprint.pformat(rsrc)<EOL>open(filename, \"<STR_LIT:w>\").write(s)<EOL>", "docstring": "Save the resource to the source file", "id": "f17359:m1"}
{"signature": "def parse(filename=\"<STR_LIT>\"):", "body": "<EOL>s = open(filename).read()<EOL>import datetime, decimal<EOL>rsrc = eval(s)<EOL>return rsrc<EOL>", "docstring": "Open, read and eval the resource from the source file", "id": "f17359:m0"}
{"signature": "def _set_icon(self, icon=None):", "body": "if icon is not None:<EOL><INDENT>try:<EOL><INDENT>wx_icon = wx.Icon(icon, wx.BITMAP_TYPE_ICO)<EOL>self.wx_obj.SetIcon(wx_icon)<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>", "docstring": "Set icon based on resource values", "id": "f17363:c0:m4"}
{"signature": "def get_items(self, names):", "body": "env = self.state.document.settings.env<EOL>prefixes = get_import_prefixes_from_env(env)<EOL>items = []<EOL>max_item_chars = <NUM_LIT:50><EOL>for name in names:<EOL><INDENT>display_name = name<EOL>if name.startswith('<STR_LIT>'):<EOL><INDENT>name = name[<NUM_LIT:1>:]<EOL>display_name = name.split('<STR_LIT:.>')[-<NUM_LIT:1>]<EOL><DEDENT>try:<EOL><INDENT>real_name, obj, parent = import_by_name(name, prefixes=prefixes)<EOL><DEDENT>except ImportError:<EOL><INDENT>self.warn('<STR_LIT>' % name)<EOL>items.append((name, '<STR_LIT>', '<STR_LIT>', name))<EOL>continue<EOL><DEDENT>documenter = get_documenter(obj, parent)(self, real_name)<EOL>if not documenter.parse_name():<EOL><INDENT>self.warn('<STR_LIT>' % real_name)<EOL>items.append((display_name, '<STR_LIT>', '<STR_LIT>', real_name))<EOL>continue<EOL><DEDENT>if not documenter.import_object():<EOL><INDENT>self.warn('<STR_LIT>' % real_name)<EOL>items.append((display_name, '<STR_LIT>', '<STR_LIT>', real_name))<EOL>continue<EOL><DEDENT>sig = documenter.format_signature()<EOL>if not sig:<EOL><INDENT>sig = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>max_chars = max(<NUM_LIT:10>, max_item_chars - len(display_name))<EOL>sig = mangle_signature(sig, max_chars=max_chars)<EOL>sig = sig.replace('<STR_LIT:*>', r'<STR_LIT>')<EOL><DEDENT>doc = list(documenter.process_doc(documenter.get_doc()))<EOL>while doc and not doc[<NUM_LIT:0>].strip():<EOL><INDENT>doc.pop(<NUM_LIT:0>)<EOL><DEDENT>m = re.search(r\"<STR_LIT>\", \"<STR_LIT:U+0020>\".join(doc).strip())<EOL>if m:<EOL><INDENT>summary = m.group(<NUM_LIT:1>).strip()<EOL><DEDENT>elif doc:<EOL><INDENT>summary = doc[<NUM_LIT:0>].strip()<EOL><DEDENT>else:<EOL><INDENT>summary = '<STR_LIT>'<EOL><DEDENT>items.append((display_name, sig, summary, real_name))<EOL><DEDENT>return items<EOL>", "docstring": "Try to import the given names, and return a list of\n        ``[(name, signature, summary_string, real_name), ...]``.", "id": "f17367:c3:m2"}
{"signature": "def autosummary_table_visit_html(self, node):", "body": "try:<EOL><INDENT>tbody = node[<NUM_LIT:0>][<NUM_LIT:0>][-<NUM_LIT:1>]<EOL>for row in tbody:<EOL><INDENT>col1_entry = row[<NUM_LIT:0>]<EOL>par = col1_entry[<NUM_LIT:0>]<EOL>for j, subnode in enumerate(list(par)):<EOL><INDENT>if isinstance(subnode, nodes.Text):<EOL><INDENT>new_text = str(subnode.astext())<EOL>new_text = new_text.replace(\"<STR_LIT:U+0020>\", \"<STR_LIT>\")<EOL>par[j] = nodes.Text(new_text)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>except IndexError:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Make the first column of the table non-breaking.", "id": "f17367:m3"}
{"signature": "def mangle_signature(sig, max_chars=<NUM_LIT:30>):", "body": "s = re.sub(r\"<STR_LIT>\", r\"<STR_LIT>\", sig).strip()<EOL>s = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", s)<EOL>s = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", s)<EOL>s = re.sub(r\"<STR_LIT>\", \"<STR_LIT>\", s)<EOL>args = []<EOL>opts = []<EOL>opt_re = re.compile(r\"<STR_LIT>\")<EOL>while s:<EOL><INDENT>m = opt_re.search(s)<EOL>if not m:<EOL><INDENT>args = s.split('<STR_LIT:U+002CU+0020>')<EOL>break<EOL><DEDENT>opts.insert(<NUM_LIT:0>, m.group(<NUM_LIT:2>))<EOL>s = m.group(<NUM_LIT:1>)[:-<NUM_LIT:2>]<EOL><DEDENT>sig = limited_join(\"<STR_LIT:U+002CU+0020>\", args, max_chars=max_chars-<NUM_LIT:2>)<EOL>if opts:<EOL><INDENT>if not sig:<EOL><INDENT>sig = \"<STR_LIT>\" % limited_join(\"<STR_LIT:U+002CU+0020>\", opts, max_chars=max_chars-<NUM_LIT:4>)<EOL><DEDENT>elif len(sig) < max_chars - <NUM_LIT:4> - <NUM_LIT:2> - <NUM_LIT:3>:<EOL><INDENT>sig += \"<STR_LIT>\" % limited_join(\"<STR_LIT:U+002CU+0020>\", opts,<EOL>max_chars=max_chars-len(sig)-<NUM_LIT:4>-<NUM_LIT:2>)<EOL><DEDENT><DEDENT>return \"<STR_LIT>\" % sig<EOL>", "docstring": "Reformat a function signature to a more compact form.", "id": "f17367:m5"}
{"signature": "def autolink_role(typ, rawtext, etext, lineno, inliner,<EOL>options={}, content=[]):", "body": "env = inliner.document.settings.env<EOL>r = env.get_domain('<STR_LIT>').role('<STR_LIT>')(<EOL>'<STR_LIT>', rawtext, etext, lineno, inliner, options, content)<EOL>pnode = r[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>prefixes = get_import_prefixes_from_env(env)<EOL>try:<EOL><INDENT>name, obj, parent = import_by_name(pnode['<STR_LIT>'], prefixes)<EOL><DEDENT>except ImportError:<EOL><INDENT>content = pnode[<NUM_LIT:0>]<EOL>r[<NUM_LIT:0>][<NUM_LIT:0>] = nodes.emphasis(rawtext, content[<NUM_LIT:0>].astext(),<EOL>classes=content['<STR_LIT>'])<EOL><DEDENT>return r<EOL>", "docstring": "Smart linking role.\n\n    Expands to ':obj:`text`' if `text` is an object that can be imported;\n    otherwise expands to '*text*'.", "id": "f17367:m10"}
{"signature": "def process_autosummary_toc(app, doctree):", "body": "env = app.builder.env<EOL>crawled = {}<EOL>def crawl_toc(node, depth=<NUM_LIT:1>):<EOL><INDENT>crawled[node] = True<EOL>for j, subnode in enumerate(node):<EOL><INDENT>try:<EOL><INDENT>if (isinstance(subnode, autosummary_toc)<EOL>and isinstance(subnode[<NUM_LIT:0>], addnodes.toctree)):<EOL><INDENT>env.note_toctree(env.docname, subnode[<NUM_LIT:0>])<EOL>continue<EOL><DEDENT><DEDENT>except IndexError:<EOL><INDENT>continue<EOL><DEDENT>if not isinstance(subnode, nodes.section):<EOL><INDENT>continue<EOL><DEDENT>if subnode not in crawled:<EOL><INDENT>crawl_toc(subnode, depth+<NUM_LIT:1>)<EOL><DEDENT><DEDENT><DEDENT>crawl_toc(doctree)<EOL>", "docstring": "Insert items described in autosummary:: to the TOC tree, but do\n    not generate the toctree:: list.", "id": "f17367:m0"}
{"signature": "def find_modules(rootpath, skip):", "body": "INITPY = '<STR_LIT>'<EOL>rootpath = os.path.normpath(os.path.abspath(rootpath))<EOL>if INITPY in os.listdir(rootpath):<EOL><INDENT>root_package = rootpath.split(os.path.sep)[-<NUM_LIT:1>]<EOL>print(\"<STR_LIT>\", rootpath)<EOL><DEDENT>else:<EOL><INDENT>print(\"<STR_LIT>\", rootpath)<EOL>return<EOL><DEDENT>def makename(package, module):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if package:<EOL><INDENT>name = package<EOL>if module:<EOL><INDENT>name += '<STR_LIT:.>' + module<EOL><DEDENT><DEDENT>else:<EOL><INDENT>name = module<EOL><DEDENT>return name<EOL><DEDENT>skipall = []<EOL>for m in list(skip.keys()):<EOL><INDENT>if skip[m] is None: skipall.append(m)<EOL><DEDENT>tree = {}<EOL>saved = <NUM_LIT:0><EOL>found = <NUM_LIT:0><EOL>def save(module, submodule):<EOL><INDENT>name = module+ \"<STR_LIT:.>\"+ submodule<EOL>for s in skipall:<EOL><INDENT>if name.startswith(s):<EOL><INDENT>print(\"<STR_LIT>\"+name)<EOL>return False<EOL><DEDENT><DEDENT>if module in skip:<EOL><INDENT>if submodule in skip[module]:<EOL><INDENT>print(\"<STR_LIT>\"+name)<EOL>return False<EOL><DEDENT><DEDENT>if module not in tree:<EOL><INDENT>tree[module] = []<EOL><DEDENT>tree[module].append(submodule)<EOL>return True<EOL><DEDENT>for root, subs, files in os.walk(rootpath):<EOL><INDENT>py_files = sorted([f for f in files if os.path.splitext(f)[<NUM_LIT:1>] == '<STR_LIT>'])<EOL>if INITPY in py_files:<EOL><INDENT>subpackage = root[len(rootpath):].lstrip(os.path.sep).replace(os.path.sep, '<STR_LIT:.>')<EOL>full = makename(root_package, subpackage)<EOL>part = full.rpartition('<STR_LIT:.>')<EOL>base_package, submodule = part[<NUM_LIT:0>], part[<NUM_LIT:2>]<EOL>found += <NUM_LIT:1><EOL>if save(base_package, submodule): saved += <NUM_LIT:1><EOL>py_files.remove(INITPY)    <EOL>for py_file in py_files:<EOL><INDENT>found += <NUM_LIT:1><EOL>module = os.path.splitext(py_file)[<NUM_LIT:0>]<EOL>if save(full, module): saved += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>for item in list(tree.keys()):<EOL><INDENT>tree[item].sort()<EOL><DEDENT>print(\"<STR_LIT>\" %(root_package, found, found-saved))<EOL>return tree<EOL>", "docstring": "Look for every file in the directory tree and return a dict\nHacked from sphinx.autodoc", "id": "f17368:m1"}
{"signature": "def find(self, item_id=None):", "body": "for it in self:<EOL><INDENT>found = it.find(item_id)<EOL>if found:<EOL><INDENT>return found<EOL><DEDENT><DEDENT>", "docstring": "Recursively find a menu item by its id (useful for event handlers)", "id": "f17370:c8:m2"}
{"signature": "def IsEnabled(self, *args, **kwargs):", "body": "for i in range(self.GetMenuCount()):<EOL><INDENT>if not self.IsEnabledTop(i):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "check if all top menus are enabled", "id": "f17370:c7:m2"}
{"signature": "def shell():", "body": "from gui.tools.debug import Shell    <EOL>shell = Shell()<EOL>shell.show()<EOL>return shell<EOL>", "docstring": "Open a shell", "id": "f17371:m1"}
{"signature": "def inspect(obj):", "body": "from gui.tools.inspector import InspectorTool<EOL>inspector = InspectorTool()<EOL>inspector.show(obj)<EOL>return inspector<EOL>", "docstring": "Open the inspector windows for a given object", "id": "f17371:m0"}
{"signature": "def represent(obj, prefix, parent=\"<STR_LIT>\", indent=<NUM_LIT:0>, context=False, max_cols=<NUM_LIT>):", "body": "try:<EOL><INDENT>name = getattr(obj, \"<STR_LIT:name>\", \"<STR_LIT>\")<EOL>class_name = \"<STR_LIT>\" % (prefix, obj.__class__.__name__)<EOL>padding = len(class_name) + <NUM_LIT:1> + indent * <NUM_LIT:4> + (<NUM_LIT:5> if context else <NUM_LIT:0>)<EOL>params = []<EOL>for (k, spec) in sorted(list(obj._meta.specs.items()), key=get_sort_key):<EOL><INDENT>if k == \"<STR_LIT:index>\":        <EOL><INDENT>continue            <EOL><DEDENT>if k == \"<STR_LIT>\" and parent != \"<STR_LIT>\":<EOL><INDENT>v = parent<EOL><DEDENT>else:<EOL><INDENT>v = getattr(obj, k, \"<STR_LIT>\")<EOL>if (not isinstance(spec, InternalSpec) <EOL>and v != spec.default<EOL>and (k != '<STR_LIT:id>' or v > <NUM_LIT:0>) <EOL>and isinstance(v, <EOL>(str, int, float, bool, dict, list, <EOL>decimal.Decimal, <EOL>datetime.datetime, datetime.date, datetime.time,<EOL>Font, Color))                <EOL>and repr(v) != '<STR_LIT:None>'<EOL>):<EOL><INDENT>v = repr(v)<EOL><DEDENT>else:<EOL><INDENT>v = None<EOL><DEDENT><DEDENT>if v is not None:<EOL><INDENT>params.append(\"<STR_LIT>\" % (k, v)) <EOL><DEDENT><DEDENT>param_lines = []<EOL>line = \"<STR_LIT>\"<EOL>for param in params:<EOL><INDENT>if len(line + param) + <NUM_LIT:3> > max_cols - padding:<EOL><INDENT>param_lines.append(line)<EOL>line = \"<STR_LIT>\"<EOL><DEDENT>line += param + \"<STR_LIT:U+002CU+0020>\"<EOL><DEDENT>param_lines.append(line)<EOL>param_str = (\"<STR_LIT>\" % (\"<STR_LIT:U+0020>\" * padding)).join(param_lines)<EOL>return \"<STR_LIT>\" % (class_name, param_str)<EOL><DEDENT>except:<EOL><INDENT>raise<EOL>return object.__repr__(obj)<EOL><DEDENT>", "docstring": "Construct a string representing the object", "id": "f17372:m2"}
{"signature": "def duplicate(self, new_parent=None):", "body": "kwargs = {}<EOL>for spec_name, spec in list(self._meta.specs.items()):<EOL><INDENT>value = getattr(self, spec_name)<EOL>if isinstance(value, Color):<EOL><INDENT>print(\"<STR_LIT>\", value, value.default)<EOL>if value.default:<EOL><INDENT>value = None<EOL><DEDENT><DEDENT>if value is not None:<EOL><INDENT>kwargs[spec_name] = value<EOL><DEDENT><DEDENT>del kwargs['<STR_LIT>'] <EOL>new_id = wx.NewId()<EOL>kwargs['<STR_LIT:id>'] = new_id<EOL>kwargs['<STR_LIT:name>'] = \"<STR_LIT>\" % (kwargs['<STR_LIT:name>'], new_id)<EOL>new_obj = self.__class__(new_parent or self.get_parent(), **kwargs)<EOL>for child in self:<EOL><INDENT>child.duplicate(new_obj)<EOL><DEDENT>return new_obj<EOL>", "docstring": "Create a new object exactly similar to self", "id": "f17372:c2:m4"}
{"signature": "def _get_fully_qualified_name(self):", "body": "parent_name = self._get_parent_name()<EOL>if not parent_name:<EOL><INDENT>return self._name<EOL><DEDENT>else:<EOL><INDENT>return \"<STR_LIT>\" % (parent_name, self._name)<EOL><DEDENT>", "docstring": "return full parents name + self name (useful as key)", "id": "f17372:c2:m18"}
{"signature": "def _get_parent_name(self):", "body": "parent = self.get_parent()<EOL>parent_names = []<EOL>while parent:<EOL><INDENT>if isinstance(parent, Component):<EOL><INDENT>parent_name = parent.name<EOL>if parent_name:<EOL><INDENT>parent_names.insert(<NUM_LIT:0>, parent_name)<EOL><DEDENT>parent = parent.get_parent()<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if not parent_names:<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT:.>'.join(parent_names)<EOL><DEDENT>", "docstring": "Return parent window name (used in __repr__ parent spec)", "id": "f17372:c2:m17"}
{"signature": "def __del__(self):", "body": "self.destroy()<EOL>", "docstring": "Destructor: clean-up all references", "id": "f17372:c2:m2"}
{"signature": "def rebuild(self, **kwargs):", "body": "for name, value in list(kwargs.items()):<EOL><INDENT>setattr(self, name, value)<EOL><DEDENT>", "docstring": "Update a property value with (used by the designer)", "id": "f17372:c8:m4"}
{"signature": "def _getId(self):", "body": "return self.wx_obj.GetId()<EOL>", "docstring": "return the id is generated using NewId by the base wxPython control", "id": "f17372:c2:m22"}
{"signature": "def set_parent(self, new_parent, init=False):", "body": "Component.set_parent(self, new_parent, init)<EOL>if not init:<EOL><INDENT>if DEBUG: print(\"<STR_LIT>\", ctrl.name)<EOL>if hasattr(self.wx_obj, \"<STR_LIT>\"):<EOL><INDENT>self.wx_obj.Reparent(self._parent.wx_obj)<EOL><DEDENT><DEDENT>", "docstring": "Re-parent a child control with the new wx_obj parent", "id": "f17372:c5:m1"}
{"signature": "def _calc_dimension(self, dim_val, dim_max, font_dim):", "body": "if dim_val is None:<EOL><INDENT>return -<NUM_LIT:1>   <EOL><DEDENT>elif isinstance(dim_val, int):<EOL><INDENT>return dim_val  <EOL><DEDENT>elif isinstance(dim_val, str):<EOL><INDENT>if dim_val.endswith(\"<STR_LIT:%>\"):<EOL><INDENT>dim_val = int(dim_val[:-<NUM_LIT:1>])<EOL>dim_val = dim_val / <NUM_LIT> * dim_max<EOL><DEDENT>elif dim_val.endswith(\"<STR_LIT>\"):<EOL><INDENT>dim_val = float(dim_val[:-<NUM_LIT:2>])<EOL>dim_val = dim_val * font_dim<EOL><DEDENT>elif dim_val.endswith(\"<STR_LIT>\"):<EOL><INDENT>dim_val = dim_val[:-<NUM_LIT:2>]<EOL><DEDENT>elif dim_val == \"<STR_LIT>\" or dim_val == \"<STR_LIT>\":<EOL><INDENT>dim_val = -<NUM_LIT:1><EOL><DEDENT>return int(dim_val)<EOL><DEDENT>", "docstring": "Calculate final pos and size (auto, absolute in pixels & relativa)", "id": "f17372:c5:m2"}
{"signature": "def choose_directory(message='<STR_LIT>', path=\"<STR_LIT>\", parent=None):", "body": "result = dialogs.directoryDialog(parent, message, path)<EOL>return result.path<EOL>", "docstring": "Show a dialog to choose a directory", "id": "f17373:m7"}
{"signature": "def confirm(message=\"<STR_LIT>\", title=\"<STR_LIT>\", default=False, ok=False, cancel=False,<EOL>parent=None):", "body": "style = wx.CENTRE<EOL>if ok:<EOL><INDENT>style |= wx.OK <EOL><DEDENT>else:<EOL><INDENT>style |= wx.YES | wx.NO<EOL>if default:<EOL><INDENT>style |= wx.YES_DEFAULT<EOL><DEDENT>else:<EOL><INDENT>style |= wx.NO_DEFAULT<EOL><DEDENT><DEDENT>if cancel:<EOL><INDENT>style |= wx.CANCEL<EOL><DEDENT>result = dialogs.messageDialog(parent, message, title, style)<EOL>if cancel and result.returned == wx.ID_CANCEL:<EOL><INDENT>return None<EOL><DEDENT>return result.accepted<EOL>", "docstring": "Ask for confirmation (yes/no or ok and cancel), returns True or False", "id": "f17373:m2"}
{"signature": "def save_file(title=\"<STR_LIT>\",  directory='<STR_LIT>', filename='<STR_LIT>', <EOL>wildcard='<STR_LIT>', overwrite=False, parent=None):", "body": "style = wx.SAVE <EOL>if not overwrite:<EOL><INDENT>style |= wx.OVERWRITE_PROMPT<EOL><DEDENT>result = dialogs.fileDialog(parent, title, directory, filename, wildcard, <EOL>style)<EOL>return result.paths<EOL>", "docstring": "Show a dialog to select file to save, return path(s) if accepted", "id": "f17373:m6"}
{"signature": "def get_count(self):", "body": "return self.wx_obj.GetCount()<EOL>", "docstring": "Returns the number of items in the control.", "id": "f17377:c0:m17"}
{"signature": "def clear(self):", "body": "self.wx_obj.Clear()<EOL>self._items_dict = {}<EOL>", "docstring": "Removes all items from the control.", "id": "f17377:c0:m12"}
{"signature": "def set_data(self, n, data):", "body": "self.wx_obj.SetClientData(n, data)<EOL>self._items_dict[data] = self.get_string(n)<EOL>", "docstring": "Associate the given client data with the item at position n.", "id": "f17377:c0:m8"}
{"signature": "def set_max_length(self, max):", "body": "return self.wx_obj.SetMaxLength(max)<EOL>", "docstring": "sets the maximum number of characters allowed into the control", "id": "f17379:c0:m18"}
{"signature": "def clear_all(self):", "body": "self.clear()<EOL>for ch in reversed(self.columns):<EOL><INDENT>del self[ch.name]<EOL><DEDENT>", "docstring": "Remove all items and column headings", "id": "f17387:c1:m13"}
{"signature": "def GetPyData(self, item):", "body": "wx_data = self.GetItemData(item)<EOL>py_data = self._py_data_map.get(wx_data)<EOL>return py_data<EOL>", "docstring": "Returns the pyth item data associated with the item", "id": "f17387:c0:m4"}
{"signature": "def DeleteItem(self, item):", "body": "wx_data = self.GetItemData(item)<EOL>py_data = self._py_data_map[wx_data]<EOL>del self._py_data_map[wx_data]<EOL>del self._wx_data_map[py_data]<EOL>wx.ListCtrl.DeleteItem(self, item)<EOL>", "docstring": "Remove the item from the list and unset the related data", "id": "f17387:c0:m7"}
{"signature": "def draw_arc(self, x1y1, x2y2, xcyc):", "body": "self._buf_image.DrawArcPoint(x1y1, x2y2, xcyc)<EOL>if self.auto_refresh:<EOL><INDENT>dc = wx.ClientDC(self.wx_obj)<EOL>dc.BlitPointSize((<NUM_LIT:0>, <NUM_LIT:0>), (self._size[<NUM_LIT:0>], self._size[<NUM_LIT:1>]), self._buf_image, (<NUM_LIT:0>, <NUM_LIT:0>))<EOL><DEDENT>", "docstring": "Draws an arc of a circle, centered on (xc, yc), with starting\npoint (x1, y1) and ending at (x2, y2). The current pen is used\nfor the outline and the current brush for filling the shape.\n\nThe arc is drawn in an anticlockwise direction from the start\npoint to the end point.", "id": "f17390:c0:m19"}
{"signature": "def Destroy(self):", "body": "self.base_Destroy()<EOL>", "docstring": "final cleanup", "id": "f17391:c6:m13"}
{"signature": "def append(self, values):", "body": "if isinstance(values, dict):<EOL><INDENT>row = GridRow(self, **values)<EOL><DEDENT>else:<EOL><INDENT>row = GridRow(self, *values)<EOL><DEDENT>list.append(self, row)<EOL>self._grid_view.wx_obj.AppendRows(numRows=<NUM_LIT:1>)<EOL>", "docstring": "Insert a number of rows into the grid (and associated table)", "id": "f17391:c4:m2"}
{"signature": "@property<EOL><INDENT>def index(self):<DEDENT>", "body": "return self._grid_model.index(self)<EOL>", "docstring": "Get the actual position (can vary due insertion/deletions and sorting)", "id": "f17391:c5:m3"}
{"signature": "def set_parent(self, new_parent, init=False):", "body": "self._created = False<EOL>SubComponent.set_parent(self, new_parent, init)<EOL>if self.index == -<NUM_LIT:1> or self.index >= len(self._parent.columns):<EOL><INDENT>self.index = len(self._parent.columns) - <NUM_LIT:1><EOL><DEDENT>self._parent.wx_obj.AppendCols(<NUM_LIT:1>)<EOL>self._created = True<EOL>", "docstring": "Associate the header to the control (it could be recreated)", "id": "f17391:c3:m0"}
{"signature": "def UpdateValues(self, grid):", "body": "<EOL>msg = gridlib.GridTableMessage(self, <EOL>gridlib.GRIDTABLE_REQUEST_VIEW_GET_VALUES)<EOL>grid.ProcessTableMessage(msg)<EOL>", "docstring": "Update all displayed values", "id": "f17391:c2:m20"}
{"signature": "def IsAcceptedKey(self, evt):", "body": "<EOL>return (not (evt.ControlDown() or evt.AltDown()) and<EOL>evt.GetKeyCode() != wx.WXK_SHIFT)<EOL>", "docstring": "Return True to allow the given key to start editing", "id": "f17391:c6:m10"}
{"signature": "def resize(self, evt=None):", "body": "for child in self:<EOL><INDENT>if isinstance(child, Control):<EOL><INDENT>child.resize(evt)<EOL><DEDENT><DEDENT>if evt:<EOL><INDENT>evt.Skip()<EOL><DEDENT>", "docstring": "automatically adjust relative pos and size of children controls", "id": "f17392:c1:m6"}
{"signature": "def get_count(self):", "body": "return self.wx_obj.GetPageCount()<EOL>", "docstring": "Get the pages (tab) count", "id": "f17392:c0:m0"}
{"signature": "def __call__(self, wx_item=None):", "body": "if wx_item is not None:<EOL><INDENT>key = self._tree_view.wx_obj.GetPyData(wx_item)<EOL>return self[key]<EOL><DEDENT>else:<EOL><INDENT>return self.items()<EOL><DEDENT>", "docstring": "Look for a item based on the wx_item or return a key/value pair", "id": "f17393:c1:m4"}
{"signature": "def log(msg):", "body": "ctrl_output.value += msg + \"<STR_LIT:\\n>\"<EOL>", "docstring": "Append the message to the output text box control", "id": "f17398:m2"}
{"signature": "def validate_integer(self, action, index, value_if_allowed, prior_value,<EOL>text, validation_type, trigger_type, widget_name):", "body": "if(action == '<STR_LIT:1>'):<EOL><INDENT>if text in '<STR_LIT>':<EOL><INDENT>try:<EOL><INDENT>int(value_if_allowed)<EOL>return True<EOL><DEDENT>except ValueError:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return True<EOL><DEDENT>", "docstring": "Check if text Entry is valid (number).\n\n        I have no idea what all these arguments are doing here but took this from\n        https://stackoverflow.com/questions/8959815/restricting-the-value-in-tkinter-entry-widget", "id": "f17400:c2:m5"}
{"signature": "def init_logs():", "body": "start_time = dt.fromtimestamp(time.time()).strftime('<STR_LIT>')<EOL>logname = os.path.join(os.path.expanduser(\"<STR_LIT>\") + \"<STR_LIT>\" + start_time + \"<STR_LIT>\")<EOL>handlers = [logging.FileHandler(logname)]<EOL>logging.basicConfig(<EOL>format='<STR_LIT>',<EOL>handlers=handlers,<EOL>level=logging.INFO)<EOL>logging.info('<STR_LIT>'.format(__version__, nanoplot.__version__))<EOL>logging.info('<STR_LIT>'.format(sys.version.replace('<STR_LIT:\\n>', '<STR_LIT:U+0020>')))<EOL>return logname<EOL>", "docstring": "Initiate log file.", "id": "f17401:m3"}
{"signature": "def get_block_count(self, **kwargs):", "body": "return self._call(JSONRPCMethods.GET_BLOCK_COUNT.value, **kwargs)<EOL>", "docstring": "Returns the number of blocks in the chain.\n\n        :return: number of blocks in the chain\n        :rtype: int", "id": "f17404:c0:m8"}
{"signature": "def get_peers(self, **kwargs):", "body": "return self._call(JSONRPCMethods.GET_PEERS.value, **kwargs)<EOL>", "docstring": "Returns a list of nodes that the node is currently connected/disconnected from.\n\n        :return: dictionary containing the nodes the current node is connected/disconnected from\n        :rtype: dict", "id": "f17404:c0:m17"}
{"signature": "def get_block_sys_fee(self, block_index, **kwargs):", "body": "return self._call(JSONRPCMethods.GET_BLOCK_SYS_FEE.value, [block_index, ], **kwargs)<EOL>", "docstring": "Returns the system fees associated with a specific block index.\n\n        :param block_index: a block index (block height)\n        :type block_index: int\n        :return: system fees of the block, expressed in NeoGas units\n        :rtype: str", "id": "f17404:c0:m10"}
{"signature": "def get_account_state(self, address, **kwargs):", "body": "return self._call(JSONRPCMethods.GET_ACCOUNT_STATE.value, params=[address, ], **kwargs)<EOL>", "docstring": "Returns the account state information associated with a specific address.\n\n        :param address: a 34-bit length address (eg. AJBENSwajTzQtwyJFkiJSv7MAaaMc7DsRz)\n        :type address: str\n        :return: dictionary containing the account state information\n        :rtype: dict", "id": "f17404:c0:m4"}
{"signature": "def get_block_hash(self, block_index, **kwargs):", "body": "return self._call(JSONRPCMethods.GET_BLOCK_HASH.value, [block_index, ], **kwargs)<EOL>", "docstring": "Returns the hash value associated with a specific block index.\n\n        :param block_index: a block index (block height)\n        :type block_index: int\n        :return: hash of the block associated with the considered index\n        :rtype: str", "id": "f17404:c0:m9"}
{"signature": "def get_raw_mem_pool(self, **kwargs):", "body": "return self._call(JSONRPCMethods.GET_RAW_MEM_POOL.value, **kwargs)<EOL>", "docstring": "Returns a list of unconfirmed transactions in memory associated with the node.\n\n        :return: list of unconfirmed transaction hashes\n        :rtype: list", "id": "f17404:c0:m13"}
{"signature": "@classmethod<EOL><INDENT>def for_mainnet(cls):<DEDENT>", "body": "return cls(host='<STR_LIT>', port=<NUM_LIT>)<EOL>", "docstring": "Creates a ``Client`` instance for use with the NEO Main Net.", "id": "f17404:c0:m1"}
{"signature": "def get_connection_count(self, **kwargs):", "body": "return self._call(JSONRPCMethods.GET_CONNECTION_COUNT.value, **kwargs)<EOL>", "docstring": "Returns the current number of connections for the considered node.\n\n        :return: number of connections for the node\n        :rtype: int", "id": "f17404:c0:m11"}
{"signature": "def invoke_script(self, script, **kwargs):", "body": "raw_result = self._call(JSONRPCMethods.INVOKE_SCRIPT.value, [script, ], **kwargs)<EOL>return decode_invocation_result(raw_result)<EOL>", "docstring": "Invokes a script on the VM and returns the result.\n\n        :param script: script runnable by the VM\n        :type script: str\n        :return: result of the invocation\n        :rtype: dictionary", "id": "f17404:c0:m21"}
{"signature": "def get_storage(self, script_hash, key, **kwargs):", "body": "hexkey = binascii.hexlify(key.encode('<STR_LIT:utf-8>')).decode('<STR_LIT:utf-8>')<EOL>hexresult = self._call(<EOL>JSONRPCMethods.GET_STORAGE.value, params=[script_hash, hexkey, ], **kwargs)<EOL>try:<EOL><INDENT>assert hexresult<EOL>result = bytearray(binascii.unhexlify(hexresult.encode('<STR_LIT:utf-8>')))<EOL><DEDENT>except AssertionError:<EOL><INDENT>result = hexresult<EOL><DEDENT>return result<EOL>", "docstring": "Returns the value stored in the storage of a contract script hash for a given key.\n\n        :param script_hash: contract script hash\n        :param key: key to look up in the storage\n        :type script_hash: str\n        :type key: str\n        :return: value associated with the storage key\n        :rtype: bytearray", "id": "f17404:c0:m15"}
{"signature": "def check_not_bot(self, user_id):", "body": "self.small_delay()<EOL>user_id = self.convert_to_user_id(user_id)<EOL>if not user_id:<EOL><INDENT>return False<EOL><DEDENT>if user_id in self.whitelist:<EOL><INDENT>return True<EOL><DEDENT>if user_id in self.blacklist:<EOL><INDENT>return False<EOL><DEDENT>user_info = self.get_user_info(user_id)<EOL>if not user_info:<EOL><INDENT>return True  <EOL><DEDENT>skipped = self.skipped_file<EOL>if \"<STR_LIT>\" in user_info and user_info[\"<STR_LIT>\"] > self.max_following_to_block:<EOL><INDENT>msg = '<STR_LIT>'<EOL>self.console_print(msg, '<STR_LIT>')<EOL>skipped.append(user_id)<EOL>return False  <EOL><DEDENT>if search_stop_words_in_user(self, user_info):<EOL><INDENT>msg = '<STR_LIT>'<EOL>skipped.append(user_id)<EOL>return False<EOL><DEDENT>return True<EOL>", "docstring": "Filter bot from real users.", "id": "f17485:m9"}
{"signature": "def send_like(self, user_ids, thread_id=None):", "body": "user_ids = _get_user_ids(self, user_ids)<EOL>if not isinstance(user_ids, (list, str)):<EOL><INDENT>self.logger.error('<STR_LIT>')<EOL>return False<EOL><DEDENT>if self.reached_limit('<STR_LIT>'):<EOL><INDENT>self.logger.info(\"<STR_LIT>\")<EOL>return False<EOL><DEDENT>self.delay('<STR_LIT:message>')<EOL>if self.api.send_direct_item('<STR_LIT>', user_ids, thread=thread_id):<EOL><INDENT>self.total['<STR_LIT>'] += <NUM_LIT:1><EOL>return True<EOL><DEDENT>self.logger.info(\"<STR_LIT>\".format(user_ids=user_ids))<EOL>return False<EOL>", "docstring": ":param self: bot\n:param text: text of message\n:param user_ids: list of user_ids for creating group or one user_id for send to one person\n:param thread_id: thread_id", "id": "f17487:m6"}
{"signature": "def comment_user(self, user_id, amount=None):", "body": "if not self.check_user(user_id, filter_closed_acc=True):<EOL><INDENT>return False<EOL><DEDENT>self.logger.info(\"<STR_LIT>\" % user_id)<EOL>user_id = self.convert_to_user_id(user_id)<EOL>medias = self.get_user_medias(user_id, is_comment=True)<EOL>if not medias:<EOL><INDENT>self.logger.info(<EOL>\"<STR_LIT>\")<EOL>return False<EOL><DEDENT>return self.comment_medias(medias[:amount])<EOL>", "docstring": "Comments last user_id's medias", "id": "f17491:m4"}
{"signature": "def get_last_user_medias(self, user_id, count):", "body": "return get_last_user_medias(self, user_id, count)<EOL>", "docstring": "Returns the last number of posts specified in count in media ids array.\n:type count: int\n:param count: Count of posts\n:return: array", "id": "f17493:c0:m30"}
{"signature": "def delay(self, key):", "body": "last_action, target_delay = self.last[key], self.delays[key]<EOL>elapsed_time = time.time() - last_action<EOL>if elapsed_time < target_delay:<EOL><INDENT>t_remaining = target_delay - elapsed_time<EOL>time.sleep(t_remaining * random.uniform(<NUM_LIT>, <NUM_LIT>))<EOL><DEDENT>self.last[key] = time.time()<EOL>", "docstring": "Sleep only if elapsed time since `self.last[key]` < `self.delay[key]`.", "id": "f17493:c0:m14"}
{"signature": "def get_your_medias(self, as_dict=False):", "body": "return get_your_medias(self, as_dict)<EOL>", "docstring": "Returns your media ids. With parameter as_dict=True returns media as dict.\n:type as_dict: bool", "id": "f17493:c0:m24"}
{"signature": "def get_credentials(username=None):", "body": "while not check_secret():<EOL><INDENT>pass<EOL><DEDENT>while True:<EOL><INDENT>try:<EOL><INDENT>with open(SECRET_FILE, \"<STR_LIT:r>\") as f:<EOL><INDENT>lines = [line.strip().split(\"<STR_LIT::>\", <NUM_LIT:2>) for line in f.readlines()]<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>msg = '<STR_LIT>'<EOL>raise Exception(msg.format(SECRET_FILE))<EOL><DEDENT>if username is not None:<EOL><INDENT>for login, password in lines:<EOL><INDENT>if login == username.strip():<EOL><INDENT>return login, password<EOL><DEDENT><DEDENT><DEDENT>print(\"<STR_LIT>\")<EOL>for ind, (login, password) in enumerate(lines):<EOL><INDENT>print(\"<STR_LIT>\" % (ind + <NUM_LIT:1>, login))<EOL><DEDENT>print(\"<STR_LIT>\" % (<NUM_LIT:0>, \"<STR_LIT>\"))<EOL>print(\"<STR_LIT>\" % (-<NUM_LIT:1>, \"<STR_LIT>\"))<EOL>try:<EOL><INDENT>ind = int(sys.stdin.readline())<EOL>if ind == <NUM_LIT:0>:<EOL><INDENT>add_credentials()<EOL>continue<EOL><DEDENT>elif ind == -<NUM_LIT:1>:<EOL><INDENT>delete_credentials()<EOL>check_secret()<EOL>continue<EOL><DEDENT>elif <NUM_LIT:0> <= ind - <NUM_LIT:1> < len(lines):<EOL><INDENT>return lines[ind - <NUM_LIT:1>]<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>", "docstring": "Returns login and password stored in `secret.txt`.", "id": "f17506:m1"}
{"signature": "def get_pending_friendships(self):", "body": "url = '<STR_LIT>'<EOL>return self.send_request(url)<EOL>", "docstring": "Get pending follow requests", "id": "f17509:c0:m117"}
{"signature": "def get_ammo_generator(self):", "body": "af_readers = {<EOL>'<STR_LIT>': missile.AmmoFileReader,<EOL>'<STR_LIT>': missile.SlowLogReader,<EOL>'<STR_LIT>': missile.LineReader,<EOL>'<STR_LIT>': missile.UriReader,<EOL>'<STR_LIT>': missile.UriPostReader,<EOL>'<STR_LIT>': missile.AccessLogReader,<EOL>'<STR_LIT>': missile.CaseLineReader,<EOL>}<EOL>if self.uris and self.ammo_file:<EOL><INDENT>raise StepperConfigurationError(<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>elif self.uris:<EOL><INDENT>ammo_gen = missile.UriStyleGenerator(<EOL>self.uris, self.headers, http_ver=self.http_ver)<EOL><DEDENT>elif self.ammo_file:<EOL><INDENT>if self.ammo_type in af_readers:<EOL><INDENT>if self.ammo_type == '<STR_LIT>':<EOL><INDENT>opener = resource.get_opener(self.ammo_file)<EOL>with opener(self.use_cache) as ammo:<EOL><INDENT>try:<EOL><INDENT>if not ammo.next()[<NUM_LIT:0>].isdigit():<EOL><INDENT>self.ammo_type = '<STR_LIT>'<EOL>self.log.info(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>else:<EOL><INDENT>self.log.info(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT><DEDENT>except StopIteration:<EOL><INDENT>self.log.exception(<EOL>\"<STR_LIT>\")<EOL>raise AmmoFileError(<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>raise NotImplementedError(<EOL>'<STR_LIT>' % self.ammo_type)<EOL><DEDENT>ammo_gen = af_readers[self.ammo_type](<EOL>self.ammo_file, headers=self.headers, http_ver=self.http_ver, use_cache=self.use_cache)<EOL><DEDENT>else:<EOL><INDENT>raise StepperConfigurationError(<EOL>'<STR_LIT>')<EOL><DEDENT>self.log.info(\"<STR_LIT>\" % type(ammo_gen).__name__)<EOL>return ammo_gen<EOL>", "docstring": "return ammo generator", "id": "f17515:c0:m2"}
{"signature": "def get_load_plan(self):", "body": "if self.rps_schedule and self.instances_schedule:<EOL><INDENT>raise StepperConfigurationError(<EOL>'<STR_LIT>'<EOL>)<EOL><DEDENT>elif self.rps_schedule:<EOL><INDENT>info.status.publish('<STR_LIT>', self.rps_schedule)<EOL>return lp.create(self.rps_schedule)<EOL><DEDENT>elif self.instances_schedule:<EOL><INDENT>info.status.publish('<STR_LIT>', self.instances_schedule)<EOL>return ip.create(self.instances_schedule)<EOL><DEDENT>else:<EOL><INDENT>self.instances_schedule = []<EOL>info.status.publish('<STR_LIT>', self.instances_schedule)<EOL>return ip.create(self.instances_schedule)<EOL><DEDENT>", "docstring": "return load plan (timestamps generator)", "id": "f17515:c0:m1"}
{"signature": "def parse_duration(duration):", "body": "_re_token = re.compile(\"<STR_LIT>\")<EOL>def parse_token(time, multiplier):<EOL><INDENT>multipliers = {<EOL>'<STR_LIT:d>': <NUM_LIT>,<EOL>'<STR_LIT:h>': <NUM_LIT>,<EOL>'<STR_LIT:m>': <NUM_LIT>,<EOL>'<STR_LIT:s>': <NUM_LIT:1>,<EOL>}<EOL>if multiplier:<EOL><INDENT>if multiplier in multipliers:<EOL><INDENT>return int(float(time) * multipliers[multiplier] * <NUM_LIT:1000>)<EOL><DEDENT>else:<EOL><INDENT>raise StepperConfigurationError(<EOL>'<STR_LIT>' % duration)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return int(float(time) * <NUM_LIT:1000>)<EOL><DEDENT><DEDENT>return sum(parse_token(*token) for token in _re_token.findall(duration))<EOL>", "docstring": "Parse duration string, such as '3h2m3s' into milliseconds\n\n>>> parse_duration('3h2m3s')\n10923000\n\n>>> parse_duration('0.3s')\n300\n\n>>> parse_duration('5')\n5000", "id": "f17516:m1"}
{"signature": "def get_duration(self):", "body": "return sum(step.get_duration() for step in self.steps)<EOL>", "docstring": "Return total duration", "id": "f17519:c2:m2"}
{"signature": "def get_float_rps_list(self):", "body": "int_rps = range(int(self.minrps), int(self.maxrps) + <NUM_LIT:1>)<EOL>step_duration = float(self.duration) / len(int_rps)<EOL>rps_list = [(rps, int(step_duration)) for rps in int_rps]<EOL>return rps_list<EOL>", "docstring": "get list of constant load parts (we have no constant load at all, but tank will think so),\nwith parts durations (float)", "id": "f17519:c1:m6"}
{"signature": "def ts(self, n):", "body": "try:<EOL><INDENT>root1, root2 = solve_quadratic(self.slope / <NUM_LIT>, self.minrps, -n)<EOL><DEDENT>except ZeroDivisionError:<EOL><INDENT>root2 = float(n) / self.minrps<EOL><DEDENT>return int(root2 * <NUM_LIT:1000>)<EOL>", "docstring": ":param n: number of charge\n:return: when to shoot nth charge, milliseconds", "id": "f17519:c1:m1"}
{"signature": "def get_rps_list(self):", "body": "seconds = range(<NUM_LIT:0>, int(self.duration) + <NUM_LIT:1>)<EOL>rps_groups = groupby([proper_round(self.rps_at(t)) for t in seconds],<EOL>lambda x: x)<EOL>rps_list = [(rps, len(list(rpl))) for rps, rpl in rps_groups]<EOL>return rps_list<EOL>", "docstring": "get list of each second's rps\n:returns: list of tuples (rps, duration of corresponding rps in seconds)\n:rtype: list", "id": "f17519:c1:m7"}
{"signature": "def __len__(self):", "body": "return int(self.duration / <NUM_LIT:1000> * self.rps)<EOL>", "docstring": "Return total ammo count", "id": "f17519:c0:m4"}
{"signature": "def __init__(self, minrps, maxrps, duration):", "body": "self.minrps = float(minrps)<EOL>self.maxrps = float(maxrps)<EOL>self.duration = duration / <NUM_LIT><EOL>self.slope = (self.maxrps - self.minrps) / self.duration<EOL>", "docstring": ":param minrps:\n:param maxrps:\n:param duration: milliseconds", "id": "f17519:c1:m0"}
{"signature": "def create(rps_schedule):", "body": "if len(rps_schedule) > <NUM_LIT:1>:<EOL><INDENT>lp = Composite(<EOL>[StepFactory.produce(step_config) for step_config in rps_schedule])<EOL><DEDENT>else:<EOL><INDENT>lp = StepFactory.produce(rps_schedule[<NUM_LIT:0>])<EOL><DEDENT>info.status.publish('<STR_LIT>', lp.get_duration() / <NUM_LIT:1000>)<EOL>info.status.publish('<STR_LIT>', lp.get_rps_list())<EOL>info.status.lp_len = len(lp)<EOL>return lp<EOL>", "docstring": "Create Load Plan as defined in schedule. Publish info about its duration.", "id": "f17519:m0"}
{"signature": "def get_option(self, option, param2=None):", "body": "result = self.cfg[option]<EOL>self.log.debug(<EOL>\"<STR_LIT>\", option, result)<EOL>return result<EOL>", "docstring": "get_option wrapper", "id": "f17522:c3:m1"}
{"signature": "def __iter__(self):", "body": "ammo_stream = (<EOL>ammo<EOL>for ammo in ((missile, marker or self.marker(missile))<EOL>for missile, marker in self.ammo_generator)<EOL>if self.filter(ammo))<EOL>return ((timestamp, marker or self.marker(missile), missile)<EOL>for timestamp, (missile, marker<EOL>) in zip(self.load_plan, ammo_stream))<EOL>", "docstring": "Returns a generator of (timestamp, marker, missile) tuples\nwhere missile is in a string representation. Load Plan (timestamps\ngenerator) and ammo generator are taken from the previously\nconfigured ComponentFactory, passed as a parameter to the\n__init__ method of this class.", "id": "f17522:c0:m1"}
{"signature": "def init_logging(events_log_fname, verbose, quiet):", "body": "logger = logging.getLogger('<STR_LIT>')<EOL>logger.setLevel(logging.DEBUG)<EOL>console_handler = logging.StreamHandler(sys.stdout)<EOL>stderr_hdl = logging.StreamHandler(sys.stderr)<EOL>fmt_verbose = logging.Formatter(<EOL>\"<STR_LIT>\"<EOL>)<EOL>fmt_regular = logging.Formatter(<EOL>\"<STR_LIT>\", \"<STR_LIT>\")<EOL>if verbose:<EOL><INDENT>console_handler.setLevel(logging.DEBUG)<EOL>console_handler.setFormatter(fmt_verbose)<EOL>stderr_hdl.setFormatter(fmt_verbose)<EOL><DEDENT>elif quiet:<EOL><INDENT>console_handler.setLevel(logging.WARNING)<EOL>console_handler.setFormatter(fmt_regular)<EOL>stderr_hdl.setFormatter(fmt_regular)<EOL><DEDENT>else:<EOL><INDENT>console_handler.setLevel(logging.INFO)<EOL>console_handler.setFormatter(fmt_regular)<EOL>stderr_hdl.setFormatter(fmt_regular)<EOL><DEDENT>f_err = SingleLevelFilter(logging.ERROR, True)<EOL>f_warn = SingleLevelFilter(logging.WARNING, True)<EOL>f_crit = SingleLevelFilter(logging.CRITICAL, True)<EOL>console_handler.addFilter(f_err)<EOL>console_handler.addFilter(f_warn)<EOL>console_handler.addFilter(f_crit)<EOL>logger.addHandler(console_handler)<EOL>f_info = SingleLevelFilter(logging.INFO, True)<EOL>f_debug = SingleLevelFilter(logging.DEBUG, True)<EOL>stderr_hdl.addFilter(f_info)<EOL>stderr_hdl.addFilter(f_debug)<EOL>logger.addHandler(stderr_hdl)<EOL>if events_log_fname:<EOL><INDENT>err_file_handler = logging.FileHandler(events_log_fname)<EOL>err_file_handler.setLevel(logging.WARNING)<EOL>err_file_handler.setFormatter(<EOL>logging.Formatter(<EOL>\"<STR_LIT>\"<EOL>))<EOL>return [err_file_handler, console_handler, stderr_hdl]<EOL><DEDENT>else:<EOL><INDENT>return [console_handler, stderr_hdl]<EOL><DEDENT>", "docstring": "Set up logging, as it is very important for console tool", "id": "f17530:m1"}
{"signature": "def mkstemp(self, suffix, prefix, directory=None):", "body": "if not directory:<EOL><INDENT>directory = self.artifacts_dir<EOL><DEDENT>fd, fname = tempfile.mkstemp(suffix, prefix, directory)<EOL>os.close(fd)<EOL>os.chmod(fname, <NUM_LIT>)  <EOL>return fname<EOL>", "docstring": "Generate temp file name in artifacts base dir\nand close temp file handle", "id": "f17531:c2:m26"}
{"signature": "def wait_for_finish(self):", "body": "if not self.interrupted.is_set():<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>logger.info('<STR_LIT>'.format(dir=self.artifacts_dir))<EOL>self.publish(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\")<EOL>if not self.plugins:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>while not self.interrupted.is_set():<EOL><INDENT>begin_time = time.time()<EOL>aggr_retcode = self.job.aggregator.is_test_finished()<EOL>if aggr_retcode >= <NUM_LIT:0>:<EOL><INDENT>return aggr_retcode<EOL><DEDENT>for plugin in self.plugins.values():<EOL><INDENT>logger.debug(\"<STR_LIT>\", plugin)<EOL>retcode = plugin.is_test_finished()<EOL>if retcode >= <NUM_LIT:0>:<EOL><INDENT>return retcode<EOL><DEDENT><DEDENT>end_time = time.time()<EOL>diff = end_time - begin_time<EOL>logger.debug(\"<STR_LIT>\", diff)<EOL>logger.debug(\"<STR_LIT>\", json.dumps(self.status))<EOL>if diff < <NUM_LIT:0.5>:<EOL><INDENT>time.sleep(<NUM_LIT:0.5> - diff)<EOL><DEDENT><DEDENT>return <NUM_LIT:1><EOL>", "docstring": "Call is_test_finished() on all plugins 'till one of them initiates exit", "id": "f17531:c2:m10"}
{"signature": "def plugins_post_process(self, retcode):", "body": "logger.info(\"<STR_LIT>\")<EOL>self.publish(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\")<EOL>for plugin in self.plugins.values():<EOL><INDENT>logger.debug(\"<STR_LIT>\", plugin)<EOL>try:<EOL><INDENT>logger.debug(\"<STR_LIT>\", retcode)<EOL>retcode = plugin.post_process(retcode)<EOL>logger.debug(\"<STR_LIT>\", retcode)<EOL><DEDENT>except Exception:  <EOL><INDENT>logger.error(\"<STR_LIT>\", plugin, exc_info=True)<EOL>if not retcode:<EOL><INDENT>retcode = <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>return retcode<EOL>", "docstring": "Call post_process() on all plugins", "id": "f17531:c2:m12"}
{"signature": "def get_plugin_of_type(self, plugin_class):", "body": "logger.debug(\"<STR_LIT>\", plugin_class)<EOL>matches = [plugin for plugin in self.plugins.values() if isinstance(plugin, plugin_class)]<EOL>if matches:<EOL><INDENT>if len(matches) > <NUM_LIT:1>:<EOL><INDENT>logger.debug(<EOL>\"<STR_LIT>\",<EOL>plugin_class)<EOL><DEDENT>return matches[-<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>raise KeyError(\"<STR_LIT>\" % plugin_class)<EOL><DEDENT>", "docstring": "Retrieve a plugin of desired class, KeyError raised otherwise", "id": "f17531:c2:m19"}
{"signature": "def add_artifact_file(self, filename, keep_original=False):", "body": "if filename:<EOL><INDENT>logger.debug(<EOL>\"<STR_LIT>\", keep_original,<EOL>filename)<EOL>self.artifact_files[filename] = keep_original<EOL><DEDENT>", "docstring": "Add file to be stored as result artifact on post-process phase", "id": "f17531:c2:m23"}
{"signature": "def set_option(self, section, option, value):", "body": "raise NotImplementedError<EOL>", "docstring": "Set an option in storage", "id": "f17531:c2:m17"}
{"signature": "def close(self):", "body": "logger.info(\"<STR_LIT>\")<EOL>for plugin in self.plugins.values():<EOL><INDENT>logger.debug(\"<STR_LIT>\", plugin)<EOL>try:<EOL><INDENT>plugin.close()<EOL><DEDENT>except Exception as ex:<EOL><INDENT>logger.error(\"<STR_LIT>\", plugin, ex)<EOL>logger.debug(<EOL>\"<STR_LIT>\", traceback.format_exc(ex))<EOL><DEDENT><DEDENT>", "docstring": "Call close() for all plugins", "id": "f17531:c2:m28"}
{"signature": "def plugins_configure(self):", "body": "self.publish(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\")<EOL>logger.info(\"<STR_LIT>\")<EOL>self.taskset_affinity = self.get_option(self.SECTION, '<STR_LIT>')<EOL>if self.taskset_affinity:<EOL><INDENT>self.__setup_taskset(self.taskset_affinity, pid=os.getpid())<EOL><DEDENT>for plugin in self.plugins.values():<EOL><INDENT>if not self.interrupted.is_set():<EOL><INDENT>logger.debug(\"<STR_LIT>\", plugin)<EOL>plugin.configure()<EOL><DEDENT><DEDENT>", "docstring": "Call configure() on all plugins", "id": "f17531:c2:m7"}
{"signature": "def load_cfg(cfg_filename):", "body": "if is_ini(cfg_filename):<EOL><INDENT>return convert_ini(cfg_filename)<EOL><DEDENT>else:<EOL><INDENT>with open(cfg_filename) as f:<EOL><INDENT>return yaml.load(f)<EOL><DEDENT><DEDENT>", "docstring": ":type cfg_filename: str", "id": "f17533:m1"}
{"signature": "def parse_options(options):", "body": "if options is None:<EOL><INDENT>return []<EOL><DEDENT>else:<EOL><INDENT>return [<EOL>convert_single_option(key.strip(), value.strip())<EOL>for key, value<EOL>in [option.split('<STR_LIT:=>', <NUM_LIT:1>) for option in options]<EOL>]<EOL><DEDENT>", "docstring": ":type options: list of str\n:rtype: list of dict", "id": "f17533:m5"}
{"signature": "def _worker(self):", "body": "logger.debug(\"<STR_LIT>\")<EOL>try:<EOL><INDENT>self.gun.setup()<EOL><DEDENT>except Exception:<EOL><INDENT>logger.exception(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>while not self.quit.is_set():<EOL><INDENT>try:<EOL><INDENT>task = self.task_queue.get(timeout=<NUM_LIT:1>)<EOL>if not task:<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>break<EOL><DEDENT>timestamp, missile, marker = task<EOL>planned_time = self.start_time + (timestamp / <NUM_LIT>)<EOL>delay = planned_time - time.time()<EOL>if delay > <NUM_LIT:0>:<EOL><INDENT>time.sleep(delay)<EOL><DEDENT>try:<EOL><INDENT>with self.instance_counter.get_lock():<EOL><INDENT>self.instance_counter.value += <NUM_LIT:1><EOL><DEDENT>self.gun.shoot(missile, marker)<EOL><DEDENT>finally:<EOL><INDENT>with self.instance_counter.get_lock():<EOL><INDENT>self.instance_counter.value -= <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>except (KeyboardInterrupt, SystemExit):<EOL><INDENT>break<EOL><DEDENT>except Empty:<EOL><INDENT>if self.quit.is_set():<EOL><INDENT>logger.debug(\"<STR_LIT>\")<EOL>return<EOL><DEDENT><DEDENT>except Full:<EOL><INDENT>logger.warning(\"<STR_LIT>\")<EOL><DEDENT>except Exception:<EOL><INDENT>logger.exception(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>try:<EOL><INDENT>self.gun.teardown()<EOL><DEDENT>except Exception:<EOL><INDENT>logger.exception(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>logger.debug(\"<STR_LIT>\")<EOL>", "docstring": "A worker that does actual jobs", "id": "f17545:c1:m0"}
{"signature": "def running(self):", "body": "return not self.workers_finished<EOL>", "docstring": "True while there are alive workers out there. Tank\nwill quit when this would become False", "id": "f17545:c0:m2"}
{"signature": "def _green_worker(self):", "body": "while not self.quit.is_set():<EOL><INDENT>try:<EOL><INDENT>task = self.green_queue.get(timeout=<NUM_LIT:1>)<EOL>timestamp, missile, marker = task<EOL>planned_time = self.start_time + (timestamp / <NUM_LIT>)<EOL>delay = planned_time - time.time()<EOL>if delay > <NUM_LIT:0>:<EOL><INDENT>time.sleep(delay)<EOL><DEDENT>try:<EOL><INDENT>with self.instance_counter.get_lock():<EOL><INDENT>self.instance_counter.value += <NUM_LIT:1><EOL><DEDENT>self.gun.shoot(missile, marker)<EOL><DEDENT>finally:<EOL><INDENT>with self.instance_counter.get_lock():<EOL><INDENT>self.instance_counter.value -= <NUM_LIT:1><EOL><DEDENT>self._free_threads_count += <NUM_LIT:1><EOL><DEDENT><DEDENT>except (KeyboardInterrupt, SystemExit):<EOL><INDENT>break<EOL><DEDENT>except Empty:<EOL><INDENT>continue<EOL><DEDENT>except Full:<EOL><INDENT>logger.warning(\"<STR_LIT>\")<EOL><DEDENT>except Exception:<EOL><INDENT>logger.exception(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>", "docstring": "A worker that does actual jobs", "id": "f17545:c2:m1"}
{"signature": "def get_level_str(self):", "body": "if self.is_relative:<EOL><INDENT>level_str = str(<NUM_LIT:100> * self.level) + \"<STR_LIT:%>\"<EOL><DEDENT>else:<EOL><INDENT>level_str = self.level<EOL><DEDENT>return level_str<EOL>", "docstring": "format level str", "id": "f17548:c2:m5"}
{"signature": "def calc_measurement_error(self, tangents):", "body": "if len(tangents) < <NUM_LIT:2>:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>avg_tan = float(sum(tangents) / len(tangents))<EOL>numerator = float()<EOL>for i in tangents:<EOL><INDENT>numerator += (i - avg_tan) * (i - avg_tan)<EOL><DEDENT>return math.sqrt(numerator / len(tangents) / (len(tangents) - <NUM_LIT:1>))<EOL>", "docstring": "formula for measurement error\nsqrt ( (sum(1, n, (k_i - <k>)**2) / (n*(n-1)))", "id": "f17549:c6:m4"}
{"signature": "def get_level_str(self):", "body": "if self.is_relative:<EOL><INDENT>level_str = str(self.level) + \"<STR_LIT:%>\"<EOL><DEDENT>else:<EOL><INDENT>level_str = self.level<EOL><DEDENT>return level_str<EOL>", "docstring": "format level str", "id": "f17549:c2:m5"}
{"signature": "def get_level_str(self):", "body": "if self.is_relative:<EOL><INDENT>level_str = str(self.level) + \"<STR_LIT:%>\"<EOL><DEDENT>else:<EOL><INDENT>level_str = self.level<EOL><DEDENT>return level_str<EOL>", "docstring": "format level str", "id": "f17549:c5:m5"}
{"signature": "def get_counting(self):", "body": "return self.counting<EOL>", "docstring": "get criterions that are activated", "id": "f17551:c0:m2"}
{"signature": "def _exc_to_http(param1):", "body": "if len(param1) <= <NUM_LIT:3>:<EOL><INDENT>try:<EOL><INDENT>int(param1)<EOL><DEDENT>except BaseException:<EOL><INDENT>logger.error(<EOL>\"<STR_LIT>\", param1)<EOL><DEDENT>else:<EOL><INDENT>return int(param1)<EOL><DEDENT><DEDENT>exc = param1.split('<STR_LIT:U+0020>')[-<NUM_LIT:1>]<EOL>if exc in KNOWN_EXC.keys():<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>logger.warning(\"<STR_LIT>\", param1)<EOL>return <NUM_LIT:0><EOL><DEDENT>", "docstring": "translate exception str to http code", "id": "f17552:m1"}
{"signature": "def __add_jmeter_components(self, jmx, jtl, variables):", "body": "logger.debug(\"<STR_LIT>\", os.path.realpath(jmx))<EOL>with open(jmx, '<STR_LIT:r>') as src_jmx:<EOL><INDENT>source_lines = src_jmx.readlines()<EOL><DEDENT>try:<EOL><INDENT>closing = source_lines.pop(-<NUM_LIT:1>)<EOL>if \"<STR_LIT>\" in source_lines[-<NUM_LIT:5>]:<EOL><INDENT>logger.info(\"<STR_LIT>\")<EOL>last_string_count = <NUM_LIT:6><EOL><DEDENT>else:<EOL><INDENT>last_string_count = <NUM_LIT:2><EOL><DEDENT>while last_string_count > <NUM_LIT:0>:<EOL><INDENT>closing = source_lines.pop(-<NUM_LIT:1>) + closing<EOL>last_string_count -= <NUM_LIT:1><EOL><DEDENT>logger.debug(\"<STR_LIT>\", closing)<EOL><DEDENT>except Exception as exc:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\" % exc)<EOL><DEDENT>udv_tpl = resource_string(__name__, '<STR_LIT>')<EOL>udv_set = []<EOL>for var_name, var_value in variables.iteritems():<EOL><INDENT>udv_set.append(udv_tpl % (var_name, var_name, var_value))<EOL><DEDENT>udv = \"<STR_LIT:\\n>\".join(udv_set)<EOL>if self.jmeter_ver >= <NUM_LIT>:<EOL><INDENT>save_connect = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>save_connect = '<STR_LIT>'<EOL><DEDENT>if self.ext_log in ['<STR_LIT>', '<STR_LIT:all>']:<EOL><INDENT>level_map = {'<STR_LIT>': '<STR_LIT:true>', '<STR_LIT:all>': '<STR_LIT:false>'}<EOL>tpl_resource = '<STR_LIT>'<EOL>tpl_args = {<EOL>'<STR_LIT>': self.jtl_file,<EOL>'<STR_LIT>': udv,<EOL>'<STR_LIT>': self.ext_log_file,<EOL>'<STR_LIT>': level_map[self.ext_log],<EOL>'<STR_LIT>': save_connect<EOL>}<EOL><DEDENT>else:<EOL><INDENT>tpl_resource = '<STR_LIT>'<EOL>tpl_args = {<EOL>'<STR_LIT>': self.jtl_file,<EOL>'<STR_LIT>': udv,<EOL>'<STR_LIT>': save_connect<EOL>}<EOL><DEDENT>tpl = resource_string(__name__, '<STR_LIT>' + tpl_resource)<EOL>try:<EOL><INDENT>new_jmx = self.core.mkstemp(<EOL>'<STR_LIT>', '<STR_LIT>', os.path.dirname(os.path.realpath(jmx)))<EOL><DEDENT>except OSError as exc:<EOL><INDENT>logger.debug(\"<STR_LIT>\", exc)<EOL>new_jmx = self.core.mkstemp('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>logger.debug(\"<STR_LIT>\", new_jmx)<EOL>with open(new_jmx, \"<STR_LIT:wb>\") as fh:<EOL><INDENT>fh.write('<STR_LIT>'.join(source_lines))<EOL>fh.write(tpl % tpl_args)<EOL>fh.write(closing)<EOL><DEDENT>return new_jmx<EOL>", "docstring": "Genius idea by Alexey Lavrenyuk", "id": "f17553:c0:m12"}
{"signature": "def __discover_jmeter_udp_port(self):", "body": "r = re.compile(self.DISCOVER_PORT_PATTERN)<EOL>with open(self.process_stderr.name, '<STR_LIT:r>') as f:<EOL><INDENT>cnt = <NUM_LIT:0><EOL>while self.process.pid and cnt < <NUM_LIT:10>:<EOL><INDENT>line = f.readline()<EOL>m = r.match(line)<EOL>if m is None:<EOL><INDENT>cnt += <NUM_LIT:1><EOL>time.sleep(<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>port = int(m.group('<STR_LIT:port>'))<EOL>return port<EOL><DEDENT><DEDENT>else:<EOL><INDENT>logger.warning('<STR_LIT>')<EOL>return None<EOL><DEDENT><DEDENT>", "docstring": "Searching for line in jmeter.log such as\n        Waiting for possible shutdown message on port 4445", "id": "f17553:c0:m10"}
{"signature": "def _decode_stat_data(self, chunk):", "body": "for date_str, statistics in chunk.iteritems():<EOL><INDENT>date_obj = datetime.datetime.strptime(<EOL>date_str.split(\"<STR_LIT:.>\")[<NUM_LIT:0>], '<STR_LIT>')<EOL>chunk_date = int(time.mktime(date_obj.timetuple()))<EOL>instances = <NUM_LIT:0><EOL>for benchmark_name, benchmark in statistics.iteritems():<EOL><INDENT>if not benchmark_name.startswith(\"<STR_LIT>\"):<EOL><INDENT>continue<EOL><DEDENT>for method, meth_obj in benchmark.iteritems():<EOL><INDENT>if \"<STR_LIT>\" in meth_obj:<EOL><INDENT>instances += meth_obj[\"<STR_LIT>\"][<NUM_LIT:2>]<EOL><DEDENT><DEDENT><DEDENT>offset = chunk_date - <NUM_LIT:1> - self.start_time<EOL>reqps = <NUM_LIT:0><EOL>if <NUM_LIT:0> <= offset < len(self.phantom_info.steps):<EOL><INDENT>reqps = self.phantom_info.steps[offset][<NUM_LIT:0>]<EOL><DEDENT>yield self.stats_item(chunk_date - <NUM_LIT:1>, instances, reqps)<EOL><DEDENT>", "docstring": "Return all items found in this chunk", "id": "f17557:c1:m1"}
{"signature": "def compose_config(self):", "body": "streams_config = '<STR_LIT>'<EOL>stat_benchmarks = '<STR_LIT>'<EOL>for stream in self.streams:<EOL><INDENT>streams_config += stream.compose_config()<EOL>if not stream.is_main:<EOL><INDENT>stat_benchmarks += \"<STR_LIT:U+0020>\" + \"<STR_LIT>\" % stream.sequence_no<EOL><DEDENT><DEDENT>kwargs = {}<EOL>kwargs['<STR_LIT>'] = self.threads<EOL>kwargs['<STR_LIT>'] = self.phantom_log<EOL>kwargs['<STR_LIT>'] = self.stat_log<EOL>kwargs['<STR_LIT>'] = streams_config<EOL>kwargs['<STR_LIT>'] = stat_benchmarks<EOL>kwargs['<STR_LIT>'] = self.additional_libs<EOL>kwargs['<STR_LIT>'] = self.phantom_modules_path<EOL>filename = self.core.mkstemp(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>self.core.add_artifact_file(filename)<EOL>logger.debug(\"<STR_LIT>\", filename)<EOL>template_str = resource_string(__name__, \"<STR_LIT>\")<EOL>tpl = string.Template(template_str)<EOL>config = tpl.substitute(kwargs)<EOL>with open(filename, '<STR_LIT:w>') as conffile:<EOL><INDENT>conffile.write(config)<EOL><DEDENT>return filename<EOL>", "docstring": "Generate phantom tool run config", "id": "f17559:c0:m6"}
{"signature": "def read_config(self):", "body": "self.threads = self.cfg[\"<STR_LIT>\"] or str(int(multiprocessing.cpu_count() / <NUM_LIT:2>) + <NUM_LIT:1>)<EOL>self.phantom_modules_path = self.cfg[\"<STR_LIT>\"]<EOL>self.additional_libs = '<STR_LIT:U+0020>'.join(self.cfg[\"<STR_LIT>\"])<EOL>self.answ_log_level = self.cfg[\"<STR_LIT>\"]<EOL>if self.answ_log_level.lower() in ['<STR_LIT:0>', '<STR_LIT:false>']:<EOL><INDENT>self.answ_log_level = '<STR_LIT:none>'<EOL><DEDENT>elif self.answ_log_level.lower() in ['<STR_LIT:1>', '<STR_LIT:true>']:<EOL><INDENT>self.answ_log_level = '<STR_LIT:all>'<EOL><DEDENT>self.timeout = parse_duration(self.cfg[\"<STR_LIT>\"])<EOL>if self.timeout > <NUM_LIT>:<EOL><INDENT>logger.warning(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>self.answ_log = self.core.mkstemp(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>self.core.add_artifact_file(self.answ_log)<EOL>self.core.add_artifact_file(self.phout_file)<EOL>self.core.add_artifact_file(self.stat_log)<EOL>self.phantom_log = self.core.mkstemp(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>self.core.add_artifact_file(self.phantom_log)<EOL>main_stream = StreamConfig(<EOL>self.core,<EOL>len(self.streams), self.phout_file, self.answ_log,<EOL>self.answ_log_level, self.timeout, self.cfg, True)<EOL>self.streams.append(main_stream)<EOL>for section in self.multi():<EOL><INDENT>self.streams.append(<EOL>StreamConfig(<EOL>self.core,<EOL>len(self.streams), self.phout_file, self.answ_log,<EOL>self.answ_log_level, self.timeout, section))<EOL><DEDENT>for stream in self.streams:<EOL><INDENT>stream.read_config()<EOL><DEDENT>if any(stream.ssl for stream in self.streams):<EOL><INDENT>self.additional_libs += '<STR_LIT>'<EOL><DEDENT>", "docstring": "Read phantom tool specific options", "id": "f17559:c0:m3"}
{"signature": "def get_info(self):", "body": "if not self.cached_info:<EOL><INDENT>if not self.phantom:<EOL><INDENT>return None<EOL><DEDENT>self.cached_info = self.phantom.get_info()<EOL><DEDENT>return self.cached_info<EOL>", "docstring": "returns info object", "id": "f17560:c0:m14"}
{"signature": "def create_startup_config(self):", "body": "cfg_path = \"<STR_LIT>\".format(self.host)<EOL>if os.path.isfile(cfg_path):<EOL><INDENT>logger.info(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>self.host)<EOL>handle, cfg_path = tempfile.mkstemp('<STR_LIT>', '<STR_LIT>')<EOL>os.close(handle)<EOL><DEDENT>try:<EOL><INDENT>config = ConfigParser.RawConfigParser()<EOL>config.add_section('<STR_LIT>')<EOL>[<EOL>config.set('<STR_LIT>', \"<STR_LIT>\" % idx, cmd)<EOL>for idx, cmd in enumerate(self.startups)<EOL>]<EOL>config.add_section('<STR_LIT>')<EOL>[<EOL>config.set('<STR_LIT>', \"<STR_LIT>\" % idx, cmd)<EOL>for idx, cmd in enumerate(self.shutdowns)<EOL>]<EOL>config.add_section('<STR_LIT:source>')<EOL>[<EOL>config.set('<STR_LIT:source>', \"<STR_LIT>\" % idx, path)<EOL>for idx, path in enumerate(self.sources)<EOL>]<EOL>with open(cfg_path, '<STR_LIT:w>') as fds:<EOL><INDENT>config.write(fds)<EOL><DEDENT><DEDENT>except Exception as exc:<EOL><INDENT>logger.error(<EOL>'<STR_LIT>',<EOL>exc,<EOL>exc_info=True)<EOL><DEDENT>return cfg_path<EOL>", "docstring": "Startup and shutdown commands config\n        Used by agent.py on the target", "id": "f17569:c1:m1"}
{"signature": "def create_custom_exec_script(self):", "body": "cfg_path = \"<STR_LIT>\".format(self.host)<EOL>if os.path.isfile(cfg_path):<EOL><INDENT>logger.info(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>self.host)<EOL>handle, cfg_path = tempfile.mkstemp('<STR_LIT>', '<STR_LIT>')<EOL>os.close(handle)<EOL><DEDENT>cmds = \"<STR_LIT>\"<EOL>for idx, cmd in enumerate(self.custom):<EOL><INDENT>cmds += \"<STR_LIT>\".format(idx=idx, cmd=cmd['<STR_LIT>'])<EOL><DEDENT>customs_script = \"\"\"<STR_LIT>\"\"\".format(cmds=cmds)<EOL>with open(cfg_path, '<STR_LIT:w>') as fds:<EOL><INDENT>fds.write(customs_script)<EOL><DEDENT>return cfg_path<EOL>", "docstring": "bash script w/ custom commands inside\n        inspired by half a night trying to avoid escaping bash special characters", "id": "f17569:c1:m2"}
{"signature": "def prepare(self):", "body": "<EOL>agent_configs = []<EOL>if self.config:<EOL><INDENT>agent_configs = self.config_manager.getconfig(<EOL>self.config, self.default_target)<EOL><DEDENT>for config in agent_configs:<EOL><INDENT>if config['<STR_LIT:host>'] in ['<STR_LIT:localhost>', '<STR_LIT:127.0.0.1>', '<STR_LIT>']:<EOL><INDENT>client = self.clients['<STR_LIT:localhost>'](<EOL>config, self.old_style_configs, kill_old=self.kill_old)<EOL><DEDENT>else:<EOL><INDENT>client = self.clients['<STR_LIT>'](<EOL>config, self.old_style_configs, timeout=<NUM_LIT:5>, kill_old=self.kill_old)<EOL><DEDENT>logger.debug('<STR_LIT>', client.host)<EOL>agent_config, startup_config, customs_script = client.install()<EOL>if agent_config:<EOL><INDENT>self.agents.append(client)<EOL>self.artifact_files.append(agent_config)<EOL><DEDENT>if startup_config:<EOL><INDENT>self.artifact_files.append(startup_config)<EOL><DEDENT>if customs_script:<EOL><INDENT>self.artifact_files.append(customs_script)<EOL><DEDENT><DEDENT>", "docstring": "Prepare for monitoring - install agents etc", "id": "f17572:c0:m2"}
{"signature": "def signal_handler(sig, frame):", "body": "logger.warning(\"<STR_LIT>\", sig)<EOL>raise KeyboardInterrupt()<EOL>", "docstring": "required for non-tty python runs to interrupt", "id": "f17573:m0"}
{"signature": "def comparison_fn(self, arg1, arg2):", "body": "raise NotImplementedError()<EOL>", "docstring": "comparison function", "id": "f17578:c3:m3"}
{"signature": "def __handle_data_items(self, host, data):", "body": "for metric, value in data.iteritems():<EOL><INDENT>if value == '<STR_LIT>':<EOL><INDENT>self.sign[host][metric] = -<NUM_LIT:1><EOL>self.data[host][metric] = value<EOL><DEDENT>else:<EOL><INDENT>if not self.data[host].get(metric, None):<EOL><INDENT>self.sign[host][metric] = <NUM_LIT:1><EOL><DEDENT>elif float(value) > float(self.data[host][metric]):<EOL><INDENT>self.sign[host][metric] = <NUM_LIT:1><EOL><DEDENT>elif float(value) < float(self.data[host][metric]):<EOL><INDENT>self.sign[host][metric] = -<NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>self.sign[host][metric] = <NUM_LIT:0><EOL><DEDENT>self.data[host][metric] = \"<STR_LIT>\" % float(value)<EOL><DEDENT><DEDENT>", "docstring": "store metric in data tree and calc offset signs\n\n        sign < 0 is CYAN, means metric value is lower then previous,\n        sign > 1 is YELLOW, means metric value is higher then prevoius,\n        sign == 0 is WHITE, means initial or equal metric value", "id": "f17578:c2:m2"}
{"signature": "def __detect_configuration(self):", "body": "try:<EOL><INDENT>is_telegraf = self.core.get_option('<STR_LIT>', \"<STR_LIT>\")<EOL><DEDENT>except KeyError:<EOL><INDENT>is_telegraf = None<EOL><DEDENT>try:<EOL><INDENT>is_monitoring = self.core.get_option('<STR_LIT>', \"<STR_LIT>\")<EOL><DEDENT>except KeyError:<EOL><INDENT>is_monitoring = None<EOL><DEDENT>if is_telegraf and is_monitoring:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>if is_telegraf and not is_monitoring:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>if not is_telegraf and is_monitoring:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>if not is_telegraf and not is_monitoring:<EOL><INDENT>try:<EOL><INDENT>is_telegraf_dt = self.core.get_option('<STR_LIT>')<EOL><DEDENT>except NoOptionError:<EOL><INDENT>is_telegraf_dt = None<EOL><DEDENT>try:<EOL><INDENT>is_monitoring_dt = self.core.get_option('<STR_LIT>')<EOL><DEDENT>except BaseException:<EOL><INDENT>is_monitoring_dt = None<EOL><DEDENT>if is_telegraf_dt and is_monitoring_dt:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>if is_telegraf_dt and not is_monitoring_dt:<EOL><INDENT>return<EOL><DEDENT>if not is_telegraf_dt and is_monitoring_dt:<EOL><INDENT>self.core.set_option(<EOL>\"<STR_LIT>\", \"<STR_LIT>\", is_monitoring_dt)<EOL><DEDENT>if not is_telegraf_dt and not is_monitoring_dt:<EOL><INDENT>return<EOL><DEDENT><DEDENT>", "docstring": "we need to be flexible in order to determine which plugin's configuration\nspecified and make appropriate configs to metrics collector\n\n:return: SECTION name or None for defaults", "id": "f17578:c0:m4"}
{"signature": "def __make_points(self, measurement, additional_tags, ts, fields):", "body": "tags = self.tags.copy()<EOL>tags.update(additional_tags)<EOL>return {<EOL>\"<STR_LIT>\": measurement,<EOL>\"<STR_LIT>\": tags,<EOL>\"<STR_LIT:time>\": int(ts),<EOL>\"<STR_LIT>\": fields,<EOL>}<EOL>", "docstring": "Parameters\n----------\nmeasurement : string\n    measurement type (e.g. monitoring, overall_meta, net_codes, proto_codes, overall_quantiles)\nadditional_tags : dict\n    custom additional tags for this points\nts : integer\n    timestamp\nfields : dict\n    influxdb columns\n\nReturns\n-------\ndict\n    points for InfluxDB client", "id": "f17579:c0:m9"}
{"signature": "def new_job(<EOL>self,<EOL>task,<EOL>person,<EOL>tank,<EOL>target_host,<EOL>target_port,<EOL>loadscheme=None,<EOL>detailed_time=None,<EOL>notify_list=None,<EOL>trace=False):", "body": "if not notify_list:<EOL><INDENT>notify_list = []<EOL><DEDENT>data = {<EOL>'<STR_LIT>': task,<EOL>'<STR_LIT>': person,<EOL>'<STR_LIT>': tank,<EOL>'<STR_LIT:host>': target_host,<EOL>'<STR_LIT:port>': target_port,<EOL>'<STR_LIT>': loadscheme,<EOL>'<STR_LIT>': detailed_time,<EOL>'<STR_LIT>': notify_list<EOL>}<EOL>logger.debug(\"<STR_LIT>\", data)<EOL>api_timeouts = self.api_timeouts()<EOL>while True:<EOL><INDENT>try:<EOL><INDENT>response = self.__post(<EOL>\"<STR_LIT>\", data, trace=trace)[<NUM_LIT:0>]<EOL>return response['<STR_LIT>'], response['<STR_LIT>']<EOL><DEDENT>except (self.NotAvailable, self.StoppedFromOnline) as e:<EOL><INDENT>try:<EOL><INDENT>timeout = next(api_timeouts)<EOL>logger.warn(\"<STR_LIT>\" % timeout)<EOL>time.sleep(timeout)<EOL>continue<EOL><DEDENT>except StopIteration:<EOL><INDENT>logger.warn('<STR_LIT>')<EOL>raise self.JobNotCreated(e.message)<EOL><DEDENT><DEDENT>except requests.HTTPError as e:<EOL><INDENT>raise self.JobNotCreated('<STR_LIT>'.format(e.response.content))<EOL><DEDENT>except Exception as e:<EOL><INDENT>logger.warn('<STR_LIT>')<EOL>logger.warn(repr(e), )<EOL>raise self.JobNotCreated()<EOL><DEDENT><DEDENT>", "docstring": ":return: job_nr, upload_token\n:rtype: tuple", "id": "f17586:c0:m19"}
{"signature": "def __make_writer_request(<EOL>self,<EOL>params=None,<EOL>json=None,<EOL>http_method=\"<STR_LIT:POST>\",<EOL>trace=False):", "body": "request = requests.Request(<EOL>http_method,<EOL>self.writer_url,<EOL>params=params,<EOL>json=json,<EOL>headers={<EOL>'<STR_LIT>': self.user_agent})<EOL>ids = id_gen(str(uuid.uuid4()))<EOL>network_timeouts = self.network_timeouts()<EOL>maintenance_timeouts = self.maintenance_timeouts()<EOL>while True:<EOL><INDENT>try:<EOL><INDENT>response = self.__send_single_request(request, ids.next(), trace=trace)<EOL>return response<EOL><DEDENT>except (Timeout, ConnectionError, ProtocolError):<EOL><INDENT>logger.warn(traceback.format_exc())<EOL>try:<EOL><INDENT>timeout = next(network_timeouts)<EOL>logger.warn(<EOL>\"<STR_LIT>\" %<EOL>timeout)<EOL>time.sleep(timeout)<EOL>continue<EOL><DEDENT>except StopIteration:<EOL><INDENT>raise self.NetworkError()<EOL><DEDENT><DEDENT>except self.UnderMaintenance as e:<EOL><INDENT>try:<EOL><INDENT>timeout = next(maintenance_timeouts)<EOL>logger.warn(<EOL>\"<STR_LIT>\" %<EOL>timeout)<EOL>time.sleep(timeout)<EOL>continue<EOL><DEDENT>except StopIteration:<EOL><INDENT>raise e<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Send request to writer service.", "id": "f17586:c0:m12"}
{"signature": "def _read_data(self, lines):", "body": "results = []<EOL>for line in lines:<EOL><INDENT>timestamp, rps, instances = line.split(\"<STR_LIT:\\t>\")<EOL>curr_ts = int(float(timestamp))  <EOL>if self.__last_ts < curr_ts:<EOL><INDENT>self.__last_ts = curr_ts<EOL>results.append(self.stats_item(self.__last_ts, float(rps), float(instances)))<EOL><DEDENT><DEDENT>return results<EOL>", "docstring": "Parse lines and return stats", "id": "f17589:c2:m1"}
{"signature": "def render(self):", "body": "raise RuntimeError(\"<STR_LIT>\")<EOL>", "docstring": "Render method, fills .lines and .width properties with rendered data", "id": "f17590:c3:m4"}
{"signature": "def add_second_data(self, data):", "body": "self.left_panel.add_second(data)<EOL>", "docstring": "Notification method about new aggregator data", "id": "f17590:c2:m6"}
{"signature": "def add_second(self, data):", "body": "pass<EOL>", "docstring": "Notification about new aggregate data", "id": "f17590:c3:m1"}
{"signature": "def __get_right_line(self, widget_output):", "body": "right_line = '<STR_LIT>'<EOL>if widget_output:<EOL><INDENT>right_line = widget_output.pop(<NUM_LIT:0>)<EOL>if len(right_line) > self.right_panel_width:<EOL><INDENT>right_line_plain = self.markup.clean_markup(right_line)<EOL>if len(right_line_plain) > self.right_panel_width:<EOL><INDENT>right_line = right_line[:self.right_panel_width] + self.markup.RESET<EOL><DEDENT><DEDENT><DEDENT>return right_line<EOL>", "docstring": "Gets next line for right panel", "id": "f17590:c2:m1"}
{"signature": "def clean_markup(self, orig_str):", "body": "for val in self.get_markup_vars():<EOL><INDENT>orig_str = orig_str.replace(val, '<STR_LIT>')<EOL><DEDENT>return orig_str<EOL>", "docstring": "clean markup from string", "id": "f17592:c1:m1"}
{"signature": "def get_default_configs(self):", "body": "<EOL>configs = [resource_filename(__name__, '<STR_LIT>')]<EOL>try:<EOL><INDENT>conf_files = sorted(os.listdir(self.baseconfigs_location))<EOL>for filename in conf_files:<EOL><INDENT>if fnmatch.fnmatch(filename, '<STR_LIT>'):<EOL><INDENT>configs += [<EOL>os.path.realpath(<EOL>self.baseconfigs_location + os.sep + filename)<EOL>]<EOL><DEDENT><DEDENT><DEDENT>except OSError:<EOL><INDENT>self.log.warn(<EOL>self.baseconfigs_location + '<STR_LIT>')<EOL><DEDENT>configs += [os.path.expanduser('<STR_LIT>')]<EOL>return configs<EOL>", "docstring": "returns default configs list, from /etc, home dir and package_data", "id": "f17596:c0:m5"}
{"signature": "def __add_user_options(self):", "body": "if self.options.get('<STR_LIT>', None):<EOL><INDENT>self.core.apply_shorthand_options(self.options['<STR_LIT>'])<EOL><DEDENT>", "docstring": "override config options with user specified options", "id": "f17596:c0:m2"}
{"signature": "def combine_sections(sections):", "body": "PLUGINS_TO_COMBINE = {<EOL>'<STR_LIT>': ('<STR_LIT>', '<STR_LIT>', True),<EOL>'<STR_LIT>': ('<STR_LIT>', '<STR_LIT>', False)<EOL>}<EOL>plugins = {}<EOL>ready_sections = []<EOL>for section in sections:<EOL><INDENT>if section.plugin in PLUGINS_TO_COMBINE.keys():<EOL><INDENT>try:<EOL><INDENT>plugins[section.plugin].append(section)<EOL><DEDENT>except KeyError:<EOL><INDENT>plugins[section.plugin] = [section]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>ready_sections.append(section)<EOL><DEDENT><DEDENT>for plugin_name, _sections in plugins.items():<EOL><INDENT>if isinstance(_sections, list):<EOL><INDENT>parent_name, child_name, is_list = PLUGINS_TO_COMBINE[plugin_name]<EOL>ready_sections.append(Section.from_multiple(_sections, parent_name, child_name, is_list))<EOL><DEDENT><DEDENT>return ready_sections<EOL>", "docstring": ":type sections: list of Section\n:rtype: list of Section", "id": "f17599:m17"}
{"signature": "def enable_sections(sections, core_opts):", "body": "DEPRECATED_PLUGINS = ['<STR_LIT>', '<STR_LIT>']<EOL>plugin_instances = [PluginInstance(key.split('<STR_LIT:_>')[<NUM_LIT:1>], value) for key, value in core_opts if<EOL>key.startswith(PLUGIN_PREFIX) and value not in DEPRECATED_PLUGINS]<EOL>enabled_instances = {instance.section_name: instance for instance in plugin_instances if instance.enabled}<EOL>disabled_instances = {instance.section_name: instance for instance in plugin_instances if not instance.enabled}<EOL>for section in sections:<EOL><INDENT>if section.name in enabled_instances.keys():<EOL><INDENT>section.enabled = True<EOL>enabled_instances.pop(section.name)<EOL><DEDENT>elif section.name in disabled_instances.keys():<EOL><INDENT>section.enabled = False<EOL>disabled_instances.pop(section.name)<EOL><DEDENT><DEDENT>for plugin_instance in [i for i in plugin_instances if<EOL>i.section_name in enabled_instances.keys() + disabled_instances.keys()]:<EOL><INDENT>sections.append(Section(plugin_instance.section_name, plugin_instance.plugin_name, [], plugin_instance.enabled))<EOL><DEDENT>return sections<EOL>", "docstring": ":type sections: list of Section", "id": "f17599:m15"}
{"signature": "def parse_sections(cfg_ini):", "body": "return [Section(section.lower(),<EOL>guess_plugin(section.lower()),<EOL>without_defaults(cfg_ini, section))<EOL>for section in cfg_ini.sections()<EOL>if not re.match(CORE_SECTION_PATTERN, section.lower()) and section.lower() not in DEPRECATED_SECTIONS]<EOL>", "docstring": ":type cfg_ini: ConfigParser", "id": "f17599:m14"}
{"signature": "def without_deprecated(plugin, options):", "body": "return filter(lambda option: not is_option_deprecated(plugin, option[<NUM_LIT:0>]), options)<EOL>", "docstring": ":type options: list of tuple", "id": "f17599:m9"}
{"signature": "@staticmethod<EOL><INDENT>def title(content, new_line_replacement='<STR_LIT:U+0020>', tab_replacement='<STR_LIT:U+0020>'):<DEDENT>", "body": "prepared_content = content.strip().replace('<STR_LIT:\\n>', new_line_replacement).replace('<STR_LIT:\\t>', tab_replacement)<EOL>return u'<STR_LIT>'.format(prepared_content, '<STR_LIT:=>' * len(prepared_content))<EOL>", "docstring": "Underlines content with '='. New lines and tabs will be replaced\n:param str content:\n:param str new_line_replacement:\n:param str tab_replacement:\n:return: unicode", "id": "f17603:c1:m4"}
{"signature": "@staticmethod<EOL><INDENT>def any_of_table(blocks):<DEDENT>", "body": "HEADER = '<STR_LIT>'<EOL>cnt = len(blocks)<EOL>if cnt < <NUM_LIT:2>:<EOL><INDENT>return blocks[<NUM_LIT:0>] if blocks else '<STR_LIT>'<EOL><DEDENT>width = max((len(HEADER), sum([c.padded_width for c in blocks]))) + (cnt + <NUM_LIT:1>)<EOL>height = max([c.height for c in blocks])<EOL>top_bar = '<STR_LIT>'.format('<STR_LIT:->' * (width - <NUM_LIT:2>))<EOL>header_bar = '<STR_LIT>'.format('<STR_LIT:+>'.join(['<STR_LIT:=>' * c.padded_width for c in blocks]))<EOL>bottom_bar = '<STR_LIT>'.format('<STR_LIT:+>'.join(['<STR_LIT:->' * c.padded_width for c in blocks]))<EOL>header = '<STR_LIT>'.format(HEADER.center(width - <NUM_LIT:2>))<EOL>body = '<STR_LIT:\\n>'.join(<EOL>['<STR_LIT>'.format('<STR_LIT>'.join([c.get_line_justified(i) for c in blocks])) for i in range(height)])<EOL>return '<STR_LIT:\\n>'.join([top_bar,<EOL>header,<EOL>header_bar,<EOL>body,<EOL>bottom_bar])<EOL>", "docstring": ":type blocks: list of TextBlock", "id": "f17603:c1:m1"}
{"signature": "def render_body(renderer, option_kwargs, exclude_keys, special_keys=None):", "body": "common_formatters = {<EOL>EXAMPLES: lambda examples: renderer.def_list({renderer.mono(example): annotation for example, annotation in examples.items()})<EOL>}<EOL>def default_fmt(x):<EOL><INDENT>return x<EOL><DEDENT>special_keys = special_keys or {}<EOL>special_part = '<STR_LIT:\\n>'.join([special_handler(renderer, option_kwargs[special_key])<EOL>for special_key, special_handler in special_keys.items()<EOL>if special_key in option_kwargs])<EOL>common_part = renderer.field_list({k: common_formatters.get(k, default_fmt)(v) for k, v in option_kwargs.items()<EOL>if k not in exclude_keys + special_keys.keys()})<EOL>return '<STR_LIT:\\n>'.join([_ for _ in [common_part, special_part] if _])<EOL>", "docstring": ":type option_kwargs: dict\n:type exclude_keys: list\n:type special_keys: dict", "id": "f17603:m1"}
{"signature": "@staticmethod<EOL><INDENT>def _list_item(block):<DEDENT>", "body": "return '<STR_LIT>' + '<STR_LIT>'.join(block.lines)<EOL>", "docstring": ":type block: TextBlock", "id": "f17603:c1:m9"}
{"signature": "def explain(self):", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "long explanation to show after test stop", "id": "f17615:c4:m4"}
{"signature": "def get_info(self):", "body": "return self.Info(**self.DEFAULT_INFO)<EOL>", "docstring": ":rtype: GeneratorPlugin.Info", "id": "f17615:c5:m1"}
{"signature": "def publish(self, key, value):", "body": "self.log.debug(<EOL>\"<STR_LIT>\", self.__class__.__name__, key, value)<EOL>self.core.publish(self.__class__.__name__, key, value)<EOL>", "docstring": "publish value to status", "id": "f17615:c0:m14"}
{"signature": "def close(self):", "body": "pass<EOL>", "docstring": "Release allocated resources here.\nWarning: don't do any logic or potentially dangerous operations", "id": "f17615:c0:m15"}
{"signature": "def get_available_options(self):", "body": "return []<EOL>", "docstring": "returns array containing known options for plugin", "id": "f17615:c0:m12"}
{"signature": "def add_cleanup(self, action):", "body": "assert callable(action)<EOL>self._cleanup_actions.append(action)<EOL>", "docstring": ":type action: function", "id": "f17615:c0:m7"}
{"signature": "def ip_v4():", "body": "return '<STR_LIT:.>'.join([str(random.randint(<NUM_LIT:0>, <NUM_LIT:255>)) for i in xrange(<NUM_LIT:0>, <NUM_LIT:4>)])<EOL>", "docstring": "Random IPv4 address.", "id": "f17635:m5"}
{"signature": "def email_address(user=None):", "body": "if not user:<EOL><INDENT>user = user_name()<EOL><DEDENT>else:<EOL><INDENT>user = user.strip().replace('<STR_LIT:U+0020>', '<STR_LIT:_>').lower()<EOL><DEDENT>return user + '<STR_LIT:@>' + domain_name()<EOL>", "docstring": "Random e-mail address in a hopefully imaginary domain.\n\nIf `user` is ``None`` :py:func:`~user_name()` will be used. Otherwise it \nwill be lowercased and will have spaces replaced with ``_``.\n\nDomain name is created using :py:func:`~domain_name()`.", "id": "f17635:m3"}
{"signature": "def cctld():", "body": "return random.choice(get_dictionary('<STR_LIT>')).strip()<EOL>", "docstring": "Random country code TLD.", "id": "f17635:m4"}
{"signature": "def domain_name():", "body": "result = random.choice(get_dictionary('<STR_LIT>')).strip()<EOL>result += '<STR_LIT:.>' + top_level_domain()<EOL>return result.lower()<EOL>", "docstring": "Random domain name.\n\nLowercased result of :py:func:`~forgery_py.forgery.name.company_name()` \nplus :py:func:`~top_level_domain()`.", "id": "f17635:m2"}
{"signature": "def title(words_quantity=<NUM_LIT:4>):", "body": "result = words(quantity=words_quantity)<EOL>result += random.choice('<STR_LIT>')<EOL>return result.capitalize()<EOL>", "docstring": "Random sentence to be used as e.g. an e-mail subject.", "id": "f17636:m2"}
{"signature": "def paragraph(separator='<STR_LIT>', wrap_start='<STR_LIT>', wrap_end='<STR_LIT>',<EOL>html=False, sentences_quantity=<NUM_LIT:3>):", "body": "return paragraphs(quantity=<NUM_LIT:1>, separator=separator, wrap_start=wrap_start,<EOL>wrap_end=wrap_end, html=html,<EOL>sentences_quantity=sentences_quantity)<EOL>", "docstring": "Random paragraph.", "id": "f17636:m5"}
{"signature": "def sentences(quantity=<NUM_LIT:2>, as_list=False):", "body": "result = [sntc.strip() for sntc in<EOL>random.sample(get_dictionary('<STR_LIT>'), quantity)]<EOL>if as_list:<EOL><INDENT>return result<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT:U+0020>'.join(result)<EOL><DEDENT>", "docstring": "Random sentences.", "id": "f17636:m4"}
{"signature": "def male_first_name():", "body": "return random.choice(get_dictionary('<STR_LIT>')).strip()<EOL>", "docstring": "Random male first name.", "id": "f17637:m3"}
{"signature": "def industry():", "body": "return random.choice(get_dictionary('<STR_LIT>')).strip()<EOL>", "docstring": "Random industry name.", "id": "f17637:m11"}
{"signature": "def month(abbr=False, numerical=False):", "body": "if numerical:<EOL><INDENT>return random.randint(<NUM_LIT:1>, <NUM_LIT:12>)<EOL><DEDENT>else:<EOL><INDENT>if abbr:<EOL><INDENT>return random.choice(MONTHS_ABBR)<EOL><DEDENT>else:<EOL><INDENT>return random.choice(MONTHS)<EOL><DEDENT><DEDENT>", "docstring": "Random (abbreviated if `abbr`) month name or month number if \n`numerical`.", "id": "f17638:m1"}
{"signature": "def year(past=False, min_delta=<NUM_LIT:0>, max_delta=<NUM_LIT:20>):", "body": "return datetime.date.today().year + _delta(past, min_delta, max_delta)<EOL>", "docstring": "Random year.", "id": "f17638:m3"}
{"signature": "def hex_color():", "body": "return '<STR_LIT>'.join(random.sample(HEX_DIGITS, <NUM_LIT:6>))<EOL>", "docstring": "Random HEX color.", "id": "f17640:m0"}
{"signature": "def hex_color_short():", "body": "return '<STR_LIT>'.join(random.sample(HEX_DIGITS, <NUM_LIT:3>))<EOL>", "docstring": "Random short (e.g. `FFF` color).", "id": "f17640:m1"}
{"signature": "def language():", "body": "return random.choice(get_dictionary('<STR_LIT>')).strip()<EOL>", "docstring": "Random language name, e.g. ``Polish``.", "id": "f17642:m4"}
{"signature": "def street_suffix():", "body": "return random.choice(get_dictionary('<STR_LIT>')).strip()<EOL>", "docstring": "Random street suffix.", "id": "f17643:m2"}
{"signature": "def phone():", "body": "format = '<STR_LIT>'<EOL>result = '<STR_LIT>'<EOL>for item in format:<EOL><INDENT>if item == '<STR_LIT:#>':<EOL><INDENT>result += str(random.randint(<NUM_LIT:0>, <NUM_LIT:9>))<EOL><DEDENT>else:<EOL><INDENT>result += item<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Random phone number in `#-(###)###-####` format.", "id": "f17643:m8"}
{"signature": "def country():", "body": "return random.choice(get_dictionary('<STR_LIT>')).strip()<EOL>", "docstring": "Random country name.", "id": "f17643:m9"}
{"signature": "def state():", "body": "return random.choice(get_dictionary('<STR_LIT>')).strip()<EOL>", "docstring": "Random US state name.", "id": "f17643:m5"}
{"signature": "def deep_update(d, u):", "body": "for k, v in u.items():<EOL><INDENT>if isinstance(v, Mapping):<EOL><INDENT>d[k] = deep_update(d.get(k, {}), v)<EOL><DEDENT>elif isinstance(v, list):<EOL><INDENT>existing_elements = d.get(k, [])<EOL>d[k] = existing_elements + [ele for ele in v if ele not in existing_elements]<EOL><DEDENT>else:<EOL><INDENT>d[k] = v<EOL><DEDENT><DEDENT>return d<EOL>", "docstring": "Deeply updates a dictionary. List values are concatenated.\n\n    Args:\n      d (dict): First dictionary which will be updated\n      u (dict): Second dictionary use to extend the first one\n\n    Returns:\n      dict: The merge dictionary", "id": "f17655:m0"}
{"signature": "def get_context(self, value):", "body": "context = super(RenditionAwareStructBlock, self).get_context(value)<EOL>context['<STR_LIT>'] = self.rendition.image_rendition or '<STR_LIT>'<EOL>return context<EOL>", "docstring": "Ensure `image_rendition` is added to the global context.", "id": "f17675:c2:m0"}
{"signature": "def register_block(self, block_type, block):", "body": "self._verify_block(block_type, block)<EOL>self._registry[block_type] = block<EOL>", "docstring": "Registers `block` to `block_type` in the registry.", "id": "f17681:c3:m2"}
{"signature": "async def post_guild_count(<EOL>self,<EOL>shard_count: int = None,<EOL>shard_no: int = None<EOL>):", "body": "await self.http.post_guild_count(self.bot_id, self.guild_count(), shard_count, shard_no)<EOL>", "docstring": "This function is a coroutine.\n\n        Posts the guild count to discordbots.org\n\n        .. _0 based indexing : https://en.wikipedia.org/wiki/Zero-based_numbering\n\n        Parameters\n        ==========\n\n        shard_count: int[Optional]\n            The total number of shards.\n        shard_no: int[Optional]\n            The index of the current shard. DBL uses `0 based indexing`_ for shards.", "id": "f17684:c0:m4"}
{"signature": "async def get_bot_info(self, bot_id: int = None):", "body": "if bot_id is None:<EOL><INDENT>bot_id = self.bot_id<EOL><DEDENT>return await self.http.get_bot_info(bot_id)<EOL>", "docstring": "This function is a coroutine.\n\n        Gets information about a bot from discordbots.org\n\n        Parameters\n        ==========\n\n        bot_id: int[Optional]\n            The bot_id of the bot you want to lookup.\n\n        Returns\n        =======\n\n        bot_info: dict\n            Information on the bot you looked up.\n            https://discordbots.org/api/docs#bots", "id": "f17684:c0:m7"}
{"signature": "async def generate_widget_large(<EOL>self,<EOL>bot_id: int = None,<EOL>top: str = '<STR_LIT>',<EOL>mid: str = '<STR_LIT>',<EOL>user: str = '<STR_LIT>',<EOL>cert: str = '<STR_LIT>',<EOL>data: str = '<STR_LIT>',<EOL>label: str = '<STR_LIT>',<EOL>highlight: str = '<STR_LIT>'<EOL>):", "body": "url = '<STR_LIT>'<EOL>if bot_id is None:<EOL><INDENT>bot_id = self.bot_id<EOL><DEDENT>url = url.format(bot_id, top, mid, user, cert, data, label, highlight)<EOL>return url<EOL>", "docstring": "This function is a coroutine.\n\n        Generates a custom large widget. Do not add `#` to the color codes (e.g. #FF00FF become FF00FF).\n\n        Parameters\n        ==========\n\n        bot_id: int\n            The bot_id of the bot you wish to make a widget for.\n        top: str\n            The hex color code of the top bar.\n        mid: str\n            The hex color code of the main section.\n        user: str\n            The hex color code of the username text.\n        cert: str\n            The hex color code of the certified text (if applicable).\n        data: str\n            The hex color code of the statistics (numbers only e.g. 44) of the bot.\n        label: str\n            The hex color code of the description (text e.g. guild count) of the statistics.\n        highlight: str\n            The hex color code of the data boxes.\n\n        Returns\n        =======\n\n        URL of the widget: str", "id": "f17684:c0:m10"}
{"signature": "async def get_guild_count(self, bot_id: int=None):", "body": "if bot_id is None:<EOL><INDENT>bot_id = self.bot_id<EOL><DEDENT>return await self.http.get_guild_count(bot_id)<EOL>", "docstring": "This function is a coroutine.\n\n        Gets a guild count from discordbots.org\n\n        Parameters\n        ==========\n\n        bot_id: int[Optional]\n            The bot_id of the bot you want to lookup.\n            Defaults to the Bot provided in Client init\n\n        Returns\n        =======\n\n        stats: dict\n            The guild count and shards of a bot.\n            The date object is returned in a datetime.datetime object", "id": "f17684:c0:m5"}
{"signature": "async def limited(until):", "body": "duration = int(round(until - time.time()))<EOL>mins = duration / <NUM_LIT><EOL>fmt = '<STR_LIT>'<EOL>log.warn(fmt, duration, mins)<EOL>", "docstring": "Handles the message shown when we are ratelimited", "id": "f17686:m1"}
{"signature": "async def request(self, method, url, **kwargs):", "body": "rate_limiter = RateLimiter(max_calls=<NUM_LIT>, period=<NUM_LIT>, callback=limited)<EOL>async with rate_limiter:  <EOL><INDENT>if not self.token:<EOL><INDENT>raise UnauthorizedDetected('<STR_LIT>')<EOL><DEDENT>headers = {<EOL>'<STR_LIT>': self.user_agent,<EOL>'<STR_LIT:Content-Type>': '<STR_LIT:application/json>'<EOL>}<EOL>if '<STR_LIT>' in kwargs:<EOL><INDENT>kwargs['<STR_LIT:data>'] = to_json(kwargs.pop('<STR_LIT>'))<EOL><DEDENT>kwargs['<STR_LIT>'] = headers<EOL>headers['<STR_LIT>'] = self.token<EOL>for tries in range(<NUM_LIT:5>):<EOL><INDENT>async with self.session.request(method, url, **kwargs) as resp:<EOL><INDENT>log.debug('<STR_LIT>', method,<EOL>url, kwargs.get('<STR_LIT:data>'), resp.status)<EOL>data = await json_or_text(resp)<EOL>if <NUM_LIT> > resp.status >= <NUM_LIT:200>:<EOL><INDENT>return data<EOL><DEDENT>if resp.status == <NUM_LIT>:  <EOL><INDENT>fmt = '<STR_LIT>'<EOL>retry_after = json.loads(resp.headers.get('<STR_LIT>'))<EOL>mins = retry_after / <NUM_LIT><EOL>log.warning(fmt, retry_after, mins)<EOL>is_global = True  <EOL>if is_global:<EOL><INDENT>self._global_over.clear()<EOL><DEDENT>await asyncio.sleep(retry_after, loop=self.loop)<EOL>log.debug('<STR_LIT>')<EOL>if is_global:<EOL><INDENT>self._global_over.set()<EOL>log.debug('<STR_LIT>')<EOL><DEDENT>continue<EOL><DEDENT>if resp.status == <NUM_LIT>:<EOL><INDENT>raise HTTPException(resp, data)<EOL><DEDENT>elif resp.status == <NUM_LIT>:<EOL><INDENT>raise Unauthorized(resp, data)<EOL><DEDENT>elif resp.status == <NUM_LIT>:<EOL><INDENT>raise Forbidden(resp, data)<EOL><DEDENT>elif resp.status == <NUM_LIT>:<EOL><INDENT>raise NotFound(resp, data)<EOL><DEDENT>else:<EOL><INDENT>raise HTTPException(resp, data)<EOL><DEDENT><DEDENT><DEDENT>raise HTTPException(resp, data)<EOL><DEDENT>", "docstring": "Handles requests to the API", "id": "f17686:c0:m1"}
{"signature": "async def get_bots(self, limit, offset):", "body": "if limit > <NUM_LIT>:<EOL><INDENT>limit = <NUM_LIT:50><EOL><DEDENT>return await self.request('<STR_LIT:GET>', '<STR_LIT>'.format(self.BASE, limit, offset))<EOL>", "docstring": "Gets an object of bots on DBL", "id": "f17686:c0:m9"}
{"signature": "def _create_bundle(self, data):", "body": "kwargs = {}<EOL>filters = None<EOL>if isinstance(data, dict):<EOL><INDENT>kwargs.update(<EOL>filters=data.get('<STR_LIT>', None),<EOL>output=data.get('<STR_LIT>', None),<EOL>debug=data.get('<STR_LIT>', None),<EOL>extra=data.get('<STR_LIT>', {}),<EOL>config=data.get('<STR_LIT>', {}),<EOL>depends=data.get('<STR_LIT>', None))<EOL><DEDENT>bundle = Bundle(*list(self._yield_bundle_contents(data)), **kwargs)<EOL>return self._auto_filter_bundle(bundle)<EOL>", "docstring": "Return a bundle initialised by the given dict.", "id": "f17692:c2:m6"}
{"signature": "def _yield_bundle_contents(self, data):", "body": "if isinstance(data, list):<EOL><INDENT>contents = data<EOL><DEDENT>else:<EOL><INDENT>contents = data.get('<STR_LIT>', [])<EOL>if isinstance(contents, six.string_types):<EOL><INDENT>contents = contents,<EOL><DEDENT><DEDENT>for content in contents:<EOL><INDENT>if isinstance(content, dict):<EOL><INDENT>content = self._create_bundle(content)<EOL><DEDENT>yield content<EOL><DEDENT>", "docstring": "Yield bundle contents from the given dict.\n\n        Each item yielded will be either a string representing a file path\n        or a bundle.", "id": "f17692:c2:m5"}
{"signature": "def encode_bytes(obj, nsprefix=None):", "body": "node = encode_xml(obj, nsprefix)<EOL>return etree.tostring(node)<EOL>", "docstring": "Encodes an OpenMath element into a string.\n\n    :param obj: Object to encode as string.\n    :type obj: OMAny\n\n    :rtype: bytes", "id": "f17706:m1"}
{"signature": "def register_to_openmath(self, py_class, converter):", "body": "if py_class is not None and not isclass(py_class):<EOL><INDENT>raise TypeError('<STR_LIT>' % py_class)<EOL><DEDENT>if not callable(converter) and not isinstance(converter, om.OMAny):<EOL><INDENT>raise TypeError('<STR_LIT>' % converter)<EOL><DEDENT>self._conv_to_om.append((py_class, converter))<EOL>", "docstring": "Register a conversion from Python to OpenMath\n\n        :param py_class: A Python class the conversion is attached to, or None\n        :type py_class: None, type\n\n        :param converter: A conversion function or an OpenMath object\n        :type converter: Callable, OMAny\n\n        :rtype: None\n\n        ``converter`` will used to convert any object of type ``py_class``,\n        or any object if ``py_class`` is ``None``. If ``converter`` is an\n        OpenMath object, it is returned immediately. If it is a callable, it\n        is called with the Python object as paramter; in this case, it must\n        either return an OpenMath object, or raise an exception.  The\n        special exception ``CannotConvertError`` can be used to signify that\n        ``converter`` does not know how to convert the current object, and that\n        ``to_openmath`` shall continue with the other converters. Any other\n        exception stops conversion immediately.\n\n        Converters registered by this function are called in order from the\n        most recent to the oldest.", "id": "f17707:c0:m9"}
{"signature": "def __call__(self, *args, **kwargs):", "body": "kwargs.update({\"<STR_LIT>\": self,  '<STR_LIT>': list(args)})<EOL>return OMApplication(**kwargs)<EOL>", "docstring": "Create an OpenMath Application Object using this object", "id": "f17708:c1:m7"}
{"signature": "def __getitem__(self, name):", "body": "return self.__getattr__(name)<EOL>", "docstring": "same as self.__getattr__", "id": "f17711:c2:m4"}
{"signature": "def interpretAsOpenMath(x):", "body": "if hasattr(x, \"<STR_LIT>\") and x._ishelper:<EOL><INDENT>return x._toOM()<EOL><DEDENT>elif isinstance(x, om.OMAny):<EOL><INDENT>return x<EOL><DEDENT>elif isinstance(x, six.integer_types):<EOL><INDENT>return om.OMInteger(x)<EOL><DEDENT>elif isinstance(x, float):<EOL><INDENT>return om.OMFloat(x)<EOL><DEDENT>elif isinstance(x, six.string_types):<EOL><INDENT>return om.OMString(x)<EOL><DEDENT>elif isinstance(x, WrappedHelper):<EOL><INDENT>return x.toOM()<EOL><DEDENT>elif inspect.isfunction(x):<EOL><INDENT>paramMap = inspect.signature(x).parameters<EOL>params = [v for k, v in six.iteritems(paramMap)]<EOL>posArgKinds = [inspect.Parameter.POSITIONAL_ONLY, inspect.Parameter.POSITIONAL_OR_KEYWORD]<EOL>if not all([p.kind in posArgKinds for p in params]):<EOL><INDENT>raise CannotInterpretAsOpenMath(\"<STR_LIT>\")<EOL><DEDENT>paramsOM = [om.OMVariable(name=p.name) for p in params]<EOL>bodyOM = interpretAsOpenMath(x(*paramsOM))<EOL>return OMBinding(om.OMSymbol(name=\"<STR_LIT>\", cd=\"<STR_LIT>\", cdbase=\"<STR_LIT>\"), paramsOM, bodyOM)<EOL><DEDENT>else:<EOL><INDENT>raise CannotInterpretAsOpenMath(\"<STR_LIT>\" + str(x))<EOL><DEDENT>", "docstring": "tries to convert a Python object into an OpenMath object\n    this is not a replacement for using a Converter for exporting Python objects\n    instead, it is used conveniently building OM objects in DSL embedded in Python\n    inparticular, it converts Python functions into OMBinding objects using lambdaOM as the binder", "id": "f17711:m0"}
{"signature": "def __getattr__(self, name):", "body": "if self._cdhook is not None:<EOL><INDENT>return self._cdhook(self._cdbase, name, self._converter, self._symbolhook)<EOL><DEDENT>return CDHelper(self._cdbase, name, self._converter, self._symbolhook)<EOL>", "docstring": "returns a CDHelper object with the given name and this as the base", "id": "f17711:c1:m5"}
{"signature": "def geturls_new_api(song_ids):", "body": "br_to_quality = {<NUM_LIT>: '<STR_LIT>', <NUM_LIT>: '<STR_LIT>'}<EOL>alters = NetEase().songs_detail_new_api(song_ids)<EOL>urls = [alter['<STR_LIT:url>'] for alter in alters]<EOL>return urls<EOL>", "docstring": "\u6279\u91cf\u83b7\u53d6\u97f3\u4e50\u7684\u5730\u5740", "id": "f17721:m8"}
{"signature": "def check(args):", "body": "if args.files:<EOL><INDENT>dir_paths = args.files<EOL><DEDENT>else:<EOL><INDENT>dir_paths = [path for path in sys.path<EOL>if os.path.isdir(path)]<EOL><DEDENT>options = []<EOL>if args.expand_star_imports:<EOL><INDENT>options.append('<STR_LIT>')<EOL><DEDENT>if args.imports:<EOL><INDENT>options.append('<STR_LIT>' + args.imports)<EOL><DEDENT>if args.remove_all_unused_imports:<EOL><INDENT>options.append('<STR_LIT>')<EOL><DEDENT>if args.remove_duplicate_keys:<EOL><INDENT>options.append('<STR_LIT>')<EOL><DEDENT>if args.remove_unused_variables:<EOL><INDENT>options.append('<STR_LIT>')<EOL><DEDENT>filenames = dir_paths<EOL>completed_filenames = set()<EOL>while filenames:<EOL><INDENT>try:<EOL><INDENT>name = os.path.realpath(filenames.pop(<NUM_LIT:0>))<EOL>if not os.path.exists(name):<EOL><INDENT>continue<EOL><DEDENT>if name in completed_filenames:<EOL><INDENT>sys.stderr.write(<EOL>colored(<EOL>'<STR_LIT>' + name + '<STR_LIT:\\n>',<EOL>YELLOW))<EOL>continue<EOL><DEDENT>else:<EOL><INDENT>completed_filenames.update(name)<EOL><DEDENT>if os.path.isdir(name):<EOL><INDENT>for root, directories, children in os.walk(unicode(name)):<EOL><INDENT>filenames += [os.path.join(root, f) for f in children<EOL>if f.endswith('<STR_LIT>') and<EOL>not f.startswith('<STR_LIT:.>')]<EOL>directories[:] = [d for d in directories<EOL>if not d.startswith('<STR_LIT:.>')]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>verbose_message = '<STR_LIT>' + name<EOL>sys.stderr.write(colored(verbose_message + '<STR_LIT:\\n>', YELLOW))<EOL>if not run(os.path.join(name),<EOL>command=args.command,<EOL>verbose=args.verbose,<EOL>options=options):<EOL><INDENT>return False<EOL><DEDENT><DEDENT><DEDENT>except (UnicodeDecodeError, UnicodeEncodeError) as exception:<EOL><INDENT>print(exception, file=sys.stderr)<EOL>continue<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Run recursively run autoflake on directory of files.\n\n    Return False if the fix results in broken syntax.", "id": "f17725:m7"}
{"signature": "def pyflakes_count(filename):", "body": "with autoflake.open_with_encoding(<EOL>filename,<EOL>encoding=autoflake.detect_encoding(filename)) as f:<EOL><INDENT>return len(list(autoflake.check(f.read())))<EOL><DEDENT>", "docstring": "Return pyflakes error count.", "id": "f17725:m1"}
{"signature": "def run(filename, command, verbose=False, options=None):", "body": "if not options:<EOL><INDENT>options = []<EOL><DEDENT>import test_autoflake<EOL>with test_autoflake.temporary_directory() as temp_directory:<EOL><INDENT>temp_filename = os.path.join(temp_directory,<EOL>os.path.basename(filename))<EOL>import shutil<EOL>shutil.copyfile(filename, temp_filename)<EOL>if <NUM_LIT:0> != subprocess.call(shlex.split(command) +<EOL>['<STR_LIT>', temp_filename] +<EOL>options):<EOL><INDENT>sys.stderr.write('<STR_LIT>' + filename + '<STR_LIT:\\n>')<EOL>return False<EOL><DEDENT>try:<EOL><INDENT>file_diff = diff(filename, temp_filename)<EOL>if verbose:<EOL><INDENT>sys.stderr.write(file_diff)<EOL><DEDENT>if check_syntax(filename):<EOL><INDENT>try:<EOL><INDENT>check_syntax(temp_filename, raise_error=True)<EOL><DEDENT>except (SyntaxError, TypeError,<EOL>UnicodeDecodeError, ValueError) as exception:<EOL><INDENT>sys.stderr.write('<STR_LIT>' + filename + '<STR_LIT:\\n>' +<EOL>str(exception) + '<STR_LIT:\\n>')<EOL>return False<EOL><DEDENT><DEDENT>before_count = pyflakes_count(filename)<EOL>after_count = pyflakes_count(temp_filename)<EOL>if verbose:<EOL><INDENT>print('<STR_LIT>', (before_count, after_count))<EOL><DEDENT>if file_diff and after_count > before_count:<EOL><INDENT>sys.stderr.write('<STR_LIT>' + filename + '<STR_LIT>')<EOL>return False<EOL><DEDENT><DEDENT>except IOError as exception:<EOL><INDENT>sys.stderr.write(str(exception) + '<STR_LIT:\\n>')<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Run autoflake on file at filename.\n\n    Return True on success.", "id": "f17725:m4"}
{"signature": "def main():", "body": "return <NUM_LIT:0> if check(process_args()) else <NUM_LIT:1><EOL>", "docstring": "Run main.", "id": "f17725:m8"}
{"signature": "def filter_useless_pass(source):", "body": "try:<EOL><INDENT>marked_lines = frozenset(useless_pass_line_numbers(source))<EOL><DEDENT>except (SyntaxError, tokenize.TokenError):<EOL><INDENT>marked_lines = frozenset()<EOL><DEDENT>sio = io.StringIO(source)<EOL>for line_number, line in enumerate(sio.readlines(), start=<NUM_LIT:1>):<EOL><INDENT>if line_number not in marked_lines:<EOL><INDENT>yield line<EOL><DEDENT><DEDENT>", "docstring": "Yield code with useless \"pass\" lines removed.", "id": "f17726:m24"}
{"signature": "def standard_package_names():", "body": "for name in standard_paths():<EOL><INDENT>if name.startswith('<STR_LIT:_>') or '<STR_LIT:->' in name:<EOL><INDENT>continue<EOL><DEDENT>if '<STR_LIT:.>' in name and name.rsplit('<STR_LIT:.>')[-<NUM_LIT:1>] not in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>continue<EOL><DEDENT>yield name.split('<STR_LIT:.>')[<NUM_LIT:0>]<EOL><DEDENT>", "docstring": "Yield standard module names.", "id": "f17726:m1"}
{"signature": "def match_file(filename, exclude):", "body": "if is_exclude_file(filename, exclude):<EOL><INDENT>return False<EOL><DEDENT>if not os.path.isdir(filename) and not is_python_file(filename):<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "Return True if file is okay for modifying/recursing.", "id": "f17726:m36"}
{"signature": "def get_diff_text(old, new, filename):", "body": "newline = '<STR_LIT:\\n>'<EOL>diff = difflib.unified_diff(<EOL>old, new,<EOL>'<STR_LIT>' + filename,<EOL>'<STR_LIT>' + filename,<EOL>lineterm=newline)<EOL>text = '<STR_LIT>'<EOL>for line in diff:<EOL><INDENT>text += line<EOL>if not line.endswith(newline):<EOL><INDENT>text += newline + r'<STR_LIT>' + newline<EOL><DEDENT><DEDENT>return text<EOL>", "docstring": "Return text of unified diff between old and new.", "id": "f17726:m32"}
{"signature": "def filter_duplicate_key(line, message, line_number, marked_line_numbers,<EOL>source, previous_line='<STR_LIT>'):", "body": "if marked_line_numbers and line_number == sorted(marked_line_numbers)[<NUM_LIT:0>]:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>return line<EOL>", "docstring": "Return '' if first occurrence of the key otherwise return `line`.", "id": "f17726:m20"}
{"signature": "def standard_paths():", "body": "for is_plat_spec in [True, False]:<EOL><INDENT>path = distutils.sysconfig.get_python_lib(standard_lib=True,<EOL>plat_specific=is_plat_spec)<EOL>for name in os.listdir(path):<EOL><INDENT>yield name<EOL><DEDENT>try:<EOL><INDENT>for name in os.listdir(os.path.join(path, '<STR_LIT>')):<EOL><INDENT>yield name<EOL><DEDENT><DEDENT>except OSError:  <EOL><INDENT>pass<EOL><DEDENT><DEDENT>", "docstring": "Yield paths to standard modules.", "id": "f17726:m0"}
{"signature": "def get_messages_by_line(messages):", "body": "line_messages = {}<EOL>for message in messages:<EOL><INDENT>line_messages[message.lineno] = message<EOL><DEDENT>return line_messages<EOL>", "docstring": "Return dictionary that maps line number to message.", "id": "f17726:m16"}
{"signature": "def unused_import_module_name(messages):", "body": "pattern = r'<STR_LIT>'<EOL>for message in messages:<EOL><INDENT>if isinstance(message, pyflakes.messages.UnusedImport):<EOL><INDENT>module_name = re.search(pattern, str(message))<EOL>module_name = module_name.group()[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL>if module_name:<EOL><INDENT>yield (message.lineno, module_name)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Yield line number and module name of unused imports.", "id": "f17726:m3"}
{"signature": "def multiline_import(line, previous_line='<STR_LIT>'):", "body": "for symbol in '<STR_LIT>':<EOL><INDENT>if symbol in line:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>if line.lstrip().startswith('<STR_LIT:>>'):<EOL><INDENT>return True<EOL><DEDENT>return multiline_statement(line, previous_line)<EOL>", "docstring": "Return True if import is spans multiples lines.", "id": "f17726:m11"}
{"signature": "def break_up_import(line):", "body": "assert '<STR_LIT:\\\\>' not in line<EOL>assert '<STR_LIT:(>' not in line<EOL>assert '<STR_LIT:)>' not in line<EOL>assert '<STR_LIT:;>' not in line<EOL>assert '<STR_LIT:#>' not in line<EOL>assert not line.lstrip().startswith('<STR_LIT>')<EOL>newline = get_line_ending(line)<EOL>if not newline:<EOL><INDENT>return line<EOL><DEDENT>(indentation, imports) = re.split(pattern=r'<STR_LIT>',<EOL>string=line, maxsplit=<NUM_LIT:1>)<EOL>indentation += '<STR_LIT>'<EOL>assert newline<EOL>return '<STR_LIT>'.join([indentation + i.strip() + newline<EOL>for i in sorted(imports.split('<STR_LIT:U+002C>'))])<EOL>", "docstring": "Return line with imports on separate lines.", "id": "f17726:m14"}
{"signature": "def _split_comma_separated(string):", "body": "return set(text.strip() for text in string.split('<STR_LIT:U+002C>') if text.strip())<EOL>", "docstring": "Return a set of strings.", "id": "f17726:m33"}
{"signature": "def multiline_statement(line, previous_line='<STR_LIT>'):", "body": "for symbol in '<STR_LIT>':<EOL><INDENT>if symbol in line:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>sio = io.StringIO(line)<EOL>try:<EOL><INDENT>list(tokenize.generate_tokens(sio.readline))<EOL>return previous_line.rstrip().endswith('<STR_LIT:\\\\>')<EOL><DEDENT>except (SyntaxError, tokenize.TokenError):<EOL><INDENT>return True<EOL><DEDENT>", "docstring": "Return True if this is part of a multiline statement.", "id": "f17726:m12"}
{"signature": "def is_starved(self):", "body": "for conn in itervalues(self.conns):<EOL><INDENT>if conn.in_flight > <NUM_LIT:0> and conn.in_flight >= (conn.last_rdy * <NUM_LIT>):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Used to identify when buffered messages should be processed and responded to.\n\nWhen max_in_flight > 1 and you're batching messages together to perform work\nis isn't possible to just compare the len of your list of buffered messages against\nyour configured max_in_flight (because max_in_flight may not be evenly divisible\nby the number of producers you're connected to, ie. you might never get that many\nmessages... it's a *max*).\n\nExample::\n\n    def message_handler(self, nsq_msg, reader):\n        # buffer messages\n        if reader.is_starved():\n            # perform work\n\n    reader = nsq.Reader(...)\n    reader.set_message_handler(functools.partial(message_handler, reader=reader))\n    nsq.run()", "id": "f17746:c0:m5"}
{"signature": "def set_max_in_flight(self, max_in_flight):", "body": "assert isinstance(max_in_flight, int)<EOL>self.max_in_flight = max_in_flight<EOL>if max_in_flight == <NUM_LIT:0>:<EOL><INDENT>for conn in itervalues(self.conns):<EOL><INDENT>if conn.rdy > <NUM_LIT:0>:<EOL><INDENT>logger.debug('<STR_LIT>', conn.id, self.name, conn.rdy)<EOL>self._send_rdy(conn, <NUM_LIT:0>)<EOL><DEDENT><DEDENT>self.total_rdy = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>self.need_rdy_redistributed = True<EOL>self._redistribute_rdy_state()<EOL><DEDENT>", "docstring": "Dynamically adjust the reader max_in_flight. Set to 0 to immediately disable a Reader", "id": "f17746:c0:m21"}
{"signature": "def is_async(self):", "body": "return self._async_enabled<EOL>", "docstring": "Returns whether or not asynchronous processing has been enabled.", "id": "f17749:c0:m2"}
{"signature": "def finish(self):", "body": "assert not self._has_responded<EOL>self._has_responded = True<EOL>self.trigger(event.FINISH, message=self)<EOL>", "docstring": "Respond to ``nsqd`` that you've processed this message successfully (or would like\nto silently discard it).", "id": "f17749:c0:m4"}
{"signature": "def has_responded(self):", "body": "return self._has_responded<EOL>", "docstring": "Returns whether or not this message has been responded to.", "id": "f17749:c0:m3"}
{"signature": "def trigger(self, name, *args, **kwargs):", "body": "for ev in self.__listeners[name]:<EOL><INDENT>ev(*args, **kwargs)<EOL><DEDENT>", "docstring": "Execute the callbacks for the listeners on the specified event with the\nsupplied arguments.\n\nAll extra arguments are passed through to each callback.\n\n:param name: the name of the event\n:type name: string", "id": "f17753:c2:m3"}
{"signature": "def _infer_tarball_url():", "body": "try:<EOL><INDENT>with click.open_file('<STR_LIT>', '<STR_LIT:r>') as f:<EOL><INDENT>contents = f.read()<EOL><DEDENT>app_json = json.loads(contents)<EOL><DEDENT>except IOError:<EOL><INDENT>return None<EOL><DEDENT>repository = app_json.get('<STR_LIT>')<EOL>if not repository:<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>return app_json.get('<STR_LIT>') + '<STR_LIT>'<EOL><DEDENT>", "docstring": "Returns the tarball URL inferred from an app.json, if present.", "id": "f17765:m0"}
{"signature": "def _read_app_name():", "body": "try:<EOL><INDENT>with click.open_file('<STR_LIT>', '<STR_LIT:r>') as f:<EOL><INDENT>return f.read().strip()<EOL><DEDENT><DEDENT>except IOError:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Reads the app name from the .happy file.", "id": "f17765:m2"}
{"signature": "def create_build(self, tarball_url, env=None, app_name=None):", "body": "data = {<EOL>'<STR_LIT>': {<EOL>'<STR_LIT:url>': tarball_url<EOL>}<EOL>}<EOL>if env:<EOL><INDENT>data['<STR_LIT>'] = {'<STR_LIT>': env}<EOL><DEDENT>if app_name:<EOL><INDENT>data['<STR_LIT>'] = {'<STR_LIT:name>': app_name}<EOL><DEDENT>return self.api_request('<STR_LIT:POST>', '<STR_LIT>', data=data)<EOL>", "docstring": "Creates an app-setups build. Returns response data as a dict.\n\n        :param tarball_url: URL of a tarball containing an ``app.json``.\n        :param env: Dict containing environment variable overrides.\n        :param app_name: Name of the Heroku app to create.\n        :returns: Response data as a ``dict``.", "id": "f17766:c2:m3"}
{"signature": "def delete(self, app_name):", "body": "self._api.delete_app(app_name=app_name)<EOL>", "docstring": "Deletes a Heroku app.\n\n        :param app_name: Name of the Heroku app to delete.", "id": "f17767:c0:m3"}
{"signature": "def __init__(self, auth_token=None):", "body": "self._api = Heroku(auth_token=auth_token)<EOL>", "docstring": "Initializes the class.\n\n        :param auth_token: A Heroku API auth token.", "id": "f17767:c0:m0"}
{"signature": "def isolated(func):", "body": "def wrapped(func, runner, *args, **kwargs):<EOL><INDENT>with runner.isolated_filesystem():<EOL><INDENT>with open('<STR_LIT>', '<STR_LIT:w>') as f:<EOL><INDENT>f.write('<STR_LIT>')<EOL><DEDENT>return func(runner, *args, **kwargs)<EOL><DEDENT><DEDENT>return decorator.decorator(wrapped, func)<EOL>", "docstring": "Runs a method in an isolated filesystem.\n\n    This also stubs out an app.json for convenience.", "id": "f17770:m2"}
{"signature": "def prepare_message(self, data=None):", "body": "message = {<EOL>'<STR_LIT>': self.protocol,<EOL>'<STR_LIT>': self._node,<EOL>'<STR_LIT>': self._chip_id,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': {},<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': [<EOL>'<STR_LIT>'<EOL>]<EOL>}<EOL>if type(data) is dict:<EOL><INDENT>for k, v in data.items():<EOL><INDENT>if k in message:<EOL><INDENT>message[k] = v<EOL><DEDENT><DEDENT><DEDENT>return message<EOL>", "docstring": "Return message as dict\n:return dict", "id": "f17774:c0:m4"}
{"signature": "@property<EOL><INDENT>def node(self):<DEDENT>", "body": "return self._node<EOL>", "docstring": "Return node name\n:return string", "id": "f17774:c0:m1"}
{"signature": "def prepare_message(self, data=None):", "body": "raise NotImplementedError(\"<STR_LIT>\")<EOL>", "docstring": "prepares empty message adn merge it with data", "id": "f17775:c0:m1"}
{"signature": "def parse_docstring(doc):", "body": "doc = inspect.cleandoc(doc)<EOL>lines = doc.split('<STR_LIT:\\n>')<EOL>section = None<EOL>section_indent = None<EOL>params = {}<EOL>returns = None<EOL>for line in lines:<EOL><INDENT>line = line.rstrip()<EOL>if len(line) == <NUM_LIT:0>:<EOL><INDENT>continue<EOL><DEDENT>elif str(line) == '<STR_LIT>':<EOL><INDENT>section = '<STR_LIT:args>'<EOL>section_indent = None<EOL>continue<EOL><DEDENT>elif str(line) == '<STR_LIT>':<EOL><INDENT>section = '<STR_LIT>'<EOL>section_indent = None<EOL>continue<EOL><DEDENT>if section is not None:<EOL><INDENT>stripped = line.lstrip()<EOL>margin = len(line) - len(stripped)<EOL>if section_indent is None:<EOL><INDENT>section_indent = margin<EOL><DEDENT>if margin != section_indent:<EOL><INDENT>continue<EOL><DEDENT>if section == '<STR_LIT:args>':<EOL><INDENT>param_name, type_info = parse_param(stripped)<EOL>params[param_name] = type_info<EOL><DEDENT>elif section == '<STR_LIT>':<EOL><INDENT>returns = parse_return(stripped)<EOL><DEDENT><DEDENT><DEDENT>return params, returns<EOL>", "docstring": "Parse a docstring into ParameterInfo and ReturnInfo objects.", "id": "f17782:m0"}
{"signature": "def format_hexdump(arg):", "body": "line = '<STR_LIT>'<EOL>for i in range(<NUM_LIT:0>, len(arg), <NUM_LIT:16>):<EOL><INDENT>if i > <NUM_LIT:0>:<EOL><INDENT>line += '<STR_LIT:\\n>'<EOL><DEDENT>chunk = arg[i:i + <NUM_LIT:16>]<EOL>hex_chunk = hexlify(chunk).decode('<STR_LIT:utf-8>')<EOL>hex_line = '<STR_LIT:U+0020>'.join(hex_chunk[j:j + <NUM_LIT:2>] for j in range(<NUM_LIT:0>, len(hex_chunk), <NUM_LIT:2>))<EOL>if len(hex_line) < (<NUM_LIT:3> * <NUM_LIT:16>) - <NUM_LIT:1>:<EOL><INDENT>hex_line += '<STR_LIT:U+0020>' * (((<NUM_LIT:3> * <NUM_LIT:16>) - <NUM_LIT:1>) - len(hex_line))<EOL><DEDENT>ascii_line = '<STR_LIT>'.join(_convert_to_ascii(x) for x in chunk)<EOL>offset_line = '<STR_LIT>' % i<EOL>line += \"<STR_LIT>\" % (offset_line, hex_line, ascii_line)<EOL><DEDENT>return line<EOL>", "docstring": "Convert the bytes object to a hexdump.\n\n    The output format will be:\n\n    <offset, 4-byte>  <16-bytes of output separated by 1 space>  <16 ascii characters>", "id": "f17785:m5"}
{"signature": "def validate_list(arg, choices):", "body": "if arg not in choices:<EOL><INDENT>raise ValueError('<STR_LIT>' % str(choices))<EOL><DEDENT>", "docstring": "Make sure the argument is in the list of choices passed to the function", "id": "f17790:m1"}
{"signature": "def load_type_module(self, module):", "body": "for name in (x for x in dir(module) if not x.startswith('<STR_LIT:_>')):<EOL><INDENT>typeobj = getattr(module, name)<EOL>try:<EOL><INDENT>self.inject_type(name, typeobj)<EOL><DEDENT>except ArgumentError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>", "docstring": "Given a module that contains a list of some types find all symbols in the module that\ndo not start with _ and attempt to import them as types.", "id": "f17793:c0:m15"}
{"signature": "def is_known_type(self, type_name):", "body": "type_name = str(type_name)<EOL>if type_name in self.known_types:<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Check if type is known to the type system.\n\n        Returns:\n            bool: True if the type is a known instantiated simple type, False otherwise", "id": "f17793:c0:m7"}
{"signature": "@classmethod<EOL><INDENT>def _is_factory(cls, typeobj):<DEDENT>", "body": "if hasattr(typeobj, '<STR_LIT>'):<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Determine if typeobj is a factory for producing complex types", "id": "f17793:c0:m11"}
{"signature": "def instantiate_type(self, typename, base, subtypes):", "body": "if base not in self.type_factories:<EOL><INDENT>raise ArgumentError(\"<STR_LIT>\", passed_type=typename, base_type=base)<EOL><DEDENT>base_type = self.type_factories[base]<EOL>for sub_type in subtypes:<EOL><INDENT>try:<EOL><INDENT>self.get_type(sub_type)<EOL><DEDENT>except KeyValueException as exc:<EOL><INDENT>raise ArgumentError(\"<STR_LIT>\", passed_type=typename, sub_type=sub_type, error=exc)<EOL><DEDENT><DEDENT>typeobj = base_type.Build(*subtypes, type_system=self)<EOL>self.inject_type(typename, typeobj)<EOL>", "docstring": "Instantiate a complex type.", "id": "f17793:c0:m9"}
{"signature": "def split_type(self, typename):", "body": "name = self._canonicalize_type(typename)<EOL>if '<STR_LIT:(>' not in name:<EOL><INDENT>return name, False, []<EOL><DEDENT>base, sub = name.split('<STR_LIT:(>')<EOL>if len(sub) == <NUM_LIT:0> or sub[-<NUM_LIT:1>] != '<STR_LIT:)>':<EOL><INDENT>raise ArgumentError(\"<STR_LIT>\", passed_type=typename, basetype=base, subtype_string=sub)<EOL><DEDENT>sub = sub[:-<NUM_LIT:1>]<EOL>subs = sub.split('<STR_LIT:U+002C>')<EOL>return base, True, subs<EOL>", "docstring": "Given a potentially complex type, split it into its base type and specializers", "id": "f17793:c0:m8"}
{"signature": "def __init__(self, *args):", "body": "self.interactive = False<EOL>self.known_types = {}<EOL>self.type_factories = {}<EOL>self.logger = logging.getLogger(__name__)<EOL>for arg in args:<EOL><INDENT>self.load_type_module(arg)<EOL><DEDENT>self._lazy_type_sources = []<EOL>self.failed_sources = []<EOL>", "docstring": "Create a TypeSystem by importing all of the types defined in modules passed\nas arguments to this function.  Each module is imported using", "id": "f17793:c0:m0"}
{"signature": "def load_external_types(self, path):", "body": "folder, filename = os.path.split(path)<EOL>try:<EOL><INDENT>fileobj, pathname, description = imp.find_module(filename, [folder])<EOL>mod = imp.load_module(filename, fileobj, pathname, description)<EOL><DEDENT>except ImportError as exc:<EOL><INDENT>raise ArgumentError(\"<STR_LIT>\", module_path=path, parent_directory=folder, module_name=filename, error=str(exc))<EOL><DEDENT>self.load_type_module(mod)<EOL>", "docstring": "Given a path to a python package or module, load that module, search for all defined variables\ninside of it that do not start with _ or __ and inject them into the type system.  If any of the\ntypes cannot be injected, silently ignore them unless verbose is True.  If path points to a module\nit should not contain the trailing .py since this is added automatically by the python import system", "id": "f17793:c0:m16"}
{"signature": "def get_type_size(self, type):", "body": "typeobj = self.get_type(type)<EOL>if hasattr(typeobj, '<STR_LIT:size>'):<EOL><INDENT>return typeobj.size()<EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Get the size of this type for converting a hex string to the\ntype. Return 0 if the size is not known.", "id": "f17793:c0:m4"}
{"signature": "def get_type(self, type_name):", "body": "type_name = self._canonicalize_type(type_name)<EOL>if str(type_name) == '<STR_LIT:int>':<EOL><INDENT>type_name = '<STR_LIT>'<EOL><DEDENT>elif str(type_name) == '<STR_LIT:str>':<EOL><INDENT>type_name = '<STR_LIT:string>'<EOL><DEDENT>elif str(type_name) == '<STR_LIT>':<EOL><INDENT>type_name = '<STR_LIT>'<EOL><DEDENT>if self.is_known_type(type_name):<EOL><INDENT>return self.known_types[type_name]<EOL><DEDENT>base_type, is_complex, subtypes = self.split_type(type_name)<EOL>if is_complex and base_type in self.type_factories:<EOL><INDENT>self.instantiate_type(type_name, base_type, subtypes)<EOL>return self.known_types[type_name]<EOL><DEDENT>i = <NUM_LIT:0><EOL>for i, (source, name) in enumerate(self._lazy_type_sources):<EOL><INDENT>if isinstance(source, str):<EOL><INDENT>import pkg_resources<EOL>for entry in pkg_resources.iter_entry_points(source):<EOL><INDENT>try:<EOL><INDENT>mod = entry.load()<EOL>type_system.load_type_module(mod)<EOL><DEDENT>except:  <EOL><INDENT>fail_info = (\"<STR_LIT>\" % (source, entry.name), sys.exc_info)<EOL>logging.exception(\"<STR_LIT>\", source, entry.name)<EOL>self.failed_sources.append(fail_info)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>source(self)<EOL><DEDENT>except:  <EOL><INDENT>fail_info = (\"<STR_LIT>\" % name, sys.exc_info)<EOL>logging.exception(\"<STR_LIT>\", source)<EOL>self.failed_sources.append(fail_info)<EOL><DEDENT><DEDENT>if self.is_known_type(type_name) or (is_complex and base_type in self.type_factories):<EOL><INDENT>break<EOL><DEDENT><DEDENT>self._lazy_type_sources = self._lazy_type_sources[i:]<EOL>if not (self.is_known_type(type_name) or (is_complex and base_type in self.type_factories)):<EOL><INDENT>raise ArgumentError(\"<STR_LIT>\", type=type_name, failed_external_sources=[x[<NUM_LIT:0>] for x in self.failed_sources])<EOL><DEDENT>return self.get_type(type_name)<EOL>", "docstring": "Return the type object corresponding to a type name.\n\n        If type_name is not found, this triggers the loading of\n        external types until a matching type is found or until there\n        are no more external type sources.", "id": "f17793:c0:m12"}
{"signature": "@classmethod<EOL><INDENT>def process_param(cls, param):<DEDENT>", "body": "<EOL>return None<EOL>", "docstring": "Process an @param decorator into a ParameterInfo.", "id": "f17794:c0:m0"}
{"signature": "def context(name=None):", "body": "def _context(cls):<EOL><INDENT>annotated(cls, name)<EOL>cls.context = True<EOL>return cls<EOL><DEDENT>return _context<EOL>", "docstring": "Declare that a class defines a context.\n\n    Contexts are for use with HierarchicalShell for discovering\n    and using functionality from the command line.\n\n    Args:\n        name (str): Optional name for this context if you don't want\n            to just use the class name.", "id": "f17795:m6"}
{"signature": "def short_description(func):", "body": "doc = inspect.getdoc(func)<EOL>if doc is not None:<EOL><INDENT>doc = inspect.cleandoc(doc)<EOL>lines = doc.splitlines()<EOL>return lines[<NUM_LIT:0>]<EOL><DEDENT>return \"<STR_LIT>\"<EOL>", "docstring": "Given an object with a docstring, return the first line of the docstring", "id": "f17795:m11"}
{"signature": "def param(name, type_name, *validators, **kwargs):", "body": "def _param(func):<EOL><INDENT>func = annotated(func)<EOL>valids = _parse_validators(validators)<EOL>func.metadata.add_param(name, type_name, valids, **kwargs)<EOL>if func.decorated:<EOL><INDENT>return func<EOL><DEDENT>func.decorated = True<EOL>return decorate(func, _check_and_execute)<EOL><DEDENT>return _param<EOL>", "docstring": "Decorate a function to give type information about its parameters.\n\n    This function stores a type name, optional description and optional list\n    of validation functions along with the decorated function it is called\n    on in order to allow run time type conversions and validation.\n\n    Args:\n        name (string): name of the parameter\n        type_name (string): The name of a type that will be known to the type\n            system by the time this function is called for the first time.  Types\n            are lazily loaded so it is not required that the type resolve correctly\n            at the point in the module where this function is defined.\n        validators (list(string or tuple)): A list of validators.  Each validator\n            can be defined either using a string name or as an n-tuple of the form\n            [name, \\\\*extra_args].  The name is used to look up a validator function\n            of the form validate_name, which is called on the parameters value to\n            determine if it is valid.  If extra_args are given, they are passed\n            as extra arguments to the validator function, which is called as:\n\n            validator(value, \\\\*extra_args)\n        desc (string): An optional descriptioon for this parameter that must be\n            passed as a keyword argument.\n\n    Returns:\n        callable: A decorated function with additional type metadata", "id": "f17795:m2"}
{"signature": "def docannotate(func):", "body": "func = annotated(func)<EOL>func.metadata.load_from_doc = True<EOL>if func.decorated:<EOL><INDENT>return func<EOL><DEDENT>func.decorated = True<EOL>return decorate(func, _check_and_execute)<EOL>", "docstring": "Annotate a function using information from its docstring.\n\n    The annotation actually happens at the time the function is first called\n    to improve startup time.  For this function to work, the docstring must be\n    formatted correctly.  You should use the typedargs pylint plugin to make\n    sure there are no errors in the docstring.", "id": "f17795:m9"}
{"signature": "def get_help(func):", "body": "help_text = \"<STR_LIT>\"<EOL>if isinstance(func, dict):<EOL><INDENT>name = context_name(func)<EOL>help_text = \"<STR_LIT:\\n>\" + name + \"<STR_LIT>\"<EOL>doc = inspect.getdoc(func)<EOL>if doc is not None:<EOL><INDENT>doc = inspect.cleandoc(doc)<EOL>help_text += doc + '<STR_LIT:\\n>'<EOL><DEDENT>return help_text<EOL><DEDENT>sig = func.metadata.signature()<EOL>doc = inspect.getdoc(func)<EOL>if doc is not None:<EOL><INDENT>doc = inspect.cleandoc(doc)<EOL><DEDENT>help_text += \"<STR_LIT:\\n>\" + sig + \"<STR_LIT>\"<EOL>if doc is not None:<EOL><INDENT>help_text += doc + '<STR_LIT:\\n>'<EOL><DEDENT>if inspect.isclass(func):<EOL><INDENT>func = func.__init__<EOL><DEDENT>if func.metadata.load_from_doc:<EOL><INDENT>return help_text<EOL><DEDENT>help_text += \"<STR_LIT>\"<EOL>for key, info in func.metadata.annotated_params.items():<EOL><INDENT>type_name = info.type_name<EOL>desc = \"<STR_LIT>\"<EOL>if info.desc is not None:<EOL><INDENT>desc = info.desc<EOL><DEDENT>help_text += \"<STR_LIT>\" % (key, type_name, desc)<EOL><DEDENT>return help_text<EOL>", "docstring": "Return usage information about a context or function.\n\n    For contexts, just return the context name and its docstring\n    For functions, return the function signature as well as its\n    argument types.\n\n    Args:\n        func (callable): An annotated callable function\n\n    Returns:\n        str: The formatted help text", "id": "f17795:m1"}
{"signature": "def return_type(type_name, formatter=None):", "body": "def _returns(func):<EOL><INDENT>annotated(func)<EOL>func.metadata.typed_returnvalue(type_name, formatter)<EOL>return func<EOL><DEDENT>return _returns<EOL>", "docstring": "Specify that this function returns a typed value.\n\n    Args:\n        type_name (str): A type name known to the global typedargs type system\n        formatter (str): An optional name of a formatting function specified\n            for the type given in type_name.", "id": "f17795:m5"}
{"signature": "@classmethod<EOL><INDENT>def _is_flag(cls, arg):<DEDENT>", "body": "if arg == '<STR_LIT>':<EOL><INDENT>return False<EOL><DEDENT>if not arg.startswith('<STR_LIT:->'):<EOL><INDENT>return False<EOL><DEDENT>if arg.startswith('<STR_LIT>'):<EOL><INDENT>first_char = arg[<NUM_LIT:2>]<EOL><DEDENT>else:<EOL><INDENT>first_char = arg[<NUM_LIT:1>]<EOL><DEDENT>if not first_char.isalpha():<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "Check if an argument is a flag.\n\n        A flag starts with - or -- and the next character must be a letter\n        followed by letters, numbers, - or _.  Currently we only check the\n        alpha'ness of the first non-dash character to make sure we're not just\n        looking at a negative number.\n\n        Returns:\n            bool: Whether the argument is a flag.", "id": "f17796:c1:m16"}
{"signature": "def add_builtin(self, name, callable):", "body": "self.builtins[name] = callable<EOL>", "docstring": "Add a builtin function callable from all contexts.\n\n        Callable should be an annotated function like any other that you\n        want to call from a HierarchicalShell\n\n        Args:\n            name (str): The name of the function\n            callable (callable): The annotated function that we should call", "id": "f17796:c1:m1"}
{"signature": "@annotate.takes_cmdline<EOL><INDENT>@annotate.stringable<EOL>def _builtin_help(self, args):<DEDENT>", "body": "if len(args) == <NUM_LIT:0>:<EOL><INDENT>return self.list_dir(self.contexts[-<NUM_LIT:1>])<EOL><DEDENT>if len(args) == <NUM_LIT:1>:<EOL><INDENT>func = self.find_function(self.contexts[-<NUM_LIT:1>], args[<NUM_LIT:0>])<EOL>return annotate.get_help(func)<EOL><DEDENT>help_text = \"<STR_LIT>\" + str(args) + \"<STR_LIT:\\n>\"<EOL>help_text += \"<STR_LIT>\"<EOL>return help_text<EOL>", "docstring": "Return help information for a context or function.", "id": "f17796:c1:m13"}
{"signature": "def root_update(self, dict_like):", "body": "self.root.update(dict_like)<EOL>", "docstring": "Add entries to root from a dict_line object.", "id": "f17796:c1:m2"}
{"signature": "def process_arguments(self, func, args):", "body": "pos_args = []<EOL>kw_args = {}<EOL>while len(args) > <NUM_LIT:0>:<EOL><INDENT>if func.metadata.spec_filled(pos_args, kw_args) and not self._is_flag(args[<NUM_LIT:0>]):<EOL><INDENT>break<EOL><DEDENT>arg = args.pop(<NUM_LIT:0>)<EOL>if arg == '<STR_LIT>':<EOL><INDENT>break<EOL><DEDENT>elif self._is_flag(arg):<EOL><INDENT>arg_value = None<EOL>arg_name = None<EOL>if len(arg) == <NUM_LIT:2>:<EOL><INDENT>arg_name = func.metadata.match_shortname(arg[<NUM_LIT:1>:], filled_args=pos_args)<EOL><DEDENT>else:<EOL><INDENT>if not arg.startswith('<STR_LIT>'):<EOL><INDENT>raise ArgumentError(\"<STR_LIT>\", argument=arg)<EOL><DEDENT>arg = arg[<NUM_LIT:2>:]<EOL>if '<STR_LIT:=>' in arg:<EOL><INDENT>arg, arg_value = arg.split('<STR_LIT:=>', <NUM_LIT:1>)<EOL><DEDENT>arg_name = func.metadata.match_shortname(arg, filled_args=pos_args)<EOL><DEDENT>arg_type = func.metadata.param_type(arg_name)<EOL>if arg_type is None:<EOL><INDENT>raise ArgumentError(\"<STR_LIT>\", argument=arg_name)<EOL><DEDENT>if arg_value is None:<EOL><INDENT>arg_value = self._extract_arg_value(arg_name, arg_type, args)<EOL><DEDENT>kw_args[arg_name] = arg_value<EOL><DEDENT>else:<EOL><INDENT>pos_args.append(arg)<EOL><DEDENT><DEDENT>if len(args) > <NUM_LIT:0> and args[<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>args.pop(<NUM_LIT:0>)<EOL><DEDENT>return pos_args, kw_args, args<EOL>", "docstring": "Process arguments from the command line into positional and kw args.\n\n        Arguments are consumed until the argument spec for the function is filled\n        or a -- is found or there are no more arguments.  Keyword arguments can be\n        specified using --field=value, -f value or --field value.  Positional\n        arguments are specified just on the command line itself.\n\n        If a keyword argument (`field`) is a boolean, it can be set to True by just passing\n        --field or -f without needing to explicitly pass True unless this would cause\n        ambiguity in parsing since the next expected positional argument is also a boolean\n        or a string.\n\n        Args:\n            func (callable): A function previously annotated with type information\n            args (list): A list of all of the potential arguments to this function.\n\n        Returns:\n            (args, kw_args, unused args): A tuple with a list of args, a dict of\n                keyword args and a list of any unused args that were not processed.", "id": "f17796:c1:m17"}
{"signature": "def invoke(self, line):", "body": "finished = True<EOL>while len(line) > <NUM_LIT:0>:<EOL><INDENT>val, line, finished = self.invoke_one(line)<EOL>if val is not None:<EOL><INDENT>iprint(val)<EOL><DEDENT><DEDENT>return finished<EOL>", "docstring": "Invoke a one or more function given a list of arguments.\n\n        The functions are searched for using the current context on the context stack\n        and its annotated type information is used to convert all of the string parameters\n        passed in line to appropriate python types.\n\n        Args:\n            line (list): The list of command line arguments.\n\n        Returns:\n            bool: A boolean specifying if the last function created a new context\n                (False if a new context was created) and a list with the remainder of the\n                command line if this function did not consume all arguments.)", "id": "f17796:c1:m20"}
{"signature": "def _split_line(self, line):", "body": "parts = shlex.split(line, posix=self.posix_lex)<EOL>if not self.posix_lex:<EOL><INDENT>parts = [self._remove_quotes(x) for x in parts]<EOL><DEDENT>return parts<EOL>", "docstring": "Split a line into arguments using shlex and a dequoting routine.", "id": "f17796:c1:m9"}
{"signature": "@classmethod<EOL><INDENT>def _deferred_add(cls, add_action):<DEDENT>", "body": "module, _, obj = add_action.partition('<STR_LIT:U+002C>')<EOL>mod = importlib.import_module(module)<EOL>if obj == \"<STR_LIT>\":<EOL><INDENT>_, con = annotate.context_from_module(mod)<EOL>return con<EOL><DEDENT>if hasattr(mod, obj):<EOL><INDENT>return getattr(mod, obj)<EOL><DEDENT>raise ArgumentError(\"<STR_LIT>\", module=module, object=obj)<EOL>", "docstring": "Lazily load a callable.\n\n        Perform a lazy import of a context so that we don't have a huge initial startup time\n        loading all of the modules that someone might want even though they probably only\n        will use a few of them.", "id": "f17796:c1:m7"}
{"signature": "def string_returnvalue(self):", "body": "self.return_info = ReturnInfo(None, str, True, None)<EOL>", "docstring": "Mark the return value as data that should be converted with str.", "id": "f17798:c0:m5"}
{"signature": "def param_type(self, name):", "body": "self._ensure_loaded()<EOL>if name not in self.annotated_params:<EOL><INDENT>return None<EOL><DEDENT>return self.annotated_params[name].type_name<EOL>", "docstring": "Get the parameter type information by name.\n\n        Args:\n            name (str): The full name of a parameter.\n\n        Returns:\n            str: The type name or None if no type information is given.", "id": "f17798:c0:m11"}
{"signature": "def check_spec(self, pos_args, kwargs=None):", "body": "if kwargs is None:<EOL><INDENT>kwargs = {}<EOL><DEDENT>if self.varargs is not None or self.kwargs is not None:<EOL><INDENT>raise InternalError(\"<STR_LIT>\")<EOL><DEDENT>missing = object()<EOL>arg_vals = [missing]*len(self.arg_names)<EOL>kw_indices = {name: i for i, name in enumerate(self.arg_names)}<EOL>for i, arg in enumerate(pos_args):<EOL><INDENT>if i >= len(arg_vals):<EOL><INDENT>raise ArgumentError(\"<STR_LIT>\" % str(arg))<EOL><DEDENT>arg_vals[i] = arg<EOL><DEDENT>for arg, val in kwargs.items():<EOL><INDENT>index = kw_indices.get(arg)<EOL>if index is None:<EOL><INDENT>raise ArgumentError(\"<STR_LIT>\" % arg)<EOL><DEDENT>if arg_vals[index] is not missing:<EOL><INDENT>raise ValidationError(\"<STR_LIT>\" % arg)<EOL><DEDENT>arg_vals[index] = val<EOL><DEDENT>if len(self.arg_defaults) > <NUM_LIT:0>:<EOL><INDENT>for i in range(<NUM_LIT:0>, len(self.arg_defaults)):<EOL><INDENT>neg_index = -len(self.arg_defaults) + i<EOL>if arg_vals[neg_index] is missing:<EOL><INDENT>arg_vals[neg_index] = self.arg_defaults[i]<EOL><DEDENT><DEDENT><DEDENT>if missing in arg_vals:<EOL><INDENT>index = arg_vals.index(missing)<EOL>raise ArgumentError(\"<STR_LIT>\" % (index, self.arg_names[index]))<EOL><DEDENT>return {name: val for name, val in zip(self.arg_names, arg_vals)}<EOL>", "docstring": "Check if there are any missing or duplicate arguments.\n\n        Args:\n            pos_args (list): A list of arguments that will be passed as positional\n                arguments.\n            kwargs (dict): A dictionary of the keyword arguments that will be passed.\n\n        Returns:\n            dict: A dictionary of argument name to argument value, pulled from either\n                the value passed or the default value if no argument is passed.\n\n        Raises:\n            ArgumentError: If a positional or keyword argument does not fit in the spec.\n            ValidationError: If an argument is passed twice.", "id": "f17798:c0:m15"}
{"signature": "def match_shortname(self, name, filled_args=None):", "body": "filled_count = <NUM_LIT:0><EOL>if filled_args is not None:<EOL><INDENT>filled_count = len(filled_args)<EOL><DEDENT>possible = [x for x in self.arg_names[filled_count:] if x.startswith(name)]<EOL>if len(possible) == <NUM_LIT:0>:<EOL><INDENT>raise ArgumentError(\"<STR_LIT>\", short_name=name, parameters=self.arg_names)<EOL><DEDENT>elif len(possible) > <NUM_LIT:1>:<EOL><INDENT>raise ArgumentError(\"<STR_LIT>\", short_name=name, possible_matches=possible)<EOL><DEDENT>return possible[<NUM_LIT:0>]<EOL>", "docstring": "Try to convert a prefix into a parameter name.\n\n        If the result could be ambiguous or there is no matching\n        parameter, throw an ArgumentError\n\n        Args:\n            name (str): A prefix for a parameter name\n            filled_args (list): A list of filled positional arguments that will be\n                removed from consideration.\n\n        Returns:\n            str: The full matching parameter name", "id": "f17798:c0:m10"}
{"signature": "def format_returnvalue(self, value):", "body": "self._ensure_loaded()<EOL>if not self.return_info.is_data:<EOL><INDENT>return None<EOL><DEDENT>if self.return_info.type_name is not None:<EOL><INDENT>return typeinfo.type_system.format_value(value, self.return_info.type_name, self.return_info.formatter)<EOL><DEDENT>return self.return_info.formatter(value)<EOL>", "docstring": "Format the return value of this function as a string.\n\n        Args:\n            value (object): The return value that we are supposed to format.\n\n        Returns:\n            str: The formatted return value, or None if this function indicates\n                that it does not return data", "id": "f17798:c0:m13"}
{"signature": "def custom_returnvalue(self, printer, desc=None):", "body": "self.return_info = ReturnInfo(None, printer, True, desc)<EOL>", "docstring": "Use a custom function to print the return value.\n\n        Args:\n            printer (callable): A function that should take in the return\n                value and convert it to a string.\n            desc (str): An optional description of the return value.", "id": "f17798:c0:m6"}
{"signature": "def spec_filled(self, pos_args, kw_args):", "body": "req_names = self.arg_names<EOL>if len(self.arg_defaults) > <NUM_LIT:0>:<EOL><INDENT>req_names = req_names[:-len(self.arg_defaults)]<EOL><DEDENT>req = [x for x in req_names if x not in kw_args]<EOL>return len(req) <= len(pos_args)<EOL>", "docstring": "Check if we have enough arguments to call this function.\n\n        Args:\n            pos_args (list): A list of all the positional values we have.\n            kw_args (dict): A dict of all of the keyword args we have.\n\n        Returns:\n            bool: True if we have a filled spec, False otherwise.", "id": "f17798:c0:m2"}
{"signature": "def has_kwargs(self):", "body": "return self.kwargs is not None<EOL>", "docstring": "Check if this function supports arbitrary keyword arguments.", "id": "f17798:c0:m8"}
{"signature": "def convert_positional_argument(self, index, arg_value):", "body": "<EOL>if self._has_self:<EOL><INDENT>if index == <NUM_LIT:0>:<EOL><INDENT>return arg_value<EOL><DEDENT>index -= <NUM_LIT:1><EOL><DEDENT>arg_name = self.arg_names[index]<EOL>return self.convert_argument(arg_name, arg_value)<EOL>", "docstring": "Convert and validate a positional argument.\n\n        Args:\n            index (int): The positional index of the argument\n            arg_value (object): The value to convert and validate\n\n        Returns:\n            object: The converted value.", "id": "f17798:c0:m14"}
{"signature": "def _check_and_execute(func, *args, **kwargs):", "body": "convargs = []<EOL>for i, arg in enumerate(args):<EOL><INDENT>val = func.metadata.convert_positional_argument(i, arg)<EOL>convargs.append(val)<EOL><DEDENT>convkw = {}<EOL>for key, val in kwargs:<EOL><INDENT>convkw[key] = func.metadata.convert_argument(key, val)<EOL><DEDENT>if not func.metadata.spec_filled(convargs, convkw):<EOL><INDENT>raise ValidationError(\"<STR_LIT>\", function=func.metadata.name, signature=func.metadata.signature())<EOL><DEDENT>retval = func(*convargs, **convkw)<EOL>return retval<EOL>", "docstring": "Check the type of all parameters with type information, converting\nas appropriate and then execute the function.", "id": "f17799:m0"}
{"signature": "@property<EOL><INDENT>def short_desc(self):<DEDENT>", "body": "if len(self.maindoc) == <NUM_LIT:0>:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>return self.maindoc[<NUM_LIT:0>].contents<EOL>", "docstring": "One line description of this parsed docstring.\n\n        Returns:\n            str", "id": "f17800:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def _join_paragraphs(cls, lines, use_indent=False, leading_blanks=False, trailing_blanks=False):<DEDENT>", "body": "curr_para = []<EOL>paragraphs = []<EOL>for line in lines:<EOL><INDENT>if use_indent:<EOL><INDENT>if line.startswith('<STR_LIT:U+0020>'):<EOL><INDENT>curr_para.append(line.lstrip())<EOL>continue<EOL><DEDENT>elif line == '<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>else:<EOL><INDENT>if len(curr_para) > <NUM_LIT:0>:<EOL><INDENT>paragraphs.append(cls._join_paragraph(curr_para, leading_blanks, trailing_blanks))<EOL><DEDENT>curr_para = [line.lstrip()]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if len(line) != <NUM_LIT:0>:<EOL><INDENT>curr_para.append(line)<EOL><DEDENT>else:<EOL><INDENT>paragraphs.append(cls._join_paragraph(curr_para, leading_blanks, trailing_blanks))<EOL>curr_para = []<EOL><DEDENT><DEDENT><DEDENT>if len(curr_para) > <NUM_LIT:0>:<EOL><INDENT>paragraphs.append(cls._join_paragraph(curr_para, leading_blanks, trailing_blanks))<EOL><DEDENT>return paragraphs<EOL>", "docstring": "Join adjacent lines together into paragraphs using either a blank line or indent as separator.", "id": "f17800:c0:m11"}
{"signature": "def parse_param(param, include_desc=False):", "body": "param_def, _colon, desc = param.partition('<STR_LIT::>')<EOL>if not include_desc:<EOL><INDENT>desc = None<EOL><DEDENT>else:<EOL><INDENT>desc = desc.lstrip()<EOL><DEDENT>if _colon == \"<STR_LIT>\":<EOL><INDENT>raise ValidationError(\"<STR_LIT>\", declaration=param)<EOL><DEDENT>param_name, _space, param_type = param_def.partition('<STR_LIT:U+0020>')<EOL>if len(param_type) < <NUM_LIT:2> or param_type[<NUM_LIT:0>] != '<STR_LIT:(>' or param_type[-<NUM_LIT:1>] != '<STR_LIT:)>':<EOL><INDENT>raise ValidationError(\"<STR_LIT>\", param_string=param_def, type_string=param_type)<EOL><DEDENT>param_type = param_type[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL>return param_name, ParameterInfo(param_type, [], desc)<EOL>", "docstring": "Parse a single typed parameter statement.", "id": "f17800:m0"}
{"signature": "def to_dict(self):", "body": "out = {}<EOL>out['<STR_LIT>'] = self.msg<EOL>out['<STR_LIT:type>'] = self.__class__.__name__<EOL>out['<STR_LIT>'] = self.params<EOL>return out<EOL>", "docstring": "Convert this exception to a dictionary.\n\n        Returns:\n            dist: A dictionary of information about this exception,\n                Has a 'reason' key, a 'type' key  and a dictionary of params", "id": "f17801:c0:m3"}
{"signature": "def format(self, exclude_class=False):", "body": "if exclude_class:<EOL><INDENT>msg = self.msg<EOL><DEDENT>else:<EOL><INDENT>msg = \"<STR_LIT>\" % (self.__class__.__name__, self.msg)<EOL><DEDENT>if len(self.params) != <NUM_LIT:0>:<EOL><INDENT>paramstring = \"<STR_LIT:\\n>\".join([str(key) + \"<STR_LIT>\" + str(val) for key, val in self.params.items()])<EOL>msg += \"<STR_LIT>\" + paramstring<EOL><DEDENT>return msg<EOL>", "docstring": "Format this exception as a string including class name.\n\n        Args:\n            exclude_class (bool): Whether to exclude the exception class\n                name when formatting this exception\n\n        Returns:\n            string: a multiline string with the message, class name and\n                key value parameters passed to create the exception.", "id": "f17801:c0:m1"}
{"signature": "def get_user_falco_rules(self):", "body": "return self._get_falco_rules(\"<STR_LIT:user>\")<EOL>", "docstring": "**Description**\n            Get the user falco rules file in use for this customer. See the `Falco wiki <https://github.com/draios/falco/wiki/Falco-Rules>`_ for documentation on the falco rules format.\n\n        **Arguments**\n            - None\n\n        **Success Return Value**\n            The contents of the user falco rules file.\n\n        **Example**\n            `examples/get_secure_user_falco_rules.py <https://github.com/draios/python-sdc-client/blob/master/examples/get_secure_user_falco_rules.py>`_", "id": "f17816:c0:m3"}
{"signature": "def list_compliance_tasks(self):", "body": "res = requests.get(self.url + '<STR_LIT>', headers=self.hdrs, verify=self.ssl_verify)<EOL>return self._request_result(res)<EOL>", "docstring": "**Description**\n            Get the list of all compliance tasks.\n\n        **Arguments**\n            - None\n\n        **Success Return Value**\n            A JSON list with the representation of each compliance task.", "id": "f17816:c0:m30"}
{"signature": "def delete_all_policies(self):", "body": "res = requests.post(self.url + '<STR_LIT>', headers=self.hdrs, verify=self.ssl_verify)<EOL>if not self._checkResponse(res):<EOL><INDENT>return [False, self.lasterr]<EOL><DEDENT>return [True, \"<STR_LIT>\"]<EOL>", "docstring": "**Description**\n            Delete all existing policies. The falco rules file is unchanged.\n\n        **Arguments**\n            - None\n\n        **Success Return Value**\n            The string \"Policies Deleted\"\n\n        **Example**\n            `examples/delete_all_policies.py <https://github.com/draios/python-sdc-client/blob/master/examples/delete_all_policies.py>`_", "id": "f17816:c0:m20"}
{"signature": "def set_system_falco_rules(self, rules_content):", "body": "return self._set_falco_rules(\"<STR_LIT>\", rules_content)<EOL>", "docstring": "**Description**\n            Set the system falco rules file in use for this customer. NOTE: This API endpoint can *only* be used in on-premise deployments. Generally the system falco rules file is only modified in conjunction with Sysdig support. See the `Falco wiki <https://github.com/draios/falco/wiki/Falco-Rules>`_ for documentation on the falco rules format.\n\n        **Arguments**\n            - A string containing the system falco rules.\n\n        **Success Return Value**\n            The contents of the system falco rules file that were just updated.\n\n        **Example**\n            `examples/set_secure_system_falco_rules.py <https://github.com/draios/python-sdc-client/blob/master/examples/get_secure_system_falco_rules.py>`_", "id": "f17816:c0:m5"}
{"signature": "def get_compliance_task(self, id):", "body": "res = requests.get(self.url + '<STR_LIT>'.format(id), headers=self.hdrs, verify=self.ssl_verify)<EOL>return self._request_result(res)<EOL>", "docstring": "**Description**\n            Get a compliance task.\n\n        **Arguments**\n            - id: the id of the compliance task to get.\n\n        **Success Return Value**\n            A JSON representation of the compliance task.", "id": "f17816:c0:m31"}
{"signature": "def get_sysdig_captures(self, from_sec=None, to_sec=None, scope_filter=None):", "body": "url = '<STR_LIT>'.format(<EOL>url=self.url,<EOL>source=self.product,<EOL>frm=\"<STR_LIT>\" % (from_sec * <NUM_LIT:10>**<NUM_LIT:6>) if from_sec else \"<STR_LIT>\",<EOL>to=\"<STR_LIT>\" % (to_sec * <NUM_LIT:10>**<NUM_LIT:6>) if to_sec else \"<STR_LIT>\",<EOL>scopeFilter=\"<STR_LIT>\" % scope_filter if scope_filter else \"<STR_LIT>\")<EOL>res = requests.get(url, headers=self.hdrs, verify=self.ssl_verify)<EOL>return self._request_result(res)<EOL>", "docstring": "**Description**\n            Returns the list of sysdig captures for the user.\n\n        **Arguments**\n            - from_sec: the start of the timerange for which to get the captures\n            - end_sec: the end of the timerange for which to get the captures\n            - scope_filter: this is a SysdigMonitor-like filter (e.g 'container.image=ubuntu'). When provided, events are filtered by their scope, so only a subset will be returned (e.g. 'container.image=ubuntu' will provide only events that have happened on an ubuntu container).\n\n        **Success Return Value**\n            A dictionary containing the list of captures.\n\n        **Example**\n            `examples/list_sysdig_captures.py <https://github.com/draios/python-sdc-client/blob/master/examples/list_sysdig_captures.py>`_", "id": "f17817:c0:m19"}
{"signature": "def get_team(self, name):", "body": "res = self.get_teams(name)<EOL>if res[<NUM_LIT:0>] == False:<EOL><INDENT>return res<EOL><DEDENT>for t in res[<NUM_LIT:1>]:<EOL><INDENT>if t['<STR_LIT:name>'] == name:<EOL><INDENT>return [True, t]<EOL><DEDENT><DEDENT>return [False, '<STR_LIT>']<EOL>", "docstring": "**Description**\n            Return the team with the specified team name, if it is present.\n\n        **Arguments**\n            - **name**: the name of the team to return\n\n        **Success Return Value**\n            The requested team.\n\n        **Example**\n            `examples/user_team_mgmt.py <https://github.com/draios/python-sdc-client/blob/master/examples/user_team_mgmt.py>`_", "id": "f17817:c0:m29"}
{"signature": "def post_event(self, name, description=None, severity=None, event_filter=None, tags=None):", "body": "options = {<EOL>'<STR_LIT:name>': name,<EOL>'<STR_LIT:description>': description,<EOL>'<STR_LIT>': severity,<EOL>'<STR_LIT>': event_filter,<EOL>'<STR_LIT>': tags<EOL>}<EOL>edata = {<EOL>'<STR_LIT>': {k: v for k, v in options.items() if v is not None}<EOL>}<EOL>res = requests.post(self.url + '<STR_LIT>', headers=self.hdrs, data=json.dumps(edata), verify=self.ssl_verify)<EOL>return self._request_result(res)<EOL>", "docstring": "**Description**\n            Send an event to Sysdig Monitor. The events you post are available in the Events tab in the Sysdig Monitor UI and can be overlied to charts.\n\n        **Arguments**\n            - **name**: the name of the new event.\n            - **description**: a longer description offering detailed information about the event.\n            - **severity**: syslog style from 0 (high) to 7 (low).\n            - **event_filter**: metadata, in Sysdig Monitor format, of nodes to associate with the event, e.g. ``host.hostName = 'ip-10-1-1-1' and container.name = 'foo'``.\n            - **tags**: a list of key-value dictionaries that can be used to tag the event. Can be used for filtering/segmenting purposes in Sysdig Monitor.\n\n        **Success Return Value**\n            A dictionary describing the new event.\n\n        **Examples**\n            - `examples/post_event_simple.py <https://github.com/draios/python-sdc-client/blob/master/examples/post_event_simple.py>`_\n            - `examples/post_event.py <https://github.com/draios/python-sdc-client/blob/master/examples/post_event.py>`_", "id": "f17817:c0:m15"}
{"signature": "def get_data_retention_info(self):", "body": "res = requests.get(self.url + '<STR_LIT>', headers=self.hdrs, verify=self.ssl_verify)<EOL>return self._request_result(res)<EOL>", "docstring": "**Description**\n            Return the list of data retention intervals, with beginning and end UTC time for each of them. Sysdig Monitor performs rollups of the data it stores. This means that data is stored at different time granularities depending on how far back in time it is. This call can be used to know what precision you can expect before you make a call to :func:`~SdcClient.get_data`.\n\n        **Success Return Value**\n            A dictionary containing the list of available sampling intervals.\n\n        **Example**\n            `examples/print_data_retention_info.py <https://github.com/draios/python-sdc-client/blob/master/examples/print_data_retention_info.py>`_", "id": "f17817:c0:m13"}
{"signature": "def get_notification_ids(self, channels=None):", "body": "res = requests.get(self.url + '<STR_LIT>', headers=self.hdrs, verify=self.ssl_verify)<EOL>if not self._checkResponse(res):<EOL><INDENT>return False, self.lasterr<EOL><DEDENT>ids = []<EOL>if channels is None:<EOL><INDENT>for ch in res.json()[\"<STR_LIT>\"]:<EOL><INDENT>ids.append(ch['<STR_LIT:id>'])<EOL><DEDENT>return [True, ids]<EOL><DEDENT>for c in channels:<EOL><INDENT>found = False<EOL>for ch in res.json()[\"<STR_LIT>\"]:<EOL><INDENT>if c['<STR_LIT:type>'] == ch['<STR_LIT:type>']:<EOL><INDENT>if c['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>opt = ch['<STR_LIT>']<EOL>if set(opt['<STR_LIT>']) == set(c['<STR_LIT>']):<EOL><INDENT>found = True<EOL>ids.append(ch['<STR_LIT:id>'])<EOL><DEDENT><DEDENT>elif c['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>opt = ch['<STR_LIT>']<EOL>if '<STR_LIT>' in c:<EOL><INDENT>if set(c['<STR_LIT>']) == set(opt['<STR_LIT>']):<EOL><INDENT>found = True<EOL>ids.append(ch['<STR_LIT:id>'])<EOL><DEDENT><DEDENT>elif '<STR_LIT:name>' in c:<EOL><INDENT>if c['<STR_LIT:name>'] == ch.get('<STR_LIT:name>'):<EOL><INDENT>found = True<EOL>ids.append(ch['<STR_LIT:id>'])<EOL><DEDENT><DEDENT><DEDENT>elif c['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>opt = ch['<STR_LIT>']<EOL>if opt['<STR_LIT>'] == c['<STR_LIT>'] and opt['<STR_LIT>'] == c['<STR_LIT>']:<EOL><INDENT>found = True<EOL>ids.append(ch['<STR_LIT:id>'])<EOL><DEDENT><DEDENT>elif c['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>opt = ch['<STR_LIT>']<EOL>if '<STR_LIT>' in opt and opt['<STR_LIT>'] == c['<STR_LIT>']:<EOL><INDENT>found = True<EOL>ids.append(ch['<STR_LIT:id>'])<EOL><DEDENT><DEDENT>elif c['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>if '<STR_LIT:name>' in c:<EOL><INDENT>if c['<STR_LIT:name>'] == ch.get('<STR_LIT:name>'):<EOL><INDENT>found = True<EOL>ids.append(ch['<STR_LIT:id>'])<EOL><DEDENT><DEDENT><DEDENT>elif c['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>if '<STR_LIT:name>' in c:<EOL><INDENT>if c['<STR_LIT:name>'] == ch.get('<STR_LIT:name>'):<EOL><INDENT>found = True<EOL>ids.append(ch['<STR_LIT:id>'])<EOL><DEDENT><DEDENT><DEDENT>elif c['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>if '<STR_LIT:name>' in c:<EOL><INDENT>if c['<STR_LIT:name>'] == ch.get('<STR_LIT:name>'):<EOL><INDENT>found = True<EOL>ids.append(ch['<STR_LIT:id>'])<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>if not found:<EOL><INDENT>return False, \"<STR_LIT>\" + str(c)<EOL><DEDENT><DEDENT>return True, ids<EOL>", "docstring": "**Description**\n            Get an array of all configured Notification Channel IDs, or a filtered subset of them.\n\n        **Arguments**\n            - **channels**: an optional array of dictionaries to limit the set of Notification Channel IDs returned. If not specified, IDs for all configured Notification Channels are returned. Each dictionary contains a ``type`` field that can be one of the available types of Notification Channel (``EMAIL``, ``SNS``, ``PAGER_DUTY``, ``SLACK``, ``OPSGENIE``, ``VICTOROPS``, ``WEBHOOK``) as well as additional elements specific to each channel type.\n\n        **Success Return Value**\n            An array of Notification Channel IDs (integers).\n\n        **Examples**\n            - `examples/create_alert.py <https://github.com/draios/python-sdc-client/blob/master/examples/create_alert.py>`_\n            - `examples/restore_alerts.py <https://github.com/draios/python-sdc-client/blob/master/examples/restore_alerts.py>`_", "id": "f17817:c0:m7"}
{"signature": "def get_data(self, metrics, start_ts, end_ts=<NUM_LIT:0>, sampling_s=<NUM_LIT:0>,<EOL>filter='<STR_LIT>', datasource_type='<STR_LIT:host>', paging=None):", "body": "reqbody = {<EOL>'<STR_LIT>': metrics,<EOL>'<STR_LIT>': datasource_type,<EOL>}<EOL>if start_ts < <NUM_LIT:0>:<EOL><INDENT>reqbody['<STR_LIT>'] = -start_ts<EOL><DEDENT>elif start_ts == <NUM_LIT:0>:<EOL><INDENT>return [False, \"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>reqbody['<STR_LIT:start>'] = start_ts<EOL>reqbody['<STR_LIT:end>'] = end_ts<EOL><DEDENT>if filter != '<STR_LIT>':<EOL><INDENT>reqbody['<STR_LIT>'] = filter<EOL><DEDENT>if paging is not None:<EOL><INDENT>reqbody['<STR_LIT>'] = paging<EOL><DEDENT>if sampling_s != <NUM_LIT:0>:<EOL><INDENT>reqbody['<STR_LIT>'] = sampling_s<EOL><DEDENT>res = requests.post(self.url + '<STR_LIT>', headers=self.hdrs, data=json.dumps(reqbody), verify=self.ssl_verify)<EOL>return self._request_result(res)<EOL>", "docstring": "**Description**\n            Export metric data (both time-series and table-based).\n\n        **Arguments**\n            - **metrics**: a list of dictionaries, specifying the metrics and grouping keys that the query will return. A metric is any of the entries that can be found in the *Metrics* section of the Explore page in Sysdig Monitor. Metric entries require an *aggregations* section specifying how to aggregate the metric across time and containers/hosts. A grouping key is any of the entries that can be found in the *Show* or *Segment By* sections of the Explore page in Sysdig Monitor. These entries are used to apply single or hierarchical segmentation to the returned data and don't require the aggregations section. Refer to the Example link below for ready-to-use code snippets.\n            - **start_ts**: the UTC time (in seconds) of the beginning of the data window. A negative value can be optionally used to indicate a relative time in the past from now. For example, -3600 means \"one hour ago\".\n            - **end_ts**: the UTC time (in seconds) of the end of the data window, or 0 to indicate \"now\". A negative value can also be optionally used to indicate a relative time in the past from now. For example, -3600 means \"one hour ago\".\n            - **sampling_s**: the duration of the samples that will be returned. 0 means that the whole data will be returned as a single sample.\n            - **filter**: a boolean expression combining Sysdig Monitor segmentation criteria that defines what the query will be applied to. For example: *kubernetes.namespace.name='production' and container.image='nginx'*.\n            - **datasource_type**: specify the metric source for the request, can be ``container`` or ``host``. Most metrics, for example ``cpu.used.percent`` or ``memory.bytes.used``, are reported by both hosts and containers. By default, host metrics are used, but if the request contains a container-specific grouping key in the metric list/filter (e.g. ``container.name``), then the container source is used. In cases where grouping keys are missing or apply to both hosts and containers (e.g. ``tag.Name``), *datasource_type* can be explicitly set to avoid any ambiguity and allow the user to select precisely what kind of data should be used for the request. `examples/get_data_datasource.py <https://github.com/draios/python-sdc-client/blob/master/examples/get_data_datasource.py>`_ contains a few examples that should clarify the use of this argument.\n            - **paging**: if segmentation of the query generates values for several different entities (e.g. containers/hosts), this parameter specifies which to include in the returned result. It's specified as a dictionary of inclusive values for ``from`` and ``to`` with the default being ``{ \"from\": 0, \"to\": 9 }``, which will return values for the \"top 10\" entities. The meaning of \"top\" is query-dependent, based on points having been sorted via the specified group aggregation, with the results sorted in ascending order if the group aggregation is ``min`` or ``none``, and descending order otherwise.\n\n        **Success Return Value**\n            A dictionary with the requested data. Data is organized in a list of time samples, each of which includes a UTC timestamp and a list of values, whose content and order reflect what was specified in the *metrics* argument.\n\n        **Examples**\n            - `examples/get_data_simple.py <https://github.com/draios/python-sdc-client/blob/master/examples/get_data_simple.py>`_\n            - `examples/get_data_advanced.py <https://github.com/draios/python-sdc-client/blob/master/examples/get_data_advanced.py>`_\n            - `examples/list_hosts.py <https://github.com/draios/python-sdc-client/blob/master/examples/list_hosts.py>`_\n            - `examples/get_data_datasource.py <https://github.com/draios/python-sdc-client/blob/master/examples/get_data_datasource.py>`_", "id": "f17817:c0:m18"}
{"signature": "def set_explore_grouping_hierarchy(self, new_hierarchy):", "body": "body = {<EOL>'<STR_LIT:id>': '<STR_LIT>',<EOL>'<STR_LIT>': [{'<STR_LIT>': []}]<EOL>}<EOL>for item in new_hierarchy:<EOL><INDENT>body['<STR_LIT>'][<NUM_LIT:0>]['<STR_LIT>'].append({'<STR_LIT>': item})<EOL><DEDENT>res = requests.put(self.url + '<STR_LIT>', headers=self.hdrs,<EOL>data=json.dumps(body), verify=self.ssl_verify)<EOL>if not self._checkResponse(res):<EOL><INDENT>return [False, self.lasterr]<EOL><DEDENT>else:<EOL><INDENT>return [True, None]<EOL><DEDENT>", "docstring": "**Description**\n            Changes the grouping hierarchy in the Explore panel of the current user.\n\n        **Arguments**\n            - **new_hierarchy**: a list of sysdig segmentation metrics indicating the new grouping hierarchy.", "id": "f17820:c0:m8"}
{"signature": "@staticmethod<EOL><INDENT>def convert_scope_string_to_expression(scope):<DEDENT>", "body": "<EOL>if scope is None or not scope:<EOL><INDENT>return [True, []]<EOL><DEDENT>expressions = []<EOL>string_expressions = scope.strip('<STR_LIT>').split('<STR_LIT>')<EOL>expression_re = re.compile('<STR_LIT>')<EOL>for string_expression in string_expressions:<EOL><INDENT>matches = expression_re.match(string_expression)<EOL>if matches is None:<EOL><INDENT>return [False, '<STR_LIT>']<EOL><DEDENT>is_not_operator = matches.group('<STR_LIT>') is not None<EOL>if matches.group('<STR_LIT>') == '<STR_LIT>':<EOL><INDENT>list_value = matches.group('<STR_LIT:value>').strip('<STR_LIT>')<EOL>value_matches = re.findall('<STR_LIT>', list_value)<EOL>if len(value_matches) == <NUM_LIT:0>:<EOL><INDENT>return [False, '<STR_LIT>']<EOL><DEDENT>value_matches = map(lambda v: v[<NUM_LIT:0>] if v[<NUM_LIT:0>] else v[<NUM_LIT:1>], value_matches)<EOL>values = map(lambda v: v.strip('<STR_LIT>'), value_matches)<EOL><DEDENT>else:<EOL><INDENT>values = [matches.group('<STR_LIT:value>').strip('<STR_LIT>')]<EOL><DEDENT>operator_parse_dict = {<EOL>'<STR_LIT>': '<STR_LIT>' if not is_not_operator else '<STR_LIT>',<EOL>'<STR_LIT:=>': '<STR_LIT>' if not is_not_operator else '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>' if not is_not_operator else '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>' if not is_not_operator else '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'<EOL>}<EOL>operator = operator_parse_dict.get(matches.group('<STR_LIT>'), None)<EOL>if operator is None:<EOL><INDENT>return [False, '<STR_LIT>']<EOL><DEDENT>expressions.append({<EOL>'<STR_LIT>': matches.group('<STR_LIT>'),<EOL>'<STR_LIT>': operator,<EOL>'<STR_LIT:value>': values<EOL>})<EOL><DEDENT>return [True, expressions]<EOL>", "docstring": "**Description**\n            Internal function to convert a filter string to a filter object to be used with dashboards.", "id": "f17820:c0:m24"}
{"signature": "def get_alert(self, alertid):", "body": "url = self.url + '<STR_LIT>' + alertid<EOL>res = requests.get(url, headers=self.hdrs, verify=self.ssl_verify)<EOL>if not self._checkResponse(res):<EOL><INDENT>return [False, self.lasterr]<EOL><DEDENT>return [True, res.json()]<EOL>", "docstring": "**Description**\n            Retrieve the scanning alert with the given id\n\n        **Arguments**\n            - alertid: Unique identifier associated with this alert.\n\n        **Success Return Value**\n            A JSON object containing the alert description.", "id": "f17821:c0:m26"}
{"signature": "def add_image(self, image, force=False, dockerfile=None, annotations={}, autosubscribe=True):", "body": "itype = self._discover_inputimage_format(image)<EOL>if itype != '<STR_LIT>':<EOL><INDENT>return [False, \"<STR_LIT>\"]<EOL><DEDENT>payload = {}<EOL>if dockerfile:<EOL><INDENT>payload['<STR_LIT>'] = base64.b64encode(dockerfile.encode()).decode(\"<STR_LIT:utf-8>\")<EOL><DEDENT>payload['<STR_LIT>'] = image<EOL>if annotations:<EOL><INDENT>payload['<STR_LIT>'] = annotations<EOL><DEDENT>url = \"<STR_LIT>\".format(<EOL>base_url=self.url,<EOL>autosubscribe=str(autosubscribe),<EOL>force=\"<STR_LIT>\" if force else \"<STR_LIT>\")<EOL>res = requests.post(url, data=json.dumps(payload), headers=self.hdrs, verify=self.ssl_verify)<EOL>if not self._checkResponse(res):<EOL><INDENT>return [False, self.lasterr]<EOL><DEDENT>return [True, res.json()]<EOL>", "docstring": "**Description**\n            Add an image to the scanner\n\n        **Arguments**\n            - image: Input image can be in the following formats: registry/repo:tag\n            - dockerfile: The contents of the dockerfile as a str.\n            - annotations: A dictionary of annotations {str: str}.\n            - autosubscribe: Should active the subscription to this image?\n\n        **Success Return Value**\n            A JSON object representing the image that was added.", "id": "f17821:c0:m1"}
{"signature": "def deactivate_subscription(self, subscription_type, subscription_key):", "body": "return self._update_subscription(subscription_type, subscription_key, False)<EOL>", "docstring": "**Description**\n            Deactivate a subscription\n\n        **Arguments**\n            - subscription_type: Type of subscription. Valid options:\n                - 'tag_update': Receive notification when new image is pushed\n                - 'policy_eval': Receive notification when image policy status changes\n                - 'vuln_update': Receive notification when vulnerabilities are added, removed or modified\n            - subscription_key: Fully qualified name of tag to subscribe to. Eg. docker.io/library/alpine:latest", "id": "f17821:c0:m30"}
{"signature": "def activate_subscription(self, subscription_type, subscription_key):", "body": "return self._update_subscription(subscription_type, subscription_key, True)<EOL>", "docstring": "**Description**\n            Activate a subscription\n\n        **Arguments**\n            - subscription_type: Type of subscription. Valid options:\n                - 'tag_update': Receive notification when new image is pushed\n                - 'policy_eval': Receive notification when image policy status changes\n                - 'vuln_update': Receive notification when vulnerabilities are added, removed or modified\n            - subscription_key: Fully qualified name of tag to subscribe to. Eg. docker.io/library/alpine:latest", "id": "f17821:c0:m29"}
{"signature": "def import_image(self, image_data):", "body": "url = self.url + \"<STR_LIT>\"<EOL>res = requests.post(url, data=json.dumps(image_data), headers=self.hdrs, verify=self.ssl_verify)<EOL>if not self._checkResponse(res):<EOL><INDENT>return [False, self.lasterr]<EOL><DEDENT>return [True, res.json()]<EOL>", "docstring": "**Description**\n            Import an image from the scanner export\n\n        **Arguments**\n            - image_data: A JSON with the image information.\n\n        **Success Return Value**\n            A JSON object representing the image that was imported.", "id": "f17821:c0:m2"}
{"signature": "def update_registry(self, registry, registry_user, registry_pass, insecure=False, registry_type=\"<STR_LIT>\", validate=True):", "body": "if self._registry_string_is_valid(registry):<EOL><INDENT>return [False, \"<STR_LIT>\"]<EOL><DEDENT>payload = {<EOL>'<STR_LIT>': registry,<EOL>'<STR_LIT>': registry_user,<EOL>'<STR_LIT>': registry_pass,<EOL>'<STR_LIT>': registry_type,<EOL>'<STR_LIT>': not insecure}<EOL>url = \"<STR_LIT>\".format(<EOL>base_url=self.url,<EOL>registry=registry,<EOL>validate=validate)<EOL>res = requests.put(url, data=json.dumps(payload), headers=self.hdrs, verify=self.ssl_verify)<EOL>if not self._checkResponse(res):<EOL><INDENT>return [False, self.lasterr]<EOL><DEDENT>return [True, res.json()]<EOL>", "docstring": "**Description**\n            Update an existing image registry.\n\n        **Arguments**\n            - registry: Full hostname/port of registry. Eg. myrepo.example.com:5000\n            - registry_user: Username\n            - registry_pass: Password\n            - insecure: Allow connection to registry without SSL cert checks (ex: if registry uses a self-signed SSL certificate)\n            - registry_type: Specify the registry type. 'docker_v2' and 'awsecr' are supported (default='docker_v2')\n            - validate: If set to 'False' will not attempt to validate registry/creds on registry add\n\n        **Success Return Value**\n            A JSON object representing the registry.", "id": "f17821:c0:m12"}
{"signature": "def list_runtime(self, scope=\"<STR_LIT>\", skip_policy_evaluation=True, start_time=None, end_time=None):", "body": "containers = {<EOL>'<STR_LIT>': scope,<EOL>'<STR_LIT>': skip_policy_evaluation<EOL>}<EOL>if start_time or end_time:<EOL><INDENT>containers['<STR_LIT:time>'] = {}<EOL>containers['<STR_LIT:time>']['<STR_LIT>'] = int(start_time * <NUM_LIT>) if start_time else <NUM_LIT:0><EOL>end_time = end_time if end_time else time.time()<EOL>containers['<STR_LIT:time>']['<STR_LIT:to>'] = int(end_time * <NUM_LIT>)<EOL><DEDENT>url = self.url + '<STR_LIT>'<EOL>data = json.dumps(containers)<EOL>res = requests.post(url, headers=self.hdrs, data=data, verify=self.ssl_verify)<EOL>if not self._checkResponse(res):<EOL><INDENT>return [False, self.lasterr]<EOL><DEDENT>return [True, res.json()]<EOL>", "docstring": "**Description**\n            List runtime containers\n\n        **Arguments**\n            - scope: An AND-composed string of predicates that selects the scope in which the alert will be applied. (like: 'host.domain = \"example.com\" and container.image != \"alpine:latest\"')\n            - skip_policy_evaluation: If true, no policy evaluations will be triggered for the images.\n            - start_time: Start of the time range (integer of unix time).\n            - end_time: End of the time range (integer of unix time).\n\n        **Success Return Value**\n            A JSON object representing the list of runtime containers.", "id": "f17821:c0:m33"}
{"signature": "def generate_access_code():", "body": "length = <NUM_LIT:6><EOL>chars = string.uppercase + string.digits[<NUM_LIT:1>:]<EOL>return get_random_string(length=length, allowed_chars=chars)<EOL>", "docstring": "Generates an access code for users' payments as well as their\n    fulfilment code for check-in.\n    The access code will 4 characters long, which allows for 1,500,625\n    unique codes, which really should be enough for anyone.", "id": "f17883:m0"}
{"signature": "def pay(self, reference, amount, pre_validate=True):", "body": "if pre_validate:<EOL><INDENT>self.validate_allowed_to_pay()<EOL><DEDENT>'''<STR_LIT>'''<EOL>commerce.PaymentBase.objects.create(<EOL>invoice=self.invoice,<EOL>reference=reference,<EOL>amount=amount,<EOL>)<EOL>self.update_status()<EOL>", "docstring": "Testing method for simulating an invoice paymenht by the given\n        amount.", "id": "f17886:c1:m0"}
{"signature": "def add_to_cart(self, product, quantity):", "body": "try:<EOL><INDENT>product_item = commerce.ProductItem.objects.get(<EOL>cart=self.cart,<EOL>product=product)<EOL>old_quantity = product_item.quantity<EOL><DEDENT>except ObjectDoesNotExist:<EOL><INDENT>old_quantity = <NUM_LIT:0><EOL><DEDENT>self.set_quantity(product, old_quantity + quantity)<EOL>", "docstring": "Adds _quantity_ of the given _product_ to the cart. Raises\n        ValidationError if constraints are violated.", "id": "f17886:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def _create_flag_for_additional_speaker(cls):<DEDENT>", "body": "flag = conditions.SpeakerFlag.objects.create(<EOL>description=\"<STR_LIT>\",<EOL>condition=conditions.FlagBase.ENABLE_IF_TRUE,<EOL>is_presenter=False,<EOL>is_copresenter=True,<EOL>)<EOL>flag.proposal_kind.add(cls.KIND_1)<EOL>flag.products.add(cls.PROD_1)<EOL>", "docstring": "Adds flag -- PROD_1 is not available unless user is a primary\n        presenter of a KIND_2", "id": "f17893:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def _create_flag_for_primary_speaker(cls):<DEDENT>", "body": "flag = conditions.SpeakerFlag.objects.create(<EOL>description=\"<STR_LIT>\",<EOL>condition=conditions.FlagBase.ENABLE_IF_TRUE,<EOL>is_presenter=True,<EOL>is_copresenter=False,<EOL>)<EOL>flag.proposal_kind.add(cls.KIND_1)<EOL>flag.products.add(cls.PROD_1)<EOL>", "docstring": "Adds flag -- PROD_1 is not available unless user is a primary\n        presenter of a KIND_1", "id": "f17893:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def add_product_flag_on_category(<EOL>cls,<EOL>condition=conditions.FlagBase.ENABLE_IF_TRUE,<EOL>):<DEDENT>", "body": "flag = conditions.ProductFlag.objects.create(<EOL>description=\"<STR_LIT>\",<EOL>condition=condition,<EOL>)<EOL>flag.categories.add(cls.CAT_1)<EOL>flag.enabling_products.add(cls.PROD_3)<EOL>", "docstring": "Adds a product flag condition that operates on a category:\n        adding an item from CAT_1 is predicated on adding PROD_3 beforehand", "id": "f17895:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def add_product_flag(cls, condition=conditions.FlagBase.ENABLE_IF_TRUE):<DEDENT>", "body": "flag = conditions.ProductFlag.objects.create(<EOL>description=\"<STR_LIT>\",<EOL>condition=condition,<EOL>)<EOL>flag.products.add(cls.PROD_1)<EOL>flag.enabling_products.add(cls.PROD_2)<EOL>", "docstring": "Adds a product flag condition: adding PROD_1 to a cart is\n        predicated on adding PROD_2 beforehand.", "id": "f17895:c0:m0"}
{"signature": "def report_view(title, form_type=None):", "body": "<EOL>def _report(view):<EOL><INDENT>report_view = ReportView(view, title, form_type)<EOL>report_view = user_passes_test(views._staff_only)(report_view)<EOL>report_view = wraps(view)(report_view)<EOL>_all_report_views.append(report_view)<EOL>return report_view<EOL><DEDENT>return _report<EOL>", "docstring": "Decorator that converts a report view function into something that\n    displays a Report.\n\n    Arguments:\n        title (str):\n            The title of the report.\n        form_type (Optional[forms.Form]):\n            A form class that can make this report display things. If not\n            supplied, no form will be displayed.", "id": "f17900:m0"}
{"signature": "def __init__(self, inner_view, title, form_type):", "body": "<EOL>self.inner_view = inner_view<EOL>self.title = title<EOL>self.form_type = form_type<EOL>", "docstring": "Arguments:\n    inner_view: Callable that returns either a Report or a sequence of\n        Report objects.\n\n    title: The title that appears at the top of all of the reports.\n\n    form_type: A Form class that can be used to query the report.", "id": "f17900:c6:m0"}
{"signature": "def rows(content_type):", "body": "raise NotImplementedError<EOL>", "docstring": "Arguments:\n    content_type (str): The content-type for the output format of this\n    report.\n\nReturns:\n    An iterator, which yields each row of the data. Each row should\n    be an iterable containing the cells, rendered appropriately for\n    content_type.", "id": "f17900:c0:m3"}
{"signature": "@report_view(\"<STR_LIT>\", form_type=forms.DiscountForm)<EOL>def discount_status(request, form):", "body": "discounts = form.cleaned_data[\"<STR_LIT>\"]<EOL>items = commerce.DiscountItem.objects.filter(<EOL>Q(discount__in=discounts),<EOL>).select_related(\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\")<EOL>items = group_by_cart_status(<EOL>items,<EOL>[\"<STR_LIT>\"],<EOL>[\"<STR_LIT>\", \"<STR_LIT>\"],<EOL>)<EOL>headings = [<EOL>\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\",<EOL>]<EOL>data = []<EOL>for item in items:<EOL><INDENT>data.append([<EOL>item[\"<STR_LIT>\"],<EOL>item[\"<STR_LIT>\"],<EOL>item[\"<STR_LIT>\"],<EOL>item[\"<STR_LIT>\"],<EOL>item[\"<STR_LIT>\"],<EOL>])<EOL><DEDENT>return ListReport(\"<STR_LIT>\", headings, data)<EOL>", "docstring": "Summarises the usage of a given discount.", "id": "f17901:m9"}
{"signature": "def sales_payment_summary():", "body": "def value_or_zero(aggregate, key):<EOL><INDENT>return aggregate[key] or <NUM_LIT:0><EOL><DEDENT>def sum_amount(payment_set):<EOL><INDENT>a = payment_set.values(\"<STR_LIT>\").aggregate(total=Sum(\"<STR_LIT>\"))<EOL>return value_or_zero(a, \"<STR_LIT>\")<EOL><DEDENT>headings = [\"<STR_LIT>\", \"<STR_LIT>\"]<EOL>data = []<EOL>sales = commerce.LineItem.objects.filter(<EOL>invoice__status=commerce.Invoice.STATUS_PAID,<EOL>).values(<EOL>\"<STR_LIT>\", \"<STR_LIT>\"<EOL>).aggregate(<EOL>total=Sum(F(\"<STR_LIT>\") * F(\"<STR_LIT>\"), output_field=CURRENCY()),<EOL>)<EOL>sales = value_or_zero(sales, \"<STR_LIT>\")<EOL>all_payments = sum_amount(commerce.PaymentBase.objects.all())<EOL>all_credit_notes = <NUM_LIT:0> - sum_amount(commerce.CreditNote.objects.all())<EOL>unclaimed_credit_notes = <NUM_LIT:0> - sum_amount(commerce.CreditNote.unclaimed())<EOL>claimed_credit_notes = sum_amount(<EOL>commerce.CreditNoteApplication.objects.all()<EOL>)<EOL>refunded_credit_notes = <NUM_LIT:0> - sum_amount(commerce.CreditNote.refunded())<EOL>data.append([\"<STR_LIT>\", sales])<EOL>data.append([\"<STR_LIT>\", all_payments])<EOL>data.append([\"<STR_LIT>\", sales - all_payments])<EOL>data.append([\"<STR_LIT>\", all_credit_notes])<EOL>data.append([\"<STR_LIT>\", claimed_credit_notes])<EOL>data.append([\"<STR_LIT>\", refunded_credit_notes])<EOL>data.append([\"<STR_LIT>\", unclaimed_credit_notes])<EOL>data.append([<EOL>\"<STR_LIT>\",<EOL>all_credit_notes - claimed_credit_notes -<EOL>refunded_credit_notes - unclaimed_credit_notes<EOL>])<EOL>return ListReport(\"<STR_LIT>\", headings, data)<EOL>", "docstring": "Summarises paid items and payments.", "id": "f17901:m4"}
{"signature": "def model_fields_form_factory(model):", "body": "fields = model._meta.get_fields()<EOL>choices = []<EOL>for field in fields:<EOL><INDENT>if hasattr(field, \"<STR_LIT>\"):<EOL><INDENT>choices.append((field.name, field.verbose_name))<EOL><DEDENT><DEDENT>class ModelFieldsForm(forms.Form):<EOL><INDENT>fields = forms.MultipleChoiceField(<EOL>choices=choices,<EOL>required=False,<EOL>)<EOL><DEDENT>return ModelFieldsForm<EOL>", "docstring": "Creates a form for specifying fields from a model to display.", "id": "f17902:m1"}
{"signature": "@register.tag<EOL>def include_if_exists(parser, token):", "body": "try:<EOL><INDENT>tag_name, template_name = token.split_contents()<EOL><DEDENT>except ValueError:<EOL><INDENT>raise template.TemplateSyntaxError(\"<STR_LIT>\" % token.contents.split()[<NUM_LIT:0>])<EOL><DEDENT>return IncludeNode(template_name)<EOL>", "docstring": "Usage: {% include_if_exists \"head.html\" %}\n\n    This will fail silently if the template doesn't exist. If it does, it will\n    be rendered with the current context.\n\n    From: https://djangosnippets.org/snippets/2058/", "id": "f17903:m11"}
{"signature": "@register.assignment_tag(takes_context=True)<EOL>def items_purchased(context, category=None):", "body": "return ItemController(user_for_context(context)).items_purchased(<EOL>category=category<EOL>)<EOL>", "docstring": "Returns the items purchased for this user.\n\n    The user will be either `context.user`, and `context.request.user` if\n    the former is not defined.", "id": "f17903:m6"}
{"signature": "@register.assignment_tag(takes_context=True)<EOL>def available_categories(context):", "body": "return CategoryController.available_categories(user_for_context(context))<EOL>", "docstring": "Gets all of the currently available products.\n\n    Returns:\n        [models.inventory.Category, ...]: A list of all of the categories that\n            have Products that the current user can reserve.", "id": "f17903:m1"}
{"signature": "@register.assignment_tag(takes_context=True)<EOL>def items_pending(context):", "body": "return ItemController(user_for_context(context)).items_pending()<EOL>", "docstring": "Gets all of the items that the user from this context has reserved.\n\n    The user will be either `context.user`, and `context.request.user` if\n    the former is not defined.", "id": "f17903:m5"}
{"signature": "@login_required<EOL>def review(request):", "body": "return render(<EOL>request,<EOL>\"<STR_LIT>\",<EOL>{},<EOL>)<EOL>", "docstring": "View for the review page.", "id": "f17910:m3"}
{"signature": "def _handle_profile(request, prefix):", "body": "attendee = people.Attendee.get_instance(request.user)<EOL>try:<EOL><INDENT>profile = attendee.attendeeprofilebase<EOL>profile = people.AttendeeProfileBase.objects.get_subclass(<EOL>pk=profile.id,<EOL>)<EOL><DEDENT>except ObjectDoesNotExist:<EOL><INDENT>profile = None<EOL><DEDENT>try:<EOL><INDENT>speaker_profile = request.user.speaker_profile<EOL>speaker_name = speaker_profile.name<EOL><DEDENT>except ObjectDoesNotExist:<EOL><INDENT>speaker_name = None<EOL><DEDENT>name_field = ProfileForm.Meta.model.name_field()<EOL>initial = {}<EOL>if profile is None and name_field is not None:<EOL><INDENT>initial[name_field] = speaker_name<EOL><DEDENT>form = ProfileForm(<EOL>request.POST or None,<EOL>initial=initial,<EOL>instance=profile,<EOL>prefix=prefix<EOL>)<EOL>handled = True if request.POST else False<EOL>if request.POST and form.is_valid():<EOL><INDENT>form.instance.attendee = attendee<EOL>form.save()<EOL><DEDENT>return form, handled<EOL>", "docstring": "Returns a profile form instance, and a boolean which is true if the\n    form was handled.", "id": "f17910:m5"}
{"signature": "def voucher_code(request):", "body": "VOUCHERS_FORM_PREFIX = \"<STR_LIT>\"<EOL>v = _handle_voucher(request, VOUCHERS_FORM_PREFIX)<EOL>voucher_form, voucher_handled = v<EOL>if voucher_handled:<EOL><INDENT>messages.success(request, \"<STR_LIT>\")<EOL>return redirect(\"<STR_LIT>\")<EOL><DEDENT>data = {<EOL>\"<STR_LIT>\": voucher_form,<EOL>}<EOL>return render(request, \"<STR_LIT>\", data)<EOL>", "docstring": "A view *just* for entering a voucher form.", "id": "f17910:m7"}
{"signature": "def _staff_only(user):", "body": "return user.is_staff<EOL>", "docstring": "Returns true if the user is staff.", "id": "f17910:m15"}
{"signature": "@login_required<EOL>def edit_profile(request):", "body": "form, handled = _handle_profile(request, \"<STR_LIT>\")<EOL>if handled and not form.errors:<EOL><INDENT>messages.success(<EOL>request,<EOL>\"<STR_LIT>\",<EOL>)<EOL>return redirect(\"<STR_LIT>\")<EOL><DEDENT>data = {<EOL>\"<STR_LIT>\": form,<EOL>}<EOL>return render(request, \"<STR_LIT>\", data)<EOL>", "docstring": "View for editing an attendee's profile\n\n    The user must be logged in to edit their profile.\n\n    Returns:\n        redirect or render:\n            In the case of a ``POST`` request, it'll redirect to ``dashboard``,\n            or otherwise, it will render ``registrasion/profile_form.html``\n            with data::\n\n                {\n                    \"form\": form,  # Instance of ATTENDEE_PROFILE_FORM.\n                }", "id": "f17910:m4"}
{"signature": "@login_required<EOL>def product_category(request, category_id):", "body": "PRODUCTS_FORM_PREFIX = \"<STR_LIT>\"<EOL>VOUCHERS_FORM_PREFIX = \"<STR_LIT>\"<EOL>v = _handle_voucher(request, VOUCHERS_FORM_PREFIX)<EOL>voucher_form, voucher_handled = v<EOL>category_id = int(category_id)  <EOL>category = inventory.Category.objects.get(pk=category_id)<EOL>with BatchController.batch(request.user):<EOL><INDENT>products = ProductController.available_products(<EOL>request.user,<EOL>category=category,<EOL>)<EOL>if not products:<EOL><INDENT>messages.warning(<EOL>request,<EOL>(<EOL>\"<STR_LIT>\" +<EOL>category.name<EOL>),<EOL>)<EOL>return redirect(\"<STR_LIT>\")<EOL><DEDENT>p = _handle_products(request, category, products, PRODUCTS_FORM_PREFIX)<EOL>products_form, discounts, products_handled = p<EOL><DEDENT>if request.POST and not voucher_handled and not products_form.errors:<EOL><INDENT>if products_form.has_changed():<EOL><INDENT>messages.success(<EOL>request,<EOL>\"<STR_LIT>\",<EOL>)<EOL><DEDENT>return redirect(review)<EOL><DEDENT>data = {<EOL>\"<STR_LIT>\": category,<EOL>\"<STR_LIT>\": discounts,<EOL>\"<STR_LIT>\": products_form,<EOL>\"<STR_LIT>\": voucher_form,<EOL>}<EOL>return render(request, \"<STR_LIT>\", data)<EOL>", "docstring": "Form for selecting products from an individual product category.\n\n    Arguments:\n        category_id (castable to int): The id of the category to display.\n\n    Returns:\n        redirect or render:\n            If the form has been sucessfully submitted, redirect to\n            ``dashboard``. Otherwise, render\n            ``registrasion/product_category.html`` with data::\n\n                {\n                    \"category\": category,         # An inventory.Category for\n                                                  # category_id\n                    \"discounts\": discounts,       # A list of\n                                                  # DiscountAndQuantity\n                    \"form\": products_form,        # A form for selecting\n                                                  # products\n                    \"voucher_form\": voucher_form, # A form for entering a\n                                                  # voucher code\n                }", "id": "f17910:m6"}
{"signature": "@classmethod<EOL><INDENT>@contextlib.contextmanager<EOL>def batch(cls, user):<DEDENT>", "body": "cls._enter_batch_context(user)<EOL>try:<EOL><INDENT>yield<EOL><DEDENT>finally:<EOL><INDENT>cls._exit_batch_context(user)<EOL><DEDENT>", "docstring": "Marks the entry point for a batch for the given user.", "id": "f17912:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>@BatchController.memoise<EOL>def _filtered_clauses(cls, user):<DEDENT>", "body": "types = list(ConditionController._controllers())<EOL>discounttypes = [<EOL>i for i in types if issubclass(i, conditions.DiscountBase)<EOL>]<EOL>product_clauses = conditions.DiscountForProduct.objects.all()<EOL>product_clauses = product_clauses.select_related(<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>)<EOL>category_clauses = conditions.DiscountForCategory.objects.all()<EOL>category_clauses = category_clauses.select_related(<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>)<EOL>all_subsets = []<EOL>for discounttype in discounttypes:<EOL><INDENT>discounts = discounttype.objects.all()<EOL>ctrl = ConditionController.for_type(discounttype)<EOL>discounts = ctrl.pre_filter(discounts, user)<EOL>all_subsets.append(discounts)<EOL><DEDENT>filtered_discounts = list(itertools.chain(*all_subsets))<EOL>from_filter = dict((i.id, i) for i in filtered_discounts)<EOL>clause_sets = (<EOL>product_clauses.filter(discount__in=filtered_discounts),<EOL>category_clauses.filter(discount__in=filtered_discounts),<EOL>)<EOL>clause_sets = (<EOL>cls._annotate_with_past_uses(i, user) for i in clause_sets<EOL>)<EOL>discount_clauses = set(itertools.chain(*clause_sets))<EOL>for clause in discount_clauses:<EOL><INDENT>clause.discount = from_filter[clause.discount.id]<EOL><DEDENT>return discount_clauses<EOL>", "docstring": "Returns:\n    Sequence[DiscountForProduct | DiscountForCategory]: All clauses\n    that passed the filter function.", "id": "f17915:c1:m1"}
{"signature": "def _modifies_cart(func):", "body": "@functools.wraps(func)<EOL>def inner(self, *a, **k):<EOL><INDENT>self._fail_if_cart_is_not_active()<EOL>with transaction.atomic():<EOL><INDENT>with BatchController.batch(self.cart.user):<EOL><INDENT>memoised = self.for_user(self.cart.user)<EOL>memoised._modified_by_batch = True<EOL>return func(self, *a, **k)<EOL><DEDENT><DEDENT><DEDENT>return inner<EOL>", "docstring": "Decorator that makes the wrapped function raise ValidationError\n    if we're doing something that could modify the cart.\n\n    It also wraps the execution of this function in a database transaction,\n    and marks the boundaries of a cart operations batch.", "id": "f17917:m0"}
{"signature": "def _autoextend_reservation(self):", "body": "time = timezone.now()<EOL>time_elapsed_since_updated = (time - self.cart.time_last_updated)<EOL>residual = self.cart.reservation_duration - time_elapsed_since_updated<EOL>reservations = [datetime.timedelta(<NUM_LIT:0>), residual]<EOL>if len(self.cart.vouchers.all()) >= <NUM_LIT:1>:<EOL><INDENT>reservations.append(inventory.Voucher.RESERVATION_DURATION)<EOL><DEDENT>items = commerce.ProductItem.objects.filter(cart=self.cart)<EOL>agg = items.aggregate(Max(\"<STR_LIT>\"))<EOL>product_max = agg[\"<STR_LIT>\"]<EOL>if product_max is not None:<EOL><INDENT>reservations.append(product_max)<EOL><DEDENT>self.cart.time_last_updated = time<EOL>self.cart.reservation_duration = max(reservations)<EOL>", "docstring": "Updates the cart's time last updated value, which is used to\n        determine whether the cart has reserved the items and discounts it\n        holds.", "id": "f17917:c0:m3"}
{"signature": "def validate_cart(self):", "body": "cart = self.cart<EOL>user = self.cart.user<EOL>errors = []<EOL>try:<EOL><INDENT>self._test_vouchers(self.cart.vouchers.all())<EOL><DEDENT>except ValidationError as ve:<EOL><INDENT>errors.append(ve)<EOL><DEDENT>items = commerce.ProductItem.objects.filter(cart=cart)<EOL>items = items.select_related(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>product_quantities = list((i.product, i.quantity) for i in items)<EOL>try:<EOL><INDENT>self._test_limits(product_quantities)<EOL><DEDENT>except ValidationError as ve:<EOL><INDENT>self._append_errors(errors, ve)<EOL><DEDENT>try:<EOL><INDENT>self._test_required_categories()<EOL><DEDENT>except ValidationError as ve:<EOL><INDENT>self._append_errors(errors, ve)<EOL><DEDENT>products = [i.product for i in items]<EOL>discounts_with_quantity = DiscountController.available_discounts(<EOL>user,<EOL>[],<EOL>products,<EOL>)<EOL>discounts = set(i.discount.id for i in discounts_with_quantity)<EOL>discount_items = commerce.DiscountItem.objects.filter(cart=cart)<EOL>for discount_item in discount_items:<EOL><INDENT>discount = discount_item.discount<EOL>if discount.id not in discounts:<EOL><INDENT>errors.append(<EOL>ValidationError(\"<STR_LIT>\")<EOL>)<EOL><DEDENT><DEDENT>if errors:<EOL><INDENT>raise ValidationError(errors)<EOL><DEDENT>", "docstring": "Determines whether the status of the current cart is valid;\n        this is normally called before generating or paying an invoice", "id": "f17917:c0:m14"}
{"signature": "def extend_reservation(self, timedelta):", "body": "self.validate_cart()<EOL>cart = self.cart<EOL>cart.refresh_from_db()<EOL>elapsed = (timezone.now() - cart.time_last_updated)<EOL>if cart.reservation_duration - elapsed > timedelta:<EOL><INDENT>return<EOL><DEDENT>cart.time_last_updated = timezone.now()<EOL>cart.reservation_duration = timedelta<EOL>cart.save()<EOL>", "docstring": "Extends the reservation on this cart by the given timedelta.\n        This can only be done if the current state of the cart is valid (i.e\n        all items and discounts in the cart are still available.)\n\n        Arguments:\n            timedelta (timedelta): The amount of time to extend the cart by.\n                The resulting reservation_duration will be now() + timedelta,\n                unless the requested extension is *LESS* than the current\n                reservation deadline.", "id": "f17917:c0:m6"}
{"signature": "@classmethod<EOL><INDENT>@BatchController.memoise<EOL>def user_remainders(cls, user):<DEDENT>", "body": "products = inventory.Product.objects.all()<EOL>cart_filter = (<EOL>Q(productitem__cart__user=user) &<EOL>Q(productitem__cart__status=commerce.Cart.STATUS_PAID)<EOL>)<EOL>quantity = When(<EOL>cart_filter,<EOL>then='<STR_LIT>'<EOL>)<EOL>quantity_or_zero = Case(<EOL>quantity,<EOL>default=Value(<NUM_LIT:0>),<EOL>)<EOL>remainder = Case(<EOL>When(limit_per_user=None, then=Value(<NUM_LIT>)),<EOL>default=F('<STR_LIT>') - Sum(quantity_or_zero),<EOL>)<EOL>products = products.annotate(remainder=remainder)<EOL>return dict((product.id, product.remainder) for product in products)<EOL>", "docstring": "Return:\n    Mapping[int->int]: A dictionary that maps the product ID to the\n    user's remainder for that product.", "id": "f17918:c0:m2"}
{"signature": "def user_quantity_remaining(self, user, filtered=True):", "body": "if filtered:<EOL><INDENT>if hasattr(self.condition, \"<STR_LIT>\"):<EOL><INDENT>return self.condition.remainder<EOL><DEDENT><DEDENT>qs = type(self.condition).objects.filter(pk=self.condition.id)<EOL>qs = self.pre_filter(qs, user)<EOL>if len(qs) > <NUM_LIT:0>:<EOL><INDENT>return qs[<NUM_LIT:0>].remainder<EOL><DEDENT>else:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>", "docstring": "returns 0 if the date range is violated, otherwise, it will return\n        the quantity remaining under the stock limit.\n\n        The filter for this condition must add an annotation called \"remainder\"\n        in order for this to work.", "id": "f17920:c2:m0"}
{"signature": "@classmethod<EOL><INDENT>def pre_filter(self, queryset, user):<DEDENT>", "body": "<EOL>queryset = queryset.filter(<EOL>proposal_kind__proposalbase__presentation__cancelled=False<EOL>)<EOL>u = user<EOL>user_is_presenter = Q(<EOL>is_presenter=True,<EOL>proposal_kind__proposalbase__presentation__speaker__user=u,<EOL>)<EOL>user_is_copresenter = Q(<EOL>is_copresenter=True,<EOL>proposal_kind__proposalbase__presentation__additional_speakers__user=u,  <EOL>)<EOL>return queryset.filter(user_is_presenter | user_is_copresenter)<EOL>", "docstring": "Returns all of the items from queryset which are enabled by a user\n        being a presenter or copresenter of a non-cancelled proposal.", "id": "f17920:c9:m0"}
{"signature": "@classmethod<EOL><INDENT>def pre_filter(self, queryset, user):<DEDENT>", "body": "in_user_carts = Q(<EOL>enabling_category__product__productitem__cart__user=user<EOL>)<EOL>released = commerce.Cart.STATUS_RELEASED<EOL>in_released_carts = Q(<EOL>enabling_category__product__productitem__cart__status=released<EOL>)<EOL>queryset = queryset.filter(in_user_carts)<EOL>queryset = queryset.exclude(in_released_carts)<EOL>return queryset<EOL>", "docstring": "Returns all of the items from queryset where the user has a\n        product from a category invoking that item's condition in one of their\n        carts.", "id": "f17920:c3:m0"}
{"signature": "def is_met(self, user, filtered=False):", "body": "if filtered:<EOL><INDENT>return True  <EOL><DEDENT>return self.passes_filter(user)<EOL>", "docstring": "Returns True if this flag condition is met, otherwise returns\n        False. It determines if the condition is met by calling pre_filter\n        with a queryset containing only self.condition.", "id": "f17920:c1:m0"}
{"signature": "@transaction.atomic<EOL><INDENT>def refund(self):<DEDENT>", "body": "if self.invoice.is_void:<EOL><INDENT>raise ValidationError(\"<STR_LIT>\")<EOL><DEDENT>amount = self.invoice.total_payments()<EOL>if amount == <NUM_LIT:0>:<EOL><INDENT>self.void()<EOL>return<EOL><DEDENT>CreditNoteController.generate_from_invoice(self.invoice, amount)<EOL>self.update_status()<EOL>", "docstring": "Refunds the invoice by generating a CreditNote for the value of\n        all of the payments against the cart.\n\n        The invoice is marked as refunded, and the underlying cart is marked\n        as released.", "id": "f17921:c0:m19"}
{"signature": "@classmethod<EOL><INDENT>def _apply_credit_notes(cls, invoice):<DEDENT>", "body": "<EOL>invoices = commerce.Invoice.objects.filter(<EOL>user=invoice.user,<EOL>status=commerce.Invoice.STATUS_UNPAID,<EOL>)<EOL>if invoices.count() > <NUM_LIT:1>:<EOL><INDENT>return<EOL><DEDENT>notes = commerce.CreditNote.unclaimed().filter(<EOL>invoice__user=invoice.user<EOL>)<EOL>for note in notes:<EOL><INDENT>try:<EOL><INDENT>CreditNoteController(note).apply_to_invoice(invoice)<EOL><DEDENT>except ValidationError:<EOL><INDENT>break<EOL><DEDENT><DEDENT>invoice.refresh_from_db()<EOL>", "docstring": "Applies the user's credit notes to the given invoice on creation.", "id": "f17921:c0:m7"}
{"signature": "def _refresh(self):", "body": "self.invoice.refresh_from_db()<EOL>if self.invoice.cart:<EOL><INDENT>self.invoice.cart.refresh_from_db()<EOL><DEDENT>", "docstring": "Refreshes the underlying invoice and cart objects.", "id": "f17921:c0:m9"}
{"signature": "@classmethod<EOL><INDENT>def email_on_invoice_change(cls, invoice, old_status, new_status):<DEDENT>", "body": "<EOL>silent_status = [<EOL>commerce.Invoice.STATUS_VOID,<EOL>commerce.Invoice.STATUS_UNPAID,<EOL>]<EOL>if old_status == new_status:<EOL><INDENT>return<EOL><DEDENT>if False and new_status in silent_status:<EOL><INDENT>pass<EOL><DEDENT>cls.email(invoice, \"<STR_LIT>\")<EOL>", "docstring": "Sends out all of the necessary notifications that the status of the\n        invoice has changed to:\n\n        - Invoice is now paid\n        - Invoice is now refunded", "id": "f17921:c0:m22"}
{"signature": "@classmethod<EOL><INDENT>def email(cls, invoice, kind):<DEDENT>", "body": "context = {<EOL>\"<STR_LIT>\": invoice,<EOL>}<EOL>send_email([invoice.user.email], kind, context=context)<EOL>", "docstring": "Sends out an e-mail notifying the user about something to do\n        with that invoice.", "id": "f17921:c0:m20"}
{"signature": "def _mark_void(self):", "body": "self.invoice.status = commerce.Invoice.STATUS_VOID<EOL>self.invoice.save()<EOL>", "docstring": "Marks the invoice as refunded, and updates the attached cart if\n        necessary.", "id": "f17921:c0:m14"}
{"signature": "@classmethod<EOL><INDENT>def initial_data(cls, product_quantities):<DEDENT>", "body": "f = [<EOL>{<EOL>_ItemQuantityProductsForm.CHOICE_FIELD: product.id,<EOL>_ItemQuantityProductsForm.QUANTITY_FIELD: quantity,<EOL>}<EOL>for product, quantity in product_quantities<EOL>if quantity > <NUM_LIT:0><EOL>]<EOL>return f<EOL>", "docstring": "Prepares initial data for an instance of this form.\n        product_quantities is a sequence of (product,quantity) tuples", "id": "f17922:c10:m1"}
{"signature": "def staff_products_formset_factory(user):", "body": "form_type = staff_products_form_factory(user)<EOL>return forms.formset_factory(form_type)<EOL>", "docstring": "Creates a formset of StaffProductsForm for the given user.", "id": "f17922:m2"}
{"signature": "def product_quantities(self):", "body": "return iter([])<EOL>", "docstring": "Yields a sequence of (product, quantity) tuples from the\n        cleaned form data.", "id": "f17922:c4:m4"}
{"signature": "def ProductsForm(category, products):", "body": "<EOL>cat = inventory.Category<EOL>RENDER_TYPES = {<EOL>cat.RENDER_TYPE_QUANTITY: _QuantityBoxProductsForm,<EOL>cat.RENDER_TYPE_RADIO: _RadioButtonProductsForm,<EOL>cat.RENDER_TYPE_ITEM_QUANTITY: _ItemQuantityProductsForm,<EOL>cat.RENDER_TYPE_CHECKBOX: _CheckboxProductsForm,<EOL>}<EOL>class ProductsForm(RENDER_TYPES[category.render_type]):<EOL><INDENT>pass<EOL><DEDENT>products = list(products)<EOL>products.sort(key=lambda prod: prod.order)<EOL>ProductsForm.set_fields(category, products)<EOL>if category.render_type == inventory.Category.RENDER_TYPE_ITEM_QUANTITY:<EOL><INDENT>ProductsForm = forms.formset_factory(<EOL>ProductsForm,<EOL>formset=_ItemQuantityProductsFormSet,<EOL>)<EOL><DEDENT>return ProductsForm<EOL>", "docstring": "Produces an appropriate _ProductsForm subclass for the given render\n    type.", "id": "f17922:m0"}
{"signature": "def staff_products_form_factory(user):", "body": "products = inventory.Product.objects.all()<EOL>products = ProductController.available_products(user, products=products)<EOL>product_ids = [product.id for product in products]<EOL>product_set = inventory.Product.objects.filter(id__in=product_ids)<EOL>class StaffProductsForm(forms.Form):<EOL><INDENT>'''<STR_LIT>'''<EOL>product = forms.ModelChoiceField(<EOL>widget=forms.Select,<EOL>queryset=product_set,<EOL>)<EOL>quantity = forms.IntegerField(<EOL>min_value=<NUM_LIT:0>,<EOL>)<EOL><DEDENT>return StaffProductsForm<EOL>", "docstring": "Creates a StaffProductsForm that restricts the available products to\n    those that are available to a user.", "id": "f17922:m1"}
{"signature": "def product_quantities(self):", "body": "products = set()<EOL>all_products = set()<EOL>for form in self:<EOL><INDENT>if form.empty_permitted and not form.cleaned_data:<EOL><INDENT>continue<EOL><DEDENT>for product, quantity in form.product_quantities():<EOL><INDENT>all_products.add(product)<EOL>if quantity == <NUM_LIT:0>:<EOL><INDENT>continue<EOL><DEDENT>if product in products:<EOL><INDENT>form.add_error(<EOL>_ItemQuantityProductsForm.CHOICE_FIELD,<EOL>\"<STR_LIT>\",<EOL>)<EOL>form.add_error(<EOL>_ItemQuantityProductsForm.QUANTITY_FIELD,<EOL>\"<STR_LIT>\",<EOL>)<EOL><DEDENT>products.add(product)<EOL>yield product, quantity<EOL><DEDENT><DEDENT>for product in (all_products - products):<EOL><INDENT>yield product, <NUM_LIT:0><EOL><DEDENT>", "docstring": "Yields a sequence of (product, quantity) tuples from the\n        cleaned form data.", "id": "f17922:c10:m2"}
{"signature": "@classmethod<EOL><INDENT>def name_field(cls):<DEDENT>", "body": "return None<EOL>", "docstring": "Returns:\n    The name of a field that stores the attendee's name. This is used\n    to pre-fill the attendee's name from their Speaker profile, if they\n    have one.", "id": "f17923:c1:m0"}
{"signature": "def invoice_recipient(self):", "body": "<EOL>slf = AttendeeProfileBase.objects.get_subclass(id=self.id)<EOL>if type(slf).invoice_recipient != type(self).invoice_recipient:<EOL><INDENT>return type(slf).invoice_recipient(slf)<EOL><DEDENT>return slf.attendee.user.username<EOL>", "docstring": "Returns:\n    A representation of this attendee profile for the purpose\n    of rendering to an invoice. This should include any information\n    that you'd usually include on an invoice. Override in subclasses.", "id": "f17923:c1:m2"}
{"signature": "@property<EOL><INDENT>def total_price(self):<DEDENT>", "body": "return self.price * self.quantity<EOL>", "docstring": "price * quantity", "id": "f17926:c4:m1"}
{"signature": "def total_payments(self):", "body": "payments = PaymentBase.objects.filter(invoice=self)<EOL>total_paid = payments.aggregate(Sum(\"<STR_LIT>\"))[\"<STR_LIT>\"] or <NUM_LIT:0><EOL>return total_paid<EOL>", "docstring": "Returns the total amount paid towards this invoice.", "id": "f17926:c3:m6"}
{"signature": "def balance_due(self):", "body": "return self.value - self.total_payments()<EOL>", "docstring": "Returns the total balance remaining towards this invoice.", "id": "f17926:c3:m7"}
{"signature": "def effects(self):", "body": "return itertools.chain(self.products.all(), self.categories.all())<EOL>", "docstring": "Returns all of the items affected by this condition.", "id": "f17927:c13:m1"}
{"signature": "def install():", "body": "load()<EOL>tab = crontab.CronTab(user=True)<EOL>for task in registry:<EOL><INDENT>tab.new(task.command, KRONOS_BREADCRUMB).setall(task.schedule)<EOL><DEDENT>tab.write()<EOL>return len(registry)<EOL>", "docstring": "Register tasks with cron.", "id": "f17941:m3"}
{"signature": "def load():", "body": "autodiscover_modules('<STR_LIT>')<EOL>if PROJECT_MODULE:<EOL><INDENT>if '<STR_LIT:.>' in PROJECT_MODULE.__name__:<EOL><INDENT>try:<EOL><INDENT>import_module('<STR_LIT>' % '<STR_LIT:.>'.join(<EOL>PROJECT_MODULE.__name__.split('<STR_LIT:.>')[<NUM_LIT:0>:-<NUM_LIT:1>]))<EOL><DEDENT>except ImportError as e:<EOL><INDENT>if '<STR_LIT>' not in str(e):<EOL><INDENT>print(e)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>for cmd, app in get_commands().items():<EOL><INDENT>try:<EOL><INDENT>load_command_class(app, cmd)<EOL><DEDENT>except django.core.exceptions.ImproperlyConfigured:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>", "docstring": "Load ``cron`` modules for applications listed in ``INSTALLED_APPS``.", "id": "f17941:m0"}
{"signature": "def list_overlay_names(self):", "body": "overlay_names = []<EOL>for blob in self._blobservice.list_blobs(<EOL>self.uuid,<EOL>prefix=self.overlays_key_prefix<EOL>):<EOL><INDENT>overlay_file = blob.name.rsplit('<STR_LIT:/>', <NUM_LIT:1>)[-<NUM_LIT:1>]<EOL>overlay_name, ext = overlay_file.split('<STR_LIT:.>')<EOL>overlay_names.append(overlay_name)<EOL><DEDENT>return overlay_names<EOL>", "docstring": "Return list of overlay names.", "id": "f17959:c0:m17"}
{"signature": "def iter_item_handles(self):", "body": "blob_generator = self._blobservice.list_blobs(<EOL>self.uuid,<EOL>include='<STR_LIT>'<EOL>)<EOL>for blob in blob_generator:<EOL><INDENT>if '<STR_LIT:type>' in blob.metadata:<EOL><INDENT>if blob.metadata['<STR_LIT:type>'] == '<STR_LIT>':<EOL><INDENT>handle = blob.metadata['<STR_LIT>']<EOL>yield handle<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Return iterator over item handles.", "id": "f17959:c0:m23"}
{"signature": "def get_item_metadata(self, handle):", "body": "metadata = {}<EOL>identifier = generate_identifier(handle)<EOL>prefix = self.fragments_key_prefix + '<STR_LIT:{}>'.format(identifier)<EOL>blob_generator = self._blobservice.list_blobs(<EOL>self.uuid,<EOL>include='<STR_LIT>',<EOL>prefix=prefix<EOL>)<EOL>for blob in blob_generator:<EOL><INDENT>metadata_key = blob.name.split('<STR_LIT:.>')[-<NUM_LIT:2>]<EOL>value_as_string = self.get_text(blob.name)<EOL>value = json.loads(value_as_string)<EOL>metadata[metadata_key] = value<EOL><DEDENT>return metadata<EOL>", "docstring": "Return dictionary containing all metadata associated with handle.\n\n        In other words all the metadata added using the ``add_item_metadata``\n        method.\n\n        :param handle: handle for accessing an item before the dataset is\n                       frozen\n        :returns: dictionary containing item metadata", "id": "f17959:c0:m29"}
{"signature": "def fake_extract_from_dir(filename, fileobj, method,<EOL>options=OPTIONS_MAP, keywords=TOWER_KEYWORDS,<EOL>comment_tags=COMMENT_TAGS):", "body": "for lineno, message, comments, context in extract(method, fileobj, keywords,<EOL>comment_tags, options):<EOL><INDENT>yield filename, lineno, message, comments<EOL><DEDENT>", "docstring": "We use Babel's exctract_from_dir() to pull out our gettext\n    strings.  In the tests, I don't have a directory of files, I have StringIO\n    objects.  So, we fake the original function with this one.", "id": "f17966:m0"}
{"signature": "def ungettext(singular, plural, number, context=None):", "body": "singular_stripped = strip_whitespace(singular)<EOL>plural_stripped = strip_whitespace(plural)<EOL>if context:<EOL><INDENT>singular = add_context(context, singular_stripped)<EOL>plural = add_context(context, plural_stripped)<EOL><DEDENT>else:<EOL><INDENT>singular = singular_stripped<EOL>plural = plural_stripped<EOL><DEDENT>ret = django_nugettext(singular, plural, number)<EOL>if ret == singular:<EOL><INDENT>return singular_stripped<EOL><DEDENT>elif ret == plural:<EOL><INDENT>return plural_stripped<EOL><DEDENT>return ret<EOL>", "docstring": "Always return a stripped string, localized if possible", "id": "f17967:m1"}
{"signature": "def tweak_message(message):", "body": "if isinstance(message, basestring):<EOL><INDENT>message = strip_whitespace(message)<EOL><DEDENT>elif isinstance(message, tuple):<EOL><INDENT>if len(message) == <NUM_LIT:2>:<EOL><INDENT>message = add_context(message[<NUM_LIT:1>], message[<NUM_LIT:0>])<EOL><DEDENT>elif len(message) == <NUM_LIT:3>:<EOL><INDENT>if all(isinstance(x, basestring) for x in message[:<NUM_LIT:2>]):<EOL><INDENT>singular, plural, num = message<EOL>message = (strip_whitespace(singular),<EOL>strip_whitespace(plural),<EOL>num)<EOL><DEDENT><DEDENT>elif len(message) == <NUM_LIT:4>:<EOL><INDENT>singular, plural, num, ctxt = message<EOL>message = (add_context(ctxt, strip_whitespace(singular)),<EOL>add_context(ctxt, strip_whitespace(plural)),<EOL>num)<EOL><DEDENT><DEDENT>return message<EOL>", "docstring": "We piggyback on jinja2's babel_extract() (really, Babel's extract_*\n    functions) but they don't support some things we need so this function will\n    tweak the message.  Specifically:\n\n        1) We strip whitespace from the msgid.  Jinja2 will only strip\n            whitespace from the ends of a string so linebreaks show up in\n            your .po files still.\n\n        2) Babel doesn't support context (msgctxt).  We hack that in ourselves\n            here.", "id": "f17967:m9"}
{"signature": "def ugettext(message, context=None):", "body": "stripped = strip_whitespace(message)<EOL>message = add_context(context, stripped) if context else stripped<EOL>ret = django_ugettext(message)<EOL>return stripped if ret == message else ret<EOL>", "docstring": "Always return a stripped string, localized if possible", "id": "f17967:m0"}
{"signature": "def install_jinja_translations():", "body": "class Translation(object):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>ugettext = staticmethod(ugettext)<EOL>ungettext = staticmethod(ungettext)<EOL><DEDENT>import jingo<EOL>jingo.env.install_gettext_translations(Translation)<EOL>", "docstring": "Install our gettext and ngettext functions into Jinja2's environment.", "id": "f17967:m5"}
{"signature": "def document_frequencies(self, hashes):", "body": "result = {}<EOL>for (k, v) in self.client.get(HASH_FREQUENCY_TABLE,<EOL>*[(h,) for h in hashes]):<EOL><INDENT>if v is None:<EOL><INDENT>v = <NUM_LIT:0><EOL><DEDENT>result[k[<NUM_LIT:0>]] = v<EOL><DEDENT>return result<EOL>", "docstring": "Get document frequencies for a list of hashes.\n\n        This will return all zeros unless the index was written with\n        `hash_frequencies` set.  If :data:`DOCUMENT_HASH_KEY` is\n        included in `hashes`, that value will be returned with the\n        total number of documents indexed.  If you are looking for\n        documents with that hash, pass\n        :data:`DOCUMENT_HASH_KEY_REPLACEMENT` instead.\n\n        :param hashes: hashes to query\n        :paramtype hashes: list of :class:`int`\n        :return: map from hash to document frequency", "id": "f17975:c0:m7"}
{"signature": "def make_hash(self, tok):", "body": "(_, h) = self.make_hash_kw(tok)<EOL>return h<EOL>", "docstring": "Get a Murmur hash for a token.\n\n        `tok` may be a :class:`unicode` string or a UTF-8-encoded\n        byte string.  :data:`DOCUMENT_HASH_KEY`, hash value 0, is\n        reserved for the document count, and this function remaps\n        that value.", "id": "f17975:c0:m2"}
{"signature": "def verify_md5(md5_expected, data, other_errors=None):", "body": "<EOL>)<EOL>!= %r = received md5' \\ d5_recv))<EOL>", "docstring": "return True if okay, raise Exception if not", "id": "f17978:m2"}
{"signature": "def __call__(self, t_path, name_info, i_str):", "body": "logger.info('<STR_LIT>',<EOL>t_path, name_info, i_str)<EOL>try:<EOL><INDENT>more_name_info = get_name_info(t_path, i_str=i_str,<EOL>chunk_type=self.chunk_type)<EOL><DEDENT>except Exception as exc:<EOL><INDENT>logger.critical('<STR_LIT>', t_path, i_str, exc_info=True)<EOL>raise<EOL><DEDENT>self.name_info = dict(name_info, **more_name_info)<EOL>if self.name_info['<STR_LIT>'] == <NUM_LIT:0>:<EOL><INDENT>return None<EOL><DEDENT>o_path = self.s3key_name<EOL>logger.info('<STR_LIT>',<EOL>self.__class__.__name__, o_path, i_str, t_path)<EOL>t_path2 = self.prepare_on_disk(t_path)<EOL>data_len = os.path.getsize(t_path2)<EOL>if data_len == <NUM_LIT:0>:<EOL><INDENT>logger.critical('<STR_LIT>')<EOL><DEDENT>logger.debug('<STR_LIT>', data_len, t_path2)<EOL>self.put_data(o_path, t_path2, self.name_info['<STR_LIT>'], data_len)<EOL>self.cleanup(t_path, t_path2)<EOL>logger.info('<STR_LIT>',<EOL>self.__class__.__name__, i_str, o_path)<EOL>return [o_path]<EOL>", "docstring": "Load chunk from t_path and put it into the right place in s3\nusing the output_name template from the config", "id": "f17978:c1:m1"}
{"signature": "def jobs_status(master, jobs):", "body": "return '<STR_LIT>'.join(['<STR_LIT>'.format(j, job_status(master, j))<EOL>for j in jobs])<EOL>", "docstring": "Get a quick summary of the statuses of all of 'jobs' as a\n    (printable) string.", "id": "f17994:m1"}
{"signature": "def fix_extensions(dummies, chunker):", "body": "ext = '<STR_LIT>' if chunker['<STR_LIT>'].lower() == '<STR_LIT>' else '<STR_LIT>'<EOL>for k in dummies.keys():<EOL><INDENT>new_k = '<STR_LIT:.>'.join([k, ext, '<STR_LIT>'])<EOL>dummies[new_k] = dummies.pop(k)<EOL><DEDENT>", "docstring": "now that to_s3_chunks uses the file extension to detect the\n    compression and type, this test has to make real filenames with\n    proper extesions.", "id": "f18007:m20"}
{"signature": "def _read(self, n):", "body": "if n <= len(self._prefix):<EOL><INDENT>result = self._prefix[:n]<EOL>self._prefix = self._prefix[n:]<EOL>return result<EOL><DEDENT>n -= len(self._prefix)<EOL>result = self._prefix + self.f.read(n)<EOL>self._prefix = \"<STR_LIT>\"<EOL>return result<EOL>", "docstring": "Read (up to) 'n' bytes from the underlying file.  If any bytes\n        have been pushed in with _unread() those are returned first.", "id": "f18016:c0:m2"}
{"signature": "def _make_content_item(node, mime_type=None, alternate_data=None):", "body": "raw = node.data<EOL>if getattr(node, '<STR_LIT>', None) == '<STR_LIT>':<EOL><INDENT>try:<EOL><INDENT>raw = zlib.decompress(node.data)<EOL><DEDENT>except Exception as exc:<EOL><INDENT>if alternate_data is not None:<EOL><INDENT>try:<EOL><INDENT>raw = zlib.decompress(alternate_data)<EOL><DEDENT>except Exception:<EOL><INDENT>raise exc  <EOL><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if mime_type is None:<EOL><INDENT>mime_type = node.mime_type<EOL><DEDENT>raw = raw.decode('<STR_LIT:utf8>').encode('<STR_LIT:utf8>')<EOL>return streamcorpus.ContentItem(raw=raw, media_type=mime_type)<EOL>", "docstring": "Create a ContentItem from a node in the spinn3r data tree.\n\n    The ContentItem is created with raw data set to ``node.data``,\n    decompressed if the node's encoding is 'zlib', and UTF-8\n    normalized, with a MIME type from ``node.mime_type``.\n\n    ``node``\n      the actual node from the spinn3r protobuf data\n    ``mime_type``\n      string MIME type to use (defaults to ``node.mime_type``)\n    ``alternate_data``\n      alternate (compressed) data to use, if ``node.data`` is missing\n      or can't be decompressed", "id": "f18016:m3"}
{"signature": "def _read_a(self, cls):", "body": "o = cls()<EOL>o.ParseFromString(self._read_block())<EOL>return o<EOL>", "docstring": "Read some protobuf-encoded object stored in a single block\n        out of the file.", "id": "f18016:c0:m5"}
{"signature": "def char_offsets_to_xpaths(html, char_offsets):", "body": "html = uni(html)<EOL>parser = XpathTextCollector()<EOL>prev_end = <NUM_LIT:0><EOL>prev_progress = True<EOL>for start, end in char_offsets:<EOL><INDENT>if start == end:<EOL><INDENT>yield None<EOL>continue<EOL><DEDENT>if not prev_progress:<EOL><INDENT>for i in xrange(prev_end, start):<EOL><INDENT>parser.feed(html[i])<EOL>prev_end += <NUM_LIT:1><EOL>if parser.made_progress:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if not parser.made_progress:<EOL><INDENT>yield None<EOL>continue<EOL><DEDENT><DEDENT>if prev_end < start:<EOL><INDENT>parser.feed(html[prev_end:start])<EOL>if not parser.made_progress:<EOL><INDENT>parser.feed(html[start:end])<EOL>prev_progress = parser.made_progress<EOL>prev_end = end<EOL>yield None<EOL>continue<EOL><DEDENT><DEDENT>xstart = parser.xpath_offset()<EOL>parser.feed(html[start:end])<EOL>xend = parser.xpath_offset()<EOL>prev_end = end<EOL>if not parser.made_progress:<EOL><INDENT>prev_progress = False<EOL>yield None<EOL><DEDENT>else:<EOL><INDENT>prev_progress = True<EOL>yield XpathRange(xstart[<NUM_LIT:0>], xstart[<NUM_LIT:1>], xend[<NUM_LIT:0>], xend[<NUM_LIT:1>])<EOL><DEDENT><DEDENT>parser.feed(html[prev_end:])<EOL>parser.close()<EOL>", "docstring": "Converts HTML and a sequence of char offsets to xpath offsets.\n\n    Returns a generator of :class:`streamcorpus.XpathRange` objects\n    in correspondences with the sequence of ``char_offsets`` given.\n    Namely, each ``XpathRange`` should address precisely the same text\n    as that ``char_offsets`` (sans the HTML).\n\n    Depending on how ``char_offsets`` was tokenized, it's possible that\n    some tokens cannot have their xpaths generated reliably. In this\n    case, a ``None`` value is yielded instead of a ``XpathRange``.\n\n    ``char_offsets`` must be a sorted and non-overlapping sequence of\n    character ranges. They do not have to be contiguous.", "id": "f18025:m3"}
{"signature": "def xpath_offset(self):", "body": "datai = self.depth_stack[-<NUM_LIT:1>].text_index()<EOL>xpath = (u'<STR_LIT:/>' +<EOL>u'<STR_LIT:/>'.join(dse.xpath_piece()<EOL>for dse in self.depth_stack[:-<NUM_LIT:1>]) +<EOL>(u'<STR_LIT>' % datai))<EOL>return (xpath, self.data_start)<EOL>", "docstring": "Returns a tuple of ``(xpath, character offset)``.\n\n        The ``xpath`` returned *uniquely* identifies the end of the\n        text node most recently inserted. The character offsets\n        indicates where the text inside the node ends. (When the text\n        node is empty, the offset returned is `0`.)", "id": "f18025:c3:m1"}
{"signature": "def main():", "body": "import argparse<EOL>import sys<EOL>parser = argparse.ArgumentParser()<EOL>parser.add_argument('<STR_LIT:path>')<EOL>args = parser.parse_args()<EOL>html = open(args.path).read()<EOL>html = html.decode('<STR_LIT:utf8>')<EOL>cursor = <NUM_LIT:0><EOL>for s in non_tag_chars_from_raw(html):<EOL><INDENT>for c in s:<EOL><INDENT>if c != '<STR_LIT:U+0020>' and c != html[cursor]:<EOL><INDENT>import pdb; pdb.set_trace()<EOL><DEDENT>sys.stdout.write(c.encode('<STR_LIT:utf8>'))<EOL>sys.stdout.flush()<EOL>cursor += <NUM_LIT:1><EOL><DEDENT><DEDENT>", "docstring": "manual test loop for make_clean_visible_from_raw", "id": "f18035:m6"}
{"signature": "@abstractmethod<EOL><INDENT>def shutdown(self):<DEDENT>", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Do an orderly shutdown of this stage.\n\n        If the stage spawns a child process, kill it, and do any other\n        required cleanup.  :meth:`streamcorpus_pipeline.Pipeline._cleanup`\n        will call this method on every batch transform stage, regardless\n        of whether this is the currently running stage or not.", "id": "f18036:c2:m1"}
{"signature": "def shutdown(self):", "body": "pass<EOL>", "docstring": "Do an orderly shutdown of this stage.\n\n        Incremental transforms are generally simple Python code and\n        a complicated shutdown is not required.  The pipeline does not\n        call this method.", "id": "f18036:c3:m2"}
{"signature": "def get_sentences(self, ner_dom):", "body": "lp_parser = LingPipeParser(self.config)<EOL>lp_parser.set(ner_dom)<EOL>sentences = list( lp_parser.sentences() )<EOL>return sentences, lp_parser.relations, lp_parser.attributes<EOL>", "docstring": "parse the sentences and tokens out of the XML", "id": "f18044:c1:m0"}
{"signature": "def tokens(self, sentence_dom):", "body": "<EOL>self.sent_pos = <NUM_LIT:0><EOL>mention_id = <NUM_LIT:0><EOL>while len(sentence_dom.childNodes) > <NUM_LIT:0>:<EOL><INDENT>node = sentence_dom.childNodes.pop(<NUM_LIT:0>)<EOL>if node.nodeType == node.TEXT_NODE:<EOL><INDENT>for line in node.data.splitlines(True):<EOL><INDENT>self._input_string = line<EOL>for start, end in self.word_tokenizer.span_tokenize(line):<EOL><INDENT>tok = self._make_token(start, end)<EOL>if tok:<EOL><INDENT>yield tok<EOL><DEDENT><DEDENT>if line.endswith('<STR_LIT:\\n>'):<EOL><INDENT>self.line_idx += <NUM_LIT:1><EOL><DEDENT>self.byte_idx += len(line.encode('<STR_LIT:utf-8>'))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>assert node.nodeName == '<STR_LIT>', node.nodeName<EOL>chain_id = node.attributes.get('<STR_LIT>').value<EOL>entity_type = node.attributes.get('<STR_LIT>').value<EOL>for node in node.childNodes:<EOL><INDENT>assert node.nodeType == node.TEXT_NODE, node.nodeType<EOL>for line in node.data.splitlines(True):<EOL><INDENT>self._input_string = line<EOL>for start, end in self.word_tokenizer.span_tokenize(line):<EOL><INDENT>tok = self._make_token(start, end)<EOL>if tok:<EOL><INDENT>if entity_type in _PRONOUNS:<EOL><INDENT>tok.mention_type = MentionType.PRO<EOL>tok.entity_type = _ENTITY_TYPES[entity_type]<EOL>attr = Attribute(<EOL>attribute_type=AttributeType.PER_GENDER,<EOL>value=str(_PRONOUNS[entity_type])<EOL>)<EOL>self.attributes.append(attr)<EOL><DEDENT>else:<EOL><INDENT>tok.mention_type = MentionType.NAME<EOL>tok.entity_type = _ENTITY_TYPES[entity_type]<EOL><DEDENT>tok.equiv_id = int(chain_id)<EOL>tok.mention_id = mention_id<EOL>yield tok<EOL><DEDENT><DEDENT>if line.endswith('<STR_LIT:\\n>'):<EOL><INDENT>self.line_idx += <NUM_LIT:1><EOL><DEDENT>self.byte_idx += len(line.encode('<STR_LIT:utf-8>'))<EOL><DEDENT><DEDENT>mention_id += <NUM_LIT:1><EOL><DEDENT><DEDENT>", "docstring": "Tokenize all the words and preserve NER labels from ENAMEX tags", "id": "f18044:c0:m5"}
{"signature": "def __call__(self, chunk_path):", "body": "<EOL>tmp_chunk_path = chunk_path + '<STR_LIT:_>'<EOL>t_chunk = Chunk(path=tmp_chunk_path, mode='<STR_LIT:wb>')<EOL>for num, si in enumerate(Chunk(path=chunk_path)):<EOL><INDENT>if num < self.config['<STR_LIT>']:<EOL><INDENT>t_chunk.add(si)<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>t_chunk.close()<EOL>os.rename(tmp_chunk_path, chunk_path)<EOL>", "docstring": "batch-type transform stage: reads a chunk from chunk_path, and\nreplaces it with a new chunk at the same path", "id": "f18047:c0:m1"}
{"signature": "def align_chunk_with_ner(self, ner_xml_path, i_chunk, o_chunk):", "body": "<EOL>input_iter = i_chunk.__iter__()<EOL>all_ner = xml.dom.minidom.parse(open(ner_xml_path))<EOL>for ner_dom in all_ner.getElementsByTagName('<STR_LIT>'):<EOL><INDENT>stream_item = next(input_iter)<EOL>stream_id = ner_dom.attributes.get('<STR_LIT>').value<EOL>if stream_item.stream_id is None:<EOL><INDENT>assert not stream_id, '<STR_LIT>' % stream_id<EOL>logger.critical('<STR_LIT>')<EOL>continue<EOL><DEDENT>assert stream_id and stream_id == stream_item.stream_id,'<STR_LIT>' % (stream_id, stream_item.stream_id)<EOL>if not stream_item.body:<EOL><INDENT>continue<EOL><DEDENT>tagging = Tagging()<EOL>tagging.tagger_id = self.tagger_id  <EOL>'''<STR_LIT>'''<EOL>tagging.generation_time = streamcorpus.make_stream_time()<EOL>stream_item.body.taggings[self.tagger_id] = tagging       <EOL>sentences, relations, attributes = self.get_sentences(ner_dom)<EOL>stream_item.body.sentences[self.tagger_id] = sentences    <EOL>stream_item.body.relations[self.tagger_id] = relations    <EOL>stream_item.body.attributes[self.tagger_id] = attributes  <EOL>logger.debug('<STR_LIT>' % stream_item.stream_id)<EOL>'''<STR_LIT>'''<EOL>if '<STR_LIT>' in self.config and self.config['<STR_LIT>']:<EOL><INDENT>assert '<STR_LIT>' in self.config, '<STR_LIT>'<EOL>aligner = AlignmentStrategies[ self.config['<STR_LIT>'] ]<EOL>aligner( stream_item, self.config['<STR_LIT>'] )<EOL><DEDENT>gc.collect()<EOL>try:<EOL><INDENT>o_chunk.add(stream_item)<EOL><DEDENT>except MemoryError as exc:<EOL><INDENT>msg = traceback.format_exc(exc)<EOL>msg += make_memory_info_msg()<EOL>logger.critical(msg)<EOL>raise PipelineOutOfMemory(msg)<EOL><DEDENT><DEDENT>try:<EOL><INDENT>o_chunk.close()<EOL>logger.info('<STR_LIT>' % ner_xml_path)<EOL><DEDENT>except MemoryError as exc:<EOL><INDENT>msg = traceback.format_exc(exc)<EOL>msg += make_memory_info_msg()<EOL>logger.critical(msg)<EOL>raise PipelineOutOfMemory(msg)<EOL><DEDENT>", "docstring": "iterate through ner_xml_path to fuse with i_chunk into o_chunk", "id": "f18048:c6:m3"}
{"signature": "def make_ner_file(self, clean_visible_path, ner_xml_path):", "body": "if self.template is None:<EOL><INDENT>raise exceptions.NotImplementedError(", "docstring": "run tagger a child process to get XML output", "id": "f18048:c6:m2"}
{"signature": "def names_in_chains(stream_item, aligner_data):", "body": "chain_selector = aligner_data.get('<STR_LIT>', '<STR_LIT>')<EOL>assert chain_selector in _CHAIN_SELECTORS,'<STR_LIT>' % (chain_selector, list(_CHAIN_SELECTORS.keys()))<EOL>chain_selector = _CHAIN_SELECTORS[chain_selector]<EOL>equiv_ids = make_chains_with_names( stream_item.body.sentences )<EOL>required_annotator_id = aligner_data.get('<STR_LIT>')<EOL>for annotator_id, ratings in list(stream_item.ratings.items()):<EOL><INDENT>if (required_annotator_id is not None) and (annotator_id != required_annotator_id):<EOL><INDENT>continue<EOL><DEDENT>else:<EOL><INDENT>for rating in ratings:<EOL><INDENT>label = Label(annotator=rating.annotator,<EOL>target=rating.target)<EOL>for eqid, (chain_mentions, chain_tokens) in list(equiv_ids.items()):<EOL><INDENT>if chain_selector(rating.mentions, chain_mentions):<EOL><INDENT>for tok in chain_tokens:<EOL><INDENT>add_annotation(tok, label)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Convert doc-level Rating object into a Label, and add that Label\nto all Token in all coref chains identified by\naligner_data[\"chain_selector\"]\n\n:param stream_item: document that has a doc-level Rating to translate into token-level Labels.\n:param aligner_data: dict containing:\n  chain_selector: ALL or ANY\n  annotator_id: string to find at stream_item.Ratings[i].annotator.annotator_id\n\nIf chain_selector==ALL, then only apply Label to chains in which\nall of the Rating.mentions strings appear as substrings within at\nleast one of the Token.token strings.\n\nIf chain_selector==ANY, then apply Label to chains in which any of\nthe Rating.mentions strings appear as a substring within at least\none of the Token.token strings.\n\nIf chain_selector==ANY_MULTI_TOKEN, then apply Label to chains in which all\nthe names in any of the Rating.mentions strings appear as a substring within at least\none of the Token.token strings.", "id": "f18048:m4"}
{"signature": "def make_chains_with_names(sentences):", "body": "<EOL>fake_equiv_ids = -<NUM_LIT:2><EOL>equiv_ids = collections.defaultdict(lambda: (set(), set()))<EOL>for tagger_id, sents in list(sentences.items()):<EOL><INDENT>for sent in sents:<EOL><INDENT>for tok in sent.tokens:<EOL><INDENT>if tok.entity_type is not None:<EOL><INDENT>if tok.equiv_id == -<NUM_LIT:1>:<EOL><INDENT>eqid = fake_equiv_ids<EOL>fake_equiv_ids -= <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>eqid = tok.equiv_id<EOL><DEDENT>equiv_ids[eqid][<NUM_LIT:0>].add(cleanse(tok.token.decode('<STR_LIT:utf8>')))<EOL>equiv_ids[eqid][<NUM_LIT:1>].add(tok)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return equiv_ids<EOL>", "docstring": "assemble in-doc coref chains by mapping equiv_id to tokens and\ntheir cleansed name strings\n\n:param sentences: iterator over token generators\n:returns dict:\n    keys are equiv_ids,\n    values are tuple(concatentated name string, list of tokens)", "id": "f18048:m0"}
{"signature": "def make_hash(obj):", "body": "if isinstance(obj, (set, tuple, list)):<EOL><INDENT>return tuple([make_hash(e) for e in obj])<EOL><DEDENT>elif not isinstance(obj, dict):<EOL><INDENT>return hash(obj)<EOL><DEDENT>new_obj = copy.deepcopy(obj)<EOL>for k, v in new_obj.items():<EOL><INDENT>new_obj[k] = make_hash(v)<EOL><DEDENT>return hash(tuple(frozenset(new_obj.items())))<EOL>", "docstring": "Makes a hash from a dictionary, list, tuple or set to any level,\nthat contains only other hashable types (including any lists,\ntuples, sets, and dictionaries).  See second answer (not the\naccepted answer):\nhttp://stackoverflow.com/questions/5884066/hashing-a-python-dictionary", "id": "f18051:m1"}
{"signature": "def _sentences(self, clean_visible):", "body": "previous_end = <NUM_LIT:0><EOL>clean_visible = clean_visible.decode('<STR_LIT:utf8>')<EOL>for start, end in self.sentence_tokenizer.span_tokenize(clean_visible):<EOL><INDENT>if start < previous_end:<EOL><INDENT>start = previous_end<EOL>if start > end:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>try:<EOL><INDENT>label = self.label_index.find_le(end)<EOL><DEDENT>except ValueError:<EOL><INDENT>label = None<EOL><DEDENT>if label:<EOL><INDENT>off = label.offsets[OffsetType.CHARS]<EOL>end = max(off.first + off.length, end)<EOL><DEDENT>previous_end = end<EOL>sent_str = clean_visible[start:end]<EOL>yield start, end, sent_str<EOL><DEDENT>", "docstring": "generate strings identified as sentences", "id": "f18056:c0:m1"}
{"signature": "def _process_output_chunk(self, start_count, next_idx, sources, i_str,<EOL>t_path):", "body": "if not self.t_chunk:<EOL><INDENT>return []<EOL><DEDENT>self.t_chunk.close()<EOL>o_paths = None<EOL>if len(self.t_chunk) > <NUM_LIT:0>:<EOL><INDENT>logger.info('<STR_LIT>',<EOL>len(self.t_chunk))<EOL>self._run_batch_transforms(t_path)<EOL>self._maybe_run_post_batch_incremental_transforms(t_path)<EOL>if (self.t_chunk) and (len(self.t_chunk) >= <NUM_LIT:0>):<EOL><INDENT>o_paths = self._run_writers(start_count, next_idx, sources,<EOL>i_str, t_path)<EOL><DEDENT><DEDENT>self.t_chunk = None<EOL>if self.work_unit and o_paths:<EOL><INDENT>old_o_paths = self.work_unit.data.get('<STR_LIT>', [])<EOL>o_paths = old_o_paths + o_paths<EOL>self.work_unit.data['<STR_LIT>'] = next_idx<EOL>self.work_unit.data['<STR_LIT>'] = o_paths<EOL>self.work_unit.update()<EOL><DEDENT>", "docstring": "for the current output chunk (which should be open):\n  1. run batch transforms\n  2. run post-batch incremental transforms\n  3. run 'writers' to load-out the data to files or other storage\nreturn list of paths that writers wrote to", "id": "f18058:c1:m3"}
{"signature": "def __call__(self, config):", "body": "tmp_dir_suffix = self.tmp_dir_suffix<EOL>if tmp_dir_suffix is None:<EOL><INDENT>with self.lock:<EOL><INDENT>self.tmp_dir_suffix = str(uuid.uuid4())<EOL>try:<EOL><INDENT>(reader, incremental_transforms, batch_transforms,<EOL>pbi_transforms, writers,<EOL>tmp_dir_path) = self._init_all_stages(config)<EOL><DEDENT>finally:<EOL><INDENT>self.tmp_dir_suffix = None<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>(reader, incremental_transforms, batch_transforms,<EOL>pbi_transforms, writers,<EOL>tmp_dir_path) = self._init_all_stages(config)<EOL><DEDENT>return Pipeline(<EOL>rate_log_interval=config['<STR_LIT>'],<EOL>input_item_limit=config.get('<STR_LIT>'),<EOL>cleanup_tmp_files=config['<STR_LIT>'],<EOL>tmp_dir_path=tmp_dir_path,<EOL>assert_single_source=config['<STR_LIT>'],<EOL>output_chunk_max_count=config.get('<STR_LIT>'),<EOL>output_max_clean_visible_bytes=config.get(<EOL>'<STR_LIT>'),<EOL>reader=reader,<EOL>incremental_transforms=incremental_transforms,<EOL>batch_transforms=batch_transforms,<EOL>post_batch_incremental_transforms=pbi_transforms,<EOL>writers=writers,<EOL>)<EOL>", "docstring": "Create a :class:`Pipeline`.\n\n        Pass in the configuration under the ``streamcorpus_pipeline``\n        block, not the top-level configuration that contains it.\n\n        If :attr:`tmp_dir_suffix` is :const:`None`, then locks the\n        factory and creates stages with a temporary (UUID) value.  If\n        the configuration has `cleanup_tmp_files` set to :const:`True`\n        (the default) then executing the resulting pipeline will clean\n        up the directory afterwards.\n\n        :param dict config: `streamcorpus_pipeline` configuration\n        :return: new pipeline instance", "id": "f18058:c0:m5"}
{"signature": "def _init_stage(self, config, name):", "body": "return self.create(config[name], config)<EOL>", "docstring": "Create a single indirect stage.\n\n        `name` should be the name of a config item that holds the\n        name of a stage, for instance, ``reader``.  This looks up\n        the name of that stage, then creates and returns the\n        stage named.  For instance, if the config says\n\n        .. code-block:: yaml\n\n            reader: from_local_chunks\n\n        then calling ``self._init_stage(scp_config, 'reader')`` will\n        return a new instance of the\n        :class:`~streamcorpus_pipeline._local_storage.from_local_chunks`\n        stage.\n\n        :param dict config: `streamcorpus_pipeline` configuration block\n        :param str name: name of stage name entry\n        :return: new instance of the stage", "id": "f18058:c0:m2"}
{"signature": "def create(self, stage, scp_config, config=None):", "body": "<EOL>if isinstance(stage, str):<EOL><INDENT>stage_name = stage<EOL>stage_obj = self.registry[stage_name]<EOL><DEDENT>else:<EOL><INDENT>stage_name = getattr(stage, '<STR_LIT>', stage.__name__)<EOL>stage_obj = stage<EOL><DEDENT>if config is None:<EOL><INDENT>config = scp_config.get(stage_name, None)<EOL><DEDENT>if config is None:<EOL><INDENT>config = getattr(stage_obj, '<STR_LIT>', {})<EOL><DEDENT>config = dict(config)<EOL>if self.tmp_dir_suffix is None:<EOL><INDENT>config['<STR_LIT>'] = scp_config['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>config['<STR_LIT>'] = os.path.join(scp_config['<STR_LIT>'],<EOL>self.tmp_dir_suffix)<EOL><DEDENT>config['<STR_LIT>'] = scp_config['<STR_LIT>']<EOL>return stage_obj(config)<EOL>", "docstring": "Create a pipeline stage.\n\n        Instantiates `stage` with `config`.  This essentially\n        translates to ``stage(config)``, except that two keys from\n        `scp_config` are injected into the configuration:\n        ``tmp_dir_path`` is an execution-specific directory from\n        combining the top-level ``tmp_dir_path`` configuration with\n        :attr:`tmp_dir_suffix`; and ``third_dir_path`` is the same\n        path from the top-level configuration.  `stage` may be either\n        a callable returning the stage (e.g. its class), or its name\n        in the configuration.\n\n        `scp_config` is the configuration for the pipeline as a\n        whole, and is required.  `config` is the configuration for\n        the stage; if it is :const:`None` then it is extracted\n        from `scp_config`.\n\n        If you already have a fully formed configuration block\n        and want to create a stage, you can call\n\n        .. code-block:: python\n\n            factory.registry[stage](stage_config)\n\n        In most cases if you have a stage class object and want to\n        instantiate it with its defaults you can call\n\n        .. code-block:: python\n\n            stage = stage_cls(stage_cls.default_config)\n\n        .. note:: This mirrors\n                  :meth:`yakonfig.factory.AutoFactory.create`, with\n                  some thought that this factory class might migrate\n                  to using that as a base in the future.\n\n        :param stage: pipeline stage class, or its name in the registry\n        :param dict scp_config: configuration block for the pipeline\n        :param dict config: configuration block for the stage, or\n          :const:`None` to get it from `scp_config`", "id": "f18058:c0:m1"}
{"signature": "def __init__(self, rate_log_interval, input_item_limit,<EOL>cleanup_tmp_files, tmp_dir_path, assert_single_source,<EOL>output_chunk_max_count, output_max_clean_visible_bytes,<EOL>reader, incremental_transforms, batch_transforms,<EOL>post_batch_incremental_transforms, writers):", "body": "self.rate_log_interval = rate_log_interval<EOL>self.input_item_limit = input_item_limit<EOL>self.cleanup_tmp_files = cleanup_tmp_files<EOL>self.tmp_dir_path = tmp_dir_path<EOL>self.assert_single_source = assert_single_source<EOL>self.output_chunk_max_count = output_chunk_max_count<EOL>self.output_max_clean_visible_bytes = output_max_clean_visible_bytes<EOL>self.reader = reader<EOL>self.incremental_transforms = incremental_transforms<EOL>self.batch_transforms = batch_transforms<EOL>self.pbi_stages = post_batch_incremental_transforms<EOL>self.writers = writers<EOL>self.t_chunk = None<EOL>self.context = dict(<EOL>i_str=None,<EOL>data=None,<EOL>)<EOL>self.work_unit = None<EOL>", "docstring": "Create a new pipeline object.\n\n        .. todo:: make this callable with just the lists of stages\n                  and give sane (language-level) defaults for the rest\n\n        :param int rate_log_interval: print progress every time this\n          many input items have been processed\n        :param int input_item_limit: stop after this many items\n        :param bool cleanup_tmp_files: delete `tmp_dir_path` after\n          execution if true\n        :param str tmp_dir_path: path for intermediate files\n        :param bool assert_single_source: require all items to have\n          the same source value if true\n        :param int output_chunk_max_count: restart output after\n          writing this many items\n        :param int output_max_clean_visible_bytes: restart output after\n          writing this much content\n        :param callable reader: reader stage object\n        :param incremental_transforms: single-item transformation stages\n        :paramtype incremental_transforms: list of callable\n        :param batch_transforms: chunk-file transformation stages\n        :paramtype batch_transforms: list of callable\n        :param post_batch_incremental_transforms: single-item transformation\n          stages\n        :paramtype post_batch_incremental_transforms: list of callable\n        :param writers: output stages\n        :paramtype writers: list of callable", "id": "f18058:c1:m0"}
{"signature": "def rmtree(path, use_shutil=True, followlinks=False, retries=<NUM_LIT:10>):", "body": "if use_shutil and not followlinks:<EOL><INDENT>try:<EOL><INDENT>shutil.rmtree(path)<EOL>return<EOL><DEDENT>except Exception as exc:<EOL><INDENT>logger.info('<STR_LIT>', path)<EOL>logger.debug('<STR_LIT>', traceback.format_exc(exc))<EOL><DEDENT><DEDENT>if not os.path.isdir(path):<EOL><INDENT>os.remove(path)<EOL>return<EOL><DEDENT>for root, dir_names, file_names in os.walk(path, topdown=False, followlinks=followlinks):<EOL><INDENT>for fname in file_names:<EOL><INDENT>fpath = os.path.join(root, fname)<EOL>tries = <NUM_LIT:0><EOL>while tries < retries:<EOL><INDENT>tries += <NUM_LIT:1><EOL>try:<EOL><INDENT>os.remove(fpath)<EOL>break<EOL><DEDENT>except Exception as exc:<EOL><INDENT>time.sleep(<NUM_LIT:0.1>)<EOL><DEDENT><DEDENT>if os.path.exists(fpath):<EOL><INDENT>logger.critical('<STR_LIT>', fpath)<EOL>logger.critical('<STR_LIT>', traceback.format_exc(exc))<EOL><DEDENT><DEDENT>for dname in dir_names:<EOL><INDENT>full_path = os.path.join(root, dname)<EOL>if os.path.islink(full_path):<EOL><INDENT>real_path = os.path.realpath(full_path)<EOL>os.remove(full_path)<EOL>full_path = real_path<EOL><DEDENT>os.rmdir(full_path)<EOL><DEDENT><DEDENT>if os.path.exists(path):<EOL><INDENT>os.rmdir(path)<EOL><DEDENT>", "docstring": "remove all files and directories below path, including path\n    itself; works even when shutil.rmtree fails because of read-only\n    files in NFS and Windows.  Follows symlinks.\n\n    `use_shutil` defaults to True; useful for testing\n\n    `followlinks` defaults to False; if set to True, shutil.rmtree is\n    not used.", "id": "f18063:m0"}
{"signature": "def parse_keys_and_ranges(i_str, keyfunc, rangefunc):", "body": "while i_str:<EOL><INDENT>m = _STREAM_ID_RE.match(i_str)<EOL>if m:<EOL><INDENT>for retval in keyfunc(stream_id_to_kvlayer_key(m.group())):<EOL><INDENT>yield retval<EOL><DEDENT>i_str = i_str[m.end():]<EOL>while i_str and ((i_str[<NUM_LIT:0>] == '<STR_LIT:U+002C>') or (i_str[<NUM_LIT:0>] == '<STR_LIT:;>')):<EOL><INDENT>i_str = i_str[<NUM_LIT:1>:]<EOL><DEDENT>continue<EOL><DEDENT>if len(i_str) == SI_KEY_LENGTH:<EOL><INDENT>key = parse_si_key(i_str)<EOL>for retval in keyfunc(key):<EOL><INDENT>yield retval<EOL><DEDENT>return<EOL><DEDENT>keya = i_str[:SI_KEY_LENGTH]<EOL>splitc = i_str[SI_KEY_LENGTH]<EOL>if splitc == '<STR_LIT:<>':<EOL><INDENT>keyb = i_str[SI_KEY_LENGTH+<NUM_LIT:1>:SI_KEY_LENGTH+<NUM_LIT:1>+SI_KEY_LENGTH]<EOL>i_str = i_str[SI_KEY_LENGTH+<NUM_LIT:1>+SI_KEY_LENGTH:]<EOL>keya = parse_si_key(keya)<EOL>keyb = parse_si_key(keyb)<EOL>for retval in rangefunc(keya, keyb):<EOL><INDENT>yield retval<EOL><DEDENT><DEDENT>elif splitc == '<STR_LIT:;>':<EOL><INDENT>keya = parse_si_key(keya)<EOL>for retval in keyfunc(keya):<EOL><INDENT>yield retval<EOL><DEDENT>i_str = i_str[SI_KEY_LENGTH+<NUM_LIT:1>+<NUM_LIT:1>:]<EOL><DEDENT>else:<EOL><INDENT>logger.error('<STR_LIT>', splitc, i_str)<EOL>return<EOL><DEDENT><DEDENT>", "docstring": "Parse the :class:`from_kvlayer` input string.\n\n    This accepts two formats.  In the textual format, it accepts any\n    number of stream IDs in timestamp-docid format, separated by ``,``\n    or ``;``, and processes those as individual stream IDs.  In the\n    binary format, it accepts 20-byte key blobs (16 bytes md5 hash, 4\n    bytes timestamp) split by ``;`` or ``<``; e.g., ``a<f;x`` loads\n    scans keys `a` through `f` and loads singly key `x`.\n\n    `keyfunc` and `rangefunc` are run as generators and their yields\n    are yielded from this function.", "id": "f18065:m1"}
{"signature": "def get_kvlayer_stream_item_by_doc_id(client, doc_id):", "body": "if client is None:<EOL><INDENT>client = kvlayer.client()<EOL>client.setup_namespace(STREAM_ITEM_TABLE_DEFS,<EOL>STREAM_ITEM_VALUE_DEFS)<EOL><DEDENT>doc_id_range = make_doc_id_range(doc_id)<EOL>for k, v in client.scan(STREAM_ITEMS_TABLE, doc_id_range):<EOL><INDENT>if v is not None:<EOL><INDENT>errors, bytestr = streamcorpus.decrypt_and_uncompress(v)<EOL>yield streamcorpus.deserialize(bytestr)<EOL><DEDENT><DEDENT>", "docstring": "Retrieve :class:`streamcorpus.StreamItem`s from :mod:`kvlayer`.\n\n    Namely, it returns an iterator over all documents with the given\n    docid. The docid should be an md5 hash of the document's abs_url.\n\n    :param client: kvlayer client object\n    :type client: :class:`kvlayer.AbstractStorage`\n    :param str doc_id: doc id of documents to retrieve\n    :return: generator of :class:`streamcorpus.StreamItem`", "id": "f18065:m4"}
{"signature": "def align_chunk_with_ner(tmp_ner_path, i_chunk, tmp_done_path):", "body": "o_chunk = Chunk()<EOL>input_iter = i_chunk.__iter__()<EOL>ner = '<STR_LIT>'<EOL>stream_id = None<EOL>all_ner = xml.dom.minidom.parse(open(tmp_ner_path))<EOL>for raw_ner in all_ner.getElementsByTagName('<STR_LIT>'):<EOL><INDENT>stream_item = next(input_iter)<EOL>stream_id = raw_ner.attributes.get('<STR_LIT>').value<EOL>assert stream_id and stream_id == stream_item.stream_id,'<STR_LIT>' % (stream_id, stream_item.stream_id, ner)<EOL>tagger_id = '<STR_LIT>'<EOL>tagging = Tagging()<EOL>tagging.tagger_id = tagger_id<EOL>tagged_doc = list(lingpipe.files(raw_ner.toxml()))[<NUM_LIT:0>][<NUM_LIT:1>]<EOL>tagging.raw_tagging = tagged_doc<EOL>tagging.generation_time = streamcorpus.make_stream_time()<EOL>stream_item.body.taggings[tagger_id] = tagging<EOL>sentences = list(lingpipe.sentences(tagged_doc))<EOL>assert stream_item.ratings[<NUM_LIT:0>].mentions, stream_item.stream_id<EOL>john_smith_label = Label()<EOL>john_smith_label.annotator = stream_item.ratings[<NUM_LIT:0>].annotator<EOL>john_smith_label.target_id = stream_item.ratings[<NUM_LIT:0>].target_id<EOL>equiv_ids = collections.defaultdict(lambda: set())<EOL>for sent in sentences:<EOL><INDENT>for tok in sent.tokens:<EOL><INDENT>if tok.entity_type is not None:<EOL><INDENT>equiv_ids[tok.equiv_id].add(cleanse(tok.token))<EOL><DEDENT><DEDENT><DEDENT>johnsmiths = set()<EOL>for equiv_id, names in list(equiv_ids.items()):<EOL><INDENT>_names = cleanse('<STR_LIT:U+0020>'.join(names))<EOL>if '<STR_LIT>' in _names and '<STR_LIT>' in _names:<EOL><INDENT>johnsmiths.add(equiv_id)<EOL><DEDENT><DEDENT>print(len(johnsmiths))<EOL>for sent in sentences:<EOL><INDENT>for tok in sent.tokens:<EOL><INDENT>if tok.equiv_id in johnsmiths:<EOL><INDENT>tok.labels = [john_smith_label]                <EOL><DEDENT><DEDENT><DEDENT>stream_item.body.sentences[tagger_id] = sentences<EOL>o_chunk.add(stream_item)<EOL><DEDENT>open(tmp_done_path, '<STR_LIT:wb>').write(str(o_chunk))<EOL>print('<STR_LIT>' % tmp_done_path)<EOL>", "docstring": "iterate through the i_chunk and tmp_ner_path to generate a new\nChunk with body.ner", "id": "f18067:m3"}
{"signature": "def make_ner_file(tagger_id, tmp_cleansed_path, tmp_ner_path, pipeline_root):", "body": "params = dict(INPUT_FILE=tmp_cleansed_path,<EOL>OUTPUT_FILE=tmp_ner_path,<EOL>PIPELINE_ROOT=pipeline_root)<EOL>pipeline_cmd = pipeline_cmd_templates[tagger_id] % params<EOL>print(pipeline_cmd)<EOL>print('<STR_LIT>' % tmp_ner_path)<EOL>start_time = time.time()<EOL>gpg_child = subprocess.Popen(<EOL>pipeline_cmd,<EOL>stderr=subprocess.PIPE, shell=True)<EOL>s_out, errors = gpg_child.communicate()<EOL>assert gpg_child.returncode == <NUM_LIT:0> and '<STR_LIT>' not in errors, errors<EOL>elapsed = time.time() - start_time<EOL>print('<STR_LIT>' % (tmp_ner_path, elapsed))<EOL>'''<STR_LIT>'''<EOL>", "docstring": "run child process to get OWPL output", "id": "f18067:m1"}
{"signature": "def __call__(self, si, context):", "body": "if self.matcher.match(strip_string(si.body.clean_visible.decode('<STR_LIT:utf-8>'))):<EOL><INDENT>return si<EOL><DEDENT>", "docstring": "only pass StreamItems that match", "id": "f18070:c0:m1"}
{"signature": "def main(version=DEFAULT_VERSION):", "body": "options = _parse_args()<EOL>tarball = download_setuptools(download_base=options.download_base)<EOL>return _install(tarball, _build_install_args(options))<EOL>", "docstring": "Install or upgrade setuptools and EasyInstall", "id": "f18077:m20"}
{"signature": "@abstractmethod<EOL><INDENT>def draw(self, notification):<DEDENT>", "body": "", "docstring": "Called by the dashboard when the display should try and draw the notification.\n\nImplementations should block the thread whilst the display is showing a notification, as soon as the thread is\nunblocked then all data-sources will be polled.\n\n:param notification: The notification to draw that is of a type returned by `get_supported_notifications()`", "id": "f18099:c0:m3"}
{"signature": "@abstractmethod<EOL><INDENT>def get_output_types(self):<DEDENT>", "body": "", "docstring": ":return: Return an array of the types of outputs this notification produces. This is used to check the\ndisplay that's been configured can handle all the types of outputs the notification could produce.", "id": "f18102:c0:m5"}
{"signature": "@staticmethod<EOL><INDENT>def _encode_url(full_url):<DEDENT>", "body": "return urllib.parse.quote(full_url, safe=\"<STR_LIT>\")<EOL>", "docstring": "Encode invalid characters in URL to provide, such as spaces.\n\nThis implements code from the following URLs\nhttps://bugs.python.org/issue14826\nhttps://hg.python.org/cpython/rev/ebd37273e0fe", "id": "f18104:c1:m4"}
{"signature": "@abstractmethod<EOL><INDENT>def filter(self, message):<DEDENT>", "body": "", "docstring": ":param message: Message to filter\n:return: True if the message should be kept, otherwise false.", "id": "f18109:c0:m3"}
{"signature": "@abstractmethod<EOL><INDENT>def load(self, type):<DEDENT>", "body": "", "docstring": "Returns an array of all the component configs", "id": "f18111:c9:m0"}
{"signature": "def __init__(self, text, source=None):", "body": "self._text = text<EOL>self._source_name = str(source) if source else \"<STR_LIT>\"<EOL>", "docstring": ":param text: Entity's text\n:param source: Source of the entity, which is converted to a string via `str()` to produce the source name", "id": "f18114:c0:m0"}
{"signature": "def process_arguments(args):", "body": "parser = argparse.ArgumentParser(<EOL>description='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>',<EOL>action='<STR_LIT:store>',<EOL>help='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>',<EOL>action='<STR_LIT:store>',<EOL>help='<STR_LIT>')<EOL>return vars(parser.parse_args(args))<EOL>", "docstring": "Argparse function to get the program parameters", "id": "f18139:m1"}
{"signature": "def estimate_tuning(input_file):", "body": "print('<STR_LIT>', input_file)<EOL>y, sr = librosa.load(input_file)<EOL>print('<STR_LIT>')<EOL>y_harm = librosa.effects.harmonic(y)<EOL>print('<STR_LIT>')<EOL>tuning = librosa.estimate_tuning(y=y_harm, sr=sr)<EOL>print('<STR_LIT>'.format(<NUM_LIT:100> * tuning))<EOL>", "docstring": "Load an audio file and estimate tuning (in cents)", "id": "f18140:m0"}
{"signature": "def process_arguments(args):", "body": "parser = argparse.ArgumentParser(description='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>',<EOL>action='<STR_LIT:store>',<EOL>help='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>',<EOL>action='<STR_LIT:store>',<EOL>help='<STR_LIT>')<EOL>parser.add_argument('<STR_LIT>',<EOL>action='<STR_LIT:store>',<EOL>help='<STR_LIT>')<EOL>return vars(parser.parse_args(args))<EOL>", "docstring": "Argparse function to get the program parameters", "id": "f18141:m1"}
{"signature": "def onset_detect(y=None, sr=<NUM_LIT>, onset_envelope=None, hop_length=<NUM_LIT>,<EOL>backtrack=False, energy=None,<EOL>units='<STR_LIT>', **kwargs):", "body": "<EOL>if onset_envelope is None:<EOL><INDENT>if y is None:<EOL><INDENT>raise ParameterError('<STR_LIT>')<EOL><DEDENT>onset_envelope = onset_strength(y=y, sr=sr, hop_length=hop_length)<EOL><DEDENT>onset_envelope -= onset_envelope.min()<EOL>if not onset_envelope.any():<EOL><INDENT>return np.array([], dtype=np.int)<EOL><DEDENT>onset_envelope /= onset_envelope.max()<EOL>kwargs.setdefault('<STR_LIT>', <NUM_LIT>*sr//hop_length)       <EOL>kwargs.setdefault('<STR_LIT>', <NUM_LIT>*sr//hop_length + <NUM_LIT:1>)  <EOL>kwargs.setdefault('<STR_LIT>', <NUM_LIT>*sr//hop_length)       <EOL>kwargs.setdefault('<STR_LIT>', <NUM_LIT>*sr//hop_length + <NUM_LIT:1>)  <EOL>kwargs.setdefault('<STR_LIT>', <NUM_LIT>*sr//hop_length)          <EOL>kwargs.setdefault('<STR_LIT>', <NUM_LIT>)<EOL>onsets = util.peak_pick(onset_envelope, **kwargs)<EOL>if backtrack:<EOL><INDENT>if energy is None:<EOL><INDENT>energy = onset_envelope<EOL><DEDENT>onsets = onset_backtrack(onsets, energy)<EOL><DEDENT>if units == '<STR_LIT>':<EOL><INDENT>pass<EOL><DEDENT>elif units == '<STR_LIT>':<EOL><INDENT>onsets = core.frames_to_samples(onsets, hop_length=hop_length)<EOL><DEDENT>elif units == '<STR_LIT:time>':<EOL><INDENT>onsets = core.frames_to_time(onsets, hop_length=hop_length, sr=sr)<EOL><DEDENT>else:<EOL><INDENT>raise ParameterError('<STR_LIT>'.format(units))<EOL><DEDENT>return onsets<EOL>", "docstring": "Basic onset detector.  Locate note onset events by picking peaks in an\n    onset strength envelope.\n\n    The `peak_pick` parameters were chosen by large-scale hyper-parameter\n    optimization over the dataset provided by [1]_.\n\n    .. [1] https://github.com/CPJKU/onset_db\n\n\n    Parameters\n    ----------\n    y          : np.ndarray [shape=(n,)]\n        audio time series\n\n    sr         : number > 0 [scalar]\n        sampling rate of `y`\n\n    onset_envelope     : np.ndarray [shape=(m,)]\n        (optional) pre-computed onset strength envelope\n\n    hop_length : int > 0 [scalar]\n        hop length (in samples)\n\n    units : {'frames', 'samples', 'time'}\n        The units to encode detected onset events in.\n        By default, 'frames' are used.\n\n    backtrack : bool\n        If `True`, detected onset events are backtracked to the nearest\n        preceding minimum of `energy`.\n\n        This is primarily useful when using onsets as slice points for segmentation.\n\n    energy : np.ndarray [shape=(m,)] (optional)\n        An energy function to use for backtracking detected onset events.\n        If none is provided, then `onset_envelope` is used.\n\n    kwargs : additional keyword arguments\n        Additional parameters for peak picking.\n\n        See `librosa.util.peak_pick` for details.\n\n\n    Returns\n    -------\n\n    onsets : np.ndarray [shape=(n_onsets,)]\n        estimated positions of detected onsets, in whichever units\n        are specified.  By default, frame indices.\n\n        .. note::\n            If no onset strength could be detected, onset_detect returns\n            an empty list.\n\n\n    Raises\n    ------\n    ParameterError\n        if neither `y` nor `onsets` are provided\n\n        or if `units` is not one of 'frames', 'samples', or 'time'\n\n    See Also\n    --------\n    onset_strength : compute onset strength per-frame\n    onset_backtrack : backtracking onset events\n    librosa.util.peak_pick : pick peaks from a time series\n\n\n    Examples\n    --------\n    Get onset times from a signal\n\n    >>> y, sr = librosa.load(librosa.util.example_audio_file(),\n    ...                      offset=30, duration=2.0)\n    >>> onset_frames = librosa.onset.onset_detect(y=y, sr=sr)\n    >>> librosa.frames_to_time(onset_frames, sr=sr)\n    array([ 0.07 ,  0.395,  0.511,  0.627,  0.766,  0.975,\n            1.207,  1.324,  1.44 ,  1.788,  1.881])\n\n    Or use a pre-computed onset envelope\n\n    >>> o_env = librosa.onset.onset_strength(y, sr=sr)\n    >>> times = librosa.frames_to_time(np.arange(len(o_env)), sr=sr)\n    >>> onset_frames = librosa.onset.onset_detect(onset_envelope=o_env, sr=sr)\n\n\n    >>> import matplotlib.pyplot as plt\n    >>> D = np.abs(librosa.stft(y))\n    >>> plt.figure()\n    >>> ax1 = plt.subplot(2, 1, 1)\n    >>> librosa.display.specshow(librosa.amplitude_to_db(D, ref=np.max),\n    ...                          x_axis='time', y_axis='log')\n    >>> plt.title('Power spectrogram')\n    >>> plt.subplot(2, 1, 2, sharex=ax1)\n    >>> plt.plot(times, o_env, label='Onset strength')\n    >>> plt.vlines(times[onset_frames], 0, o_env.max(), color='r', alpha=0.9,\n    ...            linestyle='--', label='Onsets')\n    >>> plt.axis('tight')\n    >>> plt.legend(frameon=True, framealpha=0.75)", "id": "f18148:m0"}
{"signature": "@cache(level=<NUM_LIT:30>)<EOL>def onset_strength_multi(y=None, sr=<NUM_LIT>, S=None, lag=<NUM_LIT:1>, max_size=<NUM_LIT:1>,<EOL>ref=None, detrend=False, center=True, feature=None,<EOL>aggregate=None, channels=None, **kwargs):", "body": "if feature is None:<EOL><INDENT>feature = melspectrogram<EOL>kwargs.setdefault('<STR_LIT>', <NUM_LIT>)<EOL><DEDENT>if aggregate is None:<EOL><INDENT>aggregate = np.mean<EOL><DEDENT>if lag < <NUM_LIT:1> or not isinstance(lag, int):<EOL><INDENT>raise ParameterError('<STR_LIT>')<EOL><DEDENT>if max_size < <NUM_LIT:1> or not isinstance(max_size, int):<EOL><INDENT>raise ParameterError('<STR_LIT>')<EOL><DEDENT>if S is None:<EOL><INDENT>S = np.abs(feature(y=y, sr=sr, **kwargs))<EOL>S = core.power_to_db(S)<EOL><DEDENT>n_fft = kwargs.get('<STR_LIT>', <NUM_LIT>)<EOL>hop_length = kwargs.get('<STR_LIT>', <NUM_LIT>)<EOL>S = np.atleast_2d(S)<EOL>if ref is None:<EOL><INDENT>if max_size == <NUM_LIT:1>:<EOL><INDENT>ref = S<EOL><DEDENT>else:<EOL><INDENT>ref = scipy.ndimage.maximum_filter1d(S, max_size, axis=<NUM_LIT:0>)<EOL><DEDENT><DEDENT>elif ref.shape != S.shape:<EOL><INDENT>raise ParameterError('<STR_LIT>'.format(ref.shape, S.shape))<EOL><DEDENT>onset_env = S[:, lag:] - ref[:, :-lag]<EOL>onset_env = np.maximum(<NUM_LIT:0.0>, onset_env)<EOL>pad = True<EOL>if channels is None:<EOL><INDENT>channels = [slice(None)]<EOL><DEDENT>else:<EOL><INDENT>pad = False<EOL><DEDENT>if aggregate:<EOL><INDENT>onset_env = util.sync(onset_env, channels,<EOL>aggregate=aggregate,<EOL>pad=pad, axis=<NUM_LIT:0>)<EOL><DEDENT>pad_width = lag<EOL>if center:<EOL><INDENT>pad_width += n_fft // (<NUM_LIT:2> * hop_length)<EOL><DEDENT>onset_env = np.pad(onset_env, ([<NUM_LIT:0>, <NUM_LIT:0>], [int(pad_width), <NUM_LIT:0>]),<EOL>mode='<STR_LIT>')<EOL>if detrend:<EOL><INDENT>onset_env = scipy.signal.lfilter([<NUM_LIT:1.0>, -<NUM_LIT:1.0>], [<NUM_LIT:1.0>, -<NUM_LIT>],<EOL>onset_env, axis=-<NUM_LIT:1>)<EOL><DEDENT>if center:<EOL><INDENT>onset_env = onset_env[:, :S.shape[<NUM_LIT:1>]]<EOL><DEDENT>return onset_env<EOL>", "docstring": "Compute a spectral flux onset strength envelope across multiple channels.\n\n    Onset strength for channel `i` at time `t` is determined by:\n\n    `mean_{f in channels[i]} max(0, S[f, t+1] - S[f, t])`\n\n\n    Parameters\n    ----------\n    y        : np.ndarray [shape=(n,)]\n        audio time-series\n\n    sr       : number > 0 [scalar]\n        sampling rate of `y`\n\n    S        : np.ndarray [shape=(d, m)]\n        pre-computed (log-power) spectrogram\n\n    lag      : int > 0\n        time lag for computing differences\n\n    max_size : int > 0\n        size (in frequency bins) of the local max filter.\n        set to `1` to disable filtering.\n\n    ref : None or np.ndarray [shape=(d, m)]\n        An optional pre-computed reference spectrum, of the same shape as `S`.\n        If not provided, it will be computed from `S`.\n        If provided, it will override any local max filtering governed by `max_size`.\n\n    detrend : bool [scalar]\n        Filter the onset strength to remove the DC component\n\n    center : bool [scalar]\n        Shift the onset function by `n_fft / (2 * hop_length)` frames\n\n    feature : function\n        Function for computing time-series features, eg, scaled spectrograms.\n        By default, uses `librosa.feature.melspectrogram` with `fmax=11025.0`\n\n    aggregate : function or False\n        Aggregation function to use when combining onsets\n        at different frequency bins.\n\n        If `False`, then no aggregation is performed.\n\n        Default: `np.mean`\n\n    channels : list or None\n        Array of channel boundaries or slice objects.\n        If `None`, then a single channel is generated to span all bands.\n\n    kwargs : additional keyword arguments\n        Additional parameters to `feature()`, if `S` is not provided.\n\n\n    Returns\n    -------\n    onset_envelope   : np.ndarray [shape=(n_channels, m)]\n        array containing the onset strength envelope for each specified channel\n\n\n    Raises\n    ------\n    ParameterError\n        if neither `(y, sr)` nor `S` are provided\n\n\n    See Also\n    --------\n    onset_strength\n\n    Notes\n    -----\n    This function caches at level 30.\n\n    Examples\n    --------\n    First, load some audio and plot the spectrogram\n\n    >>> import matplotlib.pyplot as plt\n    >>> y, sr = librosa.load(librosa.util.example_audio_file(),\n    ...                      duration=10.0)\n    >>> D = np.abs(librosa.stft(y))\n    >>> plt.figure()\n    >>> plt.subplot(2, 1, 1)\n    >>> librosa.display.specshow(librosa.amplitude_to_db(D, ref=np.max),\n    ...                          y_axis='log')\n    >>> plt.title('Power spectrogram')\n\n    Construct a standard onset function over four sub-bands\n\n    >>> onset_subbands = librosa.onset.onset_strength_multi(y=y, sr=sr,\n    ...                                                     channels=[0, 32, 64, 96, 128])\n    >>> plt.subplot(2, 1, 2)\n    >>> librosa.display.specshow(onset_subbands, x_axis='time')\n    >>> plt.ylabel('Sub-bands')\n    >>> plt.title('Sub-band onset strength')", "id": "f18148:m3"}
{"signature": "def onset_strength(y=None, sr=<NUM_LIT>, S=None, lag=<NUM_LIT:1>, max_size=<NUM_LIT:1>,<EOL>ref=None,<EOL>detrend=False, center=True,<EOL>feature=None, aggregate=None,<EOL>centering=None,<EOL>**kwargs):", "body": "if aggregate is False:<EOL><INDENT>raise ParameterError('<STR_LIT>')<EOL><DEDENT>odf_all = onset_strength_multi(y=y,<EOL>sr=sr,<EOL>S=S,<EOL>lag=lag,<EOL>max_size=max_size,<EOL>ref=ref,<EOL>detrend=detrend,<EOL>center=center,<EOL>feature=feature,<EOL>aggregate=aggregate,<EOL>channels=None,<EOL>**kwargs)<EOL>return odf_all[<NUM_LIT:0>]<EOL>", "docstring": "Compute a spectral flux onset strength envelope.\n\n    Onset strength at time `t` is determined by:\n\n    `mean_f max(0, S[f, t] - ref[f, t - lag])`\n\n    where `ref` is `S` after local max filtering along the frequency\n    axis [1]_.\n\n    By default, if a time series `y` is provided, S will be the\n    log-power Mel spectrogram.\n\n    .. [1] B\u00f6ck, Sebastian, and Gerhard Widmer.\n           \"Maximum filter vibrato suppression for onset detection.\"\n           16th International Conference on Digital Audio Effects,\n           Maynooth, Ireland. 2013.\n\n    Parameters\n    ----------\n    y        : np.ndarray [shape=(n,)]\n        audio time-series\n\n    sr       : number > 0 [scalar]\n        sampling rate of `y`\n\n    S        : np.ndarray [shape=(d, m)]\n        pre-computed (log-power) spectrogram\n\n    lag      : int > 0\n        time lag for computing differences\n\n    max_size : int > 0\n        size (in frequency bins) of the local max filter.\n        set to `1` to disable filtering.\n\n    ref : None or np.ndarray [shape=(d, m)]\n        An optional pre-computed reference spectrum, of the same shape as `S`.\n        If not provided, it will be computed from `S`.\n        If provided, it will override any local max filtering governed by `max_size`.\n\n    detrend : bool [scalar]\n        Filter the onset strength to remove the DC component\n\n    center : bool [scalar]\n        Shift the onset function by `n_fft / (2 * hop_length)` frames\n\n    feature : function\n        Function for computing time-series features, eg, scaled spectrograms.\n        By default, uses `librosa.feature.melspectrogram` with `fmax=11025.0`\n\n    aggregate : function\n        Aggregation function to use when combining onsets\n        at different frequency bins.\n\n        Default: `np.mean`\n\n    kwargs : additional keyword arguments\n        Additional parameters to `feature()`, if `S` is not provided.\n\n\n    Returns\n    -------\n    onset_envelope   : np.ndarray [shape=(m,)]\n        vector containing the onset strength envelope\n\n\n    Raises\n    ------\n    ParameterError\n        if neither `(y, sr)` nor `S` are provided\n\n        or if `lag` or `max_size` are not positive integers\n\n\n    See Also\n    --------\n    onset_detect\n    onset_strength_multi\n\n\n    Examples\n    --------\n    First, load some audio and plot the spectrogram\n\n    >>> import matplotlib.pyplot as plt\n    >>> y, sr = librosa.load(librosa.util.example_audio_file(),\n    ...                      duration=10.0)\n    >>> D = np.abs(librosa.stft(y))\n    >>> times = librosa.frames_to_time(np.arange(D.shape[1]))\n    >>> plt.figure()\n    >>> ax1 = plt.subplot(2, 1, 1)\n    >>> librosa.display.specshow(librosa.amplitude_to_db(D, ref=np.max),\n    ...                          y_axis='log', x_axis='time')\n    >>> plt.title('Power spectrogram')\n\n    Construct a standard onset function\n\n    >>> onset_env = librosa.onset.onset_strength(y=y, sr=sr)\n    >>> plt.subplot(2, 1, 2, sharex=ax1)\n    >>> plt.plot(times, 2 + onset_env / onset_env.max(), alpha=0.8,\n    ...          label='Mean (mel)')\n\n\n    Median aggregation, and custom mel options\n\n    >>> onset_env = librosa.onset.onset_strength(y=y, sr=sr,\n    ...                                          aggregate=np.median,\n    ...                                          fmax=8000, n_mels=256)\n    >>> plt.plot(times, 1 + onset_env / onset_env.max(), alpha=0.8,\n    ...          label='Median (custom mel)')\n\n\n    Constant-Q spectrogram instead of Mel\n\n    >>> onset_env = librosa.onset.onset_strength(y=y, sr=sr,\n    ...                                          feature=librosa.cqt)\n    >>> plt.plot(times, onset_env / onset_env.max(), alpha=0.8,\n    ...          label='Mean (CQT)')\n    >>> plt.legend(frameon=True, framealpha=0.75)\n    >>> plt.ylabel('Normalized strength')\n    >>> plt.yticks([])\n    >>> plt.axis('tight')\n    >>> plt.tight_layout()", "id": "f18148:m1"}
{"signature": "def __nn_filter_helper(R_data, R_indices, R_ptr, S, aggregate):", "body": "s_out = np.empty_like(S)<EOL>for i in range(len(R_ptr)-<NUM_LIT:1>):<EOL><INDENT>targets = R_indices[R_ptr[i]:R_ptr[i+<NUM_LIT:1>]]<EOL>if not len(targets):<EOL><INDENT>s_out[i] = S[i]<EOL>continue<EOL><DEDENT>neighbors = np.take(S, targets, axis=<NUM_LIT:0>)<EOL>if aggregate is np.average:<EOL><INDENT>weights = R_data[R_ptr[i]:R_ptr[i+<NUM_LIT:1>]]<EOL>s_out[i] = aggregate(neighbors, axis=<NUM_LIT:0>, weights=weights)<EOL><DEDENT>else:<EOL><INDENT>s_out[i] = aggregate(neighbors, axis=<NUM_LIT:0>)<EOL><DEDENT><DEDENT>return s_out<EOL>", "docstring": "Nearest-neighbor filter helper function.\n\n    This is an internal function, not for use outside of the decompose module.\n\n    It applies the nearest-neighbor filter to S, assuming that the first index\n    corresponds to observations.\n\n    Parameters\n    ----------\n    R_data, R_indices, R_ptr : np.ndarrays\n        The `data`, `indices`, and `indptr` of a scipy.sparse matrix\n\n    S : np.ndarray\n        The observation data to filter\n\n    aggregate : callable\n        The aggregation operator\n\n\n    Returns\n    -------\n    S_out : np.ndarray like S\n        The filtered data array", "id": "f18149:m3"}
{"signature": "@cache(level=<NUM_LIT:30>)<EOL>def hpss(S, kernel_size=<NUM_LIT>, power=<NUM_LIT>, mask=False, margin=<NUM_LIT:1.0>):", "body": "if np.iscomplexobj(S):<EOL><INDENT>S, phase = core.magphase(S)<EOL><DEDENT>else:<EOL><INDENT>phase = <NUM_LIT:1><EOL><DEDENT>if np.isscalar(kernel_size):<EOL><INDENT>win_harm = kernel_size<EOL>win_perc = kernel_size<EOL><DEDENT>else:<EOL><INDENT>win_harm = kernel_size[<NUM_LIT:0>]<EOL>win_perc = kernel_size[<NUM_LIT:1>]<EOL><DEDENT>if np.isscalar(margin):<EOL><INDENT>margin_harm = margin<EOL>margin_perc = margin<EOL><DEDENT>else:<EOL><INDENT>margin_harm = margin[<NUM_LIT:0>]<EOL>margin_perc = margin[<NUM_LIT:1>]<EOL><DEDENT>if margin_harm < <NUM_LIT:1> or margin_perc < <NUM_LIT:1>:<EOL><INDENT>raise ParameterError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>harm = np.empty_like(S)<EOL>harm[:] = median_filter(S, size=(<NUM_LIT:1>, win_harm), mode='<STR_LIT>')<EOL>perc = np.empty_like(S)<EOL>perc[:] = median_filter(S, size=(win_perc, <NUM_LIT:1>), mode='<STR_LIT>')<EOL>split_zeros = (margin_harm == <NUM_LIT:1> and margin_perc == <NUM_LIT:1>)<EOL>mask_harm = util.softmask(harm, perc * margin_harm,<EOL>power=power,<EOL>split_zeros=split_zeros)<EOL>mask_perc = util.softmask(perc, harm * margin_perc,<EOL>power=power,<EOL>split_zeros=split_zeros)<EOL>if mask:<EOL><INDENT>return mask_harm, mask_perc<EOL><DEDENT>return ((S * mask_harm) * phase, (S * mask_perc) * phase)<EOL>", "docstring": "Median-filtering harmonic percussive source separation (HPSS).\n\n    If `margin = 1.0`, decomposes an input spectrogram `S = H + P`\n    where `H` contains the harmonic components,\n    and `P` contains the percussive components.\n\n    If `margin > 1.0`, decomposes an input spectrogram `S = H + P + R`\n    where `R` contains residual components not included in `H` or `P`.\n\n    This implementation is based upon the algorithm described by [1]_ and [2]_.\n\n    .. [1] Fitzgerald, Derry.\n        \"Harmonic/percussive separation using median filtering.\"\n        13th International Conference on Digital Audio Effects (DAFX10),\n        Graz, Austria, 2010.\n\n    .. [2] Driedger, M\u00fcller, Disch.\n        \"Extending harmonic-percussive separation of audio.\"\n        15th International Society for Music Information Retrieval Conference (ISMIR 2014),\n        Taipei, Taiwan, 2014.\n\n    Parameters\n    ----------\n    S : np.ndarray [shape=(d, n)]\n        input spectrogram. May be real (magnitude) or complex.\n\n    kernel_size : int or tuple (kernel_harmonic, kernel_percussive)\n        kernel size(s) for the median filters.\n\n        - If scalar, the same size is used for both harmonic and percussive.\n        - If tuple, the first value specifies the width of the\n          harmonic filter, and the second value specifies the width\n          of the percussive filter.\n\n    power : float > 0 [scalar]\n        Exponent for the Wiener filter when constructing soft mask matrices.\n\n    mask : bool\n        Return the masking matrices instead of components.\n\n        Masking matrices contain non-negative real values that\n        can be used to measure the assignment of energy from `S`\n        into harmonic or percussive components.\n\n        Components can be recovered by multiplying `S * mask_H`\n        or `S * mask_P`.\n\n\n    margin : float or tuple (margin_harmonic, margin_percussive)\n        margin size(s) for the masks (as described in [2]_)\n\n        - If scalar, the same size is used for both harmonic and percussive.\n        - If tuple, the first value specifies the margin of the\n          harmonic mask, and the second value specifies the margin\n          of the percussive mask.\n\n    Returns\n    -------\n    harmonic : np.ndarray [shape=(d, n)]\n        harmonic component (or mask)\n\n    percussive : np.ndarray [shape=(d, n)]\n        percussive component (or mask)\n\n\n    See Also\n    --------\n    util.softmask\n\n    Notes\n    -----\n    This function caches at level 30.\n\n    Examples\n    --------\n    Separate into harmonic and percussive\n\n    >>> y, sr = librosa.load(librosa.util.example_audio_file(), duration=15)\n    >>> D = librosa.stft(y)\n    >>> H, P = librosa.decompose.hpss(D)\n\n    >>> import matplotlib.pyplot as plt\n    >>> plt.figure()\n    >>> plt.subplot(3, 1, 1)\n    >>> librosa.display.specshow(librosa.amplitude_to_db(np.abs(D),\n    ...                                                  ref=np.max),\n    ...                          y_axis='log')\n    >>> plt.colorbar(format='%+2.0f dB')\n    >>> plt.title('Full power spectrogram')\n    >>> plt.subplot(3, 1, 2)\n    >>> librosa.display.specshow(librosa.amplitude_to_db(np.abs(H),\n    ...                                                  ref=np.max),\n    ...                          y_axis='log')\n    >>> plt.colorbar(format='%+2.0f dB')\n    >>> plt.title('Harmonic power spectrogram')\n    >>> plt.subplot(3, 1, 3)\n    >>> librosa.display.specshow(librosa.amplitude_to_db(np.abs(P),\n    ...                                                  ref=np.max),\n    ...                          y_axis='log')\n    >>> plt.colorbar(format='%+2.0f dB')\n    >>> plt.title('Percussive power spectrogram')\n    >>> plt.tight_layout()\n\n\n    Or with a narrower horizontal filter\n\n    >>> H, P = librosa.decompose.hpss(D, kernel_size=(13, 31))\n\n    Just get harmonic/percussive masks, not the spectra\n\n    >>> mask_H, mask_P = librosa.decompose.hpss(D, mask=True)\n    >>> mask_H\n    array([[  1.000e+00,   1.469e-01, ...,   2.648e-03,   2.164e-03],\n           [  1.000e+00,   2.368e-01, ...,   9.413e-03,   7.703e-03],\n           ...,\n           [  8.869e-01,   5.673e-02, ...,   4.603e-02,   1.247e-05],\n           [  7.068e-01,   2.194e-02, ...,   4.453e-02,   1.205e-05]], dtype=float32)\n    >>> mask_P\n    array([[  2.858e-05,   8.531e-01, ...,   9.974e-01,   9.978e-01],\n           [  1.586e-05,   7.632e-01, ...,   9.906e-01,   9.923e-01],\n           ...,\n           [  1.131e-01,   9.433e-01, ...,   9.540e-01,   1.000e+00],\n           [  2.932e-01,   9.781e-01, ...,   9.555e-01,   1.000e+00]], dtype=float32)\n\n    Separate into harmonic/percussive/residual components by using a margin > 1.0\n\n    >>> H, P = librosa.decompose.hpss(D, margin=3.0)\n    >>> R = D - (H+P)\n    >>> y_harm = librosa.core.istft(H)\n    >>> y_perc = librosa.core.istft(P)\n    >>> y_resi = librosa.core.istft(R)\n\n\n    Get a more isolated percussive component by widening its margin\n\n    >>> H, P = librosa.decompose.hpss(D, margin=(1.0,5.0))", "id": "f18149:m1"}
{"signature": "def __trim_beats(localscore, beats, trim):", "body": "smooth_boe = scipy.signal.convolve(localscore[beats],<EOL>scipy.signal.hann(<NUM_LIT:5>),<EOL>'<STR_LIT>')<EOL>if trim:<EOL><INDENT>threshold = <NUM_LIT:0.5> * ((smooth_boe**<NUM_LIT:2>).mean()**<NUM_LIT:0.5>)<EOL><DEDENT>else:<EOL><INDENT>threshold = <NUM_LIT:0.0><EOL><DEDENT>valid = np.argwhere(smooth_boe > threshold)<EOL>return beats[valid.min():valid.max()]<EOL>", "docstring": "Final post-processing: throw out spurious leading/trailing beats", "id": "f18150:m7"}
{"signature": "@cache(level=<NUM_LIT:30>)<EOL>def tempo(y=None, sr=<NUM_LIT>, onset_envelope=None, hop_length=<NUM_LIT>, start_bpm=<NUM_LIT>,<EOL>std_bpm=<NUM_LIT:1.0>, ac_size=<NUM_LIT>, max_tempo=<NUM_LIT>, aggregate=np.mean):", "body": "if start_bpm <= <NUM_LIT:0>:<EOL><INDENT>raise ParameterError('<STR_LIT>')<EOL><DEDENT>win_length = np.asscalar(core.time_to_frames(ac_size, sr=sr,<EOL>hop_length=hop_length))<EOL>tg = tempogram(y=y, sr=sr,<EOL>onset_envelope=onset_envelope,<EOL>hop_length=hop_length,<EOL>win_length=win_length)<EOL>if aggregate is not None:<EOL><INDENT>tg = aggregate(tg, axis=<NUM_LIT:1>, keepdims=True)<EOL><DEDENT>bpms = core.tempo_frequencies(tg.shape[<NUM_LIT:0>], hop_length=hop_length, sr=sr)<EOL>prior = np.exp(-<NUM_LIT:0.5> * ((np.log2(bpms) - np.log2(start_bpm)) / std_bpm)**<NUM_LIT:2>)<EOL>if max_tempo is not None:<EOL><INDENT>max_idx = np.argmax(bpms < max_tempo)<EOL>prior[:max_idx] = <NUM_LIT:0><EOL><DEDENT>best_period = np.argmax(tg * prior[:, np.newaxis], axis=<NUM_LIT:0>)<EOL>tempi = bpms[best_period]<EOL>tempi[best_period == <NUM_LIT:0>] = start_bpm<EOL>return tempi<EOL>", "docstring": "Estimate the tempo (beats per minute)\n\n    Parameters\n    ----------\n    y : np.ndarray [shape=(n,)] or None\n        audio time series\n\n    sr : number > 0 [scalar]\n        sampling rate of the time series\n\n    onset_envelope    : np.ndarray [shape=(n,)]\n        pre-computed onset strength envelope\n\n    hop_length : int > 0 [scalar]\n        hop length of the time series\n\n    start_bpm : float [scalar]\n        initial guess of the BPM\n\n    std_bpm : float > 0 [scalar]\n        standard deviation of tempo distribution\n\n    ac_size : float > 0 [scalar]\n        length (in seconds) of the auto-correlation window\n\n    max_tempo : float > 0 [scalar, optional]\n        If provided, only estimate tempo below this threshold\n\n    aggregate : callable [optional]\n        Aggregation function for estimating global tempo.\n        If `None`, then tempo is estimated independently for each frame.\n\n    Returns\n    -------\n    tempo : np.ndarray [scalar]\n        estimated tempo (beats per minute)\n\n    See Also\n    --------\n    librosa.onset.onset_strength\n    librosa.feature.tempogram\n\n    Notes\n    -----\n    This function caches at level 30.\n\n    Examples\n    --------\n    >>> # Estimate a static tempo\n    >>> y, sr = librosa.load(librosa.util.example_audio_file())\n    >>> onset_env = librosa.onset.onset_strength(y, sr=sr)\n    >>> tempo = librosa.beat.tempo(onset_envelope=onset_env, sr=sr)\n    >>> tempo\n    array([129.199])\n\n    >>> # Or a dynamic tempo\n    >>> dtempo = librosa.beat.tempo(onset_envelope=onset_env, sr=sr,\n    ...                             aggregate=None)\n    >>> dtempo\n    array([ 143.555,  143.555,  143.555, ...,  161.499,  161.499,\n            172.266])\n\n\n    Plot the estimated tempo against the onset autocorrelation\n\n    >>> import matplotlib.pyplot as plt\n    >>> # Convert to scalar\n    >>> tempo = np.asscalar(tempo)\n    >>> # Compute 2-second windowed autocorrelation\n    >>> hop_length = 512\n    >>> ac = librosa.autocorrelate(onset_env, 2 * sr // hop_length)\n    >>> freqs = librosa.tempo_frequencies(len(ac), sr=sr,\n    ...                                   hop_length=hop_length)\n    >>> # Plot on a BPM axis.  We skip the first (0-lag) bin.\n    >>> plt.figure(figsize=(8,4))\n    >>> plt.semilogx(freqs[1:], librosa.util.normalize(ac)[1:],\n    ...              label='Onset autocorrelation', basex=2)\n    >>> plt.axvline(tempo, 0, 1, color='r', alpha=0.75, linestyle='--',\n    ...            label='Tempo: {:.2f} BPM'.format(tempo))\n    >>> plt.xlabel('Tempo (BPM)')\n    >>> plt.grid()\n    >>> plt.title('Static tempo estimation')\n    >>> plt.legend(frameon=True)\n    >>> plt.axis('tight')\n\n    Plot dynamic tempo estimates over a tempogram\n\n    >>> plt.figure()\n    >>> tg = librosa.feature.tempogram(onset_envelope=onset_env, sr=sr,\n    ...                                hop_length=hop_length)\n    >>> librosa.display.specshow(tg, x_axis='time', y_axis='tempo')\n    >>> plt.plot(librosa.frames_to_time(np.arange(len(dtempo))), dtempo,\n    ...          color='w', linewidth=1.5, label='Tempo estimate')\n    >>> plt.title('Dynamic tempo estimation')\n    >>> plt.legend(frameon=True, framealpha=0.75)", "id": "f18150:m1"}
{"signature": "@cache(level=<NUM_LIT:10>)<EOL>def window_bandwidth(window, n=<NUM_LIT:1000>):", "body": "if hasattr(window, '<STR_LIT>'):<EOL><INDENT>key = window.__name__<EOL><DEDENT>else:<EOL><INDENT>key = window<EOL><DEDENT>if key not in WINDOW_BANDWIDTHS:<EOL><INDENT>win = get_window(window, n)<EOL>WINDOW_BANDWIDTHS[key] = n * np.sum(win**<NUM_LIT:2>) / np.sum(np.abs(win))**<NUM_LIT:2><EOL><DEDENT>return WINDOW_BANDWIDTHS[key]<EOL>", "docstring": "Get the equivalent noise bandwidth of a window function.\n\n\n    Parameters\n    ----------\n    window : callable or string\n        A window function, or the name of a window function.\n        Examples:\n        - scipy.signal.hann\n        - 'boxcar'\n\n    n : int > 0\n        The number of coefficients to use in estimating the\n        window bandwidth\n\n    Returns\n    -------\n    bandwidth : float\n        The equivalent noise bandwidth (in FFT bins) of the\n        given window function\n\n    Notes\n    -----\n    This function caches at level 10.\n\n    See Also\n    --------\n    get_window", "id": "f18151:m6"}
{"signature": "@cache(level=<NUM_LIT:10>)<EOL>def mel(sr, n_fft, n_mels=<NUM_LIT>, fmin=<NUM_LIT:0.0>, fmax=None, htk=False,<EOL>norm=<NUM_LIT:1>, dtype=np.float32):", "body": "if fmax is None:<EOL><INDENT>fmax = float(sr) / <NUM_LIT:2><EOL><DEDENT>if norm is not None and norm != <NUM_LIT:1> and norm != np.inf:<EOL><INDENT>raise ParameterError('<STR_LIT>'.format(repr(norm)))<EOL><DEDENT>n_mels = int(n_mels)<EOL>weights = np.zeros((n_mels, int(<NUM_LIT:1> + n_fft // <NUM_LIT:2>)), dtype=dtype)<EOL>fftfreqs = fft_frequencies(sr=sr, n_fft=n_fft)<EOL>mel_f = mel_frequencies(n_mels + <NUM_LIT:2>, fmin=fmin, fmax=fmax, htk=htk)<EOL>fdiff = np.diff(mel_f)<EOL>ramps = np.subtract.outer(mel_f, fftfreqs)<EOL>for i in range(n_mels):<EOL><INDENT>lower = -ramps[i] / fdiff[i]<EOL>upper = ramps[i+<NUM_LIT:2>] / fdiff[i+<NUM_LIT:1>]<EOL>weights[i] = np.maximum(<NUM_LIT:0>, np.minimum(lower, upper))<EOL><DEDENT>if norm == <NUM_LIT:1>:<EOL><INDENT>enorm = <NUM_LIT> / (mel_f[<NUM_LIT:2>:n_mels+<NUM_LIT:2>] - mel_f[:n_mels])<EOL>weights *= enorm[:, np.newaxis]<EOL><DEDENT>if not np.all((mel_f[:-<NUM_LIT:2>] == <NUM_LIT:0>) | (weights.max(axis=<NUM_LIT:1>) > <NUM_LIT:0>)):<EOL><INDENT>warnings.warn('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>return weights<EOL>", "docstring": "Create a Filterbank matrix to combine FFT bins into Mel-frequency bins\n\n    Parameters\n    ----------\n    sr        : number > 0 [scalar]\n        sampling rate of the incoming signal\n\n    n_fft     : int > 0 [scalar]\n        number of FFT components\n\n    n_mels    : int > 0 [scalar]\n        number of Mel bands to generate\n\n    fmin      : float >= 0 [scalar]\n        lowest frequency (in Hz)\n\n    fmax      : float >= 0 [scalar]\n        highest frequency (in Hz).\n        If `None`, use `fmax = sr / 2.0`\n\n    htk       : bool [scalar]\n        use HTK formula instead of Slaney\n\n    norm : {None, 1, np.inf} [scalar]\n        if 1, divide the triangular mel weights by the width of the mel band\n        (area normalization).  Otherwise, leave all the triangles aiming for\n        a peak value of 1.0\n\n    dtype : np.dtype\n        The data type of the output basis.\n        By default, uses 32-bit (single-precision) floating point.\n\n    Returns\n    -------\n    M         : np.ndarray [shape=(n_mels, 1 + n_fft/2)]\n        Mel transform matrix\n\n    Notes\n    -----\n    This function caches at level 10.\n\n    Examples\n    --------\n    >>> melfb = librosa.filters.mel(22050, 2048)\n    >>> melfb\n    array([[ 0.   ,  0.016, ...,  0.   ,  0.   ],\n           [ 0.   ,  0.   , ...,  0.   ,  0.   ],\n           ...,\n           [ 0.   ,  0.   , ...,  0.   ,  0.   ],\n           [ 0.   ,  0.   , ...,  0.   ,  0.   ]])\n\n\n    Clip the maximum frequency to 8KHz\n\n    >>> librosa.filters.mel(22050, 2048, fmax=8000)\n    array([[ 0.  ,  0.02, ...,  0.  ,  0.  ],\n           [ 0.  ,  0.  , ...,  0.  ,  0.  ],\n           ...,\n           [ 0.  ,  0.  , ...,  0.  ,  0.  ],\n           [ 0.  ,  0.  , ...,  0.  ,  0.  ]])\n\n\n    >>> import matplotlib.pyplot as plt\n    >>> plt.figure()\n    >>> librosa.display.specshow(melfb, x_axis='linear')\n    >>> plt.ylabel('Mel filter')\n    >>> plt.title('Mel filter bank')\n    >>> plt.colorbar()\n    >>> plt.tight_layout()", "id": "f18151:m0"}
{"signature": "def window_sumsquare(window, n_frames, hop_length=<NUM_LIT>, win_length=None, n_fft=<NUM_LIT>,<EOL>dtype=np.float32, norm=None):", "body": "if win_length is None:<EOL><INDENT>win_length = n_fft<EOL><DEDENT>n = n_fft + hop_length * (n_frames - <NUM_LIT:1>)<EOL>x = np.zeros(n, dtype=dtype)<EOL>win_sq = get_window(window, win_length)<EOL>win_sq = util.normalize(win_sq, norm=norm)**<NUM_LIT:2><EOL>win_sq = util.pad_center(win_sq, n_fft)<EOL>__window_ss_fill(x, win_sq, n_frames, hop_length)<EOL>return x<EOL>", "docstring": "Compute the sum-square envelope of a window function at a given hop length.\n\nThis is used to estimate modulation effects induced by windowing observations\nin short-time fourier transforms.\n\nParameters\n----------\nwindow : string, tuple, number, callable, or list-like\n    Window specification, as in `get_window`\n\nn_frames : int > 0\n    The number of analysis frames\n\nhop_length : int > 0\n    The number of samples to advance between frames\n\nwin_length : [optional]\n    The length of the window function.  By default, this matches `n_fft`.\n\nn_fft : int > 0\n    The length of each analysis frame.\n\ndtype : np.dtype\n    The data type of the output\n\nReturns\n-------\nwss : np.ndarray, shape=`(n_fft + hop_length * (n_frames - 1))`\n    The sum-squared envelope of the window function\n\nExamples\n--------\nFor a fixed frame length (2048), compare modulation effects for a Hann window\nat different hop lengths:\n\n>>> n_frames = 50\n>>> wss_256 = librosa.filters.window_sumsquare('hann', n_frames, hop_length=256)\n>>> wss_512 = librosa.filters.window_sumsquare('hann', n_frames, hop_length=512)\n>>> wss_1024 = librosa.filters.window_sumsquare('hann', n_frames, hop_length=1024)\n\n>>> import matplotlib.pyplot as plt\n>>> plt.figure()\n>>> plt.subplot(3,1,1)\n>>> plt.plot(wss_256)\n>>> plt.title('hop_length=256')\n>>> plt.subplot(3,1,2)\n>>> plt.plot(wss_512)\n>>> plt.title('hop_length=512')\n>>> plt.subplot(3,1,3)\n>>> plt.plot(wss_1024)\n>>> plt.title('hop_length=1024')\n>>> plt.tight_layout()", "id": "f18151:m12"}
{"signature": "@jit(nopython=True, cache=True)<EOL>def __window_ss_fill(x, win_sq, n_frames, hop_length):  ", "body": "n = len(x)<EOL>n_fft = len(win_sq)<EOL>for i in range(n_frames):<EOL><INDENT>sample = i * hop_length<EOL>x[sample:min(n, sample + n_fft)] += win_sq[:max(<NUM_LIT:0>, min(n_fft, n - sample))]<EOL><DEDENT>", "docstring": "Helper function for window sum-square calculation.", "id": "f18151:m11"}
{"signature": "@cache(level=<NUM_LIT:10>)<EOL>def get_window(window, Nx, fftbins=True):", "body": "if six.callable(window):<EOL><INDENT>return window(Nx)<EOL><DEDENT>elif (isinstance(window, (six.string_types, tuple)) or<EOL>np.isscalar(window)):<EOL><INDENT>return scipy.signal.get_window(window, Nx, fftbins=fftbins)<EOL><DEDENT>elif isinstance(window, (np.ndarray, list)):<EOL><INDENT>if len(window) == Nx:<EOL><INDENT>return np.asarray(window)<EOL><DEDENT>raise ParameterError('<STR_LIT>'<EOL>'<STR_LIT>'.format(len(window), Nx))<EOL><DEDENT>else:<EOL><INDENT>raise ParameterError('<STR_LIT>'.format(window))<EOL><DEDENT>", "docstring": "Compute a window function.\n\n    This is a wrapper for `scipy.signal.get_window` that additionally\n    supports callable or pre-computed windows.\n\n    Parameters\n    ----------\n    window : string, tuple, number, callable, or list-like\n        The window specification:\n\n        - If string, it's the name of the window function (e.g., `'hann'`)\n        - If tuple, it's the name of the window function and any parameters\n          (e.g., `('kaiser', 4.0)`)\n        - If numeric, it is treated as the beta parameter of the `'kaiser'`\n          window, as in `scipy.signal.get_window`.\n        - If callable, it's a function that accepts one integer argument\n          (the window length)\n        - If list-like, it's a pre-computed window of the correct length `Nx`\n\n    Nx : int > 0\n        The length of the window\n\n    fftbins : bool, optional\n        If True (default), create a periodic window for use with FFT\n        If False, create a symmetric window for filter design applications.\n\n    Returns\n    -------\n    get_window : np.ndarray\n        A window of length `Nx` and type `window`\n\n    See Also\n    --------\n    scipy.signal.get_window\n\n    Notes\n    -----\n    This function caches at level 10.\n\n    Raises\n    ------\n    ParameterError\n        If `window` is supplied as a vector of length != `n_fft`,\n        or is otherwise mis-specified.", "id": "f18151:m7"}
{"signature": "@cache(level=<NUM_LIT:10>)<EOL>def constant_q(sr, fmin=None, n_bins=<NUM_LIT>, bins_per_octave=<NUM_LIT:12>, tuning=<NUM_LIT:0.0>,<EOL>window='<STR_LIT>', filter_scale=<NUM_LIT:1>, pad_fft=True, norm=<NUM_LIT:1>,<EOL>dtype=np.complex64, **kwargs):", "body": "if fmin is None:<EOL><INDENT>fmin = note_to_hz('<STR_LIT>')<EOL><DEDENT>lengths = constant_q_lengths(sr, fmin,<EOL>n_bins=n_bins,<EOL>bins_per_octave=bins_per_octave,<EOL>tuning=tuning,<EOL>window=window,<EOL>filter_scale=filter_scale)<EOL>correction = <NUM_LIT>**(float(tuning) / bins_per_octave)<EOL>fmin = correction * fmin<EOL>Q = float(filter_scale) / (<NUM_LIT>**(<NUM_LIT:1.> / bins_per_octave) - <NUM_LIT:1>)<EOL>freqs = Q * sr / lengths<EOL>filters = []<EOL>for ilen, freq in zip(lengths, freqs):<EOL><INDENT>sig = np.exp(np.arange(-ilen//<NUM_LIT:2>, ilen//<NUM_LIT:2>, dtype=float) * <NUM_LIT> * <NUM_LIT:2> * np.pi * freq / sr)<EOL>sig = sig * __float_window(window)(len(sig))<EOL>sig = util.normalize(sig, norm=norm)<EOL>filters.append(sig)<EOL><DEDENT>max_len = max(lengths)<EOL>if pad_fft:<EOL><INDENT>max_len = int(<NUM_LIT>**(np.ceil(np.log2(max_len))))<EOL><DEDENT>else:<EOL><INDENT>max_len = int(np.ceil(max_len))<EOL><DEDENT>filters = np.asarray([util.pad_center(filt, max_len, **kwargs)<EOL>for filt in filters], dtype=dtype)<EOL>return filters, np.asarray(lengths)<EOL>", "docstring": "r'''Construct a constant-Q basis.\n\n    This uses the filter bank described by [1]_.\n\n    .. [1] McVicar, Matthew.\n            \"A machine learning approach to automatic chord extraction.\"\n            Dissertation, University of Bristol. 2013.\n\n\n    Parameters\n    ----------\n    sr : number > 0 [scalar]\n        Audio sampling rate\n\n    fmin : float > 0 [scalar]\n        Minimum frequency bin. Defaults to `C1 ~= 32.70`\n\n    n_bins : int > 0 [scalar]\n        Number of frequencies.  Defaults to 7 octaves (84 bins).\n\n    bins_per_octave : int > 0 [scalar]\n        Number of bins per octave\n\n    tuning : float in `[-0.5, +0.5)` [scalar]\n        Tuning deviation from A440 in fractions of a bin\n\n    window : string, tuple, number, or function\n        Windowing function to apply to filters.\n\n    filter_scale : float > 0 [scalar]\n        Scale of filter windows.\n        Small values (<1) use shorter windows for higher temporal resolution.\n\n    pad_fft : boolean\n        Center-pad all filters up to the nearest integral power of 2.\n\n        By default, padding is done with zeros, but this can be overridden\n        by setting the `mode=` field in *kwargs*.\n\n    norm : {inf, -inf, 0, float > 0}\n        Type of norm to use for basis function normalization.\n        See librosa.util.normalize\n\n    dtype : np.dtype\n        The data type of the output basis.\n        By default, uses 64-bit (single precision) complex floating point.\n\n    kwargs : additional keyword arguments\n        Arguments to `np.pad()` when `pad==True`.\n\n    Returns\n    -------\n    filters : np.ndarray, `len(filters) == n_bins`\n        `filters[i]` is `i`\\ th time-domain CQT basis filter\n\n    lengths : np.ndarray, `len(lengths) == n_bins`\n        The (fractional) length of each filter\n\n    Notes\n    -----\n    This function caches at level 10.\n\n    See Also\n    --------\n    constant_q_lengths\n    librosa.core.cqt\n    librosa.util.normalize\n\n\n    Examples\n    --------\n    Use a shorter window for each filter\n\n    >>> basis, lengths = librosa.filters.constant_q(22050, filter_scale=0.5)\n\n    Plot one octave of filters in time and frequency\n\n    >>> import matplotlib.pyplot as plt\n    >>> basis, lengths = librosa.filters.constant_q(22050)\n    >>> plt.figure(figsize=(10, 6))\n    >>> plt.subplot(2, 1, 1)\n    >>> notes = librosa.midi_to_note(np.arange(24, 24 + len(basis)))\n    >>> for i, (f, n) in enumerate(zip(basis, notes[:12])):\n    ...     f_scale = librosa.util.normalize(f) / 2\n    ...     plt.plot(i + f_scale.real)\n    ...     plt.plot(i + f_scale.imag, linestyle=':')\n    >>> plt.axis('tight')\n    >>> plt.yticks(np.arange(len(notes[:12])), notes[:12])\n    >>> plt.ylabel('CQ filters')\n    >>> plt.title('CQ filters (one octave, time domain)')\n    >>> plt.xlabel('Time (samples at 22050 Hz)')\n    >>> plt.legend(['Real', 'Imaginary'], frameon=True, framealpha=0.8)\n    >>> plt.subplot(2, 1, 2)\n    >>> F = np.abs(np.fft.fftn(basis, axes=[-1]))\n    >>> # Keep only the positive frequencies\n    >>> F = F[:, :(1 + F.shape[1] // 2)]\n    >>> librosa.display.specshow(F, x_axis='linear')\n    >>> plt.yticks(np.arange(len(notes))[::12], notes[::12])\n    >>> plt.ylabel('CQ filters')\n    >>> plt.title('CQ filter magnitudes (frequency domain)')\n    >>> plt.tight_layout()", "id": "f18151:m3"}
{"signature": "@cache(level=<NUM_LIT:10>)<EOL>def cq_to_chroma(n_input, bins_per_octave=<NUM_LIT:12>, n_chroma=<NUM_LIT:12>,<EOL>fmin=None, window=None, base_c=True, dtype=np.float32):", "body": "<EOL>n_merge = float(bins_per_octave) / n_chroma<EOL>if fmin is None:<EOL><INDENT>fmin = note_to_hz('<STR_LIT>')<EOL><DEDENT>if np.mod(n_merge, <NUM_LIT:1>) != <NUM_LIT:0>:<EOL><INDENT>raise ParameterError('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>cq_to_ch = np.repeat(np.eye(n_chroma), n_merge, axis=<NUM_LIT:1>)<EOL>cq_to_ch = np.roll(cq_to_ch, - int(n_merge // <NUM_LIT:2>), axis=<NUM_LIT:1>)<EOL>n_octaves = np.ceil(np.float(n_input) / bins_per_octave)<EOL>cq_to_ch = np.tile(cq_to_ch, int(n_octaves))[:, :n_input]<EOL>midi_0 = np.mod(hz_to_midi(fmin), <NUM_LIT:12>)<EOL>if base_c:<EOL><INDENT>roll = midi_0<EOL><DEDENT>else:<EOL><INDENT>roll = midi_0 - <NUM_LIT:9><EOL><DEDENT>roll = int(np.round(roll * (n_chroma / <NUM_LIT>)))<EOL>cq_to_ch = np.roll(cq_to_ch, roll, axis=<NUM_LIT:0>).astype(dtype)<EOL>if window is not None:<EOL><INDENT>cq_to_ch = scipy.signal.convolve(cq_to_ch,<EOL>np.atleast_2d(window),<EOL>mode='<STR_LIT>')<EOL><DEDENT>return cq_to_ch<EOL>", "docstring": "Convert a Constant-Q basis to Chroma.\n\n\n    Parameters\n    ----------\n    n_input : int > 0 [scalar]\n        Number of input components (CQT bins)\n\n    bins_per_octave : int > 0 [scalar]\n        How many bins per octave in the CQT\n\n    n_chroma : int > 0 [scalar]\n        Number of output bins (per octave) in the chroma\n\n    fmin : None or float > 0\n        Center frequency of the first constant-Q channel.\n        Default: 'C1' ~= 32.7 Hz\n\n    window : None or np.ndarray\n        If provided, the cq_to_chroma filter bank will be\n        convolved with `window`.\n\n    base_c : bool\n        If True, the first chroma bin will start at 'C'\n        If False, the first chroma bin will start at 'A'\n\n    dtype : np.dtype\n        The data type of the output basis.\n        By default, uses 32-bit (single-precision) floating point.\n\n\n    Returns\n    -------\n    cq_to_chroma : np.ndarray [shape=(n_chroma, n_input)]\n        Transformation matrix: `Chroma = np.dot(cq_to_chroma, CQT)`\n\n    Raises\n    ------\n    ParameterError\n        If `n_input` is not an integer multiple of `n_chroma`\n\n    Notes\n    -----\n    This function caches at level 10.\n\n    Examples\n    --------\n    Get a CQT, and wrap bins to chroma\n\n    >>> y, sr = librosa.load(librosa.util.example_audio_file())\n    >>> CQT = np.abs(librosa.cqt(y, sr=sr))\n    >>> chroma_map = librosa.filters.cq_to_chroma(CQT.shape[0])\n    >>> chromagram = chroma_map.dot(CQT)\n    >>> # Max-normalize each time step\n    >>> chromagram = librosa.util.normalize(chromagram, axis=0)\n\n    >>> import matplotlib.pyplot as plt\n    >>> plt.subplot(3, 1, 1)\n    >>> librosa.display.specshow(librosa.amplitude_to_db(CQT,\n    ...                                                  ref=np.max),\n    ...                          y_axis='cqt_note')\n    >>> plt.title('CQT Power')\n    >>> plt.colorbar()\n    >>> plt.subplot(3, 1, 2)\n    >>> librosa.display.specshow(chromagram, y_axis='chroma')\n    >>> plt.title('Chroma (wrapped CQT)')\n    >>> plt.colorbar()\n    >>> plt.subplot(3, 1, 3)\n    >>> chroma = librosa.feature.chroma_stft(y=y, sr=sr)\n    >>> librosa.display.specshow(chroma, y_axis='chroma', x_axis='time')\n    >>> plt.title('librosa.feature.chroma_stft')\n    >>> plt.colorbar()\n    >>> plt.tight_layout()", "id": "f18151:m5"}
{"signature": "@jit(nopython=True, cache=True)<EOL>def __dtw_backtracking(D_steps, step_sizes_sigma):  ", "body": "wp = []<EOL>cur_idx = (D_steps.shape[<NUM_LIT:0>] - <NUM_LIT:1>, D_steps.shape[<NUM_LIT:1>] - <NUM_LIT:1>)<EOL>wp.append((cur_idx[<NUM_LIT:0>], cur_idx[<NUM_LIT:1>]))<EOL>while cur_idx[<NUM_LIT:0>] > <NUM_LIT:0>:<EOL><INDENT>cur_step_idx = D_steps[(cur_idx[<NUM_LIT:0>], cur_idx[<NUM_LIT:1>])]<EOL>cur_idx = (cur_idx[<NUM_LIT:0>] - step_sizes_sigma[cur_step_idx][<NUM_LIT:0>],<EOL>cur_idx[<NUM_LIT:1>] - step_sizes_sigma[cur_step_idx][<NUM_LIT:1>])<EOL>wp.append((cur_idx[<NUM_LIT:0>], cur_idx[<NUM_LIT:1>]))<EOL><DEDENT>return wp<EOL>", "docstring": "Backtrack optimal warping path.\n\n    Uses the saved step sizes from the cost accumulation\n    step to backtrack the index pairs for an optimal\n    warping path.\n\n\n    Parameters\n    ----------\n    D_steps : np.ndarray [shape=(N, M)]\n        Saved indices of the used steps used in the calculation of D.\n\n    step_sizes_sigma : np.ndarray [shape=[n, 2]]\n        Specifies allowed step sizes as used by the dtw.\n\n    Returns\n    -------\n    wp : list [shape=(N,)]\n        Warping path with index pairs.\n        Each list entry contains an index pair\n        (n,m) as a tuple\n\n    See Also\n    --------\n    dtw", "id": "f18152:m2"}
{"signature": "def viterbi_discriminative(prob, transition, p_state=None, p_init=None, return_logp=False):", "body": "n_states, n_steps = prob.shape<EOL>if transition.shape != (n_states, n_states):<EOL><INDENT>raise ParameterError('<STR_LIT>'<EOL>'<STR_LIT>'.format(transition.shape,<EOL>(n_states, n_states)))<EOL><DEDENT>if np.any(transition < <NUM_LIT:0>) or not np.allclose(transition.sum(axis=<NUM_LIT:1>), <NUM_LIT:1>):<EOL><INDENT>raise ParameterError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>if np.any(prob < <NUM_LIT:0>) or not np.allclose(prob.sum(axis=<NUM_LIT:0>), <NUM_LIT:1>):<EOL><INDENT>raise ParameterError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>states = np.zeros(n_steps, dtype=int)<EOL>values = np.zeros((n_steps, n_states), dtype=float)<EOL>ptr = np.zeros((n_steps, n_states), dtype=int)<EOL>epsilon = np.finfo(prob.dtype).tiny<EOL>if p_state is None:<EOL><INDENT>p_state = np.empty(n_states)<EOL>p_state.fill(<NUM_LIT:1.>/n_states)<EOL><DEDENT>elif p_state.shape != (n_states,):<EOL><INDENT>raise ParameterError('<STR_LIT>'<EOL>'<STR_LIT>'.format(p_state.shape))<EOL><DEDENT>elif np.any(p_state < <NUM_LIT:0>) or not np.allclose(p_state.sum(axis=-<NUM_LIT:1>), <NUM_LIT:1>):<EOL><INDENT>raise ParameterError('<STR_LIT>'<EOL>'<STR_LIT>'.format(p_state))<EOL><DEDENT>log_trans = np.log(transition + epsilon)<EOL>log_marginal = np.log(p_state + epsilon)<EOL>log_prob = np.log(prob.T + epsilon) - log_marginal<EOL>if p_init is None:<EOL><INDENT>p_init = np.empty(n_states)<EOL>p_init.fill(<NUM_LIT:1.>/n_states)<EOL><DEDENT>elif np.any(p_init < <NUM_LIT:0>) or not np.allclose(p_init.sum(), <NUM_LIT:1>):<EOL><INDENT>raise ParameterError('<STR_LIT>'<EOL>'<STR_LIT>'.format(p_init))<EOL><DEDENT>log_p_init = np.log(p_init + epsilon)<EOL>_viterbi(log_prob, log_trans, log_p_init, states, values, ptr)<EOL>if return_logp:<EOL><INDENT>return states, values[-<NUM_LIT:1>, states[-<NUM_LIT:1>]]<EOL><DEDENT>return states<EOL>", "docstring": "Viterbi decoding from discriminative state predictions.\n\n    Given a sequence of conditional state predictions `prob[s, t]`,\n    indicating the conditional likelihood of state `s` given the\n    observation at time `t`, and a transition matrix `transition[i, j]`\n    which encodes the conditional probability of moving from state `i`\n    to state `j`, the Viterbi algorithm computes the most likely sequence\n    of states from the observations.\n\n    This implementation uses the standard Viterbi decoding algorithm\n    for observation likelihood sequences, under the assumption that\n    `P[Obs(t) | State(t) = s]` is proportional to\n    `P[State(t) = s | Obs(t)] / P[State(t) = s]`, where the denominator\n    is the marginal probability of state `s` occurring as given by `p_state`.\n\n    Parameters\n    ----------\n    prob : np.ndarray [shape=(n_states, n_steps), non-negative]\n        `prob[s, t]` is the probability of state `s` conditional on\n        the observation at time `t`.\n        Must be non-negative and sum to 1 along each column.\n\n    transition : np.ndarray [shape=(n_states, n_states), non-negative]\n        `transition[i, j]` is the probability of a transition from i->j.\n        Each row must sum to 1.\n\n    p_state : np.ndarray [shape=(n_states,)]\n        Optional: marginal probability distribution over states,\n        must be non-negative and sum to 1.\n        If not provided, a uniform distribution is assumed.\n\n    p_init : np.ndarray [shape=(n_states,)]\n        Optional: initial state distribution.\n        If not provided, it is assumed to be uniform.\n\n    return_logp : bool\n        If `True`, return the log-likelihood of the state sequence.\n\n    Returns\n    -------\n    Either `states` or `(states, logp)`:\n\n    states : np.ndarray [shape=(n_steps,)]\n        The most likely state sequence.\n\n    logp : scalar [float]\n        If `return_logp=True`, the log probability of `states` given\n        the observations.\n\n    See Also\n    --------\n    viterbi : Viterbi decoding from observation likelihoods\n    viterbi_binary: Viterbi decoding for multi-label, conditional state likelihoods\n\n    Examples\n    --------\n    This example constructs a simple, template-based discriminative chord estimator,\n    using CENS chroma as input features.\n\n    .. note:: this chord model is not accurate enough to use in practice. It is only\n            intended to demonstrate how to use discriminative Viterbi decoding.\n\n    >>> # Create templates for major, minor, and no-chord qualities\n    >>> maj_template = np.array([1,0,0, 0,1,0, 0,1,0, 0,0,0])\n    >>> min_template = np.array([1,0,0, 1,0,0, 0,1,0, 0,0,0])\n    >>> N_template   = np.array([1,1,1, 1,1,1, 1,1,1, 1,1,1.]) / 4.\n    >>> # Generate the weighting matrix that maps chroma to labels\n    >>> weights = np.zeros((25, 12), dtype=float)\n    >>> labels = ['C:maj', 'C#:maj', 'D:maj', 'D#:maj', 'E:maj', 'F:maj',\n    ...           'F#:maj', 'G:maj', 'G#:maj', 'A:maj', 'A#:maj', 'B:maj',\n    ...           'C:min', 'C#:min', 'D:min', 'D#:min', 'E:min', 'F:min',\n    ...           'F#:min', 'G:min', 'G#:min', 'A:min', 'A#:min', 'B:min',\n    ...           'N']\n    >>> for c in range(12):\n    ...     weights[c, :] = np.roll(maj_template, c) # c:maj\n    ...     weights[c + 12, :] = np.roll(min_template, c)  # c:min\n    >>> weights[-1] = N_template  # the last row is the no-chord class\n    >>> # Make a self-loop transition matrix over 25 states\n    >>> trans = librosa.sequence.transition_loop(25, 0.9)\n\n    >>> # Load in audio and make features\n    >>> y, sr = librosa.load(librosa.util.example_audio_file())\n    >>> chroma = librosa.feature.chroma_cens(y=y, sr=sr, bins_per_octave=36)\n    >>> # Map chroma (observations) to class (state) likelihoods\n    >>> probs = np.exp(weights.dot(chroma))  # P[class | chroma] proportional to exp(template' chroma)\n    >>> probs /= probs.sum(axis=0, keepdims=True)  # probabilities must sum to 1 in each column\n    >>> # Compute independent frame-wise estimates\n    >>> chords_ind = np.argmax(probs, axis=0)\n    >>> # And viterbi estimates\n    >>> chords_vit = librosa.sequence.viterbi_discriminative(probs, trans)\n\n    >>> # Plot the features and prediction map\n    >>> import matplotlib.pyplot as plt\n    >>> plt.figure(figsize=(10, 6))\n    >>> plt.subplot(2,1,1)\n    >>> librosa.display.specshow(chroma, x_axis='time', y_axis='chroma')\n    >>> plt.colorbar()\n    >>> plt.subplot(2,1,2)\n    >>> librosa.display.specshow(weights, x_axis='chroma')\n    >>> plt.yticks(np.arange(25) + 0.5, labels)\n    >>> plt.ylabel('Chord')\n    >>> plt.colorbar()\n    >>> plt.tight_layout()\n\n    >>> # And plot the results\n    >>> plt.figure(figsize=(10, 4))\n    >>> librosa.display.specshow(probs, x_axis='time', cmap='gray')\n    >>> plt.colorbar()\n    >>> times = librosa.frames_to_time(np.arange(len(chords_vit)))\n    >>> plt.scatter(times, chords_ind + 0.75, color='lime', alpha=0.5, marker='+', s=15, label='Independent')\n    >>> plt.scatter(times, chords_vit + 0.25, color='deeppink', alpha=0.5, marker='o', s=15, label='Viterbi')\n    >>> plt.yticks(0.5 + np.unique(chords_vit), [labels[i] for i in np.unique(chords_vit)], va='center')\n    >>> plt.legend(loc='best')\n    >>> plt.tight_layout()", "id": "f18152:m5"}
{"signature": "def transition_loop(n_states, prob):", "body": "if not isinstance(n_states, int) or n_states <= <NUM_LIT:1>:<EOL><INDENT>raise ParameterError('<STR_LIT>')<EOL><DEDENT>transition = np.empty((n_states, n_states), dtype=np.float)<EOL>prob = np.asarray(prob, dtype=np.float)<EOL>if prob.ndim == <NUM_LIT:0>:<EOL><INDENT>prob = np.tile(prob, n_states)<EOL><DEDENT>if prob.shape != (n_states,):<EOL><INDENT>raise ParameterError('<STR_LIT>'.format(prob, n_states))<EOL><DEDENT>if np.any(prob < <NUM_LIT:0>) or np.any(prob > <NUM_LIT:1>):<EOL><INDENT>raise ParameterError('<STR_LIT>'.format(prob))<EOL><DEDENT>for i, prob_i in enumerate(prob):<EOL><INDENT>transition[i] = (<NUM_LIT:1.> - prob_i) / (n_states - <NUM_LIT:1>)<EOL>transition[i, i] = prob_i<EOL><DEDENT>return transition<EOL>", "docstring": "Construct a self-loop transition matrix over `n_states`.\n\n    The transition matrix will have the following properties:\n\n        - `transition[i, i] = p` for all i\n        - `transition[i, j] = (1 - p) / (n_states - 1)` for all `j != i`\n\n    This type of transition matrix is appropriate when states tend to be\n    locally stable, and there is no additional structure between different\n    states.  This is primarily useful for de-noising frame-wise predictions.\n\n    Parameters\n    ----------\n    n_states : int > 1\n        The number of states\n\n    prob : float in [0, 1] or iterable, length=n_states\n        If a scalar, this is the probability of a self-transition.\n\n        If a vector of length `n_states`, `p[i]` is the probability of state `i`'s self-transition.\n\n    Returns\n    -------\n    transition : np.ndarray [shape=(n_states, n_states)]\n        The transition matrix\n\n    Examples\n    --------\n    >>> librosa.sequence.transition_loop(3, 0.5)\n    array([[0.5 , 0.25, 0.25],\n           [0.25, 0.5 , 0.25],\n           [0.25, 0.25, 0.5 ]])\n\n    >>> librosa.sequence.transition_loop(3, [0.8, 0.5, 0.25])\n    array([[0.8  , 0.1  , 0.1  ],\n           [0.25 , 0.5  , 0.25 ],\n           [0.375, 0.375, 0.25 ]])", "id": "f18152:m8"}
{"signature": "@jit(nopython=True, cache=True)<EOL>def _viterbi(log_prob, log_trans, log_p_init, state, value, ptr):  ", "body": "n_steps, n_states = log_prob.shape<EOL>value[<NUM_LIT:0>] = log_prob[<NUM_LIT:0>] + log_p_init<EOL>for t in range(<NUM_LIT:1>, n_steps):<EOL><INDENT>trans_out = value[t - <NUM_LIT:1>] + log_trans.T<EOL>for j in range(n_states):<EOL><INDENT>ptr[t, j] = np.argmax(trans_out[j])<EOL>value[t, j] = log_prob[t, j] + trans_out[j, ptr[t][j]]<EOL><DEDENT><DEDENT>state[-<NUM_LIT:1>] = np.argmax(value[-<NUM_LIT:1>])<EOL>for t in range(n_steps - <NUM_LIT:2>, -<NUM_LIT:1>, -<NUM_LIT:1>):<EOL><INDENT>state[t] = ptr[t+<NUM_LIT:1>, state[t+<NUM_LIT:1>]]<EOL><DEDENT>", "docstring": "Core Viterbi algorithm.\n\n    This is intended for internal use only.\n\n    Parameters\n    ----------\n    log_prob : np.ndarray [shape=(T, m)]\n        `log_prob[t, s]` is the conditional log-likelihood\n        log P[X = X(t) | State(t) = s]\n\n    log_trans : np.ndarray [shape=(m, m)]\n        The log transition matrix\n        `log_trans[i, j]` = log P[State(t+1) = j | State(t) = i]\n\n    log_p_init : np.ndarray [shape=(m,)]\n        log of the initial state distribution\n\n    state : np.ndarray [shape=(T,), dtype=int]\n        Pre-allocated state index array\n\n    value : np.ndarray [shape=(T, m)] float\n        Pre-allocated value array\n\n    ptr : np.ndarray [shape=(T, m), dtype=int]\n        Pre-allocated pointer array\n\n    Returns\n    -------\n    None\n        All computations are performed in-place on `state, value, ptr`.", "id": "f18152:m3"}
{"signature": "def dtw(X=None, Y=None, C=None, metric='<STR_LIT>', step_sizes_sigma=None,<EOL>weights_add=None, weights_mul=None, subseq=False, backtrack=True,<EOL>global_constraints=False, band_rad=<NUM_LIT>):", "body": "<EOL>if step_sizes_sigma is None:<EOL><INDENT>step_sizes_sigma = np.array([[<NUM_LIT:1>, <NUM_LIT:1>], [<NUM_LIT:0>, <NUM_LIT:1>], [<NUM_LIT:1>, <NUM_LIT:0>]])<EOL><DEDENT>if weights_add is None:<EOL><INDENT>weights_add = np.zeros(len(step_sizes_sigma))<EOL><DEDENT>if weights_mul is None:<EOL><INDENT>weights_mul = np.ones(len(step_sizes_sigma))<EOL><DEDENT>if len(step_sizes_sigma) != len(weights_add):<EOL><INDENT>raise ParameterError('<STR_LIT>')<EOL><DEDENT>if len(step_sizes_sigma) != len(weights_mul):<EOL><INDENT>raise ParameterError('<STR_LIT>')<EOL><DEDENT>if C is None and (X is None or Y is None):<EOL><INDENT>raise ParameterError('<STR_LIT>')<EOL><DEDENT>if C is not None and (X is not None or Y is not None):<EOL><INDENT>raise ParameterError('<STR_LIT>')<EOL><DEDENT>if C is None:<EOL><INDENT>X = np.atleast_2d(X)<EOL>Y = np.atleast_2d(Y)<EOL>try:<EOL><INDENT>C = cdist(X.T, Y.T, metric=metric)<EOL><DEDENT>except ValueError:<EOL><INDENT>msg = ('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>six.reraise(ParameterError, ParameterError(msg))<EOL><DEDENT>if subseq and (X.shape[<NUM_LIT:1>] > Y.shape[<NUM_LIT:1>]):<EOL><INDENT>C = C.T<EOL><DEDENT><DEDENT>C = np.atleast_2d(C)<EOL>if np.array_equal(step_sizes_sigma, np.array([[<NUM_LIT:1>, <NUM_LIT:1>]])) and (C.shape[<NUM_LIT:0>] > C.shape[<NUM_LIT:1>]):<EOL><INDENT>raise ParameterError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>max_0 = step_sizes_sigma[:, <NUM_LIT:0>].max()<EOL>max_1 = step_sizes_sigma[:, <NUM_LIT:1>].max()<EOL>if global_constraints:<EOL><INDENT>fill_off_diagonal(C, band_rad, value=np.inf)<EOL><DEDENT>D = np.ones(C.shape + np.array([max_0, max_1])) * np.inf<EOL>D[max_0, max_1] = C[<NUM_LIT:0>, <NUM_LIT:0>]<EOL>if subseq:<EOL><INDENT>D[max_0, max_1:] = C[<NUM_LIT:0>, :]<EOL><DEDENT>D_steps = -<NUM_LIT:1> * np.ones(D.shape, dtype=np.int)<EOL>D, D_steps = __dtw_calc_accu_cost(C, D, D_steps,<EOL>step_sizes_sigma,<EOL>weights_mul, weights_add,<EOL>max_0, max_1)<EOL>D = D[max_0:, max_1:]<EOL>D_steps = D_steps[max_0:, max_1:]<EOL>if backtrack:<EOL><INDENT>if subseq:<EOL><INDENT>wp_end_idx = np.argmin(D[-<NUM_LIT:1>, :]) + <NUM_LIT:1><EOL>wp = __dtw_backtracking(D_steps[:, :wp_end_idx], step_sizes_sigma)<EOL><DEDENT>else:<EOL><INDENT>wp = __dtw_backtracking(D_steps, step_sizes_sigma)<EOL><DEDENT>wp = np.asarray(wp, dtype=int)<EOL>if subseq and (X.shape[<NUM_LIT:1>] > Y.shape[<NUM_LIT:1>]):<EOL><INDENT>wp = np.fliplr(wp)<EOL><DEDENT>return D, wp<EOL><DEDENT>else:<EOL><INDENT>return D<EOL><DEDENT>", "docstring": "Dynamic time warping (DTW).\n\n    This function performs a DTW and path backtracking on two sequences.\n    We follow the nomenclature and algorithmic approach as described in [1]_.\n\n    .. [1] Meinard Mueller\n           Fundamentals of Music Processing \u2014 Audio, Analysis, Algorithms, Applications\n           Springer Verlag, ISBN: 978-3-319-21944-8, 2015.\n\n    Parameters\n    ----------\n    X : np.ndarray [shape=(K, N)]\n        audio feature matrix (e.g., chroma features)\n\n    Y : np.ndarray [shape=(K, M)]\n        audio feature matrix (e.g., chroma features)\n\n    C : np.ndarray [shape=(N, M)]\n        Precomputed distance matrix. If supplied, X and Y must not be supplied and\n        ``metric`` will be ignored.\n\n    metric : str\n        Identifier for the cost-function as documented\n        in `scipy.spatial.cdist()`\n\n    step_sizes_sigma : np.ndarray [shape=[n, 2]]\n        Specifies allowed step sizes as used by the dtw.\n\n    weights_add : np.ndarray [shape=[n, ]]\n        Additive weights to penalize certain step sizes.\n\n    weights_mul : np.ndarray [shape=[n, ]]\n        Multiplicative weights to penalize certain step sizes.\n\n    subseq : binary\n        Enable subsequence DTW, e.g., for retrieval tasks.\n\n    backtrack : binary\n        Enable backtracking in accumulated cost matrix.\n\n    global_constraints : binary\n        Applies global constraints to the cost matrix ``C`` (Sakoe-Chiba band).\n\n    band_rad : float\n        The Sakoe-Chiba band radius (1/2 of the width) will be\n        ``int(radius*min(C.shape))``.\n\n    Returns\n    -------\n    D : np.ndarray [shape=(N,M)]\n        accumulated cost matrix.\n        D[N,M] is the total alignment cost.\n        When doing subsequence DTW, D[N,:] indicates a matching function.\n\n    wp : np.ndarray [shape=(N,2)]\n        Warping path with index pairs.\n        Each row of the array contains an index pair n,m).\n        Only returned when ``backtrack`` is True.\n\n    Raises\n    ------\n    ParameterError\n        If you are doing diagonal matching and Y is shorter than X or if an incompatible\n        combination of X, Y, and C are supplied.\n        If your input dimensions are incompatible.\n\n    Examples\n    --------\n    >>> import numpy as np\n    >>> import matplotlib.pyplot as plt\n    >>> y, sr = librosa.load(librosa.util.example_audio_file(), offset=10, duration=15)\n    >>> X = librosa.feature.chroma_cens(y=y, sr=sr)\n    >>> noise = np.random.rand(X.shape[0], 200)\n    >>> Y = np.concatenate((noise, noise, X, noise), axis=1)\n    >>> D, wp = librosa.sequence.dtw(X, Y, subseq=True)\n    >>> plt.subplot(2, 1, 1)\n    >>> librosa.display.specshow(D, x_axis='frames', y_axis='frames')\n    >>> plt.title('Database excerpt')\n    >>> plt.plot(wp[:, 1], wp[:, 0], label='Optimal path', color='y')\n    >>> plt.legend()\n    >>> plt.subplot(2, 1, 2)\n    >>> plt.plot(D[-1, :] / wp.shape[0])\n    >>> plt.xlim([0, Y.shape[1]])\n    >>> plt.ylim([0, 2])\n    >>> plt.title('Matching cost function')\n    >>> plt.tight_layout()", "id": "f18152:m0"}
{"signature": "def __coord_fft_hz(n, sr=<NUM_LIT>, **_kwargs):", "body": "n_fft = <NUM_LIT:2> * (n - <NUM_LIT:1>)<EOL>basis = core.fft_frequencies(sr=sr, n_fft=n_fft)<EOL>fmax = basis[-<NUM_LIT:1>]<EOL>basis -= <NUM_LIT:0.5> * (basis[<NUM_LIT:1>] - basis[<NUM_LIT:0>])<EOL>basis = np.append(np.maximum(<NUM_LIT:0>, basis), [fmax])<EOL>return basis<EOL>", "docstring": "Get the frequencies for FFT bins", "id": "f18153:m9"}
{"signature": "def __call__(self, x, pos=None):", "body": "_, dmax = self.axis.get_data_interval()<EOL>vmin, vmax = self.axis.get_view_interval()<EOL>if self.lag and x >= dmax * <NUM_LIT:0.5>:<EOL><INDENT>if x > dmax:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>value = np.abs(x - dmax)<EOL>sign = '<STR_LIT:->'<EOL><DEDENT>else:<EOL><INDENT>value = x<EOL>sign = '<STR_LIT>'<EOL><DEDENT>if self.unit == '<STR_LIT:s>':<EOL><INDENT>s = '<STR_LIT>'.format(value)<EOL><DEDENT>elif self.unit == '<STR_LIT>':<EOL><INDENT>s = '<STR_LIT>'.format(value * <NUM_LIT:1000>)<EOL><DEDENT>else:<EOL><INDENT>if vmax - vmin > <NUM_LIT>:<EOL><INDENT>s = '<STR_LIT>'.format(int(value / <NUM_LIT>),<EOL>int(np.mod(value / <NUM_LIT>, <NUM_LIT>)),<EOL>int(np.mod(value, <NUM_LIT>)))<EOL><DEDENT>elif vmax - vmin > <NUM_LIT>:<EOL><INDENT>s = '<STR_LIT>'.format(int(value / <NUM_LIT>),<EOL>int(np.mod(value, <NUM_LIT>)))<EOL><DEDENT>else:<EOL><INDENT>s = '<STR_LIT>'.format(value)<EOL><DEDENT><DEDENT>return '<STR_LIT>'.format(sign, s)<EOL>", "docstring": "Return the time format as pos", "id": "f18153:c0:m1"}
{"signature": "def __check_axes(axes):", "body": "if axes is None:<EOL><INDENT>import matplotlib.pyplot as plt<EOL>axes = plt.gca()<EOL><DEDENT>elif not isinstance(axes, Axes):<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(type(axes)))<EOL><DEDENT>return axes<EOL>", "docstring": "Check if \"axes\" is an instance of an axis object. If not, use `gca`.", "id": "f18153:m6"}
{"signature": "def __set_current_image(ax, img):", "body": "if ax is None:<EOL><INDENT>import matplotlib.pyplot as plt<EOL>plt.sci(img)<EOL><DEDENT>", "docstring": "Helper to set the current image in pyplot mode.\n\n    If the provided `ax` is not `None`, then we assume that the user is using the object API.\n    In this case, the pyplot current image is not set.", "id": "f18153:m4"}
{"signature": "def __coord_tempo(n, sr=<NUM_LIT>, hop_length=<NUM_LIT>, **_kwargs):", "body": "basis = core.tempo_frequencies(n+<NUM_LIT:2>, sr=sr, hop_length=hop_length)[<NUM_LIT:1>:]<EOL>edges = np.arange(<NUM_LIT:1>, n+<NUM_LIT:2>)<EOL>return basis * (edges + <NUM_LIT:0.5>) / edges<EOL>", "docstring": "Tempo coordinates", "id": "f18153:m13"}
{"signature": "def __scale_axes(axes, ax_type, which):", "body": "kwargs = dict()<EOL>if which == '<STR_LIT:x>':<EOL><INDENT>thresh = '<STR_LIT>'<EOL>base = '<STR_LIT>'<EOL>scale = '<STR_LIT>'<EOL>scaler = axes.set_xscale<EOL>limit = axes.set_xlim<EOL><DEDENT>else:<EOL><INDENT>thresh = '<STR_LIT>'<EOL>base = '<STR_LIT>'<EOL>scale = '<STR_LIT>'<EOL>scaler = axes.set_yscale<EOL>limit = axes.set_ylim<EOL><DEDENT>if ax_type == '<STR_LIT>':<EOL><INDENT>mode = '<STR_LIT>'<EOL>kwargs[thresh] = <NUM_LIT><EOL>kwargs[base] = <NUM_LIT:2><EOL><DEDENT>elif ax_type == '<STR_LIT>':<EOL><INDENT>mode = '<STR_LIT>'<EOL>kwargs[base] = <NUM_LIT:2><EOL>kwargs[thresh] = core.note_to_hz('<STR_LIT>')<EOL>kwargs[scale] = <NUM_LIT:0.5><EOL><DEDENT>elif ax_type in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>mode = '<STR_LIT>'<EOL>kwargs[base] = <NUM_LIT:2><EOL><DEDENT>elif ax_type == '<STR_LIT>':<EOL><INDENT>mode = '<STR_LIT>'<EOL>kwargs[base] = <NUM_LIT:2><EOL>limit(<NUM_LIT:16>, <NUM_LIT>)<EOL><DEDENT>else:<EOL><INDENT>return<EOL><DEDENT>scaler(mode, **kwargs)<EOL>", "docstring": "Set the axis scaling", "id": "f18153:m7"}
{"signature": "def waveplot(y, sr=<NUM_LIT>, max_points=<NUM_LIT>, x_axis='<STR_LIT:time>', offset=<NUM_LIT:0.0>,<EOL>max_sr=<NUM_LIT:1000>, ax=None, **kwargs):", "body": "util.valid_audio(y, mono=False)<EOL>if not (isinstance(max_sr, int) and max_sr > <NUM_LIT:0>):<EOL><INDENT>raise ParameterError('<STR_LIT>')<EOL><DEDENT>target_sr = sr<EOL>hop_length = <NUM_LIT:1><EOL>if max_points is not None:<EOL><INDENT>if max_points <= <NUM_LIT:0>:<EOL><INDENT>raise ParameterError('<STR_LIT>')<EOL><DEDENT>if max_points < y.shape[-<NUM_LIT:1>]:<EOL><INDENT>target_sr = min(max_sr, (sr * y.shape[-<NUM_LIT:1>]) // max_points)<EOL><DEDENT>hop_length = sr // target_sr<EOL>if y.ndim == <NUM_LIT:1>:<EOL><INDENT>y = __envelope(y, hop_length)<EOL><DEDENT>else:<EOL><INDENT>y = np.vstack([__envelope(_, hop_length) for _ in y])<EOL><DEDENT><DEDENT>if y.ndim > <NUM_LIT:1>:<EOL><INDENT>y_top = y[<NUM_LIT:0>]<EOL>y_bottom = -y[<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>y_top = y<EOL>y_bottom = -y<EOL><DEDENT>axes = __check_axes(ax)<EOL>kwargs.setdefault('<STR_LIT>', next(axes._get_lines.prop_cycler)['<STR_LIT>'])<EOL>locs = offset + core.frames_to_time(np.arange(len(y_top)),<EOL>sr=sr,<EOL>hop_length=hop_length)<EOL>out = axes.fill_between(locs, y_bottom, y_top, **kwargs)<EOL>axes.set_xlim([locs.min(), locs.max()])<EOL>if x_axis == '<STR_LIT:time>':<EOL><INDENT>axes.xaxis.set_major_formatter(TimeFormatter(lag=False))<EOL>axes.xaxis.set_label_text('<STR_LIT>')<EOL><DEDENT>elif x_axis is None or x_axis in ['<STR_LIT>', '<STR_LIT:none>']:<EOL><INDENT>axes.set_xticks([])<EOL><DEDENT>else:<EOL><INDENT>raise ParameterError('<STR_LIT>'.format(x_axis))<EOL><DEDENT>return out<EOL>", "docstring": "Plot the amplitude envelope of a waveform.\n\n    If `y` is monophonic, a filled curve is drawn between `[-abs(y), abs(y)]`.\n\n    If `y` is stereo, the curve is drawn between `[-abs(y[1]), abs(y[0])]`,\n    so that the left and right channels are drawn above and below the axis,\n    respectively.\n\n    Long signals (`duration >= max_points`) are down-sampled to at\n    most `max_sr` before plotting.\n\n    Parameters\n    ----------\n    y : np.ndarray [shape=(n,) or (2,n)]\n        audio time series (mono or stereo)\n\n    sr : number > 0 [scalar]\n        sampling rate of `y`\n\n    max_points : postive number or None\n        Maximum number of time-points to plot: if `max_points` exceeds\n        the duration of `y`, then `y` is downsampled.\n\n        If `None`, no downsampling is performed.\n\n    x_axis : str {'time', 'off', 'none'} or None\n        If 'time', the x-axis is given time tick-marks.\n\n    ax : matplotlib.axes.Axes or None\n        Axes to plot on instead of the default `plt.gca()`.\n\n    offset : float\n        Horizontal offset (in seconds) to start the waveform plot\n\n    max_sr : number > 0 [scalar]\n        Maximum sampling rate for the visualization\n\n    kwargs\n        Additional keyword arguments to `matplotlib.pyplot.fill_between`\n\n    Returns\n    -------\n    pc : matplotlib.collections.PolyCollection\n        The PolyCollection created by `fill_between`.\n\n    See also\n    --------\n    librosa.core.resample\n    matplotlib.pyplot.fill_between\n\n\n    Examples\n    --------\n    Plot a monophonic waveform\n\n    >>> import matplotlib.pyplot as plt\n    >>> y, sr = librosa.load(librosa.util.example_audio_file(), duration=10)\n    >>> plt.figure()\n    >>> plt.subplot(3, 1, 1)\n    >>> librosa.display.waveplot(y, sr=sr)\n    >>> plt.title('Monophonic')\n\n    Or a stereo waveform\n\n    >>> y, sr = librosa.load(librosa.util.example_audio_file(),\n    ...                      mono=False, duration=10)\n    >>> plt.subplot(3, 1, 2)\n    >>> librosa.display.waveplot(y, sr=sr)\n    >>> plt.title('Stereo')\n\n    Or harmonic and percussive components with transparency\n\n    >>> y, sr = librosa.load(librosa.util.example_audio_file(), duration=10)\n    >>> y_harm, y_perc = librosa.effects.hpss(y)\n    >>> plt.subplot(3, 1, 3)\n    >>> librosa.display.waveplot(y_harm, sr=sr, alpha=0.25)\n    >>> librosa.display.waveplot(y_perc, sr=sr, color='r', alpha=0.5)\n    >>> plt.title('Harmonic + Percussive')\n    >>> plt.tight_layout()", "id": "f18153:m2"}
{"signature": "def lpc(y, order):", "body": "if not isinstance(order, int) or order < <NUM_LIT:1>:<EOL><INDENT>raise ParameterError(\"<STR_LIT>\")<EOL><DEDENT>util.valid_audio(y, mono=True)<EOL>return __lpc(y, order)<EOL>", "docstring": "Linear Prediction Coefficients via Burg's method\n\n    This function applies Burg's method to estimate coefficients of a linear\n    filter on `y` of order `order`.  Burg's method is an extension to the\n    Yule-Walker approach, which are both sometimes referred to as LPC parameter\n    estimation by autocorrelation.\n\n    It follows the description and implementation approach described in the\n    introduction in [1]_.  N.B. This paper describes a different method, which\n    is not implemented here, but has been chosen for its clear explanation of\n    Burg's technique in its introduction.\n\n    .. [1] Larry Marple\n           A New Autoregressive Spectrum Analysis Algorithm\n           IEEE Transactions on Accoustics, Speech, and Signal Processing\n           vol 28, no. 4, 1980\n\n    Parameters\n    ----------\n    y : np.ndarray\n        Time series to fit\n\n    order : int > 0\n        Order of the linear filter\n\n    Returns\n    -------\n    a : np.ndarray of length order + 1\n        LP prediction error coefficients, i.e. filter denominator polynomial\n\n    Raises\n    ------\n    ParameterError\n        - If y is not valid audio as per `util.valid_audio`\n        - If order < 1 or not integer\n    FloatingPointError\n        - If y is ill-conditioned\n\n    See also\n    --------\n    scipy.signal.lfilter\n\n    Examples\n    --------\n    Compute LP coefficients of y at order 16 on entire series\n\n    >>> y, sr = librosa.load(librosa.util.example_audio_file(), offset=30,\n    ...                      duration=10)\n    >>> librosa.lpc(y, 16)\n\n    Compute LP coefficients, and plot LP estimate of original series\n\n    >>> import matplotlib.pyplot as plt\n    >>> import scipy\n    >>> y, sr = librosa.load(librosa.util.example_audio_file(), offset=30,\n    ...                      duration=0.020)\n    >>> a = librosa.lpc(y, 2)\n    >>> y_hat = scipy.signal.lfilter([0] + -1*a[1:], [1], y)\n    >>> plt.figure()\n    >>> plt.plot(y)\n    >>> plt.plot(y_hat)\n    >>> plt.legend(['y', 'y_hat'])\n    >>> plt.title('LP Model Forward Prediction')", "id": "f18154:m6"}
{"signature": "def clicks(times=None, frames=None, sr=<NUM_LIT>, hop_length=<NUM_LIT>,<EOL>click_freq=<NUM_LIT>, click_duration=<NUM_LIT:0.1>, click=None, length=None):", "body": "<EOL>if times is None:<EOL><INDENT>if frames is None:<EOL><INDENT>raise ParameterError('<STR_LIT>')<EOL><DEDENT>positions = frames_to_samples(frames, hop_length=hop_length)<EOL><DEDENT>else:<EOL><INDENT>positions = time_to_samples(times, sr=sr)<EOL><DEDENT>if click is not None:<EOL><INDENT>util.valid_audio(click, mono=True)<EOL><DEDENT>else:<EOL><INDENT>if click_duration <= <NUM_LIT:0>:<EOL><INDENT>raise ParameterError('<STR_LIT>')<EOL><DEDENT>if click_freq <= <NUM_LIT:0>:<EOL><INDENT>raise ParameterError('<STR_LIT>')<EOL><DEDENT>angular_freq = <NUM_LIT:2> * np.pi * click_freq / float(sr)<EOL>click = np.logspace(<NUM_LIT:0>, -<NUM_LIT:10>,<EOL>num=int(np.round(sr * click_duration)),<EOL>base=<NUM_LIT>)<EOL>click *= np.sin(angular_freq * np.arange(len(click)))<EOL><DEDENT>if length is None:<EOL><INDENT>length = positions.max() + click.shape[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>if length < <NUM_LIT:1>:<EOL><INDENT>raise ParameterError('<STR_LIT>')<EOL><DEDENT>positions = positions[positions < length]<EOL><DEDENT>click_signal = np.zeros(length, dtype=np.float32)<EOL>for start in positions:<EOL><INDENT>end = start + click.shape[<NUM_LIT:0>]<EOL>if end >= length:<EOL><INDENT>click_signal[start:] += click[:length - start]<EOL><DEDENT>else:<EOL><INDENT>click_signal[start:end] += click<EOL><DEDENT><DEDENT>return click_signal<EOL>", "docstring": "Returns a signal with the signal `click` placed at each specified time\n\n    Parameters\n    ----------\n    times : np.ndarray or None\n        times to place clicks, in seconds\n\n    frames : np.ndarray or None\n        frame indices to place clicks\n\n    sr : number > 0\n        desired sampling rate of the output signal\n\n    hop_length : int > 0\n        if positions are specified by `frames`, the number of samples between frames.\n\n    click_freq : float > 0\n        frequency (in Hz) of the default click signal.  Default is 1KHz.\n\n    click_duration : float > 0\n        duration (in seconds) of the default click signal.  Default is 100ms.\n\n    click : np.ndarray or None\n        optional click signal sample to use instead of the default blip.\n\n    length : int > 0\n        desired number of samples in the output signal\n\n\n    Returns\n    -------\n    click_signal : np.ndarray\n        Synthesized click signal\n\n\n    Raises\n    ------\n    ParameterError\n        - If neither `times` nor `frames` are provided.\n        - If any of `click_freq`, `click_duration`, or `length` are out of range.\n\n\n    Examples\n    --------\n    >>> # Sonify detected beat events\n    >>> y, sr = librosa.load(librosa.util.example_audio_file())\n    >>> tempo, beats = librosa.beat.beat_track(y=y, sr=sr)\n    >>> y_beats = librosa.clicks(frames=beats, sr=sr)\n\n    >>> # Or generate a signal of the same length as y\n    >>> y_beats = librosa.clicks(frames=beats, sr=sr, length=len(y))\n\n    >>> # Or use timing instead of frame indices\n    >>> times = librosa.frames_to_time(beats, sr=sr)\n    >>> y_beat_times = librosa.clicks(times=times, sr=sr)\n\n    >>> # Or with a click frequency of 880Hz and a 500ms sample\n    >>> y_beat_times880 = librosa.clicks(times=times, sr=sr,\n    ...                                  click_freq=880, click_duration=0.5)\n\n    Display click waveform next to the spectrogram\n\n    >>> import matplotlib.pyplot as plt\n    >>> plt.figure()\n    >>> S = librosa.feature.melspectrogram(y=y, sr=sr)\n    >>> ax = plt.subplot(2,1,2)\n    >>> librosa.display.specshow(librosa.power_to_db(S, ref=np.max),\n    ...                          x_axis='time', y_axis='mel')\n    >>> plt.subplot(2,1,1, sharex=ax)\n    >>> librosa.display.waveplot(y_beat_times, sr=sr, label='Beat clicks')\n    >>> plt.legend()\n    >>> plt.xlim(15, 30)\n    >>> plt.tight_layout()", "id": "f18154:m9"}
{"signature": "@cache(level=<NUM_LIT:20>)<EOL>def zero_crossings(y, threshold=<NUM_LIT>, ref_magnitude=None, pad=True,<EOL>zero_pos=True, axis=-<NUM_LIT:1>):", "body": "<EOL>if threshold is None:<EOL><INDENT>threshold = <NUM_LIT:0.0><EOL><DEDENT>if six.callable(ref_magnitude):<EOL><INDENT>threshold = threshold * ref_magnitude(np.abs(y))<EOL><DEDENT>elif ref_magnitude is not None:<EOL><INDENT>threshold = threshold * ref_magnitude<EOL><DEDENT>if threshold > <NUM_LIT:0>:<EOL><INDENT>y = y.copy()<EOL>y[np.abs(y) <= threshold] = <NUM_LIT:0><EOL><DEDENT>if zero_pos:<EOL><INDENT>y_sign = np.signbit(y)<EOL><DEDENT>else:<EOL><INDENT>y_sign = np.sign(y)<EOL><DEDENT>slice_pre = [slice(None)] * y.ndim<EOL>slice_pre[axis] = slice(<NUM_LIT:1>, None)<EOL>slice_post = [slice(None)] * y.ndim<EOL>slice_post[axis] = slice(-<NUM_LIT:1>)<EOL>padding = [(<NUM_LIT:0>, <NUM_LIT:0>)] * y.ndim<EOL>padding[axis] = (<NUM_LIT:1>, <NUM_LIT:0>)<EOL>return np.pad((y_sign[tuple(slice_post)] != y_sign[tuple(slice_pre)]),<EOL>padding,<EOL>mode='<STR_LIT>',<EOL>constant_values=pad)<EOL>", "docstring": "Find the zero-crossings of a signal `y`: indices `i` such that\n    `sign(y[i]) != sign(y[j])`.\n\n    If `y` is multi-dimensional, then zero-crossings are computed along\n    the specified `axis`.\n\n\n    Parameters\n    ----------\n    y : np.ndarray\n        The input array\n\n    threshold : float > 0 or None\n        If specified, values where `-threshold <= y <= threshold` are\n        clipped to 0.\n\n    ref_magnitude : float > 0 or callable\n        If numeric, the threshold is scaled relative to `ref_magnitude`.\n\n        If callable, the threshold is scaled relative to\n        `ref_magnitude(np.abs(y))`.\n\n    pad : boolean\n        If `True`, then `y[0]` is considered a valid zero-crossing.\n\n    zero_pos : boolean\n        If `True` then the value 0 is interpreted as having positive sign.\n\n        If `False`, then 0, -1, and +1 all have distinct signs.\n\n    axis : int\n        Axis along which to compute zero-crossings.\n\n    Returns\n    -------\n    zero_crossings : np.ndarray [shape=y.shape, dtype=boolean]\n        Indicator array of zero-crossings in `y` along the selected axis.\n\n    Notes\n    -----\n    This function caches at level 20.\n\n    Examples\n    --------\n    >>> # Generate a time-series\n    >>> y = np.sin(np.linspace(0, 4 * 2 * np.pi, 20))\n    >>> y\n    array([  0.000e+00,   9.694e-01,   4.759e-01,  -7.357e-01,\n            -8.372e-01,   3.247e-01,   9.966e-01,   1.646e-01,\n            -9.158e-01,  -6.142e-01,   6.142e-01,   9.158e-01,\n            -1.646e-01,  -9.966e-01,  -3.247e-01,   8.372e-01,\n             7.357e-01,  -4.759e-01,  -9.694e-01,  -9.797e-16])\n    >>> # Compute zero-crossings\n    >>> z = librosa.zero_crossings(y)\n    >>> z\n    array([ True, False, False,  True, False,  True, False, False,\n            True, False,  True, False,  True, False, False,  True,\n           False,  True, False,  True], dtype=bool)\n    >>> # Stack y against the zero-crossing indicator\n    >>> np.vstack([y, z]).T\n    array([[  0.000e+00,   1.000e+00],\n           [  9.694e-01,   0.000e+00],\n           [  4.759e-01,   0.000e+00],\n           [ -7.357e-01,   1.000e+00],\n           [ -8.372e-01,   0.000e+00],\n           [  3.247e-01,   1.000e+00],\n           [  9.966e-01,   0.000e+00],\n           [  1.646e-01,   0.000e+00],\n           [ -9.158e-01,   1.000e+00],\n           [ -6.142e-01,   0.000e+00],\n           [  6.142e-01,   1.000e+00],\n           [  9.158e-01,   0.000e+00],\n           [ -1.646e-01,   1.000e+00],\n           [ -9.966e-01,   0.000e+00],\n           [ -3.247e-01,   0.000e+00],\n           [  8.372e-01,   1.000e+00],\n           [  7.357e-01,   0.000e+00],\n           [ -4.759e-01,   1.000e+00],\n           [ -9.694e-01,   0.000e+00],\n           [ -9.797e-16,   1.000e+00]])\n    >>> # Find the indices of zero-crossings\n    >>> np.nonzero(z)\n    (array([ 0,  3,  5,  8, 10, 12, 15, 17, 19]),)", "id": "f18154:m8"}
{"signature": "def __audioread_load(path, offset, duration, dtype):", "body": "y = []<EOL>with audioread.audio_open(path) as input_file:<EOL><INDENT>sr_native = input_file.samplerate<EOL>n_channels = input_file.channels<EOL>s_start = int(np.round(sr_native * offset)) * n_channels<EOL>if duration is None:<EOL><INDENT>s_end = np.inf<EOL><DEDENT>else:<EOL><INDENT>s_end = s_start + (int(np.round(sr_native * duration))<EOL>* n_channels)<EOL><DEDENT>n = <NUM_LIT:0><EOL>for frame in input_file:<EOL><INDENT>frame = util.buf_to_float(frame, dtype=dtype)<EOL>n_prev = n<EOL>n = n + len(frame)<EOL>if n < s_start:<EOL><INDENT>continue<EOL><DEDENT>if s_end < n_prev:<EOL><INDENT>break<EOL><DEDENT>if s_end < n:<EOL><INDENT>frame = frame[:s_end - n_prev]<EOL><DEDENT>if n_prev <= s_start <= n:<EOL><INDENT>frame = frame[(s_start - n_prev):]<EOL><DEDENT>y.append(frame)<EOL><DEDENT><DEDENT>if y:<EOL><INDENT>y = np.concatenate(y)<EOL>if n_channels > <NUM_LIT:1>:<EOL><INDENT>y = y.reshape((-<NUM_LIT:1>, n_channels)).T<EOL><DEDENT><DEDENT>else:<EOL><INDENT>y = np.empty(<NUM_LIT:0>, dtype=dtype)<EOL><DEDENT>return y, sr_native<EOL>", "docstring": "Load an audio buffer using audioread.\n\n    This loads one block at a time, and then concatenates the results.", "id": "f18154:m1"}
{"signature": "def chirp(fmin, fmax, sr=<NUM_LIT>, length=None, duration=None, linear=False, phi=None):", "body": "if fmin is None or fmax is None:<EOL><INDENT>raise ParameterError('<STR_LIT>')<EOL><DEDENT>period = <NUM_LIT:1.0> / sr<EOL>if length is None:<EOL><INDENT>if duration is None:<EOL><INDENT>raise ParameterError('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>duration = period * length<EOL><DEDENT>if phi is None:<EOL><INDENT>phi = -np.pi * <NUM_LIT:0.5><EOL><DEDENT>method = '<STR_LIT>' if linear else '<STR_LIT>'<EOL>return scipy.signal.chirp(<EOL>np.arange(duration, step=period),<EOL>fmin,<EOL>duration,<EOL>fmax,<EOL>method=method,<EOL>phi=phi / np.pi * <NUM_LIT>,  <EOL>)<EOL>", "docstring": "Returns a chirp signal that goes from frequency `fmin` to frequency `fmax`\n\n    Parameters\n    ----------\n    fmin : float > 0\n        initial frequency\n\n    fmax : float > 0\n        final frequency\n\n    sr : number > 0\n        desired sampling rate of the output signal\n\n    length : int > 0\n        desired number of samples in the output signal.\n        When both `duration` and `length` are defined, `length` would take priority.\n\n    duration : float > 0\n        desired duration in seconds.\n        When both `duration` and `length` are defined, `length` would take priority.\n\n    linear : boolean\n        - If `True`, use a linear sweep, i.e., frequency changes linearly with time\n        - If `False`, use a exponential sweep.\n        Default is `False`.\n\n    phi : float or None\n        phase offset, in radians.\n        If unspecified, defaults to `-np.pi * 0.5`.\n\n\n    Returns\n    -------\n    chirp_signal : np.ndarray [shape=(length,), dtype=float64]\n        Synthesized chirp signal\n\n\n    Raises\n    ------\n    ParameterError\n        - If either `fmin` or `fmax` are not provided.\n        - If neither `length` nor `duration` are provided.\n\n\n    See Also\n    --------\n    scipy.signal.chirp\n\n\n    Examples\n    --------\n    >>> # Generate a exponential chirp from A4 to A5\n    >>> exponential_chirp = librosa.chirp(440, 880, duration=1)\n\n    >>> # Or generate the same signal using `length`\n    >>> exponential_chirp = librosa.chirp(440, 880, sr=22050, length=22050)\n\n    >>> # Or generate a linear chirp instead\n    >>> linear_chirp = librosa.chirp(440, 880, duration=1, linear=True)\n\n    Display spectrogram for both exponential and linear chirps\n\n    >>> import matplotlib.pyplot as plt\n    >>> plt.figure()\n    >>> S_exponential = librosa.feature.melspectrogram(y=exponential_chirp)\n    >>> ax = plt.subplot(2,1,1)\n    >>> librosa.display.specshow(librosa.power_to_db(S_exponential, ref=np.max),\n    ...                          x_axis='time', y_axis='mel')\n    >>> plt.subplot(2,1,2, sharex=ax)\n    >>> S_linear = librosa.feature.melspectrogram(y=linear_chirp)\n    >>> librosa.display.specshow(librosa.power_to_db(S_linear, ref=np.max),\n    ...                          x_axis='time', y_axis='mel')\n    >>> plt.tight_layout()", "id": "f18154:m11"}
{"signature": "@cache(level=<NUM_LIT:20>)<EOL>def to_mono(y):", "body": "<EOL>util.valid_audio(y, mono=False)<EOL>if y.ndim > <NUM_LIT:1>:<EOL><INDENT>y = np.mean(y, axis=<NUM_LIT:0>)<EOL><DEDENT>return y<EOL>", "docstring": "Force an audio signal down to mono.\n\n    Parameters\n    ----------\n    y : np.ndarray [shape=(2,n) or shape=(n,)]\n        audio time series, either stereo or mono\n\n    Returns\n    -------\n    y_mono : np.ndarray [shape=(n,)]\n        `y` as a monophonic time-series\n\n    Notes\n    -----\n    This function caches at level 20.\n\n    Examples\n    --------\n    >>> y, sr = librosa.load(librosa.util.example_audio_file(), mono=False)\n    >>> y.shape\n    (2, 1355168)\n    >>> y_mono = librosa.to_mono(y)\n    >>> y_mono.shape\n    (1355168,)", "id": "f18154:m2"}
{"signature": "def interp_harmonics(x, freqs, h_range, kind='<STR_LIT>', fill_value=<NUM_LIT:0>, axis=<NUM_LIT:0>):", "body": "<EOL>out_shape = [len(h_range)]<EOL>out_shape.extend(x.shape)<EOL>x_out = np.zeros(out_shape, dtype=x.dtype)<EOL>if freqs.ndim == <NUM_LIT:1> and len(freqs) == x.shape[axis]:<EOL><INDENT>harmonics_1d(x_out, x, freqs, h_range,<EOL>kind=kind, fill_value=fill_value,<EOL>axis=axis)<EOL><DEDENT>elif freqs.ndim == <NUM_LIT:2> and freqs.shape == x.shape:<EOL><INDENT>harmonics_2d(x_out, x, freqs, h_range,<EOL>kind=kind, fill_value=fill_value,<EOL>axis=axis)<EOL><DEDENT>else:<EOL><INDENT>raise ParameterError('<STR_LIT>'<EOL>'<STR_LIT>'.format(freqs.shape, x.shape))<EOL><DEDENT>return x_out<EOL>", "docstring": "Compute the energy at harmonics of time-frequency representation.\n\n    Given a frequency-based energy representation such as a spectrogram\n    or tempogram, this function computes the energy at the chosen harmonics\n    of the frequency axis.  (See examples below.)\n    The resulting harmonic array can then be used as input to a salience\n    computation.\n\n    Parameters\n    ----------\n    x : np.ndarray\n        The input energy\n\n    freqs : np.ndarray, shape=(X.shape[axis])\n        The frequency values corresponding to X's elements along the\n        chosen axis.\n\n    h_range : list-like, non-negative\n        Harmonics to compute.  The first harmonic (1) corresponds to `x`\n        itself.\n        Values less than one (e.g., 1/2) correspond to sub-harmonics.\n\n    kind : str\n        Interpolation type.  See `scipy.interpolate.interp1d`.\n\n    fill_value : float\n        The value to fill when extrapolating beyond the observed\n        frequency range.\n\n    axis : int\n        The axis along which to compute harmonics\n\n    Returns\n    -------\n    x_harm : np.ndarray, shape=(len(h_range), [x.shape])\n        `x_harm[i]` will have the same shape as `x`, and measure\n        the energy at the `h_range[i]` harmonic of each frequency.\n\n    See Also\n    --------\n    scipy.interpolate.interp1d\n\n\n    Examples\n    --------\n    Estimate the harmonics of a time-averaged tempogram\n\n    >>> y, sr = librosa.load(librosa.util.example_audio_file(),\n    ...                      duration=15, offset=30)\n    >>> # Compute the time-varying tempogram and average over time\n    >>> tempi = np.mean(librosa.feature.tempogram(y=y, sr=sr), axis=1)\n    >>> # We'll measure the first five harmonics\n    >>> h_range = [1, 2, 3, 4, 5]\n    >>> f_tempo = librosa.tempo_frequencies(len(tempi), sr=sr)\n    >>> # Build the harmonic tensor\n    >>> t_harmonics = librosa.interp_harmonics(tempi, f_tempo, h_range)\n    >>> print(t_harmonics.shape)\n    (5, 384)\n\n    >>> # And plot the results\n    >>> import matplotlib.pyplot as plt\n    >>> plt.figure()\n    >>> librosa.display.specshow(t_harmonics, x_axis='tempo', sr=sr)\n    >>> plt.yticks(0.5 + np.arange(len(h_range)),\n    ...            ['{:.3g}'.format(_) for _ in h_range])\n    >>> plt.ylabel('Harmonic')\n    >>> plt.xlabel('Tempo (BPM)')\n    >>> plt.tight_layout()\n\n    We can also compute frequency harmonics for spectrograms.\n    To calculate sub-harmonic energy, use values < 1.\n\n    >>> h_range = [1./3, 1./2, 1, 2, 3, 4]\n    >>> S = np.abs(librosa.stft(y))\n    >>> fft_freqs = librosa.fft_frequencies(sr=sr)\n    >>> S_harm = librosa.interp_harmonics(S, fft_freqs, h_range, axis=0)\n    >>> print(S_harm.shape)\n    (6, 1025, 646)\n\n    >>> plt.figure()\n    >>> for i, _sh in enumerate(S_harm, 1):\n    ...     plt.subplot(3, 2, i)\n    ...     librosa.display.specshow(librosa.amplitude_to_db(_sh,\n    ...                                                      ref=S.max()),\n    ...                              sr=sr, y_axis='log')\n    ...     plt.title('h={:.3g}'.format(h_range[i-1]))\n    ...     plt.yticks([])\n    >>> plt.tight_layout()", "id": "f18155:m1"}
{"signature": "def harmonics_1d(harmonic_out, x, freqs, h_range, kind='<STR_LIT>',<EOL>fill_value=<NUM_LIT:0>, axis=<NUM_LIT:0>):", "body": "<EOL>f_interp = scipy.interpolate.interp1d(freqs, x,<EOL>kind=kind,<EOL>axis=axis,<EOL>copy=False,<EOL>bounds_error=False,<EOL>fill_value=fill_value)<EOL>idx_out = [slice(None)] * harmonic_out.ndim<EOL>interp_axis = <NUM_LIT:1> + (axis % x.ndim)<EOL>for h_index, harmonic in enumerate(h_range):<EOL><INDENT>idx_out[<NUM_LIT:0>] = h_index<EOL>for f_index, frequency in enumerate(freqs):<EOL><INDENT>idx_out[interp_axis] = f_index<EOL>harmonic_out[tuple(idx_out)] = f_interp(harmonic * frequency)<EOL><DEDENT><DEDENT>", "docstring": "Populate a harmonic tensor from a time-frequency representation.\n\n    Parameters\n    ----------\n    harmonic_out : np.ndarray, shape=(len(h_range), X.shape)\n        The output array to store harmonics\n\n    X : np.ndarray\n        The input energy\n\n    freqs : np.ndarray, shape=(x.shape[axis])\n        The frequency values corresponding to x's elements along the\n        chosen axis.\n\n    h_range : list-like, non-negative\n        Harmonics to compute.  The first harmonic (1) corresponds to `x`\n        itself.\n        Values less than one (e.g., 1/2) correspond to sub-harmonics.\n\n    kind : str\n        Interpolation type.  See `scipy.interpolate.interp1d`.\n\n    fill_value : float\n        The value to fill when extrapolating beyond the observed\n        frequency range.\n\n    axis : int\n        The axis along which to compute harmonics\n\n    See Also\n    --------\n    harmonics\n    scipy.interpolate.interp1d\n\n\n    Examples\n    --------\n    Estimate the harmonics of a time-averaged tempogram\n\n    >>> y, sr = librosa.load(librosa.util.example_audio_file(),\n    ...                      duration=15, offset=30)\n    >>> # Compute the time-varying tempogram and average over time\n    >>> tempi = np.mean(librosa.feature.tempogram(y=y, sr=sr), axis=1)\n    >>> # We'll measure the first five harmonics\n    >>> h_range = [1, 2, 3, 4, 5]\n    >>> f_tempo = librosa.tempo_frequencies(len(tempi), sr=sr)\n    >>> # Build the harmonic tensor\n    >>> t_harmonics = librosa.interp_harmonics(tempi, f_tempo, h_range)\n    >>> print(t_harmonics.shape)\n    (5, 384)\n\n    >>> # And plot the results\n    >>> import matplotlib.pyplot as plt\n    >>> plt.figure()\n    >>> librosa.display.specshow(t_harmonics, x_axis='tempo', sr=sr)\n    >>> plt.yticks(0.5 + np.arange(len(h_range)),\n    ...            ['{:.3g}'.format(_) for _ in h_range])\n    >>> plt.ylabel('Harmonic')\n    >>> plt.xlabel('Tempo (BPM)')\n    >>> plt.tight_layout()\n\n    We can also compute frequency harmonics for spectrograms.\n    To calculate subharmonic energy, use values < 1.\n\n    >>> h_range = [1./3, 1./2, 1, 2, 3, 4]\n    >>> S = np.abs(librosa.stft(y))\n    >>> fft_freqs = librosa.fft_frequencies(sr=sr)\n    >>> S_harm = librosa.interp_harmonics(S, fft_freqs, h_range, axis=0)\n    >>> print(S_harm.shape)\n    (6, 1025, 646)\n\n    >>> plt.figure()\n    >>> for i, _sh in enumerate(S_harm, 1):\n    ...     plt.subplot(3,2,i)\n    ...     librosa.display.specshow(librosa.amplitude_to_db(_sh,\n    ...                                                      ref=S.max()),\n    ...                              sr=sr, y_axis='log')\n    ...     plt.title('h={:.3g}'.format(h_range[i-1]))\n    ...     plt.yticks([])\n    >>> plt.tight_layout()", "id": "f18155:m2"}
{"signature": "@cache(level=<NUM_LIT:20>)<EOL>def pseudo_cqt(y, sr=<NUM_LIT>, hop_length=<NUM_LIT>, fmin=None, n_bins=<NUM_LIT>,<EOL>bins_per_octave=<NUM_LIT:12>, tuning=<NUM_LIT:0.0>, filter_scale=<NUM_LIT:1>,<EOL>norm=<NUM_LIT:1>, sparsity=<NUM_LIT>, window='<STR_LIT>', scale=True,<EOL>pad_mode='<STR_LIT>'):", "body": "if fmin is None:<EOL><INDENT>fmin = note_to_hz('<STR_LIT>')<EOL><DEDENT>if tuning is None:<EOL><INDENT>tuning = estimate_tuning(y=y, sr=sr)<EOL><DEDENT>fft_basis, n_fft, _ = __cqt_filter_fft(sr, fmin, n_bins,<EOL>bins_per_octave,<EOL>tuning, filter_scale,<EOL>norm, sparsity,<EOL>hop_length=hop_length,<EOL>window=window)<EOL>fft_basis = np.abs(fft_basis)<EOL>D = np.abs(stft(y, n_fft=n_fft, hop_length=hop_length, pad_mode=pad_mode))<EOL>C = fft_basis.dot(D)<EOL>if scale:<EOL><INDENT>C /= np.sqrt(n_fft)<EOL><DEDENT>else:<EOL><INDENT>lengths = filters.constant_q_lengths(sr, fmin,<EOL>n_bins=n_bins,<EOL>bins_per_octave=bins_per_octave,<EOL>tuning=tuning,<EOL>window=window,<EOL>filter_scale=filter_scale)<EOL>C *= np.sqrt(lengths[:, np.newaxis] / n_fft)<EOL><DEDENT>return C<EOL>", "docstring": "Compute the pseudo constant-Q transform of an audio signal.\n\n    This uses a single fft size that is the smallest power of 2 that is greater\n    than or equal to the max of:\n\n        1. The longest CQT filter\n        2. 2x the hop_length\n\n    Parameters\n    ----------\n    y : np.ndarray [shape=(n,)]\n        audio time series\n\n    sr : number > 0 [scalar]\n        sampling rate of `y`\n\n    hop_length : int > 0 [scalar]\n        number of samples between successive CQT columns.\n\n    fmin : float > 0 [scalar]\n        Minimum frequency. Defaults to C1 ~= 32.70 Hz\n\n    n_bins : int > 0 [scalar]\n        Number of frequency bins, starting at `fmin`\n\n    bins_per_octave : int > 0 [scalar]\n        Number of bins per octave\n\n    tuning : None or float in `[-0.5, 0.5)`\n        Tuning offset in fractions of a bin (cents).\n\n        If `None`, tuning will be automatically estimated from the signal.\n\n    filter_scale : float > 0\n        Filter filter_scale factor. Larger values use longer windows.\n\n    sparsity : float in [0, 1)\n        Sparsify the CQT basis by discarding up to `sparsity`\n        fraction of the energy in each basis.\n\n        Set `sparsity=0` to disable sparsification.\n\n    window : str, tuple, number, or function\n        Window specification for the basis filters.\n        See `filters.get_window` for details.\n\n    pad_mode : string\n        Padding mode for centered frame analysis.\n\n        See also: `librosa.core.stft` and `np.pad`.\n\n    Returns\n    -------\n    CQT : np.ndarray [shape=(n_bins, t), dtype=np.float]\n        Pseudo Constant-Q energy for each frequency at each time.\n\n    Raises\n    ------\n    ParameterError\n        If `hop_length` is not an integer multiple of\n        `2**(n_bins / bins_per_octave)`\n\n        Or if `y` is too short to support the frequency range of the CQT.\n\n    Notes\n    -----\n    This function caches at level 20.", "id": "f18156:m2"}
{"signature": "def __cqt_response(y, n_fft, hop_length, fft_basis, mode):", "body": "<EOL>D = stft(y, n_fft=n_fft, hop_length=hop_length,<EOL>window='<STR_LIT>',<EOL>pad_mode=mode)<EOL>return fft_basis.dot(D)<EOL>", "docstring": "Compute the filter response with a target STFT hop.", "id": "f18156:m6"}
{"signature": "@jit(nopython=True, cache=True)<EOL>def __num_two_factors(x):", "body": "if x <= <NUM_LIT:0>:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>num_twos = <NUM_LIT:0><EOL>while x % <NUM_LIT:2> == <NUM_LIT:0>:<EOL><INDENT>num_twos += <NUM_LIT:1><EOL>x //= <NUM_LIT:2><EOL><DEDENT>return num_twos<EOL>", "docstring": "Return how many times integer x can be evenly divided by 2.\n\n    Returns 0 for non-positive integers.", "id": "f18156:m9"}
{"signature": "def times_like(X, sr=<NUM_LIT>, hop_length=<NUM_LIT>, n_fft=None, axis=-<NUM_LIT:1>):", "body": "samples = samples_like(X, hop_length=hop_length, n_fft=n_fft, axis=axis)<EOL>return samples_to_time(samples, sr=sr)<EOL>", "docstring": "Return an array of time values to match the time axis from a feature matrix.\n\n    Parameters\n    ----------\n    X : np.ndarray or scalar\n        - If ndarray, X is a feature matrix, e.g. STFT, chromagram, or mel spectrogram.\n        - If scalar, X represents the number of frames.\n\n    sr : number > 0 [scalar]\n        audio sampling rate\n\n    hop_length : int > 0 [scalar]\n        number of samples between successive frames\n\n    n_fft : None or int > 0 [scalar]\n        Optional: length of the FFT window.\n        If given, time conversion will include an offset of `n_fft / 2`\n        to counteract windowing effects when using a non-centered STFT.\n\n    axis : int [scalar]\n        The axis representing the time axis of X.\n        By default, the last axis (-1) is taken.\n\n    Returns\n    -------\n    times : np.ndarray [shape=(n,)]\n        ndarray of times (in seconds) corresponding to each frame of X.\n\n    See Also\n    --------\n    samples_like : Return an array of sample indices to match the time axis from a feature matrix.\n\n    Examples\n    --------\n    Provide a feature matrix input:\n\n    >>> y, sr = librosa.load(librosa.util.example_audio_file())\n    >>> X = librosa.stft(y)\n    >>> times = librosa.times_like(X)\n    >>> times\n    array([  0.00000000e+00,   2.32199546e-02,   4.64399093e-02, ...,\n             6.13935601e+01,   6.14167800e+01,   6.14400000e+01])\n\n    Provide a scalar input:\n\n    >>> n_frames = 2647\n    >>> times = librosa.times_like(n_frames)\n    >>> times\n    array([  0.00000000e+00,   2.32199546e-02,   4.64399093e-02, ...,\n             6.13935601e+01,   6.14167800e+01,   6.14400000e+01])", "id": "f18158:m21"}
{"signature": "def midi_to_hz(notes):", "body": "return <NUM_LIT> * (<NUM_LIT> ** ((np.asanyarray(notes) - <NUM_LIT>)/<NUM_LIT>))<EOL>", "docstring": "Get the frequency (Hz) of MIDI note(s)\n\n    Examples\n    --------\n    >>> librosa.midi_to_hz(36)\n    65.406\n\n    >>> librosa.midi_to_hz(np.arange(36, 48))\n    array([  65.406,   69.296,   73.416,   77.782,   82.407,\n             87.307,   92.499,   97.999,  103.826,  110.   ,\n            116.541,  123.471])\n\n    Parameters\n    ----------\n    notes       : int or np.ndarray [shape=(n,), dtype=int]\n        midi number(s) of the note(s)\n\n    Returns\n    -------\n    frequency   : number or np.ndarray [shape=(n,), dtype=float]\n        frequency (frequencies) of `notes` in Hz\n\n    See Also\n    --------\n    hz_to_midi\n    note_to_hz", "id": "f18158:m9"}
{"signature": "def frames_to_samples(frames, hop_length=<NUM_LIT>, n_fft=None):", "body": "offset = <NUM_LIT:0><EOL>if n_fft is not None:<EOL><INDENT>offset = int(n_fft // <NUM_LIT:2>)<EOL><DEDENT>return (np.asanyarray(frames) * hop_length + offset).astype(int)<EOL>", "docstring": "Converts frame indices to audio sample indices.\n\n    Parameters\n    ----------\n    frames     : number or np.ndarray [shape=(n,)]\n        frame index or vector of frame indices\n\n    hop_length : int > 0 [scalar]\n        number of samples between successive frames\n\n    n_fft : None or int > 0 [scalar]\n        Optional: length of the FFT window.\n        If given, time conversion will include an offset of `n_fft / 2`\n        to counteract windowing effects when using a non-centered STFT.\n\n    Returns\n    -------\n    times : number or np.ndarray\n        time (in samples) of each given frame number:\n        `times[i] = frames[i] * hop_length`\n\n    See Also\n    --------\n    frames_to_time : convert frame indices to time values\n    samples_to_frames : convert sample indices to frame indices\n\n    Examples\n    --------\n    >>> y, sr = librosa.load(librosa.util.example_audio_file())\n    >>> tempo, beats = librosa.beat.beat_track(y, sr=sr)\n    >>> beat_samples = librosa.frames_to_samples(beats)", "id": "f18158:m0"}
{"signature": "def note_to_hz(note, **kwargs):", "body": "return midi_to_hz(note_to_midi(note, **kwargs))<EOL>", "docstring": "Convert one or more note names to frequency (Hz)\n\n    Examples\n    --------\n    >>> # Get the frequency of a note\n    >>> librosa.note_to_hz('C')\n    array([ 16.352])\n    >>> # Or multiple notes\n    >>> librosa.note_to_hz(['A3', 'A4', 'A5'])\n    array([ 220.,  440.,  880.])\n    >>> # Or notes with tuning deviations\n    >>> librosa.note_to_hz('C2-32', round_midi=False)\n    array([ 64.209])\n\n    Parameters\n    ----------\n    note : str or iterable of str\n        One or more note names to convert\n\n    kwargs : additional keyword arguments\n        Additional parameters to `note_to_midi`\n\n    Returns\n    -------\n    frequencies : number or np.ndarray [shape=(len(note),)]\n        Array of frequencies (in Hz) corresponding to `note`\n\n    See Also\n    --------\n    midi_to_hz\n    note_to_midi\n    hz_to_note", "id": "f18158:m6"}
{"signature": "def octs_to_hz(octs, A440=<NUM_LIT>):", "body": "return (float(A440) / <NUM_LIT:16>)*(<NUM_LIT>**np.asanyarray(octs))<EOL>", "docstring": "Convert octaves numbers to frequencies.\n\n    Octaves are counted relative to A.\n\n    Examples\n    --------\n    >>> librosa.octs_to_hz(1)\n    55.\n    >>> librosa.octs_to_hz([-2, -1, 0, 1, 2])\n    array([   6.875,   13.75 ,   27.5  ,   55.   ,  110.   ])\n\n    Parameters\n    ----------\n    octaves       : np.ndarray [shape=(n,)] or float\n        octave number for each frequency\n    A440          : float\n        frequency of A440\n\n    Returns\n    -------\n    frequencies   : number or np.ndarray [shape=(n,)]\n        scalar or vector of frequencies\n\n    See Also\n    --------\n    hz_to_octs", "id": "f18158:m15"}
{"signature": "def frames_to_time(frames, sr=<NUM_LIT>, hop_length=<NUM_LIT>, n_fft=None):", "body": "samples = frames_to_samples(frames,<EOL>hop_length=hop_length,<EOL>n_fft=n_fft)<EOL>return samples_to_time(samples, sr=sr)<EOL>", "docstring": "Converts frame counts to time (seconds).\n\n    Parameters\n    ----------\n    frames     : np.ndarray [shape=(n,)]\n        frame index or vector of frame indices\n\n    sr         : number > 0 [scalar]\n        audio sampling rate\n\n    hop_length : int > 0 [scalar]\n        number of samples between successive frames\n\n    n_fft : None or int > 0 [scalar]\n        Optional: length of the FFT window.\n        If given, time conversion will include an offset of `n_fft / 2`\n        to counteract windowing effects when using a non-centered STFT.\n\n    Returns\n    -------\n    times : np.ndarray [shape=(n,)]\n        time (in seconds) of each given frame number:\n        `times[i] = frames[i] * hop_length / sr`\n\n    See Also\n    --------\n    time_to_frames : convert time values to frame indices\n    frames_to_samples : convert frame indices to sample indices\n\n    Examples\n    --------\n    >>> y, sr = librosa.load(librosa.util.example_audio_file())\n    >>> tempo, beats = librosa.beat.beat_track(y, sr=sr)\n    >>> beat_times = librosa.frames_to_time(beats, sr=sr)", "id": "f18158:m2"}
{"signature": "def time_to_samples(times, sr=<NUM_LIT>):", "body": "return (np.asanyarray(times) * sr).astype(int)<EOL>", "docstring": "Convert timestamps (in seconds) to sample indices.\n\n    Parameters\n    ----------\n    times : number or np.ndarray\n        Time value or array of time values (in seconds)\n\n    sr : number > 0\n        Sampling rate\n\n    Returns\n    -------\n    samples : int or np.ndarray [shape=times.shape, dtype=int]\n        Sample indices corresponding to values in `times`\n\n    See Also\n    --------\n    time_to_frames : convert time values to frame indices\n    samples_to_time : convert sample indices to time values\n\n    Examples\n    --------\n    >>> librosa.time_to_samples(np.arange(0, 1, 0.1), sr=22050)\n    array([    0,  2205,  4410,  6615,  8820, 11025, 13230, 15435,\n           17640, 19845])", "id": "f18158:m4"}
{"signature": "def note_to_midi(note, round_midi=True):", "body": "if not isinstance(note, six.string_types):<EOL><INDENT>return np.array([note_to_midi(n, round_midi=round_midi) for n in note])<EOL><DEDENT>pitch_map = {'<STR_LIT:C>': <NUM_LIT:0>, '<STR_LIT:D>': <NUM_LIT:2>, '<STR_LIT:E>': <NUM_LIT:4>, '<STR_LIT:F>': <NUM_LIT:5>, '<STR_LIT>': <NUM_LIT:7>, '<STR_LIT:A>': <NUM_LIT:9>, '<STR_LIT:B>': <NUM_LIT:11>}<EOL>acc_map = {'<STR_LIT:#>': <NUM_LIT:1>, '<STR_LIT>': <NUM_LIT:0>, '<STR_LIT:b>': -<NUM_LIT:1>, '<STR_LIT:!>': -<NUM_LIT:1>}<EOL>match = re.match(r'<STR_LIT>'<EOL>r'<STR_LIT>'<EOL>r'<STR_LIT>'<EOL>r'<STR_LIT>',<EOL>note)<EOL>if not match:<EOL><INDENT>raise ParameterError('<STR_LIT>'.format(note))<EOL><DEDENT>pitch = match.group('<STR_LIT>').upper()<EOL>offset = np.sum([acc_map[o] for o in match.group('<STR_LIT>')])<EOL>octave = match.group('<STR_LIT>')<EOL>cents = match.group('<STR_LIT>')<EOL>if not octave:<EOL><INDENT>octave = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>octave = int(octave)<EOL><DEDENT>if not cents:<EOL><INDENT>cents = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>cents = int(cents) * <NUM_LIT><EOL><DEDENT>note_value = <NUM_LIT:12> * (octave + <NUM_LIT:1>) + pitch_map[pitch] + offset + cents<EOL>if round_midi:<EOL><INDENT>note_value = int(np.round(note_value))<EOL><DEDENT>return note_value<EOL>", "docstring": "Convert one or more spelled notes to MIDI number(s).\n\n    Notes may be spelled out with optional accidentals or octave numbers.\n\n    The leading note name is case-insensitive.\n\n    Sharps are indicated with ``#``, flats may be indicated with ``!`` or ``b``.\n\n    Parameters\n    ----------\n    note : str or iterable of str\n        One or more note names.\n\n    round_midi : bool\n        - If `True`, allow for fractional midi notes\n        - Otherwise, round cent deviations to the nearest note\n\n    Returns\n    -------\n    midi : float or np.array\n        Midi note numbers corresponding to inputs.\n\n    Raises\n    ------\n    ParameterError\n        If the input is not in valid note format\n\n    See Also\n    --------\n    midi_to_note\n    note_to_hz\n\n    Examples\n    --------\n    >>> librosa.note_to_midi('C')\n    12\n    >>> librosa.note_to_midi('C#3')\n    49\n    >>> librosa.note_to_midi('f4')\n    65\n    >>> librosa.note_to_midi('Bb-1')\n    10\n    >>> librosa.note_to_midi('A!8')\n    116\n    >>> # Lists of notes also work\n    >>> librosa.note_to_midi(['C', 'E', 'G'])\n    array([12, 16, 19])", "id": "f18158:m7"}
{"signature": "def hz_to_note(frequencies, **kwargs):", "body": "return midi_to_note(hz_to_midi(frequencies), **kwargs)<EOL>", "docstring": "Convert one or more frequencies (in Hz) to the nearest note names.\n\n    Parameters\n    ----------\n    frequencies : float or iterable of float\n        Input frequencies, specified in Hz\n\n    kwargs : additional keyword arguments\n        Arguments passed through to `midi_to_note`\n\n\n    Returns\n    -------\n    notes : list of str\n        `notes[i]` is the closest note name to `frequency[i]`\n        (or `frequency` if the input is scalar)\n\n\n    See Also\n    --------\n    hz_to_midi\n    midi_to_note\n    note_to_hz\n\n\n    Examples\n    --------\n    Get a single note name for a frequency\n\n    >>> librosa.hz_to_note(440.0)\n    ['A5']\n\n    Get multiple notes with cent deviation\n\n    >>> librosa.hz_to_note([32, 64], cents=True)\n    ['C1-38', 'C2-38']\n\n    Get multiple notes, but suppress octave labels\n\n    >>> librosa.hz_to_note(440.0 * (2.0 ** np.linspace(0, 1, 12)),\n    ...                    octave=False)\n    ['A', 'A#', 'B', 'C', 'C#', 'D', 'E', 'F', 'F#', 'G', 'G#', 'A']", "id": "f18158:m11"}
{"signature": "def phase_vocoder(D, rate, hop_length=None):", "body": "n_fft = <NUM_LIT:2> * (D.shape[<NUM_LIT:0>] - <NUM_LIT:1>)<EOL>if hop_length is None:<EOL><INDENT>hop_length = int(n_fft // <NUM_LIT:4>)<EOL><DEDENT>time_steps = np.arange(<NUM_LIT:0>, D.shape[<NUM_LIT:1>], rate, dtype=np.float)<EOL>d_stretch = np.zeros((D.shape[<NUM_LIT:0>], len(time_steps)), D.dtype, order='<STR_LIT:F>')<EOL>phi_advance = np.linspace(<NUM_LIT:0>, np.pi * hop_length, D.shape[<NUM_LIT:0>])<EOL>phase_acc = np.angle(D[:, <NUM_LIT:0>])<EOL>D = np.pad(D, [(<NUM_LIT:0>, <NUM_LIT:0>), (<NUM_LIT:0>, <NUM_LIT:2>)], mode='<STR_LIT>')<EOL>for (t, step) in enumerate(time_steps):<EOL><INDENT>columns = D[:, int(step):int(step + <NUM_LIT:2>)]<EOL>alpha = np.mod(step, <NUM_LIT:1.0>)<EOL>mag = ((<NUM_LIT:1.0> - alpha) * np.abs(columns[:, <NUM_LIT:0>])<EOL>+ alpha * np.abs(columns[:, <NUM_LIT:1>]))<EOL>d_stretch[:, t] = mag * np.exp(<NUM_LIT> * phase_acc)<EOL>dphase = (np.angle(columns[:, <NUM_LIT:1>])<EOL>- np.angle(columns[:, <NUM_LIT:0>])<EOL>- phi_advance)<EOL>dphase = dphase - <NUM_LIT> * np.pi * np.round(dphase / (<NUM_LIT> * np.pi))<EOL>phase_acc += phi_advance + dphase<EOL><DEDENT>return d_stretch<EOL>", "docstring": "Phase vocoder.  Given an STFT matrix D, speed up by a factor of `rate`\n\n    Based on the implementation provided by [1]_.\n\n    .. [1] Ellis, D. P. W. \"A phase vocoder in Matlab.\"\n        Columbia University, 2002.\n        http://www.ee.columbia.edu/~dpwe/resources/matlab/pvoc/\n\n    Examples\n    --------\n    >>> # Play at double speed\n    >>> y, sr   = librosa.load(librosa.util.example_audio_file())\n    >>> D       = librosa.stft(y, n_fft=2048, hop_length=512)\n    >>> D_fast  = librosa.phase_vocoder(D, 2.0, hop_length=512)\n    >>> y_fast  = librosa.istft(D_fast, hop_length=512)\n\n    >>> # Or play at 1/3 speed\n    >>> y, sr   = librosa.load(librosa.util.example_audio_file())\n    >>> D       = librosa.stft(y, n_fft=2048, hop_length=512)\n    >>> D_slow  = librosa.phase_vocoder(D, 1./3, hop_length=512)\n    >>> y_slow  = librosa.istft(D_slow, hop_length=512)\n\n    Parameters\n    ----------\n    D : np.ndarray [shape=(d, t), dtype=complex]\n        STFT matrix\n\n    rate :  float > 0 [scalar]\n        Speed-up factor: `rate > 1` is faster, `rate < 1` is slower.\n\n    hop_length : int > 0 [scalar] or None\n        The number of samples between successive columns of `D`.\n\n        If None, defaults to `n_fft/4 = (D.shape[0]-1)/2`\n\n    Returns\n    -------\n    D_stretched : np.ndarray [shape=(d, t / rate), dtype=complex]\n        time-stretched STFT", "id": "f18159:m5"}
{"signature": "@cache(level=<NUM_LIT:30>)<EOL>def pcen(S, sr=<NUM_LIT>, hop_length=<NUM_LIT>, gain=<NUM_LIT>, bias=<NUM_LIT:2>, power=<NUM_LIT:0.5>,<EOL>time_constant=<NUM_LIT>, eps=<NUM_LIT>, b=None, max_size=<NUM_LIT:1>, ref=None,<EOL>axis=-<NUM_LIT:1>, max_axis=None, zi=None, return_zf=False):", "body": "if power <= <NUM_LIT:0>:<EOL><INDENT>raise ParameterError('<STR_LIT>'.format(power))<EOL><DEDENT>if gain < <NUM_LIT:0>:<EOL><INDENT>raise ParameterError('<STR_LIT>'.format(gain))<EOL><DEDENT>if bias < <NUM_LIT:0>:<EOL><INDENT>raise ParameterError('<STR_LIT>'.format(bias))<EOL><DEDENT>if eps <= <NUM_LIT:0>:<EOL><INDENT>raise ParameterError('<STR_LIT>'.format(eps))<EOL><DEDENT>if time_constant <= <NUM_LIT:0>:<EOL><INDENT>raise ParameterError('<STR_LIT>'.format(time_constant))<EOL><DEDENT>if max_size < <NUM_LIT:1> or not isinstance(max_size, int):<EOL><INDENT>raise ParameterError('<STR_LIT>'.format(max_size))<EOL><DEDENT>if b is None:<EOL><INDENT>t_frames = time_constant * sr / float(hop_length)<EOL>b = (np.sqrt(<NUM_LIT:1> + <NUM_LIT:4> * t_frames**<NUM_LIT:2>) - <NUM_LIT:1>) / (<NUM_LIT:2> * t_frames**<NUM_LIT:2>)<EOL><DEDENT>if not <NUM_LIT:0> <= b <= <NUM_LIT:1>:<EOL><INDENT>raise ParameterError('<STR_LIT>'.format(b))<EOL><DEDENT>if np.issubdtype(S.dtype, np.complexfloating):<EOL><INDENT>warnings.warn('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL>S = np.abs(S)<EOL><DEDENT>if ref is None:<EOL><INDENT>if max_size == <NUM_LIT:1>:<EOL><INDENT>ref = S<EOL><DEDENT>elif S.ndim == <NUM_LIT:1>:<EOL><INDENT>raise ParameterError('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>if max_axis is None:<EOL><INDENT>if S.ndim != <NUM_LIT:2>:<EOL><INDENT>raise ParameterError('<STR_LIT>'<EOL>'<STR_LIT>'.format(S.ndim))<EOL><DEDENT>max_axis = np.mod(<NUM_LIT:1> - axis, <NUM_LIT:2>)<EOL><DEDENT>ref = scipy.ndimage.maximum_filter1d(S, max_size, axis=max_axis)<EOL><DEDENT><DEDENT>if zi is None:<EOL><INDENT>shape = tuple([<NUM_LIT:1>] * ref.ndim)<EOL>zi = np.empty(shape)<EOL>zi[:] = scipy.signal.lfilter_zi([b], [<NUM_LIT:1>, b - <NUM_LIT:1>])[:]<EOL><DEDENT>S_smooth, zf = scipy.signal.lfilter([b], [<NUM_LIT:1>, b - <NUM_LIT:1>], ref, zi=zi,<EOL>axis=axis)<EOL>smooth = np.exp(-gain * (np.log(eps) + np.log1p(S_smooth / eps)))<EOL>S_out = (S * smooth + bias)**power - bias**power<EOL>if return_zf:<EOL><INDENT>return S_out, zf<EOL><DEDENT>else:<EOL><INDENT>return S_out<EOL><DEDENT>", "docstring": "Per-channel energy normalization (PCEN) [1]_\n\n    This function normalizes a time-frequency representation `S` by\n    performing automatic gain control, followed by nonlinear compression:\n\n        P[f, t] = (S / (eps + M[f, t])**gain + bias)**power - bias**power\n\n    where `M` is the result of applying a low-pass, temporal IIR filter\n    to `S`:\n\n        M[f, t] = (1 - b) * M[f, t - 1] + b * S[f, t]\n\n    If `b` is not provided, it is calculated as:\n\n        b = (sqrt(1 + 4* T**2) - 1) / (2 * T**2)\n\n    where `T = time_constant * sr / hop_length`.\n\n    This normalization is designed to suppress background noise and\n    emphasize foreground signals, and can be used as an alternative to\n    decibel scaling (`amplitude_to_db`).\n\n    This implementation also supports smoothing across frequency bins\n    by specifying `max_size > 1`.  If this option is used, the filtered\n    spectrogram `M` is computed as\n\n        M[f, t] = (1 - b) * M[f, t - 1] + b * R[f, t]\n\n    where `R` has been max-filtered along the frequency axis, similar to\n    the SuperFlux algorithm implemented in `onset.onset_strength`:\n\n        R[f, t] = max(S[f - max_size//2: f + max_size//2, t])\n\n    This can be used to perform automatic gain control on signals that cross\n    or span multiple frequency bans, which may be desirable for spectrograms\n    with high frequency resolution.\n\n    .. [1] Wang, Y., Getreuer, P., Hughes, T., Lyon, R. F., & Saurous, R. A.\n       (2017, March). Trainable frontend for robust and far-field keyword spotting.\n       In Acoustics, Speech and Signal Processing (ICASSP), 2017\n       IEEE International Conference on (pp. 5670-5674). IEEE.\n\n    Parameters\n    ----------\n    S : np.ndarray (non-negative)\n        The input (magnitude) spectrogram\n\n    sr : number > 0 [scalar]\n        The audio sampling rate\n\n    hop_length : int > 0 [scalar]\n        The hop length of `S`, expressed in samples\n\n    gain : number >= 0 [scalar]\n        The gain factor.  Typical values should be slightly less than 1.\n\n    bias : number >= 0 [scalar]\n        The bias point of the nonlinear compression (default: 2)\n\n    power : number > 0 [scalar]\n        The compression exponent.  Typical values should be between 0 and 1.\n        Smaller values of `power` result in stronger compression.\n\n    time_constant : number > 0 [scalar]\n        The time constant for IIR filtering, measured in seconds.\n\n    eps : number > 0 [scalar]\n        A small constant used to ensure numerical stability of the filter.\n\n    b : number in [0, 1]  [scalar]\n        The filter coefficient for the low-pass filter.\n        If not provided, it will be inferred from `time_constant`.\n\n    max_size : int > 0 [scalar]\n        The width of the max filter applied to the frequency axis.\n        If left as `1`, no filtering is performed.\n\n    ref : None or np.ndarray (shape=S.shape)\n        An optional pre-computed reference spectrum (`R` in the above).\n        If not provided it will be computed from `S`.\n\n    axis : int [scalar]\n        The (time) axis of the input spectrogram.\n\n    max_axis : None or int [scalar]\n        The frequency axis of the input spectrogram.\n        If `None`, and `S` is two-dimensional, it will be inferred\n        as the opposite from `axis`.\n        If `S` is not two-dimensional, and `max_size > 1`, an error\n        will be raised.\n\n    zi : np.ndarray\n        The initial filter delay values.\n\n        This may be the `zf` (final delay values) of a previous call to `pcen`, or\n        computed by `scipy.signal.lfilter_zi`.\n\n    return_zf : bool\n        If `True`, return the final filter delay values along with the PCEN output `P`.\n        This is primarily useful in streaming contexts, where the final state of one\n        block of processing should be used to initialize the next block.\n\n        If `False` (default) only the PCEN values `P` are returned.\n\n\n    Returns\n    -------\n    P : np.ndarray, non-negative [shape=(n, m)]\n        The per-channel energy normalized version of `S`.\n\n    zf : np.ndarray (optional)\n        The final filter delay values.  Only returned if `return_zf=True`.\n\n    See Also\n    --------\n    amplitude_to_db\n    librosa.onset.onset_strength\n\n    Examples\n    --------\n\n    Compare PCEN to log amplitude (dB) scaling on Mel spectra\n\n    >>> import matplotlib.pyplot as plt\n    >>> y, sr = librosa.load(librosa.util.example_audio_file(),\n    ...                      offset=10, duration=10)\n\n    >>> # We'll use power=1 to get a magnitude spectrum\n    >>> # instead of a power spectrum\n    >>> S = librosa.feature.melspectrogram(y, sr=sr, power=1)\n    >>> log_S = librosa.amplitude_to_db(S, ref=np.max)\n    >>> pcen_S = librosa.pcen(S)\n    >>> plt.figure()\n    >>> plt.subplot(2,1,1)\n    >>> librosa.display.specshow(log_S, x_axis='time', y_axis='mel')\n    >>> plt.title('log amplitude (dB)')\n    >>> plt.colorbar()\n    >>> plt.subplot(2,1,2)\n    >>> librosa.display.specshow(pcen_S, x_axis='time', y_axis='mel')\n    >>> plt.title('Per-channel energy normalization')\n    >>> plt.colorbar()\n    >>> plt.tight_layout()\n\n    Compare PCEN with and without max-filtering\n\n    >>> pcen_max = librosa.pcen(S, max_size=3)\n    >>> plt.figure()\n    >>> plt.subplot(2,1,1)\n    >>> librosa.display.specshow(pcen_S, x_axis='time', y_axis='mel')\n    >>> plt.title('Per-channel energy normalization (no max-filter)')\n    >>> plt.colorbar()\n    >>> plt.subplot(2,1,2)\n    >>> librosa.display.specshow(pcen_max, x_axis='time', y_axis='mel')\n    >>> plt.title('Per-channel energy normalization (max_size=3)')\n    >>> plt.colorbar()\n    >>> plt.tight_layout()", "id": "f18159:m13"}
{"signature": "@cache(level=<NUM_LIT:30>)<EOL>def fmt(y, t_min=<NUM_LIT:0.5>, n_fmt=None, kind='<STR_LIT>', beta=<NUM_LIT:0.5>, over_sample=<NUM_LIT:1>, axis=-<NUM_LIT:1>):", "body": "n = y.shape[axis]<EOL>if n < <NUM_LIT:3>:<EOL><INDENT>raise ParameterError('<STR_LIT>'.format(axis, n))<EOL><DEDENT>if t_min <= <NUM_LIT:0>:<EOL><INDENT>raise ParameterError('<STR_LIT>')<EOL><DEDENT>if n_fmt is None:<EOL><INDENT>if over_sample < <NUM_LIT:1>:<EOL><INDENT>raise ParameterError('<STR_LIT>')<EOL><DEDENT>log_base = np.log(n - <NUM_LIT:1>) - np.log(n - <NUM_LIT:2>)<EOL>n_fmt = int(np.ceil(over_sample * (np.log(n - <NUM_LIT:1>) - np.log(t_min)) / log_base))<EOL><DEDENT>elif n_fmt < <NUM_LIT:3>:<EOL><INDENT>raise ParameterError('<STR_LIT>'.format(n_fmt))<EOL><DEDENT>else:<EOL><INDENT>log_base = (np.log(n_fmt - <NUM_LIT:1>) - np.log(n_fmt - <NUM_LIT:2>)) / over_sample<EOL><DEDENT>if not np.all(np.isfinite(y)):<EOL><INDENT>raise ParameterError('<STR_LIT>')<EOL><DEDENT>base = np.exp(log_base)<EOL>x = np.linspace(<NUM_LIT:0>, <NUM_LIT:1>, num=n, endpoint=False)<EOL>f_interp = scipy.interpolate.interp1d(x, y, kind=kind, axis=axis)<EOL>n_over = int(np.ceil(over_sample))<EOL>x_exp = np.logspace((np.log(t_min) - np.log(n)) / log_base,<EOL><NUM_LIT:0>,<EOL>num=n_fmt + n_over,<EOL>endpoint=False,<EOL>base=base)[:-n_over]<EOL>if x_exp[<NUM_LIT:0>] < t_min or x_exp[-<NUM_LIT:1>] > float(n - <NUM_LIT:1.0>) / n:<EOL><INDENT>x_exp = np.clip(x_exp, float(t_min) / n, x[-<NUM_LIT:1>])<EOL><DEDENT>if len(np.unique(x_exp)) != len(x_exp):<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>y_res = f_interp(x_exp)<EOL>shape = [<NUM_LIT:1>] * y_res.ndim<EOL>shape[axis] = -<NUM_LIT:1><EOL>fft = get_fftlib()<EOL>return fft.rfft(y_res * ((x_exp**beta).reshape(shape) * np.sqrt(n) / n_fmt),<EOL>axis=axis)<EOL>", "docstring": "The fast Mellin transform (FMT) [1]_ of a uniformly sampled signal y.\n\n    When the Mellin parameter (beta) is 1/2, it is also known as the scale transform [2]_.\n    The scale transform can be useful for audio analysis because its magnitude is invariant\n    to scaling of the domain (e.g., time stretching or compression).  This is analogous\n    to the magnitude of the Fourier transform being invariant to shifts in the input domain.\n\n\n    .. [1] De Sena, Antonio, and Davide Rocchesso.\n        \"A fast Mellin and scale transform.\"\n        EURASIP Journal on Applied Signal Processing 2007.1 (2007): 75-75.\n\n    .. [2] Cohen, L.\n        \"The scale representation.\"\n        IEEE Transactions on Signal Processing 41, no. 12 (1993): 3275-3292.\n\n    Parameters\n    ----------\n    y : np.ndarray, real-valued\n        The input signal(s).  Can be multidimensional.\n        The target axis must contain at least 3 samples.\n\n    t_min : float > 0\n        The minimum time spacing (in samples).\n        This value should generally be less than 1 to preserve as much information as\n        possible.\n\n    n_fmt : int > 2 or None\n        The number of scale transform bins to use.\n        If None, then `n_bins = over_sample * ceil(n * log((n-1)/t_min))` is taken,\n        where `n = y.shape[axis]`\n\n    kind : str\n        The type of interpolation to use when re-sampling the input.\n        See `scipy.interpolate.interp1d` for possible values.\n\n        Note that the default is to use high-precision (cubic) interpolation.\n        This can be slow in practice; if speed is preferred over accuracy,\n        then consider using `kind='linear'`.\n\n    beta : float\n        The Mellin parameter.  `beta=0.5` provides the scale transform.\n\n    over_sample : float >= 1\n        Over-sampling factor for exponential resampling.\n\n    axis : int\n        The axis along which to transform `y`\n\n    Returns\n    -------\n    x_scale : np.ndarray [dtype=complex]\n        The scale transform of `y` along the `axis` dimension.\n\n    Raises\n    ------\n    ParameterError\n        if `n_fmt < 2` or `t_min <= 0`\n        or if `y` is not finite\n        or if `y.shape[axis] < 3`.\n\n    Notes\n    -----\n    This function caches at level 30.\n\n\n    Examples\n    --------\n    >>> # Generate a signal and time-stretch it (with energy normalization)\n    >>> scale = 1.25\n    >>> freq = 3.0\n    >>> x1 = np.linspace(0, 1, num=1024, endpoint=False)\n    >>> x2 = np.linspace(0, 1, num=scale * len(x1), endpoint=False)\n    >>> y1 = np.sin(2 * np.pi * freq * x1)\n    >>> y2 = np.sin(2 * np.pi * freq * x2) / np.sqrt(scale)\n    >>> # Verify that the two signals have the same energy\n    >>> np.sum(np.abs(y1)**2), np.sum(np.abs(y2)**2)\n        (255.99999999999997, 255.99999999999969)\n    >>> scale1 = librosa.fmt(y1, n_fmt=512)\n    >>> scale2 = librosa.fmt(y2, n_fmt=512)\n    >>> # And plot the results\n    >>> import matplotlib.pyplot as plt\n    >>> plt.figure(figsize=(8, 4))\n    >>> plt.subplot(1, 2, 1)\n    >>> plt.plot(y1, label='Original')\n    >>> plt.plot(y2, linestyle='--', label='Stretched')\n    >>> plt.xlabel('time (samples)')\n    >>> plt.title('Input signals')\n    >>> plt.legend(frameon=True)\n    >>> plt.axis('tight')\n    >>> plt.subplot(1, 2, 2)\n    >>> plt.semilogy(np.abs(scale1), label='Original')\n    >>> plt.semilogy(np.abs(scale2), linestyle='--', label='Stretched')\n    >>> plt.xlabel('scale coefficients')\n    >>> plt.title('Scale transform magnitude')\n    >>> plt.legend(frameon=True)\n    >>> plt.axis('tight')\n    >>> plt.tight_layout()\n\n    >>> # Plot the scale transform of an onset strength autocorrelation\n    >>> y, sr = librosa.load(librosa.util.example_audio_file(),\n    ...                      offset=10.0, duration=30.0)\n    >>> odf = librosa.onset.onset_strength(y=y, sr=sr)\n    >>> # Auto-correlate with up to 10 seconds lag\n    >>> odf_ac = librosa.autocorrelate(odf, max_size=10 * sr // 512)\n    >>> # Normalize\n    >>> odf_ac = librosa.util.normalize(odf_ac, norm=np.inf)\n    >>> # Compute the scale transform\n    >>> odf_ac_scale = librosa.fmt(librosa.util.normalize(odf_ac), n_fmt=512)\n    >>> # Plot the results\n    >>> plt.figure()\n    >>> plt.subplot(3, 1, 1)\n    >>> plt.plot(odf, label='Onset strength')\n    >>> plt.axis('tight')\n    >>> plt.xlabel('Time (frames)')\n    >>> plt.xticks([])\n    >>> plt.legend(frameon=True)\n    >>> plt.subplot(3, 1, 2)\n    >>> plt.plot(odf_ac, label='Onset autocorrelation')\n    >>> plt.axis('tight')\n    >>> plt.xlabel('Lag (frames)')\n    >>> plt.xticks([])\n    >>> plt.legend(frameon=True)\n    >>> plt.subplot(3, 1, 3)\n    >>> plt.semilogy(np.abs(odf_ac_scale), label='Scale transform magnitude')\n    >>> plt.axis('tight')\n    >>> plt.xlabel('scale coefficients')\n    >>> plt.legend(frameon=True)\n    >>> plt.tight_layout()", "id": "f18159:m12"}
{"signature": "def estimate_tuning(y=None, sr=<NUM_LIT>, S=None, n_fft=<NUM_LIT>,<EOL>resolution=<NUM_LIT>, bins_per_octave=<NUM_LIT:12>, **kwargs):", "body": "pitch, mag = piptrack(y=y, sr=sr, S=S, n_fft=n_fft, **kwargs)<EOL>pitch_mask = pitch > <NUM_LIT:0><EOL>if pitch_mask.any():<EOL><INDENT>threshold = np.median(mag[pitch_mask])<EOL><DEDENT>else:<EOL><INDENT>threshold = <NUM_LIT:0.0><EOL><DEDENT>return pitch_tuning(pitch[(mag >= threshold) & pitch_mask],<EOL>resolution=resolution,<EOL>bins_per_octave=bins_per_octave)<EOL>", "docstring": "Estimate the tuning of an audio time series or spectrogram input.\n\n    Parameters\n    ----------\n    y: np.ndarray [shape=(n,)] or None\n        audio signal\n\n    sr : number > 0 [scalar]\n        audio sampling rate of `y`\n\n    S: np.ndarray [shape=(d, t)] or None\n        magnitude or power spectrogram\n\n    n_fft : int > 0 [scalar] or None\n        number of FFT bins to use, if `y` is provided.\n\n    resolution : float in `(0, 1)`\n        Resolution of the tuning as a fraction of a bin.\n        0.01 corresponds to measurements in cents.\n\n    bins_per_octave : int > 0 [scalar]\n        How many frequency bins per octave\n\n    kwargs : additional keyword arguments\n        Additional arguments passed to `piptrack`\n\n    Returns\n    -------\n    tuning: float in `[-0.5, 0.5)`\n        estimated tuning deviation (fractions of a bin)\n\n    See Also\n    --------\n    piptrack\n        Pitch tracking by parabolic interpolation\n\n    Examples\n    --------\n    >>> # With time-series input\n    >>> y, sr = librosa.load(librosa.util.example_audio_file())\n    >>> librosa.estimate_tuning(y=y, sr=sr)\n    0.089999999999999969\n\n    >>> # In tenths of a cent\n    >>> y, sr = librosa.load(librosa.util.example_audio_file())\n    >>> librosa.estimate_tuning(y=y, sr=sr, resolution=1e-3)\n    0.093999999999999972\n\n    >>> # Using spectrogram input\n    >>> y, sr = librosa.load(librosa.util.example_audio_file())\n    >>> S = np.abs(librosa.stft(y))\n    >>> librosa.estimate_tuning(S=S, sr=sr)\n    0.089999999999999969\n\n    >>> # Using pass-through arguments to `librosa.piptrack`\n    >>> y, sr = librosa.load(librosa.util.example_audio_file())\n    >>> librosa.estimate_tuning(y=y, sr=sr, n_fft=8192,\n    ...                         fmax=librosa.note_to_hz('G#9'))\n    0.070000000000000062", "id": "f18161:m0"}
{"signature": "def pitch_tuning(frequencies, resolution=<NUM_LIT>, bins_per_octave=<NUM_LIT:12>):", "body": "frequencies = np.atleast_1d(frequencies)<EOL>frequencies = frequencies[frequencies > <NUM_LIT:0>]<EOL>if not np.any(frequencies):<EOL><INDENT>warnings.warn('<STR_LIT>')<EOL>return <NUM_LIT:0.0><EOL><DEDENT>residual = np.mod(bins_per_octave *<EOL>time_frequency.hz_to_octs(frequencies), <NUM_LIT:1.0>)<EOL>residual[residual >= <NUM_LIT:0.5>] -= <NUM_LIT:1.0><EOL>bins = np.linspace(-<NUM_LIT:0.5>, <NUM_LIT:0.5>, int(np.ceil(<NUM_LIT:1.> / resolution)) + <NUM_LIT:1>)<EOL>counts, tuning = np.histogram(residual, bins)<EOL>return tuning[np.argmax(counts)]<EOL>", "docstring": "Given a collection of pitches, estimate its tuning offset\n    (in fractions of a bin) relative to A440=440.0Hz.\n\n    Parameters\n    ----------\n    frequencies : array-like, float\n        A collection of frequencies detected in the signal.\n        See `piptrack`\n\n    resolution : float in `(0, 1)`\n        Resolution of the tuning as a fraction of a bin.\n        0.01 corresponds to cents.\n\n    bins_per_octave : int > 0 [scalar]\n        How many frequency bins per octave\n\n    Returns\n    -------\n    tuning: float in `[-0.5, 0.5)`\n        estimated tuning deviation (fractions of a bin)\n\n    See Also\n    --------\n    estimate_tuning\n        Estimating tuning from time-series or spectrogram input\n\n    Examples\n    --------\n    >>> # Generate notes at +25 cents\n    >>> freqs = librosa.cqt_frequencies(24, 55, tuning=0.25)\n    >>> librosa.pitch_tuning(freqs)\n    0.25\n\n    >>> # Track frequencies from a real spectrogram\n    >>> y, sr = librosa.load(librosa.util.example_audio_file())\n    >>> pitches, magnitudes, stft = librosa.ifptrack(y, sr)\n    >>> # Select out pitches with high energy\n    >>> pitches = pitches[magnitudes > np.median(magnitudes)]\n    >>> librosa.pitch_tuning(pitches)\n    0.089999999999999969", "id": "f18161:m1"}
{"signature": "def rename_kw(old_name, old_value, new_name, new_value,<EOL>version_deprecated, version_removed):", "body": "if isinstance(old_value, Deprecated):<EOL><INDENT>return new_value<EOL><DEDENT>else:<EOL><INDENT>stack = inspect.stack()<EOL>dep_func = stack[<NUM_LIT:1>]<EOL>caller = stack[<NUM_LIT:2>]<EOL>warnings.warn_explicit(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(dep_func[<NUM_LIT:3>],<EOL>old_name, new_name,<EOL>version_deprecated,<EOL>version_removed),<EOL>category=DeprecationWarning,<EOL>filename=caller[<NUM_LIT:1>],<EOL>lineno=caller[<NUM_LIT:2>])<EOL>return old_value<EOL><DEDENT>", "docstring": "Handle renamed arguments.\n\n    Parameters\n    ----------\n    old_name : str\n    old_value\n        The name and value of the old argument\n\n    new_name : str\n    new_value\n        The name and value of the new argument\n\n    version_deprecated : str\n        The version at which the old name became deprecated\n\n    version_removed : str\n        The version at which the old name will be removed\n\n    Returns\n    -------\n    value\n        - `new_value` if `old_value` of type `Deprecated`\n        - `old_value` otherwise\n\n    Warnings\n    --------\n    if `old_value` is not of type `Deprecated`", "id": "f18163:m0"}
{"signature": "def valid_intervals(intervals):", "body": "if intervals.ndim != <NUM_LIT:2> or intervals.shape[-<NUM_LIT:1>] != <NUM_LIT:2>:<EOL><INDENT>raise ParameterError('<STR_LIT>')<EOL><DEDENT>if np.any(intervals[:, <NUM_LIT:0>] > intervals[:, <NUM_LIT:1>]):<EOL><INDENT>raise ParameterError('<STR_LIT>'.format(intervals))<EOL><DEDENT>return True<EOL>", "docstring": "Ensure that an array is a valid representation of time intervals:\n\n        - intervals.ndim == 2\n        - intervals.shape[1] == 2\n        - intervals[i, 0] <= intervals[i, 1] for all i\n\n    Parameters\n    ----------\n    intervals : np.ndarray [shape=(n, 2)]\n        set of time intervals\n\n    Returns\n    -------\n    valid : bool\n        True if `intervals` passes validation.", "id": "f18165:m3"}
{"signature": "def peak_pick(x, pre_max, post_max, pre_avg, post_avg, delta, wait):", "body": "if pre_max < <NUM_LIT:0>:<EOL><INDENT>raise ParameterError('<STR_LIT>')<EOL><DEDENT>if pre_avg < <NUM_LIT:0>:<EOL><INDENT>raise ParameterError('<STR_LIT>')<EOL><DEDENT>if delta < <NUM_LIT:0>:<EOL><INDENT>raise ParameterError('<STR_LIT>')<EOL><DEDENT>if wait < <NUM_LIT:0>:<EOL><INDENT>raise ParameterError('<STR_LIT>')<EOL><DEDENT>if post_max <= <NUM_LIT:0>:<EOL><INDENT>raise ParameterError('<STR_LIT>')<EOL><DEDENT>if post_avg <= <NUM_LIT:0>:<EOL><INDENT>raise ParameterError('<STR_LIT>')<EOL><DEDENT>if x.ndim != <NUM_LIT:1>:<EOL><INDENT>raise ParameterError('<STR_LIT>')<EOL><DEDENT>pre_max = valid_int(pre_max, cast=np.ceil)<EOL>post_max = valid_int(post_max, cast=np.ceil)<EOL>pre_avg = valid_int(pre_avg, cast=np.ceil)<EOL>post_avg = valid_int(post_avg, cast=np.ceil)<EOL>wait = valid_int(wait, cast=np.ceil)<EOL>max_length = pre_max + post_max<EOL>max_origin = np.ceil(<NUM_LIT:0.5> * (pre_max - post_max))<EOL>mov_max = scipy.ndimage.filters.maximum_filter1d(x, int(max_length),<EOL>mode='<STR_LIT>',<EOL>origin=int(max_origin),<EOL>cval=x.min())<EOL>avg_length = pre_avg + post_avg<EOL>avg_origin = np.ceil(<NUM_LIT:0.5> * (pre_avg - post_avg))<EOL>mov_avg = scipy.ndimage.filters.uniform_filter1d(x, int(avg_length),<EOL>mode='<STR_LIT>',<EOL>origin=int(avg_origin))<EOL>n = <NUM_LIT:0><EOL>while n - pre_avg < <NUM_LIT:0> and n < x.shape[<NUM_LIT:0>]:<EOL><INDENT>start = n - pre_avg<EOL>start = start if start > <NUM_LIT:0> else <NUM_LIT:0><EOL>mov_avg[n] = np.mean(x[start:n + post_avg])<EOL>n += <NUM_LIT:1><EOL><DEDENT>n = x.shape[<NUM_LIT:0>] - post_avg<EOL>n = n if n > <NUM_LIT:0> else <NUM_LIT:0><EOL>while n < x.shape[<NUM_LIT:0>]:<EOL><INDENT>start = n - pre_avg<EOL>start = start if start > <NUM_LIT:0> else <NUM_LIT:0><EOL>mov_avg[n] = np.mean(x[start:n + post_avg])<EOL>n += <NUM_LIT:1><EOL><DEDENT>detections = x * (x == mov_max)<EOL>detections = detections * (detections >= (mov_avg + delta))<EOL>peaks = []<EOL>last_onset = -np.inf<EOL>for i in np.nonzero(detections)[<NUM_LIT:0>]:<EOL><INDENT>if i > last_onset + wait:<EOL><INDENT>peaks.append(i)<EOL>last_onset = i<EOL><DEDENT><DEDENT>return np.array(peaks)<EOL>", "docstring": "Uses a flexible heuristic to pick peaks in a signal.\n\n    A sample n is selected as an peak if the corresponding x[n]\n    fulfills the following three conditions:\n\n    1. `x[n] == max(x[n - pre_max:n + post_max])`\n    2. `x[n] >= mean(x[n - pre_avg:n + post_avg]) + delta`\n    3. `n - previous_n > wait`\n\n    where `previous_n` is the last sample picked as a peak (greedily).\n\n    This implementation is based on [1]_ and [2]_.\n\n    .. [1] Boeck, Sebastian, Florian Krebs, and Markus Schedl.\n        \"Evaluating the Online Capabilities of Onset Detection Methods.\" ISMIR.\n        2012.\n\n    .. [2] https://github.com/CPJKU/onset_detection/blob/master/onset_program.py\n\n\n    Parameters\n    ----------\n    x         : np.ndarray [shape=(n,)]\n        input signal to peak picks from\n\n    pre_max   : int >= 0 [scalar]\n        number of samples before `n` over which max is computed\n\n    post_max  : int >= 1 [scalar]\n        number of samples after `n` over which max is computed\n\n    pre_avg   : int >= 0 [scalar]\n        number of samples before `n` over which mean is computed\n\n    post_avg  : int >= 1 [scalar]\n        number of samples after `n` over which mean is computed\n\n    delta     : float >= 0 [scalar]\n        threshold offset for mean\n\n    wait      : int >= 0 [scalar]\n        number of samples to wait after picking a peak\n\n    Returns\n    -------\n    peaks     : np.ndarray [shape=(n_peaks,), dtype=int]\n        indices of peaks in `x`\n\n    Raises\n    ------\n    ParameterError\n        If any input lies outside its defined range\n\n    Examples\n    --------\n    >>> y, sr = librosa.load(librosa.util.example_audio_file(), duration=15)\n    >>> onset_env = librosa.onset.onset_strength(y=y, sr=sr,\n    ...                                          hop_length=512,\n    ...                                          aggregate=np.median)\n    >>> peaks = librosa.util.peak_pick(onset_env, 3, 3, 3, 5, 0.5, 10)\n    >>> peaks\n    array([  4,  23,  73, 102, 142, 162, 182, 211, 261, 301, 320,\n           331, 348, 368, 382, 396, 411, 431, 446, 461, 476, 491,\n           510, 525, 536, 555, 570, 590, 609, 625, 639])\n\n    >>> import matplotlib.pyplot as plt\n    >>> times = librosa.frames_to_time(np.arange(len(onset_env)),\n    ...                                sr=sr, hop_length=512)\n    >>> plt.figure()\n    >>> ax = plt.subplot(2, 1, 2)\n    >>> D = librosa.stft(y)\n    >>> librosa.display.specshow(librosa.amplitude_to_db(D, ref=np.max),\n    ...                          y_axis='log', x_axis='time')\n    >>> plt.subplot(2, 1, 1, sharex=ax)\n    >>> plt.plot(times, onset_env, alpha=0.8, label='Onset strength')\n    >>> plt.vlines(times[peaks], 0,\n    ...            onset_env.max(), color='r', alpha=0.8,\n    ...            label='Selected peaks')\n    >>> plt.legend(frameon=True, framealpha=0.8)\n    >>> plt.axis('tight')\n    >>> plt.tight_layout()", "id": "f18165:m10"}
{"signature": "def pad_center(data, size, axis=-<NUM_LIT:1>, **kwargs):", "body": "kwargs.setdefault('<STR_LIT>', '<STR_LIT>')<EOL>n = data.shape[axis]<EOL>lpad = int((size - n) // <NUM_LIT:2>)<EOL>lengths = [(<NUM_LIT:0>, <NUM_LIT:0>)] * data.ndim<EOL>lengths[axis] = (lpad, int(size - n - lpad))<EOL>if lpad < <NUM_LIT:0>:<EOL><INDENT>raise ParameterError(('<STR_LIT>'<EOL>'<STR_LIT>').format(size, n))<EOL><DEDENT>return np.pad(data, lengths, **kwargs)<EOL>", "docstring": "Wrapper for np.pad to automatically center an array prior to padding.\n    This is analogous to `str.center()`\n\n    Examples\n    --------\n    >>> # Generate a vector\n    >>> data = np.ones(5)\n    >>> librosa.util.pad_center(data, 10, mode='constant')\n    array([ 0.,  0.,  1.,  1.,  1.,  1.,  1.,  0.,  0.,  0.])\n\n    >>> # Pad a matrix along its first dimension\n    >>> data = np.ones((3, 5))\n    >>> librosa.util.pad_center(data, 7, axis=0)\n    array([[ 0.,  0.,  0.,  0.,  0.],\n           [ 0.,  0.,  0.,  0.,  0.],\n           [ 1.,  1.,  1.,  1.,  1.],\n           [ 1.,  1.,  1.,  1.,  1.],\n           [ 1.,  1.,  1.,  1.,  1.],\n           [ 0.,  0.,  0.,  0.,  0.],\n           [ 0.,  0.,  0.,  0.,  0.]])\n    >>> # Or its second dimension\n    >>> librosa.util.pad_center(data, 7, axis=1)\n    array([[ 0.,  1.,  1.,  1.,  1.,  1.,  0.],\n           [ 0.,  1.,  1.,  1.,  1.,  1.,  0.],\n           [ 0.,  1.,  1.,  1.,  1.,  1.,  0.]])\n\n    Parameters\n    ----------\n    data : np.ndarray\n        Vector to be padded and centered\n\n    size : int >= len(data) [scalar]\n        Length to pad `data`\n\n    axis : int\n        Axis along which to pad and center the data\n\n    kwargs : additional keyword arguments\n      arguments passed to `np.pad()`\n\n    Returns\n    -------\n    data_padded : np.ndarray\n        `data` centered and padded to length `size` along the\n        specified axis\n\n    Raises\n    ------\n    ParameterError\n        If `size < data.shape[axis]`\n\n    See Also\n    --------\n    numpy.pad", "id": "f18165:m4"}
{"signature": "@cache(level=<NUM_LIT>)<EOL>def normalize(S, norm=np.inf, axis=<NUM_LIT:0>, threshold=None, fill=None):", "body": "<EOL>if threshold is None:<EOL><INDENT>threshold = tiny(S)<EOL><DEDENT>elif threshold <= <NUM_LIT:0>:<EOL><INDENT>raise ParameterError('<STR_LIT>'<EOL>'<STR_LIT>'.format(threshold))<EOL><DEDENT>if fill not in [None, False, True]:<EOL><INDENT>raise ParameterError('<STR_LIT>'.format(fill))<EOL><DEDENT>if not np.all(np.isfinite(S)):<EOL><INDENT>raise ParameterError('<STR_LIT>')<EOL><DEDENT>mag = np.abs(S).astype(np.float)<EOL>fill_norm = <NUM_LIT:1><EOL>if norm == np.inf:<EOL><INDENT>length = np.max(mag, axis=axis, keepdims=True)<EOL><DEDENT>elif norm == -np.inf:<EOL><INDENT>length = np.min(mag, axis=axis, keepdims=True)<EOL><DEDENT>elif norm == <NUM_LIT:0>:<EOL><INDENT>if fill is True:<EOL><INDENT>raise ParameterError('<STR_LIT>')<EOL><DEDENT>length = np.sum(mag > <NUM_LIT:0>, axis=axis, keepdims=True, dtype=mag.dtype)<EOL><DEDENT>elif np.issubdtype(type(norm), np.number) and norm > <NUM_LIT:0>:<EOL><INDENT>length = np.sum(mag**norm, axis=axis, keepdims=True)**(<NUM_LIT:1.>/norm)<EOL>if axis is None:<EOL><INDENT>fill_norm = mag.size**(-<NUM_LIT:1.>/norm)<EOL><DEDENT>else:<EOL><INDENT>fill_norm = mag.shape[axis]**(-<NUM_LIT:1.>/norm)<EOL><DEDENT><DEDENT>elif norm is None:<EOL><INDENT>return S<EOL><DEDENT>else:<EOL><INDENT>raise ParameterError('<STR_LIT>'.format(repr(norm)))<EOL><DEDENT>small_idx = length < threshold<EOL>Snorm = np.empty_like(S)<EOL>if fill is None:<EOL><INDENT>length[small_idx] = <NUM_LIT:1.0><EOL>Snorm[:] = S / length<EOL><DEDENT>elif fill:<EOL><INDENT>length[small_idx] = np.nan<EOL>Snorm[:] = S / length<EOL>Snorm[np.isnan(Snorm)] = fill_norm<EOL><DEDENT>else:<EOL><INDENT>length[small_idx] = np.inf<EOL>Snorm[:] = S / length<EOL><DEDENT>return Snorm<EOL>", "docstring": "Normalize an array along a chosen axis.\n\n    Given a norm (described below) and a target axis, the input\n    array is scaled so that\n\n        `norm(S, axis=axis) == 1`\n\n    For example, `axis=0` normalizes each column of a 2-d array\n    by aggregating over the rows (0-axis).\n    Similarly, `axis=1` normalizes each row of a 2-d array.\n\n    This function also supports thresholding small-norm slices:\n    any slice (i.e., row or column) with norm below a specified\n    `threshold` can be left un-normalized, set to all-zeros, or\n    filled with uniform non-zero values that normalize to 1.\n\n    Note: the semantics of this function differ from\n    `scipy.linalg.norm` in two ways: multi-dimensional arrays\n    are supported, but matrix-norms are not.\n\n\n    Parameters\n    ----------\n    S : np.ndarray\n        The matrix to normalize\n\n    norm : {np.inf, -np.inf, 0, float > 0, None}\n        - `np.inf`  : maximum absolute value\n        - `-np.inf` : mininum absolute value\n        - `0`    : number of non-zeros (the support)\n        - float  : corresponding l_p norm\n            See `scipy.linalg.norm` for details.\n        - None : no normalization is performed\n\n    axis : int [scalar]\n        Axis along which to compute the norm.\n\n    threshold : number > 0 [optional]\n        Only the columns (or rows) with norm at least `threshold` are\n        normalized.\n\n        By default, the threshold is determined from\n        the numerical precision of `S.dtype`.\n\n    fill : None or bool\n        If None, then columns (or rows) with norm below `threshold`\n        are left as is.\n\n        If False, then columns (rows) with norm below `threshold`\n        are set to 0.\n\n        If True, then columns (rows) with norm below `threshold`\n        are filled uniformly such that the corresponding norm is 1.\n\n        .. note:: `fill=True` is incompatible with `norm=0` because\n            no uniform vector exists with l0 \"norm\" equal to 1.\n\n    Returns\n    -------\n    S_norm : np.ndarray [shape=S.shape]\n        Normalized array\n\n    Raises\n    ------\n    ParameterError\n        If `norm` is not among the valid types defined above\n\n        If `S` is not finite\n\n        If `fill=True` and `norm=0`\n\n    See Also\n    --------\n    scipy.linalg.norm\n\n    Notes\n    -----\n    This function caches at level 40.\n\n    Examples\n    --------\n    >>> # Construct an example matrix\n    >>> S = np.vander(np.arange(-2.0, 2.0))\n    >>> S\n    array([[-8.,  4., -2.,  1.],\n           [-1.,  1., -1.,  1.],\n           [ 0.,  0.,  0.,  1.],\n           [ 1.,  1.,  1.,  1.]])\n    >>> # Max (l-infinity)-normalize the columns\n    >>> librosa.util.normalize(S)\n    array([[-1.   ,  1.   , -1.   ,  1.   ],\n           [-0.125,  0.25 , -0.5  ,  1.   ],\n           [ 0.   ,  0.   ,  0.   ,  1.   ],\n           [ 0.125,  0.25 ,  0.5  ,  1.   ]])\n    >>> # Max (l-infinity)-normalize the rows\n    >>> librosa.util.normalize(S, axis=1)\n    array([[-1.   ,  0.5  , -0.25 ,  0.125],\n           [-1.   ,  1.   , -1.   ,  1.   ],\n           [ 0.   ,  0.   ,  0.   ,  1.   ],\n           [ 1.   ,  1.   ,  1.   ,  1.   ]])\n    >>> # l1-normalize the columns\n    >>> librosa.util.normalize(S, norm=1)\n    array([[-0.8  ,  0.667, -0.5  ,  0.25 ],\n           [-0.1  ,  0.167, -0.25 ,  0.25 ],\n           [ 0.   ,  0.   ,  0.   ,  0.25 ],\n           [ 0.1  ,  0.167,  0.25 ,  0.25 ]])\n    >>> # l2-normalize the columns\n    >>> librosa.util.normalize(S, norm=2)\n    array([[-0.985,  0.943, -0.816,  0.5  ],\n           [-0.123,  0.236, -0.408,  0.5  ],\n           [ 0.   ,  0.   ,  0.   ,  0.5  ],\n           [ 0.123,  0.236,  0.408,  0.5  ]])\n\n    >>> # Thresholding and filling\n    >>> S[:, -1] = 1e-308\n    >>> S\n    array([[ -8.000e+000,   4.000e+000,  -2.000e+000,\n              1.000e-308],\n           [ -1.000e+000,   1.000e+000,  -1.000e+000,\n              1.000e-308],\n           [  0.000e+000,   0.000e+000,   0.000e+000,\n              1.000e-308],\n           [  1.000e+000,   1.000e+000,   1.000e+000,\n              1.000e-308]])\n\n    >>> # By default, small-norm columns are left untouched\n    >>> librosa.util.normalize(S)\n    array([[ -1.000e+000,   1.000e+000,  -1.000e+000,\n              1.000e-308],\n           [ -1.250e-001,   2.500e-001,  -5.000e-001,\n              1.000e-308],\n           [  0.000e+000,   0.000e+000,   0.000e+000,\n              1.000e-308],\n           [  1.250e-001,   2.500e-001,   5.000e-001,\n              1.000e-308]])\n    >>> # Small-norm columns can be zeroed out\n    >>> librosa.util.normalize(S, fill=False)\n    array([[-1.   ,  1.   , -1.   ,  0.   ],\n           [-0.125,  0.25 , -0.5  ,  0.   ],\n           [ 0.   ,  0.   ,  0.   ,  0.   ],\n           [ 0.125,  0.25 ,  0.5  ,  0.   ]])\n    >>> # Or set to constant with unit-norm\n    >>> librosa.util.normalize(S, fill=True)\n    array([[-1.   ,  1.   , -1.   ,  1.   ],\n           [-0.125,  0.25 , -0.5  ,  1.   ],\n           [ 0.   ,  0.   ,  0.   ,  1.   ],\n           [ 0.125,  0.25 ,  0.5  ,  1.   ]])\n    >>> # With an l1 norm instead of max-norm\n    >>> librosa.util.normalize(S, norm=1, fill=True)\n    array([[-0.8  ,  0.667, -0.5  ,  0.25 ],\n           [-0.1  ,  0.167, -0.25 ,  0.25 ],\n           [ 0.   ,  0.   ,  0.   ,  0.25 ],\n           [ 0.1  ,  0.167,  0.25 ,  0.25 ]])", "id": "f18165:m8"}
{"signature": "def buf_to_float(x, n_bytes=<NUM_LIT:2>, dtype=np.float32):", "body": "<EOL>scale = <NUM_LIT:1.>/float(<NUM_LIT:1> << ((<NUM_LIT:8> * n_bytes) - <NUM_LIT:1>))<EOL>fmt = '<STR_LIT>'.format(n_bytes)<EOL>return scale * np.frombuffer(x, fmt).astype(dtype)<EOL>", "docstring": "Convert an integer buffer to floating point values.\n    This is primarily useful when loading integer-valued wav data\n    into numpy arrays.\n\n    See Also\n    --------\n    buf_to_float\n\n    Parameters\n    ----------\n    x : np.ndarray [dtype=int]\n        The integer-valued data buffer\n\n    n_bytes : int [1, 2, 4]\n        The number of bytes per sample in `x`\n\n    dtype : numeric type\n        The target output type (default: 32-bit float)\n\n    Returns\n    -------\n    x_float : np.ndarray [dtype=float]\n        The input data buffer cast to floating point", "id": "f18165:m13"}
{"signature": "@numba.jit(nopython=True, cache=True)<EOL>def __match_intervals(intervals_from, intervals_to, strict=True):  ", "body": "<EOL>start_index = np.argsort(intervals_to[:, <NUM_LIT:0>])<EOL>end_index = np.argsort(intervals_to[:, <NUM_LIT:1>])<EOL>start_sorted = intervals_to[start_index, <NUM_LIT:0>]<EOL>end_sorted = intervals_to[end_index, <NUM_LIT:1>]<EOL>search_ends = np.searchsorted(start_sorted, intervals_from[:, <NUM_LIT:1>], side='<STR_LIT:right>')<EOL>search_starts = np.searchsorted(end_sorted, intervals_from[:, <NUM_LIT:0>], side='<STR_LIT:left>')<EOL>output = np.empty(len(intervals_from), dtype=numba.uint32)<EOL>for i in range(len(intervals_from)):<EOL><INDENT>query = intervals_from[i]<EOL>after_query = search_ends[i]<EOL>before_query = search_starts[i]<EOL>candidates = set(start_index[:after_query]) & set(end_index[before_query:])<EOL>if len(candidates) > <NUM_LIT:0>:<EOL><INDENT>output[i] = __match_interval_overlaps(query, intervals_to, candidates)<EOL><DEDENT>elif strict:<EOL><INDENT>raise ParameterError<EOL><DEDENT>else:<EOL><INDENT>dist_before = np.inf<EOL>dist_after = np.inf<EOL>if search_starts[i] > <NUM_LIT:0>:<EOL><INDENT>dist_before = query[<NUM_LIT:0>] - end_sorted[search_starts[i]-<NUM_LIT:1>]<EOL><DEDENT>if search_ends[i] + <NUM_LIT:1> < len(intervals_to):<EOL><INDENT>dist_after = start_sorted[search_ends[i]+<NUM_LIT:1>] - query[<NUM_LIT:1>]<EOL><DEDENT>if dist_before < dist_after:<EOL><INDENT>output[i] = end_index[search_starts[i]-<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>output[i] = start_index[search_ends[i]+<NUM_LIT:1>]<EOL><DEDENT><DEDENT><DEDENT>return output<EOL>", "docstring": "Numba-accelerated interval matching algorithm.", "id": "f18168:m2"}
{"signature": "def split(y, top_db=<NUM_LIT>, ref=np.max, frame_length=<NUM_LIT>, hop_length=<NUM_LIT>):", "body": "non_silent = _signal_to_frame_nonsilent(y,<EOL>frame_length=frame_length,<EOL>hop_length=hop_length,<EOL>ref=ref,<EOL>top_db=top_db)<EOL>edges = np.flatnonzero(np.diff(non_silent.astype(int)))<EOL>edges = [edges + <NUM_LIT:1>]<EOL>if non_silent[<NUM_LIT:0>]:<EOL><INDENT>edges.insert(<NUM_LIT:0>, [<NUM_LIT:0>])<EOL><DEDENT>if non_silent[-<NUM_LIT:1>]:<EOL><INDENT>edges.append([len(non_silent)])<EOL><DEDENT>edges = core.frames_to_samples(np.concatenate(edges),<EOL>hop_length=hop_length)<EOL>edges = np.minimum(edges, y.shape[-<NUM_LIT:1>])<EOL>return edges.reshape((-<NUM_LIT:1>, <NUM_LIT:2>))<EOL>", "docstring": "Split an audio signal into non-silent intervals.\n\n    Parameters\n    ----------\n    y : np.ndarray, shape=(n,) or (2, n)\n        An audio signal\n\n    top_db : number > 0\n        The threshold (in decibels) below reference to consider as\n        silence\n\n    ref : number or callable\n        The reference power.  By default, it uses `np.max` and compares\n        to the peak power in the signal.\n\n    frame_length : int > 0\n        The number of samples per analysis frame\n\n    hop_length : int > 0\n        The number of samples between analysis frames\n\n    Returns\n    -------\n    intervals : np.ndarray, shape=(m, 2)\n        `intervals[i] == (start_i, end_i)` are the start and end time\n        (in samples) of non-silent interval `i`.", "id": "f18171:m8"}
{"signature": "def remix(y, intervals, align_zeros=True):", "body": "<EOL>util.valid_audio(y, mono=False)<EOL>y_out = []<EOL>if align_zeros:<EOL><INDENT>y_mono = core.to_mono(y)<EOL>zeros = np.nonzero(core.zero_crossings(y_mono))[-<NUM_LIT:1>]<EOL>zeros = np.append(zeros, [len(y_mono)])<EOL><DEDENT>clip = [slice(None)] * y.ndim<EOL>for interval in intervals:<EOL><INDENT>if align_zeros:<EOL><INDENT>interval = zeros[util.match_events(interval, zeros)]<EOL><DEDENT>clip[-<NUM_LIT:1>] = slice(interval[<NUM_LIT:0>], interval[<NUM_LIT:1>])<EOL>y_out.append(y[tuple(clip)])<EOL><DEDENT>return np.concatenate(y_out, axis=-<NUM_LIT:1>)<EOL>", "docstring": "Remix an audio signal by re-ordering time intervals.\n\n\n    Parameters\n    ----------\n    y : np.ndarray [shape=(t,) or (2, t)]\n        Audio time series\n\n    intervals : iterable of tuples (start, end)\n        An iterable (list-like or generator) where the `i`th item\n        `intervals[i]` indicates the start and end (in samples)\n        of a slice of `y`.\n\n    align_zeros : boolean\n        If `True`, interval boundaries are mapped to the closest\n        zero-crossing in `y`.  If `y` is stereo, zero-crossings\n        are computed after converting to mono.\n\n\n    Returns\n    -------\n    y_remix : np.ndarray [shape=(d,) or (2, d)]\n        `y` remixed in the order specified by `intervals`\n\n\n    Examples\n    --------\n    Load in the example track and reverse the beats\n\n    >>> y, sr = librosa.load(librosa.util.example_audio_file())\n\n\n    Compute beats\n\n    >>> _, beat_frames = librosa.beat.beat_track(y=y, sr=sr,\n    ...                                          hop_length=512)\n\n\n    Convert from frames to sample indices\n\n    >>> beat_samples = librosa.frames_to_samples(beat_frames)\n\n\n    Generate intervals from consecutive events\n\n    >>> intervals = librosa.util.frame(beat_samples, frame_length=2,\n    ...                                hop_length=1).T\n\n\n    Reverse the beat intervals\n\n    >>> y_out = librosa.effects.remix(y, intervals[::-1])", "id": "f18171:m5"}
{"signature": "def path_enhance(R, n, window='<STR_LIT>', max_ratio=<NUM_LIT>, min_ratio=None, n_filters=<NUM_LIT:7>,<EOL>zero_mean=False, clip=True, **kwargs):", "body": "if min_ratio is None:<EOL><INDENT>min_ratio = <NUM_LIT:1.>/max_ratio<EOL><DEDENT>elif min_ratio > max_ratio:<EOL><INDENT>raise ParameterError('<STR_LIT>'.format(min_ratio, max_ratio))<EOL><DEDENT>R_smooth = None<EOL>for ratio in np.logspace(np.log2(min_ratio), np.log2(max_ratio), num=n_filters, base=<NUM_LIT:2>):<EOL><INDENT>kernel = diagonal_filter(window, n, slope=ratio, zero_mean=zero_mean)<EOL>if R_smooth is None:<EOL><INDENT>R_smooth = scipy.ndimage.convolve(R, kernel, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>np.maximum(R_smooth, scipy.ndimage.convolve(R, kernel, **kwargs),<EOL>out=R_smooth)<EOL><DEDENT><DEDENT>if clip:<EOL><INDENT>np.clip(R_smooth, <NUM_LIT:0>, None, out=R_smooth)<EOL><DEDENT>return R_smooth<EOL>", "docstring": "Multi-angle path enhancement for self- and cross-similarity matrices.\n\n    This function convolves multiple diagonal smoothing filters with a self-similarity (or\n    recurrence) matrix R, and aggregates the result by an element-wise maximum.\n\n    Technically, the output is a matrix R_smooth such that\n\n        `R_smooth[i, j] = max_theta (R * filter_theta)[i, j]`\n\n    where `*` denotes 2-dimensional convolution, and `filter_theta` is a smoothing filter at\n    orientation theta.\n\n    This is intended to provide coherent temporal smoothing of self-similarity matrices\n    when there are changes in tempo.\n\n    Smoothing filters are generated at evenly spaced orientations between min_ratio and\n    max_ratio.\n\n    This function is inspired by the multi-angle path enhancement of [1]_, but differs by\n    modeling tempo differences in the space of similarity matrices rather than re-sampling\n    the underlying features prior to generating the self-similarity matrix.\n\n    .. [1] M\u00fcller, Meinard and Frank Kurth.\n            \"Enhancing similarity matrices for music audio analysis.\"\n            2006 IEEE International Conference on Acoustics Speech and Signal Processing Proceedings.\n            Vol. 5. IEEE, 2006.\n\n    .. note:: if using recurrence_matrix to construct the input similarity matrix, be sure to include the main\n              diagonal by setting `self=True`.  Otherwise, the diagonal will be suppressed, and this is likely to\n              produce discontinuities which will pollute the smoothing filter response.\n\n    Parameters\n    ----------\n    R : np.ndarray\n        The self- or cross-similarity matrix to be smoothed.\n        Note: sparse inputs are not supported.\n\n    n : int > 0\n        The length of the smoothing filter\n\n    window : window specification\n        The type of smoothing filter to use.  See `filters.get_window` for more information\n        on window specification formats.\n\n    max_ratio : float > 0\n        The maximum tempo ratio to support\n\n    min_ratio : float > 0\n        The minimum tempo ratio to support.\n        If not provided, it will default to `1/max_ratio`\n\n    n_filters : int >= 1\n        The number of different smoothing filters to use, evenly spaced\n        between `min_ratio` and `max_ratio`.\n\n        If `min_ratio = 1/max_ratio` (the default), using an odd number\n        of filters will ensure that the main diagonal (ratio=1) is included.\n\n    zero_mean : bool\n        By default, the smoothing filters are non-negative and sum to one (i.e. are averaging\n        filters).\n\n        If `zero_mean=True`, then the smoothing filters are made to sum to zero by subtracting\n        a constant value from the non-diagonal coordinates of the filter.  This is primarily\n        useful for suppressing blocks while enhancing diagonals.\n\n    clip : bool\n        If True, the smoothed similarity matrix will be thresholded at 0, and will not contain\n        negative entries.\n\n    kwargs : additional keyword arguments\n        Additional arguments to pass to `scipy.ndimage.convolve`\n\n\n    Returns\n    -------\n    R_smooth : np.ndarray, shape=R.shape\n        The smoothed self- or cross-similarity matrix\n\n    See Also\n    --------\n    filters.diagonal_filter\n    recurrence_matrix\n\n\n    Examples\n    --------\n    Use a 51-frame diagonal smoothing filter to enhance paths in a recurrence matrix\n\n    >>> y, sr = librosa.load(librosa.util.example_audio_file(), duration=30)\n    >>> chroma = librosa.feature.chroma_cqt(y=y, sr=sr)\n    >>> rec = librosa.segment.recurrence_matrix(chroma, mode='affinity', self=True)\n    >>> rec_smooth = librosa.segment.path_enhance(rec, 51, window='hann', n_filters=7)\n\n    Plot the recurrence matrix before and after smoothing\n\n    >>> import matplotlib.pyplot as plt\n    >>> plt.figure(figsize=(8, 4))\n    >>> plt.subplot(1,2,1)\n    >>> librosa.display.specshow(rec, x_axis='time', y_axis='time')\n    >>> plt.title('Unfiltered recurrence')\n    >>> plt.subplot(1,2,2)\n    >>> librosa.display.specshow(rec_smooth, x_axis='time', y_axis='time')\n    >>> plt.title('Multi-angle enhanced recurrence')\n    >>> plt.tight_layout()", "id": "f18172:m6"}
{"signature": "def recurrence_to_lag(rec, pad=True, axis=-<NUM_LIT:1>):", "body": "axis = np.abs(axis)<EOL>if rec.ndim != <NUM_LIT:2> or rec.shape[<NUM_LIT:0>] != rec.shape[<NUM_LIT:1>]:<EOL><INDENT>raise ParameterError('<STR_LIT>'<EOL>'<STR_LIT:{}>'.format(rec.shape))<EOL><DEDENT>sparse = scipy.sparse.issparse(rec)<EOL>roll_ax = None<EOL>if sparse:<EOL><INDENT>roll_ax = <NUM_LIT:1> - axis<EOL>lag_format = rec.format<EOL>if axis == <NUM_LIT:0>:<EOL><INDENT>rec = rec.tocsc()<EOL><DEDENT>elif axis in (-<NUM_LIT:1>, <NUM_LIT:1>):<EOL><INDENT>rec = rec.tocsr()<EOL><DEDENT><DEDENT>t = rec.shape[axis]<EOL>if sparse:<EOL><INDENT>if pad:<EOL><INDENT>kron = np.asarray([[<NUM_LIT:1>, <NUM_LIT:0>]]).swapaxes(axis, <NUM_LIT:0>)<EOL>lag = scipy.sparse.kron(kron.astype(rec.dtype), rec, format='<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>lag = scipy.sparse.lil_matrix(rec)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if pad:<EOL><INDENT>padding = [(<NUM_LIT:0>, <NUM_LIT:0>), (<NUM_LIT:0>, <NUM_LIT:0>)]<EOL>padding[(<NUM_LIT:1>-axis)] = (<NUM_LIT:0>, t)<EOL>lag = np.pad(rec, padding, mode='<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>lag = rec.copy()<EOL><DEDENT><DEDENT>idx_slice = [slice(None)] * lag.ndim<EOL>for i in range(<NUM_LIT:1>, t):<EOL><INDENT>idx_slice[axis] = i<EOL>lag[tuple(idx_slice)] = util.roll_sparse(lag[tuple(idx_slice)], -i, axis=roll_ax)<EOL><DEDENT>if sparse:<EOL><INDENT>return lag.asformat(lag_format)<EOL><DEDENT>return np.ascontiguousarray(lag.T).T<EOL>", "docstring": "Convert a recurrence matrix into a lag matrix.\n\n        `lag[i, j] == rec[i+j, j]`\n\n    Parameters\n    ----------\n    rec : np.ndarray, or scipy.sparse.spmatrix [shape=(n, n)]\n        A (binary) recurrence matrix, as returned by `recurrence_matrix`\n\n    pad : bool\n        If False, `lag` matrix is square, which is equivalent to\n        assuming that the signal repeats itself indefinitely.\n\n        If True, `lag` is padded with `n` zeros, which eliminates\n        the assumption of repetition.\n\n    axis : int\n        The axis to keep as the `time` axis.\n        The alternate axis will be converted to lag coordinates.\n\n    Returns\n    -------\n    lag : np.ndarray\n        The recurrence matrix in (lag, time) (if `axis=1`)\n        or (time, lag) (if `axis=0`) coordinates\n\n    Raises\n    ------\n    ParameterError : if `rec` is non-square\n\n    See Also\n    --------\n    recurrence_matrix\n    lag_to_recurrence\n\n    Examples\n    --------\n    >>> y, sr = librosa.load(librosa.util.example_audio_file())\n    >>> mfccs = librosa.feature.mfcc(y=y, sr=sr)\n    >>> recurrence = librosa.segment.recurrence_matrix(mfccs)\n    >>> lag_pad = librosa.segment.recurrence_to_lag(recurrence, pad=True)\n    >>> lag_nopad = librosa.segment.recurrence_to_lag(recurrence, pad=False)\n\n    >>> import matplotlib.pyplot as plt\n    >>> plt.figure(figsize=(8, 4))\n    >>> plt.subplot(1, 2, 1)\n    >>> librosa.display.specshow(lag_pad, x_axis='time', y_axis='lag')\n    >>> plt.title('Lag (zero-padded)')\n    >>> plt.subplot(1, 2, 2)\n    >>> librosa.display.specshow(lag_nopad, x_axis='time')\n    >>> plt.title('Lag (no padding)')\n    >>> plt.tight_layout()", "id": "f18172:m1"}
{"signature": "def timelag_filter(function, pad=True, index=<NUM_LIT:0>):", "body": "def __my_filter(wrapped_f, *args, **kwargs):<EOL><INDENT>'''<STR_LIT>'''<EOL>args = list(args)<EOL>args[index] = recurrence_to_lag(args[index], pad=pad)<EOL>result = wrapped_f(*args, **kwargs)<EOL>return lag_to_recurrence(result)<EOL><DEDENT>return decorator(__my_filter, function)<EOL>", "docstring": "Filtering in the time-lag domain.\n\n    This is primarily useful for adapting image filters to operate on\n    `recurrence_to_lag` output.\n\n    Using `timelag_filter` is equivalent to the following sequence of\n    operations:\n\n    >>> data_tl = librosa.segment.recurrence_to_lag(data)\n    >>> data_filtered_tl = function(data_tl)\n    >>> data_filtered = librosa.segment.lag_to_recurrence(data_filtered_tl)\n\n    Parameters\n    ----------\n    function : callable\n        The filtering function to wrap, e.g., `scipy.ndimage.median_filter`\n\n    pad : bool\n        Whether to zero-pad the structure feature matrix\n\n    index : int >= 0\n        If `function` accepts input data as a positional argument, it should be\n        indexed by `index`\n\n\n    Returns\n    -------\n    wrapped_function : callable\n        A new filter function which applies in time-lag space rather than\n        time-time space.\n\n\n    Examples\n    --------\n\n    Apply a 5-bin median filter to the diagonal of a recurrence matrix\n\n    >>> y, sr = librosa.load(librosa.util.example_audio_file())\n    >>> chroma = librosa.feature.chroma_cqt(y=y, sr=sr)\n    >>> rec = librosa.segment.recurrence_matrix(chroma)\n    >>> from scipy.ndimage import median_filter\n    >>> diagonal_median = librosa.segment.timelag_filter(median_filter)\n    >>> rec_filtered = diagonal_median(rec, size=(1, 3), mode='mirror')\n\n    Or with affinity weights\n\n    >>> rec_aff = librosa.segment.recurrence_matrix(chroma, mode='affinity')\n    >>> rec_aff_fil = diagonal_median(rec_aff, size=(1, 3), mode='mirror')\n\n    >>> import matplotlib.pyplot as plt\n    >>> plt.figure(figsize=(8,8))\n    >>> plt.subplot(2, 2, 1)\n    >>> librosa.display.specshow(rec, y_axis='time')\n    >>> plt.title('Raw recurrence matrix')\n    >>> plt.subplot(2, 2, 2)\n    >>> librosa.display.specshow(rec_filtered)\n    >>> plt.title('Filtered recurrence matrix')\n    >>> plt.subplot(2, 2, 3)\n    >>> librosa.display.specshow(rec_aff, x_axis='time', y_axis='time',\n    ...                          cmap='magma_r')\n    >>> plt.title('Raw affinity matrix')\n    >>> plt.subplot(2, 2, 4)\n    >>> librosa.display.specshow(rec_aff_fil, x_axis='time',\n    ...                          cmap='magma_r')\n    >>> plt.title('Filtered affinity matrix')\n    >>> plt.tight_layout()", "id": "f18172:m3"}
{"signature": "def spectral_rolloff(y=None, sr=<NUM_LIT>, S=None, n_fft=<NUM_LIT>, hop_length=<NUM_LIT>,<EOL>win_length=None, window='<STR_LIT>', center=True, pad_mode='<STR_LIT>',<EOL>freq=None, roll_percent=<NUM_LIT>):", "body": "if not <NUM_LIT:0.0> < roll_percent < <NUM_LIT:1.0>:<EOL><INDENT>raise ParameterError('<STR_LIT>')<EOL><DEDENT>S, n_fft = _spectrogram(y=y, S=S, n_fft=n_fft, hop_length=hop_length,<EOL>win_length=win_length, window=window, center=center,<EOL>pad_mode=pad_mode)<EOL>if not np.isrealobj(S):<EOL><INDENT>raise ParameterError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>elif np.any(S < <NUM_LIT:0>):<EOL><INDENT>raise ParameterError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>if freq is None:<EOL><INDENT>freq = fft_frequencies(sr=sr, n_fft=n_fft)<EOL><DEDENT>if freq.ndim == <NUM_LIT:1>:<EOL><INDENT>freq = freq.reshape((-<NUM_LIT:1>, <NUM_LIT:1>))<EOL><DEDENT>total_energy = np.cumsum(S, axis=<NUM_LIT:0>)<EOL>threshold = roll_percent * total_energy[-<NUM_LIT:1>]<EOL>ind = np.where(total_energy < threshold, np.nan, <NUM_LIT:1>)<EOL>return np.nanmin(ind * freq, axis=<NUM_LIT:0>, keepdims=True)<EOL>", "docstring": "Compute roll-off frequency.\n\n    The roll-off frequency is defined for each frame as the center frequency\n    for a spectrogram bin such that at least roll_percent (0.85 by default)\n    of the energy of the spectrum in this frame is contained in this bin and\n    the bins below. This can be used to, e.g., approximate the maximum (or\n    minimum) frequency by setting roll_percent to a value close to 1 (or 0).\n\n    Parameters\n    ----------\n    y : np.ndarray [shape=(n,)] or None\n        audio time series\n\n    sr : number > 0 [scalar]\n        audio sampling rate of `y`\n\n    S : np.ndarray [shape=(d, t)] or None\n        (optional) spectrogram magnitude\n\n    n_fft : int > 0 [scalar]\n        FFT window size\n\n    hop_length : int > 0 [scalar]\n        hop length for STFT. See `librosa.core.stft` for details.\n\n    win_length : int <= n_fft [scalar]\n        Each frame of audio is windowed by `window()`.\n        The window will be of length `win_length` and then padded\n        with zeros to match `n_fft`.\n\n        If unspecified, defaults to ``win_length = n_fft``.\n\n    window : string, tuple, number, function, or np.ndarray [shape=(n_fft,)]\n        - a window specification (string, tuple, or number);\n          see `scipy.signal.get_window`\n        - a window function, such as `scipy.signal.hanning`\n        - a vector or array of length `n_fft`\n\n        .. see also:: `filters.get_window`\n\n    center : boolean\n        - If `True`, the signal `y` is padded so that frame\n          `t` is centered at `y[t * hop_length]`.\n        - If `False`, then frame `t` begins at `y[t * hop_length]`\n\n    pad_mode : string\n        If `center=True`, the padding mode to use at the edges of the signal.\n        By default, STFT uses reflection padding.\n\n    freq : None or np.ndarray [shape=(d,) or shape=(d, t)]\n        Center frequencies for spectrogram bins.\n        If `None`, then FFT bin center frequencies are used.\n        Otherwise, it can be a single array of `d` center frequencies,\n\n        .. note:: `freq` is assumed to be sorted in increasing order\n\n    roll_percent : float [0 < roll_percent < 1]\n        Roll-off percentage.\n\n    Returns\n    -------\n    rolloff : np.ndarray [shape=(1, t)]\n        roll-off frequency for each frame\n\n\n    Examples\n    --------\n    From time-series input\n\n    >>> y, sr = librosa.load(librosa.util.example_audio_file())\n    >>> # Approximate maximum frequencies with roll_percent=0.85 (default)\n    >>> rolloff = librosa.feature.spectral_rolloff(y=y, sr=sr)\n    >>> rolloff\n    array([[ 8376.416,   968.994, ...,  8925.513,  9108.545]])\n    >>> # Approximate minimum frequencies with roll_percent=0.1\n    >>> rolloff = librosa.feature.spectral_rolloff(y=y, sr=sr, roll_percent=0.1)\n    >>> rolloff\n    array([[ 75.36621094,  64.59960938,  64.59960938, ...,  75.36621094,\n         75.36621094,  64.59960938]])\n\n\n    From spectrogram input\n\n    >>> S, phase = librosa.magphase(librosa.stft(y))\n    >>> librosa.feature.spectral_rolloff(S=S, sr=sr)\n    array([[ 8376.416,   968.994, ...,  8925.513,  9108.545]])\n\n    >>> # With a higher roll percentage:\n    >>> y, sr = librosa.load(librosa.util.example_audio_file())\n    >>> librosa.feature.spectral_rolloff(y=y, sr=sr, roll_percent=0.95)\n    array([[ 10012.939,   3003.882, ...,  10034.473,  10077.539]])\n\n    >>> import matplotlib.pyplot as plt\n    >>> plt.figure()\n    >>> plt.subplot(2, 1, 1)\n    >>> plt.semilogy(rolloff.T, label='Roll-off frequency')\n    >>> plt.ylabel('Hz')\n    >>> plt.xticks([])\n    >>> plt.xlim([0, rolloff.shape[-1]])\n    >>> plt.legend()\n    >>> plt.subplot(2, 1, 2)\n    >>> librosa.display.specshow(librosa.amplitude_to_db(S, ref=np.max),\n    ...                          y_axis='log', x_axis='time')\n    >>> plt.title('log Power spectrogram')\n    >>> plt.tight_layout()", "id": "f18173:m3"}
{"signature": "def rms(y=None, S=None, frame_length=<NUM_LIT>, hop_length=<NUM_LIT>,<EOL>center=True, pad_mode='<STR_LIT>'):", "body": "if y is not None and S is not None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if y is not None:<EOL><INDENT>y = to_mono(y)<EOL>if center:<EOL><INDENT>y = np.pad(y, int(frame_length // <NUM_LIT:2>), mode=pad_mode)<EOL><DEDENT>x = util.frame(y,<EOL>frame_length=frame_length,<EOL>hop_length=hop_length)<EOL><DEDENT>elif S is not None:<EOL><INDENT>x, _ = _spectrogram(y=y, S=S,<EOL>n_fft=frame_length,<EOL>hop_length=hop_length)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return np.sqrt(np.mean(np.abs(x)**<NUM_LIT:2>, axis=<NUM_LIT:0>, keepdims=True))<EOL>", "docstring": "Compute root-mean-square (RMS) value for each frame, either from the\n    audio samples `y` or from a spectrogram `S`.\n\n    Computing the RMS value from audio samples is faster as it doesn't require\n    a STFT calculation. However, using a spectrogram will give a more accurate\n    representation of energy over time because its frames can be windowed,\n    thus prefer using `S` if it's already available.\n\n\n    Parameters\n    ----------\n    y : np.ndarray [shape=(n,)] or None\n        (optional) audio time series. Required if `S` is not input.\n\n    S : np.ndarray [shape=(d, t)] or None\n        (optional) spectrogram magnitude. Required if `y` is not input.\n\n    frame_length : int > 0 [scalar]\n        length of analysis frame (in samples) for energy calculation\n\n    hop_length : int > 0 [scalar]\n        hop length for STFT. See `librosa.core.stft` for details.\n\n    center : bool\n        If `True` and operating on time-domain input (`y`), pad the signal\n        by `frame_length//2` on either side.\n\n        If operating on spectrogram input, this has no effect.\n\n    pad_mode : str\n        Padding mode for centered analysis.  See `np.pad` for valid\n        values.\n\n    Returns\n    -------\n    rms : np.ndarray [shape=(1, t)]\n        RMS value for each frame\n\n\n    Examples\n    --------\n    >>> y, sr = librosa.load(librosa.util.example_audio_file())\n    >>> librosa.feature.rms(y=y)\n    array([[ 0.   ,  0.056, ...,  0.   ,  0.   ]], dtype=float32)\n\n    Or from spectrogram input\n\n    >>> S, phase = librosa.magphase(librosa.stft(y))\n    >>> rms = librosa.feature.rms(S=S)\n\n    >>> import matplotlib.pyplot as plt\n    >>> plt.figure()\n    >>> plt.subplot(2, 1, 1)\n    >>> plt.semilogy(rms.T, label='RMS Energy')\n    >>> plt.xticks([])\n    >>> plt.xlim([0, rms.shape[-1]])\n    >>> plt.legend(loc='best')\n    >>> plt.subplot(2, 1, 2)\n    >>> librosa.display.specshow(librosa.amplitude_to_db(S, ref=np.max),\n    ...                          y_axis='log', x_axis='time')\n    >>> plt.title('log Power spectrogram')\n    >>> plt.tight_layout()\n\n    Use a STFT window of constant ones and no frame centering to get consistent\n    results with the RMS computed from the audio samples `y`\n\n    >>> S = librosa.magphase(librosa.stft(y, window=np.ones, center=False))[0]\n    >>> librosa.feature.rms(S=S)", "id": "f18173:m5"}
{"signature": "def spectral_bandwidth(y=None, sr=<NUM_LIT>, S=None, n_fft=<NUM_LIT>, hop_length=<NUM_LIT>,<EOL>win_length=None, window='<STR_LIT>', center=True, pad_mode='<STR_LIT>',<EOL>freq=None, centroid=None, norm=True, p=<NUM_LIT:2>):", "body": "S, n_fft = _spectrogram(y=y, S=S, n_fft=n_fft, hop_length=hop_length,<EOL>win_length=win_length, window=window, center=center,<EOL>pad_mode=pad_mode)<EOL>if not np.isrealobj(S):<EOL><INDENT>raise ParameterError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>elif np.any(S < <NUM_LIT:0>):<EOL><INDENT>raise ParameterError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>if centroid is None:<EOL><INDENT>centroid = spectral_centroid(y=y, sr=sr, S=S,<EOL>n_fft=n_fft,<EOL>hop_length=hop_length,<EOL>freq=freq)<EOL><DEDENT>if freq is None:<EOL><INDENT>freq = fft_frequencies(sr=sr, n_fft=n_fft)<EOL><DEDENT>if freq.ndim == <NUM_LIT:1>:<EOL><INDENT>deviation = np.abs(np.subtract.outer(freq, centroid[<NUM_LIT:0>]))<EOL><DEDENT>else:<EOL><INDENT>deviation = np.abs(freq - centroid[<NUM_LIT:0>])<EOL><DEDENT>if norm:<EOL><INDENT>S = util.normalize(S, norm=<NUM_LIT:1>, axis=<NUM_LIT:0>)<EOL><DEDENT>return np.sum(S * deviation**p, axis=<NUM_LIT:0>, keepdims=True)**(<NUM_LIT:1.>/p)<EOL>", "docstring": "Compute p'th-order spectral bandwidth:\n\n        (sum_k S[k] * (freq[k] - centroid)**p)**(1/p)\n\n    Parameters\n    ----------\n    y : np.ndarray [shape=(n,)] or None\n        audio time series\n\n    sr : number > 0 [scalar]\n        audio sampling rate of `y`\n\n    S : np.ndarray [shape=(d, t)] or None\n        (optional) spectrogram magnitude\n\n    n_fft : int > 0 [scalar]\n        FFT window size\n\n    hop_length : int > 0 [scalar]\n        hop length for STFT. See `librosa.core.stft` for details.\n\n    win_length : int <= n_fft [scalar]\n        Each frame of audio is windowed by `window()`.\n        The window will be of length `win_length` and then padded\n        with zeros to match `n_fft`.\n\n        If unspecified, defaults to ``win_length = n_fft``.\n\n    window : string, tuple, number, function, or np.ndarray [shape=(n_fft,)]\n        - a window specification (string, tuple, or number);\n          see `scipy.signal.get_window`\n        - a window function, such as `scipy.signal.hanning`\n        - a vector or array of length `n_fft`\n\n        .. see also:: `filters.get_window`\n\n    center : boolean\n        - If `True`, the signal `y` is padded so that frame\n          `t` is centered at `y[t * hop_length]`.\n        - If `False`, then frame `t` begins at `y[t * hop_length]`\n\n    pad_mode : string\n        If `center=True`, the padding mode to use at the edges of the signal.\n        By default, STFT uses reflection padding.\n\n    freq : None or np.ndarray [shape=(d,) or shape=(d, t)]\n        Center frequencies for spectrogram bins.\n        If `None`, then FFT bin center frequencies are used.\n        Otherwise, it can be a single array of `d` center frequencies,\n        or a matrix of center frequencies as constructed by\n        `librosa.core.ifgram`\n\n    centroid : None or np.ndarray [shape=(1, t)]\n        pre-computed centroid frequencies\n\n    norm : bool\n        Normalize per-frame spectral energy (sum to one)\n\n    p : float > 0\n        Power to raise deviation from spectral centroid.\n\n\n    Returns\n    -------\n    bandwidth : np.ndarray [shape=(1, t)]\n        frequency bandwidth for each frame\n\n\n    Examples\n    --------\n    From time-series input\n\n    >>> y, sr = librosa.load(librosa.util.example_audio_file())\n    >>> spec_bw = librosa.feature.spectral_bandwidth(y=y, sr=sr)\n    >>> spec_bw\n    array([[ 3379.878,  1429.486, ...,  3235.214,  3080.148]])\n\n    From spectrogram input\n\n    >>> S, phase = librosa.magphase(librosa.stft(y=y))\n    >>> librosa.feature.spectral_bandwidth(S=S)\n    array([[ 3379.878,  1429.486, ...,  3235.214,  3080.148]])\n\n    Using variable bin center frequencies\n\n    >>> if_gram, D = librosa.ifgram(y)\n    >>> librosa.feature.spectral_bandwidth(S=np.abs(D), freq=if_gram)\n    array([[ 3380.011,  1429.11 , ...,  3235.22 ,  3080.148]])\n\n    Plot the result\n\n    >>> import matplotlib.pyplot as plt\n    >>> plt.figure()\n    >>> plt.subplot(2, 1, 1)\n    >>> plt.semilogy(spec_bw.T, label='Spectral bandwidth')\n    >>> plt.ylabel('Hz')\n    >>> plt.xticks([])\n    >>> plt.xlim([0, spec_bw.shape[-1]])\n    >>> plt.legend()\n    >>> plt.subplot(2, 1, 2)\n    >>> librosa.display.specshow(librosa.amplitude_to_db(S, ref=np.max),\n    ...                          y_axis='log', x_axis='time')\n    >>> plt.title('log Power spectrogram')\n    >>> plt.tight_layout()", "id": "f18173:m1"}
{"signature": "def mfcc(y=None, sr=<NUM_LIT>, S=None, n_mfcc=<NUM_LIT:20>, dct_type=<NUM_LIT:2>, norm='<STR_LIT>', **kwargs):", "body": "if S is None:<EOL><INDENT>S = power_to_db(melspectrogram(y=y, sr=sr, **kwargs))<EOL><DEDENT>return scipy.fftpack.dct(S, axis=<NUM_LIT:0>, type=dct_type, norm=norm)[:n_mfcc]<EOL>", "docstring": "Mel-frequency cepstral coefficients (MFCCs)\n\n    Parameters\n    ----------\n    y : np.ndarray [shape=(n,)] or None\n        audio time series\n\n    sr : number > 0 [scalar]\n        sampling rate of `y`\n\n    S : np.ndarray [shape=(d, t)] or None\n        log-power Mel spectrogram\n\n    n_mfcc: int > 0 [scalar]\n        number of MFCCs to return\n\n    dct_type : None, or {1, 2, 3}\n        Discrete cosine transform (DCT) type.\n        By default, DCT type-2 is used.\n\n    norm : None or 'ortho'\n        If `dct_type` is `2 or 3`, setting `norm='ortho'` uses an ortho-normal\n        DCT basis.\n\n        Normalization is not supported for `dct_type=1`.\n\n    kwargs : additional keyword arguments\n        Arguments to `melspectrogram`, if operating\n        on time series input\n\n    Returns\n    -------\n    M : np.ndarray [shape=(n_mfcc, t)]\n        MFCC sequence\n\n    See Also\n    --------\n    melspectrogram\n    scipy.fftpack.dct\n\n    Examples\n    --------\n    Generate mfccs from a time series\n\n    >>> y, sr = librosa.load(librosa.util.example_audio_file(), offset=30, duration=5)\n    >>> librosa.feature.mfcc(y=y, sr=sr)\n    array([[ -5.229e+02,  -4.944e+02, ...,  -5.229e+02,  -5.229e+02],\n           [  7.105e-15,   3.787e+01, ...,  -7.105e-15,  -7.105e-15],\n           ...,\n           [  1.066e-14,  -7.500e+00, ...,   1.421e-14,   1.421e-14],\n           [  3.109e-14,  -5.058e+00, ...,   2.931e-14,   2.931e-14]])\n\n    Use a pre-computed log-power Mel spectrogram\n\n    >>> S = librosa.feature.melspectrogram(y=y, sr=sr, n_mels=128,\n    ...                                    fmax=8000)\n    >>> librosa.feature.mfcc(S=librosa.power_to_db(S))\n    array([[ -5.207e+02,  -4.898e+02, ...,  -5.207e+02,  -5.207e+02],\n           [ -2.576e-14,   4.054e+01, ...,  -3.997e-14,  -3.997e-14],\n           ...,\n           [  7.105e-15,  -3.534e+00, ...,   0.000e+00,   0.000e+00],\n           [  3.020e-14,  -2.613e+00, ...,   3.553e-14,   3.553e-14]])\n\n    Get more components\n\n    >>> mfccs = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=40)\n\n    Visualize the MFCC series\n\n    >>> import matplotlib.pyplot as plt\n    >>> plt.figure(figsize=(10, 4))\n    >>> librosa.display.specshow(mfccs, x_axis='time')\n    >>> plt.colorbar()\n    >>> plt.title('MFCC')\n    >>> plt.tight_layout()\n\n    Compare different DCT bases\n\n    >>> m_slaney = librosa.feature.mfcc(y=y, sr=sr, dct_type=2)\n    >>> m_htk = librosa.feature.mfcc(y=y, sr=sr, dct_type=3)\n    >>> plt.figure(figsize=(10, 6))\n    >>> plt.subplot(2, 1, 1)\n    >>> librosa.display.specshow(m_slaney, x_axis='time')\n    >>> plt.title('RASTAMAT / Auditory toolbox (dct_type=2)')\n    >>> plt.colorbar()\n    >>> plt.subplot(2, 1, 2)\n    >>> librosa.display.specshow(m_htk, x_axis='time')\n    >>> plt.title('HTK-style (dct_type=3)')\n    >>> plt.colorbar()\n    >>> plt.tight_layout()", "id": "f18173:m12"}
{"signature": "@classmethod<EOL><INDENT>def create_topic(cls, client, name='<STR_LIT>'):<DEDENT>", "body": "data = {<EOL>'<STR_LIT:name>': name<EOL>}<EOL>url = reverse('<STR_LIT>')<EOL>return client.post(url, data, format='<STR_LIT>')<EOL>", "docstring": "Create a dummy topic instance", "id": "f18206:c0:m11"}
{"signature": "@classmethod<EOL><INDENT>def create_invite(cls, client, email, person=None, permissions='<STR_LIT>'):<DEDENT>", "body": "if person is None:<EOL><INDENT>person = cls.create_person(client, full_name='<STR_LIT>')<EOL><DEDENT>url = reverse('<STR_LIT>')<EOL>data = {<EOL>'<STR_LIT:email>': email,<EOL>'<STR_LIT>': permissions,<EOL>'<STR_LIT>': person.data['<STR_LIT:id>']<EOL>}<EOL>return client.post(url, data, format='<STR_LIT>')<EOL>", "docstring": "Create dummy invite instance", "id": "f18206:c0:m13"}
{"signature": "def is_valid_slug(slug):", "body": "return slug_re.match(slug)<EOL>", "docstring": "Uses Django's slug regex to test if id is valid", "id": "f18220:m0"}
{"signature": "def validate(self, data):", "body": "raise NotImplementedError<EOL>", "docstring": "Validates the field data", "id": "f18221:c1:m1"}
{"signature": "def render(self, data=None, add_context=None):", "body": "template = loader.get_template(self.template)<EOL>if not data:<EOL><INDENT>data = self.context(self.prepare_data())<EOL><DEDENT>if add_context is not None:<EOL><INDENT>for key, value in add_context.iteritems():<EOL><INDENT>if key in self.accepted_keywords:<EOL><INDENT>data[key] = value<EOL><DEDENT><DEDENT><DEDENT>return template.render(data)<EOL>", "docstring": "Renders the widget as HTML.", "id": "f18223:c2:m5"}
{"signature": "def prepare_data(self):", "body": "result = {}<EOL>for field in self.fields:<EOL><INDENT>data = self.data.get(field.name)<EOL>result[field.name] = field.prepare_data(data)<EOL><DEDENT>return result<EOL>", "docstring": "Prepare widget data for template.", "id": "f18223:c2:m4"}
{"signature": "def serialize(self, instance):", "body": "return ImageGallerySerializer(instance).data<EOL>", "docstring": "Return serialized image gallery data.", "id": "f18256:c17:m0"}
{"signature": "def to_internal_value(self, content):", "body": "return map(self.sanitize_block, content)<EOL>", "docstring": "Convert each block in `content` to its internal value before saving.", "id": "f18256:c18:m2"}
{"signature": "def queue_data(self, content):", "body": "for block in content:<EOL><INDENT>self.queue_instance(block['<STR_LIT:type>'], block['<STR_LIT:data>'])<EOL><DEDENT>", "docstring": "Queue data to be loaded for each embed block.", "id": "f18256:c18:m7"}
{"signature": "def load_data(self):", "body": "for embed_type in self.ids.keys():<EOL><INDENT>self.load_instances(embed_type, self.ids[embed_type])<EOL><DEDENT>", "docstring": "Load data in bulk for each embed block.", "id": "f18256:c18:m8"}
{"signature": "def AuthorValidator(data):", "body": "if not isinstance(data, list):<EOL><INDENT>data = [data]<EOL><DEDENT>for author in data:<EOL><INDENT>if '<STR_LIT>' not in author:<EOL><INDENT>raise ValidationError('<STR_LIT>')<EOL><DEDENT>if '<STR_LIT:type>' in author and not isinstance(author['<STR_LIT:type>'], basestring):<EOL><INDENT>raise ValidationError('<STR_LIT>')<EOL><DEDENT><DEDENT>", "docstring": "Raise a ValidationError if data does not match the author format.", "id": "f18257:m4"}
{"signature": "def get_queryset(self):", "body": "<EOL>queryset = self.get_publishable_queryset()<EOL>queryset = queryset.order_by('<STR_LIT>')<EOL>q = self.request.query_params.get('<STR_LIT:q>')<EOL>if q:<EOL><INDENT>queryset = queryset.filter(title__icontains=q)<EOL><DEDENT>return queryset<EOL>", "docstring": "Only display unpublished content to authenticated users, filter by\n        query parameter if present.", "id": "f18258:c4:m0"}
{"signature": "def get_queryset(self):", "body": "<EOL>queryset = self.get_publishable_queryset()<EOL>queryset = queryset.select_related('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>').prefetch_related(<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'<EOL>)<EOL>queryset = queryset.order_by('<STR_LIT>')<EOL>q = self.request.query_params.get('<STR_LIT:q>', None)<EOL>section = self.request.query_params.get('<STR_LIT>', None)<EOL>tags = self.request.query_params.getlist('<STR_LIT>', None)<EOL>author = self.request.query_params.get('<STR_LIT>', None)<EOL>if q is not None:<EOL><INDENT>queryset = queryset.filter(headline__icontains=q)<EOL><DEDENT>if section is not None:<EOL><INDENT>queryset = queryset.filter(section_id=section)<EOL><DEDENT>if tags is not None:<EOL><INDENT>for tag in tags:<EOL><INDENT>queryset = queryset.filter(tags__id=tag)<EOL><DEDENT><DEDENT>if author is not None:<EOL><INDENT>queryset = queryset.filter(authors__person_id=author)<EOL><DEDENT>return queryset<EOL>", "docstring": "Optionally restricts the returned articles by filtering against a `topic`\n        query parameter in the URL.", "id": "f18258:c2:m0"}
{"signature": "def get_attribute(self, instance):", "body": "attr = super(NullBooleanField, self).get_attribute(instance)<EOL>return True if attr else False<EOL>", "docstring": "Overrides the default get_attribute method to convert None values to False.", "id": "f18259:c1:m0"}
{"signature": "@classmethod<EOL><INDENT>def update_settings(cls, settings):<DEDENT>", "body": "return Integration.objects.update_settings(cls.ID, settings)<EOL>", "docstring": "Updates setting for this integration with the given name.", "id": "f18269:c3:m1"}
{"signature": "def get_filename(self):", "body": "return os.path.basename(self.img.name)<EOL>", "docstring": "Returns the image filename.", "id": "f18273:c9:m1"}
{"signature": "def get_vote_count(self):", "body": "return PollVote.objects.filter(answer=self).count()<EOL>", "docstring": "Return the number of votes for this answer", "id": "f18273:c16:m0"}
{"signature": "def get_absolute_url(self):", "body": "return settings.MEDIA_URL + str(self.file)<EOL>", "docstring": "Returns the absolute file URL.", "id": "f18273:c13:m0"}
{"signature": "def is_gif(self):", "body": "return self.get_extension() in self.GIF_FORMATS<EOL>", "docstring": "Returns true if image is a gif.", "id": "f18273:c9:m0"}
{"signature": "def get_name(self):", "body": "return os.path.splitext(self.img.name)[<NUM_LIT:0>]<EOL>", "docstring": "Returns the filename without its extension.", "id": "f18273:c9:m2"}
{"signature": "def modify_permissions(self, permissions):", "body": "group = Group.objects.get(name='<STR_LIT>')<EOL>if permissions == '<STR_LIT>':<EOL><INDENT>self.groups.add(group)<EOL><DEDENT>else:<EOL><INDENT>self.groups.remove(group)<EOL><DEDENT>", "docstring": "Modify the user's permissions.", "id": "f18277:c1:m1"}
{"signature": "def _seconds(jd):", "body": "return (jd - T0) * S_PER_DAY<EOL>", "docstring": "Convert a Julian Date to a number of seconds since J2000.", "id": "f18283:m0"}
{"signature": "def close(self):", "body": "self.daf.file.close()<EOL>for segment in self.segments:<EOL><INDENT>if hasattr(segment, '<STR_LIT>'):<EOL><INDENT>del segment._data<EOL><DEDENT><DEDENT>self.daf._array = None<EOL>self.daf._map = None<EOL>", "docstring": "Close this SPK file.", "id": "f18284:c0:m2"}
{"signature": "def compute(self, tdb, tdb2=<NUM_LIT:0.0>):", "body": "for position in self.generate(tdb, tdb2):<EOL><INDENT>return position<EOL><DEDENT>", "docstring": "Compute the component values for the time `tdb` plus `tdb2`.", "id": "f18284:c1:m3"}
{"signature": "def describe(self, verbose=True):", "body": "center = titlecase(target_names.get(self.center, '<STR_LIT>'))<EOL>target = titlecase(target_names.get(self.target, '<STR_LIT>'))<EOL>text = ('<STR_LIT>'<EOL>'<STR_LIT>'.format(self, center, target))<EOL>if verbose:<EOL><INDENT>text += ('<STR_LIT>'<EOL>.format(self, self.source.decode('<STR_LIT:ascii>')))<EOL><DEDENT>return text<EOL>", "docstring": "Return a textual description of the segment.", "id": "f18284:c1:m2"}
{"signature": "def titlecase(name):", "body": "return name if name.startswith(('<STR_LIT:1>', '<STR_LIT>', '<STR_LIT>')) else name.title()<EOL>", "docstring": "Title-case body `name` if it looks safe to do so.", "id": "f18287:m1"}
{"signature": "def comments(self):", "body": "return self.daf.comments()<EOL>", "docstring": "Return the file comments, as a string.", "id": "f18287:c0:m4"}
{"signature": "def read_record(self, n):", "body": "self.file.seek(n * K - K)<EOL>return self.file.read(K)<EOL>", "docstring": "Return record `n` as 1,024 bytes; records are indexed from 1.", "id": "f18289:c0:m1"}
{"signature": "def map_words(self, start, end):", "body": "i, j = <NUM_LIT:8> * start - <NUM_LIT:8>, <NUM_LIT:8> * end<EOL>try:<EOL><INDENT>fileno = self.file.fileno()<EOL><DEDENT>except (AttributeError, io.UnsupportedOperation):<EOL><INDENT>fileno = None<EOL><DEDENT>if fileno is None:<EOL><INDENT>skip = <NUM_LIT:0><EOL>self.file.seek(i)<EOL>m = self.file.read(j - i)<EOL><DEDENT>else:<EOL><INDENT>skip = i % mmap.ALLOCATIONGRANULARITY<EOL>r = mmap.ACCESS_READ<EOL>m = mmap.mmap(fileno, length=j-i+skip, access=r, offset=i-skip)<EOL><DEDENT>if sys.version_info > (<NUM_LIT:3>,):<EOL><INDENT>m = memoryview(m)  <EOL><DEDENT>return m, skip<EOL>", "docstring": "Return a memory-map of the elements `start` through `end`.\n\n        The memory map will offer the 8-byte double-precision floats\n        (\"elements\") in the file from index `start` through to the index\n        `end`, inclusive, both counting the first float as element 1.\n        Memory maps must begin on a page boundary, so `skip` returns the\n        number of extra bytes at the beginning of the return value.", "id": "f18289:c0:m4"}
{"signature": "def add_array(self, name, values, array):", "body": "f = self.file<EOL>scs = self.summary_control_struct<EOL>record_number = self.bward<EOL>data = bytearray(self.read_record(record_number))<EOL>next_record, previous_record, n_summaries = scs.unpack(data[:<NUM_LIT>])<EOL>if n_summaries < self.summaries_per_record:<EOL><INDENT>summary_record = record_number<EOL>name_record = summary_record + <NUM_LIT:1><EOL>data[:<NUM_LIT>] = scs.pack(next_record, previous_record, n_summaries + <NUM_LIT:1>)<EOL>self.write_record(summary_record, data)<EOL><DEDENT>else:<EOL><INDENT>summary_record = ((self.free - <NUM_LIT:1>) * <NUM_LIT:8> + <NUM_LIT>) // <NUM_LIT> + <NUM_LIT:1><EOL>name_record = summary_record + <NUM_LIT:1><EOL>free_record = summary_record + <NUM_LIT:2><EOL>n_summaries = <NUM_LIT:0><EOL>data[:<NUM_LIT>] = scs.pack(summary_record, previous_record, n_summaries)<EOL>self.write_record(record_number, data)<EOL>summaries = scs.pack(<NUM_LIT:0>, record_number, <NUM_LIT:1>).ljust(<NUM_LIT>, b'<STR_LIT>')<EOL>names = b'<STR_LIT>' * <NUM_LIT><EOL>self.write_record(summary_record, summaries)<EOL>self.write_record(name_record, names)<EOL>self.bward = summary_record<EOL>self.free = (free_record - <NUM_LIT:1>) * <NUM_LIT> // <NUM_LIT:8> + <NUM_LIT:1><EOL><DEDENT>start_word = self.free<EOL>f.seek((start_word - <NUM_LIT:1>) * <NUM_LIT:8>)<EOL>array = numpy_array(array)  <EOL>f.write(array.view())<EOL>end_word = f.tell() // <NUM_LIT:8><EOL>self.free = end_word + <NUM_LIT:1><EOL>self.write_file_record()<EOL>values = values[:self.nd + self.ni - <NUM_LIT:2>] + (start_word, end_word)<EOL>base = <NUM_LIT> * (summary_record - <NUM_LIT:1>)<EOL>offset = int(n_summaries) * self.summary_step<EOL>f.seek(base + scs.size + offset)<EOL>f.write(self.summary_struct.pack(*values))<EOL>f.seek(base + <NUM_LIT> + offset)<EOL>f.write(name[:self.summary_length].ljust(self.summary_step, b'<STR_LIT:U+0020>'))<EOL>", "docstring": "Add a new array to the DAF file.\n\n        The summary will be initialized with the `name` and `values`,\n        and will have its start word and end word fields set to point to\n        where the `array` of floats has been appended to the file.", "id": "f18289:c0:m11"}
{"signature": "def summaries(self):", "body": "length = self.summary_length<EOL>step = self.summary_step<EOL>for record_number, n_summaries, summary_data in self.summary_records():<EOL><INDENT>name_data = self.read_record(record_number + <NUM_LIT:1>)<EOL>for i in range(<NUM_LIT:0>, int(n_summaries) * step, step):<EOL><INDENT>j = self.summary_control_struct.size + i<EOL>name = name_data[i:i+step].strip()<EOL>data = summary_data[j:j+length]<EOL>values = self.summary_struct.unpack(data)<EOL>yield name, values<EOL><DEDENT><DEDENT>", "docstring": "Yield (name, (value, value, ...)) for each summary in the file.", "id": "f18289:c0:m9"}
{"signature": "def position(self, name, tdb, tdb2=<NUM_LIT:0.0>):", "body": "bundle = self.compute_bundle(name, tdb, tdb2)<EOL>return self.position_from_bundle(bundle)<EOL>", "docstring": "[DEPRECATED] Compute the position of `name` at time ``tdb [+ tdb2]``.\n\n        The position is returned as a NumPy array ``[x y z]``.\n\n        The barycentric dynamical time `tdb` argument should be a float.\n        If there are many dates you want computed, then make `tdb` an\n        array, which is more efficient than calling this method multiple\n        times; the return value will be a two-dimensional array giving a\n        row of values for each coordinate.\n\n        For extra precision, the time can be split into two floats; a\n        popular choice is to use `tdb` for the integer or half-integer\n        date, and `tdb2` to hold the remaining fraction.\n\n        Consult the `names` attribute of this ephemeris for the values\n        of `name` it supports, such as ``'mars'`` or ``'earthmoon'``.", "id": "f18290:c1:m3"}
{"signature": "def path(self, filename):", "body": "return os.path.join(self.dirpath, filename)<EOL>", "docstring": "[DEPRECATED] Compute the path to a particular file in the ephemeris.", "id": "f18290:c1:m1"}
{"signature": "def julian_day(year, month=<NUM_LIT:1>, day=<NUM_LIT:1>):", "body": "janfeb = month < <NUM_LIT:3><EOL>return (day<EOL>+ <NUM_LIT> * (year + <NUM_LIT> - janfeb) // <NUM_LIT:4><EOL>+ <NUM_LIT> * (month - <NUM_LIT:2> + janfeb * <NUM_LIT:12>) // <NUM_LIT:12><EOL>- <NUM_LIT:3> * ((year + <NUM_LIT> - janfeb) // <NUM_LIT:100>) // <NUM_LIT:4><EOL>- <NUM_LIT>)<EOL>", "docstring": "Given a proleptic Gregorian calendar date, return a Julian day int.", "id": "f18293:m6"}
{"signature": "def _validate(value, optdict, name=\"<STR_LIT>\"):", "body": "try:<EOL><INDENT>_type = optdict[\"<STR_LIT:type>\"]<EOL><DEDENT>except KeyError:<EOL><INDENT>return value<EOL><DEDENT>return _call_validator(_type, optdict, name, value)<EOL>", "docstring": "return a validated value for an option according to its type\n\n    optional argument name is only used for error message formatting", "id": "f18308:m12"}
{"signature": "def options_by_section(self):", "body": "sections = {}<EOL>for optname, optdict in self.options:<EOL><INDENT>sections.setdefault(optdict.get(\"<STR_LIT>\"), []).append(<EOL>(optname, optdict, self.option_value(optname))<EOL>)<EOL><DEDENT>if None in sections:<EOL><INDENT>yield None, sections.pop(None)<EOL><DEDENT>for section, options in sorted(sections.items()):<EOL><INDENT>yield section.upper(), options<EOL><DEDENT>", "docstring": "return an iterator on options grouped by section\n\n        (section, [list of (optname, optdict, optvalue)])", "id": "f18308:c5:m6"}
{"signature": "def find_pylintrc():", "body": "<EOL>if os.path.exists(\"<STR_LIT>\"):<EOL><INDENT>return os.path.abspath(\"<STR_LIT>\")<EOL><DEDENT>if os.path.exists(\"<STR_LIT>\"):<EOL><INDENT>return os.path.abspath(\"<STR_LIT>\")<EOL><DEDENT>if os.path.isfile(\"<STR_LIT>\"):<EOL><INDENT>curdir = os.path.abspath(os.getcwd())<EOL>while os.path.isfile(os.path.join(curdir, \"<STR_LIT>\")):<EOL><INDENT>curdir = os.path.abspath(os.path.join(curdir, \"<STR_LIT:..>\"))<EOL>if os.path.isfile(os.path.join(curdir, \"<STR_LIT>\")):<EOL><INDENT>return os.path.join(curdir, \"<STR_LIT>\")<EOL><DEDENT>if os.path.isfile(os.path.join(curdir, \"<STR_LIT>\")):<EOL><INDENT>return os.path.join(curdir, \"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>if \"<STR_LIT>\" in os.environ and os.path.exists(os.environ[\"<STR_LIT>\"]):<EOL><INDENT>pylintrc = os.environ[\"<STR_LIT>\"]<EOL><DEDENT>else:<EOL><INDENT>user_home = os.path.expanduser(\"<STR_LIT>\")<EOL>if user_home in (\"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>pylintrc = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>pylintrc = os.path.join(user_home, \"<STR_LIT>\")<EOL>if not os.path.isfile(pylintrc):<EOL><INDENT>pylintrc = os.path.join(user_home, \"<STR_LIT>\", \"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>if not os.path.isfile(pylintrc):<EOL><INDENT>if os.path.isfile(\"<STR_LIT>\"):<EOL><INDENT>pylintrc = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>pylintrc = None<EOL><DEDENT><DEDENT>return pylintrc<EOL>", "docstring": "search the pylint rc file and return its path if it find it, else None", "id": "f18308:m3"}
{"signature": "def help(self, level=<NUM_LIT:0>):", "body": "self.cmdline_parser.formatter.output_level = level<EOL>with _patch_optparse():<EOL><INDENT>return self.cmdline_parser.format_help()<EOL><DEDENT>", "docstring": "return the usage string for available options", "id": "f18308:c4:m17"}
{"signature": "def option_value(self, opt):", "body": "return getattr(self.config, self.option_attrname(opt), None)<EOL>", "docstring": "get the current value for the given option", "id": "f18308:c5:m3"}
{"signature": "def get_option_def(self, opt):", "body": "assert self.options<EOL>for option in self.options:<EOL><INDENT>if option[<NUM_LIT:0>] == opt:<EOL><INDENT>return option[<NUM_LIT:1>]<EOL><DEDENT><DEDENT>raise optparse.OptionError(<EOL>\"<STR_LIT>\" % (opt, self.name), opt<EOL>)<EOL>", "docstring": "return the dictionary defining an option given its name", "id": "f18308:c5:m5"}
{"signature": "def load_command_line_configuration(self, args=None):", "body": "with _patch_optparse():<EOL><INDENT>if args is None:<EOL><INDENT>args = sys.argv[<NUM_LIT:1>:]<EOL><DEDENT>else:<EOL><INDENT>args = list(args)<EOL><DEDENT>(options, args) = self.cmdline_parser.parse_args(args=args)<EOL>for provider in self._nocallback_options:<EOL><INDENT>config = provider.config<EOL>for attr in config.__dict__.keys():<EOL><INDENT>value = getattr(options, attr, None)<EOL>if value is None:<EOL><INDENT>continue<EOL><DEDENT>setattr(config, attr, value)<EOL><DEDENT><DEDENT>return args<EOL><DEDENT>", "docstring": "Override configuration according to command line parameters\n\n        return additional arguments", "id": "f18308:c4:m15"}
{"signature": "def read_config_file(self, config_file=None, verbose=None):", "body": "helplevel = <NUM_LIT:1><EOL>while helplevel <= self._maxlevel:<EOL><INDENT>opt = \"<STR_LIT:->\".join([\"<STR_LIT>\"] * helplevel) + \"<STR_LIT>\"<EOL>if opt in self._all_options:<EOL><INDENT>break  <EOL><DEDENT>def helpfunc(option, opt, val, p, level=helplevel):<EOL><INDENT>print(self.help(level))<EOL>sys.exit(<NUM_LIT:0>)<EOL><DEDENT>helpmsg = \"<STR_LIT>\" % \"<STR_LIT:U+0020>\".join([\"<STR_LIT>\"] * helplevel)<EOL>optdict = {\"<STR_LIT:action>\": \"<STR_LIT>\", \"<STR_LIT>\": helpfunc, \"<STR_LIT>\": helpmsg}<EOL>provider = self.options_providers[<NUM_LIT:0>]<EOL>self.add_optik_option(provider, self.cmdline_parser, opt, optdict)<EOL>provider.options += ((opt, optdict),)<EOL>helplevel += <NUM_LIT:1><EOL><DEDENT>if config_file is None:<EOL><INDENT>config_file = self.config_file<EOL><DEDENT>if config_file is not None:<EOL><INDENT>config_file = os.path.expanduser(config_file)<EOL>if not os.path.exists(config_file):<EOL><INDENT>raise IOError(\"<STR_LIT>\".format(config_file))<EOL><DEDENT><DEDENT>use_config_file = config_file and os.path.exists(config_file)<EOL>if use_config_file:<EOL><INDENT>parser = self.cfgfile_parser<EOL>with io.open(config_file, \"<STR_LIT:r>\", encoding=\"<STR_LIT>\") as fp:<EOL><INDENT>parser.read_file(fp)<EOL><DEDENT>for sect, values in list(parser._sections.items()):<EOL><INDENT>if not sect.isupper() and values:<EOL><INDENT>parser._sections[sect.upper()] = values<EOL><DEDENT><DEDENT><DEDENT>if not verbose:<EOL><INDENT>return<EOL><DEDENT>if use_config_file:<EOL><INDENT>msg = \"<STR_LIT>\".format(os.path.abspath(config_file))<EOL><DEDENT>else:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL><DEDENT>print(msg, file=sys.stderr)<EOL>", "docstring": "read the configuration file but do not load it (i.e. dispatching\n        values to each options provider)", "id": "f18308:c4:m11"}
{"signature": "def set_option(self, optname, value, action=None, optdict=None):", "body": "if optdict is None:<EOL><INDENT>optdict = self.get_option_def(optname)<EOL><DEDENT>if value is not None:<EOL><INDENT>value = _validate(value, optdict, optname)<EOL><DEDENT>if action is None:<EOL><INDENT>action = optdict.get(\"<STR_LIT:action>\", \"<STR_LIT:store>\")<EOL><DEDENT>if action == \"<STR_LIT:store>\":<EOL><INDENT>setattr(self.config, self.option_attrname(optname, optdict), value)<EOL><DEDENT>elif action in (\"<STR_LIT:store_true>\", \"<STR_LIT:count>\"):<EOL><INDENT>setattr(self.config, self.option_attrname(optname, optdict), <NUM_LIT:0>)<EOL><DEDENT>elif action == \"<STR_LIT>\":<EOL><INDENT>setattr(self.config, self.option_attrname(optname, optdict), <NUM_LIT:1>)<EOL><DEDENT>elif action == \"<STR_LIT>\":<EOL><INDENT>optname = self.option_attrname(optname, optdict)<EOL>_list = getattr(self.config, optname, None)<EOL>if _list is None:<EOL><INDENT>if isinstance(value, (list, tuple)):<EOL><INDENT>_list = value<EOL><DEDENT>elif value is not None:<EOL><INDENT>_list = []<EOL>_list.append(value)<EOL><DEDENT>setattr(self.config, optname, _list)<EOL><DEDENT>elif isinstance(_list, tuple):<EOL><INDENT>setattr(self.config, optname, _list + (value,))<EOL><DEDENT>else:<EOL><INDENT>_list.append(value)<EOL><DEDENT><DEDENT>elif action == \"<STR_LIT>\":<EOL><INDENT>optdict[\"<STR_LIT>\"](None, optname, value, None)<EOL><DEDENT>else:<EOL><INDENT>raise UnsupportedAction(action)<EOL><DEDENT>", "docstring": "method called to set an option (registered in the options list)", "id": "f18308:c5:m4"}
{"signature": "def add_renamed_message(self, old_id, old_symbol, new_symbol):", "body": "message_definition = self.get_message_definitions(new_symbol)[<NUM_LIT:0>]<EOL>message_definition.old_names.append((old_id, old_symbol))<EOL>self._register_alternative_name(message_definition, old_id, old_symbol)<EOL>", "docstring": "Register the old ID and symbol for a warning that was renamed.\n\n        This allows users to keep using the old ID/symbol in suppressions.", "id": "f18310:c0:m2"}
{"signature": "def register_messages_from_checker(self, checker):", "body": "checker.check_consistency()<EOL>for message in checker.messages:<EOL><INDENT>self.register_message(message)<EOL><DEDENT>", "docstring": "Register all messages from a checker.\n\n        :param BaseChecker checker:", "id": "f18310:c0:m3"}
{"signature": "def _register_alternative_name(self, msg, msgid, symbol):", "body": "self._check_id_and_symbol_consistency(msgid, symbol)<EOL>self._alternative_names[msgid] = msg<EOL>self._alternative_names[symbol] = msg<EOL>", "docstring": "helper for register_message()", "id": "f18310:c0:m5"}
{"signature": "def format(self, template):", "body": "<EOL>return template.format(**dict(zip(self._fields, self)))<EOL>", "docstring": "Format the message according to the given template.\n\n        The template format is the one of the format method :\n        cf. http://docs.python.org/2/library/string.html#formatstrings", "id": "f18312:c0:m1"}
{"signature": "def may_be_emitted(self):", "body": "if self.minversion is not None and self.minversion > sys.version_info:<EOL><INDENT>return False<EOL><DEDENT>if self.maxversion is not None and self.maxversion <= sys.version_info:<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "return True if message may be emitted using the current interpreter", "id": "f18314:c0:m2"}
{"signature": "def py_run(command_options=\"<STR_LIT>\", return_std=False, stdout=None, stderr=None):", "body": "<EOL>executable = sys.executable if \"<STR_LIT>\" in sys.executable else \"<STR_LIT>\"<EOL>epylint_part = [executable, \"<STR_LIT:-c>\", \"<STR_LIT>\"]<EOL>options = shlex.split(command_options, posix=not sys.platform.startswith(\"<STR_LIT>\"))<EOL>cli = epylint_part + options<EOL>if stdout is None:<EOL><INDENT>if return_std:<EOL><INDENT>stdout = PIPE<EOL><DEDENT>else:<EOL><INDENT>stdout = sys.stdout<EOL><DEDENT><DEDENT>if stderr is None:<EOL><INDENT>if return_std:<EOL><INDENT>stderr = PIPE<EOL><DEDENT>else:<EOL><INDENT>stderr = sys.stderr<EOL><DEDENT><DEDENT>process = Popen(<EOL>cli,<EOL>shell=False,<EOL>stdout=stdout,<EOL>stderr=stderr,<EOL>env=_get_env(),<EOL>universal_newlines=True,<EOL>)<EOL>proc_stdout, proc_stderr = process.communicate()<EOL>if return_std:<EOL><INDENT>return StringIO(proc_stdout), StringIO(proc_stderr)<EOL><DEDENT>return None<EOL>", "docstring": "Run pylint from python\n\n    ``command_options`` is a string containing ``pylint`` command line options;\n    ``return_std`` (boolean) indicates return of created standard output\n    and error (see below);\n    ``stdout`` and ``stderr`` are 'file-like' objects in which standard output\n    could be written.\n\n    Calling agent is responsible for stdout/err management (creation, close).\n    Default standard output and error are those from sys,\n    or standalone ones (``subprocess.PIPE``) are used\n    if they are not set and ``return_std``.\n\n    If ``return_std`` is set to ``True``, this function returns a 2-uple\n    containing standard output and error related to created process,\n    as follows: ``(stdout, stderr)``.\n\n    To silently run Pylint on a module, and get its standard output and error:\n        >>> (pylint_stdout, pylint_stderr) = py_run( 'module_name.py', True)", "id": "f18315:m2"}
{"signature": "def lint(filename, options=()):", "body": "<EOL>full_path = osp.abspath(filename)<EOL>parent_path = osp.dirname(full_path)<EOL>child_path = osp.basename(full_path)<EOL>while parent_path != \"<STR_LIT:/>\" and osp.exists(osp.join(parent_path, \"<STR_LIT>\")):<EOL><INDENT>child_path = osp.join(osp.basename(parent_path), child_path)<EOL>parent_path = osp.dirname(parent_path)<EOL><DEDENT>run_cmd = \"<STR_LIT>\"<EOL>cmd = (<EOL>[sys.executable, \"<STR_LIT:-c>\", run_cmd]<EOL>+ [<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT:n>\",<EOL>child_path,<EOL>]<EOL>+ list(options)<EOL>)<EOL>process = Popen(<EOL>cmd, stdout=PIPE, cwd=parent_path, env=_get_env(), universal_newlines=True<EOL>)<EOL>for line in process.stdout:<EOL><INDENT>if line.startswith(\"<STR_LIT>\"):<EOL><INDENT>continue<EOL><DEDENT>parts = line.split(\"<STR_LIT::>\")<EOL>if parts and parts[<NUM_LIT:0>] == child_path:<EOL><INDENT>line = \"<STR_LIT::>\".join([filename] + parts[<NUM_LIT:1>:])<EOL><DEDENT>print(line, end=\"<STR_LIT:U+0020>\")<EOL><DEDENT>process.wait()<EOL>return process.returncode<EOL>", "docstring": "Pylint the given file.\n\n    When run from emacs we will be in the directory of a file, and passed its\n    filename.  If this file is part of a package and is trying to import other\n    modules from within its own package or another package rooted in a directory\n    below it, pylint will classify it as a failed import.\n\n    To get around this, we traverse down the directory tree to find the root of\n    the package this module is in.  We then invoke pylint from this directory.\n\n    Finally, we must correct the filenames in the output generated by pylint so\n    Emacs doesn't become confused (it will expect just the original filename,\n    while pylint may extend it with extra directories if we've traversed down\n    the tree)", "id": "f18315:m1"}
{"signature": "def append(self, child):", "body": "self.children.append(child)<EOL>child.parent = self<EOL>", "docstring": "add a node to children", "id": "f18318:c0:m2"}
{"signature": "def _get_visit_name(self):", "body": "try:<EOL><INDENT>return self.TYPE.replace(\"<STR_LIT:->\", \"<STR_LIT:_>\")<EOL><DEDENT>except Exception:<EOL><INDENT>return self.__class__.__name__.lower()<EOL><DEDENT>", "docstring": "return the visit name for the mixed class. When calling 'accept', the\nmethod <'visit_' + name returned by this method> will be called on the\nvisitor", "id": "f18318:c0:m4"}
{"signature": "def format_children(self, layout):", "body": "for child in getattr(layout, \"<STR_LIT>\", ()):<EOL><INDENT>child.accept(self)<EOL><DEDENT>", "docstring": "recurse on the layout children and call their accept method\n        (see the Visitor pattern)", "id": "f18319:c0:m1"}
{"signature": "def writeln(self, string=\"<STR_LIT>\"):", "body": "self.write(string + os.linesep)<EOL>", "docstring": "write a line in the output buffer", "id": "f18319:c0:m2"}
{"signature": "def compute_content(self, layout):", "body": "<EOL>out = self.out<EOL>try:<EOL><INDENT>for child in layout.children:<EOL><INDENT>stream = StringIO()<EOL>self.out = stream<EOL>child.accept(self)<EOL>yield stream.getvalue()<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>self.out = out<EOL><DEDENT>", "docstring": "trick to compute the formatting of children layout before actually\n        writing it\n\n        return an iterator on strings (one for each child element)", "id": "f18319:c0:m7"}
{"signature": "def end_format(self):", "body": "", "docstring": "finished to format a layout", "id": "f18319:c0:m5"}
{"signature": "def visit_paragraph(self, layout):", "body": "self.format_children(layout)<EOL>self.writeln()<EOL>", "docstring": "enter a paragraph", "id": "f18320:c0:m4"}
{"signature": "def report_order(self):", "body": "return list(self._reports)<EOL>", "docstring": "Return a list of reports, sorted in the order\n        in which they must be called.", "id": "f18321:c0:m1"}
{"signature": "def colorize_ansi(msg, color=None, style=None):", "body": "<EOL>if color is None and style is None:<EOL><INDENT>return msg<EOL><DEDENT>escape_code = _get_ansi_code(color, style)<EOL>if escape_code:<EOL><INDENT>return \"<STR_LIT>\" % (escape_code, msg, ANSI_RESET)<EOL><DEDENT>return msg<EOL>", "docstring": "colorize message by wrapping it with ansi escape codes\n\n    :type msg: str or unicode\n    :param msg: the message string to colorize\n\n    :type color: str or None\n    :param color:\n      the color identifier (see `ANSI_COLORS` for available values)\n\n    :type style: str or None\n    :param style:\n      style string (see `ANSI_COLORS` for available values). To get\n      several style effects at the same time, use a coma as separator.\n\n    :raise KeyError: if an unexistent color or style identifier is given\n\n    :rtype: str or unicode\n    :return: the ansi escaped string", "id": "f18322:m1"}
{"signature": "def _get_decoration(self, msg_id):", "body": "try:<EOL><INDENT>return self.color_mapping[msg_id[<NUM_LIT:0>]]<EOL><DEDENT>except KeyError:<EOL><INDENT>return None, None<EOL><DEDENT>", "docstring": "Returns the tuple color, style associated with msg_id as defined\n        in self.color_mapping", "id": "f18322:c3:m1"}
{"signature": "def display_reports(self, layout):", "body": "self.section = <NUM_LIT:0><EOL>if hasattr(layout, \"<STR_LIT>\"):<EOL><INDENT>layout.children[<NUM_LIT:0>].children[<NUM_LIT:0>].data += \"<STR_LIT>\" % layout.report_id<EOL><DEDENT>self._display(layout)<EOL>", "docstring": "display results encapsulated in the layout tree", "id": "f18324:c0:m4"}
{"signature": "def process_module(self, astroid):", "body": "", "docstring": "process a module\n\n        the module's content is accessible via astroid.stream", "id": "f18326:c2:m0"}
{"signature": "def handle_message(self, msg):", "body": "", "docstring": "Handle the given message object.", "id": "f18326:c5:m0"}
{"signature": "def close(self):", "body": "", "docstring": "called after visiting project (i.e set of modules)", "id": "f18326:c1:m1"}
{"signature": "def register(linter):", "body": "linter.register_checker(BroadTryClauseChecker(linter))<EOL>", "docstring": "Required method to auto register this checker.", "id": "f18332:m0"}
{"signature": "def visit_functiondef(self, node):", "body": "node_doc = utils.docstringify(node.doc, self.config.default_docstring_type)<EOL>self.check_functiondef_params(node, node_doc)<EOL>self.check_functiondef_returns(node, node_doc)<EOL>self.check_functiondef_yields(node, node_doc)<EOL>", "docstring": "Called for function and method definitions (def).\n\n        :param node: Node for a function or method definition in the AST\n        :type node: :class:`astroid.scoped_nodes.Function`", "id": "f18334:c0:m0"}
{"signature": "def _add_raise_message(self, missing_excs, node):", "body": "if node.is_abstract():<EOL><INDENT>try:<EOL><INDENT>missing_excs.remove(\"<STR_LIT>\")<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if not missing_excs:<EOL><INDENT>return<EOL><DEDENT>self.add_message(<EOL>\"<STR_LIT>\", args=(\"<STR_LIT:U+002CU+0020>\".join(sorted(missing_excs)),), node=node<EOL>)<EOL>", "docstring": "Adds a message on :param:`node` for the missing exception type.\n\n:param missing_excs: A list of missing exception types.\n:type missing_excs: set(str)\n\n:param node: The node show the message on.\n:type node: astroid.node_classes.NodeNG", "id": "f18334:c0:m11"}
{"signature": "def returns_something(return_node):", "body": "returns = return_node.value<EOL>if returns is None:<EOL><INDENT>return False<EOL><DEDENT>return not (isinstance(returns, astroid.Const) and returns.value is None)<EOL>", "docstring": "Check if a return node returns a value other than None.\n\n    :param return_node: The return node to check.\n    :type return_node: astroid.Return\n\n    :rtype: bool\n    :return: True if the return node returns a value other than None,\n        False otherwise.", "id": "f18335:m3"}
{"signature": "def register(linter):", "body": "warnings.warn(<EOL>\"<STR_LIT>\",<EOL>DeprecationWarning,<EOL>)<EOL>linter.register_checker(docparams.DocstringParameterChecker(linter))<EOL>", "docstring": "Required method to auto register this checker.\n\n    :param linter: Main interface object for Pylint plugins\n    :type linter: Pylint object", "id": "f18338:m0"}
{"signature": "def issue329(*args):", "body": "first, second, third = args<EOL>return first, second, third<EOL>", "docstring": "Don't emit unbalanced tuple unpacking if the\n    rhs of the assignment is a variable-length argument,\n    because we don't know the actual length of the tuple.", "id": "f18350:m12"}
{"signature": "def temp():", "body": "if True:<EOL><INDENT>return [<NUM_LIT:1>, <NUM_LIT:2>]<EOL><DEDENT>return [<NUM_LIT:2>, <NUM_LIT:3>, <NUM_LIT:4>]<EOL>", "docstring": "This is not weird", "id": "f18350:m7"}
{"signature": "def do_stuff4():", "body": "first, second = <NUM_LIT:1>, <NUM_LIT:2><EOL>return first + second<EOL>", "docstring": "This is right", "id": "f18350:m4"}
{"signature": "def do_stuff2():", "body": "(first, second) = <NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:3> <EOL>return first + second<EOL>", "docstring": "This is not right.", "id": "f18350:m2"}
{"signature": "def function12(value=dict([('<STR_LIT:a>', <NUM_LIT:1>), ('<STR_LIT:b>', <NUM_LIT:2>)])): ", "body": "return value<EOL>", "docstring": "dictionaries with items should not output item values in error message", "id": "f18360:m11"}
{"signature": "def function5(value=frozenset()):", "body": "return value<EOL>", "docstring": "frozenset is immutable and safe.", "id": "f18360:m4"}
{"signature": "def __index__(self, n=<NUM_LIT>):", "body": "", "docstring": "Expects 0 args, but we are taking in account arguments with defaults.", "id": "f18375:c5:m4"}
{"signature": "@CustomProperty<EOL><INDENT>def five(self):<DEDENT>", "body": "return self<EOL>", "docstring": "Always 5.", "id": "f18377:c3:m1"}
{"signature": "def _private_documented():", "body": "", "docstring": "It has a docstring.", "id": "f18379:m2"}
{"signature": "def newmethod(self, aax, aay): ", "body": "return self, aax<EOL>", "docstring": "another method, warning for aay desired", "id": "f18380:c1:m1"}
{"signature": "def inherited(self, aaa, aab, aac):", "body": "raise NotImplementedError<EOL>", "docstring": "abstract method", "id": "f18380:c0:m0"}
{"signature": "def inherited(self, aaa, aab, aac):", "body": "return aaa<EOL>", "docstring": "overridden method, though don't use every argument", "id": "f18380:c1:m0"}
{"signature": "def inherited(self, aaa, aab, aac):", "body": "return aaa + aab + aac<EOL>", "docstring": "overridden method, use every argument", "id": "f18380:c2:m0"}
{"signature": "def metadata_from_dict(key):", "body": "return {key: str(value) for key, value in key.items()}<EOL>", "docstring": "Should not raise unused-argument message because key is\nused inside comprehension dict", "id": "f18380:m3"}
{"signature": "def do_nothing():", "body": "with open(\"<STR_LIT>\") as ctx.obj:  <EOL><INDENT>context.do()  <EOL>context = None<EOL><DEDENT>", "docstring": "empty", "id": "f18385:m0"}
{"signature": "def in_method(var):", "body": "var = nomoreknown  <EOL>assert var<EOL>", "docstring": "method doc", "id": "f18386:m0"}
{"signature": "@decorator(arg=(i * <NUM_LIT:2> for i in range(<NUM_LIT:15>)))<EOL>def func2():", "body": "", "docstring": "A function with a decorator that contains a genexpr.", "id": "f18386:m5"}
{"signature": "def nonlocal_in_ifexp():", "body": "bug2 = True<EOL>def on_click(event):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if event:<EOL><INDENT>nonlocal bug2<EOL>bug2 = not bug2<EOL><DEDENT><DEDENT>on_click(True)<EOL>", "docstring": "bar", "id": "f18407:m8"}
{"signature": "def function_1_arg(first_argument):", "body": "return first_argument<EOL>", "docstring": "one argument function", "id": "f18411:m1"}
{"signature": "@staticmethod<EOL><INDENT>def static_method(arg):<DEDENT>", "body": "return arg + arg<EOL>", "docstring": "static method.", "id": "f18411:c0:m0"}
{"signature": "def method(self, arg):", "body": "return (self, arg)<EOL>", "docstring": "method.", "id": "f18411:c0:m2"}
{"signature": "def no_kwargs(self, arg, **kwargs): ", "body": "", "docstring": "Not okay to add extra capabilities.", "id": "f18413:c8:m1"}
{"signature": "@staticmethod<EOL><INDENT>def static_method_in_class(param1, param2=<NUM_LIT:3>, *args): <DEDENT>", "body": "pass<EOL>", "docstring": "static method in class AAAA", "id": "f18433:c0:m1"}
{"signature": "def func_in_class(self, param1, param2=<NUM_LIT:2>, *args): ", "body": "pass<EOL>", "docstring": "method in class AAAA", "id": "f18433:c0:m0"}
{"signature": "def func(arg1, arg2):", "body": "return arg1.value + arg2<EOL>", "docstring": "function that will be used as a method", "id": "f18434:m0"}
{"signature": "def meth18(self):", "body": "", "docstring": "hehehe", "id": "f18448:c0:m18"}
{"signature": "def meth17(self):", "body": "", "docstring": "hehehe", "id": "f18448:c0:m17"}
{"signature": "def meth12(self):", "body": "", "docstring": "hehehe", "id": "f18448:c0:m12"}
{"signature": "def meth11(self):", "body": "", "docstring": "hehehe", "id": "f18448:c0:m11"}
{"signature": "def meth7(self):", "body": "", "docstring": "hehehe", "id": "f18448:c0:m7"}
{"signature": "def meth21(self):", "body": "", "docstring": "hehehe", "id": "f18448:c0:m21"}
{"signature": "def meth6(self):", "body": "", "docstring": "hehehe", "id": "f18448:c0:m6"}
{"signature": "def meth13(self):", "body": "", "docstring": "hehehe", "id": "f18448:c0:m13"}
{"signature": "def func_with_long(parameter):", "body": "return parameter<EOL>", "docstring": "# pylint: disable=line-too-long\naaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccccccccccccccccccccccccccccccccccccccccccccc", "id": "f18449:m1"}
{"signature": "def foo4(_, *, _): ", "body": "", "docstring": "Function with duplicate argument name.", "id": "f18450:m3"}
{"signature": "def foo1(_, _): ", "body": "", "docstring": "Function with duplicate argument name.", "id": "f18450:m0"}
{"signature": "def function7():", "body": "return TESTSTR[None]<EOL>", "docstring": "String index is None", "id": "f18452:m6"}
{"signature": "def function14():", "body": "return TESTTUPLE[<NUM_LIT:0>]<EOL>", "docstring": "Tuple index is an int constant", "id": "f18452:m13"}
{"signature": "def function4():", "body": "return TESTLIST['<STR_LIT:0>']<EOL>", "docstring": "list index is a str constant", "id": "f18452:m3"}
{"signature": "def function24():", "body": "class ListTest(list):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>def __getitem__(self, key):<EOL><INDENT>pass<EOL><DEDENT><DEDENT>test = ListTest()<EOL>test[None] = <NUM_LIT:0> <EOL>del test[None] <EOL>test[None][<NUM_LIT:0>] = <NUM_LIT:0> <EOL>test[<NUM_LIT:0>][<NUM_LIT:0>] = <NUM_LIT:0> <EOL>test[<NUM_LIT:0>] = <NUM_LIT:0> <EOL>del test[<NUM_LIT:0>]<EOL>", "docstring": "Get, set, and delete on a subclass of list that overrides __getitem__", "id": "f18452:m23"}
{"signature": "def function23():", "body": "class ListTest(list):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>def __delitem__(self, key):<EOL><INDENT>pass<EOL><DEDENT><DEDENT>test = ListTest()<EOL>test[None][<NUM_LIT:0>] = <NUM_LIT:0> <EOL>test[None] = <NUM_LIT:0>  <EOL>test[<NUM_LIT:0>][<NUM_LIT:0>] = <NUM_LIT:0> <EOL>test[<NUM_LIT:0>] = <NUM_LIT:0> <EOL>del test[None] <EOL>del test[<NUM_LIT:0>]<EOL>", "docstring": "Get, set, and delete on a subclass of list that overrides __delitem__", "id": "f18452:m22"}
{"signature": "def function16():", "body": "class TupleTest(tuple):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>pass<EOL><DEDENT>return TupleTest()[<NUM_LIT:0>]<EOL>", "docstring": "Index of subclass of tuple is an int constant", "id": "f18452:m15"}
{"signature": "def function21():", "body": "class ListTest(list):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>pass<EOL><DEDENT>test = ListTest()<EOL>test[None] = <NUM_LIT:0> <EOL>del test[None] <EOL>test[<NUM_LIT:0>] = <NUM_LIT:0> <EOL>del test[<NUM_LIT:0>]<EOL>", "docstring": "Set and delete on a subclass of list", "id": "f18452:m20"}
{"signature": "def good_multiarg(name, value):", "body": "raise ValueError('<STR_LIT>' % (name, value))<EOL>", "docstring": "The arguments have to be written as a tuple for formatting", "id": "f18454:m3"}
{"signature": "def helloworld():", "body": "", "docstring": "says hello", "id": "f18458:m0"}
{"signature": "def smethod():", "body": "", "docstring": "static method-to-be", "id": "f18458:c0:m1"}
{"signature": "def other_method(cls):", "body": "", "docstring": "some method", "id": "f18470:c0:m3"}
{"signature": "def cmethod(cls):", "body": "", "docstring": "class method-to-be", "id": "f18470:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def my_second_method(cls):<DEDENT>", "body": "", "docstring": "correct class method definition", "id": "f18470:c0:m2"}
{"signature": "@staticmethod<EOL><INDENT>def static_foo(lala):<DEDENT>", "body": "lala = <NUM_LIT:10><EOL>", "docstring": "Static method, no warnings", "id": "f18475:c0:m3"}
{"signature": "def bbbb(self):", "body": "raise NotImplementedError()<EOL>", "docstring": "should be overridden in concrete class", "id": "f18491:c0:m1"}
{"signature": "@decor<EOL><INDENT>def prop(self):<DEDENT>", "body": "return self<EOL>", "docstring": "method", "id": "f18493:c0:m0"}
{"signature": "def decor(trop):", "body": "return trop<EOL>", "docstring": "decorator", "id": "f18493:m0"}
{"signature": "def hop(self):", "body": "super(NewAaaa, self).hop()<EOL>", "docstring": "hop", "id": "f18502:c1:m0"}
{"signature": "def func1():", "body": "return true_value if condition else false_value<EOL>", "docstring": "Ternary return value correct", "id": "f18507:m0"}
{"signature": "def many_yield(text):", "body": "if text:<EOL><INDENT>yield \"<STR_LIT>\" % text<EOL>yield \"<STR_LIT>\"<EOL>yield \"<STR_LIT>\"<EOL>yield \"<STR_LIT>\"<EOL>yield \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>yield \"<STR_LIT>\"<EOL>yield \"<STR_LIT>\"<EOL>yield \"<STR_LIT>\"<EOL>yield \"<STR_LIT>\"<EOL>yield \"<STR_LIT>\"<EOL><DEDENT>", "docstring": "Not a problem", "id": "f18509:m1"}
{"signature": "def __iter_(self):", "body": "", "docstring": "do nothing", "id": "f18516:c0:m0"}
{"signature": "def method():  ", "body": "", "docstring": "A method without a self argument.", "id": "f18529:c0:m1"}
{"signature": "def correct(self):", "body": "self.var = \"<STR_LIT>\"<EOL>", "docstring": "Correct.", "id": "f18529:c0:m3"}
{"signature": "def aaaa(self):", "body": "raise NotImplementedError()<EOL>", "docstring": "should be overridden in concrete class", "id": "f18535:c0:m0"}
{"signature": "def bbbb(self):", "body": "raise NotImplementedError()<EOL>", "docstring": "should be overridden in concrete class", "id": "f18535:c0:m1"}
{"signature": "def good_case5():", "body": "return (i for i in range(<NUM_LIT:10>))<EOL>", "docstring": "No problems here.", "id": "f18549:m4"}
{"signature": "def bad_case3():", "body": "lst = []<EOL>for i in range(<NUM_LIT:10>):<EOL><INDENT>j = i * i<EOL>lst.append(lambda: j)  <EOL><DEDENT>return lst<EOL>", "docstring": "Closing over variable defined in loop.", "id": "f18549:m10"}
{"signature": "def bad_case():", "body": "lst = []<EOL>for i in range(<NUM_LIT:10>):<EOL><INDENT>print(i)<EOL>lst.append(lambda: i)<EOL><DEDENT>", "docstring": "Closing over a loop variable.", "id": "f18549:m8"}
{"signature": "def bad_case5():", "body": "return (lambda: i for i in range(<NUM_LIT:10>))<EOL>", "docstring": "Problematic case.\n\n    If this function is used as\n\n    >>> [x() for x in bad_case5()]\n\n    it behaves 'as expected', i.e. the result is range(10).\n\n    If it's used with\n\n    >>> lst = list(bad_case5())\n    >>> [x() for x in lst]\n\n    the result is [9] * 10 again.", "id": "f18549:m12"}
{"signature": "def method1():", "body": "import x<EOL>", "docstring": "Method 1", "id": "f18551:m0"}
{"signature": "def method2(self):", "body": "pass<EOL>", "docstring": "yeah !", "id": "f18562:c0:m1"}
{"signature": "def function2(value):", "body": "print(value)<EOL>", "docstring": "docstring", "id": "f18562:m2"}
{"signature": "def function7():", "body": "def inner():<EOL><INDENT>return <NUM_LIT><EOL><DEDENT>return inner()<EOL>", "docstring": "docstring", "id": "f18562:m7"}
{"signature": "def kwonly_4(self, first, second): ", "body": "", "docstring": "Two positional params.", "id": "f18567:c1:m3"}
{"signature": "def ellipsis():", "body": "...<EOL>", "docstring": "Test that an Ellipsis as a body does not trigger the error", "id": "f18572:m1"}
{"signature": "def func_call():", "body": "partial_func = partial(root_function, <NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:3>)<EOL>partial_func()<EOL>return root_function(<NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:3>)<EOL>", "docstring": "Test we don't emit a FP for https://github.com/PyCQA/pylint/issues/2588", "id": "f18575:m2"}
{"signature": "def func(self):", "body": "return Sub(), self<EOL>", "docstring": "check Sub is not defined here", "id": "f18581:c0:m0"}
{"signature": "def function2():", "body": "return TESTLIST['<STR_LIT:0>':'<STR_LIT:1>':]<EOL>", "docstring": "strings used as indices", "id": "f18591:m1"}
{"signature": "def function4():", "body": "return TESTLIST[<NUM_LIT:0>:<NUM_LIT:0>:<NUM_LIT:0>]<EOL>", "docstring": "integers used as indices", "id": "f18591:m3"}
{"signature": "def function7():", "body": "class IndexType(object):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>def __index__(self):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return <NUM_LIT:0><EOL><DEDENT><DEDENT>class IndexSubType(IndexType):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>pass<EOL><DEDENT>return TESTLIST[IndexSubType():None:None]<EOL>", "docstring": "class with __index__ in superclass used as index", "id": "f18591:m6"}
{"signature": "def function6():", "body": "class IndexTest(object):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>def __index__(self):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>return <NUM_LIT:0><EOL><DEDENT><DEDENT>return TESTLIST[IndexTest():None:None]<EOL>", "docstring": "class with __index__ used as index", "id": "f18591:m5"}
{"signature": "def use_method(self):", "body": "self._prov.hophop()<EOL>self._prov.hophophop()<EOL>", "docstring": "use provider's method", "id": "f18599:c1:m2"}
{"signature": "def socket_false_positive():", "body": "import socket<EOL>sckt = socket.socket(socket.AF_INET, socket.SOCK_STREAM)<EOL>sckt.connect(('<STR_LIT:127.0.0.1>', <NUM_LIT>))<EOL>sckt.close()<EOL>", "docstring": "Test a regression\n    Version used:\n\n    - Pylint 0.10.0\n    - Logilab common 0.15.0\n    - Logilab astroid 0.15.1\n\n    False E1101 positive, line 23:\n    Instance of '_socketobject' has no 'connect' member", "id": "f18599:m0"}
{"signature": "def use_attr(self):", "body": "print(self._prov.attr)<EOL>print(self._prov.attribute)<EOL>", "docstring": "use provider's attr", "id": "f18599:c1:m3"}
{"signature": "def bad_case6():", "body": "raise None<EOL>", "docstring": "raise", "id": "f18625:m10"}
{"signature": "def good_case2():", "body": "import decimal<EOL>raise decimal.DivisionByZero(<NUM_LIT:4>)<EOL>", "docstring": "decimal.DivisionByZero is defined in C on Python 3.", "id": "f18625:m2"}
{"signature": "def bad_case3():", "body": "raise NewStyleClass<EOL>", "docstring": "raise", "id": "f18625:m7"}
{"signature": "def issue322():", "body": "'<STR_LIT>'.format(<NUM_LIT>, {'<STR_LIT>': <NUM_LIT>})<EOL>'<STR_LIT>'.format(<NUM_LIT>, {'<STR_LIT>': <NUM_LIT>}, <NUM_LIT>) <EOL>'<STR_LIT>'.format(<NUM_LIT>)<EOL>", "docstring": "Test a regression using mixed manual position arguments\n    and attribute access arguments.", "id": "f18626:m7"}
{"signature": "def avoid_empty_attribute():", "body": "return \"<STR_LIT>\".format(<NUM_LIT:1>)<EOL>", "docstring": "The following string is invalid, avoid crashing.", "id": "f18626:m12"}
{"signature": "def issue338():", "body": "from collections import namedtuple<EOL>class Crash(namedtuple(\"<STR_LIT:C>\", \"<STR_LIT>\")):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>def __str__(self):<EOL><INDENT>return \"<STR_LIT>\".format(self)<EOL><DEDENT><DEDENT>return Crash<EOL>", "docstring": "Check that using a namedtuple subclass doesn't crash when\ntrying to infer EmptyNodes (resulted after mocking the\nmembers of namedtuples).", "id": "f18626:m8"}
{"signature": "def nested_issue294():", "body": "'<STR_LIT>'.format(<NUM_LIT>, <NUM_LIT>)<EOL>'<STR_LIT>'.format(<NUM_LIT:1>, a=[<NUM_LIT:1>, <NUM_LIT:2>])<EOL>'<STR_LIT>'.format(<NUM_LIT>, <NUM_LIT>)<EOL>'<STR_LIT>'.format(<NUM_LIT>) <EOL>'<STR_LIT>'.format(<NUM_LIT>, <NUM_LIT>, <NUM_LIT>) <EOL>'<STR_LIT>'.format(<NUM_LIT:1>) <EOL>'<STR_LIT>'.format(<NUM_LIT:1>, a=<NUM_LIT:2>)<EOL>", "docstring": "Test nested format fields.", "id": "f18626:m5"}
{"signature": "def yoo(self):", "body": "", "docstring": "yoo", "id": "f18633:c1:m2"}
{"signature": "def method2(self):", "body": "", "docstring": "docstring", "id": "f18633:c0:m2"}
{"signature": "def func2(): ", "body": "__revision__ = <NUM_LIT:1> <EOL>return __revision__<EOL>", "docstring": "docstring", "id": "f18633:m2"}
{"signature": "def func1():", "body": "", "docstring": "docstring", "id": "f18633:m0"}
{"signature": "def dummy_func():", "body": "pass<EOL>", "docstring": "Second dummy function, don't emit function-redefined message\n    because of the dummy name", "id": "f18633:m7"}
{"signature": "def unneeded_not():", "body": "bool_var = True<EOL>someint = <NUM_LIT:2><EOL>if not not bool_var:  <EOL><INDENT>pass<EOL><DEDENT>if not someint == <NUM_LIT:1>:  <EOL><INDENT>pass<EOL><DEDENT>if not someint != <NUM_LIT:1>:  <EOL><INDENT>pass<EOL><DEDENT>if not someint < <NUM_LIT:1>:  <EOL><INDENT>pass<EOL><DEDENT>if not someint > <NUM_LIT:1>:  <EOL><INDENT>pass<EOL><DEDENT>if not someint <= <NUM_LIT:1>:  <EOL><INDENT>pass<EOL><DEDENT>if not someint >= <NUM_LIT:1>:  <EOL><INDENT>pass<EOL><DEDENT>if not not someint:  <EOL><INDENT>pass<EOL><DEDENT>if not bool_var == True:  <EOL><INDENT>pass<EOL><DEDENT>if not bool_var == False:  <EOL><INDENT>pass<EOL><DEDENT>if not bool_var != True:  <EOL><INDENT>pass<EOL><DEDENT>if not True == True:  <EOL><INDENT>pass<EOL><DEDENT>if not <NUM_LIT:2> in [<NUM_LIT:3>, <NUM_LIT:4>]:  <EOL><INDENT>pass<EOL><DEDENT>if not someint is '<STR_LIT:test>':  <EOL><INDENT>pass<EOL><DEDENT>", "docstring": "This is not ok", "id": "f18641:m0"}
{"signature": "def ignored_arguments_function(arga, argu, argi,<EOL>_arge=<NUM_LIT:0>, _argt=<NUM_LIT:1>, _args=None):", "body": "arg0 = <NUM_LIT:0><EOL>arg1 = arg0 * <NUM_LIT:1> + arga<EOL>arg2 = arg1 * <NUM_LIT:2> + argu<EOL>arg3 = arg2 * <NUM_LIT:3> + argi<EOL>arg4 = arg3 * <NUM_LIT:4> + _arge<EOL>arg5 = arg4 * <NUM_LIT:5> + _argt<EOL>arg6 = arg5 * <NUM_LIT:6><EOL>arg7 = arg6 * <NUM_LIT:7><EOL>arg8 = arg7 * <NUM_LIT:8><EOL>arg9 = arg8 * <NUM_LIT:9><EOL>arg9 += arg0<EOL>if _args:<EOL><INDENT>arg9 += sum(_args)<EOL><DEDENT>return arg9<EOL>", "docstring": "pylint will ignore _arge, _argt, _args.\n\n    Consequently pylint will only coun 13 arguments.", "id": "f18642:m3"}
{"signature": "def too_many_arguments_function(arga, argu, argi, arge, argt, args): ", "body": "arga = argu<EOL>arga += argi<EOL>arga += arge<EOL>arga += argt<EOL>arga += args<EOL>return arga<EOL>", "docstring": "pylint will complains about too many arguments.", "id": "f18642:m2"}
{"signature": "def isinstances():", "body": "var = range(<NUM_LIT:10>)<EOL>if isinstance(var[<NUM_LIT:1>], (int, float)):<EOL><INDENT>pass<EOL><DEDENT>result = isinstance(var[<NUM_LIT:2>], (int, float))<EOL>if isinstance(var[<NUM_LIT:3>], int) or isinstance(var[<NUM_LIT:3>], float) or isinstance(var[<NUM_LIT:3>], list) and True:  <EOL><INDENT>pass<EOL><DEDENT>result = isinstance(var[<NUM_LIT:4>], int) or isinstance(var[<NUM_LIT:4>], float) or isinstance(var[<NUM_LIT:5>], list) and False  <EOL>result = isinstance(var[<NUM_LIT:5>], int) or True or isinstance(var[<NUM_LIT:5>], float)  <EOL>infered_isinstance = isinstance<EOL>result = infered_isinstance(var[<NUM_LIT:6>], int) or infered_isinstance(var[<NUM_LIT:6>], float) or infered_isinstance(var[<NUM_LIT:6>], list) and False   <EOL>result = isinstance(var[<NUM_LIT:10>], str) or isinstance(var[<NUM_LIT:10>], int) and var[<NUM_LIT:8>] * <NUM_LIT> or isinstance(var[<NUM_LIT:10>], float) and var[<NUM_LIT:5>] * <NUM_LIT> or isinstance(var[<NUM_LIT:10>], list)   <EOL>result = isinstance(var[<NUM_LIT:11>], int) or isinstance(var[<NUM_LIT:11>], int) or isinstance(var[<NUM_LIT:11>], float)   <EOL>result = isinstance(var[<NUM_LIT:20>])<EOL>result = isinstance()<EOL>result = isinstance(var[<NUM_LIT:12>], (int, float)) or isinstance(var[<NUM_LIT:12>], list)  <EOL>result = isinstance(var[<NUM_LIT:5>], int) and var[<NUM_LIT:5>] * <NUM_LIT> or isinstance(var[<NUM_LIT:5>], float) and var[<NUM_LIT:5>] * <NUM_LIT><EOL>result = isinstance(var[<NUM_LIT:7>], int) or not isinstance(var[<NUM_LIT:7>], float)<EOL>result = isinstance(var[<NUM_LIT:6>], int) or isinstance(var[<NUM_LIT:7>], float)<EOL>result = isinstance(var[<NUM_LIT:6>], int) or isinstance(var[<NUM_LIT:7>], int)<EOL>return result<EOL>", "docstring": "Examples of isinstances", "id": "f18663:m0"}
{"signature": "def __len__(self):", "body": "print(<NUM_LIT>)<EOL>", "docstring": "no i can not be a function", "id": "f18666:c4:m1"}
{"signature": "def __init__(self, first_argument):", "body": "", "docstring": "one argument function", "id": "f18667:c0:m0"}
{"signature": "def with_metaclass(meta, base=object):", "body": "return meta(\"<STR_LIT>\", (base, ), {})<EOL>", "docstring": "Create a new type that can be used as a metaclass.", "id": "f18667:m0"}
{"signature": "def continue2(<EOL>some_arg,<EOL>some_other_arg):", "body": "print(some_arg, some_other_arg)<EOL>", "docstring": "A function with well-aligned arguments.", "id": "f18670:m1"}
{"signature": "def good_method_name(self):", "body": "", "docstring": "A method with a good name.", "id": "f18678:c1:m2"}
{"signature": "def BadMethodName(self):", "body": "", "docstring": "Ignored since the method is in the interface.", "id": "f18678:c2:m1"}
{"signature": "def BADFUNCTION_name():  ", "body": "BAD_LOCAL_VAR = <NUM_LIT:1>  <EOL>print(BAD_LOCAL_VAR)<EOL>", "docstring": "Bad function name.", "id": "f18678:m0"}
{"signature": "def BadMethodName(self):  ", "body": "", "docstring": "A Method with a bad name.", "id": "f18678:c1:m1"}
{"signature": "def _nice_and_long_descriptive_private_method_name(self):", "body": "pass<EOL>", "docstring": "private method with long name", "id": "f18678:c3:m3"}
{"signature": "def good():", "body": "def nested_1():<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if <NUM_LIT:1>:<EOL><INDENT>pass<EOL><DEDENT>elif <NUM_LIT:2>:<EOL><INDENT>pass<EOL><DEDENT>elif <NUM_LIT:3>:<EOL><INDENT>pass<EOL><DEDENT>elif <NUM_LIT:4>:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>nested_1()<EOL>try:<EOL><INDENT>pass<EOL><DEDENT>finally:<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>pass<EOL><DEDENT>finally:<EOL><INDENT>pass<EOL><DEDENT>if <NUM_LIT:1>:<EOL><INDENT>pass<EOL><DEDENT>elif <NUM_LIT:2>:<EOL><INDENT>pass<EOL><DEDENT>elif <NUM_LIT:3>:<EOL><INDENT>pass<EOL><DEDENT>elif <NUM_LIT:4>:<EOL><INDENT>pass<EOL><DEDENT>elif <NUM_LIT:5>:<EOL><INDENT>pass<EOL><DEDENT>elif <NUM_LIT:6>:<EOL><INDENT>pass<EOL><DEDENT>elif <NUM_LIT:7>:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Too many branches only if we take\n    into consideration the nested functions.", "id": "f18680:m1"}
{"signature": "def _process_classes(classes):", "body": "return sorted([(isinstance(c.node, astroid.ClassDef), c.title) for c in classes])<EOL>", "docstring": "extract class names of a list", "id": "f18693:m0"}
{"signature": "def _process_relations(relations):", "body": "result = []<EOL>for rel_type, rels in relations.items():<EOL><INDENT>for rel in rels:<EOL><INDENT>result.append((rel_type, rel.from_object.title, rel.to_object.title))<EOL><DEDENT><DEDENT>result.sort()<EOL>return result<EOL>", "docstring": "extract relation indices from a relation list", "id": "f18693:m1"}
{"signature": "def _clean_paths(self, output):", "body": "return re.sub(<EOL>\"<STR_LIT>\", \"<STR_LIT>\", output.replace(\"<STR_LIT:\\\\>\", \"<STR_LIT:/>\"), flags=re.MULTILINE<EOL>)<EOL>", "docstring": "Remove version-specific tox parent directories from paths.", "id": "f18697:c1:m2"}
{"signature": "def __init__(truc):", "body": "print(<NUM_LIT:1>)<EOL>", "docstring": "method without self", "id": "f18702:c0:m0"}
{"signature": "def pprint():", "body": "print(\"<STR_LIT>\" % {'<STR_LIT>': <NUM_LIT:1>, '<STR_LIT>': <NUM_LIT:2>}) <EOL>print(\"<STR_LIT:%s>\" % (PARG_1, PARG_2)) <EOL>print(\"<STR_LIT>\" % {'<STR_LIT>': <NUM_LIT:1>, '<STR_LIT>': <NUM_LIT:2>}) <EOL>print(\"<STR_LIT>\" % {'<STR_LIT>': <NUM_LIT:1>}) <EOL>print(\"<STR_LIT>\" % {'<STR_LIT>': <NUM_LIT:1>, '<STR_LIT>':<NUM_LIT:2>, '<STR_LIT>':<NUM_LIT:3>}) <EOL>print(\"<STR_LIT>\" % {'<STR_LIT>': <NUM_LIT:1>, <NUM_LIT:2>:<NUM_LIT:3>}) <EOL>print(\"<STR_LIT>\" % (<NUM_LIT:2>, <NUM_LIT:3>)) <EOL>print(\"<STR_LIT>\" % [<NUM_LIT:2>, <NUM_LIT:3>]) <EOL>print(\"<STR_LIT>\" % PARG_1)<EOL>print(\"<STR_LIT>\" % PARG_2)<EOL>print(\"<STR_LIT>\" % <NUM_LIT:1>)<EOL>", "docstring": "Test string format", "id": "f18706:m0"}
{"signature": "def sys(self):", "body": "print(self, sys)<EOL>", "docstring": "should not get sys from there...", "id": "f18712:c0:m1"}
{"signature": "def func(yooo):", "body": "import os as ass<EOL>ass.remove(yooo)<EOL>import re<EOL>re.compile('<STR_LIT>')<EOL>", "docstring": "reimport in different scope", "id": "f18719:m0"}
{"signature": "def suppressed():", "body": "<EOL>var = <NUM_LIT:0><EOL>", "docstring": "A function with an unused variable.", "id": "f18730:m0"}
{"signature": "@myattr.setter<EOL><INDENT>def myattr(self, value):<DEDENT>", "body": "self._thing = value<EOL>", "docstring": "Setter for myattr.", "id": "f18733:c0:m2"}
{"signature": "def func_implicit_return_none():", "body": "return<EOL>", "docstring": "Function returning None from bare return statement.", "id": "f18734:m2"}
{"signature": "def generator():", "body": "yield <NUM_LIT:2><EOL>", "docstring": "no problemo", "id": "f18734:m4"}
{"signature": "def func_no_return():", "body": "print('<STR_LIT>')<EOL>", "docstring": "function without return", "id": "f18734:m0"}
{"signature": "def abstract_method(self):", "body": "raise NotImplementedError<EOL>", "docstring": "use to return something in concrete implementation", "id": "f18734:c0:m0"}
{"signature": "def generator_fp1(seq):", "body": "for val in seq:<EOL><INDENT>pass<EOL><DEDENT>for val in seq:<EOL><INDENT>yield val<EOL><DEDENT>", "docstring": "W0631 false positive", "id": "f18737:m1"}
{"signature": "def __init__(self):", "body": "self.e1101 = <NUM_LIT:1><EOL>", "docstring": "Set an attribute.", "id": "f18742:c0:m0"}
{"signature": "def __init__(self, host=None, port=<NUM_LIT:0>):", "body": "telnetlib.Telnet.__init__(self, host, port)<EOL>", "docstring": "Constructor.\nWhen called without arguments, create an unconnected instance.\nWith a hostname argument, it connects the instance; a port\nnumber is optional.\nParameter:\n- host: IP address of the host\n- port: Port number", "id": "f18743:c0:m0"}
{"signature": "def reset(self):", "body": "self.attr = <NUM_LIT:4><EOL>", "docstring": "reset members", "id": "f18743:c4:m2"}
{"signature": "def readUntilArray(self, matches, _=None):", "body": "self.process_rawq()<EOL>maxLength = <NUM_LIT:0><EOL>for match in matches:<EOL><INDENT>if len(match) > maxLength:<EOL><INDENT>maxLength = len(match)<EOL><DEDENT><DEDENT>", "docstring": "Read until a given string is encountered or until timeout.\n...", "id": "f18743:c0:m1"}
{"signature": "def somegen():", "body": "if True:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>yield <NUM_LIT:2><EOL><DEDENT>", "docstring": "this is a bad generator", "id": "f18749:m0"}
{"signature": "def moregen():", "body": "if True:<EOL><INDENT>yield <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>return <NUM_LIT:2><EOL><DEDENT>", "docstring": "this is another bad generator", "id": "f18749:m1"}
{"signature": "def reimport():", "body": "import sys<EOL>del sys<EOL>", "docstring": "This function contains a reimport.", "id": "f18761:m1"}
{"signature": "def visit_if(self, node):", "body": "branches = <NUM_LIT:1><EOL>if node.orelse and len(node.orelse) > <NUM_LIT:1>:<EOL><INDENT>branches += <NUM_LIT:1><EOL><DEDENT>self.inc_branch(branches)<EOL>self.stmts += branches<EOL>", "docstring": "increments the branches counter", "id": "f18764:m1"}
{"signature": "def get_project(module, name=\"<STR_LIT>\"):", "body": "def _astroid_wrapper(func, modname):<EOL><INDENT>return func(modname)<EOL><DEDENT>return project_from_files([module], _astroid_wrapper, project_name=name)<EOL>", "docstring": "return an astroid project representation", "id": "f18769:m1"}
{"signature": "def meth6(self):", "body": "<EOL>print(self.bla)<EOL>try:<EOL><INDENT>print(self.blip)<EOL><DEDENT>except UndefinedName: <EOL><INDENT>print(self.blip)<EOL><DEDENT>print(self.blip)<EOL>", "docstring": "test TRY/EXCEPT sub-block re-enabling", "id": "f18780:c0:m6"}
{"signature": "def meth3(self):", "body": "<EOL>print(self.bla) <EOL>print(self.blop)<EOL>", "docstring": "test one line disabling", "id": "f18780:c0:m3"}
{"signature": "def __init__(self):", "body": "", "docstring": "only to make pylint happier", "id": "f18792:c0:m0"}
{"signature": "def f10():", "body": "myint = <NUM_LIT:2><EOL>if myint == <NUM_LIT:5>:<EOL><INDENT>return myint<EOL><DEDENT>elif myint == <NUM_LIT:6>:<EOL><INDENT>return myint<EOL><DEDENT>elif myint == <NUM_LIT:7>:<EOL><INDENT>return myint<EOL><DEDENT>elif myint == <NUM_LIT:8>:<EOL><INDENT>return myint<EOL><DEDENT>elif myint == <NUM_LIT:9>:<EOL><INDENT>return myint<EOL><DEDENT>elif myint == <NUM_LIT:10>:<EOL><INDENT>if myint == <NUM_LIT:8>:<EOL><INDENT>while True:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>elif myint == <NUM_LIT:8>:<EOL><INDENT>with myint:<EOL><INDENT>return <NUM_LIT:8><EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if myint == <NUM_LIT:2>:<EOL><INDENT>return myint<EOL><DEDENT>return myint<EOL><DEDENT>return myint<EOL>", "docstring": "McCabe rating: 11", "id": "f18824:m9"}
{"signature": "def method1():", "body": "pass<EOL>", "docstring": "McCabe rating: 1", "id": "f18824:c0:m0"}
{"signature": "def check_messages(*messages):", "body": "return messages<EOL>", "docstring": "docstring", "id": "f18831:m0"}
{"signature": "def function2():", "body": "", "docstring": "Test Ok", "id": "f18831:m1"}
{"signature": "def method2(self):", "body": "", "docstring": "bad docstring 1", "id": "f18831:c0:m1"}
{"signature": "def exception_str(self, ex):  ", "body": "return \"<STR_LIT>\" % (ex.file, \"<STR_LIT:U+002CU+0020>\".join(ex.args))<EOL>", "docstring": "function used to replace default __str__ method of exception instances", "id": "f18846:m0"}
{"signature": "def set_msg_status(self, msg, line, status):", "body": "assert line > <NUM_LIT:0><EOL>try:<EOL><INDENT>self._module_msgs_state[msg.msgid][line] = status<EOL><DEDENT>except KeyError:<EOL><INDENT>self._module_msgs_state[msg.msgid] = {line: status}<EOL><DEDENT>", "docstring": "Set status (enabled/disable) for a given message at a given line", "id": "f18856:c0:m3"}
{"signature": "def load_plugin_modules(self, modnames):", "body": "for modname in modnames:<EOL><INDENT>if modname in self._dynamic_plugins:<EOL><INDENT>continue<EOL><DEDENT>self._dynamic_plugins.add(modname)<EOL>module = modutils.load_module_from_name(modname)<EOL>module.register(self)<EOL><DEDENT>", "docstring": "take a list of module names which are pylint plugins and load\n        and register them", "id": "f18861:c0:m3"}
{"signature": "def _report_evaluation(self):", "body": "<EOL>previous_stats = config.load_results(self.file_state.base_name)<EOL>if self.stats[\"<STR_LIT>\"] == <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>evaluation = self.config.evaluation<EOL>try:<EOL><INDENT>note = eval(evaluation, {}, self.stats)  <EOL><DEDENT>except Exception as ex:<EOL><INDENT>msg = \"<STR_LIT>\" % ex<EOL><DEDENT>else:<EOL><INDENT>self.stats[\"<STR_LIT>\"] = note<EOL>msg = \"<STR_LIT>\" % note<EOL>pnote = previous_stats.get(\"<STR_LIT>\")<EOL>if pnote is not None:<EOL><INDENT>msg += \"<STR_LIT>\" % (pnote, note - pnote)<EOL><DEDENT><DEDENT>if self.config.score:<EOL><INDENT>sect = report_nodes.EvaluationSection(msg)<EOL>self.reporter.display_reports(sect)<EOL><DEDENT>", "docstring": "make the global evaluation report", "id": "f18861:c0:m32"}
{"signature": "def register_checker(self, checker):", "body": "assert checker.priority <= <NUM_LIT:0>, \"<STR_LIT>\"<EOL>self._checkers[checker.name].append(checker)<EOL>for r_id, r_title, r_cb in checker.reports:<EOL><INDENT>self.register_report(r_id, r_title, r_cb, checker)<EOL><DEDENT>self.register_options_provider(checker)<EOL>if hasattr(checker, \"<STR_LIT>\"):<EOL><INDENT>self.msgs_store.register_messages_from_checker(checker)<EOL><DEDENT>checker.load_defaults()<EOL>if not getattr(checker, \"<STR_LIT>\", True):<EOL><INDENT>self.disable(checker.name)<EOL><DEDENT>", "docstring": "register a new checker\n\n        checker is an object implementing IRawChecker or / and IAstroidChecker", "id": "f18861:c0:m11"}
{"signature": "def python3_porting_mode(self):", "body": "self.disable(\"<STR_LIT:all>\")<EOL>self.enable(\"<STR_LIT>\")<EOL>if self._error_mode:<EOL><INDENT>for msg_id in self._checker_messages(\"<STR_LIT>\"):<EOL><INDENT>if msg_id.startswith(\"<STR_LIT:E>\"):<EOL><INDENT>self.enable(msg_id)<EOL><DEDENT>else:<EOL><INDENT>self.disable(msg_id)<EOL><DEDENT><DEDENT><DEDENT>config_parser = self.cfgfile_parser<EOL>if config_parser.has_option(\"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>value = config_parser.get(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>self.global_set_option(\"<STR_LIT>\", value)<EOL><DEDENT>self._python3_porting_mode = True<EOL>", "docstring": "Disable all other checkers and enable Python 3 warnings.", "id": "f18861:c0:m15"}
{"signature": "def report_messages_by_module_stats(sect, stats, _):", "body": "if len(stats[\"<STR_LIT>\"]) == <NUM_LIT:1>:<EOL><INDENT>raise exceptions.EmptyReportError()<EOL><DEDENT>by_mod = collections.defaultdict(dict)<EOL>for m_type in (\"<STR_LIT>\", \"<STR_LIT:error>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>total = stats[m_type]<EOL>for module in stats[\"<STR_LIT>\"].keys():<EOL><INDENT>mod_total = stats[\"<STR_LIT>\"][module][m_type]<EOL>if total == <NUM_LIT:0>:<EOL><INDENT>percent = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>percent = float((mod_total) * <NUM_LIT:100>) / total<EOL><DEDENT>by_mod[module][m_type] = percent<EOL><DEDENT><DEDENT>sorted_result = []<EOL>for module, mod_info in by_mod.items():<EOL><INDENT>sorted_result.append(<EOL>(<EOL>mod_info[\"<STR_LIT:error>\"],<EOL>mod_info[\"<STR_LIT>\"],<EOL>mod_info[\"<STR_LIT>\"],<EOL>mod_info[\"<STR_LIT>\"],<EOL>module,<EOL>)<EOL>)<EOL><DEDENT>sorted_result.sort()<EOL>sorted_result.reverse()<EOL>lines = [\"<STR_LIT>\", \"<STR_LIT:error>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]<EOL>for line in sorted_result:<EOL><INDENT>if all(entry == <NUM_LIT:0> for entry in line[:-<NUM_LIT:1>]):<EOL><INDENT>continue<EOL><DEDENT>lines.append(line[-<NUM_LIT:1>])<EOL>for val in line[:-<NUM_LIT:1>]:<EOL><INDENT>lines.append(\"<STR_LIT>\" % val)<EOL><DEDENT><DEDENT>if len(lines) == <NUM_LIT:5>:<EOL><INDENT>raise exceptions.EmptyReportError()<EOL><DEDENT>sect.append(report_nodes.Table(children=lines, cols=<NUM_LIT:5>, rheaders=<NUM_LIT:1>))<EOL>", "docstring": "make errors / warnings by modules report", "id": "f18861:m8"}
{"signature": "def cb_generate_config(self, *args, **kwargs):", "body": "self.linter.generate_config(skipsections=(\"<STR_LIT>\",))<EOL>sys.exit(<NUM_LIT:0>)<EOL>", "docstring": "optik callback for sample config file generation", "id": "f18861:c2:m4"}
{"signature": "def cb_add_plugins(self, name, value):", "body": "self._plugins.extend(utils._splitstrip(value))<EOL>", "docstring": "callback for option preprocessing (i.e. before option parsing)", "id": "f18861:c2:m2"}
{"signature": "def check_astroid_module(self, ast_node, walker, rawcheckers, tokencheckers):", "body": "try:<EOL><INDENT>tokens = utils.tokenize_module(ast_node)<EOL><DEDENT>except tokenize.TokenError as ex:<EOL><INDENT>self.add_message(\"<STR_LIT>\", line=ex.args[<NUM_LIT:1>][<NUM_LIT:0>], args=ex.args[<NUM_LIT:0>])<EOL>return None<EOL><DEDENT>if not ast_node.pure_python:<EOL><INDENT>self.add_message(\"<STR_LIT>\", args=ast_node.name)<EOL><DEDENT>else:<EOL><INDENT>self.process_tokens(tokens)<EOL>if self._ignore_file:<EOL><INDENT>return False<EOL><DEDENT>self.file_state.collect_block_lines(self.msgs_store, ast_node)<EOL>for checker in rawcheckers:<EOL><INDENT>checker.process_module(ast_node)<EOL><DEDENT>for checker in tokencheckers:<EOL><INDENT>checker.process_tokens(tokens)<EOL><DEDENT><DEDENT>walker.walk(ast_node)<EOL>return True<EOL>", "docstring": "Check a module from its astroid representation.", "id": "f18861:c0:m29"}
{"signature": "def set_reporter(self, reporter):", "body": "self.reporter = reporter<EOL>reporter.linter = self<EOL>", "docstring": "set the reporter used to display messages and reports", "id": "f18861:c0:m7"}
{"signature": "def cb_init_hook(optname, value):", "body": "exec(value)<EOL>", "docstring": "exec arbitrary code to set sys.path for instance", "id": "f18861:m12"}
{"signature": "@staticmethod<EOL><INDENT>def should_analyze_file(modname, path, is_argument=False):<DEDENT>", "body": "if is_argument:<EOL><INDENT>return True<EOL><DEDENT>return path.endswith(\"<STR_LIT>\")<EOL>", "docstring": "Returns whether or not a module should be checked.\n\n        This implementation returns True for all python source file, indicating\n        that all files should be linted.\n\n        Subclasses may override this method to indicate that modules satisfying\n        certain conditions should not be linted.\n\n        :param str modname: The name of the module to be checked.\n        :param str path: The full path to the source code of the module.\n        :param bool is_argument: Whetter the file is an argument to pylint or not.\n                                 Files which respect this property are always\n                                 checked, since the user requested it explicitly.\n        :returns: True if the module should be checked.\n        :rtype: bool", "id": "f18861:c0:m20"}
{"signature": "@contextlib.contextmanager<EOL>def fix_import_path(args):", "body": "orig = list(sys.path)<EOL>changes = []<EOL>for arg in args:<EOL><INDENT>path = _get_python_path(arg)<EOL>if path in changes:<EOL><INDENT>continue<EOL><DEDENT>else:<EOL><INDENT>changes.append(path)<EOL><DEDENT><DEDENT>sys.path[:] = changes + [\"<STR_LIT:.>\"] + sys.path<EOL>try:<EOL><INDENT>yield<EOL><DEDENT>finally:<EOL><INDENT>sys.path[:] = orig<EOL><DEDENT>", "docstring": "Prepare sys.path for running the linter checks.\n\n    Within this context, each of the given arguments is importable.\n    Paths are added to sys.path in corresponding order to the arguments.\n    We avoid adding duplicate directories to sys.path.\n    `sys.path` is reset to its original value upon exiting this context.", "id": "f18861:m10"}
{"signature": "def cb_help_message(self, option, optname, value, parser):", "body": "self.linter.msgs_store.help_message(utils._splitstrip(value))<EOL>sys.exit(<NUM_LIT:0>)<EOL>", "docstring": "optik callback for printing some help about a particular message", "id": "f18861:c2:m6"}
{"signature": "def visit_module(self, node):  ", "body": "<EOL>self._logging_names = set()<EOL>logging_mods = self.config.logging_modules<EOL>self._format_style = self.config.logging_format_style<EOL>self._logging_modules = set(logging_mods)<EOL>self._from_imports = {}<EOL>for logging_mod in logging_mods:<EOL><INDENT>parts = logging_mod.rsplit(\"<STR_LIT:.>\", <NUM_LIT:1>)<EOL>if len(parts) > <NUM_LIT:1>:<EOL><INDENT>self._from_imports[parts[<NUM_LIT:0>]] = parts[<NUM_LIT:1>]<EOL><DEDENT><DEDENT>", "docstring": "Clears any state left in this checker from last module checked.", "id": "f18863:c0:m0"}
{"signature": "def _check_format_string(self, node, format_arg):", "body": "num_args = _count_supplied_tokens(node.args[format_arg + <NUM_LIT:1> :])<EOL>if not num_args:<EOL><INDENT>return<EOL><DEDENT>format_string = node.args[format_arg].value<EOL>if not isinstance(format_string, str):<EOL><INDENT>required_num_args = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>if self._format_style == \"<STR_LIT>\":<EOL><INDENT>keyword_args, required_num_args, _, _ = utils.parse_format_string(<EOL>format_string<EOL>)<EOL>if keyword_args:<EOL><INDENT>return<EOL><DEDENT><DEDENT>elif self._format_style == \"<STR_LIT>\":<EOL><INDENT>keyword_arguments, implicit_pos_args, explicit_pos_args = utils.parse_format_method_string(<EOL>format_string<EOL>)<EOL>keyword_args_cnt = len(<EOL>set(k for k, l in keyword_arguments if not isinstance(k, int))<EOL>)<EOL>required_num_args = (<EOL>keyword_args_cnt + implicit_pos_args + explicit_pos_args<EOL>)<EOL><DEDENT><DEDENT>except utils.UnsupportedFormatCharacter as ex:<EOL><INDENT>char = format_string[ex.index]<EOL>self.add_message(<EOL>\"<STR_LIT>\",<EOL>node=node,<EOL>args=(char, ord(char), ex.index),<EOL>)<EOL>return<EOL><DEDENT>except utils.IncompleteFormatString:<EOL><INDENT>self.add_message(\"<STR_LIT>\", node=node)<EOL>return<EOL><DEDENT><DEDENT>if num_args > required_num_args:<EOL><INDENT>self.add_message(\"<STR_LIT>\", node=node)<EOL><DEDENT>elif num_args < required_num_args:<EOL><INDENT>self.add_message(\"<STR_LIT>\", node=node)<EOL><DEDENT>", "docstring": "Checks that format string tokens match the supplied arguments.\n\n        Args:\n          node (astroid.node_classes.NodeNG): AST node to be checked.\n          format_arg (int): Index of the format string in the node arguments.", "id": "f18863:c0:m7"}
{"signature": "def visit_import(self, node):", "body": "for module, as_name in node.names:<EOL><INDENT>if module in self._logging_modules:<EOL><INDENT>self._logging_names.add(as_name or module)<EOL><DEDENT><DEDENT>", "docstring": "Checks to see if this module uses Python's built-in logging.", "id": "f18863:c0:m2"}
{"signature": "@staticmethod<EOL><INDENT>def _is_operand_literal_str(operand):<DEDENT>", "body": "return isinstance(operand, astroid.Const) and operand.name == \"<STR_LIT:str>\"<EOL>", "docstring": "Return True if the operand in argument is a literal string", "id": "f18863:c0:m5"}
{"signature": "def is_method_call(func, types=(), methods=()):", "body": "return (<EOL>isinstance(func, astroid.BoundMethod)<EOL>and isinstance(func.bound, astroid.Instance)<EOL>and (func.bound.name in types if types else True)<EOL>and (func.name in methods if methods else True)<EOL>)<EOL>", "docstring": "Determines if a BoundMethod node represents a method call.\n\n    Args:\n      func (astroid.BoundMethod): The BoundMethod AST node to check.\n      types (Optional[String]): Optional sequence of caller type names to restrict check.\n      methods (Optional[String]): Optional sequence of method names to restrict check.\n\n    Returns:\n      bool: true if the node represents a method call for the given type and\n      method names, False otherwise.", "id": "f18863:m0"}
{"signature": "def register(linter):", "body": "linter.register_checker(EncodingChecker(linter))<EOL>linter.register_checker(ByIdManagedMessagesChecker(linter))<EOL>", "docstring": "required method to auto register this checker", "id": "f18864:m0"}
{"signature": "def _repr_tree_defs(data, indent_str=None):", "body": "lines = []<EOL>nodes = data.items()<EOL>for i, (mod, (sub, files)) in enumerate(sorted(nodes, key=lambda x: x[<NUM_LIT:0>])):<EOL><INDENT>if not files:<EOL><INDENT>files = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>files = \"<STR_LIT>\" % \"<STR_LIT:U+002C>\".join(sorted(files))<EOL><DEDENT>if indent_str is None:<EOL><INDENT>lines.append(\"<STR_LIT>\" % (mod, files))<EOL>sub_indent_str = \"<STR_LIT:U+0020>\"<EOL><DEDENT>else:<EOL><INDENT>lines.append(r\"<STR_LIT>\" % (indent_str, mod, files))<EOL>if i == len(nodes) - <NUM_LIT:1>:<EOL><INDENT>sub_indent_str = \"<STR_LIT>\" % indent_str<EOL><DEDENT>else:<EOL><INDENT>sub_indent_str = \"<STR_LIT>\" % indent_str<EOL><DEDENT><DEDENT>if sub:<EOL><INDENT>lines.append(_repr_tree_defs(sub, sub_indent_str))<EOL><DEDENT><DEDENT>return \"<STR_LIT:\\n>\".join(lines)<EOL>", "docstring": "return a string which represents imports as a tree", "id": "f18865:m5"}
{"signature": "def _make_tree_defs(mod_files_list):", "body": "tree_defs = {}<EOL>for mod, files in mod_files_list:<EOL><INDENT>node = (tree_defs, ())<EOL>for prefix in mod.split(\"<STR_LIT:.>\"):<EOL><INDENT>node = node[<NUM_LIT:0>].setdefault(prefix, [{}, []])<EOL><DEDENT>node[<NUM_LIT:1>] += files<EOL><DEDENT>return tree_defs<EOL>", "docstring": "get a list of 2-uple (module, list_of_files_which_import_this_module),\n    it will return a dictionary to represent this as a tree", "id": "f18865:m4"}
{"signature": "def _report_dependencies_graph(self, sect, _, _dummy):", "body": "dep_info = self.stats[\"<STR_LIT>\"]<EOL>if not dep_info or not (<EOL>self.config.import_graph<EOL>or self.config.ext_import_graph<EOL>or self.config.int_import_graph<EOL>):<EOL><INDENT>raise EmptyReportError()<EOL><DEDENT>filename = self.config.import_graph<EOL>if filename:<EOL><INDENT>_make_graph(filename, dep_info, sect, \"<STR_LIT>\")<EOL><DEDENT>filename = self.config.ext_import_graph<EOL>if filename:<EOL><INDENT>_make_graph(filename, self._external_dependencies_info(), sect, \"<STR_LIT>\")<EOL><DEDENT>filename = self.config.int_import_graph<EOL>if filename:<EOL><INDENT>_make_graph(filename, self._internal_dependencies_info(), sect, \"<STR_LIT>\")<EOL><DEDENT>", "docstring": "write dependencies as a dot (graphviz) file", "id": "f18865:c0:m24"}
{"signature": "def _dependencies_graph(filename, dep_info):", "body": "done = {}<EOL>printer = DotBackend(filename[:-<NUM_LIT:4>], rankdir=\"<STR_LIT>\")<EOL>printer.emit('<STR_LIT>')<EOL>for modname, dependencies in sorted(dep_info.items()):<EOL><INDENT>done[modname] = <NUM_LIT:1><EOL>printer.emit_node(modname)<EOL>for depmodname in dependencies:<EOL><INDENT>if depmodname not in done:<EOL><INDENT>done[depmodname] = <NUM_LIT:1><EOL>printer.emit_node(depmodname)<EOL><DEDENT><DEDENT><DEDENT>for depmodname, dependencies in sorted(dep_info.items()):<EOL><INDENT>for modname in dependencies:<EOL><INDENT>printer.emit_edge(modname, depmodname)<EOL><DEDENT><DEDENT>printer.generate(filename)<EOL>", "docstring": "write dependencies as a dot (graphviz) file", "id": "f18865:m6"}
{"signature": "@check_messages(*MSGS)<EOL><INDENT>def visit_importfrom(self, node):<DEDENT>", "body": "basename = node.modname<EOL>imported_module = self._get_imported_module(node, basename)<EOL>self._check_import_as_rename(node)<EOL>self._check_misplaced_future(node)<EOL>self._check_deprecated_module(node, basename)<EOL>self._check_preferred_module(node, basename)<EOL>self._check_wildcard_imports(node, imported_module)<EOL>self._check_same_line_imports(node)<EOL>self._check_reimport(node, basename=basename, level=node.level)<EOL>if isinstance(node.parent, astroid.Module):<EOL><INDENT>self._check_position(node)<EOL><DEDENT>if isinstance(node.scope(), astroid.Module):<EOL><INDENT>self._record_import(node, imported_module)<EOL><DEDENT>if imported_module is None:<EOL><INDENT>return<EOL><DEDENT>modnode = node.root()<EOL>self._check_relative_import(modnode, node, imported_module, basename)<EOL>for name, _ in node.names:<EOL><INDENT>if name != \"<STR_LIT:*>\":<EOL><INDENT>self._add_imported_module(node, \"<STR_LIT>\" % (imported_module.name, name))<EOL><DEDENT>else:<EOL><INDENT>self._add_imported_module(node, imported_module.name)<EOL><DEDENT><DEDENT>", "docstring": "triggered when a from statement is seen", "id": "f18865:c0:m6"}
{"signature": "@check_messages(*MSGS)<EOL><INDENT>def visit_import(self, node):<DEDENT>", "body": "self._check_reimport(node)<EOL>self._check_import_as_rename(node)<EOL>modnode = node.root()<EOL>names = [name for name, _ in node.names]<EOL>if len(names) >= <NUM_LIT:2>:<EOL><INDENT>self.add_message(\"<STR_LIT>\", args=\"<STR_LIT:U+002CU+0020>\".join(names), node=node)<EOL><DEDENT>for name in names:<EOL><INDENT>self._check_deprecated_module(node, name)<EOL>self._check_preferred_module(node, name)<EOL>imported_module = self._get_imported_module(node, name)<EOL>if isinstance(node.parent, astroid.Module):<EOL><INDENT>self._check_position(node)<EOL><DEDENT>if isinstance(node.scope(), astroid.Module):<EOL><INDENT>self._record_import(node, imported_module)<EOL><DEDENT>if imported_module is None:<EOL><INDENT>continue<EOL><DEDENT>self._check_relative_import(modnode, node, imported_module, name)<EOL>self._add_imported_module(node, imported_module.name)<EOL><DEDENT>", "docstring": "triggered when an import statement is seen", "id": "f18865:c0:m5"}
{"signature": "def _check_preferred_module(self, node, mod_path):", "body": "if mod_path in self.preferred_modules:<EOL><INDENT>self.add_message(<EOL>\"<STR_LIT>\",<EOL>node=node,<EOL>args=(self.preferred_modules[mod_path], mod_path),<EOL>)<EOL><DEDENT>", "docstring": "check if the module has a preferred replacement", "id": "f18865:c0:m20"}
{"signature": "def _check_relative_import(<EOL>self, modnode, importnode, importedmodnode, importedasname<EOL>):", "body": "if not self.linter.is_message_enabled(\"<STR_LIT>\"):<EOL><INDENT>return None<EOL><DEDENT>if importedmodnode.file is None:<EOL><INDENT>return False  <EOL><DEDENT>if modnode is importedmodnode:<EOL><INDENT>return False  <EOL><DEDENT>if modnode.absolute_import_activated() or getattr(importnode, \"<STR_LIT>\", None):<EOL><INDENT>return False<EOL><DEDENT>if importedmodnode.name != importedasname:<EOL><INDENT>self.add_message(<EOL>\"<STR_LIT>\",<EOL>args=(importedasname, importedmodnode.name),<EOL>node=importnode,<EOL>)<EOL>return None<EOL><DEDENT>return None<EOL>", "docstring": "check relative import. node is either an Import or From node, modname\n        the imported module name.", "id": "f18865:c0:m17"}
{"signature": "def _add_imported_module(self, node, importedmodname):", "body": "module_file = node.root().file<EOL>context_name = node.root().name<EOL>base = os.path.splitext(os.path.basename(module_file))[<NUM_LIT:0>]<EOL>try:<EOL><INDENT>importedmodname = astroid.modutils.get_module_part(<EOL>importedmodname, module_file<EOL>)<EOL><DEDENT>except ImportError:<EOL><INDENT>pass<EOL><DEDENT>if context_name == importedmodname:<EOL><INDENT>self.add_message(\"<STR_LIT>\", node=node)<EOL><DEDENT>elif not astroid.modutils.is_standard_module(importedmodname):<EOL><INDENT>if base != \"<STR_LIT>\" and context_name not in self._module_pkg:<EOL><INDENT>self._module_pkg[context_name] = context_name.rsplit(\"<STR_LIT:.>\", <NUM_LIT:1>)[<NUM_LIT:0>]<EOL><DEDENT>importedmodnames = self.stats[\"<STR_LIT>\"].setdefault(<EOL>importedmodname, set()<EOL>)<EOL>if context_name not in importedmodnames:<EOL><INDENT>importedmodnames.add(context_name)<EOL><DEDENT>self.import_graph[context_name].add(importedmodname)<EOL>if not self.linter.is_message_enabled(\"<STR_LIT>\", line=node.lineno):<EOL><INDENT>self._excluded_edges[context_name].add(importedmodname)<EOL><DEDENT><DEDENT>", "docstring": "notify an imported module, used to analyze dependencies", "id": "f18865:c0:m18"}
{"signature": "def visit_module(self, node):", "body": "self._to_consume = [NamesConsumer(node, \"<STR_LIT>\")]<EOL>self._postponed_evaluation_enabled = is_postponed_evaluation_enabled(node)<EOL>for name, stmts in node.locals.items():<EOL><INDENT>if utils.is_builtin(name) and not utils.is_inside_except(stmts[<NUM_LIT:0>]):<EOL><INDENT>if self._should_ignore_redefined_builtin(stmts[<NUM_LIT:0>]) or name == \"<STR_LIT>\":<EOL><INDENT>continue<EOL><DEDENT>self.add_message(\"<STR_LIT>\", args=name, node=stmts[<NUM_LIT:0>])<EOL><DEDENT><DEDENT>", "docstring": "visit module : update consumption analysis variable\n        checks globals doesn't overrides builtins", "id": "f18866:c1:m6"}
{"signature": "@lru_cache(maxsize=<NUM_LIT:1000>)<EOL>def overridden_method(klass, name):", "body": "try:<EOL><INDENT>parent = next(klass.local_attr_ancestors(name))<EOL><DEDENT>except (StopIteration, KeyError):<EOL><INDENT>return None<EOL><DEDENT>try:<EOL><INDENT>meth_node = parent[name]<EOL><DEDENT>except KeyError:<EOL><INDENT>return None<EOL><DEDENT>if isinstance(meth_node, astroid.FunctionDef):<EOL><INDENT>return meth_node<EOL><DEDENT>return None<EOL>", "docstring": "get overridden method if any", "id": "f18866:m2"}
{"signature": "def mark_as_consumed(self, name, new_node):", "body": "self.consumed[name] = new_node<EOL>del self.to_consume[name]<EOL>", "docstring": "Mark the name as consumed and delete it from\nthe to_consume dictionary", "id": "f18866:c0:m6"}
{"signature": "def _has_homonym_in_upper_function_scope(self, node, index):", "body": "for _consumer in self._to_consume[index - <NUM_LIT:1> :: -<NUM_LIT:1>]:<EOL><INDENT>if _consumer.scope_type == \"<STR_LIT>\" and node.name in _consumer.to_consume:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Return True if there is a node with the same name in the to_consume dict of an upper scope\nand if that scope is a function\n\n:param node: node to check for\n:type node: astroid.Node\n:param index: index of the current consumer inside self._to_consume\n:type index: int\n:return: True if there is a node with the same name in the to_consume dict of an upper scope\n         and if that scope is a function\n:rtype: bool", "id": "f18866:c1:m37"}
{"signature": "def _check_unpacking(self, infered, node, targets):", "body": "if utils.is_inside_abstract_class(node):<EOL><INDENT>return<EOL><DEDENT>if utils.is_comprehension(node):<EOL><INDENT>return<EOL><DEDENT>if infered is astroid.Uninferable:<EOL><INDENT>return<EOL><DEDENT>if (<EOL>isinstance(infered.parent, astroid.Arguments)<EOL>and isinstance(node.value, astroid.Name)<EOL>and node.value.name == infered.parent.vararg<EOL>):<EOL><INDENT>return<EOL><DEDENT>if isinstance(infered, (astroid.Tuple, astroid.List)):<EOL><INDENT>values = infered.itered()<EOL>if len(targets) != len(values):<EOL><INDENT>if any(isinstance(target, astroid.Starred) for target in targets):<EOL><INDENT>return<EOL><DEDENT>self.add_message(<EOL>\"<STR_LIT>\",<EOL>node=node,<EOL>args=(<EOL>_get_unpacking_extra_info(node, infered),<EOL>len(targets),<EOL>len(values),<EOL>),<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if not utils.is_iterable(infered):<EOL><INDENT>self.add_message(<EOL>\"<STR_LIT>\",<EOL>node=node,<EOL>args=(_get_unpacking_extra_info(node, infered),),<EOL>)<EOL><DEDENT><DEDENT>", "docstring": "Check for unbalanced tuple unpacking\n        and unpacking non sequences.", "id": "f18866:c1:m44"}
{"signature": "@utils.check_messages(<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>)<EOL><INDENT>def leave_module(self, node):<DEDENT>", "body": "assert len(self._to_consume) == <NUM_LIT:1><EOL>not_consumed = self._to_consume.pop().to_consume<EOL>if \"<STR_LIT>\" in node.locals:<EOL><INDENT>self._check_all(node, not_consumed)<EOL><DEDENT>self._check_globals(not_consumed)<EOL>if not self.config.init_import and node.package:<EOL><INDENT>return<EOL><DEDENT>self._check_imports(not_consumed)<EOL>", "docstring": "leave module: check globals", "id": "f18866:c1:m7"}
{"signature": "def leave_classdef(self, _):", "body": "<EOL>self._to_consume.pop()<EOL>", "docstring": "leave class: update consumption analysis variable", "id": "f18866:c1:m13"}
{"signature": "def leave_setcomp(self, _):", "body": "<EOL>self._to_consume.pop()<EOL>", "docstring": "leave setcomp: update consumption analysis variable", "id": "f18866:c1:m21"}
{"signature": "def leave_functiondef(self, node):", "body": "if node.type_comment_returns:<EOL><INDENT>self._store_type_annotation_node(node.type_comment_returns)<EOL><DEDENT>if node.type_comment_args:<EOL><INDENT>for argument_annotation in node.type_comment_args:<EOL><INDENT>self._store_type_annotation_node(argument_annotation)<EOL><DEDENT><DEDENT>not_consumed = self._to_consume.pop().to_consume<EOL>if not (<EOL>self.linter.is_message_enabled(\"<STR_LIT>\")<EOL>or self.linter.is_message_enabled(\"<STR_LIT>\")<EOL>or self.linter.is_message_enabled(\"<STR_LIT>\")<EOL>):<EOL><INDENT>return<EOL><DEDENT>if utils.is_error(node):<EOL><INDENT>return<EOL><DEDENT>is_method = node.is_method()<EOL>if is_method and node.is_abstract():<EOL><INDENT>return<EOL><DEDENT>global_names = _flattened_scope_names(node.nodes_of_class(astroid.Global))<EOL>nonlocal_names = _flattened_scope_names(node.nodes_of_class(astroid.Nonlocal))<EOL>for name, stmts in not_consumed.items():<EOL><INDENT>self._check_is_unused(name, node, stmts[<NUM_LIT:0>], global_names, nonlocal_names)<EOL><DEDENT>", "docstring": "leave function: check function's locals are consumed", "id": "f18866:c1:m25"}
{"signature": "def _is_from_future_import(stmt, name):", "body": "try:<EOL><INDENT>module = stmt.do_import_module(stmt.modname)<EOL><DEDENT>except astroid.AstroidBuildingException:<EOL><INDENT>return None<EOL><DEDENT>for local_node in module.locals.get(name, []):<EOL><INDENT>if isinstance(local_node, astroid.ImportFrom) and local_node.modname == FUTURE:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Check if the name is a future import from another module.", "id": "f18866:m0"}
{"signature": "def _check_metaclasses(self, node):", "body": "consumed = []  <EOL>for child_node in node.get_children():<EOL><INDENT>if isinstance(child_node, astroid.ClassDef):<EOL><INDENT>consumed.extend(self._check_classdef_metaclasses(child_node, node))<EOL><DEDENT><DEDENT>for scope_locals, name in consumed:<EOL><INDENT>scope_locals.pop(name, None)<EOL><DEDENT>", "docstring": "Update consumption analysis for metaclasses.", "id": "f18866:c2:m4"}
{"signature": "def _check_module_attrs(self, node, module, module_names):", "body": "assert isinstance(module, astroid.Module), module<EOL>while module_names:<EOL><INDENT>name = module_names.pop(<NUM_LIT:0>)<EOL>if name == \"<STR_LIT>\":<EOL><INDENT>module = None<EOL>break<EOL><DEDENT>try:<EOL><INDENT>module = next(module.getattr(name)[<NUM_LIT:0>].infer())<EOL>if module is astroid.Uninferable:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>except astroid.NotFoundError:<EOL><INDENT>if module.name in self._ignored_modules:<EOL><INDENT>return None<EOL><DEDENT>self.add_message(<EOL>\"<STR_LIT>\", args=(name, module.name), node=node<EOL>)<EOL>return None<EOL><DEDENT>except astroid.InferenceError:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>if module_names:<EOL><INDENT>modname = module.name if module else \"<STR_LIT>\"<EOL>self.add_message(<EOL>\"<STR_LIT>\", node=node, args=(\"<STR_LIT:.>\".join(module_names), modname)<EOL>)<EOL>return None<EOL><DEDENT>if isinstance(module, astroid.Module):<EOL><INDENT>return module<EOL><DEDENT>return None<EOL>", "docstring": "check that module_names (list of string) are accessible through the\n        given module\n        if the latest access name corresponds to a module, return it", "id": "f18866:c1:m45"}
{"signature": "def _get_unpacking_extra_info(node, infered):", "body": "more = \"<STR_LIT>\"<EOL>infered_module = infered.root().name<EOL>if node.root().name == infered_module:<EOL><INDENT>if node.lineno == infered.lineno:<EOL><INDENT>more = \"<STR_LIT>\" % infered.as_string()<EOL><DEDENT>elif infered.lineno:<EOL><INDENT>more = \"<STR_LIT>\" % infered.lineno<EOL><DEDENT><DEDENT>elif infered.lineno:<EOL><INDENT>more = \"<STR_LIT>\" % (infered.lineno, infered_module)<EOL><DEDENT>return more<EOL>", "docstring": "return extra information to add to the message for unpacking-non-sequence\n    and unbalanced-tuple-unpacking errors", "id": "f18866:m3"}
{"signature": "@check_messages(\"<STR_LIT>\", \"<STR_LIT>\")<EOL><INDENT>def visit_functiondef(self, node):<DEDENT>", "body": "<EOL>if not node.is_method():<EOL><INDENT>return<EOL><DEDENT>klass = node.parent.frame()<EOL>for stmt in node.nodes_of_class(astroid.Call):<EOL><INDENT>if node_frame_class(stmt) != node_frame_class(node):<EOL><INDENT>continue<EOL><DEDENT>expr = stmt.func<EOL>if not isinstance(expr, astroid.Attribute):<EOL><INDENT>continue<EOL><DEDENT>call = expr.expr<EOL>if not (<EOL>isinstance(call, astroid.Call)<EOL>and isinstance(call.func, astroid.Name)<EOL>and call.func.name == \"<STR_LIT>\"<EOL>):<EOL><INDENT>continue<EOL><DEDENT>if not klass.newstyle and has_known_bases(klass):<EOL><INDENT>continue<EOL><DEDENT>else:<EOL><INDENT>if not call.args:<EOL><INDENT>if sys.version_info[<NUM_LIT:0>] == <NUM_LIT:3>:<EOL><INDENT>continue<EOL><DEDENT>else:<EOL><INDENT>self.add_message(\"<STR_LIT>\", node=call)<EOL>continue<EOL><DEDENT><DEDENT>arg0 = call.args[<NUM_LIT:0>]<EOL>if (<EOL>isinstance(arg0, astroid.Call)<EOL>and isinstance(arg0.func, astroid.Name)<EOL>and arg0.func.name == \"<STR_LIT:type>\"<EOL>):<EOL><INDENT>self.add_message(\"<STR_LIT>\", node=call, args=(\"<STR_LIT:type>\",))<EOL>continue<EOL><DEDENT>if (<EOL>len(call.args) >= <NUM_LIT:2><EOL>and isinstance(call.args[<NUM_LIT:1>], astroid.Name)<EOL>and call.args[<NUM_LIT:1>].name == \"<STR_LIT>\"<EOL>and isinstance(arg0, astroid.Attribute)<EOL>and arg0.attrname == \"<STR_LIT>\"<EOL>):<EOL><INDENT>self.add_message(<EOL>\"<STR_LIT>\", node=call, args=(\"<STR_LIT>\",)<EOL>)<EOL>continue<EOL><DEDENT>try:<EOL><INDENT>supcls = call.args and next(call.args[<NUM_LIT:0>].infer(), None)<EOL><DEDENT>except astroid.InferenceError:<EOL><INDENT>continue<EOL><DEDENT>if klass is not supcls:<EOL><INDENT>name = None<EOL>if supcls:<EOL><INDENT>name = supcls.name<EOL><DEDENT>elif call.args and hasattr(call.args[<NUM_LIT:0>], \"<STR_LIT:name>\"):<EOL><INDENT>name = call.args[<NUM_LIT:0>].name<EOL><DEDENT>if name:<EOL><INDENT>self.add_message(\"<STR_LIT>\", node=call, args=(name,))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "check use of super", "id": "f18867:c0:m0"}
{"signature": "def get_access_path(key, parts):", "body": "path = []<EOL>for is_attribute, specifier in parts:<EOL><INDENT>if is_attribute:<EOL><INDENT>path.append(\"<STR_LIT>\".format(specifier))<EOL><DEDENT>else:<EOL><INDENT>path.append(\"<STR_LIT>\".format(specifier))<EOL><DEDENT><DEDENT>return str(key) + \"<STR_LIT>\".join(path)<EOL>", "docstring": "Given a list of format specifiers, returns\n    the final access path (e.g. a.b.c[0][1]).", "id": "f18868:m0"}
{"signature": "def _check_new_format(self, node, func):", "body": "<EOL>if isinstance(node.func, astroid.Attribute) and not isinstance(<EOL>node.func.expr, astroid.Const<EOL>):<EOL><INDENT>return<EOL><DEDENT>if node.starargs or node.kwargs:<EOL><INDENT>return<EOL><DEDENT>try:<EOL><INDENT>strnode = next(func.bound.infer())<EOL><DEDENT>except astroid.InferenceError:<EOL><INDENT>return<EOL><DEDENT>if not (isinstance(strnode, astroid.Const) and isinstance(strnode.value, str)):<EOL><INDENT>return<EOL><DEDENT>try:<EOL><INDENT>call_site = CallSite.from_call(node)<EOL><DEDENT>except astroid.InferenceError:<EOL><INDENT>return<EOL><DEDENT>try:<EOL><INDENT>fields, num_args, manual_pos = utils.parse_format_method_string(<EOL>strnode.value<EOL>)<EOL><DEDENT>except utils.IncompleteFormatString:<EOL><INDENT>self.add_message(\"<STR_LIT>\", node=node)<EOL>return<EOL><DEDENT>positional_arguments = call_site.positional_arguments<EOL>named_arguments = call_site.keyword_arguments<EOL>named_fields = {field[<NUM_LIT:0>] for field in fields if isinstance(field[<NUM_LIT:0>], str)}<EOL>if num_args and manual_pos:<EOL><INDENT>self.add_message(\"<STR_LIT>\", node=node)<EOL>return<EOL><DEDENT>check_args = False<EOL>num_args += sum(<NUM_LIT:1> for field in named_fields if field == \"<STR_LIT>\")<EOL>if named_fields:<EOL><INDENT>for field in named_fields:<EOL><INDENT>if field and field not in named_arguments:<EOL><INDENT>self.add_message(<EOL>\"<STR_LIT>\", node=node, args=(field,)<EOL>)<EOL><DEDENT><DEDENT>for field in named_arguments:<EOL><INDENT>if field not in named_fields:<EOL><INDENT>self.add_message(<EOL>\"<STR_LIT>\", node=node, args=(field,)<EOL>)<EOL><DEDENT><DEDENT>num_args = num_args or manual_pos<EOL>if positional_arguments or num_args:<EOL><INDENT>empty = any(True for field in named_fields if field == \"<STR_LIT>\")<EOL>if named_arguments or empty:<EOL><INDENT>check_args = True<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>check_args = True<EOL><DEDENT>if check_args:<EOL><INDENT>num_args = num_args or manual_pos<EOL>if len(positional_arguments) > num_args:<EOL><INDENT>self.add_message(\"<STR_LIT>\", node=node)<EOL><DEDENT>elif len(positional_arguments) < num_args:<EOL><INDENT>self.add_message(\"<STR_LIT>\", node=node)<EOL><DEDENT><DEDENT>self._detect_vacuous_formatting(node, positional_arguments)<EOL>self._check_new_format_specifiers(node, fields, named_arguments)<EOL>", "docstring": "Check the new string formatting.", "id": "f18868:c0:m3"}
{"signature": "@utils.check_messages(\"<STR_LIT>\")<EOL><INDENT>def visit_raise(self, node):<DEDENT>", "body": "self._check_unreachable(node)<EOL>", "docstring": "check if the node has a right sibling (if so, that's some unreachable\n        code)", "id": "f18869:c8:m17"}
{"signature": "def _check_in_loop(self, node, node_name):", "body": "_node = node.parent<EOL>while _node:<EOL><INDENT>if isinstance(_node, (astroid.For, astroid.While)):<EOL><INDENT>if node not in _node.orelse:<EOL><INDENT>return<EOL><DEDENT><DEDENT>if isinstance(_node, (astroid.ClassDef, astroid.FunctionDef)):<EOL><INDENT>break<EOL><DEDENT>if (<EOL>isinstance(_node, astroid.TryFinally)<EOL>and node in _node.finalbody<EOL>and isinstance(node, astroid.Continue)<EOL>):<EOL><INDENT>self.add_message(\"<STR_LIT>\", node=node)<EOL><DEDENT>_node = _node.parent<EOL><DEDENT>self.add_message(\"<STR_LIT>\", node=node, args=node_name)<EOL>", "docstring": "check that a node is inside a for or while loop", "id": "f18869:c7:m21"}
{"signature": "@utils.check_messages(\"<STR_LIT>\")<EOL><INDENT>def visit_lambda(self, node):<DEDENT>", "body": "<EOL>if node.args.defaults:<EOL><INDENT>return<EOL><DEDENT>call = node.body<EOL>if not isinstance(call, astroid.Call):<EOL><INDENT>return<EOL><DEDENT>if isinstance(node.body.func, astroid.Attribute) and isinstance(<EOL>node.body.func.expr, astroid.Call<EOL>):<EOL><INDENT>return<EOL><DEDENT>call_site = CallSite.from_call(call)<EOL>ordinary_args = list(node.args.args)<EOL>new_call_args = list(self._filter_vararg(node, call.args))<EOL>if node.args.kwarg:<EOL><INDENT>if self._has_variadic_argument(call.kwargs, node.args.kwarg):<EOL><INDENT>return<EOL><DEDENT><DEDENT>if node.args.vararg:<EOL><INDENT>if self._has_variadic_argument(call.starargs, node.args.vararg):<EOL><INDENT>return<EOL><DEDENT><DEDENT>elif call.starargs:<EOL><INDENT>return<EOL><DEDENT>if call.keywords:<EOL><INDENT>lambda_kwargs = {keyword.name for keyword in node.args.defaults}<EOL>if len(lambda_kwargs) != len(call_site.keyword_arguments):<EOL><INDENT>return<EOL><DEDENT>if set(call_site.keyword_arguments).difference(lambda_kwargs):<EOL><INDENT>return<EOL><DEDENT><DEDENT>if len(ordinary_args) != len(new_call_args):<EOL><INDENT>return<EOL><DEDENT>for arg, passed_arg in zip(ordinary_args, new_call_args):<EOL><INDENT>if not isinstance(passed_arg, astroid.Name):<EOL><INDENT>return<EOL><DEDENT>if arg.name != passed_arg.name:<EOL><INDENT>return<EOL><DEDENT><DEDENT>self.add_message(\"<STR_LIT>\", line=node.fromlineno, node=node)<EOL>", "docstring": "check whether or not the lambda is suspicious", "id": "f18869:c8:m11"}
{"signature": "@utils.check_messages(\"<STR_LIT>\")<EOL><INDENT>def visit_dict(self, node):<DEDENT>", "body": "keys = set()<EOL>for k, _ in node.items:<EOL><INDENT>if isinstance(k, astroid.Const):<EOL><INDENT>key = k.value<EOL>if key in keys:<EOL><INDENT>self.add_message(\"<STR_LIT>\", node=node, args=key)<EOL><DEDENT>keys.add(key)<EOL><DEDENT><DEDENT>", "docstring": "check duplicate key in dictionary", "id": "f18869:c8:m22"}
{"signature": "def register(linter):", "body": "linter.register_checker(BasicErrorChecker(linter))<EOL>linter.register_checker(BasicChecker(linter))<EOL>linter.register_checker(NameChecker(linter))<EOL>linter.register_checker(DocStringChecker(linter))<EOL>linter.register_checker(PassChecker(linter))<EOL>linter.register_checker(ComparisonChecker(linter))<EOL>", "docstring": "required method to auto register this checker", "id": "f18869:m13"}
{"signature": "def _get_break_loop_node(break_node):", "body": "loop_nodes = (astroid.For, astroid.While)<EOL>parent = break_node.parent<EOL>while not isinstance(parent, loop_nodes) or break_node in getattr(<EOL>parent, \"<STR_LIT>\", []<EOL>):<EOL><INDENT>break_node = parent<EOL>parent = parent.parent<EOL>if parent is None:<EOL><INDENT>break<EOL><DEDENT><DEDENT>return parent<EOL>", "docstring": "Returns the loop node that holds the break node in arguments.\n\nArgs:\n    break_node (astroid.Break): the break node of interest.\n\nReturns:\n    astroid.For or astroid.While: the loop node holding the break node.", "id": "f18869:m3"}
{"signature": "def visit_module(self, _):", "body": "self.stats[\"<STR_LIT>\"] += <NUM_LIT:1><EOL>", "docstring": "check module name, docstring and required arguments", "id": "f18869:c8:m6"}
{"signature": "@utils.check_messages(\"<STR_LIT>\", \"<STR_LIT>\")<EOL><INDENT>def visit_return(self, node):<DEDENT>", "body": "self._check_unreachable(node)<EOL>self._check_not_in_finally(node, \"<STR_LIT>\", (astroid.FunctionDef,))<EOL>", "docstring": "1 - check is the node has a right sibling (if so, that's some\n        unreachable code)\n        2 - check is the node is inside the finally clause of a try...finally\n        block", "id": "f18869:c8:m14"}
{"signature": "def _determine_function_name_type(node, config=None):", "body": "property_classes, property_names = _get_properties(config)<EOL>if not node.is_method():<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT>if node.decorators:<EOL><INDENT>decorators = node.decorators.nodes<EOL><DEDENT>else:<EOL><INDENT>decorators = []<EOL><DEDENT>for decorator in decorators:<EOL><INDENT>if isinstance(decorator, astroid.Name) or (<EOL>isinstance(decorator, astroid.Attribute)<EOL>and decorator.attrname in property_names<EOL>):<EOL><INDENT>infered = utils.safe_infer(decorator)<EOL>if infered and infered.qname() in property_classes:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT><DEDENT>elif isinstance(decorator, astroid.Attribute) and decorator.attrname in (<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>):<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT><DEDENT>return \"<STR_LIT>\"<EOL>", "docstring": "Determine the name type whose regex the a function's name should match.\n\n    :param node: A function node.\n    :type node: astroid.node_classes.NodeNG\n    :param config: Configuration from which to pull additional property classes.\n    :type config: :class:`optparse.Values`\n\n    :returns: One of ('function', 'method', 'attr')\n    :rtype: str", "id": "f18869:m7"}
{"signature": "def _check_nonlocal_and_global(self, node):", "body": "def same_scope(current):<EOL><INDENT>return current.scope() is node<EOL><DEDENT>from_iter = itertools.chain.from_iterable<EOL>nonlocals = set(<EOL>from_iter(<EOL>child.names<EOL>for child in node.nodes_of_class(astroid.Nonlocal)<EOL>if same_scope(child)<EOL>)<EOL>)<EOL>if not nonlocals:<EOL><INDENT>return<EOL><DEDENT>global_vars = set(<EOL>from_iter(<EOL>child.names<EOL>for child in node.nodes_of_class(astroid.Global)<EOL>if same_scope(child)<EOL>)<EOL>)<EOL>for name in nonlocals.intersection(global_vars):<EOL><INDENT>self.add_message(\"<STR_LIT>\", args=(name,), node=node)<EOL><DEDENT>", "docstring": "Check that a name is both nonlocal and global.", "id": "f18869:c7:m6"}
{"signature": "def _check_reversed(self, node):", "body": "try:<EOL><INDENT>argument = utils.safe_infer(utils.get_argument_from_call(node, position=<NUM_LIT:0>))<EOL><DEDENT>except utils.NoSuchArgumentError:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>if argument is astroid.Uninferable:<EOL><INDENT>return<EOL><DEDENT>if argument is None:<EOL><INDENT>if isinstance(node.args[<NUM_LIT:0>], astroid.Call):<EOL><INDENT>try:<EOL><INDENT>func = next(node.args[<NUM_LIT:0>].func.infer())<EOL><DEDENT>except astroid.InferenceError:<EOL><INDENT>return<EOL><DEDENT>if getattr(<EOL>func, \"<STR_LIT:name>\", None<EOL>) == \"<STR_LIT>\" and utils.is_builtin_object(func):<EOL><INDENT>self.add_message(\"<STR_LIT>\", node=node)<EOL><DEDENT><DEDENT>return<EOL><DEDENT>if isinstance(argument, (astroid.List, astroid.Tuple)):<EOL><INDENT>return<EOL><DEDENT>if isinstance(argument, astroid.Instance):<EOL><INDENT>if argument._proxied.name == \"<STR_LIT>\" and utils.is_builtin_object(<EOL>argument._proxied<EOL>):<EOL><INDENT>self.add_message(\"<STR_LIT>\", node=node)<EOL>return<EOL><DEDENT>if any(<EOL>ancestor.name == \"<STR_LIT>\" and utils.is_builtin_object(ancestor)<EOL>for ancestor in argument._proxied.ancestors()<EOL>):<EOL><INDENT>try:<EOL><INDENT>argument.locals[REVERSED_PROTOCOL_METHOD]<EOL><DEDENT>except KeyError:<EOL><INDENT>self.add_message(\"<STR_LIT>\", node=node)<EOL><DEDENT>return<EOL><DEDENT><DEDENT>if hasattr(argument, \"<STR_LIT>\"):<EOL><INDENT>for methods in REVERSED_METHODS:<EOL><INDENT>for meth in methods:<EOL><INDENT>try:<EOL><INDENT>argument.getattr(meth)<EOL><DEDENT>except astroid.NotFoundError:<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.add_message(\"<STR_LIT>\", node=node)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.add_message(\"<STR_LIT>\", node=node)<EOL><DEDENT><DEDENT>", "docstring": "check that the argument to `reversed` is a sequence", "id": "f18869:c8:m27"}
{"signature": "@utils.check_messages(\"<STR_LIT>\")<EOL><INDENT>def visit_assert(self, node):<DEDENT>", "body": "if (<EOL>node.fail is None<EOL>and isinstance(node.test, astroid.Tuple)<EOL>and len(node.test.elts) == <NUM_LIT:2><EOL>):<EOL><INDENT>self.add_message(\"<STR_LIT>\", node=node)<EOL><DEDENT>", "docstring": "check the use of an assert statement on a tuple.", "id": "f18869:c8:m21"}
{"signature": "def _check_type_x_is_y(self, node, left, operator, right):", "body": "left_func = utils.safe_infer(left.func)<EOL>if not (<EOL>isinstance(left_func, astroid.ClassDef) and left_func.qname() == TYPE_QNAME<EOL>):<EOL><INDENT>return<EOL><DEDENT>if operator in (\"<STR_LIT>\", \"<STR_LIT>\") and _is_one_arg_pos_call(right):<EOL><INDENT>right_func = utils.safe_infer(right.func)<EOL>if (<EOL>isinstance(right_func, astroid.ClassDef)<EOL>and right_func.qname() == TYPE_QNAME<EOL>):<EOL><INDENT>right_arg = utils.safe_infer(right.args[<NUM_LIT:0>])<EOL>if not isinstance(right_arg, LITERAL_NODE_TYPES):<EOL><INDENT>return<EOL><DEDENT><DEDENT><DEDENT>self.add_message(\"<STR_LIT>\", node=node)<EOL>", "docstring": "Check for expressions like type(x) == Y.", "id": "f18869:c12:m7"}
{"signature": "def leave_tryfinally(self, node):  ", "body": "self._tryfinallys.pop()<EOL>", "docstring": "update try...finally flag", "id": "f18869:c8:m24"}
{"signature": "@utils.check_messages(\"<STR_LIT>\")<EOL><INDENT>def visit_call(self, node):<DEDENT>", "body": "try:<EOL><INDENT>for inferred in node.func.infer():<EOL><INDENT>self._check_inferred_class_is_abstract(inferred, node)<EOL><DEDENT><DEDENT>except astroid.InferenceError:<EOL><INDENT>return<EOL><DEDENT>", "docstring": "Check instantiating abstract class with\n        abc.ABCMeta as metaclass.", "id": "f18869:c7:m17"}
{"signature": "def _check_unreachable(self, node):", "body": "unreach_stmt = node.next_sibling()<EOL>if unreach_stmt is not None:<EOL><INDENT>self.add_message(\"<STR_LIT>\", node=unreach_stmt)<EOL><DEDENT>", "docstring": "check unreachable code", "id": "f18869:c8:m25"}
{"signature": "def _check_name(self, node_type, name, node, confidence=interfaces.HIGH):", "body": "def _should_exempt_from_invalid_name(node):<EOL><INDENT>if node_type == \"<STR_LIT>\":<EOL><INDENT>inferred = utils.safe_infer(node)<EOL>if isinstance(inferred, astroid.ClassDef):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL><DEDENT>if utils.is_inside_except(node):<EOL><INDENT>clobbering, _ = utils.clobber_in_except(node)<EOL>if clobbering:<EOL><INDENT>return<EOL><DEDENT><DEDENT>if name in self.config.good_names:<EOL><INDENT>return<EOL><DEDENT>if name in self.config.bad_names:<EOL><INDENT>self.stats[\"<STR_LIT>\" + node_type] += <NUM_LIT:1><EOL>self.add_message(\"<STR_LIT>\", node=node, args=name)<EOL>return<EOL><DEDENT>regexp = self._name_regexps[node_type]<EOL>match = regexp.match(name)<EOL>if _is_multi_naming_match(match, node_type, confidence):<EOL><INDENT>name_group = self._find_name_group(node_type)<EOL>bad_name_group = self._bad_names.setdefault(name_group, {})<EOL>warnings = bad_name_group.setdefault(match.lastgroup, [])<EOL>warnings.append((node, node_type, name, confidence))<EOL><DEDENT>if match is None and not _should_exempt_from_invalid_name(node):<EOL><INDENT>self._raise_name_warning(node, node_type, name, confidence)<EOL><DEDENT>", "docstring": "check for a name using the type's regexp", "id": "f18869:c9:m12"}
{"signature": "def _has_different_parameters_default_value(original, overridden):", "body": "if original.args is None or overridden.args is None:<EOL><INDENT>return False<EOL><DEDENT>all_args = chain(original.args, original.kwonlyargs)<EOL>original_param_names = [param.name for param in all_args]<EOL>default_missing = object()<EOL>for param_name in original_param_names:<EOL><INDENT>try:<EOL><INDENT>original_default = original.default_value(param_name)<EOL><DEDENT>except astroid.exceptions.NoDefault:<EOL><INDENT>original_default = default_missing<EOL><DEDENT>try:<EOL><INDENT>overridden_default = overridden.default_value(param_name)<EOL><DEDENT>except astroid.exceptions.NoDefault:<EOL><INDENT>overridden_default = default_missing<EOL><DEDENT>default_list = [<EOL>arg == default_missing for arg in (original_default, overridden_default)<EOL>]<EOL>if any(default_list) and not all(default_list):<EOL><INDENT>return True<EOL><DEDENT>astroid_type_compared_attr = {<EOL>astroid.Const: \"<STR_LIT:value>\",<EOL>astroid.ClassDef: \"<STR_LIT:name>\",<EOL>astroid.Tuple: \"<STR_LIT>\",<EOL>astroid.List: \"<STR_LIT>\",<EOL>}<EOL>handled_types = tuple(<EOL>astroid_type for astroid_type in astroid_type_compared_attr<EOL>)<EOL>original_type = _get_node_type(original_default, handled_types)<EOL>if original_type:<EOL><INDENT>if not isinstance(overridden_default, original_type):<EOL><INDENT>return True<EOL><DEDENT>if not _check_arg_equality(<EOL>original_default,<EOL>overridden_default,<EOL>astroid_type_compared_attr[original_type],<EOL>):<EOL><INDENT>return True<EOL><DEDENT><DEDENT><DEDENT>return False<EOL>", "docstring": "Check if original and overridden methods arguments have different default values\n\nReturn True if one of the overridden arguments has a default\nvalue different from the default value of the original argument\nIf one of the method doesn't have argument (.args is None)\nreturn False", "id": "f18870:m6"}
{"signature": "def _different_parameters(original, overridden, dummy_parameter_regex):", "body": "original_parameters = _positional_parameters(original)<EOL>overridden_parameters = _positional_parameters(overridden)<EOL>different_positional = _has_different_parameters(<EOL>original_parameters, overridden_parameters, dummy_parameter_regex<EOL>)<EOL>different_kwonly = _has_different_parameters(<EOL>original.args.kwonlyargs, overridden.args.kwonlyargs, dummy_parameter_regex<EOL>)<EOL>if original.name in PYMETHODS:<EOL><INDENT>different_positional = different_kwonly = False<EOL><DEDENT>different_kwarg = (<EOL>sum(<NUM_LIT:1> for param in (original.args.kwarg, overridden.args.kwarg) if not param)<EOL>== <NUM_LIT:1><EOL>)<EOL>different_vararg = (<EOL>sum(<NUM_LIT:1> for param in (original.args.vararg, overridden.args.vararg) if not param)<EOL>== <NUM_LIT:1><EOL>)<EOL>return any(<EOL>(different_positional, different_kwarg, different_vararg, different_kwonly)<EOL>)<EOL>", "docstring": "Determine if the two methods have different parameters\n\n    They are considered to have different parameters if:\n\n       * they have different positional parameters, including different names\n\n       * one of the methods is having variadics, while the other is not\n\n       * they have different keyword only parameters.", "id": "f18870:m8"}
{"signature": "def _get_node_type(node, potential_types):", "body": "for potential_type in potential_types:<EOL><INDENT>if isinstance(node, potential_type):<EOL><INDENT>return potential_type<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Return the type of the node if it exists in potential_types.\n\nArgs:\n    node (astroid.node): node to get the type of.\n    potential_types (tuple): potential types of the node.\n\nReturns:\n    type: type of the node or None.", "id": "f18870:m4"}
{"signature": "def _check_consistent_mro(self, node):", "body": "try:<EOL><INDENT>node.mro()<EOL><DEDENT>except InconsistentMroError:<EOL><INDENT>self.add_message(\"<STR_LIT>\", args=node.name, node=node)<EOL><DEDENT>except DuplicateBasesError:<EOL><INDENT>self.add_message(\"<STR_LIT>\", args=node.name, node=node)<EOL><DEDENT>except NotImplementedError:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Detect that a class has a consistent mro or duplicate bases.", "id": "f18870:c1:m4"}
{"signature": "def set_accessed(self, node):", "body": "frame = node_frame_class(node)<EOL>if frame is None:<EOL><INDENT>return<EOL><DEDENT>self._scopes[frame][node.attrname].append(node)<EOL>", "docstring": "Set the given node as accessed.", "id": "f18870:c0:m1"}
{"signature": "def _check_proper_bases(self, node):", "body": "for base in node.bases:<EOL><INDENT>ancestor = safe_infer(base)<EOL>if ancestor in (astroid.Uninferable, None):<EOL><INDENT>continue<EOL><DEDENT>if isinstance(ancestor, astroid.Instance) and ancestor.is_subtype_of(<EOL>\"<STR_LIT>\" % (BUILTINS,)<EOL>):<EOL><INDENT>continue<EOL><DEDENT>if not isinstance(ancestor, astroid.ClassDef) or _is_invalid_base_class(<EOL>ancestor<EOL>):<EOL><INDENT>self.add_message(\"<STR_LIT>\", args=base.as_string(), node=node)<EOL><DEDENT>if ancestor.name == object.__name__:<EOL><INDENT>self.add_message(<EOL>\"<STR_LIT>\", args=node.name, node=node<EOL>)<EOL><DEDENT><DEDENT>", "docstring": "Detect that a class inherits something which is not\na class or a type.", "id": "f18870:c1:m5"}
{"signature": "def leave_functiondef(self, node):", "body": "if node.is_method():<EOL><INDENT>if node.args.args is not None:<EOL><INDENT>self._first_attrs.pop()<EOL><DEDENT>if not self.linter.is_message_enabled(\"<STR_LIT>\"):<EOL><INDENT>return<EOL><DEDENT>class_node = node.parent.frame()<EOL>if (<EOL>self._meth_could_be_func<EOL>and node.type == \"<STR_LIT>\"<EOL>and node.name not in PYMETHODS<EOL>and not (<EOL>node.is_abstract()<EOL>or overrides_a_method(class_node, node.name)<EOL>or decorated_with_property(node)<EOL>or _has_bare_super_call(node)<EOL>)<EOL>):<EOL><INDENT>self.add_message(\"<STR_LIT>\", node=node)<EOL><DEDENT><DEDENT>", "docstring": "on method node, check if this method couldn't be a function\n\n        ignore class, static and abstract methods, initializer,\n        methods overridden from a parent class.", "id": "f18870:c1:m11"}
{"signature": "def accessed(self, scope):", "body": "return self._scopes.get(scope, {})<EOL>", "docstring": "Get the accessed variables for the given scope.", "id": "f18870:c0:m2"}
{"signature": "def _check_protected_attribute_access(self, node):", "body": "attrname = node.attrname<EOL>if (<EOL>is_attr_protected(attrname)<EOL>and attrname not in self.config.exclude_protected<EOL>):<EOL><INDENT>klass = node_frame_class(node)<EOL>callee = node.expr.as_string()<EOL>if klass is None:<EOL><INDENT>self.add_message(\"<STR_LIT>\", node=node, args=attrname)<EOL>return<EOL><DEDENT>if (<EOL>isinstance(node.expr, astroid.Call)<EOL>and isinstance(node.expr.func, astroid.Name)<EOL>and node.expr.func.name == \"<STR_LIT>\"<EOL>):<EOL><INDENT>return<EOL><DEDENT>if self._is_type_self_call(node.expr):<EOL><INDENT>return<EOL><DEDENT>if not (callee == klass.name or callee in klass.basenames):<EOL><INDENT>stmt = node.parent.statement()<EOL>if (<EOL>isinstance(stmt, astroid.Assign)<EOL>and len(stmt.targets) == <NUM_LIT:1><EOL>and isinstance(stmt.targets[<NUM_LIT:0>], astroid.AssignName)<EOL>):<EOL><INDENT>name = stmt.targets[<NUM_LIT:0>].name<EOL>if _is_attribute_property(name, klass):<EOL><INDENT>return<EOL><DEDENT><DEDENT>self.add_message(\"<STR_LIT>\", node=node, args=attrname)<EOL><DEDENT><DEDENT>", "docstring": "Given an attribute access node (set or get), check if attribute\n        access is legitimate. Call _check_first_attr with node before calling\n        this method. Valid cases are:\n        * self._attr in a method or cls._attr in a classmethod. Checked by\n        _check_first_attr.\n        * Klass._attr inside \"Klass\" class.\n        * Klass2._attr inside \"Klass\" class when Klass2 is a base class of\n            Klass.", "id": "f18870:c1:m17"}
{"signature": "def _check_arg_equality(node_a, node_b, attr_name):", "body": "return getattr(node_a, attr_name) == getattr(node_b, attr_name)<EOL>", "docstring": "Check equality of nodes based on the comparison of their attributes named attr_name.\n\nArgs:\n    node_a (astroid.node): first node to compare.\n    node_b (astroid.node): second node to compare.\n    attr_name (str): name of the nodes attribute to use for comparison.\n\nReturns:\n    bool: True if node_a.attr_name == node_b.attr_name, False otherwise.", "id": "f18870:m5"}
{"signature": "def _ancestors_to_call(klass_node, method=\"<STR_LIT>\"):", "body": "to_call = {}<EOL>for base_node in klass_node.ancestors(recurs=False):<EOL><INDENT>try:<EOL><INDENT>to_call[base_node] = next(base_node.igetattr(method))<EOL><DEDENT>except astroid.InferenceError:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>return to_call<EOL>", "docstring": "return a dictionary where keys are the list of base classes providing\n    the queried method, and so that should/may be called from the method node", "id": "f18870:m16"}
{"signature": "def visit_name(self, node):", "body": "if self._first_attrs and (<EOL>node.name == self._first_attrs[-<NUM_LIT:1>] or not self._first_attrs[-<NUM_LIT:1>]<EOL>):<EOL><INDENT>self._meth_could_be_func = False<EOL><DEDENT>", "docstring": "check if the name handle an access to a class member\n        if so, register it", "id": "f18870:c1:m19"}
{"signature": "def _definition_equivalent_to_call(definition, call):", "body": "if definition.kwargs:<EOL><INDENT>same_kw_variadics = definition.kwargs in call.starred_kws<EOL><DEDENT>else:<EOL><INDENT>same_kw_variadics = not call.starred_kws<EOL><DEDENT>if definition.varargs:<EOL><INDENT>same_args_variadics = definition.varargs in call.starred_args<EOL><DEDENT>else:<EOL><INDENT>same_args_variadics = not call.starred_args<EOL><DEDENT>same_kwonlyargs = all(kw in call.kws for kw in definition.kwonlyargs)<EOL>same_args = definition.args == call.args<EOL>no_additional_kwarg_arguments = True<EOL>if call.kws:<EOL><INDENT>for keyword in call.kws:<EOL><INDENT>is_arg = keyword in call.args<EOL>is_kwonly = keyword in definition.kwonlyargs<EOL>if not is_arg and not is_kwonly:<EOL><INDENT>no_additional_kwarg_arguments = False<EOL>break<EOL><DEDENT><DEDENT><DEDENT>return all(<EOL>(<EOL>same_args,<EOL>same_kwonlyargs,<EOL>same_args_variadics,<EOL>same_kw_variadics,<EOL>no_additional_kwarg_arguments,<EOL>)<EOL>)<EOL>", "docstring": "Check if a definition signature is equivalent to a call.", "id": "f18870:m2"}
{"signature": "def _called_in_methods(func, klass, methods):", "body": "if not isinstance(func, astroid.FunctionDef):<EOL><INDENT>return False<EOL><DEDENT>for method in methods:<EOL><INDENT>try:<EOL><INDENT>infered = klass.getattr(method)<EOL><DEDENT>except astroid.NotFoundError:<EOL><INDENT>continue<EOL><DEDENT>for infer_method in infered:<EOL><INDENT>for call in infer_method.nodes_of_class(astroid.Call):<EOL><INDENT>try:<EOL><INDENT>bound = next(call.func.infer())<EOL><DEDENT>except (astroid.InferenceError, StopIteration):<EOL><INDENT>continue<EOL><DEDENT>if not isinstance(bound, astroid.BoundMethod):<EOL><INDENT>continue<EOL><DEDENT>func_obj = bound._proxied<EOL>if isinstance(func_obj, astroid.UnboundMethod):<EOL><INDENT>func_obj = func_obj._proxied<EOL><DEDENT>if func_obj.name == func.name:<EOL><INDENT>return True<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return False<EOL>", "docstring": "Check if the func was called in any of the given methods,\n    belonging to the *klass*. Returns True if so, False otherwise.", "id": "f18870:m11"}
{"signature": "def _continuation_inside_bracket(self, bracket, position):", "body": "indentation = self._tokens.line_indent(position)<EOL>token_indent = self._tokens.token_indent(position)<EOL>next_token_indent = self._tokens.token_indent(position + <NUM_LIT:1>)<EOL>if (<EOL>self._is_block_opener<EOL>and next_token_indent == indentation + self._block_indent_string<EOL>):<EOL><INDENT>return _ContinuedIndent(<EOL>CONTINUED_BLOCK,<EOL>bracket,<EOL>position,<EOL>_Indentations(token_indent),<EOL>_BeforeBlockIndentations(<EOL>next_token_indent, next_token_indent + self._continuation_string<EOL>),<EOL>)<EOL><DEDENT>return _ContinuedIndent(<EOL>CONTINUED,<EOL>bracket,<EOL>position,<EOL>_Indentations(token_indent, next_token_indent),<EOL>_Indentations(next_token_indent),<EOL>)<EOL>", "docstring": "Extracts indentation information for a continued indent.", "id": "f18874:c2:m11"}
{"signature": "def _get_indent_string(line):", "body": "result = \"<STR_LIT>\"<EOL>for char in line:<EOL><INDENT>if char in \"<STR_LIT>\":<EOL><INDENT>result += char<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Return the indention string of the given line.", "id": "f18874:m4"}
{"signature": "def next_logical_line(self):", "body": "self.next_physical_line()<EOL>self.retained_warnings = []<EOL>self._cont_stack = []<EOL>", "docstring": "Prepares the tracker for a new logical line (NEWLINE).\n\n        A new logical line only starts with block indentation.", "id": "f18874:c2:m7"}
{"signature": "def line_indent(self, idx):", "body": "return _get_indent_string(self.line(idx))<EOL>", "docstring": "Get the string of TABs and Spaces used for indentation of the line of this token", "id": "f18874:c1:m6"}
{"signature": "def _has_valid_type_annotation(self, tokens, i):", "body": "if not self._inside_brackets(\"<STR_LIT:(>\"):<EOL><INDENT>return False<EOL><DEDENT>bracket_level = <NUM_LIT:0><EOL>for token in tokens[i - <NUM_LIT:1> :: -<NUM_LIT:1>]:<EOL><INDENT>if token[<NUM_LIT:1>] == \"<STR_LIT::>\":<EOL><INDENT>return True<EOL><DEDENT>if token[<NUM_LIT:1>] == \"<STR_LIT:(>\":<EOL><INDENT>return False<EOL><DEDENT>if token[<NUM_LIT:1>] == \"<STR_LIT:]>\":<EOL><INDENT>bracket_level += <NUM_LIT:1><EOL><DEDENT>elif token[<NUM_LIT:1>] == \"<STR_LIT:[>\":<EOL><INDENT>bracket_level -= <NUM_LIT:1><EOL><DEDENT>elif token[<NUM_LIT:1>] == \"<STR_LIT:U+002C>\":<EOL><INDENT>if not bracket_level:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>elif token[<NUM_LIT:1>] in (\"<STR_LIT:.>\", \"<STR_LIT>\"):<EOL><INDENT>continue<EOL><DEDENT>elif token[<NUM_LIT:0>] not in (tokenize.NAME, tokenize.STRING, tokenize.NL):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Extended check of PEP-484 type hint presence", "id": "f18874:c3:m8"}
{"signature": "def _check_equals_spacing(self, tokens, i):", "body": "if self._has_valid_type_annotation(tokens, i):<EOL><INDENT>self._check_space(tokens, i, (_MUST, _MUST))<EOL><DEDENT>elif self._inside_brackets(\"<STR_LIT:(>\") or self._inside_brackets(\"<STR_LIT>\"):<EOL><INDENT>self._check_space(tokens, i, (_MUST_NOT, _MUST_NOT))<EOL><DEDENT>else:<EOL><INDENT>self._check_space(tokens, i, (_MUST, _MUST))<EOL><DEDENT>", "docstring": "Check the spacing of a single equals sign.", "id": "f18874:c3:m9"}
{"signature": "def get_valid_indentations(self, idx):", "body": "<EOL>stack_top = -<NUM_LIT:1><EOL>if (<EOL>self._tokens.token(idx) in (\"<STR_LIT:}>\", \"<STR_LIT>\")<EOL>and self._cont_stack[-<NUM_LIT:1>].token == \"<STR_LIT::>\"<EOL>):<EOL><INDENT>stack_top = -<NUM_LIT:2><EOL><DEDENT>indent = self._cont_stack[stack_top]<EOL>if self._tokens.token(idx) in _CLOSING_BRACKETS:<EOL><INDENT>valid_indentations = indent.valid_outdent_strings<EOL><DEDENT>else:<EOL><INDENT>valid_indentations = indent.valid_continuation_strings<EOL><DEDENT>return indent, valid_indentations.copy()<EOL>", "docstring": "Returns the valid offsets for the token at the given position.", "id": "f18874:c2:m9"}
{"signature": "def set_option(self, optname, value, action=None, optdict=None):", "body": "BaseChecker.set_option(self, optname, value, action, optdict)<EOL>if optname == \"<STR_LIT>\":<EOL><INDENT>self.min_lines = self.config.min_similarity_lines<EOL><DEDENT>elif optname == \"<STR_LIT>\":<EOL><INDENT>self.ignore_comments = self.config.ignore_comments<EOL><DEDENT>elif optname == \"<STR_LIT>\":<EOL><INDENT>self.ignore_docstrings = self.config.ignore_docstrings<EOL><DEDENT>elif optname == \"<STR_LIT>\":<EOL><INDENT>self.ignore_imports = self.config.ignore_imports<EOL><DEDENT>", "docstring": "method called to set an option (registered in the options list)\n\n        overridden to report options setting to Similar", "id": "f18875:c2:m1"}
{"signature": "def process_module(self, node):", "body": "with node.stream() as stream:<EOL><INDENT>self.append_stream(self.linter.current_name, stream, node.file_encoding)<EOL><DEDENT>", "docstring": "process a module\n\n        the module's content is accessible via the stream object\n\n        stream must implement the readlines method", "id": "f18875:c2:m3"}
{"signature": "def close(self):", "body": "total = sum(len(lineset) for lineset in self.linesets)<EOL>duplicated = <NUM_LIT:0><EOL>stats = self.stats<EOL>for num, couples in self._compute_sims():<EOL><INDENT>msg = []<EOL>for lineset, idx in couples:<EOL><INDENT>msg.append(\"<STR_LIT>\" % (lineset.name, idx))<EOL><DEDENT>msg.sort()<EOL>for line in lineset._real_lines[idx : idx + num]:<EOL><INDENT>msg.append(line.rstrip())<EOL><DEDENT>self.add_message(\"<STR_LIT>\", args=(len(couples), \"<STR_LIT:\\n>\".join(msg)))<EOL>duplicated += num * (len(couples) - <NUM_LIT:1>)<EOL><DEDENT>stats[\"<STR_LIT>\"] = duplicated<EOL>stats[\"<STR_LIT>\"] = total and duplicated * <NUM_LIT> / total<EOL>", "docstring": "compute and display similarities on closing (i.e. end of parsing)", "id": "f18875:c2:m4"}
{"signature": "def _display_sims(self, sims):", "body": "nb_lignes_dupliquees = <NUM_LIT:0><EOL>for num, couples in sims:<EOL><INDENT>print()<EOL>print(num, \"<STR_LIT>\", len(couples), \"<STR_LIT>\")<EOL>couples = sorted(couples)<EOL>for lineset, idx in couples:<EOL><INDENT>print(\"<STR_LIT>\" % (lineset.name, idx))<EOL><DEDENT>for line in lineset._real_lines[idx : idx + num]:<EOL><INDENT>print(\"<STR_LIT:U+0020>\", line.rstrip())<EOL><DEDENT>nb_lignes_dupliquees += num * (len(couples) - <NUM_LIT:1>)<EOL><DEDENT>nb_total_lignes = sum([len(lineset) for lineset in self.linesets])<EOL>print(<EOL>\"<STR_LIT>\"<EOL>% (<EOL>nb_total_lignes,<EOL>nb_lignes_dupliquees,<EOL>nb_lignes_dupliquees * <NUM_LIT> / nb_total_lignes,<EOL>)<EOL>)<EOL>", "docstring": "display computed similarities on stdout", "id": "f18875:c0:m4"}
{"signature": "def report_similarities(sect, stats, old_stats):", "body": "lines = [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]<EOL>lines += table_lines_from_stats(<EOL>stats, old_stats, (\"<STR_LIT>\", \"<STR_LIT>\")<EOL>)<EOL>sect.append(Table(children=lines, cols=<NUM_LIT:4>, rheaders=<NUM_LIT:1>, cheaders=<NUM_LIT:1>))<EOL>", "docstring": "make a layout with some stats about duplication", "id": "f18875:m1"}
{"signature": "def register(linter):", "body": "linter.register_checker(SimilarChecker(linter))<EOL>", "docstring": "required method to auto register this checker", "id": "f18875:m2"}
{"signature": "def stripped_lines(lines, ignore_comments, ignore_docstrings, ignore_imports):", "body": "if ignore_imports:<EOL><INDENT>tree = astroid.parse(\"<STR_LIT>\".join(lines))<EOL>node_is_import_by_lineno = (<EOL>(node.lineno, isinstance(node, (astroid.Import, astroid.ImportFrom)))<EOL>for node in tree.body<EOL>)<EOL>line_begins_import = {<EOL>lineno: all(is_import for _, is_import in node_is_import_group)<EOL>for lineno, node_is_import_group in groupby(<EOL>node_is_import_by_lineno, key=lambda x: x[<NUM_LIT:0>]<EOL>)<EOL>}<EOL>current_line_is_import = False<EOL><DEDENT>strippedlines = []<EOL>docstring = None<EOL>for lineno, line in enumerate(lines, start=<NUM_LIT:1>):<EOL><INDENT>line = line.strip()<EOL>if ignore_docstrings:<EOL><INDENT>if not docstring and any(<EOL>line.startswith(i) for i in ['<STR_LIT>', \"<STR_LIT>\", '<STR_LIT>', \"<STR_LIT>\"]<EOL>):<EOL><INDENT>docstring = line[:<NUM_LIT:3>]<EOL>line = line[<NUM_LIT:3>:]<EOL><DEDENT>if docstring:<EOL><INDENT>if line.endswith(docstring):<EOL><INDENT>docstring = None<EOL><DEDENT>line = \"<STR_LIT>\"<EOL><DEDENT><DEDENT>if ignore_imports:<EOL><INDENT>current_line_is_import = line_begins_import.get(<EOL>lineno, current_line_is_import<EOL>)<EOL>if current_line_is_import:<EOL><INDENT>line = \"<STR_LIT>\"<EOL><DEDENT><DEDENT>if ignore_comments:<EOL><INDENT>line = line.split(\"<STR_LIT:#>\", <NUM_LIT:1>)[<NUM_LIT:0>].strip()<EOL><DEDENT>strippedlines.append(line)<EOL><DEDENT>return strippedlines<EOL>", "docstring": "return lines with leading/trailing whitespace and any ignored code\n    features removed", "id": "f18875:m0"}
{"signature": "def _no_context_variadic(node, variadic_name, variadic_type, variadics):", "body": "statement = node.statement()<EOL>for name in statement.nodes_of_class(astroid.Name):<EOL><INDENT>if name.name != variadic_name:<EOL><INDENT>continue<EOL><DEDENT>inferred = safe_infer(name)<EOL>if isinstance(inferred, (astroid.List, astroid.Tuple)):<EOL><INDENT>length = len(inferred.elts)<EOL><DEDENT>elif isinstance(inferred, astroid.Dict):<EOL><INDENT>length = len(inferred.items)<EOL><DEDENT>else:<EOL><INDENT>continue<EOL><DEDENT>inferred_statement = inferred.statement()<EOL>if not length and isinstance(inferred_statement, astroid.FunctionDef):<EOL><INDENT>is_in_starred_context = _has_parent_of_type(node, variadic_type, statement)<EOL>used_as_starred_argument = _is_name_used_as_variadic(name, variadics)<EOL>if is_in_starred_context or used_as_starred_argument:<EOL><INDENT>return True<EOL><DEDENT><DEDENT><DEDENT>return False<EOL>", "docstring": "Verify if the given call node has variadic nodes without context\n\n    This is a workaround for handling cases of nested call functions\n    which don't have the specific call context at hand.\n    Variadic arguments (variable positional arguments and variable\n    keyword arguments) are inferred, inherently wrong, by astroid\n    as a Tuple, respectively a Dict with empty elements.\n    This can lead pylint to believe that a function call receives\n    too few arguments.", "id": "f18876:m14"}
{"signature": "def _is_owner_ignored(owner, name, ignored_classes, ignored_modules):", "body": "ignored_modules = set(ignored_modules)<EOL>module_name = owner.root().name<EOL>module_qname = owner.root().qname()<EOL>if any(<EOL>module_name in ignored_modules<EOL>or module_qname in ignored_modules<EOL>or fnmatch.fnmatch(module_qname, ignore)<EOL>for ignore in ignored_modules<EOL>):<EOL><INDENT>return True<EOL><DEDENT>ignored_classes = set(ignored_classes)<EOL>if hasattr(owner, \"<STR_LIT>\"):<EOL><INDENT>qname = owner.qname()<EOL><DEDENT>else:<EOL><INDENT>qname = \"<STR_LIT>\"<EOL><DEDENT>return any(ignore in (name, qname) for ignore in ignored_classes)<EOL>", "docstring": "Check if the given owner should be ignored\n\n    This will verify if the owner's module is in *ignored_modules*\n    or the owner's module fully qualified name is in *ignored_modules*\n    or if the *ignored_modules* contains a pattern which catches\n    the fully qualified name of the module.\n\n    Also, similar checks are done for the owner itself, if its name\n    matches any name from the *ignored_classes* or if its qualified\n    name can be found in *ignored_classes*.", "id": "f18876:m2"}
{"signature": "@check_messages(*(list(MSGS.keys())))<EOL><INDENT>def visit_call(self, node):<DEDENT>", "body": "called = safe_infer(node.func)<EOL>if called and not called.callable():<EOL><INDENT>if isinstance(called, astroid.Instance) and (<EOL>not has_known_bases(called)<EOL>or (<EOL>isinstance(called.scope(), astroid.ClassDef)<EOL>and \"<STR_LIT>\" in called.locals<EOL>)<EOL>):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>self.add_message(\"<STR_LIT>\", node=node, args=node.func.as_string())<EOL><DEDENT><DEDENT>self._check_uninferable_call(node)<EOL>try:<EOL><INDENT>called, implicit_args, callable_name = _determine_callable(called)<EOL><DEDENT>except ValueError:<EOL><INDENT>return<EOL><DEDENT>if called.args.args is None:<EOL><INDENT>return<EOL><DEDENT>if len(called.argnames()) != len(set(called.argnames())):<EOL><INDENT>return<EOL><DEDENT>call_site = astroid.arguments.CallSite.from_call(node)<EOL>for keyword in call_site.duplicated_keywords:<EOL><INDENT>self.add_message(\"<STR_LIT>\", node=node, args=(keyword,))<EOL><DEDENT>if call_site.has_invalid_arguments() or call_site.has_invalid_keywords():<EOL><INDENT>return<EOL><DEDENT>num_positional_args = len(call_site.positional_arguments)<EOL>keyword_args = list(call_site.keyword_arguments.keys())<EOL>if isinstance(node.scope(), astroid.FunctionDef):<EOL><INDENT>has_no_context_positional_variadic = _no_context_variadic_positional(node)<EOL>has_no_context_keywords_variadic = _no_context_variadic_keywords(node)<EOL><DEDENT>else:<EOL><INDENT>has_no_context_positional_variadic = (<EOL>has_no_context_keywords_variadic<EOL>) = False<EOL><DEDENT>already_filled_positionals = getattr(called, \"<STR_LIT>\", <NUM_LIT:0>)<EOL>already_filled_keywords = getattr(called, \"<STR_LIT>\", {})<EOL>keyword_args += list(already_filled_keywords)<EOL>num_positional_args += implicit_args + already_filled_positionals<EOL>num_mandatory_parameters = len(called.args.args) - len(called.args.defaults)<EOL>parameters = []<EOL>parameter_name_to_index = {}<EOL>for i, arg in enumerate(called.args.args):<EOL><INDENT>if isinstance(arg, astroid.Tuple):<EOL><INDENT>name = None<EOL><DEDENT>else:<EOL><INDENT>assert isinstance(arg, astroid.AssignName)<EOL>name = arg.name<EOL>parameter_name_to_index[name] = i<EOL><DEDENT>if i >= num_mandatory_parameters:<EOL><INDENT>defval = called.args.defaults[i - num_mandatory_parameters]<EOL><DEDENT>else:<EOL><INDENT>defval = None<EOL><DEDENT>parameters.append([(name, defval), False])<EOL><DEDENT>kwparams = {}<EOL>for i, arg in enumerate(called.args.kwonlyargs):<EOL><INDENT>if isinstance(arg, astroid.Keyword):<EOL><INDENT>name = arg.arg<EOL><DEDENT>else:<EOL><INDENT>assert isinstance(arg, astroid.AssignName)<EOL>name = arg.name<EOL><DEDENT>kwparams[name] = [called.args.kw_defaults[i], False]<EOL><DEDENT>for i in range(num_positional_args):<EOL><INDENT>if i < len(parameters):<EOL><INDENT>parameters[i][<NUM_LIT:1>] = True<EOL><DEDENT>elif called.args.vararg is not None:<EOL><INDENT>break<EOL><DEDENT>else:<EOL><INDENT>self.add_message(<EOL>\"<STR_LIT>\", node=node, args=(callable_name,)<EOL>)<EOL>break<EOL><DEDENT><DEDENT>for keyword in keyword_args:<EOL><INDENT>if keyword in parameter_name_to_index:<EOL><INDENT>i = parameter_name_to_index[keyword]<EOL>if parameters[i][<NUM_LIT:1>]:<EOL><INDENT>if not (keyword == \"<STR_LIT>\" and called.qname() in STR_FORMAT):<EOL><INDENT>self.add_message(<EOL>\"<STR_LIT>\",<EOL>node=node,<EOL>args=(keyword, callable_name),<EOL>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>parameters[i][<NUM_LIT:1>] = True<EOL><DEDENT><DEDENT>elif keyword in kwparams:<EOL><INDENT>if kwparams[keyword][<NUM_LIT:1>]:  <EOL><INDENT>self.add_message(<EOL>\"<STR_LIT>\",<EOL>node=node,<EOL>args=(keyword, callable_name),<EOL>)<EOL><DEDENT>else:<EOL><INDENT>kwparams[keyword][<NUM_LIT:1>] = True<EOL><DEDENT><DEDENT>elif called.args.kwarg is not None:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>self.add_message(<EOL>\"<STR_LIT>\", node=node, args=(keyword, callable_name)<EOL>)<EOL><DEDENT><DEDENT>if node.kwargs:<EOL><INDENT>for i, [(name, defval), assigned] in enumerate(parameters):<EOL><INDENT>if name is not None:<EOL><INDENT>parameters[i][<NUM_LIT:1>] = True<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>for [(name, defval), assigned] in parameters:<EOL><INDENT>if (defval is None) and not assigned:<EOL><INDENT>if name is None:<EOL><INDENT>display_name = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>display_name = repr(name)<EOL><DEDENT>if not has_no_context_positional_variadic:<EOL><INDENT>self.add_message(<EOL>\"<STR_LIT>\",<EOL>node=node,<EOL>args=(display_name, callable_name),<EOL>)<EOL><DEDENT><DEDENT><DEDENT>for name in kwparams:<EOL><INDENT>defval, assigned = kwparams[name]<EOL>if defval is None and not assigned and not has_no_context_keywords_variadic:<EOL><INDENT>self.add_message(\"<STR_LIT>\", node=node, args=(name, callable_name))<EOL><DEDENT><DEDENT>", "docstring": "check that called functions/methods are inferred to callable objects,\n        and that the arguments passed to the function match the parameters in\n        the inferred function's definition", "id": "f18876:c0:m10"}
{"signature": "def register(linter):", "body": "linter.register_checker(TypeChecker(linter))<EOL>linter.register_checker(IterableChecker(linter))<EOL>", "docstring": "required method to auto register this checker", "id": "f18876:m18"}
{"signature": "def process_tokens(self, tokens):", "body": "raise NotImplementedError()<EOL>", "docstring": "Should be overridden by subclasses.", "id": "f18877:c1:m0"}
{"signature": "def __init__(self, linter=None):", "body": "if self.name is not None:<EOL><INDENT>self.name = self.name.lower()<EOL><DEDENT>OptionsProviderMixIn.__init__(self)<EOL>self.linter = linter<EOL>", "docstring": "checker instances should have the linter as argument\n\n        :param ILinter linter: is an object implementing ILinter.", "id": "f18877:c0:m0"}
{"signature": "def collect_string_fields(format_string) -> Iterable[Optional[str]]:", "body": "formatter = string.Formatter()<EOL>try:<EOL><INDENT>parseiterator = formatter.parse(format_string)<EOL>for result in parseiterator:<EOL><INDENT>if all(item is None for item in result[<NUM_LIT:1>:]):<EOL><INDENT>continue<EOL><DEDENT>name = result[<NUM_LIT:1>]<EOL>nested = result[<NUM_LIT:2>]<EOL>yield name<EOL>if nested:<EOL><INDENT>for field in collect_string_fields(nested):<EOL><INDENT>yield field<EOL><DEDENT><DEDENT><DEDENT><DEDENT>except ValueError as exc:<EOL><INDENT>if exc.args[<NUM_LIT:0>].startswith(\"<STR_LIT>\"):<EOL><INDENT>yield \"<STR_LIT>\"<EOL>yield \"<STR_LIT:1>\"<EOL>return<EOL><DEDENT>raise IncompleteFormatString(format_string)<EOL><DEDENT>", "docstring": "Given a format string, return an iterator\n    of all the valid format fields. It handles nested fields\n    as well.", "id": "f18878:m18"}
{"signature": "def node_frame_class(<EOL>node: astroid.node_classes.NodeNG<EOL>) -> Optional[astroid.node_classes.NodeNG]:", "body": "klass = node.frame()<EOL>while klass is not None and not isinstance(klass, astroid.ClassDef):<EOL><INDENT>if klass.parent is None:<EOL><INDENT>klass = None<EOL><DEDENT>else:<EOL><INDENT>klass = klass.parent.frame()<EOL><DEDENT><DEDENT>return klass<EOL>", "docstring": "return klass node for a method node (or a staticmethod or a\n    classmethod), return null otherwise", "id": "f18878:m21"}
{"signature": "def is_node_inside_try_except(node: astroid.Raise) -> bool:", "body": "context = find_try_except_wrapper_node(node)<EOL>return isinstance(context, astroid.TryExcept)<EOL>", "docstring": "Check if the node is directly under a Try/Except statement.\n    (but not under an ExceptHandler!)\n\n    Args:\n        node (astroid.Raise): the node raising the exception.\n\n    Returns:\n        bool: True if the node is inside a try/except statement, False otherwise.", "id": "f18878:m34"}
{"signature": "def error_of_type(handler: astroid.ExceptHandler, error_type) -> bool:", "body": "def stringify_error(error):<EOL><INDENT>if not isinstance(error, str):<EOL><INDENT>return error.__name__<EOL><DEDENT>return error<EOL><DEDENT>if not isinstance(error_type, tuple):<EOL><INDENT>error_type = (error_type,)  <EOL><DEDENT>expected_errors = {stringify_error(error) for error in error_type}  <EOL>if not handler.type:<EOL><INDENT>return True<EOL><DEDENT>return handler.catch(expected_errors)<EOL>", "docstring": "Check if the given exception handler catches\nthe given error_type.\n\nThe *handler* parameter is a node, representing an ExceptHandler node.\nThe *error_type* can be an exception, such as AttributeError,\nthe name of an exception, or it can be a tuple of errors.\nThe function will return True if the handler catches any of the\ngiven errors.", "id": "f18878:m25"}
{"signature": "def is_from_fallback_block(node: astroid.node_classes.NodeNG) -> bool:", "body": "context = find_try_except_wrapper_node(node)<EOL>if not context:<EOL><INDENT>return False<EOL><DEDENT>if isinstance(context, astroid.ExceptHandler):<EOL><INDENT>other_body = context.parent.body<EOL>handlers = context.parent.handlers<EOL><DEDENT>else:<EOL><INDENT>other_body = itertools.chain.from_iterable(<EOL>handler.body for handler in context.handlers<EOL>)<EOL>handlers = context.handlers<EOL><DEDENT>has_fallback_imports = any(<EOL>isinstance(import_node, (astroid.ImportFrom, astroid.Import))<EOL>for import_node in other_body<EOL>)<EOL>ignores_import_error = _except_handlers_ignores_exception(handlers, ImportError)<EOL>return ignores_import_error or has_fallback_imports<EOL>", "docstring": "Check if the given node is from a fallback import block.", "id": "f18878:m31"}
{"signature": "def is_default_argument(node: astroid.node_classes.NodeNG) -> bool:", "body": "parent = node.scope()<EOL>if isinstance(parent, (astroid.FunctionDef, astroid.Lambda)):<EOL><INDENT>for default_node in parent.args.defaults:<EOL><INDENT>for default_name_node in default_node.nodes_of_class(astroid.Name):<EOL><INDENT>if default_name_node is node:<EOL><INDENT>return True<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return False<EOL>", "docstring": "return true if the given Name node is used in function or lambda\n    default argument's value", "id": "f18878:m10"}
{"signature": "def has_known_bases(klass: astroid.ClassDef, context=None) -> bool:", "body": "try:<EOL><INDENT>return klass._all_bases_known<EOL><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT>for base in klass.bases:<EOL><INDENT>result = safe_infer(base, context=context)<EOL>if (<EOL>not isinstance(result, astroid.ClassDef)<EOL>or result is klass<EOL>or not has_known_bases(result, context=context)<EOL>):<EOL><INDENT>klass._all_bases_known = False<EOL>return False<EOL><DEDENT><DEDENT>klass._all_bases_known = True<EOL>return True<EOL>", "docstring": "Return true if all base classes of a class could be inferred.", "id": "f18878:m56"}
{"signature": "def decorated_with(func: astroid.FunctionDef, qnames: Iterable[str]) -> bool:", "body": "decorators = func.decorators.nodes if func.decorators else []<EOL>for decorator_node in decorators:<EOL><INDENT>try:<EOL><INDENT>if any(<EOL>i is not None and i.qname() in qnames for i in decorator_node.infer()<EOL>):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>except astroid.InferenceError:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Determine if the `func` node has a decorator with the qualified name `qname`.", "id": "f18878:m28"}
{"signature": "def node_ignores_exception(<EOL>node: astroid.node_classes.NodeNG, exception=Exception<EOL>) -> bool:", "body": "managing_handlers = get_exception_handlers(node, exception)<EOL>if not managing_handlers:<EOL><INDENT>return False<EOL><DEDENT>return any(managing_handlers)<EOL>", "docstring": "Check if the node is in a TryExcept which handles the given exception.\n\n    If the exception is not given, the function is going to look for bare\n    excepts.", "id": "f18878:m35"}
{"signature": "@lru_cache(maxsize=<NUM_LIT>)<EOL>def safe_infer(<EOL>node: astroid.node_classes.NodeNG, context=None<EOL>) -> Optional[astroid.node_classes.NodeNG]:", "body": "try:<EOL><INDENT>inferit = node.infer(context=context)<EOL>value = next(inferit)<EOL><DEDENT>except astroid.InferenceError:<EOL><INDENT>return None<EOL><DEDENT>try:<EOL><INDENT>next(inferit)<EOL>return None  <EOL><DEDENT>except astroid.InferenceError:<EOL><INDENT>return None  <EOL><DEDENT>except StopIteration:<EOL><INDENT>return value<EOL><DEDENT>", "docstring": "Return the inferred value for the given node.\n\n    Return None if inference failed or if there is some ambiguity (more than\n    one node has been inferred).", "id": "f18878:m55"}
{"signature": "def get_node_last_lineno(node: astroid.node_classes.NodeNG) -> int:", "body": "<EOL>if getattr(node, \"<STR_LIT>\", False):<EOL><INDENT>return get_node_last_lineno(node.finalbody[-<NUM_LIT:1>])<EOL><DEDENT>if getattr(node, \"<STR_LIT>\", False):<EOL><INDENT>return get_node_last_lineno(node.orelse[-<NUM_LIT:1>])<EOL><DEDENT>if getattr(node, \"<STR_LIT>\", False):<EOL><INDENT>return get_node_last_lineno(node.handlers[-<NUM_LIT:1>])<EOL><DEDENT>if getattr(node, \"<STR_LIT:body>\", False):<EOL><INDENT>return get_node_last_lineno(node.body[-<NUM_LIT:1>])<EOL><DEDENT>return node.lineno<EOL>", "docstring": "Get the last lineno of the given node. For a simple statement this will just be node.lineno,\nbut for a node that has child statements (e.g. a method) this will be the lineno of the last\nchild statement recursively.", "id": "f18878:m60"}
{"signature": "@utils.check_messages(\"<STR_LIT>\", \"<STR_LIT>\")<EOL><INDENT>def visit_raise(self, node):<DEDENT>", "body": "<EOL>if node.exc is None:<EOL><INDENT>return<EOL><DEDENT>expr = node.exc<EOL>if self._check_raise_value(node, expr):<EOL><INDENT>return<EOL><DEDENT>try:<EOL><INDENT>value = next(astroid.unpack_infer(expr))<EOL><DEDENT>except astroid.InferenceError:<EOL><INDENT>return<EOL><DEDENT>self._check_raise_value(node, value)<EOL>", "docstring": "Visit a raise statement and check for raising\n        strings or old-raise-syntax.", "id": "f18879:c0:m31"}
{"signature": "@utils.check_messages(\"<STR_LIT>\", \"<STR_LIT>\")<EOL><INDENT>def visit_excepthandler(self, node):<DEDENT>", "body": "def _is_used_in_except_block(node):<EOL><INDENT>scope = node.scope()<EOL>current = node<EOL>while (<EOL>current<EOL>and current != scope<EOL>and not isinstance(current, astroid.ExceptHandler)<EOL>):<EOL><INDENT>current = current.parent<EOL><DEDENT>return isinstance(current, astroid.ExceptHandler) and current.type != node<EOL><DEDENT>if isinstance(node.name, (astroid.Tuple, astroid.List)):<EOL><INDENT>self.add_message(\"<STR_LIT>\", node=node)<EOL>return<EOL><DEDENT>if not node.name:<EOL><INDENT>return<EOL><DEDENT>scope = node.parent.scope()<EOL>scope_names = scope.nodes_of_class(astroid.Name, skip_klass=astroid.FunctionDef)<EOL>scope_names = list(scope_names)<EOL>potential_leaked_names = [<EOL>scope_name<EOL>for scope_name in scope_names<EOL>if scope_name.name == node.name.name<EOL>and scope_name.lineno > node.lineno<EOL>and not _is_used_in_except_block(scope_name)<EOL>]<EOL>reassignments_for_same_name = {<EOL>assign_name.lineno<EOL>for assign_name in scope.nodes_of_class(<EOL>astroid.AssignName, skip_klass=astroid.FunctionDef<EOL>)<EOL>if assign_name.name == node.name.name<EOL>}<EOL>for leaked_name in potential_leaked_names:<EOL><INDENT>if any(<EOL>node.lineno < elem < leaked_name.lineno<EOL>for elem in reassignments_for_same_name<EOL>):<EOL><INDENT>continue<EOL><DEDENT>self.add_message(\"<STR_LIT>\", node=leaked_name)<EOL><DEDENT>", "docstring": "Visit an except handler block and check for exception unpacking.", "id": "f18879:c0:m29"}
{"signature": "@utils.check_messages(\"<STR_LIT>\", \"<STR_LIT>\")<EOL><INDENT>def visit_attribute(self, node):<DEDENT>", "body": "if node.attrname == \"<STR_LIT>\":<EOL><INDENT>self.add_message(\"<STR_LIT>\", node=node)<EOL>return<EOL><DEDENT>exception_message = \"<STR_LIT:message>\"<EOL>try:<EOL><INDENT>for inferred in node.expr.infer():<EOL><INDENT>if isinstance(inferred, astroid.Instance) and utils.inherit_from_std_ex(<EOL>inferred<EOL>):<EOL><INDENT>if node.attrname == exception_message:<EOL><INDENT>if exception_message in inferred.instance_attrs:<EOL><INDENT>continue<EOL><DEDENT>self.add_message(\"<STR_LIT>\", node=node)<EOL><DEDENT><DEDENT>if isinstance(inferred, astroid.Module):<EOL><INDENT>self._warn_if_deprecated(<EOL>node, inferred.name, {node.attrname}, report_on_modules=False<EOL>)<EOL><DEDENT><DEDENT><DEDENT>except astroid.InferenceError:<EOL><INDENT>return<EOL><DEDENT>", "docstring": "Look for removed attributes", "id": "f18879:c0:m28"}
{"signature": "def visit_while(self, node):", "body": "branches = <NUM_LIT:1><EOL>if node.orelse:<EOL><INDENT>branches += <NUM_LIT:1><EOL><DEDENT>self._inc_branch(node, branches)<EOL>", "docstring": "increments the branches counter", "id": "f18880:c0:m14"}
{"signature": "def _count_boolean_expressions(bool_op):", "body": "nb_bool_expr = <NUM_LIT:0><EOL>for bool_expr in bool_op.get_children():<EOL><INDENT>if isinstance(bool_expr, BoolOp):<EOL><INDENT>nb_bool_expr += _count_boolean_expressions(bool_expr)<EOL><DEDENT>else:<EOL><INDENT>nb_bool_expr += <NUM_LIT:1><EOL><DEDENT><DEDENT>return nb_bool_expr<EOL>", "docstring": "Counts the number of boolean expressions in BoolOp `bool_op` (recursive)\n\n    example: a and (b or c or (d and e)) ==> 5 boolean expressions", "id": "f18880:m3"}
{"signature": "def visit_default(self, node):", "body": "if node.is_statement:<EOL><INDENT>self._inc_all_stmts(<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "default visit method -> increments the statements counter if\n        necessary", "id": "f18880:c0:m9"}
{"signature": "def open(self):", "body": "self.stats = self.linter.add_stats()<EOL>self._returns = []<EOL>self._branches = defaultdict(int)<EOL>self._stmts = []<EOL>", "docstring": "initialize visit variables", "id": "f18880:c0:m1"}
{"signature": "def visit_default(self, node):  ", "body": "", "docstring": "Default implementation for all the nodes.", "id": "f18882:c0:m2"}
{"signature": "def _check_datetime(self, node):", "body": "try:<EOL><INDENT>infered = next(node.infer())<EOL><DEDENT>except astroid.InferenceError:<EOL><INDENT>return<EOL><DEDENT>if isinstance(infered, Instance) and infered.qname() == \"<STR_LIT>\":<EOL><INDENT>self.add_message(\"<STR_LIT>\", node=node)<EOL><DEDENT>", "docstring": "Check that a datetime was infered.\n        If so, emit boolean-datetime warning.", "id": "f18883:c0:m11"}
{"signature": "def register(linter):", "body": "linter.register_checker(StdlibChecker(linter))<EOL>", "docstring": "required method to auto register this checker", "id": "f18883:m1"}
{"signature": "def _check_simplifiable_if(self, node):", "body": "if self._is_actual_elif(node):<EOL><INDENT>return<EOL><DEDENT>if len(node.orelse) != <NUM_LIT:1> or len(node.body) != <NUM_LIT:1>:<EOL><INDENT>return<EOL><DEDENT>first_branch = node.body[<NUM_LIT:0>]<EOL>else_branch = node.orelse[<NUM_LIT:0>]<EOL>if isinstance(first_branch, astroid.Return):<EOL><INDENT>if not isinstance(else_branch, astroid.Return):<EOL><INDENT>return<EOL><DEDENT>first_branch_is_bool = self._is_bool_const(first_branch)<EOL>else_branch_is_bool = self._is_bool_const(else_branch)<EOL>reduced_to = \"<STR_LIT>\"<EOL><DEDENT>elif isinstance(first_branch, astroid.Assign):<EOL><INDENT>if not isinstance(else_branch, astroid.Assign):<EOL><INDENT>return<EOL><DEDENT>first_branch_targets = [<EOL>target.name<EOL>for target in first_branch.targets<EOL>if isinstance(target, astroid.AssignName)<EOL>]<EOL>else_branch_targets = [<EOL>target.name<EOL>for target in else_branch.targets<EOL>if isinstance(target, astroid.AssignName)<EOL>]<EOL>if not first_branch_targets or not else_branch_targets:<EOL><INDENT>return<EOL><DEDENT>if sorted(first_branch_targets) != sorted(else_branch_targets):<EOL><INDENT>return<EOL><DEDENT>first_branch_is_bool = self._is_bool_const(first_branch)<EOL>else_branch_is_bool = self._is_bool_const(else_branch)<EOL>reduced_to = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>return<EOL><DEDENT>if not first_branch_is_bool or not else_branch_is_bool:<EOL><INDENT>return<EOL><DEDENT>if not first_branch.value.value:<EOL><INDENT>return<EOL><DEDENT>self.add_message(\"<STR_LIT>\", node=node, args=(reduced_to,))<EOL>", "docstring": "Check if the given if node can be simplified.\n\n        The if statement can be reduced to a boolean expression\n        in some cases. For instance, if there are two branches\n        and both of them return a boolean value that depends on\n        the result of the statement's test, then this can be reduced\n        to `bool(test)` without losing any functionality.", "id": "f18884:c0:m6"}
{"signature": "@staticmethod<EOL><INDENT>def _check_exception_inherit_from_stopiteration(exc):<DEDENT>", "body": "stopiteration_qname = \"<STR_LIT>\".format(utils.EXCEPTIONS_MODULE)<EOL>return any(_class.qname() == stopiteration_qname for _class in exc.mro())<EOL>", "docstring": "Return True if the exception node in argument inherit from StopIteration", "id": "f18884:c0:m24"}
{"signature": "def _is_node_return_ended(self, node):", "body": "<EOL>if isinstance(node, astroid.Return):<EOL><INDENT>return True<EOL><DEDENT>if isinstance(node, astroid.Call):<EOL><INDENT>try:<EOL><INDENT>funcdef_node = node.func.inferred()[<NUM_LIT:0>]<EOL>if self._is_function_def_never_returning(funcdef_node):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>except astroid.InferenceError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if isinstance(node, astroid.While):<EOL><INDENT>return True<EOL><DEDENT>if isinstance(node, astroid.Raise):<EOL><INDENT>if not node.exc:<EOL><INDENT>return True<EOL><DEDENT>if not utils.is_node_inside_try_except(node):<EOL><INDENT>return True<EOL><DEDENT>exc = utils.safe_infer(node.exc)<EOL>if exc is None or exc is astroid.Uninferable:<EOL><INDENT>return False<EOL><DEDENT>exc_name = exc.pytype().split(\"<STR_LIT:.>\")[-<NUM_LIT:1>]<EOL>handlers = utils.get_exception_handlers(node, exc_name)<EOL>handlers = list(handlers) if handlers is not None else []<EOL>if handlers:<EOL><INDENT>return any(<EOL>self._is_node_return_ended(_handler) for _handler in handlers<EOL>)<EOL><DEDENT>return True<EOL><DEDENT>if isinstance(node, astroid.If):<EOL><INDENT>is_orelse_returning = any(<EOL>self._is_node_return_ended(_ore)<EOL>for _ore in node.orelse<EOL>if not isinstance(_ore, astroid.FunctionDef)<EOL>)<EOL>is_if_returning = any(<EOL>self._is_node_return_ended(_ifn)<EOL>for _ifn in node.body<EOL>if not isinstance(_ifn, astroid.FunctionDef)<EOL>)<EOL>return is_if_returning and is_orelse_returning<EOL><DEDENT>return any(<EOL>self._is_node_return_ended(_child)<EOL>for _child in node.get_children()<EOL>if not isinstance(_child, astroid.ExceptHandler)<EOL>)<EOL>", "docstring": "Check if the node ends with an explicit return statement.\n\n        Args:\n            node (astroid.NodeNG): node to be checked.\n\n        Returns:\n            bool: True if the node ends with an explicit statement, False otherwise.", "id": "f18884:c0:m44"}
{"signature": "def _check_chained_comparison(self, node):", "body": "if node.op != \"<STR_LIT>\" or len(node.values) < <NUM_LIT:2>:<EOL><INDENT>return<EOL><DEDENT>def _find_lower_upper_bounds(comparison_node, uses):<EOL><INDENT>left_operand = comparison_node.left<EOL>for operator, right_operand in comparison_node.ops:<EOL><INDENT>for operand in (left_operand, right_operand):<EOL><INDENT>value = None<EOL>if isinstance(operand, astroid.Name):<EOL><INDENT>value = operand.name<EOL><DEDENT>elif isinstance(operand, astroid.Const):<EOL><INDENT>value = operand.value<EOL><DEDENT>if value is None:<EOL><INDENT>continue<EOL><DEDENT>if operator in (\"<STR_LIT:<>\", \"<STR_LIT>\"):<EOL><INDENT>if operand is left_operand:<EOL><INDENT>uses[value][\"<STR_LIT>\"].add(comparison_node)<EOL><DEDENT>elif operand is right_operand:<EOL><INDENT>uses[value][\"<STR_LIT>\"].add(comparison_node)<EOL><DEDENT><DEDENT>elif operator in (\"<STR_LIT:>>\", \"<STR_LIT>\"):<EOL><INDENT>if operand is left_operand:<EOL><INDENT>uses[value][\"<STR_LIT>\"].add(comparison_node)<EOL><DEDENT>elif operand is right_operand:<EOL><INDENT>uses[value][\"<STR_LIT>\"].add(comparison_node)<EOL><DEDENT><DEDENT><DEDENT>left_operand = right_operand<EOL><DEDENT><DEDENT>uses = collections.defaultdict(<EOL>lambda: {\"<STR_LIT>\": set(), \"<STR_LIT>\": set()}<EOL>)<EOL>for comparison_node in node.values:<EOL><INDENT>if isinstance(comparison_node, astroid.Compare):<EOL><INDENT>_find_lower_upper_bounds(comparison_node, uses)<EOL><DEDENT><DEDENT>for _, bounds in uses.items():<EOL><INDENT>num_shared = len(bounds[\"<STR_LIT>\"].intersection(bounds[\"<STR_LIT>\"]))<EOL>num_lower_bounds = len(bounds[\"<STR_LIT>\"])<EOL>num_upper_bounds = len(bounds[\"<STR_LIT>\"])<EOL>if num_shared < num_lower_bounds and num_shared < num_upper_bounds:<EOL><INDENT>self.add_message(\"<STR_LIT>\", node=node)<EOL>break<EOL><DEDENT><DEDENT>", "docstring": "Check if there is any chained comparison in the expression.\n\n        Add a refactoring message if a boolOp contains comparison like a < b and b < c,\n        which can be chained as a < b < c.\n\n        Care is taken to avoid simplifying a < b < c and b < d.", "id": "f18884:c0:m33"}
{"signature": "@staticmethod<EOL><INDENT>def _duplicated_isinstance_types(node):<DEDENT>", "body": "duplicated_objects = set()<EOL>all_types = collections.defaultdict(set)<EOL>for call in node.values:<EOL><INDENT>if not isinstance(call, astroid.Call) or len(call.args) != <NUM_LIT:2>:<EOL><INDENT>continue<EOL><DEDENT>inferred = utils.safe_infer(call.func)<EOL>if not inferred or not utils.is_builtin_object(inferred):<EOL><INDENT>continue<EOL><DEDENT>if inferred.name != \"<STR_LIT>\":<EOL><INDENT>continue<EOL><DEDENT>isinstance_object = call.args[<NUM_LIT:0>].as_string()<EOL>isinstance_types = call.args[<NUM_LIT:1>]<EOL>if isinstance_object in all_types:<EOL><INDENT>duplicated_objects.add(isinstance_object)<EOL><DEDENT>if isinstance(isinstance_types, astroid.Tuple):<EOL><INDENT>elems = [<EOL>class_type.as_string() for class_type in isinstance_types.itered()<EOL>]<EOL><DEDENT>else:<EOL><INDENT>elems = [isinstance_types.as_string()]<EOL><DEDENT>all_types[isinstance_object].update(elems)<EOL><DEDENT>return {<EOL>key: value for key, value in all_types.items() if key in duplicated_objects<EOL>}<EOL>", "docstring": "Get the duplicated types from the underlying isinstance calls.\n\n        :param astroid.BoolOp node: Node which should contain a bunch of isinstance calls.\n        :returns: Dictionary of the comparison objects from the isinstance calls,\n                  to duplicate values from consecutive calls.\n        :rtype: dict", "id": "f18884:c0:m30"}
{"signature": "@utils.check_messages(\"<STR_LIT>\")<EOL><INDENT>def visit_for(self, node):<DEDENT>", "body": "<EOL>if not isinstance(node.iter, astroid.Call):<EOL><INDENT>return<EOL><DEDENT>if not self._is_builtin(node.iter.func, \"<STR_LIT>\"):<EOL><INDENT>return<EOL><DEDENT>if len(node.iter.args) == <NUM_LIT:2> and not _is_constant_zero(node.iter.args[<NUM_LIT:0>]):<EOL><INDENT>return<EOL><DEDENT>if len(node.iter.args) > <NUM_LIT:2>:<EOL><INDENT>return<EOL><DEDENT>if not isinstance(node.iter.args[-<NUM_LIT:1>], astroid.Call):<EOL><INDENT>return<EOL><DEDENT>second_func = node.iter.args[-<NUM_LIT:1>].func<EOL>if not self._is_builtin(second_func, \"<STR_LIT>\"):<EOL><INDENT>return<EOL><DEDENT>len_args = node.iter.args[-<NUM_LIT:1>].args<EOL>if not len_args or len(len_args) != <NUM_LIT:1>:<EOL><INDENT>return<EOL><DEDENT>iterating_object = len_args[<NUM_LIT:0>]<EOL>if not isinstance(iterating_object, astroid.Name):<EOL><INDENT>return<EOL><DEDENT>scope = node.scope()<EOL>if iterating_object.name == \"<STR_LIT>\" and scope.name == \"<STR_LIT>\":<EOL><INDENT>return<EOL><DEDENT>for child in node.body:<EOL><INDENT>for subscript in child.nodes_of_class(astroid.Subscript):<EOL><INDENT>if not isinstance(subscript.value, astroid.Name):<EOL><INDENT>continue<EOL><DEDENT>if not isinstance(subscript.slice, astroid.Index):<EOL><INDENT>continue<EOL><DEDENT>if not isinstance(subscript.slice.value, astroid.Name):<EOL><INDENT>continue<EOL><DEDENT>if subscript.slice.value.name != node.target.name:<EOL><INDENT>continue<EOL><DEDENT>if iterating_object.name != subscript.value.name:<EOL><INDENT>continue<EOL><DEDENT>if subscript.value.scope() != node.scope():<EOL><INDENT>continue<EOL><DEDENT>self.add_message(\"<STR_LIT>\", node=node)<EOL>return<EOL><DEDENT><DEDENT>", "docstring": "Emit a convention whenever range and len are used for indexing.", "id": "f18884:c1:m2"}
{"signature": "def _check_return_at_the_end(self, node):", "body": "if len(self._return_nodes[node.name]) > <NUM_LIT:1>:<EOL><INDENT>return<EOL><DEDENT>if len(node.body) <= <NUM_LIT:1>:<EOL><INDENT>return<EOL><DEDENT>last = node.body[-<NUM_LIT:1>]<EOL>if isinstance(last, astroid.Return):<EOL><INDENT>if last.value is None:<EOL><INDENT>self.add_message(\"<STR_LIT>\", node=node)<EOL><DEDENT>elif isinstance(last.value, astroid.Const) and (last.value.value is None):<EOL><INDENT>self.add_message(\"<STR_LIT>\", node=node)<EOL><DEDENT><DEDENT>", "docstring": "Check for presence of a *single* return statement at the end of a\n        function. \"return\" or \"return None\" are useless because None is the\n        default return type if they are missing.\n\n        NOTE: produces a message only if there is a single return statement\n        in the function body. Otherwise _check_consistent_returns() is called!\n        Per its implementation and PEP8 we can have a \"return None\" at the end\n        of the function body if there are other return statements before that!", "id": "f18884:c0:m46"}
{"signature": "def walk(self, node):", "body": "walker = ASTWalker(linter)<EOL>walker.add_checker(self.checker)<EOL>walker.walk(node)<EOL>", "docstring": "recursive walk on the given node", "id": "f18885:c4:m3"}
{"signature": "@contextlib.contextmanager<EOL>def _create_tempfile(content=None):", "body": "<EOL>file_handle, tmp = tempfile.mkstemp()<EOL>if content:<EOL><INDENT>if sys.version_info >= (<NUM_LIT:3>, <NUM_LIT:0>):<EOL><INDENT>write(file_handle, bytes(content, \"<STR_LIT:ascii>\"))<EOL><DEDENT>else:<EOL><INDENT>write(file_handle, content)<EOL><DEDENT><DEDENT>try:<EOL><INDENT>yield tmp<EOL><DEDENT>finally:<EOL><INDENT>close(file_handle)<EOL>remove(tmp)<EOL><DEDENT>", "docstring": "Create a new temporary file.\n\n    If *content* parameter is given, then it will be written\n    in the temporary file, before passing it back.\n    This is a context manager and should be used with a *with* statement.", "id": "f18885:m3"}
{"signature": "def display_reports(self, layout):", "body": "", "docstring": "ignore layouts", "id": "f18885:c0:m5"}
{"signature": "def close_graph(self):", "body": "self._dec_indent()<EOL>self._stream.write(\"<STR_LIT>\" % self._indent)<EOL>", "docstring": "close a vcg graph", "id": "f18886:c0:m2"}
{"signature": "def _inc_indent(self):", "body": "self._indent = \"<STR_LIT>\" % self._indent<EOL>", "docstring": "increment indentation", "id": "f18886:c0:m6"}
{"signature": "def _set_default_options(self):", "body": "self.module_names = self._set_option(self.config.module_names)<EOL>all_ancestors = self._set_option(self.config.all_ancestors)<EOL>all_associated = self._set_option(self.config.all_associated)<EOL>anc_level, association_level = (<NUM_LIT:0>, <NUM_LIT:0>)<EOL>if all_ancestors:<EOL><INDENT>anc_level = -<NUM_LIT:1><EOL><DEDENT>if all_associated:<EOL><INDENT>association_level = -<NUM_LIT:1><EOL><DEDENT>if self.config.show_ancestors is not None:<EOL><INDENT>anc_level = self.config.show_ancestors<EOL><DEDENT>if self.config.show_associated is not None:<EOL><INDENT>association_level = self.config.show_associated<EOL><DEDENT>self.anc_level, self.association_level = anc_level, association_level<EOL>", "docstring": "set different default options with _default dictionary", "id": "f18887:c0:m3"}
{"signature": "def _set_option(self, option):", "body": "<EOL>if option is None:<EOL><INDENT>return bool(self.config.classes)<EOL><DEDENT>return option<EOL>", "docstring": "activate some options if not explicitly deactivated", "id": "f18887:c0:m2"}
{"signature": "def visit_classdef(self, node):", "body": "anc_level, association_level = self._get_levels()<EOL>self.extract_classes(node, anc_level, association_level)<EOL>", "docstring": "visit an astroid.Class node\n\n        add this class to the class diagram definition", "id": "f18887:c1:m4"}
{"signature": "def set_printer(self, file_name, basename):", "body": "self.graph_file = open(file_name, \"<STR_LIT>\")<EOL>self.printer = VCGPrinter(self.graph_file)<EOL>self.printer.open_graph(<EOL>title=basename,<EOL>layoutalgorithm=\"<STR_LIT>\",<EOL>late_edge_labels=\"<STR_LIT:yes>\",<EOL>port_sharing=\"<STR_LIT>\",<EOL>manhattan_edges=\"<STR_LIT:yes>\",<EOL>)<EOL>self.printer.emit_node = self.printer.node<EOL>self.printer.emit_edge = self.printer.edge<EOL>", "docstring": "initialize VCGWriter for a UML graph", "id": "f18890:c2:m1"}
{"signature": "def write_classes(self, diagram):", "body": "<EOL>for i, obj in enumerate(sorted(diagram.objects, key=lambda x: x.title)):<EOL><INDENT>self.printer.emit_node(i, **self.get_values(obj))<EOL>obj.fig_id = i<EOL><DEDENT>for rel in diagram.get_relationships(\"<STR_LIT>\"):<EOL><INDENT>self.printer.emit_edge(<EOL>rel.from_object.fig_id, rel.to_object.fig_id, **self.inh_edges<EOL>)<EOL><DEDENT>for rel in diagram.get_relationships(\"<STR_LIT>\"):<EOL><INDENT>self.printer.emit_edge(<EOL>rel.from_object.fig_id, rel.to_object.fig_id, **self.imp_edges<EOL>)<EOL><DEDENT>for rel in diagram.get_relationships(\"<STR_LIT>\"):<EOL><INDENT>self.printer.emit_edge(<EOL>rel.from_object.fig_id,<EOL>rel.to_object.fig_id,<EOL>label=rel.name,<EOL>**self.association_edges<EOL>)<EOL><DEDENT>", "docstring": "write a class diagram", "id": "f18890:c0:m3"}
{"signature": "def get_title(self, obj):", "body": "raise NotImplementedError<EOL>", "docstring": "get project title", "id": "f18890:c0:m5"}
{"signature": "def __init__(self, mode):", "body": "__mode = <NUM_LIT:0><EOL>for nummod in mode.split(\"<STR_LIT:+>\"):<EOL><INDENT>try:<EOL><INDENT>__mode += MODES[nummod]<EOL><DEDENT>except KeyError as ex:<EOL><INDENT>print(\"<STR_LIT>\" % ex, file=sys.stderr)<EOL><DEDENT><DEDENT>self.__mode = __mode<EOL>", "docstring": "init filter modes", "id": "f18891:c0:m0"}
{"signature": "def visit_classdef(self, node):", "body": "if hasattr(node, \"<STR_LIT>\"):<EOL><INDENT>return<EOL><DEDENT>node.locals_type = collections.defaultdict(list)<EOL>if self.tag:<EOL><INDENT>node.uid = self.generate_id()<EOL><DEDENT>for baseobj in node.ancestors(recurs=False):<EOL><INDENT>specializations = getattr(baseobj, \"<STR_LIT>\", [])<EOL>specializations.append(node)<EOL>baseobj.specializations = specializations<EOL><DEDENT>node.instance_attrs_type = collections.defaultdict(list)<EOL>for assignattrs in node.instance_attrs.values():<EOL><INDENT>for assignattr in assignattrs:<EOL><INDENT>self.handle_assignattr_type(assignattr, node)<EOL><DEDENT><DEDENT>try:<EOL><INDENT>node.implements = list(interfaces(node, self.inherited_interfaces))<EOL><DEDENT>except astroid.InferenceError:<EOL><INDENT>node.implements = ()<EOL><DEDENT>", "docstring": "visit an astroid.Class node\n\n         * set the locals_type and instance_attrs_type mappings\n         * set the implements list and build it\n         * optionally tag the node with a unique id", "id": "f18892:c1:m4"}
{"signature": "def interfaces(node, herited=True, handler_func=_iface_hdlr):", "body": "<EOL>try:<EOL><INDENT>implements = bases.Instance(node).getattr(\"<STR_LIT>\")[<NUM_LIT:0>]<EOL><DEDENT>except exceptions.NotFoundError:<EOL><INDENT>return<EOL><DEDENT>if not herited and implements.frame() is not node:<EOL><INDENT>return<EOL><DEDENT>found = set()<EOL>missing = False<EOL>for iface in node_classes.unpack_infer(implements):<EOL><INDENT>if iface is astroid.Uninferable:<EOL><INDENT>missing = True<EOL>continue<EOL><DEDENT>if iface not in found and handler_func(iface):<EOL><INDENT>found.add(iface)<EOL>yield iface<EOL><DEDENT><DEDENT>if missing:<EOL><INDENT>raise exceptions.InferenceError()<EOL><DEDENT>", "docstring": "Return an iterator on interfaces implemented by the given class node.", "id": "f18892:m2"}
{"signature": "def visit_import(self, node):", "body": "context_file = node.root().file<EOL>for name in node.names:<EOL><INDENT>relative = modutils.is_relative(name[<NUM_LIT:0>], context_file)<EOL>self._imported_module(node, name[<NUM_LIT:0>], relative)<EOL><DEDENT>", "docstring": "visit an astroid.Import node\n\n        resolve module dependencies", "id": "f18892:c1:m8"}
{"signature": "def _iface_hdlr(_):", "body": "return True<EOL>", "docstring": "Handler used by interfaces to handle suspicious interface nodes.", "id": "f18892:m0"}
{"signature": "def generate_id(self):", "body": "self.id_count += <NUM_LIT:1><EOL>return self.id_count<EOL>", "docstring": "generate a new identifier", "id": "f18892:c0:m2"}
{"signature": "def extract_relationships(self):", "body": "for obj in self.classes():<EOL><INDENT>node = obj.node<EOL>obj.attrs = self.get_attrs(node)<EOL>obj.methods = self.get_methods(node)<EOL>if is_interface(node):<EOL><INDENT>obj.shape = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>obj.shape = \"<STR_LIT:class>\"<EOL><DEDENT>for par_node in node.ancestors(recurs=False):<EOL><INDENT>try:<EOL><INDENT>par_obj = self.object_from_node(par_node)<EOL>self.add_relationship(obj, par_obj, \"<STR_LIT>\")<EOL><DEDENT>except KeyError:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>for impl_node in node.implements:<EOL><INDENT>try:<EOL><INDENT>impl_obj = self.object_from_node(impl_node)<EOL>self.add_relationship(obj, impl_obj, \"<STR_LIT>\")<EOL><DEDENT>except KeyError:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>for name, values in list(node.instance_attrs_type.items()) + list(<EOL>node.locals_type.items()<EOL>):<EOL><INDENT>for value in values:<EOL><INDENT>if value is astroid.Uninferable:<EOL><INDENT>continue<EOL><DEDENT>if isinstance(value, astroid.Instance):<EOL><INDENT>value = value._proxied<EOL><DEDENT>try:<EOL><INDENT>associated_obj = self.object_from_node(value)<EOL>self.add_relationship(associated_obj, obj, \"<STR_LIT>\", name)<EOL><DEDENT>except KeyError:<EOL><INDENT>continue<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "extract relation ships between nodes in the diagram", "id": "f18893:c3:m13"}
{"signature": "def class_names(self, nodes):", "body": "names = []<EOL>for node in nodes:<EOL><INDENT>if isinstance(node, astroid.Instance):<EOL><INDENT>node = node._proxied<EOL><DEDENT>if (<EOL>isinstance(node, astroid.ClassDef)<EOL>and hasattr(node, \"<STR_LIT:name>\")<EOL>and not self.has_node(node)<EOL>):<EOL><INDENT>if node.name not in names:<EOL><INDENT>node_name = node.name<EOL>names.append(node_name)<EOL><DEDENT><DEDENT><DEDENT>return names<EOL>", "docstring": "return class names if needed in diagram", "id": "f18893:c3:m7"}
{"signature": "def get_module(self, name, node):", "body": "for mod in self.modules():<EOL><INDENT>mod_name = mod.node.name<EOL>if mod_name == name:<EOL><INDENT>return mod<EOL><DEDENT>package = node.root().name<EOL>if mod_name == \"<STR_LIT>\" % (package, name):<EOL><INDENT>return mod<EOL><DEDENT>if mod_name == \"<STR_LIT>\" % (package.rsplit(\"<STR_LIT:.>\", <NUM_LIT:1>)[<NUM_LIT:0>], name):<EOL><INDENT>return mod<EOL><DEDENT><DEDENT>raise KeyError(name)<EOL>", "docstring": "return a module by its name, looking also for relative imports;\n        raise KeyError if not found", "id": "f18893:c4:m2"}
{"signature": "def normalize_node_id(nid):", "body": "return '<STR_LIT>' % nid<EOL>", "docstring": "Returns a suitable DOT node id for `nid`.", "id": "f18894:m1"}
{"signature": "def emit(self, line):", "body": "self.lines.append(line)<EOL>", "docstring": "Adds <line> to final output.", "id": "f18894:c0:m3"}
{"signature": "def target_info_from_filename(filename):", "body": "basename = osp.basename(filename)<EOL>storedir = osp.dirname(osp.abspath(filename))<EOL>target = filename.split(\"<STR_LIT:.>\")[-<NUM_LIT:1>]<EOL>return storedir, basename, target<EOL>", "docstring": "Transforms /some/path/foo.png into ('/some/path', 'foo.png', 'png').", "id": "f18894:m0"}
{"signature": "def register(linter):", "body": "linter.register_checker(MyAstroidChecker(linter))<EOL>", "docstring": "This required method auto registers the checker.\n\n    :param linter: The linter to register the checker to.\n    :type linter: pylint.lint.PyLinter", "id": "f18899:m0"}
{"signature": "def run(self):", "body": "install_lib.install_lib.run(self)<EOL>if include_dirs:<EOL><INDENT>for directory in include_dirs:<EOL><INDENT>dest = join(self.install_dir, directory)<EOL>if sys.version_info >= (<NUM_LIT:3>, <NUM_LIT:0>):<EOL><INDENT>exclude = {\"<STR_LIT>\", \"<STR_LIT>\"}<EOL><DEDENT>else:<EOL><INDENT>exclude = set()<EOL><DEDENT>shutil.rmtree(dest, ignore_errors=True)<EOL>shutil.copytree(<EOL>directory, dest, ignore=shutil.ignore_patterns(*exclude)<EOL>)<EOL><DEDENT><DEDENT>", "docstring": "overridden from install_lib class", "id": "f18901:c0:m0"}
{"signature": "def install(**kwargs):", "body": "if USE_SETUPTOOLS:<EOL><INDENT>if \"<STR_LIT>\" in sys.argv:<EOL><INDENT>sys.argv.remove(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>packages = [modname] + get_packages(join(base_dir, \"<STR_LIT>\"), modname)<EOL>if USE_SETUPTOOLS:<EOL><INDENT>if install_requires:<EOL><INDENT>kwargs[\"<STR_LIT>\"] = install_requires<EOL>kwargs[\"<STR_LIT>\"] = dependency_links<EOL><DEDENT>kwargs[\"<STR_LIT>\"] = {<EOL>\"<STR_LIT>\": [<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\",<EOL>]<EOL>}<EOL><DEDENT>kwargs[\"<STR_LIT>\"] = packages<EOL>cmdclass = {\"<STR_LIT>\": MyInstallLib, \"<STR_LIT>\": build_py}<EOL>if easy_install_lib:<EOL><INDENT>cmdclass[\"<STR_LIT>\"] = easy_install<EOL><DEDENT>return setup(<EOL>name=distname,<EOL>version=__pkginfo__[\"<STR_LIT:version>\"],<EOL>license=__pkginfo__[\"<STR_LIT>\"],<EOL>description=__pkginfo__[\"<STR_LIT:description>\"],<EOL>long_description=long_description,<EOL>author=__pkginfo__[\"<STR_LIT>\"],<EOL>author_email=__pkginfo__[\"<STR_LIT>\"],<EOL>url=__pkginfo__[\"<STR_LIT>\"],<EOL>scripts=ensure_scripts(scripts),<EOL>classifiers=__pkginfo__[\"<STR_LIT>\"],<EOL>data_files=data_files,<EOL>ext_modules=ext_modules,<EOL>cmdclass=cmdclass,<EOL>extras_require=extras_require,<EOL>test_suite=\"<STR_LIT:test>\",<EOL>python_requires=\"<STR_LIT>\",<EOL>setup_requires=[\"<STR_LIT>\"],<EOL>tests_require=[\"<STR_LIT>\"],<EOL>**kwargs<EOL>)<EOL>", "docstring": "setup entry point", "id": "f18901:m3"}
{"signature": "def ensure_scripts(linux_scripts):", "body": "from distutils import util<EOL>if util.get_platform()[:<NUM_LIT:3>] == \"<STR_LIT>\":<EOL><INDENT>return linux_scripts + [script + \"<STR_LIT>\" for script in linux_scripts]<EOL><DEDENT>return linux_scripts<EOL>", "docstring": "Creates the proper script names required for each platform\n    (taken from 4Suite)", "id": "f18901:m0"}
{"signature": "def collection_to_df(collection):", "body": "return pd.concat([record.series for record in collection], axis=<NUM_LIT:1>).T<EOL>", "docstring": "Converts a collection back into a pandas DataFrame\n\nparameters\n----------\ncollection : list\n    list of Record objects where each Record represents one row from a dataframe\n\nReturns\n-------\ndf : pandas.DataFrame\n    DataFrame of length=len(collection) where each row represents one Record", "id": "f18904:m2"}
{"signature": "def catch(fcn, *args, **kwargs):", "body": "try:<EOL><INDENT>spit = kwargs.pop('<STR_LIT>')<EOL><DEDENT>except:<EOL><INDENT>spit = None<EOL><DEDENT>try:<EOL><INDENT>results = fcn(*args, **kwargs)<EOL>if results:<EOL><INDENT>return results<EOL><DEDENT><DEDENT>except:<EOL><INDENT>print(traceback.format_exc())<EOL>if spit:<EOL><INDENT>return spit<EOL><DEDENT><DEDENT>", "docstring": "try:\n          retrun fcn(*args, **kwargs)\n       except:\n          print traceback\n            if 'spit' in kwargs.keys():\n                return kwargs['spit']\n\n    Parameters\n    ----------\n    fcn : function\n    *args : unnamed parameters of fcn\n    **kwargs : named parameters of fcn\n        spit : returns the parameter named return in the exception\n\n    Returns\n    -------\n    The expected output of fcn or prints the exception traceback", "id": "f18908:m0"}
{"signature": "def to_pickle(obj, filename, clean_memory=False):", "body": "path, filename = path_to_filename(filename)<EOL>create_dir(path)<EOL>with open(path + filename, \"<STR_LIT:wb>\") as output:<EOL><INDENT>pickle.dump(obj, output, pickle.HIGHEST_PROTOCOL)<EOL><DEDENT>if clean_memory:<EOL><INDENT>obj = None<EOL><DEDENT>return obj<EOL>", "docstring": "http://stackoverflow.com/questions/7900944/read-write-classes-to-files-in-an-efficent-way", "id": "f18908:m2"}
{"signature": "def Walk(root='<STR_LIT:.>', recurse=True, pattern='<STR_LIT:*>'):", "body": "for path, subdirs, files in os.walk(root):<EOL><INDENT>for name in files:<EOL><INDENT>if fnmatch.fnmatch(name, pattern):<EOL><INDENT>yield os.path.join(path, name)<EOL><DEDENT><DEDENT>if not recurse:<EOL><INDENT>break<EOL><DEDENT><DEDENT>", "docstring": "Generator for walking a directory tree.\nStarts at specified root folder, returning files that match our pattern. \nOptionally will also recurse through sub-folders.\n\nParameters\n----------\nroot : string (default is *'.'*)\n    Path for the root folder to look in.\nrecurse : bool (default is *True*)\n    If *True*, will also look in the subfolders.\npattern : string (default is :emphasis:`'*'`, which means all the files are concerned)\n    The pattern to look for in the files' name.\n\nReturns\n-------\ngenerator\n    **Walk** yields a generator from the matching files paths.", "id": "f18908:m7"}
{"signature": "def scan_path(root='<STR_LIT:.>', recurse=False, pattern='<STR_LIT:*>'):", "body": "path_list = []<EOL>for path in Walk(root=root, recurse=recurse, pattern=pattern):<EOL><INDENT>path_list.append(path)<EOL><DEDENT>return path_list<EOL>", "docstring": "Runs a loop over the :doc:`Walk<relpy.utils.Walk>` Generator\nto find all file paths in the root directory with the given\npattern. If recurse is *True*: matching paths are identified\nfor all sub directories.\n\nParameters\n----------\nroot : string (default is *'.'*)\n    Path for the root folder to look in.\nrecurse : bool (default is *True*)\n    If *True*, will also look in the subfolders.\npattern : string (default is :emphasis:`'*'`, which means all the files are concerned)\n    The pattern to look for in the files' name.\n\nReturns\n-------\npath_list : list\n    list of all the matching files paths.", "id": "f18908:m8"}
{"signature": "def _get_sorted_names(self):", "body": "depend_dict = {}<EOL>for name, info_module in self.info_modules.items():<EOL><INDENT>depend_dict[name] = getattr(info_module, '<STR_LIT>', [])<EOL><DEDENT>package_names = []<EOL>for name in list(depend_dict.keys()):<EOL><INDENT>if not depend_dict[name]:<EOL><INDENT>package_names.append(name)<EOL>del depend_dict[name]<EOL><DEDENT><DEDENT>while depend_dict:<EOL><INDENT>for name, lst in list(depend_dict.items()):<EOL><INDENT>new_lst = [n for n in lst if n in depend_dict]<EOL>if not new_lst:<EOL><INDENT>package_names.append(name)<EOL>del depend_dict[name]<EOL><DEDENT>else:<EOL><INDENT>depend_dict[name] = new_lst<EOL><DEDENT><DEDENT><DEDENT>return package_names<EOL>", "docstring": "Return package names sorted in the order as they should be\n        imported due to dependence relations between packages.", "id": "f18910:c0:m3"}
{"signature": "def get_pkgdocs(self):", "body": "import sys<EOL>self.info_modules = {}<EOL>self._init_info_modules(None)<EOL>titles = []<EOL>symbols = []<EOL>for package_name, info_module in self.info_modules.items():<EOL><INDENT>global_symbols = getattr(info_module, '<STR_LIT>', [])<EOL>fullname = self.parent_name +'<STR_LIT:.>'+ package_name<EOL>note = '<STR_LIT>'<EOL>if fullname not in sys.modules:<EOL><INDENT>note = '<STR_LIT>'<EOL><DEDENT>titles.append((fullname, self._get_doc_title(info_module) + note))<EOL>if global_symbols:<EOL><INDENT>symbols.append((package_name, '<STR_LIT:U+002CU+0020>'.join(global_symbols)))<EOL><DEDENT><DEDENT>retstr = self._format_titles(titles) +'<STR_LIT>'<EOL>if symbols:<EOL><INDENT>retstr += \"\"\"<STR_LIT>\"\"\"\"\"\"<STR_LIT>\"\"\" +self._format_titles(symbols, '<STR_LIT>')<EOL><DEDENT>return retstr<EOL>", "docstring": "Return documentation summary of subpackages.", "id": "f18910:c0:m12"}
{"signature": "def _get_info_files(self, package_dir, parent_path, parent_package=None):", "body": "from glob import glob<EOL>files = glob(os.path.join(parent_path, package_dir, '<STR_LIT>'))<EOL>for info_file in glob(os.path.join(parent_path, package_dir, '<STR_LIT>')):<EOL><INDENT>if info_file[:-<NUM_LIT:1>] not in files:<EOL><INDENT>files.append(info_file)<EOL><DEDENT><DEDENT>info_files = []<EOL>for info_file in files:<EOL><INDENT>package_name = os.path.dirname(info_file[len(parent_path)+<NUM_LIT:1>:]).replace(os.sep, '<STR_LIT:.>')<EOL>if parent_package:<EOL><INDENT>package_name = parent_package + '<STR_LIT:.>' + package_name<EOL><DEDENT>info_files.append((package_name, info_file))<EOL>info_files.extend(self._get_info_files('<STR_LIT:*>',<EOL>os.path.dirname(info_file),<EOL>package_name))<EOL><DEDENT>return info_files<EOL>", "docstring": "Return list of (package name,info.py file) from parent_path subdirectories.", "id": "f18910:c0:m1"}
{"signature": "def __call__(self,*packages, **options):", "body": "frame = self.parent_frame<EOL>self.info_modules = {}<EOL>if options.get('<STR_LIT>', False):<EOL><INDENT>self.imported_packages = []<EOL><DEDENT>self.verbose = verbose = options.get('<STR_LIT>', -<NUM_LIT:1>)<EOL>postpone = options.get('<STR_LIT>', None)<EOL>self._init_info_modules(packages or None)<EOL>self.log('<STR_LIT>'% self.parent_name)<EOL>for package_name in self._get_sorted_names():<EOL><INDENT>if package_name in self.imported_packages:<EOL><INDENT>continue<EOL><DEDENT>info_module = self.info_modules[package_name]<EOL>global_symbols = getattr(info_module, '<STR_LIT>', [])<EOL>postpone_import = getattr(info_module, '<STR_LIT>', False)<EOL>if (postpone and not global_symbols)or (postpone_import and postpone is not None):<EOL><INDENT>continue<EOL><DEDENT>old_object = frame.f_locals.get(package_name, None)<EOL>cmdstr = '<STR_LIT>'+package_name<EOL>if self._execcmd(cmdstr):<EOL><INDENT>continue<EOL><DEDENT>self.imported_packages.append(package_name)<EOL>if verbose!=-<NUM_LIT:1>:<EOL><INDENT>new_object = frame.f_locals.get(package_name)<EOL>if old_object is not None and old_object is not new_object:<EOL><INDENT>self.warn('<STR_LIT>'% (package_name, self._obj2repr(new_object),<EOL>self._obj2repr(old_object)))<EOL><DEDENT><DEDENT>if '<STR_LIT:.>' not in package_name:<EOL><INDENT>self.parent_export_names.append(package_name)<EOL><DEDENT>for symbol in global_symbols:<EOL><INDENT>if symbol=='<STR_LIT:*>':<EOL><INDENT>symbols = eval('<STR_LIT>'% (package_name),<EOL>frame.f_globals, frame.f_locals)<EOL>if symbols is None:<EOL><INDENT>symbols = eval('<STR_LIT>' % (package_name),<EOL>frame.f_globals, frame.f_locals)<EOL>symbols = [s for s in symbols if not s.startswith('<STR_LIT:_>')]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>symbols = [symbol]<EOL><DEDENT>if verbose!=-<NUM_LIT:1>:<EOL><INDENT>old_objects = {}<EOL>for s in symbols:<EOL><INDENT>if s in frame.f_locals:<EOL><INDENT>old_objects[s] = frame.f_locals[s]<EOL><DEDENT><DEDENT><DEDENT>cmdstr = '<STR_LIT>'+package_name+'<STR_LIT>'+symbol<EOL>if self._execcmd(cmdstr):<EOL><INDENT>continue<EOL><DEDENT>if verbose!=-<NUM_LIT:1>:<EOL><INDENT>for s, old_object in old_objects.items():<EOL><INDENT>new_object = frame.f_locals[s]<EOL>if new_object is not old_object:<EOL><INDENT>self.warn('<STR_LIT>'% (s, self._obj2repr(new_object),<EOL>self._obj2repr(old_object)))<EOL><DEDENT><DEDENT><DEDENT>if symbol=='<STR_LIT:*>':<EOL><INDENT>self.parent_export_names.extend(symbols)<EOL><DEDENT>else:<EOL><INDENT>self.parent_export_names.append(symbol)<EOL><DEDENT><DEDENT><DEDENT>return<EOL>", "docstring": "Load one or more packages into parent package top-level namespace.\n\n       This function is intended to shorten the need to import many\n       subpackages, say of scipy, constantly with statements such as\n\n         import scipy.linalg, scipy.fftpack, scipy.etc...\n\n       Instead, you can say:\n\n         import scipy\n         scipy.pkgload('linalg','fftpack',...)\n\n       or\n\n         scipy.pkgload()\n\n       to load all of them in one call.\n\n       If a name which doesn't exist in scipy's namespace is\n       given, a warning is shown.\n\n       Parameters\n       ----------\n        *packages : arg-tuple\n             the names (one or more strings) of all the modules one\n             wishes to load into the top-level namespace.\n        verbose= : integer\n             verbosity level [default: -1].\n             verbose=-1 will suspend also warnings.\n        force= : bool\n             when True, force reloading loaded packages [default: False].\n        postpone= : bool\n             when True, don't load packages [default: False]", "id": "f18910:c0:m4"}
{"signature": "def __RandomState_ctor():", "body": "return RandomState(seed=<NUM_LIT:0>)<EOL>", "docstring": "Return a RandomState instance.\n\n    This function exists solely to assist (un)pickling.\n\n    Note that the state of the RandomState returned here is irrelevant, as this function's\n    entire purpose is to return a newly allocated RandomState whose state pickle can set.\n    Consequently the RandomState returned by this function is a freshly allocated copy\n    with a seed=0.\n\n    See https://github.com/numpy/numpy/issues/4763 for a detailed discussion", "id": "f18914:m0"}
{"signature": "def chebmulx(c):", "body": "<EOL>[c] = pu.as_series([c])<EOL>if len(c) == <NUM_LIT:1> and c[<NUM_LIT:0>] == <NUM_LIT:0>:<EOL><INDENT>return c<EOL><DEDENT>prd = np.empty(len(c) + <NUM_LIT:1>, dtype=c.dtype)<EOL>prd[<NUM_LIT:0>] = c[<NUM_LIT:0>]*<NUM_LIT:0><EOL>prd[<NUM_LIT:1>] = c[<NUM_LIT:0>]<EOL>if len(c) > <NUM_LIT:1>:<EOL><INDENT>tmp = c[<NUM_LIT:1>:]/<NUM_LIT:2><EOL>prd[<NUM_LIT:2>:] = tmp<EOL>prd[<NUM_LIT:0>:-<NUM_LIT:2>] += tmp<EOL><DEDENT>return prd<EOL>", "docstring": "Multiply a Chebyshev series by x.\n\n    Multiply the polynomial `c` by x, where x is the independent\n    variable.\n\n\n    Parameters\n    ----------\n    c : array_like\n        1-D array of Chebyshev series coefficients ordered from low to\n        high.\n\n    Returns\n    -------\n    out : ndarray\n        Array representing the result of the multiplication.\n\n    Notes\n    -----\n\n    .. versionadded:: 1.5.0", "id": "f18918:m12"}
{"signature": "def _cseries_to_zseries(c):", "body": "n = c.size<EOL>zs = np.zeros(<NUM_LIT:2>*n-<NUM_LIT:1>, dtype=c.dtype)<EOL>zs[n-<NUM_LIT:1>:] = c/<NUM_LIT:2><EOL>return zs + zs[::-<NUM_LIT:1>]<EOL>", "docstring": "Covert Chebyshev series to z-series.\n\n    Covert a Chebyshev series to the equivalent z-series. The result is\n    never an empty array. The dtype of the return is the same as that of\n    the input. No checks are run on the arguments as this routine is for\n    internal use.\n\n    Parameters\n    ----------\n    c : 1-D ndarray\n        Chebyshev coefficients, ordered from low to high\n\n    Returns\n    -------\n    zs : 1-D ndarray\n        Odd length symmetric z-series, ordered from  low to high.", "id": "f18918:m0"}
{"signature": "def chebval2d(x, y, c):", "body": "try:<EOL><INDENT>x, y = np.array((x, y), copy=<NUM_LIT:0>)<EOL><DEDENT>except:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>c = chebval(x, c)<EOL>c = chebval(y, c, tensor=False)<EOL>return c<EOL>", "docstring": "Evaluate a 2-D Chebyshev series at points (x, y).\n\nThis function returns the values:\n\n.. math:: p(x,y) = \\\\sum_{i,j} c_{i,j} * T_i(x) * T_j(y)\n\nThe parameters `x` and `y` are converted to arrays only if they are\ntuples or a lists, otherwise they are treated as a scalars and they\nmust have the same shape after conversion. In either case, either `x`\nand `y` or their elements must support multiplication and addition both\nwith themselves and with the elements of `c`.\n\nIf `c` is a 1-D array a one is implicitly appended to its shape to make\nit 2-D. The shape of the result will be c.shape[2:] + x.shape.\n\nParameters\n----------\nx, y : array_like, compatible objects\n    The two dimensional series is evaluated at the points `(x, y)`,\n    where `x` and `y` must have the same shape. If `x` or `y` is a list\n    or tuple, it is first converted to an ndarray, otherwise it is left\n    unchanged and if it isn't an ndarray it is treated as a scalar.\nc : array_like\n    Array of coefficients ordered so that the coefficient of the term\n    of multi-degree i,j is contained in ``c[i,j]``. If `c` has\n    dimension greater than 2 the remaining indices enumerate multiple\n    sets of coefficients.\n\nReturns\n-------\nvalues : ndarray, compatible object\n    The values of the two dimensional Chebyshev series at points formed\n    from pairs of corresponding values from `x` and `y`.\n\nSee Also\n--------\nchebval, chebgrid2d, chebval3d, chebgrid3d\n\nNotes\n-----\n\n.. versionadded::1.7.0", "id": "f18918:m19"}
{"signature": "def chebgrid3d(x, y, z, c):", "body": "c = chebval(x, c)<EOL>c = chebval(y, c)<EOL>c = chebval(z, c)<EOL>return c<EOL>", "docstring": "Evaluate a 3-D Chebyshev series on the Cartesian product of x, y, and z.\n\nThis function returns the values:\n\n.. math:: p(a,b,c) = \\\\sum_{i,j,k} c_{i,j,k} * T_i(a) * T_j(b) * T_k(c)\n\nwhere the points `(a, b, c)` consist of all triples formed by taking\n`a` from `x`, `b` from `y`, and `c` from `z`. The resulting points form\na grid with `x` in the first dimension, `y` in the second, and `z` in\nthe third.\n\nThe parameters `x`, `y`, and `z` are converted to arrays only if they\nare tuples or a lists, otherwise they are treated as a scalars. In\neither case, either `x`, `y`, and `z` or their elements must support\nmultiplication and addition both with themselves and with the elements\nof `c`.\n\nIf `c` has fewer than three dimensions, ones are implicitly appended to\nits shape to make it 3-D. The shape of the result will be c.shape[3:] +\nx.shape + y.shape + z.shape.\n\nParameters\n----------\nx, y, z : array_like, compatible objects\n    The three dimensional series is evaluated at the points in the\n    Cartesian product of `x`, `y`, and `z`.  If `x`,`y`, or `z` is a\n    list or tuple, it is first converted to an ndarray, otherwise it is\n    left unchanged and, if it isn't an ndarray, it is treated as a\n    scalar.\nc : array_like\n    Array of coefficients ordered so that the coefficients for terms of\n    degree i,j are contained in ``c[i,j]``. If `c` has dimension\n    greater than two the remaining indices enumerate multiple sets of\n    coefficients.\n\nReturns\n-------\nvalues : ndarray, compatible object\n    The values of the two dimensional polynomial at points in the Cartesian\n    product of `x` and `y`.\n\nSee Also\n--------\nchebval, chebval2d, chebgrid2d, chebval3d\n\nNotes\n-----\n\n.. versionadded::1.7.0", "id": "f18918:m22"}
{"signature": "def _zseries_to_cseries(zs):", "body": "n = (zs.size + <NUM_LIT:1>)//<NUM_LIT:2><EOL>c = zs[n-<NUM_LIT:1>:].copy()<EOL>c[<NUM_LIT:1>:n] *= <NUM_LIT:2><EOL>return c<EOL>", "docstring": "Covert z-series to a Chebyshev series.\n\n    Covert a z series to the equivalent Chebyshev series. The result is\n    never an empty array. The dtype of the return is the same as that of\n    the input. No checks are run on the arguments as this routine is for\n    internal use.\n\n    Parameters\n    ----------\n    zs : 1-D ndarray\n        Odd length symmetric z-series, ordered from  low to high.\n\n    Returns\n    -------\n    c : 1-D ndarray\n        Chebyshev coefficients, ordered from  low to high.", "id": "f18918:m1"}
{"signature": "def chebmul(c1, c2):", "body": "<EOL>[c1, c2] = pu.as_series([c1, c2])<EOL>z1 = _cseries_to_zseries(c1)<EOL>z2 = _cseries_to_zseries(c2)<EOL>prd = _zseries_mul(z1, z2)<EOL>ret = _zseries_to_cseries(prd)<EOL>return pu.trimseq(ret)<EOL>", "docstring": "Multiply one Chebyshev series by another.\n\nReturns the product of two Chebyshev series `c1` * `c2`.  The arguments\nare sequences of coefficients, from lowest order \"term\" to highest,\ne.g., [1,2,3] represents the series ``T_0 + 2*T_1 + 3*T_2``.\n\nParameters\n----------\nc1, c2 : array_like\n    1-D arrays of Chebyshev series coefficients ordered from low to\n    high.\n\nReturns\n-------\nout : ndarray\n    Of Chebyshev series coefficients representing their product.\n\nSee Also\n--------\nchebadd, chebsub, chebdiv, chebpow\n\nNotes\n-----\nIn general, the (polynomial) product of two C-series results in terms\nthat are not in the Chebyshev polynomial basis set.  Thus, to express\nthe product as a C-series, it is typically necessary to \"reproject\"\nthe product onto said basis set, which typically produces\n\"unintuitive live\" (but correct) results; see Examples section below.\n\nExamples\n--------\n>>> from numpy.polynomial import chebyshev as C\n>>> c1 = (1,2,3)\n>>> c2 = (3,2,1)\n>>> C.chebmul(c1,c2) # multiplication requires \"reprojection\"\narray([  6.5,  12. ,  12. ,   4. ,   1.5])", "id": "f18918:m13"}
{"signature": "def chebfromroots(roots):", "body": "if len(roots) == <NUM_LIT:0>:<EOL><INDENT>return np.ones(<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>[roots] = pu.as_series([roots], trim=False)<EOL>roots.sort()<EOL>p = [chebline(-r, <NUM_LIT:1>) for r in roots]<EOL>n = len(p)<EOL>while n > <NUM_LIT:1>:<EOL><INDENT>m, r = divmod(n, <NUM_LIT:2>)<EOL>tmp = [chebmul(p[i], p[i+m]) for i in range(m)]<EOL>if r:<EOL><INDENT>tmp[<NUM_LIT:0>] = chebmul(tmp[<NUM_LIT:0>], p[-<NUM_LIT:1>])<EOL><DEDENT>p = tmp<EOL>n = m<EOL><DEDENT>return p[<NUM_LIT:0>]<EOL><DEDENT>", "docstring": "Generate a Chebyshev series with given roots.\n\nThe function returns the coefficients of the polynomial\n\n.. math:: p(x) = (x - r_0) * (x - r_1) * ... * (x - r_n),\n\nin Chebyshev form, where the `r_n` are the roots specified in `roots`.\nIf a zero has multiplicity n, then it must appear in `roots` n times.\nFor instance, if 2 is a root of multiplicity three and 3 is a root of\nmultiplicity 2, then `roots` looks something like [2, 2, 2, 3, 3]. The\nroots can appear in any order.\n\nIf the returned coefficients are `c`, then\n\n.. math:: p(x) = c_0 + c_1 * T_1(x) + ... +  c_n * T_n(x)\n\nThe coefficient of the last term is not generally 1 for monic\npolynomials in Chebyshev form.\n\nParameters\n----------\nroots : array_like\n    Sequence containing the roots.\n\nReturns\n-------\nout : ndarray\n    1-D array of coefficients.  If all roots are real then `out` is a\n    real array, if some of the roots are complex, then `out` is complex\n    even if all the coefficients in the result are real (see Examples\n    below).\n\nSee Also\n--------\npolyfromroots, legfromroots, lagfromroots, hermfromroots,\nhermefromroots.\n\nExamples\n--------\n>>> import numpy.polynomial.chebyshev as C\n>>> C.chebfromroots((-1,0,1)) # x^3 - x relative to the standard basis\narray([ 0.  , -0.25,  0.  ,  0.25])\n>>> j = complex(0,1)\n>>> C.chebfromroots((-j,j)) # x^2 + 1 relative to the standard basis\narray([ 1.5+0.j,  0.0+0.j,  0.5+0.j])", "id": "f18918:m9"}
{"signature": "def _zseries_mul(z1, z2):", "body": "return np.convolve(z1, z2)<EOL>", "docstring": "Multiply two z-series.\n\n    Multiply two z-series to produce a z-series.\n\n    Parameters\n    ----------\n    z1, z2 : 1-D ndarray\n        The arrays must be 1-D but this is not checked.\n\n    Returns\n    -------\n    product : 1-D ndarray\n        The product z-series.\n\n    Notes\n    -----\n    This is simply convolution. If symmetric/anti-symmetric z-series are\n    denoted by S/A then the following rules apply:\n\n    S*S, A*A -> S\n    S*A, A*S -> A", "id": "f18918:m2"}
{"signature": "def chebline(off, scl):", "body": "if scl != <NUM_LIT:0>:<EOL><INDENT>return np.array([off, scl])<EOL><DEDENT>else:<EOL><INDENT>return np.array([off])<EOL><DEDENT>", "docstring": "Chebyshev series whose graph is a straight line.\n\n\n\nParameters\n----------\noff, scl : scalars\n    The specified line is given by ``off + scl*x``.\n\nReturns\n-------\ny : ndarray\n    This module's representation of the Chebyshev series for\n    ``off + scl*x``.\n\nSee Also\n--------\npolyline\n\nExamples\n--------\n>>> import numpy.polynomial.chebyshev as C\n>>> C.chebline(3,2)\narray([3, 2])\n>>> C.chebval(-3, C.chebline(3,2)) # should be -3\n-3.0", "id": "f18918:m8"}
{"signature": "def chebpts1(npts):", "body": "_npts = int(npts)<EOL>if _npts != npts:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if _npts < <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>x = np.linspace(-np.pi, <NUM_LIT:0>, _npts, endpoint=False) + np.pi/(<NUM_LIT:2>*_npts)<EOL>return np.cos(x)<EOL>", "docstring": "Chebyshev points of the first kind.\n\nThe Chebyshev points of the first kind are the points ``cos(x)``,\nwhere ``x = [pi*(k + .5)/npts for k in range(npts)]``.\n\nParameters\n----------\nnpts : int\n    Number of sample points desired.\n\nReturns\n-------\npts : ndarray\n    The Chebyshev points of the first kind.\n\nSee Also\n--------\nchebpts2\n\nNotes\n-----\n\n.. versionadded:: 1.5.0", "id": "f18918:m31"}
{"signature": "def chebcompanion(c):", "body": "<EOL>[c] = pu.as_series([c])<EOL>if len(c) < <NUM_LIT:2>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if len(c) == <NUM_LIT:2>:<EOL><INDENT>return np.array([[-c[<NUM_LIT:0>]/c[<NUM_LIT:1>]]])<EOL><DEDENT>n = len(c) - <NUM_LIT:1><EOL>mat = np.zeros((n, n), dtype=c.dtype)<EOL>scl = np.array([<NUM_LIT:1.>] + [np.sqrt(<NUM_LIT>)]*(n-<NUM_LIT:1>))<EOL>top = mat.reshape(-<NUM_LIT:1>)[<NUM_LIT:1>::n+<NUM_LIT:1>]<EOL>bot = mat.reshape(-<NUM_LIT:1>)[n::n+<NUM_LIT:1>]<EOL>top[<NUM_LIT:0>] = np.sqrt(<NUM_LIT>)<EOL>top[<NUM_LIT:1>:] = <NUM_LIT:1>/<NUM_LIT:2><EOL>bot[...] = top<EOL>mat[:, -<NUM_LIT:1>] -= (c[:-<NUM_LIT:1>]/c[-<NUM_LIT:1>])*(scl/scl[-<NUM_LIT:1>])*<NUM_LIT><EOL>return mat<EOL>", "docstring": "Return the scaled companion matrix of c.\n\n    The basis polynomials are scaled so that the companion matrix is\n    symmetric when `c` is aa Chebyshev basis polynomial. This provides\n    better eigenvalue estimates than the unscaled case and for basis\n    polynomials the eigenvalues are guaranteed to be real if\n    `numpy.linalg.eigvalsh` is used to obtain them.\n\n    Parameters\n    ----------\n    c : array_like\n        1-D array of Chebyshev series coefficients ordered from low to high\n        degree.\n\n    Returns\n    -------\n    mat : ndarray\n        Scaled companion matrix of dimensions (deg, deg).\n\n    Notes\n    -----\n\n    .. versionadded::1.7.0", "id": "f18918:m27"}
{"signature": "def poly2leg(pol):", "body": "[pol] = pu.as_series([pol])<EOL>deg = len(pol) - <NUM_LIT:1><EOL>res = <NUM_LIT:0><EOL>for i in range(deg, -<NUM_LIT:1>, -<NUM_LIT:1>):<EOL><INDENT>res = legadd(legmulx(res), pol[i])<EOL><DEDENT>return res<EOL>", "docstring": "Convert a polynomial to a Legendre series.\n\nConvert an array representing the coefficients of a polynomial (relative\nto the \"standard\" basis) ordered from lowest degree to highest, to an\narray of the coefficients of the equivalent Legendre series, ordered\nfrom lowest to highest degree.\n\nParameters\n----------\npol : array_like\n    1-D array containing the polynomial coefficients\n\nReturns\n-------\nc : ndarray\n    1-D array containing the coefficients of the equivalent Legendre\n    series.\n\nSee Also\n--------\nleg2poly\n\nNotes\n-----\nThe easy way to do conversions between polynomial basis sets\nis to use the convert method of a class instance.\n\nExamples\n--------\n>>> from numpy import polynomial as P\n>>> p = P.Polynomial(np.arange(4))\n>>> p\nPolynomial([ 0.,  1.,  2.,  3.], [-1.,  1.])\n>>> c = P.Legendre(P.poly2leg(p.coef))\n>>> c\nLegendre([ 1.  ,  3.25,  1.  ,  0.75], [-1.,  1.])", "id": "f18928:m0"}
{"signature": "def legmulx(c):", "body": "<EOL>[c] = pu.as_series([c])<EOL>if len(c) == <NUM_LIT:1> and c[<NUM_LIT:0>] == <NUM_LIT:0>:<EOL><INDENT>return c<EOL><DEDENT>prd = np.empty(len(c) + <NUM_LIT:1>, dtype=c.dtype)<EOL>prd[<NUM_LIT:0>] = c[<NUM_LIT:0>]*<NUM_LIT:0><EOL>prd[<NUM_LIT:1>] = c[<NUM_LIT:0>]<EOL>for i in range(<NUM_LIT:1>, len(c)):<EOL><INDENT>j = i + <NUM_LIT:1><EOL>k = i - <NUM_LIT:1><EOL>s = i + j<EOL>prd[j] = (c[i]*j)/s<EOL>prd[k] += (c[i]*i)/s<EOL><DEDENT>return prd<EOL>", "docstring": "Multiply a Legendre series by x.\n\n    Multiply the Legendre series `c` by x, where x is the independent\n    variable.\n\n\n    Parameters\n    ----------\n    c : array_like\n        1-D array of Legendre series coefficients ordered from low to\n        high.\n\n    Returns\n    -------\n    out : ndarray\n        Array representing the result of the multiplication.\n\n    Notes\n    -----\n    The multiplication uses the recursion relationship for Legendre\n    polynomials in the form\n\n    .. math::\n\n      xP_i(x) = ((i + 1)*P_{i + 1}(x) + i*P_{i - 1}(x))/(2i + 1)", "id": "f18928:m6"}
{"signature": "def legroots(c):", "body": "<EOL>[c] = pu.as_series([c])<EOL>if len(c) < <NUM_LIT:2>:<EOL><INDENT>return np.array([], dtype=c.dtype)<EOL><DEDENT>if len(c) == <NUM_LIT:2>:<EOL><INDENT>return np.array([-c[<NUM_LIT:0>]/c[<NUM_LIT:1>]])<EOL><DEDENT>m = legcompanion(c)<EOL>r = la.eigvals(m)<EOL>r.sort()<EOL>return r<EOL>", "docstring": "Compute the roots of a Legendre series.\n\nReturn the roots (a.k.a. \"zeros\") of the polynomial\n\n.. math:: p(x) = \\\\sum_i c[i] * L_i(x).\n\nParameters\n----------\nc : 1-D array_like\n    1-D array of coefficients.\n\nReturns\n-------\nout : ndarray\n    Array of the roots of the series. If all the roots are real,\n    then `out` is also real, otherwise it is complex.\n\nSee Also\n--------\npolyroots, chebroots, lagroots, hermroots, hermeroots\n\nNotes\n-----\nThe root estimates are obtained as the eigenvalues of the companion\nmatrix, Roots far from the origin of the complex plane may have large\nerrors due to the numerical instability of the series for such values.\nRoots with multiplicity greater than 1 will also show larger errors as\nthe value of the series near such points is relatively insensitive to\nerrors in the roots. Isolated roots near the origin can be improved by\na few iterations of Newton's method.\n\nThe Legendre series basis polynomials aren't powers of ``x`` so the\nresults of this function may seem unintuitive.\n\nExamples\n--------\n>>> import numpy.polynomial.legendre as leg\n>>> leg.legroots((1, 2, 3, 4)) # 4L_3 + 3L_2 + 2L_1 + 1L_0, all real roots\narray([-0.85099543, -0.11407192,  0.51506735])", "id": "f18928:m22"}
{"signature": "def legval3d(x, y, z, c):", "body": "try:<EOL><INDENT>x, y, z = np.array((x, y, z), copy=<NUM_LIT:0>)<EOL><DEDENT>except:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>c = legval(x, c)<EOL>c = legval(y, c, tensor=False)<EOL>c = legval(z, c, tensor=False)<EOL>return c<EOL>", "docstring": "Evaluate a 3-D Legendre series at points (x, y, z).\n\nThis function returns the values:\n\n.. math:: p(x,y,z) = \\\\sum_{i,j,k} c_{i,j,k} * L_i(x) * L_j(y) * L_k(z)\n\nThe parameters `x`, `y`, and `z` are converted to arrays only if\nthey are tuples or a lists, otherwise they are treated as a scalars and\nthey must have the same shape after conversion. In either case, either\n`x`, `y`, and `z` or their elements must support multiplication and\naddition both with themselves and with the elements of `c`.\n\nIf `c` has fewer than 3 dimensions, ones are implicitly appended to its\nshape to make it 3-D. The shape of the result will be c.shape[3:] +\nx.shape.\n\nParameters\n----------\nx, y, z : array_like, compatible object\n    The three dimensional series is evaluated at the points\n    `(x, y, z)`, where `x`, `y`, and `z` must have the same shape.  If\n    any of `x`, `y`, or `z` is a list or tuple, it is first converted\n    to an ndarray, otherwise it is left unchanged and if it isn't an\n    ndarray it is  treated as a scalar.\nc : array_like\n    Array of coefficients ordered so that the coefficient of the term of\n    multi-degree i,j,k is contained in ``c[i,j,k]``. If `c` has dimension\n    greater than 3 the remaining indices enumerate multiple sets of\n    coefficients.\n\nReturns\n-------\nvalues : ndarray, compatible object\n    The values of the multidimensional polynomial on points formed with\n    triples of corresponding values from `x`, `y`, and `z`.\n\nSee Also\n--------\nlegval, legval2d, leggrid2d, leggrid3d\n\nNotes\n-----\n\n.. versionadded::1.7.0", "id": "f18928:m15"}
{"signature": "def legval(x, c, tensor=True):", "body": "c = np.array(c, ndmin=<NUM_LIT:1>, copy=<NUM_LIT:0>)<EOL>if c.dtype.char in '<STR_LIT>':<EOL><INDENT>c = c.astype(np.double)<EOL><DEDENT>if isinstance(x, (tuple, list)):<EOL><INDENT>x = np.asarray(x)<EOL><DEDENT>if isinstance(x, np.ndarray) and tensor:<EOL><INDENT>c = c.reshape(c.shape + (<NUM_LIT:1>,)*x.ndim)<EOL><DEDENT>if len(c) == <NUM_LIT:1>:<EOL><INDENT>c0 = c[<NUM_LIT:0>]<EOL>c1 = <NUM_LIT:0><EOL><DEDENT>elif len(c) == <NUM_LIT:2>:<EOL><INDENT>c0 = c[<NUM_LIT:0>]<EOL>c1 = c[<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>nd = len(c)<EOL>c0 = c[-<NUM_LIT:2>]<EOL>c1 = c[-<NUM_LIT:1>]<EOL>for i in range(<NUM_LIT:3>, len(c) + <NUM_LIT:1>):<EOL><INDENT>tmp = c0<EOL>nd = nd - <NUM_LIT:1><EOL>c0 = c[-i] - (c1*(nd - <NUM_LIT:1>))/nd<EOL>c1 = tmp + (c1*x*(<NUM_LIT:2>*nd - <NUM_LIT:1>))/nd<EOL><DEDENT><DEDENT>return c0 + c1*x<EOL>", "docstring": "Evaluate a Legendre series at points x.\n\nIf `c` is of length `n + 1`, this function returns the value:\n\n.. math:: p(x) = c_0 * L_0(x) + c_1 * L_1(x) + ... + c_n * L_n(x)\n\nThe parameter `x` is converted to an array only if it is a tuple or a\nlist, otherwise it is treated as a scalar. In either case, either `x`\nor its elements must support multiplication and addition both with\nthemselves and with the elements of `c`.\n\nIf `c` is a 1-D array, then `p(x)` will have the same shape as `x`.  If\n`c` is multidimensional, then the shape of the result depends on the\nvalue of `tensor`. If `tensor` is true the shape will be c.shape[1:] +\nx.shape. If `tensor` is false the shape will be c.shape[1:]. Note that\nscalars have shape (,).\n\nTrailing zeros in the coefficients will be used in the evaluation, so\nthey should be avoided if efficiency is a concern.\n\nParameters\n----------\nx : array_like, compatible object\n    If `x` is a list or tuple, it is converted to an ndarray, otherwise\n    it is left unchanged and treated as a scalar. In either case, `x`\n    or its elements must support addition and multiplication with\n    with themselves and with the elements of `c`.\nc : array_like\n    Array of coefficients ordered so that the coefficients for terms of\n    degree n are contained in c[n]. If `c` is multidimensional the\n    remaining indices enumerate multiple polynomials. In the two\n    dimensional case the coefficients may be thought of as stored in\n    the columns of `c`.\ntensor : boolean, optional\n    If True, the shape of the coefficient array is extended with ones\n    on the right, one for each dimension of `x`. Scalars have dimension 0\n    for this action. The result is that every column of coefficients in\n    `c` is evaluated for every element of `x`. If False, `x` is broadcast\n    over the columns of `c` for the evaluation.  This keyword is useful\n    when `c` is multidimensional. The default value is True.\n\n    .. versionadded:: 1.7.0\n\nReturns\n-------\nvalues : ndarray, algebra_like\n    The shape of the return value is described above.\n\nSee Also\n--------\nlegval2d, leggrid2d, legval3d, leggrid3d\n\nNotes\n-----\nThe evaluation uses Clenshaw recursion, aka synthetic division.\n\nExamples\n--------", "id": "f18928:m12"}
{"signature": "def legmul(c1, c2):", "body": "<EOL>[c1, c2] = pu.as_series([c1, c2])<EOL>if len(c1) > len(c2):<EOL><INDENT>c = c2<EOL>xs = c1<EOL><DEDENT>else:<EOL><INDENT>c = c1<EOL>xs = c2<EOL><DEDENT>if len(c) == <NUM_LIT:1>:<EOL><INDENT>c0 = c[<NUM_LIT:0>]*xs<EOL>c1 = <NUM_LIT:0><EOL><DEDENT>elif len(c) == <NUM_LIT:2>:<EOL><INDENT>c0 = c[<NUM_LIT:0>]*xs<EOL>c1 = c[<NUM_LIT:1>]*xs<EOL><DEDENT>else:<EOL><INDENT>nd = len(c)<EOL>c0 = c[-<NUM_LIT:2>]*xs<EOL>c1 = c[-<NUM_LIT:1>]*xs<EOL>for i in range(<NUM_LIT:3>, len(c) + <NUM_LIT:1>):<EOL><INDENT>tmp = c0<EOL>nd = nd - <NUM_LIT:1><EOL>c0 = legsub(c[-i]*xs, (c1*(nd - <NUM_LIT:1>))/nd)<EOL>c1 = legadd(tmp, (legmulx(c1)*(<NUM_LIT:2>*nd - <NUM_LIT:1>))/nd)<EOL><DEDENT><DEDENT>return legadd(c0, legmulx(c1))<EOL>", "docstring": "Multiply one Legendre series by another.\n\nReturns the product of two Legendre series `c1` * `c2`.  The arguments\nare sequences of coefficients, from lowest order \"term\" to highest,\ne.g., [1,2,3] represents the series ``P_0 + 2*P_1 + 3*P_2``.\n\nParameters\n----------\nc1, c2 : array_like\n    1-D arrays of Legendre series coefficients ordered from low to\n    high.\n\nReturns\n-------\nout : ndarray\n    Of Legendre series coefficients representing their product.\n\nSee Also\n--------\nlegadd, legsub, legdiv, legpow\n\nNotes\n-----\nIn general, the (polynomial) product of two C-series results in terms\nthat are not in the Legendre polynomial basis set.  Thus, to express\nthe product as a Legendre series, it is necessary to \"reproject\" the\nproduct onto said basis set, which may produce \"unintuitive\" (but\ncorrect) results; see Examples section below.\n\nExamples\n--------\n>>> from numpy.polynomial import legendre as L\n>>> c1 = (1,2,3)\n>>> c2 = (3,2)\n>>> P.legmul(c1,c2) # multiplication requires \"reprojection\"\narray([  4.33333333,  10.4       ,  11.66666667,   3.6       ])", "id": "f18928:m7"}
{"signature": "def legweight(x):", "body": "w = x*<NUM_LIT:0.0> + <NUM_LIT:1.0><EOL>return w<EOL>", "docstring": "Weight function of the Legendre polynomials.\n\nThe weight function is :math:`1` and the interval of integration is\n:math:`[-1, 1]`. The Legendre polynomials are orthogonal, but not\nnormalized, with respect to this weight function.\n\nParameters\n----------\nx : array_like\n   Values at which the weight function will be computed.\n\nReturns\n-------\nw : ndarray\n   The weight function at `x`.\n\nNotes\n-----\n\n.. versionadded::1.7.0", "id": "f18928:m24"}
{"signature": "def legvander3d(x, y, z, deg):", "body": "ideg = [int(d) for d in deg]<EOL>is_valid = [id == d and id >= <NUM_LIT:0> for id, d in zip(ideg, deg)]<EOL>if is_valid != [<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>]:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>degx, degy, degz = ideg<EOL>x, y, z = np.array((x, y, z), copy=<NUM_LIT:0>) + <NUM_LIT:0.0><EOL>vx = legvander(x, degx)<EOL>vy = legvander(y, degy)<EOL>vz = legvander(z, degz)<EOL>v = vx[..., None, None]*vy[..., None,:, None]*vz[..., None, None,:]<EOL>return v.reshape(v.shape[:-<NUM_LIT:3>] + (-<NUM_LIT:1>,))<EOL>", "docstring": "Pseudo-Vandermonde matrix of given degrees.\n\n    Returns the pseudo-Vandermonde matrix of degrees `deg` and sample\n    points `(x, y, z)`. If `l, m, n` are the given degrees in `x, y, z`,\n    then The pseudo-Vandermonde matrix is defined by\n\n    .. math:: V[..., (m+1)(n+1)i + (n+1)j + k] = L_i(x)*L_j(y)*L_k(z),\n\n    where `0 <= i <= l`, `0 <= j <= m`, and `0 <= j <= n`.  The leading\n    indices of `V` index the points `(x, y, z)` and the last index encodes\n    the degrees of the Legendre polynomials.\n\n    If ``V = legvander3d(x, y, z, [xdeg, ydeg, zdeg])``, then the columns\n    of `V` correspond to the elements of a 3-D coefficient array `c` of\n    shape (xdeg + 1, ydeg + 1, zdeg + 1) in the order\n\n    .. math:: c_{000}, c_{001}, c_{002},... , c_{010}, c_{011}, c_{012},...\n\n    and ``np.dot(V, c.flat)`` and ``legval3d(x, y, z, c)`` will be the\n    same up to roundoff. This equivalence is useful both for least squares\n    fitting and for the evaluation of a large number of 3-D Legendre\n    series of the same degrees and sample points.\n\n    Parameters\n    ----------\n    x, y, z : array_like\n        Arrays of point coordinates, all of the same shape. The dtypes will\n        be converted to either float64 or complex128 depending on whether\n        any of the elements are complex. Scalars are converted to 1-D\n        arrays.\n    deg : list of ints\n        List of maximum degrees of the form [x_deg, y_deg, z_deg].\n\n    Returns\n    -------\n    vander3d : ndarray\n        The shape of the returned matrix is ``x.shape + (order,)``, where\n        :math:`order = (deg[0]+1)*(deg([1]+1)*(deg[2]+1)`.  The dtype will\n        be the same as the converted `x`, `y`, and `z`.\n\n    See Also\n    --------\n    legvander, legvander3d. legval2d, legval3d\n\n    Notes\n    -----\n\n    .. versionadded::1.7.0", "id": "f18928:m19"}
{"signature": "def legder(c, m=<NUM_LIT:1>, scl=<NUM_LIT:1>, axis=<NUM_LIT:0>):", "body": "c = np.array(c, ndmin=<NUM_LIT:1>, copy=<NUM_LIT:1>)<EOL>if c.dtype.char in '<STR_LIT>':<EOL><INDENT>c = c.astype(np.double)<EOL><DEDENT>cnt, iaxis = [int(t) for t in [m, axis]]<EOL>if cnt != m:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if cnt < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if iaxis != axis:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not -c.ndim <= iaxis < c.ndim:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if iaxis < <NUM_LIT:0>:<EOL><INDENT>iaxis += c.ndim<EOL><DEDENT>if cnt == <NUM_LIT:0>:<EOL><INDENT>return c<EOL><DEDENT>c = np.rollaxis(c, iaxis)<EOL>n = len(c)<EOL>if cnt >= n:<EOL><INDENT>c = c[:<NUM_LIT:1>]*<NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>for i in range(cnt):<EOL><INDENT>n = n - <NUM_LIT:1><EOL>c *= scl<EOL>der = np.empty((n,) + c.shape[<NUM_LIT:1>:], dtype=c.dtype)<EOL>for j in range(n, <NUM_LIT:2>, -<NUM_LIT:1>):<EOL><INDENT>der[j - <NUM_LIT:1>] = (<NUM_LIT:2>*j - <NUM_LIT:1>)*c[j]<EOL>c[j - <NUM_LIT:2>] += c[j]<EOL><DEDENT>if n > <NUM_LIT:1>:<EOL><INDENT>der[<NUM_LIT:1>] = <NUM_LIT:3>*c[<NUM_LIT:2>]<EOL><DEDENT>der[<NUM_LIT:0>] = c[<NUM_LIT:1>]<EOL>c = der<EOL><DEDENT><DEDENT>c = np.rollaxis(c, <NUM_LIT:0>, iaxis + <NUM_LIT:1>)<EOL>return c<EOL>", "docstring": "Differentiate a Legendre series.\n\nReturns the Legendre series coefficients `c` differentiated `m` times\nalong `axis`.  At each iteration the result is multiplied by `scl` (the\nscaling factor is for use in a linear change of variable). The argument\n`c` is an array of coefficients from low to high degree along each\naxis, e.g., [1,2,3] represents the series ``1*L_0 + 2*L_1 + 3*L_2``\nwhile [[1,2],[1,2]] represents ``1*L_0(x)*L_0(y) + 1*L_1(x)*L_0(y) +\n2*L_0(x)*L_1(y) + 2*L_1(x)*L_1(y)`` if axis=0 is ``x`` and axis=1 is\n``y``.\n\nParameters\n----------\nc : array_like\n    Array of Legendre series coefficients. If c is multidimensional the\n    different axis correspond to different variables with the degree in\n    each axis given by the corresponding index.\nm : int, optional\n    Number of derivatives taken, must be non-negative. (Default: 1)\nscl : scalar, optional\n    Each differentiation is multiplied by `scl`.  The end result is\n    multiplication by ``scl**m``.  This is for use in a linear change of\n    variable. (Default: 1)\naxis : int, optional\n    Axis over which the derivative is taken. (Default: 0).\n\n    .. versionadded:: 1.7.0\n\nReturns\n-------\nder : ndarray\n    Legendre series of the derivative.\n\nSee Also\n--------\nlegint\n\nNotes\n-----\nIn general, the result of differentiating a Legendre series does not\nresemble the same operation on a power series. Thus the result of this\nfunction may be \"unintuitive,\" albeit correct; see Examples section\nbelow.\n\nExamples\n--------\n>>> from numpy.polynomial import legendre as L\n>>> c = (1,2,3,4)\n>>> L.legder(c)\narray([  6.,   9.,  20.])\n>>> L.legder(c, 3)\narray([ 60.])\n>>> L.legder(c, scl=-1)\narray([ -6.,  -9., -20.])\n>>> L.legder(c, 2,-1)\narray([  9.,  60.])", "id": "f18928:m10"}
{"signature": "def polygrid3d(x, y, z, c):", "body": "c = polyval(x, c)<EOL>c = polyval(y, c)<EOL>c = polyval(z, c)<EOL>return c<EOL>", "docstring": "Evaluate a 3-D polynomial on the Cartesian product of x, y and z.\n\nThis function returns the values:\n\n.. math:: p(a,b,c) = \\\\sum_{i,j,k} c_{i,j,k} * a^i * b^j * c^k\n\nwhere the points `(a, b, c)` consist of all triples formed by taking\n`a` from `x`, `b` from `y`, and `c` from `z`. The resulting points form\na grid with `x` in the first dimension, `y` in the second, and `z` in\nthe third.\n\nThe parameters `x`, `y`, and `z` are converted to arrays only if they\nare tuples or a lists, otherwise they are treated as a scalars. In\neither case, either `x`, `y`, and `z` or their elements must support\nmultiplication and addition both with themselves and with the elements\nof `c`.\n\nIf `c` has fewer than three dimensions, ones are implicitly appended to\nits shape to make it 3-D. The shape of the result will be c.shape[3:] +\nx.shape + y.shape + z.shape.\n\nParameters\n----------\nx, y, z : array_like, compatible objects\n    The three dimensional series is evaluated at the points in the\n    Cartesian product of `x`, `y`, and `z`.  If `x`,`y`, or `z` is a\n    list or tuple, it is first converted to an ndarray, otherwise it is\n    left unchanged and, if it isn't an ndarray, it is treated as a\n    scalar.\nc : array_like\n    Array of coefficients ordered so that the coefficients for terms of\n    degree i,j are contained in ``c[i,j]``. If `c` has dimension\n    greater than two the remaining indices enumerate multiple sets of\n    coefficients.\n\nReturns\n-------\nvalues : ndarray, compatible object\n    The values of the two dimensional polynomial at points in the Cartesian\n    product of `x` and `y`.\n\nSee Also\n--------\npolyval, polyval2d, polygrid2d, polyval3d\n\nNotes\n-----\n\n.. versionadded:: 1.7.0", "id": "f18930:m14"}
{"signature": "def polymulx(c):", "body": "<EOL>[c] = pu.as_series([c])<EOL>if len(c) == <NUM_LIT:1> and c[<NUM_LIT:0>] == <NUM_LIT:0>:<EOL><INDENT>return c<EOL><DEDENT>prd = np.empty(len(c) + <NUM_LIT:1>, dtype=c.dtype)<EOL>prd[<NUM_LIT:0>] = c[<NUM_LIT:0>]*<NUM_LIT:0><EOL>prd[<NUM_LIT:1>:] = c<EOL>return prd<EOL>", "docstring": "Multiply a polynomial by x.\n\n    Multiply the polynomial `c` by x, where x is the independent\n    variable.\n\n\n    Parameters\n    ----------\n    c : array_like\n        1-D array of polynomial coefficients ordered from low to\n        high.\n\n    Returns\n    -------\n    out : ndarray\n        Array representing the result of the multiplication.\n\n    Notes\n    -----\n\n    .. versionadded:: 1.5.0", "id": "f18930:m4"}
{"signature": "def polycompanion(c):", "body": "<EOL>[c] = pu.as_series([c])<EOL>if len(c) < <NUM_LIT:2>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if len(c) == <NUM_LIT:2>:<EOL><INDENT>return np.array([[-c[<NUM_LIT:0>]/c[<NUM_LIT:1>]]])<EOL><DEDENT>n = len(c) - <NUM_LIT:1><EOL>mat = np.zeros((n, n), dtype=c.dtype)<EOL>bot = mat.reshape(-<NUM_LIT:1>)[n::n+<NUM_LIT:1>]<EOL>bot[...] = <NUM_LIT:1><EOL>mat[:, -<NUM_LIT:1>] -= c[:-<NUM_LIT:1>]/c[-<NUM_LIT:1>]<EOL>return mat<EOL>", "docstring": "Return the companion matrix of c.\n\nThe companion matrix for power series cannot be made symmetric by\nscaling the basis, so this function differs from those for the\northogonal polynomials.\n\nParameters\n----------\nc : array_like\n    1-D array of polynomial coefficients ordered from low to high\n    degree.\n\nReturns\n-------\nmat : ndarray\n    Companion matrix of dimensions (deg, deg).\n\nNotes\n-----\n\n.. versionadded:: 1.7.0", "id": "f18930:m19"}
{"signature": "def polyadd(c1, c2):", "body": "<EOL>[c1, c2] = pu.as_series([c1, c2])<EOL>if len(c1) > len(c2):<EOL><INDENT>c1[:c2.size] += c2<EOL>ret = c1<EOL><DEDENT>else:<EOL><INDENT>c2[:c1.size] += c1<EOL>ret = c2<EOL><DEDENT>return pu.trimseq(ret)<EOL>", "docstring": "Add one polynomial to another.\n\nReturns the sum of two polynomials `c1` + `c2`.  The arguments are\nsequences of coefficients from lowest order term to highest, i.e.,\n[1,2,3] represents the polynomial ``1 + 2*x + 3*x**2``.\n\nParameters\n----------\nc1, c2 : array_like\n    1-D arrays of polynomial coefficients ordered from low to high.\n\nReturns\n-------\nout : ndarray\n    The coefficient array representing their sum.\n\nSee Also\n--------\npolysub, polymul, polydiv, polypow\n\nExamples\n--------\n>>> from numpy.polynomial import polynomial as P\n>>> c1 = (1,2,3)\n>>> c2 = (3,2,1)\n>>> sum = P.polyadd(c1,c2); sum\narray([ 4.,  4.,  4.])\n>>> P.polyval(2, sum) # 4 + 4(2) + 4(2**2)\n28.0", "id": "f18930:m2"}
{"signature": "def polyval3d(x, y, z, c):", "body": "try:<EOL><INDENT>x, y, z = np.array((x, y, z), copy=<NUM_LIT:0>)<EOL><DEDENT>except:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>c = polyval(x, c)<EOL>c = polyval(y, c, tensor=False)<EOL>c = polyval(z, c, tensor=False)<EOL>return c<EOL>", "docstring": "Evaluate a 3-D polynomial at points (x, y, z).\n\nThis function returns the values:\n\n.. math:: p(x,y,z) = \\\\sum_{i,j,k} c_{i,j,k} * x^i * y^j * z^k\n\nThe parameters `x`, `y`, and `z` are converted to arrays only if\nthey are tuples or a lists, otherwise they are treated as a scalars and\nthey must have the same shape after conversion. In either case, either\n`x`, `y`, and `z` or their elements must support multiplication and\naddition both with themselves and with the elements of `c`.\n\nIf `c` has fewer than 3 dimensions, ones are implicitly appended to its\nshape to make it 3-D. The shape of the result will be c.shape[3:] +\nx.shape.\n\nParameters\n----------\nx, y, z : array_like, compatible object\n    The three dimensional series is evaluated at the points\n    `(x, y, z)`, where `x`, `y`, and `z` must have the same shape.  If\n    any of `x`, `y`, or `z` is a list or tuple, it is first converted\n    to an ndarray, otherwise it is left unchanged and if it isn't an\n    ndarray it is  treated as a scalar.\nc : array_like\n    Array of coefficients ordered so that the coefficient of the term of\n    multi-degree i,j,k is contained in ``c[i,j,k]``. If `c` has dimension\n    greater than 3 the remaining indices enumerate multiple sets of\n    coefficients.\n\nReturns\n-------\nvalues : ndarray, compatible object\n    The values of the multidimensional polynomial on points formed with\n    triples of corresponding values from `x`, `y`, and `z`.\n\nSee Also\n--------\npolyval, polyval2d, polygrid2d, polygrid3d\n\nNotes\n-----\n\n.. versionadded:: 1.7.0", "id": "f18930:m13"}
{"signature": "def polysub(c1, c2):", "body": "<EOL>[c1, c2] = pu.as_series([c1, c2])<EOL>if len(c1) > len(c2):<EOL><INDENT>c1[:c2.size] -= c2<EOL>ret = c1<EOL><DEDENT>else:<EOL><INDENT>c2 = -c2<EOL>c2[:c1.size] += c1<EOL>ret = c2<EOL><DEDENT>return pu.trimseq(ret)<EOL>", "docstring": "Subtract one polynomial from another.\n\nReturns the difference of two polynomials `c1` - `c2`.  The arguments\nare sequences of coefficients from lowest order term to highest, i.e.,\n[1,2,3] represents the polynomial ``1 + 2*x + 3*x**2``.\n\nParameters\n----------\nc1, c2 : array_like\n    1-D arrays of polynomial coefficients ordered from low to\n    high.\n\nReturns\n-------\nout : ndarray\n    Of coefficients representing their difference.\n\nSee Also\n--------\npolyadd, polymul, polydiv, polypow\n\nExamples\n--------\n>>> from numpy.polynomial import polynomial as P\n>>> c1 = (1,2,3)\n>>> c2 = (3,2,1)\n>>> P.polysub(c1,c2)\narray([-2.,  0.,  2.])\n>>> P.polysub(c2,c1) # -P.polysub(c1,c2)\narray([ 2.,  0., -2.])", "id": "f18930:m3"}
{"signature": "def polyvander(x, deg):", "body": "ideg = int(deg)<EOL>if ideg != deg:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if ideg < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>x = np.array(x, copy=<NUM_LIT:0>, ndmin=<NUM_LIT:1>) + <NUM_LIT:0.0><EOL>dims = (ideg + <NUM_LIT:1>,) + x.shape<EOL>dtyp = x.dtype<EOL>v = np.empty(dims, dtype=dtyp)<EOL>v[<NUM_LIT:0>] = x*<NUM_LIT:0> + <NUM_LIT:1><EOL>if ideg > <NUM_LIT:0>:<EOL><INDENT>v[<NUM_LIT:1>] = x<EOL>for i in range(<NUM_LIT:2>, ideg + <NUM_LIT:1>):<EOL><INDENT>v[i] = v[i-<NUM_LIT:1>]*x<EOL><DEDENT><DEDENT>return np.rollaxis(v, <NUM_LIT:0>, v.ndim)<EOL>", "docstring": "Vandermonde matrix of given degree.\n\n    Returns the Vandermonde matrix of degree `deg` and sample points\n    `x`. The Vandermonde matrix is defined by\n\n    .. math:: V[..., i] = x^i,\n\n    where `0 <= i <= deg`. The leading indices of `V` index the elements of\n    `x` and the last index is the power of `x`.\n\n    If `c` is a 1-D array of coefficients of length `n + 1` and `V` is the\n    matrix ``V = polyvander(x, n)``, then ``np.dot(V, c)`` and\n    ``polyval(x, c)`` are the same up to roundoff. This equivalence is\n    useful both for least squares fitting and for the evaluation of a large\n    number of polynomials of the same degree and sample points.\n\n    Parameters\n    ----------\n    x : array_like\n        Array of points. The dtype is converted to float64 or complex128\n        depending on whether any of the elements are complex. If `x` is\n        scalar it is converted to a 1-D array.\n    deg : int\n        Degree of the resulting matrix.\n\n    Returns\n    -------\n    vander : ndarray.\n        The Vandermonde matrix. The shape of the returned matrix is\n        ``x.shape + (deg + 1,)``, where the last index is the power of `x`.\n        The dtype will be the same as the converted `x`.\n\n    See Also\n    --------\n    polyvander2d, polyvander3d", "id": "f18930:m15"}
{"signature": "def hermegrid2d(x, y, c):", "body": "c = hermeval(x, c)<EOL>c = hermeval(y, c)<EOL>return c<EOL>", "docstring": "Evaluate a 2-D HermiteE series on the Cartesian product of x and y.\n\nThis function returns the values:\n\n.. math:: p(a,b) = \\sum_{i,j} c_{i,j} * H_i(a) * H_j(b)\n\nwhere the points `(a, b)` consist of all pairs formed by taking\n`a` from `x` and `b` from `y`. The resulting points form a grid with\n`x` in the first dimension and `y` in the second.\n\nThe parameters `x` and `y` are converted to arrays only if they are\ntuples or a lists, otherwise they are treated as a scalars. In either\ncase, either `x` and `y` or their elements must support multiplication\nand addition both with themselves and with the elements of `c`.\n\nIf `c` has fewer than two dimensions, ones are implicitly appended to\nits shape to make it 2-D. The shape of the result will be c.shape[2:] +\nx.shape.\n\nParameters\n----------\nx, y : array_like, compatible objects\n    The two dimensional series is evaluated at the points in the\n    Cartesian product of `x` and `y`.  If `x` or `y` is a list or\n    tuple, it is first converted to an ndarray, otherwise it is left\n    unchanged and, if it isn't an ndarray, it is treated as a scalar.\nc : array_like\n    Array of coefficients ordered so that the coefficients for terms of\n    degree i,j are contained in ``c[i,j]``. If `c` has dimension\n    greater than two the remaining indices enumerate multiple sets of\n    coefficients.\n\nReturns\n-------\nvalues : ndarray, compatible object\n    The values of the two dimensional polynomial at points in the Cartesian\n    product of `x` and `y`.\n\nSee Also\n--------\nhermeval, hermeval2d, hermeval3d, hermegrid3d\n\nNotes\n-----\n\n.. versionadded::1.7.0", "id": "f18931:m14"}
{"signature": "def hermeval3d(x, y, z, c):", "body": "try:<EOL><INDENT>x, y, z = np.array((x, y, z), copy=<NUM_LIT:0>)<EOL><DEDENT>except:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>c = hermeval(x, c)<EOL>c = hermeval(y, c, tensor=False)<EOL>c = hermeval(z, c, tensor=False)<EOL>return c<EOL>", "docstring": "Evaluate a 3-D Hermite_e series at points (x, y, z).\n\nThis function returns the values:\n\n.. math:: p(x,y,z) = \\\\sum_{i,j,k} c_{i,j,k} * He_i(x) * He_j(y) * He_k(z)\n\nThe parameters `x`, `y`, and `z` are converted to arrays only if\nthey are tuples or a lists, otherwise they are treated as a scalars and\nthey must have the same shape after conversion. In either case, either\n`x`, `y`, and `z` or their elements must support multiplication and\naddition both with themselves and with the elements of `c`.\n\nIf `c` has fewer than 3 dimensions, ones are implicitly appended to its\nshape to make it 3-D. The shape of the result will be c.shape[3:] +\nx.shape.\n\nParameters\n----------\nx, y, z : array_like, compatible object\n    The three dimensional series is evaluated at the points\n    `(x, y, z)`, where `x`, `y`, and `z` must have the same shape.  If\n    any of `x`, `y`, or `z` is a list or tuple, it is first converted\n    to an ndarray, otherwise it is left unchanged and if it isn't an\n    ndarray it is  treated as a scalar.\nc : array_like\n    Array of coefficients ordered so that the coefficient of the term of\n    multi-degree i,j,k is contained in ``c[i,j,k]``. If `c` has dimension\n    greater than 3 the remaining indices enumerate multiple sets of\n    coefficients.\n\nReturns\n-------\nvalues : ndarray, compatible object\n    The values of the multidimensional polynomial on points formed with\n    triples of corresponding values from `x`, `y`, and `z`.\n\nSee Also\n--------\nhermeval, hermeval2d, hermegrid2d, hermegrid3d\n\nNotes\n-----\n\n.. versionadded::1.7.0", "id": "f18931:m15"}
{"signature": "def hermemul(c1, c2):", "body": "<EOL>[c1, c2] = pu.as_series([c1, c2])<EOL>if len(c1) > len(c2):<EOL><INDENT>c = c2<EOL>xs = c1<EOL><DEDENT>else:<EOL><INDENT>c = c1<EOL>xs = c2<EOL><DEDENT>if len(c) == <NUM_LIT:1>:<EOL><INDENT>c0 = c[<NUM_LIT:0>]*xs<EOL>c1 = <NUM_LIT:0><EOL><DEDENT>elif len(c) == <NUM_LIT:2>:<EOL><INDENT>c0 = c[<NUM_LIT:0>]*xs<EOL>c1 = c[<NUM_LIT:1>]*xs<EOL><DEDENT>else:<EOL><INDENT>nd = len(c)<EOL>c0 = c[-<NUM_LIT:2>]*xs<EOL>c1 = c[-<NUM_LIT:1>]*xs<EOL>for i in range(<NUM_LIT:3>, len(c) + <NUM_LIT:1>):<EOL><INDENT>tmp = c0<EOL>nd = nd - <NUM_LIT:1><EOL>c0 = hermesub(c[-i]*xs, c1*(nd - <NUM_LIT:1>))<EOL>c1 = hermeadd(tmp, hermemulx(c1))<EOL><DEDENT><DEDENT>return hermeadd(c0, hermemulx(c1))<EOL>", "docstring": "Multiply one Hermite series by another.\n\nReturns the product of two Hermite series `c1` * `c2`.  The arguments\nare sequences of coefficients, from lowest order \"term\" to highest,\ne.g., [1,2,3] represents the series ``P_0 + 2*P_1 + 3*P_2``.\n\nParameters\n----------\nc1, c2 : array_like\n    1-D arrays of Hermite series coefficients ordered from low to\n    high.\n\nReturns\n-------\nout : ndarray\n    Of Hermite series coefficients representing their product.\n\nSee Also\n--------\nhermeadd, hermesub, hermediv, hermepow\n\nNotes\n-----\nIn general, the (polynomial) product of two C-series results in terms\nthat are not in the Hermite polynomial basis set.  Thus, to express\nthe product as a Hermite series, it is necessary to \"reproject\" the\nproduct onto said basis set, which may produce \"unintuitive\" (but\ncorrect) results; see Examples section below.\n\nExamples\n--------\n>>> from numpy.polynomial.hermite_e import hermemul\n>>> hermemul([1, 2, 3], [0, 1, 2])\narray([ 14.,  15.,  28.,   7.,   6.])", "id": "f18931:m7"}
{"signature": "def herme2poly(c):", "body": "from .polynomial import polyadd, polysub, polymulx<EOL>[c] = pu.as_series([c])<EOL>n = len(c)<EOL>if n == <NUM_LIT:1>:<EOL><INDENT>return c<EOL><DEDENT>if n == <NUM_LIT:2>:<EOL><INDENT>return c<EOL><DEDENT>else:<EOL><INDENT>c0 = c[-<NUM_LIT:2>]<EOL>c1 = c[-<NUM_LIT:1>]<EOL>for i in range(n - <NUM_LIT:1>, <NUM_LIT:1>, -<NUM_LIT:1>):<EOL><INDENT>tmp = c0<EOL>c0 = polysub(c[i - <NUM_LIT:2>], c1*(i - <NUM_LIT:1>))<EOL>c1 = polyadd(tmp, polymulx(c1))<EOL><DEDENT>return polyadd(c0, polymulx(c1))<EOL><DEDENT>", "docstring": "Convert a Hermite series to a polynomial.\n\nConvert an array representing the coefficients of a Hermite series,\nordered from lowest degree to highest, to an array of the coefficients\nof the equivalent polynomial (relative to the \"standard\" basis) ordered\nfrom lowest to highest degree.\n\nParameters\n----------\nc : array_like\n    1-D array containing the Hermite series coefficients, ordered\n    from lowest order term to highest.\n\nReturns\n-------\npol : ndarray\n    1-D array containing the coefficients of the equivalent polynomial\n    (relative to the \"standard\" basis) ordered from lowest order term\n    to highest.\n\nSee Also\n--------\npoly2herme\n\nNotes\n-----\nThe easy way to do conversions between polynomial basis sets\nis to use the convert method of a class instance.\n\nExamples\n--------\n>>> from numpy.polynomial.hermite_e import herme2poly\n>>> herme2poly([  2.,  10.,   2.,   3.])\narray([ 0.,  1.,  2.,  3.])", "id": "f18931:m1"}
{"signature": "def hermepow(c, pow, maxpower=<NUM_LIT:16>):", "body": "<EOL>[c] = pu.as_series([c])<EOL>power = int(pow)<EOL>if power != pow or power < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>elif maxpower is not None and power > maxpower:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>elif power == <NUM_LIT:0>:<EOL><INDENT>return np.array([<NUM_LIT:1>], dtype=c.dtype)<EOL><DEDENT>elif power == <NUM_LIT:1>:<EOL><INDENT>return c<EOL><DEDENT>else:<EOL><INDENT>prd = c<EOL>for i in range(<NUM_LIT:2>, power + <NUM_LIT:1>):<EOL><INDENT>prd = hermemul(prd, c)<EOL><DEDENT>return prd<EOL><DEDENT>", "docstring": "Raise a Hermite series to a power.\n\n    Returns the Hermite series `c` raised to the power `pow`. The\n    argument `c` is a sequence of coefficients ordered from low to high.\n    i.e., [1,2,3] is the series  ``P_0 + 2*P_1 + 3*P_2.``\n\n    Parameters\n    ----------\n    c : array_like\n        1-D array of Hermite series coefficients ordered from low to\n        high.\n    pow : integer\n        Power to which the series will be raised\n    maxpower : integer, optional\n        Maximum power allowed. This is mainly to limit growth of the series\n        to unmanageable size. Default is 16\n\n    Returns\n    -------\n    coef : ndarray\n        Hermite series of power.\n\n    See Also\n    --------\n    hermeadd, hermesub, hermemul, hermediv\n\n    Examples\n    --------\n    >>> from numpy.polynomial.hermite_e import hermepow\n    >>> hermepow([1, 2, 3], 2)\n    array([ 23.,  28.,  46.,  12.,   9.])", "id": "f18931:m9"}
{"signature": "def hermeweight(x):", "body": "w = np.exp(-<NUM_LIT>*x**<NUM_LIT:2>)<EOL>return w<EOL>", "docstring": "Weight function of the Hermite_e polynomials.\n\n    The weight function is :math:`\\exp(-x^2/2)` and the interval of\n    integration is :math:`[-\\inf, \\inf]`. the HermiteE polynomials are\n    orthogonal, but not normalized, with respect to this weight function.\n\n    Parameters\n    ----------\n    x : array_like\n       Values at which the weight function will be computed.\n\n    Returns\n    -------\n    w : ndarray\n       The weight function at `x`.\n\n    Notes\n    -----\n\n    .. versionadded::1.7.0", "id": "f18931:m24"}
{"signature": "def hermefit(x, y, deg, rcond=None, full=False, w=None):", "body": "order = int(deg) + <NUM_LIT:1><EOL>x = np.asarray(x) + <NUM_LIT:0.0><EOL>y = np.asarray(y) + <NUM_LIT:0.0><EOL>if deg < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if x.ndim != <NUM_LIT:1>:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if x.size == <NUM_LIT:0>:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if y.ndim < <NUM_LIT:1> or y.ndim > <NUM_LIT:2>:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if len(x) != len(y):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>lhs = hermevander(x, deg).T<EOL>rhs = y.T<EOL>if w is not None:<EOL><INDENT>w = np.asarray(w) + <NUM_LIT:0.0><EOL>if w.ndim != <NUM_LIT:1>:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if len(x) != len(w):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>lhs = lhs * w<EOL>rhs = rhs * w<EOL><DEDENT>if rcond is None:<EOL><INDENT>rcond = len(x)*np.finfo(x.dtype).eps<EOL><DEDENT>if issubclass(lhs.dtype.type, np.complexfloating):<EOL><INDENT>scl = np.sqrt((np.square(lhs.real) + np.square(lhs.imag)).sum(<NUM_LIT:1>))<EOL><DEDENT>else:<EOL><INDENT>scl = np.sqrt(np.square(lhs).sum(<NUM_LIT:1>))<EOL><DEDENT>scl[scl == <NUM_LIT:0>] = <NUM_LIT:1><EOL>c, resids, rank, s = la.lstsq(lhs.T/scl, rhs.T, rcond)<EOL>c = (c.T/scl).T<EOL>if rank != order and not full:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>warnings.warn(msg, pu.RankWarning)<EOL><DEDENT>if full:<EOL><INDENT>return c, [resids, rank, s, rcond]<EOL><DEDENT>else:<EOL><INDENT>return c<EOL><DEDENT>", "docstring": "Least squares fit of Hermite series to data.\n\nReturn the coefficients of a HermiteE series of degree `deg` that is\nthe least squares fit to the data values `y` given at points `x`. If\n`y` is 1-D the returned coefficients will also be 1-D. If `y` is 2-D\nmultiple fits are done, one for each column of `y`, and the resulting\ncoefficients are stored in the corresponding columns of a 2-D return.\nThe fitted polynomial(s) are in the form\n\n.. math::  p(x) = c_0 + c_1 * He_1(x) + ... + c_n * He_n(x),\n\nwhere `n` is `deg`.\n\nParameters\n----------\nx : array_like, shape (M,)\n    x-coordinates of the M sample points ``(x[i], y[i])``.\ny : array_like, shape (M,) or (M, K)\n    y-coordinates of the sample points. Several data sets of sample\n    points sharing the same x-coordinates can be fitted at once by\n    passing in a 2D-array that contains one dataset per column.\ndeg : int\n    Degree of the fitting polynomial\nrcond : float, optional\n    Relative condition number of the fit. Singular values smaller than\n    this relative to the largest singular value will be ignored. The\n    default value is len(x)*eps, where eps is the relative precision of\n    the float type, about 2e-16 in most cases.\nfull : bool, optional\n    Switch determining nature of return value. When it is False (the\n    default) just the coefficients are returned, when True diagnostic\n    information from the singular value decomposition is also returned.\nw : array_like, shape (`M`,), optional\n    Weights. If not None, the contribution of each point\n    ``(x[i],y[i])`` to the fit is weighted by `w[i]`. Ideally the\n    weights are chosen so that the errors of the products ``w[i]*y[i]``\n    all have the same variance.  The default value is None.\n\nReturns\n-------\ncoef : ndarray, shape (M,) or (M, K)\n    Hermite coefficients ordered from low to high. If `y` was 2-D,\n    the coefficients for the data in column k  of `y` are in column\n    `k`.\n\n[residuals, rank, singular_values, rcond] : list\n    These values are only returned if `full` = True\n\n    resid -- sum of squared residuals of the least squares fit\n    rank -- the numerical rank of the scaled Vandermonde matrix\n    sv -- singular values of the scaled Vandermonde matrix\n    rcond -- value of `rcond`.\n\n    For more details, see `linalg.lstsq`.\n\nWarns\n-----\nRankWarning\n    The rank of the coefficient matrix in the least-squares fit is\n    deficient. The warning is only raised if `full` = False.  The\n    warnings can be turned off by\n\n    >>> import warnings\n    >>> warnings.simplefilter('ignore', RankWarning)\n\nSee Also\n--------\nchebfit, legfit, polyfit, hermfit, polyfit\nhermeval : Evaluates a Hermite series.\nhermevander : pseudo Vandermonde matrix of Hermite series.\nhermeweight : HermiteE weight function.\nlinalg.lstsq : Computes a least-squares fit from the matrix.\nscipy.interpolate.UnivariateSpline : Computes spline fits.\n\nNotes\n-----\nThe solution is the coefficients of the HermiteE series `p` that\nminimizes the sum of the weighted squared errors\n\n.. math:: E = \\\\sum_j w_j^2 * |y_j - p(x_j)|^2,\n\nwhere the :math:`w_j` are the weights. This problem is solved by\nsetting up the (typically) overdetermined matrix equation\n\n.. math:: V(x) * c = w * y,\n\nwhere `V` is the pseudo Vandermonde matrix of `x`, the elements of `c`\nare the coefficients to be solved for, and the elements of `y` are the\nobserved values.  This equation is then solved using the singular value\ndecomposition of `V`.\n\nIf some of the singular values of `V` are so small that they are\nneglected, then a `RankWarning` will be issued. This means that the\ncoefficient values may be poorly determined. Using a lower order fit\nwill usually get rid of the warning.  The `rcond` parameter can also be\nset to a value smaller than its default, but the resulting fit may be\nspurious and have large contributions from roundoff error.\n\nFits using HermiteE series are probably most useful when the data can\nbe approximated by ``sqrt(w(x)) * p(x)``, where `w(x)` is the HermiteE\nweight. In that case the weight ``sqrt(w(x[i])`` should be used\ntogether with data values ``y[i]/sqrt(w(x[i])``. The weight function is\navailable as `hermeweight`.\n\nReferences\n----------\n.. [1] Wikipedia, \"Curve fitting\",\n       http://en.wikipedia.org/wiki/Curve_fitting\n\nExamples\n--------\n>>> from numpy.polynomial.hermite_e import hermefik, hermeval\n>>> x = np.linspace(-10, 10)\n>>> err = np.random.randn(len(x))/10\n>>> y = hermeval(x, [1, 2, 3]) + err\n>>> hermefit(x, y, 2)\narray([ 1.01690445,  1.99951418,  2.99948696])", "id": "f18931:m20"}
{"signature": "def lagweight(x):", "body": "w = np.exp(-x)<EOL>return w<EOL>", "docstring": "Weight function of the Laguerre polynomials.\n\n    The weight function is :math:`exp(-x)` and the interval of integration\n    is :math:`[0, \\inf]`. The Laguerre polynomials are orthogonal, but not\n    normalized, with respect to this weight function.\n\n    Parameters\n    ----------\n    x : array_like\n       Values at which the weight function will be computed.\n\n    Returns\n    -------\n    w : ndarray\n       The weight function at `x`.\n\n    Notes\n    -----\n\n    .. versionadded::1.7.0", "id": "f18933:m24"}
{"signature": "def lagval3d(x, y, z, c):", "body": "try:<EOL><INDENT>x, y, z = np.array((x, y, z), copy=<NUM_LIT:0>)<EOL><DEDENT>except:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>c = lagval(x, c)<EOL>c = lagval(y, c, tensor=False)<EOL>c = lagval(z, c, tensor=False)<EOL>return c<EOL>", "docstring": "Evaluate a 3-D Laguerre series at points (x, y, z).\n\nThis function returns the values:\n\n.. math:: p(x,y,z) = \\\\sum_{i,j,k} c_{i,j,k} * L_i(x) * L_j(y) * L_k(z)\n\nThe parameters `x`, `y`, and `z` are converted to arrays only if\nthey are tuples or a lists, otherwise they are treated as a scalars and\nthey must have the same shape after conversion. In either case, either\n`x`, `y`, and `z` or their elements must support multiplication and\naddition both with themselves and with the elements of `c`.\n\nIf `c` has fewer than 3 dimensions, ones are implicitly appended to its\nshape to make it 3-D. The shape of the result will be c.shape[3:] +\nx.shape.\n\nParameters\n----------\nx, y, z : array_like, compatible object\n    The three dimensional series is evaluated at the points\n    `(x, y, z)`, where `x`, `y`, and `z` must have the same shape.  If\n    any of `x`, `y`, or `z` is a list or tuple, it is first converted\n    to an ndarray, otherwise it is left unchanged and if it isn't an\n    ndarray it is  treated as a scalar.\nc : array_like\n    Array of coefficients ordered so that the coefficient of the term of\n    multi-degree i,j,k is contained in ``c[i,j,k]``. If `c` has dimension\n    greater than 3 the remaining indices enumerate multiple sets of\n    coefficients.\n\nReturns\n-------\nvalues : ndarray, compatible object\n    The values of the multidimension polynomial on points formed with\n    triples of corresponding values from `x`, `y`, and `z`.\n\nSee Also\n--------\nlagval, lagval2d, laggrid2d, laggrid3d\n\nNotes\n-----\n\n.. versionadded::1.7.0", "id": "f18933:m15"}
{"signature": "def lagval2d(x, y, c):", "body": "try:<EOL><INDENT>x, y = np.array((x, y), copy=<NUM_LIT:0>)<EOL><DEDENT>except:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>c = lagval(x, c)<EOL>c = lagval(y, c, tensor=False)<EOL>return c<EOL>", "docstring": "Evaluate a 2-D Laguerre series at points (x, y).\n\nThis function returns the values:\n\n.. math:: p(x,y) = \\\\sum_{i,j} c_{i,j} * L_i(x) * L_j(y)\n\nThe parameters `x` and `y` are converted to arrays only if they are\ntuples or a lists, otherwise they are treated as a scalars and they\nmust have the same shape after conversion. In either case, either `x`\nand `y` or their elements must support multiplication and addition both\nwith themselves and with the elements of `c`.\n\nIf `c` is a 1-D array a one is implicitly appended to its shape to make\nit 2-D. The shape of the result will be c.shape[2:] + x.shape.\n\nParameters\n----------\nx, y : array_like, compatible objects\n    The two dimensional series is evaluated at the points `(x, y)`,\n    where `x` and `y` must have the same shape. If `x` or `y` is a list\n    or tuple, it is first converted to an ndarray, otherwise it is left\n    unchanged and if it isn't an ndarray it is treated as a scalar.\nc : array_like\n    Array of coefficients ordered so that the coefficient of the term\n    of multi-degree i,j is contained in ``c[i,j]``. If `c` has\n    dimension greater than two the remaining indices enumerate multiple\n    sets of coefficients.\n\nReturns\n-------\nvalues : ndarray, compatible object\n    The values of the two dimensional polynomial at points formed with\n    pairs of corresponding values from `x` and `y`.\n\nSee Also\n--------\nlagval, laggrid2d, lagval3d, laggrid3d\n\nNotes\n-----\n\n.. versionadded::1.7.0", "id": "f18933:m13"}
{"signature": "def laggauss(deg):", "body": "ideg = int(deg)<EOL>if ideg != deg or ideg < <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>c = np.array([<NUM_LIT:0>]*deg + [<NUM_LIT:1>])<EOL>m = lagcompanion(c)<EOL>x = la.eigvals(m)<EOL>x.sort()<EOL>dy = lagval(x, c)<EOL>df = lagval(x, lagder(c))<EOL>x -= dy/df<EOL>fm = lagval(x, c[<NUM_LIT:1>:])<EOL>fm /= np.abs(fm).max()<EOL>df /= np.abs(df).max()<EOL>w = <NUM_LIT:1>/(fm * df)<EOL>w /= w.sum()<EOL>return x, w<EOL>", "docstring": "Gauss-Laguerre quadrature.\n\nComputes the sample points and weights for Gauss-Laguerre quadrature.\nThese sample points and weights will correctly integrate polynomials of\ndegree :math:`2*deg - 1` or less over the interval :math:`[0, \\inf]`\nwith the weight function :math:`f(x) = \\exp(-x)`.\n\nParameters\n----------\ndeg : int\n    Number of sample points and weights. It must be >= 1.\n\nReturns\n-------\nx : ndarray\n    1-D ndarray containing the sample points.\ny : ndarray\n    1-D ndarray containing the weights.\n\nNotes\n-----\n\n.. versionadded::1.7.0\n\nThe results have only been tested up to degree 100 higher degrees may\nbe problematic. The weights are determined by using the fact that\n\n.. math:: w_k = c / (L'_n(x_k) * L_{n-1}(x_k))\n\nwhere :math:`c` is a constant independent of :math:`k` and :math:`x_k`\nis the k'th root of :math:`L_n`, and then scaling the results to get\nthe right value when integrating 1.", "id": "f18933:m23"}
{"signature": "def lagval(x, c, tensor=True):", "body": "c = np.array(c, ndmin=<NUM_LIT:1>, copy=<NUM_LIT:0>)<EOL>if c.dtype.char in '<STR_LIT>':<EOL><INDENT>c = c.astype(np.double)<EOL><DEDENT>if isinstance(x, (tuple, list)):<EOL><INDENT>x = np.asarray(x)<EOL><DEDENT>if isinstance(x, np.ndarray) and tensor:<EOL><INDENT>c = c.reshape(c.shape + (<NUM_LIT:1>,)*x.ndim)<EOL><DEDENT>if len(c) == <NUM_LIT:1>:<EOL><INDENT>c0 = c[<NUM_LIT:0>]<EOL>c1 = <NUM_LIT:0><EOL><DEDENT>elif len(c) == <NUM_LIT:2>:<EOL><INDENT>c0 = c[<NUM_LIT:0>]<EOL>c1 = c[<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>nd = len(c)<EOL>c0 = c[-<NUM_LIT:2>]<EOL>c1 = c[-<NUM_LIT:1>]<EOL>for i in range(<NUM_LIT:3>, len(c) + <NUM_LIT:1>):<EOL><INDENT>tmp = c0<EOL>nd = nd - <NUM_LIT:1><EOL>c0 = c[-i] - (c1*(nd - <NUM_LIT:1>))/nd<EOL>c1 = tmp + (c1*((<NUM_LIT:2>*nd - <NUM_LIT:1>) - x))/nd<EOL><DEDENT><DEDENT>return c0 + c1*(<NUM_LIT:1> - x)<EOL>", "docstring": "Evaluate a Laguerre series at points x.\n\nIf `c` is of length `n + 1`, this function returns the value:\n\n.. math:: p(x) = c_0 * L_0(x) + c_1 * L_1(x) + ... + c_n * L_n(x)\n\nThe parameter `x` is converted to an array only if it is a tuple or a\nlist, otherwise it is treated as a scalar. In either case, either `x`\nor its elements must support multiplication and addition both with\nthemselves and with the elements of `c`.\n\nIf `c` is a 1-D array, then `p(x)` will have the same shape as `x`.  If\n`c` is multidimensional, then the shape of the result depends on the\nvalue of `tensor`. If `tensor` is true the shape will be c.shape[1:] +\nx.shape. If `tensor` is false the shape will be c.shape[1:]. Note that\nscalars have shape (,).\n\nTrailing zeros in the coefficients will be used in the evaluation, so\nthey should be avoided if efficiency is a concern.\n\nParameters\n----------\nx : array_like, compatible object\n    If `x` is a list or tuple, it is converted to an ndarray, otherwise\n    it is left unchanged and treated as a scalar. In either case, `x`\n    or its elements must support addition and multiplication with\n    with themselves and with the elements of `c`.\nc : array_like\n    Array of coefficients ordered so that the coefficients for terms of\n    degree n are contained in c[n]. If `c` is multidimensional the\n    remaining indices enumerate multiple polynomials. In the two\n    dimensional case the coefficients may be thought of as stored in\n    the columns of `c`.\ntensor : boolean, optional\n    If True, the shape of the coefficient array is extended with ones\n    on the right, one for each dimension of `x`. Scalars have dimension 0\n    for this action. The result is that every column of coefficients in\n    `c` is evaluated for every element of `x`. If False, `x` is broadcast\n    over the columns of `c` for the evaluation.  This keyword is useful\n    when `c` is multidimensional. The default value is True.\n\n    .. versionadded:: 1.7.0\n\nReturns\n-------\nvalues : ndarray, algebra_like\n    The shape of the return value is described above.\n\nSee Also\n--------\nlagval2d, laggrid2d, lagval3d, laggrid3d\n\nNotes\n-----\nThe evaluation uses Clenshaw recursion, aka synthetic division.\n\nExamples\n--------\n>>> from numpy.polynomial.laguerre import lagval\n>>> coef = [1,2,3]\n>>> lagval(1, coef)\n-0.5\n>>> lagval([[1,2],[3,4]], coef)\narray([[-0.5, -4. ],\n       [-4.5, -2. ]])", "id": "f18933:m12"}
{"signature": "def hermpow(c, pow, maxpower=<NUM_LIT:16>):", "body": "<EOL>[c] = pu.as_series([c])<EOL>power = int(pow)<EOL>if power != pow or power < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>elif maxpower is not None and power > maxpower:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>elif power == <NUM_LIT:0>:<EOL><INDENT>return np.array([<NUM_LIT:1>], dtype=c.dtype)<EOL><DEDENT>elif power == <NUM_LIT:1>:<EOL><INDENT>return c<EOL><DEDENT>else:<EOL><INDENT>prd = c<EOL>for i in range(<NUM_LIT:2>, power + <NUM_LIT:1>):<EOL><INDENT>prd = hermmul(prd, c)<EOL><DEDENT>return prd<EOL><DEDENT>", "docstring": "Raise a Hermite series to a power.\n\n    Returns the Hermite series `c` raised to the power `pow`. The\n    argument `c` is a sequence of coefficients ordered from low to high.\n    i.e., [1,2,3] is the series  ``P_0 + 2*P_1 + 3*P_2.``\n\n    Parameters\n    ----------\n    c : array_like\n        1-D array of Hermite series coefficients ordered from low to\n        high.\n    pow : integer\n        Power to which the series will be raised\n    maxpower : integer, optional\n        Maximum power allowed. This is mainly to limit growth of the series\n        to unmanageable size. Default is 16\n\n    Returns\n    -------\n    coef : ndarray\n        Hermite series of power.\n\n    See Also\n    --------\n    hermadd, hermsub, hermmul, hermdiv\n\n    Examples\n    --------\n    >>> from numpy.polynomial.hermite import hermpow\n    >>> hermpow([1, 2, 3], 2)\n    array([ 81.,  52.,  82.,  12.,   9.])", "id": "f18934:m9"}
{"signature": "def hermroots(c):", "body": "<EOL>[c] = pu.as_series([c])<EOL>if len(c) <= <NUM_LIT:1>:<EOL><INDENT>return np.array([], dtype=c.dtype)<EOL><DEDENT>if len(c) == <NUM_LIT:2>:<EOL><INDENT>return np.array([-<NUM_LIT>*c[<NUM_LIT:0>]/c[<NUM_LIT:1>]])<EOL><DEDENT>m = hermcompanion(c)<EOL>r = la.eigvals(m)<EOL>r.sort()<EOL>return r<EOL>", "docstring": "Compute the roots of a Hermite series.\n\nReturn the roots (a.k.a. \"zeros\") of the polynomial\n\n.. math:: p(x) = \\\\sum_i c[i] * H_i(x).\n\nParameters\n----------\nc : 1-D array_like\n    1-D array of coefficients.\n\nReturns\n-------\nout : ndarray\n    Array of the roots of the series. If all the roots are real,\n    then `out` is also real, otherwise it is complex.\n\nSee Also\n--------\npolyroots, legroots, lagroots, chebroots, hermeroots\n\nNotes\n-----\nThe root estimates are obtained as the eigenvalues of the companion\nmatrix, Roots far from the origin of the complex plane may have large\nerrors due to the numerical instability of the series for such\nvalues. Roots with multiplicity greater than 1 will also show larger\nerrors as the value of the series near such points is relatively\ninsensitive to errors in the roots. Isolated roots near the origin can\nbe improved by a few iterations of Newton's method.\n\nThe Hermite series basis polynomials aren't powers of `x` so the\nresults of this function may seem unintuitive.\n\nExamples\n--------\n>>> from numpy.polynomial.hermite import hermroots, hermfromroots\n>>> coef = hermfromroots([-1, 0, 1])\n>>> coef\narray([ 0.   ,  0.25 ,  0.   ,  0.125])\n>>> hermroots(coef)\narray([ -1.00000000e+00,  -1.38777878e-17,   1.00000000e+00])", "id": "f18934:m22"}
{"signature": "def hermvander3d(x, y, z, deg):", "body": "ideg = [int(d) for d in deg]<EOL>is_valid = [id == d and id >= <NUM_LIT:0> for id, d in zip(ideg, deg)]<EOL>if is_valid != [<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>]:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>degx, degy, degz = ideg<EOL>x, y, z = np.array((x, y, z), copy=<NUM_LIT:0>) + <NUM_LIT:0.0><EOL>vx = hermvander(x, degx)<EOL>vy = hermvander(y, degy)<EOL>vz = hermvander(z, degz)<EOL>v = vx[..., None, None]*vy[..., None,:, None]*vz[..., None, None,:]<EOL>return v.reshape(v.shape[:-<NUM_LIT:3>] + (-<NUM_LIT:1>,))<EOL>", "docstring": "Pseudo-Vandermonde matrix of given degrees.\n\n    Returns the pseudo-Vandermonde matrix of degrees `deg` and sample\n    points `(x, y, z)`. If `l, m, n` are the given degrees in `x, y, z`,\n    then The pseudo-Vandermonde matrix is defined by\n\n    .. math:: V[..., (m+1)(n+1)i + (n+1)j + k] = H_i(x)*H_j(y)*H_k(z),\n\n    where `0 <= i <= l`, `0 <= j <= m`, and `0 <= j <= n`.  The leading\n    indices of `V` index the points `(x, y, z)` and the last index encodes\n    the degrees of the Hermite polynomials.\n\n    If ``V = hermvander3d(x, y, z, [xdeg, ydeg, zdeg])``, then the columns\n    of `V` correspond to the elements of a 3-D coefficient array `c` of\n    shape (xdeg + 1, ydeg + 1, zdeg + 1) in the order\n\n    .. math:: c_{000}, c_{001}, c_{002},... , c_{010}, c_{011}, c_{012},...\n\n    and  ``np.dot(V, c.flat)`` and ``hermval3d(x, y, z, c)`` will be the\n    same up to roundoff. This equivalence is useful both for least squares\n    fitting and for the evaluation of a large number of 3-D Hermite\n    series of the same degrees and sample points.\n\n    Parameters\n    ----------\n    x, y, z : array_like\n        Arrays of point coordinates, all of the same shape. The dtypes will\n        be converted to either float64 or complex128 depending on whether\n        any of the elements are complex. Scalars are converted to 1-D\n        arrays.\n    deg : list of ints\n        List of maximum degrees of the form [x_deg, y_deg, z_deg].\n\n    Returns\n    -------\n    vander3d : ndarray\n        The shape of the returned matrix is ``x.shape + (order,)``, where\n        :math:`order = (deg[0]+1)*(deg([1]+1)*(deg[2]+1)`.  The dtype will\n        be the same as the converted `x`, `y`, and `z`.\n\n    See Also\n    --------\n    hermvander, hermvander3d. hermval2d, hermval3d\n\n    Notes\n    -----\n\n    .. versionadded::1.7.0", "id": "f18934:m19"}
{"signature": "def hermval(x, c, tensor=True):", "body": "c = np.array(c, ndmin=<NUM_LIT:1>, copy=<NUM_LIT:0>)<EOL>if c.dtype.char in '<STR_LIT>':<EOL><INDENT>c = c.astype(np.double)<EOL><DEDENT>if isinstance(x, (tuple, list)):<EOL><INDENT>x = np.asarray(x)<EOL><DEDENT>if isinstance(x, np.ndarray) and tensor:<EOL><INDENT>c = c.reshape(c.shape + (<NUM_LIT:1>,)*x.ndim)<EOL><DEDENT>x2 = x*<NUM_LIT:2><EOL>if len(c) == <NUM_LIT:1>:<EOL><INDENT>c0 = c[<NUM_LIT:0>]<EOL>c1 = <NUM_LIT:0><EOL><DEDENT>elif len(c) == <NUM_LIT:2>:<EOL><INDENT>c0 = c[<NUM_LIT:0>]<EOL>c1 = c[<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>nd = len(c)<EOL>c0 = c[-<NUM_LIT:2>]<EOL>c1 = c[-<NUM_LIT:1>]<EOL>for i in range(<NUM_LIT:3>, len(c) + <NUM_LIT:1>):<EOL><INDENT>tmp = c0<EOL>nd = nd - <NUM_LIT:1><EOL>c0 = c[-i] - c1*(<NUM_LIT:2>*(nd - <NUM_LIT:1>))<EOL>c1 = tmp + c1*x2<EOL><DEDENT><DEDENT>return c0 + c1*x2<EOL>", "docstring": "Evaluate an Hermite series at points x.\n\nIf `c` is of length `n + 1`, this function returns the value:\n\n.. math:: p(x) = c_0 * H_0(x) + c_1 * H_1(x) + ... + c_n * H_n(x)\n\nThe parameter `x` is converted to an array only if it is a tuple or a\nlist, otherwise it is treated as a scalar. In either case, either `x`\nor its elements must support multiplication and addition both with\nthemselves and with the elements of `c`.\n\nIf `c` is a 1-D array, then `p(x)` will have the same shape as `x`.  If\n`c` is multidimensional, then the shape of the result depends on the\nvalue of `tensor`. If `tensor` is true the shape will be c.shape[1:] +\nx.shape. If `tensor` is false the shape will be c.shape[1:]. Note that\nscalars have shape (,).\n\nTrailing zeros in the coefficients will be used in the evaluation, so\nthey should be avoided if efficiency is a concern.\n\nParameters\n----------\nx : array_like, compatible object\n    If `x` is a list or tuple, it is converted to an ndarray, otherwise\n    it is left unchanged and treated as a scalar. In either case, `x`\n    or its elements must support addition and multiplication with\n    with themselves and with the elements of `c`.\nc : array_like\n    Array of coefficients ordered so that the coefficients for terms of\n    degree n are contained in c[n]. If `c` is multidimensional the\n    remaining indices enumerate multiple polynomials. In the two\n    dimensional case the coefficients may be thought of as stored in\n    the columns of `c`.\ntensor : boolean, optional\n    If True, the shape of the coefficient array is extended with ones\n    on the right, one for each dimension of `x`. Scalars have dimension 0\n    for this action. The result is that every column of coefficients in\n    `c` is evaluated for every element of `x`. If False, `x` is broadcast\n    over the columns of `c` for the evaluation.  This keyword is useful\n    when `c` is multidimensional. The default value is True.\n\n    .. versionadded:: 1.7.0\n\nReturns\n-------\nvalues : ndarray, algebra_like\n    The shape of the return value is described above.\n\nSee Also\n--------\nhermval2d, hermgrid2d, hermval3d, hermgrid3d\n\nNotes\n-----\nThe evaluation uses Clenshaw recursion, aka synthetic division.\n\nExamples\n--------\n>>> from numpy.polynomial.hermite import hermval\n>>> coef = [1,2,3]\n>>> hermval(1, coef)\n11.0\n>>> hermval([[1,2],[3,4]], coef)\narray([[  11.,   51.],\n       [ 115.,  203.]])", "id": "f18934:m12"}
{"signature": "def hermder(c, m=<NUM_LIT:1>, scl=<NUM_LIT:1>, axis=<NUM_LIT:0>):", "body": "c = np.array(c, ndmin=<NUM_LIT:1>, copy=<NUM_LIT:1>)<EOL>if c.dtype.char in '<STR_LIT>':<EOL><INDENT>c = c.astype(np.double)<EOL><DEDENT>cnt, iaxis = [int(t) for t in [m, axis]]<EOL>if cnt != m:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if cnt < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if iaxis != axis:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not -c.ndim <= iaxis < c.ndim:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if iaxis < <NUM_LIT:0>:<EOL><INDENT>iaxis += c.ndim<EOL><DEDENT>if cnt == <NUM_LIT:0>:<EOL><INDENT>return c<EOL><DEDENT>c = np.rollaxis(c, iaxis)<EOL>n = len(c)<EOL>if cnt >= n:<EOL><INDENT>c = c[:<NUM_LIT:1>]*<NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>for i in range(cnt):<EOL><INDENT>n = n - <NUM_LIT:1><EOL>c *= scl<EOL>der = np.empty((n,) + c.shape[<NUM_LIT:1>:], dtype=c.dtype)<EOL>for j in range(n, <NUM_LIT:0>, -<NUM_LIT:1>):<EOL><INDENT>der[j - <NUM_LIT:1>] = (<NUM_LIT:2>*j)*c[j]<EOL><DEDENT>c = der<EOL><DEDENT><DEDENT>c = np.rollaxis(c, <NUM_LIT:0>, iaxis + <NUM_LIT:1>)<EOL>return c<EOL>", "docstring": "Differentiate a Hermite series.\n\nReturns the Hermite series coefficients `c` differentiated `m` times\nalong `axis`.  At each iteration the result is multiplied by `scl` (the\nscaling factor is for use in a linear change of variable). The argument\n`c` is an array of coefficients from low to high degree along each\naxis, e.g., [1,2,3] represents the series ``1*H_0 + 2*H_1 + 3*H_2``\nwhile [[1,2],[1,2]] represents ``1*H_0(x)*H_0(y) + 1*H_1(x)*H_0(y) +\n2*H_0(x)*H_1(y) + 2*H_1(x)*H_1(y)`` if axis=0 is ``x`` and axis=1 is\n``y``.\n\nParameters\n----------\nc : array_like\n    Array of Hermite series coefficients. If `c` is multidimensional the\n    different axis correspond to different variables with the degree in\n    each axis given by the corresponding index.\nm : int, optional\n    Number of derivatives taken, must be non-negative. (Default: 1)\nscl : scalar, optional\n    Each differentiation is multiplied by `scl`.  The end result is\n    multiplication by ``scl**m``.  This is for use in a linear change of\n    variable. (Default: 1)\naxis : int, optional\n    Axis over which the derivative is taken. (Default: 0).\n\n    .. versionadded:: 1.7.0\n\nReturns\n-------\nder : ndarray\n    Hermite series of the derivative.\n\nSee Also\n--------\nhermint\n\nNotes\n-----\nIn general, the result of differentiating a Hermite series does not\nresemble the same operation on a power series. Thus the result of this\nfunction may be \"unintuitive,\" albeit correct; see Examples section\nbelow.\n\nExamples\n--------\n>>> from numpy.polynomial.hermite import hermder\n>>> hermder([ 1. ,  0.5,  0.5,  0.5])\narray([ 1.,  2.,  3.])\n>>> hermder([-0.5,  1./2.,  1./8.,  1./12.,  1./16.], m=2)\narray([ 1.,  2.,  3.])", "id": "f18934:m10"}
{"signature": "def hermval3d(x, y, z, c):", "body": "try:<EOL><INDENT>x, y, z = np.array((x, y, z), copy=<NUM_LIT:0>)<EOL><DEDENT>except:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>c = hermval(x, c)<EOL>c = hermval(y, c, tensor=False)<EOL>c = hermval(z, c, tensor=False)<EOL>return c<EOL>", "docstring": "Evaluate a 3-D Hermite series at points (x, y, z).\n\nThis function returns the values:\n\n.. math:: p(x,y,z) = \\\\sum_{i,j,k} c_{i,j,k} * H_i(x) * H_j(y) * H_k(z)\n\nThe parameters `x`, `y`, and `z` are converted to arrays only if\nthey are tuples or a lists, otherwise they are treated as a scalars and\nthey must have the same shape after conversion. In either case, either\n`x`, `y`, and `z` or their elements must support multiplication and\naddition both with themselves and with the elements of `c`.\n\nIf `c` has fewer than 3 dimensions, ones are implicitly appended to its\nshape to make it 3-D. The shape of the result will be c.shape[3:] +\nx.shape.\n\nParameters\n----------\nx, y, z : array_like, compatible object\n    The three dimensional series is evaluated at the points\n    `(x, y, z)`, where `x`, `y`, and `z` must have the same shape.  If\n    any of `x`, `y`, or `z` is a list or tuple, it is first converted\n    to an ndarray, otherwise it is left unchanged and if it isn't an\n    ndarray it is  treated as a scalar.\nc : array_like\n    Array of coefficients ordered so that the coefficient of the term of\n    multi-degree i,j,k is contained in ``c[i,j,k]``. If `c` has dimension\n    greater than 3 the remaining indices enumerate multiple sets of\n    coefficients.\n\nReturns\n-------\nvalues : ndarray, compatible object\n    The values of the multidimensional polynomial on points formed with\n    triples of corresponding values from `x`, `y`, and `z`.\n\nSee Also\n--------\nhermval, hermval2d, hermgrid2d, hermgrid3d\n\nNotes\n-----\n\n.. versionadded::1.7.0", "id": "f18934:m15"}
{"signature": "def hermvander(x, deg):", "body": "ideg = int(deg)<EOL>if ideg != deg:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if ideg < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>x = np.array(x, copy=<NUM_LIT:0>, ndmin=<NUM_LIT:1>) + <NUM_LIT:0.0><EOL>dims = (ideg + <NUM_LIT:1>,) + x.shape<EOL>dtyp = x.dtype<EOL>v = np.empty(dims, dtype=dtyp)<EOL>v[<NUM_LIT:0>] = x*<NUM_LIT:0> + <NUM_LIT:1><EOL>if ideg > <NUM_LIT:0>:<EOL><INDENT>x2 = x*<NUM_LIT:2><EOL>v[<NUM_LIT:1>] = x2<EOL>for i in range(<NUM_LIT:2>, ideg + <NUM_LIT:1>):<EOL><INDENT>v[i] = (v[i-<NUM_LIT:1>]*x2 - v[i-<NUM_LIT:2>]*(<NUM_LIT:2>*(i - <NUM_LIT:1>)))<EOL><DEDENT><DEDENT>return np.rollaxis(v, <NUM_LIT:0>, v.ndim)<EOL>", "docstring": "Pseudo-Vandermonde matrix of given degree.\n\n    Returns the pseudo-Vandermonde matrix of degree `deg` and sample points\n    `x`. The pseudo-Vandermonde matrix is defined by\n\n    .. math:: V[..., i] = H_i(x),\n\n    where `0 <= i <= deg`. The leading indices of `V` index the elements of\n    `x` and the last index is the degree of the Hermite polynomial.\n\n    If `c` is a 1-D array of coefficients of length `n + 1` and `V` is the\n    array ``V = hermvander(x, n)``, then ``np.dot(V, c)`` and\n    ``hermval(x, c)`` are the same up to roundoff. This equivalence is\n    useful both for least squares fitting and for the evaluation of a large\n    number of Hermite series of the same degree and sample points.\n\n    Parameters\n    ----------\n    x : array_like\n        Array of points. The dtype is converted to float64 or complex128\n        depending on whether any of the elements are complex. If `x` is\n        scalar it is converted to a 1-D array.\n    deg : int\n        Degree of the resulting matrix.\n\n    Returns\n    -------\n    vander : ndarray\n        The pseudo-Vandermonde matrix. The shape of the returned matrix is\n        ``x.shape + (deg + 1,)``, where The last index is the degree of the\n        corresponding Hermite polynomial.  The dtype will be the same as\n        the converted `x`.\n\n    Examples\n    --------\n    >>> from numpy.polynomial.hermite import hermvander\n    >>> x = np.array([-1, 0, 1])\n    >>> hermvander(x, 3)\n    array([[ 1., -2.,  2.,  4.],\n           [ 1.,  0., -2., -0.],\n           [ 1.,  2.,  2., -4.]])", "id": "f18934:m17"}
{"signature": "def has_samewindow(self, other):", "body": "return np.all(self.window == other.window)<EOL>", "docstring": "Check if windows match.\n\n        .. versionadded:: 1.6.0\n\n        Parameters\n        ----------\n        other : class instance\n            The other class must have the ``window`` attribute.\n\n        Returns\n        -------\n        bool : boolean\n            True if the windows are the same, False otherwise.", "id": "f18935:c0:m17"}
{"signature": "@classmethod<EOL><INDENT>def fromroots(cls, roots, domain=[], window=None):<DEDENT>", "body": "[roots] = pu.as_series([roots], trim=False)<EOL>if domain is None:<EOL><INDENT>domain = pu.getdomain(roots)<EOL><DEDENT>elif type(domain) is list and len(domain) == <NUM_LIT:0>:<EOL><INDENT>domain = cls.domain<EOL><DEDENT>if window is None:<EOL><INDENT>window = cls.window<EOL><DEDENT>deg = len(roots)<EOL>off, scl = pu.mapparms(domain, window)<EOL>rnew = off + scl*roots<EOL>coef = cls._fromroots(rnew) / scl**deg<EOL>return cls(coef, domain=domain, window=window)<EOL>", "docstring": "Return series instance that has the specified roots.\n\n        Returns a series representing the product\n        ``(x - r[0])*(x - r[1])*...*(x - r[n-1])``, where ``r`` is a\n        list of roots.\n\n        Parameters\n        ----------\n        roots : array_like\n            List of roots.\n        domain : {[], None, array_like}, optional\n            Domain for the resulting series. If None the domain is the\n            interval from the smallest root to the largest. If [] the\n            domain is the class domain. The default is [].\n        window : {None, array_like}, optional\n            Window for the returned series. If None the class window is\n            used. The default is None.\n\n        Returns\n        -------\n        new_series : series\n            Series with the specified roots.", "id": "f18935:c0:m61"}
{"signature": "def mapparms(self):", "body": "return pu.mapparms(self.domain, self.window)<EOL>", "docstring": "Return the mapping parameters.\n\n        The returned values define a linear map ``off + scl*x`` that is\n        applied to the input arguments before the series is evaluated. The\n        map depends on the ``domain`` and ``window``; if the current\n        ``domain`` is equal to the ``window`` the resulting map is the\n        identity.  If the coefficients of the series instance are to be\n        used by themselves outside this class, then the linear function\n        must be substituted for the ``x`` in the standard representation of\n        the base polynomials.\n\n        Returns\n        -------\n        off, scl : float or complex\n            The mapping function is defined by ``off + scl*x``.\n\n        Notes\n        -----\n        If the current domain is the interval ``[l1, r1]`` and the window\n        is ``[l2, r2]``, then the linear mapping function ``L`` is\n        defined by the equations::\n\n            L(l1) = l2\n            L(r1) = r2", "id": "f18935:c0:m55"}
{"signature": "@classmethod<EOL><INDENT>def identity(cls, domain=None, window=None):<DEDENT>", "body": "if domain is None:<EOL><INDENT>domain = cls.domain<EOL><DEDENT>if window is None:<EOL><INDENT>window = cls.window<EOL><DEDENT>off, scl = pu.mapparms(window, domain)<EOL>coef = cls._line(off, scl)<EOL>return cls(coef, domain, window)<EOL>", "docstring": "Identity function.\n\n        If ``p`` is the returned series, then ``p(x) == x`` for all\n        values of x.\n\n        Parameters\n        ----------\n        domain : {None, array_like}, optional\n            If given, the array must be of the form ``[beg, end]``, where\n            ``beg`` and ``end`` are the endpoints of the domain. If None is\n            given then the class domain is used. The default is None.\n        window : {None, array_like}, optional\n            If given, the resulting array must be if the form\n            ``[beg, end]``, where ``beg`` and ``end`` are the endpoints of\n            the window. If None is given then the class window is used. The\n            default is None.\n\n        Returns\n        -------\n        new_series : series\n             Series of representing the identity.", "id": "f18935:c0:m62"}
{"signature": "def convert(self, domain=None, kind=None, window=None):", "body": "if kind is None:<EOL><INDENT>kind = self.__class__<EOL><DEDENT>if domain is None:<EOL><INDENT>domain = kind.domain<EOL><DEDENT>if window is None:<EOL><INDENT>window = kind.window<EOL><DEDENT>return self(kind.identity(domain, window=window))<EOL>", "docstring": "Convert series to a different kind and/or domain and/or window.\n\n        Parameters\n        ----------\n        domain : array_like, optional\n            The domain of the converted series. If the value is None,\n            the default domain of `kind` is used.\n        kind : class, optional\n            The polynomial series type class to which the current instance\n            should be converted. If kind is None, then the class of the\n            current instance is used.\n        window : array_like, optional\n            The window of the converted series. If the value is None,\n            the default window of `kind` is used.\n\n        Returns\n        -------\n        new_series : series\n            The returned class can be of different type than the current\n            instance and/or have a different domain and/or different\n            window.\n\n        Notes\n        -----\n        Conversion between domains and class types can result in\n        numerically ill defined series.\n\n        Examples\n        --------", "id": "f18935:c0:m54"}
{"signature": "def mapdomain(x, old, new):", "body": "x = np.asanyarray(x)<EOL>off, scl = mapparms(old, new)<EOL>return off + scl*x<EOL>", "docstring": "Apply linear map to input points.\n\nThe linear map ``offset + scale*x`` that maps the domain `old` to\nthe domain `new` is applied to the points `x`.\n\nParameters\n----------\nx : array_like\n    Points to be mapped. If `x` is a subtype of ndarray the subtype\n    will be preserved.\nold, new : array_like\n    The two domains that determine the map.  Each must (successfully)\n    convert to 1-d arrays containing precisely two values.\n\nReturns\n-------\nx_out : ndarray\n    Array of points of the same shape as `x`, after application of the\n    linear map between the two domains.\n\nSee Also\n--------\ngetdomain, mapparms\n\nNotes\n-----\nEffectively, this implements:\n\n.. math ::\n    x\\\\_out = new[0] + m(x - old[0])\n\nwhere\n\n.. math ::\n    m = \\\\frac{new[1]-new[0]}{old[1]-old[0]}\n\nExamples\n--------\n>>> from numpy import polynomial as P\n>>> old_domain = (-1,1)\n>>> new_domain = (0,2*np.pi)\n>>> x = np.linspace(-1,1,6); x\narray([-1. , -0.6, -0.2,  0.2,  0.6,  1. ])\n>>> x_out = P.mapdomain(x, old_domain, new_domain); x_out\narray([ 0.        ,  1.25663706,  2.51327412,  3.76991118,  5.02654825,\n        6.28318531])\n>>> x - P.mapdomain(x_out, new_domain, old_domain)\narray([ 0.,  0.,  0.,  0.,  0.,  0.])\n\nAlso works for complex numbers (and thus can be used to map any line in\nthe complex plane to any other line therein).\n\n>>> i = complex(0,1)\n>>> old = (-1 - i, 1 + i)\n>>> new = (-1 + i, 1 - i)\n>>> z = np.linspace(old[0], old[1], 6); z\narray([-1.0-1.j , -0.6-0.6j, -0.2-0.2j,  0.2+0.2j,  0.6+0.6j,  1.0+1.j ])\n>>> new_z = P.mapdomain(z, old, new); new_z\narray([-1.0+1.j , -0.6+0.6j, -0.2+0.2j,  0.2-0.2j,  0.6-0.6j,  1.0-1.j ])", "id": "f18936:m5"}
{"signature": "def mapparms(old, new):", "body": "oldlen = old[<NUM_LIT:1>] - old[<NUM_LIT:0>]<EOL>newlen = new[<NUM_LIT:1>] - new[<NUM_LIT:0>]<EOL>off = (old[<NUM_LIT:1>]*new[<NUM_LIT:0>] - old[<NUM_LIT:0>]*new[<NUM_LIT:1>])/oldlen<EOL>scl = newlen/oldlen<EOL>return off, scl<EOL>", "docstring": "Linear map parameters between domains.\n\nReturn the parameters of the linear map ``offset + scale*x`` that maps\n`old` to `new` such that ``old[i] -> new[i]``, ``i = 0, 1``.\n\nParameters\n----------\nold, new : array_like\n    Domains. Each domain must (successfully) convert to a 1-d array\n    containing precisely two values.\n\nReturns\n-------\noffset, scale : scalars\n    The map ``L(x) = offset + scale*x`` maps the first domain to the\n    second.\n\nSee Also\n--------\ngetdomain, mapdomain\n\nNotes\n-----\nAlso works for complex numbers, and thus can be used to calculate the\nparameters required to map any line in the complex plane to any other\nline therein.\n\nExamples\n--------\n>>> from numpy import polynomial as P\n>>> P.mapparms((-1,1),(-1,1))\n(0.0, 1.0)\n>>> P.mapparms((1,-1),(-1,1))\n(0.0, -1.0)\n>>> i = complex(0,1)\n>>> P.mapparms((-i,-1),(1,i))\n((1+1j), (1+0j))", "id": "f18936:m4"}
{"signature": "def sign2map(a, var):", "body": "global lcb_map, cb_map<EOL>out_a = a<EOL>if isintent_out(var):<EOL><INDENT>for k in var['<STR_LIT>']:<EOL><INDENT>if k[:<NUM_LIT:4>]=='<STR_LIT>':<EOL><INDENT>out_a = k[<NUM_LIT:4>:]<EOL>break<EOL><DEDENT><DEDENT><DEDENT>ret={'<STR_LIT>':a,'<STR_LIT>':out_a}<EOL>ret['<STR_LIT>']=getctype(var)<EOL>intent_flags = []<EOL>for f, s in isintent_dict.items():<EOL><INDENT>if f(var): intent_flags.append('<STR_LIT>'%s)<EOL><DEDENT>if intent_flags:<EOL><INDENT>ret['<STR_LIT>'] = '<STR_LIT:|>'.join(intent_flags)<EOL><DEDENT>else:<EOL><INDENT>ret['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>if isarray(var): ret['<STR_LIT>']='<STR_LIT:N>'<EOL>elif ret['<STR_LIT>'] in c2buildvalue_map:<EOL><INDENT>ret['<STR_LIT>']=c2buildvalue_map[ret['<STR_LIT>']]<EOL><DEDENT>else: ret['<STR_LIT>']='<STR_LIT:O>'<EOL>ret['<STR_LIT>'], ret['<STR_LIT>']=getinit(a, var)<EOL>if hasinitvalue(var) and iscomplex(var) and not isarray(var):<EOL><INDENT>ret['<STR_LIT>'], ret['<STR_LIT>'] = markoutercomma(ret['<STR_LIT>'][<NUM_LIT:1>:-<NUM_LIT:1>]).split('<STR_LIT>')<EOL><DEDENT>if isexternal(var):<EOL><INDENT>ret['<STR_LIT>']=a<EOL>if a in lcb_map:<EOL><INDENT>ret['<STR_LIT>']=lcb_map[a]<EOL>ret['<STR_LIT>']=lcb2_map[lcb_map[a]]['<STR_LIT>']<EOL>ret['<STR_LIT>']=lcb2_map[lcb_map[a]]['<STR_LIT>']<EOL>ret['<STR_LIT>']=lcb2_map[lcb_map[a]]['<STR_LIT>']<EOL>ret['<STR_LIT>']=lcb2_map[lcb_map[a]]['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>ret['<STR_LIT>']=a<EOL>errmess('<STR_LIT>'%(a, list(lcb_map.keys())))<EOL><DEDENT><DEDENT>if isstring(var):<EOL><INDENT>ret['<STR_LIT>']=getstrlength(var)<EOL><DEDENT>if isarray(var):<EOL><INDENT>ret=dictappend(ret, getarrdims(a, var))<EOL>dim=copy.copy(var['<STR_LIT>'])<EOL><DEDENT>if ret['<STR_LIT>'] in c2capi_map:<EOL><INDENT>ret['<STR_LIT>']=c2capi_map[ret['<STR_LIT>']]<EOL><DEDENT>if debugcapi(var):<EOL><INDENT>il=[isintent_in, '<STR_LIT:input>', isintent_out, '<STR_LIT>',<EOL>isintent_inout, '<STR_LIT>', isrequired, '<STR_LIT>',<EOL>isoptional, '<STR_LIT>', isintent_hide, '<STR_LIT>',<EOL>iscomplex, '<STR_LIT>',<EOL>l_and(isscalar, l_not(iscomplex)), '<STR_LIT>',<EOL>isstring, '<STR_LIT:string>', isarray, '<STR_LIT>',<EOL>iscomplexarray, '<STR_LIT>', isstringarray, '<STR_LIT>',<EOL>iscomplexfunction, '<STR_LIT>',<EOL>l_and(isfunction, l_not(iscomplexfunction)), '<STR_LIT>',<EOL>isexternal, '<STR_LIT>',<EOL>isintent_callback, '<STR_LIT>',<EOL>isintent_aux, '<STR_LIT>',<EOL>]<EOL>rl=[]<EOL>for i in range(<NUM_LIT:0>, len(il), <NUM_LIT:2>):<EOL><INDENT>if il[i](var): rl.append(il[i+<NUM_LIT:1>])<EOL><DEDENT>if isstring(var):<EOL><INDENT>rl.append('<STR_LIT>'%(a, ret['<STR_LIT>']))<EOL><DEDENT>if isarray(var):<EOL><INDENT>if not isintent_c(var):<EOL><INDENT>var['<STR_LIT>'].reverse()<EOL>", "docstring": "varname,ctype,atype\ninit,init.r,init.i,pytype\nvardebuginfo,vardebugshowvalue,varshowvalue\nvarrfromat\nintent", "id": "f18959:m6"}
{"signature": "def solve(a, b):", "body": "a, _ = _makearray(a)<EOL>_assertRankAtLeast2(a)<EOL>_assertNdSquareness(a)<EOL>b, wrap = _makearray(b)<EOL>t, result_t = _commonType(a, b)<EOL>if b.ndim == a.ndim - <NUM_LIT:1>:<EOL><INDENT>if a.shape[-<NUM_LIT:1>] == <NUM_LIT:0> and b.shape[-<NUM_LIT:1>] == <NUM_LIT:0>:<EOL><INDENT>a = a.reshape(a.shape[:-<NUM_LIT:1>])<EOL>bc = broadcast(a, b)<EOL>return wrap(empty(bc.shape, dtype=result_t))<EOL><DEDENT>gufunc = _umath_linalg.solve1<EOL><DEDENT>else:<EOL><INDENT>if b.size == <NUM_LIT:0>:<EOL><INDENT>if (a.shape[-<NUM_LIT:1>] == <NUM_LIT:0> and b.shape[-<NUM_LIT:2>] == <NUM_LIT:0>) or b.shape[-<NUM_LIT:1>] == <NUM_LIT:0>:<EOL><INDENT>a = a[:,:<NUM_LIT:1>].reshape(a.shape[:-<NUM_LIT:1>] + (<NUM_LIT:1>,))<EOL>bc = broadcast(a, b)<EOL>return wrap(empty(bc.shape, dtype=result_t))<EOL><DEDENT><DEDENT>gufunc = _umath_linalg.solve<EOL><DEDENT>signature = '<STR_LIT>' if isComplexType(t) else '<STR_LIT>'<EOL>extobj = get_linalg_error_extobj(_raise_linalgerror_singular)<EOL>r = gufunc(a, b, signature=signature, extobj=extobj)<EOL>return wrap(r.astype(result_t))<EOL>", "docstring": "Solve a linear matrix equation, or system of linear scalar equations.\n\nComputes the \"exact\" solution, `x`, of the well-determined, i.e., full\nrank, linear matrix equation `ax = b`.\n\nParameters\n----------\na : (..., M, M) array_like\n    Coefficient matrix.\nb : {(..., M,), (..., M, K)}, array_like\n    Ordinate or \"dependent variable\" values.\n\nReturns\n-------\nx : {(..., M,), (..., M, K)} ndarray\n    Solution to the system a x = b.  Returned shape is identical to `b`.\n\nRaises\n------\nLinAlgError\n    If `a` is singular or not square.\n\nNotes\n-----\nBroadcasting rules apply, see the `numpy.linalg` documentation for\ndetails.\n\nThe solutions are computed using LAPACK routine _gesv\n\n`a` must be square and of full-rank, i.e., all rows (or, equivalently,\ncolumns) must be linearly independent; if either is not true, use\n`lstsq` for the least-squares best \"solution\" of the\nsystem/equation.\n\nReferences\n----------\n.. [1] G. Strang, *Linear Algebra and Its Applications*, 2nd Ed., Orlando,\n       FL, Academic Press, Inc., 1980, pg. 22.\n\nExamples\n--------\nSolve the system of equations ``3 * x0 + x1 = 9`` and ``x0 + 2 * x1 = 8``:\n\n>>> a = np.array([[3,1], [1,2]])\n>>> b = np.array([9,8])\n>>> x = np.linalg.solve(a, b)\n>>> x\narray([ 2.,  3.])\n\nCheck that the solution is correct:\n\n>>> np.allclose(np.dot(a, x), b)\nTrue", "id": "f18969:m21"}
{"signature": "def tensorinv(a, ind=<NUM_LIT:2>):", "body": "a = asarray(a)<EOL>oldshape = a.shape<EOL>prod = <NUM_LIT:1><EOL>if ind > <NUM_LIT:0>:<EOL><INDENT>invshape = oldshape[ind:] + oldshape[:ind]<EOL>for k in oldshape[ind:]:<EOL><INDENT>prod *= k<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>a = a.reshape(prod, -<NUM_LIT:1>)<EOL>ia = inv(a)<EOL>return ia.reshape(*invshape)<EOL>", "docstring": "Compute the 'inverse' of an N-dimensional array.\n\nThe result is an inverse for `a` relative to the tensordot operation\n``tensordot(a, b, ind)``, i. e., up to floating-point accuracy,\n``tensordot(tensorinv(a), a, ind)`` is the \"identity\" tensor for the\ntensordot operation.\n\nParameters\n----------\na : array_like\n    Tensor to 'invert'. Its shape must be 'square', i. e.,\n    ``prod(a.shape[:ind]) == prod(a.shape[ind:])``.\nind : int, optional\n    Number of first indices that are involved in the inverse sum.\n    Must be a positive integer, default is 2.\n\nReturns\n-------\nb : ndarray\n    `a`'s tensordot inverse, shape ``a.shape[ind:] + a.shape[:ind]``.\n\nRaises\n------\nLinAlgError\n    If `a` is singular or not 'square' (in the above sense).\n\nSee Also\n--------\ntensordot, tensorsolve\n\nExamples\n--------\n>>> a = np.eye(4*6)\n>>> a.shape = (4, 6, 8, 3)\n>>> ainv = np.linalg.tensorinv(a, ind=2)\n>>> ainv.shape\n(8, 3, 4, 6)\n>>> b = np.random.randn(4, 6)\n>>> np.allclose(np.tensordot(ainv, b), np.linalg.tensorsolve(a, b))\nTrue\n\n>>> a = np.eye(4*6)\n>>> a.shape = (24, 8, 3)\n>>> ainv = np.linalg.tensorinv(a, ind=1)\n>>> ainv.shape\n(8, 3, 24)\n>>> b = np.random.randn(24)\n>>> np.allclose(np.tensordot(ainv, b, 1), np.linalg.tensorsolve(a, b))\nTrue", "id": "f18969:m22"}
{"signature": "def eigvalsh(a, UPLO='<STR_LIT:L>'):", "body": "UPLO = UPLO.upper()<EOL>if UPLO not in ('<STR_LIT:L>', '<STR_LIT>'):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>extobj = get_linalg_error_extobj(<EOL>_raise_linalgerror_eigenvalues_nonconvergence)<EOL>if UPLO == '<STR_LIT:L>':<EOL><INDENT>gufunc = _umath_linalg.eigvalsh_lo<EOL><DEDENT>else:<EOL><INDENT>gufunc = _umath_linalg.eigvalsh_up<EOL><DEDENT>a, wrap = _makearray(a)<EOL>_assertNoEmpty2d(a)<EOL>_assertRankAtLeast2(a)<EOL>_assertNdSquareness(a)<EOL>t, result_t = _commonType(a)<EOL>signature = '<STR_LIT>' if isComplexType(t) else '<STR_LIT>'<EOL>w = gufunc(a, signature=signature, extobj=extobj)<EOL>return w.astype(_realType(result_t))<EOL>", "docstring": "Compute the eigenvalues of a Hermitian or real symmetric matrix.\n\nMain difference from eigh: the eigenvectors are not computed.\n\nParameters\n----------\na : (..., M, M) array_like\n    A complex- or real-valued matrix whose eigenvalues are to be\n    computed.\nUPLO : {'L', 'U'}, optional\n    Same as `lower`, with 'L' for lower and 'U' for upper triangular.\n    Deprecated.\n\nReturns\n-------\nw : (..., M,) ndarray\n    The eigenvalues, not necessarily ordered, each repeated according to\n    its multiplicity.\n\nRaises\n------\nLinAlgError\n    If the eigenvalue computation does not converge.\n\nSee Also\n--------\neigh : eigenvalues and eigenvectors of symmetric/Hermitian arrays.\neigvals : eigenvalues of general real or complex arrays.\neig : eigenvalues and right eigenvectors of general real or complex\n      arrays.\n\nNotes\n-----\nBroadcasting rules apply, see the `numpy.linalg` documentation for\ndetails.\n\nThe eigenvalues are computed using LAPACK routines _ssyevd, _heevd\n\nExamples\n--------\n>>> from numpy import linalg as LA\n>>> a = np.array([[1, -2j], [2j, 5]])\n>>> LA.eigvalsh(a)\narray([ 0.17157288+0.j,  5.82842712+0.j])", "id": "f18969:m27"}
{"signature": "def eigh(a, UPLO='<STR_LIT:L>'):", "body": "UPLO = UPLO.upper()<EOL>if UPLO not in ('<STR_LIT:L>', '<STR_LIT>'):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>a, wrap = _makearray(a)<EOL>_assertRankAtLeast2(a)<EOL>_assertNdSquareness(a)<EOL>t, result_t = _commonType(a)<EOL>extobj = get_linalg_error_extobj(<EOL>_raise_linalgerror_eigenvalues_nonconvergence)<EOL>if UPLO == '<STR_LIT:L>':<EOL><INDENT>gufunc = _umath_linalg.eigh_lo<EOL><DEDENT>else:<EOL><INDENT>gufunc = _umath_linalg.eigh_up<EOL><DEDENT>signature = '<STR_LIT>' if isComplexType(t) else '<STR_LIT>'<EOL>w, vt = gufunc(a, signature=signature, extobj=extobj)<EOL>w = w.astype(_realType(result_t))<EOL>vt = vt.astype(result_t)<EOL>return w, wrap(vt)<EOL>", "docstring": "Return the eigenvalues and eigenvectors of a Hermitian or symmetric matrix.\n\nReturns two objects, a 1-D array containing the eigenvalues of `a`, and\na 2-D square array or matrix (depending on the input type) of the\ncorresponding eigenvectors (in columns).\n\nParameters\n----------\nA : (..., M, M) array\n    Hermitian/Symmetric matrices whose eigenvalues and\n    eigenvectors are to be computed.\nUPLO : {'L', 'U'}, optional\n    Specifies whether the calculation is done with the lower triangular\n    part of `a` ('L', default) or the upper triangular part ('U').\n\nReturns\n-------\nw : (..., M) ndarray\n    The eigenvalues, not necessarily ordered.\nv : {(..., M, M) ndarray, (..., M, M) matrix}\n    The column ``v[:, i]`` is the normalized eigenvector corresponding\n    to the eigenvalue ``w[i]``.  Will return a matrix object if `a` is\n    a matrix object.\n\nRaises\n------\nLinAlgError\n    If the eigenvalue computation does not converge.\n\nSee Also\n--------\neigvalsh : eigenvalues of symmetric or Hermitian arrays.\neig : eigenvalues and right eigenvectors for non-symmetric arrays.\neigvals : eigenvalues of non-symmetric arrays.\n\nNotes\n-----\nBroadcasting rules apply, see the `numpy.linalg` documentation for\ndetails.\n\nThe eigenvalues/eigenvectors are computed using LAPACK routines _ssyevd,\n_heevd\n\nThe eigenvalues of real symmetric or complex Hermitian matrices are\nalways real. [1]_ The array `v` of (column) eigenvectors is unitary\nand `a`, `w`, and `v` satisfy the equations\n``dot(a, v[:, i]) = w[i] * v[:, i]``.\n\nReferences\n----------\n.. [1] G. Strang, *Linear Algebra and Its Applications*, 2nd Ed., Orlando,\n       FL, Academic Press, Inc., 1980, pg. 222.\n\nExamples\n--------\n>>> from numpy import linalg as LA\n>>> a = np.array([[1, -2j], [2j, 5]])\n>>> a\narray([[ 1.+0.j,  0.-2.j],\n       [ 0.+2.j,  5.+0.j]])\n>>> w, v = LA.eigh(a)\n>>> w; v\narray([ 0.17157288,  5.82842712])\narray([[-0.92387953+0.j        , -0.38268343+0.j        ],\n       [ 0.00000000+0.38268343j,  0.00000000-0.92387953j]])\n\n>>> np.dot(a, v[:, 0]) - w[0] * v[:, 0] # verify 1st e-val/vec pair\narray([2.77555756e-17 + 0.j, 0. + 1.38777878e-16j])\n>>> np.dot(a, v[:, 1]) - w[1] * v[:, 1] # verify 2nd e-val/vec pair\narray([ 0.+0.j,  0.+0.j])\n\n>>> A = np.matrix(a) # what happens if input is a matrix object\n>>> A\nmatrix([[ 1.+0.j,  0.-2.j],\n        [ 0.+2.j,  5.+0.j]])\n>>> w, v = LA.eigh(A)\n>>> w; v\narray([ 0.17157288,  5.82842712])\nmatrix([[-0.92387953+0.j        , -0.38268343+0.j        ],\n        [ 0.00000000+0.38268343j,  0.00000000-0.92387953j]])", "id": "f18969:m30"}
{"signature": "def inv(a):", "body": "a, wrap = _makearray(a)<EOL>_assertRankAtLeast2(a)<EOL>_assertNdSquareness(a)<EOL>t, result_t = _commonType(a)<EOL>if a.shape[-<NUM_LIT:1>] == <NUM_LIT:0>:<EOL><INDENT>return wrap(empty_like(a, dtype=result_t))<EOL><DEDENT>signature = '<STR_LIT>' if isComplexType(t) else '<STR_LIT>'<EOL>extobj = get_linalg_error_extobj(_raise_linalgerror_singular)<EOL>ainv = _umath_linalg.inv(a, signature=signature, extobj=extobj)<EOL>return wrap(ainv.astype(result_t))<EOL>", "docstring": "Compute the (multiplicative) inverse of a matrix.\n\nGiven a square matrix `a`, return the matrix `ainv` satisfying\n``dot(a, ainv) = dot(ainv, a) = eye(a.shape[0])``.\n\nParameters\n----------\na : (..., M, M) array_like\n    Matrix to be inverted.\n\nReturns\n-------\nainv : (..., M, M) ndarray or matrix\n    (Multiplicative) inverse of the matrix `a`.\n\nRaises\n------\nLinAlgError\n    If `a` is not square or inversion fails.\n\nNotes\n-----\nBroadcasting rules apply, see the `numpy.linalg` documentation for\ndetails.\n\nExamples\n--------\n>>> from numpy.linalg import inv\n>>> a = np.array([[1., 2.], [3., 4.]])\n>>> ainv = inv(a)\n>>> np.allclose(np.dot(a, ainv), np.eye(2))\nTrue\n>>> np.allclose(np.dot(ainv, a), np.eye(2))\nTrue\n\nIf a is a matrix object, then the return value is a matrix as well:\n\n>>> ainv = inv(np.matrix(a))\n>>> ainv\nmatrix([[-2. ,  1. ],\n        [ 1.5, -0.5]])\n\nInverses of several matrices can be computed at once:\n\n>>> a = np.array([[[1., 2.], [3., 4.]], [[1, 3], [3, 5]]])\n>>> inv(a)\narray([[[-2. ,  1. ],\n        [ 1.5, -0.5]],\n       [[-5. ,  2. ],\n        [ 3. , -1. ]]])", "id": "f18969:m23"}
{"signature": "def norm(x, ord=None, axis=None):", "body": "x = asarray(x)<EOL>if ord is None and axis is None:<EOL><INDENT>x = x.ravel(order='<STR_LIT>')<EOL>if isComplexType(x.dtype.type):<EOL><INDENT>sqnorm = dot(x.real, x.real) + dot(x.imag, x.imag)<EOL><DEDENT>else:<EOL><INDENT>sqnorm = dot(x, x)<EOL><DEDENT>return sqrt(sqnorm)<EOL><DEDENT>nd = x.ndim<EOL>if axis is None:<EOL><INDENT>axis = tuple(range(nd))<EOL><DEDENT>elif not isinstance(axis, tuple):<EOL><INDENT>axis = (axis,)<EOL><DEDENT>if len(axis) == <NUM_LIT:1>:<EOL><INDENT>if ord == Inf:<EOL><INDENT>return abs(x).max(axis=axis)<EOL><DEDENT>elif ord == -Inf:<EOL><INDENT>return abs(x).min(axis=axis)<EOL><DEDENT>elif ord == <NUM_LIT:0>:<EOL><INDENT>return (x != <NUM_LIT:0>).sum(axis=axis)<EOL><DEDENT>elif ord == <NUM_LIT:1>:<EOL><INDENT>return add.reduce(abs(x), axis=axis)<EOL><DEDENT>elif ord is None or ord == <NUM_LIT:2>:<EOL><INDENT>s = (x.conj() * x).real<EOL>return sqrt(add.reduce(s, axis=axis))<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>ord + <NUM_LIT:1><EOL><DEDENT>except TypeError:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if x.dtype.type is longdouble:<EOL><INDENT>absx = abs(x)<EOL><DEDENT>else:<EOL><INDENT>absx = x if isComplexType(x.dtype.type) else asfarray(x)<EOL>if absx.dtype is x.dtype:<EOL><INDENT>absx = abs(absx)<EOL><DEDENT>else:<EOL><INDENT>abs(absx, out=absx)<EOL><DEDENT><DEDENT>absx **= ord<EOL>return add.reduce(absx, axis=axis) ** (<NUM_LIT:1.0> / ord)<EOL><DEDENT><DEDENT>elif len(axis) == <NUM_LIT:2>:<EOL><INDENT>row_axis, col_axis = axis<EOL>if not (-nd <= row_axis < nd and -nd <= col_axis < nd):<EOL><INDENT>raise ValueError('<STR_LIT>' %<EOL>(axis, x.shape))<EOL><DEDENT>if row_axis % nd == col_axis % nd:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if ord == <NUM_LIT:2>:<EOL><INDENT>return _multi_svd_norm(x, row_axis, col_axis, amax)<EOL><DEDENT>elif ord == -<NUM_LIT:2>:<EOL><INDENT>return _multi_svd_norm(x, row_axis, col_axis, amin)<EOL><DEDENT>elif ord == <NUM_LIT:1>:<EOL><INDENT>if col_axis > row_axis:<EOL><INDENT>col_axis -= <NUM_LIT:1><EOL><DEDENT>return add.reduce(abs(x), axis=row_axis).max(axis=col_axis)<EOL><DEDENT>elif ord == Inf:<EOL><INDENT>if row_axis > col_axis:<EOL><INDENT>row_axis -= <NUM_LIT:1><EOL><DEDENT>return add.reduce(abs(x), axis=col_axis).max(axis=row_axis)<EOL><DEDENT>elif ord == -<NUM_LIT:1>:<EOL><INDENT>if col_axis > row_axis:<EOL><INDENT>col_axis -= <NUM_LIT:1><EOL><DEDENT>return add.reduce(abs(x), axis=row_axis).min(axis=col_axis)<EOL><DEDENT>elif ord == -Inf:<EOL><INDENT>if row_axis > col_axis:<EOL><INDENT>row_axis -= <NUM_LIT:1><EOL><DEDENT>return add.reduce(abs(x), axis=col_axis).min(axis=row_axis)<EOL><DEDENT>elif ord in [None, '<STR_LIT>', '<STR_LIT:f>']:<EOL><INDENT>return sqrt(add.reduce((x.conj() * x).real, axis=axis))<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Matrix or vector norm.\n\nThis function is able to return one of seven different matrix norms,\nor one of an infinite number of vector norms (described below), depending\non the value of the ``ord`` parameter.\n\nParameters\n----------\nx : array_like\n    Input array.  If `axis` is None, `x` must be 1-D or 2-D.\nord : {non-zero int, inf, -inf, 'fro'}, optional\n    Order of the norm (see table under ``Notes``). inf means numpy's\n    `inf` object.\naxis : {int, 2-tuple of ints, None}, optional\n    If `axis` is an integer, it specifies the axis of `x` along which to\n    compute the vector norms.  If `axis` is a 2-tuple, it specifies the\n    axes that hold 2-D matrices, and the matrix norms of these matrices\n    are computed.  If `axis` is None then either a vector norm (when `x`\n    is 1-D) or a matrix norm (when `x` is 2-D) is returned.\n\nReturns\n-------\nn : float or ndarray\n    Norm of the matrix or vector(s).\n\nNotes\n-----\nFor values of ``ord <= 0``, the result is, strictly speaking, not a\nmathematical 'norm', but it may still be useful for various numerical\npurposes.\n\nThe following norms can be calculated:\n\n=====  ============================  ==========================\nord    norm for matrices             norm for vectors\n=====  ============================  ==========================\nNone   Frobenius norm                2-norm\n'fro'  Frobenius norm                --\ninf    max(sum(abs(x), axis=1))      max(abs(x))\n-inf   min(sum(abs(x), axis=1))      min(abs(x))\n0      --                            sum(x != 0)\n1      max(sum(abs(x), axis=0))      as below\n-1     min(sum(abs(x), axis=0))      as below\n2      2-norm (largest sing. value)  as below\n-2     smallest singular value       as below\nother  --                            sum(abs(x)**ord)**(1./ord)\n=====  ============================  ==========================\n\nThe Frobenius norm is given by [1]_:\n\n    :math:`||A||_F = [\\\\sum_{i,j} abs(a_{i,j})^2]^{1/2}`\n\nReferences\n----------\n.. [1] G. H. Golub and C. F. Van Loan, *Matrix Computations*,\n       Baltimore, MD, Johns Hopkins University Press, 1985, pg. 15\n\nExamples\n--------\n>>> from numpy import linalg as LA\n>>> a = np.arange(9) - 4\n>>> a\narray([-4, -3, -2, -1,  0,  1,  2,  3,  4])\n>>> b = a.reshape((3, 3))\n>>> b\narray([[-4, -3, -2],\n       [-1,  0,  1],\n       [ 2,  3,  4]])\n\n>>> LA.norm(a)\n7.745966692414834\n>>> LA.norm(b)\n7.745966692414834\n>>> LA.norm(b, 'fro')\n7.745966692414834\n>>> LA.norm(a, np.inf)\n4\n>>> LA.norm(b, np.inf)\n9\n>>> LA.norm(a, -np.inf)\n0\n>>> LA.norm(b, -np.inf)\n2\n\n>>> LA.norm(a, 1)\n20\n>>> LA.norm(b, 1)\n7\n>>> LA.norm(a, -1)\n-4.6566128774142013e-010\n>>> LA.norm(b, -1)\n6\n>>> LA.norm(a, 2)\n7.745966692414834\n>>> LA.norm(b, 2)\n7.3484692283495345\n\n>>> LA.norm(a, -2)\nnan\n>>> LA.norm(b, -2)\n1.8570331885190563e-016\n>>> LA.norm(a, 3)\n5.8480354764257312\n>>> LA.norm(a, -3)\nnan\n\nUsing the `axis` argument to compute vector norms:\n\n>>> c = np.array([[ 1, 2, 3],\n...               [-1, 1, 4]])\n>>> LA.norm(c, axis=0)\narray([ 1.41421356,  2.23606798,  5.        ])\n>>> LA.norm(c, axis=1)\narray([ 3.74165739,  4.24264069])\n>>> LA.norm(c, ord=1, axis=1)\narray([6, 6])\n\nUsing the `axis` argument to compute matrix norms:\n\n>>> m = np.arange(8).reshape(2,2,2)\n>>> LA.norm(m, axis=(1,2))\narray([  3.74165739,  11.22497216])\n>>> LA.norm(m[0, :, :]), LA.norm(m[1, :, :])\n(3.7416573867739413, 11.224972160321824)", "id": "f18969:m39"}
{"signature": "def tensorsolve(a, b, axes=None):", "body": "a, wrap = _makearray(a)<EOL>b = asarray(b)<EOL>an = a.ndim<EOL>if axes is not None:<EOL><INDENT>allaxes = list(range(<NUM_LIT:0>, an))<EOL>for k in axes:<EOL><INDENT>allaxes.remove(k)<EOL>allaxes.insert(an, k)<EOL><DEDENT>a = a.transpose(allaxes)<EOL><DEDENT>oldshape = a.shape[-(an-b.ndim):]<EOL>prod = <NUM_LIT:1><EOL>for k in oldshape:<EOL><INDENT>prod *= k<EOL><DEDENT>a = a.reshape(-<NUM_LIT:1>, prod)<EOL>b = b.ravel()<EOL>res = wrap(solve(a, b))<EOL>res.shape = oldshape<EOL>return res<EOL>", "docstring": "Solve the tensor equation ``a x = b`` for x.\n\nIt is assumed that all indices of `x` are summed over in the product,\ntogether with the rightmost indices of `a`, as is done in, for example,\n``tensordot(a, x, axes=len(b.shape))``.\n\nParameters\n----------\na : array_like\n    Coefficient tensor, of shape ``b.shape + Q``. `Q`, a tuple, equals\n    the shape of that sub-tensor of `a` consisting of the appropriate\n    number of its rightmost indices, and must be such that\n   ``prod(Q) == prod(b.shape)`` (in which sense `a` is said to be\n   'square').\nb : array_like\n    Right-hand tensor, which can be of any shape.\naxes : tuple of ints, optional\n    Axes in `a` to reorder to the right, before inversion.\n    If None (default), no reordering is done.\n\nReturns\n-------\nx : ndarray, shape Q\n\nRaises\n------\nLinAlgError\n    If `a` is singular or not 'square' (in the above sense).\n\nSee Also\n--------\ntensordot, tensorinv, einsum\n\nExamples\n--------\n>>> a = np.eye(2*3*4)\n>>> a.shape = (2*3, 4, 2, 3, 4)\n>>> b = np.random.randn(2*3, 4)\n>>> x = np.linalg.tensorsolve(a, b)\n>>> x.shape\n(2, 3, 4)\n>>> np.allclose(np.tensordot(a, x, axes=3), b)\nTrue", "id": "f18969:m20"}
{"signature": "def ismethod(object):", "body": "return isinstance(object, types.MethodType)<EOL>", "docstring": "Return true if the object is an instance method.\n\n    Instance method objects provide these attributes:\n        __doc__         documentation string\n        __name__        name with which this method was defined\n        im_class        class object in which this method belongs\n        im_func         function object containing implementation of method\n        im_self         instance to which this method is bound, or None", "id": "f18980:m0"}
{"signature": "def formatargspec(args, varargs=None, varkw=None, defaults=None,<EOL>formatarg=str,<EOL>formatvarargs=lambda name: '<STR_LIT:*>' + name,<EOL>formatvarkw=lambda name: '<STR_LIT>' + name,<EOL>formatvalue=lambda value: '<STR_LIT:=>' + repr(value),<EOL>join=joinseq):", "body": "specs = []<EOL>if defaults:<EOL><INDENT>firstdefault = len(args) - len(defaults)<EOL><DEDENT>for i in range(len(args)):<EOL><INDENT>spec = strseq(args[i], formatarg, join)<EOL>if defaults and i >= firstdefault:<EOL><INDENT>spec = spec + formatvalue(defaults[i - firstdefault])<EOL><DEDENT>specs.append(spec)<EOL><DEDENT>if varargs is not None:<EOL><INDENT>specs.append(formatvarargs(varargs))<EOL><DEDENT>if varkw is not None:<EOL><INDENT>specs.append(formatvarkw(varkw))<EOL><DEDENT>return '<STR_LIT:(>' + '<STR_LIT:U+002CU+0020>'.join(specs) + '<STR_LIT:)>'<EOL>", "docstring": "Format an argument spec from the 4 values returned by getargspec.\n\n    The first four arguments are (args, varargs, varkw, defaults).  The\n    other four arguments are the corresponding optional formatting functions\n    that are called to turn names and values into strings.  The ninth\n    argument is an optional function to format the sequence of arguments.", "id": "f18980:m8"}
{"signature": "def strseq(object, convert, join=joinseq):", "body": "if type(object) in [list, tuple]:<EOL><INDENT>return join([strseq(_o, convert, join) for _o in object])<EOL><DEDENT>else:<EOL><INDENT>return convert(object)<EOL><DEDENT>", "docstring": "Recursively walk a sequence, stringifying each element.", "id": "f18980:m7"}
{"signature": "def getargvalues(frame):", "body": "args, varargs, varkw = getargs(frame.f_code)<EOL>return args, varargs, varkw, frame.f_locals<EOL>", "docstring": "Get information about arguments passed into a particular frame.\n\n    A tuple of four things is returned: (args, varargs, varkw, locals).\n    'args' is a list of the argument names (it may contain nested lists).\n    'varargs' and 'varkw' are the names of the * and ** arguments or None.\n    'locals' is the locals dictionary of the given frame.", "id": "f18980:m5"}
{"signature": "def ediff1d(arr, to_end=None, to_begin=None):", "body": "arr = ma.asanyarray(arr).flat<EOL>ed = arr[<NUM_LIT:1>:] - arr[:-<NUM_LIT:1>]<EOL>arrays = [ed]<EOL>if to_begin is not None:<EOL><INDENT>arrays.insert(<NUM_LIT:0>, to_begin)<EOL><DEDENT>if to_end is not None:<EOL><INDENT>arrays.append(to_end)<EOL><DEDENT>if len(arrays) != <NUM_LIT:1>:<EOL><INDENT>ed = hstack(arrays)<EOL><DEDENT>return ed<EOL>", "docstring": "Compute the differences between consecutive elements of an array.\n\nThis function is the equivalent of `numpy.ediff1d` that takes masked\nvalues into account, see `numpy.ediff1d` for details.\n\nSee Also\n--------\nnumpy.ediff1d : Equivalent function for ndarrays.", "id": "f18989:m16"}
{"signature": "def _ezclump(mask):", "body": "<EOL>if mask.ndim > <NUM_LIT:1>:<EOL><INDENT>mask = mask.ravel()<EOL><DEDENT>idx = (mask[<NUM_LIT:1>:] ^ mask[:-<NUM_LIT:1>]).nonzero()<EOL>idx = idx[<NUM_LIT:0>] + <NUM_LIT:1><EOL>slices = [slice(left, right)<EOL>for (left, right) in zip(itertools.chain([<NUM_LIT:0>], idx),<EOL>itertools.chain(idx, [len(mask)]),)]<EOL>return slices<EOL>", "docstring": "Finds the clumps (groups of data with the same values) for a 1D bool array.\n\nReturns a series of slices.", "id": "f18989:m30"}
{"signature": "def corrcoef(x, y=None, rowvar=True, bias=False, allow_masked=True, ddof=None):", "body": "<EOL>if ddof is not None and ddof != int(ddof):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if ddof is None:<EOL><INDENT>if bias:<EOL><INDENT>ddof = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>ddof = <NUM_LIT:1><EOL><DEDENT><DEDENT>(x, xnotmask, rowvar) = _covhelper(x, y, rowvar, allow_masked)<EOL>if not rowvar:<EOL><INDENT>fact = np.dot(xnotmask.T, xnotmask) * <NUM_LIT:1.> - ddof<EOL>c = (dot(x.T, x.conj(), strict=False) / fact).squeeze()<EOL><DEDENT>else:<EOL><INDENT>fact = np.dot(xnotmask, xnotmask.T) * <NUM_LIT:1.> - ddof<EOL>c = (dot(x, x.T.conj(), strict=False) / fact).squeeze()<EOL><DEDENT>try:<EOL><INDENT>diag = ma.diagonal(c)<EOL><DEDENT>except ValueError:<EOL><INDENT>return <NUM_LIT:1><EOL><DEDENT>if xnotmask.all():<EOL><INDENT>_denom = ma.sqrt(ma.multiply.outer(diag, diag))<EOL><DEDENT>else:<EOL><INDENT>_denom = diagflat(diag)<EOL>n = x.shape[<NUM_LIT:1> - rowvar]<EOL>if rowvar:<EOL><INDENT>for i in range(n - <NUM_LIT:1>):<EOL><INDENT>for j in range(i + <NUM_LIT:1>, n):<EOL><INDENT>_x = mask_cols(vstack((x[i], x[j]))).var(axis=<NUM_LIT:1>, ddof=ddof)<EOL>_denom[i, j] = _denom[j, i] = ma.sqrt(ma.multiply.reduce(_x))<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for i in range(n - <NUM_LIT:1>):<EOL><INDENT>for j in range(i + <NUM_LIT:1>, n):<EOL><INDENT>_x = mask_cols(<EOL>vstack((x[:, i], x[:, j]))).var(axis=<NUM_LIT:1>, ddof=ddof)<EOL>_denom[i, j] = _denom[j, i] = ma.sqrt(ma.multiply.reduce(_x))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>return c / _denom<EOL>", "docstring": "Return correlation coefficients of the input array.\n\nExcept for the handling of missing data this function does the same as\n`numpy.corrcoef`. For more details and examples, see `numpy.corrcoef`.\n\nParameters\n----------\nx : array_like\n    A 1-D or 2-D array containing multiple variables and observations.\n    Each row of `x` represents a variable, and each column a single\n    observation of all those variables. Also see `rowvar` below.\ny : array_like, optional\n    An additional set of variables and observations. `y` has the same\n    shape as `x`.\nrowvar : bool, optional\n    If `rowvar` is True (default), then each row represents a\n    variable, with observations in the columns. Otherwise, the relationship\n    is transposed: each column represents a variable, while the rows\n    contain observations.\nbias : bool, optional\n    Default normalization (False) is by ``(N-1)``, where ``N`` is the\n    number of observations given (unbiased estimate). If `bias` is 1,\n    then normalization is by ``N``. This keyword can be overridden by\n    the keyword ``ddof`` in numpy versions >= 1.5.\nallow_masked : bool, optional\n    If True, masked values are propagated pair-wise: if a value is masked\n    in `x`, the corresponding value is masked in `y`.\n    If False, raises an exception.\nddof : {None, int}, optional\n    .. versionadded:: 1.5\n    If not ``None`` normalization is by ``(N - ddof)``, where ``N`` is\n    the number of observations; this overrides the value implied by\n    ``bias``. The default value is ``None``.\n\nSee Also\n--------\nnumpy.corrcoef : Equivalent function in top-level NumPy module.\ncov : Estimate the covariance matrix.", "id": "f18989:m25"}
{"signature": "def cov(x, y=None, rowvar=True, bias=False, allow_masked=True, ddof=None):", "body": "<EOL>if ddof is not None and ddof != int(ddof):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if ddof is None:<EOL><INDENT>if bias:<EOL><INDENT>ddof = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>ddof = <NUM_LIT:1><EOL><DEDENT><DEDENT>(x, xnotmask, rowvar) = _covhelper(x, y, rowvar, allow_masked)<EOL>if not rowvar:<EOL><INDENT>fact = np.dot(xnotmask.T, xnotmask) * <NUM_LIT:1.> - ddof<EOL>result = (dot(x.T, x.conj(), strict=False) / fact).squeeze()<EOL><DEDENT>else:<EOL><INDENT>fact = np.dot(xnotmask, xnotmask.T) * <NUM_LIT:1.> - ddof<EOL>result = (dot(x, x.T.conj(), strict=False) / fact).squeeze()<EOL><DEDENT>return result<EOL>", "docstring": "Estimate the covariance matrix.\n\nExcept for the handling of missing data this function does the same as\n`numpy.cov`. For more details and examples, see `numpy.cov`.\n\nBy default, masked values are recognized as such. If `x` and `y` have the\nsame shape, a common mask is allocated: if ``x[i,j]`` is masked, then\n``y[i,j]`` will also be masked.\nSetting `allow_masked` to False will raise an exception if values are\nmissing in either of the input arrays.\n\nParameters\n----------\nx : array_like\n    A 1-D or 2-D array containing multiple variables and observations.\n    Each row of `x` represents a variable, and each column a single\n    observation of all those variables. Also see `rowvar` below.\ny : array_like, optional\n    An additional set of variables and observations. `y` has the same\n    form as `x`.\nrowvar : bool, optional\n    If `rowvar` is True (default), then each row represents a\n    variable, with observations in the columns. Otherwise, the relationship\n    is transposed: each column represents a variable, while the rows\n    contain observations.\nbias : bool, optional\n    Default normalization (False) is by ``(N-1)``, where ``N`` is the\n    number of observations given (unbiased estimate). If `bias` is True,\n    then normalization is by ``N``. This keyword can be overridden by\n    the keyword ``ddof`` in numpy versions >= 1.5.\nallow_masked : bool, optional\n    If True, masked values are propagated pair-wise: if a value is masked\n    in `x`, the corresponding value is masked in `y`.\n    If False, raises a `ValueError` exception when some values are missing.\nddof : {None, int}, optional\n    .. versionadded:: 1.5\n    If not ``None`` normalization is by ``(N - ddof)``, where ``N`` is\n    the number of observations; this overrides the value implied by\n    ``bias``. The default value is ``None``.\n\n\nRaises\n------\nValueError\n    Raised if some values are missing and `allow_masked` is False.\n\nSee Also\n--------\nnumpy.cov", "id": "f18989:m24"}
{"signature": "def compress_rowcols(x, axis=None):", "body": "x = asarray(x)<EOL>if x.ndim != <NUM_LIT:2>:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\")<EOL><DEDENT>m = getmask(x)<EOL>if m is nomask or not m.any():<EOL><INDENT>return x._data<EOL><DEDENT>if m.all():<EOL><INDENT>return nxarray([])<EOL><DEDENT>(idxr, idxc) = (list(range(len(x))), list(range(x.shape[<NUM_LIT:1>])))<EOL>masked = m.nonzero()<EOL>if not axis:<EOL><INDENT>for i in np.unique(masked[<NUM_LIT:0>]):<EOL><INDENT>idxr.remove(i)<EOL><DEDENT><DEDENT>if axis in [None, <NUM_LIT:1>, -<NUM_LIT:1>]:<EOL><INDENT>for j in np.unique(masked[<NUM_LIT:1>]):<EOL><INDENT>idxc.remove(j)<EOL><DEDENT><DEDENT>return x._data[idxr][:, idxc]<EOL>", "docstring": "Suppress the rows and/or columns of a 2-D array that contain\nmasked values.\n\nThe suppression behavior is selected with the `axis` parameter.\n\n- If axis is None, both rows and columns are suppressed.\n- If axis is 0, only rows are suppressed.\n- If axis is 1 or -1, only columns are suppressed.\n\nParameters\n----------\naxis : int, optional\n    Axis along which to perform the operation. Default is None.\n\nReturns\n-------\ncompressed_array : ndarray\n    The compressed array.\n\nExamples\n--------\n>>> x = np.ma.array(np.arange(9).reshape(3, 3), mask=[[1, 0, 0],\n...                                                   [1, 0, 0],\n...                                                   [0, 0, 0]])\n>>> x\nmasked_array(data =\n [[-- 1 2]\n [-- 4 5]\n [6 7 8]],\n             mask =\n [[ True False False]\n [ True False False]\n [False False False]],\n       fill_value = 999999)\n\n>>> np.ma.extras.compress_rowcols(x)\narray([[7, 8]])\n>>> np.ma.extras.compress_rowcols(x, 0)\narray([[6, 7, 8]])\n>>> np.ma.extras.compress_rowcols(x, 1)\narray([[1, 2],\n       [4, 5],\n       [7, 8]])", "id": "f18989:m9"}
{"signature": "def average(a, axis=None, weights=None, returned=False):", "body": "a = asarray(a)<EOL>mask = a.mask<EOL>ash = a.shape<EOL>if ash == ():<EOL><INDENT>ash = (<NUM_LIT:1>,)<EOL><DEDENT>if axis is None:<EOL><INDENT>if mask is nomask:<EOL><INDENT>if weights is None:<EOL><INDENT>n = a.sum(axis=None)<EOL>d = float(a.size)<EOL><DEDENT>else:<EOL><INDENT>w = filled(weights, <NUM_LIT:0.0>).ravel()<EOL>n = umath.add.reduce(a._data.ravel() * w)<EOL>d = umath.add.reduce(w)<EOL>del w<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if weights is None:<EOL><INDENT>n = a.filled(<NUM_LIT:0>).sum(axis=None)<EOL>d = float(umath.add.reduce((~mask).ravel()))<EOL><DEDENT>else:<EOL><INDENT>w = array(filled(weights, <NUM_LIT:0.0>), float, mask=mask).ravel()<EOL>n = add.reduce(a.ravel() * w)<EOL>d = add.reduce(w)<EOL>del w<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if mask is nomask:<EOL><INDENT>if weights is None:<EOL><INDENT>d = ash[axis] * <NUM_LIT:1.0><EOL>n = add.reduce(a._data, axis)<EOL><DEDENT>else:<EOL><INDENT>w = filled(weights, <NUM_LIT:0.0>)<EOL>wsh = w.shape<EOL>if wsh == ():<EOL><INDENT>wsh = (<NUM_LIT:1>,)<EOL><DEDENT>if wsh == ash:<EOL><INDENT>w = np.array(w, float, copy=<NUM_LIT:0>)<EOL>n = add.reduce(a * w, axis)<EOL>d = add.reduce(w, axis)<EOL>del w<EOL><DEDENT>elif wsh == (ash[axis],):<EOL><INDENT>ni = ash[axis]<EOL>r = [None] * len(ash)<EOL>r[axis] = slice(None, None, <NUM_LIT:1>)<EOL>w = eval (\"<STR_LIT>\" + repr(tuple(r)) + \"<STR_LIT>\")<EOL>n = add.reduce(a * w, axis)<EOL>d = add.reduce(w, axis, dtype=float)<EOL>del w, r<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if weights is None:<EOL><INDENT>n = add.reduce(a, axis)<EOL>d = umath.add.reduce((~mask), axis=axis, dtype=float)<EOL><DEDENT>else:<EOL><INDENT>w = filled(weights, <NUM_LIT:0.0>)<EOL>wsh = w.shape<EOL>if wsh == ():<EOL><INDENT>wsh = (<NUM_LIT:1>,)<EOL><DEDENT>if wsh == ash:<EOL><INDENT>w = array(w, dtype=float, mask=mask, copy=<NUM_LIT:0>)<EOL>n = add.reduce(a * w, axis)<EOL>d = add.reduce(w, axis, dtype=float)<EOL><DEDENT>elif wsh == (ash[axis],):<EOL><INDENT>ni = ash[axis]<EOL>r = [None] * len(ash)<EOL>r[axis] = slice(None, None, <NUM_LIT:1>)<EOL>w = eval (\"<STR_LIT>\" + repr(tuple(r)) +\"<STR_LIT>\")<EOL>n = add.reduce(a * w, axis)<EOL>d = add.reduce(w, axis, dtype=float)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>del w<EOL><DEDENT><DEDENT><DEDENT>if n is masked or d is masked:<EOL><INDENT>return masked<EOL><DEDENT>result = n / d<EOL>del n<EOL>if isinstance(result, MaskedArray):<EOL><INDENT>if ((axis is None) or (axis == <NUM_LIT:0> and a.ndim == <NUM_LIT:1>)) and(result.mask is nomask):<EOL><INDENT>result = result._data<EOL><DEDENT>if returned:<EOL><INDENT>if not isinstance(d, MaskedArray):<EOL><INDENT>d = masked_array(d)<EOL><DEDENT>if isinstance(d, ndarray) and (not d.shape == result.shape):<EOL><INDENT>d = ones(result.shape, dtype=float) * d<EOL><DEDENT><DEDENT><DEDENT>if returned:<EOL><INDENT>return result, d<EOL><DEDENT>else:<EOL><INDENT>return result<EOL><DEDENT>", "docstring": "Return the weighted average of array over the given axis.\n\nParameters\n----------\na : array_like\n    Data to be averaged.\n    Masked entries are not taken into account in the computation.\naxis : int, optional\n    Axis along which the average is computed. The default is to compute\n    the average of the flattened array.\nweights : array_like, optional\n    The importance that each element has in the computation of the average.\n    The weights array can either be 1-D (in which case its length must be\n    the size of `a` along the given axis) or of the same shape as `a`.\n    If ``weights=None``, then all data in `a` are assumed to have a\n    weight equal to one.   If `weights` is complex, the imaginary parts\n    are ignored.\nreturned : bool, optional\n    Flag indicating whether a tuple ``(result, sum of weights)``\n    should be returned as output (True), or just the result (False).\n    Default is False.\n\nReturns\n-------\naverage, [sum_of_weights] : (tuple of) scalar or MaskedArray\n    The average along the specified axis. When returned is `True`,\n    return a tuple with the average as the first element and the sum\n    of the weights as the second element. The return type is `np.float64`\n    if `a` is of integer type, otherwise it is of the same type as `a`.\n    If returned, `sum_of_weights` is of the same type as `average`.\n\nExamples\n--------\n>>> a = np.ma.array([1., 2., 3., 4.], mask=[False, False, True, True])\n>>> np.ma.average(a, weights=[3, 1, 0, 0])\n1.25\n\n>>> x = np.ma.arange(6.).reshape(3, 2)\n>>> print x\n[[ 0.  1.]\n [ 2.  3.]\n [ 4.  5.]]\n>>> avg, sumweights = np.ma.average(x, axis=0, weights=[1, 2, 3],\n...                                 returned=True)\n>>> print avg\n[2.66666666667 3.66666666667]", "id": "f18989:m7"}
{"signature": "def masked_all_like(arr):", "body": "a = np.empty_like(arr).view(MaskedArray)<EOL>a._mask = np.ones(a.shape, dtype=make_mask_descr(a.dtype))<EOL>return a<EOL>", "docstring": "Empty masked array with the properties of an existing array.\n\nReturn an empty masked array of the same shape and dtype as\nthe array `arr`, where all the data are masked.\n\nParameters\n----------\narr : ndarray\n    An array describing the shape and dtype of the required MaskedArray.\n\nReturns\n-------\na : MaskedArray\n    A masked array with all data masked.\n\nRaises\n------\nAttributeError\n    If `arr` doesn't have a shape attribute (i.e. not an ndarray)\n\nSee Also\n--------\nmasked_all : Empty masked array with all elements masked.\n\nExamples\n--------\n>>> import numpy.ma as ma\n>>> arr = np.zeros((2, 3), dtype=np.float32)\n>>> arr\narray([[ 0.,  0.,  0.],\n       [ 0.,  0.,  0.]], dtype=float32)\n>>> ma.masked_all_like(arr)\nmasked_array(data =\n [[-- -- --]\n [-- -- --]],\n      mask =\n [[ True  True  True]\n [ True  True  True]],\n      fill_value=1e+20)\n\nThe dtype of the masked array matches the dtype of `arr`.\n\n>>> arr.dtype\ndtype('float32')\n>>> ma.masked_all_like(arr).dtype\ndtype('float32')", "id": "f18989:m3"}
{"signature": "def setxor1d(ar1, ar2, assume_unique=False):", "body": "if not assume_unique:<EOL><INDENT>ar1 = unique(ar1)<EOL>ar2 = unique(ar2)<EOL><DEDENT>aux = ma.concatenate((ar1, ar2))<EOL>if aux.size == <NUM_LIT:0>:<EOL><INDENT>return aux<EOL><DEDENT>aux.sort()<EOL>auxf = aux.filled()<EOL><INDENT>flag = ediff1d( aux, to_end = <NUM_LIT:1>, to_begin = <NUM_LIT:1> ) == <NUM_LIT:0><EOL><DEDENT>flag = ma.concatenate(([True], (auxf[<NUM_LIT:1>:] != auxf[:-<NUM_LIT:1>]), [True]))<EOL><INDENT>flag2 = ediff1d( flag ) == <NUM_LIT:0><EOL><DEDENT>flag2 = (flag[<NUM_LIT:1>:] == flag[:-<NUM_LIT:1>])<EOL>return aux[flag2]<EOL>", "docstring": "Set exclusive-or of 1-D arrays with unique elements.\n\nThe output is always a masked array. See `numpy.setxor1d` for more details.\n\nSee Also\n--------\nnumpy.setxor1d : Equivalent function for ndarrays.", "id": "f18989:m19"}
{"signature": "def compress_cols(a):", "body": "return compress_rowcols(a, <NUM_LIT:1>)<EOL>", "docstring": "Suppress whole columns of a 2-D array that contain masked values.\n\nThis is equivalent to ``np.ma.extras.compress_rowcols(a, 1)``, see\n`extras.compress_rowcols` for details.\n\nSee Also\n--------\nextras.compress_rowcols", "id": "f18989:m11"}
{"signature": "def getdoc(self):", "body": "npfunc = getattr(np, self.__name__, None)<EOL>doc = getattr(npfunc, '<STR_LIT>', None)<EOL>if doc:<EOL><INDENT>sig = self.__name__ + ma.get_object_signature(npfunc)<EOL>locdoc = \"<STR_LIT>\"\"<STR_LIT>\"<EOL>return '<STR_LIT:\\n>'.join((sig, doc, locdoc))<EOL><DEDENT>return<EOL>", "docstring": "Retrieve the docstring and signature from the function.\n\nThe ``__doc__`` attribute of the function is used as the docstring for\nthe new masked array version of the function. A note on application\nof the function to the mask is appended.\n\n.. warning::\n  If the function docstring already contained a Notes section, the\n  new docstring will have two Notes sections instead of appending a note\n  to the existing section.\n\nParameters\n----------\nNone", "id": "f18989:c0:m1"}
{"signature": "def mask_cols(a, axis=None):", "body": "return mask_rowcols(a, <NUM_LIT:1>)<EOL>", "docstring": "Mask columns of a 2D array that contain masked values.\n\nThis function is a shortcut to ``mask_rowcols`` with `axis` equal to 1.\n\nSee Also\n--------\nmask_rowcols : Mask rows and/or columns of a 2D array.\nmasked_where : Mask where a condition is met.\n\nExamples\n--------\n>>> import numpy.ma as ma\n>>> a = np.zeros((3, 3), dtype=np.int)\n>>> a[1, 1] = 1\n>>> a\narray([[0, 0, 0],\n       [0, 1, 0],\n       [0, 0, 0]])\n>>> a = ma.masked_equal(a, 1)\n>>> a\nmasked_array(data =\n [[0 0 0]\n [0 -- 0]\n [0 0 0]],\n      mask =\n [[False False False]\n [False  True False]\n [False False False]],\n      fill_value=999999)\n>>> ma.mask_cols(a)\nmasked_array(data =\n [[0 -- 0]\n [0 -- 0]\n [0 -- 0]],\n      mask =\n [[False  True False]\n [False  True False]\n [False  True False]],\n      fill_value=999999)", "id": "f18989:m14"}
{"signature": "def masked_all(shape, dtype=float):", "body": "a = masked_array(np.empty(shape, dtype),<EOL>mask=np.ones(shape, make_mask_descr(dtype)))<EOL>return a<EOL>", "docstring": "Empty masked array with all elements masked.\n\nReturn an empty masked array of the given shape and dtype, where all the\ndata are masked.\n\nParameters\n----------\nshape : tuple\n    Shape of the required MaskedArray.\ndtype : dtype, optional\n    Data type of the output.\n\nReturns\n-------\na : MaskedArray\n    A masked array with all data masked.\n\nSee Also\n--------\nmasked_all_like : Empty masked array modelled on an existing array.\n\nExamples\n--------\n>>> import numpy.ma as ma\n>>> ma.masked_all((3, 3))\nmasked_array(data =\n [[-- -- --]\n [-- -- --]\n [-- -- --]],\n      mask =\n [[ True  True  True]\n [ True  True  True]\n [ True  True  True]],\n      fill_value=1e+20)\n\nThe `dtype` parameter defines the underlying data type.\n\n>>> a = ma.masked_all((3, 3))\n>>> a.dtype\ndtype('float64')\n>>> a = ma.masked_all((3, 3), dtype=np.int32)\n>>> a.dtype\ndtype('int32')", "id": "f18989:m2"}
{"signature": "def _checknames(descr, names=None):", "body": "ndescr = len(descr)<EOL>default_names = ['<STR_LIT>' % i for i in range(ndescr)]<EOL>if names is None:<EOL><INDENT>new_names = default_names<EOL><DEDENT>else:<EOL><INDENT>if isinstance(names, (tuple, list)):<EOL><INDENT>new_names = names<EOL><DEDENT>elif isinstance(names, str):<EOL><INDENT>new_names = names.split('<STR_LIT:U+002C>')<EOL><DEDENT>else:<EOL><INDENT>raise NameError(\"<STR_LIT>\" % repr(names))<EOL><DEDENT>nnames = len(new_names)<EOL>if nnames < ndescr:<EOL><INDENT>new_names += default_names[nnames:]<EOL><DEDENT><DEDENT>ndescr = []<EOL>for (n, d, t) in zip(new_names, default_names, descr.descr):<EOL><INDENT>if n in reserved_fields:<EOL><INDENT>if t[<NUM_LIT:0>] in reserved_fields:<EOL><INDENT>ndescr.append((d, t[<NUM_LIT:1>]))<EOL><DEDENT>else:<EOL><INDENT>ndescr.append(t)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>ndescr.append((n, t[<NUM_LIT:1>]))<EOL><DEDENT><DEDENT>return np.dtype(ndescr)<EOL>", "docstring": "Checks that the field names of the descriptor ``descr`` are not some\nreserved keywords. If this is the case, a default 'f%i' is substituted.\nIf the argument `names` is not None, updates the field names to valid names.", "id": "f18990:m1"}
{"signature": "def harden_mask(self):", "body": "self._hardmask = True<EOL>", "docstring": "Forces the mask to hard", "id": "f18990:c0:m12"}
{"signature": "def fromrecords(reclist, dtype=None, shape=None, formats=None, names=None,<EOL>titles=None, aligned=False, byteorder=None,<EOL>fill_value=None, mask=nomask):", "body": "<EOL>_mask = getattr(reclist, '<STR_LIT>', None)<EOL>try:<EOL><INDENT>nfields = len(reclist[<NUM_LIT:0>])<EOL><DEDENT>except TypeError:<EOL><INDENT>nfields = len(reclist[<NUM_LIT:0>].dtype)<EOL><DEDENT>if isinstance(reclist, ndarray):<EOL><INDENT>if isinstance(reclist, MaskedArray):<EOL><INDENT>reclist = reclist.filled().view(ndarray)<EOL><DEDENT>if dtype is None:<EOL><INDENT>dtype = reclist.dtype<EOL><DEDENT>reclist = reclist.tolist()<EOL><DEDENT>mrec = recfromrecords(reclist, dtype=dtype, shape=shape, formats=formats,<EOL>names=names, titles=titles,<EOL>aligned=aligned, byteorder=byteorder).view(mrecarray)<EOL>if fill_value is not None:<EOL><INDENT>mrec.fill_value = fill_value<EOL><DEDENT>if mask is not nomask:<EOL><INDENT>mask = np.array(mask, copy=False)<EOL>maskrecordlength = len(mask.dtype)<EOL>if maskrecordlength:<EOL><INDENT>mrec._mask.flat = mask<EOL><DEDENT>elif len(mask.shape) == <NUM_LIT:2>:<EOL><INDENT>mrec._mask.flat = [tuple(m) for m in mask]<EOL><DEDENT>else:<EOL><INDENT>mrec.__setmask__(mask)<EOL><DEDENT><DEDENT>if _mask is not None:<EOL><INDENT>mrec._mask[:] = _mask<EOL><DEDENT>return mrec<EOL>", "docstring": "Creates a MaskedRecords from a list of records.\n\n    Parameters\n    ----------\n    reclist : sequence\n        A list of records. Each element of the sequence is first converted\n        to a masked array if needed. If a 2D array is passed as argument, it is\n        processed line by line\n    dtype : {None, dtype}, optional\n        Data type descriptor.\n    shape : {None,int}, optional\n        Number of records. If None, ``shape`` is defined from the shape of the\n        first array in the list.\n    formats : {None, sequence}, optional\n        Sequence of formats for each individual field. If None, the formats will\n        be autodetected by inspecting the fields and selecting the highest dtype\n        possible.\n    names : {None, sequence}, optional\n        Sequence of the names of each field.\n    fill_value : {None, sequence}, optional\n        Sequence of data to be used as filling values.\n    mask : {nomask, sequence}, optional.\n        External mask to apply on the data.\n\n    Notes\n    -----\n    Lists of tuples should be preferred over lists of lists for faster processing.", "id": "f18990:m5"}
{"signature": "def __str__(self):", "body": "if self.size > <NUM_LIT:1>:<EOL><INDENT>mstr = [\"<STR_LIT>\" % \"<STR_LIT:U+002C>\".join([str(i) for i in s])<EOL>for s in zip(*[getattr(self, f) for f in self.dtype.names])]<EOL>return \"<STR_LIT>\" % \"<STR_LIT:U+002CU+0020>\".join(mstr)<EOL><DEDENT>else:<EOL><INDENT>mstr = [\"<STR_LIT:%s>\" % \"<STR_LIT:U+002C>\".join([str(i) for i in s])<EOL>for s in zip([getattr(self, f) for f in self.dtype.names])]<EOL>return \"<STR_LIT>\" % \"<STR_LIT:U+002CU+0020>\".join(mstr)<EOL><DEDENT>", "docstring": "Calculates the string representation.", "id": "f18990:c0:m9"}
{"signature": "def tolist(self, fill_value=None):", "body": "if fill_value is not None:<EOL><INDENT>return self.filled(fill_value).tolist()<EOL><DEDENT>result = narray(self.filled().tolist(), dtype=object)<EOL>mask = narray(self._mask.tolist())<EOL>result[mask] = None<EOL>return result.tolist()<EOL>", "docstring": "Copy the data portion of the array to a hierarchical python\n        list and returns that list.\n\n        Data items are converted to the nearest compatible Python\n        type.  Masked values are converted to fill_value. If\n        fill_value is None, the corresponding entries in the output\n        list will be ``None``.", "id": "f18990:c0:m15"}
{"signature": "def addfield(mrecord, newfield, newfieldname=None):", "body": "_data = mrecord._data<EOL>_mask = mrecord._mask<EOL>if newfieldname is None or newfieldname in reserved_fields:<EOL><INDENT>newfieldname = '<STR_LIT>' % len(_data.dtype)<EOL><DEDENT>newfield = ma.array(newfield)<EOL>newdtype = np.dtype(_data.dtype.descr + [(newfieldname, newfield.dtype)])<EOL>newdata = recarray(_data.shape, newdtype)<EOL>[newdata.setfield(_data.getfield(*f), *f)<EOL>for f in _data.dtype.fields.values()]<EOL>newdata.setfield(newfield._data, *newdata.dtype.fields[newfieldname])<EOL>newdata = newdata.view(MaskedRecords)<EOL>newmdtype = np.dtype([(n, bool_) for n in newdtype.names])<EOL>newmask = recarray(_data.shape, newmdtype)<EOL>[newmask.setfield(_mask.getfield(*f), *f)<EOL>for f in _mask.dtype.fields.values()]<EOL>newmask.setfield(getmaskarray(newfield),<EOL>*newmask.dtype.fields[newfieldname])<EOL>newdata._mask = newmask<EOL>return newdata<EOL>", "docstring": "Adds a new field to the masked record array, using `newfield` as data\nand `newfieldname` as name. If `newfieldname` is None, the new field name is\nset to 'fi', where `i` is the number of existing fields.", "id": "f18990:m9"}
{"signature": "def __call__ (self, x):", "body": "return umath.logical_or(umath.greater (x, self.b),<EOL>umath.less(x, self.a))<EOL>", "docstring": "Execute the call behavior.", "id": "f18992:c2:m1"}
{"signature": "def right_shift (a, n):", "body": "m = getmask(a)<EOL>if m is nomask:<EOL><INDENT>d = umath.right_shift(filled(a), n)<EOL>return masked_array(d)<EOL><DEDENT>else:<EOL><INDENT>d = umath.right_shift(filled(a, <NUM_LIT:0>), n)<EOL>return masked_array(d, mask=m)<EOL><DEDENT>", "docstring": "Shift the bits of an integer to the right.\n\nThis is the masked array version of `numpy.right_shift`, for details\nsee that function.\n\nSee Also\n--------\nnumpy.right_shift", "id": "f18992:m60"}
{"signature": "def soften_mask(self):", "body": "self._hardmask = False<EOL>return self<EOL>", "docstring": "Force the mask to soft.\n\nWhether the mask of a masked array is hard or soft is determined by\nits `hardmask` property. `soften_mask` sets `hardmask` to False.\n\nSee Also\n--------\nhardmask", "id": "f18992:c13:m15"}
{"signature": "def is_masked(x):", "body": "m = getmask(x)<EOL>if m is nomask:<EOL><INDENT>return False<EOL><DEDENT>elif m.any():<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Determine whether input has masked values.\n\nAccepts any object as input, but always returns False unless the\ninput is a MaskedArray containing masked values.\n\nParameters\n----------\nx : array_like\n    Array to check for masked values.\n\nReturns\n-------\nresult : bool\n    True if `x` is a MaskedArray with masked values, False otherwise.\n\nExamples\n--------\n>>> import numpy.ma as ma\n>>> x = ma.masked_equal([0, 1, 0, 2, 3], 0)\n>>> x\nmasked_array(data = [-- 1 -- 2 3],\n      mask = [ True False  True False False],\n      fill_value=999999)\n>>> ma.is_masked(x)\nTrue\n>>> x = ma.masked_equal([0, 1, 0, 2, 3], 42)\n>>> x\nmasked_array(data = [0 1 0 2 3],\n      mask = False,\n      fill_value=999999)\n>>> ma.is_masked(x)\nFalse\n\nAlways returns False if `x` isn't a MaskedArray.\n\n>>> x = [False, True, False]\n>>> ma.is_masked(x)\nFalse\n>>> x = 'a string'\n>>> ma.is_masked(x)\nFalse", "id": "f18992:m44"}
{"signature": "def getmask(a):", "body": "return getattr(a, '<STR_LIT>', nomask)<EOL>", "docstring": "Return the mask of a masked array, or nomask.\n\nReturn the mask of `a` as an ndarray if `a` is a `MaskedArray` and the\nmask is not `nomask`, else return `nomask`. To guarantee a full array\nof booleans of the same shape as a, use `getmaskarray`.\n\nParameters\n----------\na : array_like\n    Input `MaskedArray` for which the mask is required.\n\nSee Also\n--------\ngetdata : Return the data of a masked array as an ndarray.\ngetmaskarray : Return the mask of a masked array, or full array of False.\n\nExamples\n--------\n>>> import numpy.ma as ma\n>>> a = ma.masked_equal([[1,2],[3,4]], 2)\n>>> a\nmasked_array(data =\n [[1 --]\n [3 4]],\n      mask =\n [[False  True]\n [False False]],\n      fill_value=999999)\n>>> ma.getmask(a)\narray([[False,  True],\n       [False, False]], dtype=bool)\n\nEquivalently use the `MaskedArray` `mask` attribute.\n\n>>> a.mask\narray([[False,  True],\n       [False, False]], dtype=bool)\n\nResult when mask == `nomask`\n\n>>> b = ma.masked_array([[1,2],[3,4]])\n>>> b\nmasked_array(data =\n [[1 2]\n [3 4]],\n      mask =\n False,\n      fill_value=999999)\n>>> ma.nomask\nFalse\n>>> ma.getmask(b) == ma.nomask\nTrue\n>>> b.mask == ma.nomask\nTrue", "id": "f18992:m18"}
{"signature": "def enabled(self):", "body": "return self._enabled<EOL>", "docstring": "Is the use of the display value enabled?", "id": "f18992:c10:m3"}
{"signature": "def set_fill_value(a, fill_value):", "body": "if isinstance(a, MaskedArray):<EOL><INDENT>a.set_fill_value(fill_value)<EOL><DEDENT>return<EOL>", "docstring": "Set the filling value of a, if a is a masked array.\n\nThis function changes the fill value of the masked array `a` in place.\nIf `a` is not a masked array, the function returns silently, without\ndoing anything.\n\nParameters\n----------\na : array_like\n    Input array.\nfill_value : dtype\n    Filling value. A consistency test is performed to make sure\n    the value is compatible with the dtype of `a`.\n\nReturns\n-------\nNone\n    Nothing returned by this function.\n\nSee Also\n--------\nmaximum_fill_value : Return the default fill value for a dtype.\nMaskedArray.fill_value : Return current fill value.\nMaskedArray.set_fill_value : Equivalent method.\n\nExamples\n--------\n>>> import numpy.ma as ma\n>>> a = np.arange(5)\n>>> a\narray([0, 1, 2, 3, 4])\n>>> a = ma.masked_where(a < 3, a)\n>>> a\nmasked_array(data = [-- -- -- 3 4],\n      mask = [ True  True  True False False],\n      fill_value=999999)\n>>> ma.set_fill_value(a, -999)\n>>> a\nmasked_array(data = [-- -- -- 3 4],\n      mask = [ True  True  True False False],\n      fill_value=-999)\n\nNothing happens if `a` is not a masked array.\n\n>>> a = range(5)\n>>> a\n[0, 1, 2, 3, 4]\n>>> ma.set_fill_value(a, 100)\n>>> a\n[0, 1, 2, 3, 4]\n>>> a = np.arange(5)\n>>> a\narray([0, 1, 2, 3, 4])\n>>> ma.set_fill_value(a, 100)\n>>> a\narray([0, 1, 2, 3, 4])", "id": "f18992:m9"}
{"signature": "def set_fill_value(self, value=None):", "body": "target = _check_fill_value(value, self.dtype)<EOL>_fill_value = self._fill_value<EOL>if _fill_value is None:<EOL><INDENT>self._fill_value = target<EOL><DEDENT>else:<EOL><INDENT>_fill_value[()] = target<EOL><DEDENT>", "docstring": "Set the filling value of the masked array.\n\nParameters\n----------\nvalue : scalar, optional\n    The new filling value. Default is None, in which case a default\n    based on the data type is used.\n\nSee Also\n--------\nma.set_fill_value : Equivalent function.\n\nExamples\n--------\n>>> x = np.ma.array([0, 1.], fill_value=-np.inf)\n>>> x.fill_value\n-inf\n>>> x.set_fill_value(np.pi)\n>>> x.fill_value\n3.1415926535897931\n\nReset to default:\n\n>>> x.set_fill_value()\n>>> x.fill_value\n1e+20", "id": "f18992:c13:m22"}
{"signature": "def allclose (a, b, masked_equal=True, rtol=<NUM_LIT>, atol=<NUM_LIT>):", "body": "x = masked_array(a, copy=False)<EOL>y = masked_array(b, copy=False)<EOL>dtype = np.result_type(y, <NUM_LIT:1.>)<EOL>if y.dtype != dtype:<EOL><INDENT>y = masked_array(y, dtype=dtype, copy=False)<EOL><DEDENT>m = mask_or(getmask(x), getmask(y))<EOL>xinf = np.isinf(masked_array(x, copy=False, mask=m)).filled(False)<EOL>if not np.all(xinf == filled(np.isinf(y), False)):<EOL><INDENT>return False<EOL><DEDENT>if not np.any(xinf):<EOL><INDENT>d = filled(umath.less_equal(umath.absolute(x - y),<EOL>atol + rtol * umath.absolute(y)),<EOL>masked_equal)<EOL>return np.all(d)<EOL><DEDENT>if not np.all(filled(x[xinf] == y[xinf], masked_equal)):<EOL><INDENT>return False<EOL><DEDENT>x = x[~xinf]<EOL>y = y[~xinf]<EOL>d = filled(umath.less_equal(umath.absolute(x - y),<EOL>atol + rtol * umath.absolute(y)),<EOL>masked_equal)<EOL>return np.all(d)<EOL>", "docstring": "Returns True if two arrays are element-wise equal within a tolerance.\n\nThis function is equivalent to `allclose` except that masked values\nare treated as equal (default) or unequal, depending on the `masked_equal`\nargument.\n\nParameters\n----------\na, b : array_like\n    Input arrays to compare.\nmasked_equal : bool, optional\n    Whether masked values in `a` and `b` are considered equal (True) or not\n    (False). They are considered equal by default.\nrtol : float, optional\n    Relative tolerance. The relative difference is equal to ``rtol * b``.\n    Default is 1e-5.\natol : float, optional\n    Absolute tolerance. The absolute difference is equal to `atol`.\n    Default is 1e-8.\n\nReturns\n-------\ny : bool\n    Returns True if the two arrays are equal within the given\n    tolerance, False otherwise. If either array contains NaN, then\n    False is returned.\n\nSee Also\n--------\nall, any\nnumpy.allclose : the non-masked `allclose`.\n\nNotes\n-----\nIf the following equation is element-wise True, then `allclose` returns\nTrue::\n\n  absolute(`a` - `b`) <= (`atol` + `rtol` * absolute(`b`))\n\nReturn True if all elements of `a` and `b` are equal subject to\ngiven tolerances.\n\nExamples\n--------\n>>> a = ma.array([1e10, 1e-7, 42.0], mask=[0, 0, 1])\n>>> a\nmasked_array(data = [10000000000.0 1e-07 --],\n             mask = [False False  True],\n       fill_value = 1e+20)\n>>> b = ma.array([1e10, 1e-8, -42.0], mask=[0, 0, 1])\n>>> ma.allclose(a, b)\nFalse\n\n>>> a = ma.array([1e10, 1e-8, 42.0], mask=[0, 0, 1])\n>>> b = ma.array([1.00001e10, 1e-9, -42.0], mask=[0, 0, 1])\n>>> ma.allclose(a, b)\nTrue\n>>> ma.allclose(a, b, masked_equal=False)\nFalse\n\nMasked values are not compared directly.\n\n>>> a = ma.array([1e10, 1e-8, 42.0], mask=[0, 0, 1])\n>>> b = ma.array([1.00001e10, 1e-9, 42.0], mask=[0, 0, 1])\n>>> ma.allclose(a, b)\nTrue\n>>> ma.allclose(a, b, masked_equal=False)\nFalse", "id": "f18992:m75"}
{"signature": "def isMaskedArray(x):", "body": "return isinstance(x, MaskedArray)<EOL>", "docstring": "Test whether input is an instance of MaskedArray.\n\nThis function returns True if `x` is an instance of MaskedArray\nand returns False otherwise.  Any object is accepted as input.\n\nParameters\n----------\nx : object\n    Object to test.\n\nReturns\n-------\nresult : bool\n    True if `x` is a MaskedArray.\n\nSee Also\n--------\nisMA : Alias to isMaskedArray.\nisarray : Alias to isMaskedArray.\n\nExamples\n--------\n>>> import numpy.ma as ma\n>>> a = np.eye(3, 3)\n>>> a\narray([[ 1.,  0.,  0.],\n       [ 0.,  1.,  0.],\n       [ 0.,  0.,  1.]])\n>>> m = ma.masked_values(a, 0)\n>>> m\nmasked_array(data =\n [[1.0 -- --]\n [-- 1.0 --]\n [-- -- 1.0]],\n      mask =\n [[False  True  True]\n [ True False  True]\n [ True  True False]],\n      fill_value=0.0)\n>>> ma.isMaskedArray(a)\nFalse\n>>> ma.isMaskedArray(m)\nTrue\n>>> ma.isMaskedArray([0, 1, 2])\nFalse", "id": "f18992:m42"}
{"signature": "def shrink_mask(self):", "body": "m = self._mask<EOL>if m.ndim and not m.any():<EOL><INDENT>self._mask = nomask<EOL><DEDENT>return self<EOL>", "docstring": "Reduce a mask to nomask when possible.\n\nParameters\n----------\nNone\n\nReturns\n-------\nNone\n\nExamples\n--------\n>>> x = np.ma.array([[1,2 ], [3, 4]], mask=[0]*4)\n>>> x.mask\narray([[False, False],\n       [False, False]], dtype=bool)\n>>> x.shrink_mask()\n>>> x.mask\nFalse", "id": "f18992:c13:m17"}
{"signature": "def make_mask_none(newshape, dtype=None):", "body": "if dtype is None:<EOL><INDENT>result = np.zeros(newshape, dtype=MaskType)<EOL><DEDENT>else:<EOL><INDENT>result = np.zeros(newshape, dtype=make_mask_descr(dtype))<EOL><DEDENT>return result<EOL>", "docstring": "Return a boolean mask of the given shape, filled with False.\n\nThis function returns a boolean ndarray with all entries False, that can\nbe used in common mask manipulations. If a complex dtype is specified, the\ntype of each field is converted to a boolean type.\n\nParameters\n----------\nnewshape : tuple\n    A tuple indicating the shape of the mask.\ndtype : {None, dtype}, optional\n    If None, use a MaskType instance. Otherwise, use a new datatype with\n    the same fields as `dtype`, converted to boolean types.\n\nReturns\n-------\nresult : ndarray\n    An ndarray of appropriate shape and dtype, filled with False.\n\nSee Also\n--------\nmake_mask : Create a boolean mask from an array.\nmake_mask_descr : Construct a dtype description list from a given dtype.\n\nExamples\n--------\n>>> import numpy.ma as ma\n>>> ma.make_mask_none((3,))\narray([False, False, False], dtype=bool)\n\nDefining a more complex dtype.\n\n>>> dtype = np.dtype({'names':['foo', 'bar'],\n                      'formats':[np.float32, np.int]})\n>>> dtype\ndtype([('foo', '<f4'), ('bar', '<i4')])\n>>> ma.make_mask_none((3,), dtype=dtype)\narray([(False, False), (False, False), (False, False)],\n      dtype=[('foo', '|b1'), ('bar', '|b1')])", "id": "f18992:m22"}
{"signature": "def left_shift (a, n):", "body": "m = getmask(a)<EOL>if m is nomask:<EOL><INDENT>d = umath.left_shift(filled(a), n)<EOL>return masked_array(d)<EOL><DEDENT>else:<EOL><INDENT>d = umath.left_shift(filled(a, <NUM_LIT:0>), n)<EOL>return masked_array(d, mask=m)<EOL><DEDENT>", "docstring": "Shift the bits of an integer to the left.\n\nThis is the masked array version of `numpy.left_shift`, for details\nsee that function.\n\nSee Also\n--------\nnumpy.left_shift", "id": "f18992:m59"}
{"signature": "def outer(a, b):", "body": "fa = filled(a, <NUM_LIT:0>).ravel()<EOL>fb = filled(b, <NUM_LIT:0>).ravel()<EOL>d = np.outer(fa, fb)<EOL>ma = getmask(a)<EOL>mb = getmask(b)<EOL>if ma is nomask and mb is nomask:<EOL><INDENT>return masked_array(d)<EOL><DEDENT>ma = getmaskarray(a)<EOL>mb = getmaskarray(b)<EOL>m = make_mask(<NUM_LIT:1> - np.outer(<NUM_LIT:1> - ma, <NUM_LIT:1> - mb), copy=<NUM_LIT:0>)<EOL>return masked_array(d, mask=m)<EOL>", "docstring": "maskedarray version of the numpy function.", "id": "f18992:m73"}
{"signature": "def getdata(a, subok=True):", "body": "try:<EOL><INDENT>data = a._data<EOL><DEDENT>except AttributeError:<EOL><INDENT>data = np.array(a, copy=False, subok=subok)<EOL><DEDENT>if not subok:<EOL><INDENT>return data.view(ndarray)<EOL><DEDENT>return data<EOL>", "docstring": "Return the data of a masked array as an ndarray.\n\nReturn the data of `a` (if any) as an ndarray if `a` is a ``MaskedArray``,\nelse return `a` as a ndarray or subclass (depending on `subok`) if not.\n\nParameters\n----------\na : array_like\n    Input ``MaskedArray``, alternatively a ndarray or a subclass thereof.\nsubok : bool\n    Whether to force the output to be a `pure` ndarray (False) or to\n    return a subclass of ndarray if appropriate (True, default).\n\nSee Also\n--------\ngetmask : Return the mask of a masked array, or nomask.\ngetmaskarray : Return the mask of a masked array, or full array of False.\n\nExamples\n--------\n>>> import numpy.ma as ma\n>>> a = ma.masked_equal([[1,2],[3,4]], 2)\n>>> a\nmasked_array(data =\n [[1 --]\n [3 4]],\n      mask =\n [[False  True]\n [False False]],\n      fill_value=999999)\n>>> ma.getdata(a)\narray([[1, 2],\n       [3, 4]])\n\nEquivalently use the ``MaskedArray`` `data` attribute.\n\n>>> a.data\narray([[1, 2],\n       [3, 4]])", "id": "f18992:m14"}
{"signature": "def __isub__(self, other):", "body": "m = getmask(other)<EOL>if self._mask is nomask:<EOL><INDENT>if m is not nomask and m.any():<EOL><INDENT>self._mask = make_mask_none(self.shape, self.dtype)<EOL>self._mask += m<EOL><DEDENT><DEDENT>elif m is not nomask:<EOL><INDENT>self._mask += m<EOL><DEDENT>ndarray.__isub__(self._data, np.where(self._mask, <NUM_LIT:0>, getdata(other)))<EOL>return self<EOL>", "docstring": "Subtract other from self in-place.", "id": "f18992:c13:m44"}
{"signature": "def argmin(a, axis=None, fill_value=None):", "body": "if fill_value is None:<EOL><INDENT>fill_value = default_fill_value(a)<EOL><DEDENT>d = filled(a, fill_value)<EOL>return d.argmin(axis=axis)<EOL>", "docstring": "Function version of the eponymous method.", "id": "f18992:m51"}
{"signature": "def __iadd__(self, other):", "body": "m = getmask(other)<EOL>if self._mask is nomask:<EOL><INDENT>if m is not nomask and m.any():<EOL><INDENT>self._mask = make_mask_none(self.shape, self.dtype)<EOL>self._mask += m<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if m is not nomask:<EOL><INDENT>self._mask += m<EOL><DEDENT><DEDENT>ndarray.__iadd__(self._data, np.where(self._mask, <NUM_LIT:0>, getdata(other)))<EOL>return self<EOL>", "docstring": "Add other to self in-place.", "id": "f18992:c13:m43"}
{"signature": "def reduce(self, target, axis=None):", "body": "target = narray(target, copy=False, subok=True)<EOL>m = getmask(target)<EOL>if axis is not None:<EOL><INDENT>kargs = { '<STR_LIT>' : axis }<EOL><DEDENT>else:<EOL><INDENT>kargs = {}<EOL>target = target.ravel()<EOL>if not (m is nomask):<EOL><INDENT>m = m.ravel()<EOL><DEDENT><DEDENT>if m is nomask:<EOL><INDENT>t = self.ufunc.reduce(target, **kargs)<EOL><DEDENT>else:<EOL><INDENT>target = target.filled(self.fill_value_func(target)).view(type(target))<EOL>t = self.ufunc.reduce(target, **kargs)<EOL>m = umath.logical_and.reduce(m, **kargs)<EOL>if hasattr(t, '<STR_LIT>'):<EOL><INDENT>t._mask = m<EOL><DEDENT>elif m:<EOL><INDENT>t = masked<EOL><DEDENT><DEDENT>return t<EOL>", "docstring": "Reduce target along the given axis.", "id": "f18992:c16:m1"}
{"signature": "def __str__(self):", "body": "if masked_print_option.enabled():<EOL><INDENT>f = masked_print_option<EOL>if self is masked:<EOL><INDENT>return str(f)<EOL><DEDENT>m = self._mask<EOL>if m is nomask:<EOL><INDENT>res = self._data<EOL><DEDENT>else:<EOL><INDENT>if m.shape == ():<EOL><INDENT>if m.dtype.names:<EOL><INDENT>m = m.view((bool, len(m.dtype)))<EOL>if m.any():<EOL><INDENT>return str(tuple((f if _m else _d) for _d, _m in<EOL>zip(self._data.tolist(), m)))<EOL><DEDENT>else:<EOL><INDENT>return str(self._data)<EOL><DEDENT><DEDENT>elif m:<EOL><INDENT>return str(f)<EOL><DEDENT>else:<EOL><INDENT>return str(self._data)<EOL><DEDENT><DEDENT>names = self.dtype.names<EOL>if names is None:<EOL><INDENT>res = self._data.astype(\"<STR_LIT:O>\")<EOL>res.view(ndarray)[m] = f<EOL><DEDENT>else:<EOL><INDENT>rdtype = _recursive_make_descr(self.dtype, \"<STR_LIT:O>\")<EOL>res = self._data.astype(rdtype)<EOL>_recursive_printoption(res, m, f)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>res = self.filled(self.fill_value)<EOL><DEDENT>return str(res)<EOL>", "docstring": "String representation.", "id": "f18992:c13:m26"}
{"signature": "def prod(self, axis=None, dtype=None, out=None):", "body": "_mask = ndarray.__getattribute__(self, '<STR_LIT>')<EOL>newmask = _check_mask_axis(_mask, axis)<EOL>if out is None:<EOL><INDENT>result = self.filled(<NUM_LIT:1>).prod(axis, dtype=dtype)<EOL>rndim = getattr(result, '<STR_LIT>', <NUM_LIT:0>)<EOL>if rndim:<EOL><INDENT>result = result.view(type(self))<EOL>result.__setmask__(newmask)<EOL><DEDENT>elif newmask:<EOL><INDENT>result = masked<EOL><DEDENT>return result<EOL><DEDENT>result = self.filled(<NUM_LIT:1>).prod(axis, dtype=dtype, out=out)<EOL>if isinstance(out, MaskedArray):<EOL><INDENT>outmask = getattr(out, '<STR_LIT>', nomask)<EOL>if (outmask is nomask):<EOL><INDENT>outmask = out._mask = make_mask_none(out.shape)<EOL><DEDENT>outmask.flat = newmask<EOL><DEDENT>return out<EOL>", "docstring": "Return the product of the array elements over the given axis.\nMasked elements are set to 1 internally for computation.\n\nParameters\n----------\naxis : {None, int}, optional\n    Axis over which the product is taken. If None is used, then the\n    product is over all the array elements.\ndtype : {None, dtype}, optional\n    Determines the type of the returned array and of the accumulator\n    where the elements are multiplied. If ``dtype`` has the value ``None``\n    and the type of a is an integer type of precision less than the default\n    platform integer, then the default platform integer precision is\n    used.  Otherwise, the dtype is the same as that of a.\nout : {None, array}, optional\n    Alternative output array in which to place the result. It must have\n    the same shape as the expected output but the type will be cast if\n    necessary.\n\nReturns\n-------\nproduct_along_axis : {array, scalar}, see dtype parameter above.\n    Returns an array whose shape is the same as a with the specified\n    axis removed. Returns a 0d array when a is 1d or axis=None.\n    Returns a reference to the specified output array if specified.\n\nSee Also\n--------\nprod : equivalent function\n\nNotes\n-----\nArithmetic is modular when using integer types, and no error is raised\non overflow.\n\nExamples\n--------\n>>> np.prod([1.,2.])\n2.0\n>>> np.prod([1.,2.], dtype=np.int32)\n2\n>>> np.prod([[1.,2.],[3.,4.]])\n24.0\n>>> np.prod([[1.,2.],[3.,4.]], axis=1)\narray([  2.,  12.])", "id": "f18992:c13:m67"}
{"signature": "def __setmask__(self, mask, copy=False):", "body": "idtype = ndarray.__getattribute__(self, '<STR_LIT>')<EOL>current_mask = ndarray.__getattribute__(self, '<STR_LIT>')<EOL>if mask is masked:<EOL><INDENT>mask = True<EOL><DEDENT>if (current_mask is nomask):<EOL><INDENT>if mask is nomask:<EOL><INDENT>return<EOL><DEDENT>current_mask = self._mask = make_mask_none(self.shape, idtype)<EOL><DEDENT>if idtype.names is None:<EOL><INDENT>if self._hardmask:<EOL><INDENT>current_mask |= mask<EOL><DEDENT>elif isinstance(mask, (int, float, np.bool_, np.number)):<EOL><INDENT>current_mask[...] = mask<EOL><DEDENT>else:<EOL><INDENT>current_mask.flat = mask<EOL><DEDENT><DEDENT>else:<EOL><INDENT>mdtype = current_mask.dtype<EOL>mask = np.array(mask, copy=False)<EOL>if not mask.ndim:<EOL><INDENT>if mask.dtype.kind == '<STR_LIT:b>':<EOL><INDENT>mask = np.array(tuple([mask.item()]*len(mdtype)),<EOL>dtype=mdtype)<EOL><DEDENT>else:<EOL><INDENT>mask = mask.astype(mdtype)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>mask = np.array(mask, copy=copy, dtype=mdtype)<EOL><DEDENT>except TypeError:<EOL><INDENT>mask = np.array([tuple([m] * len(mdtype)) for m in mask],<EOL>dtype=mdtype)<EOL><DEDENT><DEDENT>if self._hardmask:<EOL><INDENT>for n in idtype.names:<EOL><INDENT>current_mask[n] |= mask[n]<EOL><DEDENT><DEDENT>elif isinstance(mask, (int, float, np.bool_, np.number)):<EOL><INDENT>current_mask[...] = mask<EOL><DEDENT>else:<EOL><INDENT>current_mask.flat = mask<EOL><DEDENT><DEDENT>if current_mask.shape:<EOL><INDENT>current_mask.shape = self.shape<EOL><DEDENT>return<EOL>", "docstring": "Set the mask.", "id": "f18992:c13:m10"}
{"signature": "def __getstate__(self):", "body": "cf = '<STR_LIT>'[self.flags.fnc]<EOL>state = (<NUM_LIT:1>,<EOL>self.shape,<EOL>self.dtype,<EOL>self.flags.fnc,<EOL>self._data.tobytes(cf),<EOL>getmaskarray(self).tobytes(cf),<EOL>self._fill_value,<EOL>)<EOL>return state<EOL>", "docstring": "Return the internal state of the masked array, for pickling\n        purposes.", "id": "f18992:c13:m88"}
{"signature": "def compress(self, condition, axis=None, out=None):", "body": "<EOL>(_data, _mask) = (self._data, self._mask)<EOL>condition = np.array(condition, copy=False, subok=False)<EOL>_new = _data.compress(condition, axis=axis, out=out).view(type(self))<EOL>_new._update_from(self)<EOL>if _mask is not nomask:<EOL><INDENT>_new._mask = _mask.compress(condition, axis=axis)<EOL><DEDENT>return _new<EOL>", "docstring": "Return `a` where condition is ``True``.\n\nIf condition is a `MaskedArray`, missing values are considered\nas ``False``.\n\nParameters\n----------\ncondition : var\n    Boolean 1-d array selecting which entries to return. If len(condition)\n    is less than the size of a along the axis, then output is truncated\n    to length of condition array.\naxis : {None, int}, optional\n    Axis along which the operation must be performed.\nout : {None, ndarray}, optional\n    Alternative output array in which to place the result. It must have\n    the same shape as the expected output but the type will be cast if\n    necessary.\n\nReturns\n-------\nresult : MaskedArray\n    A :class:`MaskedArray` object.\n\nNotes\n-----\nPlease note the difference with :meth:`compressed` !\nThe output of :meth:`compress` has a mask, the output of\n:meth:`compressed` does not.\n\nExamples\n--------\n>>> x = np.ma.array([[1,2,3],[4,5,6],[7,8,9]], mask=[0] + [1,0]*4)\n>>> print x\n[[1 -- 3]\n [-- 5 --]\n [7 -- 9]]\n>>> x.compress([1, 0, 1])\nmasked_array(data = [1 3],\n      mask = [False False],\n      fill_value=999999)\n\n>>> x.compress([1, 0, 1], axis=1)\nmasked_array(data =\n [[1 3]\n [-- --]\n [7 9]],\n      mask =\n [[False False]\n [ True  True]\n [False False]],\n      fill_value=999999)", "id": "f18992:c13:m25"}
{"signature": "def min(self, axis=None, out=None, fill_value=None):", "body": "_mask = ndarray.__getattribute__(self, '<STR_LIT>')<EOL>newmask = _check_mask_axis(_mask, axis)<EOL>if fill_value is None:<EOL><INDENT>fill_value = minimum_fill_value(self)<EOL><DEDENT>if out is None:<EOL><INDENT>result = self.filled(fill_value).min(axis=axis, out=out).view(type(self))<EOL>if result.ndim:<EOL><INDENT>result.__setmask__(newmask)<EOL>if newmask.ndim:<EOL><INDENT>np.copyto(result, result.fill_value, where=newmask)<EOL><DEDENT><DEDENT>elif newmask:<EOL><INDENT>result = masked<EOL><DEDENT>return result<EOL><DEDENT>result = self.filled(fill_value).min(axis=axis, out=out)<EOL>if isinstance(out, MaskedArray):<EOL><INDENT>outmask = getattr(out, '<STR_LIT>', nomask)<EOL>if (outmask is nomask):<EOL><INDENT>outmask = out._mask = make_mask_none(out.shape)<EOL><DEDENT>outmask.flat = newmask<EOL><DEDENT>else:<EOL><INDENT>if out.dtype.kind in '<STR_LIT>':<EOL><INDENT>errmsg = \"<STR_LIT>\"\"<STR_LIT>\"<EOL>raise MaskError(errmsg)<EOL><DEDENT>np.copyto(out, np.nan, where=newmask)<EOL><DEDENT>return out<EOL>", "docstring": "Return the minimum along a given axis.\n\nParameters\n----------\naxis : {None, int}, optional\n    Axis along which to operate.  By default, ``axis`` is None and the\n    flattened input is used.\nout : array_like, optional\n    Alternative output array in which to place the result.  Must be of\n    the same shape and buffer length as the expected output.\nfill_value : {var}, optional\n    Value used to fill in the masked values.\n    If None, use the output of `minimum_fill_value`.\n\nReturns\n-------\namin : array_like\n    New array holding the result.\n    If ``out`` was specified, ``out`` is returned.\n\nSee Also\n--------\nminimum_fill_value\n    Returns the minimum filling value for a given datatype.", "id": "f18992:c13:m78"}
{"signature": "def make_mask_descr(ndtype):", "body": "<EOL>if not isinstance(ndtype, np.dtype):<EOL><INDENT>ndtype = np.dtype(ndtype)<EOL><DEDENT>return np.dtype(_recursive_make_descr(ndtype, np.bool))<EOL>", "docstring": "Construct a dtype description list from a given dtype.\n\nReturns a new dtype object, with the type of all fields in `ndtype` to a\nboolean type. Field names are not altered.\n\nParameters\n----------\nndtype : dtype\n    The dtype to convert.\n\nReturns\n-------\nresult : dtype\n    A dtype that looks like `ndtype`, the type of all fields is boolean.\n\nExamples\n--------\n>>> import numpy.ma as ma\n>>> dtype = np.dtype({'names':['foo', 'bar'],\n                      'formats':[np.float32, np.int]})\n>>> dtype\ndtype([('foo', '<f4'), ('bar', '<i4')])\n>>> ma.make_mask_descr(dtype)\ndtype([('foo', '|b1'), ('bar', '|b1')])\n>>> ma.make_mask_descr(np.float32)\n<type 'numpy.bool_'>", "id": "f18992:m17"}
{"signature": "def argmax(a, axis=None, fill_value=None):", "body": "if fill_value is None:<EOL><INDENT>fill_value = default_fill_value(a)<EOL>try:<EOL><INDENT>fill_value = -fill_value<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>d = filled(a, fill_value)<EOL>return d.argmax(axis=axis)<EOL>", "docstring": "Function version of the eponymous method.", "id": "f18992:m52"}
{"signature": "def size(obj, axis=None):", "body": "return np.size(getdata(obj), axis)<EOL>", "docstring": "maskedarray version of the numpy function.", "id": "f18992:m68"}
{"signature": "def _check_fill_value(fill_value, ndtype):", "body": "ndtype = np.dtype(ndtype)<EOL>fields = ndtype.fields<EOL>if fill_value is None:<EOL><INDENT>if fields:<EOL><INDENT>descr = ndtype.descr<EOL>fill_value = np.array(_recursive_set_default_fill_value(descr),<EOL>dtype=ndtype,)<EOL><DEDENT>else:<EOL><INDENT>fill_value = default_fill_value(ndtype)<EOL><DEDENT><DEDENT>elif fields:<EOL><INDENT>fdtype = [(_[<NUM_LIT:0>], _[<NUM_LIT:1>]) for _ in ndtype.descr]<EOL>if isinstance(fill_value, (ndarray, np.void)):<EOL><INDENT>try:<EOL><INDENT>fill_value = np.array(fill_value, copy=False, dtype=fdtype)<EOL><DEDENT>except ValueError:<EOL><INDENT>err_msg = \"<STR_LIT>\"<EOL>raise ValueError(err_msg % (fill_value, fdtype))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>descr = ndtype.descr<EOL>fill_value = np.asarray(fill_value, dtype=object)<EOL>fill_value = np.array(_recursive_set_fill_value(fill_value, descr),<EOL>dtype=ndtype)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if isinstance(fill_value, basestring) and (ndtype.char not in '<STR_LIT>'):<EOL><INDENT>err_msg = \"<STR_LIT>\"<EOL>raise TypeError(err_msg % ndtype)<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>fill_value = np.array(fill_value, copy=False, dtype=ndtype)<EOL><DEDENT>except OverflowError:<EOL><INDENT>err_msg = \"<STR_LIT>\"<EOL>raise TypeError(err_msg % (fill_value, ndtype))<EOL><DEDENT><DEDENT><DEDENT>return np.array(fill_value)<EOL>", "docstring": "Private function validating the given `fill_value` for the given dtype.\n\nIf fill_value is None, it is set to the default corresponding to the dtype\nif this latter is standard (no fields). If the datatype is flexible (named\nfields), fill_value is set to a tuple whose elements are the default fill\nvalues corresponding to each field.\n\nIf fill_value is not None, its value is forced to the given dtype.", "id": "f18992:m8"}
{"signature": "def __setitem__(self, indx, value):", "body": "if self is masked:<EOL><INDENT>raise MaskError('<STR_LIT>')<EOL>", "docstring": "x.__setitem__(i, y) <==> x[i]=y\n\n        Set item described by index. If value is masked, masks those\n        locations.", "id": "f18992:c13:m7"}
{"signature": "def view(self, dtype=None, type=None, fill_value=None):", "body": "if dtype is None:<EOL><INDENT>if type is None:<EOL><INDENT>output = ndarray.view(self)<EOL><DEDENT>else:<EOL><INDENT>output = ndarray.view(self, type)<EOL><DEDENT><DEDENT>elif type is None:<EOL><INDENT>try:<EOL><INDENT>if issubclass(dtype, ndarray):<EOL><INDENT>output = ndarray.view(self, dtype)<EOL>dtype = None<EOL><DEDENT>else:<EOL><INDENT>output = ndarray.view(self, dtype)<EOL><DEDENT><DEDENT>except TypeError:<EOL><INDENT>output = ndarray.view(self, dtype)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>output = ndarray.view(self, dtype, type)<EOL><DEDENT>if (getattr(output, '<STR_LIT>', nomask) is not nomask):<EOL><INDENT>if dtype is None:<EOL><INDENT>dtype = output.dtype<EOL><DEDENT>mdtype = make_mask_descr(dtype)<EOL>output._mask = self._mask.view(mdtype, ndarray)<EOL>try:<EOL><INDENT>output._mask.shape = output.shape<EOL><DEDENT>except (AttributeError, TypeError):<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if getattr(output, '<STR_LIT>', None) is not None:<EOL><INDENT>if fill_value is None:<EOL><INDENT>if dtype is None:<EOL><INDENT>pass <EOL><DEDENT>else:<EOL><INDENT>output._fill_value = None<EOL><DEDENT><DEDENT>else:<EOL><INDENT>output.fill_value = fill_value<EOL><DEDENT><DEDENT>return output<EOL>", "docstring": "Return a view of the MaskedArray data\n\nParameters\n----------\ndtype : data-type or ndarray sub-class, optional\n    Data-type descriptor of the returned view, e.g., float32 or int16.\n    The default, None, results in the view having the same data-type\n    as `a`. As with ``ndarray.view``, dtype can also be specified as\n    an ndarray sub-class, which then specifies the type of the\n    returned object (this is equivalent to setting the ``type``\n    parameter).\ntype : Python type, optional\n    Type of the returned view, e.g., ndarray or matrix.  Again, the\n    default None results in type preservation.\n\nNotes\n-----\n\n``a.view()`` is used two different ways:\n\n``a.view(some_dtype)`` or ``a.view(dtype=some_dtype)`` constructs a view\nof the array's memory with a different data-type.  This can cause a\nreinterpretation of the bytes of memory.\n\n``a.view(ndarray_subclass)`` or ``a.view(type=ndarray_subclass)`` just\nreturns an instance of `ndarray_subclass` that looks at the same array\n(same shape, dtype, etc.)  This does not cause a reinterpretation of the\nmemory.\n\nIf `fill_value` is not specified, but `dtype` is specified (and is not\nan ndarray sub-class), the `fill_value` of the MaskedArray will be\nreset. If neither `fill_value` nor `dtype` are specified (or if\n`dtype` is an ndarray sub-class), then the fill value is preserved.\nFinally, if `fill_value` is specified, but `dtype` is not, the fill\nvalue is set to the specified value.\n\nFor ``a.view(some_dtype)``, if ``some_dtype`` has a different number of\nbytes per entry than the previous dtype (for example, converting a\nregular array to a structured array), then the behavior of the view\ncannot be predicted just from the superficial appearance of ``a`` (shown\nby ``print(a)``). It also depends on exactly how ``a`` is stored in\nmemory. Therefore if ``a`` is C-ordered versus fortran-ordered, versus\ndefined as a slice or transpose, etc., the view may give different\nresults.", "id": "f18992:c13:m4"}
{"signature": "def outer (self, a, b):", "body": "ma = getmask(a)<EOL>mb = getmask(b)<EOL>if ma is nomask and mb is nomask:<EOL><INDENT>m = nomask<EOL><DEDENT>else:<EOL><INDENT>ma = getmaskarray(a)<EOL>mb = getmaskarray(b)<EOL>m = logical_or.outer(ma, mb)<EOL><DEDENT>result = self.ufunc.outer(filled(a), filled(b))<EOL>if not isinstance(result, MaskedArray):<EOL><INDENT>result = result.view(MaskedArray)<EOL><DEDENT>result._mask = m<EOL>return result<EOL>", "docstring": "Return the function applied to the outer product of a and b.", "id": "f18992:c16:m2"}
{"signature": "def __div__(self, other):", "body": "return divide(self, other)<EOL>", "docstring": "Divide other into self, and return a new masked array.", "id": "f18992:c13:m36"}
{"signature": "def __rfloordiv__(self, other):", "body": "return floor_divide(other, self)<EOL>", "docstring": "Divide other into self, and return a new masked array.", "id": "f18992:c13:m40"}
{"signature": "def array(data, dtype=None, copy=False, order=False,<EOL>mask=nomask, fill_value=None,<EOL>keep_mask=True, hard_mask=False, shrink=True, subok=True, ndmin=<NUM_LIT:0>,<EOL>):", "body": "<EOL>return MaskedArray(data, mask=mask, dtype=dtype, copy=copy, subok=subok,<EOL>keep_mask=keep_mask, hard_mask=hard_mask,<EOL>fill_value=fill_value, ndmin=ndmin, shrink=shrink)<EOL>", "docstring": "array(data, dtype=None, copy=False, order=False, mask=nomask,\n             fill_value=None, keep_mask=True, hard_mask=False, shrink=True,\n             subok=True, ndmin=0)\n\n    Acts as shortcut to MaskedArray, with options in a different order\n    for convenience.  And backwards compatibility...", "id": "f18992:m43"}
{"signature": "def masked_less_equal(x, value, copy=True):", "body": "return masked_where(less_equal(x, value), x, copy=copy)<EOL>", "docstring": "Mask an array where less than or equal to a given value.\n\nThis function is a shortcut to ``masked_where``, with\n`condition` = (x <= value).\n\nSee Also\n--------\nmasked_where : Mask where a condition is met.\n\nExamples\n--------\n>>> import numpy.ma as ma\n>>> a = np.arange(4)\n>>> a\narray([0, 1, 2, 3])\n>>> ma.masked_less_equal(a, 2)\nmasked_array(data = [-- -- -- 3],\n      mask = [ True  True  True False],\n      fill_value=999999)", "id": "f18992:m30"}
{"signature": "def concatenate(arrays, axis=<NUM_LIT:0>):", "body": "d = np.concatenate([getdata(a) for a in arrays], axis)<EOL>rcls = get_masked_subclass(*arrays)<EOL>data = d.view(rcls)<EOL>for x in arrays:<EOL><INDENT>if getmask(x) is not nomask:<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return data<EOL><DEDENT>dm = np.concatenate([getmaskarray(a) for a in arrays], axis)<EOL><INDENT>shrink = numpy.logical_or.reduce([getattr(a,'<STR_LIT>',True) for a in arrays])<EOL>if shrink and not dm.any():<EOL><DEDENT>if not dm.dtype.fields and not dm.any():<EOL><INDENT>data._mask = nomask<EOL><DEDENT>else:<EOL><INDENT>data._mask = dm.reshape(d.shape)<EOL><DEDENT>return data<EOL>", "docstring": "Concatenate a sequence of arrays along the given axis.\n\nParameters\n----------\narrays : sequence of array_like\n    The arrays must have the same shape, except in the dimension\n    corresponding to `axis` (the first, by default).\naxis : int, optional\n    The axis along which the arrays will be joined. Default is 0.\n\nReturns\n-------\nresult : MaskedArray\n    The concatenated array with any masked entries preserved.\n\nSee Also\n--------\nnumpy.concatenate : Equivalent function in the top-level NumPy module.\n\nExamples\n--------\n>>> import numpy.ma as ma\n>>> a = ma.arange(3)\n>>> a[1] = ma.masked\n>>> b = ma.arange(2, 5)\n>>> a\nmasked_array(data = [0 -- 2],\n             mask = [False  True False],\n       fill_value = 999999)\n>>> b\nmasked_array(data = [2 3 4],\n             mask = False,\n       fill_value = 999999)\n>>> ma.concatenate([a, b])\nmasked_array(data = [0 -- 2 2 3 4],\n             mask = [False  True False False False False],\n       fill_value = 999999)", "id": "f18992:m55"}
{"signature": "def filled(self, fill_value=None):", "body": "m = self._mask<EOL>if m is nomask:<EOL><INDENT>return self._data<EOL><DEDENT>if fill_value is None:<EOL><INDENT>fill_value = self.fill_value<EOL><DEDENT>else:<EOL><INDENT>fill_value = _check_fill_value(fill_value, self.dtype)<EOL><DEDENT>if self is masked_singleton:<EOL><INDENT>return np.asanyarray(fill_value)<EOL><DEDENT>if m.dtype.names:<EOL><INDENT>result = self._data.copy('<STR_LIT>')<EOL>_recursive_filled(result, self._mask, fill_value)<EOL><DEDENT>elif not m.any():<EOL><INDENT>return self._data<EOL><DEDENT>else:<EOL><INDENT>result = self._data.copy('<STR_LIT>')<EOL>try:<EOL><INDENT>np.copyto(result, fill_value, where=m)<EOL><DEDENT>except (TypeError, AttributeError):<EOL><INDENT>fill_value = narray(fill_value, dtype=object)<EOL>d = result.astype(object)<EOL>result = np.choose(m, (d, fill_value))<EOL><DEDENT>except IndexError:<EOL><INDENT>if self._data.shape:<EOL><INDENT>raise<EOL><DEDENT>elif m:<EOL><INDENT>result = np.array(fill_value, dtype=self.dtype)<EOL><DEDENT>else:<EOL><INDENT>result = self._data<EOL><DEDENT><DEDENT><DEDENT>return result<EOL>", "docstring": "Return a copy of self, with masked values filled with a given value.\n\nParameters\n----------\nfill_value : scalar, optional\n    The value to use for invalid entries (None by default).\n    If None, the `fill_value` attribute of the array is used instead.\n\nReturns\n-------\nfilled_array : ndarray\n    A copy of ``self`` with invalid entries replaced by *fill_value*\n    (be it the function argument or the attribute of ``self``.\n\nNotes\n-----\nThe result is **not** a MaskedArray!\n\nExamples\n--------\n>>> x = np.ma.array([1,2,3,4,5], mask=[0,0,1,0,1], fill_value=-999)\n>>> x.filled()\narray([1, 2, -999, 4, -999])\n>>> type(x.filled())\n<type 'numpy.ndarray'>\n\nSubclassing is preserved. This means that if the data part of the masked\narray is a matrix, `filled` returns a matrix:\n\n>>> x = np.ma.array(np.matrix([[1, 2], [3, 4]]), mask=[[0, 1], [1, 0]])\n>>> x.filled()\nmatrix([[     1, 999999],\n        [999999,      4]])", "id": "f18992:c13:m23"}
{"signature": "def mini(self, axis=None):", "body": "if axis is None:<EOL><INDENT>return minimum(self)<EOL><DEDENT>else:<EOL><INDENT>return minimum.reduce(self, axis)<EOL><DEDENT>", "docstring": "Return the array minimum along the specified axis.\n\nParameters\n----------\naxis : int, optional\n    The axis along which to find the minima. Default is None, in which case\n    the minimum value in the whole array is returned.\n\nReturns\n-------\nmin : scalar or MaskedArray\n    If `axis` is None, the result is a scalar. Otherwise, if `axis` is\n    given and the array is at least 2-D, the result is a masked array with\n    dimension one smaller than the array on which `mini` is called.\n\nExamples\n--------\n>>> x = np.ma.array(np.arange(6), mask=[0 ,1, 0, 0, 0 ,1]).reshape(3, 2)\n>>> print x\n[[0 --]\n [2 3]\n [4 --]]\n>>> x.mini()\n0\n>>> x.mini(axis=0)\nmasked_array(data = [0 3],\n             mask = [False False],\n       fill_value = 999999)\n>>> print x.mini(axis=1)\n[0 2 4]", "id": "f18992:c13:m79"}
{"signature": "def default_fill_value(obj):", "body": "if hasattr(obj, '<STR_LIT>'):<EOL><INDENT>defval = _check_fill_value(None, obj.dtype)<EOL><DEDENT>elif isinstance(obj, np.dtype):<EOL><INDENT>if obj.subdtype:<EOL><INDENT>defval = default_filler.get(obj.subdtype[<NUM_LIT:0>].kind, '<STR_LIT:?>')<EOL><DEDENT>elif obj.kind in '<STR_LIT>':<EOL><INDENT>defval = default_filler.get(obj.str[<NUM_LIT:1>:], '<STR_LIT:?>')<EOL><DEDENT>else:<EOL><INDENT>defval = default_filler.get(obj.kind, '<STR_LIT:?>')<EOL><DEDENT><DEDENT>elif isinstance(obj, float):<EOL><INDENT>defval = default_filler['<STR_LIT:f>']<EOL><DEDENT>elif isinstance(obj, int) or isinstance(obj, long):<EOL><INDENT>defval = default_filler['<STR_LIT:i>']<EOL><DEDENT>elif isinstance(obj, str):<EOL><INDENT>defval = default_filler['<STR_LIT:S>']<EOL><DEDENT>elif isinstance(obj, unicode):<EOL><INDENT>defval = default_filler['<STR_LIT>']<EOL><DEDENT>elif isinstance(obj, complex):<EOL><INDENT>defval = default_filler['<STR_LIT:c>']<EOL><DEDENT>else:<EOL><INDENT>defval = default_filler['<STR_LIT:O>']<EOL><DEDENT>return defval<EOL>", "docstring": "Return the default fill value for the argument object.\n\nThe default filling value depends on the datatype of the input\narray or the type of the input scalar:\n\n   ========  ========\n   datatype  default\n   ========  ========\n   bool      True\n   int       999999\n   float     1.e20\n   complex   1.e20+0j\n   object    '?'\n   string    'N/A'\n   ========  ========\n\n\nParameters\n----------\nobj : ndarray, dtype or scalar\n    The array data-type or scalar for which the default fill value\n    is returned.\n\nReturns\n-------\nfill_value : scalar\n    The default fill value.\n\nExamples\n--------\n>>> np.ma.default_fill_value(1)\n999999\n>>> np.ma.default_fill_value(np.array([1.1, 2., np.pi]))\n1e+20\n>>> np.ma.default_fill_value(np.dtype(complex))\n(1e+20+0j)", "id": "f18992:m2"}
{"signature": "def make_mask(m, copy=False, shrink=True, dtype=MaskType):", "body": "if m is nomask:<EOL><INDENT>return nomask<EOL><DEDENT>elif isinstance(m, ndarray):<EOL><INDENT>m = filled(m, True)<EOL>dtype = make_mask_descr(dtype)<EOL>if m.dtype == dtype:<EOL><INDENT>if copy:<EOL><INDENT>result = m.copy()<EOL><DEDENT>else:<EOL><INDENT>result = m<EOL><DEDENT><DEDENT>else:<EOL><INDENT>result = np.array(m, dtype=dtype, copy=copy)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>result = np.array(filled(m, True), dtype=MaskType)<EOL><DEDENT>if shrink and (not result.dtype.names) and (not result.any()):<EOL><INDENT>return nomask<EOL><DEDENT>else:<EOL><INDENT>return result<EOL><DEDENT>", "docstring": "Create a boolean mask from an array.\n\nReturn `m` as a boolean mask, creating a copy if necessary or requested.\nThe function can accept any sequence that is convertible to integers,\nor ``nomask``.  Does not require that contents must be 0s and 1s, values\nof 0 are interepreted as False, everything else as True.\n\nParameters\n----------\nm : array_like\n    Potential mask.\ncopy : bool, optional\n    Whether to return a copy of `m` (True) or `m` itself (False).\nshrink : bool, optional\n    Whether to shrink `m` to ``nomask`` if all its values are False.\ndtype : dtype, optional\n    Data-type of the output mask. By default, the output mask has\n    a dtype of MaskType (bool). If the dtype is flexible, each field\n    has a boolean dtype.\n\nReturns\n-------\nresult : ndarray\n    A boolean mask derived from `m`.\n\nExamples\n--------\n>>> import numpy.ma as ma\n>>> m = [True, False, True, True]\n>>> ma.make_mask(m)\narray([ True, False,  True,  True], dtype=bool)\n>>> m = [1, 0, 1, 1]\n>>> ma.make_mask(m)\narray([ True, False,  True,  True], dtype=bool)\n>>> m = [1, 0, 2, -3]\n>>> ma.make_mask(m)\narray([ True, False,  True,  True], dtype=bool)\n\nEffect of the `shrink` parameter.\n\n>>> m = np.zeros(4)\n>>> m\narray([ 0.,  0.,  0.,  0.])\n>>> ma.make_mask(m)\nFalse\n>>> ma.make_mask(m, shrink=False)\narray([False, False, False, False], dtype=bool)\n\nUsing a flexible `dtype`.\n\n>>> m = [1, 0, 1, 1]\n>>> n = [0, 1, 0, 0]\n>>> arr = []\n>>> for man, mouse in zip(m, n):\n...     arr.append((man, mouse))\n>>> arr\n[(1, 0), (0, 1), (1, 0), (1, 0)]\n>>> dtype = np.dtype({'names':['man', 'mouse'],\n                      'formats':[np.int, np.int]})\n>>> arr = np.array(arr, dtype=dtype)\n>>> arr\narray([(1, 0), (0, 1), (1, 0), (1, 0)],\n      dtype=[('man', '<i4'), ('mouse', '<i4')])\n>>> ma.make_mask(arr, dtype=dtype)\narray([(True, False), (False, True), (True, False), (True, False)],\n      dtype=[('man', '|b1'), ('mouse', '|b1')])", "id": "f18992:m21"}
{"signature": "def loads(strg):", "body": "return pickle.loads(strg)<EOL>", "docstring": "Load a pickle from the current string.\n\nThe result of ``cPickle.loads(strg)`` is returned.\n\nParameters\n----------\nstrg : str\n    The string to load.\n\nSee Also\n--------\ndumps : Return a string corresponding to the pickling of a masked array.", "id": "f18992:m81"}
{"signature": "def expand_dims(x, axis):", "body": "result = n_expand_dims(x, axis)<EOL>if isinstance(x, MaskedArray):<EOL><INDENT>new_shape = result.shape<EOL>result = x.view()<EOL>result.shape = new_shape<EOL>if result._mask is not nomask:<EOL><INDENT>result._mask.shape = new_shape<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Expand the shape of an array.\n\nExpands the shape of the array by including a new axis before the one\nspecified by the `axis` parameter. This function behaves the same as\n`numpy.expand_dims` but preserves masked elements.\n\nSee Also\n--------\nnumpy.expand_dims : Equivalent function in top-level NumPy module.\n\nExamples\n--------\n>>> import numpy.ma as ma\n>>> x = ma.array([1, 2, 4])\n>>> x[1] = ma.masked\n>>> x\nmasked_array(data = [1 -- 4],\n             mask = [False  True False],\n       fill_value = 999999)\n>>> np.expand_dims(x, axis=0)\narray([[1, 2, 4]])\n>>> ma.expand_dims(x, axis=0)\nmasked_array(data =\n [[1 -- 4]],\n             mask =\n [[False  True False]],\n       fill_value = 999999)\n\nThe same result can be achieved using slicing syntax with `np.newaxis`.\n\n>>> x[np.newaxis, :]\nmasked_array(data =\n [[1 -- 4]],\n             mask =\n [[False  True False]],\n       fill_value = 999999)", "id": "f18992:m58"}
{"signature": "def _set_flat (self, value):", "body": "y = self.ravel()<EOL>y[:] = value<EOL>", "docstring": "Set a flattened version of self to value.", "id": "f18992:c13:m20"}
{"signature": "def __radd__(self, other):", "body": "return add(self, other)<EOL>", "docstring": "Add other to self, and return a new masked array.", "id": "f18992:c13:m31"}
{"signature": "def put(a, indices, values, mode='<STR_LIT>'):", "body": "<EOL>try:<EOL><INDENT>return a.put(indices, values, mode=mode)<EOL><DEDENT>except AttributeError:<EOL><INDENT>return narray(a, copy=False).put(indices, values, mode=mode)<EOL><DEDENT>", "docstring": "Set storage-indexed locations to corresponding values.\n\nThis function is equivalent to `MaskedArray.put`, see that method\nfor details.\n\nSee Also\n--------\nMaskedArray.put", "id": "f18992:m61"}
{"signature": "def resize(self, newshape, refcheck=True, order=False):", "body": "<EOL><INDENT>try:<EOL><INDENT>ndarray.resize(self, newshape, refcheck=refcheck)<EOL>if self.mask is not nomask:<EOL><INDENT>self._mask.resize(newshape, refcheck=refcheck)<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>return None<EOL><DEDENT>errmsg = \"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"<EOL>raise ValueError(errmsg)<EOL>", "docstring": ".. warning::\n\n    This method does nothing, except raise a ValueError exception. A\n    masked array does not own its data and therefore cannot safely be\n    resized in place. Use the `numpy.ma.resize` function instead.\n\nThis method is difficult to implement safely and may be deprecated in\nfuture releases of NumPy.", "id": "f18992:c13:m57"}
{"signature": "def transpose(a, axes=None):", "body": "<EOL>try:<EOL><INDENT>return a.transpose(axes)<EOL><DEDENT>except AttributeError:<EOL><INDENT>return narray(a, copy=False).transpose(axes).view(MaskedArray)<EOL><DEDENT>", "docstring": "Permute the dimensions of an array.\n\nThis function is exactly equivalent to `numpy.transpose`.\n\nSee Also\n--------\nnumpy.transpose : Equivalent function in top-level NumPy module.\n\nExamples\n--------\n>>> import numpy.ma as ma\n>>> x = ma.arange(4).reshape((2,2))\n>>> x[1, 1] = ma.masked\n>>>> x\nmasked_array(data =\n [[0 1]\n [2 --]],\n             mask =\n [[False False]\n [False  True]],\n       fill_value = 999999)\n>>> ma.transpose(x)\nmasked_array(data =\n [[0 2]\n [1 --]],\n             mask =\n [[False False]\n [False  True]],\n       fill_value = 999999)", "id": "f18992:m63"}
{"signature": "def where (condition, x=None, y=None):", "body": "if x is None and y is None:<EOL><INDENT>return filled(condition, <NUM_LIT:0>).nonzero()<EOL><DEDENT>elif x is None or y is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>fc = filled(condition, <NUM_LIT:0>).astype(MaskType)<EOL>notfc = np.logical_not(fc)<EOL>xv = getdata(x)<EOL>yv = getdata(y)<EOL>if x is masked:<EOL><INDENT>ndtype = yv.dtype<EOL><DEDENT>elif y is masked:<EOL><INDENT>ndtype = xv.dtype<EOL><DEDENT>else:<EOL><INDENT>ndtype = np.find_common_type([xv.dtype, yv.dtype], [])<EOL><DEDENT>d = np.empty(fc.shape, dtype=ndtype).view(MaskedArray)<EOL>_data = d._data<EOL>np.copyto(_data, xv.astype(ndtype), where=fc)<EOL>np.copyto(_data, yv.astype(ndtype), where=notfc)<EOL>_mask = d._mask = np.zeros(fc.shape, dtype=MaskType)<EOL>np.copyto(_mask, getmask(x), where=fc)<EOL>np.copyto(_mask, getmask(y), where=notfc)<EOL>_mask |= getmaskarray(condition)<EOL>if not _mask.any():<EOL><INDENT>d._mask = nomask<EOL><DEDENT>return d<EOL>", "docstring": "Return a masked array with elements from x or y, depending on condition.\n\nReturns a masked array, shaped like condition, where the elements\nare from `x` when `condition` is True, and from `y` otherwise.\nIf neither `x` nor `y` are given, the function returns a tuple of\nindices where `condition` is True (the result of\n``condition.nonzero()``).\n\nParameters\n----------\ncondition : array_like, bool\n    The condition to meet. For each True element, yield the corresponding\n    element from `x`, otherwise from `y`.\nx, y : array_like, optional\n    Values from which to choose. `x` and `y` need to have the same shape\n    as condition, or be broadcast-able to that shape.\n\nReturns\n-------\nout : MaskedArray or tuple of ndarrays\n    The resulting masked array if `x` and `y` were given, otherwise\n    the result of ``condition.nonzero()``.\n\nSee Also\n--------\nnumpy.where : Equivalent function in the top-level NumPy module.\n\nExamples\n--------\n>>> x = np.ma.array(np.arange(9.).reshape(3, 3), mask=[[0, 1, 0],\n...                                                    [1, 0, 1],\n...                                                    [0, 1, 0]])\n>>> print x\n[[0.0 -- 2.0]\n [-- 4.0 --]\n [6.0 -- 8.0]]\n>>> np.ma.where(x > 5)    # return the indices where x > 5\n(array([2, 2]), array([0, 2]))\n\n>>> print np.ma.where(x > 5, x, -3.1416)\n[[-3.1416 -- -3.1416]\n [-- -3.1416 --]\n [6.0 -- 8.0]]", "id": "f18992:m69"}
{"signature": "def set_display (self, s):", "body": "self._display = s<EOL>", "docstring": "Set the string to print for masked values.", "id": "f18992:c10:m2"}
{"signature": "def argmax(self, axis=None, fill_value=None, out=None):", "body": "if fill_value is None:<EOL><INDENT>fill_value = maximum_fill_value(self._data)<EOL><DEDENT>d = self.filled(fill_value).view(ndarray)<EOL>return d.argmax(axis, out=out)<EOL>", "docstring": "Returns array of indices of the maximum values along the given axis.\nMasked values are treated as if they had the value fill_value.\n\nParameters\n----------\naxis : {None, integer}\n    If None, the index is into the flattened array, otherwise along\n    the specified axis\nfill_value : {var}, optional\n    Value used to fill in the masked values.  If None, the output of\n    maximum_fill_value(self._data) is used instead.\nout : {None, array}, optional\n    Array into which the result can be placed. Its type is preserved\n    and it must be of the right shape to hold the output.\n\nReturns\n-------\nindex_array : {integer_array}\n\nExamples\n--------\n>>> a = np.arange(6).reshape(2,3)\n>>> a.argmax()\n5\n>>> a.argmax(0)\narray([1, 1, 1])\n>>> a.argmax(1)\narray([2, 2])", "id": "f18992:c13:m76"}
{"signature": "def __rtruediv__(self, other):", "body": "return true_divide(other, self)<EOL>", "docstring": "Divide other into self, and return a new masked array.", "id": "f18992:c13:m38"}
{"signature": "def allequal (a, b, fill_value=True):", "body": "m = mask_or(getmask(a), getmask(b))<EOL>if m is nomask:<EOL><INDENT>x = getdata(a)<EOL>y = getdata(b)<EOL>d = umath.equal(x, y)<EOL>return d.all()<EOL><DEDENT>elif fill_value:<EOL><INDENT>x = getdata(a)<EOL>y = getdata(b)<EOL>d = umath.equal(x, y)<EOL>dm = array(d, mask=m, copy=False)<EOL>return dm.filled(True).all(None)<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Return True if all entries of a and b are equal, using\nfill_value as a truth value where either or both are masked.\n\nParameters\n----------\na, b : array_like\n    Input arrays to compare.\nfill_value : bool, optional\n    Whether masked values in a or b are considered equal (True) or not\n    (False).\n\nReturns\n-------\ny : bool\n    Returns True if the two arrays are equal within the given\n    tolerance, False otherwise. If either array contains NaN,\n    then False is returned.\n\nSee Also\n--------\nall, any\nnumpy.ma.allclose\n\nExamples\n--------\n>>> a = ma.array([1e10, 1e-7, 42.0], mask=[0, 0, 1])\n>>> a\nmasked_array(data = [10000000000.0 1e-07 --],\n      mask = [False False  True],\n      fill_value=1e+20)\n\n>>> b = array([1e10, 1e-7, -42.0])\n>>> b\narray([  1.00000000e+10,   1.00000000e-07,  -4.20000000e+01])\n>>> ma.allequal(a, b, fill_value=False)\nFalse\n>>> ma.allequal(a, b)\nTrue", "id": "f18992:m74"}
{"signature": "def dumps(a):", "body": "return pickle.dumps(a)<EOL>", "docstring": "Return a string corresponding to the pickling of a masked array.\n\nThis is a wrapper around ``cPickle.dumps``.\n\nParameters\n----------\na : MaskedArray\n    The array for which the string representation of the pickle is\n    returned.", "id": "f18992:m79"}
{"signature": "def tolist(self):", "body": "_mask = self._mask<EOL>if _mask is nomask:<EOL><INDENT>return self._data.tolist()<EOL><DEDENT>result = []<EOL>for (d, m) in zip(self._data, self._mask):<EOL><INDENT>if m:<EOL><INDENT>result.append(None)<EOL><DEDENT>else:<EOL><INDENT>result.append(d.item())<EOL><DEDENT><DEDENT>return tuple(result)<EOL>", "docstring": "Transforms the mvoid object into a tuple.\n\nMasked fields are replaced by None.\n\nReturns\n-------\nreturned_tuple\n    Tuple of fields", "id": "f18992:c14:m9"}
{"signature": "def getdoc(self):", "body": "doc = getattr(self._func, '<STR_LIT>', None)<EOL>sig = get_object_signature(self._func)<EOL>if doc:<EOL><INDENT>if sig:<EOL><INDENT>sig = \"<STR_LIT>\" % (self._func.__name__, sig)<EOL><DEDENT>doc = sig + doc<EOL><DEDENT>return doc<EOL>", "docstring": "Return the doc of the function (from the doc of the method).", "id": "f18992:c20:m1"}
{"signature": "def anom(self, axis=None, dtype=None):", "body": "m = self.mean(axis, dtype)<EOL>if not axis:<EOL><INDENT>return (self - m)<EOL><DEDENT>else:<EOL><INDENT>return (self - expand_dims(m, axis))<EOL><DEDENT>", "docstring": "Compute the anomalies (deviations from the arithmetic mean)\nalong the given axis.\n\nReturns an array of anomalies, with the same shape as the input and\nwhere the arithmetic mean is computed along the given axis.\n\nParameters\n----------\naxis : int, optional\n    Axis over which the anomalies are taken.\n    The default is to use the mean of the flattened array as reference.\ndtype : dtype, optional\n    Type to use in computing the variance. For arrays of integer type\n     the default is float32; for arrays of float types it is the same as\n     the array type.\n\nSee Also\n--------\nmean : Compute the mean of the array.\n\nExamples\n--------\n>>> a = np.ma.array([1,2,3])\n>>> a.anom()\nmasked_array(data = [-1.  0.  1.],\n             mask = False,\n       fill_value = 1e+20)", "id": "f18992:c13:m70"}
{"signature": "def masked_values(x, value, rtol=<NUM_LIT>, atol=<NUM_LIT>, copy=True, shrink=True):", "body": "mabs = umath.absolute<EOL>xnew = filled(x, value)<EOL>if issubclass(xnew.dtype.type, np.floating):<EOL><INDENT>condition = umath.less_equal(mabs(xnew - value), atol + rtol * mabs(value))<EOL>mask = getattr(x, '<STR_LIT>', nomask)<EOL><DEDENT>else:<EOL><INDENT>condition = umath.equal(xnew, value)<EOL>mask = nomask<EOL><DEDENT>mask = mask_or(mask, make_mask(condition, shrink=shrink))<EOL>return masked_array(xnew, mask=mask, copy=copy, fill_value=value)<EOL>", "docstring": "Mask using floating point equality.\n\nReturn a MaskedArray, masked where the data in array `x` are approximately\nequal to `value`, i.e. where the following condition is True\n\n(abs(x - value) <= atol+rtol*abs(value))\n\nThe fill_value is set to `value` and the mask is set to ``nomask`` if\npossible.  For integers, consider using ``masked_equal``.\n\nParameters\n----------\nx : array_like\n    Array to mask.\nvalue : float\n    Masking value.\nrtol : float, optional\n    Tolerance parameter.\natol : float, optional\n    Tolerance parameter (1e-8).\ncopy : bool, optional\n    Whether to return a copy of `x`.\nshrink : bool, optional\n    Whether to collapse a mask full of False to ``nomask``.\n\nReturns\n-------\nresult : MaskedArray\n    The result of masking `x` where approximately equal to `value`.\n\nSee Also\n--------\nmasked_where : Mask where a condition is met.\nmasked_equal : Mask where equal to a given value (integers).\n\nExamples\n--------\n>>> import numpy.ma as ma\n>>> x = np.array([1, 1.1, 2, 1.1, 3])\n>>> ma.masked_values(x, 1.1)\nmasked_array(data = [1.0 -- 2.0 -- 3.0],\n      mask = [False  True False  True False],\n      fill_value=1.1)\n\nNote that `mask` is set to ``nomask`` if possible.\n\n>>> ma.masked_values(x, 1.5)\nmasked_array(data = [ 1.   1.1  2.   1.1  3. ],\n      mask = False,\n      fill_value=1.5)\n\nFor integers, the fill value will be different in general to the\nresult of ``masked_equal``.\n\n>>> x = np.arange(5)\n>>> x\narray([0, 1, 2, 3, 4])\n>>> ma.masked_values(x, 2)\nmasked_array(data = [0 1 -- 3 4],\n      mask = [False False  True False False],\n      fill_value=2)\n>>> ma.masked_equal(x, 2)\nmasked_array(data = [0 1 -- 3 4],\n      mask = [False False  True False False],\n      fill_value=999999)", "id": "f18992:m36"}
{"signature": "def __init__(self, eps):", "body": "self.eps = eps<EOL>", "docstring": "domain_tan(eps) = true where abs(cos(x)) < eps)", "id": "f18992:c3:m0"}
{"signature": "def __itruediv__(self, other):", "body": "other_data = getdata(other)<EOL>dom_mask = _DomainSafeDivide().__call__(self._data, other_data)<EOL>other_mask = getmask(other)<EOL>new_mask = mask_or(other_mask, dom_mask)<EOL>if dom_mask.any():<EOL><INDENT>(_, fval) = ufunc_fills[np.true_divide]<EOL>other_data = np.where(dom_mask, fval, other_data)<EOL>", "docstring": "True divide self by other in-place.", "id": "f18992:c13:m48"}
{"signature": "def power(a, b, third=None):", "body": "if third is not None:<EOL><INDENT>raise MaskError(\"<STR_LIT>\")<EOL><DEDENT>ma = getmask(a)<EOL>mb = getmask(b)<EOL>m = mask_or(ma, mb)<EOL>fa = getdata(a)<EOL>fb = getdata(b)<EOL>if isinstance(a, MaskedArray):<EOL><INDENT>basetype = type(a)<EOL><DEDENT>else:<EOL><INDENT>basetype = MaskedArray<EOL><DEDENT>with np.errstate(divide='<STR_LIT:ignore>', invalid='<STR_LIT:ignore>'):<EOL><INDENT>result = np.where(m, fa, umath.power(fa, fb)).view(basetype)<EOL><DEDENT>result._update_from(a)<EOL>invalid = np.logical_not(np.isfinite(result.view(ndarray)))<EOL>if m is not nomask:<EOL><INDENT>if not (result.ndim):<EOL><INDENT>return masked<EOL><DEDENT>result._mask = np.logical_or(m, invalid)<EOL><DEDENT>if invalid.any():<EOL><INDENT>if not result.ndim:<EOL><INDENT>return masked<EOL><DEDENT>elif result._mask is nomask:<EOL><INDENT>result._mask = invalid<EOL><DEDENT>result._data[invalid] = result.fill_value<EOL><DEDENT>return result<EOL>", "docstring": "Returns element-wise base array raised to power from second array.\n\nThis is the masked array version of `numpy.power`. For details see\n`numpy.power`.\n\nSee Also\n--------\nnumpy.power\n\nNotes\n-----\nThe *out* argument to `numpy.power` is not supported, `third` has to be\nNone.", "id": "f18992:m49"}
{"signature": "def masked_object(x, value, copy=True, shrink=True):", "body": "if isMaskedArray(x):<EOL><INDENT>condition = umath.equal(x._data, value)<EOL>mask = x._mask<EOL><DEDENT>else:<EOL><INDENT>condition = umath.equal(np.asarray(x), value)<EOL>mask = nomask<EOL><DEDENT>mask = mask_or(mask, make_mask(condition, shrink=shrink))<EOL>return masked_array(x, mask=mask, copy=copy, fill_value=value)<EOL>", "docstring": "Mask the array `x` where the data are exactly equal to value.\n\nThis function is similar to `masked_values`, but only suitable\nfor object arrays: for floating point, use `masked_values` instead.\n\nParameters\n----------\nx : array_like\n    Array to mask\nvalue : object\n    Comparison value\ncopy : {True, False}, optional\n    Whether to return a copy of `x`.\nshrink : {True, False}, optional\n    Whether to collapse a mask full of False to nomask\n\nReturns\n-------\nresult : MaskedArray\n    The result of masking `x` where equal to `value`.\n\nSee Also\n--------\nmasked_where : Mask where a condition is met.\nmasked_equal : Mask where equal to a given value (integers).\nmasked_values : Mask using floating point equality.\n\nExamples\n--------\n>>> import numpy.ma as ma\n>>> food = np.array(['green_eggs', 'ham'], dtype=object)\n>>> # don't eat spoiled food\n>>> eat = ma.masked_object(food, 'green_eggs')\n>>> print eat\n[-- ham]\n>>> # plain ol` ham is boring\n>>> fresh_food = np.array(['cheese', 'ham', 'pineapple'], dtype=object)\n>>> eat = ma.masked_object(fresh_food, 'green_eggs')\n>>> print eat\n[cheese ham pineapple]\n\nNote that `mask` is set to ``nomask`` if possible.\n\n>>> eat\nmasked_array(data = [cheese ham pineapple],\n      mask = False,\n      fill_value=?)", "id": "f18992:m35"}
{"signature": "def unshare_mask(self):", "body": "if self._sharedmask:<EOL><INDENT>self._mask = self._mask.copy()<EOL>self._sharedmask = False<EOL><DEDENT>return self<EOL>", "docstring": "Copy the mask and set the sharedmask flag to False.\n\nWhether the mask is shared between masked arrays can be seen from\nthe `sharedmask` property. `unshare_mask` ensures the mask is not shared.\nA copy of the mask is only made if it was shared.\n\nSee Also\n--------\nsharedmask", "id": "f18992:c13:m16"}
{"signature": "def __mul__(self, other):", "body": "return multiply(self, other)<EOL>", "docstring": "Multiply other by self, and return a new masked array.", "id": "f18992:c13:m34"}
{"signature": "def flatten_mask(mask):", "body": "<EOL>def _flatmask(mask):<EOL><INDENT>\"<STR_LIT>\"<EOL>mnames = mask.dtype.names<EOL>if mnames:<EOL><INDENT>return [flatten_mask(mask[name]) for name in mnames]<EOL><DEDENT>else:<EOL><INDENT>return mask<EOL><DEDENT><DEDENT>def _flatsequence(sequence):<EOL><INDENT>\"<STR_LIT>\"<EOL>try:<EOL><INDENT>for element in sequence:<EOL><INDENT>if hasattr(element, '<STR_LIT>'):<EOL><INDENT>for f in _flatsequence(element):<EOL><INDENT>yield f<EOL><DEDENT><DEDENT>else:<EOL><INDENT>yield element<EOL><DEDENT><DEDENT><DEDENT>except TypeError:<EOL><INDENT>yield sequence<EOL><DEDENT><DEDENT>mask = np.asarray(mask)<EOL>flattened = _flatsequence(_flatmask(mask))<EOL>return np.array([_ for _ in flattened], dtype=bool)<EOL>", "docstring": "Returns a completely flattened version of the mask, where nested fields\nare collapsed.\n\nParameters\n----------\nmask : array_like\n    Input array, which will be interpreted as booleans.\n\nReturns\n-------\nflattened_mask : ndarray of bools\n    The flattened input.\n\nExamples\n--------\n>>> mask = np.array([0, 0, 1], dtype=np.bool)\n>>> flatten_mask(mask)\narray([False, False,  True], dtype=bool)\n\n>>> mask = np.array([(0, 0), (0, 1)], dtype=[('a', bool), ('b', bool)])\n>>> flatten_mask(mask)\narray([False, False, False,  True], dtype=bool)\n\n>>> mdtype = [('a', bool), ('b', [('ba', bool), ('bb', bool)])]\n>>> mask = np.array([(0, (0, 0)), (0, (0, 1))], dtype=mdtype)\n>>> flatten_mask(mask)\narray([False, False, False, False, False,  True], dtype=bool)", "id": "f18992:m24"}
{"signature": "def _update_from(self, obj):", "body": "if obj is not None and isinstance(obj, ndarray):<EOL><INDENT>_baseclass = type(obj)<EOL><DEDENT>else:<EOL><INDENT>_baseclass = ndarray<EOL><DEDENT>_optinfo = {}<EOL>_optinfo.update(getattr(obj, '<STR_LIT>', {}))<EOL>_optinfo.update(getattr(obj, '<STR_LIT>', {}))<EOL>if not isinstance(obj, MaskedArray):<EOL><INDENT>_optinfo.update(getattr(obj, '<STR_LIT>', {}))<EOL><DEDENT>_dict = dict(_fill_value=getattr(obj, '<STR_LIT>', None),<EOL>_hardmask=getattr(obj, '<STR_LIT>', False),<EOL>_sharedmask=getattr(obj, '<STR_LIT>', False),<EOL>_isfield=getattr(obj, '<STR_LIT>', False),<EOL>_baseclass=getattr(obj, '<STR_LIT>', _baseclass),<EOL>_optinfo=_optinfo,<EOL>_basedict=_optinfo)<EOL>self.__dict__.update(_dict)<EOL>self.__dict__.update(_optinfo)<EOL>return<EOL>", "docstring": "Copies some attributes of obj to self.", "id": "f18992:c13:m1"}
{"signature": "def __imul__(self, other):", "body": "m = getmask(other)<EOL>if self._mask is nomask:<EOL><INDENT>if m is not nomask and m.any():<EOL><INDENT>self._mask = make_mask_none(self.shape, self.dtype)<EOL>self._mask += m<EOL><DEDENT><DEDENT>elif m is not nomask:<EOL><INDENT>self._mask += m<EOL><DEDENT>ndarray.__imul__(self._data, np.where(self._mask, <NUM_LIT:1>, getdata(other)))<EOL>return self<EOL>", "docstring": "Multiply self by other in-place.", "id": "f18992:c13:m45"}
{"signature": "def ptp(obj, axis=None, out=None, fill_value=None):", "body": "try:<EOL><INDENT>return obj.ptp(axis, out=out, fill_value=fill_value)<EOL><DEDENT>except (AttributeError, TypeError):<EOL><INDENT>return asanyarray(obj).ptp(axis=axis, fill_value=fill_value, out=out)<EOL><DEDENT>", "docstring": "a.ptp(axis=None) =  a.max(axis)-a.min(axis)", "id": "f18992:m47"}
{"signature": "def assert_almost_equal(actual, desired, decimal=<NUM_LIT:7>, err_msg='<STR_LIT>', verbose=True):", "body": "if isinstance(actual, np.ndarray) or isinstance(desired, np.ndarray):<EOL><INDENT>return assert_array_almost_equal(actual, desired, decimal=decimal,<EOL>err_msg=err_msg, verbose=verbose)<EOL><DEDENT>msg = build_err_msg([actual, desired],<EOL>err_msg=err_msg, verbose=verbose)<EOL>if not round(abs(desired - actual), decimal) == <NUM_LIT:0>:<EOL><INDENT>raise AssertionError(msg)<EOL><DEDENT>", "docstring": "Asserts that two items are almost equal.\n    The test is equivalent to abs(desired-actual) < 0.5 * 10**(-decimal)", "id": "f18993:m6"}
{"signature": "def assert_array_less(x, y, err_msg='<STR_LIT>', verbose=True):", "body": "assert_array_compare(operator.__lt__, x, y,<EOL>err_msg=err_msg, verbose=verbose,<EOL>header='<STR_LIT>')<EOL>", "docstring": "Checks that x is smaller than y elementwise.", "id": "f18993:m12"}
{"signature": "def fail_if_array_equal(x, y, err_msg='<STR_LIT>', verbose=True):", "body": "def compare(x, y):<EOL><INDENT>return (not np.alltrue(approx(x, y)))<EOL><DEDENT>assert_array_compare(compare, x, y, err_msg=err_msg, verbose=verbose,<EOL>header='<STR_LIT>')<EOL>", "docstring": "Raises an assertion error if two masked arrays are not equal (elementwise).", "id": "f18993:m9"}
{"signature": "def _assert_equal_on_sequences(actual, desired, err_msg='<STR_LIT>'):", "body": "assert_equal(len(actual), len(desired), err_msg)<EOL>for k in range(len(desired)):<EOL><INDENT>assert_equal(actual[k], desired[k], '<STR_LIT>' % (k, err_msg))<EOL><DEDENT>return<EOL>", "docstring": "Asserts the equality of two non-array sequences.", "id": "f18993:m2"}
{"signature": "def check_random_directive():", "body": "", "docstring": ">>> 2+2\n<BadExample object at 0x084D05AC>  #random: may vary on your system", "id": "f18997:m0"}
{"signature": "def get_package_name(filepath):", "body": "fullpath = filepath[:]<EOL>pkg_name = []<EOL>while '<STR_LIT>' in filepath or '<STR_LIT>' in filepath:<EOL><INDENT>filepath, p2 = os.path.split(filepath)<EOL>if p2 in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>break<EOL><DEDENT>pkg_name.append(p2)<EOL><DEDENT>if not pkg_name:<EOL><INDENT>if '<STR_LIT>' in fullpath:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT><DEDENT>pkg_name.reverse()<EOL>if pkg_name[<NUM_LIT:0>].endswith('<STR_LIT>'):<EOL><INDENT>pkg_name.pop(<NUM_LIT:0>)<EOL><DEDENT>return '<STR_LIT:.>'.join(pkg_name)<EOL>", "docstring": "Given a path where a package is installed, determine its name.\n\nParameters\n----------\nfilepath : str\n    Path to a file. If the determination fails, \"numpy\" is returned.\n\nExamples\n--------\n>>> np.testing.nosetester.get_package_name('nonsense')\n'numpy'", "id": "f19000:m0"}
{"signature": "def import_nose():", "body": "fine_nose = True<EOL>minimum_nose_version = (<NUM_LIT:0>, <NUM_LIT:10>, <NUM_LIT:0>)<EOL>try:<EOL><INDENT>import nose<EOL><DEDENT>except ImportError:<EOL><INDENT>fine_nose = False<EOL><DEDENT>else:<EOL><INDENT>if nose.__versioninfo__ < minimum_nose_version:<EOL><INDENT>fine_nose = False<EOL><DEDENT><DEDENT>if not fine_nose:<EOL><INDENT>msg = '<STR_LIT>''<STR_LIT>' %minimum_nose_version<EOL>raise ImportError(msg)<EOL><DEDENT>return nose<EOL>", "docstring": "Import nose only when needed.", "id": "f19000:m1"}
{"signature": "def bench(self, label='<STR_LIT>', verbose=<NUM_LIT:1>, extra_argv=None):", "body": "print(\"<STR_LIT>\" % self.package_name)<EOL>self._show_system_info()<EOL>argv = self._test_argv(label, verbose, extra_argv)<EOL>argv += ['<STR_LIT>', r'<STR_LIT>' % os.sep]<EOL>nose = import_nose()<EOL>from .noseclasses import Unplugger<EOL>add_plugins = [Unplugger('<STR_LIT>')]<EOL>return nose.run(argv=argv, addplugins=add_plugins)<EOL>", "docstring": "Run benchmarks for module using nose.\n\nParameters\n----------\nlabel : {'fast', 'full', '', attribute identifier}, optional\n    Identifies the benchmarks to run. This can be a string to pass to\n    the nosetests executable with the '-A' option, or one of several\n    special values.  Special values are:\n    * 'fast' - the default - which corresponds to the ``nosetests -A``\n      option of 'not slow'.\n    * 'full' - fast (as above) and slow benchmarks as in the\n      'no -A' option to nosetests - this is the same as ''.\n    * None or '' - run all tests.\n    attribute_identifier - string passed directly to nosetests as '-A'.\nverbose : int, optional\n    Verbosity value for benchmark outputs, in the range 1-10. Default is 1.\nextra_argv : list, optional\n    List with any extra arguments to pass to nosetests.\n\nReturns\n-------\nsuccess : bool\n    Returns True if running the benchmarks works, False if an error\n    occurred.\n\nNotes\n-----\nBenchmarks are like tests, but have names starting with \"bench\" instead\nof \"test\", and can be found under the \"benchmarks\" sub-directory of the\nmodule.\n\nEach NumPy module exposes `bench` in its namespace to run all benchmarks\nfor it.\n\nExamples\n--------\n>>> success = np.lib.bench() #doctest: +SKIP\nRunning benchmarks for numpy.lib\n...\nusing 562341 items:\nunique:\n0.11\nunique1d:\n0.11\nratio: 1.0\nnUnique: 56230 == 56230\n...\nOK\n\n>>> success #doctest: +SKIP\nTrue", "id": "f19000:c0:m6"}
{"signature": "def _from_module(self, module, object):", "body": "if module is None:<EOL><INDENT>return True<EOL><DEDENT>elif inspect.isfunction(object):<EOL><INDENT>return module.__dict__ is object.__globals__<EOL><DEDENT>elif inspect.isbuiltin(object):<EOL><INDENT>return module.__name__ == object.__module__<EOL><DEDENT>elif inspect.isclass(object):<EOL><INDENT>return module.__name__ == object.__module__<EOL><DEDENT>elif inspect.ismethod(object):<EOL><INDENT>return module.__name__ == object.__self__.__class__.__module__<EOL><DEDENT>elif inspect.getmodule(object) is not None:<EOL><INDENT>return module is inspect.getmodule(object)<EOL><DEDENT>elif hasattr(object, '<STR_LIT>'):<EOL><INDENT>return module.__name__ == object.__module__<EOL><DEDENT>elif isinstance(object, property):<EOL><INDENT>return True <EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Return true if the given object is defined in the given\nmodule.", "id": "f19001:c0:m0"}
{"signature": "def integer_repr(x):", "body": "import numpy as np<EOL>if x.dtype == np.float32:<EOL><INDENT>return _integer_repr(x, np.int32, np.int32(-<NUM_LIT:2>**<NUM_LIT>))<EOL><DEDENT>elif x.dtype == np.float64:<EOL><INDENT>return _integer_repr(x, np.int64, np.int64(-<NUM_LIT:2>**<NUM_LIT>))<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % x.dtype)<EOL><DEDENT>", "docstring": "Return the signed-magnitude interpretation of the binary representation of\n    x.", "id": "f19002:m28"}
{"signature": "def assert_array_equal(x, y, err_msg='<STR_LIT>', verbose=True):", "body": "assert_array_compare(operator.__eq__, x, y, err_msg=err_msg,<EOL>verbose=verbose, header='<STR_LIT>')<EOL>", "docstring": "Raises an AssertionError if two array_like objects are not equal.\n\nGiven two array_like objects, check that the shape is equal and all\nelements of these objects are equal. An exception is raised at\nshape mismatch or conflicting values. In contrast to the standard usage\nin numpy, NaNs are compared like numbers, no assertion is raised if\nboth objects have NaNs in the same positions.\n\nThe usual caution for verifying equality with floating point numbers is\nadvised.\n\nParameters\n----------\nx : array_like\n    The actual object to check.\ny : array_like\n    The desired, expected object.\nerr_msg : str, optional\n    The error message to be printed in case of failure.\nverbose : bool, optional\n    If True, the conflicting values are appended to the error message.\n\nRaises\n------\nAssertionError\n    If actual and desired objects are not equal.\n\nSee Also\n--------\nassert_allclose: Compare two array_like objects for equality with desired\n                 relative and/or absolute precision.\nassert_array_almost_equal_nulp, assert_array_max_ulp, assert_equal\n\nExamples\n--------\nThe first assert does not raise an exception:\n\n>>> np.testing.assert_array_equal([1.0,2.33333,np.nan],\n...                               [np.exp(0),2.33333, np.nan])\n\nAssert fails with numerical inprecision with floats:\n\n>>> np.testing.assert_array_equal([1.0,np.pi,np.nan],\n...                               [1, np.sqrt(np.pi)**2, np.nan])\n...\n<type 'exceptions.ValueError'>:\nAssertionError:\nArrays are not equal\n<BLANKLINE>\n(mismatch 50.0%)\n x: array([ 1.        ,  3.14159265,         NaN])\n y: array([ 1.        ,  3.14159265,         NaN])\n\nUse `assert_allclose` or one of the nulp (number of floating point values)\nfunctions for these cases instead:\n\n>>> np.testing.assert_allclose([1.0,np.pi,np.nan],\n...                            [1, np.sqrt(np.pi)**2, np.nan],\n...                            rtol=1e-10, atol=0)", "id": "f19002:m11"}
{"signature": "def measure(code_str,times=<NUM_LIT:1>,label=None):", "body": "frame = sys._getframe(<NUM_LIT:1>)<EOL>locs, globs = frame.f_locals, frame.f_globals<EOL>code = compile(code_str,<EOL>'<STR_LIT>' % label,<EOL>'<STR_LIT>')<EOL>i = <NUM_LIT:0><EOL>elapsed = jiffies()<EOL>while i < times:<EOL><INDENT>i += <NUM_LIT:1><EOL>exec(code, globs, locs)<EOL><DEDENT>elapsed = jiffies() - elapsed<EOL>return <NUM_LIT>*elapsed<EOL>", "docstring": "Return elapsed time for executing code in the namespace of the caller.\n\nThe supplied code string is compiled with the Python builtin ``compile``.\nThe precision of the timing is 10 milli-seconds. If the code will execute\nfast on this timescale, it can be executed many times to get reasonable\ntiming accuracy.\n\nParameters\n----------\ncode_str : str\n    The code to be timed.\ntimes : int, optional\n    The number of times the code is executed. Default is 1. The code is\n    only compiled once.\nlabel : str, optional\n    A label to identify `code_str` with. This is passed into ``compile``\n    as the second argument (for run-time error messages).\n\nReturns\n-------\nelapsed : float\n    Total elapsed time in seconds for executing `code_str` `times` times.\n\nExamples\n--------\n>>> etime = np.testing.measure('for i in range(1000): np.sqrt(i**2)',\n...                            times=times)\n>>> print \"Time for a single execution : \", etime / times, \"s\"\nTime for a single execution :  0.005 s", "id": "f19002:m21"}
{"signature": "def gisfinite(x):", "body": "from numpy.core import isfinite, errstate<EOL>with errstate(invalid='<STR_LIT:ignore>'):<EOL><INDENT>st = isfinite(x)<EOL>if isinstance(st, type(NotImplemented)):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>return st<EOL>", "docstring": "like isfinite, but always raise an error if type not supported instead of\n    returning a TypeError object.\n\n    Notes\n    -----\n    isfinite and other ufunc sometimes return a NotImplementedType object instead\n    of raising any exception. This function is a wrapper to make sure an\n    exception is always raised.\n\n    This should be removed once this problem is solved at the Ufunc level.", "id": "f19002:m2"}
{"signature": "def rand(*args):", "body": "import random<EOL>from numpy.core import zeros, float64<EOL>results = zeros(args, float64)<EOL>f = results.flat<EOL>for i in range(len(f)):<EOL><INDENT>f[i] = random.random()<EOL><DEDENT>return results<EOL>", "docstring": "Returns an array of random numbers with the given shape.\n\n    This only uses the standard library, so it is useful for testing purposes.", "id": "f19002:m4"}
{"signature": "def nulp_diff(x, y, dtype=None):", "body": "import numpy as np<EOL>if dtype:<EOL><INDENT>x = np.array(x, dtype=dtype)<EOL>y = np.array(y, dtype=dtype)<EOL><DEDENT>else:<EOL><INDENT>x = np.array(x)<EOL>y = np.array(y)<EOL><DEDENT>t = np.common_type(x, y)<EOL>if np.iscomplexobj(x) or np.iscomplexobj(y):<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\")<EOL><DEDENT>x = np.array(x, dtype=t)<EOL>y = np.array(y, dtype=t)<EOL>if not x.shape == y.shape:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" %(x.shape, y.shape))<EOL><DEDENT>def _diff(rx, ry, vdt):<EOL><INDENT>diff = np.array(rx-ry, dtype=vdt)<EOL>return np.abs(diff)<EOL><DEDENT>rx = integer_repr(x)<EOL>ry = integer_repr(y)<EOL>return _diff(rx, ry, t)<EOL>", "docstring": "For each item in x and y, return the number of representable floating\n    points between them.\n\n    Parameters\n    ----------\n    x : array_like\n        first input array\n    y : array_like\n        second input array\n\n    Returns\n    -------\n    nulp : array_like\n        number of representable floating point numbers between each item in x\n        and y.\n\n    Examples\n    --------\n    # By definition, epsilon is the smallest number such as 1 + eps != 1, so\n    # there should be exactly one ULP between 1 and 1 + eps\n    >>> nulp_diff(1, 1 + np.finfo(x.dtype).eps)\n    1.0", "id": "f19002:m26"}
{"signature": "def assert_raises(*args,**kwargs):", "body": "nose = import_nose()<EOL>return nose.tools.assert_raises(*args,**kwargs)<EOL>", "docstring": "assert_raises(exception_class, callable, *args, **kwargs)\n\nFail unless an exception of class exception_class is thrown\nby callable when invoked with arguments args and keyword\narguments kwargs. If a different type of exception is\nthrown, it will not be caught, and the test case will be\ndeemed to have suffered an error, exactly as for an\nunexpected exception.", "id": "f19002:m18"}
{"signature": "def assert_equal(actual,desired,err_msg='<STR_LIT>',verbose=True):", "body": "if isinstance(desired, dict):<EOL><INDENT>if not isinstance(actual, dict) :<EOL><INDENT>raise AssertionError(repr(type(actual)))<EOL><DEDENT>assert_equal(len(actual), len(desired), err_msg, verbose)<EOL>for k, i in desired.items():<EOL><INDENT>if k not in actual :<EOL><INDENT>raise AssertionError(repr(k))<EOL><DEDENT>assert_equal(actual[k], desired[k], '<STR_LIT>' % (k, err_msg), verbose)<EOL><DEDENT>return<EOL><DEDENT>if isinstance(desired, (list, tuple)) and isinstance(actual, (list, tuple)):<EOL><INDENT>assert_equal(len(actual), len(desired), err_msg, verbose)<EOL>for k in range(len(desired)):<EOL><INDENT>assert_equal(actual[k], desired[k], '<STR_LIT>' % (k, err_msg), verbose)<EOL><DEDENT>return<EOL><DEDENT>from numpy.core import ndarray, isscalar, signbit<EOL>from numpy.lib import iscomplexobj, real, imag<EOL>if isinstance(actual, ndarray) or isinstance(desired, ndarray):<EOL><INDENT>return assert_array_equal(actual, desired, err_msg, verbose)<EOL><DEDENT>msg = build_err_msg([actual, desired], err_msg, verbose=verbose)<EOL>try:<EOL><INDENT>usecomplex = iscomplexobj(actual) or iscomplexobj(desired)<EOL><DEDENT>except ValueError:<EOL><INDENT>usecomplex = False<EOL><DEDENT>if usecomplex:<EOL><INDENT>if iscomplexobj(actual):<EOL><INDENT>actualr = real(actual)<EOL>actuali = imag(actual)<EOL><DEDENT>else:<EOL><INDENT>actualr = actual<EOL>actuali = <NUM_LIT:0><EOL><DEDENT>if iscomplexobj(desired):<EOL><INDENT>desiredr = real(desired)<EOL>desiredi = imag(desired)<EOL><DEDENT>else:<EOL><INDENT>desiredr = desired<EOL>desiredi = <NUM_LIT:0><EOL><DEDENT>try:<EOL><INDENT>assert_equal(actualr, desiredr)<EOL>assert_equal(actuali, desiredi)<EOL><DEDENT>except AssertionError:<EOL><INDENT>raise AssertionError(msg)<EOL><DEDENT><DEDENT>try:<EOL><INDENT>if isscalar(desired) != isscalar(actual):<EOL><INDENT>raise AssertionError(msg)<EOL><DEDENT>if not (gisfinite(desired) and gisfinite(actual)):<EOL><INDENT>isdesnan = gisnan(desired)<EOL>isactnan = gisnan(actual)<EOL>if isdesnan or isactnan:<EOL><INDENT>if not (isdesnan and isactnan):<EOL><INDENT>raise AssertionError(msg)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if not desired == actual:<EOL><INDENT>raise AssertionError(msg)<EOL><DEDENT><DEDENT>return<EOL><DEDENT>elif desired == <NUM_LIT:0> and actual == <NUM_LIT:0>:<EOL><INDENT>if not signbit(desired) == signbit(actual):<EOL><INDENT>raise AssertionError(msg)<EOL><DEDENT><DEDENT><DEDENT>except (TypeError, ValueError, NotImplementedError):<EOL><INDENT>pass<EOL><DEDENT>if not (desired == actual):<EOL><INDENT>raise AssertionError(msg)<EOL><DEDENT>", "docstring": "Raises an AssertionError if two objects are not equal.\n\nGiven two objects (scalars, lists, tuples, dictionaries or numpy arrays),\ncheck that all elements of these objects are equal. An exception is raised\nat the first conflicting values.\n\nParameters\n----------\nactual : array_like\n    The object to check.\ndesired : array_like\n    The expected object.\nerr_msg : str, optional\n    The error message to be printed in case of failure.\nverbose : bool, optional\n    If True, the conflicting values are appended to the error message.\n\nRaises\n------\nAssertionError\n    If actual and desired are not equal.\n\nExamples\n--------\n>>> np.testing.assert_equal([4,5], [4,6])\n...\n<type 'exceptions.AssertionError'>:\nItems are not equal:\nitem=1\n ACTUAL: 5\n DESIRED: 6", "id": "f19002:m6"}
{"signature": "def slow(t):", "body": "t.slow = True<EOL>return t<EOL>", "docstring": "Label a test as 'slow'.\n\nThe exact definition of a slow test is obviously both subjective and\nhardware-dependent, but in general any individual test that requires more\nthan a second or two should be labeled as slow (the whole suite consits of\nthousands of tests, so even a second is significant).\n\nParameters\n----------\nt : callable\n    The test to label as slow.\n\nReturns\n-------\nt : callable\n    The decorated test `t`.\n\nExamples\n--------\nThe `numpy.testing` module includes ``import decorators as dec``.\nA test can be decorated as slow like this::\n\n  from numpy.testing import *\n\n  @dec.slow\n  def test_big(self):\n      print 'Big, slow test'", "id": "f19004:m0"}
{"signature": "def in_foreign_locale(func):", "body": "if sys.platform == '<STR_LIT:win32>':<EOL><INDENT>locales = ['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>locales = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL><DEDENT>def wrapper(*args, **kwargs):<EOL><INDENT>curloc = locale.getlocale(locale.LC_NUMERIC)<EOL>try:<EOL><INDENT>for loc in locales:<EOL><INDENT>try:<EOL><INDENT>locale.setlocale(locale.LC_NUMERIC, loc)<EOL>break<EOL><DEDENT>except locale.Error:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise nose.SkipTest(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>return func(*args, **kwargs)<EOL><DEDENT>finally:<EOL><INDENT>locale.setlocale(locale.LC_NUMERIC, locale=curloc)<EOL><DEDENT><DEDENT>return nose.tools.make_decorator(func)(wrapper)<EOL>", "docstring": "Swap LC_NUMERIC locale to one in which the decimal point is ',' and not '.'\nIf not possible, raise nose.SkipTest", "id": "f19012:m14"}
{"signature": "def assert_deprecated(self, function, num=<NUM_LIT:1>, ignore_others=False,<EOL>function_fails=False,<EOL>exceptions=(DeprecationWarning,), args=(), kwargs={}):", "body": "<EOL>self.log[:] = []<EOL>try:<EOL><INDENT>function(*args, **kwargs)<EOL><DEDENT>except (Exception if function_fails else tuple()):<EOL><INDENT>pass<EOL><DEDENT>num_found = <NUM_LIT:0><EOL>for warning in self.log:<EOL><INDENT>if warning.category is DeprecationWarning:<EOL><INDENT>num_found += <NUM_LIT:1><EOL><DEDENT>elif not ignore_others:<EOL><INDENT>raise AssertionError(\"<STR_LIT>\"<EOL>% warning.category)<EOL><DEDENT><DEDENT>if num is not None and num_found != num:<EOL><INDENT>raise AssertionError(\"<STR_LIT>\"<EOL>% (len(self.log), num))<EOL><DEDENT>with warnings.catch_warnings():<EOL><INDENT>warnings.filterwarnings(\"<STR_LIT:error>\", message=self.message,<EOL>category=DeprecationWarning)<EOL>try:<EOL><INDENT>function(*args, **kwargs)<EOL>if exceptions != tuple():<EOL><INDENT>raise AssertionError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>except exceptions:<EOL><INDENT>if exceptions == tuple():<EOL><INDENT>raise AssertionError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Test if DeprecationWarnings are given and raised.\n\n        This first checks if the function when called gives `num`\n        DeprecationWarnings, after that it tries to raise these\n        DeprecationWarnings and compares them with `exceptions`.\n        The exceptions can be different for cases where this code path\n        is simply not anticipated and the exception is replaced.\n\n        Parameters\n        ----------\n        f : callable\n            The function to test\n        num : int\n            Number of DeprecationWarnings to expect. This should normally be 1.\n        ignore_other : bool\n            Whether warnings of the wrong type should be ignored (note that\n            the message is not checked)\n        function_fails : bool\n            If the function would normally fail, setting this will check for\n            warnings inside a try/except block.\n        exceptions : Exception or tuple of Exceptions\n            Exception to expect when turning the warnings into an error.\n            The default checks for DeprecationWarnings. If exceptions is\n            empty the function is expected to run successfull.\n        args : tuple\n            Arguments for `f`\n        kwargs : dict\n            Keyword arguments for `f`", "id": "f19038:c0:m2"}
{"signature": "def flush(self):", "body": "if self.base is not None and hasattr(self.base, '<STR_LIT>'):<EOL><INDENT>self.base.flush()<EOL><DEDENT>", "docstring": "Write any changes in the array to the file on disk.\n\nFor further information, see `memmap`.\n\nParameters\n----------\nNone\n\nSee Also\n--------\nmemmap", "id": "f19040:c0:m2"}
{"signature": "def get_printoptions():", "body": "d = dict(precision=_float_output_precision,<EOL>threshold=_summaryThreshold,<EOL>edgeitems=_summaryEdgeItems,<EOL>linewidth=_line_width,<EOL>suppress=_float_output_suppress_small,<EOL>nanstr=_nan_str,<EOL>infstr=_inf_str,<EOL>formatter=_formatter)<EOL>return d<EOL>", "docstring": "Return the current print options.\n\nReturns\n-------\nprint_opts : dict\n    Dictionary of current print options with keys\n\n      - precision : int\n      - threshold : int\n      - edgeitems : int\n      - linewidth : int\n      - suppress : bool\n      - nanstr : str\n      - infstr : str\n      - formatter : dict of callables\n\n    For a full description of these options, see `set_printoptions`.\n\nSee Also\n--------\nset_printoptions, set_string_function", "id": "f19043:m2"}
{"signature": "def _formatArray(a, format_function, rank, max_line_len,<EOL>next_line_prefix, separator, edge_items, summary_insert):", "body": "if rank == <NUM_LIT:0>:<EOL><INDENT>obj = a.item()<EOL>if isinstance(obj, tuple):<EOL><INDENT>obj = _convert_arrays(obj)<EOL><DEDENT>return str(obj)<EOL><DEDENT>if summary_insert and <NUM_LIT:2>*edge_items < len(a):<EOL><INDENT>leading_items, trailing_items, summary_insert1 =edge_items, edge_items, summary_insert<EOL><DEDENT>else:<EOL><INDENT>leading_items, trailing_items, summary_insert1 = <NUM_LIT:0>, len(a), \"<STR_LIT>\"<EOL><DEDENT>if rank == <NUM_LIT:1>:<EOL><INDENT>s = \"<STR_LIT>\"<EOL>line = next_line_prefix<EOL>for i in range(leading_items):<EOL><INDENT>word = format_function(a[i]) + separator<EOL>s, line = _extendLine(s, line, word, max_line_len, next_line_prefix)<EOL><DEDENT>if summary_insert1:<EOL><INDENT>s, line = _extendLine(s, line, summary_insert1, max_line_len, next_line_prefix)<EOL><DEDENT>for i in range(trailing_items, <NUM_LIT:1>, -<NUM_LIT:1>):<EOL><INDENT>word = format_function(a[-i]) + separator<EOL>s, line = _extendLine(s, line, word, max_line_len, next_line_prefix)<EOL><DEDENT>word = format_function(a[-<NUM_LIT:1>])<EOL>s, line = _extendLine(s, line, word, max_line_len, next_line_prefix)<EOL>s += line + \"<STR_LIT>\"<EOL>s = '<STR_LIT:[>' + s[len(next_line_prefix):]<EOL><DEDENT>else:<EOL><INDENT>s = '<STR_LIT:[>'<EOL>sep = separator.rstrip()<EOL>for i in range(leading_items):<EOL><INDENT>if i > <NUM_LIT:0>:<EOL><INDENT>s += next_line_prefix<EOL><DEDENT>s += _formatArray(a[i], format_function, rank-<NUM_LIT:1>, max_line_len,<EOL>\"<STR_LIT:U+0020>\" + next_line_prefix, separator, edge_items,<EOL>summary_insert)<EOL>s = s.rstrip() + sep.rstrip() + '<STR_LIT:\\n>'*max(rank-<NUM_LIT:1>, <NUM_LIT:1>)<EOL><DEDENT>if summary_insert1:<EOL><INDENT>s += next_line_prefix + summary_insert1 + \"<STR_LIT:\\n>\"<EOL><DEDENT>for i in range(trailing_items, <NUM_LIT:1>, -<NUM_LIT:1>):<EOL><INDENT>if leading_items or i != trailing_items:<EOL><INDENT>s += next_line_prefix<EOL><DEDENT>s += _formatArray(a[-i], format_function, rank-<NUM_LIT:1>, max_line_len,<EOL>\"<STR_LIT:U+0020>\" + next_line_prefix, separator, edge_items,<EOL>summary_insert)<EOL>s = s.rstrip() + sep.rstrip() + '<STR_LIT:\\n>'*max(rank-<NUM_LIT:1>, <NUM_LIT:1>)<EOL><DEDENT>if leading_items or trailing_items > <NUM_LIT:1>:<EOL><INDENT>s += next_line_prefix<EOL><DEDENT>s += _formatArray(a[-<NUM_LIT:1>], format_function, rank-<NUM_LIT:1>, max_line_len,<EOL>\"<STR_LIT:U+0020>\" + next_line_prefix, separator, edge_items,<EOL>summary_insert).rstrip()+'<STR_LIT>'<EOL><DEDENT>return s<EOL>", "docstring": "formatArray is designed for two modes of operation:\n\n    1. Full output\n\n    2. Summarized output", "id": "f19043:m10"}
{"signature": "def shape(a):", "body": "try:<EOL><INDENT>result = a.shape<EOL><DEDENT>except AttributeError:<EOL><INDENT>result = asarray(a).shape<EOL><DEDENT>return result<EOL>", "docstring": "Return the shape of an array.\n\nParameters\n----------\na : array_like\n    Input array.\n\nReturns\n-------\nshape : tuple of ints\n    The elements of the shape tuple give the lengths of the\n    corresponding array dimensions.\n\nSee Also\n--------\nalen\nndarray.shape : Equivalent array method.\n\nExamples\n--------\n>>> np.shape(np.eye(3))\n(3, 3)\n>>> np.shape([[1, 2]])\n(1, 2)\n>>> np.shape([0])\n(1,)\n>>> np.shape(0)\n()\n\n>>> a = np.array([(1, 2), (3, 4)], dtype=[('x', 'i4'), ('y', 'i4')])\n>>> np.shape(a)\n(2,)\n>>> a.shape\n(2,)", "id": "f19044:m21"}
{"signature": "def argmin(a, axis=None):", "body": "try:<EOL><INDENT>argmin = a.argmin<EOL><DEDENT>except AttributeError:<EOL><INDENT>return _wrapit(a, '<STR_LIT>', axis)<EOL><DEDENT>return argmin(axis)<EOL>", "docstring": "Return the indices of the minimum values along an axis.\n\nSee Also\n--------\nargmax : Similar function.  Please refer to `numpy.argmax` for detailed\n    documentation.", "id": "f19044:m13"}
{"signature": "def around(a, decimals=<NUM_LIT:0>, out=None):", "body": "try:<EOL><INDENT>round = a.round<EOL><DEDENT>except AttributeError:<EOL><INDENT>return _wrapit(a, '<STR_LIT>', decimals, out)<EOL><DEDENT>return round(decimals, out)<EOL>", "docstring": "Evenly round to the given number of decimals.\n\nParameters\n----------\na : array_like\n    Input data.\ndecimals : int, optional\n    Number of decimal places to round to (default: 0).  If\n    decimals is negative, it specifies the number of positions to\n    the left of the decimal point.\nout : ndarray, optional\n    Alternative output array in which to place the result. It must have\n    the same shape as the expected output, but the type of the output\n    values will be cast if necessary. See `doc.ufuncs` (Section\n    \"Output arguments\") for details.\n\nReturns\n-------\nrounded_array : ndarray\n    An array of the same type as `a`, containing the rounded values.\n    Unless `out` was specified, a new array is created.  A reference to\n    the result is returned.\n\n    The real and imaginary parts of complex numbers are rounded\n    separately.  The result of rounding a float is a float.\n\nSee Also\n--------\nndarray.round : equivalent method\n\nceil, fix, floor, rint, trunc\n\n\nNotes\n-----\nFor values exactly halfway between rounded decimal values, Numpy\nrounds to the nearest even value. Thus 1.5 and 2.5 round to 2.0,\n-0.5 and 0.5 round to 0.0, etc. Results may also be surprising due\nto the inexact representation of decimal fractions in the IEEE\nfloating point standard [1]_ and errors introduced when scaling\nby powers of ten.\n\nReferences\n----------\n.. [1] \"Lecture Notes on the Status of  IEEE 754\", William Kahan,\n       http://www.cs.berkeley.edu/~wkahan/ieee754status/IEEE754.PDF\n.. [2] \"How Futile are Mindless Assessments of\n       Roundoff in Floating-Point Computation?\", William Kahan,\n       http://www.cs.berkeley.edu/~wkahan/Mindless.pdf\n\nExamples\n--------\n>>> np.around([0.37, 1.64])\narray([ 0.,  2.])\n>>> np.around([0.37, 1.64], decimals=1)\narray([ 0.4,  1.6])\n>>> np.around([.5, 1.5, 2.5, 3.5, 4.5]) # rounds to nearest even value\narray([ 0.,  2.,  2.,  4.,  4.])\n>>> np.around([1,2,3,11], decimals=1) # ndarray of ints is returned\narray([ 1,  2,  3, 11])\n>>> np.around([1,2,3,11], decimals=-1)\narray([ 0,  0,  0, 10])", "id": "f19044:m41"}
{"signature": "def squeeze(a, axis=None):", "body": "try:<EOL><INDENT>squeeze = a.squeeze<EOL><DEDENT>except AttributeError:<EOL><INDENT>return _wrapit(a, '<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>return squeeze(axis=axis)<EOL><DEDENT>except TypeError:<EOL><INDENT>return squeeze()<EOL><DEDENT>", "docstring": "Remove single-dimensional entries from the shape of an array.\n\nParameters\n----------\na : array_like\n    Input data.\naxis : None or int or tuple of ints, optional\n    .. versionadded:: 1.7.0\n\n    Selects a subset of the single-dimensional entries in the\n    shape. If an axis is selected with shape entry greater than\n    one, an error is raised.\n\nReturns\n-------\nsqueezed : ndarray\n    The input array, but with all or a subset of the\n    dimensions of length 1 removed. This is always `a` itself\n    or a view into `a`.\n\nExamples\n--------\n>>> x = np.array([[[0], [1], [2]]])\n>>> x.shape\n(1, 3, 1)\n>>> np.squeeze(x).shape\n(3,)\n>>> np.squeeze(x, axis=(2,)).shape\n(1, 3)", "id": "f19044:m16"}
{"signature": "def ravel(a, order='<STR_LIT:C>'):", "body": "return asarray(a).ravel(order)<EOL>", "docstring": "Return a flattened array.\n\nA 1-D array, containing the elements of the input, is returned.  A copy is\nmade only if needed.\n\nParameters\n----------\na : array_like\n    Input array.  The elements in `a` are read in the order specified by\n    `order`, and packed as a 1-D array.\norder : {'C','F', 'A', 'K'}, optional\n    The elements of `a` are read using this index order. 'C' means to\n    index the elements in C-like order, with the last axis index changing\n    fastest, back to the first axis index changing slowest.   'F' means to\n    index the elements in Fortran-like index order, with the first index\n    changing fastest, and the last index changing slowest. Note that the 'C'\n    and 'F' options take no account of the memory layout of the underlying\n    array, and only refer to the order of axis indexing.  'A' means to read\n    the elements in Fortran-like index order if `a` is Fortran *contiguous*\n    in memory, C-like order otherwise.  'K' means to read the elements in\n    the order they occur in memory, except for reversing the data when\n    strides are negative.  By default, 'C' index order is used.\n\nReturns\n-------\n1d_array : ndarray\n    Output of the same dtype as `a`, and of shape ``(a.size,)``.\n\nSee Also\n--------\nndarray.flat : 1-D iterator over an array.\nndarray.flatten : 1-D array copy of the elements of an array\n                  in row-major order.\n\nNotes\n-----\nIn C-like (row-major) order, in two dimensions, the row index varies the\nslowest, and the column index the quickest.  This can be generalized to\nmultiple dimensions, where row-major order implies that the index along the\nfirst axis varies slowest, and the index along the last quickest.  The\nopposite holds for Fortran-like, or column-major, index ordering.\n\nExamples\n--------\nIt is equivalent to ``reshape(-1, order=order)``.\n\n>>> x = np.array([[1, 2, 3], [4, 5, 6]])\n>>> print np.ravel(x)\n[1 2 3 4 5 6]\n\n>>> print x.reshape(-1)\n[1 2 3 4 5 6]\n\n>>> print np.ravel(x, order='F')\n[1 4 2 5 3 6]\n\nWhen ``order`` is 'A', it will preserve the array's 'C' or 'F' ordering:\n\n>>> print np.ravel(x.T)\n[1 4 2 5 3 6]\n>>> print np.ravel(x.T, order='A')\n[1 2 3 4 5 6]\n\nWhen ``order`` is 'K', it will preserve orderings that are neither 'C'\nnor 'F', but won't reverse axes:\n\n>>> a = np.arange(3)[::-1]; a\narray([2, 1, 0])\n>>> a.ravel(order='C')\narray([2, 1, 0])\n>>> a.ravel(order='K')\narray([2, 1, 0])\n\n>>> a = np.arange(12).reshape(2,3,2).swapaxes(1,2); a\narray([[[ 0,  2,  4],\n        [ 1,  3,  5]],\n       [[ 6,  8, 10],\n        [ 7,  9, 11]]])\n>>> a.ravel(order='C')\narray([ 0,  2,  4,  1,  3,  5,  6,  8, 10,  7,  9, 11])\n>>> a.ravel(order='K')\narray([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])", "id": "f19044:m19"}
{"signature": "def choose(a, choices, out=None, mode='<STR_LIT>'):", "body": "try:<EOL><INDENT>choose = a.choose<EOL><DEDENT>except AttributeError:<EOL><INDENT>return _wrapit(a, '<STR_LIT>', choices, out=out, mode=mode)<EOL><DEDENT>return choose(choices, out=out, mode=mode)<EOL>", "docstring": "Construct an array from an index array and a set of arrays to choose from.\n\nFirst of all, if confused or uncertain, definitely look at the Examples -\nin its full generality, this function is less simple than it might\nseem from the following code description (below ndi =\n`numpy.lib.index_tricks`):\n\n``np.choose(a,c) == np.array([c[a[I]][I] for I in ndi.ndindex(a.shape)])``.\n\nBut this omits some subtleties.  Here is a fully general summary:\n\nGiven an \"index\" array (`a`) of integers and a sequence of `n` arrays\n(`choices`), `a` and each choice array are first broadcast, as necessary,\nto arrays of a common shape; calling these *Ba* and *Bchoices[i], i =\n0,...,n-1* we have that, necessarily, ``Ba.shape == Bchoices[i].shape``\nfor each `i`.  Then, a new array with shape ``Ba.shape`` is created as\nfollows:\n\n* if ``mode=raise`` (the default), then, first of all, each element of\n  `a` (and thus `Ba`) must be in the range `[0, n-1]`; now, suppose that\n  `i` (in that range) is the value at the `(j0, j1, ..., jm)` position\n  in `Ba` - then the value at the same position in the new array is the\n  value in `Bchoices[i]` at that same position;\n\n* if ``mode=wrap``, values in `a` (and thus `Ba`) may be any (signed)\n  integer; modular arithmetic is used to map integers outside the range\n  `[0, n-1]` back into that range; and then the new array is constructed\n  as above;\n\n* if ``mode=clip``, values in `a` (and thus `Ba`) may be any (signed)\n  integer; negative integers are mapped to 0; values greater than `n-1`\n  are mapped to `n-1`; and then the new array is constructed as above.\n\nParameters\n----------\na : int array\n    This array must contain integers in `[0, n-1]`, where `n` is the number\n    of choices, unless ``mode=wrap`` or ``mode=clip``, in which cases any\n    integers are permissible.\nchoices : sequence of arrays\n    Choice arrays. `a` and all of the choices must be broadcastable to the\n    same shape.  If `choices` is itself an array (not recommended), then\n    its outermost dimension (i.e., the one corresponding to\n    ``choices.shape[0]``) is taken as defining the \"sequence\".\nout : array, optional\n    If provided, the result will be inserted into this array. It should\n    be of the appropriate shape and dtype.\nmode : {'raise' (default), 'wrap', 'clip'}, optional\n    Specifies how indices outside `[0, n-1]` will be treated:\n\n      * 'raise' : an exception is raised\n      * 'wrap' : value becomes value mod `n`\n      * 'clip' : values < 0 are mapped to 0, values > n-1 are mapped to n-1\n\nReturns\n-------\nmerged_array : array\n    The merged result.\n\nRaises\n------\nValueError: shape mismatch\n    If `a` and each choice array are not all broadcastable to the same\n    shape.\n\nSee Also\n--------\nndarray.choose : equivalent method\n\nNotes\n-----\nTo reduce the chance of misinterpretation, even though the following\n\"abuse\" is nominally supported, `choices` should neither be, nor be\nthought of as, a single array, i.e., the outermost sequence-like container\nshould be either a list or a tuple.\n\nExamples\n--------\n\n>>> choices = [[0, 1, 2, 3], [10, 11, 12, 13],\n...   [20, 21, 22, 23], [30, 31, 32, 33]]\n>>> np.choose([2, 3, 1, 0], choices\n... # the first element of the result will be the first element of the\n... # third (2+1) \"array\" in choices, namely, 20; the second element\n... # will be the second element of the fourth (3+1) choice array, i.e.,\n... # 31, etc.\n... )\narray([20, 31, 12,  3])\n>>> np.choose([2, 4, 1, 0], choices, mode='clip') # 4 goes to 3 (4-1)\narray([20, 31, 12,  3])\n>>> # because there are 4 choice arrays\n>>> np.choose([2, 4, 1, 0], choices, mode='wrap') # 4 goes to (4 mod 4)\narray([20,  1, 12,  3])\n>>> # i.e., 0\n\nA couple examples illustrating how choose broadcasts:\n\n>>> a = [[1, 0, 1], [0, 1, 0], [1, 0, 1]]\n>>> choices = [-10, 10]\n>>> np.choose(a, choices)\narray([[ 10, -10,  10],\n       [-10,  10, -10],\n       [ 10, -10,  10]])\n\n>>> # With thanks to Anne Archibald\n>>> a = np.array([0, 1]).reshape((2,1,1))\n>>> c1 = np.array([1, 2, 3]).reshape((1,3,1))\n>>> c2 = np.array([-1, -2, -3, -4, -5]).reshape((1,1,5))\n>>> np.choose(a, (c1, c2)) # result is 2x3x5, res[0,:,:]=c1, res[1,:,:]=c2\narray([[[ 1,  1,  1,  1,  1],\n        [ 2,  2,  2,  2,  2],\n        [ 3,  3,  3,  3,  3]],\n       [[-1, -2, -3, -4, -5],\n        [-1, -2, -3, -4, -5],\n        [-1, -2, -3, -4, -5]]])", "id": "f19044:m3"}
{"signature": "def rank(a):", "body": "warnings.warn(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>VisibleDeprecationWarning)<EOL>try:<EOL><INDENT>return a.ndim<EOL><DEDENT>except AttributeError:<EOL><INDENT>return asarray(a).ndim<EOL><DEDENT>", "docstring": "Return the number of dimensions of an array.\n\nIf `a` is not already an array, a conversion is attempted.\nScalars are zero dimensional.\n\n.. note::\n    This function is deprecated in NumPy 1.9 to avoid confusion with\n    `numpy.linalg.matrix_rank`. The ``ndim`` attribute or function\n    should be used instead.\n\nParameters\n----------\na : array_like\n    Array whose number of dimensions is desired. If `a` is not an array,\n    a conversion is attempted.\n\nReturns\n-------\nnumber_of_dimensions : int\n    The number of dimensions in the array.\n\nSee Also\n--------\nndim : equivalent function\nndarray.ndim : equivalent property\nshape : dimensions of array\nndarray.shape : dimensions of array\n\nNotes\n-----\nIn the old Numeric package, `rank` was the term used for the number of\ndimensions, but in Numpy `ndim` is used instead.\n\nExamples\n--------\n>>> np.rank([1,2,3])\n1\n>>> np.rank(np.array([[1,2,3],[4,5,6]]))\n2\n>>> np.rank(1)\n0", "id": "f19044:m39"}
{"signature": "def all(a, axis=None, out=None, keepdims=False):", "body": "arr = asanyarray(a)<EOL>try:<EOL><INDENT>return arr.all(axis=axis, out=out, keepdims=keepdims)<EOL><DEDENT>except TypeError:<EOL><INDENT>return arr.all(axis=axis, out=out)<EOL><DEDENT>", "docstring": "Test whether all array elements along a given axis evaluate to True.\n\nParameters\n----------\na : array_like\n    Input array or object that can be converted to an array.\naxis : None or int or tuple of ints, optional\n    Axis or axes along which a logical AND reduction is performed.\n    The default (`axis` = `None`) is to perform a logical AND over all\n    the dimensions of the input array. `axis` may be negative, in\n    which case it counts from the last to the first axis.\n\n    .. versionadded:: 1.7.0\n\n    If this is a tuple of ints, a reduction is performed on multiple\n    axes, instead of a single axis or all the axes as before.\nout : ndarray, optional\n    Alternate output array in which to place the result.\n    It must have the same shape as the expected output and its\n    type is preserved (e.g., if ``dtype(out)`` is float, the result\n    will consist of 0.0's and 1.0's).  See `doc.ufuncs` (Section\n    \"Output arguments\") for more details.\nkeepdims : bool, optional\n    If this is set to True, the axes which are reduced are left\n    in the result as dimensions with size one. With this option,\n    the result will broadcast correctly against the original `arr`.\n\nReturns\n-------\nall : ndarray, bool\n    A new boolean or array is returned unless `out` is specified,\n    in which case a reference to `out` is returned.\n\nSee Also\n--------\nndarray.all : equivalent method\n\nany : Test whether any element along a given axis evaluates to True.\n\nNotes\n-----\nNot a Number (NaN), positive infinity and negative infinity\nevaluate to `True` because these are not equal to zero.\n\nExamples\n--------\n>>> np.all([[True,False],[True,True]])\nFalse\n\n>>> np.all([[True,False],[True,True]], axis=0)\narray([ True, False], dtype=bool)\n\n>>> np.all([-1, 4, 5])\nTrue\n\n>>> np.all([1.0, np.nan])\nTrue\n\n>>> o=np.array([False])\n>>> z=np.all([-1, 4, 5], out=o)\n>>> id(z), id(o), z                             # doctest: +SKIP\n(28293632, 28293632, array([ True], dtype=bool))", "id": "f19044:m29"}
{"signature": "def ndim(a):", "body": "try:<EOL><INDENT>return a.ndim<EOL><DEDENT>except AttributeError:<EOL><INDENT>return asarray(a).ndim<EOL><DEDENT>", "docstring": "Return the number of dimensions of an array.\n\nParameters\n----------\na : array_like\n    Input array.  If it is not already an ndarray, a conversion is\n    attempted.\n\nReturns\n-------\nnumber_of_dimensions : int\n    The number of dimensions in `a`.  Scalars are zero-dimensional.\n\nSee Also\n--------\nndarray.ndim : equivalent method\nshape : dimensions of array\nndarray.shape : dimensions of array\n\nExamples\n--------\n>>> np.ndim([[1,2,3],[4,5,6]])\n2\n>>> np.ndim(np.array([[1,2,3],[4,5,6]]))\n2\n>>> np.ndim(1)\n0", "id": "f19044:m38"}
{"signature": "def prod(a, axis=None, dtype=None, out=None, keepdims=False):", "body": "if type(a) is not mu.ndarray:<EOL><INDENT>try:<EOL><INDENT>prod = a.prod<EOL><DEDENT>except AttributeError:<EOL><INDENT>return _methods._prod(a, axis=axis, dtype=dtype,<EOL>out=out, keepdims=keepdims)<EOL><DEDENT>return prod(axis=axis, dtype=dtype, out=out)<EOL><DEDENT>else:<EOL><INDENT>return _methods._prod(a, axis=axis, dtype=dtype,<EOL>out=out, keepdims=keepdims)<EOL><DEDENT>", "docstring": "Return the product of array elements over a given axis.\n\nParameters\n----------\na : array_like\n    Input data.\naxis : None or int or tuple of ints, optional\n    Axis or axes along which a product is performed.\n    The default (`axis` = `None`) is perform a product over all\n    the dimensions of the input array. `axis` may be negative, in\n    which case it counts from the last to the first axis.\n\n    .. versionadded:: 1.7.0\n\n    If this is a tuple of ints, a product is performed on multiple\n    axes, instead of a single axis or all the axes as before.\ndtype : data-type, optional\n    The data-type of the returned array, as well as of the accumulator\n    in which the elements are multiplied.  By default, if `a` is of\n    integer type, `dtype` is the default platform integer. (Note: if\n    the type of `a` is unsigned, then so is `dtype`.)  Otherwise,\n    the dtype is the same as that of `a`.\nout : ndarray, optional\n    Alternative output array in which to place the result. It must have\n    the same shape as the expected output, but the type of the\n    output values will be cast if necessary.\nkeepdims : bool, optional\n    If this is set to True, the axes which are reduced are left\n    in the result as dimensions with size one. With this option,\n    the result will broadcast correctly against the original `arr`.\n\nReturns\n-------\nproduct_along_axis : ndarray, see `dtype` parameter above.\n    An array shaped as `a` but with the specified axis removed.\n    Returns a reference to `out` if specified.\n\nSee Also\n--------\nndarray.prod : equivalent method\nnumpy.doc.ufuncs : Section \"Output arguments\"\n\nNotes\n-----\nArithmetic is modular when using integer types, and no error is\nraised on overflow.  That means that, on a 32-bit platform:\n\n>>> x = np.array([536870910, 536870910, 536870910, 536870910])\n>>> np.prod(x) #random\n16\n\nExamples\n--------\nBy default, calculate the product of all elements:\n\n>>> np.prod([1.,2.])\n2.0\n\nEven when the input array is two-dimensional:\n\n>>> np.prod([[1.,2.],[3.,4.]])\n24.0\n\nBut we can also specify the axis over which to multiply:\n\n>>> np.prod([[1.,2.],[3.,4.]], axis=1)\narray([  2.,  12.])\n\nIf the type of `x` is unsigned, then the output type is\nthe unsigned platform integer:\n\n>>> x = np.array([1, 2, 3], dtype=np.uint8)\n>>> np.prod(x).dtype == np.uint\nTrue\n\nIf `x` is of a signed integer type, then the output type\nis the default platform integer:\n\n>>> x = np.array([1, 2, 3], dtype=np.int8)\n>>> np.prod(x).dtype == np.int\nTrue", "id": "f19044:m36"}
{"signature": "def alltrue (a, axis=None, out=None, keepdims=False):", "body": "arr = asanyarray(a)<EOL>try:<EOL><INDENT>return arr.all(axis=axis, out=out, keepdims=keepdims)<EOL><DEDENT>except TypeError:<EOL><INDENT>return arr.all(axis=axis, out=out)<EOL><DEDENT>", "docstring": "Check if all elements of input array are true.\n\nSee Also\n--------\nnumpy.all : Equivalent function; see for details.", "id": "f19044:m27"}
{"signature": "def ptp(a, axis=None, out=None):", "body": "try:<EOL><INDENT>ptp = a.ptp<EOL><DEDENT>except AttributeError:<EOL><INDENT>return _wrapit(a, '<STR_LIT>', axis, out)<EOL><DEDENT>return ptp(axis, out)<EOL>", "docstring": "Range of values (maximum - minimum) along an axis.\n\nThe name of the function comes from the acronym for 'peak to peak'.\n\nParameters\n----------\na : array_like\n    Input values.\naxis : int, optional\n    Axis along which to find the peaks.  By default, flatten the\n    array.\nout : array_like\n    Alternative output array in which to place the result. It must\n    have the same shape and buffer length as the expected output,\n    but the type of the output values will be cast if necessary.\n\nReturns\n-------\nptp : ndarray\n    A new array holding the result, unless `out` was\n    specified, in which case a reference to `out` is returned.\n\nExamples\n--------\n>>> x = np.arange(4).reshape((2,2))\n>>> x\narray([[0, 1],\n       [2, 3]])\n\n>>> np.ptp(x, axis=0)\narray([2, 2])\n\n>>> np.ptp(x, axis=1)\narray([1, 1])", "id": "f19044:m32"}
{"signature": "def product (a, axis=None, dtype=None, out=None, keepdims=False):", "body": "return um.multiply.reduce(a, axis=axis, dtype=dtype, out=out, keepdims=keepdims)<EOL>", "docstring": "Return the product of array elements over a given axis.\n\nSee Also\n--------\nprod : equivalent function; see for details.", "id": "f19044:m25"}
{"signature": "def take(a, indices, axis=None, out=None, mode='<STR_LIT>'):", "body": "try:<EOL><INDENT>take = a.take<EOL><DEDENT>except AttributeError:<EOL><INDENT>return _wrapit(a, '<STR_LIT>', indices, axis, out, mode)<EOL><DEDENT>return take(indices, axis, out, mode)<EOL>", "docstring": "Take elements from an array along an axis.\n\nThis function does the same thing as \"fancy\" indexing (indexing arrays\nusing arrays); however, it can be easier to use if you need elements\nalong a given axis.\n\nParameters\n----------\na : array_like\n    The source array.\nindices : array_like\n    The indices of the values to extract.\n\n    .. versionadded:: 1.8.0\n\n    Also allow scalars for indices.\naxis : int, optional\n    The axis over which to select values. By default, the flattened\n    input array is used.\nout : ndarray, optional\n    If provided, the result will be placed in this array. It should\n    be of the appropriate shape and dtype.\nmode : {'raise', 'wrap', 'clip'}, optional\n    Specifies how out-of-bounds indices will behave.\n\n    * 'raise' -- raise an error (default)\n    * 'wrap' -- wrap around\n    * 'clip' -- clip to the range\n\n    'clip' mode means that all indices that are too large are replaced\n    by the index that addresses the last element along that axis. Note\n    that this disables indexing with negative numbers.\n\nReturns\n-------\nsubarray : ndarray\n    The returned array has the same type as `a`.\n\nSee Also\n--------\ncompress : Take elements using a boolean mask\nndarray.take : equivalent method\n\nExamples\n--------\n>>> a = [4, 3, 5, 7, 6, 8]\n>>> indices = [0, 1, 4]\n>>> np.take(a, indices)\narray([4, 3, 6])\n\nIn this example if `a` is an ndarray, \"fancy\" indexing can be used.\n\n>>> a = np.array(a)\n>>> a[indices]\narray([4, 3, 6])\n\nIf `indices` is not one dimensional, the output also has these dimensions.\n\n>>> np.take(a, [[0, 1], [2, 3]])\narray([[4, 3],\n       [5, 7]])", "id": "f19044:m1"}
{"signature": "def resize(a, new_shape):", "body": "if isinstance(new_shape, (int, nt.integer)):<EOL><INDENT>new_shape = (new_shape,)<EOL><DEDENT>a = ravel(a)<EOL>Na = len(a)<EOL>if not Na: return mu.zeros(new_shape, a.dtype.char)<EOL>total_size = um.multiply.reduce(new_shape)<EOL>n_copies = int(total_size / Na)<EOL>extra = total_size % Na<EOL>if total_size == <NUM_LIT:0>:<EOL><INDENT>return a[:<NUM_LIT:0>]<EOL><DEDENT>if extra != <NUM_LIT:0>:<EOL><INDENT>n_copies = n_copies+<NUM_LIT:1><EOL>extra = Na-extra<EOL><DEDENT>a = concatenate( (a,)*n_copies)<EOL>if extra > <NUM_LIT:0>:<EOL><INDENT>a = a[:-extra]<EOL><DEDENT>return reshape(a, new_shape)<EOL>", "docstring": "Return a new array with the specified shape.\n\nIf the new array is larger than the original array, then the new\narray is filled with repeated copies of `a`.  Note that this behavior\nis different from a.resize(new_shape) which fills with zeros instead\nof repeated copies of `a`.\n\nParameters\n----------\na : array_like\n    Array to be resized.\n\nnew_shape : int or tuple of int\n    Shape of resized array.\n\nReturns\n-------\nreshaped_array : ndarray\n    The new array is formed from the data in the old array, repeated\n    if necessary to fill out the required number of elements.  The\n    data are repeated in the order that they are stored in memory.\n\nSee Also\n--------\nndarray.resize : resize an array in-place.\n\nExamples\n--------\n>>> a=np.array([[0,1],[2,3]])\n>>> np.resize(a,(1,4))\narray([[0, 1, 2, 3]])\n>>> np.resize(a,(2,4))\narray([[0, 1, 2, 3],\n       [0, 1, 2, 3]])", "id": "f19044:m15"}
{"signature": "def bitname(obj):", "body": "name = obj.__name__<EOL>base = '<STR_LIT>'<EOL>char = '<STR_LIT>'<EOL>try:<EOL><INDENT>if name[-<NUM_LIT:1>] == '<STR_LIT:_>':<EOL><INDENT>newname = name[:-<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>newname = name<EOL><DEDENT>info = typeinfo[english_upper(newname)]<EOL>assert(info[-<NUM_LIT:1>] == obj)  <EOL>bits = info[<NUM_LIT:2>]<EOL><DEDENT>except KeyError:     <EOL><INDENT>base, bits = _evalname(name)<EOL>char = base[<NUM_LIT:0>]<EOL><DEDENT>if name == '<STR_LIT>':<EOL><INDENT>char = '<STR_LIT:b>'<EOL>base = '<STR_LIT:bool>'<EOL><DEDENT>elif name=='<STR_LIT>':<EOL><INDENT>char = '<STR_LIT>'<EOL>base = '<STR_LIT>'<EOL><DEDENT>elif name=='<STR_LIT>':<EOL><INDENT>char = '<STR_LIT:O>'<EOL>base = '<STR_LIT:object>'<EOL>bits = <NUM_LIT:0><EOL><DEDENT>elif name=='<STR_LIT>':<EOL><INDENT>char = '<STR_LIT:M>'<EOL><DEDENT>elif name=='<STR_LIT>':<EOL><INDENT>char = '<STR_LIT:m>'<EOL><DEDENT>if sys.version_info[<NUM_LIT:0>] >= <NUM_LIT:3>:<EOL><INDENT>if name=='<STR_LIT>':<EOL><INDENT>char = '<STR_LIT:S>'<EOL>base = '<STR_LIT>'<EOL><DEDENT>elif name=='<STR_LIT>':<EOL><INDENT>char = '<STR_LIT>'<EOL>base = '<STR_LIT:str>'<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if name=='<STR_LIT>':<EOL><INDENT>char = '<STR_LIT:S>'<EOL>base = '<STR_LIT:string>'<EOL><DEDENT>elif name=='<STR_LIT>':<EOL><INDENT>char = '<STR_LIT>'<EOL>base = '<STR_LIT>'<EOL><DEDENT><DEDENT>bytes = bits // <NUM_LIT:8><EOL>if char != '<STR_LIT>' and bytes != <NUM_LIT:0>:<EOL><INDENT>char = \"<STR_LIT>\" % (char, bytes)<EOL><DEDENT>return base, bits, char<EOL>", "docstring": "Return a bit-width name for a given type object", "id": "f19046:m4"}
{"signature": "def issubclass_(arg1, arg2):", "body": "try:<EOL><INDENT>return issubclass(arg1, arg2)<EOL><DEDENT>except TypeError:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Determine if a class is a subclass of a second class.\n\n`issubclass_` is equivalent to the Python built-in ``issubclass``,\nexcept that it returns False instead of raising a TypeError is one\nof the arguments is not a class.\n\nParameters\n----------\narg1 : class\n    Input class. True is returned if `arg1` is a subclass of `arg2`.\narg2 : class or tuple of classes.\n    Input class. If a tuple of classes, True is returned if `arg1` is a\n    subclass of any of the tuple elements.\n\nReturns\n-------\nout : bool\n    Whether `arg1` is a subclass of `arg2` or not.\n\nSee Also\n--------\nissubsctype, issubdtype, issctype\n\nExamples\n--------\n>>> np.issubclass_(np.int32, np.int)\nTrue\n>>> np.issubclass_(np.int32, np.float)\nFalse", "id": "f19046:m15"}
{"signature": "def obj2sctype(rep, default=None):", "body": "try:<EOL><INDENT>if issubclass(rep, generic):<EOL><INDENT>return rep<EOL><DEDENT><DEDENT>except TypeError:<EOL><INDENT>pass<EOL><DEDENT>if isinstance(rep, dtype):<EOL><INDENT>return rep.type<EOL><DEDENT>if isinstance(rep, type):<EOL><INDENT>return _python_type(rep)<EOL><DEDENT>if isinstance(rep, ndarray):<EOL><INDENT>return rep.dtype.type<EOL><DEDENT>try:<EOL><INDENT>res = dtype(rep)<EOL><DEDENT>except:<EOL><INDENT>return default<EOL><DEDENT>return res.type<EOL>", "docstring": "Return the scalar dtype or NumPy equivalent of Python type of an object.\n\nParameters\n----------\nrep : any\n    The object of which the type is returned.\ndefault : any, optional\n    If given, this is returned for objects whose types can not be\n    determined. If not given, None is returned for those objects.\n\nReturns\n-------\ndtype : dtype or Python type\n    The data type of `rep`.\n\nSee Also\n--------\nsctype2char, issctype, issubsctype, issubdtype, maximum_sctype\n\nExamples\n--------\n>>> np.obj2sctype(np.int32)\n<type 'numpy.int32'>\n>>> np.obj2sctype(np.array([1., 2.]))\n<type 'numpy.float64'>\n>>> np.obj2sctype(np.array([1.j]))\n<type 'numpy.complex128'>\n\n>>> np.obj2sctype(dict)\n<type 'numpy.object_'>\n>>> np.obj2sctype('string')\n<type 'numpy.string_'>\n\n>>> np.obj2sctype(1, default=list)\n<type 'list'>", "id": "f19046:m14"}
{"signature": "def fromrecords(recList, dtype=None, shape=None, formats=None, names=None,<EOL>titles=None, aligned=False, byteorder=None):", "body": "nfields = len(recList[<NUM_LIT:0>])<EOL>if formats is None and dtype is None:  <EOL><INDENT>obj = sb.array(recList, dtype=object)<EOL>arrlist = [sb.array(obj[..., i].tolist()) for i in range(nfields)]<EOL>return fromarrays(arrlist, formats=formats, shape=shape, names=names,<EOL>titles=titles, aligned=aligned, byteorder=byteorder)<EOL><DEDENT>if dtype is not None:<EOL><INDENT>descr = sb.dtype((record, dtype))<EOL><DEDENT>else:<EOL><INDENT>descr = format_parser(formats, names, titles, aligned, byteorder)._descr<EOL><DEDENT>try:<EOL><INDENT>retval = sb.array(recList, dtype=descr)<EOL><DEDENT>except TypeError:  <EOL><INDENT>if (shape is None or shape == <NUM_LIT:0>):<EOL><INDENT>shape = len(recList)<EOL><DEDENT>if isinstance(shape, (int, long)):<EOL><INDENT>shape = (shape,)<EOL><DEDENT>if len(shape) > <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>_array = recarray(shape, descr)<EOL>for k in range(_array.size):<EOL><INDENT>_array[k] = tuple(recList[k])<EOL><DEDENT>return _array<EOL><DEDENT>else:<EOL><INDENT>if shape is not None and retval.shape != shape:<EOL><INDENT>retval.shape = shape<EOL><DEDENT><DEDENT>res = retval.view(recarray)<EOL>return res<EOL>", "docstring": "create a recarray from a list of records in text form\n\n        The data in the same field can be heterogeneous, they will be promoted\n        to the highest data type.  This method is intended for creating\n        smaller record arrays.  If used to create large array without formats\n        defined\n\n        r=fromrecords([(2,3.,'abc')]*100000)\n\n        it can be slow.\n\n        If formats is None, then this will auto-detect formats. Use list of\n        tuples rather than list of lists for faster processing.\n\n    >>> r=np.core.records.fromrecords([(456,'dbe',1.2),(2,'de',1.3)],\n    ... names='col1,col2,col3')\n    >>> print r[0]\n    (456, 'dbe', 1.2)\n    >>> r.col1\n    array([456,   2])\n    >>> r.col2\n    chararray(['dbe', 'de'],\n          dtype='|S3')\n    >>> import pickle\n    >>> print pickle.loads(pickle.dumps(r))\n    [(456, 'dbe', 1.2) (2, 'de', 1.3)]", "id": "f19047:m2"}
{"signature": "def fromarrays(arrayList, dtype=None, shape=None, formats=None,<EOL>names=None, titles=None, aligned=False, byteorder=None):", "body": "arrayList = [sb.asarray(x) for x in arrayList]<EOL>if shape is None or shape == <NUM_LIT:0>:<EOL><INDENT>shape = arrayList[<NUM_LIT:0>].shape<EOL><DEDENT>if isinstance(shape, int):<EOL><INDENT>shape = (shape,)<EOL><DEDENT>if formats is None and dtype is None:<EOL><INDENT>formats = []<EOL>for obj in arrayList:<EOL><INDENT>if not isinstance(obj, ndarray):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>formats.append(obj.dtype.str)<EOL><DEDENT>formats = '<STR_LIT:U+002C>'.join(formats)<EOL><DEDENT>if dtype is not None:<EOL><INDENT>descr = sb.dtype(dtype)<EOL>_names = descr.names<EOL><DEDENT>else:<EOL><INDENT>parsed = format_parser(formats, names, titles, aligned, byteorder)<EOL>_names = parsed._names<EOL>descr = parsed._descr<EOL><DEDENT>if len(descr) != len(arrayList):<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>d0 = descr[<NUM_LIT:0>].shape<EOL>nn = len(d0)<EOL>if nn > <NUM_LIT:0>:<EOL><INDENT>shape = shape[:-nn]<EOL><DEDENT>for k, obj in enumerate(arrayList):<EOL><INDENT>nn = len(descr[k].shape)<EOL>testshape = obj.shape[:len(obj.shape) - nn]<EOL>if testshape != shape:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % k)<EOL><DEDENT><DEDENT>_array = recarray(shape, descr)<EOL>for i in range(len(arrayList)):<EOL><INDENT>_array[_names[i]] = arrayList[i]<EOL><DEDENT>return _array<EOL>", "docstring": "create a record array from a (flat) list of arrays\n\n    >>> x1=np.array([1,2,3,4])\n    >>> x2=np.array(['a','dd','xyz','12'])\n    >>> x3=np.array([1.1,2,3,4])\n    >>> r = np.core.records.fromarrays([x1,x2,x3],names='a,b,c')\n    >>> print r[1]\n    (2, 'dd', 2.0)\n    >>> x1[1]=34\n    >>> r.a\n    array([1, 2, 3, 4])", "id": "f19047:m1"}
{"signature": "def __init__(self, float_conv=float,int_conv=int,<EOL>float_to_float=float,<EOL>float_to_str = lambda v:'<STR_LIT>' % v,<EOL>title = '<STR_LIT>'):", "body": "<EOL>with errstate(under='<STR_LIT:ignore>'):<EOL><INDENT>self._do_init(float_conv, int_conv, float_to_float, float_to_str, title)<EOL><DEDENT>", "docstring": "float_conv - convert integer to float (array)\nint_conv   - convert float (array) to integer\nfloat_to_float - convert float array to float\nfloat_to_str - convert array float to str\ntitle        - description of used floating point numbers", "id": "f19049:c0:m0"}
{"signature": "def _frz(a):", "body": "if a.ndim == <NUM_LIT:0>: a.shape = (<NUM_LIT:1>,)<EOL>return a<EOL>", "docstring": "fix rank-0 --> rank-1", "id": "f19050:m0"}
{"signature": "def title(a):", "body": "a_arr = numpy.asarray(a)<EOL>return _vec_string(a_arr, a_arr.dtype, '<STR_LIT:title>')<EOL>", "docstring": "Return element-wise title cased version of string or unicode.\n\nTitle case words start with uppercase characters, all remaining cased\ncharacters are lowercase.\n\nCalls `str.title` element-wise.\n\nFor 8-bit strings, this method is locale-dependent.\n\nParameters\n----------\na : array_like, {str, unicode}\n    Input array.\n\nReturns\n-------\nout : ndarray\n    Output array of str or unicode, depending on input type\n\nSee also\n--------\nstr.title\n\nExamples\n--------\n>>> c=np.array(['a1b c','1b ca','b ca1','ca1b'],'S5'); c\narray(['a1b c', '1b ca', 'b ca1', 'ca1b'],\n    dtype='|S5')\n>>> np.char.title(c)\narray(['A1B C', '1B Ca', 'B Ca1', 'Ca1B'],\n    dtype='|S5')", "id": "f19052:m47"}
{"signature": "def center(self, width, fillchar='<STR_LIT:U+0020>'):", "body": "return asarray(center(self, width, fillchar))<EOL>", "docstring": "Return a copy of `self` with its elements centered in a\nstring of length `width`.\n\nSee also\n--------\ncenter", "id": "f19052:c0:m17"}
{"signature": "def join(self, seq):", "body": "return join(self, seq)<EOL>", "docstring": "Return a string which is the concatenation of the strings in the\nsequence `seq`.\n\nSee also\n--------\nchar.join", "id": "f19052:c0:m32"}
{"signature": "def zfill(a, width):", "body": "a_arr = numpy.asarray(a)<EOL>width_arr = numpy.asarray(width)<EOL>size = long(numpy.max(width_arr.flat))<EOL>return _vec_string(<EOL>a_arr, (a_arr.dtype.type, size), '<STR_LIT>', (width_arr,))<EOL>", "docstring": "Return the numeric string left-filled with zeros\n\nCalls `str.zfill` element-wise.\n\nParameters\n----------\na : array_like, {str, unicode}\n    Input array.\nwidth : int\n    Width of string to left-fill elements in `a`.\n\nReturns\n-------\nout : ndarray, {str, unicode}\n    Output array of str or unicode, depending on input type\n\nSee also\n--------\nstr.zfill", "id": "f19052:m50"}
{"signature": "def replace(a, old, new, count=None):", "body": "return _to_string_or_unicode_array(<EOL>_vec_string(<EOL>a, object_, '<STR_LIT:replace>', [old, new] +_clean_args(count)))<EOL>", "docstring": "For each element in `a`, return a copy of the string with all\noccurrences of substring `old` replaced by `new`.\n\nCalls `str.replace` element-wise.\n\nParameters\n----------\na : array-like of str or unicode\n\nold, new : str or unicode\n\ncount : int, optional\n    If the optional argument `count` is given, only the first\n    `count` occurrences are replaced.\n\nReturns\n-------\nout : ndarray\n    Output array of str or unicode, depending on input type\n\nSee also\n--------\nstr.replace", "id": "f19052:m35"}
{"signature": "def zfill(self, width):", "body": "return asarray(zfill(self, width))<EOL>", "docstring": "Return the numeric string left-filled with zeros in a string of\nlength `width`.\n\nSee also\n--------\nchar.zfill", "id": "f19052:c0:m52"}
{"signature": "def isdigit(a):", "body": "return _vec_string(a, bool_, '<STR_LIT>')<EOL>", "docstring": "Returns true for each element if all characters in the string are\ndigits and there is at least one character, false otherwise.\n\nCalls `str.isdigit` element-wise.\n\nFor 8-bit strings, this method is locale-dependent.\n\nParameters\n----------\na : array_like of str or unicode\n\nReturns\n-------\nout : ndarray\n    Output array of bools\n\nSee also\n--------\nstr.isdigit", "id": "f19052:m25"}
{"signature": "def istitle(a):", "body": "return _vec_string(a, bool_, '<STR_LIT>')<EOL>", "docstring": "Returns true for each element if the element is a titlecased\nstring and there is at least one character, false otherwise.\n\nCall `str.istitle` element-wise.\n\nFor 8-bit strings, this method is locale-dependent.\n\nParameters\n----------\na : array_like of str or unicode\n\nReturns\n-------\nout : ndarray\n    Output array of bools\n\nSee also\n--------\nstr.istitle", "id": "f19052:m28"}
{"signature": "def lower(self):", "body": "return asarray(lower(self))<EOL>", "docstring": "Return an array with the elements of `self` converted to\nlowercase.\n\nSee also\n--------\nchar.lower", "id": "f19052:c0:m34"}
{"signature": "def add(x1, x2):", "body": "arr1 = numpy.asarray(x1)<EOL>arr2 = numpy.asarray(x2)<EOL>out_size = _get_num_chars(arr1) + _get_num_chars(arr2)<EOL>dtype = _use_unicode(arr1, arr2)<EOL>return _vec_string(arr1, (dtype, out_size), '<STR_LIT>', (arr2,))<EOL>", "docstring": "Return element-wise string concatenation for two arrays of str or unicode.\n\nArrays `x1` and `x2` must have the same shape.\n\nParameters\n----------\nx1 : array_like of str or unicode\n    Input array.\nx2 : array_like of str or unicode\n    Input array.\n\nReturns\n-------\nadd : ndarray\n    Output array of `string_` or `unicode_`, depending on input types\n    of the same shape as `x1` and `x2`.", "id": "f19052:m11"}
{"signature": "def isdecimal(self):", "body": "return isdecimal(self)<EOL>", "docstring": "For each element in `self`, return True if there are only\ndecimal characters in the element.\n\nSee also\n--------\nchar.isdecimal", "id": "f19052:c0:m54"}
{"signature": "def upper(a):", "body": "a_arr = numpy.asarray(a)<EOL>return _vec_string(a_arr, a_arr.dtype, '<STR_LIT>')<EOL>", "docstring": "Return an array with the elements converted to uppercase.\n\nCalls `str.upper` element-wise.\n\nFor 8-bit strings, this method is locale-dependent.\n\nParameters\n----------\na : array_like, {str, unicode}\n    Input array.\n\nReturns\n-------\nout : ndarray, {str, unicode}\n    Output array of str or unicode, depending on input type\n\nSee also\n--------\nstr.upper\n\nExamples\n--------\n>>> c = np.array(['a1b c', '1bca', 'bca1']); c\narray(['a1b c', '1bca', 'bca1'],\n    dtype='|S5')\n>>> np.char.upper(c)\narray(['A1B C', '1BCA', 'BCA1'],\n    dtype='|S5')", "id": "f19052:m49"}
{"signature": "def __le__(self, other):", "body": "return less_equal(self, other)<EOL>", "docstring": "Return (self <= other) element-wise.\n\nSee also\n--------\nless_equal", "id": "f19052:c0:m6"}
{"signature": "def lstrip(a, chars=None):", "body": "a_arr = numpy.asarray(a)<EOL>return _vec_string(a_arr, a_arr.dtype, '<STR_LIT>', (chars,))<EOL>", "docstring": "For each element in `a`, return a copy with the leading characters\nremoved.\n\nCalls `str.lstrip` element-wise.\n\nParameters\n----------\na : array-like, {str, unicode}\n    Input array.\n\nchars : {str, unicode}, optional\n    The `chars` argument is a string specifying the set of\n    characters to be removed. If omitted or None, the `chars`\n    argument defaults to removing whitespace. The `chars` argument\n    is not a prefix; rather, all combinations of its values are\n    stripped.\n\nReturns\n-------\nout : ndarray, {str, unicode}\n    Output array of str or unicode, depending on input type\n\nSee also\n--------\nstr.lstrip\n\nExamples\n--------\n>>> c = np.array(['aAaAaA', '  aA  ', 'abBABba'])\n>>> c\narray(['aAaAaA', '  aA  ', 'abBABba'],\n    dtype='|S7')\n\nThe 'a' variable is unstripped from c[1] because whitespace leading.\n\n>>> np.char.lstrip(c, 'a')\narray(['AaAaA', '  aA  ', 'bBABba'],\n    dtype='|S7')\n\n\n>>> np.char.lstrip(c, 'A') # leaves c unchanged\narray(['aAaAaA', '  aA  ', 'abBABba'],\n    dtype='|S7')\n>>> (np.char.lstrip(c, ' ') == np.char.lstrip(c, '')).all()\n... # XXX: is this a regression? this line now returns False\n... # np.char.lstrip(c,'') does not modify c at all.\nTrue\n>>> (np.char.lstrip(c, ' ') == np.char.lstrip(c, None)).all()\nTrue", "id": "f19052:m33"}
{"signature": "def _get_num_chars(a):", "body": "if issubclass(a.dtype.type, unicode_):<EOL><INDENT>return a.itemsize // <NUM_LIT:4><EOL><DEDENT>return a.itemsize<EOL>", "docstring": "Helper function that returns the number of characters per field in\na string or unicode array.  This is to abstract out the fact that\nfor a unicode array this is itemsize / 4.", "id": "f19052:m3"}
{"signature": "def startswith(a, prefix, start=<NUM_LIT:0>, end=None):", "body": "return _vec_string(<EOL>a, bool_, '<STR_LIT>', [prefix, start] + _clean_args(end))<EOL>", "docstring": "Returns a boolean array which is `True` where the string element\nin `a` starts with `prefix`, otherwise `False`.\n\nCalls `str.startswith` element-wise.\n\nParameters\n----------\na : array_like of str or unicode\n\nprefix : str\n\nstart, end : int, optional\n    With optional `start`, test beginning at that position. With\n    optional `end`, stop comparing at that position.\n\nReturns\n-------\nout : ndarray\n    Array of booleans\n\nSee also\n--------\nstr.startswith", "id": "f19052:m44"}
{"signature": "def split(a, sep=None, maxsplit=None):", "body": "<EOL>return _vec_string(<EOL>a, object_, '<STR_LIT>', [sep] + _clean_args(maxsplit))<EOL>", "docstring": "For each element in `a`, return a list of the words in the\nstring, using `sep` as the delimiter string.\n\nCalls `str.rsplit` element-wise.\n\nParameters\n----------\na : array_like of str or unicode\n\nsep : str or unicode, optional\n   If `sep` is not specified or `None`, any whitespace string is a\n   separator.\n\nmaxsplit : int, optional\n    If `maxsplit` is given, at most `maxsplit` splits are done.\n\nReturns\n-------\nout : ndarray\n    Array of list objects\n\nSee also\n--------\nstr.split, rsplit", "id": "f19052:m42"}
{"signature": "def lstrip(self, chars=None):", "body": "return asarray(lstrip(self, chars))<EOL>", "docstring": "For each element in `self`, return a copy with the leading characters\nremoved.\n\nSee also\n--------\nchar.lstrip", "id": "f19052:c0:m35"}
{"signature": "def replace(self, old, new, count=None):", "body": "return asarray(replace(self, old, new, count))<EOL>", "docstring": "For each element in `self`, return a copy of the string with all\noccurrences of substring `old` replaced by `new`.\n\nSee also\n--------\nchar.replace", "id": "f19052:c0:m37"}
{"signature": "def __mod__(self, i):", "body": "return asarray(mod(self, i))<EOL>", "docstring": "Return (self % i), that is pre-Python 2.6 string formatting\n(iterpolation), element-wise for a pair of array_likes of `string_`\nor `unicode_`.\n\nSee also\n--------\nmod", "id": "f19052:c0:m13"}
{"signature": "def __radd__(self, other):", "body": "return asarray(add(numpy.asarray(other), self))<EOL>", "docstring": "Return (other + self), that is string concatenation,\nelement-wise for a pair of array_likes of `string_` or `unicode_`.\n\nSee also\n--------\nadd", "id": "f19052:c0:m10"}
{"signature": "def isupper(self):", "body": "return isupper(self)<EOL>", "docstring": "Returns true for each element if all cased characters in the\nstring are uppercase and there is at least one character, false\notherwise.\n\nSee also\n--------\nchar.isupper", "id": "f19052:c0:m31"}
{"signature": "def upper(self):", "body": "return asarray(upper(self))<EOL>", "docstring": "Return an array with the elements of `self` converted to\nuppercase.\n\nSee also\n--------\nchar.upper", "id": "f19052:c0:m51"}
{"signature": "def asarray(obj, itemsize=None, unicode=None, order=None):", "body": "return array(obj, itemsize, copy=False,<EOL>unicode=unicode, order=order)<EOL>", "docstring": "Convert the input to a `chararray`, copying the data only if\nnecessary.\n\nVersus a regular Numpy array of type `str` or `unicode`, this\nclass adds the following functionality:\n\n  1) values automatically have whitespace removed from the end\n     when indexed\n\n  2) comparison operators automatically remove whitespace from the\n     end when comparing values\n\n  3) vectorized string operations are provided as methods\n     (e.g. `str.endswith`) and infix operators (e.g. +, *, %)\n\nParameters\n----------\nobj : array of str or unicode-like\n\nitemsize : int, optional\n    `itemsize` is the number of characters per scalar in the\n    resulting array.  If `itemsize` is None, and `obj` is an\n    object array or a Python list, the `itemsize` will be\n    automatically determined.  If `itemsize` is provided and `obj`\n    is of type str or unicode, then the `obj` string will be\n    chunked into `itemsize` pieces.\n\nunicode : bool, optional\n    When true, the resulting `chararray` can contain Unicode\n    characters, when false only 8-bit characters.  If unicode is\n    `None` and `obj` is one of the following:\n\n      - a `chararray`,\n      - an ndarray of type `str` or 'unicode`\n      - a Python str or unicode object,\n\n    then the unicode setting of the output array will be\n    automatically determined.\n\norder : {'C', 'F'}, optional\n    Specify the order of the array.  If order is 'C' (default), then the\n    array will be in C-contiguous order (last-index varies the\n    fastest).  If order is 'F', then the returned array\n    will be in Fortran-contiguous order (first-index varies the\n    fastest).", "id": "f19052:m54"}
{"signature": "def __ge__(self, other):", "body": "return greater_equal(self, other)<EOL>", "docstring": "Return (self >= other) element-wise.\n\nSee also\n--------\ngreater_equal", "id": "f19052:c0:m5"}
{"signature": "def rstrip(a, chars=None):", "body": "a_arr = numpy.asarray(a)<EOL>return _vec_string(a_arr, a_arr.dtype, '<STR_LIT>', (chars,))<EOL>", "docstring": "For each element in `a`, return a copy with the trailing\ncharacters removed.\n\nCalls `str.rstrip` element-wise.\n\nParameters\n----------\na : array-like of str or unicode\n\nchars : str or unicode, optional\n   The `chars` argument is a string specifying the set of\n   characters to be removed. If omitted or None, the `chars`\n   argument defaults to removing whitespace. The `chars` argument\n   is not a suffix; rather, all combinations of its values are\n   stripped.\n\nReturns\n-------\nout : ndarray\n    Output array of str or unicode, depending on input type\n\nSee also\n--------\nstr.rstrip\n\nExamples\n--------\n>>> c = np.array(['aAaAaA', 'abBABba'], dtype='S7'); c\narray(['aAaAaA', 'abBABba'],\n    dtype='|S7')\n>>> np.char.rstrip(c, 'a')\narray(['aAaAaA', 'abBABb'],\n    dtype='|S7')\n>>> np.char.rstrip(c, 'A')\narray(['aAaAa', 'abBABba'],\n    dtype='|S7')", "id": "f19052:m41"}
{"signature": "def rfind(self, sub, start=<NUM_LIT:0>, end=None):", "body": "return rfind(self, sub, start, end)<EOL>", "docstring": "For each element in `self`, return the highest index in the string\nwhere substring `sub` is found, such that `sub` is contained\nwithin [`start`, `end`].\n\nSee also\n--------\nchar.rfind", "id": "f19052:c0:m38"}
{"signature": "def isalnum(self):", "body": "return isalnum(self)<EOL>", "docstring": "Returns true for each element if all characters in the string\nare alphanumeric and there is at least one character, false\notherwise.\n\nSee also\n--------\nchar.isalnum", "id": "f19052:c0:m25"}
{"signature": "def greater_equal(x1, x2):", "body": "return compare_chararrays(x1, x2, '<STR_LIT>', True)<EOL>", "docstring": "Return (x1 >= x2) element-wise.\n\nUnlike `numpy.greater_equal`, this comparison is performed by\nfirst stripping whitespace characters from the end of the string.\nThis behavior is provided for backward-compatibility with\nnumarray.\n\nParameters\n----------\nx1, x2 : array_like of str or unicode\n    Input arrays of the same shape.\n\nReturns\n-------\nout : {ndarray, bool}\n    Output array of bools, or a single bool if x1 and x2 are scalars.\n\nSee Also\n--------\nequal, not_equal, less_equal, greater, less", "id": "f19052:m6"}
{"signature": "def encode(a, encoding=None, errors=None):", "body": "return _to_string_or_unicode_array(<EOL>_vec_string(a, object_, '<STR_LIT>', _clean_args(encoding, errors)))<EOL>", "docstring": "Calls `str.encode` element-wise.\n\nThe set of available codecs comes from the Python standard library,\nand may be extended at runtime. For more information, see the codecs\nmodule.\n\nParameters\n----------\na : array_like of str or unicode\n\nencoding : str, optional\n   The name of an encoding\n\nerrors : str, optional\n   Specifies how to handle encoding errors\n\nReturns\n-------\nout : ndarray\n\nSee also\n--------\nstr.encode\n\nNotes\n-----\nThe type of the result will depend on the encoding specified.", "id": "f19052:m18"}
{"signature": "def istitle(self):", "body": "return istitle(self)<EOL>", "docstring": "Returns true for each element if the element is a titlecased\nstring and there is at least one character, false otherwise.\n\nSee also\n--------\nchar.istitle", "id": "f19052:c0:m30"}
{"signature": "def endswith(a, suffix, start=<NUM_LIT:0>, end=None):", "body": "return _vec_string(<EOL>a, bool_, '<STR_LIT>', [suffix, start] + _clean_args(end))<EOL>", "docstring": "Returns a boolean array which is `True` where the string element\nin `a` ends with `suffix`, otherwise `False`.\n\nCalls `str.endswith` element-wise.\n\nParameters\n----------\na : array_like of str or unicode\n\nsuffix : str\n\nstart, end : int, optional\n    With optional `start`, test beginning at that position. With\n    optional `end`, stop comparing at that position.\n\nReturns\n-------\nout : ndarray\n    Outputs an array of bools.\n\nSee also\n--------\nstr.endswith\n\nExamples\n--------\n>>> s = np.array(['foo', 'bar'])\n>>> s[0] = 'foo'\n>>> s[1] = 'bar'\n>>> s\narray(['foo', 'bar'],\n    dtype='|S3')\n>>> np.char.endswith(s, 'ar')\narray([False,  True], dtype=bool)\n>>> np.char.endswith(s, 'a', start=1, end=2)\narray([False,  True], dtype=bool)", "id": "f19052:m19"}
{"signature": "def isdecimal(a):", "body": "if _use_unicode(a) != unicode_:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>return _vec_string(a, bool_, '<STR_LIT>')<EOL>", "docstring": "For each element, return True if there are only decimal\ncharacters in the element.\n\nCalls `unicode.isdecimal` element-wise.\n\nDecimal characters include digit characters, and all characters\nthat that can be used to form decimal-radix numbers,\ne.g. ``U+0660, ARABIC-INDIC DIGIT ZERO``.\n\nParameters\n----------\na : array_like, unicode\n    Input array.\n\nReturns\n-------\nout : ndarray, bool\n    Array of booleans identical in shape to `a`.\n\nSee also\n--------\nunicode.isdecimal", "id": "f19052:m52"}
{"signature": "def decode(a, encoding=None, errors=None):", "body": "return _to_string_or_unicode_array(<EOL>_vec_string(a, object_, '<STR_LIT>', _clean_args(encoding, errors)))<EOL>", "docstring": "Calls `str.decode` element-wise.\n\nThe set of available codecs comes from the Python standard library,\nand may be extended at runtime.  For more information, see the\n:mod:`codecs` module.\n\nParameters\n----------\na : array_like of str or unicode\n\nencoding : str, optional\n   The name of an encoding\n\nerrors : str, optional\n   Specifies how to handle encoding errors\n\nReturns\n-------\nout : ndarray\n\nSee also\n--------\nstr.decode\n\nNotes\n-----\nThe type of the result will depend on the encoding specified.\n\nExamples\n--------\n>>> c = np.array(['aAaAaA', '  aA  ', 'abBABba'])\n>>> c\narray(['aAaAaA', '  aA  ', 'abBABba'],\n    dtype='|S7')\n>>> np.char.encode(c, encoding='cp037')\narray(['\\\\x81\\\\xc1\\\\x81\\\\xc1\\\\x81\\\\xc1', '@@\\\\x81\\\\xc1@@',\n    '\\\\x81\\\\x82\\\\xc2\\\\xc1\\\\xc2\\\\x82\\\\x81'],\n    dtype='|S7')", "id": "f19052:m17"}
{"signature": "def is_released(config):", "body": "from distutils.version import LooseVersion<EOL>v = config.get_version('<STR_LIT>')<EOL>if v is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>pv = LooseVersion(vstring=v).version<EOL>if len(pv) > <NUM_LIT:3>:<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "Return True if a released version of numpy is detected.", "id": "f19055:m0"}
{"signature": "def check_api_version(apiversion, codegen_dir):", "body": "curapi_hash, api_hash = get_api_versions(apiversion, codegen_dir)<EOL>if not curapi_hash == api_hash:<EOL><INDENT>msg = \"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"\"<STR_LIT>\"<EOL>warnings.warn(msg % (apiversion, curapi_hash, apiversion, api_hash,<EOL>__file__),<EOL>MismatchCAPIWarning)<EOL><DEDENT>", "docstring": "Emits a MismacthCAPIWarning if the C API version needs updating.", "id": "f19055:m2"}
{"signature": "def _add_trailing_padding(value, padding):", "body": "from numpy.core.multiarray import dtype<EOL>if value.fields is None:<EOL><INDENT>vfields = {'<STR_LIT>': (value, <NUM_LIT:0>)}<EOL><DEDENT>else:<EOL><INDENT>vfields = dict(value.fields)<EOL><DEDENT>if value.names and value.names[-<NUM_LIT:1>] == '<STR_LIT>' andvalue['<STR_LIT>'].char == '<STR_LIT>':<EOL><INDENT>vfields['<STR_LIT>'] = ('<STR_LIT>' % (vfields['<STR_LIT>'][<NUM_LIT:0>].itemsize + padding),<EOL>vfields['<STR_LIT>'][<NUM_LIT:1>])<EOL>value = dtype(vfields)<EOL><DEDENT>else:<EOL><INDENT>j = <NUM_LIT:0><EOL>while True:<EOL><INDENT>name = '<STR_LIT>' % j<EOL>if name not in vfields:<EOL><INDENT>vfields[name] = ('<STR_LIT>' % padding, value.itemsize)<EOL>break<EOL><DEDENT>j += <NUM_LIT:1><EOL><DEDENT>value = dtype(vfields)<EOL>if '<STR_LIT>' not in vfields:<EOL><INDENT>names = list(value.names)<EOL>names[-<NUM_LIT:1>] = '<STR_LIT>'<EOL>value.names = tuple(names)<EOL><DEDENT><DEDENT>return value<EOL>", "docstring": "Inject the specified number of padding bytes at the end of a dtype", "id": "f19056:m9"}
{"signature": "def indices(dimensions, dtype=int):", "body": "dimensions = tuple(dimensions)<EOL>N = len(dimensions)<EOL>if N == <NUM_LIT:0>:<EOL><INDENT>return array([], dtype=dtype)<EOL><DEDENT>res = empty((N,)+dimensions, dtype=dtype)<EOL>for i, dim in enumerate(dimensions):<EOL><INDENT>tmp = arange(dim, dtype=dtype)<EOL>tmp.shape = (<NUM_LIT:1>,)*i + (dim,)+(<NUM_LIT:1>,)*(N-i-<NUM_LIT:1>)<EOL>newdim = dimensions[:i] + (<NUM_LIT:1>,)+ dimensions[i+<NUM_LIT:1>:]<EOL>val = zeros(newdim, dtype)<EOL>add(tmp, val, res[i])<EOL><DEDENT>return res<EOL>", "docstring": "Return an array representing the indices of a grid.\n\nCompute an array where the subarrays contain index values 0,1,...\nvarying only along the corresponding axis.\n\nParameters\n----------\ndimensions : sequence of ints\n    The shape of the grid.\ndtype : dtype, optional\n    Data type of the result.\n\nReturns\n-------\ngrid : ndarray\n    The array of grid indices,\n    ``grid.shape = (len(dimensions),) + tuple(dimensions)``.\n\nSee Also\n--------\nmgrid, meshgrid\n\nNotes\n-----\nThe output shape is obtained by prepending the number of dimensions\nin front of the tuple of dimensions, i.e. if `dimensions` is a tuple\n``(r0, ..., rN-1)`` of length ``N``, the output shape is\n``(N,r0,...,rN-1)``.\n\nThe subarrays ``grid[k]`` contains the N-D array of indices along the\n``k-th`` axis. Explicitly::\n\n    grid[k,i0,i1,...,iN-1] = ik\n\nExamples\n--------\n>>> grid = np.indices((2, 3))\n>>> grid.shape\n(2, 2, 3)\n>>> grid[0]        # row indices\narray([[0, 0, 0],\n       [1, 1, 1]])\n>>> grid[1]        # column indices\narray([[0, 1, 2],\n       [0, 1, 2]])\n\nThe indices can be used as an index into an array.\n\n>>> x = np.arange(20).reshape(5, 4)\n>>> row, col = np.indices((2, 3))\n>>> x[row, col]\narray([[0, 1, 2],\n       [4, 5, 6]])\n\nNote that it would be more straightforward in the above example to\nextract the required elements directly with ``x[:2, :3]``.", "id": "f19057:m26"}
{"signature": "def correlate(a, v, mode='<STR_LIT>', old_behavior=False):", "body": "mode = _mode_from_name(mode)<EOL>e old behavior should be made available under a different name, see thread<EOL>tp://thread.gmane.org/gmane.comp.python.numeric.general/<NUM_LIT>/focus=<NUM_LIT><EOL>if old_behavior:<EOL><INDENT>warnings.warn(\"\"\"<STR_LIT>\"\"\",<EOL>DeprecationWarning)<EOL>return multiarray.correlate(a, v, mode)<EOL><DEDENT>else:<EOL><INDENT>return multiarray.correlate2(a, v, mode)<EOL><DEDENT>", "docstring": "Cross-correlation of two 1-dimensional sequences.\n\nThis function computes the correlation as generally defined in signal\nprocessing texts::\n\n    c_{av}[k] = sum_n a[n+k] * conj(v[n])\n\nwith a and v sequences being zero-padded where necessary and conj being\nthe conjugate.\n\nParameters\n----------\na, v : array_like\n    Input sequences.\nmode : {'valid', 'same', 'full'}, optional\n    Refer to the `convolve` docstring.  Note that the default\n    is `valid`, unlike `convolve`, which uses `full`.\nold_behavior : bool\n    If True, uses the old behavior from Numeric,\n    (correlate(a,v) == correlate(v,a), and the conjugate is not taken\n    for complex arrays). If False, uses the conventional signal\n    processing definition.\n\nReturns\n-------\nout : ndarray\n    Discrete cross-correlation of `a` and `v`.\n\nSee Also\n--------\nconvolve : Discrete, linear convolution of two one-dimensional sequences.\n\nNotes\n-----\nThe definition of correlation above is not unique and sometimes correlation\nmay be defined differently. Another common definition is::\n\n    c'_{av}[k] = sum_n a[n] conj(v[n+k])\n\nwhich is related to ``c_{av}[k]`` by ``c'_{av}[k] = c_{av}[-k]``.\n\nExamples\n--------\n>>> np.correlate([1, 2, 3], [0, 1, 0.5])\narray([ 3.5])\n>>> np.correlate([1, 2, 3], [0, 1, 0.5], \"same\")\narray([ 2. ,  3.5,  3. ])\n>>> np.correlate([1, 2, 3], [0, 1, 0.5], \"full\")\narray([ 0.5,  2. ,  3.5,  3. ,  0. ])\n\nUsing complex sequences:\n\n>>> np.correlate([1+1j, 2, 3-1j], [0, 1, 0.5j], 'full')\narray([ 0.5-0.5j,  1.0+0.j ,  1.5-1.5j,  3.0-1.j ,  0.0+0.j ])\n\nNote that you get the time reversed, complex conjugated result\nwhen the two input sequences change places, i.e.,\n``c_{va}[k] = c^{*}_{av}[-k]``:\n\n>>> np.correlate([0, 1, 0.5j], [1+1j, 2, 3-1j], 'full')\narray([ 0.0+0.j ,  3.0+1.j ,  1.5+1.5j,  1.0+0.j ,  0.5+0.5j])", "id": "f19057:m15"}
{"signature": "def setbufsize(size):", "body": "if size > <NUM_LIT>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % size)<EOL><DEDENT>if size < <NUM_LIT:5>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" %size)<EOL><DEDENT>if size % <NUM_LIT:16> != <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" %size)<EOL><DEDENT>pyvals = umath.geterrobj()<EOL>old = getbufsize()<EOL>pyvals[<NUM_LIT:0>] = size<EOL>umath.seterrobj(pyvals)<EOL>return old<EOL>", "docstring": "Set the size of the buffer used in ufuncs.\n\nParameters\n----------\nsize : int\n    Size of buffer.", "id": "f19057:m40"}
{"signature": "def isfortran(a):", "body": "return a.flags.fnc<EOL>", "docstring": "Returns True if array is arranged in Fortran-order in memory\nand not C-order.\n\nParameters\n----------\na : ndarray\n    Input array.\n\n\nExamples\n--------\n\nnp.array allows to specify whether the array is written in C-contiguous\norder (last index varies the fastest), or FORTRAN-contiguous order in\nmemory (first index varies the fastest).\n\n>>> a = np.array([[1, 2, 3], [4, 5, 6]], order='C')\n>>> a\narray([[1, 2, 3],\n       [4, 5, 6]])\n>>> np.isfortran(a)\nFalse\n\n>>> b = np.array([[1, 2, 3], [4, 5, 6]], order='FORTRAN')\n>>> b\narray([[1, 2, 3],\n       [4, 5, 6]])\n>>> np.isfortran(b)\nTrue\n\n\nThe transpose of a C-ordered array is a FORTRAN-ordered array.\n\n>>> a = np.array([[1, 2, 3], [4, 5, 6]], order='C')\n>>> a\narray([[1, 2, 3],\n       [4, 5, 6]])\n>>> np.isfortran(a)\nFalse\n>>> b = a.T\n>>> b\narray([[1, 4],\n       [2, 5],\n       [3, 6]])\n>>> np.isfortran(b)\nTrue\n\nC-ordered arrays evaluate as False even if they are also FORTRAN-ordered.\n\n>>> np.isfortran(np.array([1, 2], order='FORTRAN'))\nFalse", "id": "f19057:m11"}
{"signature": "def binary_repr(num, width=None):", "body": "<EOL>sign = '<STR_LIT>'<EOL>if num < <NUM_LIT:0>:<EOL><INDENT>if width is None:<EOL><INDENT>sign = '<STR_LIT:->'<EOL>num = -num<EOL><DEDENT>else:<EOL><INDENT>num = <NUM_LIT:2>**width + num<EOL><DEDENT><DEDENT>elif num == <NUM_LIT:0>:<EOL><INDENT>return '<STR_LIT:0>'*(width or <NUM_LIT:1>)<EOL><DEDENT>ostr = hex(num)<EOL>bin = '<STR_LIT>'.join([_lkup[ch] for ch in ostr[<NUM_LIT:2>:]])<EOL>bin = bin.lstrip('<STR_LIT:0>')<EOL>if width is not None:<EOL><INDENT>bin = bin.zfill(width)<EOL><DEDENT>return sign + bin<EOL>", "docstring": "Return the binary representation of the input number as a string.\n\nFor negative numbers, if width is not given, a minus sign is added to the\nfront. If width is given, the two's complement of the number is\nreturned, with respect to that width.\n\nIn a two's-complement system negative numbers are represented by the two's\ncomplement of the absolute value. This is the most common method of\nrepresenting signed integers on computers [1]_. A N-bit two's-complement\nsystem can represent every integer in the range\n:math:`-2^{N-1}` to :math:`+2^{N-1}-1`.\n\nParameters\n----------\nnum : int\n    Only an integer decimal number can be used.\nwidth : int, optional\n    The length of the returned string if `num` is positive, the length of\n    the two's complement if `num` is negative.\n\nReturns\n-------\nbin : str\n    Binary representation of `num` or two's complement of `num`.\n\nSee Also\n--------\nbase_repr: Return a string representation of a number in the given base\n           system.\n\nNotes\n-----\n`binary_repr` is equivalent to using `base_repr` with base 2, but about 25x\nfaster.\n\nReferences\n----------\n.. [1] Wikipedia, \"Two's complement\",\n    http://en.wikipedia.org/wiki/Two's_complement\n\nExamples\n--------\n>>> np.binary_repr(3)\n'11'\n>>> np.binary_repr(-3)\n'-11'\n>>> np.binary_repr(3, width=4)\n'0011'\n\nThe two's complement is returned when the input number is negative and\nwidth is specified:\n\n>>> np.binary_repr(-3, width=4)\n'1101'", "id": "f19057:m29"}
{"signature": "def load(file):", "body": "if isinstance(file, type(\"<STR_LIT>\")):<EOL><INDENT>file = open(file, \"<STR_LIT:rb>\")<EOL><DEDENT>return pickle.load(file)<EOL>", "docstring": "Wrapper around cPickle.load which accepts either a file-like object or\na filename.\n\nNote that the NumPy binary format is not based on pickle/cPickle anymore.\nFor details on the preferred way of loading and saving files, see `load`\nand `save`.\n\nSee Also\n--------\nload, save", "id": "f19057:m31"}
{"signature": "def set_string_function(f, repr=True):", "body": "if f is None:<EOL><INDENT>if repr:<EOL><INDENT>return multiarray.set_string_function(array_repr, <NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>return multiarray.set_string_function(array_str, <NUM_LIT:0>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return multiarray.set_string_function(f, repr)<EOL><DEDENT>", "docstring": "Set a Python function to be used when pretty printing arrays.\n\nParameters\n----------\nf : function or None\n    Function to be used to pretty print arrays. The function should expect\n    a single array argument and return a string of the representation of\n    the array. If None, the function is reset to the default NumPy function\n    to print arrays.\nrepr : bool, optional\n    If True (default), the function for pretty printing (``__repr__``)\n    is set, if False the function that returns the default string\n    representation (``__str__``) is set.\n\nSee Also\n--------\nset_printoptions, get_printoptions\n\nExamples\n--------\n>>> def pprint(arr):\n...     return 'HA! - What are you going to do now?'\n...\n>>> np.set_string_function(pprint)\n>>> a = np.arange(10)\n>>> a\nHA! - What are you going to do now?\n>>> print a\n[0 1 2 3 4 5 6 7 8 9]\n\nWe can reset the function to the default:\n\n>>> np.set_string_function(None)\n>>> a\narray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])\n\n`repr` affects either pretty printing or normal string representation.\nNote that ``__repr__`` is still affected by setting ``__str__``\nbecause the width of each array element in the returned string becomes\nequal to the length of the result of ``__str__()``.\n\n>>> x = np.arange(4)\n>>> np.set_string_function(lambda x:'random', repr=False)\n>>> x.__str__()\n'random'\n>>> x.__repr__()\n'array([     0,      1,      2,      3])'", "id": "f19057:m25"}
{"signature": "def getbufsize():", "body": "return umath.geterrobj()[<NUM_LIT:0>]<EOL>", "docstring": "Return the size of the buffer used in ufuncs.\n\nReturns\n-------\ngetbufsize : int\n    Size of ufunc buffer in bytes.", "id": "f19057:m41"}
{"signature": "def array_equal(a1, a2):", "body": "try:<EOL><INDENT>a1, a2 = asarray(a1), asarray(a2)<EOL><DEDENT>except:<EOL><INDENT>return False<EOL><DEDENT>if a1.shape != a2.shape:<EOL><INDENT>return False<EOL><DEDENT>return bool(asarray(a1 == a2).all())<EOL>", "docstring": "True if two arrays have the same shape and elements, False otherwise.\n\nParameters\n----------\na1, a2 : array_like\n    Input arrays.\n\nReturns\n-------\nb : bool\n    Returns True if the arrays are equal.\n\nSee Also\n--------\nallclose: Returns True if two arrays are element-wise equal within a\n          tolerance.\narray_equiv: Returns True if input arrays are shape consistent and all\n             elements equal.\n\nExamples\n--------\n>>> np.array_equal([1, 2], [1, 2])\nTrue\n>>> np.array_equal(np.array([1, 2]), np.array([1, 2]))\nTrue\n>>> np.array_equal([1, 2], [1, 2, 3])\nFalse\n>>> np.array_equal([1, 2], [1, 4])\nFalse", "id": "f19057:m36"}
{"signature": "def geterr():", "body": "maskvalue = umath.geterrobj()[<NUM_LIT:1>]<EOL>mask = <NUM_LIT:7><EOL>res = {}<EOL>val = (maskvalue >> SHIFT_DIVIDEBYZERO) & mask<EOL>res['<STR_LIT>'] = _errdict_rev[val]<EOL>val = (maskvalue >> SHIFT_OVERFLOW) & mask<EOL>res['<STR_LIT>'] = _errdict_rev[val]<EOL>val = (maskvalue >> SHIFT_UNDERFLOW) & mask<EOL>res['<STR_LIT>'] = _errdict_rev[val]<EOL>val = (maskvalue >> SHIFT_INVALID) & mask<EOL>res['<STR_LIT>'] = _errdict_rev[val]<EOL>return res<EOL>", "docstring": "Get the current way of handling floating-point errors.\n\nReturns\n-------\nres : dict\n    A dictionary with keys \"divide\", \"over\", \"under\", and \"invalid\",\n    whose values are from the strings \"ignore\", \"print\", \"log\", \"warn\",\n    \"raise\", and \"call\". The keys represent possible floating-point\n    exceptions, and the values define how these exceptions are handled.\n\nSee Also\n--------\ngeterrcall, seterr, seterrcall\n\nNotes\n-----\nFor complete documentation of the types of floating-point exceptions and\ntreatment options, see `seterr`.\n\nExamples\n--------\n>>> np.geterr()\n{'over': 'warn', 'divide': 'warn', 'invalid': 'warn',\n'under': 'ignore'}\n>>> np.arange(3.) / np.arange(3.)\narray([ NaN,   1.,   1.])\n\n>>> oldsettings = np.seterr(all='warn', over='raise')\n>>> np.geterr()\n{'over': 'raise', 'divide': 'warn', 'invalid': 'warn', 'under': 'warn'}\n>>> np.arange(3.) / np.arange(3.)\n__main__:1: RuntimeWarning: invalid value encountered in divide\narray([ NaN,   1.,   1.])", "id": "f19057:m39"}
{"signature": "def irfftn(a, s=None, axes=None):", "body": "a = asarray(a).astype(complex)<EOL>s, axes = _cook_nd_args(a, s, axes, invreal=<NUM_LIT:1>)<EOL>for ii in range(len(axes)-<NUM_LIT:1>):<EOL><INDENT>a = ifft(a, s[ii], axes[ii])<EOL><DEDENT>a = irfft(a, s[-<NUM_LIT:1>], axes[-<NUM_LIT:1>])<EOL>return a<EOL>", "docstring": "Compute the inverse of the N-dimensional FFT of real input.\n\nThis function computes the inverse of the N-dimensional discrete\nFourier Transform for real input over any number of axes in an\nM-dimensional array by means of the Fast Fourier Transform (FFT).  In\nother words, ``irfftn(rfftn(a), a.shape) == a`` to within numerical\naccuracy. (The ``a.shape`` is necessary like ``len(a)`` is for `irfft`,\nand for the same reason.)\n\nThe input should be ordered in the same way as is returned by `rfftn`,\ni.e. as for `irfft` for the final transformation axis, and as for `ifftn`\nalong all the other axes.\n\nParameters\n----------\na : array_like\n    Input array.\ns : sequence of ints, optional\n    Shape (length of each transformed axis) of the output\n    (``s[0]`` refers to axis 0, ``s[1]`` to axis 1, etc.). `s` is also the\n    number of input points used along this axis, except for the last axis,\n    where ``s[-1]//2+1`` points of the input are used.\n    Along any axis, if the shape indicated by `s` is smaller than that of\n    the input, the input is cropped.  If it is larger, the input is padded\n    with zeros. If `s` is not given, the shape of the input along the\n    axes specified by `axes` is used.\naxes : sequence of ints, optional\n    Axes over which to compute the inverse FFT. If not given, the last\n    `len(s)` axes are used, or all axes if `s` is also not specified.\n    Repeated indices in `axes` means that the inverse transform over that\n    axis is performed multiple times.\n\nReturns\n-------\nout : ndarray\n    The truncated or zero-padded input, transformed along the axes\n    indicated by `axes`, or by a combination of `s` or `a`,\n    as explained in the parameters section above.\n    The length of each transformed axis is as given by the corresponding\n    element of `s`, or the length of the input in every axis except for the\n    last one if `s` is not given.  In the final transformed axis the length\n    of the output when `s` is not given is ``2*(m-1)`` where ``m`` is the\n    length of the final transformed axis of the input.  To get an odd\n    number of output points in the final axis, `s` must be specified.\n\nRaises\n------\nValueError\n    If `s` and `axes` have different length.\nIndexError\n    If an element of `axes` is larger than than the number of axes of `a`.\n\nSee Also\n--------\nrfftn : The forward n-dimensional FFT of real input,\n        of which `ifftn` is the inverse.\nfft : The one-dimensional FFT, with definitions and conventions used.\nirfft : The inverse of the one-dimensional FFT of real input.\nirfft2 : The inverse of the two-dimensional FFT of real input.\n\nNotes\n-----\nSee `fft` for definitions and conventions used.\n\nSee `rfft` for definitions and conventions used for real input.\n\nExamples\n--------\n>>> a = np.zeros((3, 2, 2))\n>>> a[0, 0, 0] = 3 * 2 * 2\n>>> np.fft.irfftn(a)\narray([[[ 1.,  1.],\n        [ 1.,  1.]],\n       [[ 1.,  1.],\n        [ 1.,  1.]],\n       [[ 1.,  1.],\n        [ 1.,  1.]]])", "id": "f19063:m15"}
{"signature": "def ifft(a, n=None, axis=-<NUM_LIT:1>):", "body": "a = asarray(a).astype(complex)<EOL>if n is None:<EOL><INDENT>n = shape(a)[axis]<EOL><DEDENT>return _raw_fft(a, n, axis, fftpack.cffti, fftpack.cfftb, _fft_cache) / n<EOL>", "docstring": "Compute the one-dimensional inverse discrete Fourier Transform.\n\nThis function computes the inverse of the one-dimensional *n*-point\ndiscrete Fourier transform computed by `fft`.  In other words,\n``ifft(fft(a)) == a`` to within numerical accuracy.\nFor a general description of the algorithm and definitions,\nsee `numpy.fft`.\n\nThe input should be ordered in the same way as is returned by `fft`,\ni.e., ``a[0]`` should contain the zero frequency term,\n``a[1:n/2+1]`` should contain the positive-frequency terms, and\n``a[n/2+1:]`` should contain the negative-frequency terms, in order of\ndecreasingly negative frequency.  See `numpy.fft` for details.\n\nParameters\n----------\na : array_like\n    Input array, can be complex.\nn : int, optional\n    Length of the transformed axis of the output.\n    If `n` is smaller than the length of the input, the input is cropped.\n    If it is larger, the input is padded with zeros.  If `n` is not given,\n    the length of the input along the axis specified by `axis` is used.\n    See notes about padding issues.\naxis : int, optional\n    Axis over which to compute the inverse DFT.  If not given, the last\n    axis is used.\n\nReturns\n-------\nout : complex ndarray\n    The truncated or zero-padded input, transformed along the axis\n    indicated by `axis`, or the last one if `axis` is not specified.\n\nRaises\n------\nIndexError\n    If `axes` is larger than the last axis of `a`.\n\nSee Also\n--------\nnumpy.fft : An introduction, with definitions and general explanations.\nfft : The one-dimensional (forward) FFT, of which `ifft` is the inverse\nifft2 : The two-dimensional inverse FFT.\nifftn : The n-dimensional inverse FFT.\n\nNotes\n-----\nIf the input parameter `n` is larger than the size of the input, the input\nis padded by appending zeros at the end.  Even though this is the common\napproach, it might lead to surprising results.  If a different padding is\ndesired, it must be performed before calling `ifft`.\n\nExamples\n--------\n>>> np.fft.ifft([0, 4, 0, 0])\narray([ 1.+0.j,  0.+1.j, -1.+0.j,  0.-1.j])\n\nCreate and plot a band-limited signal with random phases:\n\n>>> import matplotlib.pyplot as plt\n>>> t = np.arange(400)\n>>> n = np.zeros((400,), dtype=complex)\n>>> n[40:60] = np.exp(1j*np.random.uniform(0, 2*np.pi, (20,)))\n>>> s = np.fft.ifft(n)\n>>> plt.plot(t, s.real, 'b-', t, s.imag, 'r--')\n[<matplotlib.lines.Line2D object at 0x...>, <matplotlib.lines.Line2D object at 0x...>]\n>>> plt.legend(('real', 'imaginary'))\n<matplotlib.legend.Legend object at 0x...>\n>>> plt.show()", "id": "f19063:m2"}
{"signature": "def log(x):", "body": "x = _fix_real_lt_zero(x)<EOL>return nx.log(x)<EOL>", "docstring": "Compute the natural logarithm of `x`.\n\nReturn the \"principal value\" (for a description of this, see `numpy.log`)\nof :math:`log_e(x)`. For real `x > 0`, this is a real number (``log(0)``\nreturns ``-inf`` and ``log(np.inf)`` returns ``inf``). Otherwise, the\ncomplex principle value is returned.\n\nParameters\n----------\nx : array_like\n   The value(s) whose log is (are) required.\n\nReturns\n-------\nout : ndarray or scalar\n   The log of the `x` value(s). If `x` was a scalar, so is `out`,\n   otherwise an array is returned.\n\nSee Also\n--------\nnumpy.log\n\nNotes\n-----\nFor a log() that returns ``NAN`` when real `x < 0`, use `numpy.log`\n(note, however, that otherwise `numpy.log` and this `log` are identical,\ni.e., both return ``-inf`` for `x = 0`, ``inf`` for `x = inf`, and,\nnotably, the complex principle value if ``x.imag != 0``).\n\nExamples\n--------\n>>> np.emath.log(np.exp(1))\n1.0\n\nNegative arguments are handled \"correctly\" (recall that\n``exp(log(x)) == x`` does *not* hold for real ``x < 0``):\n\n>>> np.emath.log(-np.exp(1)) == (1 + np.pi * 1j)\nTrue", "id": "f19086:m5"}
{"signature": "def _fix_real_abs_gt_1(x):", "body": "x = asarray(x)<EOL>if any(isreal(x) & (abs(x) > <NUM_LIT:1>)):<EOL><INDENT>x = _tocomplex(x)<EOL><DEDENT>return x<EOL>", "docstring": "Convert `x` to complex if it has real components x_i with abs(x_i)>1.\n\n    Otherwise, output is just the array version of the input (via asarray).\n\n    Parameters\n    ----------\n    x : array_like\n\n    Returns\n    -------\n    array\n\n    Examples\n    --------\n    >>> np.lib.scimath._fix_real_abs_gt_1([0,1])\n    array([0, 1])\n\n    >>> np.lib.scimath._fix_real_abs_gt_1([0,2])\n    array([ 0.+0.j,  2.+0.j])", "id": "f19086:m3"}
{"signature": "def arcsin(x):", "body": "x = _fix_real_abs_gt_1(x)<EOL>return nx.arcsin(x)<EOL>", "docstring": "Compute the inverse sine of x.\n\nReturn the \"principal value\" (for a description of this, see\n`numpy.arcsin`) of the inverse sine of `x`. For real `x` such that\n`abs(x) <= 1`, this is a real number in the closed interval\n:math:`[-\\\\pi/2, \\\\pi/2]`.  Otherwise, the complex principle value is\nreturned.\n\nParameters\n----------\nx : array_like or scalar\n   The value(s) whose arcsin is (are) required.\n\nReturns\n-------\nout : ndarray or scalar\n   The inverse sine(s) of the `x` value(s). If `x` was a scalar, so\n   is `out`, otherwise an array object is returned.\n\nSee Also\n--------\nnumpy.arcsin\n\nNotes\n-----\nFor an arcsin() that returns ``NAN`` when real `x` is not in the\ninterval ``[-1,1]``, use `numpy.arcsin`.\n\nExamples\n--------\n>>> np.set_printoptions(precision=4)\n\n>>> np.emath.arcsin(0)\n0.0\n\n>>> np.emath.arcsin([0,1])\narray([ 0.    ,  1.5708])", "id": "f19086:m11"}
{"signature": "def sqrt(x):", "body": "x = _fix_real_lt_zero(x)<EOL>return nx.sqrt(x)<EOL>", "docstring": "Compute the square root of x.\n\nFor negative input elements, a complex value is returned\n(unlike `numpy.sqrt` which returns NaN).\n\nParameters\n----------\nx : array_like\n   The input value(s).\n\nReturns\n-------\nout : ndarray or scalar\n   The square root of `x`. If `x` was a scalar, so is `out`,\n   otherwise an array is returned.\n\nSee Also\n--------\nnumpy.sqrt\n\nExamples\n--------\nFor real, non-negative inputs this works just like `numpy.sqrt`:\n\n>>> np.lib.scimath.sqrt(1)\n1.0\n>>> np.lib.scimath.sqrt([1, 4])\narray([ 1.,  2.])\n\nBut it automatically handles negative inputs:\n\n>>> np.lib.scimath.sqrt(-1)\n(0.0+1.0j)\n>>> np.lib.scimath.sqrt([-1,4])\narray([ 0.+1.j,  2.+0.j])", "id": "f19086:m4"}
{"signature": "def log10(x):", "body": "x = _fix_real_lt_zero(x)<EOL>return nx.log10(x)<EOL>", "docstring": "Compute the logarithm base 10 of `x`.\n\nReturn the \"principal value\" (for a description of this, see\n`numpy.log10`) of :math:`log_{10}(x)`. For real `x > 0`, this\nis a real number (``log10(0)`` returns ``-inf`` and ``log10(np.inf)``\nreturns ``inf``). Otherwise, the complex principle value is returned.\n\nParameters\n----------\nx : array_like or scalar\n   The value(s) whose log base 10 is (are) required.\n\nReturns\n-------\nout : ndarray or scalar\n   The log base 10 of the `x` value(s). If `x` was a scalar, so is `out`,\n   otherwise an array object is returned.\n\nSee Also\n--------\nnumpy.log10\n\nNotes\n-----\nFor a log10() that returns ``NAN`` when real `x < 0`, use `numpy.log10`\n(note, however, that otherwise `numpy.log10` and this `log10` are\nidentical, i.e., both return ``-inf`` for `x = 0`, ``inf`` for `x = inf`,\nand, notably, the complex principle value if ``x.imag != 0``).\n\nExamples\n--------\n\n(We set the printing precision so the example can be auto-tested)\n\n>>> np.set_printoptions(precision=4)\n\n>>> np.emath.log10(10**1)\n1.0\n\n>>> np.emath.log10([-10**1, -10**2, 10**2])\narray([ 1.+1.3644j,  2.+1.3644j,  2.+0.j    ])", "id": "f19086:m6"}
{"signature": "def _fix_real_lt_zero(x):", "body": "x = asarray(x)<EOL>if any(isreal(x) & (x < <NUM_LIT:0>)):<EOL><INDENT>x = _tocomplex(x)<EOL><DEDENT>return x<EOL>", "docstring": "Convert `x` to complex if it has real, negative components.\n\n    Otherwise, output is just the array version of the input (via asarray).\n\n    Parameters\n    ----------\n    x : array_like\n\n    Returns\n    -------\n    array\n\n    Examples\n    --------\n    >>> np.lib.scimath._fix_real_lt_zero([1,2])\n    array([1, 2])\n\n    >>> np.lib.scimath._fix_real_lt_zero([-1,2])\n    array([-1.+0.j,  2.+0.j])", "id": "f19086:m1"}
{"signature": "def logn(n, x):", "body": "x = _fix_real_lt_zero(x)<EOL>n = _fix_real_lt_zero(n)<EOL>return nx.log(x)/nx.log(n)<EOL>", "docstring": "Take log base n of x.\n\nIf `x` contains negative inputs, the answer is computed and returned in the\ncomplex domain.\n\nParameters\n----------\nn : int\n   The base in which the log is taken.\nx : array_like\n   The value(s) whose log base `n` is (are) required.\n\nReturns\n-------\nout : ndarray or scalar\n   The log base `n` of the `x` value(s). If `x` was a scalar, so is\n   `out`, otherwise an array is returned.\n\nExamples\n--------\n>>> np.set_printoptions(precision=4)\n\n>>> np.lib.scimath.logn(2, [4, 8])\narray([ 2.,  3.])\n>>> np.lib.scimath.logn(2, [-4, -8, 8])\narray([ 2.+4.5324j,  3.+4.5324j,  3.+0.j    ])", "id": "f19086:m7"}
{"signature": "def __init__(self, baseurl, destpath=os.curdir):", "body": "DataSource.__init__(self, destpath=destpath)<EOL>self._baseurl = baseurl<EOL>", "docstring": "Create a Repository with a shared url or directory of baseurl.", "id": "f19087:c2:m0"}
{"signature": "def _sanitize_relative_path(self, path):", "body": "last = None<EOL>path = os.path.normpath(path)<EOL>while path != last:<EOL><INDENT>last = path<EOL>path = path.lstrip(os.sep).lstrip('<STR_LIT:/>')<EOL>path = path.lstrip(os.pardir).lstrip('<STR_LIT:..>')<EOL>drive, path = os.path.splitdrive(path)  <EOL><DEDENT>return path<EOL>", "docstring": "Return a sanitised relative path for which\n        os.path.abspath(os.path.join(base, path)).startswith(base)", "id": "f19087:c1:m10"}
{"signature": "def _fullpath(self, path):", "body": "splitpath = path.split(self._baseurl, <NUM_LIT:2>)<EOL>if len(splitpath) == <NUM_LIT:1>:<EOL><INDENT>result = os.path.join(self._baseurl, path)<EOL><DEDENT>else:<EOL><INDENT>result = path    <EOL><DEDENT>return result<EOL>", "docstring": "Return complete path for path.  Prepends baseurl if necessary.", "id": "f19087:c2:m2"}
{"signature": "def abspath(self, path):", "body": "return DataSource.abspath(self, self._fullpath(path))<EOL>", "docstring": "Return absolute path of file in the Repository directory.\n\nIf `path` is an URL, then `abspath` will return either the location\nthe file exists locally or the location it would exist when opened\nusing the `open` method.\n\nParameters\n----------\npath : str\n    Can be a local file or a remote URL. This may, but does not\n    have to, include the `baseurl` with which the `Repository` was\n    initialized.\n\nReturns\n-------\nout : str\n    Complete path, including the `DataSource` destination directory.", "id": "f19087:c2:m4"}
{"signature": "def _findfile(self, path):", "body": "<EOL>if not self._isurl(path):<EOL><INDENT>filelist = self._possible_names(path)<EOL>filelist += self._possible_names(self.abspath(path))<EOL><DEDENT>else:<EOL><INDENT>filelist = self._possible_names(self.abspath(path))<EOL>filelist = filelist + self._possible_names(path)<EOL><DEDENT>for name in filelist:<EOL><INDENT>if self.exists(name):<EOL><INDENT>if self._isurl(name):<EOL><INDENT>name = self._cache(name)<EOL><DEDENT>return name<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Searches for ``path`` and returns full path if found.\n\n        If path is an URL, _findfile will cache a local copy and return the\n        path to the cached file.  If path is a local file, _findfile will\n        return a path to that local file.\n\n        The search will include possible compressed versions of the file\n        and return the first occurence found.", "id": "f19087:c1:m8"}
{"signature": "def abspath(self, path):", "body": "<EOL>if sys.version_info[<NUM_LIT:0>] >= <NUM_LIT:3>:<EOL><INDENT>from urllib.parse import urlparse<EOL><DEDENT>else:<EOL><INDENT>from urlparse import urlparse<EOL><DEDENT>splitpath = path.split(self._destpath, <NUM_LIT:2>)<EOL>if len(splitpath) > <NUM_LIT:1>:<EOL><INDENT>path = splitpath[<NUM_LIT:1>]<EOL><DEDENT>scheme, netloc, upath, uparams, uquery, ufrag = urlparse(path)<EOL>netloc = self._sanitize_relative_path(netloc)<EOL>upath = self._sanitize_relative_path(upath)<EOL>return os.path.join(self._destpath, netloc, upath)<EOL>", "docstring": "Return absolute path of file in the DataSource directory.\n\nIf `path` is an URL, then `abspath` will return either the location\nthe file exists locally or the location it would exist when opened\nusing the `open` method.\n\nParameters\n----------\npath : str\n    Can be a local file or a remote URL.\n\nReturns\n-------\nout : str\n    Complete path, including the `DataSource` destination directory.\n\nNotes\n-----\nThe functionality is based on `os.path.abspath`.", "id": "f19087:c1:m9"}
{"signature": "def _iswritemode(self, mode):", "body": "<EOL>_writemodes = (\"<STR_LIT:w>\", \"<STR_LIT:+>\")<EOL>for c in mode:<EOL><INDENT>if c in _writemodes:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Test if the given mode will open a file for writing.", "id": "f19087:c1:m3"}
{"signature": "def exists(self, path):", "body": "<EOL>if sys.version_info[<NUM_LIT:0>] >= <NUM_LIT:3>:<EOL><INDENT>from urllib.request import urlopen<EOL>from urllib.error import URLError<EOL><DEDENT>else:<EOL><INDENT>from urllib2 import urlopen<EOL>from urllib2 import URLError<EOL><DEDENT>if os.path.exists(path):<EOL><INDENT>return True<EOL><DEDENT>upath = self.abspath(path)<EOL>if os.path.exists(upath):<EOL><INDENT>return True<EOL><DEDENT>if self._isurl(path):<EOL><INDENT>try:<EOL><INDENT>netfile = urlopen(path)<EOL>netfile.close()<EOL>del(netfile)<EOL>return True<EOL><DEDENT>except URLError:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Test if path exists.\n\nTest if `path` exists as (and in this order):\n\n- a local file.\n- a remote URL that has been downloaded and stored locally in the\n  `DataSource` directory.\n- a remote URL that has not been downloaded, but is valid and\n  accessible.\n\nParameters\n----------\npath : str\n    Can be a local file or a remote URL.\n\nReturns\n-------\nout : bool\n    True if `path` exists.\n\nNotes\n-----\nWhen `path` is an URL, `exists` will return True if it's either\nstored locally in the `DataSource` directory, or is a valid remote\nURL.  `DataSource` does not discriminate between the two, the file\nis accessible if it exists in either location.", "id": "f19087:c1:m11"}
{"signature": "def roundtrip(self, save_func, *args, **kwargs):", "body": "save_kwds = kwargs.get('<STR_LIT>', {})<EOL>load_kwds = kwargs.get('<STR_LIT>', {})<EOL>file_on_disk = kwargs.get('<STR_LIT>', False)<EOL>if file_on_disk:<EOL><INDENT>target_file = NamedTemporaryFile(delete=False)<EOL>load_file = target_file.name<EOL><DEDENT>else:<EOL><INDENT>target_file = BytesIO()<EOL>load_file = target_file<EOL><DEDENT>try:<EOL><INDENT>arr = args<EOL>save_func(target_file, *arr, **save_kwds)<EOL>target_file.flush()<EOL>target_file.seek(<NUM_LIT:0>)<EOL>if sys.platform == '<STR_LIT:win32>' and not isinstance(target_file, BytesIO):<EOL><INDENT>target_file.close()<EOL><DEDENT>arr_reloaded = np.load(load_file, **load_kwds)<EOL>self.arr = arr<EOL>self.arr_reloaded = arr_reloaded<EOL><DEDENT>finally:<EOL><INDENT>if not isinstance(target_file, BytesIO):<EOL><INDENT>target_file.close()<EOL>if not isinstance(arr_reloaded, np.lib.npyio.NpzFile):<EOL><INDENT>os.remove(target_file.name)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "save_func : callable\n    Function used to save arrays to file.\nfile_on_disk : bool\n    If true, store the file on disk, instead of in a\n    string buffer.\nsave_kwds : dict\n    Parameters passed to `save_func`.\nload_kwds : dict\n    Parameters passed to `numpy.load`.\nargs : tuple of arrays\n    Arrays stored to file.", "id": "f19092:c1:m0"}
{"signature": "def __next__(self):", "body": "next(self._it)<EOL>return self._it.multi_index<EOL>", "docstring": "Standard iterator method, updates the index and returns the index\ntuple.\n\nReturns\n-------\nval : tuple of ints\n    Returns a tuple containing the indices of the current\n    iteration.", "id": "f19109:c5:m3"}
{"signature": "def fill_diagonal(a, val, wrap=False):", "body": "if a.ndim < <NUM_LIT:2>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>end = None<EOL>if a.ndim == <NUM_LIT:2>:<EOL><INDENT>step = a.shape[<NUM_LIT:1>] + <NUM_LIT:1><EOL>if not wrap:<EOL><INDENT>end = a.shape[<NUM_LIT:1>] * a.shape[<NUM_LIT:1>]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if not alltrue(diff(a.shape) == <NUM_LIT:0>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>step = <NUM_LIT:1> + (cumprod(a.shape[:-<NUM_LIT:1>])).sum()<EOL><DEDENT>a.flat[:end:step] = val<EOL>", "docstring": "Fill the main diagonal of the given array of any dimensionality.\n\n    For an array `a` with ``a.ndim > 2``, the diagonal is the list of\n    locations with indices ``a[i, i, ..., i]`` all identical. This function\n    modifies the input array in-place, it does not return a value.\n\n    Parameters\n    ----------\n    a : array, at least 2-D.\n      Array whose diagonal is to be filled, it gets modified in-place.\n\n    val : scalar\n      Value to be written on the diagonal, its type must be compatible with\n      that of the array a.\n\n    wrap : bool\n      For tall matrices in NumPy version up to 1.6.2, the\n      diagonal \"wrapped\" after N columns. You can have this behavior\n      with this option. This affect only tall matrices.\n\n    See also\n    --------\n    diag_indices, diag_indices_from\n\n    Notes\n    -----\n    .. versionadded:: 1.4.0\n\n    This functionality can be obtained via `diag_indices`, but internally\n    this version uses a much faster implementation that never constructs the\n    indices and uses simple slicing.\n\n    Examples\n    --------\n    >>> a = np.zeros((3, 3), int)\n    >>> np.fill_diagonal(a, 5)\n    >>> a\n    array([[5, 0, 0],\n           [0, 5, 0],\n           [0, 0, 5]])\n\n    The same function can operate on a 4-D array:\n\n    >>> a = np.zeros((3, 3, 3, 3), int)\n    >>> np.fill_diagonal(a, 4)\n\n    We only show a few blocks for clarity:\n\n    >>> a[0, 0]\n    array([[4, 0, 0],\n           [0, 0, 0],\n           [0, 0, 0]])\n    >>> a[1, 1]\n    array([[0, 0, 0],\n           [0, 4, 0],\n           [0, 0, 0]])\n    >>> a[2, 2]\n    array([[0, 0, 0],\n           [0, 0, 0],\n           [0, 0, 4]])\n\n    # tall matrices no wrap\n    >>> a = np.zeros((5, 3),int)\n    >>> fill_diagonal(a, 4)\n    array([[4, 0, 0],\n           [0, 4, 0],\n           [0, 0, 4],\n           [0, 0, 0],\n           [0, 0, 0]])\n\n    # tall matrices wrap\n    >>> a = np.zeros((5, 3),int)\n    >>> fill_diagonal(a, 4)\n    array([[4, 0, 0],\n           [0, 4, 0],\n           [0, 0, 4],\n           [0, 0, 0],\n           [4, 0, 0]])\n\n    # wide matrices\n    >>> a = np.zeros((3, 5),int)\n    >>> fill_diagonal(a, 4)\n    array([[4, 0, 0, 0, 0],\n           [0, 4, 0, 0, 0],\n           [0, 0, 4, 0, 0]])", "id": "f19109:m1"}
{"signature": "def _pad_sym(arr, pad_amt, method, axis=-<NUM_LIT:1>):", "body": "<EOL>if pad_amt[<NUM_LIT:0>] == <NUM_LIT:0> and pad_amt[<NUM_LIT:1>] == <NUM_LIT:0>:<EOL><INDENT>return arr<EOL><DEDENT>sym_slice = tuple(slice(None) if i != axis else slice(<NUM_LIT:0>, pad_amt[<NUM_LIT:0>])<EOL>for (i, x) in enumerate(arr.shape))<EOL>rev_idx = tuple(slice(None) if i != axis else slice(None, None, -<NUM_LIT:1>)<EOL>for (i, x) in enumerate(arr.shape))<EOL>sym_chunk1 = arr[sym_slice][rev_idx]<EOL>pad_singleton = tuple(x if i != axis else <NUM_LIT:1><EOL>for (i, x) in enumerate(arr.shape))<EOL>if pad_amt[<NUM_LIT:0>] == <NUM_LIT:1>:<EOL><INDENT>sym_chunk1 = sym_chunk1.reshape(pad_singleton)<EOL><DEDENT>if '<STR_LIT>' in method and pad_amt[<NUM_LIT:0>] > <NUM_LIT:0>:<EOL><INDENT>edge_slice1 = tuple(slice(None) if i != axis else <NUM_LIT:0><EOL>for (i, x) in enumerate(arr.shape))<EOL>edge_chunk = arr[edge_slice1].reshape(pad_singleton)<EOL>sym_chunk1 = <NUM_LIT:2> * edge_chunk - sym_chunk1<EOL>del edge_chunk<EOL><DEDENT>start = arr.shape[axis] - pad_amt[<NUM_LIT:1>]<EOL>end = arr.shape[axis]<EOL>sym_slice = tuple(slice(None) if i != axis else slice(start, end)<EOL>for (i, x) in enumerate(arr.shape))<EOL>sym_chunk2 = arr[sym_slice][rev_idx]<EOL>if pad_amt[<NUM_LIT:1>] == <NUM_LIT:1>:<EOL><INDENT>sym_chunk2 = sym_chunk2.reshape(pad_singleton)<EOL><DEDENT>if '<STR_LIT>' in method:<EOL><INDENT>edge_slice2 = tuple(slice(None) if i != axis else -<NUM_LIT:1><EOL>for (i, x) in enumerate(arr.shape))<EOL>edge_chunk = arr[edge_slice2].reshape(pad_singleton)<EOL>sym_chunk2 = <NUM_LIT:2> * edge_chunk - sym_chunk2<EOL>del edge_chunk<EOL><DEDENT>return np.concatenate((sym_chunk1, arr, sym_chunk2), axis=axis)<EOL>", "docstring": "Pad `axis` of `arr` by symmetry.\n\nParameters\n----------\narr : ndarray\n    Input array of arbitrary shape.\npad_amt : tuple of ints, length 2\n    Padding to (prepend, append) along `axis`.\nmethod : str\n    Controls method of symmetry; options are 'even' or 'odd'.\naxis : int\n    Axis along which to pad `arr`.\n\nReturns\n-------\npadarr : ndarray\n    Output array, with `pad_amt[0]` values prepended and `pad_amt[1]`\n    values appended along `axis`. Both regions are padded with symmetric\n    values from the original array.\n\nNotes\n-----\nThis algorithm DOES pad with repetition, i.e. the edges are repeated.\nFor a method that does not repeat edges, use `method='reflect'`.\n\nThe modes 'reflect', 'symmetric', and 'wrap' must be padded with a\nsingle function, lest the indexing tricks in non-integer multiples of the\noriginal shape would violate repetition in the final iteration.", "id": "f19110:m17"}
{"signature": "def _append_med(arr, pad_amt, num, axis=-<NUM_LIT:1>):", "body": "if pad_amt == <NUM_LIT:0>:<EOL><INDENT>return arr<EOL><DEDENT>if num == <NUM_LIT:1>:<EOL><INDENT>return _append_edge(arr, pad_amt, axis)<EOL><DEDENT>if num is not None:<EOL><INDENT>if num >= arr.shape[axis]:<EOL><INDENT>num = None<EOL><DEDENT><DEDENT>end = arr.shape[axis] - <NUM_LIT:1><EOL>if num is not None:<EOL><INDENT>med_slice = tuple(<EOL>slice(None) if i != axis else slice(end, end - num, -<NUM_LIT:1>)<EOL>for (i, x) in enumerate(arr.shape))<EOL><DEDENT>else:<EOL><INDENT>med_slice = tuple(slice(None) for x in arr.shape)<EOL><DEDENT>pad_singleton = tuple(x if i != axis else <NUM_LIT:1><EOL>for (i, x) in enumerate(arr.shape))<EOL>med_chunk = np.median(arr[med_slice], axis=axis).reshape(pad_singleton)<EOL>_round_ifneeded(med_chunk, arr.dtype)<EOL>return np.concatenate(<EOL>(arr, med_chunk.repeat(pad_amt, axis).astype(arr.dtype)), axis=axis)<EOL>", "docstring": "Append `pad_amt` median values along `axis`.\n\nParameters\n----------\narr : ndarray\n    Input array of arbitrary shape.\npad_amt : int\n    Amount of padding to append.\nnum : int\n    Depth into `arr` along `axis` to calculate median.\n    Range: [1, `arr.shape[axis]`] or None (entire axis)\naxis : int\n    Axis along which to pad `arr`.\n\nReturns\n-------\npadarr : ndarray\n    Output array, with `pad_amt` values appended along `axis`. The\n    appended region is the median of the final `num` values along `axis`.", "id": "f19110:m13"}
{"signature": "def _prepend_mean(arr, pad_amt, num, axis=-<NUM_LIT:1>):", "body": "if pad_amt == <NUM_LIT:0>:<EOL><INDENT>return arr<EOL><DEDENT>if num == <NUM_LIT:1>:<EOL><INDENT>return _prepend_edge(arr, pad_amt, axis)<EOL><DEDENT>if num is not None:<EOL><INDENT>if num >= arr.shape[axis]:<EOL><INDENT>num = None<EOL><DEDENT><DEDENT>mean_slice = tuple(slice(None) if i != axis else slice(num)<EOL>for (i, x) in enumerate(arr.shape))<EOL>pad_singleton = tuple(x if i != axis else <NUM_LIT:1><EOL>for (i, x) in enumerate(arr.shape))<EOL>mean_chunk = arr[mean_slice].mean(axis).reshape(pad_singleton)<EOL>_round_ifneeded(mean_chunk, arr.dtype)<EOL>return np.concatenate((mean_chunk.repeat(pad_amt, axis).astype(arr.dtype),<EOL>arr), axis=axis)<EOL>", "docstring": "Prepend `pad_amt` mean values along `axis`.\n\nParameters\n----------\narr : ndarray\n    Input array of arbitrary shape.\npad_amt : int\n    Amount of padding to prepend.\nnum : int\n    Depth into `arr` along `axis` to calculate mean.\n    Range: [1, `arr.shape[axis]`] or None (entire axis)\naxis : int\n    Axis along which to pad `arr`.\n\nReturns\n-------\npadarr : ndarray\n    Output array, with `pad_amt` values prepended along `axis`. The\n    prepended region is the mean of the first `num` values along `axis`.", "id": "f19110:m10"}
{"signature": "def _prepend_min(arr, pad_amt, num, axis=-<NUM_LIT:1>):", "body": "if pad_amt == <NUM_LIT:0>:<EOL><INDENT>return arr<EOL><DEDENT>if num == <NUM_LIT:1>:<EOL><INDENT>return _prepend_edge(arr, pad_amt, axis)<EOL><DEDENT>if num is not None:<EOL><INDENT>if num >= arr.shape[axis]:<EOL><INDENT>num = None<EOL><DEDENT><DEDENT>min_slice = tuple(slice(None) if i != axis else slice(num)<EOL>for (i, x) in enumerate(arr.shape))<EOL>pad_singleton = tuple(x if i != axis else <NUM_LIT:1><EOL>for (i, x) in enumerate(arr.shape))<EOL>min_chunk = arr[min_slice].min(axis=axis).reshape(pad_singleton)<EOL>return np.concatenate((min_chunk.repeat(pad_amt, axis=axis), arr),<EOL>axis=axis)<EOL>", "docstring": "Prepend `pad_amt` minimum values along `axis`.\n\nParameters\n----------\narr : ndarray\n    Input array of arbitrary shape.\npad_amt : int\n    Amount of padding to prepend.\nnum : int\n    Depth into `arr` along `axis` to calculate minimum.\n    Range: [1, `arr.shape[axis]`] or None (entire axis)\naxis : int\n    Axis along which to pad `arr`.\n\nReturns\n-------\npadarr : ndarray\n    Output array, with `pad_amt` values prepended along `axis`. The\n    prepended region is the minimum of the first `num` values along\n    `axis`.", "id": "f19110:m14"}
{"signature": "def _append_const(arr, pad_amt, val, axis=-<NUM_LIT:1>):", "body": "if pad_amt == <NUM_LIT:0>:<EOL><INDENT>return arr<EOL><DEDENT>padshape = tuple(x if i != axis else pad_amt<EOL>for (i, x) in enumerate(arr.shape))<EOL>if val == <NUM_LIT:0>:<EOL><INDENT>return np.concatenate((arr, np.zeros(padshape, dtype=arr.dtype)),<EOL>axis=axis)<EOL><DEDENT>else:<EOL><INDENT>return np.concatenate(<EOL>(arr, (np.zeros(padshape) + val).astype(arr.dtype)), axis=axis)<EOL><DEDENT>", "docstring": "Append constant `val` along `axis` of `arr`.\n\nParameters\n----------\narr : ndarray\n    Input array of arbitrary shape.\npad_amt : int\n    Amount of padding to append.\nval : scalar\n    Constant value to use. For best results should be of type `arr.dtype`;\n    if not `arr.dtype` will be cast to `arr.dtype`.\naxis : int\n    Axis along which to pad `arr`.\n\nReturns\n-------\npadarr : ndarray\n    Output array, with `pad_amt` constant `val` appended along `axis`.", "id": "f19110:m3"}
{"signature": "def _min_int(low, high):", "body": "if high <= i1.max and low >= i1.min:<EOL><INDENT>return int8<EOL><DEDENT>if high <= i2.max and low >= i2.min:<EOL><INDENT>return int16<EOL><DEDENT>if high <= i4.max and low >= i4.min:<EOL><INDENT>return int32<EOL><DEDENT>return int64<EOL>", "docstring": "get small int that fits the range", "id": "f19111:m0"}
{"signature": "def diag(v, k=<NUM_LIT:0>):", "body": "v = asarray(v)<EOL>s = v.shape<EOL>if len(s) == <NUM_LIT:1>:<EOL><INDENT>n = s[<NUM_LIT:0>]+abs(k)<EOL>res = zeros((n, n), v.dtype)<EOL>if k >= <NUM_LIT:0>:<EOL><INDENT>i = k<EOL><DEDENT>else:<EOL><INDENT>i = (-k) * n<EOL><DEDENT>res[:n-k].flat[i::n+<NUM_LIT:1>] = v<EOL>return res<EOL><DEDENT>elif len(s) == <NUM_LIT:2>:<EOL><INDENT>return v.diagonal(k)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Extract a diagonal or construct a diagonal array.\n\nSee the more detailed documentation for ``numpy.diagonal`` if you use this\nfunction to extract a diagonal and wish to write to the resulting array;\nwhether it returns a copy or a view depends on what version of numpy you\nare using.\n\nParameters\n----------\nv : array_like\n    If `v` is a 2-D array, return a copy of its `k`-th diagonal.\n    If `v` is a 1-D array, return a 2-D array with `v` on the `k`-th\n    diagonal.\nk : int, optional\n    Diagonal in question. The default is 0. Use `k>0` for diagonals\n    above the main diagonal, and `k<0` for diagonals below the main\n    diagonal.\n\nReturns\n-------\nout : ndarray\n    The extracted diagonal or constructed diagonal array.\n\nSee Also\n--------\ndiagonal : Return specified diagonals.\ndiagflat : Create a 2-D array with the flattened input as a diagonal.\ntrace : Sum along diagonals.\ntriu : Upper triangle of an array.\ntril : Lower triangle of an array.\n\nExamples\n--------\n>>> x = np.arange(9).reshape((3,3))\n>>> x\narray([[0, 1, 2],\n       [3, 4, 5],\n       [6, 7, 8]])\n\n>>> np.diag(x)\narray([0, 4, 8])\n>>> np.diag(x, k=1)\narray([1, 5])\n>>> np.diag(x, k=-1)\narray([3, 7])\n\n>>> np.diag(np.diag(x))\narray([[0, 0, 0],\n       [0, 4, 0],\n       [0, 0, 8]])", "id": "f19111:m5"}
{"signature": "def vander(x, N=None, increasing=False):", "body": "x = asarray(x)<EOL>if x.ndim != <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if N is None:<EOL><INDENT>N = len(x)<EOL><DEDENT>v = empty((len(x), N), dtype=promote_types(x.dtype, int))<EOL>tmp = v[:, ::-<NUM_LIT:1>] if not increasing else v<EOL>if N > <NUM_LIT:0>:<EOL><INDENT>tmp[:, <NUM_LIT:0>] = <NUM_LIT:1><EOL><DEDENT>if N > <NUM_LIT:1>:<EOL><INDENT>tmp[:, <NUM_LIT:1>:] = x[:, None]<EOL>multiply.accumulate(tmp[:, <NUM_LIT:1>:], out=tmp[:, <NUM_LIT:1>:], axis=<NUM_LIT:1>)<EOL><DEDENT>return v<EOL>", "docstring": "Generate a Vandermonde matrix.\n\nThe columns of the output matrix are powers of the input vector. The\norder of the powers is determined by the `increasing` boolean argument.\nSpecifically, when `increasing` is False, the `i`-th output column is\nthe input vector raised element-wise to the power of ``N - i - 1``. Such\na matrix with a geometric progression in each row is named for Alexandre-\nTheophile Vandermonde.\n\nParameters\n----------\nx : array_like\n    1-D input array.\nN : int, optional\n    Number of columns in the output.  If `N` is not specified, a square\n    array is returned (``N = len(x)``).\nincreasing : bool, optional\n    Order of the powers of the columns.  If True, the powers increase\n    from left to right, if False (the default) they are reversed.\n\n    .. versionadded:: 1.9.0\n\nReturns\n-------\nout : ndarray\n    Vandermonde matrix.  If `increasing` is False, the first column is\n    ``x^(N-1)``, the second ``x^(N-2)`` and so forth. If `increasing` is\n    True, the columns are ``x^0, x^1, ..., x^(N-1)``.\n\nSee Also\n--------\npolynomial.polynomial.polyvander\n\nExamples\n--------\n>>> x = np.array([1, 2, 3, 5])\n>>> N = 3\n>>> np.vander(x, N)\narray([[ 1,  1,  1],\n       [ 4,  2,  1],\n       [ 9,  3,  1],\n       [25,  5,  1]])\n\n>>> np.column_stack([x**(N-1-i) for i in range(N)])\narray([[ 1,  1,  1],\n       [ 4,  2,  1],\n       [ 9,  3,  1],\n       [25,  5,  1]])\n\n>>> x = np.array([1, 2, 3, 5])\n>>> np.vander(x)\narray([[  1,   1,   1,   1],\n       [  8,   4,   2,   1],\n       [ 27,   9,   3,   1],\n       [125,  25,   5,   1]])\n>>> np.vander(x, increasing=True)\narray([[  1,   1,   1,   1],\n       [  1,   2,   4,   8],\n       [  1,   3,   9,  27],\n       [  1,   5,  25, 125]])\n\nThe determinant of a square Vandermonde matrix is the product\nof the differences between the values of the input vector:\n\n>>> np.linalg.det(np.vander(x))\n48.000000000000043\n>>> (5-3)*(5-2)*(5-1)*(3-2)*(3-1)*(2-1)\n48", "id": "f19111:m10"}
{"signature": "def triu(m, k=<NUM_LIT:0>):", "body": "m = asanyarray(m)<EOL>mask = tri(*m.shape[-<NUM_LIT:2>:], k=k-<NUM_LIT:1>, dtype=bool)<EOL>return where(mask, zeros(<NUM_LIT:1>, m.dtype), m)<EOL>", "docstring": "Upper triangle of an array.\n\nReturn a copy of a matrix with the elements below the `k`-th diagonal\nzeroed.\n\nPlease refer to the documentation for `tril` for further details.\n\nSee Also\n--------\ntril : lower triangle of an array\n\nExamples\n--------\n>>> np.triu([[1,2,3],[4,5,6],[7,8,9],[10,11,12]], -1)\narray([[ 1,  2,  3],\n       [ 4,  5,  6],\n       [ 0,  8,  9],\n       [ 0,  0, 12]])", "id": "f19111:m9"}
{"signature": "def as_strided(x, shape=None, strides=None):", "body": "interface = dict(x.__array_interface__)<EOL>if shape is not None:<EOL><INDENT>interface['<STR_LIT>'] = tuple(shape)<EOL><DEDENT>if strides is not None:<EOL><INDENT>interface['<STR_LIT>'] = tuple(strides)<EOL><DEDENT>array = np.asarray(DummyArray(interface, base=x))<EOL>if array.dtype.kind == '<STR_LIT>':<EOL><INDENT>array.dtype = x.dtype<EOL><DEDENT>return array<EOL>", "docstring": "Make an ndarray from the given array with the given shape and strides.", "id": "f19112:m0"}
{"signature": "@classmethod<EOL><INDENT>def _getdtype(cls, val):<DEDENT>", "body": "return np.array(val).dtype<EOL>", "docstring": "Returns the dtype of the input variable.", "id": "f19113:c5:m0"}
{"signature": "@classmethod<EOL><INDENT>def _getsubdtype(cls, val):<DEDENT>", "body": "return np.array(val).dtype.type<EOL>", "docstring": "Returns the type of the dtype of the input variable.", "id": "f19113:c5:m1"}
{"signature": "def npv(rate, values):", "body": "values = np.asarray(values)<EOL>return (values / (<NUM_LIT:1>+rate)**np.arange(<NUM_LIT:0>, len(values))).sum(axis=<NUM_LIT:0>)<EOL>", "docstring": "Returns the NPV (Net Present Value) of a cash flow series.\n\nParameters\n----------\nrate : scalar\n    The discount rate.\nvalues : array_like, shape(M, )\n    The values of the time series of cash flows.  The (fixed) time\n    interval between cash flow \"events\" must be the same as that for\n    which `rate` is given (i.e., if `rate` is per year, then precisely\n    a year is understood to elapse between each cash flow event).  By\n    convention, investments or \"deposits\" are negative, income or\n    \"withdrawals\" are positive; `values` must begin with the initial\n    investment, thus `values[0]` will typically be negative.\n\nReturns\n-------\nout : float\n    The NPV of the input cash flow series `values` at the discount\n    `rate`.\n\nNotes\n-----\nReturns the result of: [G]_\n\n.. math :: \\\\sum_{t=0}^{M-1}{\\\\frac{values_t}{(1+rate)^{t}}}\n\nReferences\n----------\n.. [G] L. J. Gitman, \"Principles of Managerial Finance, Brief,\" 3rd ed.,\n   Addison-Wesley, 2003, pg. 346.\n\nExamples\n--------\n>>> np.npv(0.281,[-100, 39, 59, 55, 20])\n-0.0084785916384548798\n\n(Compare with the Example given for numpy.lib.financial.irr)", "id": "f19114:m11"}
{"signature": "def rate(nper, pmt, pv, fv, when='<STR_LIT:end>', guess=<NUM_LIT>, tol=<NUM_LIT>, maxiter=<NUM_LIT:100>):", "body": "when = _convert_when(when)<EOL>(nper, pmt, pv, fv, when) = map(np.asarray, [nper, pmt, pv, fv, when])<EOL>rn = guess<EOL>iter = <NUM_LIT:0><EOL>close = False<EOL>while (iter < maxiter) and not close:<EOL><INDENT>rnp1 = rn - _g_div_gp(rn, nper, pmt, pv, fv, when)<EOL>diff = abs(rnp1-rn)<EOL>close = np.all(diff < tol)<EOL>iter += <NUM_LIT:1><EOL>rn = rnp1<EOL><DEDENT>if not close:<EOL><INDENT>return np.nan + rn<EOL><DEDENT>else:<EOL><INDENT>return rn<EOL><DEDENT>", "docstring": "Compute the rate of interest per period.\n\nParameters\n----------\nnper : array_like\n    Number of compounding periods\npmt : array_like\n    Payment\npv : array_like\n    Present value\nfv : array_like\n    Future value\nwhen : {{'begin', 1}, {'end', 0}}, {string, int}, optional\n    When payments are due ('begin' (1) or 'end' (0))\nguess : float, optional\n    Starting guess for solving the rate of interest\ntol : float, optional\n    Required tolerance for the solution\nmaxiter : int, optional\n    Maximum iterations in finding the solution\n\nNotes\n-----\nThe rate of interest is computed by iteratively solving the\n(non-linear) equation::\n\n fv + pv*(1+rate)**nper + pmt*(1+rate*when)/rate * ((1+rate)**nper - 1) = 0\n\nfor ``rate``.\n\nReferences\n----------\nWheeler, D. A., E. Rathke, and R. Weir (Eds.) (2009, May). Open Document\nFormat for Office Applications (OpenDocument)v1.2, Part 2: Recalculated\nFormula (OpenFormula) Format - Annotated Version, Pre-Draft 12.\nOrganization for the Advancement of Structured Information Standards\n(OASIS). Billerica, MA, USA. [ODT Document]. Available:\nhttp://www.oasis-open.org/committees/documents.php?wg_abbrev=office-formula\nOpenDocument-formula-20090508.odt", "id": "f19114:m9"}
{"signature": "def _compare_pre_release(self, other):", "body": "if self.pre_release == other.pre_release:<EOL><INDENT>vercmp = <NUM_LIT:0><EOL><DEDENT>elif self.pre_release == '<STR_LIT>':<EOL><INDENT>vercmp = <NUM_LIT:1><EOL><DEDENT>elif other.pre_release == '<STR_LIT>':<EOL><INDENT>vercmp = -<NUM_LIT:1><EOL><DEDENT>elif self.pre_release > other.pre_release:<EOL><INDENT>vercmp = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>vercmp = -<NUM_LIT:1><EOL><DEDENT>return vercmp<EOL>", "docstring": "Compare alpha/beta/rc/final.", "id": "f19116:c0:m2"}
{"signature": "def close(self):", "body": "if self.zip is not None:<EOL><INDENT>self.zip.close()<EOL>self.zip = None<EOL><DEDENT>if self.fid is not None:<EOL><INDENT>self.fid.close()<EOL>self.fid = None<EOL><DEDENT>self.f = None<EOL>", "docstring": "Close the file.", "id": "f19117:c1:m3"}
{"signature": "def recfromcsv(fname, **kwargs):", "body": "<EOL>kwargs.setdefault(\"<STR_LIT>\", \"<STR_LIT>\")<EOL>kwargs.setdefault(\"<STR_LIT>\", True)<EOL>kwargs.setdefault(\"<STR_LIT>\", \"<STR_LIT:U+002C>\")<EOL>kwargs.setdefault(\"<STR_LIT>\", None)<EOL>output = genfromtxt(fname, **kwargs)<EOL>usemask = kwargs.get(\"<STR_LIT>\", False)<EOL>if usemask:<EOL><INDENT>from numpy.ma.mrecords import MaskedRecords<EOL>output = output.view(MaskedRecords)<EOL><DEDENT>else:<EOL><INDENT>output = output.view(np.recarray)<EOL><DEDENT>return output<EOL>", "docstring": "Load ASCII data stored in a comma-separated file.\n\nThe returned array is a record array (if ``usemask=False``, see\n`recarray`) or a masked record array (if ``usemask=True``,\nsee `ma.mrecords.MaskedRecords`).\n\nParameters\n----------\nfname, kwargs : For a description of input parameters, see `genfromtxt`.\n\nSee Also\n--------\nnumpy.genfromtxt : generic function to load ASCII data.\n\nNotes\n-----\nBy default, `dtype` is None, which means that the data-type of the output\narray will be determined from the data.", "id": "f19117:m15"}
{"signature": "def savetxt(fname, X, fmt='<STR_LIT>', delimiter='<STR_LIT:U+0020>', newline='<STR_LIT:\\n>', header='<STR_LIT>',<EOL>footer='<STR_LIT>', comments='<STR_LIT>'):", "body": "<EOL>if isinstance(fmt, bytes):<EOL><INDENT>fmt = asstr(fmt)<EOL><DEDENT>delimiter = asstr(delimiter)<EOL>own_fh = False<EOL>if _is_string_like(fname):<EOL><INDENT>own_fh = True<EOL>if fname.endswith('<STR_LIT>'):<EOL><INDENT>import gzip<EOL>fh = gzip.open(fname, '<STR_LIT:wb>')<EOL><DEDENT>else:<EOL><INDENT>if sys.version_info[<NUM_LIT:0>] >= <NUM_LIT:3>:<EOL><INDENT>fh = open(fname, '<STR_LIT:wb>')<EOL><DEDENT>else:<EOL><INDENT>fh = open(fname, '<STR_LIT:w>')<EOL><DEDENT><DEDENT><DEDENT>elif hasattr(fname, '<STR_LIT>'):<EOL><INDENT>fh = fname<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>try:<EOL><INDENT>X = np.asarray(X)<EOL>if X.ndim == <NUM_LIT:1>:<EOL><INDENT>if X.dtype.names is None:<EOL><INDENT>X = np.atleast_2d(X).T<EOL>ncol = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>ncol = len(X.dtype.descr)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>ncol = X.shape[<NUM_LIT:1>]<EOL><DEDENT>iscomplex_X = np.iscomplexobj(X)<EOL>if type(fmt) in (list, tuple):<EOL><INDENT>if len(fmt) != ncol:<EOL><INDENT>raise AttributeError('<STR_LIT>' % str(fmt))<EOL><DEDENT>format = asstr(delimiter).join(map(asstr, fmt))<EOL><DEDENT>elif isinstance(fmt, str):<EOL><INDENT>n_fmt_chars = fmt.count('<STR_LIT:%>')<EOL>error = ValueError('<STR_LIT>' % fmt)<EOL>if n_fmt_chars == <NUM_LIT:1>:<EOL><INDENT>if iscomplex_X:<EOL><INDENT>fmt = ['<STR_LIT>' % (fmt, fmt), ] * ncol<EOL><DEDENT>else:<EOL><INDENT>fmt = [fmt, ] * ncol<EOL><DEDENT>format = delimiter.join(fmt)<EOL><DEDENT>elif iscomplex_X and n_fmt_chars != (<NUM_LIT:2> * ncol):<EOL><INDENT>raise error<EOL><DEDENT>elif ((not iscomplex_X) and n_fmt_chars != ncol):<EOL><INDENT>raise error<EOL><DEDENT>else:<EOL><INDENT>format = fmt<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' % (fmt,))<EOL><DEDENT>if len(header) > <NUM_LIT:0>:<EOL><INDENT>header = header.replace('<STR_LIT:\\n>', '<STR_LIT:\\n>' + comments)<EOL>fh.write(asbytes(comments + header + newline))<EOL><DEDENT>if iscomplex_X:<EOL><INDENT>for row in X:<EOL><INDENT>row2 = []<EOL>for number in row:<EOL><INDENT>row2.append(number.real)<EOL>row2.append(number.imag)<EOL><DEDENT>fh.write(asbytes(format % tuple(row2) + newline))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for row in X:<EOL><INDENT>fh.write(asbytes(format % tuple(row) + newline))<EOL><DEDENT><DEDENT>if len(footer) > <NUM_LIT:0>:<EOL><INDENT>footer = footer.replace('<STR_LIT:\\n>', '<STR_LIT:\\n>' + comments)<EOL>fh.write(asbytes(comments + footer + newline))<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>if own_fh:<EOL><INDENT>fh.close()<EOL><DEDENT><DEDENT>", "docstring": "Save an array to a text file.\n\nParameters\n----------\nfname : filename or file handle\n    If the filename ends in ``.gz``, the file is automatically saved in\n    compressed gzip format.  `loadtxt` understands gzipped files\n    transparently.\nX : array_like\n    Data to be saved to a text file.\nfmt : str or sequence of strs, optional\n    A single format (%10.5f), a sequence of formats, or a\n    multi-format string, e.g. 'Iteration %d -- %10.5f', in which\n    case `delimiter` is ignored. For complex `X`, the legal options\n    for `fmt` are:\n        a) a single specifier, `fmt='%.4e'`, resulting in numbers formatted\n            like `' (%s+%sj)' % (fmt, fmt)`\n        b) a full string specifying every real and imaginary part, e.g.\n            `' %.4e %+.4j %.4e %+.4j %.4e %+.4j'` for 3 columns\n        c) a list of specifiers, one per column - in this case, the real\n            and imaginary part must have separate specifiers,\n            e.g. `['%.3e + %.3ej', '(%.15e%+.15ej)']` for 2 columns\ndelimiter : str, optional\n    String or character separating columns.\nnewline : str, optional\n    String or character separating lines.\n\n    .. versionadded:: 1.5.0\nheader : str, optional\n    String that will be written at the beginning of the file.\n\n    .. versionadded:: 1.7.0\nfooter : str, optional\n    String that will be written at the end of the file.\n\n    .. versionadded:: 1.7.0\ncomments : str, optional\n    String that will be prepended to the ``header`` and ``footer`` strings,\n    to mark them as comments. Default: '# ',  as expected by e.g.\n    ``numpy.loadtxt``.\n\n    .. versionadded:: 1.7.0\n\n\nSee Also\n--------\nsave : Save an array to a binary file in NumPy ``.npy`` format\nsavez : Save several arrays into an uncompressed ``.npz`` archive\nsavez_compressed : Save several arrays into a compressed ``.npz`` archive\n\nNotes\n-----\nFurther explanation of the `fmt` parameter\n(``%[flag]width[.precision]specifier``):\n\nflags:\n    ``-`` : left justify\n\n    ``+`` : Forces to precede result with + or -.\n\n    ``0`` : Left pad the number with zeros instead of space (see width).\n\nwidth:\n    Minimum number of characters to be printed. The value is not truncated\n    if it has more characters.\n\nprecision:\n    - For integer specifiers (eg. ``d,i,o,x``), the minimum number of\n      digits.\n    - For ``e, E`` and ``f`` specifiers, the number of digits to print\n      after the decimal point.\n    - For ``g`` and ``G``, the maximum number of significant digits.\n    - For ``s``, the maximum number of characters.\n\nspecifiers:\n    ``c`` : character\n\n    ``d`` or ``i`` : signed decimal integer\n\n    ``e`` or ``E`` : scientific notation with ``e`` or ``E``.\n\n    ``f`` : decimal floating point\n\n    ``g,G`` : use the shorter of ``e,E`` or ``f``\n\n    ``o`` : signed octal\n\n    ``s`` : string of characters\n\n    ``u`` : unsigned decimal integer\n\n    ``x,X`` : unsigned hexadecimal integer\n\nThis explanation of ``fmt`` is not complete, for an exhaustive\nspecification see [1]_.\n\nReferences\n----------\n.. [1] `Format Specification Mini-Language\n       <http://docs.python.org/library/string.html#\n       format-specification-mini-language>`_, Python Documentation.\n\nExamples\n--------\n>>> x = y = z = np.arange(0.0,5.0,1.0)\n>>> np.savetxt('test.out', x, delimiter=',')   # X is an array\n>>> np.savetxt('test.out', (x,y,z))   # x,y,z equal sized 1D arrays\n>>> np.savetxt('test.out', x, fmt='%1.4e')   # use exponential notation", "id": "f19117:m9"}
{"signature": "def genfromtxt(fname, dtype=float, comments='<STR_LIT:#>', delimiter=None,<EOL>skiprows=<NUM_LIT:0>, skip_header=<NUM_LIT:0>, skip_footer=<NUM_LIT:0>, converters=None,<EOL>missing='<STR_LIT>', missing_values=None, filling_values=None,<EOL>usecols=None, names=None,<EOL>excludelist=None, deletechars=None, replace_space='<STR_LIT:_>',<EOL>autostrip=False, case_sensitive=True, defaultfmt=\"<STR_LIT>\",<EOL>unpack=None, usemask=False, loose=True, invalid_raise=True):", "body": "<EOL>if comments is not None:<EOL><INDENT>comments = asbytes(comments)<EOL><DEDENT>if isinstance(delimiter, unicode):<EOL><INDENT>delimiter = asbytes(delimiter)<EOL><DEDENT>if isinstance(missing, unicode):<EOL><INDENT>missing = asbytes(missing)<EOL><DEDENT>if isinstance(missing_values, (unicode, list, tuple)):<EOL><INDENT>missing_values = asbytes_nested(missing_values)<EOL><DEDENT>if usemask:<EOL><INDENT>from numpy.ma import MaskedArray, make_mask_descr<EOL><DEDENT>user_converters = converters or {}<EOL>if not isinstance(user_converters, dict):<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % type(user_converters))<EOL><DEDENT>own_fhd = False<EOL>try:<EOL><INDENT>if isinstance(fname, basestring):<EOL><INDENT>if sys.version_info[<NUM_LIT:0>] == <NUM_LIT:2>:<EOL><INDENT>fhd = iter(np.lib._datasource.open(fname, '<STR_LIT>'))<EOL><DEDENT>else:<EOL><INDENT>fhd = iter(np.lib._datasource.open(fname, '<STR_LIT:rb>'))<EOL><DEDENT>own_fhd = True<EOL><DEDENT>else:<EOL><INDENT>fhd = iter(fname)<EOL><DEDENT><DEDENT>except TypeError:<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % type(fname))<EOL><DEDENT>split_line = LineSplitter(delimiter=delimiter, comments=comments,<EOL>autostrip=autostrip)._handyman<EOL>validate_names = NameValidator(excludelist=excludelist,<EOL>deletechars=deletechars,<EOL>case_sensitive=case_sensitive,<EOL>replace_space=replace_space)<EOL>if skiprows:<EOL><INDENT>warnings.warn(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>DeprecationWarning)<EOL>skip_header = skiprows<EOL><DEDENT>for i in range(skip_header):<EOL><INDENT>next(fhd)<EOL><DEDENT>first_values = None<EOL>try:<EOL><INDENT>while not first_values:<EOL><INDENT>first_line = next(fhd)<EOL>if names is True:<EOL><INDENT>if comments in first_line:<EOL><INDENT>first_line = (<EOL>asbytes('<STR_LIT>').join(first_line.split(comments)[<NUM_LIT:1>:]))<EOL><DEDENT><DEDENT>first_values = split_line(first_line)<EOL><DEDENT><DEDENT>except StopIteration:<EOL><INDENT>first_line = asbytes('<STR_LIT>')<EOL>first_values = []<EOL>warnings.warn('<STR_LIT>' % fname)<EOL><DEDENT>if names is True:<EOL><INDENT>fval = first_values[<NUM_LIT:0>].strip()<EOL>if fval in comments:<EOL><INDENT>del first_values[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>if usecols is not None:<EOL><INDENT>try:<EOL><INDENT>usecols = [_.strip() for _ in usecols.split(\"<STR_LIT:U+002C>\")]<EOL><DEDENT>except AttributeError:<EOL><INDENT>try:<EOL><INDENT>usecols = list(usecols)<EOL><DEDENT>except TypeError:<EOL><INDENT>usecols = [usecols, ]<EOL><DEDENT><DEDENT><DEDENT>nbcols = len(usecols or first_values)<EOL>if names is True:<EOL><INDENT>names = validate_names([_bytes_to_name(_.strip())<EOL>for _ in first_values])<EOL>first_line = asbytes('<STR_LIT>')<EOL><DEDENT>elif _is_string_like(names):<EOL><INDENT>names = validate_names([_.strip() for _ in names.split('<STR_LIT:U+002C>')])<EOL><DEDENT>elif names:<EOL><INDENT>names = validate_names(names)<EOL><DEDENT>if dtype is not None:<EOL><INDENT>dtype = easy_dtype(dtype, defaultfmt=defaultfmt, names=names)<EOL><DEDENT>if names is not None:<EOL><INDENT>names = list(names)<EOL><DEDENT>if usecols:<EOL><INDENT>for (i, current) in enumerate(usecols):<EOL><INDENT>if _is_string_like(current):<EOL><INDENT>usecols[i] = names.index(current)<EOL><DEDENT>elif current < <NUM_LIT:0>:<EOL><INDENT>usecols[i] = current + len(first_values)<EOL><DEDENT><DEDENT>if (dtype is not None) and (len(dtype) > nbcols):<EOL><INDENT>descr = dtype.descr<EOL>dtype = np.dtype([descr[_] for _ in usecols])<EOL>names = list(dtype.names)<EOL><DEDENT>elif (names is not None) and (len(names) > nbcols):<EOL><INDENT>names = [names[_] for _ in usecols]<EOL><DEDENT><DEDENT>elif (names is not None) and (dtype is not None):<EOL><INDENT>names = list(dtype.names)<EOL><DEDENT>user_missing_values = missing_values or ()<EOL>missing_values = [list([asbytes('<STR_LIT>')]) for _ in range(nbcols)]<EOL>if isinstance(user_missing_values, dict):<EOL><INDENT>for (key, val) in user_missing_values.items():<EOL><INDENT>if _is_string_like(key):<EOL><INDENT>try:<EOL><INDENT>key = names.index(key)<EOL><DEDENT>except ValueError:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>if usecols:<EOL><INDENT>try:<EOL><INDENT>key = usecols.index(key)<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if isinstance(val, (list, tuple)):<EOL><INDENT>val = [str(_) for _ in val]<EOL><DEDENT>else:<EOL><INDENT>val = [str(val), ]<EOL><DEDENT>if key is None:<EOL><INDENT>for miss in missing_values:<EOL><INDENT>miss.extend(val)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>missing_values[key].extend(val)<EOL><DEDENT><DEDENT><DEDENT>elif isinstance(user_missing_values, (list, tuple)):<EOL><INDENT>for (value, entry) in zip(user_missing_values, missing_values):<EOL><INDENT>value = str(value)<EOL>if value not in entry:<EOL><INDENT>entry.append(value)<EOL><DEDENT><DEDENT><DEDENT>elif isinstance(user_missing_values, bytes):<EOL><INDENT>user_value = user_missing_values.split(asbytes(\"<STR_LIT:U+002C>\"))<EOL>for entry in missing_values:<EOL><INDENT>entry.extend(user_value)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for entry in missing_values:<EOL><INDENT>entry.extend([str(user_missing_values)])<EOL><DEDENT><DEDENT>if missing != asbytes('<STR_LIT>'):<EOL><INDENT>warnings.warn(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>DeprecationWarning)<EOL>values = [str(_) for _ in missing.split(asbytes(\"<STR_LIT:U+002C>\"))]<EOL>for entry in missing_values:<EOL><INDENT>entry.extend(values)<EOL><DEDENT><DEDENT>user_filling_values = filling_values<EOL>if user_filling_values is None:<EOL><INDENT>user_filling_values = []<EOL><DEDENT>filling_values = [None] * nbcols<EOL>if isinstance(user_filling_values, dict):<EOL><INDENT>for (key, val) in user_filling_values.items():<EOL><INDENT>if _is_string_like(key):<EOL><INDENT>try:<EOL><INDENT>key = names.index(key)<EOL><DEDENT>except ValueError:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>if usecols:<EOL><INDENT>try:<EOL><INDENT>key = usecols.index(key)<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>filling_values[key] = val<EOL><DEDENT><DEDENT>elif isinstance(user_filling_values, (list, tuple)):<EOL><INDENT>n = len(user_filling_values)<EOL>if (n <= nbcols):<EOL><INDENT>filling_values[:n] = user_filling_values<EOL><DEDENT>else:<EOL><INDENT>filling_values = user_filling_values[:nbcols]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>filling_values = [user_filling_values] * nbcols<EOL><DEDENT>if dtype is None:<EOL><INDENT>converters = [StringConverter(None, missing_values=miss, default=fill)<EOL>for (miss, fill) in zip(missing_values, filling_values)]<EOL><DEDENT>else:<EOL><INDENT>dtype_flat = flatten_dtype(dtype, flatten_base=True)<EOL>if len(dtype_flat) > <NUM_LIT:1>:<EOL><INDENT>zipit = zip(dtype_flat, missing_values, filling_values)<EOL>converters = [StringConverter(dt, locked=True,<EOL>missing_values=miss, default=fill)<EOL>for (dt, miss, fill) in zipit]<EOL><DEDENT>else:<EOL><INDENT>zipit = zip(missing_values, filling_values)<EOL>converters = [StringConverter(dtype, locked=True,<EOL>missing_values=miss, default=fill)<EOL>for (miss, fill) in zipit]<EOL><DEDENT><DEDENT>uc_update = []<EOL>for (j, conv) in user_converters.items():<EOL><INDENT>if _is_string_like(j):<EOL><INDENT>try:<EOL><INDENT>j = names.index(j)<EOL>i = j<EOL><DEDENT>except ValueError:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>elif usecols:<EOL><INDENT>try:<EOL><INDENT>i = usecols.index(j)<EOL><DEDENT>except ValueError:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>else:<EOL><INDENT>i = j<EOL><DEDENT>if len(first_line):<EOL><INDENT>testing_value = first_values[j]<EOL><DEDENT>else:<EOL><INDENT>testing_value = None<EOL><DEDENT>converters[i].update(conv, locked=True,<EOL>testing_value=testing_value,<EOL>default=filling_values[i],<EOL>missing_values=missing_values[i],)<EOL>uc_update.append((i, conv))<EOL><DEDENT>user_converters.update(uc_update)<EOL>rows = []<EOL>append_to_rows = rows.append<EOL>if usemask:<EOL><INDENT>masks = []<EOL>append_to_masks = masks.append<EOL><DEDENT>invalid = []<EOL>append_to_invalid = invalid.append<EOL>for (i, line) in enumerate(itertools.chain([first_line, ], fhd)):<EOL><INDENT>values = split_line(line)<EOL>nbvalues = len(values)<EOL>if nbvalues == <NUM_LIT:0>:<EOL><INDENT>continue<EOL><DEDENT>if usecols:<EOL><INDENT>try:<EOL><INDENT>values = [values[_] for _ in usecols]<EOL><DEDENT>except IndexError:<EOL><INDENT>append_to_invalid((i + skip_header + <NUM_LIT:1>, nbvalues))<EOL>continue<EOL><DEDENT><DEDENT>elif nbvalues != nbcols:<EOL><INDENT>append_to_invalid((i + skip_header + <NUM_LIT:1>, nbvalues))<EOL>continue<EOL><DEDENT>append_to_rows(tuple(values))<EOL>if usemask:<EOL><INDENT>append_to_masks(tuple([v.strip() in m<EOL>for (v, m) in zip(values, missing_values)]))<EOL><DEDENT><DEDENT>if own_fhd:<EOL><INDENT>fhd.close()<EOL><DEDENT>if dtype is None:<EOL><INDENT>for (i, converter) in enumerate(converters):<EOL><INDENT>current_column = [itemgetter(i)(_m) for _m in rows]<EOL>try:<EOL><INDENT>converter.iterupgrade(current_column)<EOL><DEDENT>except ConverterLockError:<EOL><INDENT>errmsg = \"<STR_LIT>\" % i<EOL>current_column = map(itemgetter(i), rows)<EOL>for (j, value) in enumerate(current_column):<EOL><INDENT>try:<EOL><INDENT>converter.upgrade(value)<EOL><DEDENT>except (ConverterError, ValueError):<EOL><INDENT>errmsg += \"<STR_LIT>\"<EOL>errmsg %= (j + <NUM_LIT:1> + skip_header, value)<EOL>raise ConverterError(errmsg)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>nbinvalid = len(invalid)<EOL>if nbinvalid > <NUM_LIT:0>:<EOL><INDENT>nbrows = len(rows) + nbinvalid - skip_footer<EOL>template = \"<STR_LIT>\" % nbcols<EOL>if skip_footer > <NUM_LIT:0>:<EOL><INDENT>nbinvalid_skipped = len([_ for _ in invalid<EOL>if _[<NUM_LIT:0>] > nbrows + skip_header])<EOL>invalid = invalid[:nbinvalid - nbinvalid_skipped]<EOL>skip_footer -= nbinvalid_skipped<EOL><INDENT>nbrows -= skip_footer<EOL>errmsg = [template % (i, nb)<EOL>for (i, nb) in invalid if i < nbrows]<EOL>", "docstring": "Load data from a text file, with missing values handled as specified.\n\nEach line past the first `skip_header` lines is split at the `delimiter`\ncharacter, and characters following the `comments` character are discarded.\n\nParameters\n----------\nfname : file or str\n    File, filename, or generator to read.  If the filename extension is\n    `.gz` or `.bz2`, the file is first decompressed. Note that\n    generators must return byte strings in Python 3k.\ndtype : dtype, optional\n    Data type of the resulting array.\n    If None, the dtypes will be determined by the contents of each\n    column, individually.\ncomments : str, optional\n    The character used to indicate the start of a comment.\n    All the characters occurring on a line after a comment are discarded\ndelimiter : str, int, or sequence, optional\n    The string used to separate values.  By default, any consecutive\n    whitespaces act as delimiter.  An integer or sequence of integers\n    can also be provided as width(s) of each field.\nskip_rows : int, optional\n    `skip_rows` was deprecated in numpy 1.5, and will be removed in\n    numpy 2.0. Please use `skip_header` instead.\nskip_header : int, optional\n    The number of lines to skip at the beginning of the file.\nskip_footer : int, optional\n    The number of lines to skip at the end of the file.\nconverters : variable, optional\n    The set of functions that convert the data of a column to a value.\n    The converters can also be used to provide a default value\n    for missing data: ``converters = {3: lambda s: float(s or 0)}``.\nmissing : variable, optional\n    `missing` was deprecated in numpy 1.5, and will be removed in\n    numpy 2.0. Please use `missing_values` instead.\nmissing_values : variable, optional\n    The set of strings corresponding to missing data.\nfilling_values : variable, optional\n    The set of values to be used as default when the data are missing.\nusecols : sequence, optional\n    Which columns to read, with 0 being the first.  For example,\n    ``usecols = (1, 4, 5)`` will extract the 2nd, 5th and 6th columns.\nnames : {None, True, str, sequence}, optional\n    If `names` is True, the field names are read from the first valid line\n    after the first `skip_header` lines.\n    If `names` is a sequence or a single-string of comma-separated names,\n    the names will be used to define the field names in a structured dtype.\n    If `names` is None, the names of the dtype fields will be used, if any.\nexcludelist : sequence, optional\n    A list of names to exclude. This list is appended to the default list\n    ['return','file','print']. Excluded names are appended an underscore:\n    for example, `file` would become `file_`.\ndeletechars : str, optional\n    A string combining invalid characters that must be deleted from the\n    names.\ndefaultfmt : str, optional\n    A format used to define default field names, such as \"f%i\" or \"f_%02i\".\nautostrip : bool, optional\n    Whether to automatically strip white spaces from the variables.\nreplace_space : char, optional\n    Character(s) used in replacement of white spaces in the variables\n    names. By default, use a '_'.\ncase_sensitive : {True, False, 'upper', 'lower'}, optional\n    If True, field names are case sensitive.\n    If False or 'upper', field names are converted to upper case.\n    If 'lower', field names are converted to lower case.\nunpack : bool, optional\n    If True, the returned array is transposed, so that arguments may be\n    unpacked using ``x, y, z = loadtxt(...)``\nusemask : bool, optional\n    If True, return a masked array.\n    If False, return a regular array.\nloose : bool, optional\n    If True, do not raise errors for invalid values.\ninvalid_raise : bool, optional\n    If True, an exception is raised if an inconsistency is detected in the\n    number of columns.\n    If False, a warning is emitted and the offending lines are skipped.\n\nReturns\n-------\nout : ndarray\n    Data read from the text file. If `usemask` is True, this is a\n    masked array.\n\nSee Also\n--------\nnumpy.loadtxt : equivalent function when no data is missing.\n\nNotes\n-----\n* When spaces are used as delimiters, or when no delimiter has been given\n  as input, there should not be any missing data between two fields.\n* When the variables are named (either by a flexible dtype or with `names`,\n  there must not be any header in the file (else a ValueError\n  exception is raised).\n* Individual values are not stripped of spaces by default.\n  When using a custom converter, make sure the function does remove spaces.\n\nReferences\n----------\n.. [1] Numpy User Guide, section `I/O with Numpy\n       <http://docs.scipy.org/doc/numpy/user/basics.io.genfromtxt.html>`_.\n\nExamples\n---------\n>>> from StringIO import StringIO\n>>> import numpy as np\n\nComma delimited file with mixed dtype\n\n>>> s = StringIO(\"1,1.3,abcde\")\n>>> data = np.genfromtxt(s, dtype=[('myint','i8'),('myfloat','f8'),\n... ('mystring','S5')], delimiter=\",\")\n>>> data\narray((1, 1.3, 'abcde'),\n      dtype=[('myint', '<i8'), ('myfloat', '<f8'), ('mystring', '|S5')])\n\nUsing dtype = None\n\n>>> s.seek(0) # needed for StringIO example only\n>>> data = np.genfromtxt(s, dtype=None,\n... names = ['myint','myfloat','mystring'], delimiter=\",\")\n>>> data\narray((1, 1.3, 'abcde'),\n      dtype=[('myint', '<i8'), ('myfloat', '<f8'), ('mystring', '|S5')])\n\nSpecifying dtype and names\n\n>>> s.seek(0)\n>>> data = np.genfromtxt(s, dtype=\"i8,f8,S5\",\n... names=['myint','myfloat','mystring'], delimiter=\",\")\n>>> data\narray((1, 1.3, 'abcde'),\n      dtype=[('myint', '<i8'), ('myfloat', '<f8'), ('mystring', '|S5')])\n\nAn example with fixed-width columns\n\n>>> s = StringIO(\"11.3abcde\")\n>>> data = np.genfromtxt(s, dtype=None, names=['intvar','fltvar','strvar'],\n...     delimiter=[1,3,5])\n>>> data\narray((1, 1.3, 'abcde'),\n      dtype=[('intvar', '<i8'), ('fltvar', '<f8'), ('strvar', '|S5')])", "id": "f19117:m11"}
{"signature": "def ndfromtxt(fname, **kwargs):", "body": "kwargs['<STR_LIT>'] = False<EOL>return genfromtxt(fname, **kwargs)<EOL>", "docstring": "Load ASCII data stored in a file and return it as a single array.\n\nParameters\n----------\nfname, kwargs : For a description of input parameters, see `genfromtxt`.\n\nSee Also\n--------\nnumpy.genfromtxt : generic function.", "id": "f19117:m12"}
{"signature": "def loadtxt(fname, dtype=float, comments='<STR_LIT:#>', delimiter=None,<EOL>converters=None, skiprows=<NUM_LIT:0>, usecols=None, unpack=False,<EOL>ndmin=<NUM_LIT:0>):", "body": "<EOL>if comments is not None:<EOL><INDENT>comments = asbytes(comments)<EOL><DEDENT>user_converters = converters<EOL>if delimiter is not None:<EOL><INDENT>delimiter = asbytes(delimiter)<EOL><DEDENT>if usecols is not None:<EOL><INDENT>usecols = list(usecols)<EOL><DEDENT>fown = False<EOL>try:<EOL><INDENT>if _is_string_like(fname):<EOL><INDENT>fown = True<EOL>if fname.endswith('<STR_LIT>'):<EOL><INDENT>fh = iter(seek_gzip_factory(fname))<EOL><DEDENT>elif fname.endswith('<STR_LIT>'):<EOL><INDENT>import bz2<EOL>fh = iter(bz2.BZ2File(fname))<EOL><DEDENT>elif sys.version_info[<NUM_LIT:0>] == <NUM_LIT:2>:<EOL><INDENT>fh = iter(open(fname, '<STR_LIT>'))<EOL><DEDENT>else:<EOL><INDENT>fh = iter(open(fname))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>fh = iter(fname)<EOL><DEDENT><DEDENT>except TypeError:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>X = []<EOL>def flatten_dtype(dt):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if dt.names is None:<EOL><INDENT>shape = dt.shape<EOL>if len(shape) == <NUM_LIT:0>:<EOL><INDENT>return ([dt.base], None)<EOL><DEDENT>else:<EOL><INDENT>packing = [(shape[-<NUM_LIT:1>], list)]<EOL>if len(shape) > <NUM_LIT:1>:<EOL><INDENT>for dim in dt.shape[-<NUM_LIT:2>::-<NUM_LIT:1>]:<EOL><INDENT>packing = [(dim*packing[<NUM_LIT:0>][<NUM_LIT:0>], packing*dim)]<EOL><DEDENT><DEDENT>return ([dt.base] * int(np.prod(dt.shape)), packing)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>types = []<EOL>packing = []<EOL>for field in dt.names:<EOL><INDENT>tp, bytes = dt.fields[field]<EOL>flat_dt, flat_packing = flatten_dtype(tp)<EOL>types.extend(flat_dt)<EOL>if len(tp.shape) > <NUM_LIT:0>:<EOL><INDENT>packing.extend(flat_packing)<EOL><DEDENT>else:<EOL><INDENT>packing.append((len(flat_dt), flat_packing))<EOL><DEDENT><DEDENT>return (types, packing)<EOL><DEDENT><DEDENT>def pack_items(items, packing):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if packing is None:<EOL><INDENT>return items[<NUM_LIT:0>]<EOL><DEDENT>elif packing is tuple:<EOL><INDENT>return tuple(items)<EOL><DEDENT>elif packing is list:<EOL><INDENT>return list(items)<EOL><DEDENT>else:<EOL><INDENT>start = <NUM_LIT:0><EOL>ret = []<EOL>for length, subpacking in packing:<EOL><INDENT>ret.append(pack_items(items[start:start+length], subpacking))<EOL>start += length<EOL><DEDENT>return tuple(ret)<EOL><DEDENT><DEDENT>def split_line(line):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if comments is None:<EOL><INDENT>line = asbytes(line).strip(asbytes('<STR_LIT:\\r\\n>'))<EOL><DEDENT>else:<EOL><INDENT>line = asbytes(line).split(comments)[<NUM_LIT:0>].strip(asbytes('<STR_LIT:\\r\\n>'))<EOL><DEDENT>if line:<EOL><INDENT>return line.split(delimiter)<EOL><DEDENT>else:<EOL><INDENT>return []<EOL><DEDENT><DEDENT>try:<EOL><INDENT>dtype = np.dtype(dtype)<EOL>defconv = _getconv(dtype)<EOL>for i in range(skiprows):<EOL><INDENT>next(fh)<EOL><DEDENT>first_vals = None<EOL>try:<EOL><INDENT>while not first_vals:<EOL><INDENT>first_line = next(fh)<EOL>first_vals = split_line(first_line)<EOL><DEDENT><DEDENT>except StopIteration:<EOL><INDENT>first_line = '<STR_LIT>'<EOL>first_vals = []<EOL>warnings.warn('<STR_LIT>' % fname)<EOL><DEDENT>N = len(usecols or first_vals)<EOL>dtype_types, packing = flatten_dtype(dtype)<EOL>if len(dtype_types) > <NUM_LIT:1>:<EOL><INDENT>converters = [_getconv(dt) for dt in dtype_types]<EOL><DEDENT>else:<EOL><INDENT>converters = [defconv for i in range(N)]<EOL>if N > <NUM_LIT:1>:<EOL><INDENT>packing = [(N, tuple)]<EOL><DEDENT><DEDENT>for i, conv in (user_converters or {}).items():<EOL><INDENT>if usecols:<EOL><INDENT>try:<EOL><INDENT>i = usecols.index(i)<EOL><DEDENT>except ValueError:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>converters[i] = conv<EOL><DEDENT>for i, line in enumerate(itertools.chain([first_line], fh)):<EOL><INDENT>vals = split_line(line)<EOL>if len(vals) == <NUM_LIT:0>:<EOL><INDENT>continue<EOL><DEDENT>if usecols:<EOL><INDENT>vals = [vals[i] for i in usecols]<EOL><DEDENT>if len(vals) != N:<EOL><INDENT>line_num = i + skiprows + <NUM_LIT:1><EOL>raise ValueError(\"<STR_LIT>\"<EOL>% line_num)<EOL><DEDENT>items = [conv(val) for (conv, val) in zip(converters, vals)]<EOL>items = pack_items(items, packing)<EOL>X.append(items)<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>if fown:<EOL><INDENT>fh.close()<EOL><DEDENT><DEDENT>X = np.array(X, dtype)<EOL>if X.ndim == <NUM_LIT:3> and X.shape[:<NUM_LIT:2>] == (<NUM_LIT:1>, <NUM_LIT:1>):<EOL><INDENT>X.shape = (<NUM_LIT:1>, -<NUM_LIT:1>)<EOL><DEDENT>if ndmin not in [<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:2>]:<EOL><INDENT>raise ValueError('<STR_LIT>' % ndmin)<EOL><DEDENT>if X.ndim > ndmin:<EOL><INDENT>X = np.squeeze(X)<EOL><DEDENT>if X.ndim < ndmin:<EOL><INDENT>if ndmin == <NUM_LIT:1>:<EOL><INDENT>X = np.atleast_1d(X)<EOL><DEDENT>elif ndmin == <NUM_LIT:2>:<EOL><INDENT>X = np.atleast_2d(X).T<EOL><DEDENT><DEDENT>if unpack:<EOL><INDENT>if len(dtype_types) > <NUM_LIT:1>:<EOL><INDENT>return [X[field] for field in dtype.names]<EOL><DEDENT>else:<EOL><INDENT>return X.T<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return X<EOL><DEDENT>", "docstring": "Load data from a text file.\n\nEach row in the text file must have the same number of values.\n\nParameters\n----------\nfname : file or str\n    File, filename, or generator to read.  If the filename extension is\n    ``.gz`` or ``.bz2``, the file is first decompressed. Note that\n    generators should return byte strings for Python 3k.\ndtype : data-type, optional\n    Data-type of the resulting array; default: float.  If this is a\n    record data-type, the resulting array will be 1-dimensional, and\n    each row will be interpreted as an element of the array.  In this\n    case, the number of columns used must match the number of fields in\n    the data-type.\ncomments : str, optional\n    The character used to indicate the start of a comment;\n    default: '#'.\ndelimiter : str, optional\n    The string used to separate values.  By default, this is any\n    whitespace.\nconverters : dict, optional\n    A dictionary mapping column number to a function that will convert\n    that column to a float.  E.g., if column 0 is a date string:\n    ``converters = {0: datestr2num}``.  Converters can also be used to\n    provide a default value for missing data (but see also `genfromtxt`):\n    ``converters = {3: lambda s: float(s.strip() or 0)}``.  Default: None.\nskiprows : int, optional\n    Skip the first `skiprows` lines; default: 0.\nusecols : sequence, optional\n    Which columns to read, with 0 being the first.  For example,\n    ``usecols = (1,4,5)`` will extract the 2nd, 5th and 6th columns.\n    The default, None, results in all columns being read.\nunpack : bool, optional\n    If True, the returned array is transposed, so that arguments may be\n    unpacked using ``x, y, z = loadtxt(...)``.  When used with a record\n    data-type, arrays are returned for each field.  Default is False.\nndmin : int, optional\n    The returned array will have at least `ndmin` dimensions.\n    Otherwise mono-dimensional axes will be squeezed.\n    Legal values: 0 (default), 1 or 2.\n\n    .. versionadded:: 1.6.0\n\nReturns\n-------\nout : ndarray\n    Data read from the text file.\n\nSee Also\n--------\nload, fromstring, fromregex\ngenfromtxt : Load data with missing values handled as specified.\nscipy.io.loadmat : reads MATLAB data files\n\nNotes\n-----\nThis function aims to be a fast reader for simply formatted files.  The\n`genfromtxt` function provides more sophisticated handling of, e.g.,\nlines with missing values.\n\nExamples\n--------\n>>> from StringIO import StringIO   # StringIO behaves like a file object\n>>> c = StringIO(\"0 1\\\\n2 3\")\n>>> np.loadtxt(c)\narray([[ 0.,  1.],\n       [ 2.,  3.]])\n\n>>> d = StringIO(\"M 21 72\\\\nF 35 58\")\n>>> np.loadtxt(d, dtype={'names': ('gender', 'age', 'weight'),\n...                      'formats': ('S1', 'i4', 'f4')})\narray([('M', 21, 72.0), ('F', 35, 58.0)],\n      dtype=[('gender', '|S1'), ('age', '<i4'), ('weight', '<f4')])\n\n>>> c = StringIO(\"1,0,2\\\\n3,0,4\")\n>>> x, y = np.loadtxt(c, delimiter=',', usecols=(0, 2), unpack=True)\n>>> x\narray([ 1.,  3.])\n>>> y\narray([ 2.,  4.])", "id": "f19117:m8"}
{"signature": "def fix(x, y=None):", "body": "x = nx.asanyarray(x)<EOL>y1 = nx.floor(x)<EOL>y2 = nx.ceil(x)<EOL>if y is None:<EOL><INDENT>y = nx.asanyarray(y1)<EOL><DEDENT>y[...] = nx.where(x >= <NUM_LIT:0>, y1, y2)<EOL>return y<EOL>", "docstring": "Round to nearest integer towards zero.\n\nRound an array of floats element-wise to nearest integer towards zero.\nThe rounded values are returned as floats.\n\nParameters\n----------\nx : array_like\n    An array of floats to be rounded\ny : ndarray, optional\n    Output array\n\nReturns\n-------\nout : ndarray of floats\n    The array of rounded numbers\n\nSee Also\n--------\ntrunc, floor, ceil\naround : Round to given number of decimals\n\nExamples\n--------\n>>> np.fix(3.14)\n3.0\n>>> np.fix(3)\n3.0\n>>> np.fix([2.1, 2.9, -2.1, -2.9])\narray([ 2.,  2., -2., -2.])", "id": "f19119:m0"}
{"signature": "def isneginf(x, y=None):", "body": "if y is None:<EOL><INDENT>x = nx.asarray(x)<EOL>y = nx.empty(x.shape, dtype=nx.bool_)<EOL><DEDENT>nx.logical_and(nx.isinf(x), nx.signbit(x), y)<EOL>return y<EOL>", "docstring": "Test element-wise for negative infinity, return result as bool array.\n\nParameters\n----------\nx : array_like\n    The input array.\ny : array_like, optional\n    A boolean array with the same shape and type as `x` to store the\n    result.\n\nReturns\n-------\ny : ndarray\n    A boolean array with the same dimensions as the input.\n    If second argument is not supplied then a numpy boolean array is\n    returned with values True where the corresponding element of the\n    input is negative infinity and values False where the element of\n    the input is not negative infinity.\n\n    If a second argument is supplied the result is stored there. If the\n    type of that array is a numeric type the result is represented as\n    zeros and ones, if the type is boolean then as False and True. The\n    return value `y` is then a reference to that array.\n\nSee Also\n--------\nisinf, isposinf, isnan, isfinite\n\nNotes\n-----\nNumpy uses the IEEE Standard for Binary Floating-Point for Arithmetic\n(IEEE 754).\n\nErrors result if the second argument is also supplied when x is a scalar\ninput, or if first and second arguments have different shapes.\n\nExamples\n--------\n>>> np.isneginf(np.NINF)\narray(True, dtype=bool)\n>>> np.isneginf(np.inf)\narray(False, dtype=bool)\n>>> np.isneginf(np.PINF)\narray(False, dtype=bool)\n>>> np.isneginf([-np.inf, 0., np.inf])\narray([ True, False, False], dtype=bool)\n\n>>> x = np.array([-np.inf, 0., np.inf])\n>>> y = np.array([2, 2, 2])\n>>> np.isneginf(x, y)\narray([1, 0, 0])\n>>> y\narray([1, 0, 0])", "id": "f19119:m2"}
{"signature": "def _write_array_header(fp, d, version=None):", "body": "import struct<EOL>header = [\"<STR_LIT:{>\"]<EOL>for key, value in sorted(d.items()):<EOL><INDENT>header.append(\"<STR_LIT>\" % (key, repr(value)))<EOL><DEDENT>header.append(\"<STR_LIT:}>\")<EOL>header = \"<STR_LIT>\".join(header)<EOL>current_header_len = MAGIC_LEN + <NUM_LIT:2> + len(header) + <NUM_LIT:1>  <EOL>topad = <NUM_LIT:16> - (current_header_len % <NUM_LIT:16>)<EOL>header = header + '<STR_LIT:U+0020>'*topad + '<STR_LIT:\\n>'<EOL>header = asbytes(_filter_header(header))<EOL>if len(header) >= (<NUM_LIT>*<NUM_LIT>) and version == (<NUM_LIT:1>, <NUM_LIT:0>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (<NUM_LIT>*<NUM_LIT>))<EOL><DEDENT>if len(header) < (<NUM_LIT>*<NUM_LIT>):<EOL><INDENT>header_len_str = struct.pack('<STR_LIT>', len(header))<EOL>version = (<NUM_LIT:1>, <NUM_LIT:0>)<EOL><DEDENT>elif len(header) < (<NUM_LIT:2>**<NUM_LIT:32>):<EOL><INDENT>header_len_str = struct.pack('<STR_LIT>', len(header))<EOL>version = (<NUM_LIT:2>, <NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>fp.write(magic(*version))<EOL>fp.write(header_len_str)<EOL>fp.write(header)<EOL>return version<EOL>", "docstring": "Write the header for an array and returns the version used\n\n    Parameters\n    ----------\n    fp : filelike object\n    d : dict\n        This has the appropriate entries for writing its string representation\n        to the header of the file.\n    version: tuple or None\n        None means use oldest that works\n        explicit version will raise a ValueError if the format does not\n        allow saving this data.  Default: None\n    Returns\n    -------\n    version : tuple of int\n        the file version which needs to be used to store the data", "id": "f19122:m5"}
{"signature": "def write_array_header_1_0(fp, d):", "body": "_write_array_header(fp, d, (<NUM_LIT:1>, <NUM_LIT:0>))<EOL>", "docstring": "Write the header for an array using the 1.0 format.\n\n    Parameters\n    ----------\n    fp : filelike object\n    d : dict\n        This has the appropriate entries for writing its string\n        representation to the header of the file.", "id": "f19122:m6"}
{"signature": "def read_array_header_1_0(fp):", "body": "_read_array_header(fp, version=(<NUM_LIT:1>, <NUM_LIT:0>))<EOL>", "docstring": "Read an array header from a filelike object using the 1.0 file format\nversion.\n\nThis will leave the file object located just after the header.\n\nParameters\n----------\nfp : filelike object\n    A file object or something with a `.read()` method like a file.\n\nReturns\n-------\nshape : tuple of int\n    The shape of the array.\nfortran_order : bool\n    The array data will be written out directly if it is either\n    C-contiguous or Fortran-contiguous. Otherwise, it will be made\n    contiguous before writing it out.\ndtype : dtype\n    The dtype of the file's data.\n\nRaises\n------\nValueError\n    If the data is invalid.", "id": "f19122:m8"}
{"signature": "def read_array_header_2_0(fp):", "body": "_read_array_header(fp, version=(<NUM_LIT:2>, <NUM_LIT:0>))<EOL>", "docstring": "Read an array header from a filelike object using the 2.0 file format\nversion.\n\nThis will leave the file object located just after the header.\n\n.. versionadded:: 1.9.0\n\nParameters\n----------\nfp : filelike object\n    A file object or something with a `.read()` method like a file.\n\nReturns\n-------\nshape : tuple of int\n    The shape of the array.\nfortran_order : bool\n    The array data will be written out directly if it is either\n    C-contiguous or Fortran-contiguous. Otherwise, it will be made\n    contiguous before writing it out.\ndtype : dtype\n    The dtype of the file's data.\n\nRaises\n------\nValueError\n    If the data is invalid.", "id": "f19122:m9"}
{"signature": "def dtype_to_descr(dtype):", "body": "if dtype.names is not None:<EOL><INDENT>return dtype.descr<EOL><DEDENT>else:<EOL><INDENT>return dtype.str<EOL><DEDENT>", "docstring": "Get a serializable descriptor from the dtype.\n\nThe .descr attribute of a dtype object cannot be round-tripped through\nthe dtype() constructor. Simple types, like dtype('float32'), have\na descr which looks like a record array with one field with '' as\na name. The dtype() constructor interprets this as a request to give\na default name.  Instead, we construct descriptor that can be passed to\ndtype().\n\nParameters\n----------\ndtype : dtype\n    The dtype of the array that will be written to disk.\n\nReturns\n-------\ndescr : object\n    An object that can be passed to `numpy.dtype()` in order to\n    replicate the input dtype.", "id": "f19122:m3"}
{"signature": "def open_memmap(filename, mode='<STR_LIT>', dtype=None, shape=None,<EOL>fortran_order=False, version=None):", "body": "if not isinstance(filename, basestring):<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>if '<STR_LIT:w>' in mode:<EOL><INDENT>_check_version(version)<EOL>dtype = numpy.dtype(dtype)<EOL>if dtype.hasobject:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValueError(msg)<EOL><DEDENT>d = dict(<EOL>descr=dtype_to_descr(dtype),<EOL>fortran_order=fortran_order,<EOL>shape=shape,<EOL>)<EOL>fp = open(filename, mode+'<STR_LIT:b>')<EOL>try:<EOL><INDENT>used_ver = _write_array_header(fp, d, version)<EOL>if version != (<NUM_LIT:2>, <NUM_LIT:0>) and used_ver == (<NUM_LIT:2>, <NUM_LIT:0>):<EOL><INDENT>warnings.warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\", UserWarning)<EOL><DEDENT>offset = fp.tell()<EOL><DEDENT>finally:<EOL><INDENT>fp.close()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>fp = open(filename, '<STR_LIT:rb>')<EOL>try:<EOL><INDENT>version = read_magic(fp)<EOL>_check_version(version)<EOL>shape, fortran_order, dtype = _read_array_header(fp, version)<EOL>if dtype.hasobject:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValueError(msg)<EOL><DEDENT>offset = fp.tell()<EOL><DEDENT>finally:<EOL><INDENT>fp.close()<EOL><DEDENT><DEDENT>if fortran_order:<EOL><INDENT>order = '<STR_LIT:F>'<EOL><DEDENT>else:<EOL><INDENT>order = '<STR_LIT:C>'<EOL><DEDENT>if mode == '<STR_LIT>':<EOL><INDENT>mode = '<STR_LIT>'<EOL><DEDENT>marray = numpy.memmap(filename, dtype=dtype, shape=shape, order=order,<EOL>mode=mode, offset=offset)<EOL>return marray<EOL>", "docstring": "Open a .npy file as a memory-mapped array.\n\nThis may be used to read an existing file or create a new one.\n\nParameters\n----------\nfilename : str\n    The name of the file on disk.  This may *not* be a file-like\n    object.\nmode : str, optional\n    The mode in which to open the file; the default is 'r+'.  In\n    addition to the standard file modes, 'c' is also accepted to mean\n    \"copy on write.\"  See `memmap` for the available mode strings.\ndtype : data-type, optional\n    The data type of the array if we are creating a new file in \"write\"\n    mode, if not, `dtype` is ignored.  The default value is None, which\n    results in a data-type of `float64`.\nshape : tuple of int\n    The shape of the array if we are creating a new file in \"write\"\n    mode, in which case this parameter is required.  Otherwise, this\n    parameter is ignored and is thus optional.\nfortran_order : bool, optional\n    Whether the array should be Fortran-contiguous (True) or\n    C-contiguous (False, the default) if we are creating a new file in\n    \"write\" mode.\nversion : tuple of int (major, minor) or None\n    If the mode is a \"write\" mode, then this is the version of the file\n    format used to create the file.  None means use the oldest\n    supported version that is able to store the data.  Default: None\n\nReturns\n-------\nmarray : memmap\n    The memory-mapped array.\n\nRaises\n------\nValueError\n    If the data or the mode is invalid.\nIOError\n    If the file is not found or cannot be opened correctly.\n\nSee Also\n--------\nmemmap", "id": "f19122:m14"}
{"signature": "def write_array(fp, array, version=None):", "body": "_check_version(version)<EOL>used_ver = _write_array_header(fp, header_data_from_array_1_0(array),<EOL>version)<EOL>if version != (<NUM_LIT:2>, <NUM_LIT:0>) and used_ver == (<NUM_LIT:2>, <NUM_LIT:0>):<EOL><INDENT>warnings.warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\", UserWarning)<EOL><DEDENT>buffersize = max(<NUM_LIT:16> * <NUM_LIT> ** <NUM_LIT:2> // array.itemsize, <NUM_LIT:1>)<EOL>if array.dtype.hasobject:<EOL><INDENT>pickle.dump(array, fp, protocol=<NUM_LIT:2>)<EOL><DEDENT>elif array.flags.f_contiguous and not array.flags.c_contiguous:<EOL><INDENT>if isfileobj(fp):<EOL><INDENT>array.T.tofile(fp)<EOL><DEDENT>else:<EOL><INDENT>for chunk in numpy.nditer(<EOL>array, flags=['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'],<EOL>buffersize=buffersize, order='<STR_LIT:F>'):<EOL><INDENT>fp.write(chunk.tobytes('<STR_LIT:C>'))<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if isfileobj(fp):<EOL><INDENT>array.tofile(fp)<EOL><DEDENT>else:<EOL><INDENT>for chunk in numpy.nditer(<EOL>array, flags=['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'],<EOL>buffersize=buffersize, order='<STR_LIT:C>'):<EOL><INDENT>fp.write(chunk.tobytes('<STR_LIT:C>'))<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Write an array to an NPY file, including a header.\n\nIf the array is neither C-contiguous nor Fortran-contiguous AND the\nfile_like object is not a real file object, this function will have to\ncopy data in memory.\n\nParameters\n----------\nfp : file_like object\n    An open, writable file object, or similar object with a\n    ``.write()`` method.\narray : ndarray\n    The array to write to disk.\nversion : (int, int) or None, optional\n    The version number of the format. None means use the oldest\n    supported version that is able to store the data.  Default: None\n\nRaises\n------\nValueError\n    If the array cannot be persisted.\nVarious other errors\n    If the array contains Python objects as part of its dtype, the\n    process of pickling them may raise various errors if the objects\n    are not picklable.", "id": "f19122:m12"}
{"signature": "def _read_array_header(fp, version):", "body": "<EOL>import struct<EOL>if version == (<NUM_LIT:1>, <NUM_LIT:0>):<EOL><INDENT>hlength_str = _read_bytes(fp, <NUM_LIT:2>, \"<STR_LIT>\")<EOL>header_length = struct.unpack('<STR_LIT>', hlength_str)[<NUM_LIT:0>]<EOL>header = _read_bytes(fp, header_length, \"<STR_LIT>\")<EOL><DEDENT>elif version == (<NUM_LIT:2>, <NUM_LIT:0>):<EOL><INDENT>hlength_str = _read_bytes(fp, <NUM_LIT:4>, \"<STR_LIT>\")<EOL>header_length = struct.unpack('<STR_LIT>', hlength_str)[<NUM_LIT:0>]<EOL>header = _read_bytes(fp, header_length, \"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % version)<EOL><DEDENT>header = _filter_header(header)<EOL>try:<EOL><INDENT>d = safe_eval(header)<EOL><DEDENT>except SyntaxError as e:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValueError(msg % (header, e))<EOL><DEDENT>if not isinstance(d, dict):<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValueError(msg % d)<EOL><DEDENT>keys = sorted(d.keys())<EOL>if keys != ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValueError(msg % (keys,))<EOL><DEDENT>if (not isinstance(d['<STR_LIT>'], tuple) or<EOL>not numpy.all([isinstance(x, (int, long)) for x in d['<STR_LIT>']])):<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValueError(msg % (d['<STR_LIT>'],))<EOL><DEDENT>if not isinstance(d['<STR_LIT>'], bool):<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValueError(msg % (d['<STR_LIT>'],))<EOL><DEDENT>try:<EOL><INDENT>dtype = numpy.dtype(d['<STR_LIT>'])<EOL><DEDENT>except TypeError as e:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>raise ValueError(msg % (d['<STR_LIT>'],))<EOL><DEDENT>return d['<STR_LIT>'], d['<STR_LIT>'], dtype<EOL>", "docstring": "see read_array_header_1_0", "id": "f19122:m11"}
{"signature": "def polymul(a1, a2):", "body": "truepoly = (isinstance(a1, poly1d) or isinstance(a2, poly1d))<EOL>a1, a2 = poly1d(a1), poly1d(a2)<EOL>val = NX.convolve(a1, a2)<EOL>if truepoly:<EOL><INDENT>val = poly1d(val)<EOL><DEDENT>return val<EOL>", "docstring": "Find the product of two polynomials.\n\nFinds the polynomial resulting from the multiplication of the two input\npolynomials. Each input must be either a poly1d object or a 1D sequence\nof polynomial coefficients, from highest to lowest degree.\n\nParameters\n----------\na1, a2 : array_like or poly1d object\n    Input polynomials.\n\nReturns\n-------\nout : ndarray or poly1d object\n    The polynomial resulting from the multiplication of the inputs. If\n    either inputs is a poly1d object, then the output is also a poly1d\n    object. Otherwise, it is a 1D array of polynomial coefficients from\n    highest to lowest degree.\n\nSee Also\n--------\npoly1d : A one-dimensional polynomial class.\npoly, polyadd, polyder, polydiv, polyfit, polyint, polysub,\npolyval\nconvolve : Array convolution. Same output as polymul, but has parameter\n           for overlap mode.\n\nExamples\n--------\n>>> np.polymul([1, 2, 3], [9, 5, 1])\narray([ 9, 23, 38, 17,  3])\n\nUsing poly1d objects:\n\n>>> p1 = np.poly1d([1, 2, 3])\n>>> p2 = np.poly1d([9, 5, 1])\n>>> print p1\n   2\n1 x + 2 x + 3\n>>> print p2\n   2\n9 x + 5 x + 1\n>>> print np.polymul(p1, p2)\n   4      3      2\n9 x + 23 x + 38 x + 17 x + 3", "id": "f19123:m8"}
{"signature": "def roots(p):", "body": "<EOL>p = atleast_1d(p)<EOL>if len(p.shape) != <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>non_zero = NX.nonzero(NX.ravel(p))[<NUM_LIT:0>]<EOL>if len(non_zero) == <NUM_LIT:0>:<EOL><INDENT>return NX.array([])<EOL><DEDENT>trailing_zeros = len(p) - non_zero[-<NUM_LIT:1>] - <NUM_LIT:1><EOL>p = p[int(non_zero[<NUM_LIT:0>]):int(non_zero[-<NUM_LIT:1>])+<NUM_LIT:1>]<EOL>if not issubclass(p.dtype.type, (NX.floating, NX.complexfloating)):<EOL><INDENT>p = p.astype(float)<EOL><DEDENT>N = len(p)<EOL>if N > <NUM_LIT:1>:<EOL><INDENT>A = diag(NX.ones((N-<NUM_LIT:2>,), p.dtype), -<NUM_LIT:1>)<EOL>A[<NUM_LIT:0>,:] = -p[<NUM_LIT:1>:] / p[<NUM_LIT:0>]<EOL>roots = eigvals(A)<EOL><DEDENT>else:<EOL><INDENT>roots = NX.array([])<EOL><DEDENT>roots = hstack((roots, NX.zeros(trailing_zeros, roots.dtype)))<EOL>return roots<EOL>", "docstring": "Return the roots of a polynomial with coefficients given in p.\n\nThe values in the rank-1 array `p` are coefficients of a polynomial.\nIf the length of `p` is n+1 then the polynomial is described by::\n\n  p[0] * x**n + p[1] * x**(n-1) + ... + p[n-1]*x + p[n]\n\nParameters\n----------\np : array_like\n    Rank-1 array of polynomial coefficients.\n\nReturns\n-------\nout : ndarray\n    An array containing the complex roots of the polynomial.\n\nRaises\n------\nValueError\n    When `p` cannot be converted to a rank-1 array.\n\nSee also\n--------\npoly : Find the coefficients of a polynomial with a given sequence\n       of roots.\npolyval : Evaluate a polynomial at a point.\npolyfit : Least squares polynomial fit.\npoly1d : A one-dimensional polynomial class.\n\nNotes\n-----\nThe algorithm relies on computing the eigenvalues of the\ncompanion matrix [1]_.\n\nReferences\n----------\n.. [1] R. A. Horn & C. R. Johnson, *Matrix Analysis*.  Cambridge, UK:\n    Cambridge University Press, 1999, pp. 146-7.\n\nExamples\n--------\n>>> coeff = [3.2, 2, 1]\n>>> np.roots(coeff)\narray([-0.3125+0.46351241j, -0.3125-0.46351241j])", "id": "f19123:m1"}
{"signature": "def polyval(p, x):", "body": "p = NX.asarray(p)<EOL>if isinstance(x, poly1d):<EOL><INDENT>y = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>x = NX.asarray(x)<EOL>y = NX.zeros_like(x)<EOL><DEDENT>for i in range(len(p)):<EOL><INDENT>y = x * y + p[i]<EOL><DEDENT>return y<EOL>", "docstring": "Evaluate a polynomial at specific values.\n\nIf `p` is of length N, this function returns the value:\n\n    ``p[0]*x**(N-1) + p[1]*x**(N-2) + ... + p[N-2]*x + p[N-1]``\n\nIf `x` is a sequence, then `p(x)` is returned for each element of `x`.\nIf `x` is another polynomial then the composite polynomial `p(x(t))`\nis returned.\n\nParameters\n----------\np : array_like or poly1d object\n   1D array of polynomial coefficients (including coefficients equal\n   to zero) from highest degree to the constant term, or an\n   instance of poly1d.\nx : array_like or poly1d object\n   A number, a 1D array of numbers, or an instance of poly1d, \"at\"\n   which to evaluate `p`.\n\nReturns\n-------\nvalues : ndarray or poly1d\n   If `x` is a poly1d instance, the result is the composition of the two\n   polynomials, i.e., `x` is \"substituted\" in `p` and the simplified\n   result is returned. In addition, the type of `x` - array_like or\n   poly1d - governs the type of the output: `x` array_like => `values`\n   array_like, `x` a poly1d object => `values` is also.\n\nSee Also\n--------\npoly1d: A polynomial class.\n\nNotes\n-----\nHorner's scheme [1]_ is used to evaluate the polynomial. Even so,\nfor polynomials of high degree the values may be inaccurate due to\nrounding errors. Use carefully.\n\nReferences\n----------\n.. [1] I. N. Bronshtein, K. A. Semendyayev, and K. A. Hirsch (Eng.\n   trans. Ed.), *Handbook of Mathematics*, New York, Van Nostrand\n   Reinhold Co., 1985, pg. 720.\n\nExamples\n--------\n>>> np.polyval([3,0,1], 5)  # 3 * 5**2 + 0 * 5**1 + 1\n76\n>>> np.polyval([3,0,1], np.poly1d(5))\npoly1d([ 76.])\n>>> np.polyval(np.poly1d([3,0,1]), 5)\n76\n>>> np.polyval(np.poly1d([3,0,1]), np.poly1d(5))\npoly1d([ 76.])", "id": "f19123:m5"}
{"signature": "def poly(seq_of_zeros):", "body": "seq_of_zeros = atleast_1d(seq_of_zeros)<EOL>sh = seq_of_zeros.shape<EOL>if len(sh) == <NUM_LIT:2> and sh[<NUM_LIT:0>] == sh[<NUM_LIT:1>] and sh[<NUM_LIT:0>] != <NUM_LIT:0>:<EOL><INDENT>seq_of_zeros = eigvals(seq_of_zeros)<EOL><DEDENT>elif len(sh) == <NUM_LIT:1>:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if len(seq_of_zeros) == <NUM_LIT:0>:<EOL><INDENT>return <NUM_LIT:1.0><EOL><DEDENT>a = [<NUM_LIT:1>]<EOL>for k in range(len(seq_of_zeros)):<EOL><INDENT>a = NX.convolve(a, [<NUM_LIT:1>, -seq_of_zeros[k]], mode='<STR_LIT>')<EOL><DEDENT>if issubclass(a.dtype.type, NX.complexfloating):<EOL><INDENT>roots = NX.asarray(seq_of_zeros, complex)<EOL>pos_roots = sort_complex(NX.compress(roots.imag > <NUM_LIT:0>, roots))<EOL>neg_roots = NX.conjugate(sort_complex(<EOL>NX.compress(roots.imag < <NUM_LIT:0>, roots)))<EOL>if (len(pos_roots) == len(neg_roots) and<EOL>NX.alltrue(neg_roots == pos_roots)):<EOL><INDENT>a = a.real.copy()<EOL><DEDENT><DEDENT>return a<EOL>", "docstring": "Find the coefficients of a polynomial with the given sequence of roots.\n\nReturns the coefficients of the polynomial whose leading coefficient\nis one for the given sequence of zeros (multiple roots must be included\nin the sequence as many times as their multiplicity; see Examples).\nA square matrix (or array, which will be treated as a matrix) can also\nbe given, in which case the coefficients of the characteristic polynomial\nof the matrix are returned.\n\nParameters\n----------\nseq_of_zeros : array_like, shape (N,) or (N, N)\n    A sequence of polynomial roots, or a square array or matrix object.\n\nReturns\n-------\nc : ndarray\n    1D array of polynomial coefficients from highest to lowest degree:\n\n    ``c[0] * x**(N) + c[1] * x**(N-1) + ... + c[N-1] * x + c[N]``\n    where c[0] always equals 1.\n\nRaises\n------\nValueError\n    If input is the wrong shape (the input must be a 1-D or square\n    2-D array).\n\nSee Also\n--------\npolyval : Evaluate a polynomial at a point.\nroots : Return the roots of a polynomial.\npolyfit : Least squares polynomial fit.\npoly1d : A one-dimensional polynomial class.\n\nNotes\n-----\nSpecifying the roots of a polynomial still leaves one degree of\nfreedom, typically represented by an undetermined leading\ncoefficient. [1]_ In the case of this function, that coefficient -\nthe first one in the returned array - is always taken as one. (If\nfor some reason you have one other point, the only automatic way\npresently to leverage that information is to use ``polyfit``.)\n\nThe characteristic polynomial, :math:`p_a(t)`, of an `n`-by-`n`\nmatrix **A** is given by\n\n    :math:`p_a(t) = \\\\mathrm{det}(t\\\\, \\\\mathbf{I} - \\\\mathbf{A})`,\n\nwhere **I** is the `n`-by-`n` identity matrix. [2]_\n\nReferences\n----------\n.. [1] M. Sullivan and M. Sullivan, III, \"Algebra and Trignometry,\n   Enhanced With Graphing Utilities,\" Prentice-Hall, pg. 318, 1996.\n\n.. [2] G. Strang, \"Linear Algebra and Its Applications, 2nd Edition,\"\n   Academic Press, pg. 182, 1980.\n\nExamples\n--------\nGiven a sequence of a polynomial's zeros:\n\n>>> np.poly((0, 0, 0)) # Multiple root example\narray([1, 0, 0, 0])\n\nThe line above represents z**3 + 0*z**2 + 0*z + 0.\n\n>>> np.poly((-1./2, 0, 1./2))\narray([ 1.  ,  0.  , -0.25,  0.  ])\n\nThe line above represents z**3 - z/4\n\n>>> np.poly((np.random.random(1.)[0], 0, np.random.random(1.)[0]))\narray([ 1.        , -0.77086955,  0.08618131,  0.        ]) #random\n\nGiven a square array object:\n\n>>> P = np.array([[0, 1./3], [-1./2, 0]])\n>>> np.poly(P)\narray([ 1.        ,  0.        ,  0.16666667])\n\nOr a square matrix object:\n\n>>> np.poly(np.matrix(P))\narray([ 1.        ,  0.        ,  0.16666667])\n\nNote how in all cases the leading coefficient is always 1.", "id": "f19123:m0"}
{"signature": "def integ(self, m=<NUM_LIT:1>, k=<NUM_LIT:0>):", "body": "return poly1d(polyint(self.coeffs, m=m, k=k))<EOL>", "docstring": "Return an antiderivative (indefinite integral) of this polynomial.\n\nRefer to `polyint` for full documentation.\n\nSee Also\n--------\npolyint : equivalent function", "id": "f19123:c1:m24"}
{"signature": "def polyder(p, m=<NUM_LIT:1>):", "body": "m = int(m)<EOL>if m < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>truepoly = isinstance(p, poly1d)<EOL>p = NX.asarray(p)<EOL>n = len(p) - <NUM_LIT:1><EOL>y = p[:-<NUM_LIT:1>] * NX.arange(n, <NUM_LIT:0>, -<NUM_LIT:1>)<EOL>if m == <NUM_LIT:0>:<EOL><INDENT>val = p<EOL><DEDENT>else:<EOL><INDENT>val = polyder(y, m - <NUM_LIT:1>)<EOL><DEDENT>if truepoly:<EOL><INDENT>val = poly1d(val)<EOL><DEDENT>return val<EOL>", "docstring": "Return the derivative of the specified order of a polynomial.\n\nParameters\n----------\np : poly1d or sequence\n    Polynomial to differentiate.\n    A sequence is interpreted as polynomial coefficients, see `poly1d`.\nm : int, optional\n    Order of differentiation (default: 1)\n\nReturns\n-------\nder : poly1d\n    A new polynomial representing the derivative.\n\nSee Also\n--------\npolyint : Anti-derivative of a polynomial.\npoly1d : Class for one-dimensional polynomials.\n\nExamples\n--------\nThe derivative of the polynomial :math:`x^3 + x^2 + x^1 + 1` is:\n\n>>> p = np.poly1d([1,1,1,1])\n>>> p2 = np.polyder(p)\n>>> p2\npoly1d([3, 2, 1])\n\nwhich evaluates to:\n\n>>> p2(2.)\n17.0\n\nWe can verify this, approximating the derivative with\n``(f(x + h) - f(x))/h``:\n\n>>> (p(2. + 0.001) - p(2.)) / 0.001\n17.007000999997857\n\nThe fourth-order derivative of a 3rd-order polynomial is zero:\n\n>>> np.polyder(p, 2)\npoly1d([6, 2])\n>>> np.polyder(p, 3)\npoly1d([6])\n>>> np.polyder(p, 4)\npoly1d([ 0.])", "id": "f19123:m3"}
{"signature": "def find_duplicates(a, key=None, ignoremask=True, return_index=False):", "body": "a = np.asanyarray(a).ravel()<EOL>fields = get_fieldstructure(a.dtype)<EOL>base = a<EOL>if key:<EOL><INDENT>for f in fields[key]:<EOL><INDENT>base = base[f]<EOL><DEDENT>base = base[key]<EOL><DEDENT>sortidx = base.argsort()<EOL>sortedbase = base[sortidx]<EOL>sorteddata = sortedbase.filled()<EOL>flag = (sorteddata[:-<NUM_LIT:1>] == sorteddata[<NUM_LIT:1>:])<EOL>if ignoremask:<EOL><INDENT>sortedmask = sortedbase.recordmask<EOL>flag[sortedmask[<NUM_LIT:1>:]] = False<EOL><DEDENT>flag = np.concatenate(([False], flag))<EOL>flag[:-<NUM_LIT:1>] = flag[:-<NUM_LIT:1>] + flag[<NUM_LIT:1>:]<EOL>duplicates = a[sortidx][flag]<EOL>if return_index:<EOL><INDENT>return (duplicates, sortidx[flag])<EOL><DEDENT>else:<EOL><INDENT>return duplicates<EOL><DEDENT>", "docstring": "Find the duplicates in a structured array along a given key\n\nParameters\n----------\na : array-like\n    Input array\nkey : {string, None}, optional\n    Name of the fields along which to check the duplicates.\n    If None, the search is performed by records\nignoremask : {True, False}, optional\n    Whether masked data should be discarded or considered as duplicates.\nreturn_index : {False, True}, optional\n    Whether to return the indices of the duplicated values.\n\nExamples\n--------\n>>> from numpy.lib import recfunctions as rfn\n>>> ndtype = [('a', int)]\n>>> a = np.ma.array([1, 1, 1, 2, 2, 3, 3],\n...         mask=[0, 0, 1, 0, 0, 0, 1]).view(ndtype)\n>>> rfn.find_duplicates(a, ignoremask=True, return_index=True)\n... # XXX: judging by the output, the ignoremask flag has no effect", "id": "f19124:m18"}
{"signature": "def izip_records(seqarrays, fill_value=None, flatten=True):", "body": "<EOL>def sentinel(counter=([fill_value] * (len(seqarrays) - <NUM_LIT:1>)).pop):<EOL><INDENT>\"<STR_LIT>\"<EOL>yield counter()<EOL><DEDENT>fillers = itertools.repeat(fill_value)<EOL>iters = [itertools.chain(it, sentinel(), fillers) for it in seqarrays]<EOL>if flatten:<EOL><INDENT>zipfunc = _izip_fields_flat<EOL><DEDENT>else:<EOL><INDENT>zipfunc = _izip_fields<EOL><DEDENT>try:<EOL><INDENT>for tup in zip(*iters):<EOL><INDENT>yield tuple(zipfunc(tup))<EOL><DEDENT><DEDENT>except IndexError:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "Returns an iterator of concatenated items from a sequence of arrays.\n\nParameters\n----------\nseqarray : sequence of arrays\n    Sequence of arrays.\nfill_value : {None, integer}\n    Value used to pad shorter iterables.\nflatten : {True, False},\n    Whether to", "id": "f19124:m8"}
{"signature": "def rec_join(key, r1, r2, jointype='<STR_LIT>', r1postfix='<STR_LIT:1>', r2postfix='<STR_LIT:2>',<EOL>defaults=None):", "body": "kwargs = dict(jointype=jointype, r1postfix=r1postfix, r2postfix=r2postfix,<EOL>defaults=defaults, usemask=False, asrecarray=True)<EOL>return join_by(key, r1, r2, **kwargs)<EOL>", "docstring": "Join arrays `r1` and `r2` on keys.\nAlternative to join_by, that always returns a np.recarray.\n\nSee Also\n--------\njoin_by : equivalent function", "id": "f19124:m20"}
{"signature": "def zip_descr(seqarrays, flatten=False):", "body": "newdtype = []<EOL>if flatten:<EOL><INDENT>for a in seqarrays:<EOL><INDENT>newdtype.extend(flatten_descr(a.dtype))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for a in seqarrays:<EOL><INDENT>current = a.dtype<EOL>names = current.names or ()<EOL>if len(names) > <NUM_LIT:1>:<EOL><INDENT>newdtype.append(('<STR_LIT>', current.descr))<EOL><DEDENT>else:<EOL><INDENT>newdtype.extend(current.descr)<EOL><DEDENT><DEDENT><DEDENT>return np.dtype(newdtype).descr<EOL>", "docstring": "Combine the dtype description of a series of arrays.\n\nParameters\n----------\nseqarrays : sequence of arrays\n    Sequence of arrays\nflatten : {boolean}, optional\n    Whether to collapse nested descriptions.", "id": "f19124:m4"}
{"signature": "def join_by(key, r1, r2, jointype='<STR_LIT>', r1postfix='<STR_LIT:1>', r2postfix='<STR_LIT:2>',<EOL>defaults=None, usemask=True, asrecarray=False):", "body": "<EOL>if jointype not in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % jointype<EOL>)<EOL><DEDENT>if isinstance(key, basestring):<EOL><INDENT>key = (key,)<EOL><DEDENT>for name in key:<EOL><INDENT>if name not in r1.dtype.names:<EOL><INDENT>raise ValueError('<STR_LIT>' % name)<EOL><DEDENT>if name not in r2.dtype.names:<EOL><INDENT>raise ValueError('<STR_LIT>' % name)<EOL><DEDENT><DEDENT>r1 = r1.ravel()<EOL>r2 = r2.ravel()<EOL>nb1 = len(r1)<EOL>(r1names, r2names) = (r1.dtype.names, r2.dtype.names)<EOL>if (set.intersection(set(r1names), set(r2names)).difference(key) and<EOL>not (r1postfix or r2postfix)):<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>msg += \"<STR_LIT>\"<EOL>raise ValueError(msg)<EOL><DEDENT>r1k = drop_fields(r1, [n for n in r1names if n not in key])<EOL>r2k = drop_fields(r2, [n for n in r2names if n not in key])<EOL>aux = ma.concatenate((r1k, r2k))<EOL>idx_sort = aux.argsort(order=key)<EOL>aux = aux[idx_sort]<EOL>flag_in = ma.concatenate(([False], aux[<NUM_LIT:1>:] == aux[:-<NUM_LIT:1>]))<EOL>flag_in[:-<NUM_LIT:1>] = flag_in[<NUM_LIT:1>:] + flag_in[:-<NUM_LIT:1>]<EOL>idx_in = idx_sort[flag_in]<EOL>idx_1 = idx_in[(idx_in < nb1)]<EOL>idx_2 = idx_in[(idx_in >= nb1)] - nb1<EOL>(r1cmn, r2cmn) = (len(idx_1), len(idx_2))<EOL>if jointype == '<STR_LIT>':<EOL><INDENT>(r1spc, r2spc) = (<NUM_LIT:0>, <NUM_LIT:0>)<EOL><DEDENT>elif jointype == '<STR_LIT>':<EOL><INDENT>idx_out = idx_sort[~flag_in]<EOL>idx_1 = np.concatenate((idx_1, idx_out[(idx_out < nb1)]))<EOL>idx_2 = np.concatenate((idx_2, idx_out[(idx_out >= nb1)] - nb1))<EOL>(r1spc, r2spc) = (len(idx_1) - r1cmn, len(idx_2) - r2cmn)<EOL><DEDENT>elif jointype == '<STR_LIT>':<EOL><INDENT>idx_out = idx_sort[~flag_in]<EOL>idx_1 = np.concatenate((idx_1, idx_out[(idx_out < nb1)]))<EOL>(r1spc, r2spc) = (len(idx_1) - r1cmn, <NUM_LIT:0>)<EOL><DEDENT>(s1, s2) = (r1[idx_1], r2[idx_2])<EOL>ndtype = [list(_) for _ in r1k.dtype.descr]<EOL>ndtype.extend(list(_) for _ in r1.dtype.descr if _[<NUM_LIT:0>] not in key)<EOL>names = list(_[<NUM_LIT:0>] for _ in ndtype)<EOL>for desc in r2.dtype.descr:<EOL><INDENT>desc = list(desc)<EOL>name = desc[<NUM_LIT:0>]<EOL>if name in names:<EOL><INDENT>nameidx = ndtype.index(desc)<EOL>current = ndtype[nameidx]<EOL>if name in key:<EOL><INDENT>current[-<NUM_LIT:1>] = max(desc[<NUM_LIT:1>], current[-<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>current[<NUM_LIT:0>] += r1postfix<EOL>desc[<NUM_LIT:0>] += r2postfix<EOL>ndtype.insert(nameidx + <NUM_LIT:1>, desc)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>names.extend(desc[<NUM_LIT:0>])<EOL>ndtype.append(desc)<EOL><DEDENT><DEDENT>ndtype = [tuple(_) for _ in ndtype]<EOL>cmn = max(r1cmn, r2cmn)<EOL>output = ma.masked_all((cmn + r1spc + r2spc,), dtype=ndtype)<EOL>names = output.dtype.names<EOL>for f in r1names:<EOL><INDENT>selected = s1[f]<EOL>if f not in names or (f in r2names and not r2postfix and f not in key):<EOL><INDENT>f += r1postfix<EOL><DEDENT>current = output[f]<EOL>current[:r1cmn] = selected[:r1cmn]<EOL>if jointype in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>current[cmn:cmn + r1spc] = selected[r1cmn:]<EOL><DEDENT><DEDENT>for f in r2names:<EOL><INDENT>selected = s2[f]<EOL>if f not in names or (f in r1names and not r1postfix and f not in key):<EOL><INDENT>f += r2postfix<EOL><DEDENT>current = output[f]<EOL>current[:r2cmn] = selected[:r2cmn]<EOL>if (jointype == '<STR_LIT>') and r2spc:<EOL><INDENT>current[-r2spc:] = selected[r2cmn:]<EOL><DEDENT><DEDENT>output.sort(order=key)<EOL>kwargs = dict(usemask=usemask, asrecarray=asrecarray)<EOL>return _fix_output(_fix_defaults(output, defaults), **kwargs)<EOL>", "docstring": "Join arrays `r1` and `r2` on key `key`.\n\nThe key should be either a string or a sequence of string corresponding\nto the fields used to join the array.  An exception is raised if the\n`key` field cannot be found in the two input arrays.  Neither `r1` nor\n`r2` should have any duplicates along `key`: the presence of duplicates\nwill make the output quite unreliable. Note that duplicates are not\nlooked for by the algorithm.\n\nParameters\n----------\nkey : {string, sequence}\n    A string or a sequence of strings corresponding to the fields used\n    for comparison.\nr1, r2 : arrays\n    Structured arrays.\njointype : {'inner', 'outer', 'leftouter'}, optional\n    If 'inner', returns the elements common to both r1 and r2.\n    If 'outer', returns the common elements as well as the elements of\n    r1 not in r2 and the elements of not in r2.\n    If 'leftouter', returns the common elements and the elements of r1\n    not in r2.\nr1postfix : string, optional\n    String appended to the names of the fields of r1 that are present\n    in r2 but absent of the key.\nr2postfix : string, optional\n    String appended to the names of the fields of r2 that are present\n    in r1 but absent of the key.\ndefaults : {dictionary}, optional\n    Dictionary mapping field names to the corresponding default values.\nusemask : {True, False}, optional\n    Whether to return a MaskedArray (or MaskedRecords is\n    `asrecarray==True`) or a ndarray.\nasrecarray : {False, True}, optional\n    Whether to return a recarray (or MaskedRecords if `usemask==True`)\n    or just a flexible-type ndarray.\n\nNotes\n-----\n* The output is sorted along the key.\n* A temporary array is formed by dropping the fields not in the key for\n  the two arrays and concatenating the result. This array is then\n  sorted, and the common entries selected. The output is constructed by\n  filling the fields with the selected entries. Matching is not\n  preserved if there are some duplicates...", "id": "f19124:m19"}
{"signature": "def _fix_defaults(output, defaults=None):", "body": "names = output.dtype.names<EOL>(data, mask, fill_value) = (output.data, output.mask, output.fill_value)<EOL>for (k, v) in (defaults or {}).items():<EOL><INDENT>if k in names:<EOL><INDENT>fill_value[k] = v<EOL>data[k][mask[k]] = v<EOL><DEDENT><DEDENT>return output<EOL>", "docstring": "Update the fill_value and masked data of `output`\nfrom the default given in a dictionary defaults.", "id": "f19124:m10"}
{"signature": "def diff(a, n=<NUM_LIT:1>, axis=-<NUM_LIT:1>):", "body": "if n == <NUM_LIT:0>:<EOL><INDENT>return a<EOL><DEDENT>if n < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\" + repr(n))<EOL><DEDENT>a = asanyarray(a)<EOL>nd = len(a.shape)<EOL>slice1 = [slice(None)]*nd<EOL>slice2 = [slice(None)]*nd<EOL>slice1[axis] = slice(<NUM_LIT:1>, None)<EOL>slice2[axis] = slice(None, -<NUM_LIT:1>)<EOL>slice1 = tuple(slice1)<EOL>slice2 = tuple(slice2)<EOL>if n > <NUM_LIT:1>:<EOL><INDENT>return diff(a[slice1]-a[slice2], n-<NUM_LIT:1>, axis=axis)<EOL><DEDENT>else:<EOL><INDENT>return a[slice1]-a[slice2]<EOL><DEDENT>", "docstring": "Calculate the n-th order discrete difference along given axis.\n\nThe first order difference is given by ``out[n] = a[n+1] - a[n]`` along\nthe given axis, higher order differences are calculated by using `diff`\nrecursively.\n\nParameters\n----------\na : array_like\n    Input array\nn : int, optional\n    The number of times values are differenced.\naxis : int, optional\n    The axis along which the difference is taken, default is the last axis.\n\nReturns\n-------\ndiff : ndarray\n    The `n` order differences. The shape of the output is the same as `a`\n    except along `axis` where the dimension is smaller by `n`.\n\nSee Also\n--------\ngradient, ediff1d, cumsum\n\nExamples\n--------\n>>> x = np.array([1, 2, 4, 7, 0])\n>>> np.diff(x)\narray([ 1,  2,  3, -7])\n>>> np.diff(x, n=2)\narray([  1,   1, -10])\n\n>>> x = np.array([[1, 3, 6, 10], [0, 5, 6, 8]])\n>>> np.diff(x)\narray([[2, 3, 4],\n       [5, 1, 2]])\n>>> np.diff(x, axis=0)\narray([[-1,  2,  0, -2]])", "id": "f19125:m9"}
{"signature": "def median(a, axis=None, out=None, overwrite_input=False, keepdims=False):", "body": "r, k = _ureduce(a, func=_median, axis=axis, out=out,<EOL>overwrite_input=overwrite_input)<EOL>if keepdims:<EOL><INDENT>return r.reshape(k)<EOL><DEDENT>else:<EOL><INDENT>return r<EOL><DEDENT>", "docstring": "Compute the median along the specified axis.\n\nReturns the median of the array elements.\n\nParameters\n----------\na : array_like\n    Input array or object that can be converted to an array.\naxis : int or sequence of int, optional\n    Axis along which the medians are computed. The default (axis=None)\n    is to compute the median along a flattened version of the array.\n    A sequence of axes is supported since version 1.9.0.\nout : ndarray, optional\n    Alternative output array in which to place the result. It must have\n    the same shape and buffer length as the expected output, but the\n    type (of the output) will be cast if necessary.\noverwrite_input : bool, optional\n   If True, then allow use of memory of input array (a) for\n   calculations. The input array will be modified by the call to\n   median. This will save memory when you do not need to preserve the\n   contents of the input array. Treat the input as undefined, but it\n   will probably be fully or partially sorted. Default is False. Note\n   that, if `overwrite_input` is True and the input is not already an\n   ndarray, an error will be raised.\nkeepdims : bool, optional\n    If this is set to True, the axes which are reduced are left\n    in the result as dimensions with size one. With this option,\n    the result will broadcast correctly against the original `arr`.\n\n    .. versionadded:: 1.9.0\n\n\nReturns\n-------\nmedian : ndarray\n    A new array holding the result (unless `out` is specified, in which\n    case that array is returned instead).  If the input contains\n    integers, or floats of smaller precision than 64, then the output\n    data-type is float64.  Otherwise, the output data-type is the same\n    as that of the input.\n\nSee Also\n--------\nmean, percentile\n\nNotes\n-----\nGiven a vector V of length N, the median of V is the middle value of\na sorted copy of V, ``V_sorted`` - i.e., ``V_sorted[(N-1)/2]``, when N is\nodd.  When N is even, it is the average of the two middle values of\n``V_sorted``.\n\nExamples\n--------\n>>> a = np.array([[10, 7, 4], [3, 2, 1]])\n>>> a\narray([[10,  7,  4],\n       [ 3,  2,  1]])\n>>> np.median(a)\n3.5\n>>> np.median(a, axis=0)\narray([ 6.5,  4.5,  2.5])\n>>> np.median(a, axis=1)\narray([ 7.,  2.])\n>>> m = np.median(a, axis=0)\n>>> out = np.zeros_like(m)\n>>> np.median(a, axis=0, out=m)\narray([ 6.5,  4.5,  2.5])\n>>> m\narray([ 6.5,  4.5,  2.5])\n>>> b = a.copy()\n>>> np.median(b, axis=1, overwrite_input=True)\narray([ 7.,  2.])\n>>> assert not np.all(a==b)\n>>> b = a.copy()\n>>> np.median(b, axis=None, overwrite_input=True)\n3.5\n>>> assert not np.all(a==b)", "id": "f19125:m33"}
{"signature": "def percentile(a, q, axis=None, out=None,<EOL>overwrite_input=False, interpolation='<STR_LIT>', keepdims=False):", "body": "q = array(q, dtype=np.float64, copy=True)<EOL>r, k = _ureduce(a, func=_percentile, q=q, axis=axis, out=out,<EOL>overwrite_input=overwrite_input,<EOL>interpolation=interpolation)<EOL>if keepdims:<EOL><INDENT>if q.ndim == <NUM_LIT:0>:<EOL><INDENT>return r.reshape(k)<EOL><DEDENT>else:<EOL><INDENT>return r.reshape([len(q)] + k)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return r<EOL><DEDENT>", "docstring": "Compute the qth percentile of the data along the specified axis.\n\nReturns the qth percentile of the array elements.\n\nParameters\n----------\na : array_like\n    Input array or object that can be converted to an array.\nq : float in range of [0,100] (or sequence of floats)\n    Percentile to compute which must be between 0 and 100 inclusive.\naxis : int or sequence of int, optional\n    Axis along which the percentiles are computed. The default (None)\n    is to compute the percentiles along a flattened version of the array.\n    A sequence of axes is supported since version 1.9.0.\nout : ndarray, optional\n    Alternative output array in which to place the result. It must\n    have the same shape and buffer length as the expected output,\n    but the type (of the output) will be cast if necessary.\noverwrite_input : bool, optional\n    If True, then allow use of memory of input array `a` for\n    calculations. The input array will be modified by the call to\n    percentile. This will save memory when you do not need to preserve\n    the contents of the input array. In this case you should not make\n    any assumptions about the content of the passed in array `a` after\n    this function completes -- treat it as undefined. Default is False.\n    Note that, if the `a` input is not already an array this parameter\n    will have no effect, `a` will be converted to an array internally\n    regardless of the value of this parameter.\ninterpolation : {'linear', 'lower', 'higher', 'midpoint', 'nearest'}\n    This optional parameter specifies the interpolation method to use,\n    when the desired quantile lies between two data points `i` and `j`:\n        * linear: `i + (j - i) * fraction`, where `fraction` is the\n          fractional part of the index surrounded by `i` and `j`.\n        * lower: `i`.\n        * higher: `j`.\n        * nearest: `i` or `j` whichever is nearest.\n        * midpoint: (`i` + `j`) / 2.\n\n    .. versionadded:: 1.9.0\nkeepdims : bool, optional\n    If this is set to True, the axes which are reduced are left\n    in the result as dimensions with size one. With this option,\n    the result will broadcast correctly against the original `arr`.\n\n    .. versionadded:: 1.9.0\n\nReturns\n-------\npercentile : scalar or ndarray\n    If a single percentile `q` is given and axis=None a scalar is\n    returned.  If multiple percentiles `q` are given an array holding\n    the result is returned. The results are listed in the first axis.\n    (If `out` is specified, in which case that array is returned\n    instead).  If the input contains integers, or floats of smaller\n    precision than 64, then the output data-type is float64. Otherwise,\n    the output data-type is the same as that of the input.\n\nSee Also\n--------\nmean, median\n\nNotes\n-----\nGiven a vector V of length N, the q-th percentile of V is the q-th ranked\nvalue in a sorted copy of V.  The values and distances of the two\nnearest neighbors as well as the `interpolation` parameter will\ndetermine the percentile if the normalized ranking does not match q\nexactly. This function is the same as the median if ``q=50``, the same\nas the minimum if ``q=0`` and the same as the maximum if ``q=100``.\n\nExamples\n--------\n>>> a = np.array([[10, 7, 4], [3, 2, 1]])\n>>> a\narray([[10,  7,  4],\n       [ 3,  2,  1]])\n>>> np.percentile(a, 50)\narray([ 3.5])\n>>> np.percentile(a, 50, axis=0)\narray([[ 6.5,  4.5,  2.5]])\n>>> np.percentile(a, 50, axis=1)\narray([[ 7.],\n       [ 2.]])\n\n>>> m = np.percentile(a, 50, axis=0)\n>>> out = np.zeros_like(m)\n>>> np.percentile(a, 50, axis=0, out=m)\narray([[ 6.5,  4.5,  2.5]])\n>>> m\narray([[ 6.5,  4.5,  2.5]])\n\n>>> b = a.copy()\n>>> np.percentile(b, 50, axis=1, overwrite_input=True)\narray([[ 7.],\n       [ 2.]])\n>>> assert not np.all(a==b)\n>>> b = a.copy()\n>>> np.percentile(b, 50, axis=None, overwrite_input=True)\narray([ 3.5])", "id": "f19125:m35"}
{"signature": "def delete(arr, obj, axis=None):", "body": "wrap = None<EOL>if type(arr) is not ndarray:<EOL><INDENT>try:<EOL><INDENT>wrap = arr.__array_wrap__<EOL><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>arr = asarray(arr)<EOL>ndim = arr.ndim<EOL>if axis is None:<EOL><INDENT>if ndim != <NUM_LIT:1>:<EOL><INDENT>arr = arr.ravel()<EOL><DEDENT>ndim = arr.ndim<EOL>axis = ndim - <NUM_LIT:1><EOL><DEDENT>if ndim == <NUM_LIT:0>:<EOL><INDENT>warnings.warn(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\", DeprecationWarning)<EOL>if wrap:<EOL><INDENT>return wrap(arr)<EOL><DEDENT>else:<EOL><INDENT>return arr.copy()<EOL><DEDENT><DEDENT>slobj = [slice(None)]*ndim<EOL>N = arr.shape[axis]<EOL>newshape = list(arr.shape)<EOL>if isinstance(obj, slice):<EOL><INDENT>start, stop, step = obj.indices(N)<EOL>xr = range(start, stop, step)<EOL>numtodel = len(xr)<EOL>if numtodel <= <NUM_LIT:0>:<EOL><INDENT>if wrap:<EOL><INDENT>return wrap(arr.copy())<EOL><DEDENT>else:<EOL><INDENT>return arr.copy()<EOL><DEDENT><DEDENT>if step < <NUM_LIT:0>:<EOL><INDENT>step = -step<EOL>start = xr[-<NUM_LIT:1>]<EOL>stop = xr[<NUM_LIT:0>] + <NUM_LIT:1><EOL><DEDENT>newshape[axis] -= numtodel<EOL>new = empty(newshape, arr.dtype, arr.flags.fnc)<EOL>if start == <NUM_LIT:0>:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>slobj[axis] = slice(None, start)<EOL>new[slobj] = arr[slobj]<EOL><DEDENT>if stop == N:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>slobj[axis] = slice(stop-numtodel, None)<EOL>slobj2 = [slice(None)]*ndim<EOL>slobj2[axis] = slice(stop, None)<EOL>new[slobj] = arr[slobj2]<EOL><DEDENT>if step == <NUM_LIT:1>:<EOL><INDENT>pass<EOL><DEDENT>else:  <EOL><INDENT>keep = ones(stop-start, dtype=bool)<EOL>keep[:stop-start:step] = False<EOL>slobj[axis] = slice(start, stop-numtodel)<EOL>slobj2 = [slice(None)]*ndim<EOL>slobj2[axis] = slice(start, stop)<EOL>arr = arr[slobj2]<EOL>slobj2[axis] = keep<EOL>new[slobj] = arr[slobj2]<EOL><DEDENT>if wrap:<EOL><INDENT>return wrap(new)<EOL><DEDENT>else:<EOL><INDENT>return new<EOL><DEDENT><DEDENT>_obj = obj<EOL>obj = np.asarray(obj)<EOL>if obj.dtype == bool:<EOL><INDENT>warnings.warn(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\", FutureWarning)<EOL>obj = obj.astype(intp)<EOL><DEDENT>if isinstance(_obj, (int, long, integer)):<EOL><INDENT>obj = obj.item()<EOL>if (obj < -N or obj >= N):<EOL><INDENT>raise IndexError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (obj, axis, N))<EOL><DEDENT>if (obj < <NUM_LIT:0>):<EOL><INDENT>obj += N<EOL><DEDENT>newshape[axis] -= <NUM_LIT:1><EOL>new = empty(newshape, arr.dtype, arr.flags.fnc)<EOL>slobj[axis] = slice(None, obj)<EOL>new[slobj] = arr[slobj]<EOL>slobj[axis] = slice(obj, None)<EOL>slobj2 = [slice(None)]*ndim<EOL>slobj2[axis] = slice(obj+<NUM_LIT:1>, None)<EOL>new[slobj] = arr[slobj2]<EOL><DEDENT>else:<EOL><INDENT>if obj.size == <NUM_LIT:0> and not isinstance(_obj, np.ndarray):<EOL><INDENT>obj = obj.astype(intp)<EOL><DEDENT>if not np.can_cast(obj, intp, '<STR_LIT>'):<EOL><INDENT>warnings.warn(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\", DeprecationWarning)<EOL>obj = obj.astype(intp)<EOL><DEDENT>keep = ones(N, dtype=bool)<EOL>inside_bounds = (obj < N) & (obj >= -N)<EOL>if not inside_bounds.all():<EOL><INDENT>warnings.warn(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>DeprecationWarning)<EOL>obj = obj[inside_bounds]<EOL><DEDENT>positive_indices = obj >= <NUM_LIT:0><EOL>if not positive_indices.all():<EOL><INDENT>warnings.warn(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\", FutureWarning)<EOL>obj = obj[positive_indices]<EOL><DEDENT>keep[obj, ] = False<EOL>slobj[axis] = keep<EOL>new = arr[slobj]<EOL><DEDENT>if wrap:<EOL><INDENT>return wrap(new)<EOL><DEDENT>else:<EOL><INDENT>return new<EOL><DEDENT>", "docstring": "Return a new array with sub-arrays along an axis deleted. For a one\ndimensional array, this returns those entries not returned by\n`arr[obj]`.\n\nParameters\n----------\narr : array_like\n  Input array.\nobj : slice, int or array of ints\n  Indicate which sub-arrays to remove.\naxis : int, optional\n  The axis along which to delete the subarray defined by `obj`.\n  If `axis` is None, `obj` is applied to the flattened array.\n\nReturns\n-------\nout : ndarray\n    A copy of `arr` with the elements specified by `obj` removed. Note\n    that `delete` does not occur in-place. If `axis` is None, `out` is\n    a flattened array.\n\nSee Also\n--------\ninsert : Insert elements into an array.\nappend : Append elements at the end of an array.\n\nNotes\n-----\nOften it is preferable to use a boolean mask. For example:\n\n>>> mask = np.ones(len(arr), dtype=bool)\n>>> mask[[0,2,4]] = False\n>>> result = arr[mask,...]\n\nIs equivalent to `np.delete(arr, [0,2,4], axis=0)`, but allows further\nuse of `mask`.\n\nExamples\n--------\n>>> arr = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])\n>>> arr\narray([[ 1,  2,  3,  4],\n       [ 5,  6,  7,  8],\n       [ 9, 10, 11, 12]])\n>>> np.delete(arr, 1, 0)\narray([[ 1,  2,  3,  4],\n       [ 9, 10, 11, 12]])\n\n>>> np.delete(arr, np.s_[::2], 1)\narray([[ 2,  4],\n       [ 6,  8],\n       [10, 12]])\n>>> np.delete(arr, [1,3,5], None)\narray([ 1,  3,  5,  7,  8,  9, 10, 11, 12])", "id": "f19125:m40"}
{"signature": "def interp(x, xp, fp, left=None, right=None):", "body": "if isinstance(x, (float, int, number)):<EOL><INDENT>return compiled_interp([x], xp, fp, left, right).item()<EOL><DEDENT>elif isinstance(x, np.ndarray) and x.ndim == <NUM_LIT:0>:<EOL><INDENT>return compiled_interp([x], xp, fp, left, right).item()<EOL><DEDENT>else:<EOL><INDENT>return compiled_interp(x, xp, fp, left, right)<EOL><DEDENT>", "docstring": "One-dimensional linear interpolation.\n\nReturns the one-dimensional piecewise linear interpolant to a function\nwith given values at discrete data-points.\n\nParameters\n----------\nx : array_like\n    The x-coordinates of the interpolated values.\n\nxp : 1-D sequence of floats\n    The x-coordinates of the data points, must be increasing.\n\nfp : 1-D sequence of floats\n    The y-coordinates of the data points, same length as `xp`.\n\nleft : float, optional\n    Value to return for `x < xp[0]`, default is `fp[0]`.\n\nright : float, optional\n    Value to return for `x > xp[-1]`, default is `fp[-1]`.\n\nReturns\n-------\ny : {float, ndarray}\n    The interpolated values, same shape as `x`.\n\nRaises\n------\nValueError\n    If `xp` and `fp` have different length\n\nNotes\n-----\nDoes not check that the x-coordinate sequence `xp` is increasing.\nIf `xp` is not increasing, the results are nonsense.\nA simple check for increasing is::\n\n    np.all(np.diff(xp) > 0)\n\n\nExamples\n--------\n>>> xp = [1, 2, 3]\n>>> fp = [3, 2, 0]\n>>> np.interp(2.5, xp, fp)\n1.0\n>>> np.interp([0, 1, 1.5, 2.72, 3.14], xp, fp)\narray([ 3. ,  3. ,  2.5 ,  0.56,  0. ])\n>>> UNDEF = -99.0\n>>> np.interp(3.14, xp, fp, right=UNDEF)\n-99.0\n\nPlot an interpolant to the sine function:\n\n>>> x = np.linspace(0, 2*np.pi, 10)\n>>> y = np.sin(x)\n>>> xvals = np.linspace(0, 2*np.pi, 50)\n>>> yinterp = np.interp(xvals, x, y)\n>>> import matplotlib.pyplot as plt\n>>> plt.plot(x, y, 'o')\n[<matplotlib.lines.Line2D object at 0x...>]\n>>> plt.plot(xvals, yinterp, '-x')\n[<matplotlib.lines.Line2D object at 0x...>]\n>>> plt.show()", "id": "f19125:m10"}
{"signature": "def corrcoef(x, y=None, rowvar=<NUM_LIT:1>, bias=<NUM_LIT:0>, ddof=None):", "body": "c = cov(x, y, rowvar, bias, ddof)<EOL>try:<EOL><INDENT>d = diag(c)<EOL><DEDENT>except ValueError:  <EOL><INDENT>return c / c<EOL><DEDENT>return c / sqrt(multiply.outer(d, d))<EOL>", "docstring": "Return correlation coefficients.\n\nPlease refer to the documentation for `cov` for more detail.  The\nrelationship between the correlation coefficient matrix, `P`, and the\ncovariance matrix, `C`, is\n\n.. math:: P_{ij} = \\\\frac{ C_{ij} } { \\\\sqrt{ C_{ii} * C_{jj} } }\n\nThe values of `P` are between -1 and 1, inclusive.\n\nParameters\n----------\nx : array_like\n    A 1-D or 2-D array containing multiple variables and observations.\n    Each row of `m` represents a variable, and each column a single\n    observation of all those variables. Also see `rowvar` below.\ny : array_like, optional\n    An additional set of variables and observations. `y` has the same\n    shape as `m`.\nrowvar : int, optional\n    If `rowvar` is non-zero (default), then each row represents a\n    variable, with observations in the columns. Otherwise, the relationship\n    is transposed: each column represents a variable, while the rows\n    contain observations.\nbias : int, optional\n    Default normalization is by ``(N - 1)``, where ``N`` is the number of\n    observations (unbiased estimate). If `bias` is 1, then\n    normalization is by ``N``. These values can be overridden by using\n    the keyword ``ddof`` in numpy versions >= 1.5.\nddof : {None, int}, optional\n    .. versionadded:: 1.5\n    If not ``None`` normalization is by ``(N - ddof)``, where ``N`` is\n    the number of observations; this overrides the value implied by\n    ``bias``. The default value is ``None``.\n\nReturns\n-------\nout : ndarray\n    The correlation coefficient matrix of the variables.\n\nSee Also\n--------\ncov : Covariance matrix", "id": "f19125:m20"}
{"signature": "def dsplit(ary, indices_or_sections):", "body": "if len(_nx.shape(ary)) < <NUM_LIT:3>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return split(ary, indices_or_sections, <NUM_LIT:2>)<EOL>", "docstring": "Split array into multiple sub-arrays along the 3rd axis (depth).\n\nPlease refer to the `split` documentation.  `dsplit` is equivalent\nto `split` with ``axis=2``, the array is always split along the third\naxis provided the array dimension is greater than or equal to 3.\n\nSee Also\n--------\nsplit : Split an array into multiple sub-arrays of equal size.\n\nExamples\n--------\n>>> x = np.arange(16.0).reshape(2, 2, 4)\n>>> x\narray([[[  0.,   1.,   2.,   3.],\n        [  4.,   5.,   6.,   7.]],\n       [[  8.,   9.,  10.,  11.],\n        [ 12.,  13.,  14.,  15.]]])\n>>> np.dsplit(x, 2)\n[array([[[  0.,   1.],\n        [  4.,   5.]],\n       [[  8.,   9.],\n        [ 12.,  13.]]]),\n array([[[  2.,   3.],\n        [  6.,   7.]],\n       [[ 10.,  11.],\n        [ 14.,  15.]]])]\n>>> np.dsplit(x, np.array([3, 6]))\n[array([[[  0.,   1.,   2.],\n        [  4.,   5.,   6.]],\n       [[  8.,   9.,  10.],\n        [ 12.,  13.,  14.]]]),\n array([[[  3.],\n        [  7.]],\n       [[ 11.],\n        [ 15.]]]),\n array([], dtype=float64)]", "id": "f19126:m10"}
{"signature": "def dstack(tup):", "body": "return _nx.concatenate([atleast_3d(_m) for _m in tup], <NUM_LIT:2>)<EOL>", "docstring": "Stack arrays in sequence depth wise (along third axis).\n\nTakes a sequence of arrays and stack them along the third axis\nto make a single array. Rebuilds arrays divided by `dsplit`.\nThis is a simple way to stack 2D arrays (images) into a single\n3D array for processing.\n\nParameters\n----------\ntup : sequence of arrays\n    Arrays to stack. All of them must have the same shape along all\n    but the third axis.\n\nReturns\n-------\nstacked : ndarray\n    The array formed by stacking the given arrays.\n\nSee Also\n--------\nvstack : Stack along first axis.\nhstack : Stack along second axis.\nconcatenate : Join arrays.\ndsplit : Split array along third axis.\n\nNotes\n-----\nEquivalent to ``np.concatenate(tup, axis=2)``.\n\nExamples\n--------\n>>> a = np.array((1,2,3))\n>>> b = np.array((2,3,4))\n>>> np.dstack((a,b))\narray([[[1, 2],\n        [2, 3],\n        [3, 4]]])\n\n>>> a = np.array([[1],[2],[3]])\n>>> b = np.array([[2],[3],[4]])\n>>> np.dstack((a,b))\narray([[[1, 2]],\n       [[2, 3]],\n       [[3, 4]]])", "id": "f19126:m4"}
{"signature": "def apply_along_axis(func1d, axis, arr, *args, **kwargs):", "body": "arr = asarray(arr)<EOL>nd = arr.ndim<EOL>if axis < <NUM_LIT:0>:<EOL><INDENT>axis += nd<EOL><DEDENT>if (axis >= nd):<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>% (axis, nd))<EOL><DEDENT>ind = [<NUM_LIT:0>]*(nd-<NUM_LIT:1>)<EOL>i = zeros(nd, '<STR_LIT:O>')<EOL>indlist = list(range(nd))<EOL>indlist.remove(axis)<EOL>i[axis] = slice(None, None)<EOL>outshape = asarray(arr.shape).take(indlist)<EOL>i.put(indlist, ind)<EOL>res = func1d(arr[tuple(i.tolist())], *args, **kwargs)<EOL>if isscalar(res):<EOL><INDENT>outarr = zeros(outshape, asarray(res).dtype)<EOL>outarr[tuple(ind)] = res<EOL>Ntot = product(outshape)<EOL>k = <NUM_LIT:1><EOL>while k < Ntot:<EOL><INDENT>ind[-<NUM_LIT:1>] += <NUM_LIT:1><EOL>n = -<NUM_LIT:1><EOL>while (ind[n] >= outshape[n]) and (n > (<NUM_LIT:1>-nd)):<EOL><INDENT>ind[n-<NUM_LIT:1>] += <NUM_LIT:1><EOL>ind[n] = <NUM_LIT:0><EOL>n -= <NUM_LIT:1><EOL><DEDENT>i.put(indlist, ind)<EOL>res = func1d(arr[tuple(i.tolist())], *args, **kwargs)<EOL>outarr[tuple(ind)] = res<EOL>k += <NUM_LIT:1><EOL><DEDENT>return outarr<EOL><DEDENT>else:<EOL><INDENT>Ntot = product(outshape)<EOL>holdshape = outshape<EOL>outshape = list(arr.shape)<EOL>outshape[axis] = len(res)<EOL>outarr = zeros(outshape, asarray(res).dtype)<EOL>outarr[tuple(i.tolist())] = res<EOL>k = <NUM_LIT:1><EOL>while k < Ntot:<EOL><INDENT>ind[-<NUM_LIT:1>] += <NUM_LIT:1><EOL>n = -<NUM_LIT:1><EOL>while (ind[n] >= holdshape[n]) and (n > (<NUM_LIT:1>-nd)):<EOL><INDENT>ind[n-<NUM_LIT:1>] += <NUM_LIT:1><EOL>ind[n] = <NUM_LIT:0><EOL>n -= <NUM_LIT:1><EOL><DEDENT>i.put(indlist, ind)<EOL>res = func1d(arr[tuple(i.tolist())], *args, **kwargs)<EOL>outarr[tuple(i.tolist())] = res<EOL>k += <NUM_LIT:1><EOL><DEDENT>return outarr<EOL><DEDENT>", "docstring": "Apply a function to 1-D slices along the given axis.\n\nExecute `func1d(a, *args)` where `func1d` operates on 1-D arrays and `a`\nis a 1-D slice of `arr` along `axis`.\n\nParameters\n----------\nfunc1d : function\n    This function should accept 1-D arrays. It is applied to 1-D\n    slices of `arr` along the specified axis.\naxis : integer\n    Axis along which `arr` is sliced.\narr : ndarray\n    Input array.\nargs : any\n    Additional arguments to `func1d`.\nkwargs: any\n    Additional named arguments to `func1d`.\n\n    .. versionadded:: 1.9.0\n\n\nReturns\n-------\napply_along_axis : ndarray\n    The output array. The shape of `outarr` is identical to the shape of\n    `arr`, except along the `axis` dimension, where the length of `outarr`\n    is equal to the size of the return value of `func1d`.  If `func1d`\n    returns a scalar `outarr` will have one fewer dimensions than `arr`.\n\nSee Also\n--------\napply_over_axes : Apply a function repeatedly over multiple axes.\n\nExamples\n--------\n>>> def my_func(a):\n...     \\\"\\\"\\\"Average first and last element of a 1-D array\\\"\\\"\\\"\n...     return (a[0] + a[-1]) * 0.5\n>>> b = np.array([[1,2,3], [4,5,6], [7,8,9]])\n>>> np.apply_along_axis(my_func, 0, b)\narray([ 4.,  5.,  6.])\n>>> np.apply_along_axis(my_func, 1, b)\narray([ 2.,  5.,  8.])\n\nFor a function that doesn't return a scalar, the number of dimensions in\n`outarr` is the same as `arr`.\n\n>>> b = np.array([[8,1,7], [4,3,9], [5,2,6]])\n>>> np.apply_along_axis(sorted, 1, b)\narray([[1, 7, 8],\n       [3, 4, 9],\n       [2, 5, 6]])", "id": "f19126:m0"}
{"signature": "def _lookfor_generate_cache(module, import_modules, regenerate):", "body": "global _lookfor_caches<EOL>import inspect<EOL>if sys.version_info[<NUM_LIT:0>] >= <NUM_LIT:3>:<EOL><INDENT>from io import StringIO<EOL><DEDENT>else:<EOL><INDENT>from StringIO import StringIO<EOL><DEDENT>if module is None:<EOL><INDENT>module = \"<STR_LIT>\"<EOL><DEDENT>if isinstance(module, str):<EOL><INDENT>try:<EOL><INDENT>__import__(module)<EOL><DEDENT>except ImportError:<EOL><INDENT>return {}<EOL><DEDENT>module = sys.modules[module]<EOL><DEDENT>elif isinstance(module, list) or isinstance(module, tuple):<EOL><INDENT>cache = {}<EOL>for mod in module:<EOL><INDENT>cache.update(_lookfor_generate_cache(mod, import_modules,<EOL>regenerate))<EOL><DEDENT>return cache<EOL><DEDENT>if id(module) in _lookfor_caches and not regenerate:<EOL><INDENT>return _lookfor_caches[id(module)]<EOL><DEDENT>cache = {}<EOL>_lookfor_caches[id(module)] = cache<EOL>seen = {}<EOL>index = <NUM_LIT:0><EOL>stack = [(module.__name__, module)]<EOL>while stack:<EOL><INDENT>name, item = stack.pop(<NUM_LIT:0>)<EOL>if id(item) in seen:<EOL><INDENT>continue<EOL><DEDENT>seen[id(item)] = True<EOL>index += <NUM_LIT:1><EOL>kind = \"<STR_LIT:object>\"<EOL>if inspect.ismodule(item):<EOL><INDENT>kind = \"<STR_LIT>\"<EOL>try:<EOL><INDENT>_all = item.__all__<EOL><DEDENT>except AttributeError:<EOL><INDENT>_all = None<EOL><DEDENT>if import_modules and hasattr(item, '<STR_LIT>'):<EOL><INDENT>for pth in item.__path__:<EOL><INDENT>for mod_path in os.listdir(pth):<EOL><INDENT>this_py = os.path.join(pth, mod_path)<EOL>init_py = os.path.join(pth, mod_path, '<STR_LIT>')<EOL>if (os.path.isfile(this_py) and<EOL>mod_path.endswith('<STR_LIT>')):<EOL><INDENT>to_import = mod_path[:-<NUM_LIT:3>]<EOL><DEDENT>elif os.path.isfile(init_py):<EOL><INDENT>to_import = mod_path<EOL><DEDENT>else:<EOL><INDENT>continue<EOL><DEDENT>if to_import == '<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>try:<EOL><INDENT>base_exc = BaseException<EOL><DEDENT>except NameError:<EOL><INDENT>base_exc = Exception<EOL><DEDENT>try:<EOL><INDENT>old_stdout = sys.stdout<EOL>old_stderr = sys.stderr<EOL>try:<EOL><INDENT>sys.stdout = StringIO()<EOL>sys.stderr = StringIO()<EOL>__import__(\"<STR_LIT>\" % (name, to_import))<EOL><DEDENT>finally:<EOL><INDENT>sys.stdout = old_stdout<EOL>sys.stderr = old_stderr<EOL><DEDENT><DEDENT>except base_exc:<EOL><INDENT>continue<EOL><DEDENT><DEDENT><DEDENT><DEDENT>for n, v in _getmembers(item):<EOL><INDENT>try:<EOL><INDENT>item_name = getattr(v, '<STR_LIT>', \"<STR_LIT>\" % (name, n))<EOL>mod_name = getattr(v, '<STR_LIT>', None)<EOL><DEDENT>except NameError:<EOL><INDENT>item_name = \"<STR_LIT>\" % (name, n)<EOL>mod_name = None<EOL><DEDENT>if '<STR_LIT:.>' not in item_name and mod_name:<EOL><INDENT>item_name = \"<STR_LIT>\" % (mod_name, item_name)<EOL><DEDENT>if not item_name.startswith(name + '<STR_LIT:.>'):<EOL><INDENT>if isinstance(v, ufunc):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>elif not (inspect.ismodule(v) or _all is None or n in _all):<EOL><INDENT>continue<EOL><DEDENT>stack.append((\"<STR_LIT>\" % (name, n), v))<EOL><DEDENT><DEDENT>elif inspect.isclass(item):<EOL><INDENT>kind = \"<STR_LIT:class>\"<EOL>for n, v in _getmembers(item):<EOL><INDENT>stack.append((\"<STR_LIT>\" % (name, n), v))<EOL><DEDENT><DEDENT>elif hasattr(item, \"<STR_LIT>\"):<EOL><INDENT>kind = \"<STR_LIT>\"<EOL><DEDENT>try:<EOL><INDENT>doc = inspect.getdoc(item)<EOL><DEDENT>except NameError:<EOL><INDENT>doc = None<EOL><DEDENT>if doc is not None:<EOL><INDENT>cache[name] = (doc, kind, index)<EOL><DEDENT><DEDENT>return cache<EOL>", "docstring": "Generate docstring cache for given module.\n\nParameters\n----------\nmodule : str, None, module\n    Module for which to generate docstring cache\nimport_modules : bool\n    Whether to import sub-modules in packages.\nregenerate : bool\n    Re-generate the docstring cache\n\nReturns\n-------\ncache : dict {obj_full_name: (docstring, kind, index), ...}\n    Docstring cache for the module, either cached one (regenerate=False)\n    or newly generated.", "id": "f19127:m11"}
{"signature": "def ediff1d(ary, to_end=None, to_begin=None):", "body": "ary = np.asanyarray(ary).flat<EOL>ed = ary[<NUM_LIT:1>:] - ary[:-<NUM_LIT:1>]<EOL>arrays = [ed]<EOL>if to_begin is not None:<EOL><INDENT>arrays.insert(<NUM_LIT:0>, to_begin)<EOL><DEDENT>if to_end is not None:<EOL><INDENT>arrays.append(to_end)<EOL><DEDENT>if len(arrays) != <NUM_LIT:1>:<EOL><INDENT>ed = np.hstack(arrays)<EOL><DEDENT>return ed<EOL>", "docstring": "The differences between consecutive elements of an array.\n\nParameters\n----------\nary : array_like\n    If necessary, will be flattened before the differences are taken.\nto_end : array_like, optional\n    Number(s) to append at the end of the returned differences.\nto_begin : array_like, optional\n    Number(s) to prepend at the beginning of the returned differences.\n\nReturns\n-------\nediff1d : ndarray\n    The differences. Loosely, this is ``ary.flat[1:] - ary.flat[:-1]``.\n\nSee Also\n--------\ndiff, gradient\n\nNotes\n-----\nWhen applied to masked arrays, this function drops the mask information\nif the `to_begin` and/or `to_end` parameters are used.\n\nExamples\n--------\n>>> x = np.array([1, 2, 4, 7, 0])\n>>> np.ediff1d(x)\narray([ 1,  2,  3, -7])\n\n>>> np.ediff1d(x, to_begin=-99, to_end=np.array([88, 99]))\narray([-99,   1,   2,   3,  -7,  88,  99])\n\nThe returned array is always 1D.\n\n>>> y = [[1, 2, 4], [1, 6, 24]]\n>>> np.ediff1d(y)\narray([ 1,  2, -3,  5, 18])", "id": "f19129:m0"}
{"signature": "def intersect1d(ar1, ar2, assume_unique=False):", "body": "if not assume_unique:<EOL><INDENT>ar1 = unique(ar1)<EOL>ar2 = unique(ar2)<EOL><DEDENT>aux = np.concatenate((ar1, ar2))<EOL>aux.sort()<EOL>return aux[:-<NUM_LIT:1>][aux[<NUM_LIT:1>:] == aux[:-<NUM_LIT:1>]]<EOL>", "docstring": "Find the intersection of two arrays.\n\nReturn the sorted, unique values that are in both of the input arrays.\n\nParameters\n----------\nar1, ar2 : array_like\n    Input arrays.\nassume_unique : bool\n    If True, the input arrays are both assumed to be unique, which\n    can speed up the calculation.  Default is False.\n\nReturns\n-------\nintersect1d : ndarray\n    Sorted 1D array of common and unique elements.\n\nSee Also\n--------\nnumpy.lib.arraysetops : Module with a number of other functions for\n                        performing set operations on arrays.\n\nExamples\n--------\n>>> np.intersect1d([1, 3, 4, 3], [3, 1, 2, 1])\narray([1, 3])", "id": "f19129:m2"}
{"signature": "def in1d(ar1, ar2, assume_unique=False, invert=False):", "body": "<EOL>ar1 = np.asarray(ar1).ravel()<EOL>ar2 = np.asarray(ar2).ravel()<EOL>if len(ar2) < <NUM_LIT:10> * len(ar1) ** <NUM_LIT>:<EOL><INDENT>if invert:<EOL><INDENT>mask = np.ones(len(ar1), dtype=np.bool)<EOL>for a in ar2:<EOL><INDENT>mask &= (ar1 != a)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>mask = np.zeros(len(ar1), dtype=np.bool)<EOL>for a in ar2:<EOL><INDENT>mask |= (ar1 == a)<EOL><DEDENT><DEDENT>return mask<EOL><DEDENT>if not assume_unique:<EOL><INDENT>ar1, rev_idx = np.unique(ar1, return_inverse=True)<EOL>ar2 = np.unique(ar2)<EOL><DEDENT>ar = np.concatenate((ar1, ar2))<EOL>order = ar.argsort(kind='<STR_LIT>')<EOL>sar = ar[order]<EOL>if invert:<EOL><INDENT>bool_ar = (sar[<NUM_LIT:1>:] != sar[:-<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>bool_ar = (sar[<NUM_LIT:1>:] == sar[:-<NUM_LIT:1>])<EOL><DEDENT>flag = np.concatenate((bool_ar, [invert]))<EOL>indx = order.argsort(kind='<STR_LIT>')[:len(ar1)]<EOL>if assume_unique:<EOL><INDENT>return flag[indx]<EOL><DEDENT>else:<EOL><INDENT>return flag[indx][rev_idx]<EOL><DEDENT>", "docstring": "Test whether each element of a 1-D array is also present in a second array.\n\nReturns a boolean array the same length as `ar1` that is True\nwhere an element of `ar1` is in `ar2` and False otherwise.\n\nParameters\n----------\nar1 : (M,) array_like\n    Input array.\nar2 : array_like\n    The values against which to test each value of `ar1`.\nassume_unique : bool, optional\n    If True, the input arrays are both assumed to be unique, which\n    can speed up the calculation.  Default is False.\ninvert : bool, optional\n    If True, the values in the returned array are inverted (that is,\n    False where an element of `ar1` is in `ar2` and True otherwise).\n    Default is False. ``np.in1d(a, b, invert=True)`` is equivalent\n    to (but is faster than) ``np.invert(in1d(a, b))``.\n\n    .. versionadded:: 1.8.0\n\nReturns\n-------\nin1d : (M,) ndarray, bool\n    The values `ar1[in1d]` are in `ar2`.\n\nSee Also\n--------\nnumpy.lib.arraysetops : Module with a number of other functions for\n                        performing set operations on arrays.\n\nNotes\n-----\n`in1d` can be considered as an element-wise function version of the\npython keyword `in`, for 1-D sequences. ``in1d(a, b)`` is roughly\nequivalent to ``np.array([item in b for item in a])``.\n\n.. versionadded:: 1.4.0\n\nExamples\n--------\n>>> test = np.array([0, 1, 2, 5, 0])\n>>> states = [0, 2]\n>>> mask = np.in1d(test, states)\n>>> mask\narray([ True, False,  True, False,  True], dtype=bool)\n>>> test[mask]\narray([0, 2, 0])\n>>> mask = np.in1d(test, states, invert=True)\n>>> mask\narray([False,  True, False,  True, False], dtype=bool)\n>>> test[mask]\narray([1, 5])", "id": "f19129:m4"}
{"signature": "def nanmax(a, axis=None, out=None, keepdims=False):", "body": "if not isinstance(a, np.ndarray) or type(a) is np.ndarray:<EOL><INDENT>res = np.fmax.reduce(a, axis=axis, out=out, keepdims=keepdims)<EOL>if np.isnan(res).any():<EOL><INDENT>warnings.warn(\"<STR_LIT>\", RuntimeWarning)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>a, mask = _replace_nan(a, -np.inf)<EOL>res = np.amax(a, axis=axis, out=out, keepdims=keepdims)<EOL>if mask is None:<EOL><INDENT>return res<EOL><DEDENT>mask = np.all(mask, axis=axis, keepdims=keepdims)<EOL>if np.any(mask):<EOL><INDENT>res = _copyto(res, np.nan, mask)<EOL>warnings.warn(\"<STR_LIT>\", RuntimeWarning)<EOL><DEDENT><DEDENT>return res<EOL>", "docstring": "Return the maximum of an array or maximum along an axis, ignoring any\nNaNs.  When all-NaN slices are encountered a ``RuntimeWarning`` is\nraised and NaN is returned for that slice.\n\nParameters\n----------\na : array_like\n    Array containing numbers whose maximum is desired. If `a` is not an\n    array, a conversion is attempted.\naxis : int, optional\n    Axis along which the maximum is computed. The default is to compute\n    the maximum of the flattened array.\nout : ndarray, optional\n    Alternate output array in which to place the result.  The default\n    is ``None``; if provided, it must have the same shape as the\n    expected output, but the type will be cast if necessary.  See\n    `doc.ufuncs` for details.\n\n    .. versionadded:: 1.8.0\nkeepdims : bool, optional\n    If this is set to True, the axes which are reduced are left in the\n    result as dimensions with size one. With this option, the result\n    will broadcast correctly against the original `a`.\n\n    .. versionadded:: 1.8.0\n\nReturns\n-------\nnanmax : ndarray\n    An array with the same shape as `a`, with the specified axis removed.\n    If `a` is a 0-d array, or if axis is None, an ndarray scalar is\n    returned.  The same dtype as `a` is returned.\n\nSee Also\n--------\nnanmin :\n    The minimum value of an array along a given axis, ignoring any NaNs.\namax :\n    The maximum value of an array along a given axis, propagating any NaNs.\nfmax :\n    Element-wise maximum of two arrays, ignoring any NaNs.\nmaximum :\n    Element-wise maximum of two arrays, propagating any NaNs.\nisnan :\n    Shows which elements are Not a Number (NaN).\nisfinite:\n    Shows which elements are neither NaN nor infinity.\n\namin, fmin, minimum\n\nNotes\n-----\nNumpy uses the IEEE Standard for Binary Floating-Point for Arithmetic\n(IEEE 754). This means that Not a Number is not equivalent to infinity.\nPositive infinity is treated as a very large number and negative\ninfinity is treated as a very small (i.e. negative) number.\n\nIf the input has a integer type the function is equivalent to np.max.\n\nExamples\n--------\n>>> a = np.array([[1, 2], [3, np.nan]])\n>>> np.nanmax(a)\n3.0\n>>> np.nanmax(a, axis=0)\narray([ 3.,  2.])\n>>> np.nanmax(a, axis=1)\narray([ 2.,  3.])\n\nWhen positive infinity and negative infinity are present:\n\n>>> np.nanmax([1, 2, np.nan, np.NINF])\n2.0\n>>> np.nanmax([1, 2, np.nan, np.inf])\ninf", "id": "f19130:m4"}
{"signature": "def nanvar(a, axis=None, dtype=None, out=None, ddof=<NUM_LIT:0>, keepdims=False):", "body": "arr, mask = _replace_nan(a, <NUM_LIT:0>)<EOL>if mask is None:<EOL><INDENT>return np.var(arr, axis=axis, dtype=dtype, out=out, ddof=ddof,<EOL>keepdims=keepdims)<EOL><DEDENT>if dtype is not None:<EOL><INDENT>dtype = np.dtype(dtype)<EOL><DEDENT>if dtype is not None and not issubclass(dtype.type, np.inexact):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if out is not None and not issubclass(out.dtype.type, np.inexact):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>with warnings.catch_warnings():<EOL><INDENT>warnings.simplefilter('<STR_LIT:ignore>')<EOL>cnt = np.sum(~mask, axis=axis, dtype=np.intp, keepdims=True)<EOL>avg = np.sum(arr, axis=axis, dtype=dtype, keepdims=True)<EOL>avg = _divide_by_count(avg, cnt)<EOL>arr -= avg<EOL>arr = _copyto(arr, <NUM_LIT:0>, mask)<EOL>if issubclass(arr.dtype.type, np.complexfloating):<EOL><INDENT>sqr = np.multiply(arr, arr.conj(), out=arr).real<EOL><DEDENT>else:<EOL><INDENT>sqr = np.multiply(arr, arr, out=arr)<EOL><DEDENT>var = np.sum(sqr, axis=axis, dtype=dtype, out=out, keepdims=keepdims)<EOL>if var.ndim < cnt.ndim:<EOL><INDENT>cnt = cnt.squeeze(axis)<EOL><DEDENT>dof = cnt - ddof<EOL>var = _divide_by_count(var, dof)<EOL><DEDENT>isbad = (dof <= <NUM_LIT:0>)<EOL>if np.any(isbad):<EOL><INDENT>warnings.warn(\"<STR_LIT>\", RuntimeWarning)<EOL>var = _copyto(var, np.nan, isbad)<EOL><DEDENT>return var<EOL>", "docstring": "Compute the variance along the specified axis, while ignoring NaNs.\n\nReturns the variance of the array elements, a measure of the spread of\na distribution.  The variance is computed for the flattened array by\ndefault, otherwise over the specified axis.\n\nFor all-NaN slices or slices with zero degrees of freedom, NaN is\nreturned and a `RuntimeWarning` is raised.\n\n.. versionadded:: 1.8.0\n\nParameters\n----------\na : array_like\n    Array containing numbers whose variance is desired.  If `a` is not an\n    array, a conversion is attempted.\naxis : int, optional\n    Axis along which the variance is computed.  The default is to compute\n    the variance of the flattened array.\ndtype : data-type, optional\n    Type to use in computing the variance.  For arrays of integer type\n    the default is `float32`; for arrays of float types it is the same as\n    the array type.\nout : ndarray, optional\n    Alternate output array in which to place the result.  It must have\n    the same shape as the expected output, but the type is cast if\n    necessary.\nddof : int, optional\n    \"Delta Degrees of Freedom\": the divisor used in the calculation is\n    ``N - ddof``, where ``N`` represents the number of non-NaN\n    elements. By default `ddof` is zero.\nkeepdims : bool, optional\n    If this is set to True, the axes which are reduced are left\n    in the result as dimensions with size one. With this option,\n    the result will broadcast correctly against the original `arr`.\n\nReturns\n-------\nvariance : ndarray, see dtype parameter above\n    If `out` is None, return a new array containing the variance,\n    otherwise return a reference to the output array. If ddof is >= the\n    number of non-NaN elements in a slice or the slice contains only\n    NaNs, then the result for that slice is NaN.\n\nSee Also\n--------\nstd : Standard deviation\nmean : Average\nvar : Variance while not ignoring NaNs\nnanstd, nanmean\nnumpy.doc.ufuncs : Section \"Output arguments\"\n\nNotes\n-----\nThe variance is the average of the squared deviations from the mean,\ni.e.,  ``var = mean(abs(x - x.mean())**2)``.\n\nThe mean is normally calculated as ``x.sum() / N``, where ``N = len(x)``.\nIf, however, `ddof` is specified, the divisor ``N - ddof`` is used\ninstead.  In standard statistical practice, ``ddof=1`` provides an\nunbiased estimator of the variance of a hypothetical infinite\npopulation.  ``ddof=0`` provides a maximum likelihood estimate of the\nvariance for normally distributed variables.\n\nNote that for complex numbers, the absolute value is taken before\nsquaring, so that the result is always real and nonnegative.\n\nFor floating-point input, the variance is computed using the same\nprecision the input has.  Depending on the input data, this can cause\nthe results to be inaccurate, especially for `float32` (see example\nbelow).  Specifying a higher-accuracy accumulator using the ``dtype``\nkeyword can alleviate this issue.\n\nExamples\n--------\n>>> a = np.array([[1, np.nan], [3, 4]])\n>>> np.var(a)\n1.5555555555555554\n>>> np.nanvar(a, axis=0)\narray([ 1.,  0.])\n>>> np.nanvar(a, axis=1)\narray([ 0.,  0.25])", "id": "f19130:m16"}
{"signature": "def _nanmedian_small(a, axis=None, out=None, overwrite_input=False):", "body": "a = np.ma.masked_array(a, np.isnan(a))<EOL>m = np.ma.median(a, axis=axis, overwrite_input=overwrite_input)<EOL>for i in range(np.count_nonzero(m.mask.ravel())):<EOL><INDENT>warnings.warn(\"<STR_LIT>\", RuntimeWarning)<EOL><DEDENT>if out is not None:<EOL><INDENT>out[...] = m.filled(np.nan)<EOL>return out<EOL><DEDENT>return m.filled(np.nan)<EOL>", "docstring": "sort + indexing median, faster for small medians along multiple dimensions\ndue to the high overhead of apply_along_axis\nsee nanmedian for parameter usage", "id": "f19130:m11"}
{"signature": "def _replace_nan(a, val):", "body": "is_new = not isinstance(a, np.ndarray)<EOL>if is_new:<EOL><INDENT>a = np.array(a)<EOL><DEDENT>if not issubclass(a.dtype.type, np.inexact):<EOL><INDENT>return a, None<EOL><DEDENT>if not is_new:<EOL><INDENT>a = np.array(a, subok=True)<EOL><DEDENT>mask = np.isnan(a)<EOL>np.copyto(a, val, where=mask)<EOL>return a, mask<EOL>", "docstring": "If `a` is of inexact type, make a copy of `a`, replace NaNs with\nthe `val` value, and return the copy together with a boolean mask\nmarking the locations where NaNs were present. If `a` is not of\ninexact type, do nothing and return `a` together with a mask of None.\n\nParameters\n----------\na : array-like\n    Input array.\nval : float\n    NaN values are set to val before doing the operation.\n\nReturns\n-------\ny : ndarray\n    If `a` is of inexact type, return a copy of `a` with the NaNs\n    replaced by the fill value, otherwise return `a`.\nmask: {bool, None}\n    If `a` is of inexact type, return a boolean mask marking locations of\n    NaNs, otherwise return None.", "id": "f19130:m0"}
{"signature": "def nanmin(a, axis=None, out=None, keepdims=False):", "body": "if not isinstance(a, np.ndarray) or type(a) is np.ndarray:<EOL><INDENT>res = np.fmin.reduce(a, axis=axis, out=out, keepdims=keepdims)<EOL>if np.isnan(res).any():<EOL><INDENT>warnings.warn(\"<STR_LIT>\", RuntimeWarning)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>a, mask = _replace_nan(a, +np.inf)<EOL>res = np.amin(a, axis=axis, out=out, keepdims=keepdims)<EOL>if mask is None:<EOL><INDENT>return res<EOL><DEDENT>mask = np.all(mask, axis=axis, keepdims=keepdims)<EOL>if np.any(mask):<EOL><INDENT>res = _copyto(res, np.nan, mask)<EOL>warnings.warn(\"<STR_LIT>\", RuntimeWarning)<EOL><DEDENT><DEDENT>return res<EOL>", "docstring": "Return minimum of an array or minimum along an axis, ignoring any NaNs.\nWhen all-NaN slices are encountered a ``RuntimeWarning`` is raised and\nNan is returned for that slice.\n\nParameters\n----------\na : array_like\n    Array containing numbers whose minimum is desired. If `a` is not an\n    array, a conversion is attempted.\naxis : int, optional\n    Axis along which the minimum is computed. The default is to compute\n    the minimum of the flattened array.\nout : ndarray, optional\n    Alternate output array in which to place the result.  The default\n    is ``None``; if provided, it must have the same shape as the\n    expected output, but the type will be cast if necessary.  See\n    `doc.ufuncs` for details.\n\n    .. versionadded:: 1.8.0\nkeepdims : bool, optional\n    If this is set to True, the axes which are reduced are left in the\n    result as dimensions with size one. With this option, the result\n    will broadcast correctly against the original `a`.\n\n    .. versionadded:: 1.8.0\n\nReturns\n-------\nnanmin : ndarray\n    An array with the same shape as `a`, with the specified axis\n    removed.  If `a` is a 0-d array, or if axis is None, an ndarray\n    scalar is returned.  The same dtype as `a` is returned.\n\nSee Also\n--------\nnanmax :\n    The maximum value of an array along a given axis, ignoring any NaNs.\namin :\n    The minimum value of an array along a given axis, propagating any NaNs.\nfmin :\n    Element-wise minimum of two arrays, ignoring any NaNs.\nminimum :\n    Element-wise minimum of two arrays, propagating any NaNs.\nisnan :\n    Shows which elements are Not a Number (NaN).\nisfinite:\n    Shows which elements are neither NaN nor infinity.\n\namax, fmax, maximum\n\nNotes\n-----\nNumpy uses the IEEE Standard for Binary Floating-Point for Arithmetic\n(IEEE 754). This means that Not a Number is not equivalent to infinity.\nPositive infinity is treated as a very large number and negative\ninfinity is treated as a very small (i.e. negative) number.\n\nIf the input has a integer type the function is equivalent to np.min.\n\nExamples\n--------\n>>> a = np.array([[1, 2], [3, np.nan]])\n>>> np.nanmin(a)\n1.0\n>>> np.nanmin(a, axis=0)\narray([ 1.,  2.])\n>>> np.nanmin(a, axis=1)\narray([ 1.,  3.])\n\nWhen positive infinity and negative infinity are present:\n\n>>> np.nanmin([1, 2, np.nan, np.inf])\n1.0\n>>> np.nanmin([1, 2, np.nan, np.NINF])\n-inf", "id": "f19130:m3"}
{"signature": "def mintypecode(typechars,typeset='<STR_LIT>',default='<STR_LIT:d>'):", "body": "typecodes = [(isinstance(t, str) and t) or asarray(t).dtype.char<EOL>for t in typechars]<EOL>intersection = [t for t in typecodes if t in typeset]<EOL>if not intersection:<EOL><INDENT>return default<EOL><DEDENT>if '<STR_LIT:F>' in intersection and '<STR_LIT:d>' in intersection:<EOL><INDENT>return '<STR_LIT:D>'<EOL><DEDENT>l = []<EOL>for t in intersection:<EOL><INDENT>i = _typecodes_by_elsize.index(t)<EOL>l.append((i, t))<EOL><DEDENT>l.sort()<EOL>return l[<NUM_LIT:0>][<NUM_LIT:1>]<EOL>", "docstring": "Return the character for the minimum-size type to which given types can\nbe safely cast.\n\nThe returned type character must represent the smallest size dtype such\nthat an array of the returned type can handle the data from an array of\nall types in `typechars` (or if `typechars` is an array, then its\ndtype.char).\n\nParameters\n----------\ntypechars : list of str or array_like\n    If a list of strings, each string should represent a dtype.\n    If array_like, the character representation of the array dtype is used.\ntypeset : str or list of str, optional\n    The set of characters that the returned character is chosen from.\n    The default set is 'GDFgdf'.\ndefault : str, optional\n    The default character, this is returned if none of the characters in\n    `typechars` matches a character in `typeset`.\n\nReturns\n-------\ntypechar : str\n    The character representing the minimum-size type that was found.\n\nSee Also\n--------\ndtype, sctype2char, maximum_sctype\n\nExamples\n--------\n>>> np.mintypecode(['d', 'f', 'S'])\n'd'\n>>> x = np.array([1.1, 2-3.j])\n>>> np.mintypecode(x)\n'D'\n\n>>> np.mintypecode('abceh', default='G')\n'G'", "id": "f19131:m0"}
{"signature": "def asscalar(a):", "body": "return a.item()<EOL>", "docstring": "Convert an array of size 1 to its scalar equivalent.\n\nParameters\n----------\na : ndarray\n    Input array of size 1.\n\nReturns\n-------\nout : scalar\n    Scalar representation of `a`. The output data type is the same type\n    returned by the input's `item` method.\n\nExamples\n--------\n>>> np.asscalar(np.array([24]))\n24", "id": "f19131:m11"}
{"signature": "def imag(val):", "body": "return asanyarray(val).imag<EOL>", "docstring": "Return the imaginary part of the elements of the array.\n\nParameters\n----------\nval : array_like\n    Input array.\n\nReturns\n-------\nout : ndarray\n    Output array. If `val` is real, the type of `val` is used for the\n    output.  If `val` has complex elements, the returned type is float.\n\nSee Also\n--------\nreal, angle, real_if_close\n\nExamples\n--------\n>>> a = np.array([1+2j, 3+4j, 5+6j])\n>>> a.imag\narray([ 2.,  4.,  6.])\n>>> a.imag = np.array([8, 10, 12])\n>>> a\narray([ 1. +8.j,  3.+10.j,  5.+12.j])", "id": "f19131:m3"}
{"signature": "def var(self, axis=None, dtype=None, out=None, ddof=<NUM_LIT:0>):", "body": "return N.ndarray.var(self, axis, dtype, out, ddof, keepdims=True)._collapse(axis)<EOL>", "docstring": "Returns the variance of the matrix elements, along the given axis.\n\nRefer to `numpy.var` for full documentation.\n\nSee Also\n--------\nnumpy.var\n\nNotes\n-----\nThis is the same as `ndarray.var`, except that where an `ndarray` would\nbe returned, a `matrix` object is returned instead.\n\nExamples\n--------\n>>> x = np.matrix(np.arange(12).reshape((3, 4)))\n>>> x\nmatrix([[ 0,  1,  2,  3],\n        [ 4,  5,  6,  7],\n        [ 8,  9, 10, 11]])\n>>> x.var()\n11.916666666666666\n>>> x.var(0)\nmatrix([[ 10.66666667,  10.66666667,  10.66666667,  10.66666667]])\n>>> x.var(1)\nmatrix([[ 1.25],\n        [ 1.25],\n        [ 1.25]])", "id": "f19135:c0:m17"}
{"signature": "def getT(self):", "body": "return self.transpose()<EOL>", "docstring": "Returns the transpose of the matrix.\n\nDoes *not* conjugate!  For the complex conjugate transpose, use ``.H``.\n\nParameters\n----------\nNone\n\nReturns\n-------\nret : matrix object\n    The (non-conjugated) transpose of the matrix.\n\nSee Also\n--------\ntranspose, getH\n\nExamples\n--------\n>>> m = np.matrix('[1, 2; 3, 4]')\n>>> m\nmatrix([[1, 2],\n        [3, 4]])\n>>> m.getT()\nmatrix([[1, 3],\n        [2, 4]])", "id": "f19135:c0:m29"}
{"signature": "def matrix_power(M, n):", "body": "M = asanyarray(M)<EOL>if len(M.shape) != <NUM_LIT:2> or M.shape[<NUM_LIT:0>] != M.shape[<NUM_LIT:1>]:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not issubdtype(type(n), int):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>from numpy.linalg import inv<EOL>if n==<NUM_LIT:0>:<EOL><INDENT>M = M.copy()<EOL>M[:] = identity(M.shape[<NUM_LIT:0>])<EOL>return M<EOL><DEDENT>elif n<<NUM_LIT:0>:<EOL><INDENT>M = inv(M)<EOL>n *= -<NUM_LIT:1><EOL><DEDENT>result = M<EOL>if n <= <NUM_LIT:3>:<EOL><INDENT>for _ in range(n-<NUM_LIT:1>):<EOL><INDENT>result=N.dot(result, M)<EOL><DEDENT>return result<EOL><DEDENT>beta = binary_repr(n)<EOL>Z, q, t = M, <NUM_LIT:0>, len(beta)<EOL>while beta[t-q-<NUM_LIT:1>] == '<STR_LIT:0>':<EOL><INDENT>Z = N.dot(Z, Z)<EOL>q += <NUM_LIT:1><EOL><DEDENT>result = Z<EOL>for k in range(q+<NUM_LIT:1>, t):<EOL><INDENT>Z = N.dot(Z, Z)<EOL>if beta[t-k-<NUM_LIT:1>] == '<STR_LIT:1>':<EOL><INDENT>result = N.dot(result, Z)<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Raise a square matrix to the (integer) power `n`.\n\nFor positive integers `n`, the power is computed by repeated matrix\nsquarings and matrix multiplications. If ``n == 0``, the identity matrix\nof the same shape as M is returned. If ``n < 0``, the inverse\nis computed and then raised to the ``abs(n)``.\n\nParameters\n----------\nM : ndarray or matrix object\n    Matrix to be \"powered.\"  Must be square, i.e. ``M.shape == (m, m)``,\n    with `m` a positive integer.\nn : int\n    The exponent can be any integer or long integer, positive,\n    negative, or zero.\n\nReturns\n-------\nM**n : ndarray or matrix object\n    The return value is the same shape and type as `M`;\n    if the exponent is positive or zero then the type of the\n    elements is the same as those of `M`. If the exponent is\n    negative the elements are floating-point.\n\nRaises\n------\nLinAlgError\n    If the matrix is not numerically invertible.\n\nSee Also\n--------\nmatrix\n    Provides an equivalent function as the exponentiation operator\n    (``**``, not ``^``).\n\nExamples\n--------\n>>> from numpy import linalg as LA\n>>> i = np.array([[0, 1], [-1, 0]]) # matrix equiv. of the imaginary unit\n>>> LA.matrix_power(i, 3) # should = -i\narray([[ 0, -1],\n       [ 1,  0]])\n>>> LA.matrix_power(np.matrix(i), 3) # matrix arg returns matrix\nmatrix([[ 0, -1],\n        [ 1,  0]])\n>>> LA.matrix_power(i, 0)\narray([[1, 0],\n       [0, 1]])\n>>> LA.matrix_power(i, -3) # should = 1/(-i) = i, but w/ f.p. elements\narray([[ 0.,  1.],\n       [-1.,  0.]])\n\nSomewhat more sophisticated example\n\n>>> q = np.zeros((4, 4))\n>>> q[0:2, 0:2] = -i\n>>> q[2:4, 2:4] = i\n>>> q # one of the three quarternion units not equal to 1\narray([[ 0., -1.,  0.,  0.],\n       [ 1.,  0.,  0.,  0.],\n       [ 0.,  0.,  0.,  1.],\n       [ 0.,  0., -1.,  0.]])\n>>> LA.matrix_power(q, 2) # = -np.eye(4)\narray([[-1.,  0.,  0.,  0.],\n       [ 0., -1.,  0.,  0.],\n       [ 0.,  0., -1.,  0.],\n       [ 0.,  0.,  0., -1.]])", "id": "f19135:m2"}
{"signature": "def getA(self):", "body": "return self.__array__()<EOL>", "docstring": "Return `self` as an `ndarray` object.\n\nEquivalent to ``np.asarray(self)``.\n\nParameters\n----------\nNone\n\nReturns\n-------\nret : ndarray\n    `self` as an `ndarray`\n\nExamples\n--------\n>>> x = np.matrix(np.arange(12).reshape((3,4))); x\nmatrix([[ 0,  1,  2,  3],\n        [ 4,  5,  6,  7],\n        [ 8,  9, 10, 11]])\n>>> x.getA()\narray([[ 0,  1,  2,  3],\n       [ 4,  5,  6,  7],\n       [ 8,  9, 10, 11]])", "id": "f19135:c0:m27"}
{"signature": "def mean(self, axis=None, dtype=None, out=None):", "body": "return N.ndarray.mean(self, axis, dtype, out, keepdims=True)._collapse(axis)<EOL>", "docstring": "Returns the average of the matrix elements along the given axis.\n\nRefer to `numpy.mean` for full documentation.\n\nSee Also\n--------\nnumpy.mean\n\nNotes\n-----\nSame as `ndarray.mean` except that, where that returns an `ndarray`,\nthis returns a `matrix` object.\n\nExamples\n--------\n>>> x = np.matrix(np.arange(12).reshape((3, 4)))\n>>> x\nmatrix([[ 0,  1,  2,  3],\n        [ 4,  5,  6,  7],\n        [ 8,  9, 10, 11]])\n>>> x.mean()\n5.5\n>>> x.mean(0)\nmatrix([[ 4.,  5.,  6.,  7.]])\n>>> x.mean(1)\nmatrix([[ 1.5],\n        [ 5.5],\n        [ 9.5]])", "id": "f19135:c0:m15"}
{"signature": "def _align(self, axis):", "body": "if axis is None:<EOL><INDENT>return self[<NUM_LIT:0>, <NUM_LIT:0>]<EOL><DEDENT>elif axis==<NUM_LIT:0>:<EOL><INDENT>return self<EOL><DEDENT>elif axis==<NUM_LIT:1>:<EOL><INDENT>return self.transpose()<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "A convenience function for operations that need to preserve axis\n        orientation.", "id": "f19135:c0:m11"}
{"signature": "def sum(self, axis=None, dtype=None, out=None):", "body": "return N.ndarray.sum(self, axis, dtype, out, keepdims=True)._collapse(axis)<EOL>", "docstring": "Returns the sum of the matrix elements, along the given axis.\n\nRefer to `numpy.sum` for full documentation.\n\nSee Also\n--------\nnumpy.sum\n\nNotes\n-----\nThis is the same as `ndarray.sum`, except that where an `ndarray` would\nbe returned, a `matrix` object is returned instead.\n\nExamples\n--------\n>>> x = np.matrix([[1, 2], [4, 3]])\n>>> x.sum()\n10\n>>> x.sum(axis=1)\nmatrix([[3],\n        [7]])\n>>> x.sum(axis=1, dtype='float')\nmatrix([[ 3.],\n        [ 7.]])\n>>> out = np.zeros((1, 2), dtype='float')\n>>> x.sum(axis=1, dtype='float', out=out)\nmatrix([[ 3.],\n        [ 7.]])", "id": "f19135:c0:m14"}
{"signature": "def bmat(obj, ldict=None, gdict=None):", "body": "if isinstance(obj, str):<EOL><INDENT>if gdict is None:<EOL><INDENT>frame = sys._getframe().f_back<EOL>glob_dict = frame.f_globals<EOL>loc_dict = frame.f_locals<EOL><DEDENT>else:<EOL><INDENT>glob_dict = gdict<EOL>loc_dict = ldict<EOL><DEDENT>return matrix(_from_string(obj, glob_dict, loc_dict))<EOL><DEDENT>if isinstance(obj, (tuple, list)):<EOL><INDENT>arr_rows = []<EOL>for row in obj:<EOL><INDENT>if isinstance(row, N.ndarray):  <EOL><INDENT>return matrix(concatenate(obj, axis=-<NUM_LIT:1>))<EOL><DEDENT>else:<EOL><INDENT>arr_rows.append(concatenate(row, axis=-<NUM_LIT:1>))<EOL><DEDENT><DEDENT>return matrix(concatenate(arr_rows, axis=<NUM_LIT:0>))<EOL><DEDENT>if isinstance(obj, N.ndarray):<EOL><INDENT>return matrix(obj)<EOL><DEDENT>", "docstring": "Build a matrix object from a string, nested sequence, or array.\n\nParameters\n----------\nobj : str or array_like\n    Input data.  Names of variables in the current scope may be\n    referenced, even if `obj` is a string.\n\nReturns\n-------\nout : matrix\n    Returns a matrix object, which is a specialized 2-D array.\n\nSee Also\n--------\nmatrix\n\nExamples\n--------\n>>> A = np.mat('1 1; 1 1')\n>>> B = np.mat('2 2; 2 2')\n>>> C = np.mat('3 4; 5 6')\n>>> D = np.mat('7 8; 9 0')\n\nAll the following expressions construct the same block matrix:\n\n>>> np.bmat([[A, B], [C, D]])\nmatrix([[1, 1, 2, 2],\n        [1, 1, 2, 2],\n        [3, 4, 7, 8],\n        [5, 6, 9, 0]])\n>>> np.bmat(np.r_[np.c_[A, B], np.c_[C, D]])\nmatrix([[1, 1, 2, 2],\n        [1, 1, 2, 2],\n        [3, 4, 7, 8],\n        [5, 6, 9, 0]])\n>>> np.bmat('A,B; C,D')\nmatrix([[1, 1, 2, 2],\n        [1, 1, 2, 2],\n        [3, 4, 7, 8],\n        [5, 6, 9, 0]])", "id": "f19135:m4"}
{"signature": "def variables(self):", "body": "return list(self._raw_data.keys())<EOL>", "docstring": "Return the list of variable names.\n\nParameters\n----------\nNone\n\nReturns\n-------\nnames : list of str\n    The names of all variables in the `VariableSet` instance.", "id": "f19160:c3:m4"}
{"signature": "def CCompiler_object_filenames(self, source_filenames, strip_dir=<NUM_LIT:0>, output_dir='<STR_LIT>'):", "body": "if output_dir is None:<EOL><INDENT>output_dir = '<STR_LIT>'<EOL><DEDENT>obj_names = []<EOL>for src_name in source_filenames:<EOL><INDENT>base, ext = os.path.splitext(os.path.normpath(src_name))<EOL>base = os.path.splitdrive(base)[<NUM_LIT:1>] <EOL>base = base[os.path.isabs(base):]  <EOL>if base.startswith('<STR_LIT:..>'):<EOL><INDENT>i = base.rfind('<STR_LIT:..>')+<NUM_LIT:2><EOL>d = base[:i]<EOL>d = os.path.basename(os.path.abspath(d))<EOL>base = d + base[i:]<EOL><DEDENT>if ext not in self.src_extensions:<EOL><INDENT>raise UnknownFileError(\"<STR_LIT>\" % (ext, src_name))<EOL><DEDENT>if strip_dir:<EOL><INDENT>base = os.path.basename(base)<EOL><DEDENT>obj_name = os.path.join(output_dir, base + self.obj_extension)<EOL>obj_names.append(obj_name)<EOL><DEDENT>return obj_names<EOL>", "docstring": "Return the name of the object files for the given source files.\n\nParameters\n----------\nsource_filenames : list of str\n    The list of paths to source files. Paths can be either relative or\n    absolute, this is handled transparently.\nstrip_dir : bool, optional\n    Whether to strip the directory from the returned paths. If True,\n    the file name prepended by `output_dir` is returned. Default is False.\noutput_dir : str, optional\n    If given, this path is prepended to the returned paths to the\n    object files.\n\nReturns\n-------\nobj_names : list of str\n    The list of paths to the object files corresponding to the source\n    files in `source_filenames`.", "id": "f19163:m2"}
{"signature": "def CCompiler_get_version(self, force=False, ok_status=[<NUM_LIT:0>]):", "body": "if not force and hasattr(self, '<STR_LIT:version>'):<EOL><INDENT>return self.version<EOL><DEDENT>self.find_executables()<EOL>try:<EOL><INDENT>version_cmd = self.version_cmd<EOL><DEDENT>except AttributeError:<EOL><INDENT>return None<EOL><DEDENT>if not version_cmd or not version_cmd[<NUM_LIT:0>]:<EOL><INDENT>return None<EOL><DEDENT>try:<EOL><INDENT>matcher = self.version_match<EOL><DEDENT>except AttributeError:<EOL><INDENT>try:<EOL><INDENT>pat = self.version_pattern<EOL><DEDENT>except AttributeError:<EOL><INDENT>return None<EOL><DEDENT>def matcher(version_string):<EOL><INDENT>m = re.match(pat, version_string)<EOL>if not m:<EOL><INDENT>return None<EOL><DEDENT>version = m.group('<STR_LIT:version>')<EOL>return version<EOL><DEDENT><DEDENT>status, output = exec_command(version_cmd, use_tee=<NUM_LIT:0>)<EOL>version = None<EOL>if status in ok_status:<EOL><INDENT>version = matcher(output)<EOL>if version:<EOL><INDENT>version = LooseVersion(version)<EOL><DEDENT><DEDENT>self.version = version<EOL>return version<EOL>", "docstring": "Return compiler version, or None if compiler is not available.\n\nParameters\n----------\nforce : bool, optional\n    If True, force a new determination of the version, even if the\n    compiler already has a version attribute. Default is False.\nok_status : list of int, optional\n    The list of status values returned by the version look-up process\n    for which a version string is returned. If the status value is not\n    in `ok_status`, None is returned. Default is ``[0]``.\n\nReturns\n-------\nversion : str or None\n    Version string, in the format of `distutils.version.LooseVersion`.", "id": "f19163:m9"}
{"signature": "def CCompiler_customize_cmd(self, cmd, ignore=()):", "body": "log.info('<STR_LIT>' % (self.__class__.__name__,<EOL>cmd.__class__.__name__))<EOL>def allow(attr):<EOL><INDENT>return getattr(cmd, attr, None) is not None and attr not in ignore<EOL><DEDENT>if allow('<STR_LIT>'):<EOL><INDENT>self.set_include_dirs(cmd.include_dirs)<EOL><DEDENT>if allow('<STR_LIT>'):<EOL><INDENT>for (name, value) in cmd.define:<EOL><INDENT>self.define_macro(name, value)<EOL><DEDENT><DEDENT>if allow('<STR_LIT>'):<EOL><INDENT>for macro in cmd.undef:<EOL><INDENT>self.undefine_macro(macro)<EOL><DEDENT><DEDENT>if allow('<STR_LIT>'):<EOL><INDENT>self.set_libraries(self.libraries + cmd.libraries)<EOL><DEDENT>if allow('<STR_LIT>'):<EOL><INDENT>self.set_library_dirs(self.library_dirs + cmd.library_dirs)<EOL><DEDENT>if allow('<STR_LIT>'):<EOL><INDENT>self.set_runtime_library_dirs(cmd.rpath)<EOL><DEDENT>if allow('<STR_LIT>'):<EOL><INDENT>self.set_link_objects(cmd.link_objects)<EOL><DEDENT>", "docstring": "Customize compiler using distutils command.\n\nParameters\n----------\ncmd : class instance\n    An instance inheriting from `distutils.cmd.Command`.\nignore : sequence of str, optional\n    List of `CCompiler` commands (without ``'set_'``) that should not be\n    altered. Strings that are checked for are:\n    ``('include_dirs', 'define', 'undef', 'libraries', 'library_dirs',\n    'rpath', 'link_objects')``.\n\nReturns\n-------\nNone", "id": "f19163:m4"}
{"signature": "def CCompiler_cxx_compiler(self):", "body": "if self.compiler_type=='<STR_LIT>': return self<EOL>cxx = copy(self)<EOL>cxx.compiler_so = [cxx.compiler_cxx[<NUM_LIT:0>]] + cxx.compiler_so[<NUM_LIT:1>:]<EOL>if sys.platform.startswith('<STR_LIT>') and '<STR_LIT>' in cxx.linker_so[<NUM_LIT:0>]:<EOL><INDENT>cxx.linker_so = [cxx.linker_so[<NUM_LIT:0>], cxx.compiler_cxx[<NUM_LIT:0>]]+ cxx.linker_so[<NUM_LIT:2>:]<EOL><DEDENT>else:<EOL><INDENT>cxx.linker_so = [cxx.compiler_cxx[<NUM_LIT:0>]] + cxx.linker_so[<NUM_LIT:1>:]<EOL><DEDENT>return cxx<EOL>", "docstring": "Return the C++ compiler.\n\nParameters\n----------\nNone\n\nReturns\n-------\ncxx : class instance\n    The C++ compiler, as a `CCompiler` instance.", "id": "f19163:m10"}
{"signature": "def simple_version_match(pat=r'<STR_LIT>', ignore='<STR_LIT>', start='<STR_LIT>'):", "body": "def matcher(self, version_string):<EOL><INDENT>version_string = version_string.replace('<STR_LIT:\\n>', '<STR_LIT:U+0020>')<EOL>pos = <NUM_LIT:0><EOL>if start:<EOL><INDENT>m = re.match(start, version_string)<EOL>if not m:<EOL><INDENT>return None<EOL><DEDENT>pos = m.end()<EOL><DEDENT>while True:<EOL><INDENT>m = re.search(pat, version_string[pos:])<EOL>if not m:<EOL><INDENT>return None<EOL><DEDENT>if ignore and re.match(ignore, m.group(<NUM_LIT:0>)):<EOL><INDENT>pos = m.end()<EOL>continue<EOL><DEDENT>break<EOL><DEDENT>return m.group(<NUM_LIT:0>)<EOL><DEDENT>return matcher<EOL>", "docstring": "Simple matching of version numbers, for use in CCompiler and FCompiler.\n\nParameters\n----------\npat : str, optional\n    A regular expression matching version numbers.\n    Default is ``r'[-.\\\\d]+'``.\nignore : str, optional\n    A regular expression matching patterns to skip.\n    Default is ``''``, in which case nothing is skipped.\nstart : str, optional\n    A regular expression matching the start of where to start looking\n    for version numbers.\n    Default is ``''``, in which case searching is started at the\n    beginning of the version string given to `matcher`.\n\nReturns\n-------\nmatcher : callable\n    A function that is appropriate to use as the ``.version_match``\n    attribute of a `CCompiler` class. `matcher` takes a single parameter,\n    a version string.", "id": "f19163:m8"}
{"signature": "def good(self, msg, *args):", "body": "if WARN >= self.threshold:<EOL><INDENT>if args:<EOL><INDENT>print(green_text(msg % _fix_args(args)))<EOL><DEDENT>else:<EOL><INDENT>print(green_text(msg))<EOL><DEDENT>sys.stdout.flush()<EOL><DEDENT>", "docstring": "If we log WARN messages, log this message as a 'nice' anti-warn\nmessage.", "id": "f19167:c0:m1"}
{"signature": "def get_f77flags(src):", "body": "flags = {}<EOL>f = open_latin1(src, '<STR_LIT:r>')<EOL>i = <NUM_LIT:0><EOL>for line in f:<EOL><INDENT>i += <NUM_LIT:1><EOL>if i><NUM_LIT:20>: break<EOL>m = _f77flags_re.match(line)<EOL>if not m: continue<EOL>fcname = m.group('<STR_LIT>').strip()<EOL>fflags = m.group('<STR_LIT>').strip()<EOL>flags[fcname] = split_quoted(fflags)<EOL><DEDENT>f.close()<EOL>return flags<EOL>", "docstring": "Search the first 20 lines of fortran 77 code for line pattern\n  `CF77FLAGS(<fcompiler type>)=<f77 flags>`\nReturn a dictionary {<fcompiler type>:<f77 flags>}.", "id": "f19175:m12"}
{"signature": "def get_flags_f77(self):", "body": "return self._get_command_flags('<STR_LIT>')<EOL>", "docstring": "List of Fortran 77 specific flags.", "id": "f19175:c1:m11"}
{"signature": "def update_executables(elf):", "body": "pass<EOL>", "docstring": "Called at the beginning of customisation. Subclasses should\n        override this if they need to set up the executables dictionary.\n\n        Note that self.find_executables() is run afterwards, so the\n        self.executables dictionary values can contain <F77> or <F90> as\n        the command, which will be replaced by the found F77 or F90\n        compiler.", "id": "f19175:c1:m8"}
{"signature": "def get_default_fcompiler(osname=None, platform=None, requiref90=False,<EOL>c_compiler=None):", "body": "matching_compiler_types = available_fcompilers_for_platform(osname,<EOL>platform)<EOL>compiler_type =  _find_existing_fcompiler(matching_compiler_types,<EOL>osname=osname,<EOL>platform=platform,<EOL>requiref90=requiref90,<EOL>c_compiler=c_compiler)<EOL>return compiler_type<EOL>", "docstring": "Determine the default Fortran compiler to use for the given\n    platform.", "id": "f19175:m6"}
{"signature": "def find_executables(self):", "body": "assert self._is_customised<EOL>exe_cache = self._exe_cache<EOL>def cached_find_executable(exe):<EOL><INDENT>if exe in exe_cache:<EOL><INDENT>return exe_cache[exe]<EOL><DEDENT>fc_exe = find_executable(exe)<EOL>exe_cache[exe] = exe_cache[fc_exe] = fc_exe<EOL>return fc_exe<EOL><DEDENT>def verify_command_form(name, value):<EOL><INDENT>if value is not None and not is_sequence_of_strings(value):<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\" %<EOL>(name, value, self.__class__.__name__))<EOL><DEDENT><DEDENT>def set_exe(exe_key, f77=None, f90=None):<EOL><INDENT>cmd = self.executables.get(exe_key, None)<EOL>if not cmd:<EOL><INDENT>return None<EOL><DEDENT>exe_from_environ = getattr(self.command_vars, exe_key)<EOL>if not exe_from_environ:<EOL><INDENT>possibles = [f90, f77] + self.possible_executables<EOL><DEDENT>else:<EOL><INDENT>possibles = [exe_from_environ] + self.possible_executables<EOL><DEDENT>seen = set()<EOL>unique_possibles = []<EOL>for e in possibles:<EOL><INDENT>if e == '<STR_LIT>':<EOL><INDENT>e = f77<EOL><DEDENT>elif e == '<STR_LIT>':<EOL><INDENT>e = f90<EOL><DEDENT>if not e or e in seen:<EOL><INDENT>continue<EOL><DEDENT>seen.add(e)<EOL>unique_possibles.append(e)<EOL><DEDENT>for exe in unique_possibles:<EOL><INDENT>fc_exe = cached_find_executable(exe)<EOL>if fc_exe:<EOL><INDENT>cmd[<NUM_LIT:0>] = fc_exe<EOL>return fc_exe<EOL><DEDENT><DEDENT>self.set_command(exe_key, None)<EOL>return None<EOL><DEDENT>ctype = self.compiler_type<EOL>f90 = set_exe('<STR_LIT>')<EOL>if not f90:<EOL><INDENT>f77 = set_exe('<STR_LIT>')<EOL>if f77:<EOL><INDENT>log.warn('<STR_LIT>' % ctype)<EOL><DEDENT>else:<EOL><INDENT>raise CompilerNotFound('<STR_LIT>' % ctype)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>f77 = set_exe('<STR_LIT>', f90=f90)<EOL>if not f77:<EOL><INDENT>log.warn('<STR_LIT>' % ctype)<EOL><DEDENT>set_exe('<STR_LIT>', f90=f90)<EOL><DEDENT>set_exe('<STR_LIT>', f77=f77, f90=f90)<EOL>set_exe('<STR_LIT>', f77=f77, f90=f90)<EOL>set_exe('<STR_LIT>', f77=f77, f90=f90)<EOL>set_exe('<STR_LIT>')<EOL>set_exe('<STR_LIT>')<EOL>", "docstring": "Go through the self.executables dictionary, and attempt to\n        find and assign appropiate executables.\n\n        Executable names are looked for in the environment (environment\n        variables, the distutils.cfg, and command line), the 0th-element of\n        the command list, and the self.possible_executables list.\n\n        Also, if the 0th element is \"<F77>\" or \"<F90>\", the Fortran 77\n        or the Fortran 90 compiler executable is used, unless overridden\n        by an environment setting.\n\n        Subclasses should call this if overriden.", "id": "f19175:c1:m7"}
{"signature": "def check_libs2(self, lib_dirs, libs, opt_libs=[]):", "body": "exts = self.library_extensions()<EOL>info = self._check_libs(lib_dirs, libs, opt_libs, exts)<EOL>if not info:<EOL><INDENT>log.info('<STR_LIT>', '<STR_LIT:U+002C>'.join(libs),<EOL>lib_dirs)<EOL><DEDENT>return info<EOL>", "docstring": "If static or shared libraries are available then return\n        their info dictionary.\n\n        Checks each library for shared or static.", "id": "f19185:c11:m14"}
{"signature": "def get_info(self, notfound_action=<NUM_LIT:0>):", "body": "flag = <NUM_LIT:0><EOL>if not self.has_info():<EOL><INDENT>flag = <NUM_LIT:1><EOL>log.info(self.__class__.__name__ + '<STR_LIT::>')<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self.calc_info()<EOL><DEDENT>if notfound_action:<EOL><INDENT>if not self.has_info():<EOL><INDENT>if notfound_action == <NUM_LIT:1>:<EOL><INDENT>warnings.warn(self.notfounderror.__doc__)<EOL><DEDENT>elif notfound_action == <NUM_LIT:2>:<EOL><INDENT>raise self.notfounderror(self.notfounderror.__doc__)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(repr(notfound_action))<EOL><DEDENT><DEDENT><DEDENT>if not self.has_info():<EOL><INDENT>log.info('<STR_LIT>')<EOL>self.set_info()<EOL><DEDENT>else:<EOL><INDENT>log.info('<STR_LIT>')<EOL><DEDENT><DEDENT>res = self.saved_results.get(self.__class__.__name__)<EOL>if self.verbosity > <NUM_LIT:0> and flag:<EOL><INDENT>for k, v in res.items():<EOL><INDENT>v = str(v)<EOL>if k in ['<STR_LIT>', '<STR_LIT>'] and len(v) > <NUM_LIT>:<EOL><INDENT>v = v[:<NUM_LIT>] + '<STR_LIT>' + v[-<NUM_LIT>:]<EOL><DEDENT>log.info('<STR_LIT>', k, v)<EOL><DEDENT>log.info('<STR_LIT>')<EOL><DEDENT>return copy.deepcopy(res)<EOL>", "docstring": "Return a dictonary with items that are compatible\n            with numpy.distutils.setup keyword arguments.", "id": "f19185:c11:m5"}
{"signature": "def combine_paths(*args, **kws):", "body": "r = []<EOL>for a in args:<EOL><INDENT>if not a:<EOL><INDENT>continue<EOL><DEDENT>if is_string(a):<EOL><INDENT>a = [a]<EOL><DEDENT>r.append(a)<EOL><DEDENT>args = r<EOL>if not args:<EOL><INDENT>return []<EOL><DEDENT>if len(args) == <NUM_LIT:1>:<EOL><INDENT>result = reduce(lambda a, b: a + b, map(glob, args[<NUM_LIT:0>]), [])<EOL><DEDENT>elif len(args) == <NUM_LIT:2>:<EOL><INDENT>result = []<EOL>for a0 in args[<NUM_LIT:0>]:<EOL><INDENT>for a1 in args[<NUM_LIT:1>]:<EOL><INDENT>result.extend(glob(os.path.join(a0, a1)))<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>result = combine_paths(*(combine_paths(args[<NUM_LIT:0>], args[<NUM_LIT:1>]) + args[<NUM_LIT:2>:]))<EOL><DEDENT>verbosity = kws.get('<STR_LIT>', <NUM_LIT:1>)<EOL>log.debug('<STR_LIT>', '<STR_LIT:U+002C>'.join(result))<EOL>return result<EOL>", "docstring": "Return a list of existing paths composed by all combinations of\n        items from arguments.", "id": "f19185:m4"}
{"signature": "def check_compiler_gcc4(self):", "body": "return check_compiler_gcc4(self)<EOL>", "docstring": "Return True if the C compiler is gcc >= 4.", "id": "f19190:c0:m14"}
{"signature": "def check_inline(self):", "body": "return check_inline(self)<EOL>", "docstring": "Return the inline keyword recognized by the compiler, empty string\n        otherwise.", "id": "f19190:c0:m13"}
{"signature": "def subst_vars(target, source, d):", "body": "var = re.compile('<STR_LIT>')<EOL>fs = open(source, '<STR_LIT:r>')<EOL>try:<EOL><INDENT>ft = open(target, '<STR_LIT:w>')<EOL>try:<EOL><INDENT>for l in fs:<EOL><INDENT>m = var.search(l)<EOL>if m:<EOL><INDENT>ft.write(l.replace('<STR_LIT>' % m.group(<NUM_LIT:1>), d[m.group(<NUM_LIT:1>)]))<EOL><DEDENT>else:<EOL><INDENT>ft.write(l)<EOL><DEDENT><DEDENT><DEDENT>finally:<EOL><INDENT>ft.close()<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>fs.close()<EOL><DEDENT>", "docstring": "Substitute any occurence of @foo@ by d['foo'] from source file into\n    target.", "id": "f19200:m1"}
{"signature": "def _build_import_library_x86():", "body": "lib_name = \"<STR_LIT>\" % tuple(sys.version_info[:<NUM_LIT:2>])<EOL>lib_file = os.path.join(sys.prefix, '<STR_LIT>', lib_name)<EOL>out_name = \"<STR_LIT>\" % tuple(sys.version_info[:<NUM_LIT:2>])<EOL>out_file = os.path.join(sys.prefix, '<STR_LIT>', out_name)<EOL>if not os.path.isfile(lib_file):<EOL><INDENT>log.warn('<STR_LIT>' % (lib_file))<EOL>return<EOL><DEDENT>if os.path.isfile(out_file):<EOL><INDENT>log.debug('<STR_LIT>' % (out_file))<EOL>return<EOL><DEDENT>log.info('<STR_LIT>' % (out_file))<EOL>from numpy.distutils import lib2def<EOL>def_name = \"<STR_LIT>\" % tuple(sys.version_info[:<NUM_LIT:2>])<EOL>def_file = os.path.join(sys.prefix, '<STR_LIT>', def_name)<EOL>nm_cmd = '<STR_LIT>' % (lib2def.DEFAULT_NM, lib_file)<EOL>nm_output = lib2def.getnm(nm_cmd)<EOL>dlist, flist = lib2def.parse_nm(nm_output)<EOL>lib2def.output_def(dlist, flist, lib2def.DEF_HEADER, open(def_file, '<STR_LIT:w>'))<EOL>dll_name = \"<STR_LIT>\" % tuple(sys.version_info[:<NUM_LIT:2>])<EOL>args = (dll_name, def_file, out_file)<EOL>cmd = '<STR_LIT>' % args<EOL>status = os.system(cmd)<EOL>if status:<EOL><INDENT>log.warn('<STR_LIT>')<EOL><DEDENT>return<EOL>", "docstring": "Build the import libraries for Mingw32-gcc on Windows", "id": "f19209:m7"}
{"signature": "def _command_line_ok(_cache=[]):", "body": "if _cache:<EOL><INDENT>return _cache[<NUM_LIT:0>]<EOL><DEDENT>ok = True<EOL>display_opts = ['<STR_LIT>'+n for n in Distribution.display_option_names]<EOL>for o in Distribution.display_options:<EOL><INDENT>if o[<NUM_LIT:1>]:<EOL><INDENT>display_opts.append('<STR_LIT:->'+o[<NUM_LIT:1>])<EOL><DEDENT><DEDENT>for arg in sys.argv:<EOL><INDENT>if arg.startswith('<STR_LIT>') or arg=='<STR_LIT>' or arg in display_opts:<EOL><INDENT>ok = False<EOL>break<EOL><DEDENT><DEDENT>_cache.append(ok)<EOL>return ok<EOL>", "docstring": "Return True if command line does not contain any\n    help or display requests.", "id": "f19210:m1"}
{"signature": "def get_info(pkgname, dirs=None):", "body": "from numpy.distutils.npy_pkg_config import parse_flags<EOL>pkg_info = get_pkg_info(pkgname, dirs)<EOL>info = parse_flags(pkg_info.cflags())<EOL>for k, v in parse_flags(pkg_info.libs()).items():<EOL><INDENT>info[k].extend(v)<EOL><DEDENT>info['<STR_LIT>'] = info['<STR_LIT>']<EOL>del info['<STR_LIT>']<EOL>del info['<STR_LIT>']<EOL>return info<EOL>", "docstring": "Return an info dict for a given C library.\n\nThe info dict contains the necessary options to use the C library.\n\nParameters\n----------\npkgname : str\n    Name of the package (should match the name of the .ini file, without\n    the extension, e.g. foo for the file foo.ini).\ndirs : sequence, optional\n    If given, should be a sequence of additional directories where to look\n    for npy-pkg-config files. Those directories are searched prior to the\n    NumPy directory.\n\nReturns\n-------\ninfo : dict\n    The dictionary with build information.\n\nRaises\n------\nPkgNotFound\n    If the package is not found.\n\nSee Also\n--------\nConfiguration.add_npy_pkg_config, Configuration.add_installed_library,\nget_pkg_info\n\nExamples\n--------\nTo get the necessary information for the npymath library from NumPy:\n\n>>> npymath_info = np.distutils.misc_util.get_info('npymath')\n>>> npymath_info                                    #doctest: +SKIP\n{'define_macros': [], 'libraries': ['npymath'], 'library_dirs':\n['.../numpy/core/lib'], 'include_dirs': ['.../numpy/core/include']}\n\nThis info dict can then be used as input to a `Configuration` instance::\n\n  config.add_extension('foo', sources=['foo.c'], extra_info=npymath_info)", "id": "f19212:m48"}
{"signature": "def make_svn_version_py(self, delete=True):", "body": "target = njoin(self.local_path, '<STR_LIT>')<EOL>revision = self._get_svn_revision(self.local_path)<EOL>if os.path.isfile(target) or revision is None:<EOL><INDENT>return<EOL><DEDENT>else:<EOL><INDENT>def generate_svn_version_py():<EOL><INDENT>if not os.path.isfile(target):<EOL><INDENT>version = str(revision)<EOL>self.info('<STR_LIT>' % (target, version))<EOL>f = open(target, '<STR_LIT:w>')<EOL>f.write('<STR_LIT>' % (version))<EOL>f.close()<EOL><DEDENT>import atexit<EOL>def rm_file(f=target,p=self.info):<EOL><INDENT>if delete:<EOL><INDENT>try: os.remove(f); p('<STR_LIT>'+f)<EOL>except OSError: pass<EOL>try: os.remove(f+'<STR_LIT:c>'); p('<STR_LIT>'+f+'<STR_LIT:c>')<EOL>except OSError: pass<EOL><DEDENT><DEDENT>atexit.register(rm_file)<EOL>return target<EOL><DEDENT>self.add_data_files(('<STR_LIT>', generate_svn_version_py()))<EOL><DEDENT>", "docstring": "Appends a data function to the data_files list that will generate\n        __svn_version__.py file to the current package directory.\n\n        Generate package __svn_version__.py file from SVN revision number,\n        it will be removed after python exits but will be available\n        when sdist, etc commands are executed.\n\n        Notes\n        -----\n        If __svn_version__.py existed before, nothing is done.\n\n        This is\n        intended for working with source directories that are in an SVN\n        repository.", "id": "f19212:c1:m34"}
{"signature": "def mingw32():", "body": "if sys.platform=='<STR_LIT:win32>':<EOL><INDENT>if os.environ.get('<STR_LIT>', '<STR_LIT>')=='<STR_LIT>':<EOL><INDENT>return True<EOL><DEDENT>if os.environ.get('<STR_LIT>', '<STR_LIT>')=='<STR_LIT>':<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Return true when using mingw32 environment.", "id": "f19212:m19"}
{"signature": "def get_subpackage(self,subpackage_name,<EOL>subpackage_path=None,<EOL>parent_name=None,<EOL>caller_level = <NUM_LIT:1>):", "body": "if subpackage_name is None:<EOL><INDENT>if subpackage_path is None:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>subpackage_name = os.path.basename(subpackage_path)<EOL><DEDENT>l = subpackage_name.split('<STR_LIT:.>')<EOL>if subpackage_path is None and '<STR_LIT:*>' in subpackage_name:<EOL><INDENT>return self._wildcard_get_subpackage(subpackage_name,<EOL>parent_name,<EOL>caller_level = caller_level+<NUM_LIT:1>)<EOL><DEDENT>assert '<STR_LIT:*>' not in subpackage_name, repr((subpackage_name, subpackage_path, parent_name))<EOL>if subpackage_path is None:<EOL><INDENT>subpackage_path = njoin([self.local_path] + l)<EOL><DEDENT>else:<EOL><INDENT>subpackage_path = njoin([subpackage_path] + l[:-<NUM_LIT:1>])<EOL>subpackage_path = self.paths([subpackage_path])[<NUM_LIT:0>]<EOL><DEDENT>setup_py = njoin(subpackage_path, self.setup_name)<EOL>if not self.options['<STR_LIT>']:<EOL><INDENT>if not os.path.isfile(setup_py):<EOL><INDENT>setup_py = njoin(subpackage_path,<EOL>'<STR_LIT>' % (subpackage_name))<EOL><DEDENT><DEDENT>if not os.path.isfile(setup_py):<EOL><INDENT>if not self.options['<STR_LIT>']:<EOL><INDENT>self.warn('<STR_LIT>''<STR_LIT>'% (os.path.dirname(setup_py), subpackage_name))<EOL><DEDENT>config = Configuration(subpackage_name, parent_name,<EOL>self.top_path, subpackage_path,<EOL>caller_level = caller_level+<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>config = self._get_configuration_from_setup_py(<EOL>setup_py,<EOL>subpackage_name,<EOL>subpackage_path,<EOL>parent_name,<EOL>caller_level = caller_level + <NUM_LIT:1>)<EOL><DEDENT>if config:<EOL><INDENT>return [config]<EOL><DEDENT>else:<EOL><INDENT>return []<EOL><DEDENT>", "docstring": "Return list of subpackage configurations.\n\n        Parameters\n        ----------\n        subpackage_name : str or None\n            Name of the subpackage to get the configuration. '*' in\n            subpackage_name is handled as a wildcard.\n        subpackage_path : str\n            If None, then the path is assumed to be the local path plus the\n            subpackage_name. If a setup.py file is not found in the\n            subpackage_path, then a default configuration is used.\n        parent_name : str\n            Parent name.", "id": "f19212:c1:m8"}
{"signature": "def minrelpath(path):", "body": "if not is_string(path):<EOL><INDENT>return path<EOL><DEDENT>if '<STR_LIT:.>' not in path:<EOL><INDENT>return path<EOL><DEDENT>l = path.split(os.sep)<EOL>while l:<EOL><INDENT>try:<EOL><INDENT>i = l.index('<STR_LIT:.>', <NUM_LIT:1>)<EOL><DEDENT>except ValueError:<EOL><INDENT>break<EOL><DEDENT>del l[i]<EOL><DEDENT>j = <NUM_LIT:1><EOL>while l:<EOL><INDENT>try:<EOL><INDENT>i = l.index('<STR_LIT:..>', j)<EOL><DEDENT>except ValueError:<EOL><INDENT>break<EOL><DEDENT>if l[i-<NUM_LIT:1>]=='<STR_LIT:..>':<EOL><INDENT>j += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>del l[i], l[i-<NUM_LIT:1>]<EOL>j = <NUM_LIT:1><EOL><DEDENT><DEDENT>if not l:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>return os.sep.join(l)<EOL>", "docstring": "Resolve `..` and '.' from path.", "id": "f19212:m6"}
{"signature": "def get_path_from_frame(frame, parent_path=None):", "body": "<EOL>try:<EOL><INDENT>caller_file = eval('<STR_LIT>', frame.f_globals, frame.f_locals)<EOL>d = os.path.dirname(os.path.abspath(caller_file))<EOL><DEDENT>except NameError:<EOL><INDENT>caller_name = eval('<STR_LIT>', frame.f_globals, frame.f_locals)<EOL>__import__(caller_name)<EOL>mod = sys.modules[caller_name]<EOL>if hasattr(mod, '<STR_LIT>'):<EOL><INDENT>d = os.path.dirname(os.path.abspath(mod.__file__))<EOL><DEDENT>else:<EOL><INDENT>d = os.path.abspath('<STR_LIT:.>')<EOL><DEDENT><DEDENT>if parent_path is not None:<EOL><INDENT>d = rel_path(d, parent_path)<EOL><DEDENT>return d or '<STR_LIT:.>'<EOL>", "docstring": "Return path of the module given a frame object from the call stack.\n\n    Returned path is relative to parent_path when given,\n    otherwise it is absolute path.", "id": "f19212:m3"}
{"signature": "def add_npy_pkg_config(self, template, install_dir, subst_dict=None):", "body": "if subst_dict is None:<EOL><INDENT>subst_dict = {}<EOL><DEDENT>basename = os.path.splitext(template)[<NUM_LIT:0>]<EOL>template = os.path.join(self.package_path, template)<EOL>if self.name in self.installed_pkg_config:<EOL><INDENT>self.installed_pkg_config[self.name].append((template, install_dir,<EOL>subst_dict))<EOL><DEDENT>else:<EOL><INDENT>self.installed_pkg_config[self.name] = [(template, install_dir,<EOL>subst_dict)]<EOL><DEDENT>", "docstring": "Generate and install a npy-pkg config file from a template.\n\nThe config file generated from `template` is installed in the\ngiven install directory, using `subst_dict` for variable substitution.\n\nParameters\n----------\ntemplate : str\n    The path of the template, relatively to the current package path.\ninstall_dir : str\n    Where to install the npy-pkg config file, relatively to the current\n    package path.\nsubst_dict : dict, optional\n    If given, any string of the form ``@key@`` will be replaced by\n    ``subst_dict[key]`` in the template file when installed. The install\n    prefix is always available through the variable ``@prefix@``, since the\n    install prefix is not easy to get reliably from setup.py.\n\nSee also\n--------\nadd_installed_library, get_info\n\nNotes\n-----\nThis works for both standard installs and in-place builds, i.e. the\n``@prefix@`` refer to the source directory for in-place builds.\n\nExamples\n--------\n::\n\n    config.add_npy_pkg_config('foo.ini.in', 'lib', {'foo': bar})\n\nAssuming the foo.ini.in file has the following content::\n\n    [meta]\n    Name=@foo@\n    Version=1.0\n    Description=dummy description\n\n    [default]\n    Cflags=-I@prefix@/include\n    Libs=\n\nThe generated file will have the following content::\n\n    [meta]\n    Name=bar\n    Version=1.0\n    Description=dummy description\n\n    [default]\n    Cflags=-Iprefix_dir/include\n    Libs=\n\nand will be installed as foo.ini in the 'lib' subpath.", "id": "f19212:c1:m22"}
{"signature": "def gpaths(paths, local_path='<STR_LIT>', include_non_existing=True):", "body": "if is_string(paths):<EOL><INDENT>paths = (paths,)<EOL><DEDENT>return _fix_paths(paths, local_path, include_non_existing)<EOL>", "docstring": "Apply glob to paths and prepend local_path if needed.", "id": "f19212:m8"}
{"signature": "def get_version(self, version_file=None, version_variable=None):", "body": "version = getattr(self, '<STR_LIT:version>', None)<EOL>if version is not None:<EOL><INDENT>return version<EOL><DEDENT>if version_file is None:<EOL><INDENT>files = ['<STR_LIT>',<EOL>self.name.split('<STR_LIT:.>')[-<NUM_LIT:1>]+'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>files = [version_file]<EOL><DEDENT>if version_variable is None:<EOL><INDENT>version_vars = ['<STR_LIT:version>',<EOL>'<STR_LIT>',<EOL>self.name.split('<STR_LIT:.>')[-<NUM_LIT:1>]+'<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>version_vars = [version_variable]<EOL><DEDENT>for f in files:<EOL><INDENT>fn = njoin(self.local_path, f)<EOL>if os.path.isfile(fn):<EOL><INDENT>info = (open(fn), fn, ('<STR_LIT>', '<STR_LIT>', <NUM_LIT:1>))<EOL>name = os.path.splitext(os.path.basename(fn))[<NUM_LIT:0>]<EOL>n = dot_join(self.name, name)<EOL>try:<EOL><INDENT>version_module = imp.load_module('<STR_LIT:_>'.join(n.split('<STR_LIT:.>')),*info)<EOL><DEDENT>except ImportError:<EOL><INDENT>msg = get_exception()<EOL>self.warn(str(msg))<EOL>version_module = None<EOL><DEDENT>if version_module is None:<EOL><INDENT>continue<EOL><DEDENT>for a in version_vars:<EOL><INDENT>version = getattr(version_module, a, None)<EOL>if version is not None:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if version is not None:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>if version is not None:<EOL><INDENT>self.version = version<EOL>return version<EOL><DEDENT>revision = self._get_svn_revision(self.local_path)<EOL>if revision is None:<EOL><INDENT>revision = self._get_hg_revision(self.local_path)<EOL><DEDENT>if revision is not None:<EOL><INDENT>version = str(revision)<EOL>self.version = version<EOL><DEDENT>return version<EOL>", "docstring": "Try to get version string of a package.\n\n        Return a version string of the current package or None if the version\n        information could not be detected.\n\n        Notes\n        -----\n        This method scans files named\n        __version__.py, <packagename>_version.py, version.py, and\n        __svn_version__.py for string variables version, __version\\__, and\n        <packagename>_version, until a version number is found.", "id": "f19212:c1:m33"}
{"signature": "def get_npy_pkg_dir():", "body": "<EOL>import numpy<EOL>d = os.path.join(os.path.dirname(numpy.__file__),<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>return d<EOL>", "docstring": "Return the path where to find the npy-pkg-config directory.", "id": "f19212:m46"}
{"signature": "def _get_hg_revision(self, path):", "body": "revision = None<EOL>m = None<EOL>cwd =  os.getcwd()<EOL>try:<EOL><INDENT>os.chdir(path or '<STR_LIT:.>')<EOL>p = subprocess.Popen(['<STR_LIT>'], shell=True,<EOL>stdout=subprocess.PIPE, stderr=None,<EOL>close_fds=True)<EOL>sout = p.stdout<EOL>m = re.match(r'<STR_LIT>', sout.read())<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>os.chdir(cwd)<EOL>if m:<EOL><INDENT>revision = int(m.group('<STR_LIT>'))<EOL>return revision<EOL><DEDENT>branch_fn = njoin(path, '<STR_LIT>', '<STR_LIT>')<EOL>branch_cache_fn = njoin(path, '<STR_LIT>', '<STR_LIT>')<EOL>if os.path.isfile(branch_fn):<EOL><INDENT>branch0 = None<EOL>f = open(branch_fn)<EOL>revision0 = f.read().strip()<EOL>f.close()<EOL>branch_map = {}<EOL>for line in file(branch_cache_fn, '<STR_LIT:r>'):<EOL><INDENT>branch1, revision1  = line.split()[:<NUM_LIT:2>]<EOL>if revision1==revision0:<EOL><INDENT>branch0 = branch1<EOL><DEDENT>try:<EOL><INDENT>revision1 = int(revision1)<EOL><DEDENT>except ValueError:<EOL><INDENT>continue<EOL><DEDENT>branch_map[branch1] = revision1<EOL><DEDENT>revision = branch_map.get(branch0)<EOL><DEDENT>return revision<EOL>", "docstring": "Return path's Mercurial revision number.", "id": "f19212:c1:m32"}
{"signature": "def msvc_version(compiler):", "body": "if not compiler.compiler_type == \"<STR_LIT>\":<EOL><INDENT>raise ValueError(\"<STR_LIT>\"% compiler.compiler_type)<EOL><DEDENT>return compiler._MSVCCompiler__version<EOL>", "docstring": "Return version major and minor of compiler instance if it is\n    MSVC, raise an exception otherwise.", "id": "f19212:m54"}
{"signature": "def get_distribution(self):", "body": "from numpy.distutils.core import get_distribution<EOL>return get_distribution()<EOL>", "docstring": "Return the distutils distribution object for self.", "id": "f19212:c1:m5"}
{"signature": "def set_options(self, **options):", "body": "for key, value in options.items():<EOL><INDENT>if key in self.options:<EOL><INDENT>self.options[key] = value<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>'+key)<EOL><DEDENT><DEDENT>", "docstring": "Configure Configuration instance.\n\nThe following options are available:\n - ignore_setup_xxx_py\n - assume_default_configuration\n - delegate_options_to_subpackages\n - quiet", "id": "f19212:c1:m4"}
{"signature": "def is_local_src_dir(directory):", "body": "if not is_string(directory):<EOL><INDENT>return False<EOL><DEDENT>abs_dir = os.path.abspath(directory)<EOL>c = os.path.commonprefix([os.getcwd(), abs_dir])<EOL>new_dir = abs_dir[len(c):].split(os.sep)<EOL>if new_dir and not new_dir[<NUM_LIT:0>]:<EOL><INDENT>new_dir = new_dir[<NUM_LIT:1>:]<EOL><DEDENT>if new_dir and new_dir[<NUM_LIT:0>]=='<STR_LIT>':<EOL><INDENT>return False<EOL><DEDENT>new_dir = os.sep.join(new_dir)<EOL>return os.path.isdir(new_dir)<EOL>", "docstring": "Return true if directory is local directory.", "id": "f19212:m34"}
{"signature": "def all_strings(lst):", "body": "for item in lst:<EOL><INDENT>if not is_string(item):<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Return True if all items in lst are string objects.", "id": "f19212:m23"}
{"signature": "def make_config_py(self,name='<STR_LIT>'):", "body": "self.py_modules.append((self.name, name, generate_config_py))<EOL>", "docstring": "Generate package __config__.py file containing system_info\n        information used during building the package.\n\n        This file is installed to the\n        package installation directory.", "id": "f19212:c1:m36"}
{"signature": "def _get_f90_modules(source):", "body": "if not f90_ext_match(source):<EOL><INDENT>return []<EOL><DEDENT>modules = []<EOL>f = open(source, '<STR_LIT:r>')<EOL>for line in f:<EOL><INDENT>m = f90_module_name_match(line)<EOL>if m:<EOL><INDENT>name = m.group('<STR_LIT:name>')<EOL>modules.append(name)<EOL><DEDENT><DEDENT>f.close()<EOL>return modules<EOL>", "docstring": "Return a list of Fortran f90 module names that\n    given source file defines.", "id": "f19212:m21"}
{"signature": "def make_hg_version_py(self, delete=True):", "body": "target = njoin(self.local_path, '<STR_LIT>')<EOL>revision = self._get_hg_revision(self.local_path)<EOL>if os.path.isfile(target) or revision is None:<EOL><INDENT>return<EOL><DEDENT>else:<EOL><INDENT>def generate_hg_version_py():<EOL><INDENT>if not os.path.isfile(target):<EOL><INDENT>version = str(revision)<EOL>self.info('<STR_LIT>' % (target, version))<EOL>f = open(target, '<STR_LIT:w>')<EOL>f.write('<STR_LIT>' % (version))<EOL>f.close()<EOL><DEDENT>import atexit<EOL>def rm_file(f=target,p=self.info):<EOL><INDENT>if delete:<EOL><INDENT>try: os.remove(f); p('<STR_LIT>'+f)<EOL>except OSError: pass<EOL>try: os.remove(f+'<STR_LIT:c>'); p('<STR_LIT>'+f+'<STR_LIT:c>')<EOL>except OSError: pass<EOL><DEDENT><DEDENT>atexit.register(rm_file)<EOL>return target<EOL><DEDENT>self.add_data_files(('<STR_LIT>', generate_hg_version_py()))<EOL><DEDENT>", "docstring": "Appends a data function to the data_files list that will generate\n        __hg_version__.py file to the current package directory.\n\n        Generate package __hg_version__.py file from Mercurial revision,\n        it will be removed after python exits but will be available\n        when sdist, etc commands are executed.\n\n        Notes\n        -----\n        If __hg_version__.py existed before, nothing is done.\n\n        This is intended for working with source directories that are\n        in an Mercurial repository.", "id": "f19212:c1:m35"}
{"signature": "def UnixCCompiler_create_static_lib(self, objects, output_libname,<EOL>output_dir=None, debug=<NUM_LIT:0>, target_lang=None):", "body": "objects, output_dir = self._fix_object_args(objects, output_dir)<EOL>output_filename =self.library_filename(output_libname, output_dir=output_dir)<EOL>if self._need_link(objects, output_filename):<EOL><INDENT>try:<EOL><INDENT>os.unlink(output_filename)<EOL><DEDENT>except (IOError, OSError):<EOL><INDENT>pass<EOL><DEDENT>self.mkpath(os.path.dirname(output_filename))<EOL>tmp_objects = objects + self.objects<EOL>while tmp_objects:<EOL><INDENT>objects = tmp_objects[:<NUM_LIT:50>]<EOL>tmp_objects = tmp_objects[<NUM_LIT:50>:]<EOL>display = '<STR_LIT>' % (<EOL>os.path.basename(self.archiver[<NUM_LIT:0>]),<EOL>len(objects), output_filename)<EOL>self.spawn(self.archiver + [output_filename] + objects,<EOL>display = display)<EOL><DEDENT>if self.ranlib:<EOL><INDENT>display = '<STR_LIT>' % (os.path.basename(self.ranlib[<NUM_LIT:0>]),<EOL>output_filename)<EOL>try:<EOL><INDENT>self.spawn(self.ranlib + [output_filename],<EOL>display = display)<EOL><DEDENT>except DistutilsExecError:<EOL><INDENT>msg = str(get_exception())<EOL>raise LibError(msg)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>log.debug(\"<STR_LIT>\", output_filename)<EOL><DEDENT>return<EOL>", "docstring": "Build a static library in a separate sub-process.\n\nParameters\n----------\nobjects : list or tuple of str\n    List of paths to object files used to build the static library.\noutput_libname : str\n    The library name as an absolute or relative (if `output_dir` is used)\n    path.\noutput_dir : str, optional\n    The path to the output directory. Default is None, in which case\n    the ``output_dir`` attribute of the UnixCCompiler instance.\ndebug : bool, optional\n    This parameter is not used.\ntarget_lang : str, optional\n    This parameter is not used.\n\nReturns\n-------\nNone", "id": "f19215:m1"}
{"signature": "def _supports_fileno(stream):", "body": "if hasattr(stream, '<STR_LIT>'):<EOL><INDENT>try:<EOL><INDENT>r = stream.fileno()<EOL>return True<EOL><DEDENT>except IOError:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Returns True if 'stream' supports the file descriptor and allows fileno().", "id": "f19216:m6"}
{"signature": "def randn(*args):", "body": "if isinstance(args[<NUM_LIT:0>], tuple):<EOL><INDENT>args = args[<NUM_LIT:0>]<EOL><DEDENT>return asmatrix(np.random.randn(*args))<EOL>", "docstring": "Return a random matrix with data from the \"standard normal\" distribution.\n\n`randn` generates a matrix filled with random floats sampled from a\nunivariate \"normal\" (Gaussian) distribution of mean 0 and variance 1.\n\nParameters\n----------\n\\\\*args : Arguments\n    Shape of the output.\n    If given as N integers, each integer specifies the size of one\n    dimension. If given as a tuple, this tuple gives the complete shape.\n\nReturns\n-------\nZ : matrix of floats\n    A matrix of floating-point samples drawn from the standard normal\n    distribution.\n\nSee Also\n--------\nrand, random.randn\n\nNotes\n-----\nFor random samples from :math:`N(\\\\mu, \\\\sigma^2)`, use:\n\n``sigma * np.matlib.randn(...) + mu``\n\nExamples\n--------\n>>> import numpy.matlib\n>>> np.matlib.randn(1)\nmatrix([[-0.09542833]])                                 #random\n>>> np.matlib.randn(1, 2, 3)\nmatrix([[ 0.16198284,  0.0194571 ,  0.18312985],\n        [-0.7509172 ,  1.61055   ,  0.45298599]])       #random\n\nTwo-by-four matrix of samples from :math:`N(3, 6.25)`:\n\n>>> 2.5 * np.matlib.randn((2, 4)) + 3\nmatrix([[ 4.74085004,  8.89381862,  4.09042411,  4.83721922],\n        [ 7.52373709,  5.07933944, -2.64043543,  0.45610557]])  #random", "id": "f19218:m6"}
{"signature": "def repmat(a, m, n):", "body": "a = asanyarray(a)<EOL>ndim = a.ndim<EOL>if ndim == <NUM_LIT:0>:<EOL><INDENT>origrows, origcols = (<NUM_LIT:1>, <NUM_LIT:1>)<EOL><DEDENT>elif ndim == <NUM_LIT:1>:<EOL><INDENT>origrows, origcols = (<NUM_LIT:1>, a.shape[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>origrows, origcols = a.shape<EOL><DEDENT>rows = origrows * m<EOL>cols = origcols * n<EOL>c = a.reshape(<NUM_LIT:1>, a.size).repeat(m, <NUM_LIT:0>).reshape(rows, origcols).repeat(n, <NUM_LIT:0>)<EOL>return c.reshape(rows, cols)<EOL>", "docstring": "Repeat a 0-D to 2-D array or matrix MxN times.\n\nParameters\n----------\na : array_like\n    The array or matrix to be repeated.\nm, n : int\n    The number of times `a` is repeated along the first and second axes.\n\nReturns\n-------\nout : ndarray\n    The result of repeating `a`.\n\nExamples\n--------\n>>> import numpy.matlib\n>>> a0 = np.array(1)\n>>> np.matlib.repmat(a0, 2, 3)\narray([[1, 1, 1],\n       [1, 1, 1]])\n\n>>> a1 = np.arange(4)\n>>> np.matlib.repmat(a1, 2, 2)\narray([[0, 1, 2, 3, 0, 1, 2, 3],\n       [0, 1, 2, 3, 0, 1, 2, 3]])\n\n>>> a2 = np.asmatrix(np.arange(6).reshape(2, 3))\n>>> np.matlib.repmat(a2, 2, 3)\nmatrix([[0, 1, 2, 0, 1, 2, 0, 1, 2],\n        [3, 4, 5, 3, 4, 5, 3, 4, 5],\n        [0, 1, 2, 0, 1, 2, 0, 1, 2],\n        [3, 4, 5, 3, 4, 5, 3, 4, 5]])", "id": "f19218:m7"}
{"signature": "def set_initial_value(self, y, t=<NUM_LIT:0.0>):", "body": "if isscalar(y):<EOL><INDENT>y = [y]<EOL><DEDENT>n_prev = len(self._y)<EOL>if not n_prev:<EOL><INDENT>self.set_integrator('<STR_LIT>')  <EOL><DEDENT>self._y = asarray(y, self._integrator.scalar)<EOL>self.t = t<EOL>self._integrator.reset(len(self._y), self.jac is not None)<EOL>return self<EOL>", "docstring": "Set initial conditions y(t) = y.", "id": "f19224:c0:m2"}
{"signature": "def set_solout(self, solout):", "body": "if self._integrator.supports_solout:<EOL><INDENT>self._integrator.set_solout(solout)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>+ \"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Set callable to be called at every successful integration step.\n\nParameters\n----------\nsolout : callable\n    ``solout(t, y)`` is called at each internal integrator step,\n    t is a scalar providing the current independent position\n    y is the current soloution ``y.shape == (n,)``\n    solout should return -1 to stop integration\n    otherwise it should return None or 0", "id": "f19224:c0:m8"}
{"signature": "def run_relax(self, f, jac, y0, t0, t1, f_params, jac_params):", "body": "raise NotImplementedError('<STR_LIT>' %<EOL>self.__class__.__name__)<EOL>", "docstring": "Integrate from t=t0 to t>=t1 and return (y1,t).", "id": "f19224:c3:m5"}
{"signature": "def romberg(function, a, b, args=(), tol=<NUM_LIT>, rtol=<NUM_LIT>, show=False,<EOL>divmax=<NUM_LIT:10>, vec_func=False):", "body": "if isinf(a) or isinf(b):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>vfunc = vectorize1(function, args, vec_func=vec_func)<EOL>n = <NUM_LIT:1><EOL>interval = [a,b]<EOL>intrange = b-a<EOL>ordsum = _difftrap(vfunc, interval, n)<EOL>result = intrange * ordsum<EOL>resmat = [[result]]<EOL>err = np.inf<EOL>for i in xrange(<NUM_LIT:1>, divmax+<NUM_LIT:1>):<EOL><INDENT>n = n * <NUM_LIT:2><EOL>ordsum = ordsum + _difftrap(vfunc, interval, n)<EOL>resmat.append([])<EOL>resmat[i].append(intrange * ordsum / n)<EOL>for k in range(i):<EOL><INDENT>resmat[i].append(_romberg_diff(resmat[i-<NUM_LIT:1>][k], resmat[i][k], k+<NUM_LIT:1>))<EOL><DEDENT>result = resmat[i][i]<EOL>lastresult = resmat[i-<NUM_LIT:1>][i-<NUM_LIT:1>]<EOL>err = abs(result - lastresult)<EOL>if err < tol or err < rtol*abs(result):<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>warnings.warn(<EOL>\"<STR_LIT>\" % (divmax, err),<EOL>AccuracyWarning)<EOL><DEDENT>if show:<EOL><INDENT>_printresmat(vfunc, interval, resmat)<EOL><DEDENT>return result<EOL>", "docstring": "Romberg integration of a callable function or method.\n\nReturns the integral of `function` (a function of one variable)\nover the interval (`a`, `b`).\n\nIf `show` is 1, the triangular array of the intermediate results\nwill be printed.  If `vec_func` is True (default is False), then\n`function` is assumed to support vector arguments.\n\nParameters\n----------\nfunction : callable\n    Function to be integrated.\na : float\n    Lower limit of integration.\nb : float\n    Upper limit of integration.\n\nReturns\n-------\nresults  : float\n    Result of the integration.\n\nOther Parameters\n----------------\nargs : tuple, optional\n    Extra arguments to pass to function. Each element of `args` will\n    be passed as a single argument to `func`. Default is to pass no\n    extra arguments.\ntol, rtol : float, optional\n    The desired absolute and relative tolerances. Defaults are 1.48e-8.\nshow : bool, optional\n    Whether to print the results. Default is False.\ndivmax : int, optional\n    Maximum order of extrapolation. Default is 10.\nvec_func : bool, optional\n    Whether `func` handles arrays as arguments (i.e whether it is a\n    \"vector\" function). Default is False.\n\nSee Also\n--------\nfixed_quad : Fixed-order Gaussian quadrature.\nquad : Adaptive quadrature using QUADPACK.\ndblquad : Double integrals.\ntplquad : Triple integrals.\nromb : Integrators for sampled data.\nsimps : Integrators for sampled data.\ncumtrapz : Cumulative integration for sampled data.\node : ODE integrator.\nodeint : ODE integrator.\n\nReferences\n----------\n.. [1] 'Romberg's method' http://en.wikipedia.org/wiki/Romberg%27s_method\n\nExamples\n--------\nIntegrate a gaussian from 0 to 1 and compare to the error function.\n\n>>> from scipy import integrate\n>>> from scipy.special import erf\n>>> gaussian = lambda x: 1/np.sqrt(np.pi) * np.exp(-x**2)\n>>> result = integrate.romberg(gaussian, 0, 1, show=True)\nRomberg integration of <function vfunc at ...> from [0, 1]\n\n::\n\n   Steps  StepSize  Results\n       1  1.000000  0.385872\n       2  0.500000  0.412631  0.421551\n       4  0.250000  0.419184  0.421368  0.421356\n       8  0.125000  0.420810  0.421352  0.421350  0.421350\n      16  0.062500  0.421215  0.421350  0.421350  0.421350  0.421350\n      32  0.031250  0.421317  0.421350  0.421350  0.421350  0.421350  0.421350\n\nThe final result is 0.421350396475 after 33 function evaluations.\n\n>>> print(\"%g %g\" % (2*result, erf(1)))\n0.842701 0.842701", "id": "f19225:m12"}
{"signature": "def _cached_p_roots(n):", "body": "if n in _cached_p_roots.cache:<EOL><INDENT>return _cached_p_roots.cache[n]<EOL><DEDENT>_cached_p_roots.cache[n] = p_roots(n)<EOL>return _cached_p_roots.cache[n]<EOL>", "docstring": "Cache p_roots results for speeding up multiple calls of the fixed_quad function.", "id": "f19225:m0"}
{"signature": "def newton_cotes(rn, equal=<NUM_LIT:0>):", "body": "try:<EOL><INDENT>N = len(rn)-<NUM_LIT:1><EOL>if equal:<EOL><INDENT>rn = np.arange(N+<NUM_LIT:1>)<EOL><DEDENT>elif np.all(np.diff(rn) == <NUM_LIT:1>):<EOL><INDENT>equal = <NUM_LIT:1><EOL><DEDENT><DEDENT>except:<EOL><INDENT>N = rn<EOL>rn = np.arange(N+<NUM_LIT:1>)<EOL>equal = <NUM_LIT:1><EOL><DEDENT>if equal and N in _builtincoeffs:<EOL><INDENT>na, da, vi, nb, db = _builtincoeffs[N]<EOL>return na*np.array(vi,float)/da, float(nb)/db<EOL><DEDENT>if (rn[<NUM_LIT:0>] != <NUM_LIT:0>) or (rn[-<NUM_LIT:1>] != N):<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>yi = rn / float(N)<EOL>ti = <NUM_LIT>*yi - <NUM_LIT:1><EOL>nvec = np.arange(<NUM_LIT:0>,N+<NUM_LIT:1>)<EOL>C = ti**nvec[:,np.newaxis]<EOL>Cinv = np.linalg.inv(C)<EOL>for i in range(<NUM_LIT:2>):<EOL><INDENT>Cinv = <NUM_LIT:2>*Cinv - Cinv.dot(C).dot(Cinv)<EOL><DEDENT>vec = <NUM_LIT> / (nvec[::<NUM_LIT:2>]+<NUM_LIT:1>)<EOL>ai = np.dot(Cinv[:,::<NUM_LIT:2>],vec) * N/<NUM_LIT:2><EOL>if (N % <NUM_LIT:2> == <NUM_LIT:0>) and equal:<EOL><INDENT>BN = N/(N+<NUM_LIT>)<EOL>power = N+<NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>BN = N/(N+<NUM_LIT>)<EOL>power = N+<NUM_LIT:1><EOL><DEDENT>BN = BN - np.dot(yi**power, ai)<EOL>p1 = power+<NUM_LIT:1><EOL>fac = power*math.log(N) - gammaln(p1)<EOL>fac = math.exp(fac)<EOL>return ai, BN*fac<EOL>", "docstring": "Return weights and error coefficient for Newton-Cotes integration.\n\nSuppose we have (N+1) samples of f at the positions\nx_0, x_1, ..., x_N.  Then an N-point Newton-Cotes formula for the\nintegral between x_0 and x_N is:\n\n:math:`\\\\int_{x_0}^{x_N} f(x)dx = \\\\Delta x \\\\sum_{i=0}^{N} a_i f(x_i)\n+ B_N (\\\\Delta x)^{N+2} f^{N+1} (\\\\xi)`\n\nwhere :math:`\\\\xi \\\\in [x_0,x_N]` and :math:`\\\\Delta x = \\\\frac{x_N-x_0}{N}`\nis the averages samples spacing.\n\nIf the samples are equally-spaced and N is even, then the error\nterm is :math:`B_N (\\\\Delta x)^{N+3} f^{N+2}(\\\\xi)`.\n\nParameters\n----------\nrn : int\n    The integer order for equally-spaced data or the relative positions of\n    the samples with the first sample at 0 and the last at N, where N+1 is\n    the length of `rn`.  N is the order of the Newton-Cotes integration.\nequal : int, optional\n    Set to 1 to enforce equally spaced data.\n\nReturns\n-------\nan : ndarray\n    1-D array of weights to apply to the function at the provided sample\n    positions.\nB : float\n    Error coefficient.\n\nNotes\n-----\nNormally, the Newton-Cotes rules are used on smaller integration\nregions and a composite rule is used to return the total integral.", "id": "f19225:m13"}
{"signature": "def fixed_quad(func,a,b,args=(),n=<NUM_LIT:5>):", "body": "[x,w] = _cached_p_roots(n)<EOL>x = real(x)<EOL>ainf, binf = map(isinf,(a,b))<EOL>if ainf or binf:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>y = (b-a)*(x+<NUM_LIT:1>)/<NUM_LIT> + a<EOL>return (b-a)/<NUM_LIT>*sum(w*func(y,*args),<NUM_LIT:0>), None<EOL>", "docstring": "Compute a definite integral using fixed-order Gaussian quadrature.\n\nIntegrate `func` from `a` to `b` using Gaussian quadrature of\norder `n`.\n\nParameters\n----------\nfunc : callable\n    A Python function or method to integrate (must accept vector inputs).\na : float\n    Lower limit of integration.\nb : float\n    Upper limit of integration.\nargs : tuple, optional\n    Extra arguments to pass to function, if any.\nn : int, optional\n    Order of quadrature integration. Default is 5.\n\nReturns\n-------\nval : float\n    Gaussian quadrature approximation to the integral\n\nSee Also\n--------\nquad : adaptive quadrature using QUADPACK\ndblquad : double integrals\ntplquad : triple integrals\nromberg : adaptive Romberg quadrature\nquadrature : adaptive Gaussian quadrature\nromb : integrators for sampled data\nsimps : integrators for sampled data\ncumtrapz : cumulative integration for sampled data\node : ODE integrator\nodeint : ODE integrator", "id": "f19225:m1"}
{"signature": "def nquad(func, ranges, args=None, opts=None):", "body": "depth = len(ranges)<EOL>ranges = [rng if callable(rng) else _RangeFunc(rng) for rng in ranges]<EOL>if args is None:<EOL><INDENT>args = ()<EOL><DEDENT>if opts is None:<EOL><INDENT>opts = [dict([])] * depth<EOL><DEDENT>if isinstance(opts, dict):<EOL><INDENT>opts = [opts] * depth<EOL><DEDENT>else:<EOL><INDENT>opts = [opt if callable(opt) else _OptFunc(opt) for opt in opts]<EOL><DEDENT>return _NQuad(func, ranges, opts).integrate(*args)<EOL>", "docstring": "Integration over multiple variables.\n\nWraps `quad` to enable integration over multiple variables.\nVarious options allow improved integration of discontinuous functions, as\nwell as the use of weighted integration, and generally finer control of the\nintegration process.\n\nParameters\n----------\nfunc : callable\n    The function to be integrated. Has arguments of ``x0, ... xn``,\n    ``t0, tm``, where integration is carried out over ``x0, ... xn``, which\n    must be floats.  Function signature should be\n    ``func(x0, x1, ..., xn, t0, t1, ..., tm)``.  Integration is carried out\n    in order.  That is, integration over ``x0`` is the innermost integral,\n    and ``xn`` is the outermost.\n    If performance is a concern, this function may be a ctypes function of\n    the form::\n\n        f(int n, double args[n])\n\n    where ``n`` is the number of extra parameters and args is an array\n    of doubles of the additional parameters.  This function may then\n    be compiled to a dynamic/shared library then imported through\n    ``ctypes``, setting the function's argtypes to ``(c_int, c_double)``,\n    and the function's restype to ``(c_double)``.  Its pointer may then be\n    passed into `nquad` normally.\n    This allows the underlying Fortran library to evaluate the function in\n    the innermost integration calls without callbacks to Python, and also \n    speeds up the evaluation of the function itself.\nranges : iterable object\n    Each element of ranges may be either a sequence  of 2 numbers, or else\n    a callable that returns such a sequence.  ``ranges[0]`` corresponds to\n    integration over x0, and so on.  If an element of ranges is a callable,\n    then it will be called with all of the integration arguments available.\n    e.g. if ``func = f(x0, x1, x2)``, then ``ranges[0]`` may be defined as\n    either ``(a, b)`` or else as ``(a, b) = range0(x1, x2)``.\nargs : iterable object, optional\n    Additional arguments ``t0, ..., tn``, required by `func`.\nopts : iterable object or dict, optional\n    Options to be passed to `quad`.  May be empty, a dict, or\n    a sequence of dicts or functions that return a dict.  If empty, the\n    default options from scipy.integrate.quadare used.  If a dict, the same\n    options are used for all levels of integraion.  If a sequence, then each\n    element of the sequence corresponds to a particular integration. e.g.\n    opts[0] corresponds to integration over x0, and so on. The available\n    options together with their default values are:\n\n      - epsabs = 1.49e-08\n      - epsrel = 1.49e-08\n      - limit  = 50\n      - points = None\n      - weight = None\n      - wvar   = None\n      - wopts  = None\n\n    The ``full_output`` option from `quad` is unavailable, due to the\n    complexity of handling the large amount of data such an option would\n    return for this kind of nested integration.  For more information on\n    these options, see `quad` and `quad_explain`.\n\nReturns\n-------\nresult : float\n    The result of the integration.\nabserr : float\n    The maximum of the estimates of the absolute error in the various\n    integration results.\n\nSee Also\n--------\nquad : 1-dimensional numerical integration\ndblquad, tplquad : double and triple integrals\nfixed_quad : fixed-order Gaussian quadrature\nquadrature : adaptive Gaussian quadrature\n\nExamples\n--------\n>>> from scipy import integrate\n>>> func = lambda x0,x1,x2,x3 : x0**2 + x1*x2 - x3**3 + np.sin(x0) + (\n...                                 1 if (x0-.2*x3-.5-.25*x1>0) else 0)\n>>> points = [[lambda (x1,x2,x3) : 0.2*x3 + 0.5 + 0.25*x1], [], [], []]\n>>> def opts0(*args, **kwargs):\n...     return {'points':[0.2*args[2] + 0.5 + 0.25*args[0]]}\n>>> integrate.nquad(func, [[0,1], [-1,1], [.13,.8], [-.15,1]],\n...                 opts=[opts0,{},{},{}])\n(1.5267454070738633, 2.9437360001402324e-14)\n\n>>> scale = .1\n>>> def func2(x0, x1, x2, x3, t0, t1):\n...     return x0*x1*x3**2 + np.sin(x2) + 1 + (1 if x0+t1*x1-t0>0 else 0)\n>>> def lim0(x1, x2, x3, t0, t1):\n...     return [scale * (x1**2 + x2 + np.cos(x3)*t0*t1 + 1) - 1,\n...             scale * (x1**2 + x2 + np.cos(x3)*t0*t1 + 1) + 1]\n>>> def lim1(x2, x3, t0, t1):\n...     return [scale * (t0*x2 + t1*x3) - 1,\n...             scale * (t0*x2 + t1*x3) + 1]\n>>> def lim2(x3, t0, t1):\n...     return [scale * (x3 + t0**2*t1**3) - 1,\n...             scale * (x3 + t0**2*t1**3) + 1]\n>>> def lim3(t0, t1):\n...     return [scale * (t0+t1) - 1, scale * (t0+t1) + 1]\n>>> def opts0(x1, x2, x3, t0, t1):\n...     return {'points' : [t0 - t1*x1]}\n>>> def opts1(x2, x3, t0, t1):\n...     return {}\n>>> def opts2(x3, t0, t1):\n...     return {}\n>>> def opts3(t0, t1):\n...     return {}\n>>> integrate.nquad(func2, [lim0, lim1, lim2, lim3], args=(0,0),\n                    opts=[opts0, opts1, opts2, opts3])\n(25.066666666666666, 2.7829590483937256e-13)", "id": "f19226:m8"}
{"signature": "def dblquad(func, a, b, gfun, hfun, args=(), epsabs=<NUM_LIT>, epsrel=<NUM_LIT>):", "body": "return quad(_infunc, a, b, (func, gfun, hfun, args),<EOL>epsabs=epsabs, epsrel=epsrel)<EOL>", "docstring": "Compute a double integral.\n\nReturn the double (definite) integral of ``func(y, x)`` from ``x = a..b``\nand ``y = gfun(x)..hfun(x)``.\n\nParameters\n----------\nfunc : callable\n    A Python function or method of at least two variables: y must be the\n    first argument and x the second argument.\n(a,b) : tuple\n    The limits of integration in x: `a` < `b`\ngfun : callable\n    The lower boundary curve in y which is a function taking a single\n    floating point argument (x) and returning a floating point result: a\n    lambda function can be useful here.\nhfun : callable\n    The upper boundary curve in y (same requirements as `gfun`).\nargs : sequence, optional\n    Extra arguments to pass to `func`.\nepsabs : float, optional\n    Absolute tolerance passed directly to the inner 1-D quadrature\n    integration. Default is 1.49e-8.\nepsrel : float\n    Relative tolerance of the inner 1-D integrals. Default is 1.49e-8.\n\nReturns\n-------\ny : float\n    The resultant integral.\nabserr : float\n    An estimate of the error.\n\nSee also\n--------\nquad : single integral\ntplquad : triple integral\nnquad : N-dimensional integrals\nfixed_quad : fixed-order Gaussian quadrature\nquadrature : adaptive Gaussian quadrature\nodeint : ODE integrator\node : ODE integrator\nsimps : integrator for sampled data\nromb : integrator for sampled data\nscipy.special : for coefficients and roots of orthogonal polynomials", "id": "f19226:m5"}
{"signature": "def quad(func, a, b, args=(), full_output=<NUM_LIT:0>, epsabs=<NUM_LIT>, epsrel=<NUM_LIT>,<EOL>limit=<NUM_LIT:50>, points=None, weight=None, wvar=None, wopts=None, maxp1=<NUM_LIT:50>,<EOL>limlst=<NUM_LIT:50>):", "body": "if not isinstance(args, tuple):<EOL><INDENT>args = (args,)<EOL><DEDENT>if (weight is None):<EOL><INDENT>retval = _quad(func, a, b, args, full_output, epsabs, epsrel, limit,<EOL>points)<EOL><DEDENT>else:<EOL><INDENT>retval = _quad_weight(func, a, b, args, full_output, epsabs, epsrel,<EOL>limlst, limit, maxp1, weight, wvar, wopts)<EOL><DEDENT>ier = retval[-<NUM_LIT:1>]<EOL>if ier == <NUM_LIT:0>:<EOL><INDENT>return retval[:-<NUM_LIT:1>]<EOL><DEDENT>msgs = {<NUM_LIT>: \"<STR_LIT>\",<EOL><NUM_LIT:1>: \"<STR_LIT>\" % limit,<EOL><NUM_LIT:2>: \"<STR_LIT>\",<EOL><NUM_LIT:3>: \"<STR_LIT>\",<EOL><NUM_LIT:4>: \"<STR_LIT>\",<EOL><NUM_LIT:5>: \"<STR_LIT>\",<EOL><NUM_LIT:6>: \"<STR_LIT>\",<EOL><NUM_LIT:7>: \"<STR_LIT>\",<EOL>'<STR_LIT>': \"<STR_LIT>\"}<EOL>if weight in ['<STR_LIT>','<STR_LIT>'] and (b == Inf or a == -Inf):<EOL><INDENT>msgs[<NUM_LIT:1>] = \"<STR_LIT>\"<EOL>msgs[<NUM_LIT:4>] = \"<STR_LIT>\"<EOL>msgs[<NUM_LIT:7>] = \"<STR_LIT>\"<EOL>explain = {<NUM_LIT:1>: \"<STR_LIT>\",<EOL><NUM_LIT:2>: \"<STR_LIT>\",<EOL><NUM_LIT:3>: \"<STR_LIT>\",<EOL><NUM_LIT:4>: \"<STR_LIT>\",<EOL><NUM_LIT:5>: \"<STR_LIT>\"}<EOL><DEDENT>try:<EOL><INDENT>msg = msgs[ier]<EOL><DEDENT>except KeyError:<EOL><INDENT>msg = msgs['<STR_LIT>']<EOL><DEDENT>if ier in [<NUM_LIT:1>,<NUM_LIT:2>,<NUM_LIT:3>,<NUM_LIT:4>,<NUM_LIT:5>,<NUM_LIT:7>]:<EOL><INDENT>if full_output:<EOL><INDENT>if weight in ['<STR_LIT>','<STR_LIT>'] and (b == Inf or a == Inf):<EOL><INDENT>return retval[:-<NUM_LIT:1>] + (msg, explain)<EOL><DEDENT>else:<EOL><INDENT>return retval[:-<NUM_LIT:1>] + (msg,)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>warnings.warn(msg, IntegrationWarning)<EOL>return retval[:-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError(msg)<EOL><DEDENT>", "docstring": "Compute a definite integral.\n\nIntegrate func from `a` to `b` (possibly infinite interval) using a\ntechnique from the Fortran library QUADPACK.\n\nParameters\n----------\nfunc : function\n    A Python function or method to integrate.  If `func` takes many\n    arguments, it is integrated along the axis corresponding to the\n    first argument.\n    If the user desires improved integration performance, then f may\n    instead be a ``ctypes`` function of the form:\n\n        f(int n, double args[n]),\n\n    where ``args`` is an array of function arguments and ``n`` is the\n    length of ``args``. ``f.argtypes`` should be set to\n    ``(c_int, c_double)``, and ``f.restype`` should be ``(c_double,)``.\na : float\n    Lower limit of integration (use -numpy.inf for -infinity).\nb : float\n    Upper limit of integration (use numpy.inf for +infinity).\nargs : tuple, optional\n    Extra arguments to pass to `func`.\nfull_output : int, optional\n    Non-zero to return a dictionary of integration information.\n    If non-zero, warning messages are also suppressed and the\n    message is appended to the output tuple.\n\nReturns\n-------\ny : float\n    The integral of func from `a` to `b`.\nabserr : float\n    An estimate of the absolute error in the result.\ninfodict : dict\n    A dictionary containing additional information.\n    Run scipy.integrate.quad_explain() for more information.\nmessage :\n    A convergence message.\nexplain :\n    Appended only with 'cos' or 'sin' weighting and infinite\n    integration limits, it contains an explanation of the codes in\n    infodict['ierlst']\n\nOther Parameters\n----------------\nepsabs : float or int, optional\n    Absolute error tolerance.\nepsrel : float or int, optional\n    Relative error tolerance.\nlimit : float or int, optional\n    An upper bound on the number of subintervals used in the adaptive\n    algorithm.\npoints : (sequence of floats,ints), optional\n    A sequence of break points in the bounded integration interval\n    where local difficulties of the integrand may occur (e.g.,\n    singularities, discontinuities). The sequence does not have\n    to be sorted.\nweight : float or int, optional\n    String indicating weighting function. Full explanation for this\n    and the remaining arguments can be found below.\nwvar : optional\n    Variables for use with weighting functions.\nwopts : optional\n    Optional input for reusing Chebyshev moments.\nmaxp1 : float or int, optional\n    An upper bound on the number of Chebyshev moments.\nlimlst : int, optional\n    Upper bound on the number of cycles (>=3) for use with a sinusoidal\n    weighting and an infinite end-point.\n\nSee Also\n--------\ndblquad : double integral\ntplquad : triple integral\nnquad : n-dimensional integrals (uses `quad` recursively)\nfixed_quad : fixed-order Gaussian quadrature\nquadrature : adaptive Gaussian quadrature\nodeint : ODE integrator\node : ODE integrator\nsimps : integrator for sampled data\nromb : integrator for sampled data\nscipy.special : for coefficients and roots of orthogonal polynomials\n\nNotes\n-----\n\n**Extra information for quad() inputs and outputs**\n\nIf full_output is non-zero, then the third output argument\n(infodict) is a dictionary with entries as tabulated below.  For\ninfinite limits, the range is transformed to (0,1) and the\noptional outputs are given with respect to this transformed range.\nLet M be the input argument limit and let K be infodict['last'].\nThe entries are:\n\n'neval'\n    The number of function evaluations.\n'last'\n    The number, K, of subintervals produced in the subdivision process.\n'alist'\n    A rank-1 array of length M, the first K elements of which are the\n    left end points of the subintervals in the partition of the\n    integration range.\n'blist'\n    A rank-1 array of length M, the first K elements of which are the\n    right end points of the subintervals.\n'rlist'\n    A rank-1 array of length M, the first K elements of which are the\n    integral approximations on the subintervals.\n'elist'\n    A rank-1 array of length M, the first K elements of which are the\n    moduli of the absolute error estimates on the subintervals.\n'iord'\n    A rank-1 integer array of length M, the first L elements of\n    which are pointers to the error estimates over the subintervals\n    with ``L=K`` if ``K<=M/2+2`` or ``L=M+1-K`` otherwise. Let I be the\n    sequence ``infodict['iord']`` and let E be the sequence\n    ``infodict['elist']``.  Then ``E[I[1]], ..., E[I[L]]`` forms a\n    decreasing sequence.\n\nIf the input argument points is provided (i.e. it is not None),\nthe following additional outputs are placed in the output\ndictionary.  Assume the points sequence is of length P.\n\n'pts'\n    A rank-1 array of length P+2 containing the integration limits\n    and the break points of the intervals in ascending order.\n    This is an array giving the subintervals over which integration\n    will occur.\n'level'\n    A rank-1 integer array of length M (=limit), containing the\n    subdivision levels of the subintervals, i.e., if (aa,bb) is a\n    subinterval of ``(pts[1], pts[2])`` where ``pts[0]`` and ``pts[2]``\n    are adjacent elements of ``infodict['pts']``, then (aa,bb) has level l\n    if ``|bb-aa| = |pts[2]-pts[1]| * 2**(-l)``.\n'ndin'\n    A rank-1 integer array of length P+2.  After the first integration\n    over the intervals (pts[1], pts[2]), the error estimates over some\n    of the intervals may have been increased artificially in order to\n    put their subdivision forward.  This array has ones in slots\n    corresponding to the subintervals for which this happens.\n\n**Weighting the integrand**\n\nThe input variables, *weight* and *wvar*, are used to weight the\nintegrand by a select list of functions.  Different integration\nmethods are used to compute the integral with these weighting\nfunctions.  The possible values of weight and the corresponding\nweighting functions are.\n\n==========  ===================================   =====================\n``weight``  Weight function used                  ``wvar``\n==========  ===================================   =====================\n'cos'       cos(w*x)                              wvar = w\n'sin'       sin(w*x)                              wvar = w\n'alg'       g(x) = ((x-a)**alpha)*((b-x)**beta)   wvar = (alpha, beta)\n'alg-loga'  g(x)*log(x-a)                         wvar = (alpha, beta)\n'alg-logb'  g(x)*log(b-x)                         wvar = (alpha, beta)\n'alg-log'   g(x)*log(x-a)*log(b-x)                wvar = (alpha, beta)\n'cauchy'    1/(x-c)                               wvar = c\n==========  ===================================   =====================\n\nwvar holds the parameter w, (alpha, beta), or c depending on the weight\nselected.  In these expressions, a and b are the integration limits.\n\nFor the 'cos' and 'sin' weighting, additional inputs and outputs are\navailable.\n\nFor finite integration limits, the integration is performed using a\nClenshaw-Curtis method which uses Chebyshev moments.  For repeated\ncalculations, these moments are saved in the output dictionary:\n\n'momcom'\n    The maximum level of Chebyshev moments that have been computed,\n    i.e., if ``M_c`` is ``infodict['momcom']`` then the moments have been\n    computed for intervals of length ``|b-a| * 2**(-l)``,\n    ``l=0,1,...,M_c``.\n'nnlog'\n    A rank-1 integer array of length M(=limit), containing the\n    subdivision levels of the subintervals, i.e., an element of this\n    array is equal to l if the corresponding subinterval is\n    ``|b-a|* 2**(-l)``.\n'chebmo'\n    A rank-2 array of shape (25, maxp1) containing the computed\n    Chebyshev moments.  These can be passed on to an integration\n    over the same interval by passing this array as the second\n    element of the sequence wopts and passing infodict['momcom'] as\n    the first element.\n\nIf one of the integration limits is infinite, then a Fourier integral is\ncomputed (assuming w neq 0).  If full_output is 1 and a numerical error\nis encountered, besides the error message attached to the output tuple,\na dictionary is also appended to the output tuple which translates the\nerror codes in the array ``info['ierlst']`` to English messages.  The\noutput information dictionary contains the following entries instead of\n'last', 'alist', 'blist', 'rlist', and 'elist':\n\n'lst'\n    The number of subintervals needed for the integration (call it ``K_f``).\n'rslst'\n    A rank-1 array of length M_f=limlst, whose first ``K_f`` elements\n    contain the integral contribution over the interval\n    ``(a+(k-1)c, a+kc)`` where ``c = (2*floor(|w|) + 1) * pi / |w|``\n    and ``k=1,2,...,K_f``.\n'erlst'\n    A rank-1 array of length ``M_f`` containing the error estimate\n    corresponding to the interval in the same position in\n    ``infodict['rslist']``.\n'ierlst'\n    A rank-1 integer array of length ``M_f`` containing an error flag\n    corresponding to the interval in the same position in\n    ``infodict['rslist']``.  See the explanation dictionary (last entry\n    in the output tuple) for the meaning of the codes.\n\nExamples\n--------\nCalculate :math:`\\\\int^4_0 x^2 dx` and compare with an analytic result\n\n>>> from scipy import integrate\n>>> x2 = lambda x: x**2\n>>> integrate.quad(x2, 0, 4)\n(21.333333333333332, 2.3684757858670003e-13)\n>>> print(4**3 / 3.)  # analytical result\n21.3333333333\n\nCalculate :math:`\\\\int^\\\\infty_0 e^{-x} dx`\n\n>>> invexp = lambda x: np.exp(-x)\n>>> integrate.quad(invexp, 0, np.inf)\n(1.0, 5.842605999138044e-11)\n\n>>> f = lambda x,a : a*x\n>>> y, err = integrate.quad(f, 0, 1, args=(1,))\n>>> y\n0.5\n>>> y, err = integrate.quad(f, 0, 1, args=(3,))\n>>> y\n1.5\n\nCalculate :math:`\\\\int^1_0 x^2 + y^2 dx` with ctypes, holding\ny parameter as 1::\n\n    testlib.c =>\n        double func(int n, double args[n]){\n            return args[0]*args[0] + args[1]*args[1];}\n    compile to library testlib.*\n\n>>> from scipy import integrate\n>>> import ctypes\n>>> lib = ctypes.CDLL('/home/.../testlib.*') #use absolute path\n>>> lib.func.restype = ctypes.c_double\n>>> lib.func.argtypes = (ctypes.c_int,ctypes.c_double)\n>>> integrate.quad(lib.func,0,1,(1))\n(1.3333333333333333, 1.4802973661668752e-14)\n>>> print((1.0**3/3.0 + 1.0) - (0.0**3/3.0 + 0.0)) #Analytic result\n1.3333333333333333", "id": "f19226:m1"}
{"signature": "def alt_sg_coeffs(window_length, polyorder, pos):", "body": "if pos is None:<EOL><INDENT>pos = window_length // <NUM_LIT:2><EOL><DEDENT>t = np.arange(window_length)<EOL>unit = (t == pos).astype(int)<EOL>h = np.polyval(np.polyfit(t, unit, polyorder), t)<EOL>return h<EOL>", "docstring": "This is an alternative implementation of the SG coefficients.\n\n    It uses numpy.polyfit and numpy.polyval.  The results should be\n    equivalent to those of savgol_coeffs(), but this implementation\n    is slower.\n\n    window_length should be odd.", "id": "f19237:m2"}
{"signature": "def __init__(self, *args, **kwords):", "body": "N = len(args)<EOL>if N == <NUM_LIT:2>:  <EOL><INDENT>self._num, self._den = normalize(*args)<EOL>self._update(N)<EOL>self.inputs = <NUM_LIT:1><EOL>if len(self.num.shape) > <NUM_LIT:1>:<EOL><INDENT>self.outputs = self.num.shape[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>self.outputs = <NUM_LIT:1><EOL><DEDENT><DEDENT>elif N == <NUM_LIT:3>:      <EOL><INDENT>self._zeros, self._poles, self._gain = args<EOL>self._update(N)<EOL>self.zeros = numpy.asarray(self.zeros)<EOL>self.poles = numpy.asarray(self.poles)<EOL>self.inputs = <NUM_LIT:1><EOL>if len(self.zeros.shape) > <NUM_LIT:1>:<EOL><INDENT>self.outputs = self.zeros.shape[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>self.outputs = <NUM_LIT:1><EOL><DEDENT><DEDENT>elif N == <NUM_LIT:4>:       <EOL><INDENT>self._A, self._B, self._C, self._D = abcd_normalize(*args)<EOL>self._update(N)<EOL>self.inputs = self.B.shape[-<NUM_LIT:1>]<EOL>self.outputs = self.C.shape[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Initialize the LTI system using either:\n\n    - (numerator, denominator)\n    - (zeros, poles, gain)\n    - (A, B, C, D) : state-space.", "id": "f19246:c0:m0"}
{"signature": "def output(self, U, T, X0=None):", "body": "return lsim(self, U, T, X0=X0)<EOL>", "docstring": "Return the response of a continuous-time system to input `U`.\nSee `scipy.signal.lsim` for details.", "id": "f19246:c0:m23"}
{"signature": "def impulse(system, X0=None, T=None, N=None):", "body": "if isinstance(system, lti):<EOL><INDENT>sys = system<EOL><DEDENT>else:<EOL><INDENT>sys = lti(*system)<EOL><DEDENT>if X0 is None:<EOL><INDENT>B = sys.B<EOL><DEDENT>else:<EOL><INDENT>B = sys.B + X0<EOL><DEDENT>if N is None:<EOL><INDENT>N = <NUM_LIT:100><EOL><DEDENT>if T is None:<EOL><INDENT>T = _default_response_times(sys.A, N)<EOL><DEDENT>else:<EOL><INDENT>T = asarray(T)<EOL><DEDENT>h = zeros(T.shape, sys.A.dtype)<EOL>s, v = linalg.eig(sys.A)<EOL>vi = linalg.inv(v)<EOL>C = sys.C<EOL>for k in range(len(h)):<EOL><INDENT>es = diag(numpy.exp(s * T[k]))<EOL>eA = dot(dot(v, es), vi)<EOL>eA = _cast_to_array_dtype(eA, h)<EOL>h[k] = squeeze(dot(dot(C, eA), B))<EOL><DEDENT>return T, h<EOL>", "docstring": "Impulse response of continuous-time system.\n\n    Parameters\n    ----------\n    system : an instance of the LTI class or a tuple of array_like\n        describing the system.\n        The following gives the number of elements in the tuple and\n        the interpretation:\n\n            * 2 (num, den)\n            * 3 (zeros, poles, gain)\n            * 4 (A, B, C, D)\n\n    X0 : array_like, optional\n        Initial state-vector.  Defaults to zero.\n    T : array_like, optional\n        Time points.  Computed if not given.\n    N : int, optional\n        The number of time points to compute (if `T` is not given).\n\n    Returns\n    -------\n    T : ndarray\n        A 1-D array of time points.\n    yout : ndarray\n        A 1-D array containing the impulse response of the system (except for\n        singularities at zero).", "id": "f19246:m14"}
{"signature": "def zpk2ss(z, p, k):", "body": "return tf2ss(*zpk2tf(z, p, k))<EOL>", "docstring": "Zero-pole-gain representation to state-space representation\n\n    Parameters\n    ----------\n    z, p : sequence\n        Zeros and poles.\n    k : float\n        System gain.\n\n    Returns\n    -------\n    A, B, C, D : ndarray\n        State space representation of the system, in controller canonical\n        form.", "id": "f19246:m8"}
{"signature": "def __repr__(self):", "body": "return '<STR_LIT>'.format(<EOL>self.__class__.__name__,<EOL>repr(self.A),<EOL>repr(self.B),<EOL>repr(self.C),<EOL>repr(self.D),<EOL>)<EOL>", "docstring": "Canonical representation using state-space to preserve numerical\nprecision and any MIMO information", "id": "f19246:c0:m1"}
{"signature": "def dstep(system, x0=None, t=None, n=None):", "body": "<EOL>if len(system) == <NUM_LIT:3>:<EOL><INDENT>n_inputs = <NUM_LIT:1><EOL>dt = system[<NUM_LIT:2>]<EOL><DEDENT>elif len(system) == <NUM_LIT:4>:<EOL><INDENT>n_inputs = <NUM_LIT:1><EOL>dt = system[<NUM_LIT:3>]<EOL><DEDENT>elif len(system) == <NUM_LIT:5>:<EOL><INDENT>n_inputs = system[<NUM_LIT:1>].shape[<NUM_LIT:1>]<EOL>dt = system[<NUM_LIT:4>]<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" +<EOL>\"<STR_LIT>\" +<EOL>\"<STR_LIT>\")<EOL><DEDENT>if n is None:<EOL><INDENT>n = <NUM_LIT:100><EOL><DEDENT>if t is None:<EOL><INDENT>t = np.linspace(<NUM_LIT:0>, n * dt, n, endpoint=False)<EOL><DEDENT>yout = None<EOL>for i in range(<NUM_LIT:0>, n_inputs):<EOL><INDENT>u = np.zeros((t.shape[<NUM_LIT:0>], n_inputs))<EOL>u[:,i] = np.ones((t.shape[<NUM_LIT:0>],))<EOL>one_output = dlsim(system, u, t=t, x0=x0)<EOL>if yout is None:<EOL><INDENT>yout = (one_output[<NUM_LIT:1>],)<EOL><DEDENT>else:<EOL><INDENT>yout = yout + (one_output[<NUM_LIT:1>],)<EOL><DEDENT>tout = one_output[<NUM_LIT:0>]<EOL><DEDENT>return tout, yout<EOL>", "docstring": "Step response of discrete-time system.\n\n    Parameters\n    ----------\n    system : a tuple describing the system.\n        The following gives the number of elements in the tuple and\n        the interpretation:\n\n          * 3: (num, den, dt)\n          * 4: (zeros, poles, gain, dt)\n          * 5: (A, B, C, D, dt)\n\n    x0 : array_like, optional\n        Initial state-vector (default is zero).\n    t : array_like, optional\n        Time points (computed if not given).\n    n : int, optional\n        Number of time points to compute if `t` is not given.\n\n    Returns\n    -------\n    t : ndarray\n        Output time points, as a 1-D array.\n    yout : tuple of array_like\n        Step response of system.  Each element of the tuple represents\n        the output of the system based on a step response to each input.\n\n    See Also\n    --------\n    step, dimpulse, dlsim, cont2discrete", "id": "f19247:m2"}
{"signature": "def dimpulse(system, x0=None, t=None, n=None):", "body": "<EOL>if len(system) == <NUM_LIT:3>:<EOL><INDENT>n_inputs = <NUM_LIT:1><EOL>dt = system[<NUM_LIT:2>]<EOL><DEDENT>elif len(system) == <NUM_LIT:4>:<EOL><INDENT>n_inputs = <NUM_LIT:1><EOL>dt = system[<NUM_LIT:3>]<EOL><DEDENT>elif len(system) == <NUM_LIT:5>:<EOL><INDENT>n_inputs = system[<NUM_LIT:1>].shape[<NUM_LIT:1>]<EOL>dt = system[<NUM_LIT:4>]<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" +<EOL>\"<STR_LIT>\" +<EOL>\"<STR_LIT>\")<EOL><DEDENT>if n is None:<EOL><INDENT>n = <NUM_LIT:100><EOL><DEDENT>if t is None:<EOL><INDENT>t = np.linspace(<NUM_LIT:0>, n * dt, n, endpoint=False)<EOL><DEDENT>yout = None<EOL>for i in range(<NUM_LIT:0>, n_inputs):<EOL><INDENT>u = np.zeros((t.shape[<NUM_LIT:0>], n_inputs))<EOL>u[<NUM_LIT:0>,i] = <NUM_LIT:1.0><EOL>one_output = dlsim(system, u, t=t, x0=x0)<EOL>if yout is None:<EOL><INDENT>yout = (one_output[<NUM_LIT:1>],)<EOL><DEDENT>else:<EOL><INDENT>yout = yout + (one_output[<NUM_LIT:1>],)<EOL><DEDENT>tout = one_output[<NUM_LIT:0>]<EOL><DEDENT>return tout, yout<EOL>", "docstring": "Impulse response of discrete-time system.\n\n    Parameters\n    ----------\n    system : tuple\n        The following gives the number of elements in the tuple and\n        the interpretation:\n\n          * 3: (num, den, dt)\n          * 4: (zeros, poles, gain, dt)\n          * 5: (A, B, C, D, dt)\n\n    x0 : array_like, optional\n        Initial state-vector.  Defaults to zero.\n    t : array_like, optional\n        Time points.  Computed if not given.\n    n : int, optional\n        The number of time points to compute (if `t` is not given).\n\n    Returns\n    -------\n    t : ndarray\n        A 1-D array of time points.\n    yout : tuple of array_like\n        Impulse response of system.  Each element of the tuple represents\n        the output of the system based on an impulse in each input.\n\n    See Also\n    --------\n    impulse, dstep, dlsim, cont2discrete", "id": "f19247:m1"}
{"signature": "def correlate2d(in1, in2, mode='<STR_LIT>', boundary='<STR_LIT>', fillvalue=<NUM_LIT:0>):", "body": "in1 = asarray(in1)<EOL>in2 = asarray(in2)<EOL>if mode == '<STR_LIT>':<EOL><INDENT>_check_valid_mode_shapes(in1.shape, in2.shape)<EOL><DEDENT>val = _valfrommode(mode)<EOL>bval = _bvalfromboundary(boundary)<EOL>with warnings.catch_warnings():<EOL><INDENT>warnings.simplefilter('<STR_LIT:ignore>', np.ComplexWarning)<EOL>out = sigtools._convolve2d(in1, in2, <NUM_LIT:0>, val, bval, fillvalue)<EOL><DEDENT>return out<EOL>", "docstring": "Cross-correlate two 2-dimensional arrays.\n\nCross correlate `in1` and `in2` with output size determined by `mode`, and\nboundary conditions determined by `boundary` and `fillvalue`.\n\nParameters\n----------\nin1, in2 : array_like\n    Two-dimensional input arrays to be convolved.\nmode : str {'full', 'valid', 'same'}, optional\n    A string indicating the size of the output:\n\n    ``full``\n       The output is the full discrete linear cross-correlation\n       of the inputs. (Default)\n    ``valid``\n       The output consists only of those elements that do not\n       rely on the zero-padding.\n    ``same``\n       The output is the same size as `in1`, centered\n       with respect to the 'full' output.\n\nboundary : str {'fill', 'wrap', 'symm'}, optional\n    A flag indicating how to handle boundaries:\n\n    ``fill``\n       pad input arrays with fillvalue. (default)\n    ``wrap``\n       circular boundary conditions.\n    ``symm``\n       symmetrical boundary conditions.\n\nfillvalue : scalar, optional\n    Value to fill pad input arrays with. Default is 0.\n\nReturns\n-------\ncorrelate2d : ndarray\n    A 2-dimensional array containing a subset of the discrete linear\n    cross-correlation of `in1` with `in2`.\n\nExamples\n--------\nUse 2D cross-correlation to find the location of a template in a noisy\nimage:\n\n>>> from scipy import signal\n>>> from scipy import misc\n>>> lena = misc.lena() - misc.lena().mean()\n>>> template = np.copy(lena[235:295, 310:370]) # right eye\n>>> template -= template.mean()\n>>> lena = lena + np.random.randn(*lena.shape) * 50 # add noise\n>>> corr = signal.correlate2d(lena, template, boundary='symm', mode='same')\n>>> y, x = np.unravel_index(np.argmax(corr), corr.shape) # find the match\n\n>>> import matplotlib.pyplot as plt\n>>> fig, (ax_orig, ax_template, ax_corr) = plt.subplots(1, 3)\n>>> ax_orig.imshow(lena, cmap='gray')\n>>> ax_orig.set_title('Original')\n>>> ax_orig.set_axis_off()\n>>> ax_template.imshow(template, cmap='gray')\n>>> ax_template.set_title('Template')\n>>> ax_template.set_axis_off()\n>>> ax_corr.imshow(corr, cmap='gray')\n>>> ax_corr.set_title('Cross-correlation')\n>>> ax_corr.set_axis_off()\n>>> ax_orig.plot(x, y, 'ro')\n>>> fig.show()", "id": "f19249:m12"}
{"signature": "def vectorstrength(events, period):", "body": "events = asarray(events)<EOL>period = asarray(period)<EOL>if events.ndim > <NUM_LIT:1>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if period.ndim > <NUM_LIT:1>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>scalarperiod = not period.ndim<EOL>events = atleast_2d(events)<EOL>period = atleast_2d(period)<EOL>if (period <= <NUM_LIT:0>).any():<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>vectors = exp(dot(<NUM_LIT>*pi/period.T, events))<EOL>vectormean = mean(vectors, axis=<NUM_LIT:1>)<EOL>strength = abs(vectormean)<EOL>phase = angle(vectormean)<EOL>if scalarperiod:<EOL><INDENT>strength = strength[<NUM_LIT:0>]<EOL>phase = phase[<NUM_LIT:0>]<EOL><DEDENT>return strength, phase<EOL>", "docstring": "Determine the vector strength of the events corresponding to the given\nperiod.\n\nThe vector strength is a measure of phase synchrony, how well the\ntiming of the events is synchronized to a single period of a periodic\nsignal.\n\nIf multiple periods are used, calculate the vector strength of each.\nThis is called the \"resonating vector strength\".\n\nParameters\n----------\nevents : 1D array_like\n    An array of time points containing the timing of the events.\nperiod : float or array_like\n    The period of the signal that the events should synchronize to.\n    The period is in the same units as `events`.  It can also be an array\n    of periods, in which case the outputs are arrays of the same length.\n\nReturns\n-------\nstrength : float or 1D array\n    The strength of the synchronization.  1.0 is perfect synchronization\n    and 0.0 is no synchronization.  If `period` is an array, this is also\n    an array with each element containing the vector strength at the\n    corresponding period.\nphase : float or array\n    The phase that the events are most strongly synchronized to in radians.\n    If `period` is an array, this is also an array with each element\n    containing the phase for the corresponding period.\n\nReferences\n----------\nvan Hemmen, JL, Longtin, A, and Vollmayr, AN. Testing resonating vector\n    strength: Auditory system, electric fish, and noise.\n    Chaos 21, 047508 (2011);\n    doi: 10.1063/1.3670512\nvan Hemmen, JL.  Vector strength after Goldberg, Brown, and von Mises:\n    biological and mathematical perspectives.  Biol Cybern.\n    2013 Aug;107(4):385-96. doi: 10.1007/s00422-013-0561-7.\nvan Hemmen, JL and Vollmayr, AN.  Resonating vector strength: what happens\n    when we vary the \"probing\" frequency while keeping the spike times\n    fixed.  Biol Cybern. 2013 Aug;107(4):491-94.\n    doi: 10.1007/s00422-013-0560-8", "id": "f19249:m26"}
{"signature": "def hilbert(x, N=None, axis=-<NUM_LIT:1>):", "body": "x = asarray(x)<EOL>if iscomplexobj(x):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if N is None:<EOL><INDENT>N = x.shape[axis]<EOL><DEDENT>if N <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>Xf = fft(x, N, axis=axis)<EOL>h = zeros(N)<EOL>if N % <NUM_LIT:2> == <NUM_LIT:0>:<EOL><INDENT>h[<NUM_LIT:0>] = h[N // <NUM_LIT:2>] = <NUM_LIT:1><EOL>h[<NUM_LIT:1>:N // <NUM_LIT:2>] = <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>h[<NUM_LIT:0>] = <NUM_LIT:1><EOL>h[<NUM_LIT:1>:(N + <NUM_LIT:1>) // <NUM_LIT:2>] = <NUM_LIT:2><EOL><DEDENT>if len(x.shape) > <NUM_LIT:1>:<EOL><INDENT>ind = [newaxis] * x.ndim<EOL>ind[axis] = slice(None)<EOL>h = h[ind]<EOL><DEDENT>x = ifft(Xf * h, axis=axis)<EOL>return x<EOL>", "docstring": "Compute the analytic signal, using the Hilbert transform.\n\nThe transformation is done along the last axis by default.\n\nParameters\n----------\nx : array_like\n    Signal data.  Must be real.\nN : int, optional\n    Number of Fourier components.  Default: ``x.shape[axis]``\naxis : int, optional\n    Axis along which to do the transformation.  Default: -1.\n\nReturns\n-------\nxa : ndarray\n    Analytic signal of `x`, of each 1-D array along `axis`\n\nNotes\n-----\nThe analytic signal ``x_a(t)`` of signal ``x(t)`` is:\n\n.. math:: x_a = F^{-1}(F(x) 2U) = x + i y\n\nwhere `F` is the Fourier transform, `U` the unit step function,\nand `y` the Hilbert transform of `x`. [1]_\n\nIn other words, the negative half of the frequency spectrum is zeroed\nout, turning the real-valued signal into a complex signal.  The Hilbert\ntransformed signal can be obtained from ``np.imag(hilbert(x))``, and the\noriginal signal from ``np.real(hilbert(x))``.\n\nReferences\n----------\n.. [1] Wikipedia, \"Analytic signal\".\n       http://en.wikipedia.org/wiki/Analytic_signal", "id": "f19249:m17"}
{"signature": "def fftconvolve(in1, in2, mode=\"<STR_LIT>\"):", "body": "in1 = asarray(in1)<EOL>in2 = asarray(in2)<EOL>if in1.ndim == in2.ndim == <NUM_LIT:0>:  <EOL><INDENT>return in1 * in2<EOL><DEDENT>elif not in1.ndim == in2.ndim:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>elif in1.size == <NUM_LIT:0> or in2.size == <NUM_LIT:0>:  <EOL><INDENT>return array([])<EOL><DEDENT>s1 = array(in1.shape)<EOL>s2 = array(in2.shape)<EOL>complex_result = (np.issubdtype(in1.dtype, np.complex) or<EOL>np.issubdtype(in2.dtype, np.complex))<EOL>shape = s1 + s2 - <NUM_LIT:1><EOL>if mode == \"<STR_LIT>\":<EOL><INDENT>_check_valid_mode_shapes(s1, s2)<EOL><DEDENT>fshape = [_next_regular(int(d)) for d in shape]<EOL>fslice = tuple([slice(<NUM_LIT:0>, int(sz)) for sz in shape])<EOL>if not complex_result and (_rfft_mt_safe or _rfft_lock.acquire(False)):<EOL><INDENT>try:<EOL><INDENT>ret = irfftn(rfftn(in1, fshape) *<EOL>rfftn(in2, fshape), fshape)[fslice].copy()<EOL><DEDENT>finally:<EOL><INDENT>if not _rfft_mt_safe:<EOL><INDENT>_rfft_lock.release()<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>ret = ifftn(fftn(in1, fshape) * fftn(in2, fshape))[fslice].copy()<EOL>if not complex_result:<EOL><INDENT>ret = ret.real<EOL><DEDENT><DEDENT>if mode == \"<STR_LIT>\":<EOL><INDENT>return ret<EOL><DEDENT>elif mode == \"<STR_LIT>\":<EOL><INDENT>return _centered(ret, s1)<EOL><DEDENT>elif mode == \"<STR_LIT>\":<EOL><INDENT>return _centered(ret, s1 - s2 + <NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Convolve two N-dimensional arrays using FFT.\n\n    Convolve `in1` and `in2` using the fast Fourier transform method, with\n    the output size determined by the `mode` argument.\n\n    This is generally much faster than `convolve` for large arrays (n > ~500),\n    but can be slower when only a few output values are needed, and can only\n    output float arrays (int or object array inputs will be cast to float).\n\n    Parameters\n    ----------\n    in1 : array_like\n        First input.\n    in2 : array_like\n        Second input. Should have the same number of dimensions as `in1`;\n        if sizes of `in1` and `in2` are not equal then `in1` has to be the\n        larger array.\n    mode : str {'full', 'valid', 'same'}, optional\n        A string indicating the size of the output:\n\n        ``full``\n           The output is the full discrete linear convolution\n           of the inputs. (Default)\n        ``valid``\n           The output consists only of those elements that do not\n           rely on the zero-padding.\n        ``same``\n           The output is the same size as `in1`, centered\n           with respect to the 'full' output.\n\n    Returns\n    -------\n    out : array\n        An N-dimensional array containing a subset of the discrete linear\n        convolution of `in1` with `in2`.\n\n    Examples\n    --------\n    Autocorrelation of white noise is an impulse.  (This is at least 100 times\n    as fast as `convolve`.)\n\n    >>> from scipy import signal\n    >>> sig = np.random.randn(1000)\n    >>> autocorr = signal.fftconvolve(sig, sig[::-1], mode='full')\n\n    >>> import matplotlib.pyplot as plt\n    >>> fig, (ax_orig, ax_mag) = plt.subplots(2, 1)\n    >>> ax_orig.plot(sig)\n    >>> ax_orig.set_title('White noise')\n    >>> ax_mag.plot(np.arange(-len(sig)+1,len(sig)), autocorr)\n    >>> ax_mag.set_title('Autocorrelation')\n    >>> fig.show()\n\n    Gaussian blur implemented using FFT convolution.  Notice the dark borders\n    around the image, due to the zero-padding beyond its boundaries.\n    The `convolve2d` function allows for other types of image boundaries,\n    but is far slower.\n\n    >>> from scipy import misc\n    >>> lena = misc.lena()\n    >>> kernel = np.outer(signal.gaussian(70, 8), signal.gaussian(70, 8))\n    >>> blurred = signal.fftconvolve(lena, kernel, mode='same')\n\n    >>> fig, (ax_orig, ax_kernel, ax_blurred) = plt.subplots(1, 3)\n    >>> ax_orig.imshow(lena, cmap='gray')\n    >>> ax_orig.set_title('Original')\n    >>> ax_orig.set_axis_off()\n    >>> ax_kernel.imshow(kernel, cmap='gray')\n    >>> ax_kernel.set_title('Gaussian kernel')\n    >>> ax_kernel.set_axis_off()\n    >>> ax_blurred.imshow(blurred, cmap='gray')\n    >>> ax_blurred.set_title('Blurred')\n    >>> ax_blurred.set_axis_off()\n    >>> fig.show()", "id": "f19249:m6"}
{"signature": "def wiener(im, mysize=None, noise=None):", "body": "im = asarray(im)<EOL>if mysize is None:<EOL><INDENT>mysize = [<NUM_LIT:3>] * len(im.shape)<EOL><DEDENT>mysize = asarray(mysize)<EOL>if mysize.shape == ():<EOL><INDENT>mysize = np.repeat(mysize.item(), im.ndim)<EOL><DEDENT>lMean = correlate(im, ones(mysize), '<STR_LIT>') / product(mysize, axis=<NUM_LIT:0>)<EOL>lVar = (correlate(im ** <NUM_LIT:2>, ones(mysize), '<STR_LIT>') / product(mysize, axis=<NUM_LIT:0>)<EOL>- lMean ** <NUM_LIT:2>)<EOL>if noise is None:<EOL><INDENT>noise = mean(ravel(lVar), axis=<NUM_LIT:0>)<EOL><DEDENT>res = (im - lMean)<EOL>res *= (<NUM_LIT:1> - noise / lVar)<EOL>res += lMean<EOL>out = where(lVar < noise, lMean, res)<EOL>return out<EOL>", "docstring": "Perform a Wiener filter on an N-dimensional array.\n\nApply a Wiener filter to the N-dimensional array `im`.\n\nParameters\n----------\nim : ndarray\n    An N-dimensional array.\nmysize : int or arraylike, optional\n    A scalar or an N-length list giving the size of the Wiener filter\n    window in each dimension.  Elements of mysize should be odd.\n    If mysize is a scalar, then this scalar is used as the size\n    in each dimension.\nnoise : float, optional\n    The noise-power to use. If None, then noise is estimated as the\n    average of the local variance of the input.\n\nReturns\n-------\nout : ndarray\n    Wiener filtered result with the same shape as `im`.", "id": "f19249:m10"}
{"signature": "def deconvolve(signal, divisor):", "body": "num = atleast_1d(signal)<EOL>den = atleast_1d(divisor)<EOL>N = len(num)<EOL>D = len(den)<EOL>if D > N:<EOL><INDENT>quot = []<EOL>rem = num<EOL><DEDENT>else:<EOL><INDENT>input = ones(N - D + <NUM_LIT:1>, float)<EOL>input[<NUM_LIT:1>:] = <NUM_LIT:0><EOL>quot = lfilter(num, den, input)<EOL>rem = num - convolve(den, quot, mode='<STR_LIT>')<EOL><DEDENT>return quot, rem<EOL>", "docstring": "Deconvolves `divisor` out of `signal`.\n\n    Returns the quotient and remainder such that\n    ``signal = convolve(divisor, quotient) + remainder``\n\n    Parameters\n    ----------\n    signal : array_like\n        Signal data, typically a recorded signal\n    divisor : array_like\n        Divisor data, typically an impulse response or filter that was\n        applied to the original signal\n\n    Returns\n    -------\n    quotient : ndarray\n        Quotient, typically the recovered original signal\n    remainder : ndarray\n        Remainder\n\n    Examples\n    --------\n    Deconvolve a signal that's been filtered:\n\n    >>> from scipy import signal\n    >>> original = [0, 1, 0, 0, 1, 1, 0, 0]\n    >>> impulse_response = [2, 1]\n    >>> recorded = signal.convolve(impulse_response, original)\n    >>> recorded\n    array([0, 2, 1, 0, 2, 3, 1, 0, 0])\n    >>> recovered, remainder = signal.deconvolve(recorded, impulse_response)\n    >>> recovered\n    array([ 0.,  1.,  0.,  0.,  1.,  1.,  0.,  0.])\n\n    See also\n    --------\n    numpy.polydiv : performs polynomial division (same operation, but\n                    also accepts poly1d objects)", "id": "f19249:m16"}
{"signature": "def correlate(in1, in2, mode='<STR_LIT>'):", "body": "in1 = asarray(in1)<EOL>in2 = asarray(in2)<EOL>try:<EOL><INDENT>val = _modedict[mode]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>if in1.ndim == in2.ndim == <NUM_LIT:0>:<EOL><INDENT>return in1 * in2<EOL><DEDENT>elif not in1.ndim == in2.ndim:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if mode == '<STR_LIT>':<EOL><INDENT>_check_valid_mode_shapes(in1.shape, in2.shape)<EOL>ps = [i - j + <NUM_LIT:1> for i, j in zip(in1.shape, in2.shape)]<EOL>out = np.empty(ps, in1.dtype)<EOL>z = sigtools._correlateND(in1, in2, out, val)<EOL><DEDENT>else:<EOL><INDENT>swapped_inputs = (mode == '<STR_LIT>') and (in2.size > in1.size)<EOL>if swapped_inputs:<EOL><INDENT>in1, in2 = in2, in1<EOL><DEDENT>ps = [i + j - <NUM_LIT:1> for i, j in zip(in1.shape, in2.shape)]<EOL>in1zpadded = np.zeros(ps, in1.dtype)<EOL>sc = [slice(<NUM_LIT:0>, i) for i in in1.shape]<EOL>in1zpadded[sc] = in1.copy()<EOL>if mode == '<STR_LIT>':<EOL><INDENT>out = np.empty(ps, in1.dtype)<EOL><DEDENT>elif mode == '<STR_LIT>':<EOL><INDENT>out = np.empty(in1.shape, in1.dtype)<EOL><DEDENT>z = sigtools._correlateND(in1zpadded, in2, out, val)<EOL>if swapped_inputs:<EOL><INDENT>slice_obj = [slice(None, None, -<NUM_LIT:1>)] * len(z.shape)<EOL>z = z[slice_obj].conj()<EOL><DEDENT><DEDENT>return z<EOL>", "docstring": "Cross-correlate two N-dimensional arrays.\n\nCross-correlate `in1` and `in2`, with the output size determined by the\n`mode` argument.\n\nParameters\n----------\nin1 : array_like\n    First input.\nin2 : array_like\n    Second input. Should have the same number of dimensions as `in1`;\n    if sizes of `in1` and `in2` are not equal then `in1` has to be the\n    larger array.\nmode : str {'full', 'valid', 'same'}, optional\n    A string indicating the size of the output:\n\n    ``full``\n       The output is the full discrete linear cross-correlation\n       of the inputs. (Default)\n    ``valid``\n       The output consists only of those elements that do not\n       rely on the zero-padding.\n    ``same``\n       The output is the same size as `in1`, centered\n       with respect to the 'full' output.\n\nReturns\n-------\ncorrelate : array\n    An N-dimensional array containing a subset of the discrete linear\n    cross-correlation of `in1` with `in2`.\n\nNotes\n-----\nThe correlation z of two d-dimensional arrays x and y is defined as:\n\n  z[...,k,...] = sum[..., i_l, ...]\n                     x[..., i_l,...] * conj(y[..., i_l + k,...])\n\nExamples\n--------\nImplement a matched filter using cross-correlation, to recover a signal\nthat has passed through a noisy channel.\n\n>>> from scipy import signal\n>>> sig = np.repeat([0., 1., 1., 0., 1., 0., 0., 1.], 128)\n>>> sig_noise = sig + np.random.randn(len(sig))\n>>> corr = signal.correlate(sig_noise, np.ones(128), mode='same') / 128\n\n>>> import matplotlib.pyplot as plt\n>>> clock = np.arange(64, len(sig), 128)\n>>> fig, (ax_orig, ax_noise, ax_corr) = plt.subplots(3, 1, sharex=True)\n>>> ax_orig.plot(sig)\n>>> ax_orig.plot(clock, sig[clock], 'ro')\n>>> ax_orig.set_title('Original signal')\n>>> ax_noise.plot(sig_noise)\n>>> ax_noise.set_title('Signal with noise')\n>>> ax_corr.plot(corr)\n>>> ax_corr.plot(clock, corr[clock], 'ro')\n>>> ax_corr.axhline(0.5, ls=':')\n>>> ax_corr.set_title('Cross-correlated with rectangular pulse')\n>>> ax_orig.margins(0, 0.1)\n>>> fig.show()", "id": "f19249:m3"}
{"signature": "def convolve(in1, in2, mode='<STR_LIT>'):", "body": "volume = asarray(in1)<EOL>kernel = asarray(in2)<EOL>if volume.ndim == kernel.ndim == <NUM_LIT:0>:<EOL><INDENT>return volume * kernel<EOL><DEDENT>slice_obj = [slice(None, None, -<NUM_LIT:1>)] * len(kernel.shape)<EOL>if np.iscomplexobj(kernel):<EOL><INDENT>return correlate(volume, kernel[slice_obj].conj(), mode)<EOL><DEDENT>else:<EOL><INDENT>return correlate(volume, kernel[slice_obj], mode)<EOL><DEDENT>", "docstring": "Convolve two N-dimensional arrays.\n\nConvolve `in1` and `in2`, with the output size determined by the\n`mode` argument.\n\nParameters\n----------\nin1 : array_like\n    First input.\nin2 : array_like\n    Second input. Should have the same number of dimensions as `in1`;\n    if sizes of `in1` and `in2` are not equal then `in1` has to be the\n    larger array.\nmode : str {'full', 'valid', 'same'}, optional\n    A string indicating the size of the output:\n\n    ``full``\n       The output is the full discrete linear convolution\n       of the inputs. (Default)\n    ``valid``\n       The output consists only of those elements that do not\n       rely on the zero-padding.\n    ``same``\n       The output is the same size as `in1`, centered\n       with respect to the 'full' output.\n\nReturns\n-------\nconvolve : array\n    An N-dimensional array containing a subset of the discrete linear\n    convolution of `in1` with `in2`.\n\nSee also\n--------\nnumpy.polymul : performs polynomial multiplication (same operation, but\n                also accepts poly1d objects)", "id": "f19249:m7"}
{"signature": "def cascade(hk, J=<NUM_LIT:7>):", "body": "N = len(hk) - <NUM_LIT:1><EOL>if (J > <NUM_LIT:30> - np.log2(N + <NUM_LIT:1>)):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if (J < <NUM_LIT:1>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>nn, kk = np.ogrid[:N, :N]<EOL>s2 = np.sqrt(<NUM_LIT:2>)<EOL>thk = np.r_[hk, <NUM_LIT:0>]<EOL>gk = qmf(hk)<EOL>tgk = np.r_[gk, <NUM_LIT:0>]<EOL>indx1 = np.clip(<NUM_LIT:2> * nn - kk, -<NUM_LIT:1>, N + <NUM_LIT:1>)<EOL>indx2 = np.clip(<NUM_LIT:2> * nn - kk + <NUM_LIT:1>, -<NUM_LIT:1>, N + <NUM_LIT:1>)<EOL>m = np.zeros((<NUM_LIT:2>, <NUM_LIT:2>, N, N), '<STR_LIT:d>')<EOL>m[<NUM_LIT:0>, <NUM_LIT:0>] = np.take(thk, indx1, <NUM_LIT:0>)<EOL>m[<NUM_LIT:0>, <NUM_LIT:1>] = np.take(thk, indx2, <NUM_LIT:0>)<EOL>m[<NUM_LIT:1>, <NUM_LIT:0>] = np.take(tgk, indx1, <NUM_LIT:0>)<EOL>m[<NUM_LIT:1>, <NUM_LIT:1>] = np.take(tgk, indx2, <NUM_LIT:0>)<EOL>m *= s2<EOL>x = np.arange(<NUM_LIT:0>, N * (<NUM_LIT:1> << J), dtype=np.float) / (<NUM_LIT:1> << J)<EOL>phi = <NUM_LIT:0> * x<EOL>psi = <NUM_LIT:0> * x<EOL>lam, v = eig(m[<NUM_LIT:0>, <NUM_LIT:0>])<EOL>ind = np.argmin(np.absolute(lam - <NUM_LIT:1>))<EOL>v = np.real(v[:, ind])<EOL>sm = np.sum(v)<EOL>if sm < <NUM_LIT:0>:  <EOL><INDENT>v = -v<EOL>sm = -sm<EOL><DEDENT>bitdic = {}<EOL>bitdic['<STR_LIT:0>'] = v / sm<EOL>bitdic['<STR_LIT:1>'] = np.dot(m[<NUM_LIT:0>, <NUM_LIT:1>], bitdic['<STR_LIT:0>'])<EOL>step = <NUM_LIT:1> << J<EOL>phi[::step] = bitdic['<STR_LIT:0>']<EOL>phi[(<NUM_LIT:1> << (J - <NUM_LIT:1>))::step] = bitdic['<STR_LIT:1>']<EOL>psi[::step] = np.dot(m[<NUM_LIT:1>, <NUM_LIT:0>], bitdic['<STR_LIT:0>'])<EOL>psi[(<NUM_LIT:1> << (J - <NUM_LIT:1>))::step] = np.dot(m[<NUM_LIT:1>, <NUM_LIT:1>], bitdic['<STR_LIT:0>'])<EOL>prevkeys = ['<STR_LIT:1>']<EOL>for level in range(<NUM_LIT:2>, J + <NUM_LIT:1>):<EOL><INDENT>newkeys = ['<STR_LIT>' % (xx, yy) for xx in [<NUM_LIT:0>, <NUM_LIT:1>] for yy in prevkeys]<EOL>fac = <NUM_LIT:1> << (J - level)<EOL>for key in newkeys:<EOL><INDENT>num = <NUM_LIT:0><EOL>for pos in range(level):<EOL><INDENT>if key[pos] == '<STR_LIT:1>':<EOL><INDENT>num += (<NUM_LIT:1> << (level - <NUM_LIT:1> - pos))<EOL><DEDENT><DEDENT>pastphi = bitdic[key[<NUM_LIT:1>:]]<EOL>ii = int(key[<NUM_LIT:0>])<EOL>temp = np.dot(m[<NUM_LIT:0>, ii], pastphi)<EOL>bitdic[key] = temp<EOL>phi[num * fac::step] = temp<EOL>psi[num * fac::step] = np.dot(m[<NUM_LIT:1>, ii], pastphi)<EOL><DEDENT>prevkeys = newkeys<EOL><DEDENT>return x, phi, psi<EOL>", "docstring": "Return (x, phi, psi) at dyadic points ``K/2**J`` from filter coefficients.\n\nParameters\n----------\nhk : array_like\n    Coefficients of low-pass filter.\nJ : int, optional\n    Values will be computed at grid points ``K/2**J``. Default is 7.\n\nReturns\n-------\nx : ndarray\n    The dyadic points ``K/2**J`` for ``K=0...N * (2**J)-1`` where\n    ``len(hk) = len(gk) = N+1``.\nphi : ndarray\n    The scaling function ``phi(x)`` at `x`:\n    ``phi(x) = sum(hk * phi(2x-k))``, where k is from 0 to N.\npsi : ndarray, optional\n    The wavelet function ``psi(x)`` at `x`:\n    ``phi(x) = sum(gk * phi(2x-k))``, where k is from 0 to N.\n    `psi` is only returned if `gk` is not None.\n\nNotes\n-----\nThe algorithm uses the vector cascade algorithm described by Strang and\nNguyen in \"Wavelets and Filter Banks\".  It builds a dictionary of values\nand slices for quick reuse.  Then inserts vectors into final vector at the\nend.", "id": "f19250:m2"}
{"signature": "def remez(numtaps, bands, desired, weight=None, Hz=<NUM_LIT:1>, type='<STR_LIT>',<EOL>maxiter=<NUM_LIT>, grid_density=<NUM_LIT:16>):", "body": "<EOL>try:<EOL><INDENT>tnum = {'<STR_LIT>': <NUM_LIT:1>, '<STR_LIT>': <NUM_LIT:2>, '<STR_LIT>': <NUM_LIT:3>}[type]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>if weight is None:<EOL><INDENT>weight = [<NUM_LIT:1>] * len(desired)<EOL><DEDENT>bands = np.asarray(bands).copy()<EOL>return sigtools._remez(numtaps, bands, desired, weight, tnum, Hz,<EOL>maxiter, grid_density)<EOL>", "docstring": "Calculate the minimax optimal filter using the Remez exchange algorithm.\n\nCalculate the filter-coefficients for the finite impulse response\n(FIR) filter whose transfer function minimizes the maximum error\nbetween the desired gain and the realized gain in the specified\nfrequency bands using the Remez exchange algorithm.\n\nParameters\n----------\nnumtaps : int\n    The desired number of taps in the filter. The number of taps is\n    the number of terms in the filter, or the filter order plus one.\nbands : array_like\n    A monotonic sequence containing the band edges in Hz.\n    All elements must be non-negative and less than half the sampling\n    frequency as given by `Hz`.\ndesired : array_like\n    A sequence half the size of bands containing the desired gain\n    in each of the specified bands.\nweight : array_like, optional\n    A relative weighting to give to each band region. The length of\n    `weight` has to be half the length of `bands`.\nHz : scalar, optional\n    The sampling frequency in Hz. Default is 1.\ntype : {'bandpass', 'differentiator', 'hilbert'}, optional\n    The type of filter:\n\n      'bandpass' : flat response in bands. This is the default.\n\n      'differentiator' : frequency proportional response in bands.\n\n      'hilbert' : filter with odd symmetry, that is, type III\n                  (for even order) or type IV (for odd order)\n                  linear phase filters.\n\nmaxiter : int, optional\n    Maximum number of iterations of the algorithm. Default is 25.\ngrid_density : int, optional\n    Grid density. The dense grid used in `remez` is of size\n    ``(numtaps + 1) * grid_density``. Default is 16.\n\nReturns\n-------\nout : ndarray\n    A rank-1 array containing the coefficients of the optimal\n    (in a minimax sense) filter.\n\nSee Also\n--------\nfreqz : Compute the frequency response of a digital filter.\n\nReferences\n----------\n.. [1] J. H. McClellan and T. W. Parks, \"A unified approach to the\n       design of optimum FIR linear phase digital filters\",\n       IEEE Trans. Circuit Theory, vol. CT-20, pp. 697-701, 1973.\n.. [2] J. H. McClellan, T. W. Parks and L. R. Rabiner, \"A Computer\n       Program for Designing Optimum FIR Linear Phase Digital\n       Filters\", IEEE Trans. Audio Electroacoust., vol. AU-21,\n       pp. 506-525, 1973.\n\nExamples\n--------\nWe want to construct a filter with a passband at 0.2-0.4 Hz, and\nstop bands at 0-0.1 Hz and 0.45-0.5 Hz. Note that this means that the\nbehavior in the frequency ranges between those bands is unspecified and\nmay overshoot.\n\n>>> from scipy import signal\n>>> bpass = signal.remez(72, [0, 0.1, 0.2, 0.4, 0.45, 0.5], [0, 1, 0])\n>>> freq, response = signal.freqz(bpass)\n>>> ampl = np.abs(response)\n\n>>> import matplotlib.pyplot as plt\n>>> fig = plt.figure()\n>>> ax1 = fig.add_subplot(111)\n>>> ax1.semilogy(freq/(2*np.pi), ampl, 'b-')  # freq in Hz\n>>> plt.show()", "id": "f19251:m5"}
{"signature": "def kaiserord(ripple, width):", "body": "A = abs(ripple)  <EOL>if A < <NUM_LIT:8>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % A)<EOL><DEDENT>beta = kaiser_beta(A)<EOL>numtaps = (A - <NUM_LIT>) / <NUM_LIT> / (np.pi * width) + <NUM_LIT:1><EOL>return int(ceil(numtaps)), beta<EOL>", "docstring": "Design a Kaiser window to limit ripple and width of transition region.\n\nParameters\n----------\nripple : float\n    Positive number specifying maximum ripple in passband (dB) and minimum\n    ripple in stopband.\nwidth : float\n    Width of transition region (normalized so that 1 corresponds to pi\n    radians / sample).\n\nReturns\n-------\nnumtaps : int\n    The length of the kaiser window.\nbeta : float\n    The beta parameter for the kaiser window.\n\nSee Also\n--------\nkaiser_beta, kaiser_atten\n\nNotes\n-----\nThere are several ways to obtain the Kaiser window:\n\n- ``signal.kaiser(numtaps, beta, sym=0)``\n- ``signal.get_window(beta, numtaps)``\n- ``signal.get_window(('kaiser', beta), numtaps)``\n\nThe empirical equations discovered by Kaiser are used.\n\nReferences\n----------\nOppenheim, Schafer, \"Discrete-Time Signal Processing\", p.475-476.", "id": "f19251:m2"}
{"signature": "def savgol_filter(x, window_length, polyorder, deriv=<NUM_LIT:0>, delta=<NUM_LIT:1.0>,<EOL>axis=-<NUM_LIT:1>, mode='<STR_LIT>', cval=<NUM_LIT:0.0>):", "body": "if mode not in [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>x = np.asarray(x)<EOL>if x.dtype != np.float64 and x.dtype != np.float32:<EOL><INDENT>x = x.astype(np.float64)<EOL><DEDENT>coeffs = savgol_coeffs(window_length, polyorder, deriv=deriv, delta=delta)<EOL>if mode == \"<STR_LIT>\":<EOL><INDENT>y = convolve1d(x, coeffs, axis=axis, mode=\"<STR_LIT>\")<EOL>_fit_edges_polyfit(x, window_length, polyorder, deriv, delta, axis, y)<EOL><DEDENT>else:<EOL><INDENT>y = convolve1d(x, coeffs, axis=axis, mode=mode, cval=cval)<EOL><DEDENT>return y<EOL>", "docstring": "Apply a Savitzky-Golay filter to an array.\n\n    This is a 1-d filter.  If `x`  has dimension greater than 1, `axis`\n    determines the axis along which the filter is applied.\n\n    Parameters\n    ----------\n    x : array_like\n        The data to be filtered.  If `x` is not a single or double precision\n        floating point array, it will be converted to type `numpy.float64`\n        before filtering.\n    window_length : int\n        The length of the filter window (i.e. the number of coefficients).\n        `window_length` must be a positive odd integer.\n    polyorder : int\n        The order of the polynomial used to fit the samples.\n        `polyorder` must be less than `window_length`.\n    deriv : int, optional\n        The order of the derivative to compute.  This must be a\n        nonnegative integer.  The default is 0, which means to filter\n        the data without differentiating.\n    delta : float, optional\n        The spacing of the samples to which the filter will be applied.\n        This is only used if deriv > 0.  Default is 1.0.\n    axis : int, optional\n        The axis of the array `x` along which the filter is to be applied.\n        Default is -1.\n    mode : str, optional\n        Must be 'mirror', 'constant', 'nearest', 'wrap' or 'interp'.  This\n        determines the type of extension to use for the padded signal to\n        which the filter is applied.  When `mode` is 'constant', the padding\n        value is given by `cval`.  See the Notes for more details on 'mirror',\n        'constant', 'wrap', and 'nearest'.\n        When the 'interp' mode is selected (the default), no extension\n        is used.  Instead, a degree `polyorder` polynomial is fit to the\n        last `window_length` values of the edges, and this polynomial is\n        used to evaluate the last `window_length // 2` output values.\n    cval : scalar, optional\n        Value to fill past the edges of the input if `mode` is 'constant'.\n        Default is 0.0.\n\n    Returns\n    -------\n    y : ndarray, same shape as `x`\n        The filtered data.\n\n    See Also\n    --------\n    savgol_coeffs\n\n    Notes\n    -----\n    Details on the `mode` options:\n\n        'mirror':\n            Repeats the values at the edges in reverse order.  The value\n            closest to the edge is not included.\n        'nearest':\n            The extension contains the nearest input value.\n        'constant':\n            The extension contains the value given by the `cval` argument.\n        'wrap':\n            The extension contains the values from the other end of the array.\n\n    For example, if the input is [1, 2, 3, 4, 5, 6, 7, 8], and\n    `window_length` is 7, the following shows the extended data for\n    the various `mode` options (assuming `cval` is 0)::\n\n        mode       |   Ext   |         Input          |   Ext\n        -----------+---------+------------------------+---------\n        'mirror'   | 4  3  2 | 1  2  3  4  5  6  7  8 | 7  6  5\n        'nearest'  | 1  1  1 | 1  2  3  4  5  6  7  8 | 8  8  8\n        'constant' | 0  0  0 | 1  2  3  4  5  6  7  8 | 0  0  0\n        'wrap'     | 6  7  8 | 1  2  3  4  5  6  7  8 | 1  2  3\n\n    .. versionadded:: 0.14.0\n\n    Examples\n    --------\n    >>> np.set_printoptions(precision=2)  # For compact display.\n    >>> x = np.array([2, 2, 5, 2, 1, 0, 1, 4, 9])\n\n    Filter with a window length of 5 and a degree 2 polynomial.  Use\n    the defaults for all other parameters.\n\n    >>> y = savgol_filter(x, 5, 2)\n    array([ 1.66,  3.17,  3.54,  2.86,  0.66,  0.17,  1.  ,  4.  ,  9.  ])\n\n    Note that the last five values in x are samples of a parabola, so\n    when mode='interp' (the default) is used with polyorder=2, the last\n    three values are unchanged.  Compare that to, for example,\n    `mode='nearest'`:\n\n    >>> savgol_filter(x, 5, 2, mode='nearest')\n    array([ 1.74,  3.03,  3.54,  2.86,  0.66,  0.17,  1.  ,  4.6 ,  7.97])", "id": "f19252:m4"}
{"signature": "def _polyder(p, m):", "body": "if m == <NUM_LIT:0>:<EOL><INDENT>result = p<EOL><DEDENT>else:<EOL><INDENT>n = len(p)<EOL>if n <= m:<EOL><INDENT>result = np.zeros_like(p[:<NUM_LIT:1>, ...])<EOL><DEDENT>else:<EOL><INDENT>dp = p[:-m].copy()<EOL>for k in range(m):<EOL><INDENT>rng = np.arange(n - k - <NUM_LIT:1>, m - k - <NUM_LIT:1>, -<NUM_LIT:1>)<EOL>dp *= rng.reshape((n - m,) + (<NUM_LIT:1>,) * (p.ndim - <NUM_LIT:1>))<EOL><DEDENT>result = dp<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Differentiate polynomials represented with coefficients.\n\n    p must be a 1D or 2D array.  In the 2D case, each column gives\n    the coefficients of a polynomial; the first row holds the coefficients\n    associated with the highest power.  m must be a nonnegative integer.\n    (numpy.polyder doesn't handle the 2D case.)", "id": "f19252:m1"}
{"signature": "def argrelmin(data, axis=<NUM_LIT:0>, order=<NUM_LIT:1>, mode='<STR_LIT>'):", "body": "return argrelextrema(data, np.less, axis, order, mode)<EOL>", "docstring": "Calculate the relative minima of `data`.\n\nParameters\n----------\ndata : ndarray\n    Array in which to find the relative minima.\naxis : int, optional\n    Axis over which to select from `data`.  Default is 0.\norder : int, optional\n    How many points on each side to use for the comparison\n    to consider ``comparator(n, n+x)`` to be True.\nmode : str, optional\n    How the edges of the vector are treated.\n    Available options are 'wrap' (wrap around) or 'clip' (treat overflow\n    as the same as the last (or first) element).\n    Default 'clip'. See numpy.take\n\nReturns\n-------\nextrema : tuple of ndarrays\n    Indices of the minima in arrays of integers.  ``extrema[k]`` is\n    the array of indices of axis `k` of `data`.  Note that the\n    return value is a tuple even when `data` is one-dimensional.\n\nSee Also\n--------\nargrelextrema, argrelmax\n\nNotes\n-----\nThis function uses `argrelextrema` with np.less as comparator.\n\n.. versionadded:: 0.11.0\n\nExamples\n--------\n>>> x = np.array([2, 1, 2, 3, 2, 0, 1, 0])\n>>> argrelmin(x)\n(array([1, 5]),)\n>>> y = np.array([[1, 2, 1, 2],\n...               [2, 2, 0, 0],\n...               [5, 3, 4, 4]])\n...\n>>> argrelmin(y, axis=1)\n(array([0, 2]), array([2, 1]))", "id": "f19254:m1"}
{"signature": "def argrelextrema(data, comparator, axis=<NUM_LIT:0>, order=<NUM_LIT:1>, mode='<STR_LIT>'):", "body": "results = _boolrelextrema(data, comparator,<EOL>axis, order, mode)<EOL>return np.where(results)<EOL>", "docstring": "Calculate the relative extrema of `data`.\n\nParameters\n----------\ndata : ndarray\n    Array in which to find the relative extrema.\ncomparator : callable\n    Function to use to compare two data points.\n    Should take 2 numbers as arguments.\naxis : int, optional\n    Axis over which to select from `data`.  Default is 0.\norder : int, optional\n    How many points on each side to use for the comparison\n    to consider ``comparator(n, n+x)`` to be True.\nmode : str, optional\n    How the edges of the vector are treated.  'wrap' (wrap around) or\n    'clip' (treat overflow as the same as the last (or first) element).\n    Default is 'clip'.  See `numpy.take`.\n\nReturns\n-------\nextrema : tuple of ndarrays\n    Indices of the maxima in arrays of integers.  ``extrema[k]`` is\n    the array of indices of axis `k` of `data`.  Note that the\n    return value is a tuple even when `data` is one-dimensional.\n\nSee Also\n--------\nargrelmin, argrelmax\n\nNotes\n-----\n\n.. versionadded:: 0.11.0\n\nExamples\n--------\n>>> x = np.array([2, 1, 2, 3, 2, 0, 1, 0])\n>>> argrelextrema(x, np.greater)\n(array([3, 6]),)\n>>> y = np.array([[1, 2, 1, 2],\n...               [2, 2, 0, 0],\n...               [5, 3, 4, 4]])\n...\n>>> argrelextrema(y, np.less, axis=1)\n(array([0, 2]), array([2, 1]))", "id": "f19254:m3"}
{"signature": "def argrelmax(data, axis=<NUM_LIT:0>, order=<NUM_LIT:1>, mode='<STR_LIT>'):", "body": "return argrelextrema(data, np.greater, axis, order, mode)<EOL>", "docstring": "Calculate the relative maxima of `data`.\n\nParameters\n----------\ndata : ndarray\n    Array in which to find the relative maxima.\naxis : int, optional\n    Axis over which to select from `data`.  Default is 0.\norder : int, optional\n    How many points on each side to use for the comparison\n    to consider ``comparator(n, n+x)`` to be True.\nmode : str, optional\n    How the edges of the vector are treated.\n    Available options are 'wrap' (wrap around) or 'clip' (treat overflow\n    as the same as the last (or first) element).\n    Default 'clip'.  See `numpy.take`.\n\nReturns\n-------\nextrema : tuple of ndarrays\n    Indices of the maxima in arrays of integers.  ``extrema[k]`` is\n    the array of indices of axis `k` of `data`.  Note that the\n    return value is a tuple even when `data` is one-dimensional.\n\nSee Also\n--------\nargrelextrema, argrelmin\n\nNotes\n-----\nThis function uses `argrelextrema` with np.greater as comparator.\n\n.. versionadded:: 0.11.0\n\nExamples\n--------\n>>> x = np.array([2, 1, 2, 3, 2, 0, 1, 0])\n>>> argrelmax(x)\n(array([3, 6]),)\n>>> y = np.array([[1, 2, 1, 2],\n...               [2, 2, 0, 0],\n...               [5, 3, 4, 4]])\n...\n>>> argrelmax(y, axis=1)\n(array([0]), array([1]))", "id": "f19254:m2"}
{"signature": "def freqs(b, a, worN=None, plot=None):", "body": "if worN is None:<EOL><INDENT>w = findfreqs(b, a, <NUM_LIT:200>)<EOL><DEDENT>elif isinstance(worN, int):<EOL><INDENT>N = worN<EOL>w = findfreqs(b, a, N)<EOL><DEDENT>else:<EOL><INDENT>w = worN<EOL><DEDENT>w = atleast_1d(w)<EOL>s = <NUM_LIT> * w<EOL>h = polyval(b, s) / polyval(a, s)<EOL>if plot is not None:<EOL><INDENT>plot(w, h)<EOL><DEDENT>return w, h<EOL>", "docstring": "Compute frequency response of analog filter.\n\nGiven the numerator `b` and denominator `a` of a filter, compute its\nfrequency response::\n\n         b[0]*(jw)**(nb-1) + b[1]*(jw)**(nb-2) + ... + b[nb-1]\n H(w) = -------------------------------------------------------\n         a[0]*(jw)**(na-1) + a[1]*(jw)**(na-2) + ... + a[na-1]\n\nParameters\n----------\nb : ndarray\n    Numerator of a linear filter.\na : ndarray\n    Denominator of a linear filter.\nworN : {None, int}, optional\n    If None, then compute at 200 frequencies around the interesting parts\n    of the response curve (determined by pole-zero locations).  If a single\n    integer, then compute at that many frequencies.  Otherwise, compute the\n    response at the angular frequencies (e.g. rad/s) given in `worN`.\nplot : callable\n    A callable that takes two arguments. If given, the return parameters\n    `w` and `h` are passed to plot. Useful for plotting the frequency\n    response inside `freqs`.\n\nReturns\n-------\nw : ndarray\n    The angular frequencies at which h was computed.\nh : ndarray\n    The frequency response.\n\nSee Also\n--------\nfreqz : Compute the frequency response of a digital filter.\n\nNotes\n-----\nUsing Matplotlib's \"plot\" function as the callable for `plot` produces\nunexpected results,  this plots the real part of the complex transfer\nfunction, not the magnitude.  Try ``lambda w, h: plot(w, abs(h))``.\n\nExamples\n--------\n>>> from scipy.signal import freqs, iirfilter\n\n>>> b, a = iirfilter(4, [1, 10], 1, 60, analog=True, ftype='cheby1')\n\n>>> w, h = freqs(b, a, worN=np.logspace(-1, 2, 1000))\n\n>>> import matplotlib.pyplot as plt\n>>> plt.semilogx(w, 20 * np.log10(abs(h)))\n>>> plt.xlabel('Frequency')\n>>> plt.ylabel('Amplitude response [dB]')\n>>> plt.grid()\n>>> plt.show()", "id": "f19255:m1"}
{"signature": "def _zpklp2lp(z, p, k, wo=<NUM_LIT:1.0>):", "body": "z = atleast_1d(z)<EOL>p = atleast_1d(p)<EOL>wo = float(wo)  <EOL>degree = _relative_degree(z, p)<EOL>z_lp = wo * z<EOL>p_lp = wo * p<EOL>k_lp = k * wo**degree<EOL>return z_lp, p_lp, k_lp<EOL>", "docstring": "Transform a lowpass filter prototype to a different frequency.\n\nReturn an analog low-pass filter with cutoff frequency `wo`\nfrom an analog low-pass filter prototype with unity cutoff frequency,\nusing zeros, poles, and gain ('zpk') representation.\n\nParameters\n----------\nz : ndarray\n    Zeros of the analog IIR filter transfer function.\np : ndarray\n    Poles of the analog IIR filter transfer function.\nk : float\n    System gain of the analog IIR filter transfer function.\nwo : float\n    Desired cutoff, as angular frequency (e.g. rad/s).\n    Defaults to no change.\n\nReturns\n-------\nz : ndarray\n    Zeros of the transformed low-pass filter transfer function.\np : ndarray\n    Poles of the transformed low-pass filter transfer function.\nk : float\n    System gain of the transformed low-pass filter.\n\nNotes\n-----\nThis is derived from the s-plane substitution\n\n.. math:: s \\rightarrow \\frac{s}{\\omega_0}", "id": "f19255:m15"}
{"signature": "def bilinear(b, a, fs=<NUM_LIT:1.0>):", "body": "fs = float(fs)<EOL>a, b = map(atleast_1d, (a, b))<EOL>D = len(a) - <NUM_LIT:1><EOL>N = len(b) - <NUM_LIT:1><EOL>artype = float<EOL>M = max([N, D])<EOL>Np = M<EOL>Dp = M<EOL>bprime = numpy.zeros(Np + <NUM_LIT:1>, artype)<EOL>aprime = numpy.zeros(Dp + <NUM_LIT:1>, artype)<EOL>for j in range(Np + <NUM_LIT:1>):<EOL><INDENT>val = <NUM_LIT:0.0><EOL>for i in range(N + <NUM_LIT:1>):<EOL><INDENT>for k in range(i + <NUM_LIT:1>):<EOL><INDENT>for l in range(M - i + <NUM_LIT:1>):<EOL><INDENT>if k + l == j:<EOL><INDENT>val += (comb(i, k) * comb(M - i, l) * b[N - i] *<EOL>pow(<NUM_LIT:2> * fs, i) * (-<NUM_LIT:1>) ** k)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>bprime[j] = real(val)<EOL><DEDENT>for j in range(Dp + <NUM_LIT:1>):<EOL><INDENT>val = <NUM_LIT:0.0><EOL>for i in range(D + <NUM_LIT:1>):<EOL><INDENT>for k in range(i + <NUM_LIT:1>):<EOL><INDENT>for l in range(M - i + <NUM_LIT:1>):<EOL><INDENT>if k + l == j:<EOL><INDENT>val += (comb(i, k) * comb(M - i, l) * a[D - i] *<EOL>pow(<NUM_LIT:2> * fs, i) * (-<NUM_LIT:1>) ** k)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>aprime[j] = real(val)<EOL><DEDENT>return normalize(bprime, aprime)<EOL>", "docstring": "Return a digital filter from an analog one using a bilinear transform.\n\n    The bilinear transform substitutes ``(z-1) / (z+1)`` for ``s``.", "id": "f19255:m10"}
{"signature": "def bessel(N, Wn, btype='<STR_LIT>', analog=False, output='<STR_LIT>'):", "body": "return iirfilter(N, Wn, btype=btype, analog=analog,<EOL>output=output, ftype='<STR_LIT>')<EOL>", "docstring": "Bessel/Thomson digital and analog filter design.\n\n    Design an Nth order digital or analog Bessel filter and return the\n    filter coefficients in (B,A) or (Z,P,K) form.\n\n    Parameters\n    ----------\n    N : int\n        The order of the filter.\n    Wn : array_like\n        A scalar or length-2 sequence giving the critical frequencies.\n        For a Bessel filter, this is defined as the point at which the\n        asymptotes of the response are the same as a Butterworth filter of\n        the same order.\n        For digital filters, `Wn` is normalized from 0 to 1, where 1 is the\n        Nyquist frequency, pi radians/sample.  (`Wn` is thus in\n        half-cycles / sample.)\n        For analog filters, `Wn` is an angular frequency (e.g. rad/s).\n    btype : {'lowpass', 'highpass', 'bandpass', 'bandstop'}, optional\n        The type of filter.  Default is 'lowpass'.\n    analog : bool, optional\n        When True, return an analog filter, otherwise a digital filter is\n        returned.\n    output : {'ba', 'zpk'}, optional\n        Type of output:  numerator/denominator ('ba') or pole-zero ('zpk').\n        Default is 'ba'.\n\n    Returns\n    -------\n    b, a : ndarray, ndarray\n        Numerator (`b`) and denominator (`a`) polynomials of the IIR filter.\n        Only returned if ``output='ba'``.\n    z, p, k : ndarray, ndarray, float\n        Zeros, poles, and system gain of the IIR filter transfer\n        function.  Only returned if ``output='zpk'``.\n\n    Notes\n    -----\n    Also known as a Thomson filter, the analog Bessel filter has maximally\n    flat group delay and maximally linear phase response, with very little\n    ringing in the step response.\n\n    As order increases, the Bessel filter approaches a Gaussian filter.\n\n    The digital Bessel filter is generated using the bilinear\n    transform, which does not preserve the phase response of the analog\n    filter. As such, it is only approximately correct at frequencies\n    below about fs/4.  To get maximally flat group delay at higher\n    frequencies, the analog Bessel filter must be transformed using\n    phase-preserving techniques.\n\n    For a given `Wn`, the lowpass and highpass filter have the same phase vs\n    frequency curves; they are \"phase-matched\".\n\n    Examples\n    --------\n    Plot the filter's frequency response, showing the flat group delay and\n    the relationship to the Butterworth's cutoff frequency:\n\n    >>> from scipy import signal\n    >>> import matplotlib.pyplot as plt\n\n    >>> b, a = signal.butter(4, 100, 'low', analog=True)\n    >>> w, h = signal.freqs(b, a)\n    >>> plt.plot(w, 20 * np.log10(np.abs(h)), color='silver', ls='dashed')\n    >>> b, a = signal.bessel(4, 100, 'low', analog=True)\n    >>> w, h = signal.freqs(b, a)\n    >>> plt.semilogx(w, 20 * np.log10(np.abs(h)))\n    >>> plt.title('Bessel filter frequency response (with Butterworth)')\n    >>> plt.xlabel('Frequency [radians / second]')\n    >>> plt.ylabel('Amplitude [dB]')\n    >>> plt.margins(0, 0.1)\n    >>> plt.grid(which='both', axis='both')\n    >>> plt.axvline(100, color='green') # cutoff frequency\n    >>> plt.show()\n\n    >>> plt.figure()\n    >>> plt.semilogx(w[1:], -np.diff(np.unwrap(np.angle(h)))/np.diff(w))\n    >>> plt.title('Bessel filter group delay')\n    >>> plt.xlabel('Frequency [radians / second]')\n    >>> plt.ylabel('Group delay [seconds]')\n    >>> plt.margins(0, 0.1)\n    >>> plt.grid(which='both', axis='both')\n    >>> plt.show()", "id": "f19255:m23"}
{"signature": "def lp2hp(b, a, wo=<NUM_LIT:1.0>):", "body": "a, b = map(atleast_1d, (a, b))<EOL>try:<EOL><INDENT>wo = float(wo)<EOL><DEDENT>except TypeError:<EOL><INDENT>wo = float(wo[<NUM_LIT:0>])<EOL><DEDENT>d = len(a)<EOL>n = len(b)<EOL>if wo != <NUM_LIT:1>:<EOL><INDENT>pwo = pow(wo, numpy.arange(max((d, n))))<EOL><DEDENT>else:<EOL><INDENT>pwo = numpy.ones(max((d, n)), b.dtype.char)<EOL><DEDENT>if d >= n:<EOL><INDENT>outa = a[::-<NUM_LIT:1>] * pwo<EOL>outb = resize(b, (d,))<EOL>outb[n:] = <NUM_LIT:0.0><EOL>outb[:n] = b[::-<NUM_LIT:1>] * pwo[:n]<EOL><DEDENT>else:<EOL><INDENT>outb = b[::-<NUM_LIT:1>] * pwo<EOL>outa = resize(a, (n,))<EOL>outa[d:] = <NUM_LIT:0.0><EOL>outa[:d] = a[::-<NUM_LIT:1>] * pwo[:d]<EOL><DEDENT>return normalize(outb, outa)<EOL>", "docstring": "Transform a lowpass filter prototype to a highpass filter.\n\nReturn an analog high-pass filter with cutoff frequency `wo`\nfrom an analog low-pass filter prototype with unity cutoff frequency, in\ntransfer function ('ba') representation.", "id": "f19255:m7"}
{"signature": "def tf2zpk(b, a):", "body": "b, a = normalize(b, a)<EOL>b = (b + <NUM_LIT:0.0>) / a[<NUM_LIT:0>]<EOL>a = (a + <NUM_LIT:0.0>) / a[<NUM_LIT:0>]<EOL>k = b[<NUM_LIT:0>]<EOL>b /= b[<NUM_LIT:0>]<EOL>z = roots(b)<EOL>p = roots(a)<EOL>return z, p, k<EOL>", "docstring": "r\"\"\"Return zero, pole, gain (z,p,k) representation from a numerator,\n    denominator representation of a linear filter.\n\n    Parameters\n    ----------\n    b : ndarray\n        Numerator polynomial.\n    a : ndarray\n        Denominator polynomial.\n\n    Returns\n    -------\n    z : ndarray\n        Zeros of the transfer function.\n    p : ndarray\n        Poles of the transfer function.\n    k : float\n        System gain.\n\n    Notes\n    -----\n    If some values of `b` are too close to 0, they are removed. In that case,\n    a BadCoefficients warning is emitted.\n\n    The `b` and `a` arrays are interpreted as coefficients for positive,\n    descending powers of the transfer function variable.  So the inputs\n    :math:`b = [b_0, b_1, ..., b_M]` and :math:`a =[a_0, a_1, ..., a_N]`\n    can represent an analog filter of the form:\n\n    .. math::\n\n        H(s) = \\frac\n        {b_0 s^M + b_1 s^{(M-1)} + \\cdots + b_M}\n        {a_0 s^N + a_1 s^{(N-1)} + \\cdots + a_N}\n\n    or a discrete-time filter of the form:\n\n    .. math::\n\n        H(z) = \\frac\n        {b_0 z^M + b_1 z^{(M-1)} + \\cdots + b_M}\n        {a_0 z^N + a_1 z^{(N-1)} + \\cdots + a_N}\n\n    This \"positive powers\" form is found more commonly in controls\n    engineering.  If `M` and `N` are equal (which is true for all filters\n    generated by the bilinear transform), then this happens to be equivalent\n    to the \"negative powers\" discrete-time form preferred in DSP:\n\n    .. math::\n\n        H(z) = \\frac\n        {b_0 + b_1 z^{-1} + \\cdots + b_M z^{-M}}\n        {a_0 + a_1 z^{-1} + \\cdots + a_N z^{-N}}\n\n    Although this is true for common filters, remember that this is not true\n    in the general case.  If `M` and `N` are not equal, the discrete-time\n    transfer function coefficients must first be converted to the \"positive\n    powers\" form before finding the poles and zeros.", "id": "f19255:m3"}
{"signature": "def findfreqs(num, den, N):", "body": "ep = atleast_1d(roots(den)) + <NUM_LIT><EOL>tz = atleast_1d(roots(num)) + <NUM_LIT><EOL>if len(ep) == <NUM_LIT:0>:<EOL><INDENT>ep = atleast_1d(-<NUM_LIT:1000>) + <NUM_LIT><EOL><DEDENT>ez = r_['<STR_LIT>',<EOL>numpy.compress(ep.imag >= <NUM_LIT:0>, ep, axis=-<NUM_LIT:1>),<EOL>numpy.compress((abs(tz) < <NUM_LIT>) & (tz.imag >= <NUM_LIT:0>), tz, axis=-<NUM_LIT:1>)]<EOL>integ = abs(ez) < <NUM_LIT><EOL>hfreq = numpy.around(numpy.log10(numpy.max(<NUM_LIT:3> * abs(ez.real + integ) +<EOL><NUM_LIT> * ez.imag)) + <NUM_LIT:0.5>)<EOL>lfreq = numpy.around(numpy.log10(<NUM_LIT:0.1> * numpy.min(abs(real(ez + integ)) +<EOL><NUM_LIT:2> * ez.imag)) - <NUM_LIT:0.5>)<EOL>w = logspace(lfreq, hfreq, N)<EOL>return w<EOL>", "docstring": "Find an array of frequencies for computing the response of a filter.\n\nParameters\n----------\nnum, den : array_like, 1-D\n    The polynomial coefficients of the numerator and denominator of the\n    transfer function of the filter or LTI system.  The coefficients are\n    ordered from highest to lowest degree.\nN : int\n    The length of the array to be computed.\n\nReturns\n-------\nw : (N,) ndarray\n    A 1-D array of frequencies, logarithmically spaced.\n\nExamples\n--------\nFind a set of nine frequencies that span the \"interesting part\" of the\nfrequency response for the filter with the transfer function\n\n    H(s) = s / (s^2 + 8s + 25)\n\n>>> findfreqs([1, 0], [1, 8, 25], N=9)\narray([  1.00000000e-02,   3.16227766e-02,   1.00000000e-01,\n         3.16227766e-01,   1.00000000e+00,   3.16227766e+00,\n         1.00000000e+01,   3.16227766e+01,   1.00000000e+02])", "id": "f19255:m0"}
{"signature": "def _zpklp2bs(z, p, k, wo=<NUM_LIT:1.0>, bw=<NUM_LIT:1.0>):", "body": "z = atleast_1d(z)<EOL>p = atleast_1d(p)<EOL>wo = float(wo)<EOL>bw = float(bw)<EOL>degree = _relative_degree(z, p)<EOL>z_hp = (bw/<NUM_LIT:2>) / z<EOL>p_hp = (bw/<NUM_LIT:2>) / p<EOL>z_hp = z_hp.astype(complex)<EOL>p_hp = p_hp.astype(complex)<EOL>z_bs = concatenate((z_hp + sqrt(z_hp**<NUM_LIT:2> - wo**<NUM_LIT:2>),<EOL>z_hp - sqrt(z_hp**<NUM_LIT:2> - wo**<NUM_LIT:2>)))<EOL>p_bs = concatenate((p_hp + sqrt(p_hp**<NUM_LIT:2> - wo**<NUM_LIT:2>),<EOL>p_hp - sqrt(p_hp**<NUM_LIT:2> - wo**<NUM_LIT:2>)))<EOL>z_bs = append(z_bs, +<NUM_LIT>*wo * ones(degree))<EOL>z_bs = append(z_bs, -<NUM_LIT>*wo * ones(degree))<EOL>k_bs = k * real(prod(-z) / prod(-p))<EOL>return z_bs, p_bs, k_bs<EOL>", "docstring": "Transform a lowpass filter prototype to a bandstop filter.\n\nReturn an analog band-stop filter with center frequency `wo` and\nstopband width `bw` from an analog low-pass filter prototype with unity\ncutoff frequency, using zeros, poles, and gain ('zpk') representation.\n\nParameters\n----------\nz : ndarray\n    Zeros of the analog IIR filter transfer function.\np : ndarray\n    Poles of the analog IIR filter transfer function.\nk : float\n    System gain of the analog IIR filter transfer function.\nwo : float\n    Desired stopband center, as angular frequency (e.g. rad/s).\n    Defaults to no change.\nbw : float\n    Desired stopband width, as angular frequency (e.g. rad/s).\n    Defaults to 1.\n\nReturns\n-------\nz : ndarray\n    Zeros of the transformed band-stop filter transfer function.\np : ndarray\n    Poles of the transformed band-stop filter transfer function.\nk : float\n    System gain of the transformed band-stop filter.\n\nNotes\n-----\nThis is derived from the s-plane substitution\n\n.. math:: s \\rightarrow \\frac{s \\cdot \\mathrm{BW}}{s^2 + {\\omega_0}^2}\n\nThis is the \"wideband\" transformation, producing a stopband with\ngeometric (log frequency) symmetry about `wo`.", "id": "f19255:m18"}
{"signature": "def ellip(N, rp, rs, Wn, btype='<STR_LIT>', analog=False, output='<STR_LIT>'):", "body": "return iirfilter(N, Wn, rs=rs, rp=rp, btype=btype, analog=analog,<EOL>output=output, ftype='<STR_LIT>')<EOL>", "docstring": "Elliptic (Cauer) digital and analog filter design.\n\nDesign an Nth order digital or analog elliptic filter and return\nthe filter coefficients in (B,A) or (Z,P,K) form.\n\nParameters\n----------\nN : int\n    The order of the filter.\nrp : float\n    The maximum ripple allowed below unity gain in the passband.\n    Specified in decibels, as a positive number.\nrs : float\n    The minimum attenuation required in the stop band.\n    Specified in decibels, as a positive number.\nWn : array_like\n    A scalar or length-2 sequence giving the critical frequencies.\n    For elliptic filters, this is the point in the transition band at\n    which the gain first drops below -`rp`.\n    For digital filters, `Wn` is normalized from 0 to 1, where 1 is the\n    Nyquist frequency, pi radians/sample.  (`Wn` is thus in\n    half-cycles / sample.)\n    For analog filters, `Wn` is an angular frequency (e.g. rad/s).\nbtype : {'lowpass', 'highpass', 'bandpass', 'bandstop'}, optional\n    The type of filter.  Default is 'lowpass'.\nanalog : bool, optional\n    When True, return an analog filter, otherwise a digital filter is\n    returned.\noutput : {'ba', 'zpk'}, optional\n    Type of output:  numerator/denominator ('ba') or pole-zero ('zpk').\n    Default is 'ba'.\n\nReturns\n-------\nb, a : ndarray, ndarray\n    Numerator (`b`) and denominator (`a`) polynomials of the IIR filter.\n    Only returned if ``output='ba'``.\nz, p, k : ndarray, ndarray, float\n    Zeros, poles, and system gain of the IIR filter transfer\n    function.  Only returned if ``output='zpk'``.\n\nSee also\n--------\nellipord\n\nNotes\n-----\nAlso known as Cauer or Zolotarev filters, the elliptical filter maximizes\nthe rate of transition between the frequency response's passband and\nstopband, at the expense of ripple in both, and increased ringing in the\nstep response.\n\nAs `rp` approaches 0, the elliptical filter becomes a Chebyshev\ntype II filter (`cheby2`).  As `rs` approaches 0, it becomes a Chebyshev\ntype I filter (`cheby1`).  As both approach 0, it becomes a Butterworth\nfilter (`butter`).\n\nThe equiripple passband has N maxima or minima (for example, a\n5th-order filter has 3 maxima and 2 minima).  Consequently, the DC gain is\nunity for odd-order filters, or -rp dB for even-order filters.\n\nExamples\n--------\nPlot the filter's frequency response, showing the critical points:\n\n>>> from scipy import signal\n>>> import matplotlib.pyplot as plt\n\n>>> b, a = signal.ellip(4, 5, 40, 100, 'low', analog=True)\n>>> w, h = signal.freqs(b, a)\n>>> plt.semilogx(w, 20 * np.log10(abs(h)))\n>>> plt.title('Elliptic filter frequency response (rp=5, rs=40)')\n>>> plt.xlabel('Frequency [radians / second]')\n>>> plt.ylabel('Amplitude [dB]')\n>>> plt.margins(0, 0.1)\n>>> plt.grid(which='both', axis='both')\n>>> plt.axvline(100, color='green') # cutoff frequency\n>>> plt.axhline(-40, color='green') # rs\n>>> plt.axhline(-5, color='green') # rp\n>>> plt.show()", "id": "f19255:m22"}
{"signature": "def butter(N, Wn, btype='<STR_LIT>', analog=False, output='<STR_LIT>'):", "body": "return iirfilter(N, Wn, btype=btype, analog=analog,<EOL>output=output, ftype='<STR_LIT>')<EOL>", "docstring": "Butterworth digital and analog filter design.\n\nDesign an Nth order digital or analog Butterworth filter and return\nthe filter coefficients in (B,A) or (Z,P,K) form.\n\nParameters\n----------\nN : int\n    The order of the filter.\nWn : array_like\n    A scalar or length-2 sequence giving the critical frequencies.\n    For a Butterworth filter, this is the point at which the gain\n    drops to 1/sqrt(2) that of the passband (the \"-3 dB point\").\n    For digital filters, `Wn` is normalized from 0 to 1, where 1 is the\n    Nyquist frequency, pi radians/sample.  (`Wn` is thus in\n    half-cycles / sample.)\n    For analog filters, `Wn` is an angular frequency (e.g. rad/s).\nbtype : {'lowpass', 'highpass', 'bandpass', 'bandstop'}, optional\n    The type of filter.  Default is 'lowpass'.\nanalog : bool, optional\n    When True, return an analog filter, otherwise a digital filter is\n    returned.\noutput : {'ba', 'zpk'}, optional\n    Type of output:  numerator/denominator ('ba') or pole-zero ('zpk').\n    Default is 'ba'.\n\nReturns\n-------\nb, a : ndarray, ndarray\n    Numerator (`b`) and denominator (`a`) polynomials of the IIR filter.\n    Only returned if ``output='ba'``.\nz, p, k : ndarray, ndarray, float\n    Zeros, poles, and system gain of the IIR filter transfer\n    function.  Only returned if ``output='zpk'``.\n\nSee also\n--------\nbuttord\n\nNotes\n-----\nThe Butterworth filter has maximally flat frequency response in the\npassband.\n\nExamples\n--------\nPlot the filter's frequency response, showing the critical points:\n\n>>> from scipy import signal\n>>> import matplotlib.pyplot as plt\n\n>>> b, a = signal.butter(4, 100, 'low', analog=True)\n>>> w, h = signal.freqs(b, a)\n>>> plt.semilogx(w, 20 * np.log10(abs(h)))\n>>> plt.title('Butterworth filter frequency response')\n>>> plt.xlabel('Frequency [radians / second]')\n>>> plt.ylabel('Amplitude [dB]')\n>>> plt.margins(0, 0.1)\n>>> plt.grid(which='both', axis='both')\n>>> plt.axvline(100, color='green') # cutoff frequency\n>>> plt.show()", "id": "f19255:m19"}
{"signature": "def ellipap(N, rp, rs):", "body": "if abs(int(N)) != N:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>elif N == <NUM_LIT:0>:<EOL><INDENT>return numpy.array([]), numpy.array([]), <NUM_LIT:10>**(-rp/<NUM_LIT:20>)<EOL><DEDENT>elif N == <NUM_LIT:1>:<EOL><INDENT>p = -sqrt(<NUM_LIT:1.0> / (<NUM_LIT:10> ** (<NUM_LIT:0.1> * rp) - <NUM_LIT:1.0>))<EOL>k = -p<EOL>z = []<EOL>return asarray(z), asarray(p), k<EOL><DEDENT>eps = numpy.sqrt(<NUM_LIT:10> ** (<NUM_LIT:0.1> * rp) - <NUM_LIT:1>)<EOL>ck1 = eps / numpy.sqrt(<NUM_LIT:10> ** (<NUM_LIT:0.1> * rs) - <NUM_LIT:1>)<EOL>ck1p = numpy.sqrt(<NUM_LIT:1> - ck1 * ck1)<EOL>if ck1p == <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>val = special.ellipk([ck1 * ck1, ck1p * ck1p])<EOL>if abs(<NUM_LIT:1> - ck1p * ck1p) < EPSILON:<EOL><INDENT>krat = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>krat = N * val[<NUM_LIT:0>] / val[<NUM_LIT:1>]<EOL><DEDENT>m = optimize.fmin(_kratio, [<NUM_LIT:0.5>], args=(krat,), maxfun=<NUM_LIT>, maxiter=<NUM_LIT>,<EOL>disp=<NUM_LIT:0>)<EOL>if m < <NUM_LIT:0> or m > <NUM_LIT:1>:<EOL><INDENT>m = optimize.fminbound(_kratio, <NUM_LIT:0>, <NUM_LIT:1>, args=(krat,), maxfun=<NUM_LIT>,<EOL>maxiter=<NUM_LIT>, disp=<NUM_LIT:0>)<EOL><DEDENT>capk = special.ellipk(m)<EOL>j = numpy.arange(<NUM_LIT:1> - N % <NUM_LIT:2>, N, <NUM_LIT:2>)<EOL>jj = len(j)<EOL>[s, c, d, phi] = special.ellipj(j * capk / N, m * numpy.ones(jj))<EOL>snew = numpy.compress(abs(s) > EPSILON, s, axis=-<NUM_LIT:1>)<EOL>z = <NUM_LIT:1.0> / (sqrt(m) * snew)<EOL>z = <NUM_LIT> * z<EOL>z = numpy.concatenate((z, conjugate(z)))<EOL>r = optimize.fmin(_vratio, special.ellipk(m), args=(<NUM_LIT:1.> / eps, ck1p * ck1p),<EOL>maxfun=<NUM_LIT>, maxiter=<NUM_LIT>, disp=<NUM_LIT:0>)<EOL>v0 = capk * r / (N * val[<NUM_LIT:0>])<EOL>[sv, cv, dv, phi] = special.ellipj(v0, <NUM_LIT:1> - m)<EOL>p = -(c * d * sv * cv + <NUM_LIT> * s * dv) / (<NUM_LIT:1> - (d * sv) ** <NUM_LIT>)<EOL>if N % <NUM_LIT:2>:<EOL><INDENT>newp = numpy.compress(abs(p.imag) > EPSILON *<EOL>numpy.sqrt(numpy.sum(p * numpy.conjugate(p),<EOL>axis=<NUM_LIT:0>).real),<EOL>p, axis=-<NUM_LIT:1>)<EOL>p = numpy.concatenate((p, conjugate(newp)))<EOL><DEDENT>else:<EOL><INDENT>p = numpy.concatenate((p, conjugate(p)))<EOL><DEDENT>k = (numpy.prod(-p, axis=<NUM_LIT:0>) / numpy.prod(-z, axis=<NUM_LIT:0>)).real<EOL>if N % <NUM_LIT:2> == <NUM_LIT:0>:<EOL><INDENT>k = k / numpy.sqrt((<NUM_LIT:1> + eps * eps))<EOL><DEDENT>return z, p, k<EOL>", "docstring": "Return (z,p,k) of Nth order elliptic analog lowpass filter.\n\n    The filter is a normalized prototype that has `rp` decibels of ripple\n    in the passband and a stopband `rs` decibels down.\n\n    The filter's angular (e.g. rad/s) cutoff frequency is normalized to 1,\n    defined as the point at which the gain first drops below ``-rp``.\n\n    References\n    ----------\n    Lutova, Tosic, and Evans, \"Filter Design for Signal Processing\", Chapters 5\n    and 12.", "id": "f19255:m36"}
{"signature": "def freqz(b, a=<NUM_LIT:1>, worN=None, whole=<NUM_LIT:0>, plot=None):", "body": "b, a = map(atleast_1d, (b, a))<EOL>if whole:<EOL><INDENT>lastpoint = <NUM_LIT:2> * pi<EOL><DEDENT>else:<EOL><INDENT>lastpoint = pi<EOL><DEDENT>if worN is None:<EOL><INDENT>N = <NUM_LIT><EOL>w = numpy.linspace(<NUM_LIT:0>, lastpoint, N, endpoint=False)<EOL><DEDENT>elif isinstance(worN, int):<EOL><INDENT>N = worN<EOL>w = numpy.linspace(<NUM_LIT:0>, lastpoint, N, endpoint=False)<EOL><DEDENT>else:<EOL><INDENT>w = worN<EOL><DEDENT>w = atleast_1d(w)<EOL>zm1 = exp(-<NUM_LIT> * w)<EOL>h = polyval(b[::-<NUM_LIT:1>], zm1) / polyval(a[::-<NUM_LIT:1>], zm1)<EOL>if plot is not None:<EOL><INDENT>plot(w, h)<EOL><DEDENT>return w, h<EOL>", "docstring": "Compute the frequency response of a digital filter.\n\nGiven the numerator `b` and denominator `a` of a digital filter,\ncompute its frequency response::\n\n           jw               -jw            -jmw\n    jw  B(e)    b[0] + b[1]e + .... + b[m]e\n H(e) = ---- = ------------------------------------\n           jw               -jw            -jnw\n        A(e)    a[0] + a[1]e + .... + a[n]e\n\nParameters\n----------\nb : ndarray\n    numerator of a linear filter\na : ndarray\n    denominator of a linear filter\nworN : {None, int, array_like}, optional\n    If None (default), then compute at 512 frequencies equally spaced\n    around the unit circle.\n    If a single integer, then compute at that many frequencies.\n    If an array_like, compute the response at the frequencies given (in\n    radians/sample).\nwhole : bool, optional\n    Normally, frequencies are computed from 0 to the Nyquist frequency,\n    pi radians/sample (upper-half of unit-circle).  If `whole` is True,\n    compute frequencies from 0 to 2*pi radians/sample.\nplot : callable\n    A callable that takes two arguments. If given, the return parameters\n    `w` and `h` are passed to plot. Useful for plotting the frequency\n    response inside `freqz`.\n\nReturns\n-------\nw : ndarray\n    The normalized frequencies at which h was computed, in radians/sample.\nh : ndarray\n    The frequency response.\n\nNotes\n-----\nUsing Matplotlib's \"plot\" function as the callable for `plot` produces\nunexpected results,  this plots the real part of the complex transfer\nfunction, not the magnitude.  Try ``lambda w, h: plot(w, abs(h))``.\n\nExamples\n--------\n>>> from scipy import signal\n>>> b = signal.firwin(80, 0.5, window=('kaiser', 8))\n>>> w, h = signal.freqz(b)\n\n>>> import matplotlib.pyplot as plt\n>>> fig = plt.figure()\n>>> plt.title('Digital filter frequency response')\n>>> ax1 = fig.add_subplot(111)\n\n>>> plt.plot(w, 20 * np.log10(abs(h)), 'b')\n>>> plt.ylabel('Amplitude [dB]', color='b')\n>>> plt.xlabel('Frequency [rad/sample]')\n\n>>> ax2 = ax1.twinx()\n>>> angles = np.unwrap(np.angle(h))\n>>> plt.plot(w, angles, 'g')\n>>> plt.ylabel('Angle (radians)', color='g')\n>>> plt.grid()\n>>> plt.axis('tight')\n>>> plt.show()", "id": "f19255:m2"}
{"signature": "def _zpklp2bp(z, p, k, wo=<NUM_LIT:1.0>, bw=<NUM_LIT:1.0>):", "body": "z = atleast_1d(z)<EOL>p = atleast_1d(p)<EOL>wo = float(wo)<EOL>bw = float(bw)<EOL>degree = _relative_degree(z, p)<EOL>z_lp = z * bw/<NUM_LIT:2><EOL>p_lp = p * bw/<NUM_LIT:2><EOL>z_lp = z_lp.astype(complex)<EOL>p_lp = p_lp.astype(complex)<EOL>z_bp = concatenate((z_lp + sqrt(z_lp**<NUM_LIT:2> - wo**<NUM_LIT:2>),<EOL>z_lp - sqrt(z_lp**<NUM_LIT:2> - wo**<NUM_LIT:2>)))<EOL>p_bp = concatenate((p_lp + sqrt(p_lp**<NUM_LIT:2> - wo**<NUM_LIT:2>),<EOL>p_lp - sqrt(p_lp**<NUM_LIT:2> - wo**<NUM_LIT:2>)))<EOL>z_bp = append(z_bp, zeros(degree))<EOL>k_bp = k * bw**degree<EOL>return z_bp, p_bp, k_bp<EOL>", "docstring": "Transform a lowpass filter prototype to a bandpass filter.\n\nReturn an analog band-pass filter with center frequency `wo` and\nbandwidth `bw` from an analog low-pass filter prototype with unity\ncutoff frequency, using zeros, poles, and gain ('zpk') representation.\n\nParameters\n----------\nz : ndarray\n    Zeros of the analog IIR filter transfer function.\np : ndarray\n    Poles of the analog IIR filter transfer function.\nk : float\n    System gain of the analog IIR filter transfer function.\nwo : float\n    Desired passband center, as angular frequency (e.g. rad/s).\n    Defaults to no change.\nbw : float\n    Desired passband width, as angular frequency (e.g. rad/s).\n    Defaults to 1.\n\nReturns\n-------\nz : ndarray\n    Zeros of the transformed band-pass filter transfer function.\np : ndarray\n    Poles of the transformed band-pass filter transfer function.\nk : float\n    System gain of the transformed band-pass filter.\n\nNotes\n-----\nThis is derived from the s-plane substitution\n\n.. math:: s \\rightarrow \\frac{s^2 + {\\omega_0}^2}{s \\cdot \\mathrm{BW}}\n\nThis is the \"wideband\" transformation, producing a passband with\ngeometric (log frequency) symmetry about `wo`.", "id": "f19255:m17"}
{"signature": "def get_window(window, Nx, fftbins=True):", "body": "sym = not fftbins<EOL>try:<EOL><INDENT>beta = float(window)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>args = ()<EOL>if isinstance(window, tuple):<EOL><INDENT>winstr = window[<NUM_LIT:0>]<EOL>if len(window) > <NUM_LIT:1>:<EOL><INDENT>args = window[<NUM_LIT:1>:]<EOL><DEDENT><DEDENT>elif isinstance(window, string_types):<EOL><INDENT>if window in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" + window + \"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>winstr = window<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % str(type(window)))<EOL><DEDENT>if winstr in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>winfunc = blackman<EOL><DEDENT>elif winstr in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>winfunc = triang<EOL><DEDENT>elif winstr in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>winfunc = hamming<EOL><DEDENT>elif winstr in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>winfunc = bartlett<EOL><DEDENT>elif winstr in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>winfunc = hann<EOL><DEDENT>elif winstr in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>winfunc = blackmanharris<EOL><DEDENT>elif winstr in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>winfunc = parzen<EOL><DEDENT>elif winstr in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>winfunc = bohman<EOL><DEDENT>elif winstr in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>winfunc = nuttall<EOL><DEDENT>elif winstr in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>winfunc = barthann<EOL><DEDENT>elif winstr in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>winfunc = flattop<EOL><DEDENT>elif winstr in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>winfunc = kaiser<EOL><DEDENT>elif winstr in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>winfunc = gaussian<EOL><DEDENT>elif winstr in ['<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>winfunc = general_gaussian<EOL><DEDENT>elif winstr in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>winfunc = boxcar<EOL><DEDENT>elif winstr in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>winfunc = slepian<EOL><DEDENT>elif winstr in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>winfunc = cosine<EOL><DEDENT>elif winstr in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>winfunc = chebwin<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>params = (Nx,) + args + (sym,)<EOL><DEDENT>else:<EOL><INDENT>winfunc = kaiser<EOL>params = (Nx, beta, sym)<EOL><DEDENT>return winfunc(*params)<EOL>", "docstring": "Return a window.\n\nParameters\n----------\nwindow : string, float, or tuple\n    The type of window to create. See below for more details.\nNx : int\n    The number of samples in the window.\nfftbins : bool, optional\n    If True, create a \"periodic\" window ready to use with ifftshift\n    and be multiplied by the result of an fft (SEE ALSO fftfreq).\n\nReturns\n-------\nget_window : ndarray\n    Returns a window of length `Nx` and type `window`\n\nNotes\n-----\nWindow types:\n\n    boxcar, triang, blackman, hamming, hann, bartlett, flattop,\n    parzen, bohman, blackmanharris, nuttall, barthann,\n    kaiser (needs beta), gaussian (needs std),\n    general_gaussian (needs power, width),\n    slepian (needs width), chebwin (needs attenuation)\n\n\nIf the window requires no parameters, then `window` can be a string.\n\nIf the window requires parameters, then `window` must be a tuple\nwith the first argument the string name of the window, and the next\narguments the needed parameters.\n\nIf `window` is a floating point number, it is interpreted as the beta\nparameter of the kaiser window.\n\nEach of the window types listed above is also the name of\na function that can be called directly to create a window of\nthat type.\n\nExamples\n--------\n>>> from scipy import signal\n>>> signal.get_window('triang', 7)\narray([ 0.25,  0.5 ,  0.75,  1.  ,  0.75,  0.5 ,  0.25])\n>>> signal.get_window(('kaiser', 4.0), 9)\narray([ 0.08848053,  0.32578323,  0.63343178,  0.89640418,  1.        ,\n        0.89640418,  0.63343178,  0.32578323,  0.08848053])\n>>> signal.get_window(4.0, 9)\narray([ 0.08848053,  0.32578323,  0.63343178,  0.89640418,  1.        ,\n        0.89640418,  0.63343178,  0.32578323,  0.08848053])", "id": "f19256:m18"}
{"signature": "def gaussian(M, std, sym=True):", "body": "if M < <NUM_LIT:1>:<EOL><INDENT>return np.array([])<EOL><DEDENT>if M == <NUM_LIT:1>:<EOL><INDENT>return np.ones(<NUM_LIT:1>, '<STR_LIT:d>')<EOL><DEDENT>odd = M % <NUM_LIT:2><EOL>if not sym and not odd:<EOL><INDENT>M = M + <NUM_LIT:1><EOL><DEDENT>n = np.arange(<NUM_LIT:0>, M) - (M - <NUM_LIT:1.0>) / <NUM_LIT><EOL>sig2 = <NUM_LIT:2> * std * std<EOL>w = np.exp(-n ** <NUM_LIT:2> / sig2)<EOL>if not sym and not odd:<EOL><INDENT>w = w[:-<NUM_LIT:1>]<EOL><DEDENT>return w<EOL>", "docstring": "r\"\"\"Return a Gaussian window.\n\n    Parameters\n    ----------\n    M : int\n        Number of points in the output window. If zero or less, an empty\n        array is returned.\n    std : float\n        The standard deviation, sigma.\n    sym : bool, optional\n        When True (default), generates a symmetric window, for use in filter\n        design.\n        When False, generates a periodic window, for use in spectral analysis.\n\n    Returns\n    -------\n    w : ndarray\n        The window, with the maximum value normalized to 1 (though the value 1\n        does not appear if `M` is even and `sym` is True).\n\n    Notes\n    -----\n    The Gaussian window is defined as\n\n    .. math::  w(n) = e^{ -\\frac{1}{2}\\left(\\frac{n}{\\sigma}\\right)^2 }\n\n    Examples\n    --------\n    Plot the window and its frequency response:\n\n    >>> from scipy import signal\n    >>> from scipy.fftpack import fft, fftshift\n    >>> import matplotlib.pyplot as plt\n\n    >>> window = signal.gaussian(51, std=7)\n    >>> plt.plot(window)\n    >>> plt.title(r\"Gaussian window ($\\sigma$=7)\")\n    >>> plt.ylabel(\"Amplitude\")\n    >>> plt.xlabel(\"Sample\")\n\n    >>> plt.figure()\n    >>> A = fft(window, 2048) / (len(window)/2.0)\n    >>> freq = np.linspace(-0.5, 0.5, len(A))\n    >>> response = 20 * np.log10(np.abs(fftshift(A / abs(A).max())))\n    >>> plt.plot(freq, response)\n    >>> plt.axis([-0.5, 0.5, -120, 0])\n    >>> plt.title(r\"Frequency response of the Gaussian window ($\\sigma$=7)\")\n    >>> plt.ylabel(\"Normalized magnitude [dB]\")\n    >>> plt.xlabel(\"Normalized frequency [cycles per sample]\")", "id": "f19256:m13"}
{"signature": "def bartlett(M, sym=True):", "body": "<EOL>if M < <NUM_LIT:1>:<EOL><INDENT>return np.array([])<EOL><DEDENT>if M == <NUM_LIT:1>:<EOL><INDENT>return np.ones(<NUM_LIT:1>, '<STR_LIT:d>')<EOL><DEDENT>odd = M % <NUM_LIT:2><EOL>if not sym and not odd:<EOL><INDENT>M = M + <NUM_LIT:1><EOL><DEDENT>n = np.arange(<NUM_LIT:0>, M)<EOL>w = np.where(np.less_equal(n, (M - <NUM_LIT:1>) / <NUM_LIT>),<EOL><NUM_LIT> * n / (M - <NUM_LIT:1>), <NUM_LIT> - <NUM_LIT> * n / (M - <NUM_LIT:1>))<EOL>if not sym and not odd:<EOL><INDENT>w = w[:-<NUM_LIT:1>]<EOL><DEDENT>return w<EOL>", "docstring": "r\"\"\"\n    Return a Bartlett window.\n\n    The Bartlett window is very similar to a triangular window, except\n    that the end points are at zero.  It is often used in signal\n    processing for tapering a signal, without generating too much\n    ripple in the frequency domain.\n\n    Parameters\n    ----------\n    M : int\n        Number of points in the output window. If zero or less, an empty\n        array is returned.\n    sym : bool, optional\n        When True (default), generates a symmetric window, for use in filter\n        design.\n        When False, generates a periodic window, for use in spectral analysis.\n\n    Returns\n    -------\n    w : ndarray\n        The triangular window, with the first and last samples equal to zero\n        and the maximum value normalized to 1 (though the value 1 does not\n        appear if `M` is even and `sym` is True).\n\n    Notes\n    -----\n    The Bartlett window is defined as\n\n    .. math:: w(n) = \\frac{2}{M-1} \\left(\n              \\frac{M-1}{2} - \\left|n - \\frac{M-1}{2}\\right|\n              \\right)\n\n    Most references to the Bartlett window come from the signal\n    processing literature, where it is used as one of many windowing\n    functions for smoothing values.  Note that convolution with this\n    window produces linear interpolation.  It is also known as an\n    apodization (which means\"removing the foot\", i.e. smoothing\n    discontinuities at the beginning and end of the sampled signal) or\n    tapering function. The Fourier transform of the Bartlett is the product\n    of two sinc functions.\n    Note the excellent discussion in Kanasewich.\n\n    References\n    ----------\n    .. [1] M.S. Bartlett, \"Periodogram Analysis and Continuous Spectra\",\n           Biometrika 37, 1-16, 1950.\n    .. [2] E.R. Kanasewich, \"Time Sequence Analysis in Geophysics\",\n           The University of Alberta Press, 1975, pp. 109-110.\n    .. [3] A.V. Oppenheim and R.W. Schafer, \"Discrete-Time Signal\n           Processing\", Prentice-Hall, 1999, pp. 468-471.\n    .. [4] Wikipedia, \"Window function\",\n           http://en.wikipedia.org/wiki/Window_function\n    .. [5] W.H. Press,  B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling,\n           \"Numerical Recipes\", Cambridge University Press, 1986, page 429.\n\n    Examples\n    --------\n    Plot the window and its frequency response:\n\n    >>> from scipy import signal\n    >>> from scipy.fftpack import fft, fftshift\n    >>> import matplotlib.pyplot as plt\n\n    >>> window = signal.bartlett(51)\n    >>> plt.plot(window)\n    >>> plt.title(\"Bartlett window\")\n    >>> plt.ylabel(\"Amplitude\")\n    >>> plt.xlabel(\"Sample\")\n\n    >>> plt.figure()\n    >>> A = fft(window, 2048) / (len(window)/2.0)\n    >>> freq = np.linspace(-0.5, 0.5, len(A))\n    >>> response = 20 * np.log10(np.abs(fftshift(A / abs(A).max())))\n    >>> plt.plot(freq, response)\n    >>> plt.axis([-0.5, 0.5, -120, 0])\n    >>> plt.title(\"Frequency response of the Bartlett window\")\n    >>> plt.ylabel(\"Normalized magnitude [dB]\")\n    >>> plt.xlabel(\"Normalized frequency [cycles per sample]\")", "id": "f19256:m8"}
{"signature": "def barthann(M, sym=True):", "body": "if M < <NUM_LIT:1>:<EOL><INDENT>return np.array([])<EOL><DEDENT>if M == <NUM_LIT:1>:<EOL><INDENT>return np.ones(<NUM_LIT:1>, '<STR_LIT:d>')<EOL><DEDENT>odd = M % <NUM_LIT:2><EOL>if not sym and not odd:<EOL><INDENT>M = M + <NUM_LIT:1><EOL><DEDENT>n = np.arange(<NUM_LIT:0>, M)<EOL>fac = np.abs(n / (M - <NUM_LIT:1.0>) - <NUM_LIT:0.5>)<EOL>w = <NUM_LIT> - <NUM_LIT> * fac + <NUM_LIT> * np.cos(<NUM_LIT:2> * np.pi * fac)<EOL>if not sym and not odd:<EOL><INDENT>w = w[:-<NUM_LIT:1>]<EOL><DEDENT>return w<EOL>", "docstring": "Return a modified Bartlett-Hann window.\n\n    Parameters\n    ----------\n    M : int\n        Number of points in the output window. If zero or less, an empty\n        array is returned.\n    sym : bool, optional\n        When True (default), generates a symmetric window, for use in filter\n        design.\n        When False, generates a periodic window, for use in spectral analysis.\n\n    Returns\n    -------\n    w : ndarray\n        The window, with the maximum value normalized to 1 (though the value 1\n        does not appear if `M` is even and `sym` is True).\n\n    Examples\n    --------\n    Plot the window and its frequency response:\n\n    >>> from scipy import signal\n    >>> from scipy.fftpack import fft, fftshift\n    >>> import matplotlib.pyplot as plt\n\n    >>> window = signal.barthann(51)\n    >>> plt.plot(window)\n    >>> plt.title(\"Bartlett-Hann window\")\n    >>> plt.ylabel(\"Amplitude\")\n    >>> plt.xlabel(\"Sample\")\n\n    >>> plt.figure()\n    >>> A = fft(window, 2048) / (len(window)/2.0)\n    >>> freq = np.linspace(-0.5, 0.5, len(A))\n    >>> response = 20 * np.log10(np.abs(fftshift(A / abs(A).max())))\n    >>> plt.plot(freq, response)\n    >>> plt.axis([-0.5, 0.5, -120, 0])\n    >>> plt.title(\"Frequency response of the Bartlett-Hann window\")\n    >>> plt.ylabel(\"Normalized magnitude [dB]\")\n    >>> plt.xlabel(\"Normalized frequency [cycles per sample]\")", "id": "f19256:m10"}
{"signature": "def blackmanharris(M, sym=True):", "body": "if M < <NUM_LIT:1>:<EOL><INDENT>return np.array([])<EOL><DEDENT>if M == <NUM_LIT:1>:<EOL><INDENT>return np.ones(<NUM_LIT:1>, '<STR_LIT:d>')<EOL><DEDENT>odd = M % <NUM_LIT:2><EOL>if not sym and not odd:<EOL><INDENT>M = M + <NUM_LIT:1><EOL><DEDENT>a = [<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>]<EOL>n = np.arange(<NUM_LIT:0>, M)<EOL>fac = n * <NUM_LIT:2> * np.pi / (M - <NUM_LIT:1.0>)<EOL>w = (a[<NUM_LIT:0>] - a[<NUM_LIT:1>] * np.cos(fac) +<EOL>a[<NUM_LIT:2>] * np.cos(<NUM_LIT:2> * fac) - a[<NUM_LIT:3>] * np.cos(<NUM_LIT:3> * fac))<EOL>if not sym and not odd:<EOL><INDENT>w = w[:-<NUM_LIT:1>]<EOL><DEDENT>return w<EOL>", "docstring": "Return a minimum 4-term Blackman-Harris window.\n\n    Parameters\n    ----------\n    M : int\n        Number of points in the output window. If zero or less, an empty\n        array is returned.\n    sym : bool, optional\n        When True (default), generates a symmetric window, for use in filter\n        design.\n        When False, generates a periodic window, for use in spectral analysis.\n\n    Returns\n    -------\n    w : ndarray\n        The window, with the maximum value normalized to 1 (though the value 1\n        does not appear if `M` is even and `sym` is True).\n\n    Examples\n    --------\n    Plot the window and its frequency response:\n\n    >>> from scipy import signal\n    >>> from scipy.fftpack import fft, fftshift\n    >>> import matplotlib.pyplot as plt\n\n    >>> window = signal.blackmanharris(51)\n    >>> plt.plot(window)\n    >>> plt.title(\"Blackman-Harris window\")\n    >>> plt.ylabel(\"Amplitude\")\n    >>> plt.xlabel(\"Sample\")\n\n    >>> plt.figure()\n    >>> A = fft(window, 2048) / (len(window)/2.0)\n    >>> freq = np.linspace(-0.5, 0.5, len(A))\n    >>> response = 20 * np.log10(np.abs(fftshift(A / abs(A).max())))\n    >>> plt.plot(freq, response)\n    >>> plt.axis([-0.5, 0.5, -120, 0])\n    >>> plt.title(\"Frequency response of the Blackman-Harris window\")\n    >>> plt.ylabel(\"Normalized magnitude [dB]\")\n    >>> plt.xlabel(\"Normalized frequency [cycles per sample]\")", "id": "f19256:m6"}
{"signature": "def _sweep_poly_phase(t, poly):", "body": "<EOL>intpoly = polyint(poly)<EOL>phase = <NUM_LIT:2> * pi * polyval(intpoly, t)<EOL>return phase<EOL>", "docstring": "Calculate the phase used by sweep_poly to generate its output.\n\nSee `sweep_poly` for a description of the arguments.", "id": "f19257:m6"}
{"signature": "def cubic(x):", "body": "ax = abs(asarray(x))<EOL>res = zeros_like(ax)<EOL>cond1 = less(ax, <NUM_LIT:1>)<EOL>if cond1.any():<EOL><INDENT>ax1 = ax[cond1]<EOL>res[cond1] = <NUM_LIT> / <NUM_LIT:3> - <NUM_LIT:1.0> / <NUM_LIT:2> * ax1 ** <NUM_LIT:2> * (<NUM_LIT:2> - ax1)<EOL><DEDENT>cond2 = ~cond1 & less(ax, <NUM_LIT:2>)<EOL>if cond2.any():<EOL><INDENT>ax2 = ax[cond2]<EOL>res[cond2] = <NUM_LIT:1.0> / <NUM_LIT:6> * (<NUM_LIT:2> - ax2) ** <NUM_LIT:3><EOL><DEDENT>return res<EOL>", "docstring": "A cubic B-spline.\n\n    This is a special case of `bspline`, and equivalent to ``bspline(x, 3)``.", "id": "f19259:m5"}
{"signature": "def _bspline_piecefunctions(order):", "body": "try:<EOL><INDENT>return _splinefunc_cache[order]<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>def condfuncgen(num, val1, val2):<EOL><INDENT>if num == <NUM_LIT:0>:<EOL><INDENT>return lambda x: logical_and(less_equal(x, val1),<EOL>greater_equal(x, val2))<EOL><DEDENT>elif num == <NUM_LIT:2>:<EOL><INDENT>return lambda x: less_equal(x, val2)<EOL><DEDENT>else:<EOL><INDENT>return lambda x: logical_and(less(x, val1),<EOL>greater_equal(x, val2))<EOL><DEDENT><DEDENT>last = order // <NUM_LIT:2> + <NUM_LIT:2><EOL>if order % <NUM_LIT:2>:<EOL><INDENT>startbound = -<NUM_LIT:1.0><EOL><DEDENT>else:<EOL><INDENT>startbound = -<NUM_LIT:0.5><EOL><DEDENT>condfuncs = [condfuncgen(<NUM_LIT:0>, <NUM_LIT:0>, startbound)]<EOL>bound = startbound<EOL>for num in xrange(<NUM_LIT:1>, last - <NUM_LIT:1>):<EOL><INDENT>condfuncs.append(condfuncgen(<NUM_LIT:1>, bound, bound - <NUM_LIT:1>))<EOL>bound = bound - <NUM_LIT:1><EOL><DEDENT>condfuncs.append(condfuncgen(<NUM_LIT:2>, <NUM_LIT:0>, -(order + <NUM_LIT:1>) / <NUM_LIT>))<EOL>fval = factorial(order)<EOL>def piecefuncgen(num):<EOL><INDENT>Mk = order // <NUM_LIT:2> - num<EOL>if (Mk < <NUM_LIT:0>):<EOL><INDENT>return <NUM_LIT:0>  <EOL><DEDENT>coeffs = [(<NUM_LIT:1> - <NUM_LIT:2> * (k % <NUM_LIT:2>)) * float(comb(order + <NUM_LIT:1>, k, exact=<NUM_LIT:1>)) / fval<EOL>for k in xrange(Mk + <NUM_LIT:1>)]<EOL>shifts = [-bound - k for k in xrange(Mk + <NUM_LIT:1>)]<EOL>def thefunc(x):<EOL><INDENT>res = <NUM_LIT:0.0><EOL>for k in range(Mk + <NUM_LIT:1>):<EOL><INDENT>res += coeffs[k] * (x + shifts[k]) ** order<EOL><DEDENT>return res<EOL><DEDENT>return thefunc<EOL><DEDENT>funclist = [piecefuncgen(k) for k in xrange(last)]<EOL>_splinefunc_cache[order] = (funclist, condfuncs)<EOL>return funclist, condfuncs<EOL>", "docstring": "Returns the function defined over the left-side pieces for a bspline of\n    a given order.\n\n    The 0th piece is the first one less than 0.  The last piece is a function\n    identical to 0 (returned as the constant 0).  (There are order//2 + 2 total\n    pieces).\n\n    Also returns the condition functions that when evaluated return boolean\n    arrays for use with `numpy.piecewise`.", "id": "f19259:m2"}
{"signature": "def odd_ext(x, n, axis=-<NUM_LIT:1>):", "body": "if n < <NUM_LIT:1>:<EOL><INDENT>return x<EOL><DEDENT>if n > x.shape[axis] - <NUM_LIT:1>:<EOL><INDENT>raise ValueError((\"<STR_LIT>\" +<EOL>\"<STR_LIT>\")<EOL>% (n, x.shape[axis] - <NUM_LIT:1>))<EOL><DEDENT>left_end = axis_slice(x, start=<NUM_LIT:0>, stop=<NUM_LIT:1>, axis=axis)<EOL>left_ext = axis_slice(x, start=n, stop=<NUM_LIT:0>, step=-<NUM_LIT:1>, axis=axis)<EOL>right_end = axis_slice(x, start=-<NUM_LIT:1>, axis=axis)<EOL>right_ext = axis_slice(x, start=-<NUM_LIT:2>, stop=-(n + <NUM_LIT:2>), step=-<NUM_LIT:1>, axis=axis)<EOL>ext = np.concatenate((<NUM_LIT:2> * left_end - left_ext,<EOL>x,<EOL><NUM_LIT:2> * right_end - right_ext),<EOL>axis=axis)<EOL>return ext<EOL>", "docstring": "Generate a new ndarray by making an odd extension of x along an axis.\n\n    Parameters\n    ----------\n    x : ndarray\n        The array to be extended.\n    n : int\n        The number of elements by which to extend x at each end of the axis.\n    axis : int\n        The axis along which to extend x.  Default is -1.\n\n    Examples\n    --------\n    >>> a = array([[1.0,2.0,3.0,4.0,5.0], [0.0, 1.0, 4.0, 9.0, 16.0]])\n    >>> _odd_ext(a, 2)\n    array([[-1.,  0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.],\n           [-4., -1,   0.,  1.,  4.,  9., 16., 23., 28.]])", "id": "f19261:m2"}
{"signature": "def axis_reverse(a, axis=-<NUM_LIT:1>):", "body": "return axis_slice(a, step=-<NUM_LIT:1>, axis=axis)<EOL>", "docstring": "Reverse the 1-d slices of `a` along axis `axis`.\n\n    Returns axis_slice(a, step=-1, axis=axis).", "id": "f19261:m1"}
{"signature": "@classmethod<EOL><INDENT>def from_spline(cls, tck, extrapolate=None):<DEDENT>", "body": "t, c, k = tck<EOL>cvals = np.empty((k + <NUM_LIT:1>, len(t)-<NUM_LIT:1>), dtype=c.dtype)<EOL>for m in xrange(k, -<NUM_LIT:1>, -<NUM_LIT:1>):<EOL><INDENT>y = fitpack.splev(t[:-<NUM_LIT:1>], tck, der=m)<EOL>cvals[k - m, :] = y/spec.gamma(m+<NUM_LIT:1>)<EOL><DEDENT>return cls.construct_fast(cvals, t, extrapolate)<EOL>", "docstring": "Construct a piecewise polynomial from a spline\n\nParameters\n----------\ntck\n    A spline, as returned by `splrep`\nextrapolate : bool, optional\n    Whether to extrapolate to ouf-of-bounds points based on first\n    and last intervals, or to return NaNs. Default: True.", "id": "f19272:c3:m5"}
{"signature": "def spltopp(xk, cvals, k):", "body": "return ppform.fromspline(xk, cvals, k)<EOL>", "docstring": "Return a piece-wise polynomial object from a fixed-spline tuple.", "id": "f19272:m20"}
{"signature": "def integrate(self, a, b, extrapolate=None):", "body": "if extrapolate is None:<EOL><INDENT>extrapolate = self.extrapolate<EOL><DEDENT>sign = <NUM_LIT:1><EOL>if b < a:<EOL><INDENT>a, b = b, a<EOL>sign = -<NUM_LIT:1><EOL><DEDENT>range_int = np.empty((prod(self.c.shape[<NUM_LIT:2>:]),), dtype=self.c.dtype)<EOL>self._ensure_c_contiguous()<EOL>_ppoly.integrate(self.c.reshape(self.c.shape[<NUM_LIT:0>], self.c.shape[<NUM_LIT:1>], -<NUM_LIT:1>),<EOL>self.x, a, b, bool(extrapolate),<EOL>out=range_int)<EOL>range_int *= sign<EOL>return range_int.reshape(self.c.shape[<NUM_LIT:2>:])<EOL>", "docstring": "Compute a definite integral over a piecewise polynomial.\n\nParameters\n----------\na : float\n    Lower integration bound\nb : float\n    Upper integration bound\nextrapolate : bool, optional\n    Whether to extrapolate to ouf-of-bounds points based on first\n    and last intervals, or to return NaNs.\n\nReturns\n-------\nig : array_like\n    Definite integral of the piecewise polynomial over [a, b]", "id": "f19272:c3:m3"}
{"signature": "def derivative(self, nu=<NUM_LIT:1>):", "body": "if nu < <NUM_LIT:0>:<EOL><INDENT>raise NotImplementedError('<STR_LIT>')<EOL><DEDENT>if nu > <NUM_LIT:1>:<EOL><INDENT>bp = self<EOL>for k in range(nu):<EOL><INDENT>bp = bp.derivative()<EOL><DEDENT>return bp<EOL><DEDENT>if nu == <NUM_LIT:0>:<EOL><INDENT>c2 = self.c.copy()<EOL><DEDENT>else:<EOL><INDENT>rest = (None,)*(self.c.ndim-<NUM_LIT:2>)<EOL>k = self.c.shape[<NUM_LIT:0>] - <NUM_LIT:1><EOL>dx = np.diff(self.x)[(None, slice(None))+rest]<EOL>c2 = k * np.diff(self.c, axis=<NUM_LIT:0>) / dx<EOL><DEDENT>if c2.shape[<NUM_LIT:0>] == <NUM_LIT:0>:<EOL><INDENT>c2 = np.zeros((<NUM_LIT:1>,) + c2.shape[<NUM_LIT:1>:], dtype=c2.dtype)<EOL><DEDENT>return self.construct_fast(c2, self.x, self.extrapolate)<EOL>", "docstring": "Construct a new piecewise polynomial representing the derivative.\n\nParameters\n----------\nnu : int, optional\n    Order of derivative to evaluate. (Default: 1)\n    If negative, the antiderivative is returned.\n\nReturns\n-------\nbp : BPoly\n    Piecewise polynomial of order k2 = k - nu representing the derivative\n    of this polynomial.", "id": "f19272:c4:m1"}
{"signature": "def interpn(points, values, xi, method=\"<STR_LIT>\", bounds_error=True,<EOL>fill_value=np.nan):", "body": "<EOL>if method not in [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" %<EOL>method)<EOL><DEDENT>if not hasattr(values, '<STR_LIT>'):<EOL><INDENT>values = np.asarray(values)<EOL><DEDENT>ndim = values.ndim<EOL>if ndim > <NUM_LIT:2> and method == \"<STR_LIT>\":<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>if not bounds_error and fill_value is None and method == \"<STR_LIT>\":<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if len(points) > ndim:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (len(points), ndim))<EOL><DEDENT>if len(points) != ndim and method == '<STR_LIT>':<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>for i, p in enumerate(points):<EOL><INDENT>if not np.all(np.diff(p) > <NUM_LIT:0.>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % i)<EOL><DEDENT>if not np.asarray(p).ndim == <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % i)<EOL><DEDENT>if not values.shape[i] == len(p):<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (len(p), values.shape[i], i))<EOL><DEDENT><DEDENT>grid = tuple([np.asarray(p) for p in points])<EOL>xi = _ndim_coords_from_arrays(xi, ndim=len(grid))<EOL>if xi.shape[-<NUM_LIT:1>] != len(grid):<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (xi.shape[<NUM_LIT:1>], len(grid)))<EOL><DEDENT>for i, p in enumerate(xi.T):<EOL><INDENT>if bounds_error and not np.logical_and(np.all(grid[i][<NUM_LIT:0>] <= p),<EOL>np.all(p <= grid[i][-<NUM_LIT:1>])):<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % i)<EOL><DEDENT><DEDENT>if method == \"<STR_LIT>\":<EOL><INDENT>interp = RegularGridInterpolator(points, values, method=\"<STR_LIT>\",<EOL>bounds_error=bounds_error,<EOL>fill_value=fill_value)<EOL>return interp(xi)<EOL><DEDENT>elif method == \"<STR_LIT>\":<EOL><INDENT>interp = RegularGridInterpolator(points, values, method=\"<STR_LIT>\",<EOL>bounds_error=bounds_error,<EOL>fill_value=fill_value)<EOL>return interp(xi)<EOL><DEDENT>elif method == \"<STR_LIT>\":<EOL><INDENT>xi_shape = xi.shape<EOL>xi = xi.reshape(-<NUM_LIT:1>, xi.shape[-<NUM_LIT:1>])<EOL>idx_valid = np.all((grid[<NUM_LIT:0>][<NUM_LIT:0>] <= xi[:, <NUM_LIT:0>], xi[:, <NUM_LIT:0>] <= grid[<NUM_LIT:0>][-<NUM_LIT:1>],<EOL>grid[<NUM_LIT:1>][<NUM_LIT:0>] <= xi[:, <NUM_LIT:1>], xi[:, <NUM_LIT:1>] <= grid[<NUM_LIT:1>][-<NUM_LIT:1>]),<EOL>axis=<NUM_LIT:0>)<EOL>result = np.empty_like(xi[:, <NUM_LIT:0>])<EOL>interp = RectBivariateSpline(points[<NUM_LIT:0>], points[<NUM_LIT:1>], values[:])<EOL>result[idx_valid] = interp.ev(xi[idx_valid, <NUM_LIT:0>], xi[idx_valid, <NUM_LIT:1>])<EOL>result[np.logical_not(idx_valid)] = fill_value<EOL>return result.reshape(xi_shape[:-<NUM_LIT:1>])<EOL><DEDENT>", "docstring": "Multidimensional interpolation on regular grids.\n\nParameters\n----------\npoints : tuple of ndarray of float, with shapes (m1, ), ..., (mn, )\n    The points defining the regular grid in n dimensions.\n\nvalues : array_like, shape (m1, ..., mn, ...)\n    The data on the regular grid in n dimensions.\n\nxi : ndarray of shape (..., ndim)\n    The coordinates to sample the gridded data at\n\nmethod : str\n    The method of interpolation to perform. Supported are \"linear\" and\n    \"nearest\", and \"splinef2d\". \"splinef2d\" is only supported for\n    2-dimensional data.\n\nbounds_error : bool, optional\n    If True, when interpolated values are requested outside of the\n    domain of the input data, a ValueError is raised.\n    If False, then `fill_value` is used.\n\nfill_value : number, optional\n    If provided, the value to use for points outside of the\n    interpolation domain. If None, values outside\n    the domain are extrapolated.  Extrapolation is not supported by method\n    \"splinef2d\".\n\nReturns\n-------\nvalues_x : ndarray, shape xi.shape[:-1] + values.shape[ndim:]\n    Interpolated values at input coordinates.\n\nNotes\n-----\n\n.. versionadded:: 0.14\n\nSee also\n--------\nNearestNDInterpolator : Nearest neighbour interpolation on unstructured\n                        data in N dimensions\n\nLinearNDInterpolator : Piecewise linear interpolant on unstructured data\n                       in N dimensions\n\nRegularGridInterpolator : Linear and nearest-neighbor Interpolation on a\n                          regular grid in arbitrary dimensions\n\nRectBivariateSpline : Bivariate spline approximation over a rectangular mesh", "id": "f19272:m3"}
{"signature": "def derivatives(self, x):", "body": "d,ier = dfitpack.spalde(*(self._eval_args+(x,)))<EOL>if not ier == <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % ier)<EOL><DEDENT>return d<EOL>", "docstring": "Return all derivatives of the spline at the point x.", "id": "f19273:c0:m11"}
{"signature": "def derivative(self, n=<NUM_LIT:1>):", "body": "tck = fitpack.splder(self._eval_args, n)<EOL>return UnivariateSpline._from_tck(tck, self.ext)<EOL>", "docstring": "Construct a new spline representing the derivative of this spline.\n\nParameters\n----------\nn : int, optional\n    Order of derivative to evaluate. Default: 1\n\nReturns\n-------\nspline : UnivariateSpline\n    Spline of order k2=k-n representing the derivative of this\n    spline.\n\nSee Also\n--------\nsplder, antiderivative\n\nNotes\n-----\n\n.. versionadded:: 0.13.0\n\nExamples\n--------\nThis can be used for finding maxima of a curve:\n\n>>> from scipy.interpolate import UnivariateSpline\n>>> x = np.linspace(0, 10, 70)\n>>> y = np.sin(x)\n>>> spl = UnivariateSpline(x, y, k=4, s=0)\n\nNow, differentiate the spline and find the zeros of the\nderivative. (NB: `sproot` only works for order 3 splines, so we\nfit an order 4 spline):\n\n>>> spl.derivative().roots() / np.pi\narray([ 0.50000001,  1.5       ,  2.49999998])\n\nThis agrees well with roots :math:`\\pi/2 + n\\pi` of `cos(x) = sin'(x)`.", "id": "f19273:c0:m13"}
{"signature": "def integral(self, a, b):", "body": "return dfitpack.splint(*(self._eval_args+(a,b)))<EOL>", "docstring": "Return definite integral of the spline between two given points.", "id": "f19273:c0:m10"}
{"signature": "def ev(self, theta, phi, dtheta=<NUM_LIT:0>, dphi=<NUM_LIT:0>):", "body": "return self.__call__(theta, phi, dtheta=dtheta, dphi=dphi, grid=False)<EOL>", "docstring": "Evaluate the spline at points\n\nReturns the interpolated value at ``(theta[i], phi[i]),\ni=0,...,len(theta)-1``.\n\nParameters\n----------\ntheta, phi : array-like\n    Input coordinates. Standard Numpy broadcasting is obeyed.\ndtheta : int\n    Order of theta-derivative\n\n    .. versionadded:: 0.14.0\ndphi : int\n    Order of phi-derivative\n\n    .. versionadded:: 0.14.0", "id": "f19273:c8:m1"}
{"signature": "def integral(self, xa, xb, ya, yb):", "body": "tx,ty,c = self.tck[:<NUM_LIT:3>]<EOL>kx,ky = self.degrees<EOL>return dfitpack.dblint(tx,ty,c,kx,ky,xa,xb,ya,yb)<EOL>", "docstring": "Evaluate the integral of the spline over area [xa,xb] x [ya,yb].\n\nParameters\n----------\nxa, xb : float\n    The end-points of the x integration interval.\nya, yb : float\n    The end-points of the y integration interval.\n\nReturns\n-------\ninteg : float\n    The value of the resulting integral.", "id": "f19273:c4:m2"}
{"signature": "@classmethod<EOL><INDENT>def _from_tck(cls, tck):<DEDENT>", "body": "self = cls.__new__(cls)<EOL>if len(tck) != <NUM_LIT:5>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self.tck = tck[:<NUM_LIT:3>]<EOL>self.degrees = tck[<NUM_LIT:3>:]<EOL>return self<EOL>", "docstring": "Construct a spline object from given tck and degree", "id": "f19273:c4:m0"}
{"signature": "def splantider(tck, n=<NUM_LIT:1>):", "body": "if n < <NUM_LIT:0>:<EOL><INDENT>return splder(tck, -n)<EOL><DEDENT>t, c, k = tck<EOL>for j in range(n):<EOL><INDENT>dt = t[k+<NUM_LIT:1>:] - t[:-k-<NUM_LIT:1>]<EOL>c = np.cumsum(c[:-k-<NUM_LIT:1>] * dt) / (k + <NUM_LIT:1>)<EOL>c = np.r_[<NUM_LIT:0>, c, [c[-<NUM_LIT:1>]]*(k+<NUM_LIT:2>)]<EOL>t = np.r_[t[<NUM_LIT:0>], t, t[-<NUM_LIT:1>]]<EOL>k += <NUM_LIT:1><EOL><DEDENT>return t, c, k<EOL>", "docstring": "Compute the spline for the antiderivative (integral) of a given spline.\n\nParameters\n----------\ntck : tuple of (t, c, k)\n    Spline whose antiderivative to compute\nn : int, optional\n    Order of antiderivative to evaluate. Default: 1\n\nReturns\n-------\ntck_ader : tuple of (t2, c2, k2)\n    Spline of order k2=k+n representing the antiderivative of the input\n    spline.\n\nSee Also\n--------\nsplder, splev, spalde\n\nNotes\n-----\nThe `splder` function is the inverse operation of this function.\nNamely, ``splder(splantider(tck))`` is identical to `tck`, modulo\nrounding error.\n\n.. versionadded:: 0.13.0\n\nExamples\n--------\n>>> from scipy.interpolate import splrep, splder, splantider, splev\n>>> x = np.linspace(0, np.pi/2, 70)\n>>> y = 1 / np.sqrt(1 - 0.8*np.sin(x)**2)\n>>> spl = splrep(x, y)\n\nThe derivative is the inverse operation of the antiderivative,\nalthough some floating point error accumulates:\n\n>>> splev(1.7, spl), splev(1.7, splder(splantider(spl)))\n(array(2.1565429877197317), array(2.1565429877201865))\n\nAntiderivative can be used to evaluate definite integrals:\n\n>>> ispl = splantider(spl)\n>>> splev(np.pi/2, ispl) - splev(0, ispl)\n2.2572053588768486\n\nThis is indeed an approximation to the complete elliptic integral\n:math:`K(m) = \\\\int_0^{\\\\pi/2} [1 - m\\\\sin^2 x]^{-1/2} dx`:\n\n>>> from scipy.special import ellipk\n>>> ellipk(0.8)\n2.2572053268208538", "id": "f19277:m13"}
{"signature": "def sproot(tck,mest=<NUM_LIT:10>):", "body": "t,c,k = tck<EOL>if k != <NUM_LIT:3>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>try:<EOL><INDENT>c[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>parametric = True<EOL><DEDENT>except:<EOL><INDENT>parametric = False<EOL><DEDENT>if parametric:<EOL><INDENT>return _ntlist(list(map(lambda c,t=t,k=k,mest=mest:sproot([t,c,k],mest),c)))<EOL><DEDENT>else:<EOL><INDENT>if len(t) < <NUM_LIT:8>:<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % len(t))<EOL><DEDENT>z,ier = _fitpack._sproot(t,c,k,mest)<EOL>if ier == <NUM_LIT:10>:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if ier == <NUM_LIT:0>:<EOL><INDENT>return z<EOL><DEDENT>if ier == <NUM_LIT:1>:<EOL><INDENT>warnings.warn(RuntimeWarning(\"<STR_LIT>\"))<EOL>return z<EOL><DEDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Find the roots of a cubic B-spline.\n\nGiven the knots (>=8) and coefficients of a cubic B-spline return the\nroots of the spline.\n\nParameters\n----------\ntck : tuple\n    A tuple (t,c,k) containing the vector of knots,\n    the B-spline coefficients, and the degree of the spline.\n    The number of knots must be >= 8, and the degree must be 3.\n    The knots must be a montonically increasing sequence.\nmest : int\n    An estimate of the number of zeros (Default is 10).\n\nReturns\n-------\nzeros : ndarray\n    An array giving the roots of the spline.\n\nSee also\n--------\nsplprep, splrep, splint, spalde, splev\nbisplrep, bisplev\nUnivariateSpline, BivariateSpline\n\n\nReferences\n----------\n.. [1] C. de Boor, \"On calculating with b-splines\", J. Approximation\n    Theory, 6, p.50-62, 1972.\n.. [2] M.G. Cox, \"The numerical evaluation of b-splines\", J. Inst. Maths\n    Applics, 10, p.134-149, 1972.\n.. [3] P. Dierckx, \"Curve and surface fitting with splines\", Monographs\n    on Numerical Analysis, Oxford University Press, 1993.", "id": "f19277:m6"}
{"signature": "def splev(x, tck, der=<NUM_LIT:0>, ext=<NUM_LIT:0>):", "body": "t,c,k = tck<EOL>try:<EOL><INDENT>c[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>parametric = True<EOL><DEDENT>except:<EOL><INDENT>parametric = False<EOL><DEDENT>if parametric:<EOL><INDENT>return list(map(lambda c, x=x, t=t, k=k, der=der: splev(x, [t,c,k], der, ext), c))<EOL><DEDENT>else:<EOL><INDENT>if not (<NUM_LIT:0> <= der <= k):<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % (der,k))<EOL><DEDENT>if ext not in (<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:3>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % ext)<EOL><DEDENT>x = asarray(x)<EOL>shape = x.shape<EOL>x = atleast_1d(x).ravel()<EOL>y, ier = _fitpack._spl_(x, der, t, c, k, ext)<EOL>if ier == <NUM_LIT:10>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if ier == <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if ier:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>return y.reshape(shape)<EOL><DEDENT>", "docstring": "Evaluate a B-spline or its derivatives.\n\nGiven the knots and coefficients of a B-spline representation, evaluate\nthe value of the smoothing polynomial and its derivatives.  This is a\nwrapper around the FORTRAN routines splev and splder of FITPACK.\n\nParameters\n----------\nx : array_like\n    An array of points at which to return the value of the smoothed\n    spline or its derivatives.  If `tck` was returned from `splprep`,\n    then the parameter values, u should be given.\ntck : tuple\n    A sequence of length 3 returned by `splrep` or `splprep` containing\n    the knots, coefficients, and degree of the spline.\nder : int\n    The order of derivative of the spline to compute (must be less than\n    or equal to k).\next : int\n    Controls the value returned for elements of ``x`` not in the\n    interval defined by the knot sequence.\n\n    * if ext=0, return the extrapolated value.\n    * if ext=1, return 0\n    * if ext=2, raise a ValueError\n    * if ext=3, return the boundary value.\n\n    The default value is 0.\n\nReturns\n-------\ny : ndarray or list of ndarrays\n    An array of values representing the spline function evaluated at\n    the points in ``x``.  If `tck` was returned from `splprep`, then this\n    is a list of arrays representing the curve in N-dimensional space.\n\nSee Also\n--------\nsplprep, splrep, sproot, spalde, splint\nbisplrep, bisplev\n\nReferences\n----------\n.. [1] C. de Boor, \"On calculating with b-splines\", J. Approximation\n    Theory, 6, p.50-62, 1972.\n.. [2] M.G. Cox, \"The numerical evaluation of b-splines\", J. Inst. Maths\n    Applics, 10, p.134-149, 1972.\n.. [3] P. Dierckx, \"Curve and surface fitting with splines\", Monographs\n    on Numerical Analysis, Oxford University Press, 1993.", "id": "f19277:m4"}
{"signature": "def bisplev(x,y,tck,dx=<NUM_LIT:0>,dy=<NUM_LIT:0>):", "body": "tx,ty,c,kx,ky = tck<EOL>if not (<NUM_LIT:0> <= dx < kx):<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % (dx,kx))<EOL><DEDENT>if not (<NUM_LIT:0> <= dy < ky):<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % (dy,ky))<EOL><DEDENT>x,y = map(myasarray,[x,y])<EOL>if (len(x.shape) != <NUM_LIT:1>) or (len(y.shape) != <NUM_LIT:1>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>z,ier = _fitpack._bispev(tx,ty,c,kx,ky,x,y,dx,dy)<EOL>if ier == <NUM_LIT:10>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if ier:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>z.shape = len(x),len(y)<EOL>if len(z) > <NUM_LIT:1>:<EOL><INDENT>return z<EOL><DEDENT>if len(z[<NUM_LIT:0>]) > <NUM_LIT:1>:<EOL><INDENT>return z[<NUM_LIT:0>]<EOL><DEDENT>return z[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>", "docstring": "Evaluate a bivariate B-spline and its derivatives.\n\nReturn a rank-2 array of spline function values (or spline derivative\nvalues) at points given by the cross-product of the rank-1 arrays `x` and\n`y`.  In special cases, return an array or just a float if either `x` or\n`y` or both are floats.  Based on BISPEV from FITPACK.\n\nParameters\n----------\nx, y : ndarray\n    Rank-1 arrays specifying the domain over which to evaluate the\n    spline or its derivative.\ntck : tuple\n    A sequence of length 5 returned by `bisplrep` containing the knot\n    locations, the coefficients, and the degree of the spline:\n    [tx, ty, c, kx, ky].\ndx, dy : int, optional\n    The orders of the partial derivatives in `x` and `y` respectively.\n\nReturns\n-------\nvals : ndarray\n    The B-spline or its derivative evaluated over the set formed by\n    the cross-product of `x` and `y`.\n\nSee Also\n--------\nsplprep, splrep, splint, sproot, splev\nUnivariateSpline, BivariateSpline\n\nNotes\n-----\n    See `bisplrep` to generate the `tck` representation.\n\nReferences\n----------\n.. [1] Dierckx P. : An algorithm for surface fitting\n   with spline functions\n   Ima J. Numer. Anal. 1 (1981) 267-283.\n.. [2] Dierckx P. : An algorithm for surface fitting\n   with spline functions\n   report tw50, Dept. Computer Science,K.U.Leuven, 1980.\n.. [3] Dierckx P. : Curve and surface fitting with splines,\n   Monographs on Numerical Analysis, Oxford University Press, 1993.", "id": "f19277:m9"}
{"signature": "def _intc_overflow(x, msg=None):", "body": "if x > iinfo(intc).max:<EOL><INDENT>if msg is None:<EOL><INDENT>msg = '<STR_LIT>' % x<EOL><DEDENT>raise OverflowError(msg)<EOL><DEDENT>return intc(x)<EOL>", "docstring": "Cast the value to an intc and raise an OverflowError if the value\n    cannot fit.", "id": "f19277:m0"}
{"signature": "def approximate_taylor_polynomial(f,x,degree,scale,order=None):", "body": "if order is None:<EOL><INDENT>order = degree<EOL><DEDENT>n = order+<NUM_LIT:1><EOL>xs = scale*np.cos(np.linspace(<NUM_LIT:0>,np.pi,n,endpoint=n % <NUM_LIT:1>)) + x<EOL>P = KroghInterpolator(xs, f(xs))<EOL>d = P.derivatives(x,der=degree+<NUM_LIT:1>)<EOL>return np.poly1d((d/factorial(np.arange(degree+<NUM_LIT:1>)))[::-<NUM_LIT:1>])<EOL>", "docstring": "Estimate the Taylor polynomial of f at x by polynomial fitting.\n\nParameters\n----------\nf : callable\n    The function whose Taylor polynomial is sought. Should accept\n    a vector of `x` values.\nx : scalar\n    The point at which the polynomial is to be evaluated.\ndegree : int\n    The degree of the Taylor polynomial\nscale : scalar\n    The width of the interval to use to evaluate the Taylor polynomial.\n    Function values spread over a range this wide are used to fit the\n    polynomial. Must be chosen carefully.\norder : int or None, optional\n    The order of the polynomial to be used in the fitting; `f` will be\n    evaluated ``order+1`` times. If None, use `degree`.\n\nReturns\n-------\np : poly1d instance\n    The Taylor polynomial (translated to the origin, so that\n    for example p(0)=f(x)).\n\nNotes\n-----\nThe appropriate choice of \"scale\" is a trade-off; too large and the\nfunction differs from its Taylor polynomial too much to get a good\nanswer, too small and round-off errors overwhelm the higher-order terms.\nThe algorithm used becomes numerically unstable around order 30 even\nunder ideal circumstances.\n\nChoosing order somewhat larger than degree may improve the higher-order\nterms.", "id": "f19281:m2"}
{"signature": "def derivative(self, x, der=<NUM_LIT:1>):", "body": "x, x_shape = self._prepare_x(x)<EOL>y = self._evaluate_derivatives(x, der+<NUM_LIT:1>)<EOL>return self._finish_y(y[der], x_shape)<EOL>", "docstring": "Evaluate one derivative of the polynomial at the point x\n\nParameters\n----------\nx : array-like\n    Point or points at which to evaluate the derivatives\n\nder : integer, optional\n    Which derivative to extract. This number includes the\n    function value as 0th derivative.\n\nReturns\n-------\nd : ndarray\n    Derivative interpolated at the x-points.  Shape of d is\n    determined by replacing the interpolation axis in the\n    original array with the shape of x.\n\nNotes\n-----\nThis is computed by evaluating all derivatives up to the desired\none (using self.derivatives()) and then discarding the rest.", "id": "f19281:c1:m1"}
{"signature": "def _get_array(shape, dtype):", "body": "if len(shape) == <NUM_LIT:2> and shape[<NUM_LIT:0>] == <NUM_LIT:2>:<EOL><INDENT>x = np.zeros(shape, dtype=dtype)<EOL>x[<NUM_LIT:0>,<NUM_LIT:1>:] = -<NUM_LIT:1><EOL>x[<NUM_LIT:1>] = <NUM_LIT:2><EOL>return x<EOL><DEDENT>elif len(shape) == <NUM_LIT:2> and shape[<NUM_LIT:0>] == shape[<NUM_LIT:1>]:<EOL><INDENT>x = np.zeros(shape, dtype=dtype)<EOL>j = np.arange(shape[<NUM_LIT:0>])<EOL>x[j,j] = <NUM_LIT:2><EOL>x[j[:-<NUM_LIT:1>],j[:-<NUM_LIT:1>]+<NUM_LIT:1>] = -<NUM_LIT:1><EOL>x[j[:-<NUM_LIT:1>]+<NUM_LIT:1>,j[:-<NUM_LIT:1>]] = -<NUM_LIT:1><EOL>return x<EOL><DEDENT>else:<EOL><INDENT>np.random.seed(<NUM_LIT>)<EOL>return np.random.randn(*shape).astype(dtype)<EOL><DEDENT>", "docstring": "Get a test array of given shape and data type.\nReturned NxN matrices are posdef, and 2xN are banded-posdef.", "id": "f19284:m0"}
{"signature": "def _logm(A):", "body": "A = np.asarray(A)<EOL>if len(A.shape) != <NUM_LIT:2> or A.shape[<NUM_LIT:0>] != A.shape[<NUM_LIT:1>]:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>n = A.shape[<NUM_LIT:0>]<EOL>if issubclass(A.dtype.type, np.integer):<EOL><INDENT>A = np.asarray(A, dtype=float)<EOL><DEDENT>keep_it_real = np.isrealobj(A)<EOL>try:<EOL><INDENT>if np.array_equal(A, np.triu(A)):<EOL><INDENT>A = _logm_force_nonsingular_triangular_matrix(A)<EOL>if np.min(np.diag(A)) < <NUM_LIT:0>:<EOL><INDENT>A = A.astype(complex)<EOL><DEDENT>return _logm_triu(A)<EOL><DEDENT>else:<EOL><INDENT>if keep_it_real:<EOL><INDENT>T, Z = schur(A)<EOL>if not np.array_equal(T, np.triu(T)):<EOL><INDENT>T, Z = rsf2csf(T,Z)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>T, Z = schur(A, output='<STR_LIT>')<EOL><DEDENT>T = _logm_force_nonsingular_triangular_matrix(T, inplace=True)<EOL>U = _logm_triu(T)<EOL>ZH = np.conjugate(Z).T<EOL>return Z.dot(U).dot(ZH)<EOL><DEDENT><DEDENT>except (SqrtmError, LogmError) as e:<EOL><INDENT>X = np.empty_like(A)<EOL>X.fill(np.nan)<EOL>return X<EOL><DEDENT>", "docstring": "Compute the matrix logarithm.\n\nSee the logm docstring in matfuncs.py for more info.\n\nNotes\n-----\nIn this function we look at triangular matrices that are similar\nto the input matrix.  If any diagonal entry of such a triangular matrix\nis exactly zero then the original matrix is singular.\nThe matrix logarithm does not exist for such matrices,\nbut in such cases we will pretend that the diagonal entries that are zero\nare actually slightly positive by an ad-hoc amount, in the interest\nof returning something more useful than NaN.  This will cause a warning.", "id": "f19285:m13"}
{"signature": "def _fractional_power_superdiag_entry(l1, l2, t12, p):", "body": "if l1 == l2:<EOL><INDENT>f12 = t12 * p * l1**(p-<NUM_LIT:1>)<EOL><DEDENT>elif abs(l1) < abs(l2) / <NUM_LIT:2> or abs(l2) < abs(l1) / <NUM_LIT:2>:<EOL><INDENT>f12 = t12 * ((l2**p) - (l1**p)) / (l2 - l1)<EOL><DEDENT>else:<EOL><INDENT>z = (l2 - l1) / (l2 + l1)<EOL>log_l1 = np.log(l1)<EOL>log_l2 = np.log(l2)<EOL>arctanh_z = np.arctanh(z)<EOL>tmp_a = t12 * np.exp((p/<NUM_LIT:2>)*(log_l2 + log_l1))<EOL>tmp_u = _unwindk(log_l2 - log_l1)<EOL>if tmp_u:<EOL><INDENT>tmp_b = p * (arctanh_z + np.pi * <NUM_LIT> * tmp_u)<EOL><DEDENT>else:<EOL><INDENT>tmp_b = p * arctanh_z<EOL><DEDENT>tmp_c = <NUM_LIT:2> * np.sinh(tmp_b) / (l2 - l1)<EOL>f12 = tmp_a * tmp_c<EOL><DEDENT>return f12<EOL>", "docstring": "Compute a superdiagonal entry of a fractional matrix power.\n\nThis is Eq. (5.6) in [1]_.\n\nParameters\n----------\nl1 : complex\n    A diagonal entry of the matrix.\nl2 : complex\n    A diagonal entry of the matrix.\nt12 : complex\n    A superdiagonal entry of the matrix.\np : float\n    A fractional power.\n\nReturns\n-------\nf12 : complex\n    A superdiagonal entry of the fractional matrix power.\n\nNotes\n-----\nSome amount of care has been taken to return a real number\nif all of the inputs are real.\n\nReferences\n----------\n.. [1] Nicholas J. Higham and Lijing lin (2011)\n       \"A Schur-Pade Algorithm for Fractional Powers of a Matrix.\"\n       SIAM Journal on Matrix Analysis and Applications,\n       32 (3). pp. 1056-1078. ISSN 0895-4798", "id": "f19285:m3"}
{"signature": "def _logm_triu(T):", "body": "T = np.asarray(T)<EOL>if len(T.shape) != <NUM_LIT:2> or T.shape[<NUM_LIT:0>] != T.shape[<NUM_LIT:1>]:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>n, n = T.shape<EOL>T_diag = np.diag(T)<EOL>keep_it_real = np.isrealobj(T) and np.min(T_diag) >= <NUM_LIT:0><EOL>if keep_it_real:<EOL><INDENT>T0 = T<EOL><DEDENT>else:<EOL><INDENT>T0 = T.astype(complex)<EOL><DEDENT>theta = (None,<EOL><NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>,<EOL><NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>,<EOL><NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>,<EOL><NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>)<EOL>R, s, m = _inverse_squaring_helper(T0, theta)<EOL>nodes, weights = scipy.special.p_roots(m)<EOL>nodes = nodes.real<EOL>if nodes.shape != (m,) or weights.shape != (m,):<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>nodes = <NUM_LIT:0.5> + <NUM_LIT:0.5> * nodes<EOL>weights = <NUM_LIT:0.5> * weights<EOL>ident = np.identity(n)<EOL>U = np.zeros_like(R)<EOL>for alpha, beta in zip(weights, nodes):<EOL><INDENT>U += solve_triangular(ident + beta*R, alpha*R)<EOL><DEDENT>U *= np.exp2(s)<EOL>has_principal_branch = all(x.real > <NUM_LIT:0> or x.imag != <NUM_LIT:0> for x in np.diag(T0))<EOL>if has_principal_branch:<EOL><INDENT>U[np.diag_indices(n)] = np.log(np.diag(T0))<EOL>for i in range(n-<NUM_LIT:1>):<EOL><INDENT>l1 = T0[i, i]<EOL>l2 = T0[i+<NUM_LIT:1>, i+<NUM_LIT:1>]<EOL>t12 = T0[i, i+<NUM_LIT:1>]<EOL>U[i, i+<NUM_LIT:1>] = _logm_superdiag_entry(l1, l2, t12)<EOL><DEDENT><DEDENT>if not np.array_equal(U, np.triu(U)):<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>return U<EOL>", "docstring": "Compute matrix logarithm of an upper triangular matrix.\n\nThe matrix logarithm is the inverse of\nexpm: expm(logm(`T`)) == `T`\n\nParameters\n----------\nT : (N, N) array_like\n    Upper triangular matrix whose logarithm to evaluate\n\nReturns\n-------\nlogm : (N, N) ndarray\n    Matrix logarithm of `T`\n\nReferences\n----------\n.. [1] Awad H. Al-Mohy and Nicholas J. Higham (2012)\n       \"Improved Inverse Scaling and Squaring Algorithms\n       for the Matrix Logarithm.\"\n       SIAM Journal on Scientific Computing, 34 (4). C152-C169.\n       ISSN 1095-7197\n\n.. [2] Nicholas J. Higham (2008)\n       \"Functions of Matrices: Theory and Computation\"\n       ISBN 978-0-898716-46-7\n\n.. [3] Nicholas J. Higham and Lijing lin (2011)\n       \"A Schur-Pade Algorithm for Fractional Powers of a Matrix.\"\n       SIAM Journal on Matrix Analysis and Applications,\n       32 (3). pp. 1056-1078. ISSN 0895-4798", "id": "f19285:m11"}
{"signature": "def _onenormest_m1_power(A, p,<EOL>t=<NUM_LIT:2>, itmax=<NUM_LIT:5>, compute_v=False, compute_w=False):", "body": "return onenormest(_MatrixM1PowerOperator(A, p),<EOL>t=t, itmax=itmax, compute_v=compute_v, compute_w=compute_w)<EOL>", "docstring": "Efficiently estimate the 1-norm of (A - I)^p.\n\nParameters\n----------\nA : ndarray\n    Matrix whose 1-norm of a power is to be computed.\np : int\n    Non-negative integer power.\nt : int, optional\n    A positive parameter controlling the tradeoff between\n    accuracy versus time and memory usage.\n    Larger values take longer and use more memory\n    but give more accurate output.\nitmax : int, optional\n    Use at most this many iterations.\ncompute_v : bool, optional\n    Request a norm-maximizing linear operator input vector if True.\ncompute_w : bool, optional\n    Request a norm-maximizing linear operator output vector if True.\n\nReturns\n-------\nest : float\n    An underestimate of the 1-norm of the sparse matrix.\nv : ndarray, optional\n    The vector such that ||Av||_1 == est*||v||_1.\n    It can be thought of as an input to the linear operator\n    that gives an output with particularly large norm.\nw : ndarray, optional\n    The vector Av which has relatively large 1-norm.\n    It can be thought of as an output of the linear operator\n    that is relatively large in norm compared to the input.", "id": "f19285:m0"}
{"signature": "def _remainder_matrix_power_triu(T, t):", "body": "m_to_theta = {<EOL><NUM_LIT:1>: <NUM_LIT>,<EOL><NUM_LIT:2>: <NUM_LIT>,<EOL><NUM_LIT:3>: <NUM_LIT>,<EOL><NUM_LIT:4>: <NUM_LIT>,<EOL><NUM_LIT:5>: <NUM_LIT>,<EOL><NUM_LIT:6>: <NUM_LIT>,<EOL><NUM_LIT:7>: <NUM_LIT>,<EOL>}<EOL>n, n = T.shape<EOL>T0 = T<EOL>T0_diag = np.diag(T0)<EOL>if np.array_equal(T0, np.diag(T0_diag)):<EOL><INDENT>U = np.diag(T0_diag ** t)<EOL><DEDENT>else:<EOL><INDENT>R, s, m = _inverse_squaring_helper(T0, m_to_theta)<EOL>U = _fractional_power_pade(-R, t, m)<EOL>eivals = np.diag(T0)<EOL>has_principal_branch = all(x.real > <NUM_LIT:0> or x.imag != <NUM_LIT:0> for x in eivals)<EOL>for i in range(s, -<NUM_LIT:1>, -<NUM_LIT:1>):<EOL><INDENT>if i < s:<EOL><INDENT>U = U.dot(U)<EOL><DEDENT>else:<EOL><INDENT>if has_principal_branch:<EOL><INDENT>p = t * np.exp2(-i)<EOL>U[np.diag_indices(n)] = T0_diag ** p<EOL>for j in range(n-<NUM_LIT:1>):<EOL><INDENT>l1 = T0[j, j]<EOL>l2 = T0[j+<NUM_LIT:1>, j+<NUM_LIT:1>]<EOL>t12 = T0[j, j+<NUM_LIT:1>]<EOL>f12 = _fractional_power_superdiag_entry(l1, l2, t12, p)<EOL>U[j, j+<NUM_LIT:1>] = f12<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>if not np.array_equal(U, np.triu(U)):<EOL><INDENT>raise Exception('<STR_LIT>')<EOL><DEDENT>return U<EOL>", "docstring": "Compute a fractional power of an upper triangular matrix.\n\nThe fractional power is restricted to fractions -1 < t < 1.\nThis uses algorithm (3.1) of [1]_.\nThe Pade approximation itself uses algorithm (4.1) of [2]_.\n\nParameters\n----------\nT : (N, N) array_like\n    Upper triangular matrix whose fractional power to evaluate.\nt : float\n    Fractional power between -1 and 1 exclusive.\n\nReturns\n-------\nX : (N, N) array_like\n    The fractional power of the matrix.\n\nReferences\n----------\n.. [1] Nicholas J. Higham and Lijing Lin (2013)\n       \"An Improved Schur-Pade Algorithm for Fractional Powers\n       of a Matrix and their Frechet Derivatives.\"\n\n.. [2] Nicholas J. Higham and Lijing lin (2011)\n       \"A Schur-Pade Algorithm for Fractional Powers of a Matrix.\"\n       SIAM Journal on Matrix Analysis and Applications,\n       32 (3). pp. 1056-1078. ISSN 0895-4798", "id": "f19285:m8"}
{"signature": "def norm(a, ord=None):", "body": "<EOL>a = np.asarray_chkfinite(a)<EOL>if ord in (None, <NUM_LIT:2>) and (a.ndim == <NUM_LIT:1>) and (a.dtype.char in '<STR_LIT>'):<EOL><INDENT>func_name = _nrm2_prefix.get(a.dtype.char, '<STR_LIT:d>') + '<STR_LIT>'<EOL>nrm2 = getattr(blas, func_name)<EOL>return nrm2(a)<EOL><DEDENT>return np.linalg.norm(a, ord=ord)<EOL>", "docstring": "Matrix or vector norm.\n\nThis function is able to return one of seven different matrix norms,\nor one of an infinite number of vector norms (described below), depending\non the value of the ``ord`` parameter.\n\nParameters\n----------\nx : (M,) or (M, N) array_like\n    Input array.\nord : {non-zero int, inf, -inf, 'fro'}, optional\n    Order of the norm (see table under ``Notes``). inf means numpy's\n    `inf` object.\n\nReturns\n-------\nnorm : float\n    Norm of the matrix or vector.\n\nNotes\n-----\nFor values of ``ord <= 0``, the result is, strictly speaking, not a\nmathematical 'norm', but it may still be useful for various numerical\npurposes.\n\nThe following norms can be calculated:\n\n=====  ============================  ==========================\nord    norm for matrices             norm for vectors\n=====  ============================  ==========================\nNone   Frobenius norm                2-norm\n'fro'  Frobenius norm                --\ninf    max(sum(abs(x), axis=1))      max(abs(x))\n-inf   min(sum(abs(x), axis=1))      min(abs(x))\n0      --                            sum(x != 0)\n1      max(sum(abs(x), axis=0))      as below\n-1     min(sum(abs(x), axis=0))      as below\n2      2-norm (largest sing. value)  as below\n-2     smallest singular value       as below\nother  --                            sum(abs(x)**ord)**(1./ord)\n=====  ============================  ==========================\n\nThe Frobenius norm is given by [1]_:\n\n    :math:`||A||_F = [\\\\sum_{i,j} abs(a_{i,j})^2]^{1/2}`\n\nReferences\n----------\n.. [1] G. H. Golub and C. F. Van Loan, *Matrix Computations*,\n       Baltimore, MD, Johns Hopkins University Press, 1985, pg. 15\n\nExamples\n--------\n>>> from scipy.linalg import norm\n>>> a = np.arange(9) - 4\n>>> a\narray([-4, -3, -2, -1,  0,  1,  2,  3,  4])\n>>> b = a.reshape((3, 3))\n>>> b\narray([[-4, -3, -2],\n       [-1,  0,  1],\n       [ 2,  3,  4]])\n\n>>> norm(a)\n7.745966692414834\n>>> norm(b)\n7.745966692414834\n>>> norm(b, 'fro')\n7.745966692414834\n>>> norm(a, np.inf)\n4\n>>> norm(b, np.inf)\n9\n>>> norm(a, -np.inf)\n0\n>>> norm(b, -np.inf)\n2\n\n>>> norm(a, 1)\n20\n>>> norm(b, 1)\n7\n>>> norm(a, -1)\n-4.6566128774142013e-010\n>>> norm(b, -1)\n6\n>>> norm(a, 2)\n7.745966692414834\n>>> norm(b, 2)\n7.3484692283495345\n\n>>> norm(a, -2)\nnan\n>>> norm(b, -2)\n1.8570331885190563e-016\n>>> norm(a, 3)\n5.8480354764257312\n>>> norm(a, -3)\nnan", "id": "f19286:m0"}
{"signature": "def _get_al_mohy_higham_2012_experiment_1():", "body": "A = np.array([<EOL>[<NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>],<EOL>[<NUM_LIT:0>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>],<EOL>[<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT>, <NUM_LIT>],<EOL>[<NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT:0>, <NUM_LIT>]], dtype=float)<EOL>return A<EOL>", "docstring": "Return the test matrix from Experiment (1) of [1]_.\n\nReferences\n----------\n.. [1] Awad H. Al-Mohy and Nicholas J. Higham (2012)\n       \"Improved Inverse Scaling and Squaring Algorithms\n       for the Matrix Logarithm.\"\n       SIAM Journal on Scientific Computing, 34 (4). C152-C169.\n       ISSN 1095-7197", "id": "f19292:m0"}
{"signature": "def check_case(self, a, b, q, r):", "body": "x = solve_continuous_are(a, b, q, r)<EOL>assert_array_almost_equal(<EOL>a.getH()*x + x*a - x*b*inv(r)*b.getH()*x + q, <NUM_LIT:0.0>)<EOL>", "docstring": "Checks if (A'X + XA - XBR^-1B'X+Q=0) is true", "id": "f19293:c1:m0"}
{"signature": "def symrand(dim_or_eigv):", "body": "if isinstance(dim_or_eigv, int):<EOL><INDENT>dim = dim_or_eigv<EOL>d = (rand(dim)*<NUM_LIT:2>)-<NUM_LIT:1><EOL><DEDENT>elif (isinstance(dim_or_eigv, ndarray) and<EOL>len(dim_or_eigv.shape) == <NUM_LIT:1>):<EOL><INDENT>dim = dim_or_eigv.shape[<NUM_LIT:0>]<EOL>d = dim_or_eigv<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>v = random_rot(dim)<EOL>h = dot(dot(v.T.conj(), diag(d)), v)<EOL>h = <NUM_LIT:0.5>*(h.T+h)<EOL>return h<EOL>", "docstring": "Return a random symmetric (Hermitian) matrix.\n\n    If 'dim_or_eigv' is an integer N, return a NxN matrix, with eigenvalues\n        uniformly distributed on (-1,1).\n\n    If 'dim_or_eigv' is  1-D real array 'a', return a matrix whose\n                      eigenvalues are 'a'.", "id": "f19295:m1"}
{"signature": "def _get_func(func, ps='<STR_LIT>'):", "body": "for p in ps:<EOL><INDENT>f = getattr(fblas, p+func, None)<EOL>if f is None:<EOL><INDENT>continue<EOL><DEDENT>yield f<EOL><DEDENT>", "docstring": "Just a helper: return a specified BLAS function w/typecode.", "id": "f19298:m2"}
{"signature": "def interp_decomp(A, eps_or_k, rand=True):", "body": "from scipy.sparse.linalg import LinearOperator<EOL>real = _is_real(A)<EOL>if isinstance(A, np.ndarray):<EOL><INDENT>if eps_or_k < <NUM_LIT:1>:<EOL><INDENT>eps = eps_or_k<EOL>if rand:<EOL><INDENT>if real:<EOL><INDENT>k, idx, proj = backend.iddp_aid(eps, A)<EOL><DEDENT>else:<EOL><INDENT>k, idx, proj = backend.idzp_aid(eps, A)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if real:<EOL><INDENT>k, idx, proj = backend.iddp_id(eps, A)<EOL><DEDENT>else:<EOL><INDENT>k, idx, proj = backend.idzp_id(eps, A)<EOL><DEDENT><DEDENT>return k, idx - <NUM_LIT:1>, proj<EOL><DEDENT>else:<EOL><INDENT>k = int(eps_or_k)<EOL>if rand:<EOL><INDENT>if real:<EOL><INDENT>idx, proj = backend.iddr_aid(A, k)<EOL><DEDENT>else:<EOL><INDENT>idx, proj = backend.idzr_aid(A, k)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if real:<EOL><INDENT>idx, proj = backend.iddr_id(A, k)<EOL><DEDENT>else:<EOL><INDENT>idx, proj = backend.idzr_id(A, k)<EOL><DEDENT><DEDENT>return idx - <NUM_LIT:1>, proj<EOL><DEDENT><DEDENT>elif isinstance(A, LinearOperator):<EOL><INDENT>m, n = A.shape<EOL>matveca = A.rmatvec<EOL>if eps_or_k < <NUM_LIT:1>:<EOL><INDENT>eps = eps_or_k<EOL>if real:<EOL><INDENT>k, idx, proj = backend.iddp_rid(eps, m, n, matveca)<EOL><DEDENT>else:<EOL><INDENT>k, idx, proj = backend.idzp_rid(eps, m, n, matveca)<EOL><DEDENT>return k, idx - <NUM_LIT:1>, proj<EOL><DEDENT>else:<EOL><INDENT>k = int(eps_or_k)<EOL>if real:<EOL><INDENT>idx, proj = backend.iddr_rid(m, n, matveca, k)<EOL><DEDENT>else:<EOL><INDENT>idx, proj = backend.idzr_rid(m, n, matveca, k)<EOL><DEDENT>return idx - <NUM_LIT:1>, proj<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise _TYPE_ERROR<EOL><DEDENT>", "docstring": "Compute ID of a matrix.\n\nAn ID of a matrix `A` is a factorization defined by a rank `k`, a column\nindex array `idx`, and interpolation coefficients `proj` such that::\n\n    numpy.dot(A[:,idx[:k]], proj) = A[:,idx[k:]]\n\nThe original matrix can then be reconstructed as::\n\n    numpy.hstack([A[:,idx[:k]],\n                                numpy.dot(A[:,idx[:k]], proj)]\n                            )[:,numpy.argsort(idx)]\n\nor via the routine :func:`reconstruct_matrix_from_id`. This can\nequivalently be written as::\n\n    numpy.dot(A[:,idx[:k]],\n                        numpy.hstack([numpy.eye(k), proj])\n                      )[:,np.argsort(idx)]\n\nin terms of the skeleton and interpolation matrices::\n\n    B = A[:,idx[:k]]\n\nand::\n\n    P = numpy.hstack([numpy.eye(k), proj])[:,np.argsort(idx)]\n\nrespectively. See also :func:`reconstruct_interp_matrix` and\n:func:`reconstruct_skel_matrix`.\n\nThe ID can be computed to any relative precision or rank (depending on the\nvalue of `eps_or_k`). If a precision is specified (`eps_or_k < 1`), then\nthis function has the output signature::\n\n    k, idx, proj = interp_decomp(A, eps_or_k)\n\nOtherwise, if a rank is specified (`eps_or_k >= 1`), then the output\nsignature is::\n\n    idx, proj = interp_decomp(A, eps_or_k)\n\n..  This function automatically detects the form of the input parameters\n    and passes them to the appropriate backend. For details, see\n    :func:`backend.iddp_id`, :func:`backend.iddp_aid`,\n    :func:`backend.iddp_rid`, :func:`backend.iddr_id`,\n    :func:`backend.iddr_aid`, :func:`backend.iddr_rid`,\n    :func:`backend.idzp_id`, :func:`backend.idzp_aid`,\n    :func:`backend.idzp_rid`, :func:`backend.idzr_id`,\n    :func:`backend.idzr_aid`, and :func:`backend.idzr_rid`.\n\nParameters\n----------\nA : :class:`numpy.ndarray` or :class:`scipy.sparse.linalg.LinearOperator` with `rmatvec`\n    Matrix to be factored\neps_or_k : float or int\n    Relative error (if `eps_or_k < 1`) or rank (if `eps_or_k >= 1`) of\n    approximation.\nrand : bool, optional\n    Whether to use random sampling if `A` is of type :class:`numpy.ndarray`\n    (randomized algorithms are always used if `A` is of type\n    :class:`scipy.sparse.linalg.LinearOperator`).\n\nReturns\n-------\nk : int\n    Rank required to achieve specified relative precision if\n    `eps_or_k < 1`.\nidx : :class:`numpy.ndarray`\n    Column index array.\nproj : :class:`numpy.ndarray`\n    Interpolation coefficients.", "id": "f19302:m3"}
{"signature": "def estimate_spectral_norm_diff(A, B, its=<NUM_LIT:20>):", "body": "from scipy.sparse.linalg import aslinearoperator<EOL>A = aslinearoperator(A)<EOL>B = aslinearoperator(B)<EOL>m, n = A.shape<EOL>matvec1 = lambda x: A. matvec(x)<EOL>matveca1 = lambda x: A.rmatvec(x)<EOL>matvec2 = lambda x: B. matvec(x)<EOL>matveca2 = lambda x: B.rmatvec(x)<EOL>if _is_real(A):<EOL><INDENT>return backend.idd_diffsnorm(<EOL>m, n, matveca1, matveca2, matvec1, matvec2, its=its)<EOL><DEDENT>else:<EOL><INDENT>return backend.idz_diffsnorm(<EOL>m, n, matveca1, matveca2, matvec1, matvec2, its=its)<EOL><DEDENT>", "docstring": "Estimate spectral norm of the difference of two matrices by the randomized\npower method.\n\n..  This function automatically detects the matrix data type and calls the\n    appropriate backend. For details, see :func:`backend.idd_diffsnorm` and\n    :func:`backend.idz_diffsnorm`.\n\nParameters\n----------\nA : :class:`scipy.sparse.linalg.LinearOperator`\n    First matrix given as a :class:`scipy.sparse.linalg.LinearOperator` with the\n    `matvec` and `rmatvec` methods (to apply the matrix and its adjoint).\nB : :class:`scipy.sparse.linalg.LinearOperator`\n    Second matrix given as a :class:`scipy.sparse.linalg.LinearOperator` with\n    the `matvec` and `rmatvec` methods (to apply the matrix and its adjoint).\nits : int\n    Number of power method iterations.\n\nReturns\n-------\nfloat\n    Spectral norm estimate of matrix difference.", "id": "f19302:m9"}
{"signature": "def estimate_spectral_norm(A, its=<NUM_LIT:20>):", "body": "from scipy.sparse.linalg import aslinearoperator<EOL>A = aslinearoperator(A)<EOL>m, n = A.shape<EOL>matvec = lambda x: A. matvec(x)<EOL>matveca = lambda x: A.rmatvec(x)<EOL>if _is_real(A):<EOL><INDENT>return backend.idd_snorm(m, n, matveca, matvec, its=its)<EOL><DEDENT>else:<EOL><INDENT>return backend.idz_snorm(m, n, matveca, matvec, its=its)<EOL><DEDENT>", "docstring": "Estimate spectral norm of a matrix by the randomized power method.\n\n..  This function automatically detects the matrix data type and calls the\n    appropriate backend. For details, see :func:`backend.idd_snorm` and\n    :func:`backend.idz_snorm`.\n\nParameters\n----------\nA : :class:`scipy.sparse.linalg.LinearOperator`\n    Matrix given as a :class:`scipy.sparse.linalg.LinearOperator` with the\n    `matvec` and `rmatvec` methods (to apply the matrix and its adjoint).\nits : int\n    Number of power method iterations.\n\nReturns\n-------\nfloat\n    Spectral norm estimate.", "id": "f19302:m8"}
{"signature": "def cholesky_banded(ab, overwrite_ab=False, lower=False, check_finite=True):", "body": "if check_finite:<EOL><INDENT>ab = asarray_chkfinite(ab)<EOL><DEDENT>else:<EOL><INDENT>ab = asarray(ab)<EOL><DEDENT>pbtrf, = get_lapack_funcs(('<STR_LIT>',), (ab,))<EOL>c, info = pbtrf(ab, lower=lower, overwrite_ab=overwrite_ab)<EOL>if info > <NUM_LIT:0>:<EOL><INDENT>raise LinAlgError(\"<STR_LIT>\" % info)<EOL><DEDENT>if info < <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>% -info)<EOL><DEDENT>return c<EOL>", "docstring": "Cholesky decompose a banded Hermitian positive-definite matrix\n\nThe matrix a is stored in ab either in lower diagonal or upper\ndiagonal ordered form:\n\n    ab[u + i - j, j] == a[i,j]        (if upper form; i <= j)\n    ab[    i - j, j] == a[i,j]        (if lower form; i >= j)\n\nExample of ab (shape of a is (6,6), u=2)::\n\n    upper form:\n    *   *   a02 a13 a24 a35\n    *   a01 a12 a23 a34 a45\n    a00 a11 a22 a33 a44 a55\n\n    lower form:\n    a00 a11 a22 a33 a44 a55\n    a10 a21 a32 a43 a54 *\n    a20 a31 a42 a53 *   *\n\nParameters\n----------\nab : (u + 1, M) array_like\n    Banded matrix\noverwrite_ab : boolean\n    Discard data in ab (may enhance performance)\nlower : boolean\n    Is the matrix in the lower form. (Default is upper form)\ncheck_finite : boolean, optional\n    Whether to check that the input matrix contains only finite numbers.\n    Disabling may give a performance gain, but may result in problems\n    (crashes, non-termination) if the inputs do contain infinities or NaNs.\n\nReturns\n-------\nc : (u + 1, M) ndarray\n    Cholesky factorization of a, in the same banded format as ab", "id": "f19303:m4"}
{"signature": "def diagsvd(s, M, N):", "body": "part = diag(s)<EOL>typ = part.dtype.char<EOL>MorN = len(s)<EOL>if MorN == M:<EOL><INDENT>return r_['<STR_LIT>', part, zeros((M, N-M), typ)]<EOL><DEDENT>elif MorN == N:<EOL><INDENT>return r_[part, zeros((M-N,N), typ)]<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Construct the sigma matrix in SVD from singular values and size M, N.\n\nParameters\n----------\ns : (M,) or (N,) array_like\n    Singular values\nM : int\n    Size of the matrix whose singular values are `s`.\nN : int\n    Size of the matrix whose singular values are `s`.\n\nReturns\n-------\nS : (M, N) ndarray\n    The S-matrix in the singular value decomposition", "id": "f19304:m2"}
{"signature": "def svd(a, full_matrices=True, compute_uv=True, overwrite_a=False,<EOL>check_finite=True):", "body": "if check_finite:<EOL><INDENT>a1 = asarray_chkfinite(a)<EOL><DEDENT>else:<EOL><INDENT>a1 = asarray(a)<EOL><DEDENT>if len(a1.shape) != <NUM_LIT:2>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>m,n = a1.shape<EOL>overwrite_a = overwrite_a or (_datacopied(a1, a))<EOL>gesdd, gesdd_lwork = get_lapack_funcs(('<STR_LIT>', '<STR_LIT>'), (a1,))<EOL>lwork, info = gesdd_lwork(a1.shape[<NUM_LIT:0>], a1.shape[<NUM_LIT:1>], compute_uv=compute_uv, full_matrices=full_matrices)<EOL>if info != <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>' % info)<EOL><DEDENT>lwork = int(lwork.real)<EOL>u,s,v,info = gesdd(a1, compute_uv=compute_uv, lwork=lwork,<EOL>full_matrices=full_matrices, overwrite_a=overwrite_a)<EOL>if info > <NUM_LIT:0>:<EOL><INDENT>raise LinAlgError(\"<STR_LIT>\")<EOL><DEDENT>if info < <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>% -info)<EOL><DEDENT>if compute_uv:<EOL><INDENT>return u, s, v<EOL><DEDENT>else:<EOL><INDENT>return s<EOL><DEDENT>", "docstring": "Singular Value Decomposition.\n\nFactorizes the matrix a into two unitary matrices U and Vh, and\na 1-D array s of singular values (real, non-negative) such that\n``a == U*S*Vh``, where S is a suitably shaped matrix of zeros with\nmain diagonal s.\n\nParameters\n----------\na : (M, N) array_like\n    Matrix to decompose.\nfull_matrices : bool, optional\n    If True, `U` and `Vh` are of shape ``(M,M)``, ``(N,N)``.\n    If False, the shapes are ``(M,K)`` and ``(K,N)``, where\n    ``K = min(M,N)``.\ncompute_uv : bool, optional\n    Whether to compute also `U` and `Vh` in addition to `s`.\n    Default is True.\noverwrite_a : bool, optional\n    Whether to overwrite `a`; may improve performance.\n    Default is False.\ncheck_finite : boolean, optional\n    Whether to check that the input matrix contains only finite numbers.\n    Disabling may give a performance gain, but may result in problems\n    (crashes, non-termination) if the inputs do contain infinities or NaNs.\n\nReturns\n-------\nU : ndarray\n    Unitary matrix having left singular vectors as columns.\n    Of shape ``(M,M)`` or ``(M,K)``, depending on `full_matrices`.\ns : ndarray\n    The singular values, sorted in non-increasing order.\n    Of shape (K,), with ``K = min(M, N)``.\nVh : ndarray\n    Unitary matrix having right singular vectors as rows.\n    Of shape ``(N,N)`` or ``(K,N)`` depending on `full_matrices`.\n\nFor ``compute_uv = False``, only `s` is returned.\n\nRaises\n------\nLinAlgError\n    If SVD computation does not converge.\n\nSee also\n--------\nsvdvals : Compute singular values of a matrix.\ndiagsvd : Construct the Sigma matrix, given the vector s.\n\nExamples\n--------\n>>> from scipy import linalg\n>>> a = np.random.randn(9, 6) + 1.j*np.random.randn(9, 6)\n>>> U, s, Vh = linalg.svd(a)\n>>> U.shape, Vh.shape, s.shape\n((9, 9), (6, 6), (6,))\n\n>>> U, s, Vh = linalg.svd(a, full_matrices=False)\n>>> U.shape, Vh.shape, s.shape\n((9, 6), (6, 6), (6,))\n>>> S = linalg.diagsvd(s, 6, 6)\n>>> np.allclose(a, np.dot(U, np.dot(S, Vh)))\nTrue\n\n>>> s2 = linalg.svd(a, compute_uv=False)\n>>> np.allclose(s, s2)\nTrue", "id": "f19304:m0"}
{"signature": "def polar(a, side=\"<STR_LIT:right>\"):", "body": "if side not in ['<STR_LIT:right>', '<STR_LIT:left>']:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>a = np.asarray(a)<EOL>if a.ndim != <NUM_LIT:2>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>w, s, vh = svd(a, full_matrices=False)<EOL>u = w.dot(vh)<EOL>if side == '<STR_LIT:right>':<EOL><INDENT>p = (vh.T.conj() * s).dot(vh)<EOL><DEDENT>else:<EOL><INDENT>p = (w * s).dot(w.T.conj())<EOL><DEDENT>return u, p<EOL>", "docstring": "Compute the polar decomposition.\n\nReturns the factors of the polar decomposition [1]_ `u` and `p` such\nthat ``a = up`` (if `side` is \"right\") or ``a = pu`` (if `side` is\n\"left\"), where `p` is positive semidefinite.  Depending on the shape\nof `a`, either the rows or columns of `u` are orthonormal.  When `a`\nis a square array, `u` is a square unitary array.  When `a` is not\nsquare, the \"canonical polar decomposition\" [2]_ is computed.\n\nParameters\n----------\na : (m, n) array_like\n    The array to be factored.\nside : string, optional\n    Determines whether a right or left polar decomposition is computed.\n    If `side` is \"right\", then ``a = up``.  If `side` is \"left\",  then\n    ``a = pu``.  The default is \"right\".\n\nReturns\n-------\nu : (m, n) ndarray\n    If `a` is square, then `u` is unitary.  If m > n, then the columns\n    of `a` are orthonormal, and if m < n, then the rows of `u` are\n    orthonormal.\np : ndarray\n    `p` is Hermitian positive semidefinite.  If `a` is nonsingular, `p`\n    is positive definite.  The shape of `p` is (n, n) or (m, m), depending\n    on whether `side` is \"right\" or \"left\", respectively.\n\nReferences\n----------\n.. [1] R. A. Horn and C. R. Johnson, \"Matrix Analysis\", Cambridge University\n       Press, 1985.\n.. [2] N. J. Higham, \"Functions of Matrices: Theory and Computation\",\n       SIAM, 2008.\n\nExamples\n--------\n>>> a = np.array([[1, -1], [2, 4]])\n>>> u, p = polar(a)\n>>> u\narray([[ 0.85749293, -0.51449576],\n       [ 0.51449576,  0.85749293]])\n>>> p\narray([[ 1.88648444,  1.2004901 ],\n       [ 1.2004901 ,  3.94446746]])\n\nA non-square example, with m < n:\n\n>>> b = np.array([[0.5, 1, 2], [1.5, 3, 4]])\n>>> u, p = polar(b)\n>>> u\narray([[-0.21196618, -0.42393237,  0.88054056],\n       [ 0.39378971,  0.78757942,  0.4739708 ]])\n>>> p\narray([[ 0.48470147,  0.96940295,  1.15122648],\n       [ 0.96940295,  1.9388059 ,  2.30245295],\n       [ 1.15122648,  2.30245295,  3.65696431]])\n>>> u.dot(p)   # Verify the decomposition.\narray([[ 0.5,  1. ,  2. ],\n       [ 1.5,  3. ,  4. ]])\n>>> u.dot(u.T)   # The rows of u are orthonormal.\narray([[  1.00000000e+00,  -2.07353665e-17],\n       [ -2.07353665e-17,   1.00000000e+00]])\n\nAnother non-square example, with m > n:\n\n>>> c = b.T\n>>> u, p = polar(c)\n>>> u\narray([[-0.21196618,  0.39378971],\n       [-0.42393237,  0.78757942],\n       [ 0.88054056,  0.4739708 ]])\n>>> p\narray([[ 1.23116567,  1.93241587],\n       [ 1.93241587,  4.84930602]])\n>>> u.dot(p)   # Verify the decomposition.\narray([[ 0.5,  1.5],\n       [ 1. ,  3. ],\n       [ 2. ,  4. ]])\n>>> u.T.dot(u)  # The columns of u are orthonormal.\narray([[  1.00000000e+00,  -1.26363763e-16],\n       [ -1.26363763e-16,   1.00000000e+00]])", "id": "f19306:m0"}
{"signature": "def sqrtm(A, disp=True, blocksize=<NUM_LIT:64>):", "body": "A = np.asarray(A)<EOL>if len(A.shape) != <NUM_LIT:2>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if blocksize < <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>keep_it_real = np.isrealobj(A)<EOL>if keep_it_real:<EOL><INDENT>T, Z = schur(A)<EOL>if not np.array_equal(T, np.triu(T)):<EOL><INDENT>T, Z = rsf2csf(T,Z)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>T, Z = schur(A, output='<STR_LIT>')<EOL><DEDENT>failflag = False<EOL>try:<EOL><INDENT>R = _sqrtm_triu(T, blocksize=blocksize)<EOL>ZH = np.conjugate(Z).T<EOL>X = Z.dot(R).dot(ZH)<EOL><DEDENT>except SqrtmError as e:<EOL><INDENT>failflag = True<EOL>X = np.empty_like(A)<EOL>X.fill(np.nan)<EOL><DEDENT>if disp:<EOL><INDENT>nzeig = np.any(np.diag(T) == <NUM_LIT:0>)<EOL>if nzeig:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>elif failflag:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>return X<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>arg2 = norm(X.dot(X) - A,'<STR_LIT>')**<NUM_LIT:2> / norm(A,'<STR_LIT>')<EOL><DEDENT>except ValueError:<EOL><INDENT>arg2 = np.inf<EOL><DEDENT>return X, arg2<EOL><DEDENT>", "docstring": "Matrix square root.\n\nParameters\n----------\nA : (N, N) array_like\n    Matrix whose square root to evaluate\ndisp : bool, optional\n    Print warning if error in the result is estimated large\n    instead of returning estimated error. (Default: True)\nblocksize : integer, optional\n    If the blocksize is not degenerate with respect to the\n    size of the input array, then use a blocked algorithm. (Default: 64)\n\nReturns\n-------\nsqrtm : (N, N) ndarray\n    Value of the sqrt function at `A`\n\nerrest : float\n    (if disp == False)\n\n    Frobenius norm of the estimated error, ||err||_F / ||A||_F\n\nReferences\n----------\n.. [1] Edvin Deadman, Nicholas J. Higham, Rui Ralha (2013)\n       \"Blocked Schur Algorithms for Computing the Matrix Square Root,\n       Lecture Notes in Computer Science, 7782. pp. 171-182.\n\nExamples\n--------\n>>> a = np.array([[1.0, 3.0], [1.0, 4.0]])\n>>> r = sqrtm(a)\n>>> r\narray([[ 0.75592895,  1.13389342],\n       [ 0.37796447,  1.88982237]])\n>>> r.dot(r)\narray([[ 1.,  3.],\n       [ 1.,  4.]])", "id": "f19307:m1"}
{"signature": "def expm_cond(A, check_finite=True):", "body": "if check_finite:<EOL><INDENT>A = np.asarray_chkfinite(A)<EOL><DEDENT>else:<EOL><INDENT>A = np.asarray(A)<EOL><DEDENT>if len(A.shape) != <NUM_LIT:2> or A.shape[<NUM_LIT:0>] != A.shape[<NUM_LIT:1>]:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>X = scipy.linalg.expm(A)<EOL>K = expm_frechet_kronform(A, check_finite=False)<EOL>A_norm = scipy.linalg.norm(A, '<STR_LIT>')<EOL>X_norm = scipy.linalg.norm(X, '<STR_LIT>')<EOL>K_norm = scipy.linalg.norm(K, <NUM_LIT:2>)<EOL>kappa = (K_norm * A_norm) / X_norm<EOL>return kappa<EOL>", "docstring": "Relative condition number of the matrix exponential in the Frobenius norm.\n\nParameters\n----------\nA : 2d array-like\n    Square input matrix with shape (N, N).\ncheck_finite : boolean, optional\n    Whether to check that the input matrix contains only finite numbers.\n    Disabling may give a performance gain, but may result in problems\n    (crashes, non-termination) if the inputs do contain infinities or NaNs.\n\nReturns\n-------\nkappa : float\n    The relative condition number of the matrix exponential\n    in the Frobenius norm\n\nNotes\n-----\nA faster estimate for the condition number in the 1-norm\nhas been published but is not yet implemented in scipy.\n\n.. versionadded:: 0.14.0\n\nSee also\n--------\nexpm : Compute the exponential of a matrix.\nexpm_frechet : Compute the Frechet derivative of the matrix exponential.", "id": "f19308:m9"}
{"signature": "def iddr_rsvd(m, n, matvect, matvec, k):", "body": "U, V, S, ier = _id.iddr_rsvd(m, n, matvect, matvec, k)<EOL>if ier != <NUM_LIT:0>:<EOL><INDENT>raise _RETCODE_ERROR<EOL><DEDENT>return U, V, S<EOL>", "docstring": "Compute SVD of a real matrix to a specified rank using random matrix-vector\nmultiplication.\n\n:param m:\n    Matrix row dimension.\n:type m: int\n:param n:\n    Matrix column dimension.\n:type n: int\n:param matvect:\n    Function to apply the matrix transpose to a vector, with call signature\n    `y = matvect(x)`, where `x` and `y` are the input and output vectors,\n    respectively.\n:type matvect: function\n:param matvec:\n    Function to apply the matrix to a vector, with call signature\n    `y = matvec(x)`, where `x` and `y` are the input and output vectors,\n    respectively.\n:type matvec: function\n:param k:\n    Rank of SVD.\n:type k: int\n\n:return:\n    Left singular vectors.\n:rtype: :class:`numpy.ndarray`\n:return:\n    Right singular vectors.\n:rtype: :class:`numpy.ndarray`\n:return:\n    Singular values.\n:rtype: :class:`numpy.ndarray`", "id": "f19309:m27"}
{"signature": "def idz_frmi(m):", "body": "return _id.idz_frmi(m)<EOL>", "docstring": "Initialize data for :func:`idz_frm`.\n\n:param m:\n    Length of vector to be transformed.\n:type m: int\n\n:return:\n    Greatest power-of-two integer `n` satisfying `n <= m`.\n:rtype: int\n:return:\n    Initialization array to be used by :func:`idz_frm`.\n:rtype: :class:`numpy.ndarray`", "id": "f19309:m30"}
{"signature": "def iddr_aid(A, k):", "body": "A = np.asfortranarray(A)<EOL>m, n = A.shape<EOL>w = iddr_aidi(m, n, k)<EOL>idx, proj = _id.iddr_aid(A, k, w)<EOL>if k == n:<EOL><INDENT>proj = np.array([], dtype='<STR_LIT>', order='<STR_LIT:F>')<EOL><DEDENT>else:<EOL><INDENT>proj = proj.reshape((k, n-k), order='<STR_LIT:F>')<EOL><DEDENT>return idx, proj<EOL>", "docstring": "Compute ID of a real matrix to a specified rank using random sampling.\n\n:param A:\n    Matrix.\n:type A: :class:`numpy.ndarray`\n:param k:\n    Rank of ID.\n:type k: int\n\n:return:\n    Column index array.\n:rtype: :class:`numpy.ndarray`\n:return:\n    Interpolation coefficients.\n:rtype: :class:`numpy.ndarray`", "id": "f19309:m23"}
{"signature": "def idd_copycols(A, k, idx):", "body": "A = np.asfortranarray(A)<EOL>return _id.idd_copycols(A, k, idx)<EOL>", "docstring": "Reconstruct skeleton matrix from real ID.\n\n:param A:\n    Original matrix.\n:type A: :class:`numpy.ndarray`\n:param k:\n    Rank of ID.\n:type k: int\n:param idx:\n    Column index array.\n:type idx: :class:`numpy.ndarray`\n\n:return:\n    Skeleton matrix.\n:rtype: :class:`numpy.ndarray`", "id": "f19309:m11"}
{"signature": "def idzr_id(A, k):", "body": "A = np.asfortranarray(A)<EOL>idx, rnorms = _id.idzr_id(A, k)<EOL>n = A.shape[<NUM_LIT:1>]<EOL>proj = A.T.ravel()[:k*(n-k)].reshape((k, n-k), order='<STR_LIT:F>')<EOL>return idx, proj<EOL>", "docstring": "Compute ID of a complex matrix to a specified rank.\n\n:param A:\n    Matrix.\n:type A: :class:`numpy.ndarray`\n:param k:\n    Rank of ID.\n:type k: int\n\n:return:\n    Column index array.\n:rtype: :class:`numpy.ndarray`\n:return:\n    Interpolation coefficients.\n:rtype: :class:`numpy.ndarray`", "id": "f19309:m33"}
{"signature": "def idzr_aidi(m, n, k):", "body": "return _id.idzr_aidi(m, n, k)<EOL>", "docstring": "Initialize array for :func:`idzr_aid`.\n\n:param m:\n    Matrix row dimension.\n:type m: int\n:param n:\n    Matrix column dimension.\n:type n: int\n:param k:\n    Rank of ID.\n:type k: int\n\n:return:\n    Initialization array to be used by :func:`idzr_aid`.\n:rtype: :class:`numpy.ndarray`", "id": "f19309:m49"}
{"signature": "def idz_reconid(B, idx, proj):", "body": "B = np.asfortranarray(B)<EOL>if proj.size > <NUM_LIT:0>:<EOL><INDENT>return _id.idz_reconid(B, idx, proj)<EOL><DEDENT>else:<EOL><INDENT>return B[:, np.argsort(idx)]<EOL><DEDENT>", "docstring": "Reconstruct matrix from complex ID.\n\n:param B:\n    Skeleton matrix.\n:type B: :class:`numpy.ndarray`\n:param idx:\n    Column index array.\n:type idx: :class:`numpy.ndarray`\n:param proj:\n    Interpolation coefficients.\n:type proj: :class:`numpy.ndarray`\n\n:return:\n    Reconstructed matrix.\n:rtype: :class:`numpy.ndarray`", "id": "f19309:m34"}
{"signature": "def idz_reconint(idx, proj):", "body": "return _id.idz_reconint(idx, proj)<EOL>", "docstring": "Reconstruct interpolation matrix from complex ID.\n\n:param idx:\n    Column index array.\n:type idx: :class:`numpy.ndarray`\n:param proj:\n    Interpolation coefficients.\n:type proj: :class:`numpy.ndarray`\n\n:return:\n    Interpolation matrix.\n:rtype: :class:`numpy.ndarray`", "id": "f19309:m35"}
{"signature": "def iddp_asvd(eps, A):", "body": "A = np.asfortranarray(A)<EOL>m, n = A.shape<EOL>n2, winit = _id.idd_frmi(m)<EOL>w = np.empty(<EOL>max((min(m, n) + <NUM_LIT:1>)*(<NUM_LIT:3>*m + <NUM_LIT:5>*n + <NUM_LIT:1>) + <NUM_LIT>*min(m, n)**<NUM_LIT:2>,<EOL>(<NUM_LIT:2>*n + <NUM_LIT:1>)*(n2 + <NUM_LIT:1>)),<EOL>order='<STR_LIT:F>')<EOL>k, iU, iV, iS, w, ier = _id.iddp_asvd(eps, A, winit, w)<EOL>if ier:<EOL><INDENT>raise _RETCODE_ERROR<EOL><DEDENT>U = w[iU-<NUM_LIT:1>:iU+m*k-<NUM_LIT:1>].reshape((m, k), order='<STR_LIT:F>')<EOL>V = w[iV-<NUM_LIT:1>:iV+n*k-<NUM_LIT:1>].reshape((n, k), order='<STR_LIT:F>')<EOL>S = w[iS-<NUM_LIT:1>:iS+k-<NUM_LIT:1>]<EOL>return U, V, S<EOL>", "docstring": "Compute SVD of a real matrix to a specified relative precision using random\nsampling.\n\n:param eps:\n    Relative precision.\n:type eps: float\n:param A:\n    Matrix.\n:type A: :class:`numpy.ndarray`\n\n:return:\n    Left singular vectors.\n:rtype: :class:`numpy.ndarray`\n:return:\n    Right singular vectors.\n:rtype: :class:`numpy.ndarray`\n:return:\n    Singular values.\n:rtype: :class:`numpy.ndarray`", "id": "f19309:m19"}
{"signature": "def iddr_asvd(A, k):", "body": "A = np.asfortranarray(A)<EOL>m, n = A.shape<EOL>w = np.empty((<NUM_LIT:2>*k + <NUM_LIT>)*m + (<NUM_LIT:6>*k + <NUM_LIT>)*n + <NUM_LIT>*k**<NUM_LIT:2> + <NUM_LIT:100>, order='<STR_LIT:F>')<EOL>w_ = iddr_aidi(m, n, k)<EOL>w[:w_.size] = w_<EOL>U, V, S, ier = _id.iddr_asvd(A, k, w)<EOL>if ier != <NUM_LIT:0>:<EOL><INDENT>raise _RETCODE_ERROR<EOL><DEDENT>return U, V, S<EOL>", "docstring": "Compute SVD of a real matrix to a specified rank using random sampling.\n\n:param A:\n    Matrix.\n:type A: :class:`numpy.ndarray`\n:param k:\n    Rank of SVD.\n:type k: int\n\n:return:\n    Left singular vectors.\n:rtype: :class:`numpy.ndarray`\n:return:\n    Right singular vectors.\n:rtype: :class:`numpy.ndarray`\n:return:\n    Singular values.\n:rtype: :class:`numpy.ndarray`", "id": "f19309:m25"}
{"signature": "def idzp_id(eps, A):", "body": "A = np.asfortranarray(A)<EOL>k, idx, rnorms = _id.idzp_id(eps, A)<EOL>n = A.shape[<NUM_LIT:1>]<EOL>proj = A.T.ravel()[:k*(n-k)].reshape((k, n-k), order='<STR_LIT:F>')<EOL>return k, idx, proj<EOL>", "docstring": "Compute ID of a complex matrix to a specified relative precision.\n\n:param eps:\n    Relative precision.\n:type eps: float\n:param A:\n    Matrix.\n:type A: :class:`numpy.ndarray`\n\n:return:\n    Rank of ID.\n:rtype: int\n:return:\n    Column index array.\n:rtype: :class:`numpy.ndarray`\n:return:\n    Interpolation coefficients.\n:rtype: :class:`numpy.ndarray`", "id": "f19309:m32"}
{"signature": "def idd_estrank(eps, A):", "body": "A = np.asfortranarray(A)<EOL>m, n = A.shape<EOL>n2, w = idd_frmi(m)<EOL>ra = np.empty(n*n2 + (n + <NUM_LIT:1>)*(n2 + <NUM_LIT:1>), order='<STR_LIT:F>')<EOL>k, ra = _id.idd_estrank(eps, A, w, ra)<EOL>return k<EOL>", "docstring": "Estimate rank of a real matrix to a specified relative precision using\nrandom sampling.\n\nThe output rank is typically about 8 higher than the actual rank.\n\n:param eps:\n    Relative precision.\n:type eps: float\n:param A:\n    Matrix.\n:type A: :class:`numpy.ndarray`\n\n:return:\n    Rank estimate.\n:rtype: int", "id": "f19309:m18"}
{"signature": "def idd_reconint(idx, proj):", "body": "return _id.idd_reconint(idx, proj)<EOL>", "docstring": "Reconstruct interpolation matrix from real ID.\n\n:param idx:\n    Column index array.\n:type idx: :class:`numpy.ndarray`\n:param proj:\n    Interpolation coefficients.\n:type proj: :class:`numpy.ndarray`\n\n:return:\n    Interpolation matrix.\n:rtype: :class:`numpy.ndarray`", "id": "f19309:m10"}
{"signature": "def idd_sfrmi(l, m):", "body": "return _id.idd_sfrmi(l, m)<EOL>", "docstring": "Initialize data for :func:`idd_sfrm`.\n\n:param l:\n    Length of output transformed vector.\n:type l: int\n:param m:\n    Length of the vector to be transformed.\n:type m: int\n\n:return:\n    Greatest power-of-two integer `n` satisfying `n <= m`.\n:rtype: int\n:return:\n    Initialization array to be used by :func:`idd_sfrm`.\n:rtype: :class:`numpy.ndarray`", "id": "f19309:m6"}
{"signature": "def idd_snorm(m, n, matvect, matvec, its=<NUM_LIT:20>):", "body": "snorm, v = _id.idd_snorm(m, n, matvect, matvec, its)<EOL>return snorm<EOL>", "docstring": "Estimate spectral norm of a real matrix by the randomized power method.\n\n:param m:\n    Matrix row dimension.\n:type m: int\n:param n:\n    Matrix column dimension.\n:type n: int\n:param matvect:\n    Function to apply the matrix transpose to a vector, with call signature\n    `y = matvect(x)`, where `x` and `y` are the input and output vectors,\n    respectively.\n:type matvect: function\n:param matvec:\n    Function to apply the matrix to a vector, with call signature\n    `y = matvec(x)`, where `x` and `y` are the input and output vectors,\n    respectively.\n:type matvec: function\n:param its:\n    Number of power method iterations.\n:type its: int\n\n:return:\n    Spectral norm estimate.\n:rtype: float", "id": "f19309:m13"}
{"signature": "def idzp_aid(eps, A):", "body": "A = np.asfortranarray(A)<EOL>m, n = A.shape<EOL>n2, w = idz_frmi(m)<EOL>proj = np.empty(n*(<NUM_LIT:2>*n2 + <NUM_LIT:1>) + n2 + <NUM_LIT:1>, dtype='<STR_LIT>', order='<STR_LIT:F>')<EOL>k, idx, proj = _id.idzp_aid(eps, A, w, proj)<EOL>proj = proj[:k*(n-k)].reshape((k, n-k), order='<STR_LIT:F>')<EOL>return k, idx, proj<EOL>", "docstring": "Compute ID of a complex matrix to a specified relative precision using\nrandom sampling.\n\n:param eps:\n    Relative precision.\n:type eps: float\n:param A:\n    Matrix.\n:type A: :class:`numpy.ndarray`\n\n:return:\n    Rank of ID.\n:rtype: int\n:return:\n    Column index array.\n:rtype: :class:`numpy.ndarray`\n:return:\n    Interpolation coefficients.\n:rtype: :class:`numpy.ndarray`", "id": "f19309:m42"}
{"signature": "def rq(a, overwrite_a=False, lwork=None, mode='<STR_LIT>', check_finite=True):", "body": "if mode not in ['<STR_LIT>', '<STR_LIT:r>', '<STR_LIT>']:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>if check_finite:<EOL><INDENT>a1 = numpy.asarray_chkfinite(a)<EOL><DEDENT>else:<EOL><INDENT>a1 = numpy.asarray(a)<EOL><DEDENT>if len(a1.shape) != <NUM_LIT:2>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>M, N = a1.shape<EOL>overwrite_a = overwrite_a or (_datacopied(a1, a))<EOL>gerqf, = get_lapack_funcs(('<STR_LIT>',), (a1,))<EOL>if lwork is None or lwork == -<NUM_LIT:1>:<EOL><INDENT>rq, tau, work, info = gerqf(a1, lwork=-<NUM_LIT:1>, overwrite_a=<NUM_LIT:1>)<EOL>lwork = work[<NUM_LIT:0>].real.astype(numpy.int)<EOL><DEDENT>rq, tau, work, info = gerqf(a1, lwork=lwork, overwrite_a=overwrite_a)<EOL>if info < <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>% -info)<EOL><DEDENT>if not mode == '<STR_LIT>' or N < M:<EOL><INDENT>R = numpy.triu(rq, N-M)<EOL><DEDENT>else:<EOL><INDENT>R = numpy.triu(rq[-M:, -M:])<EOL><DEDENT>if mode == '<STR_LIT:r>':<EOL><INDENT>return R<EOL><DEDENT>gor_un_grq, = get_lapack_funcs(('<STR_LIT>',), (rq,))<EOL>if N < M:<EOL><INDENT>Q, work, info = gor_un_grq(rq[-N:], tau, lwork=-<NUM_LIT:1>, overwrite_a=<NUM_LIT:1>)<EOL>lwork = work[<NUM_LIT:0>].real.astype(numpy.int)<EOL>Q, work, info = gor_un_grq(rq[-N:], tau, lwork=lwork, overwrite_a=<NUM_LIT:1>)<EOL><DEDENT>elif mode == '<STR_LIT>':<EOL><INDENT>Q, work, info = gor_un_grq(rq, tau, lwork=-<NUM_LIT:1>, overwrite_a=<NUM_LIT:1>)<EOL>lwork = work[<NUM_LIT:0>].real.astype(numpy.int)<EOL>Q, work, info = gor_un_grq(rq, tau, lwork=lwork, overwrite_a=<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>rq1 = numpy.empty((N, N), dtype=rq.dtype)<EOL>rq1[-M:] = rq<EOL>Q, work, info = gor_un_grq(rq1, tau, lwork=-<NUM_LIT:1>, overwrite_a=<NUM_LIT:1>)<EOL>lwork = work[<NUM_LIT:0>].real.astype(numpy.int)<EOL>Q, work, info = gor_un_grq(rq1, tau, lwork=lwork, overwrite_a=<NUM_LIT:1>)<EOL><DEDENT>if info < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>% -info)<EOL><DEDENT>return R, Q<EOL>", "docstring": "Compute RQ decomposition of a matrix.\n\nCalculate the decomposition ``A = R Q`` where Q is unitary/orthogonal\nand R upper triangular.\n\nParameters\n----------\na : (M, N) array_like\n    Matrix to be decomposed\noverwrite_a : bool, optional\n    Whether data in a is overwritten (may improve performance)\nlwork : int, optional\n    Work array size, lwork >= a.shape[1]. If None or -1, an optimal size\n    is computed.\nmode : {'full', 'r', 'economic'}, optional\n    Determines what information is to be returned: either both Q and R\n    ('full', default), only R ('r') or both Q and R but computed in\n    economy-size ('economic', see Notes).\ncheck_finite : bool, optional\n    Whether to check that the input matrix contains only finite numbers.\n    Disabling may give a performance gain, but may result in problems\n    (crashes, non-termination) if the inputs do contain infinities or NaNs.\n\nReturns\n-------\nR : float or complex ndarray\n    Of shape (M, N) or (M, K) for ``mode='economic'``.  ``K = min(M, N)``.\nQ : float or complex ndarray\n    Of shape (N, N) or (K, N) for ``mode='economic'``.  Not returned\n    if ``mode='r'``.\n\nRaises\n------\nLinAlgError\n    If decomposition fails.\n\nNotes\n-----\nThis is an interface to the LAPACK routines sgerqf, dgerqf, cgerqf, zgerqf,\nsorgrq, dorgrq, cungrq and zungrq.\n\nIf ``mode=economic``, the shapes of Q and R are (K, N) and (M, K) instead\nof (N,N) and (M,N), with ``K=min(M,N)``.\n\nExamples\n--------\n>>> from scipy import linalg\n>>> from numpy import random, dot, allclose\n>>> a = random.randn(6, 9)\n>>> r, q = linalg.rq(a)\n>>> allclose(a, dot(r, q))\nTrue\n>>> r.shape, q.shape\n((6, 9), (9, 9))\n>>> r2 = linalg.rq(a, mode='r')\n>>> allclose(r, r2)\nTrue\n>>> r3, q3 = linalg.rq(a, mode='economic')\n>>> r3.shape, q3.shape\n((6, 6), (6, 9))", "id": "f19310:m3"}
{"signature": "def _make_complex_eigvecs(w, vin, dtype):", "body": "<EOL>v = numpy.array(vin, dtype=dtype)<EOL>m = (w.imag > <NUM_LIT:0>)<EOL>m[:-<NUM_LIT:1>] |= (w.imag[<NUM_LIT:1>:] < <NUM_LIT:0>)  <EOL>for i in flatnonzero(m):<EOL><INDENT>v.imag[:,i] = vin[:,i+<NUM_LIT:1>]<EOL>conj(v[:,i], v[:,i+<NUM_LIT:1>])<EOL><DEDENT>return v<EOL>", "docstring": "Produce complex-valued eigenvectors from LAPACK DGGEV real-valued output", "id": "f19313:m0"}
{"signature": "def eigh(a, b=None, lower=True, eigvals_only=False, overwrite_a=False,<EOL>overwrite_b=False, turbo=True, eigvals=None, type=<NUM_LIT:1>,<EOL>check_finite=True):", "body": "if check_finite:<EOL><INDENT>a1 = asarray_chkfinite(a)<EOL><DEDENT>else:<EOL><INDENT>a1 = asarray(a)<EOL><DEDENT>if len(a1.shape) != <NUM_LIT:2> or a1.shape[<NUM_LIT:0>] != a1.shape[<NUM_LIT:1>]:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>overwrite_a = overwrite_a or (_datacopied(a1, a))<EOL>if iscomplexobj(a1):<EOL><INDENT>cplx = True<EOL><DEDENT>else:<EOL><INDENT>cplx = False<EOL><DEDENT>if b is not None:<EOL><INDENT>if check_finite:<EOL><INDENT>b1 = asarray_chkfinite(b)<EOL><DEDENT>else:<EOL><INDENT>b1 = asarray(b)<EOL><DEDENT>overwrite_b = overwrite_b or _datacopied(b1, b)<EOL>if len(b1.shape) != <NUM_LIT:2> or b1.shape[<NUM_LIT:0>] != b1.shape[<NUM_LIT:1>]:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if b1.shape != a1.shape:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (str(b1.shape), str(a1.shape)))<EOL><DEDENT>if iscomplexobj(b1):<EOL><INDENT>cplx = True<EOL><DEDENT>else:<EOL><INDENT>cplx = cplx or False<EOL><DEDENT><DEDENT>else:<EOL><INDENT>b1 = None<EOL><DEDENT>_job = (eigvals_only and '<STR_LIT:N>') or '<STR_LIT>'<EOL>if eigvals is not None:<EOL><INDENT>lo, hi = eigvals<EOL>if lo < <NUM_LIT:0> or hi >= a1.shape[<NUM_LIT:0>]:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>' % (<NUM_LIT:0>, a1.shape[<NUM_LIT:0>]-<NUM_LIT:1>))<EOL><DEDENT>lo += <NUM_LIT:1><EOL>hi += <NUM_LIT:1><EOL>eigvals = (lo, hi)<EOL><DEDENT>if lower:<EOL><INDENT>uplo = '<STR_LIT:L>'<EOL><DEDENT>else:<EOL><INDENT>uplo = '<STR_LIT>'<EOL><DEDENT>if cplx:<EOL><INDENT>pfx = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>pfx = '<STR_LIT>'<EOL><DEDENT>if b1 is None:<EOL><INDENT>(evr,) = get_lapack_funcs((pfx+'<STR_LIT>',), (a1,))<EOL>if eigvals is None:<EOL><INDENT>w, v, info = evr(a1, uplo=uplo, jobz=_job, range=\"<STR_LIT:A>\", il=<NUM_LIT:1>,<EOL>iu=a1.shape[<NUM_LIT:0>], overwrite_a=overwrite_a)<EOL><DEDENT>else:<EOL><INDENT>(lo, hi) = eigvals<EOL>w_tot, v, info = evr(a1, uplo=uplo, jobz=_job, range=\"<STR_LIT:I>\",<EOL>il=lo, iu=hi, overwrite_a=overwrite_a)<EOL>w = w_tot[<NUM_LIT:0>:hi-lo+<NUM_LIT:1>]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if eigvals is not None:<EOL><INDENT>(gvx,) = get_lapack_funcs((pfx+'<STR_LIT>',), (a1,b1))<EOL>(lo, hi) = eigvals<EOL>w_tot, v, ifail, info = gvx(a1, b1, uplo=uplo, iu=hi,<EOL>itype=type,jobz=_job, il=lo,<EOL>overwrite_a=overwrite_a,<EOL>overwrite_b=overwrite_b)<EOL>w = w_tot[<NUM_LIT:0>:hi-lo+<NUM_LIT:1>]<EOL><DEDENT>elif turbo:<EOL><INDENT>(gvd,) = get_lapack_funcs((pfx+'<STR_LIT>',), (a1,b1))<EOL>v, w, info = gvd(a1, b1, uplo=uplo, itype=type, jobz=_job,<EOL>overwrite_a=overwrite_a,<EOL>overwrite_b=overwrite_b)<EOL><DEDENT>else:<EOL><INDENT>(gv,) = get_lapack_funcs((pfx+'<STR_LIT>',), (a1,b1))<EOL>v, w, info = gv(a1, b1, uplo=uplo, itype=type, jobz=_job,<EOL>overwrite_a=overwrite_a,<EOL>overwrite_b=overwrite_b)<EOL><DEDENT><DEDENT>if info == <NUM_LIT:0>:<EOL><INDENT>if eigvals_only:<EOL><INDENT>return w<EOL><DEDENT>else:<EOL><INDENT>return w, v<EOL><DEDENT><DEDENT>elif info < <NUM_LIT:0>:<EOL><INDENT>raise LinAlgError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (-info))<EOL><DEDENT>elif info > <NUM_LIT:0> and b1 is None:<EOL><INDENT>raise LinAlgError(\"<STR_LIT>\")<EOL><DEDENT>elif info > <NUM_LIT:0> and info <= b1.shape[<NUM_LIT:0>]:<EOL><INDENT>if eigvals is not None:<EOL><INDENT>raise LinAlgError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % nonzero(ifail)-<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>raise LinAlgError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % info)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise LinAlgError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (info-b1.shape[<NUM_LIT:0>]))<EOL><DEDENT>", "docstring": "Solve an ordinary or generalized eigenvalue problem for a complex\nHermitian or real symmetric matrix.\n\nFind eigenvalues w and optionally eigenvectors v of matrix `a`, where\n`b` is positive definite::\n\n                  a v[:,i] = w[i] b v[:,i]\n    v[i,:].conj() a v[:,i] = w[i]\n    v[i,:].conj() b v[:,i] = 1\n\nParameters\n----------\na : (M, M) array_like\n    A complex Hermitian or real symmetric matrix whose eigenvalues and\n    eigenvectors will be computed.\nb : (M, M) array_like, optional\n    A complex Hermitian or real symmetric definite positive matrix in.\n    If omitted, identity matrix is assumed.\nlower : bool, optional\n    Whether the pertinent array data is taken from the lower or upper\n    triangle of `a`. (Default: lower)\neigvals_only : bool, optional\n    Whether to calculate only eigenvalues and no eigenvectors.\n    (Default: both are calculated)\nturbo : bool, optional\n    Use divide and conquer algorithm (faster but expensive in memory,\n    only for generalized eigenvalue problem and if eigvals=None)\neigvals : tuple (lo, hi), optional\n    Indexes of the smallest and largest (in ascending order) eigenvalues\n    and corresponding eigenvectors to be returned: 0 <= lo <= hi <= M-1.\n    If omitted, all eigenvalues and eigenvectors are returned.\ntype : int, optional\n    Specifies the problem type to be solved:\n\n       type = 1: a   v[:,i] = w[i] b v[:,i]\n\n       type = 2: a b v[:,i] = w[i]   v[:,i]\n\n       type = 3: b a v[:,i] = w[i]   v[:,i]\noverwrite_a : bool, optional\n    Whether to overwrite data in `a` (may improve performance)\noverwrite_b : bool, optional\n    Whether to overwrite data in `b` (may improve performance)\ncheck_finite : boolean, optional\n    Whether to check that the input matrices contain only finite numbers.\n    Disabling may give a performance gain, but may result in problems\n    (crashes, non-termination) if the inputs do contain infinities or NaNs.\n\nReturns\n-------\nw : (N,) float ndarray\n    The N (1<=N<=M) selected eigenvalues, in ascending order, each\n    repeated according to its multiplicity.\nv : (M, N) complex ndarray\n    (if eigvals_only == False)\n\n    The normalized selected eigenvector corresponding to the\n    eigenvalue w[i] is the column v[:,i].\n\n    Normalization:\n\n        type 1 and 3: v.conj() a      v  = w\n\n        type 2: inv(v).conj() a  inv(v) = w\n\n        type = 1 or 2: v.conj() b      v  = I\n\n        type = 3: v.conj() inv(b) v  = I\n\nRaises\n------\nLinAlgError :\n    If eigenvalue computation does not converge,\n    an error occurred, or b matrix is not definite positive. Note that\n    if input matrices are not symmetric or hermitian, no error is reported\n    but results will be wrong.\n\nSee Also\n--------\neig : eigenvalues and right eigenvectors for non-symmetric arrays", "id": "f19313:m3"}
{"signature": "def eig_banded(a_band, lower=False, eigvals_only=False, overwrite_a_band=False,<EOL>select='<STR_LIT:a>', select_range=None, max_ev=<NUM_LIT:0>, check_finite=True):", "body": "if eigvals_only or overwrite_a_band:<EOL><INDENT>if check_finite:<EOL><INDENT>a1 = asarray_chkfinite(a_band)<EOL><DEDENT>else:<EOL><INDENT>a1 = asarray(a_band)<EOL><DEDENT>overwrite_a_band = overwrite_a_band or (_datacopied(a1, a_band))<EOL><DEDENT>else:<EOL><INDENT>a1 = array(a_band)<EOL>if issubclass(a1.dtype.type, inexact) and not isfinite(a1).all():<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>overwrite_a_band = <NUM_LIT:1><EOL><DEDENT>if len(a1.shape) != <NUM_LIT:2>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if select.lower() not in [<NUM_LIT:0>, <NUM_LIT:1>, <NUM_LIT:2>, '<STR_LIT:a>', '<STR_LIT:v>', '<STR_LIT:i>', '<STR_LIT:all>', '<STR_LIT:value>', '<STR_LIT:index>']:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if select.lower() in [<NUM_LIT:0>, '<STR_LIT:a>', '<STR_LIT:all>']:<EOL><INDENT>if a1.dtype.char in '<STR_LIT>':<EOL><INDENT>bevd, = get_lapack_funcs(('<STR_LIT>',), (a1,))<EOL>internal_name = '<STR_LIT>'<EOL><DEDENT>else:  <EOL><INDENT>bevd, = get_lapack_funcs(('<STR_LIT>',), (a1,))<EOL>internal_name = '<STR_LIT>'<EOL><DEDENT>w,v,info = bevd(a1, compute_v=not eigvals_only,<EOL>lower=lower,<EOL>overwrite_ab=overwrite_a_band)<EOL><DEDENT>if select.lower() in [<NUM_LIT:1>, <NUM_LIT:2>, '<STR_LIT:i>', '<STR_LIT:v>', '<STR_LIT:index>', '<STR_LIT:value>']:<EOL><INDENT>if select.lower() in [<NUM_LIT:2>, '<STR_LIT:i>', '<STR_LIT:index>']:<EOL><INDENT>select = <NUM_LIT:2><EOL>vl, vu, il, iu = <NUM_LIT:0.0>, <NUM_LIT:0.0>, min(select_range), max(select_range)<EOL>if min(il, iu) < <NUM_LIT:0> or max(il, iu) >= a1.shape[<NUM_LIT:1>]:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>max_ev = iu - il + <NUM_LIT:1><EOL><DEDENT>else:  <EOL><INDENT>select = <NUM_LIT:1><EOL>vl, vu, il, iu = min(select_range), max(select_range), <NUM_LIT:0>, <NUM_LIT:0><EOL>if max_ev == <NUM_LIT:0>:<EOL><INDENT>max_ev = a_band.shape[<NUM_LIT:1>]<EOL><DEDENT><DEDENT>if eigvals_only:<EOL><INDENT>max_ev = <NUM_LIT:1><EOL><DEDENT>if a1.dtype.char in '<STR_LIT>':  <EOL><INDENT>lamch, = get_lapack_funcs(('<STR_LIT>',), (array(<NUM_LIT:0>, dtype='<STR_LIT:f>'),))<EOL><DEDENT>else:<EOL><INDENT>lamch, = get_lapack_funcs(('<STR_LIT>',), (array(<NUM_LIT:0>, dtype='<STR_LIT:d>'),))<EOL><DEDENT>abstol = <NUM_LIT:2> * lamch('<STR_LIT:s>')<EOL>if a1.dtype.char in '<STR_LIT>':<EOL><INDENT>bevx, = get_lapack_funcs(('<STR_LIT>',), (a1,))<EOL>internal_name = '<STR_LIT>'<EOL><DEDENT>else:  <EOL><INDENT>bevx, = get_lapack_funcs(('<STR_LIT>',), (a1,))<EOL>internal_name = '<STR_LIT>'<EOL><DEDENT>w, v, m, ifail, info = bevx(a1, vl, vu, il+<NUM_LIT:1>, iu+<NUM_LIT:1>,<EOL>compute_v=not eigvals_only,<EOL>mmax=max_ev,<EOL>range=select, lower=lower,<EOL>overwrite_ab=overwrite_a_band,<EOL>abstol=abstol)<EOL>w = w[:m]<EOL>if not eigvals_only:<EOL><INDENT>v = v[:, :m]<EOL><DEDENT><DEDENT>if info < <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>% (-info, internal_name))<EOL><DEDENT>if info > <NUM_LIT:0>:<EOL><INDENT>raise LinAlgError(\"<STR_LIT>\")<EOL><DEDENT>if eigvals_only:<EOL><INDENT>return w<EOL><DEDENT>return w, v<EOL>", "docstring": "Solve real symmetric or complex hermitian band matrix eigenvalue problem.\n\nFind eigenvalues w and optionally right eigenvectors v of a::\n\n    a v[:,i] = w[i] v[:,i]\n    v.H v    = identity\n\nThe matrix a is stored in a_band either in lower diagonal or upper\ndiagonal ordered form:\n\n    a_band[u + i - j, j] == a[i,j]        (if upper form; i <= j)\n    a_band[    i - j, j] == a[i,j]        (if lower form; i >= j)\n\nwhere u is the number of bands above the diagonal.\n\nExample of a_band (shape of a is (6,6), u=2)::\n\n    upper form:\n    *   *   a02 a13 a24 a35\n    *   a01 a12 a23 a34 a45\n    a00 a11 a22 a33 a44 a55\n\n    lower form:\n    a00 a11 a22 a33 a44 a55\n    a10 a21 a32 a43 a54 *\n    a20 a31 a42 a53 *   *\n\nCells marked with * are not used.\n\nParameters\n----------\na_band : (u+1, M) array_like\n    The bands of the M by M matrix a.\nlower : bool, optional\n    Is the matrix in the lower form. (Default is upper form)\neigvals_only : bool, optional\n    Compute only the eigenvalues and no eigenvectors.\n    (Default: calculate also eigenvectors)\noverwrite_a_band : bool, optional\n    Discard data in a_band (may enhance performance)\nselect : {'a', 'v', 'i'}, optional\n    Which eigenvalues to calculate\n\n    ======  ========================================\n    select  calculated\n    ======  ========================================\n    'a'     All eigenvalues\n    'v'     Eigenvalues in the interval (min, max]\n    'i'     Eigenvalues with indices min <= i <= max\n    ======  ========================================\nselect_range : (min, max), optional\n    Range of selected eigenvalues\nmax_ev : int, optional\n    For select=='v', maximum number of eigenvalues expected.\n    For other values of select, has no meaning.\n\n    In doubt, leave this parameter untouched.\n\ncheck_finite : boolean, optional\n    Whether to check that the input matrix contains only finite numbers.\n    Disabling may give a performance gain, but may result in problems\n    (crashes, non-termination) if the inputs do contain infinities or NaNs.\n\nReturns\n-------\nw : (M,) ndarray\n    The eigenvalues, in ascending order, each repeated according to its\n    multiplicity.\nv : (M, M) float or complex ndarray\n    The normalized eigenvector corresponding to the eigenvalue w[i] is\n    the column v[:,i].\n\nRaises LinAlgError if eigenvalue computation does not converge", "id": "f19313:m4"}
{"signature": "def eig(a, b=None, left=False, right=True, overwrite_a=False,<EOL>overwrite_b=False, check_finite=True):", "body": "if check_finite:<EOL><INDENT>a1 = asarray_chkfinite(a)<EOL><DEDENT>else:<EOL><INDENT>a1 = asarray(a)<EOL><DEDENT>if len(a1.shape) != <NUM_LIT:2> or a1.shape[<NUM_LIT:0>] != a1.shape[<NUM_LIT:1>]:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>overwrite_a = overwrite_a or (_datacopied(a1, a))<EOL>if b is not None:<EOL><INDENT>if check_finite:<EOL><INDENT>b1 = asarray_chkfinite(b)<EOL><DEDENT>else:<EOL><INDENT>b1 = asarray(b)<EOL><DEDENT>overwrite_b = overwrite_b or _datacopied(b1, b)<EOL>if len(b1.shape) != <NUM_LIT:2> or b1.shape[<NUM_LIT:0>] != b1.shape[<NUM_LIT:1>]:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if b1.shape != a1.shape:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return _geneig(a1, b1, left, right, overwrite_a, overwrite_b)<EOL><DEDENT>geev, geev_lwork = get_lapack_funcs(('<STR_LIT>', '<STR_LIT>'), (a1,))<EOL>compute_vl, compute_vr = left, right<EOL>lwork, info = geev_lwork(a1.shape[<NUM_LIT:0>],<EOL>compute_vl=compute_vl,<EOL>compute_vr=compute_vr)<EOL>if info != <NUM_LIT:0>:<EOL><INDENT>raise LinAlgError(\"<STR_LIT>\" % (info,))<EOL><DEDENT>lwork = int(lwork.real)<EOL>if geev.typecode in '<STR_LIT>':<EOL><INDENT>w, vl, vr, info = geev(a1, lwork=lwork,<EOL>compute_vl=compute_vl,<EOL>compute_vr=compute_vr,<EOL>overwrite_a=overwrite_a)<EOL><DEDENT>else:<EOL><INDENT>wr, wi, vl, vr, info = geev(a1, lwork=lwork,<EOL>compute_vl=compute_vl,<EOL>compute_vr=compute_vr,<EOL>overwrite_a=overwrite_a)<EOL>t = {'<STR_LIT:f>':'<STR_LIT:F>','<STR_LIT:d>':'<STR_LIT:D>'}[wr.dtype.char]<EOL>w = wr + _I * wi<EOL><DEDENT>if info < <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>% -info)<EOL><DEDENT>if info > <NUM_LIT:0>:<EOL><INDENT>raise LinAlgError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % info)<EOL><DEDENT>only_real = numpy.logical_and.reduce(numpy.equal(w.imag, <NUM_LIT:0.0>))<EOL>if not (geev.typecode in '<STR_LIT>' or only_real):<EOL><INDENT>t = w.dtype.char<EOL>if left:<EOL><INDENT>vl = _make_complex_eigvecs(w, vl, t)<EOL><DEDENT>if right:<EOL><INDENT>vr = _make_complex_eigvecs(w, vr, t)<EOL><DEDENT><DEDENT>if not (left or right):<EOL><INDENT>return w<EOL><DEDENT>if left:<EOL><INDENT>if right:<EOL><INDENT>return w, vl, vr<EOL><DEDENT>return w, vl<EOL><DEDENT>return w, vr<EOL>", "docstring": "Solve an ordinary or generalized eigenvalue problem of a square matrix.\n\nFind eigenvalues w and right or left eigenvectors of a general matrix::\n\n    a   vr[:,i] = w[i]        b   vr[:,i]\n    a.H vl[:,i] = w[i].conj() b.H vl[:,i]\n\nwhere ``.H`` is the Hermitian conjugation.\n\nParameters\n----------\na : (M, M) array_like\n    A complex or real matrix whose eigenvalues and eigenvectors\n    will be computed.\nb : (M, M) array_like, optional\n    Right-hand side matrix in a generalized eigenvalue problem.\n    Default is None, identity matrix is assumed.\nleft : bool, optional\n    Whether to calculate and return left eigenvectors.  Default is False.\nright : bool, optional\n    Whether to calculate and return right eigenvectors.  Default is True.\noverwrite_a : bool, optional\n    Whether to overwrite `a`; may improve performance.  Default is False.\noverwrite_b : bool, optional\n    Whether to overwrite `b`; may improve performance.  Default is False.\ncheck_finite : boolean, optional\n    Whether to check that the input matrices contain only finite numbers.\n    Disabling may give a performance gain, but may result in problems\n    (crashes, non-termination) if the inputs do contain infinities or NaNs.\n\nReturns\n-------\nw : (M,) double or complex ndarray\n    The eigenvalues, each repeated according to its multiplicity.\nvl : (M, M) double or complex ndarray\n    The normalized left eigenvector corresponding to the eigenvalue\n    ``w[i]`` is the column vl[:,i]. Only returned if ``left=True``.\nvr : (M, M) double or complex ndarray\n    The normalized right eigenvector corresponding to the eigenvalue\n    ``w[i]`` is the column ``vr[:,i]``.  Only returned if ``right=True``.\n\nRaises\n------\nLinAlgError\n    If eigenvalue computation does not converge.\n\nSee Also\n--------\neigh : Eigenvalues and right eigenvectors for symmetric/Hermitian arrays.", "id": "f19313:m2"}
{"signature": "def pinv2(a, cond=None, rcond=None, return_rank=False, check_finite=True):", "body": "if check_finite:<EOL><INDENT>a = np.asarray_chkfinite(a)<EOL><DEDENT>else:<EOL><INDENT>a = np.asarray(a)<EOL><DEDENT>u, s, vh = decomp_svd.svd(a, full_matrices=False, check_finite=False)<EOL>if rcond is not None:<EOL><INDENT>cond = rcond<EOL><DEDENT>if cond in [None,-<NUM_LIT:1>]:<EOL><INDENT>t = u.dtype.char.lower()<EOL>factor = {'<STR_LIT:f>': <NUM_LIT>, '<STR_LIT:d>': <NUM_LIT>}<EOL>cond = factor[t] * np.finfo(t).eps<EOL><DEDENT>rank = np.sum(s > cond * np.max(s))<EOL>psigma_diag = <NUM_LIT:1.0> / s[: rank]<EOL>B = np.transpose(np.conjugate(np.dot(u[:, : rank] *<EOL>psigma_diag, vh[: rank])))<EOL>if return_rank:<EOL><INDENT>return B, rank<EOL><DEDENT>else:<EOL><INDENT>return B<EOL><DEDENT>", "docstring": "Compute the (Moore-Penrose) pseudo-inverse of a matrix.\n\nCalculate a generalized inverse of a matrix using its\nsingular-value decomposition and including all 'large' singular\nvalues.\n\nParameters\n----------\na : (M, N) array_like\n    Matrix to be pseudo-inverted.\ncond, rcond : float or None\n    Cutoff for 'small' singular values.\n    Singular values smaller than ``rcond*largest_singular_value``\n    are considered zero.\n    If None or -1, suitable machine precision is used.\nreturn_rank : bool, optional\n    if True, return the effective rank of the matrix\ncheck_finite : boolean, optional\n    Whether to check that the input matrix contains only finite numbers.\n    Disabling may give a performance gain, but may result in problems\n    (crashes, non-termination) if the inputs do contain infinities or NaNs.\n\nReturns\n-------\nB : (N, M) ndarray\n    The pseudo-inverse of matrix `a`.\nrank : int\n    The effective rank of the matrix.  Returned if return_rank == True\n\nRaises\n------\nLinAlgError\n    If SVD computation does not converge.\n\nExamples\n--------\n>>> a = np.random.randn(9, 6)\n>>> B = linalg.pinv2(a)\n>>> np.allclose(a, dot(a, dot(B, a)))\nTrue\n>>> np.allclose(B, dot(B, dot(a, B)))\nTrue", "id": "f19314:m8"}
{"signature": "def lstsq(a, b, cond=None, overwrite_a=False, overwrite_b=False,<EOL>check_finite=True):", "body": "if check_finite:<EOL><INDENT>a1,b1 = map(np.asarray_chkfinite, (a,b))<EOL><DEDENT>else:<EOL><INDENT>a1,b1 = map(np.asarray, (a,b))<EOL><DEDENT>if len(a1.shape) != <NUM_LIT:2>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>m, n = a1.shape<EOL>if len(b1.shape) == <NUM_LIT:2>:<EOL><INDENT>nrhs = b1.shape[<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>nrhs = <NUM_LIT:1><EOL><DEDENT>if m != b1.shape[<NUM_LIT:0>]:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>gelss, = get_lapack_funcs(('<STR_LIT>',), (a1, b1))<EOL>if n > m:<EOL><INDENT>if len(b1.shape) == <NUM_LIT:2>:<EOL><INDENT>b2 = np.zeros((n, nrhs), dtype=gelss.dtype)<EOL>b2[:m,:] = b1<EOL><DEDENT>else:<EOL><INDENT>b2 = np.zeros(n, dtype=gelss.dtype)<EOL>b2[:m] = b1<EOL><DEDENT>b1 = b2<EOL><DEDENT>overwrite_a = overwrite_a or _datacopied(a1, a)<EOL>overwrite_b = overwrite_b or _datacopied(b1, b)<EOL>work = gelss(a1, b1, lwork=-<NUM_LIT:1>)[<NUM_LIT:4>]<EOL>lwork = work[<NUM_LIT:0>].real.astype(np.int)<EOL>v, x, s, rank, work, info = gelss(<EOL>a1, b1, cond=cond, lwork=lwork, overwrite_a=overwrite_a,<EOL>overwrite_b=overwrite_b)<EOL>if info > <NUM_LIT:0>:<EOL><INDENT>raise LinAlgError(\"<STR_LIT>\")<EOL><DEDENT>if info < <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>% -info)<EOL><DEDENT>resids = np.asarray([], dtype=x.dtype)<EOL>if n < m:<EOL><INDENT>x1 = x[:n]<EOL>if rank == n:<EOL><INDENT>resids = np.sum(np.abs(x[n:])**<NUM_LIT:2>, axis=<NUM_LIT:0>)<EOL><DEDENT>x = x1<EOL><DEDENT>return x, resids, rank, s<EOL>", "docstring": "Compute least-squares solution to equation Ax = b.\n\nCompute a vector x such that the 2-norm ``|b - A x|`` is minimized.\n\nParameters\n----------\na : (M, N) array_like\n    Left hand side matrix (2-D array).\nb : (M,) or (M, K) array_like\n    Right hand side matrix or vector (1-D or 2-D array).\ncond : float, optional\n    Cutoff for 'small' singular values; used to determine effective\n    rank of a. Singular values smaller than\n    ``rcond * largest_singular_value`` are considered zero.\noverwrite_a : bool, optional\n    Discard data in `a` (may enhance performance). Default is False.\noverwrite_b : bool, optional\n    Discard data in `b` (may enhance performance). Default is False.\ncheck_finite : boolean, optional\n    Whether to check that the input matrices contain only finite numbers.\n    Disabling may give a performance gain, but may result in problems\n    (crashes, non-termination) if the inputs do contain infinities or NaNs.\n\nReturns\n-------\nx : (N,) or (N, K) ndarray\n    Least-squares solution.  Return shape matches shape of `b`.\nresidues : () or (1,) or (K,) ndarray\n    Sums of residues, squared 2-norm for each column in ``b - a x``.\n    If rank of matrix a is < N or > M this is an empty array.\n    If b was 1-D, this is an (1,) shape array, otherwise the shape is (K,).\nrank : int\n    Effective rank of matrix `a`.\ns : (min(M,N),) ndarray\n    Singular values of `a`. The condition number of a is\n    ``abs(s[0]/s[-1])``.\n\nRaises\n------\nLinAlgError :\n    If computation does not converge.\n\n\nSee Also\n--------\noptimize.nnls : linear least squares with non-negativity constraint", "id": "f19314:m6"}
{"signature": "def solve_triangular(a, b, trans=<NUM_LIT:0>, lower=False, unit_diagonal=False,<EOL>overwrite_b=False, debug=False, check_finite=True):", "body": "if check_finite:<EOL><INDENT>a1, b1 = map(np.asarray_chkfinite,(a,b))<EOL><DEDENT>else:<EOL><INDENT>a1, b1 = map(np.asarray, (a,b))<EOL><DEDENT>if len(a1.shape) != <NUM_LIT:2> or a1.shape[<NUM_LIT:0>] != a1.shape[<NUM_LIT:1>]:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if a1.shape[<NUM_LIT:0>] != b1.shape[<NUM_LIT:0>]:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>overwrite_b = overwrite_b or _datacopied(b1, b)<EOL>if debug:<EOL><INDENT>print('<STR_LIT>',overwrite_b)<EOL><DEDENT>trans = {'<STR_LIT:N>': <NUM_LIT:0>, '<STR_LIT:T>': <NUM_LIT:1>, '<STR_LIT:C>': <NUM_LIT:2>}.get(trans, trans)<EOL>trtrs, = get_lapack_funcs(('<STR_LIT>',), (a1,b1))<EOL>x, info = trtrs(a1, b1, overwrite_b=overwrite_b, lower=lower,<EOL>trans=trans, unitdiag=unit_diagonal)<EOL>if info == <NUM_LIT:0>:<EOL><INDENT>return x<EOL><DEDENT>if info > <NUM_LIT:0>:<EOL><INDENT>raise LinAlgError(\"<STR_LIT>\" % (info-<NUM_LIT:1>))<EOL><DEDENT>raise ValueError('<STR_LIT>'<EOL>% -info)<EOL>", "docstring": "Solve the equation `a x = b` for `x`, assuming a is a triangular matrix.\n\nParameters\n----------\na : (M, M) array_like\n    A triangular matrix\nb : (M,) or (M, N) array_like\n    Right-hand side matrix in `a x = b`\nlower : boolean\n    Use only data contained in the lower triangle of `a`.\n    Default is to use upper triangle.\ntrans : {0, 1, 2, 'N', 'T', 'C'}, optional\n    Type of system to solve:\n\n    ========  =========\n    trans     system\n    ========  =========\n    0 or 'N'  a x  = b\n    1 or 'T'  a^T x = b\n    2 or 'C'  a^H x = b\n    ========  =========\nunit_diagonal : bool, optional\n    If True, diagonal elements of `a` are assumed to be 1 and\n    will not be referenced.\noverwrite_b : bool, optional\n    Allow overwriting data in `b` (may enhance performance)\ncheck_finite : bool, optional\n    Whether to check that the input matrices contain only finite numbers.\n    Disabling may give a performance gain, but may result in problems\n    (crashes, non-termination) if the inputs do contain infinities or NaNs.\n\nReturns\n-------\nx : (M,) or (M, N) ndarray\n    Solution to the system `a x = b`.  Shape of return matches `b`.\n\nRaises\n------\nLinAlgError\n    If `a` is singular\n\nNotes\n-----\n.. versionadded:: 0.9.0", "id": "f19314:m1"}
{"signature": "def pinv(a, cond=None, rcond=None, return_rank=False, check_finite=True):", "body": "if check_finite:<EOL><INDENT>a = np.asarray_chkfinite(a)<EOL><DEDENT>else:<EOL><INDENT>a = np.asarray(a)<EOL><DEDENT>b = np.identity(a.shape[<NUM_LIT:0>], dtype=a.dtype)<EOL>if rcond is not None:<EOL><INDENT>cond = rcond<EOL><DEDENT>x, resids, rank, s = lstsq(a, b, cond=cond, check_finite=False)<EOL>if return_rank:<EOL><INDENT>return x, rank<EOL><DEDENT>else:<EOL><INDENT>return x<EOL><DEDENT>", "docstring": "Compute the (Moore-Penrose) pseudo-inverse of a matrix.\n\nCalculate a generalized inverse of a matrix using a least-squares\nsolver.\n\nParameters\n----------\na : (M, N) array_like\n    Matrix to be pseudo-inverted.\ncond, rcond : float, optional\n    Cutoff for 'small' singular values in the least-squares solver.\n    Singular values smaller than ``rcond * largest_singular_value``\n    are considered zero.\nreturn_rank : bool, optional\n    if True, return the effective rank of the matrix\ncheck_finite : boolean, optional\n    Whether to check that the input matrix contains only finite numbers.\n    Disabling may give a performance gain, but may result in problems\n    (crashes, non-termination) if the inputs do contain infinities or NaNs.\n\nReturns\n-------\nB : (N, M) ndarray\n    The pseudo-inverse of matrix `a`.\nrank : int\n    The effective rank of the matrix.  Returned if return_rank == True\n\nRaises\n------\nLinAlgError\n    If computation does not converge.\n\nExamples\n--------\n>>> a = np.random.randn(9, 6)\n>>> B = linalg.pinv(a)\n>>> np.allclose(a, dot(a, dot(B, a)))\nTrue\n>>> np.allclose(B, dot(B, dot(a, B)))\nTrue", "id": "f19314:m7"}
{"signature": "def pinvh(a, cond=None, rcond=None, lower=True, return_rank=False,<EOL>check_finite=True):", "body": "if check_finite:<EOL><INDENT>a = np.asarray_chkfinite(a)<EOL><DEDENT>else:<EOL><INDENT>a = np.asarray(a)<EOL><DEDENT>s, u = decomp.eigh(a, lower=lower, check_finite=False)<EOL>if rcond is not None:<EOL><INDENT>cond = rcond<EOL><DEDENT>if cond in [None, -<NUM_LIT:1>]:<EOL><INDENT>t = u.dtype.char.lower()<EOL>factor = {'<STR_LIT:f>': <NUM_LIT>, '<STR_LIT:d>': <NUM_LIT>}<EOL>cond = factor[t] * np.finfo(t).eps<EOL><DEDENT>above_cutoff = (abs(s) > cond * np.max(abs(s)))<EOL>psigma_diag = <NUM_LIT:1.0> / s[above_cutoff]<EOL>u = u[:, above_cutoff]<EOL>B = np.dot(u * psigma_diag, np.conjugate(u).T)<EOL>if return_rank:<EOL><INDENT>return B, len(psigma_diag)<EOL><DEDENT>else:<EOL><INDENT>return B<EOL><DEDENT>", "docstring": "Compute the (Moore-Penrose) pseudo-inverse of a Hermitian matrix.\n\nCalculate a generalized inverse of a Hermitian or real symmetric matrix\nusing its eigenvalue decomposition and including all eigenvalues with\n'large' absolute value.\n\nParameters\n----------\na : (N, N) array_like\n    Real symmetric or complex hermetian matrix to be pseudo-inverted\ncond, rcond : float or None\n    Cutoff for 'small' eigenvalues.\n    Singular values smaller than rcond * largest_eigenvalue are considered\n    zero.\n\n    If None or -1, suitable machine precision is used.\nlower : bool\n    Whether the pertinent array data is taken from the lower or upper\n    triangle of a. (Default: lower)\nreturn_rank : bool, optional\n    if True, return the effective rank of the matrix\ncheck_finite : boolean, optional\n    Whether to check that the input matrix contains only finite numbers.\n    Disabling may give a performance gain, but may result in problems\n    (crashes, non-termination) if the inputs do contain infinities or NaNs.\n\nReturns\n-------\nB : (N, N) ndarray\n    The pseudo-inverse of matrix `a`.\nrank : int\n    The effective rank of the matrix.  Returned if return_rank == True\n\nRaises\n------\nLinAlgError\n    If eigenvalue does not converge\n\nExamples\n--------\n>>> import numpy as np\n>>> a = np.random.randn(9, 6)\n>>> a = np.dot(a, a.T)\n>>> B = pinvh(a)\n>>> np.allclose(a, np.dot(a, np.dot(B, a)))\nTrue\n>>> np.allclose(B, np.dot(B, np.dot(a, B)))\nTrue", "id": "f19314:m9"}
{"signature": "def _maybe_real(A, B, tol=None):", "body": "<EOL>if np.isrealobj(A) and np.iscomplexobj(B):<EOL><INDENT>if tol is None:<EOL><INDENT>tol = {<NUM_LIT:0>:feps*<NUM_LIT>, <NUM_LIT:1>:eps*<NUM_LIT>}[_array_precision[B.dtype.char]]<EOL><DEDENT>if np.allclose(B.imag, <NUM_LIT:0.0>, atol=tol):<EOL><INDENT>B = B.real<EOL><DEDENT><DEDENT>return B<EOL>", "docstring": "Return either B or the real part of B, depending on properties of A and B.\n\nThe motivation is that B has been computed as a complicated function of A,\nand B may be perturbed by negligible imaginary components.\nIf A is real and B is complex with small imaginary components,\nthen return a real copy of B.  The assumption in that case would be that\nthe imaginary components of B are numerical artifacts.\n\nParameters\n----------\nA : ndarray\n    Input array whose type is to be checked as real vs. complex.\nB : ndarray\n    Array to be returned, possibly without its imaginary part.\ntol : float\n    Absolute tolerance.\n\nReturns\n-------\nout : real or complex array\n    Either the input array B or only the real part of the input array B.", "id": "f19326:m1"}
{"signature": "def tanm(A):", "body": "A = _asarray_square(A)<EOL>return _maybe_real(A, solve(cosm(A), sinm(A)))<EOL>", "docstring": "Compute the matrix tangent.\n\nThis routine uses expm to compute the matrix exponentials.\n\nParameters\n----------\nA : (N, N) array_like\n    Input array.\n\nReturns\n-------\ntanm : (N, N) ndarray\n    Matrix tangent of `A`\n\nExamples\n--------\n>>> from scipy.linalg import tanm, sinm, cosm\n>>> a = np.array([[1.0, 3.0], [1.0, 4.0]])\n>>> t = tanm(a)\n>>> t\narray([[ -2.00876993,  -8.41880636],\n       [ -2.80626879, -10.42757629]])\n\nVerify tanm(a) = sinm(a).dot(inv(cosm(a)))\n\n>>> s = sinm(a)\n>>> c = cosm(a)\n>>> s.dot(np.linalg.inv(c))\narray([[ -2.00876993,  -8.41880636],\n       [ -2.80626879, -10.42757629]])", "id": "f19326:m9"}
{"signature": "@np.deprecate(new_name=\"<STR_LIT>\")<EOL>def expm3(A, q=<NUM_LIT:20>):", "body": "A = _asarray_square(A)<EOL>n = A.shape[<NUM_LIT:0>]<EOL>t = A.dtype.char<EOL>if t not in ['<STR_LIT:f>','<STR_LIT:F>','<STR_LIT:d>','<STR_LIT:D>']:<EOL><INDENT>A = A.astype('<STR_LIT:d>')<EOL>t = '<STR_LIT:d>'<EOL><DEDENT>eA = np.identity(n, dtype=t)<EOL>trm = np.identity(n, dtype=t)<EOL>castfunc = cast[t]<EOL>for k in range(<NUM_LIT:1>, q):<EOL><INDENT>trm[:] = trm.dot(A) / castfunc(k)<EOL>eA += trm<EOL><DEDENT>return eA<EOL>", "docstring": "Compute the matrix exponential using Taylor series.\n\nParameters\n----------\nA : (N, N) array_like\n    Matrix to be exponentiated\nq : int\n    Order of the Taylor series used is `q-1`\n\nReturns\n-------\nexpm3 : (N, N) ndarray\n    Matrix exponential of `A`", "id": "f19326:m6"}
{"signature": "@np.deprecate(new_name=\"<STR_LIT>\")<EOL>def expm2(A):", "body": "A = _asarray_square(A)<EOL>t = A.dtype.char<EOL>if t not in ['<STR_LIT:f>','<STR_LIT:F>','<STR_LIT:d>','<STR_LIT:D>']:<EOL><INDENT>A = A.astype('<STR_LIT:d>')<EOL>t = '<STR_LIT:d>'<EOL><DEDENT>s, vr = eig(A)<EOL>vri = inv(vr)<EOL>r = dot(dot(vr, diag(exp(s))), vri)<EOL>if t in ['<STR_LIT:f>', '<STR_LIT:d>']:<EOL><INDENT>return r.real.astype(t)<EOL><DEDENT>else:<EOL><INDENT>return r.astype(t)<EOL><DEDENT>", "docstring": "Compute the matrix exponential using eigenvalue decomposition.\n\nParameters\n----------\nA : (N, N) array_like\n    Matrix to be exponentiated\n\nReturns\n-------\nexpm2 : (N, N) ndarray\n    Matrix exponential of `A`", "id": "f19326:m5"}
{"signature": "def _solve_discrete_lyapunov_direct(a, q):", "body": "lhs = kron(a, a.conj())<EOL>lhs = np.eye(lhs.shape[<NUM_LIT:0>]) - lhs<EOL>x = solve(lhs, q.flatten())<EOL>return np.reshape(x, q.shape)<EOL>", "docstring": "Solves the discrete Lyapunov equation directly.\n\nThis function is called by the `solve_discrete_lyapunov` function with\n`method=direct`. It is not supposed to be called directly.", "id": "f19327:m2"}
{"signature": "def solve_lyapunov(a, q):", "body": "return solve_sylvester(a, a.conj().transpose(), q)<EOL>", "docstring": "Solves the continuous Lyapunov equation (AX + XA^H = Q) given the values\nof A and Q using the Bartels-Stewart algorithm.\n\nParameters\n----------\na : array_like\n    A square matrix\n\nq : array_like\n    Right-hand side square matrix\n\nReturns\n-------\nx : array_like\n    Solution to the continuous Lyapunov equation\n\nSee Also\n--------\nsolve_sylvester : computes the solution to the Sylvester equation\n\nNotes\n-----\nBecause the continuous Lyapunov equation is just a special form of the\nSylvester equation, this solver relies entirely on solve_sylvester for a\nsolution.\n\n.. versionadded:: 0.11.0", "id": "f19327:m1"}
{"signature": "def solve_sylvester(a,b,q):", "body": "<EOL>r,u = schur(a, output='<STR_LIT>')<EOL>s,v = schur(b.conj().transpose(), output='<STR_LIT>')<EOL>f = np.dot(np.dot(u.conj().transpose(), q), v)<EOL>trsyl, = get_lapack_funcs(('<STR_LIT>',), (r,s,f))<EOL>if trsyl is None:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>y, scale, info = trsyl(r, s, f, tranb='<STR_LIT:C>')<EOL>y = scale*y<EOL>if info < <NUM_LIT:0>:<EOL><INDENT>raise LinAlgError(\"<STR_LIT>\" % (-info,))<EOL><DEDENT>return np.dot(np.dot(u, y), v.conj().transpose())<EOL>", "docstring": "Computes a solution (X) to the Sylvester equation (AX + XB = Q).\n\nParameters\n----------\na : (M, M) array_like\n    Leading matrix of the Sylvester equation\nb : (N, N) array_like\n    Trailing matrix of the Sylvester equation\nq : (M, N) array_like\n    Right-hand side\n\nReturns\n-------\nx : (M, N) ndarray\n    The solution to the Sylvester equation.\n\nRaises\n------\nLinAlgError\n    If solution was not found\n\nNotes\n-----\nComputes a solution to the Sylvester matrix equation via the Bartels-\nStewart algorithm.  The A and B matrices first undergo Schur\ndecompositions.  The resulting matrices are used to construct an\nalternative Sylvester equation (``RY + YS^T = F``) where the R and S\nmatrices are in quasi-triangular form (or, when R, S or F are complex,\ntriangular form).  The simplified equation is then solved using\n``*TRSYL`` from LAPACK directly.\n\n.. versionadded:: 0.11.0", "id": "f19327:m0"}
{"signature": "def solve_discrete_are(a, b, q, r):", "body": "try:<EOL><INDENT>g = inv(r)<EOL><DEDENT>except LinAlgError:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>g = np.dot(np.dot(b, g), b.conj().transpose())<EOL>try:<EOL><INDENT>ait = inv(a).conj().transpose()  <EOL><DEDENT>except LinAlgError:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>z11 = a+np.dot(np.dot(g, ait), q)<EOL>z12 = -<NUM_LIT:1.0>*np.dot(g, ait)<EOL>z21 = -<NUM_LIT:1.0>*np.dot(ait, q)<EOL>z22 = ait<EOL>z = np.vstack((np.hstack((z11, z12)), np.hstack((z21, z22))))<EOL>[s, u, sorted] = schur(z, sort='<STR_LIT>')<EOL>(m,n) = u.shape<EOL>u11 = u[<NUM_LIT:0>:m//<NUM_LIT:2>, <NUM_LIT:0>:n//<NUM_LIT:2>]<EOL>u21 = u[m//<NUM_LIT:2>:m, <NUM_LIT:0>:n//<NUM_LIT:2>]<EOL>u11i = inv(u11)<EOL>return np.dot(u21, u11i)<EOL>", "docstring": "Solves the disctrete algebraic Riccati equation, or DARE, defined as\n(X = A'XA-(A'XB)(R+B'XB)^-1(B'XA)+Q), directly using a Schur decomposition\nmethod.\n\nParameters\n----------\na : (M, M) array_like\n    Non-singular, square matrix\nb : (M, N) array_like\n    Input\nq : (M, M) array_like\n    Input\nr : (N, N) array_like\n    Non-singular, square matrix\n\nReturns\n-------\nx : ndarray\n    Solution to the continuous Lyapunov equation\n\nSee Also\n--------\nsolve_continuous_are : Solves the continuous algebraic Riccati equation\n\nNotes\n-----\nMethod taken from:\nLaub, \"A Schur Method for Solving Algebraic Riccati Equations.\"\nU.S. Energy Research and Development Agency under contract\nERDA-E(49-18)-2087.\nhttp://dspace.mit.edu/bitstream/handle/1721.1/1301/R-0859-05666488.pdf\n\n.. versionadded:: 0.11.0", "id": "f19327:m6"}
{"signature": "def hankel(c, r=None):", "body": "c = np.asarray(c).ravel()<EOL>if r is None:<EOL><INDENT>r = np.zeros_like(c)<EOL><DEDENT>else:<EOL><INDENT>r = np.asarray(r).ravel()<EOL><DEDENT>vals = np.concatenate((c, r[<NUM_LIT:1>:]))<EOL>a, b = np.ogrid[<NUM_LIT:0>:len(c), <NUM_LIT:0>:len(r)]<EOL>indx = a + b<EOL>return vals[indx]<EOL>", "docstring": "Construct a Hankel matrix.\n\nThe Hankel matrix has constant anti-diagonals, with `c` as its\nfirst column and `r` as its last row.  If `r` is not given, then\n`r = zeros_like(c)` is assumed.\n\nParameters\n----------\nc : array_like\n    First column of the matrix.  Whatever the actual shape of `c`, it\n    will be converted to a 1-D array.\nr : array_like\n    Last row of the matrix. If None, ``r = zeros_like(c)`` is assumed.\n    r[0] is ignored; the last row of the returned matrix is\n    ``[c[-1], r[1:]]``.  Whatever the actual shape of `r`, it will be\n    converted to a 1-D array.\n\nReturns\n-------\nA : (len(c), len(r)) ndarray\n    The Hankel matrix. Dtype is the same as ``(c[0] + r[0]).dtype``.\n\nSee also\n--------\ntoeplitz : Toeplitz matrix\ncirculant : circulant matrix\n\nExamples\n--------\n>>> from scipy.linalg import hankel\n>>> hankel([1, 17, 99])\narray([[ 1, 17, 99],\n       [17, 99,  0],\n       [99,  0,  0]])\n>>> hankel([1,2,3,4], [4,7,7,8,9])\narray([[1, 2, 3, 4, 7],\n       [2, 3, 4, 7, 7],\n       [3, 4, 7, 7, 8],\n       [4, 7, 7, 8, 9]])", "id": "f19328:m5"}
{"signature": "def triu(m, k=<NUM_LIT:0>):", "body": "m = np.asarray(m)<EOL>out = (<NUM_LIT:1> - tri(m.shape[<NUM_LIT:0>], m.shape[<NUM_LIT:1>], k - <NUM_LIT:1>, m.dtype.char)) * m<EOL>return out<EOL>", "docstring": "Make a copy of a matrix with elements below the k-th diagonal zeroed.\n\nParameters\n----------\nm : array_like\n    Matrix whose elements to return\nk : int, optional\n    Diagonal below which to zero elements.\n    `k` == 0 is the main diagonal, `k` < 0 subdiagonal and\n    `k` > 0 superdiagonal.\n\nReturns\n-------\ntriu : ndarray\n    Return matrix with zeroed elements below the k-th diagonal and has\n    same shape and type as `m`.\n\nExamples\n--------\n>>> from scipy.linalg import triu\n>>> triu([[1,2,3],[4,5,6],[7,8,9],[10,11,12]], -1)\narray([[ 1,  2,  3],\n       [ 4,  5,  6],\n       [ 0,  8,  9],\n       [ 0,  0, 12]])", "id": "f19328:m2"}
{"signature": "def hadamard(n, dtype=int):", "body": "<EOL>if n < <NUM_LIT:1>:<EOL><INDENT>lg2 = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>lg2 = int(math.log(n, <NUM_LIT:2>))<EOL><DEDENT>if <NUM_LIT:2> ** lg2 != n:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>H = np.array([[<NUM_LIT:1>]], dtype=dtype)<EOL>for i in range(<NUM_LIT:0>, lg2):<EOL><INDENT>H = np.vstack((np.hstack((H, H)), np.hstack((H, -H))))<EOL><DEDENT>return H<EOL>", "docstring": "Construct a Hadamard matrix.\n\nConstructs an n-by-n Hadamard matrix, using Sylvester's\nconstruction.  `n` must be a power of 2.\n\nParameters\n----------\nn : int\n    The order of the matrix.  `n` must be a power of 2.\ndtype : numpy dtype\n    The data type of the array to be constructed.\n\nReturns\n-------\nH : (n, n) ndarray\n    The Hadamard matrix.\n\nNotes\n-----\n.. versionadded:: 0.8.0\n\nExamples\n--------\n>>> from scipy.linalg import hadamard\n>>> hadamard(2, dtype=complex)\narray([[ 1.+0.j,  1.+0.j],\n       [ 1.+0.j, -1.-0.j]])\n>>> hadamard(4)\narray([[ 1,  1,  1,  1],\n       [ 1, -1,  1, -1],\n       [ 1,  1, -1, -1],\n       [ 1, -1, -1,  1]])", "id": "f19328:m6"}
{"signature": "def leslie(f, s):", "body": "f = np.atleast_1d(f)<EOL>s = np.atleast_1d(s)<EOL>if f.ndim != <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if s.ndim != <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if f.size != s.size + <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>if s.size == <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>tmp = f[<NUM_LIT:0>] + s[<NUM_LIT:0>]<EOL>n = f.size<EOL>a = np.zeros((n, n), dtype=tmp.dtype)<EOL>a[<NUM_LIT:0>] = f<EOL>a[list(range(<NUM_LIT:1>, n)), list(range(<NUM_LIT:0>, n - <NUM_LIT:1>))] = s<EOL>return a<EOL>", "docstring": "Create a Leslie matrix.\n\nGiven the length n array of fecundity coefficients `f` and the length\nn-1 array of survival coefficents `s`, return the associated Leslie matrix.\n\nParameters\n----------\nf : (N,) array_like\n    The \"fecundity\" coefficients.\ns : (N-1,) array_like\n    The \"survival\" coefficients, has to be 1-D.  The length of `s`\n    must be one less than the length of `f`, and it must be at least 1.\n\nReturns\n-------\nL : (N, N) ndarray\n    The array is zero except for the first row,\n    which is `f`, and the first sub-diagonal, which is `s`.\n    The data-type of the array will be the data-type of ``f[0]+s[0]``.\n\nNotes\n-----\n.. versionadded:: 0.8.0\n\nThe Leslie matrix is used to model discrete-time, age-structured\npopulation growth [1]_ [2]_. In a population with `n` age classes, two sets\nof parameters define a Leslie matrix: the `n` \"fecundity coefficients\",\nwhich give the number of offspring per-capita produced by each age\nclass, and the `n` - 1 \"survival coefficients\", which give the\nper-capita survival rate of each age class.\n\nReferences\n----------\n.. [1] P. H. Leslie, On the use of matrices in certain population\n       mathematics, Biometrika, Vol. 33, No. 3, 183--212 (Nov. 1945)\n.. [2] P. H. Leslie, Some further notes on the use of matrices in\n       population mathematics, Biometrika, Vol. 35, No. 3/4, 213--245\n       (Dec. 1948)\n\nExamples\n--------\n>>> from scipy.linalg import leslie\n>>> leslie([0.1, 2.0, 1.0, 0.1], [0.2, 0.8, 0.7])\narray([[ 0.1,  2. ,  1. ,  0.1],\n       [ 0.2,  0. ,  0. ,  0. ],\n       [ 0. ,  0.8,  0. ,  0. ],\n       [ 0. ,  0. ,  0.7,  0. ]])", "id": "f19328:m7"}
{"signature": "def toeplitz(c, r=None):", "body": "c = np.asarray(c).ravel()<EOL>if r is None:<EOL><INDENT>r = c.conjugate()<EOL><DEDENT>else:<EOL><INDENT>r = np.asarray(r).ravel()<EOL><DEDENT>vals = np.concatenate((r[-<NUM_LIT:1>:<NUM_LIT:0>:-<NUM_LIT:1>], c))<EOL>a, b = np.ogrid[<NUM_LIT:0>:len(c), len(r) - <NUM_LIT:1>:-<NUM_LIT:1>:-<NUM_LIT:1>]<EOL>indx = a + b<EOL>return vals[indx]<EOL>", "docstring": "Construct a Toeplitz matrix.\n\nThe Toeplitz matrix has constant diagonals, with c as its first column\nand r as its first row.  If r is not given, ``r == conjugate(c)`` is\nassumed.\n\nParameters\n----------\nc : array_like\n    First column of the matrix.  Whatever the actual shape of `c`, it\n    will be converted to a 1-D array.\nr : array_like\n    First row of the matrix. If None, ``r = conjugate(c)`` is assumed;\n    in this case, if c[0] is real, the result is a Hermitian matrix.\n    r[0] is ignored; the first row of the returned matrix is\n    ``[c[0], r[1:]]``.  Whatever the actual shape of `r`, it will be\n    converted to a 1-D array.\n\nReturns\n-------\nA : (len(c), len(r)) ndarray\n    The Toeplitz matrix. Dtype is the same as ``(c[0] + r[0]).dtype``.\n\nSee also\n--------\ncirculant : circulant matrix\nhankel : Hankel matrix\n\nNotes\n-----\nThe behavior when `c` or `r` is a scalar, or when `c` is complex and\n`r` is None, was changed in version 0.8.0.  The behavior in previous\nversions was undocumented and is no longer supported.\n\nExamples\n--------\n>>> from scipy.linalg import toeplitz\n>>> toeplitz([1,2,3], [1,4,5,6])\narray([[1, 4, 5, 6],\n       [2, 1, 4, 5],\n       [3, 2, 1, 4]])\n>>> toeplitz([1.0, 2+3j, 4-1j])\narray([[ 1.+0.j,  2.-3.j,  4.+1.j],\n       [ 2.+3.j,  1.+0.j,  2.-3.j],\n       [ 4.-1.j,  2.+3.j,  1.+0.j]])", "id": "f19328:m3"}
{"signature": "def hilbert(n):", "body": "values = <NUM_LIT:1.0> / (<NUM_LIT:1.0> + np.arange(<NUM_LIT:2> * n - <NUM_LIT:1>))<EOL>h = hankel(values[:n], r=values[n - <NUM_LIT:1>:])<EOL>return h<EOL>", "docstring": "Create a Hilbert matrix of order `n`.\n\nReturns the `n` by `n` array with entries `h[i,j] = 1 / (i + j + 1)`.\n\nParameters\n----------\nn : int\n    The size of the array to create.\n\nReturns\n-------\nh : (n, n) ndarray\n    The Hilbert matrix.\n\nSee Also\n--------\ninvhilbert : Compute the inverse of a Hilbert matrix.\n\nNotes\n-----\n.. versionadded:: 0.10.0\n\nExamples\n--------\n>>> from scipy.linalg import hilbert\n>>> hilbert(3)\narray([[ 1.        ,  0.5       ,  0.33333333],\n       [ 0.5       ,  0.33333333,  0.25      ],\n       [ 0.33333333,  0.25      ,  0.2       ]])", "id": "f19328:m12"}
{"signature": "def kmeans(obs, k_or_guess, iter=<NUM_LIT:20>, thresh=<NUM_LIT>):", "body": "if int(iter) < <NUM_LIT:1>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if type(k_or_guess) == type(array([])):<EOL><INDENT>guess = k_or_guess<EOL>if guess.size < <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" %<EOL>guess)<EOL><DEDENT>result = _kmeans(obs, guess, thresh=thresh)<EOL><DEDENT>else:<EOL><INDENT>best_dist = np.inf<EOL>No = obs.shape[<NUM_LIT:0>]<EOL>k = k_or_guess<EOL>if k < <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>for i in range(iter):<EOL><INDENT>guess = take(obs, randint(<NUM_LIT:0>, No, k), <NUM_LIT:0>)<EOL>book, dist = _kmeans(obs, guess, thresh=thresh)<EOL>if dist < best_dist:<EOL><INDENT>best_book = book<EOL>best_dist = dist<EOL><DEDENT><DEDENT>result = best_book, best_dist<EOL><DEDENT>return result<EOL>", "docstring": "Performs k-means on a set of observation vectors forming k clusters.\n\nThe k-means algorithm adjusts the centroids until sufficient\nprogress cannot be made, i.e. the change in distortion since\nthe last iteration is less than some threshold. This yields\na code book mapping centroids to codes and vice versa.\n\nDistortion is defined as the sum of the squared differences\nbetween the observations and the corresponding centroid.\n\nParameters\n----------\nobs : ndarray\n   Each row of the M by N array is an observation vector. The\n   columns are the features seen during each observation.\n   The features must be whitened first with the `whiten` function.\n\nk_or_guess : int or ndarray\n   The number of centroids to generate. A code is assigned to\n   each centroid, which is also the row index of the centroid\n   in the code_book matrix generated.\n\n   The initial k centroids are chosen by randomly selecting\n   observations from the observation matrix. Alternatively,\n   passing a k by N array specifies the initial k centroids.\n\niter : int, optional\n   The number of times to run k-means, returning the codebook\n   with the lowest distortion. This argument is ignored if\n   initial centroids are specified with an array for the\n   ``k_or_guess`` parameter. This parameter does not represent the\n   number of iterations of the k-means algorithm.\n\nthresh : float, optional\n   Terminates the k-means algorithm if the change in\n   distortion since the last k-means iteration is less than\n   or equal to thresh.\n\nReturns\n-------\ncodebook : ndarray\n   A k by N array of k centroids. The i'th centroid\n   codebook[i] is represented with the code i. The centroids\n   and codes generated represent the lowest distortion seen,\n   not necessarily the globally minimal distortion.\n\ndistortion : float\n   The distortion between the observations passed and the\n   centroids generated.\n\nSee Also\n--------\nkmeans2 : a different implementation of k-means clustering\n   with more methods for generating initial centroids but without\n   using a distortion change threshold as a stopping criterion.\n\nwhiten : must be called prior to passing an observation matrix\n   to kmeans.\n\nExamples\n--------\n>>> from numpy import array\n>>> from scipy.cluster.vq import vq, kmeans, whiten\n>>> features  = array([[ 1.9,2.3],\n...                    [ 1.5,2.5],\n...                    [ 0.8,0.6],\n...                    [ 0.4,1.8],\n...                    [ 0.1,0.1],\n...                    [ 0.2,1.8],\n...                    [ 2.0,0.5],\n...                    [ 0.3,1.5],\n...                    [ 1.0,1.0]])\n>>> whitened = whiten(features)\n>>> book = array((whitened[0],whitened[2]))\n>>> kmeans(whitened,book)\n(array([[ 2.3110306 ,  2.86287398],\n       [ 0.93218041,  1.24398691]]), 0.85684700941625547)\n\n>>> from numpy import random\n>>> random.seed((1000,2000))\n>>> codes = 3\n>>> kmeans(whitened,codes)\n(array([[ 2.3110306 ,  2.86287398],\n       [ 1.32544402,  0.65607529],\n       [ 0.40782893,  2.02786907]]), 0.5196582527686241)", "id": "f19329:m6"}
{"signature": "def _krandinit(data, k):", "body": "def init_rank1(data):<EOL><INDENT>mu = np.mean(data)<EOL>cov = np.cov(data)<EOL>x = np.random.randn(k)<EOL>x *= np.sqrt(cov)<EOL>x += mu<EOL>return x<EOL><DEDENT>def init_rankn(data):<EOL><INDENT>mu = np.mean(data, <NUM_LIT:0>)<EOL>cov = np.atleast_2d(np.cov(data, rowvar=<NUM_LIT:0>))<EOL>x = np.random.randn(k, mu.size)<EOL>x = np.dot(x, np.linalg.cholesky(cov).T) + mu<EOL>return x<EOL><DEDENT>nd = np.ndim(data)<EOL>if nd == <NUM_LIT:1>:<EOL><INDENT>return init_rank1(data)<EOL><DEDENT>else:<EOL><INDENT>return init_rankn(data)<EOL><DEDENT>", "docstring": "Returns k samples of a random variable which parameters depend on data.\n\n    More precisely, it returns k observations sampled from a Gaussian random\n    variable which mean and covariances are the one estimated from data.\n\n    Parameters\n    ----------\n    data : ndarray\n        Expect a rank 1 or 2 array. Rank 1 are assumed to describe one\n        dimensional data, rank 2 multidimensional data, in which case one\n        row is one observation.\n    k : int\n        Number of samples to generate.", "id": "f19329:m8"}
{"signature": "def _remove_dups(L):", "body": "seen_before = set([])<EOL>L2 = []<EOL>for i in L:<EOL><INDENT>if i not in seen_before:<EOL><INDENT>seen_before.add(i)<EOL>L2.append(i)<EOL><DEDENT><DEDENT>return L2<EOL>", "docstring": "Removes duplicates AND preserves the original order of the elements.\nThe set class is not guaranteed to do this.", "id": "f19336:m30"}
{"signature": "def leaders(Z, T):", "body": "Z = np.asarray(Z, order='<STR_LIT:c>')<EOL>T = np.asarray(T, order='<STR_LIT:c>')<EOL>if type(T) != np.ndarray or T.dtype != '<STR_LIT:i>':<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>is_valid_linkage(Z, throw=True, name='<STR_LIT>')<EOL>if len(T) != Z.shape[<NUM_LIT:0>] + <NUM_LIT:1>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>Cl = np.unique(T)<EOL>kk = len(Cl)<EOL>L = np.zeros((kk,), dtype='<STR_LIT:i>')<EOL>M = np.zeros((kk,), dtype='<STR_LIT:i>')<EOL>n = Z.shape[<NUM_LIT:0>] + <NUM_LIT:1><EOL>[Z, T] = _copy_arrays_if_base_present([Z, T])<EOL>s = _hierarchy.leaders(Z, T, L, M, int(kk), int(n))<EOL>if s >= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(('<STR_LIT>'<EOL>'<STR_LIT>') % s)<EOL><DEDENT>return (L, M)<EOL>", "docstring": "Returns the root nodes in a hierarchical clustering.\n\nReturns the root nodes in a hierarchical clustering corresponding\nto a cut defined by a flat cluster assignment vector ``T``. See\nthe ``fcluster`` function for more information on the format of ``T``.\n\nFor each flat cluster :math:`j` of the :math:`k` flat clusters\nrepresented in the n-sized flat cluster assignment vector ``T``,\nthis function finds the lowest cluster node :math:`i` in the linkage\ntree Z such that:\n\n  * leaf descendents belong only to flat cluster j\n    (i.e. ``T[p]==j`` for all :math:`p` in :math:`S(i)` where\n    :math:`S(i)` is the set of leaf ids of leaf nodes descendent\n    with cluster node :math:`i`)\n\n  * there does not exist a leaf that is not descendent with\n    :math:`i` that also belongs to cluster :math:`j`\n    (i.e. ``T[q]!=j`` for all :math:`q` not in :math:`S(i)`).  If\n    this condition is violated, ``T`` is not a valid cluster\n    assignment vector, and an exception will be thrown.\n\nParameters\n----------\nZ : ndarray\n    The hierarchical clustering encoded as a matrix. See\n    ``linkage`` for more information.\nT : ndarray\n    The flat cluster assignment vector.\n\nReturns\n-------\nL : ndarray\n    The leader linkage node id's stored as a k-element 1-D array\n    where ``k`` is the number of flat clusters found in ``T``.\n\n    ``L[j]=i`` is the linkage cluster node id that is the\n    leader of flat cluster with id M[j].  If ``i < n``, ``i``\n    corresponds to an original observation, otherwise it\n    corresponds to a non-singleton cluster.\n\n    For example: if ``L[3]=2`` and ``M[3]=8``, the flat cluster with\n    id 8's leader is linkage node 2.\nM : ndarray\n    The leader linkage node id's stored as a k-element 1-D array where\n    ``k`` is the number of flat clusters found in ``T``. This allows the\n    set of flat cluster ids to be any arbitrary set of ``k`` integers.", "id": "f19336:m45"}
{"signature": "def _randdm(pnts):", "body": "if pnts >= <NUM_LIT:2>:<EOL><INDENT>D = np.random.rand(pnts * (pnts - <NUM_LIT:1>) / <NUM_LIT:2>)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>return D<EOL>", "docstring": "Generates a random distance matrix stored in condensed form. A\n        pnts * (pnts - 1) / 2 sized vector is returned.", "id": "f19336:m3"}
{"signature": "def _copy_array_if_base_present(a):", "body": "if a.base is not None:<EOL><INDENT>return a.copy()<EOL><DEDENT>elif np.issubsctype(a, np.float32):<EOL><INDENT>return np.array(a, dtype=np.double)<EOL><DEDENT>else:<EOL><INDENT>return a<EOL><DEDENT>", "docstring": "Copies the array if its base points to a parent array.", "id": "f19336:m1"}
{"signature": "def linkage(y, method='<STR_LIT>', metric='<STR_LIT>'):", "body": "if not isinstance(method, string_types):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>y = _convert_to_double(np.asarray(y, order='<STR_LIT:c>'))<EOL>s = y.shape<EOL>if len(s) == <NUM_LIT:1>:<EOL><INDENT>distance.is_valid_y(y, throw=True, name='<STR_LIT:y>')<EOL>d = distance.num_obs_y(y)<EOL>if method not in _cpy_non_euclid_methods:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>[y] = _copy_arrays_if_base_present([y])<EOL>Z = np.zeros((d - <NUM_LIT:1>, <NUM_LIT:4>))<EOL>if method == '<STR_LIT>':<EOL><INDENT>_hierarchy.slink(y, Z, int(d))<EOL><DEDENT>else:<EOL><INDENT>_hierarchy.linkage(y, Z, int(d),<EOL>int(_cpy_non_euclid_methods[method]))<EOL><DEDENT><DEDENT>elif len(s) == <NUM_LIT:2>:<EOL><INDENT>X = y<EOL>n = s[<NUM_LIT:0>]<EOL>if method not in _cpy_linkage_methods:<EOL><INDENT>raise ValueError('<STR_LIT>' % method)<EOL><DEDENT>if method in _cpy_non_euclid_methods:<EOL><INDENT>dm = distance.pdist(X, metric)<EOL>Z = np.zeros((n - <NUM_LIT:1>, <NUM_LIT:4>))<EOL>if method == '<STR_LIT>':<EOL><INDENT>_hierarchy.slink(dm, Z, n)<EOL><DEDENT>else:<EOL><INDENT>_hierarchy.linkage(dm, Z, n,<EOL>int(_cpy_non_euclid_methods[method]))<EOL><DEDENT><DEDENT>elif method in _cpy_euclid_methods:<EOL><INDENT>if metric != '<STR_LIT>':<EOL><INDENT>raise ValueError((\"<STR_LIT>\"<EOL>\"<STR_LIT>\") % method)<EOL><DEDENT>dm = distance.pdist(X, metric)<EOL>Z = np.zeros((n - <NUM_LIT:1>, <NUM_LIT:4>))<EOL>_hierarchy.linkage(dm, Z, n,<EOL>int(_cpy_euclid_methods[method]))<EOL><DEDENT><DEDENT>return Z<EOL>", "docstring": "Performs hierarchical/agglomerative clustering on the condensed\ndistance matrix y.\n\ny must be a :math:`{n \\\\choose 2}` sized\nvector where n is the number of original observations paired\nin the distance matrix. The behavior of this function is very\nsimilar to the MATLAB linkage function.\n\nA 4 by :math:`(n-1)` matrix ``Z`` is returned. At the\n:math:`i`-th iteration, clusters with indices ``Z[i, 0]`` and\n``Z[i, 1]`` are combined to form cluster :math:`n + i`. A\ncluster with an index less than :math:`n` corresponds to one of\nthe :math:`n` original observations. The distance between\nclusters ``Z[i, 0]`` and ``Z[i, 1]`` is given by ``Z[i, 2]``. The\nfourth value ``Z[i, 3]`` represents the number of original\nobservations in the newly formed cluster.\n\nThe following linkage methods are used to compute the distance\n:math:`d(s, t)` between two clusters :math:`s` and\n:math:`t`. The algorithm begins with a forest of clusters that\nhave yet to be used in the hierarchy being formed. When two\nclusters :math:`s` and :math:`t` from this forest are combined\ninto a single cluster :math:`u`, :math:`s` and :math:`t` are\nremoved from the forest, and :math:`u` is added to the\nforest. When only one cluster remains in the forest, the algorithm\nstops, and this cluster becomes the root.\n\nA distance matrix is maintained at each iteration. The ``d[i,j]``\nentry corresponds to the distance between cluster :math:`i` and\n:math:`j` in the original forest.\n\nAt each iteration, the algorithm must update the distance matrix\nto reflect the distance of the newly formed cluster u with the\nremaining clusters in the forest.\n\nSuppose there are :math:`|u|` original observations\n:math:`u[0], \\\\ldots, u[|u|-1]` in cluster :math:`u` and\n:math:`|v|` original objects :math:`v[0], \\\\ldots, v[|v|-1]` in\ncluster :math:`v`. Recall :math:`s` and :math:`t` are\ncombined to form cluster :math:`u`. Let :math:`v` be any\nremaining cluster in the forest that is not :math:`u`.\n\nThe following are methods for calculating the distance between the\nnewly formed cluster :math:`u` and each :math:`v`.\n\n  * method='single' assigns\n\n    .. math::\n       d(u,v) = \\\\min(dist(u[i],v[j]))\n\n    for all points :math:`i` in cluster :math:`u` and\n    :math:`j` in cluster :math:`v`. This is also known as the\n    Nearest Point Algorithm.\n\n  * method='complete' assigns\n\n    .. math::\n       d(u, v) = \\\\max(dist(u[i],v[j]))\n\n    for all points :math:`i` in cluster u and :math:`j` in\n    cluster :math:`v`. This is also known by the Farthest Point\n    Algorithm or Voor Hees Algorithm.\n\n  * method='average' assigns\n\n    .. math::\n       d(u,v) = \\\\sum_{ij} \\\\frac{d(u[i], v[j])}\n                               {(|u|*|v|)}\n\n    for all points :math:`i` and :math:`j` where :math:`|u|`\n    and :math:`|v|` are the cardinalities of clusters :math:`u`\n    and :math:`v`, respectively. This is also called the UPGMA\n    algorithm.\n\n  * method='weighted' assigns\n\n    .. math::\n       d(u,v) = (dist(s,v) + dist(t,v))/2\n\n    where cluster u was formed with cluster s and t and v\n    is a remaining cluster in the forest. (also called WPGMA)\n\n  * method='centroid' assigns\n\n    .. math::\n       dist(s,t) = ||c_s-c_t||_2\n\n    where :math:`c_s` and :math:`c_t` are the centroids of\n    clusters :math:`s` and :math:`t`, respectively. When two\n    clusters :math:`s` and :math:`t` are combined into a new\n    cluster :math:`u`, the new centroid is computed over all the\n    original objects in clusters :math:`s` and :math:`t`. The\n    distance then becomes the Euclidean distance between the\n    centroid of :math:`u` and the centroid of a remaining cluster\n    :math:`v` in the forest. This is also known as the UPGMC\n    algorithm.\n\n  * method='median' assigns math:`d(s,t)` like the ``centroid``\n    method. When two clusters :math:`s` and :math:`t` are combined\n    into a new cluster :math:`u`, the average of centroids s and t\n    give the new centroid :math:`u`. This is also known as the\n    WPGMC algorithm.\n\n  * method='ward' uses the Ward variance minimization algorithm.\n    The new entry :math:`d(u,v)` is computed as follows,\n\n    .. math::\n\n       d(u,v) = \\\\sqrt{\\\\frac{|v|+|s|}\n                           {T}d(v,s)^2\n                    + \\\\frac{|v|+|t|}\n                           {T}d(v,t)^2\n                    + \\\\frac{|v|}\n                           {T}d(s,t)^2}\n\n    where :math:`u` is the newly joined cluster consisting of\n    clusters :math:`s` and :math:`t`, :math:`v` is an unused\n    cluster in the forest, :math:`T=|v|+|s|+|t|`, and\n    :math:`|*|` is the cardinality of its argument. This is also\n    known as the incremental algorithm.\n\nWarning: When the minimum distance pair in the forest is chosen, there\nmay be two or more pairs with the same minimum distance. This\nimplementation may chose a different minimum than the MATLAB\nversion.\n\nParameters\n----------\ny : ndarray\n    A condensed or redundant distance matrix. A condensed distance matrix\n    is a flat array containing the upper triangular of the distance matrix.\n    This is the form that ``pdist`` returns. Alternatively, a collection of\n    :math:`m` observation vectors in n dimensions may be passed as an\n    :math:`m` by :math:`n` array.\nmethod : str, optional\n    The linkage algorithm to use. See the ``Linkage Methods`` section below\n    for full descriptions.\nmetric : str, optional\n    The distance metric to use. See the ``distance.pdist`` function for a\n    list of valid distance metrics.\n\nReturns\n-------\nZ : ndarray\n    The hierarchical clustering encoded as a linkage matrix.", "id": "f19336:m11"}
{"signature": "def is_valid_linkage(Z, warning=False, throw=False, name=None):", "body": "Z = np.asarray(Z, order='<STR_LIT:c>')<EOL>valid = True<EOL>try:<EOL><INDENT>if type(Z) != np.ndarray:<EOL><INDENT>if name:<EOL><INDENT>raise TypeError(('<STR_LIT>'<EOL>'<STR_LIT>') % name)<EOL><DEDENT>else:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT><DEDENT>if Z.dtype != np.double:<EOL><INDENT>if name:<EOL><INDENT>raise TypeError('<STR_LIT>'<EOL>% name)<EOL><DEDENT>else:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT><DEDENT>if len(Z.shape) != <NUM_LIT:2>:<EOL><INDENT>if name:<EOL><INDENT>raise ValueError(('<STR_LIT>'<EOL>'<STR_LIT>') % name)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>if Z.shape[<NUM_LIT:1>] != <NUM_LIT:4>:<EOL><INDENT>if name:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>% name)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>if Z.shape[<NUM_LIT:0>] == <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>n = Z.shape[<NUM_LIT:0>]<EOL>if n > <NUM_LIT:1>:<EOL><INDENT>if ((Z[:, <NUM_LIT:0>] < <NUM_LIT:0>).any() or (Z[:, <NUM_LIT:1>] < <NUM_LIT:0>).any()):<EOL><INDENT>if name:<EOL><INDENT>raise ValueError(('<STR_LIT>'<EOL>'<STR_LIT>') % name)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>if (Z[:, <NUM_LIT:2>] < <NUM_LIT:0>).any():<EOL><INDENT>if name:<EOL><INDENT>raise ValueError(('<STR_LIT>'<EOL>'<STR_LIT>') % name)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>if (Z[:, <NUM_LIT:3>] < <NUM_LIT:0>).any():<EOL><INDENT>if name:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>% name)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>if _check_hierarchy_uses_cluster_before_formed(Z):<EOL><INDENT>if name:<EOL><INDENT>raise ValueError(('<STR_LIT>'<EOL>'<STR_LIT>') % name)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if _check_hierarchy_uses_cluster_more_than_once(Z):<EOL><INDENT>if name:<EOL><INDENT>raise ValueError(('<STR_LIT>'<EOL>'<STR_LIT>') % name)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>except Exception as e:<EOL><INDENT>if throw:<EOL><INDENT>raise<EOL><DEDENT>if warning:<EOL><INDENT>_warning(str(e))<EOL><DEDENT>valid = False<EOL><DEDENT>return valid<EOL>", "docstring": "Checks the validity of a linkage matrix.\n\nA linkage matrix is valid if it is a two dimensional\nndarray (type double) with :math:`n`\nrows and 4 columns.  The first two columns must contain indices\nbetween 0 and :math:`2n-1`. For a given row ``i``,\n:math:`0 \\\\leq \\\\mathtt{Z[i,0]} \\\\leq i+n-1`\nand :math:`0 \\\\leq Z[i,1] \\\\leq i+n-1`\n(i.e. a cluster cannot join another cluster unless the cluster\nbeing joined has been generated.)\n\nParameters\n----------\nZ : array_like\n    Linkage matrix.\nwarning : bool, optional\n    When True, issues a Python warning if the linkage\n    matrix passed is invalid.\nthrow : bool, optional\n    When True, throws a Python exception if the linkage\n    matrix passed is invalid.\nname : str, optional\n       This string refers to the variable name of the invalid\n       linkage matrix.\n\nReturns\n-------\nb : bool\n    True iff the inconsistency matrix is valid.", "id": "f19336:m21"}
{"signature": "def _dendrogram_calculate_info(Z, p, truncate_mode,<EOL>color_threshold=np.inf, get_leaves=True,<EOL>orientation='<STR_LIT>', labels=None,<EOL>count_sort=False, distance_sort=False,<EOL>show_leaf_counts=False, i=-<NUM_LIT:1>, iv=<NUM_LIT:0.0>,<EOL>ivl=[], n=<NUM_LIT:0>, icoord_list=[], dcoord_list=[],<EOL>lvs=None, mhr=False,<EOL>current_color=[], color_list=[],<EOL>currently_below_threshold=[],<EOL>leaf_label_func=None, level=<NUM_LIT:0>,<EOL>contraction_marks=None,<EOL>link_color_func=None):", "body": "if n == <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if i == -<NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if truncate_mode == '<STR_LIT>':<EOL><INDENT>if i < <NUM_LIT:2> * n - p and i >= n:<EOL><INDENT>d = Z[i - n, <NUM_LIT:2>]<EOL>_append_nonsingleton_leaf_node(Z, p, n, level, lvs, ivl,<EOL>leaf_label_func, i, labels,<EOL>show_leaf_counts)<EOL>if contraction_marks is not None:<EOL><INDENT>_append_contraction_marks(Z, iv + <NUM_LIT>, i, n, contraction_marks)<EOL><DEDENT>return (iv + <NUM_LIT>, <NUM_LIT>, <NUM_LIT:0.0>, d)<EOL><DEDENT>elif i < n:<EOL><INDENT>_append_singleton_leaf_node(Z, p, n, level, lvs, ivl,<EOL>leaf_label_func, i, labels)<EOL>return (iv + <NUM_LIT>, <NUM_LIT>, <NUM_LIT:0.0>, <NUM_LIT:0.0>)<EOL><DEDENT><DEDENT>elif truncate_mode in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>if i > n and level > p:<EOL><INDENT>d = Z[i - n, <NUM_LIT:2>]<EOL>_append_nonsingleton_leaf_node(Z, p, n, level, lvs, ivl,<EOL>leaf_label_func, i, labels,<EOL>show_leaf_counts)<EOL>if contraction_marks is not None:<EOL><INDENT>_append_contraction_marks(Z, iv + <NUM_LIT>, i, n, contraction_marks)<EOL><DEDENT>return (iv + <NUM_LIT>, <NUM_LIT>, <NUM_LIT:0.0>, d)<EOL><DEDENT>elif i < n:<EOL><INDENT>_append_singleton_leaf_node(Z, p, n, level, lvs, ivl,<EOL>leaf_label_func, i, labels)<EOL>return (iv + <NUM_LIT>, <NUM_LIT>, <NUM_LIT:0.0>, <NUM_LIT:0.0>)<EOL><DEDENT><DEDENT>elif truncate_mode in ('<STR_LIT>',):<EOL><INDENT>pass<EOL><DEDENT>if i < n:<EOL><INDENT>_append_singleton_leaf_node(Z, p, n, level, lvs, ivl,<EOL>leaf_label_func, i, labels)<EOL>return (iv + <NUM_LIT>, <NUM_LIT>, <NUM_LIT:0.0>, <NUM_LIT:0.0>)<EOL><DEDENT>aa = int(Z[i - n, <NUM_LIT:0>])<EOL>ab = int(Z[i - n, <NUM_LIT:1>])<EOL>if aa > n:<EOL><INDENT>na = Z[aa - n, <NUM_LIT:3>]<EOL>da = Z[aa - n, <NUM_LIT:2>]<EOL><DEDENT>else:<EOL><INDENT>na = <NUM_LIT:1><EOL>da = <NUM_LIT:0.0><EOL><DEDENT>if ab > n:<EOL><INDENT>nb = Z[ab - n, <NUM_LIT:3>]<EOL>db = Z[ab - n, <NUM_LIT:2>]<EOL><DEDENT>else:<EOL><INDENT>nb = <NUM_LIT:1><EOL>db = <NUM_LIT:0.0><EOL><DEDENT>if count_sort == '<STR_LIT>' or count_sort == True:<EOL><INDENT>if na > nb:<EOL><INDENT>ua = ab<EOL>ub = aa<EOL><DEDENT>else:<EOL><INDENT>ua = aa<EOL>ub = ab<EOL><DEDENT><DEDENT>elif count_sort == '<STR_LIT>':<EOL><INDENT>if na > nb:<EOL><INDENT>ua = aa<EOL>ub = ab<EOL><DEDENT>else:<EOL><INDENT>ua = ab<EOL>ub = aa<EOL><DEDENT><DEDENT>elif distance_sort == '<STR_LIT>' or distance_sort == True:<EOL><INDENT>if da > db:<EOL><INDENT>ua = ab<EOL>ub = aa<EOL><DEDENT>else:<EOL><INDENT>ua = aa<EOL>ub = ab<EOL><DEDENT><DEDENT>elif distance_sort == '<STR_LIT>':<EOL><INDENT>if da > db:<EOL><INDENT>ua = aa<EOL>ub = ab<EOL><DEDENT>else:<EOL><INDENT>ua = ab<EOL>ub = aa<EOL><DEDENT><DEDENT>else:<EOL><INDENT>ua = aa<EOL>ub = ab<EOL><DEDENT>(uiva, uwa, uah, uamd) =_dendrogram_calculate_info(<EOL>Z=Z, p=p,<EOL>truncate_mode=truncate_mode,<EOL>color_threshold=color_threshold,<EOL>get_leaves=get_leaves,<EOL>orientation=orientation,<EOL>labels=labels,<EOL>count_sort=count_sort,<EOL>distance_sort=distance_sort,<EOL>show_leaf_counts=show_leaf_counts,<EOL>i=ua, iv=iv, ivl=ivl, n=n,<EOL>icoord_list=icoord_list,<EOL>dcoord_list=dcoord_list, lvs=lvs,<EOL>current_color=current_color,<EOL>color_list=color_list,<EOL>currently_below_threshold=currently_below_threshold,<EOL>leaf_label_func=leaf_label_func,<EOL>level=level + <NUM_LIT:1>, contraction_marks=contraction_marks,<EOL>link_color_func=link_color_func)<EOL>h = Z[i - n, <NUM_LIT:2>]<EOL>if h >= color_threshold or color_threshold <= <NUM_LIT:0>:<EOL><INDENT>c = '<STR_LIT:b>'<EOL>if currently_below_threshold[<NUM_LIT:0>]:<EOL><INDENT>current_color[<NUM_LIT:0>] = (current_color[<NUM_LIT:0>] + <NUM_LIT:1>) % len(_link_line_colors)<EOL><DEDENT>currently_below_threshold[<NUM_LIT:0>] = False<EOL><DEDENT>else:<EOL><INDENT>currently_below_threshold[<NUM_LIT:0>] = True<EOL>c = _link_line_colors[current_color[<NUM_LIT:0>]]<EOL><DEDENT>(uivb, uwb, ubh, ubmd) =_dendrogram_calculate_info(<EOL>Z=Z, p=p,<EOL>truncate_mode=truncate_mode,<EOL>color_threshold=color_threshold,<EOL>get_leaves=get_leaves,<EOL>orientation=orientation,<EOL>labels=labels,<EOL>count_sort=count_sort,<EOL>distance_sort=distance_sort,<EOL>show_leaf_counts=show_leaf_counts,<EOL>i=ub, iv=iv + uwa, ivl=ivl, n=n,<EOL>icoord_list=icoord_list,<EOL>dcoord_list=dcoord_list, lvs=lvs,<EOL>current_color=current_color,<EOL>color_list=color_list,<EOL>currently_below_threshold=currently_below_threshold,<EOL>leaf_label_func=leaf_label_func,<EOL>level=level + <NUM_LIT:1>, contraction_marks=contraction_marks,<EOL>link_color_func=link_color_func)<EOL>max_dist = max(uamd, ubmd, h)<EOL>icoord_list.append([uiva, uiva, uivb, uivb])<EOL>dcoord_list.append([uah, h, h, ubh])<EOL>if link_color_func is not None:<EOL><INDENT>v = link_color_func(int(i))<EOL>if not isinstance(v, string_types):<EOL><INDENT>raise TypeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>color_list.append(v)<EOL><DEDENT>else:<EOL><INDENT>color_list.append(c)<EOL><DEDENT>return (((uiva + uivb) / <NUM_LIT:2>), uwa + uwb, h, max_dist)<EOL>", "docstring": "Calculates the endpoints of the links as well as the labels for the\nthe dendrogram rooted at the node with index i. iv is the independent\nvariable value to plot the left-most leaf node below the root node i\n(if orientation='top', this would be the left-most x value where the\nplotting of this root node i and its descendents should begin).\n\nivl is a list to store the labels of the leaf nodes. The leaf_label_func\nis called whenever ivl != None, labels == None, and\nleaf_label_func != None. When ivl != None and labels != None, the\nlabels list is used only for labeling the leaf nodes. When\nivl == None, no labels are generated for leaf nodes.\n\nWhen get_leaves==True, a list of leaves is built as they are visited\nin the dendrogram.\n\nReturns a tuple with l being the independent variable coordinate that\ncorresponds to the midpoint of cluster to the left of cluster i if\ni is non-singleton, otherwise the independent coordinate of the leaf\nnode if i is a leaf node.\n\nReturns\n-------\nA tuple (left, w, h, md), where:\n\n  * left is the independent variable coordinate of the center of the\n    the U of the subtree\n\n  * w is the amount of space used for the subtree (in independent\n    variable units)\n\n  * h is the height of the subtree in dependent variable units\n\n  * md is the max(Z[*,2]) for all nodes * below and including\n    the target node.", "id": "f19336:m40"}
{"signature": "def maxdists(Z):", "body": "Z = np.asarray(Z, order='<STR_LIT:c>', dtype=np.double)<EOL>is_valid_linkage(Z, throw=True, name='<STR_LIT>')<EOL>n = Z.shape[<NUM_LIT:0>] + <NUM_LIT:1><EOL>MD = np.zeros((n - <NUM_LIT:1>,))<EOL>[Z] = _copy_arrays_if_base_present([Z])<EOL>_hierarchy.get_max_dist_for_each_cluster(Z, MD, int(n))<EOL>return MD<EOL>", "docstring": "Returns the maximum distance between any non-singleton cluster.\n\nParameters\n----------\nZ : ndarray\n    The hierarchical clustering encoded as a matrix. See\n    ``linkage`` for more information.\n\nReturns\n-------\nmaxdists : ndarray\n    A ``(n-1)`` sized numpy array of doubles; ``MD[i]`` represents\n    the maximum distance between any cluster (including\n    singletons) below and including the node with index i. More\n    specifically, ``MD[i] = Z[Q(i)-n, 2].max()`` where ``Q(i)`` is the\n    set of all node indices below and including node i.", "id": "f19336:m42"}
{"signature": "def maxinconsts(Z, R):", "body": "Z = np.asarray(Z, order='<STR_LIT:c>')<EOL>R = np.asarray(R, order='<STR_LIT:c>')<EOL>is_valid_linkage(Z, throw=True, name='<STR_LIT>')<EOL>is_valid_im(R, throw=True, name='<STR_LIT:R>')<EOL>n = Z.shape[<NUM_LIT:0>] + <NUM_LIT:1><EOL>if Z.shape[<NUM_LIT:0>] != R.shape[<NUM_LIT:0>]:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>MI = np.zeros((n - <NUM_LIT:1>,))<EOL>[Z, R] = _copy_arrays_if_base_present([Z, R])<EOL>_hierarchy.get_max_Rfield_for_each_cluster(Z, R, MI, int(n), <NUM_LIT:3>)<EOL>return MI<EOL>", "docstring": "Returns the maximum inconsistency coefficient for each\nnon-singleton cluster and its descendents.\n\nParameters\n----------\nZ : ndarray\n    The hierarchical clustering encoded as a matrix. See\n    ``linkage`` for more information.\nR : ndarray\n    The inconsistency matrix.\n\nReturns\n-------\nMI : ndarray\n    A monotonic ``(n-1)``-sized numpy array of doubles.", "id": "f19336:m43"}
{"signature": "def pre_order(self, func=(lambda x: x.id)):", "body": "<EOL>n = self.count<EOL>curNode = [None] * (<NUM_LIT:2> * n)<EOL>lvisited = set()<EOL>rvisited = set()<EOL>curNode[<NUM_LIT:0>] = self<EOL>k = <NUM_LIT:0><EOL>preorder = []<EOL>while k >= <NUM_LIT:0>:<EOL><INDENT>nd = curNode[k]<EOL>ndid = nd.id<EOL>if nd.is_leaf():<EOL><INDENT>preorder.append(func(nd))<EOL>k = k - <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>if ndid not in lvisited:<EOL><INDENT>curNode[k + <NUM_LIT:1>] = nd.left<EOL>lvisited.add(ndid)<EOL>k = k + <NUM_LIT:1><EOL><DEDENT>elif ndid not in rvisited:<EOL><INDENT>curNode[k + <NUM_LIT:1>] = nd.right<EOL>rvisited.add(ndid)<EOL>k = k + <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>k = k - <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>return preorder<EOL>", "docstring": "Performs pre-order traversal without recursive function calls.\n\nWhen a leaf node is first encountered, ``func`` is called with\nthe leaf node as its argument, and its result is appended to\nthe list.\n\nFor example, the statement::\n\n   ids = root.pre_order(lambda x: x.id)\n\nreturns a list of the node ids corresponding to the leaf nodes\nof the tree as they appear from left to right.\n\nParameters\n----------\nfunc : function\n    Applied to each leaf ClusterNode object in the pre-order traversal.\n    Given the i'th leaf node in the pre-ordeR traversal ``n[i]``, the\n    result of func(n[i]) is stored in L[i]. If not provided, the index\n    of the original observation to which the node corresponds is used.\n\nReturns\n-------\nL : list\n    The pre-order traversal.", "id": "f19336:c0:m6"}
{"signature": "def weighted(y):", "body": "return linkage(y, method='<STR_LIT>', metric='<STR_LIT>')<EOL>", "docstring": "Performs weighted/WPGMA linkage on the condensed distance matrix.\n\nSee ``linkage`` for more information on the return\nstructure and algorithm.\n\nParameters\n----------\ny : ndarray\n    The upper triangular of the distance matrix. The result of\n    ``pdist`` is returned in this form.\n\nReturns\n-------\nZ : ndarray\n    A linkage matrix containing the hierarchical clustering. See\n    the ``linkage`` function documentation for more information\n    on its structure.\n\nSee Also\n--------\nlinkage : for advanced creation of hierarchical clusterings.", "id": "f19336:m7"}
{"signature": "@classmethod<EOL><INDENT>def from_number(cls, n, min=None):<DEDENT>", "body": "width = number_digits(n) + <NUM_LIT:1><EOL>if n < <NUM_LIT:0>:<EOL><INDENT>width += <NUM_LIT:1><EOL><DEDENT>repeat = <NUM_LIT> // width<EOL>return cls(width, min, repeat=repeat)<EOL>", "docstring": "Given an integer, returns a \"reasonable\" IntFormat instance to represent\n        any number between 0 and n if n > 0, -n and n if n < 0\n\n        Parameters\n        ----------\n        n : int\n            max number one wants to be able to represent\n        min : int\n            minimum number of characters to use for the format\n\n        Returns\n        -------\n        res : IntFormat\n            IntFormat instance with reasonable (see Notes) computed width\n\n        Notes\n        -----\n        Reasonable should be understood as the minimal string length necessary\n        without losing precision. For example, IntFormat.from_number(1) will\n        return an IntFormat instance of width 2, so that any 0 and 1 may be\n        represented as 1-character strings without loss of information.", "id": "f19339:c1:m0"}
{"signature": "@classmethod<EOL><INDENT>def from_data(cls, m, title=\"<STR_LIT>\", key=\"<STR_LIT:0>\", mxtype=None, fmt=None):<DEDENT>", "body": "pointer = m.indptr<EOL>indices = m.indices<EOL>values = m.data<EOL>nrows, ncols = m.shape<EOL>nnon_zeros = m.nnz<EOL>if fmt is None:<EOL><INDENT>pointer_fmt = IntFormat.from_number(np.max(pointer+<NUM_LIT:1>))<EOL>indices_fmt = IntFormat.from_number(np.max(indices+<NUM_LIT:1>))<EOL>if values.dtype.kind in np.typecodes[\"<STR_LIT>\"]:<EOL><INDENT>values_fmt = ExpFormat.from_number(-np.max(np.abs(values)))<EOL><DEDENT>elif values.dtype.kind in np.typecodes[\"<STR_LIT>\"]:<EOL><INDENT>values_fmt = IntFormat.from_number(-np.max(np.abs(values)))<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\" % values.dtype.kind)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\")<EOL><DEDENT>if mxtype is None:<EOL><INDENT>if not np.isrealobj(values):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if values.dtype.kind in np.typecodes[\"<STR_LIT>\"]:<EOL><INDENT>tp = \"<STR_LIT>\"<EOL><DEDENT>elif values.dtype.kind in np.typecodes[\"<STR_LIT>\"]:<EOL><INDENT>tp = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\"<EOL>% values.dtype)<EOL><DEDENT>mxtype = HBMatrixType(tp, \"<STR_LIT>\", \"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>def _nlines(fmt, size):<EOL><INDENT>nlines = size // fmt.repeat<EOL>if nlines * fmt.repeat != size:<EOL><INDENT>nlines += <NUM_LIT:1><EOL><DEDENT>return nlines<EOL><DEDENT>pointer_nlines = _nlines(pointer_fmt, pointer.size)<EOL>indices_nlines = _nlines(indices_fmt, indices.size)<EOL>values_nlines = _nlines(values_fmt, values.size)<EOL>total_nlines = pointer_nlines + indices_nlines + values_nlines<EOL>return cls(title, key,<EOL>total_nlines, pointer_nlines, indices_nlines, values_nlines,<EOL>mxtype, nrows, ncols, nnon_zeros,<EOL>pointer_fmt.fortran_format, indices_fmt.fortran_format,<EOL>values_fmt.fortran_format)<EOL>", "docstring": "Create a HBInfo instance from an existing sparse matrix.\n\n        Parameters\n        ----------\n        m : sparse matrix\n            the HBInfo instance will derive its parameters from m\n        title : str\n            Title to put in the HB header\n        key : str\n            Key\n        mxtype : HBMatrixType\n            type of the input matrix\n        fmt : dict\n            not implemented\n\n        Returns\n        -------\n        hb_info : HBInfo instance", "id": "f19340:c2:m0"}
{"signature": "def _nbytes_full(fmt, nlines):", "body": "return (fmt.repeat * fmt.width + <NUM_LIT:1>) * (nlines - <NUM_LIT:1>)<EOL>", "docstring": "Return the number of bytes to read to get every full lines for the\n    given parsed fortran format.", "id": "f19340:m0"}
{"signature": "@classmethod<EOL><INDENT>def from_file(cls, fid):<DEDENT>", "body": "<EOL>line = fid.readline().strip(\"<STR_LIT:\\n>\")<EOL>if not len(line) > <NUM_LIT>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % line)<EOL><DEDENT>title = line[:<NUM_LIT>]<EOL>key = line[<NUM_LIT>:]<EOL>line = fid.readline().strip(\"<STR_LIT:\\n>\")<EOL>if not len(line.rstrip()) >= <NUM_LIT>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % line)<EOL><DEDENT>total_nlines = _expect_int(line[:<NUM_LIT>])<EOL>pointer_nlines = _expect_int(line[<NUM_LIT>:<NUM_LIT>])<EOL>indices_nlines = _expect_int(line[<NUM_LIT>:<NUM_LIT>])<EOL>values_nlines = _expect_int(line[<NUM_LIT>:<NUM_LIT>])<EOL>rhs_nlines = line[<NUM_LIT>:<NUM_LIT>].strip()<EOL>if rhs_nlines == '<STR_LIT>':<EOL><INDENT>rhs_nlines = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>rhs_nlines = _expect_int(rhs_nlines)<EOL><DEDENT>if not rhs_nlines == <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>line = fid.readline().strip(\"<STR_LIT:\\n>\")<EOL>if not len(line) >= <NUM_LIT>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT:%s>\" % line)<EOL><DEDENT>mxtype_s = line[:<NUM_LIT:3>].upper()<EOL>if not len(mxtype_s) == <NUM_LIT:3>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>mxtype = HBMatrixType.from_fortran(mxtype_s)<EOL>if mxtype.value_type not in [\"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % mxtype)<EOL><DEDENT>if not mxtype.structure == \"<STR_LIT>\":<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % mxtype)<EOL><DEDENT>if not mxtype.storage == \"<STR_LIT>\":<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not line[<NUM_LIT:3>:<NUM_LIT>] == \"<STR_LIT:U+0020>\" * <NUM_LIT:11>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % line)<EOL><DEDENT>nrows = _expect_int(line[<NUM_LIT>:<NUM_LIT>])<EOL>ncols = _expect_int(line[<NUM_LIT>:<NUM_LIT>])<EOL>nnon_zeros = _expect_int(line[<NUM_LIT>:<NUM_LIT>])<EOL>nelementals = _expect_int(line[<NUM_LIT>:<NUM_LIT>])<EOL>if not nelementals == <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>% nelementals)<EOL><DEDENT>line = fid.readline().strip(\"<STR_LIT:\\n>\")<EOL>ct = line.split()<EOL>if not len(ct) == <NUM_LIT:3>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % ct)<EOL><DEDENT>return cls(title, key,<EOL>total_nlines, pointer_nlines, indices_nlines, values_nlines,<EOL>mxtype, nrows, ncols, nnon_zeros,<EOL>ct[<NUM_LIT:0>], ct[<NUM_LIT:1>], ct[<NUM_LIT:2>],<EOL>rhs_nlines, nelementals)<EOL>", "docstring": "Create a HBInfo instance from a file object containg a matrix in the\n        HB format.\n\n        Parameters\n        ----------\n        fid : file-like matrix\n            File or file-like object containing a matrix in the HB format.\n\n        Returns\n        -------\n        hb_info : HBInfo instance", "id": "f19340:c2:m1"}
{"signature": "def __init__(self, file, hb_info=None):", "body": "self._fid = file<EOL>if hb_info is None:<EOL><INDENT>self._hb_info = HBInfo.from_file(file)<EOL><DEDENT>else:<EOL><INDENT>self._hb_info = hb_info<EOL><DEDENT>", "docstring": "Create a HBFile instance.\n\n        Parameters\n        ----------\n        file : file-object\n            StringIO work as well\n        hb_info : HBInfo\n            Should be given as an argument for writing, in which case the file\n            should be writable.", "id": "f19340:c4:m0"}
{"signature": "def mlarr(*args, **kwargs):", "body": "arr = np.array(*args, **kwargs)<EOL>arr.shape = matdims(arr)<EOL>return arr<EOL>", "docstring": "Convenience function to return matlab-compatible 2D array.", "id": "f19344:m0"}
{"signature": "def _check_level(label, expected, actual):", "body": "if SP.issparse(expected):  <EOL><INDENT>assert_(SP.issparse(actual))<EOL>assert_array_almost_equal(actual.todense(),<EOL>expected.todense(),<EOL>err_msg=label,<EOL>decimal=<NUM_LIT:5>)<EOL>return<EOL><DEDENT>assert_(types_compatible(expected, actual),<EOL>\"<STR_LIT>\" %<EOL>(type(expected), type(actual), label))<EOL>if not isinstance(expected,<EOL>(np.void, np.ndarray, MatlabObject)):<EOL><INDENT>assert_equal(expected, actual)<EOL>return<EOL><DEDENT>assert_(expected.shape == actual.shape,<EOL>msg='<STR_LIT>' % (expected.shape,<EOL>actual.shape,<EOL>label))<EOL>ex_dtype = expected.dtype<EOL>if ex_dtype.hasobject:  <EOL><INDENT>if isinstance(expected, MatlabObject):<EOL><INDENT>assert_equal(expected.classname, actual.classname)<EOL><DEDENT>for i, ev in enumerate(expected):<EOL><INDENT>level_label = \"<STR_LIT>\" % (label, i)<EOL>_check_level(level_label, ev, actual[i])<EOL><DEDENT>return<EOL><DEDENT>if ex_dtype.fields:  <EOL><INDENT>for fn in ex_dtype.fields:<EOL><INDENT>level_label = \"<STR_LIT>\" % (label, fn)<EOL>_check_level(level_label,<EOL>expected[fn], actual[fn])<EOL><DEDENT>return<EOL><DEDENT>if ex_dtype.type in (text_type,  <EOL>np.unicode_,<EOL>np.bool_):<EOL><INDENT>assert_equal(actual, expected, err_msg=label)<EOL>return<EOL><DEDENT>assert_array_almost_equal(actual, expected, err_msg=label, decimal=<NUM_LIT:5>)<EOL>", "docstring": "Check one level of a potentially nested array", "id": "f19344:m2"}
{"signature": "def _make_tag(base_dt, val, mdtype, sde=False):", "body": "base_dt = np.dtype(base_dt)<EOL>bo = boc.to_numpy_code(base_dt.byteorder)<EOL>byte_count = base_dt.itemsize<EOL>if not sde:<EOL><INDENT>udt = bo + '<STR_LIT>'<EOL>padding = <NUM_LIT:8> - (byte_count % <NUM_LIT:8>)<EOL>all_dt = [('<STR_LIT>', udt),<EOL>('<STR_LIT>', udt),<EOL>('<STR_LIT>', base_dt)]<EOL>if padding:<EOL><INDENT>all_dt.append(('<STR_LIT>', '<STR_LIT>', padding))<EOL><DEDENT><DEDENT>else:  <EOL><INDENT>udt = bo + '<STR_LIT>'<EOL>padding = <NUM_LIT:4>-byte_count<EOL>if bo == '<STR_LIT:<>':  <EOL><INDENT>all_dt = [('<STR_LIT>', udt),<EOL>('<STR_LIT>', udt),<EOL>('<STR_LIT>', base_dt)]<EOL><DEDENT>else:  <EOL><INDENT>all_dt = [('<STR_LIT>', udt),<EOL>('<STR_LIT>', udt),<EOL>('<STR_LIT>', base_dt)]<EOL><DEDENT>if padding:<EOL><INDENT>all_dt.append(('<STR_LIT>', '<STR_LIT>', padding))<EOL><DEDENT><DEDENT>tag = np.zeros((<NUM_LIT:1>,), dtype=all_dt)<EOL>tag['<STR_LIT>'] = mdtype<EOL>tag['<STR_LIT>'] = byte_count<EOL>tag['<STR_LIT>'] = val<EOL>return tag<EOL>", "docstring": "Makes a simple matlab tag, full or sde", "id": "f19347:m1"}
{"signature": "@docfiller<EOL>def loadmat(file_name, mdict=None, appendmat=True, **kwargs):", "body": "variable_names = kwargs.pop('<STR_LIT>', None)<EOL>MR = mat_reader_factory(file_name, appendmat, **kwargs)<EOL>matfile_dict = MR.get_variables(variable_names)<EOL>if mdict is not None:<EOL><INDENT>mdict.update(matfile_dict)<EOL><DEDENT>else:<EOL><INDENT>mdict = matfile_dict<EOL><DEDENT>if isinstance(file_name, string_types):<EOL><INDENT>MR.mat_stream.close()<EOL><DEDENT>return mdict<EOL>", "docstring": "Load MATLAB file\n\nParameters\n----------\nfile_name : str\n   Name of the mat file (do not need .mat extension if\n   appendmat==True) Can also pass open file-like object.\nm_dict : dict, optional\n    Dictionary in which to insert matfile variables.\nappendmat : bool, optional\n   True to append the .mat extension to the end of the given\n   filename, if not already present.\nbyte_order : str or None, optional\n   None by default, implying byte order guessed from mat\n   file. Otherwise can be one of ('native', '=', 'little', '<',\n   'BIG', '>').\nmat_dtype : bool, optional\n   If True, return arrays in same dtype as would be loaded into\n   MATLAB (instead of the dtype with which they are saved).\nsqueeze_me : bool, optional\n   Whether to squeeze unit matrix dimensions or not.\nchars_as_strings : bool, optional\n   Whether to convert char arrays to string arrays.\nmatlab_compatible : bool, optional\n   Returns matrices as would be loaded by MATLAB (implies\n   squeeze_me=False, chars_as_strings=False, mat_dtype=True,\n   struct_as_record=True).\nstruct_as_record : bool, optional\n   Whether to load MATLAB structs as numpy record arrays, or as\n   old-style numpy arrays with dtype=object.  Setting this flag to\n   False replicates the behavior of scipy version 0.7.x (returning\n   numpy object arrays).  The default setting is True, because it\n   allows easier round-trip load and save of MATLAB files.\nverify_compressed_data_integrity : bool, optional\n    Whether the length of compressed sequences in the MATLAB file\n    should be checked, to ensure that they are not longer than we expect.\n    It is advisable to enable this (the default) because overlong\n    compressed sequences in MATLAB files generally indicate that the\n    files have experienced some sort of corruption.\nvariable_names : None or sequence\n    If None (the default) - read all variables in file. Otherwise\n    `variable_names` should be a sequence of strings, giving names of the\n    matlab variables to read from the file.  The reader will skip any\n    variable with a name not in this sequence, possibly saving some read\n    processing.\n\nReturns\n-------\nmat_dict : dict\n   dictionary with variable names as keys, and loaded matrices as\n   values\n\nNotes\n-----\nv4 (Level 1.0), v6 and v7 to 7.2 matfiles are supported.\n\nYou will need an HDF5 python library to read matlab 7.3 format mat\nfiles.  Because scipy does not supply one, we do not implement the\nHDF5 / 7.3 interface here.", "id": "f19352:m2"}
{"signature": "@docfiller<EOL>def savemat(file_name, mdict,<EOL>appendmat=True,<EOL>format='<STR_LIT:5>',<EOL>long_field_names=False,<EOL>do_compression=False,<EOL>oned_as='<STR_LIT>'):", "body": "file_is_string = isinstance(file_name, string_types)<EOL>if file_is_string:<EOL><INDENT>if appendmat and file_name[-<NUM_LIT:4>:] != \"<STR_LIT>\":<EOL><INDENT>file_name = file_name + \"<STR_LIT>\"<EOL><DEDENT>file_stream = open(file_name, '<STR_LIT:wb>')<EOL><DEDENT>else:<EOL><INDENT>if not hasattr(file_name, '<STR_LIT>'):<EOL><INDENT>raise IOError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>file_stream = file_name<EOL><DEDENT>if format == '<STR_LIT:4>':<EOL><INDENT>if long_field_names:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>MW = MatFile4Writer(file_stream, oned_as)<EOL><DEDENT>elif format == '<STR_LIT:5>':<EOL><INDENT>MW = MatFile5Writer(file_stream,<EOL>do_compression=do_compression,<EOL>unicode_strings=True,<EOL>long_field_names=long_field_names,<EOL>oned_as=oned_as)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>MW.put_variables(mdict)<EOL>if file_is_string:<EOL><INDENT>file_stream.close()<EOL><DEDENT>", "docstring": "Save a dictionary of names and arrays into a MATLAB-style .mat file.\n\nThis saves the array objects in the given dictionary to a MATLAB-\nstyle .mat file.\n\nParameters\n----------\nfile_name : str or file-like object\n    Name of the .mat file (.mat extension not needed if ``appendmat ==\n    True``).\n    Can also pass open file_like object.\nmdict : dict\n    Dictionary from which to save matfile variables.\nappendmat : bool, optional\n    True (the default) to append the .mat extension to the end of the\n    given filename, if not already present.\nformat : {'5', '4'}, string, optional\n    '5' (the default) for MATLAB 5 and up (to 7.2),\n    '4' for MATLAB 4 .mat files\nlong_field_names : bool, optional\n    False (the default) - maximum field name length in a structure is\n    31 characters which is the documented maximum length.\n    True - maximum field name length in a structure is 63 characters\n    which works for MATLAB 7.6+\ndo_compression : bool, optional\n    Whether or not to compress matrices on write.  Default is False.\noned_as : {'row', 'column'}, optional\n    If 'column', write 1-D numpy arrays as column vectors.\n    If 'row', write 1-D numpy arrays as row vectors.\n\nSee also\n--------\nmio4.MatFile4Writer\nmio5.MatFile5Writer", "id": "f19352:m3"}
{"signature": "@docfiller<EOL>def mat_reader_factory(file_name, appendmat=True, **kwargs):", "body": "byte_stream = _open_file(file_name, appendmat)<EOL>mjv, mnv = get_matfile_version(byte_stream)<EOL>if mjv == <NUM_LIT:0>:<EOL><INDENT>return MatFile4Reader(byte_stream, **kwargs)<EOL><DEDENT>elif mjv == <NUM_LIT:1>:<EOL><INDENT>return MatFile5Reader(byte_stream, **kwargs)<EOL><DEDENT>elif mjv == <NUM_LIT:2>:<EOL><INDENT>raise NotImplementedError('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>raise TypeError('<STR_LIT>' % mjv)<EOL><DEDENT>", "docstring": "Create reader for matlab .mat format files\n\n    Parameters\n    ----------\n    %(file_arg)s\n    %(append_arg)s\n    %(load_args)s\n    %(struct_arg)s\n\n    Returns\n    -------\n    matreader : MatFileReader object\n       Initialized instance of MatFileReader class matching the mat file\n       type detected in `filename`.", "id": "f19352:m1"}
{"signature": "def arr_to_2d(arr, oned_as='<STR_LIT>'):", "body": "dims = matdims(arr, oned_as)<EOL>if len(dims) > <NUM_LIT:2>:<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>return arr.reshape(dims)<EOL>", "docstring": "Make ``arr`` exactly two dimensional\n\n    If `arr` has more than 2 dimensions, raise a ValueError\n\n    Parameters\n    ----------\n    arr : array\n    oned_as : {'row', 'column'}\n       Whether to reshape 1D vectors as row vectors or column vectors.\n       See documentation for ``matdims`` for more detail\n\n    Returns\n    -------\n    arr2d : array\n       2D version of the array", "id": "f19357:m0"}
{"signature": "def get_variables(self, variable_names=None):", "body": "if isinstance(variable_names, string_types):<EOL><INDENT>variable_names = [variable_names]<EOL><DEDENT>elif variable_names is not None:<EOL><INDENT>variable_names = list(variable_names)<EOL><DEDENT>self.mat_stream.seek(<NUM_LIT:0>)<EOL>self.initialize_read()<EOL>mdict = {}<EOL>while not self.end_of_stream():<EOL><INDENT>hdr, next_position = self.read_var_header()<EOL>name = asstr(hdr.name)<EOL>if variable_names and name not in variable_names:<EOL><INDENT>self.mat_stream.seek(next_position)<EOL>continue<EOL><DEDENT>mdict[name] = self.read_var_array(hdr)<EOL>self.mat_stream.seek(next_position)<EOL>if variable_names:<EOL><INDENT>variable_names.remove(name)<EOL>if len(variable_names) == <NUM_LIT:0>:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>return mdict<EOL>", "docstring": "get variables from stream as dictionary\n\n        Parameters\n        ----------\n        variable_names : None or str or sequence of str, optional\n            variable name, or sequence of variable names to get from Mat file /\n            file stream.  If None, then get all variables in file", "id": "f19357:c2:m5"}
{"signature": "def read_header(self):", "body": "data = read_dtype(self.mat_stream, self.dtypes['<STR_LIT>'])<EOL>name = self.mat_stream.read(int(data['<STR_LIT>'])).strip(b'<STR_LIT:\\x00>')<EOL>if data['<STR_LIT>'] < <NUM_LIT:0> or data['<STR_LIT>'] > <NUM_LIT>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>M, rest = divmod(data['<STR_LIT>'], <NUM_LIT:1000>)  <EOL>if M not in (<NUM_LIT:0>, <NUM_LIT:1>):<EOL><INDENT>warnings.warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % order_codes[M],<EOL>UserWarning)<EOL><DEDENT>O, rest = divmod(rest, <NUM_LIT:100>)  <EOL>if O != <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>P, rest = divmod(rest, <NUM_LIT:10>)  <EOL>T = rest  <EOL>dims = (data['<STR_LIT>'], data['<STR_LIT>'])<EOL>is_complex = data['<STR_LIT>'] == <NUM_LIT:1><EOL>dtype = self.dtypes[P]<EOL>return VarHeader4(<EOL>name,<EOL>dtype,<EOL>T,<EOL>dims,<EOL>is_complex)<EOL>", "docstring": "Read and return header for variable", "id": "f19357:c1:m1"}
{"signature": "def write(self, arr, name):", "body": "<EOL>if scipy.sparse.issparse(arr):<EOL><INDENT>self.write_sparse(arr, name)<EOL>return<EOL><DEDENT>arr = np.asarray(arr)<EOL>dt = arr.dtype<EOL>if not dt.isnative:<EOL><INDENT>arr = arr.astype(dt.newbyteorder('<STR_LIT:=>'))<EOL><DEDENT>dtt = dt.type<EOL>if dtt is np.object_:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>elif dtt is np.void:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>elif dtt in (np.unicode_, np.string_):<EOL><INDENT>self.write_char(arr, name)<EOL>return<EOL><DEDENT>self.write_numeric(arr, name)<EOL>", "docstring": "Write matrix `arr`, with name `name`\n\n        Parameters\n        ----------\n        arr : array-like\n           array to write\n        name : str\n           name in matlab workspace", "id": "f19357:c3:m4"}
{"signature": "def put_variables(self, mdict, write_header=None):", "body": "<EOL>self._matrix_writer = VarWriter4(self)<EOL>for name, var in mdict.items():<EOL><INDENT>self._matrix_writer.write(var, name)<EOL><DEDENT>", "docstring": "Write variables in `mdict` to stream\n\n        Parameters\n        ----------\n        mdict : mapping\n           mapping with method ``items`` return name, contents pairs\n           where ``name`` which will appeak in the matlab workspace in\n           file load, and ``contents`` is something writeable to a\n           matlab file, such as a numpy array.\n        write_header : {None, True, False}\n           If True, then write the matlab file header before writing the\n           variables.  If None (the default) then write the file header\n           if we are at position 0 in the stream.  By setting False\n           here, and setting the stream position to the end of the file,\n           you can append variables to a matlab file", "id": "f19357:c4:m1"}
{"signature": "def list_variables(self):", "body": "self.mat_stream.seek(<NUM_LIT:0>)<EOL>self.initialize_read()<EOL>vars = []<EOL>while not self.end_of_stream():<EOL><INDENT>hdr, next_position = self.read_var_header()<EOL>name = asstr(hdr.name)<EOL>shape = self._matrix_reader.shape_from_header(hdr)<EOL>info = mclass_info.get(hdr.mclass, '<STR_LIT>')<EOL>vars.append((name, shape, info))<EOL>self.mat_stream.seek(next_position)<EOL><DEDENT>return vars<EOL>", "docstring": "list variables from stream", "id": "f19357:c2:m6"}
{"signature": "def read_var_array(self, header, process=True):", "body": "return self._matrix_reader.array_from_header(header, process)<EOL>", "docstring": "Read array, given `header`\n\n        Parameters\n        ----------\n        header : header object\n           object with fields defining variable header\n        process : {True, False}, optional\n           If True, apply recursive post-processing during loading of array.\n\n        Returns\n        -------\n        arr : array\n           array with post-processing applied or not according to\n           `process`.", "id": "f19357:c2:m4"}
{"signature": "def shape_from_header(self, hdr):", "body": "mclass = hdr.mclass<EOL>if mclass == mxFULL_CLASS:<EOL><INDENT>shape = tuple(map(int, hdr.dims))<EOL><DEDENT>elif mclass == mxCHAR_CLASS:<EOL><INDENT>shape = tuple(map(int, hdr.dims))<EOL>if self.chars_as_strings:<EOL><INDENT>shape = shape[:-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>elif mclass == mxSPARSE_CLASS:<EOL><INDENT>dt = hdr.dtype<EOL>dims = hdr.dims<EOL>if not (len(dims) == <NUM_LIT:2> and dims[<NUM_LIT:0>] >= <NUM_LIT:1> and dims[<NUM_LIT:1>] >= <NUM_LIT:1>):<EOL><INDENT>return ()<EOL><DEDENT>self.mat_stream.seek(dt.itemsize * (dims[<NUM_LIT:0>] - <NUM_LIT:1>), <NUM_LIT:1>)<EOL>rows = np.ndarray(shape=(<NUM_LIT:1>,), dtype=dt,<EOL>buffer=self.mat_stream.read(dt.itemsize))<EOL>self.mat_stream.seek(dt.itemsize * (dims[<NUM_LIT:0>] - <NUM_LIT:1>), <NUM_LIT:1>)<EOL>cols = np.ndarray(shape=(<NUM_LIT:1>,), dtype=dt,<EOL>buffer=self.mat_stream.read(dt.itemsize))<EOL>shape = (int(rows), int(cols))<EOL><DEDENT>else:<EOL><INDENT>raise TypeError('<STR_LIT>' % mclass)<EOL><DEDENT>if self.squeeze_me:<EOL><INDENT>shape = tuple([x for x in shape if x != <NUM_LIT:1>])<EOL><DEDENT>return shape<EOL>", "docstring": "Read the shape of the array described by the header.\n        The file position after this call is unspecified.", "id": "f19357:c1:m7"}
{"signature": "def convert_dtypes(dtype_template, order_code):", "body": "dtypes = dtype_template.copy()<EOL>for k in dtypes:<EOL><INDENT>dtypes[k] = np.dtype(dtypes[k]).newbyteorder(order_code)<EOL><DEDENT>return dtypes<EOL>", "docstring": "Convert dtypes in mapping to given order\n\n    Parameters\n    ----------\n    dtype_template : mapping\n       mapping with values returning numpy dtype from ``np.dtype(val)``\n    order_code : str\n       an order code suitable for using in ``dtype.newbyteorder()``\n\n    Returns\n    -------\n    dtypes : mapping\n       mapping where values have been replaced by\n       ``np.dtype(val).newbyteorder(order_code)``", "id": "f19358:m0"}
{"signature": "def guess_byte_order(self):", "body": "return boc.native_code<EOL>", "docstring": "As we do not know what file type we have, assume native", "id": "f19358:c4:m2"}
{"signature": "def arr_dtype_number(arr, num):", "body": "return np.dtype(arr.dtype.str[:<NUM_LIT:2>] + str(num))<EOL>", "docstring": "Return dtype for given number of items per element", "id": "f19358:m4"}
{"signature": "def put_variables(self, mdict, write_header=None):", "body": "<EOL>if write_header is None:<EOL><INDENT>write_header = self.file_stream.tell() == <NUM_LIT:0><EOL><DEDENT>if write_header:<EOL><INDENT>self.write_file_header()<EOL><DEDENT>self._matrix_writer = VarWriter5(self)<EOL>for name, var in mdict.items():<EOL><INDENT>if name[<NUM_LIT:0>] == '<STR_LIT:_>':<EOL><INDENT>continue<EOL><DEDENT>is_global = name in self.global_vars<EOL>if self.do_compression:<EOL><INDENT>stream = BytesIO()<EOL>self._matrix_writer.file_stream = stream<EOL>self._matrix_writer.write_top(var, asbytes(name), is_global)<EOL>out_str = zlib.compress(stream.getvalue())<EOL>tag = np.empty((), NDT_TAG_FULL)<EOL>tag['<STR_LIT>'] = miCOMPRESSED<EOL>tag['<STR_LIT>'] = len(out_str)<EOL>self.file_stream.write(tag.tostring())<EOL>self.file_stream.write(out_str)<EOL><DEDENT>else:  <EOL><INDENT>self._matrix_writer.write_top(var, asbytes(name), is_global)<EOL><DEDENT><DEDENT>", "docstring": "Write variables in `mdict` to stream\n\n        Parameters\n        ----------\n        mdict : mapping\n           mapping with method ``items`` returns name, contents pairs where\n           ``name`` which will appear in the matlab workspace in file load, and\n           ``contents`` is something writeable to a matlab file, such as a numpy\n           array.\n        write_header : {None, True, False}\n           If True, then write the matlab file header before writing the\n           variables.  If None (the default) then write the file header\n           if we are at position 0 in the stream.  By setting False\n           here, and setting the stream position to the end of the file,\n           you can append variables to a matlab file", "id": "f19359:c2:m2"}
{"signature": "@docfiller<EOL><INDENT>def __init__(self, file_stream,<EOL>do_compression=False,<EOL>unicode_strings=False,<EOL>global_vars=None,<EOL>long_field_names=False,<EOL>oned_as='<STR_LIT>'):<DEDENT>", "body": "self.file_stream = file_stream<EOL>self.do_compression = do_compression<EOL>self.unicode_strings = unicode_strings<EOL>if global_vars:<EOL><INDENT>self.global_vars = global_vars<EOL><DEDENT>else:<EOL><INDENT>self.global_vars = []<EOL><DEDENT>self.long_field_names = long_field_names<EOL>self.oned_as = oned_as<EOL>self._matrix_writer = None<EOL>", "docstring": "Initialize writer for matlab 5 format files\n\n        Parameters\n        ----------\n        %(do_compression)s\n        %(unicode_strings)s\n        global_vars : None or sequence of strings, optional\n            Names of variables to be marked as global for matlab\n        %(long_fields)s\n        %(oned_as)s", "id": "f19359:c2:m0"}
{"signature": "def to_writeable(source):", "body": "if isinstance(source, np.ndarray):<EOL><INDENT>return source<EOL><DEDENT>if source is None:<EOL><INDENT>return None<EOL><DEDENT>is_mapping = (hasattr(source, '<STR_LIT>') and hasattr(source, '<STR_LIT>') and<EOL>hasattr(source, '<STR_LIT>'))<EOL>if not is_mapping and hasattr(source, '<STR_LIT>'):<EOL><INDENT>source = dict((key, value) for key, value in source.__dict__.items()<EOL>if not key.startswith('<STR_LIT:_>'))<EOL>is_mapping = True<EOL><DEDENT>if is_mapping:<EOL><INDENT>dtype = []<EOL>values = []<EOL>for field, value in source.items():<EOL><INDENT>if (isinstance(field, string_types) and<EOL>field[<NUM_LIT:0>] not in '<STR_LIT>'):<EOL><INDENT>dtype.append((field,object))<EOL>values.append(value)<EOL><DEDENT><DEDENT>if dtype:<EOL><INDENT>return np.array([tuple(values)],dtype)<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT><DEDENT>narr = np.asanyarray(source)<EOL>if narr.dtype.type in (np.object, np.object_) andnarr.shape == () and narr == source:<EOL><INDENT>return None<EOL><DEDENT>return narr<EOL>", "docstring": "Convert input object ``source`` to something we can write\n\n    Parameters\n    ----------\n    source : object\n\n    Returns\n    -------\n    arr : ndarray\n\n    Examples\n    --------\n    >>> to_writeable(np.array([1])) # pass through ndarrays\n    array([1])\n    >>> expected = np.array([(1, 2)], dtype=[('a', '|O8'), ('b', '|O8')])\n    >>> np.all(to_writeable({'a':1,'b':2}) == expected)\n    True\n    >>> np.all(to_writeable({'a':1,'b':2, '_c':3}) == expected)\n    True\n    >>> np.all(to_writeable({'a':1,'b':2, 100:3}) == expected)\n    True\n    >>> np.all(to_writeable({'a':1,'b':2, '99':3}) == expected)\n    True\n    >>> class klass(object): pass\n    >>> c = klass\n    >>> c.a = 1\n    >>> c.b = 2\n    >>> np.all(to_writeable({'a':1,'b':2}) == expected)\n    True\n    >>> to_writeable([])\n    array([], dtype=float64)\n    >>> to_writeable(())\n    array([], dtype=float64)\n    >>> to_writeable(None)\n\n    >>> to_writeable('a string').dtype.type == np.str_\n    True\n    >>> to_writeable(1)\n    array(1)\n    >>> to_writeable([1])\n    array([1])\n    >>> to_writeable([1])\n    array([1])\n    >>> to_writeable(object()) # not convertable\n\n    dict keys with legal characters are convertible\n\n    >>> to_writeable({'a':1})['a']\n    array([1], dtype=object)\n\n    but not with illegal characters\n\n    >>> to_writeable({'1':1}) is None\n    True\n    >>> to_writeable({'_a':1}) is None\n    True", "id": "f19359:m1"}
{"signature": "def write_sparse(self, arr):", "body": "A = arr.tocsc()  <EOL>A.sort_indices()     <EOL>is_complex = (A.dtype.kind == '<STR_LIT:c>')<EOL>is_logical = (A.dtype.kind == '<STR_LIT:b>')<EOL>nz = A.nnz<EOL>self.write_header(matdims(arr, self.oned_as),<EOL>mxSPARSE_CLASS,<EOL>is_complex=is_complex,<EOL>is_logical=is_logical,<EOL>nzmax=nz)<EOL>self.write_element(A.indices.astype('<STR_LIT>'))<EOL>self.write_element(A.indptr.astype('<STR_LIT>'))<EOL>self.write_element(A.data.real)<EOL>if is_complex:<EOL><INDENT>self.write_element(A.data.imag)<EOL><DEDENT>", "docstring": "Sparse matrices are 2D", "id": "f19359:c1:m12"}
{"signature": "def write_header(self,<EOL>shape,<EOL>mclass,<EOL>is_complex=False,<EOL>is_logical=False,<EOL>nzmax=<NUM_LIT:0>):", "body": "<EOL>name = self._var_name<EOL>is_global = self._var_is_global<EOL>self._mat_tag_pos = self.file_stream.tell()<EOL>self.write_bytes(self.mat_tag)<EOL>af = np.zeros((), NDT_ARRAY_FLAGS)<EOL>af['<STR_LIT>'] = miUINT32<EOL>af['<STR_LIT>'] = <NUM_LIT:8><EOL>flags = is_complex << <NUM_LIT:3> | is_global << <NUM_LIT:2> | is_logical << <NUM_LIT:1><EOL>af['<STR_LIT>'] = mclass | flags << <NUM_LIT:8><EOL>af['<STR_LIT>'] = nzmax<EOL>self.write_bytes(af)<EOL>self.write_element(np.array(shape, dtype='<STR_LIT>'))<EOL>name = np.asarray(name)<EOL>if name == '<STR_LIT>':  <EOL><INDENT>self.write_smalldata_element(name, miINT8, <NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>self.write_element(name, miINT8)<EOL><DEDENT>self._var_name = '<STR_LIT>'<EOL>self._var_is_global = False<EOL>", "docstring": "Write header for given data options\n        shape : sequence\n           array shape\n        mclass      - mat5 matrix class\n        is_complex  - True if matrix is complex\n        is_logical  - True if matrix is logical\n        nzmax        - max non zero elements for sparse arrays\n\n        We get the name and the global flag from the object, and reset\n        them to defaults after we've used them", "id": "f19359:c1:m6"}
{"signature": "def check_simple(ncfileobj):", "body": "assert_equal(ncfileobj.history, b'<STR_LIT>')<EOL>time = ncfileobj.variables['<STR_LIT:time>']<EOL>assert_equal(time.units, b'<STR_LIT>')<EOL>assert_equal(time.shape, (N_EG_ELS,))<EOL>assert_equal(time[-<NUM_LIT:1>], N_EG_ELS-<NUM_LIT:1>)<EOL>", "docstring": "Example fileobj tests", "id": "f19362:m1"}
{"signature": "def assert_identical(a, b):", "body": "assert_equal(a, b)<EOL>if type(b) is np.str:<EOL><INDENT>assert_equal(type(a), type(b))<EOL><DEDENT>else:<EOL><INDENT>assert_equal(np.asarray(a).dtype.type, np.asarray(b).dtype.type)<EOL><DEDENT>", "docstring": "Assert whether value AND type are the same", "id": "f19365:m1"}
{"signature": "def write(filename, rate, data):", "body": "if hasattr(filename,'<STR_LIT>'):<EOL><INDENT>fid = filename<EOL><DEDENT>else:<EOL><INDENT>fid = open(filename, '<STR_LIT:wb>')<EOL><DEDENT>try:<EOL><INDENT>dkind = data.dtype.kind<EOL>if not (dkind == '<STR_LIT:i>' or dkind == '<STR_LIT:f>' or (dkind == '<STR_LIT:u>' and data.dtype.itemsize == <NUM_LIT:1>)):<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % data.dtype)<EOL><DEDENT>fid.write(b'<STR_LIT>')<EOL>fid.write(b'<STR_LIT>')<EOL>fid.write(b'<STR_LIT>')<EOL>fid.write(b'<STR_LIT>')<EOL>if dkind == '<STR_LIT:f>':<EOL><INDENT>comp = <NUM_LIT:3><EOL><DEDENT>else:<EOL><INDENT>comp = <NUM_LIT:1><EOL><DEDENT>if data.ndim == <NUM_LIT:1>:<EOL><INDENT>noc = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>noc = data.shape[<NUM_LIT:1>]<EOL><DEDENT>bits = data.dtype.itemsize * <NUM_LIT:8><EOL>sbytes = rate*(bits // <NUM_LIT:8>)*noc<EOL>ba = noc * (bits // <NUM_LIT:8>)<EOL>fid.write(struct.pack('<STR_LIT>', <NUM_LIT:16>, comp, noc, rate, sbytes, ba, bits))<EOL>fid.write(b'<STR_LIT:data>')<EOL>fid.write(struct.pack('<STR_LIT>', data.nbytes))<EOL>if data.dtype.byteorder == '<STR_LIT:>>' or (data.dtype.byteorder == '<STR_LIT:=>' and sys.byteorder == '<STR_LIT>'):<EOL><INDENT>data = data.byteswap()<EOL><DEDENT>_array_tofile(fid, data)<EOL>size = fid.tell()<EOL>fid.seek(<NUM_LIT:4>)<EOL>fid.write(struct.pack('<STR_LIT>', size-<NUM_LIT:8>))<EOL><DEDENT>finally:<EOL><INDENT>if not hasattr(filename,'<STR_LIT>'):<EOL><INDENT>fid.close()<EOL><DEDENT>else:<EOL><INDENT>fid.seek(<NUM_LIT:0>)<EOL><DEDENT><DEDENT>", "docstring": "Write a numpy array as a WAV file\n\nParameters\n----------\nfilename : string or open file handle\n    Output wav file\nrate : int\n    The sample rate (in samples/sec).\ndata : ndarray\n    A 1-D or 2-D numpy array of either integer or float data-type.\n\nNotes\n-----\n* The file can be an open file or a filename.\n\n* Writes a simple uncompressed WAV file.\n* The bits-per-sample will be determined by the data-type.\n* To write multiple-channels, use a 2-D array of shape\n  (Nsamples, Nchannels).", "id": "f19366:m5"}
{"signature": "def read_record(self, dtype=None):", "body": "if dtype is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>dtype = np.dtype(dtype)<EOL>firstSize = self._read_size()<EOL>if firstSize % dtype.itemsize != <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>'.format(firstSize, dtype.itemsize))<EOL><DEDENT>data = np.fromfile(self._fp, dtype=dtype, count=firstSize//dtype.itemsize)<EOL>secondSize = self._read_size()<EOL>if firstSize != secondSize:<EOL><INDENT>raise IOError('<STR_LIT>')<EOL><DEDENT>return data<EOL>", "docstring": "Reads a record of a given type from the file.\n\nParameters\n----------\ndtype : data-type\n    Data type specifying the size and endiness of the data.\n\nReturns\n-------\ndata : ndarray\n    A one-dimensional array object.\n\nNotes\n-----\nIf the record contains a multi-dimensional array, calling reshape or\nresize will restructure the array to the correct size.\nSince Fortran multidimensional arrays are stored in column-major format,\nthis may have some non-intuitive consequences. If the variable was\ndeclared as 'INTEGER var(5,4)', for example, var could be read with\n'read_record(dtype=np.integer).reshape( (4,5) )' since Python uses\nrow-major ordering of indices.\n\nOne can transpose to obtain the indices in the same order as in Fortran.\n\nFor records that contain several variables or mixed types (as opposed\nto single scalar or array types), it is possible to specify a dtype\nwith mixed types:\n\n>>> record = f.read_record([('a', '<f4'), ('b', '<i4')])\n>>> record['a']  # access the variable 'a'\n5.6\n\nand if any of the variables are arrays, the shape can be specified as\nthe third item in the relevant tuple:\n\n>>> record = f.read_record([('a', '<f4'), ('b', '<i4', (3,3))])\n\nNumpy also supports a short syntax for this kind of type:\n\n>>> record = f.read_record('<f4,(3,3)<i4')\n>>> record['f0']  # variables are called f0, f1, ...\n5.6\n\n\nSee Also\n--------\nread_reals\nread_ints", "id": "f19367:c0:m3"}
{"signature": "def mmread(source):", "body": "return MMFile().read(source)<EOL>", "docstring": "Reads the contents of a Matrix Market file 'filename' into a matrix.\n\nParameters\n----------\n\nsource : file\n    Matrix Market filename (extensions .mtx, .mtz.gz)\n    or open file object.\n\nReturns\n-------\na:\n    Sparse or full matrix", "id": "f19368:m1"}
{"signature": "@staticmethod<EOL><INDENT>def _open(filespec, mode='<STR_LIT:rb>'):<DEDENT>", "body": "close_it = False<EOL>if isinstance(filespec, string_types):<EOL><INDENT>close_it = True<EOL>if mode[<NUM_LIT:0>] == '<STR_LIT:r>':<EOL><INDENT>if not os.path.isfile(filespec):<EOL><INDENT>if os.path.isfile(filespec+'<STR_LIT>'):<EOL><INDENT>filespec = filespec + '<STR_LIT>'<EOL><DEDENT>elif os.path.isfile(filespec+'<STR_LIT>'):<EOL><INDENT>filespec = filespec + '<STR_LIT>'<EOL><DEDENT>elif os.path.isfile(filespec+'<STR_LIT>'):<EOL><INDENT>filespec = filespec + '<STR_LIT>'<EOL><DEDENT><DEDENT>if filespec.endswith('<STR_LIT>'):<EOL><INDENT>import gzip<EOL>stream = gzip.open(filespec, mode)<EOL><DEDENT>elif filespec.endswith('<STR_LIT>'):<EOL><INDENT>import bz2<EOL>stream = bz2.BZ2File(filespec, '<STR_LIT:rb>')<EOL><DEDENT>else:<EOL><INDENT>stream = open(filespec, mode)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if filespec[-<NUM_LIT:4>:] != '<STR_LIT>':<EOL><INDENT>filespec = filespec + '<STR_LIT>'<EOL><DEDENT>stream = open(filespec, mode)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>stream = filespec<EOL><DEDENT>return stream, close_it<EOL>", "docstring": "Return an open file stream for reading based on source.  If source is\na file name, open it (after trying to find it with mtx and gzipped mtx\nextensions).  Otherwise, just return source.", "id": "f19368:c0:m13"}
{"signature": "def mmwrite(target, a, comment='<STR_LIT>', field=None, precision=None):", "body": "MMFile().write(target, a, comment, field, precision)<EOL>", "docstring": "Writes the sparse or dense array `a` to a Matrix Market formatted file.\n\nParameters\n----------\ntarget : file\n    Matrix Market filename (extension .mtx) or open file object\na : array like\n    Sparse or dense 2D array\ncomment : str, optional\n    comments to be prepended to the Matrix Market file\nfield : None or str, optional\n    Either 'real', 'complex', 'pattern', or 'integer'.\nprecision : None or int, optional\n    Number of digits to display for real or complex values.", "id": "f19368:m2"}
{"signature": "def read_header(ofile):", "body": "i = next(ofile)<EOL>while r_comment.match(i):<EOL><INDENT>i = next(ofile)<EOL><DEDENT>relation = None<EOL>attributes = []<EOL>while not r_datameta.match(i):<EOL><INDENT>m = r_headerline.match(i)<EOL>if m:<EOL><INDENT>isattr = r_attribute.match(i)<EOL>if isattr:<EOL><INDENT>name, type, i = tokenize_attribute(ofile, i)<EOL>attributes.append((name, type))<EOL><DEDENT>else:<EOL><INDENT>isrel = r_relation.match(i)<EOL>if isrel:<EOL><INDENT>relation = isrel.group(<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % i)<EOL><DEDENT>i = next(ofile)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>i = next(ofile)<EOL><DEDENT><DEDENT>return relation, attributes<EOL>", "docstring": "Read the header of the iterable ofile.", "id": "f19372:m11"}
{"signature": "def go_data(ofile):", "body": "return itertools.dropwhile(lambda x: not r_datameta.match(x), ofile)<EOL>", "docstring": "Skip header.\n\n    the first next() call of the returned iterator will be the @data line", "id": "f19372:m7"}
{"signature": "def get_nom_val(atrv):", "body": "r_nominal = re.compile('<STR_LIT>')<EOL>m = r_nominal.match(atrv)<EOL>if m:<EOL><INDENT>return tuple(i.strip() for i in m.group(<NUM_LIT:1>).split('<STR_LIT:U+002C>'))<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Given a string containing a nominal type, returns a tuple of the\n    possible values.\n\n    A nominal type is defined as something framed between braces ({}).\n\n    Parameters\n    ----------\n    atrv : str\n       Nominal type definition\n\n    Returns\n    -------\n    poss_vals : tuple\n       possible values\n\n    Examples\n    --------\n    >>> get_nom_val(\"{floup, bouga, fl, ratata}\")\n    ('floup', 'bouga', 'fl', 'ratata')", "id": "f19372:m5"}
{"signature": "def close(self):", "body": "if not self.fp.closed:<EOL><INDENT>try:<EOL><INDENT>self.flush()<EOL><DEDENT>finally:<EOL><INDENT>self.variables = {}<EOL>if self._mm_buf is not None:<EOL><INDENT>ref = weakref.ref(self._mm_buf)<EOL>self._mm_buf = None<EOL>if ref() is None:<EOL><INDENT>self._mm.close()<EOL><DEDENT>else:<EOL><INDENT>warnings.warn((<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>), category=RuntimeWarning)<EOL><DEDENT><DEDENT>self._mm = None<EOL>self.fp.close()<EOL><DEDENT><DEDENT>", "docstring": "Closes the NetCDF file.", "id": "f19375:c0:m2"}
{"signature": "def createVariable(self, name, type, dimensions):", "body": "shape = tuple([self.dimensions[dim] for dim in dimensions])<EOL>shape_ = tuple([dim or <NUM_LIT:0> for dim in shape])  <EOL>type = dtype(type)<EOL>typecode, size = type.char, type.itemsize<EOL>if (typecode, size) not in REVERSE:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % type)<EOL><DEDENT>data = empty(shape_, dtype=type.newbyteorder(\"<STR_LIT:B>\"))  <EOL>self.variables[name] = netcdf_variable(data, typecode, size, shape, dimensions)<EOL>return self.variables[name]<EOL>", "docstring": "Create an empty variable for the `netcdf_file` object, specifying its data\ntype and the dimensions it uses.\n\nParameters\n----------\nname : str\n    Name of the new variable.\ntype : dtype or str\n    Data type of the variable.\ndimensions : sequence of str\n    List of the dimension names used by the variable, in the desired order.\n\nReturns\n-------\nvariable : netcdf_variable\n    The newly created ``netcdf_variable`` object.\n    This object has also been added to the `netcdf_file` object as well.\n\nSee Also\n--------\ncreateDimension\n\nNotes\n-----\nAny dimensions to be used by the variable should already exist in the\nNetCDF data structure or should be created by `createDimension` prior to\ncreating the NetCDF variable.", "id": "f19375:c0:m6"}
{"signature": "def typecode(self):", "body": "return self._typecode<EOL>", "docstring": "Return the typecode of the variable.\n\nReturns\n-------\ntypecode : char\n    The character typecode of the variable (eg, 'i' for int).", "id": "f19375:c1:m6"}
{"signature": "def assignValue(self, value):", "body": "if not self.data.flags.writeable:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>self.data.itemset(value)<EOL>", "docstring": "Assign a scalar value to a `netcdf_variable` of length one.\n\nParameters\n----------\nvalue : scalar\n    Scalar value (of compatible type) to assign to a length-one netcdf\n    variable. This value will be written to file.\n\nRaises\n------\nValueError\n    If the input is not a scalar, or if the destination is not a length-one\n    netcdf variable.", "id": "f19375:c1:m5"}
{"signature": "def _read_structdesc(f):", "body": "structdesc = {}<EOL>structstart = _read_long(f)<EOL>if structstart != <NUM_LIT:9>:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>structdesc['<STR_LIT:name>'] = _read_string(f)<EOL>predef = _read_long(f)<EOL>structdesc['<STR_LIT>'] = _read_long(f)<EOL>structdesc['<STR_LIT>'] = _read_long(f)<EOL>structdesc['<STR_LIT>'] = predef & <NUM_LIT:1><EOL>structdesc['<STR_LIT>'] = predef & <NUM_LIT:2><EOL>structdesc['<STR_LIT>'] = predef & <NUM_LIT:4><EOL>if not structdesc['<STR_LIT>']:<EOL><INDENT>structdesc['<STR_LIT>'] = []<EOL>for t in range(structdesc['<STR_LIT>']):<EOL><INDENT>structdesc['<STR_LIT>'].append(_read_tagdesc(f))<EOL><DEDENT>for tag in structdesc['<STR_LIT>']:<EOL><INDENT>tag['<STR_LIT:name>'] = _read_string(f)<EOL><DEDENT>structdesc['<STR_LIT>'] = {}<EOL>for tag in structdesc['<STR_LIT>']:<EOL><INDENT>if tag['<STR_LIT>']:<EOL><INDENT>structdesc['<STR_LIT>'][tag['<STR_LIT:name>']] = _read_arraydesc(f)<EOL><DEDENT><DEDENT>structdesc['<STR_LIT>'] = {}<EOL>for tag in structdesc['<STR_LIT>']:<EOL><INDENT>if tag['<STR_LIT>']:<EOL><INDENT>structdesc['<STR_LIT>'][tag['<STR_LIT:name>']] = _read_structdesc(f)<EOL><DEDENT><DEDENT>if structdesc['<STR_LIT>'] or structdesc['<STR_LIT>']:<EOL><INDENT>structdesc['<STR_LIT>'] = _read_string(f)<EOL>structdesc['<STR_LIT>'] = _read_long(f)<EOL>structdesc['<STR_LIT>'] = []<EOL>for s in range(structdesc['<STR_LIT>']):<EOL><INDENT>structdesc['<STR_LIT>'].append(_read_string(f))<EOL><DEDENT>structdesc['<STR_LIT>'] = []<EOL>for s in range(structdesc['<STR_LIT>']):<EOL><INDENT>structdesc['<STR_LIT>'].append(_read_structdesc(f))<EOL><DEDENT><DEDENT>STRUCT_DICT[structdesc['<STR_LIT:name>']] = structdesc<EOL><DEDENT>else:<EOL><INDENT>if not structdesc['<STR_LIT:name>'] in STRUCT_DICT:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>structdesc = STRUCT_DICT[structdesc['<STR_LIT:name>']]<EOL><DEDENT>return structdesc<EOL>", "docstring": "Function to read in a structure descriptor", "id": "f19376:m21"}
{"signature": "def _read_array(f, typecode, array_desc):", "body": "if typecode in [<NUM_LIT:1>, <NUM_LIT:3>, <NUM_LIT:4>, <NUM_LIT:5>, <NUM_LIT:6>, <NUM_LIT:9>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT:15>]:<EOL><INDENT>if typecode == <NUM_LIT:1>:<EOL><INDENT>nbytes = _read_int32(f)<EOL>if nbytes != array_desc['<STR_LIT>']:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>array = np.fromstring(f.read(array_desc['<STR_LIT>']),<EOL>dtype=DTYPE_DICT[typecode])<EOL><DEDENT>elif typecode in [<NUM_LIT:2>, <NUM_LIT:12>]:<EOL><INDENT>array = np.fromstring(f.read(array_desc['<STR_LIT>']*<NUM_LIT:2>),<EOL>dtype=DTYPE_DICT[typecode])[<NUM_LIT:1>::<NUM_LIT:2>]<EOL><DEDENT>else:<EOL><INDENT>array = []<EOL>for i in range(array_desc['<STR_LIT>']):<EOL><INDENT>dtype = typecode<EOL>data = _read_data(f, dtype)<EOL>array.append(data)<EOL><DEDENT>array = np.array(array, dtype=np.object_)<EOL><DEDENT>if array_desc['<STR_LIT>'] > <NUM_LIT:1>:<EOL><INDENT>dims = array_desc['<STR_LIT>'][:int(array_desc['<STR_LIT>'])]<EOL>dims.reverse()<EOL>array = array.reshape(dims)<EOL><DEDENT>_align_32(f)<EOL>return array<EOL>", "docstring": "Read an array of type `typecode`, with the array descriptor given as\n`array_desc`.", "id": "f19376:m17"}
{"signature": "def _read_long(f):", "body": "return np.int32(struct.unpack('<STR_LIT>', f.read(<NUM_LIT:4>))[<NUM_LIT:0>])<EOL>", "docstring": "Read a signed 32-bit integer", "id": "f19376:m4"}
{"signature": "def _read_string(f):", "body": "length = _read_long(f)<EOL>if length > <NUM_LIT:0>:<EOL><INDENT>chars = _read_bytes(f, length)<EOL>_align_32(f)<EOL>chars = asstr(chars)<EOL><DEDENT>else:<EOL><INDENT>chars = '<STR_LIT>'<EOL><DEDENT>return chars<EOL>", "docstring": "Read a string", "id": "f19376:m13"}
{"signature": "def _read_uint16(f):", "body": "return np.uint16(struct.unpack('<STR_LIT>', f.read(<NUM_LIT:4>)[<NUM_LIT:2>:<NUM_LIT:4>])[<NUM_LIT:0>])<EOL>", "docstring": "Read an unsigned 16-bit integer", "id": "f19376:m8"}
{"signature": "def _read_byte(f):", "body": "return np.uint8(struct.unpack('<STR_LIT>', f.read(<NUM_LIT:4>)[:<NUM_LIT:1>])[<NUM_LIT:0>])<EOL>", "docstring": "Read a single byte", "id": "f19376:m3"}
{"signature": "def _read_float32(f):", "body": "return np.float32(struct.unpack('<STR_LIT>', f.read(<NUM_LIT:4>))[<NUM_LIT:0>])<EOL>", "docstring": "Read a 32-bit float", "id": "f19376:m11"}
{"signature": "def _read_typedesc(f):", "body": "typedesc = {}<EOL>typedesc['<STR_LIT>'] = _read_long(f)<EOL>typedesc['<STR_LIT>'] = _read_long(f)<EOL>if typedesc['<STR_LIT>'] & <NUM_LIT:2> == <NUM_LIT:2>:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>typedesc['<STR_LIT>'] = typedesc['<STR_LIT>'] & <NUM_LIT:4> == <NUM_LIT:4><EOL>typedesc['<STR_LIT>'] = typedesc['<STR_LIT>'] & <NUM_LIT:32> == <NUM_LIT:32><EOL>if typedesc['<STR_LIT>']:<EOL><INDENT>typedesc['<STR_LIT>'] = _read_arraydesc(f)<EOL>typedesc['<STR_LIT>'] = _read_structdesc(f)<EOL><DEDENT>elif typedesc['<STR_LIT>']:<EOL><INDENT>typedesc['<STR_LIT>'] = _read_arraydesc(f)<EOL><DEDENT>return typedesc<EOL>", "docstring": "Function to read in a type descriptor", "id": "f19376:m19"}
{"signature": "def _read_arraydesc(f):", "body": "arraydesc = {}<EOL>arraydesc['<STR_LIT>'] = _read_long(f)<EOL>if arraydesc['<STR_LIT>'] == <NUM_LIT:8>:<EOL><INDENT>_skip_bytes(f, <NUM_LIT:4>)<EOL>arraydesc['<STR_LIT>'] = _read_long(f)<EOL>arraydesc['<STR_LIT>'] = _read_long(f)<EOL>arraydesc['<STR_LIT>'] = _read_long(f)<EOL>_skip_bytes(f, <NUM_LIT:8>)<EOL>arraydesc['<STR_LIT>'] = _read_long(f)<EOL>arraydesc['<STR_LIT>'] = []<EOL>for d in range(arraydesc['<STR_LIT>']):<EOL><INDENT>arraydesc['<STR_LIT>'].append(_read_long(f))<EOL><DEDENT><DEDENT>elif arraydesc['<STR_LIT>'] == <NUM_LIT>:<EOL><INDENT>warnings.warn(\"<STR_LIT>\")<EOL>_skip_bytes(f, <NUM_LIT:8>)<EOL>arraydesc['<STR_LIT>'] = _read_uint64(f)<EOL>arraydesc['<STR_LIT>'] = _read_uint64(f)<EOL>arraydesc['<STR_LIT>'] = _read_long(f)<EOL>_skip_bytes(f, <NUM_LIT:8>)<EOL>arraydesc['<STR_LIT>'] = <NUM_LIT:8><EOL>arraydesc['<STR_LIT>'] = []<EOL>for d in range(arraydesc['<STR_LIT>']):<EOL><INDENT>v = _read_long(f)<EOL>if v != <NUM_LIT:0>:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>arraydesc['<STR_LIT>'].append(_read_long(f))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise Exception(\"<STR_LIT>\" % arraydesc['<STR_LIT>'])<EOL><DEDENT>return arraydesc<EOL>", "docstring": "Function to read in an array descriptor", "id": "f19376:m20"}
{"signature": "def central_diff_weights(Np, ndiv=<NUM_LIT:1>):", "body": "if Np < ndiv + <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if Np % <NUM_LIT:2> == <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>from scipy import linalg<EOL>ho = Np >> <NUM_LIT:1><EOL>x = arange(-ho,ho+<NUM_LIT:1.0>)<EOL>x = x[:,newaxis]<EOL>X = x**<NUM_LIT:0.0><EOL>for k in range(<NUM_LIT:1>,Np):<EOL><INDENT>X = hstack([X,x**k])<EOL><DEDENT>w = product(arange(<NUM_LIT:1>,ndiv+<NUM_LIT:1>),axis=<NUM_LIT:0>)*linalg.inv(X)[ndiv]<EOL>return w<EOL>", "docstring": "Return weights for an Np-point central derivative.\n\nAssumes equally-spaced function points.\n\nIf weights are in the vector w, then\nderivative is w[0] * f(x-ho*dx) + ... + w[-1] * f(x+h0*dx)\n\nParameters\n----------\nNp : int\n    Number of points for the central derivative.\nndiv : int, optional\n    Number of divisions.  Default is 1.\n\nNotes\n-----\nCan be inaccurate for large number of points.", "id": "f19381:m1"}
{"signature": "def ascent():", "body": "import pickle<EOL>import os<EOL>fname = os.path.join(os.path.dirname(__file__),'<STR_LIT>')<EOL>with open(fname, '<STR_LIT:rb>') as f:<EOL><INDENT>ascent = array(pickle.load(f))<EOL><DEDENT>return ascent<EOL>", "docstring": "Get an 8-bit grayscale bit-depth, 512 x 512 derived image for easy use in demos\n\nThe image is derived from accent-to-the-top.jpg at\nhttp://www.public-domain-image.com/people-public-domain-images-pictures/\n\nParameters\n----------\nNone\n\nReturns\n-------\nascent : ndarray\n   convenient image to use for testing and demonstration\n\nExamples\n--------\n>>> import scipy.misc\n>>> ascent = scipy.misc.ascent()\n>>> ascent.shape\n(512, 512)\n>>> ascent.max()\n255\n\n>>> import matplotlib.pyplot as plt\n>>> plt.gray()\n>>> plt.imshow(ascent)\n>>> plt.show()", "id": "f19381:m5"}
{"signature": "def face(gray=False):", "body": "import bz2<EOL>import os<EOL>with open(os.path.join(os.path.dirname(__file__), '<STR_LIT>'), '<STR_LIT:rb>') as f:<EOL><INDENT>rawdata = f.read()<EOL><DEDENT>data = bz2.decompress(rawdata)<EOL>face = fromstring(data, dtype='<STR_LIT>')<EOL>face.shape = (<NUM_LIT>, <NUM_LIT>, <NUM_LIT:3>)<EOL>if gray is True:<EOL><INDENT>face = (<NUM_LIT> * face[:,:,<NUM_LIT:0>] + <NUM_LIT> * face[:,:,<NUM_LIT:1>] + <NUM_LIT> * face[:,:,<NUM_LIT:2>]).astype('<STR_LIT>')<EOL><DEDENT>return face<EOL>", "docstring": "Get a 1024 x 768, color image of a raccoon face.\n\nraccoon-procyon-lotor.jpg at http://www.public-domain-image.com\n\nParameters\n----------\ngray : bool, optional\n    If True then return color image, otherwise return an 8-bit gray-scale\n\nReturns\n-------\nface : ndarray\n    image of a racoon face\n\nExamples\n--------\n>>> import scipy.misc\n>>> face = scipy.misc.face()\n>>> face.shape\n(768, 1024, 3)\n>>> face.max()\n230\n>>> face.dtype\ndtype('uint8')\n\n>>> import matplotlib.pyplot as plt\n>>> plt.gray()\n>>> plt.imshow(face)\n>>> plt.show()", "id": "f19381:m6"}
{"signature": "def docformat(docstring, docdict=None):", "body": "if not docstring:<EOL><INDENT>return docstring<EOL><DEDENT>if docdict is None:<EOL><INDENT>docdict = {}<EOL><DEDENT>if not docdict:<EOL><INDENT>return docstring<EOL><DEDENT>lines = docstring.expandtabs().splitlines()<EOL>if len(lines) < <NUM_LIT:2>:<EOL><INDENT>icount = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>icount = indentcount_lines(lines[<NUM_LIT:1>:])<EOL><DEDENT>indent = '<STR_LIT:U+0020>' * icount<EOL>indented = {}<EOL>for name, dstr in docdict.items():<EOL><INDENT>lines = dstr.expandtabs().splitlines()<EOL>try:<EOL><INDENT>newlines = [lines[<NUM_LIT:0>]]<EOL>for line in lines[<NUM_LIT:1>:]:<EOL><INDENT>newlines.append(indent+line)<EOL><DEDENT>indented[name] = '<STR_LIT:\\n>'.join(newlines)<EOL><DEDENT>except IndexError:<EOL><INDENT>indented[name] = dstr<EOL><DEDENT><DEDENT>return docstring % indented<EOL>", "docstring": "Fill a function docstring from variables in dictionary\n\n    Adapt the indent of the inserted docs\n\n    Parameters\n    ----------\n    docstring : string\n        docstring from function, possibly with dict formatting strings\n    docdict : dict\n        dictionary with keys that match the dict formatting strings\n        and values that are docstring fragments to be inserted.  The\n        indentation of the inserted docstrings is set to match the\n        minimum indentation of the ``docstring`` by adding this\n        indentation to all lines of the inserted string, except the\n        first\n\n    Returns\n    -------\n    outstring : string\n        string with requested ``docdict`` strings inserted\n\n    Examples\n    --------\n    >>> docformat(' Test string with %(value)s', {'value':'inserted value'})\n    ' Test string with inserted value'\n    >>> docstring = 'First line\\\\n    Second line\\\\n    %(value)s'\n    >>> inserted_string = \"indented\\\\nstring\"\n    >>> docdict = {'value': inserted_string}\n    >>> docformat(docstring, docdict)\n    'First line\\\\n    Second line\\\\n    indented\\\\n    string'", "id": "f19384:m0"}
{"signature": "def inherit_docstring_from(cls):", "body": "def _doc(func):<EOL><INDENT>cls_docstring = getattr(cls, func.__name__).__doc__<EOL>func_docstring = func.__doc__<EOL>if func_docstring is None:<EOL><INDENT>func.__doc__ = cls_docstring<EOL><DEDENT>else:<EOL><INDENT>new_docstring = func_docstring % dict(super=cls_docstring)<EOL>func.__doc__ = new_docstring<EOL><DEDENT>return func<EOL><DEDENT>return _doc<EOL>", "docstring": "This decorator modifies the decorated function's docstring by\nreplacing occurrences of '%(super)s' with the docstring of the\nmethod of the same name from the class `cls`.\n\nIf the decorated method has no docstring, it is simply given the\ndocstring of `cls`s method.\n\nParameters\n----------\ncls : Python class or instance\n    A class with a method with the same name as the decorated method.\n    The docstring of the method in this class replaces '%(super)s' in the\n    docstring of the decorated method.\n\nReturns\n-------\nf : function\n    The decorator function that modifies the __doc__ attribute\n    of its argument.\n\nExamples\n--------\nIn the following, the docstring for Bar.func created using the\ndocstring of `Foo.func`.\n\n>>> class Foo(object):\n...     def func(self):\n...         '''Do something useful.'''\n...         return\n...\n>>> class Bar(Foo):\n...     @inherit_docstring_from(Foo)\n...     def func(self):\n...         '''%(super)s\n...         Do it fast.\n...         '''\n...         return\n...\n>>> b = Bar()\n>>> b.func.__doc__\n'Do something useful.\\n        Do it fast.\\n        '", "id": "f19384:m1"}
{"signature": "def fmin_l_bfgs_b(func, x0, fprime=None, args=(),<EOL>approx_grad=<NUM_LIT:0>,<EOL>bounds=None, m=<NUM_LIT:10>, factr=<NUM_LIT>, pgtol=<NUM_LIT>,<EOL>epsilon=<NUM_LIT>,<EOL>iprint=-<NUM_LIT:1>, maxfun=<NUM_LIT>, maxiter=<NUM_LIT>, disp=None,<EOL>callback=None):", "body": "<EOL>if approx_grad:<EOL><INDENT>fun = func<EOL>jac = None<EOL><DEDENT>elif fprime is None:<EOL><INDENT>fun = MemoizeJac(func)<EOL>jac = fun.derivative<EOL><DEDENT>else:<EOL><INDENT>fun = func<EOL>jac = fprime<EOL><DEDENT>if disp is None:<EOL><INDENT>disp = iprint<EOL><DEDENT>opts = {'<STR_LIT>': disp,<EOL>'<STR_LIT>': iprint,<EOL>'<STR_LIT>': m,<EOL>'<STR_LIT>': factr * np.finfo(float).eps,<EOL>'<STR_LIT>': pgtol,<EOL>'<STR_LIT>': epsilon,<EOL>'<STR_LIT>': maxfun,<EOL>'<STR_LIT>': maxiter,<EOL>'<STR_LIT>': callback}<EOL>res = _minimize_lbfgsb(fun, x0, args=args, jac=jac, bounds=bounds,<EOL>**opts)<EOL>d = {'<STR_LIT>': res['<STR_LIT>'],<EOL>'<STR_LIT>': res['<STR_LIT:message>'],<EOL>'<STR_LIT>': res['<STR_LIT>'],<EOL>'<STR_LIT>': res['<STR_LIT>'],<EOL>'<STR_LIT>': res['<STR_LIT:status>']}<EOL>f = res['<STR_LIT>']<EOL>x = res['<STR_LIT:x>']<EOL>return x, f, d<EOL>", "docstring": "Minimize a function func using the L-BFGS-B algorithm.\n\nParameters\n----------\nfunc : callable f(x,*args)\n    Function to minimise.\nx0 : ndarray\n    Initial guess.\nfprime : callable fprime(x,*args)\n    The gradient of `func`.  If None, then `func` returns the function\n    value and the gradient (``f, g = func(x, *args)``), unless\n    `approx_grad` is True in which case `func` returns only ``f``.\nargs : sequence\n    Arguments to pass to `func` and `fprime`.\napprox_grad : bool\n    Whether to approximate the gradient numerically (in which case\n    `func` returns only the function value).\nbounds : list\n    ``(min, max)`` pairs for each element in ``x``, defining\n    the bounds on that parameter. Use None for one of ``min`` or\n    ``max`` when there is no bound in that direction.\nm : int\n    The maximum number of variable metric corrections\n    used to define the limited memory matrix. (The limited memory BFGS\n    method does not store the full hessian but uses this many terms in an\n    approximation to it.)\nfactr : float\n    The iteration stops when\n    ``(f^k - f^{k+1})/max{|f^k|,|f^{k+1}|,1} <= factr * eps``,\n    where ``eps`` is the machine precision, which is automatically\n    generated by the code. Typical values for `factr` are: 1e12 for\n    low accuracy; 1e7 for moderate accuracy; 10.0 for extremely\n    high accuracy.\npgtol : float\n    The iteration will stop when\n    ``max{|proj g_i | i = 1, ..., n} <= pgtol``\n    where ``pg_i`` is the i-th component of the projected gradient.\nepsilon : float\n    Step size used when `approx_grad` is True, for numerically\n    calculating the gradient\niprint : int\n    Controls the frequency of output. ``iprint < 0`` means no output;\n    ``iprint == 0`` means write messages to stdout; ``iprint > 1`` in\n    addition means write logging information to a file named\n    ``iterate.dat`` in the current working directory.\ndisp : int, optional\n    If zero, then no output.  If a positive number, then this over-rides\n    `iprint` (i.e., `iprint` gets the value of `disp`).\nmaxfun : int\n    Maximum number of function evaluations.\nmaxiter : int\n    Maximum number of iterations.\ncallback : callable, optional\n    Called after each iteration, as ``callback(xk)``, where ``xk`` is the\n    current parameter vector.\n\nReturns\n-------\nx : array_like\n    Estimated position of the minimum.\nf : float\n    Value of `func` at the minimum.\nd : dict\n    Information dictionary.\n\n    * d['warnflag'] is\n\n      - 0 if converged,\n      - 1 if too many function evaluations or too many iterations,\n      - 2 if stopped for another reason, given in d['task']\n\n    * d['grad'] is the gradient at the minimum (should be 0 ish)\n    * d['funcalls'] is the number of function calls made.\n    * d['nit'] is the number of iterations.\n\nSee also\n--------\nminimize: Interface to minimization algorithms for multivariate\n    functions. See the 'L-BFGS-B' `method` in particular.\n\nNotes\n-----\nLicense of L-BFGS-B (FORTRAN code):\n\nThe version included here (in fortran code) is 3.0\n(released April 25, 2011).  It was written by Ciyou Zhu, Richard Byrd,\nand Jorge Nocedal <nocedal@ece.nwu.edu>. It carries the following\ncondition for use:\n\nThis software is freely available, but we expect that all publications\ndescribing work using this software, or all commercial products using it,\nquote at least one of the references given below. This software is released\nunder the BSD License.\n\nReferences\n----------\n* R. H. Byrd, P. Lu and J. Nocedal. A Limited Memory Algorithm for Bound\n  Constrained Optimization, (1995), SIAM Journal on Scientific and\n  Statistical Computing, 16, 5, pp. 1190-1208.\n* C. Zhu, R. H. Byrd and J. Nocedal. L-BFGS-B: Algorithm 778: L-BFGS-B,\n  FORTRAN routines for large scale bound constrained optimization (1997),\n  ACM Transactions on Mathematical Software, 23, 4, pp. 550 - 560.\n* J.L. Morales and J. Nocedal. L-BFGS-B: Remark on Algorithm 778: L-BFGS-B,\n  FORTRAN routines for large scale bound constrained optimization (2011),\n  ACM Transactions on Mathematical Software, 38, 1.", "id": "f19385:m0"}
{"signature": "def fprime_ieqcon(self, x, sign=<NUM_LIT:1.0>):", "body": "return np.array([[<NUM_LIT:1>, -<NUM_LIT:1>]])<EOL>", "docstring": "Inequality constraint, derivative", "id": "f19388:c1:m9"}
{"signature": "def f_eqcon(self, x, sign=<NUM_LIT:1.0>):", "body": "return np.array([x[<NUM_LIT:0>] - x[<NUM_LIT:1>]])<EOL>", "docstring": "Equality constraint", "id": "f19388:c1:m4"}
{"signature": "def f_ieqcon2(self, x):", "body": "return np.asarray(x)<EOL>", "docstring": "Vector inequality constraint", "id": "f19388:c1:m10"}
{"signature": "def fprime_eqcon(self, x, sign=<NUM_LIT:1.0>):", "body": "return np.array([[<NUM_LIT:1>, -<NUM_LIT:1>]])<EOL>", "docstring": "Equality constraint, derivative", "id": "f19388:c1:m5"}
{"signature": "def f_eqcon_scalar(self, x, sign=<NUM_LIT:1.0>):", "body": "return self.f_eqcon(x, sign)[<NUM_LIT:0>]<EOL>", "docstring": "Scalar equality constraint", "id": "f19388:c1:m6"}
{"signature": "def lpgen_2d(m,n):", "body": "np.random.seed(<NUM_LIT:0>)<EOL>c = - np.random.exponential(size=(m,n))<EOL>Arow = np.zeros((m,m*n))<EOL>brow = np.zeros(m)<EOL>for j in range(m):<EOL><INDENT>j1 = j + <NUM_LIT:1><EOL>Arow[j,j*n:j1*n] = <NUM_LIT:1><EOL>brow[j] = n/m<EOL><DEDENT>Acol = np.zeros((n,m*n))<EOL>bcol = np.zeros(n)<EOL>for j in range(n):<EOL><INDENT>j1 = j + <NUM_LIT:1><EOL>Acol[j,j::n] = <NUM_LIT:1><EOL>bcol[j] = <NUM_LIT:1><EOL><DEDENT>A = np.vstack((Arow,Acol))<EOL>b = np.hstack((brow,bcol))<EOL>return A, b, c.ravel()<EOL>", "docstring": "-> A b c LP test: m*n vars, m+n constraints\n        row sums == n/m, col sums == 1\n        https://gist.github.com/denis-bz/8647461", "id": "f19392:m0"}
{"signature": "def get_boundaries_intersections(self, z, d, trust_radius):", "body": "a = np.dot(d, d)<EOL>b = <NUM_LIT:2> * np.dot(z, d)<EOL>c = np.dot(z, z) - trust_radius**<NUM_LIT:2><EOL>sqrt_discriminant = math.sqrt(b*b - <NUM_LIT:4>*a*c)<EOL>ta = (-b - sqrt_discriminant) / (<NUM_LIT:2>*a)<EOL>tb = (-b + sqrt_discriminant) / (<NUM_LIT:2>*a)<EOL>return ta, tb<EOL>", "docstring": "Solve the scalar quadratic equation ||z + t d|| == trust_radius.\nThis is like a line-sphere intersection.\nReturn the two values of t, sorted from low to high.", "id": "f19403:c0:m7"}
{"signature": "@property<EOL><INDENT>def jac_mag(self):<DEDENT>", "body": "if self._g_mag is None:<EOL><INDENT>self._g_mag = scipy.linalg.norm(self.jac)<EOL><DEDENT>return self._g_mag<EOL>", "docstring": "Magniture of jacobian of objective function at current iteration.", "id": "f19403:c0:m6"}
{"signature": "@property<EOL><INDENT>def fun(self):<DEDENT>", "body": "if self._f is None:<EOL><INDENT>self._f = self._fun(self._x)<EOL><DEDENT>return self._f<EOL>", "docstring": "Value of objective function at current iteration.", "id": "f19403:c0:m2"}
{"signature": "def matvec(self, v):", "body": "if self.collapsed is not None:<EOL><INDENT>return np.dot(self.collapsed, v)<EOL><DEDENT>return LowRankMatrix._matvec(v, self.alpha, self.cs, self.ds)<EOL>", "docstring": "Evaluate w = M v", "id": "f19404:c5:m3"}
{"signature": "def nonlin_solve(F, x0, jacobian='<STR_LIT>', iter=None, verbose=False,<EOL>maxiter=None, f_tol=None, f_rtol=None, x_tol=None, x_rtol=None,<EOL>tol_norm=None, line_search='<STR_LIT>', callback=None,<EOL>full_output=False, raise_exception=True):", "body": "condition = TerminationCondition(f_tol=f_tol, f_rtol=f_rtol,<EOL>x_tol=x_tol, x_rtol=x_rtol,<EOL>iter=iter, norm=tol_norm)<EOL>x0 = _as_inexact(x0)<EOL>func = lambda z: _as_inexact(F(_array_like(z, x0))).flatten()<EOL>x = x0.flatten()<EOL>dx = np.inf<EOL>Fx = func(x)<EOL>Fx_norm = norm(Fx)<EOL>jacobian = asjacobian(jacobian)<EOL>jacobian.setup(x.copy(), Fx, func)<EOL>if maxiter is None:<EOL><INDENT>if iter is not None:<EOL><INDENT>maxiter = iter + <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>maxiter = <NUM_LIT:100>*(x.size+<NUM_LIT:1>)<EOL><DEDENT><DEDENT>if line_search is True:<EOL><INDENT>line_search = '<STR_LIT>'<EOL><DEDENT>elif line_search is False:<EOL><INDENT>line_search = None<EOL><DEDENT>if line_search not in (None, '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>gamma = <NUM_LIT><EOL>eta_max = <NUM_LIT><EOL>eta_treshold = <NUM_LIT:0.1><EOL>eta = <NUM_LIT><EOL>for n in xrange(maxiter):<EOL><INDENT>status = condition.check(Fx, x, dx)<EOL>if status:<EOL><INDENT>break<EOL><DEDENT>tol = min(eta, eta*Fx_norm)<EOL>dx = -jacobian.solve(Fx, tol=tol)<EOL>if norm(dx) == <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>if line_search:<EOL><INDENT>s, x, Fx, Fx_norm_new = _nonlin_line_search(func, x, Fx, dx,<EOL>line_search)<EOL><DEDENT>else:<EOL><INDENT>s = <NUM_LIT:1.0><EOL>x = x + dx<EOL>Fx = func(x)<EOL>Fx_norm_new = norm(Fx)<EOL><DEDENT>jacobian.update(x.copy(), Fx)<EOL>if callback:<EOL><INDENT>callback(x, Fx)<EOL><DEDENT>eta_A = gamma * Fx_norm_new**<NUM_LIT:2> / Fx_norm**<NUM_LIT:2><EOL>if gamma * eta**<NUM_LIT:2> < eta_treshold:<EOL><INDENT>eta = min(eta_max, eta_A)<EOL><DEDENT>else:<EOL><INDENT>eta = min(eta_max, max(eta_A, gamma*eta**<NUM_LIT:2>))<EOL><DEDENT>Fx_norm = Fx_norm_new<EOL>if verbose:<EOL><INDENT>sys.stdout.write(\"<STR_LIT>\" % (<EOL>n, norm(Fx), s, eta))<EOL>sys.stdout.flush()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if raise_exception:<EOL><INDENT>raise NoConvergence(_array_like(x, x0))<EOL><DEDENT>else:<EOL><INDENT>status = <NUM_LIT:2><EOL><DEDENT><DEDENT>if full_output:<EOL><INDENT>info = {'<STR_LIT>': condition.iteration,<EOL>'<STR_LIT>': Fx,<EOL>'<STR_LIT:status>': status,<EOL>'<STR_LIT:success>': status == <NUM_LIT:1>,<EOL>'<STR_LIT:message>': {<NUM_LIT:1>: '<STR_LIT>'<EOL>'<STR_LIT>',<EOL><NUM_LIT:2>: '<STR_LIT>'<EOL>'<STR_LIT>'<EOL>}[status]<EOL>}<EOL>return _array_like(x, x0), info<EOL><DEDENT>else:<EOL><INDENT>return _array_like(x, x0)<EOL><DEDENT>", "docstring": "Find a root of a function, in a way suitable for large-scale problems.\n\nParameters\n----------\n%(params_basic)s\njacobian : Jacobian\n    A Jacobian approximation: `Jacobian` object or something that\n    `asjacobian` can transform to one. Alternatively, a string specifying\n    which of the builtin Jacobian approximations to use:\n\n        krylov, broyden1, broyden2, anderson\n        diagbroyden, linearmixing, excitingmixing\n\n%(params_extra)s\nfull_output : bool\n    If true, returns a dictionary `info` containing convergence\n    information.\nraise_exception : bool\n    If True, a `NoConvergence` exception is raise if no solution is found.\n\nSee Also\n--------\nasjacobian, Jacobian\n\nNotes\n-----\nThis algorithm implements the inexact Newton method, with\nbacktracking or full line searches. Several Jacobian\napproximations are available, including Krylov and Quasi-Newton\nmethods.\n\nReferences\n----------\n.. [KIM] C. T. Kelley, \\\"Iterative Methods for Linear and Nonlinear\n   Equations\\\". Society for Industrial and Applied Mathematics. (1995)\n   http://www.siam.org/books/kelley/", "id": "f19404:m5"}
{"signature": "@staticmethod<EOL><INDENT>def _solve(v, alpha, cs, ds):<DEDENT>", "body": "if len(cs) == <NUM_LIT:0>:<EOL><INDENT>return v/alpha<EOL><DEDENT>axpy, dotc = get_blas_funcs(['<STR_LIT>', '<STR_LIT>'], cs[:<NUM_LIT:1>] + [v])<EOL>c0 = cs[<NUM_LIT:0>]<EOL>A = alpha * np.identity(len(cs), dtype=c0.dtype)<EOL>for i, d in enumerate(ds):<EOL><INDENT>for j, c in enumerate(cs):<EOL><INDENT>A[i,j] += dotc(d, c)<EOL><DEDENT><DEDENT>q = np.zeros(len(cs), dtype=c0.dtype)<EOL>for j, d in enumerate(ds):<EOL><INDENT>q[j] = dotc(d, v)<EOL><DEDENT>q /= alpha<EOL>q = solve(A, q)<EOL>w = v/alpha<EOL>for c, qc in zip(cs, q):<EOL><INDENT>w = axpy(c, w, w.size, -qc)<EOL><DEDENT>return w<EOL>", "docstring": "Evaluate w = M^-1 v", "id": "f19404:c5:m2"}
{"signature": "def asjacobian(J):", "body": "spsolve = scipy.sparse.linalg.spsolve<EOL>if isinstance(J, Jacobian):<EOL><INDENT>return J<EOL><DEDENT>elif inspect.isclass(J) and issubclass(J, Jacobian):<EOL><INDENT>return J()<EOL><DEDENT>elif isinstance(J, np.ndarray):<EOL><INDENT>if J.ndim > <NUM_LIT:2>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>J = np.atleast_2d(np.asarray(J))<EOL>if J.shape[<NUM_LIT:0>] != J.shape[<NUM_LIT:1>]:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return Jacobian(matvec=lambda v: dot(J, v),<EOL>rmatvec=lambda v: dot(J.conj().T, v),<EOL>solve=lambda v: solve(J, v),<EOL>rsolve=lambda v: solve(J.conj().T, v),<EOL>dtype=J.dtype, shape=J.shape)<EOL><DEDENT>elif scipy.sparse.isspmatrix(J):<EOL><INDENT>if J.shape[<NUM_LIT:0>] != J.shape[<NUM_LIT:1>]:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return Jacobian(matvec=lambda v: J*v,<EOL>rmatvec=lambda v: J.conj().T * v,<EOL>solve=lambda v: spsolve(J, v),<EOL>rsolve=lambda v: spsolve(J.conj().T, v),<EOL>dtype=J.dtype, shape=J.shape)<EOL><DEDENT>elif hasattr(J, '<STR_LIT>') and hasattr(J, '<STR_LIT>') and hasattr(J, '<STR_LIT>'):<EOL><INDENT>return Jacobian(matvec=getattr(J, '<STR_LIT>'),<EOL>rmatvec=getattr(J, '<STR_LIT>'),<EOL>solve=J.solve,<EOL>rsolve=getattr(J, '<STR_LIT>'),<EOL>update=getattr(J, '<STR_LIT>'),<EOL>setup=getattr(J, '<STR_LIT>'),<EOL>dtype=J.dtype,<EOL>shape=J.shape)<EOL><DEDENT>elif callable(J):<EOL><INDENT>class Jac(Jacobian):<EOL><INDENT>def update(self, x, F):<EOL><INDENT>self.x = x<EOL><DEDENT>def solve(self, v, tol=<NUM_LIT:0>):<EOL><INDENT>m = J(self.x)<EOL>if isinstance(m, np.ndarray):<EOL><INDENT>return solve(m, v)<EOL><DEDENT>elif scipy.sparse.isspmatrix(m):<EOL><INDENT>return spsolve(m, v)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>def matvec(self, v):<EOL><INDENT>m = J(self.x)<EOL>if isinstance(m, np.ndarray):<EOL><INDENT>return dot(m, v)<EOL><DEDENT>elif scipy.sparse.isspmatrix(m):<EOL><INDENT>return m*v<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>def rsolve(self, v, tol=<NUM_LIT:0>):<EOL><INDENT>m = J(self.x)<EOL>if isinstance(m, np.ndarray):<EOL><INDENT>return solve(m.conj().T, v)<EOL><DEDENT>elif scipy.sparse.isspmatrix(m):<EOL><INDENT>return spsolve(m.conj().T, v)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>def rmatvec(self, v):<EOL><INDENT>m = J(self.x)<EOL>if isinstance(m, np.ndarray):<EOL><INDENT>return dot(m.conj().T, v)<EOL><DEDENT>elif scipy.sparse.isspmatrix(m):<EOL><INDENT>return m.conj().T * v<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>return Jac()<EOL><DEDENT>elif isinstance(J, str):<EOL><INDENT>return dict(broyden1=BroydenFirst,<EOL>broyden2=BroydenSecond,<EOL>anderson=Anderson,<EOL>diagbroyden=DiagBroyden,<EOL>linearmixing=LinearMixing,<EOL>excitingmixing=ExcitingMixing,<EOL>krylov=KrylovJacobian)[J]()<EOL><DEDENT>else:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Convert given object to one suitable for use as a Jacobian.", "id": "f19404:m7"}
{"signature": "def rsolve(self, v, tol=<NUM_LIT:0>):", "body": "if self.collapsed is not None:<EOL><INDENT>return solve(self.collapsed.T.conj(), v)<EOL><DEDENT>return LowRankMatrix._solve(v, np.conj(self.alpha), self.ds, self.cs)<EOL>", "docstring": "Evaluate w = M^-H v", "id": "f19404:c5:m6"}
{"signature": "def _nonlin_wrapper(name, jac):", "body": "import inspect<EOL>args, varargs, varkw, defaults = inspect.getargspec(jac.__init__)<EOL>kwargs = list(zip(args[-len(defaults):], defaults))<EOL>kw_str = \"<STR_LIT:U+002CU+0020>\".join([\"<STR_LIT>\" % (k, v) for k, v in kwargs])<EOL>if kw_str:<EOL><INDENT>kw_str = \"<STR_LIT:U+002CU+0020>\" + kw_str<EOL><DEDENT>kwkw_str = \"<STR_LIT:U+002CU+0020>\".join([\"<STR_LIT>\" % (k, k) for k, v in kwargs])<EOL>if kwkw_str:<EOL><INDENT>kwkw_str = kwkw_str + \"<STR_LIT:U+002CU+0020>\"<EOL><DEDENT>wrapper =", "docstring": "Construct a solver wrapper with given name and jacobian approx.\n\nIt inspects the keyword arguments of ``jac.__init__``, and allows to\nuse the same arguments in the wrapper function, in addition to the\nkeyword arguments of `nonlin_solve`", "id": "f19404:m8"}
{"signature": "def solve(self, v, tol=<NUM_LIT:0>):", "body": "if self.collapsed is not None:<EOL><INDENT>return solve(self.collapsed, v)<EOL><DEDENT>return LowRankMatrix._solve(v, self.alpha, self.cs, self.ds)<EOL>", "docstring": "Evaluate w = M^-1 v", "id": "f19404:c5:m5"}
{"signature": "def golden(func, args=(), brack=None, tol=_epsilon, full_output=<NUM_LIT:0>):", "body": "options = {'<STR_LIT>': tol}<EOL>res = _minimize_scalar_golden(func, brack, args, **options)<EOL>if full_output:<EOL><INDENT>return res['<STR_LIT:x>'], res['<STR_LIT>'], res['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>return res['<STR_LIT:x>']<EOL><DEDENT>", "docstring": "Return the minimum of a function of one variable.\n\nGiven a function of one variable and a possible bracketing interval,\nreturn the minimum of the function isolated to a fractional precision of\ntol.\n\nParameters\n----------\nfunc : callable func(x,*args)\n    Objective function to minimize.\nargs : tuple\n    Additional arguments (if present), passed to func.\nbrack : tuple\n    Triple (a,b,c), where (a<b<c) and func(b) <\n    func(a),func(c).  If bracket consists of two numbers (a,\n    c), then they are assumed to be a starting interval for a\n    downhill bracket search (see `bracket`); it doesn't always\n    mean that obtained solution will satisfy a<=x<=c.\ntol : float\n    x tolerance stop criterion\nfull_output : bool\n    If True, return optional outputs.\n\nSee also\n--------\nminimize_scalar: Interface to minimization algorithms for scalar\n    univariate functions. See the 'Golden' `method` in particular.\n\nNotes\n-----\nUses analog of bisection method to decrease the bracketed\ninterval.", "id": "f19405:m25"}
{"signature": "def _linesearch_powell(func, p, xi, tol=<NUM_LIT>):", "body": "def myfunc(alpha):<EOL><INDENT>return func(p + alpha*xi)<EOL><DEDENT>alpha_min, fret, iter, num = brent(myfunc, full_output=<NUM_LIT:1>, tol=tol)<EOL>xi = alpha_min*xi<EOL>return squeeze(fret), p + xi, xi<EOL>", "docstring": "Line-search algorithm using fminbound.\n\n    Find the minimium of the function ``func(x0+ alpha*direc)``.", "id": "f19405:m28"}
{"signature": "def fmin_ncg(f, x0, fprime, fhess_p=None, fhess=None, args=(), avextol=<NUM_LIT>,<EOL>epsilon=_epsilon, maxiter=None, full_output=<NUM_LIT:0>, disp=<NUM_LIT:1>, retall=<NUM_LIT:0>,<EOL>callback=None):", "body": "opts = {'<STR_LIT>': avextol,<EOL>'<STR_LIT>': epsilon,<EOL>'<STR_LIT>': maxiter,<EOL>'<STR_LIT>': disp,<EOL>'<STR_LIT>': retall}<EOL>res = _minimize_newtoncg(f, x0, args, fprime, fhess, fhess_p,<EOL>callback=callback, **opts)<EOL>if full_output:<EOL><INDENT>retlist = (res['<STR_LIT:x>'], res['<STR_LIT>'], res['<STR_LIT>'], res['<STR_LIT>'],<EOL>res['<STR_LIT>'], res['<STR_LIT:status>'])<EOL>if retall:<EOL><INDENT>retlist += (res['<STR_LIT>'], )<EOL><DEDENT>return retlist<EOL><DEDENT>else:<EOL><INDENT>if retall:<EOL><INDENT>return res['<STR_LIT:x>'], res['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>return res['<STR_LIT:x>']<EOL><DEDENT><DEDENT>", "docstring": "Unconstrained minimization of a function using the Newton-CG method.\n\nParameters\n----------\nf : callable ``f(x, *args)``\n    Objective function to be minimized.\nx0 : ndarray\n    Initial guess.\nfprime : callable ``f'(x, *args)``\n    Gradient of f.\nfhess_p : callable ``fhess_p(x, p, *args)``, optional\n    Function which computes the Hessian of f times an\n    arbitrary vector, p.\nfhess : callable ``fhess(x, *args)``, optional\n    Function to compute the Hessian matrix of f.\nargs : tuple, optional\n    Extra arguments passed to f, fprime, fhess_p, and fhess\n    (the same set of extra arguments is supplied to all of\n    these functions).\nepsilon : float or ndarray, optional\n    If fhess is approximated, use this value for the step size.\ncallback : callable, optional\n    An optional user-supplied function which is called after\n    each iteration.  Called as callback(xk), where xk is the\n    current parameter vector.\navextol : float, optional\n    Convergence is assumed when the average relative error in\n    the minimizer falls below this amount.\nmaxiter : int, optional\n    Maximum number of iterations to perform.\nfull_output : bool, optional\n    If True, return the optional outputs.\ndisp : bool, optional\n    If True, print convergence message.\nretall : bool, optional\n    If True, return a list of results at each iteration.\n\nReturns\n-------\nxopt : ndarray\n    Parameters which minimize f, i.e. ``f(xopt) == fopt``.\nfopt : float\n    Value of the function at xopt, i.e. ``fopt = f(xopt)``.\nfcalls : int\n    Number of function calls made.\ngcalls : int\n    Number of gradient calls made.\nhcalls : int\n    Number of hessian calls made.\nwarnflag : int\n    Warnings generated by the algorithm.\n    1 : Maximum number of iterations exceeded.\nallvecs : list\n    The result at each iteration, if retall is True (see below).\n\nSee also\n--------\nminimize: Interface to minimization algorithms for multivariate\n    functions. See the 'Newton-CG' `method` in particular.\n\nNotes\n-----\nOnly one of `fhess_p` or `fhess` need to be given.  If `fhess`\nis provided, then `fhess_p` will be ignored.  If neither `fhess`\nnor `fhess_p` is provided, then the hessian product will be\napproximated using finite differences on `fprime`. `fhess_p`\nmust compute the hessian times an arbitrary vector. If it is not\ngiven, finite-differences on `fprime` are used to compute\nit.\n\nNewton-CG methods are also called truncated Newton methods. This\nfunction differs from scipy.optimize.fmin_tnc because\n\n1. scipy.optimize.fmin_ncg is written purely in python using numpy\n    and scipy while scipy.optimize.fmin_tnc calls a C function.\n2. scipy.optimize.fmin_ncg is only for unconstrained minimization\n    while scipy.optimize.fmin_tnc is for unconstrained minimization\n    or box constrained minimization. (Box constraints give\n    lower and upper bounds for each variable separately.)\n\nReferences\n----------\nWright & Nocedal, 'Numerical Optimization', 1999, pg. 140.", "id": "f19405:m19"}
{"signature": "def brent(func, args=(), brack=None, tol=<NUM_LIT>, full_output=<NUM_LIT:0>, maxiter=<NUM_LIT>):", "body": "options = {'<STR_LIT>': tol,<EOL>'<STR_LIT>': maxiter}<EOL>res = _minimize_scalar_brent(func, brack, args, **options)<EOL>if full_output:<EOL><INDENT>return res['<STR_LIT:x>'], res['<STR_LIT>'], res['<STR_LIT>'], res['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>return res['<STR_LIT:x>']<EOL><DEDENT>", "docstring": "Given a function of one-variable and a possible bracketing interval,\nreturn the minimum of the function isolated to a fractional precision of\ntol.\n\nParameters\n----------\nfunc : callable f(x,*args)\n    Objective function.\nargs\n    Additional arguments (if present).\nbrack : tuple\n    Triple (a,b,c) where (a<b<c) and func(b) <\n    func(a),func(c).  If bracket consists of two numbers (a,c)\n    then they are assumed to be a starting interval for a\n    downhill bracket search (see `bracket`); it doesn't always\n    mean that the obtained solution will satisfy a<=x<=c.\ntol : float\n    Stop if between iteration change is less than `tol`.\nfull_output : bool\n    If True, return all output args (xmin, fval, iter,\n    funcalls).\nmaxiter : int\n    Maximum number of iterations in solution.\n\nReturns\n-------\nxmin : ndarray\n    Optimum point.\nfval : float\n    Optimum value.\niter : int\n    Number of iterations.\nfuncalls : int\n    Number of objective function evaluations made.\n\nSee also\n--------\nminimize_scalar: Interface to minimization algorithms for scalar\n    univariate functions. See the 'Brent' `method` in particular.\n\nNotes\n-----\nUses inverse parabolic interpolation when possible to speed up\nconvergence of golden section method.", "id": "f19405:m23"}
{"signature": "def root(fun, x0, args=(), method='<STR_LIT>', jac=None, tol=None, callback=None,<EOL>options=None):", "body": "if not isinstance(args, tuple):<EOL><INDENT>args = (args,)<EOL><DEDENT>meth = method.lower()<EOL>if options is None:<EOL><INDENT>options = {}<EOL><DEDENT>if callback is not None and meth in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>warn('<STR_LIT>' % method,<EOL>RuntimeWarning)<EOL><DEDENT>if not callable(jac) and meth in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>if bool(jac):<EOL><INDENT>fun = MemoizeJac(fun)<EOL>jac = fun.derivative<EOL><DEDENT>else:<EOL><INDENT>jac = None<EOL><DEDENT><DEDENT>if tol is not None:<EOL><INDENT>options = dict(options)<EOL>if meth in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>options.setdefault('<STR_LIT>', tol)<EOL><DEDENT>elif meth in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>options.setdefault('<STR_LIT>', tol)<EOL>options.setdefault('<STR_LIT>', np.inf)<EOL>options.setdefault('<STR_LIT>', np.inf)<EOL>options.setdefault('<STR_LIT>', np.inf)<EOL><DEDENT><DEDENT>if meth == '<STR_LIT>':<EOL><INDENT>sol = _root_hybr(fun, x0, args=args, jac=jac, **options)<EOL><DEDENT>elif meth == '<STR_LIT>':<EOL><INDENT>sol = _root_leastsq(fun, x0, args=args, jac=jac, **options)<EOL><DEDENT>elif meth in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>if jac is not None:<EOL><INDENT>warn('<STR_LIT>' % method,<EOL>RuntimeWarning)<EOL><DEDENT>sol = _root_nonlin_solve(fun, x0, args=args, jac=jac,<EOL>_method=meth, _callback=callback,<EOL>**options)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' % method)<EOL><DEDENT>return sol<EOL>", "docstring": "Find a root of a vector function.\n\nParameters\n----------\nfun : callable\n    A vector function to find a root of.\nx0 : ndarray\n    Initial guess.\nargs : tuple, optional\n    Extra arguments passed to the objective function and its Jacobian.\nmethod : str, optional\n    Type of solver.  Should be one of\n\n        - 'hybr'\n        - 'lm'\n        - 'broyden1'\n        - 'broyden2'\n        - 'anderson'\n        - 'linearmixing'\n        - 'diagbroyden'\n        - 'excitingmixing'\n        - 'krylov'\n\njac : bool or callable, optional\n    If `jac` is a Boolean and is True, `fun` is assumed to return the\n    value of Jacobian along with the objective function. If False, the\n    Jacobian will be estimated numerically.\n    `jac` can also be a callable returning the Jacobian of `fun`. In\n    this case, it must accept the same arguments as `fun`.\ntol : float, optional\n    Tolerance for termination. For detailed control, use solver-specific\n    options.\ncallback : function, optional\n    Optional callback function. It is called on every iteration as\n    ``callback(x, f)`` where `x` is the current solution and `f`\n    the corresponding residual. For all methods but 'hybr' and 'lm'.\noptions : dict, optional\n    A dictionary of solver options. E.g. `xtol` or `maxiter`, see\n    :obj:`show_options()` for details.\n\nReturns\n-------\nsol : OptimizeResult\n    The solution represented as a ``OptimizeResult`` object.\n    Important attributes are: ``x`` the solution array, ``success`` a\n    Boolean flag indicating if the algorithm exited successfully and\n    ``message`` which describes the cause of the termination. See\n    `OptimizeResult` for a description of other attributes.\n\nSee also\n--------\nshow_options : Additional options accepted by the solvers\n\nNotes\n-----\nThis section describes the available solvers that can be selected by the\n'method' parameter. The default method is *hybr*.\n\nMethod *hybr* uses a modification of the Powell hybrid method as\nimplemented in MINPACK [1]_.\n\nMethod *lm* solves the system of nonlinear equations in a least squares\nsense using a modification of the Levenberg-Marquardt algorithm as\nimplemented in MINPACK [1]_.\n\nMethods *broyden1*, *broyden2*, *anderson*, *linearmixing*,\n*diagbroyden*, *excitingmixing*, *krylov* are inexact Newton methods,\nwith backtracking or full line searches [2]_. Each method corresponds\nto a particular Jacobian approximations. See `nonlin` for details.\n\n- Method *broyden1* uses Broyden's first Jacobian approximation, it is\n  known as Broyden's good method.\n- Method *broyden2* uses Broyden's second Jacobian approximation, it\n  is known as Broyden's bad method.\n- Method *anderson* uses (extended) Anderson mixing.\n- Method *Krylov* uses Krylov approximation for inverse Jacobian. It\n  is suitable for large-scale problem.\n- Method *diagbroyden* uses diagonal Broyden Jacobian approximation.\n- Method *linearmixing* uses a scalar Jacobian approximation.\n- Method *excitingmixing* uses a tuned diagonal Jacobian\n  approximation.\n\n.. warning::\n\n    The algorithms implemented for methods *diagbroyden*,\n    *linearmixing* and *excitingmixing* may be useful for specific\n    problems, but whether they will work may depend strongly on the\n    problem.\n\n.. versionadded:: 0.11.0\n\nReferences\n----------\n.. [1] More, Jorge J., Burton S. Garbow, and Kenneth E. Hillstrom.\n   1980. User Guide for MINPACK-1.\n.. [2] C. T. Kelley. 1995. Iterative Methods for Linear and Nonlinear\n    Equations. Society for Industrial and Applied Mathematics.\n    <http://www.siam.org/books/kelley/>\n\nExamples\n--------\nThe following functions define a system of nonlinear equations and its\njacobian.\n\n>>> def fun(x):\n...     return [x[0]  + 0.5 * (x[0] - x[1])**3 - 1.0,\n...             0.5 * (x[1] - x[0])**3 + x[1]]\n\n>>> def jac(x):\n...     return np.array([[1 + 1.5 * (x[0] - x[1])**2,\n...                       -1.5 * (x[0] - x[1])**2],\n...                      [-1.5 * (x[1] - x[0])**2,\n...                       1 + 1.5 * (x[1] - x[0])**2]])\n\nA solution can be obtained as follows.\n\n>>> from scipy import optimize\n>>> sol = optimize.root(fun, [0, 0], jac=jac, method='hybr')\n>>> sol.x\narray([ 0.8411639,  0.1588361])", "id": "f19407:m0"}
{"signature": "def fmin_cobyla(func, x0, cons, args=(), consargs=None, rhobeg=<NUM_LIT:1.0>,<EOL>rhoend=<NUM_LIT>, iprint=<NUM_LIT:1>, maxfun=<NUM_LIT:1000>, disp=None, catol=<NUM_LIT>):", "body": "err = \"<STR_LIT>\"\"<STR_LIT>\"<EOL>try:<EOL><INDENT>len(cons)<EOL><DEDENT>except TypeError:<EOL><INDENT>if callable(cons):<EOL><INDENT>cons = [cons]<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(err)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>for thisfunc in cons:<EOL><INDENT>if not callable(thisfunc):<EOL><INDENT>raise TypeError(err)<EOL><DEDENT><DEDENT><DEDENT>if consargs is None:<EOL><INDENT>consargs = args<EOL><DEDENT>con = tuple({'<STR_LIT:type>': '<STR_LIT>', '<STR_LIT>': c, '<STR_LIT:args>': consargs} for c in cons)<EOL>if disp is not None:<EOL><INDENT>iprint = disp<EOL><DEDENT>opts = {'<STR_LIT>': rhobeg,<EOL>'<STR_LIT>': rhoend,<EOL>'<STR_LIT>': iprint,<EOL>'<STR_LIT>': iprint != <NUM_LIT:0>,<EOL>'<STR_LIT>': maxfun,<EOL>'<STR_LIT>': catol}<EOL>sol = _minimize_cobyla(func, x0, args, constraints=con,<EOL>**opts)<EOL>if iprint > <NUM_LIT:0> and not sol['<STR_LIT:success>']:<EOL><INDENT>print(\"<STR_LIT>\" % (sol.message,))<EOL><DEDENT>return sol['<STR_LIT:x>']<EOL>", "docstring": "Minimize a function using the Constrained Optimization BY Linear\nApproximation (COBYLA) method. This method wraps a FORTRAN\nimplentation of the algorithm.\n\nParameters\n----------\nfunc : callable\n    Function to minimize. In the form func(x, \\\\*args).\nx0 : ndarray\n    Initial guess.\ncons : sequence\n    Constraint functions; must all be ``>=0`` (a single function\n    if only 1 constraint). Each function takes the parameters `x`\n    as its first argument.\nargs : tuple\n    Extra arguments to pass to function.\nconsargs : tuple\n    Extra arguments to pass to constraint functions (default of None means\n    use same extra arguments as those passed to func).\n    Use ``()`` for no extra arguments.\nrhobeg :\n    Reasonable initial changes to the variables.\nrhoend :\n    Final accuracy in the optimization (not precisely guaranteed). This\n    is a lower bound on the size of the trust region.\niprint : {0, 1, 2, 3}\n    Controls the frequency of output; 0 implies no output.  Deprecated.\ndisp : {0, 1, 2, 3}\n    Over-rides the iprint interface.  Preferred.\nmaxfun : int\n    Maximum number of function evaluations.\ncatol : float\n    Absolute tolerance for constraint violations.\n\nReturns\n-------\nx : ndarray\n    The argument that minimises `f`.\n\nSee also\n--------\nminimize: Interface to minimization algorithms for multivariate\n    functions. See the 'COBYLA' `method` in particular.\n\nNotes\n-----\nThis algorithm is based on linear approximations to the objective\nfunction and each constraint. We briefly describe the algorithm.\n\nSuppose the function is being minimized over k variables. At the\njth iteration the algorithm has k+1 points v_1, ..., v_(k+1),\nan approximate solution x_j, and a radius RHO_j.\n(i.e. linear plus a constant) approximations to the objective\nfunction and constraint functions such that their function values\nagree with the linear approximation on the k+1 points v_1,.., v_(k+1).\nThis gives a linear program to solve (where the linear approximations\nof the constraint functions are constrained to be non-negative).\n\nHowever the linear approximations are likely only good\napproximations near the current simplex, so the linear program is\ngiven the further requirement that the solution, which\nwill become x_(j+1), must be within RHO_j from x_j. RHO_j only\ndecreases, never increases. The initial RHO_j is rhobeg and the\nfinal RHO_j is rhoend. In this way COBYLA's iterations behave\nlike a trust region algorithm.\n\nAdditionally, the linear program may be inconsistent, or the\napproximation may give poor improvement. For details about\nhow these issues are resolved, as well as how the points v_i are\nupdated, refer to the source code or the references below.\n\n\nReferences\n----------\nPowell M.J.D. (1994), \"A direct search optimization method that models\nthe objective and constraint functions by linear interpolation.\", in\nAdvances in Optimization and Numerical Analysis, eds. S. Gomez and\nJ-P Hennart, Kluwer Academic (Dordrecht), pp. 51-67\n\nPowell M.J.D. (1998), \"Direct search algorithms for optimization\ncalculations\", Acta Numerica 7, 287-336\n\nPowell M.J.D. (2007), \"A view of algorithms for optimization without\nderivatives\", Cambridge University Technical Report DAMTP 2007/NA03\n\n\nExamples\n--------\nMinimize the objective function f(x,y) = x*y subject\nto the constraints x**2 + y**2 < 1 and y > 0::\n\n    >>> def objective(x):\n    ...     return x[0]*x[1]\n    ...\n    >>> def constr1(x):\n    ...     return 1 - (x[0]**2 + x[1]**2)\n    ...\n    >>> def constr2(x):\n    ...     return x[1]\n    ...\n    >>> fmin_cobyla(objective, [0.0, 0.1], [constr1, constr2], rhoend=1e-7)\n\n       Normal return from subroutine COBYLA\n\n       NFVALS =   64   F =-5.000000E-01    MAXCV = 1.998401E-14\n       X =-7.071069E-01   7.071067E-01\n    array([-0.70710685,  0.70710671])\n\nThe exact solution is (-sqrt(2)/2, sqrt(2)/2).", "id": "f19408:m0"}
{"signature": "def print_results(self):", "body": "results = self.average_results()<EOL>results = sorted(results, key=lambda x: (x.nfail, x.mean_time))<EOL>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\" % (self.function_name))<EOL>print(\"<STR_LIT>\" % (results[<NUM_LIT:0>].ndim, str(self.minimizer_kwargs)))<EOL>print(\"<STR_LIT>\" % (results[<NUM_LIT:0>].ntrials))<EOL>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\")<EOL>for res in results:<EOL><INDENT>print(\"<STR_LIT>\" %<EOL>(res.name, res.nfail, res.mean_nfev, res.mean_njev, res.mean_nhev, res.mean_time))<EOL><DEDENT>", "docstring": "print the current list of results", "id": "f19410:c0:m3"}
{"signature": "def add_result(self, result, t, name):", "body": "result.time = t<EOL>result.name = name<EOL>if not hasattr(result, \"<STR_LIT>\"):<EOL><INDENT>result.njev = <NUM_LIT:0><EOL><DEDENT>if not hasattr(result, \"<STR_LIT>\"):<EOL><INDENT>result.nhev = <NUM_LIT:0><EOL><DEDENT>self.results.append(result)<EOL>", "docstring": "add a result to the list", "id": "f19410:c0:m2"}
{"signature": "def add_result(self, result, t, name):", "body": "result.time = t<EOL>result.name = name<EOL>if not hasattr(result, \"<STR_LIT>\"):<EOL><INDENT>result.njev = <NUM_LIT:0><EOL><DEDENT>if not hasattr(result, \"<STR_LIT>\"):<EOL><INDENT>result.nhev = <NUM_LIT:0><EOL><DEDENT>self.results.append(result)<EOL>", "docstring": "add a result to the list", "id": "f19411:c0:m7"}
{"signature": "def average_results(self):", "body": "grouped_results = defaultdict(list)<EOL>for res in self.results:<EOL><INDENT>grouped_results[res.name].append(res)<EOL><DEDENT>averaged_results = dict()<EOL>for name, result_list in grouped_results.items():<EOL><INDENT>newres = OptimizeResult()<EOL>newres.name = name<EOL>newres.mean_nfev = np.mean([r.nfev for r in result_list])<EOL>newres.mean_njev = np.mean([r.njev for r in result_list])<EOL>newres.mean_nhev = np.mean([r.nhev for r in result_list])<EOL>newres.mean_time = np.mean([r.time for r in result_list])<EOL>newres.ntrials = len(result_list)<EOL>newres.nfail = len([r for r in result_list if not r.success])<EOL>try:<EOL><INDENT>newres.ndim = len(result_list[<NUM_LIT:0>].x)<EOL><DEDENT>except TypeError:<EOL><INDENT>newres.ndim = <NUM_LIT:1><EOL><DEDENT>averaged_results[name] = newres<EOL><DEDENT>return averaged_results.values()<EOL>", "docstring": "group the results by minimizer and average over the runs", "id": "f19411:c0:m9"}
{"signature": "def dabs(self, x):", "body": "if x < <NUM_LIT:0>:<EOL><INDENT>return -<NUM_LIT:1.><EOL><DEDENT>elif x > <NUM_LIT:0>:<EOL><INDENT>return <NUM_LIT:1.><EOL><DEDENT>else:<EOL><INDENT>return <NUM_LIT:0.><EOL><DEDENT>", "docstring": "derivative of absolute value", "id": "f19412:c9:m1"}
{"signature": "def scalar_search_wolfe2(phi, derphi=None, phi0=None,<EOL>old_phi0=None, derphi0=None,<EOL>c1=<NUM_LIT>, c2=<NUM_LIT>, amax=<NUM_LIT:50>):", "body": "if phi0 is None:<EOL><INDENT>phi0 = phi(<NUM_LIT:0.>)<EOL><DEDENT>if derphi0 is None and derphi is not None:<EOL><INDENT>derphi0 = derphi(<NUM_LIT:0.>)<EOL><DEDENT>alpha0 = <NUM_LIT:0><EOL>if old_phi0 is not None and derphi0 != <NUM_LIT:0>:<EOL><INDENT>alpha1 = min(<NUM_LIT:1.0>, <NUM_LIT>*<NUM_LIT:2>*(phi0 - old_phi0)/derphi0)<EOL><DEDENT>else:<EOL><INDENT>alpha1 = <NUM_LIT:1.0><EOL><DEDENT>if alpha1 < <NUM_LIT:0>:<EOL><INDENT>alpha1 = <NUM_LIT:1.0><EOL><DEDENT>if alpha1 == <NUM_LIT:0>:<EOL><INDENT>alpha_star = None<EOL>phi_star = phi0<EOL>phi0 = old_phi0<EOL>derphi_star = None<EOL><DEDENT>phi_a1 = phi(alpha1)<EOL>phi_a0 = phi0<EOL>derphi_a0 = derphi0<EOL>i = <NUM_LIT:1><EOL>maxiter = <NUM_LIT:10><EOL>for i in xrange(maxiter):<EOL><INDENT>if alpha1 == <NUM_LIT:0>:<EOL><INDENT>break<EOL><DEDENT>if (phi_a1 > phi0 + c1 * alpha1 * derphi0) or((phi_a1 >= phi_a0) and (i > <NUM_LIT:1>)):<EOL><INDENT>alpha_star, phi_star, derphi_star =_zoom(alpha0, alpha1, phi_a0,<EOL>phi_a1, derphi_a0, phi, derphi,<EOL>phi0, derphi0, c1, c2)<EOL>break<EOL><DEDENT>derphi_a1 = derphi(alpha1)<EOL>if (abs(derphi_a1) <= -c2*derphi0):<EOL><INDENT>alpha_star = alpha1<EOL>phi_star = phi_a1<EOL>derphi_star = derphi_a1<EOL>break<EOL><DEDENT>if (derphi_a1 >= <NUM_LIT:0>):<EOL><INDENT>alpha_star, phi_star, derphi_star =_zoom(alpha1, alpha0, phi_a1,<EOL>phi_a0, derphi_a1, phi, derphi,<EOL>phi0, derphi0, c1, c2)<EOL>break<EOL><DEDENT>alpha2 = <NUM_LIT:2> * alpha1   <EOL>i = i + <NUM_LIT:1><EOL>alpha0 = alpha1<EOL>alpha1 = alpha2<EOL>phi_a0 = phi_a1<EOL>phi_a1 = phi(alpha1)<EOL>derphi_a0 = derphi_a1<EOL><DEDENT>else:<EOL><INDENT>alpha_star = alpha1<EOL>phi_star = phi_a1<EOL>derphi_star = None<EOL><DEDENT>return alpha_star, phi_star, phi0, derphi_star<EOL>", "docstring": "Find alpha that satisfies strong Wolfe conditions.\n\n    alpha > 0 is assumed to be a descent direction.\n\n    Parameters\n    ----------\n    phi : callable f(x,*args)\n        Objective scalar function.\n\n    derphi : callable f'(x,*args), optional\n        Objective function derivative (can be None)\n    phi0 : float, optional\n        Value of phi at s=0\n    old_phi0 : float, optional\n        Value of phi at previous point\n    derphi0 : float, optional\n        Value of derphi at s=0\n    args : tuple\n        Additional arguments passed to objective function.\n    c1 : float\n        Parameter for Armijo condition rule.\n    c2 : float\n        Parameter for curvature condition rule.\n\n    Returns\n    -------\n    alpha_star : float\n        Best alpha\n    phi_star\n        phi at alpha_star\n    phi0\n        phi at 0\n    derphi_star\n        derphi at alpha_star\n\n    Notes\n    -----\n    Uses the line search algorithm to enforce strong Wolfe\n    conditions.  See Wright and Nocedal, 'Numerical Optimization',\n    1999, pg. 59-60.\n\n    For the zoom phase it uses an algorithm by [...].", "id": "f19413:m3"}
{"signature": "def getstart_temp(self, best_state):", "body": "assert(self.dims is not None)<EOL>lrange = self.lower<EOL>urange = self.upper<EOL>fmax = _double_min<EOL>fmin = _double_max<EOL>for _ in range(self.Ninit):<EOL><INDENT>x0 = random.uniform(size=self.dims)*(urange-lrange) + lrange<EOL>fval = self.func(x0, *self.args)<EOL>self.feval += <NUM_LIT:1><EOL>if fval > fmax:<EOL><INDENT>fmax = fval<EOL><DEDENT>if fval < fmin:<EOL><INDENT>fmin = fval<EOL>best_state.cost = fval<EOL>best_state.x = array(x0)<EOL><DEDENT><DEDENT>self.T0 = (fmax-fmin)*<NUM_LIT><EOL>return best_state.x<EOL>", "docstring": "Find a matching starting temperature and starting parameters vector\n        i.e. find x0 such that func(x0) = T0.\n\n        Parameters\n        ----------\n        best_state : _state\n            A _state object to store the function value and x0 found.\n\n        Returns\n        -------\n        x0 : array\n            The starting parameters vector.", "id": "f19416:c0:m2"}
{"signature": "def _solve_simplex(T, n, basis, maxiter=<NUM_LIT:1000>, phase=<NUM_LIT:2>, callback=None,<EOL>tol=<NUM_LIT>, nit0=<NUM_LIT:0>, bland=False):", "body": "nit = nit0<EOL>complete = False<EOL>solution = np.zeros(T.shape[<NUM_LIT:1>]-<NUM_LIT:1>, dtype=np.float64)<EOL>if phase == <NUM_LIT:1>:<EOL><INDENT>m = T.shape[<NUM_LIT:0>]-<NUM_LIT:2><EOL><DEDENT>elif phase == <NUM_LIT:2>:<EOL><INDENT>m = T.shape[<NUM_LIT:0>]-<NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>while not complete:<EOL><INDENT>pivcol_found, pivcol = _pivot_col(T, tol, bland)<EOL>if not pivcol_found:<EOL><INDENT>pivcol = np.nan<EOL>pivrow = np.nan<EOL>status = <NUM_LIT:0><EOL>complete = True<EOL><DEDENT>else:<EOL><INDENT>pivrow_found, pivrow = _pivot_row(T, pivcol, phase, tol)<EOL>if not pivrow_found:<EOL><INDENT>status = <NUM_LIT:3><EOL>complete = True<EOL><DEDENT><DEDENT>if callback is not None:<EOL><INDENT>solution[:] = <NUM_LIT:0><EOL>solution[basis[:m]] = T[:m, -<NUM_LIT:1>]<EOL>callback(solution[:n], **{\"<STR_LIT>\": T,<EOL>\"<STR_LIT>\":phase,<EOL>\"<STR_LIT>\":nit,<EOL>\"<STR_LIT>\":(pivrow, pivcol),<EOL>\"<STR_LIT>\":basis,<EOL>\"<STR_LIT>\": complete and phase == <NUM_LIT:2>})<EOL><DEDENT>if not complete:<EOL><INDENT>if nit >= maxiter:<EOL><INDENT>status = <NUM_LIT:1><EOL>complete = True<EOL><DEDENT>else:<EOL><INDENT>basis[pivrow] = pivcol<EOL>pivval = T[pivrow][pivcol]<EOL>T[pivrow, :] = T[pivrow, :] / pivval<EOL>for irow in range(T.shape[<NUM_LIT:0>]):<EOL><INDENT>if irow != pivrow:<EOL><INDENT>T[irow, :] = T[irow, :] - T[pivrow, :]*T[irow, pivcol]<EOL><DEDENT><DEDENT>nit += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>return nit, status<EOL>", "docstring": "Solve a linear programming problem in \"standard maximization form\" using\nthe Simplex Method.\n\nMinimize :math:`f = c^T x`\n\nsubject to\n\n.. math::\n\n    Ax = b\n    x_i >= 0\n    b_j >= 0\n\nParameters\n----------\nT : array_like\n    A 2-D array representing the simplex T corresponding to the\n    maximization problem.  It should have the form:\n\n    [[A[0, 0], A[0, 1], ..., A[0, n_total], b[0]],\n     [A[1, 0], A[1, 1], ..., A[1, n_total], b[1]],\n     .\n     .\n     .\n     [A[m, 0], A[m, 1], ..., A[m, n_total], b[m]],\n     [c[0],   c[1], ...,   c[n_total],    0]]\n\n    for a Phase 2 problem, or the form:\n\n    [[A[0, 0], A[0, 1], ..., A[0, n_total], b[0]],\n     [A[1, 0], A[1, 1], ..., A[1, n_total], b[1]],\n     .\n     .\n     .\n     [A[m, 0], A[m, 1], ..., A[m, n_total], b[m]],\n     [c[0],   c[1], ...,   c[n_total],   0],\n     [c'[0],  c'[1], ...,  c'[n_total],  0]]\n\n     for a Phase 1 problem (a Problem in which a basic feasible solution is\n     sought prior to maximizing the actual objective.  T is modified in\n     place by _solve_simplex.\nn : int\n    The number of true variables in the problem.\nbasis : array\n    An array of the indices of the basic variables, such that basis[i]\n    contains the column corresponding to the basic variable for row i.\n    Basis is modified in place by _solve_simplex\nmaxiter : int\n    The maximum number of iterations to perform before aborting the\n    optimization.\nphase : int\n    The phase of the optimization being executed.  In phase 1 a basic\n    feasible solution is sought and the T has an additional row representing\n    an alternate objective function.\ncallback : callable\n    If a callback function is provided, it will be called within each\n    iteration of the simplex algorithm. The callback must have the\n    signature `callback(xk, **kwargs)` where xk is the current solution\n    vector and kwargs is a dictionary containing the following::\n    \"T\" : The current Simplex algorithm T\n    \"nit\" : The current iteration.\n    \"pivot\" : The pivot (row, column) used for the next iteration.\n    \"phase\" : Whether the algorithm is in Phase 1 or Phase 2.\n    \"basis\" : The indices of the columns of the basic variables.\ntol : float\n    The tolerance which determines when a solution is \"close enough\" to\n    zero in Phase 1 to be considered a basic feasible solution or close\n    enough to positive to to serve as an optimal solution.\nnit0 : int\n    The initial iteration number used to keep an accurate iteration total\n    in a two-phase problem.\nbland : bool\n    If True, choose pivots using Bland's rule [3].  In problems which\n    fail to converge due to cycling, using Bland's rule can provide\n    convergence at the expense of a less optimal path about the simplex.\n\nReturns\n-------\nres : OptimizeResult\n    The optimization result represented as a ``OptimizeResult`` object.\n    Important attributes are: ``x`` the solution array, ``success`` a\n    Boolean flag indicating if the optimizer exited successfully and\n    ``message`` which describes the cause of the termination. Possible\n    values for the ``status`` attribute are:\n     0 : Optimization terminated successfully\n     1 : Iteration limit reached\n     2 : Problem appears to be infeasible\n     3 : Problem appears to be unbounded\n\n    See `OptimizeResult` for a description of other attributes.", "id": "f19417:m4"}
{"signature": "def _pivot_col(T, tol=<NUM_LIT>, bland=False):", "body": "ma = np.ma.masked_where(T[-<NUM_LIT:1>, :-<NUM_LIT:1>] >= -tol, T[-<NUM_LIT:1>, :-<NUM_LIT:1>], copy=False)<EOL>if ma.count() == <NUM_LIT:0>:<EOL><INDENT>return False, np.nan<EOL><DEDENT>if bland:<EOL><INDENT>return True, np.where(ma.mask == False)[<NUM_LIT:0>][<NUM_LIT:0>]<EOL><DEDENT>return True, np.ma.where(ma == ma.min())[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>", "docstring": "Given a linear programming simplex tableau, determine the column\nof the variable to enter the basis.\n\nParameters\n----------\nT : 2D ndarray\n    The simplex tableau.\ntol : float\n    Elements in the objective row larger than -tol will not be considered\n    for pivoting.  Nominally this value is zero, but numerical issues\n    cause a tolerance about zero to be necessary.\nbland : bool\n    If True, use Bland's rule for selection of the column (select the\n    first column with a negative coefficient in the objective row,\n    regardless of magnitude).\n\nReturns\n-------\nstatus: bool\n    True if a suitable pivot column was found, otherwise False.\n    A return of False indicates that the linear programming simplex\n    algorithm is complete.\ncol: int\n    The index of the column of the pivot element.\n    If status is False, col will be returned as nan.", "id": "f19417:m2"}
{"signature": "def _linprog_simplex(c, A_ub=None, b_ub=None, A_eq=None, b_eq=None,<EOL>bounds=None, maxiter=<NUM_LIT:1000>, disp=False, callback=None,<EOL>tol=<NUM_LIT>, bland=False, **unknown_options):", "body": "_check_unknown_options(unknown_options)<EOL>status = <NUM_LIT:0><EOL>messages = {<NUM_LIT:0>: \"<STR_LIT>\",<EOL><NUM_LIT:1>: \"<STR_LIT>\",<EOL><NUM_LIT:2>: \"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL><NUM_LIT:3>: \"<STR_LIT>\",<EOL><NUM_LIT:4>: \"<STR_LIT>\"}<EOL>have_floor_variable = False<EOL>cc = np.asarray(c)<EOL>f0 = <NUM_LIT:0><EOL>n = len(c)<EOL>Aeq = np.asarray(A_eq) if A_eq is not None else np.empty([<NUM_LIT:0>, len(cc)])<EOL>Aub = np.asarray(A_ub) if A_ub is not None else np.empty([<NUM_LIT:0>, len(cc)])<EOL>beq = np.ravel(np.asarray(b_eq)) if b_eq is not None else np.empty([<NUM_LIT:0>])<EOL>bub = np.ravel(np.asarray(b_ub)) if b_ub is not None else np.empty([<NUM_LIT:0>])<EOL>L = np.zeros(n, dtype=np.float64)<EOL>U = np.ones(n, dtype=np.float64)*np.inf<EOL>if bounds is None or len(bounds) == <NUM_LIT:0>:<EOL><INDENT>pass<EOL><DEDENT>elif len(bounds) == <NUM_LIT:2> and not hasattr(bounds[<NUM_LIT:0>], '<STR_LIT>'):<EOL><INDENT>L = np.asarray(n*[bounds[<NUM_LIT:0>]], dtype=np.float64)<EOL>U = np.asarray(n*[bounds[<NUM_LIT:1>]], dtype=np.float64)<EOL><DEDENT>else:<EOL><INDENT>if len(bounds) != n:<EOL><INDENT>status = -<NUM_LIT:1><EOL>message = (\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>for i in range(n):<EOL><INDENT>if len(bounds[i]) != <NUM_LIT:2>:<EOL><INDENT>raise IndexError()<EOL><DEDENT>L[i] = bounds[i][<NUM_LIT:0>] if bounds[i][<NUM_LIT:0>] is not None else -np.inf<EOL>U[i] = bounds[i][<NUM_LIT:1>] if bounds[i][<NUM_LIT:1>] is not None else np.inf<EOL><DEDENT><DEDENT>except IndexError:<EOL><INDENT>status = -<NUM_LIT:1><EOL>message = (\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>if np.any(L == -np.inf):<EOL><INDENT>n = n + <NUM_LIT:1><EOL>L = np.concatenate([np.array([<NUM_LIT:0>]), L])<EOL>U = np.concatenate([np.array([np.inf]), U])<EOL>cc = np.concatenate([np.array([<NUM_LIT:0>]), cc])<EOL>Aeq = np.hstack([np.zeros([Aeq.shape[<NUM_LIT:0>], <NUM_LIT:1>]), Aeq])<EOL>Aub = np.hstack([np.zeros([Aub.shape[<NUM_LIT:0>], <NUM_LIT:1>]), Aub])<EOL>have_floor_variable = True<EOL><DEDENT>for i in range(n):<EOL><INDENT>if(L[i] > U[i]):<EOL><INDENT>status = -<NUM_LIT:1><EOL>message = (\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (i, i))<EOL><DEDENT>if np.isinf(L[i]) and L[i] > <NUM_LIT:0>:<EOL><INDENT>status = -<NUM_LIT:1><EOL>message = (\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>if np.isinf(U[i]) and U[i] < <NUM_LIT:0>:<EOL><INDENT>status = -<NUM_LIT:1><EOL>message = (\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>if np.isfinite(L[i]) and L[i] > <NUM_LIT:0>:<EOL><INDENT>Aub = np.vstack([Aub, np.zeros(n)])<EOL>Aub[-<NUM_LIT:1>, i] = -<NUM_LIT:1><EOL>bub = np.concatenate([bub, np.array([-L[i]])])<EOL>L[i] = <NUM_LIT:0><EOL><DEDENT>if np.isfinite(U[i]):<EOL><INDENT>Aub = np.vstack([Aub, np.zeros(n)])<EOL>Aub[-<NUM_LIT:1>, i] = <NUM_LIT:1><EOL>bub = np.concatenate([bub, np.array([U[i]])])<EOL>U[i] = np.inf<EOL><DEDENT><DEDENT>for i in range(<NUM_LIT:0>, n):<EOL><INDENT>if L[i] < <NUM_LIT:0>:<EOL><INDENT>if np.isfinite(L[i]) and L[i] < <NUM_LIT:0>:<EOL><INDENT>beq[:] = beq[:] - Aeq[:, i] * L[i]<EOL>bub[:] = bub[:] - Aub[:, i] * L[i]<EOL>f0 = f0 - cc[i] * L[i]<EOL><DEDENT>else:<EOL><INDENT>Aeq[:, <NUM_LIT:0>] = Aeq[:, <NUM_LIT:0>] - Aeq[:, i]<EOL>Aub[:, <NUM_LIT:0>] = Aub[:, <NUM_LIT:0>] - Aub[:, i]<EOL>cc[<NUM_LIT:0>] = cc[<NUM_LIT:0>] - cc[i]<EOL><DEDENT><DEDENT>if np.isinf(U[i]):<EOL><INDENT>if U[i] < <NUM_LIT:0>:<EOL><INDENT>status = -<NUM_LIT:1><EOL>message = (\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>mub = len(bub)<EOL>meq = len(beq)<EOL>m = mub+meq<EOL>n_slack = mub<EOL>n_artificial = meq + _count_nonzero(bub < <NUM_LIT:0>)<EOL>try:<EOL><INDENT>Aub_rows, Aub_cols = Aub.shape<EOL><DEDENT>except ValueError:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>try:<EOL><INDENT>Aeq_rows, Aeq_cols = Aeq.shape<EOL><DEDENT>except ValueError:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if Aeq_rows != meq:<EOL><INDENT>status = -<NUM_LIT:1><EOL>message = (\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>if Aub_rows != mub:<EOL><INDENT>status = -<NUM_LIT:1><EOL>message = (\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>if Aeq_cols > <NUM_LIT:0> and Aeq_cols != n:<EOL><INDENT>status = -<NUM_LIT:1><EOL>message = (\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>if Aub_cols > <NUM_LIT:0> and Aub_cols != n:<EOL><INDENT>status = -<NUM_LIT:1><EOL>message = (\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>if status != <NUM_LIT:0>:<EOL><INDENT>raise ValueError(message)<EOL><DEDENT>T = np.zeros([m+<NUM_LIT:2>, n+n_slack+n_artificial+<NUM_LIT:1>])<EOL>T[-<NUM_LIT:2>, :n] = cc<EOL>T[-<NUM_LIT:2>, -<NUM_LIT:1>] = f0<EOL>b = T[:-<NUM_LIT:2>, -<NUM_LIT:1>]<EOL>if meq > <NUM_LIT:0>:<EOL><INDENT>T[:meq, :n] = Aeq<EOL>b[:meq] = beq<EOL><DEDENT>if mub > <NUM_LIT:0>:<EOL><INDENT>T[meq:meq+mub, :n] = Aub<EOL>b[meq:meq+mub] = bub<EOL>np.fill_diagonal(T[meq:m, n:n+n_slack], <NUM_LIT:1>)<EOL><DEDENT>slcount = <NUM_LIT:0><EOL>avcount = <NUM_LIT:0><EOL>basis = np.zeros(m, dtype=int)<EOL>r_artificial = np.zeros(n_artificial, dtype=int)<EOL>for i in range(m):<EOL><INDENT>if i < meq or b[i] < <NUM_LIT:0>:<EOL><INDENT>basis[i] = n+n_slack+avcount<EOL>r_artificial[avcount] = i<EOL>avcount += <NUM_LIT:1><EOL>if b[i] < <NUM_LIT:0>:<EOL><INDENT>b[i] *= -<NUM_LIT:1><EOL>T[i, :-<NUM_LIT:1>] *= -<NUM_LIT:1><EOL><DEDENT>T[i, basis[i]] = <NUM_LIT:1><EOL>T[-<NUM_LIT:1>, basis[i]] = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>basis[i] = n+slcount<EOL>slcount += <NUM_LIT:1><EOL><DEDENT><DEDENT>for r in r_artificial:<EOL><INDENT>T[-<NUM_LIT:1>, :] = T[-<NUM_LIT:1>, :] - T[r, :]<EOL><DEDENT>nit1, status = _solve_simplex(T, n, basis, phase=<NUM_LIT:1>, callback=callback,<EOL>maxiter=maxiter, tol=tol, bland=bland)<EOL>if abs(T[-<NUM_LIT:1>, -<NUM_LIT:1>]) < tol:<EOL><INDENT>T = T[:-<NUM_LIT:1>, :]<EOL>T = np.delete(T, np.s_[n+n_slack:n+n_slack+n_artificial], <NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>status = <NUM_LIT:2><EOL><DEDENT>if status != <NUM_LIT:0>:<EOL><INDENT>message = messages[status]<EOL>if disp:<EOL><INDENT>print(message)<EOL><DEDENT>return OptimizeResult(x=np.nan, fun=-T[-<NUM_LIT:1>, -<NUM_LIT:1>], nit=nit1, status=status,<EOL>message=message, success=False)<EOL><DEDENT>nit2, status = _solve_simplex(T, n, basis, maxiter=maxiter-nit1, phase=<NUM_LIT:2>,<EOL>callback=callback, tol=tol, nit0=nit1,<EOL>bland=bland)<EOL>solution = np.zeros(n+n_slack+n_artificial)<EOL>solution[basis[:m]] = T[:m, -<NUM_LIT:1>]<EOL>x = solution[:n]<EOL>slack = solution[n:n+n_slack]<EOL>masked_L = np.ma.array(L, mask=np.isinf(L), fill_value=<NUM_LIT:0.0>).filled()<EOL>x = x + masked_L<EOL>if have_floor_variable:<EOL><INDENT>for i in range(<NUM_LIT:1>, n):<EOL><INDENT>if np.isinf(L[i]):<EOL><INDENT>x[i] -= x[<NUM_LIT:0>]<EOL><DEDENT><DEDENT>x = x[<NUM_LIT:1>:]<EOL><DEDENT>obj = -T[-<NUM_LIT:1>, -<NUM_LIT:1>]<EOL>if status in (<NUM_LIT:0>, <NUM_LIT:1>):<EOL><INDENT>if disp:<EOL><INDENT>print(messages[status])<EOL>print(\"<STR_LIT>\".format(obj))<EOL>print(\"<STR_LIT>\".format(nit2))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if disp:<EOL><INDENT>print(messages[status])<EOL>print(\"<STR_LIT>\".format(nit2))<EOL><DEDENT><DEDENT>return OptimizeResult(x=x, fun=obj, nit=int(nit2), status=status, slack=slack,<EOL>message=messages[status], success=(status == <NUM_LIT:0>))<EOL>", "docstring": "Solve the following linear programming problem via a two-phase\nsimplex algorithm.\n\nmaximize:     c^T * x\n\nsubject to:   A_ub * x <= b_ub\n              A_eq * x == b_eq\n\nParameters\n----------\nc : array_like\n    Coefficients of the linear objective function to be maximized.\nA_ub :\n    2-D array which, when matrix-multiplied by x, gives the values of the\n    upper-bound inequality constraints at x.\nb_ub : array_like\n    1-D array of values representing the upper-bound of each inequality\n    constraint (row) in A_ub.\nA_eq : array_like\n    2-D array which, when matrix-multiplied by x, gives the values of the\n    equality constraints at x.\nb_eq : array_like\n    1-D array of values representing the RHS of each equality constraint\n    (row) in A_eq.\nbounds : array_like\n    The bounds for each independent variable in the solution, which can take\n    one of three forms::\n    None : The default bounds, all variables are non-negative.\n    (lb, ub) : If a 2-element sequence is provided, the same\n              lower bound (lb) and upper bound (ub) will be applied\n              to all variables.\n    [(lb_0, ub_0), (lb_1, ub_1), ...] : If an n x 2 sequence is provided,\n              each variable x_i will be bounded by lb[i] and ub[i].\n    Infinite bounds are specified using -np.inf (negative)\n    or np.inf (positive).\nmaxiter : int\n   The maximum number of iterations to perform.\ndisp : bool\n    If True, print exit status message to sys.stdout\ncallback : callable\n    If a callback function is provide, it will be called within each\n    iteration of the simplex algorithm. The callback must have the\n    signature `callback(xk, **kwargs)` where xk is the current solution\n    vector and kwargs is a dictionary containing the following::\n    \"tableau\" : The current Simplex algorithm tableau\n    \"nit\" : The current iteration.\n    \"pivot\" : The pivot (row, column) used for the next iteration.\n    \"phase\" : Whether the algorithm is in Phase 1 or Phase 2.\n    \"bv\" : A structured array containing a string representation of each\n           basic variable and its current value.\ntol : float\n    The tolerance which determines when a solution is \"close enough\" to zero\n    in Phase 1 to be considered a basic feasible solution or close enough\n    to positive to to serve as an optimal solution.\nbland : bool\n    If True, use Bland's anti-cycling rule [3] to choose pivots to\n    prevent cycling.  If False, choose pivots which should lead to a\n    converged solution more quickly.  The latter method is subject to\n    cycling (non-convergence) in rare instances.\n\nReturns\n-------\nA scipy.optimize.OptimizeResult consisting of the following fields::\n    x : ndarray\n        The independent variable vector which optimizes the linear\n        programming problem.\n    slack : ndarray\n        The values of the slack variables.  Each slack variable corresponds\n        to an inequality constraint.  If the slack is zero, then the\n        corresponding constraint is active.\n    success : bool\n        Returns True if the algorithm succeeded in finding an optimal\n        solution.\n    status : int\n        An integer representing the exit status of the optimization::\n         0 : Optimization terminated successfully\n         1 : Iteration limit reached\n         2 : Problem appears to be infeasible\n         3 : Problem appears to be unbounded\n    nit : int\n        The number of iterations performed.\n    message : str\n        A string descriptor of the exit status of the optimization.\n\nExamples\n--------\nConsider the following problem:\n\nMinimize: f = -1*x[0] + 4*x[1]\n\nSubject to: -3*x[0] + 1*x[1] <= 6\n             1*x[0] + 2*x[1] <= 4\n                        x[1] >= -3\n\nwhere:  -inf <= x[0] <= inf\n\nThis problem deviates from the standard linear programming problem.  In\nstandard form, linear programming problems assume the variables x are\nnon-negative.  Since the variables don't have standard bounds where\n0 <= x <= inf, the bounds of the variables must be explicitly set.\n\nThere are two upper-bound constraints, which can be expressed as\n\ndot(A_ub, x) <= b_ub\n\nThe input for this problem is as follows:\n\n>>> c = [-1, 4]\n>>> A = [[-3, 1], [1, 2]]\n>>> b = [6, 4]\n>>> x0_bnds = (None, None)\n>>> x1_bnds = (-3, None)\n>>> res = linprog(c, A, b, bounds=(x0_bnds, x1_bnds), options={\"disp\":True})\n>>> print(res)\nOptimization terminated successfully.\n     Current function value: 11.428571\n     Iterations: 2\nstatus: 0\nsuccess: True\nfun: 11.428571428571429\nx: array([-1.14285714,  2.57142857])\nslack: array([], dtype=np.float64)\nmessage: 'Optimization terminated successfully.'\nnit: 2\n\nReferences\n----------\n.. [1] Dantzig, George B., Linear programming and extensions. Rand\n       Corporation Research Study Princeton Univ. Press, Princeton, NJ, 1963\n.. [2] Hillier, S.H. and Lieberman, G.J. (1995), \"Introduction to\n       Mathematical Programming\", McGraw-Hill, Chapter 4.\n.. [3] Bland, Robert G. New finite pivoting rules for the simplex method.\n       Mathematics of Operations Research (2), 1977: pp. 103-107.", "id": "f19417:m5"}
{"signature": "def linprog_terse_callback(xk, **kwargs):", "body": "nit = kwargs[\"<STR_LIT>\"]<EOL>if nit == <NUM_LIT:0>:<EOL><INDENT>print(\"<STR_LIT>\")<EOL><DEDENT>print(\"<STR_LIT>\".format(nit), end=\"<STR_LIT>\")<EOL>print(xk)<EOL>", "docstring": "A sample callback function demonstrating the linprog callback interface.\nThis callback produces brief output to sys.stdout before each iteration\nand after the final iteration of the simplex algorithm.\n\nParameters\n----------\nxk : array_like\n    The current solution vector.\n**kwargs : dict\n    A dictionary containing the following parameters:\n\n    tableau : array_like\n        The current tableau of the simplex algorithm.\n        Its structure is defined in _solve_simplex.\n    vars : tuple(str, ...)\n        Column headers for each column in tableau.\n        \"x[i]\" for actual variables, \"s[i]\" for slack surplus variables,\n        \"a[i]\" for artificial variables, and \"RHS\" for the constraint\n        RHS vector.\n    phase : int\n        The current Phase of the simplex algorithm (1 or 2)\n    nit : int\n        The current iteration number.\n    pivot : tuple(int, int)\n        The index of the tableau selected as the next pivot,\n        or nan if no pivot exists\n    basics : list[tuple(int, float)]\n        A list of the current basic variables.\n        Each element contains the index of a basic variable and\n        its value.\n    complete : bool\n        True if the simplex algorithm has completed\n        (and this is the final call to callback), otherwise False.", "id": "f19417:m1"}
{"signature": "def _pivot_row(T, pivcol, phase, tol=<NUM_LIT>):", "body": "if phase == <NUM_LIT:1>:<EOL><INDENT>k = <NUM_LIT:2><EOL><DEDENT>else:<EOL><INDENT>k = <NUM_LIT:1><EOL><DEDENT>ma = np.ma.masked_where(T[:-k, pivcol] <= tol, T[:-k, pivcol], copy=False)<EOL>if ma.count() == <NUM_LIT:0>:<EOL><INDENT>return False, np.nan<EOL><DEDENT>mb = np.ma.masked_where(T[:-k, pivcol] <= tol, T[:-k, -<NUM_LIT:1>], copy=False)<EOL>q = mb / ma<EOL>return True, np.ma.where(q == q.min())[<NUM_LIT:0>][<NUM_LIT:0>]<EOL>", "docstring": "Given a linear programming simplex tableau, determine the row for the\npivot operation.\n\nParameters\n----------\nT : 2D ndarray\n    The simplex tableau.\npivcol : int\n    The index of the pivot column.\nphase : int\n    The phase of the simplex algorithm (1 or 2).\ntol : float\n    Elements in the pivot column smaller than tol will not be considered\n    for pivoting.  Nominally this value is zero, but numerical issues\n    cause a tolerance about zero to be necessary.\n\nReturns\n-------\nstatus: bool\n    True if a suitable pivot row was found, otherwise False.  A return\n    of False indicates that the linear programming problem is unbounded.\nrow: int\n    The index of the row of the pivot element.  If status is False, row\n    will be returned as nan.", "id": "f19417:m3"}
{"signature": "def newton(func, x0, fprime=None, args=(), tol=<NUM_LIT>, maxiter=<NUM_LIT:50>,<EOL>fprime2=None):", "body": "if tol <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % tol)<EOL><DEDENT>if fprime is not None:<EOL><INDENT>p0 = <NUM_LIT:1.0> * x0<EOL>fder2 = <NUM_LIT:0><EOL>for iter in range(maxiter):<EOL><INDENT>myargs = (p0,) + args<EOL>fder = fprime(*myargs)<EOL>if fder == <NUM_LIT:0>:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>warnings.warn(msg, RuntimeWarning)<EOL>return p0<EOL><DEDENT>fval = func(*myargs)<EOL>if fprime2 is not None:<EOL><INDENT>fder2 = fprime2(*myargs)<EOL><DEDENT>if fder2 == <NUM_LIT:0>:<EOL><INDENT>p = p0 - fval / fder<EOL><DEDENT>else:<EOL><INDENT>discr = fder ** <NUM_LIT:2> - <NUM_LIT:2> * fval * fder2<EOL>if discr < <NUM_LIT:0>:<EOL><INDENT>p = p0 - fder / fder2<EOL><DEDENT>else:<EOL><INDENT>p = p0 - <NUM_LIT:2>*fval / (fder + sign(fder) * sqrt(discr))<EOL><DEDENT><DEDENT>if abs(p - p0) < tol:<EOL><INDENT>return p<EOL><DEDENT>p0 = p<EOL><DEDENT><DEDENT>else:<EOL><INDENT>p0 = x0<EOL>if x0 >= <NUM_LIT:0>:<EOL><INDENT>p1 = x0*(<NUM_LIT:1> + <NUM_LIT>) + <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>p1 = x0*(<NUM_LIT:1> + <NUM_LIT>) - <NUM_LIT><EOL><DEDENT>q0 = func(*((p0,) + args))<EOL>q1 = func(*((p1,) + args))<EOL>for iter in range(maxiter):<EOL><INDENT>if q1 == q0:<EOL><INDENT>if p1 != p0:<EOL><INDENT>msg = \"<STR_LIT>\" % (p1 - p0)<EOL>warnings.warn(msg, RuntimeWarning)<EOL><DEDENT>return (p1 + p0)/<NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>p = p1 - q1*(p1 - p0)/(q1 - q0)<EOL><DEDENT>if abs(p - p1) < tol:<EOL><INDENT>return p<EOL><DEDENT>p0 = p1<EOL>q0 = q1<EOL>p1 = p<EOL>q1 = func(*((p1,) + args))<EOL><DEDENT><DEDENT>msg = \"<STR_LIT>\" % (maxiter, p)<EOL>raise RuntimeError(msg)<EOL>", "docstring": "Find a zero using the Newton-Raphson or secant method.\n\nFind a zero of the function `func` given a nearby starting point `x0`.\nThe Newton-Raphson method is used if the derivative `fprime` of `func`\nis provided, otherwise the secant method is used.  If the second order\nderivate `fprime2` of `func` is provided, parabolic Halley's method\nis used.\n\nParameters\n----------\nfunc : function\n    The function whose zero is wanted. It must be a function of a\n    single variable of the form f(x,a,b,c...), where a,b,c... are extra\n    arguments that can be passed in the `args` parameter.\nx0 : float\n    An initial estimate of the zero that should be somewhere near the\n    actual zero.\nfprime : function, optional\n    The derivative of the function when available and convenient. If it\n    is None (default), then the secant method is used.\nargs : tuple, optional\n    Extra arguments to be used in the function call.\ntol : float, optional\n    The allowable error of the zero value.\nmaxiter : int, optional\n    Maximum number of iterations.\nfprime2 : function, optional\n    The second order derivative of the function when available and\n    convenient. If it is None (default), then the normal Newton-Raphson\n    or the secant method is used. If it is given, parabolic Halley's\n    method is used.\n\nReturns\n-------\nzero : float\n    Estimated location where function is zero.\n\nSee Also\n--------\nbrentq, brenth, ridder, bisect\nfsolve : find zeroes in n dimensions.\n\nNotes\n-----\nThe convergence rate of the Newton-Raphson method is quadratic,\nthe Halley method is cubic, and the secant method is\nsub-quadratic.  This means that if the function is well behaved\nthe actual error in the estimated zero is approximately the square\n(cube for Halley) of the requested tolerance up to roundoff\nerror. However, the stopping criterion used here is the step size\nand there is no guarantee that a zero has been found. Consequently\nthe result should be verified. Safer algorithms are brentq,\nbrenth, ridder, and bisect, but they all require that the root\nfirst be bracketed in an interval where the function changes\nsign. The brentq algorithm is recommended for general use in one\ndimensional problems when such an interval has been found.", "id": "f19418:m1"}
{"signature": "def _scale_parameters(self, trial):", "body": "return self.__scale_arg1 + (trial - <NUM_LIT:0.5>) * self.__scale_arg2<EOL>", "docstring": "scale from a number between 0 and 1 to parameters", "id": "f19421:c0:m5"}
{"signature": "def _best2(self, samples):", "body": "r0, r1, r2, r3 = samples[:<NUM_LIT:4>]<EOL>bprime = (self.population[<NUM_LIT:0>] + self.scale *<EOL>(self.population[r0] + self.population[r1]<EOL>- self.population[r2] - self.population[r3]))<EOL>return bprime<EOL>", "docstring": "best2bin, best2exp", "id": "f19421:c0:m12"}
{"signature": "def _select_samples(self, candidate, number_samples):", "body": "idxs = list(range(np.size(self.population, <NUM_LIT:0>)))<EOL>idxs.remove(candidate)<EOL>self.random_number_generator.shuffle(idxs)<EOL>idxs = idxs[:number_samples]<EOL>return idxs<EOL>", "docstring": "obtain random integers from range(np.size(self.population, 0)),\nwithout replacement.  You can't have the original candidate either.", "id": "f19421:c0:m14"}
{"signature": "def init_population_random(self):", "body": "rng = self.random_number_generator<EOL>self.population = rng.random_sample(self.population.shape)<EOL>", "docstring": "Initialises the population at random.  This type of initialization\ncan possess clustering, Latin Hypercube sampling is generally better.", "id": "f19421:c0:m2"}
{"signature": "@property<EOL><INDENT>def x(self):<DEDENT>", "body": "return self._scale_parameters(self.population[<NUM_LIT:0>])<EOL>", "docstring": "The best solution from the solver\n\nReturns\n-------\nx - ndarray\n    The best solution from the solver.", "id": "f19421:c0:m3"}
{"signature": "def leastsq(func, x0, args=(), Dfun=None, full_output=<NUM_LIT:0>,<EOL>col_deriv=<NUM_LIT:0>, ftol=<NUM_LIT>, xtol=<NUM_LIT>,<EOL>gtol=<NUM_LIT:0.0>, maxfev=<NUM_LIT:0>, epsfcn=None, factor=<NUM_LIT:100>, diag=None):", "body": "x0 = asarray(x0).flatten()<EOL>n = len(x0)<EOL>if not isinstance(args, tuple):<EOL><INDENT>args = (args,)<EOL><DEDENT>shape, dtype = _check_func('<STR_LIT>', '<STR_LIT>', func, x0, args, n)<EOL>m = shape[<NUM_LIT:0>]<EOL>if n > m:<EOL><INDENT>raise TypeError('<STR_LIT>' % (n, m))<EOL><DEDENT>if epsfcn is None:<EOL><INDENT>epsfcn = finfo(dtype).eps<EOL><DEDENT>if Dfun is None:<EOL><INDENT>if maxfev == <NUM_LIT:0>:<EOL><INDENT>maxfev = <NUM_LIT:200>*(n + <NUM_LIT:1>)<EOL><DEDENT>retval = _minpack._lmdif(func, x0, args, full_output, ftol, xtol,<EOL>gtol, maxfev, epsfcn, factor, diag)<EOL><DEDENT>else:<EOL><INDENT>if col_deriv:<EOL><INDENT>_check_func('<STR_LIT>', '<STR_LIT>', Dfun, x0, args, n, (n, m))<EOL><DEDENT>else:<EOL><INDENT>_check_func('<STR_LIT>', '<STR_LIT>', Dfun, x0, args, n, (m, n))<EOL><DEDENT>if maxfev == <NUM_LIT:0>:<EOL><INDENT>maxfev = <NUM_LIT:100> * (n + <NUM_LIT:1>)<EOL><DEDENT>retval = _minpack._lmder(func, Dfun, x0, args, full_output, col_deriv,<EOL>ftol, xtol, gtol, maxfev, factor, diag)<EOL><DEDENT>errors = {<NUM_LIT:0>: [\"<STR_LIT>\", TypeError],<EOL><NUM_LIT:1>: [\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % ftol, None],<EOL><NUM_LIT:2>: [\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % xtol, None],<EOL><NUM_LIT:3>: [\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (ftol, xtol), None],<EOL><NUM_LIT:4>: [\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % gtol, None],<EOL><NUM_LIT:5>: [\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % maxfev, ValueError],<EOL><NUM_LIT:6>: [\"<STR_LIT>\"<EOL>\"<STR_LIT>\"\"<STR_LIT>\" % ftol,<EOL>ValueError],<EOL><NUM_LIT:7>: [\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % xtol,<EOL>ValueError],<EOL><NUM_LIT:8>: [\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % gtol, ValueError],<EOL>'<STR_LIT>': [\"<STR_LIT>\", TypeError]}<EOL>info = retval[-<NUM_LIT:1>]    <EOL>if info not in [<NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:3>, <NUM_LIT:4>] and not full_output:<EOL><INDENT>if info in [<NUM_LIT:5>, <NUM_LIT:6>, <NUM_LIT:7>, <NUM_LIT:8>]:<EOL><INDENT>warnings.warn(errors[info][<NUM_LIT:0>], RuntimeWarning)<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>raise errors[info][<NUM_LIT:1>](errors[info][<NUM_LIT:0>])<EOL><DEDENT>except KeyError:<EOL><INDENT>raise errors['<STR_LIT>'][<NUM_LIT:1>](errors['<STR_LIT>'][<NUM_LIT:0>])<EOL><DEDENT><DEDENT><DEDENT>mesg = errors[info][<NUM_LIT:0>]<EOL>if full_output:<EOL><INDENT>cov_x = None<EOL>if info in [<NUM_LIT:1>, <NUM_LIT:2>, <NUM_LIT:3>, <NUM_LIT:4>]:<EOL><INDENT>from numpy.dual import inv<EOL>from numpy.linalg import LinAlgError<EOL>perm = take(eye(n), retval[<NUM_LIT:1>]['<STR_LIT>'] - <NUM_LIT:1>, <NUM_LIT:0>)<EOL>r = triu(transpose(retval[<NUM_LIT:1>]['<STR_LIT>'])[:n, :])<EOL>R = dot(r, perm)<EOL>try:<EOL><INDENT>cov_x = inv(dot(transpose(R), R))<EOL><DEDENT>except (LinAlgError, ValueError):<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return (retval[<NUM_LIT:0>], cov_x) + retval[<NUM_LIT:1>:-<NUM_LIT:1>] + (mesg, info)<EOL><DEDENT>else:<EOL><INDENT>return (retval[<NUM_LIT:0>], info)<EOL><DEDENT>", "docstring": "Minimize the sum of squares of a set of equations.\n\n::\n\n    x = arg min(sum(func(y)**2,axis=0))\n             y\n\nParameters\n----------\nfunc : callable\n    should take at least one (possibly length N vector) argument and\n    returns M floating point numbers. It must not return NaNs or\n    fitting might fail.\nx0 : ndarray\n    The starting estimate for the minimization.\nargs : tuple\n    Any extra arguments to func are placed in this tuple.\nDfun : callable\n    A function or method to compute the Jacobian of func with derivatives\n    across the rows. If this is None, the Jacobian will be estimated.\nfull_output : bool\n    non-zero to return all optional outputs.\ncol_deriv : bool\n    non-zero to specify that the Jacobian function computes derivatives\n    down the columns (faster, because there is no transpose operation).\nftol : float\n    Relative error desired in the sum of squares.\nxtol : float\n    Relative error desired in the approximate solution.\ngtol : float\n    Orthogonality desired between the function vector and the columns of\n    the Jacobian.\nmaxfev : int\n    The maximum number of calls to the function. If zero, then 100*(N+1) is\n    the maximum where N is the number of elements in x0.\nepsfcn : float\n    A variable used in determining a suitable step length for the forward-\n    difference approximation of the Jacobian (for Dfun=None). \n    Normally the actual step length will be sqrt(epsfcn)*x\n    If epsfcn is less than the machine precision, it is assumed that the \n    relative errors are of the order of the machine precision.\nfactor : float\n    A parameter determining the initial step bound\n    (``factor * || diag * x||``). Should be in interval ``(0.1, 100)``.\ndiag : sequence\n    N positive entries that serve as a scale factors for the variables.\n\nReturns\n-------\nx : ndarray\n    The solution (or the result of the last iteration for an unsuccessful\n    call).\ncov_x : ndarray\n    Uses the fjac and ipvt optional outputs to construct an\n    estimate of the jacobian around the solution. None if a\n    singular matrix encountered (indicates very flat curvature in\n    some direction).  This matrix must be multiplied by the\n    residual variance to get the covariance of the\n    parameter estimates -- see curve_fit.\ninfodict : dict\n    a dictionary of optional outputs with the key s:\n\n    ``nfev``\n        The number of function calls\n    ``fvec``\n        The function evaluated at the output\n    ``fjac``\n        A permutation of the R matrix of a QR\n        factorization of the final approximate\n        Jacobian matrix, stored column wise.\n        Together with ipvt, the covariance of the\n        estimate can be approximated.\n    ``ipvt``\n        An integer array of length N which defines\n        a permutation matrix, p, such that\n        fjac*p = q*r, where r is upper triangular\n        with diagonal elements of nonincreasing\n        magnitude. Column j of p is column ipvt(j)\n        of the identity matrix.\n    ``qtf``\n        The vector (transpose(q) * fvec).\n\nmesg : str\n    A string message giving information about the cause of failure.\nier : int\n    An integer flag.  If it is equal to 1, 2, 3 or 4, the solution was\n    found.  Otherwise, the solution was not found. In either case, the\n    optional output variable 'mesg' gives more information.\n\nNotes\n-----\n\"leastsq\" is a wrapper around MINPACK's lmdif and lmder algorithms.\n\ncov_x is a Jacobian approximation to the Hessian of the least squares\nobjective function.\nThis approximation assumes that the objective function is based on the\ndifference between some observed target data (ydata) and a (non-linear)\nfunction of the parameters `f(xdata, params)` ::\n\n       func(params) = ydata - f(xdata, params)\n\nso that the objective function is ::\n\n       min   sum((ydata - f(xdata, params))**2, axis=0)\n     params", "id": "f19422:m3"}
{"signature": "def fsolve(func, x0, args=(), fprime=None, full_output=<NUM_LIT:0>,<EOL>col_deriv=<NUM_LIT:0>, xtol=<NUM_LIT>, maxfev=<NUM_LIT:0>, band=None,<EOL>epsfcn=None, factor=<NUM_LIT:100>, diag=None):", "body": "options = {'<STR_LIT>': col_deriv,<EOL>'<STR_LIT>': xtol,<EOL>'<STR_LIT>': maxfev,<EOL>'<STR_LIT>': band,<EOL>'<STR_LIT>': epsfcn,<EOL>'<STR_LIT>': factor,<EOL>'<STR_LIT>': diag,<EOL>'<STR_LIT>': full_output}<EOL>res = _root_hybr(func, x0, args, jac=fprime, **options)<EOL>if full_output:<EOL><INDENT>x = res['<STR_LIT:x>']<EOL>info = dict((k, res.get(k))<EOL>for k in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:r>', '<STR_LIT>') if k in res)<EOL>info['<STR_LIT>'] = res['<STR_LIT>']<EOL>return x, info, res['<STR_LIT:status>'], res['<STR_LIT:message>']<EOL><DEDENT>else:<EOL><INDENT>return res['<STR_LIT:x>']<EOL><DEDENT>", "docstring": "Find the roots of a function.\n\nReturn the roots of the (non-linear) equations defined by\n``func(x) = 0`` given a starting estimate.\n\nParameters\n----------\nfunc : callable ``f(x, *args)``\n    A function that takes at least one (possibly vector) argument.\nx0 : ndarray\n    The starting estimate for the roots of ``func(x) = 0``.\nargs : tuple, optional\n    Any extra arguments to `func`.\nfprime : callable(x), optional\n    A function to compute the Jacobian of `func` with derivatives\n    across the rows. By default, the Jacobian will be estimated.\nfull_output : bool, optional\n    If True, return optional outputs.\ncol_deriv : bool, optional\n    Specify whether the Jacobian function computes derivatives down\n    the columns (faster, because there is no transpose operation).\nxtol : float\n    The calculation will terminate if the relative error between two\n    consecutive iterates is at most `xtol`.\nmaxfev : int, optional\n    The maximum number of calls to the function. If zero, then\n    ``100*(N+1)`` is the maximum where N is the number of elements\n    in `x0`.\nband : tuple, optional\n    If set to a two-sequence containing the number of sub- and\n    super-diagonals within the band of the Jacobi matrix, the\n    Jacobi matrix is considered banded (only for ``fprime=None``).\nepsfcn : float, optional\n    A suitable step length for the forward-difference\n    approximation of the Jacobian (for ``fprime=None``). If\n    `epsfcn` is less than the machine precision, it is assumed\n    that the relative errors in the functions are of the order of\n    the machine precision.\nfactor : float, optional\n    A parameter determining the initial step bound\n    (``factor * || diag * x||``).  Should be in the interval\n    ``(0.1, 100)``.\ndiag : sequence, optional\n    N positive entries that serve as a scale factors for the\n    variables.\n\nReturns\n-------\nx : ndarray\n    The solution (or the result of the last iteration for\n    an unsuccessful call).\ninfodict : dict\n    A dictionary of optional outputs with the keys:\n\n    ``nfev``\n        number of function calls\n    ``njev``\n        number of Jacobian calls\n    ``fvec``\n        function evaluated at the output\n    ``fjac``\n        the orthogonal matrix, q, produced by the QR\n        factorization of the final approximate Jacobian\n        matrix, stored column wise\n    ``r``\n        upper triangular matrix produced by QR factorization\n        of the same matrix\n    ``qtf``\n        the vector ``(transpose(q) * fvec)``\n\nier : int\n    An integer flag.  Set to 1 if a solution was found, otherwise refer\n    to `mesg` for more information.\nmesg : str\n    If no solution is found, `mesg` details the cause of failure.\n\nSee Also\n--------\nroot : Interface to root finding algorithms for multivariate\nfunctions. See the 'hybr' `method` in particular.\n\nNotes\n-----\n``fsolve`` is a wrapper around MINPACK's hybrd and hybrj algorithms.", "id": "f19422:m1"}
{"signature": "def approx_jacobian(x,func,epsilon,*args):", "body": "x0 = asfarray(x)<EOL>f0 = atleast_1d(func(*((x0,)+args)))<EOL>jac = zeros([len(x0),len(f0)])<EOL>dx = zeros(len(x0))<EOL>for i in range(len(x0)):<EOL><INDENT>dx[i] = epsilon<EOL>jac[i] = (func(*((x0+dx,)+args)) - f0)/epsilon<EOL>dx[i] = <NUM_LIT:0.0><EOL><DEDENT>return jac.transpose()<EOL>", "docstring": "Approximate the Jacobian matrix of a callable function.\n\nParameters\n----------\nx : array_like\n    The state vector at which to compute the Jacobian matrix.\nfunc : callable f(x,*args)\n    The vector-valued function.\nepsilon : float\n    The perturbation used to determine the partial derivatives.\nargs : sequence\n    Additional arguments passed to func.\n\nReturns\n-------\nAn array of dimensions ``(lenf, lenx)`` where ``lenf`` is the length\nof the outputs of `func`, and ``lenx`` is the number of elements in\n`x`.\n\nNotes\n-----\nThe approximation is done using forward differences.", "id": "f19426:m0"}
{"signature": "def fourier_shift(input, shift, n=-<NUM_LIT:1>, axis=-<NUM_LIT:1>, output=None):", "body": "input = numpy.asarray(input)<EOL>output, return_value = _get_output_fourier_complex(output, input)<EOL>axis = _ni_support._check_axis(axis, input.ndim)<EOL>shifts = _ni_support._normalize_sequence(shift, input.ndim)<EOL>shifts = numpy.asarray(shifts, dtype=numpy.float64)<EOL>if not shifts.flags.contiguous:<EOL><INDENT>shifts = shifts.copy()<EOL><DEDENT>_nd_image.fourier_shift(input, shifts, n, axis, output)<EOL>return return_value<EOL>", "docstring": "Multi-dimensional fourier shift filter.\n\nThe array is multiplied with the fourier transform of a shift operation.\n\nParameters\n----------\ninput : array_like\n    The input array.\nshift : float or sequence\n    The size of the box used for filtering.\n    If a float, `shift` is the same for all axes. If a sequence, `shift`\n    has to contain one value for each axis.\nn : int, optional\n    If `n` is negative (default), then the input is assumed to be the\n    result of a complex fft.\n    If `n` is larger than or equal to zero, the input is assumed to be the\n    result of a real fft, and `n` gives the length of the array before\n    transformation along the real transform direction.\naxis : int, optional\n    The axis of the real transform.\noutput : ndarray, optional\n    If given, the result of shifting the input is placed in this array.\n    None is returned in this case.\n\nReturns\n-------\nfourier_shift : ndarray or None\n    The shifted input. If `output` is given as a parameter, None is\n    returned.", "id": "f19427:m5"}
{"signature": "def fourier_gaussian(input, sigma, n=-<NUM_LIT:1>, axis=-<NUM_LIT:1>, output=None):", "body": "input = numpy.asarray(input)<EOL>output, return_value = _get_output_fourier(output, input)<EOL>axis = _ni_support._check_axis(axis, input.ndim)<EOL>sigmas = _ni_support._normalize_sequence(sigma, input.ndim)<EOL>sigmas = numpy.asarray(sigmas, dtype=numpy.float64)<EOL>if not sigmas.flags.contiguous:<EOL><INDENT>sigmas = sigmas.copy()<EOL><DEDENT>_nd_image.fourier_filter(input, sigmas, n, axis, output, <NUM_LIT:0>)<EOL>return return_value<EOL>", "docstring": "Multi-dimensional Gaussian fourier filter.\n\nThe array is multiplied with the fourier transform of a Gaussian\nkernel.\n\nParameters\n----------\ninput : array_like\n    The input array.\nsigma : float or sequence\n    The sigma of the Gaussian kernel. If a float, `sigma` is the same for\n    all axes. If a sequence, `sigma` has to contain one value for each\n    axis.\nn : int, optional\n    If `n` is negative (default), then the input is assumed to be the\n    result of a complex fft.\n    If `n` is larger than or equal to zero, the input is assumed to be the\n    result of a real fft, and `n` gives the length of the array before\n    transformation along the real transform direction.\naxis : int, optional\n    The axis of the real transform.\noutput : ndarray, optional\n    If given, the result of filtering the input is placed in this array.\n    None is returned in this case.\n\nReturns\n-------\nfourier_gaussian : ndarray or None\n    The filtered input. If `output` is given as a parameter, None is\n    returned.", "id": "f19427:m2"}
{"signature": "def median(input, labels=None, index=None):", "body": "return _select(input, labels, index, find_median=True)[<NUM_LIT:0>]<EOL>", "docstring": "Calculate the median of the values of an array over labeled regions.\n\nParameters\n----------\ninput : array_like\n    Array_like of values. For each region specified by `labels`, the\n    median value of `input` over the region is computed.\nlabels : array_like, optional\n    An array_like of integers marking different regions over which the\n    median value of `input` is to be computed. `labels` must have the\n    same shape as `input`. If `labels` is not specified, the median\n    over the whole array is returned.\nindex : array_like, optional\n    A list of region labels that are taken into account for computing the\n    medians. If index is None, the median over all elements where `labels`\n    is non-zero is returned.\n\nReturns\n-------\nmedian : float or list of floats\n    List of medians of `input` over the regions determined by `labels` and\n    whose index is in `index`. If `index` or `labels` are not specified, a\n    float is returned: the median value of `input` if `labels` is None,\n    and the median value of elements where `labels` is greater than zero\n    if `index` is None.\n\nSee also\n--------\nlabel, minimum, maximum, extrema, sum, mean, variance, standard_deviation\n\nNotes\n-----\nThe function returns a Python list and not a Numpy array, use\n`np.array` to convert the list to an array.\n\nExamples\n--------\n>>> a = np.array([[1, 2, 0, 1],\n...               [5, 3, 0, 4],\n...               [0, 0, 0, 7],\n...               [9, 3, 0, 0]])\n>>> labels, labels_nb = ndimage.label(a)\n>>> labels\narray([[1, 1, 0, 2],\n       [1, 1, 0, 2],\n       [0, 0, 0, 2],\n       [3, 3, 0, 0]])\n>>> ndimage.median(a, labels=labels, index=np.arange(1, labels_nb + 1))\n[2.5, 4.0, 6.0]\n>>> ndimage.median(a)\n1.0\n>>> ndimage.median(a, labels=labels)\n3.0", "id": "f19434:m12"}
{"signature": "def center_of_mass(input, labels=None, index=None):", "body": "normalizer = sum(input, labels, index)<EOL>grids = numpy.ogrid[[slice(<NUM_LIT:0>, i) for i in input.shape]]<EOL>results = [sum(input * grids[dir].astype(float), labels, index) / normalizer<EOL>for dir in range(input.ndim)]<EOL>if numpy.isscalar(results[<NUM_LIT:0>]):<EOL><INDENT>return tuple(results)<EOL><DEDENT>return [tuple(v) for v in numpy.array(results).T]<EOL>", "docstring": "Calculate the center of mass of the values of an array at labels.\n\nParameters\n----------\ninput : ndarray\n    Data from which to calculate center-of-mass.\nlabels : ndarray, optional\n    Labels for objects in `input`, as generated by `ndimage.label`.\n    Only used with `index`.  Dimensions must be the same as `input`.\nindex : int or sequence of ints, optional\n    Labels for which to calculate centers-of-mass. If not specified,\n    all labels greater than zero are used.  Only used with `labels`.\n\nReturns\n-------\ncenter_of_mass : tuple, or list of tuples\n    Coordinates of centers-of-mass.\n\nExamples\n--------\n>>> a = np.array(([0,0,0,0],\n                  [0,1,1,0],\n                  [0,1,1,0],\n                  [0,1,1,0]))\n>>> from scipy import ndimage\n>>> ndimage.measurements.center_of_mass(a)\n(2.0, 1.5)\n\nCalculation of multiple objects in an image\n\n>>> b = np.array(([0,1,1,0],\n                  [0,1,0,0],\n                  [0,0,0,0],\n                  [0,0,1,1],\n                  [0,0,1,1]))\n>>> lbl = ndimage.label(b)[0]\n>>> ndimage.measurements.center_of_mass(b, lbl, [1,2])\n[(0.33333333333333331, 1.3333333333333333), (3.5, 2.5)]", "id": "f19434:m16"}
{"signature": "def labeled_comprehension(input, labels, index, func, out_dtype, default, pass_positions=False):", "body": "as_scalar = numpy.isscalar(index)<EOL>input = numpy.asarray(input)<EOL>if pass_positions:<EOL><INDENT>positions = numpy.arange(input.size).reshape(input.shape)<EOL><DEDENT>if labels is None:<EOL><INDENT>if index is not None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not pass_positions:<EOL><INDENT>return func(input.ravel())<EOL><DEDENT>else:<EOL><INDENT>return func(input.ravel(), positions.ravel())<EOL><DEDENT><DEDENT>try:<EOL><INDENT>input, labels = numpy.broadcast_arrays(input, labels)<EOL><DEDENT>except ValueError:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>if index is None:<EOL><INDENT>if not pass_positions:<EOL><INDENT>return func(input[labels > <NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>return func(input[labels > <NUM_LIT:0>], positions[labels > <NUM_LIT:0>])<EOL><DEDENT><DEDENT>index = numpy.atleast_1d(index)<EOL>if np.any(index.astype(labels.dtype).astype(index.dtype) != index):<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" %<EOL>(index.dtype, labels.dtype))<EOL><DEDENT>index = index.astype(labels.dtype)<EOL>lo = index.min()<EOL>hi = index.max()<EOL>mask = (labels >= lo) & (labels <= hi)<EOL>labels = labels[mask]<EOL>input = input[mask]<EOL>if pass_positions:<EOL><INDENT>positions = positions[mask]<EOL><DEDENT>label_order = labels.argsort()<EOL>labels = labels[label_order]<EOL>input = input[label_order]<EOL>if pass_positions:<EOL><INDENT>positions = positions[label_order]<EOL><DEDENT>index_order = index.argsort()<EOL>sorted_index = index[index_order]<EOL>def do_map(inputs, output):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>nidx = sorted_index.size<EOL>lo = numpy.searchsorted(labels, sorted_index, side='<STR_LIT:left>')<EOL>hi = numpy.searchsorted(labels, sorted_index, side='<STR_LIT:right>')<EOL>for i, l, h in zip(range(nidx), lo, hi):<EOL><INDENT>if l == h:<EOL><INDENT>continue<EOL><DEDENT>output[i] = func(*[inp[l:h] for inp in inputs])<EOL><DEDENT><DEDENT>temp = numpy.empty(index.shape, out_dtype)<EOL>temp[:] = default<EOL>if not pass_positions:<EOL><INDENT>do_map([input], temp)<EOL><DEDENT>else:<EOL><INDENT>do_map([input, positions], temp)<EOL><DEDENT>output = numpy.zeros(index.shape, out_dtype)<EOL>output[index_order] = temp<EOL>if as_scalar:<EOL><INDENT>output = output[<NUM_LIT:0>]<EOL><DEDENT>return output<EOL>", "docstring": "Roughly equivalent to [func(input[labels == i]) for i in index].\n\nSequentially applies an arbitrary function (that works on array_like input)\nto subsets of an n-D image array specified by `labels` and `index`.\nThe option exists to provide the function with positional parameters as the\nsecond argument.\n\nParameters\n----------\ninput : array_like\n    Data from which to select `labels` to process.\nlabels : array_like or None\n    Labels to objects in `input`.\n    If not None, array must be same shape as `input`.\n    If None, `func` is applied to raveled `input`.\nindex : int, sequence of ints or None\n    Subset of `labels` to which to apply `func`.\n    If a scalar, a single value is returned.\n    If None, `func` is applied to all non-zero values of `labels`.\nfunc : callable\n    Python function to apply to `labels` from `input`.\nout_dtype : dtype\n    Dtype to use for `result`.\ndefault : int, float or None\n    Default return value when a element of `index` does not exist\n    in `labels`.\npass_positions : bool, optional\n    If True, pass linear indices to `func` as a second argument.\n    Default is False.\n\nReturns\n-------\nresult : ndarray\n    Result of applying `func` to each of `labels` to `input` in `index`.\n\nExamples\n--------\n>>> a = np.array([[1, 2, 0, 0],\n                  [5, 3, 0, 4],\n                  [0, 0, 0, 7],\n                  [9, 3, 0, 0]])\n>>> from scipy import ndimage\n>>> lbl, nlbl = ndimage.label(a)\n>>> lbls = np.arange(1, nlbl+1)\n>>> ndimage.labeled_comprehension(a, lbl, lbls, np.mean, float, 0)\narray([ 2.75,  5.5 ,  6.  ])\n\nFalling back to `default`:\n\n>>> lbls = np.arange(1, nlbl+2)\n>>> ndimage.labeled_comprehension(a, lbl, lbls, np.mean, float, -1)\narray([ 2.75,  5.5 ,  6.  , -1.  ])\n\nPassing positions:\n\n>>> def fn(val, pos):\n...     print(\"fn says: %s : %s\" % (val, pos))\n...     return (val.sum()) if (pos.sum() % 2 == 0) else (-val.sum())\n...\n>>> ndimage.labeled_comprehension(a, lbl, lbls, fn, float, 0, True)\nfn says: [1 2 5 3] : [0 1 4 5]\nfn says: [4 7] : [7 11]\nfn says: [9 3] : [12 13]\narray([ 11.,  11., -12.])", "id": "f19434:m2"}
{"signature": "def minimum_position(input, labels=None, index=None):", "body": "dims = numpy.array(numpy.asarray(input).shape)<EOL>dim_prod = numpy.cumprod([<NUM_LIT:1>] + list(dims[:<NUM_LIT:0>:-<NUM_LIT:1>]))[::-<NUM_LIT:1>]<EOL>result = _select(input, labels, index, find_min_positions=True)[<NUM_LIT:0>]<EOL>if numpy.isscalar(result):<EOL><INDENT>return tuple((result // dim_prod) % dims)<EOL><DEDENT>return [tuple(v) for v in (result.reshape(-<NUM_LIT:1>, <NUM_LIT:1>) // dim_prod) % dims]<EOL>", "docstring": "Find the positions of the minimums of the values of an array at labels.\n\nParameters\n----------\ninput : array_like\n    Array_like of values.\nlabels : array_like, optional\n    An array of integers marking different regions over which the\n    position of the minimum value of `input` is to be computed.\n    `labels` must have the same shape as `input`. If `labels` is not\n    specified, the location of the first minimum over the whole\n    array is returned.\n\n    The `labels` argument only works when `index` is specified.\nindex : array_like, optional\n    A list of region labels that are taken into account for finding the\n    location of the minima. If `index` is None, the ``first`` minimum\n    over all elements where `labels` is non-zero is returned.\n\n    The `index` argument only works when `labels` is specified.\n\nReturns\n-------\noutput : list of tuples of ints\n    Tuple of ints or list of tuples of ints that specify the location\n    of minima of `input` over the regions determined by `labels` and\n    whose index is in `index`.\n\n    If `index` or `labels` are not specified, a tuple of ints is\n    returned specifying the location of the first minimal value of `input`.\n\nSee also\n--------\nlabel, minimum, median, maximum_position, extrema, sum, mean, variance,\nstandard_deviation", "id": "f19434:m13"}
{"signature": "def label(input, structure=None, output=None):", "body": "input = numpy.asarray(input)<EOL>if numpy.iscomplexobj(input):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if structure is None:<EOL><INDENT>structure = morphology.generate_binary_structure(input.ndim, <NUM_LIT:1>)<EOL><DEDENT>structure = numpy.asarray(structure, dtype=bool)<EOL>if structure.ndim != input.ndim:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>for ii in structure.shape:<EOL><INDENT>if ii != <NUM_LIT:3>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>need_64bits = input.size >= (<NUM_LIT:2>**<NUM_LIT> - <NUM_LIT:2>)<EOL>if isinstance(output, numpy.ndarray):<EOL><INDENT>if output.shape != input.shape:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>caller_provided_output = True<EOL><DEDENT>else:<EOL><INDENT>caller_provided_output = False<EOL>if output is None:<EOL><INDENT>output = np.empty(input.shape, np.intp if need_64bits else np.int32)<EOL><DEDENT>else:<EOL><INDENT>output = np.empty(input.shape, output)<EOL><DEDENT><DEDENT>if input.ndim == <NUM_LIT:0> or input.size == <NUM_LIT:0>:<EOL><INDENT>if input.ndim == <NUM_LIT:0>:<EOL><INDENT>maxlabel = <NUM_LIT:1> if (input != <NUM_LIT:0>) else <NUM_LIT:0><EOL>output[...] = maxlabel<EOL><DEDENT>else:<EOL><INDENT>maxlabel = <NUM_LIT:0><EOL><DEDENT>if caller_provided_output:<EOL><INDENT>return maxlabel<EOL><DEDENT>else:<EOL><INDENT>return output, maxlabel<EOL><DEDENT><DEDENT>try:<EOL><INDENT>max_label = _ni_label._label(input, structure, output)<EOL><DEDENT>except _ni_label.NeedMoreBits:<EOL><INDENT>tmp_output = np.empty(input.shape, np.intp if need_64bits else np.int32)<EOL>max_label = _ni_label._label(input, structure, tmp_output)<EOL>output[...] = tmp_output[...]<EOL>if not np.all(output == tmp_output):<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if caller_provided_output:<EOL><INDENT>return max_label<EOL><DEDENT>else:<EOL><INDENT>return output, max_label<EOL><DEDENT>", "docstring": "Label features in an array.\n\nParameters\n----------\ninput : array_like\n    An array-like object to be labeled.  Any non-zero values in `input` are\n    counted as features and zero values are considered the background.\nstructure : array_like, optional\n    A structuring element that defines feature connections.\n    `structure` must be symmetric.  If no structuring element is provided,\n    one is automatically generated with a squared connectivity equal to\n    one.  That is, for a 2-D `input` array, the default structuring element\n    is::\n\n        [[0,1,0],\n         [1,1,1],\n         [0,1,0]]\n\noutput : (None, data-type, array_like), optional\n    If `output` is a data type, it specifies the type of the resulting\n    labeled feature array\n    If `output` is an array-like object, then `output` will be updated\n    with the labeled features from this function.  This function can\n    operate in-place, by passing output=input.\n    Note that the output must be able to store the largest label, or this\n    function will raise an Exception.\n\nReturns\n-------\nlabel : ndarray or int\n    An integer ndarray where each unique feature in `input` has a unique\n    label in the returned array.\nnum_features : int\n    How many objects were found.\n\n    If `output` is None, this function returns a tuple of\n    (`labeled_array`, `num_features`).\n\n    If `output` is a ndarray, then it will be updated with values in\n    `labeled_array` and only `num_features` will be returned by this\n    function.\n\nSee Also\n--------\nfind_objects : generate a list of slices for the labeled features (or\n               objects); useful for finding features' position or\n               dimensions\n\nExamples\n--------\nCreate an image with some features, then label it using the default\n(cross-shaped) structuring element:\n\n>>> a = np.array([[0,0,1,1,0,0],\n...               [0,0,0,1,0,0],\n...               [1,1,0,0,1,0],\n...               [0,0,0,1,0,0]])\n>>> labeled_array, num_features = label(a)\n\nEach of the 4 features are labeled with a different integer:\n\n>>> print(num_features)\n4\n>>> print(labeled_array)\narray([[0, 0, 1, 1, 0, 0],\n       [0, 0, 0, 1, 0, 0],\n       [2, 2, 0, 0, 3, 0],\n       [0, 0, 0, 4, 0, 0]])\n\nGenerate a structuring element that will consider features connected even\nif they touch diagonally:\n\n>>> s = generate_binary_structure(2,2)\n\nor,\n\n>>> s = [[1,1,1],\n         [1,1,1],\n         [1,1,1]]\n\nLabel the image using the new structuring element:\n\n>>> labeled_array, num_features = label(a, structure=s)\n\nShow the 2 labeled features (note that features 1, 3, and 4 from above are\nnow considered a single feature):\n\n>>> print(num_features)\n2\n>>> print(labeled_array)\narray([[0, 0, 1, 1, 0, 0],\n       [0, 0, 0, 1, 0, 0],\n       [2, 2, 0, 0, 1, 0],\n       [0, 0, 0, 1, 0, 0]])", "id": "f19434:m0"}
{"signature": "@docfiller<EOL>def convolve(input, weights, output=None, mode='<STR_LIT>', cval=<NUM_LIT:0.0>,<EOL>origin=<NUM_LIT:0>):", "body": "return _correlate_or_convolve(input, weights, output, mode, cval,<EOL>origin, True)<EOL>", "docstring": "Multidimensional convolution.\n\nThe array is convolved with the given kernel.\n\nParameters\n----------\ninput : array_like\n    Input array to filter.\nweights : array_like\n    Array of weights, same number of dimensions as input\noutput : ndarray, optional\n    The `output` parameter passes an array in which to store the\n    filter output.\nmode : {'reflect','constant','nearest','mirror', 'wrap'}, optional\n    the `mode` parameter determines how the array borders are\n    handled. For 'constant' mode, values beyond borders are set to be\n    `cval`. Default is 'reflect'.\ncval : scalar, optional\n    Value to fill past edges of input if `mode` is 'constant'. Default\n    is 0.0\norigin : array_like, optional\n    The `origin` parameter controls the placement of the filter.\n    Default is 0.\n\nReturns\n-------\nresult : ndarray\n    The result of convolution of `input` with `weights`.\n\nSee Also\n--------\ncorrelate : Correlate an image with a kernel.\n\nNotes\n-----\nEach value in result is :math:`C_i = \\\\sum_j{I_{i+j-k} W_j}`, where\nW is the `weights` kernel,\nj is the n-D spatial index over :math:`W`,\nI is the `input` and k is the coordinate of the center of\nW, specified by `origin` in the input parameters.\n\nExamples\n--------\nPerhaps the simplest case to understand is ``mode='constant', cval=0.0``,\nbecause in this case borders (i.e. where the `weights` kernel, centered\non any one value, extends beyond an edge of `input`.\n\n>>> a = np.array([[1, 2, 0, 0],\n....    [5, 3, 0, 4],\n....    [0, 0, 0, 7],\n....    [9, 3, 0, 0]])\n>>> k = np.array([[1,1,1],[1,1,0],[1,0,0]])\n>>> from scipy import ndimage\n>>> ndimage.convolve(a, k, mode='constant', cval=0.0)\narray([[11, 10,  7,  4],\n       [10,  3, 11, 11],\n       [15, 12, 14,  7],\n       [12,  3,  7,  0]])\n\nSetting ``cval=1.0`` is equivalent to padding the outer edge of `input`\nwith 1.0's (and then extracting only the original region of the result).\n\n>>> ndimage.convolve(a, k, mode='constant', cval=1.0)\narray([[13, 11,  8,  7],\n       [11,  3, 11, 14],\n       [16, 12, 14, 10],\n       [15,  6, 10,  5]])\n\nWith ``mode='reflect'`` (the default), outer values are reflected at the\nedge of `input` to fill in missing values.\n\n>>> b = np.array([[2, 0, 0],\n                  [1, 0, 0],\n                  [0, 0, 0]])\n>>> k = np.array([[0,1,0],[0,1,0],[0,1,0]])\n>>> ndimage.convolve(b, k, mode='reflect')\narray([[5, 0, 0],\n       [3, 0, 0],\n       [1, 0, 0]])\n\nThis includes diagonally at the corners.\n\n>>> k = np.array([[1,0,0],[0,1,0],[0,0,1]])\n>>> ndimage.convolve(b, k)\narray([[4, 2, 0],\n       [3, 2, 0],\n       [1, 1, 0]])\n\nWith ``mode='nearest'``, the single nearest value in to an edge in\n`input` is repeated as many times as needed to match the overlapping\n`weights`.\n\n>>> c = np.array([[2, 0, 1],\n                  [1, 0, 0],\n                  [0, 0, 0]])\n>>> k = np.array([[0, 1, 0],\n                  [0, 1, 0],\n                  [0, 1, 0],\n                  [0, 1, 0],\n                  [0, 1, 0]])\n>>> ndimage.convolve(c, k, mode='nearest')\narray([[7, 0, 3],\n       [5, 0, 2],\n       [3, 0, 1]])", "id": "f19435:m13"}
{"signature": "@docfiller<EOL>def prewitt(input, axis=-<NUM_LIT:1>, output=None, mode=\"<STR_LIT>\", cval=<NUM_LIT:0.0>):", "body": "input = numpy.asarray(input)<EOL>axis = _ni_support._check_axis(axis, input.ndim)<EOL>output, return_value = _ni_support._get_output(output, input)<EOL>correlate1d(input, [-<NUM_LIT:1>, <NUM_LIT:0>, <NUM_LIT:1>], axis, output, mode, cval, <NUM_LIT:0>)<EOL>axes = [ii for ii in range(input.ndim) if ii != axis]<EOL>for ii in axes:<EOL><INDENT>correlate1d(output, [<NUM_LIT:1>, <NUM_LIT:1>, <NUM_LIT:1>], ii, output, mode, cval, <NUM_LIT:0>,)<EOL><DEDENT>return return_value<EOL>", "docstring": "Calculate a Prewitt filter.\n\n    Parameters\n    ----------\n    %(input)s\n    %(axis)s\n    %(output)s\n    %(mode)s\n    %(cval)s", "id": "f19435:m4"}
{"signature": "@docfiller<EOL>def rank_filter(input, rank, size=None, footprint=None, output=None,<EOL>mode=\"<STR_LIT>\", cval=<NUM_LIT:0.0>, origin=<NUM_LIT:0>):", "body": "return _rank_filter(input, rank, size, footprint, output, mode, cval,<EOL>origin, '<STR_LIT>')<EOL>", "docstring": "Calculates a multi-dimensional rank filter.\n\n    Parameters\n    ----------\n    %(input)s\n    rank : integer\n        The rank parameter may be less then zero, i.e., rank = -1\n        indicates the largest element.\n    %(size_foot)s\n    %(output)s\n    %(mode)s\n    %(cval)s\n    %(origin)s", "id": "f19435:m22"}
{"signature": "@docfiller<EOL>def minimum_filter1d(input, size, axis=-<NUM_LIT:1>, output=None,<EOL>mode=\"<STR_LIT>\", cval=<NUM_LIT:0.0>, origin=<NUM_LIT:0>):", "body": "input = numpy.asarray(input)<EOL>if numpy.iscomplexobj(input):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>axis = _ni_support._check_axis(axis, input.ndim)<EOL>if size < <NUM_LIT:1>:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>output, return_value = _ni_support._get_output(output, input)<EOL>if (size // <NUM_LIT:2> + origin < <NUM_LIT:0>) or (size // <NUM_LIT:2> + origin >= size):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>mode = _ni_support._extend_mode_to_code(mode)<EOL>_nd_image.min_or_max_filter1d(input, size, axis, output, mode, cval,<EOL>origin, <NUM_LIT:1>)<EOL>return return_value<EOL>", "docstring": "Calculate a one-dimensional minimum filter along the given axis.\n\n    The lines of the array along the given axis are filtered with a\n    minimum filter of given size.\n\n    Parameters\n    ----------\n    %(input)s\n    size : int\n        length along which to calculate 1D minimum\n    %(axis)s\n    %(output)s\n    %(mode)s\n    %(cval)s\n    %(origin)s\n\n    Notes\n    -----\n    This function implements the MINLIST algorithm [1]_, as described by\n    Richard Harter [2]_, and has a guaranteed O(n) performance, `n` being\n    the `input` length, regardless of filter size.\n\n    References\n    ----------\n    .. [1] http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.42.2777\n    .. [2] http://www.richardhartersworld.com/cri/2001/slidingmin.html", "id": "f19435:m16"}
{"signature": "@docfiller<EOL>def generic_gradient_magnitude(input, derivative, output=None,<EOL>mode=\"<STR_LIT>\", cval=<NUM_LIT:0.0>,<EOL>extra_arguments=(), extra_keywords = None):", "body": "if extra_keywords is None:<EOL><INDENT>extra_keywords = {}<EOL><DEDENT>input = numpy.asarray(input)<EOL>output, return_value = _ni_support._get_output(output, input)<EOL>axes = list(range(input.ndim))<EOL>if len(axes) > <NUM_LIT:0>:<EOL><INDENT>derivative(input, axes[<NUM_LIT:0>], output, mode, cval,<EOL>*extra_arguments, **extra_keywords)<EOL>numpy.multiply(output, output, output)<EOL>for ii in range(<NUM_LIT:1>, len(axes)):<EOL><INDENT>tmp = derivative(input, axes[ii], output.dtype, mode, cval,<EOL>*extra_arguments, **extra_keywords)<EOL>numpy.multiply(tmp, tmp, tmp)<EOL>output += tmp<EOL><DEDENT>if NumpyVersion(numpy.__version__) > '<STR_LIT>':<EOL><INDENT>numpy.sqrt(output, output, casting='<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>numpy.sqrt(output, output)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>output[...] = input[...]<EOL><DEDENT>return return_value<EOL>", "docstring": "Gradient magnitude using a provided gradient function.\n\n    Parameters\n    ----------\n    %(input)s\n    derivative : callable\n        Callable with the following signature::\n\n            derivative(input, axis, output, mode, cval,\n                       *extra_arguments, **extra_keywords)\n\n        See `extra_arguments`, `extra_keywords` below.\n        `derivative` can assume that `input` and `output` are ndarrays.\n        Note that the output from `derivative` is modified inplace;\n        be careful to copy important inputs before returning them.\n    %(output)s\n    %(mode)s\n    %(cval)s\n    %(extra_keywords)s\n    %(extra_arguments)s", "id": "f19435:m9"}
{"signature": "@docfiller<EOL>def generic_filter1d(input, function, filter_size, axis=-<NUM_LIT:1>,<EOL>output=None, mode=\"<STR_LIT>\", cval=<NUM_LIT:0.0>, origin=<NUM_LIT:0>,<EOL>extra_arguments=(), extra_keywords = None):", "body": "if extra_keywords is None:<EOL><INDENT>extra_keywords = {}<EOL><DEDENT>input = numpy.asarray(input)<EOL>if numpy.iscomplexobj(input):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>output, return_value = _ni_support._get_output(output, input)<EOL>if filter_size < <NUM_LIT:1>:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>axis = _ni_support._check_axis(axis, input.ndim)<EOL>if (filter_size // <NUM_LIT:2> + origin < <NUM_LIT:0>) or (filter_size // <NUM_LIT:2> + origin >=<EOL>filter_size):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>mode = _ni_support._extend_mode_to_code(mode)<EOL>_nd_image.generic_filter1d(input, function, filter_size, axis, output,<EOL>mode, cval, origin, extra_arguments, extra_keywords)<EOL>return return_value<EOL>", "docstring": "Calculate a one-dimensional filter along the given axis.\n\n    `generic_filter1d` iterates over the lines of the array, calling the\n    given function at each line. The arguments of the line are the\n    input line, and the output line. The input and output lines are 1D\n    double arrays.  The input line is extended appropriately according\n    to the filter size and origin. The output line must be modified\n    in-place with the result.\n\n    Parameters\n    ----------\n    %(input)s\n    function : callable\n        Function to apply along given axis.\n    filter_size : scalar\n        Length of the filter.\n    %(axis)s\n    %(output)s\n    %(mode)s\n    %(cval)s\n    %(origin)s\n    %(extra_arguments)s\n    %(extra_keywords)s", "id": "f19435:m25"}
{"signature": "@docfiller<EOL>def convolve1d(input, weights, axis=-<NUM_LIT:1>, output=None, mode=\"<STR_LIT>\",<EOL>cval=<NUM_LIT:0.0>, origin=<NUM_LIT:0>):", "body": "weights = weights[::-<NUM_LIT:1>]<EOL>origin = -origin<EOL>if not len(weights) & <NUM_LIT:1>:<EOL><INDENT>origin -= <NUM_LIT:1><EOL><DEDENT>return correlate1d(input, weights, axis, output, mode, cval, origin)<EOL>", "docstring": "Calculate a one-dimensional convolution along the given axis.\n\n    The lines of the array along the given axis are convolved with the\n    given weights.\n\n    Parameters\n    ----------\n    %(input)s\n    weights : ndarray\n        One-dimensional sequence of numbers.\n    %(axis)s\n    %(output)s\n    %(mode)s\n    %(cval)s\n    %(origin)s\n\n    Returns\n    -------\n    convolve1d : ndarray\n        Convolved array with same shape as input", "id": "f19435:m1"}
{"signature": "def _geometric_transform(input, mapping, coordinates, matrix, offset, output,<EOL>order, mode, cval, extra_arguments, extra_keywords):", "body": "_nd_image.geometric_transform(<EOL>input, mapping, coordinates, matrix, offset, output,<EOL>order, mode, cval, extra_arguments, extra_keywords)<EOL>if output is not None and not output.dtype.isnative:<EOL><INDENT>output.byteswap(True)<EOL><DEDENT>return output<EOL>", "docstring": "Wrapper around _nd_image.geometric_transform to work around\nendianness issues", "id": "f19436:m3"}
{"signature": "def spline_filter1d(input, order=<NUM_LIT:3>, axis=-<NUM_LIT:1>, output=numpy.float64):", "body": "if order < <NUM_LIT:0> or order > <NUM_LIT:5>:<EOL><INDENT>raise RuntimeError('<STR_LIT>')<EOL><DEDENT>input = numpy.asarray(input)<EOL>if numpy.iscomplexobj(input):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>output, return_value = _ni_support._get_output(output, input)<EOL>if order in [<NUM_LIT:0>, <NUM_LIT:1>]:<EOL><INDENT>output[...] = numpy.array(input)<EOL><DEDENT>else:<EOL><INDENT>axis = _ni_support._check_axis(axis, input.ndim)<EOL>_nd_image.spline_filter1d(input, order, axis, output)<EOL><DEDENT>return return_value<EOL>", "docstring": "Calculates a one-dimensional spline filter along the given axis.\n\nThe lines of the array along the given axis are filtered by a\nspline filter. The order of the spline must be >= 2 and <= 5.\n\nParameters\n----------\ninput : array_like\n    The input array.\norder : int, optional\n    The order of the spline, default is 3.\naxis : int, optional\n    The axis along which the spline filter is applied. Default is the last\n    axis.\noutput : ndarray or dtype, optional\n    The array in which to place the output, or the dtype of the returned\n    array. Default is `numpy.float64`.\n\nReturns\n-------\nspline_filter1d : ndarray or None\n    The filtered input. If `output` is given as a parameter, None is\n    returned.", "id": "f19436:m1"}
{"signature": "def _normalize_sequence(input, rank, array_type=None):", "body": "if isinstance(input, integer_types + (float,)):<EOL><INDENT>normalized = [input] * rank<EOL><DEDENT>else:<EOL><INDENT>normalized = list(input)<EOL>if len(normalized) != rank:<EOL><INDENT>err = \"<STR_LIT>\"<EOL>raise RuntimeError(err)<EOL><DEDENT><DEDENT>return normalized<EOL>", "docstring": "If input is a scalar, create a sequence of length equal to the\n    rank by duplicating the input. If input is a sequence,\n    check if its length is equal to the length of array.", "id": "f19437:m1"}
{"signature": "def grey_opening(input, size=None, footprint=None, structure=None,<EOL>output=None, mode=\"<STR_LIT>\", cval=<NUM_LIT:0.0>, origin=<NUM_LIT:0>):", "body": "tmp = grey_erosion(input, size, footprint, structure, None, mode,<EOL>cval, origin)<EOL>return grey_dilation(tmp, size, footprint, structure, output, mode,<EOL>cval, origin)<EOL>", "docstring": "Multi-dimensional greyscale opening.\n\nA greyscale opening consists in the succession of a greyscale erosion,\nand a greyscale dilation.\n\nParameters\n----------\ninput : array_like\n    Array over which the grayscale opening is to be computed.\nsize : tuple of ints\n    Shape of a flat and full structuring element used for the grayscale\n    opening. Optional if `footprint` or `structure` is provided.\nfootprint : array of ints, optional\n    Positions of non-infinite elements of a flat structuring element\n    used for the grayscale opening.\nstructure : array of ints, optional\n    Structuring element used for the grayscale opening. `structure`\n    may be a non-flat structuring element.\noutput : array, optional\n    An array used for storing the ouput of the opening may be provided.\nmode : {'reflect', 'constant', 'nearest', 'mirror', 'wrap'}, optional\n    The `mode` parameter determines how the array borders are\n    handled, where `cval` is the value when mode is equal to\n    'constant'. Default is 'reflect'\ncval : scalar, optional\n    Value to fill past edges of input if `mode` is 'constant'. Default\n    is 0.0.\norigin : scalar, optional\n    The `origin` parameter controls the placement of the filter.\n    Default 0\n\nReturns\n-------\ngrey_opening : ndarray\n    Result of the grayscale opening of `input` with `structure`.\n\nSee also\n--------\nbinary_opening, grey_dilation, grey_erosion, grey_closing\ngenerate_binary_structure\n\nNotes\n-----\nThe action of a grayscale opening with a flat structuring element amounts\nto smoothen high local maxima, whereas binary opening erases small objects.\n\nReferences\n----------\n.. [1] http://en.wikipedia.org/wiki/Mathematical_morphology\n\nExamples\n--------\n>>> a = np.arange(36).reshape((6,6))\n>>> a[3, 3] = 50\n>>> a\narray([[ 0,  1,  2,  3,  4,  5],\n       [ 6,  7,  8,  9, 10, 11],\n       [12, 13, 14, 15, 16, 17],\n       [18, 19, 20, 50, 22, 23],\n       [24, 25, 26, 27, 28, 29],\n       [30, 31, 32, 33, 34, 35]])\n>>> ndimage.grey_opening(a, size=(3,3))\narray([[ 0,  1,  2,  3,  4,  4],\n       [ 6,  7,  8,  9, 10, 10],\n       [12, 13, 14, 15, 16, 16],\n       [18, 19, 20, 22, 22, 22],\n       [24, 25, 26, 27, 28, 28],\n       [24, 25, 26, 27, 28, 28]])\n>>> # Note that the local maximum a[3,3] has disappeared", "id": "f19439:m13"}
{"signature": "def generate_binary_structure(rank, connectivity):", "body": "if connectivity < <NUM_LIT:1>:<EOL><INDENT>connectivity = <NUM_LIT:1><EOL><DEDENT>if rank < <NUM_LIT:1>:<EOL><INDENT>if connectivity < <NUM_LIT:1>:<EOL><INDENT>return numpy.array(<NUM_LIT:0>, dtype=bool)<EOL><DEDENT>else:<EOL><INDENT>return numpy.array(<NUM_LIT:1>, dtype=bool)<EOL><DEDENT><DEDENT>output = numpy.fabs(numpy.indices([<NUM_LIT:3>] * rank) - <NUM_LIT:1>)<EOL>output = numpy.add.reduce(output, <NUM_LIT:0>)<EOL>return numpy.asarray(output <= connectivity, dtype=bool)<EOL>", "docstring": "Generate a binary structure for binary morphological operations.\n\nParameters\n----------\nrank : int\n     Number of dimensions of the array to which the structuring element\n     will be applied, as returned by `np.ndim`.\nconnectivity : int\n     `connectivity` determines which elements of the output array belong\n     to the structure, i.e. are considered as neighbors of the central\n     element. Elements up to a squared distance of `connectivity` from\n     the center are considered neighbors. `connectivity` may range from 1\n     (no diagonal elements are neighbors) to `rank` (all elements are\n     neighbors).\n\nReturns\n-------\noutput : ndarray of bools\n     Structuring element which may be used for binary morphological\n     operations, with `rank` dimensions and all dimensions equal to 3.\n\nSee also\n--------\niterate_structure, binary_dilation, binary_erosion\n\nNotes\n-----\n`generate_binary_structure` can only create structuring elements with\ndimensions equal to 3, i.e. minimal dimensions. For larger structuring\nelements, that are useful e.g. for eroding large objects, one may either\nuse   `iterate_structure`, or create directly custom arrays with\nnumpy functions such as `numpy.ones`.\n\nExamples\n--------\n>>> struct = ndimage.generate_binary_structure(2, 1)\n>>> struct\narray([[False,  True, False],\n       [ True,  True,  True],\n       [False,  True, False]], dtype=bool)\n>>> a = np.zeros((5,5))\n>>> a[2, 2] = 1\n>>> a\narray([[ 0.,  0.,  0.,  0.,  0.],\n       [ 0.,  0.,  0.,  0.,  0.],\n       [ 0.,  0.,  1.,  0.,  0.],\n       [ 0.,  0.,  0.,  0.,  0.],\n       [ 0.,  0.,  0.,  0.,  0.]])\n>>> b = ndimage.binary_dilation(a, structure=struct).astype(a.dtype)\n>>> b\narray([[ 0.,  0.,  0.,  0.,  0.],\n       [ 0.,  0.,  1.,  0.,  0.],\n       [ 0.,  1.,  1.,  1.,  0.],\n       [ 0.,  0.,  1.,  0.,  0.],\n       [ 0.,  0.,  0.,  0.,  0.]])\n>>> ndimage.binary_dilation(b, structure=struct).astype(a.dtype)\narray([[ 0.,  0.,  1.,  0.,  0.],\n       [ 0.,  1.,  1.,  1.,  0.],\n       [ 1.,  1.,  1.,  1.,  1.],\n       [ 0.,  1.,  1.,  1.,  0.],\n       [ 0.,  0.,  1.,  0.,  0.]])\n>>> struct = ndimage.generate_binary_structure(2, 2)\n>>> struct\narray([[ True,  True,  True],\n       [ True,  True,  True],\n       [ True,  True,  True]], dtype=bool)\n>>> struct = ndimage.generate_binary_structure(3, 1)\n>>> struct # no diagonal elements\narray([[[False, False, False],\n        [False,  True, False],\n        [False, False, False]],\n       [[False,  True, False],\n        [ True,  True,  True],\n        [False,  True, False]],\n       [[False, False, False],\n        [False,  True, False],\n        [False, False, False]]], dtype=bool)", "id": "f19439:m2"}
{"signature": "def precision(key):", "body": "_check_obsolete(key)<EOL>return physical_constants[key][<NUM_LIT:2>] / physical_constants[key][<NUM_LIT:0>]<EOL>", "docstring": "Relative precision in physical_constants indexed by key\n\nParameters\n----------\nkey : Python string or unicode\n    Key in dictionary `physical_constants`\n\nReturns\n-------\nprec : float\n    Relative precision in `physical_constants` corresponding to `key`\n\nSee Also\n--------\ncodata : Contains the description of `physical_constants`, which, as a\n    dictionary literal object, does not itself possess a docstring.\n\nExamples\n--------\n>>> from scipy.constants import codata\n>>> codata.precision(u'proton mass')\n4.96226989798e-08", "id": "f19447:m4"}
{"signature": "def find(sub=None, disp=False):", "body": "if sub is None:<EOL><INDENT>result = list(_current_constants.keys())<EOL><DEDENT>else:<EOL><INDENT>result = [key for key in _current_constants<EOL>if sub.lower() in key.lower()]<EOL><DEDENT>result.sort()<EOL>if disp:<EOL><INDENT>for key in result:<EOL><INDENT>print(key)<EOL><DEDENT>return<EOL><DEDENT>else:<EOL><INDENT>return result<EOL><DEDENT>", "docstring": "Return list of codata.physical_constant keys containing a given string.\n\nParameters\n----------\nsub : str, unicode\n    Sub-string to search keys for.  By default, return all keys.\ndisp : bool\n    If True, print the keys that are found, and return None.\n    Otherwise, return the list of keys without printing anything.\n\nReturns\n-------\nkeys : list or None\n    If `disp` is False, the list of keys is returned.\n    Otherwise, None is returned.\n\nSee Also\n--------\ncodata : Contains the description of `physical_constants`, which, as a\n    dictionary literal object, does not itself possess a docstring.", "id": "f19447:m5"}
{"signature": "def ellip_harm_2(h2, k2, n, p, s):", "body": "with _ellip_lock:<EOL><INDENT>with np.errstate(all='<STR_LIT:ignore>'):<EOL><INDENT>return _ellip_harm_2_vec(h2, k2, n, p, s)<EOL><DEDENT><DEDENT>", "docstring": "r\"\"\"\n    Ellipsoidal harmonic functions F^p_n(l)\n\n    These are also known as Lame functions of the second kind, and are\n    solutions to the Lame equation:\n\n    .. math:: (s^2 - h^2)(s^2 - k^2)F''(s) + s(2s^2 - h^2 - k^2)F'(s) + (a - q s^2)F(s) = 0\n\n    where :math:`q = (n+1)n` and :math:`a` is the eigenvalue (not\n    returned) corresponding to the solutions.\n\n    Parameters\n    ----------\n    h2 : float\n        ``h**2``\n    k2 : float\n        ``k**2``; should be larger than ``h**2``\n    n : int\n        Degree.\n    p : int\n        Order, can range between [1,2n+1].\n    s : float\n        Coordinate\n\n    Returns\n    -------\n    F : float\n        The harmonic :math:`F^p_n(s)`\n\n    Notes\n    -----\n    Lame functions of the second kind are related to the functions of the first kind:\n\n    .. math::\n\n       F^p_n(s)=(2n + 1)E^p_n(s)\\int_{0}^{1/s}\\frac{du}{(E^p_n(1/u))^2\\sqrt{(1-u^2k^2)(1-u^2h^2)}}\n\n    See Also\n    --------\n    ellip_harm, ellip_normal\n\n    Examples\n    --------\n    >>> from scipy.special import ellip_harm_2\n    >>> w = ellip_harm_2(5,8,2,1,10)\n    >>> w\n    0.00108056853382", "id": "f19448:m2"}
{"signature": "def ellip_harm(h2, k2, n, p, s, signm=<NUM_LIT:1>, signn=<NUM_LIT:1>):", "body": "return _ellip_harm(h2, k2, n, p, s, signm, signn)<EOL>", "docstring": "r\"\"\"\n    Ellipsoidal harmonic functions E^p_n(l)\n\n    These are also known as Lame functions of the first kind, and are\n    solutions to the Lame equation:\n\n    .. math:: (s^2 - h^2)(s^2 - k^2)E''(s) + s(2s^2 - h^2 - k^2)E'(s) + (a - q s^2)E(s) = 0\n\n    where :math:`q = (n+1)n` and :math:`a` is the eigenvalue (not\n    returned) corresponding to the solutions.\n\n    Parameters\n    ----------\n    h2 : float\n        ``h**2``\n    k2 : float\n        ``k**2``; should be larger than ``h**2``\n    n : int\n        Degree\n    s : float\n        Coordinate\n    p : int\n        Order, can range between [1,2n+1]\n    signm : {1, -1}, optional\n        Sign of prefactor of functions. Can be +/-1. See Notes.\n    signn : {1, -1}, optional\n        Sign of prefactor of functions. Can be +/-1. See Notes.\n\n    Returns\n    -------\n    E : float\n        the harmonic :math:`E^p_n(s)`\n\n    See Also\n    --------\n    ellip_harm_2, ellip_normal\n\n    Notes\n    -----\n    The geometric intepretation of the ellipsoidal functions is\n    explained in [2]_, [3]_, [4]_.  The `signm` and `signn` arguments control the\n    sign of prefactors for functions according to their type::\n\n        K : +1 \n        L : signm\n        M : signn\n        N : signm*signn\n\n    References\n    ----------\n    .. [1] Digital Libary of Mathematical Functions 29.12\n       http://dlmf.nist.gov/29.12\n    .. [2] Bardhan and Knepley, \"Computational science and \n       re-discovery: open-source implementations of \n       ellipsoidal harmonics for problems in potential theory\",\n       Comput. Sci. Disc. 5, 014006 (2012)\n       doi:10.1088/1749-4699/5/1/014006\n    .. [3] David J.and Dechambre P, \"Computation of Ellipsoidal\n       Gravity Field Harmonics for small solar system bodies\"\n       pp. 30-36, 2000\n    .. [4] George Dassios, \"Ellipsoidal Harmonics: Theory and Applications\"\n       pp. 418, 2012\n\n    Examples\n    --------\n    >>> from scipy.special import ellip_harm\n    >>> w = ellip_harm(5,8,1,1,2.5)\n    >>> w\n    2.5\n\n    Check that the functions indeed are solutions to the Lame equation:\n\n    >>> from scipy.interpolate import UnivariateSpline\n    >>> def eigenvalue(f, df, ddf):\n    ...     r = ((s**2 - h**2)*(s**2 - k**2)*ddf + s*(2*s**2 - h**2 - k**2)*df - n*(n+1)*s**2*f)/f\n    ...     return -r.mean(), r.std()\n    >>> s = np.linspace(0.1, 10, 200)\n    >>> k, h, n, p = 8.0, 2.2, 3, 2\n    >>> E = ellip_harm(h**2, k**2, n, p, s)\n    >>> E_spl = UnivariateSpline(s, E)\n    >>> a, a_err = eigenvalue(E_spl(s), E_spl(s,1), E_spl(s,2))\n    >>> a, a_err\n    (583.44366156701483, 6.4580890640310646e-11)", "id": "f19448:m0"}
{"signature": "def __repr__(self):", "body": "if np.any(list(map(np.iscomplexobj, self.param_columns))):<EOL><INDENT>is_complex = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>is_complex = \"<STR_LIT>\"<EOL><DEDENT>if self.dataname:<EOL><INDENT>return \"<STR_LIT>\" % (self.func.__name__, is_complex,<EOL>os.path.basename(self.dataname))<EOL><DEDENT>else:<EOL><INDENT>return \"<STR_LIT>\" % (self.func.__name__, is_complex)<EOL><DEDENT>", "docstring": "Pretty-printing, esp. for Nose output", "id": "f19449:c0:m3"}
{"signature": "def _exception_to_nan(func):", "body": "def wrap(*a, **kw):<EOL><INDENT>try:<EOL><INDENT>return func(*a, **kw)<EOL><DEDENT>except Exception:<EOL><INDENT>return np.nan<EOL><DEDENT><DEDENT>return wrap<EOL>", "docstring": "Decorate function to return nan if it raises an exception", "id": "f19452:m15"}
{"signature": "def _cephes_vs_amos_points(self):", "body": "<EOL>for v in [-<NUM_LIT>, -<NUM_LIT>, -<NUM_LIT>, -<NUM_LIT>, -<NUM_LIT:1.>, -<NUM_LIT>,<EOL><NUM_LIT:0.>, <NUM_LIT:1.>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>]:<EOL><INDENT>for z in [-<NUM_LIT>, -<NUM_LIT:11>, -<NUM_LIT:10>, -<NUM_LIT:1>, <NUM_LIT:1.>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>,<EOL><NUM_LIT>, <NUM_LIT>, <NUM_LIT>]:<EOL><INDENT>yield v, z<EOL><DEDENT><DEDENT>for v in <NUM_LIT:0.5> + arange(-<NUM_LIT>, <NUM_LIT>):<EOL><INDENT>yield v, <NUM_LIT><EOL><DEDENT>", "docstring": "Yield points at which to compare Cephes implementation to AMOS", "id": "f19453:c19:m47"}
{"signature": "def ellipk(m):", "body": "return ellipkm1(<NUM_LIT:1> - asarray(m))<EOL>", "docstring": "Complete elliptic integral of the first kind\n\nThis function is defined as\n\n.. math:: K(m) = \\\\int_0^{\\\\pi/2} [1 - m \\\\sin(t)^2]^{-1/2} dt\n\nParameters\n----------\nm : array_like\n    The parameter of the elliptic integral.\n\nReturns\n-------\nK : array_like\n    Value of the elliptic integral.\n\nNotes\n-----\nFor more precision around point m = 1, use `ellipkm1`.\n\nSee Also\n--------\nellipkm1 : Complete elliptic integral of the first kind around m = 1\nellipkinc : Incomplete elliptic integral of the first kind\nellipe : Complete elliptic integral of the second kind\nellipeinc : Incomplete elliptic integral of the second kind", "id": "f19460:m60"}
{"signature": "def erf_zeros(nt):", "body": "if (floor(nt) != nt) or (nt <= <NUM_LIT:0>) or not isscalar(nt):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return specfun.cerzo(nt)<EOL>", "docstring": "Compute nt complex zeros of the error function erf(z).", "id": "f19460:m27"}
{"signature": "def pbdv_seq(v,x):", "body": "if not (isscalar(v) and isscalar(x)):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>n = int(v)<EOL>v0 = v-n<EOL>if (n < <NUM_LIT:1>):<EOL><INDENT>n1 = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>n1 = n<EOL><DEDENT>v1 = n1 + v0<EOL>dv,dp,pdf,pdd = specfun.pbdv(v1,x)<EOL>return dv[:n1+<NUM_LIT:1>],dp[:n1+<NUM_LIT:1>]<EOL>", "docstring": "Compute sequence of parabolic cylinder functions Dv(x) and\n    their derivatives for Dv0(x)..Dv(x) with v0=v-int(v).", "id": "f19460:m46"}
{"signature": "def ynp_zeros(n,nt):", "body": "return jnyn_zeros(n,nt)[<NUM_LIT:3>]<EOL>", "docstring": "Compute nt zeros of the Bessel function Yn'(x).", "id": "f19460:m6"}
{"signature": "def bei_zeros(nt):", "body": "if not isscalar(nt) or (floor(nt) != nt) or (nt <= <NUM_LIT:0>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return specfun.klvnzo(nt,<NUM_LIT:2>)<EOL>", "docstring": "Compute nt zeros of the Kelvin function bei x", "id": "f19460:m50"}
{"signature": "def sph_jn(n,z):", "body": "if not (isscalar(n) and isscalar(z)):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if (n != floor(n)) or (n < <NUM_LIT:0>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if (n < <NUM_LIT:1>):<EOL><INDENT>n1 = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>n1 = n<EOL><DEDENT>if iscomplex(z):<EOL><INDENT>nm,jn,jnp,yn,ynp = specfun.csphjy(n1,z)<EOL><DEDENT>else:<EOL><INDENT>nm,jn,jnp = specfun.sphj(n1,z)<EOL><DEDENT>return jn[:(n+<NUM_LIT:1>)], jnp[:(n+<NUM_LIT:1>)]<EOL>", "docstring": "Compute the spherical Bessel function jn(z) and its derivative for\n    all orders up to and including n.", "id": "f19460:m17"}
{"signature": "def h1vp(v,z,n=<NUM_LIT:1>):", "body": "if not isinstance(n,int) or (n < <NUM_LIT:0>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if n == <NUM_LIT:0>:<EOL><INDENT>return hankel1(v,z)<EOL><DEDENT>else:<EOL><INDENT>return _bessel_diff_formula(v, z, n, hankel1, -<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "Return the nth derivative of H1v(z) with respect to z.", "id": "f19460:m15"}
{"signature": "def pro_cv_seq(m,n,c):", "body": "if not (isscalar(m) and isscalar(n) and isscalar(c)):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if (n != floor(n)) or (m != floor(m)):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if (n-m > <NUM_LIT>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>maxL = n-m+<NUM_LIT:1><EOL>return specfun.segv(m,n,c,<NUM_LIT:1>)[<NUM_LIT:1>][:maxL]<EOL>", "docstring": "Compute a sequence of characteristic values for the prolate\n    spheroidal wave functions for mode m and n'=m..n and spheroidal\n    parameter c.", "id": "f19460:m58"}
{"signature": "def sph_kn(n,z):", "body": "if not (isscalar(n) and isscalar(z)):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if (n != floor(n)) or (n < <NUM_LIT:0>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if (n < <NUM_LIT:1>):<EOL><INDENT>n1 = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>n1 = n<EOL><DEDENT>if iscomplex(z) or less(z,<NUM_LIT:0>):<EOL><INDENT>nm,In,Inp,kn,knp = specfun.csphik(n1,z)<EOL><DEDENT>else:<EOL><INDENT>nm,kn,knp = specfun.sphk(n1,z)<EOL><DEDENT>return kn[:(n+<NUM_LIT:1>)], knp[:(n+<NUM_LIT:1>)]<EOL>", "docstring": "Compute the spherical Bessel function kn(z) and its derivative for\n    all orders up to and including n.", "id": "f19460:m21"}
{"signature": "def riccati_jn(n,x):", "body": "if not (isscalar(n) and isscalar(x)):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if (n != floor(n)) or (n < <NUM_LIT:0>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if (n == <NUM_LIT:0>):<EOL><INDENT>n1 = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>n1 = n<EOL><DEDENT>nm,jn,jnp = specfun.rctj(n1,x)<EOL>return jn[:(n+<NUM_LIT:1>)],jnp[:(n+<NUM_LIT:1>)]<EOL>", "docstring": "Compute the Ricatti-Bessel function of the first kind and its\n    derivative for all orders up to and including n.", "id": "f19460:m23"}
{"signature": "def clpmn(m,n,z,type=<NUM_LIT:3>):", "body": "if not isscalar(m) or (abs(m) > n):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not isscalar(n) or (n < <NUM_LIT:0>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not isscalar(z):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not(type == <NUM_LIT:2> or type == <NUM_LIT:3>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if (m < <NUM_LIT:0>):<EOL><INDENT>mp = -m<EOL>mf,nf = mgrid[<NUM_LIT:0>:mp+<NUM_LIT:1>,<NUM_LIT:0>:n+<NUM_LIT:1>]<EOL>sv = errprint(<NUM_LIT:0>)<EOL>if type == <NUM_LIT:2>:<EOL><INDENT>fixarr = where(mf > nf,<NUM_LIT:0.0>, (-<NUM_LIT:1>)**mf * gamma(nf-mf+<NUM_LIT:1>) / gamma(nf+mf+<NUM_LIT:1>))<EOL><DEDENT>else:<EOL><INDENT>fixarr = where(mf > nf,<NUM_LIT:0.0>,gamma(nf-mf+<NUM_LIT:1>) / gamma(nf+mf+<NUM_LIT:1>))<EOL><DEDENT>sv = errprint(sv)<EOL><DEDENT>else:<EOL><INDENT>mp = m<EOL><DEDENT>p,pd = specfun.clpmn(mp,n,real(z),imag(z),type)<EOL>if (m < <NUM_LIT:0>):<EOL><INDENT>p = p * fixarr<EOL>pd = pd * fixarr<EOL><DEDENT>return p,pd<EOL>", "docstring": "Associated Legendre function of the first kind, Pmn(z)\n\n    Computes the (associated) Legendre function of the first kind\n    of order m and degree n,::\n\n        Pmn(z) = P_n^m(z)\n\n    and its derivative, ``Pmn'(z)``.  Returns two arrays of size\n    ``(m+1, n+1)`` containing ``Pmn(z)`` and ``Pmn'(z)`` for all\n    orders from ``0..m`` and degrees from ``0..n``.\n\n    Parameters\n    ----------\n    m : int\n       ``|m| <= n``; the order of the Legendre function.\n    n : int\n       where ``n >= 0``; the degree of the Legendre function.  Often\n       called ``l`` (lower case L) in descriptions of the associated\n       Legendre function\n    z : float or complex\n        Input value.\n    type : int\n       takes values 2 or 3\n       2: cut on the real axis |x|>1\n       3: cut on the real axis -1<x<1 (default)\n\n    Returns\n    -------\n    Pmn_z : (m+1, n+1) array\n       Values for all orders 0..m and degrees 0..n\n    Pmn_d_z : (m+1, n+1) array\n       Derivatives for all orders 0..m and degrees 0..n\n\n    See Also\n    --------\n    lpmn: associated Legendre functions of the first kind for real z\n\n    Notes\n    -----\n    By default, i.e. for ``type=3``, phase conventions are chosen according\n    to [1]_ such that the function is analytic. The cut lies on the interval\n    (-1, 1). Approaching the cut from above or below in general yields a phase\n    factor with respect to Ferrer's function of the first kind\n    (cf. `lpmn`).\n\n    For ``type=2`` a cut at |x|>1 is chosen. Approaching the real values\n    on the interval (-1, 1) in the complex plane yields Ferrer's function\n    of the first kind.\n\n    References\n    ----------\n    .. [1] NIST Digital Library of Mathematical Functions\n           http://dlmf.nist.gov/14.21", "id": "f19460:m37"}
{"signature": "def lqn(n,z):", "body": "if not (isscalar(n) and isscalar(z)):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if (n != floor(n)) or (n < <NUM_LIT:0>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if (n < <NUM_LIT:1>):<EOL><INDENT>n1 = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>n1 = n<EOL><DEDENT>if iscomplex(z):<EOL><INDENT>qn,qd = specfun.clqn(n1,z)<EOL><DEDENT>else:<EOL><INDENT>qn,qd = specfun.lqnb(n1,z)<EOL><DEDENT>return qn[:(n+<NUM_LIT:1>)],qd[:(n+<NUM_LIT:1>)]<EOL>", "docstring": "Compute sequence of Legendre functions of the second kind,\n    Qn(z) and derivatives for all degrees from 0 to n (inclusive).", "id": "f19460:m42"}
{"signature": "def comb(N, k, exact=False, repetition=False):", "body": "if repetition:<EOL><INDENT>return comb(N + k - <NUM_LIT:1>, k, exact)<EOL><DEDENT>if exact:<EOL><INDENT>N = int(N)<EOL>k = int(k)<EOL>if (k > N) or (N < <NUM_LIT:0>) or (k < <NUM_LIT:0>):<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>val = <NUM_LIT:1><EOL>for j in xrange(min(k, N-k)):<EOL><INDENT>val = (val*(N-j))//(j+<NUM_LIT:1>)<EOL><DEDENT>return val<EOL><DEDENT>else:<EOL><INDENT>k,N = asarray(k), asarray(N)<EOL>cond = (k <= N) & (N >= <NUM_LIT:0>) & (k >= <NUM_LIT:0>)<EOL>vals = binom(N, k)<EOL>if isinstance(vals, np.ndarray):<EOL><INDENT>vals[~cond] = <NUM_LIT:0><EOL><DEDENT>elif not cond:<EOL><INDENT>vals = np.float64(<NUM_LIT:0>)<EOL><DEDENT>return vals<EOL><DEDENT>", "docstring": "The number of combinations of N things taken k at a time.\n\nThis is often expressed as \"N choose k\".\n\nParameters\n----------\nN : int, ndarray\n    Number of things.\nk : int, ndarray\n    Number of elements taken.\nexact : bool, optional\n    If `exact` is False, then floating point precision is used, otherwise\n    exact long integer is computed.\nrepetition : bool, optional\n    If `repetition` is True, then the number of combinations with\n    repetition is computed.\n\nReturns\n-------\nval : int, ndarray\n    The total number of combinations.\n\nNotes\n-----\n- Array arguments accepted only for exact=False case.\n- If k > N, N < 0, or k < 0, then a 0 is returned.\n\nExamples\n--------\n>>> k = np.array([3, 4])\n>>> n = np.array([10, 10])\n>>> sc.comb(n, k, exact=False)\narray([ 120.,  210.])\n>>> sc.comb(10, 3, exact=True)\n120L\n>>> sc.comb(10, 3, exact=True, repetition=True)\n220L", "id": "f19460:m62"}
{"signature": "def factorial(n,exact=False):", "body": "if exact:<EOL><INDENT>if n < <NUM_LIT:0>:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>val = <NUM_LIT:1><EOL>for k in xrange(<NUM_LIT:1>,n+<NUM_LIT:1>):<EOL><INDENT>val *= k<EOL><DEDENT>return val<EOL><DEDENT>else:<EOL><INDENT>n = asarray(n)<EOL>vals = gamma(n+<NUM_LIT:1>)<EOL>return where(n >= <NUM_LIT:0>,vals,<NUM_LIT:0>)<EOL><DEDENT>", "docstring": "The factorial function, n! = special.gamma(n+1).\n\nIf exact is 0, then floating point precision is used, otherwise\nexact long integer is computed.\n\n- Array argument accepted only for exact=False case.\n- If n<0, the return value is 0.\n\nParameters\n----------\nn : int or array_like of ints\n    Calculate ``n!``.  Arrays are only supported with `exact` set\n    to False.  If ``n < 0``, the return value is 0.\nexact : bool, optional\n    The result can be approximated rapidly using the gamma-formula\n    above.  If `exact` is set to True, calculate the\n    answer exactly using integer arithmetic. Default is False.\n\nReturns\n-------\nnf : float or int\n    Factorial of `n`, as an integer or a float depending on `exact`.\n\nExamples\n--------\n>>> arr = np.array([3,4,5])\n>>> sc.factorial(arr, exact=False)\narray([   6.,   24.,  120.])\n>>> sc.factorial(5, exact=True)\n120L", "id": "f19460:m64"}
{"signature": "def lqmn(m,n,z):", "body": "if not isscalar(m) or (m < <NUM_LIT:0>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not isscalar(n) or (n < <NUM_LIT:0>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not isscalar(z):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>m = int(m)<EOL>n = int(n)<EOL>mm = max(<NUM_LIT:1>,m)<EOL>nn = max(<NUM_LIT:1>,n)<EOL>if iscomplex(z):<EOL><INDENT>q,qd = specfun.clqmn(mm,nn,z)<EOL><DEDENT>else:<EOL><INDENT>q,qd = specfun.lqmn(mm,nn,z)<EOL><DEDENT>return q[:(m+<NUM_LIT:1>),:(n+<NUM_LIT:1>)],qd[:(m+<NUM_LIT:1>),:(n+<NUM_LIT:1>)]<EOL>", "docstring": "Associated Legendre functions of the second kind, Qmn(z) and its\n    derivative, ``Qmn'(z)`` of order m and degree n.  Returns two\n    arrays of size ``(m+1, n+1)`` containing ``Qmn(z)`` and ``Qmn'(z)`` for\n    all orders from ``0..m`` and degrees from ``0..n``.\n\n    z can be complex.", "id": "f19460:m38"}
{"signature": "def beip_zeros(nt):", "body": "if not isscalar(nt) or (floor(nt) != nt) or (nt <= <NUM_LIT:0>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return specfun.klvnzo(nt,<NUM_LIT:6>)<EOL>", "docstring": "Compute nt zeros of the Kelvin function bei' x", "id": "f19460:m54"}
{"signature": "def jnjnp_zeros(nt):", "body": "if not isscalar(nt) or (floor(nt) != nt) or (nt > <NUM_LIT>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>nt = int(nt)<EOL>n,m,t,zo = specfun.jdzo(nt)<EOL>return zo[<NUM_LIT:1>:nt+<NUM_LIT:1>],n[:nt],m[:nt],t[:nt]<EOL>", "docstring": "Compute nt (<=1200) zeros of the Bessel functions Jn and Jn'\n    and arange them in order of their magnitudes.\n\n    Returns\n    -------\n    zo[l-1] : ndarray\n        Value of the lth zero of Jn(x) and Jn'(x). Of length `nt`.\n    n[l-1] : ndarray\n        Order of the Jn(x) or Jn'(x) associated with lth zero. Of length `nt`.\n    m[l-1] : ndarray\n        Serial number of the zeros of Jn(x) or Jn'(x) associated\n        with lth zero. Of length `nt`.\n    t[l-1] : ndarray\n        0 if lth zero in zo is zero of Jn(x), 1 if it is a zero of Jn'(x). Of\n        length `nt`.\n\n    See Also\n    --------\n    jn_zeros, jnp_zeros : to get separated arrays of zeros.", "id": "f19460:m1"}
{"signature": "def obl_cv_seq(m,n,c):", "body": "if not (isscalar(m) and isscalar(n) and isscalar(c)):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if (n != floor(n)) or (m != floor(m)):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if (n-m > <NUM_LIT>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>maxL = n-m+<NUM_LIT:1><EOL>return specfun.segv(m,n,c,-<NUM_LIT:1>)[<NUM_LIT:1>][:maxL]<EOL>", "docstring": "Compute a sequence of characteristic values for the oblate\n    spheroidal wave functions for mode m and n'=m..n and spheroidal\n    parameter c.", "id": "f19460:m59"}
{"signature": "def y0_zeros(nt,complex=<NUM_LIT:0>):", "body": "if not isscalar(nt) or (floor(nt) != nt) or (nt <= <NUM_LIT:0>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>kf = <NUM_LIT:0><EOL>kc = (complex != <NUM_LIT:1>)<EOL>return specfun.cyzo(nt,kf,kc)<EOL>", "docstring": "Returns nt (complex or real) zeros of Y0(z), z0, and the value\n    of Y0'(z0) = -Y1(z0) at each zero.", "id": "f19460:m7"}
{"signature": "def jn_zeros(n,nt):", "body": "return jnyn_zeros(n,nt)[<NUM_LIT:0>]<EOL>", "docstring": "Compute nt zeros of the Bessel function Jn(x).", "id": "f19460:m3"}
{"signature": "def chebyc(n, monic=False):", "body": "if n < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if n == <NUM_LIT:0>:<EOL><INDENT>n1 = n + <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>n1 = n<EOL><DEDENT>x, w, mu0 = c_roots(n1, mu=True)<EOL>if n == <NUM_LIT:0>:<EOL><INDENT>x, w = [], []<EOL><DEDENT>hn = <NUM_LIT:4> * pi * ((n == <NUM_LIT:0>) + <NUM_LIT:1>)<EOL>kn = <NUM_LIT:1.0><EOL>p = orthopoly1d(x, w, hn, kn,<EOL>wfunc=lambda x: <NUM_LIT:1.0> / sqrt(<NUM_LIT:1> - x * x / <NUM_LIT>),<EOL>limits=(-<NUM_LIT:2>, <NUM_LIT:2>), monic=monic)<EOL>if not monic:<EOL><INDENT>p._scale(<NUM_LIT> / p(<NUM_LIT:2>))<EOL>p.__dict__['<STR_LIT>'] = lambda x: eval_chebyc(n, x)<EOL><DEDENT>return p<EOL>", "docstring": "Return nth order Chebyshev polynomial of first kind, Cn(x).  Orthogonal\n    over [-2,2] with weight function (1-(x/2)**2)**(-1/2).", "id": "f19467:m20"}
{"signature": "def chebyu(n, monic=False):", "body": "base = jacobi(n, <NUM_LIT:0.5>, <NUM_LIT:0.5>, monic=monic)<EOL>if monic:<EOL><INDENT>return base<EOL><DEDENT>factor = sqrt(pi) / <NUM_LIT> * _gam(n + <NUM_LIT:2>) / _gam(n + <NUM_LIT>)<EOL>base._scale(factor)<EOL>return base<EOL>", "docstring": "Return nth order Chebyshev polynomial of second kind, Un(x).  Orthogonal\n    over [-1,1] with weight function (1-x**2)**(1/2).", "id": "f19467:m18"}
{"signature": "def genlaguerre(n, alpha, monic=False):", "body": "if any(alpha <= -<NUM_LIT:1>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if n < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if n == <NUM_LIT:0>:<EOL><INDENT>n1 = n + <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>n1 = n<EOL><DEDENT>x, w, mu0 = la_roots(n1, alpha, mu=True)<EOL>wfunc = lambda x: exp(-x) * x**alpha<EOL>if n == <NUM_LIT:0>:<EOL><INDENT>x, w = [], []<EOL><DEDENT>hn = _gam(n + alpha + <NUM_LIT:1>) / _gam(n + <NUM_LIT:1>)<EOL>kn = (-<NUM_LIT:1>)**n / _gam(n + <NUM_LIT:1>)<EOL>p = orthopoly1d(x, w, hn, kn, wfunc, (<NUM_LIT:0>, inf), monic,<EOL>lambda x: eval_genlaguerre(n, alpha, x))<EOL>return p<EOL>", "docstring": "Returns the nth order generalized (associated) Laguerre polynomial,\n    L^(alpha)_n(x), orthogonal over [0,inf) with weighting function\n    exp(-x) x**alpha with alpha > -1", "id": "f19467:m6"}
{"signature": "def jacobi(n, alpha, beta, monic=False):", "body": "if n < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>wfunc = lambda x: (<NUM_LIT:1> - x)**alpha * (<NUM_LIT:1> + x)**beta<EOL>if n == <NUM_LIT:0>:<EOL><INDENT>return orthopoly1d([], [], <NUM_LIT:1.0>, <NUM_LIT:1.0>, wfunc, (-<NUM_LIT:1>, <NUM_LIT:1>), monic,<EOL>eval_func=np.ones_like)<EOL><DEDENT>x, w, mu = j_roots(n, alpha, beta, mu=True)<EOL>ab1 = alpha + beta + <NUM_LIT:1.0><EOL>hn = <NUM_LIT:2>**ab1 / (<NUM_LIT:2> * n + ab1) * _gam(n + alpha + <NUM_LIT:1>)<EOL>hn *= _gam(n + beta + <NUM_LIT:1.0>) / _gam(n + <NUM_LIT:1>) / _gam(n + ab1)<EOL>kn = _gam(<NUM_LIT:2> * n + ab1) / <NUM_LIT>**n / _gam(n + <NUM_LIT:1>) / _gam(n + ab1)<EOL>p = orthopoly1d(x, w, hn, kn, wfunc, (-<NUM_LIT:1>, <NUM_LIT:1>), monic,<EOL>lambda x: eval_jacobi(n, alpha, beta, x))<EOL>return p<EOL>", "docstring": "Returns the nth order Jacobi polynomial, P^(alpha,beta)_n(x)\n    orthogonal over [-1,1] with weighting function\n    (1-x)**alpha (1+x)**beta with alpha,beta > -1.", "id": "f19467:m2"}
{"signature": "def _dct(x, type, n=None, axis=-<NUM_LIT:1>, overwrite_x=False, normalize=None):", "body": "tmp = np.asarray(x)<EOL>if not np.isrealobj(tmp):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if n is None:<EOL><INDENT>n = tmp.shape[axis]<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\")<EOL><DEDENT>if tmp.dtype == np.double:<EOL><INDENT>if type == <NUM_LIT:1>:<EOL><INDENT>f = _fftpack.ddct1<EOL><DEDENT>elif type == <NUM_LIT:2>:<EOL><INDENT>f = _fftpack.ddct2<EOL><DEDENT>elif type == <NUM_LIT:3>:<EOL><INDENT>f = _fftpack.ddct3<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % type)<EOL><DEDENT><DEDENT>elif tmp.dtype == np.float32:<EOL><INDENT>if type == <NUM_LIT:1>:<EOL><INDENT>f = _fftpack.dct1<EOL><DEDENT>elif type == <NUM_LIT:2>:<EOL><INDENT>f = _fftpack.dct2<EOL><DEDENT>elif type == <NUM_LIT:3>:<EOL><INDENT>f = _fftpack.dct3<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % type)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % tmp.dtype)<EOL><DEDENT>if normalize:<EOL><INDENT>if normalize == \"<STR_LIT>\":<EOL><INDENT>nm = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % normalize)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>nm = <NUM_LIT:0><EOL><DEDENT>if type == <NUM_LIT:1> and n < <NUM_LIT:2>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>overwrite_x = overwrite_x or _datacopied(tmp, x)<EOL>if axis == -<NUM_LIT:1> or axis == len(tmp.shape) - <NUM_LIT:1>:<EOL><INDENT>return f(tmp, n, nm, overwrite_x)<EOL><DEDENT>tmp = np.swapaxes(tmp, axis, -<NUM_LIT:1>)<EOL>tmp = f(tmp, n, nm, overwrite_x)<EOL>return np.swapaxes(tmp, axis, -<NUM_LIT:1>)<EOL>", "docstring": "Return Discrete Cosine Transform of arbitrary type sequence x.\n\nParameters\n----------\nx : array-like\n    input array.\nn : int, optional\n    Length of the transform.\naxis : int, optional\n    Axis along which the dct is computed. (default=-1)\noverwrite_x : bool, optional\n    If True the contents of x can be destroyed. (default=False)\n\nReturns\n-------\nz : real ndarray", "id": "f19475:m2"}
{"signature": "def ifft(x, n=None, axis=-<NUM_LIT:1>, overwrite_x=False):", "body": "tmp = _asfarray(x)<EOL>try:<EOL><INDENT>work_function = _DTYPE_TO_FFT[tmp.dtype]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % tmp.dtype)<EOL><DEDENT>if not (istype(tmp, numpy.complex64) or istype(tmp, numpy.complex128)):<EOL><INDENT>overwrite_x = <NUM_LIT:1><EOL><DEDENT>overwrite_x = overwrite_x or _datacopied(tmp, x)<EOL>if n is None:<EOL><INDENT>n = tmp.shape[axis]<EOL><DEDENT>elif n != tmp.shape[axis]:<EOL><INDENT>tmp, copy_made = _fix_shape(tmp,n,axis)<EOL>overwrite_x = overwrite_x or copy_made<EOL><DEDENT>if n < <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % n)<EOL><DEDENT>if axis == -<NUM_LIT:1> or axis == len(tmp.shape) - <NUM_LIT:1>:<EOL><INDENT>return work_function(tmp,n,-<NUM_LIT:1>,<NUM_LIT:1>,overwrite_x)<EOL><DEDENT>tmp = swapaxes(tmp, axis, -<NUM_LIT:1>)<EOL>tmp = work_function(tmp,n,-<NUM_LIT:1>,<NUM_LIT:1>,overwrite_x)<EOL>return swapaxes(tmp, axis, -<NUM_LIT:1>)<EOL>", "docstring": "Return discrete inverse Fourier transform of real or complex sequence.\n\nThe returned complex array contains ``y(0), y(1),..., y(n-1)`` where\n\n``y(j) = (x * exp(2*pi*sqrt(-1)*j*np.arange(n)/n)).mean()``.\n\nParameters\n----------\nx : array_like\n    Transformed data to invert.\nn : int, optional\n    Length of the inverse Fourier transform.  If ``n < x.shape[axis]``,\n    `x` is truncated.  If ``n > x.shape[axis]``, `x` is zero-padded.\n    The default results in ``n = x.shape[axis]``.\naxis : int, optional\n    Axis along which the ifft's are computed; the default is over the\n    last axis (i.e., ``axis=-1``).\noverwrite_x : bool, optional\n    If True, the contents of `x` can be destroyed; the default is False.\n\nReturns\n-------\nifft : ndarray of floats\n    The inverse discrete Fourier transform.\n\nSee Also\n--------\nfft : Forward FFT\n\nNotes\n-----\nThis function is most efficient when `n` is a power of two, and least\nefficient when `n` is prime.\n\nIf the data type of `x` is real, a \"real IFFT\" algorithm is automatically\nused, which roughly halves the computation time.", "id": "f19476:m11"}
{"signature": "def fft2(x, shape=None, axes=(-<NUM_LIT:2>,-<NUM_LIT:1>), overwrite_x=False):", "body": "return fftn(x,shape,axes,overwrite_x)<EOL>", "docstring": "2-D discrete Fourier transform.\n\nReturn the two-dimensional discrete Fourier transform of the 2-D argument\n`x`.\n\nSee Also\n--------\nfftn : for detailed information.", "id": "f19476:m18"}
{"signature": "def ifftn(x, shape=None, axes=None, overwrite_x=False):", "body": "return _raw_fftn_dispatch(x, shape, axes, overwrite_x, -<NUM_LIT:1>)<EOL>", "docstring": "Return inverse multi-dimensional discrete Fourier transform of\narbitrary type sequence x.\n\nThe returned array contains::\n\n  y[j_1,..,j_d] = 1/p * sum[k_1=0..n_1-1, ..., k_d=0..n_d-1]\n     x[k_1,..,k_d] * prod[i=1..d] exp(sqrt(-1)*2*pi/n_i * j_i * k_i)\n\nwhere ``d = len(x.shape)``, ``n = x.shape``, and ``p = prod[i=1..d] n_i``.\n\nFor description of parameters see `fftn`.\n\nSee Also\n--------\nfftn : for detailed information.", "id": "f19476:m17"}
{"signature": "def _is_safe_size(n):", "body": "n = int(n)<EOL>if n == <NUM_LIT:0>:<EOL><INDENT>return True<EOL><DEDENT>for c in (<NUM_LIT:3>, <NUM_LIT:5>):<EOL><INDENT>while n % c == <NUM_LIT:0>:<EOL><INDENT>n //= c<EOL><DEDENT><DEDENT>return not n & (n-<NUM_LIT:1>)<EOL>", "docstring": "Is the size of FFT such that FFTPACK can handle it in single precision\nwith sufficient accuracy?\n\nComposite numbers of 2, 3, and 5 are accepted, as FFTPACK has those", "id": "f19476:m2"}
{"signature": "def fft(x, n=None, axis=-<NUM_LIT:1>, overwrite_x=False):", "body": "tmp = _asfarray(x)<EOL>try:<EOL><INDENT>work_function = _DTYPE_TO_FFT[tmp.dtype]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % tmp.dtype)<EOL><DEDENT>if not (istype(tmp, numpy.complex64) or istype(tmp, numpy.complex128)):<EOL><INDENT>overwrite_x = <NUM_LIT:1><EOL><DEDENT>overwrite_x = overwrite_x or _datacopied(tmp, x)<EOL>if n is None:<EOL><INDENT>n = tmp.shape[axis]<EOL><DEDENT>elif n != tmp.shape[axis]:<EOL><INDENT>tmp, copy_made = _fix_shape(tmp,n,axis)<EOL>overwrite_x = overwrite_x or copy_made<EOL><DEDENT>if n < <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % n)<EOL><DEDENT>if axis == -<NUM_LIT:1> or axis == len(tmp.shape) - <NUM_LIT:1>:<EOL><INDENT>return work_function(tmp,n,<NUM_LIT:1>,<NUM_LIT:0>,overwrite_x)<EOL><DEDENT>tmp = swapaxes(tmp, axis, -<NUM_LIT:1>)<EOL>tmp = work_function(tmp,n,<NUM_LIT:1>,<NUM_LIT:0>,overwrite_x)<EOL>return swapaxes(tmp, axis, -<NUM_LIT:1>)<EOL>", "docstring": "Return discrete Fourier transform of real or complex sequence.\n\nThe returned complex array contains ``y(0), y(1),..., y(n-1)`` where\n\n``y(j) = (x * exp(-2*pi*sqrt(-1)*j*np.arange(n)/n)).sum()``.\n\nParameters\n----------\nx : array_like\n    Array to Fourier transform.\nn : int, optional\n    Length of the Fourier transform.  If ``n < x.shape[axis]``, `x` is\n    truncated.  If ``n > x.shape[axis]``, `x` is zero-padded. The\n    default results in ``n = x.shape[axis]``.\naxis : int, optional\n    Axis along which the fft's are computed; the default is over the\n    last axis (i.e., ``axis=-1``).\noverwrite_x : bool, optional\n    If True, the contents of `x` can be destroyed; the default is False.\n\nReturns\n-------\nz : complex ndarray\n    with the elements::\n\n        [y(0),y(1),..,y(n/2),y(1-n/2),...,y(-1)]        if n is even\n        [y(0),y(1),..,y((n-1)/2),y(-(n-1)/2),...,y(-1)]  if n is odd\n\n    where::\n\n        y(j) = sum[k=0..n-1] x[k] * exp(-sqrt(-1)*j*k* 2*pi/n), j = 0..n-1\n\n    Note that ``y(-j) = y(n-j).conjugate()``.\n\nSee Also\n--------\nifft : Inverse FFT\nrfft : FFT of a real sequence\n\nNotes\n-----\nThe packing of the result is \"standard\": If ``A = fft(a, n)``, then\n``A[0]`` contains the zero-frequency term, ``A[1:n/2]`` contains the\npositive-frequency terms, and ``A[n/2:]`` contains the negative-frequency\nterms, in order of decreasingly negative frequency. So for an 8-point\ntransform, the frequencies of the result are [0, 1, 2, 3, -4, -3, -2, -1].\nTo rearrange the fft output so that the zero-frequency component is\ncentered, like [-4, -3, -2, -1,  0,  1,  2,  3], use `fftshift`.\n\nFor `n` even, ``A[n/2]`` contains the sum of the positive and\nnegative-frequency terms.  For `n` even and `x` real, ``A[n/2]`` will\nalways be real.\n\nThis function is most efficient when `n` is a power of two, and least\nefficient when `n` is prime.\n\nIf the data type of `x` is real, a \"real FFT\" algorithm is automatically\nused, which roughly halves the computation time.  To increase efficiency\na little further, use `rfft`, which does the same calculation, but only\noutputs half of the symmetrical spectrum.  If the data is both real and\nsymmetrical, the `dct` can again double the efficiency, by generating\nhalf of the spectrum from half of the signal.\n\nExamples\n--------\n>>> from scipy.fftpack import fft, ifft\n>>> x = np.arange(5)\n>>> np.allclose(fft(ifft(x)), x, atol=1e-15)  # within numerical accuracy.\nTrue", "id": "f19476:m10"}
{"signature": "def cc_diff(x, a, b, period=None, _cache=_cache):", "body": "tmp = asarray(x)<EOL>if iscomplexobj(tmp):<EOL><INDENT>return cc_diff(tmp.real,a,b,period) +<NUM_LIT>*cc_diff(tmp.imag,a,b,period)<EOL><DEDENT>if period is not None:<EOL><INDENT>a = a*<NUM_LIT:2>*pi/period<EOL>b = b*<NUM_LIT:2>*pi/period<EOL><DEDENT>n = len(x)<EOL>omega = _cache.get((n,a,b))<EOL>if omega is None:<EOL><INDENT>if len(_cache) > <NUM_LIT:20>:<EOL><INDENT>while _cache:<EOL><INDENT>_cache.popitem()<EOL><DEDENT><DEDENT>def kernel(k,a=a,b=b):<EOL><INDENT>return cosh(a*k)/cosh(b*k)<EOL><DEDENT>omega = convolve.init_convolution_kernel(n,kernel)<EOL>_cache[(n,a,b)] = omega<EOL><DEDENT>overwrite_x = _datacopied(tmp, x)<EOL>return convolve.convolve(tmp,omega,overwrite_x=overwrite_x)<EOL>", "docstring": "Return (a,b)-cosh/cosh pseudo-derivative of a periodic sequence.\n\nIf x_j and y_j are Fourier coefficients of periodic functions x\nand y, respectively, then::\n\n  y_j = cosh(j*a*2*pi/period)/cosh(j*b*2*pi/period) * x_j\n\nParameters\n----------\nx : array_like\n    The array to take the pseudo-derivative from.\na,b : float\n    Defines the parameters of the sinh/sinh pseudo-differential\n    operator.\nperiod : float, optional\n    The period of the sequence x. Default is ``2*pi``.\n\nReturns\n-------\ncc_diff : ndarray\n    Pseudo-derivative of periodic sequence `x`.\n\nNotes\n-----\n``cc_diff(cc_diff(x,a,b),b,a) == x``", "id": "f19482:m8"}
{"signature": "def ss_diff(x, a, b, period=None, _cache=_cache):", "body": "tmp = asarray(x)<EOL>if iscomplexobj(tmp):<EOL><INDENT>return ss_diff(tmp.real,a,b,period) +<NUM_LIT>*ss_diff(tmp.imag,a,b,period)<EOL><DEDENT>if period is not None:<EOL><INDENT>a = a*<NUM_LIT:2>*pi/period<EOL>b = b*<NUM_LIT:2>*pi/period<EOL><DEDENT>n = len(x)<EOL>omega = _cache.get((n,a,b))<EOL>if omega is None:<EOL><INDENT>if len(_cache) > <NUM_LIT:20>:<EOL><INDENT>while _cache:<EOL><INDENT>_cache.popitem()<EOL><DEDENT><DEDENT>def kernel(k,a=a,b=b):<EOL><INDENT>if k:<EOL><INDENT>return sinh(a*k)/sinh(b*k)<EOL><DEDENT>return float(a)/b<EOL><DEDENT>omega = convolve.init_convolution_kernel(n,kernel)<EOL>_cache[(n,a,b)] = omega<EOL><DEDENT>overwrite_x = _datacopied(tmp, x)<EOL>return convolve.convolve(tmp,omega,overwrite_x=overwrite_x)<EOL>", "docstring": "Return (a,b)-sinh/sinh pseudo-derivative of a periodic sequence x.\n\nIf x_j and y_j are Fourier coefficients of periodic functions x\nand y, respectively, then::\n\n  y_j = sinh(j*a*2*pi/period)/sinh(j*b*2*pi/period) * x_j\n  y_0 = a/b * x_0\n\nParameters\n----------\nx : array_like\n    The array to take the pseudo-derivative from.\na,b\n    Defines the parameters of the sinh/sinh pseudo-differential\n    operator.\nperiod : float, optional\n    The period of the sequence x. Default is ``2*pi``.\n\nNotes\n-----\n``ss_diff(ss_diff(x,a,b),b,a) == x``", "id": "f19482:m7"}
{"signature": "def hilbert(x, _cache=_cache):", "body": "tmp = asarray(x)<EOL>if iscomplexobj(tmp):<EOL><INDENT>return hilbert(tmp.real)+<NUM_LIT>*hilbert(tmp.imag)<EOL><DEDENT>n = len(x)<EOL>omega = _cache.get(n)<EOL>if omega is None:<EOL><INDENT>if len(_cache) > <NUM_LIT:20>:<EOL><INDENT>while _cache:<EOL><INDENT>_cache.popitem()<EOL><DEDENT><DEDENT>def kernel(k):<EOL><INDENT>if k > <NUM_LIT:0>:<EOL><INDENT>return <NUM_LIT:1.0><EOL><DEDENT>elif k < <NUM_LIT:0>:<EOL><INDENT>return -<NUM_LIT:1.0><EOL><DEDENT>return <NUM_LIT:0.0><EOL><DEDENT>omega = convolve.init_convolution_kernel(n,kernel,d=<NUM_LIT:1>)<EOL>_cache[n] = omega<EOL><DEDENT>overwrite_x = _datacopied(tmp, x)<EOL>return convolve.convolve(tmp,omega,swap_real_imag=<NUM_LIT:1>,overwrite_x=overwrite_x)<EOL>", "docstring": "Return Hilbert transform of a periodic sequence x.\n\nIf x_j and y_j are Fourier coefficients of periodic functions x\nand y, respectively, then::\n\n  y_j = sqrt(-1)*sign(j) * x_j\n  y_0 = 0\n\nParameters\n----------\nx : array_like\n    The input array, should be periodic.\n_cache : dict, optional\n    Dictionary that contains the kernel used to do a convolution with.\n\nReturns\n-------\ny : ndarray\n    The transformed input.\n\nNotes\n-----\nIf ``sum(x, axis=0) == 0`` then ``hilbert(ihilbert(x)) == x``.\n\nFor even len(x), the Nyquist mode of x is taken zero.\n\nThe sign of the returned transform does not have a factor -1 that is more\noften than not found in the definition of the Hilbert transform.  Note also\nthat ``scipy.signal.hilbert`` does have an extra -1 factor compared to this\nfunction.", "id": "f19482:m3"}
{"signature": "def set_meta(self, **kwds):", "body": "self.meta.update(kwds)<EOL>", "docstring": "Update the metadata dictionary with the keywords and data provided\n        by keywords.\n\n        Examples\n        --------\n        >>> data.set_meta(lab=\"Ph 7; Lab 26\", title=\"Ag110 + Ag108 Decay\")", "id": "f19485:c2:m1"}
{"signature": "def run(self):", "body": "args = (self.model.fcn, self.beta0, self.data.y, self.data.x)<EOL>kwds = {'<STR_LIT>': <NUM_LIT:1>}<EOL>kwd_l = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>if self.delta0 is not None and self.job % <NUM_LIT:1000> // <NUM_LIT:10> == <NUM_LIT:1>:<EOL><INDENT>self._gen_work()<EOL>d0 = numpy.ravel(self.delta0)<EOL>self.work[:len(d0)] = d0<EOL><DEDENT>if self.model.fjacb is not None:<EOL><INDENT>kwds['<STR_LIT>'] = self.model.fjacb<EOL><DEDENT>if self.model.fjacd is not None:<EOL><INDENT>kwds['<STR_LIT>'] = self.model.fjacd<EOL><DEDENT>if self.data.we is not None:<EOL><INDENT>kwds['<STR_LIT>'] = self.data.we<EOL><DEDENT>if self.data.wd is not None:<EOL><INDENT>kwds['<STR_LIT>'] = self.data.wd<EOL><DEDENT>if self.model.extra_args is not None:<EOL><INDENT>kwds['<STR_LIT>'] = self.model.extra_args<EOL><DEDENT>for attr in kwd_l:<EOL><INDENT>obj = getattr(self, attr)<EOL>if obj is not None:<EOL><INDENT>kwds[attr] = obj<EOL><DEDENT><DEDENT>self.output = Output(odr(*args, **kwds))<EOL>return self.output<EOL>", "docstring": "Run the fitting routine with all of the information given.\n\n        Returns\n        -------\n        output : Output instance\n            This object is also assigned to the attribute .output .", "id": "f19485:c6:m5"}
{"signature": "def _check(self):", "body": "x_s = list(self.data.x.shape)<EOL>if isinstance(self.data.y, numpy.ndarray):<EOL><INDENT>y_s = list(self.data.y.shape)<EOL>if self.model.implicit:<EOL><INDENT>raise odr_error(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>y_s = [self.data.y, x_s[-<NUM_LIT:1>]]<EOL>if not self.model.implicit:<EOL><INDENT>raise odr_error(\"<STR_LIT>\")<EOL><DEDENT>self.set_job(fit_type=<NUM_LIT:1>)<EOL><DEDENT>if x_s[-<NUM_LIT:1>] != y_s[-<NUM_LIT:1>]:<EOL><INDENT>raise odr_error(\"<STR_LIT>\")<EOL><DEDENT>n = x_s[-<NUM_LIT:1>]<EOL>if len(x_s) == <NUM_LIT:2>:<EOL><INDENT>m = x_s[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>m = <NUM_LIT:1><EOL><DEDENT>if len(y_s) == <NUM_LIT:2>:<EOL><INDENT>q = y_s[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>q = <NUM_LIT:1><EOL><DEDENT>p = len(self.beta0)<EOL>fcn_perms = [(q, n)]<EOL>fjacd_perms = [(q, m, n)]<EOL>fjacb_perms = [(q, p, n)]<EOL>if q == <NUM_LIT:1>:<EOL><INDENT>fcn_perms.append((n,))<EOL>fjacd_perms.append((m, n))<EOL>fjacb_perms.append((p, n))<EOL><DEDENT>if m == <NUM_LIT:1>:<EOL><INDENT>fjacd_perms.append((q, n))<EOL><DEDENT>if p == <NUM_LIT:1>:<EOL><INDENT>fjacb_perms.append((q, n))<EOL><DEDENT>if m == q == <NUM_LIT:1>:<EOL><INDENT>fjacd_perms.append((n,))<EOL><DEDENT>if p == q == <NUM_LIT:1>:<EOL><INDENT>fjacb_perms.append((n,))<EOL><DEDENT>arglist = (self.beta0, self.data.x)<EOL>if self.model.extra_args is not None:<EOL><INDENT>arglist = arglist + self.model.extra_args<EOL><DEDENT>res = self.model.fcn(*arglist)<EOL>if res.shape not in fcn_perms:<EOL><INDENT>print(res.shape)<EOL>print(fcn_perms)<EOL>raise odr_error(\"<STR_LIT>\" % y_s)<EOL><DEDENT>if self.model.fjacd is not None:<EOL><INDENT>res = self.model.fjacd(*arglist)<EOL>if res.shape not in fjacd_perms:<EOL><INDENT>raise odr_error(<EOL>\"<STR_LIT>\" % (q, m, n))<EOL><DEDENT><DEDENT>if self.model.fjacb is not None:<EOL><INDENT>res = self.model.fjacb(*arglist)<EOL>if res.shape not in fjacb_perms:<EOL><INDENT>raise odr_error(<EOL>\"<STR_LIT>\" % (q, p, n))<EOL><DEDENT><DEDENT>if self.delta0 is not None and self.delta0.shape != self.data.x.shape:<EOL><INDENT>raise odr_error(<EOL>\"<STR_LIT>\" % self.data.x.shape)<EOL><DEDENT>", "docstring": "Check the inputs for consistency, but don't bother checking things\n        that the builtin function odr will check.", "id": "f19485:c6:m1"}
{"signature": "def __getattr__(self, attr):", "body": "if attr in self.meta:<EOL><INDENT>return self.meta[attr]<EOL><DEDENT>else:<EOL><INDENT>raise AttributeError(\"<STR_LIT>\" % attr)<EOL><DEDENT>", "docstring": "Dispatch attribute access to the metadata.", "id": "f19485:c4:m2"}
{"signature": "def update(self, func, **kw):", "body": "func.__name__ = self.name<EOL>func.__doc__ = getattr(self, '<STR_LIT>', None)<EOL>func.__dict__ = getattr(self, '<STR_LIT>', {})<EOL>if sys.version_info[<NUM_LIT:0>] >= <NUM_LIT:3>:<EOL><INDENT>func.__defaults__ = getattr(self, '<STR_LIT>', ())<EOL><DEDENT>else:<EOL><INDENT>func.func_defaults = getattr(self, '<STR_LIT>', ())<EOL><DEDENT>func.__kwdefaults__ = getattr(self, '<STR_LIT>', None)<EOL>callermodule = sys._getframe(<NUM_LIT:3>).f_globals.get('<STR_LIT>', '<STR_LIT:?>')<EOL>func.__module__ = getattr(self, '<STR_LIT>', callermodule)<EOL>func.__dict__.update(kw)<EOL>", "docstring": "Update the signature of func with the data in self", "id": "f19491:c0:m1"}
{"signature": "def make(self, src_templ, evaldict=None, addsource=False, **attrs):", "body": "src = src_templ % vars(self)  <EOL>evaldict = evaldict or {}<EOL>mo = DEF.match(src)<EOL>if mo is None:<EOL><INDENT>raise SyntaxError('<STR_LIT>' % src)<EOL><DEDENT>name = mo.group(<NUM_LIT:1>)  <EOL>names = set([name] + [arg.strip('<STR_LIT>') for arg in<EOL>self.shortsignature.split('<STR_LIT:U+002C>')])<EOL>for n in names:<EOL><INDENT>if n in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>raise NameError('<STR_LIT>' % (n, src))<EOL><DEDENT><DEDENT>if not src.endswith('<STR_LIT:\\n>'):  <EOL><INDENT>src += '<STR_LIT:\\n>'  <EOL><DEDENT>try:<EOL><INDENT>code = compile(src, '<STR_LIT>', '<STR_LIT>')<EOL>exec_(code, evaldict)<EOL><DEDENT>except:<EOL><INDENT>print('<STR_LIT>', file=sys.stderr)<EOL>print(src, file=sys.stderr)<EOL>raise<EOL><DEDENT>func = evaldict[name]<EOL>if addsource:<EOL><INDENT>attrs['<STR_LIT>'] = src<EOL><DEDENT>self.update(func, **attrs)<EOL>return func<EOL>", "docstring": "Make a new function from a given template and update the signature", "id": "f19491:c0:m2"}
{"signature": "@classmethod<EOL><INDENT>def create(cls, obj, body, evaldict, defaults=None,<EOL>doc=None, module=None, addsource=True, **attrs):<DEDENT>", "body": "if isinstance(obj, str):  <EOL><INDENT>name, rest = obj.strip().split('<STR_LIT:(>', <NUM_LIT:1>)<EOL>signature = rest[:-<NUM_LIT:1>]  <EOL>func = None<EOL><DEDENT>else:  <EOL><INDENT>name = None<EOL>signature = None<EOL>func = obj<EOL><DEDENT>self = cls(func, name, signature, defaults, doc, module)<EOL>ibody = '<STR_LIT:\\n>'.join('<STR_LIT:U+0020>' + line for line in body.splitlines())<EOL>return self.make('<STR_LIT>' + ibody,<EOL>evaldict, addsource, **attrs)<EOL>", "docstring": "Create a function from the strings name, signature and body.\nevaldict is the evaluation dictionary. If addsource is true an attribute\n__source__ is added to the result. The attributes attrs are added,\nif any.", "id": "f19491:c0:m3"}
{"signature": "@contextmanager<EOL>def gc_state(state):", "body": "orig_state = gc.isenabled()<EOL>set_gc_state(state)<EOL>yield<EOL>set_gc_state(orig_state)<EOL>", "docstring": "Context manager to set state of garbage collector to `state`\n\n    Parameters\n    ----------\n    state : bool\n        True for gc enabled, False for disabled\n\n    Examples\n    --------\n    >>> with gc_state(False):\n    ...     assert not gc.isenabled()\n    >>> with gc_state(True):\n    ...     assert gc.isenabled()", "id": "f19496:m1"}
{"signature": "@contextmanager<EOL>def assert_deallocated(func, *args, **kwargs):", "body": "with gc_state(False):<EOL><INDENT>obj = func(*args, **kwargs)<EOL>ref = weakref.ref(obj)<EOL>yield obj<EOL>del obj<EOL>if ref() is not None:<EOL><INDENT>raise ReferenceError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>", "docstring": "Context manager to check that object is deallocated\n\n    This is useful for checking that an object can be freed directly by\n    reference counting, without requiring gc to break reference cycles.\n    GC is disabled inside the context manager.\n\n    Parameters\n    ----------\n    func : callable\n        Callable to create object to check\n    \\*args : sequence\n        positional arguments to `func` in order to create object to check\n    \\*\\*kwargs : dict\n        keyword arguments to `func` in order to create object to check\n\n    Examples\n    --------\n    >>> class C(object): pass\n    >>> with assert_deallocated(C) as c:\n    ...     # do something\n    ...     del c\n\n    >>> class C(object):\n    ...     def __init__(self):\n    ...         self._circular = self # Make circular reference\n    >>> with assert_deallocated(C) as c: #doctest: +IGNORE_EXCEPTION_DETAIL\n    ...     # do something\n    ...     del c\n    Traceback (most recent call last):\n        ...\n    ReferenceError: Remaining reference(s) to object", "id": "f19496:m2"}
{"signature": "def iterkeys(d):", "body": "return iter(getattr(d, _iterkeys)())<EOL>", "docstring": "Return an iterator over the keys of a dictionary.", "id": "f19497:m2"}
{"signature": "def iteritems(d):", "body": "return iter(getattr(d, _iteritems)())<EOL>", "docstring": "Return an iterator over the (key, value) pairs of a dictionary.", "id": "f19497:m4"}
{"signature": "def with_metaclass(meta, base=object):", "body": "return meta(\"<STR_LIT>\", (base,), {})<EOL>", "docstring": "Create a base class with a metaclass.", "id": "f19497:m5"}
{"signature": "def _compare_pre_release(self, other):", "body": "if self.pre_release == other.pre_release:<EOL><INDENT>vercmp = <NUM_LIT:0><EOL><DEDENT>elif self.pre_release == '<STR_LIT>':<EOL><INDENT>vercmp = <NUM_LIT:1><EOL><DEDENT>elif other.pre_release == '<STR_LIT>':<EOL><INDENT>vercmp = -<NUM_LIT:1><EOL><DEDENT>elif self.pre_release > other.pre_release:<EOL><INDENT>vercmp = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>vercmp = -<NUM_LIT:1><EOL><DEDENT>return vercmp<EOL>", "docstring": "Compare alpha/beta/rc/final.", "id": "f19498:c0:m2"}
{"signature": "@deprecate<EOL>def get_lapack_funcs(names,arrays=(),debug=<NUM_LIT:0>,force_clapack=<NUM_LIT:1>):", "body": "<EOL>force_clapack = <NUM_LIT:0><EOL>ordering = []<EOL>for i in range(len(arrays)):<EOL><INDENT>t = arrays[i].dtype.char<EOL>if t not in _type_conv:<EOL><INDENT>t = '<STR_LIT:d>'<EOL><DEDENT>ordering.append((t,i))<EOL><DEDENT>if ordering:<EOL><INDENT>ordering.sort()<EOL>required_prefix = _type_conv[ordering[<NUM_LIT:0>][<NUM_LIT:0>]]<EOL><DEDENT>else:<EOL><INDENT>required_prefix = '<STR_LIT:d>'<EOL><DEDENT>dtypechar = _inv_type_conv[required_prefix]<EOL>if ordering and arrays[ordering[<NUM_LIT:0>][<NUM_LIT:1>]].flags['<STR_LIT>']:<EOL><INDENT>m1,m2 = flapack,clapack<EOL><DEDENT>else:<EOL><INDENT>m1,m2 = clapack,flapack<EOL><DEDENT>if not _use_force_clapack:<EOL><INDENT>force_clapack = <NUM_LIT:0><EOL><DEDENT>funcs = []<EOL>m1_name = m1.__name__.split('<STR_LIT:.>')[-<NUM_LIT:1>]<EOL>m2_name = m2.__name__.split('<STR_LIT:.>')[-<NUM_LIT:1>]<EOL>for name in names:<EOL><INDENT>func_name = required_prefix + name<EOL>func = getattr(m1,func_name,None)<EOL>if func is None:<EOL><INDENT>func = getattr(m2,func_name)<EOL>func.module_name = m2_name<EOL><DEDENT>else:<EOL><INDENT>func.module_name = m1_name<EOL>if force_clapack and m1 is flapack:<EOL><INDENT>func2 = getattr(m2,func_name,None)<EOL>if func2 is not None:<EOL><INDENT>import new<EOL>func_code = None   <EOL>exec(_colmajor_func_template % {'<STR_LIT>':func_name})<EOL>func = new.function(func_code,{'<STR_LIT>':func2},func_name)<EOL>func.module_name = m2_name<EOL>func.__doc__ = func2.__doc__<EOL><DEDENT><DEDENT><DEDENT>func.prefix = required_prefix<EOL>func.dtypechar = dtypechar<EOL>funcs.append(func)<EOL><DEDENT>return tuple(funcs)<EOL>", "docstring": "Return available LAPACK function objects with names.\n    arrays are used to determine the optimal prefix of\n    LAPACK routines.\n    If force_clapack is True then available Atlas routine\n    is returned for column major storaged arrays with\n    rowmajor argument set to False.", "id": "f19503:m1"}
{"signature": "def _with_data(self, data, copy=True):", "body": "if copy:<EOL><INDENT>return dia_matrix((data, self.offsets.copy()), shape=self.shape)<EOL><DEDENT>else:<EOL><INDENT>return dia_matrix((data,self.offsets), shape=self.shape)<EOL><DEDENT>", "docstring": "Returns a matrix with the same sparsity structure as self,\n        but with different data.  By default the structure arrays are copied.", "id": "f19514:c0:m10"}
{"signature": "def validate_graph(csgraph, directed, dtype=DTYPE,<EOL>csr_output=True, dense_output=True,<EOL>copy_if_dense=False, copy_if_sparse=False,<EOL>null_value_in=<NUM_LIT:0>, null_value_out=np.inf,<EOL>infinity_null=True, nan_null=True):", "body": "if not (csr_output or dense_output):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if (not directed) and isspmatrix_csc(csgraph):<EOL><INDENT>csgraph = csgraph.T<EOL><DEDENT>if isspmatrix(csgraph):<EOL><INDENT>if csr_output:<EOL><INDENT>csgraph = csr_matrix(csgraph, dtype=DTYPE, copy=copy_if_sparse)<EOL><DEDENT>else:<EOL><INDENT>csgraph = csgraph_to_dense(csgraph, null_value=null_value_out)<EOL><DEDENT><DEDENT>elif np.ma.isMaskedArray(csgraph):<EOL><INDENT>if dense_output:<EOL><INDENT>mask = csgraph.mask<EOL>csgraph = np.array(csgraph.data, dtype=DTYPE, copy=copy_if_dense)<EOL>csgraph[mask] = null_value_out<EOL><DEDENT>else:<EOL><INDENT>csgraph = csgraph_from_masked(csgraph)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if dense_output:<EOL><INDENT>csgraph = csgraph_masked_from_dense(csgraph,<EOL>copy=copy_if_dense,<EOL>null_value=null_value_in,<EOL>nan_null=nan_null,<EOL>infinity_null=infinity_null)<EOL>mask = csgraph.mask<EOL>csgraph = np.asarray(csgraph.data, dtype=DTYPE)<EOL>csgraph[mask] = null_value_out<EOL><DEDENT>else:<EOL><INDENT>csgraph = csgraph_from_dense(csgraph, null_value=null_value_in,<EOL>infinity_null=infinity_null,<EOL>nan_null=nan_null)<EOL><DEDENT><DEDENT>if csgraph.ndim != <NUM_LIT:2>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if csgraph.shape[<NUM_LIT:0>] != csgraph.shape[<NUM_LIT:1>]:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return csgraph<EOL>", "docstring": "Routine for validation and conversion of csgraph inputs", "id": "f19525:m0"}
{"signature": "def diags(diagonals, offsets, shape=None, format=None, dtype=None):", "body": "<EOL>try:<EOL><INDENT>iter(offsets)<EOL><DEDENT>except TypeError:<EOL><INDENT>try:<EOL><INDENT>iter(diagonals[<NUM_LIT:0>])<EOL><DEDENT>except TypeError:<EOL><INDENT>diagonals = [np.atleast_1d(diagonals)]<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>else:<EOL><INDENT>diagonals = list(map(np.atleast_1d, diagonals))<EOL><DEDENT>offsets = np.atleast_1d(offsets)<EOL>if len(diagonals) != len(offsets):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if shape is None:<EOL><INDENT>m = len(diagonals[<NUM_LIT:0>]) + abs(int(offsets[<NUM_LIT:0>]))<EOL>shape = (m, m)<EOL><DEDENT>if dtype is None:<EOL><INDENT>dtype = np.common_type(*diagonals)<EOL><DEDENT>m, n = shape<EOL>M = max([min(m + offset, n - offset) + max(<NUM_LIT:0>, offset)<EOL>for offset in offsets])<EOL>M = max(<NUM_LIT:0>, M)<EOL>data_arr = np.zeros((len(offsets), M), dtype=dtype)<EOL>for j, diagonal in enumerate(diagonals):<EOL><INDENT>offset = offsets[j]<EOL>k = max(<NUM_LIT:0>, offset)<EOL>length = min(m + offset, n - offset)<EOL>if length <= <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % (offset, j))<EOL><DEDENT>try:<EOL><INDENT>data_arr[j, k:k+length] = diagonal<EOL><DEDENT>except ValueError:<EOL><INDENT>if len(diagonal) != length and len(diagonal) != <NUM_LIT:1>:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (<EOL>j, len(diagonal), offset, m, n))<EOL><DEDENT>raise<EOL><DEDENT><DEDENT>return dia_matrix((data_arr, offsets), shape=(m, n)).asformat(format)<EOL>", "docstring": "Construct a sparse matrix from diagonals.\n\nParameters\n----------\ndiagonals : sequence of array_like\n    Sequence of arrays containing the matrix diagonals,\n    corresponding to `offsets`.\noffsets  : sequence of int\n    Diagonals to set:\n      - k = 0  the main diagonal\n      - k > 0  the k-th upper diagonal\n      - k < 0  the k-th lower diagonal\nshape : tuple of int, optional\n    Shape of the result. If omitted, a square matrix large enough\n    to contain the diagonals is returned.\nformat : {\"dia\", \"csr\", \"csc\", \"lil\", ...}, optional\n    Matrix format of the result.  By default (format=None) an\n    appropriate sparse matrix format is returned.  This choice is\n    subject to change.\ndtype : dtype, optional\n    Data type of the matrix.\n\nSee Also\n--------\nspdiags : construct matrix from diagonals\n\nNotes\n-----\nThis function differs from `spdiags` in the way it handles\noff-diagonals.\n\nThe result from `diags` is the sparse equivalent of::\n\n    np.diag(diagonals[0], offsets[0])\n    + ...\n    + np.diag(diagonals[k], offsets[k])\n\nRepeated diagonal offsets are disallowed.\n\n.. versionadded:: 0.11\n\nExamples\n--------\n>>> diagonals = [[1, 2, 3, 4], [1, 2, 3], [1, 2]]\n>>> diags(diagonals, [0, -1, 2]).toarray()\narray([[1, 0, 1, 0],\n       [1, 2, 0, 2],\n       [0, 2, 3, 0],\n       [0, 0, 3, 4]])\n\nBroadcasting of scalars is supported (but shape needs to be\nspecified):\n\n>>> diags([1, -2, 1], [-1, 0, 1], shape=(4, 4)).toarray()\narray([[-2.,  1.,  0.,  0.],\n       [ 1., -2.,  1.,  0.],\n       [ 0.,  1., -2.,  1.],\n       [ 0.,  0.,  1., -2.]])\n\n\nIf only one diagonal is wanted (as in `numpy.diag`), the following\nworks as well:\n\n>>> diags([1, 2, 3], 1).toarray()\narray([[ 0.,  1.,  0.,  0.],\n       [ 0.,  0.,  2.,  0.],\n       [ 0.,  0.,  0.,  3.],\n       [ 0.,  0.,  0.,  0.]])", "id": "f19529:m1"}
{"signature": "def _arg1_for_noncanonical(self, M):", "body": "data, indices, indptr = _same_sum_duplicate(M.data, M.indices,<EOL>indptr=M.indptr)<EOL>for start, stop in izip(indptr, indptr[<NUM_LIT:1>:]):<EOL><INDENT>indices[start:stop] = indices[start:stop][::-<NUM_LIT:1>].copy()<EOL>data[start:stop] = data[start:stop][::-<NUM_LIT:1>].copy()<EOL><DEDENT>return data, indices, indptr<EOL>", "docstring": "Return non-canonical constructor arg1 equivalent to M", "id": "f19532:c23:m0"}
{"signature": "def _possibly_unimplemented(cls, require=True):", "body": "if require:<EOL><INDENT>return cls<EOL><DEDENT>else:<EOL><INDENT>def wrap(fc):<EOL><INDENT>def wrapper(*a, **kw):<EOL><INDENT>try:<EOL><INDENT>return fc(*a, **kw)<EOL><DEDENT>except (NotImplementedError, TypeError, ValueError,<EOL>IndexError, AttributeError):<EOL><INDENT>raise nose.SkipTest(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>wrapper.__name__ = fc.__name__<EOL>return wrapper<EOL><DEDENT>new_dict = dict(cls.__dict__)<EOL>for name, func in cls.__dict__.items():<EOL><INDENT>if name.startswith('<STR_LIT>'):<EOL><INDENT>new_dict[name] = wrap(func)<EOL><DEDENT><DEDENT>return type(cls.__name__ + \"<STR_LIT>\",<EOL>cls.__bases__,<EOL>new_dict)<EOL><DEDENT>", "docstring": "Construct a class that either runs tests as usual (require=True),\nor each method raises SkipTest if it encounters a common error.", "id": "f19532:m4"}
{"signature": "def _compute_p_max(m_max):", "body": "sqrt_m_max = np.sqrt(m_max)<EOL>p_low = int(np.floor(sqrt_m_max))<EOL>p_high = int(np.ceil(sqrt_m_max + <NUM_LIT:1>))<EOL>return max(p for p in range(p_low, p_high+<NUM_LIT:1>) if p*(p-<NUM_LIT:1>) <= m_max + <NUM_LIT:1>)<EOL>", "docstring": "Compute the largest positive integer p such that p*(p-1) <= m_max + 1.\n\nDo this in a slightly dumb way, but safe and not too slow.\n\nParameters\n----------\nm_max : int\n    A count related to bounds.", "id": "f19538:m9"}
{"signature": "def _expm_multiply_interval_core_0(A, X, h, mu, m_star, s, q):", "body": "for k in range(q):<EOL><INDENT>X[k+<NUM_LIT:1>] = _expm_multiply_simple_core(A, X[k], h, mu, m_star, s)<EOL><DEDENT>return X, <NUM_LIT:0><EOL>", "docstring": "A helper function, for the case q <= s.", "id": "f19538:m13"}
{"signature": "def expm_multiply(A, B, start=None, stop=None, num=None, endpoint=None):", "body": "if all(arg is None for arg in (start, stop, num, endpoint)):<EOL><INDENT>X = _expm_multiply_simple(A, B)<EOL><DEDENT>else:<EOL><INDENT>X, status = _expm_multiply_interval(A, B, start, stop, num, endpoint)<EOL><DEDENT>return X<EOL>", "docstring": "Compute the action of the matrix exponential of A on B.\n\nParameters\n----------\nA : transposable linear operator\n    The operator whose exponential is of interest.\nB : ndarray\n    The matrix or vector to be multiplied by the matrix exponential of A.\nstart : scalar, optional\n    The starting time point of the sequence.\nstop : scalar, optional\n    The end time point of the sequence, unless `endpoint` is set to False.\n    In that case, the sequence consists of all but the last of ``num + 1``\n    evenly spaced time points, so that `stop` is excluded.\n    Note that the step size changes when `endpoint` is False.\nnum : int, optional\n    Number of time points to use.\nendpoint : bool, optional\n    If True, `stop` is the last time point.  Otherwise, it is not included.\n\nReturns\n-------\nexpm_A_B : ndarray\n     The result of the action :math:`e^{t_k A} B`.\n\nNotes\n-----\nThe optional arguments defining the sequence of evenly spaced time points\nare compatible with the arguments of `numpy.linspace`.\n\nThe output ndarray shape is somewhat complicated so I explain it here.\nThe ndim of the output could be either 1, 2, or 3.\nIt would be 1 if you are computing the expm action on a single vector\nat a single time point.\nIt would be 2 if you are computing the expm action on a vector\nat multiple time points, or if you are computing the expm action\non a matrix at a single time point.\nIt would be 3 if you want the action on a matrix with multiple\ncolumns at multiple time points.\nIf multiple time points are requested, expm_A_B[0] will always\nbe the action of the expm at the first time point,\nregardless of whether the action is on a vector or a matrix.\n\nReferences\n----------\n.. [1] Awad H. Al-Mohy and Nicholas J. Higham (2011)\n       \"Computing the Action of the Matrix Exponential,\n       with an Application to Exponential Integrators.\"\n       SIAM Journal on Scientific Computing,\n       33 (2). pp. 488-511. ISSN 1064-8275\n       http://eprints.ma.man.ac.uk/1591/\n\n.. [2] Nicholas J. Higham and Awad H. Al-Mohy (2010)\n       \"Computing Matrix Functions.\"\n       Acta Numerica,\n       19. 159-208. ISSN 0962-4929\n       http://eprints.ma.man.ac.uk/1451/", "id": "f19538:m4"}
{"signature": "def d(self, p):", "body": "if p not in self._d:<EOL><INDENT>est = _onenormest_matrix_power(self._A, p, self._ell)<EOL>self._d[p] = est ** (<NUM_LIT:1.0> / p)<EOL><DEDENT>return self._d[p]<EOL>", "docstring": "Lazily estimate d_p(A) ~= || A^p ||^(1/p) where ||.|| is the 1-norm.", "id": "f19538:c1:m2"}
{"signature": "def _condition_3_13(A_1_norm, n0, m_max, ell):", "body": "<EOL>p_max = _compute_p_max(m_max)<EOL>a = <NUM_LIT:2> * ell * p_max * (p_max + <NUM_LIT:3>)<EOL>b = _theta[m_max] / float(n0 * m_max)<EOL>return A_1_norm <= a * b<EOL>", "docstring": "A helper function for the _expm_multiply_* functions.\n\nParameters\n----------\nA_1_norm : float\n    The precomputed 1-norm of A.\nn0 : int\n    Number of columns in the _expm_multiply_* B matrix.\nm_max : int\n    A value related to a bound.\nell : int\n    The number of columns used in the 1-norm approximation.\n    This is usually taken to be small, maybe between 1 and 5.\n\nReturns\n-------\nvalue : bool\n    Indicates whether or not the condition has been met.\n\nNotes\n-----\nThis is condition (3.13) in Al-Mohy and Higham (2011).", "id": "f19538:m11"}
{"signature": "def _burkardt_13_power(n, p):", "body": "<EOL>if n != int(n) or n < <NUM_LIT:2>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>n = int(n)<EOL>if p != int(p) or p < <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>p = int(p)<EOL>a, b = divmod(p, n)<EOL>large = np.power(<NUM_LIT>, -n*a)<EOL>small = large * np.power(<NUM_LIT>, -n)<EOL>return np.diag([large]*(n-b), b) + np.diag([small]*b, b-n)<EOL>", "docstring": "A helper function for testing matrix functions.\n\nParameters\n----------\nn : integer greater than 1\n    Order of the square matrix to be returned.\np : non-negative integer\n    Power of the matrix.\n\nReturns\n-------\nout : ndarray representing a square matrix\n    A Forsythe matrix of order n, raised to the power p.", "id": "f19539:m0"}
{"signature": "def lsqr(A, b, damp=<NUM_LIT:0.0>, atol=<NUM_LIT>, btol=<NUM_LIT>, conlim=<NUM_LIT>,<EOL>iter_lim=None, show=False, calc_var=False):", "body": "A = aslinearoperator(A)<EOL>if len(b.shape) > <NUM_LIT:1>:<EOL><INDENT>b = b.squeeze()<EOL><DEDENT>m, n = A.shape<EOL>if iter_lim is None:<EOL><INDENT>iter_lim = <NUM_LIT:2> * n<EOL><DEDENT>var = np.zeros(n)<EOL>msg = ('<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>')<EOL>if show:<EOL><INDENT>print('<STR_LIT:U+0020>')<EOL>print('<STR_LIT>')<EOL>str1 = '<STR_LIT>' % (m, n)<EOL>str2 = '<STR_LIT>' % (damp, calc_var)<EOL>str3 = '<STR_LIT>' % (atol, conlim)<EOL>str4 = '<STR_LIT>' % (btol, iter_lim)<EOL>print(str1)<EOL>print(str2)<EOL>print(str3)<EOL>print(str4)<EOL><DEDENT>itn = <NUM_LIT:0><EOL>istop = <NUM_LIT:0><EOL>nstop = <NUM_LIT:0><EOL>ctol = <NUM_LIT:0><EOL>if conlim > <NUM_LIT:0>:<EOL><INDENT>ctol = <NUM_LIT:1>/conlim<EOL><DEDENT>anorm = <NUM_LIT:0><EOL>acond = <NUM_LIT:0><EOL>dampsq = damp**<NUM_LIT:2><EOL>ddnorm = <NUM_LIT:0><EOL>res2 = <NUM_LIT:0><EOL>xnorm = <NUM_LIT:0><EOL>xxnorm = <NUM_LIT:0><EOL>z = <NUM_LIT:0><EOL>cs2 = -<NUM_LIT:1><EOL>sn2 = <NUM_LIT:0><EOL>\"\"\"<STR_LIT>\"\"\"<EOL>__xm = np.zeros(m)  <EOL>__xn = np.zeros(n)  <EOL>v = np.zeros(n)<EOL>u = b<EOL>x = np.zeros(n)<EOL>alfa = <NUM_LIT:0><EOL>beta = np.linalg.norm(u)<EOL>w = np.zeros(n)<EOL>if beta > <NUM_LIT:0>:<EOL><INDENT>u = (<NUM_LIT:1>/beta) * u<EOL>v = A.rmatvec(u)<EOL>alfa = np.linalg.norm(v)<EOL><DEDENT>if alfa > <NUM_LIT:0>:<EOL><INDENT>v = (<NUM_LIT:1>/alfa) * v<EOL>w = v.copy()<EOL><DEDENT>rhobar = alfa<EOL>phibar = beta<EOL>bnorm = beta<EOL>rnorm = beta<EOL>r1norm = rnorm<EOL>r2norm = rnorm<EOL>arnorm = alfa * beta<EOL>if arnorm == <NUM_LIT:0>:<EOL><INDENT>print(msg[<NUM_LIT:0>])<EOL>return x, istop, itn, r1norm, r2norm, anorm, acond, arnorm, xnorm, var<EOL><DEDENT>head1 = '<STR_LIT>'<EOL>head2 = '<STR_LIT>'<EOL>if show:<EOL><INDENT>print('<STR_LIT:U+0020>')<EOL>print(head1, head2)<EOL>test1 = <NUM_LIT:1><EOL>test2 = alfa / beta<EOL>str1 = '<STR_LIT>' % (itn, x[<NUM_LIT:0>])<EOL>str2 = '<STR_LIT>' % (r1norm, r2norm)<EOL>str3 = '<STR_LIT>' % (test1, test2)<EOL>print(str1, str2, str3)<EOL><DEDENT>while itn < iter_lim:<EOL><INDENT>itn = itn + <NUM_LIT:1><EOL>\"\"\"<STR_LIT>\"\"\"<EOL>u = A.matvec(v) - alfa * u<EOL>beta = np.linalg.norm(u)<EOL>if beta > <NUM_LIT:0>:<EOL><INDENT>u = (<NUM_LIT:1>/beta) * u<EOL>anorm = sqrt(anorm**<NUM_LIT:2> + alfa**<NUM_LIT:2> + beta**<NUM_LIT:2> + damp**<NUM_LIT:2>)<EOL>v = A.rmatvec(u) - beta * v<EOL>alfa = np.linalg.norm(v)<EOL>if alfa > <NUM_LIT:0>:<EOL><INDENT>v = (<NUM_LIT:1> / alfa) * v<EOL><DEDENT><DEDENT>rhobar1 = sqrt(rhobar**<NUM_LIT:2> + damp**<NUM_LIT:2>)<EOL>cs1 = rhobar / rhobar1<EOL>sn1 = damp / rhobar1<EOL>psi = sn1 * phibar<EOL>phibar = cs1 * phibar<EOL>cs, sn, rho = _sym_ortho(rhobar1, beta)<EOL>theta = sn * alfa<EOL>rhobar = -cs * alfa<EOL>phi = cs * phibar<EOL>phibar = sn * phibar<EOL>tau = sn * phi<EOL>t1 = phi / rho<EOL>t2 = -theta / rho<EOL>dk = (<NUM_LIT:1> / rho) * w<EOL>x = x + t1 * w<EOL>w = v + t2 * w<EOL>ddnorm = ddnorm + np.linalg.norm(dk)**<NUM_LIT:2><EOL>if calc_var:<EOL><INDENT>var = var + dk**<NUM_LIT:2><EOL><DEDENT>delta = sn2 * rho<EOL>gambar = -cs2 * rho<EOL>rhs = phi - delta * z<EOL>zbar = rhs / gambar<EOL>xnorm = sqrt(xxnorm + zbar**<NUM_LIT:2>)<EOL>gamma = sqrt(gambar**<NUM_LIT:2> + theta**<NUM_LIT:2>)<EOL>cs2 = gambar / gamma<EOL>sn2 = theta / gamma<EOL>z = rhs / gamma<EOL>xxnorm = xxnorm + z**<NUM_LIT:2><EOL>acond = anorm * sqrt(ddnorm)<EOL>res1 = phibar**<NUM_LIT:2><EOL>res2 = res2 + psi**<NUM_LIT:2><EOL>rnorm = sqrt(res1 + res2)<EOL>arnorm = alfa * abs(tau)<EOL>r1sq = rnorm**<NUM_LIT:2> - dampsq * xxnorm<EOL>r1norm = sqrt(abs(r1sq))<EOL>if r1sq < <NUM_LIT:0>:<EOL><INDENT>r1norm = -r1norm<EOL><DEDENT>r2norm = rnorm<EOL>test1 = rnorm / bnorm<EOL>test2 = arnorm / (anorm * rnorm + eps)<EOL>test3 = <NUM_LIT:1> / (acond + eps)<EOL>t1 = test1 / (<NUM_LIT:1> + anorm * xnorm / bnorm)<EOL>rtol = btol + atol * anorm * xnorm / bnorm<EOL>if itn >= iter_lim:<EOL><INDENT>istop = <NUM_LIT:7><EOL><DEDENT>if <NUM_LIT:1> + test3 <= <NUM_LIT:1>:<EOL><INDENT>istop = <NUM_LIT:6><EOL><DEDENT>if <NUM_LIT:1> + test2 <= <NUM_LIT:1>:<EOL><INDENT>istop = <NUM_LIT:5><EOL><DEDENT>if <NUM_LIT:1> + t1 <= <NUM_LIT:1>:<EOL><INDENT>istop = <NUM_LIT:4><EOL><DEDENT>if test3 <= ctol:<EOL><INDENT>istop = <NUM_LIT:3><EOL><DEDENT>if test2 <= atol:<EOL><INDENT>istop = <NUM_LIT:2><EOL><DEDENT>if test1 <= rtol:<EOL><INDENT>istop = <NUM_LIT:1><EOL><DEDENT>prnt = False<EOL>if n <= <NUM_LIT>:<EOL><INDENT>prnt = True<EOL><DEDENT>if itn <= <NUM_LIT:10>:<EOL><INDENT>prnt = True<EOL><DEDENT>if itn >= iter_lim-<NUM_LIT:10>:<EOL><INDENT>prnt = True<EOL><DEDENT>if test3 <= <NUM_LIT:2>*ctol:<EOL><INDENT>prnt = True<EOL><DEDENT>if test2 <= <NUM_LIT:10>*atol:<EOL><INDENT>prnt = True<EOL><DEDENT>if test1 <= <NUM_LIT:10>*rtol:<EOL><INDENT>prnt = True<EOL><DEDENT>if istop != <NUM_LIT:0>:<EOL><INDENT>prnt = True<EOL><DEDENT>if prnt:<EOL><INDENT>if show:<EOL><INDENT>str1 = '<STR_LIT>' % (itn, x[<NUM_LIT:0>])<EOL>str2 = '<STR_LIT>' % (r1norm, r2norm)<EOL>str3 = '<STR_LIT>' % (test1, test2)<EOL>str4 = '<STR_LIT>' % (anorm, acond)<EOL>print(str1, str2, str3, str4)<EOL><DEDENT><DEDENT>if istop != <NUM_LIT:0>:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if show:<EOL><INDENT>print('<STR_LIT:U+0020>')<EOL>print('<STR_LIT>')<EOL>print(msg[istop])<EOL>print('<STR_LIT:U+0020>')<EOL>str1 = '<STR_LIT>' % (istop, r1norm)<EOL>str2 = '<STR_LIT>' % (anorm, arnorm)<EOL>str3 = '<STR_LIT>' % (itn, r2norm)<EOL>str4 = '<STR_LIT>' % (acond, xnorm)<EOL>print(str1 + '<STR_LIT:U+0020>' + str2)<EOL>print(str3 + '<STR_LIT:U+0020>' + str4)<EOL>print('<STR_LIT:U+0020>')<EOL><DEDENT>return x, istop, itn, r1norm, r2norm, anorm, acond, arnorm, xnorm, var<EOL>", "docstring": "Find the least-squares solution to a large, sparse, linear system\n    of equations.\n\n    The function solves ``Ax = b``  or  ``min ||b - Ax||^2`` or\n    ``min ||Ax - b||^2 + d^2 ||x||^2``.\n\n    The matrix A may be square or rectangular (over-determined or\n    under-determined), and may have any rank.\n\n    ::\n\n      1. Unsymmetric equations --    solve  A*x = b\n\n      2. Linear least squares  --    solve  A*x = b\n                                     in the least-squares sense\n\n      3. Damped least squares  --    solve  (   A    )*x = ( b )\n                                            ( damp*I )     ( 0 )\n                                     in the least-squares sense\n\n    Parameters\n    ----------\n    A : {sparse matrix, ndarray, LinearOperator}\n        Representation of an m-by-n matrix.  It is required that\n        the linear operator can produce ``Ax`` and ``A^T x``.\n    b : (m,) ndarray\n        Right-hand side vector ``b``.\n    damp : float\n        Damping coefficient.\n    atol, btol : float\n        Stopping tolerances. If both are 1.0e-9 (say), the final\n        residual norm should be accurate to about 9 digits.  (The\n        final x will usually have fewer correct digits, depending on\n        cond(A) and the size of damp.)\n    conlim : float\n        Another stopping tolerance.  lsqr terminates if an estimate of\n        ``cond(A)`` exceeds `conlim`.  For compatible systems ``Ax =\n        b``, `conlim` could be as large as 1.0e+12 (say).  For\n        least-squares problems, conlim should be less than 1.0e+8.\n        Maximum precision can be obtained by setting ``atol = btol =\n        conlim = zero``, but the number of iterations may then be\n        excessive.\n    iter_lim : int\n        Explicit limitation on number of iterations (for safety).\n    show : bool\n        Display an iteration log.\n    calc_var : bool\n        Whether to estimate diagonals of ``(A'A + damp^2*I)^{-1}``.\n\n    Returns\n    -------\n    x : ndarray of float\n        The final solution.\n    istop : int\n        Gives the reason for termination.\n        1 means x is an approximate solution to Ax = b.\n        2 means x approximately solves the least-squares problem.\n    itn : int\n        Iteration number upon termination.\n    r1norm : float\n        ``norm(r)``, where ``r = b - Ax``.\n    r2norm : float\n        ``sqrt( norm(r)^2  +  damp^2 * norm(x)^2 )``.  Equal to `r1norm` if\n        ``damp == 0``.\n    anorm : float\n        Estimate of Frobenius norm of ``Abar = [[A]; [damp*I]]``.\n    acond : float\n        Estimate of ``cond(Abar)``.\n    arnorm : float\n        Estimate of ``norm(A'*r - damp^2*x)``.\n    xnorm : float\n        ``norm(x)``\n    var : ndarray of float\n        If ``calc_var`` is True, estimates all diagonals of\n        ``(A'A)^{-1}`` (if ``damp == 0``) or more generally ``(A'A +\n        damp^2*I)^{-1}``.  This is well defined if A has full column\n        rank or ``damp > 0``.  (Not sure what var means if ``rank(A)\n        < n`` and ``damp = 0.``)\n\n    Notes\n    -----\n    LSQR uses an iterative method to approximate the solution.  The\n    number of iterations required to reach a certain accuracy depends\n    strongly on the scaling of the problem.  Poor scaling of the rows\n    or columns of A should therefore be avoided where possible.\n\n    For example, in problem 1 the solution is unaltered by\n    row-scaling.  If a row of A is very small or large compared to\n    the other rows of A, the corresponding row of ( A  b ) should be\n    scaled up or down.\n\n    In problems 1 and 2, the solution x is easily recovered\n    following column-scaling.  Unless better information is known,\n    the nonzero columns of A should be scaled so that they all have\n    the same Euclidean norm (e.g., 1.0).\n\n    In problem 3, there is no freedom to re-scale if damp is\n    nonzero.  However, the value of damp should be assigned only\n    after attention has been paid to the scaling of A.\n\n    The parameter damp is intended to help regularize\n    ill-conditioned systems, by preventing the true solution from\n    being very large.  Another aid to regularization is provided by\n    the parameter acond, which may be used to terminate iterations\n    before the computed solution becomes very large.\n\n    If some initial estimate ``x0`` is known and if ``damp == 0``,\n    one could proceed as follows:\n\n      1. Compute a residual vector ``r0 = b - A*x0``.\n      2. Use LSQR to solve the system  ``A*dx = r0``.\n      3. Add the correction dx to obtain a final solution ``x = x0 + dx``.\n\n    This requires that ``x0`` be available before and after the call\n    to LSQR.  To judge the benefits, suppose LSQR takes k1 iterations\n    to solve A*x = b and k2 iterations to solve A*dx = r0.\n    If x0 is \"good\", norm(r0) will be smaller than norm(b).\n    If the same stopping tolerances atol and btol are used for each\n    system, k1 and k2 will be similar, but the final solution x0 + dx\n    should be more accurate.  The only way to reduce the total work\n    is to use a larger stopping tolerance for the second system.\n    If some value btol is suitable for A*x = b, the larger value\n    btol*norm(b)/norm(r0)  should be suitable for A*dx = r0.\n\n    Preconditioning is another way to reduce the number of iterations.\n    If it is possible to solve a related system ``M*x = b``\n    efficiently, where M approximates A in some helpful way (e.g. M -\n    A has low rank or its elements are small relative to those of A),\n    LSQR may converge more rapidly on the system ``A*M(inverse)*z =\n    b``, after which x can be recovered by solving M*x = z.\n\n    If A is symmetric, LSQR should not be used!\n\n    Alternatives are the symmetric conjugate-gradient method (cg)\n    and/or SYMMLQ.  SYMMLQ is an implementation of symmetric cg that\n    applies to any symmetric A and will converge more rapidly than\n    LSQR.  If A is positive definite, there are other implementations\n    of symmetric cg that require slightly less work per iteration than\n    SYMMLQ (but will take the same number of iterations).\n\n    References\n    ----------\n    .. [1] C. C. Paige and M. A. Saunders (1982a).\n           \"LSQR: An algorithm for sparse linear equations and\n           sparse least squares\", ACM TOMS 8(1), 43-71.\n    .. [2] C. C. Paige and M. A. Saunders (1982b).\n           \"Algorithm 583.  LSQR: Sparse linear equations and least\n           squares problems\", ACM TOMS 8(2), 195-209.\n    .. [3] M. A. Saunders (1995).  \"Solution of sparse rectangular\n           systems using LSQR and CRAIG\", BIT 35, 588-604.", "id": "f19546:m1"}
{"signature": "def lgmres(A, b, x0=None, tol=<NUM_LIT>, maxiter=<NUM_LIT:1000>, M=None, callback=None,<EOL>inner_m=<NUM_LIT:30>, outer_k=<NUM_LIT:3>, outer_v=None, store_outer_Av=True):", "body": "from scipy.linalg.basic import lstsq<EOL>A,M,x,b,postprocess = make_system(A,M,x0,b)<EOL>if not np.isfinite(b).all():<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>matvec = A.matvec<EOL>psolve = M.matvec<EOL>if outer_v is None:<EOL><INDENT>outer_v = []<EOL><DEDENT>axpy, dot, scal = None, None, None<EOL>b_norm = norm2(b)<EOL>if b_norm == <NUM_LIT:0>:<EOL><INDENT>b_norm = <NUM_LIT:1><EOL><DEDENT>for k_outer in xrange(maxiter):<EOL><INDENT>r_outer = matvec(x) - b<EOL>if callback is not None:<EOL><INDENT>callback(x)<EOL><DEDENT>if axpy is None:<EOL><INDENT>if np.iscomplexobj(r_outer) and not np.iscomplexobj(x):<EOL><INDENT>x = x.astype(r_outer.dtype)<EOL><DEDENT>axpy, dot, scal = get_blas_funcs(['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'],<EOL>(x, r_outer))<EOL><DEDENT>r_norm = norm2(r_outer)<EOL>if r_norm < tol * b_norm or r_norm < tol:<EOL><INDENT>break<EOL><DEDENT>vs0 = -psolve(r_outer)<EOL>inner_res_0 = norm2(vs0)<EOL>if inner_res_0 == <NUM_LIT:0>:<EOL><INDENT>rnorm = norm2(r_outer)<EOL>raise RuntimeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % rnorm)<EOL><DEDENT>vs0 = scal(<NUM_LIT:1.0>/inner_res_0, vs0)<EOL>hs = []<EOL>vs = [vs0]<EOL>ws = []<EOL>y = None<EOL>for j in xrange(<NUM_LIT:1>, <NUM_LIT:1> + inner_m + len(outer_v)):<EOL><INDENT>v_new = None<EOL>if j < len(outer_v) + <NUM_LIT:1>:<EOL><INDENT>z, v_new = outer_v[j-<NUM_LIT:1>]<EOL><DEDENT>elif j == len(outer_v) + <NUM_LIT:1>:<EOL><INDENT>z = vs0<EOL><DEDENT>else:<EOL><INDENT>z = vs[-<NUM_LIT:1>]<EOL><DEDENT>if v_new is None:<EOL><INDENT>v_new = psolve(matvec(z))<EOL><DEDENT>else:<EOL><INDENT>v_new = v_new.copy()<EOL><DEDENT>hcur = []<EOL>for v in vs:<EOL><INDENT>alpha = dot(v, v_new)<EOL>hcur.append(alpha)<EOL>v_new = axpy(v, v_new, v.shape[<NUM_LIT:0>], -alpha)  <EOL><DEDENT>hcur.append(norm2(v_new))<EOL>if hcur[-<NUM_LIT:1>] == <NUM_LIT:0>:<EOL><INDENT>bailout = True<EOL><DEDENT>else:<EOL><INDENT>bailout = False<EOL>v_new = scal(<NUM_LIT:1.0>/hcur[-<NUM_LIT:1>], v_new)<EOL><DEDENT>vs.append(v_new)<EOL>hs.append(hcur)<EOL>ws.append(z)<EOL>if not bailout and j % <NUM_LIT:5> != <NUM_LIT:1> and j < inner_m + len(outer_v) - <NUM_LIT:1>:<EOL><INDENT>continue<EOL><DEDENT>hess = np.zeros((j+<NUM_LIT:1>, j), x.dtype)<EOL>e1 = np.zeros((j+<NUM_LIT:1>,), x.dtype)<EOL>e1[<NUM_LIT:0>] = inner_res_0<EOL>for q in xrange(j):<EOL><INDENT>hess[:(q+<NUM_LIT:2>),q] = hs[q]<EOL><DEDENT>y, resids, rank, s = lstsq(hess, e1)<EOL>inner_res = norm2(np.dot(hess, y) - e1)<EOL>if inner_res < tol * inner_res_0:<EOL><INDENT>break<EOL><DEDENT><DEDENT>dx = ws[<NUM_LIT:0>]*y[<NUM_LIT:0>]<EOL>for w, yc in zip(ws[<NUM_LIT:1>:], y[<NUM_LIT:1>:]):<EOL><INDENT>dx = axpy(w, dx, dx.shape[<NUM_LIT:0>], yc)  <EOL><DEDENT>nx = norm2(dx)<EOL>if store_outer_Av:<EOL><INDENT>q = np.dot(hess, y)<EOL>ax = vs[<NUM_LIT:0>]*q[<NUM_LIT:0>]<EOL>for v, qc in zip(vs[<NUM_LIT:1>:], q[<NUM_LIT:1>:]):<EOL><INDENT>ax = axpy(v, ax, ax.shape[<NUM_LIT:0>], qc)<EOL><DEDENT>outer_v.append((dx/nx, ax/nx))<EOL><DEDENT>else:<EOL><INDENT>outer_v.append((dx/nx, None))<EOL><DEDENT>while len(outer_v) > outer_k:<EOL><INDENT>del outer_v[<NUM_LIT:0>]<EOL><DEDENT>x += dx<EOL><DEDENT>else:<EOL><INDENT>return postprocess(x), maxiter<EOL><DEDENT>return postprocess(x), <NUM_LIT:0><EOL>", "docstring": "Solve a matrix equation using the LGMRES algorithm.\n\nThe LGMRES algorithm [BJM]_ [BPh]_ is designed to avoid some problems\nin the convergence in restarted GMRES, and often converges in fewer\niterations.\n\nParameters\n----------\nA : {sparse matrix, dense matrix, LinearOperator}\n    The real or complex N-by-N matrix of the linear system.\nb : {array, matrix}\n    Right hand side of the linear system. Has shape (N,) or (N,1).\nx0  : {array, matrix}\n    Starting guess for the solution.\ntol : float\n    Tolerance to achieve. The algorithm terminates when either the relative\n    or the absolute residual is below `tol`.\nmaxiter : int\n    Maximum number of iterations.  Iteration will stop after maxiter\n    steps even if the specified tolerance has not been achieved.\nM : {sparse matrix, dense matrix, LinearOperator}\n    Preconditioner for A.  The preconditioner should approximate the\n    inverse of A.  Effective preconditioning dramatically improves the\n    rate of convergence, which implies that fewer iterations are needed\n    to reach a given error tolerance.\ncallback : function\n    User-supplied function to call after each iteration.  It is called\n    as callback(xk), where xk is the current solution vector.\ninner_m : int, optional\n    Number of inner GMRES iterations per each outer iteration.\nouter_k : int, optional\n    Number of vectors to carry between inner GMRES iterations.\n    According to [BJM]_, good values are in the range of 1...3.\n    However, note that if you want to use the additional vectors to\n    accelerate solving multiple similar problems, larger values may\n    be beneficial.\nouter_v : list of tuples, optional\n    List containing tuples ``(v, Av)`` of vectors and corresponding\n    matrix-vector products, used to augment the Krylov subspace, and\n    carried between inner GMRES iterations. The element ``Av`` can\n    be `None` if the matrix-vector product should be re-evaluated.\n    This parameter is modified in-place by `lgmres`, and can be used\n    to pass \"guess\" vectors in and out of the algorithm when solving\n    similar problems.\nstore_outer_Av : bool, optional\n    Whether LGMRES should store also A*v in addition to vectors `v`\n    in the `outer_v` list. Default is True.\n\nReturns\n-------\nx : array or matrix\n    The converged solution.\ninfo : int\n    Provides convergence information:\n\n        - 0  : successful exit\n        - >0 : convergence to tolerance not achieved, number of iterations\n        - <0 : illegal input or breakdown\n\nNotes\n-----\nThe LGMRES algorithm [BJM]_ [BPh]_ is designed to avoid the\nslowing of convergence in restarted GMRES, due to alternating\nresidual vectors. Typically, it often outperforms GMRES(m) of\ncomparable memory requirements by some measure, or at least is not\nmuch worse.\n\nAnother advantage in this algorithm is that you can supply it with\n'guess' vectors in the `outer_v` argument that augment the Krylov\nsubspace. If the solution lies close to the span of these vectors,\nthe algorithm converges faster. This can be useful if several very\nsimilar matrices need to be inverted one after another, such as in\nNewton-Krylov iteration where the Jacobian matrix often changes\nlittle in the nonlinear steps.\n\nReferences\n----------\n.. [BJM] A.H. Baker and E.R. Jessup and T. Manteuffel,\n         SIAM J. Matrix Anal. Appl. 26, 962 (2005).\n.. [BPh] A.H. Baker, PhD thesis, University of Colorado (2003).\n         http://amath.colorado.edu/activities/thesis/allisonb/Thesis.ps", "id": "f19554:m1"}
{"signature": "def lsmr(A, b, damp=<NUM_LIT:0.0>, atol=<NUM_LIT>, btol=<NUM_LIT>, conlim=<NUM_LIT>,<EOL>maxiter=None, show=False):", "body": "A = aslinearoperator(A)<EOL>b = b.squeeze()<EOL>msg = ('<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>')<EOL>hdg1 = '<STR_LIT>''<STR_LIT:r>'<EOL>hdg2 = '<STR_LIT>'<EOL>pfreq = <NUM_LIT:20>   <EOL>pcount = <NUM_LIT:0>   <EOL>m, n = A.shape<EOL>minDim = min([m, n])<EOL>if maxiter is None:<EOL><INDENT>maxiter = minDim<EOL><DEDENT>if show:<EOL><INDENT>print('<STR_LIT:U+0020>')<EOL>print('<STR_LIT>')<EOL>print('<STR_LIT>' % (m, n))<EOL>print('<STR_LIT>' % (damp))<EOL>print('<STR_LIT>' % (atol, conlim))<EOL>print('<STR_LIT>' % (btol, maxiter))<EOL><DEDENT>u = b<EOL>beta = norm(u)<EOL>v = zeros(n)<EOL>alpha = <NUM_LIT:0><EOL>if beta > <NUM_LIT:0>:<EOL><INDENT>u = (<NUM_LIT:1> / beta) * u<EOL>v = A.rmatvec(u)<EOL>alpha = norm(v)<EOL><DEDENT>if alpha > <NUM_LIT:0>:<EOL><INDENT>v = (<NUM_LIT:1> / alpha) * v<EOL><DEDENT>itn = <NUM_LIT:0><EOL>zetabar = alpha * beta<EOL>alphabar = alpha<EOL>rho = <NUM_LIT:1><EOL>rhobar = <NUM_LIT:1><EOL>cbar = <NUM_LIT:1><EOL>sbar = <NUM_LIT:0><EOL>h = v.copy()<EOL>hbar = zeros(n)<EOL>x = zeros(n)<EOL>betadd = beta<EOL>betad = <NUM_LIT:0><EOL>rhodold = <NUM_LIT:1><EOL>tautildeold = <NUM_LIT:0><EOL>thetatilde = <NUM_LIT:0><EOL>zeta = <NUM_LIT:0><EOL>d = <NUM_LIT:0><EOL>normA2 = alpha * alpha<EOL>maxrbar = <NUM_LIT:0><EOL>minrbar = <NUM_LIT><EOL>normA = sqrt(normA2)<EOL>condA = <NUM_LIT:1><EOL>normx = <NUM_LIT:0><EOL>normb = beta<EOL>istop = <NUM_LIT:0><EOL>ctol = <NUM_LIT:0><EOL>if conlim > <NUM_LIT:0>:<EOL><INDENT>ctol = <NUM_LIT:1> / conlim<EOL><DEDENT>normr = beta<EOL>normar = alpha * beta<EOL>if normar == <NUM_LIT:0>:<EOL><INDENT>if show:<EOL><INDENT>print(msg[<NUM_LIT:0>])<EOL><DEDENT>return x, istop, itn, normr, normar, normA, condA, normx<EOL><DEDENT>if show:<EOL><INDENT>print('<STR_LIT:U+0020>')<EOL>print(hdg1, hdg2)<EOL>test1 = <NUM_LIT:1><EOL>test2 = alpha / beta<EOL>str1 = '<STR_LIT>' % (itn, x[<NUM_LIT:0>])<EOL>str2 = '<STR_LIT>' % (normr, normar)<EOL>str3 = '<STR_LIT>' % (test1, test2)<EOL>print('<STR_LIT>'.join([str1, str2, str3]))<EOL><DEDENT>while itn < maxiter:<EOL><INDENT>itn = itn + <NUM_LIT:1><EOL>u = A.matvec(v) - alpha * u<EOL>beta = norm(u)<EOL>if beta > <NUM_LIT:0>:<EOL><INDENT>u = (<NUM_LIT:1> / beta) * u<EOL>v = A.rmatvec(u) - beta * v<EOL>alpha = norm(v)<EOL>if alpha > <NUM_LIT:0>:<EOL><INDENT>v = (<NUM_LIT:1> / alpha) * v<EOL><DEDENT><DEDENT>chat, shat, alphahat = _sym_ortho(alphabar, damp)<EOL>rhoold = rho<EOL>c, s, rho = _sym_ortho(alphahat, beta)<EOL>thetanew = s*alpha<EOL>alphabar = c*alpha<EOL>rhobarold = rhobar<EOL>zetaold = zeta<EOL>thetabar = sbar * rho<EOL>rhotemp = cbar * rho<EOL>cbar, sbar, rhobar = _sym_ortho(cbar * rho, thetanew)<EOL>zeta = cbar * zetabar<EOL>zetabar = - sbar * zetabar<EOL>hbar = h - (thetabar * rho / (rhoold * rhobarold)) * hbar<EOL>x = x + (zeta / (rho * rhobar)) * hbar<EOL>h = v - (thetanew / rho) * h<EOL>betaacute = chat * betadd<EOL>betacheck = -shat * betadd<EOL>betahat = c * betaacute<EOL>betadd = -s * betaacute<EOL>thetatildeold = thetatilde<EOL>ctildeold, stildeold, rhotildeold = _sym_ortho(rhodold, thetabar)<EOL>thetatilde = stildeold * rhobar<EOL>rhodold = ctildeold * rhobar<EOL>betad = - stildeold * betad + ctildeold * betahat<EOL>tautildeold = (zetaold - thetatildeold * tautildeold) / rhotildeold<EOL>taud = (zeta - thetatilde * tautildeold) / rhodold<EOL>d = d + betacheck * betacheck<EOL>normr = sqrt(d + (betad - taud)**<NUM_LIT:2> + betadd * betadd)<EOL>normA2 = normA2 + beta * beta<EOL>normA = sqrt(normA2)<EOL>normA2 = normA2 + alpha * alpha<EOL>maxrbar = max(maxrbar, rhobarold)<EOL>if itn > <NUM_LIT:1>:<EOL><INDENT>minrbar = min(minrbar, rhobarold)<EOL><DEDENT>condA = max(maxrbar, rhotemp) / min(minrbar, rhotemp)<EOL>normar = abs(zetabar)<EOL>normx = norm(x)<EOL>test1 = normr / normb<EOL>if (normA * normr) != <NUM_LIT:0>:<EOL><INDENT>test2 = normar / (normA * normr)<EOL><DEDENT>else:<EOL><INDENT>test2 = infty<EOL><DEDENT>test3 = <NUM_LIT:1> / condA<EOL>t1 = test1 / (<NUM_LIT:1> + normA * normx / normb)<EOL>rtol = btol + atol * normA * normx / normb<EOL>if itn >= maxiter:<EOL><INDENT>istop = <NUM_LIT:7><EOL><DEDENT>if <NUM_LIT:1> + test3 <= <NUM_LIT:1>:<EOL><INDENT>istop = <NUM_LIT:6><EOL><DEDENT>if <NUM_LIT:1> + test2 <= <NUM_LIT:1>:<EOL><INDENT>istop = <NUM_LIT:5><EOL><DEDENT>if <NUM_LIT:1> + t1 <= <NUM_LIT:1>:<EOL><INDENT>istop = <NUM_LIT:4><EOL><DEDENT>if test3 <= ctol:<EOL><INDENT>istop = <NUM_LIT:3><EOL><DEDENT>if test2 <= atol:<EOL><INDENT>istop = <NUM_LIT:2><EOL><DEDENT>if test1 <= rtol:<EOL><INDENT>istop = <NUM_LIT:1><EOL><DEDENT>if show:<EOL><INDENT>if (n <= <NUM_LIT>) or (itn <= <NUM_LIT:10>) or (itn >= maxiter - <NUM_LIT:10>) or(itn % <NUM_LIT:10> == <NUM_LIT:0>) or (test3 <= <NUM_LIT> * ctol) or(test2 <= <NUM_LIT> * atol) or (test1 <= <NUM_LIT> * rtol) or(istop != <NUM_LIT:0>):<EOL><INDENT>if pcount >= pfreq:<EOL><INDENT>pcount = <NUM_LIT:0><EOL>print('<STR_LIT:U+0020>')<EOL>print(hdg1, hdg2)<EOL><DEDENT>pcount = pcount + <NUM_LIT:1><EOL>str1 = '<STR_LIT>' % (itn, x[<NUM_LIT:0>])<EOL>str2 = '<STR_LIT>' % (normr, normar)<EOL>str3 = '<STR_LIT>' % (test1, test2)<EOL>str4 = '<STR_LIT>' % (normA, condA)<EOL>print('<STR_LIT>'.join([str1, str2, str3, str4]))<EOL><DEDENT><DEDENT>if istop > <NUM_LIT:0>:<EOL><INDENT>break<EOL><DEDENT><DEDENT>if show:<EOL><INDENT>print('<STR_LIT:U+0020>')<EOL>print('<STR_LIT>')<EOL>print(msg[istop])<EOL>print('<STR_LIT>' % (istop, normr))<EOL>print('<STR_LIT>' % (normA, normar))<EOL>print('<STR_LIT>' % (itn, condA))<EOL>print('<STR_LIT>' % (normx))<EOL>print(str1, str2)<EOL>print(str3, str4)<EOL><DEDENT>return x, istop, itn, normr, normar, normA, condA, normx<EOL>", "docstring": "Iterative solver for least-squares problems.\n\n    lsmr solves the system of linear equations ``Ax = b``. If the system\n    is inconsistent, it solves the least-squares problem ``min ||b - Ax||_2``.\n    A is a rectangular matrix of dimension m-by-n, where all cases are\n    allowed: m = n, m > n, or m < n. B is a vector of length m.\n    The matrix A may be dense or sparse (usually sparse).\n\n    Parameters\n    ----------\n    A : {matrix, sparse matrix, ndarray, LinearOperator}\n        Matrix A in the linear system.\n    b : (m,) ndarray\n        Vector b in the linear system.\n    damp : float\n        Damping factor for regularized least-squares. `lsmr` solves\n        the regularized least-squares problem::\n\n         min ||(b) - (  A   )x||\n             ||(0)   (damp*I) ||_2\n\n        where damp is a scalar.  If damp is None or 0, the system\n        is solved without regularization.\n    atol, btol : float\n        Stopping tolerances. `lsmr` continues iterations until a\n        certain backward error estimate is smaller than some quantity\n        depending on atol and btol.  Let ``r = b - Ax`` be the\n        residual vector for the current approximate solution ``x``.\n        If ``Ax = b`` seems to be consistent, ``lsmr`` terminates\n        when ``norm(r) <= atol * norm(A) * norm(x) + btol * norm(b)``.\n        Otherwise, lsmr terminates when ``norm(A^{T} r) <=\n        atol * norm(A) * norm(r)``.  If both tolerances are 1.0e-6 (say),\n        the final ``norm(r)`` should be accurate to about 6\n        digits. (The final x will usually have fewer correct digits,\n        depending on ``cond(A)`` and the size of LAMBDA.)  If `atol`\n        or `btol` is None, a default value of 1.0e-6 will be used.\n        Ideally, they should be estimates of the relative error in the\n        entries of A and B respectively.  For example, if the entries\n        of `A` have 7 correct digits, set atol = 1e-7. This prevents\n        the algorithm from doing unnecessary work beyond the\n        uncertainty of the input data.\n    conlim : float\n        `lsmr` terminates if an estimate of ``cond(A)`` exceeds\n        `conlim`.  For compatible systems ``Ax = b``, conlim could be\n        as large as 1.0e+12 (say).  For least-squares problems,\n        `conlim` should be less than 1.0e+8. If `conlim` is None, the\n        default value is 1e+8.  Maximum precision can be obtained by\n        setting ``atol = btol = conlim = 0``, but the number of\n        iterations may then be excessive.\n    maxiter : int\n        `lsmr` terminates if the number of iterations reaches\n        `maxiter`.  The default is ``maxiter = min(m, n)``.  For\n        ill-conditioned systems, a larger value of `maxiter` may be\n        needed.\n    show : bool\n        Print iterations logs if ``show=True``.\n\n    Returns\n    -------\n    x : ndarray of float\n        Least-square solution returned.\n    istop : int\n        istop gives the reason for stopping::\n\n          istop   = 0 means x=0 is a solution.\n                  = 1 means x is an approximate solution to A*x = B,\n                      according to atol and btol.\n                  = 2 means x approximately solves the least-squares problem\n                      according to atol.\n                  = 3 means COND(A) seems to be greater than CONLIM.\n                  = 4 is the same as 1 with atol = btol = eps (machine\n                      precision)\n                  = 5 is the same as 2 with atol = eps.\n                  = 6 is the same as 3 with CONLIM = 1/eps.\n                  = 7 means ITN reached maxiter before the other stopping\n                      conditions were satisfied.\n\n    itn : int\n        Number of iterations used.\n    normr : float\n        ``norm(b-Ax)``\n    normar : float\n        ``norm(A^T (b - Ax))``\n    norma : float\n        ``norm(A)``\n    conda : float\n        Condition number of A.\n    normx : float\n        ``norm(x)``\n\n    Notes\n    -----\n\n    .. versionadded:: 0.11.0\n\n    References\n    ----------\n    .. [1] D. C.-L. Fong and M. A. Saunders,\n           \"LSMR: An iterative algorithm for sparse least-squares problems\",\n           SIAM J. Sci. Comput., vol. 33, pp. 2950-2971, 2011.\n           http://arxiv.org/abs/1006.0758\n    .. [2] LSMR Software, http://www.stanford.edu/~clfong/lsmr.html", "id": "f19555:m0"}
{"signature": "def make_system(A, M, x0, b, xtype=None):", "body": "A_ = A<EOL>A = aslinearoperator(A)<EOL>if A.shape[<NUM_LIT:0>] != A.shape[<NUM_LIT:1>]:<EOL><INDENT>raise ValueError('<STR_LIT>' % (A.shape,))<EOL><DEDENT>N = A.shape[<NUM_LIT:0>]<EOL>b = asanyarray(b)<EOL>if not (b.shape == (N,<NUM_LIT:1>) or b.shape == (N,)):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if b.dtype.char not in '<STR_LIT>':<EOL><INDENT>b = b.astype('<STR_LIT:d>')  <EOL><DEDENT>def postprocess(x):<EOL><INDENT>if isinstance(b,matrix):<EOL><INDENT>x = asmatrix(x)<EOL><DEDENT>return x.reshape(b.shape)<EOL><DEDENT>if xtype is None:<EOL><INDENT>if hasattr(A,'<STR_LIT>'):<EOL><INDENT>xtype = A.dtype.char<EOL><DEDENT>else:<EOL><INDENT>xtype = A.matvec(b).dtype.char<EOL><DEDENT>xtype = coerce(xtype, b.dtype.char)<EOL><DEDENT>else:<EOL><INDENT>warn('<STR_LIT>'<EOL>'<STR_LIT>',<EOL>DeprecationWarning)<EOL>if xtype == <NUM_LIT:0>:<EOL><INDENT>xtype = b.dtype.char<EOL><DEDENT>else:<EOL><INDENT>if xtype not in '<STR_LIT>':<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>b = asarray(b,dtype=xtype)  <EOL>b = b.ravel()<EOL>if x0 is None:<EOL><INDENT>x = zeros(N, dtype=xtype)<EOL><DEDENT>else:<EOL><INDENT>x = array(x0, dtype=xtype)<EOL>if not (x.shape == (N,<NUM_LIT:1>) or x.shape == (N,)):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>x = x.ravel()<EOL><DEDENT>if M is None:<EOL><INDENT>if hasattr(A_,'<STR_LIT>'):<EOL><INDENT>psolve = A_.psolve<EOL><DEDENT>else:<EOL><INDENT>psolve = id<EOL><DEDENT>if hasattr(A_,'<STR_LIT>'):<EOL><INDENT>rpsolve = A_.rpsolve<EOL><DEDENT>else:<EOL><INDENT>rpsolve = id<EOL><DEDENT>if psolve is id and rpsolve is id:<EOL><INDENT>M = IdentityOperator(shape=A.shape, dtype=A.dtype)<EOL><DEDENT>else:<EOL><INDENT>M = LinearOperator(A.shape, matvec=psolve, rmatvec=rpsolve,<EOL>dtype=A.dtype)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>M = aslinearoperator(M)<EOL>if A.shape != M.shape:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT><DEDENT>return A, M, x, b, postprocess<EOL>", "docstring": "Make a linear system Ax=b\n\n    Parameters\n    ----------\n    A : LinearOperator\n        sparse or dense matrix (or any valid input to aslinearoperator)\n    M : {LinearOperator, Nones}\n        preconditioner\n        sparse or dense matrix (or any valid input to aslinearoperator)\n    x0 : {array_like, None}\n        initial guess to iterative method\n    b : array_like\n        right hand side\n    xtype : {'f', 'd', 'F', 'D', None}\n        dtype of the x vector\n\n    Returns\n    -------\n    (A, M, x, b, postprocess)\n        A : LinearOperator\n            matrix of the linear system\n        M : LinearOperator\n            preconditioner\n        x : rank 1 ndarray\n            initial guess\n        b : rank 1 ndarray\n            right hand side\n        postprocess : function\n            converts the solution vector to the appropriate\n            type and dimensions (e.g. (N,1) matrix)", "id": "f19558:m2"}
{"signature": "def assert_allclose_cc(actual, desired, **kw):", "body": "try:<EOL><INDENT>assert_allclose(actual, desired, **kw)<EOL><DEDENT>except:<EOL><INDENT>assert_allclose(actual, conj(desired), **kw)<EOL><DEDENT>", "docstring": "Almost equal or complex conjugates almost equal", "id": "f19561:m5"}
{"signature": "def svds(A, k=<NUM_LIT:6>, ncv=None, tol=<NUM_LIT:0>, which='<STR_LIT>', v0=None,<EOL>maxiter=None, return_singular_vectors=True):", "body": "if not (isinstance(A, LinearOperator) or isspmatrix(A)):<EOL><INDENT>A = np.asarray(A)<EOL><DEDENT>n, m = A.shape<EOL>if isinstance(A, LinearOperator):<EOL><INDENT>if n > m:<EOL><INDENT>X_dot = A.matvec<EOL>X_matmat = A.matmat<EOL>XH_dot = A.rmatvec<EOL><DEDENT>else:<EOL><INDENT>X_dot = A.rmatvec<EOL>XH_dot = A.matvec<EOL>dtype = getattr(A, '<STR_LIT>', None)<EOL>if dtype is None:<EOL><INDENT>dtype = A.dot(np.zeros([m,<NUM_LIT:1>])).dtype<EOL><DEDENT>def X_matmat(V):<EOL><INDENT>out = np.empty((V.shape[<NUM_LIT:1>], m), dtype=dtype)<EOL>for i, col in enumerate(V.T):<EOL><INDENT>out[i, :] = A.rmatvec(col.reshape(-<NUM_LIT:1>, <NUM_LIT:1>)).T<EOL><DEDENT>return out.T<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if n > m:<EOL><INDENT>X_dot = X_matmat = A.dot<EOL>XH_dot = _herm(A).dot<EOL><DEDENT>else:<EOL><INDENT>XH_dot = A.dot<EOL>X_dot = X_matmat = _herm(A).dot<EOL><DEDENT><DEDENT>def matvec_XH_X(x):<EOL><INDENT>return XH_dot(X_dot(x))<EOL><DEDENT>XH_X = LinearOperator(matvec=matvec_XH_X, dtype=A.dtype,<EOL>shape=(min(A.shape), min(A.shape)))<EOL>eigvals, eigvec = eigsh(XH_X, k=k, tol=tol ** <NUM_LIT:2>, maxiter=maxiter,<EOL>ncv=ncv, which=which, v0=v0)<EOL>if which == '<STR_LIT>':<EOL><INDENT>eigvals = np.maximum(eigvals.real, <NUM_LIT:0>)<EOL>t = eigvec.dtype.char.lower()<EOL>factor = {'<STR_LIT:f>': <NUM_LIT>, '<STR_LIT:d>': <NUM_LIT>}<EOL>cond = factor[t] * np.finfo(t).eps<EOL>cutoff = cond * np.max(eigvals)<EOL>above_cutoff = (eigvals > cutoff)<EOL>nlarge = above_cutoff.sum()<EOL>nsmall = k - nlarge<EOL>slarge = np.sqrt(eigvals[above_cutoff])<EOL>s = np.zeros_like(eigvals)<EOL>s[:nlarge] = slarge<EOL>if not return_singular_vectors:<EOL><INDENT>return s<EOL><DEDENT>if n > m:<EOL><INDENT>vlarge = eigvec[:, above_cutoff]<EOL>ularge = X_matmat(vlarge) / slarge<EOL>vhlarge = _herm(vlarge)<EOL><DEDENT>else:<EOL><INDENT>ularge = eigvec[:, above_cutoff]<EOL>vhlarge = _herm(X_matmat(ularge) / slarge)<EOL><DEDENT>u = _augmented_orthonormal_cols(ularge, nsmall)<EOL>vh = _augmented_orthonormal_rows(vhlarge, nsmall)<EOL><DEDENT>else:<EOL><INDENT>s = np.sqrt(eigvals)<EOL>if not return_singular_vectors:<EOL><INDENT>return s<EOL><DEDENT>if n > m:<EOL><INDENT>v = eigvec<EOL>u = X_matmat(v) / s<EOL>vh = _herm(v)<EOL><DEDENT>else:<EOL><INDENT>u = eigvec<EOL>vh = _herm(X_matmat(u) / s)<EOL><DEDENT><DEDENT>return u, s, vh<EOL>", "docstring": "Compute the largest k singular values/vectors for a sparse matrix.\n\n    Parameters\n    ----------\n    A : {sparse matrix, LinearOperator}\n        Array to compute the SVD on, of shape (M, N)\n    k : int, optional\n        Number of singular values and vectors to compute.\n    ncv : int, optional\n        The number of Lanczos vectors generated\n        ncv must be greater than k+1 and smaller than n;\n        it is recommended that ncv > 2*k\n        Default: ``min(n, 2*k + 1)``\n    tol : float, optional\n        Tolerance for singular values. Zero (default) means machine precision.\n    which : str, ['LM' | 'SM'], optional\n        Which `k` singular values to find:\n\n            - 'LM' : largest singular values\n            - 'SM' : smallest singular values\n\n        .. versionadded:: 0.12.0\n    v0 : ndarray, optional\n        Starting vector for iteration, of length min(A.shape). Should be an\n        (approximate) right singular vector if N > M and a right singular vector\n        otherwise.\n        Default: random\n\n        .. versionadded:: 0.12.0\n    maxiter: int, optional\n        Maximum number of iterations.\n\n        .. versionadded:: 0.12.0\n    return_singular_vectors : bool, optional\n        Return singular vectors (True) in addition to singular values\n\n        .. versionadded:: 0.12.0\n\n    Returns\n    -------\n    u : ndarray, shape=(M, k)\n        Unitary matrix having left singular vectors as columns.\n    s : ndarray, shape=(k,)\n        The singular values.\n    vt : ndarray, shape=(k, N)\n        Unitary matrix having right singular vectors as rows.\n\n    Notes\n    -----\n    This is a naive implementation using ARPACK as an eigensolver\n    on A.H * A or A * A.H, depending on which one is more efficient.", "id": "f19562:m8"}
{"signature": "def as2d(ar):", "body": "if ar.ndim == <NUM_LIT:2>:<EOL><INDENT>return ar<EOL><DEDENT>else:  <EOL><INDENT>aux = np.array(ar, copy=False)<EOL>aux.shape = (ar.shape[<NUM_LIT:0>], <NUM_LIT:1>)<EOL>return aux<EOL><DEDENT>", "docstring": "If the input array is 2D return it, if it is 1D, append a dimension,\nmaking it a column vector.", "id": "f19571:m4"}
{"signature": "def aslinearoperator(A):", "body": "if isinstance(A, LinearOperator):<EOL><INDENT>return A<EOL><DEDENT>elif isinstance(A, np.ndarray) or isinstance(A, np.matrix):<EOL><INDENT>if A.ndim > <NUM_LIT:2>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>A = np.atleast_2d(np.asarray(A))<EOL>return MatrixLinearOperator(A)<EOL><DEDENT>elif isspmatrix(A):<EOL><INDENT>return MatrixLinearOperator(A)<EOL><DEDENT>else:<EOL><INDENT>if hasattr(A, '<STR_LIT>') and hasattr(A, '<STR_LIT>'):<EOL><INDENT>rmatvec = None<EOL>dtype = None<EOL>if hasattr(A, '<STR_LIT>'):<EOL><INDENT>rmatvec = A.rmatvec<EOL><DEDENT>if hasattr(A, '<STR_LIT>'):<EOL><INDENT>dtype = A.dtype<EOL><DEDENT>return LinearOperator(A.shape, A.matvec,<EOL>rmatvec=rmatvec, dtype=dtype)<EOL><DEDENT>else:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT><DEDENT>", "docstring": "Return A as a LinearOperator.\n\n    'A' may be any of the following types:\n     - ndarray\n     - matrix\n     - sparse matrix (e.g. csr_matrix, lil_matrix, etc.)\n     - LinearOperator\n     - An object with .shape and .matvec attributes\n\n    See the LinearOperator documentation for additional information.\n\n    Examples\n    --------\n    >>> from scipy import matrix\n    >>> M = matrix( [[1,2,3],[4,5,6]], dtype='int32' )\n    >>> aslinearoperator( M )\n    <2x3 LinearOperator with dtype=int32>", "id": "f19573:m1"}
{"signature": "def spilu(A, drop_tol=None, fill_factor=None, drop_rule=None, permc_spec=None,<EOL>diag_pivot_thresh=None, relax=None, panel_size=None, options=None):", "body": "if not isspmatrix_csc(A):<EOL><INDENT>A = csc_matrix(A)<EOL>warn('<STR_LIT>', SparseEfficiencyWarning)<EOL><DEDENT>A.sort_indices()<EOL>A = A.asfptype()  <EOL>M, N = A.shape<EOL>if (M != N):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")  <EOL><DEDENT>_options = dict(ILU_DropRule=drop_rule, ILU_DropTol=drop_tol,<EOL>ILU_FillFactor=fill_factor,<EOL>DiagPivotThresh=diag_pivot_thresh, ColPerm=permc_spec,<EOL>PanelSize=panel_size, Relax=relax)<EOL>if options is not None:<EOL><INDENT>_options.update(options)<EOL><DEDENT>return _superlu.gstrf(N, A.nnz, A.data, A.indices, A.indptr,<EOL>ilu=True, options=_options)<EOL>", "docstring": "Compute an incomplete LU decomposition for a sparse, square matrix.\n\nThe resulting object is an approximation to the inverse of `A`.\n\nParameters\n----------\nA : (N, N) array_like\n    Sparse matrix to factorize\ndrop_tol : float, optional\n    Drop tolerance (0 <= tol <= 1) for an incomplete LU decomposition.\n    (default: 1e-4)\nfill_factor : float, optional\n    Specifies the fill ratio upper bound (>= 1.0) for ILU. (default: 10)\ndrop_rule : str, optional\n    Comma-separated string of drop rules to use.\n    Available rules: ``basic``, ``prows``, ``column``, ``area``,\n    ``secondary``, ``dynamic``, ``interp``. (Default: ``basic,area``)\n\n    See SuperLU documentation for details.\nmilu : str, optional\n    Which version of modified ILU to use. (Choices: ``silu``,\n    ``smilu_1``, ``smilu_2`` (default), ``smilu_3``.)\n\nRemaining other options\n    Same as for `splu`\n\nReturns\n-------\ninvA_approx : scipy.sparse.linalg.SuperLU\n    Object, which has a ``solve`` method.\n\nSee also\n--------\nsplu : complete LU decomposition\n\nNotes\n-----\nTo improve the better approximation to the inverse, you may need to\nincrease `fill_factor` AND decrease `drop_tol`.\n\nThis function uses the SuperLU library.", "id": "f19578:m3"}
{"signature": "def _onenormest_matrix_power(A, p,<EOL>t=<NUM_LIT:2>, itmax=<NUM_LIT:5>, compute_v=False, compute_w=False, structure=None):", "body": "return scipy.sparse.linalg.onenormest(<EOL>MatrixPowerOperator(A, p, structure=structure))<EOL>", "docstring": "Efficiently estimate the 1-norm of A^p.\n\nParameters\n----------\nA : ndarray\n    Matrix whose 1-norm of a power is to be computed.\np : int\n    Non-negative integer power.\nt : int, optional\n    A positive parameter controlling the tradeoff between\n    accuracy versus time and memory usage.\n    Larger values take longer and use more memory\n    but give more accurate output.\nitmax : int, optional\n    Use at most this many iterations.\ncompute_v : bool, optional\n    Request a norm-maximizing linear operator input vector if True.\ncompute_w : bool, optional\n    Request a norm-maximizing linear operator output vector if True.\n\nReturns\n-------\nest : float\n    An underestimate of the 1-norm of the sparse matrix.\nv : ndarray, optional\n    The vector such that ||Av||_1 == est*||v||_1.\n    It can be thought of as an input to the linear operator\n    that gives an output with particularly large norm.\nw : ndarray, optional\n    The vector Av which has relatively large 1-norm.\n    It can be thought of as an output of the linear operator\n    that is relatively large in norm compared to the input.", "id": "f19579:m7"}
{"signature": "def __init__(self, A, structure=None, use_exact_onenorm=False):", "body": "self.A = A<EOL>self._A2 = None<EOL>self._A4 = None<EOL>self._A6 = None<EOL>self._A8 = None<EOL>self._A10 = None<EOL>self._d4_exact = None<EOL>self._d6_exact = None<EOL>self._d8_exact = None<EOL>self._d10_exact = None<EOL>self._d4_approx = None<EOL>self._d6_approx = None<EOL>self._d8_approx = None<EOL>self._d10_approx = None<EOL>self.ident = _ident_like(A)<EOL>self.structure = structure<EOL>self.use_exact_onenorm = use_exact_onenorm<EOL>", "docstring": "Initialize the object.\n\nParameters\n----------\nA : a dense or sparse square numpy matrix or ndarray\n    The matrix to be exponentiated.\nstructure : str, optional\n    A string describing the structure of matrix `A`.\n    Only `upper_triangular` is currently supported.\nuse_exact_onenorm : bool, optional\n    If True then only the exact one-norm of matrix powers and products\n    will be used. Otherwise, the one-norm of powers and products\n    may initially be estimated.", "id": "f19579:c2:m0"}
{"signature": "def inv(A):", "body": "I = speye(A.shape[<NUM_LIT:0>], A.shape[<NUM_LIT:1>], dtype=A.dtype, format=A.format)<EOL>Ainv = spsolve(A, I)<EOL>return Ainv<EOL>", "docstring": "Compute the inverse of a sparse matrix\n\nParameters\n----------\nA : (M,M) ndarray or sparse matrix\n    square matrix to be inverted\n\nReturns\n-------\nAinv : (M,M) ndarray or sparse matrix\n    inverse of `A`\n\nNotes\n-----\nThis computes the sparse inverse of `A`.  If the inverse of `A` is expected\nto be non-sparse, it will likely be faster to convert `A` to dense and use\nscipy.linalg.inv.\n\n.. versionadded:: 0.12.0", "id": "f19579:m0"}
{"signature": "def expm(A):", "body": "<EOL>if isinstance(A, (list, tuple)):<EOL><INDENT>A = np.asarray(A)<EOL><DEDENT>if len(A.shape) != <NUM_LIT:2> or A.shape[<NUM_LIT:0>] != A.shape[<NUM_LIT:1>]:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>structure = UPPER_TRIANGULAR if _is_upper_triangular(A) else None<EOL>use_exact_onenorm = A.shape[<NUM_LIT:0>] < <NUM_LIT:200><EOL>h = _ExpmPadeHelper(<EOL>A, structure=structure, use_exact_onenorm=use_exact_onenorm)<EOL>eta_1 = max(h.d4_loose, h.d6_loose)<EOL>if eta_1 < <NUM_LIT> and _ell(h.A, <NUM_LIT:3>) == <NUM_LIT:0>:<EOL><INDENT>U, V = h.pade3()<EOL>return _solve_P_Q(U, V, structure=structure)<EOL><DEDENT>eta_2 = max(h.d4_tight, h.d6_loose)<EOL>if eta_2 < <NUM_LIT> and _ell(h.A, <NUM_LIT:5>) == <NUM_LIT:0>:<EOL><INDENT>U, V = h.pade5()<EOL>return _solve_P_Q(U, V, structure=structure)<EOL><DEDENT>eta_3 = max(h.d6_tight, h.d8_loose)<EOL>if eta_3 < <NUM_LIT> and _ell(h.A, <NUM_LIT:7>) == <NUM_LIT:0>:<EOL><INDENT>U, V = h.pade7()<EOL>return _solve_P_Q(U, V, structure=structure)<EOL><DEDENT>if eta_3 < <NUM_LIT> and _ell(h.A, <NUM_LIT:9>) == <NUM_LIT:0>:<EOL><INDENT>U, V = h.pade9()<EOL>return _solve_P_Q(U, V, structure=structure)<EOL><DEDENT>eta_4 = max(h.d8_loose, h.d10_loose)<EOL>eta_5 = min(eta_3, eta_4)<EOL>theta_13 = <NUM_LIT><EOL>s = max(int(np.ceil(np.log2(eta_5 / theta_13))), <NUM_LIT:0>)<EOL>s = s + _ell(<NUM_LIT:2>**-s * h.A, <NUM_LIT>)<EOL>U, V = h.pade13_scaled(s)<EOL>X = _solve_P_Q(U, V, structure=structure)<EOL>if structure == UPPER_TRIANGULAR:<EOL><INDENT>X = _fragment_2_1(X, h.A, s)<EOL><DEDENT>else:<EOL><INDENT>for i in range(s):<EOL><INDENT>X = X.dot(X)<EOL><DEDENT><DEDENT>return X<EOL>", "docstring": "Compute the matrix exponential using Pade approximation.\n\nParameters\n----------\nA : (M,M) array_like or sparse matrix\n    2D Array or Matrix (sparse or dense) to be exponentiated\n\nReturns\n-------\nexpA : (M,M) ndarray\n    Matrix exponential of `A`\n\nNotes\n-----\nThis is algorithm (6.1) which is a simplification of algorithm (5.1).\n\n.. versionadded:: 0.12.0\n\nReferences\n----------\n.. [1] Awad H. Al-Mohy and Nicholas J. Higham (2009)\n       \"A New Scaling and Squaring Algorithm for the Matrix Exponential.\"\n       SIAM Journal on Matrix Analysis and Applications.\n       31 (3). pp. 970-989. ISSN 1095-7162", "id": "f19579:m9"}
{"signature": "def onenormest(A, t=<NUM_LIT:2>, itmax=<NUM_LIT:5>, compute_v=False, compute_w=False):", "body": "<EOL>if len(A.shape) != <NUM_LIT:2> or A.shape[<NUM_LIT:0>] != A.shape[<NUM_LIT:1>]:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>n = A.shape[<NUM_LIT:1>]<EOL>if t >= n:<EOL><INDENT>A_explicit = np.asarray(aslinearoperator(A).matmat(np.identity(n)))<EOL>if A_explicit.shape != (n, n):<EOL><INDENT>raise Exception('<STR_LIT>',<EOL>'<STR_LIT>' + str(A_explicit.shape))<EOL><DEDENT>col_abs_sums = abs(A_explicit).sum(axis=<NUM_LIT:0>)<EOL>if col_abs_sums.shape != (n, ):<EOL><INDENT>raise Exception('<STR_LIT>',<EOL>'<STR_LIT>' + str(col_abs_sums.shape))<EOL><DEDENT>argmax_j = np.argmax(col_abs_sums)<EOL>v = elementary_vector(n, argmax_j)<EOL>w = A_explicit[:, argmax_j]<EOL>est = col_abs_sums[argmax_j]<EOL><DEDENT>else:<EOL><INDENT>est, v, w, nmults, nresamples = _onenormest_core(A, A.T, t, itmax)<EOL><DEDENT>if compute_v or compute_w:<EOL><INDENT>result = (est,)<EOL>if compute_v:<EOL><INDENT>result += (v,)<EOL><DEDENT>if compute_w:<EOL><INDENT>result += (w,)<EOL><DEDENT>return result<EOL><DEDENT>else:<EOL><INDENT>return est<EOL><DEDENT>", "docstring": "Compute a lower bound of the 1-norm of a sparse matrix.\n\nParameters\n----------\nA : ndarray or other linear operator\n    A linear operator that can be transposed and that can\n    produce matrix products.\nt : int, optional\n    A positive parameter controlling the tradeoff between\n    accuracy versus time and memory usage.\n    Larger values take longer and use more memory\n    but give more accurate output.\nitmax : int, optional\n    Use at most this many iterations.\ncompute_v : bool, optional\n    Request a norm-maximizing linear operator input vector if True.\ncompute_w : bool, optional\n    Request a norm-maximizing linear operator output vector if True.\n\nReturns\n-------\nest : float\n    An underestimate of the 1-norm of the sparse matrix.\nv : ndarray, optional\n    The vector such that ||Av||_1 == est*||v||_1.\n    It can be thought of as an input to the linear operator\n    that gives an output with particularly large norm.\nw : ndarray, optional\n    The vector Av which has relatively large 1-norm.\n    It can be thought of as an output of the linear operator\n    that is relatively large in norm compared to the input.\n\nNotes\n-----\nThis is algorithm 2.4 of [1].\n\nIn [2] it is described as follows.\n\"This algorithm typically requires the evaluation of\nabout 4t matrix-vector products and almost invariably\nproduces a norm estimate (which is, in fact, a lower\nbound on the norm) correct to within a factor 3.\"\n\n.. versionadded:: 0.13.0\n\nReferences\n----------\n.. [1] Nicholas J. Higham and Francoise Tisseur (2000),\n       \"A Block Algorithm for Matrix 1-Norm Estimation,\n       with an Application to 1-Norm Pseudospectra.\"\n       SIAM J. Matrix Anal. Appl. Vol. 21, No. 4, pp. 1185-1201.\n\n.. [2] Awad H. Al-Mohy and Nicholas J. Higham (2009),\n       \"A new scaling and squaring algorithm for the matrix exponential.\"\n       SIAM J. Matrix Anal. Appl. Vol. 31, No. 3, pp. 970-989.", "id": "f19580:m0"}
{"signature": "def _onenormest_core(A, AT, t, itmax):", "body": "<EOL>A_linear_operator = aslinearoperator(A)<EOL>AT_linear_operator = aslinearoperator(AT)<EOL>if itmax < <NUM_LIT:2>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if t < <NUM_LIT:1>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>n = A.shape[<NUM_LIT:0>]<EOL>if t >= n:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>nmults = <NUM_LIT:0><EOL>nresamples = <NUM_LIT:0><EOL>X = np.ones((n, t), dtype=float)<EOL>if t > <NUM_LIT:1>:<EOL><INDENT>for i in range(<NUM_LIT:1>, t):<EOL><INDENT>resample_column(i, X)<EOL><DEDENT>for i in range(t):<EOL><INDENT>while column_needs_resampling(i, X):<EOL><INDENT>resample_column(i, X)<EOL>nresamples += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>X /= float(n)<EOL>ind_hist = set()<EOL>est_old = <NUM_LIT:0><EOL>S = np.zeros((n, t), dtype=float)<EOL>k = <NUM_LIT:1><EOL>ind = None<EOL>while True:<EOL><INDENT>Y = np.asarray(A_linear_operator.matmat(X))<EOL>nmults += <NUM_LIT:1><EOL>mags = [norm_1d_1(Y[:, j]) for j in range(t)]<EOL>est = np.max(mags)<EOL>best_j = np.argmax(mags)<EOL>if est > est_old or k == <NUM_LIT:2>:<EOL><INDENT>if k >= <NUM_LIT:2>:<EOL><INDENT>ind_best = ind[best_j]<EOL><DEDENT>w = Y[:, best_j]<EOL><DEDENT>if k >= <NUM_LIT:2> and est <= est_old:<EOL><INDENT>est = est_old<EOL>break<EOL><DEDENT>est_old = est<EOL>S_old = S<EOL>if k > itmax:<EOL><INDENT>break<EOL><DEDENT>S = sign_round_up(Y)<EOL>if every_col_of_X_is_parallel_to_a_col_of_Y(S, S_old):<EOL><INDENT>break<EOL><DEDENT>if t > <NUM_LIT:1>:<EOL><INDENT>for i in range(t):<EOL><INDENT>while column_needs_resampling(i, S, S_old):<EOL><INDENT>resample_column(i, S)<EOL>nresamples += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>Z = np.asarray(AT_linear_operator.matmat(S))<EOL>nmults += <NUM_LIT:1><EOL>h = [norm_1d_inf(row) for row in Z]<EOL>if k >= <NUM_LIT:2> and max(h) == h[ind_best]:<EOL><INDENT>break<EOL><DEDENT>h_i_pairs = zip(h, range(n))<EOL>h, ind = zip(*sorted(h_i_pairs, reverse=True))<EOL>if t > <NUM_LIT:1>:<EOL><INDENT>if set(ind[:t]) <= ind_hist:<EOL><INDENT>break<EOL><DEDENT>unused_entries = [i for i in ind if i not in ind_hist]<EOL>used_entries = [i for i in ind if i in ind_hist]<EOL>ind = unused_entries + used_entries<EOL><DEDENT>for j in range(t):<EOL><INDENT>X[:, j] = elementary_vector(n, ind[j])<EOL><DEDENT>ind_hist.update(ind[:t])<EOL>k += <NUM_LIT:1><EOL><DEDENT>v = elementary_vector(n, ind_best)<EOL>return est, v, w, nmults, nresamples<EOL>", "docstring": "Compute a lower bound of the 1-norm of a sparse matrix.\n\nParameters\n----------\nA : ndarray or other linear operator\n    A linear operator that can produce matrix products.\nAT : ndarray or other linear operator\n    The transpose of A.\nt : int, optional\n    A positive parameter controlling the tradeoff between\n    accuracy versus time and memory usage.\nitmax : int, optional\n    Use at most this many iterations.\n\nReturns\n-------\nest : float\n    An underestimate of the 1-norm of the sparse matrix.\nv : ndarray, optional\n    The vector such that ||Av||_1 == est*||v||_1.\n    It can be thought of as an input to the linear operator\n    that gives an output with particularly large norm.\nw : ndarray, optional\n    The vector Av which has relatively large 1-norm.\n    It can be thought of as an output of the linear operator\n    that is relatively large in norm compared to the input.\nnmults : int, optional\n    The number of matrix products that were computed.\nnresamples : int, optional\n    The number of times a parallel column was observed,\n    necessitating a re-randomization of the column.\n\nNotes\n-----\nThis is algorithm 2.4.", "id": "f19580:m11"}
{"signature": "def getnnz(self, axis=None):", "body": "if axis is None:<EOL><INDENT>return int(self.indptr[-<NUM_LIT:1>])<EOL><DEDENT>else:<EOL><INDENT>if axis < <NUM_LIT:0>:<EOL><INDENT>axis += <NUM_LIT:2><EOL><DEDENT>axis, _ = self._swap((axis, <NUM_LIT:1> - axis))<EOL>_, N = self._swap(self.shape)<EOL>if axis == <NUM_LIT:0>:<EOL><INDENT>return _compat_bincount(downcast_intp_index(self.indices),<EOL>minlength=N)<EOL><DEDENT>elif axis == <NUM_LIT:1>:<EOL><INDENT>return np.diff(self.indptr)<EOL><DEDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>", "docstring": "Get the count of explicitly-stored values (nonzeros)\n\n        Parameters\n        ----------\n        axis : None, 0, or 1\n            Select between the number of values across the whole matrix, in\n            each column, or in each row.", "id": "f19581:c0:m1"}
{"signature": "def check_format(self, full_check=True):", "body": "<EOL>major_name,minor_name = self._swap(('<STR_LIT>','<STR_LIT>'))<EOL>major_dim,minor_dim = self._swap(self.shape)<EOL>if self.indptr.dtype.kind != '<STR_LIT:i>':<EOL><INDENT>warn(\"<STR_LIT>\"<EOL>% self.indptr.dtype.name)<EOL><DEDENT>if self.indices.dtype.kind != '<STR_LIT:i>':<EOL><INDENT>warn(\"<STR_LIT>\"<EOL>% self.indices.dtype.name)<EOL><DEDENT>idx_dtype = get_index_dtype((self.indptr, self.indices))<EOL>self.indptr = np.asarray(self.indptr, dtype=idx_dtype)<EOL>self.indices = np.asarray(self.indices, dtype=idx_dtype)<EOL>self.data = to_native(self.data)<EOL>if self.data.ndim != <NUM_LIT:1> or self.indices.ndim != <NUM_LIT:1> or self.indptr.ndim != <NUM_LIT:1>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if (len(self.indptr) != major_dim + <NUM_LIT:1>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\" %<EOL>(len(self.indptr), major_dim + <NUM_LIT:1>))<EOL><DEDENT>if (self.indptr[<NUM_LIT:0>] != <NUM_LIT:0>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if (len(self.indices) != len(self.data)):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if (self.indptr[-<NUM_LIT:1>] > len(self.indices)):<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>self.prune()<EOL>if full_check:<EOL><INDENT>if self.nnz > <NUM_LIT:0>:<EOL><INDENT>if self.indices.max() >= minor_dim:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" %<EOL>(minor_name,minor_dim))<EOL><DEDENT>if self.indices.min() < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" %<EOL>minor_name)<EOL><DEDENT>if np.diff(self.indptr).min() < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "check whether the matrix format is valid\n\n        Parameters\n        ==========\n\n            - full_check : {bool}\n                - True  - rigorous check, O(N) operations : default\n                - False - basic check, O(1) operations", "id": "f19581:c0:m3"}
{"signature": "def __get_sorted(self):", "body": "<EOL>if not hasattr(self,'<STR_LIT>'):<EOL><INDENT>fn = _sparsetools.csr_has_sorted_indices<EOL>self._has_sorted_indices =fn(len(self.indptr) - <NUM_LIT:1>, self.indptr, self.indices)<EOL><DEDENT>return self._has_sorted_indices<EOL>", "docstring": "Determine whether the matrix has sorted indices\n\n        Returns\n            - True: if the indices of the matrix are in sorted order\n            - False: otherwise", "id": "f19581:c0:m42"}
{"signature": "def _insert_many(self, i, j, x):", "body": "order = np.argsort(i, kind='<STR_LIT>')  <EOL>i = i.take(order, mode='<STR_LIT>')<EOL>j = j.take(order, mode='<STR_LIT>')<EOL>x = x.take(order, mode='<STR_LIT>')<EOL>do_sort = self.has_sorted_indices<EOL>idx_dtype = get_index_dtype((self.indices, self.indptr),<EOL>maxval=(self.indptr[-<NUM_LIT:1>] + x.size))<EOL>self.indptr = np.asarray(self.indptr, dtype=idx_dtype)<EOL>self.indices = np.asarray(self.indices, dtype=idx_dtype)<EOL>i = np.asarray(i, dtype=idx_dtype)<EOL>j = np.asarray(j, dtype=idx_dtype)<EOL>indices_parts = []<EOL>data_parts = []<EOL>ui, ui_indptr = _compat_unique(i, return_index=True)<EOL>ui_indptr = np.append(ui_indptr, len(j))<EOL>new_nnzs = np.diff(ui_indptr)<EOL>prev = <NUM_LIT:0><EOL>for c, (ii, js, je) in enumerate(izip(ui, ui_indptr, ui_indptr[<NUM_LIT:1>:])):<EOL><INDENT>start = self.indptr[prev]<EOL>stop = self.indptr[ii]<EOL>indices_parts.append(self.indices[start:stop])<EOL>data_parts.append(self.data[start:stop])<EOL>uj, uj_indptr = _compat_unique(j[js:je][::-<NUM_LIT:1>], return_index=True)<EOL>if len(uj) == je - js:<EOL><INDENT>indices_parts.append(j[js:je])<EOL>data_parts.append(x[js:je])<EOL><DEDENT>else:<EOL><INDENT>indices_parts.append(j[js:je][::-<NUM_LIT:1>][uj_indptr])<EOL>data_parts.append(x[js:je][::-<NUM_LIT:1>][uj_indptr])<EOL>new_nnzs[c] = len(uj)<EOL><DEDENT>prev = ii<EOL><DEDENT>start = self.indptr[ii]<EOL>indices_parts.append(self.indices[start:])<EOL>data_parts.append(self.data[start:])<EOL>self.indices = np.concatenate(indices_parts)<EOL>self.data = np.concatenate(data_parts)<EOL>nnzs = np.asarray(np.ediff1d(self.indptr, to_begin=<NUM_LIT:0>), dtype=idx_dtype)<EOL>nnzs[<NUM_LIT:1>:][ui] += new_nnzs<EOL>self.indptr = np.cumsum(nnzs, out=nnzs)<EOL>if do_sort:<EOL><INDENT>self.has_sorted_indices = False<EOL>self.sort_indices()<EOL><DEDENT>self.check_format(full_check=False)<EOL>", "docstring": "Inserts new nonzero at each (i, j) with value x\n\n        Here (i,j) index major and minor respectively.\n        i, j and x must be non-empty, 1d arrays.\n        Inserts each major group (e.g. all entries per row) at a time.\n        Maintains has_sorted_indices property.\n        Modifies i, j, x in place.", "id": "f19581:c0:m30"}
{"signature": "def _with_data(self,data,copy=True):", "body": "if copy:<EOL><INDENT>return self.__class__((data,self.indices.copy(),self.indptr.copy()),<EOL>shape=self.shape,dtype=data.dtype)<EOL><DEDENT>else:<EOL><INDENT>return self.__class__((data,self.indices,self.indptr),<EOL>shape=self.shape,dtype=data.dtype)<EOL><DEDENT>", "docstring": "Returns a matrix with the same sparsity structure as self,\n        but with different data.  By default the structure arrays\n        (i.e. .indptr and .indices) are copied.", "id": "f19581:c0:m47"}
{"signature": "def tocoo(self,copy=True):", "body": "major_dim,minor_dim = self._swap(self.shape)<EOL>data = self.data<EOL>minor_indices = self.indices<EOL>if copy:<EOL><INDENT>data = data.copy()<EOL>minor_indices = minor_indices.copy()<EOL><DEDENT>major_indices = np.empty(len(minor_indices), dtype=self.indices.dtype)<EOL>_sparsetools.expandptr(major_dim,self.indptr,major_indices)<EOL>row,col = self._swap((major_indices,minor_indices))<EOL>from .coo import coo_matrix<EOL>return coo_matrix((data,(row,col)), self.shape)<EOL>", "docstring": "Return a COOrdinate representation of this matrix\n\n        When copy=False the index and data arrays are not copied.", "id": "f19581:c0:m36"}
{"signature": "def _get_slice(self, i, start, stop, stride, shape):", "body": "if stride != <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if stop <= start:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>indices = []<EOL>for ind in xrange(self.indptr[i], self.indptr[i+<NUM_LIT:1>]):<EOL><INDENT>if self.indices[ind] >= start and self.indices[ind] < stop:<EOL><INDENT>indices.append(ind)<EOL><DEDENT><DEDENT>index = self.indices[indices] - start<EOL>data = self.data[indices]<EOL>indptr = np.array([<NUM_LIT:0>, len(indices)])<EOL>return self.__class__((data, index, indptr), shape=shape,<EOL>dtype=self.dtype)<EOL>", "docstring": "Returns a copy of the elements\n            [i, start:stop:string] for row-oriented matrices\n            [start:stop:string, i] for column-oriented matrices", "id": "f19581:c0:m32"}
{"signature": "def diagonal(self):", "body": "<EOL>fn = getattr(_sparsetools, self.format + \"<STR_LIT>\")<EOL>y = np.empty(min(self.shape), dtype=upcast(self.dtype))<EOL>fn(self.shape[<NUM_LIT:0>], self.shape[<NUM_LIT:1>], self.indptr, self.indices, self.data, y)<EOL>return y<EOL>", "docstring": "Returns the main diagonal of the matrix", "id": "f19581:c0:m20"}
{"signature": "def toarray(self, order=None, out=None):", "body": "return self.tocoo(copy=False).toarray(order=order, out=out)<EOL>", "docstring": "See the docstring for `spmatrix.toarray`.", "id": "f19581:c0:m37"}
{"signature": "def sum_duplicates(self):", "body": "if self.has_canonical_format:<EOL><INDENT>return<EOL><DEDENT>self.sort_indices()<EOL>fn = _sparsetools.csr_sum_duplicates<EOL>M,N = self._swap(self.shape)<EOL>fn(M, N, self.indptr, self.indices, self.data)<EOL>self.prune()  <EOL>self.has_canonical_format = True<EOL>", "docstring": "Eliminate duplicate matrix entries by adding them together\n\n        The is an *in place* operation", "id": "f19581:c0:m41"}
{"signature": "def upcast_char(*args):", "body": "t = _upcast_memo.get(args)<EOL>if t is not None:<EOL><INDENT>return t<EOL><DEDENT>t = upcast(*map(np.dtype, args))<EOL>_upcast_memo[args] = t<EOL>return t<EOL>", "docstring": "Same as `upcast` but taking dtype.char as input (faster).", "id": "f19582:m1"}
{"signature": "def upcast_scalar(dtype, scalar):", "body": "return (np.array([<NUM_LIT:0>], dtype=dtype) * scalar).dtype<EOL>", "docstring": "Determine data type for binary operation between an array of\n    type `dtype` and a scalar.", "id": "f19582:m2"}
{"signature": "def isscalarlike(x):", "body": "return np.isscalar(x) or (isdense(x) and x.ndim == <NUM_LIT:0>)<EOL>", "docstring": "Is x either a scalar, an array scalar, or a 0-dim array?", "id": "f19582:m7"}
{"signature": "def getdtype(dtype, a=None, default=None):", "body": "<EOL>canCast = True<EOL>if dtype is None:<EOL><INDENT>try:<EOL><INDENT>newdtype = a.dtype<EOL><DEDENT>except AttributeError:<EOL><INDENT>if default is not None:<EOL><INDENT>newdtype = np.dtype(default)<EOL>canCast = False<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>newdtype = np.dtype(dtype)<EOL>if newdtype == np.object_:<EOL><INDENT>warnings.warn(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>return newdtype<EOL>", "docstring": "Function used to simplify argument processing.  If 'dtype' is not\n    specified (is None), returns a.dtype; otherwise returns a np.dtype\n    object created from the specified dtype argument.  If 'dtype' and 'a'\n    are both None, construct a data type out of the 'default' parameter.\n    Furthermore, 'dtype' must be in 'allowed' set.", "id": "f19582:m5"}
{"signature": "def getrow(self, i):", "body": "new = lil_matrix((<NUM_LIT:1>, self.shape[<NUM_LIT:1>]), dtype=self.dtype)<EOL>new.rows[<NUM_LIT:0>] = self.rows[i][:]<EOL>new.data[<NUM_LIT:0>] = self.data[i][:]<EOL>return new<EOL>", "docstring": "Returns a copy of the 'i'th row.", "id": "f19583:c0:m9"}
{"signature": "def toarray(self, order=None, out=None):", "body": "d = self._process_toarray_args(order, out)<EOL>for i, row in enumerate(self.rows):<EOL><INDENT>for pos, j in enumerate(row):<EOL><INDENT>d[i, j] = self.data[i][pos]<EOL><DEDENT><DEDENT>return d<EOL>", "docstring": "See the docstring for `spmatrix.toarray`.", "id": "f19583:c0:m16"}
{"signature": "def getrow(self, i):", "body": "<EOL>from .csr import csr_matrix<EOL>m = self.shape[<NUM_LIT:0>]<EOL>if i < <NUM_LIT:0>:<EOL><INDENT>i += m<EOL><DEDENT>if i < <NUM_LIT:0> or i >= m:<EOL><INDENT>raise IndexError(\"<STR_LIT>\")<EOL><DEDENT>row_selector = csr_matrix(([<NUM_LIT:1>], [[<NUM_LIT:0>], [i]]), shape=(<NUM_LIT:1>,m), dtype=self.dtype)<EOL>return row_selector * self<EOL>", "docstring": "Returns a copy of row i of the matrix, as a (1 x n) sparse\n        matrix (row vector).", "id": "f19585:c3:m57"}
{"signature": "def todense(self, order=None, out=None):", "body": "return np.asmatrix(self.toarray(order=order, out=out))<EOL>", "docstring": "Return a dense matrix representation of this matrix.\n\nParameters\n----------\norder : {'C', 'F'}, optional\n    Whether to store multi-dimensional data in C (row-major)\n    or Fortran (column-major) order in memory. The default\n    is 'None', indicating the NumPy default of C-ordered.\n    Cannot be specified in conjunction with the `out`\n    argument.\n\nout : ndarray, 2-dimensional, optional\n    If specified, uses this array (or `numpy.matrix`) as the\n    output buffer instead of allocating a new array to\n    return. The provided array must have the same shape and\n    dtype as the sparse matrix on which you are calling the\n    method.\n\nReturns\n-------\narr : numpy.matrix, 2-dimensional\n    A NumPy matrix object with the same shape and containing\n    the same data represented by the sparse matrix, with the\n    requested memory order. If `out` was passed and was an\n    array (rather than a `numpy.matrix`), it will be filled\n    with the appropriate values and returned wrapped in a\n    `numpy.matrix` object that shares the same memory.", "id": "f19585:c3:m58"}
{"signature": "def multiply(self, other):", "body": "return self.tocsr().multiply(other)<EOL>", "docstring": "Point-wise multiplication by another matrix", "id": "f19585:c3:m15"}
{"signature": "def asformat(self, format):", "body": "if format is None or format == self.format:<EOL><INDENT>return self<EOL><DEDENT>else:<EOL><INDENT>return getattr(self,'<STR_LIT:to>' + format)()<EOL><DEDENT>", "docstring": "Return this matrix in a given sparse format\n\n        Parameters\n        ----------\n        format : {string, None}\n            desired sparse matrix format\n                - None for no format conversion\n                - \"csr\" for csr_matrix format\n                - \"csc\" for csc_matrix format\n                - \"lil\" for lil_matrix format\n                - \"dok\" for dok_matrix format and so on", "id": "f19585:c3:m14"}
{"signature": "def nonzero(self):", "body": "<EOL>A = self.tocoo()<EOL>nz_mask = A.data != <NUM_LIT:0><EOL>return (A.row[nz_mask],A.col[nz_mask])<EOL>", "docstring": "nonzero indices\n\n        Returns a tuple of arrays (row,col) containing the indices\n        of the non-zero elements of the matrix.\n\n        Examples\n        --------\n        >>> from scipy.sparse import csr_matrix\n        >>> A = csr_matrix([[1,2,0],[0,0,3],[4,0,5]])\n        >>> A.nonzero()\n        (array([0, 0, 1, 2, 2]), array([0, 1, 2, 0, 2]))", "id": "f19585:c3:m55"}
{"signature": "def _get_submatrix(self, row_slice, col_slice):", "body": "M,N = self.shape<EOL>def process_slice(sl, num):<EOL><INDENT>if isinstance(sl, slice):<EOL><INDENT>if sl.step not in (<NUM_LIT:1>, None):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>i0, i1 = sl.start, sl.stop<EOL>if i0 is None:<EOL><INDENT>i0 = <NUM_LIT:0><EOL><DEDENT>elif i0 < <NUM_LIT:0>:<EOL><INDENT>i0 = num + i0<EOL><DEDENT>if i1 is None:<EOL><INDENT>i1 = num<EOL><DEDENT>elif i1 < <NUM_LIT:0>:<EOL><INDENT>i1 = num + i1<EOL><DEDENT>return i0, i1<EOL><DEDENT>elif isintlike(sl):<EOL><INDENT>if sl < <NUM_LIT:0>:<EOL><INDENT>sl += num<EOL><DEDENT>return sl, sl + <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT><DEDENT>def check_bounds(i0, i1, num):<EOL><INDENT>if not (<NUM_LIT:0> <= i0 <= num) or not (<NUM_LIT:0> <= i1 <= num) or not (i0 <= i1):<EOL><INDENT>raise IndexError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (i0, num, i1, num, i0, i1))<EOL><DEDENT><DEDENT>i0, i1 = process_slice(row_slice, M)<EOL>j0, j1 = process_slice(col_slice, N)<EOL>check_bounds(i0, i1, M)<EOL>check_bounds(j0, j1, N)<EOL>indptr, indices, data = get_csr_submatrix(M, N,<EOL>self.indptr, self.indices, self.data,<EOL>int(i0), int(i1), int(j0), int(j1))<EOL>shape = (i1 - i0, j1 - j0)<EOL>return self.__class__((data,indices,indptr), shape=shape)<EOL>", "docstring": "Return a submatrix of this matrix (new matrix is created).", "id": "f19586:c0:m10"}
{"signature": "def _swap(self,x):", "body": "return (x[<NUM_LIT:0>],x[<NUM_LIT:1>])<EOL>", "docstring": "swap the members of x if this is a column-oriented matrix", "id": "f19586:c0:m5"}
{"signature": "def _get_row_slice(self, i, cslice):", "body": "if i < <NUM_LIT:0>:<EOL><INDENT>i += self.shape[<NUM_LIT:0>]<EOL><DEDENT>if i < <NUM_LIT:0> or i >= self.shape[<NUM_LIT:0>]:<EOL><INDENT>raise IndexError('<STR_LIT>' % i)<EOL><DEDENT>start, stop, stride = cslice.indices(self.shape[<NUM_LIT:1>])<EOL>if stride == <NUM_LIT:1>:<EOL><INDENT>row_slice = self._get_submatrix(i, cslice)<EOL><DEDENT>else:<EOL><INDENT>row_indices = self.indices[self.indptr[i]:self.indptr[i + <NUM_LIT:1>]]<EOL>row_data = self.data[self.indptr[i]:self.indptr[i + <NUM_LIT:1>]]<EOL>if stride > <NUM_LIT:0>:<EOL><INDENT>ind = (row_indices >= start) & (row_indices < stop)<EOL><DEDENT>elif stride < <NUM_LIT:0>:<EOL><INDENT>ind = (row_indices <= start) & (row_indices > stop)<EOL><DEDENT>if abs(stride) > <NUM_LIT:1>:<EOL><INDENT>ind = ind & ((row_indices - start) % stride == <NUM_LIT:0>)<EOL><DEDENT>row_indices = (row_indices[ind] - start) // stride<EOL>row_data = row_data[ind]<EOL>row_indptr = np.array([<NUM_LIT:0>, len(row_indices)])<EOL>if stride < <NUM_LIT:0>:<EOL><INDENT>row_data = row_data[::-<NUM_LIT:1>]<EOL>row_indices = abs(row_indices[::-<NUM_LIT:1>])<EOL><DEDENT>shape = (<NUM_LIT:1>, int(np.ceil(float(stop - start) / stride)))<EOL>row_slice = csr_matrix((row_data, row_indices, row_indptr),<EOL>shape=shape)<EOL><DEDENT>return row_slice<EOL>", "docstring": "Returns a copy of row self[i, cslice]", "id": "f19586:c0:m9"}
{"signature": "def poisson2d(N,dtype='<STR_LIT:d>',format=None):", "body": "if N == <NUM_LIT:1>:<EOL><INDENT>diags = asarray([[<NUM_LIT:4>]],dtype=dtype)<EOL>return dia_matrix((diags,[<NUM_LIT:0>]), shape=(<NUM_LIT:1>,<NUM_LIT:1>)).asformat(format)<EOL><DEDENT>offsets = array([<NUM_LIT:0>,-N,N,-<NUM_LIT:1>,<NUM_LIT:1>])<EOL>diags = empty((<NUM_LIT:5>,N**<NUM_LIT:2>),dtype=dtype)<EOL>diags[<NUM_LIT:0>] = <NUM_LIT:4>  <EOL>diags[<NUM_LIT:1>:] = -<NUM_LIT:1>  <EOL>diags[<NUM_LIT:3>,N-<NUM_LIT:1>::N] = <NUM_LIT:0>  <EOL>diags[<NUM_LIT:4>,N::N] = <NUM_LIT:0>  <EOL>return dia_matrix((diags,offsets),shape=(N**<NUM_LIT:2>,N**<NUM_LIT:2>)).asformat(format)<EOL>", "docstring": "Return a sparse matrix for the 2D Poisson problem\nwith standard 5-point finite difference stencil on a\nsquare N-by-N grid.", "id": "f19587:m1"}
{"signature": "def bench_construction(self):", "body": "matrices = []<EOL>matrices.append(('<STR_LIT>',csr_matrix((<NUM_LIT>,<NUM_LIT>))))<EOL>matrices.append(('<STR_LIT>',sparse.eye(<NUM_LIT>)))<EOL>matrices.append(('<STR_LIT>', poisson2d(<NUM_LIT:100>)))<EOL>print()<EOL>print('<STR_LIT>')<EOL>print('<STR_LIT>')<EOL>print('<STR_LIT>')<EOL>print('<STR_LIT>')<EOL>fmt = '<STR_LIT>'<EOL>for name,A in matrices:<EOL><INDENT>A = A.tocoo()<EOL>for format in ['<STR_LIT>','<STR_LIT>']:<EOL><INDENT>start = time.clock()<EOL>iter = <NUM_LIT:0><EOL>while time.clock() < start + <NUM_LIT:0.5>:<EOL><INDENT>T = eval(format + '<STR_LIT>')(A.shape)<EOL>for i,j,v in zip(A.row,A.col,A.data):<EOL><INDENT>T[i,j] = v<EOL><DEDENT>iter += <NUM_LIT:1><EOL><DEDENT>end = time.clock()<EOL>del T<EOL>name = name.center(<NUM_LIT:12>)<EOL>shape = (\"<STR_LIT:%s>\" % (A.shape,)).center(<NUM_LIT:20>)<EOL>print(fmt % (format,name,shape,A.nnz,(end-start)/float(iter)))<EOL><DEDENT><DEDENT>", "docstring": "build matrices by inserting single values", "id": "f19587:c0:m4"}
{"signature": "def tocoo(self):", "body": "from .coo import coo_matrix<EOL>if self.nnz == <NUM_LIT:0>:<EOL><INDENT>return coo_matrix(self.shape, dtype=self.dtype)<EOL><DEDENT>else:<EOL><INDENT>idx_dtype = get_index_dtype(maxval=max(self.shape[<NUM_LIT:0>], self.shape[<NUM_LIT:1>]))<EOL>data = np.asarray(_list(self.values()), dtype=self.dtype)<EOL>indices = np.asarray(_list(self.keys()), dtype=idx_dtype).T<EOL>return coo_matrix((data,indices), shape=self.shape, dtype=self.dtype)<EOL><DEDENT>", "docstring": "Return a copy of this matrix in COOrdinate format", "id": "f19588:c0:m21"}
{"signature": "def resize(self, shape):", "body": "if not isshape(shape):<EOL><INDENT>raise TypeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>newM, newN = shape<EOL>M, N = self.shape<EOL>if newM < M or newN < N:<EOL><INDENT>for (i, j) in list(self.keys()):<EOL><INDENT>if i >= newM or j >= newN:<EOL><INDENT>del self[i, j]<EOL><DEDENT><DEDENT><DEDENT>self._shape = shape<EOL>", "docstring": "Resize the matrix in-place to dimensions given by 'shape'.\n\n        Any non-zero elements that lie outside the new shape are removed.", "id": "f19588:c0:m26"}
{"signature": "def _list(x):", "body": "if not isinstance(x, list):<EOL><INDENT>x = list(x)<EOL><DEDENT>return x<EOL>", "docstring": "Force x to a list.", "id": "f19588:m0"}
{"signature": "def get_thunk_type_set():", "body": "it_types = []<EOL>i_types = []<EOL>j = <NUM_LIT:0><EOL>getter_code = \"<STR_LIT>\"<EOL>for I_typenum, I_type in I_TYPES:<EOL><INDENT>piece = \"\"\"<STR_LIT>\"\"\"<EOL>getter_code += piece % dict(I_typenum=I_typenum, j=j)<EOL>i_types.append((j, I_typenum, None, I_type, None))<EOL>j += <NUM_LIT:1><EOL>for T_typenum, T_type in T_TYPES:<EOL><INDENT>piece = \"\"\"<STR_LIT>\"\"\"<EOL>getter_code += piece % dict(T_typenum=T_typenum, j=j)<EOL>it_types.append((j, I_typenum, T_typenum, I_type, T_type))<EOL>j += <NUM_LIT:1><EOL><DEDENT>getter_code += \"\"\"<STR_LIT>\"\"\"<EOL><DEDENT>return i_types, it_types, GET_THUNK_CASE_TEMPLATE % dict(content=getter_code)<EOL>", "docstring": "Get a list containing cartesian product of data types, plus a getter routine.\n\nReturns\n-------\ni_types : list [(j, I_typenum, None, I_type, None), ...] \n     Pairing of index type numbers and the corresponding C++ types,\n     and an unique index `j`. This is for routines that are parameterized\n     only by I but not by T.\nit_types : list [(j, I_typenum, T_typenum, I_type, T_type), ...]\n     Same as `i_types`, but for routines parameterized both by T and I.\ngetter_code : str\n     C++ code for a function that takes I_typenum, T_typenum and returns\n     the unique index corresponding to the lists, or -1 if no match was\n     found.", "id": "f19589:m0"}
{"signature": "def toarray(self, order=None, out=None):", "body": "B = self._process_toarray_args(order, out)<EOL>fortran = int(B.flags.f_contiguous)<EOL>if not fortran and not B.flags.c_contiguous:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>M,N = self.shape<EOL>coo_todense(M, N, self.nnz, self.row, self.col, self.data,<EOL>B.ravel('<STR_LIT:A>'), fortran)<EOL>return B<EOL>", "docstring": "See the docstring for `spmatrix.toarray`.", "id": "f19591:c0:m4"}
{"signature": "def _with_data(self,data,copy=True):", "body": "if copy:<EOL><INDENT>return coo_matrix((data, (self.row.copy(), self.col.copy())),<EOL>shape=self.shape, dtype=data.dtype)<EOL><DEDENT>else:<EOL><INDENT>return coo_matrix((data, (self.row, self.col)),<EOL>shape=self.shape, dtype=data.dtype)<EOL><DEDENT>", "docstring": "Returns a matrix with the same sparsity structure as self,\n        but with different data.  By default the index arrays\n        (i.e. .row and .col) are copied.", "id": "f19591:c0:m12"}
{"signature": "def sum_duplicates(self):", "body": "if self.has_canonical_format or len(self.data) == <NUM_LIT:0>:<EOL><INDENT>return<EOL><DEDENT>order = np.lexsort((self.row,self.col))<EOL>self.row = self.row[order]<EOL>self.col = self.col[order]<EOL>self.data = self.data[order]<EOL>unique_mask = ((self.row[<NUM_LIT:1>:] != self.row[:-<NUM_LIT:1>]) |<EOL>(self.col[<NUM_LIT:1>:] != self.col[:-<NUM_LIT:1>]))<EOL>unique_mask = np.append(True, unique_mask)<EOL>self.row = self.row[unique_mask]<EOL>self.col = self.col[unique_mask]<EOL>unique_inds, = np.nonzero(unique_mask)<EOL>self.data = np.add.reduceat(self.data, unique_inds, dtype=self.dtype)<EOL>self.has_canonical_format = True<EOL>", "docstring": "Eliminate duplicate matrix entries by adding them together\n\n        This is an *in place* operation", "id": "f19591:c0:m13"}
{"signature": "def getrow(self, i):", "body": "<EOL>return self._get_submatrix(i, slice(None)).tocsr()<EOL>", "docstring": "Returns a copy of row i of the matrix, as a (1 x n)\n        CSR matrix (row vector).", "id": "f19592:c0:m6"}
{"signature": "def _with_data(self,data,copy=True):", "body": "if copy:<EOL><INDENT>return self.__class__((data,self.indices.copy(),self.indptr.copy()),<EOL>shape=self.shape,dtype=data.dtype)<EOL><DEDENT>else:<EOL><INDENT>return self.__class__((data,self.indices,self.indptr),<EOL>shape=self.shape,dtype=data.dtype)<EOL><DEDENT>", "docstring": "Returns a matrix with the same sparsity structure as self,\n        but with different data.  By default the structure arrays\n        (i.e. .indptr and .indices) are copied.", "id": "f19596:c0:m24"}
{"signature": "def tocoo(self,copy=True):", "body": "M,N = self.shape<EOL>R,C = self.blocksize<EOL>indptr_diff = np.diff(self.indptr)<EOL>if indptr_diff.dtype.itemsize > np.dtype(np.intp).itemsize:<EOL><INDENT>indptr_diff_limited = indptr_diff.astype(np.intp)<EOL>if np.any(indptr_diff_limited != indptr_diff):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>indptr_diff = indptr_diff_limited<EOL><DEDENT>row = (R * np.arange(M//R)).repeat(indptr_diff)<EOL>row = row.repeat(R*C).reshape(-<NUM_LIT:1>,R,C)<EOL>row += np.tile(np.arange(R).reshape(-<NUM_LIT:1>,<NUM_LIT:1>), (<NUM_LIT:1>,C))<EOL>row = row.reshape(-<NUM_LIT:1>)<EOL>col = (C * self.indices).repeat(R*C).reshape(-<NUM_LIT:1>,R,C)<EOL>col += np.tile(np.arange(C), (R,<NUM_LIT:1>))<EOL>col = col.reshape(-<NUM_LIT:1>)<EOL>data = self.data.reshape(-<NUM_LIT:1>)<EOL>if copy:<EOL><INDENT>data = data.copy()<EOL><DEDENT>from .coo import coo_matrix<EOL>return coo_matrix((data,(row,col)), shape=self.shape)<EOL>", "docstring": "Convert this matrix to COOrdinate format.\n\n        When copy=False the data array will be shared between\n        this matrix and the resultant coo_matrix.", "id": "f19596:c0:m17"}
{"signature": "def euclidean(u, v):", "body": "u = _validate_vector(u)<EOL>v = _validate_vector(v)<EOL>dist = norm(u - v)<EOL>return dist<EOL>", "docstring": "Computes the Euclidean distance between two 1-D arrays.\n\nThe Euclidean distance between 1-D arrays `u` and `v`, is defined as\n\n.. math::\n\n   {||u-v||}_2\n\nParameters\n----------\nu : (N,) array_like\n    Input array.\nv : (N,) array_like\n    Input array.\n\nReturns\n-------\neuclidean : double\n    The Euclidean distance between vectors `u` and `v`.", "id": "f19601:m7"}
{"signature": "def jaccard(u, v):", "body": "u = _validate_vector(u)<EOL>v = _validate_vector(v)<EOL>dist = (np.double(np.bitwise_and((u != v),<EOL>np.bitwise_or(u != <NUM_LIT:0>, v != <NUM_LIT:0>)).sum())<EOL>/ np.double(np.bitwise_or(u != <NUM_LIT:0>, v != <NUM_LIT:0>).sum()))<EOL>return dist<EOL>", "docstring": "Computes the Jaccard-Needham dissimilarity between two boolean 1-D arrays.\n\nThe Jaccard-Needham dissimilarity between 1-D boolean arrays `u` and `v`,\nis defined as\n\n.. math::\n\n   \\\\frac{c_{TF} + c_{FT}}\n        {c_{TT} + c_{FT} + c_{TF}}\n\nwhere :math:`c_{ij}` is the number of occurrences of\n:math:`\\\\mathtt{u[k]} = i` and :math:`\\\\mathtt{v[k]} = j` for\n:math:`k < n`.\n\nParameters\n----------\nu : (N,) array_like, bool\n    Input array.\nv : (N,) array_like, bool\n    Input array.\n\nReturns\n-------\njaccard : double\n    The Jaccard distance between vectors `u` and `v`.", "id": "f19601:m12"}
{"signature": "def dice(u, v):", "body": "u = _validate_vector(u)<EOL>v = _validate_vector(v)<EOL>if u.dtype == np.bool:<EOL><INDENT>ntt = (u & v).sum()<EOL><DEDENT>else:<EOL><INDENT>ntt = (u * v).sum()<EOL><DEDENT>(nft, ntf) = _nbool_correspond_ft_tf(u, v)<EOL>return float(ntf + nft) / float(<NUM_LIT> * ntt + ntf + nft)<EOL>", "docstring": "Computes the Dice dissimilarity between two boolean 1-D arrays.\n\nThe Dice dissimilarity between `u` and `v`, is\n\n.. math::\n\n     \\\\frac{c_{TF} + c_{FT}}\n          {2c_{TT} + c_{FT} + c_{TF}}\n\nwhere :math:`c_{ij}` is the number of occurrences of\n:math:`\\\\mathtt{u[k]} = i` and :math:`\\\\mathtt{v[k]} = j` for\n:math:`k < n`.\n\nParameters\n----------\nu : (N,) ndarray, bool\n    Input 1-D array.\nv : (N,) ndarray, bool\n    Input 1-D array.\n\nReturns\n-------\ndice : double\n    The Dice dissimilarity between 1-D arrays `u` and `v`.", "id": "f19601:m24"}
{"signature": "def squareform(X, force=\"<STR_LIT>\", checks=True):", "body": "X = _convert_to_double(np.asarray(X, order='<STR_LIT:c>'))<EOL>if not np.issubsctype(X, np.double):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>s = X.shape<EOL>if force.lower() == '<STR_LIT>':<EOL><INDENT>if len(s) != <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT>elif force.lower() == '<STR_LIT>':<EOL><INDENT>if len(s) != <NUM_LIT:2>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT>if len(s) == <NUM_LIT:1>:<EOL><INDENT>if X.shape[<NUM_LIT:0>] == <NUM_LIT:0>:<EOL><INDENT>return np.zeros((<NUM_LIT:1>, <NUM_LIT:1>), dtype=np.double)<EOL><DEDENT>d = int(np.ceil(np.sqrt(X.shape[<NUM_LIT:0>] * <NUM_LIT:2>)))<EOL>if d * (d - <NUM_LIT:1>) / <NUM_LIT:2> != int(s[<NUM_LIT:0>]):<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>M = np.zeros((d, d), dtype=np.double)<EOL>[X] = _copy_arrays_if_base_present([X])<EOL>_distance_wrap.to_squareform_from_vector_wrap(M, X)<EOL>M = M + M.transpose()<EOL>return M<EOL><DEDENT>elif len(s) == <NUM_LIT:2>:<EOL><INDENT>if s[<NUM_LIT:0>] != s[<NUM_LIT:1>]:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if checks:<EOL><INDENT>is_valid_dm(X, throw=True, name='<STR_LIT:X>')<EOL><DEDENT>d = s[<NUM_LIT:0>]<EOL>if d <= <NUM_LIT:1>:<EOL><INDENT>return np.array([], dtype=np.double)<EOL><DEDENT>v = np.zeros((d * (d - <NUM_LIT:1>)) // <NUM_LIT:2>, dtype=np.double)<EOL>[X] = _copy_arrays_if_base_present([X])<EOL>_distance_wrap.to_vector_from_squareform_wrap(X, v)<EOL>return v<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>') % len(s))<EOL><DEDENT>", "docstring": "Converts a vector-form distance vector to a square-form distance\nmatrix, and vice-versa.\n\nParameters\n----------\nX : ndarray\n    Either a condensed or redundant distance matrix.\nforce : str, optional\n    As with MATLAB(TM), if force is equal to 'tovector' or 'tomatrix',\n    the input will be treated as a distance matrix or distance vector\n    respectively.\nchecks : bool, optional\n    If `checks` is set to False, no checks will be made for matrix\n    symmetry nor zero diagonals. This is useful if it is known that\n    ``X - X.T1`` is small and ``diag(X)`` is close to zero.\n    These values are ignored any way so they do not disrupt the\n    squareform transformation.\n\nReturns\n-------\nY : ndarray\n    If a condensed distance matrix is passed, a redundant one is\n    returned, or if a redundant one is passed, a condensed distance\n    matrix is returned.\n\nNotes\n-----\n\n1. v = squareform(X)\n\n   Given a square d-by-d symmetric distance matrix X,\n   ``v=squareform(X)`` returns a ``d * (d-1) / 2`` (or\n   `${n \\\\choose 2}$`) sized vector v.\n\n  v[{n \\\\choose 2}-{n-i \\\\choose 2} + (j-i-1)] is the distance\n  between points i and j. If X is non-square or asymmetric, an error\n  is returned.\n\n2. X = squareform(v)\n\n  Given a d*d(-1)/2 sized v for some integer d>=2 encoding distances\n  as described, X=squareform(v) returns a d by d distance matrix X. The\n  X[i, j] and X[j, i] values are set to\n  v[{n \\\\choose 2}-{n-i \\\\choose 2} + (j-u-1)] and all\n  diagonal elements are zero.", "id": "f19601:m30"}
{"signature": "def matching(u, v):", "body": "u = _validate_vector(u)<EOL>v = _validate_vector(v)<EOL>(nft, ntf) = _nbool_correspond_ft_tf(u, v)<EOL>return float(nft + ntf) / float(len(u))<EOL>", "docstring": "Computes the Matching dissimilarity between two boolean 1-D arrays.\n\nThe Matching dissimilarity between two boolean 1-D arrays\n`u` and `v`, is defined as\n\n.. math::\n\n   \\\\frac{c_{TF} + c_{FT}}{n}\n\nwhere :math:`c_{ij}` is the number of occurrences of\n:math:`\\\\mathtt{u[k]} = i` and :math:`\\\\mathtt{v[k]} = j` for\n:math:`k < n`.\n\nParameters\n----------\nu : (N,) array_like, bool\n    Input array.\nv : (N,) array_like, bool\n    Input array.\n\nReturns\n-------\nmatching : double\n    The Matching dissimilarity between vectors `u` and `v`.", "id": "f19601:m23"}
{"signature": "def num_obs_y(Y):", "body": "Y = np.asarray(Y, order='<STR_LIT:c>')<EOL>is_valid_y(Y, throw=True, name='<STR_LIT:Y>')<EOL>k = Y.shape[<NUM_LIT:0>]<EOL>if k == <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>d = int(np.ceil(np.sqrt(k * <NUM_LIT:2>)))<EOL>if (d * (d - <NUM_LIT:1>) / <NUM_LIT:2>) != k:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>return d<EOL>", "docstring": "Returns the number of original observations that correspond to a\ncondensed distance matrix.\n\nParameters\n----------\nY : ndarray\n    Condensed distance matrix.\n\nReturns\n-------\nn : int\n    The number of observations in the condensed distance matrix `Y`.", "id": "f19601:m34"}
{"signature": "def sokalmichener(u, v):", "body": "u = _validate_vector(u)<EOL>v = _validate_vector(v)<EOL>if u.dtype == np.bool:<EOL><INDENT>ntt = (u & v).sum()<EOL>nff = (~u & ~v).sum()<EOL><DEDENT>else:<EOL><INDENT>ntt = (u * v).sum()<EOL>nff = ((<NUM_LIT:1.0> - u) * (<NUM_LIT:1.0> - v)).sum()<EOL><DEDENT>(nft, ntf) = _nbool_correspond_ft_tf(u, v)<EOL>return float(<NUM_LIT> * (ntf + nft)) / float(ntt + nff + <NUM_LIT> * (ntf + nft))<EOL>", "docstring": "Computes the Sokal-Michener dissimilarity between two boolean 1-D arrays.\n\nThe Sokal-Michener dissimilarity between boolean 1-D arrays `u` and `v`,\nis defined as\n\n.. math::\n\n   \\\\frac{R}\n        {S + R}\n\nwhere :math:`c_{ij}` is the number of occurrences of\n:math:`\\\\mathtt{u[k]} = i` and :math:`\\\\mathtt{v[k]} = j` for\n:math:`k < n`, :math:`R = 2 * (c_{TF} + c_{FT})` and\n:math:`S = c_{FF} + c_{TT}`.\n\nParameters\n----------\nu : (N,) array_like, bool\n    Input array.\nv : (N,) array_like, bool\n    Input array.\n\nReturns\n-------\nsokalmichener : double\n    The Sokal-Michener dissimilarity between vectors `u` and `v`.", "id": "f19601:m27"}
{"signature": "def num_obs_dm(d):", "body": "d = np.asarray(d, order='<STR_LIT:c>')<EOL>is_valid_dm(d, tol=np.inf, throw=True, name='<STR_LIT:d>')<EOL>return d.shape[<NUM_LIT:0>]<EOL>", "docstring": "Returns the number of original observations that correspond to a\nsquare, redundant distance matrix.\n\nParameters\n----------\nd : ndarray\n    The target distance matrix.\n\nReturns\n-------\nnum_obs_dm : int\n    The number of observations in the redundant distance matrix.", "id": "f19601:m33"}
{"signature": "def _copy_array_if_base_present(a):", "body": "if a.base is not None:<EOL><INDENT>return a.copy()<EOL><DEDENT>elif np.issubsctype(a, np.float32):<EOL><INDENT>return np.array(a, dtype=np.double)<EOL><DEDENT>else:<EOL><INDENT>return a<EOL><DEDENT>", "docstring": "Copies the array if its base points to a parent array.", "id": "f19601:m0"}
{"signature": "def hamming(u, v):", "body": "u = _validate_vector(u)<EOL>v = _validate_vector(v)<EOL>return (u != v).mean()<EOL>", "docstring": "Computes the Hamming distance between two 1-D arrays.\n\nThe Hamming distance between 1-D arrays `u` and `v`, is simply the\nproportion of disagreeing components in `u` and `v`. If `u` and `v` are\nboolean vectors, the Hamming distance is\n\n.. math::\n\n   \\\\frac{c_{01} + c_{10}}{n}\n\nwhere :math:`c_{ij}` is the number of occurrences of\n:math:`\\\\mathtt{u[k]} = i` and :math:`\\\\mathtt{v[k]} = j` for\n:math:`k < n`.\n\nParameters\n----------\nu : (N,) array_like\n    Input array.\nv : (N,) array_like\n    Input array.\n\nReturns\n-------\nhamming : double\n    The Hamming distance between vectors `u` and `v`.", "id": "f19601:m11"}
{"signature": "@_held_figure<EOL>def voronoi_plot_2d(vor, ax=None):", "body": "if vor.points.shape[<NUM_LIT:1>] != <NUM_LIT:2>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>ax.plot(vor.points[:,<NUM_LIT:0>], vor.points[:,<NUM_LIT:1>], '<STR_LIT:.>')<EOL>ax.plot(vor.vertices[:,<NUM_LIT:0>], vor.vertices[:,<NUM_LIT:1>], '<STR_LIT:o>')<EOL>for simplex in vor.ridge_vertices:<EOL><INDENT>simplex = np.asarray(simplex)<EOL>if np.all(simplex >= <NUM_LIT:0>):<EOL><INDENT>ax.plot(vor.vertices[simplex,<NUM_LIT:0>], vor.vertices[simplex,<NUM_LIT:1>], '<STR_LIT>')<EOL><DEDENT><DEDENT>ptp_bound = vor.points.ptp(axis=<NUM_LIT:0>)<EOL>center = vor.points.mean(axis=<NUM_LIT:0>)<EOL>for pointidx, simplex in zip(vor.ridge_points, vor.ridge_vertices):<EOL><INDENT>simplex = np.asarray(simplex)<EOL>if np.any(simplex < <NUM_LIT:0>):<EOL><INDENT>i = simplex[simplex >= <NUM_LIT:0>][<NUM_LIT:0>]  <EOL>t = vor.points[pointidx[<NUM_LIT:1>]] - vor.points[pointidx[<NUM_LIT:0>]]  <EOL>t /= np.linalg.norm(t)<EOL>n = np.array([-t[<NUM_LIT:1>], t[<NUM_LIT:0>]])  <EOL>midpoint = vor.points[pointidx].mean(axis=<NUM_LIT:0>)<EOL>direction = np.sign(np.dot(midpoint - center, n)) * n<EOL>far_point = vor.vertices[i] + direction * ptp_bound.max()<EOL>ax.plot([vor.vertices[i,<NUM_LIT:0>], far_point[<NUM_LIT:0>]],<EOL>[vor.vertices[i,<NUM_LIT:1>], far_point[<NUM_LIT:1>]], '<STR_LIT>')<EOL><DEDENT><DEDENT>_adjust_bounds(ax, vor.points)<EOL>return ax.figure<EOL>", "docstring": "Plot the given Voronoi diagram in 2-D\n\nParameters\n----------\nvor : scipy.spatial.Voronoi instance\n    Diagram to plot\nax : matplotlib.axes.Axes instance, optional\n    Axes to plot on\n\nReturns\n-------\nfig : matplotlib.figure.Figure instance\n    Figure for the plot\n\nSee Also\n--------\nVoronoi\n\nNotes\n-----\nRequires Matplotlib.", "id": "f19602:m4"}
{"signature": "def min_distance_point(self, x, p=<NUM_LIT>):", "body": "return minkowski_distance(<NUM_LIT:0>, np.maximum(<NUM_LIT:0>,np.maximum(self.mins-x,x-self.maxes)),p)<EOL>", "docstring": "Return the minimum distance between input and points in the hyperrectangle.\n\nParameters\n----------\nx : array_like\n    Input.\np : float, optional\n    Input.", "id": "f19603:c0:m4"}
{"signature": "def query_ball_point(self, x, r, p=<NUM_LIT>, eps=<NUM_LIT:0>):", "body": "x = np.asarray(x)<EOL>if x.shape[-<NUM_LIT:1>] != self.m:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (x.shape[-<NUM_LIT:1>], self.m))<EOL><DEDENT>if len(x.shape) == <NUM_LIT:1>:<EOL><INDENT>return self.__query_ball_point(x, r, p, eps)<EOL><DEDENT>else:<EOL><INDENT>retshape = x.shape[:-<NUM_LIT:1>]<EOL>result = np.empty(retshape, dtype=np.object)<EOL>for c in np.ndindex(retshape):<EOL><INDENT>result[c] = self.__query_ball_point(x[c], r, p=p, eps=eps)<EOL><DEDENT>return result<EOL><DEDENT>", "docstring": "Find all points within distance r of point(s) x.\n\n        Parameters\n        ----------\n        x : array_like, shape tuple + (self.m,)\n            The point or points to search for neighbors of.\n        r : positive float\n            The radius of points to return.\n        p : float, optional\n            Which Minkowski p-norm to use.  Should be in the range [1, inf].\n        eps : nonnegative float, optional\n            Approximate search. Branches of the tree are not explored if their\n            nearest points are further than ``r / (1 + eps)``, and branches are\n            added in bulk if their furthest points are nearer than\n            ``r * (1 + eps)``.\n\n        Returns\n        -------\n        results : list or array of lists\n            If `x` is a single point, returns a list of the indices of the\n            neighbors of `x`. If `x` is an array of points, returns an object\n            array of shape tuple containing lists of neighbors.\n\n        Notes\n        -----\n        If you have many points whose neighbors you want to find, you may save\n        substantial amounts of time by putting them in a KDTree and using\n        query_ball_tree.\n\n        Examples\n        --------\n        >>> from scipy import spatial\n        >>> x, y = np.mgrid[0:4, 0:4]\n        >>> points = zip(x.ravel(), y.ravel())\n        >>> tree = spatial.KDTree(points)\n        >>> tree.query_ball_point([2, 0], 1)\n        [4, 8, 9, 12]", "id": "f19603:c1:m5"}
{"signature": "def query(self, x, k=<NUM_LIT:1>, eps=<NUM_LIT:0>, p=<NUM_LIT:2>, distance_upper_bound=np.inf):", "body": "x = np.asarray(x)<EOL>if np.shape(x)[-<NUM_LIT:1>] != self.m:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % (self.m, np.shape(x)))<EOL><DEDENT>if p < <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>retshape = np.shape(x)[:-<NUM_LIT:1>]<EOL>if retshape != ():<EOL><INDENT>if k is None:<EOL><INDENT>dd = np.empty(retshape,dtype=np.object)<EOL>ii = np.empty(retshape,dtype=np.object)<EOL><DEDENT>elif k > <NUM_LIT:1>:<EOL><INDENT>dd = np.empty(retshape+(k,),dtype=np.float)<EOL>dd.fill(np.inf)<EOL>ii = np.empty(retshape+(k,),dtype=np.int)<EOL>ii.fill(self.n)<EOL><DEDENT>elif k == <NUM_LIT:1>:<EOL><INDENT>dd = np.empty(retshape,dtype=np.float)<EOL>dd.fill(np.inf)<EOL>ii = np.empty(retshape,dtype=np.int)<EOL>ii.fill(self.n)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>for c in np.ndindex(retshape):<EOL><INDENT>hits = self.__query(x[c], k=k, eps=eps, p=p, distance_upper_bound=distance_upper_bound)<EOL>if k is None:<EOL><INDENT>dd[c] = [d for (d,i) in hits]<EOL>ii[c] = [i for (d,i) in hits]<EOL><DEDENT>elif k > <NUM_LIT:1>:<EOL><INDENT>for j in range(len(hits)):<EOL><INDENT>dd[c+(j,)], ii[c+(j,)] = hits[j]<EOL><DEDENT><DEDENT>elif k == <NUM_LIT:1>:<EOL><INDENT>if len(hits) > <NUM_LIT:0>:<EOL><INDENT>dd[c], ii[c] = hits[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>dd[c] = np.inf<EOL>ii[c] = self.n<EOL><DEDENT><DEDENT><DEDENT>return dd, ii<EOL><DEDENT>else:<EOL><INDENT>hits = self.__query(x, k=k, eps=eps, p=p, distance_upper_bound=distance_upper_bound)<EOL>if k is None:<EOL><INDENT>return [d for (d,i) in hits], [i for (d,i) in hits]<EOL><DEDENT>elif k == <NUM_LIT:1>:<EOL><INDENT>if len(hits) > <NUM_LIT:0>:<EOL><INDENT>return hits[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>return np.inf, self.n<EOL><DEDENT><DEDENT>elif k > <NUM_LIT:1>:<EOL><INDENT>dd = np.empty(k,dtype=np.float)<EOL>dd.fill(np.inf)<EOL>ii = np.empty(k,dtype=np.int)<EOL>ii.fill(self.n)<EOL>for j in range(len(hits)):<EOL><INDENT>dd[j], ii[j] = hits[j]<EOL><DEDENT>return dd, ii<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>", "docstring": "Query the kd-tree for nearest neighbors\n\nParameters\n----------\nx : array_like, last dimension self.m\n    An array of points to query.\nk : integer\n    The number of nearest neighbors to return.\neps : nonnegative float\n    Return approximate nearest neighbors; the kth returned value\n    is guaranteed to be no further than (1+eps) times the\n    distance to the real kth nearest neighbor.\np : float, 1<=p<=infinity\n    Which Minkowski p-norm to use.\n    1 is the sum-of-absolute-values \"Manhattan\" distance\n    2 is the usual Euclidean distance\n    infinity is the maximum-coordinate-difference distance\ndistance_upper_bound : nonnegative float\n    Return only neighbors within this distance. This is used to prune\n    tree searches, so if you are doing a series of nearest-neighbor\n    queries, it may help to supply the distance to the nearest neighbor\n    of the most recent point.\n\nReturns\n-------\nd : float or array of floats\n    The distances to the nearest neighbors.\n    If x has shape tuple+(self.m,), then d has shape tuple if\n    k is one, or tuple+(k,) if k is larger than one. Missing\n    neighbors (e.g. when k > n or distance_upper_bound is\n    given) are indicated with infinite distances.  If k is None,\n    then d is an object array of shape tuple, containing lists\n    of distances. In either case the hits are sorted by distance\n    (nearest first).\ni : integer or array of integers\n    The locations of the neighbors in self.data. i is the same\n    shape as d.\n\nExamples\n--------\n>>> from scipy import spatial\n>>> x, y = np.mgrid[0:5, 2:8]\n>>> tree = spatial.KDTree(zip(x.ravel(), y.ravel()))\n>>> tree.data\narray([[0, 2],\n       [0, 3],\n       [0, 4],\n       [0, 5],\n       [0, 6],\n       [0, 7],\n       [1, 2],\n       [1, 3],\n       [1, 4],\n       [1, 5],\n       [1, 6],\n       [1, 7],\n       [2, 2],\n       [2, 3],\n       [2, 4],\n       [2, 5],\n       [2, 6],\n       [2, 7],\n       [3, 2],\n       [3, 3],\n       [3, 4],\n       [3, 5],\n       [3, 6],\n       [3, 7],\n       [4, 2],\n       [4, 3],\n       [4, 4],\n       [4, 5],\n       [4, 6],\n       [4, 7]])\n>>> pts = np.array([[0, 0], [2.1, 2.9]])\n>>> tree.query(pts)\n(array([ 2.        ,  0.14142136]), array([ 0, 13]))\n>>> tree.query(pts[0])\n(2.0, 0)", "id": "f19603:c1:m3"}
{"signature": "@dec.slow<EOL><INDENT>def _check_5point_avg_2d_complex_float(self):<DEDENT>", "body": "expr = \"<STR_LIT>\"\"<STR_LIT>\"<EOL>self.generic_2d(expr,complex64)<EOL>", "docstring": "Note: THIS TEST is KNOWN TO FAIL ON GCC 3.x.\n            It will not adversely affect 99.99 percent of weave\n\n        result[1:-1,1:-1] = (b[1:-1,1:-1] + b[2:,1:-1] + b[:-2,1:-1]\n                             + b[1:-1,2:] + b[1:-1,:-2]) / 5.\n\n        Note: THIS TEST is KNOWN TO FAIL ON GCC 3.x.  The reason is that\n        5. is a double and b is a complex32.  blitz doesn't know\n        how to handle complex32/double.  See:\n        http://www.oonumerics.org/MailArchives/blitz-support/msg00541.php\n        Unfortunately, the fix isn't trivial.  Instead of fixing it, I\n        prefer to wait until we replace blitz++ with Pat Miller's code\n        that doesn't rely on blitz..", "id": "f19614:c1:m4"}
{"signature": "def clear_temp_catalog():", "body": "backup_dir = tempfile.mkdtemp()<EOL>for file in temp_catalog_files():<EOL><INDENT>move_file(file,backup_dir)<EOL><DEDENT>return backup_dir<EOL>", "docstring": "Remove any catalog from the temp dir.", "id": "f19618:m3"}
{"signature": "def gcc_exists(name='<STR_LIT>'):", "body": "result = <NUM_LIT:0><EOL>cmd = [str(name), '<STR_LIT>']<EOL>try:<EOL><INDENT>if sys.platform == '<STR_LIT:win32>':<EOL><INDENT>p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE,<EOL>stderr=subprocess.STDOUT)<EOL><DEDENT>else:<EOL><INDENT>p = subprocess.Popen(cmd, stdout=subprocess.PIPE,<EOL>stderr=subprocess.STDOUT)<EOL><DEDENT>str_result = p.stdout.read()<EOL>if '<STR_LIT>' in str_result:<EOL><INDENT>result = <NUM_LIT:1><EOL><DEDENT><DEDENT>except:<EOL><INDENT>result = not os.system(\"<STR_LIT:U+0020>\".join(cmd))<EOL><DEDENT>return result<EOL>", "docstring": "Test to make sure gcc is found.", "id": "f19628:m7"}
{"signature": "def choose_compiler(compiler_name='<STR_LIT>'):", "body": "if sys.platform == '<STR_LIT:win32>':<EOL><INDENT>if not compiler_name:<EOL><INDENT>if msvc_exists():<EOL><INDENT>compiler_name = '<STR_LIT>'<EOL><DEDENT>elif gcc_exists():<EOL><INDENT>compiler_name = '<STR_LIT>'<EOL><DEDENT><DEDENT>elif compiler_name == '<STR_LIT>':<EOL><INDENT>compiler_name = '<STR_LIT>'<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if compiler_name == '<STR_LIT>':<EOL><INDENT>compiler_name = '<STR_LIT>'<EOL><DEDENT><DEDENT>return compiler_name<EOL>", "docstring": "Try and figure out which compiler is gonna be used on windows.\n        On other platforms, it just returns whatever value it is given.\n\n        converts 'gcc' to 'mingw32' on win32", "id": "f19628:m6"}
{"signature": "def choose_compiler(compiler_name='<STR_LIT>'):", "body": "if not compiler_name:<EOL><INDENT>compiler_name = '<STR_LIT>'<EOL><DEDENT>if sys.platform == '<STR_LIT:win32>':<EOL><INDENT>if not compiler_name:<EOL><INDENT>if msvc_exists():<EOL><INDENT>compiler_name = '<STR_LIT>'<EOL><DEDENT>elif gcc_exists():<EOL><INDENT>compiler_name = '<STR_LIT>'<EOL><DEDENT><DEDENT>elif compiler_name == '<STR_LIT>':<EOL><INDENT>compiler_name = '<STR_LIT>'<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if compiler_name == '<STR_LIT>':<EOL><INDENT>compiler_name = '<STR_LIT>'<EOL><DEDENT><DEDENT>return compiler_name<EOL>", "docstring": "Try and figure out which compiler is gonna be used on windows.\n        On other platforms, it just returns whatever value it is given.\n\n        converts 'gcc' to 'mingw32' on win32", "id": "f19631:m6"}
{"signature": "def __init__(self, class_name=\"<STR_LIT>\", pycobj=<NUM_LIT:0>, runtime_version=None):", "body": "self.class_name = class_name<EOL>self.pycobj = pycobj  <EOL>self.runtime_version = runtime_version<EOL>common_base_converter.__init__(self)<EOL>", "docstring": "Initializes the instance.\n\n        Parameters\n        ----------\n\n        - class_name : `string`\n\n          Name of class, this is set dynamically at build time by the\n          `type_spec` method.\n\n        - pycobj : `int`\n\n          If `pycobj` is 0 then code is generated to deal with string\n          representations of the SWIG wrapped pointer.  If it is 1,\n          then code is generated to deal with a PyCObject.  If it is 2\n          then code is generated to deal with a PySwigObject.\n\n        - runtime_version : `int`\n\n          Specifies the SWIG_RUNTIME_VERSION to use.  Defaults to\n          `None`.  In this case the runtime is automatically\n          determined.  This option is useful if you want to force the\n          runtime_version to be a specific one and override the\n          auto-detected one.", "id": "f19633:c0:m0"}
{"signature": "def _get_swig_type(self, value):", "body": "swig_typ = '<STR_LIT>'<EOL>if hasattr(value, '<STR_LIT>'):<EOL><INDENT>type_this = type(value.this)<EOL>type_str = str(type_this)<EOL>if isinstance(type_this, str):<EOL><INDENT>try:<EOL><INDENT>data = value.this.split('<STR_LIT:_>')<EOL>if data[<NUM_LIT:2>] == '<STR_LIT:p>':<EOL><INDENT>swig_typ = '<STR_LIT:str>'<EOL><DEDENT><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>elif type_str == \"<STR_LIT>\":<EOL><INDENT>swig_typ = '<STR_LIT>'<EOL><DEDENT>elif type_str.find('<STR_LIT>') > -<NUM_LIT:1>:<EOL><INDENT>swig_typ = '<STR_LIT>'<EOL><DEDENT><DEDENT>return swig_typ<EOL>", "docstring": "Given the object in the form of `value`, this method\n        returns information on the SWIG internal object repesentation\n        type.  Different versions of SWIG use different object\n        representations.  This method provides information on the type\n        of internal representation.\n\n        Currently returns one of ['', 'str', 'pycobj', 'pyswig'].", "id": "f19633:c0:m3"}
{"signature": "def CStr(s):", "body": "if s is None:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>assert_(isinstance(s, str), msg=\"<STR_LIT>\")<EOL>r = repr('<STR_LIT:\">'+s)  <EOL>return '<STR_LIT:\">'+r[<NUM_LIT:2>:-<NUM_LIT:1>]+'<STR_LIT:\">'<EOL>", "docstring": "Hacky way to get legal C string from Python string", "id": "f19636:m0"}
{"signature": "def parse_tuple_code(self):", "body": "declare_return = '<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>'<EOL>py_objects = '<STR_LIT:U+002CU+0020>'.join(self.arg_specs.py_pointers())<EOL>if py_objects:<EOL><INDENT>declare_py_objects = '<STR_LIT>' + py_objects + '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>declare_py_objects = '<STR_LIT>'<EOL><DEDENT>py_vars = '<STR_LIT>'.join(self.arg_specs.py_variables())<EOL>if py_vars:<EOL><INDENT>init_values = py_vars + '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>init_values = '<STR_LIT>'<EOL><DEDENT>parse_tuple = '<STR_LIT>''<STR_LIT>''<STR_LIT>''<STR_LIT>'<EOL>return declare_return + declare_py_objects +init_values + parse_tuple<EOL>", "docstring": "Create code block for PyArg_ParseTuple.  Variable declarations\n            for all PyObjects are done also.\n\n            This code got a lot uglier when I added local_dict...", "id": "f19638:c0:m2"}
{"signature": "def arg_local_dict_code(self):", "body": "arg_strings = [arg.local_dict_code() for arg in self.arg_specs]<EOL>return \"<STR_LIT>\".join(arg_strings)<EOL>", "docstring": "Return the code to create the local dict as a string.", "id": "f19638:c0:m5"}
{"signature": "def inline(code,arg_names=[],local_dict=None, global_dict=None,<EOL>force=<NUM_LIT:0>,<EOL>compiler='<STR_LIT>',<EOL>verbose=<NUM_LIT:0>,<EOL>support_code=None,<EOL>headers=[],<EOL>customize=None,<EOL>type_converters=None,<EOL>auto_downcast=<NUM_LIT:1>,<EOL>newarr_converter=<NUM_LIT:0>,<EOL>**kw):", "body": "<EOL>global function_catalog<EOL>call_frame = sys._getframe().f_back<EOL>if local_dict is None:<EOL><INDENT>local_dict = call_frame.f_locals<EOL><DEDENT>if global_dict is None:<EOL><INDENT>global_dict = call_frame.f_globals<EOL><DEDENT>if force:<EOL><INDENT>module_dir = global_dict.get('<STR_LIT>',None)<EOL>func = compile_function(code,arg_names,local_dict,<EOL>global_dict,module_dir,<EOL>compiler=compiler,<EOL>verbose=verbose,<EOL>support_code=support_code,<EOL>headers=headers,<EOL>customize=customize,<EOL>type_converters=type_converters,<EOL>auto_downcast=auto_downcast,<EOL>**kw)<EOL>function_catalog.add_function(code,func,module_dir)<EOL>results = attempt_function_call(code,local_dict,global_dict)<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>results = apply(function_cache[code],(local_dict,global_dict))<EOL>return results<EOL><DEDENT>except TypeError as msg:<EOL><INDENT>msg = str(msg).strip()<EOL>if msg[:<NUM_LIT:16>] == \"<STR_LIT>\":<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(msg)<EOL><DEDENT><DEDENT>except NameError as msg:<EOL><INDENT>msg = str(msg).strip()<EOL>if msg[:<NUM_LIT:16>] == \"<STR_LIT>\":<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>raise NameError(msg)<EOL><DEDENT><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>results = attempt_function_call(code,local_dict,global_dict)<EOL><DEDENT>except ValueError:<EOL><INDENT>module_dir = global_dict.get('<STR_LIT>',None)<EOL>func = compile_function(code,arg_names,local_dict,<EOL>global_dict,module_dir,<EOL>compiler=compiler,<EOL>verbose=verbose,<EOL>support_code=support_code,<EOL>headers=headers,<EOL>customize=customize,<EOL>type_converters=type_converters,<EOL>auto_downcast=auto_downcast,<EOL>**kw)<EOL>function_catalog.add_function(code,func,module_dir)<EOL>results = attempt_function_call(code,local_dict,global_dict)<EOL><DEDENT><DEDENT>return results<EOL>", "docstring": "Inline C/C++ code within Python scripts.\n\n``inline()`` compiles and executes C/C++ code on the fly.  Variables\nin the local and global Python scope are also available in the\nC/C++ code.  Values are passed to the C/C++ code by assignment\nmuch like variables passed are passed into a standard Python\nfunction.  Values are returned from the C/C++ code through a\nspecial argument called return_val.  Also, the contents of\nmutable objects can be changed within the C/C++ code and the\nchanges remain after the C code exits and returns to Python.\n\ninline has quite a few options as listed below.  Also, the keyword\narguments for distutils extension modules are accepted to\nspecify extra information needed for compiling.\n\nParameters\n----------\ncode : string\n    A string of valid C++ code.  It should not specify a return\n    statement.  Instead it should assign results that need to be\n    returned to Python in the `return_val`.\narg_names : [str], optional\n    A list of Python variable names that should be transferred from\n    Python into the C/C++ code.  It defaults to an empty string.\nlocal_dict : dict, optional\n    If specified, it is a dictionary of values that should be used as\n    the local scope for the C/C++ code.  If local_dict is not\n    specified the local dictionary of the calling function is used.\nglobal_dict : dict, optional\n    If specified, it is a dictionary of values that should be used as\n    the global scope for the C/C++ code.  If `global_dict` is not\n    specified, the global dictionary of the calling function is used.\nforce : {0, 1}, optional\n    If 1, the C++ code is compiled every time inline is called.  This\n    is really only useful for debugging, and probably only useful if\n    your editing `support_code` a lot.\ncompiler : str, optional\n    The name of compiler to use when compiling.  On windows, it\n    understands 'msvc' and 'gcc' as well as all the compiler names\n    understood by distutils.  On Unix, it'll only understand the\n    values understood by distutils. (I should add 'gcc' though to\n    this).\n\n    On windows, the compiler defaults to the Microsoft C++ compiler.\n    If this isn't available, it looks for mingw32 (the gcc compiler).\n\n    On Unix, it'll probably use the same compiler that was used when\n    compiling Python. Cygwin's behavior should be similar.\nverbose : {0,1,2}, optional\n    Specifies how much information is printed during the compile\n    phase of inlining code.  0 is silent (except on windows with msvc\n    where it still prints some garbage). 1 informs you when compiling\n    starts, finishes, and how long it took.  2 prints out the command\n    lines for the compilation process and can be useful if your having\n    problems getting code to work.  Its handy for finding the name of\n    the .cpp file if you need to examine it.  verbose has no effect if\n    the compilation isn't necessary.\nsupport_code : str, optional\n    A string of valid C++ code declaring extra code that might be\n    needed by your compiled function.  This could be declarations of\n    functions, classes, or structures.\nheaders : [str], optional\n    A list of strings specifying header files to use when compiling\n    the code.  The list might look like ``[\"<vector>\",\"'my_header'\"]``.\n    Note that the header strings need to be in a form than can be\n    pasted at the end of a ``#include`` statement in the C++ code.\ncustomize : base_info.custom_info, optional\n    An alternative way to specify `support_code`, `headers`, etc. needed\n    by the function.  See :mod:`scipy.weave.base_info` for more\n    details. (not sure this'll be used much).\ntype_converters : [type converters], optional\n    These guys are what convert Python data types to C/C++ data types.\n    If you'd like to use a different set of type conversions than the\n    default, specify them here. Look in the type conversions section\n    of the main documentation for examples.\nauto_downcast : {1,0}, optional\n    This only affects functions that have numpy arrays as input\n    variables.  Setting this to 1 will cause all floating point values\n    to be cast as float instead of double if all the Numeric arrays\n    are of type float.  If even one of the arrays has type double or\n    double complex, all variables maintain their standard\n    types.\nnewarr_converter : int, optional\n    Unused.\n\nOther Parameters\n----------------\nRelevant :mod:`distutils` keywords.  These are duplicated from Greg Ward's\n:class:`distutils.extension.Extension` class for convenience:\n\nsources : [string]\n    List of source filenames, relative to the distribution root\n    (where the setup script lives), in Unix form (slash-separated)\n    for portability.  Source files may be C, C++, SWIG (.i),\n    platform-specific resource files, or whatever else is recognized\n    by the \"build_ext\" command as source for a Python extension.\n\n    .. note:: The `module_path` file is always appended to the front of\n       this list\ninclude_dirs : [string]\n    List of directories to search for C/C++ header files (in Unix\n    form for portability).\ndefine_macros : [(name : string, value : string|None)]\n    List of macros to define; each macro is defined using a 2-tuple,\n    where 'value' is either the string to define it to or None to\n    define it without a particular value (equivalent of \"#define\n    FOO\" in source or -DFOO on Unix C compiler command line).\nundef_macros : [string]\n    List of macros to undefine explicitly.\nlibrary_dirs : [string]\n    List of directories to search for C/C++ libraries at link time.\nlibraries : [string]\n    List of library names (not filenames or paths) to link against.\nruntime_library_dirs : [string]\n    List of directories to search for C/C++ libraries at run time\n    (for shared extensions, this is when the extension is loaded).\nextra_objects : [string]\n    List of extra files to link with (e.g. object files not implied\n    by 'sources', static libraries that must be explicitly specified,\n    binary resource files, etc.)\nextra_compile_args : [string]\n    Any extra platform- and compiler-specific information to use\n    when compiling the source files in 'sources'.  For platforms and\n    compilers where \"command line\" makes sense, this is typically a\n    list of command-line arguments, but for other platforms it could\n    be anything.\nextra_link_args : [string]\n    Any extra platform- and compiler-specific information to use\n    when linking object files together to create the extension (or\n    to create a new static Python interpreter).  Similar\n    interpretation as for 'extra_compile_args'.\nexport_symbols : [string]\n    List of symbols to be exported from a shared extension.  Not\n    used on all platforms, and not generally necessary for Python\n    extensions, which typically export exactly one symbol: \"init\" +\n    extension_name.\nswig_opts : [string]\n    Any extra options to pass to SWIG if a source file has the .i\n    extension.\ndepends : [string]\n    List of files that the extension depends on.\nlanguage : string\n    Extension language (i.e. \"c\", \"c++\", \"objc\").  Will be detected\n    from the source extensions if not provided.\n\nSee Also\n--------\ndistutils.extension.Extension : Describes additional parameters.", "id": "f19638:m0"}
{"signature": "def arg_declaration_code(self):", "body": "arg_strings = [arg.declaration_code(inline=<NUM_LIT:1>)<EOL>for arg in self.arg_specs]<EOL>return \"<STR_LIT>\".join(arg_strings)<EOL>", "docstring": "Return the declaration code as a string.", "id": "f19638:c0:m3"}
{"signature": "def setup_dict(m):", "body": "import random<EOL>a = range(m)<EOL>d = {}<EOL>for i in range(m):<EOL><INDENT>key = random.choice(a)<EOL>a.remove(key)<EOL>d[key] = key<EOL><DEDENT>return d<EOL>", "docstring": "does insertion order matter?", "id": "f19649:m6"}
{"signature": "def create_array():", "body": "rows, cols, depth = <NUM_LIT:2>, <NUM_LIT:3>, <NUM_LIT:4><EOL>arr = numpy.zeros((rows, cols, depth), '<STR_LIT:i>')<EOL>count = <NUM_LIT:0><EOL>for i in range(rows):<EOL><INDENT>for j in range(cols):<EOL><INDENT>for k in range(depth):<EOL><INDENT>arr[i,j,k] = count<EOL>count += <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>return arr<EOL>", "docstring": "Creates a simple 3D numpy array with unique values at each\n    location in the matrix.", "id": "f19655:m0"}
{"signature": "def pure_inline(arr):", "body": "code = \"\"\"<STR_LIT>\"\"\"<EOL>weave.inline(code, ['<STR_LIT>'])<EOL>", "docstring": "Prints the given 3D array by accessing the raw numpy data and\n    without using blitz converters.\n\n    Notice the following:\n      1. '\\\\n' to escape generating a newline in the C++ code.\n      2. rows, cols = Narr[0], Narr[1].\n      3. Array access using arr[(i*cols + j)*depth + k].", "id": "f19655:m1"}
{"signature": "def check_expr(expr,local_vars,global_vars={}):", "body": "values = {}<EOL>for var,val in global_vars.items():<EOL><INDENT>if isinstance(val, ndarray):<EOL><INDENT>values[var] = dummy_array(val,name=var)<EOL><DEDENT>elif isnumeric(val):<EOL><INDENT>values[var] = val<EOL><DEDENT><DEDENT>for var,val in local_vars.items():<EOL><INDENT>if isinstance(val, ndarray):<EOL><INDENT>values[var] = dummy_array(val,name=var)<EOL><DEDENT>if isnumeric(val):<EOL><INDENT>values[var] = val<EOL><DEDENT><DEDENT>exec(expr,values)<EOL>try:<EOL><INDENT>exec(expr,values)<EOL><DEDENT>except:<EOL><INDENT>try:<EOL><INDENT>eval(expr,values)<EOL><DEDENT>except:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT><DEDENT>return <NUM_LIT:1><EOL>", "docstring": "Currently only checks expressions (not suites).\n        Doesn't check that lhs = rhs. checked by compiled func though", "id": "f19661:m2"}
{"signature": "def binary_op_size(xx,yy):", "body": "x,y = make_same_length(xx,yy)<EOL>res = zeros(len(x))<EOL>for i in range(len(x)):<EOL><INDENT>if x[i] == y[i]:<EOL><INDENT>res[i] = x[i]<EOL><DEDENT>elif x[i] == <NUM_LIT:1>:<EOL><INDENT>res[i] = y[i]<EOL><DEDENT>elif y[i] == <NUM_LIT:1>:<EOL><INDENT>res[i] = x[i]<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>return res<EOL>", "docstring": "This returns the resulting size from operating on xx, and yy\n        with a binary operator.  It accounts for broadcasting, and\n        throws errors if the array sizes are incompatible.", "id": "f19661:m4"}
{"signature": "def int_to_symbol(i):", "body": "try:<EOL><INDENT>return symbol.sym_name[i]<EOL><DEDENT>except KeyError:<EOL><INDENT>return token.tok_name[i]<EOL><DEDENT>", "docstring": "Convert numeric symbol or token to a desriptive name.", "id": "f19662:m1"}
{"signature": "def ast_to_string(ast_seq):", "body": "output = '<STR_LIT>'<EOL>for item in ast_seq:<EOL><INDENT>if isinstance(item, str):<EOL><INDENT>output = output + item<EOL><DEDENT>elif issequence(item):<EOL><INDENT>output = output + ast_to_string(item)<EOL><DEDENT><DEDENT>return output<EOL>", "docstring": "* Traverse an ast tree sequence, printing out all leaf nodes.\n\n         This effectively rebuilds the expression the tree was built\n         from.  I guess its probably missing whitespace.  How bout\n         indent stuff and new lines?  Haven't checked this since we're\n         currently only dealing with simple expressions.\n    *", "id": "f19662:m3"}
{"signature": "def get_module_directory(self):", "body": "return self.module_dir<EOL>", "docstring": "Return the path used to replace the 'MODULE' in searches.", "id": "f19666:c0:m2"}
{"signature": "def __init__(self,user_path_list=None):", "body": "if isinstance(user_path_list, str):<EOL><INDENT>self.user_path_list = [user_path_list]<EOL><DEDENT>elif user_path_list:<EOL><INDENT>self.user_path_list = user_path_list<EOL><DEDENT>else:<EOL><INDENT>self.user_path_list = []<EOL><DEDENT>self.cache = {}<EOL>self.module_dir = None<EOL>self.paths_added = <NUM_LIT:0><EOL>sys.path.append(default_dir())<EOL>", "docstring": "Create a catalog for storing/searching for compiled functions.\n\n            user_path_list contains directories that should be searched\n            first for function catalogs.  They will come before the path\n            entries in the PYTHONCOMPILED environment varilable.", "id": "f19666:c0:m0"}
{"signature": "def find_temp_dir(prefix, tmp_dir=None):", "body": "matches = []<EOL>tmp_dir = tmp_dir or tempfile.gettempdir()<EOL>for tmp_file in os.listdir(tmp_dir):<EOL><INDENT>if tmp_file.startswith(prefix):<EOL><INDENT>matches.append(os.path.join(tmp_dir, tmp_file))<EOL><DEDENT><DEDENT>return matches<EOL>", "docstring": "Find temp dirs in 'tmp_dir' starting with 'prefix", "id": "f19666:m12"}
{"signature": "def is_writable(dir):", "body": "if not os.path.isdir(dir):<EOL><INDENT>return False<EOL><DEDENT>prefix = '<STR_LIT>' % (socket.gethostname(),os.getpid())<EOL>try:<EOL><INDENT>tmp = tempfile.TemporaryFile(prefix=prefix,dir=dir)<EOL><DEDENT>except OSError:<EOL><INDENT>return False<EOL><DEDENT>tmp.close()<EOL>return True<EOL>", "docstring": "Determine whether a given directory is writable in a portable manner.\n\n    Parameters\n    ----------\n    dir : str\n        A string represeting a path to a directory on the filesystem.\n\n    Returns\n    -------\n    res : bool\n        True or False.", "id": "f19666:m3"}
{"signature": "def clear_module_directory(self):", "body": "self.module_dir = None<EOL>", "docstring": "Reset 'MODULE' path to None so that it is ignored in searches.", "id": "f19666:c0:m3"}
{"signature": "def unconfigure_path(self):", "body": "sys.path = sys.path[self.paths_added:]<EOL>self.paths_added = <NUM_LIT:0><EOL>", "docstring": "Restores sys.path to normal after calls to configure_path()\n\n            Remove the previously added paths from sys.path", "id": "f19666:c0:m13"}
{"signature": "def _create_dirs(path):", "body": "try:<EOL><INDENT>os.makedirs(path, mode=<NUM_LIT>)<EOL><DEDENT>except OSError:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "create provided path, ignore errors", "id": "f19666:m5"}
{"signature": "def whoami():", "body": "return os.environ.get(\"<STR_LIT>\") or os.environ.get(\"<STR_LIT>\") or \"<STR_LIT>\"<EOL>", "docstring": "return a string identifying the user.", "id": "f19666:m4"}
{"signature": "def py_intermediate_dir():", "body": "name = \"<STR_LIT>\" % tuple(sys.version_info[:<NUM_LIT:2>])<EOL>return name<EOL>", "docstring": "Name of intermediate dir for current python interpreter:\n<temp dir>/<name>/pythonXY_intermediate/", "id": "f19666:m14"}
{"signature": "def get_functions_fast(self,code):", "body": "return self.cache.get(code,[])<EOL>", "docstring": "Return list of functions for code from the cache.\n\n            Return an empty list if the code entry is not found.", "id": "f19666:c0:m16"}
{"signature": "def BINARY_MULTIPLY(self,pc):", "body": "raise NotImplementedError<EOL>", "docstring": "Implements TOS = TOS1 * TOS.", "id": "f19667:c3:m16"}
{"signature": "def STORE_SLICE_2(self,pc):", "body": "raise NotImplementedError<EOL>", "docstring": "Implements TOS1[:TOS] = TOS2.", "id": "f19667:c3:m44"}
{"signature": "def LOAD_NAME(self,pc,namei):", "body": "raise NotImplementedError<EOL>", "docstring": "Pushes the value associated with co_names[namei] onto the stack.", "id": "f19667:c3:m74"}
{"signature": "def SLICE_0(self,pc):", "body": "raise NotImplementedError<EOL>", "docstring": "Implements TOS = TOS[:].", "id": "f19667:c3:m38"}
{"signature": "def SETUP_EXCEPT(self,pc,delta):", "body": "raise NotImplementedError<EOL>", "docstring": "Pushes a try block from a try-except clause onto the block stack. delta points to the first except block.", "id": "f19667:c3:m89"}
{"signature": "def STORE_FAST(self,pc,var_num):", "body": "raise NotImplementedError<EOL>", "docstring": "Stores TOS into the local co_varnames[var_num].", "id": "f19667:c3:m92"}
{"signature": "def DELETE_NAME(self,pc,namei):", "body": "raise NotImplementedError<EOL>", "docstring": "Implements del name, where namei is the index into co_names attribute of the code object.", "id": "f19667:c3:m66"}
{"signature": "def LOAD_ATTR(self,pc,namei):", "body": "raise NotImplementedError<EOL>", "docstring": "Replaces TOS with getattr(TOS, co_names[namei].", "id": "f19667:c3:m78"}
{"signature": "def DELETE_SLICE_2(self,pc):", "body": "raise NotImplementedError<EOL>", "docstring": "Implements del TOS1[:TOS].", "id": "f19667:c3:m48"}
{"signature": "def IMPORT_FROM(self,pc,namei):", "body": "raise NotImplementedError<EOL>", "docstring": "Loads the attribute co_names[namei] from the module found in TOS. The resulting object is pushed onto the stack, to be subsequently stored by a STORE_FAST instruction.", "id": "f19667:c3:m81"}
{"signature": "def BINARY_POWER(self,pc):", "body": "raise NotImplementedError<EOL>", "docstring": "Implements TOS = TOS1 ** TOS.", "id": "f19667:c3:m15"}
{"signature": "def UNARY_NEGATIVE(self,pc):", "body": "raise NotImplementedError<EOL>", "docstring": "Implements TOS = -TOS.", "id": "f19667:c3:m11"}
{"signature": "def INPLACE_MODULO(self,pc):", "body": "raise NotImplementedError<EOL>", "docstring": "Implements in-place TOS = TOS1 % TOS.", "id": "f19667:c3:m30"}
{"signature": "def DELETE_SUBSCR(self,pc):", "body": "raise NotImplementedError<EOL>", "docstring": "Implements del TOS1[TOS].", "id": "f19667:c3:m51"}
{"signature": "def DELETE_GLOBAL(self,pc,namei):", "body": "raise NotImplementedError<EOL>", "docstring": "Works as DELETE_NAME, but deletes a global name.", "id": "f19667:c3:m72"}
{"signature": "def UNARY_POSITIVE(self,pc):", "body": "raise NotImplementedError<EOL>", "docstring": "Implements TOS = +TOS.", "id": "f19667:c3:m10"}
{"signature": "def POP_TOP(self,pc):", "body": "raise NotImplementedError<EOL>", "docstring": "Removes the top-of-stack (TOS) item.", "id": "f19667:c3:m5"}
{"signature": "def BINARY_SUBSCR(self,pc):", "body": "raise NotImplementedError<EOL>", "docstring": "Implements TOS = TOS1[TOS].", "id": "f19667:c3:m21"}
{"signature": "def BUILD_TUPLE(self,pc,count):", "body": "V = []<EOL>T = []<EOL>for i in range(count):<EOL><INDENT>v,t = self.pop()<EOL>V.append(v)<EOL>T.append(t)<EOL><DEDENT>V.reverse()<EOL>T.reverse()<EOL>self.pushTuple(tuple(V),tuple(T))<EOL>return<EOL>", "docstring": "Creates a tuple consuming count items from the stack, and pushes the resulting tuple onto the stack.", "id": "f19667:c4:m32"}
{"signature": "def opcodize(s):", "body": "length = len(s)<EOL>i = <NUM_LIT:0><EOL>answer = []<EOL>while i < length:<EOL><INDENT>bytecode = ord(s[i])<EOL>name = byOpcode[bytecode]<EOL>if bytecode >= haveArgument:<EOL><INDENT>argument = <NUM_LIT>*ord(s[i+<NUM_LIT:2>])+ord(s[i+<NUM_LIT:1>])<EOL>i += <NUM_LIT:3><EOL><DEDENT>else:<EOL><INDENT>argument = None<EOL>i += <NUM_LIT:1><EOL><DEDENT>answer.append((bytecode,argument,name))<EOL><DEDENT>return answer<EOL>", "docstring": "Slightly more readable form", "id": "f19667:m0"}
{"signature": "def STORE_SUBSCR(self,pc):", "body": "raise NotImplementedError<EOL>", "docstring": "Implements TOS1[TOS] = TOS2.", "id": "f19667:c3:m50"}
{"signature": "def EXTENDED_ARG(self,pc,ext):", "body": "raise NotImplementedError<EOL>", "docstring": "Prefixes any opcode which has an argument too big to fit into the default two bytes. ext holds two additional bytes which, taken together with the subsequent opcode's argument, comprise a four-byte argument, ext being the two most-significant bytes.", "id": "f19667:c3:m103"}
{"signature": "def SET_LINENO(self,pc,lineno):", "body": "raise NotImplementedError<EOL>", "docstring": "Sets the current line number to lineno.", "id": "f19667:c3:m97"}
{"signature": "def BUILD_TUPLE(self,pc,count):", "body": "raise NotImplementedError<EOL>", "docstring": "Creates a tuple consuming count items from the stack, and pushes the resulting tuple onto the stack.", "id": "f19667:c3:m75"}
{"signature": "def CALL_FUNCTION_VAR(self,pc,argc):", "body": "raise NotImplementedError<EOL>", "docstring": "Calls a function. argc is interpreted as in CALL_FUNCTION. The top element on the stack contains the variable argument list, followed by keyword and positional arguments.", "id": "f19667:c3:m104"}
{"signature": "def DELETE_SLICE_3(self,pc):", "body": "raise NotImplementedError<EOL>", "docstring": "Implements del TOS2[TOS1:TOS].", "id": "f19667:c3:m49"}
{"signature": "def BINARY_OR(self,pc):", "body": "raise NotImplementedError<EOL>", "docstring": "Implements TOS = TOS1 | TOS.", "id": "f19667:c3:m26"}
{"signature": "def STORE_SLICE_3(self,pc):", "body": "raise NotImplementedError<EOL>", "docstring": "Implements TOS2[TOS1:TOS] = TOS3.", "id": "f19667:c3:m45"}
{"signature": "def INPLACE_POWER(self,pc):", "body": "raise NotImplementedError<EOL>", "docstring": "Implements in-place TOS = TOS1 ** TOS.", "id": "f19667:c3:m27"}
{"signature": "def BINARY_LSHIFT(self,pc):", "body": "raise NotImplementedError<EOL>", "docstring": "Implements TOS = TOS1 << TOS.", "id": "f19667:c3:m22"}
{"signature": "def DELETE_ATTR(self,pc,namei):", "body": "raise NotImplementedError<EOL>", "docstring": "Implements del TOS.name, using namei as index into co_names.", "id": "f19667:c3:m70"}
{"signature": "def DELETE_SLICE_1(self,pc):", "body": "raise NotImplementedError<EOL>", "docstring": "Implements del TOS1[TOS:].", "id": "f19667:c3:m47"}
{"signature": "def BINARY_AND(self,pc):", "body": "raise NotImplementedError<EOL>", "docstring": "Implements TOS = TOS1 & TOS.", "id": "f19667:c3:m24"}
{"signature": "def INPLACE_ADD(self,pc):", "body": "raise NotImplementedError<EOL>", "docstring": "Implements in-place TOS = TOS1 + TOS.", "id": "f19667:c3:m31"}
{"signature": "def generate_module(module_string, module_file):", "body": "file_changed = <NUM_LIT:1><EOL>if os.path.exists(module_file):<EOL><INDENT>f = open(module_file,'<STR_LIT:r>')<EOL>old_string = f.read()<EOL>f.close()<EOL>if old_string == module_string:<EOL><INDENT>file_changed = <NUM_LIT:0><EOL><DEDENT><DEDENT>if file_changed:<EOL><INDENT>f = open(module_file,'<STR_LIT:w>')<EOL>f.write(module_string)<EOL>f.close()<EOL><DEDENT>return module_file<EOL>", "docstring": "generate the source code file.  Only overwrite\n        the existing file if the actual source has changed.", "id": "f19669:m1"}
{"signature": "def get_n(self):", "body": "return [<NUM_LIT:1000>, <NUM_LIT:100>, <NUM_LIT:10>, <NUM_LIT:5>]<EOL>", "docstring": "Returns list of sample sizes to be used for comparison.", "id": "f19681:c14:m0"}
{"signature": "def expect(self, func=None, args=(), loc=<NUM_LIT:0>, scale=<NUM_LIT:1>, lb=None, ub=None,<EOL>conditional=False, **kwds):", "body": "lockwds = {'<STR_LIT>': loc,<EOL>'<STR_LIT>': scale}<EOL>self._argcheck(*args)<EOL>if func is None:<EOL><INDENT>def fun(x, *args):<EOL><INDENT>return x * self.pdf(x, *args, **lockwds)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>def fun(x, *args):<EOL><INDENT>return func(x) * self.pdf(x, *args, **lockwds)<EOL><DEDENT><DEDENT>if lb is None:<EOL><INDENT>lb = loc + self.a * scale<EOL><DEDENT>if ub is None:<EOL><INDENT>ub = loc + self.b * scale<EOL><DEDENT>if conditional:<EOL><INDENT>invfac = (self.sf(lb, *args, **lockwds)<EOL>- self.sf(ub, *args, **lockwds))<EOL><DEDENT>else:<EOL><INDENT>invfac = <NUM_LIT:1.0><EOL><DEDENT>kwds['<STR_LIT:args>'] = args<EOL>olderr = np.seterr(all='<STR_LIT:ignore>')<EOL>vals = integrate.quad(fun, lb, ub, **kwds)[<NUM_LIT:0>] / invfac<EOL>np.seterr(**olderr)<EOL>return vals<EOL>", "docstring": "Calculate expected value of a function with respect to the\n        distribution.\n\n        The expected value of a function ``f(x)`` with respect to a\n        distribution ``dist`` is defined as::\n\n                    ubound\n            E[x] = Integral(f(x) * dist.pdf(x))\n                    lbound\n\n        Parameters\n        ----------\n        func : callable, optional\n            Function for which integral is calculated. Takes only one argument.\n            The default is the identity mapping f(x) = x.\n        args : tuple, optional\n            Argument (parameters) of the distribution.\n        lb, ub : scalar, optional\n            Lower and upper bound for integration. default is set to the\n            support of the distribution.\n        conditional : bool, optional\n            If True, the integral is corrected by the conditional probability\n            of the integration interval.  The return value is the expectation\n            of the function, conditional on being in the given interval.\n            Default is False.\n\n        Additional keyword arguments are passed to the integration routine.\n\n        Returns\n        -------\n        expect : float\n            The calculated expected value.\n\n        Notes\n        -----\n        The integration behavior of this function is inherited from\n        `integrate.quad`.", "id": "f19688:c2:m30"}
{"signature": "def _construct_default_doc(self, longname=None, extradoc=None):", "body": "if longname is None:<EOL><INDENT>longname = '<STR_LIT:A>'<EOL><DEDENT>if extradoc is None:<EOL><INDENT>extradoc = '<STR_LIT>'<EOL><DEDENT>if extradoc.startswith('<STR_LIT>'):<EOL><INDENT>extradoc = extradoc[<NUM_LIT:2>:]<EOL><DEDENT>self.__doc__ = '<STR_LIT>'.join(['<STR_LIT>' % longname,<EOL>'<STR_LIT>', docheaders['<STR_LIT>'],<EOL>extradoc, '<STR_LIT>'])<EOL>self._construct_doc(docdict)<EOL>", "docstring": "Construct instance docstring from the default template.", "id": "f19688:c2:m1"}
{"signature": "def fit(self, data, *args, **kwds):", "body": "Narg = len(args)<EOL>if Narg > self.numargs:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>start = [None]*<NUM_LIT:2><EOL>if (Narg < self.numargs) or not ('<STR_LIT>' in kwds and<EOL>'<STR_LIT>' in kwds):<EOL><INDENT>start = self._fitstart(data)<EOL>args += start[Narg:-<NUM_LIT:2>]<EOL><DEDENT>loc = kwds.get('<STR_LIT>', start[-<NUM_LIT:2>])<EOL>scale = kwds.get('<STR_LIT>', start[-<NUM_LIT:1>])<EOL>args += (loc, scale)<EOL>x0, func, restore, args = self._reduce_func(args, kwds)<EOL>optimizer = kwds.get('<STR_LIT>', optimize.fmin)<EOL>if not callable(optimizer) and isinstance(optimizer, string_types):<EOL><INDENT>if not optimizer.startswith('<STR_LIT>'):<EOL><INDENT>optimizer = \"<STR_LIT>\"+optimizer<EOL><DEDENT>if optimizer == '<STR_LIT>':<EOL><INDENT>optimizer = '<STR_LIT>'<EOL><DEDENT>try:<EOL><INDENT>optimizer = getattr(optimize, optimizer)<EOL><DEDENT>except AttributeError:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % optimizer)<EOL><DEDENT><DEDENT>vals = optimizer(func, x0, args=(ravel(data),), disp=<NUM_LIT:0>)<EOL>if restore is not None:<EOL><INDENT>vals = restore(args, vals)<EOL><DEDENT>vals = tuple(vals)<EOL>return vals<EOL>", "docstring": "Return MLEs for shape, location, and scale parameters from data.\n\nMLE stands for Maximum Likelihood Estimate.  Starting estimates for\nthe fit are given by input arguments; for any arguments not provided\nwith starting estimates, ``self._fitstart(data)`` is called to generate\nsuch.\n\nOne can hold some parameters fixed to specific values by passing in\nkeyword arguments ``f0``, ``f1``, ..., ``fn`` (for shape parameters)\nand ``floc`` and ``fscale`` (for location and scale parameters,\nrespectively).\n\nParameters\n----------\ndata : array_like\n    Data to use in calculating the MLEs.\nargs : floats, optional\n    Starting value(s) for any shape-characterizing arguments (those not\n    provided will be determined by a call to ``_fitstart(data)``).\n    No default value.\nkwds : floats, optional\n    Starting values for the location and scale parameters; no default.\n    Special keyword arguments are recognized as holding certain\n    parameters fixed:\n\n    f0...fn : hold respective shape parameters fixed.\n\n    floc : hold location parameter fixed to specified value.\n\n    fscale : hold scale parameter fixed to specified value.\n\n    optimizer : The optimizer to use.  The optimizer must take func,\n                and starting position as the first two arguments,\n                plus args (for extra arguments to pass to the\n                function to be optimized) and disp=0 to suppress\n                output as keyword arguments.\n\nReturns\n-------\nshape, loc, scale : tuple of floats\n    MLEs for any shape statistics, followed by those for location and\n    scale.\n\nNotes\n-----\nThis fit is computed by maximizing a log-likelihood function, with\npenalty applied for samples outside of range of the distribution. The\nreturned answer is not guaranteed to be the globally optimal MLE, it\nmay only be locally optimal, or the optimization may fail altogether.", "id": "f19688:c2:m25"}
{"signature": "def logsf(self, x, *args, **kwds):", "body": "args, loc, scale = self._parse_args(*args, **kwds)<EOL>x, loc, scale = map(asarray, (x, loc, scale))<EOL>args = tuple(map(asarray, args))<EOL>x = (x-loc)*<NUM_LIT:1.0>/scale<EOL>cond0 = self._argcheck(*args) & (scale > <NUM_LIT:0>)<EOL>cond1 = (scale > <NUM_LIT:0>) & (x > self.a) & (x < self.b)<EOL>cond2 = cond0 & (x <= self.a)<EOL>cond = cond0 & cond1<EOL>output = empty(shape(cond), '<STR_LIT:d>')<EOL>output.fill(NINF)<EOL>place(output, (<NUM_LIT:1>-cond0)+np.isnan(x), self.badvalue)<EOL>place(output, cond2, <NUM_LIT:0.0>)<EOL>if any(cond):<EOL><INDENT>goodargs = argsreduce(cond, *((x,)+args))<EOL>place(output, cond, self._logsf(*goodargs))<EOL><DEDENT>if output.ndim == <NUM_LIT:0>:<EOL><INDENT>return output[()]<EOL><DEDENT>return output<EOL>", "docstring": "Log of the survival function of the given RV.\n\nReturns the log of the \"survival function,\" defined as (1 - `cdf`),\nevaluated at `x`.\n\nParameters\n----------\nx : array_like\n    quantiles\narg1, arg2, arg3,... : array_like\n    The shape parameter(s) for the distribution (see docstring of the\n    instance object for more information)\nloc : array_like, optional\n    location parameter (default=0)\nscale : array_like, optional\n    scale parameter (default=1)\n\nReturns\n-------\nlogsf : ndarray\n    Log of the survival function evaluated at `x`.", "id": "f19688:c2:m17"}
{"signature": "def logcdf(self, k, *args, **kwds):", "body": "args, loc, _ = self._parse_args(*args, **kwds)<EOL>k, loc = map(asarray, (k, loc))<EOL>args = tuple(map(asarray, args))<EOL>k = asarray((k-loc))<EOL>cond0 = self._argcheck(*args)<EOL>cond1 = (k >= self.a) & (k < self.b)<EOL>cond2 = (k >= self.b)<EOL>cond = cond0 & cond1<EOL>output = empty(shape(cond), '<STR_LIT:d>')<EOL>output.fill(NINF)<EOL>place(output, (<NUM_LIT:1>-cond0) + np.isnan(k), self.badvalue)<EOL>place(output, cond2*(cond0 == cond0), <NUM_LIT:0.0>)<EOL>if any(cond):<EOL><INDENT>goodargs = argsreduce(cond, *((k,)+args))<EOL>place(output, cond, self._logcdf(*goodargs))<EOL><DEDENT>if output.ndim == <NUM_LIT:0>:<EOL><INDENT>return output[()]<EOL><DEDENT>return output<EOL>", "docstring": "Log of the cumulative distribution function at k of the given RV\n\nParameters\n----------\nk : array_like, int\n    Quantiles.\narg1, arg2, arg3,... : array_like\n    The shape parameter(s) for the distribution (see docstring of the\n    instance object for more information).\nloc : array_like, optional\n    Location parameter (default=0).\n\nReturns\n-------\nlogcdf : array_like\n    Log of the cumulative distribution function evaluated at k.", "id": "f19688:c3:m11"}
{"signature": "def fit_loc_scale(self, data, *args):", "body": "mu, mu2 = self.stats(*args, **{'<STR_LIT>': '<STR_LIT>'})<EOL>tmp = asarray(data)<EOL>muhat = tmp.mean()<EOL>mu2hat = tmp.var()<EOL>Shat = sqrt(mu2hat / mu2)<EOL>Lhat = muhat - Shat*mu<EOL>if not np.isfinite(Lhat):<EOL><INDENT>Lhat = <NUM_LIT:0><EOL><DEDENT>if not (np.isfinite(Shat) and (<NUM_LIT:0> < Shat)):<EOL><INDENT>Shat = <NUM_LIT:1><EOL><DEDENT>return Lhat, Shat<EOL>", "docstring": "Estimate loc and scale parameters from data using 1st and 2nd moments.\n\nParameters\n----------\ndata : array_like\n    Data to fit.\narg1, arg2, arg3,... : array_like\n    The shape parameter(s) for the distribution (see docstring of the\n    instance object for more information).\n\nReturns\n-------\nLhat : float\n    Estimated location parameter for the data.\nShat : float\n    Estimated scale parameter for the data.", "id": "f19688:c2:m26"}
{"signature": "def argsreduce(cond, *args):", "body": "newargs = np.atleast_1d(*args)<EOL>if not isinstance(newargs, list):<EOL><INDENT>newargs = [newargs, ]<EOL><DEDENT>expand_arr = (cond == cond)<EOL>return [np.extract(cond, arr1 * expand_arr) for arr1 in newargs]<EOL>", "docstring": "Return the sequence of ravel(args[i]) where ravel(condition) is\n    True in 1D.\n\n    Examples\n    --------\n    >>> import numpy as np\n    >>> rand = np.random.random_sample\n    >>> A = rand((4, 5))\n    >>> B = 2\n    >>> C = rand((1, 5))\n    >>> cond = np.ones(A.shape)\n    >>> [A1, B1, C1] = argsreduce(cond, A, B, C)\n    >>> B1.shape\n    (20,)\n    >>> cond[2,:] = 0\n    >>> [A2, B2, C2] = argsreduce(cond, A, B, C)\n    >>> B2.shape\n    (15,)", "id": "f19688:m6"}
{"signature": "def _lazywhere(cond, arrays, f, fillvalue=None, f2=None):", "body": "if fillvalue is None:<EOL><INDENT>if f2 is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>fillvalue = np.nan<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if f2 is not None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>arrays = np.broadcast_arrays(*arrays)<EOL>temp = tuple(np.extract(cond, arr) for arr in arrays)<EOL>out = valarray(shape(arrays[<NUM_LIT:0>]), value=fillvalue)<EOL>np.place(out, cond, f(*temp))<EOL>if f2 is not None:<EOL><INDENT>temp = tuple(np.extract(~cond, arr) for arr in arrays)<EOL>np.place(out, ~cond, f2(*temp))<EOL><DEDENT>return out<EOL>", "docstring": "np.where(cond, x, fillvalue) always evaluates x even where cond is False.\nThis one only evaluates f(arr1[cond], arr2[cond], ...).\nFor example,\n>>> a, b = np.array([1, 2, 3, 4]), np.array([5, 6, 7, 8])\n>>> def f(a, b):\n    return a*b\n>>> _lazywhere(a > 2, (a, b), f, np.nan)\narray([ nan,  nan,  21.,  32.])\n\nNotice it assumes that all `arrays` are of the same shape, or can be\nbroadcasted together.", "id": "f19688:m5"}
{"signature": "def ppf(self, q, *args, **kwds):", "body": "args, loc, _ = self._parse_args(*args, **kwds)<EOL>q, loc = map(asarray, (q, loc))<EOL>args = tuple(map(asarray, args))<EOL>cond0 = self._argcheck(*args) & (loc == loc)<EOL>cond1 = (q > <NUM_LIT:0>) & (q < <NUM_LIT:1>)<EOL>cond2 = (q == <NUM_LIT:1>) & cond0<EOL>cond = cond0 & cond1<EOL>output = valarray(shape(cond), value=self.badvalue, typecode='<STR_LIT:d>')<EOL>place(output, (q == <NUM_LIT:0>)*(cond == cond), self.a-<NUM_LIT:1>)<EOL>place(output, cond2, self.b)<EOL>if any(cond):<EOL><INDENT>goodargs = argsreduce(cond, *((q,)+args+(loc,)))<EOL>loc, goodargs = goodargs[-<NUM_LIT:1>], goodargs[:-<NUM_LIT:1>]<EOL>place(output, cond, self._ppf(*goodargs) + loc)<EOL><DEDENT>if output.ndim == <NUM_LIT:0>:<EOL><INDENT>return output[()]<EOL><DEDENT>return output<EOL>", "docstring": "Percent point function (inverse of cdf) at q of the given RV\n\nParameters\n----------\nq : array_like\n    Lower tail probability.\narg1, arg2, arg3,... : array_like\n    The shape parameter(s) for the distribution (see docstring of the\n    instance object for more information).\nloc : array_like, optional\n    Location parameter (default=0).\nscale : array_like, optional\n    Scale parameter (default=1).\n\nReturns\n-------\nk : array_like\n    Quantile corresponding to the lower tail probability, q.", "id": "f19688:c3:m14"}
{"signature": "def var(self, *args, **kwds):", "body": "kwds['<STR_LIT>'] = '<STR_LIT:v>'<EOL>res = self.stats(*args, **kwds)<EOL>if isinstance(res, ndarray) and res.ndim == <NUM_LIT:0>:<EOL><INDENT>return res[()]<EOL><DEDENT>return res<EOL>", "docstring": "Variance of the distribution\n\nParameters\n----------\narg1, arg2, arg3,... : array_like\n    The shape parameter(s) for the distribution (see docstring of the\n    instance object for more information)\nloc : array_like, optional\n    location parameter (default=0)\nscale : array_like, optional\n    scale parameter (default=1)\n\nReturns\n-------\nvar : float\n    the variance of the distribution", "id": "f19688:c1:m20"}
{"signature": "def _argcheck(self, *args):", "body": "cond = <NUM_LIT:1><EOL>for arg in args:<EOL><INDENT>cond = logical_and(cond, (asarray(arg) > <NUM_LIT:0>))<EOL><DEDENT>return cond<EOL>", "docstring": "Default check for correct values on args and keywords.\n\n        Returns condition array of 1's where arguments are correct and\n         0's where they are not.", "id": "f19688:c1:m7"}
{"signature": "def _construct_argparser(<EOL>self, meths_to_inspect, locscale_in, locscale_out):", "body": "if self.shapes:<EOL><INDENT>if not isinstance(self.shapes, string_types):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>shapes = self.shapes.replace('<STR_LIT:U+002C>', '<STR_LIT:U+0020>').split()<EOL>for field in shapes:<EOL><INDENT>if keyword.iskeyword(field):<EOL><INDENT>raise SyntaxError('<STR_LIT>')<EOL><DEDENT>if not re.match('<STR_LIT>', field):<EOL><INDENT>raise SyntaxError(<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>shapes_list = []<EOL>for meth in meths_to_inspect:<EOL><INDENT>shapes_args = inspect.getargspec(meth)<EOL>shapes_list.append(shapes_args.args)<EOL>if len(shapes_args.args) > <NUM_LIT:2>:<EOL><INDENT>if shapes_args.varargs is not None:<EOL><INDENT>raise TypeError(<EOL>'<STR_LIT>')<EOL><DEDENT>if shapes_args.keywords is not None:<EOL><INDENT>raise TypeError(<EOL>'<STR_LIT>')<EOL><DEDENT>if shapes_args.defaults is not None:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>shapes = max(shapes_list, key=lambda x: len(x))<EOL>shapes = shapes[<NUM_LIT:2>:]  <EOL>for item in shapes_list:<EOL><INDENT>if len(item) > <NUM_LIT:2> and item[<NUM_LIT:2>:] != shapes:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT><DEDENT><DEDENT>shapes_str = '<STR_LIT:U+002CU+0020>'.join(shapes) + '<STR_LIT:U+002CU+0020>' if shapes else '<STR_LIT>'  <EOL>dct = dict(shape_arg_str=shapes_str,<EOL>locscale_in=locscale_in,<EOL>locscale_out=locscale_out,<EOL>)<EOL>ns = {}<EOL>exec_(parse_arg_template % dct, ns)<EOL>for name in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>setattr(self, name,<EOL>instancemethod(ns[name], self, self.__class__)<EOL>)<EOL><DEDENT>self.shapes = '<STR_LIT:U+002CU+0020>'.join(shapes) if shapes else None<EOL>if not hasattr(self, '<STR_LIT>'):<EOL><INDENT>self.numargs = len(shapes)<EOL><DEDENT>", "docstring": "Construct the parser for the shape arguments.\n\n        Generates the argument-parsing functions dynamically and attaches\n        them to the instance.\n        Is supposed to be called in __init__ of a class for each distribution.\n\n        If self.shapes is a non-empty string, interprets it as a\n        comma-separated list of shape parameters.\n\n        Otherwise inspects the call signatures of `meths_to_inspect`\n        and constructs the argument-parsing functions from these.\n        In this case also sets `shapes` and `numargs`.", "id": "f19688:c1:m1"}
{"signature": "def _construct_default_doc(self, longname=None, extradoc=None):", "body": "if extradoc is None:<EOL><INDENT>extradoc = '<STR_LIT>'<EOL><DEDENT>if extradoc.startswith('<STR_LIT>'):<EOL><INDENT>extradoc = extradoc[<NUM_LIT:2>:]<EOL><DEDENT>self.__doc__ = '<STR_LIT>'.join(['<STR_LIT>' % longname,<EOL>'<STR_LIT>', docheaders['<STR_LIT>'],<EOL>extradoc, '<STR_LIT>'])<EOL>self._construct_doc(docdict_discrete)<EOL>", "docstring": "Construct instance docstring from the rv_discrete template.", "id": "f19688:c3:m1"}
{"signature": "def _construct_doc(self, docdict, shapes_vals=None):", "body": "tempdict = docdict.copy()<EOL>tempdict['<STR_LIT:name>'] = self.name or '<STR_LIT>'<EOL>tempdict['<STR_LIT>'] = self.shapes or '<STR_LIT>'<EOL>if shapes_vals is None:<EOL><INDENT>shapes_vals = ()<EOL><DEDENT>vals = '<STR_LIT:U+002CU+0020>'.join(str(_) for _ in shapes_vals)<EOL>tempdict['<STR_LIT>'] = vals<EOL>if self.shapes:<EOL><INDENT>tempdict['<STR_LIT>'] = '<STR_LIT>' % (self.shapes, vals)<EOL><DEDENT>else:<EOL><INDENT>tempdict['<STR_LIT>'] = '<STR_LIT>'<EOL><DEDENT>if self.shapes is None:<EOL><INDENT>for item in ['<STR_LIT>', '<STR_LIT:default>', '<STR_LIT>']:<EOL><INDENT>tempdict[item] = tempdict[item].replace(<EOL>\"<STR_LIT>\", \"<STR_LIT>\")<EOL><DEDENT><DEDENT>for i in range(<NUM_LIT:2>):<EOL><INDENT>if self.shapes is None:<EOL><INDENT>self.__doc__ = self.__doc__.replace(\"<STR_LIT>\", \"<STR_LIT>\")<EOL><DEDENT>self.__doc__ = doccer.docformat(self.__doc__, tempdict)<EOL><DEDENT>self.__doc__ = self.__doc__.replace('<STR_LIT>', '<STR_LIT:(>').replace('<STR_LIT>', '<STR_LIT:)>')<EOL>", "docstring": "Construct the instance docstring with string substitutions.", "id": "f19688:c1:m2"}
{"signature": "def entropy(pk, qk=None, base=None):", "body": "pk = asarray(pk)<EOL>pk = <NUM_LIT:1.0>*pk / sum(pk, axis=<NUM_LIT:0>)<EOL>if qk is None:<EOL><INDENT>vec = entr(pk)<EOL><DEDENT>else:<EOL><INDENT>qk = asarray(qk)<EOL>if len(qk) != len(pk):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>qk = <NUM_LIT:1.0>*qk / sum(qk, axis=<NUM_LIT:0>)<EOL>vec = kl_div(pk, qk)<EOL><DEDENT>S = sum(vec, axis=<NUM_LIT:0>)<EOL>if base is not None:<EOL><INDENT>S /= log(base)<EOL><DEDENT>return S<EOL>", "docstring": "Calculate the entropy of a distribution for given probability values.\n\n    If only probabilities `pk` are given, the entropy is calculated as\n    ``S = -sum(pk * log(pk), axis=0)``.\n\n    If `qk` is not None, then compute the Kullback-Leibler divergence\n    ``S = sum(pk * log(pk / qk), axis=0)``.\n\n    This routine will normalize `pk` and `qk` if they don't sum to 1.\n\n    Parameters\n    ----------\n    pk : sequence\n        Defines the (discrete) distribution. ``pk[i]`` is the (possibly\n        unnormalized) probability of event ``i``.\n    qk : sequence, optional\n        Sequence against which the relative entropy is computed. Should be in\n        the same format as `pk`.\n    base : float, optional\n        The logarithmic base to use, defaults to ``e`` (natural logarithm).\n\n    Returns\n    -------\n    S : float\n        The calculated entropy.", "id": "f19688:m18"}
{"signature": "def sf(self, k, *args, **kwds):", "body": "args, loc, _ = self._parse_args(*args, **kwds)<EOL>k, loc = map(asarray, (k, loc))<EOL>args = tuple(map(asarray, args))<EOL>k = asarray(k-loc)<EOL>cond0 = self._argcheck(*args)<EOL>cond1 = (k >= self.a) & (k <= self.b)<EOL>cond2 = (k < self.a) & cond0<EOL>cond = cond0 & cond1<EOL>output = zeros(shape(cond), '<STR_LIT:d>')<EOL>place(output, (<NUM_LIT:1>-cond0) + np.isnan(k), self.badvalue)<EOL>place(output, cond2, <NUM_LIT:1.0>)<EOL>if any(cond):<EOL><INDENT>goodargs = argsreduce(cond, *((k,)+args))<EOL>place(output, cond, np.clip(self._sf(*goodargs), <NUM_LIT:0>, <NUM_LIT:1>))<EOL><DEDENT>if output.ndim == <NUM_LIT:0>:<EOL><INDENT>return output[()]<EOL><DEDENT>return output<EOL>", "docstring": "Survival function (1-cdf) at k of the given RV.\n\nParameters\n----------\nk : array_like\n    Quantiles.\narg1, arg2, arg3,... : array_like\n    The shape parameter(s) for the distribution (see docstring of the\n    instance object for more information).\nloc : array_like, optional\n    Location parameter (default=0).\n\nReturns\n-------\nsf : array_like\n    Survival function evaluated at k.", "id": "f19688:c3:m12"}
{"signature": "@np.deprecate<EOL><INDENT>def est_loc_scale(self, data, *args):<DEDENT>", "body": "return self.fit_loc_scale(data, *args)<EOL>", "docstring": "This function is deprecated, use self.fit_loc_scale(data) instead.", "id": "f19688:c2:m27"}
{"signature": "def logpmf(self, k, *args, **kwds):", "body": "args, loc, _ = self._parse_args(*args, **kwds)<EOL>k, loc = map(asarray, (k, loc))<EOL>args = tuple(map(asarray, args))<EOL>k = asarray((k-loc))<EOL>cond0 = self._argcheck(*args)<EOL>cond1 = (k >= self.a) & (k <= self.b) & self._nonzero(k, *args)<EOL>cond = cond0 & cond1<EOL>output = empty(shape(cond), '<STR_LIT:d>')<EOL>output.fill(NINF)<EOL>place(output, (<NUM_LIT:1>-cond0) + np.isnan(k), self.badvalue)<EOL>if any(cond):<EOL><INDENT>goodargs = argsreduce(cond, *((k,)+args))<EOL>place(output, cond, self._logpmf(*goodargs))<EOL><DEDENT>if output.ndim == <NUM_LIT:0>:<EOL><INDENT>return output[()]<EOL><DEDENT>return output<EOL>", "docstring": "Log of the probability mass function at k of the given RV.\n\nParameters\n----------\nk : array_like\n    Quantiles.\narg1, arg2, arg3,... : array_like\n    The shape parameter(s) for the distribution (see docstring of the\n    instance object for more information).\nloc : array_like, optional\n    Location parameter. Default is 0.\n\nReturns\n-------\nlogpmf : array_like\n    Log of the probability mass function evaluated at k.", "id": "f19688:c3:m9"}
{"signature": "def mean(self, alpha):", "body": "alpha = _dirichlet_check_parameters(alpha)<EOL>out = alpha / (np.sum(alpha))<EOL>return _squeeze_output(out)<EOL>", "docstring": "Compute the mean of the dirichlet distribution.\n\nParameters\n----------\n%(_dirichlet_doc_default_callparams)s\n\nReturns\n-------\nmu : scalar\n    Mean of the Dirichlet distribution", "id": "f19694:c3:m5"}
{"signature": "def _process_quantiles(x, dim):", "body": "x = np.asarray(x, dtype=float)<EOL>if x.ndim == <NUM_LIT:0>:<EOL><INDENT>x = x[np.newaxis]<EOL><DEDENT>elif x.ndim == <NUM_LIT:1>:<EOL><INDENT>if dim == <NUM_LIT:1>:<EOL><INDENT>x = x[:, np.newaxis]<EOL><DEDENT>else:<EOL><INDENT>x = x[np.newaxis, :]<EOL><DEDENT><DEDENT>return x<EOL>", "docstring": "Adjust quantiles array so that last axis labels the components of\neach data point.", "id": "f19694:m1"}
{"signature": "def _lnB(alpha):", "body": "return np.sum(gammaln(alpha)) - gammaln(np.sum(alpha))<EOL>", "docstring": "r\"\"\"\n    Internal helper function to compute the log of the useful quotient\n\n    .. math::\n        B(\\alpha) = \\frac{\\prod_{i=1}{K}\\Gamma(\\alpha_i)}{\\Gamma\\left(\\sum_{i=1}^{K}\\alpha_i\\right)}\n\n    Parameters\n    ----------\n    %(_dirichlet_doc_default_callparams)s\n\n    Returns\n    -------\n    B : scalar\n        Helper quotient, internal use only", "id": "f19694:m7"}
{"signature": "def rvs(self, alpha, size=<NUM_LIT:1>):", "body": "alpha = _dirichlet_check_parameters(alpha)<EOL>return np.random.dirichlet(alpha, size=size)<EOL>", "docstring": "Draw random samples from a Dirichlet distribution.\n\nParameters\n----------\n%(_dirichlet_doc_default_callparams)s\nsize : integer, optional\n    Number of samples to draw (default 1).\n\n\nReturns\n-------\nrvs : ndarray or scalar\n    Random variates of size (`size`, `N`), where `N` is the\n    dimension of the random variable.", "id": "f19694:c3:m8"}
{"signature": "def _logpdf(self, x, mean, prec_U, log_det_cov, rank):", "body": "dev = x - mean<EOL>maha = np.sum(np.square(np.dot(dev, prec_U)), axis=-<NUM_LIT:1>)<EOL>return -<NUM_LIT:0.5> * (rank * _LOG_2PI + log_det_cov + maha)<EOL>", "docstring": "Parameters\n----------\nx : ndarray\n    Points at which to evaluate the log of the probability\n    density function\nmean : ndarray\n    Mean of the distribution\nprec_U : ndarray\n    A decomposition such that np.dot(prec_U, prec_U.T)\n    is the precision matrix, i.e. inverse of the covariance matrix.\nlog_det_cov : float\n    Logarithm of the determinant of the covariance matrix\nrank : int\n    Rank of the covariance matrix.\n\nNotes\n-----\nAs this function does no argument checking, it should not be\ncalled directly; use 'logpdf' instead.", "id": "f19694:c1:m2"}
{"signature": "def rvs(self, mean=None, cov=<NUM_LIT:1>, size=<NUM_LIT:1>):", "body": "dim, mean, cov = _process_parameters(None, mean, cov)<EOL>out = np.random.multivariate_normal(mean, cov, size)<EOL>return _squeeze_output(out)<EOL>", "docstring": "Draw random samples from a multivariate normal distribution.\n\nParameters\n----------\n%(_doc_default_callparams)s\nsize : integer, optional\n    Number of samples to draw (default 1).\n\nNotes\n-----\n%(_doc_callparams_note)s\n\nReturns\n-------\nrvs : ndarray or scalar\n    Random variates of size (`size`, `N`), where `N` is the\n    dimension of the random variable.", "id": "f19694:c1:m5"}
{"signature": "def mvsdist(data):", "body": "x = ravel(data)<EOL>n = len(x)<EOL>if (n < <NUM_LIT:2>):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>xbar = x.mean()<EOL>C = x.var()<EOL>if (n > <NUM_LIT:1000>):  <EOL><INDENT>mdist = distributions.norm(loc=xbar, scale=math.sqrt(C/n))<EOL>sdist = distributions.norm(loc=math.sqrt(C), scale=math.sqrt(C/(<NUM_LIT>*n)))<EOL>vdist = distributions.norm(loc=C, scale=math.sqrt(<NUM_LIT>/n)*C)<EOL><DEDENT>else:<EOL><INDENT>nm1 = n-<NUM_LIT:1><EOL>fac = n*C/<NUM_LIT><EOL>val = nm1/<NUM_LIT><EOL>mdist = distributions.t(nm1,loc=xbar,scale=math.sqrt(C/nm1))<EOL>sdist = distributions.gengamma(val,-<NUM_LIT:2>,scale=math.sqrt(fac))<EOL>vdist = distributions.invgamma(val,scale=fac)<EOL><DEDENT>return mdist, vdist, sdist<EOL>", "docstring": "'Frozen' distributions for mean, variance, and standard deviation of data.\n\nParameters\n----------\ndata : array_like\n    Input array. Converted to 1-D using ravel.\n    Requires 2 or more data-points.\n\nReturns\n-------\nmdist : \"frozen\" distribution object\n    Distribution object representing the mean of the data\nvdist : \"frozen\" distribution object\n    Distribution object representing the variance of the data\nsdist : \"frozen\" distribution object\n    Distribution object representing the standard deviation of the data\n\nNotes\n-----\nThe return values from bayes_mvs(data) is equivalent to\n``tuple((x.mean(), x.interval(0.90)) for x in mvsdist(data))``.\n\nIn other words, calling ``<dist>.mean()`` and ``<dist>.interval(0.90)``\non the three distribution objects returned from this function will give\nthe same results that are returned from `bayes_mvs`.\n\nExamples\n--------\n>>> from scipy.stats import mvsdist\n>>> data = [6, 9, 12, 7, 8, 8, 13]\n>>> mean, var, std = mvsdist(data)\n\nWe now have frozen distribution objects \"mean\", \"var\" and \"std\" that we can\nexamine:\n\n>>> mean.mean()\n9.0\n>>> mean.interval(0.95)\n(6.6120585482655692, 11.387941451734431)\n>>> mean.std()\n1.1952286093343936", "id": "f19695:m1"}
{"signature": "def ppcc_max(x, brack=(<NUM_LIT:0.0>,<NUM_LIT:1.0>), dist='<STR_LIT>'):", "body": "dist = _parse_dist_kw(dist)<EOL>osm_uniform = _calc_uniform_order_statistic_medians(x)<EOL>osr = sort(x)<EOL>def tempfunc(shape, mi, yvals, func):<EOL><INDENT>xvals = func(mi, shape)<EOL>r, prob = stats.pearsonr(xvals, yvals)<EOL>return <NUM_LIT:1>-r<EOL><DEDENT>return optimize.brent(tempfunc, brack=brack, args=(osm_uniform, osr, dist.ppf))<EOL>", "docstring": "Returns the shape parameter that maximizes the probability plot\n    correlation coefficient for the given data to a one-parameter\n    family of distributions.\n\n    See also ppcc_plot", "id": "f19695:m7"}
{"signature": "def wilcoxon(x, y=None, zero_method=\"<STR_LIT>\", correction=False):", "body": "if zero_method not in [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if y is None:<EOL><INDENT>d = x<EOL><DEDENT>else:<EOL><INDENT>x, y = map(asarray, (x, y))<EOL>if len(x) != len(y):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>d = x-y<EOL><DEDENT>if zero_method == \"<STR_LIT>\":<EOL><INDENT>d = compress(not_equal(d, <NUM_LIT:0>), d, axis=-<NUM_LIT:1>)  <EOL><DEDENT>count = len(d)<EOL>if (count < <NUM_LIT:10>):<EOL><INDENT>warnings.warn(\"<STR_LIT>\")<EOL><DEDENT>r = stats.rankdata(abs(d))<EOL>r_plus = sum((d > <NUM_LIT:0>) * r, axis=<NUM_LIT:0>)<EOL>r_minus = sum((d < <NUM_LIT:0>) * r, axis=<NUM_LIT:0>)<EOL>if zero_method == \"<STR_LIT>\":<EOL><INDENT>r_zero = sum((d == <NUM_LIT:0>) * r, axis=<NUM_LIT:0>)<EOL>r_plus += r_zero / <NUM_LIT><EOL>r_minus += r_zero / <NUM_LIT><EOL><DEDENT>T = min(r_plus, r_minus)<EOL>mn = count*(count + <NUM_LIT:1.>) * <NUM_LIT><EOL>se = count*(count + <NUM_LIT:1.>) * (<NUM_LIT> * count + <NUM_LIT:1.>)<EOL>if zero_method == \"<STR_LIT>\":<EOL><INDENT>r = r[d != <NUM_LIT:0>]<EOL><DEDENT>replist, repnum = find_repeats(r)<EOL>if repnum.size != <NUM_LIT:0>:<EOL><INDENT>se -= <NUM_LIT:0.5> * (repnum * (repnum * repnum - <NUM_LIT:1>)).sum()<EOL><DEDENT>se = sqrt(se / <NUM_LIT>)<EOL>correction = <NUM_LIT:0.5> * int(bool(correction)) * np.sign(T - mn)<EOL>z = (T - mn - correction) / se<EOL>prob = <NUM_LIT> * distributions.norm.sf(abs(z))<EOL>return T, prob<EOL>", "docstring": "Calculate the Wilcoxon signed-rank test.\n\nThe Wilcoxon signed-rank test tests the null hypothesis that two\nrelated paired samples come from the same distribution. In particular,\nit tests whether the distribution of the differences x - y is symmetric\nabout zero. It is a non-parametric version of the paired T-test.\n\nParameters\n----------\nx : array_like\n    The first set of measurements.\ny : array_like, optional\n    The second set of measurements.  If `y` is not given, then the `x`\n    array is considered to be the differences between the two sets of\n    measurements.\nzero_method : string, {\"pratt\", \"wilcox\", \"zsplit\"}, optional\n    \"pratt\":\n        Pratt treatment: includes zero-differences in the ranking process\n        (more conservative)\n    \"wilcox\":\n        Wilcox treatment: discards all zero-differences\n    \"zsplit\":\n        Zero rank split: just like Pratt, but spliting the zero rank\n        between positive and negative ones\ncorrection : bool, optional\n    If True, apply continuity correction by adjusting the Wilcoxon rank\n    statistic by 0.5 towards the mean value when computing the\n    z-statistic.  Default is False.\n\nReturns\n-------\nT : float\n    The sum of the ranks of the differences above or below zero, whichever\n    is smaller.\np-value : float\n    The two-sided p-value for the test.\n\nNotes\n-----\nBecause the normal approximation is used for the calculations, the\nsamples used should be large.  A typical rule is to require that\nn > 20.\n\nReferences\n----------\n.. [1] http://en.wikipedia.org/wiki/Wilcoxon_signed-rank_test", "id": "f19695:m26"}
{"signature": "def _anderson_ksamp_right(samples, Z, Zstar, k, n, N):", "body": "A2kN = <NUM_LIT:0.><EOL>lj = Z.searchsorted(Zstar[:-<NUM_LIT:1>], '<STR_LIT:right>') - Z.searchsorted(Zstar[:-<NUM_LIT:1>],<EOL>'<STR_LIT:left>')<EOL>Bj = lj.cumsum()<EOL>for i in arange(<NUM_LIT:0>, k):<EOL><INDENT>s = np.sort(samples[i])<EOL>Mij = s.searchsorted(Zstar[:-<NUM_LIT:1>], side='<STR_LIT:right>')<EOL>inner = lj / float(N) * (N * Mij - Bj * n[i])**<NUM_LIT:2> / (Bj * (N - Bj))<EOL>A2kN += inner.sum() / n[i]<EOL><DEDENT>return A2kN<EOL>", "docstring": "Compute A2akN equation 6 of Scholz & Stephens.\n\nParameters\n----------\nsamples : sequence of 1-D array_like\n    Array of sample arrays.\nZ : array_like\n    Sorted array of all observations.\nZstar : array_like\n    Sorted array of unique observations.\nk : int\n    Number of samples.\nn : array_like\n    Number of observations in each sample.\nN : int\n    Total number of observations.\n\nReturns\n-------\nA2KN : float\n    The A2KN statistics of Scholz and Stephens 1987.", "id": "f19695:m17"}
{"signature": "def circvar(samples, high=<NUM_LIT:2>*pi, low=<NUM_LIT:0>, axis=None):", "body": "samples, ang = _circfuncs_common(samples, high, low)<EOL>res = np.mean(exp(<NUM_LIT>*ang), axis=axis)<EOL>R = abs(res)<EOL>return ((high-low)/<NUM_LIT>/pi)**<NUM_LIT:2> * <NUM_LIT:2> * log(<NUM_LIT:1>/R)<EOL>", "docstring": "Compute the circular variance for samples assumed to be in a range\n\nParameters\n----------\nsamples : array_like\n    Input array.\nlow : float or int, optional\n    Low boundary for circular variance range.  Default is 0.\nhigh : float or int, optional\n    High boundary for circular variance range.  Default is ``2*pi``.\naxis : int, optional\n    Axis along which variances are computed.  The default is to compute\n    the variance of the flattened array.\n\nReturns\n-------\ncircvar : float\n    Circular variance.\n\nNotes\n-----\nThis uses a definition of circular variance that in the limit of small\nangles returns a number close to the 'linear' variance.", "id": "f19695:m32"}
{"signature": "def bartlett(*args):", "body": "k = len(args)<EOL>if k < <NUM_LIT:2>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>Ni = zeros(k)<EOL>ssq = zeros(k,'<STR_LIT:d>')<EOL>for j in range(k):<EOL><INDENT>Ni[j] = len(args[j])<EOL>ssq[j] = np.var(args[j], ddof=<NUM_LIT:1>)<EOL><DEDENT>Ntot = sum(Ni,axis=<NUM_LIT:0>)<EOL>spsq = sum((Ni-<NUM_LIT:1>)*ssq,axis=<NUM_LIT:0>)/(<NUM_LIT:1.0>*(Ntot-k))<EOL>numer = (Ntot*<NUM_LIT:1.0>-k)*log(spsq) - sum((Ni-<NUM_LIT:1.0>)*log(ssq),axis=<NUM_LIT:0>)<EOL>denom = <NUM_LIT:1.0> + (<NUM_LIT:1.0>/(<NUM_LIT:3>*(k-<NUM_LIT:1>)))*((sum(<NUM_LIT:1.0>/(Ni-<NUM_LIT:1.0>),axis=<NUM_LIT:0>))-<NUM_LIT:1.0>/(Ntot-k))<EOL>T = numer / denom<EOL>pval = distributions.chi2.sf(T,k-<NUM_LIT:1>)  <EOL>return T, pval<EOL>", "docstring": "Perform Bartlett's test for equal variances\n\nBartlett's test tests the null hypothesis that all input samples\nare from populations with equal variances.  For samples\nfrom significantly non-normal populations, Levene's test\n`levene` is more robust.\n\nParameters\n----------\nsample1, sample2,... : array_like\n    arrays of sample data.  May be different lengths.\n\nReturns\n-------\nT : float\n    The test statistic.\np-value : float\n    The p-value of the test.\n\nReferences\n----------\n.. [1]  http://www.itl.nist.gov/div898/handbook/eda/section3/eda357.htm\n\n.. [2]  Snedecor, George W. and Cochran, William G. (1989), Statistical\n          Methods, Eighth Edition, Iowa State University Press.", "id": "f19695:m20"}
{"signature": "def integrate_box_1d(self, low, high):", "body": "if self.d != <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>stdev = ravel(sqrt(self.covariance))[<NUM_LIT:0>]<EOL>normalized_low = ravel((low - self.dataset) / stdev)<EOL>normalized_high = ravel((high - self.dataset) / stdev)<EOL>value = np.mean(special.ndtr(normalized_high) -<EOL>special.ndtr(normalized_low))<EOL>return value<EOL>", "docstring": "Computes the integral of a 1D pdf between two bounds.\n\nParameters\n----------\nlow : scalar\n    Lower bound of integration.\nhigh : scalar\n    Upper bound of integration.\n\nReturns\n-------\nvalue : scalar\n    The result of the integral.\n\nRaises\n------\nValueError\n    If the KDE is over more than one dimension.", "id": "f19696:c0:m3"}
{"signature": "def set_bandwidth(self, bw_method=None):", "body": "if bw_method is None:<EOL><INDENT>pass<EOL><DEDENT>elif bw_method == '<STR_LIT>':<EOL><INDENT>self.covariance_factor = self.scotts_factor<EOL><DEDENT>elif bw_method == '<STR_LIT>':<EOL><INDENT>self.covariance_factor = self.silverman_factor<EOL><DEDENT>elif np.isscalar(bw_method) and not isinstance(bw_method, string_types):<EOL><INDENT>self._bw_method = '<STR_LIT>'<EOL>self.covariance_factor = lambda: bw_method<EOL><DEDENT>elif callable(bw_method):<EOL><INDENT>self._bw_method = bw_method<EOL>self.covariance_factor = lambda: self._bw_method(self)<EOL><DEDENT>else:<EOL><INDENT>msg = \"<STR_LIT>\"\"<STR_LIT>\"<EOL>raise ValueError(msg)<EOL><DEDENT>self._compute_covariance()<EOL>", "docstring": "Compute the estimator bandwidth with given method.\n\n        The new bandwidth calculated after a call to `set_bandwidth` is used\n        for subsequent evaluations of the estimated density.\n\n        Parameters\n        ----------\n        bw_method : str, scalar or callable, optional\n            The method used to calculate the estimator bandwidth.  This can be\n            'scott', 'silverman', a scalar constant or a callable.  If a\n            scalar, this will be used directly as `kde.factor`.  If a callable,\n            it should take a `gaussian_kde` instance as only parameter and\n            return a scalar.  If None (default), nothing happens; the current\n            `kde.covariance_factor` method is kept.\n\n        Notes\n        -----\n        .. versionadded:: 0.11\n\n        Examples\n        --------\n        >>> x1 = np.array([-7, -5, 1, 4, 5.])\n        >>> kde = stats.gaussian_kde(x1)\n        >>> xs = np.linspace(-10, 10, num=50)\n        >>> y1 = kde(xs)\n        >>> kde.set_bandwidth(bw_method='silverman')\n        >>> y2 = kde(xs)\n        >>> kde.set_bandwidth(bw_method=kde.factor / 3.)\n        >>> y3 = kde(xs)\n\n        >>> fig = plt.figure()\n        >>> ax = fig.add_subplot(111)\n        >>> ax.plot(x1, np.ones(x1.shape) / (4. * x1.size), 'bo',\n        ...         label='Data points (rescaled)')\n        >>> ax.plot(xs, y1, label='Scott (default)')\n        >>> ax.plot(xs, y2, label='Silverman')\n        >>> ax.plot(xs, y3, label='Const (1/3 * Silverman)')\n        >>> ax.legend()\n        >>> plt.show()", "id": "f19696:c0:m9"}
{"signature": "def integrate_kde(self, other):", "body": "if other.d != self.d:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if other.n < self.n:<EOL><INDENT>small = other<EOL>large = self<EOL><DEDENT>else:<EOL><INDENT>small = self<EOL>large = other<EOL><DEDENT>sum_cov = small.covariance + large.covariance<EOL>sum_cov_chol = linalg.cho_factor(sum_cov)<EOL>result = <NUM_LIT:0.0><EOL>for i in range(small.n):<EOL><INDENT>mean = small.dataset[:, i, newaxis]<EOL>diff = large.dataset - mean<EOL>tdiff = linalg.cho_solve(sum_cov_chol, diff)<EOL>energies = sum(diff * tdiff, axis=<NUM_LIT:0>) / <NUM_LIT><EOL>result += sum(exp(-energies), axis=<NUM_LIT:0>)<EOL><DEDENT>result /= sqrt(linalg.det(<NUM_LIT:2> * pi * sum_cov)) * large.n * small.n<EOL>return result<EOL>", "docstring": "Computes the integral of the product of this  kernel density estimate\nwith another.\n\nParameters\n----------\nother : gaussian_kde instance\n    The other kde.\n\nReturns\n-------\nvalue : scalar\n    The result of the integral.\n\nRaises\n------\nValueError\n    If the KDEs have different dimensionality.", "id": "f19696:c0:m5"}
{"signature": "def resample(self, size=None):", "body": "if size is None:<EOL><INDENT>size = self.n<EOL><DEDENT>norm = transpose(multivariate_normal(zeros((self.d,), float),<EOL>self.covariance, size=size))<EOL>indices = randint(<NUM_LIT:0>, self.n, size=size)<EOL>means = self.dataset[:, indices]<EOL>return means + norm<EOL>", "docstring": "Randomly sample a dataset from the estimated pdf.\n\nParameters\n----------\nsize : int, optional\n    The number of samples to draw.  If not provided, then the size is\n    the same as the underlying dataset.\n\nReturns\n-------\nresample : (self.d, `size`) ndarray\n    The sampled dataset.", "id": "f19696:c0:m6"}
{"signature": "def f_value_multivariate(ER, EF, dfnum, dfden):", "body": "if isinstance(ER, (int, float)):<EOL><INDENT>ER = array([[ER]])<EOL><DEDENT>if isinstance(EF, (int, float)):<EOL><INDENT>EF = array([[EF]])<EOL><DEDENT>n_um = (linalg.det(ER) - linalg.det(EF)) / float(dfnum)<EOL>d_en = linalg.det(EF) / float(dfden)<EOL>return n_um / d_en<EOL>", "docstring": "Returns a multivariate F-statistic.\n\nParameters\n----------\nER : ndarray\n    Error associated with the null hypothesis (the Restricted model).\n    From a multivariate F calculation.\nEF : ndarray\n    Error associated with the alternate hypothesis (the Full model)\n    From a multivariate F calculation.\ndfnum : int\n    Degrees of freedom the Restricted model.\ndfden : int\n    Degrees of freedom associated with the Restricted model.\n\nReturns\n-------\nfstat : float\n    The computed F-statistic.", "id": "f19697:m71"}
{"signature": "def itemfreq(a):", "body": "items, inv = np.unique(a, return_inverse=True)<EOL>freq = np.bincount(inv)<EOL>return np.array([items, freq]).T<EOL>", "docstring": "Returns a 2-D array of item frequencies.\n\nParameters\n----------\na : (N,) array_like\n    Input array.\n\nReturns\n-------\nitemfreq : (K, 2) ndarray\n    A 2-D frequency table.  Column 1 contains sorted, unique values from\n    `a`, column 2 contains their respective counts.\n\nExamples\n--------\n>>> a = np.array([1, 1, 5, 0, 1, 2, 2, 0, 1, 4])\n>>> stats.itemfreq(a)\narray([[ 0.,  2.],\n       [ 1.,  4.],\n       [ 2.,  2.],\n       [ 4.,  1.],\n       [ 5.,  1.]])\n>>> np.bincount(a)\narray([2, 4, 2, 0, 1, 1])\n\n>>> stats.itemfreq(a/10.)\narray([[ 0. ,  2. ],\n       [ 0.1,  4. ],\n       [ 0.2,  2. ],\n       [ 0.4,  1. ],\n       [ 0.5,  1. ]])", "id": "f19697:m27"}
{"signature": "def zmap(scores, compare, axis=<NUM_LIT:0>, ddof=<NUM_LIT:0>):", "body": "scores, compare = map(np.asanyarray, [scores, compare])<EOL>mns = compare.mean(axis=axis)<EOL>sstd = compare.std(axis=axis, ddof=ddof)<EOL>if axis and mns.ndim < compare.ndim:<EOL><INDENT>return ((scores - np.expand_dims(mns, axis=axis)) /<EOL>np.expand_dims(sstd,axis=axis))<EOL><DEDENT>else:<EOL><INDENT>return (scores - mns) / sstd<EOL><DEDENT>", "docstring": "Calculates the relative z-scores.\n\nReturns an array of z-scores, i.e., scores that are standardized to zero\nmean and unit variance, where mean and variance are calculated from the\ncomparison array.\n\nParameters\n----------\nscores : array_like\n    The input for which z-scores are calculated.\ncompare : array_like\n    The input from which the mean and standard deviation of the\n    normalization are taken; assumed to have the same dimension as\n    `scores`.\naxis : int or None, optional\n    Axis over which mean and variance of `compare` are calculated.\n    Default is 0.\nddof : int, optional\n    Degrees of freedom correction in the calculation of the\n    standard deviation. Default is 0.\n\nReturns\n-------\nzscore : array_like\n    Z-scores, in the same shape as `scores`.\n\nNotes\n-----\nThis function preserves ndarray subclasses, and works also with\nmatrices and masked arrays (it uses `asanyarray` instead of `asarray`\nfor parameters).\n\nExamples\n--------\n>>> a = [0.5, 2.0, 2.5, 3]\n>>> b = [0, 1, 2, 3, 4]\n>>> zmap(a, b)\narray([-1.06066017,  0.        ,  0.35355339,  0.70710678])", "id": "f19697:m39"}
{"signature": "def tvar(a, limits=None, inclusive=(True, True)):", "body": "a = asarray(a)<EOL>a = a.astype(float).ravel()<EOL>if limits is None:<EOL><INDENT>n = len(a)<EOL>return a.var()*(n/(n-<NUM_LIT:1.>))<EOL><DEDENT>am = mask_to_limits(a, limits, inclusive)<EOL>return masked_var(am)<EOL>", "docstring": "Compute the trimmed variance\n\nThis function computes the sample variance of an array of values,\nwhile ignoring values which are outside of given `limits`.\n\nParameters\n----------\na : array_like\n    Array of values.\nlimits : None or (lower limit, upper limit), optional\n    Values in the input array less than the lower limit or greater than the\n    upper limit will be ignored. When limits is None, then all values are\n    used. Either of the limit values in the tuple can also be None\n    representing a half-open interval.  The default value is None.\ninclusive : (bool, bool), optional\n    A tuple consisting of the (lower flag, upper flag).  These flags\n    determine whether values exactly equal to the lower or upper limits\n    are included.  The default value is (True, True).\n\nReturns\n-------\ntvar : float\n    Trimmed variance.\n\nNotes\n-----\n`tvar` computes the unbiased sample variance, i.e. it uses a correction\nfactor ``n / (n - 1)``.", "id": "f19697:m13"}
{"signature": "def ss(a, axis=<NUM_LIT:0>):", "body": "a, axis = _chk_asarray(a, axis)<EOL>return np.sum(a*a, axis)<EOL>", "docstring": "Squares each element of the input array, and returns the sum(s) of that.\n\nParameters\n----------\na : array_like\n    Input array.\naxis : int or None, optional\n    The axis along which to calculate. If None, use whole array.\n    Default is 0, i.e. along the first axis.\n\nReturns\n-------\nss : ndarray\n    The sum along the given axis for (a**2).\n\nSee also\n--------\nsquare_of_sums : The square(s) of the sum(s) (the opposite of `ss`).\n\nExamples\n--------\n>>> from scipy import stats\n>>> a = np.array([1., 2., 5.])\n>>> stats.ss(a)\n30.0\n\nAnd calculating along an axis:\n\n>>> b = np.array([[1., 2., 5.], [2., 5., 6.]])\n>>> stats.ss(b, axis=1)\narray([ 30., 65.])", "id": "f19697:m72"}
{"signature": "def trimboth(a, proportiontocut, axis=<NUM_LIT:0>):", "body": "a = np.asarray(a)<EOL>if axis is None:<EOL><INDENT>a = a.ravel()<EOL>axis = <NUM_LIT:0><EOL><DEDENT>nobs = a.shape[axis]<EOL>lowercut = int(proportiontocut * nobs)<EOL>uppercut = nobs - lowercut<EOL>if (lowercut >= uppercut):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>sl = [slice(None)] * a.ndim<EOL>sl[axis] = slice(lowercut, uppercut)<EOL>return a[sl]<EOL>", "docstring": "Slices off a proportion of items from both ends of an array.\n\nSlices off the passed proportion of items from both ends of the passed\narray (i.e., with `proportiontocut` = 0.1, slices leftmost 10% **and**\nrightmost 10% of scores).  You must pre-sort the array if you want\n'proper' trimming.  Slices off less if proportion results in a\nnon-integer slice index (i.e., conservatively slices off\n`proportiontocut`).\n\nParameters\n----------\na : array_like\n    Data to trim.\nproportiontocut : float\n    Proportion (in range 0-1) of total data set to trim of each end.\naxis : int or None, optional\n    Axis along which the observations are trimmed. The default is to trim\n    along axis=0. If axis is None then the array will be flattened before\n    trimming.\n\nReturns\n-------\nout : ndarray\n    Trimmed version of array `a`.\n\nSee Also\n--------\ntrim_mean\n\nExamples\n--------\n>>> from scipy import stats\n>>> a = np.arange(20)\n>>> b = stats.trimboth(a, 0.1)\n>>> b.shape\n(16,)", "id": "f19697:m42"}
{"signature": "def mask_to_limits(a, limits, inclusive):", "body": "lower_limit, upper_limit = limits<EOL>lower_include, upper_include = inclusive<EOL>am = ma.MaskedArray(a)<EOL>if lower_limit is not None:<EOL><INDENT>if lower_include:<EOL><INDENT>am = ma.masked_less(am, lower_limit)<EOL><DEDENT>else:<EOL><INDENT>am = ma.masked_less_equal(am, lower_limit)<EOL><DEDENT><DEDENT>if upper_limit is not None:<EOL><INDENT>if upper_include:<EOL><INDENT>am = ma.masked_greater(am, upper_limit)<EOL><DEDENT>else:<EOL><INDENT>am = ma.masked_greater_equal(am, upper_limit)<EOL><DEDENT><DEDENT>if am.count() == <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return am<EOL>", "docstring": "Mask an array for values outside of given limits.\n\n    This is primarily a utility function.\n\n    Parameters\n    ----------\n    a : array\n    limits : (float or None, float or None)\n        A tuple consisting of the (lower limit, upper limit).  Values in the\n        input array less than the lower limit or greater than the upper limit\n        will be masked out. None implies no limit.\n    inclusive : (bool, bool)\n        A tuple consisting of the (lower flag, upper flag).  These flags\n        determine whether values exactly equal to lower or upper are allowed.\n\n    Returns\n    -------\n    A MaskedArray.\n\n    Raises\n    ------\n    A ValueError if there are no values within the given limits.", "id": "f19697:m10"}
{"signature": "def kendalltau(x, y, initial_lexsort=True):", "body": "x = np.asarray(x).ravel()<EOL>y = np.asarray(y).ravel()<EOL>if not x.size or not y.size:<EOL><INDENT>return (np.nan, np.nan)  <EOL><DEDENT>n = np.int64(len(x))<EOL>temp = list(range(n))  <EOL>def mergesort(offs, length):<EOL><INDENT>exchcnt = <NUM_LIT:0><EOL>if length == <NUM_LIT:1>:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>if length == <NUM_LIT:2>:<EOL><INDENT>if y[perm[offs]] <= y[perm[offs+<NUM_LIT:1>]]:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>t = perm[offs]<EOL>perm[offs] = perm[offs+<NUM_LIT:1>]<EOL>perm[offs+<NUM_LIT:1>] = t<EOL>return <NUM_LIT:1><EOL><DEDENT>length0 = length // <NUM_LIT:2><EOL>length1 = length - length0<EOL>middle = offs + length0<EOL>exchcnt += mergesort(offs, length0)<EOL>exchcnt += mergesort(middle, length1)<EOL>if y[perm[middle - <NUM_LIT:1>]] < y[perm[middle]]:<EOL><INDENT>return exchcnt<EOL><DEDENT>i = j = k = <NUM_LIT:0><EOL>while j < length0 or k < length1:<EOL><INDENT>if k >= length1 or (j < length0 and y[perm[offs + j]] <=<EOL>y[perm[middle + k]]):<EOL><INDENT>temp[i] = perm[offs + j]<EOL>d = i - j<EOL>j += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>temp[i] = perm[middle + k]<EOL>d = (offs + i) - (middle + k)<EOL>k += <NUM_LIT:1><EOL><DEDENT>if d > <NUM_LIT:0>:<EOL><INDENT>exchcnt += d<EOL><DEDENT>i += <NUM_LIT:1><EOL><DEDENT>perm[offs:offs+length] = temp[<NUM_LIT:0>:length]<EOL>return exchcnt<EOL><DEDENT>if initial_lexsort:<EOL><INDENT>perm = np.lexsort((y, x))<EOL><DEDENT>else:<EOL><INDENT>perm = list(range(n))<EOL>perm.sort(key=lambda a: (x[a], y[a]))<EOL><DEDENT>first = <NUM_LIT:0><EOL>t = <NUM_LIT:0><EOL>for i in xrange(<NUM_LIT:1>, n):<EOL><INDENT>if x[perm[first]] != x[perm[i]] or y[perm[first]] != y[perm[i]]:<EOL><INDENT>t += ((i - first) * (i - first - <NUM_LIT:1>)) // <NUM_LIT:2><EOL>first = i<EOL><DEDENT><DEDENT>t += ((n - first) * (n - first - <NUM_LIT:1>)) // <NUM_LIT:2><EOL>first = <NUM_LIT:0><EOL>u = <NUM_LIT:0><EOL>for i in xrange(<NUM_LIT:1>,n):<EOL><INDENT>if x[perm[first]] != x[perm[i]]:<EOL><INDENT>u += ((i - first) * (i - first - <NUM_LIT:1>)) // <NUM_LIT:2><EOL>first = i<EOL><DEDENT><DEDENT>u += ((n - first) * (n - first - <NUM_LIT:1>)) // <NUM_LIT:2><EOL>exchanges = mergesort(<NUM_LIT:0>, n)<EOL>first = <NUM_LIT:0><EOL>v = <NUM_LIT:0><EOL>for i in xrange(<NUM_LIT:1>,n):<EOL><INDENT>if y[perm[first]] != y[perm[i]]:<EOL><INDENT>v += ((i - first) * (i - first - <NUM_LIT:1>)) // <NUM_LIT:2><EOL>first = i<EOL><DEDENT><DEDENT>v += ((n - first) * (n - first - <NUM_LIT:1>)) // <NUM_LIT:2><EOL>tot = (n * (n - <NUM_LIT:1>)) // <NUM_LIT:2><EOL>if tot == u or tot == v:<EOL><INDENT>return (np.nan, np.nan)    <EOL><DEDENT>denom = np.exp(<NUM_LIT:0.5> * (np.log(tot - u) + np.log(tot - v)))<EOL>tau = ((tot - (v + u - t)) - <NUM_LIT> * exchanges) / denom<EOL>svar = (<NUM_LIT> * n + <NUM_LIT>) / (<NUM_LIT> * n * (n - <NUM_LIT:1>))<EOL>z = tau / np.sqrt(svar)<EOL>prob = special.erfc(np.abs(z) / <NUM_LIT>)<EOL>return tau, prob<EOL>", "docstring": "Calculates Kendall's tau, a correlation measure for ordinal data.\n\nKendall's tau is a measure of the correspondence between two rankings.\nValues close to 1 indicate strong agreement, values close to -1 indicate\nstrong disagreement.  This is the tau-b version of Kendall's tau which\naccounts for ties.\n\nParameters\n----------\nx, y : array_like\n    Arrays of rankings, of the same shape. If arrays are not 1-D, they will\n    be flattened to 1-D.\ninitial_lexsort : bool, optional\n    Whether to use lexsort or quicksort as the sorting method for the\n    initial sort of the inputs. Default is lexsort (True), for which\n    `kendalltau` is of complexity O(n log(n)). If False, the complexity is\n    O(n^2), but with a smaller pre-factor (so quicksort may be faster for\n    small arrays).\n\nReturns\n-------\nKendall's tau : float\n   The tau statistic.\np-value : float\n   The two-sided p-value for a hypothesis test whose null hypothesis is\n   an absence of association, tau = 0.\n\nNotes\n-----\nThe definition of Kendall's tau that is used is::\n\n  tau = (P - Q) / sqrt((P + Q + T) * (P + Q + U))\n\nwhere P is the number of concordant pairs, Q the number of discordant\npairs, T the number of ties only in `x`, and U the number of ties only in\n`y`.  If a tie occurs for the same pair in both `x` and `y`, it is not\nadded to either T or U.\n\nReferences\n----------\nW.R. Knight, \"A Computer Method for Calculating Kendall's Tau with\nUngrouped Data\", Journal of the American Statistical Association, Vol. 61,\nNo. 314, Part 1, pp. 436-439, 1966.\n\nExamples\n--------\n>>> import scipy.stats as stats\n>>> x1 = [12, 2, 1, 12, 2]\n>>> x2 = [1, 4, 7, 1, 0]\n>>> tau, p_value = stats.kendalltau(x1, x2)\n>>> tau\n-0.47140452079103173\n>>> p_value\n0.24821309157521476", "id": "f19697:m50"}
{"signature": "def hmean(a, axis=<NUM_LIT:0>, dtype=None):", "body": "if not isinstance(a, np.ndarray):<EOL><INDENT>a = np.array(a, dtype=dtype)<EOL><DEDENT>if np.all(a > <NUM_LIT:0>):  <EOL><INDENT>if isinstance(a, np.ma.MaskedArray):<EOL><INDENT>size = a.count(axis)<EOL><DEDENT>else:<EOL><INDENT>if axis is None:<EOL><INDENT>a = a.ravel()<EOL>size = a.shape[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>size = a.shape[axis]<EOL><DEDENT><DEDENT>return size / np.sum(<NUM_LIT:1.0>/a, axis=axis, dtype=dtype)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Calculates the harmonic mean along the specified axis.\n\nThat is:  n / (1/x1 + 1/x2 + ... + 1/xn)\n\nParameters\n----------\na : array_like\n    Input array, masked array or object that can be converted to an array.\naxis : int, optional, default axis=0\n    Axis along which the harmonic mean is computed.\ndtype : dtype, optional\n    Type of the returned array and of the accumulator in which the\n    elements are summed. If `dtype` is not specified, it defaults to the\n    dtype of `a`, unless `a` has an integer `dtype` with a precision less\n    than that of the default platform integer. In that case, the default\n    platform integer is used.\n\nReturns\n-------\nhmean : ndarray\n    see `dtype` parameter above\n\nSee Also\n--------\nnumpy.mean : Arithmetic average\nnumpy.average : Weighted average\ngmean : Geometric mean\n\nNotes\n-----\nThe harmonic mean is computed over a single dimension of the input\narray, axis=0 by default, or all values in the array if axis=None.\nfloat64 intermediate and return values are used for integer inputs.\n\nUse masked arrays to ignore any non-finite values in the input or that\narise in the calculations such as Not a Number and infinity.", "id": "f19697:m8"}
{"signature": "@np.deprecate(message=\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>def nanstd(x, axis=<NUM_LIT:0>, bias=False):", "body": "x, axis = _chk_asarray(x, axis)<EOL>x = x.copy()<EOL>Norig = x.shape[axis]<EOL>mask = np.isnan(x)<EOL>Nnan = np.sum(mask, axis) * <NUM_LIT:1.0><EOL>n = Norig - Nnan<EOL>x[mask] = <NUM_LIT:0.0><EOL>m1 = np.sum(x, axis) / n<EOL>if axis:<EOL><INDENT>d = x - np.expand_dims(m1, axis)<EOL><DEDENT>else:<EOL><INDENT>d = x - m1<EOL><DEDENT>d *= d<EOL>m2 = np.sum(d, axis) - m1 * m1 * Nnan<EOL>if bias:<EOL><INDENT>m2c = m2 / n<EOL><DEDENT>else:<EOL><INDENT>m2c = m2 / (n - <NUM_LIT:1.0>)<EOL><DEDENT>return np.sqrt(m2c)<EOL>", "docstring": "Compute the standard deviation over the given axis, ignoring nans.\n\nParameters\n----------\nx : array_like\n    Input array.\naxis : int or None, optional\n    Axis along which the standard deviation is computed. Default is 0.\n    If None, compute over the whole array `x`.\nbias : bool, optional\n    If True, the biased (normalized by N) definition is used. If False\n    (default), the unbiased definition is used.\n\nReturns\n-------\ns : float\n    The standard deviation.\n\nSee Also\n--------\nnanmean, nanmedian\n\nExamples\n--------\n>>> from scipy import stats\n>>> a = np.arange(10, dtype=float)\n>>> a[1:3] = np.nan\n>>> np.std(a)\nnan\n>>> stats.nanstd(a)\n2.9154759474226504\n>>> stats.nanstd(a.reshape(2, 5), axis=1)\narray([ 2.0817,  1.5811])\n>>> stats.nanstd(a.reshape(2, 5), axis=None)\n2.9154759474226504", "id": "f19697:m4"}
{"signature": "def histogram2(a, bins):", "body": "<EOL>n = np.searchsorted(np.sort(a), bins)<EOL>n = np.concatenate([n, [len(a)]])<EOL>return n[<NUM_LIT:1>:]-n[:-<NUM_LIT:1>]<EOL>", "docstring": "Compute histogram using divisions in bins.\n\nCount the number of times values from array `a` fall into\nnumerical ranges defined by `bins`.  Range x is given by\nbins[x] <= range_x < bins[x+1] where x =0,N and N is the\nlength of the `bins` array.  The last range is given by\nbins[N] <= range_N < infinity.  Values less than bins[0] are\nnot included in the histogram.\n\nParameters\n----------\na : array_like of rank 1\n    The array of values to be assigned into bins\nbins : array_like of rank 1\n    Defines the ranges of values to use during histogramming.\n\nReturns\n-------\nhistogram2 : ndarray of rank 1\n    Each value represents the occurrences for a given bin (range) of\n    values.", "id": "f19697:m31"}
{"signature": "def moment(a, moment=<NUM_LIT:1>, axis=<NUM_LIT:0>):", "body": "a, axis = _chk_asarray(a, axis)<EOL>if moment == <NUM_LIT:1>:<EOL><INDENT>shape = list(a.shape)<EOL>del shape[axis]<EOL>if shape:<EOL><INDENT>return np.zeros(shape, dtype=float)<EOL><DEDENT>else:<EOL><INDENT>return np.float64(<NUM_LIT:0.0>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>mn = np.expand_dims(np.mean(a,axis), axis)<EOL>s = np.power((a-mn), moment)<EOL>return np.mean(s, axis)<EOL><DEDENT>", "docstring": "Calculates the nth moment about the mean for a sample.\n\nGenerally used to calculate coefficients of skewness and\nkurtosis.\n\nParameters\n----------\na : array_like\n   data\nmoment : int\n   order of central moment that is returned\naxis : int or None\n   Axis along which the central moment is computed. If None, then the data\n   array is raveled. The default axis is zero.\n\nReturns\n-------\nn-th central moment : ndarray or float\n   The appropriate moment along the given axis or over all values if axis\n   is None. The denominator for the moment calculation is the number of\n   observations, no degrees of freedom correction is done.", "id": "f19697:m18"}
{"signature": "def mode(a, axis=<NUM_LIT:0>):", "body": "a, axis = _chk_asarray(a, axis)<EOL>scores = np.unique(np.ravel(a))       <EOL>testshape = list(a.shape)<EOL>testshape[axis] = <NUM_LIT:1><EOL>oldmostfreq = np.zeros(testshape, dtype=a.dtype)<EOL>oldcounts = np.zeros(testshape)<EOL>for score in scores:<EOL><INDENT>template = (a == score)<EOL>counts = np.expand_dims(np.sum(template, axis),axis)<EOL>mostfrequent = np.where(counts > oldcounts, score, oldmostfreq)<EOL>oldcounts = np.maximum(counts, oldcounts)<EOL>oldmostfreq = mostfrequent<EOL><DEDENT>return mostfrequent, oldcounts<EOL>", "docstring": "Returns an array of the modal (most common) value in the passed array.\n\nIf there is more than one such value, only the first is returned.\nThe bin-count for the modal bins is also returned.\n\nParameters\n----------\na : array_like\n    n-dimensional array of which to find mode(s).\naxis : int, optional\n    Axis along which to operate. Default is 0, i.e. the first axis.\n\nReturns\n-------\nvals : ndarray\n    Array of modal values.\ncounts : ndarray\n    Array of counts for each mode.\n\nExamples\n--------\n>>> a = np.array([[6, 8, 3, 0],\n                  [3, 2, 1, 7],\n                  [8, 1, 8, 4],\n                  [5, 3, 0, 5],\n                  [4, 7, 5, 9]])\n>>> from scipy import stats\n>>> stats.mode(a)\n(array([[ 3.,  1.,  0.,  0.]]), array([[ 1.,  1.,  1.,  1.]]))\n\nTo get mode of whole array, specify axis=None:\n\n>>> stats.mode(a, axis=None)\n(array([ 3.]), array([ 3.]))", "id": "f19697:m9"}
{"signature": "def fastsort(a):", "body": "<EOL>it = np.argsort(a)<EOL>as_ = a[it]<EOL>return as_, it<EOL>", "docstring": "Sort an array and provide the argsort.\n\nParameters\n----------\na : array_like\n    Input array.\n\nReturns\n-------\nfastsort : ndarray of type int\n    sorted indices into the original array", "id": "f19697:m74"}
{"signature": "def combine_pvalues(pvalues, method='<STR_LIT>', weights=None):", "body": "pvalues = np.asarray(pvalues)<EOL>if pvalues.ndim != <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if method == '<STR_LIT>':<EOL><INDENT>Xsq = -<NUM_LIT:2> * np.sum(np.log(pvalues))<EOL>pval = distributions.chi2.sf(Xsq, <NUM_LIT:2> * len(pvalues))<EOL>return (Xsq, pval)<EOL><DEDENT>elif method == '<STR_LIT>':<EOL><INDENT>if weights is None:<EOL><INDENT>weights = np.ones_like(pvalues)<EOL><DEDENT>elif len(weights) != len(pvalues):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>weights = np.asarray(weights)<EOL>if weights.ndim != <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>Zi = distributions.norm.isf(pvalues)<EOL>Z = np.dot(weights, Zi) / np.linalg.norm(weights)<EOL>pval = distributions.norm.sf(Z)<EOL>return (Z, pval)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\", method)<EOL><DEDENT>", "docstring": "Methods for combining the p-values of independent tests bearing upon the\nsame hypothesis.\n\nParameters\n----------\np: array_like, 1-D\n    Array of p-values assumed to come from independent tests.\nmethod: str\n    Name of method to use to combine p-values. The following methods are\n    available:\n    - \"fisher\": Fisher's method (Fisher's combined probability test)\n    - \"stouffer\": Stouffer's Z-score method\nweights: array_like, 1-D, optional\n    Optional array of weights used only for Stouffer's Z-score method.\n\nReturns\n-------\nstatistic: float\n    The statistic calculated by the specified method:\n    - \"fisher\": The chi-squared statistic\n    - \"stouffer\": The Z-score\npval: float\n    The combined p-value.\n\nNotes\n-----\nFisher's method (also known as Fisher's combined probability test) [1]_ uses\na chi-squared statistic to compute a combined p-value. The closely related\nStouffer's Z-score method [2]_ uses Z-scores rather than p-values. The\nadvantage of Stouffer's method is that it is straightforward to introduce\nweights, which can make Stouffer's method more powerful than Fisher's\nmethod when the p-values are from studies of different size [3]_ [4]_.\n\nFisher's method may be extended to combine p-values from dependent tests\n[5]_. Extensions such as Brown's method and Kost's method are not currently\nimplemented.\n\nReferences\n----------\n.. [1] https://en.wikipedia.org/wiki/Fisher%27s_method\n.. [2] http://en.wikipedia.org/wiki/Fisher's_method#Relation_to_Stouffer.27s_Z-score_method\n.. [3] Whitlock, M. C. \"Combining probability from independent tests: the\n       weighted Z-method is superior to Fisher's approach.\" Journal of\n       Evolutionary Biology 18, no. 5 (2005): 1368-1373.\n.. [4] Zaykin, Dmitri V. \"Optimally weighted Z-test is a powerful method\n       for combining probabilities in meta-analysis.\" Journal of\n       Evolutionary Biology 24, no. 8 (2011): 1836-1841.\n.. [5] https://en.wikipedia.org/wiki/Extensions_of_Fisher%27s_method", "id": "f19697:m66"}
{"signature": "def linregress(x, y=None):", "body": "TINY = <NUM_LIT><EOL>if y is None:  <EOL><INDENT>x = asarray(x)<EOL>if x.shape[<NUM_LIT:0>] == <NUM_LIT:2>:<EOL><INDENT>x, y = x<EOL><DEDENT>elif x.shape[<NUM_LIT:1>] == <NUM_LIT:2>:<EOL><INDENT>x, y = x.T<EOL><DEDENT>else:<EOL><INDENT>msg = \"<STR_LIT>\" % str(x.shape)<EOL>raise ValueError(msg)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>x = asarray(x)<EOL>y = asarray(y)<EOL><DEDENT>n = len(x)<EOL>xmean = np.mean(x,None)<EOL>ymean = np.mean(y,None)<EOL>ssxm, ssxym, ssyxm, ssym = np.cov(x, y, bias=<NUM_LIT:1>).flat<EOL>r_num = ssxym<EOL>r_den = np.sqrt(ssxm*ssym)<EOL>if r_den == <NUM_LIT:0.0>:<EOL><INDENT>r = <NUM_LIT:0.0><EOL><DEDENT>else:<EOL><INDENT>r = r_num / r_den<EOL>if (r > <NUM_LIT:1.0>):<EOL><INDENT>r = <NUM_LIT:1.0><EOL><DEDENT>elif (r < -<NUM_LIT:1.0>):<EOL><INDENT>r = -<NUM_LIT:1.0><EOL><DEDENT><DEDENT>df = n-<NUM_LIT:2><EOL>t = r*np.sqrt(df/((<NUM_LIT:1.0>-r+TINY)*(<NUM_LIT:1.0>+r+TINY)))<EOL>prob = distributions.t.sf(np.abs(t),df)*<NUM_LIT:2><EOL>slope = r_num / ssxm<EOL>intercept = ymean - slope*xmean<EOL>sterrest = np.sqrt((<NUM_LIT:1>-r*r)*ssym / ssxm / df)<EOL>return slope, intercept, r, prob, sterrest<EOL>", "docstring": "Calculate a regression line\n\nThis computes a least-squares regression for two sets of measurements.\n\nParameters\n----------\nx, y : array_like\n    two sets of measurements.  Both arrays should have the same length.\n    If only x is given (and y=None), then it must be a two-dimensional\n    array where one dimension has length 2.  The two sets of measurements\n    are then found by splitting the array along the length-2 dimension.\n\nReturns\n-------\nslope : float\n    slope of the regression line\nintercept : float\n    intercept of the regression line\nr-value : float\n    correlation coefficient\np-value : float\n    two-sided p-value for a hypothesis test whose null hypothesis is\n    that the slope is zero.\nstderr : float\n    Standard error of the estimate\n\n\nExamples\n--------\n>>> from scipy import stats\n>>> import numpy as np\n>>> x = np.random.random(10)\n>>> y = np.random.random(10)\n>>> slope, intercept, r_value, p_value, std_err = stats.linregress(x,y)\n\n# To get coefficient of determination (r_squared)\n\n>>> print \"r-squared:\", r_value**2\nr-squared: 0.15286643777", "id": "f19697:m51"}
{"signature": "def stde_median(data, axis=None):", "body": "def _stdemed_1D(data):<EOL><INDENT>data = np.sort(data.compressed())<EOL>n = len(data)<EOL>z = <NUM_LIT><EOL>k = int(np.round((n+<NUM_LIT:1>)/<NUM_LIT> - z * np.sqrt(n/<NUM_LIT>),<NUM_LIT:0>))<EOL>return ((data[n-k] - data[k-<NUM_LIT:1>])/(<NUM_LIT>*z))<EOL><DEDENT>data = ma.array(data, copy=False, subok=True)<EOL>if (axis is None):<EOL><INDENT>return _stdemed_1D(data)<EOL><DEDENT>else:<EOL><INDENT>if data.ndim > <NUM_LIT:2>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % data.ndim)<EOL><DEDENT>return ma.apply_along_axis(_stdemed_1D, axis, data)<EOL><DEDENT>", "docstring": "Returns the McKean-Schrader estimate of the standard error of the sample\n    median along the given axis. masked values are discarded.\n\n    Parameters\n    ----------\n    data : ndarray\n        Data to trim.\n    axis : {None,int}, optional\n        Axis along which to perform the trimming.\n        If None, the input array is first flattened.", "id": "f19701:m46"}
{"signature": "def find_repeats(arr):", "body": "marr = ma.compressed(arr)<EOL>if not marr.size:<EOL><INDENT>return (np.array(<NUM_LIT:0>), np.array(<NUM_LIT:0>))<EOL><DEDENT>(v1, v2, n) = futil.dfreps(ma.array(ma.compressed(arr), copy=True))<EOL>return (v1[:n], v2[:n])<EOL>", "docstring": "Find repeats in arr and return a tuple (repeats, repeat_count).\n    Masked values are discarded.\n\n    Parameters\n    ----------\n    arr : sequence\n        Input array. The array is flattened if it is not 1D.\n\n    Returns\n    -------\n    repeats : ndarray\n        Array of repeated values.\n    counts : ndarray\n        Array of counts.", "id": "f19701:m4"}
{"signature": "def spearmanr(x, y, use_ties=True):", "body": "(x, y, n) = _chk_size(x, y)<EOL>(x, y) = (x.ravel(), y.ravel())<EOL>m = ma.mask_or(ma.getmask(x), ma.getmask(y))<EOL>n -= m.sum()<EOL>if m is not nomask:<EOL><INDENT>x = ma.array(x, mask=m, copy=True)<EOL>y = ma.array(y, mask=m, copy=True)<EOL><DEDENT>df = n-<NUM_LIT:2><EOL>if df < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>rankx = rankdata(x)<EOL>ranky = rankdata(y)<EOL>dsq = np.add.reduce((rankx-ranky)**<NUM_LIT:2>)<EOL>if use_ties:<EOL><INDENT>xties = count_tied_groups(x)<EOL>yties = count_tied_groups(y)<EOL>corr_x = np.sum(v*k*(k**<NUM_LIT:2>-<NUM_LIT:1>) for (k,v) in iteritems(xties))/<NUM_LIT><EOL>corr_y = np.sum(v*k*(k**<NUM_LIT:2>-<NUM_LIT:1>) for (k,v) in iteritems(yties))/<NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>corr_x = corr_y = <NUM_LIT:0><EOL><DEDENT>denom = n*(n**<NUM_LIT:2> - <NUM_LIT:1>)/<NUM_LIT><EOL>if corr_x != <NUM_LIT:0> or corr_y != <NUM_LIT:0>:<EOL><INDENT>rho = denom - dsq - corr_x - corr_y<EOL>rho /= ma.sqrt((denom-<NUM_LIT:2>*corr_x)*(denom-<NUM_LIT:2>*corr_y))<EOL><DEDENT>else:<EOL><INDENT>rho = <NUM_LIT:1.> - dsq/denom<EOL><DEDENT>t = ma.sqrt(ma.divide(df,(rho+<NUM_LIT:1.0>)*(<NUM_LIT:1.0>-rho))) * rho<EOL>if t is masked:<EOL><INDENT>prob = <NUM_LIT:0.><EOL><DEDENT>else:<EOL><INDENT>prob = betai(<NUM_LIT:0.5>*df,<NUM_LIT:0.5>,df/(df+t*t))<EOL><DEDENT>return rho, prob<EOL>", "docstring": "Calculates a Spearman rank-order correlation coefficient and the p-value\nto test for non-correlation.\n\nThe Spearman correlation is a nonparametric measure of the linear\nrelationship between two datasets. Unlike the Pearson correlation, the\nSpearman correlation does not assume that both datasets are normally\ndistributed. Like other correlation coefficients, this one varies\nbetween -1 and +1 with 0 implying no correlation. Correlations of -1 or\n+1 imply an exact linear relationship. Positive correlations imply that\nas `x` increases, so does `y`. Negative correlations imply that as `x`\nincreases, `y` decreases.\n\nMissing values are discarded pair-wise: if a value is missing in `x`, the\ncorresponding value in `y` is masked.\n\nThe p-value roughly indicates the probability of an uncorrelated system\nproducing datasets that have a Spearman correlation at least as extreme\nas the one computed from these datasets. The p-values are not entirely\nreliable but are probably reasonable for datasets larger than 500 or so.\n\nParameters\n----------\nx : array_like\n    The length of `x` must be > 2.\ny : array_like\n    The length of `y` must be > 2.\nuse_ties : bool, optional\n    Whether the correction for ties should be computed.\n\nReturns\n-------\nspearmanr : float\n    Spearman correlation coefficient, 2-tailed p-value.\n\nReferences\n----------\n[CRCProbStat2000] section 14.7", "id": "f19701:m11"}
{"signature": "def trimboth(data, proportiontocut=<NUM_LIT>, inclusive=(True,True), axis=None):", "body": "return trimr(data, limits=(proportiontocut,proportiontocut),<EOL>inclusive=inclusive, axis=axis)<EOL>", "docstring": "Trims the smallest and largest data values.\n\nTrims the `data` by masking the ``int(proportiontocut * n)`` smallest and\n``int(proportiontocut * n)`` largest values of data along the given axis,\nwhere n is the number of unmasked values before trimming.\n\nParameters\n----------\ndata : ndarray\n    Data to trim.\nproportiontocut : float, optional\n    Percentage of trimming (as a float between 0 and 1).\n    If n is the number of unmasked values before trimming, the number of\n    values after trimming is ``(1 - 2*proportiontocut) * n``.\n    Default is 0.2.\ninclusive : {(bool, bool) tuple}, optional\n    Tuple indicating whether the number of data being masked on each side\n    should be rounded (True) or truncated (False).\naxis : int, optional\n    Axis along which to perform the trimming.\n    If None, the input array is first flattened.", "id": "f19701:m29"}
{"signature": "def sem(a, axis=<NUM_LIT:0>, ddof=<NUM_LIT:1>):", "body": "a, axis = _chk_asarray(a, axis)<EOL>n = a.count(axis=axis)<EOL>s = a.std(axis=axis, ddof=ddof) / ma.sqrt(n)<EOL>return s<EOL>", "docstring": "Calculates the standard error of the mean of the input array.\n\nAlso sometimes called standard error of measurement.\n\nParameters\n----------\na : array_like\n    An array containing the values for which the standard error is\n    returned.\naxis : int or None, optional.\n    If axis is None, ravel `a` first. If axis is an integer, this will be\n    the axis over which to operate. Defaults to 0.\nddof : int, optional\n    Delta degrees-of-freedom. How many degrees of freedom to adjust\n    for bias in limited samples relative to the population estimate\n    of variance. Defaults to 1.\n\nReturns\n-------\ns : ndarray or float\n    The standard error of the mean in the sample(s), along the input axis.\n\nNotes\n-----\nThe default value for `ddof` changed in scipy 0.15.0 to be consistent with\n`stats.sem` as well as with the most common definition used (like in the R\ndocumentation).\n\nExamples\n--------\nFind standard error along the first axis:\n\n>>> from scipy import stats\n>>> a = np.arange(20).reshape(5,4)\n>>> stats.sem(a)\narray([ 2.8284,  2.8284,  2.8284,  2.8284])\n\nFind standard error across the whole array, using n degrees of freedom:\n\n>>> stats.sem(a, axis=None, ddof=0)\n1.2893796958227628", "id": "f19701:m55"}
{"signature": "def kendalltau(x, y, use_ties=True, use_missing=False):", "body": "(x, y, n) = _chk_size(x, y)<EOL>(x, y) = (x.flatten(), y.flatten())<EOL>m = ma.mask_or(ma.getmask(x), ma.getmask(y))<EOL>if m is not nomask:<EOL><INDENT>x = ma.array(x, mask=m, copy=True)<EOL>y = ma.array(y, mask=m, copy=True)<EOL>n -= m.sum()<EOL><DEDENT>if n < <NUM_LIT:2>:<EOL><INDENT>return (np.nan, np.nan)<EOL><DEDENT>rx = ma.masked_equal(rankdata(x, use_missing=use_missing), <NUM_LIT:0>)<EOL>ry = ma.masked_equal(rankdata(y, use_missing=use_missing), <NUM_LIT:0>)<EOL>idx = rx.argsort()<EOL>(rx, ry) = (rx[idx], ry[idx])<EOL>C = np.sum([((ry[i+<NUM_LIT:1>:] > ry[i]) * (rx[i+<NUM_LIT:1>:] > rx[i])).filled(<NUM_LIT:0>).sum()<EOL>for i in range(len(ry)-<NUM_LIT:1>)], dtype=float)<EOL>D = np.sum([((ry[i+<NUM_LIT:1>:] < ry[i])*(rx[i+<NUM_LIT:1>:] > rx[i])).filled(<NUM_LIT:0>).sum()<EOL>for i in range(len(ry)-<NUM_LIT:1>)], dtype=float)<EOL>if use_ties:<EOL><INDENT>xties = count_tied_groups(x)<EOL>yties = count_tied_groups(y)<EOL>corr_x = np.sum([v*k*(k-<NUM_LIT:1>) for (k,v) in iteritems(xties)], dtype=float)<EOL>corr_y = np.sum([v*k*(k-<NUM_LIT:1>) for (k,v) in iteritems(yties)], dtype=float)<EOL>denom = ma.sqrt((n*(n-<NUM_LIT:1>)-corr_x)/<NUM_LIT> * (n*(n-<NUM_LIT:1>)-corr_y)/<NUM_LIT>)<EOL><DEDENT>else:<EOL><INDENT>denom = n*(n-<NUM_LIT:1>)/<NUM_LIT><EOL><DEDENT>tau = (C-D) / denom<EOL>var_s = n*(n-<NUM_LIT:1>)*(<NUM_LIT:2>*n+<NUM_LIT:5>)<EOL>if use_ties:<EOL><INDENT>var_s -= np.sum(v*k*(k-<NUM_LIT:1>)*(<NUM_LIT:2>*k+<NUM_LIT:5>)*<NUM_LIT:1.> for (k,v) in iteritems(xties))<EOL>var_s -= np.sum(v*k*(k-<NUM_LIT:1>)*(<NUM_LIT:2>*k+<NUM_LIT:5>)*<NUM_LIT:1.> for (k,v) in iteritems(yties))<EOL>v1 = np.sum([v*k*(k-<NUM_LIT:1>) for (k, v) in iteritems(xties)], dtype=float) *np.sum([v*k*(k-<NUM_LIT:1>) for (k, v) in iteritems(yties)], dtype=float)<EOL>v1 /= <NUM_LIT>*n*(n-<NUM_LIT:1>)<EOL>if n > <NUM_LIT:2>:<EOL><INDENT>v2 = np.sum([v*k*(k-<NUM_LIT:1>)*(k-<NUM_LIT:2>) for (k,v) in iteritems(xties)],<EOL>dtype=float) *np.sum([v*k*(k-<NUM_LIT:1>)*(k-<NUM_LIT:2>) for (k,v) in iteritems(yties)],<EOL>dtype=float)<EOL>v2 /= <NUM_LIT>*n*(n-<NUM_LIT:1>)*(n-<NUM_LIT:2>)<EOL><DEDENT>else:<EOL><INDENT>v2 = <NUM_LIT:0><EOL><DEDENT><DEDENT>else:<EOL><INDENT>v1 = v2 = <NUM_LIT:0><EOL><DEDENT>var_s /= <NUM_LIT><EOL>var_s += (v1 + v2)<EOL>z = (C-D)/np.sqrt(var_s)<EOL>prob = special.erfc(abs(z)/np.sqrt(<NUM_LIT:2>))<EOL>return (tau, prob)<EOL>", "docstring": "Computes Kendall's rank correlation tau on two variables *x* and *y*.\n\nParameters\n----------\nxdata : sequence\n    First data list (for example, time).\nydata : sequence\n    Second data list.\nuse_ties : {True, False}, optional\n    Whether ties correction should be performed.\nuse_missing : {False, True}, optional\n    Whether missing data should be allocated a rank of 0 (False) or the\n    average rank (True)\n\nReturns\n-------\ntau : float\n    Kendall tau\nprob : float\n    Approximate 2-side p-value.", "id": "f19701:m12"}
{"signature": "def mquantiles_cimj(data, prob=[<NUM_LIT>,<NUM_LIT>,<NUM_LIT>], alpha=<NUM_LIT>, axis=None):", "body": "alpha = min(alpha, <NUM_LIT:1>-alpha)<EOL>z = norm.ppf(<NUM_LIT:1>-alpha/<NUM_LIT>)<EOL>xq = mstats.mquantiles(data, prob, alphap=<NUM_LIT:0>, betap=<NUM_LIT:0>, axis=axis)<EOL>smj = mjci(data, prob, axis=axis)<EOL>return (xq - z * smj, xq + z * smj)<EOL>", "docstring": "Computes the alpha confidence interval for the selected quantiles of the\ndata, with Maritz-Jarrett estimators.\n\nParameters\n----------\ndata : ndarray\n    Data array.\nprob : sequence\n    Sequence of quantiles to compute.\nalpha : float\n    Confidence level of the intervals.\naxis : integer\n    Axis along which to compute the quantiles.\n    If None, use a flattened array.", "id": "f19703:m5"}
{"signature": "def mjci(data, prob=[<NUM_LIT>,<NUM_LIT:0.5>,<NUM_LIT>], axis=None):", "body": "def _mjci_1D(data, p):<EOL><INDENT>data = np.sort(data.compressed())<EOL>n = data.size<EOL>prob = (np.array(p) * n + <NUM_LIT:0.5>).astype(int_)<EOL>betacdf = beta.cdf<EOL>mj = np.empty(len(prob), float_)<EOL>x = np.arange(<NUM_LIT:1>,n+<NUM_LIT:1>, dtype=float_) / n<EOL>y = x - <NUM_LIT:1.>/n<EOL>for (i,m) in enumerate(prob):<EOL><INDENT>(m1,m2) = (m-<NUM_LIT:1>, n-m)<EOL>W = betacdf(x,m-<NUM_LIT:1>,n-m) - betacdf(y,m-<NUM_LIT:1>,n-m)<EOL>C1 = np.dot(W,data)<EOL>C2 = np.dot(W,data**<NUM_LIT:2>)<EOL>mj[i] = np.sqrt(C2 - C1**<NUM_LIT:2>)<EOL><DEDENT>return mj<EOL><DEDENT>data = ma.array(data, copy=False)<EOL>if data.ndim > <NUM_LIT:2>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % data.ndim)<EOL><DEDENT>p = np.array(prob, copy=False, ndmin=<NUM_LIT:1>)<EOL>if (axis is None):<EOL><INDENT>return _mjci_1D(data, p)<EOL><DEDENT>else:<EOL><INDENT>return ma.apply_along_axis(_mjci_1D, axis, data, p)<EOL><DEDENT>", "docstring": "Returns the Maritz-Jarrett estimators of the standard error of selected\nexperimental quantiles of the data.\n\nParameters\n----------\ndata: ndarray\n    Data array.\nprob: sequence\n    Sequence of quantiles to compute.\naxis : int\n    Axis along which to compute the quantiles. If None, use a flattened\n    array.", "id": "f19703:m4"}
{"signature": "def hdmedian(data, axis=-<NUM_LIT:1>, var=False):", "body": "result = hdquantiles(data,[<NUM_LIT:0.5>], axis=axis, var=var)<EOL>return result.squeeze()<EOL>", "docstring": "Returns the Harrell-Davis estimate of the median along the given axis.\n\nParameters\n----------\ndata : ndarray\n    Data array.\naxis : int\n    Axis along which to compute the quantiles. If None, use a flattened\n    array.\nvar : boolean\n    Whether to return the variance of the estimate.", "id": "f19703:m1"}
{"signature": "def _sf(self, k, M, n, N):", "body": "<EOL>res = []<EOL>for quant, tot, good, draw in zip(k, M, n, N):<EOL><INDENT>k2 = np.arange(quant + <NUM_LIT:1>, draw + <NUM_LIT:1>)<EOL>res.append(np.sum(self._pmf(k2, tot, good, draw)))<EOL><DEDENT>return np.asarray(res)<EOL>", "docstring": "More precise calculation, 1 - cdf doesn't cut it.", "id": "f19704:c4:m6"}
{"signature": "def expected_freq(observed):", "body": "<EOL>observed = np.asarray(observed, dtype=np.float64)<EOL>margsums = margins(observed)<EOL>d = observed.ndim<EOL>expected = reduce(np.multiply, margsums) / observed.sum() ** (d - <NUM_LIT:1>)<EOL>return expected<EOL>", "docstring": "Compute the expected frequencies from a contingency table.\n\nGiven an n-dimensional contingency table of observed frequencies,\ncompute the expected frequencies for the table based on the marginal\nsums under the assumption that the groups associated with each\ndimension are independent.\n\nParameters\n----------\nobserved : array_like\n    The table of observed frequencies.  (While this function can handle\n    a 1-D array, that case is trivial.  Generally `observed` is at\n    least 2-D.)\n\nReturns\n-------\nexpected : ndarray of float64\n    The expected frequencies, based on the marginal sums of the table.\n    Same shape as `observed`.\n\nExamples\n--------\n>>> observed = np.array([[10, 10, 20],[20, 20, 20]])\n>>> expected_freq(observed)\narray([[ 12.,  12.,  16.],\n       [ 18.,  18.,  24.]])", "id": "f19707:m1"}
{"signature": "def get_sgemv_fix(info):", "body": "path = os.path.abspath(os.path.dirname(__file__))<EOL>if needs_sgemv_fix(info):<EOL><INDENT>return [os.path.join(path, '<STR_LIT:src>', '<STR_LIT>')]<EOL><DEDENT>else:<EOL><INDENT>return []<EOL><DEDENT>", "docstring": "Returns source file needed to correct SGEMV", "id": "f19708:m6"}
{"signature": "def needs_g77_abi_wrapper(info):", "body": "if uses_accelerate(info) or uses_veclib(info):<EOL><INDENT>return True<EOL><DEDENT>elif uses_mkl(info) and sys.platform == \"<STR_LIT>\":<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Returns True if g77 ABI wrapper must be used.", "id": "f19708:m3"}
{"signature": "def check_dimensions(self, instance, width, height,<EOL>field_name='<STR_LIT>'):", "body": "field = getattr(instance, field_name)<EOL>if width is None and height is None:<EOL><INDENT>with self.assertRaises(ValueError):<EOL><INDENT>getattr(field, '<STR_LIT:width>')<EOL><DEDENT>with self.assertRaises(ValueError):<EOL><INDENT>getattr(field, '<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.assertEqual(field.width, width)<EOL>self.assertEqual(field.height, height)<EOL><DEDENT>width_field_name = field_name + '<STR_LIT>'<EOL>if hasattr(instance, width_field_name):<EOL><INDENT>self.assertEqual(getattr(instance, width_field_name), width)<EOL><DEDENT>height_field_name = field_name + '<STR_LIT>'<EOL>if hasattr(instance, height_field_name):<EOL><INDENT>self.assertEqual(getattr(instance, height_field_name), height)<EOL><DEDENT>", "docstring": "Asserts that the given width and height values match both the\nfield's height and width attributes and the height and width fields\n(if defined) the image field is caching to.\n\nNote, this method will check for dimension fields named by adding\n\"_width\" or \"_height\" to the name of the ImageField.  So, the\nmodels used in these tests must have their fields named\naccordingly.\n\nBy default, we check the field named \"mugshot\", but this can be\nspecified by passing the field_name parameter.", "id": "f19725:c0:m2"}
{"signature": "def _run_it(self, dbinfo):", "body": "def _mock_subprocess_call(*args):<EOL><INDENT>self.subprocess_args = list(*args)<EOL>if '<STR_LIT>' in os.environ:<EOL><INDENT>with open(os.environ['<STR_LIT>'], '<STR_LIT:r>') as f:<EOL><INDENT>self.pgpass = f.read().strip()  <EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.pgpass = None<EOL><DEDENT>return <NUM_LIT:0><EOL><DEDENT>self.subprocess_args = None<EOL>self.pgpass = None<EOL>with mock.patch('<STR_LIT>', new=_mock_subprocess_call):<EOL><INDENT>DatabaseClient.runshell_db(dbinfo)<EOL><DEDENT>return self.subprocess_args, self.pgpass<EOL>", "docstring": "That function invokes the runshell command, while mocking\nsubprocess.call. It returns a 2-tuple with:\n- The command line list\n- The content of the file pointed by environment PGPASSFILE, or None.", "id": "f19748:c0:m0"}
{"signature": "def set_session_data(storage, messages):", "body": "storage.request.session[storage.session_key] = storage.serialize_messages(messages)<EOL>if hasattr(storage, '<STR_LIT>'):<EOL><INDENT>del storage._loaded_data<EOL><DEDENT>", "docstring": "Sets the messages into the backend request's session and remove the\nbackend's loaded data cache.", "id": "f19758:m0"}
{"signature": "def stored_cookie_messages_count(storage, response):", "body": "<EOL>cookie = response.cookies.get(storage.cookie_name)<EOL>if not cookie or cookie['<STR_LIT>'] == <NUM_LIT:0>:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>data = storage._decode(cookie.value)<EOL>if not data:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>if data[-<NUM_LIT:1>] == CookieStorage.not_finished:<EOL><INDENT>data.pop()<EOL><DEDENT>return len(data)<EOL>", "docstring": "Return an integer containing the number of messages stored.", "id": "f19761:m1"}
{"signature": "def has_change_permission(self, request, obj=None):", "body": "return request.user.is_staff and (obj is not None) and (obj.id % <NUM_LIT:2> == <NUM_LIT:0>)<EOL>", "docstring": "Only allow changing objects with even id number", "id": "f19783:c5:m0"}
{"signature": "def remove_url(self, name):", "body": "return [url for url in super().get_urls() if url.name != name]<EOL>", "docstring": "Remove all entries named 'name' from the ModelAdmin instance URL\npatterns list", "id": "f19806:c1:m0"}
{"signature": "@classmethod<EOL><INDENT>def traverse_qs(cls, obj_iter, path):<DEDENT>", "body": "ret_val = []<EOL>if hasattr(obj_iter, '<STR_LIT:all>'):<EOL><INDENT>obj_iter = obj_iter.all()<EOL><DEDENT>try:<EOL><INDENT>iter(obj_iter)<EOL><DEDENT>except TypeError:<EOL><INDENT>obj_iter = [obj_iter]<EOL><DEDENT>for obj in obj_iter:<EOL><INDENT>rel_objs = []<EOL>for part in path:<EOL><INDENT>if not part:<EOL><INDENT>continue<EOL><DEDENT>try:<EOL><INDENT>related = getattr(obj, part[<NUM_LIT:0>])<EOL><DEDENT>except ObjectDoesNotExist:<EOL><INDENT>continue<EOL><DEDENT>if related is not None:<EOL><INDENT>rel_objs.extend(cls.traverse_qs(related, [part[<NUM_LIT:1>:]]))<EOL><DEDENT><DEDENT>ret_val.append((obj, rel_objs))<EOL><DEDENT>return ret_val<EOL>", "docstring": "Helper method that returns a list containing a list of the objects in the\nobj_iter. Then for each object in the obj_iter, the path will be\nrecursively travelled and the found objects are added to the return value.", "id": "f19980:c1:m0"}
{"signature": "def allow_migrate(self, db, app_label, **hints):", "body": "if app_label == '<STR_LIT>':<EOL><INDENT>return db == '<STR_LIT>'<EOL><DEDENT>return None<EOL>", "docstring": "Make sure the auth app only appears on the 'other' db", "id": "f20036:c1:m3"}
{"signature": "@classmethod<EOL><INDENT>def setUpClass(cls):<DEDENT>", "body": "super().setUpClass()<EOL>cls._import_module_mock = YamlImportModuleMock()<EOL>importlib.import_module = cls._import_module_mock.import_module<EOL>serializers._serializers = {}<EOL>", "docstring": "Removes imported yaml and stubs importlib.import_module", "id": "f20050:c1:m0"}
{"signature": "def check_paginator(self, params, output):", "body": "count, num_pages, page_range = output<EOL>paginator = Paginator(*params)<EOL>self.check_attribute('<STR_LIT:count>', paginator, count, params)<EOL>self.check_attribute('<STR_LIT>', paginator, num_pages, params)<EOL>self.check_attribute('<STR_LIT>', paginator, page_range, params, coerce=list)<EOL>", "docstring": "Helper method that instantiates a Paginator object from the passed\nparams and then checks that its attributes match the passed output.", "id": "f20060:c0:m0"}
{"signature": "def session_view(request):", "body": "request.session['<STR_LIT>'] = '<STR_LIT>'<EOL>t = Template('<STR_LIT>',<EOL>name='<STR_LIT>')<EOL>c = Context()<EOL>return HttpResponse(t.render(c))<EOL>", "docstring": "A view that modifies the session", "id": "f20083:m20"}
{"signature": "def redirect_view(request):", "body": "if request.GET:<EOL><INDENT>query = '<STR_LIT:?>' + urlencode(request.GET, True)<EOL><DEDENT>else:<EOL><INDENT>query = '<STR_LIT>'<EOL><DEDENT>return HttpResponseRedirect('<STR_LIT>' + query)<EOL>", "docstring": "A view that redirects all requests to the GET view", "id": "f20083:m7"}
{"signature": "def formset_view(request):", "body": "if request.method == '<STR_LIT:POST>':<EOL><INDENT>formset = TestFormSet(request.POST)<EOL>if formset.is_valid():<EOL><INDENT>t = Template('<STR_LIT>', name='<STR_LIT>')<EOL>c = Context()<EOL><DEDENT>else:<EOL><INDENT>t = Template('<STR_LIT>',<EOL>name='<STR_LIT>')<EOL>c = Context({'<STR_LIT>': formset})<EOL><DEDENT><DEDENT>else:<EOL><INDENT>formset = TestForm(request.GET)<EOL>t = Template('<STR_LIT>',<EOL>name='<STR_LIT>')<EOL>c = Context({'<STR_LIT>': formset})<EOL><DEDENT>return HttpResponse(t.render(c))<EOL>", "docstring": "A view that tests a simple formset", "id": "f20083:m16"}
{"signature": "def form_view_with_template(request):", "body": "if request.method == '<STR_LIT:POST>':<EOL><INDENT>form = TestForm(request.POST)<EOL>if form.is_valid():<EOL><INDENT>message = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>message = '<STR_LIT>'<EOL><DEDENT><DEDENT>else:<EOL><INDENT>form = TestForm()<EOL>message = '<STR_LIT>'<EOL><DEDENT>return render(request, '<STR_LIT>', {<EOL>'<STR_LIT>': form,<EOL>'<STR_LIT:message>': message,<EOL>})<EOL>", "docstring": "A view that tests a simple form", "id": "f20083:m15"}
{"signature": "def run_select_for_update(self, status, **kwargs):", "body": "status.append('<STR_LIT>')<EOL>try:<EOL><INDENT>with transaction.atomic():<EOL><INDENT>person = Person.objects.select_for_update(**kwargs).get()<EOL>person.name = '<STR_LIT>'<EOL>person.save()<EOL><DEDENT><DEDENT>except (DatabaseError, Person.DoesNotExist) as e:<EOL><INDENT>status.append(e)<EOL><DEDENT>finally:<EOL><INDENT>connection.close()<EOL><DEDENT>", "docstring": "Utility method that runs a SELECT FOR UPDATE against all\nPerson instances. After the select_for_update, it attempts\nto update the name of the only record, save, and commit.\n\nThis function expects to run in a separate thread.", "id": "f20107:c0:m25"}
{"signature": "def articles_from_same_day_2(self):", "body": "from django.db import connection<EOL>with connection.cursor() as cursor:<EOL><INDENT>cursor.execute(\"\"\"<STR_LIT>\"\"\", [connection.ops.adapt_datefield_value(self.pub_date),<EOL>self.id])<EOL>return [self.__class__(*row) for row in cursor.fetchall()]<EOL><DEDENT>", "docstring": "Verbose version of get_articles_from_same_day_1, which does a custom\ndatabase query for the sake of demonstration.", "id": "f20108:c0:m3"}
{"signature": "@classmethod<EOL><INDENT>def create_tree(cls, stringtree):<DEDENT>", "body": "names = stringtree.split()<EOL>models = [Domain, Kingdom, Phylum, Klass, Order, Family, Genus, Species]<EOL>assert len(names) == len(models), (names, models)<EOL>parent = None<EOL>for name, model in zip(names, models):<EOL><INDENT>try:<EOL><INDENT>obj = model.objects.get(name=name)<EOL><DEDENT>except model.DoesNotExist:<EOL><INDENT>obj = model(name=name)<EOL><DEDENT>if parent:<EOL><INDENT>setattr(obj, parent.__class__.__name__.lower(), parent)<EOL><DEDENT>obj.save()<EOL>parent = obj<EOL><DEDENT>", "docstring": "Helper to create a complete tree.", "id": "f20125:c0:m0"}
{"signature": "def assertProcessed(self, model, results, orig, expected_annotations=()):", "body": "self.assertEqual(len(results), len(orig))<EOL>for index, item in enumerate(results):<EOL><INDENT>orig_item = orig[index]<EOL>for annotation in expected_annotations:<EOL><INDENT>setattr(orig_item, *annotation)<EOL><DEDENT>for field in model._meta.fields:<EOL><INDENT>self.assertEqual(<EOL>getattr(item, field.attname),<EOL>getattr(orig_item, field.attname)<EOL>)<EOL>self.assertEqual(<EOL>type(getattr(item, field.attname)),<EOL>type(getattr(orig_item, field.attname))<EOL>)<EOL><DEDENT><DEDENT>", "docstring": "Compare the results of a raw query against expected results", "id": "f20132:c0:m2"}
{"signature": "def _ext_backend_paths(self):", "body": "paths = []<EOL>for backend in settings.DATABASES.values():<EOL><INDENT>package = backend['<STR_LIT>'].split('<STR_LIT:.>')[<NUM_LIT:0>]<EOL>if package != '<STR_LIT>':<EOL><INDENT>backend_pkg = __import__(package)<EOL>backend_dir = os.path.dirname(backend_pkg.__file__)<EOL>paths.append(os.path.dirname(backend_dir))<EOL><DEDENT><DEDENT>return paths<EOL>", "docstring": "Returns the paths for any external backend packages.", "id": "f20161:c0:m4"}
{"signature": "def assertNoOutput(self, stream):", "body": "self.assertEqual(len(stream), <NUM_LIT:0>, \"<STR_LIT>\" % stream)<EOL>", "docstring": "Utility assertion: assert that the given stream is empty", "id": "f20161:c0:m8"}
{"signature": "def file_upload_echo_content(request):", "body": "def read_and_close(f):<EOL><INDENT>with f:<EOL><INDENT>return f.read().decode()<EOL><DEDENT><DEDENT>r = {k: read_and_close(f) for k, f in request.FILES.items()}<EOL>return JsonResponse(r)<EOL>", "docstring": "Simple view to echo back the content of uploaded files for tests.", "id": "f20240:m4"}
{"signature": "def file_upload_view(request):", "body": "form_data = request.POST.copy()<EOL>form_data.update(request.FILES)<EOL>if isinstance(form_data.get('<STR_LIT>'), UploadedFile) and isinstance(form_data['<STR_LIT:name>'], str):<EOL><INDENT>if os.path.dirname(form_data['<STR_LIT>'].name) != '<STR_LIT>':<EOL><INDENT>return HttpResponseServerError()<EOL><DEDENT>return HttpResponse('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>return HttpResponseServerError()<EOL><DEDENT>", "docstring": "A file upload can be updated into the POST dictionary.", "id": "f20240:m0"}
{"signature": "def get_ogr_db_string():", "body": "db = connections.databases['<STR_LIT:default>']<EOL>drivers = {<EOL>'<STR_LIT>': ('<STR_LIT>', \"<STR_LIT>\", '<STR_LIT:U+0020>'),<EOL>'<STR_LIT>': ('<STR_LIT>', '<STR_LIT>', '<STR_LIT:U+002C>'),<EOL>'<STR_LIT>': ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>}<EOL>db_engine = db['<STR_LIT>']<EOL>if db_engine not in drivers:<EOL><INDENT>return None<EOL><DEDENT>drv_name, db_str, param_sep = drivers[db_engine]<EOL>try:<EOL><INDENT>Driver(drv_name)<EOL><DEDENT>except GDALException:<EOL><INDENT>return None<EOL><DEDENT>if db['<STR_LIT>'] == \"<STR_LIT>\":<EOL><INDENT>return None<EOL><DEDENT>params = [db_str % {'<STR_LIT>': db['<STR_LIT>']}]<EOL>def add(key, template):<EOL><INDENT>value = db.get(key, None)<EOL>if value:<EOL><INDENT>params.append(template % value)<EOL><DEDENT><DEDENT>add('<STR_LIT>', \"<STR_LIT>\")<EOL>add('<STR_LIT>', \"<STR_LIT>\")<EOL>add('<STR_LIT>', \"<STR_LIT>\")<EOL>add('<STR_LIT>', \"<STR_LIT>\")<EOL>return param_sep.join(params)<EOL>", "docstring": "Construct the DB string that GDAL will use to inspect the database.\nGDAL will create its own connection to the database, so we re-use the\nconnection settings from the Django test.", "id": "f20289:m0"}
{"signature": "def strconvert(d):", "body": "return {str(k): v for k, v in d.items()}<EOL>", "docstring": "Converts all keys in dictionary to str type.", "id": "f20305:m1"}
{"signature": "def tuplize(seq):", "body": "if isinstance(seq, (list, tuple)):<EOL><INDENT>return tuple(tuplize(i) for i in seq)<EOL><DEDENT>return seq<EOL>", "docstring": "Turn all nested sequences to tuples in given sequence.", "id": "f20305:m0"}
{"signature": "def assertTextarea(self, geom, rendered):", "body": "self.assertIn('<STR_LIT>', rendered)<EOL>self.assertIn('<STR_LIT>', rendered)<EOL>ogr = geom.ogr<EOL>ogr.transform(<NUM_LIT>)<EOL>self.assertIn(escape(ogr.json), rendered)<EOL>", "docstring": "Makes sure the wkt and a textarea are in the content", "id": "f20334:c1:m2"}
{"signature": "@login_required<EOL>def get_view(request):", "body": "return HttpResponse(\"<STR_LIT>\")<EOL>", "docstring": "A simple login protected view", "id": "f20338:m2"}
{"signature": "def no_template_view(request):", "body": "return HttpResponse(\"<STR_LIT>\")<EOL>", "docstring": "A simple view that expects a GET request, and returns a rendered template", "id": "f20338:m0"}
{"signature": "def view_with_argument(request, name):", "body": "if name == '<STR_LIT>':<EOL><INDENT>return HttpResponse('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>return HttpResponse('<STR_LIT>' % name)<EOL><DEDENT>", "docstring": "A view that takes a string argument\n\n    The purpose of this view is to check that if a space is provided in\n    the argument, the test framework unescapes the %20 before passing\n    the value to the view.", "id": "f20338:m4"}
{"signature": "def render_template_multiple_times(request):", "body": "return HttpResponse(<EOL>render_to_string('<STR_LIT>') + render_to_string('<STR_LIT>'))<EOL>", "docstring": "A view that renders a template multiple times.", "id": "f20338:m20"}
{"signature": "def read_buffer(request):", "body": "return HttpResponse(request.read(<NUM_LIT>))<EOL>", "docstring": "A view that is requested with accesses request.read(LARGE_BUFFER).", "id": "f20338:m18"}
{"signature": "def read_all(request):", "body": "return HttpResponse(request.read())<EOL>", "docstring": "A view that is requested with accesses request.read().", "id": "f20338:m17"}
{"signature": "def check_headers(request):", "body": "return HttpResponse('<STR_LIT>' % request.META.get('<STR_LIT>', '<STR_LIT>'))<EOL>", "docstring": "A view that responds with value of the X-ARG-CHECK header", "id": "f20338:m15"}
{"signature": "@register.inclusion_tag('<STR_LIT>', takes_context=True)<EOL>def inclusion_no_params_with_context(context):", "body": "return {\"<STR_LIT:result>\": \"<STR_LIT>\" % context['<STR_LIT:value>']}<EOL>", "docstring": "Expected inclusion_no_params_with_context __doc__", "id": "f20541:m6"}
{"signature": "@register.inclusion_tag('<STR_LIT>')<EOL>def inclusion_two_params(one, two):", "body": "return {\"<STR_LIT:result>\": \"<STR_LIT>\" % (one, two)}<EOL>", "docstring": "Expected inclusion_two_params __doc__", "id": "f20541:m10"}
{"signature": "@register.simple_tag<EOL>def simple_two_params(one, two):", "body": "return \"<STR_LIT>\" % (one, two)<EOL>", "docstring": "Expected simple_two_params __doc__", "id": "f20545:m8"}
{"signature": "@register.simple_tag<EOL>def simple_one_default(one, two='<STR_LIT>'):", "body": "return \"<STR_LIT>\" % (one, two)<EOL>", "docstring": "Expected simple_one_default __doc__", "id": "f20545:m11"}
{"signature": "@register.simple_tag(takes_context=True)<EOL>def no_params_with_context(context):", "body": "return \"<STR_LIT>\" % context['<STR_LIT:value>']<EOL>", "docstring": "Expected no_params_with_context __doc__", "id": "f20545:m6"}
{"signature": "@register.simple_tag<EOL>def no_params():", "body": "return \"<STR_LIT>\"<EOL>", "docstring": "Expected no_params __doc__", "id": "f20545:m3"}
{"signature": "@register.simple_tag(takes_context=True)<EOL>def simple_tag_without_context_parameter(arg):", "body": "return \"<STR_LIT>\"<EOL>", "docstring": "Expected simple_tag_without_context_parameter __doc__", "id": "f20545:m15"}
{"signature": "def _collectstatic_output(self, **kwargs):", "body": "out = StringIO()<EOL>call_command('<STR_LIT>', interactive=False, verbosity=<NUM_LIT:3>, stdout=out, **kwargs)<EOL>return out.getvalue()<EOL>", "docstring": "Run collectstatic, and capture and return the output. We want to run\nthe command at highest verbosity, which is why we can't\njust call e.g. BaseCollectionTestCase.run_collectstatic()", "id": "f20615:c12:m0"}
{"signature": "def assertFormError(self, response, error):", "body": "form_errors = list(itertools.chain(*response.context['<STR_LIT>'].errors.values()))<EOL>self.assertIn(str(error), form_errors)<EOL>", "docstring": "Assert that error is found in response.context['form'] errors", "id": "f20623:c0:m3"}
{"signature": "def tearDown(self):", "body": "signals.user_logged_in.disconnect(self.listener_login)<EOL>signals.user_logged_out.disconnect(self.listener_logout)<EOL>signals.user_login_failed.disconnect(self.listener_login_failed)<EOL>", "docstring": "Disconnect the listeners", "id": "f20627:c0:m5"}
{"signature": "def create_dummy_user(self):", "body": "username = '<STR_LIT>'<EOL>email = '<STR_LIT>'<EOL>user = User.objects.create_user(username, email, '<STR_LIT>')<EOL>return (user, username, email)<EOL>", "docstring": "Create a user and return a tuple (user_object, username, email).", "id": "f20642:c7:m1"}
{"signature": "@never_cache<EOL>def remote_user_auth_view(request):", "body": "t = Template(\"<STR_LIT>\")<EOL>c = RequestContext(request, {})<EOL>return HttpResponse(t.render(c))<EOL>", "docstring": "Dummy view for remote user tests", "id": "f20649:m0"}
{"signature": "def configure_user(self, user):", "body": "user.email = '<STR_LIT>'<EOL>user.save()<EOL>return user<EOL>", "docstring": "Sets user's email address.", "id": "f20656:c4:m1"}
{"signature": "def setUp(self):", "body": "if os.path.exists(temp_storage_dir):<EOL><INDENT>shutil.rmtree(temp_storage_dir)<EOL><DEDENT>os.mkdir(temp_storage_dir)<EOL>file_path1 = os.path.join(os.path.dirname(__file__), '<STR_LIT>')<EOL>self.file1 = self.File(open(file_path1, '<STR_LIT:rb>'), name='<STR_LIT>')<EOL>file_path2 = os.path.join(os.path.dirname(__file__), '<STR_LIT>')<EOL>self.file2 = self.File(open(file_path2, '<STR_LIT:rb>'), name='<STR_LIT>')<EOL>", "docstring": "Creates a pristine temp directory (or deletes and recreates if it\nalready exists) that the model uses as its storage directory.\n\nSets up two ImageFile instances for use in tests.", "id": "f20805:c0:m0"}
{"signature": "def custom_key_func(key, key_prefix, version):", "body": "return '<STR_LIT>' + '<STR_LIT:->'.join([key_prefix, str(version), key])<EOL>", "docstring": "A customized cache key function", "id": "f20820:m1"}
{"signature": "def assert_non_localized_year(self, response, year):", "body": "self.assertNotContains(response, formats.number_format(year))<EOL>", "docstring": "The year is not localized with USE_THOUSAND_SEPARATOR (#15234).", "id": "f20828:c34:m2"}
{"signature": "def assertMessageHasHeaders(self, message, headers):", "body": "if isinstance(message, bytes):<EOL><INDENT>message = message_from_bytes(message)<EOL><DEDENT>msg_headers = set(message.items())<EOL>self.assertTrue(headers.issubset(msg_headers), msg='<STR_LIT>'<EOL>'<STR_LIT>' % (headers - msg_headers),)<EOL>", "docstring": "Asserts that the `message` has all `headers`.\n\nmessage: can be an instance of an email.Message subclass or a string\n         with the contents of an email message.\nheaders: should be a set of (header-name, header-value) tuples.", "id": "f20830:c0:m0"}
{"signature": "def get_decoded_attachments(self, django_message):", "body": "msg_bytes = django_message.message().as_bytes()<EOL>email_message = message_from_bytes(msg_bytes)<EOL>def iter_attachments():<EOL><INDENT>for i in email_message.walk():<EOL><INDENT>if i.get_content_disposition() == '<STR_LIT>':<EOL><INDENT>filename = i.get_filename()<EOL>content = i.get_payload(decode=True)<EOL>mimetype = i.get_content_type()<EOL>yield filename, content, mimetype<EOL><DEDENT><DEDENT><DEDENT>return list(iter_attachments())<EOL>", "docstring": "Encode the specified django.core.mail.message.EmailMessage, then decode\nit using Python's email.parser module and, for each attachment of the\nmessage, return a list of tuples with (filename, content, mimetype).", "id": "f20830:c1:m0"}
{"signature": "def verify_safe_response(self, view, check_for_vars=True,<EOL>check_for_POST_params=True):", "body": "request = self.rf.post('<STR_LIT>', self.breakfast_data)<EOL>response = view(request)<EOL>if check_for_vars:<EOL><INDENT>self.assertContains(response, '<STR_LIT>', status_code=<NUM_LIT>)<EOL>self.assertContains(response, '<STR_LIT>', status_code=<NUM_LIT>)<EOL>self.assertContains(response, '<STR_LIT>', status_code=<NUM_LIT>)<EOL>self.assertNotContains(response, '<STR_LIT>', status_code=<NUM_LIT>)<EOL><DEDENT>if check_for_POST_params:<EOL><INDENT>for k in self.breakfast_data:<EOL><INDENT>self.assertContains(response, k, status_code=<NUM_LIT>)<EOL><DEDENT>self.assertContains(response, '<STR_LIT>', status_code=<NUM_LIT>)<EOL>self.assertContains(response, '<STR_LIT>', status_code=<NUM_LIT>)<EOL>self.assertNotContains(response, '<STR_LIT>', status_code=<NUM_LIT>)<EOL>self.assertNotContains(response, '<STR_LIT>', status_code=<NUM_LIT>)<EOL><DEDENT>", "docstring": "Asserts that certain sensitive info are not displayed in the response.", "id": "f20833:c8:m1"}
{"signature": "def assertLocationCommentNotPresent(self, po_filename, line_number, *comment_parts):", "body": "return self._assertPoLocComment(False, po_filename, line_number, *comment_parts)<EOL>", "docstring": "Check the opposite of assertLocationComment()", "id": "f20854:c0:m7"}
{"signature": "def _set_times_for_all_po_files(self):", "body": "for locale in self.LOCALES:<EOL><INDENT>os.utime(self.PO_FILE % locale, (<NUM_LIT:0>, <NUM_LIT:0>))<EOL><DEDENT>", "docstring": "Set access and modification times to the Unix epoch time for all the .po files.", "id": "f20854:c10:m0"}
{"signature": "def make_project_state(self, model_states):", "body": "project_state = ProjectState()<EOL>for model_state in model_states:<EOL><INDENT>project_state.add_model(model_state.clone())<EOL><DEDENT>return project_state<EOL>", "docstring": "Shortcut to make ProjectStates from lists of predefined models", "id": "f20953:c1:m6"}
{"signature": "def check_attribute(self, name, paginator, expected, params, coerce=None):", "body": "got = getattr(paginator, name)<EOL>if coerce is not None:<EOL><INDENT>got = coerce(got)<EOL><DEDENT>self.assertEqual(<EOL>expected, got,<EOL>\"<STR_LIT>\"<EOL>% (name, expected, got, params)<EOL>)<EOL>", "docstring": "Helper method that checks a single attribute and gives a nice error\nmessage upon test failure.", "id": "f20979:c0:m1"}
{"signature": "def check_indexes(self, params, page_num, indexes):", "body": "paginator = Paginator(*params)<EOL>if page_num == '<STR_LIT>':<EOL><INDENT>page_num = <NUM_LIT:1><EOL><DEDENT>elif page_num == '<STR_LIT>':<EOL><INDENT>page_num = paginator.num_pages<EOL><DEDENT>page = paginator.page(page_num)<EOL>start, end = indexes<EOL>msg = (\"<STR_LIT>\")<EOL>self.assertEqual(start, page.start_index(), msg % ('<STR_LIT>', page_num, start, page.start_index(), params))<EOL>self.assertEqual(end, page.end_index(), msg % ('<STR_LIT>', page_num, end, page.end_index(), params))<EOL>", "docstring": "Helper method that instantiates a Paginator object from the passed\nparams and then checks that the start and end indexes of the passed\npage_num match those given as a 2-tuple in indexes.", "id": "f20979:c0:m7"}
{"signature": "def assertProcessed(self, model, results, orig, expected_annotations=()):", "body": "self.assertEqual(len(results), len(orig))<EOL>for index, item in enumerate(results):<EOL><INDENT>orig_item = orig[index]<EOL>for annotation in expected_annotations:<EOL><INDENT>setattr(orig_item, *annotation)<EOL><DEDENT>for field in model._meta.fields:<EOL><INDENT>self.assertEqual(<EOL>getattr(item, field.attname),<EOL>getattr(orig_item, field.attname)<EOL>)<EOL>self.assertEqual(<EOL>type(getattr(item, field.attname)),<EOL>type(getattr(orig_item, field.attname))<EOL>)<EOL><DEDENT><DEDENT>", "docstring": "Compare the results of a raw query against expected results", "id": "f20992:c0:m2"}
{"signature": "def _ext_backend_paths(self):", "body": "paths = []<EOL>for backend in settings.DATABASES.values():<EOL><INDENT>package = backend['<STR_LIT>'].split('<STR_LIT:.>')[<NUM_LIT:0>]<EOL>if package != '<STR_LIT>':<EOL><INDENT>backend_pkg = __import__(package)<EOL>backend_dir = os.path.dirname(backend_pkg.__file__)<EOL>paths.append(os.path.dirname(backend_dir))<EOL><DEDENT><DEDENT>return paths<EOL>", "docstring": "Returns the paths for any external backend packages.", "id": "f20996:c0:m4"}
{"signature": "def assertMapWidget(self, form_instance):", "body": "self.assertTrue(form_instance.is_valid())<EOL>rendered = form_instance.as_p()<EOL>self.assertIn('<STR_LIT>', rendered)<EOL>self.assertIn('<STR_LIT>', rendered)<EOL>self.assertIn('<STR_LIT>', str(form_instance.media))<EOL>", "docstring": "Make sure the MapWidget js is passed in the form media and a MapWidget\nis actually created", "id": "f21031:c1:m1"}
{"signature": "def setUp(self):", "body": "<EOL>self.response_form_errors = self.getResponse({<EOL>'<STR_LIT>': '<STR_LIT:2>',<EOL>'<STR_LIT>': '<STR_LIT:2>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': '<STR_LIT:b>',<EOL>'<STR_LIT>': ('<STR_LIT:b>', '<STR_LIT:c>', '<STR_LIT:e>'),<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': '<STR_LIT:b>',<EOL>'<STR_LIT>': ('<STR_LIT:b>', '<STR_LIT:c>', '<STR_LIT:e>'),<EOL>})<EOL>self.response_nonform_errors = self.getResponse({<EOL>'<STR_LIT>': '<STR_LIT:2>',<EOL>'<STR_LIT>': '<STR_LIT:2>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': '<STR_LIT:b>',<EOL>'<STR_LIT>': ('<STR_LIT:b>', '<STR_LIT:c>', '<STR_LIT:e>'),<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': <NUM_LIT>,<EOL>'<STR_LIT>': '<STR_LIT:b>',<EOL>'<STR_LIT>': ('<STR_LIT:b>', '<STR_LIT:c>', '<STR_LIT:e>'),<EOL>})<EOL>", "docstring": "Makes response object for testing field and non-field errors", "id": "f21033:c5:m0"}
{"signature": "def assert_delayed(self, obj, num):", "body": "count = len(obj.get_deferred_fields())<EOL>self.assertEqual(count, num)<EOL>", "docstring": "Instances with deferred fields look the same as normal instances when\nwe examine attribute values. Therefore, this method returns the number\nof deferred fields on returned instances.", "id": "f21035:c0:m0"}
{"signature": "def cxOracle_py3_bug(func):", "body": "from unittest import expectedFailure<EOL>from django.db import connection<EOL>return expectedFailure(func) if connection.vendor == '<STR_LIT>' else func<EOL>", "docstring": "There's a bug in Django/cx_Oracle with respect to string handling under\nPython 3 (essentially, they treat Python 3 strings as Python 2 strings\nrather than unicode). This makes some tests here fail under Python 3, so\nwe mark them as expected failures until someone fixes them in #23843.", "id": "f21036:m0"}
{"signature": "def make_field_type_asserter(self):", "body": "out = StringIO()<EOL>call_command('<STR_LIT>', '<STR_LIT>', stdout=out)<EOL>output = out.getvalue()<EOL>def assertFieldType(name, definition):<EOL><INDENT>out_def = re.search(r'<STR_LIT>' % name, output, re.MULTILINE).groups()[<NUM_LIT:0>]<EOL>self.assertEqual(definition, out_def)<EOL><DEDENT>return assertFieldType<EOL>", "docstring": "Call inspectdb and return a function to validate a field type in its output", "id": "f21043:c0:m2"}
{"signature": "@register.simple_tag(takes_context=True)<EOL>def escape_format_html(context):", "body": "return format_html(\"<STR_LIT>\", context['<STR_LIT:name>'])<EOL>", "docstring": "A tag that uses format_html", "id": "f21072:m19"}
{"signature": "@register.simple_tag(takes_context=True)<EOL>def params_and_context(context, arg):", "body": "return \"<STR_LIT>\" % (context['<STR_LIT:value>'], arg)<EOL>", "docstring": "Expected params_and_context __doc__", "id": "f21072:m8"}
{"signature": "@register.filter<EOL>def noop(value, param=None):", "body": "return value<EOL>", "docstring": "A noop filter that always return its first argument and does nothing with\n    its second (optional) one.\n    Useful for testing out whitespace in filter arguments (see #19882).", "id": "f21072:m2"}
{"signature": "@register.simple_tag<EOL>def simple_unlimited_args(one, two='<STR_LIT>', *args):", "body": "return \"<STR_LIT>\" % (<EOL>'<STR_LIT:U+002CU+0020>'.join(str(arg) for arg in [one, two] + list(args))<EOL>)<EOL>", "docstring": "Expected simple_unlimited_args __doc__", "id": "f21072:m13"}
{"signature": "@register.simple_tag<EOL>def simple_unlimited_args_kwargs(one, two='<STR_LIT>', *args, **kwargs):", "body": "<EOL>sorted_kwarg = sorted(kwargs.items(), key=operator.itemgetter(<NUM_LIT:0>))<EOL>return \"<STR_LIT>\" % (<EOL>'<STR_LIT:U+002CU+0020>'.join(str(arg) for arg in [one, two] + list(args)),<EOL>'<STR_LIT:U+002CU+0020>'.join('<STR_LIT>' % (k, v) for (k, v) in sorted_kwarg)<EOL>)<EOL>", "docstring": "Expected simple_unlimited_args_kwargs __doc__", "id": "f21072:m15"}
{"signature": "@register.simple_tag(takes_context=False)<EOL>def explicit_no_context(arg):", "body": "return \"<STR_LIT>\" % arg<EOL>", "docstring": "Expected explicit_no_context __doc__", "id": "f21072:m6"}
{"signature": "@never_cache<EOL>def remote_user_auth_view(request):", "body": "t = Template(\"<STR_LIT>\")<EOL>c = RequestContext(request, {})<EOL>return HttpResponse(t.render(c))<EOL>", "docstring": "Dummy view for remote user tests", "id": "f21104:m0"}
{"signature": "def mock_inputs(inputs):", "body": "def inner(test_func):<EOL><INDENT>def wrapped(*args):<EOL><INDENT>class mock_getpass:<EOL><INDENT>@staticmethod<EOL>def getpass(prompt=b'<STR_LIT>', stream=None):<EOL><INDENT>if callable(inputs['<STR_LIT:password>']):<EOL><INDENT>return inputs['<STR_LIT:password>']()<EOL><DEDENT>return inputs['<STR_LIT:password>']<EOL><DEDENT><DEDENT>def mock_input(prompt):<EOL><INDENT>assert '<STR_LIT>' not in prompt<EOL>response = None<EOL>for key, val in inputs.items():<EOL><INDENT>prompt_msgs = MOCK_INPUT_KEY_TO_PROMPTS.get(key, key)<EOL>if isinstance(prompt_msgs, list):<EOL><INDENT>prompt_msgs = [msg() if callable(msg) else msg for msg in prompt_msgs]<EOL><DEDENT>if prompt in prompt_msgs:<EOL><INDENT>if callable(val):<EOL><INDENT>response = val()<EOL><DEDENT>else:<EOL><INDENT>response = val<EOL><DEDENT>break<EOL><DEDENT><DEDENT>if response is None:<EOL><INDENT>raise ValueError('<STR_LIT>' % prompt)<EOL><DEDENT>return response<EOL><DEDENT>old_getpass = createsuperuser.getpass<EOL>old_input = builtins.input<EOL>createsuperuser.getpass = mock_getpass<EOL>builtins.input = mock_input<EOL>try:<EOL><INDENT>test_func(*args)<EOL><DEDENT>finally:<EOL><INDENT>createsuperuser.getpass = old_getpass<EOL>builtins.input = old_input<EOL><DEDENT><DEDENT>return wrapped<EOL><DEDENT>return inner<EOL>", "docstring": "Decorator to temporarily replace input/getpass to allow interactive\ncreatesuperuser.", "id": "f21105:m0"}
{"signature": "def formfield(self, **kwargs):", "body": "defaults = {<EOL>'<STR_LIT>': ArrayFormField,<EOL>'<STR_LIT>': self.model_container,<EOL>'<STR_LIT>': self.model_form_class,<EOL>'<STR_LIT:name>': self.attname,<EOL>'<STR_LIT>': self.model_form_kwargs_l<EOL>}<EOL>defaults.update(kwargs)<EOL>return super().formfield(**defaults)<EOL>", "docstring": "Returns the formfield for the array.", "id": "f21176:c5:m5"}
{"signature": "def _apply_rel_filters(self, queryset):", "body": "queryset._add_hints(instance=self.instance)<EOL>if self._db:<EOL><INDENT>queryset = queryset.using(self._db)<EOL><DEDENT>queryset = queryset.filter(**self.core_filters)<EOL>return queryset<EOL>", "docstring": "Filter the queryset for the instance this manager is bound to.", "id": "f21176:c16:m0"}
{"signature": "def _set_autocommit(self, autocommit):", "body": "pass<EOL>", "docstring": "Default method must be overridden, eventhough not used.\n\nTODO: For future reference, setting two phase commits and rollbacks\nmight require populating this method.", "id": "f21179:c2:m4"}
{"signature": "def create_cursor(self, name=None):", "body": "return Cursor(self.client_connection, self.connection, self.djongo_connection)<EOL>", "docstring": "Returns an active connection cursor to the database.", "id": "f21179:c2:m6"}
{"signature": "def get_connection_params(self):", "body": "valid_settings = {<EOL>'<STR_LIT>': '<STR_LIT:name>',<EOL>'<STR_LIT>': '<STR_LIT:host>',<EOL>'<STR_LIT>': '<STR_LIT:port>',<EOL>'<STR_LIT>': '<STR_LIT:username>',<EOL>'<STR_LIT>': '<STR_LIT:password>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>'<EOL>}<EOL>connection_params = {<EOL>'<STR_LIT:name>': '<STR_LIT>',<EOL>'<STR_LIT>': True<EOL>}<EOL>for setting_name, kwarg in valid_settings.items():<EOL><INDENT>try:<EOL><INDENT>setting = self.settings_dict[setting_name]<EOL><DEDENT>except KeyError:<EOL><INDENT>continue<EOL><DEDENT>if setting or setting is False:<EOL><INDENT>connection_params[kwarg] = setting<EOL><DEDENT><DEDENT>return connection_params<EOL>", "docstring": "Default method to acquire database connection parameters.\n\nSets connection parameters to match settings.py, and sets\ndefault values to blank fields.", "id": "f21179:c2:m2"}
{"signature": "def OnFunButton(self, evt):", "body": "print(\"<STR_LIT>\")<EOL>", "docstring": "Event handler for the button click.", "id": "f21211:c0:m2"}
{"signature": "def print_wordfreq(freqs, n=<NUM_LIT:10>):", "body": "words, counts = freqs.keys(), freqs.values()<EOL>items = zip(counts, words)<EOL>items.sort(reverse=True)<EOL>for (count, word) in items[:n]:<EOL><INDENT>print(word, count)<EOL><DEDENT>", "docstring": "Print the n most common words and counts in the freqs dict.", "id": "f21222:m1"}
{"signature": "def serialize(self, obj):", "body": "return [pickle.dumps(obj)]<EOL>", "docstring": "serialize objects.\n\n        Must return list of sendable buffers.\n\n        Can be extended for more efficient/noncopying serialization of numpy arrays, etc.", "id": "f21226:c0:m4"}
{"signature": "def connect(self, peers, btree, pub_url, root_id=<NUM_LIT:0>):", "body": "<EOL>self.nchildren = list(btree.values()).count(self.id)<EOL>if self.root:<EOL><INDENT>return <EOL><DEDENT>root_location = peers[root_id][-<NUM_LIT:1>]<EOL>self.sub.connect(disambiguate_dns_url(pub_url, root_location))<EOL>parent = btree[self.id]<EOL>tree_url, location = peers[parent]<EOL>self.upstream.connect(disambiguate_dns_url(tree_url, location))<EOL>", "docstring": "connect to peers.  `peers` will be a dict of 4-tuples, keyed by name.\n        {peer : (ident, addr, pub_addr, location)}\n        where peer is the name, ident is the XREP identity, addr,pub_addr are the", "id": "f21226:c0:m3"}
{"signature": "def depth(n, tree):", "body": "d = <NUM_LIT:0><EOL>parent = tree[n]<EOL>while parent is not None:<EOL><INDENT>d += <NUM_LIT:1><EOL>parent = tree[parent]<EOL><DEDENT>return d<EOL>", "docstring": "get depth of an element in the tree", "id": "f21226:m2"}
{"signature": "@property<EOL><INDENT>def info(self):<DEDENT>", "body": "return (self.tree_url, self.location)<EOL>", "docstring": "return the connection info for this object's sockets.", "id": "f21226:c0:m2"}
{"signature": "def unserialize(self, msg):", "body": "return pickle.loads(msg[<NUM_LIT:0>])<EOL>", "docstring": "inverse of serialize", "id": "f21226:c0:m5"}
{"signature": "def send(client, sender, targets, msg_name, dest_name=None, block=None):", "body": "dest_name = msg_name if dest_name is None else dest_name<EOL>def _send(targets, m_name):<EOL><INDENT>msg = globals()[m_name]<EOL>return com.send(targets, msg)<EOL><DEDENT>client[sender].apply_async(_send, targets, msg_name)<EOL>return client[targets].execute('<STR_LIT>'%dest_name, block=None)<EOL>", "docstring": "send a message from one to one-or-more engines.", "id": "f21227:m1"}
{"signature": "def mul(a,b):", "body": "return a*b<EOL>", "docstring": "cumulative product reduction", "id": "f21228:m2"}
{"signature": "def downsample(array, k):", "body": "length = array.shape[<NUM_LIT:0>]<EOL>indices = random.sample(xrange(length), k)<EOL>return array[indices]<EOL>", "docstring": "Choose k random elements of array.", "id": "f21233:m1"}
{"signature": "def setup_solver(*args, **kwargs):", "body": "global solver<EOL>solver = WaveSolver(*args, **kwargs)<EOL>", "docstring": "create a WaveSolver in the engine namespace.", "id": "f21240:m1"}
{"signature": "def prepare_communication (self):", "body": "RectPartitioner.prepare_communication (self)<EOL>if self.lower_neighbors[<NUM_LIT:0>]>=<NUM_LIT:0>:<EOL><INDENT>self.in_lower_buffers = [zeros(<NUM_LIT:1>, float)]<EOL>self.out_lower_buffers = [zeros(<NUM_LIT:1>, float)]<EOL><DEDENT>if self.upper_neighbors[<NUM_LIT:0>]>=<NUM_LIT:0>:<EOL><INDENT>self.in_upper_buffers = [zeros(<NUM_LIT:1>, float)]<EOL>self.out_upper_buffers = [zeros(<NUM_LIT:1>, float)]<EOL><DEDENT>", "docstring": "Prepare the buffers to be used for later communications", "id": "f21241:c1:m0"}
{"signature": "def connect(self, south_peer=None, west_peer=None):", "body": "if south_peer is not None:<EOL><INDENT>location, url, _ = south_peer<EOL>self.south.connect(disambiguate_url(url, location))<EOL><DEDENT>if west_peer is not None:<EOL><INDENT>location, _, url = west_peer<EOL>self.west.connect(disambiguate_url(url, location))<EOL><DEDENT>", "docstring": "connect to peers.  `peers` will be a 3-tuples, of the form:\n        (location, north_addr, east_addr)\n        as produced by", "id": "f21243:c0:m3"}
{"signature": "def center_eigenvalue_diff(mat):", "body": "N = len(mat)<EOL>evals = np.sort(la.eigvals(mat))<EOL>diff = np.abs(evals[N/<NUM_LIT:2>] - evals[N/<NUM_LIT:2>-<NUM_LIT:1>])<EOL>return diff<EOL>", "docstring": "Compute the eigvals of mat and then find the center eigval difference.", "id": "f21250:m1"}
{"signature": "def price_options(S=<NUM_LIT>, K=<NUM_LIT>, sigma=<NUM_LIT>, r=<NUM_LIT>, days=<NUM_LIT>, paths=<NUM_LIT>):", "body": "import numpy as np<EOL>from math import exp,sqrt<EOL>h = <NUM_LIT:1.0>/days<EOL>const1 = exp((r-<NUM_LIT:0.5>*sigma**<NUM_LIT:2>)*h)<EOL>const2 = sigma*sqrt(h)<EOL>stock_price = S*np.ones(paths, dtype='<STR_LIT>')<EOL>stock_price_sum = np.zeros(paths, dtype='<STR_LIT>')<EOL>for j in range(days):<EOL><INDENT>growth_factor = const1*np.exp(const2*np.random.standard_normal(paths))<EOL>stock_price = stock_price*growth_factor<EOL>stock_price_sum = stock_price_sum + stock_price<EOL><DEDENT>stock_price_avg = stock_price_sum/days<EOL>zeros = np.zeros(paths, dtype='<STR_LIT>')<EOL>r_factor = exp(-r*h*days)<EOL>euro_put = r_factor*np.mean(np.maximum(zeros, K-stock_price))<EOL>asian_put = r_factor*np.mean(np.maximum(zeros, K-stock_price_avg))<EOL>euro_call = r_factor*np.mean(np.maximum(zeros, stock_price-K))<EOL>asian_call = r_factor*np.mean(np.maximum(zeros, stock_price_avg-K))<EOL>return (euro_call, euro_put, asian_call, asian_put)<EOL>", "docstring": "Price European and Asian options using a Monte Carlo method.\n\nParameters\n----------\nS : float\n    The initial price of the stock.\nK : float\n    The strike price of the option.\nsigma : float\n    The volatility of the stock.\nr : float\n    The risk free interest rate.\ndays : int\n    The number of days until the option expires.\npaths : int\n    The number of Monte Carlo paths used to price the option.\n\nReturns\n-------\nA tuple of (E. call, E. put, A. call, A. put) option prices.", "id": "f21252:m0"}
{"signature": "def one_digit_freqs(digits, normalize=False):", "body": "freqs = np.zeros(<NUM_LIT:10>, dtype='<STR_LIT>')<EOL>for d in digits:<EOL><INDENT>freqs[int(d)] += <NUM_LIT:1><EOL><DEDENT>if normalize:<EOL><INDENT>freqs = freqs/freqs.sum()<EOL><DEDENT>return freqs<EOL>", "docstring": "Consume digits of pi and compute 1 digit freq. counts.", "id": "f21253:m6"}
{"signature": "def addbuilddir():", "body": "from distutils.util import get_platform<EOL>s = \"<STR_LIT>\" % (get_platform(), sys.version)<EOL>if hasattr(sys, '<STR_LIT>'):<EOL><INDENT>s += '<STR_LIT>'<EOL><DEDENT>s = os.path.join(os.path.dirname(sys.path[-<NUM_LIT:1>]), s)<EOL>sys.path.append(s)<EOL>", "docstring": "Append ./build/lib.<platform> in case we're running in the build dir\n    (especially for Guido :-)", "id": "f21260:m3"}
{"signature": "def setencoding():", "body": "encoding = \"<STR_LIT:ascii>\" <EOL>if <NUM_LIT:0>:<EOL><INDENT>import locale<EOL>loc = locale.getdefaultlocale()<EOL>if loc[<NUM_LIT:1>]:<EOL><INDENT>encoding = loc[<NUM_LIT:1>]<EOL><DEDENT><DEDENT>if <NUM_LIT:0>:<EOL><INDENT>encoding = \"<STR_LIT>\"<EOL><DEDENT>if encoding != \"<STR_LIT:ascii>\":<EOL><INDENT>sys.setdefaultencoding(encoding)<EOL><DEDENT>", "docstring": "Set the string encoding used by the Unicode implementation.  The\n    default is 'ascii', but if you're willing to experiment, you can\n    change this.", "id": "f21260:m15"}
{"signature": "def force_global_eggs_after_local_site_packages():", "body": "egginsert = getattr(sys, '<STR_LIT>', <NUM_LIT:0>)<EOL>for i, path in enumerate(sys.path):<EOL><INDENT>if i > egginsert and path.startswith(sys.prefix):<EOL><INDENT>egginsert = i<EOL><DEDENT><DEDENT>sys.__egginsert = egginsert + <NUM_LIT:1><EOL>", "docstring": "Force easy_installed eggs in the global environment to get placed\nin sys.path after all packages inside the virtualenv.  This\nmaintains the \"least surprise\" result that packages in the\nvirtualenv always mask global packages, never the other way\naround.", "id": "f21260:m18"}
{"signature": "def addusersitepackages(known_paths):", "body": "global USER_BASE, USER_SITE, ENABLE_USER_SITE<EOL>env_base = os.environ.get(\"<STR_LIT>\", None)<EOL>def joinuser(*args):<EOL><INDENT>return os.path.expanduser(os.path.join(*args))<EOL><DEDENT>if os.name == \"<STR_LIT>\":<EOL><INDENT>base = os.environ.get(\"<STR_LIT>\") or \"<STR_LIT>\"<EOL>if env_base:<EOL><INDENT>USER_BASE = env_base<EOL><DEDENT>else:<EOL><INDENT>USER_BASE = joinuser(base, \"<STR_LIT>\")<EOL><DEDENT>USER_SITE = os.path.join(USER_BASE,<EOL>\"<STR_LIT>\" + sys.version[<NUM_LIT:0>] + sys.version[<NUM_LIT:2>],<EOL>\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>if env_base:<EOL><INDENT>USER_BASE = env_base<EOL><DEDENT>else:<EOL><INDENT>USER_BASE = joinuser(\"<STR_LIT>\", \"<STR_LIT>\")<EOL><DEDENT>USER_SITE = os.path.join(USER_BASE, \"<STR_LIT>\",<EOL>\"<STR_LIT>\" + sys.version[:<NUM_LIT:3>],<EOL>\"<STR_LIT>\")<EOL><DEDENT>if ENABLE_USER_SITE and os.path.isdir(USER_SITE):<EOL><INDENT>addsitedir(USER_SITE, known_paths)<EOL><DEDENT>if ENABLE_USER_SITE:<EOL><INDENT>for dist_libdir in (\"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>user_site = os.path.join(USER_BASE, dist_libdir,<EOL>\"<STR_LIT>\" + sys.version[:<NUM_LIT:3>],<EOL>\"<STR_LIT>\")<EOL>if os.path.isdir(user_site):<EOL><INDENT>addsitedir(user_site, known_paths)<EOL><DEDENT><DEDENT><DEDENT>return known_paths<EOL>", "docstring": "Add a per user site-package to sys.path\n\n    Each user has its own python directory with site-packages in the\n    home directory.\n\n    USER_BASE is the root directory for all Python versions\n\n    USER_SITE is the user specific site-packages directory\n\n    USER_SITE/.. can be used for data.", "id": "f21260:m9"}
{"signature": "def abs__file__():", "body": "for m in sys.modules.values():<EOL><INDENT>if ((_is_jython and not isinstance(m, ModuleType)) or<EOL>hasattr(m, '<STR_LIT>')):<EOL><INDENT>continue<EOL><DEDENT>f = getattr(m, '<STR_LIT>', None)<EOL>if f is None:<EOL><INDENT>continue<EOL><DEDENT>m.__file__ = os.path.abspath(f)<EOL><DEDENT>", "docstring": "Set all module' __file__ attribute to an absolute path", "id": "f21260:m1"}
{"signature": "def addpackage(sitedir, name, known_paths):", "body": "if known_paths is None:<EOL><INDENT>_init_pathinfo()<EOL>reset = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>reset = <NUM_LIT:0><EOL><DEDENT>fullname = os.path.join(sitedir, name)<EOL>try:<EOL><INDENT>f = open(fullname, \"<STR_LIT>\")<EOL><DEDENT>except IOError:<EOL><INDENT>return<EOL><DEDENT>try:<EOL><INDENT>for line in f:<EOL><INDENT>if line.startswith(\"<STR_LIT:#>\"):<EOL><INDENT>continue<EOL><DEDENT>if line.startswith(\"<STR_LIT>\"):<EOL><INDENT>exec(line)<EOL>continue<EOL><DEDENT>line = line.rstrip()<EOL>dir, dircase = makepath(sitedir, line)<EOL>if not dircase in known_paths and os.path.exists(dir):<EOL><INDENT>sys.path.append(dir)<EOL>known_paths.add(dircase)<EOL><DEDENT><DEDENT><DEDENT>finally:<EOL><INDENT>f.close()<EOL><DEDENT>if reset:<EOL><INDENT>known_paths = None<EOL><DEDENT>return known_paths<EOL>", "docstring": "Add a new path to known_paths by combining sitedir and 'name' or execute\n    sitedir if it starts with 'import", "id": "f21260:m5"}
{"signature": "def setcopyright():", "body": "builtins.copyright = _Printer(\"<STR_LIT>\", sys.copyright)<EOL>if _is_jython:<EOL><INDENT>builtins.credits = _Printer(<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\")<EOL><DEDENT>elif _is_pypy:<EOL><INDENT>builtins.credits = _Printer(<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>builtins.credits = _Printer(\"<STR_LIT>\", \"\"\"<STR_LIT>\"\"\")<EOL><DEDENT>here = os.path.dirname(os.__file__)<EOL>builtins.license = _Printer(<EOL>\"<STR_LIT>\", \"<STR_LIT>\" % sys.version,<EOL>[\"<STR_LIT>\", \"<STR_LIT>\"],<EOL>[os.path.join(here, os.pardir), here, os.curdir])<EOL>", "docstring": "Set 'copyright' and 'credits' in __builtin__", "id": "f21260:m12"}
{"signature": "def untar_file(filename, location):", "body": "if not os.path.exists(location):<EOL><INDENT>os.makedirs(location)<EOL><DEDENT>if filename.lower().endswith('<STR_LIT>') or filename.lower().endswith('<STR_LIT>'):<EOL><INDENT>mode = '<STR_LIT>'<EOL><DEDENT>elif filename.lower().endswith('<STR_LIT>') or filename.lower().endswith('<STR_LIT>'):<EOL><INDENT>mode = '<STR_LIT>'<EOL><DEDENT>elif filename.lower().endswith('<STR_LIT>'):<EOL><INDENT>mode = '<STR_LIT:r>'<EOL><DEDENT>else:<EOL><INDENT>logger.warn('<STR_LIT>' % filename)<EOL>mode = '<STR_LIT>'<EOL><DEDENT>tar = tarfile.open(filename, mode)<EOL>try:<EOL><INDENT>leading = has_leading_dir([<EOL>member.name for member in tar.getmembers()<EOL>if member.name != '<STR_LIT>'<EOL>])<EOL>for member in tar.getmembers():<EOL><INDENT>fn = member.name<EOL>if fn == '<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>if leading:<EOL><INDENT>fn = split_leading_dir(fn)[<NUM_LIT:1>]<EOL><DEDENT>path = os.path.join(location, fn)<EOL>if member.isdir():<EOL><INDENT>if not os.path.exists(path):<EOL><INDENT>os.makedirs(path)<EOL><DEDENT><DEDENT>elif member.issym():<EOL><INDENT>try:<EOL><INDENT>tar._extract_member(member, path)<EOL><DEDENT>except:<EOL><INDENT>e = sys.exc_info()[<NUM_LIT:1>]<EOL>logger.warn(<EOL>'<STR_LIT>'<EOL>% (filename, member.name, e))<EOL>continue<EOL><DEDENT><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>fp = tar.extractfile(member)<EOL><DEDENT>except (KeyError, AttributeError):<EOL><INDENT>e = sys.exc_info()[<NUM_LIT:1>]<EOL>logger.warn(<EOL>'<STR_LIT>'<EOL>% (filename, member.name, e))<EOL>continue<EOL><DEDENT>if not os.path.exists(os.path.dirname(path)):<EOL><INDENT>os.makedirs(os.path.dirname(path))<EOL><DEDENT>destfp = open(path, '<STR_LIT:wb>')<EOL>try:<EOL><INDENT>shutil.copyfileobj(fp, destfp)<EOL><DEDENT>finally:<EOL><INDENT>destfp.close()<EOL><DEDENT>fp.close()<EOL><DEDENT><DEDENT><DEDENT>finally:<EOL><INDENT>tar.close()<EOL><DEDENT>", "docstring": "Untar the file (tar file located at filename) to the destination location", "id": "f21261:m29"}
{"signature": "def is_local(path):", "body": "if not running_under_virtualenv():<EOL><INDENT>return True<EOL><DEDENT>return normalize_path(path).startswith(normalize_path(sys.prefix))<EOL>", "docstring": "Return True if path is within sys.prefix, if we're running in a virtualenv.\n\nIf we're not in a virtualenv, all paths are considered \"local.\"", "id": "f21261:m20"}
{"signature": "def get_terminal_size():", "body": "def ioctl_GWINSZ(fd):<EOL><INDENT>try:<EOL><INDENT>import fcntl<EOL>import termios<EOL>import struct<EOL>cr = struct.unpack('<STR_LIT>', fcntl.ioctl(fd, termios.TIOCGWINSZ,<EOL>'<STR_LIT>'))<EOL><DEDENT>except:<EOL><INDENT>return None<EOL><DEDENT>if cr == (<NUM_LIT:0>, <NUM_LIT:0>):<EOL><INDENT>return None<EOL><DEDENT>if cr == (<NUM_LIT:0>, <NUM_LIT:0>):<EOL><INDENT>return None<EOL><DEDENT>return cr<EOL><DEDENT>cr = ioctl_GWINSZ(<NUM_LIT:0>) or ioctl_GWINSZ(<NUM_LIT:1>) or ioctl_GWINSZ(<NUM_LIT:2>)<EOL>if not cr:<EOL><INDENT>try:<EOL><INDENT>fd = os.open(os.ctermid(), os.O_RDONLY)<EOL>cr = ioctl_GWINSZ(fd)<EOL>os.close(fd)<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if not cr:<EOL><INDENT>cr = (os.environ.get('<STR_LIT>', <NUM_LIT>), os.environ.get('<STR_LIT>', <NUM_LIT>))<EOL><DEDENT>return int(cr[<NUM_LIT:1>]), int(cr[<NUM_LIT:0>])<EOL>", "docstring": "Returns a tuple (x, y) representing the width(x) and the height(x)\n    in characters of the terminal window.", "id": "f21261:m27"}
{"signature": "def rmtree_errorhandler(func, path, exc_info):", "body": "exctype, value = exc_info[:<NUM_LIT:2>]<EOL>if not ((exctype is WindowsError and value.args[<NUM_LIT:0>] == <NUM_LIT:5>) or<EOL>(exctype is OSError and value.args[<NUM_LIT:0>] == <NUM_LIT>)):<EOL><INDENT>raise<EOL><DEDENT>if ((os.stat(path).st_mode & stat.S_IREAD) != stat.S_IREAD):<EOL><INDENT>raise<EOL><DEDENT>os.chmod(path, stat.S_IWRITE)<EOL>func(path)<EOL>", "docstring": "On Windows, the files in .svn are read-only, so when rmtree() tries to\n    remove them, an exception is thrown.  We catch that here, remove the\n    read-only attribute, and hopefully continue without problems.", "id": "f21261:m2"}
{"signature": "def dist_is_local(dist):", "body": "return is_local(dist_location(dist))<EOL>", "docstring": "Return True if given Distribution object is installed locally\n(i.e. within current virtualenv).\n\nAlways True if we're not in a virtualenv.", "id": "f21261:m21"}
{"signature": "def dist_in_site_packages(dist):", "body": "return normalize_path(dist_location(dist)).startswith(normalize_path(site_packages))<EOL>", "docstring": "Return True if given Distribution is installed in distutils.sysconfig.get_python_lib().", "id": "f21261:m23"}
{"signature": "def has_leading_dir(paths):", "body": "common_prefix = None<EOL>for path in paths:<EOL><INDENT>prefix, rest = split_leading_dir(path)<EOL>if not prefix:<EOL><INDENT>return False<EOL><DEDENT>elif common_prefix is None:<EOL><INDENT>common_prefix = prefix<EOL><DEDENT>elif prefix != common_prefix:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Returns true if all the paths have the same leading path name\n    (i.e., everything is in one subdirectory in an archive)", "id": "f21261:m15"}
{"signature": "def display_path(path):", "body": "path = os.path.normcase(os.path.abspath(path))<EOL>if path.startswith(os.getcwd() + os.path.sep):<EOL><INDENT>path = '<STR_LIT:.>' + path[len(os.getcwd()):]<EOL><DEDENT>return path<EOL>", "docstring": "Gives the display value for a given path, making it relative to cwd\n    if possible.", "id": "f21261:m3"}
{"signature": "def unzip_file(filename, location, flatten=True):", "body": "if not os.path.exists(location):<EOL><INDENT>os.makedirs(location)<EOL><DEDENT>zipfp = open(filename, '<STR_LIT:rb>')<EOL>try:<EOL><INDENT>zip = zipfile.ZipFile(zipfp)<EOL>leading = has_leading_dir(zip.namelist()) and flatten<EOL>for name in zip.namelist():<EOL><INDENT>data = zip.read(name)<EOL>fn = name<EOL>if leading:<EOL><INDENT>fn = split_leading_dir(name)[<NUM_LIT:1>]<EOL><DEDENT>fn = os.path.join(location, fn)<EOL>dir = os.path.dirname(fn)<EOL>if not os.path.exists(dir):<EOL><INDENT>os.makedirs(dir)<EOL><DEDENT>if fn.endswith('<STR_LIT:/>') or fn.endswith('<STR_LIT:\\\\>'):<EOL><INDENT>if not os.path.exists(fn):<EOL><INDENT>os.makedirs(fn)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>fp = open(fn, '<STR_LIT:wb>')<EOL>try:<EOL><INDENT>fp.write(data)<EOL><DEDENT>finally:<EOL><INDENT>fp.close()<EOL><DEDENT><DEDENT><DEDENT><DEDENT>finally:<EOL><INDENT>zipfp.close()<EOL><DEDENT>", "docstring": "Unzip the file (zip file located at filename) to the destination\n    location", "id": "f21261:m28"}
{"signature": "def get_url_rev(self):", "body": "if not '<STR_LIT>' in self.url:<EOL><INDENT>assert not '<STR_LIT>' in self.url<EOL>self.url = self.url.replace('<STR_LIT>', '<STR_LIT>')<EOL>url, rev = super(Git, self).get_url_rev()<EOL>url = url.replace('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>url, rev = super(Git, self).get_url_rev()<EOL><DEDENT>return url, rev<EOL>", "docstring": "Prefixes stub URLs like 'user@hostname:user/repo.git' with 'ssh://'.\nThat's required because although they use SSH they sometimes doesn't\nwork with a ssh:// scheme (e.g. Github). But we need a scheme for\nparsing. Hence we remove it again afterwards and return it as a stub.", "id": "f21262:c0:m12"}
{"signature": "def export(self, location):", "body": "url, rev = self.get_url_rev()<EOL>rev_options = get_rev_options(url, rev)<EOL>logger.notify('<STR_LIT>' % (url, location))<EOL>logger.indent += <NUM_LIT:2><EOL>try:<EOL><INDENT>if os.path.exists(location):<EOL><INDENT>rmtree(location)<EOL><DEDENT>call_subprocess(<EOL>[self.cmd, '<STR_LIT>'] + rev_options + [url, location],<EOL>filter_stdout=self._filter, show_stdout=False)<EOL><DEDENT>finally:<EOL><INDENT>logger.indent -= <NUM_LIT:2><EOL><DEDENT>", "docstring": "Export the svn repository at the url to the destination location", "id": "f21263:c0:m2"}
{"signature": "def get_revision(self, location):", "body": "<EOL>revision = <NUM_LIT:0><EOL>for base, dirs, files in os.walk(location):<EOL><INDENT>if self.dirname not in dirs:<EOL><INDENT>dirs[:] = []<EOL>continue    <EOL><DEDENT>dirs.remove(self.dirname)<EOL>entries_fn = os.path.join(base, self.dirname, '<STR_LIT>')<EOL>if not os.path.exists(entries_fn):<EOL><INDENT>continue<EOL><DEDENT>dirurl, localrev = self._get_svn_url_rev(base)<EOL>if base == location:<EOL><INDENT>base_url = dirurl+'<STR_LIT:/>'   <EOL><DEDENT>elif not dirurl or not dirurl.startswith(base_url):<EOL><INDENT>dirs[:] = []<EOL>continue    <EOL><DEDENT>revision = max(revision, localrev)<EOL><DEDENT>return revision<EOL>", "docstring": "Return the maximum revision for all files under a given location", "id": "f21263:c0:m7"}
{"signature": "def get_url_rev(self):", "body": "error_message= (<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>assert '<STR_LIT:+>' in self.url, error_message % self.url<EOL>url = self.url.split('<STR_LIT:+>', <NUM_LIT:1>)[<NUM_LIT:1>]<EOL>scheme, netloc, path, query, frag = urlparse.urlsplit(url)<EOL>rev = None<EOL>if '<STR_LIT:@>' in path:<EOL><INDENT>path, rev = path.rsplit('<STR_LIT:@>', <NUM_LIT:1>)<EOL><DEDENT>url = urlparse.urlunsplit((scheme, netloc, path, query, '<STR_LIT>'))<EOL>return url, rev<EOL>", "docstring": "Returns the correct repository URL and revision by parsing the given\nrepository URL", "id": "f21265:c1:m4"}
{"signature": "def update(self, dest, rev_options):", "body": "raise NotImplementedError<EOL>", "docstring": "Update an already-existing repo to the given ``rev_options``.", "id": "f21265:c1:m11"}
{"signature": "def obtain(self, dest):", "body": "raise NotImplementedError<EOL>", "docstring": "Called when installing or updating an editable package, takes the\nsource path of the checkout.", "id": "f21265:c1:m9"}
{"signature": "def is_archive_file(name):", "body": "archives = ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>ext = splitext(name)[<NUM_LIT:1>].lower()<EOL>if ext in archives:<EOL><INDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Return True if `name` is a considered as an archive file.", "id": "f21267:m6"}
{"signature": "def get_response(self, url, username=None, password=None):", "body": "scheme, netloc, path, query, frag = urlparse.urlsplit(url)<EOL>req = self.get_request(url)<EOL>stored_username, stored_password = self.passman.find_user_password(None, netloc)<EOL>if stored_username is None:<EOL><INDENT>if username is None and self.prompting:<EOL><INDENT>username = urllib.quote(raw_input('<STR_LIT>' % netloc))<EOL>password = urllib.quote(getpass.getpass('<STR_LIT>'))<EOL><DEDENT>if username and password:<EOL><INDENT>self.passman.add_password(None, netloc, username, password)<EOL><DEDENT>stored_username, stored_password = self.passman.find_user_password(None, netloc)<EOL><DEDENT>authhandler = urllib2.HTTPBasicAuthHandler(self.passman)<EOL>opener = urllib2.build_opener(authhandler)<EOL>return opener.open(req)<EOL>", "docstring": "does the dirty work of actually getting the rsponse object using urllib2\nand its HTTP auth builtins.", "id": "f21267:c0:m3"}
{"signature": "def _link_package_versions(self, link, search_name):", "body": "if link.egg_fragment:<EOL><INDENT>egg_info = link.egg_fragment<EOL><DEDENT>else:<EOL><INDENT>egg_info, ext = link.splitext()<EOL>if not ext:<EOL><INDENT>if link not in self.logged_links:<EOL><INDENT>logger.debug('<STR_LIT>' % link)<EOL>self.logged_links.add(link)<EOL><DEDENT>return []<EOL><DEDENT>if egg_info.endswith('<STR_LIT>'):<EOL><INDENT>egg_info = egg_info[:-<NUM_LIT:4>]<EOL>ext = '<STR_LIT>' + ext<EOL><DEDENT>if ext not in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>if link not in self.logged_links:<EOL><INDENT>logger.debug('<STR_LIT>' % (link, ext))<EOL>self.logged_links.add(link)<EOL><DEDENT>return []<EOL><DEDENT>if \"<STR_LIT>\" in link.path and ext == '<STR_LIT>':<EOL><INDENT>if link not in self.logged_links:<EOL><INDENT>logger.debug('<STR_LIT>' % (link))<EOL>self.logged_links.add(link)<EOL><DEDENT>return []<EOL><DEDENT><DEDENT>version = self._egg_info_matches(egg_info, search_name, link)<EOL>if version is None:<EOL><INDENT>logger.debug('<STR_LIT>' % (link, search_name))<EOL>return []<EOL><DEDENT>match = self._py_version_re.search(version)<EOL>if match:<EOL><INDENT>version = version[:match.start()]<EOL>py_version = match.group(<NUM_LIT:1>)<EOL>if py_version != sys.version[:<NUM_LIT:3>]:<EOL><INDENT>logger.debug('<STR_LIT>' % link)<EOL>return []<EOL><DEDENT><DEDENT>logger.debug('<STR_LIT>' % (link, version))<EOL>return [(pkg_resources.parse_version(version),<EOL>link,<EOL>version)]<EOL>", "docstring": "Return an iterable of triples (pkg_resources_version_key,\nlink, python_version) that can be extracted from the given\nlink.\n\nMeant to be overridden by subclasses, not called by clients.", "id": "f21268:c0:m9"}
{"signature": "def _get_pages(self, locations, req):", "body": "pending_queue = Queue()<EOL>for location in locations:<EOL><INDENT>pending_queue.put(location)<EOL><DEDENT>done = []<EOL>seen = set()<EOL>threads = []<EOL>for i in range(min(<NUM_LIT:10>, len(locations))):<EOL><INDENT>t = threading.Thread(target=self._get_queued_page, args=(req, pending_queue, done, seen))<EOL>t.setDaemon(True)<EOL>threads.append(t)<EOL>t.start()<EOL><DEDENT>for t in threads:<EOL><INDENT>t.join()<EOL><DEDENT>return done<EOL>", "docstring": "Yields (page, page_url) from the given locations, skipping\n        locations that have errors, and adding download/homepage links", "id": "f21268:c0:m5"}
{"signature": "def _show_progress(self):", "body": "return (self.stdout_level_matches(self.NOTIFY) and sys.stdout.isatty())<EOL>", "docstring": "Should we display download progress?", "id": "f21269:c0:m8"}
{"signature": "def _stdout_level(self):", "body": "for level, consumer in self.consumers:<EOL><INDENT>if consumer is sys.stdout:<EOL><INDENT>return level<EOL><DEDENT><DEDENT>return self.FATAL<EOL>", "docstring": "Returns the level that stdout runs at", "id": "f21269:c0:m13"}
{"signature": "def check_if_exists(self):", "body": "if self.req is None:<EOL><INDENT>return False<EOL><DEDENT>try:<EOL><INDENT>self.satisfied_by = pkg_resources.get_distribution(self.req)<EOL><DEDENT>except pkg_resources.DistributionNotFound:<EOL><INDENT>return False<EOL><DEDENT>except pkg_resources.VersionConflict:<EOL><INDENT>existing_dist = pkg_resources.get_distribution(self.req.project_name)<EOL>if self.use_user_site:<EOL><INDENT>if dist_in_usersite(existing_dist):<EOL><INDENT>self.conflicts_with = existing_dist<EOL><DEDENT>elif running_under_virtualenv() and dist_in_site_packages(existing_dist):<EOL><INDENT>raise InstallationError(\"<STR_LIT>\"<EOL>%(existing_dist.project_name, existing_dist.location))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.conflicts_with = existing_dist<EOL><DEDENT><DEDENT>return True<EOL>", "docstring": "Find an installed distribution that satisfies or conflicts\n        with this requirement, and set self.satisfied_by or\n        self.conflicts_with appropriately.", "id": "f21273:c0:m30"}
{"signature": "def _permitted(self, path):", "body": "return is_local(path)<EOL>", "docstring": "Return True if the given path is one we are permitted to\nremove/modify, False otherwise.", "id": "f21273:c3:m1"}
{"signature": "def remove_temporary_source(self):", "body": "if self.is_bundle or os.path.exists(self.delete_marker_filename):<EOL><INDENT>logger.info('<STR_LIT>' % self.source_dir)<EOL>if self.source_dir:<EOL><INDENT>rmtree(self.source_dir)<EOL><DEDENT>self.source_dir = None<EOL><DEDENT>if self._temp_build_dir and os.path.exists(self._temp_build_dir):<EOL><INDENT>rmtree(self._temp_build_dir)<EOL><DEDENT>self._temp_build_dir = None<EOL>", "docstring": "Remove the source files from this requirement, if they are marked\n        for deletion", "id": "f21273:c0:m27"}
{"signature": "def compact(self, paths):", "body": "short_paths = set()<EOL>for path in sorted(paths, key=len):<EOL><INDENT>if not any([(path.startswith(shortpath) and<EOL>path[len(shortpath.rstrip(os.path.sep))] == os.path.sep)<EOL>for shortpath in short_paths]):<EOL><INDENT>short_paths.add(path)<EOL><DEDENT><DEDENT>return short_paths<EOL>", "docstring": "Compact a path set to contain the minimal number of paths\n        necessary to contain all paths in the set. If /a/path/ and\n        /a/path/to/a/file.txt are both in the set, leave only the\n        shorter path.", "id": "f21273:c3:m5"}
{"signature": "def transform_hits(hits):", "body": "packages = {}<EOL>for hit in hits:<EOL><INDENT>name = hit['<STR_LIT:name>']<EOL>summary = hit['<STR_LIT>']<EOL>version = hit['<STR_LIT:version>']<EOL>score = hit['<STR_LIT>']<EOL>if score is None:<EOL><INDENT>score = <NUM_LIT:0><EOL><DEDENT>if name not in packages.keys():<EOL><INDENT>packages[name] = {'<STR_LIT:name>': name, '<STR_LIT>': summary, '<STR_LIT>': [version], '<STR_LIT>': score}<EOL><DEDENT>else:<EOL><INDENT>packages[name]['<STR_LIT>'].append(version)<EOL>if version == highest_version(packages[name]['<STR_LIT>']):<EOL><INDENT>packages[name]['<STR_LIT>'] = summary<EOL>packages[name]['<STR_LIT>'] = score<EOL><DEDENT><DEDENT><DEDENT>package_list = sorted(packages.values(), key=lambda x: x['<STR_LIT>'], reverse=True)<EOL>return package_list<EOL>", "docstring": "The list from pypi is really a list of versions. We want a list of\npackages with the list of versions stored inline. This converts the\nlist from pypi into one we can use.", "id": "f21278:m0"}
{"signature": "def get_environ_vars(self, prefix='<STR_LIT>'):", "body": "for key, val in os.environ.items():<EOL><INDENT>if key.startswith(prefix):<EOL><INDENT>yield (key.replace(prefix, '<STR_LIT>').lower(), val)<EOL><DEDENT><DEDENT>", "docstring": "Returns a generator with all environmental vars with prefix PIP_", "id": "f21284:c2:m5"}
{"signature": "def _format_option_strings(self, option, mvarfmt='<STR_LIT>', optsep='<STR_LIT:U+002CU+0020>'):", "body": "opts = []<EOL>if option._short_opts:<EOL><INDENT>opts.append(option._short_opts[<NUM_LIT:0>])<EOL><DEDENT>if option._long_opts:<EOL><INDENT>opts.append(option._long_opts[<NUM_LIT:0>])<EOL><DEDENT>if len(opts) > <NUM_LIT:1>:<EOL><INDENT>opts.insert(<NUM_LIT:1>, optsep)<EOL><DEDENT>if option.takes_value():<EOL><INDENT>metavar = option.metavar or option.dest.lower()<EOL>opts.append(mvarfmt % metavar.upper())<EOL><DEDENT>return '<STR_LIT>'.join(opts)<EOL>", "docstring": "Return a comma-separated list of option strings and metavars.\n\n:param option:  tuple of (short opt, long opt), e.g: ('-f', '--format')\n:param mvarfmt: metavar format string - evaluated as mvarfmt % metavar\n:param optsep:  separator", "id": "f21284:c0:m2"}
{"signature": "def get_config_section(self, name):", "body": "if self.config.has_section(name):<EOL><INDENT>return self.config.items(name)<EOL><DEDENT>return []<EOL>", "docstring": "Get a section of a configuration", "id": "f21284:c2:m4"}
{"signature": "def open_logfile(filename, mode='<STR_LIT:a>'):", "body": "filename = os.path.expanduser(filename)<EOL>filename = os.path.abspath(filename)<EOL>dirname = os.path.dirname(filename)<EOL>if not os.path.exists(dirname):<EOL><INDENT>os.makedirs(dirname)<EOL><DEDENT>exists = os.path.exists(filename)<EOL>log_fp = open(filename, mode)<EOL>if exists:<EOL><INDENT>log_fp.write('<STR_LIT>' % ('<STR_LIT:->'*<NUM_LIT>))<EOL>log_fp.write('<STR_LIT>' % (sys.argv[<NUM_LIT:0>], time.strftime('<STR_LIT>')))<EOL><DEDENT>return log_fp<EOL>", "docstring": "Open the named log file in append mode.\n\n    If the file already exists, a separator will also be printed to\n    the file to separate past activity from current activity.", "id": "f21286:m1"}
{"signature": "def DateTimeDelta2literal(d, c):", "body": "return string_literal(format_TIMEDELTA(d),c)<EOL>", "docstring": "Format a DateTimeDelta object as a time.", "id": "f21292:m10"}
{"signature": "def mysql_timestamp_converter(s):", "body": "<EOL>if s[<NUM_LIT:4>] == '<STR_LIT:->': return DateTime_or_None(s)<EOL>s = s + \"<STR_LIT:0>\"*(<NUM_LIT>-len(s)) <EOL>parts = map(int, filter(None, (s[:<NUM_LIT:4>],s[<NUM_LIT:4>:<NUM_LIT:6>],s[<NUM_LIT:6>:<NUM_LIT:8>],<EOL>s[<NUM_LIT:8>:<NUM_LIT:10>],s[<NUM_LIT:10>:<NUM_LIT:12>],s[<NUM_LIT:12>:<NUM_LIT>])))<EOL>try:<EOL><INDENT>return Timestamp(*parts)<EOL><DEDENT>except (SystemExit, KeyboardInterrupt):<EOL><INDENT>raise<EOL><DEDENT>except:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Convert a MySQL TIMESTAMP to a Timestamp object.", "id": "f21292:m11"}
{"signature": "def TimestampFromTicks(ticks):", "body": "return datetime(*localtime(ticks)[:<NUM_LIT:6>])<EOL>", "docstring": "Convert UNIX ticks into a datetime instance.", "id": "f21292:m2"}
{"signature": "def TimeFromTicks(ticks):", "body": "return time(*localtime(ticks)[<NUM_LIT:3>:<NUM_LIT:6>])<EOL>", "docstring": "Convert UNIX ticks into a time instance.", "id": "f21292:m1"}
{"signature": "def show_warnings(self):", "body": "if self._server_version < (<NUM_LIT:4>,<NUM_LIT:1>): return ()<EOL>self.query(\"<STR_LIT>\")<EOL>r = self.store_result()<EOL>warnings = r.fetch_row(<NUM_LIT:0>)<EOL>return warnings<EOL>", "docstring": "Return detailed information about warnings as a\n        sequence of tuples of (Level, Code, Message). This\n        is only supported in MySQL-4.1 and up. If your server\n        is an earlier version, an empty sequence is returned.", "id": "f21302:c0:m8"}
{"signature": "def literal(self, o):", "body": "return self.escape(o, self.encoders)<EOL>", "docstring": "If o is a single object, returns an SQL literal as a string.\nIf o is a non-string sequence, the items of the sequence are\nconverted and returned as a sequence.\n\nNon-standard. For internal use; do not use this in your\napplications.", "id": "f21302:c0:m4"}
{"signature": "def defaulterrorhandler(connection, cursor, errorclass, errorvalue):", "body": "error = errorclass, errorvalue<EOL>if cursor:<EOL><INDENT>cursor.messages.append(error)<EOL><DEDENT>else:<EOL><INDENT>connection.messages.append(error)<EOL><DEDENT>del cursor<EOL>del connection<EOL>raise errorclass(errorvalue)<EOL>", "docstring": "If cursor is not None, (errorclass, errorvalue) is appended to\ncursor.messages; otherwise it is appended to\nconnection.messages. Then errorclass is raised with errorvalue as\nthe value.\n\nYou can override this with your own error handler by assigning it\nto the instance.", "id": "f21302:m0"}
{"signature": "def fetchone(self):", "body": "self._check_executed()<EOL>if self.rownumber >= len(self._rows): return None<EOL>result = self._rows[self.rownumber]<EOL>self.rownumber = self.rownumber+<NUM_LIT:1><EOL>return result<EOL>", "docstring": "Fetches a single row from the cursor. None indicates that\n        no more rows are available.", "id": "f21303:c1:m3"}
{"signature": "def nextset(self):", "body": "if self._executed:<EOL><INDENT>self.fetchall()<EOL><DEDENT>del self.messages[:]<EOL>db = self._get_db()<EOL>nr = db.next_result()<EOL>if nr == -<NUM_LIT:1>:<EOL><INDENT>return None<EOL><DEDENT>self._do_get_result()<EOL>self._post_get_result()<EOL>self._warning_check()<EOL>return <NUM_LIT:1><EOL>", "docstring": "Advance to the next result set.\n\n        Returns None if there are no more result sets.", "id": "f21303:c0:m5"}
{"signature": "@wrap_exceptions<EOL><INDENT>def get_process_cmdline(self):<DEDENT>", "body": "if not pid_exists(self.pid):<EOL><INDENT>raise NoSuchProcess(self.pid, self._process_name)<EOL><DEDENT>return _psutil_osx.get_process_cmdline(self.pid)<EOL>", "docstring": "Return process cmdline as a list of arguments.", "id": "f21306:c0:m3"}
{"signature": "@wrap_exceptions<EOL><INDENT>def get_open_files(self):<DEDENT>", "body": "if self.pid == <NUM_LIT:0>:<EOL><INDENT>return []<EOL><DEDENT>files = []<EOL>rawlist = _psutil_osx.get_process_open_files(self.pid)<EOL>for path, fd in rawlist:<EOL><INDENT>if isfile_strict(path):<EOL><INDENT>ntuple = nt_openfile(path, fd)<EOL>files.append(ntuple)<EOL><DEDENT><DEDENT>return files<EOL>", "docstring": "Return files opened by process.", "id": "f21306:c0:m15"}
{"signature": "@wrap_exceptions<EOL><INDENT>def get_ext_memory_info(self):<DEDENT>", "body": "rss, vms, pfaults, pageins = _psutil_osx.get_process_memory_info(self.pid)<EOL>return self._nt_ext_mem(rss, vms,<EOL>pfaults * _PAGESIZE,<EOL>pageins * _PAGESIZE)<EOL>", "docstring": "Return a tuple with the process' RSS and VMS size.", "id": "f21306:c0:m10"}
{"signature": "@wrap_exceptions<EOL><INDENT>def get_connections(self, kind='<STR_LIT>'):<DEDENT>", "body": "if kind not in conn_tmap:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>% (kind, '<STR_LIT:U+002CU+0020>'.join([repr(x) for x in conn_tmap])))<EOL><DEDENT>families, types = conn_tmap[kind]<EOL>ret = _psutil_osx.get_process_connections(self.pid, families, types)<EOL>return [nt_connection(*conn) for conn in ret]<EOL>", "docstring": "Return etwork connections opened by a process as a list of\n        namedtuples.", "id": "f21306:c0:m16"}
{"signature": "def swap_memory():", "body": "mem = _psutil_mswindows.get_virtual_mem()<EOL>total = mem[<NUM_LIT:2>]<EOL>free = mem[<NUM_LIT:3>]<EOL>used = total - free<EOL>percent = usage_percent(used, total, _round=<NUM_LIT:1>)<EOL>return nt_swapmeminfo(total, used, free, percent, <NUM_LIT:0>, <NUM_LIT:0>)<EOL>", "docstring": "Swap system memory as a (total, used, free, sin, sout) tuple.", "id": "f21307:m3"}
{"signature": "def virtual_memory():", "body": "mem = _psutil_mswindows.get_virtual_mem()<EOL>totphys, availphys, totpagef, availpagef, totvirt, freevirt = mem<EOL>total = totphys<EOL>avail = availphys<EOL>free = availphys<EOL>used = total - avail<EOL>percent = usage_percent((total - avail), total, _round=<NUM_LIT:1>)<EOL>return nt_virtmem_info(total, avail, percent, used, free)<EOL>", "docstring": "System virtual memory as a namedtuple.", "id": "f21307:m2"}
{"signature": "@wrap_exceptions<EOL><INDENT>def kill_process(self):<DEDENT>", "body": "return _psutil_mswindows.kill_process(self.pid)<EOL>", "docstring": "Terminates the process with the given PID.", "id": "f21307:c0:m9"}
{"signature": "@wrap_exceptions<EOL><INDENT>def get_process_ppid(self):<DEDENT>", "body": "return _psutil_mswindows.get_process_ppid(self.pid)<EOL>", "docstring": "Return process parent pid.", "id": "f21307:c0:m4"}
{"signature": "def wrap_exceptions(callable):", "body": "def wrapper(self, *args, **kwargs):<EOL><INDENT>try:<EOL><INDENT>return callable(self, *args, **kwargs)<EOL><DEDENT>except OSError:<EOL><INDENT>err = sys.exc_info()[<NUM_LIT:1>]<EOL>if err.errno in ACCESS_DENIED_SET:<EOL><INDENT>raise AccessDenied(self.pid, self._process_name)<EOL><DEDENT>if err.errno == errno.ESRCH:<EOL><INDENT>raise NoSuchProcess(self.pid, self._process_name)<EOL><DEDENT>raise<EOL><DEDENT><DEDENT>return wrapper<EOL>", "docstring": "Call callable into a try/except clause so that if a\n    WindowsError 5 AccessDenied exception is raised we translate it\n    into psutil.AccessDenied", "id": "f21307:m9"}
{"signature": "@wrap_exceptions<EOL><INDENT>def get_process_num_threads(self):<DEDENT>", "body": "return _psutil_bsd.get_process_num_threads(self.pid)<EOL>", "docstring": "Return the number of threads belonging to the process.", "id": "f21308:c0:m12"}
{"signature": "@wrap_exceptions<EOL><INDENT>def get_open_files(self):<DEDENT>", "body": "<EOL>if hasattr(_psutil_bsd, \"<STR_LIT>\"):<EOL><INDENT>rawlist = _psutil_bsd.get_process_open_files(self.pid)<EOL>return [nt_openfile(path, fd) for path, fd in rawlist]<EOL><DEDENT>else:<EOL><INDENT>lsof = _psposix.LsofParser(self.pid, self._process_name)<EOL>return lsof.get_process_open_files()<EOL><DEDENT>", "docstring": "Return files opened by process as a list of namedtuples.", "id": "f21308:c0:m16"}
{"signature": "@wrap_exceptions<EOL><INDENT>def get_process_cmdline(self):<DEDENT>", "body": "return _psutil_bsd.get_process_cmdline(self.pid)<EOL>", "docstring": "Return process cmdline as a list of arguments.", "id": "f21308:c0:m3"}
{"signature": "def swap_memory():", "body": "total, used, free, sin, sout =[x * _PAGESIZE for x in _psutil_bsd.get_swap_mem()]<EOL>percent = usage_percent(used, total, _round=<NUM_LIT:1>)<EOL>return nt_swapmeminfo(total, used, free, percent, sin, sout)<EOL>", "docstring": "System swap memory as (total, used, free, sin, sout) namedtuple.", "id": "f21308:m1"}
{"signature": "@wrap_exceptions<EOL><INDENT>def get_process_exe(self):<DEDENT>", "body": "return _psutil_bsd.get_process_exe(self.pid)<EOL>", "docstring": "Return process executable pathname.", "id": "f21308:c0:m2"}
{"signature": "@wrap_exceptions<EOL><INDENT>def get_connections(self, kind='<STR_LIT>'):<DEDENT>", "body": "if kind not in conn_tmap:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>% (kind, '<STR_LIT:U+002CU+0020>'.join([repr(x) for x in conn_tmap])))<EOL><DEDENT>families, types = conn_tmap[kind]<EOL>ret = _psutil_bsd.get_process_connections(self.pid, families, types)<EOL>return [nt_connection(*conn) for conn in ret]<EOL>", "docstring": "Return etwork connections opened by a process as a list of\n        namedtuples.", "id": "f21308:c0:m17"}
{"signature": "def deprecated(replacement=None):", "body": "def outer(fun):<EOL><INDENT>msg = \"<STR_LIT>\" % fun.__name__<EOL>if replacement is not None:<EOL><INDENT>msg += \"<STR_LIT>\" % replacement<EOL><DEDENT>if fun.__doc__ is None:<EOL><INDENT>fun.__doc__ = msg<EOL><DEDENT>@wraps(fun)<EOL>def inner(*args, **kwargs):<EOL><INDENT>warnings.warn(msg, category=DeprecationWarning, stacklevel=<NUM_LIT:2>)<EOL>return fun(*args, **kwargs)<EOL><DEDENT>return inner<EOL><DEDENT>return outer<EOL>", "docstring": "A decorator which can be used to mark functions as deprecated.", "id": "f21309:m2"}
{"signature": "def wait_pid(pid, timeout=None):", "body": "def check_timeout(delay):<EOL><INDENT>if timeout is not None:<EOL><INDENT>if time.time() >= stop_at:<EOL><INDENT>raise TimeoutExpired(pid)<EOL><DEDENT><DEDENT>time.sleep(delay)<EOL>return min(delay * <NUM_LIT:2>, <NUM_LIT>)<EOL><DEDENT>if timeout is not None:<EOL><INDENT>waitcall = lambda: os.waitpid(pid, os.WNOHANG)<EOL>stop_at = time.time() + timeout<EOL><DEDENT>else:<EOL><INDENT>waitcall = lambda: os.waitpid(pid, <NUM_LIT:0>)<EOL><DEDENT>delay = <NUM_LIT><EOL>while <NUM_LIT:1>:<EOL><INDENT>try:<EOL><INDENT>retpid, status = waitcall()<EOL><DEDENT>except OSError:<EOL><INDENT>err = sys.exc_info()[<NUM_LIT:1>]<EOL>if err.errno == errno.EINTR:<EOL><INDENT>delay = check_timeout(delay)<EOL>continue<EOL><DEDENT>elif err.errno == errno.ECHILD:<EOL><INDENT>while <NUM_LIT:1>:<EOL><INDENT>if pid_exists(pid):<EOL><INDENT>delay = check_timeout(delay)<EOL><DEDENT>else:<EOL><INDENT>return<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if retpid == <NUM_LIT:0>:<EOL><INDENT>delay = check_timeout(delay)<EOL>continue<EOL><DEDENT>if os.WIFSIGNALED(status):<EOL><INDENT>return os.WTERMSIG(status)<EOL><DEDENT>elif os.WIFEXITED(status):<EOL><INDENT>return os.WEXITSTATUS(status)<EOL><DEDENT>else:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Wait for process with pid 'pid' to terminate and return its\n    exit status code as an integer.\n\n    If pid is not a children of os.getpid() (current process) just\n    waits until the process disappears and return None.\n\n    If pid does not exist at all return None immediately.\n\n    Raise TimeoutExpired on timeout expired.", "id": "f21311:m1"}
{"signature": "def pid_exists(pid):", "body": "if not isinstance(pid, int):<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if pid < <NUM_LIT:0>:<EOL><INDENT>return False<EOL><DEDENT>try:<EOL><INDENT>os.kill(pid, <NUM_LIT:0>)<EOL><DEDENT>except OSError:<EOL><INDENT>e = sys.exc_info()[<NUM_LIT:1>]<EOL>return e.errno == errno.EPERM<EOL><DEDENT>else:<EOL><INDENT>return True<EOL><DEDENT>", "docstring": "Check whether pid exists in the current process table.", "id": "f21311:m0"}
{"signature": "def cpu_times(percpu=False):", "body": "if not percpu:<EOL><INDENT>return _psplatform.get_system_cpu_times()<EOL><DEDENT>else:<EOL><INDENT>return _psplatform.get_system_per_cpu_times()<EOL><DEDENT>", "docstring": "Return system-wide CPU times as a namedtuple object.\n    Every CPU time represents the time CPU has spent in the given mode.\n    The attributes availability varies depending on the platform.\n    Here follows a list of all available attributes:\n     - user\n     - system\n     - idle\n     - nice (UNIX)\n     - iowait (Linux)\n     - irq (Linux, FreeBSD)\n     - softirq (Linux)\n\n    When percpu is True return a list of nameduples for each CPU.\n    First element of the list refers to first CPU, second element\n    to second CPU and so on.\n    The order of the list is consistent across calls.", "id": "f21312:m1"}
{"signature": "def get_open_files(self):", "body": "return self._platform_impl.get_open_files()<EOL>", "docstring": "Return files opened by process as a list of namedtuples\n        including absolute file name and file descriptor number.", "id": "f21312:c0:m26"}
{"signature": "def get_users():", "body": "return _psplatform.get_system_users()<EOL>", "docstring": "Return users currently connected on the system as a list of\n    namedtuples including the following attributes.\n\n     - user: the name of the user\n     - terminal: the tty or pseudo-tty associated with the user, if any.\n     - host: the host name associated with the entry, if any.\n     - started: the creation time as a floating point number expressed in\n       seconds since the epoch.", "id": "f21312:m9"}
{"signature": "def disk_usage(path):", "body": "return _psplatform.get_disk_usage(path)<EOL>", "docstring": "Return disk usage statistics about the given path as a namedtuple\n    including total, used and free space expressed in bytes plus the\n    percentage usage.", "id": "f21312:m5"}
{"signature": "@cached_property<EOL><INDENT>def cmdline(self):<DEDENT>", "body": "return self._platform_impl.get_process_cmdline()<EOL>", "docstring": "The command line process has been called with.", "id": "f21312:c0:m9"}
{"signature": "def suspend(self):", "body": "<EOL>if not self.is_running():<EOL><INDENT>name = self._platform_impl._process_name<EOL>raise NoSuchProcess(self.pid, name)<EOL><DEDENT>if hasattr(self._platform_impl, \"<STR_LIT>\"):<EOL><INDENT>self._platform_impl.suspend_process()<EOL><DEDENT>else:<EOL><INDENT>self.send_signal(signal.SIGSTOP)<EOL><DEDENT>", "docstring": "Suspend process execution.", "id": "f21312:c0:m30"}
{"signature": "def get_children(self, recursive=False):", "body": "if not self.is_running():<EOL><INDENT>name = self._platform_impl._process_name<EOL>raise NoSuchProcess(self.pid, name)<EOL><DEDENT>ret = []<EOL>if not recursive:<EOL><INDENT>for p in process_iter():<EOL><INDENT>try:<EOL><INDENT>if p.ppid == self.pid:<EOL><INDENT>if self.create_time <= p.create_time:<EOL><INDENT>ret.append(p)<EOL><DEDENT><DEDENT><DEDENT>except NoSuchProcess:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>table = defaultdict(list)<EOL>for p in process_iter():<EOL><INDENT>try:<EOL><INDENT>table[p.ppid].append(p)<EOL><DEDENT>except NoSuchProcess:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>checkpids = [self.pid]<EOL>for pid in checkpids:<EOL><INDENT>for child in table[pid]:<EOL><INDENT>try:<EOL><INDENT>intime = self.create_time <= child.create_time<EOL><DEDENT>except NoSuchProcess:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>if intime:<EOL><INDENT>ret.append(child)<EOL>if child.pid not in checkpids:<EOL><INDENT>checkpids.append(child.pid)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>return ret<EOL>", "docstring": "Return the children of this process as a list of Process\n        objects.\n        If recursive is True return all the parent descendants.\n\n        Example (A == this process):\n\n         A \u2500\u2510\n            \u2502\n            \u251c\u2500 B (child) \u2500\u2510\n            \u2502             \u2514\u2500 X (grandchild) \u2500\u2510\n            \u2502                                \u2514\u2500 Y (great grandchild)\n            \u251c\u2500 C (child)\n            \u2514\u2500 D (child)\n\n        >>> p.get_children()\n        B, C, D\n        >>> p.get_children(recursive=True)\n        B, X, Y, C, D\n\n        Note that in the example above if process X disappears\n        process Y won't be returned either as the reference to\n        process A is lost.", "id": "f21312:c0:m19"}
{"signature": "def send_signal(self, sig):", "body": "<EOL>if not self.is_running():<EOL><INDENT>name = self._platform_impl._process_name<EOL>raise NoSuchProcess(self.pid, name)<EOL><DEDENT>if os.name == '<STR_LIT>':<EOL><INDENT>try:<EOL><INDENT>os.kill(self.pid, sig)<EOL><DEDENT>except OSError:<EOL><INDENT>err = sys.exc_info()[<NUM_LIT:1>]<EOL>name = self._platform_impl._process_name<EOL>if err.errno == errno.ESRCH:<EOL><INDENT>raise NoSuchProcess(self.pid, name)<EOL><DEDENT>if err.errno == errno.EPERM:<EOL><INDENT>raise AccessDenied(self.pid, name)<EOL><DEDENT>raise<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if sig == signal.SIGTERM:<EOL><INDENT>self._platform_impl.kill_process()<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>", "docstring": "Send a signal to process (see signal module constants).\n        On Windows only SIGTERM is valid and is treated as an alias\n        for kill().", "id": "f21312:c0:m29"}
{"signature": "def cpu_percent(interval=<NUM_LIT:0.1>, percpu=False):", "body": "global _last_cpu_times<EOL>global _last_per_cpu_times<EOL>blocking = interval is not None and interval > <NUM_LIT:0.0><EOL>def calculate(t1, t2):<EOL><INDENT>t1_all = sum(t1)<EOL>t1_busy = t1_all - t1.idle<EOL>t2_all = sum(t2)<EOL>t2_busy = t2_all - t2.idle<EOL>if t2_busy <= t1_busy:<EOL><INDENT>return <NUM_LIT:0.0><EOL><DEDENT>busy_delta = t2_busy - t1_busy<EOL>all_delta = t2_all - t1_all<EOL>busy_perc = (busy_delta / all_delta) * <NUM_LIT:100><EOL>return round(busy_perc, <NUM_LIT:1>)<EOL><DEDENT>if not percpu:<EOL><INDENT>if blocking:<EOL><INDENT>t1 = cpu_times()<EOL>time.sleep(interval)<EOL><DEDENT>else:<EOL><INDENT>t1 = _last_cpu_times<EOL><DEDENT>_last_cpu_times = cpu_times()<EOL>return calculate(t1, _last_cpu_times)<EOL><DEDENT>else:<EOL><INDENT>ret = []<EOL>if blocking:<EOL><INDENT>tot1 = cpu_times(percpu=True)<EOL>time.sleep(interval)<EOL><DEDENT>else:<EOL><INDENT>tot1 = _last_per_cpu_times<EOL><DEDENT>_last_per_cpu_times = cpu_times(percpu=True)<EOL>for t1, t2 in zip(tot1, _last_per_cpu_times):<EOL><INDENT>ret.append(calculate(t1, t2))<EOL><DEDENT>return ret<EOL><DEDENT>", "docstring": "Return a float representing the current system-wide CPU\n    utilization as a percentage.\n\n    When interval is > 0.0 compares system CPU times elapsed before\n    and after the interval (blocking).\n\n    When interval is 0.0 or None compares system CPU times elapsed\n    since last call or module import, returning immediately.\n    In this case is recommended for accuracy that this function be\n    called with at least 0.1 seconds between calls.\n\n    When percpu is True returns a list of floats representing the\n    utilization as a percentage for each CPU.\n    First element of the list refers to first CPU, second element\n    to second CPU and so on.\n    The order of the list is consistent across calls.", "id": "f21312:m2"}
{"signature": "def _get_boot_time():", "body": "f = open('<STR_LIT>', '<STR_LIT:r>')<EOL>try:<EOL><INDENT>for line in f:<EOL><INDENT>if line.startswith('<STR_LIT>'):<EOL><INDENT>return float(line.strip().split()[<NUM_LIT:1>])<EOL><DEDENT><DEDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>finally:<EOL><INDENT>f.close()<EOL><DEDENT>", "docstring": "Return system boot time (epoch in seconds)", "id": "f21313:m0"}
{"signature": "def disk_partitions(all=False):", "body": "phydevs = []<EOL>f = open(\"<STR_LIT>\", \"<STR_LIT:r>\")<EOL>try:<EOL><INDENT>for line in f:<EOL><INDENT>if not line.startswith(\"<STR_LIT>\"):<EOL><INDENT>phydevs.append(line.strip())<EOL><DEDENT><DEDENT><DEDENT>finally:<EOL><INDENT>f.close()<EOL><DEDENT>retlist = []<EOL>partitions = _psutil_linux.get_disk_partitions()<EOL>for partition in partitions:<EOL><INDENT>device, mountpoint, fstype, opts = partition<EOL>if device == '<STR_LIT:none>':<EOL><INDENT>device = '<STR_LIT>'<EOL><DEDENT>if not all:<EOL><INDENT>if device == '<STR_LIT>' or fstype not in phydevs:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>ntuple = nt_partition(device, mountpoint, fstype, opts)<EOL>retlist.append(ntuple)<EOL><DEDENT>return retlist<EOL>", "docstring": "Return mounted disk partitions as a list of nameduples", "id": "f21313:m8"}
{"signature": "def expect_list(self, pattern_list, timeout = -<NUM_LIT:1>, searchwindowsize = -<NUM_LIT:1>):", "body": "return self.expect_loop(searcher_re(pattern_list), timeout, searchwindowsize)<EOL>", "docstring": "This takes a list of compiled regular expressions and returns the\n        index into the pattern_list that matched the child output. The list may\n        also contain EOF or TIMEOUT (which are not compiled regular\n        expressions). This method is similar to the expect() method except that\n        expect_list() does not recompile the pattern list on every call. This\n        may help if you are trying to optimize for speed, otherwise just use\n        the expect() method.  This is called by expect(). If timeout==-1 then\n        the self.timeout value is used. If searchwindowsize==-1 then the\n        self.searchwindowsize value is used.", "id": "f21318:c3:m35"}
{"signature": "def sendeof(self):", "body": "<EOL>if hasattr(termios, '<STR_LIT>'):<EOL><INDENT>char = termios.tcgetattr(self.child_fd)[<NUM_LIT:6>][termios.VEOF]<EOL><DEDENT>else:<EOL><INDENT>char = chr(<NUM_LIT:4>)<EOL><DEDENT>self.send(char)<EOL>", "docstring": "This sends an EOF to the child. This sends a character which causes\n        the pending parent output buffer to be sent to the waiting child\n        program without waiting for end-of-line. If it is the first character\n        of the line, the read() in the user program returns 0, which signifies\n        end-of-file. This means to work as expected a sendeof() has to be\n        called at the beginning of a line. This method does not send a newline.\n        It is the responsibility of the caller to ensure the eof is sent at the\n        beginning of a line.", "id": "f21318:c3:m25"}
{"signature": "def waitnoecho (self, timeout=-<NUM_LIT:1>):", "body": "if timeout == -<NUM_LIT:1>:<EOL><INDENT>timeout = self.timeout<EOL><DEDENT>if timeout is not None:<EOL><INDENT>end_time = time.time() + timeout<EOL><DEDENT>while True:<EOL><INDENT>if not self.getecho():<EOL><INDENT>return True<EOL><DEDENT>if timeout < <NUM_LIT:0> and timeout is not None:<EOL><INDENT>return False<EOL><DEDENT>if timeout is not None:<EOL><INDENT>timeout = end_time - time.time()<EOL><DEDENT>time.sleep(<NUM_LIT:0.1>)<EOL><DEDENT>", "docstring": "This waits until the terminal ECHO flag is set False. This returns\n        True if the echo mode is off. This returns False if the ECHO flag was\n        not set False before the timeout. This can be used to detect when the\n        child is waiting for a password. Usually a child application will turn\n        off echo mode when it is waiting for the user to enter a password. For\n        example, instead of expecting the \"password:\" prompt you can wait for\n        the child to set ECHO off::\n\n            p = pexpect.spawn ('ssh user@example.com')\n            p.waitnoecho()\n            p.sendline(mypassword)\n\n        If timeout==-1 then this method will use the value in self.timeout.\n        If timeout==None then this method to block until ECHO flag is False.", "id": "f21318:c3:m11"}
{"signature": "def __str__(self):", "body": "s = []<EOL>s.append(repr(self))<EOL>s.append('<STR_LIT>' + __version__)<EOL>s.append('<STR_LIT>' + str(self.command))<EOL>s.append('<STR_LIT>' + str(self.args))<EOL>s.append('<STR_LIT>' + str(self.searcher))<EOL>s.append('<STR_LIT>' + str(self.buffer)[-<NUM_LIT:100>:])<EOL>s.append('<STR_LIT>' + str(self.before)[-<NUM_LIT:100>:])<EOL>s.append('<STR_LIT>' + str(self.after))<EOL>s.append('<STR_LIT>' + str(self.match))<EOL>s.append('<STR_LIT>' + str(self.match_index))<EOL>s.append('<STR_LIT>' + str(self.exitstatus))<EOL>s.append('<STR_LIT>' + str(self.flag_eof))<EOL>s.append('<STR_LIT>' + str(self.pid))<EOL>s.append('<STR_LIT>' + str(self.child_fd))<EOL>s.append('<STR_LIT>' + str(self.closed))<EOL>s.append('<STR_LIT>' + str(self.timeout))<EOL>s.append('<STR_LIT>' + str(self.delimiter))<EOL>s.append('<STR_LIT>' + str(self.logfile))<EOL>s.append('<STR_LIT>' + str(self.logfile_read))<EOL>s.append('<STR_LIT>' + str(self.logfile_send))<EOL>s.append('<STR_LIT>' + str(self.maxread))<EOL>s.append('<STR_LIT>' + str(self.ignorecase))<EOL>s.append('<STR_LIT>' + str(self.searchwindowsize))<EOL>s.append('<STR_LIT>' + str(self.delaybeforesend))<EOL>s.append('<STR_LIT>' + str(self.delayafterclose))<EOL>s.append('<STR_LIT>' + str(self.delayafterterminate))<EOL>return '<STR_LIT:\\n>'.join(s)<EOL>", "docstring": "This returns a human-readable string that represents the state of\n        the object.", "id": "f21318:c3:m3"}
{"signature": "def isalive(self):", "body": "if self.terminated:<EOL><INDENT>return False<EOL><DEDENT>if self.flag_eof:<EOL><INDENT>waitpid_options = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>waitpid_options = os.WNOHANG<EOL><DEDENT>try:<EOL><INDENT>pid, status = os.waitpid(self.pid, waitpid_options)<EOL><DEDENT>except OSError as e: <EOL><INDENT>if e.errno == errno.ECHILD:<EOL><INDENT>raise ExceptionPexpect ('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>raise e<EOL><DEDENT><DEDENT>if pid == <NUM_LIT:0>:<EOL><INDENT>try:<EOL><INDENT>pid, status = os.waitpid(self.pid, waitpid_options) <EOL><DEDENT>except OSError as e: <EOL><INDENT>if e[<NUM_LIT:0>] == errno.ECHILD:<EOL><INDENT>raise ExceptionPexpect ('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>raise e<EOL><DEDENT><DEDENT>if pid == <NUM_LIT:0>:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>if pid == <NUM_LIT:0>:<EOL><INDENT>return True<EOL><DEDENT>if os.WIFEXITED (status):<EOL><INDENT>self.status = status<EOL>self.exitstatus = os.WEXITSTATUS(status)<EOL>self.signalstatus = None<EOL>self.terminated = True<EOL><DEDENT>elif os.WIFSIGNALED (status):<EOL><INDENT>self.status = status<EOL>self.exitstatus = None<EOL>self.signalstatus = os.WTERMSIG(status)<EOL>self.terminated = True<EOL><DEDENT>elif os.WIFSTOPPED (status):<EOL><INDENT>raise ExceptionPexpect ('<STR_LIT>')<EOL><DEDENT>return False<EOL>", "docstring": "This tests if the child process is running or not. This is\n        non-blocking. If the child was terminated then this will read the\n        exitstatus or signalstatus of the child. This returns True if the child\n        process appears to be running or False if not. It can take literally\n        SECONDS for Solaris to return the right status.", "id": "f21318:c3:m30"}
{"signature": "def isatty (self):   ", "body": "return os.isatty(self.child_fd)<EOL>", "docstring": "This returns True if the file descriptor is open and connected to a\n        tty(-like) device, else False.", "id": "f21318:c3:m10"}
{"signature": "def get_trace(self):", "body": "tblist = traceback.extract_tb(sys.exc_info()[<NUM_LIT:2>])<EOL>tblist = [item for item in tblist if self.__filter_not_pexpect(item)]<EOL>tblist = traceback.format_list(tblist)<EOL>return '<STR_LIT>'.join(tblist)<EOL>", "docstring": "This returns an abbreviated stack trace with lines that only concern\n        the caller. In other words, the stack trace inside the Pexpect module\n        is not included.", "id": "f21318:c0:m2"}
{"signature": "def __str__(self):", "body": "ss =  [ (n,'<STR_LIT>' % (n,str(s.pattern))) for n,s in self._searches]<EOL>ss.append((-<NUM_LIT:1>,'<STR_LIT>'))<EOL>if self.eof_index >= <NUM_LIT:0>:<EOL><INDENT>ss.append ((self.eof_index,'<STR_LIT>' % self.eof_index))<EOL><DEDENT>if self.timeout_index >= <NUM_LIT:0>:<EOL><INDENT>ss.append ((self.timeout_index,'<STR_LIT>' % self.timeout_index))<EOL><DEDENT>ss.sort()<EOL>return '<STR_LIT:\\n>'.join(a[<NUM_LIT:1>] for a in ss)<EOL>", "docstring": "This returns a human-readable string that represents the state of\n        the object.", "id": "f21318:c6:m1"}
{"signature": "def __next__ (self):    ", "body": "result = self.readline()<EOL>if result == self._empty_buffer:<EOL><INDENT>raise StopIteration<EOL><DEDENT>return result<EOL>", "docstring": "This is to support iterators over a file-like object.", "id": "f21318:c3:m18"}
{"signature": "def _prepare_regex_pattern(self, p):", "body": "if isinstance(p.pattern, str):<EOL><INDENT>p = re.compile(p.pattern.encode('<STR_LIT:utf-8>'), p.flags &~ re.UNICODE)<EOL><DEDENT>return p<EOL>", "docstring": "Recompile unicode regexes as bytes regexes. Overridden in subclass.", "id": "f21318:c3:m33"}
{"signature": "def eof (self):", "body": "return self.flag_eof<EOL>", "docstring": "This returns True if the EOF exception was ever raised.", "id": "f21318:c3:m27"}
{"signature": "def terminate(self, force=False):", "body": "if not self.isalive():<EOL><INDENT>return True<EOL><DEDENT>try:<EOL><INDENT>self.kill(signal.SIGHUP)<EOL>time.sleep(self.delayafterterminate)<EOL>if not self.isalive():<EOL><INDENT>return True<EOL><DEDENT>self.kill(signal.SIGCONT)<EOL>time.sleep(self.delayafterterminate)<EOL>if not self.isalive():<EOL><INDENT>return True<EOL><DEDENT>self.kill(signal.SIGINT)<EOL>time.sleep(self.delayafterterminate)<EOL>if not self.isalive():<EOL><INDENT>return True<EOL><DEDENT>if force:<EOL><INDENT>self.kill(signal.SIGKILL)<EOL>time.sleep(self.delayafterterminate)<EOL>if not self.isalive():<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>return False<EOL><DEDENT>except OSError as e:<EOL><INDENT>time.sleep(self.delayafterterminate)<EOL>if not self.isalive():<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>", "docstring": "This forces a child process to terminate. It starts nicely with\n        SIGHUP and SIGINT. If \"force\" is True then moves onto SIGKILL. This\n        returns True if the child was terminated. This returns False if the\n        child could not be terminated.", "id": "f21318:c3:m28"}
{"signature": "def __pty_make_controlling_tty(self, tty_fd):", "body": "child_name = os.ttyname(tty_fd)<EOL>try:<EOL><INDENT>fd = os.open(\"<STR_LIT>\", os.O_RDWR | os.O_NOCTTY);<EOL>if fd >= <NUM_LIT:0>:<EOL><INDENT>os.close(fd)<EOL><DEDENT><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>os.setsid()<EOL>try:<EOL><INDENT>fd = os.open(\"<STR_LIT>\", os.O_RDWR | os.O_NOCTTY);<EOL>if fd >= <NUM_LIT:0>:<EOL><INDENT>os.close(fd)<EOL>raise ExceptionPexpect(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>fd = os.open(child_name, os.O_RDWR);<EOL>if fd < <NUM_LIT:0>:<EOL><INDENT>raise ExceptionPexpect(\"<STR_LIT>\" + child_name)<EOL><DEDENT>else:<EOL><INDENT>os.close(fd)<EOL><DEDENT>fd = os.open(\"<STR_LIT>\", os.O_WRONLY)<EOL>if fd < <NUM_LIT:0>:<EOL><INDENT>raise ExceptionPexpect(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>os.close(fd)<EOL><DEDENT>", "docstring": "This makes the pseudo-terminal the controlling tty. This should be\n        more portable than the pty.fork() function. Specifically, this should\n        work on Solaris.", "id": "f21318:c3:m6"}
{"signature": "def setwinsize(self, r, c):", "body": "<EOL>TIOCSWINSZ = getattr(termios, '<STR_LIT>', -<NUM_LIT>)<EOL>if TIOCSWINSZ == <NUM_LIT>: <EOL><INDENT>TIOCSWINSZ = -<NUM_LIT> <EOL><DEDENT>s = struct.pack('<STR_LIT>', r, c, <NUM_LIT:0>, <NUM_LIT:0>)<EOL>fcntl.ioctl(self.fileno(), TIOCSWINSZ, s)<EOL>", "docstring": "This sets the terminal window size of the child tty. This will cause\n        a SIGWINCH signal to be sent to the child. This does not change the\n        physical window size. It changes the size reported to TTY-aware\n        applications like vi or curses -- applications that respond to the\n        SIGWINCH signal.", "id": "f21318:c3:m39"}
{"signature": "def expect_loop(self, searcher, timeout = -<NUM_LIT:1>, searchwindowsize = -<NUM_LIT:1>):", "body": "self.searcher = searcher<EOL>if timeout == -<NUM_LIT:1>:<EOL><INDENT>timeout = self.timeout<EOL><DEDENT>if timeout is not None:<EOL><INDENT>end_time = time.time() + timeout<EOL><DEDENT>if searchwindowsize == -<NUM_LIT:1>:<EOL><INDENT>searchwindowsize = self.searchwindowsize<EOL><DEDENT>try:<EOL><INDENT>incoming = self.buffer<EOL>freshlen = len(incoming)<EOL>while True: <EOL><INDENT>index = searcher.search(incoming, freshlen, searchwindowsize)<EOL>if index >= <NUM_LIT:0>:<EOL><INDENT>self.buffer = incoming[searcher.end : ]<EOL>self.before = incoming[ : searcher.start]<EOL>self.after = incoming[searcher.start : searcher.end]<EOL>self.match = searcher.match<EOL>self.match_index = index<EOL>return self.match_index<EOL><DEDENT>if timeout is not None and timeout < <NUM_LIT:0>:<EOL><INDENT>raise TIMEOUT ('<STR_LIT>')<EOL><DEDENT>c = self.read_nonblocking (self.maxread, timeout)<EOL>freshlen = len(c)<EOL>time.sleep (<NUM_LIT>)<EOL>incoming = incoming + c<EOL>if timeout is not None:<EOL><INDENT>timeout = end_time - time.time()<EOL><DEDENT><DEDENT><DEDENT>except EOF as e:<EOL><INDENT>self.buffer = self._empty_buffer<EOL>self.before = incoming<EOL>self.after = EOF<EOL>index = searcher.eof_index<EOL>if index >= <NUM_LIT:0>:<EOL><INDENT>self.match = EOF<EOL>self.match_index = index<EOL>return self.match_index<EOL><DEDENT>else:<EOL><INDENT>self.match = None<EOL>self.match_index = None<EOL>raise EOF (str(e) + '<STR_LIT:\\n>' + str(self))<EOL><DEDENT><DEDENT>except TIMEOUT as e:<EOL><INDENT>self.buffer = incoming<EOL>self.before = incoming<EOL>self.after = TIMEOUT<EOL>index = searcher.timeout_index<EOL>if index >= <NUM_LIT:0>:<EOL><INDENT>self.match = TIMEOUT<EOL>self.match_index = index<EOL>return self.match_index<EOL><DEDENT>else:<EOL><INDENT>self.match = None<EOL>self.match_index = None<EOL>raise TIMEOUT (str(e) + '<STR_LIT:\\n>' + str(self))<EOL><DEDENT><DEDENT>except:<EOL><INDENT>self.before = incoming<EOL>self.after = None<EOL>self.match = None<EOL>self.match_index = None<EOL>raise<EOL><DEDENT>", "docstring": "This is the common loop used inside expect. The 'searcher' should be\n        an instance of searcher_re or searcher_string, which describes how and what\n        to search for in the input.\n\n        See expect() for other arguments, return value and exceptions.", "id": "f21318:c3:m37"}
{"signature": "def writelines (self, sequence):   ", "body": "for s in sequence:<EOL><INDENT>self.write (s)<EOL><DEDENT>", "docstring": "This calls write() for each element in the sequence. The sequence\n        can be any iterable object producing strings, typically a list of\n        strings. This does not add line separators There is no return value.", "id": "f21318:c3:m21"}
{"signature": "def generic(func):", "body": "_sentinel = object()<EOL>def _by_class(*args, **kw):<EOL><INDENT>cls = args[<NUM_LIT:0>].__class__<EOL>for t in type(cls.__name__, (cls,object), {}).__mro__:<EOL><INDENT>f = _gbt(t, _sentinel)<EOL>if f is not _sentinel:<EOL><INDENT>return f(*args, **kw)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return func(*args, **kw)<EOL><DEDENT><DEDENT>_by_type = {object: func}<EOL>try:<EOL><INDENT>_by_type[InstanceType] = _by_class<EOL><DEDENT>except NameError:   <EOL><INDENT>pass<EOL><DEDENT>_gbt = _by_type.get<EOL>def when_type(*types):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>for t in types:<EOL><INDENT>if not isinstance(t, classtypes):<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\" % (t,)<EOL>)<EOL><DEDENT><DEDENT>def decorate(f):<EOL><INDENT>for t in types:<EOL><INDENT>if _by_type.setdefault(t,f) is not f:<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\" % (func, t)<EOL>)<EOL><DEDENT><DEDENT>return f<EOL><DEDENT>return decorate<EOL><DEDENT>_by_object = {}<EOL>_gbo = _by_object.get<EOL>def when_object(*obs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>def decorate(f):<EOL><INDENT>for o in obs:<EOL><INDENT>if _by_object.setdefault(id(o), (o,f))[<NUM_LIT:1>] is not f:<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\" % (func, o)<EOL>)<EOL><DEDENT><DEDENT>return f<EOL><DEDENT>return decorate<EOL><DEDENT>def dispatch(*args, **kw):<EOL><INDENT>f = _gbo(id(args[<NUM_LIT:0>]), _sentinel)<EOL>if f is _sentinel:<EOL><INDENT>for t in type(args[<NUM_LIT:0>]).__mro__:<EOL><INDENT>f = _gbt(t, _sentinel)<EOL>if f is not _sentinel:<EOL><INDENT>return f(*args, **kw)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return func(*args, **kw)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return f[<NUM_LIT:1>](*args, **kw)<EOL><DEDENT><DEDENT>dispatch.__name__       = func.__name__<EOL>dispatch.__dict__       = func.__dict__.copy()<EOL>dispatch.__doc__        = func.__doc__<EOL>dispatch.__module__     = func.__module__<EOL>dispatch.when_type = when_type<EOL>dispatch.when_object = when_object<EOL>dispatch.default = func<EOL>dispatch.has_object = lambda o: id(o) in _by_object<EOL>dispatch.has_type   = lambda t: t in _by_type<EOL>return dispatch<EOL>", "docstring": "Create a simple generic function", "id": "f21320:m0"}
{"signature": "def get_owner(self):", "body": "if os.name == '<STR_LIT>':<EOL><INDENT>if win32security is None:<EOL><INDENT>raise Exception(\"<STR_LIT>\")<EOL><DEDENT>desc = win32security.GetFileSecurity(<EOL>self, win32security.OWNER_SECURITY_INFORMATION)<EOL>sid = desc.GetSecurityDescriptorOwner()<EOL>account, domain, typecode = win32security.LookupAccountSid(None, sid)<EOL>return domain + '<STR_LIT:\\\\>' + account<EOL><DEDENT>else:<EOL><INDENT>if pwd is None:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\")<EOL><DEDENT>st = self.stat()<EOL>return pwd.getpwuid(st.st_uid).pw_name<EOL><DEDENT>", "docstring": "r\"\"\" Return the name of the owner of this file or directory.\n\n        This follows symbolic links.\n\n        On Windows, this returns a name of the form ur'DOMAIN\\User Name'.\n        On Windows, a group can own a file or directory.", "id": "f21322:c1:m52"}
{"signature": "def write_bytes(self, bytes, append=False):", "body": "if append:<EOL><INDENT>mode = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>mode = '<STR_LIT:wb>'<EOL><DEDENT>f = self.open(mode)<EOL>try:<EOL><INDENT>f.write(bytes)<EOL><DEDENT>finally:<EOL><INDENT>f.close()<EOL><DEDENT>", "docstring": "Open this file and write the given bytes to it.\n\n        Default behavior is to overwrite any existing file.\n        Call p.write_bytes(bytes, append=True) to append instead.", "id": "f21322:c1:m36"}
{"signature": "def stripext(self):", "body": "return self.splitext()[<NUM_LIT:0>]<EOL>", "docstring": "p.stripext() -> Remove one file extension from the path.\n\n        For example, path('/home/guido/python.tar.gz').stripext()\n        returns path('/home/guido/python.tar').", "id": "f21322:c1:m21"}
{"signature": "def write_text(self, text, encoding=None, errors='<STR_LIT:strict>', linesep=os.linesep, append=False):", "body": "if isinstance(text, str):<EOL><INDENT>if linesep is not None:<EOL><INDENT>text = (text.replace('<STR_LIT:\\r\\n>', '<STR_LIT:\\n>')<EOL>.replace('<STR_LIT>', '<STR_LIT:\\n>')<EOL>.replace('<STR_LIT:\\r>', '<STR_LIT:\\n>')<EOL>.replace('<STR_LIT>', '<STR_LIT:\\n>')<EOL>.replace('<STR_LIT>', '<STR_LIT:\\n>'))<EOL>text = text.replace('<STR_LIT:\\n>', linesep)<EOL><DEDENT>if encoding is None:<EOL><INDENT>encoding = sys.getdefaultencoding()<EOL><DEDENT>bytes = text.encode(encoding, errors)<EOL><DEDENT>else:<EOL><INDENT>assert encoding is None<EOL>if linesep is not None:<EOL><INDENT>text = (text.replace('<STR_LIT:\\r\\n>', '<STR_LIT:\\n>')<EOL>.replace('<STR_LIT:\\r>', '<STR_LIT:\\n>'))<EOL>bytes = text.replace('<STR_LIT:\\n>', linesep)<EOL><DEDENT><DEDENT>self.write_bytes(bytes, append)<EOL>", "docstring": "r\"\"\" Write the given text to this file.\n\n        The default behavior is to overwrite any existing file;\n        to append instead, use the 'append=True' keyword argument.\n\n        There are two differences between path.write_text() and\n        path.write_bytes(): newline handling and Unicode handling.\n        See below.\n\n        Parameters:\n\n          - text - str/unicode - The text to be written.\n\n          - encoding - str - The Unicode encoding that will be used.\n            This is ignored if 'text' isn't a Unicode string.\n\n          - errors - str - How to handle Unicode encoding errors.\n            Default is 'strict'.  See help(unicode.encode) for the\n            options.  This is ignored if 'text' isn't a Unicode\n            string.\n\n          - linesep - keyword argument - str/unicode - The sequence of\n            characters to be used to mark end-of-line.  The default is\n            os.linesep.  You can also specify None; this means to\n            leave all newlines as they are in 'text'.\n\n          - append - keyword argument - bool - Specifies what to do if\n            the file already exists (True: append to the end of it;\n            False: overwrite it.)  The default is False.\n\n\n        --- Newline handling.\n\n        write_text() converts all standard end-of-line sequences\n        ('\\n', '\\r', and '\\r\\n') to your platform's default end-of-line\n        sequence (see os.linesep; on Windows, for example, the\n        end-of-line marker is '\\r\\n').\n\n        If you don't like your platform's default, you can override it\n        using the 'linesep=' keyword argument.  If you specifically want\n        write_text() to preserve the newlines as-is, use 'linesep=None'.\n\n        This applies to Unicode text the same as to 8-bit text, except\n        there are three additional standard Unicode end-of-line sequences:\n        u'\\x85', u'\\r\\x85', and u'\\u2028'.\n\n        (This is slightly different from when you open a file for\n        writing with fopen(filename, \"w\") in C or open(filename, 'w')\n        in Python.)\n\n\n        --- Unicode\n\n        If 'text' isn't Unicode, then apart from newline handling, the\n        bytes are written verbatim to the file.  The 'encoding' and\n        'errors' arguments are not used and must be omitted.\n\n        If 'text' is Unicode, it is first converted to bytes using the\n        specified 'encoding' (or the default encoding if 'encoding'\n        isn't specified).  The 'errors' argument applies only to this\n        conversion.", "id": "f21322:c1:m38"}
{"signature": "def open(self, mode='<STR_LIT:r>'):", "body": "return open(self, mode)<EOL>", "docstring": "Open this file.  Return a file object.", "id": "f21322:c1:m34"}
{"signature": "def write_lines(self, lines, encoding=None, errors='<STR_LIT:strict>',<EOL>linesep=os.linesep, append=False):", "body": "if append:<EOL><INDENT>mode = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>mode = '<STR_LIT:wb>'<EOL><DEDENT>f = self.open(mode)<EOL>try:<EOL><INDENT>for line in lines:<EOL><INDENT>isUnicode = isinstance(line, str)<EOL>if linesep is not None:<EOL><INDENT>if isUnicode:<EOL><INDENT>if line[-<NUM_LIT:2>:] in ('<STR_LIT:\\r\\n>', '<STR_LIT>'):<EOL><INDENT>line = line[:-<NUM_LIT:2>]<EOL><DEDENT>elif line[-<NUM_LIT:1>:] in ('<STR_LIT:\\r>', '<STR_LIT:\\n>',<EOL>'<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>line = line[:-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if line[-<NUM_LIT:2>:] == '<STR_LIT:\\r\\n>':<EOL><INDENT>line = line[:-<NUM_LIT:2>]<EOL><DEDENT>elif line[-<NUM_LIT:1>:] in ('<STR_LIT:\\r>', '<STR_LIT:\\n>'):<EOL><INDENT>line = line[:-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>line += linesep<EOL><DEDENT>if isUnicode:<EOL><INDENT>if encoding is None:<EOL><INDENT>encoding = sys.getdefaultencoding()<EOL><DEDENT>line = line.encode(encoding, errors)<EOL><DEDENT>f.write(line)<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>f.close()<EOL><DEDENT>", "docstring": "r\"\"\" Write the given lines of text to this file.\n\n        By default this overwrites any existing file at this path.\n\n        This puts a platform-specific newline sequence on every line.\n        See 'linesep' below.\n\n        lines - A list of strings.\n\n        encoding - A Unicode encoding to use.  This applies only if\n            'lines' contains any Unicode strings.\n\n        errors - How to handle errors in Unicode encoding.  This\n            also applies only to Unicode strings.\n\n        linesep - The desired line-ending.  This line-ending is\n            applied to every line.  If a line already has any\n            standard line ending ('\\r', '\\n', '\\r\\n', u'\\x85',\n            u'\\r\\x85', u'\\u2028'), that will be stripped off and\n            this will be used instead.  The default is os.linesep,\n            which is platform-dependent ('\\r\\n' on Windows, '\\n' on\n            Unix, etc.)  Specify None to write the lines as-is,\n            like file.writelines().\n\n        Use the keyword argument append=True to append lines to the\n        file.  The default is to overwrite the file.  Warning:\n        When you use this with Unicode data, if the encoding of the\n        existing data in the file is different from the encoding\n        you specify with the encoding= parameter, the result is\n        mixed-encoding data, which can really confuse someone trying\n        to read the file later.", "id": "f21322:c1:m40"}
{"signature": "def relpath(self):", "body": "cwd = self.__class__(os.getcwd())<EOL>return cwd.relpathto(self)<EOL>", "docstring": "Return this path as a relative path,\n        based from the current working directory.", "id": "f21322:c1:m24"}
{"signature": "def getcwd(cls):", "body": "return cls(os.getcwd())<EOL>", "docstring": "Return the current working directory as a path object.", "id": "f21322:c1:m4"}
{"signature": "def splitdrive(self):", "body": "drive, rel = os.path.splitdrive(self)<EOL>return self.__class__(drive), rel<EOL>", "docstring": "p.splitdrive() -> Return (p.drive, <the rest of p>).\n\n        Split the drive specifier from this path.  If there is\n        no drive specifier, p.drive is empty, so the return value\n        is simply (path(''), p).  This is always the case on Unix.", "id": "f21322:c1:m19"}
{"signature": "def relpathto(self, dest):", "body": "origin = self.abspath()<EOL>dest = self.__class__(dest).abspath()<EOL>orig_list = origin.normcase().splitall()<EOL>dest_list = dest.splitall()<EOL>if orig_list[<NUM_LIT:0>] != os.path.normcase(dest_list[<NUM_LIT:0>]):<EOL><INDENT>return dest<EOL><DEDENT>i = <NUM_LIT:0><EOL>for start_seg, dest_seg in zip(orig_list, dest_list):<EOL><INDENT>if start_seg != os.path.normcase(dest_seg):<EOL><INDENT>break<EOL><DEDENT>i += <NUM_LIT:1><EOL><DEDENT>segments = [os.pardir] * (len(orig_list) - i)<EOL>segments += dest_list[i:]<EOL>if len(segments) == <NUM_LIT:0>:<EOL><INDENT>relpath = os.curdir<EOL><DEDENT>else:<EOL><INDENT>relpath = os.path.join(*segments)<EOL><DEDENT>return self.__class__(relpath)<EOL>", "docstring": "Return a relative path from self to dest.\n\n        If there is no relative path from self to dest, for example if\n        they reside on different drives in Windows, then this returns\n        dest.abspath().", "id": "f21322:c1:m25"}
{"signature": "def splitext(self):", "body": "filename, ext = os.path.splitext(self)<EOL>return self.__class__(filename), ext<EOL>", "docstring": "p.splitext() -> Return (p.stripext(), p.ext).\n\n        Split the filename extension from this path and return\n        the two parts.  Either part may be empty.\n\n        The extension is everything from '.' to the end of the\n        last path segment.  This has the property that if\n        (a, b) == p.splitext(), then a + b == p.", "id": "f21322:c1:m20"}
{"signature": "def splitall(self):", "body": "parts = []<EOL>loc = self<EOL>while loc != os.curdir and loc != os.pardir:<EOL><INDENT>prev = loc<EOL>loc, child = prev.splitpath()<EOL>if loc == prev:<EOL><INDENT>break<EOL><DEDENT>parts.append(child)<EOL><DEDENT>parts.append(loc)<EOL>parts.reverse()<EOL>return parts<EOL>", "docstring": "r\"\"\" Return a list of the path components in this path.\n\n        The first item in the list will be a path.  Its value will be\n        either os.curdir, os.pardir, empty, or the root directory of\n        this path (for example, '/' or 'C:\\\\').  The other items in\n        the list will be strings.\n\n        path.path.joinpath(*result) will yield the original path.", "id": "f21322:c1:m23"}
{"signature": "def skipif(skip_condition, msg=None):", "body": "def skip_decorator(f):<EOL><INDENT>import nose<EOL>if callable(skip_condition):<EOL><INDENT>skip_val = lambda : skip_condition()<EOL><DEDENT>else:<EOL><INDENT>skip_val = lambda : skip_condition<EOL><DEDENT>def get_msg(func,msg=None):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if msg is None:<EOL><INDENT>out = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>out = '<STR_LIT:\\n>'+msg<EOL><DEDENT>return \"<STR_LIT>\" % (func.__name__,out)<EOL><DEDENT>def skipper_func(*args, **kwargs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if skip_val():<EOL><INDENT>raise nose.SkipTest(get_msg(f,msg))<EOL><DEDENT>else:<EOL><INDENT>return f(*args, **kwargs)<EOL><DEDENT><DEDENT>def skipper_gen(*args, **kwargs):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if skip_val():<EOL><INDENT>raise nose.SkipTest(get_msg(f,msg))<EOL><DEDENT>else:<EOL><INDENT>for x in f(*args, **kwargs):<EOL><INDENT>yield x<EOL><DEDENT><DEDENT><DEDENT>if nose.util.isgenerator(f):<EOL><INDENT>skipper = skipper_gen<EOL><DEDENT>else:<EOL><INDENT>skipper = skipper_func<EOL><DEDENT>return nose.tools.make_decorator(f)(skipper)<EOL><DEDENT>return skip_decorator<EOL>", "docstring": "Make function raise SkipTest exception if a given condition is true.\n\nIf the condition is a callable, it is used at runtime to dynamically\nmake the decision. This is useful for tests that may require costly\nimports, to delay the cost until the test suite is actually executed.\n\nParameters\n----------\nskip_condition : bool or callable\n    Flag to determine whether to skip the decorated test.\nmsg : str, optional\n    Message to give on raising a SkipTest exception. Default is None.\n\nReturns\n-------\ndecorator : function\n    Decorator which, when applied to a function, causes SkipTest\n    to be raised when `skip_condition` is True, and the function\n    to be called normally otherwise.\n\nNotes\n-----\nThe decorator itself is decorated with the ``nose.tools.make_decorator``\nfunction in order to transmit function name, and various other metadata.", "id": "f21331:m2"}
{"signature": "def knownfailureif(fail_condition, msg=None):", "body": "if msg is None:<EOL><INDENT>msg = '<STR_LIT>'<EOL><DEDENT>if callable(fail_condition):<EOL><INDENT>fail_val = lambda : fail_condition()<EOL><DEDENT>else:<EOL><INDENT>fail_val = lambda : fail_condition<EOL><DEDENT>def knownfail_decorator(f):<EOL><INDENT>import nose<EOL>def knownfailer(*args, **kwargs):<EOL><INDENT>if fail_val():<EOL><INDENT>raise KnownFailureTest(msg)<EOL><DEDENT>else:<EOL><INDENT>return f(*args, **kwargs)<EOL><DEDENT><DEDENT>return nose.tools.make_decorator(f)(knownfailer)<EOL><DEDENT>return knownfail_decorator<EOL>", "docstring": "Make function raise KnownFailureTest exception if given condition is true.\n\nIf the condition is a callable, it is used at runtime to dynamically\nmake the decision. This is useful for tests that may require costly\nimports, to delay the cost until the test suite is actually executed.\n\nParameters\n----------\nfail_condition : bool or callable\n    Flag to determine whether to mark the decorated test as a known\n    failure (if True) or not (if False).\nmsg : str, optional\n    Message to give on raising a KnownFailureTest exception.\n    Default is None.\n\nReturns\n-------\ndecorator : function\n    Decorator, which, when applied to a function, causes SkipTest\n    to be raised when `skip_condition` is True, and the function\n    to be called normally otherwise.\n\nNotes\n-----\nThe decorator itself is decorated with the ``nose.tools.make_decorator``\nfunction in order to transmit function name, and various other metadata.", "id": "f21331:m3"}
{"signature": "def tunnel_connection(socket, addr, server, keyfile=None, password=None, paramiko=None, timeout=<NUM_LIT>):", "body": "new_url, tunnel = open_tunnel(addr, server, keyfile=keyfile, password=password, paramiko=paramiko, timeout=timeout)<EOL>socket.connect(new_url)<EOL>return tunnel<EOL>", "docstring": "Connect a socket to an address via an ssh tunnel.\n\n    This is a wrapper for socket.connect(addr), when addr is not accessible\n    from the local machine.  It simply creates an ssh tunnel using the remaining args,\n    and calls socket.connect('tcp://localhost:lport') where lport is the randomly\n    selected local port of the tunnel.", "id": "f21332:m4"}
{"signature": "def _try_passwordless_paramiko(server, keyfile):", "body": "if paramiko is None:<EOL><INDENT>msg = \"<STR_LIT>\"<EOL>if sys.platform == '<STR_LIT:win32>':<EOL><INDENT>msg += \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>msg += \"<STR_LIT>\"<EOL><DEDENT>raise ImportError(msg)<EOL><DEDENT>username, server, port = _split_server(server)<EOL>client = paramiko.SSHClient()<EOL>client.load_system_host_keys()<EOL>client.set_missing_host_key_policy(paramiko.WarningPolicy())<EOL>try:<EOL><INDENT>client.connect(server, port, username=username, key_filename=keyfile,<EOL>look_for_keys=True)<EOL><DEDENT>except paramiko.AuthenticationException:<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>client.close()<EOL>return True<EOL><DEDENT>", "docstring": "Try passwordless login with paramiko.", "id": "f21332:m3"}
{"signature": "def select_random_ports(n):", "body": "ports = []<EOL>for i in xrange(n):<EOL><INDENT>sock = socket.socket()<EOL>sock.bind(('<STR_LIT>', <NUM_LIT:0>))<EOL>while sock.getsockname()[<NUM_LIT:1>] in _random_ports:<EOL><INDENT>sock.close()<EOL>sock = socket.socket()<EOL>sock.bind(('<STR_LIT>', <NUM_LIT:0>))<EOL><DEDENT>ports.append(sock)<EOL><DEDENT>for i, sock in enumerate(ports):<EOL><INDENT>port = sock.getsockname()[<NUM_LIT:1>]<EOL>sock.close()<EOL>ports[i] = port<EOL>_random_ports.add(port)<EOL><DEDENT>return ports<EOL>", "docstring": "Selects and return n random ports that are available.", "id": "f21332:m0"}
{"signature": "def complete(self, text, line, cursor_pos, block=None):", "body": "content = dict(text=text, line=line, block=block, cursor_pos=cursor_pos)<EOL>msg = self.session.msg('<STR_LIT>', content)<EOL>self._queue_send(msg)<EOL>return msg['<STR_LIT>']['<STR_LIT>']<EOL>", "docstring": "Tab complete text in the kernel's namespace.\n\n        Parameters\n        ----------\n        text : str\n            The text to complete.\n        line : str\n            The full line of text that is the surrounding context for the\n            text to complete.\n        cursor_pos : int\n            The position of the cursor in the line where the completion was\n            requested.\n        block : str, optional\n            The full block of code in which the completion is being requested.\n\n        Returns\n        -------\n        The msg_id of the message sent.", "id": "f21336:c2:m5"}
{"signature": "def pause(self):", "body": "self._pause = True<EOL>", "docstring": "Pause the heartbeat.", "id": "f21336:c5:m4"}
{"signature": "def call_handlers(self, msg):", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "This method is called in the ioloop thread when a message arrives.\n\n        Subclasses should override this method to handle incoming messages.\n        It is important to remember that this method is called in the thread\n        so that some logic must be done to ensure that the application leve\n        handlers are called in the application thread.", "id": "f21336:c2:m3"}
{"signature": "def run(self):", "body": "self._create_socket()<EOL>self._running = True<EOL>self._beating = True<EOL>while self._running:<EOL><INDENT>if self._pause:<EOL><INDENT>time.sleep(self.time_to_dead)<EOL>continue<EOL><DEDENT>since_last_heartbeat = <NUM_LIT:0.0><EOL>self.socket.send(b'<STR_LIT>')<EOL>request_time = time.time()<EOL>ready = self._poll(request_time)<EOL>if ready:<EOL><INDENT>self._beating = True<EOL>self.socket.recv()<EOL>remainder = self.time_to_dead - (time.time() - request_time)<EOL>if remainder > <NUM_LIT:0>:<EOL><INDENT>time.sleep(remainder)<EOL><DEDENT>continue<EOL><DEDENT>else:<EOL><INDENT>self._beating = False<EOL>since_last_heartbeat = time.time() - request_time<EOL>self.call_handlers(since_last_heartbeat)<EOL>self._create_socket()<EOL>continue<EOL><DEDENT><DEDENT>try:<EOL><INDENT>self.socket.close()<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "The thread's main activity.  Call start() instead.", "id": "f21336:c5:m3"}
{"signature": "def input(self, string):", "body": "content = dict(value=string)<EOL>msg = self.session.msg('<STR_LIT>', content)<EOL>self._queue_send(msg)<EOL>", "docstring": "Send a string of raw input to the kernel.", "id": "f21336:c4:m4"}
{"signature": "@property<EOL><INDENT>def is_alive(self):<DEDENT>", "body": "if self.has_kernel:<EOL><INDENT>if self.kernel.poll() is None:<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>elif self._hb_channel is not None:<EOL><INDENT>return self._hb_channel.is_beating()<EOL><DEDENT>else:<EOL><INDENT>return True<EOL><DEDENT>", "docstring": "Is the kernel process still running?", "id": "f21336:c6:m17"}
{"signature": "@property<EOL><INDENT>def stdin_channel(self):<DEDENT>", "body": "if self._stdin_channel is None:<EOL><INDENT>self._stdin_channel = self.stdin_channel_class(self.context,<EOL>self.session,<EOL>(self.ip, self.stdin_port))<EOL><DEDENT>return self._stdin_channel<EOL>", "docstring": "Get the REP socket channel object to handle stdin (raw_input).", "id": "f21336:c6:m20"}
{"signature": "def is_beating(self):", "body": "if self.is_alive() and not self._pause and self._beating:<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Is the heartbeat running and responsive (and not paused).", "id": "f21336:c5:m6"}
{"signature": "def validate_string_list(lst):", "body": "if not isinstance(lst, list):<EOL><INDENT>raise ValueError('<STR_LIT>' % lst)<EOL><DEDENT>for x in lst:<EOL><INDENT>if not isinstance(x, str):<EOL><INDENT>raise ValueError('<STR_LIT>' % x)<EOL><DEDENT><DEDENT>", "docstring": "Validate that the input is a list of strings.\n\n    Raises ValueError if not.", "id": "f21336:m0"}
{"signature": "def restart_kernel(self, now=False, **kw):", "body": "if self._launch_args is None:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>if self.has_kernel:<EOL><INDENT>if now:<EOL><INDENT>self.kill_kernel()<EOL><DEDENT>else:<EOL><INDENT>self.shutdown_kernel(restart=True)<EOL><DEDENT><DEDENT>self._launch_args.update(kw)<EOL>self.start_kernel(**self._launch_args)<EOL>if sys.platform == '<STR_LIT:win32>':<EOL><INDENT>time.sleep(<NUM_LIT>)<EOL><DEDENT><DEDENT>", "docstring": "Restarts a kernel with the arguments that were used to launch it.\n\n        If the old kernel was launched with random ports, the same ports will be\n        used for the new kernel.\n\n        Parameters\n        ----------\n        now : bool, optional\n            If True, the kernel is forcefully restarted *immediately*, without\n            having a chance to do any cleanup action.  Otherwise the kernel is\n            given 1s to clean up before a forceful restart is issued.\n\n            In all cases the kernel is restarted, the only difference is whether\n            it is given a chance to perform a clean shutdown or not.\n\n        **kw : optional\n            Any options specified here will replace those used to launch the\n            kernel.", "id": "f21336:c6:m12"}
{"signature": "def stop_channels(self):", "body": "if self.shell_channel.is_alive():<EOL><INDENT>self.shell_channel.stop()<EOL><DEDENT>if self.sub_channel.is_alive():<EOL><INDENT>self.sub_channel.stop()<EOL><DEDENT>if self.stdin_channel.is_alive():<EOL><INDENT>self.stdin_channel.stop()<EOL><DEDENT>if self.hb_channel.is_alive():<EOL><INDENT>self.hb_channel.stop()<EOL><DEDENT>", "docstring": "Stops all the running channels for this kernel.", "id": "f21336:c6:m5"}
{"signature": "def start_channels(self, shell=True, sub=True, stdin=True, hb=True):", "body": "if shell:<EOL><INDENT>self.shell_channel.start()<EOL><DEDENT>if sub:<EOL><INDENT>self.sub_channel.start()<EOL><DEDENT>if stdin:<EOL><INDENT>self.stdin_channel.start()<EOL>self.shell_channel.allow_stdin = True<EOL><DEDENT>else:<EOL><INDENT>self.shell_channel.allow_stdin = False<EOL><DEDENT>if hb:<EOL><INDENT>self.hb_channel.start()<EOL><DEDENT>", "docstring": "Starts the channels for this kernel.\n\n        This will create the channels if they do not exist and then start\n        them. If port numbers of 0 are being used (random ports) then you\n        must first call :method:`start_kernel`. If the channels have been\n        stopped and you call this, :class:`RuntimeError` will be raised.", "id": "f21336:c6:m4"}
{"signature": "def send_figure(fig):", "body": "fmt = InlineBackend.instance().figure_format<EOL>data = print_figure(fig, fmt)<EOL>if data is None:<EOL><INDENT>return<EOL><DEDENT>mimetypes = { '<STR_LIT>' : '<STR_LIT>', '<STR_LIT>' : '<STR_LIT>' }<EOL>mime = mimetypes[fmt]<EOL>sys.stdout.flush(); sys.stderr.flush()<EOL>publish_display_data(<EOL>'<STR_LIT>',<EOL>{mime : data}<EOL>)<EOL>", "docstring": "Draw the given figure and send it as a PNG payload.", "id": "f21337:m3"}
{"signature": "def loop_gtk(kernel):", "body": "from .gui.gtkembed import GTKEmbed<EOL>gtk_kernel = GTKEmbed(kernel)<EOL>gtk_kernel.start()<EOL>", "docstring": "Start the kernel, coordinating with the GTK event loop", "id": "f21338:m3"}
{"signature": "def loop_cocoa(kernel):", "body": "import matplotlib<EOL>if matplotlib.__version__ < '<STR_LIT>':<EOL><INDENT>kernel.log.warn(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL>return loop_tk(kernel)<EOL><DEDENT>from matplotlib.backends.backend_macosx import TimerMac, show<EOL>poll_interval = int(<NUM_LIT:1000>*kernel._poll_interval)<EOL>real_excepthook = sys.excepthook<EOL>def handle_int(etype, value, tb):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>if etype is KeyboardInterrupt:<EOL><INDENT>io.raw_print(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>real_excepthook(etype, value, tb)<EOL><DEDENT><DEDENT>def doi():<EOL><INDENT>sys.excepthook = real_excepthook<EOL>kernel.do_one_iteration()<EOL>sys.excepthook = handle_int<EOL><DEDENT>t = TimerMac(poll_interval)<EOL>t.add_callback(doi)<EOL>t.start()<EOL>poller = zmq.Poller()<EOL>if kernel.control_stream:<EOL><INDENT>poller.register(kernel.control_stream.socket, zmq.POLLIN)<EOL><DEDENT>for stream in kernel.shell_streams:<EOL><INDENT>poller.register(stream.socket, zmq.POLLIN)<EOL><DEDENT>while True:<EOL><INDENT>try:<EOL><INDENT>try:<EOL><INDENT>sys.excepthook = handle_int<EOL>show.mainloop()<EOL>sys.excepthook = real_excepthook<EOL>poller.poll(<NUM_LIT:10>*poll_interval)<EOL>kernel.do_one_iteration()<EOL><DEDENT>except:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>except KeyboardInterrupt:<EOL><INDENT>io.raw_print(\"<STR_LIT>\")<EOL><DEDENT>finally:<EOL><INDENT>sys.excepthook = real_excepthook<EOL><DEDENT><DEDENT>", "docstring": "Start the kernel, coordinating with the Cocoa CFRunLoop event loop\n    via the matplotlib MacOSX backend.", "id": "f21338:m4"}
{"signature": "def enable_gui(gui, kernel=None):", "body": "if gui not in loop_map:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % gui)<EOL><DEDENT>if kernel is None:<EOL><INDENT>if Application.initialized():<EOL><INDENT>kernel = getattr(Application.instance(), '<STR_LIT>', None)<EOL><DEDENT>if kernel is None:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT><DEDENT>loop = loop_map[gui]<EOL>if kernel.eventloop is not None and kernel.eventloop is not loop:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>kernel.eventloop = loop<EOL>", "docstring": "Enable integration with a given GUI", "id": "f21338:m5"}
{"signature": "def setup():", "body": "global IPYTHONDIR<EOL>global env<EOL>global save_get_ipython_dir<EOL>IPYTHONDIR = tempfile.mkdtemp()<EOL>env = os.environ.copy()<EOL>env[\"<STR_LIT>\"] = IPYTHONDIR<EOL>save_get_ipython_dir = path.get_ipython_dir<EOL>path.get_ipython_dir = lambda : IPYTHONDIR<EOL>", "docstring": "setup temporary IPYTHONDIR for tests", "id": "f21339:m0"}
{"signature": "def flush_channels():", "body": "for channel in (KM.shell_channel, KM.sub_channel):<EOL><INDENT>while True:<EOL><INDENT>try:<EOL><INDENT>msg = channel.get_msg(block=True, timeout=<NUM_LIT:0.1>)<EOL><DEDENT>except Empty:<EOL><INDENT>break<EOL><DEDENT>else:<EOL><INDENT>list(validate_message(msg))<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "flush any messages waiting on the queue", "id": "f21341:m2"}
{"signature": "def check(self, d):", "body": "for key in self.trait_names():<EOL><INDENT>yield nt.assert_true(key in d, \"<STR_LIT>\" % (key, d))<EOL>if d[key] is None:<EOL><INDENT>continue<EOL><DEDENT>try:<EOL><INDENT>setattr(self, key, d[key])<EOL><DEDENT>except TraitError as e:<EOL><INDENT>yield nt.assert_true(False, str(e))<EOL><DEDENT><DEDENT>", "docstring": "validate a dict against our traits", "id": "f21341:c0:m0"}
{"signature": "def execute(code='<STR_LIT>', **kwargs):", "body": "shell = KM.shell_channel<EOL>sub = KM.sub_channel<EOL>msg_id = shell.execute(code=code, **kwargs)<EOL>reply = shell.get_msg(timeout=<NUM_LIT:2>)<EOL>list(validate_message(reply, '<STR_LIT>', msg_id))<EOL>busy = sub.get_msg(timeout=<NUM_LIT:2>)<EOL>list(validate_message(busy, '<STR_LIT:status>', msg_id))<EOL>nt.assert_equals(busy['<STR_LIT:content>']['<STR_LIT>'], '<STR_LIT>')<EOL>if not kwargs.get('<STR_LIT>'):<EOL><INDENT>pyin = sub.get_msg(timeout=<NUM_LIT:2>)<EOL>list(validate_message(pyin, '<STR_LIT>', msg_id))<EOL>nt.assert_equals(pyin['<STR_LIT:content>']['<STR_LIT:code>'], code)<EOL><DEDENT>return msg_id, reply['<STR_LIT:content>']<EOL>", "docstring": "wrapper for doing common steps for validating an execution request", "id": "f21341:m3"}
{"signature": "def get_msgs(self):", "body": "msgs = []<EOL>while True:<EOL><INDENT>try:<EOL><INDENT>msgs.append(self.get_msg(block=False))<EOL><DEDENT>except Empty:<EOL><INDENT>break<EOL><DEDENT><DEDENT>return msgs<EOL>", "docstring": "Get all messages that are currently ready.", "id": "f21342:c1:m4"}
{"signature": "def main():", "body": "app = IPKernelApp.instance()<EOL>app.initialize()<EOL>app.start()<EOL>", "docstring": "Run an IPKernel as an application", "id": "f21345:m2"}
{"signature": "def _eventloop_changed(self, name, old, new):", "body": "loop = ioloop.IOLoop.instance()<EOL>loop.add_timeout(time.time()+<NUM_LIT:0.1>, self.enter_eventloop)<EOL>", "docstring": "schedule call to eventloop from IOLoop", "id": "f21345:c0:m0"}
{"signature": "def start(self):", "body": "self.shell.exit_now = False<EOL>if self.control_stream:<EOL><INDENT>self.control_stream.on_recv(self.dispatch_control, copy=False)<EOL><DEDENT>def make_dispatcher(stream):<EOL><INDENT>def dispatcher(msg):<EOL><INDENT>return self.dispatch_shell(stream, msg)<EOL><DEDENT>return dispatcher<EOL><DEDENT>for s in self.shell_streams:<EOL><INDENT>s.on_recv(make_dispatcher(s), copy=False)<EOL><DEDENT>", "docstring": "register dispatchers for streams", "id": "f21345:c0:m8"}
{"signature": "def _wire_kernel(self):", "body": "self.gtk_main, self.gtk_main_quit = self._hijack_gtk()<EOL>gobject.timeout_add(int(<NUM_LIT:1000>*self.kernel._poll_interval),<EOL>self.iterate_kernel)<EOL>return False<EOL>", "docstring": "Initializes the kernel inside GTK.\n\n        This is meant to run only once at startup, so it does its job and\n        returns False to ensure it doesn't get run again by GTK.", "id": "f21350:c0:m2"}
{"signature": "def init_heartbeat(self):", "body": "<EOL>hb_ctx = zmq.Context()<EOL>self.heartbeat = Heartbeat(hb_ctx, (self.ip, self.hb_port))<EOL>self.hb_port = self.heartbeat.port<EOL>self.log.debug(\"<STR_LIT>\"%self.hb_port)<EOL>self.heartbeat.start()<EOL>self.log.critical(\"<STR_LIT>\")<EOL>", "docstring": "start the heart beating", "id": "f21352:c0:m9"}
{"signature": "def init_kernel(self):", "body": "kernel_factory = import_item(str(self.kernel_class))<EOL>self.kernel = kernel_factory(config=self.config, session=self.session,<EOL>shell_socket=self.shell_socket,<EOL>iopub_socket=self.iopub_socket,<EOL>stdin_socket=self.stdin_socket,<EOL>log=self.log<EOL>)<EOL>self.kernel.record_ports(self.ports)<EOL>", "docstring": "Create the Kernel object itself", "id": "f21352:c0:m15"}
{"signature": "def __init__(self, interrupt_handle=None, parent_handle=None):", "body": "assert(interrupt_handle or parent_handle)<EOL>super(ParentPollerWindows, self).__init__()<EOL>if ctypes is None:<EOL><INDENT>raise ImportError(\"<STR_LIT>\")<EOL><DEDENT>self.daemon = True<EOL>self.interrupt_handle = interrupt_handle<EOL>self.parent_handle = parent_handle<EOL>", "docstring": "Create the poller. At least one of the optional parameters must be\n        provided.\n\n        Parameters:\n        -----------\n        interrupt_handle : HANDLE (int), optional\n            If provided, the program will generate a Ctrl+C event when this\n            handle is signaled.\n\n        parent_handle : HANDLE (int), optional\n            If provided, the program will terminate immediately when this\n            handle is signaled.", "id": "f21353:c1:m0"}
{"signature": "@line_magic<EOL><INDENT>def less(self, arg_s):<DEDENT>", "body": "cont = open(arg_s).read()<EOL>if arg_s.endswith('<STR_LIT>'):<EOL><INDENT>cont = self.shell.pycolorize(cont)<EOL><DEDENT>page.page(cont)<EOL>", "docstring": "Show a file through the pager.\n\n        Files ending in .py are syntax-highlighted.", "id": "f21354:c1:m3"}
{"signature": "@line_magic<EOL><INDENT>def connect_info(self, arg_s):<DEDENT>", "body": "from IPython.core.application import BaseIPythonApplication as BaseIPApp<EOL>if BaseIPApp.initialized():<EOL><INDENT>app = BaseIPApp.instance()<EOL>security_dir = app.profile_dir.security_dir<EOL>profile = app.profile<EOL><DEDENT>else:<EOL><INDENT>profile = '<STR_LIT:default>'<EOL>security_dir = '<STR_LIT>'<EOL><DEDENT>try:<EOL><INDENT>connection_file = get_connection_file()<EOL>info = get_connection_info(unpack=False)<EOL><DEDENT>except Exception as e:<EOL><INDENT>error(\"<STR_LIT>\" % e)<EOL>return<EOL><DEDENT>profile_flag = \"<STR_LIT>\" % profile if profile != '<STR_LIT:default>' else \"<STR_LIT>\"<EOL>if security_dir == os.path.dirname(connection_file):<EOL><INDENT>connection_file = os.path.basename(connection_file)<EOL><DEDENT>print (info + '<STR_LIT:\\n>')<EOL>print (\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\".format(<EOL>connection_file, profile_flag<EOL>)<EOL>)<EOL>", "docstring": "Print information for connecting other clients to this kernel\n\n        It will print the contents of this session's connection file, as well as\n        shortcuts for local clients.\n\n        In the simplest case, when called from the most recently launched kernel,\n        secondary clients can be connected, simply with:\n\n        $> ipython <app> --existing", "id": "f21354:c1:m4"}
{"signature": "def unserialize(self, msg_list, content=True, copy=True):", "body": "minlen = <NUM_LIT:4><EOL>message = {}<EOL>if not copy:<EOL><INDENT>for i in range(minlen):<EOL><INDENT>msg_list[i] = msg_list[i].bytes<EOL><DEDENT><DEDENT>if self.auth is not None:<EOL><INDENT>signature = msg_list[<NUM_LIT:0>]<EOL>if not signature:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if signature in self.digest_history:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"%signature)<EOL><DEDENT>self.digest_history.add(signature)<EOL>check = self.sign(msg_list[<NUM_LIT:1>:<NUM_LIT:4>])<EOL>if not signature == check:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"%signature)<EOL><DEDENT><DEDENT>if not len(msg_list) >= minlen:<EOL><INDENT>raise TypeError(\"<STR_LIT>\"%minlen)<EOL><DEDENT>header = self.unpack(msg_list[<NUM_LIT:1>])<EOL>message['<STR_LIT>'] = header<EOL>message['<STR_LIT>'] = header['<STR_LIT>']<EOL>message['<STR_LIT>'] = header['<STR_LIT>']<EOL>message['<STR_LIT>'] = self.unpack(msg_list[<NUM_LIT:2>])<EOL>if content:<EOL><INDENT>message['<STR_LIT:content>'] = self.unpack(msg_list[<NUM_LIT:3>])<EOL><DEDENT>else:<EOL><INDENT>message['<STR_LIT:content>'] = msg_list[<NUM_LIT:3>]<EOL><DEDENT>message['<STR_LIT>'] = msg_list[<NUM_LIT:4>:]<EOL>return message<EOL>", "docstring": "Unserialize a msg_list to a nested message dict.\n\n        This is roughly the inverse of serialize. The serialize/unserialize\n        methods work with full message lists, whereas pack/unpack work with\n        the individual message parts in the message list.\n\n        Parameters:\n        -----------\n        msg_list : list of bytes or Message objects\n            The list of message parts of the form [HMAC,p_header,p_parent,\n            p_content,buffer1,buffer2,...].\n        content : bool (True)\n            Whether to unpack the content dict (True), or leave it packed\n            (False).\n        copy : bool (True)\n            Whether to return the bytes (True), or the non-copying Message\n            object in each place (False).\n\n        Returns\n        -------\n        msg : dict\n            The nested message dict with top-level keys [header, parent_header,\n            content, buffers].", "id": "f21355:c2:m19"}
{"signature": "def squash_unicode(obj):", "body": "if isinstance(obj,dict):<EOL><INDENT>for key in obj.keys():<EOL><INDENT>obj[key] = squash_unicode(obj[key])<EOL>if isinstance(key, unicode):<EOL><INDENT>obj[squash_unicode(key)] = obj.pop(key)<EOL><DEDENT><DEDENT><DEDENT>elif isinstance(obj, list):<EOL><INDENT>for i,v in enumerate(obj):<EOL><INDENT>obj[i] = squash_unicode(v)<EOL><DEDENT><DEDENT>elif isinstance(obj, unicode):<EOL><INDENT>obj = obj.encode('<STR_LIT:utf8>')<EOL><DEDENT>return obj<EOL>", "docstring": "coerce unicode back to bytestrings.", "id": "f21355:m0"}
{"signature": "def serialize(self, msg, ident=None):", "body": "content = msg.get('<STR_LIT:content>', {})<EOL>if content is None:<EOL><INDENT>content = self.none<EOL><DEDENT>elif isinstance(content, dict):<EOL><INDENT>content = self.pack(content)<EOL><DEDENT>elif isinstance(content, bytes):<EOL><INDENT>pass<EOL><DEDENT>elif isinstance(content, unicode):<EOL><INDENT>content = content.encode('<STR_LIT:utf8>')<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\"%type(content))<EOL><DEDENT>real_message = [self.pack(msg['<STR_LIT>']),<EOL>self.pack(msg['<STR_LIT>']),<EOL>content<EOL>]<EOL>to_send = []<EOL>if isinstance(ident, list):<EOL><INDENT>to_send.extend(ident)<EOL><DEDENT>elif ident is not None:<EOL><INDENT>to_send.append(ident)<EOL><DEDENT>to_send.append(DELIM)<EOL>signature = self.sign(real_message)<EOL>to_send.append(signature)<EOL>to_send.extend(real_message)<EOL>return to_send<EOL>", "docstring": "Serialize the message components to bytes.\n\n        This is roughly the inverse of unserialize. The serialize/unserialize\n        methods work with full message lists, whereas pack/unpack work with\n        the individual message parts in the message list.\n\n        Parameters\n        ----------\n        msg : dict or Message\n            The nexted message dict as returned by the self.msg method.\n\n        Returns\n        -------\n        msg_list : list\n            The list of bytes objects to be sent with the format:\n            [ident1,ident2,...,DELIM,HMAC,p_header,p_parent,p_content,\n             buffer1,buffer2,...]. In this list, the p_* entities are\n            the packed or serialized versions, so if JSON is used, these\n            are utf8 encoded JSON strings.", "id": "f21355:c2:m14"}
{"signature": "def recv(self, socket, mode=zmq.NOBLOCK, content=True, copy=True):", "body": "if isinstance(socket, ZMQStream):<EOL><INDENT>socket = socket.socket<EOL><DEDENT>try:<EOL><INDENT>msg_list = socket.recv_multipart(mode, copy=copy)<EOL><DEDENT>except zmq.ZMQError as e:<EOL><INDENT>if e.errno == zmq.EAGAIN:<EOL><INDENT>return None,None<EOL><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>idents, msg_list = self.feed_identities(msg_list, copy)<EOL>try:<EOL><INDENT>return idents, self.unserialize(msg_list, content=content, copy=copy)<EOL><DEDENT>except Exception as e:<EOL><INDENT>raise e<EOL><DEDENT>", "docstring": "Receive and unpack a message.\n\n        Parameters\n        ----------\n        socket : ZMQStream or Socket\n            The socket or stream to use in receiving.\n\n        Returns\n        -------\n        [idents], msg\n            [idents] is a list of idents and msg is a nested message dict of\n            same format as self.msg returns.", "id": "f21355:c2:m17"}
{"signature": "def __init__(self, **kwargs):", "body": "super(Session, self).__init__(**kwargs)<EOL>self._check_packers()<EOL>self.none = self.pack({})<EOL>self.session<EOL>", "docstring": "create a Session object\n\n        Parameters\n        ----------\n\n        debug : bool\n            whether to trigger extra debugging statements\n        packer/unpacker : str : 'json', 'pickle' or import_string\n            importstrings for methods to serialize message parts.  If just\n            'json' or 'pickle', predefined JSON and pickle packers will be used.\n            Otherwise, the entire importstring must be used.\n\n            The functions must accept at least valid JSON input, and output\n            *bytes*.\n\n            For example, to use msgpack:\n            packer = 'msgpack.packb', unpacker='msgpack.unpackb'\n        pack/unpack : callables\n            You can also set the pack/unpack callables for serialization\n            directly.\n        session : unicode (must be ascii)\n            the ID of this Session object.  The default is to generate a new\n            UUID.\n        bsession : bytes\n            The session as bytes\n        username : unicode\n            username added to message headers.  The default is to ask the OS.\n        key : bytes\n            The key used to initialize an HMAC signature.  If unset, messages\n            will not be signed or checked.\n        keyfile : filepath\n            The file containing a key.  If this is set, `key` will be\n            initialized to the contents of the file.", "id": "f21355:c2:m8"}
{"signature": "def write_output_prompt(self):", "body": "self.msg['<STR_LIT:content>']['<STR_LIT>'] = self.prompt_count<EOL>", "docstring": "Write the output prompt.", "id": "f21357:c1:m2"}
{"signature": "def set_parent(self, parent):", "body": "self.parent_header = extract_header(parent)<EOL>", "docstring": "Set the parent for outbound messages.", "id": "f21357:c1:m0"}
{"signature": "def __call__(self, ds):", "body": "from . import globalipapp<EOL>pyps1 = '<STR_LIT>'<EOL>pyps2 = '<STR_LIT>'<EOL>pyout = '<STR_LIT>'<EOL>dnew = ds<EOL>dnew = self.rps1.sub(pyps1, dnew)<EOL>dnew = self.rps2.sub(pyps2, dnew)<EOL>dnew = self.rout.sub(pyout, dnew)<EOL>ip = globalipapp.get_ipython()<EOL>out = []<EOL>newline = out.append<EOL>for line in dnew.splitlines():<EOL><INDENT>mps1 = self.rpyps1.match(line)<EOL>if mps1 is not None:<EOL><INDENT>prompt, text = mps1.groups()<EOL>newline(prompt+ip.prefilter(text, False))<EOL>continue<EOL><DEDENT>mps2 = self.rpyps2.match(line)<EOL>if mps2 is not None:<EOL><INDENT>prompt, text = mps2.groups()<EOL>newline(prompt+ip.prefilter(text, True))<EOL>continue<EOL><DEDENT>newline(line)<EOL><DEDENT>newline('<STR_LIT>')  <EOL>return '<STR_LIT:\\n>'.join(out)<EOL>", "docstring": "Convert IPython prompts to python ones in a string.", "id": "f21360:c0:m1"}
{"signature": "def parametric(func):", "body": "<EOL>func._generator = True<EOL>class Tester(ParametricTestCase):<EOL><INDENT>test = staticmethod(func)<EOL><DEDENT>Tester.__name__ = func.__name__<EOL>return Tester<EOL>", "docstring": "Decorator to make a simple function into a normal test via\n unittest.", "id": "f21361:m1"}
{"signature": "def make_runners():", "body": "<EOL>nose_pkg_names = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>', '<STR_LIT>' ]<EOL>if have['<STR_LIT>']:<EOL><INDENT>nose_pkg_names.append('<STR_LIT>')<EOL>nose_pkg_names.append('<STR_LIT>')<EOL><DEDENT>nose_packages = ['<STR_LIT>' % m for m in nose_pkg_names ]<EOL>runners = [ (v, IPTester('<STR_LIT>', params=v)) for v in nose_packages ]<EOL>return runners<EOL>", "docstring": "Define the top-level packages that need to be tested.", "id": "f21362:m6"}
{"signature": "def baz(self,y):", "body": "return self.x==y<EOL>", "docstring": "Example:\n\n        >>> ff2 = FooClass(3)\n        Making a FooClass.\n        >>> ff2.baz(3)\n        True", "id": "f21364:c1:m2"}
{"signature": "def ranfunc():", "body": "return '<STR_LIT>'<EOL>", "docstring": "A function with some random output.\n\n       Normal examples are verified as usual:\n       >>> 1+3\n       4\n\n       But if you put '# random' in the output, it is ignored:\n       >>> 1+3\n       junk goes here...  # random\n\n       >>> 1+2\n       again,  anything goes #random\n       if multiline, the random mark is only needed once.\n\n       >>> 1+2\n       You can also put the random marker at the end:\n       # random\n\n       >>> 1+2\n       # random\n       .. or at the beginning.\n\n       More correct input is properly verified:\n       >>> ranfunc()\n       'ranfunc'", "id": "f21370:m2"}
{"signature": "def random_all():", "body": "pass<EOL>", "docstring": "A function where we ignore the output of ALL examples.\n\n    Examples:\n\n      # all-random\n\n      This mark tells the testing machinery that all subsequent examples should\n      be treated as random (ignoring their output).  They are still executed,\n      so if a they raise an error, it will be detected as such, but their\n      output is completely ignored.\n\n      >>> 1+3\n      junk goes here...\n\n      >>> 1+3\n      klasdfj;\n\n      >>> 1+2\n      again,  anything goes\n      blah...", "id": "f21370:m3"}
{"signature": "def _parse_example(self, m, name, lineno,ip2py=False):", "body": "<EOL>indent = len(m.group('<STR_LIT>'))<EOL>source_lines = m.group('<STR_LIT:source>').split('<STR_LIT:\\n>')<EOL>ps1 = m.group('<STR_LIT>')<EOL>ps2 = m.group('<STR_LIT>')<EOL>ps1_len = len(ps1)<EOL>self._check_prompt_blank(source_lines, indent, name, lineno,ps1_len)<EOL>if ps2:<EOL><INDENT>self._check_prefix(source_lines[<NUM_LIT:1>:], '<STR_LIT:U+0020>'*indent + ps2, name, lineno)<EOL><DEDENT>source = '<STR_LIT:\\n>'.join([sl[indent+ps1_len+<NUM_LIT:1>:] for sl in source_lines])<EOL>if ip2py:<EOL><INDENT>source = self.ip2py(source)<EOL><DEDENT>want = m.group('<STR_LIT>')<EOL>want_lines = want.split('<STR_LIT:\\n>')<EOL>if len(want_lines) > <NUM_LIT:1> and re.match(r'<STR_LIT>', want_lines[-<NUM_LIT:1>]):<EOL><INDENT>del want_lines[-<NUM_LIT:1>]  <EOL><DEDENT>self._check_prefix(want_lines, '<STR_LIT:U+0020>'*indent, name,<EOL>lineno + len(source_lines))<EOL>want_lines[<NUM_LIT:0>] = re.sub(r'<STR_LIT>','<STR_LIT>',want_lines[<NUM_LIT:0>])<EOL>want = '<STR_LIT:\\n>'.join([wl[indent:] for wl in want_lines])<EOL>m = self._EXCEPTION_RE.match(want)<EOL>if m:<EOL><INDENT>exc_msg = m.group('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>exc_msg = None<EOL><DEDENT>options = self._find_options(source, name, lineno)<EOL>return source, options, want, exc_msg<EOL>", "docstring": "Given a regular expression match from `_EXAMPLE_RE` (`m`),\nreturn a pair `(source, want)`, where `source` is the matched\nexample's source code (with prompts and indentation stripped);\nand `want` is the example's expected output (with indentation\nstripped).\n\n`name` is the string's name, and `lineno` is the line number\nwhere the example starts; both are used for error messages.\n\nOptional:\n`ip2py`: if true, filter the input via IPython to convert the syntax\ninto valid python.", "id": "f21375:c6:m2"}
{"signature": "def parse(self, string, name='<STR_LIT>'):", "body": "<EOL>string = string.expandtabs()<EOL>min_indent = self._min_indent(string)<EOL>if min_indent > <NUM_LIT:0>:<EOL><INDENT>string = '<STR_LIT:\\n>'.join([l[min_indent:] for l in string.split('<STR_LIT:\\n>')])<EOL><DEDENT>output = []<EOL>charno, lineno = <NUM_LIT:0>, <NUM_LIT:0><EOL>if self._RANDOM_TEST.search(string):<EOL><INDENT>random_marker = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>random_marker = '<STR_LIT>'<EOL><DEDENT>ip2py = False<EOL>terms = list(self._EXAMPLE_RE_PY.finditer(string))<EOL>if terms:<EOL><INDENT>Example = doctest.Example<EOL><DEDENT>else:<EOL><INDENT>terms = list(self._EXAMPLE_RE_IP.finditer(string))<EOL>if self._EXTERNAL_IP.search(string):<EOL><INDENT>Example = IPExternalExample<EOL><DEDENT>else:<EOL><INDENT>Example = IPExample<EOL>ip2py = True<EOL><DEDENT><DEDENT>for m in terms:<EOL><INDENT>output.append(string[charno:m.start()])<EOL>lineno += string.count('<STR_LIT:\\n>', charno, m.start())<EOL>(source, options, want, exc_msg) =self._parse_example(m, name, lineno,ip2py)<EOL>want += random_marker<EOL>if Example is IPExternalExample:<EOL><INDENT>options[doctest.NORMALIZE_WHITESPACE] = True<EOL>want += '<STR_LIT:\\n>'<EOL><DEDENT>if not self._IS_BLANK_OR_COMMENT(source):<EOL><INDENT>output.append(Example(source, want, exc_msg,<EOL>lineno=lineno,<EOL>indent=min_indent+len(m.group('<STR_LIT>')),<EOL>options=options))<EOL><DEDENT>lineno += string.count('<STR_LIT:\\n>', m.start(), m.end())<EOL>charno = m.end()<EOL><DEDENT>output.append(string[charno:])<EOL>return output<EOL>", "docstring": "Divide the given string into examples and intervening text,\nand return them as a list of alternating Examples and strings.\nLine numbers for the Examples are 0-based.  The optional\nargument `name` is a name identifying this string, and is only\nused for error messages.", "id": "f21375:c6:m1"}
{"signature": "def is_extension_module(filename):", "body": "return os.path.splitext(filename)[<NUM_LIT:1>].lower() in ('<STR_LIT>','<STR_LIT>')<EOL>", "docstring": "Return whether the given filename is an extension module.\n\n    This simply checks that the extension is either .so or .pyd.", "id": "f21375:m0"}
{"signature": "def parametric(func):", "body": "class Tester(ParametricTestCase):<EOL><INDENT>test = staticmethod(func)<EOL><DEDENT>Tester.__name__ = func.__name__<EOL>return Tester<EOL>", "docstring": "Decorator to make a simple function into a normal test via unittest.", "id": "f21377:m1"}
{"signature": "def __call__(self,fname):", "body": "if fname.endswith('<STR_LIT>'):<EOL><INDENT>runnerClass = irunner.PythonRunner<EOL><DEDENT>elif fname.endswith('<STR_LIT>'):<EOL><INDENT>runnerClass = irunner.IPythonRunner<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' % fname)<EOL><DEDENT>if self.runner is None:<EOL><INDENT>return self._makeRunner(runnerClass)<EOL><DEDENT>else:<EOL><INDENT>if runnerClass==self.runnerClass:<EOL><INDENT>return self.runner<EOL><DEDENT>else:<EOL><INDENT>e='<STR_LIT>' %(self.runnerClass,fname)<EOL>raise ValueError(e)<EOL><DEDENT><DEDENT>", "docstring": "Return a runner for the given filename.", "id": "f21379:c1:m2"}
{"signature": "def ipexec_validate(fname, expected_out, expected_err='<STR_LIT>',<EOL>options=None):", "body": "import nose.tools as nt<EOL>out, err = ipexec(fname, options)<EOL>if err:<EOL><INDENT>if expected_err:<EOL><INDENT>nt.assert_equals(err.strip(), expected_err.strip())<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' %<EOL>(fname, err))<EOL><DEDENT><DEDENT>nt.assert_equals(out.strip(), expected_out.strip())<EOL>", "docstring": "Utility to call 'ipython filename' and validate output/error.\n\n    This function raises an AssertionError if the validation fails.\n\n    Note that this starts IPython in a subprocess!\n\n    Parameters\n    ----------\n    fname : str\n      Name of the file to be executed (should have .py or .ipy extension).\n\n    expected_out : str\n      Expected stdout of the process.\n\n    expected_err : optional, str\n      Expected stderr of the process.\n\n    options : optional, list\n      Extra command-line flags to be passed to IPython.\n\n    Returns\n    -------\n    None", "id": "f21382:m5"}
{"signature": "def default_argv():", "body": "return ['<STR_LIT>', <EOL>'<STR_LIT>', '<STR_LIT>','<STR_LIT>',<EOL>'<STR_LIT>']<EOL>", "docstring": "Return a valid default argv for creating testing instances of ipython", "id": "f21382:m2"}
{"signature": "def default_config():", "body": "config = Config()<EOL>config.TerminalInteractiveShell.colors = '<STR_LIT>'<EOL>config.TerminalTerminalInteractiveShell.term_title = False,<EOL>config.TerminalInteractiveShell.autocall = <NUM_LIT:0><EOL>config.HistoryManager.hist_file = tempfile.mktemp('<STR_LIT>')<EOL>config.HistoryManager.db_cache_size = <NUM_LIT><EOL>return config<EOL>", "docstring": "Return a config object with good defaults for testing.", "id": "f21382:m3"}
{"signature": "def apply_wrapper(wrapper,func):", "body": "import nose.tools<EOL>return decorator(wrapper,nose.tools.make_decorator(func)(wrapper))<EOL>", "docstring": "Apply a wrapper to a function for decoration.\n\n    This mixes Michele Simionato's decorator tool with nose's make_decorator,\n    to apply a wrapper in a decorator so that all nose attributes, as well as\n    function signature and other properties, survive the decoration cleanly.\n    This will ensure that wrapped functions can still be well introspected via\n    IPython, for example.", "id": "f21384:m1"}
{"signature": "def make_label_dec(label,ds=None):", "body": "if isinstance(label,basestring):<EOL><INDENT>labels = [label]<EOL><DEDENT>else:<EOL><INDENT>labels = label<EOL><DEDENT>tmp = lambda : None<EOL>for label in labels:<EOL><INDENT>setattr(tmp,label,True)<EOL><DEDENT>def decor(f):<EOL><INDENT>for label in labels:<EOL><INDENT>setattr(f,label,True)<EOL><DEDENT>return f<EOL><DEDENT>if ds is None:<EOL><INDENT>ds = \"<STR_LIT>\" % label<EOL><DEDENT>decor.__doc__ = ds<EOL>return decor<EOL>", "docstring": "Factory function to create a decorator that applies one or more labels.\n\n    Parameters\n    ----------\n      label : string or sequence\n      One or more labels that will be applied by the decorator to the functions\n    it decorates.  Labels are attributes of the decorated function with their\n    value set to True.\n\n      ds : string\n      An optional docstring for the resulting decorator.  If not given, a\n      default docstring is auto-generated.\n\n    Returns\n    -------\n      A decorator.\n\n    Examples\n    --------\n\n    A simple labeling decorator:\n    >>> slow = make_label_dec('slow')\n    >>> print slow.__doc__\n    Labels a test as 'slow'.\n\n    And one that uses multiple labels and a custom docstring:\n    >>> rare = make_label_dec(['slow','hard'],\n    ... \"Mix labels 'slow' and 'hard' for rare tests.\")\n    >>> print rare.__doc__\n    Mix labels 'slow' and 'hard' for rare tests.\n\n    Now, let's test using this one:\n    >>> @rare\n    ... def f(): pass\n    ...\n    >>>\n    >>> f.slow\n    True\n    >>> f.hard\n    True", "id": "f21384:m2"}
{"signature": "def onlyif(condition, msg):", "body": "if callable(condition):<EOL><INDENT>skip_condition = lambda : not condition()<EOL><DEDENT>else:<EOL><INDENT>skip_condition = lambda : not condition<EOL><DEDENT>return skipif(skip_condition, msg)<EOL>", "docstring": "The reverse from skipif, see skipif for details.", "id": "f21384:m5"}
{"signature": "def init_fakemod_dict(fm,adict=None):", "body": "dct = {}<EOL>dct.setdefault('<STR_LIT>',lambda : True)<EOL>dct.setdefault('<STR_LIT>',__file__)<EOL>if adict is not None:<EOL><INDENT>dct.update(adict)<EOL><DEDENT>fm.__dict__.clear()<EOL>fm.__dict__.update(dct)<EOL>", "docstring": "Initialize a FakeModule instance __dict__.\n\n    Kept as a standalone function and not a method so the FakeModule API can\n    remain basically empty.\n\n    This should be considered for private IPython use, used in managing\n    namespaces for %run.\n\n    Parameters\n    ----------\n\n    fm : FakeModule instance\n\n    adict : dict, optional", "id": "f21386:m0"}
{"signature": "def _detect_screen_size(use_curses, screen_lines_def):", "body": "TERM = os.environ.get('<STR_LIT>',None)<EOL>if (TERM=='<STR_LIT>' or TERM=='<STR_LIT>') and sys.platform != '<STR_LIT>':<EOL><INDENT>local_use_curses = use_curses<EOL><DEDENT>else:<EOL><INDENT>local_use_curses = False<EOL><DEDENT>if local_use_curses:<EOL><INDENT>import termios<EOL>import curses<EOL>term_flags = termios.tcgetattr(sys.stdout)<EOL>NCURSES_NO_SETBUF = os.environ.get('<STR_LIT>', None)<EOL>os.environ['<STR_LIT>'] = '<STR_LIT>'<EOL>scr = curses.initscr()<EOL>screen_lines_real,screen_cols = scr.getmaxyx()<EOL>curses.endwin()<EOL>if NCURSES_NO_SETBUF is None:<EOL><INDENT>del os.environ['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>os.environ['<STR_LIT>'] = NCURSES_NO_SETBUF<EOL><DEDENT>termios.tcsetattr(sys.stdout,termios.TCSANOW,term_flags)<EOL>return screen_lines_real<EOL><DEDENT>else:<EOL><INDENT>return screen_lines_def<EOL><DEDENT>", "docstring": "Attempt to work out the number of lines on the screen.\n\n    This is called by page(). It can raise an error (e.g. when run in the\n    test suite), so it's separated out so it can easily be called in a try block.", "id": "f21387:m1"}
{"signature": "def get_pager_cmd(pager_cmd=None):", "body": "if os.name == '<STR_LIT>':<EOL><INDENT>default_pager_cmd = '<STR_LIT>'  <EOL><DEDENT>elif os.name in ['<STR_LIT>','<STR_LIT>']:<EOL><INDENT>default_pager_cmd = '<STR_LIT:type>'<EOL><DEDENT>if pager_cmd is None:<EOL><INDENT>try:<EOL><INDENT>pager_cmd = os.environ['<STR_LIT>']<EOL><DEDENT>except:<EOL><INDENT>pager_cmd = default_pager_cmd<EOL><DEDENT><DEDENT>return pager_cmd<EOL>", "docstring": "Return a pager command.\n\n    Makes some attempts at finding an OS-correct one.", "id": "f21387:m4"}
{"signature": "def set_ip(self, ip):", "body": "self._ip = ip<EOL>", "docstring": "Will be used to set _ip point to current ipython instance b/f call\n\n        Override this method if you don't want this to happen.", "id": "f21389:c0:m1"}
{"signature": "def set_colors(self, scheme):", "body": "self.color_scheme_table.set_active_scheme(scheme)<EOL>", "docstring": "Shorthand access to the color table scheme selector method.", "id": "f21390:c1:m1"}
{"signature": "def do_pdoc(self, arg):", "body": "namespaces = [('<STR_LIT>', self.curframe.f_locals),<EOL>('<STR_LIT>', self.curframe.f_globals)]<EOL>self.shell.find_line_magic('<STR_LIT>')(arg, namespaces=namespaces)<EOL>", "docstring": "The debugger interface to magic_pdoc", "id": "f21390:c1:m17"}
{"signature": "def checkline(self, filename, lineno):", "body": "<EOL>line = linecache.getline(filename, lineno)<EOL>if not line:<EOL><INDENT>print('<STR_LIT>', file=self.stdout)<EOL>return <NUM_LIT:0><EOL><DEDENT>line = line.strip()<EOL>if (not line or (line[<NUM_LIT:0>] == '<STR_LIT:#>') or<EOL>(line[:<NUM_LIT:3>] == '<STR_LIT>') or line[:<NUM_LIT:3>] == \"<STR_LIT>\"):<EOL><INDENT>print('<STR_LIT>', file=self.stdout)<EOL>return <NUM_LIT:0><EOL><DEDENT>return lineno<EOL>", "docstring": "Check whether specified line seems to be executable.\n\n        Return `lineno` if it is, 0 if not (e.g. a docstring, comment, blank\n        line or EOF). Warning: testing is not comprehensive.", "id": "f21390:c1:m19"}
{"signature": "def _file_lines(fname):", "body": "try:<EOL><INDENT>outfile = open(fname)<EOL><DEDENT>except IOError:<EOL><INDENT>return []<EOL><DEDENT>else:<EOL><INDENT>out = outfile.readlines()<EOL>outfile.close()<EOL>return out<EOL><DEDENT>", "docstring": "Return the contents of a named file as a list of lines.\n\n    This function never raises an IOError exception: if the file can't be\n    read, it simply returns an empty list.", "id": "f21390:m3"}
{"signature": "def new_do_restart(self, arg):", "body": "self.msg(\"<STR_LIT>\")<EOL>return self.do_quit(arg)<EOL>", "docstring": "Restart command. In the context of ipython this is exactly the same\n        thing as 'quit'.", "id": "f21390:c1:m7"}
{"signature": "def __getstate__(self):", "body": "return {'<STR_LIT:value>': self.value}<EOL>", "docstring": "needed for safe pickling via %store", "id": "f21391:c0:m4"}
{"signature": "def mini_interactive_loop(input_func):", "body": "from IPython.core.inputsplitter import InputSplitter<EOL>isp = InputSplitter()<EOL>while isp.push_accepts_more():<EOL><INDENT>indent = '<STR_LIT:U+0020>'*isp.indent_spaces<EOL>prompt = '<STR_LIT>' + indent<EOL>line = indent + input_func(prompt)<EOL>isp.push(line)<EOL><DEDENT>src = isp.source_reset()<EOL>return src<EOL>", "docstring": "Minimal example of the logic of an interactive interpreter loop.\n\n    This serves as an example, and it is used by the test system with a fake\n    raw_input that simulates interactive input.", "id": "f21394:m0"}
{"signature": "@cell_magic(\"<STR_LIT:foo>\")<EOL><INDENT>def cell_foo(self, line, cell):<DEDENT>", "body": "pass<EOL>", "docstring": "I am cell foo, not line foo", "id": "f21399:c3:m1"}
{"signature": "def setup(self):", "body": "self.mktmp('<STR_LIT>')<EOL>", "docstring": "Make a valid python temp file.", "id": "f21416:c0:m0"}
{"signature": "def method(self, x, z=<NUM_LIT:2>):", "body": "", "docstring": "Some method's docstring", "id": "f21423:c0:m2"}
{"signature": "def setup():", "body": "<EOL>os.makedirs(IP_TEST_DIR)<EOL>", "docstring": "Setup test environment for the module:\n\n            - Adds dummy home dir tree", "id": "f21424:m0"}
{"signature": "@line_magic<EOL><INDENT>def page(self, parameter_s='<STR_LIT>'):<DEDENT>", "body": "<EOL>opts, args = self.parse_options(parameter_s, '<STR_LIT:r>')<EOL>raw = '<STR_LIT:r>' in opts<EOL>oname = args and args or '<STR_LIT:_>'<EOL>info = self.shell._ofind(oname)<EOL>if info['<STR_LIT>']:<EOL><INDENT>txt = (raw and str or pformat)( info['<STR_LIT>'] )<EOL>page.page(txt)<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>' % oname)<EOL><DEDENT>", "docstring": "Pretty print the object and display it through a pager.\n\n        %page [options] OBJECT\n\n        If no object is given, use _ (last output).\n\n        Options:\n\n          -r: page str(object), don't pretty-print it.", "id": "f21428:c0:m5"}
{"signature": "@magic_arguments.magic_arguments()<EOL><INDENT>@magic_arguments.argument(<EOL>'<STR_LIT>', '<STR_LIT>', action='<STR_LIT:store_true>', default=False,<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL>@magic_arguments.argument(<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>)<EOL>@magic_arguments.argument(<EOL>'<STR_LIT:filename>', type=unicode,<EOL>help='<STR_LIT>'<EOL>)<EOL>@line_magic<EOL>def notebook(self, s):<DEDENT>", "body": "args = magic_arguments.parse_argstring(self.notebook, s)<EOL>from IPython.nbformat import current<EOL>args.filename = unquote_filename(args.filename)<EOL>if args.export:<EOL><INDENT>fname, name, format = current.parse_filename(args.filename)<EOL>cells = []<EOL>hist = list(self.shell.history_manager.get_range())<EOL>for session, prompt_number, input in hist[:-<NUM_LIT:1>]:<EOL><INDENT>cells.append(current.new_code_cell(prompt_number=prompt_number,<EOL>input=input))<EOL><DEDENT>worksheet = current.new_worksheet(cells=cells)<EOL>nb = current.new_notebook(name=name,worksheets=[worksheet])<EOL>with io.open(fname, '<STR_LIT:w>', encoding='<STR_LIT:utf-8>') as f:<EOL><INDENT>current.write(nb, f, format);<EOL><DEDENT><DEDENT>elif args.format is not None:<EOL><INDENT>old_fname, old_name, old_format = current.parse_filename(args.filename)<EOL>new_format = args.format<EOL>if new_format == u'<STR_LIT>':<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>elif new_format == u'<STR_LIT>' or new_format == u'<STR_LIT>':<EOL><INDENT>new_fname = old_name + u'<STR_LIT>'<EOL>new_format = u'<STR_LIT>'<EOL><DEDENT>elif new_format == u'<STR_LIT>':<EOL><INDENT>new_fname = old_name + u'<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' % new_format)<EOL><DEDENT>with io.open(old_fname, '<STR_LIT:r>', encoding='<STR_LIT:utf-8>') as f:<EOL><INDENT>nb = current.read(f, old_format)<EOL><DEDENT>with io.open(new_fname, '<STR_LIT:w>', encoding='<STR_LIT:utf-8>') as f:<EOL><INDENT>current.write(nb, f, new_format)<EOL><DEDENT><DEDENT>", "docstring": "Export and convert IPython notebooks.\n\n        This function can export the current IPython history to a notebook file\n        or can convert an existing notebook file into a different format. For\n        example, to export the history to \"foo.ipynb\" do \"%notebook -e foo.ipynb\".\n        To export the history to \"foo.py\" do \"%notebook -e foo.py\". To convert\n        \"foo.ipynb\" to \"foo.json\" do \"%notebook -f json foo.ipynb\". Possible\n        formats include (json/ipynb, py).", "id": "f21428:c0:m14"}
{"signature": "@line_magic<EOL><INDENT>def quickref(self,arg):<DEDENT>", "body": "from IPython.core.usage import quick_reference<EOL>qr = quick_reference + self._magic_docs(brief=True)<EOL>page.page(qr)<EOL>", "docstring": "Show a quick reference sheet", "id": "f21428:c0:m10"}
{"signature": "@line_magic<EOL><INDENT>def automagic(self, parameter_s='<STR_LIT>'):<DEDENT>", "body": "arg = parameter_s.lower()<EOL>mman = self.shell.magics_manager<EOL>if arg in ('<STR_LIT>', '<STR_LIT:1>', '<STR_LIT:true>'):<EOL><INDENT>val = True<EOL><DEDENT>elif arg in ('<STR_LIT>', '<STR_LIT:0>', '<STR_LIT:false>'):<EOL><INDENT>val = False<EOL><DEDENT>else:<EOL><INDENT>val = not mman.auto_magic<EOL><DEDENT>mman.auto_magic = val<EOL>print('<STR_LIT:\\n>' + self.shell.magics_manager.auto_status())<EOL>", "docstring": "Make magic functions callable without having to type the initial %.\n\n        Without argumentsl toggles on/off (when off, you must call it as\n        %automagic, of course).  With arguments it sets the value, and you can\n        use any of (case insensitive):\n\n         - on, 1, True: to activate\n\n         - off, 0, False: to deactivate.\n\n        Note that magic functions have lowest priority, so if there's a\n        variable whose name collides with that of a magic fn, automagic won't\n        work for that function (you get the variable instead). However, if you\n        delete the variable (del var), the previously shadowed magic function\n        becomes visible to automagic again.", "id": "f21430:c0:m1"}
{"signature": "@line_magic<EOL><INDENT>def bookmark(self, parameter_s='<STR_LIT>'):<DEDENT>", "body": "opts,args = self.parse_options(parameter_s,'<STR_LIT>',mode='<STR_LIT:list>')<EOL>if len(args) > <NUM_LIT:2>:<EOL><INDENT>raise UsageError(\"<STR_LIT>\")<EOL><DEDENT>bkms = self.shell.db.get('<STR_LIT>',{})<EOL>if '<STR_LIT:d>' in opts:<EOL><INDENT>try:<EOL><INDENT>todel = args[<NUM_LIT:0>]<EOL><DEDENT>except IndexError:<EOL><INDENT>raise UsageError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>del bkms[todel]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise UsageError(<EOL>\"<STR_LIT>\" % todel)<EOL><DEDENT><DEDENT><DEDENT>elif '<STR_LIT:r>' in opts:<EOL><INDENT>bkms = {}<EOL><DEDENT>elif '<STR_LIT:l>' in opts:<EOL><INDENT>bks = list(bkms.keys())<EOL>bks.sort()<EOL>if bks:<EOL><INDENT>size = max(list(map(len, bks)))<EOL><DEDENT>else:<EOL><INDENT>size = <NUM_LIT:0><EOL><DEDENT>fmt = '<STR_LIT>'+str(size)+'<STR_LIT>'<EOL>print('<STR_LIT>')<EOL>for bk in bks:<EOL><INDENT>print(fmt % (bk, bkms[bk]))<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if not args:<EOL><INDENT>raise UsageError(\"<STR_LIT>\")<EOL><DEDENT>elif len(args)==<NUM_LIT:1>:<EOL><INDENT>bkms[args[<NUM_LIT:0>]] = os.getcwd()<EOL><DEDENT>elif len(args)==<NUM_LIT:2>:<EOL><INDENT>bkms[args[<NUM_LIT:0>]] = args[<NUM_LIT:1>]<EOL><DEDENT><DEDENT>self.shell.db['<STR_LIT>'] = bkms<EOL>", "docstring": "Manage IPython's bookmark system.\n\n        %bookmark <name>       - set bookmark to current dir\n        %bookmark <name> <dir> - set bookmark to <dir>\n        %bookmark -l           - list all bookmarks\n        %bookmark -d <name>    - remove bookmark\n        %bookmark -r           - remove all bookmarks\n\n        You can later on access a bookmarked folder with::\n\n          %cd -b <name>\n\n        or simply '%cd <name>' if there is no directory called <name> AND\n        there is such a bookmark defined.\n\n        Your bookmarks persist through IPython sessions, but they are\n        associated with each profile.", "id": "f21432:c0:m12"}
{"signature": "@line_cell_magic<EOL><INDENT>def sx(self, line='<STR_LIT>', cell=None):<DEDENT>", "body": "if cell is None:<EOL><INDENT>return self.shell.getoutput(line)<EOL><DEDENT>else:<EOL><INDENT>opts,args = self.parse_options(line, '<STR_LIT>', '<STR_LIT>')<EOL>output = self.shell.getoutput(cell)<EOL>out_name = opts.get('<STR_LIT>', opts.get('<STR_LIT:o>'))<EOL>if out_name:<EOL><INDENT>self.shell.user_ns[out_name] = output<EOL><DEDENT>else:<EOL><INDENT>return output<EOL><DEDENT><DEDENT>", "docstring": "Shell execute - run shell command and capture output (!! is short-hand).\n\n        %sx command\n\n        IPython will run the given command using commands.getoutput(), and\n        return the result formatted as a list (split on '\\\\n').  Since the\n        output is _returned_, it will be stored in ipython's regular output\n        cache Out[N] and in the '_N' automatic variables.\n\n        Notes:\n\n        1) If an input line begins with '!!', then %sx is automatically\n        invoked.  That is, while::\n\n          !ls\n\n        causes ipython to simply issue system('ls'), typing::\n\n          !!ls\n\n        is a shorthand equivalent to::\n\n          %sx ls\n\n        2) %sx differs from %sc in that %sx automatically splits into a list,\n        like '%sc -l'.  The reason for this is to make it as easy as possible\n        to process line-oriented shell output via further python commands.\n        %sc is meant to provide much finer control, but requires more\n        typing.\n\n        3) Just like %sc -l, this is a list with special attributes:\n        ::\n\n          .l (or .list) : value as list.\n          .n (or .nlstr): value as newline-separated string.\n          .s (or .spstr): value as whitespace-separated string.\n\n        This is very useful when trying to use such lists as arguments to\n        system commands.", "id": "f21432:c0:m11"}
{"signature": "@line_magic<EOL><INDENT>def unalias(self, parameter_s='<STR_LIT>'):<DEDENT>", "body": "aname = parameter_s.strip()<EOL>self.shell.alias_manager.undefine_alias(aname)<EOL>stored = self.shell.db.get('<STR_LIT>', {} )<EOL>if aname in stored:<EOL><INDENT>print(\"<STR_LIT>\",aname)<EOL>del stored[aname]<EOL>self.shell.db['<STR_LIT>'] = stored<EOL><DEDENT>", "docstring": "Remove an alias", "id": "f21432:c0:m1"}
{"signature": "@line_magic<EOL><INDENT>def pastebin(self, parameter_s='<STR_LIT>'):<DEDENT>", "body": "opts, args = self.parse_options(parameter_s, '<STR_LIT>')<EOL>try:<EOL><INDENT>code = self.shell.find_user_code(args)<EOL><DEDENT>except (ValueError, TypeError) as e:<EOL><INDENT>print(e.args[<NUM_LIT:0>])<EOL>return<EOL><DEDENT>post_data = json.dumps({<EOL>\"<STR_LIT:description>\": opts.get('<STR_LIT:d>', \"<STR_LIT>\"),<EOL>\"<STR_LIT>\": True,<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT:content>\": code<EOL>}<EOL>}<EOL>}).encode('<STR_LIT:utf-8>')<EOL>response = urlopen(\"<STR_LIT>\", post_data)<EOL>response_data = json.loads(response.read().decode('<STR_LIT:utf-8>'))<EOL>return response_data['<STR_LIT>']<EOL>", "docstring": "Upload code to Github's Gist paste bin, returning the URL.\n\n        Usage:\\\\\n          %pastebin [-d \"Custom description\"] 1-7\n\n        The argument can be an input history range, a filename, or the name of a\n        string or macro.\n\n        Options:\n\n          -d: Pass a custom description for the gist. The default will say\n              \"Pasted from IPython\".", "id": "f21433:c1:m1"}
{"signature": "@line_magic<EOL><INDENT>def pinfo2(self, parameter_s='<STR_LIT>', namespaces=None):<DEDENT>", "body": "self.shell._inspect('<STR_LIT>', parameter_s, detail_level=<NUM_LIT:1>,<EOL>namespaces=namespaces)<EOL>", "docstring": "Provide extra detailed information about an object.\n\n        '%pinfo2 object' is just a synonym for object?? or ??object.", "id": "f21434:c0:m1"}
{"signature": "@line_magic<EOL><INDENT>def reset_selective(self, parameter_s='<STR_LIT>'):<DEDENT>", "body": "opts, regex = self.parse_options(parameter_s,'<STR_LIT:f>')<EOL>if '<STR_LIT:f>' in opts:<EOL><INDENT>ans = True<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>ans = self.shell.ask_yes_no(<EOL>\"<STR_LIT>\",<EOL>default='<STR_LIT:n>')<EOL><DEDENT>except StdinNotImplementedError:<EOL><INDENT>ans = True<EOL><DEDENT><DEDENT>if not ans:<EOL><INDENT>print('<STR_LIT>')<EOL>return<EOL><DEDENT>user_ns = self.shell.user_ns<EOL>if not regex:<EOL><INDENT>print('<STR_LIT>')<EOL>return<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>m = re.compile(regex)<EOL><DEDENT>except TypeError:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>for i in self.who_ls():<EOL><INDENT>if m.search(i):<EOL><INDENT>del(user_ns[i])<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Resets the namespace by removing names defined by the user.\n\n        Input/Output history are left around in case you need them.\n\n        %reset_selective [-f] regex\n\n        No action is taken if regex is not included\n\n        Options\n          -f : force reset without asking for confirmation.\n\n        See Also\n        --------\n        magic_reset : invoked as ``%reset``\n\n        Examples\n        --------\n\n        We first fully reset the namespace so your output looks identical to\n        this example for pedagogical reasons; in practice you do not need a\n        full reset::\n\n          In [1]: %reset -f\n\n        Now, with a clean namespace we can make a few variables and use\n        ``%reset_selective`` to only delete names that match our regexp::\n\n          In [2]: a=1; b=2; c=3; b1m=4; b2m=5; b3m=6; b4m=7; b2s=8\n\n          In [3]: who_ls\n          Out[3]: ['a', 'b', 'b1m', 'b2m', 'b2s', 'b3m', 'b4m', 'c']\n\n          In [4]: %reset_selective -f b[2-3]m\n\n          In [5]: who_ls\n          Out[5]: ['a', 'b', 'b1m', 'b2s', 'b4m', 'c']\n\n          In [6]: %reset_selective -f d\n\n          In [7]: who_ls\n          Out[7]: ['a', 'b', 'b1m', 'b2s', 'b4m', 'c']\n\n          In [8]: %reset_selective -f c\n\n          In [9]: who_ls\n          Out[9]: ['a', 'b', 'b1m', 'b2s', 'b4m']\n\n          In [10]: %reset_selective -f b\n\n          In [11]: who_ls\n          Out[11]: ['a']\n\n        Notes\n        -----\n        Calling this magic from clients that do not implement standard input,\n        such as the ipython notebook interface, will reset the namespace\n        without confirmation.", "id": "f21434:c0:m11"}
{"signature": "@line_magic<EOL><INDENT>def pfile(self, parameter_s='<STR_LIT>'):<DEDENT>", "body": "<EOL>out = self.shell._inspect('<STR_LIT>',parameter_s)<EOL>if out == '<STR_LIT>':<EOL><INDENT>try:<EOL><INDENT>filename = get_py_filename(parameter_s)<EOL><DEDENT>except IOError as msg:<EOL><INDENT>print(msg)<EOL>return<EOL><DEDENT>page.page(self.shell.inspector.format(open(filename).read()))<EOL><DEDENT>", "docstring": "Print (or run through pager) the file where an object is defined.\n\n        The file opens at the line where the object definition begins. IPython\n        will honor the environment variable PAGER if set, and otherwise will\n        do its best to print the file in a convenient form.\n\n        If the given argument is not an object currently defined, IPython will\n        try to interpret it as a filename (automatically adding a .py extension\n        if needed). You can thus use %pfile as a syntax highlighting code\n        viewer.", "id": "f21434:c0:m5"}
{"signature": "@line_magic<EOL><INDENT>def psearch(self, parameter_s='<STR_LIT>'):<DEDENT>", "body": "try:<EOL><INDENT>parameter_s.encode('<STR_LIT:ascii>')<EOL><DEDENT>except UnicodeEncodeError:<EOL><INDENT>print('<STR_LIT>')<EOL>return<EOL><DEDENT>def_search = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>opts,args = self.parse_options(parameter_s,'<STR_LIT>',list_all=True)<EOL>opt = opts.get<EOL>shell = self.shell<EOL>psearch = shell.inspector.psearch<EOL>if '<STR_LIT:i>' in opts:<EOL><INDENT>ignore_case = True<EOL><DEDENT>elif '<STR_LIT:c>' in opts:<EOL><INDENT>ignore_case = False<EOL><DEDENT>else:<EOL><INDENT>ignore_case = not shell.wildcards_case_sensitive<EOL><DEDENT>def_search.extend(opt('<STR_LIT:s>',[]))<EOL>ns_exclude = ns_exclude=opt('<STR_LIT:e>',[])<EOL>ns_search = [nm for nm in def_search if nm not in ns_exclude]<EOL>try:<EOL><INDENT>psearch(args,shell.ns_table,ns_search,<EOL>show_all=opt('<STR_LIT:a>'),ignore_case=ignore_case)<EOL><DEDENT>except:<EOL><INDENT>shell.showtraceback()<EOL><DEDENT>", "docstring": "Search for object in namespaces by wildcard.\n\n        %psearch [options] PATTERN [OBJECT TYPE]\n\n        Note: ? can be used as a synonym for %psearch, at the beginning or at\n        the end: both a*? and ?a* are equivalent to '%psearch a*'.  Still, the\n        rest of the command line must be unchanged (options come first), so\n        for example the following forms are equivalent\n\n        %psearch -i a* function\n        -i a* function?\n        ?-i a* function\n\n        Arguments:\n\n          PATTERN\n\n          where PATTERN is a string containing * as a wildcard similar to its\n          use in a shell.  The pattern is matched in all namespaces on the\n          search path. By default objects starting with a single _ are not\n          matched, many IPython generated objects have a single\n          underscore. The default is case insensitive matching. Matching is\n          also done on the attributes of objects and not only on the objects\n          in a module.\n\n          [OBJECT TYPE]\n\n          Is the name of a python type from the types module. The name is\n          given in lowercase without the ending type, ex. StringType is\n          written string. By adding a type here only objects matching the\n          given type are matched. Using all here makes the pattern match all\n          types (this is the default).\n\n        Options:\n\n          -a: makes the pattern match even objects whose names start with a\n          single underscore.  These names are normally omitted from the\n          search.\n\n          -i/-c: make the pattern case insensitive/sensitive.  If neither of\n          these options are given, the default is read from your configuration\n          file, with the option ``InteractiveShell.wildcards_case_sensitive``.\n          If this option is not specified in your configuration file, IPython's\n          internal default is to do a case sensitive search.\n\n          -e/-s NAMESPACE: exclude/search a given namespace.  The pattern you\n          specify can be searched in any of the following namespaces:\n          'builtin', 'user', 'user_global','internal', 'alias', where\n          'builtin' and 'user' are the search defaults.  Note that you should\n          not use quotes when specifying namespaces.\n\n          'Builtin' contains the python module builtin, 'user' contains all\n          user data, 'alias' only contain the shell aliases and no python\n          objects, 'internal' contains objects used by IPython.  The\n          'user_global' namespace is only used by embedded IPython instances,\n          and it contains module-level globals.  You can add namespaces to the\n          search with -s or exclude them with -e (these options can be given\n          more than once).\n\n        Examples\n        --------\n        ::\n\n          %psearch a*            -> objects beginning with an a\n          %psearch -e builtin a* -> objects NOT in the builtin space starting in a\n          %psearch a* function   -> all functions beginning with an a\n          %psearch re.e*         -> objects beginning with an e in module re\n          %psearch r*.e*         -> objects that start with e in modules starting in r\n          %psearch r*.* string   -> all strings in modules beginning with r\n\n        Case sensitive search::\n\n          %psearch -c a*         list all object beginning with lower case a\n\n        Show objects beginning with a single _::\n\n          %psearch -a _*         list objects beginning with a single underscore", "id": "f21434:c0:m6"}
{"signature": "@line_magic<EOL><INDENT>def pinfo(self, parameter_s='<STR_LIT>', namespaces=None):<DEDENT>", "body": "<EOL>detail_level = <NUM_LIT:0><EOL>pinfo,qmark1,oname,qmark2 =re.match('<STR_LIT>',parameter_s).groups()<EOL>if pinfo or qmark1 or qmark2:<EOL><INDENT>detail_level = <NUM_LIT:1><EOL><DEDENT>if \"<STR_LIT:*>\" in oname:<EOL><INDENT>self.psearch(oname)<EOL><DEDENT>else:<EOL><INDENT>self.shell._inspect('<STR_LIT>', oname, detail_level=detail_level,<EOL>namespaces=namespaces)<EOL><DEDENT>", "docstring": "Provide detailed information about an object.\n\n        '%pinfo object' is just a synonym for object? or ?object.", "id": "f21434:c0:m0"}
{"signature": "@line_magic<EOL><INDENT>def unload_ext(self, module_str):<DEDENT>", "body": "self.shell.extension_manager.unload_extension(module_str)<EOL>", "docstring": "Unload an IPython extension by its module name.", "id": "f21435:c0:m2"}
{"signature": "@line_magic<EOL><INDENT>def tb(self, s):<DEDENT>", "body": "self.shell.showtraceback()<EOL>", "docstring": "Print the last traceback with the currently active exception mode.\n\n        See %xmode for changing exception reporting modes.", "id": "f21438:c0:m5"}
{"signature": "@magic_arguments.magic_arguments()<EOL><INDENT>@magic_arguments.argument('<STR_LIT>', type=str, default='<STR_LIT>', nargs='<STR_LIT:?>',<EOL>help=\"\"\"<STR_LIT>\"\"\"<EOL>)<EOL>@magic_arguments.argument('<STR_LIT>', action=\"<STR_LIT:store_true>\",<EOL>help=\"\"\"<STR_LIT>\"\"\"<EOL>)<EOL>@magic_arguments.argument('<STR_LIT>', action=\"<STR_LIT:store_true>\",<EOL>help=\"\"\"<STR_LIT>\"\"\"<EOL>)<EOL>@cell_magic<EOL>def capture(self, line, cell):<DEDENT>", "body": "args = magic_arguments.parse_argstring(self.capture, line)<EOL>out = not args.no_stdout<EOL>err = not args.no_stderr<EOL>with capture_output(out, err) as io:<EOL><INDENT>self.shell.run_cell(cell)<EOL><DEDENT>if args.output:<EOL><INDENT>self.shell.user_ns[args.output] = io<EOL><DEDENT>", "docstring": "run the cell, capturing stdout/err", "id": "f21438:c0:m10"}
{"signature": "def cwd_filt(depth):", "body": "cwd = os.getcwdu().replace(HOME,\"<STR_LIT>\")<EOL>out = os.sep.join(cwd.split(os.sep)[-depth:])<EOL>return out or os.sep<EOL>", "docstring": "Return the last depth elements of the current working directory.\n\n    $HOME is always replaced with '~'.\n    If depth==0, the full path is returned.", "id": "f21439:m1"}
{"signature": "def __call__(self, etype, evalue, etb):", "body": "<EOL>sys.excepthook = sys.__excepthook__<EOL>color_scheme = '<STR_LIT>'<EOL>try:<EOL><INDENT>rptdir = self.app.ipython_dir<EOL><DEDENT>except:<EOL><INDENT>rptdir = os.getcwdu()<EOL><DEDENT>if rptdir is None or not os.path.isdir(rptdir):<EOL><INDENT>rptdir = os.getcwdu()<EOL><DEDENT>report_name = os.path.join(rptdir,self.crash_report_fname)<EOL>self.crash_report_fname = report_name<EOL>self.info['<STR_LIT>'] = report_name<EOL>TBhandler = ultratb.VerboseTB(<EOL>color_scheme=color_scheme,<EOL>long_header=<NUM_LIT:1>,<EOL>call_pdb=self.call_pdb,<EOL>)<EOL>if self.call_pdb:<EOL><INDENT>TBhandler(etype,evalue,etb)<EOL>return<EOL><DEDENT>else:<EOL><INDENT>traceback = TBhandler.text(etype,evalue,etb,context=<NUM_LIT>)<EOL><DEDENT>if self.show_crash_traceback:<EOL><INDENT>print >> sys.stderr, traceback<EOL><DEDENT>try:<EOL><INDENT>report = open(report_name,'<STR_LIT:w>')<EOL><DEDENT>except:<EOL><INDENT>print >> sys.stderr, '<STR_LIT>'<EOL>return<EOL><DEDENT>print >> sys.stderr, '<STR_LIT:\\n>'+'<STR_LIT:*>'*<NUM_LIT>+'<STR_LIT:\\n>'<EOL>print >> sys.stderr, self.message_template.format(**self.info)<EOL>report.write(self.make_report(traceback))<EOL>report.close()<EOL>raw_input(\"<STR_LIT>\")<EOL>", "docstring": "Handle an exception, call for compatible with sys.excepthook", "id": "f21440:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def create_profile_dir_by_name(cls, path, name='<STR_LIT:default>', config=None):<DEDENT>", "body": "if not os.path.isdir(path):<EOL><INDENT>raise ProfileDirError('<STR_LIT>' % path)<EOL><DEDENT>profile_dir = os.path.join(path, '<STR_LIT>' + name)<EOL>return cls(location=profile_dir, config=config)<EOL>", "docstring": "Create a profile dir by profile name and path.\n\n        Parameters\n        ----------\n        path : unicode\n            The path (directory) to put the profile directory in.\n        name : unicode\n            The name of the profile.  The name of the profile directory will\n            be \"profile_<profile>\".", "id": "f21441:c1:m12"}
{"signature": "def excepthook(self, etype, value, tb):", "body": "self.showtraceback((etype,value,tb),tb_offset=<NUM_LIT:0>)<EOL>", "docstring": "One more defense for GUI apps that call sys.excepthook.\n\n        GUI frameworks like wxPython trap exceptions and call\n        sys.excepthook themselves.  I guess this is a feature that\n        enables them to keep running after exceptions that would\n        otherwise kill their mainloop. This is a bother for IPython\n        which excepts to catch all of the program exceptions with a try:\n        except: statement.\n\n        Normally, IPython sets sys.excepthook to a CrashHandler instance, so if\n        any app directly invokes sys.excepthook, it will look to the user like\n        IPython crashed.  In order to work around this, we can disable the\n        CrashHandler and replace it with this excepthook instead, which prints a\n        regular traceback using our InteractiveTB.  In this fashion, apps which\n        call sys.excepthook will generate a regular-looking exception from\n        IPython, and the CrashHandler will only be triggered by real IPython\n        crashes.\n\n        This hook should be used sparingly, only in places which are not likely\n        to be true IPython errors.", "id": "f21442:c5:m56"}
{"signature": "def reset_selective(self, regex=None):", "body": "if regex is not None:<EOL><INDENT>try:<EOL><INDENT>m = re.compile(regex)<EOL><DEDENT>except TypeError:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>for ns in self.all_ns_refs:<EOL><INDENT>for var in ns:<EOL><INDENT>if m.search(var):<EOL><INDENT>del ns[var]<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Clear selective variables from internal namespaces based on a\n        specified regular expression.\n\n        Parameters\n        ----------\n        regex : string or compiled pattern, optional\n            A regular expression pattern that will be used in searching\n            variable names in the users namespaces.", "id": "f21442:c5:m45"}
{"signature": "def init_virtualenv(self):", "body": "if '<STR_LIT>' not in os.environ:<EOL><INDENT>return<EOL><DEDENT>if sys.executable.startswith(os.environ['<STR_LIT>']):<EOL><INDENT>return<EOL><DEDENT>warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>if sys.platform == \"<STR_LIT:win32>\":<EOL><INDENT>virtual_env = os.path.join(os.environ['<STR_LIT>'], '<STR_LIT>', '<STR_LIT>') <EOL><DEDENT>else:<EOL><INDENT>virtual_env = os.path.join(os.environ['<STR_LIT>'], '<STR_LIT>',<EOL>'<STR_LIT>' % sys.version_info[:<NUM_LIT:2>], '<STR_LIT>')<EOL><DEDENT>import site<EOL>sys.path.insert(<NUM_LIT:0>, virtual_env)<EOL>site.addsitedir(virtual_env)<EOL>", "docstring": "Add a virtualenv to sys.path so the user can import modules from it.\n        This isn't perfect: it doesn't use the Python interpreter with which the\n        virtualenv was built, and it ignores the --no-site-packages option. A\n        warning will appear suggesting the user installs IPython in the\n        virtualenv, but for many cases, it probably works well enough.\n\n        Adapted from code snippets online.\n\n        http://blog.ufsoft.org/2009/1/29/ipython-and-virtualenv", "id": "f21442:c5:m24"}
{"signature": "def push(self, variables, interactive=True):", "body": "vdict = None<EOL>if isinstance(variables, dict):<EOL><INDENT>vdict = variables<EOL><DEDENT>elif isinstance(variables, (str, list, tuple)):<EOL><INDENT>if isinstance(variables, str):<EOL><INDENT>vlist = variables.split()<EOL><DEDENT>else:<EOL><INDENT>vlist = variables<EOL><DEDENT>vdict = {}<EOL>cf = sys._getframe(<NUM_LIT:1>)<EOL>for name in vlist:<EOL><INDENT>try:<EOL><INDENT>vdict[name] = eval(name, cf.f_globals, cf.f_locals)<EOL><DEDENT>except:<EOL><INDENT>print(('<STR_LIT>' %<EOL>(name,cf.f_code.co_name)))<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>self.user_ns.update(vdict)<EOL>user_ns_hidden = self.user_ns_hidden<EOL>if interactive:<EOL><INDENT>user_ns_hidden.difference_update(vdict)<EOL><DEDENT>else:<EOL><INDENT>user_ns_hidden.update(vdict)<EOL><DEDENT>", "docstring": "Inject a group of variables into the IPython user namespace.\n\n        Parameters\n        ----------\n        variables : dict, str or list/tuple of str\n            The variables to inject into the user's namespace.  If a dict, a\n            simple update is done.  If a str, the string is assumed to have\n            variable names separated by spaces.  A list/tuple of str can also\n            be used to give the variable names.  If just the variable names are\n            give (list/tuple/str) then the variable values looked up in the\n            callers frame.\n        interactive : bool\n            If True (default), the variables will be listed with the ``who``\n            magic.", "id": "f21442:c5:m46"}
{"signature": "def enable_pylab(self, gui=None, import_all=True):", "body": "from IPython.core.pylabtools import mpl_runner<EOL>ns = {}<EOL>try:<EOL><INDENT>gui = pylab_activate(ns, gui, import_all, self)<EOL><DEDENT>except KeyError:<EOL><INDENT>error(\"<STR_LIT>\" % gui)<EOL>return<EOL><DEDENT>self.user_ns.update(ns)<EOL>self.user_ns_hidden.update(ns)<EOL>self.enable_gui(gui)<EOL>self.magics_manager.registry['<STR_LIT>'].default_runner =mpl_runner(self.safe_execfile)<EOL>", "docstring": "Activate pylab support at runtime.\n\n        This turns on support for matplotlib, preloads into the interactive\n        namespace all of numpy and pylab, and configures IPython to correctly\n        interact with the GUI event loop.  The GUI backend to be used can be\n        optionally selected with the optional :param:`gui` argument.\n\n        Parameters\n        ----------\n        gui : optional, string\n\n          If given, dictates the choice of matplotlib GUI backend to use\n          (should be one of IPython's supported backends, 'qt', 'osx', 'tk',\n          'gtk', 'wx' or 'inline'), otherwise we use the default chosen by\n          matplotlib (as dictated by the matplotlib build-time options plus the\n          user's matplotlibrc configuration file).  Note that not all backends\n          make sense in all contexts, for example a terminal ipython can't\n          display figures inline.", "id": "f21442:c5:m102"}
{"signature": "def var_expand(self, cmd, depth=<NUM_LIT:0>, formatter=DollarFormatter()):", "body": "ns = self.user_ns.copy()<EOL>ns.update(sys._getframe(depth+<NUM_LIT:1>).f_locals)<EOL>ns.pop('<STR_LIT>', None)<EOL>try:<EOL><INDENT>cmd = formatter.format(cmd, **ns)<EOL><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT>return cmd<EOL>", "docstring": "Expand python variables in a string.\n\n        The depth argument indicates how many frames above the caller should\n        be walked to look for the local namespace where to expand variables.\n\n        The global namespace for expansion is always the user's interactive\n        namespace.", "id": "f21442:c5:m103"}
{"signature": "def init_logstart(self):", "body": "if self.logappend:<EOL><INDENT>self.magic('<STR_LIT>' % self.logappend)<EOL><DEDENT>elif self.logfile:<EOL><INDENT>self.magic('<STR_LIT>' % self.logfile)<EOL><DEDENT>elif self.logstart:<EOL><INDENT>self.magic('<STR_LIT>')<EOL><DEDENT>", "docstring": "Initialize logging in case it was requested at the command line.", "id": "f21442:c5:m15"}
{"signature": "def clear_main_mod_cache(self):", "body": "self._main_ns_cache.clear()<EOL>", "docstring": "Clear the cache of main modules.\n\n        Mainly for use by utilities like %reset.\n\n        Examples\n        --------\n\n        In [15]: import IPython\n\n        In [16]: _ip.cache_main_mod(IPython.__dict__,IPython.__file__)\n\n        In [17]: len(_ip._main_ns_cache) > 0\n        Out[17]: True\n\n        In [18]: _ip.clear_main_mod_cache()\n\n        In [19]: len(_ip._main_ns_cache) == 0\n        Out[19]: True", "id": "f21442:c5:m32"}
{"signature": "def safe_run_module(self, mod_name, where):", "body": "try:<EOL><INDENT>where.update(<EOL>runpy.run_module(str(mod_name), run_name=\"<STR_LIT:__main__>\",<EOL>alter_sys=True)<EOL>)<EOL><DEDENT>except:<EOL><INDENT>self.showtraceback()<EOL>warn('<STR_LIT>' % mod_name)<EOL><DEDENT>", "docstring": "A safe version of runpy.run_module().\n\n        This version will never throw an exception, but instead print\n        helpful error messages to the screen.\n\n        Parameters\n        ----------\n        mod_name : string\n            The name of the module to be executed.\n        where : dict\n            The globals namespace.", "id": "f21442:c5:m96"}
{"signature": "def init_user_ns(self):", "body": "<EOL>ns = dict()<EOL>try:<EOL><INDENT>from site import _Helper<EOL>ns['<STR_LIT>'] = _Helper()<EOL><DEDENT>except ImportError:<EOL><INDENT>warn('<STR_LIT>')<EOL><DEDENT>ns['<STR_LIT>'] = self.history_manager.input_hist_parsed<EOL>ns['<STR_LIT>'] = self.history_manager.output_hist<EOL>ns['<STR_LIT>'] = self.history_manager.dir_hist<EOL>ns['<STR_LIT>'] = shadowns<EOL>ns['<STR_LIT>']  = self.history_manager.input_hist_parsed<EOL>ns['<STR_LIT>'] = self.history_manager.output_hist<EOL>ns['<STR_LIT>'] = self.get_ipython<EOL>ns['<STR_LIT>'] = self.exiter<EOL>ns['<STR_LIT>'] = self.exiter<EOL>self.user_ns_hidden.update(ns)<EOL>self.user_ns.update(ns)<EOL>", "docstring": "Initialize all user-visible namespaces to their minimum defaults.\n\n        Certain history lists are also initialized here, as they effectively\n        act as user namespaces.\n\n        Notes\n        -----\n        All data structures here are only filled in, they are NOT reset by this\n        method.  If they were not empty before, data will simply be added to\n        therm.", "id": "f21442:c5:m41"}
{"signature": "def complete(self, text, line=None, cursor_pos=None):", "body": "<EOL>with self.builtin_trap:<EOL><INDENT>return self.Completer.complete(text, line, cursor_pos)<EOL><DEDENT>", "docstring": "Return the completed text and a list of completions.\n\n        Parameters\n        ----------\n\n           text : string\n             A string of text to be completed on.  It can be given as empty and\n             instead a line/position pair are given.  In this case, the\n             completer itself will split the line like readline does.\n\n           line : string, optional\n             The complete line that text is part of.\n\n           cursor_pos : int, optional\n             The position of the cursor on the input line.\n\n        Returns\n        -------\n          text : string\n            The actual text that was completed.\n\n          matches : list\n            A sorted list with all possible completions.\n\n        The optional arguments allow the completion to take more context into\n        account, and are part of the low-level completion API.\n\n        This is a wrapper around the completion mechanism, similar to what\n        readline does at the command line when the TAB key is hit.  By\n        exposing it as a method, it can be used by other non-readline\n        environments (such as GUIs) for text completion.\n\n        Simple usage example:\n\n        In [1]: x = 'hello'\n\n        In [2]: _ip.complete('x.l')\n        Out[2]: ('x.l', ['x.ljust', 'x.lower', 'x.lstrip'])", "id": "f21442:c5:m68"}
{"signature": "def prepare_user_module(self, user_module=None, user_ns=None):", "body": "if user_module is None and user_ns is not None:<EOL><INDENT>user_ns.setdefault(\"<STR_LIT>\", \"<STR_LIT:__main__>\")<EOL>class DummyMod(object):<EOL><INDENT>\"<STR_LIT>\"<EOL>pass<EOL><DEDENT>user_module = DummyMod()<EOL>user_module.__dict__ = user_ns<EOL><DEDENT>if user_module is None:<EOL><INDENT>user_module = types.ModuleType(\"<STR_LIT:__main__>\",<EOL>doc=\"<STR_LIT>\")<EOL><DEDENT>user_module.__dict__.setdefault('<STR_LIT>', builtin_mod)<EOL>user_module.__dict__.setdefault('<STR_LIT>', builtin_mod)<EOL>if user_ns is None:<EOL><INDENT>user_ns = user_module.__dict__<EOL><DEDENT>return user_module, user_ns<EOL>", "docstring": "Prepare the module and namespace in which user code will be run.\n\n        When IPython is started normally, both parameters are None: a new module\n        is created automatically, and its __dict__ used as the namespace.\n\n        If only user_module is provided, its __dict__ is used as the namespace.\n        If only user_ns is provided, a dummy module is created, and user_ns\n        becomes the global namespace. If both are provided (as they may be\n        when embedding), user_ns is the local namespace, and user_module\n        provides the global namespace.\n\n        Parameters\n        ----------\n        user_module : module, optional\n            The current user module in which IPython is being run. If None,\n            a clean module will be created.\n        user_ns : dict, optional\n            A namespace in which to run interactive commands.\n\n        Returns\n        -------\n        A tuple of user_module and user_ns, each properly initialised.", "id": "f21442:c5:m39"}
{"signature": "def mktempfile(self, data=None, prefix='<STR_LIT>'):", "body": "filename = tempfile.mktemp('<STR_LIT>', prefix)<EOL>self.tempfiles.append(filename)<EOL>if data:<EOL><INDENT>tmp_file = open(filename,'<STR_LIT:w>')<EOL>tmp_file.write(data)<EOL>tmp_file.close()<EOL><DEDENT>return filename<EOL>", "docstring": "Make a new tempfile and return its filename.\n\n        This makes a call to tempfile.mktemp, but it registers the created\n        filename internally so ipython cleans it up at exit time.\n\n        Optional inputs:\n\n          - data(None): if data is given, it gets written out to the temp file\n          immediately, and the file is closed again.", "id": "f21442:c5:m104"}
{"signature": "def register_post_execute(self, func):", "body": "if not callable(func):<EOL><INDENT>raise ValueError('<STR_LIT>' % func)<EOL><DEDENT>self._post_execute[func] = True<EOL>", "docstring": "Register a function for calling after code execution.", "id": "f21442:c5:m29"}
{"signature": "def debugger(self,force=False):", "body": "if not (force or self.call_pdb):<EOL><INDENT>return<EOL><DEDENT>if not hasattr(sys,'<STR_LIT>'):<EOL><INDENT>error('<STR_LIT>')<EOL>return<EOL><DEDENT>if debugger.has_pydb:<EOL><INDENT>from pydb import pm<EOL><DEDENT>else:<EOL><INDENT>pm = lambda : self.InteractiveTB.debugger(force=True)<EOL><DEDENT>with self.readline_no_record:<EOL><INDENT>pm()<EOL><DEDENT>", "docstring": "Call the pydb/pdb debugger.\n\n        Keywords:\n\n          - force(False): by default, this routine checks the instance call_pdb\n          flag and does not actually invoke the debugger if the flag is false.\n          The 'force' option forces the debugger to activate even if the flag\n          is false.", "id": "f21442:c5:m36"}
{"signature": "def get_readline_tail(self, n=<NUM_LIT:10>):", "body": "end = self.shell.readline.get_current_history_length() + <NUM_LIT:1><EOL>start = max(end-n, <NUM_LIT:1>)<EOL>ghi = self.shell.readline.get_history_item<EOL>return [ghi(x) for x in range(start, end)]<EOL>", "docstring": "Get the last n items in readline history.", "id": "f21442:c4:m4"}
{"signature": "def set_custom_exc(self, exc_tuple, handler):", "body": "assert type(exc_tuple)==type(()) ,\"<STR_LIT>\"<EOL>def dummy_handler(self,etype,value,tb,tb_offset=None):<EOL><INDENT>print('<STR_LIT>')<EOL>print('<STR_LIT>',etype)<EOL>print('<STR_LIT>',value)<EOL>print('<STR_LIT>',tb)<EOL><DEDENT>def validate_stb(stb):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>msg = \"<STR_LIT>\" % stb<EOL>if stb is None:<EOL><INDENT>return []<EOL><DEDENT>elif isinstance(stb, str):<EOL><INDENT>return [stb]<EOL><DEDENT>elif not isinstance(stb, list):<EOL><INDENT>raise TypeError(msg)<EOL><DEDENT>for line in stb:<EOL><INDENT>if not isinstance(line, str):<EOL><INDENT>raise TypeError(msg)<EOL><DEDENT><DEDENT>return stb<EOL><DEDENT>if handler is None:<EOL><INDENT>wrapped = dummy_handler<EOL><DEDENT>else:<EOL><INDENT>def wrapped(self,etype,value,tb,tb_offset=None):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>try:<EOL><INDENT>stb = handler(self,etype,value,tb,tb_offset=tb_offset)<EOL>return validate_stb(stb)<EOL><DEDENT>except:<EOL><INDENT>self.set_custom_exc((), None)<EOL>print(\"<STR_LIT>\", file=io.stderr)<EOL>stb = self.InteractiveTB.structured_traceback(*sys.exc_info())<EOL>print(self.InteractiveTB.stb2text(stb), file=io.stdout)<EOL>print(\"<STR_LIT>\", file=io.stdout)<EOL>stb = self.InteractiveTB.structured_traceback(<EOL>(etype,value,tb), tb_offset=tb_offset<EOL>)<EOL><DEDENT>return stb<EOL><DEDENT><DEDENT>self.CustomTB = types.MethodType(wrapped,self)<EOL>self.custom_exceptions = exc_tuple<EOL>", "docstring": "set_custom_exc(exc_tuple,handler)\n\n        Set a custom exception handler, which will be called if any of the\n        exceptions in exc_tuple occur in the mainloop (specifically, in the\n        run_code() method).\n\n        Parameters\n        ----------\n\n        exc_tuple : tuple of exception classes\n            A *tuple* of exception classes, for which to call the defined\n            handler.  It is very important that you use a tuple, and NOT A\n            LIST here, because of the way Python's except statement works.  If\n            you only want to trap a single exception, use a singleton tuple::\n\n                exc_tuple == (MyCustomException,)\n\n        handler : callable\n            handler must have the following signature::\n\n                def my_handler(self, etype, value, tb, tb_offset=None):\n                    ...\n                    return structured_traceback\n\n            Your handler must return a structured traceback (a list of strings),\n            or None.\n\n            This will be made into an instance method (via types.MethodType)\n            of IPython itself, and it will be called if any of the exceptions\n            listed in the exc_tuple are caught. If the handler is None, an\n            internal basic one is used, which just prints basic info.\n\n            To protect IPython from crashes, if your handler ever raises an\n            exception or returns an invalid result, it will be immediately\n            disabled.\n\n        WARNING: by putting in your own exception handler into IPython's main\n        execution loop, you run a very good chance of nasty crashes.  This\n        facility should only be used if you really know what you are doing.", "id": "f21442:c5:m55"}
{"signature": "def set_autoindent(self,value=None):", "body": "if value != <NUM_LIT:0> and not self.has_readline:<EOL><INDENT>if os.name == '<STR_LIT>':<EOL><INDENT>warn(\"<STR_LIT>\")<EOL><DEDENT>self.autoindent = <NUM_LIT:0><EOL>return<EOL><DEDENT>if value is None:<EOL><INDENT>self.autoindent = not self.autoindent<EOL><DEDENT>else:<EOL><INDENT>self.autoindent = value<EOL><DEDENT>", "docstring": "Set the autoindent flag, checking for readline support.\n\n        If called with no arguments, it acts as a toggle.", "id": "f21442:c5:m6"}
{"signature": "def cache_main_mod(self,ns,fname):", "body": "self._main_ns_cache[os.path.abspath(fname)] = ns.copy()<EOL>", "docstring": "Cache a main module's namespace.\n\n        When scripts are executed via %run, we must keep a reference to the\n        namespace of their __main__ module (a FakeModule instance) around so\n        that Python doesn't clear it, rendering objects defined therein\n        useless.\n\n        This method keeps said reference in a private dict, keyed by the\n        absolute path of the module object (which corresponds to the script\n        path).  This way, for multiple executions of the same script we only\n        keep one copy of the namespace (the last one), thus preventing memory\n        leaks from old references while allowing the objects from the last\n        execution to be accessible.\n\n        Note: we can not allow the actual FakeModule instances to be deleted,\n        because of how Python tears down modules (it hard-sets all their\n        references to None without regard for reference counts).  This method\n        must therefore make a *copy* of the given namespace, to allow the\n        original module's __dict__ to be cleared and reused.\n\n\n        Parameters\n        ----------\n          ns : a namespace (a dict, typically)\n\n          fname : str\n            Filename associated with the namespace.\n\n        Examples\n        --------\n\n        In [10]: import IPython\n\n        In [11]: _ip.cache_main_mod(IPython.__dict__,IPython.__file__)\n\n        In [12]: IPython.__file__ in _ip._main_ns_cache\n        Out[12]: True", "id": "f21442:c5:m31"}
{"signature": "def set_completer_frame(self, frame=None):", "body": "if frame:<EOL><INDENT>self.Completer.namespace = frame.f_locals<EOL>self.Completer.global_namespace = frame.f_globals<EOL><DEDENT>else:<EOL><INDENT>self.Completer.namespace = self.user_ns<EOL>self.Completer.global_namespace = self.user_global_ns<EOL><DEDENT>", "docstring": "Set the frame of the completer.", "id": "f21442:c5:m71"}
{"signature": "def del_var(self, varname, by_name=False):", "body": "if varname in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % varname)<EOL><DEDENT>ns_refs = self.all_ns_refs<EOL>if by_name:                    <EOL><INDENT>for ns in ns_refs:<EOL><INDENT>try:<EOL><INDENT>del ns[varname]<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT>else:                         <EOL><INDENT>try:<EOL><INDENT>obj = self.user_ns[varname]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise NameError(\"<STR_LIT>\" % varname)<EOL><DEDENT>ns_refs.append(self.history_manager.output_hist)<EOL>for ns in ns_refs:<EOL><INDENT>to_delete = [n for n, o in ns.items() if o is obj]<EOL>for name in to_delete:<EOL><INDENT>del ns[name]<EOL><DEDENT><DEDENT>for name in ('<STR_LIT:_>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>if getattr(self.displayhook, name) is obj:<EOL><INDENT>setattr(self.displayhook, name, None)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Delete a variable from the various namespaces, so that, as\n        far as possible, we're not keeping any hidden references to it.\n\n        Parameters\n        ----------\n        varname : str\n            The name of the variable to delete.\n        by_name : bool\n            If True, delete variables with the given name in each\n            namespace. If False (default), find the variable in the user\n            namespace, and delete references to it.", "id": "f21442:c5:m44"}
{"signature": "def _inspect(self, meth, oname, namespaces=None, **kw):", "body": "info = self._object_find(oname, namespaces)<EOL>if info.found:<EOL><INDENT>pmethod = getattr(self.inspector, meth)<EOL>formatter = format_screen if info.ismagic else None<EOL>if meth == '<STR_LIT>':<EOL><INDENT>pmethod(info.obj, oname, formatter)<EOL><DEDENT>elif meth == '<STR_LIT>':<EOL><INDENT>pmethod(info.obj, oname, formatter, info, **kw)<EOL><DEDENT>else:<EOL><INDENT>pmethod(info.obj, oname)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>print('<STR_LIT>' % oname)<EOL>return '<STR_LIT>'<EOL><DEDENT>", "docstring": "Generic interface to the inspector system.\n\n        This function is meant to be called by pdef, pdoc & friends.", "id": "f21442:c5:m51"}
{"signature": "def atexit_operations(self):", "body": "<EOL>self.history_manager.end_session()<EOL>for tfile in self.tempfiles:<EOL><INDENT>try:<EOL><INDENT>os.unlink(tfile)<EOL><DEDENT>except OSError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>self.reset(new_session=False)<EOL>self.hooks.shutdown_hook()<EOL>", "docstring": "This will be executed at the time of exit.\n\n        Cleanup operations and saving of persistent data that is done\n        unconditionally by IPython should be performed here.\n\n        For things that may depend on startup flags or platform specifics (such\n        as having readline or not), register a separate atexit function in the\n        code that has the appropriate information, rather than trying to\n        clutter", "id": "f21442:c5:m111"}
{"signature": "def reload(self):", "body": "if self.embed:<EOL><INDENT>super(Image,self).reload()<EOL><DEDENT>", "docstring": "Reload the raw data from file or URL.", "id": "f21443:c8:m1"}
{"signature": "def display_latex(*objs, **kwargs):", "body": "raw = kwargs.pop('<STR_LIT>',False)<EOL>if raw:<EOL><INDENT>for obj in objs:<EOL><INDENT>publish_latex(obj)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>display(*objs, include=['<STR_LIT>','<STR_LIT>'])<EOL><DEDENT>", "docstring": "Display the LaTeX representation of an object.\n\n    Parameters\n    ----------\n    objs : tuple of objects\n        The Python objects to display, or if raw=True raw latex data to\n        display.\n    raw : bool\n        Are the data objects raw data or Python objects that need to be\n        formatted before display? [default: False]", "id": "f21443:m6"}
{"signature": "def __init__(self, data=None, url=None, filename=None, lib=None, css=None):", "body": "if isinstance(lib, basestring):<EOL><INDENT>lib = [lib]<EOL><DEDENT>elif lib is None:<EOL><INDENT>lib = []<EOL><DEDENT>if isinstance(css, basestring):<EOL><INDENT>css = [css]<EOL><DEDENT>elif css is None:<EOL><INDENT>css = []<EOL><DEDENT>if not isinstance(lib, (list,tuple)):<EOL><INDENT>raise TypeError('<STR_LIT>' % lib)<EOL><DEDENT>if not isinstance(css, (list,tuple)):<EOL><INDENT>raise TypeError('<STR_LIT>' % css)<EOL><DEDENT>self.lib = lib<EOL>self.css = css<EOL>super(Javascript, self).__init__(data=data, url=url, filename=filename)<EOL>", "docstring": "Create a Javascript display object given raw data.\n\n        When this object is returned by an expression or passed to the\n        display function, it will result in the data being displayed\n        in the frontend. If the data is a URL, the data will first be\n        downloaded and then displayed. \n\n        In the Notebook, the containing element will be available as `element`,\n        and jQuery will be available.  The output area starts hidden, so if\n        the js appends content to `element` that should be visible, then\n        it must call `container.show()` to unhide the area.\n\n        Parameters\n        ----------\n        data : unicode, str or bytes\n            The Javascript source code or a URL to download it from.\n        url : unicode\n            A URL to download the data from.\n        filename : unicode\n            Path to a local file to load the data from.\n        lib : list or str\n            A sequence of Javascript library URLs to load asynchronously before\n            running the source code. The full URLs of the libraries should\n            be given. A single Javascript library URL can also be given as a\n            string.\n        css: : list or str\n            A sequence of css files to load before running the source code.\n            The full URLs of the css files should be give. A single css URL\n            can also be given as a string.", "id": "f21443:c7:m0"}
{"signature": "def display(*objs, **kwargs):", "body": "include = kwargs.get('<STR_LIT>')<EOL>exclude = kwargs.get('<STR_LIT>')<EOL>from IPython.core.interactiveshell import InteractiveShell<EOL>inst = InteractiveShell.instance()<EOL>format = inst.display_formatter.format<EOL>publish = inst.display_pub.publish<EOL>for obj in objs:<EOL><INDENT>format_dict = format(obj, include=include, exclude=exclude)<EOL>publish('<STR_LIT>', format_dict)<EOL><DEDENT>", "docstring": "Display a Python object in all frontends.\n\n    By default all representations will be computed and sent to the frontends.\n    Frontends can decide which representation is used and how.\n\n    Parameters\n    ----------\n    objs : tuple of objects\n        The Python objects to display.\n    include : list or tuple, optional\n        A list of format type strings (MIME types) to include in the\n        format data dict. If this is set *only* the format types included\n        in this list will be computed.\n    exclude : list or tuple, optional\n        A list of format type string (MIME types) to exclue in the format\n        data dict. If this is set all format types will be computed,\n        except for those included in this argument.", "id": "f21443:m0"}
{"signature": "def __init__(self, data=None, url=None, filename=None, format=u'<STR_LIT>', embed=None):", "body": "if filename is not None:<EOL><INDENT>ext = self._find_ext(filename)<EOL><DEDENT>elif url is not None:<EOL><INDENT>ext = self._find_ext(url)<EOL><DEDENT>elif data.startswith('<STR_LIT:http>'):<EOL><INDENT>ext = self._find_ext(data)<EOL><DEDENT>else:<EOL><INDENT>ext = None<EOL><DEDENT>if ext is not None:<EOL><INDENT>if ext == u'<STR_LIT>' or ext == u'<STR_LIT>':<EOL><INDENT>format = u'<STR_LIT>'<EOL><DEDENT>if ext == u'<STR_LIT>':<EOL><INDENT>format = u'<STR_LIT>'<EOL><DEDENT><DEDENT>self.format = unicode(format).lower()<EOL>self.embed = embed if embed is not None else (url is None)<EOL>super(Image, self).__init__(data=data, url=url, filename=filename)<EOL>", "docstring": "Create a display an PNG/JPEG image given raw data.\n\n        When this object is returned by an expression or passed to the\n        display function, it will result in the image being displayed\n        in the frontend.\n\n        Parameters\n        ----------\n        data : unicode, str or bytes\n            The raw data or a URL to download the data from.\n        url : unicode\n            A URL to download the data from.\n        filename : unicode\n            Path to a local file to load the data from.\n        format : unicode\n            The format of the image data (png/jpeg/jpg). If a filename or URL is given\n            for format will be inferred from the filename extension.\n        embed : bool\n            Should the image data be embedded using a data URI (True) or be\n            loaded using an <img> tag. Set this to True if you want the image\n            to be viewable later with no internet connection in the notebook.\n\n            Default is `True`, unless the keyword argument `url` is set, then\n            default value is `False`.\n\n            Note that QtConsole is not able to display images if `embed` is set to `False`\n\n        Examples\n        --------\n        # embed implicitly True, works in qtconsole and notebook\n        Image('http://www.google.fr/images/srpr/logo3w.png')\n\n        # embed implicitly False, does not works in qtconsole but works in notebook if\n        # internet connection available\n        Image(url='http://www.google.fr/images/srpr/logo3w.png')", "id": "f21443:c8:m0"}
{"signature": "def magics_class(cls):", "body": "cls.registered = True<EOL>cls.magics = dict(line = magics['<STR_LIT>'],<EOL>cell = magics['<STR_LIT>'])<EOL>magics['<STR_LIT>'] = {}<EOL>magics['<STR_LIT>'] = {}<EOL>return cls<EOL>", "docstring": "Class decorator for all subclasses of the main Magics class.\n\n    Any class that subclasses Magics *must* also apply this decorator, to\n    ensure that all the methods that have been decorated as line/cell magics\n    get correctly registered in the class instance.  This is necessary because\n    when method decorators run, the class does not exist yet, so they\n    temporarily store their information into a module global.  Application of\n    this class decorator copies that global data to the class instance and\n    clears the global.\n\n    Obviously, this mechanism is not thread-safe, which means that the\n    *creation* of subclasses of Magic should only be done in a single-thread\n    context.  Instantiation of the classes has no restrictions.  Given that\n    these classes are typically created at IPython startup time and before user\n    application code becomes active, in practice this should not pose any\n    problems.", "id": "f21445:m3"}
{"signature": "def arg_err(self,func):", "body": "print('<STR_LIT>')<EOL>print(oinspect.getdoc(func))<EOL>", "docstring": "Print docstring if incorrect arguments were passed", "id": "f21445:c2:m1"}
{"signature": "def format_latex(self, strng):", "body": "<EOL>escape_re = re.compile(r'<STR_LIT>',re.MULTILINE)<EOL>cmd_name_re = re.compile(r'<STR_LIT>' % ESC_MAGIC,<EOL>re.MULTILINE)<EOL>cmd_re = re.compile(r'<STR_LIT>' % ESC_MAGIC,<EOL>re.MULTILINE)<EOL>par_re = re.compile(r'<STR_LIT>',re.MULTILINE)<EOL>newline_re = re.compile(r'<STR_LIT>')<EOL>strng = cmd_name_re.sub(r'<STR_LIT>',<EOL>strng)<EOL>strng = cmd_re.sub(r'<STR_LIT>',strng)<EOL>strng = par_re.sub(r'<STR_LIT>',strng)<EOL>strng = escape_re.sub(r'<STR_LIT>',strng)<EOL>strng = newline_re.sub(r'<STR_LIT>',strng)<EOL>return strng<EOL>", "docstring": "Format a string for latex inclusion.", "id": "f21445:c2:m2"}
{"signature": "def default_option(self, fn, optstr):", "body": "if fn not in self.lsmagic():<EOL><INDENT>error(\"<STR_LIT>\" % fn)<EOL><DEDENT>self.options_table[fn] = optstr<EOL>", "docstring": "Make an entry in the options_table for fn, with value optstr", "id": "f21445:c2:m4"}
{"signature": "def find_source_lines(obj):", "body": "<EOL>if hasattr(obj, '<STR_LIT>'):<EOL><INDENT>obj = obj.__wrapped__<EOL><DEDENT>try:<EOL><INDENT>try:<EOL><INDENT>lineno = inspect.getsourcelines(obj)[<NUM_LIT:1>]<EOL><DEDENT>except TypeError:<EOL><INDENT>if hasattr(obj, '<STR_LIT>'):<EOL><INDENT>lineno = inspect.getsourcelines(obj.__class__)[<NUM_LIT:1>]<EOL><DEDENT><DEDENT><DEDENT>except:<EOL><INDENT>return None<EOL><DEDENT>return lineno<EOL>", "docstring": "Find the line number in a file where an object was defined.\n\n    This is essentially a robust wrapper around `inspect.getsourcelines`.\n\n    Returns None if no file can be found.\n\n    Parameters\n    ----------\n    obj : any Python object\n\n    Returns\n    -------\n    lineno : int\n      The line number where the object definition starts.", "id": "f21446:m7"}
{"signature": "def call_tip(oinfo, format_call=True):", "body": "<EOL>argspec = oinfo.get('<STR_LIT>')<EOL>if argspec is None:<EOL><INDENT>call_line = None<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>has_self = argspec['<STR_LIT:args>'][<NUM_LIT:0>] == '<STR_LIT>'<EOL><DEDENT>except (KeyError, IndexError):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>if has_self:<EOL><INDENT>argspec['<STR_LIT:args>'] = argspec['<STR_LIT:args>'][<NUM_LIT:1>:]<EOL><DEDENT><DEDENT>call_line = oinfo['<STR_LIT:name>']+format_argspec(argspec)<EOL><DEDENT>doc = oinfo.get('<STR_LIT>')<EOL>if doc is None:<EOL><INDENT>doc = oinfo.get('<STR_LIT>')<EOL><DEDENT>if doc is None:<EOL><INDENT>doc = oinfo.get('<STR_LIT>','<STR_LIT>')<EOL><DEDENT>return call_line, doc<EOL>", "docstring": "Extract call tip data from an oinfo dict.\n\n    Parameters\n    ----------\n    oinfo : dict\n\n    format_call : bool, optional\n      If True, the call line is formatted and returned as a string.  If not, a\n      tuple of (name, argspec) is returned.\n\n    Returns\n    -------\n    call_info : None, str or (str, dict) tuple.\n      When format_call is True, the whole call information is formattted as a\n      single string.  Otherwise, the object's name and its argspec dict are\n      returned.  If no call information is available, None is returned.\n\n    docstring : str or None\n      The most relevant docstring for calling purposes is returned, if\n      available.  The priority is: call docstring for callable instances, then\n      constructor docstring for classes, then main object's docstring otherwise\n      (regular functions).", "id": "f21446:m5"}
{"signature": "def psource(self,obj,oname='<STR_LIT>'):", "body": "<EOL>linecache.checkcache()<EOL>try:<EOL><INDENT>src = getsource(obj)<EOL><DEDENT>except:<EOL><INDENT>self.noinfo('<STR_LIT:source>',oname)<EOL><DEDENT>else:<EOL><INDENT>page.page(self.format(py3compat.unicode_to_str(src)))<EOL><DEDENT>", "docstring": "Print the source code for an object.", "id": "f21446:c0:m7"}
{"signature": "def pdef(self, obj, oname='<STR_LIT>'):", "body": "if not callable(obj):<EOL><INDENT>print('<STR_LIT>')<EOL>return<EOL><DEDENT>header = '<STR_LIT>'<EOL>if inspect.isclass(obj):<EOL><INDENT>header = self.__head('<STR_LIT>')<EOL>obj = obj.__init__<EOL><DEDENT>elif (not py3compat.PY3) and type(obj) is types.InstanceType:<EOL><INDENT>obj = obj.__call__<EOL><DEDENT>output = self._getdef(obj,oname)<EOL>if output is None:<EOL><INDENT>self.noinfo('<STR_LIT>',oname)<EOL><DEDENT>else:<EOL><INDENT>print(header,self.format(output), end='<STR_LIT:U+0020>', file=io.stdout)<EOL><DEDENT>", "docstring": "Print the definition header for any callable object.\n\n        If the object is a class, print the constructor information.", "id": "f21446:c0:m5"}
{"signature": "def fix_frame_records_filenames(records):", "body": "fixed_records = []<EOL>for frame, filename, line_no, func_name, lines, index in records:<EOL><INDENT>better_fn = frame.f_globals.get('<STR_LIT>', None)<EOL>if isinstance(better_fn, str):<EOL><INDENT>filename = better_fn<EOL><DEDENT>fixed_records.append((frame, filename, line_no, func_name, lines, index))<EOL><DEDENT>return fixed_records<EOL>", "docstring": "Try to fix the filenames in each record from inspect.getinnerframes().\n\n    Particularly, modules loaded from within zip files have useless filenames\n    attached to their code object, and inspect.getinnerframes() just uses it.", "id": "f21447:m2"}
{"signature": "def stb2text(self, stb):", "body": "return self.tb_join_char.join(stb)<EOL>", "docstring": "Convert a structured traceback (a list) to a string.", "id": "f21447:c3:m3"}
{"signature": "def structured_traceback(self, etype, evalue, etb, tb_offset=None,<EOL>context=<NUM_LIT:5>):", "body": "tb_offset = self.tb_offset if tb_offset is None else tb_offset<EOL>try:<EOL><INDENT>etype = etype.__name__<EOL><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT>Colors        = self.Colors   <EOL>ColorsNormal  = Colors.Normal  <EOL>col_scheme    = self.color_scheme_table.active_scheme_name<EOL>indent        = '<STR_LIT:U+0020>'*INDENT_SIZE<EOL>em_normal     = '<STR_LIT>' % (Colors.valEm, indent,ColorsNormal)<EOL>undefined     = '<STR_LIT>' % (Colors.em, ColorsNormal)<EOL>exc = '<STR_LIT>' % (Colors.excName,etype,ColorsNormal)<EOL>def text_repr(value):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>try:<EOL><INDENT>return pydoc.text.repr(value)<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>raise<EOL><DEDENT>except:<EOL><INDENT>try:<EOL><INDENT>return repr(value)<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>raise<EOL><DEDENT>except:<EOL><INDENT>try:<EOL><INDENT>name = getattr(value, '<STR_LIT>', None)<EOL>if name:<EOL><INDENT>return text_repr(name)<EOL><DEDENT>klass = getattr(value, '<STR_LIT>', None)<EOL>if klass:<EOL><INDENT>return '<STR_LIT>' % text_repr(klass)<EOL><DEDENT><DEDENT>except KeyboardInterrupt:<EOL><INDENT>raise<EOL><DEDENT>except:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT><DEDENT><DEDENT><DEDENT>def eqrepr(value, repr=text_repr): return '<STR_LIT>' % repr(value)<EOL>def nullrepr(value, repr=text_repr): return '<STR_LIT>'<EOL>try:<EOL><INDENT>etype = etype.__name__<EOL><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT>if self.long_header:<EOL><INDENT>pyver = '<STR_LIT>' + sys.version.split()[<NUM_LIT:0>] + '<STR_LIT>' + sys.executable<EOL>date = time.ctime(time.time())<EOL>head = '<STR_LIT>' % (Colors.topline, '<STR_LIT:->'*<NUM_LIT>, ColorsNormal,<EOL>exc, '<STR_LIT:U+0020>'*(<NUM_LIT>-len(str(etype))-len(pyver)),<EOL>pyver, date.rjust(<NUM_LIT>) )<EOL>head += \"<STR_LIT>\"\"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>head = '<STR_LIT>' % (Colors.topline, '<STR_LIT:->'*<NUM_LIT>, ColorsNormal,exc,<EOL>'<STR_LIT>'.rjust(<NUM_LIT> - len(str(etype)) ) )<EOL><DEDENT>frames = []<EOL>try:<EOL><INDENT>records = _fixed_getinnerframes(etb, context, tb_offset)<EOL><DEDENT>except:<EOL><INDENT>inspect_error()<EOL>traceback.print_exc(file=self.ostream)<EOL>info('<STR_LIT>')<EOL>return '<STR_LIT>'<EOL><DEDENT>tpl_link       = '<STR_LIT>' % (Colors.filenameEm,ColorsNormal)<EOL>tpl_call       = '<STR_LIT>' % (Colors.vName, Colors.valEm,<EOL>ColorsNormal)<EOL>tpl_call_fail  = '<STR_LIT>' %(Colors.vName, Colors.valEm, ColorsNormal)<EOL>tpl_local_var  = '<STR_LIT>' % (Colors.vName, ColorsNormal)<EOL>tpl_global_var = '<STR_LIT>' % (Colors.em, ColorsNormal,<EOL>Colors.vName, ColorsNormal)<EOL>tpl_name_val   = '<STR_LIT>' % (Colors.valEm, ColorsNormal)<EOL>tpl_line       = '<STR_LIT>' % (Colors.lineno, ColorsNormal)<EOL>tpl_line_em    = '<STR_LIT>' % (Colors.linenoEm,Colors.line,<EOL>ColorsNormal)<EOL>abspath = os.path.abspath<EOL>for frame, file, lnum, func, lines, index in records:<EOL><INDENT>if not file:<EOL><INDENT>file = '<STR_LIT:?>'<EOL><DEDENT>elif not(file.startswith(\"<STR_LIT:<>\") and file.endswith(\"<STR_LIT:>>\")):<EOL><INDENT>try:<EOL><INDENT>file = abspath(file)<EOL><DEDENT>except OSError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>link = tpl_link % file<EOL>args, varargs, varkw, locals = inspect.getargvalues(frame)<EOL>if func == '<STR_LIT:?>':<EOL><INDENT>call = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>var_repr = self.include_vars and eqrepr or nullrepr<EOL>try:<EOL><INDENT>call = tpl_call % (func,inspect.formatargvalues(args,<EOL>varargs, varkw,<EOL>locals,formatvalue=var_repr))<EOL><DEDENT>except KeyError:<EOL><INDENT>call = tpl_call_fail % func<EOL><DEDENT><DEDENT>if file.endswith(('<STR_LIT>', '<STR_LIT>', '<STR_LIT>')):<EOL><INDENT>frames.append('<STR_LIT>' % (link,call))<EOL>continue<EOL><DEDENT>elif file.endswith(('<STR_LIT>','<STR_LIT>')):<EOL><INDENT>file = pyfile.source_from_cache(file)<EOL><DEDENT>def linereader(file=file, lnum=[lnum], getline=linecache.getline):<EOL><INDENT>line = getline(file, lnum[<NUM_LIT:0>])<EOL>lnum[<NUM_LIT:0>] += <NUM_LIT:1><EOL>return line<EOL><DEDENT>try:<EOL><INDENT>names = []<EOL>name_cont = False<EOL>for token_type, token, start, end, line in generate_tokens(linereader):<EOL><INDENT>if token_type == tokenize.NAME and token not in keyword.kwlist:<EOL><INDENT>if name_cont:<EOL><INDENT>try:<EOL><INDENT>names[-<NUM_LIT:1>].append(token)<EOL><DEDENT>except IndexError:<EOL><INDENT>names.append([token])<EOL><DEDENT>name_cont = False<EOL><DEDENT>else:<EOL><INDENT>names.append([token])<EOL><DEDENT><DEDENT>elif token == '<STR_LIT:.>':<EOL><INDENT>name_cont = True<EOL><DEDENT>elif token_type == tokenize.NEWLINE:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT>except (IndexError, UnicodeDecodeError):<EOL><INDENT>pass<EOL><DEDENT>except tokenize.TokenError as msg:<EOL><INDENT>_m = (\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % msg)<EOL>error(_m)<EOL><DEDENT>names = ['<STR_LIT:.>'.join(n) for n in names]<EOL>unique_names = uniq_stable(names)<EOL>lvals = []<EOL>if self.include_vars:<EOL><INDENT>for name_full in unique_names:<EOL><INDENT>name_base = name_full.split('<STR_LIT:.>',<NUM_LIT:1>)[<NUM_LIT:0>]<EOL>if name_base in frame.f_code.co_varnames:<EOL><INDENT>if name_base in locals:<EOL><INDENT>try:<EOL><INDENT>value = repr(eval(name_full,locals))<EOL><DEDENT>except:<EOL><INDENT>value = undefined<EOL><DEDENT><DEDENT>else:<EOL><INDENT>value = undefined<EOL><DEDENT>name = tpl_local_var % name_full<EOL><DEDENT>else:<EOL><INDENT>if name_base in frame.f_globals:<EOL><INDENT>try:<EOL><INDENT>value = repr(eval(name_full,frame.f_globals))<EOL><DEDENT>except:<EOL><INDENT>value = undefined<EOL><DEDENT><DEDENT>else:<EOL><INDENT>value = undefined<EOL><DEDENT>name = tpl_global_var % name_full<EOL><DEDENT>lvals.append(tpl_name_val % (name,value))<EOL><DEDENT><DEDENT>if lvals:<EOL><INDENT>lvals = '<STR_LIT>' % (indent,em_normal.join(lvals))<EOL><DEDENT>else:<EOL><INDENT>lvals = '<STR_LIT>'<EOL><DEDENT>level = '<STR_LIT>' % (link,call)<EOL>if index is None:<EOL><INDENT>frames.append(level)<EOL><DEDENT>else:<EOL><INDENT>frames.append('<STR_LIT>' % (level,'<STR_LIT>'.join(<EOL>_format_traceback_lines(lnum,index,lines,Colors,lvals,<EOL>col_scheme))))<EOL><DEDENT><DEDENT>try:<EOL><INDENT>etype_str,evalue_str = list(map(str,(etype,evalue)))<EOL><DEDENT>except:<EOL><INDENT>etype,evalue = str,sys.exc_info()[:<NUM_LIT:2>]<EOL>etype_str,evalue_str = list(map(str,(etype,evalue)))<EOL><DEDENT>exception = ['<STR_LIT>' % (Colors.excName, etype_str,<EOL>ColorsNormal, evalue_str)]<EOL>if (not py3compat.PY3) and type(evalue) is types.InstanceType:<EOL><INDENT>try:<EOL><INDENT>names = [w for w in dir(evalue) if isinstance(w, str)]<EOL><DEDENT>except:<EOL><INDENT>_m = '<STR_LIT>'<EOL>exception.append(_m % (Colors.excName,ColorsNormal))<EOL>etype_str,evalue_str = list(map(str,sys.exc_info()[:<NUM_LIT:2>]))<EOL>exception.append('<STR_LIT>' % (Colors.excName,etype_str,<EOL>ColorsNormal, evalue_str))<EOL>names = []<EOL><DEDENT>for name in names:<EOL><INDENT>value = text_repr(getattr(evalue, name))<EOL>exception.append('<STR_LIT>' % (indent, name, value))<EOL><DEDENT><DEDENT>if records:<EOL><INDENT>filepath, lnum = records[-<NUM_LIT:1>][<NUM_LIT:1>:<NUM_LIT:3>]<EOL>filepath = os.path.abspath(filepath)<EOL>ipinst = ipapi.get()<EOL>if ipinst is not None:<EOL><INDENT>ipinst.hooks.synchronize_with_editor(filepath, lnum, <NUM_LIT:0>)<EOL><DEDENT><DEDENT>return [head] + frames + ['<STR_LIT>'.join(exception[<NUM_LIT:0>])]<EOL>", "docstring": "Return a nice text document describing the traceback.", "id": "f21447:c2:m1"}
{"signature": "def __init__(self,color_scheme = '<STR_LIT>', call_pdb=False, ostream=None,<EOL>tb_offset=<NUM_LIT:0>, long_header=False, include_vars=True,<EOL>check_cache=None):", "body": "TBTools.__init__(self, color_scheme=color_scheme, call_pdb=call_pdb,<EOL>ostream=ostream)<EOL>self.tb_offset = tb_offset<EOL>self.long_header = long_header<EOL>self.include_vars = include_vars<EOL>if check_cache is None:<EOL><INDENT>check_cache = linecache.checkcache<EOL><DEDENT>self.check_cache = check_cache<EOL>", "docstring": "Specify traceback offset, headers and color scheme.\n\n        Define how many frames to drop from the tracebacks. Calling it with\n        tb_offset=1 allows use of this handler in interpreters which will have\n        their own code at the top of the traceback (VerboseTB will first\n        remove that frame before printing the traceback info).", "id": "f21447:c2:m0"}
{"signature": "def debugger(self,force=False):", "body": "if force or self.call_pdb:<EOL><INDENT>if self.pdb is None:<EOL><INDENT>self.pdb = debugger.Pdb(<EOL>self.color_scheme_table.active_scheme_name)<EOL><DEDENT>display_trap = DisplayTrap(hook=sys.__displayhook__)<EOL>with display_trap:<EOL><INDENT>self.pdb.reset()<EOL>if hasattr(self,'<STR_LIT>') and self.tb is not None:<EOL><INDENT>etb = self.tb<EOL><DEDENT>else:<EOL><INDENT>etb = self.tb = sys.last_traceback<EOL><DEDENT>while self.tb is not None and self.tb.tb_next is not None:<EOL><INDENT>self.tb = self.tb.tb_next<EOL><DEDENT>if etb and etb.tb_next:<EOL><INDENT>etb = etb.tb_next<EOL><DEDENT>self.pdb.botframe = etb.tb_frame<EOL>self.pdb.interaction(self.tb.tb_frame, self.tb)<EOL><DEDENT><DEDENT>if hasattr(self,'<STR_LIT>'):<EOL><INDENT>del self.tb<EOL><DEDENT>", "docstring": "Call up the pdb debugger if desired, always clean up the tb\n        reference.\n\n        Keywords:\n\n          - force(False): by default, this routine checks the instance call_pdb\n          flag and does not actually invoke the debugger if the flag is false.\n          The 'force' option forces the debugger to activate even if the flag\n          is false.\n\n        If the call_pdb flag is set, the pdb interactive debugger is\n        invoked. In all cases, the self.tb reference to the current traceback\n        is deleted to prevent lingering references which hamper memory\n        management.\n\n        Note that each call to pdb() does an 'import readline', so if your app\n        requires a special setup for the readline completers, you'll have to\n        fix that by hand after invoking the exception handler.", "id": "f21447:c2:m2"}
{"signature": "def inspect_error():", "body": "error('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>", "docstring": "Print a message about internal inspect errors.\n\n    These are unfortunately quite common.", "id": "f21447:m0"}
{"signature": "def stb2text(self, stb):", "body": "return '<STR_LIT:\\n>'.join(stb)<EOL>", "docstring": "Convert a structured traceback (a list) to a string.", "id": "f21447:c0:m5"}
{"signature": "def input_prefilter(self,line):", "body": "<EOL>return line<EOL>", "docstring": "Default input prefilter\n\n    This returns the line as unchanged, so that the interpreter\n    knows that nothing was done and proceeds with \"classic\" prefiltering\n    (%magics, !shell commands etc.).\n\n    Note that leading whitespace is not passed to this hook. Prefilter\n    can't alter indentation.", "id": "f21448:m3"}
{"signature": "def editor(self, filename, linenum=None, wait=True):", "body": "<EOL>editor = self.editor<EOL>if linenum is None or editor=='<STR_LIT>':<EOL><INDENT>linemark = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>linemark = '<STR_LIT>' % int(linenum)<EOL><DEDENT>if '<STR_LIT:U+0020>' in editor and os.path.isfile(editor) and editor[<NUM_LIT:0>] != '<STR_LIT:\">':<EOL><INDENT>editor = '<STR_LIT>' % editor<EOL><DEDENT>proc = subprocess.Popen('<STR_LIT>' % (editor, linemark, filename),<EOL>shell=True)<EOL>if wait and proc.wait() != <NUM_LIT:0>:<EOL><INDENT>raise TryNext()<EOL><DEDENT>", "docstring": "Open the default editor at the given filename and linenumber.\n\n    This is IPython's default editor hook, you can use it as an example to\n    write your own modified one.  To set your own editor function as the\n    new editor hook, call ip.set_hook('editor',yourfunc).", "id": "f21448:m0"}
{"signature": "def __call__(self,*args, **kw):", "body": "last_exc = TryNext()<EOL>for prio,cmd in self.chain:<EOL><INDENT>try:<EOL><INDENT>return cmd(*args, **kw)<EOL><DEDENT>except TryNext as exc:<EOL><INDENT>last_exc = exc<EOL><DEDENT><DEDENT>raise last_exc<EOL>", "docstring": "Command chain is called just like normal func.\n\n        This will call all funcs in chain with the same args as were given to\n        this function, and return the result of first func that didn't raise\n        TryNext", "id": "f21448:c0:m1"}
{"signature": "def ast_parse(self, source, filename='<STR_LIT>', symbol='<STR_LIT>'):", "body": "return compile(source, filename, symbol, self.flags | PyCF_ONLY_AST, <NUM_LIT:1>)<EOL>", "docstring": "Parse code to an AST with the current compiler flags active.\n\n        Arguments are exactly the same as ast.parse (in the standard library),\n        and are passed to the built-in compile function.", "id": "f21450:c0:m1"}
{"signature": "def cache(self, code, number=<NUM_LIT:0>):", "body": "name = code_name(code, number)<EOL>entry = (len(code), time.time(),<EOL>[line+'<STR_LIT:\\n>' for line in code.splitlines()], name)<EOL>linecache.cache[name] = entry<EOL>linecache._ipython_cache[name] = entry<EOL>return name<EOL>", "docstring": "Make a name for a block of code, and cache the code.\n\n        Parameters\n        ----------\n        code : str\n          The Python source code to cache.\n        number : int\n          A number which forms part of the code's name. Used for the execution\n          counter.\n\n        Returns\n        -------\n        The name of the cached code (as a string). Pass this as the filename\n        argument to compilation, so that tracebacks are correctly hooked up.", "id": "f21450:c0:m4"}
{"signature": "def check_cache(self, *args):", "body": "<EOL>linecache._checkcache_ori(*args)<EOL>linecache.cache.update(linecache._ipython_cache)<EOL>", "docstring": "Call linecache.checkcache() safely protecting our cached values.", "id": "f21450:c0:m5"}
{"signature": "def init_profile_dir(self):", "body": "try:<EOL><INDENT>location = self.config.ProfileDir.location<EOL><DEDENT>except AttributeError:<EOL><INDENT>try:<EOL><INDENT>p = ProfileDir.find_profile_dir_by_name(self.ipython_dir, self.profile, self.config)<EOL><DEDENT>except ProfileDirError:<EOL><INDENT>if self.auto_create or self.profile=='<STR_LIT:default>':<EOL><INDENT>try:<EOL><INDENT>p = ProfileDir.create_profile_dir_by_name(self.ipython_dir, self.profile, self.config)<EOL><DEDENT>except ProfileDirError:<EOL><INDENT>self.log.fatal(\"<STR_LIT>\"%self.profile)<EOL>self.exit(<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>self.log.info(\"<STR_LIT>\"%p.location)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.log.fatal(\"<STR_LIT>\"%self.profile)<EOL>self.exit(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.log.info(\"<STR_LIT>\"%p.location)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>p = ProfileDir.find_profile_dir(location, self.config)<EOL><DEDENT>except ProfileDirError:<EOL><INDENT>if self.auto_create:<EOL><INDENT>try:<EOL><INDENT>p = ProfileDir.create_profile_dir(location, self.config)<EOL><DEDENT>except ProfileDirError:<EOL><INDENT>self.log.fatal(\"<STR_LIT>\"%location)<EOL>self.exit(<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>self.log.info(\"<STR_LIT>\"%location)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.log.fatal(\"<STR_LIT>\"%location)<EOL>self.exit(<NUM_LIT:1>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.log.info(\"<STR_LIT>\"%location)<EOL><DEDENT><DEDENT>self.profile_dir = p<EOL>self.config_file_paths.append(p.location)<EOL>", "docstring": "initialize the profile dir", "id": "f21451:c0:m10"}
{"signature": "def init_crash_handler(self):", "body": "self.crash_handler = self.crash_handler_class(self)<EOL>sys.excepthook = self.excepthook<EOL>def unset_crashhandler():<EOL><INDENT>sys.excepthook = sys.__excepthook__<EOL><DEDENT>atexit.register(unset_crashhandler)<EOL>", "docstring": "Create a crash handler, typically setting sys.excepthook to it.", "id": "f21451:c0:m6"}
{"signature": "def deactivate(self):", "body": "remove_builtin = self.remove_builtin<EOL>for key, val in self._orig_builtins.iteritems():<EOL><INDENT>remove_builtin(key, val)<EOL><DEDENT>self._orig_builtins.clear()<EOL>self._builtins_added = False<EOL>", "docstring": "Remove any builtins which might have been added by add_builtins, or\n        restore overwritten ones to their previous values.", "id": "f21452:c2:m6"}
{"signature": "def activate(self):", "body": "add_builtin = self.add_builtin<EOL>for name, func in self.auto_builtins.iteritems():<EOL><INDENT>add_builtin(name, func)<EOL><DEDENT>", "docstring": "Store ipython references in the __builtin__ namespace.", "id": "f21452:c2:m5"}
{"signature": "def protect_filename(s):", "body": "return \"<STR_LIT>\".join([(ch in PROTECTABLES and '<STR_LIT:\\\\>' + ch or ch)<EOL>for ch in s])<EOL>", "docstring": "Escape a string to protect certain characters.", "id": "f21453:m1"}
{"signature": "def get__all__entries(obj):", "body": "try:<EOL><INDENT>words = getattr(obj, '<STR_LIT>')<EOL><DEDENT>except:<EOL><INDENT>return []<EOL><DEDENT>return [w for w in words if isinstance(w, basestring)]<EOL>", "docstring": "returns the strings in the __all__ attribute", "id": "f21453:m4"}
{"signature": "def rlcomplete(self, text, state):", "body": "if state==<NUM_LIT:0>:<EOL><INDENT>self.line_buffer = line_buffer = self.readline.get_line_buffer()<EOL>cursor_pos = self.readline.get_endidx()<EOL>if not (self.dumb_terminal or line_buffer.strip()):<EOL><INDENT>self.readline.insert_text('<STR_LIT:\\t>')<EOL>sys.stdout.flush()<EOL>return None<EOL><DEDENT>DEBUG = False<EOL>if DEBUG:<EOL><INDENT>try:<EOL><INDENT>self.complete(text, line_buffer, cursor_pos)<EOL><DEDENT>except:<EOL><INDENT>import traceback; traceback.print_exc()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.complete(text, line_buffer, cursor_pos)<EOL><DEDENT><DEDENT>try:<EOL><INDENT>return self.matches[state]<EOL><DEDENT>except IndexError:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Return the state-th possible completion for 'text'.\n\n        This is called successively with state == 0, 1, 2, ... until it\n        returns None.  The completion should begin with 'text'.\n\n        Parameters\n        ----------\n          text : string\n            Text to perform the completion on.\n\n          state : int\n            Counter used by readline.", "id": "f21453:c3:m13"}
{"signature": "def complete(self, text=None, line_buffer=None, cursor_pos=None):", "body": "<EOL>if cursor_pos is None:<EOL><INDENT>cursor_pos = len(line_buffer) if text is None else len(text)<EOL><DEDENT>if not text:<EOL><INDENT>text = self.splitter.split_line(line_buffer, cursor_pos)<EOL><DEDENT>if line_buffer is None:<EOL><INDENT>line_buffer = text<EOL><DEDENT>self.line_buffer = line_buffer<EOL>self.text_until_cursor = self.line_buffer[:cursor_pos]<EOL>self.matches[:] = []<EOL>custom_res = self.dispatch_custom_completer(text)<EOL>if custom_res is not None:<EOL><INDENT>self.matches = custom_res<EOL><DEDENT>else:<EOL><INDENT>if self.merge_completions:<EOL><INDENT>self.matches = []<EOL>for matcher in self.matchers:<EOL><INDENT>try:<EOL><INDENT>self.matches.extend(matcher(text))<EOL><DEDENT>except:<EOL><INDENT>sys.excepthook(*sys.exc_info())<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for matcher in self.matchers:<EOL><INDENT>self.matches = matcher(text)<EOL>if self.matches:<EOL><INDENT>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT>self.matches = sorted(set(self.matches))<EOL>return text, self.matches<EOL>", "docstring": "Find completions for the given text and line context.\n\n        This is called successively with state == 0, 1, 2, ... until it\n        returns None.  The completion should begin with 'text'.\n\n        Note that both the text and the line_buffer are optional, but at least\n        one of them must be given.\n\n        Parameters\n        ----------\n          text : string, optional\n            Text to perform the completion on.  If not given, the line buffer\n            is split using the instance's CompletionSplitter object.\n\n          line_buffer : string, optional\n            If not given, the completer attempts to obtain the current line\n            buffer via readline.  This keyword allows clients which are\n            requesting for text completions in non-readline contexts to inform\n            the completer of the entire text.\n\n          cursor_pos : int, optional\n            Index of the cursor in the full line buffer.  Should be provided by\n            remote frontends where kernel has no access to frontend state.\n\n        Returns\n        -------\n        text : str\n          Text that was actually used in the completion.\n\n        matches : list\n          A list of completion matches.", "id": "f21453:c3:m12"}
{"signature": "@delims.setter<EOL><INDENT>def delims(self, delims):<DEDENT>", "body": "expr = '<STR_LIT:[>' + '<STR_LIT>'.join('<STR_LIT:\\\\>'+ c for c in delims) + '<STR_LIT:]>'<EOL>self._delim_re = re.compile(expr)<EOL>self._delims = delims<EOL>self._delim_expr = expr<EOL>", "docstring": "Set the delimiters for line splitting.", "id": "f21453:c1:m2"}
{"signature": "def magic_matches(self, text):", "body": "<EOL>lsm = self.shell.magics_manager.lsmagic()<EOL>line_magics = lsm['<STR_LIT>']<EOL>cell_magics = lsm['<STR_LIT>']<EOL>pre = self.magic_escape<EOL>pre2 = pre+pre<EOL>bare_text = text.lstrip(pre)<EOL>comp = [ pre2+m for m in cell_magics if m.startswith(bare_text)]<EOL>if not text.startswith(pre2):<EOL><INDENT>comp += [ pre+m for m in line_magics if m.startswith(bare_text)]<EOL><DEDENT>return comp<EOL>", "docstring": "Match magics", "id": "f21453:c3:m6"}
{"signature": "def _run_startup_files(self):", "body": "startup_dir = self.profile_dir.startup_dir<EOL>startup_files = glob.glob(os.path.join(startup_dir, '<STR_LIT>'))<EOL>startup_files += glob.glob(os.path.join(startup_dir, '<STR_LIT>'))<EOL>if not startup_files:<EOL><INDENT>return<EOL><DEDENT>self.log.debug(\"<STR_LIT>\", startup_dir)<EOL>try:<EOL><INDENT>for fname in sorted(startup_files):<EOL><INDENT>self._exec_file(fname)<EOL><DEDENT><DEDENT>except:<EOL><INDENT>self.log.warn(\"<STR_LIT>\")<EOL>self.shell.showtraceback()<EOL><DEDENT>", "docstring": "Run files from profile startup directory", "id": "f21454:c0:m8"}
{"signature": "def page_guiref(arg_s=None):", "body": "from IPython.core import page<EOL>page.page(gui_reference, auto_html=True)<EOL>", "docstring": "Show a basic reference about the GUI Console.", "id": "f21455:m0"}
{"signature": "def for_type(self, typ, func):", "body": "oldfunc = self.type_printers.get(typ, None)<EOL>if func is not None:<EOL><INDENT>self.type_printers[typ] = func<EOL><DEDENT>return oldfunc<EOL>", "docstring": "Add a format function for a given type.\n\n        Parameters\n        -----------\n        typ : class\n            The class of the object that will be formatted using `func`.\n        func : callable\n            The callable that will be called to compute the format data. The\n            call signature of this function is simple, it must take the\n            object to be formatted and return the raw data for the given\n            format. Subclasses may use a different call signature for the\n            `func` argument.", "id": "f21456:c2:m4"}
{"signature": "def __call__(self, obj):", "body": "if self.enabled:<EOL><INDENT>obj_id = id(obj)<EOL>try:<EOL><INDENT>obj_class = getattr(obj, '<STR_LIT>', None) or type(obj)<EOL>try:<EOL><INDENT>printer = self.singleton_printers[obj_id]<EOL><DEDENT>except (TypeError, KeyError):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>return printer(obj)<EOL><DEDENT>for cls in pretty._get_mro(obj_class):<EOL><INDENT>if cls in self.type_printers:<EOL><INDENT>return self.type_printers[cls](obj)<EOL><DEDENT>else:<EOL><INDENT>printer = self._in_deferred_types(cls)<EOL>if printer is not None:<EOL><INDENT>return printer(obj)<EOL><DEDENT><DEDENT><DEDENT>if hasattr(obj_class, self.print_method):<EOL><INDENT>printer = getattr(obj_class, self.print_method)<EOL>return printer(obj)<EOL><DEDENT>return None<EOL><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Compute the format for an object.", "id": "f21456:c2:m3"}
{"signature": "def _float_precision_changed(self, name, old, new):", "body": "if '<STR_LIT:%>' in new:<EOL><INDENT>fmt = new<EOL>try:<EOL><INDENT>fmt%<NUM_LIT><EOL><DEDENT>except Exception:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"%new)<EOL><DEDENT><DEDENT>elif new:<EOL><INDENT>try:<EOL><INDENT>i = int(new)<EOL>assert i >= <NUM_LIT:0><EOL><DEDENT>except ValueError:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"%new)<EOL><DEDENT>except AssertionError:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"%i)<EOL><DEDENT>fmt = '<STR_LIT>'%i<EOL>if '<STR_LIT>' in sys.modules:<EOL><INDENT>import numpy<EOL>numpy.set_printoptions(precision=i)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>fmt = '<STR_LIT>'<EOL>if '<STR_LIT>' in sys.modules:<EOL><INDENT>import numpy<EOL>numpy.set_printoptions(precision=<NUM_LIT:8>)<EOL><DEDENT><DEDENT>self.float_format = fmt<EOL>", "docstring": "float_precision changed, set float_format accordingly.\n\n        float_precision can be set by int or str.\n        This will set float_format, after interpreting input.\n        If numpy has been imported, numpy print precision will also be set.\n\n        integer `n` sets format to '%.nf', otherwise, format set directly.\n\n        An empty string returns to defaults (repr for float, 8 for numpy).\n\n        This parameter can be set via the '%precision' magic.", "id": "f21456:c3:m0"}
{"signature": "def parse_argstring(magic_func, argstring):", "body": "return magic_func.parser.parse_argstring(argstring)<EOL>", "docstring": "Parse the string of arguments for the given magic function.", "id": "f21458:m1"}
{"signature": "def soft_define_alias(self, name, cmd):", "body": "try:<EOL><INDENT>self.define_alias(name, cmd)<EOL><DEDENT>except AliasError as e:<EOL><INDENT>error(\"<STR_LIT>\" % e)<EOL><DEDENT>", "docstring": "Define an alias, but don't raise on an AliasError.", "id": "f21460:c2:m6"}
{"signature": "def default_aliases():", "body": "<EOL>if os.name == '<STR_LIT>':<EOL><INDENT>default_aliases = [('<STR_LIT>', '<STR_LIT>'), ('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'), ('<STR_LIT>', '<STR_LIT>'), ('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>]<EOL>if sys.platform.startswith('<STR_LIT>'):<EOL><INDENT>ls_aliases = [('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>]<EOL><DEDENT>else:<EOL><INDENT>ls_aliases = [('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'),<EOL>]<EOL><DEDENT>default_aliases = default_aliases + ls_aliases<EOL><DEDENT>elif os.name in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>default_aliases = [('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'), ('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'), ('<STR_LIT>', '<STR_LIT>'),<EOL>('<STR_LIT>', '<STR_LIT>'), ('<STR_LIT>', '<STR_LIT>'), ('<STR_LIT>', '<STR_LIT>'),<EOL>]<EOL><DEDENT>else:<EOL><INDENT>default_aliases = []<EOL><DEDENT>return default_aliases<EOL>", "docstring": "Return list of shell aliases to auto-define.", "id": "f21460:m0"}
{"signature": "def define_alias(self, name, cmd):", "body": "nargs = self.validate_alias(name, cmd)<EOL>self.alias_table[name] = (nargs, cmd)<EOL>", "docstring": "Define a new alias after validating it.\n\n        This will raise an :exc:`AliasError` if there are validation\n        problems.", "id": "f21460:c2:m7"}
{"signature": "def get():", "body": "from IPython.core.interactiveshell import InteractiveShell<EOL>return InteractiveShell.instance()<EOL>", "docstring": "Get the global InteractiveShell instance.", "id": "f21461:m0"}
{"signature": "def print_figure(fig, fmt='<STR_LIT>'):", "body": "<EOL>if not fig.axes and not fig.lines:<EOL><INDENT>return<EOL><DEDENT>fc = fig.get_facecolor()<EOL>ec = fig.get_edgecolor()<EOL>fig.set_facecolor('<STR_LIT>')<EOL>fig.set_edgecolor('<STR_LIT>')<EOL>try:<EOL><INDENT>bytes_io = BytesIO()<EOL>fig.canvas.print_figure(bytes_io, format=fmt, bbox_inches='<STR_LIT>')<EOL>data = bytes_io.getvalue()<EOL><DEDENT>finally:<EOL><INDENT>fig.set_facecolor(fc)<EOL>fig.set_edgecolor(ec)<EOL><DEDENT>return data<EOL>", "docstring": "Convert a figure to svg or png for inline display.", "id": "f21463:m2"}
{"signature": "def configure_inline_support(shell, backend, user_ns=None):", "body": "<EOL>try:<EOL><INDENT>from IPython.zmq.pylab.backend_inline import InlineBackend<EOL><DEDENT>except ImportError:<EOL><INDENT>return<EOL><DEDENT>user_ns = shell.user_ns if user_ns is None else user_ns<EOL>cfg = InlineBackend.instance(config=shell.config)<EOL>cfg.shell = shell<EOL>if cfg not in shell.configurables:<EOL><INDENT>shell.configurables.append(cfg)<EOL><DEDENT>if backend == backends['<STR_LIT>']:<EOL><INDENT>from IPython.zmq.pylab.backend_inline import flush_figures<EOL>from matplotlib import pyplot<EOL>shell.register_post_execute(flush_figures)<EOL>pyplot.rcParams.update(cfg.rc)<EOL>user_ns['<STR_LIT>'] = pyplot.figsize = figsize<EOL><DEDENT>fmt = cfg.figure_format<EOL>select_figure_format(shell, fmt)<EOL>from IPython.core.display import display<EOL>user_ns['<STR_LIT>'] = display<EOL>user_ns['<STR_LIT>'] = getfigs<EOL>", "docstring": "Configure an IPython shell object for matplotlib use.\n\n    Parameters\n    ----------\n    shell : InteractiveShell instance\n\n    backend : matplotlib backend\n\n    user_ns : dict\n      A namespace where all configured variables will be placed.  If not given,\n      the `user_ns` attribute of the shell object is used.", "id": "f21463:m8"}
{"signature": "def figsize(sizex, sizey):", "body": "import matplotlib<EOL>matplotlib.rcParams['<STR_LIT>'] = [sizex, sizey]<EOL>", "docstring": "Set the default figure size to be [sizex, sizey].\n\n    This is just an easy to remember, convenience wrapper that sets::\n\n      matplotlib.rcParams['figure.figsize'] = [sizex, sizey]", "id": "f21463:m1"}
{"signature": "def import_pylab(user_ns, import_all=True):", "body": "<EOL>s = (\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>)<EOL>exec(s, user_ns)<EOL>if import_all:<EOL><INDENT>s = (\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>exec(s, user_ns)<EOL><DEDENT>", "docstring": "Import the standard pylab symbols into user_ns.", "id": "f21463:m7"}
{"signature": "def check(self, line_info):", "body": "if line_info.the_rest and line_info.the_rest[<NUM_LIT:0>] in '<STR_LIT>':<EOL><INDENT>return self.prefilter_manager.get_handler_by_name('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "If the 'rest' of the line begins with a function call or pretty much\n        any python operator, we should simply execute the line (regardless of\n        whether or not there's a possible autocall expansion).  This avoids\n        spurious (and very confusing) geattr() accesses.", "id": "f21465:c17:m0"}
{"signature": "def prefilter_lines(self, lines, continue_prompt=False):", "body": "llines = lines.rstrip('<STR_LIT:\\n>').split('<STR_LIT:\\n>')<EOL>if len(llines) > <NUM_LIT:1>:<EOL><INDENT>out = '<STR_LIT:\\n>'.join([self.prefilter_line(line, lnum><NUM_LIT:0>)<EOL>for lnum, line in enumerate(llines) ])<EOL><DEDENT>else:<EOL><INDENT>out = self.prefilter_line(llines[<NUM_LIT:0>], continue_prompt)<EOL><DEDENT>return out<EOL>", "docstring": "Prefilter multiple input lines of text.\n\n        This is the main entry point for prefiltering multiple lines of\n        input.  This simply calls :meth:`prefilter_line` for each line of\n        input.\n\n        This covers cases where there are multiple lines in the user entry,\n        which is the case when the user goes back to a multiline history\n        entry and presses enter.", "id": "f21465:c1:m21"}
{"signature": "def handle(self, line_info):", "body": "normal_handler = self.prefilter_manager.get_handler_by_name('<STR_LIT>')<EOL>line = line_info.line<EOL>try:<EOL><INDENT>codeop.compile_command(line)<EOL><DEDENT>except SyntaxError:<EOL><INDENT>if line[<NUM_LIT:0>]==ESC_HELP:<EOL><INDENT>line = line[<NUM_LIT:1>:]<EOL><DEDENT>elif line[-<NUM_LIT:1>]==ESC_HELP:<EOL><INDENT>line = line[:-<NUM_LIT:1>]<EOL><DEDENT>if line:<EOL><INDENT>self.shell.magic('<STR_LIT>' % line_info.ifun)<EOL><DEDENT>else:<EOL><INDENT>self.shell.show_usage()<EOL><DEDENT>return '<STR_LIT>' <EOL><DEDENT>except:<EOL><INDENT>raise<EOL>return normal_handler.handle(line_info)<EOL><DEDENT>else:<EOL><INDENT>return normal_handler.handle(line_info)<EOL><DEDENT>", "docstring": "Try to get some help for the object.\n\n        obj? or ?obj   -> basic information.\n        obj?? or ??obj -> more details.", "id": "f21465:c25:m0"}
{"signature": "def prefilter_line(self, line, continue_prompt=False):", "body": "<EOL>self.shell._last_input_line = line<EOL>if not line:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>if not continue_prompt or (continue_prompt and self.multi_line_specials):<EOL><INDENT>line = self.transform_line(line, continue_prompt)<EOL><DEDENT>line_info = LineInfo(line, continue_prompt)<EOL>stripped = line.strip()<EOL>normal_handler = self.get_handler_by_name('<STR_LIT>')<EOL>if not stripped:<EOL><INDENT>if not continue_prompt:<EOL><INDENT>self.shell.displayhook.prompt_count -= <NUM_LIT:1><EOL><DEDENT>return normal_handler.handle(line_info)<EOL><DEDENT>if continue_prompt and not self.multi_line_specials:<EOL><INDENT>return normal_handler.handle(line_info)<EOL><DEDENT>prefiltered = self.prefilter_line_info(line_info)<EOL>return prefiltered<EOL>", "docstring": "Prefilter a single input line as text.\n\n        This method prefilters a single line of text by calling the\n        transformers and then the checkers/handlers.", "id": "f21465:c1:m20"}
{"signature": "def transform_line(self, line, continue_prompt):", "body": "for transformer in self.transformers:<EOL><INDENT>if transformer.enabled:<EOL><INDENT>line = transformer.transform(line, continue_prompt)<EOL><DEDENT><DEDENT>return line<EOL>", "docstring": "Calls the enabled transformers in order of increasing priority.", "id": "f21465:c1:m19"}
{"signature": "def check(self, line_info):", "body": "if line_info.the_rest:<EOL><INDENT>if line_info.the_rest[<NUM_LIT:0>] in '<STR_LIT>':<EOL><INDENT>return self.prefilter_manager.get_handler_by_name('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Check to see if user is assigning to a var for the first time, in\n        which case we want to avoid any sort of automagic / autocall games.\n\n        This allows users to assign to either alias or magic names true python\n        variables (the magic/alias systems always take second seat to true\n        python code).  E.g. ls='hi', or ls,that=1,2", "id": "f21465:c14:m0"}
{"signature": "def register_handler(self, name, handler, esc_strings):", "body": "self._handlers[name] = handler<EOL>for esc_str in esc_strings:<EOL><INDENT>self._esc_handlers[esc_str] = handler<EOL><DEDENT>", "docstring": "Register a handler instance by name with esc_strings.", "id": "f21465:c1:m13"}
{"signature": "def check(self, line_info):", "body": "if line_info.line.endswith('<STR_LIT>'):<EOL><INDENT>return self.prefilter_manager.get_handler_by_name('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>", "docstring": "Emacs ipython-mode tags certain input lines.", "id": "f21465:c8:m0"}
{"signature": "def is_shadowed(identifier, ip):", "body": "<EOL>return (identifier in ip.user_nsor identifier in ip.user_global_nsor identifier in ip.ns_table['<STR_LIT>'])<EOL>", "docstring": "Is the given identifier defined in one of the namespaces which shadow\n    the alias and magic namespaces?  Note that an identifier is different\n    than ifun, because it can not contain a '.' character.", "id": "f21465:m0"}
{"signature": "@property<EOL><INDENT>def checkers(self):<DEDENT>", "body": "return self._checkers<EOL>", "docstring": "Return a list of checkers, sorted by priority.", "id": "f21465:c1:m8"}
{"signature": "def unregister_handler(self, name, handler, esc_strings):", "body": "try:<EOL><INDENT>del self._handlers[name]<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>for esc_str in esc_strings:<EOL><INDENT>h = self._esc_handlers.get(esc_str)<EOL>if h is handler:<EOL><INDENT>del self._esc_handlers[esc_str]<EOL><DEDENT><DEDENT>", "docstring": "Unregister a handler instance by name with esc_strings.", "id": "f21465:c1:m14"}
{"signature": "def get_handler_by_esc(self, esc_str):", "body": "return self._esc_handlers.get(esc_str)<EOL>", "docstring": "Get a handler by its escape string.", "id": "f21465:c1:m16"}
{"signature": "def unregister_transformer(self, transformer):", "body": "if transformer in self._transformers:<EOL><INDENT>self._transformers.remove(transformer)<EOL><DEDENT>", "docstring": "Unregister a transformer instance.", "id": "f21465:c1:m5"}
{"signature": "def handle(self, line_info):<EOL>", "body": "<EOL>line = line_info.line<EOL>continue_prompt = line_info.continue_prompt<EOL>if (continue_prompt and<EOL>self.shell.autoindent and<EOL>line.isspace() and<EOL><NUM_LIT:0> < abs(len(line) - self.shell.indent_current_nsp) <= <NUM_LIT:2>):<EOL><INDENT>line = '<STR_LIT>'<EOL><DEDENT>return line<EOL>", "docstring": "Handle normal input lines. Use as a template for handlers.", "id": "f21465:c19:m1"}
{"signature": "def register_checker(self, checker):", "body": "if checker not in self._checkers:<EOL><INDENT>self._checkers.append(checker)<EOL>self.sort_checkers()<EOL><DEDENT>", "docstring": "Register a checker instance.", "id": "f21465:c1:m9"}
{"signature": "def last_blank(src):", "body": "if not src: return False<EOL>ll  = src.splitlines()[-<NUM_LIT:1>]<EOL>return (ll == '<STR_LIT>') or ll.isspace()<EOL>", "docstring": "Determine if the input source ends in a blank.\n\n    A blank is either a newline or a line consisting of whitespace.\n\n    Parameters\n    ----------\n    src : string\n      A single or multiline string.", "id": "f21466:m1"}
{"signature": "@staticmethod<EOL><INDENT>def _tr_magic(line_info):<DEDENT>", "body": "tpl = '<STR_LIT>'<EOL>cmd = '<STR_LIT:U+0020>'.join([line_info.ifun, line_info.the_rest]).strip()<EOL>return tpl % (line_info.pre, cmd)<EOL>", "docstring": "Translate lines escaped with: %", "id": "f21466:c1:m4"}
{"signature": "def push_accepts_more(self):", "body": "<EOL>if not self._is_complete:<EOL><INDENT>return True<EOL><DEDENT>if self.indent_spaces==<NUM_LIT:0>:<EOL><INDENT>if self.input_mode=='<STR_LIT>':<EOL><INDENT>if not self._full_dedent:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>code_ast = ast.parse(u'<STR_LIT>'.join(self._buffer))<EOL><DEDENT>except Exception:<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>if len(code_ast.body) == <NUM_LIT:1>:<EOL><INDENT>return False<EOL><DEDENT><DEDENT><DEDENT><DEDENT>last_line = self.source.splitlines()[-<NUM_LIT:1>]<EOL>return bool(last_line and not last_line.isspace())<EOL>", "docstring": "Return whether a block of interactive input can accept more input.\n\n        This method is meant to be used by line-oriented frontends, who need to\n        guess whether a block is complete or not based solely on prior and\n        current input lines.  The InputSplitter considers it has a complete\n        interactive block and will not accept more input only when either a\n        SyntaxError is raised, or *all* of the following are true:\n\n        1. The input compiles to a complete statement.\n\n        2. The indentation level is flush-left (because if we are indented,\n           like inside a function definition or for loop, we need to keep\n           reading new input).\n\n        3. There is one extra line consisting only of whitespace.\n\n        Because of condition #3, this method should be used only by\n        *line-oriented* frontends, since it means that intermediate blank lines\n        are not allowed in function definitions (or any other indented block).\n\n        If the current input produces a syntax error, this method immediately\n        returns False but does *not* raise the syntax error exception, as\n        typically clients will want to send invalid syntax to an execution\n        backend which might convert the invalid syntax into valid Python via\n        one of the dynamic IPython mechanisms.", "id": "f21466:c0:m4"}
{"signature": "def _make_help_call(target, esc, lspace, next_input=None):", "body": "method  = '<STR_LIT>' if esc == '<STR_LIT>'else '<STR_LIT>' if '<STR_LIT:*>' in targetelse '<STR_LIT>'<EOL>arg = \"<STR_LIT:U+0020>\".join([method, target])<EOL>if next_input is None:<EOL><INDENT>return '<STR_LIT>' % (lspace, arg)<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT>' %(lspace, next_input, arg)<EOL><DEDENT>", "docstring": "Prepares a pinfo(2)/psearch call from a target name and the escape\n    (i.e. ? or ??)", "id": "f21466:m10"}
{"signature": "def reset(self):", "body": "super(IPythonInputSplitter, self).reset()<EOL>self._buffer_raw[:] = []<EOL>self.source_raw = '<STR_LIT>'<EOL>self.cell_magic_parts = []<EOL>self.processing_cell_magic = False<EOL>", "docstring": "Reset the input buffer and associated state.", "id": "f21466:c2:m1"}
{"signature": "def reset(self):", "body": "self.indent_spaces = <NUM_LIT:0><EOL>self._buffer[:] = []<EOL>self.source = '<STR_LIT>'<EOL>self.code = None<EOL>self._is_complete = False<EOL>self._full_dedent = False<EOL>", "docstring": "Reset the input buffer and associated state.", "id": "f21466:c0:m1"}
{"signature": "def exception_colors():", "body": "ex_colors = ColorSchemeTable()<EOL>C = TermColors <EOL>ex_colors.add_scheme(ColorScheme(<EOL>'<STR_LIT>',<EOL>topline = C.NoColor,<EOL>filename = C.NoColor,<EOL>lineno = C.NoColor,<EOL>name = C.NoColor,<EOL>vName = C.NoColor,<EOL>val = C.NoColor,<EOL>em = C.NoColor,<EOL>normalEm = C.NoColor,<EOL>filenameEm = C.NoColor,<EOL>linenoEm = C.NoColor,<EOL>nameEm = C.NoColor,<EOL>valEm = C.NoColor,<EOL>excName = C.NoColor,<EOL>line = C.NoColor,<EOL>caret = C.NoColor,<EOL>Normal = C.NoColor<EOL>))<EOL>ex_colors.add_scheme(ColorScheme(<EOL>'<STR_LIT>',<EOL>topline = C.LightRed,<EOL>filename = C.Green,<EOL>lineno = C.Green,<EOL>name = C.Purple,<EOL>vName = C.Cyan,<EOL>val = C.Green,<EOL>em = C.LightCyan,<EOL>normalEm = C.LightCyan,<EOL>filenameEm = C.LightGreen,<EOL>linenoEm = C.LightGreen,<EOL>nameEm = C.LightPurple,<EOL>valEm = C.LightBlue,<EOL>excName = C.LightRed,<EOL>line = C.Yellow,<EOL>caret = C.White,<EOL>Normal = C.Normal<EOL>))<EOL>ex_colors.add_scheme(ColorScheme(<EOL>'<STR_LIT>',<EOL>topline = C.Red,<EOL>filename = C.LightGreen,<EOL>lineno = C.LightGreen,<EOL>name = C.LightPurple,<EOL>vName = C.Cyan,<EOL>val = C.LightGreen,<EOL>em = C.Cyan,<EOL>normalEm = C.Cyan,<EOL>filenameEm = C.Green,<EOL>linenoEm = C.Green,<EOL>nameEm = C.Purple,<EOL>valEm = C.Blue,<EOL>excName = C.Red,<EOL>line = C.Red,<EOL>caret = C.Normal,<EOL>Normal = C.Normal,<EOL>))<EOL>return ex_colors<EOL>", "docstring": "Return a color table with fields for exception reporting.\n\n    The table is an instance of ColorSchemeTable with schemes added for\n    'Linux', 'LightBG' and 'NoColor' and fields for exception handling filled\n    in.\n\n    Examples:\n\n    >>> ec = exception_colors()\n    >>> ec.active_scheme_name\n    ''\n    >>> print ec.active_colors\n    None\n\n    Now we activate a color scheme:\n    >>> ec.set_active_scheme('NoColor')\n    >>> ec.active_scheme_name\n    'NoColor'\n    >>> sorted(ec.active_colors.keys())\n    ['Normal', 'caret', 'em', 'excName', 'filename', 'filenameEm', 'line',\n    'lineno', 'linenoEm', 'name', 'nameEm', 'normalEm', 'topline', 'vName',\n    'val', 'valEm']", "id": "f21467:m0"}
{"signature": "def _validate_data(self, source, data, metadata=None):", "body": "if not isinstance(source, basestring):<EOL><INDENT>raise TypeError('<STR_LIT>' % source)<EOL><DEDENT>if not isinstance(data, dict):<EOL><INDENT>raise TypeError('<STR_LIT>' % data)<EOL><DEDENT>if metadata is not None:<EOL><INDENT>if not isinstance(metadata, dict):<EOL><INDENT>raise TypeError('<STR_LIT>' % data)<EOL><DEDENT><DEDENT>", "docstring": "Validate the display data.\n\n        Parameters\n        ----------\n        source : str\n            The fully dotted name of the callable that created the data, like\n            :func:`foo.bar.my_formatter`.\n        data : dict\n            The formata data dictionary.\n        metadata : dict\n            Any metadata for the data.", "id": "f21468:c0:m0"}
{"signature": "def publish_html(data, metadata=None):", "body": "publish_display_data(<EOL>u'<STR_LIT>',<EOL>{'<STR_LIT>':data},<EOL>metadata=metadata<EOL>)<EOL>", "docstring": "Publish raw HTML data to all frontends.\n\n    Parameters\n    ----------\n    data : unicode\n        The raw HTML data to publish.\n    metadata : dict\n        A dictionary for metadata related to the data. This can contain\n        arbitrary key, value pairs that frontends can use to interpret\n        the data.", "id": "f21468:m2"}
{"signature": "def publish_latex(data, metadata=None):", "body": "publish_display_data(<EOL>u'<STR_LIT>',<EOL>{'<STR_LIT>':data},<EOL>metadata=metadata<EOL>)<EOL>", "docstring": "Publish raw LaTeX data to all frontends.\n\n    Parameters\n    ----------\n    data : unicode\n        The raw LaTeX data to publish.\n    metadata : dict\n        A dictionary for metadata related to the data. This can contain\n        arbitrary key, value pairs that frontends can use to interpret\n        the data.", "id": "f21468:m3"}
{"signature": "def module_completer(self,event):", "body": "<EOL>return module_completion(event.line)<EOL>", "docstring": "Give completions after user has typed 'import ...' or 'from ...", "id": "f21469:m6"}
{"signature": "def cd_completer(self, event):", "body": "ip = get_ipython()<EOL>relpath = event.symbol<EOL>if event.line.endswith('<STR_LIT>') or '<STR_LIT>' in event.line:<EOL><INDENT>bkms = self.db.get('<STR_LIT>', None)<EOL>if bkms:<EOL><INDENT>return bkms.keys()<EOL><DEDENT>else:<EOL><INDENT>return []<EOL><DEDENT><DEDENT>if event.symbol == '<STR_LIT:->':<EOL><INDENT>width_dh = str(len(str(len(ip.user_ns['<STR_LIT>']) + <NUM_LIT:1>)))<EOL>fmt = '<STR_LIT>' + width_dh +'<STR_LIT>'<EOL>ents = [ fmt % (i,s) for i,s in enumerate(ip.user_ns['<STR_LIT>'])]<EOL>if len(ents) > <NUM_LIT:1>:<EOL><INDENT>return ents<EOL><DEDENT>return []<EOL><DEDENT>if event.symbol.startswith('<STR_LIT>'):<EOL><INDENT>return [\"<STR_LIT>\" + os.path.basename(d) for d in ip.user_ns['<STR_LIT>']]<EOL><DEDENT>relpath, tilde_expand, tilde_val = expand_user(relpath)<EOL>relpath = relpath.replace('<STR_LIT:\\\\>','<STR_LIT:/>')<EOL>found = []<EOL>for d in [f.replace('<STR_LIT:\\\\>','<STR_LIT:/>') + '<STR_LIT:/>' for f in glob.glob(relpath+'<STR_LIT:*>')<EOL>if os.path.isdir(f)]:<EOL><INDENT>if '<STR_LIT:U+0020>' in d:<EOL><INDENT>raise TryNext<EOL><DEDENT>found.append(d)<EOL><DEDENT>if not found:<EOL><INDENT>if os.path.isdir(relpath):<EOL><INDENT>return [compress_user(relpath, tilde_expand, tilde_val)]<EOL><DEDENT>bks = self.db.get('<STR_LIT>',{}).iterkeys()<EOL>bkmatches = [s for s in bks if s.startswith(event.symbol)]<EOL>if bkmatches:<EOL><INDENT>return bkmatches<EOL><DEDENT>raise TryNext<EOL><DEDENT>return [compress_user(p, tilde_expand, tilde_val) for p in found]<EOL>", "docstring": "Completer function for cd, which only returns directories.", "id": "f21469:m8"}
{"signature": "def get_root_modules():", "body": "ip = get_ipython()<EOL>if '<STR_LIT>' in ip.db:<EOL><INDENT>return ip.db['<STR_LIT>']<EOL><DEDENT>t = time()<EOL>store = False<EOL>modules = list(sys.builtin_module_names)<EOL>for path in sys.path:<EOL><INDENT>modules += module_list(path)<EOL>if time() - t >= TIMEOUT_STORAGE and not store:<EOL><INDENT>store = True<EOL>print(\"<STR_LIT>\")<EOL>print(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>sys.stdout.flush()<EOL><DEDENT>if time() - t > TIMEOUT_GIVEUP:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>ip.db['<STR_LIT>'] = []<EOL>return []<EOL><DEDENT><DEDENT>modules = set(modules)<EOL>if '<STR_LIT>' in modules:<EOL><INDENT>modules.remove('<STR_LIT>')<EOL><DEDENT>modules = list(modules)<EOL>if store:<EOL><INDENT>ip.db['<STR_LIT>'] = modules<EOL><DEDENT>return modules<EOL>", "docstring": "Returns a list containing the names of all the modules available in the\nfolders of the pythonpath.", "id": "f21469:m1"}
{"signature": "def magic_run_completer(self, event):", "body": "comps = arg_split(event.line, strict=False)<EOL>relpath = (len(comps) > <NUM_LIT:1> and comps[-<NUM_LIT:1>] or '<STR_LIT>').strip(\"<STR_LIT>\")<EOL>lglob = glob.glob<EOL>isdir = os.path.isdir<EOL>relpath, tilde_expand, tilde_val = expand_user(relpath)<EOL>dirs = [f.replace('<STR_LIT:\\\\>','<STR_LIT:/>') + \"<STR_LIT:/>\" for f in lglob(relpath+'<STR_LIT:*>') if isdir(f)]<EOL>if filter(magic_run_re.match, comps):<EOL><INDENT>pys =  [f.replace('<STR_LIT:\\\\>','<STR_LIT:/>') for f in lglob('<STR_LIT:*>')]<EOL><DEDENT>else:<EOL><INDENT>pys =  [f.replace('<STR_LIT:\\\\>','<STR_LIT:/>')<EOL>for f in lglob(relpath+'<STR_LIT>') + lglob(relpath+'<STR_LIT>') +<EOL>lglob(relpath + '<STR_LIT>')]<EOL><DEDENT>return [compress_user(p, tilde_expand, tilde_val) for p in dirs+pys]<EOL>", "docstring": "Complete files that end in .py or .ipy for the %run command.", "id": "f21469:m7"}
{"signature": "def reset_completer(self, event):", "body": "return '<STR_LIT>'.split()<EOL>", "docstring": "A completer for %reset magic", "id": "f21469:m9"}
{"signature": "def module_completion(line):", "body": "words = line.split('<STR_LIT:U+0020>')<EOL>nwords = len(words)<EOL>if nwords == <NUM_LIT:3> and words[<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>return ['<STR_LIT>']<EOL><DEDENT>if nwords < <NUM_LIT:3> and (words[<NUM_LIT:0>] in ['<STR_LIT>','<STR_LIT>']) :<EOL><INDENT>if nwords == <NUM_LIT:1>:<EOL><INDENT>return get_root_modules()<EOL><DEDENT>mod = words[<NUM_LIT:1>].split('<STR_LIT:.>')<EOL>if len(mod) < <NUM_LIT:2>:<EOL><INDENT>return get_root_modules()<EOL><DEDENT>completion_list = try_import('<STR_LIT:.>'.join(mod[:-<NUM_LIT:1>]), True)<EOL>return ['<STR_LIT:.>'.join(mod[:-<NUM_LIT:1>] + [el]) for el in completion_list]<EOL><DEDENT>if nwords >= <NUM_LIT:3> and words[<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>mod = words[<NUM_LIT:1>]<EOL>return try_import(mod)<EOL><DEDENT>", "docstring": "Returns a list containing the completion possibilities for an import line.\n\nThe line looks like this :\n'import xml.d'\n'from xml.dom import'", "id": "f21469:m5"}
{"signature": "def _format_lineno(session, line):", "body": "if session == <NUM_LIT:0>:<EOL><INDENT>return str(line)<EOL><DEDENT>return \"<STR_LIT>\" % (session, line)<EOL>", "docstring": "Helper function to format line numbers properly.", "id": "f21470:m2"}
{"signature": "def _get_hist_file_name(self, profile='<STR_LIT:default>'):", "body": "return os.path.join(locate_profile(profile), '<STR_LIT>')<EOL>", "docstring": "Find the history file for the given profile name.\n\n        This is overridden by the HistoryManager subclass, to use the shell's\n        active profile.\n\n        Parameters\n        ----------\n        profile : str\n          The name of a profile which has a history file.", "id": "f21470:c1:m1"}
{"signature": "def name_session(self, name):", "body": "with self.db:<EOL><INDENT>self.db.execute(\"<STR_LIT>\",<EOL>(name, self.session_number))<EOL><DEDENT>", "docstring": "Give the current session a name in the history database.", "id": "f21470:c2:m5"}
{"signature": "def reset(self, new_session=True):", "body": "self.output_hist.clear()<EOL>self.dir_hist[:] = [os.getcwdu()]<EOL>if new_session:<EOL><INDENT>if self.session_number:<EOL><INDENT>self.end_session()<EOL><DEDENT>self.input_hist_parsed[:] = [\"<STR_LIT>\"]<EOL>self.input_hist_raw[:] = [\"<STR_LIT>\"]<EOL>self.new_session()<EOL><DEDENT>", "docstring": "Clear the session history, releasing all object references, and\n        optionally open a new session.", "id": "f21470:c2:m6"}
{"signature": "def get_range(self, session, start=<NUM_LIT:1>, stop=None, raw=True,output=False):", "body": "if stop:<EOL><INDENT>lineclause = \"<STR_LIT>\"<EOL>params = (session, start, stop)<EOL><DEDENT>else:<EOL><INDENT>lineclause = \"<STR_LIT>\"<EOL>params = (session, start)<EOL><DEDENT>return self._run_sql(\"<STR_LIT>\"\"<STR_LIT>\" % lineclause,<EOL>params, raw=raw, output=output)<EOL>", "docstring": "Retrieve input by session.\n\n        Parameters\n        ----------\n        session : int\n            Session number to retrieve.\n        start : int\n            First line to retrieve.\n        stop : int\n            End of line range (excluded from output itself). If None, retrieve\n            to the end of the session.\n        raw : bool\n            If True, return untranslated input\n        output : bool\n            If True, attempt to include output. This will be 'real' Python\n            objects for the current session, or text reprs from previous\n            sessions if db_log_output was enabled at the time. Where no output\n            is found, None is used.\n\n        Returns\n        -------\n        An iterator over the desired lines. Each line is a 3-tuple, either\n        (session, line, input) if output is False, or\n        (session, line, (input, output)) if output is True.", "id": "f21470:c1:m8"}
{"signature": "def _get_hist_file_name(self, profile=None):", "body": "profile_dir = self.shell.profile_dir.location<EOL>return os.path.join(profile_dir, '<STR_LIT>')<EOL>", "docstring": "Get default history file name based on the Shell's profile.\n\n        The profile parameter is ignored, but must exist for compatibility with\n        the parent class.", "id": "f21470:c2:m2"}
{"signature": "def stop(self):", "body": "self.stop_now = True<EOL>self.history_manager.save_flag.set()<EOL>self.join()<EOL>", "docstring": "This can be called from the main thread to safely stop this thread.\n\n        Note that it does not attempt to write out remaining history before\n        exiting. That should be done by calling the HistoryManager's\n        end_session method.", "id": "f21470:c3:m2"}
{"signature": "def _run_sql(self, sql, params, raw=True, output=False):", "body": "toget = '<STR_LIT>' if raw else '<STR_LIT:source>'<EOL>sqlfrom = \"<STR_LIT>\"<EOL>if output:<EOL><INDENT>sqlfrom = \"<STR_LIT>\"<EOL>toget = \"<STR_LIT>\" % toget<EOL><DEDENT>cur = self.db.execute(\"<STR_LIT>\" %(toget, sqlfrom) + sql, params)<EOL>if output:    <EOL><INDENT>return ((ses, lin, (inp, out)) for ses, lin, inp, out in cur)<EOL><DEDENT>return cur<EOL>", "docstring": "Prepares and runs an SQL query for the history database.\n\n        Parameters\n        ----------\n        sql : str\n          Any filtering expressions to go after SELECT ... FROM ...\n        params : tuple\n          Parameters passed to the SQL query (to replace \"?\")\n        raw, output : bool\n          See :meth:`get_range`\n\n        Returns\n        -------\n        Tuples as :meth:`get_range`", "id": "f21470:c1:m4"}
{"signature": "def get_range(self, session=<NUM_LIT:0>, start=<NUM_LIT:1>, stop=None, raw=True,output=False):", "body": "if session <= <NUM_LIT:0>:<EOL><INDENT>session += self.session_number<EOL><DEDENT>if session==self.session_number:          <EOL><INDENT>return self._get_range_session(start, stop, raw, output)<EOL><DEDENT>return super(HistoryManager, self).get_range(session, start, stop, raw,<EOL>output)<EOL>", "docstring": "Retrieve input by session.\n\n        Parameters\n        ----------\n        session : int\n            Session number to retrieve. The current session is 0, and negative\n            numbers count back from current session, so -1 is previous session.\n        start : int\n            First line to retrieve.\n        stop : int\n            End of line range (excluded from output itself). If None, retrieve\n            to the end of the session.\n        raw : bool\n            If True, return untranslated input\n        output : bool\n            If True, attempt to include output. This will be 'real' Python\n            objects for the current session, or text reprs from previous\n            sessions if db_log_output was enabled at the time. Where no output\n            is found, None is used.\n\n        Returns\n        -------\n        An iterator over the desired lines. Each line is a 3-tuple, either\n        (session, line, input) if output is False, or\n        (session, line, (input, output)) if output is True.", "id": "f21470:c2:m8"}
{"signature": "def extract_hist_ranges(ranges_str):", "body": "for range_str in ranges_str.split():<EOL><INDENT>rmatch = range_re.match(range_str)<EOL>if not rmatch:<EOL><INDENT>continue<EOL><DEDENT>start = int(rmatch.group(\"<STR_LIT:start>\"))<EOL>end = rmatch.group(\"<STR_LIT:end>\")<EOL>end = int(end) if end else start+<NUM_LIT:1>   <EOL>if rmatch.group(\"<STR_LIT>\") == \"<STR_LIT:->\":       <EOL><INDENT>end += <NUM_LIT:1><EOL><DEDENT>startsess = rmatch.group(\"<STR_LIT>\") or \"<STR_LIT:0>\"<EOL>endsess = rmatch.group(\"<STR_LIT>\") or startsess<EOL>startsess = int(startsess.replace(\"<STR_LIT>\",\"<STR_LIT:->\"))<EOL>endsess = int(endsess.replace(\"<STR_LIT>\",\"<STR_LIT:->\"))<EOL>assert endsess >= startsess<EOL>if endsess == startsess:<EOL><INDENT>yield (startsess, start, end)<EOL>continue<EOL><DEDENT>yield (startsess, start, None)<EOL>for sess in range(startsess+<NUM_LIT:1>, endsess):<EOL><INDENT>yield (sess, <NUM_LIT:1>, None)<EOL><DEDENT>yield (endsess, <NUM_LIT:1>, end)<EOL><DEDENT>", "docstring": "Turn a string of history ranges into 3-tuples of (session, start, stop).\n\n    Examples\n    --------\n    list(extract_input_ranges(\"~8/5-~7/4 2\"))\n    [(-8, 5, None), (-7, 1, 4), (0, 2, 3)]", "id": "f21470:m1"}
{"signature": "def _get_range_session(self, start=<NUM_LIT:1>, stop=None, raw=True, output=False):", "body": "input_hist = self.input_hist_raw if raw else self.input_hist_parsed<EOL>n = len(input_hist)<EOL>if start < <NUM_LIT:0>:<EOL><INDENT>start += n<EOL><DEDENT>if not stop or (stop > n):<EOL><INDENT>stop = n<EOL><DEDENT>elif stop < <NUM_LIT:0>:<EOL><INDENT>stop += n<EOL><DEDENT>for i in range(start, stop):<EOL><INDENT>if output:<EOL><INDENT>line = (input_hist[i], self.output_hist_reprs.get(i))<EOL><DEDENT>else:<EOL><INDENT>line = input_hist[i]<EOL><DEDENT>yield (<NUM_LIT:0>, i, line)<EOL><DEDENT>", "docstring": "Get input and output history from the current session. Called by\n        get_range, and takes similar parameters.", "id": "f21470:c2:m7"}
{"signature": "def log_write(self, data, kind='<STR_LIT:input>'):", "body": "<EOL>if self.log_active and data:<EOL><INDENT>write = self.logfile.write<EOL>if kind=='<STR_LIT:input>':<EOL><INDENT>if self.timestamp:<EOL><INDENT>write(str_to_unicode(time.strftime('<STR_LIT>',<EOL>time.localtime())))<EOL><DEDENT>write(data)<EOL><DEDENT>elif kind=='<STR_LIT>' and self.log_output:<EOL><INDENT>odata = '<STR_LIT:\\n>'.join(['<STR_LIT>' % s<EOL>for s in data.splitlines()])<EOL>write('<STR_LIT>' % odata)<EOL><DEDENT>self.logfile.flush()<EOL><DEDENT>", "docstring": "Write data to the log file, if active", "id": "f21471:c0:m7"}
{"signature": "def logstate(self):", "body": "if self.logfile is None:<EOL><INDENT>print('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>state = self.log_active and '<STR_LIT>' or '<STR_LIT>'<EOL>print('<STR_LIT>',self.logfname)<EOL>print('<STR_LIT>',self.logmode)<EOL>print('<STR_LIT>',self.log_output)<EOL>print('<STR_LIT>',self.log_raw_input)<EOL>print('<STR_LIT>',self.timestamp)<EOL>print('<STR_LIT>',state)<EOL><DEDENT>", "docstring": "Print a status message about the logger.", "id": "f21471:c0:m5"}
{"signature": "def mark_module_skipped(self, module_name):", "body": "try:<EOL><INDENT>del self.modules[module_name]<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>self.skip_modules[module_name] = True<EOL>", "docstring": "Skip reloading the named module in the future", "id": "f21476:c0:m0"}
{"signature": "def update_property(old, new):", "body": "update_generic(old.fdel, new.fdel)<EOL>update_generic(old.fget, new.fget)<EOL>update_generic(old.fset, new.fset)<EOL>", "docstring": "Replace get/set/del functions of a property", "id": "f21476:m3"}
{"signature": "@line_magic<EOL><INDENT>def aimport(self, parameter_s='<STR_LIT>', stream=None):<DEDENT>", "body": "modname = parameter_s<EOL>if not modname:<EOL><INDENT>to_reload = self._reloader.modules.keys()<EOL>to_reload.sort()<EOL>to_skip = self._reloader.skip_modules.keys()<EOL>to_skip.sort()<EOL>if stream is None:<EOL><INDENT>stream = sys.stdout<EOL><DEDENT>if self._reloader.check_all:<EOL><INDENT>stream.write(\"<STR_LIT>\")<EOL><DEDENT>else:<EOL><INDENT>stream.write(\"<STR_LIT>\" % '<STR_LIT:U+0020>'.join(to_reload))<EOL><DEDENT>stream.write(\"<STR_LIT>\" % '<STR_LIT:U+0020>'.join(to_skip))<EOL><DEDENT>elif modname.startswith('<STR_LIT:->'):<EOL><INDENT>modname = modname[<NUM_LIT:1>:]<EOL>self._reloader.mark_module_skipped(modname)<EOL><DEDENT>else:<EOL><INDENT>top_module, top_name = self._reloader.aimport_module(modname)<EOL>self.shell.push({top_name: top_module})<EOL><DEDENT>", "docstring": "%aimport => Import modules for automatic reloading.\n\n        %aimport\n        List modules to automatically import and not to import.\n\n        %aimport foo\n        Import module 'foo' and mark it to be autoreloaded for %autoreload 1\n\n        %aimport -foo\n        Mark module 'foo' to not be autoreloaded for %autoreload 1", "id": "f21476:c2:m2"}
{"signature": "@line_magic<EOL><INDENT>def autoreload(self, parameter_s='<STR_LIT>'):<DEDENT>", "body": "if parameter_s == '<STR_LIT>':<EOL><INDENT>self._reloader.check(True)<EOL><DEDENT>elif parameter_s == '<STR_LIT:0>':<EOL><INDENT>self._reloader.enabled = False<EOL><DEDENT>elif parameter_s == '<STR_LIT:1>':<EOL><INDENT>self._reloader.check_all = False<EOL>self._reloader.enabled = True<EOL><DEDENT>elif parameter_s == '<STR_LIT:2>':<EOL><INDENT>self._reloader.check_all = True<EOL>self._reloader.enabled = True<EOL><DEDENT>", "docstring": "r\"\"\"%autoreload => Reload modules automatically\n\n        %autoreload\n        Reload all modules (except those excluded by %aimport) automatically\n        now.\n\n        %autoreload 0\n        Disable automatic reloading.\n\n        %autoreload 1\n        Reload all modules imported with %aimport every time before executing\n        the Python code typed.\n\n        %autoreload 2\n        Reload all modules (except those excluded by %aimport) every time\n        before executing the Python code typed.\n\n        Reloading Python modules in a reliable way is in general\n        difficult, and unexpected things may occur. %autoreload tries to\n        work around common pitfalls by replacing function code objects and\n        parts of classes previously in the module with new versions. This\n        makes the following things to work:\n\n        - Functions and classes imported via 'from xxx import foo' are upgraded\n          to new versions when 'xxx' is reloaded.\n\n        - Methods and properties of classes are upgraded on reload, so that\n          calling 'c.foo()' on an object 'c' created before the reload causes\n          the new code for 'foo' to be executed.\n\n        Some of the known remaining caveats are:\n\n        - Replacing code objects does not always succeed: changing a @property\n          in a class to an ordinary method or a method to a member variable\n          can cause problems (but in old objects only).\n\n        - Functions that are removed (eg. via monkey-patching) from a module\n          before it is reloaded are not upgraded.\n\n        - C extension modules cannot be reloaded, and so cannot be\n          autoreloaded.", "id": "f21476:c2:m1"}
{"signature": "def aimport_module(self, module_name):", "body": "self.mark_module_reloadable(module_name)<EOL>__import__(module_name)<EOL>top_name = module_name.split('<STR_LIT:.>')[<NUM_LIT:0>]<EOL>top_module = sys.modules[top_name]<EOL>return top_module, top_name<EOL>", "docstring": "Import a module, and mark it reloadable\n\n        Returns\n        -------\n        top_module : module\n            The imported module if it is top-level, or the top-level\n        top_name : module\n            Name of top_module", "id": "f21476:c0:m2"}
{"signature": "def load_ipython_extension(ip):", "body": "global _loaded<EOL>if not _loaded:<EOL><INDENT>ip.register_magics(RMagics)<EOL>_loaded = True<EOL><DEDENT>", "docstring": "Load the extension in IPython.", "id": "f21477:m1"}
{"signature": "def flush(self):", "body": "value = '<STR_LIT>'.join([str_to_unicode(s, '<STR_LIT:utf-8>') for s in self.Rstdout_cache])<EOL>self.Rstdout_cache = []<EOL>return value<EOL>", "docstring": "Flush R's stdout cache to a string, returning the string.", "id": "f21477:c1:m3"}
{"signature": "def write_console(self, output):", "body": "self.Rstdout_cache.append(output)<EOL>", "docstring": "A hook to capture R's stdout in a cache.", "id": "f21477:c1:m2"}
{"signature": "def print_png(o):", "body": "s = latex(o, mode='<STR_LIT>')<EOL>s = s.replace('<STR_LIT>','<STR_LIT>')<EOL>s = s.replace('<STR_LIT>', '<STR_LIT>')<EOL>png = latex_to_png(s)<EOL>return png<EOL>", "docstring": "A function to display sympy expression using inline style LaTeX in PNG.", "id": "f21482:m1"}
{"signature": "def print_basic_unicode(o, p, cycle):", "body": "if cycle:<EOL><INDENT>return p.text('<STR_LIT>')<EOL><DEDENT>out = pretty(o, use_unicode=True)<EOL>if '<STR_LIT:\\n>' in out:<EOL><INDENT>p.text(u'<STR_LIT:\\n>')<EOL><DEDENT>p.text(out)<EOL>", "docstring": "A function to pretty print sympy Basic objects.", "id": "f21482:m0"}
{"signature": "def __init__(self, **kwargs):", "body": "config = kwargs.pop('<STR_LIT>', None)<EOL>if config is not None:<EOL><INDENT>self.config = config<EOL><DEDENT>super(Configurable, self).__init__(**kwargs)<EOL>self.created = datetime.datetime.now()<EOL>", "docstring": "Create a configurable given a config config.\n\n        Parameters\n        ----------\n        config : Config\n            If this is empty, default values are used. If config is a\n            :class:`Config` instance, it will be used to configure the\n            instance.\n\n        Notes\n        -----\n        Subclasses of Configurable must call the :meth:`__init__` method of\n        :class:`Configurable` *before* doing anything else and using\n        :func:`super`::\n\n            class MyConfigurable(Configurable):\n                def __init__(self, config=None):\n                    super(MyConfigurable, self).__init__(config)\n                    # Then any other code you need to finish initialization.\n\n        This ensures that instances will be configured properly.", "id": "f21494:c2:m0"}
{"signature": "@classmethod<EOL><INDENT>def class_config_section(cls):<DEDENT>", "body": "def c(s):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>s = '<STR_LIT>'.join(wrap_paragraphs(s, <NUM_LIT>))<EOL>return '<STR_LIT>' + s.replace('<STR_LIT:\\n>', '<STR_LIT>')<EOL><DEDENT>breaker = '<STR_LIT:#>' + '<STR_LIT:->'*<NUM_LIT><EOL>s = \"<STR_LIT>\"%cls.__name__<EOL>lines = [breaker, s, breaker, '<STR_LIT>']<EOL>desc = cls.class_traits().get('<STR_LIT:description>')<EOL>if desc:<EOL><INDENT>desc = desc.default_value<EOL><DEDENT>else:<EOL><INDENT>desc = getattr(cls, '<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>if desc:<EOL><INDENT>lines.append(c(desc))<EOL>lines.append('<STR_LIT>')<EOL><DEDENT>parents = []<EOL>for parent in cls.mro():<EOL><INDENT>if parent is not cls and issubclass(parent, Configurable) andparent.class_traits(config=True):<EOL><INDENT>parents.append(parent)<EOL><DEDENT><DEDENT>if parents:<EOL><INDENT>pstr = '<STR_LIT:U+002CU+0020>'.join([ p.__name__ for p in parents ])<EOL>lines.append(c('<STR_LIT>'%(cls.__name__, pstr)))<EOL>lines.append('<STR_LIT>')<EOL><DEDENT>for name,trait in cls.class_traits(config=True).items():<EOL><INDENT>help = trait.get_metadata('<STR_LIT>') or '<STR_LIT>'<EOL>lines.append(c(help))<EOL>lines.append('<STR_LIT>'%(cls.__name__, name, trait.get_default_value()))<EOL>lines.append('<STR_LIT>')<EOL><DEDENT>return '<STR_LIT:\\n>'.join(lines)<EOL>", "docstring": "Get the config class config section", "id": "f21494:c2:m6"}
{"signature": "@classmethod<EOL><INDENT>def initialized(cls):<DEDENT>", "body": "return hasattr(cls, \"<STR_LIT>\") and cls._instance is not None<EOL>", "docstring": "Has an instance been created?", "id": "f21494:c3:m3"}
{"signature": "@catch_config_error<EOL><INDENT>def parse_command_line(self, argv=None):<DEDENT>", "body": "argv = sys.argv[<NUM_LIT:1>:] if argv is None else argv<EOL>if argv and argv[<NUM_LIT:0>] == '<STR_LIT>':<EOL><INDENT>argv = argv[<NUM_LIT:1>:] + ['<STR_LIT>']<EOL><DEDENT>if self.subcommands and len(argv) > <NUM_LIT:0>:<EOL><INDENT>subc, subargv = argv[<NUM_LIT:0>], argv[<NUM_LIT:1>:]<EOL>if re.match(r'<STR_LIT>', subc) and subc in self.subcommands:<EOL><INDENT>return self.initialize_subcommand(subc, subargv)<EOL><DEDENT><DEDENT>if '<STR_LIT>' in argv or '<STR_LIT>' in argv or '<STR_LIT>' in argv:<EOL><INDENT>self.print_description()<EOL>self.print_help('<STR_LIT>' in argv)<EOL>self.print_examples()<EOL>self.exit(<NUM_LIT:0>)<EOL><DEDENT>if '<STR_LIT>' in argv or '<STR_LIT>' in argv:<EOL><INDENT>self.print_version()<EOL>self.exit(<NUM_LIT:0>)<EOL><DEDENT>flags,aliases = self.flatten_flags()<EOL>loader = KVArgParseConfigLoader(argv=argv, aliases=aliases,<EOL>flags=flags)<EOL>config = loader.load_config()<EOL>self.update_config(config)<EOL>self.extra_args = loader.extra_args<EOL>", "docstring": "Parse the command line arguments.", "id": "f21495:c1:m18"}
{"signature": "def _log_level_changed(self, name, old, new):", "body": "if isinstance(new, str):<EOL><INDENT>new = getattr(logging, new)<EOL>self.log_level = new<EOL><DEDENT>self.log.setLevel(new)<EOL>", "docstring": "Adjust the log level when log_level is set.", "id": "f21495:c1:m0"}
{"signature": "def generate_config_file(self):", "body": "lines = [\"<STR_LIT>\"%self.name]<EOL>lines.append('<STR_LIT>')<EOL>lines.append('<STR_LIT>')<EOL>lines.append('<STR_LIT>')<EOL>for cls in self.classes:<EOL><INDENT>lines.append(cls.class_config_section())<EOL><DEDENT>return '<STR_LIT:\\n>'.join(lines)<EOL>", "docstring": "generate default config file from Configurables", "id": "f21495:c1:m20"}
{"signature": "def load_config(self):", "body": "self.clear()<EOL>return self.config<EOL>", "docstring": "Load a config from somewhere, return a :class:`Config` instance.\n\n        Usually, this will cause self.config to be set and then returned.\n        However, in most cases, :meth:`ConfigLoader.clear` should be called\n        to erase any previous state.", "id": "f21496:c6:m2"}
{"signature": "def load_config(self, argv=None, aliases=None, flags=None):", "body": "self.clear()<EOL>if argv is None:<EOL><INDENT>argv = self.argv<EOL><DEDENT>if aliases is None:<EOL><INDENT>aliases = self.aliases<EOL><DEDENT>if flags is None:<EOL><INDENT>flags = self.flags<EOL><DEDENT>self._create_parser(aliases, flags)<EOL>self._parse_args(argv)<EOL>self._convert_to_config()<EOL>return self.config<EOL>", "docstring": "Parse command line arguments and return as a Config object.\n\n        Parameters\n        ----------\n\n        args : optional, list\n          If given, a list with the structure of sys.argv[1:] to parse\n          arguments from. If not given, the instance's self.argv attribute\n          (given at construction time) is used.", "id": "f21496:c11:m1"}
{"signature": "def __init__(self, filename, path=None):", "body": "super(PyFileConfigLoader, self).__init__()<EOL>self.filename = filename<EOL>self.path = path<EOL>self.full_filename = '<STR_LIT>'<EOL>self.data = None<EOL>", "docstring": "Build a config loader for a filename and path.\n\n        Parameters\n        ----------\n        filename : str\n            The file name of the config file.\n        path : str, list, tuple\n            The path to search for the config file on, or a sequence of\n            paths to try in order.", "id": "f21496:c8:m0"}
{"signature": "def _decode_argv(self, argv, enc=None):", "body": "uargv = []<EOL>if enc is None:<EOL><INDENT>enc = DEFAULT_ENCODING<EOL><DEDENT>for arg in argv:<EOL><INDENT>if not isinstance(arg, str):<EOL><INDENT>arg = arg.decode(enc)<EOL><DEDENT>uargv.append(arg)<EOL><DEDENT>return uargv<EOL>", "docstring": "decode argv if bytes, using stin.encoding, falling back on default enc", "id": "f21496:c10:m2"}
{"signature": "def post_notification(self, ntype, sender, *args, **kwargs):", "body": "if(ntype==None or sender==None):<EOL><INDENT>raise NotificationError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>if((ntype not in self.registered_types and<EOL>None not in self.registered_types) or<EOL>(sender not in self.registered_senders and<EOL>None not in self.registered_senders)):<EOL><INDENT>return<EOL><DEDENT>for o in self._observers_for_notification(ntype, sender):<EOL><INDENT>o(ntype, sender, *args, **kwargs)<EOL><DEDENT>", "docstring": "Post notification to all registered observers.\n\n        The registered callback will be called as::\n\n            callback(ntype, sender, *args, **kwargs)\n\n        Parameters\n        ----------\n        ntype : hashable\n            The notification type.\n        sender : hashable\n            The object sending the notification.\n        *args : tuple\n            The positional arguments to be passed to the callback.\n        **kwargs : dict\n            The keyword argument to be passed to the callback.\n\n        Notes\n        -----\n        * If no registered observers, performance is O(1).\n        * Notificaiton order is undefined.\n        * Notifications are posted synchronously.", "id": "f21498:c1:m2"}
{"signature": "def _observers_for_notification(self, ntype, sender):", "body": "keys = (<EOL>(ntype,sender),<EOL>(ntype, None),<EOL>(None, sender),<EOL>(None,None)<EOL>)<EOL>obs = set()<EOL>for k in keys:<EOL><INDENT>obs.update(self.observers.get(k, set()))<EOL><DEDENT>return obs<EOL>", "docstring": "Find all registered observers that should recieve notification", "id": "f21498:c1:m3"}
{"signature": "def _init_observers(self):", "body": "self.registered_types = set() <EOL>self.registered_senders = set() <EOL>self.observers = {}<EOL>", "docstring": "Initialize observer storage", "id": "f21498:c1:m1"}
{"signature": "def locate_profile(profile='<STR_LIT:default>'):", "body": "from IPython.core.profiledir import ProfileDir, ProfileDirError<EOL>try:<EOL><INDENT>pd = ProfileDir.find_profile_dir_by_name(get_ipython_dir(), profile)<EOL><DEDENT>except ProfileDirError:<EOL><INDENT>raise IOError(\"<STR_LIT>\" % profile)<EOL><DEDENT>return pd.location<EOL>", "docstring": "Find the path to the folder associated with a given profile.\n\n    I.e. find $IPYTHONDIR/profile_whatever.", "id": "f21499:m11"}
{"signature": "def get_xdg_dir():", "body": "env = os.environ<EOL>if os.name == '<STR_LIT>' and sys.platform != '<STR_LIT>':<EOL><INDENT>xdg = env.get(\"<STR_LIT>\", None) or os.path.join(get_home_dir(), '<STR_LIT>')<EOL>if xdg and _writable_dir(xdg):<EOL><INDENT>return py3compat.cast_unicode(xdg, fs_encoding)<EOL><DEDENT><DEDENT>return None<EOL>", "docstring": "Return the XDG_CONFIG_HOME, if it is defined and exists, else None.\n\n    This is only for non-OS X posix (Linux,Unix,etc.) systems.", "id": "f21499:m7"}
{"signature": "def get_long_path_name(path):", "body": "return _get_long_path_name(path)<EOL>", "docstring": "Expand a path into its long form.\n\n    On Windows this expands any ~ in the paths. On other platforms, it is\n    a null operation.", "id": "f21499:m2"}
{"signature": "def get_ipython_package_dir():", "body": "ipdir = os.path.dirname(IPython.__file__)<EOL>return py3compat.cast_unicode(ipdir, fs_encoding)<EOL>", "docstring": "Get the base directory where IPython itself is installed.", "id": "f21499:m9"}
{"signature": "def filehash(path):", "body": "with open(path, \"<STR_LIT>\") as f:<EOL><INDENT>return md5(py3compat.str_to_bytes(f.read())).hexdigest()<EOL><DEDENT>", "docstring": "Make an MD5 hash of a file, ignoring any differences in line\n    ending characters.", "id": "f21499:m15"}
{"signature": "def get_ipython_dir():", "body": "env = os.environ<EOL>pjoin = os.path.join<EOL>ipdir_def = '<STR_LIT>'<EOL>xdg_def = '<STR_LIT>'<EOL>home_dir = get_home_dir()<EOL>xdg_dir = get_xdg_dir()<EOL>if '<STR_LIT>' in env:<EOL><INDENT>warnings.warn('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>ipdir = env.get('<STR_LIT>', env.get('<STR_LIT>', None))<EOL>if ipdir is None:<EOL><INDENT>home_ipdir = pjoin(home_dir, ipdir_def)<EOL>if xdg_dir:<EOL><INDENT>xdg_ipdir = pjoin(xdg_dir, xdg_def)<EOL>if _writable_dir(xdg_ipdir) or not _writable_dir(home_ipdir):<EOL><INDENT>ipdir = xdg_ipdir<EOL><DEDENT><DEDENT>if ipdir is None:<EOL><INDENT>ipdir = home_ipdir<EOL><DEDENT><DEDENT>ipdir = os.path.normpath(os.path.expanduser(ipdir))<EOL>if os.path.exists(ipdir) and not _writable_dir(ipdir):<EOL><INDENT>warnings.warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"%ipdir)<EOL>ipdir = tempfile.mkdtemp()<EOL><DEDENT>elif not os.path.exists(ipdir):<EOL><INDENT>parent = ipdir.rsplit(os.path.sep, <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>if not _writable_dir(parent):<EOL><INDENT>warnings.warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"%parent)<EOL>ipdir = tempfile.mkdtemp()<EOL><DEDENT><DEDENT>return py3compat.cast_unicode(ipdir, fs_encoding)<EOL>", "docstring": "Get the IPython directory for this platform and user.\n\n    This uses the logic in `get_home_dir` to find the home directory\n    and then adds .ipython to the end of the path.", "id": "f21499:m8"}
{"signature": "def __init__(self,func):", "body": "self.getter = func<EOL>self.name = func.func_name<EOL>", "docstring": "Create a OneTimeProperty instance.\n\n         Parameters\n         ----------\n           func : method\n\n             The method that will be called the first time to compute a value.\n             Afterwards, the method's name will be a standard attribute holding\n             the value of this computation.", "id": "f21500:c1:m0"}
{"signature": "def auto_attr(func):", "body": "return OneTimeProperty(func)<EOL>", "docstring": "Decorator to create OneTimeProperty attributes.\n\n    Parameters\n    ----------\n      func : method\n        The method that will be called the first time to compute a value.\n        Afterwards, the method's name will be a standard attribute holding the\n        value of this computation.\n\n    Examples\n    --------\n    >>> class MagicProp(object):\n    ...     @auto_attr\n    ...     def a(self):\n    ...         return 99\n    ...\n    >>> x = MagicProp()\n    >>> 'a' in x.__dict__\n    False\n    >>> x.a\n    99\n    >>> 'a' in x.__dict__\n    True", "id": "f21500:m0"}
{"signature": "def fatal(msg,exit_val=<NUM_LIT:1>):", "body": "warn(msg,exit_val=exit_val,level=<NUM_LIT:4>)<EOL>", "docstring": "Equivalent to warn(msg,exit_val=exit_val,level=4).", "id": "f21501:m3"}
{"signature": "def setup():", "body": "<EOL>os.makedirs(IP_TEST_DIR)<EOL>os.makedirs(os.path.join(XDG_TEST_DIR, '<STR_LIT>'))<EOL>", "docstring": "Setup testenvironment for the module:\n\n            - Adds dummy home dir tree", "id": "f21506:m0"}
{"signature": "def toggle_set_term_title(val):", "body": "global ignore_termtitle<EOL>ignore_termtitle = not(val)<EOL>", "docstring": "Control whether set_term_title is active or not.\n\n    set_term_title() allows writing to the console titlebar.  In embedded\n    widgets this can cause problems, so this call can be used to toggle it on\n    or off as needed.\n\n    The default state of the module is for the function to be disabled.\n\n    Parameters\n    ----------\n      val : bool\n        If True, set_term_title() actually writes to the terminal (using the\n        appropriate platform-specific module).  If False, it is a no-op.", "id": "f21519:m2"}
{"signature": "def hdict(self, hashroot):", "body": "hfiles = self.keys(hashroot + \"<STR_LIT>\")<EOL>hfiles.sort()<EOL>last = len(hfiles) and hfiles[-<NUM_LIT:1>] or '<STR_LIT>'<EOL>if last.endswith('<STR_LIT>'):<EOL><INDENT>hfiles = [last] + hfiles[:-<NUM_LIT:1>]<EOL><DEDENT>all = {}<EOL>for f in hfiles:<EOL><INDENT>try:<EOL><INDENT>all.update(self[f])<EOL><DEDENT>except KeyError:<EOL><INDENT>print(\"<STR_LIT>\",f,\"<STR_LIT>\")<EOL>del self[f]<EOL><DEDENT>self.uncache(f)<EOL><DEDENT>return all<EOL>", "docstring": "Get all data contained in hashed category 'hashroot' as dict", "id": "f21521:c0:m5"}
{"signature": "def __init__(self,root):", "body": "self.root = Path(root).expanduser().abspath()<EOL>if not self.root.isdir():<EOL><INDENT>self.root.makedirs()<EOL><DEDENT>self.cache = {}<EOL>", "docstring": "Return a db object that will manage the specied directory", "id": "f21521:c0:m0"}
{"signature": "def waitget(self,key, maxwaittime = <NUM_LIT> ):", "body": "wtimes = [<NUM_LIT>] * <NUM_LIT:3> + [<NUM_LIT:0.5>] * <NUM_LIT:2> + [<NUM_LIT:1>]<EOL>tries = <NUM_LIT:0><EOL>waited = <NUM_LIT:0><EOL>while <NUM_LIT:1>:<EOL><INDENT>try:<EOL><INDENT>val = self[key]<EOL>return val<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>if waited > maxwaittime:<EOL><INDENT>raise KeyError(key)<EOL><DEDENT>time.sleep(wtimes[tries])<EOL>waited+=wtimes[tries]<EOL>if tries < len(wtimes) -<NUM_LIT:1>:<EOL><INDENT>tries+=<NUM_LIT:1><EOL><DEDENT><DEDENT>", "docstring": "Wait (poll) for a key to get a value\n\n        Will wait for `maxwaittime` seconds before raising a KeyError.\n        The call exits normally if the `key` field in db gets a value\n        within the timeout period.\n\n        Use this for synchronizing different processes or for ensuring\n        that an unfortunately timed \"db['key'] = newvalue\" operation\n        in another process (which causes all 'get' operation to cause a\n        KeyError for the duration of pickling) won't screw up your program\n        logic.", "id": "f21521:c0:m13"}
{"signature": "def hcompress(self, hashroot):", "body": "hfiles = self.keys(hashroot + \"<STR_LIT>\")<EOL>all = {}<EOL>for f in hfiles:<EOL><INDENT>all.update(self[f])<EOL>self.uncache(f)<EOL><DEDENT>self[hashroot + '<STR_LIT>'] = all<EOL>for f in hfiles:<EOL><INDENT>p = self.root / f<EOL>if p.basename() == '<STR_LIT>':<EOL><INDENT>continue<EOL><DEDENT>p.remove()<EOL><DEDENT>", "docstring": "Compress category 'hashroot', so hset is fast again\n\n        hget will fail if fast_only is True for compressed items (that were\n        hset before hcompress).", "id": "f21521:c0:m6"}
{"signature": "def uncache(self,*items):", "body": "if not items:<EOL><INDENT>self.cache = {}<EOL><DEDENT>for it in items:<EOL><INDENT>self.cache.pop(it,None)<EOL><DEDENT>", "docstring": "Removes all, or specified items from cache\n\n        Use this after reading a large amount of large objects\n        to free up memory, when you won't be needing the objects\n        for a while.", "id": "f21521:c0:m12"}
{"signature": "def hset(self, hashroot, key, value):", "body": "hroot = self.root / hashroot<EOL>if not hroot.isdir():<EOL><INDENT>hroot.makedirs()<EOL><DEDENT>hfile = hroot / gethashfile(key)<EOL>d = self.get(hfile, {})<EOL>d.update( {key : value})<EOL>self[hfile] = d<EOL>", "docstring": "hashed set", "id": "f21521:c0:m3"}
{"signature": "def __delitem__(self,key):", "body": "fil = self.root / key<EOL>self.cache.pop(fil,None)<EOL>try:<EOL><INDENT>fil.remove()<EOL><DEDENT>except OSError:<EOL><INDENT>pass<EOL><DEDENT>", "docstring": "del db[\"key\"]", "id": "f21521:c0:m7"}
{"signature": "@classmethod<EOL><INDENT>def class_traits(cls, **metadata):<DEDENT>", "body": "traits = dict([memb for memb in getmembers(cls) ifisinstance(memb[<NUM_LIT:1>], TraitType)])<EOL>if len(metadata) == <NUM_LIT:0>:<EOL><INDENT>return traits<EOL><DEDENT>for meta_name, meta_eval in list(metadata.items()):<EOL><INDENT>if type(meta_eval) is not FunctionType:<EOL><INDENT>metadata[meta_name] = _SimpleTest(meta_eval)<EOL><DEDENT><DEDENT>result = {}<EOL>for name, trait in list(traits.items()):<EOL><INDENT>for meta_name, meta_eval in list(metadata.items()):<EOL><INDENT>if not meta_eval(trait.get_metadata(meta_name)):<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>result[name] = trait<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Get a list of all the traits of this class.\n\n        This method is just like the :meth:`traits` method, but is unbound.\n\n        The TraitTypes returned don't know anything about the values\n        that the various HasTrait's instances are holding.\n\n        This follows the same algorithm as traits does and does not allow\n        for any simple way of specifying merely that a metadata name\n        exists, but has any value.  This is because get_metadata returns\n        None if a metadata key doesn't exist.", "id": "f21522:c6:m7"}
{"signature": "def trait_metadata(self, traitname, key):", "body": "try:<EOL><INDENT>trait = getattr(self.__class__, traitname)<EOL><DEDENT>except AttributeError:<EOL><INDENT>raise TraitError(\"<STR_LIT>\" %<EOL>(self.__class__.__name__, traitname))<EOL><DEDENT>else:<EOL><INDENT>return trait.get_metadata(key)<EOL><DEDENT>", "docstring": "Get metadata values for trait by key.", "id": "f21522:c6:m10"}
{"signature": "@classmethod<EOL><INDENT>def class_trait_names(cls, **metadata):<DEDENT>", "body": "return list(cls.class_traits(**metadata).keys())<EOL>", "docstring": "Get a list of all the names of this classes traits.\n\n        This method is just like the :meth:`trait_names` method, but is unbound.", "id": "f21522:c6:m6"}
{"signature": "def __init__ (self, default_value=None, klass=None, allow_none=True, **metadata ):", "body": "if default_value is None:<EOL><INDENT>if klass is None:<EOL><INDENT>klass = object<EOL><DEDENT><DEDENT>elif klass is None:<EOL><INDENT>klass = default_value<EOL><DEDENT>if not (inspect.isclass(klass) or isinstance(klass, str)):<EOL><INDENT>raise TraitError(\"<STR_LIT>\")<EOL><DEDENT>self.klass       = klass<EOL>self._allow_none = allow_none<EOL>super(Type, self).__init__(default_value, **metadata)<EOL>", "docstring": "Construct a Type trait\n\n        A Type trait specifies that its values must be subclasses of\n        a particular class.\n\n        If only ``default_value`` is given, it is used for the ``klass`` as\n        well.\n\n        Parameters\n        ----------\n        default_value : class, str or None\n            The default value must be a subclass of klass.  If an str,\n            the str must be a fully specified class name, like 'foo.bar.Bah'.\n            The string is resolved into real class, when the parent\n            :class:`HasTraits` class is instantiated.\n        klass : class, str, None\n            Values of this trait must be a subclass of klass.  The klass\n            may be specified in a string like: 'foo.bar.MyClass'.\n            The string is resolved into real class, when the parent\n            :class:`HasTraits` class is instantiated.\n        allow_none : boolean\n            Indicates whether None is allowed as an assignable value. Even if\n            ``False``, the default value may be ``None``.", "id": "f21522:c8:m0"}
{"signature": "def repr_type(obj):", "body": "the_type = type(obj)<EOL>if (not py3compat.PY3) and the_type is InstanceType:<EOL><INDENT>the_type = obj.__class__<EOL><DEDENT>msg = '<STR_LIT>' % (obj, the_type)<EOL>return msg<EOL>", "docstring": "Return a string representation of a value and its type for readable\n    error messages.", "id": "f21522:m2"}
{"signature": "def __get__(self, obj, cls=None):", "body": "if obj is None:<EOL><INDENT>return self<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>value = obj._trait_values[self.name]<EOL><DEDENT>except KeyError:<EOL><INDENT>if self.name in obj._trait_dyn_inits:<EOL><INDENT>value = obj._trait_dyn_inits[self.name](obj)<EOL>value = self._validate(obj, value)<EOL>obj._trait_values[self.name] = value<EOL>return value<EOL><DEDENT>else:<EOL><INDENT>raise TraitError('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>raise TraitError('<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>return value<EOL><DEDENT><DEDENT>", "docstring": "Get the value of the trait by self.name for the instance.\n\n        Default values are instantiated when :meth:`HasTraits.__new__`\n        is called.  Thus by the time this method gets called either the\n        default value or a user defined value (they called :meth:`__set__`)\n        is in the :class:`HasTraits` instance.", "id": "f21522:c4:m5"}
{"signature": "def __init__(self, trait=None, default_value=None, minlen=<NUM_LIT:0>, maxlen=sys.maxsize,<EOL>allow_none=True, **metadata):", "body": "self._minlen = minlen<EOL>self._maxlen = maxlen<EOL>super(List, self).__init__(trait=trait, default_value=default_value,<EOL>allow_none=allow_none, **metadata)<EOL>", "docstring": "Create a List trait type from a list, set, or tuple.\n\n        The default value is created by doing ``List(default_value)``,\n        which creates a copy of the ``default_value``.\n\n        ``trait`` can be specified, which restricts the type of elements\n        in the container to that TraitType.\n\n        If only one arg is given and it is not a Trait, it is taken as\n        ``default_value``:\n\n        ``c = List([1,2,3])``\n\n        Parameters\n        ----------\n\n        trait : TraitType [ optional ]\n            the type for restricting the contents of the Container.  If unspecified,\n            types are not checked.\n\n        default_value : SequenceType [ optional ]\n            The default value for the Trait.  Must be list/tuple/set, and\n            will be cast to the container type.\n\n        minlen : Int [ default 0 ]\n            The minimum length of the input list\n\n        maxlen : Int [ default sys.maxint ]\n            The maximum length of the input list\n\n        allow_none : Bool [ default True ]\n            Whether to allow the value to be None\n\n        **metadata : any\n            further keys for extensions to the Trait (e.g. config)", "id": "f21522:c30:m0"}
{"signature": "def __init__(self, *traits, **metadata):", "body": "default_value = metadata.pop('<STR_LIT>', None)<EOL>allow_none = metadata.pop('<STR_LIT>', True)<EOL>istrait = lambda t: isinstance(t, type) and issubclass(t, TraitType)<EOL>if len(traits) == <NUM_LIT:1> and default_value is None and not istrait(traits[<NUM_LIT:0>]):<EOL><INDENT>default_value = traits[<NUM_LIT:0>]<EOL>traits = ()<EOL><DEDENT>if default_value is None:<EOL><INDENT>args = ()<EOL><DEDENT>elif isinstance(default_value, self._valid_defaults):<EOL><INDENT>args = (default_value,)<EOL><DEDENT>else:<EOL><INDENT>raise TypeError('<STR_LIT>' %(self.__class__.__name__, default_value))<EOL><DEDENT>self._traits = []<EOL>for trait in traits:<EOL><INDENT>t = trait()<EOL>t.name = '<STR_LIT>'<EOL>self._traits.append(t)<EOL><DEDENT>if self._traits and default_value is None:<EOL><INDENT>args = None<EOL><DEDENT>super(Container,self).__init__(klass=self.klass, args=args,<EOL>allow_none=allow_none, **metadata)<EOL>", "docstring": "Tuple(*traits, default_value=None, allow_none=True, **medatata)\n\n        Create a tuple from a list, set, or tuple.\n\n        Create a fixed-type tuple with Traits:\n\n        ``t = Tuple(Int, Str, CStr)``\n\n        would be length 3, with Int,Str,CStr for each element.\n\n        If only one arg is given and it is not a Trait, it is taken as\n        default_value:\n\n        ``t = Tuple((1,2,3))``\n\n        Otherwise, ``default_value`` *must* be specified by keyword.\n\n        Parameters\n        ----------\n\n        *traits : TraitTypes [ optional ]\n            the tsype for restricting the contents of the Tuple.  If unspecified,\n            types are not checked. If specified, then each positional argument\n            corresponds to an element of the tuple.  Tuples defined with traits\n            are of fixed length.\n\n        default_value : SequenceType [ optional ]\n            The default value for the Tuple.  Must be list/tuple/set, and\n            will be cast to a tuple. If `traits` are specified, the\n            `default_value` must conform to the shape and type they specify.\n\n        allow_none : Bool [ default True ]\n            Whether to allow the value to be None\n\n        **metadata : any\n            further keys for extensions to the Trait (e.g. config)", "id": "f21522:c32:m0"}
{"signature": "def instance_init(self, obj):", "body": "self.set_default_value(obj)<EOL>", "docstring": "This is called by :meth:`HasTraits.__new__` to finish init'ing.\n\n        Some stages of initialization must be delayed until the parent\n        :class:`HasTraits` instance has been created.  This method is\n        called in :meth:`HasTraits.__new__` after the instance has been\n        created.\n\n        This method trigger the creation and validation of default values\n        and also things like the resolution of str given class names in\n        :class:`Type` and :class`Instance`.\n\n        Parameters\n        ----------\n        obj : :class:`HasTraits` instance\n            The parent :class:`HasTraits` instance that has just been\n            created.", "id": "f21522:c4:m3"}
{"signature": "def belong(candidates,checklist):", "body": "return [x in checklist for x in candidates]<EOL>", "docstring": "Check whether a list of items appear in a given list of options.\n\n    Returns a list of 1 and 0, one for each candidate given.", "id": "f21524:m2"}
{"signature": "def _run_stdio(self):", "body": "<EOL>if self.mergeout:<EOL><INDENT>return self.run(stdout_func = self._stdout_raw,<EOL>stdin_func = self._stdin_raw_block)<EOL><DEDENT>else:<EOL><INDENT>return self.run(stdout_func = self._stdout_raw,<EOL>stdin_func = self._stdin_raw_block,<EOL>stderr_func = self._stderr_raw)<EOL><DEDENT>", "docstring": "Runs the process using the system standard I/O.\n\n        IMPORTANT: stdin needs to be asynchronous, so the Python\n                   sys.stdin object is not used. Instead,\n                   msvcrt.kbhit/getwch are used asynchronously.", "id": "f21525:c4:m9"}
{"signature": "def run(self, stdout_func = None, stdin_func = None, stderr_func = None):", "body": "if stdout_func == None and stdin_func == None and stderr_func == None:<EOL><INDENT>return self._run_stdio()<EOL><DEDENT>if stderr_func != None and self.mergeout:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>stdin_thread = None<EOL>threads = []<EOL>if stdin_func:<EOL><INDENT>stdin_thread = threading.Thread(target=self._stdin_thread,<EOL>args=(self.hstdin, self.piProcInfo.hProcess,<EOL>stdin_func, stdout_func))<EOL><DEDENT>threads.append(threading.Thread(target=self._stdout_thread,<EOL>args=(self.hstdout, stdout_func)))<EOL>if not self.mergeout:<EOL><INDENT>if stderr_func == None:<EOL><INDENT>stderr_func = stdout_func<EOL><DEDENT>threads.append(threading.Thread(target=self._stdout_thread,<EOL>args=(self.hstderr, stderr_func)))<EOL><DEDENT>if ResumeThread(self.piProcInfo.hThread) == <NUM_LIT>:<EOL><INDENT>raise ctypes.WinError()<EOL><DEDENT>if stdin_thread is not None:<EOL><INDENT>stdin_thread.start()<EOL><DEDENT>for thread in threads:<EOL><INDENT>thread.start()<EOL><DEDENT>if WaitForSingleObject(self.piProcInfo.hProcess, INFINITE) ==WAIT_FAILED:<EOL><INDENT>raise ctypes.WinError()<EOL><DEDENT>for thread in threads:<EOL><INDENT>thread.join()<EOL><DEDENT>if stdin_thread is not None:<EOL><INDENT>stdin_thread.join()<EOL><DEDENT>", "docstring": "Runs the process, using the provided functions for I/O.\n\n        The function stdin_func should return strings whenever a\n        character or characters become available.\n        The functions stdout_func and stderr_func are called whenever\n        something is printed to stdout or stderr, respectively.\n        These functions are called from different threads (but not\n        concurrently, because of the GIL).", "id": "f21525:c4:m4"}
{"signature": "def system(cmd):", "body": "with AvoidUNCPath() as path:<EOL><INDENT>if path is not None:<EOL><INDENT>cmd = '<STR_LIT>' % (path, cmd)<EOL><DEDENT>with Win32ShellCommandController(cmd) as scc:<EOL><INDENT>scc.run()<EOL><DEDENT><DEDENT>", "docstring": "Win32 version of os.system() that works with network shares.\n\n    Note that this implementation returns None, as meant for use in IPython.\n\n    Parameters\n    ----------\n    cmd : str\n      A command to be executed in the system shell.\n\n    Returns\n    -------\n    None : we explicitly do NOT return the subprocess status code, as this\n    utility is meant to be used extensively in IPython, where any return value\n    would trigger :func:`sys.displayhook` calls.", "id": "f21525:m0"}
{"signature": "def uniq_stable(elems):", "body": "unique = []<EOL>unique_dict = {}<EOL>for nn in elems:<EOL><INDENT>if nn not in unique_dict:<EOL><INDENT>unique.append(nn)<EOL>unique_dict[nn] = None<EOL><DEDENT><DEDENT>return unique<EOL>", "docstring": "uniq_stable(elems) -> list\n\n    Return from an iterable, a list of all the unique elements in the input,\n    but maintaining the order in which they first appear.\n\n    A naive solution to this problem which just makes a dictionary with the\n    elements as keys fails to respect the stability condition, since\n    dictionaries are unsorted by nature.\n\n    Note: All elements in the input must be valid dictionary keys for this\n    routine to work, as it internally uses a dictionary for efficiency\n    reasons.", "id": "f21526:m0"}
{"signature": "def sort_compare(lst1, lst2, inplace=<NUM_LIT:1>):", "body": "if not inplace:<EOL><INDENT>lst1 = lst1[:]<EOL>lst2 = lst2[:]<EOL><DEDENT>lst1.sort(); lst2.sort()<EOL>return lst1 == lst2<EOL>", "docstring": "Sort and compare two lists.\n\n    By default it does it in place, thus modifying the lists. Use inplace = 0\n    to avoid that (at the cost of temporary copy creation).", "id": "f21526:m1"}
{"signature": "def list2dict(lst):", "body": "dic = {}<EOL>for k,v in lst: dic[k] = v<EOL>return dic<EOL>", "docstring": "Takes a list of (key,value) pairs and turns it into a dict.", "id": "f21526:m2"}
{"signature": "def _find_cmd(cmd):", "body": "try:<EOL><INDENT>from win32api import SearchPath<EOL><DEDENT>except ImportError:<EOL><INDENT>raise ImportError('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>PATH = os.environ['<STR_LIT>']<EOL>extensions = ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>path = None<EOL>for ext in extensions:<EOL><INDENT>try:<EOL><INDENT>path = SearchPath(PATH, cmd + ext)[<NUM_LIT:0>]<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if path is None:<EOL><INDENT>raise OSError(\"<STR_LIT>\" % cmd)<EOL><DEDENT>else:<EOL><INDENT>return path<EOL><DEDENT><DEDENT>", "docstring": "Find the full path to a .bat or .exe using the win32api module.", "id": "f21528:m0"}
{"signature": "def __init__(self, *args, **kw):", "body": "object.__setattr__(self, '<STR_LIT>', True)<EOL>dict.__init__(self, *args, **kw)<EOL>", "docstring": "Initialize with a dictionary, another Struct, or data.\n\n        Parameters\n        ----------\n        args : dict, Struct\n            Initialize with one dict or Struct\n        kw : dict\n            Initialize with key, value pairs.\n\n        Examples\n        --------\n\n        >>> s = Struct(a=10,b=30)\n        >>> s.a\n        10\n        >>> s.b\n        30\n        >>> s2 = Struct(s,c=30)\n        >>> sorted(s2.keys())\n        ['a', 'b', 'c']", "id": "f21531:c0:m0"}
{"signature": "def format_screen(strng):", "body": "<EOL>par_re = re.compile(r'<STR_LIT>',re.MULTILINE)<EOL>strng = par_re.sub('<STR_LIT>',strng)<EOL>return strng<EOL>", "docstring": "Format a string for screen printing.\n\n    This removes some latex-type format codes.", "id": "f21532:m14"}
{"signature": "def fields(self, *fields):", "body": "if len(fields) == <NUM_LIT:0>:<EOL><INDENT>return [el.split() for el in self]<EOL><DEDENT>res = SList()<EOL>for el in [f.split() for f in self]:<EOL><INDENT>lineparts = []<EOL>for fd in fields:<EOL><INDENT>try:<EOL><INDENT>lineparts.append(el[fd])<EOL><DEDENT>except IndexError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if lineparts:<EOL><INDENT>res.append(\"<STR_LIT:U+0020>\".join(lineparts))<EOL><DEDENT><DEDENT>return res<EOL>", "docstring": "Collect whitespace-separated fields from string list\n\n        Allows quick awk-like usage of string lists.\n\n        Example data (in var a, created by 'a = !ls -l')::\n            -rwxrwxrwx  1 ville None      18 Dec 14  2006 ChangeLog\n            drwxrwxrwx+ 6 ville None       0 Oct 24 18:05 IPython\n\n        a.fields(0) is ['-rwxrwxrwx', 'drwxrwxrwx+']\n        a.fields(1,0) is ['1 -rwxrwxrwx', '6 drwxrwxrwx+']\n        (note the joining by space).\n        a.fields(-1) is ['ChangeLog', 'IPython']\n\n        IndexErrors are ignored.\n\n        Without args, fields() just split()'s the strings.", "id": "f21532:c1:m5"}
{"signature": "def dedent(text):", "body": "if text.startswith('<STR_LIT:\\n>'):<EOL><INDENT>return textwrap.dedent(text)<EOL><DEDENT>splits = text.split('<STR_LIT:\\n>',<NUM_LIT:1>)<EOL>if len(splits) == <NUM_LIT:1>:<EOL><INDENT>return textwrap.dedent(text)<EOL><DEDENT>first, rest = splits<EOL>rest = textwrap.dedent(rest)<EOL>return '<STR_LIT:\\n>'.join([first, rest])<EOL>", "docstring": "Equivalent of textwrap.dedent that ignores unindented first line.\n\n    This means it will still dedent strings like:\n    '''foo\n    is a bar\n    '''\n\n    For use in wrap_paragraphs.", "id": "f21532:m15"}
{"signature": "def strip_email_quotes(text):", "body": "lines = text.splitlines()<EOL>matches = set()<EOL>for line in lines:<EOL><INDENT>prefix = re.match(r'<STR_LIT>', line)<EOL>if prefix:<EOL><INDENT>matches.add(prefix.group(<NUM_LIT:1>))<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>prefix = long_substr(list(matches))<EOL>if prefix:<EOL><INDENT>strip = len(prefix)<EOL>text = '<STR_LIT:\\n>'.join([ ln[strip:] for ln in lines])<EOL><DEDENT><DEDENT>return text<EOL>", "docstring": "Strip leading email quotation characters ('>').\n\n    Removes any combination of leading '>' interspersed with whitespace that\n    appears *identically* in all lines of the input text.\n\n    Parameters\n    ----------\n    text : str\n\n    Examples\n    --------\n\n    Simple uses::\n\n        In [2]: strip_email_quotes('> > text')\n        Out[2]: 'text'\n\n        In [3]: strip_email_quotes('> > text\\\\n> > more')\n        Out[3]: 'text\\\\nmore'\n\n    Note how only the common prefix that appears in all lines is stripped::\n\n        In [4]: strip_email_quotes('> > text\\\\n> > more\\\\n> more...')\n        Out[4]: '> text\\\\n> more\\\\nmore...'\n\n    So if any line has no quote marks ('>') , then none are stripped from any\n    of them ::\n\n        In [5]: strip_email_quotes('> > text\\\\n> > more\\\\nlast different')\n        Out[5]: '> > text\\\\n> > more\\\\nlast different'", "id": "f21532:m18"}
{"signature": "def esc_quotes(strng):", "body": "return strng.replace('<STR_LIT:\">','<STR_LIT>').replace(\"<STR_LIT:'>\",\"<STR_LIT>\")<EOL>", "docstring": "Return the input string with single and double quotes escaped out", "id": "f21532:m1"}
{"signature": "def pkg_info(pkg_path):", "body": "src, hsh = pkg_commit_hash(pkg_path)<EOL>return dict(<EOL>ipython_version=release.version,<EOL>ipython_path=pkg_path,<EOL>commit_source=src,<EOL>commit_hash=hsh,<EOL>sys_version=sys.version,<EOL>sys_executable=sys.executable,<EOL>sys_platform=sys.platform,<EOL>platform=platform.platform(),<EOL>os_name=os.name,<EOL>default_encoding=encoding.DEFAULT_ENCODING,<EOL>)<EOL>", "docstring": "Return dict describing the context of this package\n\n    Parameters\n    ----------\n    pkg_path : str\n       path containing __init__.py for package\n\n    Returns\n    -------\n    context : dict\n       with named parameters of interest", "id": "f21535:m1"}
{"signature": "def _num_cpus_unix():", "body": "return os.sysconf(\"<STR_LIT>\")<EOL>", "docstring": "Return the number of active CPUs on a Unix system.", "id": "f21535:m3"}
{"signature": "def extract_module_locals(depth=<NUM_LIT:0>):", "body": "f = sys._getframe(depth + <NUM_LIT:1>)<EOL>global_ns = f.f_globals<EOL>module = sys.modules[global_ns['<STR_LIT>']]<EOL>return (module, f.f_locals)<EOL>", "docstring": "Returns (module, locals) of the funciton `depth` frames away from the caller", "id": "f21536:m3"}
{"signature": "def timing(func,*args,**kw):", "body": "return timings_out(<NUM_LIT:1>,func,*args,**kw)[<NUM_LIT:0>]<EOL>", "docstring": "timing(func,*args,**kw) -> t_total\n\n    Execute a function once, return the elapsed total CPU time in\n    seconds. This is just the first value in timings_out().", "id": "f21539:m2"}
{"signature": "def getoutputerror(cmd):", "body": "out_err = process_handler(cmd, lambda p: p.communicate())<EOL>if out_err is None:<EOL><INDENT>return '<STR_LIT>', '<STR_LIT>'<EOL><DEDENT>out, err = out_err<EOL>return py3compat.bytes_to_str(out), py3compat.bytes_to_str(err)<EOL>", "docstring": "Return (standard output, standard error) of executing cmd in a shell.\n\n    Accepts the same arguments as os.system().\n\n    Parameters\n    ----------\n    cmd : str\n      A command to be executed in the system shell.\n\n    Returns\n    -------\n    stdout : str\n    stderr : str", "id": "f21540:m3"}
{"signature": "def add_re(self, regex, obj, priority= <NUM_LIT:0> ):", "body": "chain = self.regexs.get(regex, CommandChainDispatcher())<EOL>chain.add(obj,priority)<EOL>self.regexs[regex] = chain<EOL>", "docstring": "Adds a target regexp for dispatching", "id": "f21542:c0:m2"}
{"signature": "def add_s(self, s, obj, priority= <NUM_LIT:0> ):", "body": "chain = self.strs.get(s, CommandChainDispatcher())<EOL>chain.add(obj,priority)<EOL>self.strs[s] = chain<EOL>", "docstring": "Adds a target 'string' for dispatching", "id": "f21542:c0:m1"}
{"signature": "def is_type(obj, typestr_or_type):", "body": "if typestr_or_type == \"<STR_LIT:all>\":<EOL><INDENT>return True<EOL><DEDENT>if type(typestr_or_type) == types.TypeType:<EOL><INDENT>test_type = typestr_or_type<EOL><DEDENT>else:<EOL><INDENT>test_type = typestr2type.get(typestr_or_type, False)<EOL><DEDENT>if test_type:<EOL><INDENT>return isinstance(obj, test_type)<EOL><DEDENT>return False<EOL>", "docstring": "is_type(obj, typestr_or_type) verifies if obj is of a certain type. It\n    can take strings or actual python types for the second argument, i.e.\n    'tuple'<->TupleType. 'all' matches all types.\n\n    TODO: Should be extended for choosing more than one type.", "id": "f21547:m1"}
{"signature": "def encode_images(format_dict):", "body": "encoded = format_dict.copy()<EOL>pngdata = format_dict.get('<STR_LIT>')<EOL>if isinstance(pngdata, bytes) and pngdata[:<NUM_LIT:8>] == PNG:<EOL><INDENT>encoded['<STR_LIT>'] = encodestring(pngdata).decode('<STR_LIT:ascii>')<EOL><DEDENT>jpegdata = format_dict.get('<STR_LIT>')<EOL>if isinstance(jpegdata, bytes) and jpegdata[:<NUM_LIT:2>] == JPEG:<EOL><INDENT>encoded['<STR_LIT>'] = encodestring(jpegdata).decode('<STR_LIT:ascii>')<EOL><DEDENT>return encoded<EOL>", "docstring": "b64-encodes images in a displaypub format dict\n\n    Perhaps this should be handled in json_clean itself?\n\n    Parameters\n    ----------\n\n    format_dict : dict\n        A dictionary of display data keyed by mime-type\n\n    Returns\n    -------\n\n    format_dict : dict\n        A copy of the same dictionary,\n        but binary image data ('image/png' or 'image/jpeg')\n        is base64-encoded.", "id": "f21550:m4"}
{"signature": "def date_default(obj):", "body": "if isinstance(obj, datetime):<EOL><INDENT>return obj.strftime(ISO8601)<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\"%obj)<EOL><DEDENT>", "docstring": "default function for packing datetime objects in JSON.", "id": "f21550:m3"}
{"signature": "def extract_dates(obj):", "body": "if isinstance(obj, dict):<EOL><INDENT>obj = dict(obj) <EOL>for k,v in obj.iteritems():<EOL><INDENT>obj[k] = extract_dates(v)<EOL><DEDENT><DEDENT>elif isinstance(obj, (list, tuple)):<EOL><INDENT>obj = [ extract_dates(o) for o in obj ]<EOL><DEDENT>elif isinstance(obj, basestring):<EOL><INDENT>if ISO8601_PAT.match(obj):<EOL><INDENT>obj = datetime.strptime(obj, ISO8601)<EOL><DEDENT><DEDENT>return obj<EOL>", "docstring": "extract ISO8601 dates from unpacked JSON", "id": "f21550:m1"}
{"signature": "def format2(self, raw, out = None, scheme = '<STR_LIT>'):", "body": "string_output = <NUM_LIT:0><EOL>if out == '<STR_LIT:str>' or self.out == '<STR_LIT:str>' orisinstance(self.out,io.StringIO):<EOL><INDENT>out_old = self.out<EOL>self.out = io.StringIO()<EOL>string_output = <NUM_LIT:1><EOL><DEDENT>elif out is not None:<EOL><INDENT>self.out = out<EOL><DEDENT>if scheme == '<STR_LIT>':<EOL><INDENT>error = False<EOL>self.out.write(raw)<EOL>if string_output:<EOL><INDENT>return raw,error<EOL><DEDENT>else:<EOL><INDENT>return None,error<EOL><DEDENT><DEDENT>colors = self.color_table[scheme].colors<EOL>self.colors = colors <EOL>self.raw = raw.expandtabs().rstrip()<EOL>self.lines = [<NUM_LIT:0>, <NUM_LIT:0>]<EOL>pos = <NUM_LIT:0><EOL>raw_find = self.raw.find<EOL>lines_append = self.lines.append<EOL>while <NUM_LIT:1>:<EOL><INDENT>pos = raw_find('<STR_LIT:\\n>', pos) + <NUM_LIT:1><EOL>if not pos: break<EOL>lines_append(pos)<EOL><DEDENT>lines_append(len(self.raw))<EOL>self.pos = <NUM_LIT:0><EOL>text = io.StringIO(self.raw)<EOL>error = False<EOL>try:<EOL><INDENT>for atoken in generate_tokens(text.readline):<EOL><INDENT>self(*atoken)<EOL><DEDENT><DEDENT>except tokenize.TokenError as ex:<EOL><INDENT>msg = ex.args[<NUM_LIT:0>]<EOL>line = ex.args[<NUM_LIT:1>][<NUM_LIT:0>]<EOL>self.out.write(\"<STR_LIT>\" %<EOL>(colors[token.ERRORTOKEN],<EOL>msg, self.raw[self.lines[line]:],<EOL>colors.normal)<EOL>)<EOL>error = True<EOL><DEDENT>self.out.write(colors.normal+'<STR_LIT:\\n>')<EOL>if string_output:<EOL><INDENT>output = self.out.getvalue()<EOL>self.out = out_old<EOL>return (output, error)<EOL><DEDENT>return (None, error)<EOL>", "docstring": "Parse and send the colored source.\n\n        If out and scheme are not specified, the defaults (given to\n        constructor) are used.\n\n        out should be a file-type object. Optionally, out can be given as the\n        string 'str' and the parser will automatically return the output in a\n        string.", "id": "f21552:c0:m2"}
{"signature": "def flush(self):", "body": "self.file.flush()<EOL>self.ostream.flush()<EOL>", "docstring": "Flush both channels.", "id": "f21557:c2:m3"}
{"signature": "def __init__(self, file_or_name, mode=\"<STR_LIT:w>\", channel='<STR_LIT>'):", "body": "if channel not in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>raise ValueError('<STR_LIT>' % channel)<EOL><DEDENT>if hasattr(file_or_name, '<STR_LIT>') and hasattr(file_or_name, '<STR_LIT>'):<EOL><INDENT>self.file = file_or_name<EOL><DEDENT>else:<EOL><INDENT>self.file = open(file_or_name, mode)<EOL><DEDENT>self.channel = channel<EOL>self.ostream = getattr(sys, channel)<EOL>setattr(sys, channel, self)<EOL>self._closed = False<EOL>", "docstring": "Construct a new Tee object.\n\n        Parameters\n        ----------\n        file_or_name : filename or open filehandle (writable)\n          File that will be duplicated\n\n        mode : optional, valid mode for open().\n          If a filename was give, open with this mode.\n\n        channel : str, one of ['stdout', 'stderr']", "id": "f21557:c2:m0"}
{"signature": "def raw_print(*args, **kw):", "body": "print(*args, sep=kw.get('<STR_LIT>', '<STR_LIT:U+0020>'), end=kw.get('<STR_LIT:end>', '<STR_LIT:\\n>'),<EOL>file=sys.__stdout__)<EOL>sys.__stdout__.flush()<EOL>", "docstring": "Raw print to sys.__stdout__, otherwise identical interface to print().", "id": "f21557:m6"}
{"signature": "def close(self):", "body": "self.flush()<EOL>setattr(sys, self.channel, self.ostream)<EOL>self.file.close()<EOL>self._closed = True<EOL>", "docstring": "Close the file and restore the channel.", "id": "f21557:c2:m1"}
{"signature": "def file_read(filename):", "body": "fobj = open(filename,'<STR_LIT:r>');<EOL>source = fobj.read();<EOL>fobj.close()<EOL>return source<EOL>", "docstring": "Read a file and close it.  Returns the file source.", "id": "f21557:m0"}
{"signature": "def new_text_cell(text=None):", "body": "cell = NotebookNode()<EOL>if text is not None:<EOL><INDENT>cell.text = unicode(text)<EOL><DEDENT>cell.cell_type = u'<STR_LIT:text>'<EOL>return cell<EOL>", "docstring": "Create a new text cell.", "id": "f21563:m2"}
{"signature": "def new_notebook(name=None, metadata=None, worksheets=None):", "body": "nb = NotebookNode()<EOL>nb.nbformat = nbformat<EOL>nb.nbformat_minor = nbformat_minor<EOL>if worksheets is None:<EOL><INDENT>nb.worksheets = []<EOL><DEDENT>else:<EOL><INDENT>nb.worksheets = list(worksheets)<EOL><DEDENT>if metadata is None:<EOL><INDENT>nb.metadata = new_metadata()<EOL><DEDENT>else:<EOL><INDENT>nb.metadata = NotebookNode(metadata)<EOL><DEDENT>if name is not None:<EOL><INDENT>nb.metadata.name = unicode(name)<EOL><DEDENT>return nb<EOL>", "docstring": "Create a notebook by name, id and a list of worksheets.", "id": "f21573:m6"}
{"signature": "def new_author(name=None, email=None, affiliation=None, url=None):", "body": "author = NotebookNode()<EOL>if name is not None:<EOL><INDENT>author.name = unicode(name)<EOL><DEDENT>if email is not None:<EOL><INDENT>author.email = unicode(email)<EOL><DEDENT>if affiliation is not None:<EOL><INDENT>author.affiliation = unicode(affiliation)<EOL><DEDENT>if url is not None:<EOL><INDENT>author.url = unicode(url)<EOL><DEDENT>return author<EOL>", "docstring": "Create a new author.", "id": "f21573:m8"}
{"signature": "def new_heading_cell(source=None, rendered=None, level=<NUM_LIT:1>, metadata=None):", "body": "cell = NotebookNode()<EOL>cell.cell_type = u'<STR_LIT>'<EOL>if source is not None:<EOL><INDENT>cell.source = unicode(source)<EOL><DEDENT>if rendered is not None:<EOL><INDENT>cell.rendered = unicode(rendered)<EOL><DEDENT>cell.level = int(level)<EOL>cell.metadata = NotebookNode(metadata or {})<EOL>return cell<EOL>", "docstring": "Create a new section cell with a given integer level.", "id": "f21573:m4"}
{"signature": "def new_code_cell(input=None, prompt_number=None, outputs=None,<EOL>language=u'<STR_LIT>', collapsed=False, metadata=None):", "body": "cell = NotebookNode()<EOL>cell.cell_type = u'<STR_LIT:code>'<EOL>if language is not None:<EOL><INDENT>cell.language = unicode(language)<EOL><DEDENT>if input is not None:<EOL><INDENT>cell.input = unicode(input)<EOL><DEDENT>if prompt_number is not None:<EOL><INDENT>cell.prompt_number = int(prompt_number)<EOL><DEDENT>if outputs is None:<EOL><INDENT>cell.outputs = []<EOL><DEDENT>else:<EOL><INDENT>cell.outputs = outputs<EOL><DEDENT>if collapsed is not None:<EOL><INDENT>cell.collapsed = bool(collapsed)<EOL><DEDENT>cell.metadata = NotebookNode(metadata or {})<EOL>return cell<EOL>", "docstring": "Create a new code cell with input and output", "id": "f21573:m2"}
{"signature": "def _join_lines(lines):", "body": "if lines and lines[<NUM_LIT:0>].endswith(('<STR_LIT:\\n>', '<STR_LIT:\\r>')):<EOL><INDENT>return u'<STR_LIT>'.join(lines)<EOL><DEDENT>else:<EOL><INDENT>return u'<STR_LIT:\\n>'.join(lines)<EOL><DEDENT>", "docstring": "join lines that have been written by splitlines()\n\n    Has logic to protect against `splitlines()`, which\n    should have been `splitlines(True)`", "id": "f21576:m1"}
{"signature": "def base64_encode(nb):", "body": "for ws in nb.worksheets:<EOL><INDENT>for cell in ws.cells:<EOL><INDENT>if cell.cell_type == '<STR_LIT:code>':<EOL><INDENT>for output in cell.outputs:<EOL><INDENT>if '<STR_LIT>' in output:<EOL><INDENT>output.png = encodestring(output.png).decode('<STR_LIT:ascii>')<EOL><DEDENT>if '<STR_LIT>' in output:<EOL><INDENT>output.jpeg = encodestring(output.jpeg).decode('<STR_LIT:ascii>')<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>return nb<EOL>", "docstring": "Base64 encode all bytes objects in the notebook.\n\n    These will be b64-encoded unicode strings\n\n    Note: This is never used", "id": "f21576:m5"}
{"signature": "def parse_json(s, **kwargs):", "body": "d = json.loads(s, **kwargs)<EOL>nbf = d.get('<STR_LIT>', <NUM_LIT:1>)<EOL>nbm = d.get('<STR_LIT>', <NUM_LIT:0>)<EOL>return nbf, nbm, d<EOL>", "docstring": "Parse a string into a (nbformat, dict) tuple.", "id": "f21579:m0"}
{"signature": "def new_author(name=None, email=None, affiliation=None, url=None):", "body": "author = NotebookNode()<EOL>if name is not None:<EOL><INDENT>author.name = unicode(name)<EOL><DEDENT>if email is not None:<EOL><INDENT>author.email = unicode(email)<EOL><DEDENT>if affiliation is not None:<EOL><INDENT>author.affiliation = unicode(affiliation)<EOL><DEDENT>if url is not None:<EOL><INDENT>author.url = unicode(url)<EOL><DEDENT>return author<EOL>", "docstring": "Create a new author.", "id": "f21584:m7"}
{"signature": "def new_notebook(metadata=None, worksheets=None):", "body": "nb = NotebookNode()<EOL>nb.nbformat = <NUM_LIT:2><EOL>if worksheets is None:<EOL><INDENT>nb.worksheets = []<EOL><DEDENT>else:<EOL><INDENT>nb.worksheets = list(worksheets)<EOL><DEDENT>if metadata is None:<EOL><INDENT>nb.metadata = new_metadata()<EOL><DEDENT>else:<EOL><INDENT>nb.metadata = NotebookNode(metadata)<EOL><DEDENT>return nb<EOL>", "docstring": "Create a notebook by name, id and a list of worksheets.", "id": "f21584:m5"}
{"signature": "def new_metadata(name=None, authors=None, license=None, created=None,<EOL>modified=None, gistid=None):", "body": "metadata = NotebookNode()<EOL>if name is not None:<EOL><INDENT>metadata.name = unicode(name)<EOL><DEDENT>if authors is not None:<EOL><INDENT>metadata.authors = list(authors)<EOL><DEDENT>if created is not None:<EOL><INDENT>metadata.created = unicode(created)<EOL><DEDENT>if modified is not None:<EOL><INDENT>metadata.modified = unicode(modified)<EOL><DEDENT>if license is not None:<EOL><INDENT>metadata.license = unicode(license)<EOL><DEDENT>if gistid is not None:<EOL><INDENT>metadata.gistid = unicode(gistid)<EOL><DEDENT>return metadata<EOL>", "docstring": "Create a new metadata node.", "id": "f21584:m6"}
{"signature": "def restore_bytes(nb):", "body": "for ws in nb.worksheets:<EOL><INDENT>for cell in ws.cells:<EOL><INDENT>if cell.cell_type == '<STR_LIT:code>':<EOL><INDENT>for output in cell.outputs:<EOL><INDENT>if '<STR_LIT>' in output:<EOL><INDENT>output.png = str_to_bytes(output.png, '<STR_LIT:ascii>')<EOL><DEDENT>if '<STR_LIT>' in output:<EOL><INDENT>output.jpeg = str_to_bytes(output.jpeg, '<STR_LIT:ascii>')<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>return nb<EOL>", "docstring": "Restore bytes of image data from unicode-only formats.\n\n    Base64 encoding is handled elsewhere.  Bytes objects in the notebook are\n    always b64-encoded. We DO NOT encode/decode around file formats.", "id": "f21588:m0"}
{"signature": "def base64_encode(nb):", "body": "for ws in nb.worksheets:<EOL><INDENT>for cell in ws.cells:<EOL><INDENT>if cell.cell_type == '<STR_LIT:code>':<EOL><INDENT>for output in cell.outputs:<EOL><INDENT>if '<STR_LIT>' in output:<EOL><INDENT>output.png = encodestring(output.png).decode('<STR_LIT:ascii>')<EOL><DEDENT>if '<STR_LIT>' in output:<EOL><INDENT>output.jpeg = encodestring(output.jpeg).decode('<STR_LIT:ascii>')<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>return nb<EOL>", "docstring": "Base64 encode all bytes objects in the notebook.\n\n    These will be b64-encoded unicode strings\n\n    Note: This is never used", "id": "f21588:m4"}
{"signature": "def parse_filename(fname):", "body": "if fname.endswith(u'<STR_LIT>'):<EOL><INDENT>format = u'<STR_LIT>'<EOL><DEDENT>elif fname.endswith(u'<STR_LIT>'):<EOL><INDENT>format = u'<STR_LIT>'<EOL><DEDENT>elif fname.endswith(u'<STR_LIT>'):<EOL><INDENT>format = u'<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>fname = fname + u'<STR_LIT>'<EOL>format = u'<STR_LIT>'<EOL><DEDENT>name = fname.split('<STR_LIT:.>')[<NUM_LIT:0>]<EOL>return fname, name, format<EOL>", "docstring": "Parse a notebook filename.\n\n    This function takes a notebook filename and returns the notebook\n    format (json/py) and the notebook name. This logic can be\n    summarized as follows:\n\n    * notebook.ipynb -> (notebook.ipynb, notebook, json)\n    * notebook.json  -> (notebook.json, notebook, json)\n    * notebook.py    -> (notebook.py, notebook, py)\n    * notebook       -> (notebook.ipynb, notebook, json)\n\n    Parameters\n    ----------\n    fname : unicode\n        The notebook filename. The filename can use a specific filename\n        extention (.ipynb, .json, .py) or none, in which case .ipynb will\n        be assumed.\n\n    Returns\n    -------\n    (fname, name, format) : (unicode, unicode, unicode)\n        The filename, notebook name and format.", "id": "f21589:m0"}
{"signature": "def show_all(self):", "body": "fname = self.title<EOL>title = self.title<EOL>nblocks = self.nblocks<EOL>silent = self._silent<EOL>marquee = self.marquee<EOL>for index,block in enumerate(self.src_blocks_colored):<EOL><INDENT>if silent[index]:<EOL><INDENT>print(marquee('<STR_LIT>' %<EOL>(title,index,nblocks-index-<NUM_LIT:1>)), file=io.stdout)<EOL><DEDENT>else:<EOL><INDENT>print(marquee('<STR_LIT>' %<EOL>(title,index,nblocks-index-<NUM_LIT:1>)), file=io.stdout)<EOL><DEDENT>print(block, end='<STR_LIT:U+0020>', file=io.stdout)<EOL><DEDENT>sys.stdout.flush()<EOL>", "docstring": "Show entire demo on screen, block by block", "id": "f21592:c1:m12"}
{"signature": "def marquee(self,txt='<STR_LIT>',width=<NUM_LIT>,mark='<STR_LIT:*>'):", "body": "return '<STR_LIT>'<EOL>", "docstring": "Blank marquee that returns '' no matter what the input.", "id": "f21592:c5:m0"}
{"signature": "def post_cmd(self):", "body": "pass<EOL>", "docstring": "Method called after executing each block.", "id": "f21592:c1:m17"}
{"signature": "def __call__(self,index=None):", "body": "index = self._get_index(index)<EOL>if index is None:<EOL><INDENT>return<EOL><DEDENT>try:<EOL><INDENT>marquee = self.marquee<EOL>next_block = self.src_blocks[index]<EOL>self.block_index += <NUM_LIT:1><EOL>if self._silent[index]:<EOL><INDENT>print(marquee('<STR_LIT>' %<EOL>(index,self.nblocks-index-<NUM_LIT:1>)), file=io.stdout)<EOL><DEDENT>else:<EOL><INDENT>self.pre_cmd()<EOL>self.show(index)<EOL>if self.auto_all or self._auto[index]:<EOL><INDENT>print(marquee('<STR_LIT>'), file=io.stdout)<EOL><DEDENT>else:<EOL><INDENT>print(marquee('<STR_LIT>'), end='<STR_LIT:U+0020>', file=io.stdout)<EOL>ans = input().strip()<EOL>if ans:<EOL><INDENT>print(marquee('<STR_LIT>'), file=io.stdout)<EOL>return<EOL><DEDENT><DEDENT><DEDENT>try:<EOL><INDENT>save_argv = sys.argv<EOL>sys.argv = self.sys_argv<EOL>self.run_cell(next_block)<EOL>self.post_cmd()<EOL><DEDENT>finally:<EOL><INDENT>sys.argv = save_argv<EOL><DEDENT><DEDENT>except:<EOL><INDENT>self.ip_showtb(filename=self.fname)<EOL><DEDENT>else:<EOL><INDENT>self.ip_ns.update(self.user_ns)<EOL><DEDENT>if self.block_index == self.nblocks:<EOL><INDENT>mq1 = self.marquee('<STR_LIT>')<EOL>if mq1:<EOL><INDENT>print(file=io.stdout)<EOL>print(mq1, file=io.stdout)<EOL>print(self.marquee('<STR_LIT>'), file=io.stdout)<EOL><DEDENT>self.finished = True<EOL><DEDENT>", "docstring": "run a block of the demo.\n\n        If index is given, it should be an integer >=1 and <= nblocks.  This\n        means that the calling convention is one off from typical Python\n        lists.  The reason for the inconsistency is that the demo always\n        prints 'Block n/N, and N is the total, so it would be very odd to use\n        zero-indexing here.", "id": "f21592:c1:m14"}
{"signature": "def back(self,num=<NUM_LIT:1>):", "body": "self.seek(self.block_index-num)<EOL>", "docstring": "Move the seek pointer back num blocks (default is 1).", "id": "f21592:c1:m7"}
{"signature": "def marquee(self,txt='<STR_LIT>',width=<NUM_LIT>,mark='<STR_LIT:*>'):", "body": "return marquee(txt,width,mark)<EOL>", "docstring": "Return the input string centered in a 'marquee'.", "id": "f21592:c1:m15"}
{"signature": "def load_next(mod, altmod, name, buf):", "body": "if len(name) == <NUM_LIT:0>:<EOL><INDENT>return mod, None, buf<EOL><DEDENT>dot = name.find('<STR_LIT:.>')<EOL>if dot == <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if dot < <NUM_LIT:0>:<EOL><INDENT>subname = name<EOL>next = None<EOL><DEDENT>else:<EOL><INDENT>subname = name[:dot]<EOL>next = name[dot+<NUM_LIT:1>:]<EOL><DEDENT>if buf != '<STR_LIT>':<EOL><INDENT>buf += '<STR_LIT:.>'<EOL><DEDENT>buf += subname<EOL>result = import_submodule(mod, subname, buf)<EOL>if result is None and mod != altmod:<EOL><INDENT>result = import_submodule(altmod, subname, subname)<EOL>if result is not None:<EOL><INDENT>buf = subname<EOL><DEDENT><DEDENT>if result is None:<EOL><INDENT>raise ImportError(\"<STR_LIT>\" % name)<EOL><DEDENT>return result, next, buf<EOL>", "docstring": "mod, name, buf = load_next(mod, altmod, name, buf)\n\naltmod is either None or same as mod", "id": "f21593:m2"}
{"signature": "def reload(module, exclude=['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:__main__>']):", "body": "global found_now<EOL>for i in exclude:<EOL><INDENT>found_now[i] = <NUM_LIT:1><EOL><DEDENT>try:<EOL><INDENT>with replace_import_hook(deep_import_hook):<EOL><INDENT>ret = deep_reload_hook(module)<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>found_now = {}<EOL><DEDENT>return ret<EOL>", "docstring": "Recursively reload all modules used in the given module.  Optionally\n    takes a list of modules to exclude from reloading.  The default exclude\n    list contains sys, __main__, and __builtin__, to prevent, e.g., resetting\n    display, exception, and io hooks.", "id": "f21593:m8"}
{"signature": "def import_submodule(mod, subname, fullname):", "body": "<EOL>global found_now<EOL>if fullname in found_now and fullname in sys.modules:<EOL><INDENT>m = sys.modules[fullname]<EOL><DEDENT>else:<EOL><INDENT>print('<STR_LIT>', fullname)<EOL>found_now[fullname] = <NUM_LIT:1><EOL>oldm = sys.modules.get(fullname, None)<EOL>if mod is None:<EOL><INDENT>path = None<EOL><DEDENT>elif hasattr(mod, '<STR_LIT>'):<EOL><INDENT>path = mod.__path__<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>try:<EOL><INDENT>with replace_import_hook(original_import):<EOL><INDENT>fp, filename, stuff = imp.find_module(subname, path)<EOL><DEDENT><DEDENT>except ImportError:<EOL><INDENT>return None<EOL><DEDENT>try:<EOL><INDENT>m = imp.load_module(fullname, fp, filename, stuff)<EOL><DEDENT>except:<EOL><INDENT>if oldm:<EOL><INDENT>sys.modules[fullname] = oldm<EOL><DEDENT>raise<EOL><DEDENT>finally:<EOL><INDENT>if fp: fp.close()<EOL><DEDENT>add_submodule(mod, m, fullname, subname)<EOL><DEDENT>return m<EOL>", "docstring": "m = import_submodule(mod, subname, fullname)", "id": "f21593:m3"}
{"signature": "def pylab_not_importable():", "body": "try:<EOL><INDENT>import pylab<EOL>return False<EOL><DEDENT>except RuntimeError:<EOL><INDENT>return True<EOL><DEDENT>", "docstring": "Test if importing pylab fails with RuntimeError (true when having no display)", "id": "f21600:m0"}
{"signature": "def __init__(self, expression, glob=None, loc=None):", "body": "<EOL>self.code = compile(expression,'<STR_LIT>','<STR_LIT>')<EOL>glob = {} if glob is None else glob<EOL>loc = {} if loc is None else loc<EOL>self.expression = self.strform = expression<EOL>self.glob = glob<EOL>self.loc = loc<EOL>self._init()<EOL>", "docstring": "Create a new job from a string which can be fed to eval().\n\n        global/locals dicts can be provided, which will be passed to the eval\n        call.", "id": "f21604:c2:m0"}
{"signature": "def _group_flush(self,group,name):", "body": "njobs = len(group)<EOL>if njobs:<EOL><INDENT>plural = {<NUM_LIT:1>:'<STR_LIT>'}.setdefault(njobs,'<STR_LIT:s>')<EOL>print('<STR_LIT>' % (njobs,name,plural))<EOL>group[:] = []<EOL>return True<EOL><DEDENT>", "docstring": "Flush a given job group\n\n        Return True if the group had any elements.", "id": "f21604:c0:m9"}
{"signature": "def new(self, func_or_exp, *args, **kwargs):", "body": "if callable(func_or_exp):<EOL><INDENT>kw  = kwargs.get('<STR_LIT>',{})<EOL>job = BackgroundJobFunc(func_or_exp,*args,**kw)<EOL><DEDENT>elif isinstance(func_or_exp, str):<EOL><INDENT>if not args:<EOL><INDENT>frame = sys._getframe(<NUM_LIT:1>)<EOL>glob, loc = frame.f_globals, frame.f_locals<EOL><DEDENT>elif len(args)==<NUM_LIT:1>:<EOL><INDENT>glob = loc = args[<NUM_LIT:0>]<EOL><DEDENT>elif len(args)==<NUM_LIT:2>:<EOL><INDENT>glob,loc = args<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(<EOL>'<STR_LIT>')<EOL><DEDENT>job = BackgroundJobExpr(func_or_exp, glob, loc)<EOL><DEDENT>else:<EOL><INDENT>raise TypeError('<STR_LIT>')<EOL><DEDENT>if kwargs.get('<STR_LIT>', False):<EOL><INDENT>job.daemon = True<EOL><DEDENT>job.num = len(self.all)+<NUM_LIT:1> if self.all else <NUM_LIT:0><EOL>self.running.append(job)<EOL>self.all[job.num] = job<EOL>print('<STR_LIT>' % job.num)<EOL>job.start()<EOL>return job<EOL>", "docstring": "Add a new background job and start it in a separate thread.\n\n        There are two types of jobs which can be created:\n\n        1. Jobs based on expressions which can be passed to an eval() call.\n        The expression must be given as a string.  For example:\n\n          job_manager.new('myfunc(x,y,z=1)'[,glob[,loc]])\n\n        The given expression is passed to eval(), along with the optional\n        global/local dicts provided.  If no dicts are given, they are\n        extracted automatically from the caller's frame.\n\n        A Python statement is NOT a valid eval() expression.  Basically, you\n        can only use as an eval() argument something which can go on the right\n        of an '=' sign and be assigned to a variable.\n\n        For example,\"print 'hello'\" is not valid, but '2+3' is.\n\n        2. Jobs given a function object, optionally passing additional\n        positional arguments:\n\n          job_manager.new(myfunc, x, y)\n\n        The function is called with the given arguments.\n\n        If you need to pass keyword arguments to your function, you must\n        supply them as a dict named kw:\n\n          job_manager.new(myfunc, x, y, kw=dict(z=1))\n\n        The reason for this assymmetry is that the new() method needs to\n        maintain access to its own keywords, and this prevents name collisions\n        between arguments to new() and arguments to your own functions.\n\n        In both cases, the result is stored in the job.result field of the\n        background job object.\n\n        You can set `daemon` attribute of the thread by giving the keyword\n        argument `daemon`.\n\n        Notes and caveats:\n\n        1. All threads running share the same standard output.  Thus, if your\n        background jobs generate output, it will come out on top of whatever\n        you are currently writing.  For this reason, background jobs are best\n        used with silent functions which simply return their output.\n\n        2. Threads also all work within the same global namespace, and this\n        system does not lock interactive variables.  So if you send job to the\n        background which operates on a mutable object for a long time, and\n        start modifying that same mutable object interactively (or in another\n        backgrounded job), all sorts of bizarre behaviour will occur.\n\n        3. If a background job is spending a lot of time inside a C extension\n        module which does not release the Python Global Interpreter Lock\n        (GIL), this will block the IPython prompt.  This is simply because the\n        Python interpreter can only switch between threads at Python\n        bytecodes.  While the execution is inside C code, the interpreter must\n        simply wait unless the extension module releases the GIL.\n\n        4. There is no way, due to limitations in the Python threads library,\n        to kill a thread once it has started.", "id": "f21604:c0:m4"}
{"signature": "def result(self,num):", "body": "try:<EOL><INDENT>return self.all[num].result<EOL><DEDENT>except KeyError:<EOL><INDENT>error('<STR_LIT>' % num)<EOL><DEDENT>", "docstring": "result(N) -> return the result of job N.", "id": "f21604:c0:m14"}
{"signature": "def latex_to_html(s, alt='<STR_LIT:image>'):", "body": "base64_data = latex_to_png(s, encode=True)<EOL>if base64_data:<EOL><INDENT>return _data_uri_template_png  % (base64_data, alt)<EOL><DEDENT>", "docstring": "Render LaTeX to HTML with embedded PNG data using data URIs.\n\n    Parameters\n    ----------\n    s : str\n        The raw string containing valid inline LateX.\n    alt : str\n        The alt text to use for the HTML.", "id": "f21605:m3"}
{"signature": "def math_to_image(s, filename_or_obj, prop=None, dpi=None, format=None):", "body": "from matplotlib import figure<EOL>from matplotlib.backends import backend_agg<EOL>from matplotlib.font_manager import FontProperties<EOL>from matplotlib.mathtext import MathTextParser<EOL>if prop is None:<EOL><INDENT>prop = FontProperties()<EOL><DEDENT>parser = MathTextParser('<STR_LIT:path>')<EOL>width, height, depth, _, _ = parser.parse(s, dpi=<NUM_LIT>, prop=prop)<EOL>fig = figure.Figure(figsize=(width / <NUM_LIT>, height / <NUM_LIT>))<EOL>fig.text(<NUM_LIT:0>, depth/height, s, fontproperties=prop)<EOL>backend_agg.FigureCanvasAgg(fig)<EOL>fig.savefig(filename_or_obj, dpi=dpi, format=format)<EOL>return depth<EOL>", "docstring": "Given a math expression, renders it in a closely-clipped bounding\nbox to an image file.\n\n*s*\n   A math expression.  The math portion should be enclosed in\n   dollar signs.\n\n*filename_or_obj*\n   A filepath or writable file-like object to write the image data\n   to.\n\n*prop*\n   If provided, a FontProperties() object describing the size and\n   style of the text.\n\n*dpi*\n   Override the output dpi, otherwise use the default associated\n   with the output format.\n\n*format*\n   The output format, eg. 'svg', 'pdf', 'ps' or 'png'.  If not\n   provided, will be deduced from the filename.", "id": "f21605:m4"}
{"signature": "def inputhook_pyglet():", "body": "<EOL>try:<EOL><INDENT>t = clock()<EOL>while not stdin_ready():<EOL><INDENT>pyglet.clock.tick()<EOL>for window in pyglet.app.windows:<EOL><INDENT>window.switch_to()<EOL>window.dispatch_events()<EOL>window.dispatch_event('<STR_LIT>')<EOL>flip(window)<EOL><DEDENT>used_time = clock() - t<EOL>if used_time > <NUM_LIT:5>*<NUM_LIT>:<EOL><INDENT>time.sleep(<NUM_LIT>)<EOL><DEDENT>elif used_time > <NUM_LIT>:<EOL><INDENT>time.sleep(<NUM_LIT:1.0>)<EOL><DEDENT>elif used_time > <NUM_LIT:0.1>:<EOL><INDENT>time.sleep(<NUM_LIT>)<EOL><DEDENT>else:<EOL><INDENT>time.sleep(<NUM_LIT>)<EOL><DEDENT><DEDENT><DEDENT>except KeyboardInterrupt:<EOL><INDENT>pass<EOL><DEDENT>return <NUM_LIT:0><EOL>", "docstring": "Run the pyglet event loop by processing pending events only.\n\n    This keeps processing pending events until stdin is ready.  After\n    processing all pending events, a call to time.sleep is inserted.  This is\n    needed, otherwise, CPU usage is at 100%.  This sleep time should be tuned\n    though for best performance.", "id": "f21606:m0"}
{"signature": "def get_connection_file(app=None):", "body": "if app is None:<EOL><INDENT>from IPython.zmq.ipkernel import IPKernelApp<EOL>if not IPKernelApp.initialized():<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>app = IPKernelApp.instance()<EOL><DEDENT>return filefind(app.connection_file, ['<STR_LIT:.>', app.profile_dir.security_dir])<EOL>", "docstring": "Return the path to the connection file of an app\n\n    Parameters\n    ----------\n    app : KernelApp instance [optional]\n        If unspecified, the currently running app will be used", "id": "f21608:m0"}
{"signature": "def connect_qtconsole(connection_file=None, argv=None, profile=None):", "body": "argv = [] if argv is None else argv<EOL>if connection_file is None:<EOL><INDENT>cf = get_connection_file()<EOL><DEDENT>else:<EOL><INDENT>cf = find_connection_file(connection_file, profile=profile)<EOL><DEDENT>cmd = '<STR_LIT:;>'.join([<EOL>\"<STR_LIT>\",<EOL>\"<STR_LIT>\"<EOL>])<EOL>return Popen([sys.executable, '<STR_LIT:-c>', cmd, '<STR_LIT>', cf] + argv, stdout=PIPE, stderr=PIPE)<EOL>", "docstring": "Connect a qtconsole to the current kernel.\n\n    This is useful for connecting a second qtconsole to a kernel, or to a\n    local notebook.\n\n    Parameters\n    ----------\n    connection_file : str [optional]\n        The connection file to be used. Can be given by absolute path, or\n        IPython will search in the security directory of a given profile.\n        If run from IPython, \n\n        If unspecified, the connection file for the currently running\n        IPython Kernel will be used, which is only allowed from inside a kernel.\n    argv : list [optional]\n        Any extra args to be passed to the console.\n    profile : str [optional]\n        The name of the profile to use when searching for the connection file,\n        if different from the current IPython session or 'default'.\n\n\n    Returns\n    -------\n    subprocess.Popen instance running the qtconsole frontend", "id": "f21608:m3"}
{"signature": "def __init__(self,program = _ipython_cmd, args=None, out=sys.stdout, echo=True):", "body": "args0 = ['<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>']<EOL>if args is None: args = args0<EOL>else: args = args0 + args<EOL>prompts = [r'<STR_LIT>',r'<STR_LIT>']<EOL>InteractiveRunner.__init__(self,program,prompts,args,out,echo)<EOL>", "docstring": "New runner, optionally passing the ipython command to use.", "id": "f21610:c1:m0"}
{"signature": "def run_source(self,source,interact=False,get_output=False):", "body": "<EOL>if isinstance(source, str):<EOL><INDENT>source = source.splitlines(True)<EOL><DEDENT>if self.echo:<EOL><INDENT>linesep  = os.linesep<EOL>stdwrite = self.out.write<EOL>write    = lambda s: stdwrite(s.replace('<STR_LIT:\\r\\n>',linesep))<EOL><DEDENT>else:<EOL><INDENT>write = lambda s: None<EOL><DEDENT>c = self.child<EOL>prompts = c.compile_pattern_list(self.prompts)<EOL>prompt_idx = c.expect_list(prompts)<EOL>end_normal = True<EOL>if get_output:<EOL><INDENT>output = []<EOL>store_output = output.append<EOL><DEDENT>for cmd in source:<EOL><INDENT>if prompt_idx==<NUM_LIT:0> and(cmd.isspace() or cmd.lstrip().startswith('<STR_LIT:#>')):<EOL><INDENT>write(cmd)<EOL>continue<EOL><DEDENT>write(c.after)<EOL>c.send(cmd)<EOL>try:<EOL><INDENT>prompt_idx = c.expect_list(prompts)<EOL><DEDENT>except pexpect.EOF:<EOL><INDENT>write(c.before)<EOL>end_normal = False<EOL>break<EOL><DEDENT>write(c.before)<EOL>if get_output:<EOL><INDENT>store_output(c.before[len(cmd+'<STR_LIT:\\n>'):])<EOL><DEDENT><DEDENT>self.out.flush()<EOL>if end_normal:<EOL><INDENT>if interact:<EOL><INDENT>c.send('<STR_LIT:\\n>')<EOL>print('<STR_LIT>', end='<STR_LIT:U+0020>')<EOL>try:<EOL><INDENT>c.interact()<EOL><DEDENT>except OSError:<EOL><INDENT>write('<STR_LIT>')<EOL>self.out.flush()<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>if interact:<EOL><INDENT>e=\"<STR_LIT>\"<EOL>print(e, file=sys.stderr)<EOL><DEDENT><DEDENT>if c.isalive():<EOL><INDENT>c.send('<STR_LIT:\\n>')<EOL><DEDENT>if get_output:<EOL><INDENT>return '<STR_LIT>'.join(output)<EOL><DEDENT>", "docstring": "Run the given source code interactively.\n\n        Inputs:\n\n          - source: a string of code to be executed, or an open file object we\n          can iterate over.\n\n        Optional inputs:\n\n          - interact(False): if true, start to interact with the running\n          program at the end of the script.  Otherwise, just exit.\n\n          - get_output(False): if true, capture the output of the child process\n          (filtering the input commands out) and return it as a string.\n\n        Returns:\n          A string containing the process output, but only if requested.", "id": "f21610:c0:m3"}
{"signature": "def __init__(self,program=sys.executable, args=None, out=sys.stdout, echo=True):", "body": "prompts = [r'<STR_LIT>',r'<STR_LIT>']<EOL>InteractiveRunner.__init__(self,program,prompts,args,out,echo)<EOL>", "docstring": "New runner, optionally passing the python command to use.", "id": "f21610:c2:m0"}
{"signature": "def __call__(self,fname):", "body": "if fname.endswith('<STR_LIT>'):<EOL><INDENT>runnerClass = PythonRunner<EOL><DEDENT>elif fname.endswith('<STR_LIT>'):<EOL><INDENT>runnerClass = IPythonRunner<EOL><DEDENT>else:<EOL><INDENT>raise ValueError('<STR_LIT>' % fname)<EOL><DEDENT>if self.runner is None:<EOL><INDENT>return self._makeRunner(runnerClass)<EOL><DEDENT>else:<EOL><INDENT>if runnerClass==self.runnerClass:<EOL><INDENT>return self.runner<EOL><DEDENT>else:<EOL><INDENT>e='<STR_LIT>' %(self.runnerClass,fname)<EOL>raise ValueError(e)<EOL><DEDENT><DEDENT>", "docstring": "Return a runner for the given filename.", "id": "f21610:c4:m2"}
{"signature": "def close(self):", "body": "self.child.close()<EOL>", "docstring": "close child process", "id": "f21610:c0:m1"}
{"signature": "def __init__(self,program,prompts,args=None,out=sys.stdout,echo=True):", "body": "self.program = program<EOL>self.prompts = prompts<EOL>if args is None: args = []<EOL>self.args = args<EOL>self.out = out<EOL>self.echo = echo<EOL>self.delaybeforesend = <NUM_LIT:0><EOL>c = self.child = pexpect.spawn(self.program,self.args,timeout=None)<EOL>c.delaybeforesend = self.delaybeforesend<EOL>c.setwinsize(<NUM_LIT>,<NUM_LIT:200>)<EOL>", "docstring": "Construct a runner.\n\n        Inputs:\n\n          - program: command to execute the given program.\n\n          - prompts: a list of patterns to match as valid prompts, in the\n          format used by pexpect.  This basically means that it can be either\n          a string (to be compiled as a regular expression) or a list of such\n          (it must be a true list, as pexpect does type checks).\n\n          If more than one prompt is given, the first is treated as the main\n          program prompt and the others as 'continuation' prompts, like\n          python's.  This means that blank lines in the input source are\n          ommitted when the first prompt is matched, but are NOT ommitted when\n          the continuation one matches, since this is how python signals the\n          end of multiline input interactively.\n\n        Optional inputs:\n\n          - args(None): optional list of strings to pass as arguments to the\n          child program.\n\n          - out(sys.stdout): if given, an output stream to be used when writing\n          output.  The only requirement is that it must have a .write() method.\n\n        Public members not parameterized in the constructor:\n\n          - delaybeforesend(0): Newer versions of pexpect have a delay before\n          sending each new input.  For our purposes here, it's typically best\n          to just set this to zero, but if you encounter reliability problems\n          or want an interactive run to pause briefly at each prompt, just\n          increase this value (it is measured in seconds).  Note that this\n          variable is not honored at all by older versions of pexpect.", "id": "f21610:c0:m0"}
{"signature": "def osx_clipboard_get():", "body": "p = subprocess.Popen(['<STR_LIT>', '<STR_LIT>', '<STR_LIT:ascii>'],<EOL>stdout=subprocess.PIPE)<EOL>text, stderr = p.communicate()<EOL>text = text.replace('<STR_LIT:\\r>', '<STR_LIT:\\n>')<EOL>return text<EOL>", "docstring": "Get the clipboard's text on OS X.", "id": "f21614:m1"}
{"signature": "def get_app_wx(*args, **kwargs):", "body": "import wx<EOL>app = wx.GetApp()<EOL>if app is None:<EOL><INDENT>if not kwargs.has_key('<STR_LIT>'):<EOL><INDENT>kwargs['<STR_LIT>'] = False<EOL><DEDENT>app = wx.PySimpleApp(*args, **kwargs)<EOL><DEDENT>return app<EOL>", "docstring": "Create a new wx app or return an exiting one.", "id": "f21615:m0"}
{"signature": "def is_event_loop_running_qt4(app=None):", "body": "if app is None:<EOL><INDENT>app = get_app_qt4(['<STR_LIT>'])<EOL><DEDENT>if hasattr(app, '<STR_LIT>'):<EOL><INDENT>return app._in_event_loop<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Is the qt4 event loop running.", "id": "f21615:m4"}
{"signature": "def enable_qt4(self, app=None):", "body": "from IPython.lib.inputhookqt4 import create_inputhook_qt4<EOL>app, inputhook_qt4 = create_inputhook_qt4(self, app)<EOL>self.set_inputhook(inputhook_qt4)<EOL>self._current_gui = GUI_QT4<EOL>app._in_event_loop = True<EOL>self._apps[GUI_QT4] = app<EOL>return app<EOL>", "docstring": "Enable event loop integration with PyQt4.\n\n        Parameters\n        ----------\n        app : Qt Application, optional.\n            Running application to use.  If not given, we probe Qt for an\n            existing application object, and create a new one if none is found.\n\n        Notes\n        -----\n        This methods sets the PyOS_InputHook for PyQt4, which allows\n        the PyQt4 to integrate with terminal based applications like\n        IPython.\n\n        If ``app`` is not given we probe for an existing one, and return it if\n        found.  If no existing app is found, we create an :class:`QApplication`\n        as follows::\n\n            from PyQt4 import QtCore\n            app = QtGui.QApplication(sys.argv)", "id": "f21616:c0:m9"}
{"signature": "def disable_tk(self):", "body": "self.clear_inputhook()<EOL>", "docstring": "Disable event loop integration with Tkinter.\n\n        This merely sets PyOS_InputHook to NULL.", "id": "f21616:c0:m14"}
{"signature": "def _ignore_CTRL_C_posix():", "body": "signal.signal(signal.SIGINT, signal.SIG_IGN)<EOL>", "docstring": "Ignore CTRL+C (SIGINT).", "id": "f21616:m3"}
{"signature": "def enable_wx(self, app=None):", "body": "import wx<EOL>wx_version = V(wx.__version__).version<EOL>if wx_version < [<NUM_LIT:2>, <NUM_LIT:8>]:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % wx.__version__)<EOL><DEDENT>from IPython.lib.inputhookwx import inputhook_wx<EOL>self.set_inputhook(inputhook_wx)<EOL>self._current_gui = GUI_WX<EOL>import wx<EOL>if app is None:<EOL><INDENT>app = wx.GetApp()<EOL><DEDENT>if app is None:<EOL><INDENT>app = wx.App(redirect=False, clearSigInt=False)<EOL><DEDENT>app._in_event_loop = True<EOL>self._apps[GUI_WX] = app<EOL>return app<EOL>", "docstring": "Enable event loop integration with wxPython.\n\n        Parameters\n        ----------\n        app : WX Application, optional.\n            Running application to use.  If not given, we probe WX for an\n            existing application object, and create a new one if none is found.\n\n        Notes\n        -----\n        This methods sets the ``PyOS_InputHook`` for wxPython, which allows\n        the wxPython to integrate with terminal based applications like\n        IPython.\n\n        If ``app`` is not given we probe for an existing one, and return it if\n        found.  If no existing app is found, we create an :class:`wx.App` as\n        follows::\n\n            import wx\n            app = wx.App(redirect=False, clearSigInt=False)", "id": "f21616:c0:m7"}
{"signature": "def enable_pyglet(self, app=None):", "body": "import pyglet<EOL>from IPython.lib.inputhookpyglet import inputhook_pyglet<EOL>self.set_inputhook(inputhook_pyglet)<EOL>self._current_gui = GUI_PYGLET<EOL>return app<EOL>", "docstring": "Enable event loop integration with pyglet.\n\n        Parameters\n        ----------\n        app : ignored\n           Ignored, it's only a placeholder to keep the call signature of all\n           gui activation methods consistent, which simplifies the logic of\n           supporting magics.\n\n        Notes\n        -----\n        This methods sets the ``PyOS_InputHook`` for pyglet, which allows\n        pyglet to integrate with terminal based applications like\n        IPython.", "id": "f21616:c0:m17"}
{"signature": "def current_gui(self):", "body": "return self._current_gui<EOL>", "docstring": "Return a string indicating the currently active GUI or None.", "id": "f21616:c0:m21"}
{"signature": "def enable_tk(self, app=None):", "body": "self._current_gui = GUI_TK<EOL>if app is None:<EOL><INDENT>import Tkinter<EOL>app = Tkinter.Tk()<EOL>app.withdraw()<EOL>self._apps[GUI_TK] = app<EOL>return app<EOL><DEDENT>", "docstring": "Enable event loop integration with Tk.\n\n        Parameters\n        ----------\n        app : toplevel :class:`Tkinter.Tk` widget, optional.\n            Running toplevel widget to use.  If not given, we probe Tk for an\n            existing one, and create a new one if none is found.\n\n        Notes\n        -----\n        If you have already created a :class:`Tkinter.Tk` object, the only\n        thing done by this method is to register with the\n        :class:`InputHookManager`, since creating that object automatically\n        sets ``PyOS_InputHook``.", "id": "f21616:c0:m13"}
{"signature": "def enable_gtk(self, app=None):", "body": "import gtk<EOL>try:<EOL><INDENT>gtk.set_interactive(True)<EOL>self._current_gui = GUI_GTK<EOL><DEDENT>except AttributeError:<EOL><INDENT>from IPython.lib.inputhookgtk import inputhook_gtk<EOL>self.set_inputhook(inputhook_gtk)<EOL>self._current_gui = GUI_GTK<EOL><DEDENT>", "docstring": "Enable event loop integration with PyGTK.\n\n        Parameters\n        ----------\n        app : ignored\n           Ignored, it's only a placeholder to keep the call signature of all\n           gui activation methods consistent, which simplifies the logic of\n           supporting magics.\n\n        Notes\n        -----\n        This methods sets the PyOS_InputHook for PyGTK, which allows\n        the PyGTK to integrate with terminal based applications like\n        IPython.", "id": "f21616:c0:m11"}
{"signature": "def end_group(self, dedent=<NUM_LIT:0>, close='<STR_LIT>'):", "body": "self.indentation -= dedent<EOL>group = self.group_stack.pop()<EOL>if not group.breakables:<EOL><INDENT>self.group_queue.remove(group)<EOL><DEDENT>if close:<EOL><INDENT>self.text(close)<EOL><DEDENT>", "docstring": "End a group. See `begin_group` for more details.", "id": "f21617:c1:m5"}
{"signature": "def _dict_pprinter_factory(start, end, basetype=None):", "body": "def inner(obj, p, cycle):<EOL><INDENT>typ = type(obj)<EOL>if basetype is not None and typ is not basetype and typ.__repr__ != basetype.__repr__:<EOL><INDENT>return p.text(typ.__repr__(obj))<EOL><DEDENT>if cycle:<EOL><INDENT>return p.text('<STR_LIT>')<EOL><DEDENT>p.begin_group(<NUM_LIT:1>, start)<EOL>keys = list(obj.keys())<EOL>try:<EOL><INDENT>keys.sort()<EOL><DEDENT>except Exception as e:<EOL><INDENT>pass<EOL><DEDENT>for idx, key in enumerate(keys):<EOL><INDENT>if idx:<EOL><INDENT>p.text('<STR_LIT:U+002C>')<EOL>p.breakable()<EOL><DEDENT>p.pretty(key)<EOL>p.text('<STR_LIT>')<EOL>p.pretty(obj[key])<EOL><DEDENT>p.end_group(<NUM_LIT:1>, end)<EOL><DEDENT>return inner<EOL>", "docstring": "Factory that returns a pprint function used by the default pprint of\ndicts and dict proxies.", "id": "f21617:m5"}
{"signature": "def pretty(obj, verbose=False, max_width=<NUM_LIT>, newline='<STR_LIT:\\n>'):", "body": "stream = StringIO()<EOL>printer = RepresentationPrinter(stream, verbose, max_width, newline)<EOL>printer.pretty(obj)<EOL>printer.flush()<EOL>return stream.getvalue()<EOL>", "docstring": "Pretty print the object's representation.", "id": "f21617:m0"}
{"signature": "def pretty(self, obj):", "body": "obj_id = id(obj)<EOL>cycle = obj_id in self.stack<EOL>self.stack.append(obj_id)<EOL>self.begin_group()<EOL>try:<EOL><INDENT>obj_class = getattr(obj, '<STR_LIT>', None) or type(obj)<EOL>try:<EOL><INDENT>printer = self.singleton_pprinters[obj_id]<EOL><DEDENT>except (TypeError, KeyError):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>return printer(obj, self, cycle)<EOL><DEDENT>for cls in _get_mro(obj_class):<EOL><INDENT>if cls in self.type_pprinters:<EOL><INDENT>return self.type_pprinters[cls](obj, self, cycle)<EOL><DEDENT>else:<EOL><INDENT>printer = self._in_deferred_types(cls)<EOL>if printer is not None:<EOL><INDENT>return printer(obj, self, cycle)<EOL><DEDENT>else:<EOL><INDENT>if '<STR_LIT>' in obj_class.__dict__:<EOL><INDENT>meth = obj_class._repr_pretty_<EOL>if callable(meth):<EOL><INDENT>return meth(obj, self, cycle)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>return _default_pprint(obj, self, cycle)<EOL><DEDENT>finally:<EOL><INDENT>self.end_group()<EOL>self.stack.pop()<EOL><DEDENT>", "docstring": "Pretty print the given object.", "id": "f21617:c2:m1"}
{"signature": "def _get_mro(obj_class):", "body": "if not hasattr(obj_class, '<STR_LIT>'):<EOL><INDENT>try:<EOL><INDENT>obj_class = type(obj_class.__name__, (obj_class, object), {})<EOL><DEDENT>except TypeError:<EOL><INDENT>mro = [obj_class]<EOL><DEDENT>else:<EOL><INDENT>mro = obj_class.__mro__[<NUM_LIT:1>:-<NUM_LIT:1>]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>mro = obj_class.__mro__<EOL><DEDENT>return mro<EOL>", "docstring": "Get a reasonable method resolution order of a class and its superclasses\n    for both old-style and new-style classes.", "id": "f21617:m2"}
{"signature": "def _seq_pprinter_factory(start, end, basetype):", "body": "def inner(obj, p, cycle):<EOL><INDENT>typ = type(obj)<EOL>if basetype is not None and typ is not basetype and typ.__repr__ != basetype.__repr__:<EOL><INDENT>return p.text(typ.__repr__(obj))<EOL><DEDENT>if cycle:<EOL><INDENT>return p.text(start + '<STR_LIT>' + end)<EOL><DEDENT>step = len(start)<EOL>p.begin_group(step, start)<EOL>for idx, x in enumerate(obj):<EOL><INDENT>if idx:<EOL><INDENT>p.text('<STR_LIT:U+002C>')<EOL>p.breakable()<EOL><DEDENT>p.pretty(x)<EOL><DEDENT>if len(obj) == <NUM_LIT:1> and type(obj) is tuple:<EOL><INDENT>p.text('<STR_LIT:U+002C>')<EOL><DEDENT>p.end_group(step, end)<EOL><DEDENT>return inner<EOL>", "docstring": "Factory that returns a pprint function useful for sequences.  Used by\nthe default pprint for tuples, dicts, lists, sets and frozensets.", "id": "f21617:m4"}
{"signature": "def begin_group(self, indent=<NUM_LIT:0>, open='<STR_LIT>'):", "body": "if open:<EOL><INDENT>self.text(open)<EOL><DEDENT>group = Group(self.group_stack[-<NUM_LIT:1>].depth + <NUM_LIT:1>)<EOL>self.group_stack.append(group)<EOL>self.group_queue.enq(group)<EOL>self.indentation += indent<EOL>", "docstring": "Begin a group.  If you want support for python < 2.5 which doesn't has\nthe with statement this is the preferred way:\n\n    p.begin_group(1, '{')\n    ...\n    p.end_group(1, '}')\n\nThe python 2.5 expression would be this:\n\n    with p.group(1, '{', '}'):\n        ...\n\nThe first parameter specifies the indentation for the next line (usually\nthe width of the opening text), the second the opening text.  All\nparameters are optional.", "id": "f21617:c1:m4"}
{"signature": "def breakable(self, sep='<STR_LIT:U+0020>'):", "body": "width = len(sep)<EOL>group = self.group_stack[-<NUM_LIT:1>]<EOL>if group.want_break:<EOL><INDENT>self.flush()<EOL>self.output.write(self.newline)<EOL>self.output.write('<STR_LIT:U+0020>' * self.indentation)<EOL>self.output_width = self.indentation<EOL>self.buffer_width = <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>self.buffer.append(Breakable(sep, width, self))<EOL>self.buffer_width += width<EOL>self._break_outer_groups()<EOL><DEDENT>", "docstring": "Add a breakable separator to the output.  This does not mean that it\nwill automatically break here.  If no breaking on this position takes\nplace the `sep` is inserted which default to one space.", "id": "f21617:c1:m3"}
{"signature": "def for_type_by_name(type_module, type_name, func):", "body": "key = (type_module, type_name)<EOL>oldfunc = _deferred_type_pprinters.get(key, None)<EOL>if func is not None:<EOL><INDENT>_deferred_type_pprinters[key] = func<EOL><DEDENT>return oldfunc<EOL>", "docstring": "Add a pretty printer for a type specified by the module and name of a type\nrather than the type object itself.", "id": "f21617:m13"}
{"signature": "def _in_deferred_types(self, cls):", "body": "mod = getattr(cls, '<STR_LIT>', None)<EOL>name = getattr(cls, '<STR_LIT>', None)<EOL>key = (mod, name)<EOL>printer = None<EOL>if key in self.deferred_pprinters:<EOL><INDENT>printer = self.deferred_pprinters.pop(key)<EOL>self.type_pprinters[cls] = printer<EOL><DEDENT>return printer<EOL>", "docstring": "Check if the given class is specified in the deferred type registry.\n\nReturns the printer from the registry if it exists, and None if the\nclass is not in the registry. Successful matches will be moved to the\nregular type registry for future use.", "id": "f21617:c2:m2"}
{"signature": "def _type_pprint(obj, p, cycle):", "body": "if obj.__module__ in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>name = obj.__name__<EOL><DEDENT>else:<EOL><INDENT>name = obj.__module__ + '<STR_LIT:.>' + obj.__name__<EOL><DEDENT>p.text(name)<EOL>", "docstring": "The pprint for classes and types.", "id": "f21617:m8"}
{"signature": "def _default_pprint(obj, p, cycle):", "body": "klass = getattr(obj, '<STR_LIT>', None) or type(obj)<EOL>if getattr(klass, '<STR_LIT>', None) not in _baseclass_reprs:<EOL><INDENT>p.text(repr(obj))<EOL>return<EOL><DEDENT>p.begin_group(<NUM_LIT:1>, '<STR_LIT:<>')<EOL>p.pretty(klass)<EOL>p.text('<STR_LIT>' % id(obj))<EOL>if cycle:<EOL><INDENT>p.text('<STR_LIT>')<EOL><DEDENT>elif p.verbose:<EOL><INDENT>first = True<EOL>for key in dir(obj):<EOL><INDENT>if not key.startswith('<STR_LIT:_>'):<EOL><INDENT>try:<EOL><INDENT>value = getattr(obj, key)<EOL><DEDENT>except AttributeError:<EOL><INDENT>continue<EOL><DEDENT>if isinstance(value, types.MethodType):<EOL><INDENT>continue<EOL><DEDENT>if not first:<EOL><INDENT>p.text('<STR_LIT:U+002C>')<EOL><DEDENT>p.breakable()<EOL>p.text(key)<EOL>p.text('<STR_LIT:=>')<EOL>step = len(key) + <NUM_LIT:1><EOL>p.indentation += step<EOL>p.pretty(value)<EOL>p.indentation -= step<EOL>first = False<EOL><DEDENT><DEDENT><DEDENT>p.end_group(<NUM_LIT:1>, '<STR_LIT:>>')<EOL>", "docstring": "The default print function.  Used if an object does not provide one and\nit's none of the builtin objects.", "id": "f21617:m3"}
{"signature": "def _replace_rlhist_multiline(self, source_raw, hlen_before_cell):", "body": "<EOL>if not self.has_readline or not self.multiline_history:<EOL><INDENT>return hlen_before_cell<EOL><DEDENT>if not hasattr(self.readline, \"<STR_LIT>\"):<EOL><INDENT>return hlen_before_cell<EOL><DEDENT>if not source_raw.rstrip():<EOL><INDENT>return hlen_before_cell<EOL><DEDENT>hlen = self.readline.get_current_history_length()<EOL>if hlen == hlen_before_cell:<EOL><INDENT>return hlen_before_cell<EOL><DEDENT>for i in range(hlen - hlen_before_cell):<EOL><INDENT>self.readline.remove_history_item(hlen - i - <NUM_LIT:1>)<EOL><DEDENT>stdin_encoding = get_stream_enc(sys.stdin, '<STR_LIT:utf-8>')<EOL>self.readline.add_history(py3compat.unicode_to_str(source_raw.rstrip(),<EOL>stdin_encoding))<EOL>return self.readline.get_current_history_length()<EOL>", "docstring": "Store multiple lines as a single entry in history", "id": "f21620:c1:m12"}
{"signature": "def rerun_pasted(self, name='<STR_LIT>'):", "body": "b = self.shell.user_ns.get(name)<EOL>if b is None:<EOL><INDENT>raise UsageError('<STR_LIT>')<EOL><DEDENT>if not isinstance(b, str):<EOL><INDENT>raise UsageError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>print(\"<STR_LIT>\"% (b.split('<STR_LIT:\\n>',<NUM_LIT:1>)[<NUM_LIT:0>], len(b)))<EOL>self.shell.run_cell(b)<EOL>", "docstring": "Rerun a previously pasted command.", "id": "f21620:c0:m3"}
{"signature": "def raw_input(self, prompt='<STR_LIT>'):", "body": "<EOL>if self.has_readline:<EOL><INDENT>self.set_readline_completer()<EOL><DEDENT>prompt = py3compat.cast_bytes_py2(prompt)<EOL>try:<EOL><INDENT>line = py3compat.str_to_unicode(self.raw_input_original(prompt))<EOL><DEDENT>except ValueError:<EOL><INDENT>warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>self.ask_exit()<EOL>return \"<STR_LIT>\"<EOL><DEDENT>if self.autoindent:<EOL><INDENT>if num_ini_spaces(line) > self.indent_current_nsp:<EOL><INDENT>line = line[self.indent_current_nsp:]<EOL>self.indent_current_nsp = <NUM_LIT:0><EOL><DEDENT><DEDENT>return line<EOL>", "docstring": "Write a prompt and read a line.\n\n        The returned line does not include the trailing newline.\n        When the user enters the EOF key sequence, EOFError is raised.\n\n        Optional inputs:\n\n          - prompt(''): a string to be printed to prompt the user.\n\n          - continue_prompt(False): whether this line is the first one or a\n          continuation in a sequence of inputs.", "id": "f21620:c1:m14"}
{"signature": "def store_or_execute(self, block, name):", "body": "b = self.cleanup_input(block)<EOL>if name:<EOL><INDENT>self.shell.user_ns[name] = SList(b.splitlines())<EOL>print(\"<STR_LIT>\" % name)<EOL><DEDENT>else:<EOL><INDENT>self.shell.user_ns['<STR_LIT>'] = b<EOL>self.shell.run_cell(b)<EOL><DEDENT>", "docstring": "Execute a block, or store it in a variable, per the user's request.", "id": "f21620:c0:m2"}
{"signature": "def interact(self, display_banner=None):", "body": "<EOL>if self.exit_now:<EOL><INDENT>return<EOL><DEDENT>if display_banner is None:<EOL><INDENT>display_banner = self.display_banner<EOL><DEDENT>if isinstance(display_banner, str):<EOL><INDENT>self.show_banner(display_banner)<EOL><DEDENT>elif display_banner:<EOL><INDENT>self.show_banner()<EOL><DEDENT>more = False<EOL>if self.has_readline:<EOL><INDENT>self.readline_startup_hook(self.pre_readline)<EOL>hlen_b4_cell = self.readline.get_current_history_length()<EOL><DEDENT>else:<EOL><INDENT>hlen_b4_cell = <NUM_LIT:0><EOL><DEDENT>while not self.exit_now:<EOL><INDENT>self.hooks.pre_prompt_hook()<EOL>if more:<EOL><INDENT>try:<EOL><INDENT>prompt = self.prompt_manager.render('<STR_LIT>')<EOL><DEDENT>except:<EOL><INDENT>self.showtraceback()<EOL><DEDENT>if self.autoindent:<EOL><INDENT>self.rl_do_indent = True<EOL><DEDENT><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>prompt = self.separate_in + self.prompt_manager.render('<STR_LIT>')<EOL><DEDENT>except:<EOL><INDENT>self.showtraceback()<EOL><DEDENT><DEDENT>try:<EOL><INDENT>line = self.raw_input(prompt)<EOL>if self.exit_now:<EOL><INDENT>break<EOL><DEDENT>if self.autoindent:<EOL><INDENT>self.rl_do_indent = False<EOL><DEDENT><DEDENT>except KeyboardInterrupt:<EOL><INDENT>try:<EOL><INDENT>self.write('<STR_LIT>')<EOL>source_raw = self.input_splitter.source_raw_reset()[<NUM_LIT:1>]<EOL>hlen_b4_cell =self._replace_rlhist_multiline(source_raw, hlen_b4_cell)<EOL>more = False<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>except EOFError:<EOL><INDENT>if self.autoindent:<EOL><INDENT>self.rl_do_indent = False<EOL>if self.has_readline:<EOL><INDENT>self.readline_startup_hook(None)<EOL><DEDENT><DEDENT>self.write('<STR_LIT:\\n>')<EOL>self.exit()<EOL><DEDENT>except bdb.BdbQuit:<EOL><INDENT>warn('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>except:<EOL><INDENT>self.showtraceback()<EOL><DEDENT>else:<EOL><INDENT>self.input_splitter.push(line)<EOL>more = self.input_splitter.push_accepts_more()<EOL>if (self.SyntaxTB.last_syntax_error and<EOL>self.autoedit_syntax):<EOL><INDENT>self.edit_syntax_error()<EOL><DEDENT>if not more:<EOL><INDENT>source_raw = self.input_splitter.source_raw_reset()[<NUM_LIT:1>]<EOL>self.run_cell(source_raw, store_history=True)<EOL>hlen_b4_cell =self._replace_rlhist_multiline(source_raw, hlen_b4_cell)<EOL><DEDENT><DEDENT><DEDENT>self.exit_now = False<EOL>", "docstring": "Closely emulate the interactive Python console.", "id": "f21620:c1:m13"}
{"signature": "def ask_exit(self):", "body": "self.exit_now = True<EOL>", "docstring": "Ask the shell to exit. Can be overiden and used as a callback.", "id": "f21620:c1:m17"}
{"signature": "def get_pasted_lines(sentinel, l_input=py3compat.input):", "body": "print(\"<STR_LIT>\"% sentinel)<EOL>while True:<EOL><INDENT>try:<EOL><INDENT>l = l_input('<STR_LIT::>')<EOL>if l == sentinel:<EOL><INDENT>return<EOL><DEDENT>else:<EOL><INDENT>yield l<EOL><DEDENT><DEDENT>except EOFError:<EOL><INDENT>print('<STR_LIT>')<EOL>return<EOL><DEDENT><DEDENT>", "docstring": "Yield pasted lines until the user enters the given sentinel value.", "id": "f21620:m1"}
{"signature": "def launch_new_instance():", "body": "app = TerminalIPythonApp.instance()<EOL>app.initialize()<EOL>app.start()<EOL>", "docstring": "Create and run a full blown IPython instance", "id": "f21625:m1"}
{"signature": "@catch_config_error<EOL><INDENT>def initialize(self, argv=None):<DEDENT>", "body": "super(TerminalIPythonApp, self).initialize(argv)<EOL>if self.subapp is not None:<EOL><INDENT>return<EOL><DEDENT>if not self.ignore_old_config:<EOL><INDENT>check_for_old_config(self.ipython_dir)<EOL><DEDENT>if self.extra_args and not self.something_to_run:<EOL><INDENT>self.file_to_run = self.extra_args[<NUM_LIT:0>]<EOL><DEDENT>self.init_path()<EOL>self.init_shell()<EOL>self.init_banner()<EOL>self.init_gui_pylab()<EOL>self.init_extensions()<EOL>self.init_code()<EOL>", "docstring": "Do actions after construct, but before starting the app.", "id": "f21625:c2:m5"}
{"signature": "def _classes_default(self):", "body": "return [<EOL>InteractiveShellApp, <EOL>self.__class__,      <EOL>TerminalInteractiveShell,<EOL>PromptManager,<EOL>HistoryManager,<EOL>ProfileDir,<EOL>PlainTextFormatter,<EOL>IPCompleter,<EOL>ScriptMagics,<EOL>]<EOL>", "docstring": "This has to be in a method, for TerminalIPythonApp to be available.", "id": "f21625:c2:m0"}
{"signature": "def _pylab_changed(self, name, old, new):", "body": "if new == '<STR_LIT>':<EOL><INDENT>warn.warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>self.pylab = '<STR_LIT>'<EOL><DEDENT>", "docstring": "Replace --pylab='inline' with --pylab='auto", "id": "f21625:c2:m8"}
{"signature": "def __len__(self):", "body": "return len(self.kernel_ids)<EOL>", "docstring": "Return the number of running kernels.", "id": "f21627:c1:m4"}
{"signature": "def get_kernel(self, kernel_id):", "body": "km = self._kernels.get(kernel_id)<EOL>if km is not None:<EOL><INDENT>return km<EOL><DEDENT>else:<EOL><INDENT>raise KeyError(\"<STR_LIT>\" % kernel_id)<EOL><DEDENT>", "docstring": "Get the single KernelManager object for a kernel by its uuid.\n\n        Parameters\n        ==========\n        kernel_id : uuid\n            The id of the kernel.", "id": "f21627:c1:m11"}
{"signature": "def interrupt_kernel(self, kernel_id):", "body": "self._check_kernel_id(kernel_id)<EOL>super(MappingKernelManager, self).interrupt_kernel(kernel_id)<EOL>self.log.info(\"<STR_LIT>\" % kernel_id)<EOL>", "docstring": "Interrupt a kernel.", "id": "f21627:c2:m7"}
{"signature": "def kill_kernel(self, kernel_id):", "body": "self.get_kernel(kernel_id).kill_kernel()<EOL>del self._kernels[kernel_id]<EOL>", "docstring": "Kill a kernel by its kernel uuid.\n\n        Parameters\n        ==========\n        kernel_id : uuid\n            The id of the kernel to kill.", "id": "f21627:c1:m8"}
{"signature": "def signal_kernel(self, kernel_id, signum):", "body": "return self.get_kernel(kernel_id).signal_kernel(signum)<EOL>", "docstring": "Sends a signal to the kernel by its uuid.\n\n        Note that since only SIGTERM is supported on Windows, this function\n        is only useful on Unix systems.\n\n        Parameters\n        ==========\n        kernel_id : uuid\n            The id of the kernel to signal.", "id": "f21627:c1:m10"}
{"signature": "def set_kernel_for_notebook(self, notebook_id, kernel_id):", "body": "if notebook_id is not None:<EOL><INDENT>self._notebook_mapping[notebook_id] = kernel_id<EOL><DEDENT>", "docstring": "Associate a notebook with a kernel.", "id": "f21627:c2:m1"}
{"signature": "def start_kernel(self, notebook_id=None, **kwargs):", "body": "kernel_id = self.kernel_for_notebook(notebook_id)<EOL>if kernel_id is None:<EOL><INDENT>kwargs['<STR_LIT>'] = self.kernel_argv<EOL>kernel_id = super(MappingKernelManager, self).start_kernel(**kwargs)<EOL>self.set_kernel_for_notebook(notebook_id, kernel_id)<EOL>self.log.info(\"<STR_LIT>\" % kernel_id)<EOL>self.log.debug(\"<STR_LIT>\" % kwargs)<EOL><DEDENT>else:<EOL><INDENT>self.log.info(\"<STR_LIT>\" % kernel_id)<EOL><DEDENT>return kernel_id<EOL>", "docstring": "Start a kernel for a notebok an return its kernel_id.\n\n        Parameters\n        ----------\n        notebook_id : uuid\n            The uuid of the notebook to associate the new kernel with. If this\n            is not None, this kernel will be persistent whenever the notebook\n            requests a kernel.", "id": "f21627:c2:m4"}
{"signature": "def _save_method_args(self, *args, **kwargs):", "body": "self._method_args = args<EOL>self._method_kwargs = kwargs<EOL>", "docstring": "Save the args and kwargs to get/post/put/delete for future use.\n\n        These arguments are not saved in the request or handler objects, but\n        are often needed by methods such as get_stream().", "id": "f21630:c0:m1"}
{"signature": "def delete_notebook(self, notebook_id):", "body": "path = self.find_path(notebook_id)<EOL>if not os.path.isfile(path):<EOL><INDENT>raise web.HTTPError(<NUM_LIT>, u'<STR_LIT>' % notebook_id)<EOL><DEDENT>os.unlink(path)<EOL>self.delete_notebook_id(notebook_id)<EOL>", "docstring": "Delete notebook by notebook_id.", "id": "f21631:c0:m12"}
{"signature": "def list_notebooks(self):", "body": "names = glob.glob(os.path.join(self.notebook_dir,<EOL>'<STR_LIT:*>' + self.filename_ext))<EOL>names = [os.path.splitext(os.path.basename(name))[<NUM_LIT:0>]<EOL>for name in names]<EOL>data = []<EOL>for name in names:<EOL><INDENT>if name not in self.rev_mapping:<EOL><INDENT>notebook_id = self.new_notebook_id(name)<EOL><DEDENT>else:<EOL><INDENT>notebook_id = self.rev_mapping[name]<EOL><DEDENT>data.append(dict(notebook_id=notebook_id,name=name))<EOL><DEDENT>data = sorted(data, key=lambda item: item['<STR_LIT:name>'])<EOL>return data<EOL>", "docstring": "List all notebooks in the notebook dir.\n\n        This returns a list of dicts of the form::\n\n            dict(notebook_id=notebook,name=name)", "id": "f21631:c0:m1"}
{"signature": "def _notebook_dir_changed(self, name, old, new):", "body": "if os.path.exists(new) and not os.path.isdir(new):<EOL><INDENT>raise TraitError(\"<STR_LIT>\" % new)<EOL><DEDENT>if not os.path.exists(new):<EOL><INDENT>self.log.info(\"<STR_LIT>\", new)<EOL>try:<EOL><INDENT>os.mkdir(new)<EOL><DEDENT>except:<EOL><INDENT>raise TraitError(\"<STR_LIT>\" % new)<EOL><DEDENT><DEDENT>", "docstring": "do a bit of validation of the notebook dir", "id": "f21631:c0:m0"}
{"signature": "def delete_notebook_id(self, notebook_id):", "body": "name = self.mapping[notebook_id]<EOL>del self.mapping[notebook_id]<EOL>del self.rev_mapping[name]<EOL>", "docstring": "Delete a notebook's id only. This doesn't delete the actual notebook.", "id": "f21631:c0:m3"}
{"signature": "def save_new_notebook(self, data, name=None, format=u'<STR_LIT>'):", "body": "if format not in self.allowed_formats:<EOL><INDENT>raise web.HTTPError(<NUM_LIT>, u'<STR_LIT>' % format)<EOL><DEDENT>try:<EOL><INDENT>nb = current.reads(data.decode('<STR_LIT:utf-8>'), format)<EOL><DEDENT>except:<EOL><INDENT>raise web.HTTPError(<NUM_LIT>, u'<STR_LIT>')<EOL><DEDENT>if name is None:<EOL><INDENT>try:<EOL><INDENT>name = nb.metadata.name<EOL><DEDENT>except AttributeError:<EOL><INDENT>raise web.HTTPError(<NUM_LIT>, u'<STR_LIT>')<EOL><DEDENT><DEDENT>nb.metadata.name = name<EOL>notebook_id = self.new_notebook_id(name)<EOL>self.save_notebook_object(notebook_id, nb)<EOL>return notebook_id<EOL>", "docstring": "Save a new notebook and return its notebook_id.\n\n        If a name is passed in, it overrides any values in the notebook data\n        and the value in the data is updated to use that value.", "id": "f21631:c0:m9"}
{"signature": "def increment_filename(self, basename):", "body": "i = <NUM_LIT:0><EOL>while True:<EOL><INDENT>name = u'<STR_LIT>' % (basename,i)<EOL>path = self.get_path_by_name(name)<EOL>if not os.path.isfile(path):<EOL><INDENT>break<EOL><DEDENT>else:<EOL><INDENT>i = i+<NUM_LIT:1><EOL><DEDENT><DEDENT>return path, name<EOL>", "docstring": "Return a non-used filename of the form basename<int>.\n\n        This searches through the filenames (basename0, basename1, ...)\n        until is find one that is not already being used. It is used to\n        create Untitled and Copy names that are unique.", "id": "f21631:c0:m13"}
{"signature": "def get_notebook_object(self, notebook_id):", "body": "path = self.find_path(notebook_id)<EOL>if not os.path.isfile(path):<EOL><INDENT>raise web.HTTPError(<NUM_LIT>, u'<STR_LIT>' % notebook_id)<EOL><DEDENT>info = os.stat(path)<EOL>last_modified = datetime.datetime.utcfromtimestamp(info.st_mtime)<EOL>with open(path,'<STR_LIT:r>') as f:<EOL><INDENT>s = f.read()<EOL>try:<EOL><INDENT>nb = current.reads(s, u'<STR_LIT>')<EOL><DEDENT>except:<EOL><INDENT>raise web.HTTPError(<NUM_LIT>, u'<STR_LIT>')<EOL><DEDENT><DEDENT>nb.metadata.name = os.path.splitext(os.path.basename(path))[<NUM_LIT:0>]<EOL>return last_modified, nb<EOL>", "docstring": "Get the NotebookNode representation of a notebook by notebook_id.", "id": "f21631:c0:m8"}
{"signature": "def init_webapp(self):", "body": "self.web_app = NotebookWebApplication(<EOL>self, self.kernel_manager, self.notebook_manager, <EOL>self.cluster_manager, self.log,<EOL>self.base_project_url, self.webapp_settings<EOL>)<EOL>if self.certfile:<EOL><INDENT>ssl_options = dict(certfile=self.certfile)<EOL>if self.keyfile:<EOL><INDENT>ssl_options['<STR_LIT>'] = self.keyfile<EOL><DEDENT><DEDENT>else:<EOL><INDENT>ssl_options = None<EOL><DEDENT>self.web_app.password = self.password<EOL>self.http_server = httpserver.HTTPServer(self.web_app, ssl_options=ssl_options)<EOL>if ssl_options is None and not self.ip and not (self.read_only and not self.password):<EOL><INDENT>self.log.critical('<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>')<EOL><DEDENT>success = None<EOL>for port in random_ports(self.port, self.port_retries+<NUM_LIT:1>):<EOL><INDENT>try:<EOL><INDENT>self.http_server.listen(port, self.ip)<EOL><DEDENT>except socket.error as e:<EOL><INDENT>if e.errno != errno.EADDRINUSE:<EOL><INDENT>raise<EOL><DEDENT>self.log.info('<STR_LIT>' % port)<EOL><DEDENT>else:<EOL><INDENT>self.port = port<EOL>success = True<EOL>break<EOL><DEDENT><DEDENT>if not success:<EOL><INDENT>self.log.critical('<STR_LIT>'<EOL>'<STR_LIT>')<EOL>self.exit(<NUM_LIT:1>)<EOL><DEDENT>", "docstring": "initialize tornado webapp and httpserver", "id": "f21632:c1:m7"}
{"signature": "@property<EOL><INDENT>def ws_url(self):<DEDENT>", "body": "proto = self.request.protocol.replace('<STR_LIT:http>', '<STR_LIT>')<EOL>host = self.application.ipython_app.websocket_host <EOL>if host == '<STR_LIT>':<EOL><INDENT>host = self.request.host <EOL><DEDENT>return \"<STR_LIT>\" % (proto, host)<EOL>", "docstring": "websocket url matching the current request\n\n        turns http[s]://host[:port] into\n                ws[s]://host[:port]", "id": "f21634:c1:m4"}
{"signature": "def update_profiles(self):", "body": "for path in [get_ipython_dir(), os.getcwdu()]:<EOL><INDENT>for profile in list_profiles_in(path):<EOL><INDENT>pd = self.get_profile_dir(profile, path)<EOL>if profile not in self.profiles:<EOL><INDENT>self.log.debug(\"<STR_LIT>\" % profile)<EOL>self.profiles[profile] = {<EOL>'<STR_LIT>': profile,<EOL>'<STR_LIT>': pd,<EOL>'<STR_LIT:status>': '<STR_LIT>'<EOL>}<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "List all profiles in the ipython_dir and cwd.", "id": "f21635:c1:m3"}
{"signature": "def get_font(family, fallback=None):", "body": "font = QtGui.QFont(family)<EOL>font_info = QtGui.QFontInfo(font)<EOL>if fallback is not None and font_info.family() != family:<EOL><INDENT>font = QtGui.QFont(fallback)<EOL><DEDENT>return font<EOL>", "docstring": "Return a font of the requested family, using fallback as alternative.\n\n    If a fallback is provided, it is used in case the requested family isn't\n    found.  If no fallback is given, no alternative is chosen and Qt's internal\n    algorithms may automatically choose a fallback font.\n\n    Parameters\n    ----------\n    family : str\n      A font name.\n    fallback : str\n      A font name.\n\n    Returns\n    -------\n    font : QFont object", "id": "f21636:m0"}
{"signature": "def flush(self):", "body": "super(QtSubSocketChannel, self).flush()<EOL>QtCore.QCoreApplication.instance().processEvents()<EOL>", "docstring": "Reimplemented to ensure that signals are dispatched immediately.", "id": "f21637:c2:m1"}
{"signature": "def call_handlers(self, msg):", "body": "<EOL>self.message_received.emit(msg)<EOL>msg_type = msg['<STR_LIT>']['<STR_LIT>']<EOL>if msg_type == '<STR_LIT>':<EOL><INDENT>self.input_requested.emit(msg)<EOL><DEDENT>", "docstring": "Reimplemented to emit signals instead of making callbacks.", "id": "f21637:c3:m0"}
{"signature": "def rotate(self):", "body": "if self._prev_yank:<EOL><INDENT>text = self._ring.rotate()<EOL>if text:<EOL><INDENT>self._skip_cursor = True<EOL>cursor = self._text_edit.textCursor()<EOL>cursor.movePosition(QtGui.QTextCursor.Left,<EOL>QtGui.QTextCursor.KeepAnchor,<EOL>n = len(self._prev_yank))<EOL>cursor.insertText(text)<EOL>self._prev_yank = text<EOL><DEDENT><DEDENT>", "docstring": "Rotate the kill ring, then yank back the new top.", "id": "f21638:c1:m5"}
{"signature": "def kill(self, text):", "body": "self._ring.kill(text)<EOL>", "docstring": "Adds some killed text to the ring.", "id": "f21638:c1:m2"}
{"signature": "def _insert_png(self, cursor, png):", "body": "self._insert_img(cursor, png, '<STR_LIT>')<EOL>", "docstring": "Insert raw PNG data into the widget.", "id": "f21639:c0:m14"}
{"signature": "def _add_image(self, image):", "body": "document = self._control.document()<EOL>name = str(image.cacheKey())<EOL>document.addResource(QtGui.QTextDocument.ImageResource,<EOL>QtCore.QUrl(name), image)<EOL>format = QtGui.QTextImageFormat()<EOL>format.setName(name)<EOL>return format<EOL>", "docstring": "Adds the specified QImage to the document and returns a\n            QTextImageFormat that references it.", "id": "f21639:c0:m9"}
{"signature": "def _append_png(self, png, before_prompt=False):", "body": "self._append_custom(self._insert_png, png, before_prompt)<EOL>", "docstring": "Append raw PNG data to the widget.", "id": "f21639:c0:m7"}
{"signature": "def _insert_img(self, cursor, img, fmt):", "body": "try:<EOL><INDENT>image = QtGui.QImage()<EOL>image.loadFromData(img, fmt.upper())<EOL><DEDENT>except ValueError:<EOL><INDENT>self._insert_plain_text(cursor, '<STR_LIT>'%fmt)<EOL><DEDENT>else:<EOL><INDENT>format = self._add_image(image)<EOL>cursor.insertBlock()<EOL>cursor.insertImage(format)<EOL>cursor.insertBlock()<EOL><DEDENT>", "docstring": "insert a raw image, jpg or png", "id": "f21639:c0:m15"}
{"signature": "def _get_image_tag(self, match, path = None, format = \"<STR_LIT>\"):", "body": "if format in (\"<STR_LIT>\",\"<STR_LIT>\"):<EOL><INDENT>try:<EOL><INDENT>image = self._get_image(match.group(\"<STR_LIT:name>\"))<EOL><DEDENT>except KeyError:<EOL><INDENT>return \"<STR_LIT>\" % match.group(\"<STR_LIT:name>\")<EOL><DEDENT>if path is not None:<EOL><INDENT>if not os.path.exists(path):<EOL><INDENT>os.mkdir(path)<EOL><DEDENT>relpath = os.path.basename(path)<EOL>if image.save(\"<STR_LIT>\" % (path, match.group(\"<STR_LIT:name>\"), format),<EOL>\"<STR_LIT>\"):<EOL><INDENT>return '<STR_LIT>' % (relpath,<EOL>match.group(\"<STR_LIT:name>\"),format)<EOL><DEDENT>else:<EOL><INDENT>return \"<STR_LIT>\"<EOL><DEDENT><DEDENT>else:<EOL><INDENT>ba = QtCore.QByteArray()<EOL>buffer_ = QtCore.QBuffer(ba)<EOL>buffer_.open(QtCore.QIODevice.WriteOnly)<EOL>image.save(buffer_, format.upper())<EOL>buffer_.close()<EOL>return '<STR_LIT>' % (<EOL>format,re.sub(r'<STR_LIT>',r'<STR_LIT>',str(ba.toBase64())))<EOL><DEDENT><DEDENT>elif format == \"<STR_LIT>\":<EOL><INDENT>try:<EOL><INDENT>svg = str(self._name_to_svg_map[match.group(\"<STR_LIT:name>\")])<EOL><DEDENT>except KeyError:<EOL><INDENT>if not self._svg_warning_displayed:<EOL><INDENT>QtGui.QMessageBox.warning(self, '<STR_LIT>',<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>'<EOL>'<STR_LIT>',<EOL>QtGui.QMessageBox.Ok)<EOL>self._svg_warning_displayed = True<EOL><DEDENT>return (\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT>offset = svg.find(\"<STR_LIT>\")<EOL>assert(offset > -<NUM_LIT:1>)<EOL>return svg[offset:]<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>", "docstring": "Return (X)HTML mark-up for the image-tag given by match.\n\n        Parameters\n        ----------\n        match : re.SRE_Match\n            A match to an HTML image tag as exported by Qt, with\n            match.group(\"Name\") containing the matched image ID.\n\n        path : string|None, optional [default None]\n            If not None, specifies a path to which supporting files may be\n            written (e.g., for linked images).  If None, all images are to be\n            included inline.\n\n        format : \"png\"|\"svg\"|\"jpg\", optional [default \"png\"]\n            Format for returned or referenced images.", "id": "f21639:c0:m12"}
{"signature": "def _copy_image(self, name):", "body": "image = self._get_image(name)<EOL>QtGui.QApplication.clipboard().setImage(image)<EOL>", "docstring": "Copies the ImageResource with 'name' to the clipboard.", "id": "f21639:c0:m10"}
{"signature": "@classmethod<EOL><INDENT>def setUpClass(cls):<DEDENT>", "body": "cls._app = QtGui.QApplication.instance()<EOL>if cls._app is None:<EOL><INDENT>cls._app = QtGui.QApplication([])<EOL><DEDENT>cls._app.setQuitOnLastWindowClosed(False)<EOL>", "docstring": "Create the application for the test case.", "id": "f21643:c0:m0"}
{"signature": "@classmethod<EOL><INDENT>def tearDownClass(cls):<DEDENT>", "body": "QtGui.QApplication.quit()<EOL>", "docstring": "Exit the application.", "id": "f21643:c0:m1"}
{"signature": "def set_default_style(self, colors='<STR_LIT>'):", "body": "colors = colors.lower()<EOL>if colors=='<STR_LIT>':<EOL><INDENT>self.style_sheet = styles.default_light_style_sheet<EOL>self.syntax_style = styles.default_light_syntax_style<EOL><DEDENT>elif colors=='<STR_LIT>':<EOL><INDENT>self.style_sheet = styles.default_dark_style_sheet<EOL>self.syntax_style = styles.default_dark_syntax_style<EOL><DEDENT>elif colors=='<STR_LIT>':<EOL><INDENT>self.style_sheet = styles.default_bw_style_sheet<EOL>self.syntax_style = styles.default_bw_syntax_style<EOL><DEDENT>else:<EOL><INDENT>raise KeyError(\"<STR_LIT>\"%colors)<EOL><DEDENT>", "docstring": "Sets the widget style to the class defaults.\n\n        Parameters:\n        -----------\n        colors : str, optional (default lightbg)\n            Whether to use the default IPython light background or dark\n            background or B&W style.", "id": "f21644:c0:m15"}
{"signature": "def _process_execute_error(self, msg):", "body": "content = msg['<STR_LIT:content>']<EOL>traceback = '<STR_LIT:\\n>'.join(content['<STR_LIT>']) + '<STR_LIT:\\n>'<EOL>if False:<EOL><INDENT>traceback = traceback.replace('<STR_LIT:U+0020>', '<STR_LIT>')<EOL>traceback = traceback.replace('<STR_LIT:\\n>', '<STR_LIT>')<EOL>ename = content['<STR_LIT>']<EOL>ename_styled = '<STR_LIT>' % ename<EOL>traceback = traceback.replace(ename, ename_styled)<EOL>self._append_html(traceback)<EOL><DEDENT>else:<EOL><INDENT>self._append_plain_text(traceback)<EOL><DEDENT>", "docstring": "Reimplemented for IPython-style traceback formatting.", "id": "f21644:c0:m11"}
{"signature": "def _make_out_prompt(self, number):", "body": "body = self.out_prompt % number<EOL>return '<STR_LIT>' % body<EOL>", "docstring": "Given a prompt number, returns an HTML Out prompt.", "id": "f21644:c0:m19"}
{"signature": "def _make_continuation_prompt(self, prompt):", "body": "end_chars = '<STR_LIT>'<EOL>space_count = len(prompt.lstrip('<STR_LIT:\\n>')) - len(end_chars)<EOL>body = '<STR_LIT>' * space_count + end_chars<EOL>return '<STR_LIT>' % body<EOL>", "docstring": "Given a plain text version of an In prompt, returns an HTML\n            continuation prompt.", "id": "f21644:c0:m18"}
{"signature": "def _handle_pyout(self, msg):", "body": "self.log.debug(\"<STR_LIT>\", msg.get('<STR_LIT:content>', '<STR_LIT>'))<EOL>if not self._hidden and self._is_from_this_session(msg):<EOL><INDENT>content = msg['<STR_LIT:content>']<EOL>prompt_number = content.get('<STR_LIT>', <NUM_LIT:0>)<EOL>data = content['<STR_LIT:data>']<EOL>if data.has_key('<STR_LIT>'):<EOL><INDENT>self._append_plain_text(self.output_sep, True)<EOL>self._append_html(self._make_out_prompt(prompt_number), True)<EOL>html = data['<STR_LIT>']<EOL>self._append_plain_text('<STR_LIT:\\n>', True)<EOL>self._append_html(html + self.output_sep2, True)<EOL><DEDENT>elif data.has_key('<STR_LIT>'):<EOL><INDENT>self._append_plain_text(self.output_sep, True)<EOL>self._append_html(self._make_out_prompt(prompt_number), True)<EOL>text = data['<STR_LIT>']<EOL>if \"<STR_LIT:\\n>\" in text and not self.output_sep.endswith(\"<STR_LIT:\\n>\"):<EOL><INDENT>self._append_plain_text('<STR_LIT:\\n>', True)<EOL><DEDENT>self._append_plain_text(text + self.output_sep2, True)<EOL><DEDENT><DEDENT>", "docstring": "Reimplemented for IPython-style \"display hook\".", "id": "f21644:c0:m4"}
{"signature": "def _handle_history_reply(self, msg):", "body": "content = msg['<STR_LIT:content>']<EOL>if '<STR_LIT>' not in content:<EOL><INDENT>self.log.error(\"<STR_LIT>\"%content)<EOL>if content.get('<STR_LIT:status>', '<STR_LIT>') == '<STR_LIT>' andnot self._retrying_history_request:<EOL><INDENT>self.log.error(\"<STR_LIT>\")<EOL>self._retrying_history_request = True<EOL>time.sleep(<NUM_LIT>)<EOL>self.kernel_manager.shell_channel.history(hist_access_type='<STR_LIT>',n=<NUM_LIT:1000>)<EOL><DEDENT>else:<EOL><INDENT>self._retrying_history_request = False<EOL><DEDENT>return<EOL><DEDENT>self._retrying_history_request = False<EOL>history_items = content['<STR_LIT>']<EOL>self.log.debug(\"<STR_LIT>\", len(history_items))<EOL>items = []<EOL>last_cell = u\"<STR_LIT>\"<EOL>for _, _, cell in history_items:<EOL><INDENT>cell = cell.rstrip()<EOL>if cell != last_cell:<EOL><INDENT>items.append(cell)<EOL>last_cell = cell<EOL><DEDENT><DEDENT>self._set_history(items)<EOL>", "docstring": "Implemented to handle history tail replies, which are only supported\n            by the IPython kernel.", "id": "f21644:c0:m3"}
{"signature": "@property<EOL><INDENT>def stop(self):<DEDENT>", "body": "return self._stop<EOL>", "docstring": "end of interval to show", "id": "f21645:c0:m4"}
{"signature": "def eventFilter(self, obj, event):", "body": "if obj == self._text_edit:<EOL><INDENT>etype = event.type()<EOL>if etype == QtCore.QEvent.KeyPress:<EOL><INDENT>key = event.key()<EOL>if self._consecutive_tab == <NUM_LIT:0> and key in (QtCore.Qt.Key_Tab,):<EOL><INDENT>return False<EOL><DEDENT>elif self._consecutive_tab == <NUM_LIT:1> and key in (QtCore.Qt.Key_Tab,):<EOL><INDENT>self._consecutive_tab = self._consecutive_tab+<NUM_LIT:1><EOL>self._update_list()<EOL>return True<EOL><DEDENT>elif self._consecutive_tab == <NUM_LIT:2>:<EOL><INDENT>if key in (QtCore.Qt.Key_Return, QtCore.Qt.Key_Enter):<EOL><INDENT>self._complete_current()<EOL>return True<EOL><DEDENT>if key in (QtCore.Qt.Key_Tab,):<EOL><INDENT>self.select_right()<EOL>self._update_list()<EOL>return True<EOL><DEDENT>elif key in ( QtCore.Qt.Key_Down,):<EOL><INDENT>self.select_down()<EOL>self._update_list()<EOL>return True<EOL><DEDENT>elif key in (QtCore.Qt.Key_Right,):<EOL><INDENT>self.select_right()<EOL>self._update_list()<EOL>return True<EOL><DEDENT>elif key in ( QtCore.Qt.Key_Up,):<EOL><INDENT>self.select_up()<EOL>self._update_list()<EOL>return True<EOL><DEDENT>elif key in ( QtCore.Qt.Key_Left,):<EOL><INDENT>self.select_left()<EOL>self._update_list()<EOL>return True<EOL><DEDENT>elif key in ( QtCore.Qt.Key_Escape,):<EOL><INDENT>self.cancel_completion()<EOL>return True<EOL><DEDENT>else :<EOL><INDENT>self.cancel_completion()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.cancel_completion()<EOL><DEDENT><DEDENT>elif etype == QtCore.QEvent.FocusOut:<EOL><INDENT>self.cancel_completion()<EOL><DEDENT><DEDENT>return super(CompletionHtml, self).eventFilter(obj, event)<EOL>", "docstring": "Reimplemented to handle keyboard input and to auto-hide when the\n            text edit loses focus.", "id": "f21645:c1:m1"}
{"signature": "def __init__(self, console_widget):", "body": "assert isinstance(console_widget._control, (QtGui.QTextEdit, QtGui.QPlainTextEdit))<EOL>super(CompletionHtml, self).__init__()<EOL>self._text_edit = console_widget._control<EOL>self._console_widget = console_widget<EOL>self._text_edit.installEventFilter(self)<EOL>self._sliding_interval = None<EOL>self._justified_items = None<EOL>self.setFocusProxy(self._text_edit)<EOL>", "docstring": "Create a completion widget that is attached to the specified Qt\n            text edit widget.", "id": "f21645:c1:m0"}
{"signature": "def _select_index(self, row, col):", "body": "nr, nc = self._size<EOL>nr = nr-<NUM_LIT:1><EOL>nc = nc-<NUM_LIT:1><EOL>if (row > nr and col >= nc) or (row >= nr and col > nc):<EOL><INDENT>self._select_index(<NUM_LIT:0>, <NUM_LIT:0>)<EOL><DEDENT>elif (row <= <NUM_LIT:0> and col < <NUM_LIT:0>) or  (row < <NUM_LIT:0> and col <= <NUM_LIT:0>):<EOL><INDENT>self._select_index(nr, nc)<EOL><DEDENT>elif row > nr :<EOL><INDENT>self._select_index(<NUM_LIT:0>, col+<NUM_LIT:1>)<EOL><DEDENT>elif row < <NUM_LIT:0> :<EOL><INDENT>self._select_index(nr, col-<NUM_LIT:1>)<EOL><DEDENT>elif col > nc :<EOL><INDENT>self._select_index(row+<NUM_LIT:1>, <NUM_LIT:0>)<EOL><DEDENT>elif col < <NUM_LIT:0> :<EOL><INDENT>self._select_index(row-<NUM_LIT:1>, nc)<EOL><DEDENT>elif <NUM_LIT:0> <= row and row <= nr and <NUM_LIT:0> <= col and col <= nc :<EOL><INDENT>self._index = (row, col)<EOL><DEDENT>else :<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\"%(row, col, nr, nc) )<EOL><DEDENT>", "docstring": "Change the selection index, and make sure it stays in the right range\n\n        A little more complicated than just dooing modulo the number of row columns\n        to be sure to cycle through all element.\n\n        horizontaly, the element are maped like this :\n        to r <-- a b c d e f --> to g\n        to f <-- g h i j k l --> to m\n        to l <-- m n o p q r --> to a\n\n        and vertically\n        a d g j m p\n        b e h k n q\n        c f i l o r", "id": "f21645:c1:m3"}
{"signature": "@property<EOL><INDENT>def start(self):<DEDENT>", "body": "return self._start<EOL>", "docstring": "begiiing of interval to show", "id": "f21645:c0:m3"}
{"signature": "def select_up(self):", "body": "r, c = self._index<EOL>self._select_index(r-<NUM_LIT:1>, c)<EOL>", "docstring": "move cursor up", "id": "f21645:c1:m5"}
{"signature": "def _current_text_cursor(self):", "body": "cursor = self._text_edit.textCursor()<EOL>if cursor.position() >= self._start_position:<EOL><INDENT>cursor.setPosition(self._start_position,<EOL>QtGui.QTextCursor.KeepAnchor)<EOL><DEDENT>return cursor<EOL>", "docstring": "Returns a cursor with text between the start position and the\n            current position selected.", "id": "f21645:c1:m12"}
{"signature": "def paintEvent(self, event):", "body": "painter = QtGui.QStylePainter(self)<EOL>option = QtGui.QStyleOptionFrame()<EOL>option.initFrom(self)<EOL>painter.drawPrimitive(QtGui.QStyle.PE_PanelTipLabel, option)<EOL>painter.end()<EOL>super(CallTipWidget, self).paintEvent(event)<EOL>", "docstring": "Reimplemented to paint the background panel.", "id": "f21646:c0:m6"}
{"signature": "def sheet_from_template(name, colors='<STR_LIT>'):", "body": "colors = colors.lower()<EOL>if colors=='<STR_LIT>':<EOL><INDENT>return default_light_style_template%get_colors(name)<EOL><DEDENT>elif colors=='<STR_LIT>':<EOL><INDENT>return default_dark_style_template%get_colors(name)<EOL><DEDENT>elif colors=='<STR_LIT>':<EOL><INDENT>return default_bw_style_sheet<EOL><DEDENT>else:<EOL><INDENT>raise KeyError(\"<STR_LIT>\"%colors)<EOL><DEDENT>", "docstring": "Use one of the base templates, and set bg/fg/select colors.", "id": "f21647:m4"}
{"signature": "def get_format(self):", "body": "format = QtGui.QTextCharFormat()<EOL>qcolor = self.get_color(self.foreground_color, self.intensity)<EOL>if qcolor is not None:<EOL><INDENT>format.setForeground(qcolor)<EOL><DEDENT>qcolor = self.get_color(self.background_color, self.intensity)<EOL>if qcolor is not None:<EOL><INDENT>format.setBackground(qcolor)<EOL><DEDENT>if self.bold:<EOL><INDENT>format.setFontWeight(QtGui.QFont.Bold)<EOL><DEDENT>else:<EOL><INDENT>format.setFontWeight(QtGui.QFont.Normal)<EOL><DEDENT>format.setFontItalic(self.italic)<EOL>format.setFontUnderline(self.underline)<EOL>return format<EOL>", "docstring": "Returns a QTextCharFormat that encodes the current style attributes.", "id": "f21648:c1:m1"}
{"signature": "def create_tab_with_current_kernel(self):", "body": "current_widget = self.tab_widget.currentWidget()<EOL>current_widget_index = self.tab_widget.indexOf(current_widget)<EOL>current_widget_name = self.tab_widget.tabText(current_widget_index)<EOL>widget = self.slave_frontend_factory(current_widget)<EOL>if '<STR_LIT>' in current_widget_name:<EOL><INDENT>name = current_widget_name<EOL><DEDENT>else:<EOL><INDENT>name = '<STR_LIT>' % current_widget_name<EOL><DEDENT>self.add_tab_with_frontend(widget,name=name)<EOL>", "docstring": "create a new frontend attached to the same kernel as the current tab", "id": "f21649:c0:m5"}
{"signature": "def update_tab_bar_visibility(self):", "body": "if self.tab_widget.count() <= <NUM_LIT:1>:<EOL><INDENT>self.tab_widget.tabBar().setVisible(False)<EOL><DEDENT>else:<EOL><INDENT>self.tab_widget.tabBar().setVisible(True)<EOL><DEDENT>if self.tab_widget.count()==<NUM_LIT:0> :<EOL><INDENT>self.close()<EOL><DEDENT>", "docstring": "update visibility of the tabBar depending of the number of tab\n\n        0 or 1 tab, tabBar hidden\n        2+ tabs, tabBar visible\n\n        send a self.close if number of tab ==0\n\n        need to be called explicitly, or be connected to tabInserted/tabRemoved", "id": "f21649:c0:m1"}
{"signature": "def _get_magic_menu(self,menuidentifier, menulabel=None):", "body": "menu = self._magic_menu_dict.get(menuidentifier,None)<EOL>if not menu :<EOL><INDENT>if not menulabel:<EOL><INDENT>menulabel = re.sub(\"<STR_LIT>\",\"<STR_LIT>\",menuidentifier)<EOL><DEDENT>menu = QtGui.QMenu(menulabel,self.magic_menu)<EOL>self._magic_menu_dict[menuidentifier]=menu<EOL>self.magic_menu.insertMenu(self.magic_menu_separator,menu)<EOL><DEDENT>return menu<EOL>", "docstring": "return a submagic menu by name, and create it if needed\n\n        parameters:\n        -----------\n\n        menulabel : str\n            Label for the menu\n\n        Will infere the menu name from the identifier at creation if menulabel not given.\n        To do so you have too give menuidentifier as a CamelCassedString", "id": "f21649:c0:m22"}
{"signature": "def close_tab(self,current_tab):", "body": "<EOL>if type(current_tab) is not int :<EOL><INDENT>current_tab = self.tab_widget.indexOf(current_tab)<EOL><DEDENT>closing_widget=self.tab_widget.widget(current_tab)<EOL>if closing_widget==None:<EOL><INDENT>return<EOL><DEDENT>slave_tabs = self.find_slave_widgets(closing_widget)<EOL>keepkernel = None <EOL>if hasattr(closing_widget,'<STR_LIT>'): <EOL><INDENT>keepkernel = closing_widget._keep_kernel_on_exit<EOL>if keepkernel is not None:<EOL><INDENT>for tab in slave_tabs:<EOL><INDENT>tab._hidden = True<EOL><DEDENT>if closing_widget in slave_tabs:<EOL><INDENT>try :<EOL><INDENT>self.find_master_tab(closing_widget).execute('<STR_LIT>')<EOL><DEDENT>except AttributeError:<EOL><INDENT>self.log.info(\"<STR_LIT>\")<EOL>self.tab_widget.removeTab(current_tab)<EOL><DEDENT>self.update_tab_bar_visibility()<EOL>return<EOL><DEDENT><DEDENT><DEDENT>kernel_manager = closing_widget.kernel_manager<EOL>if keepkernel is None and not closing_widget._confirm_exit:<EOL><INDENT>keepkernel = closing_widget._existing<EOL><DEDENT>if keepkernel is None: <EOL><INDENT>if kernel_manager and kernel_manager.channels_running:<EOL><INDENT>title = self.window().windowTitle()<EOL>cancel = QtGui.QMessageBox.Cancel<EOL>okay = QtGui.QMessageBox.Ok<EOL>if closing_widget._may_close:<EOL><INDENT>msg = \"<STR_LIT>\"+'<STR_LIT:\">'+self.tab_widget.tabText(current_tab)+'<STR_LIT:\">'<EOL>info = \"<STR_LIT>\"<EOL>justthis = QtGui.QPushButton(\"<STR_LIT>\", self)<EOL>justthis.setShortcut('<STR_LIT:N>')<EOL>closeall = QtGui.QPushButton(\"<STR_LIT>\", self)<EOL>closeall.setShortcut('<STR_LIT:Y>')<EOL>closeall.setShortcut('<STR_LIT>')<EOL>box = QtGui.QMessageBox(QtGui.QMessageBox.Question,<EOL>title, msg)<EOL>box.setInformativeText(info)<EOL>box.addButton(cancel)<EOL>box.addButton(justthis, QtGui.QMessageBox.NoRole)<EOL>box.addButton(closeall, QtGui.QMessageBox.YesRole)<EOL>box.setDefaultButton(closeall)<EOL>box.setEscapeButton(cancel)<EOL>pixmap = QtGui.QPixmap(self._app.icon.pixmap(QtCore.QSize(<NUM_LIT:64>,<NUM_LIT:64>)))<EOL>box.setIconPixmap(pixmap)<EOL>reply = box.exec_()<EOL>if reply == <NUM_LIT:1>: <EOL><INDENT>for slave in slave_tabs:<EOL><INDENT>background(slave.kernel_manager.stop_channels)<EOL>self.tab_widget.removeTab(self.tab_widget.indexOf(slave))<EOL><DEDENT>closing_widget.execute(\"<STR_LIT>\")<EOL>self.tab_widget.removeTab(current_tab)<EOL>background(kernel_manager.stop_channels)<EOL><DEDENT>elif reply == <NUM_LIT:0>: <EOL><INDENT>if not closing_widget._existing:<EOL><INDENT>closing_widget.execute(\"<STR_LIT>\")<EOL><DEDENT>self.tab_widget.removeTab(current_tab)<EOL>background(kernel_manager.stop_channels)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>reply = QtGui.QMessageBox.question(self, title,<EOL>\"<STR_LIT>\"+<EOL>\"<STR_LIT>\",<EOL>okay|cancel,<EOL>defaultButton=okay<EOL>)<EOL>if reply == okay:<EOL><INDENT>self.tab_widget.removeTab(current_tab)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>elif keepkernel: <EOL><INDENT>self.tab_widget.removeTab(current_tab)<EOL>background(kernel_manager.stop_channels)<EOL><DEDENT>else: <EOL><INDENT>self.tab_widget.removeTab(current_tab)<EOL>if kernel_manager and kernel_manager.channels_running:<EOL><INDENT>for slave in slave_tabs:<EOL><INDENT>background(slave.kernel_manager.stop_channels)<EOL>self.tab_widget.removeTab(self.tab_widget.indexOf(slave))<EOL><DEDENT>kernel_manager.shutdown_kernel()<EOL>background(kernel_manager.stop_channels)<EOL><DEDENT><DEDENT>self.update_tab_bar_visibility()<EOL>", "docstring": "Called when you need to try to close a tab.\n\n        It takes the number of the tab to be closed as argument, or a reference\n        to the widget inside this tab", "id": "f21649:c0:m6"}
{"signature": "def find_master_tab(self,tab,as_list=False):", "body": "<EOL>if isinstance(tab, int):<EOL><INDENT>tab = self.tab_widget.widget(tab)<EOL><DEDENT>km=tab.kernel_manager<EOL>widget_list = [self.tab_widget.widget(i) for i in range(self.tab_widget.count())]<EOL>filtered_widget_list = [ widget for widget in widget_list if<EOL>widget.kernel_manager.connection_file == km.connection_file and<EOL>hasattr(widget,'<STR_LIT>') ]<EOL>master_widget= [ widget for widget in filtered_widget_list if widget._may_close]<EOL>if as_list:<EOL><INDENT>return master_widget<EOL><DEDENT>assert(len(master_widget)<=<NUM_LIT:1> )<EOL>if len(master_widget)==<NUM_LIT:0>:<EOL><INDENT>return None<EOL><DEDENT>return master_widget[<NUM_LIT:0>]<EOL>", "docstring": "Try to return the frontend that owns the kernel attached to the given widget/tab.\n\n    Only finds frontend owned by the current application. Selection\n    based on port of the kernel might be inaccurate if several kernel\n    on different ip use same port number.\n\n    This function does the conversion tabNumber/widget if needed.\n    Might return None if no master widget (non local kernel)\n    Will crash IPython if more than 1 masterWidget\n\n    When asList set to True, always return a list of widget(s) owning\n    the kernel. The list might be empty or containing several Widget.", "id": "f21649:c0:m11"}
{"signature": "def populate_all_magic_menu(self, listofmagic=None):", "body": "for k,v in self._magic_menu_dict.items():<EOL><INDENT>v.clear()<EOL><DEDENT>self.all_magic_menu.clear()<EOL>protected_magic = set([\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\",\"<STR_LIT>\"])<EOL>mlist=ast.literal_eval(listofmagic)<EOL>for magic in mlist:<EOL><INDENT>cell = (magic['<STR_LIT:type>'] == '<STR_LIT>')<EOL>name = magic['<STR_LIT:name>']<EOL>mclass = magic['<STR_LIT:class>']<EOL>if cell :<EOL><INDENT>prefix='<STR_LIT>'<EOL><DEDENT>else :<EOL><INDENT>prefix='<STR_LIT:%>'<EOL><DEDENT>magic_menu = self._get_magic_menu(mclass)<EOL>if name in protected_magic:<EOL><INDENT>suffix = '<STR_LIT:?>'<EOL><DEDENT>else :<EOL><INDENT>suffix = '<STR_LIT>'<EOL><DEDENT>pmagic = '<STR_LIT>'%(prefix,name,suffix)<EOL>xaction = QtGui.QAction(pmagic,<EOL>self,<EOL>triggered=self._make_dynamic_magic(pmagic)<EOL>)<EOL>magic_menu.addAction(xaction)<EOL>self.all_magic_menu.addAction(xaction)<EOL><DEDENT>", "docstring": "Clean \"All Magics...\" menu and repopulate it with `listofmagic`\n\n        Parameters\n        ----------\n        listofmagic : string,\n            repr() of a list of strings, send back by the kernel\n\n        Notes\n        -----\n        `listofmagic`is a repr() of list because it is fed with the result of\n        a 'user_expression'", "id": "f21649:c0:m20"}
{"signature": "def history_tail(self, n=<NUM_LIT:10>):", "body": "return self._history[-n:]<EOL>", "docstring": "Get the local history list.\n\n        Parameters:\n        -----------\n        n : int\n            The (maximum) number of history items to get.", "id": "f21650:c0:m6"}
{"signature": "def execute(self, source=None, hidden=False, interactive=False):", "body": "if not hidden:<EOL><INDENT>history = self.input_buffer if source is None else source<EOL><DEDENT>executed = super(HistoryConsoleWidget, self).execute(<EOL>source, hidden, interactive)<EOL>if executed and not hidden:<EOL><INDENT>history = history.rstrip()<EOL>if history and (not self._history or self._history[-<NUM_LIT:1>] != history):<EOL><INDENT>self._history.append(history)<EOL><DEDENT>self._history_edits = {}<EOL>self._history_index = len(self._history)<EOL><DEDENT>return executed<EOL>", "docstring": "Reimplemented to the store history.", "id": "f21650:c0:m1"}
{"signature": "def _get_edited_history(self, index):", "body": "if index in self._history_edits:<EOL><INDENT>return self._history_edits[index]<EOL><DEDENT>elif index == len(self._history):<EOL><INDENT>return unicode()<EOL><DEDENT>return self._history[index]<EOL>", "docstring": "Retrieves a history item, possibly with temporary edits.", "id": "f21650:c0:m11"}
{"signature": "def _append_plain_text(self, text, before_prompt=False):", "body": "self._append_custom(self._insert_plain_text, text, before_prompt)<EOL>", "docstring": "Appends plain text, processing ANSI codes if enabled.", "id": "f21651:c0:m38"}
{"signature": "def _get_cursor(self):", "body": "return self._control.textCursor()<EOL>", "docstring": "Convenience method that returns a cursor for the current position.", "id": "f21651:c0:m51"}
{"signature": "def _append_custom(self, insert, input, before_prompt=False):", "body": "<EOL>cursor = self._control.textCursor()<EOL>if before_prompt and (self._reading or not self._executing):<EOL><INDENT>cursor.setPosition(self._append_before_prompt_pos)<EOL><DEDENT>else:<EOL><INDENT>cursor.movePosition(QtGui.QTextCursor.End)<EOL><DEDENT>start_pos = cursor.position()<EOL>result = insert(cursor, input)<EOL>if before_prompt and not self._executing:<EOL><INDENT>diff = cursor.position() - start_pos<EOL>self._append_before_prompt_pos += diff<EOL>self._prompt_pos += diff<EOL><DEDENT>return result<EOL>", "docstring": "A low-level method for appending content to the end of the buffer.\n\n        If 'before_prompt' is enabled, the content will be inserted before the\n        current prompt, if there is one.", "id": "f21651:c0:m35"}
{"signature": "def _get_font(self):", "body": "return self._control.document().defaultFont()<EOL>", "docstring": "The base font being used by the ConsoleWidget.", "id": "f21651:c0:m14"}
{"signature": "def _get_end_cursor(self):", "body": "cursor = self._control.textCursor()<EOL>cursor.movePosition(QtGui.QTextCursor.End)<EOL>return cursor<EOL>", "docstring": "Convenience method that returns a cursor for the last character.", "id": "f21651:c0:m52"}
{"signature": "def print_(self, printer = None):", "body": "if (not printer):<EOL><INDENT>printer = QtGui.QPrinter()<EOL>if(QtGui.QPrintDialog(printer).exec_() != QtGui.QDialog.Accepted):<EOL><INDENT>return<EOL><DEDENT><DEDENT>self._control.print_(printer)<EOL>", "docstring": "Print the contents of the ConsoleWidget to the specified QPrinter.", "id": "f21651:c0:m17"}
{"signature": "def _set_continuation_prompt(self, prompt, html=False):", "body": "if html:<EOL><INDENT>self._continuation_prompt_html = prompt<EOL><DEDENT>else:<EOL><INDENT>self._continuation_prompt = prompt<EOL>self._continuation_prompt_html = None<EOL><DEDENT>", "docstring": "Sets the continuation prompt.\n\n        Parameters\n        ----------\n        prompt : str\n            The prompt to show when more input is needed.\n\n        html : bool, optional (default False)\n            If set, the prompt will be inserted as formatted HTML. Otherwise,\n            the prompt will be treated as plain text, though ANSI color codes\n            will be handled.", "id": "f21651:c0:m72"}
{"signature": "def _get_block_plain_text(self, block):", "body": "cursor = QtGui.QTextCursor(block)<EOL>cursor.movePosition(QtGui.QTextCursor.StartOfBlock)<EOL>cursor.movePosition(QtGui.QTextCursor.EndOfBlock,<EOL>QtGui.QTextCursor.KeepAnchor)<EOL>return cursor.selection().toPlainText()<EOL>", "docstring": "Given a QTextBlock, return its unformatted text.", "id": "f21651:c0:m50"}
{"signature": "def undo(self):", "body": "self._control.undo()<EOL>", "docstring": "Undo the last operation. If there is no operation to undo, nothing\n            happens.", "id": "f21651:c0:m27"}
{"signature": "def _append_html(self, html, before_prompt=False):", "body": "self._append_custom(self._insert_html, html, before_prompt)<EOL>", "docstring": "Appends HTML at the end of the console buffer.", "id": "f21651:c0:m36"}
{"signature": "def _event_filter_page_keypress(self, event):", "body": "key = event.key()<EOL>ctrl_down = self._control_key_down(event.modifiers())<EOL>alt_down = event.modifiers() & QtCore.Qt.AltModifier<EOL>if ctrl_down:<EOL><INDENT>if key == QtCore.Qt.Key_O:<EOL><INDENT>self._control.setFocus()<EOL>intercept = True<EOL><DEDENT><DEDENT>elif alt_down:<EOL><INDENT>if key == QtCore.Qt.Key_Greater:<EOL><INDENT>self._page_control.moveCursor(QtGui.QTextCursor.End)<EOL>intercepted = True<EOL><DEDENT>elif key == QtCore.Qt.Key_Less:<EOL><INDENT>self._page_control.moveCursor(QtGui.QTextCursor.Start)<EOL>intercepted = True<EOL><DEDENT><DEDENT>elif key in (QtCore.Qt.Key_Q, QtCore.Qt.Key_Escape):<EOL><INDENT>if self._splitter:<EOL><INDENT>self._page_control.hide()<EOL>self._control.setFocus()<EOL><DEDENT>else:<EOL><INDENT>self.layout().setCurrentWidget(self._control)<EOL><DEDENT>return True<EOL><DEDENT>elif key in (QtCore.Qt.Key_Enter, QtCore.Qt.Key_Return,<EOL>QtCore.Qt.Key_Tab):<EOL><INDENT>new_event = QtGui.QKeyEvent(QtCore.QEvent.KeyPress,<EOL>QtCore.Qt.Key_PageDown,<EOL>QtCore.Qt.NoModifier)<EOL>QtGui.qApp.sendEvent(self._page_control, new_event)<EOL>return True<EOL><DEDENT>elif key == QtCore.Qt.Key_Backspace:<EOL><INDENT>new_event = QtGui.QKeyEvent(QtCore.QEvent.KeyPress,<EOL>QtCore.Qt.Key_PageUp,<EOL>QtCore.Qt.NoModifier)<EOL>QtGui.qApp.sendEvent(self._page_control, new_event)<EOL>return True<EOL><DEDENT>return False<EOL>", "docstring": "Filter key events for the paging widget to create console-like\n            interface.", "id": "f21651:c0:m48"}
{"signature": "def _insert_continuation_prompt(self, cursor):", "body": "if self._continuation_prompt_html is None:<EOL><INDENT>self._insert_plain_text(cursor, self._continuation_prompt)<EOL><DEDENT>else:<EOL><INDENT>self._continuation_prompt = self._insert_html_fetching_plain_text(<EOL>cursor, self._continuation_prompt_html)<EOL><DEDENT>", "docstring": "Inserts new continuation prompt using the specified cursor.", "id": "f21651:c0:m60"}
{"signature": "def _prompt_finished_hook(self):", "body": "pass<EOL>", "docstring": "Called immediately after a prompt is finished, i.e. when some input\n            will be processed and a new prompt displayed.", "id": "f21651:c0:m31"}
{"signature": "def _set_font(self, font):", "body": "font_metrics = QtGui.QFontMetrics(font)<EOL>self._control.setTabStopWidth(self.tab_width * font_metrics.width('<STR_LIT:U+0020>'))<EOL>self._completion_widget.setFont(font)<EOL>self._control.document().setDefaultFont(font)<EOL>if self._page_control:<EOL><INDENT>self._page_control.document().setDefaultFont(font)<EOL><DEDENT>self.font_changed.emit(font)<EOL>", "docstring": "Sets the base font for the ConsoleWidget to the specified QFont.", "id": "f21651:c0:m15"}
{"signature": "def cut(self):", "body": "self.copy()<EOL>if self.can_cut():<EOL><INDENT>self._control.textCursor().removeSelectedText()<EOL><DEDENT>", "docstring": "Copy the currently selected text to the clipboard and delete it\n            if it's inside the input buffer.", "id": "f21651:c0:m9"}
{"signature": "def can_copy(self):", "body": "return self._control.textCursor().hasSelection()<EOL>", "docstring": "Returns whether text can be copied to the clipboard.", "id": "f21651:c0:m4"}
{"signature": "def _prompt_started(self):", "body": "<EOL>self._control.document().setMaximumBlockCount(<NUM_LIT:0>)<EOL>self._control.setUndoRedoEnabled(True)<EOL>self._control.setReadOnly(False)<EOL>self._control.setAttribute(QtCore.Qt.WA_InputMethodEnabled, True)<EOL>if not self._reading:<EOL><INDENT>self._executing = False<EOL><DEDENT>self._prompt_started_hook()<EOL>if self._input_buffer_pending:<EOL><INDENT>self.input_buffer = self._input_buffer_pending<EOL>self._input_buffer_pending = '<STR_LIT>'<EOL><DEDENT>self._control.moveCursor(QtGui.QTextCursor.End)<EOL>", "docstring": "Called immediately after a new prompt is displayed.", "id": "f21651:c0:m70"}
{"signature": "def _context_menu_make(self, pos):", "body": "menu = QtGui.QMenu(self)<EOL>self.cut_action = menu.addAction('<STR_LIT>', self.cut)<EOL>self.cut_action.setEnabled(self.can_cut())<EOL>self.cut_action.setShortcut(QtGui.QKeySequence.Cut)<EOL>self.copy_action = menu.addAction('<STR_LIT>', self.copy)<EOL>self.copy_action.setEnabled(self.can_copy())<EOL>self.copy_action.setShortcut(QtGui.QKeySequence.Copy)<EOL>self.paste_action = menu.addAction('<STR_LIT>', self.paste)<EOL>self.paste_action.setEnabled(self.can_paste())<EOL>self.paste_action.setShortcut(QtGui.QKeySequence.Paste)<EOL>menu.addSeparator()<EOL>menu.addAction(self.select_all_action)<EOL>menu.addSeparator()<EOL>menu.addAction(self.export_action)<EOL>menu.addAction(self.print_action)<EOL>return menu<EOL>", "docstring": "Creates a context menu for the given QPoint (in widget coordinates).", "id": "f21651:c0:m43"}
{"signature": "def _keep_cursor_in_buffer(self):", "body": "moved = not self._in_buffer()<EOL>if moved:<EOL><INDENT>cursor = self._control.textCursor()<EOL>cursor.movePosition(QtGui.QTextCursor.End)<EOL>self._control.setTextCursor(cursor)<EOL><DEDENT>return moved<EOL>", "docstring": "Ensures that the cursor is inside the editing region. Returns\n            whether the cursor was moved.", "id": "f21651:c0:m66"}
{"signature": "def _get_input_buffer(self, force=False):", "body": "<EOL>if self._executing and not force:<EOL><INDENT>return self._input_buffer_executing<EOL><DEDENT>cursor = self._get_end_cursor()<EOL>cursor.setPosition(self._prompt_pos, QtGui.QTextCursor.KeepAnchor)<EOL>input_buffer = cursor.selection().toPlainText()<EOL>return input_buffer.replace('<STR_LIT:\\n>' + self._continuation_prompt, '<STR_LIT:\\n>')<EOL>", "docstring": "The text that the user has entered entered at the current prompt.\n\n        If the console is currently executing, the text that is executing will\n        always be returned.", "id": "f21651:c0:m12"}
{"signature": "def _get_prompt_cursor(self):", "body": "cursor = self._control.textCursor()<EOL>cursor.setPosition(self._prompt_pos)<EOL>return cursor<EOL>", "docstring": "Convenience method that returns a cursor for the prompt position.", "id": "f21651:c0:m56"}
{"signature": "def change_font_size(self, delta):", "body": "font = self.font<EOL>size = max(font.pointSize() + delta, <NUM_LIT:1>) <EOL>font.setPointSize(size)<EOL>self._set_font(font)<EOL>", "docstring": "Change the font size by the specified amount (in points).", "id": "f21651:c0:m21"}
{"signature": "def _context_menu_make(self, pos):", "body": "menu = super(FrontendWidget, self)._context_menu_make(pos)<EOL>for before_action in menu.actions():<EOL><INDENT>if before_action.shortcut().matches(QtGui.QKeySequence.Paste) ==QtGui.QKeySequence.ExactMatch:<EOL><INDENT>menu.insertAction(before_action, self._copy_raw_action)<EOL>break<EOL><DEDENT><DEDENT>return menu<EOL>", "docstring": "Reimplemented to add an action for raw copy.", "id": "f21652:c1:m7"}
{"signature": "def _show_interpreter_prompt_for_reply(self, msg):", "body": "self._show_interpreter_prompt()<EOL>", "docstring": "Shows a prompt for the interpreter given an 'execute_reply' message.", "id": "f21652:c1:m36"}
{"signature": "def _insert_continuation_prompt(self, cursor):", "body": "super(FrontendWidget, self)._insert_continuation_prompt(cursor)<EOL>cursor.insertText('<STR_LIT:U+0020>' * self._input_splitter.indent_spaces)<EOL>", "docstring": "Reimplemented for auto-indentation.", "id": "f21652:c1:m11"}
{"signature": "def _handle_kernel_died(self, since_last_heartbeat):", "body": "self.log.debug(\"<STR_LIT>\", since_last_heartbeat)<EOL>if self.custom_restart:<EOL><INDENT>self.custom_restart_kernel_died.emit(since_last_heartbeat)<EOL><DEDENT>else:<EOL><INDENT>message = '<STR_LIT>''<STR_LIT>''<STR_LIT>' %since_last_heartbeat<EOL>self.restart_kernel(message, now=True)<EOL><DEDENT>", "docstring": "Handle the kernel's death by asking if the user wants to restart.", "id": "f21652:c1:m17"}
{"signature": "def _handle_shutdown_reply(self, msg):", "body": "self.log.debug(\"<STR_LIT>\", msg.get('<STR_LIT:content>', '<STR_LIT>'))<EOL>if not self._hidden and not self._is_from_this_session(msg):<EOL><INDENT>if self._local_kernel:<EOL><INDENT>if not msg['<STR_LIT:content>']['<STR_LIT>']:<EOL><INDENT>self.exit_requested.emit(self)<EOL><DEDENT>else:<EOL><INDENT>time.sleep(<NUM_LIT>) <EOL>self.reset()<EOL><DEDENT><DEDENT>else: <EOL><INDENT>title = self.window().windowTitle()<EOL>if not msg['<STR_LIT:content>']['<STR_LIT>']:<EOL><INDENT>reply = QtGui.QMessageBox.question(self, title,<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>QtGui.QMessageBox.Yes,QtGui.QMessageBox.No)<EOL>if reply == QtGui.QMessageBox.Yes:<EOL><INDENT>self.exit_requested.emit(self)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>reply = QtGui.QMessageBox.question(self, title,<EOL>\"<STR_LIT>\",<EOL>QtGui.QMessageBox.Yes,QtGui.QMessageBox.No)<EOL>if reply == QtGui.QMessageBox.Yes:<EOL><INDENT>time.sleep(<NUM_LIT>) <EOL>self.reset()<EOL><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Handle shutdown signal, only if from other console.", "id": "f21652:c1:m21"}
{"signature": "def _started_channels(self):", "body": "self.reset(clear=True)<EOL>", "docstring": "Called when the KernelManager channels have started listening or\n            when the frontend is assigned an already listening KernelManager.", "id": "f21652:c1:m22"}
{"signature": "def _handle_pyout(self, msg):", "body": "self.log.debug(\"<STR_LIT>\", msg.get('<STR_LIT:content>', '<STR_LIT>'))<EOL>if not self._hidden and self._is_from_this_session(msg):<EOL><INDENT>text = msg['<STR_LIT:content>']['<STR_LIT:data>']<EOL>self._append_plain_text(text + '<STR_LIT:\\n>', before_prompt=True)<EOL><DEDENT>", "docstring": "Handle display hook output.", "id": "f21652:c1:m19"}
{"signature": "def _process_execute_abort(self, msg):", "body": "self._append_plain_text(\"<STR_LIT>\")<EOL>", "docstring": "Process a reply for an aborted execution request.", "id": "f21652:c1:m31"}
{"signature": "def _is_complete(self, source, interactive):", "body": "complete = self._input_splitter.push(source)<EOL>if interactive:<EOL><INDENT>complete = not self._input_splitter.push_accepts_more()<EOL><DEDENT>return complete<EOL>", "docstring": "Returns whether 'source' can be completely processed and a new\n            prompt created. When triggered by an Enter/Return key press,\n            'interactive' is True; otherwise, it is False.", "id": "f21652:c1:m2"}
{"signature": "def copy_raw(self):", "body": "self._control.copy()<EOL>", "docstring": "Copy the currently selected text to the clipboard without attempting\n            to remove prompts or otherwise alter the text.", "id": "f21652:c1:m23"}
{"signature": "def _process_execute_ok(self, msg):", "body": "payload = msg['<STR_LIT:content>']['<STR_LIT>']<EOL>for item in payload:<EOL><INDENT>if not self._process_execute_payload(item):<EOL><INDENT>warning = '<STR_LIT>'<EOL>print(warning % repr(item['<STR_LIT:source>']))<EOL><DEDENT><DEDENT>", "docstring": "Process a reply for a successful execution request.", "id": "f21652:c1:m33"}
{"signature": "def _document_contents_change(self, position, removed, added):", "body": "<EOL>position += added<EOL>document = self._control.document()<EOL>if position == self._get_cursor().position():<EOL><INDENT>self._call_tip()<EOL><DEDENT>", "docstring": "Called whenever the document's content changes. Display a call tip\n            if appropriate.", "id": "f21652:c1:m37"}
{"signature": "def _show_interpreter_prompt(self):", "body": "self._show_prompt('<STR_LIT>')<EOL>", "docstring": "Shows a prompt for the interpreter.", "id": "f21652:c1:m35"}
{"signature": "def _banner_default(self):", "body": "banner = '<STR_LIT>''<STR_LIT>'<EOL>return banner % (sys.version, sys.platform)<EOL>", "docstring": "Returns the standard Python banner.", "id": "f21652:c1:m38"}
{"signature": "def reset(self, clear=False):", "body": "if self._executing:<EOL><INDENT>self._executing = False<EOL>self._request_info['<STR_LIT>'] = {}<EOL><DEDENT>self._reading = False<EOL>self._highlighter.highlighting_on = False<EOL>if self.clear_on_kernel_restart or clear:<EOL><INDENT>self._control.clear()<EOL>self._append_plain_text(self.banner)<EOL><DEDENT>else:<EOL><INDENT>self._append_plain_text(\"<STR_LIT>\")<EOL>self._append_html(\"<STR_LIT>\")<EOL><DEDENT>self._append_before_prompt_pos = self._get_cursor().position()<EOL>self._show_interpreter_prompt()<EOL>", "docstring": "Resets the widget to its initial state if ``clear`` parameter or\n        ``clear_on_kernel_restart`` configuration setting is True, otherwise\n        prints a visual indication of the fact that the kernel restarted, but\n        does not clear the traces from previous usage of the kernel before it\n        was restarted.  With ``clear=True``, it is similar to ``%clear``, but\n        also re-writes the banner and aborts execution if necessary.", "id": "f21652:c1:m26"}
{"signature": "def _process_execute_payload(self, item):", "body": "<EOL>return False<EOL>", "docstring": "Process a single payload item from the list of payload items in an\n            execution reply. Returns whether the payload was handled.", "id": "f21652:c1:m34"}
{"signature": "def show_items(self, cursor, items):", "body": "if not items :<EOL><INDENT>return<EOL><DEDENT>self.cancel_completion()<EOL>strng = text.columnize(items)<EOL>self._console_widget._fill_temporary_buffer(cursor, strng, html=False)<EOL>", "docstring": "Shows the completion widget with 'items' at the position specified\n            by 'cursor'.", "id": "f21653:c0:m3"}
{"signature": "def init_signal(self):", "body": "signal.signal(signal.SIGINT, lambda sig, frame: self.exit(-<NUM_LIT:2>))<EOL>timer = QtCore.QTimer()<EOL>timer.timeout.connect(lambda: None)<EOL>timer.start(<NUM_LIT:200>)<EOL>self._sigint_timer = timer<EOL>", "docstring": "allow clean shutdown on sigint", "id": "f21654:c0:m6"}
{"signature": "def show_items(self, cursor, items):", "body": "text_edit = self._text_edit<EOL>point = text_edit.cursorRect(cursor).bottomRight()<EOL>point = text_edit.mapToGlobal(point)<EOL>height = self.sizeHint().height()<EOL>screen_rect = QtGui.QApplication.desktop().availableGeometry(self)<EOL>if screen_rect.size().height() - point.y() - height < <NUM_LIT:0>:<EOL><INDENT>point = text_edit.mapToGlobal(text_edit.cursorRect().topRight())<EOL>point.setY(point.y() - height)<EOL><DEDENT>self.move(point)<EOL>self._start_position = cursor.position()<EOL>self.clear()<EOL>self.addItems(items)<EOL>self.setCurrentRow(<NUM_LIT:0>)<EOL>self.show()<EOL>", "docstring": "Shows the completion widget with 'items' at the position specified\n            by 'cursor'.", "id": "f21655:c0:m4"}
{"signature": "def hideEvent(self, event):", "body": "super(CompletionWidget, self).hideEvent(event)<EOL>self._text_edit.cursorPositionChanged.disconnect(self._update_current)<EOL>self._text_edit.removeEventFilter(self)<EOL>", "docstring": "Reimplemented to disconnect signal handlers and event filter.", "id": "f21655:c0:m2"}
{"signature": "def __init__(self, lexer):", "body": "self.lexer = lexer<EOL>", "docstring": "Create a CompletionLexer using the specified Pygments lexer.", "id": "f21657:c0:m0"}
{"signature": "def highlightBlock(self, string):", "body": "prev_data = self.currentBlock().previous().userData()<EOL>if prev_data is not None:<EOL><INDENT>self._lexer._saved_state_stack = prev_data.syntax_stack<EOL><DEDENT>elif hasattr(self._lexer, '<STR_LIT>'):<EOL><INDENT>del self._lexer._saved_state_stack<EOL><DEDENT>index = <NUM_LIT:0><EOL>for token, text in self._lexer.get_tokens(string):<EOL><INDENT>length = len(text)<EOL>self.setFormat(index, length, self._get_format(token))<EOL>index += length<EOL><DEDENT>if hasattr(self._lexer, '<STR_LIT>'):<EOL><INDENT>data = PygmentsBlockUserData(<EOL>syntax_stack=self._lexer._saved_state_stack)<EOL>self.currentBlock().setUserData(data)<EOL>del self._lexer._saved_state_stack<EOL><DEDENT>", "docstring": "Highlight a block of text.", "id": "f21658:c1:m1"}
{"signature": "def default_image_tag(match, path = None, format = \"<STR_LIT>\"):", "body": "return '<STR_LIT>'<EOL>", "docstring": "Return (X)HTML mark-up for the image-tag given by match.\n\n    This default implementation merely removes the image, and exists mostly\n    for documentation purposes. More information than is present in the Qt\n    HTML is required to supply the images.\n\n    Parameters\n    ----------\n    match : re.SRE_Match\n        A match to an HTML image tag as exported by Qt, with match.group(\"Name\")\n        containing the matched image ID.\n\n    path : string|None, optional [default None]\n        If not None, specifies a path to which supporting files may be written\n        (e.g., for linked images).  If None, all images are to be included\n        inline.\n\n    format : \"png\"|\"svg\", optional [default \"png\"]\n        Format for returned or referenced images.", "id": "f21660:m2"}
{"signature": "def ensure_utf8(image_tag):", "body": "if py3compat.PY3:<EOL><INDENT>return image_tag<EOL><DEDENT>def utf8_image_tag(*args, **kwargs):<EOL><INDENT>s = image_tag(*args, **kwargs)<EOL>if isinstance(s, str):<EOL><INDENT>s = s.encode('<STR_LIT:utf8>')<EOL><DEDENT>return s<EOL><DEDENT>return utf8_image_tag<EOL>", "docstring": "wrapper for ensuring image_tag returns utf8-encoded str on Python 2", "id": "f21660:m3"}
{"signature": "def export_xhtml(html, filename, image_tag=None):", "body": "if image_tag is None:<EOL><INDENT>image_tag = default_image_tag<EOL><DEDENT>else:<EOL><INDENT>image_tag = ensure_utf8(image_tag)<EOL><DEDENT>with open(filename, '<STR_LIT:w>') as f:<EOL><INDENT>offset = html.find(\"<STR_LIT>\")<EOL>assert offset > -<NUM_LIT:1>, '<STR_LIT>'<EOL>html = ('<STR_LIT>'+<EOL>html[offset+<NUM_LIT:6>:])<EOL>html = fix_html(html)<EOL>f.write(IMG_RE.sub(lambda x: image_tag(x, path = None, format = \"<STR_LIT>\"),<EOL>html))<EOL><DEDENT>", "docstring": "Export the contents of the ConsoleWidget as XHTML with inline SVGs.\n\n    Parameters:\n    -----------\n    html : str,\n        A utf-8 encoded Python string containing the Qt HTML to export.\n\n    filename : str\n        The file to be saved.\n\n    image_tag : callable, optional (default None)\n        Used to convert images. See ``default_image_tag()`` for information.", "id": "f21660:m1"}
{"signature": "def _dispatch(self, msg):", "body": "msg_type = msg['<STR_LIT>']['<STR_LIT>']<EOL>handler = getattr(self, '<STR_LIT>' + msg_type, None)<EOL>if handler:<EOL><INDENT>handler(msg)<EOL><DEDENT>", "docstring": "Calls the frontend handler associated with the message type of the\n            given message.", "id": "f21661:c0:m6"}
{"signature": "def _started_kernel(self):", "body": "", "docstring": "Called when the KernelManager starts (or restarts) the kernel subprocess.\n        Channels may or may not be running at this point.", "id": "f21661:c0:m3"}
{"signature": "def _is_from_this_session(self, msg):", "body": "session = self._kernel_manager.session.session<EOL>parent = msg['<STR_LIT>']<EOL>if not parent:<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return parent.get('<STR_LIT>') == session<EOL><DEDENT>", "docstring": "Returns whether a reply from the kernel originated from a request\n            from this frontend.", "id": "f21661:c0:m7"}
{"signature": "def validate_url(url):", "body": "if not isinstance(url, str):<EOL><INDENT>raise TypeError(\"<STR_LIT>\"%type(url))<EOL><DEDENT>url = url.lower()<EOL>proto_addr = url.split('<STR_LIT>')<EOL>assert len(proto_addr) == <NUM_LIT:2>, '<STR_LIT>'%url<EOL>proto, addr = proto_addr<EOL>assert proto in ['<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>','<STR_LIT>'], \"<STR_LIT>\"%proto<EOL>pat = re.compile(r'<STR_LIT>')<EOL>if proto == '<STR_LIT>':<EOL><INDENT>lis = addr.split('<STR_LIT::>')<EOL>assert len(lis) == <NUM_LIT:2>, '<STR_LIT>'%url<EOL>addr,s_port = lis<EOL>try:<EOL><INDENT>port = int(s_port)<EOL><DEDENT>except ValueError:<EOL><INDENT>raise AssertionError(\"<STR_LIT>\"%(port, url))<EOL><DEDENT>assert addr == '<STR_LIT:*>' or pat.match(addr) is not None, '<STR_LIT>'%url<EOL><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>return True<EOL>", "docstring": "validate a url for zeromq", "id": "f21663:m2"}
{"signature": "def __setattr__(self, key, value):", "body": "if hasattr(dict, key):<EOL><INDENT>raise KeyError(\"<STR_LIT>\"%key)<EOL><DEDENT>self[key] = value<EOL>", "docstring": "setattr aliased to setitem, with strict", "id": "f21663:c0:m1"}
{"signature": "@interactive<EOL>def _execute(code):", "body": "exec(code, globals())<EOL>", "docstring": "helper method for implementing `client.execute` via `client.apply`", "id": "f21663:m10"}
{"signature": "@interactive<EOL>def _pull(keys):", "body": "user_ns = globals()<EOL>if isinstance(keys, (list,tuple, set)):<EOL><INDENT>for key in keys:<EOL><INDENT>if key not in user_ns:<EOL><INDENT>raise NameError(\"<STR_LIT>\"%key)<EOL><DEDENT><DEDENT>return list(map(user_ns.get, keys))<EOL><DEDENT>else:<EOL><INDENT>if keys not in user_ns:<EOL><INDENT>raise NameError(\"<STR_LIT>\"%keys)<EOL><DEDENT>return user_ns.get(keys)<EOL><DEDENT>", "docstring": "helper method for implementing `client.pull` via `client.apply`", "id": "f21663:m9"}
{"signature": "def select_random_ports(n):", "body": "ports = []<EOL>for i in range(n):<EOL><INDENT>sock = socket.socket()<EOL>sock.bind(('<STR_LIT>', <NUM_LIT:0>))<EOL>while sock.getsockname()[<NUM_LIT:1>] in _random_ports:<EOL><INDENT>sock.close()<EOL>sock = socket.socket()<EOL>sock.bind(('<STR_LIT>', <NUM_LIT:0>))<EOL><DEDENT>ports.append(sock)<EOL><DEDENT>for i, sock in enumerate(ports):<EOL><INDENT>port = sock.getsockname()[<NUM_LIT:1>]<EOL>sock.close()<EOL>ports[i] = port<EOL>_random_ports.add(port)<EOL><DEDENT>return ports<EOL>", "docstring": "Selects and return n random ports that are available.", "id": "f21663:m11"}
{"signature": "def write_pid_file(self, overwrite=False):", "body": "pid_file = os.path.join(self.profile_dir.pid_dir, self.name + u'<STR_LIT>')<EOL>if os.path.isfile(pid_file):<EOL><INDENT>pid = self.get_pid_from_file()<EOL>if not overwrite:<EOL><INDENT>raise PIDFileError(<EOL>'<STR_LIT>'<EOL>'<STR_LIT>' % (pid_file, pid)<EOL>)<EOL><DEDENT><DEDENT>with open(pid_file, '<STR_LIT:w>') as f:<EOL><INDENT>self.log.info(\"<STR_LIT>\" % pid_file)<EOL>f.write(repr(os.getpid())+'<STR_LIT:\\n>')<EOL><DEDENT>", "docstring": "Create a .pid file in the pid_dir with my pid.\n\n        This must be called after pre_construct, which sets `self.pid_dir`.\n        This raises :exc:`PIDFileError` if the pid file exists already.", "id": "f21665:c2:m9"}
{"signature": "def _log_format_default(self):", "body": "return u\"<STR_LIT>\"<EOL>", "docstring": "override default log format to include time", "id": "f21665:c2:m1"}
{"signature": "def bind_kernel(self, **kwargs):", "body": "if self.kernel_app is not None:<EOL><INDENT>return<EOL><DEDENT>self.log.info(\"<STR_LIT>\")<EOL>kernel = self.kernel<EOL>kwargs.setdefault('<STR_LIT>', self.config)<EOL>kwargs.setdefault('<STR_LIT>', self.log)<EOL>kwargs.setdefault('<STR_LIT>', self.profile_dir)<EOL>kwargs.setdefault('<STR_LIT>', self.engine.session)<EOL>app = self.kernel_app = IPKernelApp(**kwargs)<EOL>IPKernelApp._instance = app<EOL>app.init_connection_file()<EOL>app.shell_port = app._bind_socket(kernel.shell_streams[<NUM_LIT:0>], app.shell_port)<EOL>app.log.debug(\"<STR_LIT>\", app.shell_port)<EOL>app.iopub_port = app._bind_socket(kernel.iopub_socket, app.iopub_port)<EOL>app.log.debug(\"<STR_LIT>\", app.iopub_port)<EOL>kernel.stdin_socket = self.engine.context.socket(zmq.ROUTER)<EOL>app.stdin_port = app._bind_socket(kernel.stdin_socket, app.stdin_port)<EOL>app.log.debug(\"<STR_LIT>\", app.stdin_port)<EOL>app.init_heartbeat()<EOL>app.log_connection_info()<EOL>app.write_connection_file()<EOL>", "docstring": "Promote engine to listening kernel, accessible to frontends.", "id": "f21666:c1:m4"}
{"signature": "def add_task(self, task):", "body": "self.tasks.append(task)<EOL>", "docstring": "Add a task to the job.\n\n        Parameters\n        ----------\n        task : :class:`WinHPCTask`\n            The task object to add.", "id": "f21669:c0:m5"}
{"signature": "def write(self, filename):", "body": "txt = self.tostring()<EOL>with open(filename, '<STR_LIT:w>') as f:<EOL><INDENT>f.write(txt)<EOL><DEDENT>", "docstring": "Write the XML job description to a file.", "id": "f21669:c0:m4"}
{"signature": "def start(self):", "body": "try:<EOL><INDENT>pid = self.get_pid_from_file()<EOL><DEDENT>except PIDFileError:<EOL><INDENT>self.log.critical(<EOL>'<STR_LIT>'<EOL>)<EOL>self.remove_pid_file()<EOL>self.exit(ALREADY_STOPPED)<EOL><DEDENT>if not self.check_pid(pid):<EOL><INDENT>self.log.critical(<EOL>'<STR_LIT>' % pid<EOL>)<EOL>self.remove_pid_file()<EOL>self.exit(ALREADY_STOPPED)<EOL><DEDENT>elif os.name=='<STR_LIT>':<EOL><INDENT>sig = self.signal<EOL>self.log.info(<EOL>\"<STR_LIT>\" % (pid, sig)<EOL>)<EOL>try:<EOL><INDENT>os.kill(pid, sig)<EOL><DEDENT>except OSError:<EOL><INDENT>self.log.error(\"<STR_LIT>\",<EOL>exc_info=True)<EOL>self.remove_pid_file()<EOL><DEDENT><DEDENT>elif os.name=='<STR_LIT>':<EOL><INDENT>try:<EOL><INDENT>p = check_call(['<STR_LIT>', '<STR_LIT>', str(pid), '<STR_LIT>', '<STR_LIT>'], stdout=PIPE,stderr=PIPE)<EOL><DEDENT>except (CalledProcessError, OSError):<EOL><INDENT>self.log.error(\"<STR_LIT>\",<EOL>exc_info=True)<EOL><DEDENT>self.remove_pid_file()<EOL><DEDENT>", "docstring": "Start the app for the stop subcommand.", "id": "f21670:c0:m0"}
{"signature": "def launch_new_instance():", "body": "app = IPClusterApp.instance()<EOL>app.initialize()<EOL>app.start()<EOL>", "docstring": "Create and run the IPython cluster.", "id": "f21670:m1"}
{"signature": "def start(self):", "body": "self.log.info(\"<STR_LIT>\")<EOL>self.log.info(<EOL>'<STR_LIT>' % self.daemonize<EOL>)<EOL>if self.daemonize:<EOL><INDENT>if os.name=='<STR_LIT>':<EOL><INDENT>daemonize()<EOL><DEDENT><DEDENT>dc = ioloop.DelayedCallback(self.start_engines, <NUM_LIT:0>, self.loop)<EOL>dc.start()<EOL>try:<EOL><INDENT>self.loop.start()<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>pass<EOL><DEDENT>except zmq.ZMQError as e:<EOL><INDENT>if e.errno == errno.EINTR:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>raise<EOL><DEDENT><DEDENT>", "docstring": "Start the app for the engines subcommand.", "id": "f21670:c1:m15"}
{"signature": "def start(self, n):", "body": "<EOL>self.write_batch_script(n)<EOL>piped_cmd = self.args[<NUM_LIT:0>]+'<STR_LIT>'+self.args[<NUM_LIT:1>]+'<STR_LIT>'<EOL>self.log.debug(\"<STR_LIT>\", self.__class__.__name__, piped_cmd)<EOL>p = Popen(piped_cmd, shell=True,env=os.environ,stdout=PIPE)<EOL>output,err = p.communicate()<EOL>job_id = self.parse_job_id(output)<EOL>self.notify_start(job_id)<EOL>return job_id<EOL>", "docstring": "Start n copies of the process using LSF batch system.\n        This cant inherit from the base class because bsub expects\n        to be piped a shell script in order to honor the #BSUB directives :\n        bsub < script", "id": "f21671:c35:m0"}
{"signature": "def find_args(self):", "body": "return self.mpi_cmd + ['<STR_LIT>', str(self.n)] + self.mpi_args +self.program + self.program_args<EOL>", "docstring": "Build self.args using all the fields.", "id": "f21671:c11:m1"}
{"signature": "def start(self, n):", "body": "return super(WindowsHPCEngineSetLauncher, self).start(n)<EOL>", "docstring": "Start the controller by profile_dir.", "id": "f21671:c26:m2"}
{"signature": "def write_batch_script(self, n):", "body": "self.n = n<EOL>if self.batch_template_file and not self.batch_template:<EOL><INDENT>with open(self.batch_template_file) as f:<EOL><INDENT>self.batch_template = f.read()<EOL><DEDENT><DEDENT>if not self.batch_template:<EOL><INDENT>self.batch_template = self.default_template<EOL>if not self.job_array_regexp.search(self.batch_template):<EOL><INDENT>self.log.debug(\"<STR_LIT>\")<EOL>firstline, rest = self.batch_template.split('<STR_LIT:\\n>',<NUM_LIT:1>)<EOL>self.batch_template = u'<STR_LIT:\\n>'.join([firstline, self.job_array_template, rest])<EOL><DEDENT>if self.queue and not self.queue_regexp.search(self.batch_template):<EOL><INDENT>self.log.debug(\"<STR_LIT>\")<EOL>firstline, rest = self.batch_template.split('<STR_LIT:\\n>',<NUM_LIT:1>)<EOL>self.batch_template = u'<STR_LIT:\\n>'.join([firstline, self.queue_template, rest])<EOL><DEDENT><DEDENT>script_as_string = self.formatter.format(self.batch_template, **self.context)<EOL>self.log.debug('<STR_LIT>', self.batch_file)<EOL>with open(self.batch_file, '<STR_LIT:w>') as f:<EOL><INDENT>f.write(script_as_string)<EOL><DEDENT>os.chmod(self.batch_file, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR)<EOL>", "docstring": "Instantiate and write the batch script to the work_dir.", "id": "f21671:c28:m5"}
{"signature": "def start(self):", "body": "return super(LSFControllerLauncher, self).start(<NUM_LIT:1>)<EOL>", "docstring": "Start the controller by profile or profile_dir.", "id": "f21671:c36:m0"}
{"signature": "@property<EOL><INDENT>def running(self):<DEDENT>", "body": "if self.state == '<STR_LIT>':<EOL><INDENT>return True<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT>", "docstring": "Am I running.", "id": "f21671:c3:m5"}
{"signature": "@property<EOL><INDENT>def arg_str(self):<DEDENT>", "body": "return '<STR_LIT:U+0020>'.join(self.args)<EOL>", "docstring": "The string form of the program arguments.", "id": "f21671:c3:m4"}
{"signature": "def save_connection_dict(self, fname, cdict):", "body": "c = self.config<EOL>url = cdict['<STR_LIT:url>']<EOL>location = cdict['<STR_LIT:location>']<EOL>if not location:<EOL><INDENT>try:<EOL><INDENT>proto,ip,port = split_url(url)<EOL><DEDENT>except AssertionError:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>location = socket.gethostbyname_ex(socket.gethostname())[<NUM_LIT:2>][-<NUM_LIT:1>]<EOL><DEDENT>except (socket.gaierror, IndexError):<EOL><INDENT>self.log.warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>location = '<STR_LIT:127.0.0.1>'<EOL><DEDENT><DEDENT>cdict['<STR_LIT:location>'] = location<EOL><DEDENT>fname = os.path.join(self.profile_dir.security_dir, fname)<EOL>self.log.info(\"<STR_LIT>\", fname)<EOL>with open(fname, '<STR_LIT:w>') as f:<EOL><INDENT>f.write(json.dumps(cdict, indent=<NUM_LIT:2>))<EOL><DEDENT>os.chmod(fname, stat.S_IRUSR|stat.S_IWUSR)<EOL>", "docstring": "save a connection dict to json file.", "id": "f21672:c0:m2"}
{"signature": "def connect_client(self):", "body": "c = Client(profile='<STR_LIT>', context=self.context)<EOL>for name in [n for n in dir(c) if n.endswith('<STR_LIT>')]:<EOL><INDENT>s = getattr(c, name)<EOL>s.setsockopt(zmq.LINGER, <NUM_LIT:0>)<EOL>self.sockets.append(s)<EOL><DEDENT>return c<EOL>", "docstring": "connect a client with my Context, and track its sockets for cleanup", "id": "f21682:c0:m3"}
{"signature": "def segfault():", "body": "import ctypes<EOL>ctypes.memset(-<NUM_LIT:1>,<NUM_LIT:0>,<NUM_LIT:1>)<EOL>", "docstring": "this will segfault", "id": "f21682:m0"}
{"signature": "def minimum_engines(self, n=<NUM_LIT:1>, block=True):", "body": "self.engines.extend(add_engines(n, total=True))<EOL>if block:<EOL><INDENT>self.wait_on_engines()<EOL><DEDENT>", "docstring": "add engines until there are at least n connected", "id": "f21682:c0:m1"}
{"signature": "def maybe_run(self, job):", "body": "msg_id = job.msg_id<EOL>self.log.debug(\"<STR_LIT>\", msg_id)<EOL>if not self.targets:<EOL><INDENT>return False<EOL><DEDENT>if job.follow or job.targets or job.blacklist or self.hwm:<EOL><INDENT>def can_run(idx):<EOL><INDENT>if self.hwm and self.loads[idx] == self.hwm:<EOL><INDENT>return False<EOL><DEDENT>target = self.targets[idx]<EOL>if target in job.blacklist:<EOL><INDENT>return False<EOL><DEDENT>if job.targets and target not in job.targets:<EOL><INDENT>return False<EOL><DEDENT>return job.follow.check(self.completed[target], self.failed[target])<EOL><DEDENT>indices = filter(can_run, range(len(self.targets)))<EOL>if not indices:<EOL><INDENT>if job.follow.all:<EOL><INDENT>dests = set()<EOL>relevant = set()<EOL>if job.follow.success:<EOL><INDENT>relevant = self.all_completed<EOL><DEDENT>if job.follow.failure:<EOL><INDENT>relevant = relevant.union(self.all_failed)<EOL><DEDENT>for m in job.follow.intersection(relevant):<EOL><INDENT>dests.add(self.destinations[m])<EOL><DEDENT>if len(dests) > <NUM_LIT:1>:<EOL><INDENT>self.depending[msg_id] = job<EOL>self.fail_unreachable(msg_id)<EOL>return False<EOL><DEDENT><DEDENT>if job.targets:<EOL><INDENT>job.targets.difference_update(job.blacklist)<EOL>if not job.targets or not job.targets.intersection(self.targets):<EOL><INDENT>self.depending[msg_id] = job<EOL>self.fail_unreachable(msg_id)<EOL>return False<EOL><DEDENT><DEDENT>return False<EOL><DEDENT><DEDENT>else:<EOL><INDENT>indices = None<EOL><DEDENT>self.submit_task(job, indices)<EOL>return True<EOL>", "docstring": "check location dependencies, and run if they are met.", "id": "f21685:c1:m13"}
{"signature": "def save_unmet(self, job):", "body": "msg_id = job.msg_id<EOL>self.depending[msg_id] = job<EOL>for dep_id in job.after.union(job.follow).difference(self.all_done):<EOL><INDENT>if dep_id not in self.graph:<EOL><INDENT>self.graph[dep_id] = set()<EOL><DEDENT>self.graph[dep_id].add(msg_id)<EOL><DEDENT>", "docstring": "Save a message for later submission when its dependencies are met.", "id": "f21685:c1:m14"}
{"signature": "def update_graph(self, dep_id=None, success=True):", "body": "<EOL>jobs = self.graph.pop(dep_id, [])<EOL>if dep_id is None or self.hwm and any( [ load==self.hwm-<NUM_LIT:1> for load in self.loads ]):<EOL><INDENT>jobs = self.depending.keys()<EOL><DEDENT>for msg_id in sorted(jobs, key=lambda msg_id: self.depending[msg_id].timestamp):<EOL><INDENT>job = self.depending[msg_id]<EOL>if job.after.unreachable(self.all_completed, self.all_failed)or job.follow.unreachable(self.all_completed, self.all_failed):<EOL><INDENT>self.fail_unreachable(msg_id)<EOL><DEDENT>elif job.after.check(self.all_completed, self.all_failed): <EOL><INDENT>if self.maybe_run(job):<EOL><INDENT>self.depending.pop(msg_id)<EOL>for mid in job.dependents:<EOL><INDENT>if mid in self.graph:<EOL><INDENT>self.graph[mid].remove(msg_id)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "dep_id just finished. Update our dependency\n        graph and submit any jobs that just became runable.\n\n        Called with dep_id=None to update entire graph for hwm, but without finishing\n        a task.", "id": "f21685:c1:m19"}
{"signature": "def audit_timeouts(self):", "body": "now = datetime.now()<EOL>for msg_id in self.depending.keys():<EOL><INDENT>if msg_id in self.depending:<EOL><INDENT>job = self.depending[msg_id]<EOL>if job.timeout and job.timeout < now:<EOL><INDENT>self.fail_unreachable(msg_id, error.TaskTimeout)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Audit all waiting tasks for expired timeouts.", "id": "f21685:c1:m11"}
{"signature": "def resume_receiving(self):", "body": "self.client_stream.on_recv(self.dispatch_submission, copy=False)<EOL>", "docstring": "Resume accepting jobs.", "id": "f21685:c1:m4"}
{"signature": "@util.log_errors<EOL><INDENT>def dispatch_notification(self, msg):<DEDENT>", "body": "try:<EOL><INDENT>idents,msg = self.session.feed_identities(msg)<EOL><DEDENT>except ValueError:<EOL><INDENT>self.log.warn(\"<STR_LIT>\",msg)<EOL>return<EOL><DEDENT>try:<EOL><INDENT>msg = self.session.unserialize(msg)<EOL><DEDENT>except ValueError:<EOL><INDENT>self.log.warn(\"<STR_LIT>\"%idents)<EOL>return<EOL><DEDENT>msg_type = msg['<STR_LIT>']['<STR_LIT>']<EOL>handler = self._notification_handlers.get(msg_type, None)<EOL>if handler is None:<EOL><INDENT>self.log.error(\"<STR_LIT>\"%msg_type)<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>handler(cast_bytes(msg['<STR_LIT:content>']['<STR_LIT>']))<EOL><DEDENT>except Exception:<EOL><INDENT>self.log.error(\"<STR_LIT>\", msg, exc_info=True)<EOL><DEDENT><DEDENT>", "docstring": "dispatch register/unregister events.", "id": "f21685:c1:m6"}
{"signature": "def handle_result(self, idents, parent, raw_msg, success=True):", "body": "<EOL>engine = idents[<NUM_LIT:0>]<EOL>client = idents[<NUM_LIT:1>]<EOL>raw_msg[:<NUM_LIT:2>] = [client,engine]<EOL>self.client_stream.send_multipart(raw_msg, copy=False)<EOL>msg_id = parent['<STR_LIT>']<EOL>self.pending[engine].pop(msg_id)<EOL>if success:<EOL><INDENT>self.completed[engine].add(msg_id)<EOL>self.all_completed.add(msg_id)<EOL><DEDENT>else:<EOL><INDENT>self.failed[engine].add(msg_id)<EOL>self.all_failed.add(msg_id)<EOL><DEDENT>self.all_done.add(msg_id)<EOL>self.destinations[msg_id] = engine<EOL>self.update_graph(msg_id, success)<EOL>", "docstring": "handle a real task result, either success or failure", "id": "f21685:c1:m17"}
{"signature": "def leastload(loads):", "body": "return loads.index(min(loads))<EOL>", "docstring": "Always choose the lowest load.\n\n    If the lowest load occurs more than once, the first\n    occurance will be used.  If loads has LRU ordering, this means\n    the LRU of those with the lowest load is chosen.", "id": "f21685:m5"}
{"signature": "def _unregister_engine(self, uid):", "body": "if len(self.targets) == <NUM_LIT:1>:<EOL><INDENT>pass<EOL><DEDENT>self.engine_stream.flush()<EOL>idx = self.targets.index(uid)<EOL>self.targets.pop(idx)<EOL>self.loads.pop(idx)<EOL>if self.pending[uid]:<EOL><INDENT>dc = ioloop.DelayedCallback(lambda : self.handle_stranded_tasks(uid), <NUM_LIT>, self.loop)<EOL>dc.start()<EOL><DEDENT>else:<EOL><INDENT>self.completed.pop(uid)<EOL>self.failed.pop(uid)<EOL><DEDENT>", "docstring": "Existing engine with ident `uid` became unavailable.", "id": "f21685:c1:m8"}
{"signature": "def finish_job(self, idx):", "body": "self.loads[idx] -= <NUM_LIT:1><EOL>", "docstring": "Called after self.targets[idx] just finished a job.\n        Override with subclasses.", "id": "f21685:c1:m21"}
{"signature": "def add_new_heart_handler(self, handler):", "body": "self.log.debug(\"<STR_LIT>\", handler)<EOL>self._new_handlers.add(handler)<EOL>", "docstring": "add a new handler for new hearts", "id": "f21686:c1:m3"}
{"signature": "def add_heart_failure_handler(self, handler):", "body": "self.log.debug(\"<STR_LIT>\", handler)<EOL>self._failure_handlers.add(handler)<EOL>", "docstring": "add a new handler for heart failure", "id": "f21686:c1:m4"}
{"signature": "def get_record(self, msg_id):", "body": "r = self._records.find_one({'<STR_LIT>': msg_id})<EOL>if not r:<EOL><INDENT>raise KeyError(msg_id)<EOL><DEDENT>return r<EOL>", "docstring": "Get a specific Task Record, by msg_id.", "id": "f21687:c0:m3"}
{"signature": "def drop_matching_records(self, check):", "body": "matches = self._match(check)<EOL>for m in matches:<EOL><INDENT>del self._records[m['<STR_LIT>']]<EOL><DEDENT>", "docstring": "Remove a record from the DB.", "id": "f21688:c2:m6"}
{"signature": "def drop_record(self, msg_id):", "body": "del self._records[msg_id]<EOL>", "docstring": "Remove a record from the DB.", "id": "f21688:c2:m7"}
{"signature": "def _match(self, check):", "body": "matches = []<EOL>tests = {}<EOL>for k,v in check.iteritems():<EOL><INDENT>if isinstance(v, dict):<EOL><INDENT>tests[k] = CompositeFilter(v)<EOL><DEDENT>else:<EOL><INDENT>tests[k] = lambda o: o==v<EOL><DEDENT><DEDENT>for rec in self._records.itervalues():<EOL><INDENT>if self._match_one(rec, tests):<EOL><INDENT>matches.append(copy(rec))<EOL><DEDENT><DEDENT>return matches<EOL>", "docstring": "Find all the matches for a check dict.", "id": "f21688:c2:m1"}
{"signature": "@property<EOL><INDENT>def _next_id(self):<DEDENT>", "body": "newid = self._idcounter<EOL>self._idcounter += <NUM_LIT:1><EOL>return newid<EOL>", "docstring": "gemerate a new ID.\n\n        No longer reuse old ids, just count from 0.", "id": "f21689:c2:m1"}
{"signature": "def save_iopub_message(self, topics, msg):", "body": "<EOL>try:<EOL><INDENT>msg = self.session.unserialize(msg, content=True)<EOL><DEDENT>except Exception:<EOL><INDENT>self.log.error(\"<STR_LIT>\", exc_info=True)<EOL>return<EOL><DEDENT>parent = msg['<STR_LIT>']<EOL>if not parent:<EOL><INDENT>self.log.warn(\"<STR_LIT>\", msg)<EOL>return<EOL><DEDENT>msg_id = parent['<STR_LIT>']<EOL>msg_type = msg['<STR_LIT>']['<STR_LIT>']<EOL>content = msg['<STR_LIT:content>']<EOL>try:<EOL><INDENT>rec = self.db.get_record(msg_id)<EOL><DEDENT>except KeyError:<EOL><INDENT>rec = empty_record()<EOL>rec['<STR_LIT>'] = msg_id<EOL>self.db.add_record(msg_id, rec)<EOL><DEDENT>d = {}<EOL>if msg_type == '<STR_LIT>':<EOL><INDENT>name = content['<STR_LIT:name>']<EOL>s = rec[name] or '<STR_LIT>'<EOL>d[name] = s + content['<STR_LIT:data>']<EOL><DEDENT>elif msg_type == '<STR_LIT>':<EOL><INDENT>d['<STR_LIT>'] = content<EOL><DEDENT>elif msg_type == '<STR_LIT>':<EOL><INDENT>d['<STR_LIT>'] = content['<STR_LIT:code>']<EOL><DEDENT>elif msg_type in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>d[msg_type] = content<EOL><DEDENT>elif msg_type == '<STR_LIT:status>':<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>self.log.warn(\"<STR_LIT>\", msg_type)<EOL><DEDENT>if not d:<EOL><INDENT>return<EOL><DEDENT>try:<EOL><INDENT>self.db.update_record(msg_id, d)<EOL><DEDENT>except Exception:<EOL><INDENT>self.log.error(\"<STR_LIT>\", msg_id, exc_info=True)<EOL><DEDENT>", "docstring": "save an iopub message into the db", "id": "f21689:c2:m14"}
{"signature": "def save_task_result(self, idents, msg):", "body": "client_id = idents[<NUM_LIT:0>]<EOL>try:<EOL><INDENT>msg = self.session.unserialize(msg)<EOL><DEDENT>except Exception:<EOL><INDENT>self.log.error(\"<STR_LIT>\",<EOL>client_id, msg, exc_info=True)<EOL>return<EOL><DEDENT>parent = msg['<STR_LIT>']<EOL>if not parent:<EOL><INDENT>self.log.warn(\"<STR_LIT>\", msg)<EOL>return<EOL><DEDENT>msg_id = parent['<STR_LIT>']<EOL>if msg_id in self.unassigned:<EOL><INDENT>self.unassigned.remove(msg_id)<EOL><DEDENT>header = msg['<STR_LIT>']<EOL>engine_uuid = header.get('<STR_LIT>', u'<STR_LIT>')<EOL>eid = self.by_ident.get(cast_bytes(engine_uuid), None)<EOL>status = header.get('<STR_LIT:status>', None)<EOL>if msg_id in self.pending:<EOL><INDENT>self.log.info(\"<STR_LIT>\", msg_id, eid)<EOL>self.pending.remove(msg_id)<EOL>self.all_completed.add(msg_id)<EOL>if eid is not None:<EOL><INDENT>if status != '<STR_LIT>':<EOL><INDENT>self.completed[eid].append(msg_id)<EOL><DEDENT>if msg_id in self.tasks[eid]:<EOL><INDENT>self.tasks[eid].remove(msg_id)<EOL><DEDENT><DEDENT>completed = header['<STR_LIT:date>']<EOL>started = header.get('<STR_LIT>', None)<EOL>result = {<EOL>'<STR_LIT>' : header,<EOL>'<STR_LIT>': msg['<STR_LIT:content>'],<EOL>'<STR_LIT>' : started,<EOL>'<STR_LIT>' : completed,<EOL>'<STR_LIT>' : datetime.now(),<EOL>'<STR_LIT>': engine_uuid,<EOL>}<EOL>result['<STR_LIT>'] = msg['<STR_LIT>']<EOL>try:<EOL><INDENT>self.db.update_record(msg_id, result)<EOL><DEDENT>except Exception:<EOL><INDENT>self.log.error(\"<STR_LIT>\", msg_id, exc_info=True)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.log.debug(\"<STR_LIT>\", msg_id)<EOL><DEDENT>", "docstring": "save the result of a completed task.", "id": "f21689:c2:m11"}
{"signature": "def db_query(self, client_id, msg):", "body": "content = msg['<STR_LIT:content>']<EOL>query = content.get('<STR_LIT>', {})<EOL>keys = content.get('<STR_LIT>', None)<EOL>buffers = []<EOL>empty = list()<EOL>try:<EOL><INDENT>records = self.db.find_records(query, keys)<EOL><DEDENT>except Exception as e:<EOL><INDENT>content = error.wrap_exception()<EOL><DEDENT>else:<EOL><INDENT>if keys is not None:<EOL><INDENT>buffer_lens = [] if '<STR_LIT>' in keys else None<EOL>result_buffer_lens = [] if '<STR_LIT>' in keys else None<EOL><DEDENT>else:<EOL><INDENT>buffer_lens = None<EOL>result_buffer_lens = None<EOL><DEDENT>for rec in records:<EOL><INDENT>b = rec.pop('<STR_LIT>', empty) or empty<EOL>if buffer_lens is not None:<EOL><INDENT>buffer_lens.append(len(b))<EOL>buffers.extend(b)<EOL><DEDENT>rb = rec.pop('<STR_LIT>', empty) or empty<EOL>if result_buffer_lens is not None:<EOL><INDENT>result_buffer_lens.append(len(rb))<EOL>buffers.extend(rb)<EOL><DEDENT><DEDENT>content = dict(status='<STR_LIT>', records=records, buffer_lens=buffer_lens,<EOL>result_buffer_lens=result_buffer_lens)<EOL><DEDENT>self.session.send(self.query, \"<STR_LIT>\", content=content,<EOL>parent=msg, ident=client_id,<EOL>buffers=buffers)<EOL>", "docstring": "Perform a raw query on the task record database.", "id": "f21689:c2:m30"}
{"signature": "def empty_record():", "body": "return {<EOL>'<STR_LIT>' : None,<EOL>'<STR_LIT>' : None,<EOL>'<STR_LIT:content>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>' : None,<EOL>'<STR_LIT>' : None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>' : None,<EOL>'<STR_LIT>' : None,<EOL>'<STR_LIT>' : None,<EOL>'<STR_LIT>' : None,<EOL>'<STR_LIT>' : None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': None,<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>}<EOL>", "docstring": "Return an empty dict with all record keys.", "id": "f21689:m2"}
{"signature": "def get_results(self, client_id, msg):", "body": "content = msg['<STR_LIT:content>']<EOL>msg_ids = sorted(set(content['<STR_LIT>']))<EOL>statusonly = content.get('<STR_LIT>', False)<EOL>pending = []<EOL>completed = []<EOL>content = dict(status='<STR_LIT>')<EOL>content['<STR_LIT>'] = pending<EOL>content['<STR_LIT>'] = completed<EOL>buffers = []<EOL>if not statusonly:<EOL><INDENT>try:<EOL><INDENT>matches = self.db.find_records(dict(msg_id={'<STR_LIT>':msg_ids}))<EOL>records = {}<EOL>for rec in matches:<EOL><INDENT>records[rec['<STR_LIT>']] = rec<EOL><DEDENT><DEDENT>except Exception:<EOL><INDENT>content = error.wrap_exception()<EOL>self.session.send(self.query, \"<STR_LIT>\", content=content,<EOL>parent=msg, ident=client_id)<EOL>return<EOL><DEDENT><DEDENT>else:<EOL><INDENT>records = {}<EOL><DEDENT>for msg_id in msg_ids:<EOL><INDENT>if msg_id in self.pending:<EOL><INDENT>pending.append(msg_id)<EOL><DEDENT>elif msg_id in self.all_completed:<EOL><INDENT>completed.append(msg_id)<EOL>if not statusonly:<EOL><INDENT>c,bufs = self._extract_record(records[msg_id])<EOL>content[msg_id] = c<EOL>buffers.extend(bufs)<EOL><DEDENT><DEDENT>elif msg_id in records:<EOL><INDENT>if rec['<STR_LIT>']:<EOL><INDENT>completed.append(msg_id)<EOL>c,bufs = self._extract_record(records[msg_id])<EOL>content[msg_id] = c<EOL>buffers.extend(bufs)<EOL><DEDENT>else:<EOL><INDENT>pending.append(msg_id)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>raise KeyError('<STR_LIT>'+msg_id)<EOL><DEDENT>except:<EOL><INDENT>content = error.wrap_exception()<EOL><DEDENT>break<EOL><DEDENT><DEDENT>self.session.send(self.query, \"<STR_LIT>\", content=content,<EOL>parent=msg, ident=client_id,<EOL>buffers=buffers)<EOL>", "docstring": "Get the result of 1 or more messages.", "id": "f21689:c2:m28"}
{"signature": "def _handle_stranded_msgs(self, eid, uuid):", "body": "outstanding = self.queues[eid]<EOL>for msg_id in outstanding:<EOL><INDENT>self.pending.remove(msg_id)<EOL>self.all_completed.add(msg_id)<EOL>try:<EOL><INDENT>raise error.EngineError(\"<STR_LIT>\" % (eid, msg_id))<EOL><DEDENT>except:<EOL><INDENT>content = error.wrap_exception()<EOL><DEDENT>header = {}<EOL>header['<STR_LIT>'] = uuid<EOL>header['<STR_LIT:date>'] = datetime.now()<EOL>rec = dict(result_content=content, result_header=header, result_buffers=[])<EOL>rec['<STR_LIT>'] = header['<STR_LIT:date>']<EOL>rec['<STR_LIT>'] = uuid<EOL>try:<EOL><INDENT>self.db.update_record(msg_id, rec)<EOL><DEDENT>except Exception:<EOL><INDENT>self.log.error(\"<STR_LIT>\", msg_id, exc_info=True)<EOL><DEDENT><DEDENT>", "docstring": "Handle messages known to be on an engine when the engine unregisters.\n\n        It is possible that this will fire prematurely - that is, an engine will\n        go down after completing a result, and the client will be notified\n        that the result failed and later receive the actual result.", "id": "f21689:c2:m18"}
{"signature": "def purge_results(self, client_id, msg):", "body": "content = msg['<STR_LIT:content>']<EOL>self.log.info(\"<STR_LIT>\", content)<EOL>msg_ids = content.get('<STR_LIT>', [])<EOL>reply = dict(status='<STR_LIT>')<EOL>if msg_ids == '<STR_LIT:all>':<EOL><INDENT>try:<EOL><INDENT>self.db.drop_matching_records(dict(completed={'<STR_LIT>':None}))<EOL><DEDENT>except Exception:<EOL><INDENT>reply = error.wrap_exception()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>pending = filter(lambda m: m in self.pending, msg_ids)<EOL>if pending:<EOL><INDENT>try:<EOL><INDENT>raise IndexError(\"<STR_LIT>\" % pending[<NUM_LIT:0>])<EOL><DEDENT>except:<EOL><INDENT>reply = error.wrap_exception()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>self.db.drop_matching_records(dict(msg_id={'<STR_LIT>':msg_ids}))<EOL><DEDENT>except Exception:<EOL><INDENT>reply = error.wrap_exception()<EOL><DEDENT><DEDENT>if reply['<STR_LIT:status>'] == '<STR_LIT>':<EOL><INDENT>eids = content.get('<STR_LIT>', [])<EOL>for eid in eids:<EOL><INDENT>if eid not in self.engines:<EOL><INDENT>try:<EOL><INDENT>raise IndexError(\"<STR_LIT>\" % eid)<EOL><DEDENT>except:<EOL><INDENT>reply = error.wrap_exception()<EOL><DEDENT>break<EOL><DEDENT>uid = self.engines[eid].queue<EOL>try:<EOL><INDENT>self.db.drop_matching_records(dict(engine_uuid=uid, completed={'<STR_LIT>':None}))<EOL><DEDENT>except Exception:<EOL><INDENT>reply = error.wrap_exception()<EOL>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT>self.session.send(self.query, '<STR_LIT>', content=reply, ident=client_id)<EOL>", "docstring": "Purge results from memory. This method is more valuable before we move\n        to a DB based message storage mechanism.", "id": "f21689:c2:m25"}
{"signature": "def update_record(self, msg_id, rec):", "body": "query = \"<STR_LIT>\"%self.table<EOL>sets = []<EOL>keys = sorted(rec.keys())<EOL>values = []<EOL>for key in keys:<EOL><INDENT>sets.append('<STR_LIT>'%key)<EOL>values.append(rec[key])<EOL><DEDENT>query += '<STR_LIT:U+002CU+0020>'.join(sets)<EOL>query += '<STR_LIT>'<EOL>values.append(msg_id)<EOL>self._db.execute(query, values)<EOL>", "docstring": "Update the data in an existing record.", "id": "f21690:c0:m9"}
{"signature": "def _render_expression(self, check):", "body": "expressions = []<EOL>args = []<EOL>skeys = set(check.keys())<EOL>skeys.difference_update(set(self._keys))<EOL>skeys.difference_update(set(['<STR_LIT>', '<STR_LIT>']))<EOL>if skeys:<EOL><INDENT>raise KeyError(\"<STR_LIT>\"%skeys)<EOL><DEDENT>for name,sub_check in check.iteritems():<EOL><INDENT>if isinstance(sub_check, dict):<EOL><INDENT>for test,value in sub_check.iteritems():<EOL><INDENT>try:<EOL><INDENT>op = operators[test]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise KeyError(\"<STR_LIT>\"%test)<EOL><DEDENT>if isinstance(op, tuple):<EOL><INDENT>op, join = op<EOL><DEDENT>if value is None and op in null_operators:<EOL><INDENT>expr = \"<STR_LIT>\" % (name, null_operators[op])<EOL><DEDENT>else:<EOL><INDENT>expr = \"<STR_LIT>\"%(name, op)<EOL>if isinstance(value, (tuple,list)):<EOL><INDENT>if op in null_operators and any([v is None for v in value]):<EOL><INDENT>raise ValueError(\"<STR_LIT>\"%test)<EOL><DEDENT>expr = '<STR_LIT>'%( join.join([expr]*len(value)) )<EOL>args.extend(value)<EOL><DEDENT>else:<EOL><INDENT>args.append(value)<EOL><DEDENT><DEDENT>expressions.append(expr)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if sub_check is None:<EOL><INDENT>expressions.append(\"<STR_LIT>\" % name)<EOL><DEDENT>else:<EOL><INDENT>expressions.append(\"<STR_LIT>\"%name)<EOL>args.append(sub_check)<EOL><DEDENT><DEDENT><DEDENT>expr = \"<STR_LIT>\".join(expressions)<EOL>return expr, args<EOL>", "docstring": "Turn a mongodb-style search dict into an SQL query.", "id": "f21690:c0:m6"}
{"signature": "def drop_record(self, msg_id):", "body": "self._db.execute(\"\"\"<STR_LIT>\"\"\"%self.table, (msg_id,))<EOL>", "docstring": "Remove a record from the DB.", "id": "f21690:c0:m10"}
{"signature": "def get_record(self, msg_id):", "body": "cursor = self._db.execute(\"\"\"<STR_LIT>\"\"\"%self.table, (msg_id,))<EOL>line = cursor.fetchone()<EOL>if line is None:<EOL><INDENT>raise KeyError(\"<STR_LIT>\"%msg_id)<EOL><DEDENT>return self._list_to_dict(line)<EOL>", "docstring": "Get a specific Task Record, by msg_id.", "id": "f21690:c0:m8"}
{"signature": "def shutdown(self, targets=None, restart=False, hub=False, block=None):", "body": "block = self.block if block is None else block<EOL>if targets is None or targets == '<STR_LIT:all>':<EOL><INDENT>targets = self.targets<EOL><DEDENT>return self.client.shutdown(targets=targets, restart=restart, hub=hub, block=block)<EOL>", "docstring": "Terminates one or more engine processes, optionally including the hub.", "id": "f21691:c0:m14"}
{"signature": "def apply_async(self, f, *args, **kwargs):", "body": "return self._really_apply(f, args, kwargs, block=False)<EOL>", "docstring": "calls f(*args, **kwargs) on remote engines in a nonblocking manner.\n\n        returns AsyncResult", "id": "f21691:c0:m7"}
{"signature": "def remote(self, block=True, **flags):", "body": "block = self.block if block is None else block<EOL>return remote(self, block=block, **flags)<EOL>", "docstring": "Decorator for making a RemoteFunction", "id": "f21691:c0:m20"}
{"signature": "def set_flags(self, **kwargs):", "body": "super(LoadBalancedView, self).set_flags(**kwargs)<EOL>for name in ('<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>if name in kwargs:<EOL><INDENT>value = kwargs[name]<EOL>if self._validate_dependency(value):<EOL><INDENT>setattr(self, name, value)<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"%value)<EOL><DEDENT><DEDENT><DEDENT>if '<STR_LIT>' in kwargs:<EOL><INDENT>t = kwargs['<STR_LIT>']<EOL>if not isinstance(t, (int, float, type(None))):<EOL><INDENT>raise TypeError(\"<STR_LIT>\"%type(t))<EOL><DEDENT>if t is not None:<EOL><INDENT>if t < <NUM_LIT:0>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"%t)<EOL><DEDENT><DEDENT>self.timeout = t<EOL><DEDENT>", "docstring": "set my attribute flags by keyword.\n\n        A View is a wrapper for the Client's apply method, but with attributes\n        that specify keyword arguments, those attributes can be set by keyword\n        argument with this method.\n\n        Parameters\n        ----------\n\n        block : bool\n            whether to wait for results\n        track : bool\n            whether to create a MessageTracker to allow the user to\n            safely edit after arrays and buffers during non-copying\n            sends.\n\n        after : Dependency or collection of msg_ids\n            Only for load-balanced execution (targets=None)\n            Specify a list of msg_ids as a time-based dependency.\n            This job will only be run *after* the dependencies\n            have been met.\n\n        follow : Dependency or collection of msg_ids\n            Only for load-balanced execution (targets=None)\n            Specify a list of msg_ids as a location-based dependency.\n            This job will only be run on an engine where this dependency\n            is met.\n\n        timeout : float/int or None\n            Only for load-balanced execution (targets=None)\n            Specify an amount of time (in seconds) for the scheduler to\n            wait for dependencies to be met before failing with a\n            DependencyTimeout.\n\n        retries : int\n            Number of times a task will be retried on failure.", "id": "f21691:c2:m3"}
{"signature": "@spin_after<EOL><INDENT>def map(self, f, *sequences, **kwargs):<DEDENT>", "body": "block = kwargs.pop('<STR_LIT>', self.block)<EOL>for k in list(kwargs.keys()):<EOL><INDENT>if k not in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>raise TypeError(\"<STR_LIT>\"%k)<EOL><DEDENT><DEDENT>assert len(sequences) > <NUM_LIT:0>, \"<STR_LIT>\"<EOL>pf = ParallelFunction(self, f, block=block, **kwargs)<EOL>return pf.map(*sequences)<EOL>", "docstring": "view.map(f, *sequences, block=self.block) => list|AsyncMapResult\n\n        Parallel version of builtin `map`, using this View's `targets`.\n\n        There will be one task per target, so work will be chunked\n        if the sequences are longer than `targets`.\n\n        Results can be iterated as they are ready, but will become available in chunks.\n\n        Parameters\n        ----------\n\n        f : callable\n            function to be mapped\n        *sequences: one or more sequences of matching length\n            the sequences to be distributed and passed to `f`\n        block : bool\n            whether to wait for the result or not [default self.block]\n\n        Returns\n        -------\n\n        if block=False:\n            AsyncMapResult\n                An object like AsyncResult, but which reassembles the sequence of results\n                into a single list. AsyncMapResults can be iterated through before all\n                results are complete.\n        else:\n            list\n                the result of map(f,*sequences)", "id": "f21691:c1:m4"}
{"signature": "@spin_after<EOL><INDENT>def get_result(self, indices_or_msg_ids=None):<DEDENT>", "body": "if indices_or_msg_ids is None:<EOL><INDENT>indices_or_msg_ids = -<NUM_LIT:1><EOL><DEDENT>if isinstance(indices_or_msg_ids, int):<EOL><INDENT>indices_or_msg_ids = self.history[indices_or_msg_ids]<EOL><DEDENT>elif isinstance(indices_or_msg_ids, (list,tuple,set)):<EOL><INDENT>indices_or_msg_ids = list(indices_or_msg_ids)<EOL>for i,index in enumerate(indices_or_msg_ids):<EOL><INDENT>if isinstance(index, int):<EOL><INDENT>indices_or_msg_ids[i] = self.history[index]<EOL><DEDENT><DEDENT><DEDENT>return self.client.get_result(indices_or_msg_ids)<EOL>", "docstring": "return one or more results, specified by history index or msg_id.\n\n        See client.get_result for details.", "id": "f21691:c0:m15"}
{"signature": "def map(self, f, *sequences, **kwargs):", "body": "raise NotImplementedError<EOL>", "docstring": "override in subclasses", "id": "f21691:c0:m16"}
{"signature": "def activate(self, suffix='<STR_LIT>'):", "body": "from IPython.parallel.client.magics import ParallelMagics<EOL>try:<EOL><INDENT>ip = get_ipython()<EOL><DEDENT>except NameError:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>M = ParallelMagics(ip, self, suffix)<EOL>ip.magics_manager.register(M)<EOL>", "docstring": "Activate IPython magics associated with this View\n\n        Defines the magics `%px, %autopx, %pxresult, %%px, %pxconfig`\n\n        Parameters\n        ----------\n\n        suffix: str [default: '']\n            The suffix, if any, for the magics.  This allows you to have\n            multiple views associated with parallel magics at the same time.\n\n            e.g. ``rc[::2].activate(suffix='_even')`` will give you\n            the magics ``%px_even``, ``%pxresult_even``, etc. for running magics \n            on the even engines.", "id": "f21691:c1:m17"}
{"signature": "def get(self, key_s):", "body": "<EOL>return self.pull(key_s, block=True)<EOL>", "docstring": "get object(s) by `key_s` from remote namespace\n\n        see `pull` for details.", "id": "f21691:c1:m9"}
{"signature": "@sync_results<EOL><INDENT>def spin(self):<DEDENT>", "body": "self.client.spin()<EOL>", "docstring": "spin the client, and sync", "id": "f21691:c0:m9"}
{"signature": "@contextmanager<EOL><INDENT>def temp_flags(self, **kwargs):<DEDENT>", "body": "<EOL>saved_flags = {}<EOL>for f in self._flag_names:<EOL><INDENT>saved_flags[f] = getattr(self, f)<EOL><DEDENT>self.set_flags(**kwargs)<EOL>try:<EOL><INDENT>yield<EOL><DEDENT>finally:<EOL><INDENT>self.set_flags(**saved_flags)<EOL><DEDENT>", "docstring": "temporarily set flags, for use in `with` statements.\n\n        See set_flags for permanent setting of flags\n\n        Examples\n        --------\n\n        >>> view.track=False\n        ...\n        >>> with view.temp_flags(track=True):\n        ...    ar = view.apply(dostuff, my_big_array)\n        ...    ar.tracker.wait() # wait for send to finish\n        >>> view.track\n        False", "id": "f21691:c0:m4"}
{"signature": "@sync_results<EOL><INDENT>@save_ids<EOL>def gather(self, key, dist='<STR_LIT:b>', targets=None, block=None):<DEDENT>", "body": "block = block if block is not None else self.block<EOL>targets = targets if targets is not None else self.targets<EOL>mapObject = Map.dists[dist]()<EOL>msg_ids = []<EOL>targets = self.client._build_targets(targets)[<NUM_LIT:1>]<EOL>for index, engineid in enumerate(targets):<EOL><INDENT>msg_ids.extend(self.pull(key, block=False, targets=engineid).msg_ids)<EOL><DEDENT>r = AsyncMapResult(self.client, msg_ids, mapObject, fname='<STR_LIT>')<EOL>if block:<EOL><INDENT>try:<EOL><INDENT>return r.get()<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>return r<EOL>", "docstring": "Gather a partitioned sequence on a set of engines as a single local seq.", "id": "f21691:c1:m12"}
{"signature": "def map_sync(self, f, *sequences, **kwargs):", "body": "if '<STR_LIT>' in kwargs:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>kwargs['<STR_LIT>'] = True<EOL>return self.map(f,*sequences,**kwargs)<EOL>", "docstring": "Parallel version of builtin `map`, using this view's engines.\n\n        This is equivalent to map(...block=True)\n\n        See `self.map` for details.", "id": "f21691:c0:m18"}
{"signature": "def apply(self, f, *args, **kwargs):", "body": "return self._really_apply(f, args, kwargs)<EOL>", "docstring": "calls f(*args, **kwargs) on remote engines, returning the result.\n\n        This method sets all apply flags via this View's attributes.\n\n        if self.block is False:\n            returns AsyncResult\n        else:\n            returns actual result of f(*args, **kwargs)", "id": "f21691:c0:m6"}
{"signature": "def _reconstruct_result(self, res):", "body": "if self._single_result:<EOL><INDENT>return res[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>return res<EOL><DEDENT>", "docstring": "Reconstruct our result from actual result list (always a list)\n\n        Override me in subclasses for turning a list of results\n        into the expected form.", "id": "f21692:c0:m2"}
{"signature": "@property<EOL><INDENT>@check_ready<EOL>def metadata(self):<DEDENT>", "body": "if self._single_result:<EOL><INDENT>return self._metadata[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>return self._metadata<EOL><DEDENT>", "docstring": "property for accessing execution metadata.", "id": "f21692:c0:m9"}
{"signature": "@check_ready<EOL><INDENT>def display_outputs(self, groupby=\"<STR_LIT:type>\"):<DEDENT>", "body": "if self._single_result:<EOL><INDENT>self._display_single_result()<EOL>return<EOL><DEDENT>stdouts = self.stdout<EOL>stderrs = self.stderr<EOL>pyouts  = self.pyout<EOL>output_lists = self.outputs<EOL>results = self.get()<EOL>targets = self.engine_id<EOL>if groupby == \"<STR_LIT>\":<EOL><INDENT>for eid,stdout,stderr,outputs,r,pyout in zip(<EOL>targets, stdouts, stderrs, output_lists, results, pyouts<EOL>):<EOL><INDENT>self._display_stream(stdout, '<STR_LIT>' % eid)<EOL>self._display_stream(stderr, '<STR_LIT>' % eid, file=sys.stderr)<EOL>try:<EOL><INDENT>get_ipython()<EOL><DEDENT>except NameError:<EOL><INDENT>return <EOL><DEDENT>if outputs or pyout is not None:<EOL><INDENT>_raw_text('<STR_LIT>' % eid)<EOL><DEDENT>for output in outputs:<EOL><INDENT>self._republish_displaypub(output, eid)<EOL><DEDENT>if pyout is not None:<EOL><INDENT>display(r)<EOL><DEDENT><DEDENT><DEDENT>elif groupby in ('<STR_LIT:type>', '<STR_LIT>'):<EOL><INDENT>for eid,stdout in zip(targets, stdouts):<EOL><INDENT>self._display_stream(stdout, '<STR_LIT>' % eid)<EOL><DEDENT>for eid,stderr in zip(targets, stderrs):<EOL><INDENT>self._display_stream(stderr, '<STR_LIT>' % eid, file=sys.stderr)<EOL><DEDENT>try:<EOL><INDENT>get_ipython()<EOL><DEDENT>except NameError:<EOL><INDENT>return<EOL><DEDENT>if groupby == '<STR_LIT>':<EOL><INDENT>output_dict = dict((eid, outputs) for eid,outputs in zip(targets, output_lists))<EOL>N = max(len(outputs) for outputs in output_lists)<EOL>for i in range(N):<EOL><INDENT>for eid in targets:<EOL><INDENT>outputs = output_dict[eid]<EOL>if len(outputs) >= N:<EOL><INDENT>_raw_text('<STR_LIT>' % eid)<EOL>self._republish_displaypub(outputs[i], eid)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for eid,outputs in zip(targets, output_lists):<EOL><INDENT>if outputs:<EOL><INDENT>_raw_text('<STR_LIT>' % eid)<EOL><DEDENT>for output in outputs:<EOL><INDENT>self._republish_displaypub(output, eid)<EOL><DEDENT><DEDENT><DEDENT>for eid,r,pyout in zip(targets, results, pyouts):<EOL><INDENT>if pyout is not None:<EOL><INDENT>display(r)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" % groupby)<EOL><DEDENT>", "docstring": "republish the outputs of the computation\n\n        Parameters\n        ----------\n\n        groupby : str [default: type]\n            if 'type':\n                Group outputs by type (show all stdout, then all stderr, etc.):\n\n                [stdout:1] foo\n                [stdout:2] foo\n                [stderr:1] bar\n                [stderr:2] bar\n            if 'engine':\n                Display outputs for each engine before moving on to the next:\n\n                [stdout:1] foo\n                [stderr:1] bar\n                [stdout:2] foo\n                [stderr:2] bar\n\n            if 'order':\n                Like 'type', but further collate individual displaypub\n                outputs.  This is meant for cases of each command producing\n                several plots, and you would like to see all of the first\n                plots together, then all of the second plots, and so on.", "id": "f21692:c0:m29"}
{"signature": "def _ordered_iter(self):", "body": "try:<EOL><INDENT>rlist = self.get(<NUM_LIT:0>)<EOL><DEDENT>except error.TimeoutError:<EOL><INDENT>for msg_id in self.msg_ids:<EOL><INDENT>ar = AsyncResult(self._client, msg_id, self._fname)<EOL>rlist = ar.get()<EOL>try:<EOL><INDENT>for r in rlist:<EOL><INDENT>yield r<EOL><DEDENT><DEDENT>except TypeError:<EOL><INDENT>yield rlist<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>for r in rlist:<EOL><INDENT>yield r<EOL><DEDENT><DEDENT>", "docstring": "iterator for results *as they arrive*, preserving submission order.", "id": "f21692:c1:m3"}
{"signature": "@decorator<EOL>def check_ready(f, self, *args, **kwargs):", "body": "self.wait(<NUM_LIT:0>)<EOL>if not self._ready:<EOL><INDENT>raise error.TimeoutError(\"<STR_LIT>\")<EOL><DEDENT>return f(self, *args, **kwargs)<EOL>", "docstring": "Call spin() to sync state prior to calling the method.", "id": "f21692:m2"}
{"signature": "def _unwrap_exception(self, content):", "body": "e = error.unwrap_exception(content)<EOL>if e.engine_info:<EOL><INDENT>e_uuid = e.engine_info['<STR_LIT>']<EOL>eid = self._engines[e_uuid]<EOL>e.engine_info['<STR_LIT>'] = eid<EOL><DEDENT>return e<EOL>", "docstring": "unwrap exception, and remap engine_id to int.", "id": "f21693:c2:m9"}
{"signature": "def _flush_iopub(self, sock):", "body": "idents,msg = self.session.recv(sock, mode=zmq.NOBLOCK)<EOL>while msg is not None:<EOL><INDENT>if self.debug:<EOL><INDENT>pprint(msg)<EOL><DEDENT>parent = msg['<STR_LIT>']<EOL>if not parent:<EOL><INDENT>continue<EOL><DEDENT>msg_id = parent['<STR_LIT>']<EOL>content = msg['<STR_LIT:content>']<EOL>header = msg['<STR_LIT>']<EOL>msg_type = msg['<STR_LIT>']['<STR_LIT>']<EOL>md = self.metadata[msg_id]<EOL>if msg_type == '<STR_LIT>':<EOL><INDENT>name = content['<STR_LIT:name>']<EOL>s = md[name] or '<STR_LIT>'<EOL>md[name] = s + content['<STR_LIT:data>']<EOL><DEDENT>elif msg_type == '<STR_LIT>':<EOL><INDENT>md.update({'<STR_LIT>' : self._unwrap_exception(content)})<EOL><DEDENT>elif msg_type == '<STR_LIT>':<EOL><INDENT>md.update({'<STR_LIT>' : content['<STR_LIT:code>']})<EOL><DEDENT>elif msg_type == '<STR_LIT>':<EOL><INDENT>md['<STR_LIT>'].append(content)<EOL><DEDENT>elif msg_type == '<STR_LIT>':<EOL><INDENT>md['<STR_LIT>'] = content<EOL><DEDENT>elif msg_type == '<STR_LIT:status>':<EOL><INDENT>if content['<STR_LIT>'] == '<STR_LIT>':<EOL><INDENT>md['<STR_LIT>'] = True<EOL><DEDENT><DEDENT>else:<EOL><INDENT>pass<EOL><DEDENT>self.metadata[msg_id] = md<EOL>idents,msg = self.session.recv(sock, mode=zmq.NOBLOCK)<EOL><DEDENT>", "docstring": "Flush replies from the iopub channel waiting\n        in the ZMQ queue.", "id": "f21693:c2:m21"}
{"signature": "def _stop_scheduling_tasks(self):", "body": "self._task_socket.close()<EOL>self._task_socket = None<EOL>msg = \"<STR_LIT>\" +\"<STR_LIT>\"<EOL>if self.outstanding:<EOL><INDENT>msg += \"<STR_LIT>\" +\"<STR_LIT>\"<EOL><DEDENT>warnings.warn(msg, RuntimeWarning)<EOL>", "docstring": "Stop scheduling tasks because an engine has been unregistered\n        from a pure ZMQ scheduler.", "id": "f21693:c2:m6"}
{"signature": "def send_execute_request(self, socket, code, silent=True, subheader=None, ident=None):", "body": "if self._closed:<EOL><INDENT>raise RuntimeError(\"<STR_LIT>\")<EOL><DEDENT>subheader = subheader if subheader is not None else {}<EOL>if not isinstance(code, str):<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % type(code))<EOL><DEDENT>if not isinstance(subheader, dict):<EOL><INDENT>raise TypeError(\"<STR_LIT>\" % type(subheader))<EOL><DEDENT>content = dict(code=code, silent=bool(silent), user_variables=[], user_expressions={})<EOL>msg = self.session.send(socket, \"<STR_LIT>\", content=content, ident=ident,<EOL>subheader=subheader)<EOL>msg_id = msg['<STR_LIT>']['<STR_LIT>']<EOL>self.outstanding.add(msg_id)<EOL>if ident:<EOL><INDENT>if isinstance(ident, list):<EOL><INDENT>ident = ident[-<NUM_LIT:1>]<EOL><DEDENT>if ident in list(self._engines.values()):<EOL><INDENT>self._outstanding_dict[ident].add(msg_id)<EOL><DEDENT><DEDENT>self.history.append(msg_id)<EOL>self.metadata[msg_id]['<STR_LIT>'] = datetime.now()<EOL>return msg<EOL>", "docstring": "construct and send an execute request via a socket.", "id": "f21693:c2:m37"}
{"signature": "def spin_thread(self, interval=<NUM_LIT:1>):", "body": "if self._spin_thread is not None:<EOL><INDENT>self.stop_spin_thread()<EOL><DEDENT>self._stop_spinning.clear()<EOL>self._spin_thread = Thread(target=self._spin_every, args=(interval,))<EOL>self._spin_thread.daemon = True<EOL>self._spin_thread.start()<EOL>", "docstring": "call Client.spin() in a background thread on some regular interval\n\n        This helps ensure that messages don't pile up too much in the zmq queue\n        while you are working on other things, or just leaving an idle terminal.\n\n        It also helps limit potential padding of the `received` timestamp\n        on AsyncResult objects, used for timings.\n\n        Parameters\n        ----------\n\n        interval : float, optional\n            The interval on which to spin the client in the background thread\n            (simply passed to time.sleep).\n\n        Notes\n        -----\n\n        For precision timing, you may want to use this method to put a bound\n        on the jitter (in seconds) in `received` timestamps used\n        in AsyncResult.wall_time.", "id": "f21693:c2:m28"}
{"signature": "def __del__(self):", "body": "self.close()<EOL>", "docstring": "cleanup sockets, but _not_ context.", "id": "f21693:c2:m3"}
{"signature": "@spin_first<EOL><INDENT>def shutdown(self, targets='<STR_LIT:all>', restart=False, hub=False, block=None):<DEDENT>", "body": "if restart:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\")<EOL><DEDENT>block = self.block if block is None else block<EOL>if hub:<EOL><INDENT>targets = '<STR_LIT:all>'<EOL><DEDENT>targets = self._build_targets(targets)[<NUM_LIT:0>]<EOL>for t in targets:<EOL><INDENT>self.session.send(self._control_socket, '<STR_LIT>',<EOL>content={'<STR_LIT>':restart},ident=t)<EOL><DEDENT>error = False<EOL>if block or hub:<EOL><INDENT>self._flush_ignored_control()<EOL>for i in range(len(targets)):<EOL><INDENT>idents,msg = self.session.recv(self._control_socket, <NUM_LIT:0>)<EOL>if self.debug:<EOL><INDENT>pprint(msg)<EOL><DEDENT>if msg['<STR_LIT:content>']['<STR_LIT:status>'] != '<STR_LIT>':<EOL><INDENT>error = self._unwrap_exception(msg['<STR_LIT:content>'])<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>self._ignored_control_replies += len(targets)<EOL><DEDENT>if hub:<EOL><INDENT>time.sleep(<NUM_LIT>)<EOL>self.session.send(self._query_socket, '<STR_LIT>')<EOL>idents,msg = self.session.recv(self._query_socket, <NUM_LIT:0>)<EOL>if self.debug:<EOL><INDENT>pprint(msg)<EOL><DEDENT>if msg['<STR_LIT:content>']['<STR_LIT:status>'] != '<STR_LIT>':<EOL><INDENT>error = self._unwrap_exception(msg['<STR_LIT:content>'])<EOL><DEDENT><DEDENT>if error:<EOL><INDENT>raise error<EOL><DEDENT>", "docstring": "Terminates one or more engine processes, optionally including the hub.\n\n        Parameters\n        ----------\n\n        targets: list of ints or 'all' [default: all]\n            Which engines to shutdown.\n        hub: bool [default: False]\n            Whether to include the Hub.  hub=True implies targets='all'.\n        block: bool [default: self.block]\n            Whether to wait for clean shutdown replies or not.\n        restart: bool [default: False]\n            NOT IMPLEMENTED\n            whether to restart engines after shutting them down.", "id": "f21693:c2:m34"}
{"signature": "def __len__(self):", "body": "return len(self.ids)<EOL>", "docstring": "len(client) returns # of engines.", "id": "f21693:c2:m22"}
{"signature": "@spin_first<EOL><INDENT>def resubmit(self, indices_or_msg_ids=None, subheader=None, block=None):<DEDENT>", "body": "block = self.block if block is None else block<EOL>if indices_or_msg_ids is None:<EOL><INDENT>indices_or_msg_ids = -<NUM_LIT:1><EOL><DEDENT>if not isinstance(indices_or_msg_ids, (list,tuple)):<EOL><INDENT>indices_or_msg_ids = [indices_or_msg_ids]<EOL><DEDENT>theids = []<EOL>for id in indices_or_msg_ids:<EOL><INDENT>if isinstance(id, int):<EOL><INDENT>id = self.history[id]<EOL><DEDENT>if not isinstance(id, str):<EOL><INDENT>raise TypeError(\"<STR_LIT>\"%id)<EOL><DEDENT>theids.append(id)<EOL><DEDENT>content = dict(msg_ids = theids)<EOL>self.session.send(self._query_socket, '<STR_LIT>', content)<EOL>zmq.select([self._query_socket], [], [])<EOL>idents,msg = self.session.recv(self._query_socket, zmq.NOBLOCK)<EOL>if self.debug:<EOL><INDENT>pprint(msg)<EOL><DEDENT>content = msg['<STR_LIT:content>']<EOL>if content['<STR_LIT:status>'] != '<STR_LIT>':<EOL><INDENT>raise self._unwrap_exception(content)<EOL><DEDENT>mapping = content['<STR_LIT>']<EOL>new_ids = [ mapping[msg_id] for msg_id in theids ]<EOL>ar = AsyncHubResult(self, msg_ids=new_ids)<EOL>if block:<EOL><INDENT>ar.wait()<EOL><DEDENT>return ar<EOL>", "docstring": "Resubmit one or more tasks.\n\n        in-flight tasks may not be resubmitted.\n\n        Parameters\n        ----------\n\n        indices_or_msg_ids : integer history index, str msg_id, or list of either\n            The indices or msg_ids of indices to be retrieved\n\n        block : bool\n            Whether to wait for the result to be done\n\n        Returns\n        -------\n\n        AsyncHubResult\n            A subclass of AsyncResult that retrieves results from the Hub", "id": "f21693:c2:m41"}
{"signature": "@magic_arguments.magic_arguments()<EOL><INDENT>@exec_args<EOL>def pxconfig(self, line):<DEDENT>", "body": "args = magic_arguments.parse_argstring(self.pxconfig, line)<EOL>if args.targets:<EOL><INDENT>self.view.targets = self._eval_target_str(args.targets)<EOL><DEDENT>if args.block is not None:<EOL><INDENT>self.view.block = args.block<EOL><DEDENT>if args.set_verbose is not None:<EOL><INDENT>self.verbose = args.set_verbose<EOL><DEDENT>", "docstring": "configure default targets/blocking for %px magics", "id": "f21694:c0:m2"}
{"signature": "def parallel_execute(self, cell, block=None, groupby='<STR_LIT:type>', save_name=None):", "body": "<EOL>block = self.view.block if block is None else block<EOL>base = \"<STR_LIT>\" if block else \"<STR_LIT>\"<EOL>targets = self.view.targets<EOL>if isinstance(targets, list) and len(targets) > <NUM_LIT:10>:<EOL><INDENT>str_targets = str(targets[:<NUM_LIT:4>])[:-<NUM_LIT:1>] + '<STR_LIT>' + str(targets[-<NUM_LIT:4>:])[<NUM_LIT:1>:]<EOL><DEDENT>else:<EOL><INDENT>str_targets = str(targets)<EOL><DEDENT>if self.verbose:<EOL><INDENT>print(base + \"<STR_LIT>\" % str_targets)<EOL><DEDENT>result = self.view.execute(cell, silent=False, block=False)<EOL>self.last_result = result<EOL>if save_name:<EOL><INDENT>self.shell.user_ns[save_name] = result<EOL><DEDENT>if block:<EOL><INDENT>result.get()<EOL>result.display_outputs(groupby)<EOL><DEDENT>else:<EOL><INDENT>return result<EOL><DEDENT>", "docstring": "implementation used by %px and %%parallel", "id": "f21694:c0:m5"}
{"signature": "def _enable_autopx(self):", "body": "<EOL>self._original_run_cell = self.shell.run_cell<EOL>self.shell.run_cell = self.pxrun_cell<EOL>self._autopx = True<EOL>print(\"<STR_LIT>\")<EOL>", "docstring": "Enable %autopx mode by saving the original run_cell and installing\n        pxrun_cell.", "id": "f21694:c0:m8"}
{"signature": "def mappable(obj):", "body": "if isinstance(obj, (tuple,list)):<EOL><INDENT>return True<EOL><DEDENT>for m in arrayModules:<EOL><INDENT>if isinstance(obj,m['<STR_LIT:type>']):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "return whether an object is mappable or not.", "id": "f21695:m0"}
{"signature": "def getPartition(self, seq, p, q):", "body": "<EOL>if p<<NUM_LIT:0> or p>=q:<EOL><INDENT>print(\"<STR_LIT>\")<EOL>return<EOL><DEDENT>remainder = len(seq)%q<EOL>basesize = len(seq)//q<EOL>hi = []<EOL>lo = []<EOL>for n in range(q):<EOL><INDENT>if n < remainder:<EOL><INDENT>lo.append(n * (basesize + <NUM_LIT:1>))<EOL>hi.append(lo[-<NUM_LIT:1>] + basesize + <NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>lo.append(n*basesize + remainder)<EOL>hi.append(lo[-<NUM_LIT:1>] + basesize)<EOL><DEDENT><DEDENT>try:<EOL><INDENT>result = seq[lo[p]:hi[p]]<EOL><DEDENT>except TypeError:<EOL><INDENT>result = list(islice(seq, lo[p], hi[p]))<EOL><DEDENT>return result<EOL>", "docstring": "Returns the pth partition of q partitions of seq.", "id": "f21695:c0:m0"}
{"signature": "def getname(f):", "body": "try:<EOL><INDENT>return f.__name__<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>return f.name<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT>return str(f)<EOL>", "docstring": "Get the name of an object.\n\n    For use in case of callables that are not functions, and\n    thus may not have __name__ defined.\n\n    Order: f.__name__ >  f.name > str(f)", "id": "f21696:m2"}
{"signature": "def bind_kernel(**kwargs):", "body": "from IPython.zmq.ipkernel import IPKernelApp<EOL>from IPython.parallel.apps.ipengineapp import IPEngineApp<EOL>if IPKernelApp.initialized() and isinstance(IPKernelApp._instance, IPKernelApp):<EOL><INDENT>return<EOL><DEDENT>if IPEngineApp.initialized():<EOL><INDENT>try:<EOL><INDENT>app = IPEngineApp.instance()<EOL><DEDENT>except MultipleInstanceError:<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>return app.bind_kernel(**kwargs)<EOL><DEDENT><DEDENT>raise RuntimeError(\"<STR_LIT>\")<EOL>", "docstring": "Bind an Engine's Kernel to be used as a full IPython kernel.\n\n    This allows a running Engine to be used simultaneously as a full IPython kernel\n    with the QtConsole or other frontends.\n\n    This function returns immediately.", "id": "f21697:m0"}
{"signature": "def render_traceback(self, excid=None):", "body": "lines = []<EOL>if excid is None:<EOL><INDENT>for (en,ev,etb,ei) in self.elist:<EOL><INDENT>lines.append(self._get_engine_str(ei))<EOL>lines.extend((etb or '<STR_LIT>').splitlines())<EOL>lines.append('<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>en,ev,etb,ei = self.elist[excid]<EOL><DEDENT>except:<EOL><INDENT>raise IndexError(\"<STR_LIT>\"%excid)<EOL><DEDENT>else:<EOL><INDENT>lines.append(self._get_engine_str(ei))<EOL>lines.extend((etb or '<STR_LIT>').splitlines())<EOL><DEDENT><DEDENT>return lines<EOL>", "docstring": "render one or all of my tracebacks to a list of lines", "id": "f21698:c38:m5"}
{"signature": "def print_traceback(self, excid=None):", "body": "print('<STR_LIT:\\n>'.join(self.render_traceback()))<EOL>", "docstring": "print my traceback", "id": "f21698:c36:m5"}
{"signature": "def _from_module(self, module, object):", "body": "if module is None:<EOL><INDENT>return True<EOL><DEDENT>elif inspect.isfunction(object):<EOL><INDENT>return module.__dict__ is object.__globals__<EOL><DEDENT>elif inspect.isclass(object):<EOL><INDENT>return module.__name__ == object.__module__<EOL><DEDENT>elif inspect.getmodule(object) is not None:<EOL><INDENT>return module is inspect.getmodule(object)<EOL><DEDENT>elif hasattr(object, '<STR_LIT>'):<EOL><INDENT>return module.__name__ == object.__module__<EOL><DEDENT>elif isinstance(object, property):<EOL><INDENT>return True <EOL><DEDENT>else:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Return true if the given object is defined in the given\nmodule.", "id": "f21705:c5:m3"}
{"signature": "def _normalize_module(module, depth=<NUM_LIT:2>):", "body": "if inspect.ismodule(module):<EOL><INDENT>return module<EOL><DEDENT>elif isinstance(module, str):<EOL><INDENT>return __import__(module, globals(), locals(), [\"<STR_LIT:*>\"])<EOL><DEDENT>elif module is None:<EOL><INDENT>return sys.modules[sys._getframe(depth).f_globals['<STR_LIT>']]<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Return the module specified by `module`.  In particular:\n  - If `module` is a module, then return module.\n  - If `module` is a string, then import and return the\n    module with that name.\n  - If `module` is None, then return the calling module.\n    The calling module is assumed to be the module of\n    the stack frame at the given depth in the call stack.", "id": "f21705:m3"}
{"signature": "def __init__(self, verbose=False, parser=DocTestParser(),<EOL>recurse=True, _namefilter=None, exclude_empty=True):", "body": "self._parser = parser<EOL>self._verbose = verbose<EOL>self._recurse = recurse<EOL>self._exclude_empty = exclude_empty<EOL>self._namefilter = _namefilter<EOL>", "docstring": "Create a new doctest finder.\n\nThe optional argument `parser` specifies a class or\nfunction that should be used to create new DocTest objects (or\nobjects that implement the same interface as DocTest).  The\nsignature for this factory function should match the signature\nof the DocTest constructor.\n\nIf the optional argument `recurse` is false, then `find` will\nonly examine the given object, and not any contained objects.\n\nIf the optional argument `exclude_empty` is false, then `find`\nwill include tests for objects with empty docstrings.", "id": "f21705:c5:m0"}
{"signature": "def is_private(prefix, base):", "body": "warnings.warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>DeprecationWarning, stacklevel=<NUM_LIT:2>)<EOL>return base[:<NUM_LIT:1>] == \"<STR_LIT:_>\" and not base[:<NUM_LIT:2>] == \"<STR_LIT>\" == base[-<NUM_LIT:2>:]<EOL>", "docstring": "prefix, base -> true iff name prefix + \".\" + base is \"private\".\n\n    Prefix may be an empty string, and base does not contain a period.\n    Prefix is ignored (although functions you write conforming to this\n    protocol may make use of it).\n    Return true iff base begins with an (at least one) underscore, but\n    does not both begin and end with (at least) two underscores.\n\n    >>> is_private(\"a.b\", \"my_func\")\n    False\n    >>> is_private(\"____\", \"_my_func\")\n    True\n    >>> is_private(\"someclass\", \"__init__\")\n    False\n    >>> is_private(\"sometypo\", \"__init_\")\n    True\n    >>> is_private(\"x.y.z\", \"_\")\n    True\n    >>> is_private(\"_x.y.z\", \"__\")\n    False\n    >>> is_private(\"\", \"\")  # senseless but consistent\n    False", "id": "f21705:m1"}
{"signature": "def _indent(s, indent=<NUM_LIT:4>):", "body": "<EOL>return re.sub('<STR_LIT>', indent*'<STR_LIT:U+0020>', s)<EOL>", "docstring": "Add the given number of space characters to the beginning every\nnon-blank line in `s`, and return the result.", "id": "f21705:m4"}
{"signature": "def _check_prefix(self, lines, prefix, name, lineno):", "body": "for i, line in enumerate(lines):<EOL><INDENT>if line and not line.startswith(prefix):<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(lineno+i+<NUM_LIT:1>, name, line))<EOL><DEDENT><DEDENT>", "docstring": "Check that every line in the given list starts with the given\nprefix; if any line does not, then raise a ValueError.", "id": "f21705:c4:m7"}
{"signature": "def output_difference(self, example, got, optionflags):", "body": "want = example.want<EOL>if not (optionflags & DONT_ACCEPT_BLANKLINE):<EOL><INDENT>got = re.sub('<STR_LIT>', BLANKLINE_MARKER, got)<EOL><DEDENT>if self._do_a_fancy_diff(want, got, optionflags):<EOL><INDENT>want_lines = want.splitlines(True)  <EOL>got_lines = got.splitlines(True)<EOL>if optionflags & REPORT_UDIFF:<EOL><INDENT>diff = difflib.unified_diff(want_lines, got_lines, n=<NUM_LIT:2>)<EOL>diff = list(diff)[<NUM_LIT:2>:] <EOL>kind = '<STR_LIT>'<EOL><DEDENT>elif optionflags & REPORT_CDIFF:<EOL><INDENT>diff = difflib.context_diff(want_lines, got_lines, n=<NUM_LIT:2>)<EOL>diff = list(diff)[<NUM_LIT:2>:] <EOL>kind = '<STR_LIT>'<EOL><DEDENT>elif optionflags & REPORT_NDIFF:<EOL><INDENT>engine = difflib.Differ(charjunk=difflib.IS_CHARACTER_JUNK)<EOL>diff = list(engine.compare(want_lines, got_lines))<EOL>kind = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>assert <NUM_LIT:0>, '<STR_LIT>'<EOL><DEDENT>diff = [line.rstrip() + '<STR_LIT:\\n>' for line in diff]<EOL>return '<STR_LIT>' % kind + _indent('<STR_LIT>'.join(diff))<EOL><DEDENT>if want and got:<EOL><INDENT>return '<STR_LIT>' % (_indent(want), _indent(got))<EOL><DEDENT>elif want:<EOL><INDENT>return '<STR_LIT>' % _indent(want)<EOL><DEDENT>elif got:<EOL><INDENT>return '<STR_LIT>' % _indent(got)<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>", "docstring": "Return a string describing the differences between the\nexpected output for a given example (`example`) and the actual\noutput (`got`).  `optionflags` is the set of option flags used\nto compare `want` and `got`.", "id": "f21705:c7:m2"}
{"signature": "def _comment_line(line):", "body": "line = line.rstrip()<EOL>if line:<EOL><INDENT>return '<STR_LIT>'+line<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT:#>'<EOL><DEDENT>", "docstring": "Return a commented form of the given line", "id": "f21705:m7"}
{"signature": "def _ellipsis_match(want, got):", "body": "if want.find(ELLIPSIS_MARKER)==-<NUM_LIT:1>:<EOL><INDENT>return want == got<EOL><DEDENT>ws = want.split(ELLIPSIS_MARKER)<EOL>assert len(ws) >= <NUM_LIT:2><EOL>startpos, endpos = <NUM_LIT:0>, len(got)<EOL>w = ws[<NUM_LIT:0>]<EOL>if w:   <EOL><INDENT>if got.startswith(w):<EOL><INDENT>startpos = len(w)<EOL>del ws[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>w = ws[-<NUM_LIT:1>]<EOL>if w:   <EOL><INDENT>if got.endswith(w):<EOL><INDENT>endpos -= len(w)<EOL>del ws[-<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>return False<EOL><DEDENT><DEDENT>if startpos > endpos:<EOL><INDENT>return False<EOL><DEDENT>for w in ws:<EOL><INDENT>startpos = got.find(w, startpos, endpos)<EOL>if startpos < <NUM_LIT:0>:<EOL><INDENT>return False<EOL><DEDENT>startpos += len(w)<EOL><DEDENT>return True<EOL>", "docstring": "Essentially the only subtle case:\n>>> _ellipsis_match('aa...aa', 'aaa')\nFalse", "id": "f21705:m6"}
{"signature": "def _check_prompt_blank(self, lines, indent, name, lineno):", "body": "for i, line in enumerate(lines):<EOL><INDENT>if len(line) >= indent+<NUM_LIT:4> and line[indent+<NUM_LIT:3>] != '<STR_LIT:U+0020>':<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(lineno+i+<NUM_LIT:1>, name,<EOL>line[indent:indent+<NUM_LIT:3>], line))<EOL><DEDENT><DEDENT>", "docstring": "Given the lines of a source string (including prompts and\nleading indentation), check to make sure that every prompt is\nfollowed by a space character.  If any line is not followed by\na space character, then raise ValueError.", "id": "f21705:c4:m6"}
{"signature": "def _find_lineno(self, obj, source_lines):", "body": "lineno = None<EOL>if inspect.ismodule(obj):<EOL><INDENT>lineno = <NUM_LIT:0><EOL><DEDENT>if inspect.isclass(obj):<EOL><INDENT>if source_lines is None:<EOL><INDENT>return None<EOL><DEDENT>pat = re.compile(r'<STR_LIT>' %<EOL>getattr(obj, '<STR_LIT>', '<STR_LIT:->'))<EOL>for i, line in enumerate(source_lines):<EOL><INDENT>if pat.match(line):<EOL><INDENT>lineno = i<EOL>break<EOL><DEDENT><DEDENT><DEDENT>if inspect.ismethod(obj): obj = obj.__func__<EOL>if inspect.isfunction(obj): obj = obj.__code__<EOL>if inspect.istraceback(obj): obj = obj.tb_frame<EOL>if inspect.isframe(obj): obj = obj.f_code<EOL>if inspect.iscode(obj):<EOL><INDENT>lineno = getattr(obj, '<STR_LIT>', None)-<NUM_LIT:1><EOL><DEDENT>if lineno is not None:<EOL><INDENT>if source_lines is None:<EOL><INDENT>return lineno+<NUM_LIT:1><EOL><DEDENT>pat = re.compile('<STR_LIT>')<EOL>for lineno in range(lineno, len(source_lines)):<EOL><INDENT>if pat.match(source_lines[lineno]):<EOL><INDENT>return lineno<EOL><DEDENT><DEDENT><DEDENT>return None<EOL>", "docstring": "Return a line number of the given object's docstring.  Note:\nthis method assumes that the object has a docstring.", "id": "f21705:c5:m6"}
{"signature": "def DocFileSuite(*paths, **kw):", "body": "suite = unittest.TestSuite()<EOL>if kw.get('<STR_LIT>', True):<EOL><INDENT>kw['<STR_LIT>'] = _normalize_module(kw.get('<STR_LIT>'))<EOL><DEDENT>for path in paths:<EOL><INDENT>suite.addTest(DocFileTest(path, **kw))<EOL><DEDENT>return suite<EOL>", "docstring": "A unittest suite for one or more doctest files.\n\n    The path to each doctest file is given as a string; the\n    interpretation of that string depends on the keyword argument\n    \"module_relative\".\n\n    A number of options may be provided as keyword arguments:\n\n    module_relative\n      If \"module_relative\" is True, then the given file paths are\n      interpreted as os-independent module-relative paths.  By\n      default, these paths are relative to the calling module's\n      directory; but if the \"package\" argument is specified, then\n      they are relative to that package.  To ensure os-independence,\n      \"filename\" should use \"/\" characters to separate path\n      segments, and may not be an absolute path (i.e., it may not\n      begin with \"/\").\n\n      If \"module_relative\" is False, then the given file paths are\n      interpreted as os-specific paths.  These paths may be absolute\n      or relative (to the current working directory).\n\n    package\n      A Python package or the name of a Python package whose directory\n      should be used as the base directory for module relative paths.\n      If \"package\" is not specified, then the calling module's\n      directory is used as the base directory for module relative\n      filenames.  It is an error to specify \"package\" if\n      \"module_relative\" is False.\n\n    setUp\n      A set-up function.  This is called before running the\n      tests in each file. The setUp function will be passed a DocTest\n      object.  The setUp function can access the test globals as the\n      globs attribute of the test passed.\n\n    tearDown\n      A tear-down function.  This is called after running the\n      tests in each file.  The tearDown function will be passed a DocTest\n      object.  The tearDown function can access the test globals as the\n      globs attribute of the test passed.\n\n    globs\n      A dictionary containing initial global variables for the tests.\n\n    optionflags\n      A set of doctest option flags expressed as an integer.\n\n    parser\n      A DocTestParser (or subclass) that should be used to extract\n      tests from the files.", "id": "f21705:m15"}
{"signature": "def _assertIn(self, member, container):", "body": "if member not in container:<EOL><INDENT>standardMsg = '<STR_LIT>' % (safe_repr(member),<EOL>safe_repr(container))<EOL>self.fail(self._formatMessage(msg, standardMsg))<EOL><DEDENT>", "docstring": "assertIn and assertTrue does not exist in Python2.3", "id": "f21706:c6:m2"}
{"signature": "def make_trivial_sdist(dist_path, setup_py):", "body": "setup_py_file = tarfile.TarInfo(name='<STR_LIT>')<EOL>try:<EOL><INDENT>MemFile = StringIO.BytesIO<EOL><DEDENT>except AttributeError:<EOL><INDENT>MemFile = StringIO.StringIO<EOL><DEDENT>setup_py_bytes = MemFile(setup_py.encode('<STR_LIT:utf-8>'))<EOL>setup_py_file.size = len(setup_py_bytes.getvalue())<EOL>dist = tarfile.open(dist_path, '<STR_LIT>')<EOL>try:<EOL><INDENT>dist.addfile(setup_py_file, fileobj=setup_py_bytes)<EOL><DEDENT>finally:<EOL><INDENT>dist.close()<EOL><DEDENT>", "docstring": "Create a simple sdist tarball at dist_path, containing just a\n    setup.py, the contents of which are provided by the setup_py string.", "id": "f21707:m1"}
{"signature": "def has_win32com():", "body": "if not sys.platform.startswith('<STR_LIT:win32>'):<EOL><INDENT>return False<EOL><DEDENT>try:<EOL><INDENT>mod = __import__('<STR_LIT>')<EOL><DEDENT>except ImportError:<EOL><INDENT>return False<EOL><DEDENT>return True<EOL>", "docstring": "Run this to determine if the local machine has win32com, and if it\ndoes, include additional tests.", "id": "f21708:m0"}
{"signature": "def stop(self):", "body": "<EOL>time.sleep(<NUM_LIT:0.1>)<EOL>self._run = False<EOL>url = '<STR_LIT>' % vars(self)<EOL>try:<EOL><INDENT>if sys.version_info >= (<NUM_LIT:2>, <NUM_LIT:6>):<EOL><INDENT>urllib2.urlopen(url, timeout=<NUM_LIT:5>)<EOL><DEDENT>else:<EOL><INDENT>urllib2.urlopen(url)<EOL><DEDENT><DEDENT>except urllib2.URLError:<EOL><INDENT>pass<EOL><DEDENT>self.thread.join()<EOL>", "docstring": "Stop the server", "id": "f21710:c0:m3"}
{"signature": "def makeSetup(**args):", "body": "distutils.core._setup_stop_after = \"<STR_LIT>\"<EOL>args.setdefault('<STR_LIT>',['<STR_LIT>'])<EOL>try:<EOL><INDENT>return setuptools.setup(**args)<EOL><DEDENT>finally:<EOL><INDENT>distutils.core._setup_stop_after = None<EOL><DEDENT>", "docstring": "Return distribution from 'setup(**args)', without executing commands", "id": "f21713:m1"}
{"signature": "def distros_for_url(url, metadata=None):", "body": "base, fragment = egg_info_for_url(url)<EOL>for dist in distros_for_location(url, base, metadata): yield dist<EOL>if fragment:<EOL><INDENT>match = EGG_FRAGMENT.match(fragment)<EOL>if match:<EOL><INDENT>for dist in interpret_distro_name(<EOL>url, match.group(<NUM_LIT:1>), metadata, precedence = CHECKOUT_DIST<EOL>):<EOL><INDENT>yield dist<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Yield egg or source distribution objects that might be found at a URL", "id": "f21720:m2"}
{"signature": "def process_url(self, url, retrieve=False):", "body": "if url in self.scanned_urls and not retrieve:<EOL><INDENT>return<EOL><DEDENT>self.scanned_urls[url] = True<EOL>if not URL_SCHEME(url):<EOL><INDENT>self.process_filename(url)<EOL>return<EOL><DEDENT>else:<EOL><INDENT>dists = list(distros_for_url(url))<EOL>if dists:<EOL><INDENT>if not self.url_ok(url):<EOL><INDENT>return<EOL><DEDENT>self.debug(\"<STR_LIT>\", url)<EOL><DEDENT><DEDENT>if dists or not retrieve or url in self.fetched_urls:<EOL><INDENT>list(map(self.add, dists))<EOL>return  <EOL><DEDENT>if not self.url_ok(url):<EOL><INDENT>self.fetched_urls[url] = True<EOL>return<EOL><DEDENT>self.info(\"<STR_LIT>\", url)<EOL>f = self.open_url(url, \"<STR_LIT>\" % url)<EOL>if f is None: return<EOL>self.fetched_urls[url] = self.fetched_urls[f.url] = True<EOL>if '<STR_LIT:html>' not in f.headers.get('<STR_LIT>', '<STR_LIT>').lower():<EOL><INDENT>f.close()   <EOL>return<EOL><DEDENT>base = f.url     <EOL>page = f.read()<EOL>if not isinstance(page, str): <EOL><INDENT>if isinstance(f, urllib.error.HTTPError):<EOL><INDENT>charset = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>charset = f.headers.get_param('<STR_LIT>') or '<STR_LIT>'<EOL><DEDENT>page = page.decode(charset, \"<STR_LIT:ignore>\")<EOL><DEDENT>f.close()<EOL>for match in HREF.finditer(page):<EOL><INDENT>link = urllib.parse.urljoin(base, htmldecode(match.group(<NUM_LIT:1>)))<EOL>self.process_url(link)<EOL><DEDENT>if url.startswith(self.index_url) and getattr(f,'<STR_LIT:code>',None)!=<NUM_LIT>:<EOL><INDENT>page = self.process_index(url, page)<EOL><DEDENT>", "docstring": "Evaluate a URL as a possible download, and maybe retrieve it", "id": "f21720:c0:m1"}
{"signature": "def local_open(url):", "body": "scheme, server, path, param, query, frag = urllib.parse.urlparse(url)<EOL>filename = urllib.request.url2pathname(path)<EOL>if os.path.isfile(filename):<EOL><INDENT>return urllib.request.urlopen(url)<EOL><DEDENT>elif path.endswith('<STR_LIT:/>') and os.path.isdir(filename):<EOL><INDENT>files = []<EOL>for f in os.listdir(filename):<EOL><INDENT>if f=='<STR_LIT>':<EOL><INDENT>fp = open(os.path.join(filename,f),'<STR_LIT:rb>')<EOL>body = fp.read()<EOL>fp.close()<EOL>break<EOL><DEDENT>elif os.path.isdir(os.path.join(filename,f)):<EOL><INDENT>f+='<STR_LIT:/>'<EOL><DEDENT>files.append(\"<STR_LIT>\" % (f,f))<EOL><DEDENT>else:<EOL><INDENT>body = (\"<STR_LIT>\" % url) +\"<STR_LIT>\" % '<STR_LIT:\\n>'.join(files)<EOL><DEDENT>status, message = <NUM_LIT:200>, \"<STR_LIT:OK>\"<EOL><DEDENT>else:<EOL><INDENT>status, message, body = <NUM_LIT>, \"<STR_LIT>\", \"<STR_LIT>\"<EOL><DEDENT>return urllib.error.HTTPError(url, status, message,<EOL>{'<STR_LIT>':'<STR_LIT>'}, io.StringIO(body))<EOL>", "docstring": "Read a local path, with special support for directories", "id": "f21720:m14"}
{"signature": "def htmldecode(text):", "body": "return entity_sub(decode_entity, text)<EOL>", "docstring": "Decode HTML entities in the given text.", "id": "f21720:m9"}
{"signature": "def fetch_distribution(self,<EOL>requirement, tmpdir, force_scan=False, source=False, develop_ok=False,<EOL>local_index=None<EOL>):", "body": "<EOL>self.info(\"<STR_LIT>\", requirement)<EOL>skipped = {}<EOL>dist = None<EOL>def find(req, env=None):<EOL><INDENT>if env is None:<EOL><INDENT>env = self<EOL><DEDENT>for dist in env[req.key]:<EOL><INDENT>if dist.precedence==DEVELOP_DIST and not develop_ok:<EOL><INDENT>if dist not in skipped:<EOL><INDENT>self.warn(\"<STR_LIT>\",dist)<EOL>skipped[dist] = <NUM_LIT:1><EOL><DEDENT>continue<EOL><DEDENT>if dist in req and (dist.precedence<=SOURCE_DIST or not source):<EOL><INDENT>self.info(\"<STR_LIT>\", dist)<EOL>return dist.clone(<EOL>location=self.download(dist.location, tmpdir)<EOL>)<EOL><DEDENT><DEDENT><DEDENT>if force_scan:<EOL><INDENT>self.prescan()<EOL>self.find_packages(requirement)<EOL>dist = find(requirement)<EOL><DEDENT>if local_index is not None:<EOL><INDENT>dist = dist or find(requirement, local_index)<EOL><DEDENT>if dist is None and self.to_scan is not None:<EOL><INDENT>self.prescan()<EOL>dist = find(requirement)<EOL><DEDENT>if dist is None and not force_scan:<EOL><INDENT>self.find_packages(requirement)<EOL>dist = find(requirement)<EOL><DEDENT>if dist is None:<EOL><INDENT>self.warn(<EOL>\"<STR_LIT>\",<EOL>(source and \"<STR_LIT>\" or \"<STR_LIT>\"),<EOL>requirement,<EOL>)<EOL><DEDENT>return dist<EOL>", "docstring": "Obtain a distribution suitable for fulfilling `requirement`\n\n        `requirement` must be a ``pkg_resources.Requirement`` instance.\n        If necessary, or if the `force_scan` flag is set, the requirement is\n        searched for in the (online) package index as well as the locally\n        installed packages.  If a distribution matching `requirement` is found,\n        the returned distribution's ``location`` is the value you would have\n        gotten from calling the ``download()`` method with the matching\n        distribution's URL or filename.  If no matching distribution is found,\n        ``None`` is returned.\n\n        If the `source` flag is set, only source distributions and source\n        checkout links will be considered.  Unless the `develop_ok` flag is\n        set, development and system eggs (i.e., those using the ``.egg-info``\n        format) will be ignored.", "id": "f21720:c0:m16"}
{"signature": "def add_find_links(self, urls):", "body": "for url in urls:<EOL><INDENT>if (<EOL>self.to_scan is None        <EOL>or not URL_SCHEME(url)      <EOL>or url.startswith('<STR_LIT>')<EOL>or list(distros_for_url(url))   <EOL>):<EOL><INDENT>self.scan_url(url)<EOL><DEDENT>else:<EOL><INDENT>self.to_scan.append(url)<EOL><DEDENT><DEDENT>", "docstring": "Add `urls` to the list that will be prescanned for searches", "id": "f21720:c0:m12"}
{"signature": "def check_package(self, package, package_dir):", "body": "try:<EOL><INDENT>return self.packages_checked[package]<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>init_py = _build_py.check_package(self, package, package_dir)<EOL>self.packages_checked[package] = init_py<EOL>if not init_py or not self.distribution.namespace_packages:<EOL><INDENT>return init_py<EOL><DEDENT>for pkg in self.distribution.namespace_packages:<EOL><INDENT>if pkg==package or pkg.startswith(package+'<STR_LIT:.>'):<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return init_py<EOL><DEDENT>f = open(init_py,'<STR_LIT>')<EOL>if '<STR_LIT>'.encode() not in f.read():<EOL><INDENT>from distutils import log<EOL>log.warn(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>'<STR_LIT>'<EOL>\"<STR_LIT>\", package<EOL>)<EOL><DEDENT>f.close()<EOL>return init_py<EOL>", "docstring": "Check namespace packages' __init__ for declare_namespace", "id": "f21722:c0:m9"}
{"signature": "def find_data_files(self, package, src_dir):", "body": "globs = (self.package_data.get('<STR_LIT>', [])<EOL>+ self.package_data.get(package, []))<EOL>files = self.manifest_files.get(package, [])[:]<EOL>for pattern in globs:<EOL><INDENT>files.extend(glob(os.path.join(src_dir, convert_path(pattern))))<EOL><DEDENT>return self.exclude_data_files(package, src_dir, files)<EOL>", "docstring": "Return filenames for package's data files in 'src_dir", "id": "f21722:c0:m5"}
{"signature": "def _get_data_files(self):", "body": "self.analyze_manifest()<EOL>data = []<EOL>for package in self.packages or ():<EOL><INDENT>src_dir = self.get_package_dir(package)<EOL>build_dir = os.path.join(*([self.build_lib] + package.split('<STR_LIT:.>')))<EOL>plen = len(src_dir)+<NUM_LIT:1><EOL>filenames = [<EOL>file[plen:] for file in self.find_data_files(package, src_dir)<EOL>]<EOL>data.append( (package, src_dir, build_dir, filenames) )<EOL><DEDENT>return data<EOL>", "docstring": "Generate list of '(package,src_dir,build_dir,filenames)' tuples", "id": "f21722:c0:m4"}
{"signature": "def build_package_data(self):", "body": "lastdir = None<EOL>for package, src_dir, build_dir, filenames in self.data_files:<EOL><INDENT>for filename in filenames:<EOL><INDENT>target = os.path.join(build_dir, filename)<EOL>self.mkpath(os.path.dirname(target))<EOL>srcfile = os.path.join(src_dir, filename)<EOL>outf, copied = self.copy_file(srcfile, target)<EOL>srcfile = os.path.abspath(srcfile)<EOL>if copied and srcfile in self.distribution.convert_2to3_doctests:<EOL><INDENT>self.__doctests_2to3.append(outf)<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Copy data files into build directory", "id": "f21722:c0:m6"}
{"signature": "def expand_dirs(self):", "body": "self._expand_attrs(['<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>',<EOL>'<STR_LIT>', '<STR_LIT>',])<EOL>", "docstring": "Calls `os.path.expanduser` on install dirs.", "id": "f21725:c0:m5"}
{"signature": "def is_sh(executable):", "body": "try:<EOL><INDENT>fp = open(executable)<EOL>magic = fp.read(<NUM_LIT:2>)<EOL>fp.close()<EOL><DEDENT>except (OSError,IOError): return executable<EOL>return magic == '<STR_LIT>'<EOL>", "docstring": "Determine if the specified executable is a .sh (contains a #! line)", "id": "f21725:m12"}
{"signature": "def extract_wininst_cfg(dist_filename):", "body": "f = open(dist_filename,'<STR_LIT:rb>')<EOL>try:<EOL><INDENT>endrec = zipfile._EndRecData(f)<EOL>if endrec is None:<EOL><INDENT>return None<EOL><DEDENT>prepended = (endrec[<NUM_LIT:9>] - endrec[<NUM_LIT:5>]) - endrec[<NUM_LIT:6>]<EOL>if prepended < <NUM_LIT:12>:  <EOL><INDENT>return None<EOL><DEDENT>f.seek(prepended-<NUM_LIT:12>)<EOL>import struct, io, configparser<EOL>tag, cfglen, bmlen = struct.unpack(\"<STR_LIT>\",f.read(<NUM_LIT:12>))<EOL>if tag not in (<NUM_LIT>, <NUM_LIT>):<EOL><INDENT>return None     <EOL><DEDENT>f.seek(prepended-(<NUM_LIT:12>+cfglen))<EOL>cfg = configparser.RawConfigParser({'<STR_LIT:version>':'<STR_LIT>','<STR_LIT>':'<STR_LIT>'})<EOL>try:<EOL><INDENT>part = f.read(cfglen)<EOL>if sys.version_info >= (<NUM_LIT:2>,<NUM_LIT:6>):<EOL><INDENT>null_byte = bytes([<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>null_byte = chr(<NUM_LIT:0>)<EOL><DEDENT>config = part.split(null_byte, <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>config = config.decode('<STR_LIT:ascii>')<EOL>cfg.readfp(io.StringIO(config))<EOL><DEDENT>except configparser.Error:<EOL><INDENT>return None<EOL><DEDENT>if not cfg.has_section('<STR_LIT>') or not cfg.has_section('<STR_LIT>'):<EOL><INDENT>return None<EOL><DEDENT>return cfg<EOL><DEDENT>finally:<EOL><INDENT>f.close()<EOL><DEDENT>", "docstring": "Extract configuration data from a bdist_wininst .exe\n\n    Returns a ConfigParser.RawConfigParser, or None", "id": "f21725:m4"}
{"signature": "def write_script(self, script_name, contents, mode=\"<STR_LIT:t>\", blockers=()):", "body": "self.delete_blockers(   <EOL>[os.path.join(self.script_dir,x) for x in blockers])<EOL>log.info(\"<STR_LIT>\", script_name, self.script_dir)<EOL>target = os.path.join(self.script_dir, script_name)<EOL>self.add_output(target)<EOL>mask = current_umask()<EOL>if not self.dry_run:<EOL><INDENT>ensure_directory(target)<EOL>f = open(target,\"<STR_LIT:w>\"+mode)<EOL>f.write(contents)<EOL>f.close()<EOL>chmod(target, <NUM_LIT>-mask)<EOL><DEDENT>", "docstring": "Write an executable file to the scripts directory", "id": "f21725:c0:m24"}
{"signature": "def install_script(self, dist, script_name, script_text, dev_path=None):", "body": "spec = str(dist.as_requirement())<EOL>is_script = is_python_script(script_text, script_name)<EOL>def get_template(filename):<EOL><INDENT>\"\"\"<STR_LIT>\"\"\"<EOL>raw_bytes = resource_string('<STR_LIT>', template_name)<EOL>template_str = raw_bytes.decode('<STR_LIT:utf-8>')<EOL>clean_template = template_str.replace('<STR_LIT>', '<STR_LIT>')<EOL>return clean_template<EOL><DEDENT>if is_script:<EOL><INDENT>template_name = '<STR_LIT>'<EOL>if dev_path:<EOL><INDENT>template_name = template_name.replace('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>script_text = (get_script_header(script_text) +<EOL>get_template(template_name) % locals())<EOL><DEDENT>self.write_script(script_name, _to_ascii(script_text), '<STR_LIT:b>')<EOL>", "docstring": "Generate a legacy script wrapper and install it", "id": "f21725:c0:m23"}
{"signature": "def install_site_py(self):", "body": "if self.sitepy_installed:<EOL><INDENT>return  <EOL><DEDENT>sitepy = os.path.join(self.install_dir, \"<STR_LIT>\")<EOL>source = resource_string(Requirement.parse(\"<STR_LIT>\"), \"<STR_LIT>\")<EOL>current = \"<STR_LIT>\"<EOL>if os.path.exists(sitepy):<EOL><INDENT>log.debug(\"<STR_LIT>\", self.install_dir)<EOL>f = open(sitepy,'<STR_LIT:rb>')<EOL>current = f.read()<EOL>if sys.version_info >= (<NUM_LIT:3>,):<EOL><INDENT>current = current.decode()<EOL><DEDENT>f.close()<EOL>if not current.startswith('<STR_LIT>'):<EOL><INDENT>raise DistutilsError(<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % sitepy<EOL>)<EOL><DEDENT><DEDENT>if current != source:<EOL><INDENT>log.info(\"<STR_LIT>\", sitepy)<EOL>if not self.dry_run:<EOL><INDENT>ensure_directory(sitepy)<EOL>f = open(sitepy,'<STR_LIT:wb>')<EOL>f.write(source)<EOL>f.close()<EOL><DEDENT>self.byte_compile([sitepy])<EOL><DEDENT>self.sitepy_installed = True<EOL>", "docstring": "Make sure there's a site.py in the target dir, if needed", "id": "f21725:c0:m42"}
{"signature": "def get_script_header(script_text, executable=sys_executable, wininst=False):", "body": "from distutils.command.build_scripts import first_line_re<EOL>if not isinstance(first_line_re.pattern, str):<EOL><INDENT>first_line_re = re.compile(first_line_re.pattern.decode())<EOL><DEDENT>first = (script_text+'<STR_LIT:\\n>').splitlines()[<NUM_LIT:0>]<EOL>match = first_line_re.match(first)<EOL>options = '<STR_LIT>'<EOL>if match:<EOL><INDENT>options = match.group(<NUM_LIT:1>) or '<STR_LIT>'<EOL>if options: options = '<STR_LIT:U+0020>'+options<EOL><DEDENT>if wininst:<EOL><INDENT>executable = \"<STR_LIT>\"<EOL><DEDENT>else:<EOL><INDENT>executable = nt_quote_arg(executable)<EOL><DEDENT>hdr = \"<STR_LIT>\" % locals()<EOL>if not isascii(hdr):<EOL><INDENT>if options:<EOL><INDENT>if options.strip().startswith('<STR_LIT:->'):<EOL><INDENT>options = '<STR_LIT>'+options.strip()[<NUM_LIT:1>:]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>options = '<STR_LIT>'<EOL><DEDENT><DEDENT>executable = fix_jython_executable(executable, options)<EOL>hdr = \"<STR_LIT>\" % locals()<EOL>return hdr<EOL>", "docstring": "Create a #! line, getting options (if any) from script_text", "id": "f21725:m7"}
{"signature": "def save(self):", "body": "if not self.dirty:<EOL><INDENT>return<EOL><DEDENT>data = '<STR_LIT:\\n>'.join(map(self.make_relative,self.paths))<EOL>if data:<EOL><INDENT>log.debug(\"<STR_LIT>\", self.filename)<EOL>data = (<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>) % data<EOL>if os.path.islink(self.filename):<EOL><INDENT>os.unlink(self.filename)<EOL><DEDENT>f = open(self.filename,'<STR_LIT>')<EOL>f.write(data); f.close()<EOL><DEDENT>elif os.path.exists(self.filename):<EOL><INDENT>log.debug(\"<STR_LIT>\", self.filename)<EOL>os.unlink(self.filename)<EOL><DEDENT>self.dirty = False<EOL>", "docstring": "Write changed .pth file back to disk", "id": "f21725:c1:m2"}
{"signature": "def select_scheme(self, name):", "body": "<EOL>scheme = INSTALL_SCHEMES[name]<EOL>for key in SCHEME_KEYS:<EOL><INDENT>attrname = '<STR_LIT>' + key<EOL>if getattr(self, attrname) is None:<EOL><INDENT>setattr(self, attrname, scheme[key])<EOL><DEDENT><DEDENT>", "docstring": "Sets the install directories by applying the install schemes.", "id": "f21725:c0:m18"}
{"signature": "def is_python(text, filename='<STR_LIT>'):", "body": "try:<EOL><INDENT>compile(text, filename, '<STR_LIT>')<EOL><DEDENT>except (SyntaxError, TypeError):<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>return True<EOL><DEDENT>", "docstring": "Is this string a valid Python script?", "id": "f21725:m11"}
{"signature": "def externals_finder(dirname, filename):", "body": "found = False<EOL>f = open(filename,'<STR_LIT>')<EOL>for line in iter(f.readline, '<STR_LIT>'):    <EOL><INDENT>parts = line.split()<EOL>if len(parts)==<NUM_LIT:2>:<EOL><INDENT>kind,length = parts<EOL>data = f.read(int(length))<EOL>if kind=='<STR_LIT>' and data=='<STR_LIT>':<EOL><INDENT>found = True<EOL><DEDENT>elif kind=='<STR_LIT>' and found:<EOL><INDENT>f.close()<EOL>break<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>f.close()<EOL>return<EOL><DEDENT>for line in data.splitlines():<EOL><INDENT>parts = line.split()<EOL>if parts:<EOL><INDENT>yield joinpath(dirname, parts[<NUM_LIT:0>])<EOL><DEDENT><DEDENT>", "docstring": "Find any 'svn:externals' directories", "id": "f21726:m5"}
{"signature": "def walk_egg(egg_dir):", "body": "walker = os.walk(egg_dir)<EOL>base,dirs,files = next(walker)<EOL>if '<STR_LIT>' in dirs:<EOL><INDENT>dirs.remove('<STR_LIT>')<EOL><DEDENT>yield base,dirs,files<EOL>for bdf in walker:<EOL><INDENT>yield bdf<EOL><DEDENT>", "docstring": "Walk an unpacked egg's contents, skipping the metadata directory", "id": "f21727:m2"}
{"signature": "def write_file(self, what, filename, data):", "body": "log.info(\"<STR_LIT>\", what, filename)<EOL>if sys.version_info >= (<NUM_LIT:3>,):<EOL><INDENT>data = data.encode(\"<STR_LIT:utf-8>\")<EOL><DEDENT>if not self.dry_run:<EOL><INDENT>f = open(filename, '<STR_LIT:wb>')<EOL>f.write(data)<EOL>f.close()<EOL><DEDENT>", "docstring": "Write `data` to `filename` (if not a dry run) after announcing it\n\n        `what` is used in a log message to identify what is being written\n        to the file.", "id": "f21734:c0:m4"}
{"signature": "def delete_file(self, filename):", "body": "log.info(\"<STR_LIT>\", filename)<EOL>if not self.dry_run:<EOL><INDENT>os.unlink(filename)<EOL><DEDENT>", "docstring": "Delete `filename` (if not a dry run) after announcing it", "id": "f21734:c0:m5"}
{"signature": "def find_sources(self):", "body": "manifest_filename = os.path.join(self.egg_info,\"<STR_LIT>\")<EOL>mm = manifest_maker(self.distribution)<EOL>mm.manifest = manifest_filename<EOL>mm.run()<EOL>self.filelist = mm.filelist<EOL>", "docstring": "Generate SOURCES.txt manifest file", "id": "f21734:c0:m10"}
{"signature": "def config_file(kind=\"<STR_LIT>\"):", "body": "if kind=='<STR_LIT>':<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>if kind=='<STR_LIT>':<EOL><INDENT>return os.path.join(<EOL>os.path.dirname(distutils.__file__),'<STR_LIT>'<EOL>)<EOL><DEDENT>if kind=='<STR_LIT:user>':<EOL><INDENT>dot = os.name=='<STR_LIT>' and '<STR_LIT:.>' or '<STR_LIT>'<EOL>return os.path.expanduser(convert_path(\"<STR_LIT>\" % dot))<EOL><DEDENT>raise ValueError(<EOL>\"<STR_LIT>\", kind<EOL>)<EOL>", "docstring": "Get the filename of the distutils, local, global, or per-user config\n\n    `kind` must be one of \"local\", \"global\", or \"user\"", "id": "f21740:m0"}
{"signature": "def findall(dir = os.curdir):", "body": "all_files = []<EOL>for base, dirs, files in os.walk(dir):<EOL><INDENT>if base==os.curdir or base.startswith(os.curdir+os.sep):<EOL><INDENT>base = base[<NUM_LIT:2>:]<EOL><DEDENT>if base:<EOL><INDENT>files = [os.path.join(base, f) for f in files]<EOL><DEDENT>all_files.extend(filter(os.path.isfile, files))<EOL><DEDENT>return all_files<EOL>", "docstring": "Find all files under 'dir' and return the list of full filenames\n    (relative to 'dir').", "id": "f21743:m1"}
{"signature": "def _remap_output(self,operation,path):", "body": "return self._validate_path(path)<EOL>", "docstring": "Called for path outputs", "id": "f21745:c0:m9"}
{"signature": "def open(self, file, flags, mode=<NUM_LIT>):", "body": "if flags & WRITE_FLAGS and not self._ok(file):<EOL><INDENT>self._violation(\"<STR_LIT>\", file, flags, mode)<EOL><DEDENT>return _os.open(file,flags,mode)<EOL>", "docstring": "Called for low-level os.open()", "id": "f21745:c1:m8"}
{"signature": "def feature_is_included(self,name):", "body": "return getattr(self,self._feature_attrname(name))<EOL>", "docstring": "Return 1 if feature is included, 0 if excluded, 'None' if unknown", "id": "f21746:c0:m12"}
{"signature": "def _set_global_opts_from_features(self):", "body": "go = []<EOL>no = self.negative_opt.copy()<EOL>for name,feature in list(self.features.items()):<EOL><INDENT>self._set_feature(name,None)<EOL>feature.validate(self)<EOL>if feature.optional:<EOL><INDENT>descr = feature.description<EOL>incdef = '<STR_LIT>'<EOL>excdef='<STR_LIT>'<EOL>if not feature.include_by_default():<EOL><INDENT>excdef, incdef = incdef, excdef<EOL><DEDENT>go.append(('<STR_LIT>'+name, None, '<STR_LIT>'+descr+incdef))<EOL>go.append(('<STR_LIT>'+name, None, '<STR_LIT>'+descr+excdef))<EOL>no['<STR_LIT>'+name] = '<STR_LIT>'+name<EOL><DEDENT><DEDENT>self.global_options = self.feature_options = go + self.global_options<EOL>self.negative_opt = self.feature_negopt = no<EOL>", "docstring": "Add --with-X/--without-X options based on optional features", "id": "f21746:c0:m7"}
{"signature": "def include_by_default(self):", "body": "return self.available and self.standard<EOL>", "docstring": "Should this feature be included by default?", "id": "f21746:c1:m1"}
{"signature": "def _feature_attrname(self,name):", "body": "return '<STR_LIT>'+name.replace('<STR_LIT:->','<STR_LIT:_>')<EOL>", "docstring": "Convert feature name to corresponding option attribute name", "id": "f21746:c0:m3"}
{"signature": "def exclude_from(self,dist):", "body": "dist.exclude(**self.extras)<EOL>if self.remove:<EOL><INDENT>for item in self.remove:<EOL><INDENT>dist.exclude_package(item)<EOL><DEDENT><DEDENT>", "docstring": "Ensure feature is excluded from distribution\n\n        You may override this in a subclass to perform additional operations on\n        the distribution.  This method will be called at most once per\n        feature, and only after all included features have been asked to\n        include themselves.", "id": "f21746:c1:m3"}
{"signature": "def iter_distribution_names(self):", "body": "for pkg in self.packages or ():<EOL><INDENT>yield pkg<EOL><DEDENT>for module in self.py_modules or ():<EOL><INDENT>yield module<EOL><DEDENT>for ext in self.ext_modules or ():<EOL><INDENT>if isinstance(ext,tuple):<EOL><INDENT>name, buildinfo = ext<EOL><DEDENT>else:<EOL><INDENT>name = ext.name<EOL><DEDENT>if name.endswith('<STR_LIT>'):<EOL><INDENT>name = name[:-<NUM_LIT:6>]<EOL><DEDENT>yield name<EOL><DEDENT>", "docstring": "Yield all packages, modules, and extension names in distribution", "id": "f21746:c0:m23"}
{"signature": "def handle_display_options(self, option_order):", "body": "import sys<EOL>if sys.version_info < (<NUM_LIT:3>,) or self.help_commands:<EOL><INDENT>return _Distribution.handle_display_options(self, option_order)<EOL><DEDENT>import io<EOL>if not isinstance(sys.stdout, io.TextIOWrapper):<EOL><INDENT>return _Distribution.handle_display_options(self, option_order)<EOL><DEDENT>if sys.stdout.encoding.lower() in ('<STR_LIT:utf-8>', '<STR_LIT:utf8>'):<EOL><INDENT>return _Distribution.handle_display_options(self, option_order)<EOL><DEDENT>encoding = sys.stdout.encoding<EOL>errors = sys.stdout.errors<EOL>newline = sys.platform != '<STR_LIT:win32>' and '<STR_LIT:\\n>' or None<EOL>line_buffering = sys.stdout.line_buffering<EOL>sys.stdout = io.TextIOWrapper(<EOL>sys.stdout.detach(), '<STR_LIT:utf-8>', errors, newline, line_buffering)<EOL>try:<EOL><INDENT>return _Distribution.handle_display_options(self, option_order)<EOL><DEDENT>finally:<EOL><INDENT>sys.stdout = io.TextIOWrapper(<EOL>sys.stdout.detach(), encoding, errors, newline, line_buffering)<EOL><DEDENT>", "docstring": "If there were any non-global \"display-only\" options\n        (--help-commands or the metadata display options) on the command\n        line, display the requested info and return true; else return\n        false.", "id": "f21746:c0:m24"}
{"signature": "def check_entry_points(dist, attr, value):", "body": "try:<EOL><INDENT>pkg_resources.EntryPoint.parse_map(value)<EOL><DEDENT>except ValueError as e:<EOL><INDENT>raise DistutilsSetupError(e)<EOL><DEDENT>", "docstring": "Verify that entry_points map is parseable", "id": "f21746:m7"}
{"signature": "def exclude_package(self,package):", "body": "pfx = package+'<STR_LIT:.>'<EOL>if self.packages:<EOL><INDENT>self.packages = [<EOL>p for p in self.packages<EOL>if p != package and not p.startswith(pfx)<EOL>]<EOL><DEDENT>if self.py_modules:<EOL><INDENT>self.py_modules = [<EOL>p for p in self.py_modules<EOL>if p != package and not p.startswith(pfx)<EOL>]<EOL><DEDENT>if self.ext_modules:<EOL><INDENT>self.ext_modules = [<EOL>p for p in self.ext_modules<EOL>if p.name != package and not p.name.startswith(pfx)<EOL>]<EOL><DEDENT>", "docstring": "Remove packages, modules, and extensions in named package", "id": "f21746:c0:m15"}
{"signature": "def _convert_pyx_sources_to_c(self):", "body": "def pyx_to_c(source):<EOL><INDENT>if source.endswith('<STR_LIT>'):<EOL><INDENT>source = source[:-<NUM_LIT:4>] + '<STR_LIT>'<EOL><DEDENT>return source<EOL><DEDENT>self.sources = map(pyx_to_c, self.sources)<EOL>", "docstring": "convert .pyx extensions to .c", "id": "f21747:c0:m1"}
{"signature": "def _iter_code(code):", "body": "from array import array<EOL>from dis import HAVE_ARGUMENT, EXTENDED_ARG<EOL>bytes = array('<STR_LIT:b>',code.co_code)<EOL>eof = len(code.co_code)<EOL>ptr = <NUM_LIT:0><EOL>extended_arg = <NUM_LIT:0><EOL>while ptr<eof:<EOL><INDENT>op = bytes[ptr]<EOL>if op>=HAVE_ARGUMENT:<EOL><INDENT>arg = bytes[ptr+<NUM_LIT:1>] + bytes[ptr+<NUM_LIT:2>]*<NUM_LIT> + extended_arg<EOL>ptr += <NUM_LIT:3><EOL>if op==EXTENDED_ARG:<EOL><INDENT>extended_arg = arg * <NUM_LIT><EOL>continue<EOL><DEDENT><DEDENT>else:<EOL><INDENT>arg = None<EOL>ptr += <NUM_LIT:1><EOL><DEDENT>yield op,arg<EOL><DEDENT>", "docstring": "Yield '(op,arg)' pair for each operation in code object 'code", "id": "f21748:m0"}
{"signature": "def full_name(self):", "body": "if self.requested_version is not None:<EOL><INDENT>return '<STR_LIT>' % (self.name,self.requested_version)<EOL><DEDENT>return self.name<EOL>", "docstring": "Return full package/distribution name, w/version", "id": "f21748:c0:m1"}
{"signature": "def find_module(module, paths=None):", "body": "parts = module.split('<STR_LIT:.>')<EOL>while parts:<EOL><INDENT>part = parts.pop(<NUM_LIT:0>)<EOL>f, path, (suffix,mode,kind) = info = imp.find_module(part, paths)<EOL>if kind==PKG_DIRECTORY:<EOL><INDENT>parts = parts or ['<STR_LIT>']<EOL>paths = [path]<EOL><DEDENT>elif parts:<EOL><INDENT>raise ImportError(\"<STR_LIT>\" % (parts,module))<EOL><DEDENT><DEDENT>return info<EOL>", "docstring": "Just like 'imp.find_module()', but with package support", "id": "f21748:m1"}
{"signature": "def _get_mro(cls):", "body": "if not isinstance(cls,type):<EOL><INDENT>class cls(cls,object): pass<EOL>return cls.__mro__[<NUM_LIT:1>:]<EOL><DEDENT>return cls.__mro__<EOL>", "docstring": "Get an mro for a type or classic class", "id": "f21749:m49"}
{"signature": "def clone(self,**kw):", "body": "for attr in (<EOL>'<STR_LIT>', '<STR_LIT:version>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT:location>',<EOL>'<STR_LIT>'<EOL>):<EOL><INDENT>kw.setdefault(attr, getattr(self,attr,None))<EOL><DEDENT>kw.setdefault('<STR_LIT>', self._provider)<EOL>return self.__class__(**kw)<EOL>", "docstring": "Copy this distribution, substituting in any changed keyword args", "id": "f21749:c21:m28"}
{"signature": "def __add__(self, other):", "body": "new = self.__class__([], platform=None, python=None)<EOL>for env in self, other:<EOL><INDENT>new += env<EOL><DEDENT>return new<EOL>", "docstring": "Add an environment or distribution to an environment", "id": "f21749:c7:m10"}
{"signature": "def to_filename(name):", "body": "return name.replace('<STR_LIT:->','<STR_LIT:_>')<EOL>", "docstring": "Convert a project or version name to its filename-escaped form\n\n    Any '-' characters are currently replaced with '_'.", "id": "f21749:m24"}
{"signature": "def find_distributions(path_item, only=False):", "body": "importer = get_importer(path_item)<EOL>finder = _find_adapter(_distribution_finders, importer)<EOL>return finder(importer, path_item, only)<EOL>", "docstring": "Yield distributions accessible via `path_item`", "id": "f21749:m27"}
{"signature": "def __init__(self, importer):", "body": "self.zipinfo = zipimport._zip_directory_cache[importer.archive]<EOL>self.zip_pre = importer.archive+os.sep<EOL>self.loader = importer<EOL>if importer.prefix:<EOL><INDENT>self.module_path = os.path.join(importer.archive, importer.prefix)<EOL><DEDENT>else:<EOL><INDENT>self.module_path = importer.archive<EOL><DEDENT>self._setup_prefix()<EOL>", "docstring": "Create a metadata provider from a zipimporter", "id": "f21749:c17:m0"}
{"signature": "def get_metadata_lines(name):", "body": "", "docstring": "Yield named metadata resource as list of non-blank non-comment lines\n\n       Leading and trailing whitespace is stripped from each line, and lines\n       with ``#`` as the first non-blank character are omitted.", "id": "f21749:c4:m2"}
{"signature": "def file_ns_handler(importer, path_item, packageName, module):", "body": "subpath = os.path.join(path_item, packageName.split('<STR_LIT:.>')[-<NUM_LIT:1>])<EOL>normalized = _normalize_cached(subpath)<EOL>for item in module.__path__:<EOL><INDENT>if _normalize_cached(item)==normalized:<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return subpath<EOL><DEDENT>", "docstring": "Compute an ns-package subpath for a filesystem or zipfile importer", "id": "f21749:m36"}
{"signature": "def parse_group(cls, group, lines, dist=None):", "body": "if not MODULE(group):<EOL><INDENT>raise ValueError(\"<STR_LIT>\", group)<EOL><DEDENT>this = {}<EOL>for line in yield_lines(lines):<EOL><INDENT>ep = cls.parse(line, dist)<EOL>if ep.name in this:<EOL><INDENT>raise ValueError(\"<STR_LIT>\", group, ep.name)<EOL><DEDENT>this[ep.name]=ep<EOL><DEDENT>return this<EOL>", "docstring": "Parse an entry point group", "id": "f21749:c20:m6"}
{"signature": "def get_entry_info(self, group, name):", "body": "return self.get_entry_map(group).get(name)<EOL>", "docstring": "Return the EntryPoint object for `group`+`name`, or ``None``", "id": "f21749:c21:m24"}
{"signature": "def get_metadata(name):", "body": "", "docstring": "The named metadata resource as a string", "id": "f21749:c4:m1"}
{"signature": "def parse(cls, src, dist=None):", "body": "try:<EOL><INDENT>attrs = extras = ()<EOL>name,value = src.split('<STR_LIT:=>',<NUM_LIT:1>)<EOL>if '<STR_LIT:[>' in value:<EOL><INDENT>value,extras = value.split('<STR_LIT:[>',<NUM_LIT:1>)<EOL>req = Requirement.parse(\"<STR_LIT>\"+extras)<EOL>if req.specs: raise ValueError<EOL>extras = req.extras<EOL><DEDENT>if '<STR_LIT::>' in value:<EOL><INDENT>value,attrs = value.split('<STR_LIT::>',<NUM_LIT:1>)<EOL>if not MODULE(attrs.rstrip()):<EOL><INDENT>raise ValueError<EOL><DEDENT>attrs = attrs.rstrip().split('<STR_LIT:.>')<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\",<EOL>src<EOL>)<EOL><DEDENT>else:<EOL><INDENT>return cls(name.strip(), value.strip(), attrs, extras, dist)<EOL><DEDENT>", "docstring": "Parse a single entry point from string `src`\n\n        Entry point syntax follows the form::\n\n            name = some.module:some.attr [extra1,extra2]\n\n        The entry name and module name are required, but the ``:attrs`` and\n        ``[extras]`` parts are optional", "id": "f21749:c20:m5"}
{"signature": "def _handle_ns(packageName, path_item):", "body": "importer = get_importer(path_item)<EOL>if importer is None:<EOL><INDENT>return None<EOL><DEDENT>loader = importer.find_module(packageName)<EOL>if loader is None:<EOL><INDENT>return None<EOL><DEDENT>module = sys.modules.get(packageName)<EOL>if module is None:<EOL><INDENT>module = sys.modules[packageName] = types.ModuleType(packageName)<EOL>module.__path__ = []<EOL>_set_parent_ns(packageName)<EOL><DEDENT>elif not hasattr(module,'<STR_LIT>'):<EOL><INDENT>raise TypeError(\"<STR_LIT>\", packageName)<EOL><DEDENT>handler = _find_adapter(_namespace_handlers, importer)<EOL>subpath = handler(importer, path_item, packageName, module)<EOL>if subpath is not None:<EOL><INDENT>path = module.__path__<EOL>path.append(subpath)<EOL>loader.load_module(packageName)<EOL>for path_item in path:<EOL><INDENT>if path_item not in module.__path__:<EOL><INDENT>module.__path__.append(path_item)<EOL><DEDENT><DEDENT><DEDENT>return subpath<EOL>", "docstring": "Ensure that named package includes a subpath of path_item (if needed)", "id": "f21749:m33"}
{"signature": "def subscribe(self, callback):", "body": "if callback in self.callbacks:<EOL><INDENT>return<EOL><DEDENT>self.callbacks.append(callback)<EOL>for dist in self:<EOL><INDENT>callback(dist)<EOL><DEDENT>", "docstring": "Invoke `callback` for all distributions (including existing ones)", "id": "f21749:c6:m11"}
{"signature": "def get_default_cache():", "body": "try:<EOL><INDENT>return os.environ['<STR_LIT>']<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>if os.name!='<STR_LIT>':<EOL><INDENT>return os.path.expanduser('<STR_LIT>')<EOL><DEDENT>app_data = '<STR_LIT>'   <EOL>app_homes = [<EOL>(('<STR_LIT>',), None),       <EOL>(('<STR_LIT>',), app_data),<EOL>(('<STR_LIT>','<STR_LIT>'), app_data),<EOL>(('<STR_LIT>',), app_data),<EOL>(('<STR_LIT>',), None),<EOL>(('<STR_LIT>',), app_data),    <EOL>]<EOL>for keys, subdir in app_homes:<EOL><INDENT>dirname = '<STR_LIT>'<EOL>for key in keys:<EOL><INDENT>if key in os.environ:<EOL><INDENT>dirname = os.path.join(dirname, os.environ[key])<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if subdir:<EOL><INDENT>dirname = os.path.join(dirname,subdir)<EOL><DEDENT>return os.path.join(dirname, '<STR_LIT>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>raise RuntimeError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>", "docstring": "Determine the default cache location\n\n    This returns the ``PYTHON_EGG_CACHE`` environment variable, if set.\n    Otherwise, on Windows, it returns a \"Python-Eggs\" subdirectory of the\n    \"Application Data\" directory.  On all other systems, it's \"~/.python-eggs\".", "id": "f21749:m20"}
{"signature": "def _override_setuptools(req):", "body": "if req.project_name == '<STR_LIT>':<EOL><INDENT>if not len(req.specs):<EOL><INDENT>return True<EOL><DEDENT>for comparator, version in req.specs:<EOL><INDENT>if comparator in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT:>>']:<EOL><INDENT>if '<STR_LIT>' in version:<EOL><INDENT>return False<EOL><DEDENT><DEDENT><DEDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Return True when distribute wants to override a setuptools dependency.\n\n    We want to override when the requirement is setuptools and the version is\n    a variant of 0.6.", "id": "f21749:m48"}
{"signature": "def safe_version(version):", "body": "version = version.replace('<STR_LIT:U+0020>','<STR_LIT:.>')<EOL>return re.sub('<STR_LIT>', '<STR_LIT:->', version)<EOL>", "docstring": "Convert an arbitrary string to a standard version string\n\n    Spaces become dots, and all other non-alphanumeric characters become\n    dashes, with runs of multiple dashes condensed to a single dash.", "id": "f21749:m22"}
{"signature": "def find_on_path(importer, path_item, only=False):", "body": "path_item = _normalize_cached(path_item)<EOL>if os.path.isdir(path_item) and os.access(path_item, os.R_OK):<EOL><INDENT>if path_item.lower().endswith('<STR_LIT>'):<EOL><INDENT>yield Distribution.from_filename(<EOL>path_item, metadata=PathMetadata(<EOL>path_item, os.path.join(path_item,'<STR_LIT>')<EOL>)<EOL>)<EOL><DEDENT>else:<EOL><INDENT>for entry in os.listdir(path_item):<EOL><INDENT>lower = entry.lower()<EOL>if lower.endswith('<STR_LIT>') or lower.endswith('<STR_LIT>'):<EOL><INDENT>fullpath = os.path.join(path_item, entry)<EOL>if os.path.isdir(fullpath):<EOL><INDENT>metadata = PathMetadata(path_item, fullpath)<EOL><DEDENT>else:<EOL><INDENT>metadata = FileMetadata(fullpath)<EOL><DEDENT>yield Distribution.from_location(<EOL>path_item,entry,metadata,precedence=DEVELOP_DIST<EOL>)<EOL><DEDENT>elif not only and lower.endswith('<STR_LIT>'):<EOL><INDENT>for dist in find_distributions(os.path.join(path_item, entry)):<EOL><INDENT>yield dist<EOL><DEDENT><DEDENT>elif not only and lower.endswith('<STR_LIT>'):<EOL><INDENT>for line in open(os.path.join(path_item, entry)):<EOL><INDENT>if not line.strip(): continue<EOL>for item in find_distributions(os.path.join(path_item,line.rstrip())):<EOL><INDENT>yield item<EOL><DEDENT>break<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>", "docstring": "Yield distributions accessible on a sys.path directory", "id": "f21749:m31"}
{"signature": "def set_extraction_path(self, path):", "body": "if self.cached_files:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>self.extraction_path = path<EOL>", "docstring": "Set the base path where resources will be extracted to, if needed.\n\n        If you do not call this routine before any extractions take place, the\n        path defaults to the return value of ``get_default_cache()``.  (Which\n        is based on the ``PYTHON_EGG_CACHE`` environment variable, with various\n        platform-specific fallbacks.  See that routine's documentation for more\n        details.)\n\n        Resources are extracted to subdirectories of this path based upon\n        information given by the ``IResourceProvider``.  You may set this to a\n        temporary directory, but then you must call ``cleanup_resources()`` to\n        delete the extracted files when done.  There is no guarantee that\n        ``cleanup_resources()`` will be able to remove all extracted files.\n\n        (Note: you may not change the extraction path for a given resource\n        manager once resources have been extracted, unless you first call\n        ``cleanup_resources()``.)", "id": "f21749:c9:m10"}
{"signature": "def compatible_platforms(provided,required):", "body": "if provided is None or required is None or provided==required:<EOL><INDENT>return True     <EOL><DEDENT>reqMac = macosVersionString.match(required)<EOL>if reqMac:<EOL><INDENT>provMac = macosVersionString.match(provided)<EOL>if not provMac:<EOL><INDENT>provDarwin = darwinVersionString.match(provided)<EOL>if provDarwin:<EOL><INDENT>dversion = int(provDarwin.group(<NUM_LIT:1>))<EOL>macosversion = \"<STR_LIT>\" % (reqMac.group(<NUM_LIT:1>), reqMac.group(<NUM_LIT:2>))<EOL>if dversion == <NUM_LIT:7> and macosversion >= \"<STR_LIT>\" ordversion == <NUM_LIT:8> and macosversion >= \"<STR_LIT>\":<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False    <EOL><DEDENT>if provMac.group(<NUM_LIT:1>) != reqMac.group(<NUM_LIT:1>) orprovMac.group(<NUM_LIT:3>) != reqMac.group(<NUM_LIT:3>):<EOL><INDENT>return False<EOL><DEDENT>if int(provMac.group(<NUM_LIT:2>)) > int(reqMac.group(<NUM_LIT:2>)):<EOL><INDENT>return False<EOL><DEDENT>return True<EOL><DEDENT>return False<EOL>", "docstring": "Can code for the `provided` platform run on the `required` platform?\n\n    Returns true if either platform is ``None``, or the platforms are equal.\n\n    XXX Needs compatibility checks for Linux and other unixy OSes.", "id": "f21749:m14"}
{"signature": "def fixup_namespace_packages(path_item, parent=None):", "body": "imp.acquire_lock()<EOL>try:<EOL><INDENT>for package in _namespace_packages.get(parent,()):<EOL><INDENT>subpath = _handle_ns(package, path_item)<EOL>if subpath: fixup_namespace_packages(subpath,package)<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>imp.release_lock()<EOL><DEDENT>", "docstring": "Ensure that previously-declared namespace packages include path_item", "id": "f21749:m35"}
{"signature": "def requires(self,extras=()):", "body": "dm = self._dep_map<EOL>deps = []<EOL>deps.extend(dm.get(None,()))<EOL>for ext in extras:<EOL><INDENT>try:<EOL><INDENT>deps.extend(dm[safe_extra(ext)])<EOL><DEDENT>except KeyError:<EOL><INDENT>raise UnknownExtra(<EOL>\"<STR_LIT>\" % (self, ext)<EOL>)<EOL><DEDENT><DEDENT>return deps<EOL>", "docstring": "List of Requirements needed for this distro if `extras` are used", "id": "f21749:c21:m13"}
{"signature": "def StringIO(*args, **kw):", "body": "global StringIO<EOL>try:<EOL><INDENT>from io import StringIO<EOL><DEDENT>except ImportError:<EOL><INDENT>from io import StringIO<EOL><DEDENT>return StringIO(*args,**kw)<EOL>", "docstring": "Thunk to load the real StringIO on demand", "id": "f21749:m29"}
{"signature": "def __getattr__(self,attr):", "body": "if attr.startswith('<STR_LIT:_>'):<EOL><INDENT>raise AttributeError(attr)<EOL><DEDENT>return getattr(self._provider, attr)<EOL>", "docstring": "Delegate all unrecognized public attributes to .metadata provider", "id": "f21749:c21:m19"}
{"signature": "def declare_namespace(packageName):", "body": "imp.acquire_lock()<EOL>try:<EOL><INDENT>if packageName in _namespace_packages:<EOL><INDENT>return<EOL><DEDENT>path, parent = sys.path, None<EOL>if '<STR_LIT:.>' in packageName:<EOL><INDENT>parent = '<STR_LIT:.>'.join(packageName.split('<STR_LIT:.>')[:-<NUM_LIT:1>])<EOL>declare_namespace(parent)<EOL>if parent not in _namespace_packages:<EOL><INDENT>__import__(parent)<EOL><DEDENT>try:<EOL><INDENT>path = sys.modules[parent].__path__<EOL><DEDENT>except AttributeError:<EOL><INDENT>raise TypeError(\"<STR_LIT>\", parent)<EOL><DEDENT><DEDENT>_namespace_packages.setdefault(parent,[]).append(packageName)<EOL>_namespace_packages.setdefault(packageName,[])<EOL>for path_item in path:<EOL><INDENT>_handle_ns(packageName, path_item)<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>imp.release_lock()<EOL><DEDENT>", "docstring": "Declare that package 'packageName' is a namespace package", "id": "f21749:m34"}
{"signature": "def default_environment():", "body": "return dict(_VARS)<EOL>", "docstring": "Return copy of default PEP 385 globals dictionary.", "id": "f21750:m0"}
{"signature": "def visit_Attribute(self, node):", "body": "new_node = ast.Name(\"<STR_LIT>\" % (node.value.id, node.attr), node.ctx)<EOL>return ast.copy_location(new_node, node)<EOL>", "docstring": "Flatten one level of attribute access.", "id": "f21750:c0:m2"}
{"signature": "def configure(self, options, conf):", "body": "super(NoseExclude, self).configure(options, conf)<EOL>self.exclude_dirs = {}<EOL>if options.exclude_dir_file:<EOL><INDENT>if not options.exclude_dirs:<EOL><INDENT>options.exclude_dirs = []<EOL><DEDENT>new_dirs = self._load_from_file(options.exclude_dir_file)<EOL>options.exclude_dirs.extend(new_dirs)<EOL><DEDENT>if not options.exclude_dirs:<EOL><INDENT>self.enabled = False<EOL>return<EOL><DEDENT>self.enabled = True<EOL>root = os.getcwd()<EOL>log.debug('<STR_LIT>' % root)<EOL>for exclude_param in options.exclude_dirs:<EOL><INDENT>for d in exclude_param.split('<STR_LIT:\\n>'):<EOL><INDENT>d = d.strip()<EOL>abs_d = self._force_to_abspath(d)<EOL>if abs_d:<EOL><INDENT>self.exclude_dirs[abs_d] = True<EOL><DEDENT><DEDENT><DEDENT>exclude_str = \"<STR_LIT>\" % \"<STR_LIT:U+002C>\".join(self.exclude_dirs.keys())<EOL>log.debug(exclude_str)<EOL>", "docstring": "Configure plugin based on command line options", "id": "f21751:c0:m3"}
{"signature": "def help(self, doc=None):", "body": "return self.getParser(doc).format_help()<EOL>", "docstring": "Return the generated help message", "id": "f21752:c3:m10"}
{"signature": "def all_config_files():", "body": "user = user_config_files()<EOL>if os.path.exists('<STR_LIT>'):<EOL><INDENT>return user + ['<STR_LIT>']<EOL><DEDENT>return user<EOL>", "docstring": "Return path to any existing user config files, plus any setup.cfg\n    in the current working directory.", "id": "f21752:m1"}
{"signature": "def try_run(obj, names):", "body": "for name in names:<EOL><INDENT>func = getattr(obj, name, None)<EOL>if func is not None:<EOL><INDENT>if type(obj) == types.ModuleType:<EOL><INDENT>try:<EOL><INDENT>args, varargs, varkw, defaults = inspect.getargspec(func)<EOL><DEDENT>except TypeError:<EOL><INDENT>if hasattr(func, '<STR_LIT>'):<EOL><INDENT>func = func.__call__<EOL><DEDENT>try:<EOL><INDENT>args, varargs, varkw, defaults =inspect.getargspec(func)<EOL>args.pop(<NUM_LIT:0>) <EOL><DEDENT>except TypeError:<EOL><INDENT>raise TypeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\" %<EOL>(name, obj))<EOL><DEDENT><DEDENT>if len(args):<EOL><INDENT>log.debug(\"<STR_LIT>\", obj, name, obj)<EOL>return func(obj)<EOL><DEDENT><DEDENT>log.debug(\"<STR_LIT>\", obj, name)<EOL>return func()<EOL><DEDENT><DEDENT>", "docstring": "Given a list of possible method names, try to run them with the\n    provided object. Keep going until something works. Used to run\n    setup/teardown methods for module, package, and function tests.", "id": "f21753:m17"}
{"signature": "def transplant_func(func, module):", "body": "from nose.tools import make_decorator<EOL>def newfunc(*arg, **kw):<EOL><INDENT>return func(*arg, **kw)<EOL><DEDENT>newfunc = make_decorator(func)(newfunc)<EOL>newfunc.__module__ = module<EOL>return newfunc<EOL>", "docstring": "Make a function imported from module A appear as if it is located\nin module B.\n\n>>> from pprint import pprint\n>>> pprint.__module__\n'pprint'\n>>> pp = transplant_func(pprint, __name__)\n>>> pp.__module__\n'nose.util'\n\nThe original function is not modified.\n\n>>> pprint.__module__\n'pprint'\n\nCalling the transplanted function calls the original.\n\n>>> pp([1, 2])\n[1, 2]\n>>> pprint([1,2])\n[1, 2]", "id": "f21753:m21"}
{"signature": "def absdir(path):", "body": "if not os.path.isabs(path):<EOL><INDENT>path = os.path.normpath(os.path.abspath(os.path.join(os.getcwd(),<EOL>path)))<EOL><DEDENT>if path is None or not os.path.isdir(path):<EOL><INDENT>return None<EOL><DEDENT>return path<EOL>", "docstring": "Return absolute, normalized path to directory, if it exists; None\n    otherwise.", "id": "f21753:m2"}
{"signature": "def tolist(val):", "body": "if val is None:<EOL><INDENT>return None<EOL><DEDENT>try:<EOL><INDENT>val.extend([])<EOL>return val<EOL><DEDENT>except AttributeError:<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>return re.split(r'<STR_LIT>', val)<EOL><DEDENT>except TypeError:<EOL><INDENT>return list(val)<EOL><DEDENT>", "docstring": "Convert a value that may be a list or a (possibly comma-separated)\n    string into a list. The exception: None is returned as None, not [None].\n\n    >>> tolist([\"one\", \"two\"])\n    ['one', 'two']\n    >>> tolist(\"hello\")\n    ['hello']\n    >>> tolist(\"separate,values, with, commas,  spaces , are    ,ok\")\n    ['separate', 'values', 'with', 'commas', 'spaces', 'are', 'ok']", "id": "f21753:m20"}
{"signature": "def src(filename):", "body": "if filename is None:<EOL><INDENT>return filename<EOL><DEDENT>if sys.platform.startswith('<STR_LIT>') and filename.endswith('<STR_LIT>'):<EOL><INDENT>return '<STR_LIT:.>'.join((filename[:-<NUM_LIT:9>], '<STR_LIT>'))<EOL><DEDENT>base, ext = os.path.splitext(filename)<EOL>if ext in ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>'):<EOL><INDENT>return '<STR_LIT:.>'.join((base, '<STR_LIT>'))<EOL><DEDENT>return filename<EOL>", "docstring": "Find the python source file for a .pyc, .pyo or $py.class file on\n    jython. Returns the filename provided if it is not a python source\n    file.", "id": "f21753:m18"}
{"signature": "def func_lineno(func):", "body": "try:<EOL><INDENT>return func.compat_co_firstlineno<EOL><DEDENT>except AttributeError:<EOL><INDENT>try:<EOL><INDENT>return func.func_code.co_firstlineno<EOL><DEDENT>except AttributeError:<EOL><INDENT>return -<NUM_LIT:1><EOL><DEDENT><DEDENT>", "docstring": "Get the line number of a function. First looks for\n    compat_co_firstlineno, then func_code.co_first_lineno.", "id": "f21753:m6"}
{"signature": "def ln(label):", "body": "label_len = len(label) + <NUM_LIT:2><EOL>chunk = (<NUM_LIT> - label_len) // <NUM_LIT:2><EOL>out = '<STR_LIT>' % ('<STR_LIT:->' * chunk, label, '<STR_LIT:->' * chunk)<EOL>pad = <NUM_LIT> - len(out)<EOL>if pad > <NUM_LIT:0>:<EOL><INDENT>out = out + ('<STR_LIT:->' * pad)<EOL><DEDENT>return out<EOL>", "docstring": "Draw a 70-char-wide divider, with label in the middle.\n\n    >>> ln('hello there')\n    '---------------------------- hello there -----------------------------'", "id": "f21753:m13"}
{"signature": "def regex_last_key(regex):", "body": "def k(obj):<EOL><INDENT>if regex.search(obj):<EOL><INDENT>return (<NUM_LIT:1>, obj)<EOL><DEDENT>return (<NUM_LIT:0>, obj)<EOL><DEDENT>return k<EOL>", "docstring": "Sort key function factory that puts items that match a\n    regular expression last.\n\n    >>> from nose.config import Config\n    >>> from nose.pyversion import sort_list\n    >>> c = Config()\n    >>> regex = c.testMatch\n    >>> entries = ['.', '..', 'a_test', 'src', 'lib', 'test', 'foo.py']\n    >>> sort_list(entries, regex_last_key(regex))\n    >>> entries\n    ['.', '..', 'foo.py', 'lib', 'src', 'a_test', 'test']", "id": "f21753:m19"}
{"signature": "def proxied_attribute(local_attr, proxied_attr, doc):", "body": "def fget(self):<EOL><INDENT>return getattr(getattr(self, local_attr), proxied_attr)<EOL><DEDENT>def fset(self, value):<EOL><INDENT>setattr(getattr(self, local_attr), proxied_attr, value)<EOL><DEDENT>def fdel(self):<EOL><INDENT>delattr(getattr(self, local_attr), proxied_attr)<EOL><DEDENT>return property(fget, fset, fdel, doc)<EOL>", "docstring": "Create a property that proxies attribute ``proxied_attr`` through\n    the local attribute ``local_attr``.", "id": "f21754:m0"}
{"signature": "def matches(self, name):", "body": "return ((self.match.search(name)<EOL>or (self.include and<EOL>filter(None,<EOL>[inc.search(name) for inc in self.include])))<EOL>and ((not self.exclude)<EOL>or not filter(None,<EOL>[exc.search(name) for exc in self.exclude])<EOL>))<EOL>", "docstring": "Does the name match my requirements?\n\n        To match, a name must match config.testMatch OR config.include\n        and it must not match config.exclude", "id": "f21755:c0:m2"}
{"signature": "def wantDirectory(self, dirname):", "body": "tail = op_basename(dirname)<EOL>if ispackage(dirname):<EOL><INDENT>wanted = (not self.exclude<EOL>or not filter(None,<EOL>[exc.search(tail) for exc in self.exclude]<EOL>))<EOL><DEDENT>else:<EOL><INDENT>wanted = (self.matches(tail)<EOL>or (self.config.srcDirs<EOL>and tail in self.config.srcDirs))<EOL><DEDENT>plug_wants = self.plugins.wantDirectory(dirname)<EOL>if plug_wants is not None:<EOL><INDENT>log.debug(\"<STR_LIT>\",<EOL>dirname, plug_wants)<EOL>wanted = plug_wants<EOL><DEDENT>log.debug(\"<STR_LIT>\", dirname, wanted)<EOL>return wanted<EOL>", "docstring": "Is the directory a wanted test directory?\n\n        All package directories match, so long as they do not match exclude. \n        All other directories must match test requirements.", "id": "f21755:c0:m4"}
{"signature": "def wantClass(self, cls):", "body": "declared = getattr(cls, '<STR_LIT>', None)<EOL>if declared is not None:<EOL><INDENT>wanted = declared<EOL><DEDENT>else:<EOL><INDENT>wanted = (not cls.__name__.startswith('<STR_LIT:_>')<EOL>and (issubclass(cls, unittest.TestCase)<EOL>or self.matches(cls.__name__)))<EOL><DEDENT>plug_wants = self.plugins.wantClass(cls)        <EOL>if plug_wants is not None:<EOL><INDENT>log.debug(\"<STR_LIT>\", cls, plug_wants)<EOL>wanted = plug_wants<EOL><DEDENT>log.debug(\"<STR_LIT>\", cls, wanted)<EOL>return wanted<EOL>", "docstring": "Is the class a wanted test class?\n\n        A class must be a unittest.TestCase subclass, or match test name\n        requirements. Classes that start with _ are always excluded.", "id": "f21755:c0:m3"}
{"signature": "def wantMethod(self, method):", "body": "try:<EOL><INDENT>method_name = method.__name__<EOL><DEDENT>except AttributeError:<EOL><INDENT>return False<EOL><DEDENT>if method_name.startswith('<STR_LIT:_>'):<EOL><INDENT>return False<EOL><DEDENT>declared = getattr(method, '<STR_LIT>', None)<EOL>if declared is not None:<EOL><INDENT>wanted = declared<EOL><DEDENT>else:<EOL><INDENT>wanted = self.matches(method_name)<EOL><DEDENT>plug_wants = self.plugins.wantMethod(method)<EOL>if plug_wants is not None:<EOL><INDENT>wanted = plug_wants<EOL><DEDENT>log.debug(\"<STR_LIT>\", method, wanted)<EOL>return wanted<EOL>", "docstring": "Is the method a test method?", "id": "f21755:c0:m7"}
{"signature": "def importFromDir(self, dir, fqname):", "body": "dir = os.path.normpath(os.path.abspath(dir))<EOL>log.debug(\"<STR_LIT>\", fqname, dir)<EOL>if fqname == '<STR_LIT:__main__>':<EOL><INDENT>return sys.modules[fqname]<EOL><DEDENT>if self.config.addPaths:<EOL><INDENT>add_path(dir, self.config)<EOL><DEDENT>path = [dir]<EOL>parts = fqname.split('<STR_LIT:.>')<EOL>part_fqname = '<STR_LIT>'<EOL>mod = parent = fh = None<EOL>for part in parts:<EOL><INDENT>if part_fqname == '<STR_LIT>':<EOL><INDENT>part_fqname = part<EOL><DEDENT>else:<EOL><INDENT>part_fqname = \"<STR_LIT>\" % (part_fqname, part)<EOL><DEDENT>try:<EOL><INDENT>acquire_lock()<EOL>log.debug(\"<STR_LIT>\",<EOL>part, part_fqname, path)<EOL>fh, filename, desc = find_module(part, path)<EOL>old = sys.modules.get(part_fqname)<EOL>if old is not None:<EOL><INDENT>log.debug(\"<STR_LIT>\", part_fqname, old)<EOL>if (self.sameModule(old, filename)<EOL>or (self.config.firstPackageWins and<EOL>getattr(old, '<STR_LIT>', None))):<EOL><INDENT>mod = old<EOL><DEDENT>else:<EOL><INDENT>del sys.modules[part_fqname]<EOL>mod = load_module(part_fqname, fh, filename, desc)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>mod = load_module(part_fqname, fh, filename, desc)<EOL><DEDENT><DEDENT>finally:<EOL><INDENT>if fh:<EOL><INDENT>fh.close()<EOL><DEDENT>release_lock()<EOL><DEDENT>if parent:<EOL><INDENT>setattr(parent, part, mod)<EOL><DEDENT>if hasattr(mod, '<STR_LIT>'):<EOL><INDENT>path = mod.__path__<EOL><DEDENT>parent = mod<EOL><DEDENT>return mod<EOL>", "docstring": "Import a module *only* from path, ignoring sys.path and\n        reloading if the version in sys.modules is not the one we want.", "id": "f21756:c0:m2"}
{"signature": "def add_path(path, config=None):", "body": "<EOL>log.debug('<STR_LIT>' % path)    <EOL>if not path:<EOL><INDENT>return []<EOL><DEDENT>added = []<EOL>parent = os.path.dirname(path)<EOL>if (parent<EOL>and os.path.exists(os.path.join(path, '<STR_LIT>'))):<EOL><INDENT>added.extend(add_path(parent, config))<EOL><DEDENT>elif not path in sys.path:<EOL><INDENT>log.debug(\"<STR_LIT>\", path)<EOL>sys.path.insert(<NUM_LIT:0>, path)<EOL>added.append(path)<EOL><DEDENT>if config and config.srcDirs:<EOL><INDENT>for dirname in config.srcDirs:<EOL><INDENT>dirpath = os.path.join(path, dirname)<EOL>if os.path.isdir(dirpath):<EOL><INDENT>sys.path.insert(<NUM_LIT:0>, dirpath)<EOL>added.append(dirpath)<EOL><DEDENT><DEDENT><DEDENT>return added<EOL>", "docstring": "Ensure that the path, or the root of the current package (if\n    path is in a package), is in sys.path.", "id": "f21756:m0"}
{"signature": "def setUp(self):", "body": "if self.setUpFunc:<EOL><INDENT>self.setUpFunc()<EOL><DEDENT>else:<EOL><INDENT>names = ('<STR_LIT>', '<STR_LIT>', '<STR_LIT>')<EOL>try_run(self.test, names)<EOL><DEDENT>", "docstring": "Run any setup function attached to the test function", "id": "f21757:c2:m3"}
{"signature": "def timed(limit):", "body": "def decorate(func):<EOL><INDENT>def newfunc(*arg, **kw):<EOL><INDENT>start = time.time()<EOL>func(*arg, **kw)<EOL>end = time.time()<EOL>if end - start > limit:<EOL><INDENT>raise TimeExpired(\"<STR_LIT>\" % limit)<EOL><DEDENT><DEDENT>newfunc = make_decorator(func)(newfunc)<EOL>return newfunc<EOL><DEDENT>return decorate<EOL>", "docstring": "Test must finish within specified time limit to pass.\n\n    Example use::\n\n      @timed(.1)\n      def test_that_fails():\n          time.sleep(.2)", "id": "f21758:m3"}
{"signature": "def __init__(self, examples, globs, name, filename, lineno, docstring):", "body": "assert not isinstance(examples, str),\"<STR_LIT>\"<EOL>self.examples = examples<EOL>self.docstring = docstring<EOL>self.globs = globs.copy()<EOL>self.name = name<EOL>self.filename = filename<EOL>self.lineno = lineno<EOL>", "docstring": "Create a new DocTest containing the given examples.  The\nDocTest's globals are initialized with a copy of `globs`.", "id": "f21761:c3:m0"}
{"signature": "def _parse_example(self, m, name, lineno):", "body": "<EOL>indent = len(m.group('<STR_LIT>'))<EOL>source_lines = m.group('<STR_LIT:source>').split('<STR_LIT:\\n>')<EOL>self._check_prompt_blank(source_lines, indent, name, lineno)<EOL>self._check_prefix(source_lines[<NUM_LIT:1>:], '<STR_LIT:U+0020>'*indent + '<STR_LIT:.>', name, lineno)<EOL>source = '<STR_LIT:\\n>'.join([sl[indent+<NUM_LIT:4>:] for sl in source_lines])<EOL>want = m.group('<STR_LIT>')<EOL>want_lines = want.split('<STR_LIT:\\n>')<EOL>if len(want_lines) > <NUM_LIT:1> and re.match(r'<STR_LIT>', want_lines[-<NUM_LIT:1>]):<EOL><INDENT>del want_lines[-<NUM_LIT:1>]  <EOL><DEDENT>self._check_prefix(want_lines, '<STR_LIT:U+0020>'*indent, name,<EOL>lineno + len(source_lines))<EOL>want = '<STR_LIT:\\n>'.join([wl[indent:] for wl in want_lines])<EOL>m = self._EXCEPTION_RE.match(want)<EOL>if m:<EOL><INDENT>exc_msg = m.group('<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>exc_msg = None<EOL><DEDENT>options = self._find_options(source, name, lineno)<EOL>return source, options, want, exc_msg<EOL>", "docstring": "Given a regular expression match from `_EXAMPLE_RE` (`m`),\nreturn a pair `(source, want)`, where `source` is the matched\nexample's source code (with prompts and indentation stripped);\nand `want` is the example's expected output (with indentation\nstripped).\n\n`name` is the string's name, and `lineno` is the line number\nwhere the example starts; both are used for error messages.", "id": "f21761:c4:m3"}
{"signature": "def output_difference(self, example, got, optionflags):", "body": "want = example.want<EOL>if not (optionflags & DONT_ACCEPT_BLANKLINE):<EOL><INDENT>got = re.sub('<STR_LIT>', BLANKLINE_MARKER, got)<EOL><DEDENT>if self._do_a_fancy_diff(want, got, optionflags):<EOL><INDENT>want_lines = want.splitlines(True)  <EOL>got_lines = got.splitlines(True)<EOL>if optionflags & REPORT_UDIFF:<EOL><INDENT>diff = difflib.unified_diff(want_lines, got_lines, n=<NUM_LIT:2>)<EOL>diff = list(diff)[<NUM_LIT:2>:] <EOL>kind = '<STR_LIT>'<EOL><DEDENT>elif optionflags & REPORT_CDIFF:<EOL><INDENT>diff = difflib.context_diff(want_lines, got_lines, n=<NUM_LIT:2>)<EOL>diff = list(diff)[<NUM_LIT:2>:] <EOL>kind = '<STR_LIT>'<EOL><DEDENT>elif optionflags & REPORT_NDIFF:<EOL><INDENT>engine = difflib.Differ(charjunk=difflib.IS_CHARACTER_JUNK)<EOL>diff = list(engine.compare(want_lines, got_lines))<EOL>kind = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>assert <NUM_LIT:0>, '<STR_LIT>'<EOL><DEDENT>diff = [line.rstrip() + '<STR_LIT:\\n>' for line in diff]<EOL>return '<STR_LIT>' % kind + _indent('<STR_LIT>'.join(diff))<EOL><DEDENT>if want and got:<EOL><INDENT>return '<STR_LIT>' % (_indent(want), _indent(got))<EOL><DEDENT>elif want:<EOL><INDENT>return '<STR_LIT>' % _indent(want)<EOL><DEDENT>elif got:<EOL><INDENT>return '<STR_LIT>' % _indent(got)<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT>'<EOL><DEDENT>", "docstring": "Return a string describing the differences between the\nexpected output for a given example (`example`) and the actual\noutput (`got`).  `optionflags` is the set of option flags used\nto compare `want` and `got`.", "id": "f21761:c7:m2"}
{"signature": "def _filter(self, obj, prefix, base):", "body": "return (self._namefilter is not None and<EOL>self._namefilter(prefix, base))<EOL>", "docstring": "Return true if the given object should not be examined.", "id": "f21761:c5:m2"}
{"signature": "def debug_src(src, pm=False, globs=None):", "body": "testsrc = script_from_examples(src)<EOL>debug_script(testsrc, pm, globs)<EOL>", "docstring": "Debug a single doctest docstring, in argument `src`", "id": "f21761:m18"}
{"signature": "def check_output(self, want, got, optionflags):", "body": "<EOL>if got == want:<EOL><INDENT>return True<EOL><DEDENT>if not (optionflags & DONT_ACCEPT_TRUE_FOR_1):<EOL><INDENT>if (got,want) == (\"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>return True<EOL><DEDENT>if (got,want) == (\"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>if not (optionflags & DONT_ACCEPT_BLANKLINE):<EOL><INDENT>want = re.sub('<STR_LIT>' % re.escape(BLANKLINE_MARKER),<EOL>'<STR_LIT>', want)<EOL>got = re.sub('<STR_LIT>', '<STR_LIT>', got)<EOL>if got == want:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>if optionflags & NORMALIZE_WHITESPACE:<EOL><INDENT>got = '<STR_LIT:U+0020>'.join(got.split())<EOL>want = '<STR_LIT:U+0020>'.join(want.split())<EOL>if got == want:<EOL><INDENT>return True<EOL><DEDENT><DEDENT>if optionflags & ELLIPSIS:<EOL><INDENT>if _ellipsis_match(want, got):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>", "docstring": "Return True iff the actual output from an example (`got`)\nmatches the expected output (`want`).  These strings are\nalways considered to match if they are identical; but\ndepending on what option flags the test runner is using,\nseveral non-exact match types are also possible.  See the\ndocumentation for `TestRunner` for more information about\noption flags.", "id": "f21761:c7:m0"}
{"signature": "def _normalize_module(module, depth=<NUM_LIT:2>):", "body": "if inspect.ismodule(module):<EOL><INDENT>return module<EOL><DEDENT>elif isinstance(module, str):<EOL><INDENT>return __import__(module, globals(), locals(), [\"<STR_LIT:*>\"])<EOL><DEDENT>elif module is None:<EOL><INDENT>return sys.modules[sys._getframe(depth).f_globals['<STR_LIT>']]<EOL><DEDENT>else:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>", "docstring": "Return the module specified by `module`.  In particular:\n  - If `module` is a module, then return module.\n  - If `module` is a string, then import and return the\n    module with that name.\n  - If `module` is None, then return the calling module.\n    The calling module is assumed to be the module of\n    the stack frame at the given depth in the call stack.", "id": "f21761:m3"}
{"signature": "def _check_prefix(self, lines, prefix, name, lineno):", "body": "for i, line in enumerate(lines):<EOL><INDENT>if line and not line.startswith(prefix):<EOL><INDENT>raise ValueError('<STR_LIT>'<EOL>'<STR_LIT>' %<EOL>(lineno+i+<NUM_LIT:1>, name, line))<EOL><DEDENT><DEDENT>", "docstring": "Check that every line in the given list starts with the given\nprefix; if any line does not, then raise a ValueError.", "id": "f21761:c4:m7"}
{"signature": "def find(self, obj, name=None, module=None, globs=None,<EOL>extraglobs=None):", "body": "<EOL>if name is None:<EOL><INDENT>name = getattr(obj, '<STR_LIT>', None)<EOL>if name is None:<EOL><INDENT>raise ValueError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" %<EOL>(type(obj),))<EOL><DEDENT><DEDENT>if module is False:<EOL><INDENT>module = None<EOL><DEDENT>elif module is None:<EOL><INDENT>module = inspect.getmodule(obj)<EOL><DEDENT>try:<EOL><INDENT>file = inspect.getsourcefile(obj) or inspect.getfile(obj)<EOL>source_lines = linecache.getlines(file)<EOL>if not source_lines:<EOL><INDENT>source_lines = None<EOL><DEDENT><DEDENT>except TypeError:<EOL><INDENT>source_lines = None<EOL><DEDENT>if globs is None:<EOL><INDENT>if module is None:<EOL><INDENT>globs = {}<EOL><DEDENT>else:<EOL><INDENT>globs = module.__dict__.copy()<EOL><DEDENT><DEDENT>else:<EOL><INDENT>globs = globs.copy()<EOL><DEDENT>if extraglobs is not None:<EOL><INDENT>globs.update(extraglobs)<EOL><DEDENT>tests = []<EOL>self._find(tests, obj, name, module, source_lines, globs, {})<EOL>tests.sort()<EOL>return tests<EOL>", "docstring": "Return a list of the DocTests that are defined by the given\nobject's docstring, or by any of its contained objects'\ndocstrings.\n\nThe optional parameter `module` is the module that contains\nthe given object.  If the module is not specified or is None, then\nthe test finder will attempt to automatically determine the\ncorrect module.  The object's module is used:\n\n    - As a default namespace, if `globs` is not specified.\n    - To prevent the DocTestFinder from extracting DocTests\n      from objects that are imported from other modules.\n    - To find the name of the file containing the object.\n    - To help find the line number of the object within its\n      file.\n\nContained objects whose module does not match `module` are ignored.\n\nIf `module` is False, no attempt to find the module will be made.\nThis is obscure, of use mostly in tests:  if `module` is False, or\nis None but cannot be found automatically, then all objects are\nconsidered to belong to the (non-existent) module, so all contained\nobjects will (recursively) be searched for doctests.\n\nThe globals for each DocTest is formed by combining `globs`\nand `extraglobs` (bindings in `extraglobs` override bindings\nin `globs`).  A new copy of the globals dictionary is created\nfor each DocTest.  If `globs` is not specified, then it\ndefaults to the module's `__dict__`, if specified, or {}\notherwise.  If `extraglobs` is not specified, then it defaults\nto {}.", "id": "f21761:c5:m1"}
{"signature": "def autohelp_directive(dirname, arguments, options, content, lineno,<EOL>content_offset, block_text, state, state_machine):", "body": "config = Config(parserClass=OptBucket,<EOL>plugins=BuiltinPluginManager())<EOL>parser = config.getParser(TestProgram.usage())<EOL>rst = ViewList()<EOL>for line in parser.format_help().split('<STR_LIT:\\n>'):<EOL><INDENT>rst.append(line, '<STR_LIT>')<EOL><DEDENT>rst.append('<STR_LIT>', '<STR_LIT>')<EOL>rst.append('<STR_LIT>', '<STR_LIT>')<EOL>rst.append('<STR_LIT>', '<STR_LIT>')<EOL>for opt in parser:<EOL><INDENT>rst.append(opt.options(), '<STR_LIT>')<EOL>rst.append('<STR_LIT>', '<STR_LIT>')<EOL>rst.append('<STR_LIT:U+0020>' + opt.help + '<STR_LIT:\\n>', '<STR_LIT>')<EOL>rst.append('<STR_LIT:\\n>', '<STR_LIT>')    <EOL><DEDENT>node = nodes.section()<EOL>node.document = state.document<EOL>surrounding_title_styles = state.memo.title_styles<EOL>surrounding_section_level = state.memo.section_level<EOL>state.memo.title_styles = []<EOL>state.memo.section_level = <NUM_LIT:0><EOL>state.nested_parse(rst, <NUM_LIT:0>, node, match_titles=<NUM_LIT:1>)<EOL>state.memo.title_styles = surrounding_title_styles<EOL>state.memo.section_level = surrounding_section_level<EOL>return node.children<EOL>", "docstring": "produces rst from nose help", "id": "f21765:m1"}
{"signature": "def run(self, result):", "body": "<EOL>log.debug(\"<STR_LIT>\",<EOL>id(self), self, self._tests)<EOL>if self.resultProxy:<EOL><INDENT>result, orig = self.resultProxy(result, self), result<EOL><DEDENT>else:<EOL><INDENT>result, orig = result, result<EOL><DEDENT>try:<EOL><INDENT>self.setUp()<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>raise<EOL><DEDENT>except:<EOL><INDENT>self.error_context = '<STR_LIT>'<EOL>result.addError(self, self._exc_info())<EOL>return<EOL><DEDENT>try:<EOL><INDENT>for test in self._tests:<EOL><INDENT>if (isinstance(test,nose.case.Test)<EOL>and self.arg is not None):<EOL><INDENT>test.test.arg = self.arg<EOL><DEDENT>else:<EOL><INDENT>test.arg = self.arg<EOL><DEDENT>test.testQueue = self.testQueue<EOL>test.tasks = self.tasks<EOL>if result.shouldStop:<EOL><INDENT>log.debug(\"<STR_LIT>\")<EOL>break<EOL><DEDENT>try:<EOL><INDENT>test(orig)<EOL><DEDENT>except KeyboardInterrupt as e:<EOL><INDENT>timeout = isinstance(e, TimedOutException)<EOL>if timeout:<EOL><INDENT>msg = '<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>msg = '<STR_LIT>'<EOL><DEDENT>log.debug(msg, test, self)<EOL>err = (TimedOutException,TimedOutException(str(test)),<EOL>sys.exc_info()[<NUM_LIT:2>])<EOL>test.config.plugins.addError(test,err)<EOL>orig.addError(test,err)<EOL>if not timeout:<EOL><INDENT>raise<EOL><DEDENT><DEDENT><DEDENT><DEDENT>finally:<EOL><INDENT>self.has_run = True<EOL>try:<EOL><INDENT>self.tearDown()<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>raise<EOL><DEDENT>except:<EOL><INDENT>self.error_context = '<STR_LIT>'<EOL>result.addError(self, self._exc_info())<EOL><DEDENT><DEDENT>", "docstring": "Run tests in suite inside of suite fixtures.", "id": "f21767:c4:m2"}
{"signature": "def prepareTestLoader(self, loader):", "body": "self.loaderClass = loader.__class__<EOL>", "docstring": "Remember loader class so MultiProcessTestRunner can instantiate\n        the right loader.", "id": "f21767:c2:m2"}
{"signature": "def configure(self, options, config):", "body": "try:<EOL><INDENT>self.status.pop('<STR_LIT>')<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>if not hasattr(options, '<STR_LIT>'):<EOL><INDENT>self.enabled = False<EOL>return<EOL><DEDENT>if config.worker:<EOL><INDENT>return<EOL><DEDENT>self.config = config<EOL>try:<EOL><INDENT>workers = int(options.multiprocess_workers)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>workers = <NUM_LIT:0><EOL><DEDENT>if workers:<EOL><INDENT>_import_mp()<EOL>if Process is None:<EOL><INDENT>self.enabled = False<EOL>return<EOL><DEDENT>self.enabled = True<EOL>self.config.multiprocess_workers = workers<EOL>t = float(options.multiprocess_timeout)<EOL>self.config.multiprocess_timeout = t<EOL>r = int(options.multiprocess_restartworker)<EOL>self.config.multiprocess_restartworker = r<EOL>self.status['<STR_LIT>'] = True<EOL><DEDENT>", "docstring": "Configure plugin.", "id": "f21767:c2:m1"}
{"signature": "def options(self, parser, env):", "body": "if not self.available():<EOL><INDENT>return<EOL><DEDENT>Plugin.options(self, parser, env)<EOL>parser.add_option('<STR_LIT>', action='<STR_LIT:store>', dest='<STR_LIT>',<EOL>default=env.get('<STR_LIT>', '<STR_LIT>'),<EOL>metavar=\"<STR_LIT>\",<EOL>help=\"<STR_LIT>\")<EOL>parser.add_option('<STR_LIT>', action='<STR_LIT:store>',<EOL>dest='<STR_LIT>',<EOL>metavar=\"<STR_LIT>\",<EOL>default=env.get('<STR_LIT>'),<EOL>help='<STR_LIT>'<EOL>'<STR_LIT>')<EOL>parser.add_option('<STR_LIT>', action='<STR_LIT>',<EOL>dest='<STR_LIT>',<EOL>metavar=\"<STR_LIT>\",<EOL>default=env.get('<STR_LIT>'),<EOL>help=\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>", "docstring": "Register commandline options.", "id": "f21768:c0:m0"}
{"signature": "def _loadTestsFromNames(self, names, module=None):", "body": "suite = []<EOL>for p, meth in self.plugins:<EOL><INDENT>result = meth(names, module=module)<EOL>if result is not None:<EOL><INDENT>suite_part, names = result<EOL>if suite_part:<EOL><INDENT>suite.extend(suite_part)<EOL><DEDENT><DEDENT><DEDENT>return suite, names<EOL>", "docstring": "Chainable but not quite normal. Plugins return a tuple of\n        (tests, names) after processing the names. The tests are added\n        to a suite that is accumulated throughout the full call, while\n        names are input for the next plugin in the chain.", "id": "f21769:c0:m7"}
{"signature": "def loadPlugins(self):", "body": "from pkg_resources import iter_entry_points<EOL>loaded = {}<EOL>for entry_point, adapt in self.entry_points:<EOL><INDENT>for ep in iter_entry_points(entry_point):<EOL><INDENT>if ep.name in loaded:<EOL><INDENT>continue<EOL><DEDENT>loaded[ep.name] = True<EOL>log.debug('<STR_LIT>', self.__class__.__name__, ep)<EOL>try:<EOL><INDENT>plugcls = ep.load()<EOL><DEDENT>except KeyboardInterrupt:<EOL><INDENT>raise<EOL><DEDENT>except Exception as e:<EOL><INDENT>warn(\"<STR_LIT>\" % (ep, e),<EOL>RuntimeWarning)<EOL>continue<EOL><DEDENT>if adapt:<EOL><INDENT>plug = adapt(plugcls())<EOL><DEDENT>else:<EOL><INDENT>plug = plugcls()<EOL><DEDENT>self.addPlugin(plug)<EOL><DEDENT><DEDENT>super(EntryPointPluginManager, self).loadPlugins()<EOL>", "docstring": "Load plugins by iterating the `nose.plugins` entry point.", "id": "f21769:c4:m0"}
{"signature": "def generate(self, *arg, **kw):", "body": "for p, meth in self.plugins:<EOL><INDENT>result = None<EOL>try:<EOL><INDENT>result = meth(*arg, **kw)<EOL>if result is not None:<EOL><INDENT>for r in result:<EOL><INDENT>yield r<EOL><DEDENT><DEDENT><DEDENT>except (KeyboardInterrupt, SystemExit):<EOL><INDENT>raise<EOL><DEDENT>except:<EOL><INDENT>exc = sys.exc_info()<EOL>yield Failure(*exc)<EOL>continue<EOL><DEDENT><DEDENT>", "docstring": "Call all plugins, yielding each item in each non-None result.", "id": "f21769:c0:m5"}
{"signature": "def chain(self, *arg, **kw):", "body": "result = None<EOL>static = [a for (static, a)<EOL>in zip(getattr(self.method, '<STR_LIT>', []), arg)<EOL>if static]<EOL>for p, meth in self.plugins:<EOL><INDENT>result = meth(*arg, **kw)<EOL>arg = static[:]<EOL>arg.append(result)<EOL><DEDENT>return result<EOL>", "docstring": "Call plugins in a chain, where the result of each plugin call is\n        sent to the next plugin as input. The final output result is returned.", "id": "f21769:c0:m4"}
{"signature": "def configure(self, options, config):", "body": "Plugin.configure(self, options, config)<EOL>self.doctest_result_var = options.doctest_result_var<EOL>self.doctest_tests = options.doctest_tests<EOL>self.extension = tolist(options.doctestExtension)<EOL>self.fixtures = options.doctestFixtures<EOL>self.finder = doctest.DocTestFinder()<EOL>self.optionflags = <NUM_LIT:0><EOL>if options.doctestOptions:<EOL><INDENT>flags = \"<STR_LIT:U+002C>\".join(options.doctestOptions).split('<STR_LIT:U+002C>')<EOL>for flag in flags:<EOL><INDENT>try:<EOL><INDENT>if flag.startswith('<STR_LIT:+>'):<EOL><INDENT>self.optionflags |= getattr(doctest, flag[<NUM_LIT:1>:])<EOL><DEDENT>elif flag.startswith('<STR_LIT:->'):<EOL><INDENT>self.optionflags &= ~getattr(doctest, flag[<NUM_LIT:1>:])<EOL><DEDENT>else:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\" +<EOL>\"<STR_LIT>\" % (flag,))<EOL><DEDENT><DEDENT>except AttributeError:<EOL><INDENT>raise ValueError(\"<STR_LIT>\" %<EOL>(flag[<NUM_LIT:1>:],))<EOL><DEDENT><DEDENT><DEDENT>", "docstring": "Configure plugin.", "id": "f21771:c2:m1"}
{"signature": "def configure(self, options, conf):", "body": "self.conf = conf<EOL>if not options.logcapture or conf.loggingConfig:<EOL><INDENT>self.enabled = False<EOL><DEDENT>self.logformat = options.logcapture_format<EOL>self.logdatefmt = options.logcapture_datefmt<EOL>self.clear = options.logcapture_clear<EOL>self.loglevel = options.logcapture_level<EOL>if options.logcapture_filters:<EOL><INDENT>self.filters = options.logcapture_filters.split('<STR_LIT:U+002C>')<EOL><DEDENT>", "docstring": "Configure plugin.", "id": "f21772:c2:m1"}
{"signature": "def allow(self, record):", "body": "if not self:<EOL><INDENT>return True<EOL><DEDENT>return self._allow(record) and not self._deny(record)<EOL>", "docstring": "returns whether this record should be printed", "id": "f21772:c0:m2"}
{"signature": "def options(self, parser, env):", "body": "env_opt = '<STR_LIT>'<EOL>parser.add_option('<STR_LIT>', action='<STR_LIT:store_true>',<EOL>dest='<STR_LIT>', default=env.get(env_opt, False),<EOL>help=\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>", "docstring": "Add my options to command line.", "id": "f21774:c0:m0"}
{"signature": "def wantFunction(self, function):", "body": "pass<EOL>", "docstring": "Return true to collect this function as a test, false to\n        prevent it from being collected, and None if you don't care.\n\n        :param function: The function object being examined by the selector", "id": "f21776:c1:m48"}
{"signature": "def prepareTestLoader(self, loader):", "body": "pass<EOL>", "docstring": "Called before tests are loaded. To replace the test loader,\n        return a test loader. To allow other plugins to process the\n        test loader, return None. Only one plugin may replace the test\n        loader. Only valid when using nose.TestProgram.\n\n        :param loader: :class:`nose.loader.TestLoader` \n             (or other loader) instance", "id": "f21776:c1:m35"}
{"signature": "def report(self, stream):", "body": "pass<EOL>", "docstring": "Called after all error output has been printed. Print your\n        plugin's report to the provided stream. Return None to allow\n        other plugins to print reports, any other value to stop them.\n\n        :param stream: stream object; send your output here\n        :type stream: file-like object", "id": "f21776:c1:m38"}
{"signature": "def prepareTestRunner(self, runner):", "body": "pass<EOL>", "docstring": "Called before tests are run. To replace the test runner,\n        return a test runner. To allow other plugins to process the\n        test runner, return None. Only valid when using nose.TestProgram.\n\n        :param runner: :class:`nose.core.TextTestRunner` \n             (or other runner) instance", "id": "f21776:c1:m37"}
{"signature": "def beforeContext(self):", "body": "pass<EOL>", "docstring": "Called before a context (generally a module) is\n        examined. Because the context is not yet loaded, plugins don't\n        get to know what the context is; so any context operations\n        should use a stack that is pushed in `beforeContext` and popped\n        in `afterContext` to ensure they operate symmetrically.\n\n        `beforeContext` and `afterContext` are mainly useful for tracking\n        and restoring global state around possible changes from within a\n        context, whatever the context may be. If you need to operate on\n        contexts themselves, see `startContext` and `stopContext`, which\n        are passed the context in question, but are called after\n        it has been loaded (imported in the module case).", "id": "f21776:c1:m11"}
{"signature": "def loadTestsFromNames(self, names, module=None):", "body": "pass<EOL>", "docstring": "Return a tuple of (tests loaded, remaining names). Return\n        None if you are not able to load any tests. Multiple plugins\n        may implement loadTestsFromNames; the remaining name list from\n        each will be passed to the next as input.\n\n        :param names: List of test names.\n        :type names: iterable\n        :param module: Module from which the names are to be loaded", "id": "f21776:c1:m26"}
{"signature": "def add_options(self, parser, env=None):", "body": "<EOL>if env is None:<EOL><INDENT>env = os.environ<EOL><DEDENT>try:<EOL><INDENT>self.options(parser, env)<EOL>self.can_configure = True<EOL><DEDENT>except OptionConflictError as e:<EOL><INDENT>warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\" % (self, e), RuntimeWarning)<EOL>self.enabled = False<EOL>self.can_configure = False<EOL><DEDENT>", "docstring": "Non-camel-case version of func name for backwards compatibility.\n\n        .. warning ::\n\n           DEPRECATED: Do not use this method,\n           use :meth:`options <nose.plugins.base.IPluginInterface.options>`\n           instead.", "id": "f21776:c0:m2"}
{"signature": "def wantDirectory(self, dirname):", "body": "pass<EOL>", "docstring": "Return true if you want test collection to descend into this\n        directory, false if you do not, and None if you don't care.\n\n        :param dirname: Full path to directory being examined by the selector", "id": "f21776:c1:m46"}
{"signature": "def afterContext(self):", "body": "pass<EOL>", "docstring": "Called after a context (generally a module) has been\n        lazy-loaded, imported, setup, had its tests loaded and\n        executed, and torn down.", "id": "f21776:c1:m7"}
{"signature": "def afterImport(self, filename, module):", "body": "pass<EOL>", "docstring": "Called after module is imported from filename. afterImport\n        is called even if the import failed.\n\n        :param filename: The file that was loaded\n        :type filename: string\n        :param filename: The name of the module\n        :type module: string", "id": "f21776:c1:m9"}
{"signature": "def loadTestsFromTestClass(self, cls):", "body": "pass<EOL>", "docstring": "Return tests in this test class. Class will *not* be a\n        unittest.TestCase subclass. Return None if you are not able to\n        load any tests, an iterable if you are. May be a generator.\n\n        :param cls: The test case class. Must be **not** be subclass of\n           :class:`unittest.TestCase`.", "id": "f21776:c1:m30"}
{"signature": "def begin(self):", "body": "pass<EOL>", "docstring": "Called before any tests are collected or run. Use this to\n        perform any setup needed before testing begins.", "id": "f21776:c1:m15"}
{"signature": "def run(*arg, **kw):", "body": "from nose import run<EOL>from nose.config import Config<EOL>from nose.plugins.manager import PluginManager<EOL>buffer = Buffer()<EOL>if '<STR_LIT>' not in kw:<EOL><INDENT>plugins = kw.pop('<STR_LIT>', [])<EOL>if isinstance(plugins, list):<EOL><INDENT>plugins = PluginManager(plugins=plugins)<EOL><DEDENT>env = kw.pop('<STR_LIT>', {})<EOL>kw['<STR_LIT>'] = Config(env=env, plugins=plugins)<EOL><DEDENT>if '<STR_LIT>' not in kw:<EOL><INDENT>kw['<STR_LIT>'] = ['<STR_LIT>', '<STR_LIT>']<EOL><DEDENT>kw['<STR_LIT>'].stream = buffer<EOL>stderr = sys.stderr<EOL>stdout = sys.stdout<EOL>if kw.pop('<STR_LIT>', False):<EOL><INDENT>sys.stdout = sys.stderr = buffer<EOL>restore = True<EOL><DEDENT>else:<EOL><INDENT>restore = False<EOL>warn(\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\",<EOL>DeprecationWarning, stacklevel=<NUM_LIT:2>)<EOL><DEDENT>try:<EOL><INDENT>run(*arg, **kw)<EOL><DEDENT>finally:<EOL><INDENT>if restore:<EOL><INDENT>sys.stderr = stderr<EOL>sys.stdout = stdout<EOL><DEDENT><DEDENT>out = buffer.getvalue()<EOL>print(munge_nose_output_for_doctest(out))<EOL>", "docstring": "Specialized version of nose.run for use inside of doctests that\ntest test runs.\n\nThis version of run() prints the result output to stdout.  Before\nprinting, the output is processed by replacing the timing\ninformation with an ellipsis (...), removing traceback stacks, and\nremoving trailing whitespace.\n\nUse this version of run wherever you are writing a doctest that\ntests nose (or unittest) test result output.\n\nNote: do not use doctest: +ELLIPSIS when testing nose output,\nsince ellipses (\"test_foo ... ok\") in your expected test runner\noutput may match multiple lines of output, causing spurious test\npasses!", "id": "f21778:m5"}
{"signature": "def configure(self, options, conf):", "body": "try:<EOL><INDENT>self.status.pop('<STR_LIT>')<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT>super(Coverage, self).configure(options, conf)<EOL>if conf.worker:<EOL><INDENT>return<EOL><DEDENT>if self.enabled:<EOL><INDENT>try:<EOL><INDENT>import coverage<EOL><DEDENT>except ImportError:<EOL><INDENT>log.error(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>self.enabled = False<EOL>return<EOL><DEDENT><DEDENT>self.conf = conf<EOL>self.coverErase = options.cover_erase<EOL>self.coverTests = options.cover_tests<EOL>self.coverPackages = []<EOL>if options.cover_packages:<EOL><INDENT>for pkgs in [tolist(x) for x in options.cover_packages]:<EOL><INDENT>self.coverPackages.extend(pkgs)<EOL><DEDENT><DEDENT>self.coverInclusive = options.cover_inclusive<EOL>if self.coverPackages:<EOL><INDENT>log.info(\"<STR_LIT>\",<EOL>self.coverPackages)<EOL><DEDENT>self.coverHtmlDir = None<EOL>if options.cover_html:<EOL><INDENT>self.coverHtmlDir = options.cover_html_dir<EOL>log.debug('<STR_LIT>', self.coverHtmlDir)<EOL><DEDENT>self.coverBranches = options.cover_branches<EOL>self.coverXmlFile = None<EOL>if options.cover_min_percentage:<EOL><INDENT>self.coverMinPercentage = int(options.cover_min_percentage.rstrip('<STR_LIT:%>'))<EOL><DEDENT>if options.cover_xml:<EOL><INDENT>self.coverXmlFile = options.cover_xml_file<EOL>log.debug('<STR_LIT>', self.coverXmlFile)<EOL><DEDENT>if self.enabled:<EOL><INDENT>self.status['<STR_LIT>'] = True<EOL>self.coverInstance = coverage.coverage(auto_data=False,<EOL>branch=self.coverBranches, data_suffix=None)<EOL><DEDENT>", "docstring": "Configure plugin.", "id": "f21780:c0:m1"}
{"signature": "def options(self, parser, env):", "body": "Plugin.options(self, parser, env)<EOL>parser.add_option('<STR_LIT>', action='<STR_LIT:store>', dest='<STR_LIT>',<EOL>default='<STR_LIT>', metavar=\"<STR_LIT>\",<EOL>help=\"<STR_LIT>\"<EOL>\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>parser.add_option('<STR_LIT>', action='<STR_LIT:store_true>',<EOL>dest='<STR_LIT>', default=False,<EOL>help=\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL>", "docstring": "Register commandline options.", "id": "f21782:c0:m0"}
{"signature": "def options(self, parser, env):", "body": "parser.add_option(<EOL>\"<STR_LIT>\", action=\"<STR_LIT:store_true>\", dest=\"<STR_LIT>\",<EOL>default=env.get('<STR_LIT>', False),<EOL>help=\"<STR_LIT>\")<EOL>parser.add_option(<EOL>\"<STR_LIT>\", action=\"<STR_LIT:store_true>\",<EOL>dest=\"<STR_LIT>\",<EOL>default=env.get('<STR_LIT>', False),<EOL>help=\"<STR_LIT>\")<EOL>", "docstring": "Register commandline options.", "id": "f21783:c0:m0"}
{"signature": "def nice_classname(obj):", "body": "if inspect.isclass(obj):<EOL><INDENT>cls_name = obj.__name__<EOL><DEDENT>else:<EOL><INDENT>cls_name = obj.__class__.__name__<EOL><DEDENT>mod = inspect.getmodule(obj)<EOL>if mod:<EOL><INDENT>name = mod.__name__<EOL>if name.startswith('<STR_LIT>'):<EOL><INDENT>name = name[len('<STR_LIT>'):]<EOL><DEDENT>return \"<STR_LIT>\" % (name, cls_name)<EOL><DEDENT>else:<EOL><INDENT>return cls_name<EOL><DEDENT>", "docstring": "Returns a nice name for class object or class instance.\n\n        >>> nice_classname(Exception()) # doctest: +ELLIPSIS\n        '...Exception'\n        >>> nice_classname(Exception) # doctest: +ELLIPSIS\n        '...Exception'", "id": "f21785:m3"}
{"signature": "def configure(self, options, conf):", "body": "if not self.can_configure:<EOL><INDENT>return<EOL><DEDENT>self.enabled = options.detailedErrors<EOL>self.conf = conf<EOL>", "docstring": "Configure plugin.", "id": "f21786:c0:m1"}
{"signature": "def options(self, parser, env):", "body": "parser.add_option('<STR_LIT>',<EOL>action='<STR_LIT:store_true>',<EOL>dest=self.enableOpt,<EOL>default=env.get('<STR_LIT>'),<EOL>help=\"<STR_LIT>\" %<EOL>(self.help()))<EOL>", "docstring": "Register commandline options.", "id": "f21787:c0:m0"}
{"signature": "def print_errors_patch(result):", "body": "return make_instancemethod(TextTestResult.printErrors, result)<EOL>", "docstring": "Create a new printErrors method that prints errorClasses items\n    as well.", "id": "f21788:m1"}
{"signature": "def print_label_patch(result):", "body": "return make_instancemethod(TextTestResult.printLabel, result)<EOL>", "docstring": "Create a new printLabel method that prints errorClasses items\n    as well.", "id": "f21788:m2"}
{"signature": "def loadTestsFromTestClass(self, cls):", "body": "def wanted(attr, cls=cls, sel=self.selector):<EOL><INDENT>item = getattr(cls, attr, None)<EOL>if isfunction(item):<EOL><INDENT>item = unbound_method(cls, item)<EOL><DEDENT>elif not ismethod(item):<EOL><INDENT>return False<EOL><DEDENT>return sel.wantMethod(item)<EOL><DEDENT>cases = [self.makeTest(getattr(cls, case), cls)<EOL>for case in filter(wanted, dir(cls))]<EOL>for test in self.config.plugins.loadTestsFromTestClass(cls):<EOL><INDENT>cases.append(test)<EOL><DEDENT>return self.suiteClass(ContextList(cases, context=cls))<EOL>", "docstring": "Load tests from a test class that is *not* a unittest.TestCase\n        subclass.\n\n        In this case, we can't depend on the class's `__init__` taking method\n        name arguments, so we have to compose a MethodTestCase for each\n        method in the class that looks testlike.", "id": "f21790:c0:m10"}
{"signature": "def _exc_info(self):", "body": "e = self.exc_info()<EOL>if sys.platform == '<STR_LIT>':<EOL><INDENT>if isinstance(e[<NUM_LIT:0>], StringException):<EOL><INDENT>e = (str(e[<NUM_LIT:0>]), e[<NUM_LIT:1>], e[<NUM_LIT:2>])<EOL><DEDENT><DEDENT>return e<EOL>", "docstring": "Bottleneck to fix up IronPython string exceptions", "id": "f21792:c2:m6"}
{"signature": "def exc_info(self):", "body": "return sys.exc_info()<EOL>", "docstring": "Hook for replacing error tuple output", "id": "f21792:c2:m5"}
{"signature": "def showPlugins(self):", "body": "import textwrap<EOL>class DummyParser:<EOL><INDENT>def __init__(self):<EOL><INDENT>self.options = []<EOL><DEDENT>def add_option(self, *arg, **kw):<EOL><INDENT>self.options.append((arg, kw.pop('<STR_LIT>', '<STR_LIT>')))<EOL><DEDENT><DEDENT>v = self.config.verbosity<EOL>self.config.plugins.sort()<EOL>for p in self.config.plugins:<EOL><INDENT>print(\"<STR_LIT>\" % p.name)<EOL>if v >= <NUM_LIT:2>:<EOL><INDENT>print(\"<STR_LIT>\" % p.score)<EOL>print('<STR_LIT:\\n>'.join(textwrap.wrap(p.help().strip(),<EOL>initial_indent='<STR_LIT:U+0020>',<EOL>subsequent_indent='<STR_LIT:U+0020>')))<EOL>if v >= <NUM_LIT:3>:<EOL><INDENT>parser = DummyParser()<EOL>p.addOptions(parser)<EOL>if len(parser.options):<EOL><INDENT>print()<EOL>print(\"<STR_LIT>\")<EOL>for opts, help in parser.options:<EOL><INDENT>print('<STR_LIT>' % ('<STR_LIT:U+002CU+0020>'.join(opts)))<EOL>if help:<EOL><INDENT>print('<STR_LIT:\\n>'.join(<EOL>textwrap.wrap(help.strip(),<EOL>initial_indent='<STR_LIT:U+0020>',<EOL>subsequent_indent='<STR_LIT:U+0020>')))<EOL><DEDENT><DEDENT><DEDENT><DEDENT>print()<EOL><DEDENT><DEDENT>", "docstring": "Print list of available plugins.", "id": "f21793:c1:m5"}
{"signature": "def makeConfig(self, env, plugins=None):", "body": "cfg_files = all_config_files()<EOL>if plugins:<EOL><INDENT>manager = PluginManager(plugins=plugins)<EOL><DEDENT>else:<EOL><INDENT>manager = DefaultPluginManager()<EOL><DEDENT>return Config(<EOL>env=env, files=cfg_files, plugins=manager)<EOL>", "docstring": "Load a Config, pre-filled with user config files if any are\n        found.", "id": "f21793:c1:m1"}
{"signature": "def parseArgs(self, argv):", "body": "self.config.configure(argv, doc=self.usage())<EOL>log.debug(\"<STR_LIT>\", self.config)<EOL>if self.config.options.version:<EOL><INDENT>from nose import __version__<EOL>sys.stdout = sys.__stdout__<EOL>print(\"<STR_LIT>\" % (os.path.basename(sys.argv[<NUM_LIT:0>]), __version__))<EOL>sys.exit(<NUM_LIT:0>)<EOL><DEDENT>if self.config.options.showPlugins:<EOL><INDENT>self.showPlugins()<EOL>sys.exit(<NUM_LIT:0>)<EOL><DEDENT>if self.testLoader is None:<EOL><INDENT>self.testLoader = defaultTestLoader(config=self.config)<EOL><DEDENT>elif isclass(self.testLoader):<EOL><INDENT>self.testLoader = self.testLoader(config=self.config)<EOL><DEDENT>plug_loader = self.config.plugins.prepareTestLoader(self.testLoader)<EOL>if plug_loader is not None:<EOL><INDENT>self.testLoader = plug_loader<EOL><DEDENT>log.debug(\"<STR_LIT>\", self.testLoader)<EOL>if self.config.testNames:<EOL><INDENT>self.testNames = self.config.testNames<EOL><DEDENT>else:<EOL><INDENT>self.testNames = tolist(self.defaultTest)<EOL><DEDENT>log.debug('<STR_LIT>', self.defaultTest)<EOL>log.debug('<STR_LIT>', self.testNames)<EOL>if self.config.workingDir is not None:<EOL><INDENT>os.chdir(self.config.workingDir)<EOL><DEDENT>self.createTests()<EOL>", "docstring": "Parse argv and env and configure running environment.", "id": "f21793:c1:m2"}
{"signature": "def runTests(self):", "body": "log.debug(\"<STR_LIT>\")<EOL>if self.testRunner is None:<EOL><INDENT>self.testRunner = TextTestRunner(stream=self.config.stream,<EOL>verbosity=self.config.verbosity,<EOL>config=self.config)<EOL><DEDENT>plug_runner = self.config.plugins.prepareTestRunner(self.testRunner)<EOL>if plug_runner is not None:<EOL><INDENT>self.testRunner = plug_runner<EOL><DEDENT>result = self.testRunner.run(self.test)<EOL>self.success = result.wasSuccessful()<EOL>if self.exit:<EOL><INDENT>sys.exit(not self.success)<EOL><DEDENT>return self.success<EOL>", "docstring": "Run Tests. Returns true on success, false on failure, and sets\n        self.success to the same value.", "id": "f21793:c1:m4"}
{"signature": "def createTests(self):", "body": "log.debug(\"<STR_LIT>\", self.suite)<EOL>if self.suite is not None:<EOL><INDENT>self.test = self.testLoader.suiteClass(self.suite)<EOL><DEDENT>else:<EOL><INDENT>self.test = self.testLoader.loadTestsFromNames(self.testNames)<EOL><DEDENT>", "docstring": "Create the tests to run. If a self.suite\n        is set, then that suite will be used. Otherwise, tests will be\n        loaded from the given test names (self.testNames) using the\n        test loader.", "id": "f21793:c1:m3"}
{"signature": "def inspect_traceback(tb):", "body": "log.debug('<STR_LIT>', tb)<EOL>while tb.tb_next:<EOL><INDENT>tb = tb.tb_next<EOL><DEDENT>frame = tb.tb_frame<EOL>lines, exc_line = tbsource(tb)<EOL>inspect_lines, mark_line = find_inspectable_lines(lines, exc_line)<EOL>src = StringIO(textwrap.dedent('<STR_LIT>'.join(inspect_lines)))<EOL>exp = Expander(frame.f_locals, frame.f_globals)<EOL>while inspect_lines:<EOL><INDENT>try:<EOL><INDENT>for tok in tokenize.generate_tokens(src.readline):<EOL><INDENT>exp(*tok)<EOL><DEDENT><DEDENT>except tokenize.TokenError as e:<EOL><INDENT>log.debug(\"<STR_LIT>\", e)<EOL>inspect_lines.pop(<NUM_LIT:0>)<EOL>mark_line -= <NUM_LIT:1><EOL>src = StringIO(textwrap.dedent('<STR_LIT>'.join(inspect_lines)))<EOL>exp = Expander(frame.f_locals, frame.f_globals)<EOL>continue<EOL><DEDENT>break<EOL><DEDENT>padded = []<EOL>if exp.expanded_source:<EOL><INDENT>exp_lines = exp.expanded_source.split('<STR_LIT:\\n>')<EOL>ep = <NUM_LIT:0><EOL>for line in exp_lines:<EOL><INDENT>if ep == mark_line:<EOL><INDENT>padded.append('<STR_LIT>' + line)<EOL><DEDENT>else:<EOL><INDENT>padded.append('<STR_LIT:U+0020>' + line)<EOL><DEDENT>ep += <NUM_LIT:1><EOL><DEDENT><DEDENT>return '<STR_LIT:\\n>'.join(padded)<EOL>", "docstring": "Inspect a traceback and its frame, returning source for the expression\n    where the exception was raised, with simple variable replacement performed\n    and the line on which the exception was raised marked with '>>'", "id": "f21795:m0"}
{"signature": "def tbsource(tb, context=<NUM_LIT:6>):", "body": "lineno = tb.tb_lineno<EOL>frame = tb.tb_frame<EOL>if context > <NUM_LIT:0>:<EOL><INDENT>start = lineno - <NUM_LIT:1> - context//<NUM_LIT:2><EOL>log.debug(\"<STR_LIT>\", lineno, start)<EOL>try:<EOL><INDENT>lines, dummy = inspect.findsource(frame)<EOL><DEDENT>except IOError:<EOL><INDENT>lines, index = ['<STR_LIT>'], <NUM_LIT:0><EOL><DEDENT>else:<EOL><INDENT>all_lines = lines<EOL>start = max(start, <NUM_LIT:1>)<EOL>start = max(<NUM_LIT:0>, min(start, len(lines) - context))<EOL>lines = lines[start:start+context]<EOL>index = lineno - <NUM_LIT:1> - start<EOL>if sys.version_info >= (<NUM_LIT:2>, <NUM_LIT:5>) and index > <NUM_LIT:0>:<EOL><INDENT>while lines[index-<NUM_LIT:1>].strip().endswith('<STR_LIT:\\\\>'):<EOL><INDENT>start -= <NUM_LIT:1><EOL>lines = all_lines[start:start+context]<EOL><DEDENT><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>lines, index = ['<STR_LIT>'], <NUM_LIT:0><EOL><DEDENT>log.debug(\"<STR_LIT>\", lines, index)<EOL>return (lines, index)<EOL>", "docstring": "Get source from  a traceback object.\n\n    A tuple of two things is returned: a list of lines of context from\n    the source code, and the index of the current line within that list.\n    The optional second argument specifies the number of lines of context\n    to return, which are centered around the current line.\n\n    .. Note ::\n       This is adapted from inspect.py in the python 2.4 standard library, \n       since a bug in the 2.3 version of inspect prevents it from correctly\n       locating source lines in a traceback frame.", "id": "f21795:m1"}
{"signature": "def find_inspectable_lines(lines, pos):", "body": "cnt = re.compile(r'<STR_LIT>')<EOL>df = re.compile(r'<STR_LIT>')<EOL>ind = re.compile(r'<STR_LIT>')<EOL>toinspect = []<EOL>home = lines[pos]<EOL>home_indent = ind.match(home).groups()[<NUM_LIT:0>]<EOL>before = lines[max(pos-<NUM_LIT:3>, <NUM_LIT:0>):pos]<EOL>before.reverse()<EOL>after = lines[pos+<NUM_LIT:1>:min(pos+<NUM_LIT:4>, len(lines))]<EOL>for line in before:<EOL><INDENT>if ind.match(line).groups()[<NUM_LIT:0>] == home_indent:<EOL><INDENT>toinspect.append(line)<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>toinspect.reverse()<EOL>toinspect.append(home)<EOL>home_pos = len(toinspect)-<NUM_LIT:1><EOL>continued = cnt.search(home)<EOL>for line in after:<EOL><INDENT>if ((continued or ind.match(line).groups()[<NUM_LIT:0>] == home_indent)<EOL>and not df.search(line)):<EOL><INDENT>toinspect.append(line)<EOL>continued = cnt.search(line)<EOL><DEDENT>else:<EOL><INDENT>break<EOL><DEDENT><DEDENT>log.debug(\"<STR_LIT>\", toinspect, home_pos)<EOL>return toinspect, home_pos<EOL>", "docstring": "Find lines in home that are inspectable.\n\n    Walk back from the err line up to 3 lines, but don't walk back over\n    changes in indent level.\n\n    Walk forward up to 3 lines, counting \\ separated lines as 1. Don't walk\n    over changes in indent level (unless part of an extended line)", "id": "f21795:m2"}
{"signature": "def deferred(timeout=None):", "body": "reactor, reactor_thread = threaded_reactor()<EOL>if reactor is None:<EOL><INDENT>raise ImportError(\"<STR_LIT>\")<EOL><DEDENT>try:<EOL><INDENT>timeout is None or timeout + <NUM_LIT:0><EOL><DEDENT>except TypeError:<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>def decorate(func):<EOL><INDENT>def wrapper(*args, **kargs):<EOL><INDENT>q = Queue()<EOL>def callback(value):<EOL><INDENT>q.put(None)<EOL><DEDENT>def errback(failure):<EOL><INDENT>try:<EOL><INDENT>failure.raiseException()<EOL><DEDENT>except:<EOL><INDENT>q.put(sys.exc_info())<EOL><DEDENT><DEDENT>def g():<EOL><INDENT>try:<EOL><INDENT>d = func(*args, **kargs)<EOL>try:<EOL><INDENT>d.addCallbacks(callback, errback)<EOL><DEDENT>except AttributeError:<EOL><INDENT>raise TypeError(\"<STR_LIT>\"<EOL>\"<STR_LIT>\")<EOL><DEDENT><DEDENT>except:<EOL><INDENT>q.put(sys.exc_info())<EOL><DEDENT><DEDENT>reactor.callFromThread(g)<EOL>try:<EOL><INDENT>error = q.get(timeout=timeout)<EOL><DEDENT>except Empty:<EOL><INDENT>raise TimeExpired(\"<STR_LIT>\"<EOL>% timeout)<EOL><DEDENT>if error is not None:<EOL><INDENT>exc_type, exc_value, tb = error<EOL>raise exc_type(exc_value).with_traceback(tb)<EOL><DEDENT><DEDENT>wrapper = make_decorator(func)(wrapper)<EOL>return wrapper<EOL><DEDENT>return decorate<EOL>", "docstring": "By wrapping a test function with this decorator, you can return a\ntwisted Deferred and the test will wait for the deferred to be triggered.\nThe whole test function will run inside the Twisted event loop.\n\nThe optional timeout parameter specifies the maximum duration of the test.\nThe difference with timed() is that timed() will still wait for the test\nto end, while deferred() will stop the test when its timeout has expired.\nThe latter is more desireable when dealing with network tests, because\nthe result may actually never arrive.\n\nIf the callback is triggered, the test has passed.\nIf the errback is triggered or the timeout expires, the test has failed.\n\nExample::\n\n    @deferred(timeout=5.0)\n    def test_resolve():\n        return reactor.resolve(\"www.python.org\")\n\nAttention! If you combine this decorator with other decorators (like\n\"raises\"), deferred() must be called *first*!\n\nIn other words, this is good::\n\n    @raises(DNSLookupError)\n    @deferred()\n    def test_error():\n        return reactor.resolve(\"xxxjhjhj.biz\")\n\nand this is bad::\n\n    @deferred()\n    @raises(DNSLookupError)\n    def test_error():\n        return reactor.resolve(\"xxxjhjhj.biz\")", "id": "f21796:m2"}
{"signature": "def check_running(process_name=\"<STR_LIT>\"):", "body": "if not gurumate.base.get_pid_list(process_name):<EOL><INDENT>fail(\"<STR_LIT>\" % process_name)<EOL>return False <EOL><DEDENT>return True<EOL>", "docstring": "CHECK if process (default=apache2) is not running", "id": "f21801:m0"}
{"signature": "def check_listening_port(port=<NUM_LIT>, process_name=\"<STR_LIT>\"):", "body": "if port not in get_listening_ports(process_name):<EOL><INDENT>fail(\"<STR_LIT>\" % port)<EOL><DEDENT>", "docstring": "CHECK if process (default=apache2) is running and listening on port 80", "id": "f21801:m1"}
{"signature": "def get_listening_ports(process_name=\"<STR_LIT>\"):", "body": "ports = set()<EOL>for _, address_info in gurumate.base.get_listening_ports(process_name):<EOL><INDENT>ports.add(address_info[<NUM_LIT:1>])<EOL><DEDENT>return list(ports)<EOL>", "docstring": "returns a list of listening ports for running process (default=apache2)", "id": "f21801:m2"}
{"signature": "def compare_response_code(url, code):", "body": "try:<EOL><INDENT>response = urllib.request.urlopen(url)<EOL><DEDENT>except HTTPError as e:<EOL><INDENT>return e.code == code<EOL><DEDENT>except:<EOL><INDENT>return False<EOL><DEDENT>return response.code == code<EOL>", "docstring": "Compare the response code of url param with code param and returns boolean \n@param url -> string e.g. http://127.0.0.1/index\n@param content_type -> int e.g. 404, 500, 400 ..etc", "id": "f21810:m5"}
{"signature": "def __init__(self, display=None):", "body": "super(CallbackModule, self).__init__(display)<EOL>self.last_skipped = False<EOL>self.last_task_name = None<EOL>self.printed_last_task = False<EOL>", "docstring": "selective.py callback plugin.", "id": "f21833:c0:m0"}
{"signature": "def _get_status(self):", "body": "return self.__status<EOL>", "docstring": "Getter method for status, mapped from YANG variable /vlans/vlan/state/status (enumeration)\n\nYANG Description: Admin state of the VLAN", "id": "f21837:c0:m8"}
{"signature": "def _set_subinterface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subinterface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subinterface, mapped from YANG variable /vlans/vlan/members/member/interface_ref/state/subinterface (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subinterface is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subinterface() directly.\n\n    YANG Description: Reference to a subinterface -- this requires the base\ninterface to be specified using the interface leaf in\nthis container.  If only a reference to a base interface\nis requuired, this leaf should not be set.", "id": "f21838:c0:m6"}
{"signature": "def _set_interface_ref(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=interface_ref.interface_ref,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface_ref = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface_ref, mapped from YANG variable /vlans/vlan/members/member/interface_ref (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_interface_ref is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_interface_ref() directly.\n\nYANG Description: Reference to an interface or subinterface", "id": "f21840:c0:m3"}
{"signature": "def _get_member(self):", "body": "return self.__member<EOL>", "docstring": "Getter method for member, mapped from YANG variable /vlans/vlan/members/member (list)\n\n    YANG Description: List of references to interfaces / subinterfaces\nassociated with the VLAN.", "id": "f21841:c0:m2"}
{"signature": "def _set_tpid(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>default=six.text_type(\"<STR_LIT>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__tpid = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for tpid, mapped from YANG variable /vlans/vlan/config/tpid (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_tpid is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_tpid() directly.\n\n    YANG Description: Optionally set the tag protocol identifier field (TPID) that\nis accepted on the VLAN", "id": "f21842:c0:m12"}
{"signature": "def _get_status(self):", "body": "return self.__status<EOL>", "docstring": "Getter method for status, mapped from YANG variable /vlans/vlan/config/status (enumeration)\n\nYANG Description: Admin state of the VLAN", "id": "f21842:c0:m8"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /vlans/vlan/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State variables for VLANs", "id": "f21843:c0:m9"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /vlans/vlan/config (container)\n\nYANG Description: Configuration parameters for VLANs", "id": "f21843:c0:m5"}
{"signature": "def _get_vlan(self):", "body": "return self.__vlan<EOL>", "docstring": "Getter method for vlan, mapped from YANG variable /vlans/vlan (list)\n\nYANG Description: Configured VLANs keyed by id", "id": "f21844:c0:m2"}
{"signature": "def _set_facility(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__facility = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for facility, mapped from YANG variable /system/logging/console/selectors/selector/state/facility (identityref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_facility is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_facility() directly.\n\nYANG Description: Specifies the facility, or class of messages to log", "id": "f21845:c0:m3"}
{"signature": "def _set_severity(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__severity = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for severity, mapped from YANG variable /system/logging/console/selectors/selector/state/severity (syslog-severity)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_severity is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_severity() directly.\n\n    YANG Description: Specifies that only messages of the given severity (or\ngreater severity) for the corresonding facility are logged", "id": "f21845:c0:m6"}
{"signature": "def _get_facility(self):", "body": "return self.__facility<EOL>", "docstring": "Getter method for facility, mapped from YANG variable /system/logging/console/selectors/selector/state/facility (identityref)\n\nYANG Description: Specifies the facility, or class of messages to log", "id": "f21845:c0:m2"}
{"signature": "def _set_facility(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__facility = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for facility, mapped from YANG variable /system/logging/console/selectors/selector/config/facility (identityref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_facility is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_facility() directly.\n\nYANG Description: Specifies the facility, or class of messages to log", "id": "f21846:c0:m3"}
{"signature": "def _set_facility(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__facility = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for facility, mapped from YANG variable /system/logging/console/selectors/selector/facility (leafref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_facility is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_facility() directly.\n\nYANG Description: Reference to facility list key", "id": "f21847:c0:m3"}
{"signature": "def _get_facility(self):", "body": "return self.__facility<EOL>", "docstring": "Getter method for facility, mapped from YANG variable /system/logging/console/selectors/selector/facility (leafref)\n\nYANG Description: Reference to facility list key", "id": "f21847:c0:m2"}
{"signature": "def _get_selector(self):", "body": "return self.__selector<EOL>", "docstring": "Getter method for selector, mapped from YANG variable /system/logging/console/selectors/selector (list)\n\nYANG Description: List of selectors for log messages", "id": "f21848:c0:m2"}
{"signature": "def _set_console(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=console.console,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__console = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for console, mapped from YANG variable /system/logging/console (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_console is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_console() directly.\n\n    YANG Description: Top-level container for data related to console-based\nlogging", "id": "f21850:c0:m3"}
{"signature": "def _get_remote_port(self):", "body": "return self.__remote_port<EOL>", "docstring": "Getter method for remote_port, mapped from YANG variable /system/logging/remote_servers/remote_server/state/remote_port (inet:port-number)\n\n    YANG Description: Sets the destination port number for syslog UDP messages to\nthe server.  The default for syslog is 514.", "id": "f21852:c0:m8"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /system/logging/remote_servers/remote_server/selectors/selector/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration data", "id": "f21855:c0:m9"}
{"signature": "def _get_severity(self):", "body": "return self.__severity<EOL>", "docstring": "Getter method for severity, mapped from YANG variable /system/logging/remote_servers/remote_server/selectors/selector/severity (leafref)\n\nYANG Description: Reference to severity list key", "id": "f21855:c0:m5"}
{"signature": "def _get_host(self):", "body": "return self.__host<EOL>", "docstring": "Getter method for host, mapped from YANG variable /system/logging/remote_servers/remote_server/config/host (inet:host)\n\nYANG Description: IP address or hostname of the remote log server", "id": "f21857:c0:m2"}
{"signature": "def _set_host(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": [\"<STR_LIT>\"],<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:host>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__host = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for host, mapped from YANG variable /system/logging/remote_servers/remote_server/config/host (inet:host)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_host is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_host() directly.\n\nYANG Description: IP address or hostname of the remote log server", "id": "f21857:c0:m3"}
{"signature": "def _get_remote_port(self):", "body": "return self.__remote_port<EOL>", "docstring": "Getter method for remote_port, mapped from YANG variable /system/logging/remote_servers/remote_server/config/remote_port (inet:port-number)\n\n    YANG Description: Sets the destination port number for syslog UDP messages to\nthe server.  The default for syslog is 514.", "id": "f21857:c0:m8"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /system/logging/remote_servers/remote_server/state (container)\n\nYANG Description: Operational state data for remote log servers", "id": "f21858:c0:m8"}
{"signature": "def _set_host(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:host>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__host = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for host, mapped from YANG variable /system/logging/remote_servers/remote_server/host (leafref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_host is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_host() directly.\n\nYANG Description: Reference to the host list key", "id": "f21858:c0:m3"}
{"signature": "def _get_boot_time(self):", "body": "return self.__boot_time<EOL>", "docstring": "Getter method for boot_time, mapped from YANG variable /system/state/boot_time (oc-types:timeticks64)\n\n    YANG Description: This timestamp indicates the time that the system was last\nrestarted.  The value is the timestamp in seconds relative\nto the Unix Epoch (Jan 1, 1970 00:00:00 UTC).", "id": "f21859:c0:m17"}
{"signature": "def _set_login_banner(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__login_banner = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for login_banner, mapped from YANG variable /system/state/login_banner (string)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_login_banner is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_login_banner() directly.\n\n    YANG Description: The console login message displayed before the login prompt,\ni.e., before a user logs into the system.", "id": "f21859:c0:m9"}
{"signature": "def _set_hostname(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": [\"<STR_LIT>\"],<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__hostname = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for hostname, mapped from YANG variable /system/state/hostname (inet:domain-name)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_hostname is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_hostname() directly.\n\n    YANG Description: The hostname of the device -- should be a single domain\nlabel, without the domain.", "id": "f21859:c0:m3"}
{"signature": "def _get_current_datetime(self):", "body": "return self.__current_datetime<EOL>", "docstring": "Getter method for current_datetime, mapped from YANG variable /system/state/current_datetime (yang:date-and-time)\n\n    YANG Description: [adapted from IETF system model RFC 7317]\n\nThe current system date and time.", "id": "f21859:c0:m14"}
{"signature": "def _get_timezone_name(self):", "body": "return self.__timezone_name<EOL>", "docstring": "Getter method for timezone_name, mapped from YANG variable /system/clock/state/timezone_name (timezone-name-type)\n\n    YANG Description: The TZ database name to use for the system, such\nas 'Europe/Stockholm'.", "id": "f21860:c0:m2"}
{"signature": "def _get_timezone_name(self):", "body": "return self.__timezone_name<EOL>", "docstring": "Getter method for timezone_name, mapped from YANG variable /system/clock/config/timezone_name (timezone-name-type)\n\n    YANG Description: The TZ database name to use for the system, such\nas 'Europe/Stockholm'.", "id": "f21861:c0:m2"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /system/ntp/state/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: [adapted from IETF system model RFC 7317]\n\nEnables the NTP protocol and indicates that the system should\nattempt to synchronize the system clock with an NTP server\nfrom the servers defined in the 'ntp/server' list.", "id": "f21863:c0:m3"}
{"signature": "def _set_auth_mismatch(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__auth_mismatch = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for auth_mismatch, mapped from YANG variable /system/ntp/state/auth_mismatch (yang:counter64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_auth_mismatch is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_auth_mismatch() directly.\n\n    YANG Description: Count of the number of NTP packets received that were not\nprocessed due to authentication mismatch.", "id": "f21863:c0:m12"}
{"signature": "def _set_key_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__key_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for key_id, mapped from YANG variable /system/ntp/ntp_keys/ntp_key/state/key_id (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_key_id is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_key_id() directly.\n\n    YANG Description: Integer identifier used by the client and server to\ndesignate a secret key.  The client and server must use\nthe same key id.", "id": "f21866:c0:m3"}
{"signature": "def _get_key_id(self):", "body": "return self.__key_id<EOL>", "docstring": "Getter method for key_id, mapped from YANG variable /system/ntp/ntp_keys/ntp_key/state/key_id (uint16)\n\n    YANG Description: Integer identifier used by the client and server to\ndesignate a secret key.  The client and server must use\nthe same key id.", "id": "f21866:c0:m2"}
{"signature": "def _get_key_value(self):", "body": "return self.__key_value<EOL>", "docstring": "Getter method for key_value, mapped from YANG variable /system/ntp/ntp_keys/ntp_key/config/key_value (string)\n\nYANG Description: NTP authentication key value", "id": "f21867:c0:m8"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /system/ntp/ntp_keys/ntp_key/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Operational state data for NTP auth keys", "id": "f21868:c0:m9"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /system/ntp/ntp_keys/ntp_key/state (container)\n\nYANG Description: Operational state data for NTP auth keys", "id": "f21868:c0:m8"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /system/ntp/ntp_keys/ntp_key/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration data for NTP auth keys", "id": "f21868:c0:m6"}
{"signature": "def _set_ntp_keys(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=ntp_keys.ntp_keys,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ntp_keys = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ntp_keys, mapped from YANG variable /system/ntp/ntp_keys (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ntp_keys is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ntp_keys() directly.\n\nYANG Description: Enclosing container for list of NTP authentication keys", "id": "f21869:c0:m9"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /system/ntp/config (container)\n\nYANG Description: Configuration data for NTP client.", "id": "f21869:c0:m2"}
{"signature": "def _set_association_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>default=six.text_type(\"<STR_LIT>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__association_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for association_type, mapped from YANG variable /system/ntp/servers/server/state/association_type (enumeration)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_association_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_association_type() directly.\n\n    YANG Description: [adapted from IETF system model RFC 7317]\n\nThe desired association type for this NTP server.", "id": "f21870:c0:m12"}
{"signature": "def _get_address(self):", "body": "return self.__address<EOL>", "docstring": "Getter method for address, mapped from YANG variable /system/ntp/servers/server/state/address (inet:host)\n\n    YANG Description: [adapted from IETF system model RFC 7317]\n\nThe address or hostname of the NTP server.", "id": "f21870:c0:m2"}
{"signature": "def _set_poll_interval(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__poll_interval = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for poll_interval, mapped from YANG variable /system/ntp/servers/server/state/poll_interval (uint32)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_poll_interval is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_poll_interval() directly.\n\nYANG Description: Polling interval of the peer", "id": "f21870:c0:m33"}
{"signature": "def _get_iburst(self):", "body": "return self.__iburst<EOL>", "docstring": "Getter method for iburst, mapped from YANG variable /system/ntp/servers/server/state/iburst (boolean)\n\n    YANG Description: [adapted from IETF system model RFC 7317]\n\nIndicates whether this server should enable burst\nsynchronization or not.", "id": "f21870:c0:m14"}
{"signature": "def _set_stratum(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__stratum = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for stratum, mapped from YANG variable /system/ntp/servers/server/state/stratum (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_stratum is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_stratum() directly.\n\n    YANG Description: Indicates the level of the server in the NTP hierarchy. As\nstratum number increases, the accuracy is degraded.  Primary\nservers are stratum while a maximum value of 16 indicates\nunsynchronized.  The values have the following specific\nsemantics:\n\n| 0      | unspecified or invalid\n| 1      | primary server (e.g., equipped with a GPS receiver)\n| 2-15   | secondary server (via NTP)\n| 16     | unsynchronized\n| 17-255 | reserved", "id": "f21870:c0:m21"}
{"signature": "def _set_version(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>default=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>)(<EOL><NUM_LIT:4><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:version>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__version = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for version, mapped from YANG variable /system/ntp/servers/server/state/version (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_version is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_version() directly.\n\n    YANG Description: [adapted from IETF system model RFC 7317]\n\nVersion number to put in outgoing NTP packets", "id": "f21870:c0:m9"}
{"signature": "def _get_prefer(self):", "body": "return self.__prefer<EOL>", "docstring": "Getter method for prefer, mapped from YANG variable /system/ntp/servers/server/config/prefer (boolean)\n\n    YANG Description: [adapted from IETF system model RFC 7317]\n\nIndicates whether this server should be preferred\nor not.", "id": "f21871:c0:m17"}
{"signature": "def _get_association_type(self):", "body": "return self.__association_type<EOL>", "docstring": "Getter method for association_type, mapped from YANG variable /system/ntp/servers/server/config/association_type (enumeration)\n\n    YANG Description: [adapted from IETF system model RFC 7317]\n\nThe desired association type for this NTP server.", "id": "f21871:c0:m11"}
{"signature": "def _set_iburst(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__iburst = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for iburst, mapped from YANG variable /system/ntp/servers/server/config/iburst (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_iburst is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_iburst() directly.\n\n    YANG Description: [adapted from IETF system model RFC 7317]\n\nIndicates whether this server should enable burst\nsynchronization or not.", "id": "f21871:c0:m15"}
{"signature": "def _get_iburst(self):", "body": "return self.__iburst<EOL>", "docstring": "Getter method for iburst, mapped from YANG variable /system/ntp/servers/server/config/iburst (boolean)\n\n    YANG Description: [adapted from IETF system model RFC 7317]\n\nIndicates whether this server should enable burst\nsynchronization or not.", "id": "f21871:c0:m14"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /system/ntp/servers/server/config (container)\n\nYANG Description: Configuration data for an NTP server.", "id": "f21872:c0:m5"}
{"signature": "def _get_address(self):", "body": "return self.__address<EOL>", "docstring": "Getter method for address, mapped from YANG variable /system/ntp/servers/server/address (leafref)\n\n    YANG Description: References the configured address or hostname of the\nNTP server.", "id": "f21872:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /system/ntp/servers/server/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Operational state data for an NTP server.", "id": "f21872:c0:m9"}
{"signature": "def _set_enable(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:true>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enable = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enable, mapped from YANG variable /system/ssh_server/state/enable (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enable is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enable() directly.\n\n    YANG Description: Enables the ssh server.  The ssh server is enabled by\ndefault.", "id": "f21874:c0:m3"}
{"signature": "def _set_rate_limit(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__rate_limit = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for rate_limit, mapped from YANG variable /system/ssh_server/state/rate_limit (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_rate_limit is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_rate_limit() directly.\n\n    YANG Description: Set a limit on the number of connection attempts per\nminute to the system for the protocol.", "id": "f21874:c0:m12"}
{"signature": "def _get_timeout(self):", "body": "return self.__timeout<EOL>", "docstring": "Getter method for timeout, mapped from YANG variable /system/ssh_server/state/timeout (uint16)\n\n    YANG Description: Set the idle timeout in seconds on terminal connections to\nthe system for the protocol.", "id": "f21874:c0:m8"}
{"signature": "def _set_timeout(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__timeout = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for timeout, mapped from YANG variable /system/ssh_server/config/timeout (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_timeout is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_timeout() directly.\n\n    YANG Description: Set the idle timeout in seconds on terminal connections to\nthe system for the protocol.", "id": "f21875:c0:m9"}
{"signature": "def _get_protocol_version(self):", "body": "return self.__protocol_version<EOL>", "docstring": "Getter method for protocol_version, mapped from YANG variable /system/ssh_server/config/protocol_version (enumeration)\n\nYANG Description: Set the protocol version for SSH connections to the system", "id": "f21875:c0:m5"}
{"signature": "def _get_rate_limit(self):", "body": "return self.__rate_limit<EOL>", "docstring": "Getter method for rate_limit, mapped from YANG variable /system/ssh_server/config/rate_limit (uint16)\n\n    YANG Description: Set a limit on the number of connection attempts per\nminute to the system for the protocol.", "id": "f21875:c0:m11"}
{"signature": "def _set_session_limit(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__session_limit = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for session_limit, mapped from YANG variable /system/ssh_server/config/session_limit (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_session_limit is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_session_limit() directly.\n\n    YANG Description: Set a limit on the number of simultaneous active terminal\nsessions to the system for the protocol (e.g., ssh,\ntelnet, ...)", "id": "f21875:c0:m15"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /system/ssh_server/state (container)\n\nYANG Description: Operational state data for the system ssh server", "id": "f21876:c0:m5"}
{"signature": "def _get_login_banner(self):", "body": "return self.__login_banner<EOL>", "docstring": "Getter method for login_banner, mapped from YANG variable /system/config/login_banner (string)\n\n    YANG Description: The console login message displayed before the login prompt,\ni.e., before a user logs into the system.", "id": "f21877:c0:m8"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /system/aaa/authorization/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration data for authorization based on AAA\nmethods", "id": "f21880:c0:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /system/aaa/authorization/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Operational state data for authorization based on AAA", "id": "f21880:c0:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /system/aaa/authorization/state (container)\n\nYANG Description: Operational state data for authorization based on AAA", "id": "f21880:c0:m5"}
{"signature": "def _get_event_type(self):", "body": "return self.__event_type<EOL>", "docstring": "Getter method for event_type, mapped from YANG variable /system/aaa/authorization/events/event/config/event_type (identityref)\n\n    YANG Description: The type of event to record at the AAA authorization\nserver", "id": "f21882:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /system/aaa/authorization/events/event/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Operational state data for each authorized activity", "id": "f21883:c0:m9"}
{"signature": "def _set_event(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>event.event,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__event = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for event, mapped from YANG variable /system/aaa/authorization/events/event (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_event is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_event() directly.\n\nYANG Description: List of events subject to AAA authorization", "id": "f21884:c0:m3"}
{"signature": "def _set_accounting(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=accounting.accounting,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__accounting = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for accounting, mapped from YANG variable /system/aaa/accounting (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_accounting is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_accounting() directly.\n\nYANG Description: Top-level container for AAA accounting", "id": "f21885:c0:m9"}
{"signature": "def _set_server_groups(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=server_groups.server_groups,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__server_groups = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for server_groups, mapped from YANG variable /system/aaa/server_groups (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_server_groups is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_server_groups() directly.\n\nYANG Description: Enclosing container for AAA server groups", "id": "f21885:c0:m12"}
{"signature": "def _get_accounting_method(self):", "body": "return self.__accounting_method<EOL>", "docstring": "Getter method for accounting_method, mapped from YANG variable /system/aaa/accounting/config/accounting_method (union)\n\n    YANG Description: The method used for AAA accounting for this event\ntype.  The method is defined by the destination for\naccounting data, which may be specified as the group of\nall TACACS+/RADIUS servers, a defined server group, or\nthe local system.", "id": "f21887:c0:m2"}
{"signature": "def _set_events(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=events.events,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__events = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for events, mapped from YANG variable /system/aaa/accounting/events (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_events is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_events() directly.\n\n    YANG Description: Enclosing container for defining handling of events\nfor accounting", "id": "f21888:c0:m9"}
{"signature": "def _get_event_type(self):", "body": "return self.__event_type<EOL>", "docstring": "Getter method for event_type, mapped from YANG variable /system/aaa/accounting/events/event/state/event_type (identityref)\n\n    YANG Description: The type of activity to record at the AAA accounting\nserver", "id": "f21889:c0:m2"}
{"signature": "def _get_record(self):", "body": "return self.__record<EOL>", "docstring": "Getter method for record, mapped from YANG variable /system/aaa/accounting/events/event/config/record (enumeration)\n\n    YANG Description: Type of record to send to the accounting server for this\nactivity type", "id": "f21890:c0:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /system/aaa/accounting/events/event/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Operational state data for accounting events", "id": "f21891:c0:m9"}
{"signature": "def _set_event(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>event.event,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__event = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for event, mapped from YANG variable /system/aaa/accounting/events/event (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_event is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_event() directly.\n\nYANG Description: List of events subject to accounting", "id": "f21892:c0:m3"}
{"signature": "def _get_server_group(self):", "body": "return self.__server_group<EOL>", "docstring": "Getter method for server_group, mapped from YANG variable /system/aaa/server_groups/server_group (list)\n\n    YANG Description: List of AAA server groups.  All servers in a group\nmust have the same type as indicated by the server\ntype.", "id": "f21893:c0:m2"}
{"signature": "def _set_name(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:name>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for name, mapped from YANG variable /system/aaa/server_groups/server_group/state/name (string)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_name is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_name() directly.\n\nYANG Description: Name for the server group", "id": "f21894:c0:m3"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /system/aaa/server_groups/server_group/state/type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_type() directly.\n\n    YANG Description: AAA server type -- all servers in the group must be of this\ntype", "id": "f21894:c0:m6"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /system/aaa/server_groups/server_group/config/type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_type() directly.\n\n    YANG Description: AAA server type -- all servers in the group must be of this\ntype", "id": "f21895:c0:m6"}
{"signature": "def _get_name(self):", "body": "return self.__name<EOL>", "docstring": "Getter method for name, mapped from YANG variable /system/aaa/server_groups/server_group/config/name (string)\n\nYANG Description: Name for the server group", "id": "f21895:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /system/aaa/server_groups/server_group/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Operational state data for each server group", "id": "f21896:c0:m9"}
{"signature": "def _get_name(self):", "body": "return self.__name<EOL>", "docstring": "Getter method for name, mapped from YANG variable /system/aaa/server_groups/server_group/name (leafref)\n\nYANG Description: Reference to configured name of the server group", "id": "f21896:c0:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /system/aaa/server_groups/server_group/state (container)\n\nYANG Description: Operational state data for each server group", "id": "f21896:c0:m8"}
{"signature": "def _set_servers(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=servers.servers,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__servers = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for servers, mapped from YANG variable /system/aaa/server_groups/server_group/servers (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_servers is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_servers() directly.\n\nYANG Description: Enclosing container the list of servers", "id": "f21896:c0:m12"}
{"signature": "def _get_connection_failures(self):", "body": "return self.__connection_failures<EOL>", "docstring": "Getter method for connection_failures, mapped from YANG variable /system/aaa/server_groups/server_group/servers/server/state/connection_failures (yang:counter64)\n\nYANG Description: Number of connection failures to the server", "id": "f21897:c0:m20"}
{"signature": "def _get_messages_received(self):", "body": "return self.__messages_received<EOL>", "docstring": "Getter method for messages_received, mapped from YANG variable /system/aaa/server_groups/server_group/servers/server/state/messages_received (yang:counter64)\n\nYANG Description: Number of messages received by the server", "id": "f21897:c0:m29"}
{"signature": "def _set_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:address>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for address, mapped from YANG variable /system/aaa/server_groups/server_group/servers/server/state/address (inet:ip-address)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_address is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_address() directly.\n\nYANG Description: Address of the authentication server", "id": "f21897:c0:m6"}
{"signature": "def _set_messages_received(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__messages_received = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for messages_received, mapped from YANG variable /system/aaa/server_groups/server_group/servers/server/state/messages_received (yang:counter64)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_messages_received is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_messages_received() directly.\n\nYANG Description: Number of messages received by the server", "id": "f21897:c0:m30"}
{"signature": "def _set_connection_failures(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__connection_failures = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for connection_failures, mapped from YANG variable /system/aaa/server_groups/server_group/servers/server/state/connection_failures (yang:counter64)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_connection_failures is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_connection_failures() directly.\n\nYANG Description: Number of connection failures to the server", "id": "f21897:c0:m21"}
{"signature": "def _get_errors_received(self):", "body": "return self.__errors_received<EOL>", "docstring": "Getter method for errors_received, mapped from YANG variable /system/aaa/server_groups/server_group/servers/server/state/errors_received (yang:counter64)\n\nYANG Description: Number of error messages received from the server", "id": "f21897:c0:m32"}
{"signature": "def _get_messages_sent(self):", "body": "return self.__messages_sent<EOL>", "docstring": "Getter method for messages_sent, mapped from YANG variable /system/aaa/server_groups/server_group/servers/server/state/messages_sent (yang:counter64)\n\nYANG Description: Number of messages sent to the server", "id": "f21897:c0:m26"}
{"signature": "def _get_connection_closes(self):", "body": "return self.__connection_closes<EOL>", "docstring": "Getter method for connection_closes, mapped from YANG variable /system/aaa/server_groups/server_group/servers/server/state/connection_closes (yang:counter64)\n\n    YANG Description: Number of connection close requests sent to the server, e.g.\nsocket close", "id": "f21897:c0:m14"}
{"signature": "def _set_messages_sent(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__messages_sent = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for messages_sent, mapped from YANG variable /system/aaa/server_groups/server_group/servers/server/state/messages_sent (yang:counter64)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_messages_sent is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_messages_sent() directly.\n\nYANG Description: Number of messages sent to the server", "id": "f21897:c0:m27"}
{"signature": "def _get_port(self):", "body": "return self.__port<EOL>", "docstring": "Getter method for port, mapped from YANG variable /system/aaa/server_groups/server_group/servers/server/tacacs/state/port (inet:port-number)\n\nYANG Description: The port number on which to contact the TACACS server", "id": "f21898:c0:m2"}
{"signature": "def _set_secret_key(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__secret_key = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for secret_key, mapped from YANG variable /system/aaa/server_groups/server_group/servers/server/tacacs/state/secret_key (oc-types:routing-password)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_secret_key is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_secret_key() directly.\n\n    YANG Description: The unencrypted shared key used between the authentication\nserver and the device.", "id": "f21898:c0:m6"}
{"signature": "def _get_secret_key(self):", "body": "return self.__secret_key<EOL>", "docstring": "Getter method for secret_key, mapped from YANG variable /system/aaa/server_groups/server_group/servers/server/tacacs/config/secret_key (oc-types:routing-password)\n\n    YANG Description: The unencrypted shared key used between the authentication\nserver and the device.", "id": "f21899:c0:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /system/aaa/server_groups/server_group/servers/server/tacacs/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Operational state data for TACACS+ server", "id": "f21900:c0:m6"}
{"signature": "def _get_secret_key(self):", "body": "return self.__secret_key<EOL>", "docstring": "Getter method for secret_key, mapped from YANG variable /system/aaa/server_groups/server_group/servers/server/radius/state/secret_key (oc-types:routing-password)\n\n    YANG Description: The unencrypted shared key used between the authentication\nserver and the device.", "id": "f21901:c0:m8"}
{"signature": "def _set_auth_port(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:16>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>default=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>)(<EOL><NUM_LIT><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__auth_port = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for auth_port, mapped from YANG variable /system/aaa/server_groups/server_group/servers/server/radius/state/auth_port (inet:port-number)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_auth_port is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_auth_port() directly.\n\nYANG Description: Port number for authentication requests", "id": "f21901:c0:m3"}
{"signature": "def _set_retransmit_attempts(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__retransmit_attempts = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for retransmit_attempts, mapped from YANG variable /system/aaa/server_groups/server_group/servers/server/radius/state/retransmit_attempts (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_retransmit_attempts is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_retransmit_attempts() directly.\n\n    YANG Description: Number of times the system may resend a request to the\nRADIUS server when it is unresponsive", "id": "f21901:c0:m15"}
{"signature": "def _get_acct_port(self):", "body": "return self.__acct_port<EOL>", "docstring": "Getter method for acct_port, mapped from YANG variable /system/aaa/server_groups/server_group/servers/server/radius/state/acct_port (inet:port-number)\n\nYANG Description: Port number for accounting requests", "id": "f21901:c0:m5"}
{"signature": "def _set_secret_key(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__secret_key = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for secret_key, mapped from YANG variable /system/aaa/server_groups/server_group/servers/server/radius/state/secret_key (oc-types:routing-password)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_secret_key is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_secret_key() directly.\n\n    YANG Description: The unencrypted shared key used between the authentication\nserver and the device.", "id": "f21901:c0:m9"}
{"signature": "def _set_acct_port(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:16>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>default=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>)(<EOL><NUM_LIT><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__acct_port = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for acct_port, mapped from YANG variable /system/aaa/server_groups/server_group/servers/server/radius/config/acct_port (inet:port-number)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_acct_port is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_acct_port() directly.\n\nYANG Description: Port number for accounting requests", "id": "f21902:c0:m6"}
{"signature": "def _get_source_address(self):", "body": "return self.__source_address<EOL>", "docstring": "Getter method for source_address, mapped from YANG variable /system/aaa/server_groups/server_group/servers/server/radius/config/source_address (inet:ip-address)\n\nYANG Description: Source IP address to use in messages to the TACACS server", "id": "f21902:c0:m11"}
{"signature": "def _set_retransmit_attempts(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__retransmit_attempts = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for retransmit_attempts, mapped from YANG variable /system/aaa/server_groups/server_group/servers/server/radius/config/retransmit_attempts (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_retransmit_attempts is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_retransmit_attempts() directly.\n\n    YANG Description: Number of times the system may resend a request to the\nRADIUS server when it is unresponsive", "id": "f21902:c0:m15"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /system/aaa/server_groups/server_group/servers/server/radius/state (container)\n\nYANG Description: Operational state data for RADIUS servers", "id": "f21903:c0:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /system/aaa/server_groups/server_group/servers/server/radius/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Operational state data for RADIUS servers", "id": "f21903:c0:m6"}
{"signature": "def _get_name(self):", "body": "return self.__name<EOL>", "docstring": "Getter method for name, mapped from YANG variable /system/aaa/server_groups/server_group/servers/server/config/name (string)\n\nYANG Description: Name assigned to the server", "id": "f21904:c0:m2"}
{"signature": "def _set_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:address>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for address, mapped from YANG variable /system/aaa/server_groups/server_group/servers/server/config/address (inet:ip-address)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_address is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_address() directly.\n\nYANG Description: Address of the authentication server", "id": "f21904:c0:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /system/aaa/server_groups/server_group/servers/server/state (container)\n\nYANG Description: Operational state data", "id": "f21905:c0:m8"}
{"signature": "def _set_tacacs(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=tacacs.tacacs,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__tacacs = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for tacacs, mapped from YANG variable /system/aaa/server_groups/server_group/servers/server/tacacs (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_tacacs is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_tacacs() directly.\n\nYANG Description: Top-level container for TACACS+ server data", "id": "f21905:c0:m12"}
{"signature": "def _get_server(self):", "body": "return self.__server<EOL>", "docstring": "Getter method for server, mapped from YANG variable /system/aaa/server_groups/server_group/servers/server (list)\n\nYANG Description: List of AAA servers", "id": "f21906:c0:m2"}
{"signature": "def _get_username(self):", "body": "return self.__username<EOL>", "docstring": "Getter method for username, mapped from YANG variable /system/aaa/authentication/users/user/state/username (string)\n\nYANG Description: Assigned username for this user", "id": "f21908:c0:m2"}
{"signature": "def _get_role(self):", "body": "return self.__role<EOL>", "docstring": "Getter method for role, mapped from YANG variable /system/aaa/authentication/users/user/config/role (union)\n\n    YANG Description: Role assigned to the user.  The role may be supplied\nas a string or a role defined by the SYSTEM_DEFINED_ROLES\nidentity.", "id": "f21909:c0:m14"}
{"signature": "def _get_username(self):", "body": "return self.__username<EOL>", "docstring": "Getter method for username, mapped from YANG variable /system/aaa/authentication/users/user/username (leafref)\n\nYANG Description: References the configured username for the user", "id": "f21910:c0:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /system/aaa/authentication/users/user/state (container)\n\nYANG Description: Operational state data for local users", "id": "f21910:c0:m8"}
{"signature": "def _set_authentication_method(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>six.text_type,<EOL>]<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__authentication_method = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for authentication_method, mapped from YANG variable /system/aaa/authentication/config/authentication_method (union)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_authentication_method is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_authentication_method() directly.\n\n    YANG Description: Ordered list of authentication methods for users.  This\ncan be either a reference to a server group, or a well-\ndefined designation in the AAA_METHOD_TYPE identity.  If\nauthentication fails with one method, the next defined\nmethod is tried -- failure of all methods results in the\nuser being denied access.", "id": "f21912:c0:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /system/aaa/authentication/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: Operational state data for global authentication\nservices", "id": "f21913:c0:m6"}
{"signature": "def _set_admin_password(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__admin_password = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for admin_password, mapped from YANG variable /system/aaa/authentication/admin_user/state/admin_password (string)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_admin_password is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_admin_password() directly.\n\n    YANG Description: The admin/root password, supplied as a cleartext string.\nThe system should encrypt and only store the password as an\nencrypted value.", "id": "f21914:c0:m3"}
{"signature": "def _get_admin_username(self):", "body": "return self.__admin_username<EOL>", "docstring": "Getter method for admin_username, mapped from YANG variable /system/aaa/authentication/admin_user/state/admin_username (string)\n\n    YANG Description: Name of the administrator user account, e.g., admin, root,\netc.", "id": "f21914:c0:m8"}
{"signature": "def _get_admin_password_encrypted(self):", "body": "return self.__admin_password_encrypted<EOL>", "docstring": "Getter method for admin_password_encrypted, mapped from YANG variable /system/aaa/authentication/admin_user/state/admin_password_encrypted (oc-aaa-types:crypt-password-type)\n\n    YANG Description: The admin/root password, supplied as an encrypted value\nusing the notation described in the definition of the\ncrypt-password-type.", "id": "f21914:c0:m5"}
{"signature": "def _set_start_time(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__start_time = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for start_time, mapped from YANG variable /system/processes/process/state/start_time (uint64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_start_time is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_start_time() directly.\n\n    YANG Description: The time at which this process started,\nreported as nanoseconds since the UNIX epoch.  The\nsystem must be synchronized such that the start-time\ncan be reported accurately, otherwise it should not be\nreported.", "id": "f21917:c0:m12"}
{"signature": "def _get_name(self):", "body": "return self.__name<EOL>", "docstring": "Getter method for name, mapped from YANG variable /system/processes/process/state/name (string)\n\nYANG Description: The process name", "id": "f21917:c0:m5"}
{"signature": "def _get_cpu_usage_user(self):", "body": "return self.__cpu_usage_user<EOL>", "docstring": "Getter method for cpu_usage_user, mapped from YANG variable /system/processes/process/state/cpu_usage_user (oc-types:timeticks64)\n\nYANG Description: CPU time consumed by this process in user mode.", "id": "f21917:c0:m17"}
{"signature": "def _get_cpu_usage_system(self):", "body": "return self.__cpu_usage_system<EOL>", "docstring": "Getter method for cpu_usage_system, mapped from YANG variable /system/processes/process/state/cpu_usage_system (oc-types:timeticks64)\n\nYANG Description: CPU time consumed by this process in kernel mode.", "id": "f21917:c0:m20"}
{"signature": "def _get_start_time(self):", "body": "return self.__start_time<EOL>", "docstring": "Getter method for start_time, mapped from YANG variable /system/processes/process/state/start_time (uint64)\n\n    YANG Description: The time at which this process started,\nreported as nanoseconds since the UNIX epoch.  The\nsystem must be synchronized such that the start-time\ncan be reported accurately, otherwise it should not be\nreported.", "id": "f21917:c0:m11"}
{"signature": "def _get_cpu_utilization(self):", "body": "return self.__cpu_utilization<EOL>", "docstring": "Getter method for cpu_utilization, mapped from YANG variable /system/processes/process/state/cpu_utilization (oc-types:percentage)\n\nYANG Description: The percentage of CPU that is being used by the process.", "id": "f21917:c0:m23"}
{"signature": "def _set_cpu_usage_system(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__cpu_usage_system = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for cpu_usage_system, mapped from YANG variable /system/processes/process/state/cpu_usage_system (oc-types:timeticks64)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_cpu_usage_system is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_cpu_usage_system() directly.\n\nYANG Description: CPU time consumed by this process in kernel mode.", "id": "f21917:c0:m21"}
{"signature": "def _get_pid(self):", "body": "return self.__pid<EOL>", "docstring": "Getter method for pid, mapped from YANG variable /system/processes/process/pid (leafref)\n\nYANG Description: Reference to the process pid key", "id": "f21918:c0:m2"}
{"signature": "def _set_pid(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__pid = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for pid, mapped from YANG variable /system/processes/process/pid (leafref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_pid is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_pid() directly.\n\nYANG Description: Reference to the process pid key", "id": "f21918:c0:m3"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /system/config (container)\n\nYANG Description: Global configuration data for the system", "id": "f21920:c0:m2"}
{"signature": "def _get_dns(self):", "body": "return self.__dns<EOL>", "docstring": "Getter method for dns, mapped from YANG variable /system/dns (container)\n\nYANG Description: Enclosing container for DNS resolver data", "id": "f21920:c0:m11"}
{"signature": "def _get_ntp(self):", "body": "return self.__ntp<EOL>", "docstring": "Getter method for ntp, mapped from YANG variable /system/ntp (container)\n\nYANG Description: Top-level container for NTP configuration and state", "id": "f21920:c0:m14"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /system/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Global configuration data for the system", "id": "f21920:c0:m3"}
{"signature": "def _set_ssh_server(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=ssh_server.ssh_server,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ssh_server = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ssh_server, mapped from YANG variable /system/ssh_server (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ssh_server is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ssh_server() directly.\n\nYANG Description: Top-level container for ssh server", "id": "f21920:c0:m18"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /system/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Global operational state data for the system", "id": "f21920:c0:m6"}
{"signature": "def _set_telnet_server(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=telnet_server.telnet_server,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__telnet_server = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for telnet_server, mapped from YANG variable /system/telnet_server (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_telnet_server is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_telnet_server() directly.\n\nYANG Description: Top-level container for telnet terminal servers", "id": "f21920:c0:m21"}
{"signature": "def _get_reserved(self):", "body": "return self.__reserved<EOL>", "docstring": "Getter method for reserved, mapped from YANG variable /system/memory/state/reserved (uint64)\n\nYANG Description: Memory reserved for system use", "id": "f21921:c0:m5"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /system/memory/state (container)\n\nYANG Description: Operational state data for system memory", "id": "f21922:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /system/memory/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Operational state data for system memory", "id": "f21922:c0:m3"}
{"signature": "def _get_enable(self):", "body": "return self.__enable<EOL>", "docstring": "Getter method for enable, mapped from YANG variable /system/telnet_server/state/enable (boolean)\n\n    YANG Description: Enables the telnet server.  Telnet is disabled by\ndefault", "id": "f21923:c0:m2"}
{"signature": "def _set_rate_limit(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__rate_limit = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for rate_limit, mapped from YANG variable /system/telnet_server/state/rate_limit (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_rate_limit is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_rate_limit() directly.\n\n    YANG Description: Set a limit on the number of connection attempts per\nminute to the system for the protocol.", "id": "f21923:c0:m9"}
{"signature": "def _get_session_limit(self):", "body": "return self.__session_limit<EOL>", "docstring": "Getter method for session_limit, mapped from YANG variable /system/telnet_server/state/session_limit (uint16)\n\n    YANG Description: Set a limit on the number of simultaneous active terminal\nsessions to the system for the protocol (e.g., ssh,\ntelnet, ...)", "id": "f21923:c0:m11"}
{"signature": "def _set_timeout(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__timeout = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for timeout, mapped from YANG variable /system/telnet_server/state/timeout (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_timeout is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_timeout() directly.\n\n    YANG Description: Set the idle timeout in seconds on terminal connections to\nthe system for the protocol.", "id": "f21923:c0:m6"}
{"signature": "def _set_timeout(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__timeout = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for timeout, mapped from YANG variable /system/telnet_server/config/timeout (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_timeout is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_timeout() directly.\n\n    YANG Description: Set the idle timeout in seconds on terminal connections to\nthe system for the protocol.", "id": "f21924:c0:m6"}
{"signature": "def _set_enable(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enable = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enable, mapped from YANG variable /system/telnet_server/config/enable (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enable is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enable() directly.\n\n    YANG Description: Enables the telnet server.  Telnet is disabled by\ndefault", "id": "f21924:c0:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /system/telnet_server/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Operational state data for telnet", "id": "f21925:c0:m6"}
{"signature": "def _get_host_entry(self):", "body": "return self.__host_entry<EOL>", "docstring": "Getter method for host_entry, mapped from YANG variable /system/dns/host_entries/host_entry (list)\n\nYANG Description: List of static host entries", "id": "f21927:c0:m2"}
{"signature": "def _get_ipv4_address(self):", "body": "return self.__ipv4_address<EOL>", "docstring": "Getter method for ipv4_address, mapped from YANG variable /system/dns/host_entries/host_entry/config/ipv4_address (inet:ipv4-address)\n\nYANG Description: List of IPv4 addressses for the host entry", "id": "f21929:c0:m8"}
{"signature": "def _set_alias(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(allowed_type=six.text_type),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__alias = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for alias, mapped from YANG variable /system/dns/host_entries/host_entry/config/alias (string)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_alias is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_alias() directly.\n\nYANG Description: Additional aliases for the hostname", "id": "f21929:c0:m6"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /system/dns/host_entries/host_entry/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Operational state data for static host entries", "id": "f21930:c0:m9"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /system/dns/host_entries/host_entry/state (container)\n\nYANG Description: Operational state data for static host entries", "id": "f21930:c0:m8"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /system/dns/state (container)\n\nYANG Description: Operational state data for the DNS resolver", "id": "f21932:c0:m5"}
{"signature": "def _set_host_entries(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=host_entries.host_entries,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__host_entries = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for host_entries, mapped from YANG variable /system/dns/host_entries (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_host_entries is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_host_entries() directly.\n\nYANG Description: Enclosing container for list of static host entries", "id": "f21932:c0:m12"}
{"signature": "def _get_port(self):", "body": "return self.__port<EOL>", "docstring": "Getter method for port, mapped from YANG variable /system/dns/servers/server/state/port (inet:port-number)\n\n    YANG Description: [adapted from IETF system model RFC 7317]\n\nThe port number of the DNS server.", "id": "f21933:c0:m5"}
{"signature": "def _set_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:address>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for address, mapped from YANG variable /system/dns/servers/server/config/address (inet:ip-address)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_address is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_address() directly.\n\n    YANG Description: [adapted from IETF system model RFC 7317]\n\nThe address of the DNS server, can be either IPv4\nor IPv6.", "id": "f21934:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /system/dns/servers/server/state (container)\n\nYANG Description: Operational state data for each DNS resolver", "id": "f21935:c0:m8"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /system/dns/servers/server/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration data for each DNS resolver", "id": "f21935:c0:m6"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /interfaces/interface/state/enabled (boolean)\n\n    YANG Description: [adapted from IETF interfaces model (RFC 7223)]\n\nThis leaf contains the configured, desired state of the\ninterface.\n\nSystems that implement the IF-MIB use the value of this\nleaf in the 'running' datastore to set\nIF-MIB.ifAdminStatus to 'up' or 'down' after an ifEntry\nhas been initialized, as described in RFC 2863.\n\nChanges in this leaf in the 'running' datastore are\nreflected in ifAdminStatus, but if ifAdminStatus is\nchanged over SNMP, this leaf is not affected.", "id": "f21937:c0:m14"}
{"signature": "def _set_oper_status(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:1>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:2>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:3>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:4>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:5>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:6>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:7>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__oper_status = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for oper_status, mapped from YANG variable /interfaces/interface/state/oper_status (enumeration)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_oper_status is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_oper_status() directly.\n\n    YANG Description: [adapted from IETF interfaces model (RFC 7223)]\n\nThe current operational state of the interface.\n\nThis leaf has the same semantics as ifOperStatus.", "id": "f21937:c0:m24"}
{"signature": "def _get_counters(self):", "body": "return self.__counters<EOL>", "docstring": "Getter method for counters, mapped from YANG variable /interfaces/interface/state/counters (container)\n\nYANG Description: A collection of interface-related statistics objects.", "id": "f21937:c0:m29"}
{"signature": "def _get_hardware_port(self):", "body": "return self.__hardware_port<EOL>", "docstring": "Getter method for hardware_port, mapped from YANG variable /interfaces/interface/state/hardware_port (leafref)\n\nYANG Description: References the hardware port in the device inventory", "id": "f21937:c0:m32"}
{"signature": "def _set_description(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:description>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__description = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for description, mapped from YANG variable /interfaces/interface/state/description (string)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_description is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_description() directly.\n\n    YANG Description: [adapted from IETF interfaces model (RFC 7223)]\n\nA textual description of the interface.\n\nA server implementation MAY map this leaf to the ifAlias\nMIB object.  Such an implementation needs to use some\nmechanism to handle the differences in size and characters\nallowed between this leaf and ifAlias.  The definition of\nsuch a mechanism is outside the scope of this document.\n\nSince ifAlias is defined to be stored in non-volatile\nstorage, the MIB implementation MUST map ifAlias to the\nvalue of 'description' in the persistently stored\ndatastore.\n\nSpecifically, if the device supports ':startup', when\nifAlias is read the device MUST return the value of\n'description' in the 'startup' datastore, and when it is\nwritten, it MUST be written to the 'running' and 'startup'\ndatastores.  Note that it is up to the implementation to\n\ndecide whether to modify this single leaf in 'startup' or\nperform an implicit copy-config from 'running' to\n'startup'.\n\nIf the device does not support ':startup', ifAlias MUST\nbe mapped to the 'description' leaf in the 'running'\ndatastore.", "id": "f21937:c0:m12"}
{"signature": "def _set_counters(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=counters.counters,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__counters = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for counters, mapped from YANG variable /interfaces/interface/state/counters (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_counters is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_counters() directly.\n\nYANG Description: A collection of interface-related statistics objects.", "id": "f21937:c0:m30"}
{"signature": "def _get_name(self):", "body": "return self.__name<EOL>", "docstring": "Getter method for name, mapped from YANG variable /interfaces/interface/state/name (string)\n\n    YANG Description: [adapted from IETF interfaces model (RFC 7223)]\n\nThe name of the interface.\n\nA device MAY restrict the allowed values for this leaf,\npossibly depending on the type of the interface.\nFor system-controlled interfaces, this leaf is the\ndevice-specific name of the interface.  The 'config false'\nlist interfaces/interface[name]/state contains the currently\nexisting interfaces on the device.\n\nIf a client tries to create configuration for a\nsystem-controlled interface that is not present in the\ncorresponding state list, the server MAY reject\nthe request if the implementation does not support\npre-provisioning of interfaces or if the name refers to\nan interface that can never exist in the system.  A\nNETCONF server MUST reply with an rpc-error with the\nerror-tag 'invalid-value' in this case.\n\nThe IETF model in RFC 7223 provides YANG features for the\nfollowing (i.e., pre-provisioning and arbitrary-names),\nhowever they are omitted here:\n\n If the device supports pre-provisioning of interface\n configuration, the 'pre-provisioning' feature is\n advertised.\n\n If the device allows arbitrarily named user-controlled\n interfaces, the 'arbitrary-names' feature is advertised.\n\nWhen a configured user-controlled interface is created by\nthe system, it is instantiated with the same name in the\n/interfaces/interface[name]/state list.", "id": "f21937:c0:m8"}
{"signature": "def _get_oper_status(self):", "body": "return self.__oper_status<EOL>", "docstring": "Getter method for oper_status, mapped from YANG variable /interfaces/interface/state/oper_status (enumeration)\n\n    YANG Description: [adapted from IETF interfaces model (RFC 7223)]\n\nThe current operational state of the interface.\n\nThis leaf has the same semantics as ifOperStatus.", "id": "f21937:c0:m23"}
{"signature": "def _set_admin_status(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__admin_status = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for admin_status, mapped from YANG variable /interfaces/interface/state/admin_status (enumeration)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_admin_status is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_admin_status() directly.\n\n    YANG Description: [adapted from IETF interfaces model (RFC 7223)]\n\nThe desired state of the interface.  In RFC 7223 this leaf\nhas the same read semantics as ifAdminStatus.  Here, it\nreflects the administrative state as set by enabling or\ndisabling the interface.", "id": "f21937:c0:m21"}
{"signature": "def _set_out_errors(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__out_errors = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for out_errors, mapped from YANG variable /interfaces/interface/state/counters/out_errors (yang:counter64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_out_errors is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_out_errors() directly.\n\n    YANG Description: [adapted from IETF interfaces model (RFC 7223)]\nChanged the counter type to counter64.\n\nFor packet-oriented interfaces, the number of outbound\npackets that could not be transmitted because of errors.\nFor character-oriented or fixed-length interfaces, the\nnumber of outbound transmission units that could not be\ntransmitted because of errors.\n\nDiscontinuities in the value of this counter can occur\nat re-initialization of the management system, and at\nother times as indicated by the value of\n'discontinuity-time'.", "id": "f21938:c0:m39"}
{"signature": "def _get_in_errors(self):", "body": "return self.__in_errors<EOL>", "docstring": "Getter method for in_errors, mapped from YANG variable /interfaces/interface/state/counters/in_errors (yang:counter64)\n\n    YANG Description: [adapted from IETF interfaces model (RFC 7223)]\nChanged the counter type to counter64.\n\nFor packet-oriented interfaces, the number of inbound\npackets that contained errors preventing them from being\ndeliverable to a higher-layer protocol.  For character-\noriented or fixed-length interfaces, the number of\ninbound transmission units that contained errors\npreventing them from being deliverable to a higher-layer\nprotocol.\n\nDiscontinuities in the value of this counter can occur\nat re-initialization of the management system, and at\nother times as indicated by the value of\n'discontinuity-time'.", "id": "f21938:c0:m17"}
{"signature": "def _set_in_unknown_protos(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__in_unknown_protos = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for in_unknown_protos, mapped from YANG variable /interfaces/interface/state/counters/in_unknown_protos (yang:counter32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_in_unknown_protos is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_in_unknown_protos() directly.\n\n    YANG Description: [adapted from IETF interfaces model (RFC 7223)]\nChanged the counter type to counter64.\n\nFor packet-oriented interfaces, the number of packets\nreceived via the interface that were discarded because\nof an unknown or unsupported protocol.  For\ncharacter-oriented or fixed-length interfaces that\nsupport protocol multiplexing, the number of\ntransmission units received via the interface that were\ndiscarded because of an unknown or unsupported protocol.\nFor any interface that does not support protocol\nmultiplexing, this counter is not present.\n\nDiscontinuities in the value of this counter can occur\nat re-initialization of the management system, and at\nother times as indicated by the value of\n'discontinuity-time'.", "id": "f21938:c0:m21"}
{"signature": "def _set_out_multicast_pkts(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__out_multicast_pkts = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for out_multicast_pkts, mapped from YANG variable /interfaces/interface/state/counters/out_multicast_pkts (yang:counter64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_out_multicast_pkts is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_out_multicast_pkts() directly.\n\n    YANG Description: [adapted from IETF interfaces model (RFC 7223)]\nChanged the counter type to counter64.\n\nThe total number of packets that higher-level protocols\nrequested be transmitted, and that were addressed to a\nmulticast address at this sub-layer, including those\nthat were discarded or not sent.  For a MAC-layer\nprotocol, this includes both Group and Functional\naddresses.\n\nDiscontinuities in the value of this counter can occur\nat re-initialization of the management system, and at\nother times as indicated by the value of\n'discontinuity-time'.", "id": "f21938:c0:m33"}
{"signature": "def _get_out_octets(self):", "body": "return self.__out_octets<EOL>", "docstring": "Getter method for out_octets, mapped from YANG variable /interfaces/interface/state/counters/out_octets (yang:counter64)\n\n    YANG Description: [adapted from IETF interfaces model (RFC 7223)]\nChanged the counter type to counter64.\n\nThe total number of octets transmitted out of the\ninterface, including framing characters.\n\nDiscontinuities in the value of this counter can occur\nat re-initialization of the management system, and at\nother times as indicated by the value of\n'discontinuity-time'.", "id": "f21938:c0:m23"}
{"signature": "def _get_out_errors(self):", "body": "return self.__out_errors<EOL>", "docstring": "Getter method for out_errors, mapped from YANG variable /interfaces/interface/state/counters/out_errors (yang:counter64)\n\n    YANG Description: [adapted from IETF interfaces model (RFC 7223)]\nChanged the counter type to counter64.\n\nFor packet-oriented interfaces, the number of outbound\npackets that could not be transmitted because of errors.\nFor character-oriented or fixed-length interfaces, the\nnumber of outbound transmission units that could not be\ntransmitted because of errors.\n\nDiscontinuities in the value of this counter can occur\nat re-initialization of the management system, and at\nother times as indicated by the value of\n'discontinuity-time'.", "id": "f21938:c0:m38"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/vlan/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State variables for VLANs", "id": "f21941:c0:m6"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/vlan/config (container)\n\nYANG Description: Configuration parameters for VLANs", "id": "f21941:c0:m2"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:true>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/state/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: Controls whether IPv4 is enabled or disabled on this\ninterface.  When IPv4 is enabled, this interface is\nconnected to an IPv4 stack, and the interface can send\nand receive IPv4 packets.", "id": "f21942:c0:m3"}
{"signature": "def _get_link_layer_address(self):", "body": "return self.__link_layer_address<EOL>", "docstring": "Getter method for link_layer_address, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/neighbors/neighbor/state/link_layer_address (yang:phys-address)\n\nYANG Description: The link-layer address of the neighbor node.", "id": "f21943:c0:m5"}
{"signature": "def _set_link_layer_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__link_layer_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for link_layer_address, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/neighbors/neighbor/state/link_layer_address (yang:phys-address)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_link_layer_address is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_link_layer_address() directly.\n\nYANG Description: The link-layer address of the neighbor node.", "id": "f21943:c0:m6"}
{"signature": "def _set_ip(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ip = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ip, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/neighbors/neighbor/state/ip (inet:ipv4-address-no-zone)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ip is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ip() directly.\n\nYANG Description: The IPv4 address of the neighbor node.", "id": "f21943:c0:m3"}
{"signature": "def _get_ip(self):", "body": "return self.__ip<EOL>", "docstring": "Getter method for ip, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/neighbors/neighbor/ip (leafref)\n\nYANG Description: References the configured IP address", "id": "f21945:c0:m2"}
{"signature": "def _set_neighbor(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>neighbor.neighbor,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__neighbor = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for neighbor, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/neighbors/neighbor (list)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_neighbor is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_neighbor() directly.\n\n    YANG Description: A list of mappings from IPv4 addresses to\nlink-layer addresses.\n\nEntries in this list are used as static entries in the\nARP Cache.", "id": "f21946:c0:m3"}
{"signature": "def _get_mtu(self):", "body": "return self.__mtu<EOL>", "docstring": "Getter method for mtu, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/config/mtu (uint16)\n\n    YANG Description: The size, in octets, of the largest IPv4 packet that the\ninterface will send and receive.\n\nThe server may restrict the allowed values for this leaf,\ndepending on the interface's type.\n\nIf this leaf is not configured, the operationally used MTU\ndepends on the interface's type.", "id": "f21947:c0:m5"}
{"signature": "def _set_ip(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ip = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ip, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/addresses/address/state/ip (inet:ipv4-address-no-zone)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_ip is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_ip() directly.\n\n    YANG Description: [adapted from IETF IP model RFC 7277]\n\nThe IPv4 address on the interface.", "id": "f21948:c0:m3"}
{"signature": "def _get_prefix_length(self):", "body": "return self.__prefix_length<EOL>", "docstring": "Getter method for prefix_length, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/addresses/address/state/prefix_length (uint8)\n\n    YANG Description: [adapted from IETF IP model RFC 7277]\n\nThe length of the subnet prefix.", "id": "f21948:c0:m5"}
{"signature": "def _set_secondary(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__secondary = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for secondary, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/addresses/address/config/secondary (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_secondary is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_secondary() directly.\n\n    YANG Description: Most platforms need a secondary statement on when configuring multiple IPv4 addresses\non the same interfaces", "id": "f21949:c0:m9"}
{"signature": "def _get_secondary(self):", "body": "return self.__secondary<EOL>", "docstring": "Getter method for secondary, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/addresses/address/config/secondary (boolean)\n\n    YANG Description: Most platforms need a secondary statement on when configuring multiple IPv4 addresses\non the same interfaces", "id": "f21949:c0:m8"}
{"signature": "def _set_prefix_length(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prefix_length = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prefix_length, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/addresses/address/config/prefix_length (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prefix_length is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prefix_length() directly.\n\n    YANG Description: [adapted from IETF IP model RFC 7277]\n\nThe length of the subnet prefix.", "id": "f21949:c0:m6"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/addresses/address/config (container)\n\n    YANG Description: Configuration data for each configured IPv4\naddress on the interface", "id": "f21950:c0:m5"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/addresses/address/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration data for each configured IPv4\naddress on the interface", "id": "f21950:c0:m6"}
{"signature": "def _get_vrrp_group(self):", "body": "return self.__vrrp_group<EOL>", "docstring": "Getter method for vrrp_group, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/addresses/address/vrrp/vrrp_group (list)\n\nYANG Description: List of VRRP groups, keyed by virtual router id", "id": "f21951:c0:m2"}
{"signature": "def _get_virtual_router_id(self):", "body": "return self.__virtual_router_id<EOL>", "docstring": "Getter method for virtual_router_id, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/addresses/address/vrrp/vrrp_group/state/virtual_router_id (uint8)\n\n    YANG Description: Set the virtual router id for use by the VRRP group.  This\nusually also determines the virtual MAC address that is\ngenerated for the VRRP group", "id": "f21952:c0:m2"}
{"signature": "def _get_priority(self):", "body": "return self.__priority<EOL>", "docstring": "Getter method for priority, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/addresses/address/vrrp/vrrp_group/state/priority (uint8)\n\n    YANG Description: Specifies the sending VRRP interface's priority\nfor the virtual router.  Higher values equal higher\npriority", "id": "f21952:c0:m8"}
{"signature": "def _set_priority(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>default=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>)(<EOL><NUM_LIT:100><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__priority = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for priority, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/addresses/address/vrrp/vrrp_group/state/priority (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_priority is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_priority() directly.\n\n    YANG Description: Specifies the sending VRRP interface's priority\nfor the virtual router.  Higher values equal higher\npriority", "id": "f21952:c0:m9"}
{"signature": "def _set_current_priority(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__current_priority = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for current_priority, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/addresses/address/vrrp/vrrp_group/state/current_priority (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_current_priority is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_current_priority() directly.\n\n    YANG Description: Operational value of the priority for the\ninterface in the VRRP group", "id": "f21952:c0:m24"}
{"signature": "def _set_advertisement_interval(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:16>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>default=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>)(<EOL><NUM_LIT:100><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__advertisement_interval = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for advertisement_interval, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/addresses/address/vrrp/vrrp_group/state/advertisement_interval (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_advertisement_interval is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_advertisement_interval() directly.\n\n    YANG Description: Sets the interval between successive VRRP\nadvertisements -- RFC 5798 defines this as a 12-bit\nvalue expressed as 0.1 seconds, with default 100, i.e.,\n1 second.  Several implementation express this in units of\nseconds", "id": "f21952:c0:m21"}
{"signature": "def _get_preempt(self):", "body": "return self.__preempt<EOL>", "docstring": "Getter method for preempt, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/addresses/address/vrrp/vrrp_group/state/preempt (boolean)\n\n    YANG Description: When set to true, enables preemption by a higher\npriority backup router of a lower priority master router", "id": "f21952:c0:m11"}
{"signature": "def _set_preempt_delay(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:16>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>default=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>)(<EOL><NUM_LIT:0><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__preempt_delay = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for preempt_delay, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/addresses/address/vrrp/vrrp_group/state/preempt_delay (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_preempt_delay is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_preempt_delay() directly.\n\n    YANG Description: Set the delay the higher priority router waits\nbefore preempting", "id": "f21952:c0:m15"}
{"signature": "def _set_accept_mode(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__accept_mode = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for accept_mode, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/addresses/address/vrrp/vrrp_group/config/accept_mode (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_accept_mode is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_accept_mode() directly.\n\n    YANG Description: Configure whether packets destined for\nvirtual addresses are accepted even when the virtual\naddress is not owned by the router interface", "id": "f21953:c0:m18"}
{"signature": "def _get_preempt(self):", "body": "return self.__preempt<EOL>", "docstring": "Getter method for preempt, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/addresses/address/vrrp/vrrp_group/config/preempt (boolean)\n\n    YANG Description: When set to true, enables preemption by a higher\npriority backup router of a lower priority master router", "id": "f21953:c0:m11"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/addresses/address/vrrp/vrrp_group/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Operational state data for the VRRP group", "id": "f21954:c0:m9"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/addresses/address/vrrp/vrrp_group/config (container)\n\nYANG Description: Configuration data for the VRRP group", "id": "f21954:c0:m5"}
{"signature": "def _set_interface_tracking(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=interface_tracking.interface_tracking,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface_tracking = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface_tracking, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/addresses/address/vrrp/vrrp_group/interface_tracking (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_interface_tracking is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_interface_tracking() directly.\n\nYANG Description: Top-level container for VRRP interface tracking", "id": "f21954:c0:m12"}
{"signature": "def _set_track_interface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__track_interface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for track_interface, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/addresses/address/vrrp/vrrp_group/interface_tracking/state/track_interface (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_track_interface is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_track_interface() directly.\n\n    YANG Description: Sets an interface that should be\ntracked for up/down events to dynamically change the\npriority state of the VRRP group, and potentially\nchange the mastership if the tracked interface going\ndown lowers the priority sufficiently", "id": "f21955:c0:m3"}
{"signature": "def _set_track_interface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__track_interface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for track_interface, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/addresses/address/vrrp/vrrp_group/interface_tracking/config/track_interface (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_track_interface is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_track_interface() directly.\n\n    YANG Description: Sets an interface that should be\ntracked for up/down events to dynamically change the\npriority state of the VRRP group, and potentially\nchange the mastership if the tracked interface going\ndown lowers the priority sufficiently", "id": "f21956:c0:m3"}
{"signature": "def _get_priority_decrement(self):", "body": "return self.__priority_decrement<EOL>", "docstring": "Getter method for priority_decrement, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/addresses/address/vrrp/vrrp_group/interface_tracking/config/priority_decrement (uint8)\n\n    YANG Description: Set the value to subtract from priority when\nthe tracked interface goes down", "id": "f21956:c0:m5"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/addresses/address/vrrp/vrrp_group/interface_tracking/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration data for VRRP interface tracking", "id": "f21957:c0:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/addresses/address/vrrp/vrrp_group/interface_tracking/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Operational state data for VRRP interface tracking", "id": "f21957:c0:m6"}
{"signature": "def _set_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>address.address,<EOL>yang_name=\"<STR_LIT:address>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT:address>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for address, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/addresses/address (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_address is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_address() directly.\n\nYANG Description: The list of configured IPv4 addresses on the interface.", "id": "f21958:c0:m3"}
{"signature": "def _get_neighbors(self):", "body": "return self.__neighbors<EOL>", "docstring": "Getter method for neighbors, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/neighbors (container)\n\nYANG Description: Enclosing container for neighbor list", "id": "f21959:c0:m5"}
{"signature": "def _set_neighbors(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=neighbors.neighbors,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__neighbors = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for neighbors, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/neighbors (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_neighbors is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_neighbors() directly.\n\nYANG Description: Enclosing container for neighbor list", "id": "f21959:c0:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/state (container)\n\nYANG Description: Top level IPv4 operational state data", "id": "f21959:c0:m14"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Top-level IPv4 configuration data for the interface", "id": "f21959:c0:m12"}
{"signature": "def _set_addresses(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=addresses.addresses,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__addresses = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for addresses, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/addresses (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_addresses is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_addresses() directly.\n\nYANG Description: Enclosing container for address list", "id": "f21959:c0:m3"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/unnumbered/state/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: Indicates that the subinterface is unnumbered.  By default\nthe subinterface is numbered, i.e., expected to have an\nIP address configuration.", "id": "f21960:c0:m3"}
{"signature": "def _set_subinterface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subinterface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subinterface, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/unnumbered/interface_ref/state/subinterface (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subinterface is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subinterface() directly.\n\n    YANG Description: Reference to a subinterface -- this requires the base\ninterface to be specified using the interface leaf in\nthis container.  If only a reference to a base interface\nis requuired, this leaf should not be set.", "id": "f21962:c0:m6"}
{"signature": "def _get_subinterface(self):", "body": "return self.__subinterface<EOL>", "docstring": "Getter method for subinterface, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/unnumbered/interface_ref/config/subinterface (leafref)\n\n    YANG Description: Reference to a subinterface -- this requires the base\ninterface to be specified using the interface leaf in\nthis container.  If only a reference to a base interface\nis requuired, this leaf should not be set.", "id": "f21963:c0:m5"}
{"signature": "def _get_interface(self):", "body": "return self.__interface<EOL>", "docstring": "Getter method for interface, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/unnumbered/interface_ref/config/interface (leafref)\n\n    YANG Description: Reference to a base interface.  If a reference to a\nsubinterface is required, this leaf must be specified\nto indicate the base interface.", "id": "f21963:c0:m2"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/unnumbered/interface_ref/config (container)\n\nYANG Description: Configured reference to interface / subinterface", "id": "f21964:c0:m2"}
{"signature": "def _get_interface_ref(self):", "body": "return self.__interface_ref<EOL>", "docstring": "Getter method for interface_ref, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/unnumbered/interface_ref (container)\n\nYANG Description: Reference to an interface or subinterface", "id": "f21965:c0:m8"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/unnumbered/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Operational state data for unnumbered interfaces", "id": "f21965:c0:m6"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/unnumbered/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration data for unnumbered interface", "id": "f21965:c0:m3"}
{"signature": "def _set_interface_ref(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=interface_ref.interface_ref,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface_ref = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface_ref, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4/unnumbered/interface_ref (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_interface_ref is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_interface_ref() directly.\n\nYANG Description: Reference to an interface or subinterface", "id": "f21965:c0:m9"}
{"signature": "def _get_name(self):", "body": "return self.__name<EOL>", "docstring": "Getter method for name, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/state/name (string)\n\n    YANG Description: [adapted from IETF interfaces model (RFC 7223)]\n\nThe name of the interface.\n\nA device MAY restrict the allowed values for this leaf,\npossibly depending on the type of the interface.\nFor system-controlled interfaces, this leaf is the\ndevice-specific name of the interface.  The 'config false'\nlist interfaces/interface[name]/state contains the currently\nexisting interfaces on the device.\n\nIf a client tries to create configuration for a\nsystem-controlled interface that is not present in the\ncorresponding state list, the server MAY reject\nthe request if the implementation does not support\npre-provisioning of interfaces or if the name refers to\nan interface that can never exist in the system.  A\nNETCONF server MUST reply with an rpc-error with the\nerror-tag 'invalid-value' in this case.\n\nThe IETF model in RFC 7223 provides YANG features for the\nfollowing (i.e., pre-provisioning and arbitrary-names),\nhowever they are omitted here:\n\n If the device supports pre-provisioning of interface\n configuration, the 'pre-provisioning' feature is\n advertised.\n\n If the device allows arbitrarily named user-controlled\n interfaces, the 'arbitrary-names' feature is advertised.\n\nWhen a configured user-controlled interface is created by\nthe system, it is instantiated with the same name in the\n/interfaces/interface[name]/state list.", "id": "f21966:c0:m5"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/state/enabled (boolean)\n\n    YANG Description: [adapted from IETF interfaces model (RFC 7223)]\n\nThis leaf contains the configured, desired state of the\ninterface.\n\nSystems that implement the IF-MIB use the value of this\nleaf in the 'running' datastore to set\nIF-MIB.ifAdminStatus to 'up' or 'down' after an ifEntry\nhas been initialized, as described in RFC 2863.\n\nChanges in this leaf in the 'running' datastore are\nreflected in ifAdminStatus, but if ifAdminStatus is\nchanged over SNMP, this leaf is not affected.", "id": "f21966:c0:m11"}
{"signature": "def _get_description(self):", "body": "return self.__description<EOL>", "docstring": "Getter method for description, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/state/description (string)\n\n    YANG Description: [adapted from IETF interfaces model (RFC 7223)]\n\nA textual description of the interface.\n\nA server implementation MAY map this leaf to the ifAlias\nMIB object.  Such an implementation needs to use some\nmechanism to handle the differences in size and characters\nallowed between this leaf and ifAlias.  The definition of\nsuch a mechanism is outside the scope of this document.\n\nSince ifAlias is defined to be stored in non-volatile\nstorage, the MIB implementation MUST map ifAlias to the\nvalue of 'description' in the persistently stored\ndatastore.\n\nSpecifically, if the device supports ':startup', when\nifAlias is read the device MUST return the value of\n'description' in the 'startup' datastore, and when it is\nwritten, it MUST be written to the 'running' and 'startup'\ndatastores.  Note that it is up to the implementation to\n\ndecide whether to modify this single leaf in 'startup' or\nperform an implicit copy-config from 'running' to\n'startup'.\n\nIf the device does not support ':startup', ifAlias MUST\nbe mapped to the 'description' leaf in the 'running'\ndatastore.", "id": "f21966:c0:m8"}
{"signature": "def _set_description(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:description>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__description = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for description, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/state/description (string)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_description is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_description() directly.\n\n    YANG Description: [adapted from IETF interfaces model (RFC 7223)]\n\nA textual description of the interface.\n\nA server implementation MAY map this leaf to the ifAlias\nMIB object.  Such an implementation needs to use some\nmechanism to handle the differences in size and characters\nallowed between this leaf and ifAlias.  The definition of\nsuch a mechanism is outside the scope of this document.\n\nSince ifAlias is defined to be stored in non-volatile\nstorage, the MIB implementation MUST map ifAlias to the\nvalue of 'description' in the persistently stored\ndatastore.\n\nSpecifically, if the device supports ':startup', when\nifAlias is read the device MUST return the value of\n'description' in the 'startup' datastore, and when it is\nwritten, it MUST be written to the 'running' and 'startup'\ndatastores.  Note that it is up to the implementation to\n\ndecide whether to modify this single leaf in 'startup' or\nperform an implicit copy-config from 'running' to\n'startup'.\n\nIf the device does not support ':startup', ifAlias MUST\nbe mapped to the 'description' leaf in the 'running'\ndatastore.", "id": "f21966:c0:m9"}
{"signature": "def _get_index(self):", "body": "return self.__index<EOL>", "docstring": "Getter method for index, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/state/index (uint32)\n\n    YANG Description: The index of the subinterface, or logical interface number.\nOn systems with no support for subinterfaces, or not using\nsubinterfaces, this value should default to 0, i.e., the\ndefault subinterface.", "id": "f21966:c0:m2"}
{"signature": "def _get_admin_status(self):", "body": "return self.__admin_status<EOL>", "docstring": "Getter method for admin_status, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/state/admin_status (enumeration)\n\n    YANG Description: [adapted from IETF interfaces model (RFC 7223)]\n\nThe desired state of the interface.  In RFC 7223 this leaf\nhas the same read semantics as ifAdminStatus.  Here, it\nreflects the administrative state as set by enabling or\ndisabling the interface.", "id": "f21966:c0:m17"}
{"signature": "def _get_last_change(self):", "body": "return self.__last_change<EOL>", "docstring": "Getter method for last_change, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/state/last_change (yang:timeticks)\n\n    YANG Description: Date and time of the last state change of the interface\n(e.g., up-to-down transition).   This corresponds to the\nifLastChange object in the standard interface MIB.", "id": "f21966:c0:m23"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:true>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/state/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: [adapted from IETF interfaces model (RFC 7223)]\n\nThis leaf contains the configured, desired state of the\ninterface.\n\nSystems that implement the IF-MIB use the value of this\nleaf in the 'running' datastore to set\nIF-MIB.ifAdminStatus to 'up' or 'down' after an ifEntry\nhas been initialized, as described in RFC 2863.\n\nChanges in this leaf in the 'running' datastore are\nreflected in ifAdminStatus, but if ifAdminStatus is\nchanged over SNMP, this leaf is not affected.", "id": "f21966:c0:m12"}
{"signature": "def _get_out_errors(self):", "body": "return self.__out_errors<EOL>", "docstring": "Getter method for out_errors, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/state/counters/out_errors (yang:counter64)\n\n    YANG Description: [adapted from IETF interfaces model (RFC 7223)]\nChanged the counter type to counter64.\n\nFor packet-oriented interfaces, the number of outbound\npackets that could not be transmitted because of errors.\nFor character-oriented or fixed-length interfaces, the\nnumber of outbound transmission units that could not be\ntransmitted because of errors.\n\nDiscontinuities in the value of this counter can occur\nat re-initialization of the management system, and at\nother times as indicated by the value of\n'discontinuity-time'.", "id": "f21967:c0:m38"}
{"signature": "def _set_in_discards(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__in_discards = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for in_discards, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/state/counters/in_discards (yang:counter64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_in_discards is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_in_discards() directly.\n\n    YANG Description: [adapted from IETF interfaces model (RFC 7223)]\nChanged the counter type to counter64.\n\nThe number of inbound packets that were chosen to be\ndiscarded even though no errors had been detected to\nprevent their being deliverable to a higher-layer\nprotocol.  One possible reason for discarding such a\npacket could be to free up buffer space.\n\nDiscontinuities in the value of this counter can occur\nat re-initialization of the management system, and at\nother times as indicated by the value of\n'discontinuity-time'.", "id": "f21967:c0:m15"}
{"signature": "def _get_in_octets(self):", "body": "return self.__in_octets<EOL>", "docstring": "Getter method for in_octets, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/state/counters/in_octets (yang:counter64)\n\n    YANG Description: [adapted from IETF interfaces model (RFC 7223)]\n\nThe total number of octets received on the interface,\nincluding framing characters.\n\nDiscontinuities in the value of this counter can occur\nat re-initialization of the management system, and at\nother times as indicated by the value of\n'discontinuity-time'.", "id": "f21967:c0:m2"}
{"signature": "def _get_in_unicast_pkts(self):", "body": "return self.__in_unicast_pkts<EOL>", "docstring": "Getter method for in_unicast_pkts, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/state/counters/in_unicast_pkts (yang:counter64)\n\n    YANG Description: [adapted from IETF interfaces model (RFC 7223)]\n\nThe number of packets, delivered by this sub-layer to a\nhigher (sub-)layer, that were not addressed to a\nmulticast or broadcast address at this sub-layer.\n\nDiscontinuities in the value of this counter can occur\nat re-initialization of the management system, and at\nother times as indicated by the value of\n'discontinuity-time'.", "id": "f21967:c0:m5"}
{"signature": "def _get_in_multicast_pkts(self):", "body": "return self.__in_multicast_pkts<EOL>", "docstring": "Getter method for in_multicast_pkts, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/state/counters/in_multicast_pkts (yang:counter64)\n\n    YANG Description: [adapted from IETF interfaces model (RFC 7223)]\n\n\nThe number of packets, delivered by this sub-layer to a\nhigher (sub-)layer, that were addressed to a multicast\naddress at this sub-layer.  For a MAC-layer protocol,\nthis includes both Group and Functional addresses.\n\nDiscontinuities in the value of this counter can occur\nat re-initialization of the management system, and at\nother times as indicated by the value of\n'discontinuity-time'.", "id": "f21967:c0:m11"}
{"signature": "def _set_description(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:description>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__description = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for description, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/config/description (string)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_description is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_description() directly.\n\n    YANG Description: [adapted from IETF interfaces model (RFC 7223)]\n\nA textual description of the interface.\n\nA server implementation MAY map this leaf to the ifAlias\nMIB object.  Such an implementation needs to use some\nmechanism to handle the differences in size and characters\nallowed between this leaf and ifAlias.  The definition of\nsuch a mechanism is outside the scope of this document.\n\nSince ifAlias is defined to be stored in non-volatile\nstorage, the MIB implementation MUST map ifAlias to the\nvalue of 'description' in the persistently stored\ndatastore.\n\nSpecifically, if the device supports ':startup', when\nifAlias is read the device MUST return the value of\n'description' in the 'startup' datastore, and when it is\nwritten, it MUST be written to the 'running' and 'startup'\ndatastores.  Note that it is up to the implementation to\n\ndecide whether to modify this single leaf in 'startup' or\nperform an implicit copy-config from 'running' to\n'startup'.\n\nIf the device does not support ':startup', ifAlias MUST\nbe mapped to the 'description' leaf in the 'running'\ndatastore.", "id": "f21968:c0:m9"}
{"signature": "def _get_name(self):", "body": "return self.__name<EOL>", "docstring": "Getter method for name, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/config/name (string)\n\n    YANG Description: [adapted from IETF interfaces model (RFC 7223)]\n\nThe name of the interface.\n\nA device MAY restrict the allowed values for this leaf,\npossibly depending on the type of the interface.\nFor system-controlled interfaces, this leaf is the\ndevice-specific name of the interface.  The 'config false'\nlist interfaces/interface[name]/state contains the currently\nexisting interfaces on the device.\n\nIf a client tries to create configuration for a\nsystem-controlled interface that is not present in the\ncorresponding state list, the server MAY reject\nthe request if the implementation does not support\npre-provisioning of interfaces or if the name refers to\nan interface that can never exist in the system.  A\nNETCONF server MUST reply with an rpc-error with the\nerror-tag 'invalid-value' in this case.\n\nThe IETF model in RFC 7223 provides YANG features for the\nfollowing (i.e., pre-provisioning and arbitrary-names),\nhowever they are omitted here:\n\n If the device supports pre-provisioning of interface\n configuration, the 'pre-provisioning' feature is\n advertised.\n\n If the device allows arbitrarily named user-controlled\n interfaces, the 'arbitrary-names' feature is advertised.\n\nWhen a configured user-controlled interface is created by\nthe system, it is instantiated with the same name in the\n/interfaces/interface[name]/state list.", "id": "f21968:c0:m5"}
{"signature": "def _get_create_temporary_addresses(self):", "body": "return self.__create_temporary_addresses<EOL>", "docstring": "Getter method for create_temporary_addresses, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/autoconf/config/create_temporary_addresses (boolean)\n\n    YANG Description: [adapted from IETF IP model RFC 7277]\n\nIf enabled, the host creates temporary addresses as\ndescribed in RFC 4941.", "id": "f21970:c0:m5"}
{"signature": "def _set_temporary_valid_lifetime(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>default=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>)(<EOL><NUM_LIT><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__temporary_valid_lifetime = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for temporary_valid_lifetime, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/autoconf/config/temporary_valid_lifetime (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_temporary_valid_lifetime is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_temporary_valid_lifetime() directly.\n\n    YANG Description: [adapted from IETF IP model RFC 7277]\n\nThe time period during which the temporary address\nis valid.", "id": "f21970:c0:m9"}
{"signature": "def _get_temporary_valid_lifetime(self):", "body": "return self.__temporary_valid_lifetime<EOL>", "docstring": "Getter method for temporary_valid_lifetime, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/autoconf/config/temporary_valid_lifetime (uint32)\n\n    YANG Description: [adapted from IETF IP model RFC 7277]\n\nThe time period during which the temporary address\nis valid.", "id": "f21970:c0:m8"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/autoconf/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: [adapted from IETF IP model RFC 7277]\n\nParameters to control the autoconfiguration of IPv6\naddresses, as described in RFC 4862.", "id": "f21971:c0:m3"}
{"signature": "def _set_mtu(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__mtu = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for mtu, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/state/mtu (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_mtu is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_mtu() directly.\n\n    YANG Description: [adapted from IETF IP model RFC 7277]\n\nThe size, in octets, of the largest IPv6 packet that the\ninterface will send and receive.\n\nThe server may restrict the allowed values for this leaf,\ndepending on the interface's type.\n\nIf this leaf is not configured, the operationally used MTU\ndepends on the interface's type.", "id": "f21972:c0:m6"}
{"signature": "def _get_is_router(self):", "body": "return self.__is_router<EOL>", "docstring": "Getter method for is_router, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/neighbors/neighbor/state/is_router (empty)\n\n    YANG Description: [adapted from IETF IP model RFC 7277]\n\nIndicates that the neighbor node acts as a router.", "id": "f21973:c0:m11"}
{"signature": "def _get_link_layer_address(self):", "body": "return self.__link_layer_address<EOL>", "docstring": "Getter method for link_layer_address, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/neighbors/neighbor/state/link_layer_address (yang:phys-address)\n\n    YANG Description: [adapted from IETF IP model RFC 7277]\n\nThe link-layer address of the neighbor node.", "id": "f21973:c0:m5"}
{"signature": "def _set_link_layer_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__link_layer_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for link_layer_address, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/neighbors/neighbor/state/link_layer_address (yang:phys-address)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_link_layer_address is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_link_layer_address() directly.\n\n    YANG Description: [adapted from IETF IP model RFC 7277]\n\nThe link-layer address of the neighbor node.", "id": "f21973:c0:m6"}
{"signature": "def _get_origin(self):", "body": "return self.__origin<EOL>", "docstring": "Getter method for origin, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/neighbors/neighbor/state/origin (neighbor-origin)\n\n    YANG Description: [adapted from IETF IP model RFC 7277]\n\nThe origin of this neighbor entry.", "id": "f21973:c0:m8"}
{"signature": "def _get_neighbor_state(self):", "body": "return self.__neighbor_state<EOL>", "docstring": "Getter method for neighbor_state, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/neighbors/neighbor/state/neighbor_state (enumeration)\n\n    YANG Description: [adapted from IETF IP model RFC 7277]\n\nThe Neighbor Unreachability Detection state of this\nentry.", "id": "f21973:c0:m14"}
{"signature": "def _set_ip(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ip = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ip, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/neighbors/neighbor/config/ip (inet:ipv6-address-no-zone)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_ip is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_ip() directly.\n\n    YANG Description: [adapted from IETF IP model RFC 7277]\n\nThe IPv6 address of the neighbor node.", "id": "f21974:c0:m3"}
{"signature": "def _set_link_layer_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__link_layer_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for link_layer_address, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/neighbors/neighbor/config/link_layer_address (yang:phys-address)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_link_layer_address is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_link_layer_address() directly.\n\n    YANG Description: [adapted from IETF IP model RFC 7277]\n\nThe link-layer address of the neighbor node.", "id": "f21974:c0:m6"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/neighbors/neighbor/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration data for each IPv6 address on\nthe interface", "id": "f21975:c0:m6"}
{"signature": "def _get_ip(self):", "body": "return self.__ip<EOL>", "docstring": "Getter method for ip, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/neighbors/neighbor/ip (leafref)\n\nYANG Description: References the configured IP neighbor address", "id": "f21975:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/neighbors/neighbor/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: State data for each IPv6 address on the\ninterface", "id": "f21975:c0:m9"}
{"signature": "def _set_neighbor(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>neighbor.neighbor,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__neighbor = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for neighbor, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/neighbors/neighbor (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_neighbor is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_neighbor() directly.\n\nYANG Description: List of IPv6 neighbors", "id": "f21976:c0:m3"}
{"signature": "def _get_dup_addr_detect_transmits(self):", "body": "return self.__dup_addr_detect_transmits<EOL>", "docstring": "Getter method for dup_addr_detect_transmits, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/config/dup_addr_detect_transmits (uint32)\n\n    YANG Description: [adapted from IETF IP model RFC 7277]\n\nThe number of consecutive Neighbor Solicitation messages\nsent while performing Duplicate Address Detection on a\ntentative address.  A value of zero indicates that\nDuplicate Address Detection is not performed on\ntentative addresses.  A value of one indicates a single\ntransmission with no follow-up retransmissions.", "id": "f21977:c0:m8"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/config/enabled (boolean)\n\n    YANG Description: [adapted from IETF IP model RFC 7277]\n\nControls whether IPv6 is enabled or disabled on this\ninterface.  When IPv6 is enabled, this interface is\nconnected to an IPv6 stack, and the interface can send\nand receive IPv6 packets.", "id": "f21977:c0:m2"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:true>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/config/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: [adapted from IETF IP model RFC 7277]\n\nControls whether IPv6 is enabled or disabled on this\ninterface.  When IPv6 is enabled, this interface is\nconnected to an IPv6 stack, and the interface can send\nand receive IPv6 packets.", "id": "f21977:c0:m3"}
{"signature": "def _set_prefix_length(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prefix_length = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prefix_length, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/addresses/address/state/prefix_length (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prefix_length is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prefix_length() directly.\n\n    YANG Description: [adapted from IETF IP model RFC 7277]\n\nThe length of the subnet prefix.", "id": "f21978:c0:m6"}
{"signature": "def _get_prefix_length(self):", "body": "return self.__prefix_length<EOL>", "docstring": "Getter method for prefix_length, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/addresses/address/state/prefix_length (uint8)\n\n    YANG Description: [adapted from IETF IP model RFC 7277]\n\nThe length of the subnet prefix.", "id": "f21978:c0:m5"}
{"signature": "def _set_status(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:status>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__status = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for status, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/addresses/address/state/status (enumeration)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_status is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_status() directly.\n\n    YANG Description: [adapted from IETF IP model RFC 7277]\n\nThe status of an address.  Most of the states correspond\nto states from the IPv6 Stateless Address\nAutoconfiguration protocol.", "id": "f21978:c0:m12"}
{"signature": "def _get_ip(self):", "body": "return self.__ip<EOL>", "docstring": "Getter method for ip, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/addresses/address/ip (leafref)\n\nYANG Description: References the configured IP address", "id": "f21980:c0:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/addresses/address/state (container)\n\n    YANG Description: State data for each IPv6 address on the\ninterface", "id": "f21980:c0:m8"}
{"signature": "def _set_current_priority(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__current_priority = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for current_priority, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/addresses/address/vrrp/vrrp_group/state/current_priority (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_current_priority is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_current_priority() directly.\n\n    YANG Description: Operational value of the priority for the\ninterface in the VRRP group", "id": "f21982:c0:m24"}
{"signature": "def _set_preempt(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:true>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__preempt = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for preempt, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/addresses/address/vrrp/vrrp_group/state/preempt (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_preempt is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_preempt() directly.\n\n    YANG Description: When set to true, enables preemption by a higher\npriority backup router of a lower priority master router", "id": "f21982:c0:m12"}
{"signature": "def _set_virtual_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>]<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__virtual_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for virtual_address, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/addresses/address/vrrp/vrrp_group/state/virtual_address (inet:ip-address)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_virtual_address is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_virtual_address() directly.\n\n    YANG Description: Configure one or more virtual addresses for the\nVRRP group", "id": "f21982:c0:m6"}
{"signature": "def _set_virtual_router_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__virtual_router_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for virtual_router_id, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/addresses/address/vrrp/vrrp_group/state/virtual_router_id (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_virtual_router_id is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_virtual_router_id() directly.\n\n    YANG Description: Set the virtual router id for use by the VRRP group.  This\nusually also determines the virtual MAC address that is\ngenerated for the VRRP group", "id": "f21982:c0:m3"}
{"signature": "def _get_virtual_address(self):", "body": "return self.__virtual_address<EOL>", "docstring": "Getter method for virtual_address, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/addresses/address/vrrp/vrrp_group/state/virtual_address (inet:ip-address)\n\n    YANG Description: Configure one or more virtual addresses for the\nVRRP group", "id": "f21982:c0:m5"}
{"signature": "def _get_virtual_router_id(self):", "body": "return self.__virtual_router_id<EOL>", "docstring": "Getter method for virtual_router_id, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/addresses/address/vrrp/vrrp_group/state/virtual_router_id (uint8)\n\n    YANG Description: Set the virtual router id for use by the VRRP group.  This\nusually also determines the virtual MAC address that is\ngenerated for the VRRP group", "id": "f21982:c0:m2"}
{"signature": "def _get_preempt(self):", "body": "return self.__preempt<EOL>", "docstring": "Getter method for preempt, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/addresses/address/vrrp/vrrp_group/state/preempt (boolean)\n\n    YANG Description: When set to true, enables preemption by a higher\npriority backup router of a lower priority master router", "id": "f21982:c0:m11"}
{"signature": "def _get_virtual_address(self):", "body": "return self.__virtual_address<EOL>", "docstring": "Getter method for virtual_address, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/addresses/address/vrrp/vrrp_group/config/virtual_address (inet:ip-address)\n\n    YANG Description: Configure one or more virtual addresses for the\nVRRP group", "id": "f21983:c0:m5"}
{"signature": "def _set_preempt_delay(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:16>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>default=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>)(<EOL><NUM_LIT:0><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__preempt_delay = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for preempt_delay, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/addresses/address/vrrp/vrrp_group/config/preempt_delay (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_preempt_delay is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_preempt_delay() directly.\n\n    YANG Description: Set the delay the higher priority router waits\nbefore preempting", "id": "f21983:c0:m15"}
{"signature": "def _get_accept_mode(self):", "body": "return self.__accept_mode<EOL>", "docstring": "Getter method for accept_mode, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/addresses/address/vrrp/vrrp_group/config/accept_mode (boolean)\n\n    YANG Description: Configure whether packets destined for\nvirtual addresses are accepted even when the virtual\naddress is not owned by the router interface", "id": "f21983:c0:m17"}
{"signature": "def _get_virtual_link_local(self):", "body": "return self.__virtual_link_local<EOL>", "docstring": "Getter method for virtual_link_local, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/addresses/address/vrrp/vrrp_group/config/virtual_link_local (inet:ip-address)\n\n    YANG Description: For VRRP on IPv6 interfaces, sets the virtual link local\naddress", "id": "f21983:c0:m23"}
{"signature": "def _set_virtual_router_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__virtual_router_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for virtual_router_id, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/addresses/address/vrrp/vrrp_group/config/virtual_router_id (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_virtual_router_id is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_virtual_router_id() directly.\n\n    YANG Description: Set the virtual router id for use by the VRRP group.  This\nusually also determines the virtual MAC address that is\ngenerated for the VRRP group", "id": "f21983:c0:m3"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/addresses/address/vrrp/vrrp_group/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration data for the VRRP group", "id": "f21984:c0:m6"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/addresses/address/vrrp/vrrp_group/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Operational state data for the VRRP group", "id": "f21984:c0:m9"}
{"signature": "def _get_interface_tracking(self):", "body": "return self.__interface_tracking<EOL>", "docstring": "Getter method for interface_tracking, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/addresses/address/vrrp/vrrp_group/interface_tracking (container)\n\nYANG Description: Top-level container for VRRP interface tracking", "id": "f21984:c0:m11"}
{"signature": "def _get_virtual_router_id(self):", "body": "return self.__virtual_router_id<EOL>", "docstring": "Getter method for virtual_router_id, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/addresses/address/vrrp/vrrp_group/virtual_router_id (leafref)\n\n    YANG Description: References the configured virtual router id for this\nVRRP group", "id": "f21984:c0:m2"}
{"signature": "def _get_priority_decrement(self):", "body": "return self.__priority_decrement<EOL>", "docstring": "Getter method for priority_decrement, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/addresses/address/vrrp/vrrp_group/interface_tracking/state/priority_decrement (uint8)\n\n    YANG Description: Set the value to subtract from priority when\nthe tracked interface goes down", "id": "f21985:c0:m5"}
{"signature": "def _set_track_interface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__track_interface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for track_interface, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/addresses/address/vrrp/vrrp_group/interface_tracking/config/track_interface (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_track_interface is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_track_interface() directly.\n\n    YANG Description: Sets an interface that should be\ntracked for up/down events to dynamically change the\npriority state of the VRRP group, and potentially\nchange the mastership if the tracked interface going\ndown lowers the priority sufficiently", "id": "f21986:c0:m3"}
{"signature": "def _get_priority_decrement(self):", "body": "return self.__priority_decrement<EOL>", "docstring": "Getter method for priority_decrement, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/addresses/address/vrrp/vrrp_group/interface_tracking/config/priority_decrement (uint8)\n\n    YANG Description: Set the value to subtract from priority when\nthe tracked interface goes down", "id": "f21986:c0:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/addresses/address/vrrp/vrrp_group/interface_tracking/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Operational state data for VRRP interface tracking", "id": "f21987:c0:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/state (container)\n\nYANG Description: Top-level operational state data for the IPv6 interface", "id": "f21989:c0:m14"}
{"signature": "def _get_autoconf(self):", "body": "return self.__autoconf<EOL>", "docstring": "Getter method for autoconf, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/autoconf (container)\n\nYANG Description: Top-level container for IPv6 autoconf", "id": "f21989:c0:m17"}
{"signature": "def _set_addresses(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=addresses.addresses,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__addresses = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for addresses, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/addresses (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_addresses is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_addresses() directly.\n\nYANG Description: Enclosing container for address list", "id": "f21989:c0:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Top-level operational state data for the IPv6 interface", "id": "f21989:c0:m15"}
{"signature": "def _get_addresses(self):", "body": "return self.__addresses<EOL>", "docstring": "Getter method for addresses, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/addresses (container)\n\nYANG Description: Enclosing container for address list", "id": "f21989:c0:m2"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/unnumbered/state/enabled (boolean)\n\n    YANG Description: Indicates that the subinterface is unnumbered.  By default\nthe subinterface is numbered, i.e., expected to have an\nIP address configuration.", "id": "f21990:c0:m2"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/unnumbered/config/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: Indicates that the subinterface is unnumbered.  By default\nthe subinterface is numbered, i.e., expected to have an\nIP address configuration.", "id": "f21991:c0:m3"}
{"signature": "def _set_interface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/unnumbered/interface_ref/state/interface (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_interface is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_interface() directly.\n\n    YANG Description: Reference to a base interface.  If a reference to a\nsubinterface is required, this leaf must be specified\nto indicate the base interface.", "id": "f21992:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/unnumbered/interface_ref/state (container)\n\nYANG Description: Operational state for interface-ref", "id": "f21994:c0:m5"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv6/unnumbered/interface_ref/config (container)\n\nYANG Description: Configured reference to interface / subinterface", "id": "f21994:c0:m2"}
{"signature": "def _set_ipv4(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=ipv4.ipv4,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv4 = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv4, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/ipv4 (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ipv4 is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ipv4() directly.\n\nYANG Description: Parameters for the IPv4 address family.", "id": "f21996:c0:m15"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface/state (container)\n\nYANG Description: Operational state data for logical interfaces", "id": "f21996:c0:m8"}
{"signature": "def _set_subinterface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT:index>\",<EOL>subinterface.subinterface,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT:index>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subinterface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subinterface, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface (list)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subinterface is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subinterface() directly.\n\n    YANG Description: The list of subinterfaces (logical interfaces) associated\nwith a physical interface", "id": "f21997:c0:m3"}
{"signature": "def _get_subinterface(self):", "body": "return self.__subinterface<EOL>", "docstring": "Getter method for subinterface, mapped from YANG variable /interfaces/interface/subinterfaces/subinterface (list)\n\n    YANG Description: The list of subinterfaces (logical interfaces) associated\nwith a physical interface", "id": "f21997:c0:m2"}
{"signature": "def _get_aggregate_id(self):", "body": "return self.__aggregate_id<EOL>", "docstring": "Getter method for aggregate_id, mapped from YANG variable /interfaces/interface/ethernet/state/aggregate_id (leafref)\n\n    YANG Description: Specify the logical aggregate interface to which\nthis interface belongs", "id": "f21998:c0:m32"}
{"signature": "def _get_in_mac_control_frames(self):", "body": "return self.__in_mac_control_frames<EOL>", "docstring": "Getter method for in_mac_control_frames, mapped from YANG variable /interfaces/interface/ethernet/state/counters/in_mac_control_frames (yang:counter64)\n\nYANG Description: MAC layer control frames received on the interface", "id": "f21999:c0:m2"}
{"signature": "def _set_out_mac_pause_frames(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__out_mac_pause_frames = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for out_mac_pause_frames, mapped from YANG variable /interfaces/interface/ethernet/state/counters/out_mac_pause_frames (yang:counter64)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_out_mac_pause_frames is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_out_mac_pause_frames() directly.\n\nYANG Description: MAC layer PAUSE frames sent on the interface", "id": "f21999:c0:m27"}
{"signature": "def _get_in_8021q_frames(self):", "body": "return self.__in_8021q_frames<EOL>", "docstring": "Getter method for in_8021q_frames, mapped from YANG variable /interfaces/interface/ethernet/state/counters/in_8021q_frames (yang:counter64)\n\nYANG Description: Number of 802.1q tagged frames received on the interface", "id": "f21999:c0:m17"}
{"signature": "def _set_out_mac_control_frames(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__out_mac_control_frames = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for out_mac_control_frames, mapped from YANG variable /interfaces/interface/ethernet/state/counters/out_mac_control_frames (yang:counter64)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_out_mac_control_frames is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_out_mac_control_frames() directly.\n\nYANG Description: MAC layer control frames sent on the interface", "id": "f21999:c0:m24"}
{"signature": "def _get_out_8021q_frames(self):", "body": "return self.__out_8021q_frames<EOL>", "docstring": "Getter method for out_8021q_frames, mapped from YANG variable /interfaces/interface/ethernet/state/counters/out_8021q_frames (yang:counter64)\n\nYANG Description: Number of 802.1q tagged frames sent on the interface", "id": "f21999:c0:m29"}
{"signature": "def _set_in_crc_errors(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__in_crc_errors = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for in_crc_errors, mapped from YANG variable /interfaces/interface/ethernet/state/counters/in_crc_errors (yang:counter64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_in_crc_errors is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_in_crc_errors() directly.\n\n    YANG Description: Number of receive error events due to FCS/CRC check\nfailure", "id": "f21999:c0:m21"}
{"signature": "def _set_in_mac_pause_frames(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__in_mac_pause_frames = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for in_mac_pause_frames, mapped from YANG variable /interfaces/interface/ethernet/state/counters/in_mac_pause_frames (yang:counter64)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_in_mac_pause_frames is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_in_mac_pause_frames() directly.\n\nYANG Description: MAC layer PAUSE frames received on the interface", "id": "f21999:c0:m6"}
{"signature": "def _get_out_mac_pause_frames(self):", "body": "return self.__out_mac_pause_frames<EOL>", "docstring": "Getter method for out_mac_pause_frames, mapped from YANG variable /interfaces/interface/ethernet/state/counters/out_mac_pause_frames (yang:counter64)\n\nYANG Description: MAC layer PAUSE frames sent on the interface", "id": "f21999:c0:m26"}
{"signature": "def _get_duplex_mode(self):", "body": "return self.__duplex_mode<EOL>", "docstring": "Getter method for duplex_mode, mapped from YANG variable /interfaces/interface/ethernet/config/duplex_mode (enumeration)\n\n    YANG Description: When auto-negotiate is TRUE, this optionally sets the\nduplex mode that will be advertised to the peer.  If\nunspecified, the interface should negotiate the duplex mode\ndirectly (typically full-duplex).  When auto-negotiate is\nFALSE, this sets the duplex mode on the interface directly.", "id": "f22000:c0:m8"}
{"signature": "def _set_duplex_mode(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__duplex_mode = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for duplex_mode, mapped from YANG variable /interfaces/interface/ethernet/config/duplex_mode (enumeration)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_duplex_mode is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_duplex_mode() directly.\n\n    YANG Description: When auto-negotiate is TRUE, this optionally sets the\nduplex mode that will be advertised to the peer.  If\nunspecified, the interface should negotiate the duplex mode\ndirectly (typically full-duplex).  When auto-negotiate is\nFALSE, this sets the duplex mode on the interface directly.", "id": "f22000:c0:m9"}
{"signature": "def _set_port_speed(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__port_speed = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for port_speed, mapped from YANG variable /interfaces/interface/ethernet/config/port_speed (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_port_speed is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_port_speed() directly.\n\n    YANG Description: When auto-negotiate is TRUE, this optionally sets the\nport-speed mode that will be advertised to the peer for\nnegotiation.  If unspecified, it is expected that the\ninterface will select the highest speed available based on\nnegotiation.  When auto-negotiate is set to FALSE, sets the\nlink speed to a fixed value -- supported values are defined\nby ETHERNET_SPEED identities", "id": "f22000:c0:m12"}
{"signature": "def _set_enable_flow_control(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enable_flow_control = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enable_flow_control, mapped from YANG variable /interfaces/interface/ethernet/config/enable_flow_control (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enable_flow_control is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enable_flow_control() directly.\n\n    YANG Description: Enable or disable flow control for this interface.\nEthernet flow control is a mechanism by which a receiver\nmay send PAUSE frames to a sender to stop transmission for\na specified time.\n\nThis setting should override auto-negotiated flow control\nsettings.  If left unspecified, and auto-negotiate is TRUE,\nflow control mode is negotiated with the peer interface.", "id": "f22000:c0:m15"}
{"signature": "def _get_mac_address(self):", "body": "return self.__mac_address<EOL>", "docstring": "Getter method for mac_address, mapped from YANG variable /interfaces/interface/ethernet/config/mac_address (yang:mac-address)\n\n    YANG Description: Assigns a MAC address to the Ethernet interface.  If not\nspecified, the corresponding operational state leaf is\nexpected to show the system-assigned MAC address.", "id": "f22000:c0:m2"}
{"signature": "def _get_auto_negotiate(self):", "body": "return self.__auto_negotiate<EOL>", "docstring": "Getter method for auto_negotiate, mapped from YANG variable /interfaces/interface/ethernet/config/auto_negotiate (boolean)\n\n    YANG Description: Set to TRUE to request the interface to auto-negotiate\ntransmission parameters with its peer interface.  When\nset to FALSE, the transmission parameters are specified\nmanually.", "id": "f22000:c0:m5"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /interfaces/interface/ethernet/state (container)\n\nYANG Description: State variables for Ethernet interfaces", "id": "f22001:c0:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /interfaces/interface/ethernet/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State variables for Ethernet interfaces", "id": "f22001:c0:m6"}
{"signature": "def _get_native_vlan(self):", "body": "return self.__native_vlan<EOL>", "docstring": "Getter method for native_vlan, mapped from YANG variable /interfaces/interface/ethernet/switched_vlan/state/native_vlan (union)\n\n    YANG Description: Set the native VLAN id for untagged frames arriving on\na trunk interface.  This configuration is only valid on\na trunk interface.", "id": "f22002:c0:m5"}
{"signature": "def _set_access_vlan(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:16>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__access_vlan = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for access_vlan, mapped from YANG variable /interfaces/interface/ethernet/switched_vlan/state/access_vlan (union)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_access_vlan is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_access_vlan() directly.\n\nYANG Description: Assign the access vlan to the access port.", "id": "f22002:c0:m9"}
{"signature": "def _get_interface_mode(self):", "body": "return self.__interface_mode<EOL>", "docstring": "Getter method for interface_mode, mapped from YANG variable /interfaces/interface/ethernet/switched_vlan/config/interface_mode (oc-vlan-types:vlan-mode-type)\n\n    YANG Description: Set the interface to access or trunk mode for\nVLANs", "id": "f22003:c0:m2"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /interfaces/interface/ethernet/switched_vlan/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration parameters for VLANs", "id": "f22004:c0:m3"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /interfaces/interface/ethernet/switched_vlan/config (container)\n\nYANG Description: Configuration parameters for VLANs", "id": "f22004:c0:m2"}
{"signature": "def _get_mtu(self):", "body": "return self.__mtu<EOL>", "docstring": "Getter method for mtu, mapped from YANG variable /interfaces/interface/routed_vlan/ipv4/state/mtu (uint16)\n\n    YANG Description: The size, in octets, of the largest IPv4 packet that the\ninterface will send and receive.\n\nThe server may restrict the allowed values for this leaf,\ndepending on the interface's type.\n\nIf this leaf is not configured, the operationally used MTU\ndepends on the interface's type.", "id": "f22005:c0:m5"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:true>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /interfaces/interface/routed_vlan/ipv4/state/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: Controls whether IPv4 is enabled or disabled on this\ninterface.  When IPv4 is enabled, this interface is\nconnected to an IPv4 stack, and the interface can send\nand receive IPv4 packets.", "id": "f22005:c0:m3"}
{"signature": "def _get_origin(self):", "body": "return self.__origin<EOL>", "docstring": "Getter method for origin, mapped from YANG variable /interfaces/interface/routed_vlan/ipv4/neighbors/neighbor/state/origin (neighbor-origin)\n\nYANG Description: The origin of this neighbor entry, static or dynamic.", "id": "f22006:c0:m8"}
{"signature": "def _set_ip(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ip = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ip, mapped from YANG variable /interfaces/interface/routed_vlan/ipv4/neighbors/neighbor/state/ip (inet:ipv4-address-no-zone)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ip is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ip() directly.\n\nYANG Description: The IPv4 address of the neighbor node.", "id": "f22006:c0:m3"}
{"signature": "def _set_ip(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ip = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ip, mapped from YANG variable /interfaces/interface/routed_vlan/ipv4/neighbors/neighbor/ip (leafref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ip is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ip() directly.\n\nYANG Description: References the configured IP address", "id": "f22008:c0:m3"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /interfaces/interface/routed_vlan/ipv4/config/enabled (boolean)\n\n    YANG Description: Controls whether IPv4 is enabled or disabled on this\ninterface.  When IPv4 is enabled, this interface is\nconnected to an IPv4 stack, and the interface can send\nand receive IPv4 packets.", "id": "f22010:c0:m2"}
{"signature": "def _get_origin(self):", "body": "return self.__origin<EOL>", "docstring": "Getter method for origin, mapped from YANG variable /interfaces/interface/routed_vlan/ipv4/addresses/address/state/origin (ip-address-origin)\n\n    YANG Description: The origin of this address, e.g., statically configured,\nassigned by DHCP, etc..", "id": "f22011:c0:m8"}
{"signature": "def _get_secondary(self):", "body": "return self.__secondary<EOL>", "docstring": "Getter method for secondary, mapped from YANG variable /interfaces/interface/routed_vlan/ipv4/addresses/address/config/secondary (boolean)\n\n    YANG Description: Most platforms need a secondary statement on when configuring multiple IPv4 addresses\non the same interfaces", "id": "f22012:c0:m8"}
{"signature": "def _get_prefix_length(self):", "body": "return self.__prefix_length<EOL>", "docstring": "Getter method for prefix_length, mapped from YANG variable /interfaces/interface/routed_vlan/ipv4/addresses/address/config/prefix_length (uint8)\n\n    YANG Description: [adapted from IETF IP model RFC 7277]\n\nThe length of the subnet prefix.", "id": "f22012:c0:m5"}
{"signature": "def _set_vrrp(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=vrrp.vrrp,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__vrrp = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for vrrp, mapped from YANG variable /interfaces/interface/routed_vlan/ipv4/addresses/address/vrrp (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_vrrp is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_vrrp() directly.\n\n    YANG Description: Enclosing container for VRRP groups handled by this\nIP interface", "id": "f22013:c0:m12"}
{"signature": "def _get_ip(self):", "body": "return self.__ip<EOL>", "docstring": "Getter method for ip, mapped from YANG variable /interfaces/interface/routed_vlan/ipv4/addresses/address/ip (leafref)\n\nYANG Description: References the configured IP address", "id": "f22013:c0:m2"}
{"signature": "def _set_virtual_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>]<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__virtual_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for virtual_address, mapped from YANG variable /interfaces/interface/routed_vlan/ipv4/addresses/address/vrrp/vrrp_group/state/virtual_address (inet:ip-address)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_virtual_address is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_virtual_address() directly.\n\n    YANG Description: Configure one or more virtual addresses for the\nVRRP group", "id": "f22015:c0:m6"}
{"signature": "def _get_advertisement_interval(self):", "body": "return self.__advertisement_interval<EOL>", "docstring": "Getter method for advertisement_interval, mapped from YANG variable /interfaces/interface/routed_vlan/ipv4/addresses/address/vrrp/vrrp_group/state/advertisement_interval (uint16)\n\n    YANG Description: Sets the interval between successive VRRP\nadvertisements -- RFC 5798 defines this as a 12-bit\nvalue expressed as 0.1 seconds, with default 100, i.e.,\n1 second.  Several implementation express this in units of\nseconds", "id": "f22015:c0:m20"}
{"signature": "def _set_virtual_router_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__virtual_router_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for virtual_router_id, mapped from YANG variable /interfaces/interface/routed_vlan/ipv4/addresses/address/vrrp/vrrp_group/state/virtual_router_id (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_virtual_router_id is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_virtual_router_id() directly.\n\n    YANG Description: Set the virtual router id for use by the VRRP group.  This\nusually also determines the virtual MAC address that is\ngenerated for the VRRP group", "id": "f22015:c0:m3"}
{"signature": "def _set_preempt_delay(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:16>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>default=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>)(<EOL><NUM_LIT:0><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__preempt_delay = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for preempt_delay, mapped from YANG variable /interfaces/interface/routed_vlan/ipv4/addresses/address/vrrp/vrrp_group/state/preempt_delay (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_preempt_delay is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_preempt_delay() directly.\n\n    YANG Description: Set the delay the higher priority router waits\nbefore preempting", "id": "f22015:c0:m15"}
{"signature": "def _set_virtual_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>]<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__virtual_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for virtual_address, mapped from YANG variable /interfaces/interface/routed_vlan/ipv4/addresses/address/vrrp/vrrp_group/config/virtual_address (inet:ip-address)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_virtual_address is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_virtual_address() directly.\n\n    YANG Description: Configure one or more virtual addresses for the\nVRRP group", "id": "f22016:c0:m6"}
{"signature": "def _get_preempt_delay(self):", "body": "return self.__preempt_delay<EOL>", "docstring": "Getter method for preempt_delay, mapped from YANG variable /interfaces/interface/routed_vlan/ipv4/addresses/address/vrrp/vrrp_group/config/preempt_delay (uint16)\n\n    YANG Description: Set the delay the higher priority router waits\nbefore preempting", "id": "f22016:c0:m14"}
{"signature": "def _set_accept_mode(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__accept_mode = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for accept_mode, mapped from YANG variable /interfaces/interface/routed_vlan/ipv4/addresses/address/vrrp/vrrp_group/config/accept_mode (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_accept_mode is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_accept_mode() directly.\n\n    YANG Description: Configure whether packets destined for\nvirtual addresses are accepted even when the virtual\naddress is not owned by the router interface", "id": "f22016:c0:m18"}
{"signature": "def _set_preempt(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:true>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__preempt = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for preempt, mapped from YANG variable /interfaces/interface/routed_vlan/ipv4/addresses/address/vrrp/vrrp_group/config/preempt (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_preempt is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_preempt() directly.\n\n    YANG Description: When set to true, enables preemption by a higher\npriority backup router of a lower priority master router", "id": "f22016:c0:m12"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /interfaces/interface/routed_vlan/ipv4/addresses/address/vrrp/vrrp_group/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration data for the VRRP group", "id": "f22017:c0:m6"}
{"signature": "def _get_interface_tracking(self):", "body": "return self.__interface_tracking<EOL>", "docstring": "Getter method for interface_tracking, mapped from YANG variable /interfaces/interface/routed_vlan/ipv4/addresses/address/vrrp/vrrp_group/interface_tracking (container)\n\nYANG Description: Top-level container for VRRP interface tracking", "id": "f22017:c0:m11"}
{"signature": "def _set_priority_decrement(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>default=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>)(<EOL><NUM_LIT:0><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__priority_decrement = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for priority_decrement, mapped from YANG variable /interfaces/interface/routed_vlan/ipv4/addresses/address/vrrp/vrrp_group/interface_tracking/state/priority_decrement (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_priority_decrement is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_priority_decrement() directly.\n\n    YANG Description: Set the value to subtract from priority when\nthe tracked interface goes down", "id": "f22018:c0:m6"}
{"signature": "def _set_track_interface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__track_interface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for track_interface, mapped from YANG variable /interfaces/interface/routed_vlan/ipv4/addresses/address/vrrp/vrrp_group/interface_tracking/config/track_interface (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_track_interface is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_track_interface() directly.\n\n    YANG Description: Sets an interface that should be\ntracked for up/down events to dynamically change the\npriority state of the VRRP group, and potentially\nchange the mastership if the tracked interface going\ndown lowers the priority sufficiently", "id": "f22019:c0:m3"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /interfaces/interface/routed_vlan/ipv4/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Top-level IPv4 configuration data for the interface", "id": "f22022:c0:m12"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /interfaces/interface/routed_vlan/ipv4/config (container)\n\nYANG Description: Top-level IPv4 configuration data for the interface", "id": "f22022:c0:m11"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /interfaces/interface/routed_vlan/ipv4/unnumbered/state/enabled (boolean)\n\n    YANG Description: Indicates that the subinterface is unnumbered.  By default\nthe subinterface is numbered, i.e., expected to have an\nIP address configuration.", "id": "f22023:c0:m2"}
{"signature": "def _get_interface(self):", "body": "return self.__interface<EOL>", "docstring": "Getter method for interface, mapped from YANG variable /interfaces/interface/routed_vlan/ipv4/unnumbered/interface_ref/config/interface (leafref)\n\n    YANG Description: Reference to a base interface.  If a reference to a\nsubinterface is required, this leaf must be specified\nto indicate the base interface.", "id": "f22026:c0:m2"}
{"signature": "def _set_interface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface, mapped from YANG variable /interfaces/interface/routed_vlan/ipv4/unnumbered/interface_ref/config/interface (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_interface is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_interface() directly.\n\n    YANG Description: Reference to a base interface.  If a reference to a\nsubinterface is required, this leaf must be specified\nto indicate the base interface.", "id": "f22026:c0:m3"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /interfaces/interface/routed_vlan/ipv4/unnumbered/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration data for unnumbered interface", "id": "f22028:c0:m3"}
{"signature": "def _set_vlan(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:16>,<EOL>),<EOL>six.text_type,<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__vlan = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for vlan, mapped from YANG variable /interfaces/interface/routed_vlan/config/vlan (union)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_vlan is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_vlan() directly.\n\n    YANG Description: References the VLAN for which this IP interface\nprovides routing services -- similar to a switch virtual\ninterface (SVI), or integrated routing and bridging interface\n(IRB) in some implementations.", "id": "f22030:c0:m3"}
{"signature": "def _get_vlan(self):", "body": "return self.__vlan<EOL>", "docstring": "Getter method for vlan, mapped from YANG variable /interfaces/interface/routed_vlan/config/vlan (union)\n\n    YANG Description: References the VLAN for which this IP interface\nprovides routing services -- similar to a switch virtual\ninterface (SVI), or integrated routing and bridging interface\n(IRB) in some implementations.", "id": "f22030:c0:m2"}
{"signature": "def _set_dup_addr_detect_transmits(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>default=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>)(<EOL><NUM_LIT:1><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__dup_addr_detect_transmits = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for dup_addr_detect_transmits, mapped from YANG variable /interfaces/interface/routed_vlan/ipv6/state/dup_addr_detect_transmits (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_dup_addr_detect_transmits is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_dup_addr_detect_transmits() directly.\n\n    YANG Description: [adapted from IETF IP model RFC 7277]\n\nThe number of consecutive Neighbor Solicitation messages\nsent while performing Duplicate Address Detection on a\ntentative address.  A value of zero indicates that\nDuplicate Address Detection is not performed on\ntentative addresses.  A value of one indicates a single\ntransmission with no follow-up retransmissions.", "id": "f22031:c0:m9"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:true>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /interfaces/interface/routed_vlan/ipv6/state/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: [adapted from IETF IP model RFC 7277]\n\nControls whether IPv6 is enabled or disabled on this\ninterface.  When IPv6 is enabled, this interface is\nconnected to an IPv6 stack, and the interface can send\nand receive IPv6 packets.", "id": "f22031:c0:m3"}
{"signature": "def _get_origin(self):", "body": "return self.__origin<EOL>", "docstring": "Getter method for origin, mapped from YANG variable /interfaces/interface/routed_vlan/ipv6/neighbors/neighbor/state/origin (neighbor-origin)\n\n    YANG Description: [adapted from IETF IP model RFC 7277]\n\nThe origin of this neighbor entry.", "id": "f22032:c0:m8"}
{"signature": "def _set_origin(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__origin = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for origin, mapped from YANG variable /interfaces/interface/routed_vlan/ipv6/neighbors/neighbor/state/origin (neighbor-origin)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_origin is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_origin() directly.\n\n    YANG Description: [adapted from IETF IP model RFC 7277]\n\nThe origin of this neighbor entry.", "id": "f22032:c0:m9"}
{"signature": "def _set_neighbor_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__neighbor_state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for neighbor_state, mapped from YANG variable /interfaces/interface/routed_vlan/ipv6/neighbors/neighbor/state/neighbor_state (enumeration)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_neighbor_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_neighbor_state() directly.\n\n    YANG Description: [adapted from IETF IP model RFC 7277]\n\nThe Neighbor Unreachability Detection state of this\nentry.", "id": "f22032:c0:m15"}
{"signature": "def _get_ip(self):", "body": "return self.__ip<EOL>", "docstring": "Getter method for ip, mapped from YANG variable /interfaces/interface/routed_vlan/ipv6/neighbors/neighbor/config/ip (inet:ipv6-address-no-zone)\n\n    YANG Description: [adapted from IETF IP model RFC 7277]\n\nThe IPv6 address of the neighbor node.", "id": "f22033:c0:m2"}
{"signature": "def _set_ip(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ip = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ip, mapped from YANG variable /interfaces/interface/routed_vlan/ipv6/neighbors/neighbor/config/ip (inet:ipv6-address-no-zone)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_ip is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_ip() directly.\n\n    YANG Description: [adapted from IETF IP model RFC 7277]\n\nThe IPv6 address of the neighbor node.", "id": "f22033:c0:m3"}
{"signature": "def _get_ip(self):", "body": "return self.__ip<EOL>", "docstring": "Getter method for ip, mapped from YANG variable /interfaces/interface/routed_vlan/ipv6/neighbors/neighbor/ip (leafref)\n\nYANG Description: References the configured IP neighbor address", "id": "f22034:c0:m2"}
{"signature": "def _get_mtu(self):", "body": "return self.__mtu<EOL>", "docstring": "Getter method for mtu, mapped from YANG variable /interfaces/interface/routed_vlan/ipv6/config/mtu (uint32)\n\n    YANG Description: [adapted from IETF IP model RFC 7277]\n\nThe size, in octets, of the largest IPv6 packet that the\ninterface will send and receive.\n\nThe server may restrict the allowed values for this leaf,\ndepending on the interface's type.\n\nIf this leaf is not configured, the operationally used MTU\ndepends on the interface's type.", "id": "f22036:c0:m5"}
{"signature": "def _set_status(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:status>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__status = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for status, mapped from YANG variable /interfaces/interface/routed_vlan/ipv6/addresses/address/state/status (enumeration)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_status is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_status() directly.\n\n    YANG Description: [adapted from IETF IP model RFC 7277]\n\nThe status of an address.  Most of the states correspond\nto states from the IPv6 Stateless Address\nAutoconfiguration protocol.", "id": "f22037:c0:m12"}
{"signature": "def _get_status(self):", "body": "return self.__status<EOL>", "docstring": "Getter method for status, mapped from YANG variable /interfaces/interface/routed_vlan/ipv6/addresses/address/state/status (enumeration)\n\n    YANG Description: [adapted from IETF IP model RFC 7277]\n\nThe status of an address.  Most of the states correspond\nto states from the IPv6 Stateless Address\nAutoconfiguration protocol.", "id": "f22037:c0:m11"}
{"signature": "def _get_ip(self):", "body": "return self.__ip<EOL>", "docstring": "Getter method for ip, mapped from YANG variable /interfaces/interface/routed_vlan/ipv6/addresses/address/state/ip (inet:ipv6-address-no-zone)\n\n    YANG Description: [adapted from IETF IP model RFC 7277]\n\nThe IPv6 address on the interface.", "id": "f22037:c0:m2"}
{"signature": "def _set_prefix_length(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prefix_length = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prefix_length, mapped from YANG variable /interfaces/interface/routed_vlan/ipv6/addresses/address/config/prefix_length (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prefix_length is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prefix_length() directly.\n\n    YANG Description: [adapted from IETF IP model RFC 7277]\n\nThe length of the subnet prefix.", "id": "f22038:c0:m6"}
{"signature": "def _set_ip(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ip = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ip, mapped from YANG variable /interfaces/interface/routed_vlan/ipv6/addresses/address/config/ip (inet:ipv6-address-no-zone)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_ip is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_ip() directly.\n\n    YANG Description: [adapted from IETF IP model RFC 7277]\n\nThe IPv6 address on the interface.", "id": "f22038:c0:m3"}
{"signature": "def _get_ip(self):", "body": "return self.__ip<EOL>", "docstring": "Getter method for ip, mapped from YANG variable /interfaces/interface/routed_vlan/ipv6/addresses/address/config/ip (inet:ipv6-address-no-zone)\n\n    YANG Description: [adapted from IETF IP model RFC 7277]\n\nThe IPv6 address on the interface.", "id": "f22038:c0:m2"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /interfaces/interface/routed_vlan/ipv6/addresses/address/config (container)\n\n    YANG Description: Configuration data for each IPv6 address on\nthe interface", "id": "f22039:c0:m5"}
{"signature": "def _get_vrrp(self):", "body": "return self.__vrrp<EOL>", "docstring": "Getter method for vrrp, mapped from YANG variable /interfaces/interface/routed_vlan/ipv6/addresses/address/vrrp (container)\n\n    YANG Description: Enclosing container for VRRP groups handled by this\nIP interface", "id": "f22039:c0:m11"}
{"signature": "def _get_advertisement_interval(self):", "body": "return self.__advertisement_interval<EOL>", "docstring": "Getter method for advertisement_interval, mapped from YANG variable /interfaces/interface/routed_vlan/ipv6/addresses/address/vrrp/vrrp_group/state/advertisement_interval (uint16)\n\n    YANG Description: Sets the interval between successive VRRP\nadvertisements -- RFC 5798 defines this as a 12-bit\nvalue expressed as 0.1 seconds, with default 100, i.e.,\n1 second.  Several implementation express this in units of\nseconds", "id": "f22041:c0:m20"}
{"signature": "def _set_preempt_delay(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:16>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>default=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>)(<EOL><NUM_LIT:0><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__preempt_delay = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for preempt_delay, mapped from YANG variable /interfaces/interface/routed_vlan/ipv6/addresses/address/vrrp/vrrp_group/state/preempt_delay (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_preempt_delay is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_preempt_delay() directly.\n\n    YANG Description: Set the delay the higher priority router waits\nbefore preempting", "id": "f22041:c0:m15"}
{"signature": "def _get_virtual_link_local(self):", "body": "return self.__virtual_link_local<EOL>", "docstring": "Getter method for virtual_link_local, mapped from YANG variable /interfaces/interface/routed_vlan/ipv6/addresses/address/vrrp/vrrp_group/state/virtual_link_local (inet:ip-address)\n\n    YANG Description: For VRRP on IPv6 interfaces, sets the virtual link local\naddress", "id": "f22041:c0:m26"}
{"signature": "def _set_virtual_link_local(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__virtual_link_local = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for virtual_link_local, mapped from YANG variable /interfaces/interface/routed_vlan/ipv6/addresses/address/vrrp/vrrp_group/state/virtual_link_local (inet:ip-address)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_virtual_link_local is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_virtual_link_local() directly.\n\n    YANG Description: For VRRP on IPv6 interfaces, sets the virtual link local\naddress", "id": "f22041:c0:m27"}
{"signature": "def _set_accept_mode(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__accept_mode = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for accept_mode, mapped from YANG variable /interfaces/interface/routed_vlan/ipv6/addresses/address/vrrp/vrrp_group/state/accept_mode (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_accept_mode is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_accept_mode() directly.\n\n    YANG Description: Configure whether packets destined for\nvirtual addresses are accepted even when the virtual\naddress is not owned by the router interface", "id": "f22041:c0:m18"}
{"signature": "def _set_virtual_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>]<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__virtual_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for virtual_address, mapped from YANG variable /interfaces/interface/routed_vlan/ipv6/addresses/address/vrrp/vrrp_group/config/virtual_address (inet:ip-address)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_virtual_address is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_virtual_address() directly.\n\n    YANG Description: Configure one or more virtual addresses for the\nVRRP group", "id": "f22042:c0:m6"}
{"signature": "def _set_preempt(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:true>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__preempt = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for preempt, mapped from YANG variable /interfaces/interface/routed_vlan/ipv6/addresses/address/vrrp/vrrp_group/config/preempt (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_preempt is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_preempt() directly.\n\n    YANG Description: When set to true, enables preemption by a higher\npriority backup router of a lower priority master router", "id": "f22042:c0:m12"}
{"signature": "def _get_virtual_router_id(self):", "body": "return self.__virtual_router_id<EOL>", "docstring": "Getter method for virtual_router_id, mapped from YANG variable /interfaces/interface/routed_vlan/ipv6/addresses/address/vrrp/vrrp_group/config/virtual_router_id (uint8)\n\n    YANG Description: Set the virtual router id for use by the VRRP group.  This\nusually also determines the virtual MAC address that is\ngenerated for the VRRP group", "id": "f22042:c0:m2"}
{"signature": "def _get_preempt_delay(self):", "body": "return self.__preempt_delay<EOL>", "docstring": "Getter method for preempt_delay, mapped from YANG variable /interfaces/interface/routed_vlan/ipv6/addresses/address/vrrp/vrrp_group/config/preempt_delay (uint16)\n\n    YANG Description: Set the delay the higher priority router waits\nbefore preempting", "id": "f22042:c0:m14"}
{"signature": "def _set_virtual_router_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__virtual_router_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for virtual_router_id, mapped from YANG variable /interfaces/interface/routed_vlan/ipv6/addresses/address/vrrp/vrrp_group/config/virtual_router_id (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_virtual_router_id is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_virtual_router_id() directly.\n\n    YANG Description: Set the virtual router id for use by the VRRP group.  This\nusually also determines the virtual MAC address that is\ngenerated for the VRRP group", "id": "f22042:c0:m3"}
{"signature": "def _set_preempt_delay(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:16>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>default=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>)(<EOL><NUM_LIT:0><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__preempt_delay = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for preempt_delay, mapped from YANG variable /interfaces/interface/routed_vlan/ipv6/addresses/address/vrrp/vrrp_group/config/preempt_delay (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_preempt_delay is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_preempt_delay() directly.\n\n    YANG Description: Set the delay the higher priority router waits\nbefore preempting", "id": "f22042:c0:m15"}
{"signature": "def _get_interface_tracking(self):", "body": "return self.__interface_tracking<EOL>", "docstring": "Getter method for interface_tracking, mapped from YANG variable /interfaces/interface/routed_vlan/ipv6/addresses/address/vrrp/vrrp_group/interface_tracking (container)\n\nYANG Description: Top-level container for VRRP interface tracking", "id": "f22043:c0:m11"}
{"signature": "def _get_priority_decrement(self):", "body": "return self.__priority_decrement<EOL>", "docstring": "Getter method for priority_decrement, mapped from YANG variable /interfaces/interface/routed_vlan/ipv6/addresses/address/vrrp/vrrp_group/interface_tracking/state/priority_decrement (uint8)\n\n    YANG Description: Set the value to subtract from priority when\nthe tracked interface goes down", "id": "f22044:c0:m5"}
{"signature": "def _set_priority_decrement(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>default=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>)(<EOL><NUM_LIT:0><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__priority_decrement = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for priority_decrement, mapped from YANG variable /interfaces/interface/routed_vlan/ipv6/addresses/address/vrrp/vrrp_group/interface_tracking/state/priority_decrement (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_priority_decrement is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_priority_decrement() directly.\n\n    YANG Description: Set the value to subtract from priority when\nthe tracked interface goes down", "id": "f22044:c0:m6"}
{"signature": "def _get_track_interface(self):", "body": "return self.__track_interface<EOL>", "docstring": "Getter method for track_interface, mapped from YANG variable /interfaces/interface/routed_vlan/ipv6/addresses/address/vrrp/vrrp_group/interface_tracking/config/track_interface (leafref)\n\n    YANG Description: Sets an interface that should be\ntracked for up/down events to dynamically change the\npriority state of the VRRP group, and potentially\nchange the mastership if the tracked interface going\ndown lowers the priority sufficiently", "id": "f22045:c0:m2"}
{"signature": "def _set_track_interface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__track_interface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for track_interface, mapped from YANG variable /interfaces/interface/routed_vlan/ipv6/addresses/address/vrrp/vrrp_group/interface_tracking/config/track_interface (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_track_interface is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_track_interface() directly.\n\n    YANG Description: Sets an interface that should be\ntracked for up/down events to dynamically change the\npriority state of the VRRP group, and potentially\nchange the mastership if the tracked interface going\ndown lowers the priority sufficiently", "id": "f22045:c0:m3"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /interfaces/interface/routed_vlan/ipv6/addresses/address/vrrp/vrrp_group/interface_tracking/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration data for VRRP interface tracking", "id": "f22046:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /interfaces/interface/routed_vlan/ipv6/addresses/address/vrrp/vrrp_group/interface_tracking/state (container)\n\nYANG Description: Operational state data for VRRP interface tracking", "id": "f22046:c0:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /interfaces/interface/routed_vlan/ipv6/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Top-level operational state data for the IPv6 interface", "id": "f22048:c0:m15"}
{"signature": "def _get_addresses(self):", "body": "return self.__addresses<EOL>", "docstring": "Getter method for addresses, mapped from YANG variable /interfaces/interface/routed_vlan/ipv6/addresses (container)\n\nYANG Description: Enclosing container for address list", "id": "f22048:c0:m2"}
{"signature": "def _set_subinterface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subinterface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subinterface, mapped from YANG variable /interfaces/interface/routed_vlan/ipv6/unnumbered/interface_ref/state/subinterface (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subinterface is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subinterface() directly.\n\n    YANG Description: Reference to a subinterface -- this requires the base\ninterface to be specified using the interface leaf in\nthis container.  If only a reference to a base interface\nis requuired, this leaf should not be set.", "id": "f22051:c0:m6"}
{"signature": "def _set_interface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface, mapped from YANG variable /interfaces/interface/routed_vlan/ipv6/unnumbered/interface_ref/config/interface (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_interface is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_interface() directly.\n\n    YANG Description: Reference to a base interface.  If a reference to a\nsubinterface is required, this leaf must be specified\nto indicate the base interface.", "id": "f22052:c0:m3"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /interfaces/interface/routed_vlan/ipv6/unnumbered/interface_ref/config (container)\n\nYANG Description: Configured reference to interface / subinterface", "id": "f22053:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /interfaces/interface/routed_vlan/ipv6/unnumbered/interface_ref/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Operational state for interface-ref", "id": "f22053:c0:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /interfaces/interface/routed_vlan/ipv6/unnumbered/interface_ref/state (container)\n\nYANG Description: Operational state for interface-ref", "id": "f22053:c0:m5"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /interfaces/interface/routed_vlan/ipv6/unnumbered/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration data for unnumbered interface", "id": "f22054:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /interfaces/interface/routed_vlan/ipv6/unnumbered/state (container)\n\nYANG Description: Operational state data for unnumbered interfaces", "id": "f22054:c0:m5"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /interfaces/interface/routed_vlan/ipv6/unnumbered/config (container)\n\nYANG Description: Configuration data for unnumbered interface", "id": "f22054:c0:m2"}
{"signature": "def _set_ipv4(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=ipv4.ipv4,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv4 = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv4, mapped from YANG variable /interfaces/interface/routed_vlan/ipv4 (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ipv4 is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ipv4() directly.\n\nYANG Description: Parameters for the IPv4 address family.", "id": "f22055:c0:m9"}
{"signature": "def _set_ipv6(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=ipv6.ipv6,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv6 = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv6, mapped from YANG variable /interfaces/interface/routed_vlan/ipv6 (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ipv6 is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ipv6() directly.\n\nYANG Description: Parameters for the IPv6 address family.", "id": "f22055:c0:m12"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /interfaces/interface/routed_vlan/state (container)\n\nYANG Description: Operational state data", "id": "f22055:c0:m5"}
{"signature": "def _set_name(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:name>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for name, mapped from YANG variable /interfaces/interface/config/name (string)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_name is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_name() directly.\n\n    YANG Description: [adapted from IETF interfaces model (RFC 7223)]\n\nThe name of the interface.\n\nA device MAY restrict the allowed values for this leaf,\npossibly depending on the type of the interface.\nFor system-controlled interfaces, this leaf is the\ndevice-specific name of the interface.  The 'config false'\nlist interfaces/interface[name]/state contains the currently\nexisting interfaces on the device.\n\nIf a client tries to create configuration for a\nsystem-controlled interface that is not present in the\ncorresponding state list, the server MAY reject\nthe request if the implementation does not support\npre-provisioning of interfaces or if the name refers to\nan interface that can never exist in the system.  A\nNETCONF server MUST reply with an rpc-error with the\nerror-tag 'invalid-value' in this case.\n\nThe IETF model in RFC 7223 provides YANG features for the\nfollowing (i.e., pre-provisioning and arbitrary-names),\nhowever they are omitted here:\n\n If the device supports pre-provisioning of interface\n configuration, the 'pre-provisioning' feature is\n advertised.\n\n If the device allows arbitrarily named user-controlled\n interfaces, the 'arbitrary-names' feature is advertised.\n\nWhen a configured user-controlled interface is created by\nthe system, it is instantiated with the same name in the\n/interfaces/interface[name]/state list.", "id": "f22056:c0:m9"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:true>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /interfaces/interface/config/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: [adapted from IETF interfaces model (RFC 7223)]\n\nThis leaf contains the configured, desired state of the\ninterface.\n\nSystems that implement the IF-MIB use the value of this\nleaf in the 'running' datastore to set\nIF-MIB.ifAdminStatus to 'up' or 'down' after an ifEntry\nhas been initialized, as described in RFC 2863.\n\nChanges in this leaf in the 'running' datastore are\nreflected in ifAdminStatus, but if ifAdminStatus is\nchanged over SNMP, this leaf is not affected.", "id": "f22056:c0:m15"}
{"signature": "def _set_mtu(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__mtu = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for mtu, mapped from YANG variable /interfaces/interface/config/mtu (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_mtu is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_mtu() directly.\n\n    YANG Description: Set the max transmission unit size in octets\nfor the physical interface.  If this is not set, the mtu is\nset to the operational default -- e.g., 1514 bytes on an\nEthernet interface.", "id": "f22056:c0:m6"}
{"signature": "def _get_description(self):", "body": "return self.__description<EOL>", "docstring": "Getter method for description, mapped from YANG variable /interfaces/interface/config/description (string)\n\n    YANG Description: [adapted from IETF interfaces model (RFC 7223)]\n\nA textual description of the interface.\n\nA server implementation MAY map this leaf to the ifAlias\nMIB object.  Such an implementation needs to use some\nmechanism to handle the differences in size and characters\nallowed between this leaf and ifAlias.  The definition of\nsuch a mechanism is outside the scope of this document.\n\nSince ifAlias is defined to be stored in non-volatile\nstorage, the MIB implementation MUST map ifAlias to the\nvalue of 'description' in the persistently stored\ndatastore.\n\nSpecifically, if the device supports ':startup', when\nifAlias is read the device MUST return the value of\n'description' in the 'startup' datastore, and when it is\nwritten, it MUST be written to the 'running' and 'startup'\ndatastores.  Note that it is up to the implementation to\n\ndecide whether to modify this single leaf in 'startup' or\nperform an implicit copy-config from 'running' to\n'startup'.\n\nIf the device does not support ':startup', ifAlias MUST\nbe mapped to the 'description' leaf in the 'running'\ndatastore.", "id": "f22056:c0:m11"}
{"signature": "def _set_description(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:description>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__description = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for description, mapped from YANG variable /interfaces/interface/config/description (string)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_description is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_description() directly.\n\n    YANG Description: [adapted from IETF interfaces model (RFC 7223)]\n\nA textual description of the interface.\n\nA server implementation MAY map this leaf to the ifAlias\nMIB object.  Such an implementation needs to use some\nmechanism to handle the differences in size and characters\nallowed between this leaf and ifAlias.  The definition of\nsuch a mechanism is outside the scope of this document.\n\nSince ifAlias is defined to be stored in non-volatile\nstorage, the MIB implementation MUST map ifAlias to the\nvalue of 'description' in the persistently stored\ndatastore.\n\nSpecifically, if the device supports ':startup', when\nifAlias is read the device MUST return the value of\n'description' in the 'startup' datastore, and when it is\nwritten, it MUST be written to the 'running' and 'startup'\ndatastores.  Note that it is up to the implementation to\n\ndecide whether to modify this single leaf in 'startup' or\nperform an implicit copy-config from 'running' to\n'startup'.\n\nIf the device does not support ':startup', ifAlias MUST\nbe mapped to the 'description' leaf in the 'running'\ndatastore.", "id": "f22056:c0:m12"}
{"signature": "def _set_routed_vlan(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=routed_vlan.routed_vlan,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__routed_vlan = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for routed_vlan, mapped from YANG variable /interfaces/interface/routed_vlan (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_routed_vlan is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_routed_vlan() directly.\n\n    YANG Description: Top-level container for routed vlan interfaces.  These\nlogical interfaces are also known as SVI (switched virtual\ninterface), IRB (integrated routing and bridging), RVI\n(routed VLAN interface)", "id": "f22057:c0:m24"}
{"signature": "def _set_aggregation(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=aggregation.aggregation,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__aggregation = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for aggregation, mapped from YANG variable /interfaces/interface/aggregation (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_aggregation is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_aggregation() directly.\n\n    YANG Description: Options for logical interfaces representing\naggregates", "id": "f22057:c0:m21"}
{"signature": "def _get_routed_vlan(self):", "body": "return self.__routed_vlan<EOL>", "docstring": "Getter method for routed_vlan, mapped from YANG variable /interfaces/interface/routed_vlan (container)\n\n    YANG Description: Top-level container for routed vlan interfaces.  These\nlogical interfaces are also known as SVI (switched virtual\ninterface), IRB (integrated routing and bridging), RVI\n(routed VLAN interface)", "id": "f22057:c0:m23"}
{"signature": "def _set_ethernet(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=ethernet.ethernet,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ethernet = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ethernet, mapped from YANG variable /interfaces/interface/ethernet (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_ethernet is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_ethernet() directly.\n\n    YANG Description: Top-level container for ethernet configuration\nand state", "id": "f22057:c0:m18"}
{"signature": "def _set_lag_speed(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__lag_speed = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for lag_speed, mapped from YANG variable /interfaces/interface/aggregation/state/lag_speed (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_lag_speed is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_lag_speed() directly.\n\n    YANG Description: Reports effective speed of the aggregate interface,\nbased on speed of active member interfaces", "id": "f22058:c0:m9"}
{"signature": "def _set_member(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(allowed_type=six.text_type),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__member = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for member, mapped from YANG variable /interfaces/interface/aggregation/state/member (oc-if:base-interface-ref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_member is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_member() directly.\n\n    YANG Description: List of current member interfaces for the aggregate,\nexpressed as references to existing interfaces", "id": "f22058:c0:m12"}
{"signature": "def _set_min_links(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__min_links = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for min_links, mapped from YANG variable /interfaces/interface/aggregation/state/min_links (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_min_links is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_min_links() directly.\n\n    YANG Description: Specifies the mininum number of member\ninterfaces that must be active for the aggregate interface\nto be available", "id": "f22058:c0:m6"}
{"signature": "def _get_min_links(self):", "body": "return self.__min_links<EOL>", "docstring": "Getter method for min_links, mapped from YANG variable /interfaces/interface/aggregation/state/min_links (uint16)\n\n    YANG Description: Specifies the mininum number of member\ninterfaces that must be active for the aggregate interface\nto be available", "id": "f22058:c0:m5"}
{"signature": "def _get_lag_speed(self):", "body": "return self.__lag_speed<EOL>", "docstring": "Getter method for lag_speed, mapped from YANG variable /interfaces/interface/aggregation/state/lag_speed (uint32)\n\n    YANG Description: Reports effective speed of the aggregate interface,\nbased on speed of active member interfaces", "id": "f22058:c0:m8"}
{"signature": "def _get_lag_type(self):", "body": "return self.__lag_type<EOL>", "docstring": "Getter method for lag_type, mapped from YANG variable /interfaces/interface/aggregation/config/lag_type (aggregation-type)\n\n    YANG Description: Sets the type of LAG, i.e., how it is\nconfigured / maintained", "id": "f22059:c0:m2"}
{"signature": "def _get_switched_vlan(self):", "body": "return self.__switched_vlan<EOL>", "docstring": "Getter method for switched_vlan, mapped from YANG variable /interfaces/interface/aggregation/switched_vlan (container)\n\n    YANG Description: Enclosing container for VLAN interface-specific\ndata on Ethernet interfaces.  These are for standard\nL2, switched-style VLANs.", "id": "f22060:c0:m8"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /interfaces/interface/aggregation/config (container)\n\n    YANG Description: Configuration variables for logical aggregate /\nLAG interfaces", "id": "f22060:c0:m2"}
{"signature": "def _set_access_vlan(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:16>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__access_vlan = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for access_vlan, mapped from YANG variable /interfaces/interface/aggregation/switched_vlan/state/access_vlan (union)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_access_vlan is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_access_vlan() directly.\n\nYANG Description: Assign the access vlan to the access port.", "id": "f22061:c0:m9"}
{"signature": "def _get_native_vlan(self):", "body": "return self.__native_vlan<EOL>", "docstring": "Getter method for native_vlan, mapped from YANG variable /interfaces/interface/aggregation/switched_vlan/state/native_vlan (union)\n\n    YANG Description: Set the native VLAN id for untagged frames arriving on\na trunk interface.  This configuration is only valid on\na trunk interface.", "id": "f22061:c0:m5"}
{"signature": "def _set_interface_mode(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface_mode = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface_mode, mapped from YANG variable /interfaces/interface/aggregation/switched_vlan/config/interface_mode (oc-vlan-types:vlan-mode-type)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_interface_mode is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_interface_mode() directly.\n\n    YANG Description: Set the interface to access or trunk mode for\nVLANs", "id": "f22062:c0:m3"}
{"signature": "def _get_trunk_vlans(self):", "body": "return self.__trunk_vlans<EOL>", "docstring": "Getter method for trunk_vlans, mapped from YANG variable /interfaces/interface/aggregation/switched_vlan/config/trunk_vlans (union)\n\n    YANG Description: Specify VLANs, or ranges thereof, that the interface may\ncarry when in trunk mode.  If not specified, all VLANs are\nallowed on the interface. Ranges are specified in the form\nx..y, where x<y - ranges are assumed to be inclusive (such\nthat the VLAN range is x <= range <= y.", "id": "f22062:c0:m11"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /interfaces/interface/aggregation/switched_vlan/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration parameters for VLANs", "id": "f22063:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /interfaces/interface/hold_time/state (container)\n\nYANG Description: Operational state data for interface hold-time.", "id": "f22066:c0:m5"}
{"signature": "def _get_interface(self):", "body": "return self.__interface<EOL>", "docstring": "Getter method for interface, mapped from YANG variable /interfaces/interface (list)\n\nYANG Description: The list of named interfaces on the device.", "id": "f22067:c0:m2"}
{"signature": "def _get_interfaces(self):", "body": "return self.__interfaces<EOL>", "docstring": "Getter method for interfaces, mapped from YANG variable /interfaces (container)\n\n    YANG Description: Top level container for interfaces, including configuration\nand state data.", "id": "f22068:c6:m2"}
{"signature": "def _set_system(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=system.system,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__system = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for system, mapped from YANG variable /system (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_system is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_system() directly.\n\n    YANG Description: Enclosing container for system-related configuration and\noperational state data", "id": "f22068:c21:m3"}
{"signature": "def _get_network_instances(self):", "body": "return self.__network_instances<EOL>", "docstring": "Getter method for network_instances, mapped from YANG variable /network_instances (container)\n\n    YANG Description: The L2, L3, or L2+L3 forwarding instances that are\nconfigured on the local system", "id": "f22068:c1:m2"}
{"signature": "def _set_interfaces(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=interfaces.interfaces,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interfaces = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interfaces, mapped from YANG variable /interfaces (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_interfaces is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_interfaces() directly.\n\n    YANG Description: Top level container for interfaces, including configuration\nand state data.", "id": "f22068:c6:m3"}
{"signature": "def _get_vlans(self):", "body": "return self.__vlans<EOL>", "docstring": "Getter method for vlans, mapped from YANG variable /vlans (container)\n\n    YANG Description: Container for VLAN configuration and state\nvariables", "id": "f22068:c11:m2"}
{"signature": "def _set_min_(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__min_ = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for min_, mapped from YANG variable /components/component/transceiver/physical_channels/channel/state/output_power/min (decimal64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_min_ is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_min_() directly.\n\n    YANG Description: The minimum value of the statistic over the sampling\nperiod", "id": "f22070:c0:m9"}
{"signature": "def _get_min_(self):", "body": "return self.__min_<EOL>", "docstring": "Getter method for min_, mapped from YANG variable /components/component/transceiver/physical_channels/channel/state/output_power/min (decimal64)\n\n    YANG Description: The minimum value of the statistic over the sampling\nperiod", "id": "f22070:c0:m8"}
{"signature": "def _set_tx_laser(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__tx_laser = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for tx_laser, mapped from YANG variable /components/component/transceiver/physical_channels/channel/state/tx_laser (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_tx_laser is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_tx_laser() directly.\n\n    YANG Description: Enable (true) or disable (false) the transmit label for the\nchannel", "id": "f22071:c0:m9"}
{"signature": "def _set_description(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:description>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__description = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for description, mapped from YANG variable /components/component/transceiver/physical_channels/channel/state/description (string)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_description is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_description() directly.\n\nYANG Description: Text description for the client physical channel", "id": "f22071:c0:m6"}
{"signature": "def _get_max_(self):", "body": "return self.__max_<EOL>", "docstring": "Getter method for max_, mapped from YANG variable /components/component/transceiver/physical_channels/channel/state/laser_bias_current/max (decimal64)\n\n    YANG Description: The maximum value of the statistic over the sampling\nperiod", "id": "f22072:c0:m11"}
{"signature": "def _set_instant(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__instant = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for instant, mapped from YANG variable /components/component/transceiver/physical_channels/channel/state/laser_bias_current/instant (decimal64)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_instant is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_instant() directly.\n\nYANG Description: The instantaneous value of the statistic.", "id": "f22072:c0:m3"}
{"signature": "def _set_max_(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__max_ = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for max_, mapped from YANG variable /components/component/transceiver/physical_channels/channel/state/input_power/max (decimal64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_max_ is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_max_() directly.\n\n    YANG Description: The maximum value of the statistic over the sampling\nperiod", "id": "f22073:c0:m12"}
{"signature": "def _get_instant(self):", "body": "return self.__instant<EOL>", "docstring": "Getter method for instant, mapped from YANG variable /components/component/transceiver/physical_channels/channel/state/input_power/instant (decimal64)\n\nYANG Description: The instantaneous value of the statistic.", "id": "f22073:c0:m2"}
{"signature": "def _set_instant(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__instant = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for instant, mapped from YANG variable /components/component/transceiver/physical_channels/channel/state/input_power/instant (decimal64)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_instant is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_instant() directly.\n\nYANG Description: The instantaneous value of the statistic.", "id": "f22073:c0:m3"}
{"signature": "def _get_index(self):", "body": "return self.__index<EOL>", "docstring": "Getter method for index, mapped from YANG variable /components/component/transceiver/physical_channels/channel/config/index (uint16)\n\n    YANG Description: Index of the physical channnel or lane within a physical\nclient port", "id": "f22074:c0:m2"}
{"signature": "def _set_tx_laser(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__tx_laser = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for tx_laser, mapped from YANG variable /components/component/transceiver/physical_channels/channel/config/tx_laser (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_tx_laser is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_tx_laser() directly.\n\n    YANG Description: Enable (true) or disable (false) the transmit label for the\nchannel", "id": "f22074:c0:m9"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /components/component/transceiver/physical_channels/channel/config (container)\n\nYANG Description: Configuration data for physical channels", "id": "f22075:c0:m5"}
{"signature": "def _get_ethernet_pmd_preconf(self):", "body": "return self.__ethernet_pmd_preconf<EOL>", "docstring": "Getter method for ethernet_pmd_preconf, mapped from YANG variable /components/component/transceiver/state/ethernet_pmd_preconf (identityref)\n\n    YANG Description: The Ethernet PMD is a property of the optical transceiver\nused on the port, indicating the type of physical connection.\nIt is included in configuration data to allow pre-configuring\na port/transceiver with the expected PMD.  The actual PMD is\nindicated by the ethernet-pmd state leaf.", "id": "f22076:c0:m8"}
{"signature": "def _get_form_factor_preconf(self):", "body": "return self.__form_factor_preconf<EOL>", "docstring": "Getter method for form_factor_preconf, mapped from YANG variable /components/component/transceiver/state/form_factor_preconf (identityref)\n\n    YANG Description: Indicates the type of optical transceiver used on this\nport.  If the client port is built into the device and not\npluggable, then non-pluggable is the corresponding state. If\na device port supports multiple form factors (e.g. QSFP28\nand QSFP+, then the value of the transceiver installed shall\nbe reported. If no transceiver is present, then the value of\nthe highest rate form factor shall be reported\n(QSFP28, for example).\n\nThe form factor is included in configuration data to allow\npre-configuring a device with the expected type of\ntransceiver ahead of deployment.  The corresponding state\nleaf should reflect the actual transceiver type plugged into\nthe system.", "id": "f22076:c0:m5"}
{"signature": "def _set_vendor_rev(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__vendor_rev = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for vendor_rev, mapped from YANG variable /components/component/transceiver/state/vendor_rev (string)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_vendor_rev is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_vendor_rev() directly.\n\n    YANG Description: Transceiver vendor's revision number. 2-octet field that\ncontains ASCII characters, left-aligned and padded on the\nright with ASCII spaces (20h)", "id": "f22076:c0:m30"}
{"signature": "def _set_connector_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__connector_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for connector_type, mapped from YANG variable /components/component/transceiver/state/connector_type (identityref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_connector_type is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_connector_type() directly.\n\nYANG Description: Connector type used on this port", "id": "f22076:c0:m18"}
{"signature": "def _get_vendor(self):", "body": "return self.__vendor<EOL>", "docstring": "Getter method for vendor, mapped from YANG variable /components/component/transceiver/state/vendor (string)\n\n    YANG Description: Full name of transceiver vendor. 16-octet field that\ncontains ASCII characters, left-aligned and padded on the\nright with ASCII spaces (20h)", "id": "f22076:c0:m23"}
{"signature": "def _get_form_factor(self):", "body": "return self.__form_factor<EOL>", "docstring": "Getter method for form_factor, mapped from YANG variable /components/component/transceiver/state/form_factor (identityref)\n\n    YANG Description: Indicates the type of optical transceiver used on this\nport.  If the client port is built into the device and not\npluggable, then non-pluggable is the corresponding state. If\na device port supports multiple form factors (e.g. QSFP28\nand QSFP+, then the value of the transceiver installed shall\nbe reported. If no transceiver is present, then the value of\nthe highest rate form factor shall be reported\n(QSFP28, for example).", "id": "f22076:c0:m14"}
{"signature": "def _get_otn_compliance_code(self):", "body": "return self.__otn_compliance_code<EOL>", "docstring": "Getter method for otn_compliance_code, mapped from YANG variable /components/component/transceiver/state/otn_compliance_code (identityref)\n\nYANG Description: OTN application code supported by the port", "id": "f22076:c0:m38"}
{"signature": "def _get_connector_type(self):", "body": "return self.__connector_type<EOL>", "docstring": "Getter method for connector_type, mapped from YANG variable /components/component/transceiver/state/connector_type (identityref)\n\nYANG Description: Connector type used on this port", "id": "f22076:c0:m17"}
{"signature": "def _set_present(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__present = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for present, mapped from YANG variable /components/component/transceiver/state/present (enumeration)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_present is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_present() directly.\n\n    YANG Description: Indicates whether a transceiver is present in\nthe specified client port.", "id": "f22076:c0:m12"}
{"signature": "def _set_vendor(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__vendor = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for vendor, mapped from YANG variable /components/component/transceiver/state/vendor (string)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_vendor is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_vendor() directly.\n\n    YANG Description: Full name of transceiver vendor. 16-octet field that\ncontains ASCII characters, left-aligned and padded on the\nright with ASCII spaces (20h)", "id": "f22076:c0:m24"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /components/component/transceiver/state/enabled (boolean)\n\n    YANG Description: Turns power on / off to the transceiver -- provides a means\nto power on/off the transceiver (in the case of SFP, SFP+,\nQSFP,...) or enable high-power mode (in the case of CFP,\nCFP2, CFP4) and is optionally supported (device can choose to\nalways enable).  True = power on / high power, False =\npowered off", "id": "f22076:c0:m2"}
{"signature": "def _get_date_code(self):", "body": "return self.__date_code<EOL>", "docstring": "Getter method for date_code, mapped from YANG variable /components/component/transceiver/state/date_code (yang:date-and-time)\n\n    YANG Description: Representation of the transceiver date code, typically\nstored as YYMMDD.  The time portion of the value is\nundefined and not intended to be read.", "id": "f22076:c0:m44"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /components/component/transceiver/config/enabled (boolean)\n\n    YANG Description: Turns power on / off to the transceiver -- provides a means\nto power on/off the transceiver (in the case of SFP, SFP+,\nQSFP,...) or enable high-power mode (in the case of CFP,\nCFP2, CFP4) and is optionally supported (device can choose to\nalways enable).  True = power on / high power, False =\npowered off", "id": "f22077:c0:m2"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /components/component/transceiver/config/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: Turns power on / off to the transceiver -- provides a means\nto power on/off the transceiver (in the case of SFP, SFP+,\nQSFP,...) or enable high-power mode (in the case of CFP,\nCFP2, CFP4) and is optionally supported (device can choose to\nalways enable).  True = power on / high power, False =\npowered off", "id": "f22077:c0:m3"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /components/component/transceiver/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration data for client port transceivers", "id": "f22078:c0:m3"}
{"signature": "def _get_type(self):", "body": "return self.__type<EOL>", "docstring": "Getter method for type, mapped from YANG variable /components/component/state/type (union)\n\nYANG Description: Type of component as identified by the system", "id": "f22079:c0:m5"}
{"signature": "def _get_mfg_name(self):", "body": "return self.__mfg_name<EOL>", "docstring": "Getter method for mfg_name, mapped from YANG variable /components/component/state/mfg_name (string)\n\n    YANG Description: System-supplied identifier for the manufacturer of the\ncomponent.  This data is particularly useful when a\ncomponent manufacturer is different than the overall\ndevice vendor.", "id": "f22079:c0:m14"}
{"signature": "def _get_serial_no(self):", "body": "return self.__serial_no<EOL>", "docstring": "Getter method for serial_no, mapped from YANG variable /components/component/state/serial_no (string)\n\nYANG Description: System-assigned serial number of the component.", "id": "f22079:c0:m20"}
{"signature": "def _set_name(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:name>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for name, mapped from YANG variable /components/component/state/name (string)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_name is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_name() directly.\n\n    YANG Description: Device name for the component -- this will not be a\nconfigurable parameter on many implementations", "id": "f22079:c0:m3"}
{"signature": "def _get_min_(self):", "body": "return self.__min_<EOL>", "docstring": "Getter method for min_, mapped from YANG variable /components/component/state/temperature/min (decimal64)\n\n    YANG Description: The minimum value of the statistic over the sampling\nperiod", "id": "f22080:c0:m8"}
{"signature": "def _set_instant(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:1>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__instant = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for instant, mapped from YANG variable /components/component/state/temperature/instant (decimal64)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_instant is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_instant() directly.\n\nYANG Description: The instantaneous value of the statistic.", "id": "f22080:c0:m3"}
{"signature": "def _set_value(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>six.text_type,<EOL>YANGBool,<EOL>RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": [\"<STR_LIT>\"]<EOL>},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:value>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__value = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for value, mapped from YANG variable /components/component/properties/property/state/value (union)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_value is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_value() directly.\n\n    YANG Description: Property values can take on a variety of types.  Signed and\nunsigned integer types may be provided in smaller sizes,\ne.g., int8, uint16, etc.", "id": "f22081:c0:m6"}
{"signature": "def _get_name(self):", "body": "return self.__name<EOL>", "docstring": "Getter method for name, mapped from YANG variable /components/component/properties/property/state/name (string)\n\n    YANG Description: System-supplied name of the property -- this is typically\nnon-configurable", "id": "f22081:c0:m2"}
{"signature": "def _set_configurable(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__configurable = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for configurable, mapped from YANG variable /components/component/properties/property/state/configurable (boolean)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_configurable is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_configurable() directly.\n\nYANG Description: Indication whether the property is user-configurable", "id": "f22081:c0:m9"}
{"signature": "def _get_value(self):", "body": "return self.__value<EOL>", "docstring": "Getter method for value, mapped from YANG variable /components/component/properties/property/state/value (union)\n\n    YANG Description: Property values can take on a variety of types.  Signed and\nunsigned integer types may be provided in smaller sizes,\ne.g., int8, uint16, etc.", "id": "f22081:c0:m5"}
{"signature": "def _set_value(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>six.text_type,<EOL>YANGBool,<EOL>RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": [\"<STR_LIT>\"]<EOL>},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:value>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__value = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for value, mapped from YANG variable /components/component/properties/property/config/value (union)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_value is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_value() directly.\n\n    YANG Description: Property values can take on a variety of types.  Signed and\nunsigned integer types may be provided in smaller sizes,\ne.g., int8, uint16, etc.", "id": "f22082:c0:m6"}
{"signature": "def _set_name(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:name>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for name, mapped from YANG variable /components/component/properties/property/config/name (string)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_name is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_name() directly.\n\n    YANG Description: System-supplied name of the property -- this is typically\nnon-configurable", "id": "f22082:c0:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /components/component/properties/property/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Operational state data for each property", "id": "f22083:c0:m9"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /components/component/properties/property/config (container)\n\nYANG Description: Configuration data for each property", "id": "f22083:c0:m5"}
{"signature": "def _set_property_(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT:name>\",<EOL>property_.property_,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT:name>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__property_ = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for property_, mapped from YANG variable /components/component/properties/property (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_property_ is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_property_() directly.\n\nYANG Description: List of system properties for the component", "id": "f22084:c0:m3"}
{"signature": "def _set_name(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:name>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for name, mapped from YANG variable /components/component/config/name (string)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_name is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_name() directly.\n\n    YANG Description: Device name for the component -- this will not be a\nconfigurable parameter on many implementations", "id": "f22085:c0:m3"}
{"signature": "def _get_transceiver(self):", "body": "return self.__transceiver<EOL>", "docstring": "Getter method for transceiver, mapped from YANG variable /components/component/transceiver (container)\n\nYANG Description: Top-level container for client port transceiver data", "id": "f22086:c0:m17"}
{"signature": "def _set_subcomponents(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=subcomponents.subcomponents,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subcomponents = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subcomponents, mapped from YANG variable /components/component/subcomponents (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_subcomponents is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_subcomponents() directly.\n\nYANG Description: Enclosing container for subcomponent references", "id": "f22086:c0:m15"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /components/component/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration data for each component", "id": "f22086:c0:m6"}
{"signature": "def _set_name(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:name>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for name, mapped from YANG variable /components/component/subcomponents/subcomponent/config/name (leafref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_name is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_name() directly.\n\nYANG Description: Reference to the name of the subcomponent", "id": "f22089:c0:m3"}
{"signature": "def _get_component(self):", "body": "return self.__component<EOL>", "docstring": "Getter method for component, mapped from YANG variable /components/component (list)\n\nYANG Description: List of components, keyed by component name.", "id": "f22091:c0:m2"}
{"signature": "def _get_default_export_policy(self):", "body": "return self.__default_export_policy<EOL>", "docstring": "Getter method for default_export_policy, mapped from YANG variable /network_instances/network_instance/inter_instance_policies/apply_policy/state/default_export_policy (default-policy-type)\n\n    YANG Description: explicitly set a default policy if no policy definition\nin the export policy chain is satisfied.", "id": "f22092:c0:m11"}
{"signature": "def _get_export_policy(self):", "body": "return self.__export_policy<EOL>", "docstring": "Getter method for export_policy, mapped from YANG variable /network_instances/network_instance/inter_instance_policies/apply_policy/state/export_policy (leafref)\n\n    YANG Description: list of policy names in sequence to be applied on\nsending a routing update in the current context, e.g.,\nfor the current peer group, neighbor, address family,\netc.", "id": "f22092:c1:m8"}
{"signature": "def _set_export_policy(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(allowed_type=six.text_type),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__export_policy = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for export_policy, mapped from YANG variable /network_instances/network_instance/inter_instance_policies/apply_policy/config/export_policy (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_export_policy is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_export_policy() directly.\n\n    YANG Description: list of policy names in sequence to be applied on\nsending a routing update in the current context, e.g.,\nfor the current peer group, neighbor, address family,\netc.", "id": "f22093:c1:m9"}
{"signature": "def _get_import_policy(self):", "body": "return self.__import_policy<EOL>", "docstring": "Getter method for import_policy, mapped from YANG variable /network_instances/network_instance/inter_instance_policies/apply_policy/config/import_policy (leafref)\n\n    YANG Description: list of policy names in sequence to be applied on\nreceiving a routing update in the current context, e.g.,\nfor the current peer group, neighbor, address family,\netc.", "id": "f22093:c1:m2"}
{"signature": "def _get_default_import_policy(self):", "body": "return self.__default_import_policy<EOL>", "docstring": "Getter method for default_import_policy, mapped from YANG variable /network_instances/network_instance/inter_instance_policies/apply_policy/config/default_import_policy (default-policy-type)\n\n    YANG Description: explicitly set a default policy if no policy definition\nin the import policy chain is satisfied.", "id": "f22093:c0:m5"}
{"signature": "def _get_default_export_policy(self):", "body": "return self.__default_export_policy<EOL>", "docstring": "Getter method for default_export_policy, mapped from YANG variable /network_instances/network_instance/inter_instance_policies/apply_policy/config/default_export_policy (default-policy-type)\n\n    YANG Description: explicitly set a default policy if no policy definition\nin the export policy chain is satisfied.", "id": "f22093:c0:m11"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/inter_instance_policies/apply_policy/config (container)\n\nYANG Description: Policy configuration data.", "id": "f22094:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/inter_instance_policies/apply_policy/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Operational state for routing policy", "id": "f22094:c1:m6"}
{"signature": "def _set_route_distinguisher(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__route_distinguisher = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for route_distinguisher, mapped from YANG variable /network_instances/network_instance/state/route_distinguisher (oc-ni-types:route-distinguisher)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_route_distinguisher is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_route_distinguisher() directly.\n\n    YANG Description: The route distinguisher that should be used for the local\nVRF or VSI instance when it is signalled via BGP.", "id": "f22096:c1:m18"}
{"signature": "def _set_enabled_address_families(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled_address_families = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled_address_families, mapped from YANG variable /network_instances/network_instance/state/enabled_address_families (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled_address_families is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled_address_families() directly.\n\n    YANG Description: The address families that are to be enabled for this\nnetwork instance.", "id": "f22096:c0:m21"}
{"signature": "def _set_mtu(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__mtu = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for mtu, mapped from YANG variable /network_instances/network_instance/state/mtu (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_mtu is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_mtu() directly.\n\n    YANG Description: The maximum frame size which should be supported for this\ninstance for Layer 2 frames", "id": "f22096:c0:m24"}
{"signature": "def _get_enabled_address_families(self):", "body": "return self.__enabled_address_families<EOL>", "docstring": "Getter method for enabled_address_families, mapped from YANG variable /network_instances/network_instance/state/enabled_address_families (identityref)\n\n    YANG Description: The address families that are to be enabled for this\nnetwork instance.", "id": "f22096:c0:m20"}
{"signature": "def _get_route_distinguisher(self):", "body": "return self.__route_distinguisher<EOL>", "docstring": "Getter method for route_distinguisher, mapped from YANG variable /network_instances/network_instance/state/route_distinguisher (oc-ni-types:route-distinguisher)\n\n    YANG Description: The route distinguisher that should be used for the local\nVRF or VSI instance when it is signalled via BGP.", "id": "f22096:c0:m17"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/state/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: Whether the network instance should be configured to be\nactive on the network element", "id": "f22096:c1:m9"}
{"signature": "def _get_type(self):", "body": "return self.__type<EOL>", "docstring": "Getter method for type, mapped from YANG variable /network_instances/network_instance/state/type (identityref)\n\n    YANG Description: The type of network instance. The value of this leaf\nindicates the type of forwarding entries that should be\nsupported by this network instance", "id": "f22096:c1:m5"}
{"signature": "def _set_mac_learning(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__mac_learning = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for mac_learning, mapped from YANG variable /network_instances/network_instance/fdb/state/mac_learning (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_mac_learning is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_mac_learning() directly.\n\n    YANG Description: When this leaf is set to true, MAC learning is enabled for\nthe network instance, such that MAC addresses are learned\nfrom ingress frames and added to the FDB.", "id": "f22097:c0:m3"}
{"signature": "def _set_maximum_entries(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__maximum_entries = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for maximum_entries, mapped from YANG variable /network_instances/network_instance/fdb/state/maximum_entries (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_maximum_entries is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_maximum_entries() directly.\n\n    YANG Description: The maximum number of MAC address entries that should be\naccepted into the FDB", "id": "f22097:c1:m9"}
{"signature": "def _get_mac_aging_time(self):", "body": "return self.__mac_aging_time<EOL>", "docstring": "Getter method for mac_aging_time, mapped from YANG variable /network_instances/network_instance/fdb/state/mac_aging_time (uint16)\n\n    YANG Description: The number of seconds of inactivity after which the entry\nin the local FDB is timed out.", "id": "f22097:c1:m5"}
{"signature": "def _set_mac_aging_time(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__mac_aging_time = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for mac_aging_time, mapped from YANG variable /network_instances/network_instance/fdb/state/mac_aging_time (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_mac_aging_time is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_mac_aging_time() directly.\n\n    YANG Description: The number of seconds of inactivity after which the entry\nin the local FDB is timed out.", "id": "f22097:c1:m6"}
{"signature": "def _set_entries(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=entries.entries,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__entries = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for entries, mapped from YANG variable /network_instances/network_instance/fdb/mac_table/entries (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_entries is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_entries() directly.\n\nYANG Description: Enclosing container for list of MAC table entries", "id": "f22098:c1:m3"}
{"signature": "def _get_entries(self):", "body": "return self.__entries<EOL>", "docstring": "Getter method for entries, mapped from YANG variable /network_instances/network_instance/fdb/mac_table/entries (container)\n\nYANG Description: Enclosing container for list of MAC table entries", "id": "f22098:c0:m2"}
{"signature": "def _set_entry_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__entry_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for entry_type, mapped from YANG variable /network_instances/network_instance/fdb/mac_table/entries/entry/state/entry_type (enumeration)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_entry_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_entry_type() directly.\n\n    YANG Description: Indicates whether the entry was statically configured, or\ndynamically learned.", "id": "f22099:c0:m12"}
{"signature": "def _get_subinterface(self):", "body": "return self.__subinterface<EOL>", "docstring": "Getter method for subinterface, mapped from YANG variable /network_instances/network_instance/fdb/mac_table/entries/entry/interface/interface_ref/state/subinterface (leafref)\n\n    YANG Description: Reference to a subinterface -- this requires the base\ninterface to be specified using the interface leaf in\nthis container.  If only a reference to a base interface\nis requuired, this leaf should not be set.", "id": "f22100:c0:m5"}
{"signature": "def _get_interface(self):", "body": "return self.__interface<EOL>", "docstring": "Getter method for interface, mapped from YANG variable /network_instances/network_instance/fdb/mac_table/entries/entry/interface/interface_ref/state/interface (leafref)\n\n    YANG Description: Reference to a base interface.  If a reference to a\nsubinterface is required, this leaf must be specified\nto indicate the base interface.", "id": "f22100:c1:m2"}
{"signature": "def _get_interface(self):", "body": "return self.__interface<EOL>", "docstring": "Getter method for interface, mapped from YANG variable /network_instances/network_instance/fdb/mac_table/entries/entry/interface/interface_ref/state/interface (leafref)\n\n    YANG Description: Reference to a base interface.  If a reference to a\nsubinterface is required, this leaf must be specified\nto indicate the base interface.", "id": "f22100:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/fdb/mac_table/entries/entry/interface/interface_ref/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Operational state for interface-ref", "id": "f22102:c1:m6"}
{"signature": "def _set_interface_ref(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=interface_ref.interface_ref,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface_ref = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface_ref, mapped from YANG variable /network_instances/network_instance/fdb/mac_table/entries/entry/interface/interface_ref (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_interface_ref is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_interface_ref() directly.\n\nYANG Description: Reference to an interface or subinterface", "id": "f22103:c1:m3"}
{"signature": "def _set_vlan(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__vlan = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for vlan, mapped from YANG variable /network_instances/network_instance/fdb/mac_table/entries/entry/config/vlan (leafref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_vlan is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_vlan() directly.\n\nYANG Description: VLAN from which this MAC address was received", "id": "f22104:c1:m6"}
{"signature": "def _get_mac_address(self):", "body": "return self.__mac_address<EOL>", "docstring": "Getter method for mac_address, mapped from YANG variable /network_instances/network_instance/fdb/mac_table/entries/entry/config/mac_address (yang:mac-address)\n\n    YANG Description: MAC address for the dynamic or static MAC table\nentry", "id": "f22104:c1:m2"}
{"signature": "def _get_vlan(self):", "body": "return self.__vlan<EOL>", "docstring": "Getter method for vlan, mapped from YANG variable /network_instances/network_instance/fdb/mac_table/entries/entry/config/vlan (leafref)\n\nYANG Description: VLAN from which this MAC address was received", "id": "f22104:c1:m5"}
{"signature": "def _get_interface(self):", "body": "return self.__interface<EOL>", "docstring": "Getter method for interface, mapped from YANG variable /network_instances/network_instance/fdb/mac_table/entries/entry/interface (container)\n\n    YANG Description: Reference to the base and/or subinterface for the\nMAC table entry", "id": "f22105:c0:m11"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/fdb/mac_table/entries/entry/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration data for MAC table entries", "id": "f22105:c0:m6"}
{"signature": "def _get_mac_address(self):", "body": "return self.__mac_address<EOL>", "docstring": "Getter method for mac_address, mapped from YANG variable /network_instances/network_instance/fdb/mac_table/entries/entry/mac_address (leafref)\n\nYANG Description: Reference to mac-address list key", "id": "f22105:c1:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/fdb/mac_table/entries/entry/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Operational state data for MAC table entries", "id": "f22105:c1:m9"}
{"signature": "def _get_interface(self):", "body": "return self.__interface<EOL>", "docstring": "Getter method for interface, mapped from YANG variable /network_instances/network_instance/fdb/mac_table/entries/entry/interface (container)\n\n    YANG Description: Reference to the base and/or subinterface for the\nMAC table entry", "id": "f22105:c1:m11"}
{"signature": "def _set_entry(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>entry.entry,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__entry = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for entry, mapped from YANG variable /network_instances/network_instance/fdb/mac_table/entries/entry (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_entry is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_entry() directly.\n\nYANG Description: List of learned MAC addresses", "id": "f22106:c0:m3"}
{"signature": "def _get_entry(self):", "body": "return self.__entry<EOL>", "docstring": "Getter method for entry, mapped from YANG variable /network_instances/network_instance/fdb/mac_table/entries/entry (list)\n\nYANG Description: List of learned MAC addresses", "id": "f22106:c0:m2"}
{"signature": "def _set_maximum_entries(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__maximum_entries = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for maximum_entries, mapped from YANG variable /network_instances/network_instance/fdb/config/maximum_entries (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_maximum_entries is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_maximum_entries() directly.\n\n    YANG Description: The maximum number of MAC address entries that should be\naccepted into the FDB", "id": "f22107:c1:m9"}
{"signature": "def _get_mac_learning(self):", "body": "return self.__mac_learning<EOL>", "docstring": "Getter method for mac_learning, mapped from YANG variable /network_instances/network_instance/fdb/config/mac_learning (boolean)\n\n    YANG Description: When this leaf is set to true, MAC learning is enabled for\nthe network instance, such that MAC addresses are learned\nfrom ingress frames and added to the FDB.", "id": "f22107:c0:m2"}
{"signature": "def _set_maximum_entries(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__maximum_entries = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for maximum_entries, mapped from YANG variable /network_instances/network_instance/fdb/config/maximum_entries (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_maximum_entries is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_maximum_entries() directly.\n\n    YANG Description: The maximum number of MAC address entries that should be\naccepted into the FDB", "id": "f22107:c0:m9"}
{"signature": "def _get_mac_aging_time(self):", "body": "return self.__mac_aging_time<EOL>", "docstring": "Getter method for mac_aging_time, mapped from YANG variable /network_instances/network_instance/fdb/config/mac_aging_time (uint16)\n\n    YANG Description: The number of seconds of inactivity after which the entry\nin the local FDB is timed out.", "id": "f22107:c1:m5"}
{"signature": "def _get_mac_learning(self):", "body": "return self.__mac_learning<EOL>", "docstring": "Getter method for mac_learning, mapped from YANG variable /network_instances/network_instance/fdb/config/mac_learning (boolean)\n\n    YANG Description: When this leaf is set to true, MAC learning is enabled for\nthe network instance, such that MAC addresses are learned\nfrom ingress frames and added to the FDB.", "id": "f22107:c1:m2"}
{"signature": "def _get_maximum_entries(self):", "body": "return self.__maximum_entries<EOL>", "docstring": "Getter method for maximum_entries, mapped from YANG variable /network_instances/network_instance/fdb/config/maximum_entries (uint16)\n\n    YANG Description: The maximum number of MAC address entries that should be\naccepted into the FDB", "id": "f22107:c0:m8"}
{"signature": "def _set_mac_aging_time(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__mac_aging_time = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for mac_aging_time, mapped from YANG variable /network_instances/network_instance/fdb/config/mac_aging_time (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_mac_aging_time is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_mac_aging_time() directly.\n\n    YANG Description: The number of seconds of inactivity after which the entry\nin the local FDB is timed out.", "id": "f22107:c0:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/fdb/state (container)\n\nYANG Description: Operational state parameters relating to the FDB", "id": "f22108:c1:m5"}
{"signature": "def _set_mac_table(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=mac_table.mac_table,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__mac_table = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for mac_table, mapped from YANG variable /network_instances/network_instance/fdb/mac_table (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_mac_table is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_mac_table() directly.\n\n    YANG Description: Table of learned or statically configured MAC addresses and\ncorresponding VLANs in the bridge domain", "id": "f22108:c1:m9"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/fdb/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Operational state parameters relating to the FDB", "id": "f22108:c0:m6"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/fdb/config (container)\n\nYANG Description: Configuration parameters relating to the FDB", "id": "f22108:c1:m2"}
{"signature": "def _set_mac_table(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=mac_table.mac_table,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__mac_table = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for mac_table, mapped from YANG variable /network_instances/network_instance/fdb/mac_table (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_mac_table is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_mac_table() directly.\n\n    YANG Description: Table of learned or statically configured MAC addresses and\ncorresponding VLANs in the bridge domain", "id": "f22108:c0:m9"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/afts/aft/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Operational state parameters relating to the AFT.", "id": "f22111:c1:m9"}
{"signature": "def _get_address_family(self):", "body": "return self.__address_family<EOL>", "docstring": "Getter method for address_family, mapped from YANG variable /network_instances/network_instance/afts/aft/address_family (leafref)\n\n    YANG Description: Reference to the address family with which the AFT is\nassociated", "id": "f22111:c0:m2"}
{"signature": "def _get_octets_forwarded(self):", "body": "return self.__octets_forwarded<EOL>", "docstring": "Getter method for octets_forwarded, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/state/octets_forwarded (yang:counter64)\n\n    YANG Description: The number of octets which have matched, and been forwarded,\nbased on the AFT entry", "id": "f22112:c0:m8"}
{"signature": "def _set_index(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:index>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__index = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for index, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/state/index (uint64)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_index is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_index() directly.\n\nYANG Description: A unique index referring to the AFT entry", "id": "f22112:c0:m3"}
{"signature": "def _set_index(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:index>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__index = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for index, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/config/index (uint64)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_index is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_index() directly.\n\nYANG Description: A unique index referring to the AFT entry", "id": "f22113:c1:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: Operational state parameters relating to the forwarding\nentry", "id": "f22114:c0:m9"}
{"signature": "def _get_index(self):", "body": "return self.__index<EOL>", "docstring": "Getter method for index, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/index (leafref)\n\n    YANG Description: A pointer to the index of the AFT entry within the\nnetwork instance", "id": "f22114:c1:m2"}
{"signature": "def _set_next_hops(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=next_hops.next_hops,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__next_hops = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for next_hops, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/next_hops (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_next_hops is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_next_hops() directly.\n\n    YANG Description: Enclosing container for the list of next-hops associated\nwith the forwarding entry", "id": "f22114:c0:m15"}
{"signature": "def _set_mac_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__mac_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for mac_address, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/next_hops/next_hop/state/mac_address (yang:mac-address)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_mac_address is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_mac_address() directly.\n\n    YANG Description: The MAC address of the next-hop if resolved by the local\nnetwork instance.", "id": "f22116:c1:m12"}
{"signature": "def _set_weight(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__weight = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for weight, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/next_hops/next_hop/state/weight (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_weight is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_weight() directly.\n\n    YANG Description: The weight of the next-hop. Traffic is balanced according to\nthe ratio described by the relative weights of the next hops\nthat exist for the AFT entry. Note that all next-hops that are\nspecified are assumed to be active next-hops and therefore\neligible (and selected) to be installed in the FIB, and hence\nused for packet forwarding.", "id": "f22116:c0:m6"}
{"signature": "def _set_origin_protocol(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__origin_protocol = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for origin_protocol, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/next_hops/next_hop/state/origin_protocol (identityref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_origin_protocol is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_origin_protocol() directly.\n\nYANG Description: The protocol from which the AFT entry was learned.", "id": "f22116:c0:m27"}
{"signature": "def _set_origin_protocol(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__origin_protocol = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for origin_protocol, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/next_hops/next_hop/state/origin_protocol (identityref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_origin_protocol is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_origin_protocol() directly.\n\nYANG Description: The protocol from which the AFT entry was learned.", "id": "f22116:c1:m27"}
{"signature": "def _get_mac_address(self):", "body": "return self.__mac_address<EOL>", "docstring": "Getter method for mac_address, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/next_hops/next_hop/state/mac_address (yang:mac-address)\n\n    YANG Description: The MAC address of the next-hop if resolved by the local\nnetwork instance.", "id": "f22116:c1:m11"}
{"signature": "def _set_popped_mpls_label_stack(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=[<EOL>RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:0>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:1>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:2>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:3>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:7>},<EOL>\"<STR_LIT>\": {},<EOL>},<EOL>),<EOL>]<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__popped_mpls_label_stack = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for popped_mpls_label_stack, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/next_hops/next_hop/state/popped_mpls_label_stack (oc-mplst:mpls-label)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_popped_mpls_label_stack is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_popped_mpls_label_stack() directly.\n\n    YANG Description: The MPLS label stack to be popped from the packet when\nswitched by the system. The stack is encoding as a leaf-list\nwhereby the other of the entries is such that the first entry\nis the label lowest down the label stack to be popped.\n\nIf the local system pops the outer-most label 400, then the\nvalue of this list is [400,]. If the local system removes two\nlabels, the outer-most being 500, and the second of which is\n500, then the value of the list is [500, 400].\n\nA swap operation is reflected by entries in the\npopped-mpls-label-stack and pushed-mpls-label-stack nodes.", "id": "f22116:c0:m15"}
{"signature": "def _get_index(self):", "body": "return self.__index<EOL>", "docstring": "Getter method for index, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/next_hops/next_hop/config/index (uint64)\n\nYANG Description: A unique entry for the next-hop", "id": "f22117:c1:m2"}
{"signature": "def _get_index(self):", "body": "return self.__index<EOL>", "docstring": "Getter method for index, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/next_hops/next_hop/config/index (uint64)\n\nYANG Description: A unique entry for the next-hop", "id": "f22117:c0:m2"}
{"signature": "def _set_index(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:index>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__index = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for index, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/next_hops/next_hop/config/index (uint64)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_index is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_index() directly.\n\nYANG Description: A unique entry for the next-hop", "id": "f22117:c0:m3"}
{"signature": "def _get_subinterface(self):", "body": "return self.__subinterface<EOL>", "docstring": "Getter method for subinterface, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/next_hops/next_hop/interface_ref/state/subinterface (leafref)\n\n    YANG Description: Reference to a subinterface -- this requires the base\ninterface to be specified using the interface leaf in\nthis container.  If only a reference to a base interface\nis requuired, this leaf should not be set.", "id": "f22118:c0:m5"}
{"signature": "def _get_subinterface(self):", "body": "return self.__subinterface<EOL>", "docstring": "Getter method for subinterface, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/next_hops/next_hop/interface_ref/state/subinterface (leafref)\n\n    YANG Description: Reference to a subinterface -- this requires the base\ninterface to be specified using the interface leaf in\nthis container.  If only a reference to a base interface\nis requuired, this leaf should not be set.", "id": "f22118:c1:m5"}
{"signature": "def _set_subinterface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subinterface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subinterface, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/next_hops/next_hop/interface_ref/state/subinterface (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subinterface is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subinterface() directly.\n\n    YANG Description: Reference to a subinterface -- this requires the base\ninterface to be specified using the interface leaf in\nthis container.  If only a reference to a base interface\nis requuired, this leaf should not be set.", "id": "f22118:c0:m6"}
{"signature": "def _set_interface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/next_hops/next_hop/interface_ref/state/interface (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_interface is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_interface() directly.\n\n    YANG Description: Reference to a base interface.  If a reference to a\nsubinterface is required, this leaf must be specified\nto indicate the base interface.", "id": "f22118:c1:m3"}
{"signature": "def _get_interface(self):", "body": "return self.__interface<EOL>", "docstring": "Getter method for interface, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/next_hops/next_hop/interface_ref/state/interface (leafref)\n\n    YANG Description: Reference to a base interface.  If a reference to a\nsubinterface is required, this leaf must be specified\nto indicate the base interface.", "id": "f22118:c0:m2"}
{"signature": "def _set_interface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/next_hops/next_hop/interface_ref/config/interface (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_interface is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_interface() directly.\n\n    YANG Description: Reference to a base interface.  If a reference to a\nsubinterface is required, this leaf must be specified\nto indicate the base interface.", "id": "f22119:c0:m3"}
{"signature": "def _set_subinterface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subinterface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subinterface, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/next_hops/next_hop/interface_ref/config/subinterface (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subinterface is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subinterface() directly.\n\n    YANG Description: Reference to a subinterface -- this requires the base\ninterface to be specified using the interface leaf in\nthis container.  If only a reference to a base interface\nis requuired, this leaf should not be set.", "id": "f22119:c0:m6"}
{"signature": "def _set_interface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/next_hops/next_hop/interface_ref/config/interface (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_interface is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_interface() directly.\n\n    YANG Description: Reference to a base interface.  If a reference to a\nsubinterface is required, this leaf must be specified\nto indicate the base interface.", "id": "f22119:c1:m3"}
{"signature": "def _get_interface(self):", "body": "return self.__interface<EOL>", "docstring": "Getter method for interface, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/next_hops/next_hop/interface_ref/config/interface (leafref)\n\n    YANG Description: Reference to a base interface.  If a reference to a\nsubinterface is required, this leaf must be specified\nto indicate the base interface.", "id": "f22119:c0:m2"}
{"signature": "def _get_interface(self):", "body": "return self.__interface<EOL>", "docstring": "Getter method for interface, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/next_hops/next_hop/interface_ref/config/interface (leafref)\n\n    YANG Description: Reference to a base interface.  If a reference to a\nsubinterface is required, this leaf must be specified\nto indicate the base interface.", "id": "f22119:c1:m2"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/next_hops/next_hop/interface_ref/config (container)\n\nYANG Description: Configured reference to interface / subinterface", "id": "f22120:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/next_hops/next_hop/interface_ref/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Operational state for interface-ref", "id": "f22120:c1:m6"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/next_hops/next_hop/interface_ref/config (container)\n\nYANG Description: Configured reference to interface / subinterface", "id": "f22120:c1:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/next_hops/next_hop/interface_ref/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Operational state for interface-ref", "id": "f22120:c0:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/next_hops/next_hop/interface_ref/state (container)\n\nYANG Description: Operational state for interface-ref", "id": "f22120:c0:m5"}
{"signature": "def _set_interface_ref(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=interface_ref.interface_ref,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface_ref = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface_ref, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/next_hops/next_hop/interface_ref (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_interface_ref is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_interface_ref() directly.\n\nYANG Description: Reference to an interface or subinterface", "id": "f22121:c0:m12"}
{"signature": "def _get_interface_ref(self):", "body": "return self.__interface_ref<EOL>", "docstring": "Getter method for interface_ref, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/next_hops/next_hop/interface_ref (container)\n\nYANG Description: Reference to an interface or subinterface", "id": "f22121:c1:m11"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/next_hops/next_hop/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to the AFT next-hop\nentry", "id": "f22121:c0:m6"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/next_hops/next_hop/config (container)\n\n    YANG Description: Configuration parameters relating to the AFT next-hop\nentry", "id": "f22121:c0:m5"}
{"signature": "def _set_index(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:index>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__index = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for index, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/next_hops/next_hop/index (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_index is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_index() directly.\n\n    YANG Description: A unique index identifying the next-hop entry for the\nAFT entry", "id": "f22121:c1:m3"}
{"signature": "def _get_index(self):", "body": "return self.__index<EOL>", "docstring": "Getter method for index, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/next_hops/next_hop/index (leafref)\n\n    YANG Description: A unique index identifying the next-hop entry for the\nAFT entry", "id": "f22121:c0:m2"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/next_hops/next_hop/config (container)\n\n    YANG Description: Configuration parameters relating to the AFT next-hop\nentry", "id": "f22121:c1:m5"}
{"signature": "def _set_l4_dst_port(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:16>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__l4_dst_port = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for l4_dst_port, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/match/state/l4_dst_port (inet:port-number)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_l4_dst_port is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_l4_dst_port() directly.\n\n    YANG Description: The value of the destination port field of the transport\nheader that is to be matched by the AFT entry.", "id": "f22122:c0:m24"}
{"signature": "def _set_l4_src_port(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:16>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__l4_src_port = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for l4_src_port, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/match/state/l4_src_port (inet:port-number)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_l4_src_port is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_l4_src_port() directly.\n\n    YANG Description: The value of the source port field of the transport header\nthat is to be matched by the AFT entry.", "id": "f22122:c0:m21"}
{"signature": "def _get_l4_dst_port(self):", "body": "return self.__l4_dst_port<EOL>", "docstring": "Getter method for l4_dst_port, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/match/state/l4_dst_port (inet:port-number)\n\n    YANG Description: The value of the destination port field of the transport\nheader that is to be matched by the AFT entry.", "id": "f22122:c1:m23"}
{"signature": "def _get_mpls_label(self):", "body": "return self.__mpls_label<EOL>", "docstring": "Getter method for mpls_label, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/match/state/mpls_label (oc-mplst:mpls-label)\n\n    YANG Description: The MPLS label that the forwarding entry matches. Used for\nMPLS forwarding entries, whereby the local device acts as an\nLSR.", "id": "f22122:c0:m8"}
{"signature": "def _set_ip_dscp(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ip_dscp = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ip_dscp, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/match/state/ip_dscp (inet:dscp)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_ip_dscp is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_ip_dscp() directly.\n\n    YANG Description: The value of the differentiated services code point (DSCP) to\nbe matched for the forwarding entry. The value is specified in\ncases where specific class-based forwarding based on IP is\nimplemented by the device.", "id": "f22122:c0:m15"}
{"signature": "def _set_mpls_tc(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__mpls_tc = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for mpls_tc, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/match/state/mpls_tc (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_mpls_tc is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_mpls_tc() directly.\n\n    YANG Description: The value of the MPLS Traffic Class bits (formerly known as\nthe MPLS experimental bits) that are to be matched by the AFT\nentry.", "id": "f22122:c1:m12"}
{"signature": "def _get_l4_src_port(self):", "body": "return self.__l4_src_port<EOL>", "docstring": "Getter method for l4_src_port, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/match/state/l4_src_port (inet:port-number)\n\n    YANG Description: The value of the source port field of the transport header\nthat is to be matched by the AFT entry.", "id": "f22122:c0:m20"}
{"signature": "def _set_interface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/match/interface_ref/state/interface (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_interface is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_interface() directly.\n\n    YANG Description: Reference to a base interface.  If a reference to a\nsubinterface is required, this leaf must be specified\nto indicate the base interface.", "id": "f22123:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/match/interface_ref/state (container)\n\nYANG Description: Operational state for interface-ref", "id": "f22124:c1:m2"}
{"signature": "def _get_interface_ref(self):", "body": "return self.__interface_ref<EOL>", "docstring": "Getter method for interface_ref, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/match/interface_ref (container)\n\nYANG Description: Reference to an interface or subinterface", "id": "f22125:c1:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry/match/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: Operational state parameters for match criteria of the\nAFT entry", "id": "f22125:c0:m3"}
{"signature": "def _get_entry(self):", "body": "return self.__entry<EOL>", "docstring": "Getter method for entry, mapped from YANG variable /network_instances/network_instance/afts/aft/entries/entry (list)\n\nYANG Description: A forwarding database entry within the network instance", "id": "f22126:c0:m2"}
{"signature": "def _get_status(self):", "body": "return self.__status<EOL>", "docstring": "Getter method for status, mapped from YANG variable /network_instances/network_instance/vlans/vlan/state/status (enumeration)\n\nYANG Description: Admin state of the VLAN", "id": "f22128:c1:m8"}
{"signature": "def _set_tpid(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>default=six.text_type(\"<STR_LIT>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__tpid = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for tpid, mapped from YANG variable /network_instances/network_instance/vlans/vlan/state/tpid (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_tpid is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_tpid() directly.\n\n    YANG Description: Optionally set the tag protocol identifier field (TPID) that\nis accepted on the VLAN", "id": "f22128:c1:m12"}
{"signature": "def _set_name(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:name>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for name, mapped from YANG variable /network_instances/network_instance/vlans/vlan/state/name (string)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_name is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_name() directly.\n\nYANG Description: Interface VLAN name.", "id": "f22128:c0:m6"}
{"signature": "def _get_vlan_id(self):", "body": "return self.__vlan_id<EOL>", "docstring": "Getter method for vlan_id, mapped from YANG variable /network_instances/network_instance/vlans/vlan/state/vlan_id (oc-vlan-types:vlan-id)\n\nYANG Description: Interface VLAN id.", "id": "f22128:c1:m2"}
{"signature": "def _get_tpid(self):", "body": "return self.__tpid<EOL>", "docstring": "Getter method for tpid, mapped from YANG variable /network_instances/network_instance/vlans/vlan/state/tpid (identityref)\n\n    YANG Description: Optionally set the tag protocol identifier field (TPID) that\nis accepted on the VLAN", "id": "f22128:c0:m11"}
{"signature": "def _set_status(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>default=six.text_type(\"<STR_LIT>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:status>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__status = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for status, mapped from YANG variable /network_instances/network_instance/vlans/vlan/state/status (enumeration)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_status is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_status() directly.\n\nYANG Description: Admin state of the VLAN", "id": "f22128:c0:m9"}
{"signature": "def _set_subinterface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subinterface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subinterface, mapped from YANG variable /network_instances/network_instance/vlans/vlan/members/member/interface_ref/state/subinterface (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subinterface is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subinterface() directly.\n\n    YANG Description: Reference to a subinterface -- this requires the base\ninterface to be specified using the interface leaf in\nthis container.  If only a reference to a base interface\nis requuired, this leaf should not be set.", "id": "f22129:c1:m6"}
{"signature": "def _get_subinterface(self):", "body": "return self.__subinterface<EOL>", "docstring": "Getter method for subinterface, mapped from YANG variable /network_instances/network_instance/vlans/vlan/members/member/interface_ref/state/subinterface (leafref)\n\n    YANG Description: Reference to a subinterface -- this requires the base\ninterface to be specified using the interface leaf in\nthis container.  If only a reference to a base interface\nis requuired, this leaf should not be set.", "id": "f22129:c1:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/vlans/vlan/members/member/interface_ref/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Operational state for interface-ref", "id": "f22130:c0:m3"}
{"signature": "def _get_interface_ref(self):", "body": "return self.__interface_ref<EOL>", "docstring": "Getter method for interface_ref, mapped from YANG variable /network_instances/network_instance/vlans/vlan/members/member/interface_ref (container)\n\nYANG Description: Reference to an interface or subinterface", "id": "f22131:c0:m2"}
{"signature": "def _get_member(self):", "body": "return self.__member<EOL>", "docstring": "Getter method for member, mapped from YANG variable /network_instances/network_instance/vlans/vlan/members/member (list)\n\n    YANG Description: List of references to interfaces / subinterfaces\nassociated with the VLAN.", "id": "f22132:c1:m2"}
{"signature": "def _set_name(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:name>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for name, mapped from YANG variable /network_instances/network_instance/vlans/vlan/config/name (string)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_name is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_name() directly.\n\nYANG Description: Interface VLAN name.", "id": "f22133:c1:m6"}
{"signature": "def _set_name(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:name>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for name, mapped from YANG variable /network_instances/network_instance/vlans/vlan/config/name (string)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_name is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_name() directly.\n\nYANG Description: Interface VLAN name.", "id": "f22133:c0:m6"}
{"signature": "def _get_vlan_id(self):", "body": "return self.__vlan_id<EOL>", "docstring": "Getter method for vlan_id, mapped from YANG variable /network_instances/network_instance/vlans/vlan/vlan_id (leafref)\n\nYANG Description: references the configured vlan-id", "id": "f22134:c0:m2"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/vlans/vlan/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration parameters for VLANs", "id": "f22134:c1:m6"}
{"signature": "def _set_vlan_id(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__vlan_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for vlan_id, mapped from YANG variable /network_instances/network_instance/vlans/vlan/vlan_id (leafref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_vlan_id is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_vlan_id() directly.\n\nYANG Description: references the configured vlan-id", "id": "f22134:c0:m3"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/vlans/vlan/config (container)\n\nYANG Description: Configuration parameters for VLANs", "id": "f22134:c1:m5"}
{"signature": "def _set_vlan(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>vlan.vlan,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__vlan = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for vlan, mapped from YANG variable /network_instances/network_instance/vlans/vlan (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_vlan is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_vlan() directly.\n\nYANG Description: Configured VLANs keyed by id", "id": "f22135:c1:m3"}
{"signature": "def _get_vlan(self):", "body": "return self.__vlan<EOL>", "docstring": "Getter method for vlan, mapped from YANG variable /network_instances/network_instance/vlans/vlan (list)\n\nYANG Description: Configured VLANs keyed by id", "id": "f22135:c1:m2"}
{"signature": "def _set_control_word(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__control_word = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for control_word, mapped from YANG variable /network_instances/network_instance/encapsulation/state/control_word (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_control_word is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_control_word() directly.\n\n    YANG Description: Whether the control-word should be used for the network\ninstance", "id": "f22136:c1:m9"}
{"signature": "def _get_label_allocation_mode(self):", "body": "return self.__label_allocation_mode<EOL>", "docstring": "Getter method for label_allocation_mode, mapped from YANG variable /network_instances/network_instance/encapsulation/state/label_allocation_mode (identityref)\n\n    YANG Description: The label allocation mode to be used for L3 entries\nin the network instance", "id": "f22136:c0:m5"}
{"signature": "def _get_label_allocation_mode(self):", "body": "return self.__label_allocation_mode<EOL>", "docstring": "Getter method for label_allocation_mode, mapped from YANG variable /network_instances/network_instance/encapsulation/config/label_allocation_mode (identityref)\n\n    YANG Description: The label allocation mode to be used for L3 entries\nin the network instance", "id": "f22137:c1:m5"}
{"signature": "def _get_label_allocation_mode(self):", "body": "return self.__label_allocation_mode<EOL>", "docstring": "Getter method for label_allocation_mode, mapped from YANG variable /network_instances/network_instance/encapsulation/config/label_allocation_mode (identityref)\n\n    YANG Description: The label allocation mode to be used for L3 entries\nin the network instance", "id": "f22137:c0:m5"}
{"signature": "def _set_encapsulation_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__encapsulation_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for encapsulation_type, mapped from YANG variable /network_instances/network_instance/encapsulation/config/encapsulation_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_encapsulation_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_encapsulation_type() directly.\n\n    YANG Description: The on-the-wire encapsulation that should be used when\nsending traffic from this network instance", "id": "f22137:c1:m3"}
{"signature": "def _set_control_word(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__control_word = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for control_word, mapped from YANG variable /network_instances/network_instance/encapsulation/config/control_word (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_control_word is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_control_word() directly.\n\n    YANG Description: Whether the control-word should be used for the network\ninstance", "id": "f22137:c1:m9"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/encapsulation/config (container)\n\n    YANG Description: Configuration parameters relating to the encapsulation\nof the network instance", "id": "f22138:c1:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/encapsulation/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: State parameters relating to the encapsulation of\nthe network instance", "id": "f22138:c1:m6"}
{"signature": "def _set_table_connection(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>table_connection.table_connection,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__table_connection = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for table_connection, mapped from YANG variable /network_instances/network_instance/table_connections/table_connection (list)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_table_connection is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_table_connection() directly.\n\n    YANG Description: A list of connections between pairs of routing or\nforwarding tables, the leaking of entries between\nwhich is specified by the import policy.\n\nA connection connecting a source table to a destination\ntable implies that routes that match the policy specified\nfor the connection are available for the destination\nprotocol to advertise, or match within its policies.", "id": "f22139:c1:m3"}
{"signature": "def _set_dst_protocol(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__dst_protocol = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for dst_protocol, mapped from YANG variable /network_instances/network_instance/table_connections/table_connection/state/dst_protocol (leafref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_dst_protocol is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_dst_protocol() directly.\n\nYANG Description: The destination protocol for the table connection", "id": "f22140:c0:m9"}
{"signature": "def _set_dst_protocol(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__dst_protocol = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for dst_protocol, mapped from YANG variable /network_instances/network_instance/table_connections/table_connection/state/dst_protocol (leafref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_dst_protocol is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_dst_protocol() directly.\n\nYANG Description: The destination protocol for the table connection", "id": "f22140:c1:m9"}
{"signature": "def _get_src_protocol(self):", "body": "return self.__src_protocol<EOL>", "docstring": "Getter method for src_protocol, mapped from YANG variable /network_instances/network_instance/table_connections/table_connection/state/src_protocol (leafref)\n\nYANG Description: The source protocol for the table connection", "id": "f22140:c1:m2"}
{"signature": "def _set_import_policy(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(allowed_type=six.text_type),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__import_policy = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for import_policy, mapped from YANG variable /network_instances/network_instance/table_connections/table_connection/state/import_policy (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_import_policy is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_import_policy() directly.\n\n    YANG Description: list of policy names in sequence to be applied on\nreceiving a routing update in the current context, e.g.,\nfor the current peer group, neighbor, address family,\netc.", "id": "f22140:c0:m12"}
{"signature": "def _set_address_family(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__address_family = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for address_family, mapped from YANG variable /network_instances/network_instance/table_connections/table_connection/state/address_family (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_address_family is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_address_family() directly.\n\n    YANG Description: The address family associated with the connection. This\nmust be defined for the source protocol. The target\naddress family is implicitly defined by the address family\nspecified for the source protocol.", "id": "f22140:c1:m6"}
{"signature": "def _get_dst_protocol(self):", "body": "return self.__dst_protocol<EOL>", "docstring": "Getter method for dst_protocol, mapped from YANG variable /network_instances/network_instance/table_connections/table_connection/state/dst_protocol (leafref)\n\nYANG Description: The destination protocol for the table connection", "id": "f22140:c0:m8"}
{"signature": "def _get_address_family(self):", "body": "return self.__address_family<EOL>", "docstring": "Getter method for address_family, mapped from YANG variable /network_instances/network_instance/table_connections/table_connection/state/address_family (leafref)\n\n    YANG Description: The address family associated with the connection. This\nmust be defined for the source protocol. The target\naddress family is implicitly defined by the address family\nspecified for the source protocol.", "id": "f22140:c1:m5"}
{"signature": "def _get_dst_protocol(self):", "body": "return self.__dst_protocol<EOL>", "docstring": "Getter method for dst_protocol, mapped from YANG variable /network_instances/network_instance/table_connections/table_connection/state/dst_protocol (leafref)\n\nYANG Description: The destination protocol for the table connection", "id": "f22140:c1:m8"}
{"signature": "def _set_address_family(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__address_family = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for address_family, mapped from YANG variable /network_instances/network_instance/table_connections/table_connection/state/address_family (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_address_family is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_address_family() directly.\n\n    YANG Description: The address family associated with the connection. This\nmust be defined for the source protocol. The target\naddress family is implicitly defined by the address family\nspecified for the source protocol.", "id": "f22140:c0:m6"}
{"signature": "def _get_dst_protocol(self):", "body": "return self.__dst_protocol<EOL>", "docstring": "Getter method for dst_protocol, mapped from YANG variable /network_instances/network_instance/table_connections/table_connection/config/dst_protocol (leafref)\n\nYANG Description: The destination protocol for the table connection", "id": "f22141:c1:m8"}
{"signature": "def _set_default_import_policy(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>default=six.text_type(\"<STR_LIT>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__default_import_policy = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for default_import_policy, mapped from YANG variable /network_instances/network_instance/table_connections/table_connection/config/default_import_policy (default-policy-type)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_default_import_policy is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_default_import_policy() directly.\n\n    YANG Description: explicitly set a default policy if no policy definition\nin the import policy chain is satisfied.", "id": "f22141:c0:m15"}
{"signature": "def _set_src_protocol(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__src_protocol = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for src_protocol, mapped from YANG variable /network_instances/network_instance/table_connections/table_connection/config/src_protocol (leafref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_src_protocol is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_src_protocol() directly.\n\nYANG Description: The source protocol for the table connection", "id": "f22141:c0:m3"}
{"signature": "def _get_address_family(self):", "body": "return self.__address_family<EOL>", "docstring": "Getter method for address_family, mapped from YANG variable /network_instances/network_instance/table_connections/table_connection/config/address_family (leafref)\n\n    YANG Description: The address family associated with the connection. This\nmust be defined for the source protocol. The target\naddress family is implicitly defined by the address family\nspecified for the source protocol.", "id": "f22141:c0:m5"}
{"signature": "def _get_import_policy(self):", "body": "return self.__import_policy<EOL>", "docstring": "Getter method for import_policy, mapped from YANG variable /network_instances/network_instance/table_connections/table_connection/config/import_policy (leafref)\n\n    YANG Description: list of policy names in sequence to be applied on\nreceiving a routing update in the current context, e.g.,\nfor the current peer group, neighbor, address family,\netc.", "id": "f22141:c0:m11"}
{"signature": "def _get_dst_protocol(self):", "body": "return self.__dst_protocol<EOL>", "docstring": "Getter method for dst_protocol, mapped from YANG variable /network_instances/network_instance/table_connections/table_connection/config/dst_protocol (leafref)\n\nYANG Description: The destination protocol for the table connection", "id": "f22141:c0:m8"}
{"signature": "def _set_address_family(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__address_family = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for address_family, mapped from YANG variable /network_instances/network_instance/table_connections/table_connection/config/address_family (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_address_family is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_address_family() directly.\n\n    YANG Description: The address family associated with the connection. This\nmust be defined for the source protocol. The target\naddress family is implicitly defined by the address family\nspecified for the source protocol.", "id": "f22141:c0:m6"}
{"signature": "def _set_dst_protocol(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__dst_protocol = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for dst_protocol, mapped from YANG variable /network_instances/network_instance/table_connections/table_connection/config/dst_protocol (leafref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_dst_protocol is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_dst_protocol() directly.\n\nYANG Description: The destination protocol for the table connection", "id": "f22141:c0:m9"}
{"signature": "def _set_src_protocol(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__src_protocol = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for src_protocol, mapped from YANG variable /network_instances/network_instance/table_connections/table_connection/config/src_protocol (leafref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_src_protocol is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_src_protocol() directly.\n\nYANG Description: The source protocol for the table connection", "id": "f22141:c1:m3"}
{"signature": "def _get_src_protocol(self):", "body": "return self.__src_protocol<EOL>", "docstring": "Getter method for src_protocol, mapped from YANG variable /network_instances/network_instance/table_connections/table_connection/config/src_protocol (leafref)\n\nYANG Description: The source protocol for the table connection", "id": "f22141:c0:m2"}
{"signature": "def _get_src_protocol(self):", "body": "return self.__src_protocol<EOL>", "docstring": "Getter method for src_protocol, mapped from YANG variable /network_instances/network_instance/table_connections/table_connection/config/src_protocol (leafref)\n\nYANG Description: The source protocol for the table connection", "id": "f22141:c1:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/table_connections/table_connection/state (container)\n\n    YANG Description: State parameters relating to the connection between\ntables", "id": "f22142:c1:m14"}
{"signature": "def _set_dst_protocol(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__dst_protocol = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for dst_protocol, mapped from YANG variable /network_instances/network_instance/table_connections/table_connection/dst_protocol (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_dst_protocol is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_dst_protocol() directly.\n\n    YANG Description: The table to which routing entries should be\nexported", "id": "f22142:c0:m6"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/table_connections/table_connection/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to the connection\nbetween tables", "id": "f22142:c1:m12"}
{"signature": "def _get_dst_protocol(self):", "body": "return self.__dst_protocol<EOL>", "docstring": "Getter method for dst_protocol, mapped from YANG variable /network_instances/network_instance/table_connections/table_connection/dst_protocol (leafref)\n\n    YANG Description: The table to which routing entries should be\nexported", "id": "f22142:c1:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/table_connections/table_connection/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: State parameters relating to the connection between\ntables", "id": "f22142:c0:m15"}
{"signature": "def _get_address_family(self):", "body": "return self.__address_family<EOL>", "docstring": "Getter method for address_family, mapped from YANG variable /network_instances/network_instance/table_connections/table_connection/address_family (leafref)\n\nYANG Description: The address family associated with the connection", "id": "f22142:c0:m8"}
{"signature": "def _get_src_protocol(self):", "body": "return self.__src_protocol<EOL>", "docstring": "Getter method for src_protocol, mapped from YANG variable /network_instances/network_instance/table_connections/table_connection/src_protocol (leafref)\n\n    YANG Description: The name of the protocol associated with the table\nwhich should be utilised as the source of forwarding\nor routing information", "id": "f22142:c1:m2"}
{"signature": "def _set_src_protocol(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__src_protocol = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for src_protocol, mapped from YANG variable /network_instances/network_instance/table_connections/table_connection/src_protocol (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_src_protocol is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_src_protocol() directly.\n\n    YANG Description: The name of the protocol associated with the table\nwhich should be utilised as the source of forwarding\nor routing information", "id": "f22142:c1:m3"}
{"signature": "def _set_src_protocol(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__src_protocol = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for src_protocol, mapped from YANG variable /network_instances/network_instance/table_connections/table_connection/src_protocol (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_src_protocol is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_src_protocol() directly.\n\n    YANG Description: The name of the protocol associated with the table\nwhich should be utilised as the source of forwarding\nor routing information", "id": "f22142:c0:m3"}
{"signature": "def _set_dst_protocol(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__dst_protocol = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for dst_protocol, mapped from YANG variable /network_instances/network_instance/table_connections/table_connection/dst_protocol (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_dst_protocol is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_dst_protocol() directly.\n\n    YANG Description: The table to which routing entries should be\nexported", "id": "f22142:c1:m6"}
{"signature": "def _set_policy(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>policy.policy,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__policy = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for policy, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy (list)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_policy is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_policy() directly.\n\n    YANG Description: A forwarding policy is defined to have a set of match\ncriteria, allowing particular fields of a packet's header to\nbe matched, and a set of forwarding actions which determines\nhow the local system should forward the packet.", "id": "f22143:c1:m3"}
{"signature": "def _get_policy(self):", "body": "return self.__policy<EOL>", "docstring": "Getter method for policy, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy (list)\n\n    YANG Description: A forwarding policy is defined to have a set of match\ncriteria, allowing particular fields of a packet's header to\nbe matched, and a set of forwarding actions which determines\nhow the local system should forward the packet.", "id": "f22143:c1:m2"}
{"signature": "def _set_policy_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__policy_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for policy_id, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/state/policy_id (string)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_policy_id is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_policy_id() directly.\n\n    YANG Description: A unique name identifying the forwarding policy. This name is\nused when applying the policy to a particular interface.", "id": "f22144:c0:m3"}
{"signature": "def _get_policy_id(self):", "body": "return self.__policy_id<EOL>", "docstring": "Getter method for policy_id, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/config/policy_id (string)\n\n    YANG Description: A unique name identifying the forwarding policy. This name is\nused when applying the policy to a particular interface.", "id": "f22145:c0:m2"}
{"signature": "def _set_policy_id(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__policy_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for policy_id, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/policy_id (leafref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_policy_id is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_policy_id() directly.\n\nYANG Description: Reference to the identifier for the forwarding-policy.", "id": "f22146:c1:m3"}
{"signature": "def _get_rules(self):", "body": "return self.__rules<EOL>", "docstring": "Getter method for rules, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules (container)\n\n    YANG Description: The criteria that should be matched for a packet to be\nforwarded according to the policy action.", "id": "f22146:c1:m11"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: Operational state parameters relating to the forwarding\npolicy.", "id": "f22146:c1:m9"}
{"signature": "def _set_rules(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=rules.rules,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__rules = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for rules, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_rules is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_rules() directly.\n\n    YANG Description: The criteria that should be matched for a packet to be\nforwarded according to the policy action.", "id": "f22146:c0:m12"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: Operational state parameters relating to the forwarding\npolicy.", "id": "f22146:c0:m9"}
{"signature": "def _get_policy_id(self):", "body": "return self.__policy_id<EOL>", "docstring": "Getter method for policy_id, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/policy_id (leafref)\n\nYANG Description: Reference to the identifier for the forwarding-policy.", "id": "f22146:c1:m2"}
{"signature": "def _get_matched_octets(self):", "body": "return self.__matched_octets<EOL>", "docstring": "Getter method for matched_octets, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/state/matched_octets (yang:counter64)\n\nYANG Description: Bytes matched by the rule.", "id": "f22147:c0:m8"}
{"signature": "def _get_sequence_id(self):", "body": "return self.__sequence_id<EOL>", "docstring": "Getter method for sequence_id, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/state/sequence_id (uint32)\n\nYANG Description: Unique sequence number for the policy rule.", "id": "f22147:c0:m2"}
{"signature": "def _set_source_mac_mask(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__source_mac_mask = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for source_mac_mask, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/l2/state/source_mac_mask (yang:mac-address)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_source_mac_mask is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_source_mac_mask() directly.\n\nYANG Description: Source IEEE 802 MAC address mask.", "id": "f22148:c0:m6"}
{"signature": "def _set_source_mac_mask(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__source_mac_mask = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for source_mac_mask, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/l2/state/source_mac_mask (yang:mac-address)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_source_mac_mask is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_source_mac_mask() directly.\n\nYANG Description: Source IEEE 802 MAC address mask.", "id": "f22148:c1:m6"}
{"signature": "def _get_source_mac_mask(self):", "body": "return self.__source_mac_mask<EOL>", "docstring": "Getter method for source_mac_mask, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/l2/state/source_mac_mask (yang:mac-address)\n\nYANG Description: Source IEEE 802 MAC address mask.", "id": "f22148:c1:m5"}
{"signature": "def _get_destination_mac_mask(self):", "body": "return self.__destination_mac_mask<EOL>", "docstring": "Getter method for destination_mac_mask, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/l2/state/destination_mac_mask (yang:mac-address)\n\nYANG Description: Destination IEEE 802 MAC address mask.", "id": "f22148:c0:m11"}
{"signature": "def _set_destination_mac(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__destination_mac = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for destination_mac, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/l2/state/destination_mac (yang:mac-address)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_destination_mac is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_destination_mac() directly.\n\nYANG Description: Destination IEEE 802 MAC address.", "id": "f22148:c0:m9"}
{"signature": "def _get_destination_mac(self):", "body": "return self.__destination_mac<EOL>", "docstring": "Getter method for destination_mac, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/l2/state/destination_mac (yang:mac-address)\n\nYANG Description: Destination IEEE 802 MAC address.", "id": "f22148:c1:m8"}
{"signature": "def _set_destination_mac(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__destination_mac = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for destination_mac, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/l2/state/destination_mac (yang:mac-address)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_destination_mac is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_destination_mac() directly.\n\nYANG Description: Destination IEEE 802 MAC address.", "id": "f22148:c1:m9"}
{"signature": "def _set_ethertype(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:16>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ethertype = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ethertype, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/l2/config/ethertype (oc-pkt-match-types:ethertype-type)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ethertype is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ethertype() directly.\n\nYANG Description: Ethertype field to match in Ethernet packets", "id": "f22149:c1:m15"}
{"signature": "def _get_ethertype(self):", "body": "return self.__ethertype<EOL>", "docstring": "Getter method for ethertype, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/l2/config/ethertype (oc-pkt-match-types:ethertype-type)\n\nYANG Description: Ethertype field to match in Ethernet packets", "id": "f22149:c1:m14"}
{"signature": "def _get_destination_mac_mask(self):", "body": "return self.__destination_mac_mask<EOL>", "docstring": "Getter method for destination_mac_mask, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/l2/config/destination_mac_mask (yang:mac-address)\n\nYANG Description: Destination IEEE 802 MAC address mask.", "id": "f22149:c0:m11"}
{"signature": "def _set_ethertype(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:16>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ethertype = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ethertype, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/l2/config/ethertype (oc-pkt-match-types:ethertype-type)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ethertype is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ethertype() directly.\n\nYANG Description: Ethertype field to match in Ethernet packets", "id": "f22149:c0:m15"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/l2/state (container)\n\nYANG Description: State Information.", "id": "f22150:c0:m5"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/l2/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration data", "id": "f22150:c1:m3"}
{"signature": "def _get_sequence_id(self):", "body": "return self.__sequence_id<EOL>", "docstring": "Getter method for sequence_id, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/config/sequence_id (uint32)\n\nYANG Description: Unique sequence number for the policy rule.", "id": "f22151:c1:m2"}
{"signature": "def _set_sequence_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__sequence_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for sequence_id, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/config/sequence_id (uint32)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_sequence_id is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_sequence_id() directly.\n\nYANG Description: Unique sequence number for the policy rule.", "id": "f22151:c0:m3"}
{"signature": "def _get_hop_limit(self):", "body": "return self.__hop_limit<EOL>", "docstring": "Getter method for hop_limit, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/ip/state/hop_limit (uint8)\n\n    YANG Description: The IP packet's hop limit -- known as TTL (in hops) in\nIPv4 packets, and hop limit in IPv6", "id": "f22152:c1:m23"}
{"signature": "def _set_ip_version(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:0>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:1>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:2>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ip_version = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ip_version, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/ip/state/ip_version (inet:ip-version)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ip_version is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ip_version() directly.\n\nYANG Description: IP version of the header.", "id": "f22152:c0:m3"}
{"signature": "def _set_dscp(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__dscp = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for dscp, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/ip/state/dscp (inet:dscp)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_dscp is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_dscp() directly.\n\nYANG Description: Value of diffserv codepoint.", "id": "f22152:c1:m18"}
{"signature": "def _set_source_ip_flow_label(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__source_ip_flow_label = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for source_ip_flow_label, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/ip/state/source_ip_flow_label (inet:ipv6-flow-label)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_source_ip_flow_label is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_source_ip_flow_label() directly.\n\nYANG Description: Source IPv6 Flow label.", "id": "f22152:c0:m9"}
{"signature": "def _set_destination_ip_flow_label(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__destination_ip_flow_label = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for destination_ip_flow_label, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/ip/state/destination_ip_flow_label (inet:ipv6-flow-label)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_destination_ip_flow_label is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_destination_ip_flow_label() directly.\n\nYANG Description: Destination IPv6 Flow label.", "id": "f22152:c0:m15"}
{"signature": "def _set_hop_limit(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__hop_limit = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for hop_limit, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/ip/state/hop_limit (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_hop_limit is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_hop_limit() directly.\n\n    YANG Description: The IP packet's hop limit -- known as TTL (in hops) in\nIPv4 packets, and hop limit in IPv6", "id": "f22152:c1:m24"}
{"signature": "def _get_source_ip_address(self):", "body": "return self.__source_ip_address<EOL>", "docstring": "Getter method for source_ip_address, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/ip/state/source_ip_address (inet:ip-prefix)\n\nYANG Description: Destination IP address prefix.", "id": "f22152:c0:m5"}
{"signature": "def _set_protocol(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__protocol = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for protocol, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/ip/state/protocol (oc-pkt-match-types:ip-protocol-type)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_protocol is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_protocol() directly.\n\nYANG Description: Internet Protocol number.", "id": "f22152:c0:m21"}
{"signature": "def _get_ip_version(self):", "body": "return self.__ip_version<EOL>", "docstring": "Getter method for ip_version, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/ip/state/ip_version (inet:ip-version)\n\nYANG Description: IP version of the header.", "id": "f22152:c0:m2"}
{"signature": "def _get_protocol(self):", "body": "return self.__protocol<EOL>", "docstring": "Getter method for protocol, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/ip/state/protocol (oc-pkt-match-types:ip-protocol-type)\n\nYANG Description: Internet Protocol number.", "id": "f22152:c0:m20"}
{"signature": "def _set_hop_limit(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__hop_limit = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for hop_limit, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/ip/state/hop_limit (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_hop_limit is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_hop_limit() directly.\n\n    YANG Description: The IP packet's hop limit -- known as TTL (in hops) in\nIPv4 packets, and hop limit in IPv6", "id": "f22152:c0:m24"}
{"signature": "def _get_source_ip_flow_label(self):", "body": "return self.__source_ip_flow_label<EOL>", "docstring": "Getter method for source_ip_flow_label, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/ip/state/source_ip_flow_label (inet:ipv6-flow-label)\n\nYANG Description: Source IPv6 Flow label.", "id": "f22152:c0:m8"}
{"signature": "def _get_hop_limit(self):", "body": "return self.__hop_limit<EOL>", "docstring": "Getter method for hop_limit, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/ip/config/hop_limit (uint8)\n\n    YANG Description: The IP packet's hop limit -- known as TTL (in hops) in\nIPv4 packets, and hop limit in IPv6", "id": "f22153:c1:m23"}
{"signature": "def _set_destination_ip_flow_label(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__destination_ip_flow_label = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for destination_ip_flow_label, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/ip/config/destination_ip_flow_label (inet:ipv6-flow-label)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_destination_ip_flow_label is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_destination_ip_flow_label() directly.\n\nYANG Description: Destination IPv6 Flow label.", "id": "f22153:c1:m15"}
{"signature": "def _get_protocol(self):", "body": "return self.__protocol<EOL>", "docstring": "Getter method for protocol, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/ip/config/protocol (oc-pkt-match-types:ip-protocol-type)\n\nYANG Description: Internet Protocol number.", "id": "f22153:c1:m20"}
{"signature": "def _get_protocol(self):", "body": "return self.__protocol<EOL>", "docstring": "Getter method for protocol, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/ip/config/protocol (oc-pkt-match-types:ip-protocol-type)\n\nYANG Description: Internet Protocol number.", "id": "f22153:c0:m20"}
{"signature": "def _get_hop_limit(self):", "body": "return self.__hop_limit<EOL>", "docstring": "Getter method for hop_limit, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/ip/config/hop_limit (uint8)\n\n    YANG Description: The IP packet's hop limit -- known as TTL (in hops) in\nIPv4 packets, and hop limit in IPv6", "id": "f22153:c0:m23"}
{"signature": "def _get_dscp(self):", "body": "return self.__dscp<EOL>", "docstring": "Getter method for dscp, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/ip/config/dscp (inet:dscp)\n\nYANG Description: Value of diffserv codepoint.", "id": "f22153:c0:m17"}
{"signature": "def _set_hop_limit(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__hop_limit = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for hop_limit, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/ip/config/hop_limit (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_hop_limit is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_hop_limit() directly.\n\n    YANG Description: The IP packet's hop limit -- known as TTL (in hops) in\nIPv4 packets, and hop limit in IPv6", "id": "f22153:c0:m24"}
{"signature": "def _get_destination_ip_flow_label(self):", "body": "return self.__destination_ip_flow_label<EOL>", "docstring": "Getter method for destination_ip_flow_label, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/ip/config/destination_ip_flow_label (inet:ipv6-flow-label)\n\nYANG Description: Destination IPv6 Flow label.", "id": "f22153:c1:m14"}
{"signature": "def _get_ip_version(self):", "body": "return self.__ip_version<EOL>", "docstring": "Getter method for ip_version, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/ip/config/ip_version (inet:ip-version)\n\nYANG Description: IP version of the header.", "id": "f22153:c0:m2"}
{"signature": "def _get_destination_ip_address(self):", "body": "return self.__destination_ip_address<EOL>", "docstring": "Getter method for destination_ip_address, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/ip/config/destination_ip_address (inet:ip-prefix)\n\nYANG Description: Destination IP address prefix.", "id": "f22153:c1:m11"}
{"signature": "def _set_ip_version(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:0>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:1>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:2>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ip_version = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ip_version, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/ip/config/ip_version (inet:ip-version)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ip_version is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ip_version() directly.\n\nYANG Description: IP version of the header.", "id": "f22153:c0:m3"}
{"signature": "def _get_source_ip_flow_label(self):", "body": "return self.__source_ip_flow_label<EOL>", "docstring": "Getter method for source_ip_flow_label, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/ip/config/source_ip_flow_label (inet:ipv6-flow-label)\n\nYANG Description: Source IPv6 Flow label.", "id": "f22153:c0:m8"}
{"signature": "def _set_protocol(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__protocol = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for protocol, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/ip/config/protocol (oc-pkt-match-types:ip-protocol-type)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_protocol is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_protocol() directly.\n\nYANG Description: Internet Protocol number.", "id": "f22153:c1:m21"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/ip/state (container)\n\nYANG Description: State information", "id": "f22154:c0:m5"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/ip/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration data", "id": "f22154:c1:m3"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/ip/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration data", "id": "f22154:c0:m3"}
{"signature": "def _set_l2(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=l2.l2,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__l2 = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for l2, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/l2 (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_l2 is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_l2() directly.\n\nYANG Description: Ethernet header fields", "id": "f22155:c1:m12"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: Operational state parameters relating to the match\nrule.", "id": "f22155:c0:m9"}
{"signature": "def _set_ip(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=ip.ip,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ip = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ip, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/ip (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ip is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ip() directly.\n\nYANG Description: Top level container", "id": "f22155:c0:m15"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to the match\nrule.", "id": "f22155:c0:m6"}
{"signature": "def _set_l2(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=l2.l2,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__l2 = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for l2, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/l2 (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_l2 is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_l2() directly.\n\nYANG Description: Ethernet header fields", "id": "f22155:c0:m12"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/config (container)\n\n    YANG Description: Configuration parameters relating to the match\nrule.", "id": "f22155:c1:m5"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/config (container)\n\n    YANG Description: Configuration parameters relating to the match\nrule.", "id": "f22155:c0:m5"}
{"signature": "def _get_transport(self):", "body": "return self.__transport<EOL>", "docstring": "Getter method for transport, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/transport (container)\n\nYANG Description: Transport fields container", "id": "f22155:c0:m17"}
{"signature": "def _get_sequence_id(self):", "body": "return self.__sequence_id<EOL>", "docstring": "Getter method for sequence_id, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/sequence_id (leafref)\n\nYANG Description: A unique sequence identifier for the match rule.", "id": "f22155:c1:m2"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to the match\nrule.", "id": "f22155:c1:m6"}
{"signature": "def _get_next_hop(self):", "body": "return self.__next_hop<EOL>", "docstring": "Getter method for next_hop, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/action/state/next_hop (inet:ip-address-no-zone)\n\n    YANG Description: When an IP next-hop is specified in the next-hop field,\npackets matching the match criteria for the forwarding rule\nshould be forwarded to the next-hop IP address, bypassing any\nlookup on the local system.", "id": "f22156:c1:m14"}
{"signature": "def _set_discard(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__discard = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for discard, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/action/state/discard (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_discard is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_discard() directly.\n\n    YANG Description: When this leaf is set to true, the local system should drop\npackets that match the rule.", "id": "f22156:c0:m3"}
{"signature": "def _set_decapsulate_gre(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__decapsulate_gre = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for decapsulate_gre, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/action/state/decapsulate_gre (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_decapsulate_gre is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_decapsulate_gre() directly.\n\n    YANG Description: When this leaf is set to true, the local system should remove\nthe GRE header from the packet matching the rule. Following\nthe decapsulation it should subsequently forward the\nencapsulated packet according to the relevant lookup (e.g., if\nthe encapsulated packet is IP, the packet should be routed\naccording to the IP destination).", "id": "f22156:c0:m6"}
{"signature": "def _get_discard(self):", "body": "return self.__discard<EOL>", "docstring": "Getter method for discard, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/action/state/discard (boolean)\n\n    YANG Description: When this leaf is set to true, the local system should drop\npackets that match the rule.", "id": "f22156:c1:m2"}
{"signature": "def _set_path_selection_group(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__path_selection_group = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for path_selection_group, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/action/state/path_selection_group (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_path_selection_group is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_path_selection_group() directly.\n\n    YANG Description: When path-selection-group is set, packets matching the\nmatch criteria for the forwarding rule should be forwarded\nonly via one of the paths that is specified within the\nreferenced path-selection-group. The next-hop of the packet\nwithin the routing context should be used to determine between\nmultiple paths that are specified within the group.", "id": "f22156:c1:m12"}
{"signature": "def _set_decapsulate_gre(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__decapsulate_gre = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for decapsulate_gre, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/action/state/decapsulate_gre (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_decapsulate_gre is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_decapsulate_gre() directly.\n\n    YANG Description: When this leaf is set to true, the local system should remove\nthe GRE header from the packet matching the rule. Following\nthe decapsulation it should subsequently forward the\nencapsulated packet according to the relevant lookup (e.g., if\nthe encapsulated packet is IP, the packet should be routed\naccording to the IP destination).", "id": "f22156:c1:m6"}
{"signature": "def _get_path_selection_group(self):", "body": "return self.__path_selection_group<EOL>", "docstring": "Getter method for path_selection_group, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/action/state/path_selection_group (leafref)\n\n    YANG Description: When path-selection-group is set, packets matching the\nmatch criteria for the forwarding rule should be forwarded\nonly via one of the paths that is specified within the\nreferenced path-selection-group. The next-hop of the packet\nwithin the routing context should be used to determine between\nmultiple paths that are specified within the group.", "id": "f22156:c1:m11"}
{"signature": "def _get_network_instance(self):", "body": "return self.__network_instance<EOL>", "docstring": "Getter method for network_instance, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/action/state/network_instance (leafref)\n\n    YANG Description: When this leaf is set, packets matching the match criteria\nfor the forwarding rule should be looked up in the\nnetwork-instance that is referenced rather than the\nnetwork-instance with which the interface is associated.\nSuch configuration allows policy-routing into multiple\nsub-topologies from a single ingress access interface, or\ndifferent send and receive contexts for a particular\ninterface (sometimes referred to as half-duplex VRF).", "id": "f22156:c1:m8"}
{"signature": "def _set_path_selection_group(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__path_selection_group = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for path_selection_group, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/action/state/path_selection_group (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_path_selection_group is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_path_selection_group() directly.\n\n    YANG Description: When path-selection-group is set, packets matching the\nmatch criteria for the forwarding rule should be forwarded\nonly via one of the paths that is specified within the\nreferenced path-selection-group. The next-hop of the packet\nwithin the routing context should be used to determine between\nmultiple paths that are specified within the group.", "id": "f22156:c0:m12"}
{"signature": "def _get_decapsulate_gre(self):", "body": "return self.__decapsulate_gre<EOL>", "docstring": "Getter method for decapsulate_gre, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/action/config/decapsulate_gre (boolean)\n\n    YANG Description: When this leaf is set to true, the local system should remove\nthe GRE header from the packet matching the rule. Following\nthe decapsulation it should subsequently forward the\nencapsulated packet according to the relevant lookup (e.g., if\nthe encapsulated packet is IP, the packet should be routed\naccording to the IP destination).", "id": "f22157:c0:m5"}
{"signature": "def _get_network_instance(self):", "body": "return self.__network_instance<EOL>", "docstring": "Getter method for network_instance, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/action/config/network_instance (leafref)\n\n    YANG Description: When this leaf is set, packets matching the match criteria\nfor the forwarding rule should be looked up in the\nnetwork-instance that is referenced rather than the\nnetwork-instance with which the interface is associated.\nSuch configuration allows policy-routing into multiple\nsub-topologies from a single ingress access interface, or\ndifferent send and receive contexts for a particular\ninterface (sometimes referred to as half-duplex VRF).", "id": "f22157:c1:m8"}
{"signature": "def _set_network_instance(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__network_instance = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for network_instance, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/action/config/network_instance (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_network_instance is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_network_instance() directly.\n\n    YANG Description: When this leaf is set, packets matching the match criteria\nfor the forwarding rule should be looked up in the\nnetwork-instance that is referenced rather than the\nnetwork-instance with which the interface is associated.\nSuch configuration allows policy-routing into multiple\nsub-topologies from a single ingress access interface, or\ndifferent send and receive contexts for a particular\ninterface (sometimes referred to as half-duplex VRF).", "id": "f22157:c1:m9"}
{"signature": "def _get_decapsulate_gre(self):", "body": "return self.__decapsulate_gre<EOL>", "docstring": "Getter method for decapsulate_gre, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/action/config/decapsulate_gre (boolean)\n\n    YANG Description: When this leaf is set to true, the local system should remove\nthe GRE header from the packet matching the rule. Following\nthe decapsulation it should subsequently forward the\nencapsulated packet according to the relevant lookup (e.g., if\nthe encapsulated packet is IP, the packet should be routed\naccording to the IP destination).", "id": "f22157:c1:m5"}
{"signature": "def _set_path_selection_group(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__path_selection_group = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for path_selection_group, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/action/config/path_selection_group (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_path_selection_group is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_path_selection_group() directly.\n\n    YANG Description: When path-selection-group is set, packets matching the\nmatch criteria for the forwarding rule should be forwarded\nonly via one of the paths that is specified within the\nreferenced path-selection-group. The next-hop of the packet\nwithin the routing context should be used to determine between\nmultiple paths that are specified within the group.", "id": "f22157:c0:m12"}
{"signature": "def _set_decapsulate_gre(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__decapsulate_gre = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for decapsulate_gre, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/action/config/decapsulate_gre (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_decapsulate_gre is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_decapsulate_gre() directly.\n\n    YANG Description: When this leaf is set to true, the local system should remove\nthe GRE header from the packet matching the rule. Following\nthe decapsulation it should subsequently forward the\nencapsulated packet according to the relevant lookup (e.g., if\nthe encapsulated packet is IP, the packet should be routed\naccording to the IP destination).", "id": "f22157:c0:m6"}
{"signature": "def _set_network_instance(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__network_instance = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for network_instance, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/action/config/network_instance (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_network_instance is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_network_instance() directly.\n\n    YANG Description: When this leaf is set, packets matching the match criteria\nfor the forwarding rule should be looked up in the\nnetwork-instance that is referenced rather than the\nnetwork-instance with which the interface is associated.\nSuch configuration allows policy-routing into multiple\nsub-topologies from a single ingress access interface, or\ndifferent send and receive contexts for a particular\ninterface (sometimes referred to as half-duplex VRF).", "id": "f22157:c0:m9"}
{"signature": "def _get_network_instance(self):", "body": "return self.__network_instance<EOL>", "docstring": "Getter method for network_instance, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/action/config/network_instance (leafref)\n\n    YANG Description: When this leaf is set, packets matching the match criteria\nfor the forwarding rule should be looked up in the\nnetwork-instance that is referenced rather than the\nnetwork-instance with which the interface is associated.\nSuch configuration allows policy-routing into multiple\nsub-topologies from a single ingress access interface, or\ndifferent send and receive contexts for a particular\ninterface (sometimes referred to as half-duplex VRF).", "id": "f22157:c0:m8"}
{"signature": "def _get_path_selection_group(self):", "body": "return self.__path_selection_group<EOL>", "docstring": "Getter method for path_selection_group, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/action/config/path_selection_group (leafref)\n\n    YANG Description: When path-selection-group is set, packets matching the\nmatch criteria for the forwarding rule should be forwarded\nonly via one of the paths that is specified within the\nreferenced path-selection-group. The next-hop of the packet\nwithin the routing context should be used to determine between\nmultiple paths that are specified within the group.", "id": "f22157:c1:m11"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/action/config (container)\n\n    YANG Description: Configuration parameters relating to the forwarding\nrule's action.", "id": "f22158:c0:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/action/state (container)\n\n    YANG Description: Operational state parameters relating to the\nforwarding rule's action.", "id": "f22158:c0:m5"}
{"signature": "def _set_destination_port(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:16>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__destination_port = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for destination_port, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/transport/state/destination_port (oc-pkt-match-types:port-num-range)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_destination_port is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_destination_port() directly.\n\nYANG Description: Destination port or range", "id": "f22159:c1:m6"}
{"signature": "def _get_tcp_flags(self):", "body": "return self.__tcp_flags<EOL>", "docstring": "Getter method for tcp_flags, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/transport/state/tcp_flags (identityref)\n\nYANG Description: List of TCP flags to match", "id": "f22159:c0:m8"}
{"signature": "def _get_source_port(self):", "body": "return self.__source_port<EOL>", "docstring": "Getter method for source_port, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/transport/state/source_port (oc-pkt-match-types:port-num-range)\n\nYANG Description: Source port or range", "id": "f22159:c1:m2"}
{"signature": "def _set_source_port(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:16>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__source_port = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for source_port, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/transport/state/source_port (oc-pkt-match-types:port-num-range)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_source_port is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_source_port() directly.\n\nYANG Description: Source port or range", "id": "f22159:c1:m3"}
{"signature": "def _get_tcp_flags(self):", "body": "return self.__tcp_flags<EOL>", "docstring": "Getter method for tcp_flags, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/transport/state/tcp_flags (identityref)\n\nYANG Description: List of TCP flags to match", "id": "f22159:c1:m8"}
{"signature": "def _set_destination_port(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:16>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__destination_port = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for destination_port, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/transport/config/destination_port (oc-pkt-match-types:port-num-range)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_destination_port is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_destination_port() directly.\n\nYANG Description: Destination port or range", "id": "f22160:c0:m6"}
{"signature": "def _get_tcp_flags(self):", "body": "return self.__tcp_flags<EOL>", "docstring": "Getter method for tcp_flags, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/transport/config/tcp_flags (identityref)\n\nYANG Description: List of TCP flags to match", "id": "f22160:c1:m8"}
{"signature": "def _set_source_port(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:16>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__source_port = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for source_port, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/transport/config/source_port (oc-pkt-match-types:port-num-range)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_source_port is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_source_port() directly.\n\nYANG Description: Source port or range", "id": "f22160:c0:m3"}
{"signature": "def _get_source_port(self):", "body": "return self.__source_port<EOL>", "docstring": "Getter method for source_port, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/transport/config/source_port (oc-pkt-match-types:port-num-range)\n\nYANG Description: Source port or range", "id": "f22160:c0:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/transport/state (container)\n\nYANG Description: State data", "id": "f22161:c0:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/transport/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State data", "id": "f22161:c1:m6"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/transport/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration data", "id": "f22161:c1:m3"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/policy_forwarding/policies/policy/rules/rule/transport/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration data", "id": "f22161:c0:m3"}
{"signature": "def _get_apply_forwarding_policy(self):", "body": "return self.__apply_forwarding_policy<EOL>", "docstring": "Getter method for apply_forwarding_policy, mapped from YANG variable /network_instances/network_instance/policy_forwarding/interfaces/interface/state/apply_forwarding_policy (leafref)\n\n    YANG Description: The policy to be applied on the interface. Packets ingress on\nthe referenced interface should be compared to the match\ncriteria within the specified policy, and in the case that\nthese criteria are met, the forwarding actions specified\napplied. These policies should be applied following quality of\nservice classification, and ACL actions if such entities are\nreferenced by the corresponding interface.", "id": "f22163:c1:m5"}
{"signature": "def _set_interface_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface_id, mapped from YANG variable /network_instances/network_instance/policy_forwarding/interfaces/interface/state/interface_id (oc-if:interface-id)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_interface_id is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_interface_id() directly.\n\nYANG Description: A unique identifier for the interface.", "id": "f22163:c0:m3"}
{"signature": "def _set_interface_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface_id, mapped from YANG variable /network_instances/network_instance/policy_forwarding/interfaces/interface/state/interface_id (oc-if:interface-id)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_interface_id is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_interface_id() directly.\n\nYANG Description: A unique identifier for the interface.", "id": "f22163:c1:m3"}
{"signature": "def _set_interface_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface_id, mapped from YANG variable /network_instances/network_instance/policy_forwarding/interfaces/interface/config/interface_id (oc-if:interface-id)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_interface_id is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_interface_id() directly.\n\nYANG Description: A unique identifier for the interface.", "id": "f22164:c1:m3"}
{"signature": "def _get_apply_forwarding_policy(self):", "body": "return self.__apply_forwarding_policy<EOL>", "docstring": "Getter method for apply_forwarding_policy, mapped from YANG variable /network_instances/network_instance/policy_forwarding/interfaces/interface/config/apply_forwarding_policy (leafref)\n\n    YANG Description: The policy to be applied on the interface. Packets ingress on\nthe referenced interface should be compared to the match\ncriteria within the specified policy, and in the case that\nthese criteria are met, the forwarding actions specified\napplied. These policies should be applied following quality of\nservice classification, and ACL actions if such entities are\nreferenced by the corresponding interface.", "id": "f22164:c0:m5"}
{"signature": "def _get_interface(self):", "body": "return self.__interface<EOL>", "docstring": "Getter method for interface, mapped from YANG variable /network_instances/network_instance/policy_forwarding/interfaces/interface/interface_ref/state/interface (leafref)\n\n    YANG Description: Reference to a base interface.  If a reference to a\nsubinterface is required, this leaf must be specified\nto indicate the base interface.", "id": "f22165:c0:m2"}
{"signature": "def _get_subinterface(self):", "body": "return self.__subinterface<EOL>", "docstring": "Getter method for subinterface, mapped from YANG variable /network_instances/network_instance/policy_forwarding/interfaces/interface/interface_ref/state/subinterface (leafref)\n\n    YANG Description: Reference to a subinterface -- this requires the base\ninterface to be specified using the interface leaf in\nthis container.  If only a reference to a base interface\nis requuired, this leaf should not be set.", "id": "f22165:c0:m5"}
{"signature": "def _get_subinterface(self):", "body": "return self.__subinterface<EOL>", "docstring": "Getter method for subinterface, mapped from YANG variable /network_instances/network_instance/policy_forwarding/interfaces/interface/interface_ref/state/subinterface (leafref)\n\n    YANG Description: Reference to a subinterface -- this requires the base\ninterface to be specified using the interface leaf in\nthis container.  If only a reference to a base interface\nis requuired, this leaf should not be set.", "id": "f22165:c1:m5"}
{"signature": "def _set_interface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface, mapped from YANG variable /network_instances/network_instance/policy_forwarding/interfaces/interface/interface_ref/state/interface (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_interface is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_interface() directly.\n\n    YANG Description: Reference to a base interface.  If a reference to a\nsubinterface is required, this leaf must be specified\nto indicate the base interface.", "id": "f22165:c0:m3"}
{"signature": "def _set_subinterface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subinterface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subinterface, mapped from YANG variable /network_instances/network_instance/policy_forwarding/interfaces/interface/interface_ref/state/subinterface (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subinterface is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subinterface() directly.\n\n    YANG Description: Reference to a subinterface -- this requires the base\ninterface to be specified using the interface leaf in\nthis container.  If only a reference to a base interface\nis requuired, this leaf should not be set.", "id": "f22165:c0:m6"}
{"signature": "def _set_subinterface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subinterface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subinterface, mapped from YANG variable /network_instances/network_instance/policy_forwarding/interfaces/interface/interface_ref/config/subinterface (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subinterface is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subinterface() directly.\n\n    YANG Description: Reference to a subinterface -- this requires the base\ninterface to be specified using the interface leaf in\nthis container.  If only a reference to a base interface\nis requuired, this leaf should not be set.", "id": "f22166:c0:m6"}
{"signature": "def _get_subinterface(self):", "body": "return self.__subinterface<EOL>", "docstring": "Getter method for subinterface, mapped from YANG variable /network_instances/network_instance/policy_forwarding/interfaces/interface/interface_ref/config/subinterface (leafref)\n\n    YANG Description: Reference to a subinterface -- this requires the base\ninterface to be specified using the interface leaf in\nthis container.  If only a reference to a base interface\nis requuired, this leaf should not be set.", "id": "f22166:c0:m5"}
{"signature": "def _get_subinterface(self):", "body": "return self.__subinterface<EOL>", "docstring": "Getter method for subinterface, mapped from YANG variable /network_instances/network_instance/policy_forwarding/interfaces/interface/interface_ref/config/subinterface (leafref)\n\n    YANG Description: Reference to a subinterface -- this requires the base\ninterface to be specified using the interface leaf in\nthis container.  If only a reference to a base interface\nis requuired, this leaf should not be set.", "id": "f22166:c1:m5"}
{"signature": "def _get_interface(self):", "body": "return self.__interface<EOL>", "docstring": "Getter method for interface, mapped from YANG variable /network_instances/network_instance/policy_forwarding/interfaces/interface/interface_ref/config/interface (leafref)\n\n    YANG Description: Reference to a base interface.  If a reference to a\nsubinterface is required, this leaf must be specified\nto indicate the base interface.", "id": "f22166:c1:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/policy_forwarding/interfaces/interface/interface_ref/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Operational state for interface-ref", "id": "f22167:c0:m6"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/policy_forwarding/interfaces/interface/interface_ref/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configured reference to interface / subinterface", "id": "f22167:c1:m3"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/policy_forwarding/interfaces/interface/interface_ref/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configured reference to interface / subinterface", "id": "f22167:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/policy_forwarding/interfaces/interface/state (container)\n\n    YANG Description: Operational state parameters relating to an interface to\npolicy forwarding rule binding.", "id": "f22168:c1:m8"}
{"signature": "def _set_interface_ref(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=interface_ref.interface_ref,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface_ref = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface_ref, mapped from YANG variable /network_instances/network_instance/policy_forwarding/interfaces/interface/interface_ref (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_interface_ref is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_interface_ref() directly.\n\nYANG Description: Reference to an interface or subinterface", "id": "f22168:c1:m12"}
{"signature": "def _get_interface_ref(self):", "body": "return self.__interface_ref<EOL>", "docstring": "Getter method for interface_ref, mapped from YANG variable /network_instances/network_instance/policy_forwarding/interfaces/interface/interface_ref (container)\n\nYANG Description: Reference to an interface or subinterface", "id": "f22168:c1:m11"}
{"signature": "def _get_interface(self):", "body": "return self.__interface<EOL>", "docstring": "Getter method for interface, mapped from YANG variable /network_instances/network_instance/policy_forwarding/interfaces/interface (list)\n\n    YANG Description: Configuration and operationals state relating to the\nrelationship between interfaces and policy-based forwarding\nrules.", "id": "f22169:c0:m2"}
{"signature": "def _set_interfaces(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=interfaces.interfaces,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interfaces = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interfaces, mapped from YANG variable /network_instances/network_instance/policy_forwarding/interfaces (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_interfaces is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_interfaces() directly.\n\n    YANG Description: Configuration and operational state relating policy\nforwarding on interfaces.", "id": "f22170:c0:m6"}
{"signature": "def _get_interfaces(self):", "body": "return self.__interfaces<EOL>", "docstring": "Getter method for interfaces, mapped from YANG variable /network_instances/network_instance/policy_forwarding/interfaces (container)\n\n    YANG Description: Configuration and operational state relating policy\nforwarding on interfaces.", "id": "f22170:c1:m5"}
{"signature": "def _set_mpls_lsp(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(allowed_type=six.text_type),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__mpls_lsp = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for mpls_lsp, mapped from YANG variable /network_instances/network_instance/policy_forwarding/path_selection_groups/path_selection_group/state/mpls_lsp (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_mpls_lsp is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_mpls_lsp() directly.\n\n    YANG Description: A set of MPLS constrained-path LSPs which should be\nconsidered for the policy forwarding next-hop. In order to\nselect between the LSPs within the path-selection-group, the\nsystem should determine which LSP provides the best path to\nthe next-hop for the routed packet.", "id": "f22171:c0:m6"}
{"signature": "def _set_group_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__group_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for group_id, mapped from YANG variable /network_instances/network_instance/policy_forwarding/path_selection_groups/path_selection_group/config/group_id (string)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_group_id is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_group_id() directly.\n\nYANG Description: A unique name for the path-selection-group", "id": "f22172:c1:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/policy_forwarding/path_selection_groups/path_selection_group/state (container)\n\n    YANG Description: Operational state parameters relating to the path\nselection group.", "id": "f22173:c1:m8"}
{"signature": "def _set_group_id(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__group_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for group_id, mapped from YANG variable /network_instances/network_instance/policy_forwarding/path_selection_groups/path_selection_group/group_id (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_group_id is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_group_id() directly.\n\n    YANG Description: Reference to a unique identifier for the path selection\ngroup", "id": "f22173:c1:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/policy_forwarding/path_selection_groups/path_selection_group/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: Operational state parameters relating to the path\nselection group.", "id": "f22173:c1:m9"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/policy_forwarding/path_selection_groups/path_selection_group/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: Operational state parameters relating to the path\nselection group.", "id": "f22173:c0:m9"}
{"signature": "def _get_path_selection_group(self):", "body": "return self.__path_selection_group<EOL>", "docstring": "Getter method for path_selection_group, mapped from YANG variable /network_instances/network_instance/policy_forwarding/path_selection_groups/path_selection_group (list)\n\n    YANG Description: A path selection group is a set of forwarding resources,\nwhich are grouped as eligible paths for a particular\npolicy-based forwarding rule. A policy rule may select a\npath-selection-group as the egress for a particular type of\ntraffic (e.g., DSCP value). The system then utilises its\nstandard forwarding lookup mechanism to select from the\npaths that are specified within the group - for IP packets,\nthe destination IP address is used such that the packet is\nrouted to the entity within the path-selection-group that\ncorresponds to the next-hop for the destination IP address\nof the packet; for L2 packets, the selection is based on the\ndestination MAC address.", "id": "f22174:c0:m2"}
{"signature": "def _get_mtu(self):", "body": "return self.__mtu<EOL>", "docstring": "Getter method for mtu, mapped from YANG variable /network_instances/network_instance/config/mtu (uint16)\n\n    YANG Description: The maximum frame size which should be supported for this\ninstance for Layer 2 frames", "id": "f22175:c0:m23"}
{"signature": "def _get_name(self):", "body": "return self.__name<EOL>", "docstring": "Getter method for name, mapped from YANG variable /network_instances/network_instance/config/name (string)\n\n    YANG Description: An operator-assigned unique name for the forwarding\ninstance", "id": "f22175:c0:m2"}
{"signature": "def _get_enabled_address_families(self):", "body": "return self.__enabled_address_families<EOL>", "docstring": "Getter method for enabled_address_families, mapped from YANG variable /network_instances/network_instance/config/enabled_address_families (identityref)\n\n    YANG Description: The address families that are to be enabled for this\nnetwork instance.", "id": "f22175:c1:m20"}
{"signature": "def _set_router_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__router_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for router_id, mapped from YANG variable /network_instances/network_instance/config/router_id (yang:dotted-quad)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_router_id is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_router_id() directly.\n\n    YANG Description: A identifier for the local network instance - typically\nused within associated routing protocols or signalling\nrouting information in another network instance", "id": "f22175:c1:m15"}
{"signature": "def _get_router_id(self):", "body": "return self.__router_id<EOL>", "docstring": "Getter method for router_id, mapped from YANG variable /network_instances/network_instance/config/router_id (yang:dotted-quad)\n\n    YANG Description: A identifier for the local network instance - typically\nused within associated routing protocols or signalling\nrouting information in another network instance", "id": "f22175:c0:m14"}
{"signature": "def _set_name(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:name>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for name, mapped from YANG variable /network_instances/network_instance/config/name (string)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_name is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_name() directly.\n\n    YANG Description: An operator-assigned unique name for the forwarding\ninstance", "id": "f22175:c1:m3"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /network_instances/network_instance/config/enabled (boolean)\n\n    YANG Description: Whether the network instance should be configured to be\nactive on the network element", "id": "f22175:c0:m8"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/config/type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_type() directly.\n\n    YANG Description: The type of network instance. The value of this leaf\nindicates the type of forwarding entries that should be\nsupported by this network instance", "id": "f22175:c0:m6"}
{"signature": "def _set_enabled_address_families(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled_address_families = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled_address_families, mapped from YANG variable /network_instances/network_instance/config/enabled_address_families (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled_address_families is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled_address_families() directly.\n\n    YANG Description: The address families that are to be enabled for this\nnetwork instance.", "id": "f22175:c1:m21"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /network_instances/network_instance/config/enabled (boolean)\n\n    YANG Description: Whether the network instance should be configured to be\nactive on the network element", "id": "f22175:c1:m8"}
{"signature": "def _set_router_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__router_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for router_id, mapped from YANG variable /network_instances/network_instance/config/router_id (yang:dotted-quad)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_router_id is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_router_id() directly.\n\n    YANG Description: A identifier for the local network instance - typically\nused within associated routing protocols or signalling\nrouting information in another network instance", "id": "f22175:c0:m15"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/config/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: Whether the network instance should be configured to be\nactive on the network element", "id": "f22175:c0:m9"}
{"signature": "def _set_value(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:value>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__value = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for value, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/srlgs/srlg/state/value (uint32)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_value is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_value() directly.\n\nYANG Description: group ID for the SRLG", "id": "f22176:c1:m6"}
{"signature": "def _set_flooding_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>default=six.text_type(\"<STR_LIT>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__flooding_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for flooding_type, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/srlgs/srlg/state/flooding_type (mpls-srlg-flooding-type)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_flooding_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_flooding_type() directly.\n\n    YANG Description: The type of SRLG, either flooded in the IGP or\nstatically configured", "id": "f22176:c1:m12"}
{"signature": "def _get_value(self):", "body": "return self.__value<EOL>", "docstring": "Getter method for value, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/srlgs/srlg/state/value (uint32)\n\nYANG Description: group ID for the SRLG", "id": "f22176:c1:m5"}
{"signature": "def _set_name(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:name>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for name, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/srlgs/srlg/state/name (string)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_name is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_name() directly.\n\nYANG Description: SRLG group identifier", "id": "f22176:c1:m3"}
{"signature": "def _get_to_address(self):", "body": "return self.__to_address<EOL>", "docstring": "Getter method for to_address, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/srlgs/srlg/static_srlg_members/members_list/state/to_address (inet:ip-address)\n\nYANG Description: IP address of the z-side of the SRLG link", "id": "f22177:c1:m5"}
{"signature": "def _set_from_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__from_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for from_address, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/srlgs/srlg/static_srlg_members/members_list/state/from_address (inet:ip-address)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_from_address is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_from_address() directly.\n\nYANG Description: IP address of the a-side of the SRLG link", "id": "f22177:c1:m3"}
{"signature": "def _set_from_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__from_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for from_address, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/srlgs/srlg/static_srlg_members/members_list/state/from_address (inet:ip-address)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_from_address is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_from_address() directly.\n\nYANG Description: IP address of the a-side of the SRLG link", "id": "f22177:c0:m3"}
{"signature": "def _set_to_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__to_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for to_address, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/srlgs/srlg/static_srlg_members/members_list/config/to_address (inet:ip-address)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_to_address is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_to_address() directly.\n\nYANG Description: IP address of the z-side of the SRLG link", "id": "f22178:c0:m6"}
{"signature": "def _set_from_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__from_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for from_address, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/srlgs/srlg/static_srlg_members/members_list/config/from_address (inet:ip-address)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_from_address is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_from_address() directly.\n\nYANG Description: IP address of the a-side of the SRLG link", "id": "f22178:c0:m3"}
{"signature": "def _set_to_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__to_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for to_address, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/srlgs/srlg/static_srlg_members/members_list/config/to_address (inet:ip-address)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_to_address is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_to_address() directly.\n\nYANG Description: IP address of the z-side of the SRLG link", "id": "f22178:c1:m6"}
{"signature": "def _get_from_address(self):", "body": "return self.__from_address<EOL>", "docstring": "Getter method for from_address, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/srlgs/srlg/static_srlg_members/members_list/config/from_address (inet:ip-address)\n\nYANG Description: IP address of the a-side of the SRLG link", "id": "f22178:c0:m2"}
{"signature": "def _set_from_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__from_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for from_address, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/srlgs/srlg/static_srlg_members/members_list/config/from_address (inet:ip-address)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_from_address is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_from_address() directly.\n\nYANG Description: IP address of the a-side of the SRLG link", "id": "f22178:c1:m3"}
{"signature": "def _get_from_address(self):", "body": "return self.__from_address<EOL>", "docstring": "Getter method for from_address, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/srlgs/srlg/static_srlg_members/members_list/config/from_address (inet:ip-address)\n\nYANG Description: IP address of the a-side of the SRLG link", "id": "f22178:c1:m2"}
{"signature": "def _get_from_address(self):", "body": "return self.__from_address<EOL>", "docstring": "Getter method for from_address, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/srlgs/srlg/static_srlg_members/members_list/from_address (leafref)\n\nYANG Description: The from address of the link in the SRLG", "id": "f22179:c1:m2"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/srlgs/srlg/static_srlg_members/members_list/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to the\nSRLG members", "id": "f22179:c1:m6"}
{"signature": "def _get_members_list(self):", "body": "return self.__members_list<EOL>", "docstring": "Getter method for members_list, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/srlgs/srlg/static_srlg_members/members_list (list)\n\n    YANG Description: List of SRLG members, which are expressed\nas IP address endpoints of links contained in the\nSRLG", "id": "f22180:c0:m2"}
{"signature": "def _get_members_list(self):", "body": "return self.__members_list<EOL>", "docstring": "Getter method for members_list, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/srlgs/srlg/static_srlg_members/members_list (list)\n\n    YANG Description: List of SRLG members, which are expressed\nas IP address endpoints of links contained in the\nSRLG", "id": "f22180:c1:m2"}
{"signature": "def _set_members_list(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>members_list.members_list,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__members_list = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for members_list, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/srlgs/srlg/static_srlg_members/members_list (list)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_members_list is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_members_list() directly.\n\n    YANG Description: List of SRLG members, which are expressed\nas IP address endpoints of links contained in the\nSRLG", "id": "f22180:c1:m3"}
{"signature": "def _set_flooding_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>default=six.text_type(\"<STR_LIT>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__flooding_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for flooding_type, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/srlgs/srlg/config/flooding_type (mpls-srlg-flooding-type)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_flooding_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_flooding_type() directly.\n\n    YANG Description: The type of SRLG, either flooded in the IGP or\nstatically configured", "id": "f22181:c0:m12"}
{"signature": "def _set_value(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:value>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__value = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for value, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/srlgs/srlg/config/value (uint32)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_value is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_value() directly.\n\nYANG Description: group ID for the SRLG", "id": "f22181:c1:m6"}
{"signature": "def _get_value(self):", "body": "return self.__value<EOL>", "docstring": "Getter method for value, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/srlgs/srlg/config/value (uint32)\n\nYANG Description: group ID for the SRLG", "id": "f22181:c1:m5"}
{"signature": "def _set_value(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:value>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__value = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for value, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/srlgs/srlg/config/value (uint32)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_value is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_value() directly.\n\nYANG Description: group ID for the SRLG", "id": "f22181:c0:m6"}
{"signature": "def _set_flooding_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>default=six.text_type(\"<STR_LIT>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__flooding_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for flooding_type, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/srlgs/srlg/config/flooding_type (mpls-srlg-flooding-type)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_flooding_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_flooding_type() directly.\n\n    YANG Description: The type of SRLG, either flooded in the IGP or\nstatically configured", "id": "f22181:c1:m12"}
{"signature": "def _get_cost(self):", "body": "return self.__cost<EOL>", "docstring": "Getter method for cost, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/srlgs/srlg/config/cost (uint32)\n\n    YANG Description: The cost of the SRLG to the computation\nalgorithm", "id": "f22181:c0:m8"}
{"signature": "def _get_name(self):", "body": "return self.__name<EOL>", "docstring": "Getter method for name, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/srlgs/srlg/config/name (string)\n\nYANG Description: SRLG group identifier", "id": "f22181:c1:m2"}
{"signature": "def _get_value(self):", "body": "return self.__value<EOL>", "docstring": "Getter method for value, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/srlgs/srlg/config/value (uint32)\n\nYANG Description: group ID for the SRLG", "id": "f22181:c0:m5"}
{"signature": "def _get_name(self):", "body": "return self.__name<EOL>", "docstring": "Getter method for name, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/srlgs/srlg/name (leafref)\n\nYANG Description: The SRLG group identifier", "id": "f22182:c1:m2"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/srlgs/srlg/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration parameters related to the SRLG", "id": "f22182:c0:m6"}
{"signature": "def _get_static_srlg_members(self):", "body": "return self.__static_srlg_members<EOL>", "docstring": "Getter method for static_srlg_members, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/srlgs/srlg/static_srlg_members (container)\n\nYANG Description: SRLG members for static (not flooded) SRLGs", "id": "f22182:c1:m11"}
{"signature": "def _get_name(self):", "body": "return self.__name<EOL>", "docstring": "Getter method for name, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/srlgs/srlg/name (leafref)\n\nYANG Description: The SRLG group identifier", "id": "f22182:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/srlgs/srlg/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters related to the SRLG", "id": "f22182:c1:m9"}
{"signature": "def _set_name(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:name>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for name, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/srlgs/srlg/name (leafref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_name is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_name() directly.\n\nYANG Description: The SRLG group identifier", "id": "f22182:c0:m3"}
{"signature": "def _get_srlg(self):", "body": "return self.__srlg<EOL>", "docstring": "Getter method for srlg, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/srlgs/srlg (list)\n\nYANG Description: List of shared risk link groups", "id": "f22183:c1:m2"}
{"signature": "def _set_te_lsp_timers(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=te_lsp_timers.te_lsp_timers,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__te_lsp_timers = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for te_lsp_timers, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/te_lsp_timers (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_te_lsp_timers is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_te_lsp_timers() directly.\n\n    YANG Description: Definition for delays associated with setup\nand cleanup of TE LSPs", "id": "f22184:c1:m9"}
{"signature": "def _get_srlgs(self):", "body": "return self.__srlgs<EOL>", "docstring": "Getter method for srlgs, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/srlgs (container)\n\nYANG Description: Shared risk link groups attributes", "id": "f22184:c1:m2"}
{"signature": "def _set_mpls_admin_groups(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=mpls_admin_groups.mpls_admin_groups,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__mpls_admin_groups = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for mpls_admin_groups, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/mpls_admin_groups (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_mpls_admin_groups is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_mpls_admin_groups() directly.\n\n    YANG Description: Top-level container for admin-groups configuration\nand state", "id": "f22184:c0:m6"}
{"signature": "def _set_te_lsp_timers(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=te_lsp_timers.te_lsp_timers,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__te_lsp_timers = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for te_lsp_timers, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/te_lsp_timers (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_te_lsp_timers is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_te_lsp_timers() directly.\n\n    YANG Description: Definition for delays associated with setup\nand cleanup of TE LSPs", "id": "f22184:c0:m9"}
{"signature": "def _get_admin_group(self):", "body": "return self.__admin_group<EOL>", "docstring": "Getter method for admin_group, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/mpls_admin_groups/admin_group (list)\n\n    YANG Description: configuration of value to name mapping\nfor mpls affinities/admin-groups", "id": "f22185:c0:m2"}
{"signature": "def _get_admin_group(self):", "body": "return self.__admin_group<EOL>", "docstring": "Getter method for admin_group, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/mpls_admin_groups/admin_group (list)\n\n    YANG Description: configuration of value to name mapping\nfor mpls affinities/admin-groups", "id": "f22185:c1:m2"}
{"signature": "def _get_bit_position(self):", "body": "return self.__bit_position<EOL>", "docstring": "Getter method for bit_position, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/mpls_admin_groups/admin_group/state/bit_position (uint32)\n\n    YANG Description: bit-position value for mpls admin-group. The value\nfor the admin group is an integer that represents one\nof the bit positions in the admin-group bitmask. Values\nbetween 0 and 31 are interpreted as the original limit\nof 32 admin groups. Values >=32 are interpreted as\nextended admin group values as per RFC7308.", "id": "f22186:c1:m5"}
{"signature": "def _set_admin_group_name(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__admin_group_name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for admin_group_name, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/mpls_admin_groups/admin_group/state/admin_group_name (string)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_admin_group_name is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_admin_group_name() directly.\n\nYANG Description: name for mpls admin-group", "id": "f22186:c0:m3"}
{"signature": "def _set_bit_position(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__bit_position = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for bit_position, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/mpls_admin_groups/admin_group/state/bit_position (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_bit_position is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_bit_position() directly.\n\n    YANG Description: bit-position value for mpls admin-group. The value\nfor the admin group is an integer that represents one\nof the bit positions in the admin-group bitmask. Values\nbetween 0 and 31 are interpreted as the original limit\nof 32 admin groups. Values >=32 are interpreted as\nextended admin group values as per RFC7308.", "id": "f22186:c0:m6"}
{"signature": "def _set_admin_group_name(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__admin_group_name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for admin_group_name, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/mpls_admin_groups/admin_group/config/admin_group_name (string)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_admin_group_name is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_admin_group_name() directly.\n\nYANG Description: name for mpls admin-group", "id": "f22187:c1:m3"}
{"signature": "def _get_bit_position(self):", "body": "return self.__bit_position<EOL>", "docstring": "Getter method for bit_position, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/mpls_admin_groups/admin_group/config/bit_position (uint32)\n\n    YANG Description: bit-position value for mpls admin-group. The value\nfor the admin group is an integer that represents one\nof the bit positions in the admin-group bitmask. Values\nbetween 0 and 31 are interpreted as the original limit\nof 32 admin groups. Values >=32 are interpreted as\nextended admin group values as per RFC7308.", "id": "f22187:c1:m5"}
{"signature": "def _get_admin_group_name(self):", "body": "return self.__admin_group_name<EOL>", "docstring": "Getter method for admin_group_name, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/mpls_admin_groups/admin_group/config/admin_group_name (string)\n\nYANG Description: name for mpls admin-group", "id": "f22187:c1:m2"}
{"signature": "def _get_admin_group_name(self):", "body": "return self.__admin_group_name<EOL>", "docstring": "Getter method for admin_group_name, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/mpls_admin_groups/admin_group/admin_group_name (leafref)\n\nYANG Description: name for mpls admin-group", "id": "f22188:c1:m2"}
{"signature": "def _set_admin_group_name(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__admin_group_name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for admin_group_name, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/mpls_admin_groups/admin_group/admin_group_name (leafref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_admin_group_name is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_admin_group_name() directly.\n\nYANG Description: name for mpls admin-group", "id": "f22188:c1:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/mpls_admin_groups/admin_group/state (container)\n\nYANG Description: Operational state for admin-groups", "id": "f22188:c1:m8"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/mpls_admin_groups/admin_group/state (container)\n\nYANG Description: Operational state for admin-groups", "id": "f22188:c0:m8"}
{"signature": "def _set_install_delay(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:16>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__install_delay = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for install_delay, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/te_lsp_timers/state/install_delay (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_install_delay is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_install_delay() directly.\n\n    YANG Description: delay the use of newly installed te lsp for a\nspecified amount of time.", "id": "f22189:c1:m3"}
{"signature": "def _get_install_delay(self):", "body": "return self.__install_delay<EOL>", "docstring": "Getter method for install_delay, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/te_lsp_timers/state/install_delay (uint16)\n\n    YANG Description: delay the use of newly installed te lsp for a\nspecified amount of time.", "id": "f22189:c0:m2"}
{"signature": "def _set_reoptimize_timer(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__reoptimize_timer = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for reoptimize_timer, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/te_lsp_timers/state/reoptimize_timer (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_reoptimize_timer is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_reoptimize_timer() directly.\n\n    YANG Description: frequency of reoptimization of\na traffic engineered LSP", "id": "f22189:c1:m9"}
{"signature": "def _get_cleanup_delay(self):", "body": "return self.__cleanup_delay<EOL>", "docstring": "Getter method for cleanup_delay, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/te_lsp_timers/config/cleanup_delay (uint16)\n\n    YANG Description: delay the removal of old te lsp for a specified\namount of time", "id": "f22190:c0:m5"}
{"signature": "def _set_reoptimize_timer(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__reoptimize_timer = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for reoptimize_timer, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/te_lsp_timers/config/reoptimize_timer (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_reoptimize_timer is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_reoptimize_timer() directly.\n\n    YANG Description: frequency of reoptimization of\na traffic engineered LSP", "id": "f22190:c0:m9"}
{"signature": "def _get_install_delay(self):", "body": "return self.__install_delay<EOL>", "docstring": "Getter method for install_delay, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/te_lsp_timers/config/install_delay (uint16)\n\n    YANG Description: delay the use of newly installed te lsp for a\nspecified amount of time.", "id": "f22190:c1:m2"}
{"signature": "def _get_cleanup_delay(self):", "body": "return self.__cleanup_delay<EOL>", "docstring": "Getter method for cleanup_delay, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/te_lsp_timers/config/cleanup_delay (uint16)\n\n    YANG Description: delay the removal of old te lsp for a specified\namount of time", "id": "f22190:c1:m5"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/mpls/te_global_attributes/te_lsp_timers/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters related\nto timers for TE LSPs", "id": "f22191:c0:m3"}
{"signature": "def _set_signaling_protocols(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=signaling_protocols.signaling_protocols,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__signaling_protocols = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for signaling_protocols, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_signaling_protocols is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_signaling_protocols() directly.\n\nYANG Description: top-level signaling protocol configuration", "id": "f22192:c0:m12"}
{"signature": "def _get_mpls_enabled(self):", "body": "return self.__mpls_enabled<EOL>", "docstring": "Getter method for mpls_enabled, mapped from YANG variable /network_instances/network_instance/mpls/global/interface_attributes/interface/state/mpls_enabled (boolean)\n\nYANG Description: Enable MPLS forwarding on this interface", "id": "f22193:c1:m5"}
{"signature": "def _set_interface_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface_id, mapped from YANG variable /network_instances/network_instance/mpls/global/interface_attributes/interface/state/interface_id (oc-if:interface-id)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_interface_id is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_interface_id() directly.\n\nYANG Description: Indentifier for the MPLS interface", "id": "f22193:c0:m3"}
{"signature": "def _set_mpls_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__mpls_enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for mpls_enabled, mapped from YANG variable /network_instances/network_instance/mpls/global/interface_attributes/interface/state/mpls_enabled (boolean)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_mpls_enabled is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_mpls_enabled() directly.\n\nYANG Description: Enable MPLS forwarding on this interface", "id": "f22193:c0:m6"}
{"signature": "def _get_interface_id(self):", "body": "return self.__interface_id<EOL>", "docstring": "Getter method for interface_id, mapped from YANG variable /network_instances/network_instance/mpls/global/interface_attributes/interface/state/interface_id (oc-if:interface-id)\n\nYANG Description: Indentifier for the MPLS interface", "id": "f22193:c1:m2"}
{"signature": "def _get_mpls_enabled(self):", "body": "return self.__mpls_enabled<EOL>", "docstring": "Getter method for mpls_enabled, mapped from YANG variable /network_instances/network_instance/mpls/global/interface_attributes/interface/config/mpls_enabled (boolean)\n\nYANG Description: Enable MPLS forwarding on this interface", "id": "f22194:c0:m5"}
{"signature": "def _set_mpls_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__mpls_enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for mpls_enabled, mapped from YANG variable /network_instances/network_instance/mpls/global/interface_attributes/interface/config/mpls_enabled (boolean)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_mpls_enabled is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_mpls_enabled() directly.\n\nYANG Description: Enable MPLS forwarding on this interface", "id": "f22194:c0:m6"}
{"signature": "def _get_subinterface(self):", "body": "return self.__subinterface<EOL>", "docstring": "Getter method for subinterface, mapped from YANG variable /network_instances/network_instance/mpls/global/interface_attributes/interface/interface_ref/state/subinterface (leafref)\n\n    YANG Description: Reference to a subinterface -- this requires the base\ninterface to be specified using the interface leaf in\nthis container.  If only a reference to a base interface\nis requuired, this leaf should not be set.", "id": "f22195:c1:m5"}
{"signature": "def _set_subinterface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subinterface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subinterface, mapped from YANG variable /network_instances/network_instance/mpls/global/interface_attributes/interface/interface_ref/config/subinterface (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subinterface is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subinterface() directly.\n\n    YANG Description: Reference to a subinterface -- this requires the base\ninterface to be specified using the interface leaf in\nthis container.  If only a reference to a base interface\nis requuired, this leaf should not be set.", "id": "f22196:c1:m6"}
{"signature": "def _get_interface(self):", "body": "return self.__interface<EOL>", "docstring": "Getter method for interface, mapped from YANG variable /network_instances/network_instance/mpls/global/interface_attributes/interface/interface_ref/config/interface (leafref)\n\n    YANG Description: Reference to a base interface.  If a reference to a\nsubinterface is required, this leaf must be specified\nto indicate the base interface.", "id": "f22196:c0:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/mpls/global/interface_attributes/interface/interface_ref/state (container)\n\nYANG Description: Operational state for interface-ref", "id": "f22197:c0:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/mpls/global/interface_attributes/interface/interface_ref/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Operational state for interface-ref", "id": "f22197:c0:m6"}
{"signature": "def _get_interface_ref(self):", "body": "return self.__interface_ref<EOL>", "docstring": "Getter method for interface_ref, mapped from YANG variable /network_instances/network_instance/mpls/global/interface_attributes/interface/interface_ref (container)\n\nYANG Description: Reference to an interface or subinterface", "id": "f22198:c0:m11"}
{"signature": "def _set_interface_ref(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=interface_ref.interface_ref,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface_ref = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface_ref, mapped from YANG variable /network_instances/network_instance/mpls/global/interface_attributes/interface/interface_ref (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_interface_ref is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_interface_ref() directly.\n\nYANG Description: Reference to an interface or subinterface", "id": "f22198:c1:m12"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/mpls/global/interface_attributes/interface/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration parameters related to MPLS interfaces:", "id": "f22198:c1:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/mpls/global/interface_attributes/interface/state (container)\n\nYANG Description: State parameters related to TE interfaces", "id": "f22198:c0:m8"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/mpls/global/interface_attributes/interface/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters related to TE interfaces", "id": "f22198:c1:m9"}
{"signature": "def _set_interface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>interface.interface,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface, mapped from YANG variable /network_instances/network_instance/mpls/global/interface_attributes/interface (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_interface is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_interface() directly.\n\nYANG Description: List of TE interfaces", "id": "f22199:c0:m3"}
{"signature": "def _set_interface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>interface.interface,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface, mapped from YANG variable /network_instances/network_instance/mpls/global/interface_attributes/interface (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_interface is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_interface() directly.\n\nYANG Description: List of TE interfaces", "id": "f22199:c1:m3"}
{"signature": "def _set_null_label(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>default=six.text_type(\"<STR_LIT>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__null_label = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for null_label, mapped from YANG variable /network_instances/network_instance/mpls/global/state/null_label (identityref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_null_label is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_null_label() directly.\n\nYANG Description: The null-label type used, implicit or explicit", "id": "f22200:c0:m3"}
{"signature": "def _get_null_label(self):", "body": "return self.__null_label<EOL>", "docstring": "Getter method for null_label, mapped from YANG variable /network_instances/network_instance/mpls/global/state/null_label (identityref)\n\nYANG Description: The null-label type used, implicit or explicit", "id": "f22200:c0:m2"}
{"signature": "def _set_upper_bound(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:0>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:1>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:2>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:3>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:7>},<EOL>\"<STR_LIT>\": {},<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__upper_bound = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for upper_bound, mapped from YANG variable /network_instances/network_instance/mpls/global/reserved_label_blocks/reserved_label_block/state/upper_bound (oc-mplst:mpls-label)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_upper_bound is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_upper_bound() directly.\n\n    YANG Description: Upper bound for the global label block. The block is defined to include\nthis label.", "id": "f22201:c0:m9"}
{"signature": "def _get_local_id(self):", "body": "return self.__local_id<EOL>", "docstring": "Getter method for local_id, mapped from YANG variable /network_instances/network_instance/mpls/global/reserved_label_blocks/reserved_label_block/state/local_id (string)\n\nYANG Description: A local identifier for the global label block allocation.", "id": "f22201:c0:m2"}
{"signature": "def _set_lower_bound(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:0>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:1>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:2>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:3>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:7>},<EOL>\"<STR_LIT>\": {},<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__lower_bound = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for lower_bound, mapped from YANG variable /network_instances/network_instance/mpls/global/reserved_label_blocks/reserved_label_block/state/lower_bound (oc-mplst:mpls-label)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_lower_bound is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_lower_bound() directly.\n\n    YANG Description: Lower bound of the global label block. The block is defined to include\nthis label.", "id": "f22201:c0:m6"}
{"signature": "def _set_local_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__local_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for local_id, mapped from YANG variable /network_instances/network_instance/mpls/global/reserved_label_blocks/reserved_label_block/state/local_id (string)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_local_id is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_local_id() directly.\n\nYANG Description: A local identifier for the global label block allocation.", "id": "f22201:c0:m3"}
{"signature": "def _get_lower_bound(self):", "body": "return self.__lower_bound<EOL>", "docstring": "Getter method for lower_bound, mapped from YANG variable /network_instances/network_instance/mpls/global/reserved_label_blocks/reserved_label_block/state/lower_bound (oc-mplst:mpls-label)\n\n    YANG Description: Lower bound of the global label block. The block is defined to include\nthis label.", "id": "f22201:c1:m5"}
{"signature": "def _set_upper_bound(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:0>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:1>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:2>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:3>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:7>},<EOL>\"<STR_LIT>\": {},<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__upper_bound = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for upper_bound, mapped from YANG variable /network_instances/network_instance/mpls/global/reserved_label_blocks/reserved_label_block/config/upper_bound (oc-mplst:mpls-label)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_upper_bound is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_upper_bound() directly.\n\n    YANG Description: Upper bound for the global label block. The block is defined to include\nthis label.", "id": "f22202:c1:m9"}
{"signature": "def _set_upper_bound(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:0>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:1>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:2>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:3>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:7>},<EOL>\"<STR_LIT>\": {},<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__upper_bound = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for upper_bound, mapped from YANG variable /network_instances/network_instance/mpls/global/reserved_label_blocks/reserved_label_block/config/upper_bound (oc-mplst:mpls-label)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_upper_bound is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_upper_bound() directly.\n\n    YANG Description: Upper bound for the global label block. The block is defined to include\nthis label.", "id": "f22202:c0:m9"}
{"signature": "def _get_local_id(self):", "body": "return self.__local_id<EOL>", "docstring": "Getter method for local_id, mapped from YANG variable /network_instances/network_instance/mpls/global/reserved_label_blocks/reserved_label_block/config/local_id (string)\n\nYANG Description: A local identifier for the global label block allocation.", "id": "f22202:c1:m2"}
{"signature": "def _set_lower_bound(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:0>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:1>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:2>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:3>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:7>},<EOL>\"<STR_LIT>\": {},<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__lower_bound = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for lower_bound, mapped from YANG variable /network_instances/network_instance/mpls/global/reserved_label_blocks/reserved_label_block/config/lower_bound (oc-mplst:mpls-label)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_lower_bound is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_lower_bound() directly.\n\n    YANG Description: Lower bound of the global label block. The block is defined to include\nthis label.", "id": "f22202:c0:m6"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/mpls/global/reserved_label_blocks/reserved_label_block/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters relating to the label block.", "id": "f22203:c1:m9"}
{"signature": "def _set_local_id(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__local_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for local_id, mapped from YANG variable /network_instances/network_instance/mpls/global/reserved_label_blocks/reserved_label_block/local_id (leafref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_local_id is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_local_id() directly.\n\nYANG Description: A reference to a unique local identifier for this label block.", "id": "f22203:c1:m3"}
{"signature": "def _get_local_id(self):", "body": "return self.__local_id<EOL>", "docstring": "Getter method for local_id, mapped from YANG variable /network_instances/network_instance/mpls/global/reserved_label_blocks/reserved_label_block/local_id (leafref)\n\nYANG Description: A reference to a unique local identifier for this label block.", "id": "f22203:c1:m2"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/mpls/global/reserved_label_blocks/reserved_label_block/config (container)\n\nYANG Description: Configuration parameters relating to the label block.", "id": "f22203:c1:m5"}
{"signature": "def _set_reserved_label_block(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>reserved_label_block.reserved_label_block,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__reserved_label_block = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for reserved_label_block, mapped from YANG variable /network_instances/network_instance/mpls/global/reserved_label_blocks/reserved_label_block (list)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_reserved_label_block is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_reserved_label_block() directly.\n\n    YANG Description: A range of labels starting with the start-label up to and including\nthe end label that should be allocated for use by a specific protocol.", "id": "f22204:c1:m3"}
{"signature": "def _get_reserved_label_block(self):", "body": "return self.__reserved_label_block<EOL>", "docstring": "Getter method for reserved_label_block, mapped from YANG variable /network_instances/network_instance/mpls/global/reserved_label_blocks/reserved_label_block (list)\n\n    YANG Description: A range of labels starting with the start-label up to and including\nthe end label that should be allocated for use by a specific protocol.", "id": "f22204:c0:m2"}
{"signature": "def _get_null_label(self):", "body": "return self.__null_label<EOL>", "docstring": "Getter method for null_label, mapped from YANG variable /network_instances/network_instance/mpls/global/config/null_label (identityref)\n\nYANG Description: The null-label type used, implicit or explicit", "id": "f22205:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/mpls/global/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Top level global MPLS state", "id": "f22206:c1:m6"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/mpls/global/config (container)\n\nYANG Description: Top level global MPLS configuration", "id": "f22206:c0:m2"}
{"signature": "def _set_interface_attributes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=interface_attributes.interface_attributes,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface_attributes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface_attributes, mapped from YANG variable /network_instances/network_instance/mpls/global/interface_attributes (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_interface_attributes is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_interface_attributes() directly.\n\nYANG Description: Parameters related to MPLS interfaces", "id": "f22206:c0:m9"}
{"signature": "def _get_reserved_label_blocks(self):", "body": "return self.__reserved_label_blocks<EOL>", "docstring": "Getter method for reserved_label_blocks, mapped from YANG variable /network_instances/network_instance/mpls/global/reserved_label_blocks (container)\n\n    YANG Description: A range of labels starting with the start-label and up-to and including\nthe end label that should be allocated as reserved. These labels should\nnot be utilised by any dynamic label allocation on the local system unless\nthe allocating protocol is explicitly configured to specify that\nallocation of labels should be out of the label block specified.", "id": "f22206:c0:m11"}
{"signature": "def _set_te_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__te_metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for te_metric, mapped from YANG variable /network_instances/network_instance/mpls/te_interface_attributes/interface/state/te_metric (uint32)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_te_metric is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_te_metric() directly.\n\nYANG Description: TE specific metric for the link", "id": "f22207:c0:m6"}
{"signature": "def _get_srlg_membership(self):", "body": "return self.__srlg_membership<EOL>", "docstring": "Getter method for srlg_membership, mapped from YANG variable /network_instances/network_instance/mpls/te_interface_attributes/interface/state/srlg_membership (leafref)\n\n    YANG Description: list of references to named shared risk link groups that the\ninterface belongs to.", "id": "f22207:c1:m8"}
{"signature": "def _set_admin_group(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(allowed_type=six.text_type),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__admin_group = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for admin_group, mapped from YANG variable /network_instances/network_instance/mpls/te_interface_attributes/interface/state/admin_group (string)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_admin_group is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_admin_group() directly.\n\nYANG Description: list of admin groups (by name) on the interface", "id": "f22207:c0:m12"}
{"signature": "def _get_te_metric(self):", "body": "return self.__te_metric<EOL>", "docstring": "Getter method for te_metric, mapped from YANG variable /network_instances/network_instance/mpls/te_interface_attributes/interface/state/te_metric (uint32)\n\nYANG Description: TE specific metric for the link", "id": "f22207:c1:m5"}
{"signature": "def _get_interface_id(self):", "body": "return self.__interface_id<EOL>", "docstring": "Getter method for interface_id, mapped from YANG variable /network_instances/network_instance/mpls/te_interface_attributes/interface/state/interface_id (oc-if:interface-id)\n\nYANG Description: Id of the interface", "id": "f22207:c1:m2"}
{"signature": "def _set_srlg_membership(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(allowed_type=six.text_type),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__srlg_membership = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for srlg_membership, mapped from YANG variable /network_instances/network_instance/mpls/te_interface_attributes/interface/state/srlg_membership (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_srlg_membership is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_srlg_membership() directly.\n\n    YANG Description: list of references to named shared risk link groups that the\ninterface belongs to.", "id": "f22207:c0:m9"}
{"signature": "def _set_interface_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface_id, mapped from YANG variable /network_instances/network_instance/mpls/te_interface_attributes/interface/state/interface_id (oc-if:interface-id)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_interface_id is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_interface_id() directly.\n\nYANG Description: Id of the interface", "id": "f22207:c0:m3"}
{"signature": "def _set_te_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__te_metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for te_metric, mapped from YANG variable /network_instances/network_instance/mpls/te_interface_attributes/interface/state/te_metric (uint32)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_te_metric is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_te_metric() directly.\n\nYANG Description: TE specific metric for the link", "id": "f22207:c1:m6"}
{"signature": "def _get_srlg_membership(self):", "body": "return self.__srlg_membership<EOL>", "docstring": "Getter method for srlg_membership, mapped from YANG variable /network_instances/network_instance/mpls/te_interface_attributes/interface/config/srlg_membership (leafref)\n\n    YANG Description: list of references to named shared risk link groups that the\ninterface belongs to.", "id": "f22208:c0:m8"}
{"signature": "def _get_srlg_membership(self):", "body": "return self.__srlg_membership<EOL>", "docstring": "Getter method for srlg_membership, mapped from YANG variable /network_instances/network_instance/mpls/te_interface_attributes/interface/config/srlg_membership (leafref)\n\n    YANG Description: list of references to named shared risk link groups that the\ninterface belongs to.", "id": "f22208:c1:m8"}
{"signature": "def _set_te_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__te_metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for te_metric, mapped from YANG variable /network_instances/network_instance/mpls/te_interface_attributes/interface/config/te_metric (uint32)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_te_metric is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_te_metric() directly.\n\nYANG Description: TE specific metric for the link", "id": "f22208:c0:m6"}
{"signature": "def _get_interface_id(self):", "body": "return self.__interface_id<EOL>", "docstring": "Getter method for interface_id, mapped from YANG variable /network_instances/network_instance/mpls/te_interface_attributes/interface/config/interface_id (oc-if:interface-id)\n\nYANG Description: Id of the interface", "id": "f22208:c0:m2"}
{"signature": "def _get_interface(self):", "body": "return self.__interface<EOL>", "docstring": "Getter method for interface, mapped from YANG variable /network_instances/network_instance/mpls/te_interface_attributes/interface/interface_ref/state/interface (leafref)\n\n    YANG Description: Reference to a base interface.  If a reference to a\nsubinterface is required, this leaf must be specified\nto indicate the base interface.", "id": "f22209:c0:m2"}
{"signature": "def _get_subinterface(self):", "body": "return self.__subinterface<EOL>", "docstring": "Getter method for subinterface, mapped from YANG variable /network_instances/network_instance/mpls/te_interface_attributes/interface/interface_ref/state/subinterface (leafref)\n\n    YANG Description: Reference to a subinterface -- this requires the base\ninterface to be specified using the interface leaf in\nthis container.  If only a reference to a base interface\nis requuired, this leaf should not be set.", "id": "f22209:c0:m5"}
{"signature": "def _get_subinterface(self):", "body": "return self.__subinterface<EOL>", "docstring": "Getter method for subinterface, mapped from YANG variable /network_instances/network_instance/mpls/te_interface_attributes/interface/interface_ref/state/subinterface (leafref)\n\n    YANG Description: Reference to a subinterface -- this requires the base\ninterface to be specified using the interface leaf in\nthis container.  If only a reference to a base interface\nis requuired, this leaf should not be set.", "id": "f22209:c1:m5"}
{"signature": "def _set_subinterface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subinterface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subinterface, mapped from YANG variable /network_instances/network_instance/mpls/te_interface_attributes/interface/interface_ref/state/subinterface (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subinterface is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subinterface() directly.\n\n    YANG Description: Reference to a subinterface -- this requires the base\ninterface to be specified using the interface leaf in\nthis container.  If only a reference to a base interface\nis requuired, this leaf should not be set.", "id": "f22209:c1:m6"}
{"signature": "def _set_subinterface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subinterface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subinterface, mapped from YANG variable /network_instances/network_instance/mpls/te_interface_attributes/interface/interface_ref/config/subinterface (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subinterface is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subinterface() directly.\n\n    YANG Description: Reference to a subinterface -- this requires the base\ninterface to be specified using the interface leaf in\nthis container.  If only a reference to a base interface\nis requuired, this leaf should not be set.", "id": "f22210:c1:m6"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/mpls/te_interface_attributes/interface/interface_ref/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configured reference to interface / subinterface", "id": "f22211:c1:m3"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/mpls/te_interface_attributes/interface/interface_ref/config (container)\n\nYANG Description: Configured reference to interface / subinterface", "id": "f22211:c1:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/mpls/te_interface_attributes/interface/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters related to TE interfaces", "id": "f22212:c1:m9"}
{"signature": "def _get_interface_id(self):", "body": "return self.__interface_id<EOL>", "docstring": "Getter method for interface_id, mapped from YANG variable /network_instances/network_instance/mpls/te_interface_attributes/interface/interface_id (leafref)\n\nYANG Description: Reference to the interface id list key", "id": "f22212:c1:m2"}
{"signature": "def _set_igp_flooding_bandwidth(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=igp_flooding_bandwidth.igp_flooding_bandwidth,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__igp_flooding_bandwidth = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for igp_flooding_bandwidth, mapped from YANG variable /network_instances/network_instance/mpls/te_interface_attributes/interface/igp_flooding_bandwidth (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_igp_flooding_bandwidth is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_igp_flooding_bandwidth() directly.\n\n    YANG Description: Interface bandwidth change percentages\nthat trigger update events into the IGP traffic\nengineering database (TED)", "id": "f22212:c1:m15"}
{"signature": "def _set_igp_flooding_bandwidth(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=igp_flooding_bandwidth.igp_flooding_bandwidth,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__igp_flooding_bandwidth = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for igp_flooding_bandwidth, mapped from YANG variable /network_instances/network_instance/mpls/te_interface_attributes/interface/igp_flooding_bandwidth (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_igp_flooding_bandwidth is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_igp_flooding_bandwidth() directly.\n\n    YANG Description: Interface bandwidth change percentages\nthat trigger update events into the IGP traffic\nengineering database (TED)", "id": "f22212:c0:m15"}
{"signature": "def _get_igp_flooding_bandwidth(self):", "body": "return self.__igp_flooding_bandwidth<EOL>", "docstring": "Getter method for igp_flooding_bandwidth, mapped from YANG variable /network_instances/network_instance/mpls/te_interface_attributes/interface/igp_flooding_bandwidth (container)\n\n    YANG Description: Interface bandwidth change percentages\nthat trigger update events into the IGP traffic\nengineering database (TED)", "id": "f22212:c1:m14"}
{"signature": "def _set_interface_ref(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=interface_ref.interface_ref,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface_ref = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface_ref, mapped from YANG variable /network_instances/network_instance/mpls/te_interface_attributes/interface/interface_ref (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_interface_ref is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_interface_ref() directly.\n\nYANG Description: Reference to an interface or subinterface", "id": "f22212:c1:m12"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/mpls/te_interface_attributes/interface/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration parameters related to TE interfaces:", "id": "f22212:c1:m6"}
{"signature": "def _get_interface_id(self):", "body": "return self.__interface_id<EOL>", "docstring": "Getter method for interface_id, mapped from YANG variable /network_instances/network_instance/mpls/te_interface_attributes/interface/interface_id (leafref)\n\nYANG Description: Reference to the interface id list key", "id": "f22212:c0:m2"}
{"signature": "def _get_up_thresholds(self):", "body": "return self.__up_thresholds<EOL>", "docstring": "Getter method for up_thresholds, mapped from YANG variable /network_instances/network_instance/mpls/te_interface_attributes/interface/igp_flooding_bandwidth/state/up_thresholds (oc-types:percentage)\n\n    YANG Description: The thresholds (expressed as a percentage of the maximum\nreservable bandwidth) at which bandwidth updates are to be\ntriggered when the bandwidth is increasing.", "id": "f22213:c0:m11"}
{"signature": "def _set_down_thresholds(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__down_thresholds = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for down_thresholds, mapped from YANG variable /network_instances/network_instance/mpls/te_interface_attributes/interface/igp_flooding_bandwidth/state/down_thresholds (oc-types:percentage)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_down_thresholds is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_down_thresholds() directly.\n\n    YANG Description: The thresholds (expressed as a percentage of the maximum\nreservable bandwidth) at which bandwidth updates are to be\ntriggered when the bandwidth is decreasing.", "id": "f22213:c0:m15"}
{"signature": "def _set_up_thresholds(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__up_thresholds = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for up_thresholds, mapped from YANG variable /network_instances/network_instance/mpls/te_interface_attributes/interface/igp_flooding_bandwidth/state/up_thresholds (oc-types:percentage)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_up_thresholds is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_up_thresholds() directly.\n\n    YANG Description: The thresholds (expressed as a percentage of the maximum\nreservable bandwidth) at which bandwidth updates are to be\ntriggered when the bandwidth is increasing.", "id": "f22213:c1:m12"}
{"signature": "def _get_delta_percentage(self):", "body": "return self.__delta_percentage<EOL>", "docstring": "Getter method for delta_percentage, mapped from YANG variable /network_instances/network_instance/mpls/te_interface_attributes/interface/igp_flooding_bandwidth/config/delta_percentage (oc-types:percentage)\n\n    YANG Description: The percentage of the maximum-reservable-bandwidth\nconsidered as the delta that results in an IGP update\nbeing flooded", "id": "f22214:c1:m5"}
{"signature": "def _get_up_thresholds(self):", "body": "return self.__up_thresholds<EOL>", "docstring": "Getter method for up_thresholds, mapped from YANG variable /network_instances/network_instance/mpls/te_interface_attributes/interface/igp_flooding_bandwidth/config/up_thresholds (oc-types:percentage)\n\n    YANG Description: The thresholds (expressed as a percentage of the maximum\nreservable bandwidth) at which bandwidth updates are to be\ntriggered when the bandwidth is increasing.", "id": "f22214:c1:m11"}
{"signature": "def _set_up_thresholds(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__up_thresholds = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for up_thresholds, mapped from YANG variable /network_instances/network_instance/mpls/te_interface_attributes/interface/igp_flooding_bandwidth/config/up_thresholds (oc-types:percentage)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_up_thresholds is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_up_thresholds() directly.\n\n    YANG Description: The thresholds (expressed as a percentage of the maximum\nreservable bandwidth) at which bandwidth updates are to be\ntriggered when the bandwidth is increasing.", "id": "f22214:c1:m12"}
{"signature": "def _set_delta_percentage(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__delta_percentage = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for delta_percentage, mapped from YANG variable /network_instances/network_instance/mpls/te_interface_attributes/interface/igp_flooding_bandwidth/config/delta_percentage (oc-types:percentage)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_delta_percentage is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_delta_percentage() directly.\n\n    YANG Description: The percentage of the maximum-reservable-bandwidth\nconsidered as the delta that results in an IGP update\nbeing flooded", "id": "f22214:c0:m6"}
{"signature": "def _set_delta_percentage(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__delta_percentage = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for delta_percentage, mapped from YANG variable /network_instances/network_instance/mpls/te_interface_attributes/interface/igp_flooding_bandwidth/config/delta_percentage (oc-types:percentage)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_delta_percentage is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_delta_percentage() directly.\n\n    YANG Description: The percentage of the maximum-reservable-bandwidth\nconsidered as the delta that results in an IGP update\nbeing flooded", "id": "f22214:c1:m6"}
{"signature": "def _get_threshold_specification(self):", "body": "return self.__threshold_specification<EOL>", "docstring": "Getter method for threshold_specification, mapped from YANG variable /network_instances/network_instance/mpls/te_interface_attributes/interface/igp_flooding_bandwidth/config/threshold_specification (enumeration)\n\n    YANG Description: This value specifies whether a single set of threshold\nvalues should be used for both increasing and decreasing\nbandwidth when determining whether to trigger updated\nbandwidth values to be flooded in the IGP TE extensions.\nMIRRORED-UP-DOWN indicates that a single value (or set of\nvalues) should be used for both increasing and decreasing\nvalues, where SEPARATE-UP-DOWN specifies that the increasing\nand decreasing values will be separately specified", "id": "f22214:c0:m8"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/mpls/te_interface_attributes/interface/igp_flooding_bandwidth/state (container)\n\nYANG Description: State parameters for TED update threshold", "id": "f22215:c0:m5"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/mpls/te_interface_attributes/interface/igp_flooding_bandwidth/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters for TED\nupdate threshold", "id": "f22215:c1:m3"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/mpls/te_interface_attributes/interface/igp_flooding_bandwidth/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters for TED\nupdate threshold", "id": "f22215:c0:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/mpls/te_interface_attributes/interface/igp_flooding_bandwidth/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters for TED update threshold", "id": "f22215:c0:m6"}
{"signature": "def _set_interface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>interface.interface,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface, mapped from YANG variable /network_instances/network_instance/mpls/te_interface_attributes/interface (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_interface is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_interface() directly.\n\nYANG Description: List of TE interfaces", "id": "f22216:c0:m3"}
{"signature": "def _get_name(self):", "body": "return self.__name<EOL>", "docstring": "Getter method for name, mapped from YANG variable /network_instances/network_instance/mpls/lsps/static_lsps/static_lsp/state/name (string)\n\nYANG Description: name to identify the LSP", "id": "f22217:c1:m2"}
{"signature": "def _set_name(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:name>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for name, mapped from YANG variable /network_instances/network_instance/mpls/lsps/static_lsps/static_lsp/state/name (string)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_name is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_name() directly.\n\nYANG Description: name to identify the LSP", "id": "f22217:c1:m3"}
{"signature": "def _set_push_label(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:0>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:1>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:2>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:3>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:7>},<EOL>\"<STR_LIT>\": {},<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__push_label = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for push_label, mapped from YANG variable /network_instances/network_instance/mpls/lsps/static_lsps/static_lsp/egress/state/push_label (oc-mplst:mpls-label)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_push_label is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_push_label() directly.\n\n    YANG Description: label value to push at the current hop for the\nLSP", "id": "f22218:c0:m9"}
{"signature": "def _get_incoming_label(self):", "body": "return self.__incoming_label<EOL>", "docstring": "Getter method for incoming_label, mapped from YANG variable /network_instances/network_instance/mpls/lsps/static_lsps/static_lsp/egress/state/incoming_label (oc-mplst:mpls-label)\n\nYANG Description: label value on the incoming packet", "id": "f22218:c0:m5"}
{"signature": "def _set_next_hop(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__next_hop = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for next_hop, mapped from YANG variable /network_instances/network_instance/mpls/lsps/static_lsps/static_lsp/egress/state/next_hop (inet:ip-address)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_next_hop is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_next_hop() directly.\n\nYANG Description: next hop IP address for the LSP", "id": "f22218:c0:m3"}
{"signature": "def _get_next_hop(self):", "body": "return self.__next_hop<EOL>", "docstring": "Getter method for next_hop, mapped from YANG variable /network_instances/network_instance/mpls/lsps/static_lsps/static_lsp/egress/state/next_hop (inet:ip-address)\n\nYANG Description: next hop IP address for the LSP", "id": "f22218:c1:m2"}
{"signature": "def _get_next_hop(self):", "body": "return self.__next_hop<EOL>", "docstring": "Getter method for next_hop, mapped from YANG variable /network_instances/network_instance/mpls/lsps/static_lsps/static_lsp/egress/config/next_hop (inet:ip-address)\n\nYANG Description: next hop IP address for the LSP", "id": "f22219:c0:m2"}
{"signature": "def _get_push_label(self):", "body": "return self.__push_label<EOL>", "docstring": "Getter method for push_label, mapped from YANG variable /network_instances/network_instance/mpls/lsps/static_lsps/static_lsp/egress/config/push_label (oc-mplst:mpls-label)\n\n    YANG Description: label value to push at the current hop for the\nLSP", "id": "f22219:c0:m8"}
{"signature": "def _set_push_label(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:0>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:1>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:2>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:3>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:7>},<EOL>\"<STR_LIT>\": {},<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__push_label = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for push_label, mapped from YANG variable /network_instances/network_instance/mpls/lsps/static_lsps/static_lsp/egress/config/push_label (oc-mplst:mpls-label)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_push_label is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_push_label() directly.\n\n    YANG Description: label value to push at the current hop for the\nLSP", "id": "f22219:c0:m9"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/mpls/lsps/static_lsps/static_lsp/egress/config (container)\n\nYANG Description: Configuration data for egress LSPs", "id": "f22220:c0:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/mpls/lsps/static_lsps/static_lsp/egress/state (container)\n\nYANG Description: Operational state data for egress LSPs", "id": "f22220:c0:m5"}
{"signature": "def _set_incoming_label(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:0>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:1>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:2>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:3>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:7>},<EOL>\"<STR_LIT>\": {},<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__incoming_label = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for incoming_label, mapped from YANG variable /network_instances/network_instance/mpls/lsps/static_lsps/static_lsp/ingress/state/incoming_label (oc-mplst:mpls-label)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_incoming_label is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_incoming_label() directly.\n\nYANG Description: label value on the incoming packet", "id": "f22221:c0:m6"}
{"signature": "def _get_push_label(self):", "body": "return self.__push_label<EOL>", "docstring": "Getter method for push_label, mapped from YANG variable /network_instances/network_instance/mpls/lsps/static_lsps/static_lsp/ingress/config/push_label (oc-mplst:mpls-label)\n\n    YANG Description: label value to push at the current hop for the\nLSP", "id": "f22222:c1:m8"}
{"signature": "def _get_incoming_label(self):", "body": "return self.__incoming_label<EOL>", "docstring": "Getter method for incoming_label, mapped from YANG variable /network_instances/network_instance/mpls/lsps/static_lsps/static_lsp/ingress/config/incoming_label (oc-mplst:mpls-label)\n\nYANG Description: label value on the incoming packet", "id": "f22222:c0:m5"}
{"signature": "def _set_next_hop(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__next_hop = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for next_hop, mapped from YANG variable /network_instances/network_instance/mpls/lsps/static_lsps/static_lsp/ingress/config/next_hop (inet:ip-address)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_next_hop is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_next_hop() directly.\n\nYANG Description: next hop IP address for the LSP", "id": "f22222:c1:m3"}
{"signature": "def _set_next_hop(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__next_hop = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for next_hop, mapped from YANG variable /network_instances/network_instance/mpls/lsps/static_lsps/static_lsp/ingress/config/next_hop (inet:ip-address)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_next_hop is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_next_hop() directly.\n\nYANG Description: next hop IP address for the LSP", "id": "f22222:c0:m3"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/mpls/lsps/static_lsps/static_lsp/ingress/config (container)\n\nYANG Description: Configuration data for ingress LSPs", "id": "f22223:c0:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/mpls/lsps/static_lsps/static_lsp/ingress/state (container)\n\nYANG Description: Operational state data for ingress LSPs", "id": "f22223:c0:m5"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/mpls/lsps/static_lsps/static_lsp/ingress/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration data for ingress LSPs", "id": "f22223:c1:m3"}
{"signature": "def _get_name(self):", "body": "return self.__name<EOL>", "docstring": "Getter method for name, mapped from YANG variable /network_instances/network_instance/mpls/lsps/static_lsps/static_lsp/config/name (string)\n\nYANG Description: name to identify the LSP", "id": "f22224:c0:m2"}
{"signature": "def _set_name(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:name>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for name, mapped from YANG variable /network_instances/network_instance/mpls/lsps/static_lsps/static_lsp/name (leafref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_name is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_name() directly.\n\nYANG Description: Reference the name list key", "id": "f22225:c0:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/mpls/lsps/static_lsps/static_lsp/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Operational state data for the static lsp", "id": "f22225:c0:m9"}
{"signature": "def _get_name(self):", "body": "return self.__name<EOL>", "docstring": "Getter method for name, mapped from YANG variable /network_instances/network_instance/mpls/lsps/static_lsps/static_lsp/name (leafref)\n\nYANG Description: Reference the name list key", "id": "f22225:c1:m2"}
{"signature": "def _set_ingress(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=ingress.ingress,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ingress = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ingress, mapped from YANG variable /network_instances/network_instance/mpls/lsps/static_lsps/static_lsp/ingress (container)\n   If this variable is read-only (config: false) in the\n   source YANG file, then _set_ingress is considered as a private\n   method. Backends looking to populate this variable should\n   do so via calling thisObj._set_ingress() directly.\n\n   YANG Description: Static LSPs for which the router is an\ningress node", "id": "f22225:c1:m12"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/mpls/lsps/static_lsps/static_lsp/config (container)\n\nYANG Description: Configuration data for the static lsp", "id": "f22225:c1:m5"}
{"signature": "def _get_name(self):", "body": "return self.__name<EOL>", "docstring": "Getter method for name, mapped from YANG variable /network_instances/network_instance/mpls/lsps/static_lsps/static_lsp/name (leafref)\n\nYANG Description: Reference the name list key", "id": "f22225:c0:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/mpls/lsps/static_lsps/static_lsp/state (container)\n\nYANG Description: Operational state data for the static lsp", "id": "f22225:c1:m8"}
{"signature": "def _set_push_label(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:0>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:1>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:2>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:3>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:7>},<EOL>\"<STR_LIT>\": {},<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__push_label = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for push_label, mapped from YANG variable /network_instances/network_instance/mpls/lsps/static_lsps/static_lsp/transit/state/push_label (oc-mplst:mpls-label)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_push_label is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_push_label() directly.\n\n    YANG Description: label value to push at the current hop for the\nLSP", "id": "f22226:c0:m9"}
{"signature": "def _set_push_label(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:0>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:1>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:2>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:3>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:7>},<EOL>\"<STR_LIT>\": {},<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__push_label = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for push_label, mapped from YANG variable /network_instances/network_instance/mpls/lsps/static_lsps/static_lsp/transit/config/push_label (oc-mplst:mpls-label)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_push_label is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_push_label() directly.\n\n    YANG Description: label value to push at the current hop for the\nLSP", "id": "f22227:c1:m9"}
{"signature": "def _get_next_hop(self):", "body": "return self.__next_hop<EOL>", "docstring": "Getter method for next_hop, mapped from YANG variable /network_instances/network_instance/mpls/lsps/static_lsps/static_lsp/transit/config/next_hop (inet:ip-address)\n\nYANG Description: next hop IP address for the LSP", "id": "f22227:c1:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/mpls/lsps/static_lsps/static_lsp/transit/state (container)\n\nYANG Description: Operational state data for transit LSPs", "id": "f22228:c1:m5"}
{"signature": "def _get_static_lsp(self):", "body": "return self.__static_lsp<EOL>", "docstring": "Getter method for static_lsp, mapped from YANG variable /network_instances/network_instance/mpls/lsps/static_lsps/static_lsp (list)\n\nYANG Description: list of defined static LSPs", "id": "f22229:c1:m2"}
{"signature": "def _set_static_lsp(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT:name>\",<EOL>static_lsp.static_lsp,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT:name>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__static_lsp = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for static_lsp, mapped from YANG variable /network_instances/network_instance/mpls/lsps/static_lsps/static_lsp (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_static_lsp is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_static_lsp() directly.\n\nYANG Description: list of defined static LSPs", "id": "f22229:c1:m3"}
{"signature": "def _set_name(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:name>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for name, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/named_explicit_paths/named_explicit_path/state/name (string)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_name is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_name() directly.\n\n    YANG Description: A string name that uniquely identifies an explicit\npath", "id": "f22230:c0:m3"}
{"signature": "def _set_sid_selection_mode(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>default=six.text_type(\"<STR_LIT>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__sid_selection_mode = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for sid_selection_mode, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/named_explicit_paths/named_explicit_path/state/sid_selection_mode (enumeration)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_sid_selection_mode is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_sid_selection_mode() directly.\n\n    YANG Description: The restrictions placed on the SIDs to be selected by the\ncalculation method for the explicit path when it is\ninstantiated for a SR-TE LSP", "id": "f22230:c1:m6"}
{"signature": "def _set_sid_selection_mode(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>default=six.text_type(\"<STR_LIT>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__sid_selection_mode = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for sid_selection_mode, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/named_explicit_paths/named_explicit_path/state/sid_selection_mode (enumeration)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_sid_selection_mode is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_sid_selection_mode() directly.\n\n    YANG Description: The restrictions placed on the SIDs to be selected by the\ncalculation method for the explicit path when it is\ninstantiated for a SR-TE LSP", "id": "f22230:c0:m6"}
{"signature": "def _get_sid_selection_mode(self):", "body": "return self.__sid_selection_mode<EOL>", "docstring": "Getter method for sid_selection_mode, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/named_explicit_paths/named_explicit_path/state/sid_selection_mode (enumeration)\n\n    YANG Description: The restrictions placed on the SIDs to be selected by the\ncalculation method for the explicit path when it is\ninstantiated for a SR-TE LSP", "id": "f22230:c1:m5"}
{"signature": "def _get_sid_protection_required(self):", "body": "return self.__sid_protection_required<EOL>", "docstring": "Getter method for sid_protection_required, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/named_explicit_paths/named_explicit_path/state/sid_protection_required (boolean)\n\n    YANG Description: When this value is set to true, only SIDs that are\nprotected are to be selected by the calculating method\nwhen the explicit path is instantiated by a SR-TE LSP.", "id": "f22230:c0:m8"}
{"signature": "def _get_sid_protection_required(self):", "body": "return self.__sid_protection_required<EOL>", "docstring": "Getter method for sid_protection_required, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/named_explicit_paths/named_explicit_path/config/sid_protection_required (boolean)\n\n    YANG Description: When this value is set to true, only SIDs that are\nprotected are to be selected by the calculating method\nwhen the explicit path is instantiated by a SR-TE LSP.", "id": "f22231:c1:m8"}
{"signature": "def _get_sid_selection_mode(self):", "body": "return self.__sid_selection_mode<EOL>", "docstring": "Getter method for sid_selection_mode, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/named_explicit_paths/named_explicit_path/config/sid_selection_mode (enumeration)\n\n    YANG Description: The restrictions placed on the SIDs to be selected by the\ncalculation method for the explicit path when it is\ninstantiated for a SR-TE LSP", "id": "f22231:c0:m5"}
{"signature": "def _get_name(self):", "body": "return self.__name<EOL>", "docstring": "Getter method for name, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/named_explicit_paths/named_explicit_path/config/name (string)\n\n    YANG Description: A string name that uniquely identifies an explicit\npath", "id": "f22231:c1:m2"}
{"signature": "def _get_explicit_route_object(self):", "body": "return self.__explicit_route_object<EOL>", "docstring": "Getter method for explicit_route_object, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/named_explicit_paths/named_explicit_path/explicit_route_objects/explicit_route_object (list)\n\nYANG Description: List of explicit route objects", "id": "f22232:c1:m2"}
{"signature": "def _get_explicit_route_object(self):", "body": "return self.__explicit_route_object<EOL>", "docstring": "Getter method for explicit_route_object, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/named_explicit_paths/named_explicit_path/explicit_route_objects/explicit_route_object (list)\n\nYANG Description: List of explicit route objects", "id": "f22232:c0:m2"}
{"signature": "def _get_hop_type(self):", "body": "return self.__hop_type<EOL>", "docstring": "Getter method for hop_type, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/named_explicit_paths/named_explicit_path/explicit_route_objects/explicit_route_object/state/hop_type (mpls-hop-type)\n\nYANG Description: strict or loose hop", "id": "f22233:c0:m5"}
{"signature": "def _get_hop_type(self):", "body": "return self.__hop_type<EOL>", "docstring": "Getter method for hop_type, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/named_explicit_paths/named_explicit_path/explicit_route_objects/explicit_route_object/state/hop_type (mpls-hop-type)\n\nYANG Description: strict or loose hop", "id": "f22233:c1:m5"}
{"signature": "def _get_address(self):", "body": "return self.__address<EOL>", "docstring": "Getter method for address, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/named_explicit_paths/named_explicit_path/explicit_route_objects/explicit_route_object/config/address (inet:ip-address)\n\nYANG Description: router hop for the LSP path", "id": "f22234:c0:m2"}
{"signature": "def _set_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:address>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for address, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/named_explicit_paths/named_explicit_path/explicit_route_objects/explicit_route_object/config/address (inet:ip-address)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_address is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_address() directly.\n\nYANG Description: router hop for the LSP path", "id": "f22234:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/named_explicit_paths/named_explicit_path/explicit_route_objects/explicit_route_object/state (container)\n\nYANG Description: State parameters relating to an explicit route", "id": "f22235:c1:m8"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/named_explicit_paths/named_explicit_path/explicit_route_objects/explicit_route_object/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to an explicit\nroute", "id": "f22235:c1:m6"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/named_explicit_paths/named_explicit_path/explicit_route_objects/explicit_route_object/config (container)\n\n    YANG Description: Configuration parameters relating to an explicit\nroute", "id": "f22235:c0:m5"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/named_explicit_paths/named_explicit_path/state (container)\n\n    YANG Description: Operational state parameters relating to the named\nexplicit paths", "id": "f22236:c1:m8"}
{"signature": "def _get_name(self):", "body": "return self.__name<EOL>", "docstring": "Getter method for name, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/named_explicit_paths/named_explicit_path/name (leafref)\n\n    YANG Description: A string name that uniquely identifies\nan explicit path", "id": "f22236:c1:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/named_explicit_paths/named_explicit_path/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: Operational state parameters relating to the named\nexplicit paths", "id": "f22236:c1:m9"}
{"signature": "def _set_name(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:name>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for name, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/named_explicit_paths/named_explicit_path/name (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_name is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_name() directly.\n\n    YANG Description: A string name that uniquely identifies\nan explicit path", "id": "f22236:c0:m3"}
{"signature": "def _set_explicit_route_objects(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=explicit_route_objects.explicit_route_objects,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__explicit_route_objects = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for explicit_route_objects, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/named_explicit_paths/named_explicit_path/explicit_route_objects (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_explicit_route_objects is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_explicit_route_objects() directly.\n\nYANG Description: Enclosing container for EROs", "id": "f22236:c1:m12"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/named_explicit_paths/named_explicit_path/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to named explicit\npaths", "id": "f22236:c0:m6"}
{"signature": "def _set_named_explicit_path(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT:name>\",<EOL>named_explicit_path.named_explicit_path,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT:name>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__named_explicit_path = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for named_explicit_path, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/named_explicit_paths/named_explicit_path (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_named_explicit_path is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_named_explicit_path() directly.\n\nYANG Description: A list of explicit paths", "id": "f22237:c0:m3"}
{"signature": "def _get_description(self):", "body": "return self.__description<EOL>", "docstring": "Getter method for description, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/state/description (string)\n\nYANG Description: optional text description for the tunnel", "id": "f22239:c1:m11"}
{"signature": "def _get_setup_priority(self):", "body": "return self.__setup_priority<EOL>", "docstring": "Getter method for setup_priority, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/state/setup_priority (uint8)\n\n    YANG Description: RSVP-TE preemption priority during LSP setup, lower is\nhigher priority; default 7 indicates that LSP will not\npreempt established LSPs during setup", "id": "f22239:c0:m41"}
{"signature": "def _set_oper_status(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__oper_status = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for oper_status, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/state/oper_status (identityref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_oper_status is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_oper_status() directly.\n\nYANG Description: The operational status of the TE tunnel", "id": "f22239:c0:m48"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/state/type (identityref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_type is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_type() directly.\n\nYANG Description: Tunnel type, p2p or p2mp", "id": "f22239:c1:m6"}
{"signature": "def _get_role(self):", "body": "return self.__role<EOL>", "docstring": "Getter method for role, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/state/role (identityref)\n\n    YANG Description: The lsp role at the current node, whether it is headend,\ntransit or tailend.", "id": "f22239:c0:m50"}
{"signature": "def _set_source(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:source>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__source = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for source, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/state/source (inet:ip-address)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_source is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_source() directly.\n\nYANG Description: RSVP-TE tunnel source address", "id": "f22239:c1:m36"}
{"signature": "def _set_admin_status(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>default=six.text_type(\"<STR_LIT>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__admin_status = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for admin_status, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/state/admin_status (identityref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_admin_status is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_admin_status() directly.\n\nYANG Description: TE tunnel administrative state.", "id": "f22239:c0:m15"}
{"signature": "def _get_preference(self):", "body": "return self.__preference<EOL>", "docstring": "Getter method for preference, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/state/preference (uint8)\n\n    YANG Description: Specifies a preference for this tunnel.\nA lower number signifies a better preference", "id": "f22239:c0:m17"}
{"signature": "def _get_counters(self):", "body": "return self.__counters<EOL>", "docstring": "Getter method for counters, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/state/counters (container)\n\n    YANG Description: State data for MPLS label switched paths. This state\ndata is specific to a single label switched path.", "id": "f22239:c1:m53"}
{"signature": "def _set_signaling_protocol(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__signaling_protocol = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for signaling_protocol, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/state/signaling_protocol (identityref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_signaling_protocol is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_signaling_protocol() directly.\n\nYANG Description: Signaling protocol used to set up this tunnel", "id": "f22239:c1:m9"}
{"signature": "def _get_setup_priority(self):", "body": "return self.__setup_priority<EOL>", "docstring": "Getter method for setup_priority, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/state/setup_priority (uint8)\n\n    YANG Description: RSVP-TE preemption priority during LSP setup, lower is\nhigher priority; default 7 indicates that LSP will not\npreempt established LSPs during setup", "id": "f22239:c1:m41"}
{"signature": "def _set_description(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:description>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__description = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for description, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/state/description (string)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_description is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_description() directly.\n\nYANG Description: optional text description for the tunnel", "id": "f22239:c1:m12"}
{"signature": "def _set_setup_priority(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>default=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>)(<EOL><NUM_LIT:7><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__setup_priority = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for setup_priority, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/state/setup_priority (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_setup_priority is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_setup_priority() directly.\n\n    YANG Description: RSVP-TE preemption priority during LSP setup, lower is\nhigher priority; default 7 indicates that LSP will not\npreempt established LSPs during setup", "id": "f22239:c0:m42"}
{"signature": "def _get_soft_preemption(self):", "body": "return self.__soft_preemption<EOL>", "docstring": "Getter method for soft_preemption, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/state/soft_preemption (boolean)\n\nYANG Description: Enables RSVP soft-preemption on this LSP", "id": "f22239:c1:m38"}
{"signature": "def _set_counters(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=counters.counters,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__counters = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for counters, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/state/counters (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_counters is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_counters() directly.\n\n    YANG Description: State data for MPLS label switched paths. This state\ndata is specific to a single label switched path.", "id": "f22239:c1:m54"}
{"signature": "def _set_description(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:description>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__description = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for description, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/state/description (string)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_description is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_description() directly.\n\nYANG Description: optional text description for the tunnel", "id": "f22239:c0:m12"}
{"signature": "def _set_admin_status(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>default=six.text_type(\"<STR_LIT>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__admin_status = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for admin_status, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/state/admin_status (identityref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_admin_status is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_admin_status() directly.\n\nYANG Description: TE tunnel administrative state.", "id": "f22239:c1:m15"}
{"signature": "def _set_preference(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__preference = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for preference, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/state/preference (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_preference is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_preference() directly.\n\n    YANG Description: Specifies a preference for this tunnel.\nA lower number signifies a better preference", "id": "f22239:c0:m18"}
{"signature": "def _get_bytes(self):", "body": "return self.__bytes<EOL>", "docstring": "Getter method for bytes, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/state/counters/bytes (yang:counter64)\n\n    YANG Description: Number of bytes that have been forwarded over the\nlabel switched path.", "id": "f22240:c1:m2"}
{"signature": "def _get_current_path_time(self):", "body": "return self.__current_path_time<EOL>", "docstring": "Getter method for current_path_time, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/state/counters/current_path_time (yang:date-and-time)\n\n    YANG Description: Indicates the time the LSP switched onto its\ncurrent path. This is reset upon a LSP path\nchange.", "id": "f22240:c1:m17"}
{"signature": "def _get_next_reoptimization_time(self):", "body": "return self.__next_reoptimization_time<EOL>", "docstring": "Getter method for next_reoptimization_time, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/state/counters/next_reoptimization_time (yang:date-and-time)\n\n    YANG Description: Indicates the next scheduled time the LSP\nwill be reoptimized.", "id": "f22240:c0:m20"}
{"signature": "def _set_bytes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__bytes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for bytes, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/state/counters/bytes (yang:counter64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_bytes is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_bytes() directly.\n\n    YANG Description: Number of bytes that have been forwarded over the\nlabel switched path.", "id": "f22240:c1:m3"}
{"signature": "def _get_next_reoptimization_time(self):", "body": "return self.__next_reoptimization_time<EOL>", "docstring": "Getter method for next_reoptimization_time, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/state/counters/next_reoptimization_time (yang:date-and-time)\n\n    YANG Description: Indicates the next scheduled time the LSP\nwill be reoptimized.", "id": "f22240:c1:m20"}
{"signature": "def _set_next_reoptimization_time(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__next_reoptimization_time = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for next_reoptimization_time, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/state/counters/next_reoptimization_time (yang:date-and-time)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_next_reoptimization_time is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_next_reoptimization_time() directly.\n\n    YANG Description: Indicates the next scheduled time the LSP\nwill be reoptimized.", "id": "f22240:c1:m21"}
{"signature": "def _get_state_changes(self):", "body": "return self.__state_changes<EOL>", "docstring": "Getter method for state_changes, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/state/counters/state_changes (yang:counter64)\n\nYANG Description: Number of state changes for the label switched path", "id": "f22240:c0:m11"}
{"signature": "def _get_signaled_bandwidth(self):", "body": "return self.__signaled_bandwidth<EOL>", "docstring": "Getter method for signaled_bandwidth, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/state/signaled_bandwidth (oc-mplst:bandwidth-kbps)\n\n    YANG Description: The currently signaled bandwidth of the LSP. In the case where\nthe bandwidth is specified explicitly, then this will match the\nvalue of the set-bandwidth leaf; in cases where the bandwidth is\ndynamically computed by the system, the current value of the\nbandwidth should be reflected.", "id": "f22241:c1:m8"}
{"signature": "def _set_specification_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>default=six.text_type(\"<STR_LIT>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__specification_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for specification_type, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/state/specification_type (te-bandwidth-type)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_specification_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_specification_type() directly.\n\n    YANG Description: The method used for settign the bandwidth, either explicitly\nspecified or configured", "id": "f22241:c1:m3"}
{"signature": "def _get_signaled_bandwidth(self):", "body": "return self.__signaled_bandwidth<EOL>", "docstring": "Getter method for signaled_bandwidth, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/state/signaled_bandwidth (oc-mplst:bandwidth-kbps)\n\n    YANG Description: The currently signaled bandwidth of the LSP. In the case where\nthe bandwidth is specified explicitly, then this will match the\nvalue of the set-bandwidth leaf; in cases where the bandwidth is\ndynamically computed by the system, the current value of the\nbandwidth should be reflected.", "id": "f22241:c0:m8"}
{"signature": "def _set_adjust_threshold(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__adjust_threshold = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for adjust_threshold, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/auto_bandwidth/state/adjust_threshold (oc-types:percentage)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_adjust_threshold is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_adjust_threshold() directly.\n\n    YANG Description: percentage difference between the LSP's\nspecified bandwidth and its current bandwidth\nallocation -- if the difference is greater than the\nspecified percentage, auto-bandwidth adjustment is\ntriggered", "id": "f22242:c1:m15"}
{"signature": "def _get_min_bw(self):", "body": "return self.__min_bw<EOL>", "docstring": "Getter method for min_bw, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/auto_bandwidth/state/min_bw (oc-mplst:bandwidth-kbps)\n\n    YANG Description: set the minimum bandwidth in Kbps for an\nauto-bandwidth LSP", "id": "f22242:c1:m5"}
{"signature": "def _get_adjust_interval(self):", "body": "return self.__adjust_interval<EOL>", "docstring": "Getter method for adjust_interval, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/auto_bandwidth/state/adjust_interval (uint32)\n\n    YANG Description: time in seconds between adjustments to\nLSP bandwidth", "id": "f22242:c0:m11"}
{"signature": "def _set_max_bw(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__max_bw = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for max_bw, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/auto_bandwidth/state/max_bw (oc-mplst:bandwidth-kbps)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_max_bw is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_max_bw() directly.\n\n    YANG Description: set the maximum bandwidth in Kbps for an\nauto-bandwidth LSP", "id": "f22242:c1:m9"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/auto_bandwidth/state/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: enables mpls auto-bandwidth on the\nlsp", "id": "f22242:c0:m3"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/auto_bandwidth/state/enabled (boolean)\n\n    YANG Description: enables mpls auto-bandwidth on the\nlsp", "id": "f22242:c1:m2"}
{"signature": "def _set_max_bw(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__max_bw = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for max_bw, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/auto_bandwidth/state/max_bw (oc-mplst:bandwidth-kbps)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_max_bw is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_max_bw() directly.\n\n    YANG Description: set the maximum bandwidth in Kbps for an\nauto-bandwidth LSP", "id": "f22242:c0:m9"}
{"signature": "def _get_overflow_threshold(self):", "body": "return self.__overflow_threshold<EOL>", "docstring": "Getter method for overflow_threshold, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/auto_bandwidth/overflow/state/overflow_threshold (oc-types:percentage)\n\n    YANG Description: bandwidth percentage change to trigger\nan overflow event", "id": "f22243:c1:m5"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/auto_bandwidth/overflow/state/enabled (boolean)\n\n    YANG Description: enables mpls lsp bandwidth overflow\nadjustment on the lsp", "id": "f22243:c0:m2"}
{"signature": "def _set_trigger_event_count(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__trigger_event_count = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for trigger_event_count, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/auto_bandwidth/overflow/state/trigger_event_count (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_trigger_event_count is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_trigger_event_count() directly.\n\n    YANG Description: number of consecutive overflow sample\nevents needed to trigger an overflow adjustment", "id": "f22243:c1:m9"}
{"signature": "def _get_trigger_event_count(self):", "body": "return self.__trigger_event_count<EOL>", "docstring": "Getter method for trigger_event_count, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/auto_bandwidth/overflow/state/trigger_event_count (uint16)\n\n    YANG Description: number of consecutive overflow sample\nevents needed to trigger an overflow adjustment", "id": "f22243:c0:m8"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/auto_bandwidth/overflow/state/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: enables mpls lsp bandwidth overflow\nadjustment on the lsp", "id": "f22243:c0:m3"}
{"signature": "def _get_trigger_event_count(self):", "body": "return self.__trigger_event_count<EOL>", "docstring": "Getter method for trigger_event_count, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/auto_bandwidth/overflow/config/trigger_event_count (uint16)\n\n    YANG Description: number of consecutive overflow sample\nevents needed to trigger an overflow adjustment", "id": "f22244:c1:m8"}
{"signature": "def _set_overflow_threshold(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__overflow_threshold = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for overflow_threshold, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/auto_bandwidth/overflow/config/overflow_threshold (oc-types:percentage)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_overflow_threshold is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_overflow_threshold() directly.\n\n    YANG Description: bandwidth percentage change to trigger\nan overflow event", "id": "f22244:c0:m6"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/auto_bandwidth/overflow/config/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: enables mpls lsp bandwidth overflow\nadjustment on the lsp", "id": "f22244:c0:m3"}
{"signature": "def _set_adjust_threshold(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__adjust_threshold = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for adjust_threshold, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/auto_bandwidth/config/adjust_threshold (oc-types:percentage)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_adjust_threshold is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_adjust_threshold() directly.\n\n    YANG Description: percentage difference between the LSP's\nspecified bandwidth and its current bandwidth\nallocation -- if the difference is greater than the\nspecified percentage, auto-bandwidth adjustment is\ntriggered", "id": "f22246:c0:m15"}
{"signature": "def _set_adjust_threshold(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__adjust_threshold = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for adjust_threshold, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/auto_bandwidth/config/adjust_threshold (oc-types:percentage)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_adjust_threshold is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_adjust_threshold() directly.\n\n    YANG Description: percentage difference between the LSP's\nspecified bandwidth and its current bandwidth\nallocation -- if the difference is greater than the\nspecified percentage, auto-bandwidth adjustment is\ntriggered", "id": "f22246:c1:m15"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/auto_bandwidth/config/enabled (boolean)\n\n    YANG Description: enables mpls auto-bandwidth on the\nlsp", "id": "f22246:c0:m2"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/auto_bandwidth/config/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: enables mpls auto-bandwidth on the\nlsp", "id": "f22246:c0:m3"}
{"signature": "def _get_adjust_threshold(self):", "body": "return self.__adjust_threshold<EOL>", "docstring": "Getter method for adjust_threshold, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/auto_bandwidth/config/adjust_threshold (oc-types:percentage)\n\n    YANG Description: percentage difference between the LSP's\nspecified bandwidth and its current bandwidth\nallocation -- if the difference is greater than the\nspecified percentage, auto-bandwidth adjustment is\ntriggered", "id": "f22246:c0:m14"}
{"signature": "def _get_max_bw(self):", "body": "return self.__max_bw<EOL>", "docstring": "Getter method for max_bw, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/auto_bandwidth/config/max_bw (oc-mplst:bandwidth-kbps)\n\n    YANG Description: set the maximum bandwidth in Kbps for an\nauto-bandwidth LSP", "id": "f22246:c0:m8"}
{"signature": "def _get_underflow_threshold(self):", "body": "return self.__underflow_threshold<EOL>", "docstring": "Getter method for underflow_threshold, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/auto_bandwidth/underflow/state/underflow_threshold (oc-types:percentage)\n\n    YANG Description: bandwidth percentage change to trigger\nand underflow event", "id": "f22247:c0:m5"}
{"signature": "def _set_underflow_threshold(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__underflow_threshold = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for underflow_threshold, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/auto_bandwidth/underflow/state/underflow_threshold (oc-types:percentage)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_underflow_threshold is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_underflow_threshold() directly.\n\n    YANG Description: bandwidth percentage change to trigger\nand underflow event", "id": "f22247:c0:m6"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/auto_bandwidth/underflow/state/enabled (boolean)\n\n    YANG Description: enables bandwidth underflow\nadjustment on the lsp", "id": "f22247:c0:m2"}
{"signature": "def _set_underflow_threshold(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__underflow_threshold = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for underflow_threshold, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/auto_bandwidth/underflow/state/underflow_threshold (oc-types:percentage)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_underflow_threshold is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_underflow_threshold() directly.\n\n    YANG Description: bandwidth percentage change to trigger\nand underflow event", "id": "f22247:c1:m6"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/auto_bandwidth/underflow/state/enabled (boolean)\n\n    YANG Description: enables bandwidth underflow\nadjustment on the lsp", "id": "f22247:c1:m2"}
{"signature": "def _set_trigger_event_count(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__trigger_event_count = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for trigger_event_count, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/auto_bandwidth/underflow/state/trigger_event_count (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_trigger_event_count is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_trigger_event_count() directly.\n\n    YANG Description: number of consecutive underflow sample\nevents needed to trigger an underflow adjustment", "id": "f22247:c0:m9"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/auto_bandwidth/underflow/config/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: enables bandwidth underflow\nadjustment on the lsp", "id": "f22248:c1:m3"}
{"signature": "def _set_underflow_threshold(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__underflow_threshold = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for underflow_threshold, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/auto_bandwidth/underflow/config/underflow_threshold (oc-types:percentage)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_underflow_threshold is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_underflow_threshold() directly.\n\n    YANG Description: bandwidth percentage change to trigger\nand underflow event", "id": "f22248:c1:m6"}
{"signature": "def _set_trigger_event_count(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__trigger_event_count = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for trigger_event_count, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/auto_bandwidth/underflow/config/trigger_event_count (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_trigger_event_count is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_trigger_event_count() directly.\n\n    YANG Description: number of consecutive underflow sample\nevents needed to trigger an underflow adjustment", "id": "f22248:c1:m9"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/auto_bandwidth/underflow/config (container)\n\n    YANG Description: Config information for MPLS underflow bandwidth\nadjustment", "id": "f22249:c1:m2"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/auto_bandwidth/config (container)\n\n    YANG Description: Configuration parameters relating to MPLS\nauto-bandwidth on the tunnel.", "id": "f22250:c1:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/auto_bandwidth/state (container)\n\n    YANG Description: State parameters relating to MPLS\nauto-bandwidth on the tunnel.", "id": "f22250:c0:m5"}
{"signature": "def _get_underflow(self):", "body": "return self.__underflow<EOL>", "docstring": "Getter method for underflow, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/auto_bandwidth/underflow (container)\n\n    YANG Description: configuration of MPLS underflow bandwidth\nadjustement for the LSP", "id": "f22250:c1:m11"}
{"signature": "def _set_overflow(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=overflow.overflow,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__overflow = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for overflow, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/auto_bandwidth/overflow (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_overflow is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_overflow() directly.\n\n    YANG Description: configuration of MPLS overflow bandwidth\nadjustement for the LSP", "id": "f22250:c1:m9"}
{"signature": "def _get_set_bandwidth(self):", "body": "return self.__set_bandwidth<EOL>", "docstring": "Getter method for set_bandwidth, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/config/set_bandwidth (oc-mplst:bandwidth-kbps)\n\n    YANG Description: set bandwidth explicitly, e.g., using\noffline calculation", "id": "f22251:c1:m5"}
{"signature": "def _set_set_bandwidth(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__set_bandwidth = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for set_bandwidth, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/config/set_bandwidth (oc-mplst:bandwidth-kbps)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_set_bandwidth is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_set_bandwidth() directly.\n\n    YANG Description: set bandwidth explicitly, e.g., using\noffline calculation", "id": "f22251:c0:m6"}
{"signature": "def _set_specification_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>default=six.text_type(\"<STR_LIT>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__specification_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for specification_type, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/config/specification_type (te-bandwidth-type)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_specification_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_specification_type() directly.\n\n    YANG Description: The method used for settign the bandwidth, either explicitly\nspecified or configured", "id": "f22251:c1:m3"}
{"signature": "def _get_auto_bandwidth(self):", "body": "return self.__auto_bandwidth<EOL>", "docstring": "Getter method for auto_bandwidth, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/auto_bandwidth (container)\n\nYANG Description: Parameters related to auto-bandwidth", "id": "f22252:c0:m8"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/config (container)\n\n    YANG Description: Configuration parameters related to bandwidth on TE\ntunnels:", "id": "f22252:c0:m2"}
{"signature": "def _set_auto_bandwidth(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=auto_bandwidth.auto_bandwidth,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__auto_bandwidth = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for auto_bandwidth, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/auto_bandwidth (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_auto_bandwidth is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_auto_bandwidth() directly.\n\nYANG Description: Parameters related to auto-bandwidth", "id": "f22252:c1:m9"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/state (container)\n\n    YANG Description: State parameters related to bandwidth\nconfiguration of TE tunnels", "id": "f22252:c0:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: State parameters related to bandwidth\nconfiguration of TE tunnels", "id": "f22252:c1:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/state (container)\n\n    YANG Description: State parameters related to bandwidth\nconfiguration of TE tunnels", "id": "f22252:c1:m5"}
{"signature": "def _set_auto_bandwidth(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=auto_bandwidth.auto_bandwidth,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__auto_bandwidth = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for auto_bandwidth, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth/auto_bandwidth (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_auto_bandwidth is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_auto_bandwidth() directly.\n\nYANG Description: Parameters related to auto-bandwidth", "id": "f22252:c0:m9"}
{"signature": "def _get_soft_preemption(self):", "body": "return self.__soft_preemption<EOL>", "docstring": "Getter method for soft_preemption, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/config/soft_preemption (boolean)\n\nYANG Description: Enables RSVP soft-preemption on this LSP", "id": "f22253:c1:m38"}
{"signature": "def _get_shortcut_eligible(self):", "body": "return self.__shortcut_eligible<EOL>", "docstring": "Getter method for shortcut_eligible, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/config/shortcut_eligible (boolean)\n\n    YANG Description: Whether this LSP is considered to be eligible for us as a\nshortcut in the IGP. In the case that this leaf is set to\ntrue, the IGP SPF calculation uses the metric specified to\ndetermine whether traffic should be carried over this LSP", "id": "f22253:c0:m26"}
{"signature": "def _get_metric(self):", "body": "return self.__metric<EOL>", "docstring": "Getter method for metric, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/config/metric (int32)\n\n    YANG Description: The value of the metric that should be specified. The value\nsupplied in this leaf is used in conjunction with the metric\ntype to determine the value of the metric used by the system.\nWhere the metric-type is set to LSP_METRIC_ABSOLUTE - the\nvalue of this leaf is used directly; where it is set to\nLSP_METRIC_RELATIVE, the relevant (positive or negative)\noffset is used to formulate the metric; where metric-type\nis LSP_METRIC_INHERITED, the value of this leaf is not\nutilised", "id": "f22253:c1:m23"}
{"signature": "def _get_protection_style_requested(self):", "body": "return self.__protection_style_requested<EOL>", "docstring": "Getter method for protection_style_requested, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/config/protection_style_requested (identityref)\n\n    YANG Description: style of mpls frr protection desired: can be\nlink, link-node or unprotected.", "id": "f22253:c1:m29"}
{"signature": "def _get_setup_priority(self):", "body": "return self.__setup_priority<EOL>", "docstring": "Getter method for setup_priority, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/config/setup_priority (uint8)\n\n    YANG Description: RSVP-TE preemption priority during LSP setup, lower is\nhigher priority; default 7 indicates that LSP will not\npreempt established LSPs during setup", "id": "f22253:c0:m41"}
{"signature": "def _set_admin_status(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>default=six.text_type(\"<STR_LIT>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__admin_status = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for admin_status, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/config/admin_status (identityref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_admin_status is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_admin_status() directly.\n\nYANG Description: TE tunnel administrative state.", "id": "f22253:c1:m15"}
{"signature": "def _set_preference(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__preference = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for preference, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/config/preference (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_preference is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_preference() directly.\n\n    YANG Description: Specifies a preference for this tunnel.\nA lower number signifies a better preference", "id": "f22253:c0:m18"}
{"signature": "def _set_protection_style_requested(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>default=six.text_type(\"<STR_LIT>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__protection_style_requested = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for protection_style_requested, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/config/protection_style_requested (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_protection_style_requested is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_protection_style_requested() directly.\n\n    YANG Description: style of mpls frr protection desired: can be\nlink, link-node or unprotected.", "id": "f22253:c0:m30"}
{"signature": "def _get_admin_status(self):", "body": "return self.__admin_status<EOL>", "docstring": "Getter method for admin_status, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/config/admin_status (identityref)\n\nYANG Description: TE tunnel administrative state.", "id": "f22253:c0:m14"}
{"signature": "def _get_reoptimize_timer(self):", "body": "return self.__reoptimize_timer<EOL>", "docstring": "Getter method for reoptimize_timer, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/config/reoptimize_timer (uint16)\n\n    YANG Description: frequency of reoptimization of\na traffic engineered LSP", "id": "f22253:c1:m32"}
{"signature": "def _get_type(self):", "body": "return self.__type<EOL>", "docstring": "Getter method for type, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/config/type (identityref)\n\nYANG Description: Tunnel type, p2p or p2mp", "id": "f22253:c0:m5"}
{"signature": "def _set_signaling_protocol(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__signaling_protocol = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for signaling_protocol, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/config/signaling_protocol (identityref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_signaling_protocol is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_signaling_protocol() directly.\n\nYANG Description: Signaling protocol used to set up this tunnel", "id": "f22253:c0:m9"}
{"signature": "def _get_metric_type(self):", "body": "return self.__metric_type<EOL>", "docstring": "Getter method for metric_type, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/config/metric_type (identityref)\n\n    YANG Description: The type of metric specification that should be used to set\nthe LSP(s) metric", "id": "f22253:c1:m20"}
{"signature": "def _get_soft_preemption(self):", "body": "return self.__soft_preemption<EOL>", "docstring": "Getter method for soft_preemption, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/config/soft_preemption (boolean)\n\nYANG Description: Enables RSVP soft-preemption on this LSP", "id": "f22253:c0:m38"}
{"signature": "def _set_setup_priority(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>default=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>)(<EOL><NUM_LIT:7><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__setup_priority = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for setup_priority, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/config/setup_priority (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_setup_priority is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_setup_priority() directly.\n\n    YANG Description: RSVP-TE preemption priority during LSP setup, lower is\nhigher priority; default 7 indicates that LSP will not\npreempt established LSPs during setup", "id": "f22253:c1:m42"}
{"signature": "def _set_source(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:source>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__source = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for source, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/config/source (inet:ip-address)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_source is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_source() directly.\n\nYANG Description: RSVP-TE tunnel source address", "id": "f22253:c1:m36"}
{"signature": "def _get_p2p_tunnel_attributes(self):", "body": "return self.__p2p_tunnel_attributes<EOL>", "docstring": "Getter method for p2p_tunnel_attributes, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes (container)\n\nYANG Description: Parameters related to LSPs of type P2P", "id": "f22254:c0:m14"}
{"signature": "def _set_p2p_tunnel_attributes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=p2p_tunnel_attributes.p2p_tunnel_attributes,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__p2p_tunnel_attributes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for p2p_tunnel_attributes, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_p2p_tunnel_attributes is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_p2p_tunnel_attributes() directly.\n\nYANG Description: Parameters related to LSPs of type P2P", "id": "f22254:c0:m15"}
{"signature": "def _set_bandwidth(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=bandwidth.bandwidth,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__bandwidth = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for bandwidth, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_bandwidth is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_bandwidth() directly.\n\nYANG Description: Bandwidth configuration for TE LSPs", "id": "f22254:c0:m12"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/config (container)\n\nYANG Description: Configuration parameters related to TE tunnels:", "id": "f22254:c0:m5"}
{"signature": "def _get_bandwidth(self):", "body": "return self.__bandwidth<EOL>", "docstring": "Getter method for bandwidth, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/bandwidth (container)\n\nYANG Description: Bandwidth configuration for TE LSPs", "id": "f22254:c1:m11"}
{"signature": "def _set_destination(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__destination = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for destination, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/state/destination (inet:ip-address)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_destination is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_destination() directly.\n\nYANG Description: P2P tunnel destination address", "id": "f22255:c0:m3"}
{"signature": "def _set_p2p_secondary_path(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT:name>\",<EOL>p2p_secondary_path.p2p_secondary_path,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT:name>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__p2p_secondary_path = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for p2p_secondary_path, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_secondary_paths/p2p_secondary_path (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_p2p_secondary_path is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_p2p_secondary_path() directly.\n\nYANG Description: List of p2p primary paths for a tunnel", "id": "f22256:c1:m3"}
{"signature": "def _set_path_computation_server(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__path_computation_server = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for path_computation_server, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_secondary_paths/p2p_secondary_path/state/path_computation_server (inet:ip-address)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_path_computation_server is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_path_computation_server() directly.\n\n    YANG Description: Address of the external path computation\nserver", "id": "f22257:c1:m15"}
{"signature": "def _get_setup_priority(self):", "body": "return self.__setup_priority<EOL>", "docstring": "Getter method for setup_priority, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_secondary_paths/p2p_secondary_path/state/setup_priority (uint8)\n\n    YANG Description: RSVP-TE preemption priority during LSP setup, lower is\nhigher priority; default 7 indicates that LSP will not\npreempt established LSPs during setup", "id": "f22257:c0:m23"}
{"signature": "def _get_explicit_path_name(self):", "body": "return self.__explicit_path_name<EOL>", "docstring": "Getter method for explicit_path_name, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_secondary_paths/p2p_secondary_path/state/explicit_path_name (leafref)\n\nYANG Description: reference to a defined path", "id": "f22257:c0:m17"}
{"signature": "def _get_retry_timer(self):", "body": "return self.__retry_timer<EOL>", "docstring": "Getter method for retry_timer, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_secondary_paths/p2p_secondary_path/state/retry_timer (uint16)\n\n    YANG Description: sets the time between attempts to establish the\nLSP", "id": "f22257:c0:m29"}
{"signature": "def _set_name(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:name>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for name, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_secondary_paths/p2p_secondary_path/state/name (string)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_name is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_name() directly.\n\nYANG Description: Path name", "id": "f22257:c0:m3"}
{"signature": "def _get_hold_priority(self):", "body": "return self.__hold_priority<EOL>", "docstring": "Getter method for hold_priority, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_secondary_paths/p2p_secondary_path/state/hold_priority (uint8)\n\n    YANG Description: preemption priority once the LSP is established,\nlower is higher priority; default 0 indicates other LSPs\nwill not preempt the LSPs once established", "id": "f22257:c1:m26"}
{"signature": "def _set_setup_priority(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>default=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>)(<EOL><NUM_LIT:7><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__setup_priority = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for setup_priority, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_secondary_paths/p2p_secondary_path/state/setup_priority (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_setup_priority is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_setup_priority() directly.\n\n    YANG Description: RSVP-TE preemption priority during LSP setup, lower is\nhigher priority; default 7 indicates that LSP will not\npreempt established LSPs during setup", "id": "f22257:c1:m24"}
{"signature": "def _get_name(self):", "body": "return self.__name<EOL>", "docstring": "Getter method for name, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_secondary_paths/p2p_secondary_path/state/name (string)\n\nYANG Description: Path name", "id": "f22257:c1:m2"}
{"signature": "def _get_cspf_tiebreaker(self):", "body": "return self.__cspf_tiebreaker<EOL>", "docstring": "Getter method for cspf_tiebreaker, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_secondary_paths/p2p_secondary_path/state/cspf_tiebreaker (cspf-tie-breaking)\n\n    YANG Description: Determine the tie-breaking method to choose between\nequally desirable paths during CSFP computation", "id": "f22257:c1:m11"}
{"signature": "def _get_explicit_path_name(self):", "body": "return self.__explicit_path_name<EOL>", "docstring": "Getter method for explicit_path_name, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_secondary_paths/p2p_secondary_path/state/explicit_path_name (leafref)\n\nYANG Description: reference to a defined path", "id": "f22257:c1:m17"}
{"signature": "def _set_setup_priority(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>default=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>)(<EOL><NUM_LIT:7><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__setup_priority = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for setup_priority, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_secondary_paths/p2p_secondary_path/state/setup_priority (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_setup_priority is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_setup_priority() directly.\n\n    YANG Description: RSVP-TE preemption priority during LSP setup, lower is\nhigher priority; default 7 indicates that LSP will not\npreempt established LSPs during setup", "id": "f22257:c0:m24"}
{"signature": "def _set_cspf_tiebreaker(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>default=six.text_type(\"<STR_LIT>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__cspf_tiebreaker = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for cspf_tiebreaker, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_secondary_paths/p2p_secondary_path/state/cspf_tiebreaker (cspf-tie-breaking)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_cspf_tiebreaker is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_cspf_tiebreaker() directly.\n\n    YANG Description: Determine the tie-breaking method to choose between\nequally desirable paths during CSFP computation", "id": "f22257:c0:m12"}
{"signature": "def _get_use_cspf(self):", "body": "return self.__use_cspf<EOL>", "docstring": "Getter method for use_cspf, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_secondary_paths/p2p_secondary_path/state/use_cspf (boolean)\n\nYANG Description: Flag to enable CSPF for locally computed LSPs", "id": "f22257:c0:m8"}
{"signature": "def _set_name(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:name>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for name, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_secondary_paths/p2p_secondary_path/state/name (string)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_name is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_name() directly.\n\nYANG Description: Path name", "id": "f22257:c1:m3"}
{"signature": "def _get_hold_priority(self):", "body": "return self.__hold_priority<EOL>", "docstring": "Getter method for hold_priority, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_secondary_paths/p2p_secondary_path/state/hold_priority (uint8)\n\n    YANG Description: preemption priority once the LSP is established,\nlower is higher priority; default 0 indicates other LSPs\nwill not preempt the LSPs once established", "id": "f22257:c0:m26"}
{"signature": "def _get_include_any_group(self):", "body": "return self.__include_any_group<EOL>", "docstring": "Getter method for include_any_group, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_secondary_paths/p2p_secondary_path/admin_groups/state/include_any_group (leafref)\n\n    YANG Description: list of references to named admin-groups of which one must\nbe included", "id": "f22258:c1:m8"}
{"signature": "def _set_include_all_group(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(allowed_type=six.text_type),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__include_all_group = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for include_all_group, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_secondary_paths/p2p_secondary_path/admin_groups/state/include_all_group (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_include_all_group is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_include_all_group() directly.\n\n    YANG Description: list of references to named admin-groups of which all must\nbe included", "id": "f22258:c0:m6"}
{"signature": "def _set_include_all_group(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(allowed_type=six.text_type),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__include_all_group = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for include_all_group, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_secondary_paths/p2p_secondary_path/admin_groups/config/include_all_group (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_include_all_group is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_include_all_group() directly.\n\n    YANG Description: list of references to named admin-groups of which all must\nbe included", "id": "f22259:c0:m6"}
{"signature": "def _get_include_any_group(self):", "body": "return self.__include_any_group<EOL>", "docstring": "Getter method for include_any_group, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_secondary_paths/p2p_secondary_path/admin_groups/config/include_any_group (leafref)\n\n    YANG Description: list of references to named admin-groups of which one must\nbe included", "id": "f22259:c0:m8"}
{"signature": "def _get_exclude_group(self):", "body": "return self.__exclude_group<EOL>", "docstring": "Getter method for exclude_group, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_secondary_paths/p2p_secondary_path/admin_groups/config/exclude_group (leafref)\n\n    YANG Description: list of references to named admin-groups to exclude in\npath calculation.", "id": "f22259:c0:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_secondary_paths/p2p_secondary_path/admin_groups/state (container)\n\nYANG Description: Operational state data", "id": "f22260:c1:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_secondary_paths/p2p_secondary_path/admin_groups/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Operational state data", "id": "f22260:c1:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_secondary_paths/p2p_secondary_path/admin_groups/state (container)\n\nYANG Description: Operational state data", "id": "f22260:c0:m5"}
{"signature": "def _set_setup_priority(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>default=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>)(<EOL><NUM_LIT:7><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__setup_priority = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for setup_priority, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_secondary_paths/p2p_secondary_path/config/setup_priority (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_setup_priority is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_setup_priority() directly.\n\n    YANG Description: RSVP-TE preemption priority during LSP setup, lower is\nhigher priority; default 7 indicates that LSP will not\npreempt established LSPs during setup", "id": "f22261:c1:m24"}
{"signature": "def _get_hold_priority(self):", "body": "return self.__hold_priority<EOL>", "docstring": "Getter method for hold_priority, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_secondary_paths/p2p_secondary_path/config/hold_priority (uint8)\n\n    YANG Description: preemption priority once the LSP is established,\nlower is higher priority; default 0 indicates other LSPs\nwill not preempt the LSPs once established", "id": "f22261:c1:m26"}
{"signature": "def _set_name(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:name>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for name, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_secondary_paths/p2p_secondary_path/config/name (string)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_name is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_name() directly.\n\nYANG Description: Path name", "id": "f22261:c0:m3"}
{"signature": "def _get_retry_timer(self):", "body": "return self.__retry_timer<EOL>", "docstring": "Getter method for retry_timer, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_secondary_paths/p2p_secondary_path/config/retry_timer (uint16)\n\n    YANG Description: sets the time between attempts to establish the\nLSP", "id": "f22261:c0:m29"}
{"signature": "def _set_path_computation_server(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__path_computation_server = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for path_computation_server, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_secondary_paths/p2p_secondary_path/config/path_computation_server (inet:ip-address)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_path_computation_server is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_path_computation_server() directly.\n\n    YANG Description: Address of the external path computation\nserver", "id": "f22261:c1:m15"}
{"signature": "def _set_path_computation_method(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>default=six.text_type(\"<STR_LIT>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__path_computation_method = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for path_computation_method, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_secondary_paths/p2p_secondary_path/config/path_computation_method (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_path_computation_method is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_path_computation_method() directly.\n\n    YANG Description: The method used for computing the path, either\nlocally computed, queried from a server or not\ncomputed at all (explicitly configured).", "id": "f22261:c1:m6"}
{"signature": "def _get_path_computation_server(self):", "body": "return self.__path_computation_server<EOL>", "docstring": "Getter method for path_computation_server, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_secondary_paths/p2p_secondary_path/config/path_computation_server (inet:ip-address)\n\n    YANG Description: Address of the external path computation\nserver", "id": "f22261:c0:m14"}
{"signature": "def _get_use_cspf(self):", "body": "return self.__use_cspf<EOL>", "docstring": "Getter method for use_cspf, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_secondary_paths/p2p_secondary_path/config/use_cspf (boolean)\n\nYANG Description: Flag to enable CSPF for locally computed LSPs", "id": "f22261:c0:m8"}
{"signature": "def _set_explicit_path_name(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__explicit_path_name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for explicit_path_name, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_secondary_paths/p2p_secondary_path/config/explicit_path_name (leafref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_explicit_path_name is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_explicit_path_name() directly.\n\nYANG Description: reference to a defined path", "id": "f22261:c1:m18"}
{"signature": "def _get_explicit_path_name(self):", "body": "return self.__explicit_path_name<EOL>", "docstring": "Getter method for explicit_path_name, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_secondary_paths/p2p_secondary_path/config/explicit_path_name (leafref)\n\nYANG Description: reference to a defined path", "id": "f22261:c1:m17"}
{"signature": "def _set_hold_priority(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>default=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>)(<EOL><NUM_LIT:0><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__hold_priority = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for hold_priority, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_secondary_paths/p2p_secondary_path/config/hold_priority (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_hold_priority is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_hold_priority() directly.\n\n    YANG Description: preemption priority once the LSP is established,\nlower is higher priority; default 0 indicates other LSPs\nwill not preempt the LSPs once established", "id": "f22261:c0:m27"}
{"signature": "def _set_admin_groups(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=admin_groups.admin_groups,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__admin_groups = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for admin_groups, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_secondary_paths/p2p_secondary_path/admin_groups (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_admin_groups is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_admin_groups() directly.\n\n    YANG Description: Top-level container for include/exclude constraints for\nlink affinities", "id": "f22262:c0:m12"}
{"signature": "def _set_admin_groups(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=admin_groups.admin_groups,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__admin_groups = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for admin_groups, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_secondary_paths/p2p_secondary_path/admin_groups (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_admin_groups is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_admin_groups() directly.\n\n    YANG Description: Top-level container for include/exclude constraints for\nlink affinities", "id": "f22262:c1:m12"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_secondary_paths/p2p_secondary_path/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration parameters related to paths", "id": "f22262:c1:m6"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_secondary_paths/p2p_secondary_path/config (container)\n\nYANG Description: Configuration parameters related to paths", "id": "f22262:c1:m5"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_secondary_paths/p2p_secondary_path/state (container)\n\nYANG Description: State parameters related to paths", "id": "f22262:c0:m8"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_secondary_paths/p2p_secondary_path/config (container)\n\nYANG Description: Configuration parameters related to paths", "id": "f22262:c0:m5"}
{"signature": "def _set_preference(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__preference = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for preference, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/state/preference (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_preference is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_preference() directly.\n\n    YANG Description: Specifies a preference for this path. The lower the\nnumber higher the preference", "id": "f22263:c0:m21"}
{"signature": "def _set_name(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:name>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for name, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/state/name (string)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_name is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_name() directly.\n\nYANG Description: Path name", "id": "f22263:c0:m3"}
{"signature": "def _set_retry_timer(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:16>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__retry_timer = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for retry_timer, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/state/retry_timer (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_retry_timer is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_retry_timer() directly.\n\n    YANG Description: sets the time between attempts to establish the\nLSP", "id": "f22263:c0:m30"}
{"signature": "def _get_path_computation_method(self):", "body": "return self.__path_computation_method<EOL>", "docstring": "Getter method for path_computation_method, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/state/path_computation_method (identityref)\n\n    YANG Description: The method used for computing the path, either\nlocally computed, queried from a server or not\ncomputed at all (explicitly configured).", "id": "f22263:c1:m5"}
{"signature": "def _set_use_cspf(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__use_cspf = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for use_cspf, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/state/use_cspf (boolean)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_use_cspf is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_use_cspf() directly.\n\nYANG Description: Flag to enable CSPF for locally computed LSPs", "id": "f22263:c1:m9"}
{"signature": "def _get_setup_priority(self):", "body": "return self.__setup_priority<EOL>", "docstring": "Getter method for setup_priority, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/state/setup_priority (uint8)\n\n    YANG Description: RSVP-TE preemption priority during LSP setup, lower is\nhigher priority; default 7 indicates that LSP will not\npreempt established LSPs during setup", "id": "f22263:c1:m23"}
{"signature": "def _get_hold_priority(self):", "body": "return self.__hold_priority<EOL>", "docstring": "Getter method for hold_priority, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/state/hold_priority (uint8)\n\n    YANG Description: preemption priority once the LSP is established,\nlower is higher priority; default 0 indicates other LSPs\nwill not preempt the LSPs once established", "id": "f22263:c1:m26"}
{"signature": "def _get_associated_rsvp_session(self):", "body": "return self.__associated_rsvp_session<EOL>", "docstring": "Getter method for associated_rsvp_session, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/state/associated_rsvp_session (leafref)\n\n    YANG Description: If the signalling protocol specified for this path is\nRSVP-TE, this leaf provides a reference to the associated\nsession within the RSVP-TE protocol sessions list, such\nthat details of the signaling can be retrieved.", "id": "f22263:c1:m32"}
{"signature": "def _get_retry_timer(self):", "body": "return self.__retry_timer<EOL>", "docstring": "Getter method for retry_timer, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/state/retry_timer (uint16)\n\n    YANG Description: sets the time between attempts to establish the\nLSP", "id": "f22263:c0:m29"}
{"signature": "def _set_associated_rsvp_session(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__associated_rsvp_session = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for associated_rsvp_session, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/state/associated_rsvp_session (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_associated_rsvp_session is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_associated_rsvp_session() directly.\n\n    YANG Description: If the signalling protocol specified for this path is\nRSVP-TE, this leaf provides a reference to the associated\nsession within the RSVP-TE protocol sessions list, such\nthat details of the signaling can be retrieved.", "id": "f22263:c1:m33"}
{"signature": "def _set_retry_timer(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:16>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__retry_timer = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for retry_timer, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/state/retry_timer (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_retry_timer is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_retry_timer() directly.\n\n    YANG Description: sets the time between attempts to establish the\nLSP", "id": "f22263:c1:m30"}
{"signature": "def _set_hold_priority(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>default=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>)(<EOL><NUM_LIT:0><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__hold_priority = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for hold_priority, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/state/hold_priority (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_hold_priority is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_hold_priority() directly.\n\n    YANG Description: preemption priority once the LSP is established,\nlower is higher priority; default 0 indicates other LSPs\nwill not preempt the LSPs once established", "id": "f22263:c0:m27"}
{"signature": "def _set_candidate_secondary_path(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>candidate_secondary_path.candidate_secondary_path,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__candidate_secondary_path = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for candidate_secondary_path, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/candidate_secondary_paths/candidate_secondary_path (list)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_candidate_secondary_path is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_candidate_secondary_path() directly.\n\n    YANG Description: List of secondary paths which may be utilised when the\ncurrent primary path is in use", "id": "f22264:c1:m3"}
{"signature": "def _get_candidate_secondary_path(self):", "body": "return self.__candidate_secondary_path<EOL>", "docstring": "Getter method for candidate_secondary_path, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/candidate_secondary_paths/candidate_secondary_path (list)\n\n    YANG Description: List of secondary paths which may be utilised when the\ncurrent primary path is in use", "id": "f22264:c0:m2"}
{"signature": "def _get_candidate_secondary_path(self):", "body": "return self.__candidate_secondary_path<EOL>", "docstring": "Getter method for candidate_secondary_path, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/candidate_secondary_paths/candidate_secondary_path (list)\n\n    YANG Description: List of secondary paths which may be utilised when the\ncurrent primary path is in use", "id": "f22264:c1:m2"}
{"signature": "def _get_secondary_path(self):", "body": "return self.__secondary_path<EOL>", "docstring": "Getter method for secondary_path, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/candidate_secondary_paths/candidate_secondary_path/state/secondary_path (leafref)\n\n    YANG Description: A reference to the secondary path that should be utilised\nwhen the containing primary path option is in use", "id": "f22265:c0:m2"}
{"signature": "def _set_secondary_path(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__secondary_path = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for secondary_path, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/candidate_secondary_paths/candidate_secondary_path/state/secondary_path (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_secondary_path is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_secondary_path() directly.\n\n    YANG Description: A reference to the secondary path that should be utilised\nwhen the containing primary path option is in use", "id": "f22265:c1:m3"}
{"signature": "def _set_secondary_path(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__secondary_path = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for secondary_path, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/candidate_secondary_paths/candidate_secondary_path/state/secondary_path (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_secondary_path is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_secondary_path() directly.\n\n    YANG Description: A reference to the secondary path that should be utilised\nwhen the containing primary path option is in use", "id": "f22265:c0:m3"}
{"signature": "def _set_priority(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__priority = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for priority, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/candidate_secondary_paths/candidate_secondary_path/config/priority (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_priority is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_priority() directly.\n\n    YANG Description: The priority of the specified secondary path option. Higher\npriority options are less preferable - such that a secondary\npath reference with a priority of 0 is the most preferred", "id": "f22266:c0:m6"}
{"signature": "def _set_secondary_path(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__secondary_path = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for secondary_path, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/candidate_secondary_paths/candidate_secondary_path/config/secondary_path (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_secondary_path is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_secondary_path() directly.\n\n    YANG Description: A reference to the secondary path that should be utilised\nwhen the containing primary path option is in use", "id": "f22266:c1:m3"}
{"signature": "def _set_secondary_path(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__secondary_path = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for secondary_path, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/candidate_secondary_paths/candidate_secondary_path/config/secondary_path (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_secondary_path is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_secondary_path() directly.\n\n    YANG Description: A reference to the secondary path that should be utilised\nwhen the containing primary path option is in use", "id": "f22266:c0:m3"}
{"signature": "def _get_secondary_path(self):", "body": "return self.__secondary_path<EOL>", "docstring": "Getter method for secondary_path, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/candidate_secondary_paths/candidate_secondary_path/secondary_path (leafref)\n\n    YANG Description: A reference to the secondary path option reference\nwhich acts as the key of the candidate-secondary-path\nlist", "id": "f22267:c1:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/candidate_secondary_paths/candidate_secondary_path/state (container)\n\n    YANG Description: Operational state parameters relating to the candidate\nsecondary path", "id": "f22267:c0:m8"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/candidate_secondary_paths/candidate_secondary_path/state (container)\n\n    YANG Description: Operational state parameters relating to the candidate\nsecondary path", "id": "f22267:c1:m8"}
{"signature": "def _get_include_any_group(self):", "body": "return self.__include_any_group<EOL>", "docstring": "Getter method for include_any_group, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/admin_groups/state/include_any_group (leafref)\n\n    YANG Description: list of references to named admin-groups of which one must\nbe included", "id": "f22268:c1:m8"}
{"signature": "def _set_include_any_group(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(allowed_type=six.text_type),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__include_any_group = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for include_any_group, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/admin_groups/state/include_any_group (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_include_any_group is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_include_any_group() directly.\n\n    YANG Description: list of references to named admin-groups of which one must\nbe included", "id": "f22268:c0:m9"}
{"signature": "def _get_exclude_group(self):", "body": "return self.__exclude_group<EOL>", "docstring": "Getter method for exclude_group, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/admin_groups/state/exclude_group (leafref)\n\n    YANG Description: list of references to named admin-groups to exclude in\npath calculation.", "id": "f22268:c0:m2"}
{"signature": "def _set_include_all_group(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(allowed_type=six.text_type),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__include_all_group = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for include_all_group, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/admin_groups/state/include_all_group (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_include_all_group is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_include_all_group() directly.\n\n    YANG Description: list of references to named admin-groups of which all must\nbe included", "id": "f22268:c1:m6"}
{"signature": "def _set_include_all_group(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(allowed_type=six.text_type),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__include_all_group = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for include_all_group, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/admin_groups/config/include_all_group (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_include_all_group is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_include_all_group() directly.\n\n    YANG Description: list of references to named admin-groups of which all must\nbe included", "id": "f22269:c0:m6"}
{"signature": "def _get_exclude_group(self):", "body": "return self.__exclude_group<EOL>", "docstring": "Getter method for exclude_group, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/admin_groups/config/exclude_group (leafref)\n\n    YANG Description: list of references to named admin-groups to exclude in\npath calculation.", "id": "f22269:c1:m2"}
{"signature": "def _get_include_all_group(self):", "body": "return self.__include_all_group<EOL>", "docstring": "Getter method for include_all_group, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/admin_groups/config/include_all_group (leafref)\n\n    YANG Description: list of references to named admin-groups of which all must\nbe included", "id": "f22269:c1:m5"}
{"signature": "def _get_exclude_group(self):", "body": "return self.__exclude_group<EOL>", "docstring": "Getter method for exclude_group, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/admin_groups/config/exclude_group (leafref)\n\n    YANG Description: list of references to named admin-groups to exclude in\npath calculation.", "id": "f22269:c0:m2"}
{"signature": "def _get_include_any_group(self):", "body": "return self.__include_any_group<EOL>", "docstring": "Getter method for include_any_group, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/admin_groups/config/include_any_group (leafref)\n\n    YANG Description: list of references to named admin-groups of which one must\nbe included", "id": "f22269:c0:m8"}
{"signature": "def _set_exclude_group(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(allowed_type=six.text_type),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__exclude_group = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for exclude_group, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/admin_groups/config/exclude_group (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_exclude_group is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_exclude_group() directly.\n\n    YANG Description: list of references to named admin-groups to exclude in\npath calculation.", "id": "f22269:c0:m3"}
{"signature": "def _set_include_any_group(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(allowed_type=six.text_type),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__include_any_group = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for include_any_group, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/admin_groups/config/include_any_group (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_include_any_group is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_include_any_group() directly.\n\n    YANG Description: list of references to named admin-groups of which one must\nbe included", "id": "f22269:c1:m9"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/admin_groups/config (container)\n\nYANG Description: Configuration data", "id": "f22270:c1:m2"}
{"signature": "def _get_setup_priority(self):", "body": "return self.__setup_priority<EOL>", "docstring": "Getter method for setup_priority, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/config/setup_priority (uint8)\n\n    YANG Description: RSVP-TE preemption priority during LSP setup, lower is\nhigher priority; default 7 indicates that LSP will not\npreempt established LSPs during setup", "id": "f22271:c1:m23"}
{"signature": "def _get_name(self):", "body": "return self.__name<EOL>", "docstring": "Getter method for name, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/config/name (string)\n\nYANG Description: Path name", "id": "f22271:c1:m2"}
{"signature": "def _get_explicit_path_name(self):", "body": "return self.__explicit_path_name<EOL>", "docstring": "Getter method for explicit_path_name, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/config/explicit_path_name (leafref)\n\nYANG Description: reference to a defined path", "id": "f22271:c0:m17"}
{"signature": "def _get_preference(self):", "body": "return self.__preference<EOL>", "docstring": "Getter method for preference, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/config/preference (uint8)\n\n    YANG Description: Specifies a preference for this path. The lower the\nnumber higher the preference", "id": "f22271:c0:m20"}
{"signature": "def _get_path_computation_method(self):", "body": "return self.__path_computation_method<EOL>", "docstring": "Getter method for path_computation_method, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/config/path_computation_method (identityref)\n\n    YANG Description: The method used for computing the path, either\nlocally computed, queried from a server or not\ncomputed at all (explicitly configured).", "id": "f22271:c1:m5"}
{"signature": "def _get_cspf_tiebreaker(self):", "body": "return self.__cspf_tiebreaker<EOL>", "docstring": "Getter method for cspf_tiebreaker, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/config/cspf_tiebreaker (cspf-tie-breaking)\n\n    YANG Description: Determine the tie-breaking method to choose between\nequally desirable paths during CSFP computation", "id": "f22271:c1:m11"}
{"signature": "def _get_hold_priority(self):", "body": "return self.__hold_priority<EOL>", "docstring": "Getter method for hold_priority, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/config/hold_priority (uint8)\n\n    YANG Description: preemption priority once the LSP is established,\nlower is higher priority; default 0 indicates other LSPs\nwill not preempt the LSPs once established", "id": "f22271:c0:m26"}
{"signature": "def _set_cspf_tiebreaker(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>default=six.text_type(\"<STR_LIT>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__cspf_tiebreaker = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for cspf_tiebreaker, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/config/cspf_tiebreaker (cspf-tie-breaking)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_cspf_tiebreaker is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_cspf_tiebreaker() directly.\n\n    YANG Description: Determine the tie-breaking method to choose between\nequally desirable paths during CSFP computation", "id": "f22271:c1:m12"}
{"signature": "def _get_preference(self):", "body": "return self.__preference<EOL>", "docstring": "Getter method for preference, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/config/preference (uint8)\n\n    YANG Description: Specifies a preference for this path. The lower the\nnumber higher the preference", "id": "f22271:c1:m20"}
{"signature": "def _get_retry_timer(self):", "body": "return self.__retry_timer<EOL>", "docstring": "Getter method for retry_timer, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/config/retry_timer (uint16)\n\n    YANG Description: sets the time between attempts to establish the\nLSP", "id": "f22271:c1:m29"}
{"signature": "def _get_setup_priority(self):", "body": "return self.__setup_priority<EOL>", "docstring": "Getter method for setup_priority, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/config/setup_priority (uint8)\n\n    YANG Description: RSVP-TE preemption priority during LSP setup, lower is\nhigher priority; default 7 indicates that LSP will not\npreempt established LSPs during setup", "id": "f22271:c0:m23"}
{"signature": "def _set_path_computation_method(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>default=six.text_type(\"<STR_LIT>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__path_computation_method = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for path_computation_method, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/config/path_computation_method (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_path_computation_method is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_path_computation_method() directly.\n\n    YANG Description: The method used for computing the path, either\nlocally computed, queried from a server or not\ncomputed at all (explicitly configured).", "id": "f22271:c0:m6"}
{"signature": "def _get_use_cspf(self):", "body": "return self.__use_cspf<EOL>", "docstring": "Getter method for use_cspf, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/config/use_cspf (boolean)\n\nYANG Description: Flag to enable CSPF for locally computed LSPs", "id": "f22271:c1:m8"}
{"signature": "def _set_hold_priority(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>default=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>)(<EOL><NUM_LIT:0><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__hold_priority = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for hold_priority, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/config/hold_priority (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_hold_priority is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_hold_priority() directly.\n\n    YANG Description: preemption priority once the LSP is established,\nlower is higher priority; default 0 indicates other LSPs\nwill not preempt the LSPs once established", "id": "f22271:c0:m27"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/config (container)\n\nYANG Description: Configuration parameters related to paths", "id": "f22272:c0:m5"}
{"signature": "def _set_name(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:name>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for name, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/name (leafref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_name is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_name() directly.\n\nYANG Description: Path name", "id": "f22272:c1:m3"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration parameters related to paths", "id": "f22272:c1:m6"}
{"signature": "def _get_candidate_secondary_paths(self):", "body": "return self.__candidate_secondary_paths<EOL>", "docstring": "Getter method for candidate_secondary_paths, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/candidate_secondary_paths (container)\n\n    YANG Description: The set of candidate secondary paths which may be used\nfor this primary path. When secondary paths are specified\nin the list the path of the secondary LSP in use must be\nrestricted to those path options referenced. The\npriority of the secondary paths is specified within the\nlist. Higher priority values are less preferred - that is\nto say that a path with priority 0 is the most preferred\npath. In the case that the list is empty, any secondary\npath option may be utilised when the current primary path\nis in use.", "id": "f22272:c0:m11"}
{"signature": "def _set_admin_groups(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=admin_groups.admin_groups,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__admin_groups = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for admin_groups, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/admin_groups (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_admin_groups is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_admin_groups() directly.\n\n    YANG Description: Top-level container for include/exclude constraints for\nlink affinities", "id": "f22272:c1:m15"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters related to paths", "id": "f22272:c1:m9"}
{"signature": "def _get_name(self):", "body": "return self.__name<EOL>", "docstring": "Getter method for name, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/name (leafref)\n\nYANG Description: Path name", "id": "f22272:c0:m2"}
{"signature": "def _set_admin_groups(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=admin_groups.admin_groups,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__admin_groups = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for admin_groups, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/admin_groups (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_admin_groups is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_admin_groups() directly.\n\n    YANG Description: Top-level container for include/exclude constraints for\nlink affinities", "id": "f22272:c0:m15"}
{"signature": "def _set_name(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:name>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for name, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path/name (leafref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_name is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_name() directly.\n\nYANG Description: Path name", "id": "f22272:c0:m3"}
{"signature": "def _get_p2p_primary_path(self):", "body": "return self.__p2p_primary_path<EOL>", "docstring": "Getter method for p2p_primary_path, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/p2p_primary_path/p2p_primary_path (list)\n\nYANG Description: List of p2p primary paths for a tunnel", "id": "f22273:c0:m2"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels/tunnel/p2p_tunnel_attributes/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration parameters for P2P LSPs", "id": "f22275:c1:m3"}
{"signature": "def _set_tunnels(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=tunnels.tunnels,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__tunnels = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for tunnels, mapped from YANG variable /network_instances/network_instance/mpls/lsps/constrained_path/tunnels (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_tunnels is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_tunnels() directly.\n\nYANG Description: Enclosing container for tunnels", "id": "f22276:c0:m6"}
{"signature": "def _get_unconstrained_path(self):", "body": "return self.__unconstrained_path<EOL>", "docstring": "Getter method for unconstrained_path, mapped from YANG variable /network_instances/network_instance/mpls/lsps/unconstrained_path (container)\n\n    YANG Description: LSPs that use the IGP-determined path, i.e., non\ntraffic-engineered, or non constrained-path", "id": "f22277:c1:m5"}
{"signature": "def _set_static_lsps(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=static_lsps.static_lsps,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__static_lsps = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for static_lsps, mapped from YANG variable /network_instances/network_instance/mpls/lsps/static_lsps (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_static_lsps is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_static_lsps() directly.\n\n    YANG Description: statically configured LSPs, without dynamic\nsignaling", "id": "f22277:c0:m9"}
{"signature": "def _set_unconstrained_path(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=unconstrained_path.unconstrained_path,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__unconstrained_path = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for unconstrained_path, mapped from YANG variable /network_instances/network_instance/mpls/lsps/unconstrained_path (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_unconstrained_path is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_unconstrained_path() directly.\n\n    YANG Description: LSPs that use the IGP-determined path, i.e., non\ntraffic-engineered, or non constrained-path", "id": "f22277:c0:m6"}
{"signature": "def _get_path_setup_protocol(self):", "body": "return self.__path_setup_protocol<EOL>", "docstring": "Getter method for path_setup_protocol, mapped from YANG variable /network_instances/network_instance/mpls/lsps/unconstrained_path/path_setup_protocol (container)\n\n   YANG Description: select and configure the signaling method for\nthe LSP", "id": "f22279:c1:m2"}
{"signature": "def _set_path_setup_protocol(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=path_setup_protocol.path_setup_protocol,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__path_setup_protocol = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for path_setup_protocol, mapped from YANG variable /network_instances/network_instance/mpls/lsps/unconstrained_path/path_setup_protocol (container)\n   If this variable is read-only (config: false) in the\n   source YANG file, then _set_path_setup_protocol is considered as a private\n   method. Backends looking to populate this variable should\n   do so via calling thisObj._set_path_setup_protocol() directly.\n\n   YANG Description: select and configure the signaling method for\nthe LSP", "id": "f22279:c1:m3"}
{"signature": "def _get_available_bandwidth(self):", "body": "return self.__available_bandwidth<EOL>", "docstring": "Getter method for available_bandwidth, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/bandwidth_reservations/bandwidth_reservation/state/available_bandwidth (oc-mplst:bandwidth-mbps)\n\n    YANG Description: Bandwidth currently available with the priority level,\nor for the entire interface when the priority is set to\nALL", "id": "f22280:c1:m5"}
{"signature": "def _get_reserved_bandwidth(self):", "body": "return self.__reserved_bandwidth<EOL>", "docstring": "Getter method for reserved_bandwidth, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/bandwidth_reservations/bandwidth_reservation/state/reserved_bandwidth (oc-mplst:bandwidth-mbps)\n\n    YANG Description: Bandwidth currently reserved within the priority level,\nor the sum of all priority levels when the keyword is set\nto ALL", "id": "f22280:c1:m8"}
{"signature": "def _set_reserved_bandwidth(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__reserved_bandwidth = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for reserved_bandwidth, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/bandwidth_reservations/bandwidth_reservation/state/reserved_bandwidth (oc-mplst:bandwidth-mbps)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_reserved_bandwidth is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_reserved_bandwidth() directly.\n\n    YANG Description: Bandwidth currently reserved within the priority level,\nor the sum of all priority levels when the keyword is set\nto ALL", "id": "f22280:c1:m9"}
{"signature": "def _get_priority(self):", "body": "return self.__priority<EOL>", "docstring": "Getter method for priority, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/bandwidth_reservations/bandwidth_reservation/state/priority (union)\n\nYANG Description: RSVP priority level for LSPs traversing the interface", "id": "f22280:c0:m2"}
{"signature": "def _get_active_reservations_count(self):", "body": "return self.__active_reservations_count<EOL>", "docstring": "Getter method for active_reservations_count, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/bandwidth_reservations/bandwidth_reservation/state/active_reservations_count (yang:gauge64)\n\n    YANG Description: Number of active RSVP reservations in the associated\npriority, or the sum of all reservations when the priority\nlevel is set to ALL", "id": "f22280:c1:m11"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/bandwidth_reservations/bandwidth_reservation/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: Operational state parameters relating to a\nbandwidth reservation at a certain priority", "id": "f22281:c0:m6"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/bandwidth_reservations/bandwidth_reservation/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: Operational state parameters relating to a\nbandwidth reservation at a certain priority", "id": "f22281:c1:m6"}
{"signature": "def _set_priority(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__priority = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for priority, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/bandwidth_reservations/bandwidth_reservation/priority (leafref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_priority is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_priority() directly.\n\nYANG Description: Reference to the RSVP priority level", "id": "f22281:c0:m3"}
{"signature": "def _get_bandwidth_reservation(self):", "body": "return self.__bandwidth_reservation<EOL>", "docstring": "Getter method for bandwidth_reservation, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/bandwidth_reservations/bandwidth_reservation (list)\n\n    YANG Description: Available and reserved bandwidth by priority on\nthe interface.", "id": "f22282:c1:m2"}
{"signature": "def _set_bandwidth_reservation(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>bandwidth_reservation.bandwidth_reservation,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__bandwidth_reservation = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for bandwidth_reservation, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/bandwidth_reservations/bandwidth_reservation (list)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_bandwidth_reservation is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_bandwidth_reservation() directly.\n\n    YANG Description: Available and reserved bandwidth by priority on\nthe interface.", "id": "f22282:c1:m3"}
{"signature": "def _get_bandwidth_reservation(self):", "body": "return self.__bandwidth_reservation<EOL>", "docstring": "Getter method for bandwidth_reservation, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/bandwidth_reservations/bandwidth_reservation (list)\n\n    YANG Description: Available and reserved bandwidth by priority on\nthe interface.", "id": "f22282:c0:m2"}
{"signature": "def _get_interface_id(self):", "body": "return self.__interface_id<EOL>", "docstring": "Getter method for interface_id, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/state/interface_id (oc-if:interface-id)\n\nYANG Description: Identifier for the interface", "id": "f22283:c0:m2"}
{"signature": "def _get_interface_id(self):", "body": "return self.__interface_id<EOL>", "docstring": "Getter method for interface_id, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/state/interface_id (oc-if:interface-id)\n\nYANG Description: Identifier for the interface", "id": "f22283:c1:m2"}
{"signature": "def _set_counters(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=counters.counters,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__counters = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for counters, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/state/counters (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_counters is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_counters() directly.\n\nYANG Description: Interface specific RSVP statistics and counters", "id": "f22283:c1:m6"}
{"signature": "def _get_out_path_tear_messages(self):", "body": "return self.__out_path_tear_messages<EOL>", "docstring": "Getter method for out_path_tear_messages, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/state/counters/out_path_tear_messages (yang:counter64)\n\nYANG Description: Number of sent RSVP Path Tear messages", "id": "f22284:c1:m35"}
{"signature": "def _get_in_srefresh_messages(self):", "body": "return self.__in_srefresh_messages<EOL>", "docstring": "Getter method for in_srefresh_messages, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/state/counters/in_srefresh_messages (yang:counter64)\n\nYANG Description: Number of received RSVP summary refresh messages", "id": "f22284:c1:m23"}
{"signature": "def _set_in_path_tear_messages(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__in_path_tear_messages = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for in_path_tear_messages, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/state/counters/in_path_tear_messages (yang:counter64)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_in_path_tear_messages is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_in_path_tear_messages() directly.\n\nYANG Description: Number of received RSVP Path Tear messages", "id": "f22284:c0:m9"}
{"signature": "def _set_in_path_tear_messages(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__in_path_tear_messages = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for in_path_tear_messages, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/state/counters/in_path_tear_messages (yang:counter64)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_in_path_tear_messages is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_in_path_tear_messages() directly.\n\nYANG Description: Number of received RSVP Path Tear messages", "id": "f22284:c1:m9"}
{"signature": "def _get_in_path_error_messages(self):", "body": "return self.__in_path_error_messages<EOL>", "docstring": "Getter method for in_path_error_messages, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/state/counters/in_path_error_messages (yang:counter64)\n\nYANG Description: Number of received RSVP Path Error messages", "id": "f22284:c0:m5"}
{"signature": "def _get_in_hello_messages(self):", "body": "return self.__in_hello_messages<EOL>", "docstring": "Getter method for in_hello_messages, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/state/counters/in_hello_messages (yang:counter64)\n\nYANG Description: Number of received RSVP hello messages", "id": "f22284:c0:m20"}
{"signature": "def _get_in_reservation_tear_messages(self):", "body": "return self.__in_reservation_tear_messages<EOL>", "docstring": "Getter method for in_reservation_tear_messages, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/state/counters/in_reservation_tear_messages (yang:counter64)\n\nYANG Description: Number of received RSVP Resv Tear messages", "id": "f22284:c1:m17"}
{"signature": "def _get_in_hello_messages(self):", "body": "return self.__in_hello_messages<EOL>", "docstring": "Getter method for in_hello_messages, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/state/counters/in_hello_messages (yang:counter64)\n\nYANG Description: Number of received RSVP hello messages", "id": "f22284:c1:m20"}
{"signature": "def _set_in_path_messages(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__in_path_messages = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for in_path_messages, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/state/counters/in_path_messages (yang:counter64)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_in_path_messages is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_in_path_messages() directly.\n\nYANG Description: Number of received RSVP Path messages", "id": "f22284:c1:m3"}
{"signature": "def _set_out_reservation_tear_messages(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__out_reservation_tear_messages = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for out_reservation_tear_messages, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/state/counters/out_reservation_tear_messages (yang:counter64)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_out_reservation_tear_messages is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_out_reservation_tear_messages() directly.\n\nYANG Description: Number of sent RSVP Resv Tear messages", "id": "f22284:c1:m45"}
{"signature": "def _get_out_reservation_error_messages(self):", "body": "return self.__out_reservation_error_messages<EOL>", "docstring": "Getter method for out_reservation_error_messages, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/state/counters/out_reservation_error_messages (yang:counter64)\n\nYANG Description: Number of sent RSVP Resv Error messages", "id": "f22284:c0:m41"}
{"signature": "def _set_in_reservation_error_messages(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__in_reservation_error_messages = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for in_reservation_error_messages, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/state/counters/in_reservation_error_messages (yang:counter64)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_in_reservation_error_messages is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_in_reservation_error_messages() directly.\n\nYANG Description: Number of received RSVP Resv Error messages", "id": "f22284:c1:m15"}
{"signature": "def _set_out_path_messages(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__out_path_messages = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for out_path_messages, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/state/counters/out_path_messages (yang:counter64)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_out_path_messages is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_out_path_messages() directly.\n\nYANG Description: Number of sent RSVP PATH messages", "id": "f22284:c0:m30"}
{"signature": "def _set_out_reservation_messages(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__out_reservation_messages = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for out_reservation_messages, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/state/counters/out_reservation_messages (yang:counter64)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_out_reservation_messages is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_out_reservation_messages() directly.\n\nYANG Description: Number of sent RSVP Resv messages", "id": "f22284:c0:m39"}
{"signature": "def _get_out_path_messages(self):", "body": "return self.__out_path_messages<EOL>", "docstring": "Getter method for out_path_messages, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/state/counters/out_path_messages (yang:counter64)\n\nYANG Description: Number of sent RSVP PATH messages", "id": "f22284:c1:m29"}
{"signature": "def _set_in_path_error_messages(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__in_path_error_messages = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for in_path_error_messages, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/state/counters/in_path_error_messages (yang:counter64)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_in_path_error_messages is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_in_path_error_messages() directly.\n\nYANG Description: Number of received RSVP Path Error messages", "id": "f22284:c1:m6"}
{"signature": "def _set_out_path_error_messages(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__out_path_error_messages = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for out_path_error_messages, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/state/counters/out_path_error_messages (yang:counter64)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_out_path_error_messages is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_out_path_error_messages() directly.\n\nYANG Description: Number of sent RSVP Path Error messages", "id": "f22284:c0:m33"}
{"signature": "def _set_out_path_tear_messages(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__out_path_tear_messages = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for out_path_tear_messages, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/state/counters/out_path_tear_messages (yang:counter64)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_out_path_tear_messages is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_out_path_tear_messages() directly.\n\nYANG Description: Number of sent RSVP Path Tear messages", "id": "f22284:c1:m36"}
{"signature": "def _set_in_srefresh_messages(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__in_srefresh_messages = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for in_srefresh_messages, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/state/counters/in_srefresh_messages (yang:counter64)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_in_srefresh_messages is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_in_srefresh_messages() directly.\n\nYANG Description: Number of received RSVP summary refresh messages", "id": "f22284:c1:m24"}
{"signature": "def _set_out_reservation_error_messages(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__out_reservation_error_messages = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for out_reservation_error_messages, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/state/counters/out_reservation_error_messages (yang:counter64)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_out_reservation_error_messages is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_out_reservation_error_messages() directly.\n\nYANG Description: Number of sent RSVP Resv Error messages", "id": "f22284:c1:m42"}
{"signature": "def _get_in_reservation_error_messages(self):", "body": "return self.__in_reservation_error_messages<EOL>", "docstring": "Getter method for in_reservation_error_messages, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/state/counters/in_reservation_error_messages (yang:counter64)\n\nYANG Description: Number of received RSVP Resv Error messages", "id": "f22284:c1:m14"}
{"signature": "def _get_in_srefresh_messages(self):", "body": "return self.__in_srefresh_messages<EOL>", "docstring": "Getter method for in_srefresh_messages, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/state/counters/in_srefresh_messages (yang:counter64)\n\nYANG Description: Number of received RSVP summary refresh messages", "id": "f22284:c0:m23"}
{"signature": "def _set_out_ack_messages(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__out_ack_messages = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for out_ack_messages, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/state/counters/out_ack_messages (yang:counter64)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_out_ack_messages is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_out_ack_messages() directly.\n\nYANG Description: Number of sent RSVP refresh reduction ack messages", "id": "f22284:c1:m54"}
{"signature": "def _get_bypass_optimize_interval(self):", "body": "return self.__bypass_optimize_interval<EOL>", "docstring": "Getter method for bypass_optimize_interval, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/protection/config/bypass_optimize_interval (uint16)\n\n    YANG Description: interval between periodic optimization\nof the bypass LSPs", "id": "f22286:c0:m5"}
{"signature": "def _get_link_protection_style_requested(self):", "body": "return self.__link_protection_style_requested<EOL>", "docstring": "Getter method for link_protection_style_requested, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/protection/config/link_protection_style_requested (identityref)\n\n    YANG Description: Style of mpls frr protection desired:\nlink, link-node, or unprotected", "id": "f22286:c1:m2"}
{"signature": "def _set_link_protection_style_requested(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>default=six.text_type(\"<STR_LIT>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__link_protection_style_requested = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for link_protection_style_requested, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/protection/config/link_protection_style_requested (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_link_protection_style_requested is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_link_protection_style_requested() directly.\n\n    YANG Description: Style of mpls frr protection desired:\nlink, link-node, or unprotected", "id": "f22286:c1:m3"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/protection/config (container)\n\nYANG Description: Configuration for link-protection", "id": "f22287:c1:m2"}
{"signature": "def _get_interface_id(self):", "body": "return self.__interface_id<EOL>", "docstring": "Getter method for interface_id, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/config/interface_id (oc-if:interface-id)\n\nYANG Description: Identifier for the interface", "id": "f22288:c0:m2"}
{"signature": "def _set_interface_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface_id, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/config/interface_id (oc-if:interface-id)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_interface_id is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_interface_id() directly.\n\nYANG Description: Identifier for the interface", "id": "f22288:c1:m3"}
{"signature": "def _get_interface(self):", "body": "return self.__interface<EOL>", "docstring": "Getter method for interface, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/interface_ref/state/interface (leafref)\n\n    YANG Description: Reference to a base interface.  If a reference to a\nsubinterface is required, this leaf must be specified\nto indicate the base interface.", "id": "f22289:c1:m2"}
{"signature": "def _set_subinterface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subinterface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subinterface, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/interface_ref/state/subinterface (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subinterface is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subinterface() directly.\n\n    YANG Description: Reference to a subinterface -- this requires the base\ninterface to be specified using the interface leaf in\nthis container.  If only a reference to a base interface\nis requuired, this leaf should not be set.", "id": "f22289:c1:m6"}
{"signature": "def _set_subinterface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subinterface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subinterface, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/interface_ref/config/subinterface (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subinterface is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subinterface() directly.\n\n    YANG Description: Reference to a subinterface -- this requires the base\ninterface to be specified using the interface leaf in\nthis container.  If only a reference to a base interface\nis requuired, this leaf should not be set.", "id": "f22290:c1:m6"}
{"signature": "def _set_interface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/interface_ref/config/interface (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_interface is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_interface() directly.\n\n    YANG Description: Reference to a base interface.  If a reference to a\nsubinterface is required, this leaf must be specified\nto indicate the base interface.", "id": "f22290:c1:m3"}
{"signature": "def _get_interface(self):", "body": "return self.__interface<EOL>", "docstring": "Getter method for interface, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/interface_ref/config/interface (leafref)\n\n    YANG Description: Reference to a base interface.  If a reference to a\nsubinterface is required, this leaf must be specified\nto indicate the base interface.", "id": "f22290:c1:m2"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/interface_ref/config (container)\n\nYANG Description: Configured reference to interface / subinterface", "id": "f22291:c0:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/interface_ref/state (container)\n\nYANG Description: Operational state for interface-ref", "id": "f22291:c1:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/interface_ref/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Operational state for interface-ref", "id": "f22291:c1:m6"}
{"signature": "def _set_protection(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=protection.protection,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__protection = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for protection, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/protection (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_protection is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_protection() directly.\n\nYANG Description: link-protection (NHOP) related configuration", "id": "f22292:c0:m27"}
{"signature": "def _set_interface_id(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface_id, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/interface_id (leafref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_interface_id is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_interface_id() directly.\n\nYANG Description: reference to the interface-id data", "id": "f22292:c1:m3"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration of per-interface RSVP parameters", "id": "f22292:c0:m6"}
{"signature": "def _get_subscription(self):", "body": "return self.__subscription<EOL>", "docstring": "Getter method for subscription, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/subscription (container)\n\n    YANG Description: Bandwidth percentage reservable by RSVP\non an interface", "id": "f22292:c1:m23"}
{"signature": "def _get_bandwidth_reservations(self):", "body": "return self.__bandwidth_reservations<EOL>", "docstring": "Getter method for bandwidth_reservations, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/bandwidth_reservations (container)\n\nYANG Description: Enclosing container for bandwidth reservation", "id": "f22292:c0:m14"}
{"signature": "def _get_interface_id(self):", "body": "return self.__interface_id<EOL>", "docstring": "Getter method for interface_id, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/interface_id (leafref)\n\nYANG Description: reference to the interface-id data", "id": "f22292:c0:m2"}
{"signature": "def _set_subscription(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=subscription.subscription,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subscription = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subscription, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/subscription (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subscription is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subscription() directly.\n\n    YANG Description: Bandwidth percentage reservable by RSVP\non an interface", "id": "f22292:c1:m24"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/config (container)\n\nYANG Description: Configuration of per-interface RSVP parameters", "id": "f22292:c1:m5"}
{"signature": "def _get_interface_ref(self):", "body": "return self.__interface_ref<EOL>", "docstring": "Getter method for interface_ref, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/interface_ref (container)\n\nYANG Description: Reference to an interface or subinterface", "id": "f22292:c1:m11"}
{"signature": "def _set_authentication(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=authentication.authentication,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__authentication = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for authentication, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/authentication (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_authentication is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_authentication() directly.\n\n    YANG Description: Configuration and state parameters relating to RSVP\nauthentication as per RFC2747", "id": "f22292:c1:m21"}
{"signature": "def _set_interface_id(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface_id, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/interface_id (leafref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_interface_id is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_interface_id() directly.\n\nYANG Description: reference to the interface-id data", "id": "f22292:c0:m3"}
{"signature": "def _set_bandwidth_reservations(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=bandwidth_reservations.bandwidth_reservations,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__bandwidth_reservations = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for bandwidth_reservations, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/bandwidth_reservations (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_bandwidth_reservations is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_bandwidth_reservations() directly.\n\nYANG Description: Enclosing container for bandwidth reservation", "id": "f22292:c0:m15"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration of per-interface RSVP parameters", "id": "f22292:c1:m6"}
{"signature": "def _get_bandwidth_reservations(self):", "body": "return self.__bandwidth_reservations<EOL>", "docstring": "Getter method for bandwidth_reservations, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/bandwidth_reservations (container)\n\nYANG Description: Enclosing container for bandwidth reservation", "id": "f22292:c1:m14"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Per-interface RSVP protocol and state information", "id": "f22292:c0:m9"}
{"signature": "def _set_hellos(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=hellos.hellos,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__hellos = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for hellos, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/hellos (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_hellos is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_hellos() directly.\n\nYANG Description: Top level container for RSVP hello parameters", "id": "f22292:c1:m18"}
{"signature": "def _set_interface_ref(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=interface_ref.interface_ref,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface_ref = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface_ref, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/interface_ref (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_interface_ref is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_interface_ref() directly.\n\nYANG Description: Reference to an interface or subinterface", "id": "f22292:c1:m12"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/subscription/config (container)\n\n    YANG Description: Configuration parameters relating to RSVP\nsubscription options", "id": "f22295:c1:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/subscription/state (container)\n\n    YANG Description: State parameters relating to RSVP\nsubscription options", "id": "f22295:c1:m5"}
{"signature": "def _get_refresh_reduction(self):", "body": "return self.__refresh_reduction<EOL>", "docstring": "Getter method for refresh_reduction, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/hellos/config/refresh_reduction (boolean)\n\n    YANG Description: enables all RSVP refresh reduction message\nbundling, RSVP message ID, reliable message delivery\nand summary refresh", "id": "f22297:c0:m5"}
{"signature": "def _get_hello_interval(self):", "body": "return self.__hello_interval<EOL>", "docstring": "Getter method for hello_interval, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/hellos/config/hello_interval (uint16)\n\n    YANG Description: set the interval in ms between RSVP hello\nmessages", "id": "f22297:c1:m2"}
{"signature": "def _set_refresh_reduction(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:true>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__refresh_reduction = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for refresh_reduction, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/hellos/config/refresh_reduction (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_refresh_reduction is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_refresh_reduction() directly.\n\n    YANG Description: enables all RSVP refresh reduction message\nbundling, RSVP message ID, reliable message delivery\nand summary refresh", "id": "f22297:c0:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/hellos/state (container)\n\nYANG Description: State information associated with RSVP hellos", "id": "f22298:c1:m5"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/hellos/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to RSVP\nhellos", "id": "f22298:c1:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/hellos/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State information associated with RSVP hellos", "id": "f22298:c1:m6"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/hellos/config (container)\n\n    YANG Description: Configuration parameters relating to RSVP\nhellos", "id": "f22298:c1:m2"}
{"signature": "def _get_authentication_key(self):", "body": "return self.__authentication_key<EOL>", "docstring": "Getter method for authentication_key, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/authentication/state/authentication_key (string)\n\n    YANG Description: authenticate RSVP signaling\nmessages", "id": "f22299:c1:m5"}
{"signature": "def _get_enable(self):", "body": "return self.__enable<EOL>", "docstring": "Getter method for enable, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/authentication/state/enable (boolean)\n\nYANG Description: Enables RSVP authentication on the node.", "id": "f22299:c1:m2"}
{"signature": "def _get_authentication_key(self):", "body": "return self.__authentication_key<EOL>", "docstring": "Getter method for authentication_key, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/authentication/state/authentication_key (string)\n\n    YANG Description: authenticate RSVP signaling\nmessages", "id": "f22299:c0:m5"}
{"signature": "def _set_enable(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enable = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enable, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/authentication/config/enable (boolean)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_enable is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_enable() directly.\n\nYANG Description: Enables RSVP authentication on the node.", "id": "f22300:c0:m3"}
{"signature": "def _get_authentication_key(self):", "body": "return self.__authentication_key<EOL>", "docstring": "Getter method for authentication_key, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/authentication/config/authentication_key (string)\n\n    YANG Description: authenticate RSVP signaling\nmessages", "id": "f22300:c1:m5"}
{"signature": "def _set_authentication_key(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__authentication_key = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for authentication_key, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/authentication/config/authentication_key (string)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_authentication_key is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_authentication_key() directly.\n\n    YANG Description: authenticate RSVP signaling\nmessages", "id": "f22300:c0:m6"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/authentication/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: State information associated\nwith authentication", "id": "f22301:c1:m6"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/authentication/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: State information associated\nwith authentication", "id": "f22301:c0:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/authentication/state (container)\n\n    YANG Description: State information associated\nwith authentication", "id": "f22301:c1:m5"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface/authentication/state (container)\n\n    YANG Description: State information associated\nwith authentication", "id": "f22301:c0:m5"}
{"signature": "def _get_interface(self):", "body": "return self.__interface<EOL>", "docstring": "Getter method for interface, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes/interface (list)\n\nYANG Description: list of per-interface RSVP configurations", "id": "f22302:c1:m2"}
{"signature": "def _set_neighbor_status(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__neighbor_status = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for neighbor_status, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/neighbors/neighbor/state/neighbor_status (enumeration)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_neighbor_status is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_neighbor_status() directly.\n\nYANG Description: Enumuration of possible RSVP neighbor states", "id": "f22303:c0:m9"}
{"signature": "def _get_detected_interface(self):", "body": "return self.__detected_interface<EOL>", "docstring": "Getter method for detected_interface, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/neighbors/neighbor/state/detected_interface (string)\n\nYANG Description: Interface where RSVP neighbor was detected", "id": "f22303:c1:m5"}
{"signature": "def _get_neighbor_status(self):", "body": "return self.__neighbor_status<EOL>", "docstring": "Getter method for neighbor_status, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/neighbors/neighbor/state/neighbor_status (enumeration)\n\nYANG Description: Enumuration of possible RSVP neighbor states", "id": "f22303:c1:m8"}
{"signature": "def _get_address(self):", "body": "return self.__address<EOL>", "docstring": "Getter method for address, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/neighbors/neighbor/state/address (inet:ip-address)\n\nYANG Description: Address of RSVP neighbor", "id": "f22303:c1:m2"}
{"signature": "def _set_address(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:address>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for address, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/neighbors/neighbor/address (leafref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_address is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_address() directly.\n\nYANG Description: Reference to the address of the RSVP neighbor", "id": "f22304:c0:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/neighbors/neighbor/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: Operational state parameters relating to the\nRSVP neighbor", "id": "f22304:c1:m6"}
{"signature": "def _get_address(self):", "body": "return self.__address<EOL>", "docstring": "Getter method for address, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/neighbors/neighbor/address (leafref)\n\nYANG Description: Reference to the address of the RSVP neighbor", "id": "f22304:c0:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/neighbors/neighbor/state (container)\n\n    YANG Description: Operational state parameters relating to the\nRSVP neighbor", "id": "f22304:c0:m5"}
{"signature": "def _get_global_(self):", "body": "return self.__global_<EOL>", "docstring": "Getter method for global_, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global (container)\n\nYANG Description: Platform wide RSVP configuration and state", "id": "f22306:c1:m8"}
{"signature": "def _get_sessions(self):", "body": "return self.__sessions<EOL>", "docstring": "Getter method for sessions, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/sessions (container)\n\nYANG Description: Enclosing container for sessions", "id": "f22306:c0:m2"}
{"signature": "def _get_interface_attributes(self):", "body": "return self.__interface_attributes<EOL>", "docstring": "Getter method for interface_attributes, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes (container)\n\nYANG Description: Attributes relating to RSVP-TE enabled interfaces", "id": "f22306:c0:m11"}
{"signature": "def _set_interface_attributes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=interface_attributes.interface_attributes,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface_attributes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface_attributes, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/interface_attributes (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_interface_attributes is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_interface_attributes() directly.\n\nYANG Description: Attributes relating to RSVP-TE enabled interfaces", "id": "f22306:c0:m12"}
{"signature": "def _set_tunnel_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__tunnel_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for tunnel_id, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/sessions/session/state/tunnel_id (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_tunnel_id is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_tunnel_id() directly.\n\n    YANG Description: The tunnel ID is an identifier used in the\nRSVP session, which remains constant over\nthe life of the tunnel.", "id": "f22307:c0:m12"}
{"signature": "def _get_source_address(self):", "body": "return self.__source_address<EOL>", "docstring": "Getter method for source_address, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/sessions/session/state/source_address (inet:ip-address)\n\nYANG Description: Origin address of RSVP session", "id": "f22307:c0:m5"}
{"signature": "def _get_session_name(self):", "body": "return self.__session_name<EOL>", "docstring": "Getter method for session_name, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/sessions/session/state/session_name (string)\n\nYANG Description: The signaled name of this RSVP session.", "id": "f22307:c1:m17"}
{"signature": "def _get_destination_address(self):", "body": "return self.__destination_address<EOL>", "docstring": "Getter method for destination_address, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/sessions/session/state/destination_address (inet:ip-address)\n\nYANG Description: Destination address of RSVP session", "id": "f22307:c0:m8"}
{"signature": "def _set_status(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:status>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__status = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for status, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/sessions/session/state/status (enumeration)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_status is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_status() directly.\n\nYANG Description: Enumeration of RSVP session states", "id": "f22307:c1:m21"}
{"signature": "def _get_label_in(self):", "body": "return self.__label_in<EOL>", "docstring": "Getter method for label_in, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/sessions/session/state/label_in (oc-mplst:mpls-label)\n\nYANG Description: Incoming MPLS label associated with this RSVP session", "id": "f22307:c0:m29"}
{"signature": "def _set_session_name(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__session_name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for session_name, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/sessions/session/state/session_name (string)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_session_name is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_session_name() directly.\n\nYANG Description: The signaled name of this RSVP session.", "id": "f22307:c0:m18"}
{"signature": "def _get_protection_requested(self):", "body": "return self.__protection_requested<EOL>", "docstring": "Getter method for protection_requested, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/sessions/session/state/protection_requested (identityref)\n\nYANG Description: The type of protection requested for the RSVP session", "id": "f22307:c0:m26"}
{"signature": "def _get_lsp_id(self):", "body": "return self.__lsp_id<EOL>", "docstring": "Getter method for lsp_id, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/sessions/session/state/lsp_id (uint16)\n\n    YANG Description: The LSP ID distinguishes between two LSPs\noriginated from the same headend, and is\ncommonly used to distinguish RSVP sessions\nduring make before break operations.", "id": "f22307:c0:m14"}
{"signature": "def _set_source_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__source_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for source_address, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/sessions/session/state/source_address (inet:ip-address)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_source_address is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_source_address() directly.\n\nYANG Description: Origin address of RSVP session", "id": "f22307:c1:m6"}
{"signature": "def _set_local_index(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__local_index = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for local_index, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/sessions/session/state/local_index (uint64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_local_index is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_local_index() directly.\n\n    YANG Description: The index used to identify the RSVP session\non the local network element. This index is\ngenerated by the device and is unique only\nto the local network element.", "id": "f22307:c1:m3"}
{"signature": "def _set_label_out(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:0>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:1>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:2>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:3>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:7>},<EOL>\"<STR_LIT>\": {},<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__label_out = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for label_out, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/sessions/session/state/label_out (oc-mplst:mpls-label)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_label_out is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_label_out() directly.\n\nYANG Description: Outgoing MPLS label associated with this RSVP session", "id": "f22307:c1:m33"}
{"signature": "def _get_size(self):", "body": "return self.__size<EOL>", "docstring": "Getter method for size, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/sessions/session/state/sender_tspec/size (oc-types:ieeefloat32)\n\n    YANG Description: The size of the token bucket that is used to determine\nthe rate at which the head-end device generates traffic,\nexpressed in bytes per second.", "id": "f22308:c0:m5"}
{"signature": "def _set_peak_data_rate(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=bitarray, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__peak_data_rate = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for peak_data_rate, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/sessions/session/state/sender_tspec/peak_data_rate (union)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_peak_data_rate is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_peak_data_rate() directly.\n\n    YANG Description: The maximum traffic generation rate that the head-end\ndevice sends traffic at.", "id": "f22308:c0:m9"}
{"signature": "def _get_record_route_object(self):", "body": "return self.__record_route_object<EOL>", "docstring": "Getter method for record_route_object, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/sessions/session/record_route_objects/record_route_object (list)\n\n    YANG Description: Read-only list of record route objects associated with the\ntraffic engineered tunnel. Each entry in the list\nmay contain a hop IP address, MPLS label allocated\nat the hop, and the flags associated with the entry.", "id": "f22309:c0:m2"}
{"signature": "def _get_reported_flags(self):", "body": "return self.__reported_flags<EOL>", "docstring": "Getter method for reported_flags, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/sessions/session/record_route_objects/record_route_object/state/reported_flags (uint8)\n\nYANG Description: Subobject flags for MPLS label", "id": "f22310:c1:m11"}
{"signature": "def _get_reported_label(self):", "body": "return self.__reported_label<EOL>", "docstring": "Getter method for reported_label, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/sessions/session/record_route_objects/record_route_object/state/reported_label (oc-mplst:mpls-label)\n\nYANG Description: Label reported for RRO hop", "id": "f22310:c0:m8"}
{"signature": "def _set_reported_flags(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__reported_flags = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for reported_flags, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/sessions/session/record_route_objects/record_route_object/state/reported_flags (uint8)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_reported_flags is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_reported_flags() directly.\n\nYANG Description: Subobject flags for MPLS label", "id": "f22310:c1:m12"}
{"signature": "def _get_address(self):", "body": "return self.__address<EOL>", "docstring": "Getter method for address, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/sessions/session/record_route_objects/record_route_object/state/address (inet:ip-address)\n\nYANG Description: IP router hop for RRO entry", "id": "f22310:c0:m5"}
{"signature": "def _set_reported_label(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:0>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:1>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:2>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:3>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:7>},<EOL>\"<STR_LIT>\": {},<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__reported_label = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for reported_label, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/sessions/session/record_route_objects/record_route_object/state/reported_label (oc-mplst:mpls-label)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_reported_label is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_reported_label() directly.\n\nYANG Description: Label reported for RRO hop", "id": "f22310:c0:m9"}
{"signature": "def _set_index(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:index>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__index = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for index, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/sessions/session/record_route_objects/record_route_object/state/index (uint8)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_index is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_index() directly.\n\nYANG Description: Index of object in the list. Used for ordering.", "id": "f22310:c1:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/sessions/session/record_route_objects/record_route_object/state (container)\n\n    YANG Description: Information related to RRO objects. The hop, label, and\noptional flags are present for each entry in the list.", "id": "f22311:c1:m5"}
{"signature": "def _get_index(self):", "body": "return self.__index<EOL>", "docstring": "Getter method for index, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/sessions/session/record_route_objects/record_route_object/index (leafref)\n\n    YANG Description: Reference to the index of the record route object.\nThe index is used to indicate the ordering of hops in\nthe path.", "id": "f22311:c1:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/sessions/session/state (container)\n\n    YANG Description: Operational state parameters relating to the\nRSVP session", "id": "f22312:c0:m8"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/sessions/session/state (container)\n\n    YANG Description: Operational state parameters relating to the\nRSVP session", "id": "f22312:c1:m8"}
{"signature": "def _set_enable(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enable = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enable, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/graceful_restart/state/enable (boolean)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_enable is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_enable() directly.\n\nYANG Description: Enables graceful restart on the node.", "id": "f22314:c1:m3"}
{"signature": "def _get_enable(self):", "body": "return self.__enable<EOL>", "docstring": "Getter method for enable, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/graceful_restart/state/enable (boolean)\n\nYANG Description: Enables graceful restart on the node.", "id": "f22314:c0:m2"}
{"signature": "def _get_recovery_time(self):", "body": "return self.__recovery_time<EOL>", "docstring": "Getter method for recovery_time, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/graceful_restart/config/recovery_time (uint32)\n\nYANG Description: RSVP state recovery time", "id": "f22315:c1:m8"}
{"signature": "def _set_recovery_time(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__recovery_time = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for recovery_time, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/graceful_restart/config/recovery_time (uint32)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_recovery_time is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_recovery_time() directly.\n\nYANG Description: RSVP state recovery time", "id": "f22315:c1:m9"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/graceful_restart/config (container)\n\n    YANG Description: Configuration parameters relating to\ngraceful-restart", "id": "f22316:c1:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/graceful_restart/state (container)\n\n    YANG Description: State information associated with\nRSVP graceful-restart", "id": "f22316:c0:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/graceful_restart/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: State information associated with\nRSVP graceful-restart", "id": "f22316:c1:m6"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/graceful_restart/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to\ngraceful-restart", "id": "f22316:c0:m3"}
{"signature": "def _get_enable(self):", "body": "return self.__enable<EOL>", "docstring": "Getter method for enable, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/soft_preemption/config/enable (boolean)\n\nYANG Description: Enables soft preemption on a node.", "id": "f22318:c1:m2"}
{"signature": "def _set_enable(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enable = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enable, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/soft_preemption/config/enable (boolean)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_enable is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_enable() directly.\n\nYANG Description: Enables soft preemption on a node.", "id": "f22318:c0:m3"}
{"signature": "def _set_soft_preemption_timeout(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:16>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>default=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>)(<EOL><NUM_LIT:30><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__soft_preemption_timeout = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for soft_preemption_timeout, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/soft_preemption/config/soft_preemption_timeout (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_soft_preemption_timeout is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_soft_preemption_timeout() directly.\n\n    YANG Description: Timeout value for soft preemption to revert\nto hard preemption. The default timeout for\nsoft-preemption is 30 seconds - after which\nthe local system reverts to hard pre-emption.", "id": "f22318:c1:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/soft_preemption/state (container)\n\n    YANG Description: State parameters relating to RSVP\nsoft preemption support", "id": "f22319:c1:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/soft_preemption/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: State parameters relating to RSVP\nsoft preemption support", "id": "f22319:c0:m6"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/soft_preemption/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to RSVP\nsoft preemption support", "id": "f22319:c0:m3"}
{"signature": "def _get_counters(self):", "body": "return self.__counters<EOL>", "docstring": "Getter method for counters, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/state/counters (container)\n\nYANG Description: Platform wide RSVP statistics and counters", "id": "f22320:c0:m2"}
{"signature": "def _set_out_hello_messages(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__out_hello_messages = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for out_hello_messages, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/state/counters/out_hello_messages (yang:counter64)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_out_hello_messages is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_out_hello_messages() directly.\n\nYANG Description: Number of sent RSVP hello messages", "id": "f22321:c0:m57"}
{"signature": "def _get_out_path_error_messages(self):", "body": "return self.__out_path_error_messages<EOL>", "docstring": "Getter method for out_path_error_messages, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/state/counters/out_path_error_messages (yang:counter64)\n\nYANG Description: Number of sent RSVP Path Error messages", "id": "f22321:c0:m41"}
{"signature": "def _set_in_path_tear_messages(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__in_path_tear_messages = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for in_path_tear_messages, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/state/counters/in_path_tear_messages (yang:counter64)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_in_path_tear_messages is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_in_path_tear_messages() directly.\n\nYANG Description: Number of received RSVP Path Tear messages", "id": "f22321:c1:m18"}
{"signature": "def _get_rate_limited_messages(self):", "body": "return self.__rate_limited_messages<EOL>", "docstring": "Getter method for rate_limited_messages, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/state/counters/rate_limited_messages (yang:counter64)\n\nYANG Description: RSVP messages dropped due to rate limiting", "id": "f22321:c0:m8"}
{"signature": "def _get_in_path_tear_messages(self):", "body": "return self.__in_path_tear_messages<EOL>", "docstring": "Getter method for in_path_tear_messages, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/state/counters/in_path_tear_messages (yang:counter64)\n\nYANG Description: Number of received RSVP Path Tear messages", "id": "f22321:c0:m17"}
{"signature": "def _get_in_hello_messages(self):", "body": "return self.__in_hello_messages<EOL>", "docstring": "Getter method for in_hello_messages, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/state/counters/in_hello_messages (yang:counter64)\n\nYANG Description: Number of received RSVP hello messages", "id": "f22321:c0:m29"}
{"signature": "def _set_in_reservation_messages(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__in_reservation_messages = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for in_reservation_messages, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/state/counters/in_reservation_messages (yang:counter64)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_in_reservation_messages is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_in_reservation_messages() directly.\n\nYANG Description: Number of received RSVP Resv messages", "id": "f22321:c0:m21"}
{"signature": "def _get_out_reservation_error_messages(self):", "body": "return self.__out_reservation_error_messages<EOL>", "docstring": "Getter method for out_reservation_error_messages, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/state/counters/out_reservation_error_messages (yang:counter64)\n\nYANG Description: Number of sent RSVP Resv Error messages", "id": "f22321:c0:m50"}
{"signature": "def _get_reservation_timeouts(self):", "body": "return self.__reservation_timeouts<EOL>", "docstring": "Getter method for reservation_timeouts, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/state/counters/reservation_timeouts (yang:counter64)\n\nYANG Description: TODO", "id": "f22321:c0:m5"}
{"signature": "def _set_out_reservation_messages(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__out_reservation_messages = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for out_reservation_messages, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/state/counters/out_reservation_messages (yang:counter64)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_out_reservation_messages is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_out_reservation_messages() directly.\n\nYANG Description: Number of sent RSVP Resv messages", "id": "f22321:c1:m48"}
{"signature": "def _set_out_ack_messages(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__out_ack_messages = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for out_ack_messages, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/state/counters/out_ack_messages (yang:counter64)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_out_ack_messages is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_out_ack_messages() directly.\n\nYANG Description: Number of sent RSVP refresh reduction ack messages", "id": "f22321:c0:m63"}
{"signature": "def _set_in_reservation_error_messages(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__in_reservation_error_messages = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for in_reservation_error_messages, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/state/counters/in_reservation_error_messages (yang:counter64)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_in_reservation_error_messages is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_in_reservation_error_messages() directly.\n\nYANG Description: Number of received RSVP Resv Error messages", "id": "f22321:c1:m24"}
{"signature": "def _get_in_path_tear_messages(self):", "body": "return self.__in_path_tear_messages<EOL>", "docstring": "Getter method for in_path_tear_messages, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/state/counters/in_path_tear_messages (yang:counter64)\n\nYANG Description: Number of received RSVP Path Tear messages", "id": "f22321:c1:m17"}
{"signature": "def _set_out_path_messages(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__out_path_messages = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for out_path_messages, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/state/counters/out_path_messages (yang:counter64)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_out_path_messages is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_out_path_messages() directly.\n\nYANG Description: Number of sent RSVP PATH messages", "id": "f22321:c1:m39"}
{"signature": "def _get_out_ack_messages(self):", "body": "return self.__out_ack_messages<EOL>", "docstring": "Getter method for out_ack_messages, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/state/counters/out_ack_messages (yang:counter64)\n\nYANG Description: Number of sent RSVP refresh reduction ack messages", "id": "f22321:c0:m62"}
{"signature": "def _set_out_path_error_messages(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__out_path_error_messages = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for out_path_error_messages, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/state/counters/out_path_error_messages (yang:counter64)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_out_path_error_messages is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_out_path_error_messages() directly.\n\nYANG Description: Number of sent RSVP Path Error messages", "id": "f22321:c0:m42"}
{"signature": "def _get_out_reservation_tear_messages(self):", "body": "return self.__out_reservation_tear_messages<EOL>", "docstring": "Getter method for out_reservation_tear_messages, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/state/counters/out_reservation_tear_messages (yang:counter64)\n\nYANG Description: Number of sent RSVP Resv Tear messages", "id": "f22321:c0:m53"}
{"signature": "def _get_out_reservation_error_messages(self):", "body": "return self.__out_reservation_error_messages<EOL>", "docstring": "Getter method for out_reservation_error_messages, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/state/counters/out_reservation_error_messages (yang:counter64)\n\nYANG Description: Number of sent RSVP Resv Error messages", "id": "f22321:c1:m50"}
{"signature": "def _set_path_timeouts(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__path_timeouts = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for path_timeouts, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/state/counters/path_timeouts (yang:counter64)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_path_timeouts is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_path_timeouts() directly.\n\nYANG Description: TODO", "id": "f22321:c0:m3"}
{"signature": "def _set_in_srefresh_messages(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__in_srefresh_messages = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for in_srefresh_messages, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/state/counters/in_srefresh_messages (yang:counter64)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_in_srefresh_messages is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_in_srefresh_messages() directly.\n\nYANG Description: Number of received RSVP summary refresh messages", "id": "f22321:c0:m33"}
{"signature": "def _get_out_reservation_tear_messages(self):", "body": "return self.__out_reservation_tear_messages<EOL>", "docstring": "Getter method for out_reservation_tear_messages, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/state/counters/out_reservation_tear_messages (yang:counter64)\n\nYANG Description: Number of sent RSVP Resv Tear messages", "id": "f22321:c1:m53"}
{"signature": "def _set_out_ack_messages(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__out_ack_messages = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for out_ack_messages, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/state/counters/out_ack_messages (yang:counter64)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_out_ack_messages is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_out_ack_messages() directly.\n\nYANG Description: Number of sent RSVP refresh reduction ack messages", "id": "f22321:c1:m63"}
{"signature": "def _set_graceful_restart(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=graceful_restart.graceful_restart,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__graceful_restart = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for graceful_restart, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/graceful_restart (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_graceful_restart is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_graceful_restart() directly.\n\n    YANG Description: Operational state and configuration parameters relating to\ngraceful-restart for RSVP", "id": "f22322:c0:m3"}
{"signature": "def _get_graceful_restart(self):", "body": "return self.__graceful_restart<EOL>", "docstring": "Getter method for graceful_restart, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/graceful_restart (container)\n\n    YANG Description: Operational state and configuration parameters relating to\ngraceful-restart for RSVP", "id": "f22322:c1:m2"}
{"signature": "def _get_hellos(self):", "body": "return self.__hellos<EOL>", "docstring": "Getter method for hellos, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/hellos (container)\n\nYANG Description: Top level container for RSVP hello parameters", "id": "f22322:c0:m8"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/state (container)\n\nYANG Description: Platform wide RSVP state, including counters", "id": "f22322:c1:m11"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Platform wide RSVP state, including counters", "id": "f22322:c0:m12"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Platform wide RSVP state, including counters", "id": "f22322:c1:m12"}
{"signature": "def _get_soft_preemption(self):", "body": "return self.__soft_preemption<EOL>", "docstring": "Getter method for soft_preemption, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/soft_preemption (container)\n\n    YANG Description: Protocol options relating to RSVP\nsoft preemption", "id": "f22322:c1:m5"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/state (container)\n\nYANG Description: Platform wide RSVP state, including counters", "id": "f22322:c0:m11"}
{"signature": "def _set_hello_interval(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:16>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>default=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>)(<EOL><NUM_LIT><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__hello_interval = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for hello_interval, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/hellos/state/hello_interval (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_hello_interval is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_hello_interval() directly.\n\n    YANG Description: set the interval in ms between RSVP hello\nmessages", "id": "f22323:c1:m3"}
{"signature": "def _set_hello_interval(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:16>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>default=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>)(<EOL><NUM_LIT><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__hello_interval = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for hello_interval, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/hellos/state/hello_interval (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_hello_interval is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_hello_interval() directly.\n\n    YANG Description: set the interval in ms between RSVP hello\nmessages", "id": "f22323:c0:m3"}
{"signature": "def _set_refresh_reduction(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:true>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__refresh_reduction = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for refresh_reduction, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/hellos/state/refresh_reduction (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_refresh_reduction is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_refresh_reduction() directly.\n\n    YANG Description: enables all RSVP refresh reduction message\nbundling, RSVP message ID, reliable message delivery\nand summary refresh", "id": "f22323:c0:m6"}
{"signature": "def _set_refresh_reduction(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:true>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__refresh_reduction = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for refresh_reduction, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/hellos/state/refresh_reduction (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_refresh_reduction is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_refresh_reduction() directly.\n\n    YANG Description: enables all RSVP refresh reduction message\nbundling, RSVP message ID, reliable message delivery\nand summary refresh", "id": "f22323:c1:m6"}
{"signature": "def _set_hello_interval(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:16>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>default=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>)(<EOL><NUM_LIT><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__hello_interval = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for hello_interval, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/hellos/config/hello_interval (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_hello_interval is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_hello_interval() directly.\n\n    YANG Description: set the interval in ms between RSVP hello\nmessages", "id": "f22324:c0:m3"}
{"signature": "def _set_hello_interval(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:16>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>default=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>)(<EOL><NUM_LIT><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__hello_interval = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for hello_interval, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/hellos/config/hello_interval (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_hello_interval is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_hello_interval() directly.\n\n    YANG Description: set the interval in ms between RSVP hello\nmessages", "id": "f22324:c1:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/hellos/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State information associated with RSVP hellos", "id": "f22325:c1:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/hellos/state (container)\n\nYANG Description: State information associated with RSVP hellos", "id": "f22325:c0:m5"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te/global/hellos/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to RSVP\nhellos", "id": "f22325:c0:m3"}
{"signature": "def _get_segment_routing(self):", "body": "return self.__segment_routing<EOL>", "docstring": "Getter method for segment_routing, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing (container)\n\n    YANG Description: MPLS-specific Segment Routing configuration and operational state\nparameters", "id": "f22326:c1:m5"}
{"signature": "def _set_rsvp_te(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=rsvp_te.rsvp_te,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__rsvp_te = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for rsvp_te, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/rsvp_te (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_rsvp_te is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_rsvp_te() directly.\n\nYANG Description: RSVP-TE global signaling protocol configuration", "id": "f22326:c0:m3"}
{"signature": "def _set_interface_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface_id, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/interfaces/interface/state/interface_id (string)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_interface_id is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_interface_id() directly.\n\nYANG Description: A unique identifier for the interface.", "id": "f22327:c1:m3"}
{"signature": "def _set_out_octets(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__out_octets = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for out_octets, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/interfaces/interface/state/out_octets (yang:counter64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_out_octets is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_out_octets() directly.\n\n    YANG Description: A cumulative counter of the total bytes transmitted by the local\nsystem within the context which have a label imported that\ncorresponds to an SR Segment Identifier.", "id": "f22327:c0:m15"}
{"signature": "def _set_in_pkts(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__in_pkts = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for in_pkts, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/interfaces/interface/state/in_pkts (yang:counter64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_in_pkts is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_in_pkts() directly.\n\n    YANG Description: A cumulative counter of the packets received within the context\nwhich have matched a label corresponding to an SR Segment Identifier.", "id": "f22327:c0:m6"}
{"signature": "def _get_interface_id(self):", "body": "return self.__interface_id<EOL>", "docstring": "Getter method for interface_id, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/interfaces/interface/state/interface_id (string)\n\nYANG Description: A unique identifier for the interface.", "id": "f22327:c1:m2"}
{"signature": "def _get_out_octets(self):", "body": "return self.__out_octets<EOL>", "docstring": "Getter method for out_octets, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/interfaces/interface/state/out_octets (yang:counter64)\n\n    YANG Description: A cumulative counter of the total bytes transmitted by the local\nsystem within the context which have a label imported that\ncorresponds to an SR Segment Identifier.", "id": "f22327:c1:m14"}
{"signature": "def _set_in_octets(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__in_octets = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for in_octets, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/interfaces/interface/state/in_octets (yang:counter64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_in_octets is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_in_octets() directly.\n\n    YANG Description: The cumulative counter of the total bytes received within the context\nwhich have matched a label corresponding to an SR Segment Identifier", "id": "f22327:c1:m9"}
{"signature": "def _set_out_octets(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__out_octets = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for out_octets, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/interfaces/interface/state/out_octets (yang:counter64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_out_octets is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_out_octets() directly.\n\n    YANG Description: A cumulative counter of the total bytes transmitted by the local\nsystem within the context which have a label imported that\ncorresponds to an SR Segment Identifier.", "id": "f22327:c1:m15"}
{"signature": "def _set_interface_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface_id, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/interfaces/interface/config/interface_id (string)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_interface_id is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_interface_id() directly.\n\nYANG Description: A unique identifier for the interface.", "id": "f22328:c1:m3"}
{"signature": "def _get_subinterface(self):", "body": "return self.__subinterface<EOL>", "docstring": "Getter method for subinterface, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/interfaces/interface/interface_ref/config/subinterface (leafref)\n\n    YANG Description: Reference to a subinterface -- this requires the base\ninterface to be specified using the interface leaf in\nthis container.  If only a reference to a base interface\nis requuired, this leaf should not be set.", "id": "f22330:c1:m5"}
{"signature": "def _get_interface(self):", "body": "return self.__interface<EOL>", "docstring": "Getter method for interface, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/interfaces/interface/interface_ref/config/interface (leafref)\n\n    YANG Description: Reference to a base interface.  If a reference to a\nsubinterface is required, this leaf must be specified\nto indicate the base interface.", "id": "f22330:c1:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/interfaces/interface/interface_ref/state (container)\n\nYANG Description: Operational state for interface-ref", "id": "f22331:c1:m5"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/interfaces/interface/interface_ref/config (container)\n\nYANG Description: Configured reference to interface / subinterface", "id": "f22331:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/interfaces/interface/interface_ref/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Operational state for interface-ref", "id": "f22331:c0:m6"}
{"signature": "def _set_interface_ref(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=interface_ref.interface_ref,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface_ref = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface_ref, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/interfaces/interface/interface_ref (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_interface_ref is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_interface_ref() directly.\n\nYANG Description: Reference to an interface or subinterface", "id": "f22332:c0:m15"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/interfaces/interface/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: MPLS-specific Segment Routing configuration parameters\nrelated to an interface.", "id": "f22332:c0:m6"}
{"signature": "def _set_out_pkts(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__out_pkts = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for out_pkts, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/interfaces/interface/sid_counters/sid_counter/state/out_pkts (yang:counter64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_out_pkts is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_out_pkts() directly.\n\n    YANG Description: A cumulative counter of the total number of packets transmitted by\nthe local system within the context which have a label imposed that\ncorresponds to an Segment Identifier.", "id": "f22333:c1:m12"}
{"signature": "def _get_out_octets(self):", "body": "return self.__out_octets<EOL>", "docstring": "Getter method for out_octets, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/interfaces/interface/sid_counters/sid_counter/state/out_octets (yang:counter64)\n\n    YANG Description: A cumulative counter of the total bytes transmitted by the local\nsystem within the context which have a label imported that\ncorresponds to an SR Segment Identifier.", "id": "f22333:c1:m14"}
{"signature": "def _get_in_pkts(self):", "body": "return self.__in_pkts<EOL>", "docstring": "Getter method for in_pkts, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/interfaces/interface/sid_counters/sid_counter/state/in_pkts (yang:counter64)\n\n    YANG Description: A cumulative counter of the packets received within the context\nwhich have matched a label corresponding to an SR Segment Identifier.", "id": "f22333:c0:m5"}
{"signature": "def _get_out_octets(self):", "body": "return self.__out_octets<EOL>", "docstring": "Getter method for out_octets, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/interfaces/interface/sid_counters/sid_counter/state/out_octets (yang:counter64)\n\n    YANG Description: A cumulative counter of the total bytes transmitted by the local\nsystem within the context which have a label imported that\ncorresponds to an SR Segment Identifier.", "id": "f22333:c0:m14"}
{"signature": "def _set_mpls_label(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:0>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:1>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:2>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:3>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:7>},<EOL>\"<STR_LIT>\": {},<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__mpls_label = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for mpls_label, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/interfaces/interface/sid_counters/sid_counter/state/mpls_label (oc-mpls-t:mpls-label)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_mpls_label is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_mpls_label() directly.\n\nYANG Description: The MPLS label used for the segment identifier", "id": "f22333:c1:m3"}
{"signature": "def _get_in_octets(self):", "body": "return self.__in_octets<EOL>", "docstring": "Getter method for in_octets, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/interfaces/interface/sid_counters/sid_counter/state/in_octets (yang:counter64)\n\n    YANG Description: The cumulative counter of the total bytes received within the context\nwhich have matched a label corresponding to an SR Segment Identifier", "id": "f22333:c1:m8"}
{"signature": "def _set_out_octets(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__out_octets = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for out_octets, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/interfaces/interface/sid_counters/sid_counter/state/out_octets (yang:counter64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_out_octets is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_out_octets() directly.\n\n    YANG Description: A cumulative counter of the total bytes transmitted by the local\nsystem within the context which have a label imported that\ncorresponds to an SR Segment Identifier.", "id": "f22333:c0:m15"}
{"signature": "def _get_out_pkts(self):", "body": "return self.__out_pkts<EOL>", "docstring": "Getter method for out_pkts, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/interfaces/interface/sid_counters/sid_counter/state/out_pkts (yang:counter64)\n\n    YANG Description: A cumulative counter of the total number of packets transmitted by\nthe local system within the context which have a label imposed that\ncorresponds to an Segment Identifier.", "id": "f22333:c0:m11"}
{"signature": "def _set_out_pkts(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__out_pkts = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for out_pkts, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/interfaces/interface/sid_counters/sid_counter/forwarding_classes/forwarding_class/state/out_pkts (yang:counter64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_out_pkts is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_out_pkts() directly.\n\n    YANG Description: A cumulative counter of the total number of packets transmitted by\nthe local system within the context which have a label imposed that\ncorresponds to an Segment Identifier.", "id": "f22334:c1:m12"}
{"signature": "def _set_in_octets(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__in_octets = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for in_octets, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/interfaces/interface/sid_counters/sid_counter/forwarding_classes/forwarding_class/state/in_octets (yang:counter64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_in_octets is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_in_octets() directly.\n\n    YANG Description: The cumulative counter of the total bytes received within the context\nwhich have matched a label corresponding to an SR Segment Identifier", "id": "f22334:c0:m9"}
{"signature": "def _get_out_pkts(self):", "body": "return self.__out_pkts<EOL>", "docstring": "Getter method for out_pkts, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/interfaces/interface/sid_counters/sid_counter/forwarding_classes/forwarding_class/state/out_pkts (yang:counter64)\n\n    YANG Description: A cumulative counter of the total number of packets transmitted by\nthe local system within the context which have a label imposed that\ncorresponds to an Segment Identifier.", "id": "f22334:c0:m11"}
{"signature": "def _set_in_pkts(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__in_pkts = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for in_pkts, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/interfaces/interface/sid_counters/sid_counter/forwarding_classes/forwarding_class/state/in_pkts (yang:counter64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_in_pkts is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_in_pkts() directly.\n\n    YANG Description: A cumulative counter of the packets received within the context\nwhich have matched a label corresponding to an SR Segment Identifier.", "id": "f22334:c1:m6"}
{"signature": "def _set_in_octets(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__in_octets = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for in_octets, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/interfaces/interface/sid_counters/sid_counter/forwarding_classes/forwarding_class/state/in_octets (yang:counter64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_in_octets is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_in_octets() directly.\n\n    YANG Description: The cumulative counter of the total bytes received within the context\nwhich have matched a label corresponding to an SR Segment Identifier", "id": "f22334:c1:m9"}
{"signature": "def _get_exp(self):", "body": "return self.__exp<EOL>", "docstring": "Getter method for exp, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/interfaces/interface/sid_counters/sid_counter/forwarding_classes/forwarding_class/exp (leafref)\n\n    YANG Description: Reference to the value of the EXP bits of the segment\nidentifier.", "id": "f22335:c1:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/interfaces/interface/sid_counters/sid_counter/forwarding_classes/forwarding_class/state (container)\n\n    YANG Description: Per-SID, per forwarding class counters for Segment Routing\nwith the MPLS dataplane", "id": "f22335:c1:m5"}
{"signature": "def _set_forwarding_class(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>forwarding_class.forwarding_class,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__forwarding_class = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for forwarding_class, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/interfaces/interface/sid_counters/sid_counter/forwarding_classes/forwarding_class (list)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_forwarding_class is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_forwarding_class() directly.\n\n    YANG Description: SID entries for the forwarding class associated with the\nreferenced MPLS EXP.", "id": "f22336:c0:m3"}
{"signature": "def _get_forwarding_class(self):", "body": "return self.__forwarding_class<EOL>", "docstring": "Getter method for forwarding_class, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/interfaces/interface/sid_counters/sid_counter/forwarding_classes/forwarding_class (list)\n\n    YANG Description: SID entries for the forwarding class associated with the\nreferenced MPLS EXP.", "id": "f22336:c1:m2"}
{"signature": "def _get_forwarding_classes(self):", "body": "return self.__forwarding_classes<EOL>", "docstring": "Getter method for forwarding_classes, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/interfaces/interface/sid_counters/sid_counter/forwarding_classes (container)\n\nYANG Description: Per-SID per-forwarding class counters for Segment Routing.", "id": "f22337:c1:m8"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/interfaces/interface/sid_counters/sid_counter/state (container)\n\nYANG Description: State parameters for per-SID statistics", "id": "f22337:c1:m5"}
{"signature": "def _set_forwarding_classes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=forwarding_classes.forwarding_classes,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__forwarding_classes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for forwarding_classes, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/interfaces/interface/sid_counters/sid_counter/forwarding_classes (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_forwarding_classes is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_forwarding_classes() directly.\n\nYANG Description: Per-SID per-forwarding class counters for Segment Routing.", "id": "f22337:c1:m9"}
{"signature": "def _get_interface(self):", "body": "return self.__interface<EOL>", "docstring": "Getter method for interface, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/interfaces/interface (list)\n\n    YANG Description: Parameters and MPLS-specific configuration relating to Segment\nRouting on an interface.", "id": "f22339:c0:m2"}
{"signature": "def _set_interfaces(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=interfaces.interfaces,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interfaces = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interfaces, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/interfaces (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_interfaces is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_interfaces() directly.\n\nYANG Description: Interface related Segment Routing parameters.", "id": "f22340:c1:m6"}
{"signature": "def _get_aggregate_sid_counters(self):", "body": "return self.__aggregate_sid_counters<EOL>", "docstring": "Getter method for aggregate_sid_counters, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/aggregate_sid_counters (container)\n\nYANG Description: Per-SID counters aggregated across all interfaces on the local system", "id": "f22340:c1:m2"}
{"signature": "def _set_mpls_label(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:0>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:1>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:2>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:3>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:7>},<EOL>\"<STR_LIT>\": {},<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__mpls_label = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for mpls_label, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/aggregate_sid_counters/aggregate_sid_counter/state/mpls_label (oc-mpls-t:mpls-label)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_mpls_label is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_mpls_label() directly.\n\nYANG Description: The MPLS label used for the segment identifier", "id": "f22341:c0:m3"}
{"signature": "def _get_in_octets(self):", "body": "return self.__in_octets<EOL>", "docstring": "Getter method for in_octets, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/aggregate_sid_counters/aggregate_sid_counter/state/in_octets (yang:counter64)\n\n    YANG Description: The cumulative counter of the total bytes received within the context\nwhich have matched a label corresponding to an SR Segment Identifier", "id": "f22341:c0:m8"}
{"signature": "def _get_in_pkts(self):", "body": "return self.__in_pkts<EOL>", "docstring": "Getter method for in_pkts, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/aggregate_sid_counters/aggregate_sid_counter/state/in_pkts (yang:counter64)\n\n    YANG Description: A cumulative counter of the packets received within the context\nwhich have matched a label corresponding to an SR Segment Identifier.", "id": "f22341:c1:m5"}
{"signature": "def _set_out_pkts(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__out_pkts = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for out_pkts, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/aggregate_sid_counters/aggregate_sid_counter/state/out_pkts (yang:counter64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_out_pkts is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_out_pkts() directly.\n\n    YANG Description: A cumulative counter of the total number of packets transmitted by\nthe local system within the context which have a label imposed that\ncorresponds to an Segment Identifier.", "id": "f22341:c0:m12"}
{"signature": "def _set_in_octets(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__in_octets = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for in_octets, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/aggregate_sid_counters/aggregate_sid_counter/state/in_octets (yang:counter64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_in_octets is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_in_octets() directly.\n\n    YANG Description: The cumulative counter of the total bytes received within the context\nwhich have matched a label corresponding to an SR Segment Identifier", "id": "f22341:c0:m9"}
{"signature": "def _set_in_pkts(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__in_pkts = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for in_pkts, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/aggregate_sid_counters/aggregate_sid_counter/state/in_pkts (yang:counter64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_in_pkts is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_in_pkts() directly.\n\n    YANG Description: A cumulative counter of the packets received within the context\nwhich have matched a label corresponding to an SR Segment Identifier.", "id": "f22341:c0:m6"}
{"signature": "def _get_out_octets(self):", "body": "return self.__out_octets<EOL>", "docstring": "Getter method for out_octets, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/aggregate_sid_counters/aggregate_sid_counter/state/out_octets (yang:counter64)\n\n    YANG Description: A cumulative counter of the total bytes transmitted by the local\nsystem within the context which have a label imported that\ncorresponds to an SR Segment Identifier.", "id": "f22341:c1:m14"}
{"signature": "def _set_in_octets(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__in_octets = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for in_octets, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/aggregate_sid_counters/aggregate_sid_counter/state/in_octets (yang:counter64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_in_octets is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_in_octets() directly.\n\n    YANG Description: The cumulative counter of the total bytes received within the context\nwhich have matched a label corresponding to an SR Segment Identifier", "id": "f22341:c1:m9"}
{"signature": "def _set_in_pkts(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__in_pkts = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for in_pkts, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/aggregate_sid_counters/aggregate_sid_counter/state/in_pkts (yang:counter64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_in_pkts is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_in_pkts() directly.\n\n    YANG Description: A cumulative counter of the packets received within the context\nwhich have matched a label corresponding to an SR Segment Identifier.", "id": "f22341:c1:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/aggregate_sid_counters/aggregate_sid_counter/state (container)\n\nYANG Description: State parameters for per-SID statistics", "id": "f22342:c1:m5"}
{"signature": "def _set_mpls_label(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__mpls_label = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for mpls_label, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/aggregate_sid_counters/aggregate_sid_counter/mpls_label (leafref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_mpls_label is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_mpls_label() directly.\n\nYANG Description: The MPLS label representing the segment identifier", "id": "f22342:c1:m3"}
{"signature": "def _get_aggregate_sid_counter(self):", "body": "return self.__aggregate_sid_counter<EOL>", "docstring": "Getter method for aggregate_sid_counter, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/aggregate_sid_counters/aggregate_sid_counter (list)\n\n    YANG Description: Counters aggregated across all of the interfaces of the local\nsystem corresponding to traffic received or forwarded with a\nparticular SID", "id": "f22343:c1:m2"}
{"signature": "def _get_aggregate_sid_counter(self):", "body": "return self.__aggregate_sid_counter<EOL>", "docstring": "Getter method for aggregate_sid_counter, mapped from YANG variable /network_instances/network_instance/mpls/signaling_protocols/segment_routing/aggregate_sid_counters/aggregate_sid_counter (list)\n\n    YANG Description: Counters aggregated across all of the interfaces of the local\nsystem corresponding to traffic received or forwarded with a\nparticular SID", "id": "f22343:c0:m2"}
{"signature": "def _set_connection_point_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__connection_point_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for connection_point_id, mapped from YANG variable /network_instances/network_instance/connection_points/connection_point/state/connection_point_id (string)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_connection_point_id is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_connection_point_id() directly.\n\nYANG Description: An identifier for a connection point", "id": "f22344:c1:m3"}
{"signature": "def _get_connection_point_id(self):", "body": "return self.__connection_point_id<EOL>", "docstring": "Getter method for connection_point_id, mapped from YANG variable /network_instances/network_instance/connection_points/connection_point/state/connection_point_id (string)\n\nYANG Description: An identifier for a connection point", "id": "f22344:c0:m2"}
{"signature": "def _get_connection_point_id(self):", "body": "return self.__connection_point_id<EOL>", "docstring": "Getter method for connection_point_id, mapped from YANG variable /network_instances/network_instance/connection_points/connection_point/config/connection_point_id (string)\n\nYANG Description: An identifier for a connection point", "id": "f22345:c0:m2"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/connection_points/connection_point/config (container)\n\n    YANG Description: Configuration parameters relating to a Layer 2\nnetwork instance connection point", "id": "f22346:c1:m5"}
{"signature": "def _set_connection_point_id(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__connection_point_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for connection_point_id, mapped from YANG variable /network_instances/network_instance/connection_points/connection_point/connection_point_id (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_connection_point_id is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_connection_point_id() directly.\n\n    YANG Description: A locally significant reference for the\nconnection-point", "id": "f22346:c0:m3"}
{"signature": "def _get_endpoints(self):", "body": "return self.__endpoints<EOL>", "docstring": "Getter method for endpoints, mapped from YANG variable /network_instances/network_instance/connection_points/connection_point/endpoints (container)\n\n    YANG Description: The set of endpoints which are grouped within the\nconnection point", "id": "f22346:c1:m11"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/connection_points/connection_point/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to a Layer 2\nnetwork instance connection point", "id": "f22346:c1:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/connection_points/connection_point/state (container)\n\n    YANG Description: Operational state parameters relating to a Layer 2\nnetwork instance connection point", "id": "f22346:c0:m8"}
{"signature": "def _get_connection_point_id(self):", "body": "return self.__connection_point_id<EOL>", "docstring": "Getter method for connection_point_id, mapped from YANG variable /network_instances/network_instance/connection_points/connection_point/connection_point_id (leafref)\n\n    YANG Description: A locally significant reference for the\nconnection-point", "id": "f22346:c0:m2"}
{"signature": "def _set_endpoints(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=endpoints.endpoints,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__endpoints = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for endpoints, mapped from YANG variable /network_instances/network_instance/connection_points/connection_point/endpoints (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_endpoints is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_endpoints() directly.\n\n    YANG Description: The set of endpoints which are grouped within the\nconnection point", "id": "f22346:c0:m12"}
{"signature": "def _get_precedence(self):", "body": "return self.__precedence<EOL>", "docstring": "Getter method for precedence, mapped from YANG variable /network_instances/network_instance/connection_points/connection_point/endpoints/endpoint/state/precedence (uint16)\n\n    YANG Description: The precedence of the endpoint - the lowest precendence\nviable endpoint will be utilised as the active endpoint\nwithin a connection", "id": "f22347:c1:m5"}
{"signature": "def _set_precedence(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__precedence = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for precedence, mapped from YANG variable /network_instances/network_instance/connection_points/connection_point/endpoints/endpoint/state/precedence (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_precedence is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_precedence() directly.\n\n    YANG Description: The precedence of the endpoint - the lowest precendence\nviable endpoint will be utilised as the active endpoint\nwithin a connection", "id": "f22347:c1:m6"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/connection_points/connection_point/endpoints/endpoint/config/type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_type() directly.\n\n    YANG Description: The type of endpoint that is referred to by the current\nendpoint", "id": "f22348:c0:m9"}
{"signature": "def _set_precedence(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__precedence = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for precedence, mapped from YANG variable /network_instances/network_instance/connection_points/connection_point/endpoints/endpoint/config/precedence (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_precedence is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_precedence() directly.\n\n    YANG Description: The precedence of the endpoint - the lowest precendence\nviable endpoint will be utilised as the active endpoint\nwithin a connection", "id": "f22348:c0:m6"}
{"signature": "def _get_endpoint_id(self):", "body": "return self.__endpoint_id<EOL>", "docstring": "Getter method for endpoint_id, mapped from YANG variable /network_instances/network_instance/connection_points/connection_point/endpoints/endpoint/config/endpoint_id (string)\n\nYANG Description: An identifier for the endpoint", "id": "f22348:c1:m2"}
{"signature": "def _get_precedence(self):", "body": "return self.__precedence<EOL>", "docstring": "Getter method for precedence, mapped from YANG variable /network_instances/network_instance/connection_points/connection_point/endpoints/endpoint/config/precedence (uint16)\n\n    YANG Description: The precedence of the endpoint - the lowest precendence\nviable endpoint will be utilised as the active endpoint\nwithin a connection", "id": "f22348:c0:m5"}
{"signature": "def _set_precedence(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__precedence = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for precedence, mapped from YANG variable /network_instances/network_instance/connection_points/connection_point/endpoints/endpoint/config/precedence (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_precedence is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_precedence() directly.\n\n    YANG Description: The precedence of the endpoint - the lowest precendence\nviable endpoint will be utilised as the active endpoint\nwithin a connection", "id": "f22348:c1:m6"}
{"signature": "def _set_virtual_circuit_identifier(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__virtual_circuit_identifier = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for virtual_circuit_identifier, mapped from YANG variable /network_instances/network_instance/connection_points/connection_point/endpoints/endpoint/remote/state/virtual_circuit_identifier (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_virtual_circuit_identifier is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_virtual_circuit_identifier() directly.\n\n    YANG Description: The virtual-circuit identifier that identifies the\nconnection at the remote end-point", "id": "f22349:c1:m6"}
{"signature": "def _get_remote_system(self):", "body": "return self.__remote_system<EOL>", "docstring": "Getter method for remote_system, mapped from YANG variable /network_instances/network_instance/connection_points/connection_point/endpoints/endpoint/remote/config/remote_system (inet:ip-address)\n\n    YANG Description: The IP address of the device which hosts the\nremote end-point", "id": "f22350:c0:m2"}
{"signature": "def _set_remote_system(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__remote_system = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for remote_system, mapped from YANG variable /network_instances/network_instance/connection_points/connection_point/endpoints/endpoint/remote/config/remote_system (inet:ip-address)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_remote_system is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_remote_system() directly.\n\n    YANG Description: The IP address of the device which hosts the\nremote end-point", "id": "f22350:c1:m3"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/connection_points/connection_point/endpoints/endpoint/remote/config (container)\n\n    YANG Description: Configuration parameters relating to a remote\nendpoint", "id": "f22351:c0:m2"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/connection_points/connection_point/endpoints/endpoint/remote/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to a remote\nendpoint", "id": "f22351:c1:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/connection_points/connection_point/endpoints/endpoint/remote/state (container)\n\n    YANG Description: Operational state parameters relating to\na remote endpoint", "id": "f22351:c1:m5"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/connection_points/connection_point/endpoints/endpoint/remote/config (container)\n\n    YANG Description: Configuration parameters relating to a remote\nendpoint", "id": "f22351:c1:m2"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/connection_points/connection_point/endpoints/endpoint/config (container)\n\n    YANG Description: Configuration parameters relating to the\nendpoint", "id": "f22352:c1:m5"}
{"signature": "def _get_local_(self):", "body": "return self.__local_<EOL>", "docstring": "Getter method for local_, mapped from YANG variable /network_instances/network_instance/connection_points/connection_point/endpoints/endpoint/local (container)\n\n    YANG Description: Configuration and operational state parameters\nrelating to a local interface", "id": "f22352:c1:m11"}
{"signature": "def _set_endpoint_id(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__endpoint_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for endpoint_id, mapped from YANG variable /network_instances/network_instance/connection_points/connection_point/endpoints/endpoint/endpoint_id (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_endpoint_id is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_endpoint_id() directly.\n\n    YANG Description: A pointer to the configured identifier for the\nendpoint", "id": "f22352:c0:m3"}
{"signature": "def _get_endpoint_id(self):", "body": "return self.__endpoint_id<EOL>", "docstring": "Getter method for endpoint_id, mapped from YANG variable /network_instances/network_instance/connection_points/connection_point/endpoints/endpoint/endpoint_id (leafref)\n\n    YANG Description: A pointer to the configured identifier for the\nendpoint", "id": "f22352:c1:m2"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/connection_points/connection_point/endpoints/endpoint/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to the\nendpoint", "id": "f22352:c0:m6"}
{"signature": "def _set_local_(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=local_.local_,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__local_ = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for local_, mapped from YANG variable /network_instances/network_instance/connection_points/connection_point/endpoints/endpoint/local (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_local_ is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_local_() directly.\n\n    YANG Description: Configuration and operational state parameters\nrelating to a local interface", "id": "f22352:c1:m12"}
{"signature": "def _set_remote(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=remote.remote,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__remote = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for remote, mapped from YANG variable /network_instances/network_instance/connection_points/connection_point/endpoints/endpoint/remote (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_remote is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_remote() directly.\n\n    YANG Description: Configuration and operational state parameters\nrelating to a remote interface", "id": "f22352:c1:m15"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/connection_points/connection_point/endpoints/endpoint/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to the\nendpoint", "id": "f22352:c1:m6"}
{"signature": "def _set_subinterface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subinterface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subinterface, mapped from YANG variable /network_instances/network_instance/connection_points/connection_point/endpoints/endpoint/local/state/subinterface (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subinterface is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subinterface() directly.\n\n    YANG Description: Reference to a subinterface -- this requires the base\ninterface to be specified using the interface leaf in\nthis container.  If only a reference to a base interface\nis requuired, this leaf should not be set.", "id": "f22353:c0:m6"}
{"signature": "def _get_interface(self):", "body": "return self.__interface<EOL>", "docstring": "Getter method for interface, mapped from YANG variable /network_instances/network_instance/connection_points/connection_point/endpoints/endpoint/local/state/interface (leafref)\n\n    YANG Description: Reference to a base interface.  If a reference to a\nsubinterface is required, this leaf must be specified\nto indicate the base interface.", "id": "f22353:c0:m2"}
{"signature": "def _set_interface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface, mapped from YANG variable /network_instances/network_instance/connection_points/connection_point/endpoints/endpoint/local/state/interface (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_interface is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_interface() directly.\n\n    YANG Description: Reference to a base interface.  If a reference to a\nsubinterface is required, this leaf must be specified\nto indicate the base interface.", "id": "f22353:c1:m3"}
{"signature": "def _set_interface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface, mapped from YANG variable /network_instances/network_instance/connection_points/connection_point/endpoints/endpoint/local/state/interface (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_interface is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_interface() directly.\n\n    YANG Description: Reference to a base interface.  If a reference to a\nsubinterface is required, this leaf must be specified\nto indicate the base interface.", "id": "f22353:c0:m3"}
{"signature": "def _get_interface(self):", "body": "return self.__interface<EOL>", "docstring": "Getter method for interface, mapped from YANG variable /network_instances/network_instance/connection_points/connection_point/endpoints/endpoint/local/config/interface (leafref)\n\n    YANG Description: Reference to a base interface.  If a reference to a\nsubinterface is required, this leaf must be specified\nto indicate the base interface.", "id": "f22354:c0:m2"}
{"signature": "def _set_interface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface, mapped from YANG variable /network_instances/network_instance/connection_points/connection_point/endpoints/endpoint/local/config/interface (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_interface is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_interface() directly.\n\n    YANG Description: Reference to a base interface.  If a reference to a\nsubinterface is required, this leaf must be specified\nto indicate the base interface.", "id": "f22354:c1:m3"}
{"signature": "def _set_subinterface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subinterface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subinterface, mapped from YANG variable /network_instances/network_instance/connection_points/connection_point/endpoints/endpoint/local/config/subinterface (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subinterface is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subinterface() directly.\n\n    YANG Description: Reference to a subinterface -- this requires the base\ninterface to be specified using the interface leaf in\nthis container.  If only a reference to a base interface\nis requuired, this leaf should not be set.", "id": "f22354:c1:m6"}
{"signature": "def _get_subinterface(self):", "body": "return self.__subinterface<EOL>", "docstring": "Getter method for subinterface, mapped from YANG variable /network_instances/network_instance/connection_points/connection_point/endpoints/endpoint/local/config/subinterface (leafref)\n\n    YANG Description: Reference to a subinterface -- this requires the base\ninterface to be specified using the interface leaf in\nthis container.  If only a reference to a base interface\nis requuired, this leaf should not be set.", "id": "f22354:c0:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/connection_points/connection_point/endpoints/endpoint/local/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: Operational state parameters relating to a\nlocal endpoint", "id": "f22355:c1:m6"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/connection_points/connection_point/endpoints/endpoint/local/config (container)\n\n    YANG Description: Configuration parameters relating to a local\nendpoint", "id": "f22355:c0:m2"}
{"signature": "def _get_endpoint(self):", "body": "return self.__endpoint<EOL>", "docstring": "Getter method for endpoint, mapped from YANG variable /network_instances/network_instance/connection_points/connection_point/endpoints/endpoint (list)\n\n    YANG Description: A list of the endpoints (interfaces or remote\nconnection points that can be used for this\nconnection point). The active endpoint is selected\nbased on the precedence that it is configured\nwith", "id": "f22356:c0:m2"}
{"signature": "def _set_endpoint(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>endpoint.endpoint,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__endpoint = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for endpoint, mapped from YANG variable /network_instances/network_instance/connection_points/connection_point/endpoints/endpoint (list)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_endpoint is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_endpoint() directly.\n\n    YANG Description: A list of the endpoints (interfaces or remote\nconnection points that can be used for this\nconnection point). The active endpoint is selected\nbased on the precedence that it is configured\nwith", "id": "f22356:c1:m3"}
{"signature": "def _set_endpoint(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>endpoint.endpoint,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__endpoint = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for endpoint, mapped from YANG variable /network_instances/network_instance/connection_points/connection_point/endpoints/endpoint (list)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_endpoint is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_endpoint() directly.\n\n    YANG Description: A list of the endpoints (interfaces or remote\nconnection points that can be used for this\nconnection point). The active endpoint is selected\nbased on the precedence that it is configured\nwith", "id": "f22356:c0:m3"}
{"signature": "def _get_connection_point(self):", "body": "return self.__connection_point<EOL>", "docstring": "Getter method for connection_point, mapped from YANG variable /network_instances/network_instance/connection_points/connection_point (list)\n\n    YANG Description: A connection point within a Layer 2 network instance.\nEach connection-point consists of a set of interfaces\nonly one of which is active at any one time. Other than\nthe specification of whether an interface is local\n(i.e., exists within this network-instance), or remote,\nall configuration and state parameters are common", "id": "f22357:c0:m2"}
{"signature": "def _get_interface(self):", "body": "return self.__interface<EOL>", "docstring": "Getter method for interface, mapped from YANG variable /network_instances/network_instance/interfaces/interface/state/interface (leafref)\n\n    YANG Description: Reference to a base interface.  If a reference to a\nsubinterface is required, this leaf must be specified\nto indicate the base interface.", "id": "f22358:c0:m5"}
{"signature": "def _set_subinterface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subinterface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subinterface, mapped from YANG variable /network_instances/network_instance/interfaces/interface/state/subinterface (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subinterface is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subinterface() directly.\n\n    YANG Description: Reference to a subinterface -- this requires the base\ninterface to be specified using the interface leaf in\nthis container.  If only a reference to a base interface\nis requuired, this leaf should not be set.", "id": "f22358:c0:m9"}
{"signature": "def _get_subinterface(self):", "body": "return self.__subinterface<EOL>", "docstring": "Getter method for subinterface, mapped from YANG variable /network_instances/network_instance/interfaces/interface/state/subinterface (leafref)\n\n    YANG Description: Reference to a subinterface -- this requires the base\ninterface to be specified using the interface leaf in\nthis container.  If only a reference to a base interface\nis requuired, this leaf should not be set.", "id": "f22358:c1:m8"}
{"signature": "def _set_associated_address_families(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__associated_address_families = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for associated_address_families, mapped from YANG variable /network_instances/network_instance/interfaces/interface/config/associated_address_families (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_associated_address_families is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_associated_address_families() directly.\n\n    YANG Description: The address families on the subinterface which are to be\nassociated with this network instance. When this leaf-list\nis empty and the network instance requires Layer 3 information\nthe address families for which the network instance is\nenabled should be imported. If the value of this leaf-list\nis specified then the association MUST only be made for\nthose address families that are included in the list.", "id": "f22359:c1:m12"}
{"signature": "def _set_associated_address_families(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__associated_address_families = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for associated_address_families, mapped from YANG variable /network_instances/network_instance/interfaces/interface/config/associated_address_families (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_associated_address_families is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_associated_address_families() directly.\n\n    YANG Description: The address families on the subinterface which are to be\nassociated with this network instance. When this leaf-list\nis empty and the network instance requires Layer 3 information\nthe address families for which the network instance is\nenabled should be imported. If the value of this leaf-list\nis specified then the association MUST only be made for\nthose address families that are included in the list.", "id": "f22359:c0:m12"}
{"signature": "def _get_interface(self):", "body": "return self.__interface<EOL>", "docstring": "Getter method for interface, mapped from YANG variable /network_instances/network_instance/interfaces/interface/config/interface (leafref)\n\n    YANG Description: Reference to a base interface.  If a reference to a\nsubinterface is required, this leaf must be specified\nto indicate the base interface.", "id": "f22359:c0:m5"}
{"signature": "def _set_subinterface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subinterface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subinterface, mapped from YANG variable /network_instances/network_instance/interfaces/interface/config/subinterface (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subinterface is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subinterface() directly.\n\n    YANG Description: Reference to a subinterface -- this requires the base\ninterface to be specified using the interface leaf in\nthis container.  If only a reference to a base interface\nis requuired, this leaf should not be set.", "id": "f22359:c0:m9"}
{"signature": "def _set_interface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface, mapped from YANG variable /network_instances/network_instance/interfaces/interface/config/interface (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_interface is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_interface() directly.\n\n    YANG Description: Reference to a base interface.  If a reference to a\nsubinterface is required, this leaf must be specified\nto indicate the base interface.", "id": "f22359:c1:m6"}
{"signature": "def _set_id(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:id>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for id, mapped from YANG variable /network_instances/network_instance/interfaces/interface/id (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_id is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_id() directly.\n\n    YANG Description: A reference to an identifier for this interface which\nacts as a key for this list", "id": "f22360:c1:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/interfaces/interface/state (container)\n\n    YANG Description: Operational state parameters relating to the\nassociated interface", "id": "f22360:c0:m8"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/interfaces/interface/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: Operational state parameters relating to the\nassociated interface", "id": "f22360:c0:m9"}
{"signature": "def _set_id(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:id>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for id, mapped from YANG variable /network_instances/network_instance/interfaces/interface/id (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_id is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_id() directly.\n\n    YANG Description: A reference to an identifier for this interface which\nacts as a key for this list", "id": "f22360:c0:m3"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/interfaces/interface/config (container)\n\n    YANG Description: Configuration parameters relating to the associated\ninterface", "id": "f22360:c1:m5"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/interfaces/interface/config (container)\n\n    YANG Description: Configuration parameters relating to the associated\ninterface", "id": "f22360:c0:m5"}
{"signature": "def _get_interface(self):", "body": "return self.__interface<EOL>", "docstring": "Getter method for interface, mapped from YANG variable /network_instances/network_instance/interfaces/interface (list)\n\nYANG Description: An interface associated with the network instance", "id": "f22361:c1:m2"}
{"signature": "def _set_afts(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=afts.afts,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__afts = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for afts, mapped from YANG variable /network_instances/network_instance/afts (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_afts is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_afts() directly.\n\n    YANG Description: The abstract forwarding tables (AFTs) that are associated\nwith the network instance. An AFT is instantiated per-protocol\nrunning within the network-instance - such that one exists for\nIPv4 Unicast, IPv6 Unicast, MPLS, L2 forwarding entries, etc.\nA forwarding entry within the FIB has a set of next-hops,\nwhich may be a reference to an entry within another table -\ne.g., where a Layer 3 next-hop has an associated Layer 2\nforwarding entry.", "id": "f22362:c0:m45"}
{"signature": "def _set_encapsulation(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=encapsulation.encapsulation,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__encapsulation = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for encapsulation, mapped from YANG variable /network_instances/network_instance/encapsulation (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_encapsulation is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_encapsulation() directly.\n\n    YANG Description: Configuration parameters relating to the encapsulation\nused for the network instance", "id": "f22362:c1:m15"}
{"signature": "def _get_connection_points(self):", "body": "return self.__connection_points<EOL>", "docstring": "Getter method for connection_points, mapped from YANG variable /network_instances/network_instance/connection_points (container)\n\n    YANG Description: The set of connection points within a forwarding\ninstance", "id": "f22362:c0:m29"}
{"signature": "def _get_table_connections(self):", "body": "return self.__table_connections<EOL>", "docstring": "Getter method for table_connections, mapped from YANG variable /network_instances/network_instance/table_connections (container)\n\n    YANG Description: Policies dictating how RIB or FIB entries are propagated\nbetween tables", "id": "f22362:c0:m20"}
{"signature": "def _get_interfaces(self):", "body": "return self.__interfaces<EOL>", "docstring": "Getter method for interfaces, mapped from YANG variable /network_instances/network_instance/interfaces (container)\n\n    YANG Description: The interfaces that are associated with this network\ninstance", "id": "f22362:c0:m23"}
{"signature": "def _get_name(self):", "body": "return self.__name<EOL>", "docstring": "Getter method for name, mapped from YANG variable /network_instances/network_instance/name (leafref)\n\nYANG Description: A unique name identifying the network instance", "id": "f22362:c0:m2"}
{"signature": "def _set_mpls(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=mpls.mpls,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__mpls = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for mpls, mapped from YANG variable /network_instances/network_instance/mpls (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_mpls is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_mpls() directly.\n\n    YANG Description: Anchor point for mpls configuration and operational\ndata", "id": "f22362:c1:m33"}
{"signature": "def _get_name(self):", "body": "return self.__name<EOL>", "docstring": "Getter method for name, mapped from YANG variable /network_instances/network_instance/name (leafref)\n\nYANG Description: A unique name identifying the network instance", "id": "f22362:c1:m2"}
{"signature": "def _get_policy_forwarding(self):", "body": "return self.__policy_forwarding<EOL>", "docstring": "Getter method for policy_forwarding, mapped from YANG variable /network_instances/network_instance/policy_forwarding (container)\n\n    YANG Description: Configuration and operational state relating to policy-forwarding within\na network instance.", "id": "f22362:c0:m41"}
{"signature": "def _get_segment_routing(self):", "body": "return self.__segment_routing<EOL>", "docstring": "Getter method for segment_routing, mapped from YANG variable /network_instances/network_instance/segment_routing (container)\n\n    YANG Description: Configuration and operational state parameters relating to\nsegment routing.", "id": "f22362:c0:m35"}
{"signature": "def _set_policy_forwarding(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=policy_forwarding.policy_forwarding,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__policy_forwarding = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for policy_forwarding, mapped from YANG variable /network_instances/network_instance/policy_forwarding (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_policy_forwarding is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_policy_forwarding() directly.\n\n    YANG Description: Configuration and operational state relating to policy-forwarding within\na network instance.", "id": "f22362:c0:m42"}
{"signature": "def _get_inter_instance_policies(self):", "body": "return self.__inter_instance_policies<EOL>", "docstring": "Getter method for inter_instance_policies, mapped from YANG variable /network_instances/network_instance/inter_instance_policies (container)\n\n    YANG Description: Policies dictating how RIB or FIB entries are imported\nto and exported from this instance", "id": "f22362:c1:m17"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/config (container)\n\n    YANG Description: Configuration parameters relating to a network\ninstance", "id": "f22362:c0:m8"}
{"signature": "def _set_segment_routing(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=segment_routing.segment_routing,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__segment_routing = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for segment_routing, mapped from YANG variable /network_instances/network_instance/segment_routing (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_segment_routing is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_segment_routing() directly.\n\n    YANG Description: Configuration and operational state parameters relating to\nsegment routing.", "id": "f22362:c0:m36"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: Operational state parameters relating to a network\ninstance", "id": "f22362:c0:m12"}
{"signature": "def _get_interfaces(self):", "body": "return self.__interfaces<EOL>", "docstring": "Getter method for interfaces, mapped from YANG variable /network_instances/network_instance/interfaces (container)\n\n    YANG Description: The interfaces that are associated with this network\ninstance", "id": "f22362:c1:m23"}
{"signature": "def _set_afts(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=afts.afts,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__afts = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for afts, mapped from YANG variable /network_instances/network_instance/afts (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_afts is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_afts() directly.\n\n    YANG Description: The abstract forwarding tables (AFTs) that are associated\nwith the network instance. An AFT is instantiated per-protocol\nrunning within the network-instance - such that one exists for\nIPv4 Unicast, IPv6 Unicast, MPLS, L2 forwarding entries, etc.\nA forwarding entry within the FIB has a set of next-hops,\nwhich may be a reference to an entry within another table -\ne.g., where a Layer 3 next-hop has an associated Layer 2\nforwarding entry.", "id": "f22362:c1:m45"}
{"signature": "def _set_table_connections(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=table_connections.table_connections,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__table_connections = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for table_connections, mapped from YANG variable /network_instances/network_instance/table_connections (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_table_connections is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_table_connections() directly.\n\n    YANG Description: Policies dictating how RIB or FIB entries are propagated\nbetween tables", "id": "f22362:c0:m21"}
{"signature": "def _get_ipv6_prefix(self):", "body": "return self.__ipv6_prefix<EOL>", "docstring": "Getter method for ipv6_prefix, mapped from YANG variable /network_instances/network_instance/segment_routing/srlbs/srlb/state/ipv6_prefix (inet:ipv6-prefix)\n\nYANG Description: The IPv6 prefix that is used for the SRLB.", "id": "f22364:c1:m11"}
{"signature": "def _set_mpls_label_block(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__mpls_label_block = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for mpls_label_block, mapped from YANG variable /network_instances/network_instance/segment_routing/srlbs/srlb/state/mpls_label_block (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_mpls_label_block is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_mpls_label_block() directly.\n\n    YANG Description: A reference to the MPLS label block that is used to contain the\nSIDs of the SRLB.", "id": "f22364:c0:m9"}
{"signature": "def _set_ipv6_prefix(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv6_prefix = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv6_prefix, mapped from YANG variable /network_instances/network_instance/segment_routing/srlbs/srlb/state/ipv6_prefix (inet:ipv6-prefix)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ipv6_prefix is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ipv6_prefix() directly.\n\nYANG Description: The IPv6 prefix that is used for the SRLB.", "id": "f22364:c1:m12"}
{"signature": "def _set_dataplane_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__dataplane_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for dataplane_type, mapped from YANG variable /network_instances/network_instance/segment_routing/srlbs/srlb/state/dataplane_type (sr-dataplane-type)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_dataplane_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_dataplane_type() directly.\n\n    YANG Description: The dataplane that is to be used for the Segment Routing Local Block.\nWhen MPLS is specified, the local block corresponds to a block of MPLS\nlabels; when IPv6 is specified it corresponds to an IPv6 prefix.", "id": "f22364:c0:m6"}
{"signature": "def _set_local_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__local_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for local_id, mapped from YANG variable /network_instances/network_instance/segment_routing/srlbs/srlb/state/local_id (string)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_local_id is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_local_id() directly.\n\n    YANG Description: A unique local identifier used for the Segment Routing Local Block.\nThe identifier is used when referencing the SRLB within other\ncontexts.", "id": "f22364:c0:m3"}
{"signature": "def _set_dataplane_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__dataplane_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for dataplane_type, mapped from YANG variable /network_instances/network_instance/segment_routing/srlbs/srlb/state/dataplane_type (sr-dataplane-type)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_dataplane_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_dataplane_type() directly.\n\n    YANG Description: The dataplane that is to be used for the Segment Routing Local Block.\nWhen MPLS is specified, the local block corresponds to a block of MPLS\nlabels; when IPv6 is specified it corresponds to an IPv6 prefix.", "id": "f22364:c1:m6"}
{"signature": "def _get_mpls_label_block(self):", "body": "return self.__mpls_label_block<EOL>", "docstring": "Getter method for mpls_label_block, mapped from YANG variable /network_instances/network_instance/segment_routing/srlbs/srlb/config/mpls_label_block (leafref)\n\n    YANG Description: A reference to the MPLS label block that is used to contain the\nSIDs of the SRLB.", "id": "f22365:c0:m8"}
{"signature": "def _get_ipv6_prefix(self):", "body": "return self.__ipv6_prefix<EOL>", "docstring": "Getter method for ipv6_prefix, mapped from YANG variable /network_instances/network_instance/segment_routing/srlbs/srlb/config/ipv6_prefix (inet:ipv6-prefix)\n\nYANG Description: The IPv6 prefix that is used for the SRLB.", "id": "f22365:c1:m11"}
{"signature": "def _set_mpls_label_block(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__mpls_label_block = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for mpls_label_block, mapped from YANG variable /network_instances/network_instance/segment_routing/srlbs/srlb/config/mpls_label_block (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_mpls_label_block is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_mpls_label_block() directly.\n\n    YANG Description: A reference to the MPLS label block that is used to contain the\nSIDs of the SRLB.", "id": "f22365:c0:m9"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/segment_routing/srlbs/srlb/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Operational state parmeters relating to the SRLB.", "id": "f22366:c0:m9"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/segment_routing/srlbs/srlb/config (container)\n\nYANG Description: Configuration parameters relating to the SRLB.", "id": "f22366:c1:m5"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/segment_routing/srlbs/srlb/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration parameters relating to the SRLB.", "id": "f22366:c1:m6"}
{"signature": "def _get_local_id(self):", "body": "return self.__local_id<EOL>", "docstring": "Getter method for local_id, mapped from YANG variable /network_instances/network_instance/segment_routing/srgbs/srgb/state/local_id (string)\n\n    YANG Description: Unique identifier for the segment routing global block on\nthe local system.", "id": "f22367:c0:m2"}
{"signature": "def _get_local_id(self):", "body": "return self.__local_id<EOL>", "docstring": "Getter method for local_id, mapped from YANG variable /network_instances/network_instance/segment_routing/srgbs/srgb/state/local_id (string)\n\n    YANG Description: Unique identifier for the segment routing global block on\nthe local system.", "id": "f22367:c1:m2"}
{"signature": "def _get_used(self):", "body": "return self.__used<EOL>", "docstring": "Getter method for used, mapped from YANG variable /network_instances/network_instance/segment_routing/srgbs/srgb/state/used (uint32)\n\n    YANG Description: The total number of SRGB entries that have already been alocated by\nprotocols referencing the SRGB.", "id": "f22367:c0:m17"}
{"signature": "def _set_size(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:size>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__size = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for size, mapped from YANG variable /network_instances/network_instance/segment_routing/srgbs/srgb/state/size (uint32)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_size is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_size() directly.\n\nYANG Description: The total number of SRGB entries that are available within the SRGB.", "id": "f22367:c0:m15"}
{"signature": "def _set_ipv6_prefixes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv6_prefixes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv6_prefixes, mapped from YANG variable /network_instances/network_instance/segment_routing/srgbs/srgb/state/ipv6_prefixes (inet:ipv6-prefix)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_ipv6_prefixes is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_ipv6_prefixes() directly.\n\n    YANG Description: A list of IPv6 prefixes which are to be used for segment routing using\nthe IPv6 dataplane.", "id": "f22367:c0:m12"}
{"signature": "def _set_local_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__local_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for local_id, mapped from YANG variable /network_instances/network_instance/segment_routing/srgbs/srgb/state/local_id (string)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_local_id is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_local_id() directly.\n\n    YANG Description: Unique identifier for the segment routing global block on\nthe local system.", "id": "f22367:c0:m3"}
{"signature": "def _get_dataplane_type(self):", "body": "return self.__dataplane_type<EOL>", "docstring": "Getter method for dataplane_type, mapped from YANG variable /network_instances/network_instance/segment_routing/srgbs/srgb/state/dataplane_type (sr-dataplane-type)\n\n    YANG Description: The dataplane being used to instantiate the SRGB. When MPLS is specified\nthe set of MPLS label blocks that are defined in the mpls-label-blocks\nlist are used to make up the SRGB. When IPv6 is specified, the set of IPv6\nprefixes specified in the ipv6-prefixes list are used.", "id": "f22367:c1:m5"}
{"signature": "def _set_dataplane_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__dataplane_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for dataplane_type, mapped from YANG variable /network_instances/network_instance/segment_routing/srgbs/srgb/state/dataplane_type (sr-dataplane-type)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_dataplane_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_dataplane_type() directly.\n\n    YANG Description: The dataplane being used to instantiate the SRGB. When MPLS is specified\nthe set of MPLS label blocks that are defined in the mpls-label-blocks\nlist are used to make up the SRGB. When IPv6 is specified, the set of IPv6\nprefixes specified in the ipv6-prefixes list are used.", "id": "f22367:c1:m6"}
{"signature": "def _set_local_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__local_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for local_id, mapped from YANG variable /network_instances/network_instance/segment_routing/srgbs/srgb/config/local_id (string)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_local_id is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_local_id() directly.\n\n    YANG Description: Unique identifier for the segment routing global block on\nthe local system.", "id": "f22368:c0:m3"}
{"signature": "def _set_dataplane_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__dataplane_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for dataplane_type, mapped from YANG variable /network_instances/network_instance/segment_routing/srgbs/srgb/config/dataplane_type (sr-dataplane-type)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_dataplane_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_dataplane_type() directly.\n\n    YANG Description: The dataplane being used to instantiate the SRGB. When MPLS is specified\nthe set of MPLS label blocks that are defined in the mpls-label-blocks\nlist are used to make up the SRGB. When IPv6 is specified, the set of IPv6\nprefixes specified in the ipv6-prefixes list are used.", "id": "f22368:c1:m6"}
{"signature": "def _get_dataplane_type(self):", "body": "return self.__dataplane_type<EOL>", "docstring": "Getter method for dataplane_type, mapped from YANG variable /network_instances/network_instance/segment_routing/srgbs/srgb/config/dataplane_type (sr-dataplane-type)\n\n    YANG Description: The dataplane being used to instantiate the SRGB. When MPLS is specified\nthe set of MPLS label blocks that are defined in the mpls-label-blocks\nlist are used to make up the SRGB. When IPv6 is specified, the set of IPv6\nprefixes specified in the ipv6-prefixes list are used.", "id": "f22368:c1:m5"}
{"signature": "def _set_ipv6_prefixes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv6_prefixes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv6_prefixes, mapped from YANG variable /network_instances/network_instance/segment_routing/srgbs/srgb/config/ipv6_prefixes (inet:ipv6-prefix)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_ipv6_prefixes is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_ipv6_prefixes() directly.\n\n    YANG Description: A list of IPv6 prefixes which are to be used for segment routing using\nthe IPv6 dataplane.", "id": "f22368:c0:m12"}
{"signature": "def _set_ipv6_prefixes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv6_prefixes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv6_prefixes, mapped from YANG variable /network_instances/network_instance/segment_routing/srgbs/srgb/config/ipv6_prefixes (inet:ipv6-prefix)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_ipv6_prefixes is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_ipv6_prefixes() directly.\n\n    YANG Description: A list of IPv6 prefixes which are to be used for segment routing using\nthe IPv6 dataplane.", "id": "f22368:c1:m12"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/segment_routing/srgbs/srgb/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters relating to the SRGB.", "id": "f22369:c1:m9"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/segment_routing/srgbs/srgb/state (container)\n\nYANG Description: State parameters relating to the SRGB.", "id": "f22369:c1:m8"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/segment_routing/srgbs/srgb/state (container)\n\nYANG Description: State parameters relating to the SRGB.", "id": "f22369:c0:m8"}
{"signature": "def _get_srgb(self):", "body": "return self.__srgb<EOL>", "docstring": "Getter method for srgb, mapped from YANG variable /network_instances/network_instance/segment_routing/srgbs/srgb (list)\n\n    YANG Description: A single definition of an SRGB which may comprise of multiple\nsets of dataplane addresses (IPv6 addresses, or MPLS labels).", "id": "f22370:c0:m2"}
{"signature": "def _get_srgbs(self):", "body": "return self.__srgbs<EOL>", "docstring": "Getter method for srgbs, mapped from YANG variable /network_instances/network_instance/segment_routing/srgbs (container)\n\n    YANG Description: Configuration and operational state parameters relating to the\nSRGBs defined for the system.", "id": "f22371:c1:m2"}
{"signature": "def _get_srgbs(self):", "body": "return self.__srgbs<EOL>", "docstring": "Getter method for srgbs, mapped from YANG variable /network_instances/network_instance/segment_routing/srgbs (container)\n\n    YANG Description: Configuration and operational state parameters relating to the\nSRGBs defined for the system.", "id": "f22371:c0:m2"}
{"signature": "def _get_srlbs(self):", "body": "return self.__srlbs<EOL>", "docstring": "Getter method for srlbs, mapped from YANG variable /network_instances/network_instance/segment_routing/srlbs (container)\n\n    YANG Description: Configuration and operational state parameters relating to the\nSegment Routing Local Blocks (SRLBs) defined for the system.", "id": "f22371:c0:m5"}
{"signature": "def _set_srlbs(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=srlbs.srlbs,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__srlbs = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for srlbs, mapped from YANG variable /network_instances/network_instance/segment_routing/srlbs (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_srlbs is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_srlbs() directly.\n\n    YANG Description: Configuration and operational state parameters relating to the\nSegment Routing Local Blocks (SRLBs) defined for the system.", "id": "f22371:c1:m6"}
{"signature": "def _get_address_family(self):", "body": "return self.__address_family<EOL>", "docstring": "Getter method for address_family, mapped from YANG variable /network_instances/network_instance/tables/table/state/address_family (identityref)\n\nYANG Description: The address family (IPv4, IPv6) of the table's entries", "id": "f22372:c1:m5"}
{"signature": "def _get_protocol(self):", "body": "return self.__protocol<EOL>", "docstring": "Getter method for protocol, mapped from YANG variable /network_instances/network_instance/tables/table/state/protocol (leafref)\n\nYANG Description: Reference to the protocol that the table is associated with.", "id": "f22372:c1:m2"}
{"signature": "def _set_address_family(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__address_family = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for address_family, mapped from YANG variable /network_instances/network_instance/tables/table/state/address_family (identityref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_address_family is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_address_family() directly.\n\nYANG Description: The address family (IPv4, IPv6) of the table's entries", "id": "f22372:c1:m6"}
{"signature": "def _set_protocol(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__protocol = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for protocol, mapped from YANG variable /network_instances/network_instance/tables/table/config/protocol (leafref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_protocol is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_protocol() directly.\n\nYANG Description: Reference to the protocol that the table is associated with.", "id": "f22373:c0:m3"}
{"signature": "def _set_protocol(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__protocol = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for protocol, mapped from YANG variable /network_instances/network_instance/tables/table/config/protocol (leafref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_protocol is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_protocol() directly.\n\nYANG Description: Reference to the protocol that the table is associated with.", "id": "f22373:c1:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/tables/table/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters related to the table", "id": "f22374:c0:m12"}
{"signature": "def _get_address_family(self):", "body": "return self.__address_family<EOL>", "docstring": "Getter method for address_family, mapped from YANG variable /network_instances/network_instance/tables/table/address_family (leafref)\n\n    YANG Description: A reference to the address-family that the\ntable represents", "id": "f22374:c0:m5"}
{"signature": "def _get_protocol(self):", "body": "return self.__protocol<EOL>", "docstring": "Getter method for protocol, mapped from YANG variable /network_instances/network_instance/tables/table/protocol (leafref)\n\n    YANG Description: A reference to the protocol that populates\nthe table", "id": "f22374:c1:m2"}
{"signature": "def _set_protocol(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__protocol = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for protocol, mapped from YANG variable /network_instances/network_instance/tables/table/protocol (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_protocol is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_protocol() directly.\n\n    YANG Description: A reference to the protocol that populates\nthe table", "id": "f22374:c0:m3"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/tables/table/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to the\ntable", "id": "f22374:c1:m9"}
{"signature": "def _set_table(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>table.table,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__table = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for table, mapped from YANG variable /network_instances/network_instance/tables/table (list)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_table is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_table() directly.\n\n    YANG Description: A network instance manages one or more forwarding or\nrouting tables. These may reflect a Layer 2 forwarding\ninformation base, a Layer 3 routing table, or an MPLS\nLFIB.\n\nThe table populated by a protocol within an instance is\nidentified by the protocol identifier (e.g., BGP, IS-IS)\nand the address family (e.g., IPv4, IPv6) supported by\nthat protocol. Multiple instances of the same protocol\npopulate a single table -- such that\na single IS-IS or OSPF IPv4 table exists per network\ninstance.\n\nAn implementation is expected to create entries within\nthis list when the relevant protocol context is enabled.\ni.e., when a BGP instance is created with IPv4 and IPv6\naddress families enabled, the protocol=BGP,\naddress-family=IPv4 table is created by the system.", "id": "f22375:c0:m3"}
{"signature": "def _get_default_metric(self):", "body": "return self.__default_metric<EOL>", "docstring": "Getter method for default_metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/state/default_metric (uint32)\n\n    YANG Description: The default metric within the RIB for entries that are\ninstalled by this protocol instance. This value may\nbe overridden by protocol specific configuration options.\nThe lower the metric specified the more preferable the RIB\nentry is to be selected for use within the network instance.\nWhere multiple entries have the same metric value then these\nequal cost paths should be treated according to the specified\nECMP path selection behaviour for the instance", "id": "f22376:c1:m11"}
{"signature": "def _set_name(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:name>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/state/name (string)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_name is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_name() directly.\n\nYANG Description: A unique name for the protocol instance", "id": "f22376:c1:m6"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/state/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: A boolean value indicating whether the local protocol\ninstance is enabled.", "id": "f22376:c1:m9"}
{"signature": "def _get_default_metric(self):", "body": "return self.__default_metric<EOL>", "docstring": "Getter method for default_metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/state/default_metric (uint32)\n\n    YANG Description: The default metric within the RIB for entries that are\ninstalled by this protocol instance. This value may\nbe overridden by protocol specific configuration options.\nThe lower the metric specified the more preferable the RIB\nentry is to be selected for use within the network instance.\nWhere multiple entries have the same metric value then these\nequal cost paths should be treated according to the specified\nECMP path selection behaviour for the instance", "id": "f22376:c0:m11"}
{"signature": "def _set_default_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__default_metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for default_metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/state/default_metric (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_default_metric is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_default_metric() directly.\n\n    YANG Description: The default metric within the RIB for entries that are\ninstalled by this protocol instance. This value may\nbe overridden by protocol specific configuration options.\nThe lower the metric specified the more preferable the RIB\nentry is to be selected for use within the network instance.\nWhere multiple entries have the same metric value then these\nequal cost paths should be treated according to the specified\nECMP path selection behaviour for the instance", "id": "f22376:c1:m12"}
{"signature": "def _get_discard(self):", "body": "return self.__discard<EOL>", "docstring": "Getter method for discard, mapped from YANG variable /network_instances/network_instance/protocols/protocol/local_aggregates/aggregate/state/discard (boolean)\n\n    YANG Description: When true, install the aggregate route with a discard\nnext-hop -- traffic destined to the aggregate will be\ndiscarded with no ICMP message generated.  When false,\ntraffic destined to an aggregate address when no\nconstituent routes are present will generate an ICMP\nunreachable message.", "id": "f22377:c0:m5"}
{"signature": "def _get_set_tag(self):", "body": "return self.__set_tag<EOL>", "docstring": "Getter method for set_tag, mapped from YANG variable /network_instances/network_instance/protocols/protocol/local_aggregates/aggregate/state/set_tag (oc-pt:tag-type)\n\n    YANG Description: Set a generic tag value on the route. This tag can be\nused for filtering routes that are distributed to other\nrouting protocols.", "id": "f22377:c1:m8"}
{"signature": "def _set_discard(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__discard = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for discard, mapped from YANG variable /network_instances/network_instance/protocols/protocol/local_aggregates/aggregate/state/discard (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_discard is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_discard() directly.\n\n    YANG Description: When true, install the aggregate route with a discard\nnext-hop -- traffic destined to the aggregate will be\ndiscarded with no ICMP message generated.  When false,\ntraffic destined to an aggregate address when no\nconstituent routes are present will generate an ICMP\nunreachable message.", "id": "f22377:c0:m6"}
{"signature": "def _get_prefix(self):", "body": "return self.__prefix<EOL>", "docstring": "Getter method for prefix, mapped from YANG variable /network_instances/network_instance/protocols/protocol/local_aggregates/aggregate/state/prefix (inet:ip-prefix)\n\nYANG Description: Aggregate prefix to be advertised", "id": "f22377:c0:m2"}
{"signature": "def _get_discard(self):", "body": "return self.__discard<EOL>", "docstring": "Getter method for discard, mapped from YANG variable /network_instances/network_instance/protocols/protocol/local_aggregates/aggregate/state/discard (boolean)\n\n    YANG Description: When true, install the aggregate route with a discard\nnext-hop -- traffic destined to the aggregate will be\ndiscarded with no ICMP message generated.  When false,\ntraffic destined to an aggregate address when no\nconstituent routes are present will generate an ICMP\nunreachable message.", "id": "f22377:c1:m5"}
{"signature": "def _set_set_tag(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__set_tag = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for set_tag, mapped from YANG variable /network_instances/network_instance/protocols/protocol/local_aggregates/aggregate/state/set_tag (oc-pt:tag-type)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_set_tag is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_set_tag() directly.\n\n    YANG Description: Set a generic tag value on the route. This tag can be\nused for filtering routes that are distributed to other\nrouting protocols.", "id": "f22377:c1:m9"}
{"signature": "def _set_discard(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__discard = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for discard, mapped from YANG variable /network_instances/network_instance/protocols/protocol/local_aggregates/aggregate/state/discard (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_discard is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_discard() directly.\n\n    YANG Description: When true, install the aggregate route with a discard\nnext-hop -- traffic destined to the aggregate will be\ndiscarded with no ICMP message generated.  When false,\ntraffic destined to an aggregate address when no\nconstituent routes are present will generate an ICMP\nunreachable message.", "id": "f22377:c1:m6"}
{"signature": "def _get_set_tag(self):", "body": "return self.__set_tag<EOL>", "docstring": "Getter method for set_tag, mapped from YANG variable /network_instances/network_instance/protocols/protocol/local_aggregates/aggregate/config/set_tag (oc-pt:tag-type)\n\n    YANG Description: Set a generic tag value on the route. This tag can be\nused for filtering routes that are distributed to other\nrouting protocols.", "id": "f22378:c1:m8"}
{"signature": "def _get_set_tag(self):", "body": "return self.__set_tag<EOL>", "docstring": "Getter method for set_tag, mapped from YANG variable /network_instances/network_instance/protocols/protocol/local_aggregates/aggregate/config/set_tag (oc-pt:tag-type)\n\n    YANG Description: Set a generic tag value on the route. This tag can be\nused for filtering routes that are distributed to other\nrouting protocols.", "id": "f22378:c0:m8"}
{"signature": "def _set_discard(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__discard = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for discard, mapped from YANG variable /network_instances/network_instance/protocols/protocol/local_aggregates/aggregate/config/discard (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_discard is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_discard() directly.\n\n    YANG Description: When true, install the aggregate route with a discard\nnext-hop -- traffic destined to the aggregate will be\ndiscarded with no ICMP message generated.  When false,\ntraffic destined to an aggregate address when no\nconstituent routes are present will generate an ICMP\nunreachable message.", "id": "f22378:c0:m6"}
{"signature": "def _set_discard(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__discard = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for discard, mapped from YANG variable /network_instances/network_instance/protocols/protocol/local_aggregates/aggregate/config/discard (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_discard is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_discard() directly.\n\n    YANG Description: When true, install the aggregate route with a discard\nnext-hop -- traffic destined to the aggregate will be\ndiscarded with no ICMP message generated.  When false,\ntraffic destined to an aggregate address when no\nconstituent routes are present will generate an ICMP\nunreachable message.", "id": "f22378:c1:m6"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/local_aggregates/aggregate/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: Operational state data for aggregate\nadvertisements", "id": "f22379:c1:m9"}
{"signature": "def _get_prefix(self):", "body": "return self.__prefix<EOL>", "docstring": "Getter method for prefix, mapped from YANG variable /network_instances/network_instance/protocols/protocol/local_aggregates/aggregate/prefix (leafref)\n\nYANG Description: Reference to the configured prefix for this aggregate", "id": "f22379:c0:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/local_aggregates/aggregate/state (container)\n\n    YANG Description: Operational state data for aggregate\nadvertisements", "id": "f22379:c1:m8"}
{"signature": "def _get_set_tag(self):", "body": "return self.__set_tag<EOL>", "docstring": "Getter method for set_tag, mapped from YANG variable /network_instances/network_instance/protocols/protocol/static_routes/static/state/set_tag (oc-pt:tag-type)\n\n    YANG Description: Set a generic tag value on the route. This tag can be\nused for filtering routes that are distributed to other\nrouting protocols.", "id": "f22381:c0:m5"}
{"signature": "def _set_set_tag(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__set_tag = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for set_tag, mapped from YANG variable /network_instances/network_instance/protocols/protocol/static_routes/static/config/set_tag (oc-pt:tag-type)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_set_tag is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_set_tag() directly.\n\n    YANG Description: Set a generic tag value on the route. This tag can be\nused for filtering routes that are distributed to other\nrouting protocols.", "id": "f22382:c0:m6"}
{"signature": "def _get_prefix(self):", "body": "return self.__prefix<EOL>", "docstring": "Getter method for prefix, mapped from YANG variable /network_instances/network_instance/protocols/protocol/static_routes/static/config/prefix (inet:ip-prefix)\n\n    YANG Description: Destination prefix for the static route, either IPv4 or\nIPv6.", "id": "f22382:c1:m2"}
{"signature": "def _set_prefix(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prefix = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prefix, mapped from YANG variable /network_instances/network_instance/protocols/protocol/static_routes/static/config/prefix (inet:ip-prefix)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prefix is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prefix() directly.\n\n    YANG Description: Destination prefix for the static route, either IPv4 or\nIPv6.", "id": "f22382:c1:m3"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/static_routes/static/config (container)\n\nYANG Description: Configuration data for static routes", "id": "f22383:c1:m5"}
{"signature": "def _get_next_hops(self):", "body": "return self.__next_hops<EOL>", "docstring": "Getter method for next_hops, mapped from YANG variable /network_instances/network_instance/protocols/protocol/static_routes/static/next_hops (container)\n\n    YANG Description: Configuration and state parameters relating to the\nnext-hops that are to be utilised for the static\nroute being specified", "id": "f22383:c0:m11"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/static_routes/static/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Operational state data for static routes", "id": "f22383:c1:m9"}
{"signature": "def _get_prefix(self):", "body": "return self.__prefix<EOL>", "docstring": "Getter method for prefix, mapped from YANG variable /network_instances/network_instance/protocols/protocol/static_routes/static/prefix (leafref)\n\nYANG Description: Reference to the destination prefix list key.", "id": "f22383:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/static_routes/static/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Operational state data for static routes", "id": "f22383:c0:m9"}
{"signature": "def _set_next_hop(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT:index>\",<EOL>next_hop.next_hop,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT:index>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__next_hop = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for next_hop, mapped from YANG variable /network_instances/network_instance/protocols/protocol/static_routes/static/next_hops/next_hop (list)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_next_hop is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_next_hop() directly.\n\n    YANG Description: A list of next-hops to be utilised for the static\nroute being specified.", "id": "f22384:c1:m3"}
{"signature": "def _get_metric(self):", "body": "return self.__metric<EOL>", "docstring": "Getter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/static_routes/static/next_hops/next_hop/state/metric (uint32)\n\n    YANG Description: A metric which is utilised to specify the preference of\nthe next-hop entry when it is injected into the RIB. The\nlower the metric, the more preferable the prefix is. When\nthis value is not specified the metric is inherited from\nthe default metric utilised for static routes within the\nnetwork instance that the static routes are being\ninstantiated. When multiple next-hops are specified for a\nstatic route, the metric is utilised to determine which of\nthe next-hops is to be installed in the RIB. When multiple\nnext-hops have the same metric (be it specified, or simply\nthe default) then these next-hops should all be installed\nin the RIB", "id": "f22385:c1:m8"}
{"signature": "def _set_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/static_routes/static/next_hops/next_hop/state/metric (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_metric is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_metric() directly.\n\n    YANG Description: A metric which is utilised to specify the preference of\nthe next-hop entry when it is injected into the RIB. The\nlower the metric, the more preferable the prefix is. When\nthis value is not specified the metric is inherited from\nthe default metric utilised for static routes within the\nnetwork instance that the static routes are being\ninstantiated. When multiple next-hops are specified for a\nstatic route, the metric is utilised to determine which of\nthe next-hops is to be installed in the RIB. When multiple\nnext-hops have the same metric (be it specified, or simply\nthe default) then these next-hops should all be installed\nin the RIB", "id": "f22385:c0:m9"}
{"signature": "def _get_index(self):", "body": "return self.__index<EOL>", "docstring": "Getter method for index, mapped from YANG variable /network_instances/network_instance/protocols/protocol/static_routes/static/next_hops/next_hop/state/index (string)\n\n    YANG Description: An user-specified identifier utilised to uniquely reference\nthe next-hop entry in the next-hop list. The value of this\nindex has no semantic meaning other than for referencing\nthe entry.", "id": "f22385:c0:m2"}
{"signature": "def _get_index(self):", "body": "return self.__index<EOL>", "docstring": "Getter method for index, mapped from YANG variable /network_instances/network_instance/protocols/protocol/static_routes/static/next_hops/next_hop/state/index (string)\n\n    YANG Description: An user-specified identifier utilised to uniquely reference\nthe next-hop entry in the next-hop list. The value of this\nindex has no semantic meaning other than for referencing\nthe entry.", "id": "f22385:c1:m2"}
{"signature": "def _get_metric(self):", "body": "return self.__metric<EOL>", "docstring": "Getter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/static_routes/static/next_hops/next_hop/state/metric (uint32)\n\n    YANG Description: A metric which is utilised to specify the preference of\nthe next-hop entry when it is injected into the RIB. The\nlower the metric, the more preferable the prefix is. When\nthis value is not specified the metric is inherited from\nthe default metric utilised for static routes within the\nnetwork instance that the static routes are being\ninstantiated. When multiple next-hops are specified for a\nstatic route, the metric is utilised to determine which of\nthe next-hops is to be installed in the RIB. When multiple\nnext-hops have the same metric (be it specified, or simply\nthe default) then these next-hops should all be installed\nin the RIB", "id": "f22385:c0:m8"}
{"signature": "def _get_metric(self):", "body": "return self.__metric<EOL>", "docstring": "Getter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/static_routes/static/next_hops/next_hop/config/metric (uint32)\n\n    YANG Description: A metric which is utilised to specify the preference of\nthe next-hop entry when it is injected into the RIB. The\nlower the metric, the more preferable the prefix is. When\nthis value is not specified the metric is inherited from\nthe default metric utilised for static routes within the\nnetwork instance that the static routes are being\ninstantiated. When multiple next-hops are specified for a\nstatic route, the metric is utilised to determine which of\nthe next-hops is to be installed in the RIB. When multiple\nnext-hops have the same metric (be it specified, or simply\nthe default) then these next-hops should all be installed\nin the RIB", "id": "f22386:c1:m8"}
{"signature": "def _get_metric(self):", "body": "return self.__metric<EOL>", "docstring": "Getter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/static_routes/static/next_hops/next_hop/config/metric (uint32)\n\n    YANG Description: A metric which is utilised to specify the preference of\nthe next-hop entry when it is injected into the RIB. The\nlower the metric, the more preferable the prefix is. When\nthis value is not specified the metric is inherited from\nthe default metric utilised for static routes within the\nnetwork instance that the static routes are being\ninstantiated. When multiple next-hops are specified for a\nstatic route, the metric is utilised to determine which of\nthe next-hops is to be installed in the RIB. When multiple\nnext-hops have the same metric (be it specified, or simply\nthe default) then these next-hops should all be installed\nin the RIB", "id": "f22386:c0:m8"}
{"signature": "def _set_index(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:index>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__index = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for index, mapped from YANG variable /network_instances/network_instance/protocols/protocol/static_routes/static/next_hops/next_hop/config/index (string)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_index is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_index() directly.\n\n    YANG Description: An user-specified identifier utilised to uniquely reference\nthe next-hop entry in the next-hop list. The value of this\nindex has no semantic meaning other than for referencing\nthe entry.", "id": "f22386:c0:m3"}
{"signature": "def _set_index(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:index>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__index = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for index, mapped from YANG variable /network_instances/network_instance/protocols/protocol/static_routes/static/next_hops/next_hop/config/index (string)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_index is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_index() directly.\n\n    YANG Description: An user-specified identifier utilised to uniquely reference\nthe next-hop entry in the next-hop list. The value of this\nindex has no semantic meaning other than for referencing\nthe entry.", "id": "f22386:c1:m3"}
{"signature": "def _set_subinterface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subinterface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subinterface, mapped from YANG variable /network_instances/network_instance/protocols/protocol/static_routes/static/next_hops/next_hop/interface_ref/state/subinterface (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subinterface is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subinterface() directly.\n\n    YANG Description: Reference to a subinterface -- this requires the base\ninterface to be specified using the interface leaf in\nthis container.  If only a reference to a base interface\nis requuired, this leaf should not be set.", "id": "f22387:c1:m6"}
{"signature": "def _get_subinterface(self):", "body": "return self.__subinterface<EOL>", "docstring": "Getter method for subinterface, mapped from YANG variable /network_instances/network_instance/protocols/protocol/static_routes/static/next_hops/next_hop/interface_ref/state/subinterface (leafref)\n\n    YANG Description: Reference to a subinterface -- this requires the base\ninterface to be specified using the interface leaf in\nthis container.  If only a reference to a base interface\nis requuired, this leaf should not be set.", "id": "f22387:c1:m5"}
{"signature": "def _set_interface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface, mapped from YANG variable /network_instances/network_instance/protocols/protocol/static_routes/static/next_hops/next_hop/interface_ref/state/interface (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_interface is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_interface() directly.\n\n    YANG Description: Reference to a base interface.  If a reference to a\nsubinterface is required, this leaf must be specified\nto indicate the base interface.", "id": "f22387:c1:m3"}
{"signature": "def _set_subinterface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subinterface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subinterface, mapped from YANG variable /network_instances/network_instance/protocols/protocol/static_routes/static/next_hops/next_hop/interface_ref/config/subinterface (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subinterface is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subinterface() directly.\n\n    YANG Description: Reference to a subinterface -- this requires the base\ninterface to be specified using the interface leaf in\nthis container.  If only a reference to a base interface\nis requuired, this leaf should not be set.", "id": "f22388:c0:m6"}
{"signature": "def _set_interface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface, mapped from YANG variable /network_instances/network_instance/protocols/protocol/static_routes/static/next_hops/next_hop/interface_ref/config/interface (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_interface is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_interface() directly.\n\n    YANG Description: Reference to a base interface.  If a reference to a\nsubinterface is required, this leaf must be specified\nto indicate the base interface.", "id": "f22388:c0:m3"}
{"signature": "def _get_interface(self):", "body": "return self.__interface<EOL>", "docstring": "Getter method for interface, mapped from YANG variable /network_instances/network_instance/protocols/protocol/static_routes/static/next_hops/next_hop/interface_ref/config/interface (leafref)\n\n    YANG Description: Reference to a base interface.  If a reference to a\nsubinterface is required, this leaf must be specified\nto indicate the base interface.", "id": "f22388:c1:m2"}
{"signature": "def _get_subinterface(self):", "body": "return self.__subinterface<EOL>", "docstring": "Getter method for subinterface, mapped from YANG variable /network_instances/network_instance/protocols/protocol/static_routes/static/next_hops/next_hop/interface_ref/config/subinterface (leafref)\n\n    YANG Description: Reference to a subinterface -- this requires the base\ninterface to be specified using the interface leaf in\nthis container.  If only a reference to a base interface\nis requuired, this leaf should not be set.", "id": "f22388:c1:m5"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/static_routes/static/next_hops/next_hop/interface_ref/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configured reference to interface / subinterface", "id": "f22389:c0:m3"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/static_routes/static/next_hops/next_hop/interface_ref/config (container)\n\nYANG Description: Configured reference to interface / subinterface", "id": "f22389:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/static_routes/static/next_hops/next_hop/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: Operational state parameters relating to the\nnext-hop entry", "id": "f22390:c1:m9"}
{"signature": "def _get_interface_ref(self):", "body": "return self.__interface_ref<EOL>", "docstring": "Getter method for interface_ref, mapped from YANG variable /network_instances/network_instance/protocols/protocol/static_routes/static/next_hops/next_hop/interface_ref (container)\n\nYANG Description: Reference to an interface or subinterface", "id": "f22390:c1:m11"}
{"signature": "def _set_index(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:index>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__index = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for index, mapped from YANG variable /network_instances/network_instance/protocols/protocol/static_routes/static/next_hops/next_hop/index (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_index is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_index() directly.\n\n    YANG Description: A reference to the index of the current next-hop.\nThe index is intended to be a user-specified value\nwhich can be used to reference the next-hop in\nquestion, without any other semantics being\nassigned to it.", "id": "f22390:c1:m3"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/static_routes/static/next_hops/next_hop/config (container)\n\n    YANG Description: Configuration parameters relating to the next-hop\nentry", "id": "f22390:c1:m5"}
{"signature": "def _get_index(self):", "body": "return self.__index<EOL>", "docstring": "Getter method for index, mapped from YANG variable /network_instances/network_instance/protocols/protocol/static_routes/static/next_hops/next_hop/index (leafref)\n\n    YANG Description: A reference to the index of the current next-hop.\nThe index is intended to be a user-specified value\nwhich can be used to reference the next-hop in\nquestion, without any other semantics being\nassigned to it.", "id": "f22390:c0:m2"}
{"signature": "def _get_index(self):", "body": "return self.__index<EOL>", "docstring": "Getter method for index, mapped from YANG variable /network_instances/network_instance/protocols/protocol/static_routes/static/next_hops/next_hop/index (leafref)\n\n    YANG Description: A reference to the index of the current next-hop.\nThe index is intended to be a user-specified value\nwhich can be used to reference the next-hop in\nquestion, without any other semantics being\nassigned to it.", "id": "f22390:c1:m2"}
{"signature": "def _get_interface_ref(self):", "body": "return self.__interface_ref<EOL>", "docstring": "Getter method for interface_ref, mapped from YANG variable /network_instances/network_instance/protocols/protocol/static_routes/static/next_hops/next_hop/interface_ref (container)\n\nYANG Description: Reference to an interface or subinterface", "id": "f22390:c0:m11"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/static_routes/static/next_hops/next_hop/state (container)\n\n    YANG Description: Operational state parameters relating to the\nnext-hop entry", "id": "f22390:c1:m8"}
{"signature": "def _get_static(self):", "body": "return self.__static<EOL>", "docstring": "Getter method for static, mapped from YANG variable /network_instances/network_instance/protocols/protocol/static_routes/static (list)\n\nYANG Description: List of locally configured static routes", "id": "f22391:c1:m2"}
{"signature": "def _set_default_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__default_metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for default_metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/config/default_metric (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_default_metric is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_default_metric() directly.\n\n    YANG Description: The default metric within the RIB for entries that are\ninstalled by this protocol instance. This value may\nbe overridden by protocol specific configuration options.\nThe lower the metric specified the more preferable the RIB\nentry is to be selected for use within the network instance.\nWhere multiple entries have the same metric value then these\nequal cost paths should be treated according to the specified\nECMP path selection behaviour for the instance", "id": "f22392:c1:m12"}
{"signature": "def _get_default_metric(self):", "body": "return self.__default_metric<EOL>", "docstring": "Getter method for default_metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/config/default_metric (uint32)\n\n    YANG Description: The default metric within the RIB for entries that are\ninstalled by this protocol instance. This value may\nbe overridden by protocol specific configuration options.\nThe lower the metric specified the more preferable the RIB\nentry is to be selected for use within the network instance.\nWhere multiple entries have the same metric value then these\nequal cost paths should be treated according to the specified\nECMP path selection behaviour for the instance", "id": "f22392:c0:m11"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/config/enabled (boolean)\n\n    YANG Description: A boolean value indicating whether the local protocol\ninstance is enabled.", "id": "f22392:c1:m8"}
{"signature": "def _set_identifier(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__identifier = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for identifier, mapped from YANG variable /network_instances/network_instance/protocols/protocol/config/identifier (identityref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_identifier is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_identifier() directly.\n\nYANG Description: The protocol identifier for the instance", "id": "f22392:c1:m3"}
{"signature": "def _get_identifier(self):", "body": "return self.__identifier<EOL>", "docstring": "Getter method for identifier, mapped from YANG variable /network_instances/network_instance/protocols/protocol/config/identifier (identityref)\n\nYANG Description: The protocol identifier for the instance", "id": "f22392:c1:m2"}
{"signature": "def _set_identifier(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__identifier = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for identifier, mapped from YANG variable /network_instances/network_instance/protocols/protocol/config/identifier (identityref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_identifier is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_identifier() directly.\n\nYANG Description: The protocol identifier for the instance", "id": "f22392:c0:m3"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/state/enabled (boolean)\n\n    YANG Description: When set to true, the functionality within which this leaf is\ndefined is enabled, when set to false it is explicitly disabled.", "id": "f22393:c1:m2"}
{"signature": "def _get_interface_id(self):", "body": "return self.__interface_id<EOL>", "docstring": "Getter method for interface_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/state/interface_id (oc-if:interface-id)\n\nYANG Description: Interface for which ISIS configuration is to be applied.", "id": "f22393:c1:m5"}
{"signature": "def _set_circuit_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__circuit_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for circuit_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/state/circuit_type (oc-isis-types:circuit-type)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_circuit_type is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_circuit_type() directly.\n\nYANG Description: ISIS circuit type (p2p, broadcast).", "id": "f22393:c0:m15"}
{"signature": "def _set_hello_padding(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {}, \"<STR_LIT>\": {}, \"<STR_LIT>\": {}, \"<STR_LIT>\": {}<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__hello_padding = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for hello_padding, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/state/hello_padding (oc-isis-types:hello-padding-type)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_hello_padding is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_hello_padding() directly.\n\nYANG Description: This leaf controls padding type for IS-IS Hello PDUs.", "id": "f22393:c0:m12"}
{"signature": "def _set_hello_padding(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {}, \"<STR_LIT>\": {}, \"<STR_LIT>\": {}, \"<STR_LIT>\": {}<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__hello_padding = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for hello_padding, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/state/hello_padding (oc-isis-types:hello-padding-type)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_hello_padding is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_hello_padding() directly.\n\nYANG Description: This leaf controls padding type for IS-IS Hello PDUs.", "id": "f22393:c1:m12"}
{"signature": "def _set_passive(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__passive = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for passive, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/state/passive (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_passive is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_passive() directly.\n\n    YANG Description: When set to true, the referenced interface is a passive interface\nsuch that it is not eligible to establish adjacencies with other\nsystems, but is advertised into the IS-IS topology.", "id": "f22393:c0:m9"}
{"signature": "def _set_lsp_pacing_interval(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__lsp_pacing_interval = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for lsp_pacing_interval, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/timers/state/lsp_pacing_interval (uint64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_lsp_pacing_interval is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_lsp_pacing_interval() directly.\n\n    YANG Description: The interval interval in milliseconds between the\ndetection of topology change and when the SPF algorithm runs.", "id": "f22394:c0:m6"}
{"signature": "def _set_lsp_pacing_interval(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__lsp_pacing_interval = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for lsp_pacing_interval, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/timers/state/lsp_pacing_interval (uint64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_lsp_pacing_interval is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_lsp_pacing_interval() directly.\n\n    YANG Description: The interval interval in milliseconds between the\ndetection of topology change and when the SPF algorithm runs.", "id": "f22394:c1:m6"}
{"signature": "def _get_lsp_pacing_interval(self):", "body": "return self.__lsp_pacing_interval<EOL>", "docstring": "Getter method for lsp_pacing_interval, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/timers/state/lsp_pacing_interval (uint64)\n\n    YANG Description: The interval interval in milliseconds between the\ndetection of topology change and when the SPF algorithm runs.", "id": "f22394:c0:m5"}
{"signature": "def _get_lsp_pacing_interval(self):", "body": "return self.__lsp_pacing_interval<EOL>", "docstring": "Getter method for lsp_pacing_interval, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/timers/state/lsp_pacing_interval (uint64)\n\n    YANG Description: The interval interval in milliseconds between the\ndetection of topology change and when the SPF algorithm runs.", "id": "f22394:c1:m5"}
{"signature": "def _get_lsp_pacing_interval(self):", "body": "return self.__lsp_pacing_interval<EOL>", "docstring": "Getter method for lsp_pacing_interval, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/timers/config/lsp_pacing_interval (uint64)\n\n    YANG Description: The interval interval in milliseconds between the\ndetection of topology change and when the SPF algorithm runs.", "id": "f22395:c1:m5"}
{"signature": "def _set_lsp_pacing_interval(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__lsp_pacing_interval = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for lsp_pacing_interval, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/timers/config/lsp_pacing_interval (uint64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_lsp_pacing_interval is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_lsp_pacing_interval() directly.\n\n    YANG Description: The interval interval in milliseconds between the\ndetection of topology change and when the SPF algorithm runs.", "id": "f22395:c0:m6"}
{"signature": "def _set_lsp_pacing_interval(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__lsp_pacing_interval = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for lsp_pacing_interval, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/timers/config/lsp_pacing_interval (uint64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_lsp_pacing_interval is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_lsp_pacing_interval() directly.\n\n    YANG Description: The interval interval in milliseconds between the\ndetection of topology change and when the SPF algorithm runs.", "id": "f22395:c1:m6"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/timers/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to interface\ntimers for IS-IS", "id": "f22396:c0:m3"}
{"signature": "def _set_interface_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/config/interface_id (oc-if:interface-id)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_interface_id is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_interface_id() directly.\n\nYANG Description: Interface for which ISIS configuration is to be applied.", "id": "f22397:c0:m6"}
{"signature": "def _set_circuit_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__circuit_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for circuit_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/config/circuit_type (oc-isis-types:circuit-type)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_circuit_type is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_circuit_type() directly.\n\nYANG Description: ISIS circuit type (p2p, broadcast).", "id": "f22397:c0:m15"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/config/enabled (boolean)\n\n    YANG Description: When set to true, the functionality within which this leaf is\ndefined is enabled, when set to false it is explicitly disabled.", "id": "f22397:c0:m2"}
{"signature": "def _get_circuit_type(self):", "body": "return self.__circuit_type<EOL>", "docstring": "Getter method for circuit_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/config/circuit_type (oc-isis-types:circuit-type)\n\nYANG Description: ISIS circuit type (p2p, broadcast).", "id": "f22397:c1:m14"}
{"signature": "def _set_passive(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__passive = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for passive, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/config/passive (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_passive is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_passive() directly.\n\n    YANG Description: When set to true, the referenced interface is a passive interface\nsuch that it is not eligible to establish adjacencies with other\nsystems, but is advertised into the IS-IS topology.", "id": "f22397:c1:m9"}
{"signature": "def _set_subinterface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subinterface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subinterface, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/interface_ref/state/subinterface (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subinterface is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subinterface() directly.\n\n    YANG Description: Reference to a subinterface -- this requires the base\ninterface to be specified using the interface leaf in\nthis container.  If only a reference to a base interface\nis requuired, this leaf should not be set.", "id": "f22398:c0:m6"}
{"signature": "def _set_interface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/interface_ref/state/interface (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_interface is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_interface() directly.\n\n    YANG Description: Reference to a base interface.  If a reference to a\nsubinterface is required, this leaf must be specified\nto indicate the base interface.", "id": "f22398:c0:m3"}
{"signature": "def _get_interface(self):", "body": "return self.__interface<EOL>", "docstring": "Getter method for interface, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/interface_ref/config/interface (leafref)\n\n    YANG Description: Reference to a base interface.  If a reference to a\nsubinterface is required, this leaf must be specified\nto indicate the base interface.", "id": "f22399:c0:m2"}
{"signature": "def _get_subinterface(self):", "body": "return self.__subinterface<EOL>", "docstring": "Getter method for subinterface, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/interface_ref/config/subinterface (leafref)\n\n    YANG Description: Reference to a subinterface -- this requires the base\ninterface to be specified using the interface leaf in\nthis container.  If only a reference to a base interface\nis requuired, this leaf should not be set.", "id": "f22399:c0:m5"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/interface_ref/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configured reference to interface / subinterface", "id": "f22400:c0:m3"}
{"signature": "def _set_timers(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=timers.timers,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__timers = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for timers, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/timers (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_timers is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_timers() directly.\n\nYANG Description: This container describes ISIS interface timers configuration", "id": "f22401:c0:m24"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: This container defines ISIS interface configuration.", "id": "f22401:c0:m6"}
{"signature": "def _set_interface_ref(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=interface_ref.interface_ref,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface_ref = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface_ref, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/interface_ref (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_interface_ref is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_interface_ref() directly.\n\nYANG Description: Reference to an interface or subinterface", "id": "f22401:c0:m30"}
{"signature": "def _set_circuit_counters(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=circuit_counters.circuit_counters,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__circuit_counters = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for circuit_counters, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/circuit_counters (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_circuit_counters is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_circuit_counters() directly.\n\nYANG Description: This container defines state information for ISIS circuit counters.", "id": "f22401:c0:m12"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/config (container)\n\nYANG Description: This container defines ISIS interface configuration.", "id": "f22401:c1:m5"}
{"signature": "def _set_authentication(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=authentication.authentication,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__authentication = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for authentication, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/authentication (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_authentication is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_authentication() directly.\n\nYANG Description: This container defines ISIS authentication.", "id": "f22401:c0:m15"}
{"signature": "def _set_timers(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=timers.timers,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__timers = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for timers, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/timers (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_timers is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_timers() directly.\n\nYANG Description: This container describes ISIS interface timers configuration", "id": "f22401:c1:m24"}
{"signature": "def _set_levels(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=levels.levels,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__levels = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for levels, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_levels is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_levels() directly.\n\n    YANG Description: This container defines ISIS level specific configuration and\nstate information.", "id": "f22401:c0:m21"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: This container defines state information for ISIS interfaces.", "id": "f22401:c0:m9"}
{"signature": "def _set_authentication(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=authentication.authentication,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__authentication = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for authentication, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/authentication (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_authentication is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_authentication() directly.\n\nYANG Description: This container defines ISIS authentication.", "id": "f22401:c1:m15"}
{"signature": "def _get_bfd_tlv(self):", "body": "return self.__bfd_tlv<EOL>", "docstring": "Getter method for bfd_tlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/bfd/state/bfd_tlv (boolean)\n\n    YANG Description: When set to true, BFD TLV is used. This enables support for the IS-IS\nBFD TLV options, which specify that a BFD session must be established\nbefore an IS-IS adjacency can transition to the established state.\nThis option should be enabled on all IS-IS neighbors on a shared\ninterface.", "id": "f22402:c0:m2"}
{"signature": "def _get_bfd_tlv(self):", "body": "return self.__bfd_tlv<EOL>", "docstring": "Getter method for bfd_tlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/bfd/state/bfd_tlv (boolean)\n\n    YANG Description: When set to true, BFD TLV is used. This enables support for the IS-IS\nBFD TLV options, which specify that a BFD session must be established\nbefore an IS-IS adjacency can transition to the established state.\nThis option should be enabled on all IS-IS neighbors on a shared\ninterface.", "id": "f22402:c1:m2"}
{"signature": "def _set_bfd_tlv(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__bfd_tlv = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for bfd_tlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/bfd/config/bfd_tlv (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_bfd_tlv is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_bfd_tlv() directly.\n\n    YANG Description: When set to true, BFD TLV is used. This enables support for the IS-IS\nBFD TLV options, which specify that a BFD session must be established\nbefore an IS-IS adjacency can transition to the established state.\nThis option should be enabled on all IS-IS neighbors on a shared\ninterface.", "id": "f22403:c1:m3"}
{"signature": "def _set_bfd_tlv(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__bfd_tlv = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for bfd_tlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/bfd/config/bfd_tlv (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_bfd_tlv is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_bfd_tlv() directly.\n\n    YANG Description: When set to true, BFD TLV is used. This enables support for the IS-IS\nBFD TLV options, which specify that a BFD session must be established\nbefore an IS-IS adjacency can transition to the established state.\nThis option should be enabled on all IS-IS neighbors on a shared\ninterface.", "id": "f22403:c0:m3"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/bfd/config (container)\n\nYANG Description: This container defines BFD configuration parameters.", "id": "f22404:c0:m2"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/bfd/config (container)\n\nYANG Description: This container defines BFD configuration parameters.", "id": "f22404:c1:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/bfd/state (container)\n\nYANG Description: This container defines BFD state information.", "id": "f22404:c0:m5"}
{"signature": "def _get_init_fails(self):", "body": "return self.__init_fails<EOL>", "docstring": "Getter method for init_fails, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/circuit_counters/state/init_fails (yang:counter32)\n\n    YANG Description: Number of times initialization of this circuit has failed. This counts\nevents such as PPP NCP failures. MIB Entry: CircInitFails.", "id": "f22405:c1:m5"}
{"signature": "def _get_max_area_address_mismatches(self):", "body": "return self.__max_area_address_mismatches<EOL>", "docstring": "Getter method for max_area_address_mismatches, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/circuit_counters/state/max_area_address_mismatches (yang:counter32)\n\n    YANG Description: Number of times an IS-IS control PDU with a max area address field\ndifferent from that for this system has been received. MIB Entry:\nCircMaxAreaAddrMismatches.", "id": "f22405:c0:m14"}
{"signature": "def _set_auth_type_fails(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__auth_type_fails = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for auth_type_fails, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/circuit_counters/state/auth_type_fails (yang:counter32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_auth_type_fails is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_auth_type_fails() directly.\n\n    YANG Description: Number of times an IS-IS control PDU with an auth type field different\nfrom that for this system has been received. MIB Entry:\nCircAuthTypeFails.", "id": "f22405:c0:m18"}
{"signature": "def _get_max_area_address_mismatches(self):", "body": "return self.__max_area_address_mismatches<EOL>", "docstring": "Getter method for max_area_address_mismatches, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/circuit_counters/state/max_area_address_mismatches (yang:counter32)\n\n    YANG Description: Number of times an IS-IS control PDU with a max area address field\ndifferent from that for this system has been received. MIB Entry:\nCircMaxAreaAddrMismatches.", "id": "f22405:c1:m14"}
{"signature": "def _set_rejected_adj(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__rejected_adj = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for rejected_adj, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/circuit_counters/state/rejected_adj (yang:counter32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_rejected_adj is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_rejected_adj() directly.\n\n    YANG Description: Number of times an adjacency has been rejected on this circuit. MIB\nEntry: CircRejAdjs.", "id": "f22405:c1:m9"}
{"signature": "def _get_rejected_adj(self):", "body": "return self.__rejected_adj<EOL>", "docstring": "Getter method for rejected_adj, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/circuit_counters/state/rejected_adj (yang:counter32)\n\n    YANG Description: Number of times an adjacency has been rejected on this circuit. MIB\nEntry: CircRejAdjs.", "id": "f22405:c0:m8"}
{"signature": "def _set_adj_changes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__adj_changes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for adj_changes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/circuit_counters/state/adj_changes (yang:counter32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_adj_changes is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_adj_changes() directly.\n\n    YANG Description: Number of times an adjacency state change has occurred on this circuit.\nMIB Entry: CircAdjChanges.", "id": "f22405:c0:m3"}
{"signature": "def _set_init_fails(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__init_fails = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for init_fails, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/circuit_counters/state/init_fails (yang:counter32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_init_fails is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_init_fails() directly.\n\n    YANG Description: Number of times initialization of this circuit has failed. This counts\nevents such as PPP NCP failures. MIB Entry: CircInitFails.", "id": "f22405:c1:m6"}
{"signature": "def _set_adj_number(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__adj_number = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for adj_number, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/circuit_counters/state/adj_number (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_adj_number is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_adj_number() directly.\n\n    YANG Description: Number of adjacencies on this circuit.\nMIB Entry: CircNumAdj.", "id": "f22405:c0:m27"}
{"signature": "def _set_auth_fails(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__auth_fails = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for auth_fails, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/circuit_counters/state/auth_fails (yang:counter32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_auth_fails is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_auth_fails() directly.\n\n    YANG Description: Number of times an IS-IS control PDU with the correct auth type has\nfailed to pass authentication validation. MIB Entry: CircAuthFails.", "id": "f22405:c1:m21"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/circuit_counters/state (container)\n\nYANG Description: The container defines a list of counters for IS circuit.", "id": "f22406:c1:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/circuit_counters/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: The container defines a list of counters for IS circuit.", "id": "f22406:c0:m3"}
{"signature": "def _set_level_number(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__level_number = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for level_number, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/state/level_number (oc-isis-types:level-number)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_level_number is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_level_number() directly.\n\nYANG Description: ISIS level number(level-1, level-2).", "id": "f22408:c0:m3"}
{"signature": "def _set_priority(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__priority = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for priority, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/state/priority (uint8)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_priority is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_priority() directly.\n\nYANG Description: ISIS neighbor priority(LAN hello PDU only).", "id": "f22408:c0:m9"}
{"signature": "def _get_passive(self):", "body": "return self.__passive<EOL>", "docstring": "Getter method for passive, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/state/passive (boolean)\n\nYANG Description: ISIS passive interface admin enable/disable function.", "id": "f22408:c1:m5"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/state/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: When set to true, the functionality within which this leaf is\ndefined is enabled, when set to false it is explicitly disabled.", "id": "f22408:c1:m12"}
{"signature": "def _get_passive(self):", "body": "return self.__passive<EOL>", "docstring": "Getter method for passive, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/state/passive (boolean)\n\nYANG Description: ISIS passive interface admin enable/disable function.", "id": "f22408:c0:m5"}
{"signature": "def _get_priority(self):", "body": "return self.__priority<EOL>", "docstring": "Getter method for priority, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/state/priority (uint8)\n\nYANG Description: ISIS neighbor priority(LAN hello PDU only).", "id": "f22408:c0:m8"}
{"signature": "def _set_passive(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__passive = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for passive, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/state/passive (boolean)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_passive is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_passive() directly.\n\nYANG Description: ISIS passive interface admin enable/disable function.", "id": "f22408:c0:m6"}
{"signature": "def _get_hello_authentication(self):", "body": "return self.__hello_authentication<EOL>", "docstring": "Getter method for hello_authentication, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/hello_authentication/state/hello_authentication (boolean)\n\nYANG Description: Enabled or disable ISIS Hello authentication.", "id": "f22409:c1:m2"}
{"signature": "def _set_auth_password(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__auth_password = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for auth_password, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/hello_authentication/key/state/auth_password (oc-types:routing-password)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_auth_password is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_auth_password() directly.\n\nYANG Description: Authentication key string.", "id": "f22410:c1:m3"}
{"signature": "def _get_auth_password(self):", "body": "return self.__auth_password<EOL>", "docstring": "Getter method for auth_password, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/hello_authentication/key/state/auth_password (oc-types:routing-password)\n\nYANG Description: Authentication key string.", "id": "f22410:c1:m2"}
{"signature": "def _get_auth_password(self):", "body": "return self.__auth_password<EOL>", "docstring": "Getter method for auth_password, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/hello_authentication/key/state/auth_password (oc-types:routing-password)\n\nYANG Description: Authentication key string.", "id": "f22410:c0:m2"}
{"signature": "def _set_auth_password(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__auth_password = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for auth_password, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/hello_authentication/key/config/auth_password (oc-types:routing-password)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_auth_password is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_auth_password() directly.\n\nYANG Description: Authentication key string.", "id": "f22411:c1:m3"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/hello_authentication/key/config (container)\n\nYANG Description: This container defines ISIS authentication key configuration.", "id": "f22412:c1:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/hello_authentication/state (container)\n\nYANG Description: This container defines ISIS authentication state.", "id": "f22414:c1:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/hello_authentication/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: This container defines ISIS authentication state.", "id": "f22414:c0:m6"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/hello_authentication/config (container)\n\nYANG Description: This container defines ISIS authentication configuration.", "id": "f22414:c1:m2"}
{"signature": "def _set_hello_interval(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__hello_interval = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for hello_interval, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/timers/state/hello_interval (uint32)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_hello_interval is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_hello_interval() directly.\n\nYANG Description: ISIS hello-interval value.", "id": "f22415:c1:m3"}
{"signature": "def _set_hello_interval(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__hello_interval = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for hello_interval, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/timers/config/hello_interval (uint32)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_hello_interval is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_hello_interval() directly.\n\nYANG Description: ISIS hello-interval value.", "id": "f22416:c0:m3"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/timers/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: This container defines ISIS interface hello-timers configuration.", "id": "f22417:c0:m3"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/timers/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: This container defines ISIS interface hello-timers configuration.", "id": "f22417:c1:m3"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/timers/config (container)\n\nYANG Description: This container defines ISIS interface hello-timers configuration.", "id": "f22417:c0:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/timers/state (container)\n\nYANG Description: This container defines ISIS interface hello-timers state.", "id": "f22417:c1:m5"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/timers/config (container)\n\nYANG Description: This container defines ISIS interface hello-timers configuration.", "id": "f22417:c1:m2"}
{"signature": "def _set_adjacency(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>adjacency.adjacency,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__adjacency = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for adjacency, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/adjacencies/adjacency (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_adjacency is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_adjacency() directly.\n\nYANG Description: List of the local system's IS-IS adjacencies.", "id": "f22418:c1:m3"}
{"signature": "def _get_adjacency(self):", "body": "return self.__adjacency<EOL>", "docstring": "Getter method for adjacency, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/adjacencies/adjacency (list)\n\nYANG Description: List of the local system's IS-IS adjacencies.", "id": "f22418:c1:m2"}
{"signature": "def _get_system_id(self):", "body": "return self.__system_id<EOL>", "docstring": "Getter method for system_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/adjacencies/adjacency/state/system_id (oc-isis-types:system-id)\n\nYANG Description: ISIS neighbor system-id.", "id": "f22419:c0:m2"}
{"signature": "def _get_priority(self):", "body": "return self.__priority<EOL>", "docstring": "Getter method for priority, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/adjacencies/adjacency/state/priority (uint8)\n\nYANG Description: Priority of the neighboring IS(LAN Hello only).", "id": "f22419:c1:m20"}
{"signature": "def _get_neighbor_extended_circuit_id(self):", "body": "return self.__neighbor_extended_circuit_id<EOL>", "docstring": "Getter method for neighbor_extended_circuit_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/adjacencies/adjacency/state/neighbor_extended_circuit_id (oc-isis-types:extended-circuit-id)\n\nYANG Description: ISIS neighbor extended circuit ID.", "id": "f22419:c1:m17"}
{"signature": "def _get_up_time(self):", "body": "return self.__up_time<EOL>", "docstring": "Getter method for up_time, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/adjacencies/adjacency/state/up_time (yang:timestamp)\n\nYANG Description: Adjacency up time.", "id": "f22419:c1:m38"}
{"signature": "def _set_topology(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__topology = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for topology, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/adjacencies/adjacency/state/topology (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_topology is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_topology() directly.\n\n    YANG Description: ISIS topology type support(ipv4-unicast, ipv6-unicast,\nipv4-multicast, ipv6-multicast).", "id": "f22419:c0:m45"}
{"signature": "def _get_nlpid(self):", "body": "return self.__nlpid<EOL>", "docstring": "Getter method for nlpid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/adjacencies/adjacency/state/nlpid (enumeration)\n\n    YANG Description: Supported Protocol. IPv4 is defined as (0xcc)\nand IPv6 - (0x8e). ISIS reference is TLV 129.", "id": "f22419:c1:m59"}
{"signature": "def _get_nlpid(self):", "body": "return self.__nlpid<EOL>", "docstring": "Getter method for nlpid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/adjacencies/adjacency/state/nlpid (enumeration)\n\n    YANG Description: Supported Protocol. IPv4 is defined as (0xcc)\nand IPv6 - (0x8e). ISIS reference is TLV 129.", "id": "f22419:c0:m59"}
{"signature": "def _get_neighbor_snpa(self):", "body": "return self.__neighbor_snpa<EOL>", "docstring": "Getter method for neighbor_snpa, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/adjacencies/adjacency/state/neighbor_snpa (oc-isis-types:snpa)\n\nYANG Description: ISIS neighbor SNPA.", "id": "f22419:c0:m11"}
{"signature": "def _set_restart_suppress(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__restart_suppress = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for restart_suppress, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/adjacencies/adjacency/state/restart_suppress (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_restart_suppress is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_restart_suppress() directly.\n\n    YANG Description: When set to true, adjacency is not advertised. The SA bit is used by a\nstarting router to  request that its neighbor suppress advertisement of\nthe adjacency  to the starting router in the neighbor's LSPs.", "id": "f22419:c1:m51"}
{"signature": "def _set_neighbor_circuit_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__neighbor_circuit_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for neighbor_circuit_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/adjacencies/adjacency/state/neighbor_circuit_type (oc-isis-types:level-type)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_neighbor_circuit_type is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_neighbor_circuit_type() directly.\n\nYANG Description: Received ISIS circuit type (level-1, level-2, level-1-2).", "id": "f22419:c0:m27"}
{"signature": "def _set_adjacency_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__adjacency_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for adjacency_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/adjacencies/adjacency/state/adjacency_type (oc-isis-types:level-type)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_adjacency_type is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_adjacency_type() directly.\n\nYANG Description: Formed ISIS adjacency type(level-1, level-2, level-1-2).", "id": "f22419:c1:m30"}
{"signature": "def _set_local_extended_circuit_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__local_extended_circuit_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for local_extended_circuit_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/adjacencies/adjacency/state/local_extended_circuit_id (oc-isis-types:extended-circuit-id)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_local_extended_circuit_id is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_local_extended_circuit_id() directly.\n\nYANG Description: Local extended circuit ID.", "id": "f22419:c1:m15"}
{"signature": "def _set_remaining_hold_time(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__remaining_hold_time = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for remaining_hold_time, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/adjacencies/adjacency/state/remaining_hold_time (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_remaining_hold_time is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_remaining_hold_time() directly.\n\n    YANG Description: Holding time in seconds for adjacency. This value is based on received\nhello PDUs and the elapsed time since receipt.", "id": "f22419:c0:m36"}
{"signature": "def _set_priority(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__priority = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for priority, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/adjacencies/adjacency/state/priority (uint8)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_priority is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_priority() directly.\n\nYANG Description: Priority of the neighboring IS(LAN Hello only).", "id": "f22419:c1:m21"}
{"signature": "def _set_neighbor_extended_circuit_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__neighbor_extended_circuit_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for neighbor_extended_circuit_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/adjacencies/adjacency/state/neighbor_extended_circuit_id (oc-isis-types:extended-circuit-id)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_neighbor_extended_circuit_id is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_neighbor_extended_circuit_id() directly.\n\nYANG Description: ISIS neighbor extended circuit ID.", "id": "f22419:c0:m18"}
{"signature": "def _set_restart_status(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__restart_status = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for restart_status, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/adjacencies/adjacency/state/restart_status (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_restart_status is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_restart_status() directly.\n\n    YANG Description: When set to true, neighbor is being helped. The RR bit is used by a\n(re)starting router to signal to its neighbors that a (re)start is in\nprogress.", "id": "f22419:c1:m54"}
{"signature": "def _get_neighbor_ipv6_address(self):", "body": "return self.__neighbor_ipv6_address<EOL>", "docstring": "Getter method for neighbor_ipv6_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/adjacencies/adjacency/state/neighbor_ipv6_address (inet:ipv6-address-no-zone)\n\nYANG Description: ISIS Neighbor IPv6 address.", "id": "f22419:c0:m8"}
{"signature": "def _set_area_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__area_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for area_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/adjacencies/adjacency/state/area_address (oc-isis-types:area-address)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_area_address is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_area_address() directly.\n\nYANG Description: List of ISIS area-address(es).", "id": "f22419:c1:m57"}
{"signature": "def _set_nlpid(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__nlpid = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for nlpid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/adjacencies/adjacency/state/nlpid (enumeration)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_nlpid is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_nlpid() directly.\n\n    YANG Description: Supported Protocol. IPv4 is defined as (0xcc)\nand IPv6 - (0x8e). ISIS reference is TLV 129.", "id": "f22419:c0:m60"}
{"signature": "def _get_area_address(self):", "body": "return self.__area_address<EOL>", "docstring": "Getter method for area_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/adjacencies/adjacency/state/area_address (oc-isis-types:area-address)\n\nYANG Description: List of ISIS area-address(es).", "id": "f22419:c0:m56"}
{"signature": "def _get_neighbor_snpa(self):", "body": "return self.__neighbor_snpa<EOL>", "docstring": "Getter method for neighbor_snpa, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/adjacencies/adjacency/state/neighbor_snpa (oc-isis-types:snpa)\n\nYANG Description: ISIS neighbor SNPA.", "id": "f22419:c1:m11"}
{"signature": "def _set_adjacency_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}, \"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__adjacency_state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for adjacency_state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/adjacencies/adjacency/state/adjacency_state (oc-isis-types:isis-interface-adj-state)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_adjacency_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_adjacency_state() directly.\n\nYANG Description: P2P 3-way ISIS adjacency state(up, down, init, failed).", "id": "f22419:c0:m33"}
{"signature": "def _get_restart_suppress(self):", "body": "return self.__restart_suppress<EOL>", "docstring": "Getter method for restart_suppress, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/adjacencies/adjacency/state/restart_suppress (boolean)\n\n    YANG Description: When set to true, adjacency is not advertised. The SA bit is used by a\nstarting router to  request that its neighbor suppress advertisement of\nthe adjacency  to the starting router in the neighbor's LSPs.", "id": "f22419:c1:m50"}
{"signature": "def _set_restart_status(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__restart_status = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for restart_status, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/adjacencies/adjacency/state/restart_status (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_restart_status is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_restart_status() directly.\n\n    YANG Description: When set to true, neighbor is being helped. The RR bit is used by a\n(re)starting router to signal to its neighbors that a (re)start is in\nprogress.", "id": "f22419:c0:m54"}
{"signature": "def _get_local_extended_circuit_id(self):", "body": "return self.__local_extended_circuit_id<EOL>", "docstring": "Getter method for local_extended_circuit_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/adjacencies/adjacency/state/local_extended_circuit_id (oc-isis-types:extended-circuit-id)\n\nYANG Description: Local extended circuit ID.", "id": "f22419:c0:m14"}
{"signature": "def _get_neighbor_circuit_type(self):", "body": "return self.__neighbor_circuit_type<EOL>", "docstring": "Getter method for neighbor_circuit_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/adjacencies/adjacency/state/neighbor_circuit_type (oc-isis-types:level-type)\n\nYANG Description: Received ISIS circuit type (level-1, level-2, level-1-2).", "id": "f22419:c1:m26"}
{"signature": "def _get_up_time(self):", "body": "return self.__up_time<EOL>", "docstring": "Getter method for up_time, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/adjacencies/adjacency/state/up_time (yang:timestamp)\n\nYANG Description: Adjacency up time.", "id": "f22419:c0:m38"}
{"signature": "def _set_neighbor_ipv4_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__neighbor_ipv4_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for neighbor_ipv4_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/adjacencies/adjacency/state/neighbor_ipv4_address (inet:ipv4-address-no-zone)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_neighbor_ipv4_address is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_neighbor_ipv4_address() directly.\n\nYANG Description: ISIS Neighbor IPv4 address.", "id": "f22419:c1:m6"}
{"signature": "def _set_multi_topology(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__multi_topology = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for multi_topology, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/adjacencies/adjacency/state/multi_topology (boolean)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_multi_topology is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_multi_topology() directly.\n\nYANG Description: When set to true, ISIS multi-topology is supported.", "id": "f22419:c1:m42"}
{"signature": "def _get_restart_support(self):", "body": "return self.__restart_support<EOL>", "docstring": "Getter method for restart_support, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/adjacencies/adjacency/state/restart_support (boolean)\n\nYANG Description: When set to true, Graceful-restart signaling is supported.", "id": "f22419:c0:m47"}
{"signature": "def _get_system_id(self):", "body": "return self.__system_id<EOL>", "docstring": "Getter method for system_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/adjacencies/adjacency/system_id (leafref)\n\nYANG Description: Reference to the IS neighbor.", "id": "f22420:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/adjacencies/adjacency/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: Operational state relating to the IS-IS adjacency with the\nremote system", "id": "f22420:c1:m6"}
{"signature": "def _get_system_id(self):", "body": "return self.__system_id<EOL>", "docstring": "Getter method for system_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/adjacencies/adjacency/system_id (leafref)\n\nYANG Description: Reference to the IS neighbor.", "id": "f22420:c1:m2"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/config/enabled (boolean)\n\n    YANG Description: When set to true, the functionality within which this leaf is\ndefined is enabled, when set to false it is explicitly disabled.", "id": "f22421:c1:m11"}
{"signature": "def _get_level_number(self):", "body": "return self.__level_number<EOL>", "docstring": "Getter method for level_number, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/config/level_number (oc-isis-types:level-number)\n\nYANG Description: ISIS level number(level-1, level-2).", "id": "f22421:c1:m2"}
{"signature": "def _get_passive(self):", "body": "return self.__passive<EOL>", "docstring": "Getter method for passive, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/config/passive (boolean)\n\nYANG Description: ISIS passive interface admin enable/disable function.", "id": "f22421:c0:m5"}
{"signature": "def _set_adjacencies(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=adjacencies.adjacencies,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__adjacencies = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for adjacencies, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/adjacencies (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_adjacencies is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_adjacencies() directly.\n\nYANG Description: This container defines ISIS adjacencies.", "id": "f22422:c0:m15"}
{"signature": "def _set_afi_safi(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=afi_safi.afi_safi,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__afi_safi = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for afi_safi, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_afi_safi is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_afi_safi() directly.\n\n    YANG Description: This container defines address-family specific configuration\nand state information.", "id": "f22422:c1:m21"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/state (container)\n\nYANG Description: This container defines interface ISIS level state information.", "id": "f22422:c0:m8"}
{"signature": "def _set_afi_safi(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=afi_safi.afi_safi,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__afi_safi = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for afi_safi, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_afi_safi is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_afi_safi() directly.\n\n    YANG Description: This container defines address-family specific configuration\nand state information.", "id": "f22422:c0:m21"}
{"signature": "def _set_hello_authentication(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=hello_authentication.hello_authentication,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__hello_authentication = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for hello_authentication, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/hello_authentication (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_hello_authentication is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_hello_authentication() directly.\n\nYANG Description: This container defines ISIS authentication.", "id": "f22422:c0:m24"}
{"signature": "def _set_packet_counters(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=packet_counters.packet_counters,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__packet_counters = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for packet_counters, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_packet_counters is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_packet_counters() directly.\n\nYANG Description: This container defines ISIS interface packet counters.", "id": "f22422:c1:m12"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/config (container)\n\nYANG Description: This container defines interface ISIS level configuration.", "id": "f22422:c1:m5"}
{"signature": "def _get_hello_authentication(self):", "body": "return self.__hello_authentication<EOL>", "docstring": "Getter method for hello_authentication, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/hello_authentication (container)\n\nYANG Description: This container defines ISIS authentication.", "id": "f22422:c1:m23"}
{"signature": "def _get_received(self):", "body": "return self.__received<EOL>", "docstring": "Getter method for received, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/unknown/state/received (yang:counter32)\n\nYANG Description: The number of the specified type of PDU received on the interface.", "id": "f22423:c1:m2"}
{"signature": "def _get_sent(self):", "body": "return self.__sent<EOL>", "docstring": "Getter method for sent, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/unknown/state/sent (yang:counter32)\n\n    YANG Description: The number of the specified type of PDU that have been sent by the\nlocal system on the interface.", "id": "f22423:c1:m11"}
{"signature": "def _set_sent(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__sent = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for sent, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/unknown/state/sent (yang:counter32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_sent is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_sent() directly.\n\n    YANG Description: The number of the specified type of PDU that have been sent by the\nlocal system on the interface.", "id": "f22423:c0:m12"}
{"signature": "def _set_processed(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__processed = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for processed, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/unknown/state/processed (yang:counter32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_processed is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_processed() directly.\n\n    YANG Description: The number of the specified type of PDU received on the interface\nthat have been processed by the local system.", "id": "f22423:c1:m6"}
{"signature": "def _set_processed(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__processed = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for processed, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/unknown/state/processed (yang:counter32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_processed is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_processed() directly.\n\n    YANG Description: The number of the specified type of PDU received on the interface\nthat have been processed by the local system.", "id": "f22423:c0:m6"}
{"signature": "def _get_dropped(self):", "body": "return self.__dropped<EOL>", "docstring": "Getter method for dropped, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/unknown/state/dropped (yang:counter32)\n\n    YANG Description: The number of the specified type of PDU received on the interface\nthat have been dropped.", "id": "f22423:c1:m8"}
{"signature": "def _set_retransmit(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__retransmit = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for retransmit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/unknown/state/retransmit (yang:counter32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_retransmit is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_retransmit() directly.\n\n    YANG Description: The number of the specified type of PDU that that have been\nretransmitted by the local system on the interface.", "id": "f22423:c1:m15"}
{"signature": "def _set_dropped(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__dropped = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for dropped, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/unknown/state/dropped (yang:counter32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_dropped is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_dropped() directly.\n\n    YANG Description: The number of the specified type of PDU received on the interface\nthat have been dropped.", "id": "f22423:c1:m9"}
{"signature": "def _set_sent(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__sent = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for sent, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/unknown/state/sent (yang:counter32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_sent is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_sent() directly.\n\n    YANG Description: The number of the specified type of PDU that have been sent by the\nlocal system on the interface.", "id": "f22423:c1:m12"}
{"signature": "def _set_received(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__received = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for received, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/unknown/state/received (yang:counter32)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_received is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_received() directly.\n\nYANG Description: The number of the specified type of PDU received on the interface.", "id": "f22423:c1:m3"}
{"signature": "def _get_processed(self):", "body": "return self.__processed<EOL>", "docstring": "Getter method for processed, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/unknown/state/processed (yang:counter32)\n\n    YANG Description: The number of the specified type of PDU received on the interface\nthat have been processed by the local system.", "id": "f22423:c0:m5"}
{"signature": "def _get_processed(self):", "body": "return self.__processed<EOL>", "docstring": "Getter method for processed, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/unknown/state/processed (yang:counter32)\n\n    YANG Description: The number of the specified type of PDU received on the interface\nthat have been processed by the local system.", "id": "f22423:c1:m5"}
{"signature": "def _get_unknown(self):", "body": "return self.__unknown<EOL>", "docstring": "Getter method for unknown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/unknown (container)\n\n    YANG Description: Operational state parameters relating to IS-IS PDUs that are not\notherwise classified - referred to as Unknown PDUs.", "id": "f22425:c1:m20"}
{"signature": "def _get_unknown(self):", "body": "return self.__unknown<EOL>", "docstring": "Getter method for unknown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/unknown (container)\n\n    YANG Description: Operational state parameters relating to IS-IS PDUs that are not\notherwise classified - referred to as Unknown PDUs.", "id": "f22425:c0:m20"}
{"signature": "def _get_esh(self):", "body": "return self.__esh<EOL>", "docstring": "Getter method for esh, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/esh (container)\n\nYANG Description: This container defines ESH packet counters.", "id": "f22425:c0:m11"}
{"signature": "def _get_iih(self):", "body": "return self.__iih<EOL>", "docstring": "Getter method for iih, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/iih (container)\n\nYANG Description: This container defines IIH packet counters.", "id": "f22425:c1:m5"}
{"signature": "def _get_psnp(self):", "body": "return self.__psnp<EOL>", "docstring": "Getter method for psnp, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/psnp (container)\n\nYANG Description: This container defines PSNP packet counters.", "id": "f22425:c1:m14"}
{"signature": "def _set_iih(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=iih.iih,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__iih = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for iih, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/iih (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_iih is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_iih() directly.\n\nYANG Description: This container defines IIH packet counters.", "id": "f22425:c0:m6"}
{"signature": "def _get_cnsp(self):", "body": "return self.__cnsp<EOL>", "docstring": "Getter method for cnsp, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/cnsp (container)\n\nYANG Description: Operational state parameters relating to CNSPs.", "id": "f22425:c1:m17"}
{"signature": "def _set_psnp(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=psnp.psnp,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__psnp = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for psnp, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/psnp (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_psnp is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_psnp() directly.\n\nYANG Description: This container defines PSNP packet counters.", "id": "f22425:c1:m15"}
{"signature": "def _set_dropped(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__dropped = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for dropped, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/psnp/state/dropped (yang:counter32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_dropped is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_dropped() directly.\n\n    YANG Description: The number of the specified type of PDU received on the interface\nthat have been dropped.", "id": "f22426:c0:m9"}
{"signature": "def _set_dropped(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__dropped = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for dropped, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/psnp/state/dropped (yang:counter32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_dropped is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_dropped() directly.\n\n    YANG Description: The number of the specified type of PDU received on the interface\nthat have been dropped.", "id": "f22426:c1:m9"}
{"signature": "def _set_received(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__received = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for received, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/psnp/state/received (yang:counter32)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_received is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_received() directly.\n\nYANG Description: The number of the specified type of PDU received on the interface.", "id": "f22426:c0:m3"}
{"signature": "def _get_retransmit(self):", "body": "return self.__retransmit<EOL>", "docstring": "Getter method for retransmit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/psnp/state/retransmit (yang:counter32)\n\n    YANG Description: The number of the specified type of PDU that that have been\nretransmitted by the local system on the interface.", "id": "f22426:c1:m14"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/psnp/state (container)\n\nYANG Description: Packet counters relating to PSNPs.", "id": "f22427:c0:m2"}
{"signature": "def _set_received(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__received = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for received, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/esh/state/received (yang:counter32)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_received is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_received() directly.\n\nYANG Description: The number of the specified type of PDU received on the interface.", "id": "f22428:c0:m3"}
{"signature": "def _set_retransmit(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__retransmit = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for retransmit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/esh/state/retransmit (yang:counter32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_retransmit is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_retransmit() directly.\n\n    YANG Description: The number of the specified type of PDU that that have been\nretransmitted by the local system on the interface.", "id": "f22428:c0:m15"}
{"signature": "def _get_processed(self):", "body": "return self.__processed<EOL>", "docstring": "Getter method for processed, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/esh/state/processed (yang:counter32)\n\n    YANG Description: The number of the specified type of PDU received on the interface\nthat have been processed by the local system.", "id": "f22428:c1:m5"}
{"signature": "def _set_processed(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__processed = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for processed, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/esh/state/processed (yang:counter32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_processed is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_processed() directly.\n\n    YANG Description: The number of the specified type of PDU received on the interface\nthat have been processed by the local system.", "id": "f22428:c1:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/esh/state (container)\n\nYANG Description: Operational state relating to ESH PDUs", "id": "f22429:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/esh/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Operational state relating to ESH PDUs", "id": "f22429:c0:m3"}
{"signature": "def _set_sent(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__sent = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for sent, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/iih/state/sent (yang:counter32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_sent is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_sent() directly.\n\n    YANG Description: The number of the specified type of PDU that have been sent by the\nlocal system on the interface.", "id": "f22430:c0:m12"}
{"signature": "def _set_received(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__received = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for received, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/iih/state/received (yang:counter32)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_received is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_received() directly.\n\nYANG Description: The number of the specified type of PDU received on the interface.", "id": "f22430:c1:m3"}
{"signature": "def _set_processed(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__processed = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for processed, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/iih/state/processed (yang:counter32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_processed is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_processed() directly.\n\n    YANG Description: The number of the specified type of PDU received on the interface\nthat have been processed by the local system.", "id": "f22430:c1:m6"}
{"signature": "def _get_received(self):", "body": "return self.__received<EOL>", "docstring": "Getter method for received, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/iih/state/received (yang:counter32)\n\nYANG Description: The number of the specified type of PDU received on the interface.", "id": "f22430:c1:m2"}
{"signature": "def _get_sent(self):", "body": "return self.__sent<EOL>", "docstring": "Getter method for sent, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/iih/state/sent (yang:counter32)\n\n    YANG Description: The number of the specified type of PDU that have been sent by the\nlocal system on the interface.", "id": "f22430:c0:m11"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/iih/state (container)\n\nYANG Description: Operational counters relating to IIH PDUs", "id": "f22431:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/iih/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Operational counters relating to IIH PDUs", "id": "f22431:c1:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/iih/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Operational counters relating to IIH PDUs", "id": "f22431:c0:m3"}
{"signature": "def _set_received(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__received = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for received, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/lsp/state/received (yang:counter32)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_received is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_received() directly.\n\nYANG Description: The number of the specified type of PDU received on the interface.", "id": "f22432:c0:m3"}
{"signature": "def _set_retransmit(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__retransmit = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for retransmit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/lsp/state/retransmit (yang:counter32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_retransmit is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_retransmit() directly.\n\n    YANG Description: The number of the specified type of PDU that that have been\nretransmitted by the local system on the interface.", "id": "f22432:c0:m15"}
{"signature": "def _get_received(self):", "body": "return self.__received<EOL>", "docstring": "Getter method for received, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/lsp/state/received (yang:counter32)\n\nYANG Description: The number of the specified type of PDU received on the interface.", "id": "f22432:c1:m2"}
{"signature": "def _get_dropped(self):", "body": "return self.__dropped<EOL>", "docstring": "Getter method for dropped, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/lsp/state/dropped (yang:counter32)\n\n    YANG Description: The number of the specified type of PDU received on the interface\nthat have been dropped.", "id": "f22432:c1:m8"}
{"signature": "def _set_processed(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__processed = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for processed, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/lsp/state/processed (yang:counter32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_processed is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_processed() directly.\n\n    YANG Description: The number of the specified type of PDU received on the interface\nthat have been processed by the local system.", "id": "f22432:c0:m6"}
{"signature": "def _get_processed(self):", "body": "return self.__processed<EOL>", "docstring": "Getter method for processed, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/lsp/state/processed (yang:counter32)\n\n    YANG Description: The number of the specified type of PDU received on the interface\nthat have been processed by the local system.", "id": "f22432:c0:m5"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/lsp/state (container)\n\nYANG Description: This container defines LSP PDU counters.", "id": "f22433:c1:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/lsp/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: This container defines LSP PDU counters.", "id": "f22433:c0:m3"}
{"signature": "def _get_retransmit(self):", "body": "return self.__retransmit<EOL>", "docstring": "Getter method for retransmit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/ish/state/retransmit (yang:counter32)\n\n    YANG Description: The number of the specified type of PDU that that have been\nretransmitted by the local system on the interface.", "id": "f22434:c0:m14"}
{"signature": "def _get_processed(self):", "body": "return self.__processed<EOL>", "docstring": "Getter method for processed, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/ish/state/processed (yang:counter32)\n\n    YANG Description: The number of the specified type of PDU received on the interface\nthat have been processed by the local system.", "id": "f22434:c0:m5"}
{"signature": "def _set_processed(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__processed = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for processed, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/ish/state/processed (yang:counter32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_processed is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_processed() directly.\n\n    YANG Description: The number of the specified type of PDU received on the interface\nthat have been processed by the local system.", "id": "f22434:c0:m6"}
{"signature": "def _get_received(self):", "body": "return self.__received<EOL>", "docstring": "Getter method for received, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/ish/state/received (yang:counter32)\n\nYANG Description: The number of the specified type of PDU received on the interface.", "id": "f22434:c1:m2"}
{"signature": "def _set_received(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__received = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for received, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/ish/state/received (yang:counter32)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_received is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_received() directly.\n\nYANG Description: The number of the specified type of PDU received on the interface.", "id": "f22434:c1:m3"}
{"signature": "def _get_retransmit(self):", "body": "return self.__retransmit<EOL>", "docstring": "Getter method for retransmit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/ish/state/retransmit (yang:counter32)\n\n    YANG Description: The number of the specified type of PDU that that have been\nretransmitted by the local system on the interface.", "id": "f22434:c1:m14"}
{"signature": "def _get_sent(self):", "body": "return self.__sent<EOL>", "docstring": "Getter method for sent, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/ish/state/sent (yang:counter32)\n\n    YANG Description: The number of the specified type of PDU that have been sent by the\nlocal system on the interface.", "id": "f22434:c0:m11"}
{"signature": "def _set_retransmit(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__retransmit = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for retransmit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/ish/state/retransmit (yang:counter32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_retransmit is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_retransmit() directly.\n\n    YANG Description: The number of the specified type of PDU that that have been\nretransmitted by the local system on the interface.", "id": "f22434:c1:m15"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/ish/state (container)\n\nYANG Description: Operational state relating to ISH PDUs.", "id": "f22435:c0:m2"}
{"signature": "def _get_processed(self):", "body": "return self.__processed<EOL>", "docstring": "Getter method for processed, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/cnsp/state/processed (yang:counter32)\n\n    YANG Description: The number of the specified type of PDU received on the interface\nthat have been processed by the local system.", "id": "f22436:c1:m5"}
{"signature": "def _set_processed(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__processed = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for processed, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/cnsp/state/processed (yang:counter32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_processed is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_processed() directly.\n\n    YANG Description: The number of the specified type of PDU received on the interface\nthat have been processed by the local system.", "id": "f22436:c1:m6"}
{"signature": "def _get_sent(self):", "body": "return self.__sent<EOL>", "docstring": "Getter method for sent, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/cnsp/state/sent (yang:counter32)\n\n    YANG Description: The number of the specified type of PDU that have been sent by the\nlocal system on the interface.", "id": "f22436:c0:m11"}
{"signature": "def _set_sent(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__sent = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for sent, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/cnsp/state/sent (yang:counter32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_sent is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_sent() directly.\n\n    YANG Description: The number of the specified type of PDU that have been sent by the\nlocal system on the interface.", "id": "f22436:c0:m12"}
{"signature": "def _get_received(self):", "body": "return self.__received<EOL>", "docstring": "Getter method for received, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/cnsp/state/received (yang:counter32)\n\nYANG Description: The number of the specified type of PDU received on the interface.", "id": "f22436:c0:m2"}
{"signature": "def _get_retransmit(self):", "body": "return self.__retransmit<EOL>", "docstring": "Getter method for retransmit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/cnsp/state/retransmit (yang:counter32)\n\n    YANG Description: The number of the specified type of PDU that that have been\nretransmitted by the local system on the interface.", "id": "f22436:c0:m14"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/packet_counters/cnsp/state (container)\n\nYANG Description: Packet counters relating to CNSPs.", "id": "f22437:c0:m2"}
{"signature": "def _set_af(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>af.af,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__af = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for af, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_af is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_af() directly.\n\nYANG Description: Address-family/Subsequent Address-family list.", "id": "f22438:c1:m3"}
{"signature": "def _get_afi_name(self):", "body": "return self.__afi_name<EOL>", "docstring": "Getter method for afi_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/state/afi_name (identityref)\n\nYANG Description: Address-family type.", "id": "f22439:c1:m2"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/state/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: When set to true, the functionality within which this leaf is\ndefined is enabled, when set to false it is explicitly disabled.", "id": "f22439:c0:m12"}
{"signature": "def _set_afi_name(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__afi_name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for afi_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/state/afi_name (identityref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_afi_name is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_afi_name() directly.\n\nYANG Description: Address-family type.", "id": "f22439:c0:m3"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/state/enabled (boolean)\n\n    YANG Description: When set to true, the functionality within which this leaf is\ndefined is enabled, when set to false it is explicitly disabled.", "id": "f22439:c0:m11"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/state/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: When set to true, the functionality within which this leaf is\ndefined is enabled, when set to false it is explicitly disabled.", "id": "f22439:c1:m12"}
{"signature": "def _get_afi_name(self):", "body": "return self.__afi_name<EOL>", "docstring": "Getter method for afi_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/state/afi_name (identityref)\n\nYANG Description: Address-family type.", "id": "f22439:c0:m2"}
{"signature": "def _set_safi_name(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__safi_name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for safi_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/state/safi_name (identityref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_safi_name is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_safi_name() directly.\n\nYANG Description: Subsequent address-family type.", "id": "f22439:c0:m6"}
{"signature": "def _set_safi_name(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__safi_name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for safi_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/config/safi_name (identityref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_safi_name is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_safi_name() directly.\n\nYANG Description: Subsequent address-family type.", "id": "f22440:c0:m6"}
{"signature": "def _set_afi_name(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__afi_name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for afi_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/config/afi_name (identityref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_afi_name is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_afi_name() directly.\n\nYANG Description: Address-family type.", "id": "f22440:c0:m3"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/config/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: When set to true, the functionality within which this leaf is\ndefined is enabled, when set to false it is explicitly disabled.", "id": "f22440:c1:m12"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/config/enabled (boolean)\n\n    YANG Description: When set to true, the functionality within which this leaf is\ndefined is enabled, when set to false it is explicitly disabled.", "id": "f22440:c1:m11"}
{"signature": "def _get_metric(self):", "body": "return self.__metric<EOL>", "docstring": "Getter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/config/metric (uint32)\n\nYANG Description: ISIS metric value(default=10).", "id": "f22440:c0:m8"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/config (container)\n\n    YANG Description: This container defines AFI-SAFI configuration parameters. Single\ntopology is the default setting.", "id": "f22441:c1:m8"}
{"signature": "def _get_safi_name(self):", "body": "return self.__safi_name<EOL>", "docstring": "Getter method for safi_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/safi_name (leafref)\n\nYANG Description: Reference to subsequent address-family type", "id": "f22441:c0:m5"}
{"signature": "def _get_segment_routing(self):", "body": "return self.__segment_routing<EOL>", "docstring": "Getter method for segment_routing, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/segment_routing (container)\n\n    YANG Description: Configuration and operatioanl state parameters relating to segment\nrouting for an interface within the IGP.", "id": "f22441:c0:m14"}
{"signature": "def _set_segment_routing(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=segment_routing.segment_routing,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__segment_routing = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for segment_routing, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/segment_routing (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_segment_routing is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_segment_routing() directly.\n\n    YANG Description: Configuration and operatioanl state parameters relating to segment\nrouting for an interface within the IGP.", "id": "f22441:c0:m15"}
{"signature": "def _set_protection_eligible(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:true>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__protection_eligible = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for protection_eligible, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/segment_routing/adjacency_sids/adjacency_sid/state/protection_eligible (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_protection_eligible is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_protection_eligible() directly.\n\n    YANG Description: Whether the Adj-SID should be considered to be eligible for protection\nusing IP or MPLS FRR during a network failure. When this value is set to\ntrue, the B-flag of the Adj-SID is set to 1, and the local system should\nprovide FRR paths for the associated label forwarding entry. When it is\nset to false, the local system must not provide FRR for the specified\nLFIB entry.", "id": "f22442:c0:m6"}
{"signature": "def _set_sid_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:0>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:1>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:2>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:3>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:7>},<EOL>\"<STR_LIT>\": {},<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__sid_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for sid_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/segment_routing/adjacency_sids/adjacency_sid/state/sid_id (union)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_sid_id is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_sid_id() directly.\n\n    YANG Description: The value of the Adj-SID to be advertised. Where a static SID\nidentifier is specified, this should be advertised directly by the\nsystem. Where the DYNAMIC value is specified, this should be treated\nas a dynamically allocated value. When the MPLS data plane is in use\nthe dynamic value should not fall within a reserved-label-block.", "id": "f22442:c1:m3"}
{"signature": "def _set_neighbor(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__neighbor = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for neighbor, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/segment_routing/adjacency_sids/adjacency_sid/state/neighbor (inet:ip-address)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_neighbor is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_neighbor() directly.\n\n    YANG Description: The remote system on the interface with which the Adj-SID is\nassociated.", "id": "f22442:c0:m12"}
{"signature": "def _set_group(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__group = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for group, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/segment_routing/adjacency_sids/adjacency_sid/state/group (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_group is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_group() directly.\n\n    YANG Description: When set to true, the Adj-SID is indicated to be part of a group, and\nthe G flag is set to 1 in the corresponding advertisement in the IGP.", "id": "f22442:c0:m9"}
{"signature": "def _set_allocated_dynamic_local(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:0>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:1>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:2>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:3>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:7>},<EOL>\"<STR_LIT>\": {},<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__allocated_dynamic_local = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for allocated_dynamic_local, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/segment_routing/adjacency_sids/adjacency_sid/state/allocated_dynamic_local (sr-sid-type)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_allocated_dynamic_local is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_allocated_dynamic_local() directly.\n\n    YANG Description: Where an Adjacency SID with a dynamic value is to be allocated by\nthe system, this leaf reports to the value of the Adj-SID allocated\nto this interface.", "id": "f22442:c1:m15"}
{"signature": "def _get_group(self):", "body": "return self.__group<EOL>", "docstring": "Getter method for group, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/segment_routing/adjacency_sids/adjacency_sid/state/group (boolean)\n\n    YANG Description: When set to true, the Adj-SID is indicated to be part of a group, and\nthe G flag is set to 1 in the corresponding advertisement in the IGP.", "id": "f22442:c1:m8"}
{"signature": "def _get_group(self):", "body": "return self.__group<EOL>", "docstring": "Getter method for group, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/segment_routing/adjacency_sids/adjacency_sid/config/group (boolean)\n\n    YANG Description: When set to true, the Adj-SID is indicated to be part of a group, and\nthe G flag is set to 1 in the corresponding advertisement in the IGP.", "id": "f22443:c1:m8"}
{"signature": "def _set_protection_eligible(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:true>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__protection_eligible = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for protection_eligible, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/segment_routing/adjacency_sids/adjacency_sid/config/protection_eligible (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_protection_eligible is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_protection_eligible() directly.\n\n    YANG Description: Whether the Adj-SID should be considered to be eligible for protection\nusing IP or MPLS FRR during a network failure. When this value is set to\ntrue, the B-flag of the Adj-SID is set to 1, and the local system should\nprovide FRR paths for the associated label forwarding entry. When it is\nset to false, the local system must not provide FRR for the specified\nLFIB entry.", "id": "f22443:c0:m6"}
{"signature": "def _set_sid_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:0>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:1>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:2>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:3>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:7>},<EOL>\"<STR_LIT>\": {},<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__sid_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for sid_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/segment_routing/adjacency_sids/adjacency_sid/config/sid_id (union)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_sid_id is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_sid_id() directly.\n\n    YANG Description: The value of the Adj-SID to be advertised. Where a static SID\nidentifier is specified, this should be advertised directly by the\nsystem. Where the DYNAMIC value is specified, this should be treated\nas a dynamically allocated value. When the MPLS data plane is in use\nthe dynamic value should not fall within a reserved-label-block.", "id": "f22443:c0:m3"}
{"signature": "def _get_sid_id(self):", "body": "return self.__sid_id<EOL>", "docstring": "Getter method for sid_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/segment_routing/adjacency_sids/adjacency_sid/sid_id (leafref)\n\n    YANG Description: Reference to the segment identifier to be used by the local\nsystem.", "id": "f22444:c1:m2"}
{"signature": "def _set_sid_id(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__sid_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for sid_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/segment_routing/adjacency_sids/adjacency_sid/sid_id (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_sid_id is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_sid_id() directly.\n\n    YANG Description: Reference to the segment identifier to be used by the local\nsystem.", "id": "f22444:c1:m3"}
{"signature": "def _set_sid_id(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__sid_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for sid_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/segment_routing/adjacency_sids/adjacency_sid/sid_id (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_sid_id is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_sid_id() directly.\n\n    YANG Description: Reference to the segment identifier to be used by the local\nsystem.", "id": "f22444:c0:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/segment_routing/adjacency_sids/adjacency_sid/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Operational state parameters relating to the AdjSID.", "id": "f22444:c1:m12"}
{"signature": "def _set_neighbor(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__neighbor = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for neighbor, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/segment_routing/adjacency_sids/adjacency_sid/neighbor (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_neighbor is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_neighbor() directly.\n\n    YANG Description: Reference to the neighbor with which the Adjacency SID is\nassociated.", "id": "f22444:c1:m6"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/segment_routing/adjacency_sids/adjacency_sid/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Operational state parameters relating to the AdjSID.", "id": "f22444:c0:m12"}
{"signature": "def _set_adjacency_sid(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>adjacency_sid.adjacency_sid,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__adjacency_sid = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for adjacency_sid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/segment_routing/adjacency_sids/adjacency_sid (list)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_adjacency_sid is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_adjacency_sid() directly.\n\n    YANG Description: An Adjacency SID to be advertised for the specified interface.\nThe Adj-SID's identifier (the SID ID) must be unique, with flags\nspecified indicating the parameters that should be set for the SID.\nWhere a SID value is specified that is allocated from the SRGB, the\nglobal flag must be set by the system.", "id": "f22445:c1:m3"}
{"signature": "def _get_adjacency_sid(self):", "body": "return self.__adjacency_sid<EOL>", "docstring": "Getter method for adjacency_sid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/segment_routing/adjacency_sids/adjacency_sid (list)\n\n    YANG Description: An Adjacency SID to be advertised for the specified interface.\nThe Adj-SID's identifier (the SID ID) must be unique, with flags\nspecified indicating the parameters that should be set for the SID.\nWhere a SID value is specified that is allocated from the SRGB, the\nglobal flag must be set by the system.", "id": "f22445:c1:m2"}
{"signature": "def _set_adjacency_sids(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=adjacency_sids.adjacency_sids,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__adjacency_sids = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for adjacency_sids, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/segment_routing/adjacency_sids (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_adjacency_sids is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_adjacency_sids() directly.\n\n    YANG Description: Configuration and operational state parameters relating to\nthe advertisement of a segment routing adjacency SID for this\ninterface.", "id": "f22446:c0:m6"}
{"signature": "def _get_prefix_sid(self):", "body": "return self.__prefix_sid<EOL>", "docstring": "Getter method for prefix_sid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/segment_routing/prefix_sids/prefix_sid (list)\n\n    YANG Description: An IGP prefix that should have a segment routing IGP-Prefix SID\nallocated to it. The value of the SID is specified by the SID ID,\nas an absolute value. If the absolute value falls within the SRGB,\nthe Global flag should be advertised by the system.", "id": "f22447:c1:m2"}
{"signature": "def _set_label_options(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__label_options = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for label_options, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/segment_routing/prefix_sids/prefix_sid/state/label_options (enumeration)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_label_options is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_label_options() directly.\n\n    YANG Description: The options associated with the IGP prefix SID for MPLS. The value\nof this leaf specifies the option that the SID should be advertised\ninto the IGP with.", "id": "f22448:c0:m9"}
{"signature": "def _get_prefix(self):", "body": "return self.__prefix<EOL>", "docstring": "Getter method for prefix, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/segment_routing/prefix_sids/prefix_sid/state/prefix (inet:ip-prefix)\n\n    YANG Description: The IP prefix for which the IGP prefix SID should be advertised. The\nvalue specified is a local prefix on the interface which is advertised\ninto the IGP.", "id": "f22448:c1:m2"}
{"signature": "def _get_label_options(self):", "body": "return self.__label_options<EOL>", "docstring": "Getter method for label_options, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/segment_routing/prefix_sids/prefix_sid/state/label_options (enumeration)\n\n    YANG Description: The options associated with the IGP prefix SID for MPLS. The value\nof this leaf specifies the option that the SID should be advertised\ninto the IGP with.", "id": "f22448:c0:m8"}
{"signature": "def _set_label_options(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__label_options = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for label_options, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/segment_routing/prefix_sids/prefix_sid/config/label_options (enumeration)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_label_options is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_label_options() directly.\n\n    YANG Description: The options associated with the IGP prefix SID for MPLS. The value\nof this leaf specifies the option that the SID should be advertised\ninto the IGP with.", "id": "f22449:c0:m9"}
{"signature": "def _get_prefix(self):", "body": "return self.__prefix<EOL>", "docstring": "Getter method for prefix, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/segment_routing/prefix_sids/prefix_sid/config/prefix (inet:ip-prefix)\n\n    YANG Description: The IP prefix for which the IGP prefix SID should be advertised. The\nvalue specified is a local prefix on the interface which is advertised\ninto the IGP.", "id": "f22449:c0:m2"}
{"signature": "def _set_prefix(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prefix = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prefix, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/segment_routing/prefix_sids/prefix_sid/config/prefix (inet:ip-prefix)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prefix is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prefix() directly.\n\n    YANG Description: The IP prefix for which the IGP prefix SID should be advertised. The\nvalue specified is a local prefix on the interface which is advertised\ninto the IGP.", "id": "f22449:c1:m3"}
{"signature": "def _set_prefix(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prefix = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prefix, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/segment_routing/prefix_sids/prefix_sid/config/prefix (inet:ip-prefix)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prefix is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prefix() directly.\n\n    YANG Description: The IP prefix for which the IGP prefix SID should be advertised. The\nvalue specified is a local prefix on the interface which is advertised\ninto the IGP.", "id": "f22449:c0:m3"}
{"signature": "def _set_sid_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:0>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:1>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:2>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:3>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:7>},<EOL>\"<STR_LIT>\": {},<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__sid_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for sid_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/segment_routing/prefix_sids/prefix_sid/config/sid_id (sr-sid-type)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_sid_id is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_sid_id() directly.\n\nYANG Description: The Segment Identifier to be used when advertising the IGP Prefix SID.", "id": "f22449:c0:m6"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/segment_routing/prefix_sids/prefix_sid/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration parameters for the IGP Prefix SID.", "id": "f22450:c0:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/segment_routing/prefix_sids/prefix_sid/state (container)\n\nYANG Description: Operational state parameters for the IGP-Prefix SID.", "id": "f22450:c1:m8"}
{"signature": "def _get_prefix(self):", "body": "return self.__prefix<EOL>", "docstring": "Getter method for prefix, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/segment_routing/prefix_sids/prefix_sid/prefix (leafref)\n\n    YANG Description: Reference to the prefix for which the IGP-Prefix SID is to be\nadvertised", "id": "f22450:c0:m2"}
{"signature": "def _set_prefix(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prefix = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prefix, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/segment_routing/prefix_sids/prefix_sid/prefix (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prefix is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prefix() directly.\n\n    YANG Description: Reference to the prefix for which the IGP-Prefix SID is to be\nadvertised", "id": "f22450:c0:m3"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/levels/level/afi_safi/af/segment_routing/prefix_sids/prefix_sid/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration parameters for the IGP Prefix SID.", "id": "f22450:c1:m6"}
{"signature": "def _set_af(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>af.af,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__af = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for af, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/afi_safi/af (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_af is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_af() directly.\n\nYANG Description: Address-family/Subsequent Address-family list.", "id": "f22451:c1:m3"}
{"signature": "def _get_safi_name(self):", "body": "return self.__safi_name<EOL>", "docstring": "Getter method for safi_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/afi_safi/af/state/safi_name (identityref)\n\nYANG Description: Subsequent address-family type.", "id": "f22452:c0:m5"}
{"signature": "def _set_safi_name(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__safi_name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for safi_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/afi_safi/af/state/safi_name (identityref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_safi_name is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_safi_name() directly.\n\nYANG Description: Subsequent address-family type.", "id": "f22452:c1:m6"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/afi_safi/af/state/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: When set to true, the functionality within which this leaf is\ndefined is enabled, when set to false it is explicitly disabled.", "id": "f22452:c0:m9"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/afi_safi/af/state/enabled (boolean)\n\n    YANG Description: When set to true, the functionality within which this leaf is\ndefined is enabled, when set to false it is explicitly disabled.", "id": "f22452:c0:m8"}
{"signature": "def _set_afi_name(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__afi_name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for afi_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/afi_safi/af/state/afi_name (identityref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_afi_name is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_afi_name() directly.\n\nYANG Description: Address-family type.", "id": "f22452:c1:m3"}
{"signature": "def _get_safi_name(self):", "body": "return self.__safi_name<EOL>", "docstring": "Getter method for safi_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/afi_safi/af/config/safi_name (identityref)\n\nYANG Description: Subsequent address-family type.", "id": "f22453:c1:m5"}
{"signature": "def _get_safi_name(self):", "body": "return self.__safi_name<EOL>", "docstring": "Getter method for safi_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/afi_safi/af/safi_name (leafref)\n\nYANG Description: Reference to subsequent address-family type", "id": "f22454:c0:m5"}
{"signature": "def _set_afi_name(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__afi_name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for afi_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/afi_safi/af/afi_name (leafref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_afi_name is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_afi_name() directly.\n\nYANG Description: Reference to address-family type", "id": "f22454:c0:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/afi_safi/af/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: This container defines AFI-SAFI State information", "id": "f22454:c1:m12"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/afi_safi/af/config (container)\n\n    YANG Description: This container defines AFI-SAFI configuration parameters. Single\ntopology is the default setting.", "id": "f22454:c0:m8"}
{"signature": "def _get_afi_name(self):", "body": "return self.__afi_name<EOL>", "docstring": "Getter method for afi_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/afi_safi/af/afi_name (leafref)\n\nYANG Description: Reference to address-family type", "id": "f22454:c1:m2"}
{"signature": "def _get_hello_authentication(self):", "body": "return self.__hello_authentication<EOL>", "docstring": "Getter method for hello_authentication, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/authentication/state/hello_authentication (boolean)\n\nYANG Description: Enabled or disable ISIS Hello authentication.", "id": "f22455:c0:m2"}
{"signature": "def _set_auth_password(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__auth_password = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for auth_password, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/authentication/key/state/auth_password (oc-types:routing-password)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_auth_password is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_auth_password() directly.\n\nYANG Description: Authentication key string.", "id": "f22456:c0:m3"}
{"signature": "def _get_auth_password(self):", "body": "return self.__auth_password<EOL>", "docstring": "Getter method for auth_password, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/authentication/key/state/auth_password (oc-types:routing-password)\n\nYANG Description: Authentication key string.", "id": "f22456:c0:m2"}
{"signature": "def _get_auth_password(self):", "body": "return self.__auth_password<EOL>", "docstring": "Getter method for auth_password, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/authentication/key/config/auth_password (oc-types:routing-password)\n\nYANG Description: Authentication key string.", "id": "f22457:c1:m2"}
{"signature": "def _set_auth_password(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__auth_password = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for auth_password, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/authentication/key/config/auth_password (oc-types:routing-password)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_auth_password is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_auth_password() directly.\n\nYANG Description: Authentication key string.", "id": "f22457:c1:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/authentication/key/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: This container defines ISIS authentication key state.", "id": "f22458:c1:m6"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/authentication/key/config (container)\n\nYANG Description: This container defines ISIS authentication key configuration.", "id": "f22458:c0:m2"}
{"signature": "def _set_hello_authentication(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__hello_authentication = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for hello_authentication, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/authentication/config/hello_authentication (boolean)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_hello_authentication is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_hello_authentication() directly.\n\nYANG Description: Enabled or disable ISIS Hello authentication.", "id": "f22459:c0:m3"}
{"signature": "def _set_hello_authentication(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__hello_authentication = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for hello_authentication, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/authentication/config/hello_authentication (boolean)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_hello_authentication is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_hello_authentication() directly.\n\nYANG Description: Enabled or disable ISIS Hello authentication.", "id": "f22459:c1:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/authentication/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: This container defines ISIS authentication state.", "id": "f22460:c1:m6"}
{"signature": "def _get_key(self):", "body": "return self.__key<EOL>", "docstring": "Getter method for key, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/authentication/key (container)\n\nYANG Description: This container defines ISIS authentication key", "id": "f22460:c0:m8"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/authentication/config (container)\n\nYANG Description: This container defines ISIS authentication configuration.", "id": "f22460:c0:m2"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/authentication/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: This container defines ISIS authentication configuration.", "id": "f22460:c0:m3"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface/authentication/config (container)\n\nYANG Description: This container defines ISIS authentication configuration.", "id": "f22460:c1:m2"}
{"signature": "def _get_interface(self):", "body": "return self.__interface<EOL>", "docstring": "Getter method for interface, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces/interface (list)\n\nYANG Description: This list contains ISIS interfaces.", "id": "f22461:c1:m2"}
{"signature": "def _get_interfaces(self):", "body": "return self.__interfaces<EOL>", "docstring": "Getter method for interfaces, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces (container)\n\n    YANG Description: This container defines global ISIS interface configuration and\nstate information.", "id": "f22462:c0:m8"}
{"signature": "def _set_interfaces(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=interfaces.interfaces,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interfaces = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interfaces, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/interfaces (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_interfaces is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_interfaces() directly.\n\n    YANG Description: This container defines global ISIS interface configuration and\nstate information.", "id": "f22462:c1:m9"}
{"signature": "def _get_global_(self):", "body": "return self.__global_<EOL>", "docstring": "Getter method for global_, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global (container)\n\n    YANG Description: This container defines global ISIS configuration and state\ninformation.", "id": "f22462:c1:m2"}
{"signature": "def _get_global_(self):", "body": "return self.__global_<EOL>", "docstring": "Getter method for global_, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global (container)\n\n    YANG Description: This container defines global ISIS configuration and state\ninformation.", "id": "f22462:c0:m2"}
{"signature": "def _get_helper_only(self):", "body": "return self.__helper_only<EOL>", "docstring": "Getter method for helper_only, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/graceful_restart/state/helper_only (boolean)\n\n    YANG Description: Enable or disable the IS-IS graceful restart helper function. When\nthis leaf is set, the local system does not utilise the IS-IS\ngraceful restart procedures during its own restart, but supports\nretaining forwarding information during a remote speaker's restart.", "id": "f22463:c0:m5"}
{"signature": "def _set_helper_only(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__helper_only = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for helper_only, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/graceful_restart/state/helper_only (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_helper_only is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_helper_only() directly.\n\n    YANG Description: Enable or disable the IS-IS graceful restart helper function. When\nthis leaf is set, the local system does not utilise the IS-IS\ngraceful restart procedures during its own restart, but supports\nretaining forwarding information during a remote speaker's restart.", "id": "f22463:c0:m6"}
{"signature": "def _set_helper_only(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__helper_only = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for helper_only, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/graceful_restart/state/helper_only (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_helper_only is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_helper_only() directly.\n\n    YANG Description: Enable or disable the IS-IS graceful restart helper function. When\nthis leaf is set, the local system does not utilise the IS-IS\ngraceful restart procedures during its own restart, but supports\nretaining forwarding information during a remote speaker's restart.", "id": "f22463:c1:m6"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/graceful_restart/state/enabled (boolean)\n\n    YANG Description: When set to true, the functionality within which this leaf is\ndefined is enabled, when set to false it is explicitly disabled.", "id": "f22463:c1:m2"}
{"signature": "def _get_helper_only(self):", "body": "return self.__helper_only<EOL>", "docstring": "Getter method for helper_only, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/graceful_restart/config/helper_only (boolean)\n\n    YANG Description: Enable or disable the IS-IS graceful restart helper function. When\nthis leaf is set, the local system does not utilise the IS-IS\ngraceful restart procedures during its own restart, but supports\nretaining forwarding information during a remote speaker's restart.", "id": "f22464:c1:m5"}
{"signature": "def _set_helper_only(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__helper_only = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for helper_only, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/graceful_restart/config/helper_only (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_helper_only is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_helper_only() directly.\n\n    YANG Description: Enable or disable the IS-IS graceful restart helper function. When\nthis leaf is set, the local system does not utilise the IS-IS\ngraceful restart procedures during its own restart, but supports\nretaining forwarding information during a remote speaker's restart.", "id": "f22464:c0:m6"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/graceful_restart/config/enabled (boolean)\n\n    YANG Description: When set to true, the functionality within which this leaf is\ndefined is enabled, when set to false it is explicitly disabled.", "id": "f22464:c1:m2"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/graceful_restart/config/enabled (boolean)\n\n    YANG Description: When set to true, the functionality within which this leaf is\ndefined is enabled, when set to false it is explicitly disabled.", "id": "f22464:c0:m2"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/graceful_restart/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: This container defines ISIS graceful-restart configuration.", "id": "f22465:c1:m3"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/graceful_restart/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: This container defines ISIS graceful-restart configuration.", "id": "f22465:c0:m3"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/graceful_restart/config (container)\n\nYANG Description: This container defines ISIS graceful-restart configuration.", "id": "f22465:c0:m2"}
{"signature": "def _set_net(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__net = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for net, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/state/net (oc-isis-types:net)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_net is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_net() directly.\n\n    YANG Description: ISIS network entity title (NET). The first 8 bits are usually\n49 (private AFI), next 16 bits represent area, next 48 bits represent\nsystem id and final 8 bits are set to 0.", "id": "f22466:c0:m9"}
{"signature": "def _set_iid_tlv(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__iid_tlv = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for iid_tlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/state/iid_tlv (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_iid_tlv is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_iid_tlv() directly.\n\n    YANG Description: ISIS Instance Identifier TLV. When set to trues, the IID-TLV identifies\nthe unique instance as well as the topology/topologies to which the\nPDU applies.", "id": "f22466:c1:m24"}
{"signature": "def _set_poi_tlv(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__poi_tlv = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for poi_tlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/state/poi_tlv (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_poi_tlv is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_poi_tlv() directly.\n\n    YANG Description: ISIS purge TLV. When set to true, a TLV is added to purges to record\nthe system ID  of the IS generating the purge.", "id": "f22466:c0:m21"}
{"signature": "def _get_authentication_check(self):", "body": "return self.__authentication_check<EOL>", "docstring": "Getter method for authentication_check, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/state/authentication_check (boolean)\n\n    YANG Description: When set to true, reject all ISIS protocol PDUs that either have a mismatch\nin authentication-type or authentication-key.", "id": "f22466:c0:m2"}
{"signature": "def _get_net(self):", "body": "return self.__net<EOL>", "docstring": "Getter method for net, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/state/net (oc-isis-types:net)\n\n    YANG Description: ISIS network entity title (NET). The first 8 bits are usually\n49 (private AFI), next 16 bits represent area, next 48 bits represent\nsystem id and final 8 bits are set to 0.", "id": "f22466:c0:m8"}
{"signature": "def _get_iid_tlv(self):", "body": "return self.__iid_tlv<EOL>", "docstring": "Getter method for iid_tlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/state/iid_tlv (boolean)\n\n    YANG Description: ISIS Instance Identifier TLV. When set to trues, the IID-TLV identifies\nthe unique instance as well as the topology/topologies to which the\nPDU applies.", "id": "f22466:c0:m23"}
{"signature": "def _set_max_ecmp_paths(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__max_ecmp_paths = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for max_ecmp_paths, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/state/max_ecmp_paths (uint8)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_max_ecmp_paths is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_max_ecmp_paths() directly.\n\nYANG Description: ISIS max-paths count.", "id": "f22466:c1:m18"}
{"signature": "def _set_poi_tlv(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__poi_tlv = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for poi_tlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/state/poi_tlv (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_poi_tlv is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_poi_tlv() directly.\n\n    YANG Description: ISIS purge TLV. When set to true, a TLV is added to purges to record\nthe system ID  of the IS generating the purge.", "id": "f22466:c1:m21"}
{"signature": "def _get_poi_tlv(self):", "body": "return self.__poi_tlv<EOL>", "docstring": "Getter method for poi_tlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/state/poi_tlv (boolean)\n\n    YANG Description: ISIS purge TLV. When set to true, a TLV is added to purges to record\nthe system ID  of the IS generating the purge.", "id": "f22466:c0:m20"}
{"signature": "def _get_fast_flooding(self):", "body": "return self.__fast_flooding<EOL>", "docstring": "Getter method for fast_flooding, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/state/fast_flooding (boolean)\n\n    YANG Description: When set to true, IS will always flood the LSP that triggered an SPF\nbefore the router actually runs the SPF computation.", "id": "f22466:c1:m26"}
{"signature": "def _set_afi_name(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__afi_name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for afi_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/igp_shortcuts/afi/state/afi_name (identityref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_afi_name is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_afi_name() directly.\n\nYANG Description: Address-family type.", "id": "f22467:c0:m3"}
{"signature": "def _set_nh_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__nh_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for nh_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/igp_shortcuts/afi/state/nh_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_nh_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_nh_type() directly.\n\n    YANG Description: Tunnel NH Type(RSVP,SR). When present it implies\nthat nh-type shortcut is enabled for a specified AFI.", "id": "f22467:c0:m6"}
{"signature": "def _get_afi_name(self):", "body": "return self.__afi_name<EOL>", "docstring": "Getter method for afi_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/igp_shortcuts/afi/config/afi_name (identityref)\n\nYANG Description: Address-family type.", "id": "f22468:c1:m2"}
{"signature": "def _set_nh_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__nh_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for nh_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/igp_shortcuts/afi/config/nh_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_nh_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_nh_type() directly.\n\n    YANG Description: Tunnel NH Type(RSVP,SR). When present it implies\nthat nh-type shortcut is enabled for a specified AFI.", "id": "f22468:c0:m6"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/igp_shortcuts/afi/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: This container defines ISIS Shortcuts configuration parameters", "id": "f22469:c1:m6"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/igp_shortcuts/afi/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: This container defines ISIS Shortcuts state information", "id": "f22469:c0:m9"}
{"signature": "def _get_afi_name(self):", "body": "return self.__afi_name<EOL>", "docstring": "Getter method for afi_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/igp_shortcuts/afi/afi_name (leafref)\n\nYANG Description: Reference to address-family type.", "id": "f22469:c0:m2"}
{"signature": "def _set_afi_name(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__afi_name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for afi_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/igp_shortcuts/afi/afi_name (leafref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_afi_name is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_afi_name() directly.\n\nYANG Description: Reference to address-family type.", "id": "f22469:c0:m3"}
{"signature": "def _set_afi(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>afi.afi,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__afi = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for afi, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/igp_shortcuts/afi (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_afi is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_afi() directly.\n\nYANG Description: Address-family list.", "id": "f22470:c1:m3"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/nsr/state/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: When set to true, the functionality within which this leaf is\ndefined is enabled, when set to false it is explicitly disabled.", "id": "f22471:c0:m3"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/nsr/state/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: When set to true, the functionality within which this leaf is\ndefined is enabled, when set to false it is explicitly disabled.", "id": "f22471:c1:m3"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/nsr/config/enabled (boolean)\n\n    YANG Description: When set to true, the functionality within which this leaf is\ndefined is enabled, when set to false it is explicitly disabled.", "id": "f22472:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/nsr/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: This container defines state for Non-Stop-Routing", "id": "f22473:c1:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/nsr/state (container)\n\nYANG Description: This container defines state for Non-Stop-Routing", "id": "f22473:c0:m5"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/nsr/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: This container defines Non-Stop-Routing configuration.", "id": "f22473:c1:m3"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/nsr/config (container)\n\nYANG Description: This container defines Non-Stop-Routing configuration.", "id": "f22473:c0:m2"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/nsr/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: This container defines Non-Stop-Routing configuration.", "id": "f22473:c0:m3"}
{"signature": "def _set_suppress_bit(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__suppress_bit = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for suppress_bit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/lsp_bit/attached_bit/state/suppress_bit (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_suppress_bit is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_suppress_bit() directly.\n\n    YANG Description: When set to true, if the local IS acts as a L1L2 router, then the\nattached bit is not advertised in locally generated PDUs.", "id": "f22474:c0:m6"}
{"signature": "def _set_ignore_bit(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ignore_bit = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ignore_bit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/lsp_bit/attached_bit/state/ignore_bit (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_ignore_bit is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_ignore_bit() directly.\n\n    YANG Description: When set to true, if the attached bit is set on an incoming Level 1\nIS-IS, the local system ignores it. In this case the local system\ndoes not set a default route to the L1L2 router advertising the PDU\nwith the attached bit set.", "id": "f22474:c1:m3"}
{"signature": "def _set_suppress_bit(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__suppress_bit = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for suppress_bit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/lsp_bit/attached_bit/config/suppress_bit (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_suppress_bit is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_suppress_bit() directly.\n\n    YANG Description: When set to true, if the local IS acts as a L1L2 router, then the\nattached bit is not advertised in locally generated PDUs.", "id": "f22475:c0:m6"}
{"signature": "def _set_ignore_bit(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ignore_bit = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ignore_bit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/lsp_bit/attached_bit/config/ignore_bit (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_ignore_bit is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_ignore_bit() directly.\n\n    YANG Description: When set to true, if the attached bit is set on an incoming Level 1\nIS-IS, the local system ignores it. In this case the local system\ndoes not set a default route to the L1L2 router advertising the PDU\nwith the attached bit set.", "id": "f22475:c0:m3"}
{"signature": "def _get_ignore_bit(self):", "body": "return self.__ignore_bit<EOL>", "docstring": "Getter method for ignore_bit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/lsp_bit/attached_bit/config/ignore_bit (boolean)\n\n    YANG Description: When set to true, if the attached bit is set on an incoming Level 1\nIS-IS, the local system ignores it. In this case the local system\ndoes not set a default route to the L1L2 router advertising the PDU\nwith the attached bit set.", "id": "f22475:c1:m2"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/lsp_bit/attached_bit/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: This container defines Attached Bit configuration.", "id": "f22476:c0:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/lsp_bit/attached_bit/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: This container defines state for Link State PDU Bit.", "id": "f22476:c0:m6"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/lsp_bit/attached_bit/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: This container defines Attached Bit configuration.", "id": "f22476:c1:m3"}
{"signature": "def _set_attached_bit(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=attached_bit.attached_bit,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__attached_bit = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for attached_bit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/lsp_bit/attached_bit (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_attached_bit is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_attached_bit() directly.\n\nYANG Description: This container defines Attached Bit.", "id": "f22477:c1:m6"}
{"signature": "def _get_overload_bit(self):", "body": "return self.__overload_bit<EOL>", "docstring": "Getter method for overload_bit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/lsp_bit/overload_bit (container)\n\nYANG Description: This container defines Overload Bit configuration.", "id": "f22477:c1:m2"}
{"signature": "def _set_attached_bit(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=attached_bit.attached_bit,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__attached_bit = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for attached_bit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/lsp_bit/attached_bit (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_attached_bit is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_attached_bit() directly.\n\nYANG Description: This container defines Attached Bit.", "id": "f22477:c0:m6"}
{"signature": "def _get_advertise_high_metric(self):", "body": "return self.__advertise_high_metric<EOL>", "docstring": "Getter method for advertise_high_metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/lsp_bit/overload_bit/state/advertise_high_metric (boolean)\n\n    YANG Description: When set to true, the local IS advertises links with the highest\navailable metric regardless of their configured metric. The metric\nvalue is based on the metric style - if wide metrics are utilised\nthe metric is advertised as 16777214, otherwise they are advertised\nwith a value of 63.", "id": "f22478:c1:m8"}
{"signature": "def _get_set_bit(self):", "body": "return self.__set_bit<EOL>", "docstring": "Getter method for set_bit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/lsp_bit/overload_bit/state/set_bit (boolean)\n\nYANG Description: When set to true, IS-IS overload bit is set.", "id": "f22478:c1:m2"}
{"signature": "def _set_set_bit(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__set_bit = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for set_bit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/lsp_bit/overload_bit/state/set_bit (boolean)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_set_bit is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_set_bit() directly.\n\nYANG Description: When set to true, IS-IS overload bit is set.", "id": "f22478:c0:m3"}
{"signature": "def _set_advertise_high_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__advertise_high_metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for advertise_high_metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/lsp_bit/overload_bit/state/advertise_high_metric (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_advertise_high_metric is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_advertise_high_metric() directly.\n\n    YANG Description: When set to true, the local IS advertises links with the highest\navailable metric regardless of their configured metric. The metric\nvalue is based on the metric style - if wide metrics are utilised\nthe metric is advertised as 16777214, otherwise they are advertised\nwith a value of 63.", "id": "f22478:c0:m9"}
{"signature": "def _set_advertise_high_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__advertise_high_metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for advertise_high_metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/lsp_bit/overload_bit/config/advertise_high_metric (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_advertise_high_metric is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_advertise_high_metric() directly.\n\n    YANG Description: When set to true, the local IS advertises links with the highest\navailable metric regardless of their configured metric. The metric\nvalue is based on the metric style - if wide metrics are utilised\nthe metric is advertised as 16777214, otherwise they are advertised\nwith a value of 63.", "id": "f22479:c1:m9"}
{"signature": "def _get_advertise_high_metric(self):", "body": "return self.__advertise_high_metric<EOL>", "docstring": "Getter method for advertise_high_metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/lsp_bit/overload_bit/config/advertise_high_metric (boolean)\n\n    YANG Description: When set to true, the local IS advertises links with the highest\navailable metric regardless of their configured metric. The metric\nvalue is based on the metric style - if wide metrics are utilised\nthe metric is advertised as 16777214, otherwise they are advertised\nwith a value of 63.", "id": "f22479:c1:m8"}
{"signature": "def _set_set_bit_on_boot(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__set_bit_on_boot = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for set_bit_on_boot, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/lsp_bit/overload_bit/config/set_bit_on_boot (boolean)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_set_bit_on_boot is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_set_bit_on_boot() directly.\n\nYANG Description: When set to true, the IS-IS overload bit is set on system boot.", "id": "f22479:c1:m6"}
{"signature": "def _get_set_bit(self):", "body": "return self.__set_bit<EOL>", "docstring": "Getter method for set_bit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/lsp_bit/overload_bit/config/set_bit (boolean)\n\nYANG Description: When set to true, IS-IS overload bit is set.", "id": "f22479:c1:m2"}
{"signature": "def _set_set_bit_on_boot(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__set_bit_on_boot = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for set_bit_on_boot, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/lsp_bit/overload_bit/config/set_bit_on_boot (boolean)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_set_bit_on_boot is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_set_bit_on_boot() directly.\n\nYANG Description: When set to true, the IS-IS overload bit is set on system boot.", "id": "f22479:c0:m6"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/lsp_bit/overload_bit/config (container)\n\nYANG Description: This container defines ISIS Overload Bit configuration.", "id": "f22480:c1:m2"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/lsp_bit/overload_bit/config (container)\n\nYANG Description: This container defines ISIS Overload Bit configuration.", "id": "f22480:c0:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/lsp_bit/overload_bit/state (container)\n\nYANG Description: This container defines state for ISIS Overload Bit.", "id": "f22480:c0:m5"}
{"signature": "def _get_reset_triggers(self):", "body": "return self.__reset_triggers<EOL>", "docstring": "Getter method for reset_triggers, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/lsp_bit/overload_bit/reset_triggers (container)\n\nYANG Description: This container defines state for ISIS Overload Bit reset triggers", "id": "f22480:c1:m8"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/lsp_bit/overload_bit/state (container)\n\nYANG Description: This container defines state for ISIS Overload Bit.", "id": "f22480:c1:m5"}
{"signature": "def _set_reset_triggers(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=reset_triggers.reset_triggers,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__reset_triggers = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for reset_triggers, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/lsp_bit/overload_bit/reset_triggers (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_reset_triggers is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_reset_triggers() directly.\n\nYANG Description: This container defines state for ISIS Overload Bit reset triggers", "id": "f22480:c1:m9"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/lsp_bit/overload_bit/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: This container defines ISIS Overload Bit configuration.", "id": "f22480:c0:m3"}
{"signature": "def _get_reset_trigger(self):", "body": "return self.__reset_trigger<EOL>", "docstring": "Getter method for reset_trigger, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/lsp_bit/overload_bit/reset_triggers/reset_trigger/state/reset_trigger (identityref)\n\n    YANG Description: In the case that the system sets the overload bit on start, the\nsystem should reset the bit (i.e., clear the overload bit) upon\nthe specified trigger.", "id": "f22482:c1:m2"}
{"signature": "def _get_reset_trigger(self):", "body": "return self.__reset_trigger<EOL>", "docstring": "Getter method for reset_trigger, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/lsp_bit/overload_bit/reset_triggers/reset_trigger/config/reset_trigger (identityref)\n\n    YANG Description: In the case that the system sets the overload bit on start, the\nsystem should reset the bit (i.e., clear the overload bit) upon\nthe specified trigger.", "id": "f22483:c1:m2"}
{"signature": "def _set_delay(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__delay = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for delay, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/lsp_bit/overload_bit/reset_triggers/reset_trigger/config/delay (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_delay is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_delay() directly.\n\n    YANG Description: If a reset trigger is specified, the system should delay resetting\nthe overload bit for the specified number of seconds after the\ntrigger occurs.", "id": "f22483:c0:m6"}
{"signature": "def _get_delay(self):", "body": "return self.__delay<EOL>", "docstring": "Getter method for delay, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/lsp_bit/overload_bit/reset_triggers/reset_trigger/config/delay (uint16)\n\n    YANG Description: If a reset trigger is specified, the system should delay resetting\nthe overload bit for the specified number of seconds after the\ntrigger occurs.", "id": "f22483:c0:m5"}
{"signature": "def _get_reset_trigger(self):", "body": "return self.__reset_trigger<EOL>", "docstring": "Getter method for reset_trigger, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/lsp_bit/overload_bit/reset_triggers/reset_trigger/config/reset_trigger (identityref)\n\n    YANG Description: In the case that the system sets the overload bit on start, the\nsystem should reset the bit (i.e., clear the overload bit) upon\nthe specified trigger.", "id": "f22483:c0:m2"}
{"signature": "def _set_reset_trigger(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__reset_trigger = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for reset_trigger, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/lsp_bit/overload_bit/reset_triggers/reset_trigger/config/reset_trigger (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_reset_trigger is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_reset_trigger() directly.\n\n    YANG Description: In the case that the system sets the overload bit on start, the\nsystem should reset the bit (i.e., clear the overload bit) upon\nthe specified trigger.", "id": "f22483:c0:m3"}
{"signature": "def _get_reset_trigger(self):", "body": "return self.__reset_trigger<EOL>", "docstring": "Getter method for reset_trigger, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/lsp_bit/overload_bit/reset_triggers/reset_trigger/reset_trigger (leafref)\n\nYANG Description: Reference to the reset trigger reason", "id": "f22484:c1:m2"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/lsp_bit/overload_bit/reset_triggers/reset_trigger/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: This container defines ISIS Overload Bit reset trigger\nconfiguration.", "id": "f22484:c0:m6"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/lsp_bit/overload_bit/reset_triggers/reset_trigger/config (container)\n\n    YANG Description: This container defines ISIS Overload Bit reset trigger\nconfiguration.", "id": "f22484:c1:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/lsp_bit/overload_bit/reset_triggers/reset_trigger/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: This container defines state for ISIS Overload Bit reset\ntriggers.", "id": "f22484:c1:m9"}
{"signature": "def _set_adaptive_timer(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__adaptive_timer = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for adaptive_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/timers/lsp_generation/state/adaptive_timer (oc-isis-types:adaptive-timer-type)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_adaptive_timer is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_adaptive_timer() directly.\n\nYANG Description: ISIS adaptive timer types (linear, exponential).", "id": "f22485:c0:m12"}
{"signature": "def _set_lsp_first_wait_interval(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__lsp_first_wait_interval = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for lsp_first_wait_interval, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/timers/lsp_generation/state/lsp_first_wait_interval (uint64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_lsp_first_wait_interval is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_lsp_first_wait_interval() directly.\n\n    YANG Description: Time interval in milliseconds that specifies the first LSP generation\ndelay.", "id": "f22485:c0:m6"}
{"signature": "def _set_lsp_max_wait_interval(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__lsp_max_wait_interval = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for lsp_max_wait_interval, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/timers/lsp_generation/state/lsp_max_wait_interval (uint64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_lsp_max_wait_interval is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_lsp_max_wait_interval() directly.\n\n    YANG Description: Time interval in milliseconds that specifies max interval between\ntwo consecutive occurrences of an LSP being generated.", "id": "f22485:c0:m3"}
{"signature": "def _get_lsp_second_wait_interval(self):", "body": "return self.__lsp_second_wait_interval<EOL>", "docstring": "Getter method for lsp_second_wait_interval, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/timers/lsp_generation/config/lsp_second_wait_interval (uint64)\n\n    YANG Description: Time interval in milliseconds that specifies the millisecond LSP\ngeneration delay.", "id": "f22486:c0:m8"}
{"signature": "def _get_lsp_first_wait_interval(self):", "body": "return self.__lsp_first_wait_interval<EOL>", "docstring": "Getter method for lsp_first_wait_interval, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/timers/lsp_generation/config/lsp_first_wait_interval (uint64)\n\n    YANG Description: Time interval in milliseconds that specifies the first LSP generation\ndelay.", "id": "f22486:c1:m5"}
{"signature": "def _set_lsp_first_wait_interval(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__lsp_first_wait_interval = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for lsp_first_wait_interval, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/timers/lsp_generation/config/lsp_first_wait_interval (uint64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_lsp_first_wait_interval is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_lsp_first_wait_interval() directly.\n\n    YANG Description: Time interval in milliseconds that specifies the first LSP generation\ndelay.", "id": "f22486:c0:m6"}
{"signature": "def _get_lsp_max_wait_interval(self):", "body": "return self.__lsp_max_wait_interval<EOL>", "docstring": "Getter method for lsp_max_wait_interval, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/timers/lsp_generation/config/lsp_max_wait_interval (uint64)\n\n    YANG Description: Time interval in milliseconds that specifies max interval between\ntwo consecutive occurrences of an LSP being generated.", "id": "f22486:c0:m2"}
{"signature": "def _get_lsp_first_wait_interval(self):", "body": "return self.__lsp_first_wait_interval<EOL>", "docstring": "Getter method for lsp_first_wait_interval, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/timers/lsp_generation/config/lsp_first_wait_interval (uint64)\n\n    YANG Description: Time interval in milliseconds that specifies the first LSP generation\ndelay.", "id": "f22486:c0:m5"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/timers/lsp_generation/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: This container defines ISIS LSP Generation timers\nconfiguration.", "id": "f22487:c1:m3"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/timers/lsp_generation/config (container)\n\n    YANG Description: This container defines ISIS LSP Generation timers\nconfiguration.", "id": "f22487:c1:m2"}
{"signature": "def _set_lsp_lifetime_interval(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>default=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>)(<EOL><NUM_LIT><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__lsp_lifetime_interval = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for lsp_lifetime_interval, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/timers/state/lsp_lifetime_interval (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_lsp_lifetime_interval is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_lsp_lifetime_interval() directly.\n\n    YANG Description: Time interval in seconds that specifies how long an LSP remains in\nLSDB without being refreshed.", "id": "f22488:c0:m3"}
{"signature": "def _get_lsp_lifetime_interval(self):", "body": "return self.__lsp_lifetime_interval<EOL>", "docstring": "Getter method for lsp_lifetime_interval, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/timers/state/lsp_lifetime_interval (uint16)\n\n    YANG Description: Time interval in seconds that specifies how long an LSP remains in\nLSDB without being refreshed.", "id": "f22488:c0:m2"}
{"signature": "def _get_lsp_refresh_interval(self):", "body": "return self.__lsp_refresh_interval<EOL>", "docstring": "Getter method for lsp_refresh_interval, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/timers/config/lsp_refresh_interval (uint16)\n\n    YANG Description: Time interval in seconds that specifies how often route topology\nthat a device originates is transmitted in LSPs.", "id": "f22489:c1:m5"}
{"signature": "def _get_lsp_lifetime_interval(self):", "body": "return self.__lsp_lifetime_interval<EOL>", "docstring": "Getter method for lsp_lifetime_interval, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/timers/config/lsp_lifetime_interval (uint16)\n\n    YANG Description: Time interval in seconds that specifies how long an LSP remains in\nLSDB without being refreshed.", "id": "f22489:c0:m2"}
{"signature": "def _get_adaptive_timer(self):", "body": "return self.__adaptive_timer<EOL>", "docstring": "Getter method for adaptive_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/timers/spf/state/adaptive_timer (oc-isis-types:adaptive-timer-type)\n\nYANG Description: ISIS adaptive timer types (linear, exponential).", "id": "f22490:c0:m11"}
{"signature": "def _get_spf_hold_interval(self):", "body": "return self.__spf_hold_interval<EOL>", "docstring": "Getter method for spf_hold_interval, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/timers/spf/state/spf_hold_interval (uint64)\n\nYANG Description: SPF Hold Down time interval in milliseconds.", "id": "f22490:c1:m2"}
{"signature": "def _get_spf_second_interval(self):", "body": "return self.__spf_second_interval<EOL>", "docstring": "Getter method for spf_second_interval, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/timers/spf/state/spf_second_interval (uint64)\n\n    YANG Description: Time interval in milliseconds between the first and second\nSPF calculation.", "id": "f22490:c0:m8"}
{"signature": "def _set_spf_second_interval(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__spf_second_interval = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for spf_second_interval, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/timers/spf/state/spf_second_interval (uint64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_spf_second_interval is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_spf_second_interval() directly.\n\n    YANG Description: Time interval in milliseconds between the first and second\nSPF calculation.", "id": "f22490:c1:m9"}
{"signature": "def _get_spf_hold_interval(self):", "body": "return self.__spf_hold_interval<EOL>", "docstring": "Getter method for spf_hold_interval, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/timers/spf/config/spf_hold_interval (uint64)\n\nYANG Description: SPF Hold Down time interval in milliseconds.", "id": "f22491:c0:m2"}
{"signature": "def _set_spf_first_interval(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__spf_first_interval = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for spf_first_interval, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/timers/spf/config/spf_first_interval (uint64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_spf_first_interval is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_spf_first_interval() directly.\n\n    YANG Description: Time interval in milliseconds between the\ndetection of topology change and when the SPF algorithm runs.", "id": "f22491:c1:m6"}
{"signature": "def _get_spf_second_interval(self):", "body": "return self.__spf_second_interval<EOL>", "docstring": "Getter method for spf_second_interval, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/timers/spf/config/spf_second_interval (uint64)\n\n    YANG Description: Time interval in milliseconds between the first and second\nSPF calculation.", "id": "f22491:c0:m8"}
{"signature": "def _get_spf_first_interval(self):", "body": "return self.__spf_first_interval<EOL>", "docstring": "Getter method for spf_first_interval, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/timers/spf/config/spf_first_interval (uint64)\n\n    YANG Description: Time interval in milliseconds between the\ndetection of topology change and when the SPF algorithm runs.", "id": "f22491:c0:m5"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/timers/spf/config (container)\n\nYANG Description: This container defines ISIS SPF timers configuration.", "id": "f22492:c0:m2"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/timers/spf/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: This container defines ISIS SPF timers configuration.", "id": "f22492:c1:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/timers/spf/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: This container defines state information for ISIS SPF timers.", "id": "f22492:c1:m6"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/timers/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: This container defines state information for ISIS global timers.", "id": "f22493:c0:m6"}
{"signature": "def _set_import_policy(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(allowed_type=six.text_type),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__import_policy = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for import_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/inter_level_propagation_policies/level1_to_level2/state/import_policy (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_import_policy is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_import_policy() directly.\n\n    YANG Description: list of policy names in sequence to be applied on\nreceiving a routing update in the current context, e.g.,\nfor the current peer group, neighbor, address family,\netc.", "id": "f22494:c1:m3"}
{"signature": "def _get_default_import_policy(self):", "body": "return self.__default_import_policy<EOL>", "docstring": "Getter method for default_import_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/inter_level_propagation_policies/level1_to_level2/config/default_import_policy (default-policy-type)\n\n    YANG Description: explicitly set a default policy if no policy definition\nin the import policy chain is satisfied.", "id": "f22495:c1:m5"}
{"signature": "def _get_import_policy(self):", "body": "return self.__import_policy<EOL>", "docstring": "Getter method for import_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/inter_level_propagation_policies/level1_to_level2/config/import_policy (leafref)\n\n    YANG Description: list of policy names in sequence to be applied on\nreceiving a routing update in the current context, e.g.,\nfor the current peer group, neighbor, address family,\netc.", "id": "f22495:c0:m2"}
{"signature": "def _get_default_import_policy(self):", "body": "return self.__default_import_policy<EOL>", "docstring": "Getter method for default_import_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/inter_level_propagation_policies/level1_to_level2/config/default_import_policy (default-policy-type)\n\n    YANG Description: explicitly set a default policy if no policy definition\nin the import policy chain is satisfied.", "id": "f22495:c0:m5"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/inter_level_propagation_policies/level1_to_level2/state (container)\n\n    YANG Description: Operational state parameters relating to the\npropagation of prefixes from IS-IS Level 1 to Level 2.", "id": "f22496:c0:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/inter_level_propagation_policies/level1_to_level2/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: Operational state parameters relating to the\npropagation of prefixes from IS-IS Level 1 to Level 2.", "id": "f22496:c0:m6"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/inter_level_propagation_policies/level1_to_level2/config (container)\n\n    YANG Description: Configuration parameters relating to the propagation\nof prefixes from IS-IS Level 1 to Level 2.", "id": "f22496:c0:m2"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/inter_level_propagation_policies/level1_to_level2/config (container)\n\n    YANG Description: Configuration parameters relating to the propagation\nof prefixes from IS-IS Level 1 to Level 2.", "id": "f22496:c1:m2"}
{"signature": "def _get_import_policy(self):", "body": "return self.__import_policy<EOL>", "docstring": "Getter method for import_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/inter_level_propagation_policies/level2_to_level1/config/import_policy (leafref)\n\n    YANG Description: list of policy names in sequence to be applied on\nreceiving a routing update in the current context, e.g.,\nfor the current peer group, neighbor, address family,\netc.", "id": "f22498:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/inter_level_propagation_policies/level2_to_level1/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: Operational state parameters relating to the propagation\nof prefixes from IS-IS Level 2 to Level 1.", "id": "f22499:c1:m6"}
{"signature": "def _get_level1_to_level2(self):", "body": "return self.__level1_to_level2<EOL>", "docstring": "Getter method for level1_to_level2, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/inter_level_propagation_policies/level1_to_level2 (container)\n\n    YANG Description: Policies relating to prefixes to be propagated from\nLevel 1 to Level 2.", "id": "f22500:c0:m2"}
{"signature": "def _set_level2_to_level1(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=level2_to_level1.level2_to_level1,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__level2_to_level1 = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for level2_to_level1, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/inter_level_propagation_policies/level2_to_level1 (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_level2_to_level1 is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_level2_to_level1() directly.\n\n    YANG Description: Policies relating to prefixes to be propagated from\nLevel2 to Level 1.", "id": "f22500:c1:m6"}
{"signature": "def _get_level1_to_level2(self):", "body": "return self.__level1_to_level2<EOL>", "docstring": "Getter method for level1_to_level2, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/inter_level_propagation_policies/level1_to_level2 (container)\n\n    YANG Description: Policies relating to prefixes to be propagated from\nLevel 1 to Level 2.", "id": "f22500:c1:m2"}
{"signature": "def _get_level2_to_level1(self):", "body": "return self.__level2_to_level1<EOL>", "docstring": "Getter method for level2_to_level1, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/inter_level_propagation_policies/level2_to_level1 (container)\n\n    YANG Description: Policies relating to prefixes to be propagated from\nLevel2 to Level 1.", "id": "f22500:c1:m5"}
{"signature": "def _set_iid_tlv(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__iid_tlv = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for iid_tlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/config/iid_tlv (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_iid_tlv is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_iid_tlv() directly.\n\n    YANG Description: ISIS Instance Identifier TLV. When set to trues, the IID-TLV identifies\nthe unique instance as well as the topology/topologies to which the\nPDU applies.", "id": "f22501:c1:m24"}
{"signature": "def _get_fast_flooding(self):", "body": "return self.__fast_flooding<EOL>", "docstring": "Getter method for fast_flooding, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/config/fast_flooding (boolean)\n\n    YANG Description: When set to true, IS will always flood the LSP that triggered an SPF\nbefore the router actually runs the SPF computation.", "id": "f22501:c1:m26"}
{"signature": "def _get_instance(self):", "body": "return self.__instance<EOL>", "docstring": "Getter method for instance, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/config/instance (string)\n\nYANG Description: ISIS Instance.", "id": "f22501:c0:m5"}
{"signature": "def _get_fast_flooding(self):", "body": "return self.__fast_flooding<EOL>", "docstring": "Getter method for fast_flooding, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/config/fast_flooding (boolean)\n\n    YANG Description: When set to true, IS will always flood the LSP that triggered an SPF\nbefore the router actually runs the SPF computation.", "id": "f22501:c0:m26"}
{"signature": "def _get_poi_tlv(self):", "body": "return self.__poi_tlv<EOL>", "docstring": "Getter method for poi_tlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/config/poi_tlv (boolean)\n\n    YANG Description: ISIS purge TLV. When set to true, a TLV is added to purges to record\nthe system ID  of the IS generating the purge.", "id": "f22501:c1:m20"}
{"signature": "def _set_authentication_check(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:true>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__authentication_check = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for authentication_check, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/config/authentication_check (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_authentication_check is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_authentication_check() directly.\n\n    YANG Description: When set to true, reject all ISIS protocol PDUs that either have a mismatch\nin authentication-type or authentication-key.", "id": "f22501:c0:m3"}
{"signature": "def _set_authentication_check(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:true>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__authentication_check = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for authentication_check, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/config/authentication_check (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_authentication_check is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_authentication_check() directly.\n\n    YANG Description: When set to true, reject all ISIS protocol PDUs that either have a mismatch\nin authentication-type or authentication-key.", "id": "f22501:c1:m3"}
{"signature": "def _get_level_capability(self):", "body": "return self.__level_capability<EOL>", "docstring": "Getter method for level_capability, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/config/level_capability (oc-isis-types:level-type)\n\nYANG Description: ISIS level capability(level-1, level-2,vlevel-1-2).", "id": "f22501:c0:m14"}
{"signature": "def _set_net(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__net = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for net, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/config/net (oc-isis-types:net)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_net is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_net() directly.\n\n    YANG Description: ISIS network entity title (NET). The first 8 bits are usually\n49 (private AFI), next 16 bits represent area, next 48 bits represent\nsystem id and final 8 bits are set to 0.", "id": "f22501:c0:m9"}
{"signature": "def _set_instance(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>default=six.text_type(\"<STR_LIT:0>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__instance = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for instance, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/config/instance (string)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_instance is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_instance() directly.\n\nYANG Description: ISIS Instance.", "id": "f22501:c0:m6"}
{"signature": "def _set_level_capability(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>default=six.text_type(\"<STR_LIT>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__level_capability = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for level_capability, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/config/level_capability (oc-isis-types:level-type)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_level_capability is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_level_capability() directly.\n\nYANG Description: ISIS level capability(level-1, level-2,vlevel-1-2).", "id": "f22501:c1:m15"}
{"signature": "def _get_authentication_check(self):", "body": "return self.__authentication_check<EOL>", "docstring": "Getter method for authentication_check, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/config/authentication_check (boolean)\n\n    YANG Description: When set to true, reject all ISIS protocol PDUs that either have a mismatch\nin authentication-type or authentication-key.", "id": "f22501:c0:m2"}
{"signature": "def _get_net(self):", "body": "return self.__net<EOL>", "docstring": "Getter method for net, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/config/net (oc-isis-types:net)\n\n    YANG Description: ISIS network entity title (NET). The first 8 bits are usually\n49 (private AFI), next 16 bits represent area, next 48 bits represent\nsystem id and final 8 bits are set to 0.", "id": "f22501:c0:m8"}
{"signature": "def _get_igp_ldp_sync(self):", "body": "return self.__igp_ldp_sync<EOL>", "docstring": "Getter method for igp_ldp_sync, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/mpls/igp_ldp_sync (container)\n\n    YANG Description: Configuration and operational state relating to synchronisation\nbetween the LDP and IS-IS", "id": "f22502:c0:m2"}
{"signature": "def _set_igp_ldp_sync(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=igp_ldp_sync.igp_ldp_sync,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__igp_ldp_sync = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for igp_ldp_sync, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/mpls/igp_ldp_sync (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_igp_ldp_sync is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_igp_ldp_sync() directly.\n\n    YANG Description: Configuration and operational state relating to synchronisation\nbetween the LDP and IS-IS", "id": "f22502:c0:m3"}
{"signature": "def _get_post_session_up_delay(self):", "body": "return self.__post_session_up_delay<EOL>", "docstring": "Getter method for post_session_up_delay, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/mpls/igp_ldp_sync/state/post_session_up_delay (uint16)\n\n    YANG Description: Specifies a delay, expressed in units of seconds,\nbetween the LDP session to the IGP neighbor being established, and\nit being considered synchronized by the IGP.", "id": "f22503:c1:m5"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:true>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/mpls/igp_ldp_sync/state/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: When set to true, rely on IGP/LDP synchronization. IGP cost for\nlink is maintained at max until LDP adjacencies are established", "id": "f22503:c0:m3"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:true>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/mpls/igp_ldp_sync/state/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: When set to true, rely on IGP/LDP synchronization. IGP cost for\nlink is maintained at max until LDP adjacencies are established", "id": "f22503:c1:m3"}
{"signature": "def _get_post_session_up_delay(self):", "body": "return self.__post_session_up_delay<EOL>", "docstring": "Getter method for post_session_up_delay, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/mpls/igp_ldp_sync/state/post_session_up_delay (uint16)\n\n    YANG Description: Specifies a delay, expressed in units of seconds,\nbetween the LDP session to the IGP neighbor being established, and\nit being considered synchronized by the IGP.", "id": "f22503:c0:m5"}
{"signature": "def _set_post_session_up_delay(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__post_session_up_delay = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for post_session_up_delay, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/mpls/igp_ldp_sync/state/post_session_up_delay (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_post_session_up_delay is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_post_session_up_delay() directly.\n\n    YANG Description: Specifies a delay, expressed in units of seconds,\nbetween the LDP session to the IGP neighbor being established, and\nit being considered synchronized by the IGP.", "id": "f22503:c1:m6"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/mpls/igp_ldp_sync/config (container)\n\nYANG Description: This container defines ISIS/IGP configuration.", "id": "f22505:c1:m2"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/mpls/igp_ldp_sync/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: This container defines ISIS/IGP configuration.", "id": "f22505:c1:m3"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/mpls/igp_ldp_sync/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: This container defines ISIS/IGP configuration.", "id": "f22505:c0:m3"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/mpls/igp_ldp_sync/config (container)\n\nYANG Description: This container defines ISIS/IGP configuration.", "id": "f22505:c0:m2"}
{"signature": "def _get_lsp_bit(self):", "body": "return self.__lsp_bit<EOL>", "docstring": "Getter method for lsp_bit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/lsp_bit (container)\n\nYANG Description: This container defines ISIS LSP Operational Bits.", "id": "f22506:c0:m8"}
{"signature": "def _get_transport(self):", "body": "return self.__transport<EOL>", "docstring": "Getter method for transport, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/transport (container)\n\nYANG Description: This container defines ISIS transport.", "id": "f22506:c1:m23"}
{"signature": "def _get_afi_safi(self):", "body": "return self.__afi_safi<EOL>", "docstring": "Getter method for afi_safi, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/afi_safi (container)\n\n    YANG Description: This container defines address-family specific configuration\nand state information.", "id": "f22506:c1:m32"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: This container defines state for ISIS global router.", "id": "f22506:c1:m6"}
{"signature": "def _get_mpls(self):", "body": "return self.__mpls<EOL>", "docstring": "Getter method for mpls, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/mpls (container)\n\n    YANG Description: Configuration and operational state relating to MPLS-related\nfeatures in IS-IS", "id": "f22506:c1:m26"}
{"signature": "def _get_inter_level_propagation_policies(self):", "body": "return self.__inter_level_propagation_policies<EOL>", "docstring": "Getter method for inter_level_propagation_policies, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/inter_level_propagation_policies (container)\n\nYANG Description: Policies to propagate prefixes between IS-IS levels.", "id": "f22506:c1:m38"}
{"signature": "def _get_igp_shortcuts(self):", "body": "return self.__igp_shortcuts<EOL>", "docstring": "Getter method for igp_shortcuts, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/igp_shortcuts (container)\n\n    YANG Description: This container defines IGP shortcuts configuration and state\ninformation.", "id": "f22506:c0:m29"}
{"signature": "def _get_transport(self):", "body": "return self.__transport<EOL>", "docstring": "Getter method for transport, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/transport (container)\n\nYANG Description: This container defines ISIS transport.", "id": "f22506:c0:m23"}
{"signature": "def _set_reference_bandwidth(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=reference_bandwidth.reference_bandwidth,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__reference_bandwidth = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for reference_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/reference_bandwidth (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_reference_bandwidth is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_reference_bandwidth() directly.\n\nYANG Description: This container defines ISIS Reference Bandwidth.", "id": "f22506:c0:m12"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/config (container)\n\nYANG Description: This container defines ISIS global configuration router.", "id": "f22506:c0:m2"}
{"signature": "def _set_graceful_restart(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=graceful_restart.graceful_restart,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__graceful_restart = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for graceful_restart, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/graceful_restart (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_graceful_restart is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_graceful_restart() directly.\n\nYANG Description: This container defines ISIS Graceful Restart.", "id": "f22506:c1:m18"}
{"signature": "def _set_mpls(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=mpls.mpls,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__mpls = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for mpls, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/mpls (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_mpls is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_mpls() directly.\n\n    YANG Description: Configuration and operational state relating to MPLS-related\nfeatures in IS-IS", "id": "f22506:c0:m27"}
{"signature": "def _get_lsp_bit(self):", "body": "return self.__lsp_bit<EOL>", "docstring": "Getter method for lsp_bit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/lsp_bit (container)\n\nYANG Description: This container defines ISIS LSP Operational Bits.", "id": "f22506:c1:m8"}
{"signature": "def _set_inter_level_propagation_policies(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=inter_level_propagation_policies.inter_level_propagation_policies,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__inter_level_propagation_policies = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for inter_level_propagation_policies, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/inter_level_propagation_policies (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_inter_level_propagation_policies is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_inter_level_propagation_policies() directly.\n\nYANG Description: Policies to propagate prefixes between IS-IS levels.", "id": "f22506:c1:m39"}
{"signature": "def _get_nsr(self):", "body": "return self.__nsr<EOL>", "docstring": "Getter method for nsr, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/nsr (container)\n\nYANG Description: This container defines ISIS Non-Stop Routing.", "id": "f22506:c0:m14"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/segment_routing/state/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: When this leaf is set to true, the segment routing extensions are\nutilised within the IGP.", "id": "f22507:c1:m3"}
{"signature": "def _get_srlb(self):", "body": "return self.__srlb<EOL>", "docstring": "Getter method for srlb, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/segment_routing/state/srlb (leafref)\n\n    YANG Description: A reference to the Segment Routing Local Block (SRLB) that is to\nbe advertised by the IGP instance.", "id": "f22507:c0:m8"}
{"signature": "def _get_srlb(self):", "body": "return self.__srlb<EOL>", "docstring": "Getter method for srlb, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/segment_routing/state/srlb (leafref)\n\n    YANG Description: A reference to the Segment Routing Local Block (SRLB) that is to\nbe advertised by the IGP instance.", "id": "f22507:c1:m8"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/segment_routing/state/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: When this leaf is set to true, the segment routing extensions are\nutilised within the IGP.", "id": "f22507:c0:m3"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/segment_routing/config/enabled (boolean)\n\n    YANG Description: When this leaf is set to true, the segment routing extensions are\nutilised within the IGP.", "id": "f22508:c0:m2"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/segment_routing/config/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: When this leaf is set to true, the segment routing extensions are\nutilised within the IGP.", "id": "f22508:c1:m3"}
{"signature": "def _set_srgb(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__srgb = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for srgb, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/segment_routing/config/srgb (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_srgb is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_srgb() directly.\n\n    YANG Description: A reference to the Segment Routing Global Block (SRGB) that is\nto be used by this IGP instance.", "id": "f22508:c0:m6"}
{"signature": "def _set_srgb(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__srgb = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for srgb, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/segment_routing/config/srgb (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_srgb is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_srgb() directly.\n\n    YANG Description: A reference to the Segment Routing Global Block (SRGB) that is\nto be used by this IGP instance.", "id": "f22508:c1:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/segment_routing/state (container)\n\n    YANG Description: Operational state parameters relating to segment routing for the\nIGP instance.", "id": "f22509:c0:m5"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/segment_routing/config (container)\n\n    YANG Description: Configuration parameters relating to the configuration of segment\nrouting for the IGP instance.", "id": "f22509:c0:m2"}
{"signature": "def _get_af(self):", "body": "return self.__af<EOL>", "docstring": "Getter method for af, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/afi_safi/af (list)\n\nYANG Description: Address-family/Subsequent Address-family list.", "id": "f22510:c1:m2"}
{"signature": "def _get_afi_name(self):", "body": "return self.__afi_name<EOL>", "docstring": "Getter method for afi_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/afi_safi/af/state/afi_name (identityref)\n\nYANG Description: Address-family type.", "id": "f22511:c0:m2"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/afi_safi/af/state/enabled (boolean)\n\n    YANG Description: When set to true, the functionality within which this leaf is\ndefined is enabled, when set to false it is explicitly disabled.", "id": "f22511:c0:m11"}
{"signature": "def _set_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>default=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>)(<EOL><NUM_LIT:10><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/afi_safi/af/state/metric (uint32)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_metric is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_metric() directly.\n\nYANG Description: ISIS metric value(default=10).", "id": "f22511:c1:m9"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/afi_safi/af/state/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: When set to true, the functionality within which this leaf is\ndefined is enabled, when set to false it is explicitly disabled.", "id": "f22511:c1:m12"}
{"signature": "def _get_afi_name(self):", "body": "return self.__afi_name<EOL>", "docstring": "Getter method for afi_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/afi_safi/af/state/afi_name (identityref)\n\nYANG Description: Address-family type.", "id": "f22511:c1:m2"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/afi_safi/af/state/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: When set to true, the functionality within which this leaf is\ndefined is enabled, when set to false it is explicitly disabled.", "id": "f22511:c0:m12"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/afi_safi/af/state/enabled (boolean)\n\n    YANG Description: When set to true, the functionality within which this leaf is\ndefined is enabled, when set to false it is explicitly disabled.", "id": "f22511:c1:m11"}
{"signature": "def _set_safi_name(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__safi_name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for safi_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/afi_safi/af/state/safi_name (identityref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_safi_name is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_safi_name() directly.\n\nYANG Description: Subsequent address-family type.", "id": "f22511:c1:m6"}
{"signature": "def _get_metric(self):", "body": "return self.__metric<EOL>", "docstring": "Getter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/afi_safi/af/state/metric (uint32)\n\nYANG Description: ISIS metric value(default=10).", "id": "f22511:c1:m8"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/afi_safi/af/config/enabled (boolean)\n\n    YANG Description: When set to true, the functionality within which this leaf is\ndefined is enabled, when set to false it is explicitly disabled.", "id": "f22512:c0:m11"}
{"signature": "def _set_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>default=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>)(<EOL><NUM_LIT:10><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/afi_safi/af/config/metric (uint32)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_metric is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_metric() directly.\n\nYANG Description: ISIS metric value(default=10).", "id": "f22512:c0:m9"}
{"signature": "def _set_afi_name(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__afi_name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for afi_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/afi_safi/af/config/afi_name (identityref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_afi_name is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_afi_name() directly.\n\nYANG Description: Address-family type.", "id": "f22512:c1:m3"}
{"signature": "def _set_safi_name(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__safi_name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for safi_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/afi_safi/af/config/safi_name (identityref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_safi_name is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_safi_name() directly.\n\nYANG Description: Subsequent address-family type.", "id": "f22512:c0:m6"}
{"signature": "def _get_afi_name(self):", "body": "return self.__afi_name<EOL>", "docstring": "Getter method for afi_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/afi_safi/af/config/afi_name (identityref)\n\nYANG Description: Address-family type.", "id": "f22512:c0:m2"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/afi_safi/af/config/enabled (boolean)\n\n    YANG Description: When set to true, the functionality within which this leaf is\ndefined is enabled, when set to false it is explicitly disabled.", "id": "f22512:c1:m11"}
{"signature": "def _set_safi_name(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__safi_name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for safi_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/afi_safi/af/config/safi_name (identityref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_safi_name is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_safi_name() directly.\n\nYANG Description: Subsequent address-family type.", "id": "f22512:c1:m6"}
{"signature": "def _set_multi_topology(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=multi_topology.multi_topology,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__multi_topology = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for multi_topology, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/afi_safi/af/multi_topology (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_multi_topology is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_multi_topology() directly.\n\n    YANG Description: This container defines multi-topology address-family configuration\nand state information. ISIS TLV 235, 237.", "id": "f22513:c0:m15"}
{"signature": "def _set_safi_name(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__safi_name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for safi_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/afi_safi/af/safi_name (leafref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_safi_name is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_safi_name() directly.\n\nYANG Description: Reference to subsequent address-family type", "id": "f22513:c1:m6"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/afi_safi/af/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: This container defines AFI-SAFI configuration parameters", "id": "f22513:c1:m9"}
{"signature": "def _set_safi_name(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__safi_name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for safi_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/afi_safi/af/safi_name (leafref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_safi_name is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_safi_name() directly.\n\nYANG Description: Reference to subsequent address-family type", "id": "f22513:c0:m6"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/afi_safi/af/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: This container defines AFI-SAFI configuration parameters", "id": "f22513:c0:m9"}
{"signature": "def _set_afi_name(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__afi_name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for afi_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/afi_safi/af/multi_topology/state/afi_name (identityref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_afi_name is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_afi_name() directly.\n\nYANG Description: Address-family type.", "id": "f22514:c1:m3"}
{"signature": "def _get_afi_name(self):", "body": "return self.__afi_name<EOL>", "docstring": "Getter method for afi_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/afi_safi/af/multi_topology/state/afi_name (identityref)\n\nYANG Description: Address-family type.", "id": "f22514:c0:m2"}
{"signature": "def _get_safi_name(self):", "body": "return self.__safi_name<EOL>", "docstring": "Getter method for safi_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/afi_safi/af/multi_topology/state/safi_name (identityref)\n\nYANG Description: Subsequent address-family type.", "id": "f22514:c1:m5"}
{"signature": "def _set_afi_name(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__afi_name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for afi_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/afi_safi/af/multi_topology/state/afi_name (identityref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_afi_name is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_afi_name() directly.\n\nYANG Description: Address-family type.", "id": "f22514:c0:m3"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/afi_safi/af/multi_topology/state/enabled (boolean)\n\n    YANG Description: When set to true, the functionality within which this leaf is\ndefined is enabled, when set to false it is explicitly disabled.", "id": "f22514:c0:m8"}
{"signature": "def _set_safi_name(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__safi_name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for safi_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/afi_safi/af/multi_topology/state/safi_name (identityref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_safi_name is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_safi_name() directly.\n\nYANG Description: Subsequent address-family type.", "id": "f22514:c0:m6"}
{"signature": "def _set_afi_name(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__afi_name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for afi_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/afi_safi/af/multi_topology/config/afi_name (identityref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_afi_name is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_afi_name() directly.\n\nYANG Description: Address-family type.", "id": "f22515:c1:m3"}
{"signature": "def _get_afi_name(self):", "body": "return self.__afi_name<EOL>", "docstring": "Getter method for afi_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/afi_safi/af/multi_topology/config/afi_name (identityref)\n\nYANG Description: Address-family type.", "id": "f22515:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/afi_safi/af/multi_topology/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: This container defines AFI-SAFI multi-topology state information", "id": "f22516:c0:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/transport/state (container)\n\n    YANG Description: This container defines state information for ISIS transport\nparameters.", "id": "f22519:c0:m5"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/transport/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: This container defines ISIS transport related configuration.", "id": "f22519:c1:m3"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/transport/config (container)\n\nYANG Description: This container defines ISIS transport related configuration.", "id": "f22519:c0:m2"}
{"signature": "def _get_reference_bandwidth(self):", "body": "return self.__reference_bandwidth<EOL>", "docstring": "Getter method for reference_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/reference_bandwidth/state/reference_bandwidth (uint32)\n\nYANG Description: ISIS Reference Bandwidth value", "id": "f22520:c0:m2"}
{"signature": "def _set_reference_bandwidth(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__reference_bandwidth = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for reference_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/reference_bandwidth/state/reference_bandwidth (uint32)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_reference_bandwidth is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_reference_bandwidth() directly.\n\nYANG Description: ISIS Reference Bandwidth value", "id": "f22520:c1:m3"}
{"signature": "def _set_reference_bandwidth(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__reference_bandwidth = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for reference_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/reference_bandwidth/config/reference_bandwidth (uint32)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_reference_bandwidth is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_reference_bandwidth() directly.\n\nYANG Description: ISIS Reference Bandwidth value", "id": "f22521:c1:m3"}
{"signature": "def _set_reference_bandwidth(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__reference_bandwidth = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for reference_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/reference_bandwidth/config/reference_bandwidth (uint32)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_reference_bandwidth is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_reference_bandwidth() directly.\n\nYANG Description: ISIS Reference Bandwidth value", "id": "f22521:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/reference_bandwidth/state (container)\n\nYANG Description: This container defines state for Reference Bandwidth.", "id": "f22522:c0:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/reference_bandwidth/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: This container defines state for Reference Bandwidth.", "id": "f22522:c0:m6"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/reference_bandwidth/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: This container defines Reference Bandwidth configuration", "id": "f22522:c1:m3"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/global/reference_bandwidth/config (container)\n\nYANG Description: This container defines Reference Bandwidth configuration", "id": "f22522:c0:m2"}
{"signature": "def _get_level(self):", "body": "return self.__level<EOL>", "docstring": "Getter method for level, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level (list)\n\n    YANG Description: Configuration and operational state parameters related to a\nparticular level within the IS-IS protocol instance", "id": "f22523:c0:m2"}
{"signature": "def _get_metric_style(self):", "body": "return self.__metric_style<EOL>", "docstring": "Getter method for metric_style, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/state/metric_style (oc-isis-types:metric-style)\n\nYANG Description: ISIS metric style types(narrow, wide).", "id": "f22524:c0:m8"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/state/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: When set to true, the functionality within which this leaf is\ndefined is enabled, when set to false it is explicitly disabled.", "id": "f22524:c1:m3"}
{"signature": "def _get_authentication_check(self):", "body": "return self.__authentication_check<EOL>", "docstring": "Getter method for authentication_check, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/state/authentication_check (boolean)\n\n    YANG Description: When set to true, reject all ISIS protocol PDUs that either have a mismatch\nin authentication-type or authentication-key.", "id": "f22524:c1:m11"}
{"signature": "def _set_level_number(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__level_number = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for level_number, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/state/level_number (oc-isis-types:level-number)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_level_number is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_level_number() directly.\n\nYANG Description: ISIS level number (level-1, level-2).", "id": "f22524:c1:m6"}
{"signature": "def _set_level_number(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__level_number = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for level_number, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/state/level_number (oc-isis-types:level-number)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_level_number is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_level_number() directly.\n\nYANG Description: ISIS level number (level-1, level-2).", "id": "f22524:c0:m6"}
{"signature": "def _set_authentication_check(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:true>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__authentication_check = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for authentication_check, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/state/authentication_check (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_authentication_check is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_authentication_check() directly.\n\n    YANG Description: When set to true, reject all ISIS protocol PDUs that either have a mismatch\nin authentication-type or authentication-key.", "id": "f22524:c0:m12"}
{"signature": "def _get_lsp_errors(self):", "body": "return self.__lsp_errors<EOL>", "docstring": "Getter method for lsp_errors, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/system_level_counters/state/lsp_errors (yang:counter32)\n\nYANG Description: The number of received LSPs with errors.", "id": "f22525:c0:m38"}
{"signature": "def _set_own_lsp_purges(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__own_lsp_purges = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for own_lsp_purges, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/system_level_counters/state/own_lsp_purges (yang:counter32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_own_lsp_purges is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_own_lsp_purges() directly.\n\n    YANG Description: Number of times a zero-aged copy of the system's\nown LSP is received from some other node.\nMIB Entry: isisSysOwnLSPPurges.", "id": "f22525:c1:m18"}
{"signature": "def _set_lsp_errors(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__lsp_errors = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for lsp_errors, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/system_level_counters/state/lsp_errors (yang:counter32)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_lsp_errors is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_lsp_errors() directly.\n\nYANG Description: The number of received LSPs with errors.", "id": "f22525:c1:m39"}
{"signature": "def _get_id_len_mismatch(self):", "body": "return self.__id_len_mismatch<EOL>", "docstring": "Getter method for id_len_mismatch, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/system_level_counters/state/id_len_mismatch (yang:counter32)\n\n    YANG Description: Number of times a PDU is received with a different value for ID field\nlength from that of the receiving system. MIB Entry:\nisisSysIDFieldLenMismatches.", "id": "f22525:c0:m20"}
{"signature": "def _set_auth_fails(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__auth_fails = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for auth_fails, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/system_level_counters/state/auth_fails (yang:counter32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_auth_fails is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_auth_fails() directly.\n\n    YANG Description: The number of authentication key failures.\nMIB Entry: SysAuthFails.", "id": "f22525:c0:m30"}
{"signature": "def _get_corrupted_lsps(self):", "body": "return self.__corrupted_lsps<EOL>", "docstring": "Getter method for corrupted_lsps, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/system_level_counters/state/corrupted_lsps (yang:counter32)\n\n    YANG Description: Number of corrupted in-memory LSPs detected. LSPs received from the\nwire with a bad checksum are silently dropped and not counted. LSPs\nreceived from the wire with parse errors are counted by lsp-errors. MIB\nEntry: SysCorrLSPs.", "id": "f22525:c0:m2"}
{"signature": "def _set_auth_type_fails(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__auth_type_fails = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for auth_type_fails, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/system_level_counters/state/auth_type_fails (yang:counter32)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_auth_type_fails is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_auth_type_fails() directly.\n\nYANG Description: The number of authentication type mismatches.", "id": "f22525:c1:m36"}
{"signature": "def _get_max_area_address_mismatches(self):", "body": "return self.__max_area_address_mismatches<EOL>", "docstring": "Getter method for max_area_address_mismatches, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/system_level_counters/state/max_area_address_mismatches (yang:counter32)\n\n    YANG Description: Number of times a PDU is received with a different value for\nMaximumAreaAddresses from that of the receiving system. MIB Entry:\nSysMaxAreaAddrMismatches.", "id": "f22525:c0:m26"}
{"signature": "def _get_id_len_mismatch(self):", "body": "return self.__id_len_mismatch<EOL>", "docstring": "Getter method for id_len_mismatch, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/system_level_counters/state/id_len_mismatch (yang:counter32)\n\n    YANG Description: Number of times a PDU is received with a different value for ID field\nlength from that of the receiving system. MIB Entry:\nisisSysIDFieldLenMismatches.", "id": "f22525:c1:m20"}
{"signature": "def _set_corrupted_lsps(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__corrupted_lsps = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for corrupted_lsps, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/system_level_counters/state/corrupted_lsps (yang:counter32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_corrupted_lsps is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_corrupted_lsps() directly.\n\n    YANG Description: Number of corrupted in-memory LSPs detected. LSPs received from the\nwire with a bad checksum are silently dropped and not counted. LSPs\nreceived from the wire with parse errors are counted by lsp-errors. MIB\nEntry: SysCorrLSPs.", "id": "f22525:c1:m3"}
{"signature": "def _set_exceed_max_seq_nums(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__exceed_max_seq_nums = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for exceed_max_seq_nums, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/system_level_counters/state/exceed_max_seq_nums (yang:counter32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_exceed_max_seq_nums is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_exceed_max_seq_nums() directly.\n\n    YANG Description: The number of times the system has attempted to exceed the maximum\nsequence number. MIB Entry: SysAttmptToExMaxSeqNums.", "id": "f22525:c0:m12"}
{"signature": "def _get_seq_num_skips(self):", "body": "return self.__seq_num_skips<EOL>", "docstring": "Getter method for seq_num_skips, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/system_level_counters/state/seq_num_skips (yang:counter32)\n\n    YANG Description: Number of times a sequence number skip has occurred. MIB Entry:\nSysSeqNumSkips.", "id": "f22525:c0:m14"}
{"signature": "def _set_spf_runs(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__spf_runs = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for spf_runs, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/system_level_counters/state/spf_runs (yang:counter32)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_spf_runs is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_spf_runs() directly.\n\nYANG Description: The number of times SPF was ran at this level.", "id": "f22525:c1:m33"}
{"signature": "def _get_auth_fails(self):", "body": "return self.__auth_fails<EOL>", "docstring": "Getter method for auth_fails, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/system_level_counters/state/auth_fails (yang:counter32)\n\n    YANG Description: The number of authentication key failures.\nMIB Entry: SysAuthFails.", "id": "f22525:c0:m29"}
{"signature": "def _get_seq_num_skips(self):", "body": "return self.__seq_num_skips<EOL>", "docstring": "Getter method for seq_num_skips, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/system_level_counters/state/seq_num_skips (yang:counter32)\n\n    YANG Description: Number of times a sequence number skip has occurred. MIB Entry:\nSysSeqNumSkips.", "id": "f22525:c1:m14"}
{"signature": "def _get_own_lsp_purges(self):", "body": "return self.__own_lsp_purges<EOL>", "docstring": "Getter method for own_lsp_purges, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/system_level_counters/state/own_lsp_purges (yang:counter32)\n\n    YANG Description: Number of times a zero-aged copy of the system's\nown LSP is received from some other node.\nMIB Entry: isisSysOwnLSPPurges.", "id": "f22525:c1:m17"}
{"signature": "def _set_external_route_preference(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__external_route_preference = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for external_route_preference, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/route_preference/state/external_route_preference (uint8)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_external_route_preference is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_external_route_preference() directly.\n\nYANG Description: Administrative Distance(preference) for external ISIS routes.", "id": "f22527:c0:m3"}
{"signature": "def _get_external_route_preference(self):", "body": "return self.__external_route_preference<EOL>", "docstring": "Getter method for external_route_preference, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/route_preference/state/external_route_preference (uint8)\n\nYANG Description: Administrative Distance(preference) for external ISIS routes.", "id": "f22527:c0:m2"}
{"signature": "def _get_internal_route_preference(self):", "body": "return self.__internal_route_preference<EOL>", "docstring": "Getter method for internal_route_preference, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/route_preference/config/internal_route_preference (uint8)\n\nYANG Description: Administrative Distance(preference) for internal ISIS routes.", "id": "f22528:c1:m5"}
{"signature": "def _get_external_route_preference(self):", "body": "return self.__external_route_preference<EOL>", "docstring": "Getter method for external_route_preference, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/route_preference/config/external_route_preference (uint8)\n\nYANG Description: Administrative Distance(preference) for external ISIS routes.", "id": "f22528:c1:m2"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/route_preference/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: This container defines route preference configuration.", "id": "f22529:c1:m3"}
{"signature": "def _get_authentication_check(self):", "body": "return self.__authentication_check<EOL>", "docstring": "Getter method for authentication_check, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/config/authentication_check (boolean)\n\n    YANG Description: When set to true, reject all ISIS protocol PDUs that either have a mismatch\nin authentication-type or authentication-key.", "id": "f22530:c1:m11"}
{"signature": "def _set_metric_style(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__metric_style = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for metric_style, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/config/metric_style (oc-isis-types:metric-style)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_metric_style is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_metric_style() directly.\n\nYANG Description: ISIS metric style types(narrow, wide).", "id": "f22530:c1:m9"}
{"signature": "def _set_route_preference(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=route_preference.route_preference,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__route_preference = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for route_preference, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/route_preference (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_route_preference is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_route_preference() directly.\n\n    YANG Description: This container defines Administrative Distance (or preference)\nassigned to ISIS routes (level1 internal, level2 internal, level1\nexternal, level2 external).", "id": "f22531:c1:m21"}
{"signature": "def _get_link_state_database(self):", "body": "return self.__link_state_database<EOL>", "docstring": "Getter method for link_state_database, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database (container)\n\nYANG Description: This container defines ISIS LSDB.", "id": "f22531:c1:m14"}
{"signature": "def _set_traffic_engineering(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=traffic_engineering.traffic_engineering,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__traffic_engineering = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for traffic_engineering, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/traffic_engineering (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_traffic_engineering is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_traffic_engineering() directly.\n\nYANG Description: This container defines ISIS TE.", "id": "f22531:c0:m18"}
{"signature": "def _set_system_level_counters(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=system_level_counters.system_level_counters,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__system_level_counters = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for system_level_counters, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/system_level_counters (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_system_level_counters is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_system_level_counters() directly.\n\nYANG Description: This container defines ISIS system level counters.", "id": "f22531:c1:m12"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/state (container)\n\nYANG Description: This container defines ISIS level state information.", "id": "f22531:c0:m8"}
{"signature": "def _get_link_state_database(self):", "body": "return self.__link_state_database<EOL>", "docstring": "Getter method for link_state_database, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database (container)\n\nYANG Description: This container defines ISIS LSDB.", "id": "f22531:c0:m14"}
{"signature": "def _set_traffic_engineering(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=traffic_engineering.traffic_engineering,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__traffic_engineering = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for traffic_engineering, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/traffic_engineering (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_traffic_engineering is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_traffic_engineering() directly.\n\nYANG Description: This container defines ISIS TE.", "id": "f22531:c1:m18"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: This container defines ISIS level state information.", "id": "f22531:c1:m9"}
{"signature": "def _set_ipv4_router_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv4_router_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv4_router_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/traffic_engineering/state/ipv4_router_id (inet:ipv4-address-no-zone)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ipv4_router_id is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ipv4_router_id() directly.\n\nYANG Description: IPv4 MPLS Traffic Engineering Router-ID.", "id": "f22532:c0:m6"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/traffic_engineering/state/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: When set to true, the functionality within which this leaf is\ndefined is enabled, when set to false it is explicitly disabled.", "id": "f22532:c0:m3"}
{"signature": "def _set_ipv4_router_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv4_router_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv4_router_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/traffic_engineering/state/ipv4_router_id (inet:ipv4-address-no-zone)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ipv4_router_id is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ipv4_router_id() directly.\n\nYANG Description: IPv4 MPLS Traffic Engineering Router-ID.", "id": "f22532:c1:m6"}
{"signature": "def _set_ipv6_router_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv6_router_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv6_router_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/traffic_engineering/config/ipv6_router_id (inet:ipv6-address-no-zone)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ipv6_router_id is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ipv6_router_id() directly.\n\nYANG Description: IPv6 MPLS Traffic Engineering Router-ID.", "id": "f22533:c0:m9"}
{"signature": "def _get_ipv6_router_id(self):", "body": "return self.__ipv6_router_id<EOL>", "docstring": "Getter method for ipv6_router_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/traffic_engineering/config/ipv6_router_id (inet:ipv6-address-no-zone)\n\nYANG Description: IPv6 MPLS Traffic Engineering Router-ID.", "id": "f22533:c1:m8"}
{"signature": "def _get_ipv4_router_id(self):", "body": "return self.__ipv4_router_id<EOL>", "docstring": "Getter method for ipv4_router_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/traffic_engineering/config/ipv4_router_id (inet:ipv4-address-no-zone)\n\nYANG Description: IPv4 MPLS Traffic Engineering Router-ID.", "id": "f22533:c0:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/traffic_engineering/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: This container defines ISIS TE state information.", "id": "f22534:c1:m6"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/traffic_engineering/config (container)\n\nYANG Description: This container defines ISIS TE configuration.", "id": "f22534:c1:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/traffic_engineering/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: This container defines ISIS TE state information.", "id": "f22534:c0:m6"}
{"signature": "def _set_lsp(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>lsp.lsp,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__lsp = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for lsp, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_lsp is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_lsp() directly.\n\nYANG Description: This list describes LSPs in LSDB.", "id": "f22535:c0:m3"}
{"signature": "def _get_value(self):", "body": "return self.__value<EOL>", "docstring": "Getter method for value, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/undefined_tlvs/undefined_tlv/state/value (binary)\n\nYANG Description: TLV value.", "id": "f22536:c1:m8"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/undefined_tlvs/undefined_tlv/state/type (uint8)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_type is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_type() directly.\n\nYANG Description: TLV Type.", "id": "f22536:c0:m3"}
{"signature": "def _get_length(self):", "body": "return self.__length<EOL>", "docstring": "Getter method for length, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/undefined_tlvs/undefined_tlv/state/length (uint8)\n\nYANG Description: TLV length.", "id": "f22536:c1:m5"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/undefined_tlvs/undefined_tlv/state (container)\n\nYANG Description: State parameters of the undefined TLV.", "id": "f22537:c0:m5"}
{"signature": "def _set_undefined_tlv(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT:type>\",<EOL>undefined_tlv.undefined_tlv,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT:type>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__undefined_tlv = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for undefined_tlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/undefined_tlvs/undefined_tlv (list)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_undefined_tlv is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_undefined_tlv() directly.\n\n    YANG Description: List of TLVs that are not defined within the model, or are not\nrecognised by the system.", "id": "f22538:c0:m3"}
{"signature": "def _get_undefined_tlv(self):", "body": "return self.__undefined_tlv<EOL>", "docstring": "Getter method for undefined_tlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/undefined_tlvs/undefined_tlv (list)\n\n    YANG Description: List of TLVs that are not defined within the model, or are not\nrecognised by the system.", "id": "f22538:c0:m2"}
{"signature": "def _get_version(self):", "body": "return self.__version<EOL>", "docstring": "Getter method for version, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/state/version (uint8)\n\nYANG Description: PDU version. This is set to 1.", "id": "f22539:c1:m8"}
{"signature": "def _set_checksum(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__checksum = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for checksum, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/state/checksum (uint16)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_checksum is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_checksum() directly.\n\nYANG Description: Checksum of the LSP.", "id": "f22539:c1:m27"}
{"signature": "def _get_pdu_type(self):", "body": "return self.__pdu_type<EOL>", "docstring": "Getter method for pdu_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/state/pdu_type (enumeration)\n\nYANG Description: Link State PDU type.", "id": "f22539:c1:m17"}
{"signature": "def _set_lsp_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__lsp_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for lsp_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/state/lsp_id (oc-isis-types:lsp-id)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_lsp_id is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_lsp_id() directly.\n\nYANG Description: LSP ID of the LSP.", "id": "f22539:c0:m3"}
{"signature": "def _get_version(self):", "body": "return self.__version<EOL>", "docstring": "Getter method for version, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/state/version (uint8)\n\nYANG Description: PDU version. This is set to 1.", "id": "f22539:c0:m8"}
{"signature": "def _set_maximum_area_addresses(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__maximum_area_addresses = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for maximum_area_addresses, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/state/maximum_area_addresses (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_maximum_area_addresses is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_maximum_area_addresses() directly.\n\n    YANG Description: Number of area addresses permitted for this ISs area. 0 indicates the\nIS only supports three area addresses (by default). Any number\ninclusive of 1 and 254 indicates the number of areas allowed.", "id": "f22539:c0:m6"}
{"signature": "def _get_checksum(self):", "body": "return self.__checksum<EOL>", "docstring": "Getter method for checksum, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/state/checksum (uint16)\n\nYANG Description: Checksum of the LSP.", "id": "f22539:c1:m26"}
{"signature": "def _set_checksum(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__checksum = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for checksum, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/state/checksum (uint16)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_checksum is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_checksum() directly.\n\nYANG Description: Checksum of the LSP.", "id": "f22539:c0:m27"}
{"signature": "def _get_id_length(self):", "body": "return self.__id_length<EOL>", "docstring": "Getter method for id_length, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/state/id_length (uint8)\n\n    YANG Description: Length of the ID field of NSAP addresses and NETs used in this\nrouting domain.", "id": "f22539:c0:m14"}
{"signature": "def _get_maximum_area_addresses(self):", "body": "return self.__maximum_area_addresses<EOL>", "docstring": "Getter method for maximum_area_addresses, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/state/maximum_area_addresses (uint8)\n\n    YANG Description: Number of area addresses permitted for this ISs area. 0 indicates the\nIS only supports three area addresses (by default). Any number\ninclusive of 1 and 254 indicates the number of areas allowed.", "id": "f22539:c1:m5"}
{"signature": "def _get_instance_id(self):", "body": "return self.__instance_id<EOL>", "docstring": "Getter method for instance_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/instance_id/state/instance_id (uint16)\n\n    YANG Description: An Instance Identifier (IID) to uniquely identify an IS-IS\ninstance. When the IID = 0, the list of supported ITIDs MUST NOT\nbe present. An IID-TLV with IID = 0 MUST NOT appear in an SNP or\nLSP. When the TLV appears (with a non-zero IID) in an SNP or\nLSP, exactly one ITID. MUST be present indicating the topology\nwith which the PDU is associated. If no ITIDs or multiple ITIDs\nare present or the IID is zero, then the PDU MUST be ignored.", "id": "f22541:c0:m5"}
{"signature": "def _get_topology_id(self):", "body": "return self.__topology_id<EOL>", "docstring": "Getter method for topology_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/instance_id/state/topology_id (uint16)\n\nYANG Description: Instance-Specific Topology Identifiers (ITIDs).", "id": "f22541:c1:m8"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/instance_id/state/type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_type() directly.\n\n    YANG Description: The type of TLV being described. The type of TLV is\nexpressed as a canonical name.", "id": "f22541:c1:m3"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/instance_id/state/type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_type() directly.\n\n    YANG Description: The type of TLV being described. The type of TLV is\nexpressed as a canonical name.", "id": "f22541:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/instance_id/state (container)\n\nYANG Description: State parameters of ISIS TLV 7.", "id": "f22542:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/instance_id/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of ISIS TLV 7.", "id": "f22542:c0:m3"}
{"signature": "def _get_hostname(self):", "body": "return self.__hostname<EOL>", "docstring": "Getter method for hostname, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/hostname/state/hostname (string)\n\nYANG Description: Name of the node.", "id": "f22543:c0:m5"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/hostname/state/type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_type() directly.\n\n    YANG Description: The type of TLV being described. The type of TLV is\nexpressed as a canonical name.", "id": "f22543:c0:m3"}
{"signature": "def _get_hostname(self):", "body": "return self.__hostname<EOL>", "docstring": "Getter method for hostname, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/hostname/state/hostname (string)\n\nYANG Description: Name of the node.", "id": "f22543:c1:m5"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/hostname/state/type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_type() directly.\n\n    YANG Description: The type of TLV being described. The type of TLV is\nexpressed as a canonical name.", "id": "f22543:c1:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/hostname/state (container)\n\nYANG Description: State parameters of ISIS TLV 137.", "id": "f22544:c1:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/hostname/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of ISIS TLV 137.", "id": "f22544:c1:m3"}
{"signature": "def _set_flags(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__flags = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_srlg/state/flags (enumeration)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_flags is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_flags() directly.\n\nYANG Description: SRLG flags.", "id": "f22545:c1:m12"}
{"signature": "def _get_srlg_value(self):", "body": "return self.__srlg_value<EOL>", "docstring": "Getter method for srlg_value, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_srlg/state/srlg_value (uint32)\n\nYANG Description: List of SRLG values.", "id": "f22545:c1:m20"}
{"signature": "def _set_ipv4_interface_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv4_interface_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv4_interface_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_srlg/state/ipv4_interface_address (inet:ipv4-address-no-zone)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ipv4_interface_address is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ipv4_interface_address() directly.\n\nYANG Description: IPv4 interface address.", "id": "f22545:c1:m15"}
{"signature": "def _get_ipv4_interface_address(self):", "body": "return self.__ipv4_interface_address<EOL>", "docstring": "Getter method for ipv4_interface_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_srlg/state/ipv4_interface_address (inet:ipv4-address-no-zone)\n\nYANG Description: IPv4 interface address.", "id": "f22545:c1:m14"}
{"signature": "def _get_flags(self):", "body": "return self.__flags<EOL>", "docstring": "Getter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_srlg/state/flags (enumeration)\n\nYANG Description: SRLG flags.", "id": "f22545:c0:m11"}
{"signature": "def _set_ipv4_interface_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv4_interface_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv4_interface_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_srlg/state/ipv4_interface_address (inet:ipv4-address-no-zone)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ipv4_interface_address is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ipv4_interface_address() directly.\n\nYANG Description: IPv4 interface address.", "id": "f22545:c0:m15"}
{"signature": "def _set_flags(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__flags = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_srlg/state/flags (enumeration)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_flags is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_flags() directly.\n\nYANG Description: SRLG flags.", "id": "f22545:c0:m12"}
{"signature": "def _get_type(self):", "body": "return self.__type<EOL>", "docstring": "Getter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_srlg/state/type (identityref)\n\n    YANG Description: The type of TLV being described. The type of TLV is\nexpressed as a canonical name.", "id": "f22545:c1:m2"}
{"signature": "def _get_srlg_value(self):", "body": "return self.__srlg_value<EOL>", "docstring": "Getter method for srlg_value, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_srlg/state/srlg_value (uint32)\n\nYANG Description: List of SRLG values.", "id": "f22545:c0:m20"}
{"signature": "def _get_psn_number(self):", "body": "return self.__psn_number<EOL>", "docstring": "Getter method for psn_number, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_srlg/state/psn_number (uint8)\n\nYANG Description: Pseudonode number if the neighbor is on a LAN interface.", "id": "f22545:c1:m8"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_srlg/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of TLV 138.", "id": "f22546:c0:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_srlg/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of TLV 138.", "id": "f22546:c1:m3"}
{"signature": "def _get_type(self):", "body": "return self.__type<EOL>", "docstring": "Getter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/state/type (identityref)\n\n    YANG Description: The type of TLV being described. The type of TLV is\nexpressed as a canonical name.", "id": "f22547:c1:m2"}
{"signature": "def _get_type(self):", "body": "return self.__type<EOL>", "docstring": "Getter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/state/type (identityref)\n\n    YANG Description: The type of TLV being described. The type of TLV is\nexpressed as a canonical name.", "id": "f22547:c0:m2"}
{"signature": "def _get_type(self):", "body": "return self.__type<EOL>", "docstring": "Getter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_external_reachability/state/type (identityref)\n\n    YANG Description: The type of TLV being described. The type of TLV is\nexpressed as a canonical name.", "id": "f22548:c1:m2"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_external_reachability/state/type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_type() directly.\n\n    YANG Description: The type of TLV being described. The type of TLV is\nexpressed as a canonical name.", "id": "f22548:c0:m3"}
{"signature": "def _set_up_down(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__up_down = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for up_down, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_external_reachability/prefixes/prefixes/state/up_down (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_up_down is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_up_down() directly.\n\n    YANG Description: The up/down bit. Set if a prefix is advertised from a higher level to\na lower level (e.g., level 2 to level 1), indicating that the prefix\nhas traveled down the hierarchy. Prefixes that have the up/down bit\nset may only be advertised down the hierarchy, i.e., to lower levels.\nWhen a prefix is first injected into IS-IS, the bit is UNSET.", "id": "f22549:c1:m3"}
{"signature": "def _get_default_metric(self):", "body": "return self.__default_metric<EOL>", "docstring": "Getter method for default_metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_external_reachability/prefixes/prefixes/default_metric/state/default_metric (oc-isis-types:narrow-metric)\n\n    YANG Description: ISIS default metric value. This is a metric understood by every\nIntermediate system in the domain. Each circuit shall have a\npositive  integral value assigned for this metric. The value may be\nassociated with any  objective function of the circuit, but by\nconvention is intended to measure the capacity of the circuit for\nhandling traffic, for example, its throughput in  bits-per-second.\nHigher values indicate a lower capacity.", "id": "f22550:c0:m5"}
{"signature": "def _set_flags(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__flags = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_external_reachability/prefixes/prefixes/default_metric/state/flags (enumeration)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_flags is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_flags() directly.\n\nYANG Description: ISIS Default-Metric Flags.", "id": "f22550:c1:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_external_reachability/prefixes/prefixes/default_metric/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters for default-metric.", "id": "f22551:c1:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_external_reachability/prefixes/prefixes/default_metric/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters for default-metric.", "id": "f22551:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_external_reachability/prefixes/prefixes/default_metric/state (container)\n\nYANG Description: State parameters for default-metric.", "id": "f22551:c0:m2"}
{"signature": "def _set_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_external_reachability/prefixes/prefixes/error_metric/state/metric (oc-isis-types:narrow-metric)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_metric is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_metric() directly.\n\n    YANG Description: ISIS error metric value. This metric measures the residual error\nprobability of the associated circuit. It is an optional metric,\nwhich if assigned to a circuit shall have a non-zero value. Higher\nvalues indicate a larger probability of undetected errors on the\ncircuit.", "id": "f22552:c0:m3"}
{"signature": "def _set_flags(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__flags = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_external_reachability/prefixes/prefixes/error_metric/state/flags (isis-metric-flags)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_flags is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_flags() directly.\n\nYANG Description: IS-IS error metric flags.", "id": "f22552:c1:m6"}
{"signature": "def _set_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_external_reachability/prefixes/prefixes/error_metric/state/metric (oc-isis-types:narrow-metric)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_metric is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_metric() directly.\n\n    YANG Description: ISIS error metric value. This metric measures the residual error\nprobability of the associated circuit. It is an optional metric,\nwhich if assigned to a circuit shall have a non-zero value. Higher\nvalues indicate a larger probability of undetected errors on the\ncircuit.", "id": "f22552:c1:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_external_reachability/prefixes/prefixes/error_metric/state (container)\n\nYANG Description: State parameters of error-metric.", "id": "f22553:c1:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_external_reachability/prefixes/prefixes/error_metric/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of error-metric.", "id": "f22553:c0:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_external_reachability/prefixes/prefixes/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of IPv4 standard prefix.", "id": "f22554:c0:m3"}
{"signature": "def _get_delay_metric(self):", "body": "return self.__delay_metric<EOL>", "docstring": "Getter method for delay_metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_external_reachability/prefixes/prefixes/delay_metric (container)\n\nYANG Description: This container defines the ISIS delay metric.", "id": "f22554:c0:m8"}
{"signature": "def _get_default_metric(self):", "body": "return self.__default_metric<EOL>", "docstring": "Getter method for default_metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_external_reachability/prefixes/prefixes/default_metric (container)\n\nYANG Description: This container defines ISIS Default Metric.", "id": "f22554:c0:m5"}
{"signature": "def _set_expense_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=expense_metric.expense_metric,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__expense_metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for expense_metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_external_reachability/prefixes/prefixes/expense_metric (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_expense_metric is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_expense_metric() directly.\n\nYANG Description: This container defines the ISIS expense metric.", "id": "f22554:c1:m12"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_external_reachability/prefixes/prefixes/state (container)\n\nYANG Description: State parameters of IPv4 standard prefix.", "id": "f22554:c1:m2"}
{"signature": "def _set_delay_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=delay_metric.delay_metric,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__delay_metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for delay_metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_external_reachability/prefixes/prefixes/delay_metric (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_delay_metric is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_delay_metric() directly.\n\nYANG Description: This container defines the ISIS delay metric.", "id": "f22554:c1:m9"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_external_reachability/prefixes/prefixes/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of IPv4 standard prefix.", "id": "f22554:c1:m3"}
{"signature": "def _set_default_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=default_metric.default_metric,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__default_metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for default_metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_external_reachability/prefixes/prefixes/default_metric (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_default_metric is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_default_metric() directly.\n\nYANG Description: This container defines ISIS Default Metric.", "id": "f22554:c1:m6"}
{"signature": "def _get_metric(self):", "body": "return self.__metric<EOL>", "docstring": "Getter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_external_reachability/prefixes/prefixes/expense_metric/state/metric (oc-isis-types:narrow-metric)\n\n    YANG Description: ISIS expense metric value. This metric measures the monetary cost\nof utilising the associated circuit. It is an optional metric, which\nif assigned to a circuit shall have a positive integral value1).\nHigher values indicate a larger monetary expense.", "id": "f22555:c0:m2"}
{"signature": "def _set_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_external_reachability/prefixes/prefixes/expense_metric/state/metric (oc-isis-types:narrow-metric)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_metric is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_metric() directly.\n\n    YANG Description: ISIS expense metric value. This metric measures the monetary cost\nof utilising the associated circuit. It is an optional metric, which\nif assigned to a circuit shall have a positive integral value1).\nHigher values indicate a larger monetary expense.", "id": "f22555:c0:m3"}
{"signature": "def _get_flags(self):", "body": "return self.__flags<EOL>", "docstring": "Getter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_external_reachability/prefixes/prefixes/expense_metric/state/flags (isis-metric-flags)\n\nYANG Description: ISIS Expense Metric Flags.", "id": "f22555:c0:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_external_reachability/prefixes/prefixes/delay_metric/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of delay-metric.", "id": "f22558:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_external_reachability/prefixes/prefixes/delay_metric/state (container)\n\nYANG Description: State parameters of delay-metric.", "id": "f22558:c0:m2"}
{"signature": "def _set_prefixes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>False,<EOL>prefixes_.prefixes,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT:False>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prefixes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_external_reachability/prefixes/prefixes (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_prefixes is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_prefixes() directly.\n\nYANG Description: IPv4 external prefixes and reachability attributes.", "id": "f22559:c1:m3"}
{"signature": "def _get_prefixes(self):", "body": "return self.__prefixes<EOL>", "docstring": "Getter method for prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_external_reachability/prefixes/prefixes (list)\n\nYANG Description: IPv4 external prefixes and reachability attributes.", "id": "f22559:c0:m2"}
{"signature": "def _set_prefixes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=prefixes.prefixes,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prefixes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_external_reachability/prefixes (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_prefixes is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_prefixes() directly.\n\nYANG Description: This container describes IS neighbors.", "id": "f22560:c0:m6"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_external_reachability/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: This container describes IPv4 external reachability state", "id": "f22560:c1:m3"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/router_capabilities/router_capability/subtlvs/subtlvs/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22561:c1:m3"}
{"signature": "def _set_range(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__range = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for range, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/router_capabilities/router_capability/subtlvs/subtlvs/segment_routing_capability/state/range (uint32)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_range is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_range() directly.\n\nYANG Description: Number of SRGB elements. The range value MUST be higher than 0.", "id": "f22562:c1:m9"}
{"signature": "def _set_range(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__range = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for range, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/router_capabilities/router_capability/subtlvs/subtlvs/segment_routing_capability/state/range (uint32)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_range is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_range() directly.\n\nYANG Description: Number of SRGB elements. The range value MUST be higher than 0.", "id": "f22562:c0:m9"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/router_capabilities/router_capability/subtlvs/subtlvs/segment_routing_capability/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22562:c0:m3"}
{"signature": "def _set_flags(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {}, \"<STR_LIT>\": {}, \"<STR_LIT>\": {}<EOL>},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__flags = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/router_capabilities/router_capability/subtlvs/subtlvs/segment_routing_capability/state/flags (enumeration)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_flags is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_flags() directly.\n\nYANG Description: Segment Routing Capability Flags.", "id": "f22562:c1:m6"}
{"signature": "def _get_flags(self):", "body": "return self.__flags<EOL>", "docstring": "Getter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/router_capabilities/router_capability/subtlvs/subtlvs/segment_routing_capability/state/flags (enumeration)\n\nYANG Description: Segment Routing Capability Flags.", "id": "f22562:c1:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/router_capabilities/router_capability/subtlvs/subtlvs/segment_routing_capability/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of IS SR Router Capability", "id": "f22563:c1:m3"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/router_capabilities/router_capability/subtlvs/subtlvs/subtlv_type (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: A reference for the TLV type being described within\nthe LSDB", "id": "f22564:c1:m3"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/router_capabilities/router_capability/subtlvs/subtlvs/subtlv_type (leafref)\n\n    YANG Description: A reference for the TLV type being described within\nthe LSDB", "id": "f22564:c0:m2"}
{"signature": "def _set_segment_routing_algorithm(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=segment_routing_algorithm.segment_routing_algorithm,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__segment_routing_algorithm = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for segment_routing_algorithm, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/router_capabilities/router_capability/subtlvs/subtlvs/segment_routing_algorithm (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_segment_routing_algorithm is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_segment_routing_algorithm() directly.\n\nYANG Description: This container defines SR algorithm sub-TLV 19.", "id": "f22564:c1:m9"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/router_capabilities/router_capability/subtlvs/subtlvs/state (container)\n\nYANG Description: State parameters of IS Router Capabilities", "id": "f22564:c0:m5"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/router_capabilities/router_capability/subtlvs/subtlvs/subtlv_type (leafref)\n\n    YANG Description: A reference for the TLV type being described within\nthe LSDB", "id": "f22564:c1:m2"}
{"signature": "def _set_segment_routing_capability(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=segment_routing_capability.segment_routing_capability,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__segment_routing_capability = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for segment_routing_capability, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/router_capabilities/router_capability/subtlvs/subtlvs/segment_routing_capability (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_segment_routing_capability is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_segment_routing_capability() directly.\n\nYANG Description: This container defines SR Capability sub-TLV 2.", "id": "f22564:c0:m12"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/router_capabilities/router_capability/subtlvs/subtlvs/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of IS Router Capabilities", "id": "f22564:c0:m6"}
{"signature": "def _get_segment_routing_algorithm(self):", "body": "return self.__segment_routing_algorithm<EOL>", "docstring": "Getter method for segment_routing_algorithm, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/router_capabilities/router_capability/subtlvs/subtlvs/segment_routing_algorithm (container)\n\nYANG Description: This container defines SR algorithm sub-TLV 19.", "id": "f22564:c1:m8"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/router_capabilities/router_capability/subtlvs/subtlvs/segment_routing_algorithm/state (container)\n\nYANG Description: State parameters of sub-TLV 3", "id": "f22566:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/router_capabilities/router_capability/subtlvs/subtlvs/segment_routing_algorithm/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of sub-TLV 3", "id": "f22566:c1:m3"}
{"signature": "def _set_subtlvs(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>subtlvs_.subtlvs,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlvs = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlvs, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/router_capabilities/router_capability/subtlvs/subtlvs (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_subtlvs is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_subtlvs() directly.\n\nYANG Description: List of subTLV types in the LSDB for the specified TLV", "id": "f22567:c1:m3"}
{"signature": "def _get_subtlvs(self):", "body": "return self.__subtlvs<EOL>", "docstring": "Getter method for subtlvs, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/router_capabilities/router_capability/subtlvs/subtlvs (list)\n\nYANG Description: List of subTLV types in the LSDB for the specified TLV", "id": "f22567:c1:m2"}
{"signature": "def _set_subtlvs(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>subtlvs_.subtlvs,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlvs = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlvs, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/router_capabilities/router_capability/subtlvs/subtlvs (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_subtlvs is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_subtlvs() directly.\n\nYANG Description: List of subTLV types in the LSDB for the specified TLV", "id": "f22567:c0:m3"}
{"signature": "def _get_flags(self):", "body": "return self.__flags<EOL>", "docstring": "Getter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/router_capabilities/router_capability/state/flags (enumeration)\n\nYANG Description: Router capability flags.", "id": "f22568:c0:m8"}
{"signature": "def _get_flags(self):", "body": "return self.__flags<EOL>", "docstring": "Getter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/router_capabilities/router_capability/state/flags (enumeration)\n\nYANG Description: Router capability flags.", "id": "f22568:c1:m8"}
{"signature": "def _get_router_id(self):", "body": "return self.__router_id<EOL>", "docstring": "Getter method for router_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/router_capabilities/router_capability/state/router_id (inet:ipv4-address-no-zone)\n\nYANG Description: IPv4 router-id.", "id": "f22568:c1:m5"}
{"signature": "def _get_type(self):", "body": "return self.__type<EOL>", "docstring": "Getter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/router_capabilities/router_capability/state/type (identityref)\n\n    YANG Description: The type of TLV being described. The type of TLV is\nexpressed as a canonical name.", "id": "f22568:c1:m2"}
{"signature": "def _set_flags(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__flags = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/router_capabilities/router_capability/state/flags (enumeration)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_flags is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_flags() directly.\n\nYANG Description: Router capability flags.", "id": "f22568:c1:m9"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/router_capabilities/router_capability/undefined_subtlvs/undefined_subtlv/state/type (uint8)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_type is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_type() directly.\n\nYANG Description: TLV Type.", "id": "f22570:c1:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/router_capabilities/router_capability/undefined_subtlvs/undefined_subtlv/state (container)\n\nYANG Description: State parameters of the undefined sub-TLV.", "id": "f22571:c0:m5"}
{"signature": "def _get_type(self):", "body": "return self.__type<EOL>", "docstring": "Getter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/router_capabilities/router_capability/undefined_subtlvs/undefined_subtlv/type (leafref)\n\nYANG Description: A reference to a subTLV", "id": "f22571:c1:m2"}
{"signature": "def _get_undefined_subtlv(self):", "body": "return self.__undefined_subtlv<EOL>", "docstring": "Getter method for undefined_subtlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/router_capabilities/router_capability/undefined_subtlvs/undefined_subtlv (list)\n\n    YANG Description: Sub-TLVs that are not defined in the model or not recognised by\nsystem.", "id": "f22572:c1:m2"}
{"signature": "def _set_undefined_subtlv(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT:type>\",<EOL>undefined_subtlv.undefined_subtlv,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT:type>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__undefined_subtlv = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for undefined_subtlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/router_capabilities/router_capability/undefined_subtlvs/undefined_subtlv (list)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_undefined_subtlv is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_undefined_subtlv() directly.\n\n    YANG Description: Sub-TLVs that are not defined in the model or not recognised by\nsystem.", "id": "f22572:c1:m3"}
{"signature": "def _get_router_capability(self):", "body": "return self.__router_capability<EOL>", "docstring": "Getter method for router_capability, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/router_capabilities/router_capability (list)\n\nYANG Description: This list describes IS Router capabilities.", "id": "f22573:c0:m2"}
{"signature": "def _get_type(self):", "body": "return self.__type<EOL>", "docstring": "Getter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/state/type (identityref)\n\n    YANG Description: The type of TLV being described. The type of TLV is\nexpressed as a canonical name.", "id": "f22574:c0:m2"}
{"signature": "def _get_neighbors(self):", "body": "return self.__neighbors<EOL>", "docstring": "Getter method for neighbors, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors (list)\n\n    YANG Description: This list describes ISIS extended neigbors and reachability\nattributes.", "id": "f22575:c1:m2"}
{"signature": "def _set_neighbors(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>False,<EOL>neighbors_.neighbors,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT:False>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__neighbors = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for neighbors, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors (list)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_neighbors is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_neighbors() directly.\n\n    YANG Description: This list describes ISIS extended neigbors and reachability\nattributes.", "id": "f22575:c1:m3"}
{"signature": "def _set_system_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__system_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for system_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/state/system_id (oc-isis-types:system-id)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_system_id is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_system_id() directly.\n\nYANG Description: System-id of the neighbor.", "id": "f22576:c1:m3"}
{"signature": "def _get_system_id(self):", "body": "return self.__system_id<EOL>", "docstring": "Getter method for system_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/state/system_id (oc-isis-types:system-id)\n\nYANG Description: System-id of the neighbor.", "id": "f22576:c1:m2"}
{"signature": "def _set_subTLVs(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>subTLVs_.subTLVs,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subTLVs = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subTLVs, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_subTLVs is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_subTLVs() directly.\n\nYANG Description: List of subTLV types in the LSDB for the specified TLV.", "id": "f22577:c1:m3"}
{"signature": "def _set_subTLVs(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>subTLVs_.subTLVs,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subTLVs = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subTLVs, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_subTLVs is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_subTLVs() directly.\n\nYANG Description: List of subTLV types in the LSDB for the specified TLV.", "id": "f22577:c0:m3"}
{"signature": "def _get_available_bandwidth(self):", "body": "return self.__available_bandwidth<EOL>", "docstring": "Getter method for available_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/available_bandwidth/state/available_bandwidth (oc-types:ieeefloat32)\n\n    YANG Description: The available bandwidth on a link, forwarding adjacency, or\nbundled link in IEEE floating-point format with units of bytes\nper second. For a link or forwarding adjacency, available\nbandwidth is defined to be residual bandwidth minus the measured\nbandwidth used for the actual forwarding of non-RSVP-TE label\nswitched path packets.  For a bundled link, available bandwidth\nis defined to be the sum of the component link available\nbandwidths minus the measured bandwidth used for the actual\nforwarding of non-RSVP-TE label switched path packets.  For a\nbundled link, available bandwidth is defined to be the sum of\nthe component link available bandwidths.", "id": "f22578:c1:m5"}
{"signature": "def _set_available_bandwidth(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=bitarray, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__available_bandwidth = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for available_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/available_bandwidth/state/available_bandwidth (oc-types:ieeefloat32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_available_bandwidth is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_available_bandwidth() directly.\n\n    YANG Description: The available bandwidth on a link, forwarding adjacency, or\nbundled link in IEEE floating-point format with units of bytes\nper second. For a link or forwarding adjacency, available\nbandwidth is defined to be residual bandwidth minus the measured\nbandwidth used for the actual forwarding of non-RSVP-TE label\nswitched path packets.  For a bundled link, available bandwidth\nis defined to be the sum of the component link available\nbandwidths minus the measured bandwidth used for the actual\nforwarding of non-RSVP-TE label switched path packets.  For a\nbundled link, available bandwidth is defined to be the sum of\nthe component link available bandwidths.", "id": "f22578:c0:m6"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/available_bandwidth/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of IS Extended Reachability sub-TLV 38.", "id": "f22579:c1:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/available_bandwidth/state (container)\n\nYANG Description: State parameters of IS Extended Reachability sub-TLV 38.", "id": "f22579:c1:m2"}
{"signature": "def _get_sid(self):", "body": "return self.__sid<EOL>", "docstring": "Getter method for sid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/adjacency_sid/sid (list)\n\n    YANG Description: Adjacency Segment-IDs List. An IGP-Adjacency Segment is an IGP\nsegment attached to a unidirectional adjacency or a set of\nunidirectional adjacencies. By default, an IGP-Adjacency Segment is\nlocal to the node which advertises it.", "id": "f22580:c0:m2"}
{"signature": "def _set_sid(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>False,<EOL>sid.sid,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT:False>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__sid = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for sid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/adjacency_sid/sid (list)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_sid is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_sid() directly.\n\n    YANG Description: Adjacency Segment-IDs List. An IGP-Adjacency Segment is an IGP\nsegment attached to a unidirectional adjacency or a set of\nunidirectional adjacencies. By default, an IGP-Adjacency Segment is\nlocal to the node which advertises it.", "id": "f22580:c0:m3"}
{"signature": "def _set_value(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:value>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__value = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for value, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/adjacency_sid/sid/state/value (uint32)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_value is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_value() directly.\n\nYANG Description: Adjacency-SID value.", "id": "f22581:c0:m3"}
{"signature": "def _get_flags(self):", "body": "return self.__flags<EOL>", "docstring": "Getter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/adjacency_sid/sid/state/flags (enumeration)\n\nYANG Description: Flags associated with Adj-Segment-ID.", "id": "f22581:c0:m5"}
{"signature": "def _get_flags(self):", "body": "return self.__flags<EOL>", "docstring": "Getter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/adjacency_sid/sid/state/flags (enumeration)\n\nYANG Description: Flags associated with Adj-Segment-ID.", "id": "f22581:c1:m5"}
{"signature": "def _get_max_reservable_link_bandwidth(self):", "body": "return self.__max_reservable_link_bandwidth<EOL>", "docstring": "Getter method for max_reservable_link_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/max_reservable_link_bandwidth/state/max_reservable_link_bandwidth (oc-types:ieeefloat32)\n\n    YANG Description: The maximum amount of bandwidth that can be reserved in this\ndirection on this link.  Note that for oversubscription\npurposes,  this can be greater than the bandwidth of the link.\nIt is encoded  in 32 bits in IEEE floating point format.  The\nunits are bytes  (not bits!) per second.", "id": "f22586:c1:m5"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/max_reservable_link_bandwidth/state (container)\n\nYANG Description: State parameters of sub-TLV 10.", "id": "f22587:c1:m2"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/ipv6_neighbor_address/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22588:c0:m2"}
{"signature": "def _set_ipv6_neighbor_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv6_neighbor_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv6_neighbor_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/ipv6_neighbor_address/state/ipv6_neighbor_address (inet:ipv6-address)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_ipv6_neighbor_address is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_ipv6_neighbor_address() directly.\n\n    YANG Description: Contains a 16-octet IPv6 address for a neighboring router on\nthe link described by the (main) TLV. This sub-TLV can occur\nmultiple times.", "id": "f22588:c1:m6"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/ipv6_neighbor_address/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22588:c1:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/ipv6_neighbor_address/state (container)\n\nYANG Description: State parameters of sub-TLV 13.", "id": "f22589:c0:m2"}
{"signature": "def _get_a_bit(self):", "body": "return self.__a_bit<EOL>", "docstring": "Getter method for a_bit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/min_max_link_delay/state/a_bit (boolean)\n\n    YANG Description: The A bit is set when the measured value of this parameter\nexceeds its configured maximum threshold. The A bit is cleared\nwhen the measured value falls below its configured reuse threshold.", "id": "f22590:c1:m5"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/min_max_link_delay/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22590:c0:m3"}
{"signature": "def _set_a_bit(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__a_bit = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for a_bit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/min_max_link_delay/state/a_bit (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_a_bit is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_a_bit() directly.\n\n    YANG Description: The A bit is set when the measured value of this parameter\nexceeds its configured maximum threshold. The A bit is cleared\nwhen the measured value falls below its configured reuse threshold.", "id": "f22590:c0:m6"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/min_max_link_delay/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of IS Extended Reachability sub-TLV 34.", "id": "f22591:c1:m3"}
{"signature": "def _set_link_attributes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=link_attributes.link_attributes,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__link_attributes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for link_attributes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/link_attributes (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_link_attributes is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_link_attributes() directly.\n\nYANG Description: This container defines link-attributes.", "id": "f22592:c1:m39"}
{"signature": "def _set_ipv4_interface_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=ipv4_interface_address.ipv4_interface_address,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv4_interface_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv4_interface_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/ipv4_interface_address (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ipv4_interface_address is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ipv4_interface_address() directly.\n\nYANG Description: This container defines sub-TLV 6.", "id": "f22592:c1:m12"}
{"signature": "def _set_adjacency_sid(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=adjacency_sid.adjacency_sid,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__adjacency_sid = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for adjacency_sid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/adjacency_sid (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_adjacency_sid is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_adjacency_sid() directly.\n\nYANG Description: This container defines segment routing extensions for prefixes.", "id": "f22592:c1:m51"}
{"signature": "def _set_ipv4_neighbor_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=ipv4_neighbor_address.ipv4_neighbor_address,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv4_neighbor_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv4_neighbor_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/ipv4_neighbor_address (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ipv4_neighbor_address is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ipv4_neighbor_address() directly.\n\nYANG Description: This container defines sub-TLV 8.", "id": "f22592:c1:m15"}
{"signature": "def _set_ipv4_neighbor_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=ipv4_neighbor_address.ipv4_neighbor_address,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv4_neighbor_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv4_neighbor_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/ipv4_neighbor_address (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ipv4_neighbor_address is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ipv4_neighbor_address() directly.\n\nYANG Description: This container defines sub-TLV 8.", "id": "f22592:c0:m15"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/subtlv_type (leafref)\n\n    YANG Description: A reference for the TLV type being described within\nthe LSDB", "id": "f22592:c0:m2"}
{"signature": "def _get_ipv6_interface_address(self):", "body": "return self.__ipv6_interface_address<EOL>", "docstring": "Getter method for ipv6_interface_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/ipv6_interface_address (container)\n\nYANG Description: This container defines sub-TLV 12.", "id": "f22592:c0:m26"}
{"signature": "def _get_unreserved_bandwidth(self):", "body": "return self.__unreserved_bandwidth<EOL>", "docstring": "Getter method for unreserved_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/unreserved_bandwidth (container)\n\n    YANG Description: This container defines unreserved-bandwidth. The units are bytes\nper second.", "id": "f22592:c0:m23"}
{"signature": "def _get_link_attributes(self):", "body": "return self.__link_attributes<EOL>", "docstring": "Getter method for link_attributes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/link_attributes (container)\n\nYANG Description: This container defines link-attributes.", "id": "f22592:c0:m38"}
{"signature": "def _get_unconstrained_lsp(self):", "body": "return self.__unconstrained_lsp<EOL>", "docstring": "Getter method for unconstrained_lsp, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/unconstrained_lsp (container)\n\nYANG Description: This container defines sub-TLV 23.", "id": "f22592:c1:m47"}
{"signature": "def _get_extended_admin_group(self):", "body": "return self.__extended_admin_group<EOL>", "docstring": "Getter method for extended_admin_group, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/extended_admin_group (container)\n\nYANG Description: This container defines sub-TLV 14.", "id": "f22592:c1:m32"}
{"signature": "def _set_utilized_bandwidth(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=utilized_bandwidth.utilized_bandwidth,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__utilized_bandwidth = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for utilized_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/utilized_bandwidth (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_utilized_bandwidth is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_utilized_bandwidth() directly.\n\nYANG Description: This container defines unidirectional utilized bandwidth.", "id": "f22592:c1:m75"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of IS neighbor state", "id": "f22592:c1:m6"}
{"signature": "def _get_link_protection_type(self):", "body": "return self.__link_protection_type<EOL>", "docstring": "Getter method for link_protection_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/link_protection_type (container)\n\n    YANG Description: ISIS LSDB parameters relating to the type of link protection\noffered.", "id": "f22592:c0:m41"}
{"signature": "def _set_unconstrained_lsp(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=unconstrained_lsp.unconstrained_lsp,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__unconstrained_lsp = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for unconstrained_lsp, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/unconstrained_lsp (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_unconstrained_lsp is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_unconstrained_lsp() directly.\n\nYANG Description: This container defines sub-TLV 23.", "id": "f22592:c0:m48"}
{"signature": "def _set_ipv6_interface_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=ipv6_interface_address.ipv6_interface_address,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv6_interface_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv6_interface_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/ipv6_interface_address (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ipv6_interface_address is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ipv6_interface_address() directly.\n\nYANG Description: This container defines sub-TLV 12.", "id": "f22592:c0:m27"}
{"signature": "def _set_adjacency_sid(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=adjacency_sid.adjacency_sid,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__adjacency_sid = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for adjacency_sid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/adjacency_sid (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_adjacency_sid is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_adjacency_sid() directly.\n\nYANG Description: This container defines segment routing extensions for prefixes.", "id": "f22592:c0:m51"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of IS neighbor state", "id": "f22592:c0:m6"}
{"signature": "def _set_te_default_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=te_default_metric.te_default_metric,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__te_default_metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for te_default_metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/te_default_metric (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_te_default_metric is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_te_default_metric() directly.\n\nYANG Description: This container defines sub-TLV 18.", "id": "f22592:c1:m36"}
{"signature": "def _set_link_delay(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=link_delay.link_delay,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__link_delay = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for link_delay, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/link_delay (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_link_delay is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_link_delay() directly.\n\nYANG Description: This container defines unidirectional link delay.", "id": "f22592:c1:m57"}
{"signature": "def _get_available_bandwidth(self):", "body": "return self.__available_bandwidth<EOL>", "docstring": "Getter method for available_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/available_bandwidth (container)\n\nYANG Description: This container defines unidirectional lavailable bandwidth.", "id": "f22592:c1:m71"}
{"signature": "def _get_ipv6_neighbor_address(self):", "body": "return self.__ipv6_neighbor_address<EOL>", "docstring": "Getter method for ipv6_neighbor_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/ipv6_neighbor_address (container)\n\nYANG Description: This container defines sub-TLV 13.", "id": "f22592:c1:m29"}
{"signature": "def _set_link_delay(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=link_delay.link_delay,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__link_delay = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for link_delay, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/link_delay (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_link_delay is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_link_delay() directly.\n\nYANG Description: This container defines unidirectional link delay.", "id": "f22592:c0:m57"}
{"signature": "def _set_bandwidth_constraints(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=bandwidth_constraints.bandwidth_constraints,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__bandwidth_constraints = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for bandwidth_constraints, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/bandwidth_constraints (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_bandwidth_constraints is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_bandwidth_constraints() directly.\n\n    YANG Description: This container defines bandwidth-constraints. For DS-TE, the\nexisting Maximum Reservable link bandwidth parameter is retained,\nbut its semantics is generalized and interpreted as the aggregate\nbandwidth constraint across all Class-Types", "id": "f22592:c0:m45"}
{"signature": "def _set_ipv6_neighbor_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=ipv6_neighbor_address.ipv6_neighbor_address,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv6_neighbor_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv6_neighbor_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/ipv6_neighbor_address (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ipv6_neighbor_address is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ipv6_neighbor_address() directly.\n\nYANG Description: This container defines sub-TLV 13.", "id": "f22592:c0:m30"}
{"signature": "def _get_link_protection_type(self):", "body": "return self.__link_protection_type<EOL>", "docstring": "Getter method for link_protection_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/link_protection_type (container)\n\n    YANG Description: ISIS LSDB parameters relating to the type of link protection\noffered.", "id": "f22592:c1:m41"}
{"signature": "def _set_link_protection_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=link_protection_type.link_protection_type,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__link_protection_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for link_protection_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/link_protection_type (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_link_protection_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_link_protection_type() directly.\n\n    YANG Description: ISIS LSDB parameters relating to the type of link protection\noffered.", "id": "f22592:c0:m42"}
{"signature": "def _set_te_default_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=te_default_metric.te_default_metric,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__te_default_metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for te_default_metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/te_default_metric (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_te_default_metric is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_te_default_metric() directly.\n\nYANG Description: This container defines sub-TLV 18.", "id": "f22592:c0:m36"}
{"signature": "def _get_min_max_link_delay(self):", "body": "return self.__min_max_link_delay<EOL>", "docstring": "Getter method for min_max_link_delay, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/min_max_link_delay (container)\n\nYANG Description: This container defines min/max link delay.", "id": "f22592:c0:m59"}
{"signature": "def _get_ipv4_neighbor_address(self):", "body": "return self.__ipv4_neighbor_address<EOL>", "docstring": "Getter method for ipv4_neighbor_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/ipv4_neighbor_address (container)\n\nYANG Description: This container defines sub-TLV 8.", "id": "f22592:c0:m14"}
{"signature": "def _get_te_default_metric(self):", "body": "return self.__te_default_metric<EOL>", "docstring": "Getter method for te_default_metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/te_default_metric (container)\n\nYANG Description: This container defines sub-TLV 18.", "id": "f22592:c1:m35"}
{"signature": "def _set_max_reservable_link_bandwidth(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=max_reservable_link_bandwidth.max_reservable_link_bandwidth,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__max_reservable_link_bandwidth = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for max_reservable_link_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/max_reservable_link_bandwidth (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_max_reservable_link_bandwidth is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_max_reservable_link_bandwidth() directly.\n\nYANG Description: This container defines sub-TLV 10.", "id": "f22592:c1:m21"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/admin_group/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of sub-TLV 3.", "id": "f22594:c0:m3"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/link_loss/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22595:c0:m2"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/link_loss/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22595:c1:m2"}
{"signature": "def _get_link_loss(self):", "body": "return self.__link_loss<EOL>", "docstring": "Getter method for link_loss, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/link_loss/state/link_loss (uint32)\n\n    YANG Description: Link packet loss as a percentage of the total traffic sent over\na configurable interval. The basic unit is 0.000003%, where\n(2^24 - 2) is 50.331642%. This value is the highest packet-loss\npercentage that can be expressed (the assumption being that\nprecision is more important on high-speed links than the ability\nto advertise loss rates greater than this, and that high- speed\nlinks with over 50% loss are unusable). Therefore, measured\nvalues that are larger than the field maximum SHOULD be encoded\nas the maximum value.", "id": "f22595:c0:m8"}
{"signature": "def _set_a_bit(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__a_bit = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for a_bit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/link_loss/state/a_bit (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_a_bit is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_a_bit() directly.\n\n    YANG Description: The A bit is set when the measured value of this parameter\nexceeds its configured maximum threshold. The A bit is cleared\nwhen the measured value falls below its configured reuse threshold.", "id": "f22595:c0:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/link_loss/state (container)\n\nYANG Description: State parameters of IS Extended Reachability sub-TLV 36.", "id": "f22596:c1:m2"}
{"signature": "def _get_setup_priority(self):", "body": "return self.__setup_priority<EOL>", "docstring": "Getter method for setup_priority, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/unreserved_bandwidth/setup_priority/state/setup_priority (uint8)\n\n    YANG Description: Setup priority level of 0 through 7 to be used by Unreserved Bandwidth\nsub-TLV 11.", "id": "f22597:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/unreserved_bandwidth/setup_priority/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of IS Extended Reachability sub-TLV 11.", "id": "f22598:c0:m3"}
{"signature": "def _set_setup_priority(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>False,<EOL>setup_priority.setup_priority,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT:False>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__setup_priority = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for setup_priority, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/unreserved_bandwidth/setup_priority (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_setup_priority is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_setup_priority() directly.\n\nYANG Description: Setup priority(0 through 7) for unreserved bandwidth.", "id": "f22599:c0:m3"}
{"signature": "def _get_setup_priority(self):", "body": "return self.__setup_priority<EOL>", "docstring": "Getter method for setup_priority, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/unreserved_bandwidth/setup_priority (list)\n\nYANG Description: Setup priority(0 through 7) for unreserved bandwidth.", "id": "f22599:c1:m2"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/link_protection_type/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22600:c0:m2"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/link_protection_type/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22600:c1:m2"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/link_protection_type/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22600:c1:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/link_protection_type/state (container)\n\nYANG Description: State parameters of sub-TLV 20.", "id": "f22601:c1:m2"}
{"signature": "def _get_utilized_bandwidth(self):", "body": "return self.__utilized_bandwidth<EOL>", "docstring": "Getter method for utilized_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/utilized_bandwidth/state/utilized_bandwidth (oc-types:ieeefloat32)\n\n    YANG Description: The bandwidth utilization on a link, forwarding adjacency, or\nbundled link in IEEE floating-point format with units of bytes\nper second.  For a link or forwarding adjacency, bandwidth\nutilization represents the actual utilization of the link (i.e.,\nas measured by the advertising node).  For a bundled link,\nbandwidth utilization is defined to be the sum of the component\nlink bandwidth utilizations.", "id": "f22602:c0:m5"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/ipv4_neighbor_address/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22604:c0:m2"}
{"signature": "def _get_ipv4_neighbor_address(self):", "body": "return self.__ipv4_neighbor_address<EOL>", "docstring": "Getter method for ipv4_neighbor_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/ipv4_neighbor_address/state/ipv4_neighbor_address (inet:ipv4-address-no-zone)\n\n    YANG Description: A single IPv4 address for a neighboring router on this link.\nThis sub-TLV can occur multiple times.", "id": "f22604:c1:m5"}
{"signature": "def _set_ipv4_neighbor_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv4_neighbor_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv4_neighbor_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/ipv4_neighbor_address/state/ipv4_neighbor_address (inet:ipv4-address-no-zone)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_ipv4_neighbor_address is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_ipv4_neighbor_address() directly.\n\n    YANG Description: A single IPv4 address for a neighboring router on this link.\nThis sub-TLV can occur multiple times.", "id": "f22604:c1:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/ipv4_neighbor_address/state (container)\n\nYANG Description: State parameters of sub-TLV 8.", "id": "f22605:c1:m2"}
{"signature": "def _get_model_id(self):", "body": "return self.__model_id<EOL>", "docstring": "Getter method for model_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/bandwidth_constraints/state/model_id (uint8)\n\n    YANG Description: Identifier for the Bandwidth Constraints  Model currently in\nuse by the LSR initiating the IGP advertisement.", "id": "f22606:c0:m5"}
{"signature": "def _set_model_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__model_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for model_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/bandwidth_constraints/state/model_id (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_model_id is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_model_id() directly.\n\n    YANG Description: Identifier for the Bandwidth Constraints  Model currently in\nuse by the LSR initiating the IGP advertisement.", "id": "f22606:c0:m6"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/bandwidth_constraints/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22606:c0:m2"}
{"signature": "def _get_bandwidth_constraints(self):", "body": "return self.__bandwidth_constraints<EOL>", "docstring": "Getter method for bandwidth_constraints, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/bandwidth_constraints/state/bandwidth_constraints (oc-types:ieeefloat32)\n\n    YANG Description: Contains BC0, BC1,... BC(N-1).  Each BC is encoded on 32 bits\nin IEEE floating point format.  The units are bytes (not bits!)\nper secondy.", "id": "f22606:c1:m11"}
{"signature": "def _set_bandwidth_constraints(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=bitarray, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__bandwidth_constraints = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for bandwidth_constraints, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/bandwidth_constraints/state/bandwidth_constraints (oc-types:ieeefloat32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_bandwidth_constraints is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_bandwidth_constraints() directly.\n\n    YANG Description: Contains BC0, BC1,... BC(N-1).  Each BC is encoded on 32 bits\nin IEEE floating point format.  The units are bytes (not bits!)\nper secondy.", "id": "f22606:c1:m12"}
{"signature": "def _set_reserved(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__reserved = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for reserved, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/bandwidth_constraints/state/reserved (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_reserved is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_reserved() directly.\n\n    YANG Description: Should be set to zero by the LSR generating the sub-TLV and\nshould be ignored by the LSR receiving the sub-TLV.", "id": "f22606:c1:m9"}
{"signature": "def _get_reserved(self):", "body": "return self.__reserved<EOL>", "docstring": "Getter method for reserved, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/bandwidth_constraints/state/reserved (uint32)\n\n    YANG Description: Should be set to zero by the LSR generating the sub-TLV and\nshould be ignored by the LSR receiving the sub-TLV.", "id": "f22606:c1:m8"}
{"signature": "def _get_bandwidth_constraints(self):", "body": "return self.__bandwidth_constraints<EOL>", "docstring": "Getter method for bandwidth_constraints, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/bandwidth_constraints/state/bandwidth_constraints (oc-types:ieeefloat32)\n\n    YANG Description: Contains BC0, BC1,... BC(N-1).  Each BC is encoded on 32 bits\nin IEEE floating point format.  The units are bytes (not bits!)\nper secondy.", "id": "f22606:c0:m11"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/bandwidth_constraints/state (container)\n\nYANG Description: State parameters of IS Extended Reachability sub-TLV 22.", "id": "f22607:c1:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/bandwidth_constraints/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of IS Extended Reachability sub-TLV 22.", "id": "f22607:c1:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/link_attributes/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of IS Extended Reachability sub-TLV 19.", "id": "f22609:c0:m3"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/unconstrained_lsp/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22612:c1:m2"}
{"signature": "def _get_unconstrained_lsp(self):", "body": "return self.__unconstrained_lsp<EOL>", "docstring": "Getter method for unconstrained_lsp, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/unconstrained_lsp/state/unconstrained_lsp (uint16)\n\n    YANG Description: Unconstrained TE LSP count(TE Label Switched Paths (LSPs)\nsignalled with zero bandwidth).", "id": "f22612:c0:m5"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/unconstrained_lsp/state (container)\n\nYANG Description: State parameters of sub-TLV 23.", "id": "f22613:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/unconstrained_lsp/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of sub-TLV 23.", "id": "f22613:c1:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/unconstrained_lsp/state (container)\n\nYANG Description: State parameters of sub-TLV 23.", "id": "f22613:c1:m2"}
{"signature": "def _set_weight(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__weight = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for weight, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/lan_adjacency_sid/sid/state/weight (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_weight is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_weight() directly.\n\n    YANG Description: Value that represents the weight of the Adj-SID for the purpose\nof load balancing.", "id": "f22615:c1:m9"}
{"signature": "def _get_neighbor_id(self):", "body": "return self.__neighbor_id<EOL>", "docstring": "Getter method for neighbor_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/lan_adjacency_sid/sid/state/neighbor_id (oc-isis-types:system-id)\n\n    YANG Description: System ID of the neighbor associated with the LAN-Adj-Segment-ID\nvalue.", "id": "f22615:c0:m11"}
{"signature": "def _get_neighbor_id(self):", "body": "return self.__neighbor_id<EOL>", "docstring": "Getter method for neighbor_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/lan_adjacency_sid/sid/state/neighbor_id (oc-isis-types:system-id)\n\n    YANG Description: System ID of the neighbor associated with the LAN-Adj-Segment-ID\nvalue.", "id": "f22615:c1:m11"}
{"signature": "def _set_flags(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__flags = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/lan_adjacency_sid/sid/state/flags (enumeration)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_flags is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_flags() directly.\n\nYANG Description: Flags associated with LAN-Adj-Segment-ID.", "id": "f22615:c0:m6"}
{"signature": "def _get_value(self):", "body": "return self.__value<EOL>", "docstring": "Getter method for value, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/lan_adjacency_sid/sid/state/value (uint32)\n\nYANG Description: LAN Adjacency-SID value.", "id": "f22615:c0:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/lan_adjacency_sid/sid/state (container)\n\nYANG Description: State parameters of LAN Adjacency-SID.", "id": "f22616:c1:m2"}
{"signature": "def _set_a_bit(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__a_bit = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for a_bit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/link_delay/state/a_bit (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_a_bit is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_a_bit() directly.\n\n    YANG Description: The A bit is set when the measured value of this parameter\nexceeds its configured maximum threshold. The A bit is cleared\nwhen the measured value falls below its configured reuse threshold.", "id": "f22617:c1:m6"}
{"signature": "def _get_a_bit(self):", "body": "return self.__a_bit<EOL>", "docstring": "Getter method for a_bit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/link_delay/state/a_bit (boolean)\n\n    YANG Description: The A bit is set when the measured value of this parameter\nexceeds its configured maximum threshold. The A bit is cleared\nwhen the measured value falls below its configured reuse threshold.", "id": "f22617:c1:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/link_delay/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of IS Extended Reachability sub-TLV 33.", "id": "f22618:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/link_delay/state (container)\n\nYANG Description: State parameters of IS Extended Reachability sub-TLV 33.", "id": "f22618:c1:m2"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/te_default_metric/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22619:c0:m2"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/te_default_metric/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22619:c1:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/te_default_metric/state (container)\n\nYANG Description: State parameters of sub-TLV 18.", "id": "f22620:c1:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/residual_bandwidth/state (container)\n\nYANG Description: State parameters of IS Extended Reachability sub-TLV 37.", "id": "f22622:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/residual_bandwidth/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of IS Extended Reachability sub-TLV 37.", "id": "f22622:c1:m3"}
{"signature": "def _set_ipv4_interface_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv4_interface_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv4_interface_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/ipv4_interface_address/state/ipv4_interface_address (inet:ipv4-address-no-zone)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_ipv4_interface_address is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_ipv4_interface_address() directly.\n\n    YANG Description: A 4-octet IPv4 address for the interface described by the\n(main) TLV. This sub-TLV can occur multiple times.", "id": "f22623:c0:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/ipv4_interface_address/state (container)\n\nYANG Description: State parameters of sub-TLV 6.", "id": "f22624:c1:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/ipv4_interface_address/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of sub-TLV 6.", "id": "f22624:c0:m3"}
{"signature": "def _set_max_link_bandwidth(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=bitarray, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__max_link_bandwidth = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for max_link_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/max_link_bandwidth/state/max_link_bandwidth (oc-types:ieeefloat32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_max_link_bandwidth is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_max_link_bandwidth() directly.\n\n    YANG Description: The maximum bandwidth that can be used on this link in this\ndirection (from the system originating the LSP to its\nneighbors).  It is encoded in 32 bits in IEEE floating point\nformat.  The units are bytes (not bits!) per second.", "id": "f22625:c0:m6"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/max_link_bandwidth/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22625:c1:m3"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/max_link_bandwidth/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22625:c0:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/max_link_bandwidth/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of sub-TLV 9.", "id": "f22626:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/max_link_bandwidth/state (container)\n\nYANG Description: State parameters of sub-TLV 9.", "id": "f22626:c1:m2"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/ipv6_interface_address/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22627:c0:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs/subTLVs/ipv6_interface_address/state (container)\n\nYANG Description: State parameters of sub-TLV 12.", "id": "f22628:c1:m2"}
{"signature": "def _set_undefined_subtlvs(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=undefined_subtlvs.undefined_subtlvs,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__undefined_subtlvs = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for undefined_subtlvs, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/undefined_subtlvs (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_undefined_subtlvs is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_undefined_subtlvs() directly.\n\nYANG Description: This container describes undefined ISIS TLVs.", "id": "f22629:c1:m9"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/state (container)\n\nYANG Description: State parameters of extended neighbor", "id": "f22629:c0:m2"}
{"signature": "def _set_subTLVs(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=subTLVs.subTLVs,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subTLVs = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subTLVs, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_subTLVs is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_subTLVs() directly.\n\nYANG Description: This container describes IS Neighbor sub-TLVs.", "id": "f22629:c0:m6"}
{"signature": "def _get_undefined_subtlvs(self):", "body": "return self.__undefined_subtlvs<EOL>", "docstring": "Getter method for undefined_subtlvs, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/undefined_subtlvs (container)\n\nYANG Description: This container describes undefined ISIS TLVs.", "id": "f22629:c1:m8"}
{"signature": "def _get_subTLVs(self):", "body": "return self.__subTLVs<EOL>", "docstring": "Getter method for subTLVs, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/subTLVs (container)\n\nYANG Description: This container describes IS Neighbor sub-TLVs.", "id": "f22629:c1:m5"}
{"signature": "def _set_undefined_subtlvs(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=undefined_subtlvs.undefined_subtlvs,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__undefined_subtlvs = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for undefined_subtlvs, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/undefined_subtlvs (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_undefined_subtlvs is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_undefined_subtlvs() directly.\n\nYANG Description: This container describes undefined ISIS TLVs.", "id": "f22629:c0:m9"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/undefined_subtlvs/undefined_subtlv/state/type (uint8)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_type is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_type() directly.\n\nYANG Description: TLV Type.", "id": "f22630:c0:m3"}
{"signature": "def _set_length(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__length = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for length, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/undefined_subtlvs/undefined_subtlv/state/length (uint8)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_length is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_length() directly.\n\nYANG Description: TLV length.", "id": "f22630:c1:m6"}
{"signature": "def _get_value(self):", "body": "return self.__value<EOL>", "docstring": "Getter method for value, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/undefined_subtlvs/undefined_subtlv/state/value (binary)\n\nYANG Description: TLV value.", "id": "f22630:c1:m8"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/undefined_subtlvs/undefined_subtlv/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of the undefined sub-TLV.", "id": "f22631:c1:m6"}
{"signature": "def _set_type(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/undefined_subtlvs/undefined_subtlv/type (leafref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_type is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_type() directly.\n\nYANG Description: A reference to a subTLV", "id": "f22631:c1:m3"}
{"signature": "def _get_undefined_subtlv(self):", "body": "return self.__undefined_subtlv<EOL>", "docstring": "Getter method for undefined_subtlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/undefined_subtlvs/undefined_subtlv (list)\n\n    YANG Description: Sub-TLVs that are not defined in the model or not recognised by\nsystem.", "id": "f22632:c1:m2"}
{"signature": "def _set_undefined_subtlv(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT:type>\",<EOL>undefined_subtlv.undefined_subtlv,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT:type>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__undefined_subtlv = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for undefined_subtlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors/neighbors/undefined_subtlvs/undefined_subtlv (list)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_undefined_subtlv is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_undefined_subtlv() directly.\n\n    YANG Description: Sub-TLVs that are not defined in the model or not recognised by\nsystem.", "id": "f22632:c1:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: This container describes extended IS reachability state", "id": "f22633:c1:m3"}
{"signature": "def _get_neighbors(self):", "body": "return self.__neighbors<EOL>", "docstring": "Getter method for neighbors, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors (container)\n\nYANG Description: This container describes IS neighbors.", "id": "f22633:c1:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: This container describes extended IS reachability state", "id": "f22633:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/state (container)\n\nYANG Description: This container describes extended IS reachability state", "id": "f22633:c1:m2"}
{"signature": "def _get_neighbors(self):", "body": "return self.__neighbors<EOL>", "docstring": "Getter method for neighbors, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/neighbors (container)\n\nYANG Description: This container describes IS neighbors.", "id": "f22633:c0:m5"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability/state (container)\n\nYANG Description: This container describes extended IS reachability state", "id": "f22633:c0:m2"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_internal_reachability/state/type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_type() directly.\n\n    YANG Description: The type of TLV being described. The type of TLV is\nexpressed as a canonical name.", "id": "f22634:c0:m3"}
{"signature": "def _set_up_down(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__up_down = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for up_down, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_internal_reachability/prefixes/prefixes/state/up_down (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_up_down is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_up_down() directly.\n\n    YANG Description: The up/down bit. Set if a prefix is advertised from a higher level to\na lower level (e.g., level 2 to level 1), indicating that the prefix\nhas traveled down the hierarchy. Prefixes that have the up/down bit\nset may only be advertised down the hierarchy, i.e., to lower levels.\nWhen a prefix is first injected into IS-IS, the bit is UNSET.", "id": "f22635:c0:m3"}
{"signature": "def _get_up_down(self):", "body": "return self.__up_down<EOL>", "docstring": "Getter method for up_down, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_internal_reachability/prefixes/prefixes/state/up_down (boolean)\n\n    YANG Description: The up/down bit. Set if a prefix is advertised from a higher level to\na lower level (e.g., level 2 to level 1), indicating that the prefix\nhas traveled down the hierarchy. Prefixes that have the up/down bit\nset may only be advertised down the hierarchy, i.e., to lower levels.\nWhen a prefix is first injected into IS-IS, the bit is UNSET.", "id": "f22635:c1:m2"}
{"signature": "def _get_ipv4_prefix(self):", "body": "return self.__ipv4_prefix<EOL>", "docstring": "Getter method for ipv4_prefix, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_internal_reachability/prefixes/prefixes/state/ipv4_prefix (inet:ipv4-prefix)\n\nYANG Description: IPv4 prefix contained within reachability TLVs.", "id": "f22635:c1:m5"}
{"signature": "def _set_ipv4_prefix(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv4_prefix = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv4_prefix, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_internal_reachability/prefixes/prefixes/state/ipv4_prefix (inet:ipv4-prefix)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ipv4_prefix is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ipv4_prefix() directly.\n\nYANG Description: IPv4 prefix contained within reachability TLVs.", "id": "f22635:c0:m6"}
{"signature": "def _set_ipv4_prefix(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv4_prefix = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv4_prefix, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_internal_reachability/prefixes/prefixes/state/ipv4_prefix (inet:ipv4-prefix)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ipv4_prefix is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ipv4_prefix() directly.\n\nYANG Description: IPv4 prefix contained within reachability TLVs.", "id": "f22635:c1:m6"}
{"signature": "def _set_default_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__default_metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for default_metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_internal_reachability/prefixes/prefixes/default_metric/state/default_metric (oc-isis-types:narrow-metric)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_default_metric is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_default_metric() directly.\n\n    YANG Description: ISIS default metric value. This is a metric understood by every\nIntermediate system in the domain. Each circuit shall have a\npositive  integral value assigned for this metric. The value may be\nassociated with any  objective function of the circuit, but by\nconvention is intended to measure the capacity of the circuit for\nhandling traffic, for example, its throughput in  bits-per-second.\nHigher values indicate a lower capacity.", "id": "f22636:c0:m6"}
{"signature": "def _set_flags(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__flags = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_internal_reachability/prefixes/prefixes/default_metric/state/flags (enumeration)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_flags is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_flags() directly.\n\nYANG Description: ISIS Default-Metric Flags.", "id": "f22636:c0:m3"}
{"signature": "def _set_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_internal_reachability/prefixes/prefixes/error_metric/state/metric (oc-isis-types:narrow-metric)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_metric is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_metric() directly.\n\n    YANG Description: ISIS error metric value. This metric measures the residual error\nprobability of the associated circuit. It is an optional metric,\nwhich if assigned to a circuit shall have a non-zero value. Higher\nvalues indicate a larger probability of undetected errors on the\ncircuit.", "id": "f22638:c0:m3"}
{"signature": "def _set_flags(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__flags = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_internal_reachability/prefixes/prefixes/error_metric/state/flags (isis-metric-flags)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_flags is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_flags() directly.\n\nYANG Description: IS-IS error metric flags.", "id": "f22638:c0:m6"}
{"signature": "def _get_flags(self):", "body": "return self.__flags<EOL>", "docstring": "Getter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_internal_reachability/prefixes/prefixes/error_metric/state/flags (isis-metric-flags)\n\nYANG Description: IS-IS error metric flags.", "id": "f22638:c1:m5"}
{"signature": "def _get_flags(self):", "body": "return self.__flags<EOL>", "docstring": "Getter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_internal_reachability/prefixes/prefixes/error_metric/state/flags (isis-metric-flags)\n\nYANG Description: IS-IS error metric flags.", "id": "f22638:c0:m5"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_internal_reachability/prefixes/prefixes/error_metric/state (container)\n\nYANG Description: State parameters of error-metric.", "id": "f22639:c1:m2"}
{"signature": "def _get_expense_metric(self):", "body": "return self.__expense_metric<EOL>", "docstring": "Getter method for expense_metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_internal_reachability/prefixes/prefixes/expense_metric (container)\n\nYANG Description: This container defines the ISIS expense metric.", "id": "f22640:c0:m11"}
{"signature": "def _get_default_metric(self):", "body": "return self.__default_metric<EOL>", "docstring": "Getter method for default_metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_internal_reachability/prefixes/prefixes/default_metric (container)\n\nYANG Description: This container defines ISIS Default Metric.", "id": "f22640:c1:m5"}
{"signature": "def _get_error_metric(self):", "body": "return self.__error_metric<EOL>", "docstring": "Getter method for error_metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_internal_reachability/prefixes/prefixes/error_metric (container)\n\nYANG Description: This container defines the ISIS error metric.", "id": "f22640:c0:m14"}
{"signature": "def _get_error_metric(self):", "body": "return self.__error_metric<EOL>", "docstring": "Getter method for error_metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_internal_reachability/prefixes/prefixes/error_metric (container)\n\nYANG Description: This container defines the ISIS error metric.", "id": "f22640:c1:m14"}
{"signature": "def _set_expense_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=expense_metric.expense_metric,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__expense_metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for expense_metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_internal_reachability/prefixes/prefixes/expense_metric (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_expense_metric is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_expense_metric() directly.\n\nYANG Description: This container defines the ISIS expense metric.", "id": "f22640:c1:m12"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_internal_reachability/prefixes/prefixes/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of IPv4 standard prefix.", "id": "f22640:c1:m3"}
{"signature": "def _get_metric(self):", "body": "return self.__metric<EOL>", "docstring": "Getter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_internal_reachability/prefixes/prefixes/expense_metric/state/metric (oc-isis-types:narrow-metric)\n\n    YANG Description: ISIS expense metric value. This metric measures the monetary cost\nof utilising the associated circuit. It is an optional metric, which\nif assigned to a circuit shall have a positive integral value1).\nHigher values indicate a larger monetary expense.", "id": "f22641:c0:m2"}
{"signature": "def _get_metric(self):", "body": "return self.__metric<EOL>", "docstring": "Getter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_internal_reachability/prefixes/prefixes/expense_metric/state/metric (oc-isis-types:narrow-metric)\n\n    YANG Description: ISIS expense metric value. This metric measures the monetary cost\nof utilising the associated circuit. It is an optional metric, which\nif assigned to a circuit shall have a positive integral value1).\nHigher values indicate a larger monetary expense.", "id": "f22641:c1:m2"}
{"signature": "def _get_flags(self):", "body": "return self.__flags<EOL>", "docstring": "Getter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_internal_reachability/prefixes/prefixes/expense_metric/state/flags (isis-metric-flags)\n\nYANG Description: ISIS Expense Metric Flags.", "id": "f22641:c0:m5"}
{"signature": "def _set_flags(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__flags = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_internal_reachability/prefixes/prefixes/expense_metric/state/flags (isis-metric-flags)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_flags is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_flags() directly.\n\nYANG Description: ISIS Expense Metric Flags.", "id": "f22641:c0:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_internal_reachability/prefixes/prefixes/expense_metric/state (container)\n\nYANG Description: State parameters of expense-metric.", "id": "f22642:c0:m2"}
{"signature": "def _set_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_internal_reachability/prefixes/prefixes/delay_metric/state/metric (oc-isis-types:narrow-metric)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_metric is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_metric() directly.\n\n    YANG Description: ISIS delay metric value. This metric measures the transit delay of\nthe associated circuit. It is an optional metric, which if assigned\nto a circuit shall have a positive integral value. Higher values\nindicate a longer transit delay.", "id": "f22643:c0:m3"}
{"signature": "def _set_flags(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__flags = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_internal_reachability/prefixes/prefixes/delay_metric/state/flags (isis-metric-flags)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_flags is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_flags() directly.\n\nYANG Description: ISIS Delay Metric Flags.", "id": "f22643:c0:m6"}
{"signature": "def _get_prefixes(self):", "body": "return self.__prefixes<EOL>", "docstring": "Getter method for prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_internal_reachability/prefixes/prefixes (list)\n\nYANG Description: IPv4 prefixes and internal reachability attributes.", "id": "f22645:c0:m2"}
{"signature": "def _set_prefixes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>False,<EOL>prefixes_.prefixes,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT:False>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prefixes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_internal_reachability/prefixes/prefixes (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_prefixes is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_prefixes() directly.\n\nYANG Description: IPv4 prefixes and internal reachability attributes.", "id": "f22645:c0:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_internal_reachability/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: This container describes IS IPv4 internal reachability state", "id": "f22646:c1:m3"}
{"signature": "def _set_nlpid(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__nlpid = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for nlpid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/nlpid/state/nlpid (enumeration)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_nlpid is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_nlpid() directly.\n\n    YANG Description: Protocol supported. IPv4 is defined as (0xcc) and IPv6 -\n(0x8e)", "id": "f22647:c0:m6"}
{"signature": "def _get_type(self):", "body": "return self.__type<EOL>", "docstring": "Getter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_te_router_id/state/type (identityref)\n\n    YANG Description: The type of TLV being described. The type of TLV is\nexpressed as a canonical name.", "id": "f22649:c1:m2"}
{"signature": "def _get_ipv4_te_router_id(self):", "body": "return self.__ipv4_te_router_id<EOL>", "docstring": "Getter method for ipv4_te_router_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_te_router_id/state/ipv4_te_router_id (inet:ipv4-address-no-zone)\n\n    YANG Description: IPv4 Traffic Engineering router ID of the node. For traffic\nengineering, it guarantees that we have a single stable address\nthat can always be referenced in a path that will be reachable\nfrom multiple hops away, regardless of the state of the node's\ninterfaces.", "id": "f22649:c0:m5"}
{"signature": "def _get_type(self):", "body": "return self.__type<EOL>", "docstring": "Getter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_te_router_id/state/type (identityref)\n\n    YANG Description: The type of TLV being described. The type of TLV is\nexpressed as a canonical name.", "id": "f22651:c1:m2"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_te_router_id/state/type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_type() directly.\n\n    YANG Description: The type of TLV being described. The type of TLV is\nexpressed as a canonical name.", "id": "f22651:c0:m3"}
{"signature": "def _get_type(self):", "body": "return self.__type<EOL>", "docstring": "Getter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_te_router_id/state/type (identityref)\n\n    YANG Description: The type of TLV being described. The type of TLV is\nexpressed as a canonical name.", "id": "f22651:c0:m2"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/state/type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_type() directly.\n\n    YANG Description: The type of TLV being described. The type of TLV is\nexpressed as a canonical name.", "id": "f22653:c0:m3"}
{"signature": "def _get_type(self):", "body": "return self.__type<EOL>", "docstring": "Getter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/state/type (identityref)\n\n    YANG Description: The type of TLV being described. The type of TLV is\nexpressed as a canonical name.", "id": "f22653:c1:m2"}
{"signature": "def _set_up_down(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__up_down = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for up_down, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/state/up_down (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_up_down is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_up_down() directly.\n\n    YANG Description: The up/down bit. Set if a prefix is advertised from a higher level to\na lower level (e.g., level 2 to level 1), indicating that the prefix\nhas traveled down the hierarchy. Prefixes that have the up/down bit\nset may only be advertised down the hierarchy, i.e., to lower levels.\nWhen a prefix is first injected into IS-IS, the bit is UNSET.", "id": "f22654:c1:m3"}
{"signature": "def _set_ipv6_prefix(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv6_prefix = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv6_prefix, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/state/ipv6_prefix (inet:ipv6-prefix)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ipv6_prefix is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ipv6_prefix() directly.\n\nYANG Description: IPv6 prefix contained within extended reachability TLVs.", "id": "f22654:c1:m12"}
{"signature": "def _set_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/state/metric (oc-isis-types:wide-metric)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_metric is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_metric() directly.\n\nYANG Description: ISIS metric value.", "id": "f22654:c0:m15"}
{"signature": "def _get_up_down(self):", "body": "return self.__up_down<EOL>", "docstring": "Getter method for up_down, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/state/up_down (boolean)\n\n    YANG Description: The up/down bit. Set if a prefix is advertised from a higher level to\na lower level (e.g., level 2 to level 1), indicating that the prefix\nhas traveled down the hierarchy. Prefixes that have the up/down bit\nset may only be advertised down the hierarchy, i.e., to lower levels.\nWhen a prefix is first injected into IS-IS, the bit is UNSET.", "id": "f22654:c0:m2"}
{"signature": "def _set_up_down(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__up_down = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for up_down, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/state/up_down (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_up_down is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_up_down() directly.\n\n    YANG Description: The up/down bit. Set if a prefix is advertised from a higher level to\na lower level (e.g., level 2 to level 1), indicating that the prefix\nhas traveled down the hierarchy. Prefixes that have the up/down bit\nset may only be advertised down the hierarchy, i.e., to lower levels.\nWhen a prefix is first injected into IS-IS, the bit is UNSET.", "id": "f22654:c0:m3"}
{"signature": "def _set_subTLVs(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>subTLVs_.subTLVs,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subTLVs = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subTLVs, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/subTLVs/subTLVs (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_subTLVs is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_subTLVs() directly.\n\nYANG Description: List of subTLV types in the LSDB for the specified TLV.", "id": "f22655:c0:m3"}
{"signature": "def _set_subTLVs(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>subTLVs_.subTLVs,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subTLVs = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subTLVs, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/subTLVs/subTLVs (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_subTLVs is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_subTLVs() directly.\n\nYANG Description: List of subTLV types in the LSDB for the specified TLV.", "id": "f22655:c1:m3"}
{"signature": "def _get_subTLVs(self):", "body": "return self.__subTLVs<EOL>", "docstring": "Getter method for subTLVs, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/subTLVs/subTLVs (list)\n\nYANG Description: List of subTLV types in the LSDB for the specified TLV.", "id": "f22655:c0:m2"}
{"signature": "def _set_ipv6_source_router_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv6_source_router_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv6_source_router_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/subTLVs/subTLVs/ipv6_source_router_id/state/ipv6_source_router_id (inet:ipv6-address)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_ipv6_source_router_id is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_ipv6_source_router_id() directly.\n\n    YANG Description: IPv6 Source router ID address. In cases where the advertisement\nis an identifier for the advertising router (e.g., with the\nN-flag set in the Prefix Attribute Flags sub-TLV), it may be\nuseful for other routers to know the source of the\nadvertisement. When reachability advertisement is leaked from\none level to another, Router ID advertised is always the Router\nID of the IS-IS instance that originated the advertisement.\nThis would be true even if the prefix had been learned from\nanother protocol.", "id": "f22656:c1:m6"}
{"signature": "def _set_ipv6_source_router_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv6_source_router_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv6_source_router_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/subTLVs/subTLVs/ipv6_source_router_id/state/ipv6_source_router_id (inet:ipv6-address)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_ipv6_source_router_id is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_ipv6_source_router_id() directly.\n\n    YANG Description: IPv6 Source router ID address. In cases where the advertisement\nis an identifier for the advertising router (e.g., with the\nN-flag set in the Prefix Attribute Flags sub-TLV), it may be\nuseful for other routers to know the source of the\nadvertisement. When reachability advertisement is leaked from\none level to another, Router ID advertised is always the Router\nID of the IS-IS instance that originated the advertisement.\nThis would be true even if the prefix had been learned from\nanother protocol.", "id": "f22656:c0:m6"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/subTLVs/subTLVs/ipv6_source_router_id/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22656:c1:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/subTLVs/subTLVs/ipv6_source_router_id/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of sub-TLV 12.", "id": "f22657:c1:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/subTLVs/subTLVs/ipv6_source_router_id/state (container)\n\nYANG Description: State parameters of sub-TLV 12.", "id": "f22657:c1:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/subTLVs/subTLVs/ipv6_source_router_id/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of sub-TLV 12.", "id": "f22657:c0:m3"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/subTLVs/subTLVs/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22658:c0:m2"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/subTLVs/subTLVs/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22658:c1:m3"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/subTLVs/subTLVs/flags/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22659:c0:m2"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/subTLVs/subTLVs/flags/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22659:c1:m3"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/subTLVs/subTLVs/flags/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22659:c1:m2"}
{"signature": "def _get_tag(self):", "body": "return self.__tag<EOL>", "docstring": "Getter method for tag, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/subTLVs/subTLVs/tag (container)\n\nYANG Description: This container defines sub-TLV 1.", "id": "f22661:c0:m8"}
{"signature": "def _get_ipv6_source_router_id(self):", "body": "return self.__ipv6_source_router_id<EOL>", "docstring": "Getter method for ipv6_source_router_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/subTLVs/subTLVs/ipv6_source_router_id (container)\n\nYANG Description: This container defines sub-TLV 12.", "id": "f22661:c0:m20"}
{"signature": "def _get_flags(self):", "body": "return self.__flags<EOL>", "docstring": "Getter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/subTLVs/subTLVs/flags (container)\n\nYANG Description: This container defines sub-TLV 4.", "id": "f22661:c1:m14"}
{"signature": "def _get_prefix_sid(self):", "body": "return self.__prefix_sid<EOL>", "docstring": "Getter method for prefix_sid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/subTLVs/subTLVs/prefix_sid (container)\n\nYANG Description: This container defines segment routing extensions for prefixes.", "id": "f22661:c0:m23"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/subTLVs/subTLVs/subtlv_type (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: A reference for the TLV type being described within\nthe LSDB", "id": "f22661:c0:m3"}
{"signature": "def _set_ipv4_source_router_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=ipv4_source_router_id.ipv4_source_router_id,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv4_source_router_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv4_source_router_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/subTLVs/subTLVs/ipv4_source_router_id (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ipv4_source_router_id is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ipv4_source_router_id() directly.\n\nYANG Description: This container defines sub-TLV 11.", "id": "f22661:c0:m18"}
{"signature": "def _set_ipv6_source_router_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=ipv6_source_router_id.ipv6_source_router_id,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv6_source_router_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv6_source_router_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/subTLVs/subTLVs/ipv6_source_router_id (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ipv6_source_router_id is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ipv6_source_router_id() directly.\n\nYANG Description: This container defines sub-TLV 12.", "id": "f22661:c1:m21"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/subTLVs/subTLVs/tag64/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22662:c0:m3"}
{"signature": "def _set_tag64(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__tag64 = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for tag64, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/subTLVs/subTLVs/tag64/state/tag64 (uint64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_tag64 is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_tag64() directly.\n\n    YANG Description: List of 64-bit tags associated with the prefix. Example uses of\nthese tags include carrying BGP standard (or extended) communities\nand controlling redistribution between levels and areas, different\nrouting protocols, or multiple instances of IS-IS running on the\nsame router.", "id": "f22662:c1:m6"}
{"signature": "def _get_tag64(self):", "body": "return self.__tag64<EOL>", "docstring": "Getter method for tag64, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/subTLVs/subTLVs/tag64/state/tag64 (uint64)\n\n    YANG Description: List of 64-bit tags associated with the prefix. Example uses of\nthese tags include carrying BGP standard (or extended) communities\nand controlling redistribution between levels and areas, different\nrouting protocols, or multiple instances of IS-IS running on the\nsame router.", "id": "f22662:c0:m5"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/subTLVs/subTLVs/ipv4_source_router_id/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22664:c1:m3"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/subTLVs/subTLVs/ipv4_source_router_id/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22664:c1:m2"}
{"signature": "def _get_ipv4_source_router_id(self):", "body": "return self.__ipv4_source_router_id<EOL>", "docstring": "Getter method for ipv4_source_router_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/subTLVs/subTLVs/ipv4_source_router_id/state/ipv4_source_router_id (inet:ipv4-address-no-zone)\n\n    YANG Description: IPv4 Source router ID address. In cases where the advertisement\nis an identifier for the advertising router (e.g., with the\nN-flag set in the Prefix Attribute Flags sub-TLV), it may be\nuseful for other routers to know the source of the\nadvertisement. When reachability advertisement is leaked from\none level to another, Router ID advertised is always the Router\nID of the IS-IS instance that originated the advertisement.\nThis would be true even if the prefix had been learned from\nanother protocol.", "id": "f22664:c0:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/subTLVs/subTLVs/ipv4_source_router_id/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of sub-TLV 11.", "id": "f22665:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/subTLVs/subTLVs/ipv4_source_router_id/state (container)\n\nYANG Description: State parameters of sub-TLV 11.", "id": "f22665:c0:m2"}
{"signature": "def _get_sid(self):", "body": "return self.__sid<EOL>", "docstring": "Getter method for sid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/subTLVs/subTLVs/prefix_sid/sid (list)\n\n    YANG Description: Prefix Segment-ID list. IGP-Prefix Segment is an IGP segment attached\nto an IGP prefix. An IGP-Prefix Segment is global (unless explicitly\nadvertised otherwise) within the SR/IGP domain.", "id": "f22666:c1:m2"}
{"signature": "def _set_value(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:value>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__value = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for value, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/subTLVs/subTLVs/prefix_sid/sid/state/value (uint32)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_value is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_value() directly.\n\nYANG Description: IGP Prefix-SID value.", "id": "f22667:c0:m6"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/subTLVs/subTLVs/prefix_sid/sid/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22667:c0:m3"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/subTLVs/subTLVs/prefix_sid/sid/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22667:c0:m2"}
{"signature": "def _set_algorithm(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__algorithm = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for algorithm, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/subTLVs/subTLVs/prefix_sid/sid/state/algorithm (uint8)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_algorithm is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_algorithm() directly.\n\nYANG Description: Prefix-SID algorithm to be used for path computation.", "id": "f22667:c1:m12"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/subTLVs/subTLVs/prefix_sid/sid/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters for Prefix-SID.", "id": "f22668:c1:m3"}
{"signature": "def _set_tag32(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__tag32 = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for tag32, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/subTLVs/subTLVs/tag/state/tag32 (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_tag32 is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_tag32() directly.\n\n    YANG Description: List of 32-bit tags associated with the prefix. Example uses of\nthese tags include carrying BGP standard (or extended) communities\nand controlling redistribution between levels and areas, different\nrouting protocols, or multiple instances of IS-IS running on the\nsame router.", "id": "f22669:c1:m6"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/subTLVs/subTLVs/tag/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of sub-TLV 1.", "id": "f22670:c1:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/subTLVs/subTLVs/tag/state (container)\n\nYANG Description: State parameters of sub-TLV 1.", "id": "f22670:c0:m2"}
{"signature": "def _set_subTLVs(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=subTLVs.subTLVs,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subTLVs = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subTLVs, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/subTLVs (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_subTLVs is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_subTLVs() directly.\n\nYANG Description: This container describes IS prefix sub-TLVs.", "id": "f22671:c0:m6"}
{"signature": "def _set_subTLVs(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=subTLVs.subTLVs,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subTLVs = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subTLVs, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/subTLVs (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_subTLVs is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_subTLVs() directly.\n\nYANG Description: This container describes IS prefix sub-TLVs.", "id": "f22671:c1:m6"}
{"signature": "def _set_undefined_subtlvs(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=undefined_subtlvs.undefined_subtlvs,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__undefined_subtlvs = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for undefined_subtlvs, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/undefined_subtlvs (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_undefined_subtlvs is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_undefined_subtlvs() directly.\n\nYANG Description: This container describes undefined ISIS TLVs.", "id": "f22671:c1:m9"}
{"signature": "def _get_subTLVs(self):", "body": "return self.__subTLVs<EOL>", "docstring": "Getter method for subTLVs, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/subTLVs (container)\n\nYANG Description: This container describes IS prefix sub-TLVs.", "id": "f22671:c0:m5"}
{"signature": "def _set_length(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__length = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for length, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/undefined_subtlvs/undefined_subtlv/state/length (uint8)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_length is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_length() directly.\n\nYANG Description: TLV length.", "id": "f22672:c1:m6"}
{"signature": "def _get_value(self):", "body": "return self.__value<EOL>", "docstring": "Getter method for value, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/undefined_subtlvs/undefined_subtlv/state/value (binary)\n\nYANG Description: TLV value.", "id": "f22672:c0:m8"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/undefined_subtlvs/undefined_subtlv/state/type (uint8)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_type is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_type() directly.\n\nYANG Description: TLV Type.", "id": "f22672:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/undefined_subtlvs/undefined_subtlv/state (container)\n\nYANG Description: State parameters of the undefined sub-TLV.", "id": "f22673:c0:m5"}
{"signature": "def _get_type(self):", "body": "return self.__type<EOL>", "docstring": "Getter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/undefined_subtlvs/undefined_subtlv/type (leafref)\n\nYANG Description: A reference to a subTLV", "id": "f22673:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes/undefined_subtlvs/undefined_subtlv/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of the undefined sub-TLV.", "id": "f22673:c1:m6"}
{"signature": "def _set_prefixes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>False,<EOL>prefixes_.prefixes,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT:False>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prefixes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_prefixes is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_prefixes() directly.\n\nYANG Description: This list defines IPv6 extended prefix attributes.", "id": "f22675:c0:m3"}
{"signature": "def _get_prefixes(self):", "body": "return self.__prefixes<EOL>", "docstring": "Getter method for prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes/prefixes (list)\n\nYANG Description: This list defines IPv6 extended prefix attributes.", "id": "f22675:c1:m2"}
{"signature": "def _get_prefixes(self):", "body": "return self.__prefixes<EOL>", "docstring": "Getter method for prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/prefixes (container)\n\nYANG Description: This container describes IS prefixes.", "id": "f22676:c0:m5"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_reachability/state (container)\n\nYANG Description: This container describes IS IPv6 reachability state", "id": "f22676:c0:m2"}
{"signature": "def _get_metric(self):", "body": "return self.__metric<EOL>", "docstring": "Getter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/state/metric (oc-isis-types:wide-metric)\n\nYANG Description: ISIS metric value.", "id": "f22678:c1:m11"}
{"signature": "def _get_s_bit(self):", "body": "return self.__s_bit<EOL>", "docstring": "Getter method for s_bit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/state/s_bit (boolean)\n\n    YANG Description: The Sub-TLV present bit. If UNSET, the octets of Sub-TLVs are not\npresent. Otherwise, the bit is set and the octet following the prefix\nwill contain the length of the Sub-TLV portion of the structure.", "id": "f22678:c1:m5"}
{"signature": "def _set_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/state/metric (oc-isis-types:wide-metric)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_metric is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_metric() directly.\n\nYANG Description: ISIS metric value.", "id": "f22678:c0:m12"}
{"signature": "def _set_subTLVs(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>subTLVs_.subTLVs,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subTLVs = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subTLVs, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_subTLVs is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_subTLVs() directly.\n\nYANG Description: List of subTLV types in the LSDB for the specified TLV.", "id": "f22679:c1:m3"}
{"signature": "def _set_ipv6_source_router_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv6_source_router_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv6_source_router_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/ipv6_source_router_id/state/ipv6_source_router_id (inet:ipv6-address)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_ipv6_source_router_id is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_ipv6_source_router_id() directly.\n\n    YANG Description: IPv6 Source router ID address. In cases where the advertisement\nis an identifier for the advertising router (e.g., with the\nN-flag set in the Prefix Attribute Flags sub-TLV), it may be\nuseful for other routers to know the source of the\nadvertisement. When reachability advertisement is leaked from\none level to another, Router ID advertised is always the Router\nID of the IS-IS instance that originated the advertisement.\nThis would be true even if the prefix had been learned from\nanother protocol.", "id": "f22680:c1:m6"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/ipv6_source_router_id/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22680:c1:m3"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/ipv6_source_router_id/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22680:c0:m2"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/ipv6_source_router_id/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22680:c1:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/ipv6_source_router_id/state (container)\n\nYANG Description: State parameters of sub-TLV 12.", "id": "f22681:c1:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/ipv6_source_router_id/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of sub-TLV 12.", "id": "f22681:c0:m3"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22682:c1:m2"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22682:c0:m3"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22682:c0:m2"}
{"signature": "def _set_flags(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__flags = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/flags/state/flags (enumeration)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_flags is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_flags() directly.\n\nYANG Description: Additional prefix reachability flags.", "id": "f22683:c0:m6"}
{"signature": "def _set_flags(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__flags = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/flags/state/flags (enumeration)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_flags is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_flags() directly.\n\nYANG Description: Additional prefix reachability flags.", "id": "f22683:c1:m6"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/flags/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of sub-TLV 4.", "id": "f22684:c0:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/flags/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of sub-TLV 4.", "id": "f22684:c1:m3"}
{"signature": "def _set_prefix_sid(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=prefix_sid.prefix_sid,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prefix_sid = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prefix_sid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/prefix_sid (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_prefix_sid is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_prefix_sid() directly.\n\nYANG Description: This container defines segment routing extensions for prefixes.", "id": "f22685:c0:m24"}
{"signature": "def _get_ipv6_source_router_id(self):", "body": "return self.__ipv6_source_router_id<EOL>", "docstring": "Getter method for ipv6_source_router_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/ipv6_source_router_id (container)\n\nYANG Description: This container defines sub-TLV 12.", "id": "f22685:c0:m20"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters for a prefix.", "id": "f22685:c0:m6"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/subtlv_type (leafref)\n\n    YANG Description: A reference for the TLV type being described within\nthe LSDB", "id": "f22685:c1:m2"}
{"signature": "def _set_flags(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=flags.flags,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__flags = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/flags (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_flags is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_flags() directly.\n\nYANG Description: This container defines sub-TLV 4.", "id": "f22685:c1:m15"}
{"signature": "def _set_tag64(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__tag64 = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for tag64, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/tag64/state/tag64 (uint64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_tag64 is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_tag64() directly.\n\n    YANG Description: List of 64-bit tags associated with the prefix. Example uses of\nthese tags include carrying BGP standard (or extended) communities\nand controlling redistribution between levels and areas, different\nrouting protocols, or multiple instances of IS-IS running on the\nsame router.", "id": "f22686:c0:m6"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/tag64/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22686:c1:m2"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/tag64/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22686:c0:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/tag64/state (container)\n\nYANG Description: State parameters of sub-TLV 2.", "id": "f22687:c1:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/tag64/state (container)\n\nYANG Description: State parameters of sub-TLV 2.", "id": "f22687:c0:m2"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/ipv4_source_router_id/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22688:c1:m3"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/ipv4_source_router_id/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22688:c1:m2"}
{"signature": "def _get_ipv4_source_router_id(self):", "body": "return self.__ipv4_source_router_id<EOL>", "docstring": "Getter method for ipv4_source_router_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/ipv4_source_router_id/state/ipv4_source_router_id (inet:ipv4-address-no-zone)\n\n    YANG Description: IPv4 Source router ID address. In cases where the advertisement\nis an identifier for the advertising router (e.g., with the\nN-flag set in the Prefix Attribute Flags sub-TLV), it may be\nuseful for other routers to know the source of the\nadvertisement. When reachability advertisement is leaked from\none level to another, Router ID advertised is always the Router\nID of the IS-IS instance that originated the advertisement.\nThis would be true even if the prefix had been learned from\nanother protocol.", "id": "f22688:c0:m5"}
{"signature": "def _set_sid(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>False,<EOL>sid.sid,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT:False>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__sid = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for sid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/prefix_sid/sid (list)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_sid is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_sid() directly.\n\n    YANG Description: Prefix Segment-ID list. IGP-Prefix Segment is an IGP segment attached\nto an IGP prefix. An IGP-Prefix Segment is global (unless explicitly\nadvertised otherwise) within the SR/IGP domain.", "id": "f22690:c0:m3"}
{"signature": "def _get_sid(self):", "body": "return self.__sid<EOL>", "docstring": "Getter method for sid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/prefix_sid/sid (list)\n\n    YANG Description: Prefix Segment-ID list. IGP-Prefix Segment is an IGP segment attached\nto an IGP prefix. An IGP-Prefix Segment is global (unless explicitly\nadvertised otherwise) within the SR/IGP domain.", "id": "f22690:c1:m2"}
{"signature": "def _set_sid(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>False,<EOL>sid.sid,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT:False>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__sid = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for sid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/prefix_sid/sid (list)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_sid is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_sid() directly.\n\n    YANG Description: Prefix Segment-ID list. IGP-Prefix Segment is an IGP segment attached\nto an IGP prefix. An IGP-Prefix Segment is global (unless explicitly\nadvertised otherwise) within the SR/IGP domain.", "id": "f22690:c1:m3"}
{"signature": "def _get_flags(self):", "body": "return self.__flags<EOL>", "docstring": "Getter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/prefix_sid/sid/state/flags (enumeration)\n\nYANG Description: Flags associated with Prefix Segment-ID.", "id": "f22691:c1:m8"}
{"signature": "def _set_value(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:value>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__value = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for value, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/prefix_sid/sid/state/value (uint32)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_value is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_value() directly.\n\nYANG Description: IGP Prefix-SID value.", "id": "f22691:c0:m6"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/prefix_sid/sid/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22691:c1:m3"}
{"signature": "def _set_flags(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__flags = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/prefix_sid/sid/state/flags (enumeration)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_flags is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_flags() directly.\n\nYANG Description: Flags associated with Prefix Segment-ID.", "id": "f22691:c0:m9"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/prefix_sid/sid/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters for Prefix-SID.", "id": "f22692:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/prefix_sid/sid/state (container)\n\nYANG Description: State parameters for Prefix-SID.", "id": "f22692:c1:m2"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/tag/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22693:c1:m3"}
{"signature": "def _get_tag32(self):", "body": "return self.__tag32<EOL>", "docstring": "Getter method for tag32, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/tag/state/tag32 (uint32)\n\n    YANG Description: List of 32-bit tags associated with the prefix. Example uses of\nthese tags include carrying BGP standard (or extended) communities\nand controlling redistribution between levels and areas, different\nrouting protocols, or multiple instances of IS-IS running on the\nsame router.", "id": "f22693:c1:m5"}
{"signature": "def _get_tag32(self):", "body": "return self.__tag32<EOL>", "docstring": "Getter method for tag32, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/tag/state/tag32 (uint32)\n\n    YANG Description: List of 32-bit tags associated with the prefix. Example uses of\nthese tags include carrying BGP standard (or extended) communities\nand controlling redistribution between levels and areas, different\nrouting protocols, or multiple instances of IS-IS running on the\nsame router.", "id": "f22693:c0:m5"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/tag/state (container)\n\nYANG Description: State parameters of sub-TLV 1.", "id": "f22694:c1:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/tag/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of sub-TLV 1.", "id": "f22694:c0:m3"}
{"signature": "def _get_mt_id(self):", "body": "return self.__mt_id<EOL>", "docstring": "Getter method for mt_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/mt/state/mt_id (uint16)\n\nYANG Description: Multi-topology ID.", "id": "f22695:c0:m2"}
{"signature": "def _set_mt_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:16>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__mt_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for mt_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/mt/state/mt_id (uint16)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_mt_id is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_mt_id() directly.\n\nYANG Description: Multi-topology ID.", "id": "f22695:c1:m3"}
{"signature": "def _get_mt_id(self):", "body": "return self.__mt_id<EOL>", "docstring": "Getter method for mt_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/mt/state/mt_id (uint16)\n\nYANG Description: Multi-topology ID.", "id": "f22695:c1:m2"}
{"signature": "def _set_mt(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=mt.mt,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__mt = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for mt, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/mt (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_mt is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_mt() directly.\n\nYANG Description: Multi-topology parameters.", "id": "f22697:c1:m3"}
{"signature": "def _set_subTLVs(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=subTLVs.subTLVs,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subTLVs = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subTLVs, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/subTLVs (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_subTLVs is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_subTLVs() directly.\n\nYANG Description: This container describes IS prefix sub-TLVs.", "id": "f22697:c0:m9"}
{"signature": "def _get_subTLVs(self):", "body": "return self.__subTLVs<EOL>", "docstring": "Getter method for subTLVs, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/subTLVs (container)\n\nYANG Description: This container describes IS prefix sub-TLVs.", "id": "f22697:c0:m8"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/undefined_subtlvs/undefined_subtlv/state/type (uint8)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_type is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_type() directly.\n\nYANG Description: TLV Type.", "id": "f22698:c1:m3"}
{"signature": "def _set_length(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__length = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for length, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/undefined_subtlvs/undefined_subtlv/state/length (uint8)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_length is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_length() directly.\n\nYANG Description: TLV length.", "id": "f22698:c0:m6"}
{"signature": "def _get_type(self):", "body": "return self.__type<EOL>", "docstring": "Getter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/undefined_subtlvs/undefined_subtlv/state/type (uint8)\n\nYANG Description: TLV Type.", "id": "f22698:c0:m2"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/undefined_subtlvs/undefined_subtlv/state/type (uint8)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_type is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_type() directly.\n\nYANG Description: TLV Type.", "id": "f22698:c0:m3"}
{"signature": "def _set_value(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=bitarray,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:value>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__value = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for value, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/undefined_subtlvs/undefined_subtlv/state/value (binary)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_value is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_value() directly.\n\nYANG Description: TLV value.", "id": "f22698:c1:m9"}
{"signature": "def _get_length(self):", "body": "return self.__length<EOL>", "docstring": "Getter method for length, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/undefined_subtlvs/undefined_subtlv/state/length (uint8)\n\nYANG Description: TLV length.", "id": "f22698:c1:m5"}
{"signature": "def _get_undefined_subtlv(self):", "body": "return self.__undefined_subtlv<EOL>", "docstring": "Getter method for undefined_subtlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/undefined_subtlvs/undefined_subtlv (list)\n\n    YANG Description: Sub-TLVs that are not defined in the model or not recognised by\nsystem.", "id": "f22700:c0:m2"}
{"signature": "def _set_undefined_subtlv(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT:type>\",<EOL>undefined_subtlv.undefined_subtlv,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT:type>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__undefined_subtlv = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for undefined_subtlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix/undefined_subtlvs/undefined_subtlv (list)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_undefined_subtlv is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_undefined_subtlv() directly.\n\n    YANG Description: Sub-TLVs that are not defined in the model or not recognised by\nsystem.", "id": "f22700:c1:m3"}
{"signature": "def _set_prefix(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>False,<EOL>prefix.prefix,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT:False>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prefix = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prefix, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_prefix is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_prefix() directly.\n\nYANG Description: IPv4 prefixes that are contained within MT reachability TLV.", "id": "f22701:c1:m3"}
{"signature": "def _get_prefix(self):", "body": "return self.__prefix<EOL>", "docstring": "Getter method for prefix, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes/prefix (list)\n\nYANG Description: IPv4 prefixes that are contained within MT reachability TLV.", "id": "f22701:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: This container describes IS MT IPv4 reachability state.", "id": "f22702:c0:m3"}
{"signature": "def _set_prefixes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=prefixes.prefixes,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prefixes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv4_reachability/prefixes (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_prefixes is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_prefixes() directly.\n\nYANG Description: This container describes IS prefixes.", "id": "f22702:c0:m6"}
{"signature": "def _get_metric(self):", "body": "return self.__metric<EOL>", "docstring": "Getter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/state/metric (oc-isis-types:wide-metric)\n\nYANG Description: Metric value.", "id": "f22704:c0:m5"}
{"signature": "def _set_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/state/metric (oc-isis-types:wide-metric)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_metric is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_metric() directly.\n\nYANG Description: Metric value.", "id": "f22704:c0:m6"}
{"signature": "def _set_subTLVs(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>subTLVs_.subTLVs,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subTLVs = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subTLVs, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_subTLVs is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_subTLVs() directly.\n\nYANG Description: List of subTLV types in the LSDB for the specified TLV.", "id": "f22705:c1:m3"}
{"signature": "def _get_available_bandwidth(self):", "body": "return self.__available_bandwidth<EOL>", "docstring": "Getter method for available_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/available_bandwidth/state/available_bandwidth (oc-types:ieeefloat32)\n\n    YANG Description: The available bandwidth on a link, forwarding adjacency, or\nbundled link in IEEE floating-point format with units of bytes\nper second. For a link or forwarding adjacency, available\nbandwidth is defined to be residual bandwidth minus the measured\nbandwidth used for the actual forwarding of non-RSVP-TE label\nswitched path packets.  For a bundled link, available bandwidth\nis defined to be the sum of the component link available\nbandwidths minus the measured bandwidth used for the actual\nforwarding of non-RSVP-TE label switched path packets.  For a\nbundled link, available bandwidth is defined to be the sum of\nthe component link available bandwidths.", "id": "f22706:c0:m5"}
{"signature": "def _get_available_bandwidth(self):", "body": "return self.__available_bandwidth<EOL>", "docstring": "Getter method for available_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/available_bandwidth/state/available_bandwidth (oc-types:ieeefloat32)\n\n    YANG Description: The available bandwidth on a link, forwarding adjacency, or\nbundled link in IEEE floating-point format with units of bytes\nper second. For a link or forwarding adjacency, available\nbandwidth is defined to be residual bandwidth minus the measured\nbandwidth used for the actual forwarding of non-RSVP-TE label\nswitched path packets.  For a bundled link, available bandwidth\nis defined to be the sum of the component link available\nbandwidths minus the measured bandwidth used for the actual\nforwarding of non-RSVP-TE label switched path packets.  For a\nbundled link, available bandwidth is defined to be the sum of\nthe component link available bandwidths.", "id": "f22706:c1:m5"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/available_bandwidth/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22706:c0:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/available_bandwidth/state (container)\n\nYANG Description: State parameters of IS Extended Reachability sub-TLV 38.", "id": "f22707:c0:m2"}
{"signature": "def _set_sid(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>False,<EOL>sid.sid,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT:False>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__sid = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for sid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/adjacency_sid/sid (list)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_sid is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_sid() directly.\n\n    YANG Description: Adjacency Segment-IDs List. An IGP-Adjacency Segment is an IGP\nsegment attached to a unidirectional adjacency or a set of\nunidirectional adjacencies. By default, an IGP-Adjacency Segment is\nlocal to the node which advertises it.", "id": "f22708:c1:m3"}
{"signature": "def _get_value(self):", "body": "return self.__value<EOL>", "docstring": "Getter method for value, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/adjacency_sid/sid/state/value (uint32)\n\nYANG Description: Adjacency-SID value.", "id": "f22709:c1:m2"}
{"signature": "def _set_flags(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__flags = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/adjacency_sid/sid/state/flags (enumeration)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_flags is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_flags() directly.\n\nYANG Description: Flags associated with Adj-Segment-ID.", "id": "f22709:c0:m6"}
{"signature": "def _get_weight(self):", "body": "return self.__weight<EOL>", "docstring": "Getter method for weight, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/adjacency_sid/sid/state/weight (uint8)\n\n    YANG Description: Value that represents the weight of the Adj-SID for the purpose\nof load balancing.", "id": "f22709:c1:m8"}
{"signature": "def _set_weight(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__weight = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for weight, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/adjacency_sid/sid/state/weight (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_weight is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_weight() directly.\n\n    YANG Description: Value that represents the weight of the Adj-SID for the purpose\nof load balancing.", "id": "f22709:c1:m9"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/adjacency_sid/sid/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of Adjacency-SID.", "id": "f22710:c0:m3"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22711:c0:m2"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_delay_variation/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22712:c1:m2"}
{"signature": "def _get_delay(self):", "body": "return self.__delay<EOL>", "docstring": "Getter method for delay, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_delay_variation/state/delay (uint32)\n\n    YANG Description: Average link delay between two directly connected IS-IS\nneighbors over a configurable interval.", "id": "f22712:c1:m5"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_delay_variation/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22712:c1:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_delay_variation/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of IS Extended Reachability sub-TLV 35.", "id": "f22713:c0:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_delay_variation/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of IS Extended Reachability sub-TLV 35.", "id": "f22713:c1:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_delay_variation/state (container)\n\nYANG Description: State parameters of IS Extended Reachability sub-TLV 35.", "id": "f22713:c1:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/max_reservable_link_bandwidth/state (container)\n\nYANG Description: State parameters of sub-TLV 10.", "id": "f22715:c1:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/max_reservable_link_bandwidth/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of sub-TLV 10.", "id": "f22715:c1:m3"}
{"signature": "def _set_ipv6_neighbor_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv6_neighbor_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv6_neighbor_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/ipv6_neighbor_address/state/ipv6_neighbor_address (inet:ipv6-address)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_ipv6_neighbor_address is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_ipv6_neighbor_address() directly.\n\n    YANG Description: Contains a 16-octet IPv6 address for a neighboring router on\nthe link described by the (main) TLV. This sub-TLV can occur\nmultiple times.", "id": "f22716:c1:m6"}
{"signature": "def _set_ipv6_neighbor_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv6_neighbor_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv6_neighbor_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/ipv6_neighbor_address/state/ipv6_neighbor_address (inet:ipv6-address)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_ipv6_neighbor_address is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_ipv6_neighbor_address() directly.\n\n    YANG Description: Contains a 16-octet IPv6 address for a neighboring router on\nthe link described by the (main) TLV. This sub-TLV can occur\nmultiple times.", "id": "f22716:c0:m6"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/ipv6_neighbor_address/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of sub-TLV 13.", "id": "f22717:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/ipv6_neighbor_address/state (container)\n\nYANG Description: State parameters of sub-TLV 13.", "id": "f22717:c0:m2"}
{"signature": "def _get_min_delay(self):", "body": "return self.__min_delay<EOL>", "docstring": "Getter method for min_delay, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/min_max_link_delay/state/min_delay (uint32)\n\n    YANG Description: Minimum measured link delay value(in microseconds) between two\ndirectly connected IS-IS neighbors over a configurable\ninterval.", "id": "f22718:c0:m8"}
{"signature": "def _get_max_delay(self):", "body": "return self.__max_delay<EOL>", "docstring": "Getter method for max_delay, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/min_max_link_delay/state/max_delay (uint32)\n\n    YANG Description: Maximum measured link delay value(in microseconds) between two\ndirectly connected IS-IS neighbors over a configurable\ninterval.", "id": "f22718:c1:m11"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/min_max_link_delay/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22718:c1:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/min_max_link_delay/state (container)\n\nYANG Description: State parameters of IS Extended Reachability sub-TLV 34.", "id": "f22719:c0:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/min_max_link_delay/state (container)\n\nYANG Description: State parameters of IS Extended Reachability sub-TLV 34.", "id": "f22719:c1:m2"}
{"signature": "def _set_adjacency_sid(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=adjacency_sid.adjacency_sid,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__adjacency_sid = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for adjacency_sid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/adjacency_sid (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_adjacency_sid is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_adjacency_sid() directly.\n\nYANG Description: This container defines segment routing extensions for prefixes.", "id": "f22720:c1:m51"}
{"signature": "def _get_link_loss(self):", "body": "return self.__link_loss<EOL>", "docstring": "Getter method for link_loss, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_loss (container)\n\nYANG Description: This container defines unidirectional link loss delay.", "id": "f22720:c1:m65"}
{"signature": "def _set_max_link_bandwidth(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=max_link_bandwidth.max_link_bandwidth,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__max_link_bandwidth = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for max_link_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/max_link_bandwidth (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_max_link_bandwidth is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_max_link_bandwidth() directly.\n\nYANG Description: This container defines sub-TLV 9.", "id": "f22720:c1:m18"}
{"signature": "def _get_available_bandwidth(self):", "body": "return self.__available_bandwidth<EOL>", "docstring": "Getter method for available_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/available_bandwidth (container)\n\nYANG Description: This container defines unidirectional lavailable bandwidth.", "id": "f22720:c1:m71"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/subtlv_type (leafref)\n\n    YANG Description: A reference for the TLV type being described within\nthe LSDB", "id": "f22720:c0:m2"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/subtlv_type (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: A reference for the TLV type being described within\nthe LSDB", "id": "f22720:c0:m3"}
{"signature": "def _get_ipv6_neighbor_address(self):", "body": "return self.__ipv6_neighbor_address<EOL>", "docstring": "Getter method for ipv6_neighbor_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/ipv6_neighbor_address (container)\n\nYANG Description: This container defines sub-TLV 13.", "id": "f22720:c0:m29"}
{"signature": "def _set_lan_adjacency_sid(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=lan_adjacency_sid.lan_adjacency_sid,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__lan_adjacency_sid = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for lan_adjacency_sid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/lan_adjacency_sid (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_lan_adjacency_sid is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_lan_adjacency_sid() directly.\n\nYANG Description: This container defines segment routing extensions for prefixes.", "id": "f22720:c1:m54"}
{"signature": "def _get_adjacency_sid(self):", "body": "return self.__adjacency_sid<EOL>", "docstring": "Getter method for adjacency_sid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/adjacency_sid (container)\n\nYANG Description: This container defines segment routing extensions for prefixes.", "id": "f22720:c0:m50"}
{"signature": "def _set_link_loss(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=link_loss.link_loss,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__link_loss = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for link_loss, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_loss (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_link_loss is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_link_loss() directly.\n\nYANG Description: This container defines unidirectional link loss delay.", "id": "f22720:c1:m66"}
{"signature": "def _set_link_delay(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=link_delay.link_delay,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__link_delay = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for link_delay, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_delay (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_link_delay is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_link_delay() directly.\n\nYANG Description: This container defines unidirectional link delay.", "id": "f22720:c0:m57"}
{"signature": "def _get_unreserved_bandwidth(self):", "body": "return self.__unreserved_bandwidth<EOL>", "docstring": "Getter method for unreserved_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/unreserved_bandwidth (container)\n\n    YANG Description: This container defines unreserved-bandwidth. The units are bytes\nper second.", "id": "f22720:c1:m23"}
{"signature": "def _get_link_attributes(self):", "body": "return self.__link_attributes<EOL>", "docstring": "Getter method for link_attributes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_attributes (container)\n\nYANG Description: This container defines link-attributes.", "id": "f22720:c0:m38"}
{"signature": "def _get_residual_bandwidth(self):", "body": "return self.__residual_bandwidth<EOL>", "docstring": "Getter method for residual_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/residual_bandwidth (container)\n\nYANG Description: This container defines unidirectional residual bandwidth.", "id": "f22720:c1:m68"}
{"signature": "def _get_ipv4_interface_address(self):", "body": "return self.__ipv4_interface_address<EOL>", "docstring": "Getter method for ipv4_interface_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/ipv4_interface_address (container)\n\nYANG Description: This container defines sub-TLV 6.", "id": "f22720:c1:m11"}
{"signature": "def _set_adjacency_sid(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=adjacency_sid.adjacency_sid,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__adjacency_sid = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for adjacency_sid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/adjacency_sid (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_adjacency_sid is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_adjacency_sid() directly.\n\nYANG Description: This container defines segment routing extensions for prefixes.", "id": "f22720:c0:m51"}
{"signature": "def _get_link_loss(self):", "body": "return self.__link_loss<EOL>", "docstring": "Getter method for link_loss, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_loss (container)\n\nYANG Description: This container defines unidirectional link loss delay.", "id": "f22720:c0:m65"}
{"signature": "def _get_admin_group(self):", "body": "return self.__admin_group<EOL>", "docstring": "Getter method for admin_group, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/admin_group (container)\n\nYANG Description: This container defines sub-TLV 3.", "id": "f22720:c0:m8"}
{"signature": "def _get_lan_adjacency_sid(self):", "body": "return self.__lan_adjacency_sid<EOL>", "docstring": "Getter method for lan_adjacency_sid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/lan_adjacency_sid (container)\n\nYANG Description: This container defines segment routing extensions for prefixes.", "id": "f22720:c1:m53"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/subtlv_type (leafref)\n\n    YANG Description: A reference for the TLV type being described within\nthe LSDB", "id": "f22720:c1:m2"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/subtlv_type (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: A reference for the TLV type being described within\nthe LSDB", "id": "f22720:c1:m3"}
{"signature": "def _get_ipv4_interface_address(self):", "body": "return self.__ipv4_interface_address<EOL>", "docstring": "Getter method for ipv4_interface_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/ipv4_interface_address (container)\n\nYANG Description: This container defines sub-TLV 6.", "id": "f22720:c0:m11"}
{"signature": "def _set_extended_admin_group(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=extended_admin_group.extended_admin_group,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__extended_admin_group = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for extended_admin_group, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/extended_admin_group (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_extended_admin_group is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_extended_admin_group() directly.\n\nYANG Description: This container defines sub-TLV 14.", "id": "f22720:c0:m33"}
{"signature": "def _get_admin_group(self):", "body": "return self.__admin_group<EOL>", "docstring": "Getter method for admin_group, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/admin_group/state/admin_group (uint32)\n\n    YANG Description: The administrative group sub-TLV contains a 4-octet bit mask\nassigned by the network administrator.  Each set bit corresponds\nto one administrative group assigned to the interface. By\nconvention, the least significant bit is referred to as group 0,\nand the most significant bit is referred to as group 31.", "id": "f22721:c0:m5"}
{"signature": "def _set_admin_group(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__admin_group = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for admin_group, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/admin_group/state/admin_group (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_admin_group is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_admin_group() directly.\n\n    YANG Description: The administrative group sub-TLV contains a 4-octet bit mask\nassigned by the network administrator.  Each set bit corresponds\nto one administrative group assigned to the interface. By\nconvention, the least significant bit is referred to as group 0,\nand the most significant bit is referred to as group 31.", "id": "f22721:c1:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/admin_group/state (container)\n\nYANG Description: State parameters of sub-TLV 3.", "id": "f22722:c1:m2"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_loss/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22723:c0:m3"}
{"signature": "def _get_a_bit(self):", "body": "return self.__a_bit<EOL>", "docstring": "Getter method for a_bit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_loss/state/a_bit (boolean)\n\n    YANG Description: The A bit is set when the measured value of this parameter\nexceeds its configured maximum threshold. The A bit is cleared\nwhen the measured value falls below its configured reuse threshold.", "id": "f22723:c0:m5"}
{"signature": "def _get_setup_priority(self):", "body": "return self.__setup_priority<EOL>", "docstring": "Getter method for setup_priority, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/unreserved_bandwidth/setup_priority/state/setup_priority (uint8)\n\n    YANG Description: Setup priority level of 0 through 7 to be used by Unreserved Bandwidth\nsub-TLV 11.", "id": "f22725:c1:m2"}
{"signature": "def _get_unreserved_bandwidth(self):", "body": "return self.__unreserved_bandwidth<EOL>", "docstring": "Getter method for unreserved_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/unreserved_bandwidth/setup_priority/state/unreserved_bandwidth (oc-types:ieeefloat32)\n\n    YANG Description: The amount of bandwidth reservable in this direction on this\nlink. Note that for oversubscription purposes, this can be\ngreater than the bandwidth of the link. It contains eight\n32-bit IEEE floating point numbers(one for each priority). The\nunits are bytes (not bits!) per second. The values correspond\nto the bandwidth that can be reserved with a setup priority of\n0 through 7, arranged in increasing order with priority 0\noccurring at the start of the sub-TLV, and priority 7 at the\nend of the sub-TLV.", "id": "f22725:c0:m8"}
{"signature": "def _get_setup_priority(self):", "body": "return self.__setup_priority<EOL>", "docstring": "Getter method for setup_priority, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/unreserved_bandwidth/setup_priority/state/setup_priority (uint8)\n\n    YANG Description: Setup priority level of 0 through 7 to be used by Unreserved Bandwidth\nsub-TLV 11.", "id": "f22725:c0:m2"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/unreserved_bandwidth/setup_priority/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22725:c1:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/unreserved_bandwidth/setup_priority/state (container)\n\nYANG Description: State parameters of IS Extended Reachability sub-TLV 11.", "id": "f22726:c0:m2"}
{"signature": "def _get_setup_priority(self):", "body": "return self.__setup_priority<EOL>", "docstring": "Getter method for setup_priority, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/unreserved_bandwidth/setup_priority (list)\n\nYANG Description: Setup priority(0 through 7) for unreserved bandwidth.", "id": "f22727:c0:m2"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_protection_type/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22728:c0:m3"}
{"signature": "def _get_link_protection_type(self):", "body": "return self.__link_protection_type<EOL>", "docstring": "Getter method for link_protection_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_protection_type/state/link_protection_type (enumeration)\n\nYANG Description: Link protection capabilities.", "id": "f22728:c0:m5"}
{"signature": "def _get_link_protection_type(self):", "body": "return self.__link_protection_type<EOL>", "docstring": "Getter method for link_protection_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_protection_type/state/link_protection_type (enumeration)\n\nYANG Description: Link protection capabilities.", "id": "f22728:c1:m5"}
{"signature": "def _get_utilized_bandwidth(self):", "body": "return self.__utilized_bandwidth<EOL>", "docstring": "Getter method for utilized_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/utilized_bandwidth/state/utilized_bandwidth (oc-types:ieeefloat32)\n\n    YANG Description: The bandwidth utilization on a link, forwarding adjacency, or\nbundled link in IEEE floating-point format with units of bytes\nper second.  For a link or forwarding adjacency, bandwidth\nutilization represents the actual utilization of the link (i.e.,\nas measured by the advertising node).  For a bundled link,\nbandwidth utilization is defined to be the sum of the component\nlink bandwidth utilizations.", "id": "f22730:c1:m5"}
{"signature": "def _set_utilized_bandwidth(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=bitarray, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__utilized_bandwidth = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for utilized_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/utilized_bandwidth/state/utilized_bandwidth (oc-types:ieeefloat32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_utilized_bandwidth is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_utilized_bandwidth() directly.\n\n    YANG Description: The bandwidth utilization on a link, forwarding adjacency, or\nbundled link in IEEE floating-point format with units of bytes\nper second.  For a link or forwarding adjacency, bandwidth\nutilization represents the actual utilization of the link (i.e.,\nas measured by the advertising node).  For a bundled link,\nbandwidth utilization is defined to be the sum of the component\nlink bandwidth utilizations.", "id": "f22730:c0:m6"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/utilized_bandwidth/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22730:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/utilized_bandwidth/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of IS Extended Reachability sub-TLV 39.", "id": "f22731:c0:m3"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/ipv4_neighbor_address/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22732:c1:m3"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/ipv4_neighbor_address/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22732:c0:m3"}
{"signature": "def _get_ipv4_neighbor_address(self):", "body": "return self.__ipv4_neighbor_address<EOL>", "docstring": "Getter method for ipv4_neighbor_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/ipv4_neighbor_address/state/ipv4_neighbor_address (inet:ipv4-address-no-zone)\n\n    YANG Description: A single IPv4 address for a neighboring router on this link.\nThis sub-TLV can occur multiple times.", "id": "f22732:c0:m5"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/ipv4_neighbor_address/state (container)\n\nYANG Description: State parameters of sub-TLV 8.", "id": "f22733:c1:m2"}
{"signature": "def _get_reserved(self):", "body": "return self.__reserved<EOL>", "docstring": "Getter method for reserved, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/bandwidth_constraints/state/reserved (uint32)\n\n    YANG Description: Should be set to zero by the LSR generating the sub-TLV and\nshould be ignored by the LSR receiving the sub-TLV.", "id": "f22734:c1:m8"}
{"signature": "def _get_model_id(self):", "body": "return self.__model_id<EOL>", "docstring": "Getter method for model_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/bandwidth_constraints/state/model_id (uint8)\n\n    YANG Description: Identifier for the Bandwidth Constraints  Model currently in\nuse by the LSR initiating the IGP advertisement.", "id": "f22734:c0:m5"}
{"signature": "def _set_reserved(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__reserved = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for reserved, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/bandwidth_constraints/state/reserved (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_reserved is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_reserved() directly.\n\n    YANG Description: Should be set to zero by the LSR generating the sub-TLV and\nshould be ignored by the LSR receiving the sub-TLV.", "id": "f22734:c1:m9"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/bandwidth_constraints/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22734:c0:m3"}
{"signature": "def _set_local_protection(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__local_protection = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for local_protection, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_attributes/state/local_protection (enumeration)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_local_protection is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_local_protection() directly.\n\nYANG Description: Link local-protection attributes.", "id": "f22736:c1:m6"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_attributes/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22736:c1:m3"}
{"signature": "def _set_local_protection(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__local_protection = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for local_protection, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_attributes/state/local_protection (enumeration)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_local_protection is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_local_protection() directly.\n\nYANG Description: Link local-protection attributes.", "id": "f22736:c0:m6"}
{"signature": "def _set_extended_admin_group(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__extended_admin_group = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for extended_admin_group, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/extended_admin_group/state/extended_admin_group (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_extended_admin_group is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_extended_admin_group() directly.\n\n    YANG Description: The extended-admin-group sub-TLV is used in addition to the\nAdministrative Groups when it is desirable to make more than 32\ncolors available for advertisement in a network.", "id": "f22738:c1:m6"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/extended_admin_group/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22738:c0:m2"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/extended_admin_group/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22738:c1:m3"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/unconstrained_lsp/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22740:c0:m2"}
{"signature": "def _get_unconstrained_lsp(self):", "body": "return self.__unconstrained_lsp<EOL>", "docstring": "Getter method for unconstrained_lsp, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/unconstrained_lsp/state/unconstrained_lsp (uint16)\n\n    YANG Description: Unconstrained TE LSP count(TE Label Switched Paths (LSPs)\nsignalled with zero bandwidth).", "id": "f22740:c0:m5"}
{"signature": "def _get_sid(self):", "body": "return self.__sid<EOL>", "docstring": "Getter method for sid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/lan_adjacency_sid/sid (list)\n\n    YANG Description: Adjacency Segment-IDs List. An IGP-Adjacency Segment is an IGP\nsegment attached to a unidirectional adjacency or a set of\nunidirectional adjacencies. By default, an IGP-Adjacency Segment is\nlocal to the node which advertises it.", "id": "f22742:c0:m2"}
{"signature": "def _set_sid(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>False,<EOL>sid.sid,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT:False>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__sid = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for sid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/lan_adjacency_sid/sid (list)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_sid is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_sid() directly.\n\n    YANG Description: Adjacency Segment-IDs List. An IGP-Adjacency Segment is an IGP\nsegment attached to a unidirectional adjacency or a set of\nunidirectional adjacencies. By default, an IGP-Adjacency Segment is\nlocal to the node which advertises it.", "id": "f22742:c1:m3"}
{"signature": "def _get_weight(self):", "body": "return self.__weight<EOL>", "docstring": "Getter method for weight, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/lan_adjacency_sid/sid/state/weight (uint8)\n\n    YANG Description: Value that represents the weight of the Adj-SID for the purpose\nof load balancing.", "id": "f22743:c1:m8"}
{"signature": "def _set_value(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:value>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__value = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for value, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/lan_adjacency_sid/sid/state/value (uint32)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_value is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_value() directly.\n\nYANG Description: LAN Adjacency-SID value.", "id": "f22743:c1:m3"}
{"signature": "def _get_flags(self):", "body": "return self.__flags<EOL>", "docstring": "Getter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/lan_adjacency_sid/sid/state/flags (enumeration)\n\nYANG Description: Flags associated with LAN-Adj-Segment-ID.", "id": "f22743:c1:m5"}
{"signature": "def _set_neighbor_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__neighbor_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for neighbor_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/lan_adjacency_sid/sid/state/neighbor_id (oc-isis-types:system-id)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_neighbor_id is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_neighbor_id() directly.\n\n    YANG Description: System ID of the neighbor associated with the LAN-Adj-Segment-ID\nvalue.", "id": "f22743:c0:m12"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/lan_adjacency_sid/sid/state (container)\n\nYANG Description: State parameters of LAN Adjacency-SID.", "id": "f22744:c0:m2"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_delay/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22745:c0:m3"}
{"signature": "def _set_a_bit(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__a_bit = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for a_bit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_delay/state/a_bit (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_a_bit is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_a_bit() directly.\n\n    YANG Description: The A bit is set when the measured value of this parameter\nexceeds its configured maximum threshold. The A bit is cleared\nwhen the measured value falls below its configured reuse threshold.", "id": "f22745:c0:m6"}
{"signature": "def _get_delay(self):", "body": "return self.__delay<EOL>", "docstring": "Getter method for delay, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_delay/state/delay (uint32)\n\n    YANG Description: Average link delay value (in microseconds) between two directly\nconnected IS-IS neighbors over a configurable interval.", "id": "f22745:c0:m8"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_delay/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22745:c1:m3"}
{"signature": "def _get_delay(self):", "body": "return self.__delay<EOL>", "docstring": "Getter method for delay, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_delay/state/delay (uint32)\n\n    YANG Description: Average link delay value (in microseconds) between two directly\nconnected IS-IS neighbors over a configurable interval.", "id": "f22745:c1:m8"}
{"signature": "def _get_a_bit(self):", "body": "return self.__a_bit<EOL>", "docstring": "Getter method for a_bit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_delay/state/a_bit (boolean)\n\n    YANG Description: The A bit is set when the measured value of this parameter\nexceeds its configured maximum threshold. The A bit is cleared\nwhen the measured value falls below its configured reuse threshold.", "id": "f22745:c0:m5"}
{"signature": "def _set_delay(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__delay = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for delay, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_delay/state/delay (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_delay is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_delay() directly.\n\n    YANG Description: Average link delay value (in microseconds) between two directly\nconnected IS-IS neighbors over a configurable interval.", "id": "f22745:c1:m9"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_delay/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of IS Extended Reachability sub-TLV 33.", "id": "f22746:c1:m3"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/te_default_metric/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22747:c0:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/te_default_metric/state (container)\n\nYANG Description: State parameters of sub-TLV 18.", "id": "f22748:c1:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/te_default_metric/state (container)\n\nYANG Description: State parameters of sub-TLV 18.", "id": "f22748:c0:m2"}
{"signature": "def _set_residual_bandwidth(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=bitarray, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__residual_bandwidth = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for residual_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/residual_bandwidth/state/residual_bandwidth (oc-types:ieeefloat32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_residual_bandwidth is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_residual_bandwidth() directly.\n\n    YANG Description: Residual bandwidth on a link,forwarding adjacency [RFC4206], or\nbundled link in IEEE floating-point format with units of bytes\nper second. For a link or forwarding adjacency, residual\nbandwidth is defined to be the Maximum Bandwidth [RFC5305] minus\nthe bandwidth currently allocated to RSVP-TE label switched\npaths. For a bundled link, residual bandwidth is defined to be\nthe sum of the component link residual bandwidths.", "id": "f22749:c0:m6"}
{"signature": "def _get_residual_bandwidth(self):", "body": "return self.__residual_bandwidth<EOL>", "docstring": "Getter method for residual_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/residual_bandwidth/state/residual_bandwidth (oc-types:ieeefloat32)\n\n    YANG Description: Residual bandwidth on a link,forwarding adjacency [RFC4206], or\nbundled link in IEEE floating-point format with units of bytes\nper second. For a link or forwarding adjacency, residual\nbandwidth is defined to be the Maximum Bandwidth [RFC5305] minus\nthe bandwidth currently allocated to RSVP-TE label switched\npaths. For a bundled link, residual bandwidth is defined to be\nthe sum of the component link residual bandwidths.", "id": "f22749:c0:m5"}
{"signature": "def _get_residual_bandwidth(self):", "body": "return self.__residual_bandwidth<EOL>", "docstring": "Getter method for residual_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/residual_bandwidth/state/residual_bandwidth (oc-types:ieeefloat32)\n\n    YANG Description: Residual bandwidth on a link,forwarding adjacency [RFC4206], or\nbundled link in IEEE floating-point format with units of bytes\nper second. For a link or forwarding adjacency, residual\nbandwidth is defined to be the Maximum Bandwidth [RFC5305] minus\nthe bandwidth currently allocated to RSVP-TE label switched\npaths. For a bundled link, residual bandwidth is defined to be\nthe sum of the component link residual bandwidths.", "id": "f22749:c1:m5"}
{"signature": "def _get_ipv4_interface_address(self):", "body": "return self.__ipv4_interface_address<EOL>", "docstring": "Getter method for ipv4_interface_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/ipv4_interface_address/state/ipv4_interface_address (inet:ipv4-address-no-zone)\n\n    YANG Description: A 4-octet IPv4 address for the interface described by the\n(main) TLV. This sub-TLV can occur multiple times.", "id": "f22751:c0:m5"}
{"signature": "def _set_ipv4_interface_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv4_interface_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv4_interface_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/ipv4_interface_address/state/ipv4_interface_address (inet:ipv4-address-no-zone)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_ipv4_interface_address is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_ipv4_interface_address() directly.\n\n    YANG Description: A 4-octet IPv4 address for the interface described by the\n(main) TLV. This sub-TLV can occur multiple times.", "id": "f22751:c0:m6"}
{"signature": "def _set_ipv4_interface_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv4_interface_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv4_interface_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/ipv4_interface_address/state/ipv4_interface_address (inet:ipv4-address-no-zone)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_ipv4_interface_address is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_ipv4_interface_address() directly.\n\n    YANG Description: A 4-octet IPv4 address for the interface described by the\n(main) TLV. This sub-TLV can occur multiple times.", "id": "f22751:c1:m6"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/ipv4_interface_address/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22751:c1:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/ipv4_interface_address/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of sub-TLV 6.", "id": "f22752:c1:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/ipv4_interface_address/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of sub-TLV 6.", "id": "f22752:c0:m3"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/max_link_bandwidth/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22753:c1:m3"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/max_link_bandwidth/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22753:c1:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/max_link_bandwidth/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of sub-TLV 9.", "id": "f22754:c0:m3"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/ipv6_interface_address/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22755:c0:m2"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/ipv6_interface_address/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22755:c0:m3"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/ipv6_interface_address/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22755:c1:m2"}
{"signature": "def _set_ipv6_interface_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv6_interface_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv6_interface_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/ipv6_interface_address/state/ipv6_interface_address (inet:ipv6-address)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_ipv6_interface_address is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_ipv6_interface_address() directly.\n\n    YANG Description: Contains a 16-octet IPv6 address for the interface described by\nthe containing  Extended IS Reachability TLV. This sub-TLV can\noccur multiple times.", "id": "f22755:c0:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/ipv6_interface_address/state (container)\n\nYANG Description: State parameters of sub-TLV 12.", "id": "f22756:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/ipv6_interface_address/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of sub-TLV 12.", "id": "f22756:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/state (container)\n\nYANG Description: State parameters of extended neighbor.", "id": "f22757:c1:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/state (container)\n\nYANG Description: State parameters of extended neighbor.", "id": "f22757:c0:m2"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/undefined_subtlvs/undefined_subtlv/state/type (uint8)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_type is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_type() directly.\n\nYANG Description: TLV Type.", "id": "f22758:c1:m3"}
{"signature": "def _get_length(self):", "body": "return self.__length<EOL>", "docstring": "Getter method for length, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/undefined_subtlvs/undefined_subtlv/state/length (uint8)\n\nYANG Description: TLV length.", "id": "f22758:c0:m5"}
{"signature": "def _set_value(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=bitarray,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:value>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__value = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for value, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/undefined_subtlvs/undefined_subtlv/state/value (binary)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_value is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_value() directly.\n\nYANG Description: TLV value.", "id": "f22758:c0:m9"}
{"signature": "def _get_type(self):", "body": "return self.__type<EOL>", "docstring": "Getter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/undefined_subtlvs/undefined_subtlv/state/type (uint8)\n\nYANG Description: TLV Type.", "id": "f22758:c0:m2"}
{"signature": "def _set_value(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=bitarray,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:value>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__value = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for value, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/undefined_subtlvs/undefined_subtlv/state/value (binary)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_value is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_value() directly.\n\nYANG Description: TLV value.", "id": "f22758:c1:m9"}
{"signature": "def _get_type(self):", "body": "return self.__type<EOL>", "docstring": "Getter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/undefined_subtlvs/undefined_subtlv/type (leafref)\n\nYANG Description: A reference to a subTLV", "id": "f22759:c0:m2"}
{"signature": "def _set_type(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/undefined_subtlvs/undefined_subtlv/type (leafref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_type is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_type() directly.\n\nYANG Description: A reference to a subTLV", "id": "f22759:c0:m3"}
{"signature": "def _get_undefined_subtlv(self):", "body": "return self.__undefined_subtlv<EOL>", "docstring": "Getter method for undefined_subtlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/undefined_subtlvs/undefined_subtlv (list)\n\n    YANG Description: Sub-TLVs that are not defined in the model or not recognised by\nsystem.", "id": "f22760:c0:m2"}
{"signature": "def _get_undefined_subtlv(self):", "body": "return self.__undefined_subtlv<EOL>", "docstring": "Getter method for undefined_subtlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor/undefined_subtlvs/undefined_subtlv (list)\n\n    YANG Description: Sub-TLVs that are not defined in the model or not recognised by\nsystem.", "id": "f22760:c1:m2"}
{"signature": "def _set_neighbor(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>False,<EOL>neighbor.neighbor,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT:False>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__neighbor = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for neighbor, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor (list)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_neighbor is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_neighbor() directly.\n\n    YANG Description: This list defines ISIS extended reachability neighbor\nattributes.", "id": "f22761:c1:m3"}
{"signature": "def _get_neighbor(self):", "body": "return self.__neighbor<EOL>", "docstring": "Getter method for neighbor, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors/neighbor (list)\n\n    YANG Description: This list defines ISIS extended reachability neighbor\nattributes.", "id": "f22761:c1:m2"}
{"signature": "def _get_neighbors(self):", "body": "return self.__neighbors<EOL>", "docstring": "Getter method for neighbors, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute/neighbors (container)\n\nYANG Description: This container describes IS neighbors.", "id": "f22762:c0:m5"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/area_address/state/type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_type() directly.\n\n    YANG Description: The type of TLV being described. The type of TLV is\nexpressed as a canonical name.", "id": "f22763:c0:m3"}
{"signature": "def _get_type(self):", "body": "return self.__type<EOL>", "docstring": "Getter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/area_address/state/type (identityref)\n\n    YANG Description: The type of TLV being described. The type of TLV is\nexpressed as a canonical name.", "id": "f22763:c0:m2"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/area_address/state/type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_type() directly.\n\n    YANG Description: The type of TLV being described. The type of TLV is\nexpressed as a canonical name.", "id": "f22763:c1:m3"}
{"signature": "def _get_type(self):", "body": "return self.__type<EOL>", "docstring": "Getter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/state/type (identityref)\n\n    YANG Description: The type of TLV being described. The type of TLV is\nexpressed as a canonical name.", "id": "f22765:c1:m2"}
{"signature": "def _get_metric(self):", "body": "return self.__metric<EOL>", "docstring": "Getter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/state/metric (oc-isis-types:wide-metric)\n\nYANG Description: ISIS metric value.", "id": "f22766:c1:m8"}
{"signature": "def _set_mt_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:16>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__mt_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for mt_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/state/mt_id (uint16)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_mt_id is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_mt_id() directly.\n\nYANG Description: Identifier of a topology being announced.", "id": "f22766:c0:m3"}
{"signature": "def _get_mt_id(self):", "body": "return self.__mt_id<EOL>", "docstring": "Getter method for mt_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/state/mt_id (uint16)\n\nYANG Description: Identifier of a topology being announced.", "id": "f22766:c0:m2"}
{"signature": "def _get_mt_id(self):", "body": "return self.__mt_id<EOL>", "docstring": "Getter method for mt_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/state/mt_id (uint16)\n\nYANG Description: Identifier of a topology being announced.", "id": "f22766:c1:m2"}
{"signature": "def _get_system_id(self):", "body": "return self.__system_id<EOL>", "docstring": "Getter method for system_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/state/system_id (oc-isis-types:system-id)\n\nYANG Description: System-id of the IS neighbor.", "id": "f22766:c1:m5"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/available_bandwidth/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22768:c1:m3"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/available_bandwidth/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22768:c0:m2"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/available_bandwidth/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22768:c1:m2"}
{"signature": "def _set_available_bandwidth(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=bitarray, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__available_bandwidth = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for available_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/available_bandwidth/state/available_bandwidth (oc-types:ieeefloat32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_available_bandwidth is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_available_bandwidth() directly.\n\n    YANG Description: The available bandwidth on a link, forwarding adjacency, or\nbundled link in IEEE floating-point format with units of bytes\nper second. For a link or forwarding adjacency, available\nbandwidth is defined to be residual bandwidth minus the measured\nbandwidth used for the actual forwarding of non-RSVP-TE label\nswitched path packets.  For a bundled link, available bandwidth\nis defined to be the sum of the component link available\nbandwidths minus the measured bandwidth used for the actual\nforwarding of non-RSVP-TE label switched path packets.  For a\nbundled link, available bandwidth is defined to be the sum of\nthe component link available bandwidths.", "id": "f22768:c0:m6"}
{"signature": "def _set_sid(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>False,<EOL>sid.sid,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT:False>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__sid = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for sid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/adjacency_sid/sid (list)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_sid is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_sid() directly.\n\n    YANG Description: Adjacency Segment-IDs List. An IGP-Adjacency Segment is an IGP\nsegment attached to a unidirectional adjacency or a set of\nunidirectional adjacencies. By default, an IGP-Adjacency Segment is\nlocal to the node which advertises it.", "id": "f22770:c1:m3"}
{"signature": "def _get_sid(self):", "body": "return self.__sid<EOL>", "docstring": "Getter method for sid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/adjacency_sid/sid (list)\n\n    YANG Description: Adjacency Segment-IDs List. An IGP-Adjacency Segment is an IGP\nsegment attached to a unidirectional adjacency or a set of\nunidirectional adjacencies. By default, an IGP-Adjacency Segment is\nlocal to the node which advertises it.", "id": "f22770:c0:m2"}
{"signature": "def _set_value(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:value>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__value = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for value, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/adjacency_sid/sid/state/value (uint32)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_value is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_value() directly.\n\nYANG Description: Adjacency-SID value.", "id": "f22771:c0:m3"}
{"signature": "def _get_flags(self):", "body": "return self.__flags<EOL>", "docstring": "Getter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/adjacency_sid/sid/state/flags (enumeration)\n\nYANG Description: Flags associated with Adj-Segment-ID.", "id": "f22771:c0:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/adjacency_sid/sid/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of Adjacency-SID.", "id": "f22772:c0:m3"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22773:c1:m3"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22773:c1:m2"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22773:c0:m2"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/link_delay_variation/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22774:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/link_delay_variation/state (container)\n\nYANG Description: State parameters of IS Extended Reachability sub-TLV 35.", "id": "f22775:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/link_delay_variation/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of IS Extended Reachability sub-TLV 35.", "id": "f22775:c0:m3"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/max_reservable_link_bandwidth/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22776:c1:m3"}
{"signature": "def _set_max_reservable_link_bandwidth(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=bitarray, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__max_reservable_link_bandwidth = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for max_reservable_link_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/max_reservable_link_bandwidth/state/max_reservable_link_bandwidth (oc-types:ieeefloat32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_max_reservable_link_bandwidth is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_max_reservable_link_bandwidth() directly.\n\n    YANG Description: The maximum amount of bandwidth that can be reserved in this\ndirection on this link.  Note that for oversubscription\npurposes,  this can be greater than the bandwidth of the link.\nIt is encoded  in 32 bits in IEEE floating point format.  The\nunits are bytes  (not bits!) per second.", "id": "f22776:c1:m6"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/max_reservable_link_bandwidth/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of sub-TLV 10.", "id": "f22777:c1:m3"}
{"signature": "def _set_ipv6_neighbor_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv6_neighbor_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv6_neighbor_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/ipv6_neighbor_address/state/ipv6_neighbor_address (inet:ipv6-address)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_ipv6_neighbor_address is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_ipv6_neighbor_address() directly.\n\n    YANG Description: Contains a 16-octet IPv6 address for a neighboring router on\nthe link described by the (main) TLV. This sub-TLV can occur\nmultiple times.", "id": "f22778:c0:m6"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/ipv6_neighbor_address/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22778:c0:m2"}
{"signature": "def _get_ipv6_neighbor_address(self):", "body": "return self.__ipv6_neighbor_address<EOL>", "docstring": "Getter method for ipv6_neighbor_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/ipv6_neighbor_address/state/ipv6_neighbor_address (inet:ipv6-address)\n\n    YANG Description: Contains a 16-octet IPv6 address for a neighboring router on\nthe link described by the (main) TLV. This sub-TLV can occur\nmultiple times.", "id": "f22778:c1:m5"}
{"signature": "def _get_ipv6_neighbor_address(self):", "body": "return self.__ipv6_neighbor_address<EOL>", "docstring": "Getter method for ipv6_neighbor_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/ipv6_neighbor_address/state/ipv6_neighbor_address (inet:ipv6-address)\n\n    YANG Description: Contains a 16-octet IPv6 address for a neighboring router on\nthe link described by the (main) TLV. This sub-TLV can occur\nmultiple times.", "id": "f22778:c0:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/ipv6_neighbor_address/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of sub-TLV 13.", "id": "f22779:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/ipv6_neighbor_address/state (container)\n\nYANG Description: State parameters of sub-TLV 13.", "id": "f22779:c0:m2"}
{"signature": "def _set_max_delay(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__max_delay = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for max_delay, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/min_max_link_delay/state/max_delay (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_max_delay is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_max_delay() directly.\n\n    YANG Description: Maximum measured link delay value(in microseconds) between two\ndirectly connected IS-IS neighbors over a configurable\ninterval.", "id": "f22780:c1:m12"}
{"signature": "def _get_a_bit(self):", "body": "return self.__a_bit<EOL>", "docstring": "Getter method for a_bit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/min_max_link_delay/state/a_bit (boolean)\n\n    YANG Description: The A bit is set when the measured value of this parameter\nexceeds its configured maximum threshold. The A bit is cleared\nwhen the measured value falls below its configured reuse threshold.", "id": "f22780:c0:m5"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/min_max_link_delay/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22780:c1:m3"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/min_max_link_delay/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22780:c0:m2"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/min_max_link_delay/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22780:c0:m3"}
{"signature": "def _set_a_bit(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__a_bit = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for a_bit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/min_max_link_delay/state/a_bit (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_a_bit is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_a_bit() directly.\n\n    YANG Description: The A bit is set when the measured value of this parameter\nexceeds its configured maximum threshold. The A bit is cleared\nwhen the measured value falls below its configured reuse threshold.", "id": "f22780:c1:m6"}
{"signature": "def _get_min_delay(self):", "body": "return self.__min_delay<EOL>", "docstring": "Getter method for min_delay, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/min_max_link_delay/state/min_delay (uint32)\n\n    YANG Description: Minimum measured link delay value(in microseconds) between two\ndirectly connected IS-IS neighbors over a configurable\ninterval.", "id": "f22780:c0:m8"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/min_max_link_delay/state (container)\n\nYANG Description: State parameters of IS Extended Reachability sub-TLV 34.", "id": "f22781:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/min_max_link_delay/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of IS Extended Reachability sub-TLV 34.", "id": "f22781:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/min_max_link_delay/state (container)\n\nYANG Description: State parameters of IS Extended Reachability sub-TLV 34.", "id": "f22781:c1:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/min_max_link_delay/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of IS Extended Reachability sub-TLV 34.", "id": "f22781:c1:m3"}
{"signature": "def _get_max_reservable_link_bandwidth(self):", "body": "return self.__max_reservable_link_bandwidth<EOL>", "docstring": "Getter method for max_reservable_link_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/max_reservable_link_bandwidth (container)\n\nYANG Description: This container defines sub-TLV 10.", "id": "f22782:c0:m20"}
{"signature": "def _set_residual_bandwidth(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=residual_bandwidth.residual_bandwidth,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__residual_bandwidth = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for residual_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/residual_bandwidth (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_residual_bandwidth is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_residual_bandwidth() directly.\n\nYANG Description: This container defines unidirectional residual bandwidth.", "id": "f22782:c1:m69"}
{"signature": "def _get_link_loss(self):", "body": "return self.__link_loss<EOL>", "docstring": "Getter method for link_loss, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/link_loss (container)\n\nYANG Description: This container defines unidirectional link loss delay.", "id": "f22782:c1:m65"}
{"signature": "def _get_bandwidth_constraints(self):", "body": "return self.__bandwidth_constraints<EOL>", "docstring": "Getter method for bandwidth_constraints, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/bandwidth_constraints (container)\n\n    YANG Description: This container defines bandwidth-constraints. For DS-TE, the\nexisting Maximum Reservable link bandwidth parameter is retained,\nbut its semantics is generalized and interpreted as the aggregate\nbandwidth constraint across all Class-Types", "id": "f22782:c0:m44"}
{"signature": "def _set_link_protection_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=link_protection_type.link_protection_type,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__link_protection_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for link_protection_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/link_protection_type (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_link_protection_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_link_protection_type() directly.\n\n    YANG Description: ISIS LSDB parameters relating to the type of link protection\noffered.", "id": "f22782:c1:m42"}
{"signature": "def _set_adjacency_sid(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=adjacency_sid.adjacency_sid,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__adjacency_sid = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for adjacency_sid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/adjacency_sid (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_adjacency_sid is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_adjacency_sid() directly.\n\nYANG Description: This container defines segment routing extensions for prefixes.", "id": "f22782:c1:m51"}
{"signature": "def _set_utilized_bandwidth(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=utilized_bandwidth.utilized_bandwidth,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__utilized_bandwidth = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for utilized_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/utilized_bandwidth (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_utilized_bandwidth is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_utilized_bandwidth() directly.\n\nYANG Description: This container defines unidirectional utilized bandwidth.", "id": "f22782:c0:m75"}
{"signature": "def _get_link_loss(self):", "body": "return self.__link_loss<EOL>", "docstring": "Getter method for link_loss, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/link_loss (container)\n\nYANG Description: This container defines unidirectional link loss delay.", "id": "f22782:c0:m65"}
{"signature": "def _set_link_delay_variation(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=link_delay_variation.link_delay_variation,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__link_delay_variation = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for link_delay_variation, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/link_delay_variation (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_link_delay_variation is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_link_delay_variation() directly.\n\nYANG Description: This container defines unidirectional link delay variation.", "id": "f22782:c1:m63"}
{"signature": "def _get_bandwidth_constraints(self):", "body": "return self.__bandwidth_constraints<EOL>", "docstring": "Getter method for bandwidth_constraints, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/bandwidth_constraints (container)\n\n    YANG Description: This container defines bandwidth-constraints. For DS-TE, the\nexisting Maximum Reservable link bandwidth parameter is retained,\nbut its semantics is generalized and interpreted as the aggregate\nbandwidth constraint across all Class-Types", "id": "f22782:c1:m44"}
{"signature": "def _get_ipv4_interface_address(self):", "body": "return self.__ipv4_interface_address<EOL>", "docstring": "Getter method for ipv4_interface_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/ipv4_interface_address (container)\n\nYANG Description: This container defines sub-TLV 6.", "id": "f22782:c0:m11"}
{"signature": "def _get_ipv4_interface_address(self):", "body": "return self.__ipv4_interface_address<EOL>", "docstring": "Getter method for ipv4_interface_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/ipv4_interface_address (container)\n\nYANG Description: This container defines sub-TLV 6.", "id": "f22782:c1:m11"}
{"signature": "def _get_ipv4_neighbor_address(self):", "body": "return self.__ipv4_neighbor_address<EOL>", "docstring": "Getter method for ipv4_neighbor_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/ipv4_neighbor_address (container)\n\nYANG Description: This container defines sub-TLV 8.", "id": "f22782:c0:m14"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/state (container)\n\nYANG Description: State parameters of IS neighbor state", "id": "f22782:c0:m5"}
{"signature": "def _set_ipv4_neighbor_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=ipv4_neighbor_address.ipv4_neighbor_address,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv4_neighbor_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv4_neighbor_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/ipv4_neighbor_address (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ipv4_neighbor_address is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ipv4_neighbor_address() directly.\n\nYANG Description: This container defines sub-TLV 8.", "id": "f22782:c0:m15"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/subtlv_type (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: A reference for the TLV type being described within\nthe LSDB", "id": "f22782:c0:m3"}
{"signature": "def _get_adjacency_sid(self):", "body": "return self.__adjacency_sid<EOL>", "docstring": "Getter method for adjacency_sid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/adjacency_sid (container)\n\nYANG Description: This container defines segment routing extensions for prefixes.", "id": "f22782:c1:m50"}
{"signature": "def _set_max_reservable_link_bandwidth(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=max_reservable_link_bandwidth.max_reservable_link_bandwidth,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__max_reservable_link_bandwidth = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for max_reservable_link_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/max_reservable_link_bandwidth (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_max_reservable_link_bandwidth is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_max_reservable_link_bandwidth() directly.\n\nYANG Description: This container defines sub-TLV 10.", "id": "f22782:c0:m21"}
{"signature": "def _get_extended_admin_group(self):", "body": "return self.__extended_admin_group<EOL>", "docstring": "Getter method for extended_admin_group, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/extended_admin_group (container)\n\nYANG Description: This container defines sub-TLV 14.", "id": "f22782:c0:m32"}
{"signature": "def _get_ipv4_neighbor_address(self):", "body": "return self.__ipv4_neighbor_address<EOL>", "docstring": "Getter method for ipv4_neighbor_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/ipv4_neighbor_address (container)\n\nYANG Description: This container defines sub-TLV 8.", "id": "f22782:c1:m14"}
{"signature": "def _get_link_delay_variation(self):", "body": "return self.__link_delay_variation<EOL>", "docstring": "Getter method for link_delay_variation, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/link_delay_variation (container)\n\nYANG Description: This container defines unidirectional link delay variation.", "id": "f22782:c1:m62"}
{"signature": "def _get_admin_group(self):", "body": "return self.__admin_group<EOL>", "docstring": "Getter method for admin_group, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/admin_group (container)\n\nYANG Description: This container defines sub-TLV 3.", "id": "f22782:c0:m8"}
{"signature": "def _get_max_link_bandwidth(self):", "body": "return self.__max_link_bandwidth<EOL>", "docstring": "Getter method for max_link_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/max_link_bandwidth (container)\n\nYANG Description: This container defines sub-TLV 9.", "id": "f22782:c1:m17"}
{"signature": "def _get_link_attributes(self):", "body": "return self.__link_attributes<EOL>", "docstring": "Getter method for link_attributes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/link_attributes (container)\n\nYANG Description: This container defines link-attributes.", "id": "f22782:c1:m38"}
{"signature": "def _set_ipv6_interface_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=ipv6_interface_address.ipv6_interface_address,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv6_interface_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv6_interface_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/ipv6_interface_address (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ipv6_interface_address is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ipv6_interface_address() directly.\n\nYANG Description: This container defines sub-TLV 12.", "id": "f22782:c1:m27"}
{"signature": "def _set_admin_group(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=admin_group.admin_group,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__admin_group = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for admin_group, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/admin_group (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_admin_group is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_admin_group() directly.\n\nYANG Description: This container defines sub-TLV 3.", "id": "f22782:c0:m9"}
{"signature": "def _set_link_delay(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=link_delay.link_delay,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__link_delay = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for link_delay, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/link_delay (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_link_delay is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_link_delay() directly.\n\nYANG Description: This container defines unidirectional link delay.", "id": "f22782:c0:m57"}
{"signature": "def _set_utilized_bandwidth(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=utilized_bandwidth.utilized_bandwidth,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__utilized_bandwidth = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for utilized_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/utilized_bandwidth (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_utilized_bandwidth is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_utilized_bandwidth() directly.\n\nYANG Description: This container defines unidirectional utilized bandwidth.", "id": "f22782:c1:m75"}
{"signature": "def _get_te_default_metric(self):", "body": "return self.__te_default_metric<EOL>", "docstring": "Getter method for te_default_metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/te_default_metric (container)\n\nYANG Description: This container defines sub-TLV 18.", "id": "f22782:c0:m35"}
{"signature": "def _set_extended_admin_group(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=extended_admin_group.extended_admin_group,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__extended_admin_group = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for extended_admin_group, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/extended_admin_group (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_extended_admin_group is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_extended_admin_group() directly.\n\nYANG Description: This container defines sub-TLV 14.", "id": "f22782:c0:m33"}
{"signature": "def _set_ipv6_neighbor_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=ipv6_neighbor_address.ipv6_neighbor_address,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv6_neighbor_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv6_neighbor_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/ipv6_neighbor_address (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ipv6_neighbor_address is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ipv6_neighbor_address() directly.\n\nYANG Description: This container defines sub-TLV 13.", "id": "f22782:c0:m30"}
{"signature": "def _set_unreserved_bandwidth(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=unreserved_bandwidth.unreserved_bandwidth,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__unreserved_bandwidth = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for unreserved_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/unreserved_bandwidth (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_unreserved_bandwidth is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_unreserved_bandwidth() directly.\n\n    YANG Description: This container defines unreserved-bandwidth. The units are bytes\nper second.", "id": "f22782:c1:m24"}
{"signature": "def _set_bandwidth_constraints(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=bandwidth_constraints.bandwidth_constraints,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__bandwidth_constraints = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for bandwidth_constraints, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/bandwidth_constraints (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_bandwidth_constraints is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_bandwidth_constraints() directly.\n\n    YANG Description: This container defines bandwidth-constraints. For DS-TE, the\nexisting Maximum Reservable link bandwidth parameter is retained,\nbut its semantics is generalized and interpreted as the aggregate\nbandwidth constraint across all Class-Types", "id": "f22782:c1:m45"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/admin_group/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22783:c1:m2"}
{"signature": "def _set_admin_group(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__admin_group = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for admin_group, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/admin_group/state/admin_group (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_admin_group is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_admin_group() directly.\n\n    YANG Description: The administrative group sub-TLV contains a 4-octet bit mask\nassigned by the network administrator.  Each set bit corresponds\nto one administrative group assigned to the interface. By\nconvention, the least significant bit is referred to as group 0,\nand the most significant bit is referred to as group 31.", "id": "f22783:c1:m6"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/admin_group/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22783:c0:m2"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/admin_group/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22783:c1:m3"}
{"signature": "def _get_link_loss(self):", "body": "return self.__link_loss<EOL>", "docstring": "Getter method for link_loss, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/link_loss/state/link_loss (uint32)\n\n    YANG Description: Link packet loss as a percentage of the total traffic sent over\na configurable interval. The basic unit is 0.000003%, where\n(2^24 - 2) is 50.331642%. This value is the highest packet-loss\npercentage that can be expressed (the assumption being that\nprecision is more important on high-speed links than the ability\nto advertise loss rates greater than this, and that high- speed\nlinks with over 50% loss are unusable). Therefore, measured\nvalues that are larger than the field maximum SHOULD be encoded\nas the maximum value.", "id": "f22785:c0:m8"}
{"signature": "def _set_link_loss(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__link_loss = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for link_loss, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/link_loss/state/link_loss (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_link_loss is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_link_loss() directly.\n\n    YANG Description: Link packet loss as a percentage of the total traffic sent over\na configurable interval. The basic unit is 0.000003%, where\n(2^24 - 2) is 50.331642%. This value is the highest packet-loss\npercentage that can be expressed (the assumption being that\nprecision is more important on high-speed links than the ability\nto advertise loss rates greater than this, and that high- speed\nlinks with over 50% loss are unusable). Therefore, measured\nvalues that are larger than the field maximum SHOULD be encoded\nas the maximum value.", "id": "f22785:c0:m9"}
{"signature": "def _set_a_bit(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__a_bit = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for a_bit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/link_loss/state/a_bit (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_a_bit is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_a_bit() directly.\n\n    YANG Description: The A bit is set when the measured value of this parameter\nexceeds its configured maximum threshold. The A bit is cleared\nwhen the measured value falls below its configured reuse threshold.", "id": "f22785:c1:m6"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/link_loss/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22785:c1:m3"}
{"signature": "def _get_link_loss(self):", "body": "return self.__link_loss<EOL>", "docstring": "Getter method for link_loss, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/link_loss/state/link_loss (uint32)\n\n    YANG Description: Link packet loss as a percentage of the total traffic sent over\na configurable interval. The basic unit is 0.000003%, where\n(2^24 - 2) is 50.331642%. This value is the highest packet-loss\npercentage that can be expressed (the assumption being that\nprecision is more important on high-speed links than the ability\nto advertise loss rates greater than this, and that high- speed\nlinks with over 50% loss are unusable). Therefore, measured\nvalues that are larger than the field maximum SHOULD be encoded\nas the maximum value.", "id": "f22785:c1:m8"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/link_loss/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of IS Extended Reachability sub-TLV 36.", "id": "f22786:c1:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/link_loss/state (container)\n\nYANG Description: State parameters of IS Extended Reachability sub-TLV 36.", "id": "f22786:c0:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/link_loss/state (container)\n\nYANG Description: State parameters of IS Extended Reachability sub-TLV 36.", "id": "f22786:c1:m2"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/unreserved_bandwidth/setup_priority/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22787:c0:m6"}
{"signature": "def _set_unreserved_bandwidth(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=bitarray, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__unreserved_bandwidth = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for unreserved_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/unreserved_bandwidth/setup_priority/state/unreserved_bandwidth (oc-types:ieeefloat32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_unreserved_bandwidth is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_unreserved_bandwidth() directly.\n\n    YANG Description: The amount of bandwidth reservable in this direction on this\nlink. Note that for oversubscription purposes, this can be\ngreater than the bandwidth of the link. It contains eight\n32-bit IEEE floating point numbers(one for each priority). The\nunits are bytes (not bits!) per second. The values correspond\nto the bandwidth that can be reserved with a setup priority of\n0 through 7, arranged in increasing order with priority 0\noccurring at the start of the sub-TLV, and priority 7 at the\nend of the sub-TLV.", "id": "f22787:c0:m9"}
{"signature": "def _get_setup_priority(self):", "body": "return self.__setup_priority<EOL>", "docstring": "Getter method for setup_priority, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/unreserved_bandwidth/setup_priority/state/setup_priority (uint8)\n\n    YANG Description: Setup priority level of 0 through 7 to be used by Unreserved Bandwidth\nsub-TLV 11.", "id": "f22787:c1:m2"}
{"signature": "def _get_unreserved_bandwidth(self):", "body": "return self.__unreserved_bandwidth<EOL>", "docstring": "Getter method for unreserved_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/unreserved_bandwidth/setup_priority/state/unreserved_bandwidth (oc-types:ieeefloat32)\n\n    YANG Description: The amount of bandwidth reservable in this direction on this\nlink. Note that for oversubscription purposes, this can be\ngreater than the bandwidth of the link. It contains eight\n32-bit IEEE floating point numbers(one for each priority). The\nunits are bytes (not bits!) per second. The values correspond\nto the bandwidth that can be reserved with a setup priority of\n0 through 7, arranged in increasing order with priority 0\noccurring at the start of the sub-TLV, and priority 7 at the\nend of the sub-TLV.", "id": "f22787:c0:m8"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/unreserved_bandwidth/setup_priority/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of IS Extended Reachability sub-TLV 11.", "id": "f22788:c0:m3"}
{"signature": "def _set_setup_priority(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>False,<EOL>setup_priority.setup_priority,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT:False>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__setup_priority = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for setup_priority, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/unreserved_bandwidth/setup_priority (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_setup_priority is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_setup_priority() directly.\n\nYANG Description: Setup priority(0 through 7) for unreserved bandwidth.", "id": "f22789:c1:m3"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/link_protection_type/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22790:c0:m3"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/link_protection_type/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22790:c0:m2"}
{"signature": "def _get_link_protection_type(self):", "body": "return self.__link_protection_type<EOL>", "docstring": "Getter method for link_protection_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/link_protection_type/state/link_protection_type (enumeration)\n\nYANG Description: Link protection capabilities.", "id": "f22790:c0:m5"}
{"signature": "def _set_link_protection_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__link_protection_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for link_protection_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/link_protection_type/state/link_protection_type (enumeration)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_link_protection_type is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_link_protection_type() directly.\n\nYANG Description: Link protection capabilities.", "id": "f22790:c0:m6"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/link_protection_type/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of sub-TLV 20.", "id": "f22791:c0:m3"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/utilized_bandwidth/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22792:c1:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/utilized_bandwidth/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of IS Extended Reachability sub-TLV 39.", "id": "f22793:c0:m3"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/ipv4_neighbor_address/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22794:c0:m2"}
{"signature": "def _set_ipv4_neighbor_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv4_neighbor_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv4_neighbor_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/ipv4_neighbor_address/state/ipv4_neighbor_address (inet:ipv4-address-no-zone)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_ipv4_neighbor_address is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_ipv4_neighbor_address() directly.\n\n    YANG Description: A single IPv4 address for a neighboring router on this link.\nThis sub-TLV can occur multiple times.", "id": "f22794:c1:m6"}
{"signature": "def _set_ipv4_neighbor_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv4_neighbor_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv4_neighbor_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/ipv4_neighbor_address/state/ipv4_neighbor_address (inet:ipv4-address-no-zone)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_ipv4_neighbor_address is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_ipv4_neighbor_address() directly.\n\n    YANG Description: A single IPv4 address for a neighboring router on this link.\nThis sub-TLV can occur multiple times.", "id": "f22794:c0:m6"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/ipv4_neighbor_address/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of sub-TLV 8.", "id": "f22795:c1:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/ipv4_neighbor_address/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of sub-TLV 8.", "id": "f22795:c0:m3"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/bandwidth_constraints/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22796:c1:m3"}
{"signature": "def _get_model_id(self):", "body": "return self.__model_id<EOL>", "docstring": "Getter method for model_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/bandwidth_constraints/state/model_id (uint8)\n\n    YANG Description: Identifier for the Bandwidth Constraints  Model currently in\nuse by the LSR initiating the IGP advertisement.", "id": "f22796:c1:m5"}
{"signature": "def _set_model_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__model_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for model_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/bandwidth_constraints/state/model_id (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_model_id is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_model_id() directly.\n\n    YANG Description: Identifier for the Bandwidth Constraints  Model currently in\nuse by the LSR initiating the IGP advertisement.", "id": "f22796:c0:m6"}
{"signature": "def _set_bandwidth_constraints(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=bitarray, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__bandwidth_constraints = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for bandwidth_constraints, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/bandwidth_constraints/state/bandwidth_constraints (oc-types:ieeefloat32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_bandwidth_constraints is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_bandwidth_constraints() directly.\n\n    YANG Description: Contains BC0, BC1,... BC(N-1).  Each BC is encoded on 32 bits\nin IEEE floating point format.  The units are bytes (not bits!)\nper secondy.", "id": "f22796:c1:m12"}
{"signature": "def _get_local_protection(self):", "body": "return self.__local_protection<EOL>", "docstring": "Getter method for local_protection, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/link_attributes/state/local_protection (enumeration)\n\nYANG Description: Link local-protection attributes.", "id": "f22798:c1:m5"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/link_attributes/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22798:c0:m2"}
{"signature": "def _get_local_protection(self):", "body": "return self.__local_protection<EOL>", "docstring": "Getter method for local_protection, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/link_attributes/state/local_protection (enumeration)\n\nYANG Description: Link local-protection attributes.", "id": "f22798:c0:m5"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/link_attributes/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22798:c1:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/link_attributes/state (container)\n\nYANG Description: State parameters of IS Extended Reachability sub-TLV 19.", "id": "f22799:c0:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/link_attributes/state (container)\n\nYANG Description: State parameters of IS Extended Reachability sub-TLV 19.", "id": "f22799:c1:m2"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/extended_admin_group/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22800:c0:m2"}
{"signature": "def _get_extended_admin_group(self):", "body": "return self.__extended_admin_group<EOL>", "docstring": "Getter method for extended_admin_group, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/extended_admin_group/state/extended_admin_group (uint32)\n\n    YANG Description: The extended-admin-group sub-TLV is used in addition to the\nAdministrative Groups when it is desirable to make more than 32\ncolors available for advertisement in a network.", "id": "f22800:c0:m5"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/extended_admin_group/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22800:c1:m2"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/unconstrained_lsp/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22802:c1:m3"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/unconstrained_lsp/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22802:c1:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/unconstrained_lsp/state (container)\n\nYANG Description: State parameters of sub-TLV 23.", "id": "f22803:c1:m2"}
{"signature": "def _get_sid(self):", "body": "return self.__sid<EOL>", "docstring": "Getter method for sid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/lan_adjacency_sid/sid (list)\n\n    YANG Description: Adjacency Segment-IDs List. An IGP-Adjacency Segment is an IGP\nsegment attached to a unidirectional adjacency or a set of\nunidirectional adjacencies. By default, an IGP-Adjacency Segment is\nlocal to the node which advertises it.", "id": "f22804:c0:m2"}
{"signature": "def _set_sid(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>False,<EOL>sid.sid,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT:False>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__sid = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for sid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/lan_adjacency_sid/sid (list)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_sid is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_sid() directly.\n\n    YANG Description: Adjacency Segment-IDs List. An IGP-Adjacency Segment is an IGP\nsegment attached to a unidirectional adjacency or a set of\nunidirectional adjacencies. By default, an IGP-Adjacency Segment is\nlocal to the node which advertises it.", "id": "f22804:c1:m3"}
{"signature": "def _get_weight(self):", "body": "return self.__weight<EOL>", "docstring": "Getter method for weight, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/lan_adjacency_sid/sid/state/weight (uint8)\n\n    YANG Description: Value that represents the weight of the Adj-SID for the purpose\nof load balancing.", "id": "f22805:c1:m8"}
{"signature": "def _get_flags(self):", "body": "return self.__flags<EOL>", "docstring": "Getter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/lan_adjacency_sid/sid/state/flags (enumeration)\n\nYANG Description: Flags associated with LAN-Adj-Segment-ID.", "id": "f22805:c1:m5"}
{"signature": "def _set_flags(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__flags = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/lan_adjacency_sid/sid/state/flags (enumeration)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_flags is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_flags() directly.\n\nYANG Description: Flags associated with LAN-Adj-Segment-ID.", "id": "f22805:c1:m6"}
{"signature": "def _get_flags(self):", "body": "return self.__flags<EOL>", "docstring": "Getter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/lan_adjacency_sid/sid/state/flags (enumeration)\n\nYANG Description: Flags associated with LAN-Adj-Segment-ID.", "id": "f22805:c0:m5"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/lan_adjacency_sid/sid/state (container)\n\nYANG Description: State parameters of LAN Adjacency-SID.", "id": "f22806:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/lan_adjacency_sid/sid/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of LAN Adjacency-SID.", "id": "f22806:c0:m3"}
{"signature": "def _get_a_bit(self):", "body": "return self.__a_bit<EOL>", "docstring": "Getter method for a_bit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/link_delay/state/a_bit (boolean)\n\n    YANG Description: The A bit is set when the measured value of this parameter\nexceeds its configured maximum threshold. The A bit is cleared\nwhen the measured value falls below its configured reuse threshold.", "id": "f22807:c1:m5"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/link_delay/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22807:c0:m3"}
{"signature": "def _get_a_bit(self):", "body": "return self.__a_bit<EOL>", "docstring": "Getter method for a_bit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/link_delay/state/a_bit (boolean)\n\n    YANG Description: The A bit is set when the measured value of this parameter\nexceeds its configured maximum threshold. The A bit is cleared\nwhen the measured value falls below its configured reuse threshold.", "id": "f22807:c0:m5"}
{"signature": "def _get_delay(self):", "body": "return self.__delay<EOL>", "docstring": "Getter method for delay, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/link_delay/state/delay (uint32)\n\n    YANG Description: Average link delay value (in microseconds) between two directly\nconnected IS-IS neighbors over a configurable interval.", "id": "f22807:c1:m8"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/link_delay/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22807:c1:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/link_delay/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of IS Extended Reachability sub-TLV 33.", "id": "f22808:c0:m3"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/te_default_metric/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22809:c1:m2"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/te_default_metric/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22809:c0:m2"}
{"signature": "def _set_te_default_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__te_default_metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for te_default_metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/te_default_metric/state/te_default_metric (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_te_default_metric is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_te_default_metric() directly.\n\n    YANG Description: This metric is administratively assigned and can be used to\npresent a differently weighted topology to traffic engineering\nSPF calculations. To preclude overflow within a traffic\nengineering SPF implementation, all metrics greater than or\nequal to MAX_PATH_METRIC SHALL be considered to have a metric of\nMAX_PATH_METRIC.", "id": "f22809:c1:m6"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/te_default_metric/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of sub-TLV 18.", "id": "f22810:c0:m3"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/residual_bandwidth/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22811:c0:m3"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/ipv4_interface_address/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22813:c1:m3"}
{"signature": "def _get_ipv4_interface_address(self):", "body": "return self.__ipv4_interface_address<EOL>", "docstring": "Getter method for ipv4_interface_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/ipv4_interface_address/state/ipv4_interface_address (inet:ipv4-address-no-zone)\n\n    YANG Description: A 4-octet IPv4 address for the interface described by the\n(main) TLV. This sub-TLV can occur multiple times.", "id": "f22813:c1:m5"}
{"signature": "def _set_max_link_bandwidth(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=bitarray, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__max_link_bandwidth = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for max_link_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/max_link_bandwidth/state/max_link_bandwidth (oc-types:ieeefloat32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_max_link_bandwidth is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_max_link_bandwidth() directly.\n\n    YANG Description: The maximum bandwidth that can be used on this link in this\ndirection (from the system originating the LSP to its\nneighbors).  It is encoded in 32 bits in IEEE floating point\nformat.  The units are bytes (not bits!) per second.", "id": "f22815:c1:m6"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/max_link_bandwidth/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of sub-TLV 9.", "id": "f22816:c1:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/max_link_bandwidth/state (container)\n\nYANG Description: State parameters of sub-TLV 9.", "id": "f22816:c0:m2"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/ipv6_interface_address/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22817:c0:m3"}
{"signature": "def _set_ipv6_interface_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv6_interface_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv6_interface_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/ipv6_interface_address/state/ipv6_interface_address (inet:ipv6-address)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_ipv6_interface_address is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_ipv6_interface_address() directly.\n\n    YANG Description: Contains a 16-octet IPv6 address for the interface described by\nthe containing  Extended IS Reachability TLV. This sub-TLV can\noccur multiple times.", "id": "f22817:c1:m6"}
{"signature": "def _get_ipv6_interface_address(self):", "body": "return self.__ipv6_interface_address<EOL>", "docstring": "Getter method for ipv6_interface_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/ipv6_interface_address/state/ipv6_interface_address (inet:ipv6-address)\n\n    YANG Description: Contains a 16-octet IPv6 address for the interface described by\nthe containing  Extended IS Reachability TLV. This sub-TLV can\noccur multiple times.", "id": "f22817:c0:m5"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/ipv6_interface_address/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22817:c1:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs/subTLVs/ipv6_interface_address/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of sub-TLV 12.", "id": "f22818:c0:m3"}
{"signature": "def _set_undefined_subtlvs(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=undefined_subtlvs.undefined_subtlvs,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__undefined_subtlvs = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for undefined_subtlvs, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/undefined_subtlvs (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_undefined_subtlvs is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_undefined_subtlvs() directly.\n\nYANG Description: This container describes undefined ISIS TLVs.", "id": "f22819:c0:m9"}
{"signature": "def _get_subTLVs(self):", "body": "return self.__subTLVs<EOL>", "docstring": "Getter method for subTLVs, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/subTLVs (container)\n\nYANG Description: This container describes IS Neighbor sub-TLVs.", "id": "f22819:c1:m5"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/state (container)\n\nYANG Description: State parameters of MT neighbor.", "id": "f22819:c0:m2"}
{"signature": "def _get_undefined_subtlvs(self):", "body": "return self.__undefined_subtlvs<EOL>", "docstring": "Getter method for undefined_subtlvs, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/undefined_subtlvs (container)\n\nYANG Description: This container describes undefined ISIS TLVs.", "id": "f22819:c0:m8"}
{"signature": "def _get_length(self):", "body": "return self.__length<EOL>", "docstring": "Getter method for length, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/undefined_subtlvs/undefined_subtlv/state/length (uint8)\n\nYANG Description: TLV length.", "id": "f22820:c1:m5"}
{"signature": "def _set_value(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=bitarray,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:value>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__value = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for value, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/undefined_subtlvs/undefined_subtlv/state/value (binary)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_value is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_value() directly.\n\nYANG Description: TLV value.", "id": "f22820:c0:m9"}
{"signature": "def _set_value(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=bitarray,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:value>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__value = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for value, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/undefined_subtlvs/undefined_subtlv/state/value (binary)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_value is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_value() directly.\n\nYANG Description: TLV value.", "id": "f22820:c1:m9"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor/undefined_subtlvs/undefined_subtlv/state (container)\n\nYANG Description: State parameters of the undefined sub-TLV.", "id": "f22821:c0:m5"}
{"signature": "def _get_neighbor(self):", "body": "return self.__neighbor<EOL>", "docstring": "Getter method for neighbor, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor (list)\n\nYANG Description: MT-ISN neighbor attributes", "id": "f22823:c0:m2"}
{"signature": "def _get_neighbor(self):", "body": "return self.__neighbor<EOL>", "docstring": "Getter method for neighbor, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn/neighbors/neighbor (list)\n\nYANG Description: MT-ISN neighbor attributes", "id": "f22823:c1:m2"}
{"signature": "def _set_mt_isis_neighbor_attribute(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=mt_isis_neighbor_attribute.mt_isis_neighbor_attribute,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__mt_isis_neighbor_attribute = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for mt_isis_neighbor_attribute, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_mt_isis_neighbor_attribute is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_mt_isis_neighbor_attribute() directly.\n\n    YANG Description: This container defines list of ISIS multi-topology\nneighbors.", "id": "f22825:c0:m81"}
{"signature": "def _get_authentication(self):", "body": "return self.__authentication<EOL>", "docstring": "Getter method for authentication, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/authentication (container)\n\n    YANG Description: This container defines authentication information of the\nnode.", "id": "f22825:c1:m56"}
{"signature": "def _get_ipv4_external_reachability(self):", "body": "return self.__ipv4_external_reachability<EOL>", "docstring": "Getter method for ipv4_external_reachability, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_external_reachability (container)\n\n    YANG Description: This container defines list of IPv4 external reachability\ninformation.", "id": "f22825:c0:m50"}
{"signature": "def _get_multi_topology(self):", "body": "return self.__multi_topology<EOL>", "docstring": "Getter method for multi_topology, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/multi_topology (container)\n\nYANG Description: This container defines the topology supported.", "id": "f22825:c1:m68"}
{"signature": "def _set_authentication(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=authentication.authentication,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__authentication = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for authentication, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/authentication (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_authentication is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_authentication() directly.\n\n    YANG Description: This container defines authentication information of the\nnode.", "id": "f22825:c1:m57"}
{"signature": "def _get_mt_isn(self):", "body": "return self.__mt_isn<EOL>", "docstring": "Getter method for mt_isn, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isn (container)\n\n    YANG Description: This container defines list of ISIS multi-topology\nneighbors.", "id": "f22825:c0:m77"}
{"signature": "def _get_isis_alias_id(self):", "body": "return self.__isis_alias_id<EOL>", "docstring": "Getter method for isis_alias_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_alias_id (container)\n\n    YANG Description: This container defines the IS-Alias TLV which allows\nextension-capable ISs to recognize the Originating System of an\nExtended LSP set. It identifies the Normal system-id of the\nOriginating System.", "id": "f22825:c1:m74"}
{"signature": "def _get_multi_topology(self):", "body": "return self.__multi_topology<EOL>", "docstring": "Getter method for multi_topology, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/multi_topology (container)\n\nYANG Description: This container defines the topology supported.", "id": "f22825:c0:m68"}
{"signature": "def _set_area_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=area_address.area_address,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__area_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for area_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/area_address (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_area_address is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_area_address() directly.\n\nYANG Description: This container defines TLV 1.", "id": "f22825:c0:m9"}
{"signature": "def _set_nlpid(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=nlpid.nlpid,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__nlpid = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for nlpid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/nlpid (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_nlpid is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_nlpid() directly.\n\nYANG Description: This container defines TLV 129.", "id": "f22825:c1:m12"}
{"signature": "def _get_nlpid(self):", "body": "return self.__nlpid<EOL>", "docstring": "Getter method for nlpid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/nlpid (container)\n\nYANG Description: This container defines TLV 129.", "id": "f22825:c0:m11"}
{"signature": "def _get_ipv6_interface_addresses(self):", "body": "return self.__ipv6_interface_addresses<EOL>", "docstring": "Getter method for ipv6_interface_addresses, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_interface_addresses (container)\n\nYANG Description: This container defines TLV 232.", "id": "f22825:c1:m20"}
{"signature": "def _get_instance_id(self):", "body": "return self.__instance_id<EOL>", "docstring": "Getter method for instance_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/instance_id (container)\n\nYANG Description: This container defines ISIS Instance Identifier TLV.", "id": "f22825:c1:m29"}
{"signature": "def _set_isis_neighbor_attribute(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=isis_neighbor_attribute.isis_neighbor_attribute,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__isis_neighbor_attribute = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for isis_neighbor_attribute, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_isis_neighbor_attribute is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_isis_neighbor_attribute() directly.\n\n    YANG Description: This container defines list of ISIS topology neighbors\nfor extended ISIS LSP(multiple system IDs).", "id": "f22825:c0:m72"}
{"signature": "def _set_multi_topology(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=multi_topology.multi_topology,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__multi_topology = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for multi_topology, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/multi_topology (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_multi_topology is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_multi_topology() directly.\n\nYANG Description: This container defines the topology supported.", "id": "f22825:c1:m69"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: This container defines TLV State.", "id": "f22825:c0:m6"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: This container defines TLV State.", "id": "f22825:c1:m6"}
{"signature": "def _set_ipv6_interface_addresses(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=ipv6_interface_addresses.ipv6_interface_addresses,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv6_interface_addresses = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv6_interface_addresses, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_interface_addresses (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ipv6_interface_addresses is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ipv6_interface_addresses() directly.\n\nYANG Description: This container defines TLV 232.", "id": "f22825:c0:m21"}
{"signature": "def _set_type_block(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=type_block.type_block,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type_block = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type_block, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/type_block (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_type_block is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_type_block() directly.\n\nYANG Description: This container defines LSP Type Block.", "id": "f22825:c1:m54"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/state (container)\n\nYANG Description: This container defines TLV State.", "id": "f22825:c0:m5"}
{"signature": "def _set_ipv4_srlg(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=ipv4_srlg.ipv4_srlg,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv4_srlg = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv4_srlg, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_srlg (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ipv4_srlg is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ipv4_srlg() directly.\n\nYANG Description: This container defines ISIS SRLG TLV 138.", "id": "f22825:c1:m33"}
{"signature": "def _get_ipv6_srlg(self):", "body": "return self.__ipv6_srlg<EOL>", "docstring": "Getter method for ipv6_srlg, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_srlg (container)\n\nYANG Description: This container defines ISIS SRLG TLV.", "id": "f22825:c1:m35"}
{"signature": "def _set_isis_neighbor_attribute(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=isis_neighbor_attribute.isis_neighbor_attribute,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__isis_neighbor_attribute = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for isis_neighbor_attribute, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_neighbor_attribute (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_isis_neighbor_attribute is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_isis_neighbor_attribute() directly.\n\n    YANG Description: This container defines list of ISIS topology neighbors\nfor extended ISIS LSP(multiple system IDs).", "id": "f22825:c1:m72"}
{"signature": "def _get_extended_ipv4_reachability(self):", "body": "return self.__extended_ipv4_reachability<EOL>", "docstring": "Getter method for extended_ipv4_reachability, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability (container)\n\n    YANG Description: This container defines list of IPv4 extended reachability\ninformation.", "id": "f22825:c1:m62"}
{"signature": "def _set_purge_oi(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=purge_oi.purge_oi,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__purge_oi = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for purge_oi, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/purge_oi (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_purge_oi is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_purge_oi() directly.\n\nYANG Description: This container defines ISIS purge TLV.", "id": "f22825:c1:m39"}
{"signature": "def _set_extended_is_reachability(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=extended_is_reachability.extended_is_reachability,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__extended_is_reachability = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for extended_is_reachability, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_is_reachability (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_extended_is_reachability is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_extended_is_reachability() directly.\n\n    YANG Description: This container defines list of ISIS extended reachability\nneighbors.", "id": "f22825:c0:m60"}
{"signature": "def _get_extended_ipv4_reachability(self):", "body": "return self.__extended_ipv4_reachability<EOL>", "docstring": "Getter method for extended_ipv4_reachability, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability (container)\n\n    YANG Description: This container defines list of IPv4 extended reachability\ninformation.", "id": "f22825:c0:m62"}
{"signature": "def _set_ipv4_internal_reachability(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=ipv4_internal_reachability.ipv4_internal_reachability,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv4_internal_reachability = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv4_internal_reachability, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_internal_reachability (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_ipv4_internal_reachability is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_ipv4_internal_reachability() directly.\n\n    YANG Description: This container defines list of IPv4 internal reachability\ninformation.", "id": "f22825:c1:m48"}
{"signature": "def _set_type(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/type (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_type() directly.\n\n    YANG Description: A reference for the TLV type being described within\nthe LSDB.", "id": "f22825:c1:m3"}
{"signature": "def _set_isis_alias_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=isis_alias_id.isis_alias_id,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__isis_alias_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for isis_alias_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_alias_id (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_isis_alias_id is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_isis_alias_id() directly.\n\n    YANG Description: This container defines the IS-Alias TLV which allows\nextension-capable ISs to recognize the Originating System of an\nExtended LSP set. It identifies the Normal system-id of the\nOriginating System.", "id": "f22825:c1:m75"}
{"signature": "def _set_ipv4_external_reachability(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=ipv4_external_reachability.ipv4_external_reachability,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv4_external_reachability = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv4_external_reachability, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_external_reachability (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_ipv4_external_reachability is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_ipv4_external_reachability() directly.\n\n    YANG Description: This container defines list of IPv4 external reachability\ninformation.", "id": "f22825:c0:m51"}
{"signature": "def _get_hostname(self):", "body": "return self.__hostname<EOL>", "docstring": "Getter method for hostname, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/hostname (container)\n\nYANG Description: This container defines TLV 137.", "id": "f22825:c0:m14"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_alias_id/state/type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_type() directly.\n\n    YANG Description: The type of TLV being described. The type of TLV is\nexpressed as a canonical name.", "id": "f22826:c1:m3"}
{"signature": "def _get_alias_id(self):", "body": "return self.__alias_id<EOL>", "docstring": "Getter method for alias_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_alias_id/state/alias_id (oc-isis-types:system-id)\n\nYANG Description: List of alias ID(s).", "id": "f22826:c0:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/isis_alias_id/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of alias ID.", "id": "f22827:c1:m3"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/state/type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_type() directly.\n\n    YANG Description: The type of TLV being described. The type of TLV is\nexpressed as a canonical name.", "id": "f22828:c0:m3"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/state/type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_type() directly.\n\n    YANG Description: The type of TLV being described. The type of TLV is\nexpressed as a canonical name.", "id": "f22828:c1:m3"}
{"signature": "def _set_mt_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:16>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__mt_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for mt_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/state/mt_id (uint16)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_mt_id is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_mt_id() directly.\n\nYANG Description: Identifier of a topology being announced.", "id": "f22829:c1:m3"}
{"signature": "def _set_mt_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:16>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__mt_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for mt_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/state/mt_id (uint16)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_mt_id is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_mt_id() directly.\n\nYANG Description: Identifier of a topology being announced.", "id": "f22829:c0:m3"}
{"signature": "def _set_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/state/metric (oc-isis-types:wide-metric)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_metric is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_metric() directly.\n\nYANG Description: ISIS metric value.", "id": "f22829:c1:m9"}
{"signature": "def _set_subTLVs(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>subTLVs_.subTLVs,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subTLVs = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subTLVs, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_subTLVs is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_subTLVs() directly.\n\nYANG Description: List of subTLV types in the LSDB for the specified TLV.", "id": "f22830:c0:m3"}
{"signature": "def _get_available_bandwidth(self):", "body": "return self.__available_bandwidth<EOL>", "docstring": "Getter method for available_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/available_bandwidth/state/available_bandwidth (oc-types:ieeefloat32)\n\n    YANG Description: The available bandwidth on a link, forwarding adjacency, or\nbundled link in IEEE floating-point format with units of bytes\nper second. For a link or forwarding adjacency, available\nbandwidth is defined to be residual bandwidth minus the measured\nbandwidth used for the actual forwarding of non-RSVP-TE label\nswitched path packets.  For a bundled link, available bandwidth\nis defined to be the sum of the component link available\nbandwidths minus the measured bandwidth used for the actual\nforwarding of non-RSVP-TE label switched path packets.  For a\nbundled link, available bandwidth is defined to be the sum of\nthe component link available bandwidths.", "id": "f22831:c1:m5"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/available_bandwidth/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22831:c1:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/available_bandwidth/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of IS Extended Reachability sub-TLV 38.", "id": "f22832:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/available_bandwidth/state (container)\n\nYANG Description: State parameters of IS Extended Reachability sub-TLV 38.", "id": "f22832:c1:m2"}
{"signature": "def _get_sid(self):", "body": "return self.__sid<EOL>", "docstring": "Getter method for sid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/adjacency_sid/sid (list)\n\n    YANG Description: Adjacency Segment-IDs List. An IGP-Adjacency Segment is an IGP\nsegment attached to a unidirectional adjacency or a set of\nunidirectional adjacencies. By default, an IGP-Adjacency Segment is\nlocal to the node which advertises it.", "id": "f22833:c0:m2"}
{"signature": "def _set_sid(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>False,<EOL>sid.sid,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT:False>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__sid = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for sid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/adjacency_sid/sid (list)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_sid is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_sid() directly.\n\n    YANG Description: Adjacency Segment-IDs List. An IGP-Adjacency Segment is an IGP\nsegment attached to a unidirectional adjacency or a set of\nunidirectional adjacencies. By default, an IGP-Adjacency Segment is\nlocal to the node which advertises it.", "id": "f22833:c1:m3"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22836:c0:m3"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22836:c1:m3"}
{"signature": "def _set_delay(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__delay = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for delay, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_delay_variation/state/delay (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_delay is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_delay() directly.\n\n    YANG Description: Average link delay between two directly connected IS-IS\nneighbors over a configurable interval.", "id": "f22837:c0:m6"}
{"signature": "def _set_delay(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__delay = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for delay, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_delay_variation/state/delay (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_delay is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_delay() directly.\n\n    YANG Description: Average link delay between two directly connected IS-IS\nneighbors over a configurable interval.", "id": "f22837:c1:m6"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_delay_variation/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22837:c1:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_delay_variation/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of IS Extended Reachability sub-TLV 35.", "id": "f22838:c0:m3"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/max_reservable_link_bandwidth/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22839:c1:m3"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/max_reservable_link_bandwidth/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22839:c1:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/max_reservable_link_bandwidth/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of sub-TLV 10.", "id": "f22840:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/max_reservable_link_bandwidth/state (container)\n\nYANG Description: State parameters of sub-TLV 10.", "id": "f22840:c0:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/max_reservable_link_bandwidth/state (container)\n\nYANG Description: State parameters of sub-TLV 10.", "id": "f22840:c1:m2"}
{"signature": "def _set_ipv6_neighbor_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv6_neighbor_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv6_neighbor_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/ipv6_neighbor_address/state/ipv6_neighbor_address (inet:ipv6-address)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_ipv6_neighbor_address is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_ipv6_neighbor_address() directly.\n\n    YANG Description: Contains a 16-octet IPv6 address for a neighboring router on\nthe link described by the (main) TLV. This sub-TLV can occur\nmultiple times.", "id": "f22841:c0:m6"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/ipv6_neighbor_address/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22841:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/ipv6_neighbor_address/state (container)\n\nYANG Description: State parameters of sub-TLV 13.", "id": "f22842:c1:m2"}
{"signature": "def _get_min_delay(self):", "body": "return self.__min_delay<EOL>", "docstring": "Getter method for min_delay, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/min_max_link_delay/state/min_delay (uint32)\n\n    YANG Description: Minimum measured link delay value(in microseconds) between two\ndirectly connected IS-IS neighbors over a configurable\ninterval.", "id": "f22843:c0:m8"}
{"signature": "def _set_max_delay(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__max_delay = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for max_delay, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/min_max_link_delay/state/max_delay (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_max_delay is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_max_delay() directly.\n\n    YANG Description: Maximum measured link delay value(in microseconds) between two\ndirectly connected IS-IS neighbors over a configurable\ninterval.", "id": "f22843:c1:m12"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/min_max_link_delay/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22843:c0:m3"}
{"signature": "def _get_min_delay(self):", "body": "return self.__min_delay<EOL>", "docstring": "Getter method for min_delay, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/min_max_link_delay/state/min_delay (uint32)\n\n    YANG Description: Minimum measured link delay value(in microseconds) between two\ndirectly connected IS-IS neighbors over a configurable\ninterval.", "id": "f22843:c1:m8"}
{"signature": "def _set_a_bit(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__a_bit = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for a_bit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/min_max_link_delay/state/a_bit (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_a_bit is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_a_bit() directly.\n\n    YANG Description: The A bit is set when the measured value of this parameter\nexceeds its configured maximum threshold. The A bit is cleared\nwhen the measured value falls below its configured reuse threshold.", "id": "f22843:c0:m6"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/min_max_link_delay/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22843:c1:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/min_max_link_delay/state (container)\n\nYANG Description: State parameters of IS Extended Reachability sub-TLV 34.", "id": "f22844:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/min_max_link_delay/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of IS Extended Reachability sub-TLV 34.", "id": "f22844:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/min_max_link_delay/state (container)\n\nYANG Description: State parameters of IS Extended Reachability sub-TLV 34.", "id": "f22844:c1:m2"}
{"signature": "def _set_utilized_bandwidth(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=utilized_bandwidth.utilized_bandwidth,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__utilized_bandwidth = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for utilized_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/utilized_bandwidth (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_utilized_bandwidth is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_utilized_bandwidth() directly.\n\nYANG Description: This container defines unidirectional utilized bandwidth.", "id": "f22845:c1:m75"}
{"signature": "def _get_min_max_link_delay(self):", "body": "return self.__min_max_link_delay<EOL>", "docstring": "Getter method for min_max_link_delay, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/min_max_link_delay (container)\n\nYANG Description: This container defines min/max link delay.", "id": "f22845:c1:m59"}
{"signature": "def _set_te_default_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=te_default_metric.te_default_metric,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__te_default_metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for te_default_metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/te_default_metric (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_te_default_metric is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_te_default_metric() directly.\n\nYANG Description: This container defines sub-TLV 18.", "id": "f22845:c0:m36"}
{"signature": "def _set_lan_adjacency_sid(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=lan_adjacency_sid.lan_adjacency_sid,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__lan_adjacency_sid = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for lan_adjacency_sid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/lan_adjacency_sid (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_lan_adjacency_sid is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_lan_adjacency_sid() directly.\n\nYANG Description: This container defines segment routing extensions for prefixes.", "id": "f22845:c0:m54"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/subtlv_type (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: A reference for the TLV type being described within\nthe LSDB", "id": "f22845:c1:m3"}
{"signature": "def _get_unconstrained_lsp(self):", "body": "return self.__unconstrained_lsp<EOL>", "docstring": "Getter method for unconstrained_lsp, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/unconstrained_lsp (container)\n\nYANG Description: This container defines sub-TLV 23.", "id": "f22845:c1:m47"}
{"signature": "def _get_ipv4_neighbor_address(self):", "body": "return self.__ipv4_neighbor_address<EOL>", "docstring": "Getter method for ipv4_neighbor_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/ipv4_neighbor_address (container)\n\nYANG Description: This container defines sub-TLV 8.", "id": "f22845:c1:m14"}
{"signature": "def _get_unreserved_bandwidth(self):", "body": "return self.__unreserved_bandwidth<EOL>", "docstring": "Getter method for unreserved_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/unreserved_bandwidth (container)\n\n    YANG Description: This container defines unreserved-bandwidth. The units are bytes\nper second.", "id": "f22845:c1:m23"}
{"signature": "def _get_max_reservable_link_bandwidth(self):", "body": "return self.__max_reservable_link_bandwidth<EOL>", "docstring": "Getter method for max_reservable_link_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/max_reservable_link_bandwidth (container)\n\nYANG Description: This container defines sub-TLV 10.", "id": "f22845:c0:m20"}
{"signature": "def _set_ipv6_interface_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=ipv6_interface_address.ipv6_interface_address,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv6_interface_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv6_interface_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/ipv6_interface_address (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ipv6_interface_address is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ipv6_interface_address() directly.\n\nYANG Description: This container defines sub-TLV 12.", "id": "f22845:c1:m27"}
{"signature": "def _get_available_bandwidth(self):", "body": "return self.__available_bandwidth<EOL>", "docstring": "Getter method for available_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/available_bandwidth (container)\n\nYANG Description: This container defines unidirectional lavailable bandwidth.", "id": "f22845:c1:m71"}
{"signature": "def _get_max_link_bandwidth(self):", "body": "return self.__max_link_bandwidth<EOL>", "docstring": "Getter method for max_link_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/max_link_bandwidth (container)\n\nYANG Description: This container defines sub-TLV 9.", "id": "f22845:c0:m17"}
{"signature": "def _set_admin_group(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=admin_group.admin_group,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__admin_group = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for admin_group, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/admin_group (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_admin_group is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_admin_group() directly.\n\nYANG Description: This container defines sub-TLV 3.", "id": "f22845:c0:m9"}
{"signature": "def _set_utilized_bandwidth(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=utilized_bandwidth.utilized_bandwidth,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__utilized_bandwidth = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for utilized_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/utilized_bandwidth (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_utilized_bandwidth is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_utilized_bandwidth() directly.\n\nYANG Description: This container defines unidirectional utilized bandwidth.", "id": "f22845:c0:m75"}
{"signature": "def _set_ipv4_interface_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=ipv4_interface_address.ipv4_interface_address,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv4_interface_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv4_interface_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/ipv4_interface_address (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ipv4_interface_address is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ipv4_interface_address() directly.\n\nYANG Description: This container defines sub-TLV 6.", "id": "f22845:c0:m12"}
{"signature": "def _set_adjacency_sid(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=adjacency_sid.adjacency_sid,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__adjacency_sid = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for adjacency_sid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/adjacency_sid (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_adjacency_sid is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_adjacency_sid() directly.\n\nYANG Description: This container defines segment routing extensions for prefixes.", "id": "f22845:c0:m51"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/state (container)\n\nYANG Description: State parameters of IS neighbor state", "id": "f22845:c1:m5"}
{"signature": "def _set_link_attributes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=link_attributes.link_attributes,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__link_attributes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for link_attributes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_attributes (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_link_attributes is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_link_attributes() directly.\n\nYANG Description: This container defines link-attributes.", "id": "f22845:c1:m39"}
{"signature": "def _set_admin_group(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=admin_group.admin_group,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__admin_group = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for admin_group, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/admin_group (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_admin_group is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_admin_group() directly.\n\nYANG Description: This container defines sub-TLV 3.", "id": "f22845:c1:m9"}
{"signature": "def _get_utilized_bandwidth(self):", "body": "return self.__utilized_bandwidth<EOL>", "docstring": "Getter method for utilized_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/utilized_bandwidth (container)\n\nYANG Description: This container defines unidirectional utilized bandwidth.", "id": "f22845:c0:m74"}
{"signature": "def _set_link_delay(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=link_delay.link_delay,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__link_delay = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for link_delay, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_delay (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_link_delay is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_link_delay() directly.\n\nYANG Description: This container defines unidirectional link delay.", "id": "f22845:c1:m57"}
{"signature": "def _get_max_reservable_link_bandwidth(self):", "body": "return self.__max_reservable_link_bandwidth<EOL>", "docstring": "Getter method for max_reservable_link_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/max_reservable_link_bandwidth (container)\n\nYANG Description: This container defines sub-TLV 10.", "id": "f22845:c1:m20"}
{"signature": "def _set_bandwidth_constraints(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=bandwidth_constraints.bandwidth_constraints,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__bandwidth_constraints = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for bandwidth_constraints, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/bandwidth_constraints (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_bandwidth_constraints is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_bandwidth_constraints() directly.\n\n    YANG Description: This container defines bandwidth-constraints. For DS-TE, the\nexisting Maximum Reservable link bandwidth parameter is retained,\nbut its semantics is generalized and interpreted as the aggregate\nbandwidth constraint across all Class-Types", "id": "f22845:c0:m45"}
{"signature": "def _set_link_loss(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=link_loss.link_loss,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__link_loss = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for link_loss, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_loss (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_link_loss is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_link_loss() directly.\n\nYANG Description: This container defines unidirectional link loss delay.", "id": "f22845:c1:m66"}
{"signature": "def _get_ipv6_neighbor_address(self):", "body": "return self.__ipv6_neighbor_address<EOL>", "docstring": "Getter method for ipv6_neighbor_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/ipv6_neighbor_address (container)\n\nYANG Description: This container defines sub-TLV 13.", "id": "f22845:c0:m29"}
{"signature": "def _set_link_attributes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=link_attributes.link_attributes,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__link_attributes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for link_attributes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_attributes (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_link_attributes is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_link_attributes() directly.\n\nYANG Description: This container defines link-attributes.", "id": "f22845:c0:m39"}
{"signature": "def _get_extended_admin_group(self):", "body": "return self.__extended_admin_group<EOL>", "docstring": "Getter method for extended_admin_group, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/extended_admin_group (container)\n\nYANG Description: This container defines sub-TLV 14.", "id": "f22845:c1:m32"}
{"signature": "def _get_unreserved_bandwidth(self):", "body": "return self.__unreserved_bandwidth<EOL>", "docstring": "Getter method for unreserved_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/unreserved_bandwidth (container)\n\n    YANG Description: This container defines unreserved-bandwidth. The units are bytes\nper second.", "id": "f22845:c0:m23"}
{"signature": "def _set_unconstrained_lsp(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=unconstrained_lsp.unconstrained_lsp,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__unconstrained_lsp = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for unconstrained_lsp, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/unconstrained_lsp (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_unconstrained_lsp is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_unconstrained_lsp() directly.\n\nYANG Description: This container defines sub-TLV 23.", "id": "f22845:c1:m48"}
{"signature": "def _set_min_max_link_delay(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=min_max_link_delay.min_max_link_delay,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__min_max_link_delay = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for min_max_link_delay, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/min_max_link_delay (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_min_max_link_delay is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_min_max_link_delay() directly.\n\nYANG Description: This container defines min/max link delay.", "id": "f22845:c1:m60"}
{"signature": "def _set_ipv4_neighbor_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=ipv4_neighbor_address.ipv4_neighbor_address,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv4_neighbor_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv4_neighbor_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/ipv4_neighbor_address (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ipv4_neighbor_address is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ipv4_neighbor_address() directly.\n\nYANG Description: This container defines sub-TLV 8.", "id": "f22845:c1:m15"}
{"signature": "def _get_bandwidth_constraints(self):", "body": "return self.__bandwidth_constraints<EOL>", "docstring": "Getter method for bandwidth_constraints, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/bandwidth_constraints (container)\n\n    YANG Description: This container defines bandwidth-constraints. For DS-TE, the\nexisting Maximum Reservable link bandwidth parameter is retained,\nbut its semantics is generalized and interpreted as the aggregate\nbandwidth constraint across all Class-Types", "id": "f22845:c1:m44"}
{"signature": "def _set_lan_adjacency_sid(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=lan_adjacency_sid.lan_adjacency_sid,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__lan_adjacency_sid = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for lan_adjacency_sid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/lan_adjacency_sid (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_lan_adjacency_sid is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_lan_adjacency_sid() directly.\n\nYANG Description: This container defines segment routing extensions for prefixes.", "id": "f22845:c1:m54"}
{"signature": "def _set_ipv4_neighbor_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=ipv4_neighbor_address.ipv4_neighbor_address,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv4_neighbor_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv4_neighbor_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/ipv4_neighbor_address (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ipv4_neighbor_address is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ipv4_neighbor_address() directly.\n\nYANG Description: This container defines sub-TLV 8.", "id": "f22845:c0:m15"}
{"signature": "def _get_link_delay_variation(self):", "body": "return self.__link_delay_variation<EOL>", "docstring": "Getter method for link_delay_variation, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_delay_variation (container)\n\nYANG Description: This container defines unidirectional link delay variation.", "id": "f22845:c0:m62"}
{"signature": "def _get_ipv6_neighbor_address(self):", "body": "return self.__ipv6_neighbor_address<EOL>", "docstring": "Getter method for ipv6_neighbor_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/ipv6_neighbor_address (container)\n\nYANG Description: This container defines sub-TLV 13.", "id": "f22845:c1:m29"}
{"signature": "def _set_extended_admin_group(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=extended_admin_group.extended_admin_group,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__extended_admin_group = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for extended_admin_group, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/extended_admin_group (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_extended_admin_group is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_extended_admin_group() directly.\n\nYANG Description: This container defines sub-TLV 14.", "id": "f22845:c0:m33"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/admin_group/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22846:c0:m3"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/admin_group/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22846:c0:m2"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/admin_group/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22846:c1:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/admin_group/state (container)\n\nYANG Description: State parameters of sub-TLV 3.", "id": "f22847:c0:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/admin_group/state (container)\n\nYANG Description: State parameters of sub-TLV 3.", "id": "f22847:c1:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/admin_group/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of sub-TLV 3.", "id": "f22847:c1:m3"}
{"signature": "def _get_link_loss(self):", "body": "return self.__link_loss<EOL>", "docstring": "Getter method for link_loss, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_loss/state/link_loss (uint32)\n\n    YANG Description: Link packet loss as a percentage of the total traffic sent over\na configurable interval. The basic unit is 0.000003%, where\n(2^24 - 2) is 50.331642%. This value is the highest packet-loss\npercentage that can be expressed (the assumption being that\nprecision is more important on high-speed links than the ability\nto advertise loss rates greater than this, and that high- speed\nlinks with over 50% loss are unusable). Therefore, measured\nvalues that are larger than the field maximum SHOULD be encoded\nas the maximum value.", "id": "f22848:c1:m8"}
{"signature": "def _get_a_bit(self):", "body": "return self.__a_bit<EOL>", "docstring": "Getter method for a_bit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_loss/state/a_bit (boolean)\n\n    YANG Description: The A bit is set when the measured value of this parameter\nexceeds its configured maximum threshold. The A bit is cleared\nwhen the measured value falls below its configured reuse threshold.", "id": "f22848:c0:m5"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_loss/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22848:c0:m2"}
{"signature": "def _set_a_bit(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__a_bit = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for a_bit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_loss/state/a_bit (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_a_bit is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_a_bit() directly.\n\n    YANG Description: The A bit is set when the measured value of this parameter\nexceeds its configured maximum threshold. The A bit is cleared\nwhen the measured value falls below its configured reuse threshold.", "id": "f22848:c1:m6"}
{"signature": "def _set_unreserved_bandwidth(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=bitarray, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__unreserved_bandwidth = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for unreserved_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/unreserved_bandwidth/setup_priority/state/unreserved_bandwidth (oc-types:ieeefloat32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_unreserved_bandwidth is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_unreserved_bandwidth() directly.\n\n    YANG Description: The amount of bandwidth reservable in this direction on this\nlink. Note that for oversubscription purposes, this can be\ngreater than the bandwidth of the link. It contains eight\n32-bit IEEE floating point numbers(one for each priority). The\nunits are bytes (not bits!) per second. The values correspond\nto the bandwidth that can be reserved with a setup priority of\n0 through 7, arranged in increasing order with priority 0\noccurring at the start of the sub-TLV, and priority 7 at the\nend of the sub-TLV.", "id": "f22850:c0:m9"}
{"signature": "def _set_setup_priority(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__setup_priority = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for setup_priority, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/unreserved_bandwidth/setup_priority/state/setup_priority (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_setup_priority is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_setup_priority() directly.\n\n    YANG Description: Setup priority level of 0 through 7 to be used by Unreserved Bandwidth\nsub-TLV 11.", "id": "f22850:c0:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/unreserved_bandwidth/setup_priority/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of IS Extended Reachability sub-TLV 11.", "id": "f22851:c0:m3"}
{"signature": "def _set_setup_priority(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>False,<EOL>setup_priority.setup_priority,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT:False>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__setup_priority = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for setup_priority, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/unreserved_bandwidth/setup_priority (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_setup_priority is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_setup_priority() directly.\n\nYANG Description: Setup priority(0 through 7) for unreserved bandwidth.", "id": "f22852:c1:m3"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_protection_type/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22853:c1:m3"}
{"signature": "def _set_link_protection_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__link_protection_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for link_protection_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_protection_type/state/link_protection_type (enumeration)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_link_protection_type is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_link_protection_type() directly.\n\nYANG Description: Link protection capabilities.", "id": "f22853:c0:m6"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_protection_type/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22853:c1:m2"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/utilized_bandwidth/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22855:c0:m3"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/utilized_bandwidth/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22855:c0:m2"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/utilized_bandwidth/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22855:c1:m2"}
{"signature": "def _get_utilized_bandwidth(self):", "body": "return self.__utilized_bandwidth<EOL>", "docstring": "Getter method for utilized_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/utilized_bandwidth/state/utilized_bandwidth (oc-types:ieeefloat32)\n\n    YANG Description: The bandwidth utilization on a link, forwarding adjacency, or\nbundled link in IEEE floating-point format with units of bytes\nper second.  For a link or forwarding adjacency, bandwidth\nutilization represents the actual utilization of the link (i.e.,\nas measured by the advertising node).  For a bundled link,\nbandwidth utilization is defined to be the sum of the component\nlink bandwidth utilizations.", "id": "f22855:c1:m5"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/utilized_bandwidth/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22855:c1:m3"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/ipv4_neighbor_address/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22857:c0:m2"}
{"signature": "def _set_ipv4_neighbor_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv4_neighbor_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv4_neighbor_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/ipv4_neighbor_address/state/ipv4_neighbor_address (inet:ipv4-address-no-zone)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_ipv4_neighbor_address is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_ipv4_neighbor_address() directly.\n\n    YANG Description: A single IPv4 address for a neighboring router on this link.\nThis sub-TLV can occur multiple times.", "id": "f22857:c1:m6"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/ipv4_neighbor_address/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22857:c1:m2"}
{"signature": "def _get_model_id(self):", "body": "return self.__model_id<EOL>", "docstring": "Getter method for model_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/bandwidth_constraints/state/model_id (uint8)\n\n    YANG Description: Identifier for the Bandwidth Constraints  Model currently in\nuse by the LSR initiating the IGP advertisement.", "id": "f22859:c1:m5"}
{"signature": "def _set_bandwidth_constraints(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=bitarray, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__bandwidth_constraints = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for bandwidth_constraints, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/bandwidth_constraints/state/bandwidth_constraints (oc-types:ieeefloat32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_bandwidth_constraints is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_bandwidth_constraints() directly.\n\n    YANG Description: Contains BC0, BC1,... BC(N-1).  Each BC is encoded on 32 bits\nin IEEE floating point format.  The units are bytes (not bits!)\nper secondy.", "id": "f22859:c0:m12"}
{"signature": "def _set_model_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__model_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for model_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/bandwidth_constraints/state/model_id (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_model_id is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_model_id() directly.\n\n    YANG Description: Identifier for the Bandwidth Constraints  Model currently in\nuse by the LSR initiating the IGP advertisement.", "id": "f22859:c1:m6"}
{"signature": "def _set_model_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__model_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for model_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/bandwidth_constraints/state/model_id (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_model_id is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_model_id() directly.\n\n    YANG Description: Identifier for the Bandwidth Constraints  Model currently in\nuse by the LSR initiating the IGP advertisement.", "id": "f22859:c0:m6"}
{"signature": "def _get_reserved(self):", "body": "return self.__reserved<EOL>", "docstring": "Getter method for reserved, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/bandwidth_constraints/state/reserved (uint32)\n\n    YANG Description: Should be set to zero by the LSR generating the sub-TLV and\nshould be ignored by the LSR receiving the sub-TLV.", "id": "f22859:c1:m8"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_attributes/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22861:c1:m3"}
{"signature": "def _set_local_protection(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__local_protection = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for local_protection, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_attributes/state/local_protection (enumeration)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_local_protection is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_local_protection() directly.\n\nYANG Description: Link local-protection attributes.", "id": "f22861:c1:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_attributes/state (container)\n\nYANG Description: State parameters of IS Extended Reachability sub-TLV 19.", "id": "f22862:c1:m2"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/extended_admin_group/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22863:c0:m2"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/extended_admin_group/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22863:c0:m3"}
{"signature": "def _set_extended_admin_group(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__extended_admin_group = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for extended_admin_group, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/extended_admin_group/state/extended_admin_group (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_extended_admin_group is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_extended_admin_group() directly.\n\n    YANG Description: The extended-admin-group sub-TLV is used in addition to the\nAdministrative Groups when it is desirable to make more than 32\ncolors available for advertisement in a network.", "id": "f22863:c1:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/extended_admin_group/state (container)\n\nYANG Description: State parameters of sub-TLV 14.", "id": "f22864:c0:m2"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/unconstrained_lsp/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22865:c0:m2"}
{"signature": "def _set_sid(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>False,<EOL>sid.sid,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT:False>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__sid = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for sid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/lan_adjacency_sid/sid (list)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_sid is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_sid() directly.\n\n    YANG Description: Adjacency Segment-IDs List. An IGP-Adjacency Segment is an IGP\nsegment attached to a unidirectional adjacency or a set of\nunidirectional adjacencies. By default, an IGP-Adjacency Segment is\nlocal to the node which advertises it.", "id": "f22867:c1:m3"}
{"signature": "def _get_sid(self):", "body": "return self.__sid<EOL>", "docstring": "Getter method for sid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/lan_adjacency_sid/sid (list)\n\n    YANG Description: Adjacency Segment-IDs List. An IGP-Adjacency Segment is an IGP\nsegment attached to a unidirectional adjacency or a set of\nunidirectional adjacencies. By default, an IGP-Adjacency Segment is\nlocal to the node which advertises it.", "id": "f22867:c0:m2"}
{"signature": "def _get_flags(self):", "body": "return self.__flags<EOL>", "docstring": "Getter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/lan_adjacency_sid/sid/state/flags (enumeration)\n\nYANG Description: Flags associated with LAN-Adj-Segment-ID.", "id": "f22868:c0:m5"}
{"signature": "def _set_weight(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__weight = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for weight, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/lan_adjacency_sid/sid/state/weight (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_weight is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_weight() directly.\n\n    YANG Description: Value that represents the weight of the Adj-SID for the purpose\nof load balancing.", "id": "f22868:c0:m9"}
{"signature": "def _get_weight(self):", "body": "return self.__weight<EOL>", "docstring": "Getter method for weight, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/lan_adjacency_sid/sid/state/weight (uint8)\n\n    YANG Description: Value that represents the weight of the Adj-SID for the purpose\nof load balancing.", "id": "f22868:c1:m8"}
{"signature": "def _get_value(self):", "body": "return self.__value<EOL>", "docstring": "Getter method for value, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/lan_adjacency_sid/sid/state/value (uint32)\n\nYANG Description: LAN Adjacency-SID value.", "id": "f22868:c0:m2"}
{"signature": "def _set_value(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:value>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__value = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for value, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/lan_adjacency_sid/sid/state/value (uint32)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_value is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_value() directly.\n\nYANG Description: LAN Adjacency-SID value.", "id": "f22868:c0:m3"}
{"signature": "def _get_weight(self):", "body": "return self.__weight<EOL>", "docstring": "Getter method for weight, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/lan_adjacency_sid/sid/state/weight (uint8)\n\n    YANG Description: Value that represents the weight of the Adj-SID for the purpose\nof load balancing.", "id": "f22868:c0:m8"}
{"signature": "def _set_value(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:value>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__value = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for value, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/lan_adjacency_sid/sid/state/value (uint32)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_value is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_value() directly.\n\nYANG Description: LAN Adjacency-SID value.", "id": "f22868:c1:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/lan_adjacency_sid/sid/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of LAN Adjacency-SID.", "id": "f22869:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/lan_adjacency_sid/sid/state (container)\n\nYANG Description: State parameters of LAN Adjacency-SID.", "id": "f22869:c1:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/lan_adjacency_sid/sid/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of LAN Adjacency-SID.", "id": "f22869:c1:m3"}
{"signature": "def _get_delay(self):", "body": "return self.__delay<EOL>", "docstring": "Getter method for delay, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_delay/state/delay (uint32)\n\n    YANG Description: Average link delay value (in microseconds) between two directly\nconnected IS-IS neighbors over a configurable interval.", "id": "f22870:c1:m8"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/link_delay/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22870:c1:m2"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/te_default_metric/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22872:c1:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/te_default_metric/state (container)\n\nYANG Description: State parameters of sub-TLV 18.", "id": "f22873:c1:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/te_default_metric/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of sub-TLV 18.", "id": "f22873:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/te_default_metric/state (container)\n\nYANG Description: State parameters of sub-TLV 18.", "id": "f22873:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/te_default_metric/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of sub-TLV 18.", "id": "f22873:c1:m3"}
{"signature": "def _get_residual_bandwidth(self):", "body": "return self.__residual_bandwidth<EOL>", "docstring": "Getter method for residual_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/residual_bandwidth/state/residual_bandwidth (oc-types:ieeefloat32)\n\n    YANG Description: Residual bandwidth on a link,forwarding adjacency [RFC4206], or\nbundled link in IEEE floating-point format with units of bytes\nper second. For a link or forwarding adjacency, residual\nbandwidth is defined to be the Maximum Bandwidth [RFC5305] minus\nthe bandwidth currently allocated to RSVP-TE label switched\npaths. For a bundled link, residual bandwidth is defined to be\nthe sum of the component link residual bandwidths.", "id": "f22874:c0:m5"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/residual_bandwidth/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22874:c0:m3"}
{"signature": "def _get_ipv4_interface_address(self):", "body": "return self.__ipv4_interface_address<EOL>", "docstring": "Getter method for ipv4_interface_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/ipv4_interface_address/state/ipv4_interface_address (inet:ipv4-address-no-zone)\n\n    YANG Description: A 4-octet IPv4 address for the interface described by the\n(main) TLV. This sub-TLV can occur multiple times.", "id": "f22876:c0:m5"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/ipv4_interface_address/state (container)\n\nYANG Description: State parameters of sub-TLV 6.", "id": "f22877:c1:m2"}
{"signature": "def _get_max_link_bandwidth(self):", "body": "return self.__max_link_bandwidth<EOL>", "docstring": "Getter method for max_link_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/max_link_bandwidth/state/max_link_bandwidth (oc-types:ieeefloat32)\n\n    YANG Description: The maximum bandwidth that can be used on this link in this\ndirection (from the system originating the LSP to its\nneighbors).  It is encoded in 32 bits in IEEE floating point\nformat.  The units are bytes (not bits!) per second.", "id": "f22878:c0:m5"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/max_link_bandwidth/state (container)\n\nYANG Description: State parameters of sub-TLV 9.", "id": "f22879:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/max_link_bandwidth/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of sub-TLV 9.", "id": "f22879:c1:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/max_link_bandwidth/state (container)\n\nYANG Description: State parameters of sub-TLV 9.", "id": "f22879:c1:m2"}
{"signature": "def _get_ipv6_interface_address(self):", "body": "return self.__ipv6_interface_address<EOL>", "docstring": "Getter method for ipv6_interface_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/ipv6_interface_address/state/ipv6_interface_address (inet:ipv6-address)\n\n    YANG Description: Contains a 16-octet IPv6 address for the interface described by\nthe containing  Extended IS Reachability TLV. This sub-TLV can\noccur multiple times.", "id": "f22880:c0:m5"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/ipv6_interface_address/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22880:c1:m3"}
{"signature": "def _set_ipv6_interface_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv6_interface_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv6_interface_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/ipv6_interface_address/state/ipv6_interface_address (inet:ipv6-address)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_ipv6_interface_address is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_ipv6_interface_address() directly.\n\n    YANG Description: Contains a 16-octet IPv6 address for the interface described by\nthe containing  Extended IS Reachability TLV. This sub-TLV can\noccur multiple times.", "id": "f22880:c1:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/ipv6_interface_address/state (container)\n\nYANG Description: State parameters of sub-TLV 12.", "id": "f22881:c1:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs/subTLVs/ipv6_interface_address/state (container)\n\nYANG Description: State parameters of sub-TLV 12.", "id": "f22881:c0:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/state (container)\n\nYANG Description: State parameters of MT neighbor.", "id": "f22882:c1:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of MT neighbor.", "id": "f22882:c1:m3"}
{"signature": "def _set_subTLVs(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=subTLVs.subTLVs,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subTLVs = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subTLVs, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/subTLVs (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_subTLVs is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_subTLVs() directly.\n\nYANG Description: This container describes IS Neighbor sub-TLVs.", "id": "f22882:c1:m6"}
{"signature": "def _get_undefined_subtlvs(self):", "body": "return self.__undefined_subtlvs<EOL>", "docstring": "Getter method for undefined_subtlvs, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/undefined_subtlvs (container)\n\nYANG Description: This container describes undefined ISIS TLVs.", "id": "f22882:c0:m8"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/state (container)\n\nYANG Description: State parameters of MT neighbor.", "id": "f22882:c0:m2"}
{"signature": "def _get_value(self):", "body": "return self.__value<EOL>", "docstring": "Getter method for value, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/undefined_subtlvs/undefined_subtlv/state/value (binary)\n\nYANG Description: TLV value.", "id": "f22883:c1:m8"}
{"signature": "def _get_type(self):", "body": "return self.__type<EOL>", "docstring": "Getter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/undefined_subtlvs/undefined_subtlv/state/type (uint8)\n\nYANG Description: TLV Type.", "id": "f22883:c0:m2"}
{"signature": "def _get_type(self):", "body": "return self.__type<EOL>", "docstring": "Getter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/undefined_subtlvs/undefined_subtlv/state/type (uint8)\n\nYANG Description: TLV Type.", "id": "f22883:c1:m2"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/undefined_subtlvs/undefined_subtlv/state/type (uint8)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_type is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_type() directly.\n\nYANG Description: TLV Type.", "id": "f22883:c1:m3"}
{"signature": "def _set_length(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__length = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for length, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/undefined_subtlvs/undefined_subtlv/state/length (uint8)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_length is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_length() directly.\n\nYANG Description: TLV length.", "id": "f22883:c0:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/undefined_subtlvs/undefined_subtlv/state (container)\n\nYANG Description: State parameters of the undefined sub-TLV.", "id": "f22884:c1:m5"}
{"signature": "def _set_type(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/undefined_subtlvs/undefined_subtlv/type (leafref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_type is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_type() directly.\n\nYANG Description: A reference to a subTLV", "id": "f22884:c0:m3"}
{"signature": "def _get_type(self):", "body": "return self.__type<EOL>", "docstring": "Getter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor/undefined_subtlvs/undefined_subtlv/type (leafref)\n\nYANG Description: A reference to a subTLV", "id": "f22884:c1:m2"}
{"signature": "def _set_neighbor(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>False,<EOL>neighbor.neighbor,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT:False>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__neighbor = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for neighbor, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors/neighbor (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_neighbor is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_neighbor() directly.\n\nYANG Description: List of multi-topology neighbors.", "id": "f22886:c1:m3"}
{"signature": "def _set_neighbors(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=neighbors.neighbors,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__neighbors = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for neighbors, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/neighbors (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_neighbors is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_neighbors() directly.\n\nYANG Description: This container describes IS neighbors.", "id": "f22887:c1:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_isis_neighbor_attribute/state (container)\n\nYANG Description: This container describes IS MT neighbor attribute state.", "id": "f22887:c0:m2"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/purge_oi/state/type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_type() directly.\n\n    YANG Description: The type of TLV being described. The type of TLV is\nexpressed as a canonical name.", "id": "f22888:c0:m3"}
{"signature": "def _set_source_system_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__source_system_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for source_system_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/purge_oi/state/source_system_id (oc-isis-types:system-id)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_source_system_id is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_source_system_id() directly.\n\nYANG Description: System ID of the Intermediate System that inserted this TLV.", "id": "f22888:c0:m9"}
{"signature": "def _set_received_system_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__received_system_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for received_system_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/purge_oi/state/received_system_id (oc-isis-types:system-id)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_received_system_id is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_received_system_id() directly.\n\n    YANG Description: System ID of the Intermediate System from which the purge was\nreceived.", "id": "f22888:c1:m12"}
{"signature": "def _get_system_id_count(self):", "body": "return self.__system_id_count<EOL>", "docstring": "Getter method for system_id_count, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/purge_oi/state/system_id_count (uint8)\n\nYANG Description: Number of system IDs carried in this TLV.", "id": "f22888:c1:m5"}
{"signature": "def _set_system_id_count(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__system_id_count = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for system_id_count, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/purge_oi/state/system_id_count (uint8)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_system_id_count is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_system_id_count() directly.\n\nYANG Description: Number of system IDs carried in this TLV.", "id": "f22888:c0:m6"}
{"signature": "def _set_system_id_count(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__system_id_count = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for system_id_count, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/purge_oi/state/system_id_count (uint8)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_system_id_count is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_system_id_count() directly.\n\nYANG Description: Number of system IDs carried in this TLV.", "id": "f22888:c1:m6"}
{"signature": "def _get_received_system_id(self):", "body": "return self.__received_system_id<EOL>", "docstring": "Getter method for received_system_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/purge_oi/state/received_system_id (oc-isis-types:system-id)\n\n    YANG Description: System ID of the Intermediate System from which the purge was\nreceived.", "id": "f22888:c0:m11"}
{"signature": "def _get_attributes(self):", "body": "return self.__attributes<EOL>", "docstring": "Getter method for attributes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/multi_topology/topologies/topology/state/attributes (enumeration)\n\nYANG Description: Attributes of the LSP for the associated topology.", "id": "f22890:c0:m5"}
{"signature": "def _get_MT_ID(self):", "body": "return self.__MT_ID<EOL>", "docstring": "Getter method for MT_ID, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/multi_topology/topologies/topology/state/MT_ID (uint16)\n\nYANG Description: Multi-topology ID.", "id": "f22890:c0:m2"}
{"signature": "def _get_topologies(self):", "body": "return self.__topologies<EOL>", "docstring": "Getter method for topologies, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/multi_topology/topologies (container)\n\nYANG Description: This container describes IS topologies.", "id": "f22894:c0:m5"}
{"signature": "def _set_topologies(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=topologies.topologies,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__topologies = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for topologies, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/multi_topology/topologies (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_topologies is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_topologies() directly.\n\nYANG Description: This container describes IS topologies.", "id": "f22894:c0:m6"}
{"signature": "def _get_topologies(self):", "body": "return self.__topologies<EOL>", "docstring": "Getter method for topologies, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/multi_topology/topologies (container)\n\nYANG Description: This container describes IS topologies.", "id": "f22894:c1:m5"}
{"signature": "def _get_flags(self):", "body": "return self.__flags<EOL>", "docstring": "Getter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/type_block/state/flags (enumeration)\n\nYANG Description: LSP Type-Block flags.", "id": "f22895:c1:m2"}
{"signature": "def _get_is_type(self):", "body": "return self.__is_type<EOL>", "docstring": "Getter method for is_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/type_block/state/is_type (oc-isis-types:level-number)\n\nYANG Description: Type of neighboring system.", "id": "f22895:c1:m5"}
{"signature": "def _set_flags(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__flags = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/type_block/state/flags (enumeration)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_flags is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_flags() directly.\n\nYANG Description: LSP Type-Block flags.", "id": "f22895:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/type_block/state (container)\n\nYANG Description: State parameters of LSP Type Block", "id": "f22896:c1:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/type_block/state (container)\n\nYANG Description: State parameters of LSP Type Block", "id": "f22896:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/type_block/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of LSP Type Block", "id": "f22896:c1:m3"}
{"signature": "def _set_ipv6_interface_addresses(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv6_interface_addresses = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv6_interface_addresses, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_interface_addresses/state/ipv6_interface_addresses (inet:ipv6-prefix)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_ipv6_interface_addresses is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_ipv6_interface_addresses() directly.\n\n    YANG Description: IPv6 interface addresses of the node.  MUST contain only the\nnon-link-local IPv6 addresses assigned to the IS.", "id": "f22897:c1:m6"}
{"signature": "def _get_ipv6_interface_addresses(self):", "body": "return self.__ipv6_interface_addresses<EOL>", "docstring": "Getter method for ipv6_interface_addresses, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_interface_addresses/state/ipv6_interface_addresses (inet:ipv6-prefix)\n\n    YANG Description: IPv6 interface addresses of the node.  MUST contain only the\nnon-link-local IPv6 addresses assigned to the IS.", "id": "f22897:c1:m5"}
{"signature": "def _set_ipv6_interface_addresses(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv6_interface_addresses = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv6_interface_addresses, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_interface_addresses/state/ipv6_interface_addresses (inet:ipv6-prefix)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_ipv6_interface_addresses is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_ipv6_interface_addresses() directly.\n\n    YANG Description: IPv6 interface addresses of the node.  MUST contain only the\nnon-link-local IPv6 addresses assigned to the IS.", "id": "f22897:c0:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_interface_addresses/state (container)\n\nYANG Description: State parameters of ISIS TLV 232.", "id": "f22898:c1:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_interface_addresses/state (container)\n\nYANG Description: State parameters of ISIS TLV 232.", "id": "f22898:c0:m2"}
{"signature": "def _set_ipv6_interface_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv6_interface_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv6_interface_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_srlg/state/ipv6_interface_address (inet:ipv6-address)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ipv6_interface_address is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ipv6_interface_address() directly.\n\nYANG Description: IPv6 interface address or Link Local Identifier.", "id": "f22899:c1:m15"}
{"signature": "def _get_flags(self):", "body": "return self.__flags<EOL>", "docstring": "Getter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_srlg/state/flags (enumeration)\n\nYANG Description: IPv6 SRLG flags.", "id": "f22899:c0:m11"}
{"signature": "def _set_ipv6_neighbor_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv6_neighbor_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv6_neighbor_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_srlg/state/ipv6_neighbor_address (inet:ipv6-address)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ipv6_neighbor_address is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ipv6_neighbor_address() directly.\n\nYANG Description: IPv6 neighbor address or Link Remote Identifier.", "id": "f22899:c1:m18"}
{"signature": "def _set_srlg_value(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__srlg_value = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for srlg_value, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_srlg/state/srlg_value (uint32)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_srlg_value is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_srlg_value() directly.\n\nYANG Description: SRLG values.", "id": "f22899:c0:m21"}
{"signature": "def _get_flags(self):", "body": "return self.__flags<EOL>", "docstring": "Getter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_srlg/state/flags (enumeration)\n\nYANG Description: IPv6 SRLG flags.", "id": "f22899:c1:m11"}
{"signature": "def _set_ipv6_neighbor_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv6_neighbor_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv6_neighbor_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_srlg/state/ipv6_neighbor_address (inet:ipv6-address)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ipv6_neighbor_address is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ipv6_neighbor_address() directly.\n\nYANG Description: IPv6 neighbor address or Link Remote Identifier.", "id": "f22899:c0:m18"}
{"signature": "def _get_system_id(self):", "body": "return self.__system_id<EOL>", "docstring": "Getter method for system_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_srlg/state/system_id (oc-isis-types:system-id)\n\nYANG Description: Neighbor system ID.", "id": "f22899:c1:m5"}
{"signature": "def _get_ipv6_neighbor_address(self):", "body": "return self.__ipv6_neighbor_address<EOL>", "docstring": "Getter method for ipv6_neighbor_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_srlg/state/ipv6_neighbor_address (inet:ipv6-address)\n\nYANG Description: IPv6 neighbor address or Link Remote Identifier.", "id": "f22899:c1:m17"}
{"signature": "def _get_ipv6_interface_address(self):", "body": "return self.__ipv6_interface_address<EOL>", "docstring": "Getter method for ipv6_interface_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_srlg/state/ipv6_interface_address (inet:ipv6-address)\n\nYANG Description: IPv6 interface address or Link Local Identifier.", "id": "f22899:c0:m14"}
{"signature": "def _get_psn_number(self):", "body": "return self.__psn_number<EOL>", "docstring": "Getter method for psn_number, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_srlg/state/psn_number (uint8)\n\nYANG Description: Pseudonode number if the neighbor is on a LAN interface.", "id": "f22899:c0:m8"}
{"signature": "def _get_ipv6_neighbor_address(self):", "body": "return self.__ipv6_neighbor_address<EOL>", "docstring": "Getter method for ipv6_neighbor_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_srlg/state/ipv6_neighbor_address (inet:ipv6-address)\n\nYANG Description: IPv6 neighbor address or Link Remote Identifier.", "id": "f22899:c0:m17"}
{"signature": "def _set_system_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__system_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for system_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_srlg/state/system_id (oc-isis-types:system-id)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_system_id is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_system_id() directly.\n\nYANG Description: Neighbor system ID.", "id": "f22899:c1:m6"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv6_srlg/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of TLV 139.", "id": "f22900:c0:m3"}
{"signature": "def _set_ipv4_interface_addresses(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv4_interface_addresses = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv4_interface_addresses, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_interface_addresses/state/ipv4_interface_addresses (inet:ipv4-prefix)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_ipv4_interface_addresses is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_ipv4_interface_addresses() directly.\n\n    YANG Description: IPv4 address(es) of the interface corresponding to the SNPA\nover which this PDU is to be transmitted.", "id": "f22901:c1:m6"}
{"signature": "def _get_ipv4_interface_addresses(self):", "body": "return self.__ipv4_interface_addresses<EOL>", "docstring": "Getter method for ipv4_interface_addresses, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_interface_addresses/state/ipv4_interface_addresses (inet:ipv4-prefix)\n\n    YANG Description: IPv4 address(es) of the interface corresponding to the SNPA\nover which this PDU is to be transmitted.", "id": "f22901:c1:m5"}
{"signature": "def _get_type(self):", "body": "return self.__type<EOL>", "docstring": "Getter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_interface_addresses/state/type (identityref)\n\n    YANG Description: The type of TLV being described. The type of TLV is\nexpressed as a canonical name.", "id": "f22901:c1:m2"}
{"signature": "def _set_ipv4_interface_addresses(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv4_interface_addresses = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv4_interface_addresses, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/ipv4_interface_addresses/state/ipv4_interface_addresses (inet:ipv4-prefix)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_ipv4_interface_addresses is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_ipv4_interface_addresses() directly.\n\n    YANG Description: IPv4 address(es) of the interface corresponding to the SNPA\nover which this PDU is to be transmitted.", "id": "f22901:c0:m6"}
{"signature": "def _get_type(self):", "body": "return self.__type<EOL>", "docstring": "Getter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/state/type (identityref)\n\n    YANG Description: The type of TLV being described. The type of TLV is\nexpressed as a canonical name.", "id": "f22903:c1:m2"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/state/type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_type() directly.\n\n    YANG Description: The type of TLV being described. The type of TLV is\nexpressed as a canonical name.", "id": "f22903:c1:m3"}
{"signature": "def _set_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/state/metric (oc-isis-types:wide-metric)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_metric is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_metric() directly.\n\nYANG Description: ISIS metric value.", "id": "f22904:c1:m15"}
{"signature": "def _set_x_bit(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__x_bit = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for x_bit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/state/x_bit (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_x_bit is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_x_bit() directly.\n\n    YANG Description: The external bit. Set when the prefix was distributed into IS-IS from\nanother routing protocol.", "id": "f22904:c0:m6"}
{"signature": "def _get_metric(self):", "body": "return self.__metric<EOL>", "docstring": "Getter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/state/metric (oc-isis-types:wide-metric)\n\nYANG Description: ISIS metric value.", "id": "f22904:c1:m14"}
{"signature": "def _get_up_down(self):", "body": "return self.__up_down<EOL>", "docstring": "Getter method for up_down, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/state/up_down (boolean)\n\n    YANG Description: The up/down bit. Set if a prefix is advertised from a higher level to\na lower level (e.g., level 2 to level 1), indicating that the prefix\nhas traveled down the hierarchy. Prefixes that have the up/down bit\nset may only be advertised down the hierarchy, i.e., to lower levels.\nWhen a prefix is first injected into IS-IS, the bit is UNSET.", "id": "f22904:c0:m2"}
{"signature": "def _get_up_down(self):", "body": "return self.__up_down<EOL>", "docstring": "Getter method for up_down, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/state/up_down (boolean)\n\n    YANG Description: The up/down bit. Set if a prefix is advertised from a higher level to\na lower level (e.g., level 2 to level 1), indicating that the prefix\nhas traveled down the hierarchy. Prefixes that have the up/down bit\nset may only be advertised down the hierarchy, i.e., to lower levels.\nWhen a prefix is first injected into IS-IS, the bit is UNSET.", "id": "f22904:c1:m2"}
{"signature": "def _get_ipv6_prefix(self):", "body": "return self.__ipv6_prefix<EOL>", "docstring": "Getter method for ipv6_prefix, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/state/ipv6_prefix (inet:ipv6-prefix)\n\nYANG Description: IPv6 prefix contained within extended reachability TLVs.", "id": "f22904:c1:m11"}
{"signature": "def _get_s_bit(self):", "body": "return self.__s_bit<EOL>", "docstring": "Getter method for s_bit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/state/s_bit (boolean)\n\n    YANG Description: The sub-tlv present bit. If UNSET, the octets of Sub-TLVs are not\npresent. Otherwise, the bit is set and the octet following the prefix\nwill contain the length of the Sub-TLV portion of the structure.", "id": "f22904:c1:m8"}
{"signature": "def _get_ipv6_prefix(self):", "body": "return self.__ipv6_prefix<EOL>", "docstring": "Getter method for ipv6_prefix, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/state/ipv6_prefix (inet:ipv6-prefix)\n\nYANG Description: IPv6 prefix contained within extended reachability TLVs.", "id": "f22904:c0:m11"}
{"signature": "def _set_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/state/metric (oc-isis-types:wide-metric)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_metric is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_metric() directly.\n\nYANG Description: ISIS metric value.", "id": "f22904:c0:m15"}
{"signature": "def _get_subTLVs(self):", "body": "return self.__subTLVs<EOL>", "docstring": "Getter method for subTLVs, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/subTLVs/subTLVs (list)\n\nYANG Description: List of subTLV types in the LSDB for the specified TLV.", "id": "f22905:c0:m2"}
{"signature": "def _get_ipv6_source_router_id(self):", "body": "return self.__ipv6_source_router_id<EOL>", "docstring": "Getter method for ipv6_source_router_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/subTLVs/subTLVs/ipv6_source_router_id/state/ipv6_source_router_id (inet:ipv6-address)\n\n    YANG Description: IPv6 Source router ID address. In cases where the advertisement\nis an identifier for the advertising router (e.g., with the\nN-flag set in the Prefix Attribute Flags sub-TLV), it may be\nuseful for other routers to know the source of the\nadvertisement. When reachability advertisement is leaked from\none level to another, Router ID advertised is always the Router\nID of the IS-IS instance that originated the advertisement.\nThis would be true even if the prefix had been learned from\nanother protocol.", "id": "f22906:c1:m5"}
{"signature": "def _get_ipv6_source_router_id(self):", "body": "return self.__ipv6_source_router_id<EOL>", "docstring": "Getter method for ipv6_source_router_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/subTLVs/subTLVs/ipv6_source_router_id/state/ipv6_source_router_id (inet:ipv6-address)\n\n    YANG Description: IPv6 Source router ID address. In cases where the advertisement\nis an identifier for the advertising router (e.g., with the\nN-flag set in the Prefix Attribute Flags sub-TLV), it may be\nuseful for other routers to know the source of the\nadvertisement. When reachability advertisement is leaked from\none level to another, Router ID advertised is always the Router\nID of the IS-IS instance that originated the advertisement.\nThis would be true even if the prefix had been learned from\nanother protocol.", "id": "f22906:c0:m5"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/subTLVs/subTLVs/ipv6_source_router_id/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22906:c0:m3"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/subTLVs/subTLVs/ipv6_source_router_id/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22906:c1:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/subTLVs/subTLVs/ipv6_source_router_id/state (container)\n\nYANG Description: State parameters of sub-TLV 12.", "id": "f22907:c1:m2"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/subTLVs/subTLVs/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22908:c1:m2"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/subTLVs/subTLVs/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22908:c0:m2"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/subTLVs/subTLVs/flags/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22909:c0:m3"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/subTLVs/subTLVs/flags/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22909:c0:m2"}
{"signature": "def _get_flags(self):", "body": "return self.__flags<EOL>", "docstring": "Getter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/subTLVs/subTLVs/flags/state/flags (enumeration)\n\nYANG Description: Additional prefix reachability flags.", "id": "f22909:c1:m5"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/subTLVs/subTLVs/flags/state (container)\n\nYANG Description: State parameters of sub-TLV 4.", "id": "f22910:c0:m2"}
{"signature": "def _get_flags(self):", "body": "return self.__flags<EOL>", "docstring": "Getter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/subTLVs/subTLVs/flags (container)\n\nYANG Description: This container defines sub-TLV 4.", "id": "f22911:c0:m14"}
{"signature": "def _get_tag64(self):", "body": "return self.__tag64<EOL>", "docstring": "Getter method for tag64, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/subTLVs/subTLVs/tag64 (container)\n\nYANG Description: This container defines sub-TLV 2.", "id": "f22911:c1:m11"}
{"signature": "def _get_tag64(self):", "body": "return self.__tag64<EOL>", "docstring": "Getter method for tag64, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/subTLVs/subTLVs/tag64 (container)\n\nYANG Description: This container defines sub-TLV 2.", "id": "f22911:c0:m11"}
{"signature": "def _set_tag(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=tag.tag,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__tag = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for tag, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/subTLVs/subTLVs/tag (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_tag is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_tag() directly.\n\nYANG Description: This container defines sub-TLV 1.", "id": "f22911:c1:m9"}
{"signature": "def _set_prefix_sid(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=prefix_sid.prefix_sid,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prefix_sid = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prefix_sid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/subTLVs/subTLVs/prefix_sid (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_prefix_sid is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_prefix_sid() directly.\n\nYANG Description: This container defines segment routing extensions for prefixes.", "id": "f22911:c0:m24"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/subTLVs/subTLVs/state (container)\n\nYANG Description: State parameters for a prefix.", "id": "f22911:c0:m5"}
{"signature": "def _set_prefix_sid(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=prefix_sid.prefix_sid,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prefix_sid = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prefix_sid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/subTLVs/subTLVs/prefix_sid (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_prefix_sid is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_prefix_sid() directly.\n\nYANG Description: This container defines segment routing extensions for prefixes.", "id": "f22911:c1:m24"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/subTLVs/subTLVs/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters for a prefix.", "id": "f22911:c0:m6"}
{"signature": "def _get_prefix_sid(self):", "body": "return self.__prefix_sid<EOL>", "docstring": "Getter method for prefix_sid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/subTLVs/subTLVs/prefix_sid (container)\n\nYANG Description: This container defines segment routing extensions for prefixes.", "id": "f22911:c0:m23"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/subTLVs/subTLVs/tag64/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22912:c1:m2"}
{"signature": "def _set_tag64(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__tag64 = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for tag64, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/subTLVs/subTLVs/tag64/state/tag64 (uint64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_tag64 is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_tag64() directly.\n\n    YANG Description: List of 64-bit tags associated with the prefix. Example uses of\nthese tags include carrying BGP standard (or extended) communities\nand controlling redistribution between levels and areas, different\nrouting protocols, or multiple instances of IS-IS running on the\nsame router.", "id": "f22912:c1:m6"}
{"signature": "def _set_tag64(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__tag64 = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for tag64, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/subTLVs/subTLVs/tag64/state/tag64 (uint64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_tag64 is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_tag64() directly.\n\n    YANG Description: List of 64-bit tags associated with the prefix. Example uses of\nthese tags include carrying BGP standard (or extended) communities\nand controlling redistribution between levels and areas, different\nrouting protocols, or multiple instances of IS-IS running on the\nsame router.", "id": "f22912:c0:m6"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/subTLVs/subTLVs/tag64/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of sub-TLV 2.", "id": "f22913:c1:m3"}
{"signature": "def _set_ipv4_source_router_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv4_source_router_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv4_source_router_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/subTLVs/subTLVs/ipv4_source_router_id/state/ipv4_source_router_id (inet:ipv4-address-no-zone)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_ipv4_source_router_id is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_ipv4_source_router_id() directly.\n\n    YANG Description: IPv4 Source router ID address. In cases where the advertisement\nis an identifier for the advertising router (e.g., with the\nN-flag set in the Prefix Attribute Flags sub-TLV), it may be\nuseful for other routers to know the source of the\nadvertisement. When reachability advertisement is leaked from\none level to another, Router ID advertised is always the Router\nID of the IS-IS instance that originated the advertisement.\nThis would be true even if the prefix had been learned from\nanother protocol.", "id": "f22914:c1:m6"}
{"signature": "def _get_ipv4_source_router_id(self):", "body": "return self.__ipv4_source_router_id<EOL>", "docstring": "Getter method for ipv4_source_router_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/subTLVs/subTLVs/ipv4_source_router_id/state/ipv4_source_router_id (inet:ipv4-address-no-zone)\n\n    YANG Description: IPv4 Source router ID address. In cases where the advertisement\nis an identifier for the advertising router (e.g., with the\nN-flag set in the Prefix Attribute Flags sub-TLV), it may be\nuseful for other routers to know the source of the\nadvertisement. When reachability advertisement is leaked from\none level to another, Router ID advertised is always the Router\nID of the IS-IS instance that originated the advertisement.\nThis would be true even if the prefix had been learned from\nanother protocol.", "id": "f22914:c0:m5"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/subTLVs/subTLVs/ipv4_source_router_id/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22914:c1:m3"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/subTLVs/subTLVs/ipv4_source_router_id/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22914:c0:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/subTLVs/subTLVs/ipv4_source_router_id/state (container)\n\nYANG Description: State parameters of sub-TLV 11.", "id": "f22915:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/subTLVs/subTLVs/ipv4_source_router_id/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of sub-TLV 11.", "id": "f22915:c1:m3"}
{"signature": "def _set_flags(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__flags = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/subTLVs/subTLVs/prefix_sid/sid/state/flags (enumeration)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_flags is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_flags() directly.\n\nYANG Description: Flags associated with Prefix Segment-ID.", "id": "f22917:c0:m9"}
{"signature": "def _get_value(self):", "body": "return self.__value<EOL>", "docstring": "Getter method for value, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/subTLVs/subTLVs/prefix_sid/sid/state/value (uint32)\n\nYANG Description: IGP Prefix-SID value.", "id": "f22917:c1:m5"}
{"signature": "def _set_flags(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>\"<STR_LIT>\": {},<EOL>},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__flags = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/subTLVs/subTLVs/prefix_sid/sid/state/flags (enumeration)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_flags is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_flags() directly.\n\nYANG Description: Flags associated with Prefix Segment-ID.", "id": "f22917:c1:m9"}
{"signature": "def _get_value(self):", "body": "return self.__value<EOL>", "docstring": "Getter method for value, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/subTLVs/subTLVs/prefix_sid/sid/state/value (uint32)\n\nYANG Description: IGP Prefix-SID value.", "id": "f22917:c0:m5"}
{"signature": "def _set_algorithm(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__algorithm = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for algorithm, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/subTLVs/subTLVs/prefix_sid/sid/state/algorithm (uint8)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_algorithm is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_algorithm() directly.\n\nYANG Description: Prefix-SID algorithm to be used for path computation.", "id": "f22917:c0:m12"}
{"signature": "def _get_flags(self):", "body": "return self.__flags<EOL>", "docstring": "Getter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/subTLVs/subTLVs/prefix_sid/sid/state/flags (enumeration)\n\nYANG Description: Flags associated with Prefix Segment-ID.", "id": "f22917:c1:m8"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/subTLVs/subTLVs/prefix_sid/sid/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters for Prefix-SID.", "id": "f22918:c0:m3"}
{"signature": "def _set_tag32(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__tag32 = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for tag32, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/subTLVs/subTLVs/tag/state/tag32 (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_tag32 is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_tag32() directly.\n\n    YANG Description: List of 32-bit tags associated with the prefix. Example uses of\nthese tags include carrying BGP standard (or extended) communities\nand controlling redistribution between levels and areas, different\nrouting protocols, or multiple instances of IS-IS running on the\nsame router.", "id": "f22919:c0:m6"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/subTLVs/subTLVs/tag/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22919:c0:m2"}
{"signature": "def _get_tag32(self):", "body": "return self.__tag32<EOL>", "docstring": "Getter method for tag32, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/subTLVs/subTLVs/tag/state/tag32 (uint32)\n\n    YANG Description: List of 32-bit tags associated with the prefix. Example uses of\nthese tags include carrying BGP standard (or extended) communities\nand controlling redistribution between levels and areas, different\nrouting protocols, or multiple instances of IS-IS running on the\nsame router.", "id": "f22919:c0:m5"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/subTLVs/subTLVs/tag/state (container)\n\nYANG Description: State parameters of sub-TLV 1.", "id": "f22920:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/subTLVs/subTLVs/tag/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of sub-TLV 1.", "id": "f22920:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/subTLVs/subTLVs/tag/state (container)\n\nYANG Description: State parameters of sub-TLV 1.", "id": "f22920:c1:m2"}
{"signature": "def _set_mt_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:16>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__mt_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for mt_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/mt/state/mt_id (uint16)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_mt_id is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_mt_id() directly.\n\nYANG Description: Multi-topology ID.", "id": "f22921:c0:m3"}
{"signature": "def _set_mt(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=mt.mt,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__mt = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for mt, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/mt (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_mt is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_mt() directly.\n\nYANG Description: Multi-topology parameters", "id": "f22923:c0:m3"}
{"signature": "def _get_undefined_subtlvs(self):", "body": "return self.__undefined_subtlvs<EOL>", "docstring": "Getter method for undefined_subtlvs, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/undefined_subtlvs (container)\n\nYANG Description: This container describes undefined ISIS TLVs.", "id": "f22923:c1:m11"}
{"signature": "def _get_mt(self):", "body": "return self.__mt<EOL>", "docstring": "Getter method for mt, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/mt (container)\n\nYANG Description: Multi-topology parameters", "id": "f22923:c0:m2"}
{"signature": "def _get_value(self):", "body": "return self.__value<EOL>", "docstring": "Getter method for value, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/undefined_subtlvs/undefined_subtlv/state/value (binary)\n\nYANG Description: TLV value.", "id": "f22924:c1:m8"}
{"signature": "def _get_value(self):", "body": "return self.__value<EOL>", "docstring": "Getter method for value, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/undefined_subtlvs/undefined_subtlv/state/value (binary)\n\nYANG Description: TLV value.", "id": "f22924:c0:m8"}
{"signature": "def _get_length(self):", "body": "return self.__length<EOL>", "docstring": "Getter method for length, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/undefined_subtlvs/undefined_subtlv/state/length (uint8)\n\nYANG Description: TLV length.", "id": "f22924:c0:m5"}
{"signature": "def _get_length(self):", "body": "return self.__length<EOL>", "docstring": "Getter method for length, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/undefined_subtlvs/undefined_subtlv/state/length (uint8)\n\nYANG Description: TLV length.", "id": "f22924:c1:m5"}
{"signature": "def _set_length(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__length = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for length, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/undefined_subtlvs/undefined_subtlv/state/length (uint8)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_length is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_length() directly.\n\nYANG Description: TLV length.", "id": "f22924:c1:m6"}
{"signature": "def _get_type(self):", "body": "return self.__type<EOL>", "docstring": "Getter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/undefined_subtlvs/undefined_subtlv/type (leafref)\n\nYANG Description: A reference to a subTLV", "id": "f22925:c0:m2"}
{"signature": "def _get_undefined_subtlv(self):", "body": "return self.__undefined_subtlv<EOL>", "docstring": "Getter method for undefined_subtlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/undefined_subtlvs/undefined_subtlv (list)\n\n    YANG Description: Sub-TLVs that are not defined in the model or not recognised by\nsystem.", "id": "f22926:c1:m2"}
{"signature": "def _set_undefined_subtlv(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT:type>\",<EOL>undefined_subtlv.undefined_subtlv,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT:type>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__undefined_subtlv = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for undefined_subtlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/undefined_subtlvs/undefined_subtlv (list)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_undefined_subtlv is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_undefined_subtlv() directly.\n\n    YANG Description: Sub-TLVs that are not defined in the model or not recognised by\nsystem.", "id": "f22926:c0:m3"}
{"signature": "def _get_undefined_subtlv(self):", "body": "return self.__undefined_subtlv<EOL>", "docstring": "Getter method for undefined_subtlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix/undefined_subtlvs/undefined_subtlv (list)\n\n    YANG Description: Sub-TLVs that are not defined in the model or not recognised by\nsystem.", "id": "f22926:c0:m2"}
{"signature": "def _set_prefix(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>False,<EOL>prefix.prefix,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT:False>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prefix = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prefix, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/prefixes/prefix (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_prefix is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_prefix() directly.\n\nYANG Description: List of IPv6 prefixes contained within MT reachability TLV.", "id": "f22927:c0:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/mt_ipv6_reachability/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: This container describes IS reachability state.", "id": "f22928:c0:m3"}
{"signature": "def _get_type(self):", "body": "return self.__type<EOL>", "docstring": "Getter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/state/type (identityref)\n\n    YANG Description: The type of TLV being described. The type of TLV is\nexpressed as a canonical name.", "id": "f22929:c1:m2"}
{"signature": "def _get_s_bit(self):", "body": "return self.__s_bit<EOL>", "docstring": "Getter method for s_bit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/state/s_bit (boolean)\n\n    YANG Description: The Sub-TLV present bit. If UNSET, the octets of Sub-TLVs are not\npresent. Otherwise, the bit is set and the octet following the prefix\nwill contain the length of the Sub-TLV portion of the structure.", "id": "f22930:c0:m5"}
{"signature": "def _set_ipv4_prefix(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv4_prefix = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv4_prefix, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/state/ipv4_prefix (inet:ipv4-prefix)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ipv4_prefix is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ipv4_prefix() directly.\n\nYANG Description: IPv4 prefix contained within extended reachability TLVs.", "id": "f22930:c0:m9"}
{"signature": "def _get_metric(self):", "body": "return self.__metric<EOL>", "docstring": "Getter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/state/metric (oc-isis-types:wide-metric)\n\nYANG Description: ISIS metric value.", "id": "f22930:c0:m11"}
{"signature": "def _get_metric(self):", "body": "return self.__metric<EOL>", "docstring": "Getter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/state/metric (oc-isis-types:wide-metric)\n\nYANG Description: ISIS metric value.", "id": "f22930:c1:m11"}
{"signature": "def _set_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/state/metric (oc-isis-types:wide-metric)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_metric is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_metric() directly.\n\nYANG Description: ISIS metric value.", "id": "f22930:c1:m12"}
{"signature": "def _get_subTLVs(self):", "body": "return self.__subTLVs<EOL>", "docstring": "Getter method for subTLVs, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs (list)\n\nYANG Description: List of subTLV types in the LSDB for the specified TLV.", "id": "f22931:c0:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/ipv6_source_router_id/state (container)\n\nYANG Description: State parameters of sub-TLV 12.", "id": "f22933:c1:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/ipv6_source_router_id/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of sub-TLV 12.", "id": "f22933:c0:m3"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/state/subtlv_type (identityref)\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22934:c1:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/flags/state (container)\n\nYANG Description: State parameters of sub-TLV 4.", "id": "f22936:c0:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/state (container)\n\nYANG Description: State parameters for a prefix.", "id": "f22937:c0:m5"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/subtlv_type (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: A reference for the TLV type being described within\nthe LSDB", "id": "f22937:c0:m3"}
{"signature": "def _get_flags(self):", "body": "return self.__flags<EOL>", "docstring": "Getter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/flags (container)\n\nYANG Description: This container defines sub-TLV 4.", "id": "f22937:c1:m14"}
{"signature": "def _set_tag(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=tag.tag,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__tag = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for tag, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/tag (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_tag is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_tag() directly.\n\nYANG Description: This container defines sub-TLV 1.", "id": "f22937:c1:m9"}
{"signature": "def _set_ipv6_source_router_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=ipv6_source_router_id.ipv6_source_router_id,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv6_source_router_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv6_source_router_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/ipv6_source_router_id (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ipv6_source_router_id is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ipv6_source_router_id() directly.\n\nYANG Description: This container defines sub-TLV 12.", "id": "f22937:c1:m21"}
{"signature": "def _get_flags(self):", "body": "return self.__flags<EOL>", "docstring": "Getter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/flags (container)\n\nYANG Description: This container defines sub-TLV 4.", "id": "f22937:c0:m14"}
{"signature": "def _get_subtlv_type(self):", "body": "return self.__subtlv_type<EOL>", "docstring": "Getter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/subtlv_type (leafref)\n\n    YANG Description: A reference for the TLV type being described within\nthe LSDB", "id": "f22937:c0:m2"}
{"signature": "def _get_ipv6_source_router_id(self):", "body": "return self.__ipv6_source_router_id<EOL>", "docstring": "Getter method for ipv6_source_router_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/ipv6_source_router_id (container)\n\nYANG Description: This container defines sub-TLV 12.", "id": "f22937:c0:m20"}
{"signature": "def _get_tag64(self):", "body": "return self.__tag64<EOL>", "docstring": "Getter method for tag64, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/tag64 (container)\n\nYANG Description: This container defines sub-TLV 2.", "id": "f22937:c1:m11"}
{"signature": "def _set_flags(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=flags.flags,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__flags = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/flags (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_flags is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_flags() directly.\n\nYANG Description: This container defines sub-TLV 4.", "id": "f22937:c0:m15"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/tag64/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22938:c0:m3"}
{"signature": "def _set_tag64(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__tag64 = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for tag64, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/tag64/state/tag64 (uint64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_tag64 is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_tag64() directly.\n\n    YANG Description: List of 64-bit tags associated with the prefix. Example uses of\nthese tags include carrying BGP standard (or extended) communities\nand controlling redistribution between levels and areas, different\nrouting protocols, or multiple instances of IS-IS running on the\nsame router.", "id": "f22938:c1:m6"}
{"signature": "def _get_tag64(self):", "body": "return self.__tag64<EOL>", "docstring": "Getter method for tag64, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/tag64/state/tag64 (uint64)\n\n    YANG Description: List of 64-bit tags associated with the prefix. Example uses of\nthese tags include carrying BGP standard (or extended) communities\nand controlling redistribution between levels and areas, different\nrouting protocols, or multiple instances of IS-IS running on the\nsame router.", "id": "f22938:c0:m5"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/tag64/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22938:c1:m3"}
{"signature": "def _get_ipv4_source_router_id(self):", "body": "return self.__ipv4_source_router_id<EOL>", "docstring": "Getter method for ipv4_source_router_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/ipv4_source_router_id/state/ipv4_source_router_id (inet:ipv4-address-no-zone)\n\n    YANG Description: IPv4 Source router ID address. In cases where the advertisement\nis an identifier for the advertising router (e.g., with the\nN-flag set in the Prefix Attribute Flags sub-TLV), it may be\nuseful for other routers to know the source of the\nadvertisement. When reachability advertisement is leaked from\none level to another, Router ID advertised is always the Router\nID of the IS-IS instance that originated the advertisement.\nThis would be true even if the prefix had been learned from\nanother protocol.", "id": "f22940:c1:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/ipv4_source_router_id/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of sub-TLV 11.", "id": "f22941:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/ipv4_source_router_id/state (container)\n\nYANG Description: State parameters of sub-TLV 11.", "id": "f22941:c1:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/ipv4_source_router_id/state (container)\n\nYANG Description: State parameters of sub-TLV 11.", "id": "f22941:c0:m2"}
{"signature": "def _set_sid(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>False,<EOL>sid.sid,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT:False>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__sid = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for sid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/prefix_sid/sid (list)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_sid is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_sid() directly.\n\n    YANG Description: Prefix Segment-ID list. IGP-Prefix Segment is an IGP segment attached\nto an IGP prefix. An IGP-Prefix Segment is global (unless explicitly\nadvertised otherwise) within the SR/IGP domain.", "id": "f22942:c1:m3"}
{"signature": "def _set_sid(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>False,<EOL>sid.sid,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT:False>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__sid = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for sid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/prefix_sid/sid (list)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_sid is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_sid() directly.\n\n    YANG Description: Prefix Segment-ID list. IGP-Prefix Segment is an IGP segment attached\nto an IGP prefix. An IGP-Prefix Segment is global (unless explicitly\nadvertised otherwise) within the SR/IGP domain.", "id": "f22942:c0:m3"}
{"signature": "def _set_algorithm(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__algorithm = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for algorithm, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/prefix_sid/sid/state/algorithm (uint8)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_algorithm is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_algorithm() directly.\n\nYANG Description: Prefix-SID algorithm to be used for path computation.", "id": "f22943:c0:m12"}
{"signature": "def _set_subtlv_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subtlv_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subtlv_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/prefix_sid/sid/state/subtlv_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subtlv_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subtlv_type() directly.\n\n    YANG Description: The type of subTLV being described. The type of subTLV is\nexpressed as a canonical name.", "id": "f22943:c1:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/prefix_sid/sid/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters for Prefix-SID.", "id": "f22944:c0:m3"}
{"signature": "def _get_tag32(self):", "body": "return self.__tag32<EOL>", "docstring": "Getter method for tag32, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/tag/state/tag32 (uint32)\n\n    YANG Description: List of 32-bit tags associated with the prefix. Example uses of\nthese tags include carrying BGP standard (or extended) communities\nand controlling redistribution between levels and areas, different\nrouting protocols, or multiple instances of IS-IS running on the\nsame router.", "id": "f22945:c0:m5"}
{"signature": "def _set_tag32(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__tag32 = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for tag32, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/tag/state/tag32 (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_tag32 is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_tag32() directly.\n\n    YANG Description: List of 32-bit tags associated with the prefix. Example uses of\nthese tags include carrying BGP standard (or extended) communities\nand controlling redistribution between levels and areas, different\nrouting protocols, or multiple instances of IS-IS running on the\nsame router.", "id": "f22945:c1:m6"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/subTLVs/subTLVs/tag/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of sub-TLV 1.", "id": "f22946:c1:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/state (container)\n\nYANG Description: State parameters of an IPv4 extended prefix.", "id": "f22947:c0:m2"}
{"signature": "def _get_undefined_subtlvs(self):", "body": "return self.__undefined_subtlvs<EOL>", "docstring": "Getter method for undefined_subtlvs, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/undefined_subtlvs (container)\n\nYANG Description: This container describes undefined ISIS TLVs.", "id": "f22947:c1:m8"}
{"signature": "def _get_subTLVs(self):", "body": "return self.__subTLVs<EOL>", "docstring": "Getter method for subTLVs, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/subTLVs (container)\n\nYANG Description: This container describes IS prefix sub-TLVs.", "id": "f22947:c0:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of an IPv4 extended prefix.", "id": "f22947:c1:m3"}
{"signature": "def _get_length(self):", "body": "return self.__length<EOL>", "docstring": "Getter method for length, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/undefined_subtlvs/undefined_subtlv/state/length (uint8)\n\nYANG Description: TLV length.", "id": "f22948:c0:m5"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/undefined_subtlvs/undefined_subtlv/state/type (uint8)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_type is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_type() directly.\n\nYANG Description: TLV Type.", "id": "f22948:c1:m3"}
{"signature": "def _set_length(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__length = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for length, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/undefined_subtlvs/undefined_subtlv/state/length (uint8)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_length is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_length() directly.\n\nYANG Description: TLV length.", "id": "f22948:c0:m6"}
{"signature": "def _get_type(self):", "body": "return self.__type<EOL>", "docstring": "Getter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/undefined_subtlvs/undefined_subtlv/type (leafref)\n\nYANG Description: A reference to a subTLV", "id": "f22949:c0:m2"}
{"signature": "def _set_type(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/undefined_subtlvs/undefined_subtlv/type (leafref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_type is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_type() directly.\n\nYANG Description: A reference to a subTLV", "id": "f22949:c1:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/undefined_subtlvs/undefined_subtlv/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of the undefined sub-TLV.", "id": "f22949:c1:m6"}
{"signature": "def _set_undefined_subtlv(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT:type>\",<EOL>undefined_subtlv.undefined_subtlv,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT:type>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__undefined_subtlv = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for undefined_subtlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix/undefined_subtlvs/undefined_subtlv (list)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_undefined_subtlv is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_undefined_subtlv() directly.\n\n    YANG Description: Sub-TLVs that are not defined in the model or not recognised by\nsystem.", "id": "f22950:c1:m3"}
{"signature": "def _get_prefix(self):", "body": "return self.__prefix<EOL>", "docstring": "Getter method for prefix, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes/prefix (list)\n\n    YANG Description: This list describes IPv4 extended prefixes and\nattributes.", "id": "f22951:c0:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/state (container)\n\nYANG Description: This container describes extended IPv4 IS reachability state", "id": "f22952:c1:m2"}
{"signature": "def _set_prefixes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=prefixes.prefixes,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prefixes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/prefixes (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_prefixes is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_prefixes() directly.\n\nYANG Description: This container describes IS prefixes.", "id": "f22952:c1:m6"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: This container describes extended IPv4 IS reachability state", "id": "f22952:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/extended_ipv4_reachability/state (container)\n\nYANG Description: This container describes extended IPv4 IS reachability state", "id": "f22952:c0:m2"}
{"signature": "def _get_authentication_key(self):", "body": "return self.__authentication_key<EOL>", "docstring": "Getter method for authentication_key, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/authentication/state/authentication_key (string)\n\nYANG Description: Authentication key to be used.", "id": "f22953:c0:m8"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/authentication/state/type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_type() directly.\n\n    YANG Description: The type of TLV being described. The type of TLV is\nexpressed as a canonical name.", "id": "f22953:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/authentication/state (container)\n\nYANG Description: State parameters of TLV 10.", "id": "f22954:c1:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/authentication/state (container)\n\nYANG Description: State parameters of TLV 10.", "id": "f22954:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/authentication/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of TLV 10.", "id": "f22954:c1:m3"}
{"signature": "def _get_type(self):", "body": "return self.__type<EOL>", "docstring": "Getter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/is_reachability/state/type (identityref)\n\n    YANG Description: The type of TLV being described. The type of TLV is\nexpressed as a canonical name.", "id": "f22955:c1:m2"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/is_reachability/state/type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_type() directly.\n\n    YANG Description: The type of TLV being described. The type of TLV is\nexpressed as a canonical name.", "id": "f22955:c1:m3"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/is_reachability/state/type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_type() directly.\n\n    YANG Description: The type of TLV being described. The type of TLV is\nexpressed as a canonical name.", "id": "f22955:c0:m3"}
{"signature": "def _set_neighbors(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>False,<EOL>neighbors_.neighbors,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT:False>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__neighbors = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for neighbors, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/is_reachability/neighbors/neighbors (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_neighbors is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_neighbors() directly.\n\nYANG Description: IS reachability neighbor attributes.", "id": "f22956:c1:m3"}
{"signature": "def _set_system_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__system_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for system_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/is_reachability/neighbors/neighbors/state/system_id (oc-isis-types:system-id)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_system_id is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_system_id() directly.\n\nYANG Description: System-ID of IS neighbor.", "id": "f22957:c0:m3"}
{"signature": "def _get_default_metric(self):", "body": "return self.__default_metric<EOL>", "docstring": "Getter method for default_metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/is_reachability/neighbors/neighbors/default_metric/state/default_metric (oc-isis-types:narrow-metric)\n\n    YANG Description: ISIS default metric value. This is a metric understood by every\nIntermediate system in the domain. Each circuit shall have a\npositive  integral value assigned for this metric. The value may be\nassociated with any  objective function of the circuit, but by\nconvention is intended to measure the capacity of the circuit for\nhandling traffic, for example, its throughput in  bits-per-second.\nHigher values indicate a lower capacity.", "id": "f22958:c1:m5"}
{"signature": "def _set_flags(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__flags = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/is_reachability/neighbors/neighbors/default_metric/state/flags (enumeration)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_flags is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_flags() directly.\n\nYANG Description: ISIS Default-Metric Flags.", "id": "f22958:c1:m3"}
{"signature": "def _set_flags(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__flags = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/is_reachability/neighbors/neighbors/default_metric/state/flags (enumeration)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_flags is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_flags() directly.\n\nYANG Description: ISIS Default-Metric Flags.", "id": "f22958:c0:m3"}
{"signature": "def _get_default_metric(self):", "body": "return self.__default_metric<EOL>", "docstring": "Getter method for default_metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/is_reachability/neighbors/neighbors/default_metric/state/default_metric (oc-isis-types:narrow-metric)\n\n    YANG Description: ISIS default metric value. This is a metric understood by every\nIntermediate system in the domain. Each circuit shall have a\npositive  integral value assigned for this metric. The value may be\nassociated with any  objective function of the circuit, but by\nconvention is intended to measure the capacity of the circuit for\nhandling traffic, for example, its throughput in  bits-per-second.\nHigher values indicate a lower capacity.", "id": "f22958:c0:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/is_reachability/neighbors/neighbors/default_metric/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters for default-metric.", "id": "f22959:c1:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/is_reachability/neighbors/neighbors/default_metric/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters for default-metric.", "id": "f22959:c0:m3"}
{"signature": "def _set_flags(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__flags = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/is_reachability/neighbors/neighbors/error_metric/state/flags (isis-metric-flags)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_flags is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_flags() directly.\n\nYANG Description: IS-IS error metric flags.", "id": "f22960:c1:m6"}
{"signature": "def _set_expense_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=expense_metric.expense_metric,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__expense_metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for expense_metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/is_reachability/neighbors/neighbors/expense_metric (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_expense_metric is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_expense_metric() directly.\n\nYANG Description: This container defines the ISIS expense metric.", "id": "f22962:c1:m12"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/is_reachability/neighbors/neighbors/state (container)\n\nYANG Description: State parameters of IS standard neighbor.", "id": "f22962:c1:m2"}
{"signature": "def _get_default_metric(self):", "body": "return self.__default_metric<EOL>", "docstring": "Getter method for default_metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/is_reachability/neighbors/neighbors/default_metric (container)\n\nYANG Description: This container defines ISIS Default Metric.", "id": "f22962:c0:m5"}
{"signature": "def _get_delay_metric(self):", "body": "return self.__delay_metric<EOL>", "docstring": "Getter method for delay_metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/is_reachability/neighbors/neighbors/delay_metric (container)\n\nYANG Description: This container defines the ISIS delay metric.", "id": "f22962:c1:m8"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/is_reachability/neighbors/neighbors/state (container)\n\nYANG Description: State parameters of IS standard neighbor.", "id": "f22962:c0:m2"}
{"signature": "def _set_default_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=default_metric.default_metric,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__default_metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for default_metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/is_reachability/neighbors/neighbors/default_metric (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_default_metric is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_default_metric() directly.\n\nYANG Description: This container defines ISIS Default Metric.", "id": "f22962:c0:m6"}
{"signature": "def _set_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/is_reachability/neighbors/neighbors/expense_metric/state/metric (oc-isis-types:narrow-metric)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_metric is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_metric() directly.\n\n    YANG Description: ISIS expense metric value. This metric measures the monetary cost\nof utilising the associated circuit. It is an optional metric, which\nif assigned to a circuit shall have a positive integral value1).\nHigher values indicate a larger monetary expense.", "id": "f22963:c1:m3"}
{"signature": "def _get_flags(self):", "body": "return self.__flags<EOL>", "docstring": "Getter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/is_reachability/neighbors/neighbors/expense_metric/state/flags (isis-metric-flags)\n\nYANG Description: ISIS Expense Metric Flags.", "id": "f22963:c1:m5"}
{"signature": "def _get_metric(self):", "body": "return self.__metric<EOL>", "docstring": "Getter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/is_reachability/neighbors/neighbors/expense_metric/state/metric (oc-isis-types:narrow-metric)\n\n    YANG Description: ISIS expense metric value. This metric measures the monetary cost\nof utilising the associated circuit. It is an optional metric, which\nif assigned to a circuit shall have a positive integral value1).\nHigher values indicate a larger monetary expense.", "id": "f22963:c1:m2"}
{"signature": "def _set_flags(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__flags = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/is_reachability/neighbors/neighbors/expense_metric/state/flags (isis-metric-flags)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_flags is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_flags() directly.\n\nYANG Description: ISIS Expense Metric Flags.", "id": "f22963:c0:m6"}
{"signature": "def _set_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/is_reachability/neighbors/neighbors/expense_metric/state/metric (oc-isis-types:narrow-metric)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_metric is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_metric() directly.\n\n    YANG Description: ISIS expense metric value. This metric measures the monetary cost\nof utilising the associated circuit. It is an optional metric, which\nif assigned to a circuit shall have a positive integral value1).\nHigher values indicate a larger monetary expense.", "id": "f22963:c0:m3"}
{"signature": "def _get_flags(self):", "body": "return self.__flags<EOL>", "docstring": "Getter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/is_reachability/neighbors/neighbors/expense_metric/state/flags (isis-metric-flags)\n\nYANG Description: ISIS Expense Metric Flags.", "id": "f22963:c0:m5"}
{"signature": "def _set_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/is_reachability/neighbors/neighbors/delay_metric/state/metric (oc-isis-types:narrow-metric)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_metric is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_metric() directly.\n\n    YANG Description: ISIS delay metric value. This metric measures the transit delay of\nthe associated circuit. It is an optional metric, which if assigned\nto a circuit shall have a positive integral value. Higher values\nindicate a longer transit delay.", "id": "f22965:c1:m3"}
{"signature": "def _get_flags(self):", "body": "return self.__flags<EOL>", "docstring": "Getter method for flags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/is_reachability/neighbors/neighbors/delay_metric/state/flags (isis-metric-flags)\n\nYANG Description: ISIS Delay Metric Flags.", "id": "f22965:c0:m5"}
{"signature": "def _get_metric(self):", "body": "return self.__metric<EOL>", "docstring": "Getter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/is_reachability/neighbors/neighbors/delay_metric/state/metric (oc-isis-types:narrow-metric)\n\n    YANG Description: ISIS delay metric value. This metric measures the transit delay of\nthe associated circuit. It is an optional metric, which if assigned\nto a circuit shall have a positive integral value. Higher values\nindicate a longer transit delay.", "id": "f22965:c1:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/is_reachability/state (container)\n\nYANG Description: This container describes IS reachability state", "id": "f22967:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/is_reachability/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: This container describes IS reachability state", "id": "f22967:c1:m3"}
{"signature": "def _get_neighbors(self):", "body": "return self.__neighbors<EOL>", "docstring": "Getter method for neighbors, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/tlvs/tlv/is_reachability/neighbors (container)\n\nYANG Description: This container describes IS neighbors.", "id": "f22967:c0:m5"}
{"signature": "def _get_undefined_tlvs(self):", "body": "return self.__undefined_tlvs<EOL>", "docstring": "Getter method for undefined_tlvs, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/undefined_tlvs (container)\n\nYANG Description: Surrounding container for a list of unknown TLVs.", "id": "f22968:c1:m11"}
{"signature": "def _get_lsp_id(self):", "body": "return self.__lsp_id<EOL>", "docstring": "Getter method for lsp_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/lsp_id (leafref)\n\nYANG Description: A reference to the Link State PDU ID.", "id": "f22968:c1:m2"}
{"signature": "def _set_undefined_tlvs(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=undefined_tlvs.undefined_tlvs,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__undefined_tlvs = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for undefined_tlvs, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/undefined_tlvs (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_undefined_tlvs is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_undefined_tlvs() directly.\n\nYANG Description: Surrounding container for a list of unknown TLVs.", "id": "f22968:c1:m12"}
{"signature": "def _set_lsp_id(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__lsp_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for lsp_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/lsp_id (leafref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_lsp_id is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_lsp_id() directly.\n\nYANG Description: A reference to the Link State PDU ID.", "id": "f22968:c1:m3"}
{"signature": "def _set_lsp_id(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__lsp_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for lsp_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/link_state_database/lsp/lsp_id (leafref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_lsp_id is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_lsp_id() directly.\n\nYANG Description: A reference to the Link State PDU ID.", "id": "f22968:c0:m3"}
{"signature": "def _set_lsp_authentication(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__lsp_authentication = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for lsp_authentication, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/authentication/state/lsp_authentication (boolean)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_lsp_authentication is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_lsp_authentication() directly.\n\nYANG Description: Enable or disable authentication for IS-IS LSPs.", "id": "f22969:c0:m9"}
{"signature": "def _get_lsp_authentication(self):", "body": "return self.__lsp_authentication<EOL>", "docstring": "Getter method for lsp_authentication, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/authentication/state/lsp_authentication (boolean)\n\nYANG Description: Enable or disable authentication for IS-IS LSPs.", "id": "f22969:c0:m8"}
{"signature": "def _get_csnp_authentication(self):", "body": "return self.__csnp_authentication<EOL>", "docstring": "Getter method for csnp_authentication, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/authentication/state/csnp_authentication (boolean)\n\nYANG Description: Enable or disable for IS-IS CSNPs.", "id": "f22969:c0:m2"}
{"signature": "def _get_auth_password(self):", "body": "return self.__auth_password<EOL>", "docstring": "Getter method for auth_password, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/authentication/key/state/auth_password (oc-types:routing-password)\n\nYANG Description: Authentication key string.", "id": "f22970:c0:m2"}
{"signature": "def _get_auth_password(self):", "body": "return self.__auth_password<EOL>", "docstring": "Getter method for auth_password, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/authentication/key/state/auth_password (oc-types:routing-password)\n\nYANG Description: Authentication key string.", "id": "f22970:c1:m2"}
{"signature": "def _set_auth_password(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__auth_password = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for auth_password, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/authentication/key/config/auth_password (oc-types:routing-password)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_auth_password is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_auth_password() directly.\n\nYANG Description: Authentication key string.", "id": "f22971:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/authentication/key/state (container)\n\nYANG Description: This container defines ISIS authentication key state.", "id": "f22972:c1:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/authentication/key/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: This container defines ISIS authentication key state.", "id": "f22972:c0:m6"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/authentication/key/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: This container defines ISIS authentication key state.", "id": "f22972:c1:m6"}
{"signature": "def _set_lsp_authentication(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__lsp_authentication = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for lsp_authentication, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/authentication/config/lsp_authentication (boolean)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_lsp_authentication is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_lsp_authentication() directly.\n\nYANG Description: Enable or disable authentication for IS-IS LSPs.", "id": "f22973:c0:m9"}
{"signature": "def _set_csnp_authentication(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__csnp_authentication = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for csnp_authentication, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/authentication/config/csnp_authentication (boolean)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_csnp_authentication is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_csnp_authentication() directly.\n\nYANG Description: Enable or disable for IS-IS CSNPs.", "id": "f22973:c0:m3"}
{"signature": "def _set_key(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=key.key,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:key>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__key = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for key, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/authentication/key (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_key is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_key() directly.\n\nYANG Description: This container defines ISIS authentication key", "id": "f22974:c1:m9"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/authentication/state (container)\n\nYANG Description: This container defines ISIS authentication state.", "id": "f22974:c0:m5"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/authentication/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: This container defines ISIS authentication configuration.", "id": "f22974:c1:m3"}
{"signature": "def _set_key(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=key.key,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:key>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__key = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for key, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/authentication/key (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_key is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_key() directly.\n\nYANG Description: This container defines ISIS authentication key", "id": "f22974:c0:m9"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/authentication/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: This container defines ISIS authentication configuration.", "id": "f22974:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis/levels/level/authentication/state (container)\n\nYANG Description: This container defines ISIS authentication state.", "id": "f22974:c1:m5"}
{"signature": "def _set_identifier(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__identifier = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for identifier, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/state/identifier (oc-ospf-types:ospf-area-identifier)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_identifier is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_identifier() directly.\n\n    YANG Description: An identifier for the area, expressed as a dotted quad or\nan unsigned 32-bit integer", "id": "f22976:c0:m3"}
{"signature": "def _get_identifier(self):", "body": "return self.__identifier<EOL>", "docstring": "Getter method for identifier, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/state/identifier (oc-ospf-types:ospf-area-identifier)\n\n    YANG Description: An identifier for the area, expressed as a dotted quad or\nan unsigned 32-bit integer", "id": "f22976:c0:m2"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/state/type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_type() directly.\n\n    YANG Description: The type of LSA being described. The type of the LSA is\nexpressed as a canonical name.", "id": "f22977:c1:m3"}
{"signature": "def _set_lsas(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=lsas.lsas,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__lsas = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for lsas, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_lsas is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_lsas() directly.\n\n    YANG Description: Enclosing container for a list of the LSAs of\nthe specified type received by the system", "id": "f22978:c0:m9"}
{"signature": "def _set_type(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/type (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_type() directly.\n\n    YANG Description: A reference for the LSA type being described within\nthe LSDB", "id": "f22978:c0:m3"}
{"signature": "def _get_type(self):", "body": "return self.__type<EOL>", "docstring": "Getter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/router_lsa/state/type (identityref)\n\nYANG Description: The sub-type of the Router LSA.", "id": "f22979:c0:m2"}
{"signature": "def _get_metric(self):", "body": "return self.__metric<EOL>", "docstring": "Getter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/router_lsa/state/metric (oc-ospf-types:ospf-metric)\n\nYANG Description: The cost of utilising the link specified independent of TOS", "id": "f22979:c1:m11"}
{"signature": "def _get_link_id(self):", "body": "return self.__link_id<EOL>", "docstring": "Getter method for link_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/router_lsa/state/link_id (yang:dotted-quad)\n\n    YANG Description: The identifier for the link specified. The value of the link\nidentifier is dependent upon the type of the LSA. The value is\nspecified to be, per sub-type:\n 1) Neighbouring router's router ID.\n 2) IP address of DR.\n 3) IP network address.\n 4) Neighbouring router router's ID.", "id": "f22979:c0:m5"}
{"signature": "def _set_link_data(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__link_data = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for link_data, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/router_lsa/state/link_data (union)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_link_data is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_link_data() directly.\n\n    YANG Description: The data associated with the link type. The value is\ndependent upon the subtype of the LSA. When the connection is\nto a stub network it represents the mask; for p2p connections\nthat are unnumbered it represents the ifIndex value of the\nrouter's interface; for all other connections it represents\nthe local system's IP address", "id": "f22979:c0:m9"}
{"signature": "def _get_number_tos_metrics(self):", "body": "return self.__number_tos_metrics<EOL>", "docstring": "Getter method for number_tos_metrics, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/router_lsa/state/number_tos_metrics (uint16)\n\n    YANG Description: The number of different TOS metrics given for this link, not\nincluding the link metric (which is referred to as TOS 0).", "id": "f22979:c0:m17"}
{"signature": "def _get_type_of_service(self):", "body": "return self.__type_of_service<EOL>", "docstring": "Getter method for type_of_service, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/router_lsa/types_of_service/type_of_service (list)\n\nYANG Description: Per-type of service parameters for the LSA", "id": "f22980:c1:m2"}
{"signature": "def _set_tos(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__tos = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for tos, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/router_lsa/types_of_service/type_of_service/state/tos (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_tos is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_tos() directly.\n\n    YANG Description: OSPF encoding of the type of service referred to by this\nLSA. Encoding for OSPF TOS are described in RFC2328.", "id": "f22981:c0:m3"}
{"signature": "def _get_tos(self):", "body": "return self.__tos<EOL>", "docstring": "Getter method for tos, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/router_lsa/types_of_service/type_of_service/state/tos (uint8)\n\n    YANG Description: OSPF encoding of the type of service referred to by this\nLSA. Encoding for OSPF TOS are described in RFC2328.", "id": "f22981:c1:m2"}
{"signature": "def _set_types_of_service(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=types_of_service.types_of_service,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__types_of_service = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for types_of_service, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/router_lsa/types_of_service (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_types_of_service is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_types_of_service() directly.\n\n    YANG Description: Breakdown of LSA contents specifying multiple\nTOS values", "id": "f22983:c1:m6"}
{"signature": "def _get_types_of_service(self):", "body": "return self.__types_of_service<EOL>", "docstring": "Getter method for types_of_service, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/router_lsa/types_of_service (container)\n\n    YANG Description: Breakdown of LSA contents specifying multiple\nTOS values", "id": "f22983:c1:m5"}
{"signature": "def _set_age(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__age = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for age, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/state/age (uint16)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_age is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_age() directly.\n\nYANG Description: The time since the LSA's generation in seconds", "id": "f22984:c0:m15"}
{"signature": "def _get_link_state_id(self):", "body": "return self.__link_state_id<EOL>", "docstring": "Getter method for link_state_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/state/link_state_id (yang:dotted-quad)\n\n    YANG Description: The Link State ID for the specified LSA type. The exact\ndefined value of the Link State ID is dependent on the LSA\ntype.", "id": "f22984:c0:m2"}
{"signature": "def _set_checksum(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__checksum = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for checksum, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/state/checksum (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_checksum is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_checksum() directly.\n\n    YANG Description: The checksum of the complete contents of the LSA excluding\nthe age field.", "id": "f22984:c1:m12"}
{"signature": "def _set_advertising_router(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__advertising_router = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for advertising_router, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/state/advertising_router (yang:dotted-quad)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_advertising_router is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_advertising_router() directly.\n\nYANG Description: The router ID of the router that originated the LSA", "id": "f22984:c0:m6"}
{"signature": "def _get_advertising_router(self):", "body": "return self.__advertising_router<EOL>", "docstring": "Getter method for advertising_router, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/state/advertising_router (yang:dotted-quad)\n\nYANG Description: The router ID of the router that originated the LSA", "id": "f22984:c1:m5"}
{"signature": "def _get_network_mask(self):", "body": "return self.__network_mask<EOL>", "docstring": "Getter method for network_mask, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/summary_lsa/state/network_mask (uint8)\n\n    YANG Description: The mask of the network described by the Summary LSA\nrepresented as a CIDR mask.", "id": "f22985:c1:m2"}
{"signature": "def _get_metric(self):", "body": "return self.__metric<EOL>", "docstring": "Getter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/summary_lsa/types_of_service/type_of_service/state/metric (oc-ospf-types:ospf-metric)\n\n    YANG Description: The metric value to be used for the TOS specified. This value\nrepresents the cost of use of the link for the specific type\nof service.", "id": "f22987:c1:m5"}
{"signature": "def _set_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/summary_lsa/types_of_service/type_of_service/state/metric (oc-ospf-types:ospf-metric)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_metric is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_metric() directly.\n\n    YANG Description: The metric value to be used for the TOS specified. This value\nrepresents the cost of use of the link for the specific type\nof service.", "id": "f22987:c1:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/summary_lsa/types_of_service/type_of_service/state (container)\n\nYANG Description: Per-TOS parameters for the LSA", "id": "f22988:c1:m5"}
{"signature": "def _set_types_of_service(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=types_of_service.types_of_service,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__types_of_service = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for types_of_service, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/summary_lsa/types_of_service (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_types_of_service is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_types_of_service() directly.\n\n    YANG Description: Breakdown of LSA contents specifying multiple\nTOS values", "id": "f22989:c1:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/summary_lsa/state (container)\n\nYANG Description: State parameters of the summary LSA", "id": "f22989:c1:m2"}
{"signature": "def _get_summary_lsa(self):", "body": "return self.__summary_lsa<EOL>", "docstring": "Getter method for summary_lsa, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/summary_lsa (container)\n\nYANG Description: Contents of the summary LSA", "id": "f22990:c0:m14"}
{"signature": "def _get_nssa_external_lsa(self):", "body": "return self.__nssa_external_lsa<EOL>", "docstring": "Getter method for nssa_external_lsa, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/nssa_external_lsa (container)\n\nYANG Description: Contents of the NSSA External LSA", "id": "f22990:c0:m20"}
{"signature": "def _get_opaque_lsa(self):", "body": "return self.__opaque_lsa<EOL>", "docstring": "Getter method for opaque_lsa, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa (container)\n\nYANG Description: Contents of the opaque LSA", "id": "f22990:c1:m23"}
{"signature": "def _set_network_lsa(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=network_lsa.network_lsa,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__network_lsa = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for network_lsa, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/network_lsa (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_network_lsa is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_network_lsa() directly.\n\nYANG Description: Contents of the network LSA", "id": "f22990:c1:m12"}
{"signature": "def _get_router_lsa(self):", "body": "return self.__router_lsa<EOL>", "docstring": "Getter method for router_lsa, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/router_lsa (container)\n\nYANG Description: Contents of the router LSA", "id": "f22990:c1:m8"}
{"signature": "def _set_summary_lsa(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=summary_lsa.summary_lsa,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__summary_lsa = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for summary_lsa, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/summary_lsa (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_summary_lsa is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_summary_lsa() directly.\n\nYANG Description: Contents of the summary LSA", "id": "f22990:c1:m15"}
{"signature": "def _get_as_external_lsa(self):", "body": "return self.__as_external_lsa<EOL>", "docstring": "Getter method for as_external_lsa, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/as_external_lsa (container)\n\nYANG Description: Contents of the AS External LSA", "id": "f22990:c0:m17"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/state (container)\n\n    YANG Description: Operational state parameters relating to all\nLSA types", "id": "f22990:c1:m5"}
{"signature": "def _set_as_external_lsa(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=as_external_lsa.as_external_lsa,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__as_external_lsa = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for as_external_lsa, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/as_external_lsa (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_as_external_lsa is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_as_external_lsa() directly.\n\nYANG Description: Contents of the AS External LSA", "id": "f22990:c1:m18"}
{"signature": "def _get_network_lsa(self):", "body": "return self.__network_lsa<EOL>", "docstring": "Getter method for network_lsa, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/network_lsa (container)\n\nYANG Description: Contents of the network LSA", "id": "f22990:c1:m11"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: Operational state parameters relating to all\nLSA types", "id": "f22990:c0:m6"}
{"signature": "def _set_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/nssa_external_lsa/state/metric (oc-ospf-types:ospf-metric)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_metric is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_metric() directly.\n\n    YANG Description: The cost to reach the external network specified. The exact\ninterpretation of this cost is dependent on the type of\nmetric specified", "id": "f22991:c1:m9"}
{"signature": "def _set_external_route_tag(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__external_route_tag = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for external_route_tag, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/nssa_external_lsa/state/external_route_tag (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_external_route_tag is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_external_route_tag() directly.\n\n    YANG Description: An opaque tag that set by the LSA originator to carry\ninformation relating to the external route", "id": "f22991:c0:m15"}
{"signature": "def _set_external_route_tag(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__external_route_tag = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for external_route_tag, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/nssa_external_lsa/state/external_route_tag (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_external_route_tag is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_external_route_tag() directly.\n\n    YANG Description: An opaque tag that set by the LSA originator to carry\ninformation relating to the external route", "id": "f22991:c1:m15"}
{"signature": "def _set_metric_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__metric_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for metric_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/nssa_external_lsa/state/metric_type (enumeration)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_metric_type is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_metric_type() directly.\n\nYANG Description: The type of metric included within the AS External LSA.", "id": "f22991:c1:m6"}
{"signature": "def _set_propagate(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__propagate = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for propagate, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/nssa_external_lsa/state/propagate (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_propagate is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_propagate() directly.\n\n    YANG Description: When this bit is set to true, an NSSA border router will\ntranslate a Type 7 LSA (NSSA External) to a Type 5 LSA\n(AS External).", "id": "f22991:c1:m18"}
{"signature": "def _get_propagate(self):", "body": "return self.__propagate<EOL>", "docstring": "Getter method for propagate, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/nssa_external_lsa/state/propagate (boolean)\n\n    YANG Description: When this bit is set to true, an NSSA border router will\ntranslate a Type 7 LSA (NSSA External) to a Type 5 LSA\n(AS External).", "id": "f22991:c0:m17"}
{"signature": "def _set_mask(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__mask = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for mask, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/nssa_external_lsa/state/mask (uint8)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_mask is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_mask() directly.\n\nYANG Description: The subnet mask for the advertised destination", "id": "f22991:c1:m3"}
{"signature": "def _set_mask(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__mask = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for mask, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/nssa_external_lsa/state/mask (uint8)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_mask is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_mask() directly.\n\nYANG Description: The subnet mask for the advertised destination", "id": "f22991:c0:m3"}
{"signature": "def _get_mask(self):", "body": "return self.__mask<EOL>", "docstring": "Getter method for mask, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/nssa_external_lsa/state/mask (uint8)\n\nYANG Description: The subnet mask for the advertised destination", "id": "f22991:c0:m2"}
{"signature": "def _get_external_route_tag(self):", "body": "return self.__external_route_tag<EOL>", "docstring": "Getter method for external_route_tag, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/nssa_external_lsa/state/external_route_tag (uint32)\n\n    YANG Description: An opaque tag that set by the LSA originator to carry\ninformation relating to the external route", "id": "f22991:c1:m14"}
{"signature": "def _get_propagate(self):", "body": "return self.__propagate<EOL>", "docstring": "Getter method for propagate, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/nssa_external_lsa/state/propagate (boolean)\n\n    YANG Description: When this bit is set to true, an NSSA border router will\ntranslate a Type 7 LSA (NSSA External) to a Type 5 LSA\n(AS External).", "id": "f22991:c1:m17"}
{"signature": "def _get_mask(self):", "body": "return self.__mask<EOL>", "docstring": "Getter method for mask, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/nssa_external_lsa/state/mask (uint8)\n\nYANG Description: The subnet mask for the advertised destination", "id": "f22991:c1:m2"}
{"signature": "def _get_type_of_service(self):", "body": "return self.__type_of_service<EOL>", "docstring": "Getter method for type_of_service, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/nssa_external_lsa/types_of_service/type_of_service (list)\n\nYANG Description: Per-type of service parameters for the NSSA external LSA", "id": "f22992:c0:m2"}
{"signature": "def _set_type_of_service(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>type_of_service.type_of_service,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type_of_service = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type_of_service, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/nssa_external_lsa/types_of_service/type_of_service (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_type_of_service is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_type_of_service() directly.\n\nYANG Description: Per-type of service parameters for the NSSA external LSA", "id": "f22992:c1:m3"}
{"signature": "def _get_forwarding_address(self):", "body": "return self.__forwarding_address<EOL>", "docstring": "Getter method for forwarding_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/nssa_external_lsa/types_of_service/type_of_service/state/forwarding_address (inet:ipv4-address-no-zone)\n\n    YANG Description: The destination to which traffic for the external prefix\nshould be advertised. When this value is set to 0.0.0.0 then\ntraffic should be forwarded to the LSA's originator", "id": "f22993:c0:m2"}
{"signature": "def _set_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/nssa_external_lsa/types_of_service/type_of_service/state/metric (oc-ospf-types:ospf-metric)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_metric is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_metric() directly.\n\n    YANG Description: The metric value to be used for the TOS specified. This value\nrepresents the cost of use of the link for the specific type\nof service.", "id": "f22993:c0:m12"}
{"signature": "def _set_forwarding_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__forwarding_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for forwarding_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/nssa_external_lsa/types_of_service/type_of_service/state/forwarding_address (inet:ipv4-address-no-zone)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_forwarding_address is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_forwarding_address() directly.\n\n    YANG Description: The destination to which traffic for the external prefix\nshould be advertised. When this value is set to 0.0.0.0 then\ntraffic should be forwarded to the LSA's originator", "id": "f22993:c0:m3"}
{"signature": "def _get_tos(self):", "body": "return self.__tos<EOL>", "docstring": "Getter method for tos, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/nssa_external_lsa/types_of_service/type_of_service/state/tos (uint8)\n\n    YANG Description: OSPF encoding of the type of service referred to by this\nLSA. Encoding for OSPF TOS are described in RFC2328.", "id": "f22993:c1:m8"}
{"signature": "def _set_forwarding_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__forwarding_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for forwarding_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/nssa_external_lsa/types_of_service/type_of_service/state/forwarding_address (inet:ipv4-address-no-zone)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_forwarding_address is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_forwarding_address() directly.\n\n    YANG Description: The destination to which traffic for the external prefix\nshould be advertised. When this value is set to 0.0.0.0 then\ntraffic should be forwarded to the LSA's originator", "id": "f22993:c1:m3"}
{"signature": "def _set_tos(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__tos = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for tos, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/nssa_external_lsa/types_of_service/type_of_service/state/tos (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_tos is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_tos() directly.\n\n    YANG Description: OSPF encoding of the type of service referred to by this\nLSA. Encoding for OSPF TOS are described in RFC2328.", "id": "f22993:c0:m9"}
{"signature": "def _set_external_route_tag(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__external_route_tag = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for external_route_tag, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/nssa_external_lsa/types_of_service/type_of_service/state/external_route_tag (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_external_route_tag is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_external_route_tag() directly.\n\n    YANG Description: An opaque tag that set by the LSA originator to carry\ninformation relating to the external route", "id": "f22993:c1:m6"}
{"signature": "def _get_tos(self):", "body": "return self.__tos<EOL>", "docstring": "Getter method for tos, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/nssa_external_lsa/types_of_service/type_of_service/tos (leafref)\n\n    YANG Description: Reference to the type of services identifier which is specified\nin the NSSA External LSA", "id": "f22994:c0:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/nssa_external_lsa/types_of_service/type_of_service/state (container)\n\nYANG Description: Per-TOS parameters for the LSA", "id": "f22994:c0:m5"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/nssa_external_lsa/types_of_service/type_of_service/state (container)\n\nYANG Description: Per-TOS parameters for the LSA", "id": "f22994:c1:m5"}
{"signature": "def _set_tos(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__tos = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for tos, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/nssa_external_lsa/types_of_service/type_of_service/tos (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_tos is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_tos() directly.\n\n    YANG Description: Reference to the type of services identifier which is specified\nin the NSSA External LSA", "id": "f22994:c0:m3"}
{"signature": "def _get_tos(self):", "body": "return self.__tos<EOL>", "docstring": "Getter method for tos, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/nssa_external_lsa/types_of_service/type_of_service/tos (leafref)\n\n    YANG Description: Reference to the type of services identifier which is specified\nin the NSSA External LSA", "id": "f22994:c1:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/nssa_external_lsa/types_of_service/type_of_service/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Per-TOS parameters for the LSA", "id": "f22994:c1:m6"}
{"signature": "def _set_tos(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__tos = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for tos, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/nssa_external_lsa/types_of_service/type_of_service/tos (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_tos is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_tos() directly.\n\n    YANG Description: Reference to the type of services identifier which is specified\nin the NSSA External LSA", "id": "f22994:c1:m3"}
{"signature": "def _set_types_of_service(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=types_of_service.types_of_service,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__types_of_service = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for types_of_service, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/nssa_external_lsa/types_of_service (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_types_of_service is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_types_of_service() directly.\n\n    YANG Description: Breakdown of the NSSA External LSA contents specifying multiple\nTOS values", "id": "f22995:c0:m6"}
{"signature": "def _get_types_of_service(self):", "body": "return self.__types_of_service<EOL>", "docstring": "Getter method for types_of_service, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/nssa_external_lsa/types_of_service (container)\n\n    YANG Description: Breakdown of the NSSA External LSA contents specifying multiple\nTOS values", "id": "f22995:c0:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/nssa_external_lsa/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters for the AS external LSA", "id": "f22995:c1:m3"}
{"signature": "def _get_scope(self):", "body": "return self.__scope<EOL>", "docstring": "Getter method for scope, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/state/scope (enumeration)\n\n    YANG Description: The scope of the opaque LSA. The type of the LSA\nindicates its scope - the value of this leaf\ndetermines both the flooding domain, and the type\nof the LSA.", "id": "f22996:c1:m2"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/state/type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_type() directly.\n\n    YANG Description: The Opaque Type of the LSA. This value is used to\nindicate the type of data carried by the opaque LSA", "id": "f22996:c1:m6"}
{"signature": "def _get_scope(self):", "body": "return self.__scope<EOL>", "docstring": "Getter method for scope, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/state/scope (enumeration)\n\n    YANG Description: The scope of the opaque LSA. The type of the LSA\nindicates its scope - the value of this leaf\ndetermines both the flooding domain, and the type\nof the LSA.", "id": "f22996:c0:m2"}
{"signature": "def _set_prefix_length(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prefix_length = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prefix_length, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/state/prefix_length (uint8)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_prefix_length is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_prefix_length() directly.\n\nYANG Description: The length of the IPv4 prefix contained in the Extended Prefix LSA", "id": "f22997:c0:m6"}
{"signature": "def _set_node(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__node = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for node, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/state/node (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_node is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_node() directly.\n\n    YANG Description: If this value is set to true, the prefix being advertised represents\nthe advertising router. Typically, the prefix within the LSA is\nexpected to be globally-reachable prefix associated with a loopback\ninterface", "id": "f22997:c0:m15"}
{"signature": "def _set_route_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:0>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:1>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:3>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:5>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:7>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__route_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for route_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/state/route_type (enumeration)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_route_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_route_type() directly.\n\n    YANG Description: The type of prefix that is contained within the Extended Prefix LSA.\nThe information contained in sub-TLVs of the attribute is applicable\nregardless of this value.", "id": "f22997:c1:m3"}
{"signature": "def _set_attached(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__attached = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for attached, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/state/attached (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_attached is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_attached() directly.\n\n    YANG Description: If this value is set to true, the prefix being advertised was\ngenerated by an ABR for an inter-area prefix. The value corresponds\nto the A-flag of the flags field of the Extended Prefix LSA", "id": "f22997:c1:m12"}
{"signature": "def _set_route_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:0>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:1>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:3>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:5>},<EOL>\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:7>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__route_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for route_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/state/route_type (enumeration)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_route_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_route_type() directly.\n\n    YANG Description: The type of prefix that is contained within the Extended Prefix LSA.\nThe information contained in sub-TLVs of the attribute is applicable\nregardless of this value.", "id": "f22997:c0:m3"}
{"signature": "def _get_address_family(self):", "body": "return self.__address_family<EOL>", "docstring": "Getter method for address_family, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/state/address_family (enumeration)\n\n    YANG Description: The address family of the prefix contained in the Extended Prefix\nLSA", "id": "f22997:c1:m8"}
{"signature": "def _get_type(self):", "body": "return self.__type<EOL>", "docstring": "Getter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/state/type (identityref)\n\nYANG Description: The type of sub-TLV as indicated by the Extended Prefix LSA", "id": "f22999:c1:m2"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/state/type (identityref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_type is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_type() directly.\n\nYANG Description: The type of sub-TLV as indicated by the Extended Prefix LSA", "id": "f22999:c1:m3"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/state/type (identityref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_type is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_type() directly.\n\nYANG Description: The type of sub-TLV as indicated by the Extended Prefix LSA", "id": "f22999:c0:m3"}
{"signature": "def _get_weight(self):", "body": "return self.__weight<EOL>", "docstring": "Getter method for weight, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/sid_label_binding/state/weight (uint8)\n\n    YANG Description: The weight of the advertised binding when used for load-balancing\npurposes", "id": "f23000:c0:m8"}
{"signature": "def _set_tlv(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>False,<EOL>tlv.tlv,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT:False>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__tlv = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for tlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/sid_label_binding/tlvs/tlv (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_tlv is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_tlv() directly.\n\nYANG Description: A TLV contained within the SID/Label Binding sub-TLV", "id": "f23001:c1:m3"}
{"signature": "def _get_tlv(self):", "body": "return self.__tlv<EOL>", "docstring": "Getter method for tlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/sid_label_binding/tlvs/tlv (list)\n\nYANG Description: A TLV contained within the SID/Label Binding sub-TLV", "id": "f23001:c1:m2"}
{"signature": "def _get_type(self):", "body": "return self.__type<EOL>", "docstring": "Getter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/sid_label_binding/tlvs/tlv/state/type (identityref)\n\n    YANG Description: The type of sub-TLV that is being contained within the SID/Label\nsub-TLV", "id": "f23002:c1:m2"}
{"signature": "def _set_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/sid_label_binding/tlvs/tlv/ero_metric/state/metric (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_metric is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_metric() directly.\n\n    YANG Description: The metric representing the aggregate IGP or TE path cost for the\nbinding included within the SID/Label Binding TLV", "id": "f23003:c1:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/sid_label_binding/tlvs/tlv/ero_metric/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: State parameters relating to the ERO Metric Sub-TLV of\nthe SID/Label binding TLV", "id": "f23004:c1:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/sid_label_binding/tlvs/tlv/ero_metric/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: State parameters relating to the ERO Metric Sub-TLV of\nthe SID/Label binding TLV", "id": "f23004:c0:m3"}
{"signature": "def _get_sid_type(self):", "body": "return self.__sid_type<EOL>", "docstring": "Getter method for sid_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/sid_label_binding/tlvs/tlv/sid_label_binding/state/sid_type (oc-ospf-types:sr-sid-type)\n\nYANG Description: The type of the value contained within the sub-TLV", "id": "f23005:c1:m2"}
{"signature": "def _set_sid_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__sid_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for sid_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/sid_label_binding/tlvs/tlv/sid_label_binding/state/sid_type (oc-ospf-types:sr-sid-type)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_sid_type is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_sid_type() directly.\n\nYANG Description: The type of the value contained within the sub-TLV", "id": "f23005:c1:m3"}
{"signature": "def _set_sid_value(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__sid_value = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for sid_value, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/sid_label_binding/tlvs/tlv/sid_label_binding/state/sid_value (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_sid_value is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_sid_value() directly.\n\n    YANG Description: The value of the binding included within the sub-TLV. The type of\nthis binding is indicated by the type leaf.", "id": "f23005:c0:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/sid_label_binding/tlvs/tlv/sid_label_binding/state (container)\n\n    YANG Description: State parameteres relating to the SID/Label Binding\nsub-TLV", "id": "f23006:c0:m2"}
{"signature": "def _set_sid_label_binding(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=sid_label_binding.sid_label_binding,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__sid_label_binding = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for sid_label_binding, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/sid_label_binding/tlvs/tlv/sid_label_binding (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_sid_label_binding is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_sid_label_binding() directly.\n\n    YANG Description: Parameters for the SID/Label Binding sub-TLV of the\nSID/Label binding TLV", "id": "f23007:c1:m6"}
{"signature": "def _set_sid_label_binding(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=sid_label_binding.sid_label_binding,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__sid_label_binding = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for sid_label_binding, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/sid_label_binding/tlvs/tlv/sid_label_binding (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_sid_label_binding is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_sid_label_binding() directly.\n\n    YANG Description: Parameters for the SID/Label Binding sub-TLV of the\nSID/Label binding TLV", "id": "f23007:c0:m6"}
{"signature": "def _get_ero_metric(self):", "body": "return self.__ero_metric<EOL>", "docstring": "Getter method for ero_metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/sid_label_binding/tlvs/tlv/ero_metric (container)\n\n    YANG Description: Parameters for the ERO Metric Sub-TLV of the SID/Label\nbinding TLV", "id": "f23007:c1:m8"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/sid_label_binding/tlvs/tlv/ero_path/segments/segment/state/type (identityref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_type is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_type() directly.\n\nYANG Description: The type of the segment being specified as part of the ERO", "id": "f23009:c0:m3"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/sid_label_binding/tlvs/tlv/ero_path/segments/segment/state/type (identityref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_type is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_type() directly.\n\nYANG Description: The type of the segment being specified as part of the ERO", "id": "f23009:c1:m3"}
{"signature": "def _set_loose(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__loose = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for loose, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/sid_label_binding/tlvs/tlv/ero_path/segments/segment/state/loose (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_loose is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_loose() directly.\n\n    YANG Description: If this leaf is set the segment is identifier as a loose path\nsegment, otherwise the path strictly follows the path specified", "id": "f23009:c0:m6"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/sid_label_binding/tlvs/tlv/ero_path/segments/segment/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: State parameters relating to the path segment\ncontained within the sub-TLV", "id": "f23010:c1:m3"}
{"signature": "def _set_ipv4_segment(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=ipv4_segment.ipv4_segment,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv4_segment = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv4_segment, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/sid_label_binding/tlvs/tlv/ero_path/segments/segment/ipv4_segment (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ipv4_segment is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ipv4_segment() directly.\n\nYANG Description: Details of the IPv4 segment interface of the ERO", "id": "f23010:c1:m6"}
{"signature": "def _get_address(self):", "body": "return self.__address<EOL>", "docstring": "Getter method for address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/sid_label_binding/tlvs/tlv/ero_path/segments/segment/ipv4_segment/state/address (inet:ipv4-address-no-zone)\n\nYANG Description: The IPv4 address of the hop within the ERO", "id": "f23011:c1:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/sid_label_binding/tlvs/tlv/ero_path/segments/segment/ipv4_segment/state (container)\n\nYANG Description: State parameters of the IPv4 segment of the ERO", "id": "f23012:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/sid_label_binding/tlvs/tlv/ero_path/segments/segment/ipv4_segment/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of the IPv4 segment of the ERO", "id": "f23012:c1:m3"}
{"signature": "def _get_router_id(self):", "body": "return self.__router_id<EOL>", "docstring": "Getter method for router_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/sid_label_binding/tlvs/tlv/ero_path/segments/segment/unnumbered_hop/state/router_id (inet:ipv4-address-no-zone)\n\nYANG Description: The IPv4 router identtifier of the remote system", "id": "f23013:c0:m2"}
{"signature": "def _set_interface_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/sid_label_binding/tlvs/tlv/ero_path/segments/segment/unnumbered_hop/state/interface_id (uint32)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_interface_id is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_interface_id() directly.\n\nYANG Description: The identifier assigned to the link by the remote system", "id": "f23013:c0:m6"}
{"signature": "def _get_interface_id(self):", "body": "return self.__interface_id<EOL>", "docstring": "Getter method for interface_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/sid_label_binding/tlvs/tlv/ero_path/segments/segment/unnumbered_hop/state/interface_id (uint32)\n\nYANG Description: The identifier assigned to the link by the remote system", "id": "f23013:c0:m5"}
{"signature": "def _set_interface_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/sid_label_binding/tlvs/tlv/ero_path/segments/segment/unnumbered_hop/state/interface_id (uint32)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_interface_id is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_interface_id() directly.\n\nYANG Description: The identifier assigned to the link by the remote system", "id": "f23013:c1:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/sid_label_binding/tlvs/tlv/ero_path/segments/segment/unnumbered_hop/state (container)\n\n    YANG Description: State parameters of the unnumbered interface\nsegment of the ERO", "id": "f23014:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/sid_label_binding/tlvs/tlv/ero_path/segments/segment/unnumbered_hop/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: State parameters of the unnumbered interface\nsegment of the ERO", "id": "f23014:c1:m3"}
{"signature": "def _get_segments(self):", "body": "return self.__segments<EOL>", "docstring": "Getter method for segments, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/sid_label_binding/tlvs/tlv/ero_path/segments (container)\n\n    YANG Description: Segments of the path described within the SID/Label\nBinding sub-TLV", "id": "f23015:c1:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/sid_label_binding/state (container)\n\n    YANG Description: State parameters relating to the SID/Label binding sub-TLV\nof the extended prefix LSA", "id": "f23016:c1:m2"}
{"signature": "def _set_tlvs(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=tlvs.tlvs,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__tlvs = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for tlvs, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/sid_label_binding/tlvs (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_tlvs is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_tlvs() directly.\n\n    YANG Description: TLVs contained within the SID/Label Binding sub-TLV of the\nSID/Label Binding TLV", "id": "f23016:c1:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/state (container)\n\n    YANG Description: State parameters relating to the sub-TLV of the extended\nprefix LSA", "id": "f23017:c1:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: State parameters relating to the sub-TLV of the extended\nprefix LSA", "id": "f23017:c0:m3"}
{"signature": "def _set_unknown_tlv(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=unknown_tlv.unknown_tlv,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__unknown_tlv = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for unknown_tlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/unknown_tlv (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_unknown_tlv is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_unknown_tlv() directly.\n\n    YANG Description: An unknown TLV within the context. Unknown TLVs are\ndefined to be the set of TLVs that are not modelled\nwithin the OpenConfig model, or are unknown to the\nlocal system such that it cannot decode their value.", "id": "f23017:c0:m15"}
{"signature": "def _get_prefix_sid(self):", "body": "return self.__prefix_sid<EOL>", "docstring": "Getter method for prefix_sid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/prefix_sid (container)\n\n    YANG Description: State parameters relating to the Prefix SID sub-TLV of the\nextended prefix LSA", "id": "f23017:c1:m8"}
{"signature": "def _get_extended_prefix_range(self):", "body": "return self.__extended_prefix_range<EOL>", "docstring": "Getter method for extended_prefix_range, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/extended_prefix_range (container)\n\n    YANG Description: State parameters relating to the extended prefix range\nsub-TLV of the extended prefix LSA", "id": "f23017:c0:m5"}
{"signature": "def _get_unknown_tlv(self):", "body": "return self.__unknown_tlv<EOL>", "docstring": "Getter method for unknown_tlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/unknown_tlv (container)\n\n    YANG Description: An unknown TLV within the context. Unknown TLVs are\ndefined to be the set of TLVs that are not modelled\nwithin the OpenConfig model, or are unknown to the\nlocal system such that it cannot decode their value.", "id": "f23017:c1:m14"}
{"signature": "def _set_prefix_sid(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=prefix_sid.prefix_sid,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prefix_sid = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prefix_sid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/prefix_sid (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prefix_sid is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prefix_sid() directly.\n\n    YANG Description: State parameters relating to the Prefix SID sub-TLV of the\nextended prefix LSA", "id": "f23017:c1:m9"}
{"signature": "def _set_sid_label_binding(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=sid_label_binding.sid_label_binding,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__sid_label_binding = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for sid_label_binding, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/sid_label_binding (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_sid_label_binding is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_sid_label_binding() directly.\n\n    YANG Description: State parameters relating to the SID/Label binding sub-TLV\nof the extended prefix LSA", "id": "f23017:c1:m12"}
{"signature": "def _get_value(self):", "body": "return self.__value<EOL>", "docstring": "Getter method for value, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/unknown_tlv/state/value (binary)\n\nYANG Description: The value portion of the unknwon TLV", "id": "f23018:c1:m8"}
{"signature": "def _set_value(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=bitarray,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:value>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__value = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for value, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/unknown_tlv/state/value (binary)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_value is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_value() directly.\n\nYANG Description: The value portion of the unknwon TLV", "id": "f23018:c0:m9"}
{"signature": "def _get_value(self):", "body": "return self.__value<EOL>", "docstring": "Getter method for value, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/unknown_tlv/state/value (binary)\n\nYANG Description: The value portion of the unknwon TLV", "id": "f23018:c0:m8"}
{"signature": "def _set_length(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__length = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for length, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/unknown_tlv/state/length (uint16)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_length is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_length() directly.\n\nYANG Description: The length value of the unknown TLV", "id": "f23018:c0:m6"}
{"signature": "def _get_algorithm(self):", "body": "return self.__algorithm<EOL>", "docstring": "Getter method for algorithm, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/prefix_sid/state/algorithm (uint8)\n\nYANG Description: The algorithm that computes the path associated with the Prefix SID", "id": "f23020:c1:m20"}
{"signature": "def _get_sid_value_type(self):", "body": "return self.__sid_value_type<EOL>", "docstring": "Getter method for sid_value_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/prefix_sid/state/sid_value_type (enumeration)\n\n    YANG Description: Specifies the type of the value specified within the Prefix SID\nsub-TLV - in particular, whether the value is an index or an\nabsolute value. This value corresponds with the V-flag of the Prefix\nSID sub-TLV", "id": "f23020:c1:m11"}
{"signature": "def _get_mapping_server(self):", "body": "return self.__mapping_server<EOL>", "docstring": "Getter method for mapping_server, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/prefix_sid/state/mapping_server (boolean)\n\n    YANG Description: If this leaf is set the SID was advertised by a Segment Routing\nmapping server", "id": "f23020:c0:m5"}
{"signature": "def _set_sid_value_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__sid_value_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for sid_value_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/prefix_sid/state/sid_value_type (enumeration)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_sid_value_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_sid_value_type() directly.\n\n    YANG Description: Specifies the type of the value specified within the Prefix SID\nsub-TLV - in particular, whether the value is an index or an\nabsolute value. This value corresponds with the V-flag of the Prefix\nSID sub-TLV", "id": "f23020:c0:m12"}
{"signature": "def _set_mapping_server(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__mapping_server = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for mapping_server, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/prefix_sid/state/mapping_server (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_mapping_server is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_mapping_server() directly.\n\n    YANG Description: If this leaf is set the SID was advertised by a Segment Routing\nmapping server", "id": "f23020:c1:m6"}
{"signature": "def _set_multi_topology_identifier(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__multi_topology_identifier = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for multi_topology_identifier, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/prefix_sid/state/multi_topology_identifier (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_multi_topology_identifier is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_multi_topology_identifier() directly.\n\n    YANG Description: The identifier for the topology to which the Prefix SID relates. The\nvalue of this leaf is a MT-ID as defined in RFC4915", "id": "f23020:c0:m18"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/prefix_sid/state (container)\n\n    YANG Description: State parameters relating to the Prefix SID sub-TLV of the\nextended prefix LSA", "id": "f23021:c1:m2"}
{"signature": "def _set_prefix_length(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prefix_length = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prefix_length, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/extended_prefix_range/state/prefix_length (uint8)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_prefix_length is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_prefix_length() directly.\n\nYANG Description: The length of the IPv4 prefix contained in the Extended Prefix LSA", "id": "f23022:c0:m3"}
{"signature": "def _get_prefix(self):", "body": "return self.__prefix<EOL>", "docstring": "Getter method for prefix, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/extended_prefix_range/state/prefix (inet:ipv4-prefix)\n\n    YANG Description: The first prefix in the range of prefixes being described by the\nextended prefix range sub-TLV", "id": "f23022:c0:m14"}
{"signature": "def _get_prefix_length(self):", "body": "return self.__prefix_length<EOL>", "docstring": "Getter method for prefix_length, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/extended_prefix_range/state/prefix_length (uint8)\n\nYANG Description: The length of the IPv4 prefix contained in the Extended Prefix LSA", "id": "f23022:c1:m2"}
{"signature": "def _get_range_size(self):", "body": "return self.__range_size<EOL>", "docstring": "Getter method for range_size, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/extended_prefix_range/state/range_size (uint16)\n\nYANG Description: The number of prefixes that are covered by the advertisement.", "id": "f23022:c1:m8"}
{"signature": "def _set_address_family(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {\"<STR_LIT:value>\": <NUM_LIT:0>}},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__address_family = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for address_family, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/extended_prefix_range/state/address_family (enumeration)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_address_family is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_address_family() directly.\n\n    YANG Description: The address family of the prefix contained in the Extended Prefix\nLSA", "id": "f23022:c0:m6"}
{"signature": "def _set_range_size(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__range_size = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for range_size, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs/tlv/extended_prefix_range/state/range_size (uint16)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_range_size is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_range_size() directly.\n\nYANG Description: The number of prefixes that are covered by the advertisement.", "id": "f23022:c0:m9"}
{"signature": "def _get_tlvs(self):", "body": "return self.__tlvs<EOL>", "docstring": "Getter method for tlvs, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix/tlvs (container)\n\nYANG Description: TLVs contained within the Extended Prefix LSA", "id": "f23024:c0:m5"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/state (container)\n\nYANG Description: State parameters for the opaque LSA", "id": "f23025:c0:m2"}
{"signature": "def _set_extended_link(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=extended_link.extended_link,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__extended_link = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for extended_link, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_link (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_extended_link is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_extended_link() directly.\n\n    YANG Description: The OSPFv2 Extended Link Opaque LSA, used to encapsulate TLV\nattributes associated with a link advertised in OSPF.", "id": "f23025:c1:m18"}
{"signature": "def _get_router_information(self):", "body": "return self.__router_information<EOL>", "docstring": "Getter method for router_information, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information (container)\n\n    YANG Description: The router information LSA is utilised to advertise capabilities\nof a system to other systems who receive the LSA", "id": "f23025:c0:m11"}
{"signature": "def _get_extended_link(self):", "body": "return self.__extended_link<EOL>", "docstring": "Getter method for extended_link, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_link (container)\n\n    YANG Description: The OSPFv2 Extended Link Opaque LSA, used to encapsulate TLV\nattributes associated with a link advertised in OSPF.", "id": "f23025:c1:m17"}
{"signature": "def _set_extended_prefix(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=extended_prefix.extended_prefix,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__extended_prefix = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for extended_prefix, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_prefix (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_extended_prefix is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_extended_prefix() directly.\n\n    YANG Description: An OSPFv2 Extended Prefix Opaque LSA, used to encapsulate\nTLV attributes associated with a prefix advertised in OSPF.", "id": "f23025:c0:m15"}
{"signature": "def _set_router_information(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=router_information.router_information,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__router_information = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for router_information, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_router_information is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_router_information() directly.\n\n    YANG Description: The router information LSA is utilised to advertise capabilities\nof a system to other systems who receive the LSA", "id": "f23025:c0:m12"}
{"signature": "def _get_grace_lsa(self):", "body": "return self.__grace_lsa<EOL>", "docstring": "Getter method for grace_lsa, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/grace_lsa (container)\n\n    YANG Description: The Grace LSA is utilised when a remote system is undergoing\ngraceful restart", "id": "f23025:c0:m8"}
{"signature": "def _set_unknown_tlv(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=unknown_tlv.unknown_tlv,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__unknown_tlv = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for unknown_tlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/unknown_tlv (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_unknown_tlv is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_unknown_tlv() directly.\n\n    YANG Description: An unknown TLV within the context. Unknown TLVs are\ndefined to be the set of TLVs that are not modelled\nwithin the OpenConfig model, or are unknown to the\nlocal system such that it cannot decode their value.", "id": "f23025:c0:m21"}
{"signature": "def _get_tlv(self):", "body": "return self.__tlv<EOL>", "docstring": "Getter method for tlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/grace_lsa/tlvs/tlv (list)\n\n    YANG Description: TLV entry in the Grace LSA, advertised by a system undergoing\ngraceful restart", "id": "f23026:c0:m2"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/grace_lsa/tlvs/tlv/state/type (identityref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_type is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_type() directly.\n\nYANG Description: The type of the sub-TLV received within the Grace LSA", "id": "f23027:c0:m3"}
{"signature": "def _set_period(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__period = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for period, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/grace_lsa/tlvs/tlv/state/period (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_period is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_period() directly.\n\n    YANG Description: The number of seconds that the router's neighbors should advertise\nthe local system as fully adjacent regardless of database\nsynchronization state", "id": "f23027:c1:m6"}
{"signature": "def _set_ip_interface_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ip_interface_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ip_interface_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/grace_lsa/tlvs/tlv/state/ip_interface_address (inet:ipv4-address-no-zone)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_ip_interface_address is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_ip_interface_address() directly.\n\n    YANG Description: The restarting system's IP address on the interface via which the\nGrace LSA is being advertised.", "id": "f23027:c1:m12"}
{"signature": "def _get_period(self):", "body": "return self.__period<EOL>", "docstring": "Getter method for period, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/grace_lsa/tlvs/tlv/state/period (uint32)\n\n    YANG Description: The number of seconds that the router's neighbors should advertise\nthe local system as fully adjacent regardless of database\nsynchronization state", "id": "f23027:c0:m5"}
{"signature": "def _get_unknown_tlv(self):", "body": "return self.__unknown_tlv<EOL>", "docstring": "Getter method for unknown_tlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/grace_lsa/tlvs/tlv/unknown_tlv (container)\n\n    YANG Description: An unknown TLV within the context. Unknown TLVs are\ndefined to be the set of TLVs that are not modelled\nwithin the OpenConfig model, or are unknown to the\nlocal system such that it cannot decode their value.", "id": "f23028:c1:m5"}
{"signature": "def _set_value(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=bitarray,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:value>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__value = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for value, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/grace_lsa/tlvs/tlv/unknown_tlv/state/value (binary)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_value is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_value() directly.\n\nYANG Description: The value portion of the unknwon TLV", "id": "f23029:c1:m9"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/grace_lsa/tlvs/tlv/unknown_tlv/state (container)\n\nYANG Description: Contents of an unknown TLV within the LSA", "id": "f23030:c0:m2"}
{"signature": "def _get_link_id(self):", "body": "return self.__link_id<EOL>", "docstring": "Getter method for link_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_link/state/link_id (yang:dotted-quad)\n\n    YANG Description: The identifier for the link specified. The value of the link\nidentifier is dependent upon the type of the LSA. The value is\nspecified to be, per sub-type:\n 1) Neighbouring router's router ID.\n 2) IP address of DR.\n 3) IP network address.\n 4) Neighbouring router router's ID.", "id": "f23032:c0:m5"}
{"signature": "def _get_link_type(self):", "body": "return self.__link_type<EOL>", "docstring": "Getter method for link_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_link/state/link_type (identityref)\n\nYANG Description: The type of link with which extended attributes are associated", "id": "f23032:c1:m2"}
{"signature": "def _set_link_data(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__link_data = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for link_data, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_link/state/link_data (union)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_link_data is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_link_data() directly.\n\n    YANG Description: The data associated with the link type. The value is\ndependent upon the subtype of the LSA. When the connection is\nto a stub network it represents the mask; for p2p connections\nthat are unnumbered it represents the ifIndex value of the\nrouter's interface; for all other connections it represents\nthe local system's IP address", "id": "f23032:c1:m9"}
{"signature": "def _get_link_data(self):", "body": "return self.__link_data<EOL>", "docstring": "Getter method for link_data, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_link/state/link_data (union)\n\n    YANG Description: The data associated with the link type. The value is\ndependent upon the subtype of the LSA. When the connection is\nto a stub network it represents the mask; for p2p connections\nthat are unnumbered it represents the ifIndex value of the\nrouter's interface; for all other connections it represents\nthe local system's IP address", "id": "f23032:c0:m8"}
{"signature": "def _get_link_type(self):", "body": "return self.__link_type<EOL>", "docstring": "Getter method for link_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_link/state/link_type (identityref)\n\nYANG Description: The type of link with which extended attributes are associated", "id": "f23032:c0:m2"}
{"signature": "def _set_tlv(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>False,<EOL>tlv.tlv,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT:False>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__tlv = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for tlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_link/tlvs/tlv (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_tlv is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_tlv() directly.\n\nYANG Description: List of TLVs within the Extended Link LSA", "id": "f23033:c0:m3"}
{"signature": "def _get_sid_value(self):", "body": "return self.__sid_value<EOL>", "docstring": "Getter method for sid_value, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_link/tlvs/tlv/adjacency_sid/state/sid_value (uint32)\n\n    YANG Description: The value of the binding included within the sub-TLV. The type of\nthis binding is indicated by the type leaf.", "id": "f23034:c1:m11"}
{"signature": "def _get_multi_topology_identifier(self):", "body": "return self.__multi_topology_identifier<EOL>", "docstring": "Getter method for multi_topology_identifier, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_link/tlvs/tlv/adjacency_sid/state/multi_topology_identifier (uint8)\n\n    YANG Description: The multi-topology identifier with which the adjacency SID is\nassociated", "id": "f23034:c1:m17"}
{"signature": "def _get_group(self):", "body": "return self.__group<EOL>", "docstring": "Getter method for group, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_link/tlvs/tlv/adjacency_sid/state/group (boolean)\n\n    YANG Description: When this flag is set it indicates that the adjacency SID refers to\na group of adjacencies that have a common value", "id": "f23034:c0:m5"}
{"signature": "def _set_backup(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__backup = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for backup, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_link/tlvs/tlv/adjacency_sid/state/backup (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_backup is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_backup() directly.\n\n    YANG Description: When this flag is set, it indicates that the adjacency SID refers to\nan adjacency which is eligible for protection", "id": "f23034:c0:m3"}
{"signature": "def _get_multi_topology_identifier(self):", "body": "return self.__multi_topology_identifier<EOL>", "docstring": "Getter method for multi_topology_identifier, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_link/tlvs/tlv/adjacency_sid/state/multi_topology_identifier (uint8)\n\n    YANG Description: The multi-topology identifier with which the adjacency SID is\nassociated", "id": "f23034:c0:m17"}
{"signature": "def _set_group(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__group = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for group, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_link/tlvs/tlv/adjacency_sid/state/group (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_group is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_group() directly.\n\n    YANG Description: When this flag is set it indicates that the adjacency SID refers to\na group of adjacencies that have a common value", "id": "f23034:c0:m6"}
{"signature": "def _set_multi_topology_identifier(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__multi_topology_identifier = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for multi_topology_identifier, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_link/tlvs/tlv/adjacency_sid/state/multi_topology_identifier (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_multi_topology_identifier is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_multi_topology_identifier() directly.\n\n    YANG Description: The multi-topology identifier with which the adjacency SID is\nassociated", "id": "f23034:c1:m18"}
{"signature": "def _set_sid_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__sid_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for sid_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_link/tlvs/tlv/adjacency_sid/state/sid_type (oc-ospf-types:sr-sid-type)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_sid_type is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_sid_type() directly.\n\nYANG Description: The type of the value contained within the sub-TLV", "id": "f23034:c0:m9"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_link/tlvs/tlv/adjacency_sid/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters relating to an Adjacency SID", "id": "f23035:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_link/tlvs/tlv/adjacency_sid/state (container)\n\nYANG Description: State parameters relating to an Adjacency SID", "id": "f23035:c0:m2"}
{"signature": "def _set_unknown_tlv(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=unknown_tlv.unknown_tlv,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__unknown_tlv = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for unknown_tlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_link/tlvs/tlv/unknown_tlv (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_unknown_tlv is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_unknown_tlv() directly.\n\n    YANG Description: An unknown TLV within the context. Unknown TLVs are\ndefined to be the set of TLVs that are not modelled\nwithin the OpenConfig model, or are unknown to the\nlocal system such that it cannot decode their value.", "id": "f23037:c1:m6"}
{"signature": "def _get_adjacency_sid(self):", "body": "return self.__adjacency_sid<EOL>", "docstring": "Getter method for adjacency_sid, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_link/tlvs/tlv/adjacency_sid (container)\n\n    YANG Description: Parameters relating to an Adjacency SID sub-TLV of the\nextended link LSA", "id": "f23037:c1:m8"}
{"signature": "def _set_length(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__length = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for length, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_link/tlvs/tlv/unknown_tlv/state/length (uint16)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_length is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_length() directly.\n\nYANG Description: The length value of the unknown TLV", "id": "f23038:c1:m6"}
{"signature": "def _set_value(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=bitarray,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:value>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__value = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for value, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_link/tlvs/tlv/unknown_tlv/state/value (binary)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_value is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_value() directly.\n\nYANG Description: The value portion of the unknwon TLV", "id": "f23038:c1:m9"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_link/tlvs/tlv/unknown_tlv/state (container)\n\nYANG Description: Contents of an unknown TLV within the LSA", "id": "f23039:c0:m2"}
{"signature": "def _get_tlvs(self):", "body": "return self.__tlvs<EOL>", "docstring": "Getter method for tlvs, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_link/tlvs (container)\n\nYANG Description: TLVs contained within the Extended Link LSA", "id": "f23040:c1:m5"}
{"signature": "def _get_tlvs(self):", "body": "return self.__tlvs<EOL>", "docstring": "Getter method for tlvs, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/extended_link/tlvs (container)\n\nYANG Description: TLVs contained within the Extended Link LSA", "id": "f23040:c0:m5"}
{"signature": "def _set_tlv(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>False,<EOL>tlv.tlv,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT:False>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__tlv = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for tlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_tlv is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_tlv() directly.\n\nYANG Description: The Type-Length-Value tuples included in the TE LSA", "id": "f23041:c0:m3"}
{"signature": "def _set_tlv(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>False,<EOL>tlv.tlv,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT:False>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__tlv = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for tlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_tlv is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_tlv() directly.\n\nYANG Description: The Type-Length-Value tuples included in the TE LSA", "id": "f23041:c1:m3"}
{"signature": "def _get_tlv(self):", "body": "return self.__tlv<EOL>", "docstring": "Getter method for tlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv (list)\n\nYANG Description: The Type-Length-Value tuples included in the TE LSA", "id": "f23041:c0:m2"}
{"signature": "def _get_tlv(self):", "body": "return self.__tlv<EOL>", "docstring": "Getter method for tlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv (list)\n\nYANG Description: The Type-Length-Value tuples included in the TE LSA", "id": "f23041:c1:m2"}
{"signature": "def _get_sub_tlvs(self):", "body": "return self.__sub_tlvs<EOL>", "docstring": "Getter method for sub_tlvs, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/link/sub_tlvs (container)\n\nYANG Description: Sub-TLVs included in the Link TLV", "id": "f23042:c1:m2"}
{"signature": "def _get_unknown_value(self):", "body": "return self.__unknown_value<EOL>", "docstring": "Getter method for unknown_value, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/link/sub_tlvs/sub_tlv/state/unknown_value (binary)\n\nYANG Description: The binary contents of the unknown TLV", "id": "f23043:c1:m8"}
{"signature": "def _set_maximum_reservable_bandwidth(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=bitarray, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__maximum_reservable_bandwidth = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for maximum_reservable_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/link/sub_tlvs/sub_tlv/state/maximum_reservable_bandwidth (oc-types:ieeefloat32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_maximum_reservable_bandwidth is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_maximum_reservable_bandwidth() directly.\n\n    YANG Description: The maximum reservable bandwidth for the link. This value represents\nthe total bandwidth which may be used for traffic engineering\npurposes. The value may exceed the maximum-bandwidth value\nin cases where the link is oversubscribed. The value is reflected as\na 32-bit IEEE floating-point number", "id": "f23043:c0:m30"}
{"signature": "def _set_unknown_value(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=bitarray,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__unknown_value = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for unknown_value, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/link/sub_tlvs/sub_tlv/state/unknown_value (binary)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_unknown_value is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_unknown_value() directly.\n\nYANG Description: The binary contents of the unknown TLV", "id": "f23043:c1:m9"}
{"signature": "def _set_unknown_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__unknown_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for unknown_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/link/sub_tlvs/sub_tlv/state/unknown_type (uint16)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_unknown_type is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_unknown_type() directly.\n\nYANG Description: The value of the type field of an unknown sub-TLV", "id": "f23043:c1:m6"}
{"signature": "def _get_maximum_bandwidth(self):", "body": "return self.__maximum_bandwidth<EOL>", "docstring": "Getter method for maximum_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/link/sub_tlvs/sub_tlv/state/maximum_bandwidth (oc-types:ieeefloat32)\n\n    YANG Description: The maximum bandwidth of the link. This value reflects the actual\nbandwidth of the link expressed asn IEEE 32-bit floating point\nnumber", "id": "f23043:c0:m26"}
{"signature": "def _get_maximum_reservable_bandwidth(self):", "body": "return self.__maximum_reservable_bandwidth<EOL>", "docstring": "Getter method for maximum_reservable_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/link/sub_tlvs/sub_tlv/state/maximum_reservable_bandwidth (oc-types:ieeefloat32)\n\n    YANG Description: The maximum reservable bandwidth for the link. This value represents\nthe total bandwidth which may be used for traffic engineering\npurposes. The value may exceed the maximum-bandwidth value\nin cases where the link is oversubscribed. The value is reflected as\na 32-bit IEEE floating-point number", "id": "f23043:c1:m29"}
{"signature": "def _get_maximum_bandwidth(self):", "body": "return self.__maximum_bandwidth<EOL>", "docstring": "Getter method for maximum_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/link/sub_tlvs/sub_tlv/state/maximum_bandwidth (oc-types:ieeefloat32)\n\n    YANG Description: The maximum bandwidth of the link. This value reflects the actual\nbandwidth of the link expressed asn IEEE 32-bit floating point\nnumber", "id": "f23043:c1:m26"}
{"signature": "def _get_unknown_value(self):", "body": "return self.__unknown_value<EOL>", "docstring": "Getter method for unknown_value, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/link/sub_tlvs/sub_tlv/state/unknown_value (binary)\n\nYANG Description: The binary contents of the unknown TLV", "id": "f23043:c0:m8"}
{"signature": "def _set_local_ip_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__local_ip_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for local_ip_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/link/sub_tlvs/sub_tlv/state/local_ip_address (inet:ipv4-address-no-zone)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_local_ip_address is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_local_ip_address() directly.\n\n    YANG Description: The IP address(es) of the local system that correspond to the\nspecified TE link", "id": "f23043:c0:m18"}
{"signature": "def _get_link_type(self):", "body": "return self.__link_type<EOL>", "docstring": "Getter method for link_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/link/sub_tlvs/sub_tlv/state/link_type (enumeration)\n\n    YANG Description: The type of the link that is being described by the TE LSA Link\nsub-TLV", "id": "f23043:c1:m11"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/link/sub_tlvs/sub_tlv/state/type (union)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_type() directly.\n\n    YANG Description: The sub-TLV type specified in the Link TLV. When the value is\nknown by the local system, a canonical name of the sub-TLV is utilised\n- the special UNKNOWN value indicates that the system did not\nsupport the sub-TLV type received in the LSA.", "id": "f23043:c0:m3"}
{"signature": "def _get_link_id(self):", "body": "return self.__link_id<EOL>", "docstring": "Getter method for link_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/link/sub_tlvs/sub_tlv/state/link_id (yang:dotted-quad)\n\n    YANG Description: The ID of the remote system. For point-to-point links, this is the\nrouter ID of the neighbor. For multi-access links it is the address\nof the designated router.", "id": "f23043:c0:m14"}
{"signature": "def _get_unknown_type(self):", "body": "return self.__unknown_type<EOL>", "docstring": "Getter method for unknown_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/link/sub_tlvs/sub_tlv/state/unknown_type (uint16)\n\nYANG Description: The value of the type field of an unknown sub-TLV", "id": "f23043:c1:m5"}
{"signature": "def _get_unknown_subtlv(self):", "body": "return self.__unknown_subtlv<EOL>", "docstring": "Getter method for unknown_subtlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/link/sub_tlvs/sub_tlv/unknown_subtlv (container)\n\n    YANG Description: An unknown SubTLV within the context. Unknown Sub-TLV\nare defined to be the set of SubTLVs that are not modelled\nby the OpenConfig schema, or are unknown to the local system\nsuch that it cannot decode their value.", "id": "f23044:c0:m5"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/link/sub_tlvs/sub_tlv/state (container)\n\nYANG Description: State parameters of the Link Sub-TLV", "id": "f23044:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/link/sub_tlvs/sub_tlv/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of the Link Sub-TLV", "id": "f23044:c0:m3"}
{"signature": "def _get_length(self):", "body": "return self.__length<EOL>", "docstring": "Getter method for length, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/link/sub_tlvs/sub_tlv/unknown_subtlv/state/length (uint16)\n\nYANG Description: The length value of the unknown TLV", "id": "f23045:c1:m5"}
{"signature": "def _set_value(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=bitarray,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:value>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__value = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for value, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/link/sub_tlvs/sub_tlv/unknown_subtlv/state/value (binary)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_value is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_value() directly.\n\nYANG Description: The value portion of the unknwon TLV", "id": "f23045:c1:m9"}
{"signature": "def _get_value(self):", "body": "return self.__value<EOL>", "docstring": "Getter method for value, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/link/sub_tlvs/sub_tlv/unknown_subtlv/state/value (binary)\n\nYANG Description: The value portion of the unknwon TLV", "id": "f23045:c0:m8"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/link/sub_tlvs/sub_tlv/unknown_subtlv/state/type (uint16)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_type is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_type() directly.\n\nYANG Description: The type value of the unknown TLV", "id": "f23045:c0:m3"}
{"signature": "def _set_length(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__length = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for length, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/link/sub_tlvs/sub_tlv/unknown_subtlv/state/length (uint16)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_length is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_length() directly.\n\nYANG Description: The length value of the unknown TLV", "id": "f23045:c0:m6"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/link/sub_tlvs/sub_tlv/unknown_subtlv/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Contents of an unknown TLV within the LSA", "id": "f23046:c0:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/link/sub_tlvs/sub_tlv/unknown_subtlv/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Contents of an unknown TLV within the LSA", "id": "f23046:c1:m3"}
{"signature": "def _set_bit_index(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__bit_index = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for bit_index, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/link/sub_tlvs/sub_tlv/administrative_groups/admin_group/state/bit_index (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_bit_index is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_bit_index() directly.\n\n    YANG Description: The index of the bit within the 32-bit administrative group field\nof the Administrative Group sub-TLV of the Traffic Engineering LSA", "id": "f23048:c1:m3"}
{"signature": "def _get_set_(self):", "body": "return self.__set_<EOL>", "docstring": "Getter method for set_, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/link/sub_tlvs/sub_tlv/administrative_groups/admin_group/state/set (boolean)\n\nYANG Description: Whether the bit is set within the administrative group field", "id": "f23048:c1:m5"}
{"signature": "def _get_bit_index(self):", "body": "return self.__bit_index<EOL>", "docstring": "Getter method for bit_index, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/link/sub_tlvs/sub_tlv/administrative_groups/admin_group/state/bit_index (uint8)\n\n    YANG Description: The index of the bit within the 32-bit administrative group field\nof the Administrative Group sub-TLV of the Traffic Engineering LSA", "id": "f23048:c1:m2"}
{"signature": "def _set_set_(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__set_ = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for set_, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/link/sub_tlvs/sub_tlv/administrative_groups/admin_group/state/set (boolean)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_set_ is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_set_() directly.\n\nYANG Description: Whether the bit is set within the administrative group field", "id": "f23048:c1:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/link/sub_tlvs/sub_tlv/administrative_groups/admin_group/state (container)\n\n    YANG Description: State parameters relating to the administrative\ngroups being described for the link", "id": "f23049:c0:m5"}
{"signature": "def _get_bit_index(self):", "body": "return self.__bit_index<EOL>", "docstring": "Getter method for bit_index, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/link/sub_tlvs/sub_tlv/administrative_groups/admin_group/bit_index (leafref)\n\nYANG Description: A reference to the bit index being described", "id": "f23049:c0:m2"}
{"signature": "def _get_unreserved_bandwidth(self):", "body": "return self.__unreserved_bandwidth<EOL>", "docstring": "Getter method for unreserved_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/link/sub_tlvs/sub_tlv/unreserved_bandwidths/unreserved_bandwidth (list)\n\nYANG Description: The unreserved bandwidth at each priority level", "id": "f23050:c0:m2"}
{"signature": "def _set_unreserved_bandwidth(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>unreserved_bandwidth.unreserved_bandwidth,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__unreserved_bandwidth = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for unreserved_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/link/sub_tlvs/sub_tlv/unreserved_bandwidths/unreserved_bandwidth (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_unreserved_bandwidth is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_unreserved_bandwidth() directly.\n\nYANG Description: The unreserved bandwidth at each priority level", "id": "f23050:c0:m3"}
{"signature": "def _get_unreserved_bandwidth(self):", "body": "return self.__unreserved_bandwidth<EOL>", "docstring": "Getter method for unreserved_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/link/sub_tlvs/sub_tlv/unreserved_bandwidths/unreserved_bandwidth/state/unreserved_bandwidth (oc-types:ieeefloat32)\n\n    YANG Description: The unreserved bandwidth for at priority level P, where P is\nequal to the priority of the current list entry. The reservable\nbandwidth at priority P is equal to the sum of the reservable\nbandwidth at all levels 0..P.", "id": "f23051:c1:m5"}
{"signature": "def _set_unreserved_bandwidth(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=bitarray, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__unreserved_bandwidth = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for unreserved_bandwidth, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/link/sub_tlvs/sub_tlv/unreserved_bandwidths/unreserved_bandwidth/state/unreserved_bandwidth (oc-types:ieeefloat32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_unreserved_bandwidth is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_unreserved_bandwidth() directly.\n\n    YANG Description: The unreserved bandwidth for at priority level P, where P is\nequal to the priority of the current list entry. The reservable\nbandwidth at priority P is equal to the sum of the reservable\nbandwidth at all levels 0..P.", "id": "f23051:c1:m6"}
{"signature": "def _get_priority(self):", "body": "return self.__priority<EOL>", "docstring": "Getter method for priority, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/link/sub_tlvs/sub_tlv/unreserved_bandwidths/unreserved_bandwidth/state/priority (uint8)\n\nYANG Description: The priority level being described", "id": "f23051:c0:m2"}
{"signature": "def _set_priority(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__priority = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for priority, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/link/sub_tlvs/sub_tlv/unreserved_bandwidths/unreserved_bandwidth/state/priority (uint8)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_priority is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_priority() directly.\n\nYANG Description: The priority level being described", "id": "f23051:c0:m3"}
{"signature": "def _set_priority(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__priority = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for priority, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/link/sub_tlvs/sub_tlv/unreserved_bandwidths/unreserved_bandwidth/priority (leafref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_priority is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_priority() directly.\n\nYANG Description: A reference to the priority level being described", "id": "f23052:c0:m3"}
{"signature": "def _get_sub_tlv(self):", "body": "return self.__sub_tlv<EOL>", "docstring": "Getter method for sub_tlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/link/sub_tlvs/sub_tlv (list)\n\n    YANG Description: The Sub-TLVs included within the Traffic Engineering\nLSA's sub-TLV", "id": "f23053:c1:m2"}
{"signature": "def _get_sub_tlv(self):", "body": "return self.__sub_tlv<EOL>", "docstring": "Getter method for sub_tlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/link/sub_tlvs/sub_tlv (list)\n\n    YANG Description: The Sub-TLVs included within the Traffic Engineering\nLSA's sub-TLV", "id": "f23053:c0:m2"}
{"signature": "def _set_sub_tlv(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>False,<EOL>sub_tlv.sub_tlv,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT:False>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__sub_tlv = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for sub_tlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/link/sub_tlvs/sub_tlv (list)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_sub_tlv is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_sub_tlv() directly.\n\n    YANG Description: The Sub-TLVs included within the Traffic Engineering\nLSA's sub-TLV", "id": "f23053:c1:m3"}
{"signature": "def _get_type(self):", "body": "return self.__type<EOL>", "docstring": "Getter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/state/type (identityref)\n\nYANG Description: The type of TLV within the Traffic Engineering LSA", "id": "f23054:c1:m2"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/state/type (identityref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_type is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_type() directly.\n\nYANG Description: The type of TLV within the Traffic Engineering LSA", "id": "f23054:c1:m3"}
{"signature": "def _set_unknown_tlv(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=unknown_tlv.unknown_tlv,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__unknown_tlv = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for unknown_tlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/unknown_tlv (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_unknown_tlv is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_unknown_tlv() directly.\n\n    YANG Description: An unknown TLV within the context. Unknown TLVs are\ndefined to be the set of TLVs that are not modelled\nwithin the OpenConfig model, or are unknown to the\nlocal system such that it cannot decode their value.", "id": "f23055:c1:m6"}
{"signature": "def _get_link(self):", "body": "return self.__link<EOL>", "docstring": "Getter method for link, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/link (container)\n\nYANG Description: Parameters included in the Link TLV", "id": "f23055:c1:m11"}
{"signature": "def _set_unknown_tlv(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=unknown_tlv.unknown_tlv,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__unknown_tlv = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for unknown_tlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/unknown_tlv (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_unknown_tlv is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_unknown_tlv() directly.\n\n    YANG Description: An unknown TLV within the context. Unknown TLVs are\ndefined to be the set of TLVs that are not modelled\nwithin the OpenConfig model, or are unknown to the\nlocal system such that it cannot decode their value.", "id": "f23055:c0:m6"}
{"signature": "def _get_router_address(self):", "body": "return self.__router_address<EOL>", "docstring": "Getter method for router_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/router_address (container)\n\nYANG Description: Parameters included in the Router Address TLV", "id": "f23055:c0:m8"}
{"signature": "def _get_unknown_tlv(self):", "body": "return self.__unknown_tlv<EOL>", "docstring": "Getter method for unknown_tlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/unknown_tlv (container)\n\n    YANG Description: An unknown TLV within the context. Unknown TLVs are\ndefined to be the set of TLVs that are not modelled\nwithin the OpenConfig model, or are unknown to the\nlocal system such that it cannot decode their value.", "id": "f23055:c0:m5"}
{"signature": "def _set_node_attribute(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=node_attribute.node_attribute,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__node_attribute = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for node_attribute, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/node_attribute (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_node_attribute is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_node_attribute() directly.\n\nYANG Description: Parameters included in the Node Attribute TLV", "id": "f23055:c1:m15"}
{"signature": "def _set_sub_tlvs(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=sub_tlvs.sub_tlvs,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__sub_tlvs = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for sub_tlvs, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/node_attribute/sub_tlvs (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_sub_tlvs is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_sub_tlvs() directly.\n\n    YANG Description: Sub-TLVs of the Node Attribute TLV of the Traffic\nEngineering LSA", "id": "f23056:c1:m3"}
{"signature": "def _set_local_ipv6_addresses(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__local_ipv6_addresses = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for local_ipv6_addresses, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/node_attribute/sub_tlvs/sub_tlv/state/local_ipv6_addresses (inet:ipv6-prefix)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_local_ipv6_addresses is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_local_ipv6_addresses() directly.\n\nYANG Description: The local IPv6 addreses of the node", "id": "f23057:c0:m9"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/node_attribute/sub_tlvs/sub_tlv/state/type (union)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_type() directly.\n\n    YANG Description: The type of the sub-TLV of the Node Attribute TLV contained within\nthe TE LSA. If the local system can interpret the value received the\ncanonical name of the type is utilised, otherwise the special UNKNOWN\nvalue is used", "id": "f23057:c0:m3"}
{"signature": "def _get_local_ipv4_addresses(self):", "body": "return self.__local_ipv4_addresses<EOL>", "docstring": "Getter method for local_ipv4_addresses, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/node_attribute/sub_tlvs/sub_tlv/state/local_ipv4_addresses (inet:ipv4-prefix)\n\nYANG Description: The local IPv4 addresses of the node expressed in CIDR notation", "id": "f23057:c1:m5"}
{"signature": "def _get_local_ipv6_addresses(self):", "body": "return self.__local_ipv6_addresses<EOL>", "docstring": "Getter method for local_ipv6_addresses, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/node_attribute/sub_tlvs/sub_tlv/state/local_ipv6_addresses (inet:ipv6-prefix)\n\nYANG Description: The local IPv6 addreses of the node", "id": "f23057:c1:m8"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/node_attribute/sub_tlvs/sub_tlv/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of the Node Attribute TLV sub-TLV", "id": "f23058:c1:m3"}
{"signature": "def _get_unknown_subtlv(self):", "body": "return self.__unknown_subtlv<EOL>", "docstring": "Getter method for unknown_subtlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/node_attribute/sub_tlvs/sub_tlv/unknown_subtlv (container)\n\n    YANG Description: An unknown SubTLV within the context. Unknown Sub-TLV\nare defined to be the set of SubTLVs that are not modelled\nby the OpenConfig schema, or are unknown to the local system\nsuch that it cannot decode their value.", "id": "f23058:c0:m5"}
{"signature": "def _set_unknown_subtlv(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=unknown_subtlv.unknown_subtlv,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__unknown_subtlv = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for unknown_subtlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/node_attribute/sub_tlvs/sub_tlv/unknown_subtlv (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_unknown_subtlv is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_unknown_subtlv() directly.\n\n    YANG Description: An unknown SubTLV within the context. Unknown Sub-TLV\nare defined to be the set of SubTLVs that are not modelled\nby the OpenConfig schema, or are unknown to the local system\nsuch that it cannot decode their value.", "id": "f23058:c0:m6"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/node_attribute/sub_tlvs/sub_tlv/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of the Node Attribute TLV sub-TLV", "id": "f23058:c0:m3"}
{"signature": "def _get_value(self):", "body": "return self.__value<EOL>", "docstring": "Getter method for value, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/node_attribute/sub_tlvs/sub_tlv/unknown_subtlv/state/value (binary)\n\nYANG Description: The value portion of the unknwon TLV", "id": "f23059:c1:m8"}
{"signature": "def _set_length(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__length = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for length, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/node_attribute/sub_tlvs/sub_tlv/unknown_subtlv/state/length (uint16)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_length is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_length() directly.\n\nYANG Description: The length value of the unknown TLV", "id": "f23059:c0:m6"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/node_attribute/sub_tlvs/sub_tlv/unknown_subtlv/state/type (uint16)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_type is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_type() directly.\n\nYANG Description: The type value of the unknown TLV", "id": "f23059:c1:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/node_attribute/sub_tlvs/sub_tlv/unknown_subtlv/state (container)\n\nYANG Description: Contents of an unknown TLV within the LSA", "id": "f23060:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/node_attribute/sub_tlvs/sub_tlv/unknown_subtlv/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Contents of an unknown TLV within the LSA", "id": "f23060:c1:m3"}
{"signature": "def _set_sub_tlv(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>False,<EOL>sub_tlv.sub_tlv,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT:False>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__sub_tlv = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for sub_tlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/node_attribute/sub_tlvs/sub_tlv (list)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_sub_tlv is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_sub_tlv() directly.\n\n    YANG Description: List of the Sub-TLVs contained within the Node Attribute\nTLV", "id": "f23061:c0:m3"}
{"signature": "def _set_sub_tlv(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>False,<EOL>sub_tlv.sub_tlv,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT:False>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__sub_tlv = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for sub_tlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/node_attribute/sub_tlvs/sub_tlv (list)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_sub_tlv is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_sub_tlv() directly.\n\n    YANG Description: List of the Sub-TLVs contained within the Node Attribute\nTLV", "id": "f23061:c1:m3"}
{"signature": "def _set_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:address>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/router_address/state/address (inet:ipv4-address-no-zone)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_address is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_address() directly.\n\n    YANG Description: A stable IP address of the advertising router, that is always\nreachable when the router is connected to the network. Typically this\nis a loopback address.", "id": "f23062:c1:m3"}
{"signature": "def _get_address(self):", "body": "return self.__address<EOL>", "docstring": "Getter method for address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/router_address/state/address (inet:ipv4-address-no-zone)\n\n    YANG Description: A stable IP address of the advertising router, that is always\nreachable when the router is connected to the network. Typically this\nis a loopback address.", "id": "f23062:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/router_address/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of the router address TLV", "id": "f23063:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/router_address/state (container)\n\nYANG Description: State parameters of the router address TLV", "id": "f23063:c0:m2"}
{"signature": "def _get_length(self):", "body": "return self.__length<EOL>", "docstring": "Getter method for length, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/unknown_tlv/state/length (uint16)\n\nYANG Description: The length value of the unknown TLV", "id": "f23064:c0:m5"}
{"signature": "def _set_value(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=bitarray,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:value>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__value = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for value, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/unknown_tlv/state/value (binary)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_value is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_value() directly.\n\nYANG Description: The value portion of the unknwon TLV", "id": "f23064:c0:m9"}
{"signature": "def _get_value(self):", "body": "return self.__value<EOL>", "docstring": "Getter method for value, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/unknown_tlv/state/value (binary)\n\nYANG Description: The value portion of the unknwon TLV", "id": "f23064:c0:m8"}
{"signature": "def _set_value(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=bitarray,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:value>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__value = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for value, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/unknown_tlv/state/value (binary)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_value is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_value() directly.\n\nYANG Description: The value portion of the unknwon TLV", "id": "f23064:c1:m9"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/unknown_tlv/state/type (uint16)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_type is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_type() directly.\n\nYANG Description: The type value of the unknown TLV", "id": "f23064:c0:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs/tlv/unknown_tlv/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Contents of an unknown TLV within the LSA", "id": "f23065:c0:m3"}
{"signature": "def _set_tlvs(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=tlvs.tlvs,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__tlvs = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for tlvs, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/traffic_engineering/tlvs (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_tlvs is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_tlvs() directly.\n\nYANG Description: The TLVs contained in the TE Opaque LSA", "id": "f23066:c1:m3"}
{"signature": "def _get_length(self):", "body": "return self.__length<EOL>", "docstring": "Getter method for length, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/unknown_tlv/state/length (uint16)\n\nYANG Description: The length value of the unknown TLV", "id": "f23067:c1:m5"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/unknown_tlv/state/type (uint16)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_type is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_type() directly.\n\nYANG Description: The type value of the unknown TLV", "id": "f23067:c1:m3"}
{"signature": "def _set_value(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=bitarray,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:value>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__value = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for value, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/unknown_tlv/state/value (binary)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_value is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_value() directly.\n\nYANG Description: The value portion of the unknwon TLV", "id": "f23067:c0:m9"}
{"signature": "def _get_type(self):", "body": "return self.__type<EOL>", "docstring": "Getter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/unknown_tlv/state/type (uint16)\n\nYANG Description: The type value of the unknown TLV", "id": "f23067:c1:m2"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information/tlvs/tlv/state/type (union)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_type is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_type() directly.\n\nYANG Description: The type of sub-TLV of the Router Information opaque LSA", "id": "f23070:c1:m3"}
{"signature": "def _get_type(self):", "body": "return self.__type<EOL>", "docstring": "Getter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information/tlvs/tlv/state/type (union)\n\nYANG Description: The type of sub-TLV of the Router Information opaque LSA", "id": "f23070:c0:m2"}
{"signature": "def _get_type(self):", "body": "return self.__type<EOL>", "docstring": "Getter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information/tlvs/tlv/state/type (union)\n\nYANG Description: The type of sub-TLV of the Router Information opaque LSA", "id": "f23070:c1:m2"}
{"signature": "def _get_point_to_point_over_lan(self):", "body": "return self.__point_to_point_over_lan<EOL>", "docstring": "Getter method for point_to_point_over_lan, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information/tlvs/tlv/informational_capabilities/state/point_to_point_over_lan (boolean)\n\n    YANG Description: When this leaf is set to true, the advertising system supports treating\nLAN adjacencies as though they were point to point", "id": "f23071:c1:m14"}
{"signature": "def _get_traffic_engineering(self):", "body": "return self.__traffic_engineering<EOL>", "docstring": "Getter method for traffic_engineering, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information/tlvs/tlv/informational_capabilities/state/traffic_engineering (boolean)\n\n    YANG Description: When this leaf is set to true, the advertising system supports OSPFv2\ntraffic engineering capabilities", "id": "f23071:c1:m11"}
{"signature": "def _set_experimental_te(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__experimental_te = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for experimental_te, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information/tlvs/tlv/informational_capabilities/state/experimental_te (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_experimental_te is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_experimental_te() directly.\n\n    YANG Description: When this leaf is set to ture, the advertising system supports the\nexperimental extensions to OSPF for TE described in RFC4973", "id": "f23071:c1:m18"}
{"signature": "def _get_graceful_restart_helper(self):", "body": "return self.__graceful_restart_helper<EOL>", "docstring": "Getter method for graceful_restart_helper, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information/tlvs/tlv/informational_capabilities/state/graceful_restart_helper (boolean)\n\n    YANG Description: When this leaf is set to true, the advertising system is capable of\nbeing a helper for OSPF graceful restart", "id": "f23071:c0:m5"}
{"signature": "def _set_graceful_restart_helper(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__graceful_restart_helper = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for graceful_restart_helper, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information/tlvs/tlv/informational_capabilities/state/graceful_restart_helper (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_graceful_restart_helper is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_graceful_restart_helper() directly.\n\n    YANG Description: When this leaf is set to true, the advertising system is capable of\nbeing a helper for OSPF graceful restart", "id": "f23071:c1:m6"}
{"signature": "def _set_experimental_te(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__experimental_te = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for experimental_te, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information/tlvs/tlv/informational_capabilities/state/experimental_te (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_experimental_te is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_experimental_te() directly.\n\n    YANG Description: When this leaf is set to ture, the advertising system supports the\nexperimental extensions to OSPF for TE described in RFC4973", "id": "f23071:c0:m18"}
{"signature": "def _set_traffic_engineering(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__traffic_engineering = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for traffic_engineering, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information/tlvs/tlv/informational_capabilities/state/traffic_engineering (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_traffic_engineering is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_traffic_engineering() directly.\n\n    YANG Description: When this leaf is set to true, the advertising system supports OSPFv2\ntraffic engineering capabilities", "id": "f23071:c0:m12"}
{"signature": "def _set_traffic_engineering(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__traffic_engineering = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for traffic_engineering, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information/tlvs/tlv/informational_capabilities/state/traffic_engineering (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_traffic_engineering is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_traffic_engineering() directly.\n\n    YANG Description: When this leaf is set to true, the advertising system supports OSPFv2\ntraffic engineering capabilities", "id": "f23071:c1:m12"}
{"signature": "def _get_stub_router(self):", "body": "return self.__stub_router<EOL>", "docstring": "Getter method for stub_router, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information/tlvs/tlv/informational_capabilities/state/stub_router (boolean)\n\n    YANG Description: When this leaf is set to true, the advertising system is able to\nadvertise its status as a stub router", "id": "f23071:c0:m8"}
{"signature": "def _set_point_to_point_over_lan(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__point_to_point_over_lan = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for point_to_point_over_lan, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information/tlvs/tlv/informational_capabilities/state/point_to_point_over_lan (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_point_to_point_over_lan is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_point_to_point_over_lan() directly.\n\n    YANG Description: When this leaf is set to true, the advertising system supports treating\nLAN adjacencies as though they were point to point", "id": "f23071:c0:m15"}
{"signature": "def _get_point_to_point_over_lan(self):", "body": "return self.__point_to_point_over_lan<EOL>", "docstring": "Getter method for point_to_point_over_lan, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information/tlvs/tlv/informational_capabilities/state/point_to_point_over_lan (boolean)\n\n    YANG Description: When this leaf is set to true, the advertising system supports treating\nLAN adjacencies as though they were point to point", "id": "f23071:c0:m14"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information/tlvs/tlv/informational_capabilities/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: State parameters of the informational capabilitis of the\nRI LSA", "id": "f23072:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information/tlvs/tlv/state (container)\n\nYANG Description: Per-TLV state parameters of the RI LSA", "id": "f23073:c0:m2"}
{"signature": "def _set_segment_routing_algorithm(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=segment_routing_algorithm.segment_routing_algorithm,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__segment_routing_algorithm = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for segment_routing_algorithm, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information/tlvs/tlv/segment_routing_algorithm (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_segment_routing_algorithm is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_segment_routing_algorithm() directly.\n\nYANG Description: The algorithms supported for Segment Routing by the local system", "id": "f23073:c1:m15"}
{"signature": "def _get_unknown_tlv(self):", "body": "return self.__unknown_tlv<EOL>", "docstring": "Getter method for unknown_tlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information/tlvs/tlv/unknown_tlv (container)\n\n    YANG Description: An unknown TLV within the context. Unknown TLVs are\ndefined to be the set of TLVs that are not modelled\nwithin the OpenConfig model, or are unknown to the\nlocal system such that it cannot decode their value.", "id": "f23073:c1:m5"}
{"signature": "def _get_node_administrative_tags(self):", "body": "return self.__node_administrative_tags<EOL>", "docstring": "Getter method for node_administrative_tags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information/tlvs/tlv/node_administrative_tags (container)\n\n    YANG Description: Per-node administrative tags associated with the local system\nspecified by the operator", "id": "f23073:c1:m11"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information/tlvs/tlv/state (container)\n\nYANG Description: Per-TLV state parameters of the RI LSA", "id": "f23073:c1:m2"}
{"signature": "def _set_unknown_tlv(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=unknown_tlv.unknown_tlv,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__unknown_tlv = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for unknown_tlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information/tlvs/tlv/unknown_tlv (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_unknown_tlv is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_unknown_tlv() directly.\n\n    YANG Description: An unknown TLV within the context. Unknown TLVs are\ndefined to be the set of TLVs that are not modelled\nwithin the OpenConfig model, or are unknown to the\nlocal system such that it cannot decode their value.", "id": "f23073:c1:m6"}
{"signature": "def _set_informational_capabilities(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=informational_capabilities.informational_capabilities,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__informational_capabilities = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for informational_capabilities, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information/tlvs/tlv/informational_capabilities (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_informational_capabilities is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_informational_capabilities() directly.\n\n    YANG Description: Information related to the capabilities of the advertising\nrouter within the scope that the opaque RI LSA is being\nadvertised", "id": "f23073:c0:m9"}
{"signature": "def _get_segment_routing_algorithm(self):", "body": "return self.__segment_routing_algorithm<EOL>", "docstring": "Getter method for segment_routing_algorithm, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information/tlvs/tlv/segment_routing_algorithm (container)\n\nYANG Description: The algorithms supported for Segment Routing by the local system", "id": "f23073:c1:m14"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information/tlvs/tlv/segment_routing_algorithm/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: State parameters of the Segment Routing algorithm advertised in\nthe RI LSA", "id": "f23075:c0:m3"}
{"signature": "def _set_value(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=bitarray,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:value>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__value = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for value, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information/tlvs/tlv/unknown_tlv/state/value (binary)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_value is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_value() directly.\n\nYANG Description: The value portion of the unknwon TLV", "id": "f23076:c1:m9"}
{"signature": "def _get_value(self):", "body": "return self.__value<EOL>", "docstring": "Getter method for value, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information/tlvs/tlv/unknown_tlv/state/value (binary)\n\nYANG Description: The value portion of the unknwon TLV", "id": "f23076:c1:m8"}
{"signature": "def _set_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:type>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information/tlvs/tlv/unknown_tlv/state/type (uint16)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_type is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_type() directly.\n\nYANG Description: The type value of the unknown TLV", "id": "f23076:c0:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information/tlvs/tlv/unknown_tlv/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Contents of an unknown TLV within the LSA", "id": "f23077:c1:m3"}
{"signature": "def _set_tlv(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>False,<EOL>tlv.tlv,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT:False>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__tlv = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for tlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information/tlvs/tlv/segment_routing_sid_label_range/tlvs/tlv (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_tlv is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_tlv() directly.\n\nYANG Description: Sub-TLVs of the SID/Label range TLV", "id": "f23078:c1:m3"}
{"signature": "def _get_type(self):", "body": "return self.__type<EOL>", "docstring": "Getter method for type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information/tlvs/tlv/segment_routing_sid_label_range/tlvs/tlv/state/type (union)\n\n    YANG Description: The type of the sub-TLV received by the local system within the\nSR SID/Label Range TLV of the RI LSA", "id": "f23079:c1:m2"}
{"signature": "def _get_range_size(self):", "body": "return self.__range_size<EOL>", "docstring": "Getter method for range_size, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information/tlvs/tlv/segment_routing_sid_label_range/tlvs/tlv/state/range_size (uint32)\n\n    YANG Description: The number of entries within the range being described within the\nSID/Label range TLV", "id": "f23079:c0:m5"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information/tlvs/tlv/segment_routing_sid_label_range/tlvs/tlv/sid_label/state (container)\n\n    YANG Description: State parameters of the SID/Label sub-TLV of the SR/Label\nrange TLV of the RI LSA", "id": "f23081:c0:m2"}
{"signature": "def _set_sid_label(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=sid_label.sid_label,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__sid_label = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for sid_label, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information/tlvs/tlv/segment_routing_sid_label_range/tlvs/tlv/sid_label (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_sid_label is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_sid_label() directly.\n\n    YANG Description: Sub-TLV used to advertise the SID or label associated with the\nsubset of the SRGB being advertised", "id": "f23082:c1:m9"}
{"signature": "def _get_unknown_tlv(self):", "body": "return self.__unknown_tlv<EOL>", "docstring": "Getter method for unknown_tlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information/tlvs/tlv/segment_routing_sid_label_range/tlvs/tlv/unknown_tlv (container)\n\n    YANG Description: An unknown TLV within the context. Unknown TLVs are\ndefined to be the set of TLVs that are not modelled\nwithin the OpenConfig model, or are unknown to the\nlocal system such that it cannot decode their value.", "id": "f23082:c0:m2"}
{"signature": "def _get_unknown_tlv(self):", "body": "return self.__unknown_tlv<EOL>", "docstring": "Getter method for unknown_tlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information/tlvs/tlv/segment_routing_sid_label_range/tlvs/tlv/unknown_tlv (container)\n\n    YANG Description: An unknown TLV within the context. Unknown TLVs are\ndefined to be the set of TLVs that are not modelled\nwithin the OpenConfig model, or are unknown to the\nlocal system such that it cannot decode their value.", "id": "f23082:c1:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information/tlvs/tlv/segment_routing_sid_label_range/tlvs/tlv/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of the sub-TLVs of the SR/Label range TLV", "id": "f23082:c1:m6"}
{"signature": "def _set_unknown_tlv(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=unknown_tlv.unknown_tlv,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__unknown_tlv = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for unknown_tlv, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information/tlvs/tlv/segment_routing_sid_label_range/tlvs/tlv/unknown_tlv (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_unknown_tlv is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_unknown_tlv() directly.\n\n    YANG Description: An unknown TLV within the context. Unknown TLVs are\ndefined to be the set of TLVs that are not modelled\nwithin the OpenConfig model, or are unknown to the\nlocal system such that it cannot decode their value.", "id": "f23082:c1:m3"}
{"signature": "def _get_length(self):", "body": "return self.__length<EOL>", "docstring": "Getter method for length, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information/tlvs/tlv/segment_routing_sid_label_range/tlvs/tlv/unknown_tlv/state/length (uint16)\n\nYANG Description: The length value of the unknown TLV", "id": "f23083:c1:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information/tlvs/tlv/segment_routing_sid_label_range/tlvs/tlv/unknown_tlv/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Contents of an unknown TLV within the LSA", "id": "f23084:c1:m3"}
{"signature": "def _get_tlvs(self):", "body": "return self.__tlvs<EOL>", "docstring": "Getter method for tlvs, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information/tlvs/tlv/segment_routing_sid_label_range/tlvs (container)\n\nYANG Description: Sub-TLVs of the SID/Label range TLV of the RI LSA", "id": "f23085:c0:m2"}
{"signature": "def _get_tlvs(self):", "body": "return self.__tlvs<EOL>", "docstring": "Getter method for tlvs, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information/tlvs/tlv/segment_routing_sid_label_range/tlvs (container)\n\nYANG Description: Sub-TLVs of the SID/Label range TLV of the RI LSA", "id": "f23085:c1:m2"}
{"signature": "def _get_administrative_tags(self):", "body": "return self.__administrative_tags<EOL>", "docstring": "Getter method for administrative_tags, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information/tlvs/tlv/node_administrative_tags/state/administrative_tags (uint32)\n\n    YANG Description: The set of administrative tags assigned to the local system by\nthe network operator. The meaning of these tags is opaque to OSPF\n- and their interpretation is per-domain specific", "id": "f23086:c1:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information/tlvs/tlv/node_administrative_tags/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: State parameters of the node administrative tags advertised\nin the RI LSA", "id": "f23087:c1:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information/tlvs/tlv/node_administrative_tags/state (container)\n\n    YANG Description: State parameters of the node administrative tags advertised\nin the RI LSA", "id": "f23087:c1:m2"}
{"signature": "def _get_tlvs(self):", "body": "return self.__tlvs<EOL>", "docstring": "Getter method for tlvs, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/opaque_lsa/router_information/tlvs (container)\n\nYANG Description: The TLVs included within the Router Information LSA.", "id": "f23088:c0:m2"}
{"signature": "def _set_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/as_external_lsa/state/metric (oc-ospf-types:ospf-metric)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_metric is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_metric() directly.\n\n    YANG Description: The cost to reach the external network specified. The exact\ninterpretation of this cost is dependent on the type of\nmetric specified", "id": "f23089:c1:m9"}
{"signature": "def _get_mask(self):", "body": "return self.__mask<EOL>", "docstring": "Getter method for mask, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/as_external_lsa/state/mask (uint8)\n\nYANG Description: The subnet mask for the advertised destination", "id": "f23089:c0:m2"}
{"signature": "def _set_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/as_external_lsa/state/metric (oc-ospf-types:ospf-metric)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_metric is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_metric() directly.\n\n    YANG Description: The cost to reach the external network specified. The exact\ninterpretation of this cost is dependent on the type of\nmetric specified", "id": "f23089:c0:m9"}
{"signature": "def _set_external_route_tag(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__external_route_tag = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for external_route_tag, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/as_external_lsa/state/external_route_tag (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_external_route_tag is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_external_route_tag() directly.\n\n    YANG Description: An opaque tag that set by the LSA originator to carry\ninformation relating to the external route", "id": "f23089:c1:m15"}
{"signature": "def _set_type_of_service(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>type_of_service.type_of_service,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__type_of_service = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for type_of_service, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/as_external_lsa/types_of_service/type_of_service (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_type_of_service is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_type_of_service() directly.\n\nYANG Description: Per-type of service parameters for the AS External LSA", "id": "f23090:c1:m3"}
{"signature": "def _get_type_of_service(self):", "body": "return self.__type_of_service<EOL>", "docstring": "Getter method for type_of_service, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/as_external_lsa/types_of_service/type_of_service (list)\n\nYANG Description: Per-type of service parameters for the AS External LSA", "id": "f23090:c0:m2"}
{"signature": "def _set_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/as_external_lsa/types_of_service/type_of_service/state/metric (oc-ospf-types:ospf-metric)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_metric is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_metric() directly.\n\n    YANG Description: The metric value to be used for the TOS specified. This value\nrepresents the cost of use of the link for the specific type\nof service.", "id": "f23091:c0:m12"}
{"signature": "def _set_external_route_tag(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__external_route_tag = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for external_route_tag, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/as_external_lsa/types_of_service/type_of_service/state/external_route_tag (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_external_route_tag is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_external_route_tag() directly.\n\n    YANG Description: An opaque tag that set by the LSA originator to carry\ninformation relating to the external route", "id": "f23091:c0:m6"}
{"signature": "def _set_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/as_external_lsa/types_of_service/type_of_service/state/metric (oc-ospf-types:ospf-metric)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_metric is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_metric() directly.\n\n    YANG Description: The metric value to be used for the TOS specified. This value\nrepresents the cost of use of the link for the specific type\nof service.", "id": "f23091:c1:m12"}
{"signature": "def _set_forwarding_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__forwarding_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for forwarding_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/as_external_lsa/types_of_service/type_of_service/state/forwarding_address (inet:ipv4-address-no-zone)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_forwarding_address is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_forwarding_address() directly.\n\n    YANG Description: The destination to which traffic for the external prefix\nshould be advertised. When this value is set to 0.0.0.0 then\ntraffic should be forwarded to the LSA's originator", "id": "f23091:c1:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/as_external_lsa/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters for the AS external LSA", "id": "f23093:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/as_external_lsa/state (container)\n\nYANG Description: State parameters for the AS external LSA", "id": "f23093:c0:m2"}
{"signature": "def _set_attached_router(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__attached_router = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for attached_router, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/network_lsa/state/attached_router (yang:dotted-quad)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_attached_router is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_attached_router() directly.\n\n    YANG Description: A list of the router ID of the routers that are attached to\nthe network described by the Network LSA", "id": "f23094:c0:m6"}
{"signature": "def _set_network_mask(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__network_mask = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for network_mask, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/network_lsa/state/network_mask (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_network_mask is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_network_mask() directly.\n\n    YANG Description: The mask of the network described by the Network LSA\nrepresented as a CIDR mask.", "id": "f23094:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/network_lsa/state (container)\n\nYANG Description: State parameters of the network LSA", "id": "f23095:c1:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/network_lsa/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of the network LSA", "id": "f23095:c1:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/network_lsa/state (container)\n\nYANG Description: State parameters of the network LSA", "id": "f23095:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa/network_lsa/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters of the network LSA", "id": "f23095:c0:m3"}
{"signature": "def _get_lsa(self):", "body": "return self.__lsa<EOL>", "docstring": "Getter method for lsa, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa (list)\n\n    YANG Description: List of the LSAs of a specified type in the\nLSDB for the specified area", "id": "f23096:c1:m2"}
{"signature": "def _set_lsa(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>lsa.lsa,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__lsa = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for lsa, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type/lsas/lsa (list)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_lsa is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_lsa() directly.\n\n    YANG Description: List of the LSAs of a specified type in the\nLSDB for the specified area", "id": "f23096:c0:m3"}
{"signature": "def _get_lsa_type(self):", "body": "return self.__lsa_type<EOL>", "docstring": "Getter method for lsa_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/lsa_types/lsa_type (list)\n\n    YANG Description: List of LSA types in the LSDB for the specified\narea", "id": "f23097:c1:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: Operational state parameters relating to the OSPFv2\narea", "id": "f23098:c0:m3"}
{"signature": "def _set_identifier(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__identifier = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for identifier, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/config/identifier (oc-ospf-types:ospf-area-identifier)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_identifier is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_identifier() directly.\n\n    YANG Description: An identifier for the OSPFv2 area - described as either a\n32-bit unsigned integer, or a dotted-quad", "id": "f23099:c0:m3"}
{"signature": "def _get_identifier(self):", "body": "return self.__identifier<EOL>", "docstring": "Getter method for identifier, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/config/identifier (oc-ospf-types:ospf-area-identifier)\n\n    YANG Description: An identifier for the OSPFv2 area - described as either a\n32-bit unsigned integer, or a dotted-quad", "id": "f23099:c1:m2"}
{"signature": "def _set_traffic_engineering_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__traffic_engineering_enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for traffic_engineering_enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/mpls/state/traffic_engineering_enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_traffic_engineering_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_traffic_engineering_enabled() directly.\n\n    YANG Description: Specifies whether traffic engineering extensions should be\nadvertised within the area", "id": "f23100:c0:m3"}
{"signature": "def _set_traffic_engineering_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__traffic_engineering_enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for traffic_engineering_enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/mpls/state/traffic_engineering_enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_traffic_engineering_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_traffic_engineering_enabled() directly.\n\n    YANG Description: Specifies whether traffic engineering extensions should be\nadvertised within the area", "id": "f23100:c1:m3"}
{"signature": "def _set_traffic_engineering_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__traffic_engineering_enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for traffic_engineering_enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/mpls/config/traffic_engineering_enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_traffic_engineering_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_traffic_engineering_enabled() directly.\n\n    YANG Description: Specifies whether traffic engineering extensions should be\nadvertised within the area", "id": "f23101:c1:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/mpls/state (container)\n\n    YANG Description: Operational state parameters relating to MPLS extensions\nfor OSPFv2", "id": "f23102:c1:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/mpls/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: Operational state parameters relating to MPLS extensions\nfor OSPFv2", "id": "f23102:c1:m6"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/mpls/config (container)\n\n    YANG Description: Configuration parameters relating to MPLS extensions for\nOSPFv2", "id": "f23102:c0:m2"}
{"signature": "def _get_id(self):", "body": "return self.__id<EOL>", "docstring": "Getter method for id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/state/id (string)\n\n    YANG Description: An operator-specified string utilised to uniquely\nreference this interface", "id": "f23103:c1:m2"}
{"signature": "def _get_multi_area_adjacency_primary(self):", "body": "return self.__multi_area_adjacency_primary<EOL>", "docstring": "Getter method for multi_area_adjacency_primary, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/state/multi_area_adjacency_primary (boolean)\n\n    YANG Description: When the specified interface is included in more than one\narea's configuration, this leaf marks whether the area should\nbe considered the primary (when the value is true). In the\ncase that this value is false, the area is considered a\nsecondary area.", "id": "f23103:c0:m11"}
{"signature": "def _get_authentication_type(self):", "body": "return self.__authentication_type<EOL>", "docstring": "Getter method for authentication_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/state/authentication_type (string)\n\n    YANG Description: The type of authentication that should be used on this\ninterface", "id": "f23103:c1:m14"}
{"signature": "def _set_network_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__network_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for network_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/state/network_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_network_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_network_type() directly.\n\n    YANG Description: The type of network that OSPFv2 should use for the specified\ninterface.", "id": "f23103:c0:m6"}
{"signature": "def _set_multi_area_adjacency_primary(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:true>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__multi_area_adjacency_primary = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for multi_area_adjacency_primary, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/state/multi_area_adjacency_primary (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_multi_area_adjacency_primary is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_multi_area_adjacency_primary() directly.\n\n    YANG Description: When the specified interface is included in more than one\narea's configuration, this leaf marks whether the area should\nbe considered the primary (when the value is true). In the\ncase that this value is false, the area is considered a\nsecondary area.", "id": "f23103:c0:m12"}
{"signature": "def _set_authentication_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__authentication_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for authentication_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/state/authentication_type (string)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_authentication_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_authentication_type() directly.\n\n    YANG Description: The type of authentication that should be used on this\ninterface", "id": "f23103:c0:m15"}
{"signature": "def _get_priority(self):", "body": "return self.__priority<EOL>", "docstring": "Getter method for priority, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/state/priority (uint8)\n\n    YANG Description: The local system's priority to become the designated\nrouter", "id": "f23103:c0:m8"}
{"signature": "def _get_passive(self):", "body": "return self.__passive<EOL>", "docstring": "Getter method for passive, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/state/passive (boolean)\n\n    YANG Description: When this leaf is set to true, the interface should be\nadvertised within the OSPF area but OSPF adjacencies should\nnot be established over the interface", "id": "f23103:c1:m20"}
{"signature": "def _get_hide_network(self):", "body": "return self.__hide_network<EOL>", "docstring": "Getter method for hide_network, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/state/hide_network (boolean)\n\n    YANG Description: When this leaf is set to true, the network connected to\nthe interface should be hidden from OSPFv2 advertisements\nper the procedure described in RFC6860.", "id": "f23103:c1:m23"}
{"signature": "def _set_multi_area_adjacency_primary(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:true>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__multi_area_adjacency_primary = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for multi_area_adjacency_primary, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/state/multi_area_adjacency_primary (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_multi_area_adjacency_primary is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_multi_area_adjacency_primary() directly.\n\n    YANG Description: When the specified interface is included in more than one\narea's configuration, this leaf marks whether the area should\nbe considered the primary (when the value is true). In the\ncase that this value is false, the area is considered a\nsecondary area.", "id": "f23103:c1:m12"}
{"signature": "def _get_state_changes(self):", "body": "return self.__state_changes<EOL>", "docstring": "Getter method for state_changes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/neighbors/neighbor/state/state_changes (uint32)\n\n    YANG Description: The number of transitions out of the FULL state that this\nneighbor has been through", "id": "f23104:c1:m29"}
{"signature": "def _set_last_established_time(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__last_established_time = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for last_established_time, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/neighbors/neighbor/state/last_established_time (oc-types:timeticks64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_last_established_time is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_last_established_time() directly.\n\n    YANG Description: The time at which the adjacency was last established with\nthe neighbor. That is to say the time at which the\nadjacency last transitioned into the FULL state.\n\nThis value is expressed as the number of seconds, relative to\nthe Unix Epoch (Jan 1, 1970 00:00:00 UTC).", "id": "f23104:c1:m24"}
{"signature": "def _get_state_changes(self):", "body": "return self.__state_changes<EOL>", "docstring": "Getter method for state_changes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/neighbors/neighbor/state/state_changes (uint32)\n\n    YANG Description: The number of transitions out of the FULL state that this\nneighbor has been through", "id": "f23104:c0:m29"}
{"signature": "def _set_backup_designated_router(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__backup_designated_router = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for backup_designated_router, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/neighbors/neighbor/state/backup_designated_router (yang:dotted-quad)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_backup_designated_router is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_backup_designated_router() directly.\n\nYANG Description: The backup designated router for the adjacency.", "id": "f23104:c0:m18"}
{"signature": "def _get_router_id(self):", "body": "return self.__router_id<EOL>", "docstring": "Getter method for router_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/neighbors/neighbor/state/router_id (yang:dotted-quad)\n\nYANG Description: The router ID of the remote system.", "id": "f23104:c0:m2"}
{"signature": "def _get_backup_designated_router(self):", "body": "return self.__backup_designated_router<EOL>", "docstring": "Getter method for backup_designated_router, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/neighbors/neighbor/state/backup_designated_router (yang:dotted-quad)\n\nYANG Description: The backup designated router for the adjacency.", "id": "f23104:c1:m17"}
{"signature": "def _get_dead_time(self):", "body": "return self.__dead_time<EOL>", "docstring": "Getter method for dead_time, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/neighbors/neighbor/state/dead_time (oc-types:timeticks64)\n\n    YANG Description: The time at which this neighbor's adjacency will be\nconsidered dead. This value is expressed as a number of\nseconds since the Unix Epoch", "id": "f23104:c1:m11"}
{"signature": "def _set_dead_time(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__dead_time = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for dead_time, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/neighbors/neighbor/state/dead_time (oc-types:timeticks64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_dead_time is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_dead_time() directly.\n\n    YANG Description: The time at which this neighbor's adjacency will be\nconsidered dead. This value is expressed as a number of\nseconds since the Unix Epoch", "id": "f23104:c0:m12"}
{"signature": "def _get_optional_capabilities(self):", "body": "return self.__optional_capabilities<EOL>", "docstring": "Getter method for optional_capabilities, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/neighbors/neighbor/state/optional_capabilities (yang:hex-string)\n\n    YANG Description: The optional capabilities field received in the Hello\nmessage from the neighbor", "id": "f23104:c1:m20"}
{"signature": "def _set_designated_router(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__designated_router = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for designated_router, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/neighbors/neighbor/state/designated_router (yang:dotted-quad)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_designated_router is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_designated_router() directly.\n\n    YANG Description: The designated router for the adjacency. This device\nadvertises the Network LSA for broadcast and NBMA networks.", "id": "f23104:c0:m15"}
{"signature": "def _get_priority(self):", "body": "return self.__priority<EOL>", "docstring": "Getter method for priority, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/neighbors/neighbor/state/priority (uint8)\n\n    YANG Description: The remote system's priority to become the designated\nrouter", "id": "f23104:c1:m8"}
{"signature": "def _get_priority(self):", "body": "return self.__priority<EOL>", "docstring": "Getter method for priority, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/neighbors/neighbor/state/priority (uint8)\n\n    YANG Description: The remote system's priority to become the designated\nrouter", "id": "f23104:c0:m8"}
{"signature": "def _get_backup_designated_router(self):", "body": "return self.__backup_designated_router<EOL>", "docstring": "Getter method for backup_designated_router, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/neighbors/neighbor/state/backup_designated_router (yang:dotted-quad)\n\nYANG Description: The backup designated router for the adjacency.", "id": "f23104:c0:m17"}
{"signature": "def _set_router_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__router_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for router_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/neighbors/neighbor/state/router_id (yang:dotted-quad)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_router_id is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_router_id() directly.\n\nYANG Description: The router ID of the remote system.", "id": "f23104:c0:m3"}
{"signature": "def _set_designated_router(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__designated_router = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for designated_router, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/neighbors/neighbor/state/designated_router (yang:dotted-quad)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_designated_router is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_designated_router() directly.\n\n    YANG Description: The designated router for the adjacency. This device\nadvertises the Network LSA for broadcast and NBMA networks.", "id": "f23104:c1:m15"}
{"signature": "def _get_metric(self):", "body": "return self.__metric<EOL>", "docstring": "Getter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/neighbors/neighbor/config/metric (oc-ospf-types:ospf-metric)\n\n    YANG Description: The metric that should be considered to the remote neighbor\nover this interface. This configuration is only applicable\nfor multiple-access networks", "id": "f23105:c1:m5"}
{"signature": "def _set_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/neighbors/neighbor/config/metric (oc-ospf-types:ospf-metric)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_metric is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_metric() directly.\n\n    YANG Description: The metric that should be considered to the remote neighbor\nover this interface. This configuration is only applicable\nfor multiple-access networks", "id": "f23105:c0:m6"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/neighbors/neighbor/config (container)\n\n    YANG Description: Configuration parameters relating to the adjacent\nsystem", "id": "f23106:c1:m5"}
{"signature": "def _get_router_id(self):", "body": "return self.__router_id<EOL>", "docstring": "Getter method for router_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/neighbors/neighbor/router_id (leafref)\n\nYANG Description: Reference to the router ID of the adjacent system", "id": "f23106:c1:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/neighbors/neighbor/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: Operational state parameters relating to the adjacent\nsystem", "id": "f23106:c0:m9"}
{"signature": "def _set_router_id(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__router_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for router_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/neighbors/neighbor/router_id (leafref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_router_id is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_router_id() directly.\n\nYANG Description: Reference to the router ID of the adjacent system", "id": "f23106:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/neighbors/neighbor/state (container)\n\n    YANG Description: Operational state parameters relating to the adjacent\nsystem", "id": "f23106:c1:m8"}
{"signature": "def _set_neighbor(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>neighbor.neighbor,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__neighbor = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for neighbor, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/neighbors/neighbor (list)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_neighbor is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_neighbor() directly.\n\n    YANG Description: A neighbor with which an OSPFv2 adjacency has been\nestablished within this area", "id": "f23107:c0:m3"}
{"signature": "def _set_neighbor(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>neighbor.neighbor,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__neighbor = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for neighbor, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/neighbors/neighbor (list)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_neighbor is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_neighbor() directly.\n\n    YANG Description: A neighbor with which an OSPFv2 adjacency has been\nestablished within this area", "id": "f23107:c1:m3"}
{"signature": "def _get_neighbor(self):", "body": "return self.__neighbor<EOL>", "docstring": "Getter method for neighbor, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/neighbors/neighbor (list)\n\n    YANG Description: A neighbor with which an OSPFv2 adjacency has been\nestablished within this area", "id": "f23107:c1:m2"}
{"signature": "def _get_hello_interval(self):", "body": "return self.__hello_interval<EOL>", "docstring": "Getter method for hello_interval, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/timers/state/hello_interval (uint32)\n\n    YANG Description: The number of seconds the local system waits between the\ntransmission of subsequent Hello packets", "id": "f23108:c1:m5"}
{"signature": "def _set_retransmission_interval(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__retransmission_interval = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for retransmission_interval, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/timers/state/retransmission_interval (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_retransmission_interval is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_retransmission_interval() directly.\n\n    YANG Description: The number of seconds that the local system waits before\nretransmitting an unacknowledged LSA.", "id": "f23108:c1:m9"}
{"signature": "def _get_retransmission_interval(self):", "body": "return self.__retransmission_interval<EOL>", "docstring": "Getter method for retransmission_interval, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/timers/state/retransmission_interval (uint32)\n\n    YANG Description: The number of seconds that the local system waits before\nretransmitting an unacknowledged LSA.", "id": "f23108:c1:m8"}
{"signature": "def _set_dead_interval(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__dead_interval = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for dead_interval, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/timers/state/dead_interval (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_dead_interval is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_dead_interval() directly.\n\n    YANG Description: The number of seconds that the local system should let\nelapse before declaring a silent router down", "id": "f23108:c0:m3"}
{"signature": "def _set_hello_interval(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__hello_interval = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for hello_interval, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/timers/config/hello_interval (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_hello_interval is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_hello_interval() directly.\n\n    YANG Description: The number of seconds the local system waits between the\ntransmission of subsequent Hello packets", "id": "f23109:c1:m6"}
{"signature": "def _get_retransmission_interval(self):", "body": "return self.__retransmission_interval<EOL>", "docstring": "Getter method for retransmission_interval, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/timers/config/retransmission_interval (uint32)\n\n    YANG Description: The number of seconds that the local system waits before\nretransmitting an unacknowledged LSA.", "id": "f23109:c1:m8"}
{"signature": "def _get_dead_interval(self):", "body": "return self.__dead_interval<EOL>", "docstring": "Getter method for dead_interval, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/timers/config/dead_interval (uint32)\n\n    YANG Description: The number of seconds that the local system should let\nelapse before declaring a silent router down", "id": "f23109:c1:m2"}
{"signature": "def _get_retransmission_interval(self):", "body": "return self.__retransmission_interval<EOL>", "docstring": "Getter method for retransmission_interval, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/timers/config/retransmission_interval (uint32)\n\n    YANG Description: The number of seconds that the local system waits before\nretransmitting an unacknowledged LSA.", "id": "f23109:c0:m8"}
{"signature": "def _get_hello_interval(self):", "body": "return self.__hello_interval<EOL>", "docstring": "Getter method for hello_interval, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/timers/config/hello_interval (uint32)\n\n    YANG Description: The number of seconds the local system waits between the\ntransmission of subsequent Hello packets", "id": "f23109:c0:m5"}
{"signature": "def _set_retransmission_interval(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__retransmission_interval = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for retransmission_interval, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/timers/config/retransmission_interval (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_retransmission_interval is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_retransmission_interval() directly.\n\n    YANG Description: The number of seconds that the local system waits before\nretransmitting an unacknowledged LSA.", "id": "f23109:c1:m9"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/timers/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: Operational state parameters for OSPFv2 timers on\nthe interface", "id": "f23110:c1:m6"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/timers/config (container)\n\n    YANG Description: Configuration parameters for OSPFv2 timers on the\ninterface", "id": "f23110:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/timers/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: Operational state parameters for OSPFv2 timers on\nthe interface", "id": "f23110:c0:m6"}
{"signature": "def _set_priority(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__priority = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for priority, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/config/priority (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_priority is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_priority() directly.\n\n    YANG Description: The local system's priority to become the designated\nrouter", "id": "f23111:c1:m9"}
{"signature": "def _set_multi_area_adjacency_primary(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:true>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__multi_area_adjacency_primary = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for multi_area_adjacency_primary, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/config/multi_area_adjacency_primary (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_multi_area_adjacency_primary is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_multi_area_adjacency_primary() directly.\n\n    YANG Description: When the specified interface is included in more than one\narea's configuration, this leaf marks whether the area should\nbe considered the primary (when the value is true). In the\ncase that this value is false, the area is considered a\nsecondary area.", "id": "f23111:c0:m12"}
{"signature": "def _set_network_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__network_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for network_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/config/network_type (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_network_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_network_type() directly.\n\n    YANG Description: The type of network that OSPFv2 should use for the specified\ninterface.", "id": "f23111:c0:m6"}
{"signature": "def _get_multi_area_adjacency_primary(self):", "body": "return self.__multi_area_adjacency_primary<EOL>", "docstring": "Getter method for multi_area_adjacency_primary, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/config/multi_area_adjacency_primary (boolean)\n\n    YANG Description: When the specified interface is included in more than one\narea's configuration, this leaf marks whether the area should\nbe considered the primary (when the value is true). In the\ncase that this value is false, the area is considered a\nsecondary area.", "id": "f23111:c1:m11"}
{"signature": "def _set_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:id>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/config/id (string)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_id is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_id() directly.\n\n    YANG Description: An operator-specified string utilised to uniquely\nreference this interface", "id": "f23111:c0:m3"}
{"signature": "def _get_passive(self):", "body": "return self.__passive<EOL>", "docstring": "Getter method for passive, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/config/passive (boolean)\n\n    YANG Description: When this leaf is set to true, the interface should be\nadvertised within the OSPF area but OSPF adjacencies should\nnot be established over the interface", "id": "f23111:c1:m20"}
{"signature": "def _set_passive(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__passive = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for passive, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/config/passive (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_passive is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_passive() directly.\n\n    YANG Description: When this leaf is set to true, the interface should be\nadvertised within the OSPF area but OSPF adjacencies should\nnot be established over the interface", "id": "f23111:c0:m21"}
{"signature": "def _get_passive(self):", "body": "return self.__passive<EOL>", "docstring": "Getter method for passive, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/config/passive (boolean)\n\n    YANG Description: When this leaf is set to true, the interface should be\nadvertised within the OSPF area but OSPF adjacencies should\nnot be established over the interface", "id": "f23111:c0:m20"}
{"signature": "def _get_priority(self):", "body": "return self.__priority<EOL>", "docstring": "Getter method for priority, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/config/priority (uint8)\n\n    YANG Description: The local system's priority to become the designated\nrouter", "id": "f23111:c1:m8"}
{"signature": "def _set_hide_network(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__hide_network = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for hide_network, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/config/hide_network (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_hide_network is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_hide_network() directly.\n\n    YANG Description: When this leaf is set to true, the network connected to\nthe interface should be hidden from OSPFv2 advertisements\nper the procedure described in RFC6860.", "id": "f23111:c1:m24"}
{"signature": "def _set_hide_network(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__hide_network = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for hide_network, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/config/hide_network (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_hide_network is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_hide_network() directly.\n\n    YANG Description: When this leaf is set to true, the network connected to\nthe interface should be hidden from OSPFv2 advertisements\nper the procedure described in RFC6860.", "id": "f23111:c0:m24"}
{"signature": "def _get_interface(self):", "body": "return self.__interface<EOL>", "docstring": "Getter method for interface, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/interface_ref/state/interface (leafref)\n\n    YANG Description: Reference to a base interface.  If a reference to a\nsubinterface is required, this leaf must be specified\nto indicate the base interface.", "id": "f23112:c1:m2"}
{"signature": "def _set_subinterface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__subinterface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for subinterface, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/interface_ref/state/subinterface (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_subinterface is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_subinterface() directly.\n\n    YANG Description: Reference to a subinterface -- this requires the base\ninterface to be specified using the interface leaf in\nthis container.  If only a reference to a base interface\nis requuired, this leaf should not be set.", "id": "f23112:c1:m6"}
{"signature": "def _set_interface(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/interface_ref/state/interface (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_interface is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_interface() directly.\n\n    YANG Description: Reference to a base interface.  If a reference to a\nsubinterface is required, this leaf must be specified\nto indicate the base interface.", "id": "f23112:c0:m3"}
{"signature": "def _get_interface(self):", "body": "return self.__interface<EOL>", "docstring": "Getter method for interface, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/interface_ref/state/interface (leafref)\n\n    YANG Description: Reference to a base interface.  If a reference to a\nsubinterface is required, this leaf must be specified\nto indicate the base interface.", "id": "f23112:c0:m2"}
{"signature": "def _get_interface(self):", "body": "return self.__interface<EOL>", "docstring": "Getter method for interface, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/interface_ref/config/interface (leafref)\n\n    YANG Description: Reference to a base interface.  If a reference to a\nsubinterface is required, this leaf must be specified\nto indicate the base interface.", "id": "f23113:c1:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/interface_ref/state (container)\n\nYANG Description: Operational state for interface-ref", "id": "f23114:c1:m5"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/interface_ref/config (container)\n\nYANG Description: Configured reference to interface / subinterface", "id": "f23114:c1:m2"}
{"signature": "def _set_traffic_engineering_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__traffic_engineering_metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for traffic_engineering_metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/mpls/config/traffic_engineering_metric (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_traffic_engineering_metric is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_traffic_engineering_metric() directly.\n\n    YANG Description: A link metric that should only be considered for traffic\nengineering purposes.", "id": "f23116:c0:m3"}
{"signature": "def _get_traffic_engineering_metric(self):", "body": "return self.__traffic_engineering_metric<EOL>", "docstring": "Getter method for traffic_engineering_metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/mpls/config/traffic_engineering_metric (uint32)\n\n    YANG Description: A link metric that should only be considered for traffic\nengineering purposes.", "id": "f23116:c1:m2"}
{"signature": "def _set_traffic_engineering_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__traffic_engineering_metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for traffic_engineering_metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/mpls/config/traffic_engineering_metric (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_traffic_engineering_metric is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_traffic_engineering_metric() directly.\n\n    YANG Description: A link metric that should only be considered for traffic\nengineering purposes.", "id": "f23116:c1:m3"}
{"signature": "def _set_synchronized(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__synchronized = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for synchronized, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/mpls/igp_ldp_sync/state/synchronized (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_synchronized is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_synchronized() directly.\n\n    YANG Description: When the value of this leaf is set to true, the\nLDP neighbors reachable via this interface are considered\nto be synchronized, and hence the link is considered\nusable by the IGP.", "id": "f23118:c1:m9"}
{"signature": "def _get_synchronized(self):", "body": "return self.__synchronized<EOL>", "docstring": "Getter method for synchronized, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/mpls/igp_ldp_sync/state/synchronized (boolean)\n\n    YANG Description: When the value of this leaf is set to true, the\nLDP neighbors reachable via this interface are considered\nto be synchronized, and hence the link is considered\nusable by the IGP.", "id": "f23118:c1:m8"}
{"signature": "def _get_post_session_up_delay(self):", "body": "return self.__post_session_up_delay<EOL>", "docstring": "Getter method for post_session_up_delay, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/mpls/igp_ldp_sync/config/post_session_up_delay (uint32)\n\n    YANG Description: This leaf specifies a delay, expressed in units of milliseconds,\nbetween the LDP session to the IGP neighbor being established, and\nit being considered synchronized by the IGP.", "id": "f23119:c0:m5"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/mpls/igp_ldp_sync/config/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: When this leaf is set to true, do not utilise this link for\nforwarding via the IGP until such time as LDP adjacencies to\nthe neighbor(s) over the link are established.", "id": "f23119:c1:m3"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/mpls/igp_ldp_sync/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to LDP/IG\nsynchronization.", "id": "f23120:c1:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/mpls/igp_ldp_sync/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: Operational state variables relating to LDP/IGP\nsynchronization", "id": "f23120:c1:m6"}
{"signature": "def _set_id(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:id>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/id (leafref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_id is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_id() directly.\n\nYANG Description: A pointer to the identifier for the interface.", "id": "f23121:c1:m3"}
{"signature": "def _get_lsa_filter(self):", "body": "return self.__lsa_filter<EOL>", "docstring": "Getter method for lsa_filter, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/lsa_filter (container)\n\n    YANG Description: OSPFv2 parameters relating to filtering of LSAs to\nneighbors the specified interface.", "id": "f23121:c0:m20"}
{"signature": "def _get_neighbors(self):", "body": "return self.__neighbors<EOL>", "docstring": "Getter method for neighbors, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/neighbors (container)\n\n    YANG Description: Enclosing container for the list of neighbors that\nan adjacency has been established with on the interface", "id": "f23121:c0:m23"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/state (container)\n\n    YANG Description: Operational state parameters for the interface on which\nOSPFv2 is enabled", "id": "f23121:c1:m8"}
{"signature": "def _get_neighbors(self):", "body": "return self.__neighbors<EOL>", "docstring": "Getter method for neighbors, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/neighbors (container)\n\n    YANG Description: Enclosing container for the list of neighbors that\nan adjacency has been established with on the interface", "id": "f23121:c1:m23"}
{"signature": "def _set_interface_ref(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=interface_ref.interface_ref,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface_ref = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface_ref, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/interface_ref (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_interface_ref is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_interface_ref() directly.\n\nYANG Description: Reference to an interface or subinterface", "id": "f23121:c0:m12"}
{"signature": "def _set_interface_ref(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=interface_ref.interface_ref,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interface_ref = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interface_ref, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/interface_ref (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_interface_ref is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_interface_ref() directly.\n\nYANG Description: Reference to an interface or subinterface", "id": "f23121:c1:m12"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/state (container)\n\n    YANG Description: Operational state parameters for the interface on which\nOSPFv2 is enabled", "id": "f23121:c0:m8"}
{"signature": "def _set_timers(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=timers.timers,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__timers = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for timers, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/timers (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_timers is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_timers() directly.\n\nYANG Description: Timers relating to OSPFv2 on the interface", "id": "f23121:c0:m15"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters for the interface on which\nOSPFv2 is enabled", "id": "f23121:c1:m6"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: Operational state parameters for the interface on which\nOSPFv2 is enabled", "id": "f23121:c0:m9"}
{"signature": "def _get_interface_ref(self):", "body": "return self.__interface_ref<EOL>", "docstring": "Getter method for interface_ref, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/interface_ref (container)\n\nYANG Description: Reference to an interface or subinterface", "id": "f23121:c0:m11"}
{"signature": "def _set_mpls(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=mpls.mpls,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__mpls = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for mpls, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/mpls (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_mpls is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_mpls() directly.\n\n    YANG Description: Configuration and operational state parameters for\nOSPFv2 extensions related to MPLS on the interface.", "id": "f23121:c0:m18"}
{"signature": "def _get_all(self):", "body": "return self.__all<EOL>", "docstring": "Getter method for all, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/lsa_filter/state/all (boolean)\n\n    YANG Description: When this leaf is set to true, all LSAs should be\nfiltered to the neighbours with whom adjacencies are\nformed on the interface.", "id": "f23122:c1:m2"}
{"signature": "def _get_all(self):", "body": "return self.__all<EOL>", "docstring": "Getter method for all, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/lsa_filter/state/all (boolean)\n\n    YANG Description: When this leaf is set to true, all LSAs should be\nfiltered to the neighbours with whom adjacencies are\nformed on the interface.", "id": "f23122:c0:m2"}
{"signature": "def _get_all(self):", "body": "return self.__all<EOL>", "docstring": "Getter method for all, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/lsa_filter/config/all (boolean)\n\n    YANG Description: When this leaf is set to true, all LSAs should be\nfiltered to the neighbours with whom adjacencies are\nformed on the interface.", "id": "f23123:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface/lsa_filter/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: Operational state parameters relating to filtering\nLSAs on the specified interface", "id": "f23124:c1:m6"}
{"signature": "def _get_interface(self):", "body": "return self.__interface<EOL>", "docstring": "Getter method for interface, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces/interface (list)\n\nYANG Description: List of interfaces which are enabled within this area", "id": "f23125:c0:m2"}
{"signature": "def _get_lsdb(self):", "body": "return self.__lsdb<EOL>", "docstring": "Getter method for lsdb, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb (container)\n\nYANG Description: The link-state database for the OSPFv2 area", "id": "f23126:c1:m14"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/state (container)\n\nYANG Description: Operational state parameters relating to an OSPFv2 area", "id": "f23126:c1:m8"}
{"signature": "def _get_identifier(self):", "body": "return self.__identifier<EOL>", "docstring": "Getter method for identifier, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/identifier (leafref)\n\nYANG Description: A reference to the identifier for the area.", "id": "f23126:c1:m2"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration parameters relating to an OSPFv2 area", "id": "f23126:c0:m6"}
{"signature": "def _get_identifier(self):", "body": "return self.__identifier<EOL>", "docstring": "Getter method for identifier, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/identifier (leafref)\n\nYANG Description: A reference to the identifier for the area.", "id": "f23126:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Operational state parameters relating to an OSPFv2 area", "id": "f23126:c0:m9"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/config (container)\n\nYANG Description: Configuration parameters relating to an OSPFv2 area", "id": "f23126:c0:m5"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/config (container)\n\nYANG Description: Configuration parameters relating to an OSPFv2 area", "id": "f23126:c1:m5"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/state (container)\n\nYANG Description: Operational state parameters relating to an OSPFv2 area", "id": "f23126:c0:m8"}
{"signature": "def _set_interfaces(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=interfaces.interfaces,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__interfaces = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for interfaces, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/interfaces (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_interfaces is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_interfaces() directly.\n\n    YANG Description: Enclosing container for a list of interfaces enabled within\nthis area", "id": "f23126:c0:m18"}
{"signature": "def _set_lsdb(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=lsdb.lsdb,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__lsdb = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for lsdb, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/lsdb (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_lsdb is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_lsdb() directly.\n\nYANG Description: The link-state database for the OSPFv2 area", "id": "f23126:c0:m15"}
{"signature": "def _get_state_changes(self):", "body": "return self.__state_changes<EOL>", "docstring": "Getter method for state_changes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/virtual_links/virtual_link/state/state_changes (uint32)\n\n    YANG Description: The number of transitions out of the FULL state that this\nneighbor has been through", "id": "f23127:c0:m26"}
{"signature": "def _get_state_changes(self):", "body": "return self.__state_changes<EOL>", "docstring": "Getter method for state_changes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/virtual_links/virtual_link/state/state_changes (uint32)\n\n    YANG Description: The number of transitions out of the FULL state that this\nneighbor has been through", "id": "f23127:c1:m26"}
{"signature": "def _get_last_established_time(self):", "body": "return self.__last_established_time<EOL>", "docstring": "Getter method for last_established_time, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/virtual_links/virtual_link/state/last_established_time (oc-types:timeticks64)\n\n    YANG Description: The time at which the adjacency was last established with\nthe neighbor. That is to say the time at which the\nadjacency last transitioned into the FULL state.\n\nThis value is expressed as the number of seconds, relative to\nthe Unix Epoch (Jan 1, 1970 00:00:00 UTC).", "id": "f23127:c0:m20"}
{"signature": "def _set_priority(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__priority = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for priority, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/virtual_links/virtual_link/state/priority (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_priority is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_priority() directly.\n\n    YANG Description: The remote system's priority to become the designated\nrouter", "id": "f23127:c1:m6"}
{"signature": "def _set_retranmission_queue_length(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__retranmission_queue_length = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for retranmission_queue_length, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/virtual_links/virtual_link/state/retranmission_queue_length (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_retranmission_queue_length is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_retranmission_queue_length() directly.\n\n    YANG Description: The number of LSAs that are currently in the queue to be\nretransmitted to the neighbor", "id": "f23127:c1:m30"}
{"signature": "def _get_adjacency_state(self):", "body": "return self.__adjacency_state<EOL>", "docstring": "Getter method for adjacency_state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/virtual_links/virtual_link/state/adjacency_state (identityref)\n\nYANG Description: The state of the adjacency with the neighbor.", "id": "f23127:c1:m23"}
{"signature": "def _set_optional_capabilities(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__optional_capabilities = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for optional_capabilities, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/virtual_links/virtual_link/state/optional_capabilities (yang:hex-string)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_optional_capabilities is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_optional_capabilities() directly.\n\n    YANG Description: The optional capabilities field received in the Hello\nmessage from the neighbor", "id": "f23127:c0:m18"}
{"signature": "def _set_optional_capabilities(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__optional_capabilities = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for optional_capabilities, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/virtual_links/virtual_link/state/optional_capabilities (yang:hex-string)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_optional_capabilities is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_optional_capabilities() directly.\n\n    YANG Description: The optional capabilities field received in the Hello\nmessage from the neighbor", "id": "f23127:c1:m18"}
{"signature": "def _get_dead_time(self):", "body": "return self.__dead_time<EOL>", "docstring": "Getter method for dead_time, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/virtual_links/virtual_link/state/dead_time (oc-types:timeticks64)\n\n    YANG Description: The time at which this neighbor's adjacency will be\nconsidered dead. This value is expressed as a number of\nseconds since the Unix Epoch", "id": "f23127:c0:m8"}
{"signature": "def _get_last_established_time(self):", "body": "return self.__last_established_time<EOL>", "docstring": "Getter method for last_established_time, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/virtual_links/virtual_link/state/last_established_time (oc-types:timeticks64)\n\n    YANG Description: The time at which the adjacency was last established with\nthe neighbor. That is to say the time at which the\nadjacency last transitioned into the FULL state.\n\nThis value is expressed as the number of seconds, relative to\nthe Unix Epoch (Jan 1, 1970 00:00:00 UTC).", "id": "f23127:c1:m20"}
{"signature": "def _get_remote_router_id(self):", "body": "return self.__remote_router_id<EOL>", "docstring": "Getter method for remote_router_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/virtual_links/virtual_link/config/remote_router_id (inet:ipv4-address-no-zone)\n\n    YANG Description: The router ID of the device which terminates the remote end\nof the virtual link", "id": "f23128:c0:m2"}
{"signature": "def _set_remote_router_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": \"<STR_LIT>\"},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__remote_router_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for remote_router_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/virtual_links/virtual_link/config/remote_router_id (inet:ipv4-address-no-zone)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_remote_router_id is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_remote_router_id() directly.\n\n    YANG Description: The router ID of the device which terminates the remote end\nof the virtual link", "id": "f23128:c0:m3"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/virtual_links/virtual_link/config (container)\n\nYANG Description: Configuration parameters relating to the OSPF virtual link", "id": "f23129:c0:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/virtual_links/virtual_link/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters relating to the OSPF virtual link", "id": "f23129:c0:m9"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/virtual_links/virtual_link/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration parameters relating to the OSPF virtual link", "id": "f23129:c1:m6"}
{"signature": "def _set_virtual_link(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>virtual_link.virtual_link,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__virtual_link = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for virtual_link, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area/virtual_links/virtual_link (list)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_virtual_link is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_virtual_link() directly.\n\n    YANG Description: Configuration and state parameters relating to a\nvirtual link", "id": "f23130:c1:m3"}
{"signature": "def _get_area(self):", "body": "return self.__area<EOL>", "docstring": "Getter method for area, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas/area (list)\n\nYANG Description: The OSPFv2 areas within which the local system exists", "id": "f23131:c1:m2"}
{"signature": "def _set_areas(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=areas.areas,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__areas = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for areas, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_areas is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_areas() directly.\n\n    YANG Description: Configuration and operational state relating to an\nOSPFv2 area.", "id": "f23132:c1:m6"}
{"signature": "def _get_global_(self):", "body": "return self.__global_<EOL>", "docstring": "Getter method for global_, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global (container)\n\n    YANG Description: Configuration and operational state parameters for settings\nthat are global to the OSPFv2 instance", "id": "f23132:c0:m2"}
{"signature": "def _get_global_(self):", "body": "return self.__global_<EOL>", "docstring": "Getter method for global_, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global (container)\n\n    YANG Description: Configuration and operational state parameters for settings\nthat are global to the OSPFv2 instance", "id": "f23132:c1:m2"}
{"signature": "def _set_areas(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=areas.areas,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__areas = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for areas, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_areas is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_areas() directly.\n\n    YANG Description: Configuration and operational state relating to an\nOSPFv2 area.", "id": "f23132:c0:m6"}
{"signature": "def _get_areas(self):", "body": "return self.__areas<EOL>", "docstring": "Getter method for areas, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/areas (container)\n\n    YANG Description: Configuration and operational state relating to an\nOSPFv2 area.", "id": "f23132:c1:m5"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/graceful_restart/state/enabled (boolean)\n\n    YANG Description: When the value of this leaf is set to true, graceful restart\nis enabled on the local system. In this case, the system will\nuse Grace-LSAs to signal that it is restarting to its\nneighbors.", "id": "f23133:c1:m2"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/graceful_restart/state/enabled (boolean)\n\n    YANG Description: When the value of this leaf is set to true, graceful restart\nis enabled on the local system. In this case, the system will\nuse Grace-LSAs to signal that it is restarting to its\nneighbors.", "id": "f23133:c0:m2"}
{"signature": "def _get_helper_only(self):", "body": "return self.__helper_only<EOL>", "docstring": "Getter method for helper_only, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/graceful_restart/config/helper_only (boolean)\n\n    YANG Description: Operate graceful-restart only in helper mode. When this leaf\nis set to true, the local system does not use Grace-LSAs to\nindicate that it is restarting, but will accept Grace-LSAs\nfrom remote systems, and suppress withdrawl of adjacencies\nof the system for the grace period specified", "id": "f23134:c0:m5"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/graceful_restart/config (container)\n\n    YANG Description: Configuration parameters relating to OSPFv2 graceful\nrestart", "id": "f23135:c0:m2"}
{"signature": "def _set_log_adjacency_changes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__log_adjacency_changes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for log_adjacency_changes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/state/log_adjacency_changes (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_log_adjacency_changes is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_log_adjacency_changes() directly.\n\n    YANG Description: When this leaf is set to true, a log message will be\ngenerated when the state of an OSPFv2 neighbour changes.", "id": "f23136:c0:m12"}
{"signature": "def _get_summary_route_cost_mode(self):", "body": "return self.__summary_route_cost_mode<EOL>", "docstring": "Getter method for summary_route_cost_mode, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/state/summary_route_cost_mode (enumeration)\n\n    YANG Description: Specify how costs for the summary routes should be specified\nas per the behaviour in the original OSPF specification\nRFC1583, or alternatively whether the revised behaviour\ndescribed in RFC2328 should be utilised", "id": "f23136:c1:m5"}
{"signature": "def _get_hide_transit_only_networks(self):", "body": "return self.__hide_transit_only_networks<EOL>", "docstring": "Getter method for hide_transit_only_networks, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/state/hide_transit_only_networks (boolean)\n\n    YANG Description: When this leaf is set to true, do not advertise prefixes\ninto OSPFv2 that correspond to transit interfaces, as per\nthe behaviour discussed in RFC6860.", "id": "f23136:c0:m14"}
{"signature": "def _get_router_id(self):", "body": "return self.__router_id<EOL>", "docstring": "Getter method for router_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/state/router_id (yang:dotted-quad)\n\n    YANG Description: A 32-bit number represented as a dotted quad assigned to\neach router running the OSPFv2 protocol. This number should\nbe unique within the autonomous system", "id": "f23136:c1:m2"}
{"signature": "def _set_igp_shortcuts(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__igp_shortcuts = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for igp_shortcuts, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/state/igp_shortcuts (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_igp_shortcuts is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_igp_shortcuts() directly.\n\n    YANG Description: When this leaf is set to true, OSPFv2 will route traffic to\na remote system via any LSP to the system that is marked as\nshortcut eligible.", "id": "f23136:c1:m9"}
{"signature": "def _set_router_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__router_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for router_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/state/router_id (yang:dotted-quad)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_router_id is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_router_id() directly.\n\n    YANG Description: A 32-bit number represented as a dotted quad assigned to\neach router running the OSPFv2 protocol. This number should\nbe unique within the autonomous system", "id": "f23136:c0:m3"}
{"signature": "def _set_summary_route_cost_mode(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {}, \"<STR_LIT>\": {}<EOL>},<EOL>),<EOL>default=six.text_type(\"<STR_LIT>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__summary_route_cost_mode = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for summary_route_cost_mode, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/state/summary_route_cost_mode (enumeration)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_summary_route_cost_mode is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_summary_route_cost_mode() directly.\n\n    YANG Description: Specify how costs for the summary routes should be specified\nas per the behaviour in the original OSPF specification\nRFC1583, or alternatively whether the revised behaviour\ndescribed in RFC2328 should be utilised", "id": "f23136:c0:m6"}
{"signature": "def _get_maximum_delay(self):", "body": "return self.__maximum_delay<EOL>", "docstring": "Getter method for maximum_delay, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/timers/spf/state/maximum_delay (uint32)\n\n    YANG Description: The value of this leaf specifies the maximum delay between\na topology change being detected and the SPF algorithm\nrunning. This value is used for implementations that support\nincreasing the wait time between SPF runs.", "id": "f23137:c1:m5"}
{"signature": "def _set_maximum_delay(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__maximum_delay = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for maximum_delay, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/timers/spf/state/maximum_delay (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_maximum_delay is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_maximum_delay() directly.\n\n    YANG Description: The value of this leaf specifies the maximum delay between\na topology change being detected and the SPF algorithm\nrunning. This value is used for implementations that support\nincreasing the wait time between SPF runs.", "id": "f23137:c1:m6"}
{"signature": "def _get_maximum_delay(self):", "body": "return self.__maximum_delay<EOL>", "docstring": "Getter method for maximum_delay, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/timers/spf/state/maximum_delay (uint32)\n\n    YANG Description: The value of this leaf specifies the maximum delay between\na topology change being detected and the SPF algorithm\nrunning. This value is used for implementations that support\nincreasing the wait time between SPF runs.", "id": "f23137:c0:m5"}
{"signature": "def _set_initial_delay(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__initial_delay = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for initial_delay, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/timers/spf/config/initial_delay (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_initial_delay is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_initial_delay() directly.\n\n    YANG Description: The value of this leaf specifies the time between a change\nin topology being detected and the first run of the SPF\nalgorithm.", "id": "f23138:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/timers/spf/state (container)\n\n    YANG Description: Operational state parameters relating to the global\nOSPFv2 SPF timers", "id": "f23139:c0:m5"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/timers/spf/config (container)\n\n    YANG Description: Configuration parameters relating to global OSPFv2\nSPF timers", "id": "f23139:c1:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/timers/spf/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: Operational state parameters relating to the global\nOSPFv2 SPF timers", "id": "f23139:c0:m6"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/timers/spf/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: Operational state parameters relating to the global\nOSPFv2 SPF timers", "id": "f23139:c1:m6"}
{"signature": "def _get_lsa_generation(self):", "body": "return self.__lsa_generation<EOL>", "docstring": "Getter method for lsa_generation, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/timers/lsa_generation (container)\n\n    YANG Description: Configuration and operational state parameters relating\nto timers governing the generation of LSAs by the local\nsystem", "id": "f23140:c1:m8"}
{"signature": "def _set_maximum_delay(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__maximum_delay = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for maximum_delay, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/timers/lsa_generation/state/maximum_delay (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_maximum_delay is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_maximum_delay() directly.\n\n    YANG Description: The value of this leaf specifies the maximum time between the\ngeneration of an LSA and the subsequent re-generation of that\nLSA. This value is used in implementations that support\nincreasing delay between generation of an LSA", "id": "f23141:c0:m6"}
{"signature": "def _get_timer_type(self):", "body": "return self.__timer_type<EOL>", "docstring": "Getter method for timer_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/timers/lsa_generation/state/timer_type (enumeration)\n\nYANG Description: The timer mode that is utilised by the implementation.", "id": "f23141:c1:m8"}
{"signature": "def _set_initial_delay(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__initial_delay = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for initial_delay, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/timers/lsa_generation/state/initial_delay (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_initial_delay is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_initial_delay() directly.\n\n    YANG Description: The value of this leaf specifies the time between the first\ntime an LSA is generated and advertised and the subsequent\ngeneration of that LSA.", "id": "f23141:c0:m3"}
{"signature": "def _get_initial_delay(self):", "body": "return self.__initial_delay<EOL>", "docstring": "Getter method for initial_delay, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/timers/lsa_generation/state/initial_delay (uint32)\n\n    YANG Description: The value of this leaf specifies the time between the first\ntime an LSA is generated and advertised and the subsequent\ngeneration of that LSA.", "id": "f23141:c0:m2"}
{"signature": "def _get_initial_delay(self):", "body": "return self.__initial_delay<EOL>", "docstring": "Getter method for initial_delay, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/timers/lsa_generation/config/initial_delay (uint32)\n\n    YANG Description: The value of this leaf specifies the time between the first\ntime an LSA is generated and advertised and the subsequent\ngeneration of that LSA.", "id": "f23142:c0:m2"}
{"signature": "def _set_maximum_delay(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__maximum_delay = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for maximum_delay, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/timers/lsa_generation/config/maximum_delay (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_maximum_delay is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_maximum_delay() directly.\n\n    YANG Description: The value of this leaf specifies the maximum time between the\ngeneration of an LSA and the subsequent re-generation of that\nLSA. This value is used in implementations that support\nincreasing delay between generation of an LSA", "id": "f23142:c1:m6"}
{"signature": "def _set_maximum_delay(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__maximum_delay = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for maximum_delay, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/timers/lsa_generation/config/maximum_delay (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_maximum_delay is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_maximum_delay() directly.\n\n    YANG Description: The value of this leaf specifies the maximum time between the\ngeneration of an LSA and the subsequent re-generation of that\nLSA. This value is used in implementations that support\nincreasing delay between generation of an LSA", "id": "f23142:c0:m6"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/timers/lsa_generation/config (container)\n\n    YANG Description: Configuration parameters relating to the generation of\nLSAs by the local system", "id": "f23143:c1:m2"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/timers/lsa_generation/config (container)\n\n    YANG Description: Configuration parameters relating to the generation of\nLSAs by the local system", "id": "f23143:c0:m2"}
{"signature": "def _get_set_(self):", "body": "return self.__set_<EOL>", "docstring": "Getter method for set_, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/timers/max_metric/state/set (boolean)\n\n    YANG Description: When this leaf is set to true, all non-stub interfaces of\nthe local system are advertised with the maximum metric,\nsuch that the router does not act as a transit system,\n(similarly to the IS-IS overload functionality).", "id": "f23144:c0:m2"}
{"signature": "def _get_include(self):", "body": "return self.__include<EOL>", "docstring": "Getter method for include, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/timers/max_metric/state/include (identityref)\n\n    YANG Description: By default, the maximum metric is advertised for all\nnon-stub interfaces of a device. When identities are\nspecified within this leaf-list, additional entities\nare also advertised with the maximum metric according\nto the values within the list.", "id": "f23144:c1:m8"}
{"signature": "def _get_include(self):", "body": "return self.__include<EOL>", "docstring": "Getter method for include, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/timers/max_metric/state/include (identityref)\n\n    YANG Description: By default, the maximum metric is advertised for all\nnon-stub interfaces of a device. When identities are\nspecified within this leaf-list, additional entities\nare also advertised with the maximum metric according\nto the values within the list.", "id": "f23144:c0:m8"}
{"signature": "def _get_timeout(self):", "body": "return self.__timeout<EOL>", "docstring": "Getter method for timeout, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/timers/max_metric/state/timeout (uint64)\n\n    YANG Description: The delay, in seconds, after which the advertisement of\nentities with the maximum metric should be cleared, and\nthe system reverts to the default, or configured, metrics.", "id": "f23144:c1:m5"}
{"signature": "def _set_trigger(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__trigger = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for trigger, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/timers/max_metric/state/trigger (identityref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_trigger is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_trigger() directly.\n\n    YANG Description: By default, the maximum metric is only advertised\nwhen the max-metric/set leaf is specified as true.\nIn the case that identities are specified within this\nlist, they provide additional triggers (e.g., system\nboot) that may cause the max-metric to be set. In this\ncase, the system should still honour the timeout specified\nby the max-metric/timeout leaf, and clear the max-metric\nadvertisements after the expiration of this timer.", "id": "f23144:c0:m12"}
{"signature": "def _get_timeout(self):", "body": "return self.__timeout<EOL>", "docstring": "Getter method for timeout, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/timers/max_metric/config/timeout (uint64)\n\n    YANG Description: The delay, in seconds, after which the advertisement of\nentities with the maximum metric should be cleared, and\nthe system reverts to the default, or configured, metrics.", "id": "f23145:c0:m5"}
{"signature": "def _get_set_(self):", "body": "return self.__set_<EOL>", "docstring": "Getter method for set_, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/timers/max_metric/config/set (boolean)\n\n    YANG Description: When this leaf is set to true, all non-stub interfaces of\nthe local system are advertised with the maximum metric,\nsuch that the router does not act as a transit system,\n(similarly to the IS-IS overload functionality).", "id": "f23145:c1:m2"}
{"signature": "def _get_set_(self):", "body": "return self.__set_<EOL>", "docstring": "Getter method for set_, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/timers/max_metric/config/set (boolean)\n\n    YANG Description: When this leaf is set to true, all non-stub interfaces of\nthe local system are advertised with the maximum metric,\nsuch that the router does not act as a transit system,\n(similarly to the IS-IS overload functionality).", "id": "f23145:c0:m2"}
{"signature": "def _get_include(self):", "body": "return self.__include<EOL>", "docstring": "Getter method for include, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/timers/max_metric/config/include (identityref)\n\n    YANG Description: By default, the maximum metric is advertised for all\nnon-stub interfaces of a device. When identities are\nspecified within this leaf-list, additional entities\nare also advertised with the maximum metric according\nto the values within the list.", "id": "f23145:c1:m8"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/timers/max_metric/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to setting the OSPFv2\nmaximum metric for a set of advertised entities.", "id": "f23146:c1:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/timers/max_metric/state (container)\n\n    YANG Description: Operational state parameters relating to setting the\nOSPFv2 maximum metric for a set of advertised entities.", "id": "f23146:c1:m5"}
{"signature": "def _set_summary_route_cost_mode(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {}, \"<STR_LIT>\": {}<EOL>},<EOL>),<EOL>default=six.text_type(\"<STR_LIT>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__summary_route_cost_mode = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for summary_route_cost_mode, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/config/summary_route_cost_mode (enumeration)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_summary_route_cost_mode is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_summary_route_cost_mode() directly.\n\n    YANG Description: Specify how costs for the summary routes should be specified\nas per the behaviour in the original OSPF specification\nRFC1583, or alternatively whether the revised behaviour\ndescribed in RFC2328 should be utilised", "id": "f23147:c1:m6"}
{"signature": "def _get_igp_shortcuts(self):", "body": "return self.__igp_shortcuts<EOL>", "docstring": "Getter method for igp_shortcuts, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/config/igp_shortcuts (boolean)\n\n    YANG Description: When this leaf is set to true, OSPFv2 will route traffic to\na remote system via any LSP to the system that is marked as\nshortcut eligible.", "id": "f23147:c1:m8"}
{"signature": "def _set_hide_transit_only_networks(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__hide_transit_only_networks = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for hide_transit_only_networks, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/config/hide_transit_only_networks (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_hide_transit_only_networks is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_hide_transit_only_networks() directly.\n\n    YANG Description: When this leaf is set to true, do not advertise prefixes\ninto OSPFv2 that correspond to transit interfaces, as per\nthe behaviour discussed in RFC6860.", "id": "f23147:c0:m15"}
{"signature": "def _get_igp_shortcuts(self):", "body": "return self.__igp_shortcuts<EOL>", "docstring": "Getter method for igp_shortcuts, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/config/igp_shortcuts (boolean)\n\n    YANG Description: When this leaf is set to true, OSPFv2 will route traffic to\na remote system via any LSP to the system that is marked as\nshortcut eligible.", "id": "f23147:c0:m8"}
{"signature": "def _get_summary_route_cost_mode(self):", "body": "return self.__summary_route_cost_mode<EOL>", "docstring": "Getter method for summary_route_cost_mode, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/config/summary_route_cost_mode (enumeration)\n\n    YANG Description: Specify how costs for the summary routes should be specified\nas per the behaviour in the original OSPF specification\nRFC1583, or alternatively whether the revised behaviour\ndescribed in RFC2328 should be utilised", "id": "f23147:c1:m5"}
{"signature": "def _set_hide_transit_only_networks(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__hide_transit_only_networks = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for hide_transit_only_networks, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/config/hide_transit_only_networks (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_hide_transit_only_networks is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_hide_transit_only_networks() directly.\n\n    YANG Description: When this leaf is set to true, do not advertise prefixes\ninto OSPFv2 that correspond to transit interfaces, as per\nthe behaviour discussed in RFC6860.", "id": "f23147:c1:m15"}
{"signature": "def _get_summary_route_cost_mode(self):", "body": "return self.__summary_route_cost_mode<EOL>", "docstring": "Getter method for summary_route_cost_mode, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/config/summary_route_cost_mode (enumeration)\n\n    YANG Description: Specify how costs for the summary routes should be specified\nas per the behaviour in the original OSPF specification\nRFC1583, or alternatively whether the revised behaviour\ndescribed in RFC2328 should be utilised", "id": "f23147:c0:m5"}
{"signature": "def _set_log_adjacency_changes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__log_adjacency_changes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for log_adjacency_changes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/config/log_adjacency_changes (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_log_adjacency_changes is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_log_adjacency_changes() directly.\n\n    YANG Description: When this leaf is set to true, a log message will be\ngenerated when the state of an OSPFv2 neighbour changes.", "id": "f23147:c1:m12"}
{"signature": "def _set_traffic_engineering_extensions(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__traffic_engineering_extensions = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for traffic_engineering_extensions, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/mpls/config/traffic_engineering_extensions (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_traffic_engineering_extensions is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_traffic_engineering_extensions() directly.\n\n    YANG Description: When this leaf is set to true, use traffic engineering\nextensions for OSPF to advertise TE parameters via type 10\nOpaque LSAs", "id": "f23149:c1:m3"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/mpls/config (container)\n\nYANG Description: Configuration parameters relating to MPLS for OSPFv2", "id": "f23150:c1:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/mpls/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: Operational state parameters relating to MPLS for\nOSPFv2", "id": "f23150:c0:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/mpls/state (container)\n\n    YANG Description: Operational state parameters relating to MPLS for\nOSPFv2", "id": "f23150:c0:m5"}
{"signature": "def _get_igp_ldp_sync(self):", "body": "return self.__igp_ldp_sync<EOL>", "docstring": "Getter method for igp_ldp_sync, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/mpls/igp_ldp_sync (container)\n\nYANG Description: OSPFv2 parameters relating to LDP/IGP synchronization", "id": "f23150:c0:m8"}
{"signature": "def _get_post_session_up_delay(self):", "body": "return self.__post_session_up_delay<EOL>", "docstring": "Getter method for post_session_up_delay, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/mpls/igp_ldp_sync/state/post_session_up_delay (uint32)\n\n    YANG Description: This leaf specifies a delay, expressed in units of milliseconds,\nbetween the LDP session to the IGP neighbor being established, and\nit being considered synchronized by the IGP.", "id": "f23151:c1:m5"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/mpls/igp_ldp_sync/state/enabled (boolean)\n\n    YANG Description: When this leaf is set to true, do not utilise this link for\nforwarding via the IGP until such time as LDP adjacencies to\nthe neighbor(s) over the link are established.", "id": "f23151:c0:m2"}
{"signature": "def _set_post_session_up_delay(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__post_session_up_delay = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for post_session_up_delay, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/mpls/igp_ldp_sync/config/post_session_up_delay (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_post_session_up_delay is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_post_session_up_delay() directly.\n\n    YANG Description: This leaf specifies a delay, expressed in units of milliseconds,\nbetween the LDP session to the IGP neighbor being established, and\nit being considered synchronized by the IGP.", "id": "f23152:c0:m6"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/mpls/igp_ldp_sync/config/enabled (boolean)\n\n    YANG Description: When this leaf is set to true, do not utilise this link for\nforwarding via the IGP until such time as LDP adjacencies to\nthe neighbor(s) over the link are established.", "id": "f23152:c1:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/mpls/igp_ldp_sync/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: Operational state variables relating to LDP/IGP\nsynchronization", "id": "f23153:c1:m6"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/mpls/igp_ldp_sync/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to LDP/IG\nsynchronization.", "id": "f23153:c0:m3"}
{"signature": "def _get_inter_area_propagation_policy(self):", "body": "return self.__inter_area_propagation_policy<EOL>", "docstring": "Getter method for inter_area_propagation_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/inter_area_propagation_policies/inter_area_propagation_policy (list)\n\n    YANG Description: A list of connections between pairs of areas - routes are\npropagated from the source (src) area to the destination (dst)\narea according to the policy specified", "id": "f23154:c1:m2"}
{"signature": "def _set_inter_area_propagation_policy(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>inter_area_propagation_policy.inter_area_propagation_policy,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__inter_area_propagation_policy = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for inter_area_propagation_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/inter_area_propagation_policies/inter_area_propagation_policy (list)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_inter_area_propagation_policy is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_inter_area_propagation_policy() directly.\n\n    YANG Description: A list of connections between pairs of areas - routes are\npropagated from the source (src) area to the destination (dst)\narea according to the policy specified", "id": "f23154:c1:m3"}
{"signature": "def _set_inter_area_propagation_policy(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>inter_area_propagation_policy.inter_area_propagation_policy,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__inter_area_propagation_policy = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for inter_area_propagation_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/inter_area_propagation_policies/inter_area_propagation_policy (list)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_inter_area_propagation_policy is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_inter_area_propagation_policy() directly.\n\n    YANG Description: A list of connections between pairs of areas - routes are\npropagated from the source (src) area to the destination (dst)\narea according to the policy specified", "id": "f23154:c0:m3"}
{"signature": "def _set_default_import_policy(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>default=six.text_type(\"<STR_LIT>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__default_import_policy = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for default_import_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/inter_area_propagation_policies/inter_area_propagation_policy/state/default_import_policy (default-policy-type)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_default_import_policy is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_default_import_policy() directly.\n\n    YANG Description: explicitly set a default policy if no policy definition\nin the import policy chain is satisfied.", "id": "f23155:c1:m12"}
{"signature": "def _get_default_import_policy(self):", "body": "return self.__default_import_policy<EOL>", "docstring": "Getter method for default_import_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/inter_area_propagation_policies/inter_area_propagation_policy/state/default_import_policy (default-policy-type)\n\n    YANG Description: explicitly set a default policy if no policy definition\nin the import policy chain is satisfied.", "id": "f23155:c1:m11"}
{"signature": "def _set_import_policy(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(allowed_type=six.text_type),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__import_policy = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for import_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/inter_area_propagation_policies/inter_area_propagation_policy/state/import_policy (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_import_policy is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_import_policy() directly.\n\n    YANG Description: list of policy names in sequence to be applied on\nreceiving a routing update in the current context, e.g.,\nfor the current peer group, neighbor, address family,\netc.", "id": "f23155:c0:m9"}
{"signature": "def _get_import_policy(self):", "body": "return self.__import_policy<EOL>", "docstring": "Getter method for import_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/inter_area_propagation_policies/inter_area_propagation_policy/state/import_policy (leafref)\n\n    YANG Description: list of policy names in sequence to be applied on\nreceiving a routing update in the current context, e.g.,\nfor the current peer group, neighbor, address family,\netc.", "id": "f23155:c1:m8"}
{"signature": "def _get_src_area(self):", "body": "return self.__src_area<EOL>", "docstring": "Getter method for src_area, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/inter_area_propagation_policies/inter_area_propagation_policy/config/src_area (leafref)\n\nYANG Description: The area from which prefixes are to be exported.", "id": "f23156:c0:m2"}
{"signature": "def _get_default_import_policy(self):", "body": "return self.__default_import_policy<EOL>", "docstring": "Getter method for default_import_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/inter_area_propagation_policies/inter_area_propagation_policy/config/default_import_policy (default-policy-type)\n\n    YANG Description: explicitly set a default policy if no policy definition\nin the import policy chain is satisfied.", "id": "f23156:c1:m11"}
{"signature": "def _get_import_policy(self):", "body": "return self.__import_policy<EOL>", "docstring": "Getter method for import_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/inter_area_propagation_policies/inter_area_propagation_policy/config/import_policy (leafref)\n\n    YANG Description: list of policy names in sequence to be applied on\nreceiving a routing update in the current context, e.g.,\nfor the current peer group, neighbor, address family,\netc.", "id": "f23156:c1:m8"}
{"signature": "def _get_dst_area(self):", "body": "return self.__dst_area<EOL>", "docstring": "Getter method for dst_area, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/inter_area_propagation_policies/inter_area_propagation_policy/config/dst_area (leafref)\n\nYANG Description: The destination area to which prefixes are to be imported", "id": "f23156:c0:m5"}
{"signature": "def _get_import_policy(self):", "body": "return self.__import_policy<EOL>", "docstring": "Getter method for import_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/inter_area_propagation_policies/inter_area_propagation_policy/config/import_policy (leafref)\n\n    YANG Description: list of policy names in sequence to be applied on\nreceiving a routing update in the current context, e.g.,\nfor the current peer group, neighbor, address family,\netc.", "id": "f23156:c0:m8"}
{"signature": "def _set_src_area(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__src_area = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for src_area, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/inter_area_propagation_policies/inter_area_propagation_policy/config/src_area (leafref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_src_area is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_src_area() directly.\n\nYANG Description: The area from which prefixes are to be exported.", "id": "f23156:c1:m3"}
{"signature": "def _get_dst_area(self):", "body": "return self.__dst_area<EOL>", "docstring": "Getter method for dst_area, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/inter_area_propagation_policies/inter_area_propagation_policy/dst_area (leafref)\n\nYANG Description: Reference to the destination area", "id": "f23157:c1:m5"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/inter_area_propagation_policies/inter_area_propagation_policy/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to the inter-area\npropagation policy", "id": "f23157:c0:m9"}
{"signature": "def _get_dst_area(self):", "body": "return self.__dst_area<EOL>", "docstring": "Getter method for dst_area, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/inter_area_propagation_policies/inter_area_propagation_policy/dst_area (leafref)\n\nYANG Description: Reference to the destination area", "id": "f23157:c0:m5"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Global configuration parameters for OSPFv2", "id": "f23158:c1:m3"}
{"signature": "def _set_graceful_restart(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=graceful_restart.graceful_restart,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__graceful_restart = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for graceful_restart, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/graceful_restart (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_graceful_restart is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_graceful_restart() directly.\n\n    YANG Description: Configuration and operational state parameters for OSPFv2\ngraceful restart", "id": "f23158:c0:m12"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/config (container)\n\nYANG Description: Global configuration parameters for OSPFv2", "id": "f23158:c0:m2"}
{"signature": "def _set_timers(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=timers.timers,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__timers = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for timers, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/timers (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_timers is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_timers() directly.\n\n    YANG Description: Configuration and operational state parameters for OSPFv2\ntimers", "id": "f23158:c1:m9"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/state (container)\n\nYANG Description: Operational state parameters for OSPFv2", "id": "f23158:c1:m5"}
{"signature": "def _get_mpls(self):", "body": "return self.__mpls<EOL>", "docstring": "Getter method for mpls, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/mpls (container)\n\nYANG Description: OSPFv2 parameters relating to MPLS", "id": "f23158:c0:m14"}
{"signature": "def _set_mpls(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=mpls.mpls,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__mpls = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for mpls, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/mpls (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_mpls is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_mpls() directly.\n\nYANG Description: OSPFv2 parameters relating to MPLS", "id": "f23158:c0:m15"}
{"signature": "def _set_graceful_restart(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=graceful_restart.graceful_restart,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__graceful_restart = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for graceful_restart, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/graceful_restart (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_graceful_restart is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_graceful_restart() directly.\n\n    YANG Description: Configuration and operational state parameters for OSPFv2\ngraceful restart", "id": "f23158:c1:m12"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/ospfv2/global/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Operational state parameters for OSPFv2", "id": "f23158:c1:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/state (container)\n\n    YANG Description: State parameters relating to the routing protocol\ninstance", "id": "f23159:c0:m11"}
{"signature": "def _get_bgp(self):", "body": "return self.__bgp<EOL>", "docstring": "Getter method for bgp, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp (container)\n\nYANG Description: Top-level configuration and state for the BGP router", "id": "f23159:c1:m20"}
{"signature": "def _set_bgp(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=bgp.bgp,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__bgp = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for bgp, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_bgp is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_bgp() directly.\n\nYANG Description: Top-level configuration and state for the BGP router", "id": "f23159:c1:m21"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/state (container)\n\n    YANG Description: State parameters relating to the routing protocol\ninstance", "id": "f23159:c1:m11"}
{"signature": "def _get_isis(self):", "body": "return self.__isis<EOL>", "docstring": "Getter method for isis, mapped from YANG variable /network_instances/network_instance/protocols/protocol/isis (container)\n\n    YANG Description: This container defines top-level ISIS configuration and state\ninformation.", "id": "f23159:c0:m26"}
{"signature": "def _get_name(self):", "body": "return self.__name<EOL>", "docstring": "Getter method for name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/name (leafref)\n\n    YANG Description: An operator-assigned identifier for the routing\nor forwarding protocol. For some processes this\nleaf may be system defined.", "id": "f23159:c1:m5"}
{"signature": "def _set_restart_time(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:16>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__restart_time = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for restart_time, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/graceful_restart/config/restart_time (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_restart_time is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_restart_time() directly.\n\n    YANG Description: Estimated time (in seconds) for the local BGP speaker to\nrestart a session. This value is advertise in the graceful\nrestart BGP capability.  This is a 12-bit value, referred to\nas Restart Time in RFC4724.  Per RFC4724, the suggested\ndefault value is <= the hold-time value.", "id": "f23161:c0:m6"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/graceful_restart/config/enabled (boolean)\n\nYANG Description: Enable or disable the graceful-restart capability.", "id": "f23161:c0:m2"}
{"signature": "def _get_helper_only(self):", "body": "return self.__helper_only<EOL>", "docstring": "Getter method for helper_only, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/graceful_restart/config/helper_only (boolean)\n\n    YANG Description: Enable graceful-restart in helper mode only. When this\nleaf is set, the local system does not retain forwarding\nits own state during a restart, but supports procedures\nfor the receiving speaker, as defined in RFC4724.", "id": "f23161:c1:m11"}
{"signature": "def _set_helper_only(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__helper_only = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for helper_only, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/graceful_restart/config/helper_only (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_helper_only is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_helper_only() directly.\n\n    YANG Description: Enable graceful-restart in helper mode only. When this\nleaf is set, the local system does not retain forwarding\nits own state during a restart, but supports procedures\nfor the receiving speaker, as defined in RFC4724.", "id": "f23161:c1:m12"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/graceful_restart/state (container)\n\nYANG Description: State information associated with graceful-restart", "id": "f23162:c0:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/graceful_restart/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State information associated with graceful-restart", "id": "f23162:c1:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/graceful_restart/state (container)\n\nYANG Description: State information associated with graceful-restart", "id": "f23162:c1:m5"}
{"signature": "def _get_local_as(self):", "body": "return self.__local_as<EOL>", "docstring": "Getter method for local_as, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/state/local_as (oc-inet:as-number)\n\n    YANG Description: The local autonomous system number that is to be used\nwhen establishing sessions with the remote peer or peer\ngroup, if this differs from the global BGP router\nautonomous system number.", "id": "f23163:c0:m8"}
{"signature": "def _set_peer_group_name(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__peer_group_name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for peer_group_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/state/peer_group_name (string)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_peer_group_name is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_peer_group_name() directly.\n\nYANG Description: Name of the BGP peer-group", "id": "f23163:c1:m3"}
{"signature": "def _get_peer_group_name(self):", "body": "return self.__peer_group_name<EOL>", "docstring": "Getter method for peer_group_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/state/peer_group_name (string)\n\nYANG Description: Name of the BGP peer-group", "id": "f23163:c1:m2"}
{"signature": "def _get_total_paths(self):", "body": "return self.__total_paths<EOL>", "docstring": "Getter method for total_paths, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/state/total_paths (uint32)\n\nYANG Description: Total number of BGP paths within the context", "id": "f23163:c1:m29"}
{"signature": "def _get_description(self):", "body": "return self.__description<EOL>", "docstring": "Getter method for description, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/state/description (string)\n\n    YANG Description: An optional textual description (intended primarily for use\nwith a peer or group", "id": "f23163:c1:m26"}
{"signature": "def _set_peer_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__peer_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for peer_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/state/peer_type (oc-bgp-types:peer-type)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_peer_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_peer_type() directly.\n\n    YANG Description: Explicitly designate the peer or peer group as internal\n(iBGP) or external (eBGP).", "id": "f23163:c1:m12"}
{"signature": "def _get_local_as(self):", "body": "return self.__local_as<EOL>", "docstring": "Getter method for local_as, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/state/local_as (oc-inet:as-number)\n\n    YANG Description: The local autonomous system number that is to be used\nwhen establishing sessions with the remote peer or peer\ngroup, if this differs from the global BGP router\nautonomous system number.", "id": "f23163:c1:m8"}
{"signature": "def _set_local_as(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__local_as = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for local_as, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/state/local_as (oc-inet:as-number)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_local_as is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_local_as() directly.\n\n    YANG Description: The local autonomous system number that is to be used\nwhen establishing sessions with the remote peer or peer\ngroup, if this differs from the global BGP router\nautonomous system number.", "id": "f23163:c0:m9"}
{"signature": "def _set_auth_password(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__auth_password = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for auth_password, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/state/auth_password (oc-types:routing-password)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_auth_password is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_auth_password() directly.\n\n    YANG Description: Configures an MD5 authentication password for use with\nneighboring devices.", "id": "f23163:c0:m15"}
{"signature": "def _set_send_community(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {}, \"<STR_LIT>\": {}, \"<STR_LIT>\": {}, \"<STR_LIT>\": {}<EOL>},<EOL>),<EOL>default=six.text_type(\"<STR_LIT>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__send_community = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for send_community, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/state/send_community (oc-bgp-types:community-type)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_send_community is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_send_community() directly.\n\n    YANG Description: Specify which types of community should be sent to the\nneighbor or group. The default is to not send the\ncommunity attribute", "id": "f23163:c1:m24"}
{"signature": "def _get_total_prefixes(self):", "body": "return self.__total_prefixes<EOL>", "docstring": "Getter method for total_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/state/total_prefixes (uint32)\n\nYANG Description: Total number of BGP prefixes received within the context", "id": "f23163:c1:m32"}
{"signature": "def _get_description(self):", "body": "return self.__description<EOL>", "docstring": "Getter method for description, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/state/description (string)\n\n    YANG Description: An optional textual description (intended primarily for use\nwith a peer or group", "id": "f23163:c0:m26"}
{"signature": "def _set_peer_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__peer_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for peer_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/state/peer_type (oc-bgp-types:peer-type)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_peer_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_peer_type() directly.\n\n    YANG Description: Explicitly designate the peer or peer group as internal\n(iBGP) or external (eBGP).", "id": "f23163:c0:m12"}
{"signature": "def _set_peer_as(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__peer_as = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for peer_as, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/state/peer_as (oc-inet:as-number)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_peer_as is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_peer_as() directly.\n\nYANG Description: AS number of the peer.", "id": "f23163:c1:m6"}
{"signature": "def _get_auth_password(self):", "body": "return self.__auth_password<EOL>", "docstring": "Getter method for auth_password, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/state/auth_password (oc-types:routing-password)\n\n    YANG Description: Configures an MD5 authentication password for use with\nneighboring devices.", "id": "f23163:c1:m14"}
{"signature": "def _set_send_community(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {}, \"<STR_LIT>\": {}, \"<STR_LIT>\": {}, \"<STR_LIT>\": {}<EOL>},<EOL>),<EOL>default=six.text_type(\"<STR_LIT>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__send_community = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for send_community, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/state/send_community (oc-bgp-types:community-type)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_send_community is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_send_community() directly.\n\n    YANG Description: Specify which types of community should be sent to the\nneighbor or group. The default is to not send the\ncommunity attribute", "id": "f23163:c0:m24"}
{"signature": "def _set_route_reflector_client(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__route_reflector_client = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for route_reflector_client, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/route_reflector/state/route_reflector_client (boolean)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_route_reflector_client is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_route_reflector_client() directly.\n\nYANG Description: Configure the neighbor as a route reflector client.", "id": "f23164:c0:m6"}
{"signature": "def _get_route_reflector_client(self):", "body": "return self.__route_reflector_client<EOL>", "docstring": "Getter method for route_reflector_client, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/route_reflector/config/route_reflector_client (boolean)\n\nYANG Description: Configure the neighbor as a route reflector client.", "id": "f23165:c1:m5"}
{"signature": "def _set_route_reflector_client(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__route_reflector_client = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for route_reflector_client, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/route_reflector/config/route_reflector_client (boolean)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_route_reflector_client is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_route_reflector_client() directly.\n\nYANG Description: Configure the neighbor as a route reflector client.", "id": "f23165:c0:m6"}
{"signature": "def _set_route_reflector_client(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__route_reflector_client = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for route_reflector_client, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/route_reflector/config/route_reflector_client (boolean)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_route_reflector_client is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_route_reflector_client() directly.\n\nYANG Description: Configure the neighbor as a route reflector client.", "id": "f23165:c1:m6"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/route_reflector/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuraton parameters relating to route reflection\nfor the BGPgroup", "id": "f23166:c1:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/route_reflector/state (container)\n\n    YANG Description: State information relating to route reflection for the\nBGPgroup", "id": "f23166:c0:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/route_reflector/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: State information relating to route reflection for the\nBGPgroup", "id": "f23166:c0:m6"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/route_reflector/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuraton parameters relating to route reflection\nfor the BGPgroup", "id": "f23166:c0:m3"}
{"signature": "def _set_afi_safi(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>afi_safi.afi_safi,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__afi_safi = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for afi_safi, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi (list)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_afi_safi is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_afi_safi() directly.\n\n    YANG Description: AFI,SAFI configuration available for the\nneighbour or group", "id": "f23167:c0:m3"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/graceful_restart/state/enabled (boolean)\n\n    YANG Description: This leaf indicates whether graceful-restart is enabled for\nthis AFI-SAFI", "id": "f23168:c0:m2"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/graceful_restart/state/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: This leaf indicates whether graceful-restart is enabled for\nthis AFI-SAFI", "id": "f23168:c0:m3"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/graceful_restart/config/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: This leaf indicates whether graceful-restart is enabled for\nthis AFI-SAFI", "id": "f23169:c0:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/graceful_restart/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State information for BGP graceful-restart", "id": "f23170:c1:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/graceful_restart/state (container)\n\nYANG Description: State information for BGP graceful-restart", "id": "f23170:c1:m5"}
{"signature": "def _set_afi_safi_name(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__afi_safi_name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for afi_safi_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/state/afi_safi_name (identityref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_afi_safi_name is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_afi_safi_name() directly.\n\nYANG Description: AFI,SAFI", "id": "f23171:c0:m3"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/state/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: This leaf indicates whether the IPv4 Unicast AFI,SAFI is\nenabled for the neighbour or group", "id": "f23171:c0:m6"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/state/enabled (boolean)\n\n    YANG Description: This leaf indicates whether the IPv4 Unicast AFI,SAFI is\nenabled for the neighbour or group", "id": "f23171:c1:m5"}
{"signature": "def _get_max_prefixes(self):", "body": "return self.__max_prefixes<EOL>", "docstring": "Getter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l2vpn_evpn/prefix_limit/state/max_prefixes (uint32)\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23173:c1:m2"}
{"signature": "def _set_shutdown_threshold_pct(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__shutdown_threshold_pct = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l2vpn_evpn/prefix_limit/state/shutdown_threshold_pct (oc-types:percentage)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_shutdown_threshold_pct is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_shutdown_threshold_pct() directly.\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23173:c1:m9"}
{"signature": "def _get_prevent_teardown(self):", "body": "return self.__prevent_teardown<EOL>", "docstring": "Getter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l2vpn_evpn/prefix_limit/state/prevent_teardown (boolean)\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23173:c0:m5"}
{"signature": "def _set_shutdown_threshold_pct(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__shutdown_threshold_pct = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l2vpn_evpn/prefix_limit/config/shutdown_threshold_pct (oc-types:percentage)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_shutdown_threshold_pct is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_shutdown_threshold_pct() directly.\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23174:c0:m9"}
{"signature": "def _get_shutdown_threshold_pct(self):", "body": "return self.__shutdown_threshold_pct<EOL>", "docstring": "Getter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l2vpn_evpn/prefix_limit/config/shutdown_threshold_pct (oc-types:percentage)\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23174:c1:m8"}
{"signature": "def _set_restart_timer(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__restart_timer = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l2vpn_evpn/prefix_limit/config/restart_timer (decimal64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_restart_timer is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_restart_timer() directly.\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23174:c0:m12"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l2vpn_evpn/prefix_limit/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: State information relating to the prefix-limit for the\nAFI-SAFI", "id": "f23175:c1:m6"}
{"signature": "def _set_prefix_limit(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=prefix_limit.prefix_limit,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prefix_limit = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prefix_limit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv6_labeled_unicast/prefix_limit (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prefix_limit is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prefix_limit() directly.\n\n    YANG Description: Configure the maximum number of prefixes that will be\naccepted from a peer", "id": "f23176:c0:m3"}
{"signature": "def _get_prefix_limit(self):", "body": "return self.__prefix_limit<EOL>", "docstring": "Getter method for prefix_limit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv6_labeled_unicast/prefix_limit (container)\n\n    YANG Description: Configure the maximum number of prefixes that will be\naccepted from a peer", "id": "f23176:c0:m2"}
{"signature": "def _get_max_prefixes(self):", "body": "return self.__max_prefixes<EOL>", "docstring": "Getter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv6_labeled_unicast/prefix_limit/state/max_prefixes (uint32)\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23177:c1:m2"}
{"signature": "def _set_prevent_teardown(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prevent_teardown = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv6_labeled_unicast/prefix_limit/state/prevent_teardown (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prevent_teardown is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prevent_teardown() directly.\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23177:c0:m6"}
{"signature": "def _get_max_prefixes(self):", "body": "return self.__max_prefixes<EOL>", "docstring": "Getter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv6_labeled_unicast/prefix_limit/state/max_prefixes (uint32)\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23177:c0:m2"}
{"signature": "def _set_shutdown_threshold_pct(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__shutdown_threshold_pct = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv6_labeled_unicast/prefix_limit/state/shutdown_threshold_pct (oc-types:percentage)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_shutdown_threshold_pct is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_shutdown_threshold_pct() directly.\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23177:c1:m9"}
{"signature": "def _get_prevent_teardown(self):", "body": "return self.__prevent_teardown<EOL>", "docstring": "Getter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv6_labeled_unicast/prefix_limit/config/prevent_teardown (boolean)\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23178:c1:m5"}
{"signature": "def _set_max_prefixes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__max_prefixes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv6_labeled_unicast/prefix_limit/config/max_prefixes (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_max_prefixes is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_max_prefixes() directly.\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23178:c1:m3"}
{"signature": "def _get_shutdown_threshold_pct(self):", "body": "return self.__shutdown_threshold_pct<EOL>", "docstring": "Getter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv6_labeled_unicast/prefix_limit/config/shutdown_threshold_pct (oc-types:percentage)\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23178:c1:m8"}
{"signature": "def _set_max_prefixes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__max_prefixes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv6_labeled_unicast/prefix_limit/config/max_prefixes (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_max_prefixes is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_max_prefixes() directly.\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23178:c0:m3"}
{"signature": "def _set_prevent_teardown(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prevent_teardown = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv6_labeled_unicast/prefix_limit/config/prevent_teardown (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prevent_teardown is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prevent_teardown() directly.\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23178:c0:m6"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv6_labeled_unicast/prefix_limit/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to the prefix\nlimit for the AFI-SAFI", "id": "f23179:c0:m3"}
{"signature": "def _get_prefix_limit(self):", "body": "return self.__prefix_limit<EOL>", "docstring": "Getter method for prefix_limit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv4_labeled_unicast/prefix_limit (container)\n\n    YANG Description: Configure the maximum number of prefixes that will be\naccepted from a peer", "id": "f23180:c0:m2"}
{"signature": "def _get_shutdown_threshold_pct(self):", "body": "return self.__shutdown_threshold_pct<EOL>", "docstring": "Getter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv4_labeled_unicast/prefix_limit/state/shutdown_threshold_pct (oc-types:percentage)\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23181:c0:m8"}
{"signature": "def _get_max_prefixes(self):", "body": "return self.__max_prefixes<EOL>", "docstring": "Getter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv4_labeled_unicast/prefix_limit/state/max_prefixes (uint32)\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23181:c0:m2"}
{"signature": "def _get_max_prefixes(self):", "body": "return self.__max_prefixes<EOL>", "docstring": "Getter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv4_labeled_unicast/prefix_limit/config/max_prefixes (uint32)\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23182:c1:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv4_labeled_unicast/prefix_limit/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: State information relating to the prefix-limit for the\nAFI-SAFI", "id": "f23183:c1:m6"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv4_labeled_unicast/prefix_limit/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to the prefix\nlimit for the AFI-SAFI", "id": "f23183:c1:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv4_labeled_unicast/prefix_limit/state (container)\n\n    YANG Description: State information relating to the prefix-limit for the\nAFI-SAFI", "id": "f23183:c0:m5"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv4_labeled_unicast/prefix_limit/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to the prefix\nlimit for the AFI-SAFI", "id": "f23183:c0:m3"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv4_labeled_unicast/prefix_limit/config (container)\n\n    YANG Description: Configuration parameters relating to the prefix\nlimit for the AFI-SAFI", "id": "f23183:c0:m2"}
{"signature": "def _set_prevent_teardown(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prevent_teardown = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv4_multicast/prefix_limit/state/prevent_teardown (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prevent_teardown is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prevent_teardown() directly.\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23185:c1:m6"}
{"signature": "def _set_max_prefixes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__max_prefixes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv4_multicast/prefix_limit/state/max_prefixes (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_max_prefixes is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_max_prefixes() directly.\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23185:c1:m3"}
{"signature": "def _get_prevent_teardown(self):", "body": "return self.__prevent_teardown<EOL>", "docstring": "Getter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv4_multicast/prefix_limit/state/prevent_teardown (boolean)\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23185:c0:m5"}
{"signature": "def _get_shutdown_threshold_pct(self):", "body": "return self.__shutdown_threshold_pct<EOL>", "docstring": "Getter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv4_multicast/prefix_limit/state/shutdown_threshold_pct (oc-types:percentage)\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23185:c1:m8"}
{"signature": "def _get_max_prefixes(self):", "body": "return self.__max_prefixes<EOL>", "docstring": "Getter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv4_multicast/prefix_limit/state/max_prefixes (uint32)\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23185:c0:m2"}
{"signature": "def _get_prevent_teardown(self):", "body": "return self.__prevent_teardown<EOL>", "docstring": "Getter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv4_multicast/prefix_limit/state/prevent_teardown (boolean)\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23185:c1:m5"}
{"signature": "def _set_restart_timer(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__restart_timer = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv4_multicast/prefix_limit/state/restart_timer (decimal64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_restart_timer is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_restart_timer() directly.\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23185:c1:m12"}
{"signature": "def _get_restart_timer(self):", "body": "return self.__restart_timer<EOL>", "docstring": "Getter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv4_multicast/prefix_limit/state/restart_timer (decimal64)\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23185:c0:m11"}
{"signature": "def _get_restart_timer(self):", "body": "return self.__restart_timer<EOL>", "docstring": "Getter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv4_multicast/prefix_limit/state/restart_timer (decimal64)\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23185:c1:m11"}
{"signature": "def _get_max_prefixes(self):", "body": "return self.__max_prefixes<EOL>", "docstring": "Getter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv4_multicast/prefix_limit/config/max_prefixes (uint32)\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23186:c1:m2"}
{"signature": "def _get_prevent_teardown(self):", "body": "return self.__prevent_teardown<EOL>", "docstring": "Getter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv4_multicast/prefix_limit/config/prevent_teardown (boolean)\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23186:c1:m5"}
{"signature": "def _set_shutdown_threshold_pct(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__shutdown_threshold_pct = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv4_multicast/prefix_limit/config/shutdown_threshold_pct (oc-types:percentage)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_shutdown_threshold_pct is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_shutdown_threshold_pct() directly.\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23186:c1:m9"}
{"signature": "def _get_shutdown_threshold_pct(self):", "body": "return self.__shutdown_threshold_pct<EOL>", "docstring": "Getter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv4_multicast/prefix_limit/config/shutdown_threshold_pct (oc-types:percentage)\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23186:c1:m8"}
{"signature": "def _set_restart_timer(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__restart_timer = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv4_multicast/prefix_limit/config/restart_timer (decimal64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_restart_timer is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_restart_timer() directly.\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23186:c1:m12"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv4_multicast/prefix_limit/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to the prefix\nlimit for the AFI-SAFI", "id": "f23187:c1:m3"}
{"signature": "def _set_ignore_as_path_length(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ignore_as_path_length = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ignore_as_path_length, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/route_selection_options/state/ignore_as_path_length (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_ignore_as_path_length is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_ignore_as_path_length() directly.\n\n    YANG Description: Ignore the AS path length when selecting the best path.\nThe default is to use the AS path length and prefer paths\nwith shorter length.", "id": "f23188:c1:m6"}
{"signature": "def _set_enable_aigp(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enable_aigp = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enable_aigp, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/route_selection_options/state/enable_aigp (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enable_aigp is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enable_aigp() directly.\n\n    YANG Description: Flag to enable sending / receiving accumulated IGP\nattribute in routing updates", "id": "f23188:c1:m15"}
{"signature": "def _get_enable_aigp(self):", "body": "return self.__enable_aigp<EOL>", "docstring": "Getter method for enable_aigp, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/route_selection_options/state/enable_aigp (boolean)\n\n    YANG Description: Flag to enable sending / receiving accumulated IGP\nattribute in routing updates", "id": "f23188:c0:m14"}
{"signature": "def _set_external_compare_router_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:true>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__external_compare_router_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for external_compare_router_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/route_selection_options/state/external_compare_router_id (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_external_compare_router_id is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_external_compare_router_id() directly.\n\n    YANG Description: When comparing similar routes received from external\nBGP peers, use the router-id as a criterion to select\nthe active path.", "id": "f23188:c1:m9"}
{"signature": "def _get_ignore_next_hop_igp_metric(self):", "body": "return self.__ignore_next_hop_igp_metric<EOL>", "docstring": "Getter method for ignore_next_hop_igp_metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/route_selection_options/state/ignore_next_hop_igp_metric (boolean)\n\n    YANG Description: Ignore the IGP metric to the next-hop when calculating\nBGP best-path. The default is to select the route for\nwhich the metric to the next-hop is lowest", "id": "f23188:c1:m17"}
{"signature": "def _get_enable_aigp(self):", "body": "return self.__enable_aigp<EOL>", "docstring": "Getter method for enable_aigp, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/route_selection_options/state/enable_aigp (boolean)\n\n    YANG Description: Flag to enable sending / receiving accumulated IGP\nattribute in routing updates", "id": "f23188:c1:m14"}
{"signature": "def _set_enable_aigp(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enable_aigp = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enable_aigp, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/route_selection_options/state/enable_aigp (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enable_aigp is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enable_aigp() directly.\n\n    YANG Description: Flag to enable sending / receiving accumulated IGP\nattribute in routing updates", "id": "f23188:c0:m15"}
{"signature": "def _get_enable_aigp(self):", "body": "return self.__enable_aigp<EOL>", "docstring": "Getter method for enable_aigp, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/route_selection_options/config/enable_aigp (boolean)\n\n    YANG Description: Flag to enable sending / receiving accumulated IGP\nattribute in routing updates", "id": "f23189:c1:m14"}
{"signature": "def _get_external_compare_router_id(self):", "body": "return self.__external_compare_router_id<EOL>", "docstring": "Getter method for external_compare_router_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/route_selection_options/config/external_compare_router_id (boolean)\n\n    YANG Description: When comparing similar routes received from external\nBGP peers, use the router-id as a criterion to select\nthe active path.", "id": "f23189:c0:m8"}
{"signature": "def _get_always_compare_med(self):", "body": "return self.__always_compare_med<EOL>", "docstring": "Getter method for always_compare_med, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/route_selection_options/config/always_compare_med (boolean)\n\n    YANG Description: Compare multi-exit discriminator (MED) value from\ndifferent ASes when selecting the best route.  The\ndefault behavior is to only compare MEDs for paths\nreceived from the same AS.", "id": "f23189:c0:m2"}
{"signature": "def _get_enable_aigp(self):", "body": "return self.__enable_aigp<EOL>", "docstring": "Getter method for enable_aigp, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/route_selection_options/config/enable_aigp (boolean)\n\n    YANG Description: Flag to enable sending / receiving accumulated IGP\nattribute in routing updates", "id": "f23189:c0:m14"}
{"signature": "def _get_advertise_inactive_routes(self):", "body": "return self.__advertise_inactive_routes<EOL>", "docstring": "Getter method for advertise_inactive_routes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/route_selection_options/config/advertise_inactive_routes (boolean)\n\n    YANG Description: Advertise inactive routes to external peers.  The\ndefault is to only advertise active routes.", "id": "f23189:c0:m11"}
{"signature": "def _get_prefix_limit(self):", "body": "return self.__prefix_limit<EOL>", "docstring": "Getter method for prefix_limit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l2vpn_vpls/prefix_limit (container)\n\n    YANG Description: Configure the maximum number of prefixes that will be\naccepted from a peer", "id": "f23191:c1:m2"}
{"signature": "def _set_shutdown_threshold_pct(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__shutdown_threshold_pct = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l2vpn_vpls/prefix_limit/state/shutdown_threshold_pct (oc-types:percentage)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_shutdown_threshold_pct is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_shutdown_threshold_pct() directly.\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23192:c1:m9"}
{"signature": "def _get_shutdown_threshold_pct(self):", "body": "return self.__shutdown_threshold_pct<EOL>", "docstring": "Getter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l2vpn_vpls/prefix_limit/state/shutdown_threshold_pct (oc-types:percentage)\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23192:c1:m8"}
{"signature": "def _set_restart_timer(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__restart_timer = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l2vpn_vpls/prefix_limit/state/restart_timer (decimal64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_restart_timer is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_restart_timer() directly.\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23192:c0:m12"}
{"signature": "def _set_restart_timer(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__restart_timer = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l2vpn_vpls/prefix_limit/state/restart_timer (decimal64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_restart_timer is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_restart_timer() directly.\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23192:c1:m12"}
{"signature": "def _get_restart_timer(self):", "body": "return self.__restart_timer<EOL>", "docstring": "Getter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l2vpn_vpls/prefix_limit/state/restart_timer (decimal64)\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23192:c0:m11"}
{"signature": "def _get_shutdown_threshold_pct(self):", "body": "return self.__shutdown_threshold_pct<EOL>", "docstring": "Getter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l2vpn_vpls/prefix_limit/state/shutdown_threshold_pct (oc-types:percentage)\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23192:c0:m8"}
{"signature": "def _get_restart_timer(self):", "body": "return self.__restart_timer<EOL>", "docstring": "Getter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l2vpn_vpls/prefix_limit/config/restart_timer (decimal64)\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23193:c0:m11"}
{"signature": "def _set_shutdown_threshold_pct(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__shutdown_threshold_pct = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l2vpn_vpls/prefix_limit/config/shutdown_threshold_pct (oc-types:percentage)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_shutdown_threshold_pct is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_shutdown_threshold_pct() directly.\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23193:c0:m9"}
{"signature": "def _get_shutdown_threshold_pct(self):", "body": "return self.__shutdown_threshold_pct<EOL>", "docstring": "Getter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l2vpn_vpls/prefix_limit/config/shutdown_threshold_pct (oc-types:percentage)\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23193:c0:m8"}
{"signature": "def _set_prevent_teardown(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prevent_teardown = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l2vpn_vpls/prefix_limit/config/prevent_teardown (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prevent_teardown is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prevent_teardown() directly.\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23193:c0:m6"}
{"signature": "def _set_restart_timer(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__restart_timer = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l2vpn_vpls/prefix_limit/config/restart_timer (decimal64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_restart_timer is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_restart_timer() directly.\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23193:c0:m12"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l2vpn_vpls/prefix_limit/config (container)\n\n    YANG Description: Configuration parameters relating to the prefix\nlimit for the AFI-SAFI", "id": "f23194:c1:m2"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l2vpn_vpls/prefix_limit/config (container)\n\n    YANG Description: Configuration parameters relating to the prefix\nlimit for the AFI-SAFI", "id": "f23194:c0:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l2vpn_vpls/prefix_limit/state (container)\n\n    YANG Description: State information relating to the prefix-limit for the\nAFI-SAFI", "id": "f23194:c0:m5"}
{"signature": "def _set_send_default_route(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__send_default_route = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for send_default_route, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv6_unicast/config/send_default_route (boolean)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_send_default_route is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_send_default_route() directly.\n\nYANG Description: If set to true, send the default-route to the neighbour(s)", "id": "f23196:c0:m3"}
{"signature": "def _get_send_default_route(self):", "body": "return self.__send_default_route<EOL>", "docstring": "Getter method for send_default_route, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv6_unicast/config/send_default_route (boolean)\n\nYANG Description: If set to true, send the default-route to the neighbour(s)", "id": "f23196:c0:m2"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv6_unicast/config (container)\n\n    YANG Description: Configuration parameters for common IPv4 and IPv6 unicast\nAFI-SAFI options", "id": "f23197:c0:m5"}
{"signature": "def _set_restart_timer(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__restart_timer = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv6_unicast/prefix_limit/state/restart_timer (decimal64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_restart_timer is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_restart_timer() directly.\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23198:c1:m12"}
{"signature": "def _set_restart_timer(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__restart_timer = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv6_unicast/prefix_limit/state/restart_timer (decimal64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_restart_timer is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_restart_timer() directly.\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23198:c0:m12"}
{"signature": "def _set_max_prefixes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__max_prefixes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv6_unicast/prefix_limit/state/max_prefixes (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_max_prefixes is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_max_prefixes() directly.\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23198:c1:m3"}
{"signature": "def _set_prevent_teardown(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prevent_teardown = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv6_unicast/prefix_limit/state/prevent_teardown (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prevent_teardown is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prevent_teardown() directly.\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23198:c0:m6"}
{"signature": "def _set_shutdown_threshold_pct(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__shutdown_threshold_pct = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv6_unicast/prefix_limit/state/shutdown_threshold_pct (oc-types:percentage)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_shutdown_threshold_pct is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_shutdown_threshold_pct() directly.\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23198:c1:m9"}
{"signature": "def _get_prevent_teardown(self):", "body": "return self.__prevent_teardown<EOL>", "docstring": "Getter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv6_unicast/prefix_limit/state/prevent_teardown (boolean)\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23198:c0:m5"}
{"signature": "def _get_prevent_teardown(self):", "body": "return self.__prevent_teardown<EOL>", "docstring": "Getter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv6_unicast/prefix_limit/config/prevent_teardown (boolean)\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23199:c1:m5"}
{"signature": "def _set_restart_timer(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__restart_timer = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv6_unicast/prefix_limit/config/restart_timer (decimal64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_restart_timer is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_restart_timer() directly.\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23199:c1:m12"}
{"signature": "def _get_shutdown_threshold_pct(self):", "body": "return self.__shutdown_threshold_pct<EOL>", "docstring": "Getter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv6_unicast/prefix_limit/config/shutdown_threshold_pct (oc-types:percentage)\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23199:c0:m8"}
{"signature": "def _set_shutdown_threshold_pct(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__shutdown_threshold_pct = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv6_unicast/prefix_limit/config/shutdown_threshold_pct (oc-types:percentage)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_shutdown_threshold_pct is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_shutdown_threshold_pct() directly.\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23199:c1:m9"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv6_unicast/prefix_limit/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to the prefix\nlimit for the AFI-SAFI", "id": "f23200:c0:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv6_unicast/prefix_limit/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: State information relating to the prefix-limit for the\nAFI-SAFI", "id": "f23200:c1:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv6_unicast/prefix_limit/state (container)\n\n    YANG Description: State information relating to the prefix-limit for the\nAFI-SAFI", "id": "f23200:c0:m5"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv6_unicast/prefix_limit/config (container)\n\n    YANG Description: Configuration parameters relating to the prefix\nlimit for the AFI-SAFI", "id": "f23200:c0:m2"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/config/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: This leaf indicates whether the IPv4 Unicast AFI,SAFI is\nenabled for the neighbour or group", "id": "f23201:c1:m6"}
{"signature": "def _get_afi_safi_name(self):", "body": "return self.__afi_safi_name<EOL>", "docstring": "Getter method for afi_safi_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/config/afi_safi_name (identityref)\n\nYANG Description: AFI,SAFI", "id": "f23201:c0:m2"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/config/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: This leaf indicates whether the IPv4 Unicast AFI,SAFI is\nenabled for the neighbour or group", "id": "f23201:c0:m6"}
{"signature": "def _set_afi_safi_name(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__afi_safi_name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for afi_safi_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/config/afi_safi_name (identityref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_afi_safi_name is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_afi_safi_name() directly.\n\nYANG Description: AFI,SAFI", "id": "f23201:c0:m3"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/use_multiple_paths/config/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: Whether the use of multiple paths for the same NLRI is\nenabled for the neighbor. This value is overridden by\nany more specific configuration value.", "id": "f23203:c1:m3"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/use_multiple_paths/config/enabled (boolean)\n\n    YANG Description: Whether the use of multiple paths for the same NLRI is\nenabled for the neighbor. This value is overridden by\nany more specific configuration value.", "id": "f23203:c0:m2"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/use_multiple_paths/config/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: Whether the use of multiple paths for the same NLRI is\nenabled for the neighbor. This value is overridden by\nany more specific configuration value.", "id": "f23203:c0:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/use_multiple_paths/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters relating to multipath", "id": "f23204:c0:m6"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/use_multiple_paths/config (container)\n\nYANG Description: Configuration parameters relating to multipath", "id": "f23204:c0:m2"}
{"signature": "def _get_ebgp(self):", "body": "return self.__ebgp<EOL>", "docstring": "Getter method for ebgp, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/use_multiple_paths/ebgp (container)\n\nYANG Description: Multipath parameters for eBGP", "id": "f23204:c0:m8"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/use_multiple_paths/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters relating to multipath", "id": "f23204:c1:m6"}
{"signature": "def _get_maximum_paths(self):", "body": "return self.__maximum_paths<EOL>", "docstring": "Getter method for maximum_paths, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/use_multiple_paths/ibgp/state/maximum_paths (uint32)\n\n    YANG Description: Maximum number of parallel paths to consider when using\niBGP multipath. The default is to use a single path", "id": "f23205:c1:m2"}
{"signature": "def _set_maximum_paths(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>default=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>)(<EOL><NUM_LIT:1><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__maximum_paths = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for maximum_paths, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/use_multiple_paths/ibgp/config/maximum_paths (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_maximum_paths is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_maximum_paths() directly.\n\n    YANG Description: Maximum number of parallel paths to consider when using\niBGP multipath. The default is to use a single path", "id": "f23206:c1:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/use_multiple_paths/ibgp/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State information relating to iBGP multipath", "id": "f23207:c0:m6"}
{"signature": "def _get_maximum_paths(self):", "body": "return self.__maximum_paths<EOL>", "docstring": "Getter method for maximum_paths, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/use_multiple_paths/ebgp/state/maximum_paths (uint32)\n\n    YANG Description: Maximum number of parallel paths to consider when using\nBGP multipath. The default is use a single path.", "id": "f23208:c0:m5"}
{"signature": "def _get_allow_multiple_as(self):", "body": "return self.__allow_multiple_as<EOL>", "docstring": "Getter method for allow_multiple_as, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/use_multiple_paths/ebgp/state/allow_multiple_as (boolean)\n\n    YANG Description: Allow multipath to use paths from different neighbouring\nASes.  The default is to only consider multiple paths from\nthe same neighbouring AS.", "id": "f23208:c0:m2"}
{"signature": "def _set_allow_multiple_as(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__allow_multiple_as = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for allow_multiple_as, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/use_multiple_paths/ebgp/config/allow_multiple_as (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_allow_multiple_as is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_allow_multiple_as() directly.\n\n    YANG Description: Allow multipath to use paths from different neighbouring\nASes.  The default is to only consider multiple paths from\nthe same neighbouring AS.", "id": "f23209:c0:m3"}
{"signature": "def _get_maximum_paths(self):", "body": "return self.__maximum_paths<EOL>", "docstring": "Getter method for maximum_paths, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/use_multiple_paths/ebgp/config/maximum_paths (uint32)\n\n    YANG Description: Maximum number of parallel paths to consider when using\nBGP multipath. The default is use a single path.", "id": "f23209:c1:m5"}
{"signature": "def _set_maximum_paths(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>default=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>)(<EOL><NUM_LIT:1><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__maximum_paths = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for maximum_paths, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/use_multiple_paths/ebgp/config/maximum_paths (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_maximum_paths is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_maximum_paths() directly.\n\n    YANG Description: Maximum number of parallel paths to consider when using\nBGP multipath. The default is use a single path.", "id": "f23209:c1:m6"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/use_multiple_paths/ebgp/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State information relating to eBGP multipath", "id": "f23210:c1:m6"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/use_multiple_paths/ebgp/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration parameters relating to eBGP multipath", "id": "f23210:c1:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/use_multiple_paths/ebgp/state (container)\n\nYANG Description: State information relating to eBGP multipath", "id": "f23210:c0:m5"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/use_multiple_paths/ebgp/config (container)\n\nYANG Description: Configuration parameters relating to eBGP multipath", "id": "f23210:c1:m2"}
{"signature": "def _get_default_import_policy(self):", "body": "return self.__default_import_policy<EOL>", "docstring": "Getter method for default_import_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/apply_policy/state/default_import_policy (default-policy-type)\n\n    YANG Description: explicitly set a default policy if no policy definition\nin the import policy chain is satisfied.", "id": "f23211:c1:m5"}
{"signature": "def _set_export_policy(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(allowed_type=six.text_type),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__export_policy = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for export_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/apply_policy/state/export_policy (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_export_policy is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_export_policy() directly.\n\n    YANG Description: list of policy names in sequence to be applied on\nsending a routing update in the current context, e.g.,\nfor the current peer group, neighbor, address family,\netc.", "id": "f23211:c1:m9"}
{"signature": "def _get_export_policy(self):", "body": "return self.__export_policy<EOL>", "docstring": "Getter method for export_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/apply_policy/state/export_policy (leafref)\n\n    YANG Description: list of policy names in sequence to be applied on\nsending a routing update in the current context, e.g.,\nfor the current peer group, neighbor, address family,\netc.", "id": "f23211:c0:m8"}
{"signature": "def _get_import_policy(self):", "body": "return self.__import_policy<EOL>", "docstring": "Getter method for import_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/apply_policy/state/import_policy (leafref)\n\n    YANG Description: list of policy names in sequence to be applied on\nreceiving a routing update in the current context, e.g.,\nfor the current peer group, neighbor, address family,\netc.", "id": "f23211:c0:m2"}
{"signature": "def _set_default_import_policy(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>default=six.text_type(\"<STR_LIT>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__default_import_policy = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for default_import_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/apply_policy/state/default_import_policy (default-policy-type)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_default_import_policy is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_default_import_policy() directly.\n\n    YANG Description: explicitly set a default policy if no policy definition\nin the import policy chain is satisfied.", "id": "f23211:c1:m6"}
{"signature": "def _set_default_import_policy(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>default=six.text_type(\"<STR_LIT>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__default_import_policy = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for default_import_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/apply_policy/config/default_import_policy (default-policy-type)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_default_import_policy is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_default_import_policy() directly.\n\n    YANG Description: explicitly set a default policy if no policy definition\nin the import policy chain is satisfied.", "id": "f23212:c1:m6"}
{"signature": "def _set_default_export_policy(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>default=six.text_type(\"<STR_LIT>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__default_export_policy = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for default_export_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/apply_policy/config/default_export_policy (default-policy-type)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_default_export_policy is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_default_export_policy() directly.\n\n    YANG Description: explicitly set a default policy if no policy definition\nin the export policy chain is satisfied.", "id": "f23212:c0:m12"}
{"signature": "def _get_export_policy(self):", "body": "return self.__export_policy<EOL>", "docstring": "Getter method for export_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/apply_policy/config/export_policy (leafref)\n\n    YANG Description: list of policy names in sequence to be applied on\nsending a routing update in the current context, e.g.,\nfor the current peer group, neighbor, address family,\netc.", "id": "f23212:c0:m8"}
{"signature": "def _set_export_policy(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(allowed_type=six.text_type),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__export_policy = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for export_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/apply_policy/config/export_policy (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_export_policy is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_export_policy() directly.\n\n    YANG Description: list of policy names in sequence to be applied on\nsending a routing update in the current context, e.g.,\nfor the current peer group, neighbor, address family,\netc.", "id": "f23212:c0:m9"}
{"signature": "def _get_default_export_policy(self):", "body": "return self.__default_export_policy<EOL>", "docstring": "Getter method for default_export_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/apply_policy/config/default_export_policy (default-policy-type)\n\n    YANG Description: explicitly set a default policy if no policy definition\nin the export policy chain is satisfied.", "id": "f23212:c1:m11"}
{"signature": "def _get_import_policy(self):", "body": "return self.__import_policy<EOL>", "docstring": "Getter method for import_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/apply_policy/config/import_policy (leafref)\n\n    YANG Description: list of policy names in sequence to be applied on\nreceiving a routing update in the current context, e.g.,\nfor the current peer group, neighbor, address family,\netc.", "id": "f23212:c0:m2"}
{"signature": "def _get_export_policy(self):", "body": "return self.__export_policy<EOL>", "docstring": "Getter method for export_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/apply_policy/config/export_policy (leafref)\n\n    YANG Description: list of policy names in sequence to be applied on\nsending a routing update in the current context, e.g.,\nfor the current peer group, neighbor, address family,\netc.", "id": "f23212:c1:m8"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/apply_policy/config (container)\n\nYANG Description: Policy configuration data.", "id": "f23213:c1:m2"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/apply_policy/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Policy configuration data.", "id": "f23213:c1:m3"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/apply_policy/config (container)\n\nYANG Description: Policy configuration data.", "id": "f23213:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/apply_policy/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Operational state for routing policy", "id": "f23213:c0:m6"}
{"signature": "def _get_ipv4_unicast(self):", "body": "return self.__ipv4_unicast<EOL>", "docstring": "Getter method for ipv4_unicast, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv4_unicast (container)\n\nYANG Description: IPv4 unicast configuration options", "id": "f23214:c0:m23"}
{"signature": "def _set_l2vpn_vpls(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=l2vpn_vpls.l2vpn_vpls,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__l2vpn_vpls = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for l2vpn_vpls, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l2vpn_vpls (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_l2vpn_vpls is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_l2vpn_vpls() directly.\n\nYANG Description: BGP-signalled VPLS configuration options", "id": "f23214:c1:m48"}
{"signature": "def _get_l3vpn_ipv4_unicast(self):", "body": "return self.__l3vpn_ipv4_unicast<EOL>", "docstring": "Getter method for l3vpn_ipv4_unicast, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv4_unicast (container)\n\nYANG Description: Unicast IPv4 L3VPN configuration options", "id": "f23214:c1:m35"}
{"signature": "def _set_ipv6_labeled_unicast(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=ipv6_labeled_unicast.ipv6_labeled_unicast,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv6_labeled_unicast = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv6_labeled_unicast, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv6_labeled_unicast (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ipv6_labeled_unicast is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ipv6_labeled_unicast() directly.\n\nYANG Description: IPv6 Labeled Unicast configuration options", "id": "f23214:c1:m33"}
{"signature": "def _get_l2vpn_vpls(self):", "body": "return self.__l2vpn_vpls<EOL>", "docstring": "Getter method for l2vpn_vpls, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l2vpn_vpls (container)\n\nYANG Description: BGP-signalled VPLS configuration options", "id": "f23214:c1:m47"}
{"signature": "def _get_ipv4_labeled_unicast(self):", "body": "return self.__ipv4_labeled_unicast<EOL>", "docstring": "Getter method for ipv4_labeled_unicast, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv4_labeled_unicast (container)\n\nYANG Description: IPv4 Labeled Unicast configuration options", "id": "f23214:c1:m29"}
{"signature": "def _set_use_multiple_paths(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=use_multiple_paths.use_multiple_paths,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__use_multiple_paths = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for use_multiple_paths, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/use_multiple_paths (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_use_multiple_paths is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_use_multiple_paths() directly.\n\n    YANG Description: Parameters related to the use of multiple paths for the\nsame NLRI", "id": "f23214:c1:m18"}
{"signature": "def _set_apply_policy(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=apply_policy.apply_policy,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__apply_policy = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for apply_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/apply_policy (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_apply_policy is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_apply_policy() directly.\n\n    YANG Description: Anchor point for routing policies in the model.\nImport and export policies are with respect to the local\nrouting table, i.e., export (send) and import (receive),\ndepending on the context.", "id": "f23214:c0:m21"}
{"signature": "def _set_afi_safi_name(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__afi_safi_name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for afi_safi_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/afi_safi_name (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_afi_safi_name is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_afi_safi_name() directly.\n\n    YANG Description: Reference to the AFI-SAFI name used as a key\nfor the AFI-SAFI list", "id": "f23214:c1:m3"}
{"signature": "def _set_route_selection_options(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=route_selection_options.route_selection_options,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__route_selection_options = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for route_selection_options, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/route_selection_options (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_route_selection_options is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_route_selection_options() directly.\n\nYANG Description: Parameters relating to options for route selection", "id": "f23214:c1:m15"}
{"signature": "def _set_l2vpn_vpls(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=l2vpn_vpls.l2vpn_vpls,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__l2vpn_vpls = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for l2vpn_vpls, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l2vpn_vpls (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_l2vpn_vpls is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_l2vpn_vpls() directly.\n\nYANG Description: BGP-signalled VPLS configuration options", "id": "f23214:c0:m48"}
{"signature": "def _get_l3vpn_ipv4_unicast(self):", "body": "return self.__l3vpn_ipv4_unicast<EOL>", "docstring": "Getter method for l3vpn_ipv4_unicast, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv4_unicast (container)\n\nYANG Description: Unicast IPv4 L3VPN configuration options", "id": "f23214:c0:m35"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/state (container)\n\nYANG Description: State information relating to the AFI-SAFI", "id": "f23214:c0:m8"}
{"signature": "def _set_route_selection_options(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=route_selection_options.route_selection_options,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__route_selection_options = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for route_selection_options, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/route_selection_options (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_route_selection_options is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_route_selection_options() directly.\n\nYANG Description: Parameters relating to options for route selection", "id": "f23214:c0:m15"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration parameters for the AFI-SAFI", "id": "f23214:c0:m6"}
{"signature": "def _get_l2vpn_evpn(self):", "body": "return self.__l2vpn_evpn<EOL>", "docstring": "Getter method for l2vpn_evpn, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l2vpn_evpn (container)\n\nYANG Description: BGP EVPN configuration options", "id": "f23214:c0:m50"}
{"signature": "def _set_prefix_limit(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=prefix_limit.prefix_limit,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prefix_limit = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prefix_limit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv6_unicast/prefix_limit (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prefix_limit is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prefix_limit() directly.\n\n    YANG Description: Configure the maximum number of prefixes that will be\naccepted from a peer", "id": "f23215:c0:m3"}
{"signature": "def _set_prefix_limit(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=prefix_limit.prefix_limit,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prefix_limit = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prefix_limit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv6_unicast/prefix_limit (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prefix_limit is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prefix_limit() directly.\n\n    YANG Description: Configure the maximum number of prefixes that will be\naccepted from a peer", "id": "f23215:c1:m3"}
{"signature": "def _get_restart_timer(self):", "body": "return self.__restart_timer<EOL>", "docstring": "Getter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv6_unicast/prefix_limit/state/restart_timer (decimal64)\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23216:c1:m11"}
{"signature": "def _get_prevent_teardown(self):", "body": "return self.__prevent_teardown<EOL>", "docstring": "Getter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv6_unicast/prefix_limit/state/prevent_teardown (boolean)\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23216:c1:m5"}
{"signature": "def _get_shutdown_threshold_pct(self):", "body": "return self.__shutdown_threshold_pct<EOL>", "docstring": "Getter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv6_unicast/prefix_limit/state/shutdown_threshold_pct (oc-types:percentage)\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23216:c1:m8"}
{"signature": "def _get_shutdown_threshold_pct(self):", "body": "return self.__shutdown_threshold_pct<EOL>", "docstring": "Getter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv6_unicast/prefix_limit/state/shutdown_threshold_pct (oc-types:percentage)\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23216:c0:m8"}
{"signature": "def _set_max_prefixes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__max_prefixes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv6_unicast/prefix_limit/state/max_prefixes (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_max_prefixes is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_max_prefixes() directly.\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23216:c0:m3"}
{"signature": "def _get_prevent_teardown(self):", "body": "return self.__prevent_teardown<EOL>", "docstring": "Getter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv6_unicast/prefix_limit/config/prevent_teardown (boolean)\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23217:c1:m5"}
{"signature": "def _set_prevent_teardown(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prevent_teardown = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv6_unicast/prefix_limit/config/prevent_teardown (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prevent_teardown is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prevent_teardown() directly.\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23217:c0:m6"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv6_unicast/prefix_limit/config (container)\n\n    YANG Description: Configuration parameters relating to the prefix\nlimit for the AFI-SAFI", "id": "f23218:c1:m2"}
{"signature": "def _get_max_prefixes(self):", "body": "return self.__max_prefixes<EOL>", "docstring": "Getter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv6_multicast/prefix_limit/state/max_prefixes (uint32)\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23220:c0:m2"}
{"signature": "def _get_prevent_teardown(self):", "body": "return self.__prevent_teardown<EOL>", "docstring": "Getter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv6_multicast/prefix_limit/state/prevent_teardown (boolean)\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23220:c0:m5"}
{"signature": "def _get_shutdown_threshold_pct(self):", "body": "return self.__shutdown_threshold_pct<EOL>", "docstring": "Getter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv6_multicast/prefix_limit/state/shutdown_threshold_pct (oc-types:percentage)\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23220:c1:m8"}
{"signature": "def _set_prevent_teardown(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prevent_teardown = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv6_multicast/prefix_limit/state/prevent_teardown (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prevent_teardown is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prevent_teardown() directly.\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23220:c1:m6"}
{"signature": "def _set_prevent_teardown(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prevent_teardown = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv6_multicast/prefix_limit/state/prevent_teardown (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prevent_teardown is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prevent_teardown() directly.\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23220:c0:m6"}
{"signature": "def _get_restart_timer(self):", "body": "return self.__restart_timer<EOL>", "docstring": "Getter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv6_multicast/prefix_limit/state/restart_timer (decimal64)\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23220:c1:m11"}
{"signature": "def _get_restart_timer(self):", "body": "return self.__restart_timer<EOL>", "docstring": "Getter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv6_multicast/prefix_limit/config/restart_timer (decimal64)\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23221:c1:m11"}
{"signature": "def _get_shutdown_threshold_pct(self):", "body": "return self.__shutdown_threshold_pct<EOL>", "docstring": "Getter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv6_multicast/prefix_limit/config/shutdown_threshold_pct (oc-types:percentage)\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23221:c0:m8"}
{"signature": "def _set_max_prefixes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__max_prefixes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv6_multicast/prefix_limit/config/max_prefixes (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_max_prefixes is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_max_prefixes() directly.\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23221:c1:m3"}
{"signature": "def _set_max_prefixes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__max_prefixes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv6_multicast/prefix_limit/config/max_prefixes (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_max_prefixes is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_max_prefixes() directly.\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23221:c0:m3"}
{"signature": "def _get_max_prefixes(self):", "body": "return self.__max_prefixes<EOL>", "docstring": "Getter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv6_multicast/prefix_limit/config/max_prefixes (uint32)\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23221:c0:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv6_multicast/prefix_limit/state (container)\n\n    YANG Description: State information relating to the prefix-limit for the\nAFI-SAFI", "id": "f23222:c0:m5"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv6_multicast/prefix_limit/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to the prefix\nlimit for the AFI-SAFI", "id": "f23222:c1:m3"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv6_multicast/prefix_limit/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to the prefix\nlimit for the AFI-SAFI", "id": "f23222:c0:m3"}
{"signature": "def _set_prefix_limit(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=prefix_limit.prefix_limit,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prefix_limit = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prefix_limit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv4_unicast/prefix_limit (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prefix_limit is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prefix_limit() directly.\n\n    YANG Description: Configure the maximum number of prefixes that will be\naccepted from a peer", "id": "f23223:c1:m3"}
{"signature": "def _get_max_prefixes(self):", "body": "return self.__max_prefixes<EOL>", "docstring": "Getter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv4_unicast/prefix_limit/state/max_prefixes (uint32)\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23224:c1:m2"}
{"signature": "def _get_max_prefixes(self):", "body": "return self.__max_prefixes<EOL>", "docstring": "Getter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv4_unicast/prefix_limit/state/max_prefixes (uint32)\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23224:c0:m2"}
{"signature": "def _set_restart_timer(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__restart_timer = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv4_unicast/prefix_limit/state/restart_timer (decimal64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_restart_timer is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_restart_timer() directly.\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23224:c1:m12"}
{"signature": "def _get_restart_timer(self):", "body": "return self.__restart_timer<EOL>", "docstring": "Getter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv4_unicast/prefix_limit/config/restart_timer (decimal64)\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23225:c1:m11"}
{"signature": "def _set_max_prefixes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__max_prefixes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv4_unicast/prefix_limit/config/max_prefixes (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_max_prefixes is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_max_prefixes() directly.\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23225:c0:m3"}
{"signature": "def _set_shutdown_threshold_pct(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__shutdown_threshold_pct = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv4_unicast/prefix_limit/config/shutdown_threshold_pct (oc-types:percentage)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_shutdown_threshold_pct is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_shutdown_threshold_pct() directly.\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23225:c0:m9"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv4_unicast/prefix_limit/config (container)\n\n    YANG Description: Configuration parameters relating to the prefix\nlimit for the AFI-SAFI", "id": "f23226:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv4_unicast/prefix_limit/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: State information relating to the prefix-limit for the\nAFI-SAFI", "id": "f23226:c0:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/l3vpn_ipv4_unicast/prefix_limit/state (container)\n\n    YANG Description: State information relating to the prefix-limit for the\nAFI-SAFI", "id": "f23226:c1:m5"}
{"signature": "def _get_send_default_route(self):", "body": "return self.__send_default_route<EOL>", "docstring": "Getter method for send_default_route, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv4_unicast/config/send_default_route (boolean)\n\nYANG Description: If set to true, send the default-route to the neighbour(s)", "id": "f23228:c1:m2"}
{"signature": "def _get_send_default_route(self):", "body": "return self.__send_default_route<EOL>", "docstring": "Getter method for send_default_route, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv4_unicast/config/send_default_route (boolean)\n\nYANG Description: If set to true, send the default-route to the neighbour(s)", "id": "f23228:c0:m2"}
{"signature": "def _set_prefix_limit(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=prefix_limit.prefix_limit,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prefix_limit = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prefix_limit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv4_unicast/prefix_limit (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prefix_limit is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prefix_limit() directly.\n\n    YANG Description: Configure the maximum number of prefixes that will be\naccepted from a peer", "id": "f23229:c1:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv4_unicast/state (container)\n\n    YANG Description: State information for common IPv4 and IPv6 unicast\nparameters", "id": "f23229:c0:m8"}
{"signature": "def _get_prefix_limit(self):", "body": "return self.__prefix_limit<EOL>", "docstring": "Getter method for prefix_limit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv4_unicast/prefix_limit (container)\n\n    YANG Description: Configure the maximum number of prefixes that will be\naccepted from a peer", "id": "f23229:c0:m2"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv4_unicast/config (container)\n\n    YANG Description: Configuration parameters for common IPv4 and IPv6 unicast\nAFI-SAFI options", "id": "f23229:c0:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv4_unicast/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: State information for common IPv4 and IPv6 unicast\nparameters", "id": "f23229:c1:m9"}
{"signature": "def _get_prevent_teardown(self):", "body": "return self.__prevent_teardown<EOL>", "docstring": "Getter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv4_unicast/prefix_limit/state/prevent_teardown (boolean)\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23230:c0:m5"}
{"signature": "def _get_shutdown_threshold_pct(self):", "body": "return self.__shutdown_threshold_pct<EOL>", "docstring": "Getter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv4_unicast/prefix_limit/state/shutdown_threshold_pct (oc-types:percentage)\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23230:c1:m8"}
{"signature": "def _set_restart_timer(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__restart_timer = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv4_unicast/prefix_limit/state/restart_timer (decimal64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_restart_timer is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_restart_timer() directly.\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23230:c1:m12"}
{"signature": "def _set_restart_timer(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__restart_timer = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv4_unicast/prefix_limit/config/restart_timer (decimal64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_restart_timer is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_restart_timer() directly.\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23231:c1:m12"}
{"signature": "def _set_max_prefixes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__max_prefixes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv4_unicast/prefix_limit/config/max_prefixes (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_max_prefixes is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_max_prefixes() directly.\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23231:c0:m3"}
{"signature": "def _set_restart_timer(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__restart_timer = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv4_unicast/prefix_limit/config/restart_timer (decimal64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_restart_timer is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_restart_timer() directly.\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23231:c0:m12"}
{"signature": "def _get_max_prefixes(self):", "body": "return self.__max_prefixes<EOL>", "docstring": "Getter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv4_unicast/prefix_limit/config/max_prefixes (uint32)\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23231:c0:m2"}
{"signature": "def _set_prevent_teardown(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prevent_teardown = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv4_unicast/prefix_limit/config/prevent_teardown (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prevent_teardown is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prevent_teardown() directly.\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23231:c0:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv4_unicast/prefix_limit/state (container)\n\n    YANG Description: State information relating to the prefix-limit for the\nAFI-SAFI", "id": "f23232:c0:m5"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv4_unicast/prefix_limit/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to the prefix\nlimit for the AFI-SAFI", "id": "f23232:c1:m3"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv4_unicast/prefix_limit/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to the prefix\nlimit for the AFI-SAFI", "id": "f23232:c0:m3"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis/afi_safi/ipv4_unicast/prefix_limit/config (container)\n\n    YANG Description: Configuration parameters relating to the prefix\nlimit for the AFI-SAFI", "id": "f23232:c0:m2"}
{"signature": "def _get_keepalive_interval(self):", "body": "return self.__keepalive_interval<EOL>", "docstring": "Getter method for keepalive_interval, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/timers/state/keepalive_interval (decimal64)\n\n    YANG Description: Time interval in seconds between transmission of keepalive\nmessages to the neighbor.  Typically set to 1/3 the\nhold-time.", "id": "f23233:c1:m8"}
{"signature": "def _get_minimum_advertisement_interval(self):", "body": "return self.__minimum_advertisement_interval<EOL>", "docstring": "Getter method for minimum_advertisement_interval, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/timers/state/minimum_advertisement_interval (decimal64)\n\n    YANG Description: Minimum time which must elapse between subsequent UPDATE\nmessages relating to a common set of NLRI being transmitted\nto a peer. This timer is referred to as\nMinRouteAdvertisementIntervalTimer by RFC 4721 and serves to\nreduce the number of UPDATE messages transmitted when a\nparticular set of NLRI exhibit instability.", "id": "f23233:c1:m11"}
{"signature": "def _set_keepalive_interval(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>),<EOL>default=Decimal(<NUM_LIT:30>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__keepalive_interval = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "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)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_keepalive_interval is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_keepalive_interval() directly.\n\n    YANG Description: Time interval in seconds between transmission of keepalive\nmessages to the neighbor.  Typically set to 1/3 the\nhold-time.", "id": "f23233:c0:m9"}
{"signature": "def _get_connect_retry(self):", "body": "return self.__connect_retry<EOL>", "docstring": "Getter method for connect_retry, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/timers/state/connect_retry (decimal64)\n\n    YANG Description: Time interval in seconds between attempts to establish a\nsession with the peer.", "id": "f23233:c0:m2"}
{"signature": "def _set_connect_retry(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>),<EOL>default=Decimal(<NUM_LIT:30>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__connect_retry = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for connect_retry, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/timers/config/connect_retry (decimal64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_connect_retry is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_connect_retry() directly.\n\n    YANG Description: Time interval in seconds between attempts to establish a\nsession with the peer.", "id": "f23234:c1:m3"}
{"signature": "def _get_keepalive_interval(self):", "body": "return self.__keepalive_interval<EOL>", "docstring": "Getter method for keepalive_interval, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/timers/config/keepalive_interval (decimal64)\n\n    YANG Description: Time interval in seconds between transmission of keepalive\nmessages to the neighbor.  Typically set to 1/3 the\nhold-time.", "id": "f23234:c1:m8"}
{"signature": "def _get_connect_retry(self):", "body": "return self.__connect_retry<EOL>", "docstring": "Getter method for connect_retry, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/timers/config/connect_retry (decimal64)\n\n    YANG Description: Time interval in seconds between attempts to establish a\nsession with the peer.", "id": "f23234:c0:m2"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/timers/config (container)\n\n    YANG Description: Configuration parameters relating to timers used for the\nBGP neighbor or peer group", "id": "f23235:c1:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/timers/state (container)\n\n    YANG Description: State information relating to the timers used for the BGP\ngroup", "id": "f23235:c1:m5"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/timers/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to timers used for the\nBGP neighbor or peer group", "id": "f23235:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/timers/state (container)\n\n    YANG Description: State information relating to the timers used for the BGP\ngroup", "id": "f23235:c0:m5"}
{"signature": "def _set_treat_as_withdraw(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__treat_as_withdraw = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for treat_as_withdraw, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/error_handling/state/treat_as_withdraw (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_treat_as_withdraw is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_treat_as_withdraw() directly.\n\n    YANG Description: Specify whether erroneous UPDATE messages for which the\nNLRI can be extracted are reated as though the NLRI is\nwithdrawn - avoiding session reset", "id": "f23236:c0:m3"}
{"signature": "def _set_treat_as_withdraw(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__treat_as_withdraw = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for treat_as_withdraw, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/error_handling/config/treat_as_withdraw (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_treat_as_withdraw is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_treat_as_withdraw() directly.\n\n    YANG Description: Specify whether erroneous UPDATE messages for which the\nNLRI can be extracted are reated as though the NLRI is\nwithdrawn - avoiding session reset", "id": "f23237:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/error_handling/state (container)\n\n    YANG Description: State information relating to enhanced error handling\nmechanisms for the BGP group", "id": "f23238:c0:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/error_handling/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: State information relating to enhanced error handling\nmechanisms for the BGP group", "id": "f23238:c0:m6"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/error_handling/config (container)\n\n    YANG Description: Configuration parameters enabling or modifying the\nbehavior or enhanced error handling mechanisms for the BGP\ngroup", "id": "f23238:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/error_handling/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: State information relating to enhanced error handling\nmechanisms for the BGP group", "id": "f23238:c1:m6"}
{"signature": "def _set_auth_password(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__auth_password = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for auth_password, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/config/auth_password (oc-types:routing-password)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_auth_password is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_auth_password() directly.\n\n    YANG Description: Configures an MD5 authentication password for use with\nneighboring devices.", "id": "f23239:c0:m15"}
{"signature": "def _get_peer_group_name(self):", "body": "return self.__peer_group_name<EOL>", "docstring": "Getter method for peer_group_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/config/peer_group_name (string)\n\nYANG Description: Name of the BGP peer-group", "id": "f23239:c1:m2"}
{"signature": "def _set_description(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:description>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__description = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for description, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/config/description (string)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_description is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_description() directly.\n\n    YANG Description: An optional textual description (intended primarily for use\nwith a peer or group", "id": "f23239:c1:m27"}
{"signature": "def _set_auth_password(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__auth_password = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for auth_password, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/config/auth_password (oc-types:routing-password)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_auth_password is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_auth_password() directly.\n\n    YANG Description: Configures an MD5 authentication password for use with\nneighboring devices.", "id": "f23239:c1:m15"}
{"signature": "def _set_route_flap_damping(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__route_flap_damping = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for route_flap_damping, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/config/route_flap_damping (boolean)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_route_flap_damping is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_route_flap_damping() directly.\n\nYANG Description: Enable route flap damping.", "id": "f23239:c1:m21"}
{"signature": "def _get_auth_password(self):", "body": "return self.__auth_password<EOL>", "docstring": "Getter method for auth_password, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/config/auth_password (oc-types:routing-password)\n\n    YANG Description: Configures an MD5 authentication password for use with\nneighboring devices.", "id": "f23239:c0:m14"}
{"signature": "def _set_peer_as(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__peer_as = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for peer_as, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/config/peer_as (oc-inet:as-number)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_peer_as is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_peer_as() directly.\n\nYANG Description: AS number of the peer.", "id": "f23239:c0:m6"}
{"signature": "def _set_peer_group_name(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__peer_group_name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for peer_group_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/config/peer_group_name (string)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_peer_group_name is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_peer_group_name() directly.\n\nYANG Description: Name of the BGP peer-group", "id": "f23239:c1:m3"}
{"signature": "def _set_send_community(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {}, \"<STR_LIT>\": {}, \"<STR_LIT>\": {}, \"<STR_LIT>\": {}<EOL>},<EOL>),<EOL>default=six.text_type(\"<STR_LIT>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__send_community = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for send_community, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/config/send_community (oc-bgp-types:community-type)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_send_community is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_send_community() directly.\n\n    YANG Description: Specify which types of community should be sent to the\nneighbor or group. The default is to not send the\ncommunity attribute", "id": "f23239:c0:m24"}
{"signature": "def _get_route_flap_damping(self):", "body": "return self.__route_flap_damping<EOL>", "docstring": "Getter method for route_flap_damping, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/config/route_flap_damping (boolean)\n\nYANG Description: Enable route flap damping.", "id": "f23239:c0:m20"}
{"signature": "def _get_peer_type(self):", "body": "return self.__peer_type<EOL>", "docstring": "Getter method for peer_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/config/peer_type (oc-bgp-types:peer-type)\n\n    YANG Description: Explicitly designate the peer or peer group as internal\n(iBGP) or external (eBGP).", "id": "f23239:c1:m11"}
{"signature": "def _set_local_as(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__local_as = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for local_as, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/config/local_as (oc-inet:as-number)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_local_as is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_local_as() directly.\n\n    YANG Description: The local autonomous system number that is to be used\nwhen establishing sessions with the remote peer or peer\ngroup, if this differs from the global BGP router\nautonomous system number.", "id": "f23239:c0:m9"}
{"signature": "def _set_peer_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__peer_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for peer_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/config/peer_type (oc-bgp-types:peer-type)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_peer_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_peer_type() directly.\n\n    YANG Description: Explicitly designate the peer or peer group as internal\n(iBGP) or external (eBGP).", "id": "f23239:c0:m12"}
{"signature": "def _get_remove_private_as(self):", "body": "return self.__remove_private_as<EOL>", "docstring": "Getter method for remove_private_as, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/config/remove_private_as (oc-bgp-types:remove-private-as-option)\n\n    YANG Description: Remove private AS numbers from updates sent to peers - when\nthis leaf is not specified, the AS_PATH attribute should be\nsent to the peer unchanged", "id": "f23239:c0:m17"}
{"signature": "def _get_peer_group_name(self):", "body": "return self.__peer_group_name<EOL>", "docstring": "Getter method for peer_group_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/config/peer_group_name (string)\n\nYANG Description: Name of the BGP peer-group", "id": "f23239:c0:m2"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/use_multiple_paths/state/enabled (boolean)\n\n    YANG Description: Whether the use of multiple paths for the same NLRI is\nenabled for the neighbor. This value is overridden by\nany more specific configuration value.", "id": "f23240:c1:m2"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/use_multiple_paths/config/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: Whether the use of multiple paths for the same NLRI is\nenabled for the neighbor. This value is overridden by\nany more specific configuration value.", "id": "f23241:c0:m3"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/use_multiple_paths/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration parameters relating to multipath", "id": "f23242:c0:m3"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/use_multiple_paths/config (container)\n\nYANG Description: Configuration parameters relating to multipath", "id": "f23242:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/use_multiple_paths/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters relating to multipath", "id": "f23242:c0:m6"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/use_multiple_paths/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration parameters relating to multipath", "id": "f23242:c1:m3"}
{"signature": "def _set_maximum_paths(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>default=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>)(<EOL><NUM_LIT:1><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__maximum_paths = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for maximum_paths, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/use_multiple_paths/ibgp/state/maximum_paths (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_maximum_paths is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_maximum_paths() directly.\n\n    YANG Description: Maximum number of parallel paths to consider when using\niBGP multipath. The default is to use a single path", "id": "f23243:c0:m3"}
{"signature": "def _set_maximum_paths(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>default=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>)(<EOL><NUM_LIT:1><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__maximum_paths = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for maximum_paths, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/use_multiple_paths/ibgp/config/maximum_paths (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_maximum_paths is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_maximum_paths() directly.\n\n    YANG Description: Maximum number of parallel paths to consider when using\niBGP multipath. The default is to use a single path", "id": "f23244:c1:m3"}
{"signature": "def _get_maximum_paths(self):", "body": "return self.__maximum_paths<EOL>", "docstring": "Getter method for maximum_paths, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/use_multiple_paths/ibgp/config/maximum_paths (uint32)\n\n    YANG Description: Maximum number of parallel paths to consider when using\niBGP multipath. The default is to use a single path", "id": "f23244:c0:m2"}
{"signature": "def _set_maximum_paths(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>default=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>)(<EOL><NUM_LIT:1><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__maximum_paths = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for maximum_paths, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/use_multiple_paths/ibgp/config/maximum_paths (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_maximum_paths is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_maximum_paths() directly.\n\n    YANG Description: Maximum number of parallel paths to consider when using\niBGP multipath. The default is to use a single path", "id": "f23244:c0:m3"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/use_multiple_paths/ibgp/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration parameters relating to iBGP multipath", "id": "f23245:c0:m3"}
{"signature": "def _set_allow_multiple_as(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__allow_multiple_as = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for allow_multiple_as, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/use_multiple_paths/ebgp/state/allow_multiple_as (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_allow_multiple_as is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_allow_multiple_as() directly.\n\n    YANG Description: Allow multipath to use paths from different neighbouring\nASes.  The default is to only consider multiple paths from\nthe same neighbouring AS.", "id": "f23246:c1:m3"}
{"signature": "def _get_allow_multiple_as(self):", "body": "return self.__allow_multiple_as<EOL>", "docstring": "Getter method for allow_multiple_as, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/use_multiple_paths/ebgp/config/allow_multiple_as (boolean)\n\n    YANG Description: Allow multipath to use paths from different neighbouring\nASes.  The default is to only consider multiple paths from\nthe same neighbouring AS.", "id": "f23247:c0:m2"}
{"signature": "def _get_allow_multiple_as(self):", "body": "return self.__allow_multiple_as<EOL>", "docstring": "Getter method for allow_multiple_as, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/use_multiple_paths/ebgp/config/allow_multiple_as (boolean)\n\n    YANG Description: Allow multipath to use paths from different neighbouring\nASes.  The default is to only consider multiple paths from\nthe same neighbouring AS.", "id": "f23247:c1:m2"}
{"signature": "def _get_maximum_paths(self):", "body": "return self.__maximum_paths<EOL>", "docstring": "Getter method for maximum_paths, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/use_multiple_paths/ebgp/config/maximum_paths (uint32)\n\n    YANG Description: Maximum number of parallel paths to consider when using\nBGP multipath. The default is use a single path.", "id": "f23247:c0:m5"}
{"signature": "def _get_export_policy(self):", "body": "return self.__export_policy<EOL>", "docstring": "Getter method for export_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/apply_policy/state/export_policy (leafref)\n\n    YANG Description: list of policy names in sequence to be applied on\nsending a routing update in the current context, e.g.,\nfor the current peer group, neighbor, address family,\netc.", "id": "f23249:c1:m8"}
{"signature": "def _set_import_policy(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(allowed_type=six.text_type),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__import_policy = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for import_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/apply_policy/state/import_policy (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_import_policy is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_import_policy() directly.\n\n    YANG Description: list of policy names in sequence to be applied on\nreceiving a routing update in the current context, e.g.,\nfor the current peer group, neighbor, address family,\netc.", "id": "f23249:c1:m3"}
{"signature": "def _get_default_export_policy(self):", "body": "return self.__default_export_policy<EOL>", "docstring": "Getter method for default_export_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/apply_policy/state/default_export_policy (default-policy-type)\n\n    YANG Description: explicitly set a default policy if no policy definition\nin the export policy chain is satisfied.", "id": "f23249:c1:m11"}
{"signature": "def _set_default_export_policy(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>default=six.text_type(\"<STR_LIT>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__default_export_policy = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for default_export_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/apply_policy/state/default_export_policy (default-policy-type)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_default_export_policy is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_default_export_policy() directly.\n\n    YANG Description: explicitly set a default policy if no policy definition\nin the export policy chain is satisfied.", "id": "f23249:c0:m12"}
{"signature": "def _set_default_export_policy(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>default=six.text_type(\"<STR_LIT>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__default_export_policy = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for default_export_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/apply_policy/state/default_export_policy (default-policy-type)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_default_export_policy is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_default_export_policy() directly.\n\n    YANG Description: explicitly set a default policy if no policy definition\nin the export policy chain is satisfied.", "id": "f23249:c1:m12"}
{"signature": "def _set_export_policy(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(allowed_type=six.text_type),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__export_policy = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for export_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/apply_policy/state/export_policy (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_export_policy is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_export_policy() directly.\n\n    YANG Description: list of policy names in sequence to be applied on\nsending a routing update in the current context, e.g.,\nfor the current peer group, neighbor, address family,\netc.", "id": "f23249:c0:m9"}
{"signature": "def _set_import_policy(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(allowed_type=six.text_type),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__import_policy = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for import_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/apply_policy/state/import_policy (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_import_policy is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_import_policy() directly.\n\n    YANG Description: list of policy names in sequence to be applied on\nreceiving a routing update in the current context, e.g.,\nfor the current peer group, neighbor, address family,\netc.", "id": "f23249:c0:m3"}
{"signature": "def _get_default_export_policy(self):", "body": "return self.__default_export_policy<EOL>", "docstring": "Getter method for default_export_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/apply_policy/config/default_export_policy (default-policy-type)\n\n    YANG Description: explicitly set a default policy if no policy definition\nin the export policy chain is satisfied.", "id": "f23250:c1:m11"}
{"signature": "def _get_default_import_policy(self):", "body": "return self.__default_import_policy<EOL>", "docstring": "Getter method for default_import_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/apply_policy/config/default_import_policy (default-policy-type)\n\n    YANG Description: explicitly set a default policy if no policy definition\nin the import policy chain is satisfied.", "id": "f23250:c0:m5"}
{"signature": "def _set_default_export_policy(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>default=six.text_type(\"<STR_LIT>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__default_export_policy = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for default_export_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/apply_policy/config/default_export_policy (default-policy-type)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_default_export_policy is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_default_export_policy() directly.\n\n    YANG Description: explicitly set a default policy if no policy definition\nin the export policy chain is satisfied.", "id": "f23250:c0:m12"}
{"signature": "def _set_export_policy(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(allowed_type=six.text_type),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__export_policy = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for export_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/apply_policy/config/export_policy (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_export_policy is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_export_policy() directly.\n\n    YANG Description: list of policy names in sequence to be applied on\nsending a routing update in the current context, e.g.,\nfor the current peer group, neighbor, address family,\netc.", "id": "f23250:c1:m9"}
{"signature": "def _get_default_import_policy(self):", "body": "return self.__default_import_policy<EOL>", "docstring": "Getter method for default_import_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/apply_policy/config/default_import_policy (default-policy-type)\n\n    YANG Description: explicitly set a default policy if no policy definition\nin the import policy chain is satisfied.", "id": "f23250:c1:m5"}
{"signature": "def _get_import_policy(self):", "body": "return self.__import_policy<EOL>", "docstring": "Getter method for import_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/apply_policy/config/import_policy (leafref)\n\n    YANG Description: list of policy names in sequence to be applied on\nreceiving a routing update in the current context, e.g.,\nfor the current peer group, neighbor, address family,\netc.", "id": "f23250:c1:m2"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/apply_policy/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Policy configuration data.", "id": "f23251:c1:m3"}
{"signature": "def _get_ebgp_multihop(self):", "body": "return self.__ebgp_multihop<EOL>", "docstring": "Getter method for ebgp_multihop, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/ebgp_multihop (container)\n\nYANG Description: eBGP multi-hop parameters for the BGPgroup", "id": "f23252:c0:m26"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to the BGP neighbor or\ngroup", "id": "f23252:c1:m6"}
{"signature": "def _set_apply_policy(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=apply_policy.apply_policy,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__apply_policy = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for apply_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/apply_policy (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_apply_policy is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_apply_policy() directly.\n\n    YANG Description: Anchor point for routing policies in the model.\nImport and export policies are with respect to the local\nrouting table, i.e., export (send) and import (receive),\ndepending on the context.", "id": "f23252:c1:m42"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State information relating to the BGP peer-group", "id": "f23252:c0:m9"}
{"signature": "def _set_apply_policy(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=apply_policy.apply_policy,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__apply_policy = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for apply_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/apply_policy (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_apply_policy is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_apply_policy() directly.\n\n    YANG Description: Anchor point for routing policies in the model.\nImport and export policies are with respect to the local\nrouting table, i.e., export (send) and import (receive),\ndepending on the context.", "id": "f23252:c0:m42"}
{"signature": "def _set_afi_safis(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=afi_safis.afi_safis,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__afi_safis = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for afi_safis, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_afi_safis is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_afi_safis() directly.\n\n    YANG Description: Per-address-family configuration parameters associated with\nthegroup", "id": "f23252:c0:m45"}
{"signature": "def _set_afi_safis(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=afi_safis.afi_safis,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__afi_safis = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for afi_safis, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/afi_safis (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_afi_safis is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_afi_safis() directly.\n\n    YANG Description: Per-address-family configuration parameters associated with\nthegroup", "id": "f23252:c1:m45"}
{"signature": "def _get_ebgp_multihop(self):", "body": "return self.__ebgp_multihop<EOL>", "docstring": "Getter method for ebgp_multihop, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/ebgp_multihop (container)\n\nYANG Description: eBGP multi-hop parameters for the BGPgroup", "id": "f23252:c1:m26"}
{"signature": "def _set_transport(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=transport.transport,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__transport = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for transport, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/transport (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_transport is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_transport() directly.\n\nYANG Description: Transport session parameters for the BGP peer-group", "id": "f23252:c0:m15"}
{"signature": "def _get_graceful_restart(self):", "body": "return self.__graceful_restart<EOL>", "docstring": "Getter method for graceful_restart, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/graceful_restart (container)\n\nYANG Description: Parameters relating the graceful restart mechanism for BGP", "id": "f23252:c0:m20"}
{"signature": "def _get_transport(self):", "body": "return self.__transport<EOL>", "docstring": "Getter method for transport, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/transport (container)\n\nYANG Description: Transport session parameters for the BGP peer-group", "id": "f23252:c1:m14"}
{"signature": "def _get_error_handling(self):", "body": "return self.__error_handling<EOL>", "docstring": "Getter method for error_handling, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/error_handling (container)\n\nYANG Description: Error handling parameters used for the BGP peer-group", "id": "f23252:c0:m17"}
{"signature": "def _get_transport(self):", "body": "return self.__transport<EOL>", "docstring": "Getter method for transport, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/transport (container)\n\nYANG Description: Transport session parameters for the BGP peer-group", "id": "f23252:c0:m14"}
{"signature": "def _set_route_reflector(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=route_reflector.route_reflector,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__route_reflector = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for route_reflector, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/route_reflector (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_route_reflector is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_route_reflector() directly.\n\nYANG Description: Route reflector parameters for the BGPgroup", "id": "f23252:c0:m30"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State information relating to the BGP peer-group", "id": "f23252:c1:m9"}
{"signature": "def _set_error_handling(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=error_handling.error_handling,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__error_handling = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for error_handling, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/error_handling (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_error_handling is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_error_handling() directly.\n\nYANG Description: Error handling parameters used for the BGP peer-group", "id": "f23252:c0:m18"}
{"signature": "def _set_timers(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=timers.timers,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__timers = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for timers, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/timers (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_timers is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_timers() directly.\n\nYANG Description: Timers related to a BGP peer-group", "id": "f23252:c0:m12"}
{"signature": "def _get_peer_group_name(self):", "body": "return self.__peer_group_name<EOL>", "docstring": "Getter method for peer_group_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/peer_group_name (leafref)\n\n    YANG Description: Reference to the name of the BGP peer-group used as a\nkey in the peer-group list", "id": "f23252:c0:m2"}
{"signature": "def _get_route_reflector(self):", "body": "return self.__route_reflector<EOL>", "docstring": "Getter method for route_reflector, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/route_reflector (container)\n\nYANG Description: Route reflector parameters for the BGPgroup", "id": "f23252:c1:m29"}
{"signature": "def _get_use_multiple_paths(self):", "body": "return self.__use_multiple_paths<EOL>", "docstring": "Getter method for use_multiple_paths, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/use_multiple_paths (container)\n\n    YANG Description: Parameters related to the use of multiple paths for the\nsame NLRI", "id": "f23252:c0:m38"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/ebgp_multihop/state/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: When enabled the referenced group or neighbors are permitted\nto be indirectly connected - including cases where the TTL\ncan be decremented between the BGP peers", "id": "f23253:c0:m3"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/ebgp_multihop/config/enabled (boolean)\n\n    YANG Description: When enabled the referenced group or neighbors are permitted\nto be indirectly connected - including cases where the TTL\ncan be decremented between the BGP peers", "id": "f23254:c1:m2"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/ebgp_multihop/config/enabled (boolean)\n\n    YANG Description: When enabled the referenced group or neighbors are permitted\nto be indirectly connected - including cases where the TTL\ncan be decremented between the BGP peers", "id": "f23254:c0:m2"}
{"signature": "def _get_multihop_ttl(self):", "body": "return self.__multihop_ttl<EOL>", "docstring": "Getter method for multihop_ttl, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/ebgp_multihop/config/multihop_ttl (uint8)\n\n    YANG Description: Time-to-live value to use when packets are sent to the\nreferenced group or neighbors and ebgp-multihop is enabled", "id": "f23254:c0:m5"}
{"signature": "def _get_multihop_ttl(self):", "body": "return self.__multihop_ttl<EOL>", "docstring": "Getter method for multihop_ttl, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/ebgp_multihop/config/multihop_ttl (uint8)\n\n    YANG Description: Time-to-live value to use when packets are sent to the\nreferenced group or neighbors and ebgp-multihop is enabled", "id": "f23254:c1:m5"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/ebgp_multihop/config (container)\n\n    YANG Description: Configuration parameters relating to eBGP multihop for the\nBGP group", "id": "f23255:c1:m2"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/ebgp_multihop/config (container)\n\n    YANG Description: Configuration parameters relating to eBGP multihop for the\nBGP group", "id": "f23255:c0:m2"}
{"signature": "def _get_eligible_prefix_policy(self):", "body": "return self.__eligible_prefix_policy<EOL>", "docstring": "Getter method for eligible_prefix_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/add_paths/state/eligible_prefix_policy (leafref)\n\n    YANG Description: A reference to a routing policy which can be used to\nrestrict the prefixes for which add-paths is enabled", "id": "f23256:c1:m8"}
{"signature": "def _set_receive(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__receive = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for receive, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/add_paths/state/receive (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_receive is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_receive() directly.\n\n    YANG Description: Enable ability to receive multiple path advertisements\nfor an NLRI from the neighbor or group", "id": "f23256:c1:m3"}
{"signature": "def _set_send_max(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__send_max = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for send_max, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/add_paths/state/send_max (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_send_max is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_send_max() directly.\n\n    YANG Description: The maximum number of paths to advertise to neighbors\nfor a single NLRI", "id": "f23256:c0:m6"}
{"signature": "def _get_send_max(self):", "body": "return self.__send_max<EOL>", "docstring": "Getter method for send_max, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/add_paths/state/send_max (uint8)\n\n    YANG Description: The maximum number of paths to advertise to neighbors\nfor a single NLRI", "id": "f23256:c0:m5"}
{"signature": "def _get_send_max(self):", "body": "return self.__send_max<EOL>", "docstring": "Getter method for send_max, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/add_paths/config/send_max (uint8)\n\n    YANG Description: The maximum number of paths to advertise to neighbors\nfor a single NLRI", "id": "f23257:c0:m5"}
{"signature": "def _set_eligible_prefix_policy(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__eligible_prefix_policy = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for eligible_prefix_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/add_paths/config/eligible_prefix_policy (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_eligible_prefix_policy is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_eligible_prefix_policy() directly.\n\n    YANG Description: A reference to a routing policy which can be used to\nrestrict the prefixes for which add-paths is enabled", "id": "f23257:c0:m9"}
{"signature": "def _get_receive(self):", "body": "return self.__receive<EOL>", "docstring": "Getter method for receive, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/add_paths/config/receive (boolean)\n\n    YANG Description: Enable ability to receive multiple path advertisements\nfor an NLRI from the neighbor or group", "id": "f23257:c1:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/add_paths/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State information associated with ADD_PATHS", "id": "f23258:c0:m6"}
{"signature": "def _get_log_neighbor_state_changes(self):", "body": "return self.__log_neighbor_state_changes<EOL>", "docstring": "Getter method for log_neighbor_state_changes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/logging_options/state/log_neighbor_state_changes (boolean)\n\n    YANG Description: Configure logging of peer state changes.  Default is\nto enable logging of peer state changes.", "id": "f23259:c1:m2"}
{"signature": "def _set_log_neighbor_state_changes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:true>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__log_neighbor_state_changes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for log_neighbor_state_changes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/logging_options/state/log_neighbor_state_changes (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_log_neighbor_state_changes is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_log_neighbor_state_changes() directly.\n\n    YANG Description: Configure logging of peer state changes.  Default is\nto enable logging of peer state changes.", "id": "f23259:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/logging_options/state (container)\n\n    YANG Description: State information relating to logging for the BGP neighbor\nor group", "id": "f23261:c0:m5"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/logging_options/config (container)\n\n    YANG Description: Configuration parameters enabling or modifying logging\nfor events relating to the BGPgroup", "id": "f23261:c0:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/logging_options/state (container)\n\n    YANG Description: State information relating to logging for the BGP neighbor\nor group", "id": "f23261:c1:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/logging_options/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: State information relating to logging for the BGP neighbor\nor group", "id": "f23261:c1:m6"}
{"signature": "def _set_passive_mode(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__passive_mode = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for passive_mode, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/transport/state/passive_mode (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_passive_mode is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_passive_mode() directly.\n\n    YANG Description: Wait for peers to issue requests to open a BGP session,\nrather than initiating sessions from the local router.", "id": "f23262:c1:m9"}
{"signature": "def _set_local_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>six.text_type,<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__local_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for local_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/transport/state/local_address (union)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_local_address is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_local_address() directly.\n\n    YANG Description: Set the local IP (either IPv4 or IPv6) address to use\nfor the session when sending BGP update messages.  This\nmay be expressed as either an IP address or reference\nto the name of an interface.", "id": "f23262:c1:m12"}
{"signature": "def _get_passive_mode(self):", "body": "return self.__passive_mode<EOL>", "docstring": "Getter method for passive_mode, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/transport/state/passive_mode (boolean)\n\n    YANG Description: Wait for peers to issue requests to open a BGP session,\nrather than initiating sessions from the local router.", "id": "f23262:c0:m8"}
{"signature": "def _set_tcp_mss(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__tcp_mss = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for tcp_mss, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/transport/state/tcp_mss (uint16)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_tcp_mss is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_tcp_mss() directly.\n\nYANG Description: Sets the max segment size for BGP TCP sessions.", "id": "f23262:c1:m3"}
{"signature": "def _set_mtu_discovery(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__mtu_discovery = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for mtu_discovery, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/transport/state/mtu_discovery (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_mtu_discovery is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_mtu_discovery() directly.\n\n    YANG Description: Turns path mtu discovery for BGP TCP sessions on (true)\nor off (false)", "id": "f23262:c1:m6"}
{"signature": "def _get_passive_mode(self):", "body": "return self.__passive_mode<EOL>", "docstring": "Getter method for passive_mode, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/transport/config/passive_mode (boolean)\n\n    YANG Description: Wait for peers to issue requests to open a BGP session,\nrather than initiating sessions from the local router.", "id": "f23263:c0:m8"}
{"signature": "def _set_tcp_mss(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__tcp_mss = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for tcp_mss, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/transport/config/tcp_mss (uint16)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_tcp_mss is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_tcp_mss() directly.\n\nYANG Description: Sets the max segment size for BGP TCP sessions.", "id": "f23263:c0:m3"}
{"signature": "def _set_passive_mode(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__passive_mode = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for passive_mode, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/transport/config/passive_mode (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_passive_mode is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_passive_mode() directly.\n\n    YANG Description: Wait for peers to issue requests to open a BGP session,\nrather than initiating sessions from the local router.", "id": "f23263:c1:m9"}
{"signature": "def _get_passive_mode(self):", "body": "return self.__passive_mode<EOL>", "docstring": "Getter method for passive_mode, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/transport/config/passive_mode (boolean)\n\n    YANG Description: Wait for peers to issue requests to open a BGP session,\nrather than initiating sessions from the local router.", "id": "f23263:c1:m8"}
{"signature": "def _set_passive_mode(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__passive_mode = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for passive_mode, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/transport/config/passive_mode (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_passive_mode is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_passive_mode() directly.\n\n    YANG Description: Wait for peers to issue requests to open a BGP session,\nrather than initiating sessions from the local router.", "id": "f23263:c0:m9"}
{"signature": "def _get_replace_peer_as(self):", "body": "return self.__replace_peer_as<EOL>", "docstring": "Getter method for replace_peer_as, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/as_path_options/state/replace_peer_as (boolean)\n\n    YANG Description: Replace occurrences of the peer's AS in the AS_PATH\nwith the local autonomous system number", "id": "f23265:c0:m5"}
{"signature": "def _get_replace_peer_as(self):", "body": "return self.__replace_peer_as<EOL>", "docstring": "Getter method for replace_peer_as, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/as_path_options/state/replace_peer_as (boolean)\n\n    YANG Description: Replace occurrences of the peer's AS in the AS_PATH\nwith the local autonomous system number", "id": "f23265:c1:m5"}
{"signature": "def _get_allow_own_as(self):", "body": "return self.__allow_own_as<EOL>", "docstring": "Getter method for allow_own_as, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/as_path_options/state/allow_own_as (uint8)\n\n    YANG Description: Specify the number of occurrences of the local BGP speaker's\nAS that can occur within the AS_PATH before it is rejected.", "id": "f23265:c0:m2"}
{"signature": "def _get_allow_own_as(self):", "body": "return self.__allow_own_as<EOL>", "docstring": "Getter method for allow_own_as, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/as_path_options/config/allow_own_as (uint8)\n\n    YANG Description: Specify the number of occurrences of the local BGP speaker's\nAS that can occur within the AS_PATH before it is rejected.", "id": "f23266:c0:m2"}
{"signature": "def _get_replace_peer_as(self):", "body": "return self.__replace_peer_as<EOL>", "docstring": "Getter method for replace_peer_as, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/as_path_options/config/replace_peer_as (boolean)\n\n    YANG Description: Replace occurrences of the peer's AS in the AS_PATH\nwith the local autonomous system number", "id": "f23266:c1:m5"}
{"signature": "def _get_allow_own_as(self):", "body": "return self.__allow_own_as<EOL>", "docstring": "Getter method for allow_own_as, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/as_path_options/config/allow_own_as (uint8)\n\n    YANG Description: Specify the number of occurrences of the local BGP speaker's\nAS that can occur within the AS_PATH before it is rejected.", "id": "f23266:c1:m2"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/as_path_options/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to AS_PATH manipulation\nfor the BGP peer or group", "id": "f23267:c1:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/as_path_options/state (container)\n\n    YANG Description: State information relating to the AS_PATH manipulation\nmechanisms for the BGP peer or group", "id": "f23267:c1:m5"}
{"signature": "def _get_local_restarting(self):", "body": "return self.__local_restarting<EOL>", "docstring": "Getter method for local_restarting, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/graceful_restart/state/local_restarting (boolean)\n\n    YANG Description: This flag indicates whether the local neighbor is currently\nrestarting. The flag is unset after all NLRI have been\nadvertised to the peer, and the End-of-RIB (EOR) marker has\nbeen unset", "id": "f23269:c0:m20"}
{"signature": "def _get_helper_only(self):", "body": "return self.__helper_only<EOL>", "docstring": "Getter method for helper_only, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/graceful_restart/state/helper_only (boolean)\n\n    YANG Description: Enable graceful-restart in helper mode only. When this\nleaf is set, the local system does not retain forwarding\nits own state during a restart, but supports procedures\nfor the receiving speaker, as defined in RFC4724.", "id": "f23269:c0:m11"}
{"signature": "def _set_local_restarting(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__local_restarting = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for local_restarting, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/graceful_restart/state/local_restarting (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_local_restarting is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_local_restarting() directly.\n\n    YANG Description: This flag indicates whether the local neighbor is currently\nrestarting. The flag is unset after all NLRI have been\nadvertised to the peer, and the End-of-RIB (EOR) marker has\nbeen unset", "id": "f23269:c1:m21"}
{"signature": "def _get_peer_restarting(self):", "body": "return self.__peer_restarting<EOL>", "docstring": "Getter method for peer_restarting, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/graceful_restart/state/peer_restarting (boolean)\n\n    YANG Description: This flag indicates whether the remote neighbor is currently\nin the process of restarting, and hence received routes are\ncurrently stale", "id": "f23269:c0:m17"}
{"signature": "def _get_mode(self):", "body": "return self.__mode<EOL>", "docstring": "Getter method for mode, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/graceful_restart/state/mode (enumeration)\n\n    YANG Description: Ths leaf indicates the mode of operation of BGP graceful\nrestart with the peer", "id": "f23269:c0:m23"}
{"signature": "def _set_peer_restarting(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__peer_restarting = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for peer_restarting, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/graceful_restart/state/peer_restarting (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_peer_restarting is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_peer_restarting() directly.\n\n    YANG Description: This flag indicates whether the remote neighbor is currently\nin the process of restarting, and hence received routes are\ncurrently stale", "id": "f23269:c1:m18"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/graceful_restart/state/enabled (boolean)\n\nYANG Description: Enable or disable the graceful-restart capability.", "id": "f23269:c1:m2"}
{"signature": "def _get_mode(self):", "body": "return self.__mode<EOL>", "docstring": "Getter method for mode, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/graceful_restart/state/mode (enumeration)\n\n    YANG Description: Ths leaf indicates the mode of operation of BGP graceful\nrestart with the peer", "id": "f23269:c1:m23"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/graceful_restart/config/enabled (boolean)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_enabled is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_enabled() directly.\n\nYANG Description: Enable or disable the graceful-restart capability.", "id": "f23270:c1:m3"}
{"signature": "def _get_stale_routes_time(self):", "body": "return self.__stale_routes_time<EOL>", "docstring": "Getter method for stale_routes_time, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/graceful_restart/config/stale_routes_time (decimal64)\n\n    YANG Description: An upper-bound on the time thate stale routes will be\nretained by a router after a session is restarted. If an\nEnd-of-RIB (EOR) marker is received prior to this timer\nexpiring stale-routes will be flushed upon its receipt - if\nno EOR is received, then when this timer expires stale paths\nwill be purged. This timer is referred to as the\nSelection_Deferral_Timer in RFC4724", "id": "f23270:c1:m8"}
{"signature": "def _set_helper_only(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__helper_only = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for helper_only, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/graceful_restart/config/helper_only (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_helper_only is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_helper_only() directly.\n\n    YANG Description: Enable graceful-restart in helper mode only. When this\nleaf is set, the local system does not retain forwarding\nits own state during a restart, but supports procedures\nfor the receiving speaker, as defined in RFC4724.", "id": "f23270:c0:m12"}
{"signature": "def _set_restart_time(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:16>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__restart_time = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for restart_time, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/graceful_restart/config/restart_time (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_restart_time is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_restart_time() directly.\n\n    YANG Description: Estimated time (in seconds) for the local BGP speaker to\nrestart a session. This value is advertise in the graceful\nrestart BGP capability.  This is a 12-bit value, referred to\nas Restart Time in RFC4724.  Per RFC4724, the suggested\ndefault value is <= the hold-time value.", "id": "f23270:c1:m6"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/graceful_restart/config (container)\n\nYANG Description: Configuration parameters relating to graceful-restart", "id": "f23271:c1:m2"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/graceful_restart/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration parameters relating to graceful-restart", "id": "f23271:c1:m3"}
{"signature": "def _get_input(self):", "body": "return self.__input<EOL>", "docstring": "Getter method for input, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/state/queues/input (uint32)\n\n    YANG Description: The number of messages received from the peer currently\nqueued", "id": "f23272:c0:m2"}
{"signature": "def _get_input(self):", "body": "return self.__input<EOL>", "docstring": "Getter method for input, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/state/queues/input (uint32)\n\n    YANG Description: The number of messages received from the peer currently\nqueued", "id": "f23272:c1:m2"}
{"signature": "def _set_input(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:input>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__input = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for input, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/state/queues/input (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_input is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_input() directly.\n\n    YANG Description: The number of messages received from the peer currently\nqueued", "id": "f23272:c0:m3"}
{"signature": "def _get_description(self):", "body": "return self.__description<EOL>", "docstring": "Getter method for description, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/state/description (string)\n\n    YANG Description: An optional textual description (intended primarily for use\nwith a peer or group", "id": "f23273:c0:m32"}
{"signature": "def _set_peer_group(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__peer_group = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for peer_group, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/state/peer_group (leafref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_peer_group is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_peer_group() directly.\n\nYANG Description: The peer-group with which this neighbor is associated", "id": "f23273:c1:m3"}
{"signature": "def _get_route_flap_damping(self):", "body": "return self.__route_flap_damping<EOL>", "docstring": "Getter method for route_flap_damping, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/state/route_flap_damping (boolean)\n\nYANG Description: Enable route flap damping.", "id": "f23273:c0:m26"}
{"signature": "def _set_neighbor_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__neighbor_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for neighbor_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/state/neighbor_address (oc-inet:ip-address)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_neighbor_address is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_neighbor_address() directly.\n\nYANG Description: Address of the BGP peer, either in IPv4 or IPv6", "id": "f23273:c1:m6"}
{"signature": "def _set_peer_group(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__peer_group = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for peer_group, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/state/peer_group (leafref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_peer_group is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_peer_group() directly.\n\nYANG Description: The peer-group with which this neighbor is associated", "id": "f23273:c0:m3"}
{"signature": "def _get_supported_capabilities(self):", "body": "return self.__supported_capabilities<EOL>", "docstring": "Getter method for supported_capabilities, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/state/supported_capabilities (identityref)\n\nYANG Description: BGP capabilities negotiated as supported with the peer", "id": "f23273:c0:m44"}
{"signature": "def _get_queues(self):", "body": "return self.__queues<EOL>", "docstring": "Getter method for queues, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/state/queues (container)\n\n    YANG Description: Counters related to queued messages associated with the\nBGP neighbor", "id": "f23273:c1:m50"}
{"signature": "def _get_last_established(self):", "body": "return self.__last_established<EOL>", "docstring": "Getter method for last_established, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/state/last_established (oc-types:timeticks64)\n\n    YANG Description: This timestamp indicates the time that the\nBGP session last transitioned in or out of the Established\nstate.  The value is the timestamp in seconds relative to\nthe Unix Epoch (Jan 1, 1970 00:00:00 UTC).\n\nThe BGP session uptime can be computed by clients as the\ndifference between this value and the current time in UTC\n(assuming the session is in the ESTABLISHED state, per the\nsession-state leaf).", "id": "f23273:c0:m38"}
{"signature": "def _set_peer_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__peer_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for peer_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/state/peer_type (oc-bgp-types:peer-type)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_peer_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_peer_type() directly.\n\n    YANG Description: Explicitly designate the peer or peer group as internal\n(iBGP) or external (eBGP).", "id": "f23273:c0:m18"}
{"signature": "def _get_established_transitions(self):", "body": "return self.__established_transitions<EOL>", "docstring": "Getter method for established_transitions, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/state/established_transitions (oc-yang:counter64)\n\n    YANG Description: Number of transitions to the Established state for\nthe neighbor session.  This value is analogous to the\nbgpPeerFsmEstablishedTransitions object from the standard\nBGP-4 MIB", "id": "f23273:c0:m41"}
{"signature": "def _get_peer_group(self):", "body": "return self.__peer_group<EOL>", "docstring": "Getter method for peer_group, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/state/peer_group (leafref)\n\nYANG Description: The peer-group with which this neighbor is associated", "id": "f23273:c1:m2"}
{"signature": "def _set_description(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:description>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__description = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for description, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/state/description (string)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_description is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_description() directly.\n\n    YANG Description: An optional textual description (intended primarily for use\nwith a peer or group", "id": "f23273:c0:m33"}
{"signature": "def _get_peer_as(self):", "body": "return self.__peer_as<EOL>", "docstring": "Getter method for peer_as, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/state/peer_as (oc-inet:as-number)\n\nYANG Description: AS number of the peer.", "id": "f23273:c0:m11"}
{"signature": "def _set_established_transitions(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__established_transitions = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for established_transitions, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/state/established_transitions (oc-yang:counter64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_established_transitions is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_established_transitions() directly.\n\n    YANG Description: Number of transitions to the Established state for\nthe neighbor session.  This value is analogous to the\nbgpPeerFsmEstablishedTransitions object from the standard\nBGP-4 MIB", "id": "f23273:c0:m42"}
{"signature": "def _set_queues(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=queues.queues,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__queues = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for queues, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/state/queues (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_queues is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_queues() directly.\n\n    YANG Description: Counters related to queued messages associated with the\nBGP neighbor", "id": "f23273:c0:m51"}
{"signature": "def _get_messages(self):", "body": "return self.__messages<EOL>", "docstring": "Getter method for messages, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/state/messages (container)\n\n    YANG Description: Counters for BGP messages sent and received from the\nneighbor", "id": "f23273:c1:m47"}
{"signature": "def _get_local_as(self):", "body": "return self.__local_as<EOL>", "docstring": "Getter method for local_as, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/state/local_as (oc-inet:as-number)\n\n    YANG Description: The local autonomous system number that is to be used\nwhen establishing sessions with the remote peer or peer\ngroup, if this differs from the global BGP router\nautonomous system number.", "id": "f23273:c0:m14"}
{"signature": "def _set_description(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:description>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:string>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:string>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__description = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for description, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/state/description (string)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_description is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_description() directly.\n\n    YANG Description: An optional textual description (intended primarily for use\nwith a peer or group", "id": "f23273:c1:m33"}
{"signature": "def _set_last_established(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__last_established = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for last_established, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/state/last_established (oc-types:timeticks64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_last_established is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_last_established() directly.\n\n    YANG Description: This timestamp indicates the time that the\nBGP session last transitioned in or out of the Established\nstate.  The value is the timestamp in seconds relative to\nthe Unix Epoch (Jan 1, 1970 00:00:00 UTC).\n\nThe BGP session uptime can be computed by clients as the\ndifference between this value and the current time in UTC\n(assuming the session is in the ESTABLISHED state, per the\nsession-state leaf).", "id": "f23273:c0:m39"}
{"signature": "def _get_dynamically_configured(self):", "body": "return self.__dynamically_configured<EOL>", "docstring": "Getter method for dynamically_configured, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/state/dynamically_configured (boolean)\n\n    YANG Description: When this leaf is set to true, the peer was configured dynamically\ndue to an inbound connection request from a specified source prefix\nwithin a dynamic-neighbor-prefix.", "id": "f23273:c0:m53"}
{"signature": "def _get_peer_as(self):", "body": "return self.__peer_as<EOL>", "docstring": "Getter method for peer_as, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/state/peer_as (oc-inet:as-number)\n\nYANG Description: AS number of the peer.", "id": "f23273:c1:m11"}
{"signature": "def _set_peer_as(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__peer_as = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for peer_as, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/state/peer_as (oc-inet:as-number)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_peer_as is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_peer_as() directly.\n\nYANG Description: AS number of the peer.", "id": "f23273:c0:m12"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:true>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/state/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: Whether the BGP peer is enabled. In cases where the\nenabled leaf is set to false, the local system should not\ninitiate connections to the neighbor, and should not\nrespond to TCP connections attempts from the neighbor. If\nthe state of the BGP session is ESTABLISHED at the time\nthat this leaf is set to false, the BGP session should be\nceased.", "id": "f23273:c0:m9"}
{"signature": "def _get_UPDATE(self):", "body": "return self.__UPDATE<EOL>", "docstring": "Getter method for UPDATE, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/state/messages/received/UPDATE (uint64)\n\n    YANG Description: Number of BGP UPDATE messages announcing, withdrawing\nor modifying paths exchanged.", "id": "f23274:c1:m2"}
{"signature": "def _get_NOTIFICATION(self):", "body": "return self.__NOTIFICATION<EOL>", "docstring": "Getter method for NOTIFICATION, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/state/messages/sent/NOTIFICATION (uint64)\n\n    YANG Description: Number of BGP NOTIFICATION messages indicating an\nerror condition has occurred exchanged.", "id": "f23275:c0:m5"}
{"signature": "def _set_UPDATE(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__UPDATE = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for UPDATE, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/state/messages/sent/UPDATE (uint64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_UPDATE is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_UPDATE() directly.\n\n    YANG Description: Number of BGP UPDATE messages announcing, withdrawing\nor modifying paths exchanged.", "id": "f23275:c0:m3"}
{"signature": "def _set_NOTIFICATION(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:64>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__NOTIFICATION = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for NOTIFICATION, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/state/messages/sent/NOTIFICATION (uint64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_NOTIFICATION is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_NOTIFICATION() directly.\n\n    YANG Description: Number of BGP NOTIFICATION messages indicating an\nerror condition has occurred exchanged.", "id": "f23275:c1:m6"}
{"signature": "def _get_received(self):", "body": "return self.__received<EOL>", "docstring": "Getter method for received, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/state/messages/received (container)\n\nYANG Description: Counters for BGP messages received from the neighbor", "id": "f23276:c1:m5"}
{"signature": "def _get_sent(self):", "body": "return self.__sent<EOL>", "docstring": "Getter method for sent, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/state/messages/sent (container)\n\nYANG Description: Counters relating to BGP messages sent to the neighbor", "id": "f23276:c1:m2"}
{"signature": "def _get_route_reflector_cluster_id(self):", "body": "return self.__route_reflector_cluster_id<EOL>", "docstring": "Getter method for route_reflector_cluster_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/route_reflector/state/route_reflector_cluster_id (oc-bgp-types:rr-cluster-id-type)\n\n    YANG Description: route-reflector cluster id to use when local router is\nconfigured as a route reflector.  Commonly set at the group\nlevel, but allows a different cluster\nid to be set for each neighbor.", "id": "f23277:c0:m2"}
{"signature": "def _set_route_reflector_cluster_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__route_reflector_cluster_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for route_reflector_cluster_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/route_reflector/state/route_reflector_cluster_id (oc-bgp-types:rr-cluster-id-type)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_route_reflector_cluster_id is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_route_reflector_cluster_id() directly.\n\n    YANG Description: route-reflector cluster id to use when local router is\nconfigured as a route reflector.  Commonly set at the group\nlevel, but allows a different cluster\nid to be set for each neighbor.", "id": "f23277:c0:m3"}
{"signature": "def _get_route_reflector_client(self):", "body": "return self.__route_reflector_client<EOL>", "docstring": "Getter method for route_reflector_client, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/route_reflector/state/route_reflector_client (boolean)\n\nYANG Description: Configure the neighbor as a route reflector client.", "id": "f23277:c0:m5"}
{"signature": "def _set_route_reflector_client(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__route_reflector_client = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for route_reflector_client, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/route_reflector/config/route_reflector_client (boolean)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_route_reflector_client is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_route_reflector_client() directly.\n\nYANG Description: Configure the neighbor as a route reflector client.", "id": "f23278:c0:m6"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/route_reflector/config (container)\n\n    YANG Description: Configuraton parameters relating to route reflection\nfor the BGPgroup", "id": "f23279:c1:m2"}
{"signature": "def _get_afi_safi(self):", "body": "return self.__afi_safi<EOL>", "docstring": "Getter method for afi_safi, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi (list)\n\n    YANG Description: AFI,SAFI configuration available for the\nneighbour or group", "id": "f23280:c0:m2"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/graceful_restart/state/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: This leaf indicates whether graceful-restart is enabled for\nthis AFI-SAFI", "id": "f23281:c0:m3"}
{"signature": "def _get_received(self):", "body": "return self.__received<EOL>", "docstring": "Getter method for received, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/graceful_restart/state/received (boolean)\n\n    YANG Description: This leaf indicates whether the neighbor advertised the\nability to support graceful-restart for this AFI-SAFI", "id": "f23281:c1:m5"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/graceful_restart/config/enabled (boolean)\n\n    YANG Description: This leaf indicates whether graceful-restart is enabled for\nthis AFI-SAFI", "id": "f23282:c1:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/graceful_restart/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State information for BGP graceful-restart", "id": "f23283:c1:m6"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/graceful_restart/config (container)\n\nYANG Description: Configuration options for BGP graceful-restart", "id": "f23283:c1:m2"}
{"signature": "def _set_sent(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__sent = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for sent, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/state/prefixes/sent (uint32)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_sent is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_sent() directly.\n\nYANG Description: The number of prefixes advertised to the neighbor", "id": "f23284:c0:m6"}
{"signature": "def _get_installed(self):", "body": "return self.__installed<EOL>", "docstring": "Getter method for installed, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/state/prefixes/installed (uint32)\n\n    YANG Description: The number of advertised prefixes installed in the\nLoc-RIB", "id": "f23284:c1:m8"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/state/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: This leaf indicates whether the IPv4 Unicast AFI,SAFI is\nenabled for the neighbour or group", "id": "f23285:c1:m6"}
{"signature": "def _set_prefixes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=prefixes.prefixes,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prefixes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/state/prefixes (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_prefixes is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_prefixes() directly.\n\nYANG Description: Prefix counters for the BGP session", "id": "f23285:c1:m12"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/state/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: This leaf indicates whether the IPv4 Unicast AFI,SAFI is\nenabled for the neighbour or group", "id": "f23285:c0:m6"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/state/enabled (boolean)\n\n    YANG Description: This leaf indicates whether the IPv4 Unicast AFI,SAFI is\nenabled for the neighbour or group", "id": "f23285:c0:m5"}
{"signature": "def _set_prefix_limit(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=prefix_limit.prefix_limit,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prefix_limit = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prefix_limit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l2vpn_evpn/prefix_limit (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prefix_limit is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prefix_limit() directly.\n\n    YANG Description: Configure the maximum number of prefixes that will be\naccepted from a peer", "id": "f23286:c1:m3"}
{"signature": "def _get_max_prefixes(self):", "body": "return self.__max_prefixes<EOL>", "docstring": "Getter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l2vpn_evpn/prefix_limit/state/max_prefixes (uint32)\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23287:c1:m2"}
{"signature": "def _get_shutdown_threshold_pct(self):", "body": "return self.__shutdown_threshold_pct<EOL>", "docstring": "Getter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l2vpn_evpn/prefix_limit/state/shutdown_threshold_pct (oc-types:percentage)\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23287:c0:m8"}
{"signature": "def _get_prevent_teardown(self):", "body": "return self.__prevent_teardown<EOL>", "docstring": "Getter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l2vpn_evpn/prefix_limit/state/prevent_teardown (boolean)\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23287:c0:m5"}
{"signature": "def _get_restart_timer(self):", "body": "return self.__restart_timer<EOL>", "docstring": "Getter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l2vpn_evpn/prefix_limit/state/restart_timer (decimal64)\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23287:c1:m11"}
{"signature": "def _set_max_prefixes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__max_prefixes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l2vpn_evpn/prefix_limit/state/max_prefixes (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_max_prefixes is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_max_prefixes() directly.\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23287:c0:m3"}
{"signature": "def _get_shutdown_threshold_pct(self):", "body": "return self.__shutdown_threshold_pct<EOL>", "docstring": "Getter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l2vpn_evpn/prefix_limit/config/shutdown_threshold_pct (oc-types:percentage)\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23288:c1:m8"}
{"signature": "def _get_prevent_teardown(self):", "body": "return self.__prevent_teardown<EOL>", "docstring": "Getter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l2vpn_evpn/prefix_limit/config/prevent_teardown (boolean)\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23288:c0:m5"}
{"signature": "def _get_prevent_teardown(self):", "body": "return self.__prevent_teardown<EOL>", "docstring": "Getter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l2vpn_evpn/prefix_limit/config/prevent_teardown (boolean)\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23288:c1:m5"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l2vpn_evpn/prefix_limit/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to the prefix\nlimit for the AFI-SAFI", "id": "f23289:c1:m3"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l2vpn_evpn/prefix_limit/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to the prefix\nlimit for the AFI-SAFI", "id": "f23289:c0:m3"}
{"signature": "def _set_prefix_limit(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=prefix_limit.prefix_limit,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prefix_limit = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prefix_limit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv6_labeled_unicast/prefix_limit (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prefix_limit is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prefix_limit() directly.\n\n    YANG Description: Configure the maximum number of prefixes that will be\naccepted from a peer", "id": "f23290:c0:m3"}
{"signature": "def _get_max_prefixes(self):", "body": "return self.__max_prefixes<EOL>", "docstring": "Getter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv6_labeled_unicast/prefix_limit/state/max_prefixes (uint32)\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23291:c0:m2"}
{"signature": "def _get_max_prefixes(self):", "body": "return self.__max_prefixes<EOL>", "docstring": "Getter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv6_labeled_unicast/prefix_limit/state/max_prefixes (uint32)\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23291:c1:m2"}
{"signature": "def _set_prevent_teardown(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prevent_teardown = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv6_labeled_unicast/prefix_limit/config/prevent_teardown (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prevent_teardown is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prevent_teardown() directly.\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23292:c0:m6"}
{"signature": "def _set_prevent_teardown(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prevent_teardown = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv6_labeled_unicast/prefix_limit/config/prevent_teardown (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prevent_teardown is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prevent_teardown() directly.\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23292:c1:m6"}
{"signature": "def _get_shutdown_threshold_pct(self):", "body": "return self.__shutdown_threshold_pct<EOL>", "docstring": "Getter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv6_labeled_unicast/prefix_limit/config/shutdown_threshold_pct (oc-types:percentage)\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23292:c0:m8"}
{"signature": "def _set_max_prefixes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__max_prefixes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv6_labeled_unicast/prefix_limit/config/max_prefixes (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_max_prefixes is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_max_prefixes() directly.\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23292:c0:m3"}
{"signature": "def _get_restart_timer(self):", "body": "return self.__restart_timer<EOL>", "docstring": "Getter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv6_labeled_unicast/prefix_limit/config/restart_timer (decimal64)\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23292:c1:m11"}
{"signature": "def _set_shutdown_threshold_pct(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__shutdown_threshold_pct = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv6_labeled_unicast/prefix_limit/config/shutdown_threshold_pct (oc-types:percentage)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_shutdown_threshold_pct is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_shutdown_threshold_pct() directly.\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23292:c1:m9"}
{"signature": "def _set_max_prefixes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__max_prefixes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv6_labeled_unicast/prefix_limit/config/max_prefixes (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_max_prefixes is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_max_prefixes() directly.\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23292:c1:m3"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv6_labeled_unicast/prefix_limit/config (container)\n\n    YANG Description: Configuration parameters relating to the prefix\nlimit for the AFI-SAFI", "id": "f23293:c1:m2"}
{"signature": "def _set_prefix_limit(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=prefix_limit.prefix_limit,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prefix_limit = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prefix_limit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv4_labeled_unicast/prefix_limit (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prefix_limit is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prefix_limit() directly.\n\n    YANG Description: Configure the maximum number of prefixes that will be\naccepted from a peer", "id": "f23294:c1:m3"}
{"signature": "def _set_prefix_limit(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=prefix_limit.prefix_limit,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prefix_limit = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prefix_limit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv4_labeled_unicast/prefix_limit (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prefix_limit is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prefix_limit() directly.\n\n    YANG Description: Configure the maximum number of prefixes that will be\naccepted from a peer", "id": "f23294:c0:m3"}
{"signature": "def _get_prefix_limit(self):", "body": "return self.__prefix_limit<EOL>", "docstring": "Getter method for prefix_limit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv4_labeled_unicast/prefix_limit (container)\n\n    YANG Description: Configure the maximum number of prefixes that will be\naccepted from a peer", "id": "f23294:c0:m2"}
{"signature": "def _set_restart_timer(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__restart_timer = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv4_labeled_unicast/prefix_limit/state/restart_timer (decimal64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_restart_timer is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_restart_timer() directly.\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23295:c0:m12"}
{"signature": "def _set_max_prefixes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__max_prefixes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv4_labeled_unicast/prefix_limit/state/max_prefixes (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_max_prefixes is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_max_prefixes() directly.\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23295:c1:m3"}
{"signature": "def _set_prevent_teardown(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prevent_teardown = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv4_labeled_unicast/prefix_limit/state/prevent_teardown (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prevent_teardown is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prevent_teardown() directly.\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23295:c1:m6"}
{"signature": "def _set_shutdown_threshold_pct(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__shutdown_threshold_pct = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv4_labeled_unicast/prefix_limit/state/shutdown_threshold_pct (oc-types:percentage)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_shutdown_threshold_pct is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_shutdown_threshold_pct() directly.\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23295:c0:m9"}
{"signature": "def _get_prevent_teardown(self):", "body": "return self.__prevent_teardown<EOL>", "docstring": "Getter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv4_labeled_unicast/prefix_limit/state/prevent_teardown (boolean)\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23295:c0:m5"}
{"signature": "def _set_max_prefixes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__max_prefixes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv4_labeled_unicast/prefix_limit/state/max_prefixes (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_max_prefixes is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_max_prefixes() directly.\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23295:c0:m3"}
{"signature": "def _set_restart_timer(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__restart_timer = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv4_labeled_unicast/prefix_limit/config/restart_timer (decimal64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_restart_timer is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_restart_timer() directly.\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23296:c1:m12"}
{"signature": "def _get_prevent_teardown(self):", "body": "return self.__prevent_teardown<EOL>", "docstring": "Getter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv4_labeled_unicast/prefix_limit/config/prevent_teardown (boolean)\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23296:c0:m5"}
{"signature": "def _set_prevent_teardown(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prevent_teardown = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv4_labeled_unicast/prefix_limit/config/prevent_teardown (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prevent_teardown is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prevent_teardown() directly.\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23296:c0:m6"}
{"signature": "def _set_max_prefixes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__max_prefixes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv4_labeled_unicast/prefix_limit/config/max_prefixes (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_max_prefixes is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_max_prefixes() directly.\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23296:c1:m3"}
{"signature": "def _set_shutdown_threshold_pct(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__shutdown_threshold_pct = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv4_labeled_unicast/prefix_limit/config/shutdown_threshold_pct (oc-types:percentage)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_shutdown_threshold_pct is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_shutdown_threshold_pct() directly.\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23296:c0:m9"}
{"signature": "def _set_restart_timer(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__restart_timer = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv4_labeled_unicast/prefix_limit/config/restart_timer (decimal64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_restart_timer is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_restart_timer() directly.\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23296:c0:m12"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv4_labeled_unicast/prefix_limit/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: State information relating to the prefix-limit for the\nAFI-SAFI", "id": "f23297:c1:m6"}
{"signature": "def _set_prefix_limit(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=prefix_limit.prefix_limit,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prefix_limit = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prefix_limit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv4_multicast/prefix_limit (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prefix_limit is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prefix_limit() directly.\n\n    YANG Description: Configure the maximum number of prefixes that will be\naccepted from a peer", "id": "f23298:c1:m3"}
{"signature": "def _set_max_prefixes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__max_prefixes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv4_multicast/prefix_limit/state/max_prefixes (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_max_prefixes is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_max_prefixes() directly.\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23299:c0:m3"}
{"signature": "def _get_max_prefixes(self):", "body": "return self.__max_prefixes<EOL>", "docstring": "Getter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv4_multicast/prefix_limit/state/max_prefixes (uint32)\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23299:c1:m2"}
{"signature": "def _set_prevent_teardown(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prevent_teardown = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv4_multicast/prefix_limit/state/prevent_teardown (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prevent_teardown is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prevent_teardown() directly.\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23299:c0:m6"}
{"signature": "def _get_prevent_teardown(self):", "body": "return self.__prevent_teardown<EOL>", "docstring": "Getter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv4_multicast/prefix_limit/state/prevent_teardown (boolean)\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23299:c0:m5"}
{"signature": "def _set_restart_timer(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__restart_timer = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv4_multicast/prefix_limit/state/restart_timer (decimal64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_restart_timer is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_restart_timer() directly.\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23299:c1:m12"}
{"signature": "def _get_shutdown_threshold_pct(self):", "body": "return self.__shutdown_threshold_pct<EOL>", "docstring": "Getter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv4_multicast/prefix_limit/state/shutdown_threshold_pct (oc-types:percentage)\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23299:c1:m8"}
{"signature": "def _get_restart_timer(self):", "body": "return self.__restart_timer<EOL>", "docstring": "Getter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv4_multicast/prefix_limit/state/restart_timer (decimal64)\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23299:c1:m11"}
{"signature": "def _get_shutdown_threshold_pct(self):", "body": "return self.__shutdown_threshold_pct<EOL>", "docstring": "Getter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv4_multicast/prefix_limit/config/shutdown_threshold_pct (oc-types:percentage)\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23300:c1:m8"}
{"signature": "def _set_max_prefixes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__max_prefixes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv4_multicast/prefix_limit/config/max_prefixes (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_max_prefixes is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_max_prefixes() directly.\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23300:c0:m3"}
{"signature": "def _set_shutdown_threshold_pct(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__shutdown_threshold_pct = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv4_multicast/prefix_limit/config/shutdown_threshold_pct (oc-types:percentage)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_shutdown_threshold_pct is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_shutdown_threshold_pct() directly.\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23300:c1:m9"}
{"signature": "def _get_restart_timer(self):", "body": "return self.__restart_timer<EOL>", "docstring": "Getter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv4_multicast/prefix_limit/config/restart_timer (decimal64)\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23300:c1:m11"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv4_multicast/prefix_limit/config (container)\n\n    YANG Description: Configuration parameters relating to the prefix\nlimit for the AFI-SAFI", "id": "f23301:c1:m2"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv4_multicast/prefix_limit/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to the prefix\nlimit for the AFI-SAFI", "id": "f23301:c0:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv4_multicast/prefix_limit/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: State information relating to the prefix-limit for the\nAFI-SAFI", "id": "f23301:c0:m6"}
{"signature": "def _get_max_prefixes(self):", "body": "return self.__max_prefixes<EOL>", "docstring": "Getter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l2vpn_vpls/prefix_limit/state/max_prefixes (uint32)\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23303:c0:m2"}
{"signature": "def _set_prevent_teardown(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prevent_teardown = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l2vpn_vpls/prefix_limit/state/prevent_teardown (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prevent_teardown is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prevent_teardown() directly.\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23303:c0:m6"}
{"signature": "def _set_prevent_teardown(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prevent_teardown = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l2vpn_vpls/prefix_limit/state/prevent_teardown (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prevent_teardown is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prevent_teardown() directly.\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23303:c1:m6"}
{"signature": "def _set_shutdown_threshold_pct(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__shutdown_threshold_pct = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l2vpn_vpls/prefix_limit/state/shutdown_threshold_pct (oc-types:percentage)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_shutdown_threshold_pct is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_shutdown_threshold_pct() directly.\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23303:c0:m9"}
{"signature": "def _get_max_prefixes(self):", "body": "return self.__max_prefixes<EOL>", "docstring": "Getter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l2vpn_vpls/prefix_limit/state/max_prefixes (uint32)\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23303:c1:m2"}
{"signature": "def _set_shutdown_threshold_pct(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__shutdown_threshold_pct = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l2vpn_vpls/prefix_limit/config/shutdown_threshold_pct (oc-types:percentage)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_shutdown_threshold_pct is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_shutdown_threshold_pct() directly.\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23304:c1:m9"}
{"signature": "def _get_shutdown_threshold_pct(self):", "body": "return self.__shutdown_threshold_pct<EOL>", "docstring": "Getter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l2vpn_vpls/prefix_limit/config/shutdown_threshold_pct (oc-types:percentage)\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23304:c0:m8"}
{"signature": "def _set_prevent_teardown(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prevent_teardown = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l2vpn_vpls/prefix_limit/config/prevent_teardown (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prevent_teardown is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prevent_teardown() directly.\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23304:c1:m6"}
{"signature": "def _get_prevent_teardown(self):", "body": "return self.__prevent_teardown<EOL>", "docstring": "Getter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l2vpn_vpls/prefix_limit/config/prevent_teardown (boolean)\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23304:c1:m5"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l2vpn_vpls/prefix_limit/config (container)\n\n    YANG Description: Configuration parameters relating to the prefix\nlimit for the AFI-SAFI", "id": "f23305:c0:m2"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l2vpn_vpls/prefix_limit/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to the prefix\nlimit for the AFI-SAFI", "id": "f23305:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l2vpn_vpls/prefix_limit/state (container)\n\n    YANG Description: State information relating to the prefix-limit for the\nAFI-SAFI", "id": "f23305:c1:m5"}
{"signature": "def _get_send_default_route(self):", "body": "return self.__send_default_route<EOL>", "docstring": "Getter method for send_default_route, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv6_unicast/config/send_default_route (boolean)\n\nYANG Description: If set to true, send the default-route to the neighbour(s)", "id": "f23307:c0:m2"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv6_unicast/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters for common IPv4 and IPv6 unicast\nAFI-SAFI options", "id": "f23308:c0:m6"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv6_unicast/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters for common IPv4 and IPv6 unicast\nAFI-SAFI options", "id": "f23308:c1:m6"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv6_unicast/config (container)\n\n    YANG Description: Configuration parameters for common IPv4 and IPv6 unicast\nAFI-SAFI options", "id": "f23308:c0:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv6_unicast/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: State information for common IPv4 and IPv6 unicast\nparameters", "id": "f23308:c0:m9"}
{"signature": "def _set_prevent_teardown(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prevent_teardown = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv6_unicast/prefix_limit/state/prevent_teardown (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prevent_teardown is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prevent_teardown() directly.\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23309:c1:m6"}
{"signature": "def _get_max_prefixes(self):", "body": "return self.__max_prefixes<EOL>", "docstring": "Getter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv6_unicast/prefix_limit/state/max_prefixes (uint32)\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23309:c1:m2"}
{"signature": "def _get_prevent_teardown(self):", "body": "return self.__prevent_teardown<EOL>", "docstring": "Getter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv6_unicast/prefix_limit/state/prevent_teardown (boolean)\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23309:c0:m5"}
{"signature": "def _set_restart_timer(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__restart_timer = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv6_unicast/prefix_limit/state/restart_timer (decimal64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_restart_timer is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_restart_timer() directly.\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23309:c0:m12"}
{"signature": "def _get_prevent_teardown(self):", "body": "return self.__prevent_teardown<EOL>", "docstring": "Getter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv6_unicast/prefix_limit/state/prevent_teardown (boolean)\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23309:c1:m5"}
{"signature": "def _set_shutdown_threshold_pct(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__shutdown_threshold_pct = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv6_unicast/prefix_limit/state/shutdown_threshold_pct (oc-types:percentage)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_shutdown_threshold_pct is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_shutdown_threshold_pct() directly.\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23309:c0:m9"}
{"signature": "def _set_restart_timer(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__restart_timer = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv6_unicast/prefix_limit/state/restart_timer (decimal64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_restart_timer is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_restart_timer() directly.\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23309:c1:m12"}
{"signature": "def _get_max_prefixes(self):", "body": "return self.__max_prefixes<EOL>", "docstring": "Getter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv6_unicast/prefix_limit/config/max_prefixes (uint32)\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23310:c1:m2"}
{"signature": "def _get_restart_timer(self):", "body": "return self.__restart_timer<EOL>", "docstring": "Getter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv6_unicast/prefix_limit/config/restart_timer (decimal64)\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23310:c0:m11"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv6_unicast/prefix_limit/state (container)\n\n    YANG Description: State information relating to the prefix-limit for the\nAFI-SAFI", "id": "f23311:c1:m5"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv6_unicast/prefix_limit/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to the prefix\nlimit for the AFI-SAFI", "id": "f23311:c0:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv6_unicast/prefix_limit/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: State information relating to the prefix-limit for the\nAFI-SAFI", "id": "f23311:c0:m6"}
{"signature": "def _get_afi_safi_name(self):", "body": "return self.__afi_safi_name<EOL>", "docstring": "Getter method for afi_safi_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/config/afi_safi_name (identityref)\n\nYANG Description: AFI,SAFI", "id": "f23312:c1:m2"}
{"signature": "def _set_afi_safi_name(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__afi_safi_name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for afi_safi_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/config/afi_safi_name (identityref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_afi_safi_name is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_afi_safi_name() directly.\n\nYANG Description: AFI,SAFI", "id": "f23312:c0:m3"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/config/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: This leaf indicates whether the IPv4 Unicast AFI,SAFI is\nenabled for the neighbour or group", "id": "f23312:c0:m6"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/use_multiple_paths/state/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: Whether the use of multiple paths for the same NLRI is\nenabled for the neighbor. This value is overridden by\nany more specific configuration value.", "id": "f23313:c0:m3"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/use_multiple_paths/config/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: Whether the use of multiple paths for the same NLRI is\nenabled for the neighbor. This value is overridden by\nany more specific configuration value.", "id": "f23314:c1:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/use_multiple_paths/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters relating to multipath", "id": "f23315:c0:m6"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/use_multiple_paths/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters relating to multipath", "id": "f23315:c1:m6"}
{"signature": "def _get_ebgp(self):", "body": "return self.__ebgp<EOL>", "docstring": "Getter method for ebgp, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/use_multiple_paths/ebgp (container)\n\nYANG Description: Multipath configuration for eBGP", "id": "f23315:c0:m8"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/use_multiple_paths/config (container)\n\nYANG Description: Configuration parameters relating to multipath", "id": "f23315:c0:m2"}
{"signature": "def _get_ebgp(self):", "body": "return self.__ebgp<EOL>", "docstring": "Getter method for ebgp, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/use_multiple_paths/ebgp (container)\n\nYANG Description: Multipath configuration for eBGP", "id": "f23315:c1:m8"}
{"signature": "def _set_allow_multiple_as(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__allow_multiple_as = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for allow_multiple_as, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/use_multiple_paths/ebgp/state/allow_multiple_as (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_allow_multiple_as is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_allow_multiple_as() directly.\n\n    YANG Description: Allow multipath to use paths from different neighbouring\nASes.  The default is to only consider multiple paths from\nthe same neighbouring AS.", "id": "f23316:c0:m3"}
{"signature": "def _get_allow_multiple_as(self):", "body": "return self.__allow_multiple_as<EOL>", "docstring": "Getter method for allow_multiple_as, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/use_multiple_paths/ebgp/config/allow_multiple_as (boolean)\n\n    YANG Description: Allow multipath to use paths from different neighbouring\nASes.  The default is to only consider multiple paths from\nthe same neighbouring AS.", "id": "f23317:c1:m2"}
{"signature": "def _set_allow_multiple_as(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__allow_multiple_as = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for allow_multiple_as, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/use_multiple_paths/ebgp/config/allow_multiple_as (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_allow_multiple_as is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_allow_multiple_as() directly.\n\n    YANG Description: Allow multipath to use paths from different neighbouring\nASes.  The default is to only consider multiple paths from\nthe same neighbouring AS.", "id": "f23317:c0:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/use_multiple_paths/ebgp/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State information relating to eBGP multipath", "id": "f23318:c0:m6"}
{"signature": "def _get_default_export_policy(self):", "body": "return self.__default_export_policy<EOL>", "docstring": "Getter method for default_export_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/apply_policy/state/default_export_policy (default-policy-type)\n\n    YANG Description: explicitly set a default policy if no policy definition\nin the export policy chain is satisfied.", "id": "f23319:c0:m11"}
{"signature": "def _get_default_export_policy(self):", "body": "return self.__default_export_policy<EOL>", "docstring": "Getter method for default_export_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/apply_policy/state/default_export_policy (default-policy-type)\n\n    YANG Description: explicitly set a default policy if no policy definition\nin the export policy chain is satisfied.", "id": "f23319:c1:m11"}
{"signature": "def _get_import_policy(self):", "body": "return self.__import_policy<EOL>", "docstring": "Getter method for import_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/apply_policy/state/import_policy (leafref)\n\n    YANG Description: list of policy names in sequence to be applied on\nreceiving a routing update in the current context, e.g.,\nfor the current peer group, neighbor, address family,\netc.", "id": "f23319:c0:m2"}
{"signature": "def _get_default_import_policy(self):", "body": "return self.__default_import_policy<EOL>", "docstring": "Getter method for default_import_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/apply_policy/state/default_import_policy (default-policy-type)\n\n    YANG Description: explicitly set a default policy if no policy definition\nin the import policy chain is satisfied.", "id": "f23319:c1:m5"}
{"signature": "def _set_default_import_policy(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>default=six.text_type(\"<STR_LIT>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__default_import_policy = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for default_import_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/apply_policy/state/default_import_policy (default-policy-type)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_default_import_policy is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_default_import_policy() directly.\n\n    YANG Description: explicitly set a default policy if no policy definition\nin the import policy chain is satisfied.", "id": "f23319:c0:m6"}
{"signature": "def _get_default_export_policy(self):", "body": "return self.__default_export_policy<EOL>", "docstring": "Getter method for default_export_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/apply_policy/config/default_export_policy (default-policy-type)\n\n    YANG Description: explicitly set a default policy if no policy definition\nin the export policy chain is satisfied.", "id": "f23320:c1:m11"}
{"signature": "def _set_default_export_policy(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>default=six.text_type(\"<STR_LIT>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__default_export_policy = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for default_export_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/apply_policy/config/default_export_policy (default-policy-type)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_default_export_policy is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_default_export_policy() directly.\n\n    YANG Description: explicitly set a default policy if no policy definition\nin the export policy chain is satisfied.", "id": "f23320:c1:m12"}
{"signature": "def _set_default_import_policy(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>default=six.text_type(\"<STR_LIT>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__default_import_policy = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for default_import_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/apply_policy/config/default_import_policy (default-policy-type)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_default_import_policy is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_default_import_policy() directly.\n\n    YANG Description: explicitly set a default policy if no policy definition\nin the import policy chain is satisfied.", "id": "f23320:c1:m6"}
{"signature": "def _get_default_import_policy(self):", "body": "return self.__default_import_policy<EOL>", "docstring": "Getter method for default_import_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/apply_policy/config/default_import_policy (default-policy-type)\n\n    YANG Description: explicitly set a default policy if no policy definition\nin the import policy chain is satisfied.", "id": "f23320:c1:m5"}
{"signature": "def _set_default_export_policy(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>default=six.text_type(\"<STR_LIT>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__default_export_policy = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for default_export_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/apply_policy/config/default_export_policy (default-policy-type)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_default_export_policy is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_default_export_policy() directly.\n\n    YANG Description: explicitly set a default policy if no policy definition\nin the export policy chain is satisfied.", "id": "f23320:c0:m12"}
{"signature": "def _get_export_policy(self):", "body": "return self.__export_policy<EOL>", "docstring": "Getter method for export_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/apply_policy/config/export_policy (leafref)\n\n    YANG Description: list of policy names in sequence to be applied on\nsending a routing update in the current context, e.g.,\nfor the current peer group, neighbor, address family,\netc.", "id": "f23320:c1:m8"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/apply_policy/state (container)\n\nYANG Description: Operational state for routing policy", "id": "f23321:c0:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/apply_policy/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: Operational state for routing policy", "id": "f23321:c1:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/apply_policy/state (container)\n\nYANG Description: Operational state for routing policy", "id": "f23321:c1:m5"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/config (container)\n\nYANG Description: Configuration parameters for the AFI-SAFI", "id": "f23322:c1:m5"}
{"signature": "def _get_apply_policy(self):", "body": "return self.__apply_policy<EOL>", "docstring": "Getter method for apply_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/apply_policy (container)\n\n    YANG Description: Anchor point for routing policies in the model.\nImport and export policies are with respect to the local\nrouting table, i.e., export (send) and import (receive),\ndepending on the context.", "id": "f23322:c0:m14"}
{"signature": "def _get_use_multiple_paths(self):", "body": "return self.__use_multiple_paths<EOL>", "docstring": "Getter method for use_multiple_paths, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/use_multiple_paths (container)\n\n    YANG Description: Parameters related to the use of multiple-paths for the same\nNLRI when they are received only from this neighbor", "id": "f23322:c1:m47"}
{"signature": "def _set_l3vpn_ipv4_unicast(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=l3vpn_ipv4_unicast.l3vpn_ipv4_unicast,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__l3vpn_ipv4_unicast = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for l3vpn_ipv4_unicast, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv4_unicast (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_l3vpn_ipv4_unicast is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_l3vpn_ipv4_unicast() directly.\n\nYANG Description: Unicast IPv4 L3VPN configuration options", "id": "f23322:c0:m30"}
{"signature": "def _get_ipv6_unicast(self):", "body": "return self.__ipv6_unicast<EOL>", "docstring": "Getter method for ipv6_unicast, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv6_unicast (container)\n\nYANG Description: IPv6 unicast configuration options", "id": "f23322:c1:m20"}
{"signature": "def _get_ipv4_labeled_unicast(self):", "body": "return self.__ipv4_labeled_unicast<EOL>", "docstring": "Getter method for ipv4_labeled_unicast, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv4_labeled_unicast (container)\n\nYANG Description: IPv4 Labeled Unicast configuration options", "id": "f23322:c0:m23"}
{"signature": "def _set_ipv6_unicast(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=ipv6_unicast.ipv6_unicast,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv6_unicast = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv6_unicast, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv6_unicast (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ipv6_unicast is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ipv6_unicast() directly.\n\nYANG Description: IPv6 unicast configuration options", "id": "f23322:c0:m21"}
{"signature": "def _get_use_multiple_paths(self):", "body": "return self.__use_multiple_paths<EOL>", "docstring": "Getter method for use_multiple_paths, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/use_multiple_paths (container)\n\n    YANG Description: Parameters related to the use of multiple-paths for the same\nNLRI when they are received only from this neighbor", "id": "f23322:c0:m47"}
{"signature": "def _set_ipv6_labeled_unicast(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=ipv6_labeled_unicast.ipv6_labeled_unicast,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ipv6_labeled_unicast = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ipv6_labeled_unicast, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv6_labeled_unicast (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ipv6_labeled_unicast is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ipv6_labeled_unicast() directly.\n\nYANG Description: IPv6 Labeled Unicast configuration options", "id": "f23322:c1:m27"}
{"signature": "def _set_apply_policy(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=apply_policy.apply_policy,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__apply_policy = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for apply_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/apply_policy (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_apply_policy is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_apply_policy() directly.\n\n    YANG Description: Anchor point for routing policies in the model.\nImport and export policies are with respect to the local\nrouting table, i.e., export (send) and import (receive),\ndepending on the context.", "id": "f23322:c0:m15"}
{"signature": "def _set_graceful_restart(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=graceful_restart.graceful_restart,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__graceful_restart = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for graceful_restart, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/graceful_restart (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_graceful_restart is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_graceful_restart() directly.\n\nYANG Description: Parameters relating to BGP graceful-restart", "id": "f23322:c0:m12"}
{"signature": "def _get_l3vpn_ipv6_multicast(self):", "body": "return self.__l3vpn_ipv6_multicast<EOL>", "docstring": "Getter method for l3vpn_ipv6_multicast, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv6_multicast (container)\n\nYANG Description: Multicast IPv6 L3VPN configuration options", "id": "f23322:c0:m38"}
{"signature": "def _get_l3vpn_ipv4_multicast(self):", "body": "return self.__l3vpn_ipv4_multicast<EOL>", "docstring": "Getter method for l3vpn_ipv4_multicast, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv4_multicast (container)\n\nYANG Description: Multicast IPv4 L3VPN configuration options", "id": "f23322:c1:m35"}
{"signature": "def _set_l3vpn_ipv6_unicast(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=l3vpn_ipv6_unicast.l3vpn_ipv6_unicast,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__l3vpn_ipv6_unicast = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for l3vpn_ipv6_unicast, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv6_unicast (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_l3vpn_ipv6_unicast is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_l3vpn_ipv6_unicast() directly.\n\nYANG Description: Unicast IPv6 L3VPN configuration options", "id": "f23322:c1:m33"}
{"signature": "def _get_ipv6_labeled_unicast(self):", "body": "return self.__ipv6_labeled_unicast<EOL>", "docstring": "Getter method for ipv6_labeled_unicast, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv6_labeled_unicast (container)\n\nYANG Description: IPv6 Labeled Unicast configuration options", "id": "f23322:c1:m26"}
{"signature": "def _get_ipv4_labeled_unicast(self):", "body": "return self.__ipv4_labeled_unicast<EOL>", "docstring": "Getter method for ipv4_labeled_unicast, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv4_labeled_unicast (container)\n\nYANG Description: IPv4 Labeled Unicast configuration options", "id": "f23322:c1:m23"}
{"signature": "def _get_l3vpn_ipv6_unicast(self):", "body": "return self.__l3vpn_ipv6_unicast<EOL>", "docstring": "Getter method for l3vpn_ipv6_unicast, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv6_unicast (container)\n\nYANG Description: Unicast IPv6 L3VPN configuration options", "id": "f23322:c1:m32"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/state (container)\n\nYANG Description: State information relating to the AFI-SAFI", "id": "f23322:c1:m8"}
{"signature": "def _set_l2vpn_vpls(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=l2vpn_vpls.l2vpn_vpls,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__l2vpn_vpls = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for l2vpn_vpls, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l2vpn_vpls (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_l2vpn_vpls is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_l2vpn_vpls() directly.\n\nYANG Description: BGP-signalled VPLS configuration options", "id": "f23322:c0:m42"}
{"signature": "def _set_graceful_restart(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=graceful_restart.graceful_restart,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__graceful_restart = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for graceful_restart, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/graceful_restart (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_graceful_restart is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_graceful_restart() directly.\n\nYANG Description: Parameters relating to BGP graceful-restart", "id": "f23322:c1:m12"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State information relating to the AFI-SAFI", "id": "f23322:c0:m9"}
{"signature": "def _set_max_prefixes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__max_prefixes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv6_unicast/prefix_limit/state/max_prefixes (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_max_prefixes is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_max_prefixes() directly.\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23324:c1:m3"}
{"signature": "def _set_shutdown_threshold_pct(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__shutdown_threshold_pct = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv6_unicast/prefix_limit/state/shutdown_threshold_pct (oc-types:percentage)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_shutdown_threshold_pct is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_shutdown_threshold_pct() directly.\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23324:c1:m9"}
{"signature": "def _get_shutdown_threshold_pct(self):", "body": "return self.__shutdown_threshold_pct<EOL>", "docstring": "Getter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv6_unicast/prefix_limit/state/shutdown_threshold_pct (oc-types:percentage)\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23324:c1:m8"}
{"signature": "def _get_restart_timer(self):", "body": "return self.__restart_timer<EOL>", "docstring": "Getter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv6_unicast/prefix_limit/state/restart_timer (decimal64)\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23324:c1:m11"}
{"signature": "def _set_prevent_teardown(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prevent_teardown = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv6_unicast/prefix_limit/config/prevent_teardown (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prevent_teardown is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prevent_teardown() directly.\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23325:c1:m6"}
{"signature": "def _get_shutdown_threshold_pct(self):", "body": "return self.__shutdown_threshold_pct<EOL>", "docstring": "Getter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv6_unicast/prefix_limit/config/shutdown_threshold_pct (oc-types:percentage)\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23325:c0:m8"}
{"signature": "def _get_prevent_teardown(self):", "body": "return self.__prevent_teardown<EOL>", "docstring": "Getter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv6_unicast/prefix_limit/config/prevent_teardown (boolean)\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23325:c1:m5"}
{"signature": "def _set_restart_timer(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__restart_timer = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv6_unicast/prefix_limit/config/restart_timer (decimal64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_restart_timer is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_restart_timer() directly.\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23325:c0:m12"}
{"signature": "def _get_shutdown_threshold_pct(self):", "body": "return self.__shutdown_threshold_pct<EOL>", "docstring": "Getter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv6_unicast/prefix_limit/config/shutdown_threshold_pct (oc-types:percentage)\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23325:c1:m8"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv6_unicast/prefix_limit/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to the prefix\nlimit for the AFI-SAFI", "id": "f23326:c0:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv6_unicast/prefix_limit/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: State information relating to the prefix-limit for the\nAFI-SAFI", "id": "f23326:c1:m6"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv6_unicast/prefix_limit/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to the prefix\nlimit for the AFI-SAFI", "id": "f23326:c1:m3"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv6_unicast/prefix_limit/config (container)\n\n    YANG Description: Configuration parameters relating to the prefix\nlimit for the AFI-SAFI", "id": "f23326:c1:m2"}
{"signature": "def _get_prefix_limit(self):", "body": "return self.__prefix_limit<EOL>", "docstring": "Getter method for prefix_limit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv6_multicast/prefix_limit (container)\n\n    YANG Description: Configure the maximum number of prefixes that will be\naccepted from a peer", "id": "f23327:c1:m2"}
{"signature": "def _set_prefix_limit(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=prefix_limit.prefix_limit,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prefix_limit = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prefix_limit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv6_multicast/prefix_limit (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prefix_limit is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prefix_limit() directly.\n\n    YANG Description: Configure the maximum number of prefixes that will be\naccepted from a peer", "id": "f23327:c1:m3"}
{"signature": "def _get_prefix_limit(self):", "body": "return self.__prefix_limit<EOL>", "docstring": "Getter method for prefix_limit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv6_multicast/prefix_limit (container)\n\n    YANG Description: Configure the maximum number of prefixes that will be\naccepted from a peer", "id": "f23327:c0:m2"}
{"signature": "def _set_max_prefixes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__max_prefixes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv6_multicast/prefix_limit/state/max_prefixes (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_max_prefixes is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_max_prefixes() directly.\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23328:c1:m3"}
{"signature": "def _get_shutdown_threshold_pct(self):", "body": "return self.__shutdown_threshold_pct<EOL>", "docstring": "Getter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv6_multicast/prefix_limit/state/shutdown_threshold_pct (oc-types:percentage)\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23328:c0:m8"}
{"signature": "def _set_prevent_teardown(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prevent_teardown = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv6_multicast/prefix_limit/state/prevent_teardown (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prevent_teardown is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prevent_teardown() directly.\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23328:c1:m6"}
{"signature": "def _set_restart_timer(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__restart_timer = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv6_multicast/prefix_limit/state/restart_timer (decimal64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_restart_timer is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_restart_timer() directly.\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23328:c1:m12"}
{"signature": "def _set_shutdown_threshold_pct(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__shutdown_threshold_pct = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv6_multicast/prefix_limit/state/shutdown_threshold_pct (oc-types:percentage)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_shutdown_threshold_pct is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_shutdown_threshold_pct() directly.\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23328:c1:m9"}
{"signature": "def _get_prevent_teardown(self):", "body": "return self.__prevent_teardown<EOL>", "docstring": "Getter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv6_multicast/prefix_limit/config/prevent_teardown (boolean)\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23329:c1:m5"}
{"signature": "def _set_shutdown_threshold_pct(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__shutdown_threshold_pct = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv6_multicast/prefix_limit/config/shutdown_threshold_pct (oc-types:percentage)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_shutdown_threshold_pct is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_shutdown_threshold_pct() directly.\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23329:c0:m9"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv6_multicast/prefix_limit/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: State information relating to the prefix-limit for the\nAFI-SAFI", "id": "f23330:c1:m6"}
{"signature": "def _set_restart_timer(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__restart_timer = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv4_unicast/prefix_limit/state/restart_timer (decimal64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_restart_timer is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_restart_timer() directly.\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23332:c0:m12"}
{"signature": "def _get_max_prefixes(self):", "body": "return self.__max_prefixes<EOL>", "docstring": "Getter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv4_unicast/prefix_limit/state/max_prefixes (uint32)\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23332:c1:m2"}
{"signature": "def _set_shutdown_threshold_pct(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__shutdown_threshold_pct = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv4_unicast/prefix_limit/state/shutdown_threshold_pct (oc-types:percentage)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_shutdown_threshold_pct is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_shutdown_threshold_pct() directly.\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23332:c1:m9"}
{"signature": "def _set_shutdown_threshold_pct(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__shutdown_threshold_pct = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv4_unicast/prefix_limit/state/shutdown_threshold_pct (oc-types:percentage)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_shutdown_threshold_pct is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_shutdown_threshold_pct() directly.\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23332:c0:m9"}
{"signature": "def _get_shutdown_threshold_pct(self):", "body": "return self.__shutdown_threshold_pct<EOL>", "docstring": "Getter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv4_unicast/prefix_limit/state/shutdown_threshold_pct (oc-types:percentage)\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23332:c1:m8"}
{"signature": "def _set_prevent_teardown(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prevent_teardown = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv4_unicast/prefix_limit/state/prevent_teardown (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prevent_teardown is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prevent_teardown() directly.\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23332:c0:m6"}
{"signature": "def _get_prevent_teardown(self):", "body": "return self.__prevent_teardown<EOL>", "docstring": "Getter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv4_unicast/prefix_limit/config/prevent_teardown (boolean)\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23333:c0:m5"}
{"signature": "def _set_max_prefixes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__max_prefixes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv4_unicast/prefix_limit/config/max_prefixes (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_max_prefixes is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_max_prefixes() directly.\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23333:c0:m3"}
{"signature": "def _set_restart_timer(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__restart_timer = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv4_unicast/prefix_limit/config/restart_timer (decimal64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_restart_timer is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_restart_timer() directly.\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23333:c1:m12"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv4_unicast/prefix_limit/state (container)\n\n    YANG Description: State information relating to the prefix-limit for the\nAFI-SAFI", "id": "f23334:c1:m5"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/l3vpn_ipv4_unicast/prefix_limit/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to the prefix\nlimit for the AFI-SAFI", "id": "f23334:c0:m3"}
{"signature": "def _get_send_default_route(self):", "body": "return self.__send_default_route<EOL>", "docstring": "Getter method for send_default_route, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv4_unicast/config/send_default_route (boolean)\n\nYANG Description: If set to true, send the default-route to the neighbour(s)", "id": "f23336:c1:m2"}
{"signature": "def _set_send_default_route(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__send_default_route = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for send_default_route, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv4_unicast/config/send_default_route (boolean)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_send_default_route is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_send_default_route() directly.\n\nYANG Description: If set to true, send the default-route to the neighbour(s)", "id": "f23336:c1:m3"}
{"signature": "def _set_send_default_route(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__send_default_route = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for send_default_route, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv4_unicast/config/send_default_route (boolean)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_send_default_route is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_send_default_route() directly.\n\nYANG Description: If set to true, send the default-route to the neighbour(s)", "id": "f23336:c0:m3"}
{"signature": "def _get_send_default_route(self):", "body": "return self.__send_default_route<EOL>", "docstring": "Getter method for send_default_route, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv4_unicast/config/send_default_route (boolean)\n\nYANG Description: If set to true, send the default-route to the neighbour(s)", "id": "f23336:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv4_unicast/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: State information for common IPv4 and IPv6 unicast\nparameters", "id": "f23337:c1:m9"}
{"signature": "def _get_prefix_limit(self):", "body": "return self.__prefix_limit<EOL>", "docstring": "Getter method for prefix_limit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv4_unicast/prefix_limit (container)\n\n    YANG Description: Configure the maximum number of prefixes that will be\naccepted from a peer", "id": "f23337:c1:m2"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv4_unicast/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters for common IPv4 and IPv6 unicast\nAFI-SAFI options", "id": "f23337:c1:m6"}
{"signature": "def _set_max_prefixes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__max_prefixes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv4_unicast/prefix_limit/state/max_prefixes (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_max_prefixes is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_max_prefixes() directly.\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23338:c0:m3"}
{"signature": "def _set_max_prefixes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__max_prefixes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv4_unicast/prefix_limit/state/max_prefixes (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_max_prefixes is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_max_prefixes() directly.\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23338:c1:m3"}
{"signature": "def _set_prevent_teardown(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prevent_teardown = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv4_unicast/prefix_limit/state/prevent_teardown (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prevent_teardown is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prevent_teardown() directly.\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23338:c0:m6"}
{"signature": "def _get_prevent_teardown(self):", "body": "return self.__prevent_teardown<EOL>", "docstring": "Getter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv4_unicast/prefix_limit/state/prevent_teardown (boolean)\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23338:c0:m5"}
{"signature": "def _get_prevent_teardown(self):", "body": "return self.__prevent_teardown<EOL>", "docstring": "Getter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv4_unicast/prefix_limit/config/prevent_teardown (boolean)\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23339:c1:m5"}
{"signature": "def _set_shutdown_threshold_pct(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__shutdown_threshold_pct = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv4_unicast/prefix_limit/config/shutdown_threshold_pct (oc-types:percentage)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_shutdown_threshold_pct is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_shutdown_threshold_pct() directly.\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23339:c1:m9"}
{"signature": "def _get_max_prefixes(self):", "body": "return self.__max_prefixes<EOL>", "docstring": "Getter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv4_unicast/prefix_limit/config/max_prefixes (uint32)\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23339:c0:m2"}
{"signature": "def _set_max_prefixes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__max_prefixes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv4_unicast/prefix_limit/config/max_prefixes (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_max_prefixes is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_max_prefixes() directly.\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23339:c1:m3"}
{"signature": "def _set_prevent_teardown(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prevent_teardown = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv4_unicast/prefix_limit/config/prevent_teardown (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prevent_teardown is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prevent_teardown() directly.\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23339:c1:m6"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv4_unicast/prefix_limit/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to the prefix\nlimit for the AFI-SAFI", "id": "f23340:c1:m3"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv4_unicast/prefix_limit/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to the prefix\nlimit for the AFI-SAFI", "id": "f23340:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis/afi_safi/ipv4_unicast/prefix_limit/state (container)\n\n    YANG Description: State information relating to the prefix-limit for the\nAFI-SAFI", "id": "f23340:c1:m5"}
{"signature": "def _get_negotiated_hold_time(self):", "body": "return self.__negotiated_hold_time<EOL>", "docstring": "Getter method for negotiated_hold_time, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/timers/state/negotiated_hold_time (decimal64)\n\nYANG Description: The negotiated hold-time for the BGP session", "id": "f23341:c0:m14"}
{"signature": "def _get_hold_time(self):", "body": "return self.__hold_time<EOL>", "docstring": "Getter method for hold_time, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/timers/state/hold_time (decimal64)\n\n    YANG Description: Time interval in seconds that a BGP session will be\nconsidered active in the absence of keepalive or other\nmessages from the peer.  The hold-time is typically\nset to 3x the keepalive-interval.", "id": "f23341:c1:m5"}
{"signature": "def _set_negotiated_hold_time(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__negotiated_hold_time = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for negotiated_hold_time, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/timers/state/negotiated_hold_time (decimal64)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_negotiated_hold_time is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_negotiated_hold_time() directly.\n\nYANG Description: The negotiated hold-time for the BGP session", "id": "f23341:c1:m15"}
{"signature": "def _set_connect_retry(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>),<EOL>default=Decimal(<NUM_LIT:30>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__connect_retry = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for connect_retry, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/timers/config/connect_retry (decimal64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_connect_retry is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_connect_retry() directly.\n\n    YANG Description: Time interval in seconds between attempts to establish a\nsession with the peer.", "id": "f23342:c1:m3"}
{"signature": "def _get_connect_retry(self):", "body": "return self.__connect_retry<EOL>", "docstring": "Getter method for connect_retry, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/timers/config/connect_retry (decimal64)\n\n    YANG Description: Time interval in seconds between attempts to establish a\nsession with the peer.", "id": "f23342:c0:m2"}
{"signature": "def _set_hold_time(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>),<EOL>default=Decimal(<NUM_LIT>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__hold_time = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for hold_time, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/timers/config/hold_time (decimal64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_hold_time is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_hold_time() directly.\n\n    YANG Description: Time interval in seconds that a BGP session will be\nconsidered active in the absence of keepalive or other\nmessages from the peer.  The hold-time is typically\nset to 3x the keepalive-interval.", "id": "f23342:c1:m6"}
{"signature": "def _set_erroneous_update_messages(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__erroneous_update_messages = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for erroneous_update_messages, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/error_handling/state/erroneous_update_messages (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_erroneous_update_messages is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_erroneous_update_messages() directly.\n\n    YANG Description: The number of BGP UPDATE messages for which the\ntreat-as-withdraw mechanism has been applied based\non erroneous message contents", "id": "f23344:c0:m6"}
{"signature": "def _get_treat_as_withdraw(self):", "body": "return self.__treat_as_withdraw<EOL>", "docstring": "Getter method for treat_as_withdraw, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/error_handling/state/treat_as_withdraw (boolean)\n\n    YANG Description: Specify whether erroneous UPDATE messages for which the\nNLRI can be extracted are reated as though the NLRI is\nwithdrawn - avoiding session reset", "id": "f23344:c0:m2"}
{"signature": "def _get_treat_as_withdraw(self):", "body": "return self.__treat_as_withdraw<EOL>", "docstring": "Getter method for treat_as_withdraw, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/error_handling/state/treat_as_withdraw (boolean)\n\n    YANG Description: Specify whether erroneous UPDATE messages for which the\nNLRI can be extracted are reated as though the NLRI is\nwithdrawn - avoiding session reset", "id": "f23344:c1:m2"}
{"signature": "def _set_treat_as_withdraw(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__treat_as_withdraw = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for treat_as_withdraw, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/error_handling/config/treat_as_withdraw (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_treat_as_withdraw is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_treat_as_withdraw() directly.\n\n    YANG Description: Specify whether erroneous UPDATE messages for which the\nNLRI can be extracted are reated as though the NLRI is\nwithdrawn - avoiding session reset", "id": "f23345:c1:m3"}
{"signature": "def _set_treat_as_withdraw(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__treat_as_withdraw = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for treat_as_withdraw, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/error_handling/config/treat_as_withdraw (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_treat_as_withdraw is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_treat_as_withdraw() directly.\n\n    YANG Description: Specify whether erroneous UPDATE messages for which the\nNLRI can be extracted are reated as though the NLRI is\nwithdrawn - avoiding session reset", "id": "f23345:c0:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/error_handling/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: State information relating to enhanced error handling\nmechanisms for the BGP neighbor", "id": "f23346:c1:m6"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/error_handling/config (container)\n\n    YANG Description: Configuration parameters enabling or modifying the\nbehavior or enhanced error handling mechanisms for the BGP\nneighbor", "id": "f23346:c0:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/error_handling/state (container)\n\n    YANG Description: State information relating to enhanced error handling\nmechanisms for the BGP neighbor", "id": "f23346:c0:m5"}
{"signature": "def _get_auth_password(self):", "body": "return self.__auth_password<EOL>", "docstring": "Getter method for auth_password, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/config/auth_password (oc-types:routing-password)\n\n    YANG Description: Configures an MD5 authentication password for use with\nneighboring devices.", "id": "f23347:c1:m20"}
{"signature": "def _get_auth_password(self):", "body": "return self.__auth_password<EOL>", "docstring": "Getter method for auth_password, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/config/auth_password (oc-types:routing-password)\n\n    YANG Description: Configures an MD5 authentication password for use with\nneighboring devices.", "id": "f23347:c0:m20"}
{"signature": "def _get_send_community(self):", "body": "return self.__send_community<EOL>", "docstring": "Getter method for send_community, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/config/send_community (oc-bgp-types:community-type)\n\n    YANG Description: Specify which types of community should be sent to the\nneighbor or group. The default is to not send the\ncommunity attribute", "id": "f23347:c0:m29"}
{"signature": "def _get_neighbor_address(self):", "body": "return self.__neighbor_address<EOL>", "docstring": "Getter method for neighbor_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/config/neighbor_address (oc-inet:ip-address)\n\nYANG Description: Address of the BGP peer, either in IPv4 or IPv6", "id": "f23347:c0:m5"}
{"signature": "def _set_send_community(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {}, \"<STR_LIT>\": {}, \"<STR_LIT>\": {}, \"<STR_LIT>\": {}<EOL>},<EOL>),<EOL>default=six.text_type(\"<STR_LIT>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__send_community = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for send_community, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/config/send_community (oc-bgp-types:community-type)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_send_community is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_send_community() directly.\n\n    YANG Description: Specify which types of community should be sent to the\nneighbor or group. The default is to not send the\ncommunity attribute", "id": "f23347:c0:m30"}
{"signature": "def _set_local_as(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__local_as = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for local_as, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/config/local_as (oc-inet:as-number)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_local_as is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_local_as() directly.\n\n    YANG Description: The local autonomous system number that is to be used\nwhen establishing sessions with the remote peer or peer\ngroup, if this differs from the global BGP router\nautonomous system number.", "id": "f23347:c1:m15"}
{"signature": "def _set_neighbor_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__neighbor_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for neighbor_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/config/neighbor_address (oc-inet:ip-address)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_neighbor_address is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_neighbor_address() directly.\n\nYANG Description: Address of the BGP peer, either in IPv4 or IPv6", "id": "f23347:c0:m6"}
{"signature": "def _set_peer_group(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__peer_group = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for peer_group, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/config/peer_group (leafref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_peer_group is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_peer_group() directly.\n\nYANG Description: The peer-group with which this neighbor is associated", "id": "f23347:c1:m3"}
{"signature": "def _set_peer_type(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__peer_type = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for peer_type, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/config/peer_type (oc-bgp-types:peer-type)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_peer_type is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_peer_type() directly.\n\n    YANG Description: Explicitly designate the peer or peer group as internal\n(iBGP) or external (eBGP).", "id": "f23347:c1:m18"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/use_multiple_paths/config/enabled (boolean)\n\n    YANG Description: Whether the use of multiple paths for the same NLRI is\nenabled for the neighbor. This value is overridden by\nany more specific configuration value.", "id": "f23349:c0:m2"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/use_multiple_paths/config/enabled (boolean)\n\n    YANG Description: Whether the use of multiple paths for the same NLRI is\nenabled for the neighbor. This value is overridden by\nany more specific configuration value.", "id": "f23349:c1:m2"}
{"signature": "def _get_ebgp(self):", "body": "return self.__ebgp<EOL>", "docstring": "Getter method for ebgp, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/use_multiple_paths/ebgp (container)\n\nYANG Description: Multipath configuration for eBGP", "id": "f23350:c0:m8"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/use_multiple_paths/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters relating to multipath", "id": "f23350:c1:m6"}
{"signature": "def _set_ebgp(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=ebgp.ebgp,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ebgp = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ebgp, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/use_multiple_paths/ebgp (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ebgp is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ebgp() directly.\n\nYANG Description: Multipath configuration for eBGP", "id": "f23350:c1:m9"}
{"signature": "def _get_allow_multiple_as(self):", "body": "return self.__allow_multiple_as<EOL>", "docstring": "Getter method for allow_multiple_as, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/use_multiple_paths/ebgp/state/allow_multiple_as (boolean)\n\n    YANG Description: Allow multipath to use paths from different neighbouring\nASes.  The default is to only consider multiple paths from\nthe same neighbouring AS.", "id": "f23351:c0:m2"}
{"signature": "def _set_allow_multiple_as(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__allow_multiple_as = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for allow_multiple_as, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/use_multiple_paths/ebgp/state/allow_multiple_as (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_allow_multiple_as is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_allow_multiple_as() directly.\n\n    YANG Description: Allow multipath to use paths from different neighbouring\nASes.  The default is to only consider multiple paths from\nthe same neighbouring AS.", "id": "f23351:c1:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/use_multiple_paths/ebgp/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State information relating to eBGP multipath", "id": "f23353:c0:m6"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/use_multiple_paths/ebgp/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State information relating to eBGP multipath", "id": "f23353:c1:m6"}
{"signature": "def _set_default_import_policy(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>default=six.text_type(\"<STR_LIT>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__default_import_policy = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for default_import_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/apply_policy/state/default_import_policy (default-policy-type)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_default_import_policy is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_default_import_policy() directly.\n\n    YANG Description: explicitly set a default policy if no policy definition\nin the import policy chain is satisfied.", "id": "f23354:c1:m6"}
{"signature": "def _set_default_export_policy(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={\"<STR_LIT>\": {}, \"<STR_LIT>\": {}},<EOL>),<EOL>default=six.text_type(\"<STR_LIT>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__default_export_policy = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for default_export_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/apply_policy/state/default_export_policy (default-policy-type)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_default_export_policy is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_default_export_policy() directly.\n\n    YANG Description: explicitly set a default policy if no policy definition\nin the export policy chain is satisfied.", "id": "f23354:c1:m12"}
{"signature": "def _get_default_import_policy(self):", "body": "return self.__default_import_policy<EOL>", "docstring": "Getter method for default_import_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/apply_policy/config/default_import_policy (default-policy-type)\n\n    YANG Description: explicitly set a default policy if no policy definition\nin the import policy chain is satisfied.", "id": "f23355:c1:m5"}
{"signature": "def _get_export_policy(self):", "body": "return self.__export_policy<EOL>", "docstring": "Getter method for export_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/apply_policy/config/export_policy (leafref)\n\n    YANG Description: list of policy names in sequence to be applied on\nsending a routing update in the current context, e.g.,\nfor the current peer group, neighbor, address family,\netc.", "id": "f23355:c1:m8"}
{"signature": "def _set_import_policy(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(allowed_type=six.text_type),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__import_policy = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for import_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/apply_policy/config/import_policy (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_import_policy is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_import_policy() directly.\n\n    YANG Description: list of policy names in sequence to be applied on\nreceiving a routing update in the current context, e.g.,\nfor the current peer group, neighbor, address family,\netc.", "id": "f23355:c0:m3"}
{"signature": "def _get_default_import_policy(self):", "body": "return self.__default_import_policy<EOL>", "docstring": "Getter method for default_import_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/apply_policy/config/default_import_policy (default-policy-type)\n\n    YANG Description: explicitly set a default policy if no policy definition\nin the import policy chain is satisfied.", "id": "f23355:c0:m5"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/apply_policy/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Policy configuration data.", "id": "f23356:c1:m3"}
{"signature": "def _set_ebgp_multihop(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=ebgp_multihop.ebgp_multihop,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ebgp_multihop = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ebgp_multihop, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/ebgp_multihop (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ebgp_multihop is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ebgp_multihop() directly.\n\nYANG Description: eBGP multi-hop parameters for the BGPgroup", "id": "f23357:c0:m27"}
{"signature": "def _set_add_paths(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=add_paths.add_paths,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__add_paths = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for add_paths, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/add_paths (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_add_paths is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_add_paths() directly.\n\n    YANG Description: Parameters relating to the advertisement and receipt of\nmultiple paths for a single NLRI (add-paths)", "id": "f23357:c0:m36"}
{"signature": "def _get_use_multiple_paths(self):", "body": "return self.__use_multiple_paths<EOL>", "docstring": "Getter method for use_multiple_paths, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/use_multiple_paths (container)\n\n    YANG Description: Parameters related to the use of multiple-paths for the same\nNLRI when they are received only from this neighbor", "id": "f23357:c0:m38"}
{"signature": "def _set_route_reflector(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=route_reflector.route_reflector,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__route_reflector = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for route_reflector, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/route_reflector (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_route_reflector is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_route_reflector() directly.\n\nYANG Description: Route reflector parameters for the BGPgroup", "id": "f23357:c1:m30"}
{"signature": "def _get_apply_policy(self):", "body": "return self.__apply_policy<EOL>", "docstring": "Getter method for apply_policy, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/apply_policy (container)\n\n    YANG Description: Anchor point for routing policies in the model.\nImport and export policies are with respect to the local\nrouting table, i.e., export (send) and import (receive),\ndepending on the context.", "id": "f23357:c0:m41"}
{"signature": "def _set_transport(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=transport.transport,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__transport = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for transport, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/transport (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_transport is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_transport() directly.\n\nYANG Description: Transport session parameters for the BGP neighbor", "id": "f23357:c1:m15"}
{"signature": "def _set_logging_options(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=logging_options.logging_options,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__logging_options = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for logging_options, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/logging_options (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_logging_options is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_logging_options() directly.\n\n    YANG Description: Logging options for events related to the BGP neighbor or\ngroup", "id": "f23357:c0:m24"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/config (container)\n\n    YANG Description: Configuration parameters relating to the BGP neighbor or\ngroup", "id": "f23357:c1:m5"}
{"signature": "def _set_afi_safis(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=afi_safis.afi_safis,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__afi_safis = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for afi_safis, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/afi_safis (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_afi_safis is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_afi_safis() directly.\n\n    YANG Description: Per-address-family configuration parameters associated with\nthe neighbor", "id": "f23357:c0:m45"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/state (container)\n\nYANG Description: State information relating to the BGP neighbor", "id": "f23357:c1:m8"}
{"signature": "def _get_transport(self):", "body": "return self.__transport<EOL>", "docstring": "Getter method for transport, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/transport (container)\n\nYANG Description: Transport session parameters for the BGP neighbor", "id": "f23357:c1:m14"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/config (container)\n\n    YANG Description: Configuration parameters relating to the BGP neighbor or\ngroup", "id": "f23357:c0:m5"}
{"signature": "def _set_as_path_options(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=as_path_options.as_path_options,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__as_path_options = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for as_path_options, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/as_path_options (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_as_path_options is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_as_path_options() directly.\n\n    YANG Description: AS_PATH manipulation parameters for the BGP neighbor or\ngroup", "id": "f23357:c0:m33"}
{"signature": "def _get_as_path_options(self):", "body": "return self.__as_path_options<EOL>", "docstring": "Getter method for as_path_options, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/as_path_options (container)\n\n    YANG Description: AS_PATH manipulation parameters for the BGP neighbor or\ngroup", "id": "f23357:c1:m32"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/state (container)\n\nYANG Description: State information relating to the BGP neighbor", "id": "f23357:c0:m8"}
{"signature": "def _set_error_handling(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=error_handling.error_handling,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__error_handling = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for error_handling, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/error_handling (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_error_handling is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_error_handling() directly.\n\n    YANG Description: Error handling parameters used for the BGP neighbor or\ngroup", "id": "f23357:c1:m18"}
{"signature": "def _get_multihop_ttl(self):", "body": "return self.__multihop_ttl<EOL>", "docstring": "Getter method for multihop_ttl, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/ebgp_multihop/state/multihop_ttl (uint8)\n\n    YANG Description: Time-to-live value to use when packets are sent to the\nreferenced group or neighbors and ebgp-multihop is enabled", "id": "f23358:c0:m5"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/ebgp_multihop/state/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: When enabled the referenced group or neighbors are permitted\nto be indirectly connected - including cases where the TTL\ncan be decremented between the BGP peers", "id": "f23358:c0:m3"}
{"signature": "def _get_multihop_ttl(self):", "body": "return self.__multihop_ttl<EOL>", "docstring": "Getter method for multihop_ttl, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/ebgp_multihop/state/multihop_ttl (uint8)\n\n    YANG Description: Time-to-live value to use when packets are sent to the\nreferenced group or neighbors and ebgp-multihop is enabled", "id": "f23358:c1:m5"}
{"signature": "def _set_multihop_ttl(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__multihop_ttl = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for multihop_ttl, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/ebgp_multihop/state/multihop_ttl (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_multihop_ttl is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_multihop_ttl() directly.\n\n    YANG Description: Time-to-live value to use when packets are sent to the\nreferenced group or neighbors and ebgp-multihop is enabled", "id": "f23358:c0:m6"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/ebgp_multihop/config/enabled (boolean)\n\n    YANG Description: When enabled the referenced group or neighbors are permitted\nto be indirectly connected - including cases where the TTL\ncan be decremented between the BGP peers", "id": "f23359:c0:m2"}
{"signature": "def _set_multihop_ttl(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__multihop_ttl = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for multihop_ttl, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/ebgp_multihop/config/multihop_ttl (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_multihop_ttl is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_multihop_ttl() directly.\n\n    YANG Description: Time-to-live value to use when packets are sent to the\nreferenced group or neighbors and ebgp-multihop is enabled", "id": "f23359:c1:m6"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/ebgp_multihop/config/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: When enabled the referenced group or neighbors are permitted\nto be indirectly connected - including cases where the TTL\ncan be decremented between the BGP peers", "id": "f23359:c1:m3"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/ebgp_multihop/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to eBGP multihop for the\nBGP group", "id": "f23360:c1:m3"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/ebgp_multihop/config (container)\n\n    YANG Description: Configuration parameters relating to eBGP multihop for the\nBGP group", "id": "f23360:c0:m2"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/ebgp_multihop/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to eBGP multihop for the\nBGP group", "id": "f23360:c0:m3"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/ebgp_multihop/config (container)\n\n    YANG Description: Configuration parameters relating to eBGP multihop for the\nBGP group", "id": "f23360:c1:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/ebgp_multihop/state (container)\n\n    YANG Description: State information for eBGP multihop, for the BGP neighbor\nor group", "id": "f23360:c0:m5"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/ebgp_multihop/state (container)\n\n    YANG Description: State information for eBGP multihop, for the BGP neighbor\nor group", "id": "f23360:c1:m5"}
{"signature": "def _set_send_max(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__send_max = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for send_max, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/add_paths/state/send_max (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_send_max is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_send_max() directly.\n\n    YANG Description: The maximum number of paths to advertise to neighbors\nfor a single NLRI", "id": "f23361:c0:m6"}
{"signature": "def _set_receive(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__receive = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for receive, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/add_paths/state/receive (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_receive is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_receive() directly.\n\n    YANG Description: Enable ability to receive multiple path advertisements\nfor an NLRI from the neighbor or group", "id": "f23361:c0:m3"}
{"signature": "def _get_receive(self):", "body": "return self.__receive<EOL>", "docstring": "Getter method for receive, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/add_paths/config/receive (boolean)\n\n    YANG Description: Enable ability to receive multiple path advertisements\nfor an NLRI from the neighbor or group", "id": "f23362:c1:m2"}
{"signature": "def _set_send_max(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__send_max = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for send_max, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/add_paths/config/send_max (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_send_max is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_send_max() directly.\n\n    YANG Description: The maximum number of paths to advertise to neighbors\nfor a single NLRI", "id": "f23362:c1:m6"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/add_paths/config (container)\n\nYANG Description: Configuration parameters relating to ADD_PATHS", "id": "f23363:c1:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/add_paths/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State information associated with ADD_PATHS", "id": "f23363:c1:m6"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/add_paths/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration parameters relating to ADD_PATHS", "id": "f23363:c1:m3"}
{"signature": "def _get_log_neighbor_state_changes(self):", "body": "return self.__log_neighbor_state_changes<EOL>", "docstring": "Getter method for log_neighbor_state_changes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/logging_options/state/log_neighbor_state_changes (boolean)\n\n    YANG Description: Configure logging of peer state changes.  Default is\nto enable logging of peer state changes.", "id": "f23364:c0:m2"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/logging_options/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters enabling or modifying logging\nfor events relating to the BGPgroup", "id": "f23366:c1:m3"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/logging_options/config (container)\n\n    YANG Description: Configuration parameters enabling or modifying logging\nfor events relating to the BGPgroup", "id": "f23366:c1:m2"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/logging_options/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters enabling or modifying logging\nfor events relating to the BGPgroup", "id": "f23366:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/logging_options/state (container)\n\n    YANG Description: State information relating to logging for the BGP neighbor\nor group", "id": "f23366:c0:m5"}
{"signature": "def _set_remote_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__remote_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for remote_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/transport/state/remote_address (oc-inet:ip-address)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_remote_address is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_remote_address() directly.\n\n    YANG Description: Remote address to which the BGP session has been\nestablished", "id": "f23367:c1:m18"}
{"signature": "def _get_mtu_discovery(self):", "body": "return self.__mtu_discovery<EOL>", "docstring": "Getter method for mtu_discovery, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/transport/state/mtu_discovery (boolean)\n\n    YANG Description: Turns path mtu discovery for BGP TCP sessions on (true)\nor off (false)", "id": "f23367:c1:m5"}
{"signature": "def _get_remote_address(self):", "body": "return self.__remote_address<EOL>", "docstring": "Getter method for remote_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/transport/state/remote_address (oc-inet:ip-address)\n\n    YANG Description: Remote address to which the BGP session has been\nestablished", "id": "f23367:c1:m17"}
{"signature": "def _get_remote_port(self):", "body": "return self.__remote_port<EOL>", "docstring": "Getter method for remote_port, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/transport/state/remote_port (oc-inet:port-number)\n\n    YANG Description: Remote port being used by the peer for the TCP session\nsupporting the BGP session", "id": "f23367:c1:m20"}
{"signature": "def _set_passive_mode(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__passive_mode = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for passive_mode, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/transport/state/passive_mode (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_passive_mode is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_passive_mode() directly.\n\n    YANG Description: Wait for peers to issue requests to open a BGP session,\nrather than initiating sessions from the local router.", "id": "f23367:c0:m9"}
{"signature": "def _get_tcp_mss(self):", "body": "return self.__tcp_mss<EOL>", "docstring": "Getter method for tcp_mss, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/transport/state/tcp_mss (uint16)\n\nYANG Description: Sets the max segment size for BGP TCP sessions.", "id": "f23367:c0:m2"}
{"signature": "def _set_tcp_mss(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__tcp_mss = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for tcp_mss, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/transport/state/tcp_mss (uint16)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_tcp_mss is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_tcp_mss() directly.\n\nYANG Description: Sets the max segment size for BGP TCP sessions.", "id": "f23367:c1:m3"}
{"signature": "def _get_local_port(self):", "body": "return self.__local_port<EOL>", "docstring": "Getter method for local_port, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/transport/state/local_port (oc-inet:port-number)\n\n    YANG Description: Local TCP port being used for the TCP session supporting\nthe BGP session", "id": "f23367:c0:m14"}
{"signature": "def _set_remote_address(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__remote_address = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for remote_address, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/transport/state/remote_address (oc-inet:ip-address)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_remote_address is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_remote_address() directly.\n\n    YANG Description: Remote address to which the BGP session has been\nestablished", "id": "f23367:c0:m18"}
{"signature": "def _get_local_port(self):", "body": "return self.__local_port<EOL>", "docstring": "Getter method for local_port, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/transport/state/local_port (oc-inet:port-number)\n\n    YANG Description: Local TCP port being used for the TCP session supporting\nthe BGP session", "id": "f23367:c1:m14"}
{"signature": "def _get_tcp_mss(self):", "body": "return self.__tcp_mss<EOL>", "docstring": "Getter method for tcp_mss, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/transport/config/tcp_mss (uint16)\n\nYANG Description: Sets the max segment size for BGP TCP sessions.", "id": "f23368:c0:m2"}
{"signature": "def _set_tcp_mss(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:16><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__tcp_mss = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for tcp_mss, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/transport/config/tcp_mss (uint16)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_tcp_mss is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_tcp_mss() directly.\n\nYANG Description: Sets the max segment size for BGP TCP sessions.", "id": "f23368:c0:m3"}
{"signature": "def _get_passive_mode(self):", "body": "return self.__passive_mode<EOL>", "docstring": "Getter method for passive_mode, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/transport/config/passive_mode (boolean)\n\n    YANG Description: Wait for peers to issue requests to open a BGP session,\nrather than initiating sessions from the local router.", "id": "f23368:c0:m8"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/transport/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to the transport\nsession(s) used for the BGP neighbor", "id": "f23369:c0:m3"}
{"signature": "def _set_replace_peer_as(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__replace_peer_as = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for replace_peer_as, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/as_path_options/state/replace_peer_as (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_replace_peer_as is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_replace_peer_as() directly.\n\n    YANG Description: Replace occurrences of the peer's AS in the AS_PATH\nwith the local autonomous system number", "id": "f23370:c0:m6"}
{"signature": "def _set_allow_own_as(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>default=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>)(<EOL><NUM_LIT:0><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__allow_own_as = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for allow_own_as, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/as_path_options/config/allow_own_as (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_allow_own_as is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_allow_own_as() directly.\n\n    YANG Description: Specify the number of occurrences of the local BGP speaker's\nAS that can occur within the AS_PATH before it is rejected.", "id": "f23371:c0:m3"}
{"signature": "def _get_replace_peer_as(self):", "body": "return self.__replace_peer_as<EOL>", "docstring": "Getter method for replace_peer_as, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/as_path_options/config/replace_peer_as (boolean)\n\n    YANG Description: Replace occurrences of the peer's AS in the AS_PATH\nwith the local autonomous system number", "id": "f23371:c1:m5"}
{"signature": "def _get_allow_own_as(self):", "body": "return self.__allow_own_as<EOL>", "docstring": "Getter method for allow_own_as, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/as_path_options/config/allow_own_as (uint8)\n\n    YANG Description: Specify the number of occurrences of the local BGP speaker's\nAS that can occur within the AS_PATH before it is rejected.", "id": "f23371:c1:m2"}
{"signature": "def _get_replace_peer_as(self):", "body": "return self.__replace_peer_as<EOL>", "docstring": "Getter method for replace_peer_as, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/as_path_options/config/replace_peer_as (boolean)\n\n    YANG Description: Replace occurrences of the peer's AS in the AS_PATH\nwith the local autonomous system number", "id": "f23371:c0:m5"}
{"signature": "def _set_allow_own_as(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>),<EOL>default=RestrictedClassType(<EOL>base_type=int, restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]}, int_size=<NUM_LIT:8><EOL>)(<EOL><NUM_LIT:0><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__allow_own_as = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for allow_own_as, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/as_path_options/config/allow_own_as (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_allow_own_as is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_allow_own_as() directly.\n\n    YANG Description: Specify the number of occurrences of the local BGP speaker's\nAS that can occur within the AS_PATH before it is rejected.", "id": "f23371:c1:m3"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor/as_path_options/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to AS_PATH manipulation\nfor the BGP peer or group", "id": "f23372:c1:m3"}
{"signature": "def _get_neighbor(self):", "body": "return self.__neighbor<EOL>", "docstring": "Getter method for neighbor, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor (list)\n\n    YANG Description: List of BGP neighbors configured on the local system,\nuniquely identified by peer IPv[46] address", "id": "f23373:c1:m2"}
{"signature": "def _set_neighbor(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>neighbor.neighbor,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__neighbor = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for neighbor, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors/neighbor (list)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_neighbor is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_neighbor() directly.\n\n    YANG Description: List of BGP neighbors configured on the local system,\nuniquely identified by peer IPv[46] address", "id": "f23373:c0:m3"}
{"signature": "def _set_neighbors(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=neighbors.neighbors,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__neighbors = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for neighbors, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/neighbors (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_neighbors is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_neighbors() directly.\n\nYANG Description: Configuration for BGP neighbors", "id": "f23374:c0:m6"}
{"signature": "def _set_stale_routes_time(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__stale_routes_time = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for stale_routes_time, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/graceful_restart/state/stale_routes_time (decimal64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_stale_routes_time is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_stale_routes_time() directly.\n\n    YANG Description: An upper-bound on the time thate stale routes will be\nretained by a router after a session is restarted. If an\nEnd-of-RIB (EOR) marker is received prior to this timer\nexpiring stale-routes will be flushed upon its receipt - if\nno EOR is received, then when this timer expires stale paths\nwill be purged. This timer is referred to as the\nSelection_Deferral_Timer in RFC4724", "id": "f23375:c1:m9"}
{"signature": "def _get_restart_time(self):", "body": "return self.__restart_time<EOL>", "docstring": "Getter method for restart_time, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/graceful_restart/state/restart_time (uint16)\n\n    YANG Description: Estimated time (in seconds) for the local BGP speaker to\nrestart a session. This value is advertise in the graceful\nrestart BGP capability.  This is a 12-bit value, referred to\nas Restart Time in RFC4724.  Per RFC4724, the suggested\ndefault value is <= the hold-time value.", "id": "f23375:c0:m5"}
{"signature": "def _set_helper_only(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__helper_only = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for helper_only, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/graceful_restart/state/helper_only (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_helper_only is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_helper_only() directly.\n\n    YANG Description: Enable graceful-restart in helper mode only. When this\nleaf is set, the local system does not retain forwarding\nits own state during a restart, but supports procedures\nfor the receiving speaker, as defined in RFC4724.", "id": "f23375:c1:m12"}
{"signature": "def _get_stale_routes_time(self):", "body": "return self.__stale_routes_time<EOL>", "docstring": "Getter method for stale_routes_time, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/graceful_restart/state/stale_routes_time (decimal64)\n\n    YANG Description: An upper-bound on the time thate stale routes will be\nretained by a router after a session is restarted. If an\nEnd-of-RIB (EOR) marker is received prior to this timer\nexpiring stale-routes will be flushed upon its receipt - if\nno EOR is received, then when this timer expires stale paths\nwill be purged. This timer is referred to as the\nSelection_Deferral_Timer in RFC4724", "id": "f23375:c1:m8"}
{"signature": "def _get_restart_time(self):", "body": "return self.__restart_time<EOL>", "docstring": "Getter method for restart_time, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/graceful_restart/state/restart_time (uint16)\n\n    YANG Description: Estimated time (in seconds) for the local BGP speaker to\nrestart a session. This value is advertise in the graceful\nrestart BGP capability.  This is a 12-bit value, referred to\nas Restart Time in RFC4724.  Per RFC4724, the suggested\ndefault value is <= the hold-time value.", "id": "f23375:c1:m5"}
{"signature": "def _set_restart_time(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:16>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__restart_time = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for restart_time, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/graceful_restart/config/restart_time (uint16)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_restart_time is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_restart_time() directly.\n\n    YANG Description: Estimated time (in seconds) for the local BGP speaker to\nrestart a session. This value is advertise in the graceful\nrestart BGP capability.  This is a 12-bit value, referred to\nas Restart Time in RFC4724.  Per RFC4724, the suggested\ndefault value is <= the hold-time value.", "id": "f23376:c1:m6"}
{"signature": "def _get_restart_time(self):", "body": "return self.__restart_time<EOL>", "docstring": "Getter method for restart_time, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/graceful_restart/config/restart_time (uint16)\n\n    YANG Description: Estimated time (in seconds) for the local BGP speaker to\nrestart a session. This value is advertise in the graceful\nrestart BGP capability.  This is a 12-bit value, referred to\nas Restart Time in RFC4724.  Per RFC4724, the suggested\ndefault value is <= the hold-time value.", "id": "f23376:c1:m5"}
{"signature": "def _get_helper_only(self):", "body": "return self.__helper_only<EOL>", "docstring": "Getter method for helper_only, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/graceful_restart/config/helper_only (boolean)\n\n    YANG Description: Enable graceful-restart in helper mode only. When this\nleaf is set, the local system does not retain forwarding\nits own state during a restart, but supports procedures\nfor the receiving speaker, as defined in RFC4724.", "id": "f23376:c0:m11"}
{"signature": "def _get_stale_routes_time(self):", "body": "return self.__stale_routes_time<EOL>", "docstring": "Getter method for stale_routes_time, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/graceful_restart/config/stale_routes_time (decimal64)\n\n    YANG Description: An upper-bound on the time thate stale routes will be\nretained by a router after a session is restarted. If an\nEnd-of-RIB (EOR) marker is received prior to this timer\nexpiring stale-routes will be flushed upon its receipt - if\nno EOR is received, then when this timer expires stale paths\nwill be purged. This timer is referred to as the\nSelection_Deferral_Timer in RFC4724", "id": "f23376:c1:m8"}
{"signature": "def _set_stale_routes_time(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__stale_routes_time = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for stale_routes_time, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/graceful_restart/config/stale_routes_time (decimal64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_stale_routes_time is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_stale_routes_time() directly.\n\n    YANG Description: An upper-bound on the time thate stale routes will be\nretained by a router after a session is restarted. If an\nEnd-of-RIB (EOR) marker is received prior to this timer\nexpiring stale-routes will be flushed upon its receipt - if\nno EOR is received, then when this timer expires stale paths\nwill be purged. This timer is referred to as the\nSelection_Deferral_Timer in RFC4724", "id": "f23376:c1:m9"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/graceful_restart/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration parameters relating to graceful-restart", "id": "f23377:c1:m3"}
{"signature": "def _set_router_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__router_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for router_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/state/router_id (oc-yang:dotted-quad)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_router_id is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_router_id() directly.\n\n    YANG Description: Router id of the router - an unsigned 32-bit integer\nexpressed in dotted quad notation.", "id": "f23378:c1:m6"}
{"signature": "def _set_router_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__router_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for router_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/state/router_id (oc-yang:dotted-quad)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_router_id is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_router_id() directly.\n\n    YANG Description: Router id of the router - an unsigned 32-bit integer\nexpressed in dotted quad notation.", "id": "f23378:c0:m6"}
{"signature": "def _get_as_(self):", "body": "return self.__as_<EOL>", "docstring": "Getter method for as_, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/state/as (oc-inet:as-number)\n\n    YANG Description: Local autonomous system number of the router.  Uses\nthe 32-bit as-number type from the model in RFC 6991.", "id": "f23378:c1:m2"}
{"signature": "def _set_total_paths(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__total_paths = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for total_paths, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/state/total_paths (uint32)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_total_paths is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_total_paths() directly.\n\nYANG Description: Total number of BGP paths within the context", "id": "f23378:c1:m9"}
{"signature": "def _set_as_(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__as_ = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for as_, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/state/as (oc-inet:as-number)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_as_ is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_as_() directly.\n\n    YANG Description: Local autonomous system number of the router.  Uses\nthe 32-bit as-number type from the model in RFC 6991.", "id": "f23378:c0:m3"}
{"signature": "def _set_as_(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__as_ = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for as_, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/state/as (oc-inet:as-number)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_as_ is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_as_() directly.\n\n    YANG Description: Local autonomous system number of the router.  Uses\nthe 32-bit as-number type from the model in RFC 6991.", "id": "f23378:c1:m3"}
{"signature": "def _get_total_prefixes(self):", "body": "return self.__total_prefixes<EOL>", "docstring": "Getter method for total_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/state/total_prefixes (uint32)\n\nYANG Description: Total number of BGP prefixes received within the context", "id": "f23378:c0:m11"}
{"signature": "def _set_prefix(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prefix = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prefix, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/dynamic_neighbor_prefixes/dynamic_neighbor_prefix/state/prefix (oc-inet:ip-prefix)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prefix is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prefix() directly.\n\n    YANG Description: The IP prefix within which the source address of the remote\nBGP speaker must fall to be considered eligible to the\ndynamically configured.", "id": "f23379:c0:m3"}
{"signature": "def _get_prefix(self):", "body": "return self.__prefix<EOL>", "docstring": "Getter method for prefix, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/dynamic_neighbor_prefixes/dynamic_neighbor_prefix/state/prefix (oc-inet:ip-prefix)\n\n    YANG Description: The IP prefix within which the source address of the remote\nBGP speaker must fall to be considered eligible to the\ndynamically configured.", "id": "f23379:c1:m2"}
{"signature": "def _set_peer_group(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__peer_group = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for peer_group, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/dynamic_neighbor_prefixes/dynamic_neighbor_prefix/state/peer_group (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_peer_group is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_peer_group() directly.\n\n    YANG Description: The peer-group within which the dynamic neighbor will be\nconfigured.  The configuration parameters used for the dynamic\nneighbor are those specified within the referenced peer\ngroup.", "id": "f23379:c0:m6"}
{"signature": "def _get_prefix(self):", "body": "return self.__prefix<EOL>", "docstring": "Getter method for prefix, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/dynamic_neighbor_prefixes/dynamic_neighbor_prefix/state/prefix (oc-inet:ip-prefix)\n\n    YANG Description: The IP prefix within which the source address of the remote\nBGP speaker must fall to be considered eligible to the\ndynamically configured.", "id": "f23379:c0:m2"}
{"signature": "def _get_prefix(self):", "body": "return self.__prefix<EOL>", "docstring": "Getter method for prefix, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/dynamic_neighbor_prefixes/dynamic_neighbor_prefix/config/prefix (oc-inet:ip-prefix)\n\n    YANG Description: The IP prefix within which the source address of the remote\nBGP speaker must fall to be considered eligible to the\ndynamically configured.", "id": "f23380:c1:m2"}
{"signature": "def _get_peer_group(self):", "body": "return self.__peer_group<EOL>", "docstring": "Getter method for peer_group, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/dynamic_neighbor_prefixes/dynamic_neighbor_prefix/config/peer_group (leafref)\n\n    YANG Description: The peer-group within which the dynamic neighbor will be\nconfigured.  The configuration parameters used for the dynamic\nneighbor are those specified within the referenced peer\ngroup.", "id": "f23380:c0:m5"}
{"signature": "def _set_prefix(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=[<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_dict={<EOL>\"<STR_LIT>\": \"<STR_LIT>\"<EOL>},<EOL>),<EOL>],<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prefix = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prefix, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/dynamic_neighbor_prefixes/dynamic_neighbor_prefix/config/prefix (oc-inet:ip-prefix)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prefix is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prefix() directly.\n\n    YANG Description: The IP prefix within which the source address of the remote\nBGP speaker must fall to be considered eligible to the\ndynamically configured.", "id": "f23380:c1:m3"}
{"signature": "def _get_prefix(self):", "body": "return self.__prefix<EOL>", "docstring": "Getter method for prefix, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/dynamic_neighbor_prefixes/dynamic_neighbor_prefix/prefix (leafref)\n\n    YANG Description: Reference to the IP prefix from which source connections\nare allowed for the dynamic neighbor group.", "id": "f23381:c0:m2"}
{"signature": "def _set_prefix(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prefix = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prefix, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/dynamic_neighbor_prefixes/dynamic_neighbor_prefix/prefix (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prefix is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prefix() directly.\n\n    YANG Description: Reference to the IP prefix from which source connections\nare allowed for the dynamic neighbor group.", "id": "f23381:c1:m3"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/dynamic_neighbor_prefixes/dynamic_neighbor_prefix/config (container)\n\n    YANG Description: Configuration parameters relating to the source prefix\nfor the dynamic BGP neighbor connections.", "id": "f23381:c0:m5"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/dynamic_neighbor_prefixes/dynamic_neighbor_prefix/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to the source prefix\nfor the dynamic BGP neighbor connections.", "id": "f23381:c1:m6"}
{"signature": "def _set_dynamic_neighbor_prefix(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>dynamic_neighbor_prefix.dynamic_neighbor_prefix,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__dynamic_neighbor_prefix = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for dynamic_neighbor_prefix, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/dynamic_neighbor_prefixes/dynamic_neighbor_prefix (list)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_dynamic_neighbor_prefix is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_dynamic_neighbor_prefix() directly.\n\n    YANG Description: An individual prefix from which dynamic neighbor\nconnections are allowed.", "id": "f23382:c1:m3"}
{"signature": "def _get_dynamic_neighbor_prefix(self):", "body": "return self.__dynamic_neighbor_prefix<EOL>", "docstring": "Getter method for dynamic_neighbor_prefix, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/dynamic_neighbor_prefixes/dynamic_neighbor_prefix (list)\n\n    YANG Description: An individual prefix from which dynamic neighbor\nconnections are allowed.", "id": "f23382:c1:m2"}
{"signature": "def _set_afi_safi(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT>\",<EOL>afi_safi.afi_safi,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__afi_safi = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for afi_safi, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi (list)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_afi_safi is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_afi_safi() directly.\n\n    YANG Description: AFI,SAFI configuration available for the\nneighbour or group", "id": "f23383:c1:m3"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/graceful_restart/state/enabled (boolean)\n\n    YANG Description: This leaf indicates whether graceful-restart is enabled for\nthis AFI-SAFI", "id": "f23384:c1:m2"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/graceful_restart/state/enabled (boolean)\n\n    YANG Description: This leaf indicates whether graceful-restart is enabled for\nthis AFI-SAFI", "id": "f23384:c0:m2"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/graceful_restart/state/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: This leaf indicates whether graceful-restart is enabled for\nthis AFI-SAFI", "id": "f23384:c1:m3"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/graceful_restart/config/enabled (boolean)\n\n    YANG Description: This leaf indicates whether graceful-restart is enabled for\nthis AFI-SAFI", "id": "f23385:c1:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/graceful_restart/state (container)\n\nYANG Description: State information for BGP graceful-restart", "id": "f23386:c1:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/graceful_restart/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State information for BGP graceful-restart", "id": "f23386:c0:m6"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/graceful_restart/config (container)\n\nYANG Description: Configuration options for BGP graceful-restart", "id": "f23386:c0:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/graceful_restart/state (container)\n\nYANG Description: State information for BGP graceful-restart", "id": "f23386:c0:m5"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/graceful_restart/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration options for BGP graceful-restart", "id": "f23386:c0:m3"}
{"signature": "def _get_total_prefixes(self):", "body": "return self.__total_prefixes<EOL>", "docstring": "Getter method for total_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/state/total_prefixes (uint32)\n\nYANG Description: Total number of BGP prefixes received within the context", "id": "f23387:c1:m11"}
{"signature": "def _set_total_prefixes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__total_prefixes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for total_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/state/total_prefixes (uint32)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_total_prefixes is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_total_prefixes() directly.\n\nYANG Description: Total number of BGP prefixes received within the context", "id": "f23387:c0:m12"}
{"signature": "def _get_afi_safi_name(self):", "body": "return self.__afi_safi_name<EOL>", "docstring": "Getter method for afi_safi_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/state/afi_safi_name (identityref)\n\nYANG Description: AFI,SAFI", "id": "f23387:c1:m2"}
{"signature": "def _get_total_paths(self):", "body": "return self.__total_paths<EOL>", "docstring": "Getter method for total_paths, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/state/total_paths (uint32)\n\nYANG Description: Total number of BGP paths within the context", "id": "f23387:c1:m8"}
{"signature": "def _get_prefix_limit(self):", "body": "return self.__prefix_limit<EOL>", "docstring": "Getter method for prefix_limit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l2vpn_evpn/prefix_limit (container)\n\n    YANG Description: Configure the maximum number of prefixes that will be\naccepted from a peer", "id": "f23388:c0:m2"}
{"signature": "def _get_restart_timer(self):", "body": "return self.__restart_timer<EOL>", "docstring": "Getter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l2vpn_evpn/prefix_limit/state/restart_timer (decimal64)\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23389:c1:m11"}
{"signature": "def _set_shutdown_threshold_pct(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__shutdown_threshold_pct = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l2vpn_evpn/prefix_limit/state/shutdown_threshold_pct (oc-types:percentage)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_shutdown_threshold_pct is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_shutdown_threshold_pct() directly.\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23389:c1:m9"}
{"signature": "def _get_shutdown_threshold_pct(self):", "body": "return self.__shutdown_threshold_pct<EOL>", "docstring": "Getter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l2vpn_evpn/prefix_limit/state/shutdown_threshold_pct (oc-types:percentage)\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23389:c0:m8"}
{"signature": "def _get_max_prefixes(self):", "body": "return self.__max_prefixes<EOL>", "docstring": "Getter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l2vpn_evpn/prefix_limit/state/max_prefixes (uint32)\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23389:c1:m2"}
{"signature": "def _get_max_prefixes(self):", "body": "return self.__max_prefixes<EOL>", "docstring": "Getter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l2vpn_evpn/prefix_limit/state/max_prefixes (uint32)\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23389:c0:m2"}
{"signature": "def _get_prevent_teardown(self):", "body": "return self.__prevent_teardown<EOL>", "docstring": "Getter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l2vpn_evpn/prefix_limit/state/prevent_teardown (boolean)\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23389:c1:m5"}
{"signature": "def _get_shutdown_threshold_pct(self):", "body": "return self.__shutdown_threshold_pct<EOL>", "docstring": "Getter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l2vpn_evpn/prefix_limit/config/shutdown_threshold_pct (oc-types:percentage)\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23390:c1:m8"}
{"signature": "def _get_restart_timer(self):", "body": "return self.__restart_timer<EOL>", "docstring": "Getter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l2vpn_evpn/prefix_limit/config/restart_timer (decimal64)\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23390:c0:m11"}
{"signature": "def _get_prevent_teardown(self):", "body": "return self.__prevent_teardown<EOL>", "docstring": "Getter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l2vpn_evpn/prefix_limit/config/prevent_teardown (boolean)\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23390:c0:m5"}
{"signature": "def _set_prevent_teardown(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prevent_teardown = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l2vpn_evpn/prefix_limit/config/prevent_teardown (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prevent_teardown is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prevent_teardown() directly.\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23390:c1:m6"}
{"signature": "def _get_max_prefixes(self):", "body": "return self.__max_prefixes<EOL>", "docstring": "Getter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l2vpn_evpn/prefix_limit/config/max_prefixes (uint32)\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23390:c0:m2"}
{"signature": "def _set_restart_timer(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__restart_timer = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l2vpn_evpn/prefix_limit/config/restart_timer (decimal64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_restart_timer is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_restart_timer() directly.\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23390:c1:m12"}
{"signature": "def _set_max_prefixes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__max_prefixes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l2vpn_evpn/prefix_limit/config/max_prefixes (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_max_prefixes is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_max_prefixes() directly.\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23390:c1:m3"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l2vpn_evpn/prefix_limit/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to the prefix\nlimit for the AFI-SAFI", "id": "f23391:c0:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l2vpn_evpn/prefix_limit/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: State information relating to the prefix-limit for the\nAFI-SAFI", "id": "f23391:c1:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l2vpn_evpn/prefix_limit/state (container)\n\n    YANG Description: State information relating to the prefix-limit for the\nAFI-SAFI", "id": "f23391:c0:m5"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l2vpn_evpn/prefix_limit/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to the prefix\nlimit for the AFI-SAFI", "id": "f23391:c1:m3"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l2vpn_evpn/prefix_limit/config (container)\n\n    YANG Description: Configuration parameters relating to the prefix\nlimit for the AFI-SAFI", "id": "f23391:c1:m2"}
{"signature": "def _get_prefix_limit(self):", "body": "return self.__prefix_limit<EOL>", "docstring": "Getter method for prefix_limit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv6_labeled_unicast/prefix_limit (container)\n\n    YANG Description: Configure the maximum number of prefixes that will be\naccepted from a peer", "id": "f23392:c1:m2"}
{"signature": "def _set_prefix_limit(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=prefix_limit.prefix_limit,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prefix_limit = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prefix_limit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv6_labeled_unicast/prefix_limit (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prefix_limit is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prefix_limit() directly.\n\n    YANG Description: Configure the maximum number of prefixes that will be\naccepted from a peer", "id": "f23392:c1:m3"}
{"signature": "def _get_shutdown_threshold_pct(self):", "body": "return self.__shutdown_threshold_pct<EOL>", "docstring": "Getter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv6_labeled_unicast/prefix_limit/state/shutdown_threshold_pct (oc-types:percentage)\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23393:c0:m8"}
{"signature": "def _set_prevent_teardown(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prevent_teardown = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv6_labeled_unicast/prefix_limit/state/prevent_teardown (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prevent_teardown is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prevent_teardown() directly.\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23393:c0:m6"}
{"signature": "def _get_restart_timer(self):", "body": "return self.__restart_timer<EOL>", "docstring": "Getter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv6_labeled_unicast/prefix_limit/state/restart_timer (decimal64)\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23393:c0:m11"}
{"signature": "def _set_restart_timer(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__restart_timer = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv6_labeled_unicast/prefix_limit/state/restart_timer (decimal64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_restart_timer is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_restart_timer() directly.\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23393:c1:m12"}
{"signature": "def _set_shutdown_threshold_pct(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__shutdown_threshold_pct = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv6_labeled_unicast/prefix_limit/state/shutdown_threshold_pct (oc-types:percentage)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_shutdown_threshold_pct is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_shutdown_threshold_pct() directly.\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23393:c0:m9"}
{"signature": "def _get_prevent_teardown(self):", "body": "return self.__prevent_teardown<EOL>", "docstring": "Getter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv6_labeled_unicast/prefix_limit/config/prevent_teardown (boolean)\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23394:c1:m5"}
{"signature": "def _get_max_prefixes(self):", "body": "return self.__max_prefixes<EOL>", "docstring": "Getter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv6_labeled_unicast/prefix_limit/config/max_prefixes (uint32)\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23394:c1:m2"}
{"signature": "def _set_restart_timer(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__restart_timer = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv6_labeled_unicast/prefix_limit/config/restart_timer (decimal64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_restart_timer is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_restart_timer() directly.\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23394:c1:m12"}
{"signature": "def _set_max_prefixes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__max_prefixes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv6_labeled_unicast/prefix_limit/config/max_prefixes (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_max_prefixes is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_max_prefixes() directly.\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23394:c0:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv6_labeled_unicast/prefix_limit/state (container)\n\n    YANG Description: State information relating to the prefix-limit for the\nAFI-SAFI", "id": "f23395:c1:m5"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv6_labeled_unicast/prefix_limit/state (container)\n\n    YANG Description: State information relating to the prefix-limit for the\nAFI-SAFI", "id": "f23395:c0:m5"}
{"signature": "def _get_prefix_limit(self):", "body": "return self.__prefix_limit<EOL>", "docstring": "Getter method for prefix_limit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv4_labeled_unicast/prefix_limit (container)\n\n    YANG Description: Configure the maximum number of prefixes that will be\naccepted from a peer", "id": "f23396:c1:m2"}
{"signature": "def _set_shutdown_threshold_pct(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__shutdown_threshold_pct = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv4_labeled_unicast/prefix_limit/state/shutdown_threshold_pct (oc-types:percentage)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_shutdown_threshold_pct is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_shutdown_threshold_pct() directly.\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23397:c1:m9"}
{"signature": "def _set_max_prefixes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__max_prefixes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv4_labeled_unicast/prefix_limit/state/max_prefixes (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_max_prefixes is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_max_prefixes() directly.\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23397:c1:m3"}
{"signature": "def _set_shutdown_threshold_pct(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__shutdown_threshold_pct = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv4_labeled_unicast/prefix_limit/state/shutdown_threshold_pct (oc-types:percentage)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_shutdown_threshold_pct is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_shutdown_threshold_pct() directly.\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23397:c0:m9"}
{"signature": "def _get_max_prefixes(self):", "body": "return self.__max_prefixes<EOL>", "docstring": "Getter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv4_labeled_unicast/prefix_limit/state/max_prefixes (uint32)\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23397:c0:m2"}
{"signature": "def _set_restart_timer(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__restart_timer = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv4_labeled_unicast/prefix_limit/state/restart_timer (decimal64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_restart_timer is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_restart_timer() directly.\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23397:c1:m12"}
{"signature": "def _get_restart_timer(self):", "body": "return self.__restart_timer<EOL>", "docstring": "Getter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv4_labeled_unicast/prefix_limit/state/restart_timer (decimal64)\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23397:c0:m11"}
{"signature": "def _set_prevent_teardown(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prevent_teardown = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv4_labeled_unicast/prefix_limit/state/prevent_teardown (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prevent_teardown is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prevent_teardown() directly.\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23397:c0:m6"}
{"signature": "def _get_max_prefixes(self):", "body": "return self.__max_prefixes<EOL>", "docstring": "Getter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv4_labeled_unicast/prefix_limit/state/max_prefixes (uint32)\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23397:c1:m2"}
{"signature": "def _set_prevent_teardown(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prevent_teardown = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv4_labeled_unicast/prefix_limit/state/prevent_teardown (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prevent_teardown is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prevent_teardown() directly.\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23397:c1:m6"}
{"signature": "def _set_max_prefixes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__max_prefixes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv4_labeled_unicast/prefix_limit/config/max_prefixes (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_max_prefixes is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_max_prefixes() directly.\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23398:c0:m3"}
{"signature": "def _set_restart_timer(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__restart_timer = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv4_labeled_unicast/prefix_limit/config/restart_timer (decimal64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_restart_timer is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_restart_timer() directly.\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23398:c0:m12"}
{"signature": "def _get_max_prefixes(self):", "body": "return self.__max_prefixes<EOL>", "docstring": "Getter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv4_labeled_unicast/prefix_limit/config/max_prefixes (uint32)\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23398:c1:m2"}
{"signature": "def _get_shutdown_threshold_pct(self):", "body": "return self.__shutdown_threshold_pct<EOL>", "docstring": "Getter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv4_labeled_unicast/prefix_limit/config/shutdown_threshold_pct (oc-types:percentage)\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23398:c0:m8"}
{"signature": "def _set_prevent_teardown(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prevent_teardown = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv4_labeled_unicast/prefix_limit/config/prevent_teardown (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prevent_teardown is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prevent_teardown() directly.\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23398:c0:m6"}
{"signature": "def _get_max_prefixes(self):", "body": "return self.__max_prefixes<EOL>", "docstring": "Getter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv4_labeled_unicast/prefix_limit/config/max_prefixes (uint32)\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23398:c0:m2"}
{"signature": "def _set_prevent_teardown(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prevent_teardown = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv4_labeled_unicast/prefix_limit/config/prevent_teardown (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prevent_teardown is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prevent_teardown() directly.\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23398:c1:m6"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv4_labeled_unicast/prefix_limit/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: State information relating to the prefix-limit for the\nAFI-SAFI", "id": "f23399:c1:m6"}
{"signature": "def _set_prefix_limit(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=prefix_limit.prefix_limit,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prefix_limit = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prefix_limit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv4_multicast/prefix_limit (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prefix_limit is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prefix_limit() directly.\n\n    YANG Description: Configure the maximum number of prefixes that will be\naccepted from a peer", "id": "f23400:c1:m3"}
{"signature": "def _get_prefix_limit(self):", "body": "return self.__prefix_limit<EOL>", "docstring": "Getter method for prefix_limit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv4_multicast/prefix_limit (container)\n\n    YANG Description: Configure the maximum number of prefixes that will be\naccepted from a peer", "id": "f23400:c1:m2"}
{"signature": "def _get_shutdown_threshold_pct(self):", "body": "return self.__shutdown_threshold_pct<EOL>", "docstring": "Getter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv4_multicast/prefix_limit/state/shutdown_threshold_pct (oc-types:percentage)\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23401:c1:m8"}
{"signature": "def _set_prevent_teardown(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prevent_teardown = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv4_multicast/prefix_limit/state/prevent_teardown (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prevent_teardown is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prevent_teardown() directly.\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23401:c1:m6"}
{"signature": "def _set_restart_timer(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__restart_timer = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv4_multicast/prefix_limit/state/restart_timer (decimal64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_restart_timer is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_restart_timer() directly.\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23401:c1:m12"}
{"signature": "def _set_max_prefixes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__max_prefixes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv4_multicast/prefix_limit/config/max_prefixes (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_max_prefixes is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_max_prefixes() directly.\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23402:c0:m3"}
{"signature": "def _get_max_prefixes(self):", "body": "return self.__max_prefixes<EOL>", "docstring": "Getter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv4_multicast/prefix_limit/config/max_prefixes (uint32)\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23402:c1:m2"}
{"signature": "def _get_restart_timer(self):", "body": "return self.__restart_timer<EOL>", "docstring": "Getter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv4_multicast/prefix_limit/config/restart_timer (decimal64)\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23402:c0:m11"}
{"signature": "def _set_restart_timer(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__restart_timer = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv4_multicast/prefix_limit/config/restart_timer (decimal64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_restart_timer is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_restart_timer() directly.\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23402:c1:m12"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv4_multicast/prefix_limit/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to the prefix\nlimit for the AFI-SAFI", "id": "f23403:c0:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv4_multicast/prefix_limit/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: State information relating to the prefix-limit for the\nAFI-SAFI", "id": "f23403:c0:m6"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv4_multicast/prefix_limit/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: State information relating to the prefix-limit for the\nAFI-SAFI", "id": "f23403:c1:m6"}
{"signature": "def _set_ignore_as_path_length(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ignore_as_path_length = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ignore_as_path_length, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/route_selection_options/state/ignore_as_path_length (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_ignore_as_path_length is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_ignore_as_path_length() directly.\n\n    YANG Description: Ignore the AS path length when selecting the best path.\nThe default is to use the AS path length and prefer paths\nwith shorter length.", "id": "f23404:c1:m6"}
{"signature": "def _set_ignore_next_hop_igp_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ignore_next_hop_igp_metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ignore_next_hop_igp_metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/route_selection_options/state/ignore_next_hop_igp_metric (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_ignore_next_hop_igp_metric is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_ignore_next_hop_igp_metric() directly.\n\n    YANG Description: Ignore the IGP metric to the next-hop when calculating\nBGP best-path. The default is to select the route for\nwhich the metric to the next-hop is lowest", "id": "f23404:c1:m18"}
{"signature": "def _get_external_compare_router_id(self):", "body": "return self.__external_compare_router_id<EOL>", "docstring": "Getter method for external_compare_router_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/route_selection_options/state/external_compare_router_id (boolean)\n\n    YANG Description: When comparing similar routes received from external\nBGP peers, use the router-id as a criterion to select\nthe active path.", "id": "f23404:c0:m8"}
{"signature": "def _get_always_compare_med(self):", "body": "return self.__always_compare_med<EOL>", "docstring": "Getter method for always_compare_med, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/route_selection_options/config/always_compare_med (boolean)\n\n    YANG Description: Compare multi-exit discriminator (MED) value from\ndifferent ASes when selecting the best route.  The\ndefault behavior is to only compare MEDs for paths\nreceived from the same AS.", "id": "f23405:c0:m2"}
{"signature": "def _set_external_compare_router_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:true>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__external_compare_router_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for external_compare_router_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/route_selection_options/config/external_compare_router_id (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_external_compare_router_id is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_external_compare_router_id() directly.\n\n    YANG Description: When comparing similar routes received from external\nBGP peers, use the router-id as a criterion to select\nthe active path.", "id": "f23405:c1:m9"}
{"signature": "def _get_ignore_next_hop_igp_metric(self):", "body": "return self.__ignore_next_hop_igp_metric<EOL>", "docstring": "Getter method for ignore_next_hop_igp_metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/route_selection_options/config/ignore_next_hop_igp_metric (boolean)\n\n    YANG Description: Ignore the IGP metric to the next-hop when calculating\nBGP best-path. The default is to select the route for\nwhich the metric to the next-hop is lowest", "id": "f23405:c1:m17"}
{"signature": "def _set_enable_aigp(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enable_aigp = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enable_aigp, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/route_selection_options/config/enable_aigp (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enable_aigp is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enable_aigp() directly.\n\n    YANG Description: Flag to enable sending / receiving accumulated IGP\nattribute in routing updates", "id": "f23405:c1:m15"}
{"signature": "def _get_enable_aigp(self):", "body": "return self.__enable_aigp<EOL>", "docstring": "Getter method for enable_aigp, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/route_selection_options/config/enable_aigp (boolean)\n\n    YANG Description: Flag to enable sending / receiving accumulated IGP\nattribute in routing updates", "id": "f23405:c1:m14"}
{"signature": "def _set_external_compare_router_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:true>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__external_compare_router_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for external_compare_router_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/route_selection_options/config/external_compare_router_id (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_external_compare_router_id is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_external_compare_router_id() directly.\n\n    YANG Description: When comparing similar routes received from external\nBGP peers, use the router-id as a criterion to select\nthe active path.", "id": "f23405:c0:m9"}
{"signature": "def _set_prefix_limit(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=prefix_limit.prefix_limit,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prefix_limit = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prefix_limit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l2vpn_vpls/prefix_limit (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prefix_limit is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prefix_limit() directly.\n\n    YANG Description: Configure the maximum number of prefixes that will be\naccepted from a peer", "id": "f23407:c0:m3"}
{"signature": "def _get_prevent_teardown(self):", "body": "return self.__prevent_teardown<EOL>", "docstring": "Getter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l2vpn_vpls/prefix_limit/state/prevent_teardown (boolean)\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23408:c1:m5"}
{"signature": "def _get_restart_timer(self):", "body": "return self.__restart_timer<EOL>", "docstring": "Getter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l2vpn_vpls/prefix_limit/state/restart_timer (decimal64)\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23408:c1:m11"}
{"signature": "def _set_max_prefixes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__max_prefixes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l2vpn_vpls/prefix_limit/config/max_prefixes (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_max_prefixes is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_max_prefixes() directly.\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23409:c1:m3"}
{"signature": "def _get_shutdown_threshold_pct(self):", "body": "return self.__shutdown_threshold_pct<EOL>", "docstring": "Getter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l2vpn_vpls/prefix_limit/config/shutdown_threshold_pct (oc-types:percentage)\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23409:c1:m8"}
{"signature": "def _set_prevent_teardown(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prevent_teardown = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l2vpn_vpls/prefix_limit/config/prevent_teardown (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prevent_teardown is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prevent_teardown() directly.\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23409:c1:m6"}
{"signature": "def _get_max_prefixes(self):", "body": "return self.__max_prefixes<EOL>", "docstring": "Getter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l2vpn_vpls/prefix_limit/config/max_prefixes (uint32)\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23409:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l2vpn_vpls/prefix_limit/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: State information relating to the prefix-limit for the\nAFI-SAFI", "id": "f23410:c0:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l2vpn_vpls/prefix_limit/state (container)\n\n    YANG Description: State information relating to the prefix-limit for the\nAFI-SAFI", "id": "f23410:c1:m5"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l2vpn_vpls/prefix_limit/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to the prefix\nlimit for the AFI-SAFI", "id": "f23410:c1:m3"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l2vpn_vpls/prefix_limit/config (container)\n\n    YANG Description: Configuration parameters relating to the prefix\nlimit for the AFI-SAFI", "id": "f23410:c0:m2"}
{"signature": "def _set_send_default_route(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__send_default_route = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for send_default_route, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv6_unicast/config/send_default_route (boolean)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_send_default_route is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_send_default_route() directly.\n\nYANG Description: If set to true, send the default-route to the neighbour(s)", "id": "f23412:c0:m3"}
{"signature": "def _set_send_default_route(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__send_default_route = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for send_default_route, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv6_unicast/config/send_default_route (boolean)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_send_default_route is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_send_default_route() directly.\n\nYANG Description: If set to true, send the default-route to the neighbour(s)", "id": "f23412:c1:m3"}
{"signature": "def _get_send_default_route(self):", "body": "return self.__send_default_route<EOL>", "docstring": "Getter method for send_default_route, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv6_unicast/config/send_default_route (boolean)\n\nYANG Description: If set to true, send the default-route to the neighbour(s)", "id": "f23412:c0:m2"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv6_unicast/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters for common IPv4 and IPv6 unicast\nAFI-SAFI options", "id": "f23413:c0:m6"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv6_unicast/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: State information for common IPv4 and IPv6 unicast\nparameters", "id": "f23413:c0:m9"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv6_unicast/state (container)\n\n    YANG Description: State information for common IPv4 and IPv6 unicast\nparameters", "id": "f23413:c1:m8"}
{"signature": "def _set_restart_timer(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__restart_timer = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv6_unicast/prefix_limit/state/restart_timer (decimal64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_restart_timer is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_restart_timer() directly.\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23414:c1:m12"}
{"signature": "def _get_shutdown_threshold_pct(self):", "body": "return self.__shutdown_threshold_pct<EOL>", "docstring": "Getter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv6_unicast/prefix_limit/state/shutdown_threshold_pct (oc-types:percentage)\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23414:c0:m8"}
{"signature": "def _get_shutdown_threshold_pct(self):", "body": "return self.__shutdown_threshold_pct<EOL>", "docstring": "Getter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv6_unicast/prefix_limit/state/shutdown_threshold_pct (oc-types:percentage)\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23414:c1:m8"}
{"signature": "def _set_prevent_teardown(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prevent_teardown = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv6_unicast/prefix_limit/state/prevent_teardown (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prevent_teardown is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prevent_teardown() directly.\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23414:c1:m6"}
{"signature": "def _get_prevent_teardown(self):", "body": "return self.__prevent_teardown<EOL>", "docstring": "Getter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv6_unicast/prefix_limit/state/prevent_teardown (boolean)\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23414:c1:m5"}
{"signature": "def _get_restart_timer(self):", "body": "return self.__restart_timer<EOL>", "docstring": "Getter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv6_unicast/prefix_limit/state/restart_timer (decimal64)\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23414:c0:m11"}
{"signature": "def _get_restart_timer(self):", "body": "return self.__restart_timer<EOL>", "docstring": "Getter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv6_unicast/prefix_limit/config/restart_timer (decimal64)\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23415:c0:m11"}
{"signature": "def _set_max_prefixes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__max_prefixes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv6_unicast/prefix_limit/config/max_prefixes (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_max_prefixes is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_max_prefixes() directly.\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23415:c1:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv6_unicast/prefix_limit/state (container)\n\n    YANG Description: State information relating to the prefix-limit for the\nAFI-SAFI", "id": "f23416:c0:m5"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv6_unicast/prefix_limit/config (container)\n\n    YANG Description: Configuration parameters relating to the prefix\nlimit for the AFI-SAFI", "id": "f23416:c1:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv6_unicast/prefix_limit/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: State information relating to the prefix-limit for the\nAFI-SAFI", "id": "f23416:c0:m6"}
{"signature": "def _set_afi_safi_name(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=six.text_type,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__afi_safi_name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for afi_safi_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/config/afi_safi_name (identityref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_afi_safi_name is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_afi_safi_name() directly.\n\nYANG Description: AFI,SAFI", "id": "f23417:c0:m3"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/use_multiple_paths/state/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: Whether the use of multiple paths for the same NLRI is\nenabled for the neighbor. This value is overridden by\nany more specific configuration value.", "id": "f23418:c0:m3"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/use_multiple_paths/config/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: Whether the use of multiple paths for the same NLRI is\nenabled for the neighbor. This value is overridden by\nany more specific configuration value.", "id": "f23419:c1:m3"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/use_multiple_paths/config/enabled (boolean)\n\n    YANG Description: Whether the use of multiple paths for the same NLRI is\nenabled for the neighbor. This value is overridden by\nany more specific configuration value.", "id": "f23419:c1:m2"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/use_multiple_paths/config/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: Whether the use of multiple paths for the same NLRI is\nenabled for the neighbor. This value is overridden by\nany more specific configuration value.", "id": "f23419:c0:m3"}
{"signature": "def _get_ebgp(self):", "body": "return self.__ebgp<EOL>", "docstring": "Getter method for ebgp, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/use_multiple_paths/ebgp (container)\n\nYANG Description: Multipath parameters for eBGP", "id": "f23420:c0:m8"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/use_multiple_paths/state (container)\n\nYANG Description: State parameters relating to multipath", "id": "f23420:c1:m5"}
{"signature": "def _get_ibgp(self):", "body": "return self.__ibgp<EOL>", "docstring": "Getter method for ibgp, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/use_multiple_paths/ibgp (container)\n\nYANG Description: Multipath parameters for iBGP", "id": "f23420:c1:m11"}
{"signature": "def _set_ebgp(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=ebgp.ebgp,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ebgp = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ebgp, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/use_multiple_paths/ebgp (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ebgp is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ebgp() directly.\n\nYANG Description: Multipath parameters for eBGP", "id": "f23420:c1:m9"}
{"signature": "def _get_ibgp(self):", "body": "return self.__ibgp<EOL>", "docstring": "Getter method for ibgp, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/use_multiple_paths/ibgp (container)\n\nYANG Description: Multipath parameters for iBGP", "id": "f23420:c0:m11"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/use_multiple_paths/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State parameters relating to multipath", "id": "f23420:c0:m6"}
{"signature": "def _set_maximum_paths(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>default=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>)(<EOL><NUM_LIT:1><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__maximum_paths = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for maximum_paths, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/use_multiple_paths/ibgp/state/maximum_paths (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_maximum_paths is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_maximum_paths() directly.\n\n    YANG Description: Maximum number of parallel paths to consider when using\niBGP multipath. The default is to use a single path", "id": "f23421:c1:m3"}
{"signature": "def _get_maximum_paths(self):", "body": "return self.__maximum_paths<EOL>", "docstring": "Getter method for maximum_paths, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/use_multiple_paths/ibgp/config/maximum_paths (uint32)\n\n    YANG Description: Maximum number of parallel paths to consider when using\niBGP multipath. The default is to use a single path", "id": "f23422:c1:m2"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/use_multiple_paths/ibgp/state (container)\n\nYANG Description: State information relating to iBGP multipath", "id": "f23423:c0:m5"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/use_multiple_paths/ibgp/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration parameters relating to iBGP multipath", "id": "f23423:c0:m3"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/use_multiple_paths/ibgp/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State information relating to iBGP multipath", "id": "f23423:c1:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/use_multiple_paths/ibgp/state (container)\n\nYANG Description: State information relating to iBGP multipath", "id": "f23423:c1:m5"}
{"signature": "def _get_maximum_paths(self):", "body": "return self.__maximum_paths<EOL>", "docstring": "Getter method for maximum_paths, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/use_multiple_paths/ebgp/state/maximum_paths (uint32)\n\n    YANG Description: Maximum number of parallel paths to consider when using\nBGP multipath. The default is use a single path.", "id": "f23424:c0:m5"}
{"signature": "def _get_allow_multiple_as(self):", "body": "return self.__allow_multiple_as<EOL>", "docstring": "Getter method for allow_multiple_as, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/use_multiple_paths/ebgp/state/allow_multiple_as (boolean)\n\n    YANG Description: Allow multipath to use paths from different neighbouring\nASes.  The default is to only consider multiple paths from\nthe same neighbouring AS.", "id": "f23424:c0:m2"}
{"signature": "def _set_maximum_paths(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>default=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>)(<EOL><NUM_LIT:1><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__maximum_paths = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for maximum_paths, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/use_multiple_paths/ebgp/state/maximum_paths (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_maximum_paths is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_maximum_paths() directly.\n\n    YANG Description: Maximum number of parallel paths to consider when using\nBGP multipath. The default is use a single path.", "id": "f23424:c0:m6"}
{"signature": "def _set_allow_multiple_as(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__allow_multiple_as = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for allow_multiple_as, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/use_multiple_paths/ebgp/config/allow_multiple_as (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_allow_multiple_as is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_allow_multiple_as() directly.\n\n    YANG Description: Allow multipath to use paths from different neighbouring\nASes.  The default is to only consider multiple paths from\nthe same neighbouring AS.", "id": "f23425:c1:m3"}
{"signature": "def _set_allow_multiple_as(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__allow_multiple_as = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for allow_multiple_as, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/use_multiple_paths/ebgp/config/allow_multiple_as (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_allow_multiple_as is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_allow_multiple_as() directly.\n\n    YANG Description: Allow multipath to use paths from different neighbouring\nASes.  The default is to only consider multiple paths from\nthe same neighbouring AS.", "id": "f23425:c0:m3"}
{"signature": "def _get_allow_multiple_as(self):", "body": "return self.__allow_multiple_as<EOL>", "docstring": "Getter method for allow_multiple_as, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/use_multiple_paths/ebgp/config/allow_multiple_as (boolean)\n\n    YANG Description: Allow multipath to use paths from different neighbouring\nASes.  The default is to only consider multiple paths from\nthe same neighbouring AS.", "id": "f23425:c0:m2"}
{"signature": "def _set_maximum_paths(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>default=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>)(<EOL><NUM_LIT:1><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__maximum_paths = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for maximum_paths, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/use_multiple_paths/ebgp/config/maximum_paths (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_maximum_paths is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_maximum_paths() directly.\n\n    YANG Description: Maximum number of parallel paths to consider when using\nBGP multipath. The default is use a single path.", "id": "f23425:c0:m6"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/use_multiple_paths/ebgp/state (container)\n\nYANG Description: State information relating to eBGP multipath", "id": "f23426:c1:m5"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/use_multiple_paths/ebgp/config (container)\n\nYANG Description: Configuration parameters relating to eBGP multipath", "id": "f23426:c1:m2"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/use_multiple_paths/ebgp/config (container)\n\nYANG Description: Configuration parameters relating to eBGP multipath", "id": "f23426:c0:m2"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/use_multiple_paths/ebgp/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration parameters relating to eBGP multipath", "id": "f23426:c1:m3"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/use_multiple_paths/ebgp/state (container)\n\nYANG Description: State information relating to eBGP multipath", "id": "f23426:c0:m5"}
{"signature": "def _get_ipv6_unicast(self):", "body": "return self.__ipv6_unicast<EOL>", "docstring": "Getter method for ipv6_unicast, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv6_unicast (container)\n\nYANG Description: IPv6 unicast configuration options", "id": "f23427:c1:m23"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/state (container)\n\nYANG Description: State information relating to the AFI-SAFI", "id": "f23427:c0:m8"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/config (container)\n\nYANG Description: Configuration parameters for the AFI-SAFI", "id": "f23427:c1:m5"}
{"signature": "def _get_route_selection_options(self):", "body": "return self.__route_selection_options<EOL>", "docstring": "Getter method for route_selection_options, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/route_selection_options (container)\n\nYANG Description: Parameters relating to options for route selection", "id": "f23427:c1:m14"}
{"signature": "def _get_ipv4_labeled_unicast(self):", "body": "return self.__ipv4_labeled_unicast<EOL>", "docstring": "Getter method for ipv4_labeled_unicast, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv4_labeled_unicast (container)\n\nYANG Description: IPv4 Labeled Unicast configuration options", "id": "f23427:c0:m26"}
{"signature": "def _get_graceful_restart(self):", "body": "return self.__graceful_restart<EOL>", "docstring": "Getter method for graceful_restart, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/graceful_restart (container)\n\nYANG Description: Parameters relating to BGP graceful-restart", "id": "f23427:c0:m11"}
{"signature": "def _set_afi_safi_name(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__afi_safi_name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for afi_safi_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/afi_safi_name (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_afi_safi_name is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_afi_safi_name() directly.\n\n    YANG Description: Reference to the AFI-SAFI name used as a key\nfor the AFI-SAFI list", "id": "f23427:c0:m3"}
{"signature": "def _set_use_multiple_paths(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=use_multiple_paths.use_multiple_paths,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__use_multiple_paths = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for use_multiple_paths, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/use_multiple_paths (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_use_multiple_paths is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_use_multiple_paths() directly.\n\n    YANG Description: Parameters related to the use of multiple paths for the\nsame NLRI", "id": "f23427:c1:m18"}
{"signature": "def _get_afi_safi_name(self):", "body": "return self.__afi_safi_name<EOL>", "docstring": "Getter method for afi_safi_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/afi_safi_name (leafref)\n\n    YANG Description: Reference to the AFI-SAFI name used as a key\nfor the AFI-SAFI list", "id": "f23427:c1:m2"}
{"signature": "def _set_l2vpn_evpn(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=l2vpn_evpn.l2vpn_evpn,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__l2vpn_evpn = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for l2vpn_evpn, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l2vpn_evpn (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_l2vpn_evpn is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_l2vpn_evpn() directly.\n\nYANG Description: BGP EVPN configuration options", "id": "f23427:c0:m48"}
{"signature": "def _get_ipv6_labeled_unicast(self):", "body": "return self.__ipv6_labeled_unicast<EOL>", "docstring": "Getter method for ipv6_labeled_unicast, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv6_labeled_unicast (container)\n\nYANG Description: IPv6 Labeled Unicast configuration options", "id": "f23427:c1:m29"}
{"signature": "def _get_l3vpn_ipv4_multicast(self):", "body": "return self.__l3vpn_ipv4_multicast<EOL>", "docstring": "Getter method for l3vpn_ipv4_multicast, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv4_multicast (container)\n\nYANG Description: Multicast IPv4 L3VPN configuration options", "id": "f23427:c1:m38"}
{"signature": "def _get_l3vpn_ipv6_multicast(self):", "body": "return self.__l3vpn_ipv6_multicast<EOL>", "docstring": "Getter method for l3vpn_ipv6_multicast, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv6_multicast (container)\n\nYANG Description: Multicast IPv6 L3VPN configuration options", "id": "f23427:c1:m41"}
{"signature": "def _set_l3vpn_ipv4_multicast(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=l3vpn_ipv4_multicast.l3vpn_ipv4_multicast,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__l3vpn_ipv4_multicast = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for l3vpn_ipv4_multicast, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv4_multicast (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_l3vpn_ipv4_multicast is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_l3vpn_ipv4_multicast() directly.\n\nYANG Description: Multicast IPv4 L3VPN configuration options", "id": "f23427:c0:m39"}
{"signature": "def _set_route_selection_options(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=route_selection_options.route_selection_options,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__route_selection_options = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for route_selection_options, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/route_selection_options (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_route_selection_options is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_route_selection_options() directly.\n\nYANG Description: Parameters relating to options for route selection", "id": "f23427:c1:m15"}
{"signature": "def _get_l2vpn_vpls(self):", "body": "return self.__l2vpn_vpls<EOL>", "docstring": "Getter method for l2vpn_vpls, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l2vpn_vpls (container)\n\nYANG Description: BGP-signalled VPLS configuration options", "id": "f23427:c1:m44"}
{"signature": "def _set_afi_safi_name(self, v, load=False):", "body": "parent = getattr(self, \"<STR_LIT>\", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError(<EOL>\"<STR_LIT>\" + \"<STR_LIT>\"<EOL>)<EOL><DEDENT>if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=six.text_type,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>is_keyval=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__afi_safi_name = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for afi_safi_name, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/afi_safi_name (leafref)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_afi_safi_name is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_afi_safi_name() directly.\n\n    YANG Description: Reference to the AFI-SAFI name used as a key\nfor the AFI-SAFI list", "id": "f23427:c1:m3"}
{"signature": "def _get_l3vpn_ipv4_unicast(self):", "body": "return self.__l3vpn_ipv4_unicast<EOL>", "docstring": "Getter method for l3vpn_ipv4_unicast, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv4_unicast (container)\n\nYANG Description: Unicast IPv4 L3VPN configuration options", "id": "f23427:c0:m32"}
{"signature": "def _set_graceful_restart(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=graceful_restart.graceful_restart,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__graceful_restart = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for graceful_restart, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/graceful_restart (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_graceful_restart is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_graceful_restart() directly.\n\nYANG Description: Parameters relating to BGP graceful-restart", "id": "f23427:c1:m12"}
{"signature": "def _get_prefix_limit(self):", "body": "return self.__prefix_limit<EOL>", "docstring": "Getter method for prefix_limit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv6_unicast/prefix_limit (container)\n\n    YANG Description: Configure the maximum number of prefixes that will be\naccepted from a peer", "id": "f23428:c1:m2"}
{"signature": "def _get_shutdown_threshold_pct(self):", "body": "return self.__shutdown_threshold_pct<EOL>", "docstring": "Getter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv6_unicast/prefix_limit/state/shutdown_threshold_pct (oc-types:percentage)\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23429:c0:m8"}
{"signature": "def _get_restart_timer(self):", "body": "return self.__restart_timer<EOL>", "docstring": "Getter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv6_unicast/prefix_limit/state/restart_timer (decimal64)\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23429:c1:m11"}
{"signature": "def _get_restart_timer(self):", "body": "return self.__restart_timer<EOL>", "docstring": "Getter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv6_unicast/prefix_limit/state/restart_timer (decimal64)\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23429:c0:m11"}
{"signature": "def _get_prevent_teardown(self):", "body": "return self.__prevent_teardown<EOL>", "docstring": "Getter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv6_unicast/prefix_limit/state/prevent_teardown (boolean)\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23429:c1:m5"}
{"signature": "def _set_restart_timer(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__restart_timer = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv6_unicast/prefix_limit/state/restart_timer (decimal64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_restart_timer is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_restart_timer() directly.\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23429:c1:m12"}
{"signature": "def _set_shutdown_threshold_pct(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__shutdown_threshold_pct = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv6_unicast/prefix_limit/config/shutdown_threshold_pct (oc-types:percentage)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_shutdown_threshold_pct is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_shutdown_threshold_pct() directly.\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23430:c0:m9"}
{"signature": "def _get_prevent_teardown(self):", "body": "return self.__prevent_teardown<EOL>", "docstring": "Getter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv6_unicast/prefix_limit/config/prevent_teardown (boolean)\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23430:c0:m5"}
{"signature": "def _set_prevent_teardown(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prevent_teardown = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv6_unicast/prefix_limit/config/prevent_teardown (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prevent_teardown is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prevent_teardown() directly.\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23430:c0:m6"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv6_unicast/prefix_limit/config (container)\n\n    YANG Description: Configuration parameters relating to the prefix\nlimit for the AFI-SAFI", "id": "f23431:c0:m2"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv6_unicast/prefix_limit/config (container)\n\n    YANG Description: Configuration parameters relating to the prefix\nlimit for the AFI-SAFI", "id": "f23431:c1:m2"}
{"signature": "def _set_max_prefixes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__max_prefixes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv6_multicast/prefix_limit/state/max_prefixes (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_max_prefixes is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_max_prefixes() directly.\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23433:c1:m3"}
{"signature": "def _get_prevent_teardown(self):", "body": "return self.__prevent_teardown<EOL>", "docstring": "Getter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv6_multicast/prefix_limit/state/prevent_teardown (boolean)\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23433:c0:m5"}
{"signature": "def _get_max_prefixes(self):", "body": "return self.__max_prefixes<EOL>", "docstring": "Getter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv6_multicast/prefix_limit/state/max_prefixes (uint32)\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23433:c0:m2"}
{"signature": "def _get_restart_timer(self):", "body": "return self.__restart_timer<EOL>", "docstring": "Getter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv6_multicast/prefix_limit/state/restart_timer (decimal64)\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23433:c0:m11"}
{"signature": "def _get_prevent_teardown(self):", "body": "return self.__prevent_teardown<EOL>", "docstring": "Getter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv6_multicast/prefix_limit/config/prevent_teardown (boolean)\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23434:c1:m5"}
{"signature": "def _get_max_prefixes(self):", "body": "return self.__max_prefixes<EOL>", "docstring": "Getter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv6_multicast/prefix_limit/config/max_prefixes (uint32)\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23434:c1:m2"}
{"signature": "def _get_shutdown_threshold_pct(self):", "body": "return self.__shutdown_threshold_pct<EOL>", "docstring": "Getter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv6_multicast/prefix_limit/config/shutdown_threshold_pct (oc-types:percentage)\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23434:c1:m8"}
{"signature": "def _set_max_prefixes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__max_prefixes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv6_multicast/prefix_limit/config/max_prefixes (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_max_prefixes is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_max_prefixes() directly.\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23434:c1:m3"}
{"signature": "def _set_prefix_limit(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=prefix_limit.prefix_limit,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prefix_limit = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prefix_limit, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv4_unicast/prefix_limit (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prefix_limit is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prefix_limit() directly.\n\n    YANG Description: Configure the maximum number of prefixes that will be\naccepted from a peer", "id": "f23436:c1:m3"}
{"signature": "def _set_shutdown_threshold_pct(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__shutdown_threshold_pct = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv4_unicast/prefix_limit/state/shutdown_threshold_pct (oc-types:percentage)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_shutdown_threshold_pct is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_shutdown_threshold_pct() directly.\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23437:c1:m9"}
{"signature": "def _get_max_prefixes(self):", "body": "return self.__max_prefixes<EOL>", "docstring": "Getter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv4_unicast/prefix_limit/state/max_prefixes (uint32)\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23437:c0:m2"}
{"signature": "def _set_shutdown_threshold_pct(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__shutdown_threshold_pct = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv4_unicast/prefix_limit/state/shutdown_threshold_pct (oc-types:percentage)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_shutdown_threshold_pct is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_shutdown_threshold_pct() directly.\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23437:c0:m9"}
{"signature": "def _set_prevent_teardown(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prevent_teardown = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv4_unicast/prefix_limit/state/prevent_teardown (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prevent_teardown is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prevent_teardown() directly.\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23437:c1:m6"}
{"signature": "def _get_prevent_teardown(self):", "body": "return self.__prevent_teardown<EOL>", "docstring": "Getter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv4_unicast/prefix_limit/state/prevent_teardown (boolean)\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23437:c1:m5"}
{"signature": "def _get_restart_timer(self):", "body": "return self.__restart_timer<EOL>", "docstring": "Getter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv4_unicast/prefix_limit/state/restart_timer (decimal64)\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23437:c0:m11"}
{"signature": "def _set_prevent_teardown(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prevent_teardown = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv4_unicast/prefix_limit/state/prevent_teardown (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prevent_teardown is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prevent_teardown() directly.\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23437:c0:m6"}
{"signature": "def _set_max_prefixes(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__max_prefixes = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv4_unicast/prefix_limit/config/max_prefixes (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_max_prefixes is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_max_prefixes() directly.\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23438:c1:m3"}
{"signature": "def _get_prevent_teardown(self):", "body": "return self.__prevent_teardown<EOL>", "docstring": "Getter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv4_unicast/prefix_limit/config/prevent_teardown (boolean)\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23438:c1:m5"}
{"signature": "def _get_max_prefixes(self):", "body": "return self.__max_prefixes<EOL>", "docstring": "Getter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv4_unicast/prefix_limit/config/max_prefixes (uint32)\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23438:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv4_unicast/prefix_limit/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: State information relating to the prefix-limit for the\nAFI-SAFI", "id": "f23439:c1:m6"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv4_unicast/prefix_limit/config (container)\n\n    YANG Description: Configuration parameters relating to the prefix\nlimit for the AFI-SAFI", "id": "f23439:c0:m2"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/l3vpn_ipv4_unicast/prefix_limit/config (container)\n\n    YANG Description: Configuration parameters relating to the prefix\nlimit for the AFI-SAFI", "id": "f23439:c1:m2"}
{"signature": "def _get_send_default_route(self):", "body": "return self.__send_default_route<EOL>", "docstring": "Getter method for send_default_route, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv4_unicast/state/send_default_route (boolean)\n\nYANG Description: If set to true, send the default-route to the neighbour(s)", "id": "f23440:c0:m2"}
{"signature": "def _get_send_default_route(self):", "body": "return self.__send_default_route<EOL>", "docstring": "Getter method for send_default_route, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv4_unicast/config/send_default_route (boolean)\n\nYANG Description: If set to true, send the default-route to the neighbour(s)", "id": "f23441:c1:m2"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv4_unicast/config (container)\n\n    YANG Description: Configuration parameters for common IPv4 and IPv6 unicast\nAFI-SAFI options", "id": "f23442:c1:m5"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv4_unicast/state (container)\n\n    YANG Description: State information for common IPv4 and IPv6 unicast\nparameters", "id": "f23442:c1:m8"}
{"signature": "def _get_max_prefixes(self):", "body": "return self.__max_prefixes<EOL>", "docstring": "Getter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv4_unicast/prefix_limit/state/max_prefixes (uint32)\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23443:c1:m2"}
{"signature": "def _set_prevent_teardown(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prevent_teardown = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv4_unicast/prefix_limit/state/prevent_teardown (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prevent_teardown is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prevent_teardown() directly.\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23443:c0:m6"}
{"signature": "def _set_restart_timer(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__restart_timer = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv4_unicast/prefix_limit/state/restart_timer (decimal64)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_restart_timer is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_restart_timer() directly.\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23443:c1:m12"}
{"signature": "def _get_prevent_teardown(self):", "body": "return self.__prevent_teardown<EOL>", "docstring": "Getter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv4_unicast/prefix_limit/state/prevent_teardown (boolean)\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23443:c0:m5"}
{"signature": "def _set_shutdown_threshold_pct(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__shutdown_threshold_pct = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv4_unicast/prefix_limit/state/shutdown_threshold_pct (oc-types:percentage)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_shutdown_threshold_pct is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_shutdown_threshold_pct() directly.\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23443:c0:m9"}
{"signature": "def _get_restart_timer(self):", "body": "return self.__restart_timer<EOL>", "docstring": "Getter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv4_unicast/prefix_limit/state/restart_timer (decimal64)\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23443:c1:m11"}
{"signature": "def _set_shutdown_threshold_pct(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__shutdown_threshold_pct = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv4_unicast/prefix_limit/config/shutdown_threshold_pct (oc-types:percentage)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_shutdown_threshold_pct is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_shutdown_threshold_pct() directly.\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23444:c0:m9"}
{"signature": "def _get_shutdown_threshold_pct(self):", "body": "return self.__shutdown_threshold_pct<EOL>", "docstring": "Getter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv4_unicast/prefix_limit/config/shutdown_threshold_pct (oc-types:percentage)\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23444:c1:m8"}
{"signature": "def _get_max_prefixes(self):", "body": "return self.__max_prefixes<EOL>", "docstring": "Getter method for max_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv4_unicast/prefix_limit/config/max_prefixes (uint32)\n\n    YANG Description: Maximum number of prefixes that will be accepted\nfrom the neighbour", "id": "f23444:c0:m2"}
{"signature": "def _get_shutdown_threshold_pct(self):", "body": "return self.__shutdown_threshold_pct<EOL>", "docstring": "Getter method for shutdown_threshold_pct, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv4_unicast/prefix_limit/config/shutdown_threshold_pct (oc-types:percentage)\n\n    YANG Description: Threshold on number of prefixes that can be received\nfrom a neighbour before generation of warning messages\nor log entries. Expressed as a percentage of\nmax-prefixes", "id": "f23444:c0:m8"}
{"signature": "def _get_prevent_teardown(self):", "body": "return self.__prevent_teardown<EOL>", "docstring": "Getter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv4_unicast/prefix_limit/config/prevent_teardown (boolean)\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23444:c1:m5"}
{"signature": "def _get_restart_timer(self):", "body": "return self.__restart_timer<EOL>", "docstring": "Getter method for restart_timer, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv4_unicast/prefix_limit/config/restart_timer (decimal64)\n\n    YANG Description: Time interval in seconds after which the BGP session\nis re-established after being torn down due to exceeding\nthe max-prefix limit.", "id": "f23444:c0:m11"}
{"signature": "def _set_prevent_teardown(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__prevent_teardown = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for prevent_teardown, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv4_unicast/prefix_limit/config/prevent_teardown (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_prevent_teardown is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_prevent_teardown() directly.\n\n    YANG Description: Do not tear down the BGP session when the maximum\nprefix limit is exceeded, but rather only log a\nwarning. The default of this leaf is false, such\nthat when it is not specified, the session is torn\ndown.", "id": "f23444:c0:m6"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv4_unicast/prefix_limit/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: State information relating to the prefix-limit for the\nAFI-SAFI", "id": "f23445:c0:m6"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis/afi_safi/ipv4_unicast/prefix_limit/state (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_state is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_state() directly.\n\n    YANG Description: State information relating to the prefix-limit for the\nAFI-SAFI", "id": "f23445:c1:m6"}
{"signature": "def _set_ignore_next_hop_igp_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ignore_next_hop_igp_metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ignore_next_hop_igp_metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/route_selection_options/state/ignore_next_hop_igp_metric (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_ignore_next_hop_igp_metric is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_ignore_next_hop_igp_metric() directly.\n\n    YANG Description: Ignore the IGP metric to the next-hop when calculating\nBGP best-path. The default is to select the route for\nwhich the metric to the next-hop is lowest", "id": "f23446:c0:m18"}
{"signature": "def _set_external_compare_router_id(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:true>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__external_compare_router_id = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for external_compare_router_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/route_selection_options/state/external_compare_router_id (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_external_compare_router_id is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_external_compare_router_id() directly.\n\n    YANG Description: When comparing similar routes received from external\nBGP peers, use the router-id as a criterion to select\nthe active path.", "id": "f23446:c0:m9"}
{"signature": "def _get_ignore_next_hop_igp_metric(self):", "body": "return self.__ignore_next_hop_igp_metric<EOL>", "docstring": "Getter method for ignore_next_hop_igp_metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/route_selection_options/state/ignore_next_hop_igp_metric (boolean)\n\n    YANG Description: Ignore the IGP metric to the next-hop when calculating\nBGP best-path. The default is to select the route for\nwhich the metric to the next-hop is lowest", "id": "f23446:c1:m17"}
{"signature": "def _set_always_compare_med(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__always_compare_med = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for always_compare_med, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/route_selection_options/state/always_compare_med (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_always_compare_med is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_always_compare_med() directly.\n\n    YANG Description: Compare multi-exit discriminator (MED) value from\ndifferent ASes when selecting the best route.  The\ndefault behavior is to only compare MEDs for paths\nreceived from the same AS.", "id": "f23446:c1:m3"}
{"signature": "def _get_advertise_inactive_routes(self):", "body": "return self.__advertise_inactive_routes<EOL>", "docstring": "Getter method for advertise_inactive_routes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/route_selection_options/state/advertise_inactive_routes (boolean)\n\n    YANG Description: Advertise inactive routes to external peers.  The\ndefault is to only advertise active routes.", "id": "f23446:c1:m11"}
{"signature": "def _set_ignore_as_path_length(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ignore_as_path_length = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ignore_as_path_length, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/route_selection_options/config/ignore_as_path_length (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_ignore_as_path_length is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_ignore_as_path_length() directly.\n\n    YANG Description: Ignore the AS path length when selecting the best path.\nThe default is to use the AS path length and prefer paths\nwith shorter length.", "id": "f23447:c0:m6"}
{"signature": "def _set_always_compare_med(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__always_compare_med = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for always_compare_med, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/route_selection_options/config/always_compare_med (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_always_compare_med is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_always_compare_med() directly.\n\n    YANG Description: Compare multi-exit discriminator (MED) value from\ndifferent ASes when selecting the best route.  The\ndefault behavior is to only compare MEDs for paths\nreceived from the same AS.", "id": "f23447:c0:m3"}
{"signature": "def _get_ignore_as_path_length(self):", "body": "return self.__ignore_as_path_length<EOL>", "docstring": "Getter method for ignore_as_path_length, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/route_selection_options/config/ignore_as_path_length (boolean)\n\n    YANG Description: Ignore the AS path length when selecting the best path.\nThe default is to use the AS path length and prefer paths\nwith shorter length.", "id": "f23447:c0:m5"}
{"signature": "def _set_enable_aigp(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enable_aigp = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enable_aigp, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/route_selection_options/config/enable_aigp (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enable_aigp is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enable_aigp() directly.\n\n    YANG Description: Flag to enable sending / receiving accumulated IGP\nattribute in routing updates", "id": "f23447:c1:m15"}
{"signature": "def _get_external_compare_router_id(self):", "body": "return self.__external_compare_router_id<EOL>", "docstring": "Getter method for external_compare_router_id, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/route_selection_options/config/external_compare_router_id (boolean)\n\n    YANG Description: When comparing similar routes received from external\nBGP peers, use the router-id as a criterion to select\nthe active path.", "id": "f23447:c1:m8"}
{"signature": "def _set_ignore_next_hop_igp_metric(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ignore_next_hop_igp_metric = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ignore_next_hop_igp_metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/route_selection_options/config/ignore_next_hop_igp_metric (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_ignore_next_hop_igp_metric is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_ignore_next_hop_igp_metric() directly.\n\n    YANG Description: Ignore the IGP metric to the next-hop when calculating\nBGP best-path. The default is to select the route for\nwhich the metric to the next-hop is lowest", "id": "f23447:c1:m18"}
{"signature": "def _get_ignore_next_hop_igp_metric(self):", "body": "return self.__ignore_next_hop_igp_metric<EOL>", "docstring": "Getter method for ignore_next_hop_igp_metric, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/route_selection_options/config/ignore_next_hop_igp_metric (boolean)\n\n    YANG Description: Ignore the IGP metric to the next-hop when calculating\nBGP best-path. The default is to select the route for\nwhich the metric to the next-hop is lowest", "id": "f23447:c1:m17"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/route_selection_options/config (container)\n\n    YANG Description: Configuration parameters relating to route selection\noptions", "id": "f23448:c1:m2"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/route_selection_options/config (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_config is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_config() directly.\n\n    YANG Description: Configuration parameters relating to route selection\noptions", "id": "f23448:c0:m3"}
{"signature": "def _set_external_route_distance(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__external_route_distance = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for external_route_distance, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/default_route_distance/state/external_route_distance (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_external_route_distance is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_external_route_distance() directly.\n\n    YANG Description: Administrative distance for routes learned from external\nBGP (eBGP).", "id": "f23449:c1:m3"}
{"signature": "def _set_internal_route_distance(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:8>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__internal_route_distance = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for internal_route_distance, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/default_route_distance/config/internal_route_distance (uint8)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_internal_route_distance is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_internal_route_distance() directly.\n\n    YANG Description: Administrative distance for routes learned from internal\nBGP (iBGP).", "id": "f23450:c1:m6"}
{"signature": "def _get_internal_route_distance(self):", "body": "return self.__internal_route_distance<EOL>", "docstring": "Getter method for internal_route_distance, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/default_route_distance/config/internal_route_distance (uint8)\n\n    YANG Description: Administrative distance for routes learned from internal\nBGP (iBGP).", "id": "f23450:c0:m5"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/default_route_distance/config (container)\n\n    YANG Description: Configuration parameters relating to the default route\ndistance", "id": "f23451:c1:m2"}
{"signature": "def _get_as_(self):", "body": "return self.__as_<EOL>", "docstring": "Getter method for as_, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/config/as (oc-inet:as-number)\n\n    YANG Description: Local autonomous system number of the router.  Uses\nthe 32-bit as-number type from the model in RFC 6991.", "id": "f23452:c1:m2"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/use_multiple_paths/state/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: Whether the use of multiple paths for the same NLRI is\nenabled for the neighbor. This value is overridden by\nany more specific configuration value.", "id": "f23453:c0:m3"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/use_multiple_paths/config/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: Whether the use of multiple paths for the same NLRI is\nenabled for the neighbor. This value is overridden by\nany more specific configuration value.", "id": "f23454:c1:m3"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/use_multiple_paths/config (container)\n\nYANG Description: Configuration parameters relating to multipath", "id": "f23455:c0:m2"}
{"signature": "def _get_ebgp(self):", "body": "return self.__ebgp<EOL>", "docstring": "Getter method for ebgp, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/use_multiple_paths/ebgp (container)\n\nYANG Description: Multipath parameters for eBGP", "id": "f23455:c0:m8"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/use_multiple_paths/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration parameters relating to multipath", "id": "f23455:c1:m3"}
{"signature": "def _set_ibgp(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=ibgp.ibgp,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ibgp = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ibgp, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/use_multiple_paths/ibgp (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ibgp is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ibgp() directly.\n\nYANG Description: Multipath parameters for iBGP", "id": "f23455:c1:m12"}
{"signature": "def _set_ebgp(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=ebgp.ebgp,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__ebgp = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for ebgp, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/use_multiple_paths/ebgp (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_ebgp is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_ebgp() directly.\n\nYANG Description: Multipath parameters for eBGP", "id": "f23455:c0:m9"}
{"signature": "def _set_maximum_paths(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>),<EOL>default=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>)(<EOL><NUM_LIT:1><EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__maximum_paths = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for maximum_paths, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/use_multiple_paths/ibgp/state/maximum_paths (uint32)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_maximum_paths is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_maximum_paths() directly.\n\n    YANG Description: Maximum number of parallel paths to consider when using\niBGP multipath. The default is to use a single path", "id": "f23456:c1:m3"}
{"signature": "def _get_maximum_paths(self):", "body": "return self.__maximum_paths<EOL>", "docstring": "Getter method for maximum_paths, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/use_multiple_paths/ibgp/config/maximum_paths (uint32)\n\n    YANG Description: Maximum number of parallel paths to consider when using\niBGP multipath. The default is to use a single path", "id": "f23457:c1:m2"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/use_multiple_paths/ibgp/config (container)\n\nYANG Description: Configuration parameters relating to iBGP multipath", "id": "f23458:c1:m2"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/use_multiple_paths/ibgp/config (container)\n\nYANG Description: Configuration parameters relating to iBGP multipath", "id": "f23458:c0:m2"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/use_multiple_paths/ibgp/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State information relating to iBGP multipath", "id": "f23458:c0:m6"}
{"signature": "def _set_config(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=config.config,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__config = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/use_multiple_paths/ibgp/config (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_config is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_config() directly.\n\nYANG Description: Configuration parameters relating to iBGP multipath", "id": "f23458:c1:m3"}
{"signature": "def _get_allow_multiple_as(self):", "body": "return self.__allow_multiple_as<EOL>", "docstring": "Getter method for allow_multiple_as, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/use_multiple_paths/ebgp/state/allow_multiple_as (boolean)\n\n    YANG Description: Allow multipath to use paths from different neighbouring\nASes.  The default is to only consider multiple paths from\nthe same neighbouring AS.", "id": "f23459:c1:m2"}
{"signature": "def _set_allow_multiple_as(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>default=YANGBool(\"<STR_LIT:false>\"),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__allow_multiple_as = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for allow_multiple_as, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/use_multiple_paths/ebgp/state/allow_multiple_as (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_allow_multiple_as is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_allow_multiple_as() directly.\n\n    YANG Description: Allow multipath to use paths from different neighbouring\nASes.  The default is to only consider multiple paths from\nthe same neighbouring AS.", "id": "f23459:c1:m3"}
{"signature": "def _get_config(self):", "body": "return self.__config<EOL>", "docstring": "Getter method for config, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/use_multiple_paths/ebgp/config (container)\n\nYANG Description: Configuration parameters relating to eBGP multipath", "id": "f23461:c1:m2"}
{"signature": "def _set_route_selection_options(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=route_selection_options.route_selection_options,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__route_selection_options = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for route_selection_options, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/route_selection_options (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_route_selection_options is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_route_selection_options() directly.\n\nYANG Description: Parameters relating to options for route selection", "id": "f23462:c1:m21"}
{"signature": "def _set_confederation(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=confederation.confederation,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__confederation = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for confederation, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/confederation (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_confederation is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_confederation() directly.\n\n    YANG Description: Parameters indicating whether the local system acts as part\nof a BGP confederation", "id": "f23462:c1:m12"}
{"signature": "def _set_use_multiple_paths(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=use_multiple_paths.use_multiple_paths,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__use_multiple_paths = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for use_multiple_paths, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/use_multiple_paths (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_use_multiple_paths is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_use_multiple_paths() directly.\n\n    YANG Description: Parameters related to the use of multiple paths for the\nsame NLRI", "id": "f23462:c1:m18"}
{"signature": "def _set_graceful_restart(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=graceful_restart.graceful_restart,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__graceful_restart = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for graceful_restart, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/graceful_restart (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_graceful_restart is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_graceful_restart() directly.\n\nYANG Description: Parameters relating the graceful restart mechanism for BGP", "id": "f23462:c0:m15"}
{"signature": "def _get_use_multiple_paths(self):", "body": "return self.__use_multiple_paths<EOL>", "docstring": "Getter method for use_multiple_paths, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/use_multiple_paths (container)\n\n    YANG Description: Parameters related to the use of multiple paths for the\nsame NLRI", "id": "f23462:c0:m17"}
{"signature": "def _set_graceful_restart(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=graceful_restart.graceful_restart,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__graceful_restart = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for graceful_restart, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/graceful_restart (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_graceful_restart is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_graceful_restart() directly.\n\nYANG Description: Parameters relating the graceful restart mechanism for BGP", "id": "f23462:c1:m15"}
{"signature": "def _set_use_multiple_paths(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=use_multiple_paths.use_multiple_paths,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__use_multiple_paths = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for use_multiple_paths, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/use_multiple_paths (container)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_use_multiple_paths is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_use_multiple_paths() directly.\n\n    YANG Description: Parameters related to the use of multiple paths for the\nsame NLRI", "id": "f23462:c0:m18"}
{"signature": "def _set_afi_safis(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=afi_safis.afi_safis,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__afi_safis = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for afi_safis, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/afi_safis (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_afi_safis is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_afi_safis() directly.\n\nYANG Description: Address family specific configuration", "id": "f23462:c1:m24"}
{"signature": "def _get_dynamic_neighbor_prefixes(self):", "body": "return self.__dynamic_neighbor_prefixes<EOL>", "docstring": "Getter method for dynamic_neighbor_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/dynamic_neighbor_prefixes (container)\n\n    YANG Description: A list of IP prefixes from which the system should:\n - Accept connections to the BGP daemon\n - Dynamically configure a BGP neighbor corresponding to the\n   source address of the remote system, using the parameters\n   of the specified peer-group.\nFor such neighbors, an entry within the neighbor list should\nbe created, indicating that the peer was dynamically\nconfigured, and referencing the peer-group from which the\nconfiguration was derived.", "id": "f23462:c0:m26"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State information relating to the global BGP router", "id": "f23462:c1:m6"}
{"signature": "def _get_dynamic_neighbor_prefixes(self):", "body": "return self.__dynamic_neighbor_prefixes<EOL>", "docstring": "Getter method for dynamic_neighbor_prefixes, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/dynamic_neighbor_prefixes (container)\n\n    YANG Description: A list of IP prefixes from which the system should:\n - Accept connections to the BGP daemon\n - Dynamically configure a BGP neighbor corresponding to the\n   source address of the remote system, using the parameters\n   of the specified peer-group.\nFor such neighbors, an entry within the neighbor list should\nbe created, indicating that the peer was dynamically\nconfigured, and referencing the peer-group from which the\nconfiguration was derived.", "id": "f23462:c1:m26"}
{"signature": "def _get_graceful_restart(self):", "body": "return self.__graceful_restart<EOL>", "docstring": "Getter method for graceful_restart, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/graceful_restart (container)\n\nYANG Description: Parameters relating the graceful restart mechanism for BGP", "id": "f23462:c0:m14"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=False,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/confederation/state/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: When this leaf is set to true it indicates that\nthe local-AS is part of a BGP confederation", "id": "f23463:c0:m3"}
{"signature": "def _get_enabled(self):", "body": "return self.__enabled<EOL>", "docstring": "Getter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/confederation/state/enabled (boolean)\n\n    YANG Description: When this leaf is set to true it indicates that\nthe local-AS is part of a BGP confederation", "id": "f23463:c1:m2"}
{"signature": "def _set_enabled(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGBool,<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__enabled = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for enabled, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/confederation/config/enabled (boolean)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_enabled is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_enabled() directly.\n\n    YANG Description: When this leaf is set to true it indicates that\nthe local-AS is part of a BGP confederation", "id": "f23464:c0:m3"}
{"signature": "def _set_member_as(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=TypedListType(<EOL>allowed_type=RestrictedClassType(<EOL>base_type=long,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:32>,<EOL>)<EOL>),<EOL>is_leaf=False,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__member_as = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for member_as, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/confederation/config/member_as (oc-inet:as-number)\n    If this variable is read-only (config: false) in the\n    source YANG file, then _set_member_as is considered as a private\n    method. Backends looking to populate this variable should\n    do so via calling thisObj._set_member_as() directly.\n\n    YANG Description: Remote autonomous systems that are to be treated\nas part of the local confederation.", "id": "f23464:c1:m9"}
{"signature": "def _get_state(self):", "body": "return self.__state<EOL>", "docstring": "Getter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/confederation/state (container)\n\nYANG Description: State information relating to the BGP confederations", "id": "f23465:c0:m5"}
{"signature": "def _set_state(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=state.state,<EOL>is_container=\"<STR_LIT>\",<EOL>yang_name=\"<STR_LIT:state>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__state = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for state, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/global/confederation/state (container)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_state is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_state() directly.\n\nYANG Description: State information relating to the BGP confederations", "id": "f23465:c0:m6"}
{"signature": "def _set_network_instance(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT:name>\",<EOL>network_instance.network_instance,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT:name>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__network_instance = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for network_instance, mapped from YANG variable /network_instances/network_instance (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_network_instance is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_network_instance() directly.\n\nYANG Description: Network instances configured on the local system", "id": "f23467:c1:m3"}
{"signature": "def parse_state(self, device=None, profile=None, native=None, attrs=None):", "body": "if attrs is None:<EOL><INDENT>attrs = self.elements().values()<EOL><DEDENT>for v in attrs:<EOL><INDENT>parser = Parser(<EOL>v, device=device, profile=profile, native=native, is_config=False<EOL>)<EOL>parser.parse()<EOL><DEDENT>", "docstring": "Parse native state and load it into the corresponding models. Only models\nthat have been added to the root object will be parsed.\n\nIf ``native`` is passed to the method that's what we will parse, otherwise, we will use the\n``device`` to retrieve it.\n\nArgs:\n    device (NetworkDriver): Device to load the configuration from.\n    profile (list): Profiles that the device supports. If no ``profile`` is passed it will\n      be read from ``device``.\n    native (list string): Native output to parse.\n\nExamples:\n\n    >>> # Load from device\n    >>> state = napalm_yang.base.Root()\n    >>> state.add_model(napalm_yang.models.openconfig_interfaces)\n    >>> state.parse_config(device=d)\n\n    >>> # Load from file\n    >>> with open(\"junos.state\", \"r\") as f:\n    >>>     state_data = f.read()\n    >>>\n    >>> state = napalm_yang.base.Root()\n    >>> state.add_model(napalm_yang.models.openconfig_interfaces)\n    >>> state.parse_config(native=[state_data], profile=\"junos\")", "id": "f23469:c0:m9"}
{"signature": "def compliance_report(self, validation_file=\"<STR_LIT>\"):", "body": "return validate.compliance_report(self, validation_file=validation_file)<EOL>", "docstring": "Return a compliance report.\nVerify that the device complies with the given validation file and writes a compliance\nreport file. See https://napalm.readthedocs.io/en/latest/validate.html.", "id": "f23469:c0:m11"}
{"signature": "def add_model(self, model, force=False):", "body": "if isinstance(model, str):<EOL><INDENT>self._load_model(model)<EOL>return<EOL><DEDENT>try:<EOL><INDENT>model = model()<EOL><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT>if model._yang_name not in [a[<NUM_LIT:0>] for a in SUPPORTED_MODELS] and not force:<EOL><INDENT>raise ValueError(<EOL>\"<STR_LIT>\"<EOL>)<EOL><DEDENT>for k, v in model:<EOL><INDENT>self._elements[k] = v<EOL>setattr(self, k, v)<EOL><DEDENT>", "docstring": "Add a model.\n\nThe model will be asssigned to a class attribute with the YANG name of the model.\n\nArgs:\n    model (PybindBase): Model to add.\n    force (bool): If not set, verify the model is in SUPPORTED_MODELS\n\nExamples:\n\n    >>> import napalm_yang\n    >>> config = napalm_yang.base.Root()\n    >>> config.add_model(napalm_yang.models.openconfig_interfaces)\n    >>> config.interfaces\n    <pyangbind.lib.yangtypes.YANGBaseClass object at 0x10bef6680>", "id": "f23469:c0:m2"}
{"signature": "def get(self, filter=False):", "body": "result = {}<EOL>for k, v in self.elements().items():<EOL><INDENT>intermediate = v.get(filter=filter)<EOL>if intermediate:<EOL><INDENT>result[k] = intermediate<EOL><DEDENT><DEDENT>return result<EOL>", "docstring": "Returns a dictionary with the values of the model. Note that the values\nof the leafs are YANG classes.\n\nArgs:\n    filter (bool): If set to ``True``, show only values that have been set.\n\nReturns:\n    dict: A dictionary with the values of the model.\n\nExample:\n\n    >>> pretty_print(config.get(filter=True))\n    >>> {\n    >>>     \"interfaces\": {\n    >>>         \"interface\": {\n    >>>             \"et1\": {\n    >>>                 \"config\": {\n    >>>                     \"description\": \"My description\",\n    >>>                     \"mtu\": 1500\n    >>>                 },\n    >>>                 \"name\": \"et1\"\n    >>>             },\n    >>>             \"et2\": {\n    >>>                 \"config\": {\n    >>>                     \"description\": \"Another description\",\n    >>>                     \"mtu\": 9000\n    >>>                 },\n    >>>                 \"name\": \"et2\"\n    >>>             }\n    >>>         }\n    >>>     }\n    >>> }", "id": "f23469:c0:m3"}
{"signature": "@check_empty()<EOL>def netmask_to_cidr(value):", "body": "return netaddr.IPAddress(value).netmask_bits()<EOL>", "docstring": "Converts a network mask to it's CIDR value.\n\nExamples:\n    >>> \"{{ '255.255.255.0'|netmask_to_cidr }}\" -> \"24\"", "id": "f23472:m1"}
{"signature": "@check_empty()<EOL>def prefix_to_addrmask(value, sep=\"<STR_LIT:U+0020>\"):", "body": "prefix = netaddr.IPNetwork(value)<EOL>return \"<STR_LIT>\".format(prefix.ip, sep, prefix.netmask)<EOL>", "docstring": "Converts a CIDR formatted prefix into an address netmask representation.\nArgument sep specifies the separator between the address and netmask parts.\nBy default it's a single space.\n\nExamples:\n    >>> \"{{ '192.168.0.1/24|prefix_to_addrmask }}\" -> \"192.168.0.1 255.255.255.0\"\n    >>> \"{{ '192.168.0.1/24|prefix_to_addrmask('/') }}\" -> \"192.168.0.1/255.255.255.0\"", "id": "f23472:m5"}
{"signature": "def find_yang_file(profile, filename, path):", "body": "<EOL>module_dir = os.path.dirname(__file__)<EOL>full_path = os.path.join(module_dir, \"<STR_LIT>\", profile, path, filename)<EOL>if os.path.exists(full_path):<EOL><INDENT>return full_path<EOL><DEDENT>else:<EOL><INDENT>msg = \"<STR_LIT>\".format(full_path)<EOL>logger.error(msg)<EOL>raise IOError(msg)<EOL><DEDENT>", "docstring": "Find the necessary file for the given test case.\n\nArgs:\n    device(napalm device connection): for which device\n    filename(str): file to find\n    path(str): where to find it relative to where the module is installed", "id": "f23477:m2"}
{"signature": "def parse_indented_config(config, current_indent=<NUM_LIT:0>, previous_indent=<NUM_LIT:0>, nested=False):", "body": "parsed = OrderedDict()<EOL>while True:<EOL><INDENT>if not config:<EOL><INDENT>break<EOL><DEDENT>line = config.pop(<NUM_LIT:0>)<EOL>if line.lstrip().startswith(\"<STR_LIT:!>\"):<EOL><INDENT>continue<EOL><DEDENT>last = line.lstrip()<EOL>leading_spaces = len(line) - len(last)<EOL>if leading_spaces > current_indent:<EOL><INDENT>current = parse_indented_config(<EOL>config, leading_spaces, current_indent, True<EOL>)<EOL>_attach_data_to_path(parsed, last, current, nested)<EOL><DEDENT>elif leading_spaces < current_indent:<EOL><INDENT>config.insert(<NUM_LIT:0>, line)<EOL>break<EOL><DEDENT>else:<EOL><INDENT>if not nested:<EOL><INDENT>current = parse_indented_config(<EOL>config, leading_spaces, current_indent, True<EOL>)<EOL>_attach_data_to_path(parsed, last, current, nested)<EOL><DEDENT>else:<EOL><INDENT>config.insert(<NUM_LIT:0>, line)<EOL>break<EOL><DEDENT><DEDENT><DEDENT>return parsed<EOL>", "docstring": "This methid basically reads a configuration that conforms to a very poor industry standard\nand returns a nested structure that behaves like a dict. For example:\n    {'enable password whatever': {},\n     'interface GigabitEthernet1': {\n         'description \"bleh\"': {},\n         'fake nested': {\n             'nested nested configuration': {}},\n         'switchport mode trunk': {}},\n     'interface GigabitEthernet2': {\n         'no ip address': {}},\n     'interface GigabitEthernet3': {\n         'negotiation auto': {},\n         'no ip address': {},\n         'shutdown': {}},\n     'interface Loopback0': {\n         'description \"blah\"': {}}}", "id": "f23479:m1"}
{"signature": "def _get_universe(self):", "body": "return self.__universe<EOL>", "docstring": "Getter method for universe, mapped from YANG variable /universe (container)", "id": "f23491:c2:m2"}
{"signature": "def _set_status(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=unicode,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={u\"<STR_LIT>\": {}, u\"<STR_LIT>\": {}},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT:status>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__status = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for status, mapped from YANG variable /universe/individual/status (enumeration)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_status is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_status() directly.", "id": "f23491:c0:m12"}
{"signature": "def _set_individual(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=YANGListType(<EOL>\"<STR_LIT:name>\",<EOL>yc_individual_napalm_star_wars__universe_individual,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>is_container=\"<STR_LIT:list>\",<EOL>user_ordered=False,<EOL>path_helper=self._path_helper,<EOL>yang_keys=\"<STR_LIT:name>\",<EOL>extensions=None,<EOL>),<EOL>is_container=\"<STR_LIT:list>\",<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>extensions=None,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT:list>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT:list>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__individual = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for individual, mapped from YANG variable /universe/individual (list)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_individual is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_individual() directly.", "id": "f23491:c1:m3"}
{"signature": "def _set_affiliation(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=unicode,<EOL>restriction_type=\"<STR_LIT>\",<EOL>restriction_arg={<EOL>u\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": u\"<STR_LIT>\",<EOL>\"<STR_LIT>\": u\"<STR_LIT>\",<EOL>},<EOL>u\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": u\"<STR_LIT>\",<EOL>\"<STR_LIT>\": u\"<STR_LIT>\",<EOL>},<EOL>u\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": u\"<STR_LIT>\",<EOL>\"<STR_LIT>\": u\"<STR_LIT>\",<EOL>},<EOL>u\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": u\"<STR_LIT>\",<EOL>\"<STR_LIT>\": u\"<STR_LIT>\",<EOL>},<EOL>u\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": u\"<STR_LIT>\",<EOL>\"<STR_LIT>\": u\"<STR_LIT>\",<EOL>},<EOL>u\"<STR_LIT>\": {<EOL>\"<STR_LIT>\": u\"<STR_LIT>\",<EOL>\"<STR_LIT>\": u\"<STR_LIT>\",<EOL>},<EOL>},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__affiliation = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for affiliation, mapped from YANG variable /universe/individual/affiliation (identityref)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_affiliation is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_affiliation() directly.", "id": "f23491:c0:m9"}
{"signature": "def _set_age(self, v, load=False):", "body": "if hasattr(v, \"<STR_LIT>\"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(<EOL>v,<EOL>base=RestrictedClassType(<EOL>base_type=RestrictedClassType(<EOL>base_type=int,<EOL>restriction_dict={\"<STR_LIT>\": [\"<STR_LIT>\"]},<EOL>int_size=<NUM_LIT:16>,<EOL>),<EOL>restriction_dict={\"<STR_LIT>\": [u\"<STR_LIT>\"]},<EOL>),<EOL>is_leaf=True,<EOL>yang_name=\"<STR_LIT>\",<EOL>parent=self,<EOL>path_helper=self._path_helper,<EOL>extmethods=self._extmethods,<EOL>register_paths=True,<EOL>namespace=\"<STR_LIT>\",<EOL>defining_module=\"<STR_LIT>\",<EOL>yang_type=\"<STR_LIT>\",<EOL>is_config=True,<EOL>)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError(<EOL>{<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>\"<STR_LIT>\": \"<STR_LIT>\",<EOL>\"<STR_LIT>\": \"\"\"<STR_LIT>\"\"\",<EOL>}<EOL>)<EOL><DEDENT>self.__age = t<EOL>if hasattr(self, \"<STR_LIT>\"):<EOL><INDENT>self._set()<EOL><DEDENT>", "docstring": "Setter method for age, mapped from YANG variable /universe/individual/age (age)\nIf this variable is read-only (config: false) in the\nsource YANG file, then _set_age is considered as a private\nmethod. Backends looking to populate this variable should\ndo so via calling thisObj._set_age() directly.", "id": "f23492:c0:m6"}
{"signature": "def list(<EOL>self, location, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List cluster code versions by location.\n\n        List cluster code versions by location\n        .\n\n        :param location: The location for the cluster code versions, this is\n         different from cluster location\n        :type location: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ClusterCodeVersionsListResult or ClientRawResponse if\n         raw=true\n        :rtype: ~azure.mgmt.servicefabric.models.ClusterCodeVersionsListResult\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f23611:c0:m3"}
{"signature": "def get_by_environment(<EOL>self, location, environment, cluster_version, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_by_environment.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", environment, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", cluster_version, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get cluster code versions by environment.\n\n        Get cluster code versions by environment\n        .\n\n        :param location: The location for the cluster code versions, this is\n         different from cluster location\n        :type location: str\n        :param environment: Cluster operating system, the default means all.\n         Possible values include: 'Windows', 'Linux'\n        :type environment: str\n        :param cluster_version: The cluster code version\n        :type cluster_version: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ClusterCodeVersionsListResult or ClientRawResponse if\n         raw=true\n        :rtype: ~azure.mgmt.servicefabric.models.ClusterCodeVersionsListResult\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f23611:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, cluster_name, application_type_name, version, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", cluster_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", application_type_name, '<STR_LIT:str>'),<EOL>'<STR_LIT:version>': self._serialize.url(\"<STR_LIT:version>\", version, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorModelException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Returns an application type version resource.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param cluster_name: The name of the cluster resource\n        :type cluster_name: str\n        :param application_type_name: The name of the application type name\n         resource\n        :type application_type_name: str\n        :param version: The application type version.\n        :type version: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VersionResource or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.servicefabric.models.VersionResource or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorModelException<azure.mgmt.servicefabric.models.ErrorModelException>`", "id": "f23614:c0:m1"}
{"signature": "def get(<EOL>self, resource_group_name, cluster_name, application_type_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", cluster_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", application_type_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorModelException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Returns an application type name resource.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param cluster_name: The name of the cluster resource\n        :type cluster_name: str\n        :param application_type_name: The name of the application type name\n         resource\n        :type application_type_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ApplicationTypeResource or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.servicefabric.models.ApplicationTypeResource or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorModelException<azure.mgmt.servicefabric.models.ErrorModelException>`", "id": "f23615:c0:m1"}
{"signature": "def delete(<EOL>self, resource_group_name, cluster_name, application_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>cluster_name=cluster_name,<EOL>application_name=application_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes an application resource with the specified name.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param cluster_name: The name of the cluster resource\n        :type cluster_name: str\n        :param application_name: The name of the application resource.\n        :type application_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises:\n         :class:`ErrorModelException<azure.mgmt.servicefabric.models.ErrorModelException>`", "id": "f23616:c0:m7"}
{"signature": "def get(<EOL>self, resource_group_name, cluster_name, application_name, service_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", cluster_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", application_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", service_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorModelException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Returns a service resource with the specified name.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param cluster_name: The name of the cluster resource\n        :type cluster_name: str\n        :param application_name: The name of the application resource.\n        :type application_name: str\n        :param service_name: The name of the service resource in the format of\n         {applicationName}~{serviceName}.\n        :type service_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ServiceResource or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.servicefabric.models.ServiceResource or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorModelException<azure.mgmt.servicefabric.models.ErrorModelException>`", "id": "f23618:c0:m1"}
{"signature": "def list(<EOL>self, resource_group_name, cluster_name, application_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", cluster_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", application_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorModelException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Returns all service resources in the specified application.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param cluster_name: The name of the cluster resource\n        :type cluster_name: str\n        :param application_name: The name of the application resource.\n        :type application_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ServiceResourceList or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.servicefabric.models.ServiceResourceList or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorModelException<azure.mgmt.servicefabric.models.ErrorModelException>`", "id": "f23618:c0:m8"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ApiErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ImageTemplatePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ImageTemplatePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about the VM image templates associated with the\n        subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ImageTemplate\n        :rtype:\n         ~azure.mgmt.imagebuilder.models.ImageTemplatePaged[~azure.mgmt.imagebuilder.models.ImageTemplate]\n        :raises:\n         :class:`ApiErrorException<azure.mgmt.imagebuilder.models.ApiErrorException>`", "id": "f23685:c0:m1"}
{"signature": "def update(<EOL>self, resource_group_name, registry_name, registry_update_parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", registry_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:5>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(registry_update_parameters, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Updates a container registry with the specified parameters.\n\n        :param resource_group_name: The name of the resource group to which\n         the container registry belongs.\n        :type resource_group_name: str\n        :param registry_name: The name of the container registry.\n        :type registry_name: str\n        :param registry_update_parameters: The parameters for updating a\n         container registry.\n        :type registry_update_parameters:\n         ~azure.mgmt.containerregistry.v2017_03_01.models.RegistryUpdateParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Registry or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.containerregistry.v2017_03_01.models.Registry or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f23730:c0:m6"}
{"signature": "def get(<EOL>self, resource_group_name, registry_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", registry_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:5>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the properties of the specified container registry.\n\n        :param resource_group_name: The name of the resource group to which\n         the container registry belongs.\n        :type resource_group_name: str\n        :param registry_name: The name of the container registry.\n        :type registry_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Registry or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.containerregistry.v2017_03_01.models.Registry or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f23730:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, registry_name, replication_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", registry_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:5>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", replication_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:5>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the properties of the specified replication.\n\n        :param resource_group_name: The name of the resource group to which\n         the container registry belongs.\n        :type resource_group_name: str\n        :param registry_name: The name of the container registry.\n        :type registry_name: str\n        :param replication_name: The name of the replication.\n        :type replication_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Replication or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.containerregistry.v2017_10_01.models.Replication\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f23815:c0:m1"}
{"signature": "def update(<EOL>self, resource_group_name, registry_name, replication_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_initial(<EOL>resource_group_name=resource_group_name,<EOL>registry_name=registry_name,<EOL>replication_name=replication_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a replication for a container registry with the specified\n        parameters.\n\n        :param resource_group_name: The name of the resource group to which\n         the container registry belongs.\n        :type resource_group_name: str\n        :param registry_name: The name of the container registry.\n        :type registry_name: str\n        :param replication_name: The name of the replication.\n        :type replication_name: str\n        :param tags: The tags for the replication.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Replication or\n         ClientRawResponse<Replication> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.containerregistry.v2017_10_01.models.Replication]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.containerregistry.v2017_10_01.models.Replication]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f23815:c0:m7"}
{"signature": "def list(<EOL>self, resource_group_name, registry_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", registry_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:5>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ReplicationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ReplicationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all the replications for the specified container registry.\n\n        :param resource_group_name: The name of the resource group to which\n         the container registry belongs.\n        :type resource_group_name: str\n        :param registry_name: The name of the container registry.\n        :type registry_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Replication\n        :rtype:\n         ~azure.mgmt.containerregistry.v2017_10_01.models.ReplicationPaged[~azure.mgmt.containerregistry.v2017_10_01.models.Replication]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f23815:c0:m8"}
{"signature": "def update(<EOL>self, resource_group_name, registry_name, registry_update_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_initial(<EOL>resource_group_name=resource_group_name,<EOL>registry_name=registry_name,<EOL>registry_update_parameters=registry_update_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a container registry with the specified parameters.\n\n        :param resource_group_name: The name of the resource group to which\n         the container registry belongs.\n        :type resource_group_name: str\n        :param registry_name: The name of the container registry.\n        :type registry_name: str\n        :param registry_update_parameters: The parameters for updating a\n         container registry.\n        :type registry_update_parameters:\n         ~azure.mgmt.containerregistry.v2017_10_01.models.RegistryUpdateParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Registry or\n         ClientRawResponse<Registry> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.containerregistry.v2017_10_01.models.Registry]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.containerregistry.v2017_10_01.models.Registry]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f23817:c0:m10"}
{"signature": "def import_image(<EOL>self, resource_group_name, registry_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._import_image_initial(<EOL>resource_group_name=resource_group_name,<EOL>registry_name=registry_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Copies an image to this container registry from the specified container\n        registry.\n\n        :param resource_group_name: The name of the resource group to which\n         the container registry belongs.\n        :type resource_group_name: str\n        :param registry_name: The name of the container registry.\n        :type registry_name: str\n        :param parameters: The parameters specifying the image to copy and the\n         source container registry.\n        :type parameters:\n         ~azure.mgmt.containerregistry.v2017_10_01.models.ImportImageParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f23817:c0:m2"}
{"signature": "def create(<EOL>self, resource_group_name, registry_name, webhook_name, webhook_create_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_initial(<EOL>resource_group_name=resource_group_name,<EOL>registry_name=registry_name,<EOL>webhook_name=webhook_name,<EOL>webhook_create_parameters=webhook_create_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates a webhook for a container registry with the specified\n        parameters.\n\n        :param resource_group_name: The name of the resource group to which\n         the container registry belongs.\n        :type resource_group_name: str\n        :param registry_name: The name of the container registry.\n        :type registry_name: str\n        :param webhook_name: The name of the webhook.\n        :type webhook_name: str\n        :param webhook_create_parameters: The parameters for creating a\n         webhook.\n        :type webhook_create_parameters:\n         ~azure.mgmt.containerregistry.v2017_10_01.models.WebhookCreateParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Webhook or\n         ClientRawResponse<Webhook> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.containerregistry.v2017_10_01.models.Webhook]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.containerregistry.v2017_10_01.models.Webhook]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f23818:c0:m3"}
{"signature": "def list_events(<EOL>self, resource_group_name, registry_name, webhook_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_events.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", registry_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:5>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", webhook_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:5>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.EventPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.EventPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists recent events for the specified webhook.\n\n        :param resource_group_name: The name of the resource group to which\n         the container registry belongs.\n        :type resource_group_name: str\n        :param registry_name: The name of the container registry.\n        :type registry_name: str\n        :param webhook_name: The name of the webhook.\n        :type webhook_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Event\n        :rtype:\n         ~azure.mgmt.containerregistry.v2017_10_01.models.EventPaged[~azure.mgmt.containerregistry.v2017_10_01.models.Event]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f23818:c0:m11"}
{"signature": "def delete(<EOL>self, resource_group_name, registry_name, webhook_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>registry_name=registry_name,<EOL>webhook_name=webhook_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes a webhook from a container registry.\n\n        :param resource_group_name: The name of the resource group to which\n         the container registry belongs.\n        :type resource_group_name: str\n        :param registry_name: The name of the container registry.\n        :type registry_name: str\n        :param webhook_name: The name of the webhook.\n        :type webhook_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f23818:c0:m5"}
{"signature": "def list(<EOL>self, resource_group_name, registry_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", registry_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:5>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.WebhookPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.WebhookPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all the webhooks for the specified container registry.\n\n        :param resource_group_name: The name of the resource group to which\n         the container registry belongs.\n        :type resource_group_name: str\n        :param registry_name: The name of the container registry.\n        :type registry_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Webhook\n        :rtype:\n         ~azure.mgmt.containerregistry.v2017_10_01.models.WebhookPaged[~azure.mgmt.containerregistry.v2017_10_01.models.Webhook]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f23818:c0:m8"}
{"signature": "@property<EOL><INDENT>def tasks(self):<DEDENT>", "body": "api_version = self._get_api_version('<STR_LIT>')<EOL>if api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_09_01.operations import TasksOperations as OperationClass<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\".format(api_version))<EOL><DEDENT>return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))<EOL>", "docstring": "Instance depends on the API version:\n\n           * 2018-09-01: :class:`TasksOperations<azure.mgmt.containerregistry.v2018_09_01.operations.TasksOperations>`", "id": "f23819:c1:m10"}
{"signature": "@classmethod<EOL><INDENT>def models(cls, api_version=DEFAULT_API_VERSION):<DEDENT>", "body": "if api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_03_01 import models<EOL>return models<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_10_01 import models<EOL>return models<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_02_01_preview import models<EOL>return models<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_09_01 import models<EOL>return models<EOL><DEDENT>raise NotImplementedError(\"<STR_LIT>\".format(api_version))<EOL>", "docstring": "Module depends on the API version:\n\n           * 2017-03-01: :mod:`v2017_03_01.models<azure.mgmt.containerregistry.v2017_03_01.models>`\n           * 2017-10-01: :mod:`v2017_10_01.models<azure.mgmt.containerregistry.v2017_10_01.models>`\n           * 2018-02-01-preview: :mod:`v2018_02_01_preview.models<azure.mgmt.containerregistry.v2018_02_01_preview.models>`\n           * 2018-09-01: :mod:`v2018_09_01.models<azure.mgmt.containerregistry.v2018_09_01.models>`", "id": "f23819:c1:m2"}
{"signature": "def create(<EOL>self, resource_group_name, registry_name, replication_name, location, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_initial(<EOL>resource_group_name=resource_group_name,<EOL>registry_name=registry_name,<EOL>replication_name=replication_name,<EOL>location=location,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates a replication for a container registry with the specified\n        parameters.\n\n        :param resource_group_name: The name of the resource group to which\n         the container registry belongs.\n        :type resource_group_name: str\n        :param registry_name: The name of the container registry.\n        :type registry_name: str\n        :param replication_name: The name of the replication.\n        :type replication_name: str\n        :param location: The location of the resource. This cannot be changed\n         after the resource is created.\n        :type location: str\n        :param tags: The tags of the resource.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Replication or\n         ClientRawResponse<Replication> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.containerregistry.v2018_09_01.models.Replication]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.containerregistry.v2018_09_01.models.Replication]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f23971:c0:m3"}
{"signature": "def get(<EOL>self, resource_group_name, registry_name, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", registry_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:5>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the properties of the specified container registry.\n\n        :param resource_group_name: The name of the resource group to which\n         the container registry belongs.\n        :type resource_group_name: str\n        :param registry_name: The name of the container registry.\n        :type registry_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Registry or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.containerregistry.v2018_09_01.models.Registry or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f23973:c0:m4"}
{"signature": "def schedule_run(<EOL>self, resource_group_name, registry_name, run_request, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._schedule_run_initial(<EOL>resource_group_name=resource_group_name,<EOL>registry_name=registry_name,<EOL>run_request=run_request,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Schedules a new run based on the request parameters and add it to the\n        run queue.\n\n        :param resource_group_name: The name of the resource group to which\n         the container registry belongs.\n        :type resource_group_name: str\n        :param registry_name: The name of the container registry.\n        :type registry_name: str\n        :param run_request: The parameters of a run that needs to scheduled.\n        :type run_request:\n         ~azure.mgmt.containerregistry.v2018_09_01.models.RunRequest\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Run or\n         ClientRawResponse<Run> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.containerregistry.v2018_09_01.models.Run]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.containerregistry.v2018_09_01.models.Run]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f23973:c0:m20"}
{"signature": "def regenerate_credential(<EOL>self, resource_group_name, registry_name, name, custom_headers=None, raw=False, **operation_config):", "body": "regenerate_credential_parameters = models.RegenerateCredentialParameters(name=name)<EOL>api_version = \"<STR_LIT>\"<EOL>url = self.regenerate_credential.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", registry_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:5>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(regenerate_credential_parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Regenerates one of the login credentials for the specified container\n        registry.\n\n        :param resource_group_name: The name of the resource group to which\n         the container registry belongs.\n        :type resource_group_name: str\n        :param registry_name: The name of the container registry.\n        :type registry_name: str\n        :param name: Specifies name of the password which should be\n         regenerated -- password or password2. Possible values include:\n         'password', 'password2'\n        :type name: str or\n         ~azure.mgmt.containerregistry.v2018_09_01.models.PasswordName\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RegistryListCredentialsResult or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.containerregistry.v2018_09_01.models.RegistryListCredentialsResult\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f23973:c0:m14"}
{"signature": "def get_build_source_upload_url(<EOL>self, resource_group_name, registry_name, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get_build_source_upload_url.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", registry_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:5>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the upload location for the user to be able to upload the source.\n\n        :param resource_group_name: The name of the resource group to which\n         the container registry belongs.\n        :type resource_group_name: str\n        :param registry_name: The name of the container registry.\n        :type registry_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SourceUploadDefinition or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.containerregistry.v2018_09_01.models.SourceUploadDefinition\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f23973:c0:m21"}
{"signature": "def create(<EOL>self, resource_group_name, registry_name, task_name, task_create_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_initial(<EOL>resource_group_name=resource_group_name,<EOL>registry_name=registry_name,<EOL>task_name=task_name,<EOL>task_create_parameters=task_create_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates a task for a container registry with the specified parameters.\n\n        :param resource_group_name: The name of the resource group to which\n         the container registry belongs.\n        :type resource_group_name: str\n        :param registry_name: The name of the container registry.\n        :type registry_name: str\n        :param task_name: The name of the container registry task.\n        :type task_name: str\n        :param task_create_parameters: The parameters for creating a task.\n        :type task_create_parameters:\n         ~azure.mgmt.containerregistry.v2018_09_01.models.Task\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Task or\n         ClientRawResponse<Task> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.containerregistry.v2018_09_01.models.Task]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.containerregistry.v2018_09_01.models.Task]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f23974:c0:m4"}
{"signature": "def update(<EOL>self, resource_group_name, registry_name, task_name, task_update_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_initial(<EOL>resource_group_name=resource_group_name,<EOL>registry_name=registry_name,<EOL>task_name=task_name,<EOL>task_update_parameters=task_update_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a task with the specified parameters.\n\n        :param resource_group_name: The name of the resource group to which\n         the container registry belongs.\n        :type resource_group_name: str\n        :param registry_name: The name of the container registry.\n        :type registry_name: str\n        :param task_name: The name of the container registry task.\n        :type task_name: str\n        :param task_update_parameters: The parameters for updating a task.\n        :type task_update_parameters:\n         ~azure.mgmt.containerregistry.v2018_09_01.models.TaskUpdateParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Task or\n         ClientRawResponse<Task> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.containerregistry.v2018_09_01.models.Task]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.containerregistry.v2018_09_01.models.Task]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f23974:c0:m8"}
{"signature": "def get(<EOL>self, resource_group_name, registry_name, run_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", registry_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:5>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", run_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the detailed information for a given run.\n\n        :param resource_group_name: The name of the resource group to which\n         the container registry belongs.\n        :type resource_group_name: str\n        :param registry_name: The name of the container registry.\n        :type registry_name: str\n        :param run_id: The run ID.\n        :type run_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Run or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.containerregistry.v2018_09_01.models.Run or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f23975:c0:m2"}
{"signature": "def get_log_sas_url(<EOL>self, resource_group_name, registry_name, run_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_log_sas_url.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", registry_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:5>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", run_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a link to download the run logs.\n\n        :param resource_group_name: The name of the resource group to which\n         the container registry belongs.\n        :type resource_group_name: str\n        :param registry_name: The name of the container registry.\n        :type registry_name: str\n        :param run_id: The run ID.\n        :type run_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RunGetLogResult or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.containerregistry.v2018_09_01.models.RunGetLogResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f23975:c0:m5"}
{"signature": "def update(<EOL>self, resource_group_name, registry_name, webhook_name, webhook_update_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_initial(<EOL>resource_group_name=resource_group_name,<EOL>registry_name=registry_name,<EOL>webhook_name=webhook_name,<EOL>webhook_update_parameters=webhook_update_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a webhook with the specified parameters.\n\n        :param resource_group_name: The name of the resource group to which\n         the container registry belongs.\n        :type resource_group_name: str\n        :param registry_name: The name of the container registry.\n        :type registry_name: str\n        :param webhook_name: The name of the webhook.\n        :type webhook_name: str\n        :param webhook_update_parameters: The parameters for updating a\n         webhook.\n        :type webhook_update_parameters:\n         ~azure.mgmt.containerregistry.v2018_09_01.models.WebhookUpdateParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Webhook or\n         ClientRawResponse<Webhook> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.containerregistry.v2018_09_01.models.Webhook]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.containerregistry.v2018_09_01.models.Webhook]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f23976:c0:m7"}
{"signature": "def get_callback_config(<EOL>self, resource_group_name, registry_name, webhook_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_callback_config.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", registry_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:5>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", webhook_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:5>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the configuration of service URI and custom headers for the\n        webhook.\n\n        :param resource_group_name: The name of the resource group to which\n         the container registry belongs.\n        :type resource_group_name: str\n        :param registry_name: The name of the container registry.\n        :type registry_name: str\n        :param webhook_name: The name of the webhook.\n        :type webhook_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: CallbackConfig or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.containerregistry.v2018_09_01.models.CallbackConfig or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f23976:c0:m10"}
{"signature": "def list_build_arguments(<EOL>self, resource_group_name, registry_name, build_task_name, step_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_build_arguments.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", registry_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:5>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", build_task_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:5>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", step_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:5>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.BuildArgumentPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.BuildArgumentPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List the build arguments for a step including the secret arguments.\n\n        :param resource_group_name: The name of the resource group to which\n         the container registry belongs.\n        :type resource_group_name: str\n        :param registry_name: The name of the container registry.\n        :type registry_name: str\n        :param build_task_name: The name of the container registry build task.\n        :type build_task_name: str\n        :param step_name: The name of a build step for a container registry\n         build task.\n        :type step_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of BuildArgument\n        :rtype:\n         ~azure.mgmt.containerregistry.v2018_02_01_preview.models.BuildArgumentPaged[~azure.mgmt.containerregistry.v2018_02_01_preview.models.BuildArgument]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24087:c0:m9"}
{"signature": "def delete(<EOL>self, resource_group_name, registry_name, build_task_name, step_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>registry_name=registry_name,<EOL>build_task_name=build_task_name,<EOL>step_name=step_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes a build step from the build task.\n\n        :param resource_group_name: The name of the resource group to which\n         the container registry belongs.\n        :type resource_group_name: str\n        :param registry_name: The name of the container registry.\n        :type registry_name: str\n        :param build_task_name: The name of the container registry build task.\n        :type build_task_name: str\n        :param step_name: The name of a build step for a container registry\n         build task.\n        :type step_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24087:c0:m6"}
{"signature": "def list_credentials(<EOL>self, resource_group_name, registry_name, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.list_credentials.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", registry_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:5>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists the login credentials for the specified container registry.\n\n        :param resource_group_name: The name of the resource group to which\n         the container registry belongs.\n        :type resource_group_name: str\n        :param registry_name: The name of the container registry.\n        :type registry_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RegistryListCredentialsResult or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.containerregistry.v2018_02_01_preview.models.RegistryListCredentialsResult\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24091:c0:m13"}
{"signature": "def delete(<EOL>self, resource_group_name, registry_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>registry_name=registry_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes a container registry.\n\n        :param resource_group_name: The name of the resource group to which\n         the container registry belongs.\n        :type resource_group_name: str\n        :param registry_name: The name of the container registry.\n        :type registry_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24091:c0:m8"}
{"signature": "def queue_build(<EOL>self, resource_group_name, registry_name, build_request, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._queue_build_initial(<EOL>resource_group_name=resource_group_name,<EOL>registry_name=registry_name,<EOL>build_request=build_request,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates a new build based on the request parameters and add it to the\n        build queue.\n\n        :param resource_group_name: The name of the resource group to which\n         the container registry belongs.\n        :type resource_group_name: str\n        :param registry_name: The name of the container registry.\n        :type registry_name: str\n        :param build_request: The parameters of a build that needs to queued.\n        :type build_request:\n         ~azure.mgmt.containerregistry.v2018_02_01_preview.models.QueueBuildRequest\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Build or\n         ClientRawResponse<Build> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.containerregistry.v2018_02_01_preview.models.Build]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.containerregistry.v2018_02_01_preview.models.Build]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24091:c0:m20"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RegistryPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RegistryPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all the container registries under the specified resource group.\n\n        :param resource_group_name: The name of the resource group to which\n         the container registry belongs.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Registry\n        :rtype:\n         ~azure.mgmt.containerregistry.v2018_02_01_preview.models.RegistryPaged[~azure.mgmt.containerregistry.v2018_02_01_preview.models.Registry]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24091:c0:m11"}
{"signature": "def get_build_source_upload_url(<EOL>self, resource_group_name, registry_name, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get_build_source_upload_url.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", registry_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:5>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the upload location for the user to be able to upload the source.\n\n        :param resource_group_name: The name of the resource group to which\n         the container registry belongs.\n        :type resource_group_name: str\n        :param registry_name: The name of the container registry.\n        :type registry_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SourceUploadDefinition or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.containerregistry.v2018_02_01_preview.models.SourceUploadDefinition\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24091:c0:m21"}
{"signature": "def list_usages(<EOL>self, resource_group_name, registry_name, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.list_usages.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", registry_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:5>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the quota usages for the specified container registry.\n\n        :param resource_group_name: The name of the resource group to which\n         the container registry belongs.\n        :type resource_group_name: str\n        :param registry_name: The name of the container registry.\n        :type registry_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RegistryUsageListResult or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.containerregistry.v2018_02_01_preview.models.RegistryUsageListResult\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24091:c0:m15"}
{"signature": "def list_source_repository_properties(<EOL>self, resource_group_name, registry_name, build_task_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_source_repository_properties.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", registry_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:5>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", build_task_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:5>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the source control properties for a build task.\n\n        :param resource_group_name: The name of the resource group to which\n         the container registry belongs.\n        :type resource_group_name: str\n        :param registry_name: The name of the container registry.\n        :type registry_name: str\n        :param build_task_name: The name of the container registry build task.\n        :type build_task_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SourceRepositoryProperties or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.containerregistry.v2018_02_01_preview.models.SourceRepositoryProperties\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24092:c0:m9"}
{"signature": "def create(<EOL>self, resource_group_name, registry_name, build_task_name, build_task_create_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_initial(<EOL>resource_group_name=resource_group_name,<EOL>registry_name=registry_name,<EOL>build_task_name=build_task_name,<EOL>build_task_create_parameters=build_task_create_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates a build task for a container registry with the specified\n        parameters.\n\n        :param resource_group_name: The name of the resource group to which\n         the container registry belongs.\n        :type resource_group_name: str\n        :param registry_name: The name of the container registry.\n        :type registry_name: str\n        :param build_task_name: The name of the container registry build task.\n        :type build_task_name: str\n        :param build_task_create_parameters: The parameters for creating a\n         build task.\n        :type build_task_create_parameters:\n         ~azure.mgmt.containerregistry.v2018_02_01_preview.models.BuildTask\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns BuildTask or\n         ClientRawResponse<BuildTask> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.containerregistry.v2018_02_01_preview.models.BuildTask]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.containerregistry.v2018_02_01_preview.models.BuildTask]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24092:c0:m4"}
{"signature": "def list(<EOL>self, resource_group_name, registry_name, filter=None, top=None, skip_token=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", registry_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:5>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>')<EOL><DEDENT>if skip_token is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", skip_token, '<STR_LIT:str>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.BuildPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.BuildPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the builds for a registry.\n\n        :param resource_group_name: The name of the resource group to which\n         the container registry belongs.\n        :type resource_group_name: str\n        :param registry_name: The name of the container registry.\n        :type registry_name: str\n        :param filter: The builds filter to apply on the operation.\n        :type filter: str\n        :param top: $top is supported for get list of builds, which limits the\n         maximum number of builds to return.\n        :type top: int\n        :param skip_token: $skipToken is supported on get list of builds,\n         which provides the next page in the list of builds.\n        :type skip_token: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Build\n        :rtype:\n         ~azure.mgmt.containerregistry.v2018_02_01_preview.models.BuildPaged[~azure.mgmt.containerregistry.v2018_02_01_preview.models.Build]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24093:c0:m1"}
{"signature": "def ping(<EOL>self, resource_group_name, registry_name, webhook_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.ping.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", registry_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:5>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", webhook_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:5>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Triggers a ping event to be sent to the webhook.\n\n        :param resource_group_name: The name of the resource group to which\n         the container registry belongs.\n        :type resource_group_name: str\n        :param registry_name: The name of the container registry.\n        :type registry_name: str\n        :param webhook_name: The name of the webhook.\n        :type webhook_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: EventInfo or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.containerregistry.v2018_02_01_preview.models.EventInfo or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24094:c0:m9"}
{"signature": "def create(<EOL>self, resource_group_name, registry_name, webhook_name, webhook_create_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_initial(<EOL>resource_group_name=resource_group_name,<EOL>registry_name=registry_name,<EOL>webhook_name=webhook_name,<EOL>webhook_create_parameters=webhook_create_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates a webhook for a container registry with the specified\n        parameters.\n\n        :param resource_group_name: The name of the resource group to which\n         the container registry belongs.\n        :type resource_group_name: str\n        :param registry_name: The name of the container registry.\n        :type registry_name: str\n        :param webhook_name: The name of the webhook.\n        :type webhook_name: str\n        :param webhook_create_parameters: The parameters for creating a\n         webhook.\n        :type webhook_create_parameters:\n         ~azure.mgmt.containerregistry.v2018_02_01_preview.models.WebhookCreateParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Webhook or\n         ClientRawResponse<Webhook> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.containerregistry.v2018_02_01_preview.models.Webhook]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.containerregistry.v2018_02_01_preview.models.Webhook]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24094:c0:m3"}
{"signature": "def update(<EOL>self, resource_group_name, registry_name, webhook_name, webhook_update_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_initial(<EOL>resource_group_name=resource_group_name,<EOL>registry_name=registry_name,<EOL>webhook_name=webhook_name,<EOL>webhook_update_parameters=webhook_update_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a webhook with the specified parameters.\n\n        :param resource_group_name: The name of the resource group to which\n         the container registry belongs.\n        :type resource_group_name: str\n        :param registry_name: The name of the container registry.\n        :type registry_name: str\n        :param webhook_name: The name of the webhook.\n        :type webhook_name: str\n        :param webhook_update_parameters: The parameters for updating a\n         webhook.\n        :type webhook_update_parameters:\n         ~azure.mgmt.containerregistry.v2018_02_01_preview.models.WebhookUpdateParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Webhook or\n         ClientRawResponse<Webhook> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.containerregistry.v2018_02_01_preview.models.Webhook]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.containerregistry.v2018_02_01_preview.models.Webhook]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24094:c0:m7"}
{"signature": "def get(<EOL>self, resource_group_name, registry_name, webhook_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", registry_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:5>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", webhook_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:5>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the properties of the specified webhook.\n\n        :param resource_group_name: The name of the resource group to which\n         the container registry belongs.\n        :type resource_group_name: str\n        :param registry_name: The name of the container registry.\n        :type registry_name: str\n        :param webhook_name: The name of the webhook.\n        :type webhook_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Webhook or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.containerregistry.v2018_02_01_preview.models.Webhook or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24094:c0:m1"}
{"signature": "def get(<EOL>self, location, publisher_name, type, version, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", publisher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT:type>': self._serialize.url(\"<STR_LIT:type>\", type, '<STR_LIT:str>'),<EOL>'<STR_LIT:version>': self._serialize.url(\"<STR_LIT:version>\", version, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a virtual machine extension image.\n\n        :param location: The name of a supported Azure region.\n        :type location: str\n        :param publisher_name:\n        :type publisher_name: str\n        :param type:\n        :type type: str\n        :param version:\n        :type version: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualMachineExtensionImage or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.compute.v2017_12_01.models.VirtualMachineExtensionImage or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24366:c0:m1"}
{"signature": "def list_versions(<EOL>self, location, publisher_name, type, filter=None, top=None, orderby=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_versions.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", publisher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT:type>': self._serialize.url(\"<STR_LIT:type>\", type, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>')<EOL><DEDENT>if orderby is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", orderby, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of virtual machine extension image versions.\n\n        :param location: The name of a supported Azure region.\n        :type location: str\n        :param publisher_name:\n        :type publisher_name: str\n        :param type:\n        :type type: str\n        :param filter: The filter to apply on the operation.\n        :type filter: str\n        :param top:\n        :type top: int\n        :param orderby:\n        :type orderby: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype:\n         list[~azure.mgmt.compute.v2017_12_01.models.VirtualMachineExtensionImage]\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24366:c0:m3"}
{"signature": "def get(<EOL>self, resource_group_name, vm_scale_set_name, instance_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vm_scale_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", instance_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a virtual machine from a VM scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_id: The instance ID of the virtual machine.\n        :type instance_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualMachineScaleSetVM or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.compute.v2017_12_01.models.VirtualMachineScaleSetVM or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24368:c0:m11"}
{"signature": "def reimage(<EOL>self, resource_group_name, vm_scale_set_name, instance_id, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._reimage_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_id=instance_id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Reimages (upgrade the operating system) a specific virtual machine in a\n        VM scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_id: The instance ID of the virtual machine.\n        :type instance_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns OperationStatusResponse\n         or ClientRawResponse<OperationStatusResponse> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2017_12_01.models.OperationStatusResponse]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2017_12_01.models.OperationStatusResponse]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24368:c0:m2"}
{"signature": "def get_instance_view(<EOL>self, resource_group_name, vm_scale_set_name, instance_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_instance_view.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vm_scale_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", instance_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the status of a virtual machine from a VM scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_id: The instance ID of the virtual machine.\n        :type instance_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualMachineScaleSetVMInstanceView or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.compute.v2017_12_01.models.VirtualMachineScaleSetVMInstanceView\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24368:c0:m12"}
{"signature": "def update(<EOL>self, resource_group_name, vm_scale_set_name, instance_id, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_id=instance_id,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a virtual machine of a VM scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set where the\n         extension should be create or updated.\n        :type vm_scale_set_name: str\n        :param instance_id: The instance ID of the virtual machine.\n        :type instance_id: str\n        :param parameters: Parameters supplied to the Update Virtual Machine\n         Scale Sets VM operation.\n        :type parameters:\n         ~azure.mgmt.compute.v2017_12_01.models.VirtualMachineScaleSetVM\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         VirtualMachineScaleSetVM or\n         ClientRawResponse<VirtualMachineScaleSetVM> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2017_12_01.models.VirtualMachineScaleSetVM]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2017_12_01.models.VirtualMachineScaleSetVM]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24368:c0:m8"}
{"signature": "def perform_maintenance(<EOL>self, resource_group_name, vm_scale_set_name, instance_id, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._perform_maintenance_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_id=instance_id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Performs maintenance on a virtual machine in a VM scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_id: The instance ID of the virtual machine.\n        :type instance_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns OperationStatusResponse\n         or ClientRawResponse<OperationStatusResponse> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2017_12_01.models.OperationStatusResponse]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2017_12_01.models.OperationStatusResponse]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24368:c0:m23"}
{"signature": "def delete(<EOL>self, resource_group_name, vm_scale_set_name, instance_id, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_id=instance_id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes a virtual machine from a VM scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_id: The instance ID of the virtual machine.\n        :type instance_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns OperationStatusResponse\n         or ClientRawResponse<OperationStatusResponse> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2017_12_01.models.OperationStatusResponse]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2017_12_01.models.OperationStatusResponse]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24368:c0:m10"}
{"signature": "def list_skus(<EOL>self, location, publisher_name, offer, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_skus.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", publisher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", offer, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of virtual machine image SKUs for the specified location,\n        publisher, and offer.\n\n        :param location: The name of a supported Azure region.\n        :type location: str\n        :param publisher_name: A valid image publisher.\n        :type publisher_name: str\n        :param offer: A valid image publisher offer.\n        :type offer: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype:\n         list[~azure.mgmt.compute.v2017_12_01.models.VirtualMachineImageResource]\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24369:c0:m5"}
{"signature": "def list(<EOL>self, location, publisher_name, offer, skus, filter=None, top=None, orderby=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", publisher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", offer, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", skus, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>')<EOL><DEDENT>if orderby is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", orderby, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of all virtual machine image versions for the specified\n        location, publisher, offer, and SKU.\n\n        :param location: The name of a supported Azure region.\n        :type location: str\n        :param publisher_name: A valid image publisher.\n        :type publisher_name: str\n        :param offer: A valid image publisher offer.\n        :type offer: str\n        :param skus: A valid image SKU.\n        :type skus: str\n        :param filter: The filter to apply on the operation.\n        :type filter: str\n        :param top:\n        :type top: int\n        :param orderby:\n        :type orderby: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype:\n         list[~azure.mgmt.compute.v2017_12_01.models.VirtualMachineImageResource]\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24369:c0:m2"}
{"signature": "def list_offers(<EOL>self, location, publisher_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_offers.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", publisher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of virtual machine image offers for the specified location\n        and publisher.\n\n        :param location: The name of a supported Azure region.\n        :type location: str\n        :param publisher_name: A valid image publisher.\n        :type publisher_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype:\n         list[~azure.mgmt.compute.v2017_12_01.models.VirtualMachineImageResource]\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24369:c0:m3"}
{"signature": "def get(<EOL>self, location, publisher_name, offer, skus, version, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", publisher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", offer, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", skus, '<STR_LIT:str>'),<EOL>'<STR_LIT:version>': self._serialize.url(\"<STR_LIT:version>\", version, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a virtual machine image.\n\n        :param location: The name of a supported Azure region.\n        :type location: str\n        :param publisher_name: A valid image publisher.\n        :type publisher_name: str\n        :param offer: A valid image publisher offer.\n        :type offer: str\n        :param skus: A valid image SKU.\n        :type skus: str\n        :param version: A valid image SKU version.\n        :type version: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualMachineImage or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.compute.v2017_12_01.models.VirtualMachineImage or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24369:c0:m1"}
{"signature": "def generalize(<EOL>self, resource_group_name, vm_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.generalize.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vm_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Sets the state of the virtual machine to generalized.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine.\n        :type vm_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: OperationStatusResponse or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.compute.v2017_12_01.models.OperationStatusResponse\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24370:c0:m17"}
{"signature": "def redeploy(<EOL>self, resource_group_name, vm_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._redeploy_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_name=vm_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The operation to redeploy a virtual machine.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine.\n        :type vm_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns OperationStatusResponse\n         or ClientRawResponse<OperationStatusResponse> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2017_12_01.models.OperationStatusResponse]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2017_12_01.models.OperationStatusResponse]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24370:c0:m28"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, vm_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_name=vm_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The operation to create or update a virtual machine.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine.\n        :type vm_name: str\n        :param parameters: Parameters supplied to the Create Virtual Machine\n         operation.\n        :type parameters:\n         ~azure.mgmt.compute.v2017_12_01.models.VirtualMachine\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualMachine or\n         ClientRawResponse<VirtualMachine> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2017_12_01.models.VirtualMachine]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2017_12_01.models.VirtualMachine]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24370:c0:m6"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualMachinePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualMachinePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all of the virtual machines in the specified subscription. Use\n        the nextLink property in the response to get the next page of virtual\n        machines.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualMachine\n        :rtype:\n         ~azure.mgmt.compute.v2017_12_01.models.VirtualMachinePaged[~azure.mgmt.compute.v2017_12_01.models.VirtualMachine]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24370:c0:m19"}
{"signature": "def capture(<EOL>self, resource_group_name, vm_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._capture_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_name=vm_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Captures the VM by copying virtual hard disks of the VM and outputs a\n        template that can be used to create similar VMs.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine.\n        :type vm_name: str\n        :param parameters: Parameters supplied to the Capture Virtual Machine\n         operation.\n        :type parameters:\n         ~azure.mgmt.compute.v2017_12_01.models.VirtualMachineCaptureParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         VirtualMachineCaptureResult or\n         ClientRawResponse<VirtualMachineCaptureResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2017_12_01.models.VirtualMachineCaptureResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2017_12_01.models.VirtualMachineCaptureResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24370:c0:m4"}
{"signature": "def run_command(<EOL>self, resource_group_name, vm_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._run_command_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_name=vm_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Run command on the VM.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine.\n        :type vm_name: str\n        :param parameters: Parameters supplied to the Run command operation.\n        :type parameters:\n         ~azure.mgmt.compute.v2017_12_01.models.RunCommandInput\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns RunCommandResult or\n         ClientRawResponse<RunCommandResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2017_12_01.models.RunCommandResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2017_12_01.models.RunCommandResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24370:c0:m32"}
{"signature": "def instance_view(<EOL>self, resource_group_name, vm_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.instance_view.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vm_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves information about the run-time state of a virtual machine.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine.\n        :type vm_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualMachineInstanceView or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.compute.v2017_12_01.models.VirtualMachineInstanceView or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24370:c0:m12"}
{"signature": "def get(<EOL>self, resource_group_name, vm_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vm_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves information about the model view or the instance view of a\n        virtual machine.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine.\n        :type vm_name: str\n        :param expand: The expand expression to apply on the operation.\n         Possible values include: 'instanceView'\n        :type expand: str or\n         ~azure.mgmt.compute.v2017_12_01.models.InstanceViewTypes\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualMachine or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.compute.v2017_12_01.models.VirtualMachine or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24370:c0:m11"}
{"signature": "def update(<EOL>self, resource_group_name, vm_name, vm_extension_name, extension_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_name=vm_name,<EOL>vm_extension_name=vm_extension_name,<EOL>extension_parameters=extension_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The operation to update the extension.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine where the extension\n         should be updated.\n        :type vm_name: str\n        :param vm_extension_name: The name of the virtual machine extension.\n        :type vm_extension_name: str\n        :param extension_parameters: Parameters supplied to the Update Virtual\n         Machine Extension operation.\n        :type extension_parameters:\n         ~azure.mgmt.compute.v2017_12_01.models.VirtualMachineExtensionUpdate\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualMachineExtension\n         or ClientRawResponse<VirtualMachineExtension> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2017_12_01.models.VirtualMachineExtension]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2017_12_01.models.VirtualMachineExtension]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24371:c0:m4"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, vm_name, vm_extension_name, extension_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_name=vm_name,<EOL>vm_extension_name=vm_extension_name,<EOL>extension_parameters=extension_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The operation to create or update the extension.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine where the extension\n         should be created or updated.\n        :type vm_name: str\n        :param vm_extension_name: The name of the virtual machine extension.\n        :type vm_extension_name: str\n        :param extension_parameters: Parameters supplied to the Create Virtual\n         Machine Extension operation.\n        :type extension_parameters:\n         ~azure.mgmt.compute.v2017_12_01.models.VirtualMachineExtension\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualMachineExtension\n         or ClientRawResponse<VirtualMachineExtension> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2017_12_01.models.VirtualMachineExtension]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2017_12_01.models.VirtualMachineExtension]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24371:c0:m2"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ImagePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ImagePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the list of Images in the subscription. Use nextLink property in\n        the response to get the next page of Images. Do this till nextLink is\n        null to fetch all the Images.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Image\n        :rtype:\n         ~azure.mgmt.compute.v2017_12_01.models.ImagePaged[~azure.mgmt.compute.v2017_12_01.models.Image]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24372:c0:m9"}
{"signature": "def delete(<EOL>self, resource_group_name, image_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>image_name=image_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes an Image.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param image_name: The name of the image.\n        :type image_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns OperationStatusResponse\n         or ClientRawResponse<OperationStatusResponse> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2017_12_01.models.OperationStatusResponse]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2017_12_01.models.OperationStatusResponse]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24372:c0:m6"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, image_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>image_name=image_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Create or update an image.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param image_name: The name of the image.\n        :type image_name: str\n        :param parameters: Parameters supplied to the Create Image operation.\n        :type parameters: ~azure.mgmt.compute.v2017_12_01.models.Image\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Image or\n         ClientRawResponse<Image> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2017_12_01.models.Image]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2017_12_01.models.Image]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24372:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, vm_scale_set_name, vmss_extension_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>vmss_extension_name=vmss_extension_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The operation to delete the extension.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set where the\n         extension should be deleted.\n        :type vm_scale_set_name: str\n        :param vmss_extension_name: The name of the VM scale set extension.\n        :type vmss_extension_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns OperationStatusResponse\n         or ClientRawResponse<OperationStatusResponse> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2017_12_01.models.OperationStatusResponse]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2017_12_01.models.OperationStatusResponse]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24374:c0:m4"}
{"signature": "def list(<EOL>self, location, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>', pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RunCommandDocumentBasePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RunCommandDocumentBasePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all available run commands for a subscription in a location.\n\n        :param location: The location upon which run commands is queried.\n        :type location: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of RunCommandDocumentBase\n        :rtype:\n         ~azure.mgmt.compute.v2017_12_01.models.RunCommandDocumentBasePaged[~azure.mgmt.compute.v2017_12_01.models.RunCommandDocumentBase]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24377:c0:m1"}
{"signature": "def delete(<EOL>self, resource_group_name, availability_set_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", availability_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Delete an availability set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param availability_set_name: The name of the availability set.\n        :type availability_set_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: OperationStatusResponse or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.compute.v2017_12_01.models.OperationStatusResponse\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24379:c0:m3"}
{"signature": "def list_available_sizes(<EOL>self, resource_group_name, availability_set_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_available_sizes.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", availability_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualMachineSizePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualMachineSizePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all available virtual machine sizes that can be used to create a\n        new virtual machine in an existing availability set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param availability_set_name: The name of the availability set.\n        :type availability_set_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualMachineSize\n        :rtype:\n         ~azure.mgmt.compute.v2017_12_01.models.VirtualMachineSizePaged[~azure.mgmt.compute.v2017_12_01.models.VirtualMachineSize]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24379:c0:m7"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.AvailabilitySetPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.AvailabilitySetPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all availability sets in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of AvailabilitySet\n        :rtype:\n         ~azure.mgmt.compute.v2017_12_01.models.AvailabilitySetPaged[~azure.mgmt.compute.v2017_12_01.models.AvailabilitySet]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24379:c0:m6"}
{"signature": "def reimage_all(<EOL>self, resource_group_name, vm_scale_set_name, instance_ids=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._reimage_all_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_ids=instance_ids,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Reimages all the disks ( including data disks ) in the virtual machines\n        in a VM scale set. This operation is only supported for managed disks.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_ids: The virtual machine scale set instance ids.\n         Omitting the virtual machine scale set instance ids will result in the\n         operation being performed on all virtual machines in the virtual\n         machine scale set.\n        :type instance_ids: list[str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns OperationStatusResponse\n         or ClientRawResponse<OperationStatusResponse> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2017_12_01.models.OperationStatusResponse]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2017_12_01.models.OperationStatusResponse]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24380:c0:m32"}
{"signature": "def update_instances(<EOL>self, resource_group_name, vm_scale_set_name, instance_ids, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_instances_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_ids=instance_ids,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Upgrades one or more virtual machines to the latest SKU set in the VM\n        scale set model.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_ids: The virtual machine scale set instance ids.\n        :type instance_ids: list[str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns OperationStatusResponse\n         or ClientRawResponse<OperationStatusResponse> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2017_12_01.models.OperationStatusResponse]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2017_12_01.models.OperationStatusResponse]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24380:c0:m28"}
{"signature": "def list_skus(<EOL>self, resource_group_name, vm_scale_set_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_skus.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vm_scale_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualMachineScaleSetSkuPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualMachineScaleSetSkuPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of SKUs available for your VM scale set, including the\n        minimum and maximum VM instances allowed for each SKU.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualMachineScaleSetSku\n        :rtype:\n         ~azure.mgmt.compute.v2017_12_01.models.VirtualMachineScaleSetSkuPaged[~azure.mgmt.compute.v2017_12_01.models.VirtualMachineScaleSetSku]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24380:c0:m15"}
{"signature": "def start(<EOL>self, resource_group_name, vm_scale_set_name, instance_ids=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._start_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_ids=instance_ids,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Starts one or more virtual machines in a VM scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_ids: The virtual machine scale set instance ids.\n         Omitting the virtual machine scale set instance ids will result in the\n         operation being performed on all virtual machines in the virtual\n         machine scale set.\n        :type instance_ids: list[str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns OperationStatusResponse\n         or ClientRawResponse<OperationStatusResponse> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2017_12_01.models.OperationStatusResponse]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2017_12_01.models.OperationStatusResponse]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24380:c0:m22"}
{"signature": "def redeploy(<EOL>self, resource_group_name, vm_scale_set_name, instance_ids=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._redeploy_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_ids=instance_ids,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Redeploy one or more virtual machines in a VM scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_ids: The virtual machine scale set instance ids.\n         Omitting the virtual machine scale set instance ids will result in the\n         operation being performed on all virtual machines in the virtual\n         machine scale set.\n        :type instance_ids: list[str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns OperationStatusResponse\n         or ClientRawResponse<OperationStatusResponse> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2017_12_01.models.OperationStatusResponse]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2017_12_01.models.OperationStatusResponse]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24380:c0:m24"}
{"signature": "def reimage(<EOL>self, resource_group_name, vm_scale_set_name, instance_ids=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._reimage_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_ids=instance_ids,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Reimages (upgrade the operating system) one or more virtual machines in\n        a VM scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_ids: The virtual machine scale set instance ids.\n         Omitting the virtual machine scale set instance ids will result in the\n         operation being performed on all virtual machines in the virtual\n         machine scale set.\n        :type instance_ids: list[str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns OperationStatusResponse\n         or ClientRawResponse<OperationStatusResponse> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2017_12_01.models.OperationStatusResponse]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2017_12_01.models.OperationStatusResponse]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24380:c0:m30"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualMachineScaleSetPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualMachineScaleSetPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of all VM scale sets under a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualMachineScaleSet\n        :rtype:\n         ~azure.mgmt.compute.v2017_12_01.models.VirtualMachineScaleSetPaged[~azure.mgmt.compute.v2017_12_01.models.VirtualMachineScaleSet]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24380:c0:m13"}
{"signature": "def update(<EOL>self, resource_group_name, vm_scale_set_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Update a VM scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set to create or\n         update.\n        :type vm_scale_set_name: str\n        :param parameters: The scale set object.\n        :type parameters:\n         ~azure.mgmt.compute.v2017_12_01.models.VirtualMachineScaleSetUpdate\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualMachineScaleSet\n         or ClientRawResponse<VirtualMachineScaleSet> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2017_12_01.models.VirtualMachineScaleSet]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2017_12_01.models.VirtualMachineScaleSet]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24380:c0:m4"}
{"signature": "def list_types(<EOL>self, location, publisher_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_types.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", publisher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of virtual machine extension image types.\n\n        :param location: The name of a supported Azure region.\n        :type location: str\n        :param publisher_name:\n        :type publisher_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype:\n         list[~azure.mgmt.compute.v2018_10_01.models.VirtualMachineExtensionImage]\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24619:c0:m2"}
{"signature": "def run_command(<EOL>self, resource_group_name, vm_scale_set_name, instance_id, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._run_command_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_id=instance_id,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT:location>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Run command on a virtual machine in a VM scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_id: The instance ID of the virtual machine.\n        :type instance_id: str\n        :param parameters: Parameters supplied to the Run command operation.\n        :type parameters:\n         ~azure.mgmt.compute.v2018_10_01.models.RunCommandInput\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns RunCommandResult or\n         ClientRawResponse<RunCommandResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2018_10_01.models.RunCommandResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2018_10_01.models.RunCommandResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24621:c0:m25"}
{"signature": "def power_off(<EOL>self, resource_group_name, vm_scale_set_name, instance_id, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._power_off_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_id=instance_id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Power off (stop) a virtual machine in a VM scale set. Note that\n        resources are still attached and you are getting charged for the\n        resources. Instead, use deallocate to release resources and avoid\n        charges.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_id: The instance ID of the virtual machine.\n        :type instance_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24621:c0:m15"}
{"signature": "def list(<EOL>self, resource_group_name, virtual_machine_scale_set_name, filter=None, select=None, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_machine_scale_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if select is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", select, '<STR_LIT:str>')<EOL><DEDENT>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualMachineScaleSetVMPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualMachineScaleSetVMPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of all virtual machines in a VM scale sets.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_machine_scale_set_name: The name of the VM scale set.\n        :type virtual_machine_scale_set_name: str\n        :param filter: The filter to apply to the operation.\n        :type filter: str\n        :param select: The list parameters.\n        :type select: str\n        :param expand: The expand expression to apply to the operation.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualMachineScaleSetVM\n        :rtype:\n         ~azure.mgmt.compute.v2018_10_01.models.VirtualMachineScaleSetVMPaged[~azure.mgmt.compute.v2018_10_01.models.VirtualMachineScaleSetVM]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24621:c0:m13"}
{"signature": "def reimage(<EOL>self, resource_group_name, vm_scale_set_name, instance_id, temp_disk=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._reimage_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_id=instance_id,<EOL>temp_disk=temp_disk,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Reimages (upgrade the operating system) a specific virtual machine in a\n        VM scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_id: The instance ID of the virtual machine.\n        :type instance_id: str\n        :param temp_disk: Specifies whether to reimage temp disk. Default\n         value: false.\n        :type temp_disk: bool\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24621:c0:m2"}
{"signature": "def reimage_all(<EOL>self, resource_group_name, vm_scale_set_name, instance_id, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._reimage_all_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_id=instance_id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Allows you to re-image all the disks ( including data disks ) in the a\n        VM scale set instance. This operation is only supported for managed\n        disks.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_id: The instance ID of the virtual machine.\n        :type instance_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24621:c0:m4"}
{"signature": "def update(<EOL>self, resource_group_name, vm_scale_set_name, instance_id, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_id=instance_id,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a virtual machine of a VM scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set where the\n         extension should be create or updated.\n        :type vm_scale_set_name: str\n        :param instance_id: The instance ID of the virtual machine.\n        :type instance_id: str\n        :param parameters: Parameters supplied to the Update Virtual Machine\n         Scale Sets VM operation.\n        :type parameters:\n         ~azure.mgmt.compute.v2018_10_01.models.VirtualMachineScaleSetVM\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         VirtualMachineScaleSetVM or\n         ClientRawResponse<VirtualMachineScaleSetVM> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2018_10_01.models.VirtualMachineScaleSetVM]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2018_10_01.models.VirtualMachineScaleSetVM]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24621:c0:m8"}
{"signature": "def perform_maintenance(<EOL>self, resource_group_name, vm_scale_set_name, instance_id, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._perform_maintenance_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_id=instance_id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Performs maintenance on a virtual machine in a VM scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_id: The instance ID of the virtual machine.\n        :type instance_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24621:c0:m23"}
{"signature": "def get(<EOL>self, resource_group_name, vm_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vm_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves information about the model view or the instance view of a\n        virtual machine.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine.\n        :type vm_name: str\n        :param expand: The expand expression to apply on the operation.\n         Possible values include: 'instanceView'\n        :type expand: str or\n         ~azure.mgmt.compute.v2018_10_01.models.InstanceViewTypes\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualMachine or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.compute.v2018_10_01.models.VirtualMachine or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24623:c0:m10"}
{"signature": "def convert_to_managed_disks(<EOL>self, resource_group_name, vm_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._convert_to_managed_disks_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_name=vm_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Converts virtual machine disks from blob-based to managed disks.\n        Virtual machine must be stop-deallocated before invoking this\n        operation.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine.\n        :type vm_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24623:c0:m13"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualMachinePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualMachinePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all of the virtual machines in the specified resource group. Use\n        the nextLink property in the response to get the next page of virtual\n        machines.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualMachine\n        :rtype:\n         ~azure.mgmt.compute.v2018_10_01.models.VirtualMachinePaged[~azure.mgmt.compute.v2018_10_01.models.VirtualMachine]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24623:c0:m17"}
{"signature": "def list_by_location(<EOL>self, location, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_location.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>', pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualMachinePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualMachinePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the virtual machines under the specified subscription for the\n        specified location.\n\n        :param location: The location for which virtual machines under the\n         subscription are queried.\n        :type location: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualMachine\n        :rtype:\n         ~azure.mgmt.compute.v2018_10_01.models.VirtualMachinePaged[~azure.mgmt.compute.v2018_10_01.models.VirtualMachine]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24623:c0:m1"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, vm_name, vm_extension_name, extension_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_name=vm_name,<EOL>vm_extension_name=vm_extension_name,<EOL>extension_parameters=extension_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The operation to create or update the extension.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine where the extension\n         should be created or updated.\n        :type vm_name: str\n        :param vm_extension_name: The name of the virtual machine extension.\n        :type vm_extension_name: str\n        :param extension_parameters: Parameters supplied to the Create Virtual\n         Machine Extension operation.\n        :type extension_parameters:\n         ~azure.mgmt.compute.v2018_10_01.models.VirtualMachineExtension\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualMachineExtension\n         or ClientRawResponse<VirtualMachineExtension> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2018_10_01.models.VirtualMachineExtension]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2018_10_01.models.VirtualMachineExtension]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24624:c0:m2"}
{"signature": "def update(<EOL>self, resource_group_name, vm_name, vm_extension_name, extension_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_name=vm_name,<EOL>vm_extension_name=vm_extension_name,<EOL>extension_parameters=extension_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The operation to update the extension.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine where the extension\n         should be updated.\n        :type vm_name: str\n        :param vm_extension_name: The name of the virtual machine extension.\n        :type vm_extension_name: str\n        :param extension_parameters: Parameters supplied to the Update Virtual\n         Machine Extension operation.\n        :type extension_parameters:\n         ~azure.mgmt.compute.v2018_10_01.models.VirtualMachineExtensionUpdate\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualMachineExtension\n         or ClientRawResponse<VirtualMachineExtension> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2018_10_01.models.VirtualMachineExtension]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2018_10_01.models.VirtualMachineExtension]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24624:c0:m4"}
{"signature": "def delete(<EOL>self, resource_group_name, vm_name, vm_extension_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_name=vm_name,<EOL>vm_extension_name=vm_extension_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The operation to delete the extension.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine where the extension\n         should be deleted.\n        :type vm_name: str\n        :param vm_extension_name: The name of the virtual machine extension.\n        :type vm_extension_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24624:c0:m6"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, image_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>image_name=image_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Create or update an image.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param image_name: The name of the image.\n        :type image_name: str\n        :param parameters: Parameters supplied to the Create Image operation.\n        :type parameters: ~azure.mgmt.compute.v2018_10_01.models.Image\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Image or\n         ClientRawResponse<Image> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2018_10_01.models.Image]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2018_10_01.models.Image]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24625:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, image_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>image_name=image_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes an Image.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param image_name: The name of the image.\n        :type image_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24625:c0:m6"}
{"signature": "def delete(<EOL>self, resource_group_name, proximity_placement_group_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", proximity_placement_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Delete a proximity placement group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param proximity_placement_group_name: The name of the proximity\n         placement group.\n        :type proximity_placement_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24626:c0:m3"}
{"signature": "def list_by_subscription(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_subscription.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ProximityPlacementGroupPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ProximityPlacementGroupPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all proximity placement groups in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ProximityPlacementGroup\n        :rtype:\n         ~azure.mgmt.compute.v2018_10_01.models.ProximityPlacementGroupPaged[~azure.mgmt.compute.v2018_10_01.models.ProximityPlacementGroup]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24626:c0:m5"}
{"signature": "def get(<EOL>self, resource_group_name, vm_scale_set_name, vmss_extension_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vm_scale_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vmss_extension_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "The operation to get the extension.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set containing the\n         extension.\n        :type vm_scale_set_name: str\n        :param vmss_extension_name: The name of the VM scale set extension.\n        :type vmss_extension_name: str\n        :param expand: The expand expression to apply on the operation.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualMachineScaleSetExtension or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.compute.v2018_10_01.models.VirtualMachineScaleSetExtension\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24628:c0:m5"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, vm_scale_set_name, vmss_extension_name, extension_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>vmss_extension_name=vmss_extension_name,<EOL>extension_parameters=extension_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The operation to create or update an extension.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set where the\n         extension should be create or updated.\n        :type vm_scale_set_name: str\n        :param vmss_extension_name: The name of the VM scale set extension.\n        :type vmss_extension_name: str\n        :param extension_parameters: Parameters supplied to the Create VM\n         scale set Extension operation.\n        :type extension_parameters:\n         ~azure.mgmt.compute.v2018_10_01.models.VirtualMachineScaleSetExtension\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         VirtualMachineScaleSetExtension or\n         ClientRawResponse<VirtualMachineScaleSetExtension> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2018_10_01.models.VirtualMachineScaleSetExtension]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2018_10_01.models.VirtualMachineScaleSetExtension]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24628:c0:m2"}
{"signature": "def list(<EOL>self, location, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>', pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualMachineSizePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualMachineSizePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "This API is deprecated. Use [Resources\n        Skus](https://docs.microsoft.com/en-us/rest/api/compute/resourceskus/list).\n\n        :param location: The location upon which virtual-machine-sizes is\n         queried.\n        :type location: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualMachineSize\n        :rtype:\n         ~azure.mgmt.compute.v2018_10_01.models.VirtualMachineSizePaged[~azure.mgmt.compute.v2018_10_01.models.VirtualMachineSize]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24629:c0:m1"}
{"signature": "def export_request_rate_by_interval(<EOL>self, parameters, location, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._export_request_rate_by_interval_initial(<EOL>parameters=parameters,<EOL>location=location,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Export logs that show Api requests made by this subscription in the\n        given time window to show throttling activities.\n\n        :param parameters: Parameters supplied to the LogAnalytics\n         getRequestRateByInterval Api.\n        :type parameters:\n         ~azure.mgmt.compute.v2018_10_01.models.RequestRateByIntervalInput\n        :param location: The location upon which virtual-machine-sizes is\n         queried.\n        :type location: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         LogAnalyticsOperationResult or\n         ClientRawResponse<LogAnalyticsOperationResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2018_10_01.models.LogAnalyticsOperationResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2018_10_01.models.LogAnalyticsOperationResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24632:c0:m2"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.AvailabilitySetPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.AvailabilitySetPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all availability sets in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of AvailabilitySet\n        :rtype:\n         ~azure.mgmt.compute.v2018_10_01.models.AvailabilitySetPaged[~azure.mgmt.compute.v2018_10_01.models.AvailabilitySet]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24633:c0:m6"}
{"signature": "def list_by_subscription(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_subscription.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.AvailabilitySetPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.AvailabilitySetPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all availability sets in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of AvailabilitySet\n        :rtype:\n         ~azure.mgmt.compute.v2018_10_01.models.AvailabilitySetPaged[~azure.mgmt.compute.v2018_10_01.models.AvailabilitySet]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24633:c0:m5"}
{"signature": "def get_os_upgrade_history(<EOL>self, resource_group_name, vm_scale_set_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.get_os_upgrade_history.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vm_scale_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.UpgradeOperationHistoricalStatusInfoPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.UpgradeOperationHistoricalStatusInfoPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets list of OS upgrades on a VM scale set instance.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of\n         UpgradeOperationHistoricalStatusInfo\n        :rtype:\n         ~azure.mgmt.compute.v2018_10_01.models.UpgradeOperationHistoricalStatusInfoPaged[~azure.mgmt.compute.v2018_10_01.models.UpgradeOperationHistoricalStatusInfo]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24634:c0:m16"}
{"signature": "def update(<EOL>self, resource_group_name, vm_scale_set_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Update a VM scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set to create or\n         update.\n        :type vm_scale_set_name: str\n        :param parameters: The scale set object.\n        :type parameters:\n         ~azure.mgmt.compute.v2018_10_01.models.VirtualMachineScaleSetUpdate\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualMachineScaleSet\n         or ClientRawResponse<VirtualMachineScaleSet> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2018_10_01.models.VirtualMachineScaleSet]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2018_10_01.models.VirtualMachineScaleSet]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24634:c0:m4"}
{"signature": "def redeploy(<EOL>self, resource_group_name, vm_scale_set_name, instance_ids=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._redeploy_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_ids=instance_ids,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Redeploy one or more virtual machines in a VM scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_ids: The virtual machine scale set instance ids.\n         Omitting the virtual machine scale set instance ids will result in the\n         operation being performed on all virtual machines in the virtual\n         machine scale set.\n        :type instance_ids: list[str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24634:c0:m24"}
{"signature": "def list_skus(<EOL>self, resource_group_name, vm_scale_set_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_skus.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vm_scale_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualMachineScaleSetSkuPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualMachineScaleSetSkuPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of SKUs available for your VM scale set, including the\n        minimum and maximum VM instances allowed for each SKU.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualMachineScaleSetSku\n        :rtype:\n         ~azure.mgmt.compute.v2018_10_01.models.VirtualMachineScaleSetSkuPaged[~azure.mgmt.compute.v2018_10_01.models.VirtualMachineScaleSetSku]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24634:c0:m15"}
{"signature": "def reimage_all(<EOL>self, resource_group_name, vm_scale_set_name, instance_ids=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._reimage_all_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_ids=instance_ids,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Reimages all the disks ( including data disks ) in the virtual machines\n        in a VM scale set. This operation is only supported for managed disks.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_ids: The virtual machine scale set instance ids.\n         Omitting the virtual machine scale set instance ids will result in the\n         operation being performed on all virtual machines in the virtual\n         machine scale set.\n        :type instance_ids: list[str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24634:c0:m32"}
{"signature": "def list_versions(<EOL>self, location, publisher_name, type, filter=None, top=None, orderby=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_versions.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", publisher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT:type>': self._serialize.url(\"<STR_LIT:type>\", type, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>')<EOL><DEDENT>if orderby is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", orderby, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of virtual machine extension image versions.\n\n        :param location: The name of a supported Azure region.\n        :type location: str\n        :param publisher_name:\n        :type publisher_name: str\n        :param type:\n        :type type: str\n        :param filter: The filter to apply on the operation.\n        :type filter: str\n        :param top:\n        :type top: int\n        :param orderby:\n        :type orderby: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype:\n         list[~azure.mgmt.compute.v2018_06_01.models.VirtualMachineExtensionImage]\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24902:c0:m3"}
{"signature": "def get(<EOL>self, resource_group_name, gallery_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", gallery_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves information about a Shared Image Gallery.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param gallery_name: The name of the Shared Image Gallery.\n        :type gallery_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Gallery or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.compute.v2018_06_01.models.Gallery or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24904:c0:m3"}
{"signature": "def delete(<EOL>self, resource_group_name, vm_scale_set_name, instance_id, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_id=instance_id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes a virtual machine from a VM scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_id: The instance ID of the virtual machine.\n        :type instance_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24905:c0:m10"}
{"signature": "def power_off(<EOL>self, resource_group_name, vm_scale_set_name, instance_id, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._power_off_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_id=instance_id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Power off (stop) a virtual machine in a VM scale set. Note that\n        resources are still attached and you are getting charged for the\n        resources. Instead, use deallocate to release resources and avoid\n        charges.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_id: The instance ID of the virtual machine.\n        :type instance_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24905:c0:m15"}
{"signature": "def get_instance_view(<EOL>self, resource_group_name, vm_scale_set_name, instance_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_instance_view.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vm_scale_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", instance_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the status of a virtual machine from a VM scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_id: The instance ID of the virtual machine.\n        :type instance_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualMachineScaleSetVMInstanceView or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.compute.v2018_06_01.models.VirtualMachineScaleSetVMInstanceView\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24905:c0:m12"}
{"signature": "def reimage_all(<EOL>self, resource_group_name, vm_scale_set_name, instance_id, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._reimage_all_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_id=instance_id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Allows you to re-image all the disks ( including data disks ) in the a\n        VM scale set instance. This operation is only supported for managed\n        disks.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_id: The instance ID of the virtual machine.\n        :type instance_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24905:c0:m4"}
{"signature": "def run_command(<EOL>self, resource_group_name, vm_scale_set_name, instance_id, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._run_command_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_id=instance_id,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT:location>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Run command on a virtual machine in a VM scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_id: The instance ID of the virtual machine.\n        :type instance_id: str\n        :param parameters: Parameters supplied to the Run command operation.\n        :type parameters:\n         ~azure.mgmt.compute.v2018_06_01.models.RunCommandInput\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns RunCommandResult or\n         ClientRawResponse<RunCommandResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2018_06_01.models.RunCommandResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2018_06_01.models.RunCommandResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24905:c0:m25"}
{"signature": "def update(<EOL>self, resource_group_name, vm_scale_set_name, instance_id, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_id=instance_id,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a virtual machine of a VM scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set where the\n         extension should be create or updated.\n        :type vm_scale_set_name: str\n        :param instance_id: The instance ID of the virtual machine.\n        :type instance_id: str\n        :param parameters: Parameters supplied to the Update Virtual Machine\n         Scale Sets VM operation.\n        :type parameters:\n         ~azure.mgmt.compute.v2018_06_01.models.VirtualMachineScaleSetVM\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         VirtualMachineScaleSetVM or\n         ClientRawResponse<VirtualMachineScaleSetVM> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2018_06_01.models.VirtualMachineScaleSetVM]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2018_06_01.models.VirtualMachineScaleSetVM]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24905:c0:m8"}
{"signature": "def list_offers(<EOL>self, location, publisher_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_offers.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", publisher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of virtual machine image offers for the specified location\n        and publisher.\n\n        :param location: The name of a supported Azure region.\n        :type location: str\n        :param publisher_name: A valid image publisher.\n        :type publisher_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype:\n         list[~azure.mgmt.compute.v2018_06_01.models.VirtualMachineImageResource]\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24906:c0:m3"}
{"signature": "def get(<EOL>self, location, publisher_name, offer, skus, version, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", publisher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", offer, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", skus, '<STR_LIT:str>'),<EOL>'<STR_LIT:version>': self._serialize.url(\"<STR_LIT:version>\", version, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a virtual machine image.\n\n        :param location: The name of a supported Azure region.\n        :type location: str\n        :param publisher_name: A valid image publisher.\n        :type publisher_name: str\n        :param offer: A valid image publisher offer.\n        :type offer: str\n        :param skus: A valid image SKU.\n        :type skus: str\n        :param version: A valid image SKU version.\n        :type version: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualMachineImage or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.compute.v2018_06_01.models.VirtualMachineImage or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24906:c0:m1"}
{"signature": "def revoke_access(<EOL>self, resource_group_name, disk_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._revoke_access_initial(<EOL>resource_group_name=resource_group_name,<EOL>disk_name=disk_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT:location>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Revokes access to a disk.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param disk_name: The name of the managed disk that is being created.\n         The name can't be changed after the disk is created. Supported\n         characters for the name are a-z, A-Z, 0-9 and _. The maximum name\n         length is 80 characters.\n        :type disk_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24907:c0:m13"}
{"signature": "def reimage(<EOL>self, resource_group_name, vm_name, temp_disk=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._reimage_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_name=vm_name,<EOL>temp_disk=temp_disk,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Reimages the virtual machine which has an ephemeral OS disk back to its\n        initial state.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine.\n        :type vm_name: str\n        :param temp_disk: Specifies whether to reimage temp disk. Default\n         value: false.\n        :type temp_disk: bool\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24908:c0:m29"}
{"signature": "def delete(<EOL>self, resource_group_name, vm_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_name=vm_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The operation to delete a virtual machine.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine.\n        :type vm_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24908:c0:m9"}
{"signature": "def start(<EOL>self, resource_group_name, vm_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._start_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_name=vm_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The operation to start a virtual machine.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine.\n        :type vm_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24908:c0:m25"}
{"signature": "def redeploy(<EOL>self, resource_group_name, vm_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._redeploy_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_name=vm_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The operation to redeploy a virtual machine.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine.\n        :type vm_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24908:c0:m27"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, vm_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_name=vm_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The operation to create or update a virtual machine.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine.\n        :type vm_name: str\n        :param parameters: Parameters supplied to the Create Virtual Machine\n         operation.\n        :type parameters:\n         ~azure.mgmt.compute.v2018_06_01.models.VirtualMachine\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualMachine or\n         ClientRawResponse<VirtualMachine> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2018_06_01.models.VirtualMachine]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2018_06_01.models.VirtualMachine]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24908:c0:m5"}
{"signature": "def list_available_sizes(<EOL>self, resource_group_name, vm_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_available_sizes.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vm_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualMachineSizePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualMachineSizePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all available virtual machine sizes to which the specified\n        virtual machine can be resized.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine.\n        :type vm_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualMachineSize\n        :rtype:\n         ~azure.mgmt.compute.v2018_06_01.models.VirtualMachineSizePaged[~azure.mgmt.compute.v2018_06_01.models.VirtualMachineSize]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24908:c0:m19"}
{"signature": "def perform_maintenance(<EOL>self, resource_group_name, vm_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._perform_maintenance_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_name=vm_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The operation to perform maintenance on a virtual machine.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine.\n        :type vm_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24908:c0:m31"}
{"signature": "def convert_to_managed_disks(<EOL>self, resource_group_name, vm_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._convert_to_managed_disks_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_name=vm_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Converts virtual machine disks from blob-based to managed disks.\n        Virtual machine must be stop-deallocated before invoking this\n        operation.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine.\n        :type vm_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24908:c0:m13"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualMachinePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualMachinePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all of the virtual machines in the specified resource group. Use\n        the nextLink property in the response to get the next page of virtual\n        machines.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualMachine\n        :rtype:\n         ~azure.mgmt.compute.v2018_06_01.models.VirtualMachinePaged[~azure.mgmt.compute.v2018_06_01.models.VirtualMachine]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24908:c0:m17"}
{"signature": "def list(<EOL>self, resource_group_name, vm_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vm_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "The operation to get all extensions of a Virtual Machine.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine containing the\n         extension.\n        :type vm_name: str\n        :param expand: The expand expression to apply on the operation.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualMachineExtensionsListResult or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.compute.v2018_06_01.models.VirtualMachineExtensionsListResult\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24910:c0:m8"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, snapshot_name, snapshot, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>snapshot_name=snapshot_name,<EOL>snapshot=snapshot,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a snapshot.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param snapshot_name: The name of the snapshot that is being created.\n         The name can't be changed after the snapshot is created. Supported\n         characters for the name are a-z, A-Z, 0-9 and _. The max name length\n         is 80 characters.\n        :type snapshot_name: str\n        :param snapshot: Snapshot object supplied in the body of the Put disk\n         operation.\n        :type snapshot: ~azure.mgmt.compute.v2018_06_01.models.Snapshot\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Snapshot or\n         ClientRawResponse<Snapshot> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2018_06_01.models.Snapshot]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2018_06_01.models.Snapshot]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24911:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, snapshot_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>snapshot_name=snapshot_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes a snapshot.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param snapshot_name: The name of the snapshot that is being created.\n         The name can't be changed after the snapshot is created. Supported\n         characters for the name are a-z, A-Z, 0-9 and _. The max name length\n         is 80 characters.\n        :type snapshot_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24911:c0:m7"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ImagePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ImagePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the list of Images in the subscription. Use nextLink property in\n        the response to get the next page of Images. Do this till nextLink is\n        null to fetch all the Images.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Image\n        :rtype:\n         ~azure.mgmt.compute.v2018_06_01.models.ImagePaged[~azure.mgmt.compute.v2018_06_01.models.Image]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24912:c0:m9"}
{"signature": "def list_by_subscription(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_subscription.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ProximityPlacementGroupPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ProximityPlacementGroupPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all proximity placement groups in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ProximityPlacementGroup\n        :rtype:\n         ~azure.mgmt.compute.v2018_06_01.models.ProximityPlacementGroupPaged[~azure.mgmt.compute.v2018_06_01.models.ProximityPlacementGroup]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24913:c0:m5"}
{"signature": "def get(<EOL>self, resource_group_name, proximity_placement_group_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", proximity_placement_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves information about a proximity placement group .\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param proximity_placement_group_name: The name of the proximity\n         placement group.\n        :type proximity_placement_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ProximityPlacementGroup or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.compute.v2018_06_01.models.ProximityPlacementGroup\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24913:c0:m4"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ProximityPlacementGroupPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ProximityPlacementGroupPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all proximity placement groups in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ProximityPlacementGroup\n        :rtype:\n         ~azure.mgmt.compute.v2018_06_01.models.ProximityPlacementGroupPaged[~azure.mgmt.compute.v2018_06_01.models.ProximityPlacementGroup]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24913:c0:m6"}
{"signature": "def list(<EOL>self, location, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>', pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.UsagePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.UsagePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets, for the specified location, the current compute resource usage\n        information as well as the limits for compute resources under the\n        subscription.\n\n        :param location: The location for which resource usage is queried.\n        :type location: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Usage\n        :rtype:\n         ~azure.mgmt.compute.v2018_06_01.models.UsagePaged[~azure.mgmt.compute.v2018_06_01.models.Usage]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24914:c0:m1"}
{"signature": "def list(<EOL>self, resource_group_name, vm_scale_set_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vm_scale_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualMachineScaleSetExtensionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualMachineScaleSetExtensionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of all extensions in a VM scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set containing the\n         extension.\n        :type vm_scale_set_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualMachineScaleSetExtension\n        :rtype:\n         ~azure.mgmt.compute.v2018_06_01.models.VirtualMachineScaleSetExtensionPaged[~azure.mgmt.compute.v2018_06_01.models.VirtualMachineScaleSetExtension]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24915:c0:m6"}
{"signature": "def list(<EOL>self, location, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>', pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RunCommandDocumentBasePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RunCommandDocumentBasePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all available run commands for a subscription in a location.\n\n        :param location: The location upon which run commands is queried.\n        :type location: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of RunCommandDocumentBase\n        :rtype:\n         ~azure.mgmt.compute.v2018_06_01.models.RunCommandDocumentBasePaged[~azure.mgmt.compute.v2018_06_01.models.RunCommandDocumentBase]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24919:c0:m1"}
{"signature": "def export_throttled_requests(<EOL>self, parameters, location, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._export_throttled_requests_initial(<EOL>parameters=parameters,<EOL>location=location,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Export logs that show total throttled Api requests for this\n        subscription in the given time window.\n\n        :param parameters: Parameters supplied to the LogAnalytics\n         getThrottledRequests Api.\n        :type parameters:\n         ~azure.mgmt.compute.v2018_06_01.models.ThrottledRequestsInput\n        :param location: The location upon which virtual-machine-sizes is\n         queried.\n        :type location: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         LogAnalyticsOperationResult or\n         ClientRawResponse<LogAnalyticsOperationResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2018_06_01.models.LogAnalyticsOperationResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2018_06_01.models.LogAnalyticsOperationResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24920:c0:m4"}
{"signature": "def list_by_subscription(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_subscription.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.AvailabilitySetPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.AvailabilitySetPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all availability sets in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of AvailabilitySet\n        :rtype:\n         ~azure.mgmt.compute.v2018_06_01.models.AvailabilitySetPaged[~azure.mgmt.compute.v2018_06_01.models.AvailabilitySet]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24921:c0:m5"}
{"signature": "def get(<EOL>self, resource_group_name, availability_set_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", availability_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves information about an availability set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param availability_set_name: The name of the availability set.\n        :type availability_set_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: AvailabilitySet or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.compute.v2018_06_01.models.AvailabilitySet or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24921:c0:m4"}
{"signature": "def list_skus(<EOL>self, resource_group_name, vm_scale_set_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_skus.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vm_scale_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualMachineScaleSetSkuPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualMachineScaleSetSkuPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of SKUs available for your VM scale set, including the\n        minimum and maximum VM instances allowed for each SKU.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualMachineScaleSetSku\n        :rtype:\n         ~azure.mgmt.compute.v2018_06_01.models.VirtualMachineScaleSetSkuPaged[~azure.mgmt.compute.v2018_06_01.models.VirtualMachineScaleSetSku]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24922:c0:m15"}
{"signature": "def reimage(<EOL>self, resource_group_name, vm_scale_set_name, temp_disk=None, instance_ids=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._reimage_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>temp_disk=temp_disk,<EOL>instance_ids=instance_ids,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Reimages (upgrade the operating system) one or more virtual machines in\n        a VM scale set which don't have a ephemeral OS disk, for virtual\n        machines who have a ephemeral OS disk the virtual machine is reset to\n        initial state.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param temp_disk: Specifies whether to reimage temp disk. Default\n         value: false.\n        :type temp_disk: bool\n        :param instance_ids: The virtual machine scale set instance ids.\n         Omitting the virtual machine scale set instance ids will result in the\n         operation being performed on all virtual machines in the virtual\n         machine scale set.\n        :type instance_ids: list[str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24922:c0:m30"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualMachineScaleSetPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualMachineScaleSetPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of all VM Scale Sets in the subscription, regardless of the\n        associated resource group. Use nextLink property in the response to get\n        the next page of VM Scale Sets. Do this till nextLink is null to fetch\n        all the VM Scale Sets.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualMachineScaleSet\n        :rtype:\n         ~azure.mgmt.compute.v2018_06_01.models.VirtualMachineScaleSetPaged[~azure.mgmt.compute.v2018_06_01.models.VirtualMachineScaleSet]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24922:c0:m14"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualMachineScaleSetPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualMachineScaleSetPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of all VM scale sets under a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualMachineScaleSet\n        :rtype:\n         ~azure.mgmt.compute.v2018_06_01.models.VirtualMachineScaleSetPaged[~azure.mgmt.compute.v2018_06_01.models.VirtualMachineScaleSet]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24922:c0:m13"}
{"signature": "def restart(<EOL>self, resource_group_name, vm_scale_set_name, instance_ids=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._restart_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_ids=instance_ids,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Restarts one or more virtual machines in a VM scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_ids: The virtual machine scale set instance ids.\n         Omitting the virtual machine scale set instance ids will result in the\n         operation being performed on all virtual machines in the virtual\n         machine scale set.\n        :type instance_ids: list[str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24922:c0:m20"}
{"signature": "def delete(<EOL>self, resource_group_name, vm_scale_set_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes a VM scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24922:c0:m6"}
{"signature": "def deallocate(<EOL>self, resource_group_name, vm_scale_set_name, instance_ids=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._deallocate_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_ids=instance_ids,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deallocates specific virtual machines in a VM scale set. Shuts down the\n        virtual machines and releases the compute resources. You are not billed\n        for the compute resources that this virtual machine scale set\n        deallocates.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_ids: The virtual machine scale set instance ids.\n         Omitting the virtual machine scale set instance ids will result in the\n         operation being performed on all virtual machines in the virtual\n         machine scale set.\n        :type instance_ids: list[str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24922:c0:m9"}
{"signature": "def redeploy(<EOL>self, resource_group_name, vm_scale_set_name, instance_ids=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._redeploy_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_ids=instance_ids,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Redeploy one or more virtual machines in a VM scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_ids: The virtual machine scale set instance ids.\n         Omitting the virtual machine scale set instance ids will result in the\n         operation being performed on all virtual machines in the virtual\n         machine scale set.\n        :type instance_ids: list[str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24922:c0:m24"}
{"signature": "def get(<EOL>self, resource_group_name, vm_scale_set_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vm_scale_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Display information about a virtual machine scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualMachineScaleSet or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.compute.v2018_06_01.models.VirtualMachineScaleSet\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24922:c0:m7"}
{"signature": "def cancel(<EOL>self, resource_group_name, vm_scale_set_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._cancel_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Cancels the current virtual machine scale set rolling upgrade.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24923:c0:m2"}
{"signature": "def start_extension_upgrade(<EOL>self, resource_group_name, vm_scale_set_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._start_extension_upgrade_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Starts a rolling upgrade to move all extensions for all virtual machine\n        scale set instances to the latest available extension version.\n        Instances which are already running the latest extension versions are\n        not affected.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24923:c0:m6"}
{"signature": "def update(<EOL>self, resource_group_name, disk_name, disk, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_initial(<EOL>resource_group_name=resource_group_name,<EOL>disk_name=disk_name,<EOL>disk=disk,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates (patches) a disk.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param disk_name: The name of the managed disk that is being created.\n         The name can't be changed after the disk is created. Supported\n         characters for the name are a-z, A-Z, 0-9 and _. The maximum name\n         length is 80 characters.\n        :type disk_name: str\n        :param disk: Disk object supplied in the body of the Patch disk\n         operation.\n        :type disk: ~azure.mgmt.compute.v2018_09_30.models.DiskUpdate\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Disk or\n         ClientRawResponse<Disk> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2018_09_30.models.Disk]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2018_09_30.models.Disk]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24954:c0:m4"}
{"signature": "def update(<EOL>self, resource_group_name, snapshot_name, snapshot, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_initial(<EOL>resource_group_name=resource_group_name,<EOL>snapshot_name=snapshot_name,<EOL>snapshot=snapshot,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates (patches) a snapshot.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param snapshot_name: The name of the snapshot that is being created.\n         The name can't be changed after the snapshot is created. Supported\n         characters for the name are a-z, A-Z, 0-9 and _. The max name length\n         is 80 characters.\n        :type snapshot_name: str\n        :param snapshot: Snapshot object supplied in the body of the Patch\n         snapshot operation.\n        :type snapshot: ~azure.mgmt.compute.v2018_09_30.models.SnapshotUpdate\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Snapshot or\n         ClientRawResponse<Snapshot> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2018_09_30.models.Snapshot]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2018_09_30.models.Snapshot]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24955:c0:m4"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SnapshotPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SnapshotPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists snapshots under a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Snapshot\n        :rtype:\n         ~azure.mgmt.compute.v2018_09_30.models.SnapshotPaged[~azure.mgmt.compute.v2018_09_30.models.Snapshot]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24955:c0:m9"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SnapshotPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SnapshotPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists snapshots under a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Snapshot\n        :rtype:\n         ~azure.mgmt.compute.v2018_09_30.models.SnapshotPaged[~azure.mgmt.compute.v2018_09_30.models.Snapshot]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24955:c0:m8"}
{"signature": "def delete(<EOL>self, resource_group_name, snapshot_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>snapshot_name=snapshot_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes a snapshot.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param snapshot_name: The name of the snapshot that is being created.\n         The name can't be changed after the snapshot is created. Supported\n         characters for the name are a-z, A-Z, 0-9 and _. The max name length\n         is 80 characters.\n        :type snapshot_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24955:c0:m7"}
{"signature": "def get(<EOL>self, resource_group_name, snapshot_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", snapshot_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about a snapshot.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param snapshot_name: The name of the snapshot that is being created.\n         The name can't be changed after the snapshot is created. Supported\n         characters for the name are a-z, A-Z, 0-9 and _. The max name length\n         is 80 characters.\n        :type snapshot_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Snapshot or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.compute.v2018_09_30.models.Snapshot or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f24955:c0:m5"}
{"signature": "def get(<EOL>self, location, publisher_name, type, version, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", publisher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT:type>': self._serialize.url(\"<STR_LIT:type>\", type, '<STR_LIT:str>'),<EOL>'<STR_LIT:version>': self._serialize.url(\"<STR_LIT:version>\", version, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a virtual machine extension image.\n\n        :param location: The name of a supported Azure region.\n        :type location: str\n        :param publisher_name:\n        :type publisher_name: str\n        :param type:\n        :type type: str\n        :param version:\n        :type version: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualMachineExtensionImage or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.compute.v2016_04_30_preview.models.VirtualMachineExtensionImage\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25113:c0:m1"}
{"signature": "def get_instance_view(<EOL>self, resource_group_name, vm_scale_set_name, instance_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_instance_view.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vm_scale_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", instance_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the status of a virtual machine from a VM scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_id: The instance ID of the virtual machine.\n        :type instance_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualMachineScaleSetVMInstanceView or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.compute.v2016_04_30_preview.models.VirtualMachineScaleSetVMInstanceView\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25114:c0:m10"}
{"signature": "def start(<EOL>self, resource_group_name, vm_scale_set_name, instance_id, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._start_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_id=instance_id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Starts a virtual machine in a VM scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_id: The instance ID of the virtual machine.\n        :type instance_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns OperationStatusResponse\n         or ClientRawResponse<OperationStatusResponse> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2016_04_30_preview.models.OperationStatusResponse]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2016_04_30_preview.models.OperationStatusResponse]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25114:c0:m17"}
{"signature": "def list(<EOL>self, resource_group_name, virtual_machine_scale_set_name, filter=None, select=None, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_machine_scale_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if select is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", select, '<STR_LIT:str>')<EOL><DEDENT>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualMachineScaleSetVMPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualMachineScaleSetVMPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of all virtual machines in a VM scale sets.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_machine_scale_set_name: The name of the VM scale set.\n        :type virtual_machine_scale_set_name: str\n        :param filter: The filter to apply to the operation.\n        :type filter: str\n        :param select: The list parameters.\n        :type select: str\n        :param expand: The expand expression to apply to the operation.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualMachineScaleSetVM\n        :rtype:\n         ~azure.mgmt.compute.v2016_04_30_preview.models.VirtualMachineScaleSetVMPaged[~azure.mgmt.compute.v2016_04_30_preview.models.VirtualMachineScaleSetVM]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25114:c0:m11"}
{"signature": "def restart(<EOL>self, resource_group_name, vm_scale_set_name, instance_id, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._restart_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_id=instance_id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Restarts a virtual machine in a VM scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_id: The instance ID of the virtual machine.\n        :type instance_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns OperationStatusResponse\n         or ClientRawResponse<OperationStatusResponse> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2016_04_30_preview.models.OperationStatusResponse]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2016_04_30_preview.models.OperationStatusResponse]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25114:c0:m15"}
{"signature": "def grant_access(<EOL>self, resource_group_name, disk_name, access, duration_in_seconds, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._grant_access_initial(<EOL>resource_group_name=resource_group_name,<EOL>disk_name=disk_name,<EOL>access=access,<EOL>duration_in_seconds=duration_in_seconds,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Grants access to a disk.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param disk_name: The name of the managed disk that is being created.\n         The name can't be changed after the disk is created. Supported\n         characters for the name are a-z, A-Z, 0-9 and _. The maximum name\n         length is 80 characters.\n        :type disk_name: str\n        :param access: Possible values include: 'None', 'Read'\n        :type access: str or\n         ~azure.mgmt.compute.v2016_04_30_preview.models.AccessLevel\n        :param duration_in_seconds: Time duration in seconds until the SAS\n         access expires.\n        :type duration_in_seconds: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns AccessUri or\n         ClientRawResponse<AccessUri> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2016_04_30_preview.models.AccessUri]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2016_04_30_preview.models.AccessUri]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25116:c0:m11"}
{"signature": "def restart(<EOL>self, resource_group_name, vm_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._restart_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_name=vm_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The operation to restart a virtual machine.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine.\n        :type vm_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns OperationStatusResponse\n         or ClientRawResponse<OperationStatusResponse> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2016_04_30_preview.models.OperationStatusResponse]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2016_04_30_preview.models.OperationStatusResponse]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25117:c0:m20"}
{"signature": "def capture(<EOL>self, resource_group_name, vm_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._capture_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_name=vm_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Captures the VM by copying virtual hard disks of the VM and outputs a\n        template that can be used to create similar VMs.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine.\n        :type vm_name: str\n        :param parameters: Parameters supplied to the Capture Virtual Machine\n         operation.\n        :type parameters:\n         ~azure.mgmt.compute.v2016_04_30_preview.models.VirtualMachineCaptureParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         VirtualMachineCaptureResult or\n         ClientRawResponse<VirtualMachineCaptureResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2016_04_30_preview.models.VirtualMachineCaptureResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2016_04_30_preview.models.VirtualMachineCaptureResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25117:c0:m3"}
{"signature": "def power_off(<EOL>self, resource_group_name, vm_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._power_off_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_name=vm_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The operation to power off (stop) a virtual machine. The virtual\n        machine can be restarted with the same provisioned resources. You are\n        still charged for this virtual machine.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine.\n        :type vm_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns OperationStatusResponse\n         or ClientRawResponse<OperationStatusResponse> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2016_04_30_preview.models.OperationStatusResponse]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2016_04_30_preview.models.OperationStatusResponse]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25117:c0:m18"}
{"signature": "def deallocate(<EOL>self, resource_group_name, vm_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._deallocate_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_name=vm_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Shuts down the virtual machine and releases the compute resources. You\n        are not billed for the compute resources that this virtual machine\n        uses.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine.\n        :type vm_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns OperationStatusResponse\n         or ClientRawResponse<OperationStatusResponse> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2016_04_30_preview.models.OperationStatusResponse]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2016_04_30_preview.models.OperationStatusResponse]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25117:c0:m12"}
{"signature": "def list_available_sizes(<EOL>self, resource_group_name, vm_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_available_sizes.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vm_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualMachineSizePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualMachineSizePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all available virtual machine sizes to which the specified\n        virtual machine can be resized.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine.\n        :type vm_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualMachineSize\n        :rtype:\n         ~azure.mgmt.compute.v2016_04_30_preview.models.VirtualMachineSizePaged[~azure.mgmt.compute.v2016_04_30_preview.models.VirtualMachineSize]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25117:c0:m16"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualMachinePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualMachinePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all of the virtual machines in the specified subscription. Use\n        the nextLink property in the response to get the next page of virtual\n        machines.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualMachine\n        :rtype:\n         ~azure.mgmt.compute.v2016_04_30_preview.models.VirtualMachinePaged[~azure.mgmt.compute.v2016_04_30_preview.models.VirtualMachine]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25117:c0:m15"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, snapshot_name, snapshot, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>snapshot_name=snapshot_name,<EOL>snapshot=snapshot,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a snapshot.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param snapshot_name: The name of the snapshot within the given\n         subscription and resource group.\n        :type snapshot_name: str\n        :param snapshot: Snapshot object supplied in the body of the Put disk\n         operation.\n        :type snapshot:\n         ~azure.mgmt.compute.v2016_04_30_preview.models.Snapshot\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Snapshot or\n         ClientRawResponse<Snapshot> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2016_04_30_preview.models.Snapshot]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2016_04_30_preview.models.Snapshot]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25119:c0:m2"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SnapshotPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SnapshotPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists snapshots under a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Snapshot\n        :rtype:\n         ~azure.mgmt.compute.v2016_04_30_preview.models.SnapshotPaged[~azure.mgmt.compute.v2016_04_30_preview.models.Snapshot]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25119:c0:m9"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.AvailabilitySetPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.AvailabilitySetPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all availability sets in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of AvailabilitySet\n        :rtype:\n         ~azure.mgmt.compute.v2016_04_30_preview.models.AvailabilitySetPaged[~azure.mgmt.compute.v2016_04_30_preview.models.AvailabilitySet]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25124:c0:m5"}
{"signature": "def start(<EOL>self, resource_group_name, vm_scale_set_name, instance_ids=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._start_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_ids=instance_ids,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Starts one or more virtual machines in a VM scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_ids: The virtual machine scale set instance ids.\n         Omitting the virtual machine scale set instance ids will result in the\n         operation being performed on all virtual machines in the virtual\n         machine scale set.\n        :type instance_ids: list[str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns OperationStatusResponse\n         or ClientRawResponse<OperationStatusResponse> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2016_04_30_preview.models.OperationStatusResponse]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2016_04_30_preview.models.OperationStatusResponse]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25125:c0:m19"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualMachineScaleSetPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualMachineScaleSetPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of all VM Scale Sets in the subscription, regardless of the\n        associated resource group. Use nextLink property in the response to get\n        the next page of VM Scale Sets. Do this till nextLink is null to fetch\n        all the VM Scale Sets.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualMachineScaleSet\n        :rtype:\n         ~azure.mgmt.compute.v2016_04_30_preview.models.VirtualMachineScaleSetPaged[~azure.mgmt.compute.v2016_04_30_preview.models.VirtualMachineScaleSet]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25125:c0:m12"}
{"signature": "def get_instance_view(<EOL>self, resource_group_name, vm_scale_set_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_instance_view.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vm_scale_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the status of a VM scale set instance.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualMachineScaleSetInstanceView or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.compute.v2016_04_30_preview.models.VirtualMachineScaleSetInstanceView\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25125:c0:m10"}
{"signature": "def get(<EOL>self, resource_group_name, vm_scale_set_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vm_scale_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Display information about a virtual machine scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualMachineScaleSet or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.compute.v2016_04_30_preview.models.VirtualMachineScaleSet\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25125:c0:m5"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>name=name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Create or update a VM scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param name: The name of the VM scale set to create or update.\n        :type name: str\n        :param parameters: The scale set object.\n        :type parameters:\n         ~azure.mgmt.compute.v2016_04_30_preview.models.VirtualMachineScaleSet\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualMachineScaleSet\n         or ClientRawResponse<VirtualMachineScaleSet> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2016_04_30_preview.models.VirtualMachineScaleSet]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2016_04_30_preview.models.VirtualMachineScaleSet]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25125:c0:m2"}
{"signature": "def list_types(<EOL>self, location, publisher_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_types.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", publisher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of virtual machine extension image types.\n\n        :param location: The name of a supported Azure region.\n        :type location: str\n        :param publisher_name:\n        :type publisher_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype:\n         list[~azure.mgmt.compute.v2019_03_01.models.VirtualMachineExtensionImage]\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25369:c0:m2"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.GalleryPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.GalleryPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List galleries under a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Gallery\n        :rtype:\n         ~azure.mgmt.compute.v2019_03_01.models.GalleryPaged[~azure.mgmt.compute.v2019_03_01.models.Gallery]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25371:c0:m6"}
{"signature": "def get(<EOL>self, resource_group_name, vm_scale_set_name, instance_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vm_scale_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", instance_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a virtual machine from a VM scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_id: The instance ID of the virtual machine.\n        :type instance_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualMachineScaleSetVM or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.compute.v2019_03_01.models.VirtualMachineScaleSetVM or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25372:c0:m11"}
{"signature": "def reimage_all(<EOL>self, resource_group_name, vm_scale_set_name, instance_id, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._reimage_all_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_id=instance_id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Allows you to re-image all the disks ( including data disks ) in the a\n        VM scale set instance. This operation is only supported for managed\n        disks.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_id: The instance ID of the virtual machine.\n        :type instance_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25372:c0:m4"}
{"signature": "def power_off(<EOL>self, resource_group_name, vm_scale_set_name, instance_id, skip_shutdown=False, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._power_off_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_id=instance_id,<EOL>skip_shutdown=skip_shutdown,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Power off (stop) a virtual machine in a VM scale set. Note that\n        resources are still attached and you are getting charged for the\n        resources. Instead, use deallocate to release resources and avoid\n        charges.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_id: The instance ID of the virtual machine.\n        :type instance_id: str\n        :param skip_shutdown: The parameter to request non-graceful VM\n         shutdown. True value for this flag indicates non-graceful shutdown\n         whereas false indicates otherwise. Default value for this flag is\n         false if not specified\n        :type skip_shutdown: bool\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25372:c0:m15"}
{"signature": "def perform_maintenance(<EOL>self, resource_group_name, vm_scale_set_name, instance_id, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._perform_maintenance_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_id=instance_id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Performs maintenance on a virtual machine in a VM scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_id: The instance ID of the virtual machine.\n        :type instance_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25372:c0:m23"}
{"signature": "def run_command(<EOL>self, resource_group_name, vm_scale_set_name, instance_id, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._run_command_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_id=instance_id,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT:location>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Run command on a virtual machine in a VM scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_id: The instance ID of the virtual machine.\n        :type instance_id: str\n        :param parameters: Parameters supplied to the Run command operation.\n        :type parameters:\n         ~azure.mgmt.compute.v2019_03_01.models.RunCommandInput\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns RunCommandResult or\n         ClientRawResponse<RunCommandResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2019_03_01.models.RunCommandResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2019_03_01.models.RunCommandResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25372:c0:m25"}
{"signature": "def get(<EOL>self, location, publisher_name, offer, skus, version, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", publisher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", offer, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", skus, '<STR_LIT:str>'),<EOL>'<STR_LIT:version>': self._serialize.url(\"<STR_LIT:version>\", version, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a virtual machine image.\n\n        :param location: The name of a supported Azure region.\n        :type location: str\n        :param publisher_name: A valid image publisher.\n        :type publisher_name: str\n        :param offer: A valid image publisher offer.\n        :type offer: str\n        :param skus: A valid image SKU.\n        :type skus: str\n        :param version: A valid image SKU version.\n        :type version: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualMachineImage or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.compute.v2019_03_01.models.VirtualMachineImage or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25373:c0:m1"}
{"signature": "def perform_maintenance(<EOL>self, resource_group_name, vm_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._perform_maintenance_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_name=vm_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The operation to perform maintenance on a virtual machine.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine.\n        :type vm_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25374:c0:m31"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualMachinePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualMachinePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all of the virtual machines in the specified subscription. Use\n        the nextLink property in the response to get the next page of virtual\n        machines.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualMachine\n        :rtype:\n         ~azure.mgmt.compute.v2019_03_01.models.VirtualMachinePaged[~azure.mgmt.compute.v2019_03_01.models.VirtualMachine]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25374:c0:m18"}
{"signature": "def deallocate(<EOL>self, resource_group_name, vm_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._deallocate_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_name=vm_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Shuts down the virtual machine and releases the compute resources. You\n        are not billed for the compute resources that this virtual machine\n        uses.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine.\n        :type vm_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25374:c0:m15"}
{"signature": "def instance_view(<EOL>self, resource_group_name, vm_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.instance_view.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vm_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves information about the run-time state of a virtual machine.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine.\n        :type vm_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualMachineInstanceView or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.compute.v2019_03_01.models.VirtualMachineInstanceView or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25374:c0:m11"}
{"signature": "def restart(<EOL>self, resource_group_name, vm_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._restart_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_name=vm_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The operation to restart a virtual machine.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine.\n        :type vm_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25374:c0:m23"}
{"signature": "def update(<EOL>self, resource_group_name, vm_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_name=vm_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The operation to update a virtual machine.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine.\n        :type vm_name: str\n        :param parameters: Parameters supplied to the Update Virtual Machine\n         operation.\n        :type parameters:\n         ~azure.mgmt.compute.v2019_03_01.models.VirtualMachineUpdate\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualMachine or\n         ClientRawResponse<VirtualMachine> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2019_03_01.models.VirtualMachine]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2019_03_01.models.VirtualMachine]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25374:c0:m7"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, vm_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_name=vm_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The operation to create or update a virtual machine.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine.\n        :type vm_name: str\n        :param parameters: Parameters supplied to the Create Virtual Machine\n         operation.\n        :type parameters:\n         ~azure.mgmt.compute.v2019_03_01.models.VirtualMachine\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualMachine or\n         ClientRawResponse<VirtualMachine> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2019_03_01.models.VirtualMachine]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2019_03_01.models.VirtualMachine]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25374:c0:m5"}
{"signature": "def get(<EOL>self, resource_group_name, gallery_name, gallery_image_name, gallery_image_version_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", gallery_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", gallery_image_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", gallery_image_version_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves information about a gallery Image Version.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param gallery_name: The name of the Shared Image Gallery in which the\n         Image Definition resides.\n        :type gallery_name: str\n        :param gallery_image_name: The name of the gallery Image Definition in\n         which the Image Version resides.\n        :type gallery_image_name: str\n        :param gallery_image_version_name: The name of the gallery Image\n         Version to be retrieved.\n        :type gallery_image_version_name: str\n        :param expand: The expand expression to apply on the operation.\n         Possible values include: 'ReplicationStatus'\n        :type expand: str or\n         ~azure.mgmt.compute.v2019_03_01.models.ReplicationStatusTypes\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: GalleryImageVersion or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.compute.v2019_03_01.models.GalleryImageVersion or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25375:c0:m3"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ProximityPlacementGroupPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ProximityPlacementGroupPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all proximity placement groups in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ProximityPlacementGroup\n        :rtype:\n         ~azure.mgmt.compute.v2019_03_01.models.ProximityPlacementGroupPaged[~azure.mgmt.compute.v2019_03_01.models.ProximityPlacementGroup]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25378:c0:m6"}
{"signature": "def delete(<EOL>self, resource_group_name, proximity_placement_group_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", proximity_placement_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Delete a proximity placement group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param proximity_placement_group_name: The name of the proximity\n         placement group.\n        :type proximity_placement_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25378:c0:m3"}
{"signature": "def list_by_subscription(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_subscription.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ProximityPlacementGroupPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ProximityPlacementGroupPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all proximity placement groups in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ProximityPlacementGroup\n        :rtype:\n         ~azure.mgmt.compute.v2019_03_01.models.ProximityPlacementGroupPaged[~azure.mgmt.compute.v2019_03_01.models.ProximityPlacementGroup]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25378:c0:m5"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, vm_scale_set_name, vmss_extension_name, extension_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>vmss_extension_name=vmss_extension_name,<EOL>extension_parameters=extension_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The operation to create or update an extension.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set where the\n         extension should be create or updated.\n        :type vm_scale_set_name: str\n        :param vmss_extension_name: The name of the VM scale set extension.\n        :type vmss_extension_name: str\n        :param extension_parameters: Parameters supplied to the Create VM\n         scale set Extension operation.\n        :type extension_parameters:\n         ~azure.mgmt.compute.v2019_03_01.models.VirtualMachineScaleSetExtension\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         VirtualMachineScaleSetExtension or\n         ClientRawResponse<VirtualMachineScaleSetExtension> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2019_03_01.models.VirtualMachineScaleSetExtension]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2019_03_01.models.VirtualMachineScaleSetExtension]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25380:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, vm_scale_set_name, vmss_extension_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>vmss_extension_name=vmss_extension_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The operation to delete the extension.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set where the\n         extension should be deleted.\n        :type vm_scale_set_name: str\n        :param vmss_extension_name: The name of the VM scale set extension.\n        :type vmss_extension_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25380:c0:m4"}
{"signature": "def delete(<EOL>self, resource_group_name, gallery_name, gallery_image_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>gallery_name=gallery_name,<EOL>gallery_image_name=gallery_image_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Delete a gallery image.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param gallery_name: The name of the Shared Image Gallery in which the\n         Image Definition is to be deleted.\n        :type gallery_name: str\n        :param gallery_image_name: The name of the gallery Image Definition to\n         be deleted.\n        :type gallery_image_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25383:c0:m5"}
{"signature": "def get(<EOL>self, location, command_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>', pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", command_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets specific run command for a subscription in a location.\n\n        :param location: The location upon which run commands is queried.\n        :type location: str\n        :param command_id: The command id.\n        :type command_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RunCommandDocument or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.compute.v2019_03_01.models.RunCommandDocument or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25384:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, availability_set_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", availability_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Delete an availability set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param availability_set_name: The name of the availability set.\n        :type availability_set_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25386:c0:m3"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.AvailabilitySetPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.AvailabilitySetPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all availability sets in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of AvailabilitySet\n        :rtype:\n         ~azure.mgmt.compute.v2019_03_01.models.AvailabilitySetPaged[~azure.mgmt.compute.v2019_03_01.models.AvailabilitySet]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25386:c0:m6"}
{"signature": "def list_by_subscription(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_subscription.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.AvailabilitySetPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.AvailabilitySetPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all availability sets in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of AvailabilitySet\n        :rtype:\n         ~azure.mgmt.compute.v2019_03_01.models.AvailabilitySetPaged[~azure.mgmt.compute.v2019_03_01.models.AvailabilitySet]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25386:c0:m5"}
{"signature": "def reimage_all(<EOL>self, resource_group_name, vm_scale_set_name, instance_ids=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._reimage_all_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_ids=instance_ids,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Reimages all the disks ( including data disks ) in the virtual machines\n        in a VM scale set. This operation is only supported for managed disks.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_ids: The virtual machine scale set instance ids.\n         Omitting the virtual machine scale set instance ids will result in the\n         operation being performed on all virtual machines in the virtual\n         machine scale set.\n        :type instance_ids: list[str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25387:c0:m32"}
{"signature": "def update_instances(<EOL>self, resource_group_name, vm_scale_set_name, instance_ids, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_instances_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_ids=instance_ids,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Upgrades one or more virtual machines to the latest SKU set in the VM\n        scale set model.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_ids: The virtual machine scale set instance ids.\n        :type instance_ids: list[str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25387:c0:m28"}
{"signature": "def convert_to_single_placement_group(<EOL>self, resource_group_name, vm_scale_set_name, active_placement_group_id=None, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.VMScaleSetConvertToSinglePlacementGroupInput(active_placement_group_id=active_placement_group_id)<EOL>url = self.convert_to_single_placement_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vm_scale_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Converts SinglePlacementGroup property to false for a existing virtual\n        machine scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the virtual machine scale set to\n         create or update.\n        :type vm_scale_set_name: str\n        :param active_placement_group_id: Id of the placement group in which\n         you want future virtual machine instances to be placed. To query\n         placement group Id, please use Virtual Machine Scale Set VMs - Get\n         API. If not provided, the platform will choose one with maximum number\n         of virtual machine instances.\n        :type active_placement_group_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25387:c0:m34"}
{"signature": "def power_off(<EOL>self, resource_group_name, vm_scale_set_name, skip_shutdown=False, instance_ids=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._power_off_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>skip_shutdown=skip_shutdown,<EOL>instance_ids=instance_ids,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Power off (stop) one or more virtual machines in a VM scale set. Note\n        that resources are still attached and you are getting charged for the\n        resources. Instead, use deallocate to release resources and avoid\n        charges.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param skip_shutdown: The parameter to request non-graceful VM\n         shutdown. True value for this flag indicates non-graceful shutdown\n         whereas false indicates otherwise. Default value for this flag is\n         false if not specified\n        :type skip_shutdown: bool\n        :param instance_ids: The virtual machine scale set instance ids.\n         Omitting the virtual machine scale set instance ids will result in the\n         operation being performed on all virtual machines in the virtual\n         machine scale set.\n        :type instance_ids: list[str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25387:c0:m18"}
{"signature": "def reimage(<EOL>self, resource_group_name, vm_scale_set_name, temp_disk=None, instance_ids=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._reimage_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>temp_disk=temp_disk,<EOL>instance_ids=instance_ids,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Reimages (upgrade the operating system) one or more virtual machines in\n        a VM scale set which don't have a ephemeral OS disk, for virtual\n        machines who have a ephemeral OS disk the virtual machine is reset to\n        initial state.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param temp_disk: Specifies whether to reimage temp disk. Default\n         value: false.\n        :type temp_disk: bool\n        :param instance_ids: The virtual machine scale set instance ids.\n         Omitting the virtual machine scale set instance ids will result in the\n         operation being performed on all virtual machines in the virtual\n         machine scale set.\n        :type instance_ids: list[str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25387:c0:m30"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualMachineScaleSetPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualMachineScaleSetPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of all VM Scale Sets in the subscription, regardless of the\n        associated resource group. Use nextLink property in the response to get\n        the next page of VM Scale Sets. Do this till nextLink is null to fetch\n        all the VM Scale Sets.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualMachineScaleSet\n        :rtype:\n         ~azure.mgmt.compute.v2019_03_01.models.VirtualMachineScaleSetPaged[~azure.mgmt.compute.v2019_03_01.models.VirtualMachineScaleSet]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25387:c0:m14"}
{"signature": "def start_extension_upgrade(<EOL>self, resource_group_name, vm_scale_set_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._start_extension_upgrade_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Starts a rolling upgrade to move all extensions for all virtual machine\n        scale set instances to the latest available extension version.\n        Instances which are already running the latest extension versions are\n        not affected.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25388:c0:m6"}
{"signature": "def get(<EOL>self, location, publisher_name, type, version, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", publisher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT:type>': self._serialize.url(\"<STR_LIT:type>\", type, '<STR_LIT:str>'),<EOL>'<STR_LIT:version>': self._serialize.url(\"<STR_LIT:version>\", version, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a virtual machine extension image.\n\n        :param location: The name of a supported Azure region.\n        :type location: str\n        :param publisher_name:\n        :type publisher_name: str\n        :param type:\n        :type type: str\n        :param version:\n        :type version: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualMachineExtensionImage or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.compute.v2016_03_30.models.VirtualMachineExtensionImage or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25507:c0:m1"}
{"signature": "def list_publishers(<EOL>self, location, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_publishers.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of virtual machine image publishers for the specified Azure\n        location.\n\n        :param location: The name of a supported Azure region.\n        :type location: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype:\n         list[~azure.mgmt.compute.v2016_03_30.models.VirtualMachineImageResource]\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25509:c0:m4"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualMachinePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualMachinePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all of the virtual machines in the specified subscription. Use\n        the nextLink property in the response to get the next page of virtual\n        machines.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualMachine\n        :rtype:\n         ~azure.mgmt.compute.v2016_03_30.models.VirtualMachinePaged[~azure.mgmt.compute.v2016_03_30.models.VirtualMachine]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25510:c0:m13"}
{"signature": "def get(<EOL>self, resource_group_name, vm_name, vm_extension_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vm_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vm_extension_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "The operation to get the extension.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine containing the\n         extension.\n        :type vm_name: str\n        :param vm_extension_name: The name of the virtual machine extension.\n        :type vm_extension_name: str\n        :param expand: The expand expression to apply on the operation.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualMachineExtension or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.compute.v2016_03_30.models.VirtualMachineExtension\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25511:c0:m7"}
{"signature": "def delete(<EOL>self, resource_group_name, vm_name, vm_extension_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_name=vm_name,<EOL>vm_extension_name=vm_extension_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The operation to delete the extension.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine where the extension\n         should be deleted.\n        :type vm_name: str\n        :param vm_extension_name: The name of the virtual machine extension.\n        :type vm_extension_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns OperationStatusResponse\n         or ClientRawResponse<OperationStatusResponse> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2016_03_30.models.OperationStatusResponse]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2016_03_30.models.OperationStatusResponse]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25511:c0:m6"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.AvailabilitySetPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.AvailabilitySetPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all availability sets in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of AvailabilitySet\n        :rtype:\n         ~azure.mgmt.compute.v2016_03_30.models.AvailabilitySetPaged[~azure.mgmt.compute.v2016_03_30.models.AvailabilitySet]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25515:c0:m5"}
{"signature": "def list_available_sizes(<EOL>self, resource_group_name, availability_set_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_available_sizes.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", availability_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualMachineSizePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualMachineSizePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all available virtual machine sizes that can be used to create a\n        new virtual machine in an existing availability set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param availability_set_name: The name of the availability set.\n        :type availability_set_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualMachineSize\n        :rtype:\n         ~azure.mgmt.compute.v2016_03_30.models.VirtualMachineSizePaged[~azure.mgmt.compute.v2016_03_30.models.VirtualMachineSize]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25515:c0:m6"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>name=name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Create or update a VM scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param name: The name of the VM scale set to create or update.\n        :type name: str\n        :param parameters: The scale set object.\n        :type parameters:\n         ~azure.mgmt.compute.v2016_03_30.models.VirtualMachineScaleSet\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualMachineScaleSet\n         or ClientRawResponse<VirtualMachineScaleSet> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2016_03_30.models.VirtualMachineScaleSet]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2016_03_30.models.VirtualMachineScaleSet]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25516:c0:m2"}
{"signature": "def get_instance_view(<EOL>self, resource_group_name, vm_scale_set_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_instance_view.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vm_scale_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the status of a VM scale set instance.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualMachineScaleSetInstanceView or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.compute.v2016_03_30.models.VirtualMachineScaleSetInstanceView\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25516:c0:m10"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualMachineScaleSetPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualMachineScaleSetPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of all VM Scale Sets in the subscription, regardless of the\n        associated resource group. Use nextLink property in the response to get\n        the next page of VM Scale Sets. Do this till nextLink is null to fetch\n        all the VM Scale Sets.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualMachineScaleSet\n        :rtype:\n         ~azure.mgmt.compute.v2016_03_30.models.VirtualMachineScaleSetPaged[~azure.mgmt.compute.v2016_03_30.models.VirtualMachineScaleSet]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25516:c0:m12"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualMachineScaleSetPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualMachineScaleSetPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of all VM scale sets under a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualMachineScaleSet\n        :rtype:\n         ~azure.mgmt.compute.v2016_03_30.models.VirtualMachineScaleSetPaged[~azure.mgmt.compute.v2016_03_30.models.VirtualMachineScaleSet]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25516:c0:m11"}
{"signature": "def delete(<EOL>self, resource_group_name, vm_scale_set_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes a VM scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns OperationStatusResponse\n         or ClientRawResponse<OperationStatusResponse> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2016_03_30.models.OperationStatusResponse]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2016_03_30.models.OperationStatusResponse]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25516:c0:m4"}
{"signature": "def delete_instances(<EOL>self, resource_group_name, vm_scale_set_name, instance_ids, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_instances_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_ids=instance_ids,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes virtual machines in a VM scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_ids: The virtual machine scale set instance ids.\n        :type instance_ids: list[str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns OperationStatusResponse\n         or ClientRawResponse<OperationStatusResponse> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2016_03_30.models.OperationStatusResponse]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2016_03_30.models.OperationStatusResponse]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25516:c0:m9"}
{"signature": "def update_instances(<EOL>self, resource_group_name, vm_scale_set_name, instance_ids, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_instances_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_ids=instance_ids,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Upgrades one or more virtual machines to the latest SKU set in the VM\n        scale set model.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_ids: The virtual machine scale set instance ids.\n        :type instance_ids: list[str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns OperationStatusResponse\n         or ClientRawResponse<OperationStatusResponse> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2016_03_30.models.OperationStatusResponse]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2016_03_30.models.OperationStatusResponse]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25516:c0:m21"}
{"signature": "def get(<EOL>self, location, publisher_name, type, version, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", publisher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT:type>': self._serialize.url(\"<STR_LIT:type>\", type, '<STR_LIT:str>'),<EOL>'<STR_LIT:version>': self._serialize.url(\"<STR_LIT:version>\", version, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a virtual machine extension image.\n\n        :param location: The name of a supported Azure region.\n        :type location: str\n        :param publisher_name:\n        :type publisher_name: str\n        :param type:\n        :type type: str\n        :param version:\n        :type version: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualMachineExtensionImage or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.compute.v2018_04_01.models.VirtualMachineExtensionImage or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25730:c0:m1"}
{"signature": "def run_command(<EOL>self, resource_group_name, vm_scale_set_name, instance_id, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._run_command_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_id=instance_id,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT:location>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Run command on a virtual machine in a VM scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_id: The instance ID of the virtual machine.\n        :type instance_id: str\n        :param parameters: Parameters supplied to the Run command operation.\n        :type parameters:\n         ~azure.mgmt.compute.v2018_04_01.models.RunCommandInput\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns RunCommandResult or\n         ClientRawResponse<RunCommandResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2018_04_01.models.RunCommandResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2018_04_01.models.RunCommandResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25732:c0:m25"}
{"signature": "def power_off(<EOL>self, resource_group_name, vm_scale_set_name, instance_id, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._power_off_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_id=instance_id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Power off (stop) a virtual machine in a VM scale set. Note that\n        resources are still attached and you are getting charged for the\n        resources. Instead, use deallocate to release resources and avoid\n        charges.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_id: The instance ID of the virtual machine.\n        :type instance_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25732:c0:m15"}
{"signature": "def list_skus(<EOL>self, location, publisher_name, offer, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_skus.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", publisher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", offer, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of virtual machine image SKUs for the specified location,\n        publisher, and offer.\n\n        :param location: The name of a supported Azure region.\n        :type location: str\n        :param publisher_name: A valid image publisher.\n        :type publisher_name: str\n        :param offer: A valid image publisher offer.\n        :type offer: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype:\n         list[~azure.mgmt.compute.v2018_04_01.models.VirtualMachineImageResource]\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25733:c0:m5"}
{"signature": "def list_publishers(<EOL>self, location, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_publishers.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of virtual machine image publishers for the specified Azure\n        location.\n\n        :param location: The name of a supported Azure region.\n        :type location: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype:\n         list[~azure.mgmt.compute.v2018_04_01.models.VirtualMachineImageResource]\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25733:c0:m4"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.DiskPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.DiskPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all the disks under a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Disk\n        :rtype:\n         ~azure.mgmt.compute.v2018_04_01.models.DiskPaged[~azure.mgmt.compute.v2018_04_01.models.Disk]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25734:c0:m8"}
{"signature": "def delete(<EOL>self, resource_group_name, disk_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>disk_name=disk_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes a disk.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param disk_name: The name of the managed disk that is being created.\n         The name can't be changed after the disk is created. Supported\n         characters for the name are a-z, A-Z, 0-9 and _. The maximum name\n         length is 80 characters.\n        :type disk_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25734:c0:m7"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, disk_name, disk, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>disk_name=disk_name,<EOL>disk=disk,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a disk.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param disk_name: The name of the managed disk that is being created.\n         The name can't be changed after the disk is created. Supported\n         characters for the name are a-z, A-Z, 0-9 and _. The maximum name\n         length is 80 characters.\n        :type disk_name: str\n        :param disk: Disk object supplied in the body of the Put disk\n         operation.\n        :type disk: ~azure.mgmt.compute.v2018_04_01.models.Disk\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Disk or\n         ClientRawResponse<Disk> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2018_04_01.models.Disk]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2018_04_01.models.Disk]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25734:c0:m2"}
{"signature": "def revoke_access(<EOL>self, resource_group_name, disk_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._revoke_access_initial(<EOL>resource_group_name=resource_group_name,<EOL>disk_name=disk_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT:location>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Revokes access to a disk.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param disk_name: The name of the managed disk that is being created.\n         The name can't be changed after the disk is created. Supported\n         characters for the name are a-z, A-Z, 0-9 and _. The maximum name\n         length is 80 characters.\n        :type disk_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25734:c0:m13"}
{"signature": "def redeploy(<EOL>self, resource_group_name, vm_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._redeploy_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_name=vm_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The operation to redeploy a virtual machine.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine.\n        :type vm_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25735:c0:m27"}
{"signature": "def get(<EOL>self, resource_group_name, vm_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vm_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves information about the model view or the instance view of a\n        virtual machine.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine.\n        :type vm_name: str\n        :param expand: The expand expression to apply on the operation.\n         Possible values include: 'instanceView'\n        :type expand: str or\n         ~azure.mgmt.compute.v2018_04_01.models.InstanceViewTypes\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualMachine or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.compute.v2018_04_01.models.VirtualMachine or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25735:c0:m10"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualMachinePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualMachinePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all of the virtual machines in the specified resource group. Use\n        the nextLink property in the response to get the next page of virtual\n        machines.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualMachine\n        :rtype:\n         ~azure.mgmt.compute.v2018_04_01.models.VirtualMachinePaged[~azure.mgmt.compute.v2018_04_01.models.VirtualMachine]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25735:c0:m17"}
{"signature": "def power_off(<EOL>self, resource_group_name, vm_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._power_off_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_name=vm_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The operation to power off (stop) a virtual machine. The virtual\n        machine can be restarted with the same provisioned resources. You are\n        still charged for this virtual machine.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine.\n        :type vm_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25735:c0:m21"}
{"signature": "def delete(<EOL>self, resource_group_name, vm_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_name=vm_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The operation to delete a virtual machine.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine.\n        :type vm_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25735:c0:m9"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, vm_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_name=vm_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The operation to create or update a virtual machine.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine.\n        :type vm_name: str\n        :param parameters: Parameters supplied to the Create Virtual Machine\n         operation.\n        :type parameters:\n         ~azure.mgmt.compute.v2018_04_01.models.VirtualMachine\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualMachine or\n         ClientRawResponse<VirtualMachine> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2018_04_01.models.VirtualMachine]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2018_04_01.models.VirtualMachine]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25735:c0:m5"}
{"signature": "def convert_to_managed_disks(<EOL>self, resource_group_name, vm_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._convert_to_managed_disks_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_name=vm_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Converts virtual machine disks from blob-based to managed disks.\n        Virtual machine must be stop-deallocated before invoking this\n        operation.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine.\n        :type vm_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25735:c0:m13"}
{"signature": "def get(<EOL>self, resource_group_name, vm_name, vm_extension_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vm_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vm_extension_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "The operation to get the extension.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine containing the\n         extension.\n        :type vm_name: str\n        :param vm_extension_name: The name of the virtual machine extension.\n        :type vm_extension_name: str\n        :param expand: The expand expression to apply on the operation.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualMachineExtension or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.compute.v2018_04_01.models.VirtualMachineExtension\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25736:c0:m7"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ImagePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ImagePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the list of images under a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Image\n        :rtype:\n         ~azure.mgmt.compute.v2018_04_01.models.ImagePaged[~azure.mgmt.compute.v2018_04_01.models.Image]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25738:c0:m8"}
{"signature": "def list_by_subscription(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_subscription.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ProximityPlacementGroupPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ProximityPlacementGroupPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all proximity placement groups in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ProximityPlacementGroup\n        :rtype:\n         ~azure.mgmt.compute.v2018_04_01.models.ProximityPlacementGroupPaged[~azure.mgmt.compute.v2018_04_01.models.ProximityPlacementGroup]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25739:c0:m5"}
{"signature": "def list(<EOL>self, location, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>', pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.UsagePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.UsagePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets, for the specified location, the current compute resource usage\n        information as well as the limits for compute resources under the\n        subscription.\n\n        :param location: The location for which resource usage is queried.\n        :type location: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Usage\n        :rtype:\n         ~azure.mgmt.compute.v2018_04_01.models.UsagePaged[~azure.mgmt.compute.v2018_04_01.models.Usage]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25740:c0:m1"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, vm_scale_set_name, vmss_extension_name, extension_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>vmss_extension_name=vmss_extension_name,<EOL>extension_parameters=extension_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The operation to create or update an extension.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set where the\n         extension should be create or updated.\n        :type vm_scale_set_name: str\n        :param vmss_extension_name: The name of the VM scale set extension.\n        :type vmss_extension_name: str\n        :param extension_parameters: Parameters supplied to the Create VM\n         scale set Extension operation.\n        :type extension_parameters:\n         ~azure.mgmt.compute.v2018_04_01.models.VirtualMachineScaleSetExtension\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         VirtualMachineScaleSetExtension or\n         ClientRawResponse<VirtualMachineScaleSetExtension> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2018_04_01.models.VirtualMachineScaleSetExtension]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2018_04_01.models.VirtualMachineScaleSetExtension]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25741:c0:m2"}
{"signature": "def list(<EOL>self, location, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>', pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RunCommandDocumentBasePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RunCommandDocumentBasePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all available run commands for a subscription in a location.\n\n        :param location: The location upon which run commands is queried.\n        :type location: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of RunCommandDocumentBase\n        :rtype:\n         ~azure.mgmt.compute.v2018_04_01.models.RunCommandDocumentBasePaged[~azure.mgmt.compute.v2018_04_01.models.RunCommandDocumentBase]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25744:c0:m1"}
{"signature": "def export_throttled_requests(<EOL>self, parameters, location, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._export_throttled_requests_initial(<EOL>parameters=parameters,<EOL>location=location,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Export logs that show total throttled Api requests for this\n        subscription in the given time window.\n\n        :param parameters: Parameters supplied to the LogAnalytics\n         getThrottledRequests Api.\n        :type parameters:\n         ~azure.mgmt.compute.v2018_04_01.models.ThrottledRequestsInput\n        :param location: The location upon which virtual-machine-sizes is\n         queried.\n        :type location: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         LogAnalyticsOperationResult or\n         ClientRawResponse<LogAnalyticsOperationResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2018_04_01.models.LogAnalyticsOperationResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2018_04_01.models.LogAnalyticsOperationResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25745:c0:m4"}
{"signature": "def list_by_subscription(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_subscription.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.AvailabilitySetPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.AvailabilitySetPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all availability sets in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of AvailabilitySet\n        :rtype:\n         ~azure.mgmt.compute.v2018_04_01.models.AvailabilitySetPaged[~azure.mgmt.compute.v2018_04_01.models.AvailabilitySet]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25746:c0:m5"}
{"signature": "def delete(<EOL>self, resource_group_name, availability_set_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", availability_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Delete an availability set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param availability_set_name: The name of the availability set.\n        :type availability_set_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25746:c0:m3"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualMachineScaleSetPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualMachineScaleSetPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of all VM Scale Sets in the subscription, regardless of the\n        associated resource group. Use nextLink property in the response to get\n        the next page of VM Scale Sets. Do this till nextLink is null to fetch\n        all the VM Scale Sets.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualMachineScaleSet\n        :rtype:\n         ~azure.mgmt.compute.v2018_04_01.models.VirtualMachineScaleSetPaged[~azure.mgmt.compute.v2018_04_01.models.VirtualMachineScaleSet]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25747:c0:m14"}
{"signature": "def start(<EOL>self, resource_group_name, vm_scale_set_name, instance_ids=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._start_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_ids=instance_ids,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Starts one or more virtual machines in a VM scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_ids: The virtual machine scale set instance ids.\n         Omitting the virtual machine scale set instance ids will result in the\n         operation being performed on all virtual machines in the virtual\n         machine scale set.\n        :type instance_ids: list[str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25747:c0:m22"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualMachineScaleSetPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualMachineScaleSetPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of all VM scale sets under a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualMachineScaleSet\n        :rtype:\n         ~azure.mgmt.compute.v2018_04_01.models.VirtualMachineScaleSetPaged[~azure.mgmt.compute.v2018_04_01.models.VirtualMachineScaleSet]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25747:c0:m13"}
{"signature": "def delete_instances(<EOL>self, resource_group_name, vm_scale_set_name, instance_ids, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_instances_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_ids=instance_ids,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes virtual machines in a VM scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_ids: The virtual machine scale set instance ids.\n        :type instance_ids: list[str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25747:c0:m11"}
{"signature": "def redeploy(<EOL>self, resource_group_name, vm_scale_set_name, instance_ids=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._redeploy_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_ids=instance_ids,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Redeploy one or more virtual machines in a VM scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_ids: The virtual machine scale set instance ids.\n         Omitting the virtual machine scale set instance ids will result in the\n         operation being performed on all virtual machines in the virtual\n         machine scale set.\n        :type instance_ids: list[str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25747:c0:m24"}
{"signature": "def list_versions(<EOL>self, location, publisher_name, type, filter=None, top=None, orderby=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_versions.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", publisher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT:type>': self._serialize.url(\"<STR_LIT:type>\", type, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>')<EOL><DEDENT>if orderby is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", orderby, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of virtual machine extension image versions.\n\n        :param location: The name of a supported Azure region.\n        :type location: str\n        :param publisher_name:\n        :type publisher_name: str\n        :param type:\n        :type type: str\n        :param filter: The filter to apply on the operation.\n        :type filter: str\n        :param top:\n        :type top: int\n        :param orderby:\n        :type orderby: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype:\n         list[~azure.mgmt.compute.v2015_06_15.models.VirtualMachineExtensionImage]\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25856:c0:m3"}
{"signature": "def list_types(<EOL>self, location, publisher_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_types.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", publisher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of virtual machine extension image types.\n\n        :param location: The name of a supported Azure region.\n        :type location: str\n        :param publisher_name:\n        :type publisher_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype:\n         list[~azure.mgmt.compute.v2015_06_15.models.VirtualMachineExtensionImage]\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25856:c0:m2"}
{"signature": "def power_off(<EOL>self, resource_group_name, vm_scale_set_name, instance_id, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._power_off_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_id=instance_id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Power off (stop) a virtual machine in a VM scale set. Note that\n        resources are still attached and you are getting charged for the\n        resources. Instead, use deallocate to release resources and avoid\n        charges.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_id: The instance ID of the virtual machine.\n        :type instance_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns OperationStatusResponse\n         or ClientRawResponse<OperationStatusResponse> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2015_06_15.models.OperationStatusResponse]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2015_06_15.models.OperationStatusResponse]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25857:c0:m11"}
{"signature": "def list(<EOL>self, resource_group_name, virtual_machine_scale_set_name, filter=None, select=None, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_machine_scale_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if select is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", select, '<STR_LIT:str>')<EOL><DEDENT>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualMachineScaleSetVMPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualMachineScaleSetVMPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of all virtual machines in a VM scale sets.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_machine_scale_set_name: The name of the VM scale set.\n        :type virtual_machine_scale_set_name: str\n        :param filter: The filter to apply to the operation.\n        :type filter: str\n        :param select: The list parameters.\n        :type select: str\n        :param expand: The expand expression to apply to the operation.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualMachineScaleSetVM\n        :rtype:\n         ~azure.mgmt.compute.v2015_06_15.models.VirtualMachineScaleSetVMPaged[~azure.mgmt.compute.v2015_06_15.models.VirtualMachineScaleSetVM]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25857:c0:m9"}
{"signature": "def list(<EOL>self, location, publisher_name, offer, skus, filter=None, top=None, orderby=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", publisher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", offer, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", skus, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>')<EOL><DEDENT>if orderby is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", orderby, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of all virtual machine image versions for the specified\n        location, publisher, offer, and SKU.\n\n        :param location: The name of a supported Azure region.\n        :type location: str\n        :param publisher_name: A valid image publisher.\n        :type publisher_name: str\n        :param offer: A valid image publisher offer.\n        :type offer: str\n        :param skus: A valid image SKU.\n        :type skus: str\n        :param filter: The filter to apply on the operation.\n        :type filter: str\n        :param top:\n        :type top: int\n        :param orderby:\n        :type orderby: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype:\n         list[~azure.mgmt.compute.v2015_06_15.models.VirtualMachineImageResource]\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25858:c0:m2"}
{"signature": "def get(<EOL>self, location, publisher_name, offer, skus, version, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", publisher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", offer, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", skus, '<STR_LIT:str>'),<EOL>'<STR_LIT:version>': self._serialize.url(\"<STR_LIT:version>\", version, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a virtual machine image.\n\n        :param location: The name of a supported Azure region.\n        :type location: str\n        :param publisher_name: A valid image publisher.\n        :type publisher_name: str\n        :param offer: A valid image publisher offer.\n        :type offer: str\n        :param skus: A valid image SKU.\n        :type skus: str\n        :param version: A valid image SKU version.\n        :type version: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualMachineImage or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.compute.v2015_06_15.models.VirtualMachineImage or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25858:c0:m1"}
{"signature": "def generalize(<EOL>self, resource_group_name, vm_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.generalize.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vm_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Sets the state of the virtual machine to generalized.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine.\n        :type vm_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: OperationStatusResponse or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.compute.v2015_06_15.models.OperationStatusResponse\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25859:c0:m10"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, vm_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_name=vm_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The operation to create or update a virtual machine.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine.\n        :type vm_name: str\n        :param parameters: Parameters supplied to the Create Virtual Machine\n         operation.\n        :type parameters:\n         ~azure.mgmt.compute.v2015_06_15.models.VirtualMachine\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualMachine or\n         ClientRawResponse<VirtualMachine> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2015_06_15.models.VirtualMachine]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2015_06_15.models.VirtualMachine]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25859:c0:m4"}
{"signature": "def delete(<EOL>self, resource_group_name, vm_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_name=vm_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The operation to delete a virtual machine.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine.\n        :type vm_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns OperationStatusResponse\n         or ClientRawResponse<OperationStatusResponse> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2015_06_15.models.OperationStatusResponse]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2015_06_15.models.OperationStatusResponse]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25859:c0:m6"}
{"signature": "def restart(<EOL>self, resource_group_name, vm_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._restart_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_name=vm_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The operation to restart a virtual machine.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine.\n        :type vm_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns OperationStatusResponse\n         or ClientRawResponse<OperationStatusResponse> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2015_06_15.models.OperationStatusResponse]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2015_06_15.models.OperationStatusResponse]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25859:c0:m17"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Create or update an availability set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param name: The name of the availability set.\n        :type name: str\n        :param parameters: Parameters supplied to the Create Availability Set\n         operation.\n        :type parameters:\n         ~azure.mgmt.compute.v2015_06_15.models.AvailabilitySet\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: AvailabilitySet or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.compute.v2015_06_15.models.AvailabilitySet or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25864:c0:m1"}
{"signature": "def power_off(<EOL>self, resource_group_name, vm_scale_set_name, instance_ids=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._power_off_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_ids=instance_ids,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Power off (stop) one or more virtual machines in a VM scale set. Note\n        that resources are still attached and you are getting charged for the\n        resources. Instead, use deallocate to release resources and avoid\n        charges.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_ids: The virtual machine scale set instance ids.\n         Omitting the virtual machine scale set instance ids will result in the\n         operation being performed on all virtual machines in the virtual\n         machine scale set.\n        :type instance_ids: list[str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns OperationStatusResponse\n         or ClientRawResponse<OperationStatusResponse> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2015_06_15.models.OperationStatusResponse]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2015_06_15.models.OperationStatusResponse]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25865:c0:m15"}
{"signature": "def deallocate(<EOL>self, resource_group_name, vm_scale_set_name, instance_ids=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._deallocate_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_ids=instance_ids,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deallocates specific virtual machines in a VM scale set. Shuts down the\n        virtual machines and releases the compute resources. You are not billed\n        for the compute resources that this virtual machine scale set\n        deallocates.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_ids: The virtual machine scale set instance ids.\n         Omitting the virtual machine scale set instance ids will result in the\n         operation being performed on all virtual machines in the virtual\n         machine scale set.\n        :type instance_ids: list[str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns OperationStatusResponse\n         or ClientRawResponse<OperationStatusResponse> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2015_06_15.models.OperationStatusResponse]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2015_06_15.models.OperationStatusResponse]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f25865:c0:m7"}
{"signature": "def list_versions(<EOL>self, location, publisher_name, type, filter=None, top=None, orderby=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_versions.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", publisher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT:type>': self._serialize.url(\"<STR_LIT:type>\", type, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>')<EOL><DEDENT>if orderby is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", orderby, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of virtual machine extension image versions.\n\n        :param location: The name of a supported Azure region.\n        :type location: str\n        :param publisher_name:\n        :type publisher_name: str\n        :param type:\n        :type type: str\n        :param filter: The filter to apply on the operation.\n        :type filter: str\n        :param top:\n        :type top: int\n        :param orderby:\n        :type orderby: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype:\n         list[~azure.mgmt.compute.v2017_03_30.models.VirtualMachineExtensionImage]\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26063:c0:m3"}
{"signature": "def reimage(<EOL>self, resource_group_name, vm_scale_set_name, instance_id, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._reimage_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_id=instance_id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Reimages (upgrade the operating system) a specific virtual machine in a\n        VM scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_id: The instance ID of the virtual machine.\n        :type instance_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns OperationStatusResponse\n         or ClientRawResponse<OperationStatusResponse> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2017_03_30.models.OperationStatusResponse]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2017_03_30.models.OperationStatusResponse]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26064:c0:m2"}
{"signature": "def deallocate(<EOL>self, resource_group_name, vm_scale_set_name, instance_id, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._deallocate_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_id=instance_id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deallocates a specific virtual machine in a VM scale set. Shuts down\n        the virtual machine and releases the compute resources it uses. You are\n        not billed for the compute resources of this virtual machine once it is\n        deallocated.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_id: The instance ID of the virtual machine.\n        :type instance_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns OperationStatusResponse\n         or ClientRawResponse<OperationStatusResponse> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2017_03_30.models.OperationStatusResponse]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2017_03_30.models.OperationStatusResponse]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26064:c0:m6"}
{"signature": "def power_off(<EOL>self, resource_group_name, vm_scale_set_name, instance_id, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._power_off_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_id=instance_id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Power off (stop) a virtual machine in a VM scale set. Note that\n        resources are still attached and you are getting charged for the\n        resources. Instead, use deallocate to release resources and avoid\n        charges.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_id: The instance ID of the virtual machine.\n        :type instance_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns OperationStatusResponse\n         or ClientRawResponse<OperationStatusResponse> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2017_03_30.models.OperationStatusResponse]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2017_03_30.models.OperationStatusResponse]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26064:c0:m13"}
{"signature": "def restart(<EOL>self, resource_group_name, vm_scale_set_name, instance_id, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._restart_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_id=instance_id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Restarts a virtual machine in a VM scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_id: The instance ID of the virtual machine.\n        :type instance_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns OperationStatusResponse\n         or ClientRawResponse<OperationStatusResponse> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2017_03_30.models.OperationStatusResponse]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2017_03_30.models.OperationStatusResponse]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26064:c0:m15"}
{"signature": "def delete(<EOL>self, resource_group_name, vm_scale_set_name, instance_id, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_id=instance_id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes a virtual machine from a VM scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_id: The instance ID of the virtual machine.\n        :type instance_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns OperationStatusResponse\n         or ClientRawResponse<OperationStatusResponse> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2017_03_30.models.OperationStatusResponse]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2017_03_30.models.OperationStatusResponse]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26064:c0:m8"}
{"signature": "def list_publishers(<EOL>self, location, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_publishers.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of virtual machine image publishers for the specified Azure\n        location.\n\n        :param location: The name of a supported Azure region.\n        :type location: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype:\n         list[~azure.mgmt.compute.v2017_03_30.models.VirtualMachineImageResource]\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26065:c0:m4"}
{"signature": "def list_offers(<EOL>self, location, publisher_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_offers.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", publisher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of virtual machine image offers for the specified location\n        and publisher.\n\n        :param location: The name of a supported Azure region.\n        :type location: str\n        :param publisher_name: A valid image publisher.\n        :type publisher_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype:\n         list[~azure.mgmt.compute.v2017_03_30.models.VirtualMachineImageResource]\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26065:c0:m3"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.DiskPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.DiskPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all the disks under a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Disk\n        :rtype:\n         ~azure.mgmt.compute.v2017_03_30.models.DiskPaged[~azure.mgmt.compute.v2017_03_30.models.Disk]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26066:c0:m9"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualMachinePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualMachinePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all of the virtual machines in the specified resource group. Use\n        the nextLink property in the response to get the next page of virtual\n        machines.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualMachine\n        :rtype:\n         ~azure.mgmt.compute.v2017_03_30.models.VirtualMachinePaged[~azure.mgmt.compute.v2017_03_30.models.VirtualMachine]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26067:c0:m16"}
{"signature": "def get(<EOL>self, resource_group_name, vm_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vm_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves information about the model view or the instance view of a\n        virtual machine.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine.\n        :type vm_name: str\n        :param expand: The expand expression to apply on the operation.\n         Possible values include: 'instanceView'\n        :type expand: str or\n         ~azure.mgmt.compute.v2017_03_30.models.InstanceViewTypes\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualMachine or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.compute.v2017_03_30.models.VirtualMachine or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26067:c0:m9"}
{"signature": "def convert_to_managed_disks(<EOL>self, resource_group_name, vm_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._convert_to_managed_disks_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_name=vm_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Converts virtual machine disks from blob-based to managed disks.\n        Virtual machine must be stop-deallocated before invoking this\n        operation.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine.\n        :type vm_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns OperationStatusResponse\n         or ClientRawResponse<OperationStatusResponse> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2017_03_30.models.OperationStatusResponse]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2017_03_30.models.OperationStatusResponse]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26067:c0:m12"}
{"signature": "def delete(<EOL>self, resource_group_name, vm_name, vm_extension_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_name=vm_name,<EOL>vm_extension_name=vm_extension_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The operation to delete the extension.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_name: The name of the virtual machine where the extension\n         should be deleted.\n        :type vm_name: str\n        :param vm_extension_name: The name of the virtual machine extension.\n        :type vm_extension_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns OperationStatusResponse\n         or ClientRawResponse<OperationStatusResponse> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2017_03_30.models.OperationStatusResponse]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2017_03_30.models.OperationStatusResponse]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26068:c0:m6"}
{"signature": "def delete(<EOL>self, resource_group_name, snapshot_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>snapshot_name=snapshot_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes a snapshot.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param snapshot_name: The name of the snapshot that is being created.\n         The name can't be changed after the snapshot is created. Supported\n         characters for the name are a-z, A-Z, 0-9 and _. The max name length\n         is 80 characters.\n        :type snapshot_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns OperationStatusResponse\n         or ClientRawResponse<OperationStatusResponse> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2017_03_30.models.OperationStatusResponse]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2017_03_30.models.OperationStatusResponse]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26069:c0:m7"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, snapshot_name, snapshot, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>snapshot_name=snapshot_name,<EOL>snapshot=snapshot,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a snapshot.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param snapshot_name: The name of the snapshot that is being created.\n         The name can't be changed after the snapshot is created. Supported\n         characters for the name are a-z, A-Z, 0-9 and _. The max name length\n         is 80 characters.\n        :type snapshot_name: str\n        :param snapshot: Snapshot object supplied in the body of the Put disk\n         operation.\n        :type snapshot: ~azure.mgmt.compute.v2017_03_30.models.Snapshot\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Snapshot or\n         ClientRawResponse<Snapshot> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2017_03_30.models.Snapshot]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2017_03_30.models.Snapshot]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26069:c0:m2"}
{"signature": "def update(<EOL>self, resource_group_name, snapshot_name, snapshot, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_initial(<EOL>resource_group_name=resource_group_name,<EOL>snapshot_name=snapshot_name,<EOL>snapshot=snapshot,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates (patches) a snapshot.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param snapshot_name: The name of the snapshot that is being created.\n         The name can't be changed after the snapshot is created. Supported\n         characters for the name are a-z, A-Z, 0-9 and _. The max name length\n         is 80 characters.\n        :type snapshot_name: str\n        :param snapshot: Snapshot object supplied in the body of the Patch\n         snapshot operation.\n        :type snapshot: ~azure.mgmt.compute.v2017_03_30.models.SnapshotUpdate\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Snapshot or\n         ClientRawResponse<Snapshot> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2017_03_30.models.Snapshot]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2017_03_30.models.Snapshot]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26069:c0:m4"}
{"signature": "def revoke_access(<EOL>self, resource_group_name, snapshot_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._revoke_access_initial(<EOL>resource_group_name=resource_group_name,<EOL>snapshot_name=snapshot_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Revokes access to a snapshot.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param snapshot_name: The name of the snapshot that is being created.\n         The name can't be changed after the snapshot is created. Supported\n         characters for the name are a-z, A-Z, 0-9 and _. The max name length\n         is 80 characters.\n        :type snapshot_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns OperationStatusResponse\n         or ClientRawResponse<OperationStatusResponse> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2017_03_30.models.OperationStatusResponse]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2017_03_30.models.OperationStatusResponse]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26069:c0:m13"}
{"signature": "def delete(<EOL>self, resource_group_name, image_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>image_name=image_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes an Image.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param image_name: The name of the image.\n        :type image_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns OperationStatusResponse\n         or ClientRawResponse<OperationStatusResponse> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2017_03_30.models.OperationStatusResponse]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2017_03_30.models.OperationStatusResponse]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26070:c0:m4"}
{"signature": "def delete(<EOL>self, resource_group_name, vm_scale_set_name, vmss_extension_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>vmss_extension_name=vmss_extension_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The operation to delete the extension.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set where the\n         extension should be deleted.\n        :type vm_scale_set_name: str\n        :param vmss_extension_name: The name of the VM scale set extension.\n        :type vmss_extension_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns OperationStatusResponse\n         or ClientRawResponse<OperationStatusResponse> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2017_03_30.models.OperationStatusResponse]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2017_03_30.models.OperationStatusResponse]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26072:c0:m4"}
{"signature": "def list(<EOL>self, location, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>', pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualMachineSizePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualMachineSizePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all available virtual machine sizes for a subscription in a\n        location.\n\n        :param location: The location upon which virtual-machine-sizes is\n         queried.\n        :type location: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualMachineSize\n        :rtype:\n         ~azure.mgmt.compute.v2017_03_30.models.VirtualMachineSizePaged[~azure.mgmt.compute.v2017_03_30.models.VirtualMachineSize]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26073:c0:m1"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, availability_set_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", availability_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Create or update an availability set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param availability_set_name: The name of the availability set.\n        :type availability_set_name: str\n        :param parameters: Parameters supplied to the Create Availability Set\n         operation.\n        :type parameters:\n         ~azure.mgmt.compute.v2017_03_30.models.AvailabilitySet\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: AvailabilitySet or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.compute.v2017_03_30.models.AvailabilitySet or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26077:c0:m1"}
{"signature": "def list_by_subscription(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_subscription.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.AvailabilitySetPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.AvailabilitySetPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all availability sets in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of AvailabilitySet\n        :rtype:\n         ~azure.mgmt.compute.v2017_03_30.models.AvailabilitySetPaged[~azure.mgmt.compute.v2017_03_30.models.AvailabilitySet]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26077:c0:m4"}
{"signature": "def get(<EOL>self, resource_group_name, availability_set_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", availability_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves information about an availability set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param availability_set_name: The name of the availability set.\n        :type availability_set_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: AvailabilitySet or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.compute.v2017_03_30.models.AvailabilitySet or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26077:c0:m3"}
{"signature": "def update_instances(<EOL>self, resource_group_name, vm_scale_set_name, instance_ids, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_instances_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_ids=instance_ids,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Upgrades one or more virtual machines to the latest SKU set in the VM\n        scale set model.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_ids: The virtual machine scale set instance ids.\n        :type instance_ids: list[str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns OperationStatusResponse\n         or ClientRawResponse<OperationStatusResponse> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2017_03_30.models.OperationStatusResponse]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2017_03_30.models.OperationStatusResponse]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26078:c0:m23"}
{"signature": "def restart(<EOL>self, resource_group_name, vm_scale_set_name, instance_ids=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._restart_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>instance_ids=instance_ids,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Restarts one or more virtual machines in a VM scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param instance_ids: The virtual machine scale set instance ids.\n         Omitting the virtual machine scale set instance ids will result in the\n         operation being performed on all virtual machines in the virtual\n         machine scale set.\n        :type instance_ids: list[str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns OperationStatusResponse\n         or ClientRawResponse<OperationStatusResponse> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2017_03_30.models.OperationStatusResponse]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2017_03_30.models.OperationStatusResponse]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26078:c0:m19"}
{"signature": "def get(<EOL>self, resource_group_name, vm_scale_set_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vm_scale_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Display information about a virtual machine scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualMachineScaleSet or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.compute.v2017_03_30.models.VirtualMachineScaleSet\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26078:c0:m7"}
{"signature": "def update(<EOL>self, resource_group_name, vm_scale_set_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_initial(<EOL>resource_group_name=resource_group_name,<EOL>vm_scale_set_name=vm_scale_set_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Update a VM scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set to create or\n         update.\n        :type vm_scale_set_name: str\n        :param parameters: The scale set object.\n        :type parameters:\n         ~azure.mgmt.compute.v2017_03_30.models.VirtualMachineScaleSetUpdate\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualMachineScaleSet\n         or ClientRawResponse<VirtualMachineScaleSet> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2017_03_30.models.VirtualMachineScaleSet]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2017_03_30.models.VirtualMachineScaleSet]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26078:c0:m4"}
{"signature": "def get_instance_view(<EOL>self, resource_group_name, vm_scale_set_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_instance_view.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vm_scale_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the status of a VM scale set instance.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualMachineScaleSetInstanceView or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.compute.v2017_03_30.models.VirtualMachineScaleSetInstanceView\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26078:c0:m12"}
{"signature": "def list_skus(<EOL>self, resource_group_name, vm_scale_set_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_skus.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vm_scale_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualMachineScaleSetSkuPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualMachineScaleSetSkuPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of SKUs available for your VM scale set, including the\n        minimum and maximum VM instances allowed for each SKU.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param vm_scale_set_name: The name of the VM scale set.\n        :type vm_scale_set_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualMachineScaleSetSku\n        :rtype:\n         ~azure.mgmt.compute.v2017_03_30.models.VirtualMachineScaleSetSkuPaged[~azure.mgmt.compute.v2017_03_30.models.VirtualMachineScaleSetSku]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26078:c0:m15"}
{"signature": "@property<EOL><INDENT>def gallery_images(self):<DEDENT>", "body": "api_version = self._get_api_version('<STR_LIT>')<EOL>if api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_06_01.operations import GalleryImagesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2019_03_01.operations import GalleryImagesOperations as OperationClass<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\".format(api_version))<EOL><DEDENT>return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))<EOL>", "docstring": "Instance depends on the API version:\n\n           * 2018-06-01: :class:`GalleryImagesOperations<azure.mgmt.compute.v2018_06_01.operations.GalleryImagesOperations>`\n           * 2019-03-01: :class:`GalleryImagesOperations<azure.mgmt.compute.v2019_03_01.operations.GalleryImagesOperations>`", "id": "f26082:c1:m7"}
{"signature": "@property<EOL><INDENT>def virtual_machine_sizes(self):<DEDENT>", "body": "api_version = self._get_api_version('<STR_LIT>')<EOL>if api_version == '<STR_LIT>':<EOL><INDENT>from .v2015_06_15.operations import VirtualMachineSizesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2016_03_30.operations import VirtualMachineSizesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2016_04_30_preview.operations import VirtualMachineSizesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_03_30.operations import VirtualMachineSizesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_12_01.operations import VirtualMachineSizesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_04_01.operations import VirtualMachineSizesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_06_01.operations import VirtualMachineSizesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_10_01.operations import VirtualMachineSizesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2019_03_01.operations import VirtualMachineSizesOperations as OperationClass<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\".format(api_version))<EOL><DEDENT>return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))<EOL>", "docstring": "Instance depends on the API version:\n\n           * 2015-06-15: :class:`VirtualMachineSizesOperations<azure.mgmt.compute.v2015_06_15.operations.VirtualMachineSizesOperations>`\n           * 2016-03-30: :class:`VirtualMachineSizesOperations<azure.mgmt.compute.v2016_03_30.operations.VirtualMachineSizesOperations>`\n           * 2016-04-30-preview: :class:`VirtualMachineSizesOperations<azure.mgmt.compute.v2016_04_30_preview.operations.VirtualMachineSizesOperations>`\n           * 2017-03-30: :class:`VirtualMachineSizesOperations<azure.mgmt.compute.v2017_03_30.operations.VirtualMachineSizesOperations>`\n           * 2017-12-01: :class:`VirtualMachineSizesOperations<azure.mgmt.compute.v2017_12_01.operations.VirtualMachineSizesOperations>`\n           * 2018-04-01: :class:`VirtualMachineSizesOperations<azure.mgmt.compute.v2018_04_01.operations.VirtualMachineSizesOperations>`\n           * 2018-06-01: :class:`VirtualMachineSizesOperations<azure.mgmt.compute.v2018_06_01.operations.VirtualMachineSizesOperations>`\n           * 2018-10-01: :class:`VirtualMachineSizesOperations<azure.mgmt.compute.v2018_10_01.operations.VirtualMachineSizesOperations>`\n           * 2019-03-01: :class:`VirtualMachineSizesOperations<azure.mgmt.compute.v2019_03_01.operations.VirtualMachineSizesOperations>`", "id": "f26082:c1:m23"}
{"signature": "@property<EOL><INDENT>def proximity_placement_groups(self):<DEDENT>", "body": "api_version = self._get_api_version('<STR_LIT>')<EOL>if api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_04_01.operations import ProximityPlacementGroupsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_06_01.operations import ProximityPlacementGroupsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_10_01.operations import ProximityPlacementGroupsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2019_03_01.operations import ProximityPlacementGroupsOperations as OperationClass<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\".format(api_version))<EOL><DEDENT>return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))<EOL>", "docstring": "Instance depends on the API version:\n\n           * 2018-04-01: :class:`ProximityPlacementGroupsOperations<azure.mgmt.compute.v2018_04_01.operations.ProximityPlacementGroupsOperations>`\n           * 2018-06-01: :class:`ProximityPlacementGroupsOperations<azure.mgmt.compute.v2018_06_01.operations.ProximityPlacementGroupsOperations>`\n           * 2018-10-01: :class:`ProximityPlacementGroupsOperations<azure.mgmt.compute.v2018_10_01.operations.ProximityPlacementGroupsOperations>`\n           * 2019-03-01: :class:`ProximityPlacementGroupsOperations<azure.mgmt.compute.v2019_03_01.operations.ProximityPlacementGroupsOperations>`", "id": "f26082:c1:m11"}
{"signature": "@property<EOL><INDENT>def images(self):<DEDENT>", "body": "api_version = self._get_api_version('<STR_LIT>')<EOL>if api_version == '<STR_LIT>':<EOL><INDENT>from .v2016_04_30_preview.operations import ImagesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_03_30.operations import ImagesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_12_01.operations import ImagesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_04_01.operations import ImagesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_06_01.operations import ImagesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_10_01.operations import ImagesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2019_03_01.operations import ImagesOperations as OperationClass<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\".format(api_version))<EOL><DEDENT>return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))<EOL>", "docstring": "Instance depends on the API version:\n\n           * 2016-04-30-preview: :class:`ImagesOperations<azure.mgmt.compute.v2016_04_30_preview.operations.ImagesOperations>`\n           * 2017-03-30: :class:`ImagesOperations<azure.mgmt.compute.v2017_03_30.operations.ImagesOperations>`\n           * 2017-12-01: :class:`ImagesOperations<azure.mgmt.compute.v2017_12_01.operations.ImagesOperations>`\n           * 2018-04-01: :class:`ImagesOperations<azure.mgmt.compute.v2018_04_01.operations.ImagesOperations>`\n           * 2018-06-01: :class:`ImagesOperations<azure.mgmt.compute.v2018_06_01.operations.ImagesOperations>`\n           * 2018-10-01: :class:`ImagesOperations<azure.mgmt.compute.v2018_10_01.operations.ImagesOperations>`\n           * 2019-03-01: :class:`ImagesOperations<azure.mgmt.compute.v2019_03_01.operations.ImagesOperations>`", "id": "f26082:c1:m8"}
{"signature": "def list_by_subscription(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_subscription.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.IdentityPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.IdentityPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all the userAssignedIdentities available under the specified\n        subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Identity\n        :rtype:\n         ~azure.mgmt.msi.models.IdentityPaged[~azure.mgmt.msi.models.Identity]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26097:c0:m1"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, zone_name, relative_record_set_name, record_type, parameters, if_match=None, if_none_match=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", zone_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", relative_record_set_name, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", record_type, '<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if if_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_match, '<STR_LIT:str>')<EOL><DEDENT>if if_none_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_none_match, '<STR_LIT:str>')<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or updates a record set within a DNS zone.\n\n        :param resource_group_name: The name of the resource group. The name\n         is case insensitive.\n        :type resource_group_name: str\n        :param zone_name: The name of the DNS zone (without a terminating\n         dot).\n        :type zone_name: str\n        :param relative_record_set_name: The name of the record set, relative\n         to the name of the zone.\n        :type relative_record_set_name: str\n        :param record_type: The type of DNS record in this record set. Record\n         sets of type SOA can be updated but not created (they are created when\n         the DNS zone is created). Possible values include: 'A', 'AAAA', 'CAA',\n         'CNAME', 'MX', 'NS', 'PTR', 'SOA', 'SRV', 'TXT'\n        :type record_type: str or\n         ~azure.mgmt.dns.v2018_03_01_preview.models.RecordType\n        :param parameters: Parameters supplied to the CreateOrUpdate\n         operation.\n        :type parameters: ~azure.mgmt.dns.v2018_03_01_preview.models.RecordSet\n        :param if_match: The etag of the record set. Omit this value to always\n         overwrite the current record set. Specify the last-seen etag value to\n         prevent accidentally overwritting any concurrent changes.\n        :type if_match: str\n        :param if_none_match: Set to '*' to allow a new record set to be\n         created, but to prevent updating an existing record set. Other values\n         will be ignored.\n        :type if_none_match: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RecordSet or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.dns.v2018_03_01_preview.models.RecordSet or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26165:c0:m2"}
{"signature": "def list_by_dns_zone(<EOL>self, resource_group_name, zone_name, top=None, recordsetnamesuffix=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_dns_zone.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", zone_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>')<EOL><DEDENT>if recordsetnamesuffix is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", recordsetnamesuffix, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RecordSetPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RecordSetPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all record sets in a DNS zone.\n\n        :param resource_group_name: The name of the resource group. The name\n         is case insensitive.\n        :type resource_group_name: str\n        :param zone_name: The name of the DNS zone (without a terminating\n         dot).\n        :type zone_name: str\n        :param top: The maximum number of record sets to return. If not\n         specified, returns up to 100 record sets.\n        :type top: int\n        :param recordsetnamesuffix: The suffix label of the record set name\n         that has to be used to filter the record set enumerations. If this\n         parameter is specified, Enumeration will return only records that end\n         with .<recordSetNameSuffix>\n        :type recordsetnamesuffix: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of RecordSet\n        :rtype:\n         ~azure.mgmt.dns.v2018_03_01_preview.models.RecordSetPaged[~azure.mgmt.dns.v2018_03_01_preview.models.RecordSet]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26165:c0:m6"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, zone_name, parameters, if_match=None, if_none_match=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", zone_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if if_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_match, '<STR_LIT:str>')<EOL><DEDENT>if if_none_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_none_match, '<STR_LIT:str>')<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or updates a DNS zone. Does not modify DNS records within the\n        zone.\n\n        :param resource_group_name: The name of the resource group. The name\n         is case insensitive.\n        :type resource_group_name: str\n        :param zone_name: The name of the DNS zone (without a terminating\n         dot).\n        :type zone_name: str\n        :param parameters: Parameters supplied to the CreateOrUpdate\n         operation.\n        :type parameters: ~azure.mgmt.dns.v2018_03_01_preview.models.Zone\n        :param if_match: The etag of the DNS zone. Omit this value to always\n         overwrite the current zone. Specify the last-seen etag value to\n         prevent accidentally overwritting any concurrent changes.\n        :type if_match: str\n        :param if_none_match: Set to '*' to allow a new DNS zone to be\n         created, but to prevent updating an existing zone. Other values will\n         be ignored.\n        :type if_none_match: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Zone or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.dns.v2018_03_01_preview.models.Zone or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26166:c0:m1"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, top=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ZonePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ZonePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists the DNS zones within a resource group.\n\n        :param resource_group_name: The name of the resource group. The name\n         is case insensitive.\n        :type resource_group_name: str\n        :param top: The maximum number of record sets to return. If not\n         specified, returns up to 100 record sets.\n        :type top: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Zone\n        :rtype:\n         ~azure.mgmt.dns.v2018_03_01_preview.models.ZonePaged[~azure.mgmt.dns.v2018_03_01_preview.models.Zone]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26166:c0:m6"}
{"signature": "def get(<EOL>self, resource_group_name, zone_name, relative_record_set_name, record_type, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", zone_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", relative_record_set_name, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", record_type, '<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a record set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param zone_name: The name of the DNS zone (without a terminating\n         dot).\n        :type zone_name: str\n        :param relative_record_set_name: The name of the record set, relative\n         to the name of the zone.\n        :type relative_record_set_name: str\n        :param record_type: The type of DNS record in this record set.\n         Possible values include: 'A', 'AAAA', 'CAA', 'CNAME', 'MX', 'NS',\n         'PTR', 'SOA', 'SRV', 'TXT'\n        :type record_type: str or\n         ~azure.mgmt.dns.v2018_05_01.models.RecordType\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RecordSet or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.dns.v2018_05_01.models.RecordSet or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26188:c0:m4"}
{"signature": "def update(<EOL>self, resource_group_name, zone_name, relative_record_set_name, record_type, parameters, if_match=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", zone_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", relative_record_set_name, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", record_type, '<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if if_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_match, '<STR_LIT:str>')<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Updates a record set within a DNS zone.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param zone_name: The name of the DNS zone (without a terminating\n         dot).\n        :type zone_name: str\n        :param relative_record_set_name: The name of the record set, relative\n         to the name of the zone.\n        :type relative_record_set_name: str\n        :param record_type: The type of DNS record in this record set.\n         Possible values include: 'A', 'AAAA', 'CAA', 'CNAME', 'MX', 'NS',\n         'PTR', 'SOA', 'SRV', 'TXT'\n        :type record_type: str or\n         ~azure.mgmt.dns.v2018_05_01.models.RecordType\n        :param parameters: Parameters supplied to the Update operation.\n        :type parameters: ~azure.mgmt.dns.v2018_05_01.models.RecordSet\n        :param if_match: The etag of the record set. Omit this value to always\n         overwrite the current record set. Specify the last-seen etag value to\n         prevent accidentally overwritting concurrent changes.\n        :type if_match: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RecordSet or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.dns.v2018_05_01.models.RecordSet or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26188:c0:m1"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, zone_name, relative_record_set_name, record_type, parameters, if_match=None, if_none_match=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", zone_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", relative_record_set_name, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", record_type, '<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if if_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_match, '<STR_LIT:str>')<EOL><DEDENT>if if_none_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_none_match, '<STR_LIT:str>')<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or updates a record set within a DNS zone.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param zone_name: The name of the DNS zone (without a terminating\n         dot).\n        :type zone_name: str\n        :param relative_record_set_name: The name of the record set, relative\n         to the name of the zone.\n        :type relative_record_set_name: str\n        :param record_type: The type of DNS record in this record set. Record\n         sets of type SOA can be updated but not created (they are created when\n         the DNS zone is created). Possible values include: 'A', 'AAAA', 'CAA',\n         'CNAME', 'MX', 'NS', 'PTR', 'SOA', 'SRV', 'TXT'\n        :type record_type: str or\n         ~azure.mgmt.dns.v2018_05_01.models.RecordType\n        :param parameters: Parameters supplied to the CreateOrUpdate\n         operation.\n        :type parameters: ~azure.mgmt.dns.v2018_05_01.models.RecordSet\n        :param if_match: The etag of the record set. Omit this value to always\n         overwrite the current record set. Specify the last-seen etag value to\n         prevent accidentally overwritting any concurrent changes.\n        :type if_match: str\n        :param if_none_match: Set to '*' to allow a new record set to be\n         created, but to prevent updating an existing record set. Other values\n         will be ignored.\n        :type if_none_match: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RecordSet or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.dns.v2018_05_01.models.RecordSet or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26188:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, zone_name, relative_record_set_name, record_type, if_match=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", zone_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", relative_record_set_name, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", record_type, '<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if if_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_match, '<STR_LIT:str>')<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes a record set from a DNS zone. This operation cannot be undone.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param zone_name: The name of the DNS zone (without a terminating\n         dot).\n        :type zone_name: str\n        :param relative_record_set_name: The name of the record set, relative\n         to the name of the zone.\n        :type relative_record_set_name: str\n        :param record_type: The type of DNS record in this record set. Record\n         sets of type SOA cannot be deleted (they are deleted when the DNS zone\n         is deleted). Possible values include: 'A', 'AAAA', 'CAA', 'CNAME',\n         'MX', 'NS', 'PTR', 'SOA', 'SRV', 'TXT'\n        :type record_type: str or\n         ~azure.mgmt.dns.v2018_05_01.models.RecordType\n        :param if_match: The etag of the record set. Omit this value to always\n         delete the current record set. Specify the last-seen etag value to\n         prevent accidentally deleting any concurrent changes.\n        :type if_match: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26188:c0:m3"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, top=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ZonePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ZonePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists the DNS zones within a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param top: The maximum number of record sets to return. If not\n         specified, returns up to 100 record sets.\n        :type top: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Zone\n        :rtype:\n         ~azure.mgmt.dns.v2018_05_01.models.ZonePaged[~azure.mgmt.dns.v2018_05_01.models.Zone]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26189:c0:m6"}
{"signature": "def update(<EOL>self, resource_group_name, zone_name, if_match=None, tags=None, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.ZoneUpdate(tags=tags)<EOL>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", zone_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if if_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_match, '<STR_LIT:str>')<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Updates a DNS zone. Does not modify DNS records within the zone.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param zone_name: The name of the DNS zone (without a terminating\n         dot).\n        :type zone_name: str\n        :param if_match: The etag of the DNS zone. Omit this value to always\n         overwrite the current zone. Specify the last-seen etag value to\n         prevent accidentally overwritting any concurrent changes.\n        :type if_match: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Zone or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.dns.v2018_05_01.models.Zone or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26189:c0:m5"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, zone_name, parameters, if_match=None, if_none_match=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", zone_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if if_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_match, '<STR_LIT:str>')<EOL><DEDENT>if if_none_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_none_match, '<STR_LIT:str>')<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or updates a DNS zone. Does not modify DNS records within the\n        zone.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param zone_name: The name of the DNS zone (without a terminating\n         dot).\n        :type zone_name: str\n        :param parameters: Parameters supplied to the CreateOrUpdate\n         operation.\n        :type parameters: ~azure.mgmt.dns.v2018_05_01.models.Zone\n        :param if_match: The etag of the DNS zone. Omit this value to always\n         overwrite the current zone. Specify the last-seen etag value to\n         prevent accidentally overwritting any concurrent changes.\n        :type if_match: str\n        :param if_none_match: Set to '*' to allow a new DNS zone to be\n         created, but to prevent updating an existing zone. Other values will\n         be ignored.\n        :type if_none_match: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Zone or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.dns.v2018_05_01.models.Zone or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26189:c0:m1"}
{"signature": "def get_by_target_resources(<EOL>self, target_resources=None, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.DnsResourceReferenceRequest(target_resources=target_resources)<EOL>url = self.get_by_target_resources.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Returns the DNS records specified by the referencing targetResourceIds.\n\n        :param target_resources: A list of references to azure resources for\n         which referencing dns records need to be queried.\n        :type target_resources:\n         list[~azure.mgmt.dns.v2018_05_01.models.SubResource]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DnsResourceReferenceResult or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.dns.v2018_05_01.models.DnsResourceReferenceResult\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26190:c0:m1"}
{"signature": "def get_text_operation_result(<EOL>self, operation_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_text_operation_result.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", operation_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ComputerVisionErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "This interface is used for getting text operation result. The URL to\n        this interface should be retrieved from 'Operation-Location' field\n        returned from Recognize Text interface.\n\n        :param operation_id: Id of the text operation returned in the response\n         of the 'Recognize Text'\n        :type operation_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: TextOperationResult or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.cognitiveservices.vision.computervision.models.TextOperationResult\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ComputerVisionErrorException<azure.cognitiveservices.vision.computervision.models.ComputerVisionErrorException>`", "id": "f26272:c1:m11"}
{"signature": "def analyze_image_by_domain(<EOL>self, model, url, language=\"<STR_LIT>\", custom_headers=None, raw=False, **operation_config):", "body": "image_url = models.ImageUrl(url=url)<EOL>url = self.analyze_image_by_domain.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", model, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if language is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", language, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(image_url, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ComputerVisionErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "This operation recognizes content within an image by applying a\n        domain-specific model. The list of domain-specific models that are\n        supported by the Computer Vision API can be retrieved using the /models\n        GET request. Currently, the API provides following domain-specific\n        models: celebrities, landmarks.\n        Two input methods are supported -- (1) Uploading an image or (2)\n        specifying an image URL.\n        A successful response will be returned in JSON.\n        If the request failed, the response will contain an error code and a\n        message to help understand what went wrong.\n\n        :param model: The domain-specific content to recognize.\n        :type model: str\n        :param url: Publicly reachable URL of an image.\n        :type url: str\n        :param language: The desired language for output generation. If this\n         parameter is not specified, the default value is\n         &quot;en&quot;.Supported languages:en - English, Default. es -\n         Spanish, ja - Japanese, pt - Portuguese, zh - Simplified Chinese.\n         Possible values include: 'en', 'es', 'ja', 'pt', 'zh'\n        :type language: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DomainModelResults or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.cognitiveservices.vision.computervision.models.DomainModelResults\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ComputerVisionErrorException<azure.cognitiveservices.vision.computervision.models.ComputerVisionErrorException>`", "id": "f26272:c1:m5"}
{"signature": "def tag_image(<EOL>self, url, language=\"<STR_LIT>\", custom_headers=None, raw=False, **operation_config):", "body": "image_url = models.ImageUrl(url=url)<EOL>url = self.tag_image.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if language is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", language, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(image_url, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ComputerVisionErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "This operation generates a list of words, or tags, that are relevant to\n        the content of the supplied image. The Computer Vision API can return\n        tags based on objects, living beings, scenery or actions found in\n        images. Unlike categories, tags are not organized according to a\n        hierarchical classification system, but correspond to image content.\n        Tags may contain hints to avoid ambiguity or provide context, for\n        example the tag \"cello\" may be accompanied by the hint \"musical\n        instrument\". All tags are in English.\n        Two input methods are supported -- (1) Uploading an image or (2)\n        specifying an image URL.\n        A successful response will be returned in JSON. If the request failed,\n        the response will contain an error code and a message to help\n        understand what went wrong.\n\n        :param url: Publicly reachable URL of an image.\n        :type url: str\n        :param language: The desired language for output generation. If this\n         parameter is not specified, the default value is\n         &quot;en&quot;.Supported languages:en - English, Default. es -\n         Spanish, ja - Japanese, pt - Portuguese, zh - Simplified Chinese.\n         Possible values include: 'en', 'es', 'ja', 'pt', 'zh'\n        :type language: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: TagResult or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.cognitiveservices.vision.computervision.models.TagResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ComputerVisionErrorException<azure.cognitiveservices.vision.computervision.models.ComputerVisionErrorException>`", "id": "f26272:c1:m7"}
{"signature": "def list_read_only_keys(<EOL>self, resource_group_name, account_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = '<STR_LIT>'<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern='<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:3>)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists the read-only access keys for the specified Azure DocumentDB\n        database account.\n\n        :param resource_group_name: Name of an Azure resource group.\n        :type resource_group_name: str\n        :param account_name: DocumentDB database account name.\n        :type account_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :rtype: :class:`DatabaseAccountListReadOnlyKeysResult\n         <azure.mgmt.documentdb.models.DatabaseAccountListReadOnlyKeysResult>`\n        :rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`\n         if raw=true\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26295:c0:m10"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = '<STR_LIT>'<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.DatabaseAccountPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.DatabaseAccountPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all the Azure DocumentDB database accounts available under the\n        subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :rtype: :class:`DatabaseAccountPaged\n         <azure.mgmt.documentdb.models.DatabaseAccountPaged>`\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26295:c0:m6"}
{"signature": "def get_by_type(<EOL>self, app_id, event_type, timespan=None, filter=None, search=None, orderby=None, select=None, skip=None, top=None, format=None, count=None, apply=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_by_type.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", app_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", event_type, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if timespan is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timespan, '<STR_LIT:str>')<EOL><DEDENT>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if search is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", search, '<STR_LIT:str>')<EOL><DEDENT>if orderby is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", orderby, '<STR_LIT:str>')<EOL><DEDENT>if select is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", select, '<STR_LIT:str>')<EOL><DEDENT>if skip is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", skip, '<STR_LIT:int>')<EOL><DEDENT>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>')<EOL><DEDENT>if format is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", format, '<STR_LIT:str>')<EOL><DEDENT>if count is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT:count>\", count, '<STR_LIT:bool>')<EOL><DEDENT>if apply is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", apply, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Execute OData query.\n\n        Executes an OData query for events.\n\n        :param app_id: ID of the application. This is Application ID from the\n         API Access settings blade in the Azure portal.\n        :type app_id: str\n        :param event_type: The type of events to query; either a standard\n         event type (`traces`, `customEvents`, `pageViews`, `requests`,\n         `dependencies`, `exceptions`, `availabilityResults`) or `$all` to\n         query across all event types. Possible values include: '$all',\n         'traces', 'customEvents', 'pageViews', 'browserTimings', 'requests',\n         'dependencies', 'exceptions', 'availabilityResults',\n         'performanceCounters', 'customMetrics'\n        :type event_type: str or ~azure.applicationinsights.models.EventType\n        :param timespan: Optional. The timespan over which to retrieve events.\n         This is an ISO8601 time period value.  This timespan is applied in\n         addition to any that are specified in the Odata expression.\n        :type timespan: str\n        :param filter: An expression used to filter the returned events\n        :type filter: str\n        :param search: A free-text search expression to match for whether a\n         particular event should be returned\n        :type search: str\n        :param orderby: A comma-separated list of properties with \\\\\"asc\\\\\"\n         (the default) or \\\\\"desc\\\\\" to control the order of returned events\n        :type orderby: str\n        :param select: Limits the properties to just those requested on each\n         returned event\n        :type select: str\n        :param skip: The number of items to skip over before returning events\n        :type skip: int\n        :param top: The number of events to return\n        :type top: int\n        :param format: Format for the returned events\n        :type format: str\n        :param count: Request a count of matching items included with the\n         returned events\n        :type count: bool\n        :param apply: An expression used for aggregation over returned events\n        :type apply: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: EventsResults or ClientRawResponse if raw=true\n        :rtype: ~azure.applicationinsights.models.EventsResults or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.applicationinsights.models.ErrorResponseException>`", "id": "f26402:c0:m1"}
{"signature": "def get_multiple(<EOL>self, app_id, body, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_multiple.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", app_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(body, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieve metric data.\n\n        Gets metric values for multiple metrics.\n\n        :param app_id: ID of the application. This is Application ID from the\n         API Access settings blade in the Azure portal.\n        :type app_id: str\n        :param body: The batched metrics query.\n        :type body:\n         list[~azure.applicationinsights.models.MetricsPostBodySchema]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype: list[~azure.applicationinsights.models.MetricsResultsItem] or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.applicationinsights.models.ErrorResponseException>`", "id": "f26405:c0:m2"}
{"signature": "def get(<EOL>self, app_id, metric_id, timespan=None, interval=None, aggregation=None, segment=None, top=None, orderby=None, filter=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", app_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", metric_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if timespan is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timespan, '<STR_LIT:str>')<EOL><DEDENT>if interval is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", interval, '<STR_LIT>')<EOL><DEDENT>if aggregation is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", aggregation, '<STR_LIT>', div='<STR_LIT:U+002C>', min_items=<NUM_LIT:1>)<EOL><DEDENT>if segment is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", segment, '<STR_LIT>', div='<STR_LIT:U+002C>', min_items=<NUM_LIT:1>)<EOL><DEDENT>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>')<EOL><DEDENT>if orderby is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", orderby, '<STR_LIT:str>')<EOL><DEDENT>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieve metric data.\n\n        Gets metric values for a single metric.\n\n        :param app_id: ID of the application. This is Application ID from the\n         API Access settings blade in the Azure portal.\n        :type app_id: str\n        :param metric_id: ID of the metric. This is either a standard AI\n         metric, or an application-specific custom metric. Possible values\n         include: 'requests/count', 'requests/duration', 'requests/failed',\n         'users/count', 'users/authenticated', 'pageViews/count',\n         'pageViews/duration', 'client/processingDuration',\n         'client/receiveDuration', 'client/networkDuration',\n         'client/sendDuration', 'client/totalDuration', 'dependencies/count',\n         'dependencies/failed', 'dependencies/duration', 'exceptions/count',\n         'exceptions/browser', 'exceptions/server', 'sessions/count',\n         'performanceCounters/requestExecutionTime',\n         'performanceCounters/requestsPerSecond',\n         'performanceCounters/requestsInQueue',\n         'performanceCounters/memoryAvailableBytes',\n         'performanceCounters/exceptionsPerSecond',\n         'performanceCounters/processCpuPercentage',\n         'performanceCounters/processIOBytesPerSecond',\n         'performanceCounters/processPrivateBytes',\n         'performanceCounters/processorCpuPercentage',\n         'availabilityResults/availabilityPercentage',\n         'availabilityResults/duration', 'billing/telemetryCount',\n         'customEvents/count'\n        :type metric_id: str or ~azure.applicationinsights.models.MetricId\n        :param timespan: The timespan over which to retrieve metric values.\n         This is an ISO8601 time period value. If timespan is omitted, a\n         default time range of `PT12H` (\"last 12 hours\") is used. The actual\n         timespan that is queried may be adjusted by the server based. In all\n         cases, the actual time span used for the query is included in the\n         response.\n        :type timespan: str\n        :param interval: The time interval to use when retrieving metric\n         values. This is an ISO8601 duration. If interval is omitted, the\n         metric value is aggregated across the entire timespan. If interval is\n         supplied, the server may adjust the interval to a more appropriate\n         size based on the timespan used for the query. In all cases, the\n         actual interval used for the query is included in the response.\n        :type interval: timedelta\n        :param aggregation: The aggregation to use when computing the metric\n         values. To retrieve more than one aggregation at a time, separate them\n         with a comma. If no aggregation is specified, then the default\n         aggregation for the metric is used.\n        :type aggregation: list[str or\n         ~azure.applicationinsights.models.MetricsAggregation]\n        :param segment: The name of the dimension to segment the metric values\n         by. This dimension must be applicable to the metric you are\n         retrieving. To segment by more than one dimension at a time, separate\n         them with a comma (,). In this case, the metric data will be segmented\n         in the order the dimensions are listed in the parameter.\n        :type segment: list[str or\n         ~azure.applicationinsights.models.MetricsSegment]\n        :param top: The number of segments to return.  This value is only\n         valid when segment is specified.\n        :type top: int\n        :param orderby: The aggregation function and direction to sort the\n         segments by.  This value is only valid when segment is specified.\n        :type orderby: str\n        :param filter: An expression used to filter the results.  This value\n         should be a valid OData filter expression where the keys of each\n         clause should be applicable dimensions for the metric you are\n         retrieving.\n        :type filter: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: MetricsResult or ClientRawResponse if raw=true\n        :rtype: ~azure.applicationinsights.models.MetricsResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.applicationinsights.models.ErrorResponseException>`", "id": "f26405:c0:m1"}
{"signature": "def key_phrases(<EOL>self, show_stats=None, documents=None, custom_headers=None, raw=False, **operation_config):", "body": "multi_language_batch_input = None<EOL>if documents is not None:<EOL><INDENT>multi_language_batch_input = models.MultiLanguageBatchInput(documents=documents)<EOL><DEDENT>url = self.key_phrases.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if show_stats is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", show_stats, '<STR_LIT:bool>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if multi_language_batch_input is not None:<EOL><INDENT>body_content = self._serialize.body(multi_language_batch_input, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>body_content = None<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "The API returns a list of strings denoting the key talking points in\n        the input text.\n\n        See the <a\n        href=\"https://docs.microsoft.com/en-us/azure/cognitive-services/text-analytics/overview#supported-languages\">Text\n        Analytics Documentation</a> for details about the languages that are\n        supported by key phrase extraction.\n\n        :param show_stats: (optional) if set to true, response will contain\n         input and document level statistics.\n        :type show_stats: bool\n        :param documents:\n        :type documents:\n         list[~azure.cognitiveservices.language.textanalytics.models.MultiLanguageInput]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: KeyPhraseBatchResult or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.cognitiveservices.language.textanalytics.models.KeyPhraseBatchResult\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.language.textanalytics.models.ErrorResponseException>`", "id": "f26410:c1:m3"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.OperationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.OperationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all of the available SQL Rest API operations.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Operation\n        :rtype:\n         ~azure.mgmt.sqlvirtualmachine.models.OperationPaged[~azure.mgmt.sqlvirtualmachine.models.Operation]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26509:c0:m1"}
{"signature": "def delete(<EOL>self, resource_group_name, sql_virtual_machine_group_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>sql_virtual_machine_group_name=sql_virtual_machine_group_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes a SQL virtual machine group.\n\n        :param resource_group_name: Name of the resource group that contains\n         the resource. You can obtain this value from the Azure Resource\n         Manager API or the portal.\n        :type resource_group_name: str\n        :param sql_virtual_machine_group_name: Name of the SQL virtual machine\n         group.\n        :type sql_virtual_machine_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26510:c0:m5"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SqlVirtualMachineGroupPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SqlVirtualMachineGroupPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all SQL virtual machine groups in a resource group.\n\n        :param resource_group_name: Name of the resource group that contains\n         the resource. You can obtain this value from the Azure Resource\n         Manager API or the portal.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of SqlVirtualMachineGroup\n        :rtype:\n         ~azure.mgmt.sqlvirtualmachine.models.SqlVirtualMachineGroupPaged[~azure.mgmt.sqlvirtualmachine.models.SqlVirtualMachineGroup]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26510:c0:m8"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SqlVirtualMachineGroupPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SqlVirtualMachineGroupPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all SQL virtual machine groups in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of SqlVirtualMachineGroup\n        :rtype:\n         ~azure.mgmt.sqlvirtualmachine.models.SqlVirtualMachineGroupPaged[~azure.mgmt.sqlvirtualmachine.models.SqlVirtualMachineGroup]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26510:c0:m9"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, sql_virtual_machine_group_name, availability_group_listener_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>sql_virtual_machine_group_name=sql_virtual_machine_group_name,<EOL>availability_group_listener_name=availability_group_listener_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates an availability group listener.\n\n        :param resource_group_name: Name of the resource group that contains\n         the resource. You can obtain this value from the Azure Resource\n         Manager API or the portal.\n        :type resource_group_name: str\n        :param sql_virtual_machine_group_name: Name of the SQL virtual machine\n         group.\n        :type sql_virtual_machine_group_name: str\n        :param availability_group_listener_name: Name of the availability\n         group listener.\n        :type availability_group_listener_name: str\n        :param parameters: The availability group listener.\n        :type parameters:\n         ~azure.mgmt.sqlvirtualmachine.models.AvailabilityGroupListener\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         AvailabilityGroupListener or\n         ClientRawResponse<AvailabilityGroupListener> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.sqlvirtualmachine.models.AvailabilityGroupListener]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.sqlvirtualmachine.models.AvailabilityGroupListener]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26511:c0:m3"}
{"signature": "def get(<EOL>self, resource_group_name, sql_virtual_machine_group_name, availability_group_listener_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", sql_virtual_machine_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", availability_group_listener_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets an availability group listener.\n\n        :param resource_group_name: Name of the resource group that contains\n         the resource. You can obtain this value from the Azure Resource\n         Manager API or the portal.\n        :type resource_group_name: str\n        :param sql_virtual_machine_group_name: Name of the SQL virtual machine\n         group.\n        :type sql_virtual_machine_group_name: str\n        :param availability_group_listener_name: Name of the availability\n         group listener.\n        :type availability_group_listener_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: AvailabilityGroupListener or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.sqlvirtualmachine.models.AvailabilityGroupListener\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26511:c0:m1"}
{"signature": "def update(<EOL>self, resource_group_name, sql_virtual_machine_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_initial(<EOL>resource_group_name=resource_group_name,<EOL>sql_virtual_machine_name=sql_virtual_machine_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a SQL virtual machine.\n\n        :param resource_group_name: Name of the resource group that contains\n         the resource. You can obtain this value from the Azure Resource\n         Manager API or the portal.\n        :type resource_group_name: str\n        :param sql_virtual_machine_name: Name of the SQL virtual machine.\n        :type sql_virtual_machine_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns SqlVirtualMachine or\n         ClientRawResponse<SqlVirtualMachine> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.sqlvirtualmachine.models.SqlVirtualMachine]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.sqlvirtualmachine.models.SqlVirtualMachine]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26513:c0:m7"}
{"signature": "def get(<EOL>self, resource_group_name, sql_virtual_machine_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", sql_virtual_machine_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a SQL virtual machine.\n\n        :param resource_group_name: Name of the resource group that contains\n         the resource. You can obtain this value from the Azure Resource\n         Manager API or the portal.\n        :type resource_group_name: str\n        :param sql_virtual_machine_name: Name of the SQL virtual machine.\n        :type sql_virtual_machine_name: str\n        :param expand: The child resources to include in the response.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SqlVirtualMachine or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.sqlvirtualmachine.models.SqlVirtualMachine or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26513:c0:m1"}
{"signature": "def delete(<EOL>self, resource_group_name, sql_virtual_machine_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>sql_virtual_machine_name=sql_virtual_machine_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes a SQL virtual machine.\n\n        :param resource_group_name: Name of the resource group that contains\n         the resource. You can obtain this value from the Azure Resource\n         Manager API or the portal.\n        :type resource_group_name: str\n        :param sql_virtual_machine_name: Name of the SQL virtual machine.\n        :type sql_virtual_machine_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f26513:c0:m5"}
{"signature": "def create_service_from_template(<EOL>self, application_id, service_from_template_description, timeout=<NUM_LIT>, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.create_service_from_template.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", application_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(service_from_template_description, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Creates a Service Fabric service from the service template.\n\n        Creates a Service Fabric service from the service template defined in\n        the application manifest. A service template contains the properties\n        that will be same for the service instance of the same type. The API\n        allows overriding the properties that are usually different for\n        different services of the same service type.\n\n        :param application_id: The identity of the application. This is\n         typically the full name of the application without the 'fabric:' URI\n         scheme.\n         Starting from version 6.0, hierarchical names are delimited with the\n         \"~\" character.\n         For example, if the application name is \"fabric:/myapp/app1\", the\n         application identity would be \"myapp~app1\" in 6.0+ and \"myapp/app1\" in\n         previous versions.\n        :type application_id: str\n        :param service_from_template_description: Describes the service that\n         needs to be created from the template defined in the application\n         manifest.\n        :type service_from_template_description:\n         ~azure.servicefabric.models.ServiceFromTemplateDescription\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m65"}
{"signature": "def get_deployed_service_package_health_using_policy(<EOL>self, node_name, application_id, service_package_name, events_health_state_filter=<NUM_LIT:0>, application_health_policy=None, timeout=<NUM_LIT>, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get_deployed_service_package_health_using_policy.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", node_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", application_id, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", service_package_name, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if events_health_state_filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", events_health_state_filter, '<STR_LIT:int>')<EOL><DEDENT>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if application_health_policy is not None:<EOL><INDENT>body_content = self._serialize.body(application_health_policy, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>body_content = None<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the information about health of service package for a specific\n        application deployed on a Service Fabric node using the specified\n        policy.\n\n        Gets the information about health of a service package for a specific\n        application deployed on a Service Fabric node. using the specified\n        policy. Use EventsHealthStateFilter to optionally filter for the\n        collection of HealthEvent objects reported on the deployed service\n        package based on health state. Use ApplicationHealthPolicy to\n        optionally override the health policies used to evaluate the health.\n        This API only uses 'ConsiderWarningAsError' field of the\n        ApplicationHealthPolicy. The rest of the fields are ignored while\n        evaluating the health of the deployed service package.\n\n        :param node_name: The name of the node.\n        :type node_name: str\n        :param application_id: The identity of the application. This is\n         typically the full name of the application without the 'fabric:' URI\n         scheme.\n         Starting from version 6.0, hierarchical names are delimited with the\n         \"~\" character.\n         For example, if the application name is \"fabric:/myapp/app1\", the\n         application identity would be \"myapp~app1\" in 6.0+ and \"myapp/app1\" in\n         previous versions.\n        :type application_id: str\n        :param service_package_name: The name of the service package.\n        :type service_package_name: str\n        :param events_health_state_filter: Allows filtering the collection of\n         HealthEvent objects returned based on health state.\n         The possible values for this parameter include integer value of one of\n         the following health states.\n         Only events that match the filter are returned. All events are used to\n         evaluate the aggregated health state.\n         If not specified, all entries are returned. The state values are\n         flag-based enumeration, so the value could be a combination of these\n         values, obtained using the bitwise 'OR' operator. For example, If the\n         provided value is 6 then all of the events with HealthState value of\n         OK (2) and Warning (4) are returned.\n         - Default - Default value. Matches any HealthState. The value is zero.\n         - None - Filter that doesn't match any HealthState value. Used in\n         order to return no results on a given collection of states. The value\n         is 1.\n         - Ok - Filter that matches input with HealthState value Ok. The value\n         is 2.\n         - Warning - Filter that matches input with HealthState value Warning.\n         The value is 4.\n         - Error - Filter that matches input with HealthState value Error. The\n         value is 8.\n         - All - Filter that matches input with any HealthState value. The\n         value is 65535.\n        :type events_health_state_filter: int\n        :param application_health_policy: Describes the health policies used\n         to evaluate the health of an application or one of its children.\n         If not present, the health evaluation uses the health policy from\n         application manifest or the default health policy.\n        :type application_health_policy:\n         ~azure.servicefabric.models.ApplicationHealthPolicy\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DeployedServicePackageHealth or ClientRawResponse if raw=true\n        :rtype: ~azure.servicefabric.models.DeployedServicePackageHealth or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m105"}
{"signature": "def delete_image_store_upload_session(<EOL>self, session_id, timeout=<NUM_LIT>, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.delete_image_store_upload_session.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", session_id, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Cancels an image store upload session.\n\n        The DELETE request will cause the existing upload session to expire and\n        remove any previously uploaded file chunks.\n\n        :param session_id: A GUID generated by the user for a file uploading.\n         It identifies an image store upload session which keeps track of all\n         file chunks until it is committed.\n        :type session_id: str\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m130"}
{"signature": "def get_property_info_list(<EOL>self, name_id, include_values=False, continuation_token=None, timeout=<NUM_LIT>, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get_property_info_list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", name_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if include_values is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", include_values, '<STR_LIT:bool>')<EOL><DEDENT>if continuation_token is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", continuation_token, '<STR_LIT:str>', skip_quote=True)<EOL><DEDENT>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information on all Service Fabric properties under a given name.\n\n        A Service Fabric name can have one or more named properties that store\n        custom information. This operation gets the information about these\n        properties in a paged list. The information includes name, value, and\n        metadata about each of the properties.\n\n        :param name_id: The Service Fabric name, without the 'fabric:' URI\n         scheme.\n        :type name_id: str\n        :param include_values: Allows specifying whether to include the values\n         of the properties returned. True if values should be returned with the\n         metadata; False to return only property metadata.\n        :type include_values: bool\n        :param continuation_token: The continuation token parameter is used to\n         obtain next set of results. A continuation token with a non-empty\n         value is included in the response of the API when the results from the\n         system do not fit in a single response. When this value is passed to\n         the next API call, the API returns next set of results. If there are\n         no further results, then the continuation token does not contain a\n         value. The value of this parameter should not be URL encoded.\n        :type continuation_token: str\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PagedPropertyInfoList or ClientRawResponse if raw=true\n        :rtype: ~azure.servicefabric.models.PagedPropertyInfoList or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m180"}
{"signature": "def get_cluster_configuration_upgrade_status(<EOL>self, timeout=<NUM_LIT>, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get_cluster_configuration_upgrade_status.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the cluster configuration upgrade status of a Service Fabric\n        standalone cluster.\n\n        Get the cluster configuration upgrade status details of a Service\n        Fabric standalone cluster.\n\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ClusterConfigurationUpgradeStatusInfo or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.servicefabric.models.ClusterConfigurationUpgradeStatusInfo or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m11"}
{"signature": "def get_deployed_service_package_health(<EOL>self, node_name, application_id, service_package_name, events_health_state_filter=<NUM_LIT:0>, timeout=<NUM_LIT>, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get_deployed_service_package_health.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", node_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", application_id, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", service_package_name, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if events_health_state_filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", events_health_state_filter, '<STR_LIT:int>')<EOL><DEDENT>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the information about health of a service package for a specific\n        application deployed for a Service Fabric node and application.\n\n        Gets the information about health of a service package for a specific\n        application deployed on a Service Fabric node. Use\n        EventsHealthStateFilter to optionally filter for the collection of\n        HealthEvent objects reported on the deployed service package based on\n        health state.\n\n        :param node_name: The name of the node.\n        :type node_name: str\n        :param application_id: The identity of the application. This is\n         typically the full name of the application without the 'fabric:' URI\n         scheme.\n         Starting from version 6.0, hierarchical names are delimited with the\n         \"~\" character.\n         For example, if the application name is \"fabric:/myapp/app1\", the\n         application identity would be \"myapp~app1\" in 6.0+ and \"myapp/app1\" in\n         previous versions.\n        :type application_id: str\n        :param service_package_name: The name of the service package.\n        :type service_package_name: str\n        :param events_health_state_filter: Allows filtering the collection of\n         HealthEvent objects returned based on health state.\n         The possible values for this parameter include integer value of one of\n         the following health states.\n         Only events that match the filter are returned. All events are used to\n         evaluate the aggregated health state.\n         If not specified, all entries are returned. The state values are\n         flag-based enumeration, so the value could be a combination of these\n         values, obtained using the bitwise 'OR' operator. For example, If the\n         provided value is 6 then all of the events with HealthState value of\n         OK (2) and Warning (4) are returned.\n         - Default - Default value. Matches any HealthState. The value is zero.\n         - None - Filter that doesn't match any HealthState value. Used in\n         order to return no results on a given collection of states. The value\n         is 1.\n         - Ok - Filter that matches input with HealthState value Ok. The value\n         is 2.\n         - Warning - Filter that matches input with HealthState value Warning.\n         The value is 4.\n         - Error - Filter that matches input with HealthState value Error. The\n         value is 8.\n         - All - Filter that matches input with any HealthState value. The\n         value is 65535.\n        :type events_health_state_filter: int\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DeployedServicePackageHealth or ClientRawResponse if raw=true\n        :rtype: ~azure.servicefabric.models.DeployedServicePackageHealth or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m104"}
{"signature": "def update_cluster_upgrade(<EOL>self, update_cluster_upgrade_description, timeout=<NUM_LIT>, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.update_cluster_upgrade.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(update_cluster_upgrade_description, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Update the upgrade parameters of a Service Fabric cluster upgrade.\n\n        Update the upgrade parameters used during a Service Fabric cluster\n        upgrade.\n\n        :param update_cluster_upgrade_description: Parameters for updating a\n         cluster upgrade.\n        :type update_cluster_upgrade_description:\n         ~azure.servicefabric.models.UpdateClusterUpgradeDescription\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m20"}
{"signature": "def set_upgrade_orchestration_service_state(<EOL>self, timeout=<NUM_LIT>, service_state=None, custom_headers=None, raw=False, **operation_config):", "body": "upgrade_orchestration_service_state = models.UpgradeOrchestrationServiceState(service_state=service_state)<EOL>api_version = \"<STR_LIT>\"<EOL>url = self.set_upgrade_orchestration_service_state.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(upgrade_orchestration_service_state, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Update the service state of Service Fabric Upgrade Orchestration\n        Service.\n\n        Update the service state of Service Fabric Upgrade Orchestration\n        Service. This API is internally used for support purposes.\n\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param service_state: The state of Service Fabric Upgrade\n         Orchestration Service.\n        :type service_state: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: UpgradeOrchestrationServiceStateSummary or ClientRawResponse\n         if raw=true\n        :rtype:\n         ~azure.servicefabric.models.UpgradeOrchestrationServiceStateSummary or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m13"}
{"signature": "def remove_node_state(<EOL>self, node_name, timeout=<NUM_LIT>, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.remove_node_state.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", node_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Notifies Service Fabric that the persisted state on a node has been\n        permanently removed or lost.\n\n        This implies that it is not possible to recover the persisted state of\n        that node. This generally happens if a hard disk has been wiped clean,\n        or if a hard disk crashes. The node has to be down for this operation\n        to be successful. This operation lets Service Fabric know that the\n        replicas on that node no longer exist, and that Service Fabric should\n        stop waiting for those replicas to come back up. Do not run this cmdlet\n        if the state on the node has not been removed and the node can come\n        back up with its state intact.\n\n        :param node_name: The name of the node.\n        :type node_name: str\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m31"}
{"signature": "def upload_file(<EOL>self, content_path, timeout=<NUM_LIT>, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.upload_file.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", content_path, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.put(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Uploads contents of the file to the image store.\n\n        Uploads contents of the file to the image store. Use this API if the\n        file is small enough to upload again if the connection fails. The\n        file's data needs to be added to the request body. The contents will be\n        uploaded to the specified path. Image store service uses a mark file to\n        indicate the availability of the folder. The mark file is an empty file\n        named \"_.dir\". The mark file is generated by the image store service\n        when all files in a folder are uploaded. When using File-by-File\n        approach to upload application package in REST, the image store service\n        isn't aware of the file hierarchy of the application package; you need\n        to create a mark file per folder and upload it last, to let the image\n        store service know that the folder is complete.\n\n        :param content_path: Relative path to file or folder in the image\n         store from its root.\n        :type content_path: str\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m125"}
{"signature": "def restart_deployed_code_package(<EOL>self, node_name, application_id, restart_deployed_code_package_description, timeout=<NUM_LIT>, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.restart_deployed_code_package.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", node_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", application_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(restart_deployed_code_package_description, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Restarts a code package deployed on a Service Fabric node in a cluster.\n\n        Restarts a code package deployed on a Service Fabric node in a cluster.\n        This aborts the code package process, which will restart all the user\n        service replicas hosted in that process.\n\n        :param node_name: The name of the node.\n        :type node_name: str\n        :param application_id: The identity of the application. This is\n         typically the full name of the application without the 'fabric:' URI\n         scheme.\n         Starting from version 6.0, hierarchical names are delimited with the\n         \"~\" character.\n         For example, if the application name is \"fabric:/myapp/app1\", the\n         application identity would be \"myapp~app1\" in 6.0+ and \"myapp/app1\" in\n         previous versions.\n        :type application_id: str\n        :param restart_deployed_code_package_description: Describes the\n         deployed code package on Service Fabric node to restart.\n        :type restart_deployed_code_package_description:\n         ~azure.servicefabric.models.RestartDeployedCodePackageDescription\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m109"}
{"signature": "def post_chaos_schedule(<EOL>self, timeout=<NUM_LIT>, version=None, schedule=None, custom_headers=None, raw=False, **operation_config):", "body": "chaos_schedule = models.ChaosScheduleDescription(version=version, schedule=schedule)<EOL>api_version = \"<STR_LIT>\"<EOL>url = self.post_chaos_schedule.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(chaos_schedule, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Set the schedule used by Chaos.\n\n        Chaos will automatically schedule runs based on the Chaos Schedule.\n        The Chaos Schedule will be updated if the provided version matches the\n        version on the server.\n        When updating the Chaos Schedule, the version on the server is\n        incremented by 1.\n        The version on the server will wrap back to 0 after reaching a large\n        number.\n        If Chaos is running when this call is made, the call will fail.\n\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param version: The version number of the Schedule.\n        :type version: int\n        :param schedule: Defines the schedule used by Chaos.\n        :type schedule: ~azure.servicefabric.models.ChaosSchedule\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m124"}
{"signature": "def get_service_manifest(<EOL>self, application_type_name, application_type_version, service_manifest_name, timeout=<NUM_LIT>, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get_service_manifest.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", application_type_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", application_type_version, '<STR_LIT:str>')<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", service_manifest_name, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the manifest describing a service type.\n\n        Gets the manifest describing a service type. The response contains the\n        service manifest XML as a string.\n\n        :param application_type_name: The name of the application type.\n        :type application_type_name: str\n        :param application_type_version: The version of the application type.\n        :type application_type_version: str\n        :param service_manifest_name: The name of a service manifest\n         registered as part of an application type in a Service Fabric cluster.\n        :type service_manifest_name: str\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ServiceTypeManifest or ClientRawResponse if raw=true\n        :rtype: ~azure.servicefabric.models.ServiceTypeManifest or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m39"}
{"signature": "def get_deployed_application_health(<EOL>self, node_name, application_id, events_health_state_filter=<NUM_LIT:0>, deployed_service_packages_health_state_filter=<NUM_LIT:0>, exclude_health_statistics=False, timeout=<NUM_LIT>, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get_deployed_application_health.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", node_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", application_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if events_health_state_filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", events_health_state_filter, '<STR_LIT:int>')<EOL><DEDENT>if deployed_service_packages_health_state_filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", deployed_service_packages_health_state_filter, '<STR_LIT:int>')<EOL><DEDENT>if exclude_health_statistics is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", exclude_health_statistics, '<STR_LIT:bool>')<EOL><DEDENT>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the information about health of an application deployed on a\n        Service Fabric node.\n\n        Gets the information about health of an application deployed on a\n        Service Fabric node. Use EventsHealthStateFilter to optionally filter\n        for the collection of HealthEvent objects reported on the deployed\n        application based on health state. Use\n        DeployedServicePackagesHealthStateFilter to optionally filter for\n        DeployedServicePackageHealth children based on health state.\n\n        :param node_name: The name of the node.\n        :type node_name: str\n        :param application_id: The identity of the application. This is\n         typically the full name of the application without the 'fabric:' URI\n         scheme.\n         Starting from version 6.0, hierarchical names are delimited with the\n         \"~\" character.\n         For example, if the application name is \"fabric:/myapp/app1\", the\n         application identity would be \"myapp~app1\" in 6.0+ and \"myapp/app1\" in\n         previous versions.\n        :type application_id: str\n        :param events_health_state_filter: Allows filtering the collection of\n         HealthEvent objects returned based on health state.\n         The possible values for this parameter include integer value of one of\n         the following health states.\n         Only events that match the filter are returned. All events are used to\n         evaluate the aggregated health state.\n         If not specified, all entries are returned. The state values are\n         flag-based enumeration, so the value could be a combination of these\n         values, obtained using the bitwise 'OR' operator. For example, If the\n         provided value is 6 then all of the events with HealthState value of\n         OK (2) and Warning (4) are returned.\n         - Default - Default value. Matches any HealthState. The value is zero.\n         - None - Filter that doesn't match any HealthState value. Used in\n         order to return no results on a given collection of states. The value\n         is 1.\n         - Ok - Filter that matches input with HealthState value Ok. The value\n         is 2.\n         - Warning - Filter that matches input with HealthState value Warning.\n         The value is 4.\n         - Error - Filter that matches input with HealthState value Error. The\n         value is 8.\n         - All - Filter that matches input with any HealthState value. The\n         value is 65535.\n        :type events_health_state_filter: int\n        :param deployed_service_packages_health_state_filter: Allows filtering\n         of the deployed service package health state objects returned in the\n         result of deployed application health query based on their health\n         state.\n         The possible values for this parameter include integer value of one of\n         the following health states.\n         Only deployed service packages that match the filter are returned. All\n         deployed service packages are used to evaluate the aggregated health\n         state of the deployed application.\n         If not specified, all entries are returned.\n         The state values are flag-based enumeration, so the value can be a\n         combination of these values, obtained using the bitwise 'OR' operator.\n         For example, if the provided value is 6 then health state of service\n         packages with HealthState value of OK (2) and Warning (4) are\n         returned.\n         - Default - Default value. Matches any HealthState. The value is zero.\n         - None - Filter that doesn't match any HealthState value. Used in\n         order to return no results on a given collection of states. The value\n         is 1.\n         - Ok - Filter that matches input with HealthState value Ok. The value\n         is 2.\n         - Warning - Filter that matches input with HealthState value Warning.\n         The value is 4.\n         - Error - Filter that matches input with HealthState value Error. The\n         value is 8.\n         - All - Filter that matches input with any HealthState value. The\n         value is 65535.\n        :type deployed_service_packages_health_state_filter: int\n        :param exclude_health_statistics: Indicates whether the health\n         statistics should be returned as part of the query result. False by\n         default.\n         The statistics show the number of children entities in health state\n         Ok, Warning, and Error.\n        :type exclude_health_statistics: bool\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DeployedApplicationHealth or ClientRawResponse if raw=true\n        :rtype: ~azure.servicefabric.models.DeployedApplicationHealth or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m57"}
{"signature": "def delete_name(<EOL>self, name_id, timeout=<NUM_LIT>, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.delete_name.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", name_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes a Service Fabric name.\n\n        Deletes the specified Service Fabric name. A name must be created\n        before it can be deleted. Deleting a name with child properties will\n        fail.\n\n        :param name_id: The Service Fabric name, without the 'fabric:' URI\n         scheme.\n        :type name_id: str\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m178"}
{"signature": "def disable_service_backup(<EOL>self, service_id, clean_backup, timeout=<NUM_LIT>, custom_headers=None, raw=False, **operation_config):", "body": "disable_backup_description = None<EOL>if clean_backup is not None:<EOL><INDENT>disable_backup_description = models.DisableBackupDescription(clean_backup=clean_backup)<EOL><DEDENT>api_version = \"<STR_LIT>\"<EOL>url = self.disable_service_backup.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", service_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if disable_backup_description is not None:<EOL><INDENT>body_content = self._serialize.body(disable_backup_description, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>body_content = None<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Disables periodic backup of Service Fabric service which was previously\n        enabled.\n\n        Disables periodic backup of Service Fabric service which was previously\n        enabled. Backup must be explicitly enabled before it can be disabled.\n        In case the backup is enabled for the Service Fabric application, which\n        this service is part of, this service would continue to be periodically\n        backed up as per the policy mapped at the application level.\n\n        :param service_id: The identity of the service. This ID is typically\n         the full name of the service without the 'fabric:' URI scheme.\n         Starting from version 6.0, hierarchical names are delimited with the\n         \"~\" character.\n         For example, if the service name is \"fabric:/myapp/app1/svc1\", the\n         service identity would be \"myapp~app1~svc1\" in 6.0+ and\n         \"myapp/app1/svc1\" in previous versions.\n        :type service_id: str\n        :param clean_backup: Boolean flag to delete backups. It can be set to\n         true for deleting all the backups which were created for the backup\n         entity that is getting disabled for backup.\n        :type clean_backup: bool\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m160"}
{"signature": "def get_application_info(<EOL>self, application_id, exclude_application_parameters=False, timeout=<NUM_LIT>, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get_application_info.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", application_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if exclude_application_parameters is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", exclude_application_parameters, '<STR_LIT:bool>')<EOL><DEDENT>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about a Service Fabric application.\n\n        Returns the information about the application that was created or in\n        the process of being created in the Service Fabric cluster and whose\n        name matches the one specified as the parameter. The response includes\n        the name, type, status, parameters, and other details about the\n        application.\n\n        :param application_id: The identity of the application. This is\n         typically the full name of the application without the 'fabric:' URI\n         scheme.\n         Starting from version 6.0, hierarchical names are delimited with the\n         \"~\" character.\n         For example, if the application name is \"fabric:/myapp/app1\", the\n         application identity would be \"myapp~app1\" in 6.0+ and \"myapp/app1\" in\n         previous versions.\n        :type application_id: str\n        :param exclude_application_parameters: The flag that specifies whether\n         application parameters will be excluded from the result.\n        :type exclude_application_parameters: bool\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ApplicationInfo or ClientRawResponse if raw=true\n        :rtype: ~azure.servicefabric.models.ApplicationInfo or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m46"}
{"signature": "def get_deployed_application_health_using_policy(<EOL>self, node_name, application_id, events_health_state_filter=<NUM_LIT:0>, deployed_service_packages_health_state_filter=<NUM_LIT:0>, application_health_policy=None, exclude_health_statistics=False, timeout=<NUM_LIT>, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get_deployed_application_health_using_policy.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", node_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", application_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if events_health_state_filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", events_health_state_filter, '<STR_LIT:int>')<EOL><DEDENT>if deployed_service_packages_health_state_filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", deployed_service_packages_health_state_filter, '<STR_LIT:int>')<EOL><DEDENT>if exclude_health_statistics is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", exclude_health_statistics, '<STR_LIT:bool>')<EOL><DEDENT>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if application_health_policy is not None:<EOL><INDENT>body_content = self._serialize.body(application_health_policy, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>body_content = None<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the information about health of an application deployed on a\n        Service Fabric node. using the specified policy.\n\n        Gets the information about health of an application deployed on a\n        Service Fabric node using the specified policy. Use\n        EventsHealthStateFilter to optionally filter for the collection of\n        HealthEvent objects reported on the deployed application based on\n        health state. Use DeployedServicePackagesHealthStateFilter to\n        optionally filter for DeployedServicePackageHealth children based on\n        health state. Use ApplicationHealthPolicy to optionally override the\n        health policies used to evaluate the health. This API only uses\n        'ConsiderWarningAsError' field of the ApplicationHealthPolicy. The rest\n        of the fields are ignored while evaluating the health of the deployed\n        application.\n\n        :param node_name: The name of the node.\n        :type node_name: str\n        :param application_id: The identity of the application. This is\n         typically the full name of the application without the 'fabric:' URI\n         scheme.\n         Starting from version 6.0, hierarchical names are delimited with the\n         \"~\" character.\n         For example, if the application name is \"fabric:/myapp/app1\", the\n         application identity would be \"myapp~app1\" in 6.0+ and \"myapp/app1\" in\n         previous versions.\n        :type application_id: str\n        :param events_health_state_filter: Allows filtering the collection of\n         HealthEvent objects returned based on health state.\n         The possible values for this parameter include integer value of one of\n         the following health states.\n         Only events that match the filter are returned. All events are used to\n         evaluate the aggregated health state.\n         If not specified, all entries are returned. The state values are\n         flag-based enumeration, so the value could be a combination of these\n         values, obtained using the bitwise 'OR' operator. For example, If the\n         provided value is 6 then all of the events with HealthState value of\n         OK (2) and Warning (4) are returned.\n         - Default - Default value. Matches any HealthState. The value is zero.\n         - None - Filter that doesn't match any HealthState value. Used in\n         order to return no results on a given collection of states. The value\n         is 1.\n         - Ok - Filter that matches input with HealthState value Ok. The value\n         is 2.\n         - Warning - Filter that matches input with HealthState value Warning.\n         The value is 4.\n         - Error - Filter that matches input with HealthState value Error. The\n         value is 8.\n         - All - Filter that matches input with any HealthState value. The\n         value is 65535.\n        :type events_health_state_filter: int\n        :param deployed_service_packages_health_state_filter: Allows filtering\n         of the deployed service package health state objects returned in the\n         result of deployed application health query based on their health\n         state.\n         The possible values for this parameter include integer value of one of\n         the following health states.\n         Only deployed service packages that match the filter are returned. All\n         deployed service packages are used to evaluate the aggregated health\n         state of the deployed application.\n         If not specified, all entries are returned.\n         The state values are flag-based enumeration, so the value can be a\n         combination of these values, obtained using the bitwise 'OR' operator.\n         For example, if the provided value is 6 then health state of service\n         packages with HealthState value of OK (2) and Warning (4) are\n         returned.\n         - Default - Default value. Matches any HealthState. The value is zero.\n         - None - Filter that doesn't match any HealthState value. Used in\n         order to return no results on a given collection of states. The value\n         is 1.\n         - Ok - Filter that matches input with HealthState value Ok. The value\n         is 2.\n         - Warning - Filter that matches input with HealthState value Warning.\n         The value is 4.\n         - Error - Filter that matches input with HealthState value Error. The\n         value is 8.\n         - All - Filter that matches input with any HealthState value. The\n         value is 65535.\n        :type deployed_service_packages_health_state_filter: int\n        :param application_health_policy: Describes the health policies used\n         to evaluate the health of an application or one of its children.\n         If not present, the health evaluation uses the health policy from\n         application manifest or the default health policy.\n        :type application_health_policy:\n         ~azure.servicefabric.models.ApplicationHealthPolicy\n        :param exclude_health_statistics: Indicates whether the health\n         statistics should be returned as part of the query result. False by\n         default.\n         The statistics show the number of children entities in health state\n         Ok, Warning, and Error.\n        :type exclude_health_statistics: bool\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DeployedApplicationHealth or ClientRawResponse if raw=true\n        :rtype: ~azure.servicefabric.models.DeployedApplicationHealth or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m58"}
{"signature": "def suspend_partition_backup(<EOL>self, partition_id, timeout=<NUM_LIT>, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.suspend_partition_backup.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", partition_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Suspends periodic backup for the specified partition.\n\n        The partition which is configured to take periodic backups, is\n        suspended for taking further backups till it is resumed again.\n\n        :param partition_id: The identity of the partition.\n        :type partition_id: str\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m169"}
{"signature": "def enable_service_backup(<EOL>self, service_id, backup_policy_name, timeout=<NUM_LIT>, custom_headers=None, raw=False, **operation_config):", "body": "enable_backup_description = models.EnableBackupDescription(backup_policy_name=backup_policy_name)<EOL>api_version = \"<STR_LIT>\"<EOL>url = self.enable_service_backup.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", service_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(enable_backup_description, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Enables periodic backup of stateful partitions under this Service\n        Fabric service.\n\n        Enables periodic backup of stateful partitions which are part of this\n        Service Fabric service. Each partition is backed up individually as per\n        the specified backup policy description. In case the application, which\n        the service is part of, is already enabled for backup then this\n        operation would override the policy being used to take the periodic\n        backup for this service and its partitions (unless explicitly\n        overridden at the partition level).\n        Note only C# based Reliable Actor and Reliable Stateful services are\n        currently supported for periodic backup.\n\n        :param service_id: The identity of the service. This ID is typically\n         the full name of the service without the 'fabric:' URI scheme.\n         Starting from version 6.0, hierarchical names are delimited with the\n         \"~\" character.\n         For example, if the service name is \"fabric:/myapp/app1/svc1\", the\n         service identity would be \"myapp~app1~svc1\" in 6.0+ and\n         \"myapp/app1/svc1\" in previous versions.\n        :type service_id: str\n        :param backup_policy_name: Name of the backup policy to be used for\n         enabling periodic backups.\n        :type backup_policy_name: str\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m159"}
{"signature": "def get_application_type_info_list_by_name(<EOL>self, application_type_name, application_type_version=None, exclude_application_parameters=False, continuation_token=None, max_results=<NUM_LIT:0>, timeout=<NUM_LIT>, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get_application_type_info_list_by_name.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", application_type_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if application_type_version is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", application_type_version, '<STR_LIT:str>')<EOL><DEDENT>if exclude_application_parameters is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", exclude_application_parameters, '<STR_LIT:bool>')<EOL><DEDENT>if continuation_token is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", continuation_token, '<STR_LIT:str>', skip_quote=True)<EOL><DEDENT>if max_results is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", max_results, '<STR_LIT>', minimum=<NUM_LIT:0>)<EOL><DEDENT>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the list of application types in the Service Fabric cluster\n        matching exactly the specified name.\n\n        Returns the information about the application types that are\n        provisioned or in the process of being provisioned in the Service\n        Fabric cluster. These results are of application types whose name match\n        exactly the one specified as the parameter, and which comply with the\n        given query parameters. All versions of the application type matching\n        the application type name are returned, with each version returned as\n        one application type. The response includes the name, version, status,\n        and other details about the application type. This is a paged query,\n        meaning that if not all of the application types fit in a page, one\n        page of results is returned as well as a continuation token, which can\n        be used to get the next page. For example, if there are 10 application\n        types but a page only fits the first three application types, or if max\n        results is set to 3, then three is returned. To access the rest of the\n        results, retrieve subsequent pages by using the returned continuation\n        token in the next query. An empty continuation token is returned if\n        there are no subsequent pages.\n\n        :param application_type_name: The name of the application type.\n        :type application_type_name: str\n        :param application_type_version: The version of the application type.\n        :type application_type_version: str\n        :param exclude_application_parameters: The flag that specifies whether\n         application parameters will be excluded from the result.\n        :type exclude_application_parameters: bool\n        :param continuation_token: The continuation token parameter is used to\n         obtain next set of results. A continuation token with a non-empty\n         value is included in the response of the API when the results from the\n         system do not fit in a single response. When this value is passed to\n         the next API call, the API returns next set of results. If there are\n         no further results, then the continuation token does not contain a\n         value. The value of this parameter should not be URL encoded.\n        :type continuation_token: str\n        :param max_results: The maximum number of results to be returned as\n         part of the paged queries. This parameter defines the upper bound on\n         the number of results returned. The results returned can be less than\n         the specified maximum results if they do not fit in the message as per\n         the max message size restrictions defined in the configuration. If\n         this parameter is zero or not specified, the paged query includes as\n         many results as possible that fit in the return message.\n        :type max_results: long\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PagedApplicationTypeInfoList or ClientRawResponse if raw=true\n        :rtype: ~azure.servicefabric.models.PagedApplicationTypeInfoList or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m34"}
{"signature": "def get_deployed_service_replica_info_list(<EOL>self, node_name, application_id, partition_id=None, service_manifest_name=None, timeout=<NUM_LIT>, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get_deployed_service_replica_info_list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", node_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", application_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if partition_id is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", partition_id, '<STR_LIT:str>')<EOL><DEDENT>if service_manifest_name is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", service_manifest_name, '<STR_LIT:str>')<EOL><DEDENT>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the list of replicas deployed on a Service Fabric node.\n\n        Gets the list containing the information about replicas deployed on a\n        Service Fabric node. The information include partition ID, replica ID,\n        status of the replica, name of the service, name of the service type,\n        and other information. Use PartitionId or ServiceManifestName query\n        parameters to return information about the deployed replicas matching\n        the specified values for those parameters.\n\n        :param node_name: The name of the node.\n        :type node_name: str\n        :param application_id: The identity of the application. This is\n         typically the full name of the application without the 'fabric:' URI\n         scheme.\n         Starting from version 6.0, hierarchical names are delimited with the\n         \"~\" character.\n         For example, if the application name is \"fabric:/myapp/app1\", the\n         application identity would be \"myapp~app1\" in 6.0+ and \"myapp/app1\" in\n         previous versions.\n        :type application_id: str\n        :param partition_id: The identity of the partition.\n        :type partition_id: str\n        :param service_manifest_name: The name of a service manifest\n         registered as part of an application type in a Service Fabric cluster.\n        :type service_manifest_name: str\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype: list[~azure.servicefabric.models.DeployedServiceReplicaInfo]\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m97"}
{"signature": "def get_quorum_loss_progress(<EOL>self, service_id, partition_id, operation_id, timeout=<NUM_LIT>, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get_quorum_loss_progress.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", service_id, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", partition_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", operation_id, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the progress of a quorum loss operation on a partition started\n        using the StartQuorumLoss API.\n\n        Gets the progress of a quorum loss operation started with\n        StartQuorumLoss, using the provided OperationId.\n\n        :param service_id: The identity of the service. This ID is typically\n         the full name of the service without the 'fabric:' URI scheme.\n         Starting from version 6.0, hierarchical names are delimited with the\n         \"~\" character.\n         For example, if the service name is \"fabric:/myapp/app1/svc1\", the\n         service identity would be \"myapp~app1~svc1\" in 6.0+ and\n         \"myapp/app1/svc1\" in previous versions.\n        :type service_id: str\n        :param partition_id: The identity of the partition.\n        :type partition_id: str\n        :param operation_id: A GUID that identifies a call of this API.  This\n         is passed into the corresponding GetProgress API\n        :type operation_id: str\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PartitionQuorumLossProgress or ClientRawResponse if raw=true\n        :rtype: ~azure.servicefabric.models.PartitionQuorumLossProgress or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m140"}
{"signature": "def get_image_store_root_content(<EOL>self, timeout=<NUM_LIT>, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get_image_store_root_content.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the content information at the root of the image store.\n\n        Returns the information about the image store content at the root of\n        the image store.\n\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ImageStoreContent or ClientRawResponse if raw=true\n        :rtype: ~azure.servicefabric.models.ImageStoreContent or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m128"}
{"signature": "def delete_application(<EOL>self, application_id, force_remove=None, timeout=<NUM_LIT>, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.delete_application.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", application_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if force_remove is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", force_remove, '<STR_LIT:bool>')<EOL><DEDENT>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes an existing Service Fabric application.\n\n        An application must be created before it can be deleted. Deleting an\n        application will delete all services that are part of that application.\n        By default, Service Fabric will try to close service replicas in a\n        graceful manner and then delete the service. However, if a service is\n        having issues closing the replica gracefully, the delete operation may\n        take a long time or get stuck. Use the optional ForceRemove flag to\n        skip the graceful close sequence and forcefully delete the application\n        and all of its services.\n\n        :param application_id: The identity of the application. This is\n         typically the full name of the application without the 'fabric:' URI\n         scheme.\n         Starting from version 6.0, hierarchical names are delimited with the\n         \"~\" character.\n         For example, if the application name is \"fabric:/myapp/app1\", the\n         application identity would be \"myapp~app1\" in 6.0+ and \"myapp/app1\" in\n         previous versions.\n        :type application_id: str\n        :param force_remove: Remove a Service Fabric application or service\n         forcefully without going through the graceful shutdown sequence. This\n         parameter can be used to forcefully delete an application or service\n         for which delete is timing out due to issues in the service code that\n         prevents graceful close of replicas.\n        :type force_remove: bool\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m43"}
{"signature": "def get_service_type_info_list(<EOL>self, application_type_name, application_type_version, timeout=<NUM_LIT>, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get_service_type_info_list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", application_type_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", application_type_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the list containing the information about service types that are\n        supported by a provisioned application type in a Service Fabric\n        cluster.\n\n        Gets the list containing the information about service types that are\n        supported by a provisioned application type in a Service Fabric\n        cluster. The provided application type must exist. Otherwise, a 404\n        status is returned.\n\n        :param application_type_name: The name of the application type.\n        :type application_type_name: str\n        :param application_type_version: The version of the application type.\n        :type application_type_version: str\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype: list[~azure.servicefabric.models.ServiceTypeInfo] or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m37"}
{"signature": "def get_partition_health_using_policy(<EOL>self, partition_id, events_health_state_filter=<NUM_LIT:0>, replicas_health_state_filter=<NUM_LIT:0>, application_health_policy=None, exclude_health_statistics=False, timeout=<NUM_LIT>, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get_partition_health_using_policy.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", partition_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if events_health_state_filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", events_health_state_filter, '<STR_LIT:int>')<EOL><DEDENT>if replicas_health_state_filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", replicas_health_state_filter, '<STR_LIT:int>')<EOL><DEDENT>if exclude_health_statistics is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", exclude_health_statistics, '<STR_LIT:bool>')<EOL><DEDENT>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if application_health_policy is not None:<EOL><INDENT>body_content = self._serialize.body(application_health_policy, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>body_content = None<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the health of the specified Service Fabric partition, by using the\n        specified health policy.\n\n        Gets the health information of the specified partition.\n        If the application health policy is specified, the health evaluation\n        uses it to get the aggregated health state.\n        If the policy is not specified, the health evaluation uses the\n        application health policy defined in the application manifest, or the\n        default health policy, if no policy is defined in the manifest.\n        Use EventsHealthStateFilter to filter the collection of health events\n        reported on the partition based on the health state.\n        Use ReplicasHealthStateFilter to filter the collection of\n        ReplicaHealthState objects on the partition. Use\n        ApplicationHealthPolicy in the POST body to override the health\n        policies used to evaluate the health.\n        If you specify a partition that does not exist in the health store,\n        this request returns an error.\n\n        :param partition_id: The identity of the partition.\n        :type partition_id: str\n        :param events_health_state_filter: Allows filtering the collection of\n         HealthEvent objects returned based on health state.\n         The possible values for this parameter include integer value of one of\n         the following health states.\n         Only events that match the filter are returned. All events are used to\n         evaluate the aggregated health state.\n         If not specified, all entries are returned. The state values are\n         flag-based enumeration, so the value could be a combination of these\n         values, obtained using the bitwise 'OR' operator. For example, If the\n         provided value is 6 then all of the events with HealthState value of\n         OK (2) and Warning (4) are returned.\n         - Default - Default value. Matches any HealthState. The value is zero.\n         - None - Filter that doesn't match any HealthState value. Used in\n         order to return no results on a given collection of states. The value\n         is 1.\n         - Ok - Filter that matches input with HealthState value Ok. The value\n         is 2.\n         - Warning - Filter that matches input with HealthState value Warning.\n         The value is 4.\n         - Error - Filter that matches input with HealthState value Error. The\n         value is 8.\n         - All - Filter that matches input with any HealthState value. The\n         value is 65535.\n        :type events_health_state_filter: int\n        :param replicas_health_state_filter: Allows filtering the collection\n         of ReplicaHealthState objects on the partition. The value can be\n         obtained from members or bitwise operations on members of\n         HealthStateFilter. Only replicas that match the filter will be\n         returned. All replicas will be used to evaluate the aggregated health\n         state. If not specified, all entries will be returned.The state values\n         are flag-based enumeration, so the value could be a combination of\n         these values obtained using bitwise 'OR' operator. For example, If the\n         provided value is 6 then all of the events with HealthState value of\n         OK (2) and Warning (4) will be returned. The possible values for this\n         parameter include integer value of one of the following health states.\n         - Default - Default value. Matches any HealthState. The value is zero.\n         - None - Filter that doesn't match any HealthState value. Used in\n         order to return no results on a given collection of states. The value\n         is 1.\n         - Ok - Filter that matches input with HealthState value Ok. The value\n         is 2.\n         - Warning - Filter that matches input with HealthState value Warning.\n         The value is 4.\n         - Error - Filter that matches input with HealthState value Error. The\n         value is 8.\n         - All - Filter that matches input with any HealthState value. The\n         value is 65535.\n        :type replicas_health_state_filter: int\n        :param application_health_policy: Describes the health policies used\n         to evaluate the health of an application or one of its children.\n         If not present, the health evaluation uses the health policy from\n         application manifest or the default health policy.\n        :type application_health_policy:\n         ~azure.servicefabric.models.ApplicationHealthPolicy\n        :param exclude_health_statistics: Indicates whether the health\n         statistics should be returned as part of the query result. False by\n         default.\n         The statistics show the number of children entities in health state\n         Ok, Warning, and Error.\n        :type exclude_health_statistics: bool\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PartitionHealth or ClientRawResponse if raw=true\n        :rtype: ~azure.servicefabric.models.PartitionHealth or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m77"}
{"signature": "def get_services_event_list(<EOL>self, start_time_utc, end_time_utc, timeout=<NUM_LIT>, events_types_filter=None, exclude_analysis_events=None, skip_correlation_lookup=None, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get_services_event_list.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", start_time_utc, '<STR_LIT:str>')<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", end_time_utc, '<STR_LIT:str>')<EOL>if events_types_filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", events_types_filter, '<STR_LIT:str>')<EOL><DEDENT>if exclude_analysis_events is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", exclude_analysis_events, '<STR_LIT:bool>')<EOL><DEDENT>if skip_correlation_lookup is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", skip_correlation_lookup, '<STR_LIT:bool>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all Services-related events.\n\n        The response is list of ServiceEvent objects.\n\n        :param start_time_utc: The start time of a lookup query in ISO UTC\n         yyyy-MM-ddTHH:mm:ssZ.\n        :type start_time_utc: str\n        :param end_time_utc: The end time of a lookup query in ISO UTC\n         yyyy-MM-ddTHH:mm:ssZ.\n        :type end_time_utc: str\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param events_types_filter: This is a comma separated string\n         specifying the types of FabricEvents that should only be included in\n         the response.\n        :type events_types_filter: str\n        :param exclude_analysis_events: This param disables the retrieval of\n         AnalysisEvents if true is passed.\n        :type exclude_analysis_events: bool\n        :param skip_correlation_lookup: This param disables the search of\n         CorrelatedEvents information if true is passed. otherwise the\n         CorrelationEvents get processed and HasCorrelatedEvents field in every\n         FabricEvent gets populated.\n        :type skip_correlation_lookup: bool\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype: list[~azure.servicefabric.models.ServiceEvent] or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m192"}
{"signature": "def get_deployed_service_replica_detail_info_by_partition_id(<EOL>self, node_name, partition_id, timeout=<NUM_LIT>, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get_deployed_service_replica_detail_info_by_partition_id.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", node_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", partition_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the details of replica deployed on a Service Fabric node.\n\n        Gets the details of the replica deployed on a Service Fabric node. The\n        information includes service kind, service name, current service\n        operation, current service operation start date time, partition ID,\n        replica/instance ID, reported load, and other information.\n\n        :param node_name: The name of the node.\n        :type node_name: str\n        :param partition_id: The identity of the partition.\n        :type partition_id: str\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DeployedServiceReplicaDetailInfo or ClientRawResponse if\n         raw=true\n        :rtype: ~azure.servicefabric.models.DeployedServiceReplicaDetailInfo\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m99"}
{"signature": "def get_property_info(<EOL>self, name_id, property_name, timeout=<NUM_LIT>, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get_property_info.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", name_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", property_name, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified Service Fabric property.\n\n        Gets the specified Service Fabric property under a given name. This\n        will always return both value and metadata.\n\n        :param name_id: The Service Fabric name, without the 'fabric:' URI\n         scheme.\n        :type name_id: str\n        :param property_name: Specifies the name of the property to get.\n        :type property_name: str\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PropertyInfo or ClientRawResponse if raw=true\n        :rtype: ~azure.servicefabric.models.PropertyInfo or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m182"}
{"signature": "def get_service_type_info_by_name(<EOL>self, application_type_name, application_type_version, service_type_name, timeout=<NUM_LIT>, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get_service_type_info_by_name.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", application_type_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", service_type_name, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", application_type_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the information about a specific service type that is supported by\n        a provisioned application type in a Service Fabric cluster.\n\n        Gets the information about a specific service type that is supported by\n        a provisioned application type in a Service Fabric cluster. The\n        provided application type must exist. Otherwise, a 404 status is\n        returned. A 204 response is returned if the specified service type is\n        not found in the cluster.\n\n        :param application_type_name: The name of the application type.\n        :type application_type_name: str\n        :param application_type_version: The version of the application type.\n        :type application_type_version: str\n        :param service_type_name: Specifies the name of a Service Fabric\n         service type.\n        :type service_type_name: str\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ServiceTypeInfo or ClientRawResponse if raw=true\n        :rtype: ~azure.servicefabric.models.ServiceTypeInfo or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m38"}
{"signature": "def get_cluster_manifest(<EOL>self, timeout=<NUM_LIT>, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get_cluster_manifest.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the Service Fabric cluster manifest.\n\n        Get the Service Fabric cluster manifest. The cluster manifest contains\n        properties of the cluster that include different node types on the\n        cluster,\n        security configurations, fault, and upgrade domain topologies, etc.\n        These properties are specified as part of the ClusterConfig.JSON file\n        while deploying a stand-alone cluster. However, most of the information\n        in the cluster manifest\n        is generated internally by service fabric during cluster deployment in\n        other deployment scenarios (e.g. when using Azure portal).\n        The contents of the cluster manifest are for informational purposes\n        only and users are not expected to take a dependency on the format of\n        the file contents or its interpretation.\n\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ClusterManifest or ClientRawResponse if raw=true\n        :rtype: ~azure.servicefabric.models.ClusterManifest or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m1"}
{"signature": "def disable_application_backup(<EOL>self, application_id, clean_backup, timeout=<NUM_LIT>, custom_headers=None, raw=False, **operation_config):", "body": "disable_backup_description = None<EOL>if clean_backup is not None:<EOL><INDENT>disable_backup_description = models.DisableBackupDescription(clean_backup=clean_backup)<EOL><DEDENT>api_version = \"<STR_LIT>\"<EOL>url = self.disable_application_backup.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", application_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if disable_backup_description is not None:<EOL><INDENT>body_content = self._serialize.body(disable_backup_description, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>body_content = None<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Disables periodic backup of Service Fabric application.\n\n        Disables periodic backup of Service Fabric application which was\n        previously enabled.\n\n        :param application_id: The identity of the application. This is\n         typically the full name of the application without the 'fabric:' URI\n         scheme.\n         Starting from version 6.0, hierarchical names are delimited with the\n         \"~\" character.\n         For example, if the application name is \"fabric:/myapp/app1\", the\n         application identity would be \"myapp~app1\" in 6.0+ and \"myapp/app1\" in\n         previous versions.\n        :type application_id: str\n        :param clean_backup: Boolean flag to delete backups. It can be set to\n         true for deleting all the backups which were created for the backup\n         entity that is getting disabled for backup.\n        :type clean_backup: bool\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m154"}
{"signature": "def report_replica_health(<EOL>self, partition_id, replica_id, health_information, replica_health_report_service_kind=\"<STR_LIT>\", immediate=False, timeout=<NUM_LIT>, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.report_replica_health.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", partition_id, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", replica_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", replica_health_report_service_kind, '<STR_LIT:str>')<EOL>if immediate is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", immediate, '<STR_LIT:bool>')<EOL><DEDENT>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(health_information, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Sends a health report on the Service Fabric replica.\n\n        Reports health state of the specified Service Fabric replica. The\n        report must contain the information about the source of the health\n        report and property on which it is reported.\n        The report is sent to a Service Fabric gateway Replica, which forwards\n        to the health store.\n        The report may be accepted by the gateway, but rejected by the health\n        store after extra validation.\n        For example, the health store may reject the report because of an\n        invalid parameter, like a stale sequence number.\n        To see whether the report was applied in the health store, run\n        GetReplicaHealth and check that the report appears in the HealthEvents\n        section.\n\n        :param partition_id: The identity of the partition.\n        :type partition_id: str\n        :param replica_id: The identifier of the replica.\n        :type replica_id: str\n        :param replica_health_report_service_kind: The kind of service replica\n         (Stateless or Stateful) for which the health is being reported.\n         Following are the possible values. Possible values include:\n         'Stateless', 'Stateful'\n        :type replica_health_report_service_kind: str or\n         ~azure.servicefabric.models.ReplicaHealthReportServiceKind\n        :param health_information: Describes the health information for the\n         health report. This information needs to be present in all of the\n         health reports sent to the health manager.\n        :type health_information:\n         ~azure.servicefabric.models.HealthInformation\n        :param immediate: A flag that indicates whether the report should be\n         sent immediately.\n         A health report is sent to a Service Fabric gateway Application, which\n         forwards to the health store.\n         If Immediate is set to true, the report is sent immediately from HTTP\n         Gateway to the health store, regardless of the fabric client settings\n         that the HTTP Gateway Application is using.\n         This is useful for critical reports that should be sent as soon as\n         possible.\n         Depending on timing and other conditions, sending the report may still\n         fail, for example if the HTTP Gateway is closed or the message doesn't\n         reach the Gateway.\n         If Immediate is set to false, the report is sent based on the health\n         client settings from the HTTP Gateway. Therefore, it will be batched\n         according to the HealthReportSendInterval configuration.\n         This is the recommended setting because it allows the health client to\n         optimize health reporting messages to health store as well as health\n         report processing.\n         By default, reports are not sent immediately.\n        :type immediate: bool\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m96"}
{"signature": "def get_cluster_health_chunk(<EOL>self, timeout=<NUM_LIT>, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get_cluster_health_chunk.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the health of a Service Fabric cluster using health chunks.\n\n        Gets the health of a Service Fabric cluster using health chunks.\n        Includes the aggregated health state of the cluster, but none of the\n        cluster entities.\n        To expand the cluster health and get the health state of all or some of\n        the entities, use the POST URI and specify the cluster health chunk\n        query description.\n\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ClusterHealthChunk or ClientRawResponse if raw=true\n        :rtype: ~azure.servicefabric.models.ClusterHealthChunk or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m4"}
{"signature": "def get_replica_health(<EOL>self, partition_id, replica_id, events_health_state_filter=<NUM_LIT:0>, timeout=<NUM_LIT>, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get_replica_health.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", partition_id, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", replica_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if events_health_state_filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", events_health_state_filter, '<STR_LIT:int>')<EOL><DEDENT>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the health of a Service Fabric stateful service replica or\n        stateless service instance.\n\n        Gets the health of a Service Fabric replica.\n        Use EventsHealthStateFilter to filter the collection of health events\n        reported on the replica based on the health state.\n\n        :param partition_id: The identity of the partition.\n        :type partition_id: str\n        :param replica_id: The identifier of the replica.\n        :type replica_id: str\n        :param events_health_state_filter: Allows filtering the collection of\n         HealthEvent objects returned based on health state.\n         The possible values for this parameter include integer value of one of\n         the following health states.\n         Only events that match the filter are returned. All events are used to\n         evaluate the aggregated health state.\n         If not specified, all entries are returned. The state values are\n         flag-based enumeration, so the value could be a combination of these\n         values, obtained using the bitwise 'OR' operator. For example, If the\n         provided value is 6 then all of the events with HealthState value of\n         OK (2) and Warning (4) are returned.\n         - Default - Default value. Matches any HealthState. The value is zero.\n         - None - Filter that doesn't match any HealthState value. Used in\n         order to return no results on a given collection of states. The value\n         is 1.\n         - Ok - Filter that matches input with HealthState value Ok. The value\n         is 2.\n         - Warning - Filter that matches input with HealthState value Warning.\n         The value is 4.\n         - Error - Filter that matches input with HealthState value Error. The\n         value is 8.\n         - All - Filter that matches input with any HealthState value. The\n         value is 65535.\n        :type events_health_state_filter: int\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ReplicaHealth or ClientRawResponse if raw=true\n        :rtype: ~azure.servicefabric.models.ReplicaHealth or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m94"}
{"signature": "def reset_partition_load(<EOL>self, partition_id, timeout=<NUM_LIT>, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.reset_partition_load.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", partition_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Resets the current load of a Service Fabric partition.\n\n        Resets the current load of a Service Fabric partition to the default\n        load for the service.\n\n        :param partition_id: The identity of the partition.\n        :type partition_id: str\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m80"}
{"signature": "def get_image_store_upload_session_by_path(<EOL>self, content_path, timeout=<NUM_LIT>, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get_image_store_upload_session_by_path.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", content_path, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the image store upload session by relative path.\n\n        Gets the image store upload session associated with the given image\n        store relative path. User can query the upload session at any time\n        during uploading. .\n\n        :param content_path: Relative path to file or folder in the image\n         store from its root.\n        :type content_path: str\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: UploadSession or ClientRawResponse if raw=true\n        :rtype: ~azure.servicefabric.models.UploadSession or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m133"}
{"signature": "def get_service_event_list(<EOL>self, service_id, start_time_utc, end_time_utc, timeout=<NUM_LIT>, events_types_filter=None, exclude_analysis_events=None, skip_correlation_lookup=None, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get_service_event_list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", service_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", start_time_utc, '<STR_LIT:str>')<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", end_time_utc, '<STR_LIT:str>')<EOL>if events_types_filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", events_types_filter, '<STR_LIT:str>')<EOL><DEDENT>if exclude_analysis_events is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", exclude_analysis_events, '<STR_LIT:bool>')<EOL><DEDENT>if skip_correlation_lookup is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", skip_correlation_lookup, '<STR_LIT:bool>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a Service-related events.\n\n        The response is list of ServiceEvent objects.\n\n        :param service_id: The identity of the service. This ID is typically\n         the full name of the service without the 'fabric:' URI scheme.\n         Starting from version 6.0, hierarchical names are delimited with the\n         \"~\" character.\n         For example, if the service name is \"fabric:/myapp/app1/svc1\", the\n         service identity would be \"myapp~app1~svc1\" in 6.0+ and\n         \"myapp/app1/svc1\" in previous versions.\n        :type service_id: str\n        :param start_time_utc: The start time of a lookup query in ISO UTC\n         yyyy-MM-ddTHH:mm:ssZ.\n        :type start_time_utc: str\n        :param end_time_utc: The end time of a lookup query in ISO UTC\n         yyyy-MM-ddTHH:mm:ssZ.\n        :type end_time_utc: str\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param events_types_filter: This is a comma separated string\n         specifying the types of FabricEvents that should only be included in\n         the response.\n        :type events_types_filter: str\n        :param exclude_analysis_events: This param disables the retrieval of\n         AnalysisEvents if true is passed.\n        :type exclude_analysis_events: bool\n        :param skip_correlation_lookup: This param disables the search of\n         CorrelatedEvents information if true is passed. otherwise the\n         CorrelationEvents get processed and HasCorrelatedEvents field in every\n         FabricEvent gets populated.\n        :type skip_correlation_lookup: bool\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype: list[~azure.servicefabric.models.ServiceEvent] or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m191"}
{"signature": "def get_compose_deployment_upgrade_progress(<EOL>self, deployment_name, timeout=<NUM_LIT>, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get_compose_deployment_upgrade_progress.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", deployment_name, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets details for the latest upgrade performed on this Service Fabric\n        compose deployment.\n\n        Returns the information about the state of the compose deployment\n        upgrade along with details to aid debugging application health issues.\n\n        :param deployment_name: The identity of the deployment.\n        :type deployment_name: str\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ComposeDeploymentUpgradeProgressInfo or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.servicefabric.models.ComposeDeploymentUpgradeProgressInfo or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m115"}
{"signature": "def get_applications_event_list(<EOL>self, start_time_utc, end_time_utc, timeout=<NUM_LIT>, events_types_filter=None, exclude_analysis_events=None, skip_correlation_lookup=None, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get_applications_event_list.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", start_time_utc, '<STR_LIT:str>')<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", end_time_utc, '<STR_LIT:str>')<EOL>if events_types_filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", events_types_filter, '<STR_LIT:str>')<EOL><DEDENT>if exclude_analysis_events is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", exclude_analysis_events, '<STR_LIT:bool>')<EOL><DEDENT>if skip_correlation_lookup is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", skip_correlation_lookup, '<STR_LIT:bool>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all Applications-related events.\n\n        The response is list of ApplicationEvent objects.\n\n        :param start_time_utc: The start time of a lookup query in ISO UTC\n         yyyy-MM-ddTHH:mm:ssZ.\n        :type start_time_utc: str\n        :param end_time_utc: The end time of a lookup query in ISO UTC\n         yyyy-MM-ddTHH:mm:ssZ.\n        :type end_time_utc: str\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param events_types_filter: This is a comma separated string\n         specifying the types of FabricEvents that should only be included in\n         the response.\n        :type events_types_filter: str\n        :param exclude_analysis_events: This param disables the retrieval of\n         AnalysisEvents if true is passed.\n        :type exclude_analysis_events: bool\n        :param skip_correlation_lookup: This param disables the search of\n         CorrelatedEvents information if true is passed. otherwise the\n         CorrelationEvents get processed and HasCorrelatedEvents field in every\n         FabricEvent gets populated.\n        :type skip_correlation_lookup: bool\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype: list[~azure.servicefabric.models.ApplicationEvent] or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m190"}
{"signature": "def start_compose_deployment_upgrade(<EOL>self, deployment_name, compose_deployment_upgrade_description, timeout=<NUM_LIT>, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.start_compose_deployment_upgrade.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", deployment_name, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(compose_deployment_upgrade_description, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Starts upgrading a compose deployment in the Service Fabric cluster.\n\n        Validates the supplied upgrade parameters and starts upgrading the\n        deployment if the parameters are valid.\n\n        :param deployment_name: The identity of the deployment.\n        :type deployment_name: str\n        :param compose_deployment_upgrade_description: Parameters for\n         upgrading compose deployment.\n        :type compose_deployment_upgrade_description:\n         ~azure.servicefabric.models.ComposeDeploymentUpgradeDescription\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m117"}
{"signature": "def get_partition_load_information(<EOL>self, partition_id, timeout=<NUM_LIT>, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get_partition_load_information.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", partition_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the load information of the specified Service Fabric partition.\n\n        Returns information about the load of a specified partition.\n        The response includes a list of load reports for a Service Fabric\n        partition.\n        Each report includes the load metric name, value, and last reported\n        time in UTC.\n\n        :param partition_id: The identity of the partition.\n        :type partition_id: str\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PartitionLoadInformation or ClientRawResponse if raw=true\n        :rtype: ~azure.servicefabric.models.PartitionLoadInformation or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m79"}
{"signature": "def provision_cluster(<EOL>self, timeout=<NUM_LIT>, code_file_path=None, cluster_manifest_file_path=None, custom_headers=None, raw=False, **operation_config):", "body": "provision_fabric_description = models.ProvisionFabricDescription(code_file_path=code_file_path, cluster_manifest_file_path=cluster_manifest_file_path)<EOL>api_version = \"<STR_LIT>\"<EOL>url = self.provision_cluster.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(provision_fabric_description, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Provision the code or configuration packages of a Service Fabric\n        cluster.\n\n        Validate and provision the code or configuration packages of a Service\n        Fabric cluster.\n\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param code_file_path: The cluster code package file path.\n        :type code_file_path: str\n        :param cluster_manifest_file_path: The cluster manifest file path.\n        :type cluster_manifest_file_path: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m14"}
{"signature": "def suspend_application_backup(<EOL>self, application_id, timeout=<NUM_LIT>, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.suspend_application_backup.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", application_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Suspends periodic backup for the specified Service Fabric application.\n\n        The application which is configured to take periodic backups, is\n        suspended for taking further backups till it is resumed again. This\n        operation applies to the entire application's hierarchy. It means all\n        the services and partitions under this application are now suspended\n        for backup.\n\n        :param application_id: The identity of the application. This is\n         typically the full name of the application without the 'fabric:' URI\n         scheme.\n         Starting from version 6.0, hierarchical names are delimited with the\n         \"~\" character.\n         For example, if the application name is \"fabric:/myapp/app1\", the\n         application identity would be \"myapp~app1\" in 6.0+ and \"myapp/app1\" in\n         previous versions.\n        :type application_id: str\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m157"}
{"signature": "def update_service(<EOL>self, service_id, service_update_description, timeout=<NUM_LIT>, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.update_service.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", service_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(service_update_description, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Updates a Service Fabric service using the specified update\n        description.\n\n        This API allows updating properties of a running Service Fabric\n        service. The set of properties that can be updated are a subset of the\n        properties that were specified at the time of creating the service. The\n        current set of properties can be obtained using `GetServiceDescription`\n        API. Note that updating the properties of a running service is\n        different than upgrading your application using\n        `StartApplicationUpgrade` API. The upgrade is a long running background\n        operation that involves moving the application from one version to\n        another, one upgrade domain at a time, whereas update applies the new\n        properties immediately to the service.\n\n        :param service_id: The identity of the service. This ID is typically\n         the full name of the service without the 'fabric:' URI scheme.\n         Starting from version 6.0, hierarchical names are delimited with the\n         \"~\" character.\n         For example, if the service name is \"fabric:/myapp/app1/svc1\", the\n         service identity would be \"myapp~app1~svc1\" in 6.0+ and\n         \"myapp/app1/svc1\" in previous versions.\n        :type service_id: str\n        :param service_update_description: The information necessary to update\n         a service.\n        :type service_update_description:\n         ~azure.servicefabric.models.ServiceUpdateDescription\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m67"}
{"signature": "def delete_repair_task(<EOL>self, task_id, version=None, custom_headers=None, raw=False, **operation_config):", "body": "repair_task_delete_description = models.RepairTaskDeleteDescription(task_id=task_id, version=version)<EOL>api_version = \"<STR_LIT>\"<EOL>url = self.delete_repair_task.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(repair_task_delete_description, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes a completed repair task.\n\n        This API supports the Service Fabric platform; it is not meant to be\n        used directly from your code.\n\n        :param task_id: The ID of the completed repair task to be deleted.\n        :type task_id: str\n        :param version: The current version number of the repair task. If\n         non-zero, then the request will only succeed if this value matches the\n         actual current version of the repair task. If zero, then no version\n         check is performed.\n        :type version: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m87"}
{"signature": "def get_provisioned_fabric_config_version_info_list(<EOL>self, config_version=None, timeout=<NUM_LIT>, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get_provisioned_fabric_config_version_info_list.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if config_version is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", config_version, '<STR_LIT:str>')<EOL><DEDENT>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of fabric config versions that are provisioned in a Service\n        Fabric cluster.\n\n        Gets a list of information about fabric config versions that are\n        provisioned in the cluster. The parameter ConfigVersion can be used to\n        optionally filter the output to only that particular version.\n\n        :param config_version: The config version of Service Fabric.\n        :type config_version: str\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype: list[~azure.servicefabric.models.FabricConfigVersionInfo] or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m8"}
{"signature": "def get_application_upgrade(<EOL>self, application_id, timeout=<NUM_LIT>, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get_application_upgrade.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", application_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets details for the latest upgrade performed on this application.\n\n        Returns information about the state of the latest application upgrade\n        along with details to aid debugging application health issues.\n\n        :param application_id: The identity of the application. This is\n         typically the full name of the application without the 'fabric:' URI\n         scheme.\n         Starting from version 6.0, hierarchical names are delimited with the\n         \"~\" character.\n         For example, if the application name is \"fabric:/myapp/app1\", the\n         application identity would be \"myapp~app1\" in 6.0+ and \"myapp/app1\" in\n         previous versions.\n        :type application_id: str\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ApplicationUpgradeProgressInfo or ClientRawResponse if\n         raw=true\n        :rtype: ~azure.servicefabric.models.ApplicationUpgradeProgressInfo or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m51"}
{"signature": "def get_deployed_code_package_info_list(<EOL>self, node_name, application_id, service_manifest_name=None, code_package_name=None, timeout=<NUM_LIT>, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get_deployed_code_package_info_list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", node_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", application_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if service_manifest_name is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", service_manifest_name, '<STR_LIT:str>')<EOL><DEDENT>if code_package_name is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", code_package_name, '<STR_LIT:str>')<EOL><DEDENT>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the list of code packages deployed on a Service Fabric node.\n\n        Gets the list of code packages deployed on a Service Fabric node for\n        the given application.\n\n        :param node_name: The name of the node.\n        :type node_name: str\n        :param application_id: The identity of the application. This is\n         typically the full name of the application without the 'fabric:' URI\n         scheme.\n         Starting from version 6.0, hierarchical names are delimited with the\n         \"~\" character.\n         For example, if the application name is \"fabric:/myapp/app1\", the\n         application identity would be \"myapp~app1\" in 6.0+ and \"myapp/app1\" in\n         previous versions.\n        :type application_id: str\n        :param service_manifest_name: The name of a service manifest\n         registered as part of an application type in a Service Fabric cluster.\n        :type service_manifest_name: str\n        :param code_package_name: The name of code package specified in\n         service manifest registered as part of an application type in a\n         Service Fabric cluster.\n        :type code_package_name: str\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype: list[~azure.servicefabric.models.DeployedCodePackageInfo] or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m108"}
{"signature": "def copy_image_store_content(<EOL>self, image_store_copy_description, timeout=<NUM_LIT>, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.copy_image_store_content.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(image_store_copy_description, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Copies image store content internally.\n\n        Copies the image store content from the source image store relative\n        path to the destination image store relative path.\n\n        :param image_store_copy_description: Describes the copy description\n         for the image store.\n        :type image_store_copy_description:\n         ~azure.servicefabric.models.ImageStoreCopyDescription\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m129"}
{"signature": "def start_rollback_compose_deployment_upgrade(<EOL>self, deployment_name, timeout=<NUM_LIT>, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.start_rollback_compose_deployment_upgrade.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", deployment_name, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Starts rolling back a compose deployment upgrade in the Service Fabric\n        cluster.\n\n        Rollback a service fabric compose deployment upgrade.\n\n        :param deployment_name: The identity of the deployment.\n        :type deployment_name: str\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m118"}
{"signature": "def get_deployed_service_package_info_list_by_name(<EOL>self, node_name, application_id, service_package_name, timeout=<NUM_LIT>, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get_deployed_service_package_info_list_by_name.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", node_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", application_id, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", service_package_name, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the list of service packages deployed on a Service Fabric node\n        matching exactly the specified name.\n\n        Returns the information about the service packages deployed on a\n        Service Fabric node for the given application. These results are of\n        service packages whose name match exactly the service package name\n        specified as the parameter.\n\n        :param node_name: The name of the node.\n        :type node_name: str\n        :param application_id: The identity of the application. This is\n         typically the full name of the application without the 'fabric:' URI\n         scheme.\n         Starting from version 6.0, hierarchical names are delimited with the\n         \"~\" character.\n         For example, if the application name is \"fabric:/myapp/app1\", the\n         application identity would be \"myapp~app1\" in 6.0+ and \"myapp/app1\" in\n         previous versions.\n        :type application_id: str\n        :param service_package_name: The name of the service package.\n        :type service_package_name: str\n        :param timeout: The server timeout for performing the operation in\n         seconds. This timeout specifies the time duration that the client is\n         willing to wait for the requested operation to complete. The default\n         value for this parameter is 60 seconds.\n        :type timeout: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype: list[~azure.servicefabric.models.DeployedServicePackageInfo]\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27460:c1:m103"}
{"signature": "def get(<EOL>self, application_resource_name, service_resource_name, replica_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", application_resource_name, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", service_resource_name, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", replica_name, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the given replica of the service of an application.\n\n        Gets the information about the service replica with the given name. The\n        information include the description and other properties of the service\n        replica.\n\n        :param application_resource_name: The identity of the application.\n        :type application_resource_name: str\n        :param service_resource_name: The identity of the service.\n        :type service_resource_name: str\n        :param replica_name: Service Fabric replica name.\n        :type replica_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ServiceReplicaDescription or ClientRawResponse if raw=true\n        :rtype: ~azure.servicefabric.models.ServiceReplicaDescription or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27462:c0:m1"}
{"signature": "def list(<EOL>self, application_resource_name, service_resource_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", application_resource_name, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", service_resource_name, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all the replicas of a service.\n\n        Gets the information about all replicas of a service. The information\n        include the description and other properties of the service replica.\n\n        :param application_resource_name: The identity of the application.\n        :type application_resource_name: str\n        :param service_resource_name: The identity of the service.\n        :type service_resource_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PagedServiceReplicaDescriptionList or ClientRawResponse if\n         raw=true\n        :rtype: ~azure.servicefabric.models.PagedServiceReplicaDescriptionList\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27462:c0:m2"}
{"signature": "def delete(<EOL>self, volume_resource_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", volume_resource_name, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>, <NUM_LIT>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes the Volume resource.\n\n        Deletes the Volume resource identified by the name.\n\n        :param volume_resource_name: The identity of the volume.\n        :type volume_resource_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27463:c0:m3"}
{"signature": "def get(<EOL>self, secret_resource_name, secret_value_resource_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", secret_resource_name, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", secret_value_resource_name, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified secret value resource.\n\n        Get the information about the specified named secret value resources.\n        The information does not include the actual value of the secret.\n\n        :param secret_resource_name: The name of the secret resource.\n        :type secret_resource_name: str\n        :param secret_value_resource_name: The name of the secret resource\n         value which is typically the version identifier for the value.\n        :type secret_value_resource_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SecretValueResourceDescription or ClientRawResponse if\n         raw=true\n        :rtype: ~azure.servicefabric.models.SecretValueResourceDescription or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27464:c0:m2"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all the network resources.\n\n        Gets the information about all network resources in a given resource\n        group. The information include the description and other properties of\n        the Network.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PagedNetworkResourceDescriptionList or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.servicefabric.models.PagedNetworkResourceDescriptionList or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27465:c0:m4"}
{"signature": "def get(<EOL>self, gateway_resource_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", gateway_resource_name, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the Gateway resource with the given name.\n\n        Gets the information about the Gateway resource with the given name.\n        The information include the description and other properties of the\n        Gateway.\n\n        :param gateway_resource_name: The identity of the gateway.\n        :type gateway_resource_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: GatewayResourceDescription or ClientRawResponse if raw=true\n        :rtype: ~azure.servicefabric.models.GatewayResourceDescription or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27466:c0:m2"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all the application resources.\n\n        Gets the information about all application resources in a given\n        resource group. The information include the description and other\n        properties of the Application.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PagedApplicationResourceDescriptionList or ClientRawResponse\n         if raw=true\n        :rtype:\n         ~azure.servicefabric.models.PagedApplicationResourceDescriptionList or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27469:c0:m4"}
{"signature": "def delete(<EOL>self, application_resource_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", application_resource_name, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>, <NUM_LIT>]:<EOL><INDENT>raise models.FabricErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes the Application resource.\n\n        Deletes the Application resource identified by the name.\n\n        :param application_resource_name: The identity of the application.\n        :type application_resource_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`", "id": "f27469:c0:m3"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.OperationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.OperationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all of the available consumption REST API operations.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Operation\n        :rtype:\n         ~azure.mgmt.consumption.models.OperationPaged[~azure.mgmt.consumption.models.Operation]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.consumption.models.ErrorResponseException>`", "id": "f27502:c0:m1"}
{"signature": "def list_by_resource_group_name(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group_name.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.BudgetPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.BudgetPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all budgets for a resource group under a subscription.\n\n        :param resource_group_name: Azure Resource Group Name.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Budget\n        :rtype:\n         ~azure.mgmt.consumption.models.BudgetPaged[~azure.mgmt.consumption.models.Budget]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.consumption.models.ErrorResponseException>`", "id": "f27504:c0:m2"}
{"signature": "def list_by_reservation_order_and_reservation(<EOL>self, reservation_order_id, reservation_id, filter, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_reservation_order_and_reservation.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", reservation_order_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", reservation_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ReservationDetailsPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ReservationDetailsPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists the reservations details for provided date range.\n\n        :param reservation_order_id: Order Id of the reservation\n        :type reservation_order_id: str\n        :param reservation_id: Id of the reservation\n        :type reservation_id: str\n        :param filter: Filter reservation details by date range. The\n         properties/UsageDate for start date and end date. The filter supports\n         'le' and  'ge'\n        :type filter: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ReservationDetails\n        :rtype:\n         ~azure.mgmt.consumption.models.ReservationDetailsPaged[~azure.mgmt.consumption.models.ReservationDetails]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.consumption.models.ErrorResponseException>`", "id": "f27508:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, account_name, content_key_policy_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", content_key_policy_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ApiErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Delete a Content Key Policy.\n\n        Deletes a Content Key Policy in the Media Services account.\n\n        :param resource_group_name: The name of the resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param account_name: The Media Services account name.\n        :type account_name: str\n        :param content_key_policy_name: The Content Key Policy name.\n        :type content_key_policy_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ApiErrorException<azure.mgmt.media.models.ApiErrorException>`", "id": "f27815:c0:m4"}
{"signature": "def get_policy_properties_with_secrets(<EOL>self, resource_group_name, account_name, content_key_policy_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_policy_properties_with_secrets.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", content_key_policy_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ApiErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get a Content Key Policy with secrets.\n\n        Get a Content Key Policy including secret values.\n\n        :param resource_group_name: The name of the resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param account_name: The Media Services account name.\n        :type account_name: str\n        :param content_key_policy_name: The Content Key Policy name.\n        :type content_key_policy_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ContentKeyPolicyProperties or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.media.models.ContentKeyPolicyProperties or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ApiErrorException<azure.mgmt.media.models.ApiErrorException>`", "id": "f27815:c0:m6"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ApiErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.OperationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.OperationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List Operations.\n\n        Lists all the Media Services operations.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Operation\n        :rtype:\n         ~azure.mgmt.media.models.OperationPaged[~azure.mgmt.media.models.Operation]\n        :raises:\n         :class:`ApiErrorException<azure.mgmt.media.models.ApiErrorException>`", "id": "f27816:c0:m1"}
{"signature": "def delete(<EOL>self, resource_group_name, account_name, streaming_endpoint_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>account_name=account_name,<EOL>streaming_endpoint_name=streaming_endpoint_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Delete StreamingEndpoint.\n\n        Deletes a StreamingEndpoint.\n\n        :param resource_group_name: The name of the resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param account_name: The Media Services account name.\n        :type account_name: str\n        :param streaming_endpoint_name: The name of the StreamingEndpoint.\n        :type streaming_endpoint_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises:\n         :class:`ApiErrorException<azure.mgmt.media.models.ApiErrorException>`", "id": "f27817:c0:m8"}
{"signature": "def create(<EOL>self, resource_group_name, account_name, transform_name, job_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", transform_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", job_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.ApiErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Create Job.\n\n        Creates a Job.\n\n        :param resource_group_name: The name of the resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param account_name: The Media Services account name.\n        :type account_name: str\n        :param transform_name: The Transform name.\n        :type transform_name: str\n        :param job_name: The Job name.\n        :type job_name: str\n        :param parameters: The request parameters\n        :type parameters: ~azure.mgmt.media.models.Job\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Job or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.media.models.Job or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ApiErrorException<azure.mgmt.media.models.ApiErrorException>`", "id": "f27818:c0:m3"}
{"signature": "def get(<EOL>self, resource_group_name, account_name, transform_name, job_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", transform_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", job_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ApiErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get Job.\n\n        Gets a Job.\n\n        :param resource_group_name: The name of the resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param account_name: The Media Services account name.\n        :type account_name: str\n        :param transform_name: The Transform name.\n        :type transform_name: str\n        :param job_name: The Job name.\n        :type job_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Job or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.media.models.Job or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ApiErrorException<azure.mgmt.media.models.ApiErrorException>`", "id": "f27818:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, account_name, transform_name, job_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", transform_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", job_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ApiErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Delete Job.\n\n        Deletes a Job.\n\n        :param resource_group_name: The name of the resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param account_name: The Media Services account name.\n        :type account_name: str\n        :param transform_name: The Transform name.\n        :type transform_name: str\n        :param job_name: The Job name.\n        :type job_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ApiErrorException<azure.mgmt.media.models.ApiErrorException>`", "id": "f27818:c0:m4"}
{"signature": "def list(<EOL>self, resource_group_name, account_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ApiErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.LiveEventPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.LiveEventPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List Live Events.\n\n        Lists the Live Events in the account.\n\n        :param resource_group_name: The name of the resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param account_name: The Media Services account name.\n        :type account_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of LiveEvent\n        :rtype:\n         ~azure.mgmt.media.models.LiveEventPaged[~azure.mgmt.media.models.LiveEvent]\n        :raises:\n         :class:`ApiErrorException<azure.mgmt.media.models.ApiErrorException>`", "id": "f27819:c0:m1"}
{"signature": "def get(<EOL>self, resource_group_name, account_name, live_event_name, live_output_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", live_event_name, '<STR_LIT:str>', max_length=<NUM_LIT:32>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", live_output_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ApiErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get Live Output.\n\n        Gets a Live Output.\n\n        :param resource_group_name: The name of the resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param account_name: The Media Services account name.\n        :type account_name: str\n        :param live_event_name: The name of the Live Event.\n        :type live_event_name: str\n        :param live_output_name: The name of the Live Output.\n        :type live_output_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: LiveOutput or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.media.models.LiveOutput or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ApiErrorException<azure.mgmt.media.models.ApiErrorException>`", "id": "f27820:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, account_name, filter_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", filter_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ApiErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Delete an Account Filter.\n\n        Deletes an Account Filter in the Media Services account.\n\n        :param resource_group_name: The name of the resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param account_name: The Media Services account name.\n        :type account_name: str\n        :param filter_name: The Account Filter name\n        :type filter_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ApiErrorException<azure.mgmt.media.models.ApiErrorException>`", "id": "f27822:c0:m4"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, account_name, filter_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", filter_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ApiErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Create or update an Account Filter.\n\n        Creates or updates an Account Filter in the Media Services account.\n\n        :param resource_group_name: The name of the resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param account_name: The Media Services account name.\n        :type account_name: str\n        :param filter_name: The Account Filter name\n        :type filter_name: str\n        :param parameters: The request parameters\n        :type parameters: ~azure.mgmt.media.models.AccountFilter\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: AccountFilter or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.media.models.AccountFilter or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ApiErrorException<azure.mgmt.media.models.ApiErrorException>`", "id": "f27822:c0:m3"}
{"signature": "def create(<EOL>self, resource_group_name, account_name, streaming_policy_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", streaming_policy_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.ApiErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Create a Streaming Policy.\n\n        Create a Streaming Policy in the Media Services account.\n\n        :param resource_group_name: The name of the resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param account_name: The Media Services account name.\n        :type account_name: str\n        :param streaming_policy_name: The Streaming Policy name.\n        :type streaming_policy_name: str\n        :param parameters: The request parameters\n        :type parameters: ~azure.mgmt.media.models.StreamingPolicy\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: StreamingPolicy or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.media.models.StreamingPolicy or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ApiErrorException<azure.mgmt.media.models.ApiErrorException>`", "id": "f27824:c0:m3"}
{"signature": "def delete(<EOL>self, resource_group_name, account_name, streaming_policy_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", streaming_policy_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ApiErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Delete a Streaming Policy.\n\n        Deletes a Streaming Policy in the Media Services account.\n\n        :param resource_group_name: The name of the resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param account_name: The Media Services account name.\n        :type account_name: str\n        :param streaming_policy_name: The Streaming Policy name.\n        :type streaming_policy_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ApiErrorException<azure.mgmt.media.models.ApiErrorException>`", "id": "f27824:c0:m4"}
{"signature": "def update(<EOL>self, resource_group_name, account_name, transform_name, outputs, description=None, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.Transform(description=description, outputs=outputs)<EOL>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", transform_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ApiErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Update Transform.\n\n        Updates a Transform.\n\n        :param resource_group_name: The name of the resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param account_name: The Media Services account name.\n        :type account_name: str\n        :param transform_name: The Transform name.\n        :type transform_name: str\n        :param outputs: An array of one or more TransformOutputs that the\n         Transform should generate.\n        :type outputs: list[~azure.mgmt.media.models.TransformOutput]\n        :param description: An optional verbose description of the Transform.\n        :type description: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Transform or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.media.models.Transform or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ApiErrorException<azure.mgmt.media.models.ApiErrorException>`", "id": "f27825:c0:m5"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, account_name, transform_name, outputs, description=None, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.Transform(description=description, outputs=outputs)<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", transform_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ApiErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Create or Update Transform.\n\n        Creates or updates a new Transform.\n\n        :param resource_group_name: The name of the resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param account_name: The Media Services account name.\n        :type account_name: str\n        :param transform_name: The Transform name.\n        :type transform_name: str\n        :param outputs: An array of one or more TransformOutputs that the\n         Transform should generate.\n        :type outputs: list[~azure.mgmt.media.models.TransformOutput]\n        :param description: An optional verbose description of the Transform.\n        :type description: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Transform or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.media.models.Transform or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ApiErrorException<azure.mgmt.media.models.ApiErrorException>`", "id": "f27825:c0:m3"}
{"signature": "def list_content_keys(<EOL>self, resource_group_name, account_name, streaming_locator_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_content_keys.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", streaming_locator_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ApiErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List Content Keys.\n\n        List Content Keys used by this Streaming Locator.\n\n        :param resource_group_name: The name of the resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param account_name: The Media Services account name.\n        :type account_name: str\n        :param streaming_locator_name: The Streaming Locator name.\n        :type streaming_locator_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ListContentKeysResponse or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.media.models.ListContentKeysResponse or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ApiErrorException<azure.mgmt.media.models.ApiErrorException>`", "id": "f27826:c0:m5"}
{"signature": "def delete(<EOL>self, resource_group_name, account_name, streaming_locator_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", streaming_locator_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ApiErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Delete a Streaming Locator.\n\n        Deletes a Streaming Locator in the Media Services account.\n\n        :param resource_group_name: The name of the resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param account_name: The Media Services account name.\n        :type account_name: str\n        :param streaming_locator_name: The Streaming Locator name.\n        :type streaming_locator_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ApiErrorException<azure.mgmt.media.models.ApiErrorException>`", "id": "f27826:c0:m4"}
{"signature": "def get(<EOL>self, resource_group_name, account_name, asset_name, filter_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", asset_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", filter_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ApiErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get an Asset Filter.\n\n        Get the details of an Asset Filter associated with the specified Asset.\n\n        :param resource_group_name: The name of the resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param account_name: The Media Services account name.\n        :type account_name: str\n        :param asset_name: The Asset name.\n        :type asset_name: str\n        :param filter_name: The Asset Filter name\n        :type filter_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: AssetFilter or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.media.models.AssetFilter or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ApiErrorException<azure.mgmt.media.models.ApiErrorException>`", "id": "f27827:c0:m2"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, account_name, asset_name, filter_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", asset_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", filter_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ApiErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Create or update an Asset Filter.\n\n        Creates or updates an Asset Filter associated with the specified Asset.\n\n        :param resource_group_name: The name of the resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param account_name: The Media Services account name.\n        :type account_name: str\n        :param asset_name: The Asset name.\n        :type asset_name: str\n        :param filter_name: The Asset Filter name\n        :type filter_name: str\n        :param parameters: The request parameters\n        :type parameters: ~azure.mgmt.media.models.AssetFilter\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: AssetFilter or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.media.models.AssetFilter or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ApiErrorException<azure.mgmt.media.models.ApiErrorException>`", "id": "f27827:c0:m3"}
{"signature": "def get(<EOL>self, resource_group_name, account_name, asset_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", asset_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ApiErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get an Asset.\n\n        Get the details of an Asset in the Media Services account.\n\n        :param resource_group_name: The name of the resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param account_name: The Media Services account name.\n        :type account_name: str\n        :param asset_name: The Asset name.\n        :type asset_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Asset or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.media.models.Asset or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ApiErrorException<azure.mgmt.media.models.ApiErrorException>`", "id": "f27828:c0:m2"}
{"signature": "def list_container_sas(<EOL>self, resource_group_name, account_name, asset_name, permissions=None, expiry_time=None, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.ListContainerSasInput(permissions=permissions, expiry_time=expiry_time)<EOL>url = self.list_container_sas.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", asset_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ApiErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List the Asset URLs.\n\n        Lists storage container URLs with shared access signatures (SAS) for\n        uploading and downloading Asset content. The signatures are derived\n        from the storage account keys.\n\n        :param resource_group_name: The name of the resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param account_name: The Media Services account name.\n        :type account_name: str\n        :param asset_name: The Asset name.\n        :type asset_name: str\n        :param permissions: The permissions to set on the SAS URL. Possible\n         values include: 'Read', 'ReadWrite', 'ReadWriteDelete'\n        :type permissions: str or\n         ~azure.mgmt.media.models.AssetContainerPermission\n        :param expiry_time: The SAS URL expiration time.  This must be less\n         than 24 hours from the current time.\n        :type expiry_time: datetime\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: AssetContainerSas or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.media.models.AssetContainerSas or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ApiErrorException<azure.mgmt.media.models.ApiErrorException>`", "id": "f27828:c0:m6"}
{"signature": "def get(<EOL>self, resource_group_name, topic_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", topic_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get a topic.\n\n        Get properties of a topic.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription.\n        :type resource_group_name: str\n        :param topic_name: Name of the topic\n        :type topic_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Topic or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.eventgrid.models.Topic or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f27936:c0:m1"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, filter=None, top=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.TopicPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.TopicPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List topics under a resource group.\n\n        List all the topics under a resource group.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription.\n        :type resource_group_name: str\n        :param filter: Filter the results using OData syntax.\n        :type filter: str\n        :param top: The number of results to return.\n        :type top: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Topic\n        :rtype:\n         ~azure.mgmt.eventgrid.models.TopicPaged[~azure.mgmt.eventgrid.models.Topic]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f27936:c0:m9"}
{"signature": "def delete(<EOL>self, resource_group_name, domain_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>domain_name=domain_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Delete a domain.\n\n        Delete existing domain.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription.\n        :type resource_group_name: str\n        :param domain_name: Name of the domain\n        :type domain_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f27937:c0:m5"}
{"signature": "def regenerate_key(<EOL>self, resource_group_name, domain_name, key_name, custom_headers=None, raw=False, **operation_config):", "body": "regenerate_key_request = models.DomainRegenerateKeyRequest(key_name=key_name)<EOL>url = self.regenerate_key.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", domain_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(regenerate_key_request, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Regenerate key for a domain.\n\n        Regenerate a shared access key for a domain.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription.\n        :type resource_group_name: str\n        :param domain_name: Name of the domain\n        :type domain_name: str\n        :param key_name: Key name to regenerate key1 or key2\n        :type key_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DomainSharedAccessKeys or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.eventgrid.models.DomainSharedAccessKeys or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f27937:c0:m11"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, domain_name, domain_info, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>domain_name=domain_name,<EOL>domain_info=domain_info,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Create or update a domain.\n\n        Asynchronously creates or updates a new domain with the specified\n        parameters.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription.\n        :type resource_group_name: str\n        :param domain_name: Name of the domain\n        :type domain_name: str\n        :param domain_info: Domain information\n        :type domain_info: ~azure.mgmt.eventgrid.models.Domain\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Domain or\n         ClientRawResponse<Domain> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.eventgrid.models.Domain]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.eventgrid.models.Domain]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f27937:c0:m3"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, filter=None, top=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.DomainPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.DomainPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List domains under a resource group.\n\n        List all the domains under a resource group.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription.\n        :type resource_group_name: str\n        :param filter: Filter the results using OData syntax.\n        :type filter: str\n        :param top: The number of results to return.\n        :type top: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Domain\n        :rtype:\n         ~azure.mgmt.eventgrid.models.DomainPaged[~azure.mgmt.eventgrid.models.Domain]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f27937:c0:m9"}
{"signature": "def list_by_domain(<EOL>self, resource_group_name, domain_name, filter=None, top=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_domain.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", domain_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.DomainTopicPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.DomainTopicPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List domain topics.\n\n        List all the topics in a domain.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription.\n        :type resource_group_name: str\n        :param domain_name: Domain name.\n        :type domain_name: str\n        :param filter: Filter the results using OData syntax.\n        :type filter: str\n        :param top: The number of results to return.\n        :type top: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of DomainTopic\n        :rtype:\n         ~azure.mgmt.eventgrid.models.DomainTopicPaged[~azure.mgmt.eventgrid.models.DomainTopic]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f27938:c0:m6"}
{"signature": "def get(<EOL>self, resource_group_name, domain_name, domain_topic_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", domain_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", domain_topic_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get a domain topic.\n\n        Get properties of a domain topic.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription.\n        :type resource_group_name: str\n        :param domain_name: Name of the domain\n        :type domain_name: str\n        :param domain_topic_name: Name of the topic\n        :type domain_topic_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DomainTopic or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.eventgrid.models.DomainTopic or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f27938:c0:m1"}
{"signature": "def get(<EOL>self, scope, event_subscription_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", scope, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", event_subscription_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get an event subscription.\n\n        Get properties of an event subscription.\n\n        :param scope: The scope of the event subscription. The scope can be a\n         subscription, or a resource group, or a top level resource belonging\n         to a resource provider namespace, or an EventGrid topic. For example,\n         use '/subscriptions/{subscriptionId}/' for a subscription,\n         '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}'\n         for a resource group, and\n         '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}'\n         for a resource, and\n         '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.EventGrid/topics/{topicName}'\n         for an EventGrid topic.\n        :type scope: str\n        :param event_subscription_name: Name of the event subscription\n        :type event_subscription_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: EventSubscription or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.eventgrid.models.EventSubscription or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f27940:c0:m1"}
{"signature": "def list_global_by_resource_group(<EOL>self, resource_group_name, filter=None, top=None, label=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_global_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>')<EOL><DEDENT>if label is not None:<EOL><INDENT>query_parameters['<STR_LIT:label>'] = self._serialize.query(\"<STR_LIT:label>\", label, '<STR_LIT:str>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.EventSubscriptionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.EventSubscriptionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List all global event subscriptions under an Azure subscription and\n        resource group.\n\n        List all global event subscriptions under a specific Azure subscription\n        and resource group.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription.\n        :type resource_group_name: str\n        :param filter: Filter the results using OData syntax.\n        :type filter: str\n        :param top: The number of results to return.\n        :type top: int\n        :param label: The label used to filter the results for event\n         subscriptions list.\n        :type label: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of EventSubscription\n        :rtype:\n         ~azure.mgmt.eventgrid.models.EventSubscriptionPaged[~azure.mgmt.eventgrid.models.EventSubscription]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f27940:c0:m11"}
{"signature": "def list_by_domain_topic(<EOL>self, resource_group_name, domain_name, topic_name, filter=None, top=None, label=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_domain_topic.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", domain_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", topic_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>')<EOL><DEDENT>if label is not None:<EOL><INDENT>query_parameters['<STR_LIT:label>'] = self._serialize.query(\"<STR_LIT:label>\", label, '<STR_LIT:str>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.EventSubscriptionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.EventSubscriptionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List all event subscriptions for a specific domain topic.\n\n        List all event subscriptions that have been created for a specific\n        domain topic.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription.\n        :type resource_group_name: str\n        :param domain_name: Name of the top level domain\n        :type domain_name: str\n        :param topic_name: Name of the domain topic\n        :type topic_name: str\n        :param filter: Filter the results using OData syntax.\n        :type filter: str\n        :param top: The number of results to return.\n        :type top: int\n        :param label: The label used to filter the results for event\n         subscriptions list.\n        :type label: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of EventSubscription\n        :rtype:\n         ~azure.mgmt.eventgrid.models.EventSubscriptionPaged[~azure.mgmt.eventgrid.models.EventSubscription]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f27940:c0:m18"}
{"signature": "def get_full_url(<EOL>self, scope, event_subscription_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_full_url.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", scope, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", event_subscription_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get full URL of an event subscription.\n\n        Get the full endpoint URL for an event subscription.\n\n        :param scope: The scope of the event subscription. The scope can be a\n         subscription, or a resource group, or a top level resource belonging\n         to a resource provider namespace, or an EventGrid topic. For example,\n         use '/subscriptions/{subscriptionId}/' for a subscription,\n         '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}'\n         for a resource group, and\n         '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}'\n         for a resource, and\n         '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.EventGrid/topics/{topicName}'\n         for an EventGrid topic.\n        :type scope: str\n        :param event_subscription_name: Name of the event subscription\n        :type event_subscription_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: EventSubscriptionFullUrl or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.eventgrid.models.EventSubscriptionFullUrl or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f27940:c0:m8"}
{"signature": "def update(<EOL>self, scope, event_subscription_name, event_subscription_update_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_initial(<EOL>scope=scope,<EOL>event_subscription_name=event_subscription_name,<EOL>event_subscription_update_parameters=event_subscription_update_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Update an event subscription.\n\n        Asynchronously updates an existing event subscription.\n\n        :param scope: The scope of existing event subscription. The scope can\n         be a subscription, or a resource group, or a top level resource\n         belonging to a resource provider namespace, or an EventGrid topic. For\n         example, use '/subscriptions/{subscriptionId}/' for a subscription,\n         '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}'\n         for a resource group, and\n         '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}'\n         for a resource, and\n         '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.EventGrid/topics/{topicName}'\n         for an EventGrid topic.\n        :type scope: str\n        :param event_subscription_name: Name of the event subscription to be\n         updated\n        :type event_subscription_name: str\n        :param event_subscription_update_parameters: Updated event\n         subscription information\n        :type event_subscription_update_parameters:\n         ~azure.mgmt.eventgrid.models.EventSubscriptionUpdateParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns EventSubscription or\n         ClientRawResponse<EventSubscription> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.eventgrid.models.EventSubscription]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.eventgrid.models.EventSubscription]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f27940:c0:m7"}
{"signature": "def list_regional_by_subscription_for_topic_type(<EOL>self, location, topic_type_name, filter=None, top=None, label=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_regional_by_subscription_for_topic_type.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", topic_type_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>')<EOL><DEDENT>if label is not None:<EOL><INDENT>query_parameters['<STR_LIT:label>'] = self._serialize.query(\"<STR_LIT:label>\", label, '<STR_LIT:str>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.EventSubscriptionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.EventSubscriptionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List all regional event subscriptions under an Azure subscription for a\n        topic type.\n\n        List all event subscriptions from the given location under a specific\n        Azure subscription and topic type.\n\n        :param location: Name of the location\n        :type location: str\n        :param topic_type_name: Name of the topic type\n        :type topic_type_name: str\n        :param filter: Filter the results using OData syntax.\n        :type filter: str\n        :param top: The number of results to return.\n        :type top: int\n        :param label: The label used to filter the results for event\n         subscriptions list.\n        :type label: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of EventSubscription\n        :rtype:\n         ~azure.mgmt.eventgrid.models.EventSubscriptionPaged[~azure.mgmt.eventgrid.models.EventSubscription]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f27940:c0:m15"}
{"signature": "def list_event_types(<EOL>self, topic_type_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_event_types.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", topic_type_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.EventTypePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.EventTypePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List event types.\n\n        List event types for a topic type.\n\n        :param topic_type_name: Name of the topic type\n        :type topic_type_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of EventType\n        :rtype:\n         ~azure.mgmt.eventgrid.models.EventTypePaged[~azure.mgmt.eventgrid.models.EventType]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f27941:c0:m3"}
{"signature": "def get(<EOL>self, topic_type_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", topic_type_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get a topic type.\n\n        Get information about a topic type.\n\n        :param topic_type_name: Name of the topic type\n        :type topic_type_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: TopicTypeInfo or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.eventgrid.models.TopicTypeInfo or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f27941:c0:m2"}
{"signature": "def search(<EOL>self, query, accept_language=None, pragma=None, user_agent=None, client_id=None, client_ip=None, location=None, country_code=None, market=\"<STR_LIT>\", response_filter=None, response_format=None, safe_search=None, set_lang=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.search.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>if country_code is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", country_code, '<STR_LIT:str>')<EOL><DEDENT>if market is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", market, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT:q>'] = self._serialize.query(\"<STR_LIT>\", query, '<STR_LIT:str>')<EOL>if response_filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", response_filter, '<STR_LIT>', div='<STR_LIT:U+002C>')<EOL><DEDENT>if response_format is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", response_format, '<STR_LIT>', div='<STR_LIT:U+002C>')<EOL><DEDENT>if safe_search is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", safe_search, '<STR_LIT:str>')<EOL><DEDENT>if set_lang is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", set_lang, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.x_bing_apis_sdk, '<STR_LIT:str>')<EOL>if accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", accept_language, '<STR_LIT:str>')<EOL><DEDENT>if pragma is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", pragma, '<STR_LIT:str>')<EOL><DEDENT>if user_agent is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", user_agent, '<STR_LIT:str>')<EOL><DEDENT>if client_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", client_id, '<STR_LIT:str>')<EOL><DEDENT>if client_ip is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", client_ip, '<STR_LIT:str>')<EOL><DEDENT>if location is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT:location>\", location, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "The Entity Search API lets you send a search query to Bing and get back\n        search results that include entities and places. Place results include\n        restaurants, hotel, or other local businesses. For places, the query\n        can specify the name of the local business or it can ask for a list\n        (for example, restaurants near me). Entity results include persons,\n        places, or things. Place in this context is tourist attractions,\n        states, countries, etc.\n\n        :param query: The user's search term.\n        :type query: str\n        :param accept_language: A comma-delimited list of one or more\n         languages to use for user interface strings. The list is in decreasing\n         order of preference. For additional information, including expected\n         format, see\n         [RFC2616](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html).\n         This header and the setLang query parameter are mutually exclusive; do\n         not specify both. If you set this header, you must also specify the cc\n         query parameter. Bing will use the first supported language it finds\n         from the list, and combine that language with the cc parameter value\n         to determine the market to return results for. If the list does not\n         include a supported language, Bing will find the closest language and\n         market that supports the request, and may use an aggregated or default\n         market for the results instead of a specified one. You should use this\n         header and the cc query parameter only if you specify multiple\n         languages; otherwise, you should use the mkt and setLang query\n         parameters. A user interface string is a string that's used as a label\n         in a user interface. There are very few user interface strings in the\n         JSON response objects. Any links in the response objects to Bing.com\n         properties will apply the specified language.\n        :type accept_language: str\n        :param pragma: By default, Bing returns cached content, if available.\n         To prevent Bing from returning cached content, set the Pragma header\n         to no-cache (for example, Pragma: no-cache).\n        :type pragma: str\n        :param user_agent: The user agent originating the request. Bing uses\n         the user agent to provide mobile users with an optimized experience.\n         Although optional, you are strongly encouraged to always specify this\n         header. The user-agent should be the same string that any commonly\n         used browser would send. For information about user agents, see [RFC\n         2616](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html).\n        :type user_agent: str\n        :param client_id: Bing uses this header to provide users with\n         consistent behavior across Bing API calls. Bing often flights new\n         features and improvements, and it uses the client ID as a key for\n         assigning traffic on different flights. If you do not use the same\n         client ID for a user across multiple requests, then Bing may assign\n         the user to multiple conflicting flights. Being assigned to multiple\n         conflicting flights can lead to an inconsistent user experience. For\n         example, if the second request has a different flight assignment than\n         the first, the experience may be unexpected. Also, Bing can use the\n         client ID to tailor web results to that client ID\u2019s search history,\n         providing a richer experience for the user. Bing also uses this header\n         to help improve result rankings by analyzing the activity generated by\n         a client ID. The relevance improvements help with better quality of\n         results delivered by Bing APIs and in turn enables higher\n         click-through rates for the API consumer. IMPORTANT: Although\n         optional, you should consider this header required. Persisting the\n         client ID across multiple requests for the same end user and device\n         combination enables 1) the API consumer to receive a consistent user\n         experience, and 2) higher click-through rates via better quality of\n         results from the Bing APIs. Each user that uses your application on\n         the device must have a unique, Bing generated client ID. If you do not\n         include this header in the request, Bing generates an ID and returns\n         it in the X-MSEdge-ClientID response header. The only time that you\n         should NOT include this header in a request is the first time the user\n         uses your app on that device. Use the client ID for each Bing API\n         request that your app makes for this user on the device. Persist the\n         client ID. To persist the ID in a browser app, use a persistent HTTP\n         cookie to ensure the ID is used across all sessions. Do not use a\n         session cookie. For other apps such as mobile apps, use the device's\n         persistent storage to persist the ID. The next time the user uses your\n         app on that device, get the client ID that you persisted. Bing\n         responses may or may not include this header. If the response includes\n         this header, capture the client ID and use it for all subsequent Bing\n         requests for the user on that device. If you include the\n         X-MSEdge-ClientID, you must not include cookies in the request.\n        :type client_id: str\n        :param client_ip: The IPv4 or IPv6 address of the client device. The\n         IP address is used to discover the user's location. Bing uses the\n         location information to determine safe search behavior. Although\n         optional, you are encouraged to always specify this header and the\n         X-Search-Location header. Do not obfuscate the address (for example,\n         by changing the last octet to 0). Obfuscating the address results in\n         the location not being anywhere near the device's actual location,\n         which may result in Bing serving erroneous results.\n        :type client_ip: str\n        :param location: A semicolon-delimited list of key/value pairs that\n         describe the client's geographical location. Bing uses the location\n         information to determine safe search behavior and to return relevant\n         local content. Specify the key/value pair as <key>:<value>. The\n         following are the keys that you use to specify the user's location.\n         lat (required): The latitude of the client's location, in degrees. The\n         latitude must be greater than or equal to -90.0 and less than or equal\n         to +90.0. Negative values indicate southern latitudes and positive\n         values indicate northern latitudes. long (required): The longitude of\n         the client's location, in degrees. The longitude must be greater than\n         or equal to -180.0 and less than or equal to +180.0. Negative values\n         indicate western longitudes and positive values indicate eastern\n         longitudes. re (required): The radius, in meters, which specifies the\n         horizontal accuracy of the coordinates. Pass the value returned by the\n         device's location service. Typical values might be 22m for GPS/Wi-Fi,\n         380m for cell tower triangulation, and 18,000m for reverse IP lookup.\n         ts (optional): The UTC UNIX timestamp of when the client was at the\n         location. (The UNIX timestamp is the number of seconds since January\n         1, 1970.) head (optional): The client's relative heading or direction\n         of travel. Specify the direction of travel as degrees from 0 through\n         360, counting clockwise relative to true north. Specify this key only\n         if the sp key is nonzero. sp (optional): The horizontal velocity\n         (speed), in meters per second, that the client device is traveling.\n         alt (optional): The altitude of the client device, in meters. are\n         (optional): The radius, in meters, that specifies the vertical\n         accuracy of the coordinates. Specify this key only if you specify the\n         alt key. Although many of the keys are optional, the more information\n         that you provide, the more accurate the location results are. Although\n         optional, you are encouraged to always specify the user's geographical\n         location. Providing the location is especially important if the\n         client's IP address does not accurately reflect the user's physical\n         location (for example, if the client uses VPN). For optimal results,\n         you should include this header and the X-MSEdge-ClientIP header, but\n         at a minimum, you should include this header.\n        :type location: str\n        :param country_code: A 2-character country code of the country where\n         the results come from. This API supports only the United States\n         market. If you specify this query parameter, it must be set to us. If\n         you set this parameter, you must also specify the Accept-Language\n         header. Bing uses the first supported language it finds from the\n         languages list, and combine that language with the country code that\n         you specify to determine the market to return results for. If the\n         languages list does not include a supported language, Bing finds the\n         closest language and market that supports the request, or it may use\n         an aggregated or default market for the results instead of a specified\n         one. You should use this query parameter and the Accept-Language query\n         parameter only if you specify multiple languages; otherwise, you\n         should use the mkt and setLang query parameters. This parameter and\n         the mkt query parameter are mutually exclusive\u2014do not specify both.\n        :type country_code: str\n        :param market: The market where the results come from. You are\n         strongly encouraged to always specify the market, if known. Specifying\n         the market helps Bing route the request and return an appropriate and\n         optimal response. This parameter and the cc query parameter are\n         mutually exclusive\u2014do not specify both.\n        :type market: str\n        :param response_filter: A comma-delimited list of answers to include\n         in the response. If you do not specify this parameter, the response\n         includes all search answers for which there's relevant data.\n        :type response_filter: list[str or\n         ~azure.cognitiveservices.search.entitysearch.models.AnswerType]\n        :param response_format: The media type to use for the response. The\n         following are the possible case-insensitive values: JSON, JSONLD. The\n         default is JSON. If you specify JSONLD, the response body includes\n         JSON-LD objects that contain the search results.\n        :type response_format: list[str or\n         ~azure.cognitiveservices.search.entitysearch.models.ResponseFormat]\n        :param safe_search: A filter used to filter adult content. Off: Return\n         webpages with adult text, images, or videos. Moderate: Return webpages\n         with adult text, but not adult images or videos. Strict: Do not return\n         webpages with adult text, images, or videos. The default is Moderate.\n         If the request comes from a market that Bing's adult policy requires\n         that safeSearch is set to Strict, Bing ignores the safeSearch value\n         and uses Strict. If you use the site: query operator, there is the\n         chance that the response may contain adult content regardless of what\n         the safeSearch query parameter is set to. Use site: only if you are\n         aware of the content on the site and your scenario supports the\n         possibility of adult content. Possible values include: 'Off',\n         'Moderate', 'Strict'\n        :type safe_search: str or\n         ~azure.cognitiveservices.search.entitysearch.models.SafeSearch\n        :param set_lang: The language to use for user interface strings.\n         Specify the language using the ISO 639-1 2-letter language code. For\n         example, the language code for English is EN. The default is EN\n         (English). Although optional, you should always specify the language.\n         Typically, you set setLang to the same language specified by mkt\n         unless the user wants the user interface strings displayed in a\n         different language. This parameter and the Accept-Language header are\n         mutually exclusive; do not specify both. A user interface string is a\n         string that's used as a label in a user interface. There are few user\n         interface strings in the JSON response objects. Also, any links to\n         Bing.com properties in the response objects apply the specified\n         language.\n        :type set_lang: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SearchResponse or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.cognitiveservices.search.entitysearch.models.SearchResponse or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.search.entitysearch.models.ErrorResponseException>`", "id": "f28025:c0:m1"}
{"signature": "def detect_image_url_with_no_store(<EOL>self, project_id, published_name, url, application=None, custom_headers=None, raw=False, **operation_config):", "body": "image_url = models.ImageUrl(url=url)<EOL>url = self.detect_image_url_with_no_store.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", project_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", published_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if application is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", application, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.api_key, '<STR_LIT:str>')<EOL>body_content = self._serialize.body(image_url, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.CustomVisionErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Detect objects in an image url without saving the result.\n\n        :param project_id: The project id.\n        :type project_id: str\n        :param published_name: Specifies the name of the model to evaluate\n         against.\n        :type published_name: str\n        :param url: Url of the image.\n        :type url: str\n        :param application: Optional. Specifies the name of application using\n         the endpoint.\n        :type application: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ImagePrediction or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.cognitiveservices.vision.customvision.prediction.models.ImagePrediction\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`CustomVisionErrorException<azure.cognitiveservices.vision.customvision.prediction.models.CustomVisionErrorException>`", "id": "f28043:c1:m7"}
{"signature": "def create_project(<EOL>self, name, description=None, domain_id=None, classification_type=None, target_export_platforms=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_project.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT:name>'] = self._serialize.query(\"<STR_LIT:name>\", name, '<STR_LIT:str>')<EOL>if description is not None:<EOL><INDENT>query_parameters['<STR_LIT:description>'] = self._serialize.query(\"<STR_LIT:description>\", description, '<STR_LIT:str>')<EOL><DEDENT>if domain_id is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", domain_id, '<STR_LIT:str>')<EOL><DEDENT>if classification_type is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", classification_type, '<STR_LIT:str>')<EOL><DEDENT>if target_export_platforms is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", target_export_platforms, '<STR_LIT>', div='<STR_LIT:U+002C>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.api_key, '<STR_LIT:str>')<EOL>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.CustomVisionErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Create a project.\n\n        :param name: Name of the project.\n        :type name: str\n        :param description: The description of the project.\n        :type description: str\n        :param domain_id: The id of the domain to use for this project.\n         Defaults to General.\n        :type domain_id: str\n        :param classification_type: The type of classifier to create for this\n         project. Possible values include: 'Multiclass', 'Multilabel'\n        :type classification_type: str\n        :param target_export_platforms: List of platforms the trained model is\n         intending exporting to.\n        :type target_export_platforms: list[str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Project or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.cognitiveservices.vision.customvision.training.models.Project\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`CustomVisionErrorException<azure.cognitiveservices.vision.customvision.training.models.CustomVisionErrorException>`", "id": "f28122:c1:m26"}
{"signature": "def delete_tag(<EOL>self, project_id, tag_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete_tag.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", project_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", tag_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.api_key, '<STR_LIT:str>')<EOL>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.CustomVisionErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Delete a tag from the project.\n\n        :param project_id: The project id.\n        :type project_id: str\n        :param tag_id: Id of the tag to be deleted.\n        :type tag_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`CustomVisionErrorException<azure.cognitiveservices.vision.customvision.training.models.CustomVisionErrorException>`", "id": "f28122:c1:m40"}
{"signature": "def get_untagged_images(<EOL>self, project_id, iteration_id=None, order_by=None, take=<NUM_LIT:50>, skip=<NUM_LIT:0>, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_untagged_images.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", project_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if iteration_id is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", iteration_id, '<STR_LIT:str>')<EOL><DEDENT>if order_by is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", order_by, '<STR_LIT:str>')<EOL><DEDENT>if take is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", take, '<STR_LIT:int>', maximum=<NUM_LIT>, minimum=<NUM_LIT:0>)<EOL><DEDENT>if skip is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", skip, '<STR_LIT:int>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.api_key, '<STR_LIT:str>')<EOL>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.CustomVisionErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get untagged images for a given project iteration.\n\n        This API supports batching and range selection. By default it will only\n        return first 50 images matching images.\n        Use the {take} and {skip} parameters to control how many images to\n        return in a given batch.\n\n        :param project_id: The project id.\n        :type project_id: str\n        :param iteration_id: The iteration id. Defaults to workspace.\n        :type iteration_id: str\n        :param order_by: The ordering. Defaults to newest. Possible values\n         include: 'Newest', 'Oldest'\n        :type order_by: str\n        :param take: Maximum number of images to return. Defaults to 50,\n         limited to 256.\n        :type take: int\n        :param skip: Number of images to skip before beginning the image\n         batch. Defaults to 0.\n        :type skip: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype:\n         list[~azure.cognitiveservices.vision.customvision.training.models.Image]\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`CustomVisionErrorException<azure.cognitiveservices.vision.customvision.training.models.CustomVisionErrorException>`", "id": "f28122:c1:m10"}
{"signature": "def update_project(<EOL>self, project_id, updated_project, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.update_project.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", project_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.api_key, '<STR_LIT:str>')<EOL>body_content = self._serialize.body(updated_project, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.CustomVisionErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Update a specific project.\n\n        :param project_id: The id of the project to update.\n        :type project_id: str\n        :param updated_project: The updated project model.\n        :type updated_project:\n         ~azure.cognitiveservices.vision.customvision.training.models.Project\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Project or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.cognitiveservices.vision.customvision.training.models.Project\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`CustomVisionErrorException<azure.cognitiveservices.vision.customvision.training.models.CustomVisionErrorException>`", "id": "f28122:c1:m29"}
{"signature": "def get_tags(<EOL>self, project_id, iteration_id=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_tags.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", project_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if iteration_id is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", iteration_id, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.api_key, '<STR_LIT:str>')<EOL>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.CustomVisionErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the tags for a given project and iteration.\n\n        :param project_id: The project id.\n        :type project_id: str\n        :param iteration_id: The iteration id. Defaults to workspace.\n        :type iteration_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype:\n         list[~azure.cognitiveservices.vision.customvision.training.models.Tag]\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`CustomVisionErrorException<azure.cognitiveservices.vision.customvision.training.models.CustomVisionErrorException>`", "id": "f28122:c1:m42"}
{"signature": "def unpublish_iteration(<EOL>self, project_id, iteration_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.unpublish_iteration.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", project_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", iteration_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.api_key, '<STR_LIT:str>')<EOL>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.CustomVisionErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Unpublish a specific iteration.\n\n        :param project_id: The project id.\n        :type project_id: str\n        :param iteration_id: The iteration id.\n        :type iteration_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`CustomVisionErrorException<azure.cognitiveservices.vision.customvision.training.models.CustomVisionErrorException>`", "id": "f28122:c1:m36"}
{"signature": "def train_project(<EOL>self, project_id, training_type=None, reserved_budget_in_hours=<NUM_LIT:0>, force_train=False, notification_email_address=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.train_project.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", project_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if training_type is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", training_type, '<STR_LIT:str>')<EOL><DEDENT>if reserved_budget_in_hours is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", reserved_budget_in_hours, '<STR_LIT:int>')<EOL><DEDENT>if force_train is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", force_train, '<STR_LIT:bool>')<EOL><DEDENT>if notification_email_address is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", notification_email_address, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.api_key, '<STR_LIT:str>')<EOL>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.CustomVisionErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Queues project for training.\n\n        :param project_id: The project id.\n        :type project_id: str\n        :param training_type: The type of training to use to train the project\n         (default: Regular). Possible values include: 'Regular', 'Advanced'\n        :type training_type: str\n        :param reserved_budget_in_hours: The number of hours reserved as\n         budget for training (if applicable).\n        :type reserved_budget_in_hours: int\n        :param force_train: Whether to force train even if dataset and\n         configuration does not change (default: false).\n        :type force_train: bool\n        :param notification_email_address: The email address to send\n         notification to when training finishes (default: null).\n        :type notification_email_address: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Iteration or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.cognitiveservices.vision.customvision.training.models.Iteration\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`CustomVisionErrorException<azure.cognitiveservices.vision.customvision.training.models.CustomVisionErrorException>`", "id": "f28122:c1:m30"}
{"signature": "def create_images_from_urls(<EOL>self, project_id, images=None, tag_ids=None, custom_headers=None, raw=False, **operation_config):", "body": "batch = models.ImageUrlCreateBatch(images=images, tag_ids=tag_ids)<EOL>url = self.create_images_from_urls.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", project_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.api_key, '<STR_LIT:str>')<EOL>body_content = self._serialize.body(batch, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.CustomVisionErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Add the provided images urls to the set of training images.\n\n        This API accepts a batch of urls, and optionally tags, to create\n        images. There is a limit of 64 images and 20 tags.\n\n        :param project_id: The project id.\n        :type project_id: str\n        :param images:\n        :type images:\n         list[~azure.cognitiveservices.vision.customvision.training.models.ImageUrlCreateEntry]\n        :param tag_ids:\n        :type tag_ids: list[str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ImageCreateSummary or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.cognitiveservices.vision.customvision.training.models.ImageCreateSummary\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`CustomVisionErrorException<azure.cognitiveservices.vision.customvision.training.models.CustomVisionErrorException>`", "id": "f28122:c1:m15"}
{"signature": "def create_images_from_files(<EOL>self, project_id, images=None, tag_ids=None, custom_headers=None, raw=False, **operation_config):", "body": "batch = models.ImageFileCreateBatch(images=images, tag_ids=tag_ids)<EOL>url = self.create_images_from_files.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", project_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.api_key, '<STR_LIT:str>')<EOL>body_content = self._serialize.body(batch, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.CustomVisionErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Add the provided batch of images to the set of training images.\n\n        This API accepts a batch of files, and optionally tags, to create\n        images. There is a limit of 64 images and 20 tags.\n\n        :param project_id: The project id.\n        :type project_id: str\n        :param images:\n        :type images:\n         list[~azure.cognitiveservices.vision.customvision.training.models.ImageFileCreateEntry]\n        :param tag_ids:\n        :type tag_ids: list[str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ImageCreateSummary or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.cognitiveservices.vision.customvision.training.models.ImageCreateSummary\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`CustomVisionErrorException<azure.cognitiveservices.vision.customvision.training.models.CustomVisionErrorException>`", "id": "f28122:c1:m14"}
{"signature": "def get_untagged_image_count(<EOL>self, project_id, iteration_id=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_untagged_image_count.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", project_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if iteration_id is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", iteration_id, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.api_key, '<STR_LIT:str>')<EOL>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.CustomVisionErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT:int>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the number of untagged images.\n\n        This API returns the images which have no tags for a given project and\n        optionally an iteration. If no iteration is specified the\n        current workspace is used.\n\n        :param project_id: The project id.\n        :type project_id: str\n        :param iteration_id: The iteration id. Defaults to workspace.\n        :type iteration_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: int or ClientRawResponse if raw=true\n        :rtype: int or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`CustomVisionErrorException<azure.cognitiveservices.vision.customvision.training.models.CustomVisionErrorException>`", "id": "f28122:c1:m4"}
{"signature": "def get_projects(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_projects.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.api_key, '<STR_LIT:str>')<EOL>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.CustomVisionErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get your projects.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype:\n         list[~azure.cognitiveservices.vision.customvision.training.models.Project]\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`CustomVisionErrorException<azure.cognitiveservices.vision.customvision.training.models.CustomVisionErrorException>`", "id": "f28122:c1:m25"}
{"signature": "def create_tag(<EOL>self, project_id, name, description=None, type=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_tag.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", project_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT:name>'] = self._serialize.query(\"<STR_LIT:name>\", name, '<STR_LIT:str>')<EOL>if description is not None:<EOL><INDENT>query_parameters['<STR_LIT:description>'] = self._serialize.query(\"<STR_LIT:description>\", description, '<STR_LIT:str>')<EOL><DEDENT>if type is not None:<EOL><INDENT>query_parameters['<STR_LIT:type>'] = self._serialize.query(\"<STR_LIT:type>\", type, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.api_key, '<STR_LIT:str>')<EOL>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.CustomVisionErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Create a tag for the project.\n\n        :param project_id: The project id.\n        :type project_id: str\n        :param name: The tag name.\n        :type name: str\n        :param description: Optional description for the tag.\n        :type description: str\n        :param type: Optional type for the tag. Possible values include:\n         'Regular', 'Negative'\n        :type type: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Tag or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.cognitiveservices.vision.customvision.training.models.Tag or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`CustomVisionErrorException<azure.cognitiveservices.vision.customvision.training.models.CustomVisionErrorException>`", "id": "f28122:c1:m43"}
{"signature": "def update_tag(<EOL>self, project_id, tag_id, updated_tag, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.update_tag.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", project_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", tag_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.api_key, '<STR_LIT:str>')<EOL>body_content = self._serialize.body(updated_tag, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.CustomVisionErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Update a tag.\n\n        :param project_id: The project id.\n        :type project_id: str\n        :param tag_id: The id of the target tag.\n        :type tag_id: str\n        :param updated_tag: The updated tag model.\n        :type updated_tag:\n         ~azure.cognitiveservices.vision.customvision.training.models.Tag\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Tag or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.cognitiveservices.vision.customvision.training.models.Tag or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`CustomVisionErrorException<azure.cognitiveservices.vision.customvision.training.models.CustomVisionErrorException>`", "id": "f28122:c1:m41"}
{"signature": "def create_image_tags(<EOL>self, project_id, tags=None, custom_headers=None, raw=False, **operation_config):", "body": "batch = models.ImageTagCreateBatch(tags=tags)<EOL>url = self.create_image_tags.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", project_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.api_key, '<STR_LIT:str>')<EOL>body_content = self._serialize.body(batch, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.CustomVisionErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Associate a set of images with a set of tags.\n\n        :param project_id: The project id.\n        :type project_id: str\n        :param tags: Image Tag entries to include in this batch.\n        :type tags:\n         list[~azure.cognitiveservices.vision.customvision.training.models.ImageTagCreateEntry]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ImageTagCreateSummary or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.cognitiveservices.vision.customvision.training.models.ImageTagCreateSummary\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`CustomVisionErrorException<azure.cognitiveservices.vision.customvision.training.models.CustomVisionErrorException>`", "id": "f28122:c1:m5"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.OperationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.OperationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all of the available REST API operations of the Microsoft.Search\n        provider.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Operation\n        :rtype:\n         ~azure.mgmt.search.models.OperationPaged[~azure.mgmt.search.models.Operation]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28154:c0:m1"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, search_management_request_options=None, custom_headers=None, raw=False, **operation_config):", "body": "client_request_id = None<EOL>if search_management_request_options is not None:<EOL><INDENT>client_request_id = search_management_request_options.client_request_id<EOL><DEDENT>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SearchServicePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SearchServicePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of all Search services in the given resource group.\n\n        :param resource_group_name: The name of the resource group within the\n         current subscription. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param search_management_request_options: Additional parameters for\n         the operation\n        :type search_management_request_options:\n         ~azure.mgmt.search.models.SearchManagementRequestOptions\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of SearchService\n        :rtype:\n         ~azure.mgmt.search.models.SearchServicePaged[~azure.mgmt.search.models.SearchService]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28155:c0:m6"}
{"signature": "def delete(<EOL>self, resource_group_name, search_service_name, search_management_request_options=None, custom_headers=None, raw=False, **operation_config):", "body": "client_request_id = None<EOL>if search_management_request_options is not None:<EOL><INDENT>client_request_id = search_management_request_options.client_request_id<EOL><DEDENT>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", search_service_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes a Search service in the given resource group, along with its\n        associated resources.\n\n        :param resource_group_name: The name of the resource group within the\n         current subscription. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param search_service_name: The name of the Azure Search service\n         associated with the specified resource group.\n        :type search_service_name: str\n        :param search_management_request_options: Additional parameters for\n         the operation\n        :type search_management_request_options:\n         ~azure.mgmt.search.models.SearchManagementRequestOptions\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28155:c0:m5"}
{"signature": "def regenerate(<EOL>self, resource_group_name, search_service_name, key_kind, search_management_request_options=None, custom_headers=None, raw=False, **operation_config):", "body": "client_request_id = None<EOL>if search_management_request_options is not None:<EOL><INDENT>client_request_id = search_management_request_options.client_request_id<EOL><DEDENT>url = self.regenerate.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", search_service_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", key_kind, '<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Regenerates either the primary or secondary admin API key. You can only\n        regenerate one key at a time.\n\n        :param resource_group_name: The name of the resource group within the\n         current subscription. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param search_service_name: The name of the Azure Search service\n         associated with the specified resource group.\n        :type search_service_name: str\n        :param key_kind: Specifies which key to regenerate. Valid values\n         include 'primary' and 'secondary'. Possible values include: 'primary',\n         'secondary'\n        :type key_kind: str or ~azure.mgmt.search.models.AdminKeyKind\n        :param search_management_request_options: Additional parameters for\n         the operation\n        :type search_management_request_options:\n         ~azure.mgmt.search.models.SearchManagementRequestOptions\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: AdminKeyResult or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.search.models.AdminKeyResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28156:c0:m2"}
{"signature": "def get_preparer_resource_name(self, prefix):", "body": "return self.get_resource_name(prefix or self.qualified_test_name.replace('<STR_LIT:.>', '<STR_LIT:_>'))<EOL>", "docstring": "Random name generation for use by preparers.\n\n        If prefix is a blank string, use the fully qualified test name instead.\n        This is what legacy tests do for resource groups.", "id": "f28165:c1:m13"}
{"signature": "def get_resource_name(self, name):", "body": "return self.create_random_name(name)<EOL>", "docstring": "Alias to create_random_name for back compatibility.", "id": "f28165:c1:m12"}
{"signature": "def parse_input(input_parameter):", "body": "split_package_name = input_parameter.split('<STR_LIT:#>')<EOL>package_name = split_package_name[<NUM_LIT:0>]<EOL>module_name = package_name.replace(\"<STR_LIT:->\", \"<STR_LIT:.>\")<EOL>if len(split_package_name) >= <NUM_LIT:2>:<EOL><INDENT>module_name = \"<STR_LIT:.>\".join([module_name, split_package_name[<NUM_LIT:1>]])<EOL><DEDENT>return package_name, module_name<EOL>", "docstring": "From a syntax like package_name#submodule, build a package name\n    and complete module name.", "id": "f28166:m0"}
{"signature": "def find_autorest_generated_folder(module_prefix=\"<STR_LIT>\"):", "body": "_LOGGER.info(f\"<STR_LIT>\")<EOL>if module_prefix in [\"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>_LOGGER.info(f\"<STR_LIT>\")<EOL>return []<EOL><DEDENT>result = []<EOL>try:<EOL><INDENT>_LOGGER.debug(f\"<STR_LIT>\")<EOL>model_module = importlib.import_module(\"<STR_LIT>\", module_prefix)<EOL>model_module.__path__<EOL>_LOGGER.info(f\"<STR_LIT>\")<EOL>result.append(module_prefix)<EOL><DEDENT>except (ModuleNotFoundError, AttributeError):<EOL><INDENT>prefix_module = importlib.import_module(module_prefix)<EOL>for _, sub_package, ispkg in pkgutil.iter_modules(prefix_module.__path__, module_prefix+\"<STR_LIT:.>\"):<EOL><INDENT>if ispkg:<EOL><INDENT>result += find_autorest_generated_folder(sub_package)<EOL><DEDENT><DEDENT><DEDENT>return result<EOL>", "docstring": "Find all Autorest generated code in that module prefix.\n    This actually looks for a \"models\" package only (not file). We could be smarter if necessary.", "id": "f28166:m5"}
{"signature": "def create(env_dir, system_site_packages=False, clear=False,<EOL>symlinks=False, with_pip=False, prompt=None):", "body": "builder = ExtendedEnvBuilder(system_site_packages=system_site_packages,<EOL>clear=clear, symlinks=symlinks, with_pip=with_pip,<EOL>prompt=prompt)<EOL>builder.create(env_dir)<EOL>return builder.context<EOL>", "docstring": "Create a virtual environment in a directory.", "id": "f28167:m0"}
{"signature": "def task_collection_thread_handler(self, results_queue):", "body": "<EOL>while self.tasks_to_add and not self.errors:<EOL><INDENT>max_tasks = self._max_tasks_per_request  <EOL>chunk_tasks_to_add = []<EOL>with self._pending_queue_lock:<EOL><INDENT>while len(chunk_tasks_to_add) < max_tasks and self.tasks_to_add:<EOL><INDENT>chunk_tasks_to_add.append(self.tasks_to_add.pop())<EOL><DEDENT><DEDENT>if chunk_tasks_to_add:<EOL><INDENT>self._bulk_add_tasks(results_queue, chunk_tasks_to_add)<EOL><DEDENT><DEDENT>", "docstring": "Main method for worker to run\n\n        Pops a chunk of tasks off the collection of pending tasks to be added and submits them to be added.\n\n        :param collections.deque results_queue: Queue for worker to output results to", "id": "f28183:c0:m2"}
{"signature": "def upload_batch_service_logs(<EOL>self, pool_id, node_id, upload_batch_service_logs_configuration, compute_node_upload_batch_service_logs_options=None, custom_headers=None, raw=False, **operation_config):", "body": "timeout = None<EOL>if compute_node_upload_batch_service_logs_options is not None:<EOL><INDENT>timeout = compute_node_upload_batch_service_logs_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if compute_node_upload_batch_service_logs_options is not None:<EOL><INDENT>client_request_id = compute_node_upload_batch_service_logs_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if compute_node_upload_batch_service_logs_options is not None:<EOL><INDENT>return_client_request_id = compute_node_upload_batch_service_logs_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if compute_node_upload_batch_service_logs_options is not None:<EOL><INDENT>ocp_date = compute_node_upload_batch_service_logs_options.ocp_date<EOL><DEDENT>url = self.upload_batch_service_logs.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.batch_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", pool_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", node_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT:int>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>if return_client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", return_client_request_id, '<STR_LIT:bool>')<EOL><DEDENT>if ocp_date is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", ocp_date, '<STR_LIT>')<EOL><DEDENT>body_content = self._serialize.body(upload_batch_service_logs_configuration, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.BatchErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>header_dict = {}<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>header_dict = {<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>}<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>client_raw_response.add_headers(header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Upload Azure Batch service log files from the specified compute node to\n        Azure Blob Storage.\n\n        This is for gathering Azure Batch service log files in an automated\n        fashion from nodes if you are experiencing an error and wish to\n        escalate to Azure support. The Azure Batch service log files should be\n        shared with Azure support to aid in debugging issues with the Batch\n        service.\n\n        :param pool_id: The ID of the pool that contains the compute node.\n        :type pool_id: str\n        :param node_id: The ID of the compute node from which you want to\n         upload the Azure Batch service log files.\n        :type node_id: str\n        :param upload_batch_service_logs_configuration: The Azure Batch\n         service log files upload configuration.\n        :type upload_batch_service_logs_configuration:\n         ~azure.batch.models.UploadBatchServiceLogsConfiguration\n        :param compute_node_upload_batch_service_logs_options: Additional\n         parameters for the operation\n        :type compute_node_upload_batch_service_logs_options:\n         ~azure.batch.models.ComputeNodeUploadBatchServiceLogsOptions\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: UploadBatchServiceLogsResult or ClientRawResponse if raw=true\n        :rtype: ~azure.batch.models.UploadBatchServiceLogsResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`BatchErrorException<azure.batch.models.BatchErrorException>`", "id": "f28191:c0:m11"}
{"signature": "def add_user(<EOL>self, pool_id, node_id, user, compute_node_add_user_options=None, custom_headers=None, raw=False, **operation_config):", "body": "timeout = None<EOL>if compute_node_add_user_options is not None:<EOL><INDENT>timeout = compute_node_add_user_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if compute_node_add_user_options is not None:<EOL><INDENT>client_request_id = compute_node_add_user_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if compute_node_add_user_options is not None:<EOL><INDENT>return_client_request_id = compute_node_add_user_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if compute_node_add_user_options is not None:<EOL><INDENT>ocp_date = compute_node_add_user_options.ocp_date<EOL><DEDENT>url = self.add_user.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.batch_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", pool_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", node_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT:int>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>if return_client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", return_client_request_id, '<STR_LIT:bool>')<EOL><DEDENT>if ocp_date is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", ocp_date, '<STR_LIT>')<EOL><DEDENT>body_content = self._serialize.body(user, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.BatchErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>client_raw_response.add_headers({<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>})<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Adds a user account to the specified compute node.\n\n        You can add a user account to a node only when it is in the idle or\n        running state.\n\n        :param pool_id: The ID of the pool that contains the compute node.\n        :type pool_id: str\n        :param node_id: The ID of the machine on which you want to create a\n         user account.\n        :type node_id: str\n        :param user: The user account to be created.\n        :type user: ~azure.batch.models.ComputeNodeUser\n        :param compute_node_add_user_options: Additional parameters for the\n         operation\n        :type compute_node_add_user_options:\n         ~azure.batch.models.ComputeNodeAddUserOptions\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`BatchErrorException<azure.batch.models.BatchErrorException>`", "id": "f28191:c0:m1"}
{"signature": "def get_remote_desktop(<EOL>self, pool_id, node_id, compute_node_get_remote_desktop_options=None, custom_headers=None, raw=False, callback=None, **operation_config):", "body": "timeout = None<EOL>if compute_node_get_remote_desktop_options is not None:<EOL><INDENT>timeout = compute_node_get_remote_desktop_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if compute_node_get_remote_desktop_options is not None:<EOL><INDENT>client_request_id = compute_node_get_remote_desktop_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if compute_node_get_remote_desktop_options is not None:<EOL><INDENT>return_client_request_id = compute_node_get_remote_desktop_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if compute_node_get_remote_desktop_options is not None:<EOL><INDENT>ocp_date = compute_node_get_remote_desktop_options.ocp_date<EOL><DEDENT>url = self.get_remote_desktop.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.batch_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", pool_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", node_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT:int>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>if return_client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", return_client_request_id, '<STR_LIT:bool>')<EOL><DEDENT>if ocp_date is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", ocp_date, '<STR_LIT>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=True, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.BatchErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>header_dict = {}<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._client.stream_download(response, callback)<EOL>header_dict = {<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>}<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>client_raw_response.add_headers(header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the Remote Desktop Protocol file for the specified compute node.\n\n        Before you can access a node by using the RDP file, you must create a\n        user account on the node. This API can only be invoked on pools created\n        with a cloud service configuration. For pools created with a virtual\n        machine configuration, see the GetRemoteLoginSettings API.\n\n        :param pool_id: The ID of the pool that contains the compute node.\n        :type pool_id: str\n        :param node_id: The ID of the compute node for which you want to get\n         the Remote Desktop Protocol file.\n        :type node_id: str\n        :param compute_node_get_remote_desktop_options: Additional parameters\n         for the operation\n        :type compute_node_get_remote_desktop_options:\n         ~azure.batch.models.ComputeNodeGetRemoteDesktopOptions\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param callback: When specified, will be called with each chunk of\n         data that is streamed. The callback should take two arguments, the\n         bytes of the current chunk of data and the response object. If the\n         data is uploading, response will be None.\n        :type callback: Callable[Bytes, response=None]\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: object or ClientRawResponse if raw=true\n        :rtype: Generator or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`BatchErrorException<azure.batch.models.BatchErrorException>`", "id": "f28191:c0:m10"}
{"signature": "def update_user(<EOL>self, pool_id, node_id, user_name, node_update_user_parameter, compute_node_update_user_options=None, custom_headers=None, raw=False, **operation_config):", "body": "timeout = None<EOL>if compute_node_update_user_options is not None:<EOL><INDENT>timeout = compute_node_update_user_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if compute_node_update_user_options is not None:<EOL><INDENT>client_request_id = compute_node_update_user_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if compute_node_update_user_options is not None:<EOL><INDENT>return_client_request_id = compute_node_update_user_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if compute_node_update_user_options is not None:<EOL><INDENT>ocp_date = compute_node_update_user_options.ocp_date<EOL><DEDENT>url = self.update_user.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.batch_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", pool_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", node_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", user_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT:int>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>if return_client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", return_client_request_id, '<STR_LIT:bool>')<EOL><DEDENT>if ocp_date is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", ocp_date, '<STR_LIT>')<EOL><DEDENT>body_content = self._serialize.body(node_update_user_parameter, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.BatchErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>client_raw_response.add_headers({<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>})<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Updates the password and expiration time of a user account on the\n        specified compute node.\n\n        This operation replaces of all the updateable properties of the\n        account. For example, if the expiryTime element is not specified, the\n        current value is replaced with the default value, not left unmodified.\n        You can update a user account on a node only when it is in the idle or\n        running state.\n\n        :param pool_id: The ID of the pool that contains the compute node.\n        :type pool_id: str\n        :param node_id: The ID of the machine on which you want to update a\n         user account.\n        :type node_id: str\n        :param user_name: The name of the user account to update.\n        :type user_name: str\n        :param node_update_user_parameter: The parameters for the request.\n        :type node_update_user_parameter:\n         ~azure.batch.models.NodeUpdateUserParameter\n        :param compute_node_update_user_options: Additional parameters for the\n         operation\n        :type compute_node_update_user_options:\n         ~azure.batch.models.ComputeNodeUpdateUserOptions\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`BatchErrorException<azure.batch.models.BatchErrorException>`", "id": "f28191:c0:m3"}
{"signature": "def get_properties_from_compute_node(<EOL>self, pool_id, node_id, file_path, file_get_properties_from_compute_node_options=None, custom_headers=None, raw=False, **operation_config):", "body": "timeout = None<EOL>if file_get_properties_from_compute_node_options is not None:<EOL><INDENT>timeout = file_get_properties_from_compute_node_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if file_get_properties_from_compute_node_options is not None:<EOL><INDENT>client_request_id = file_get_properties_from_compute_node_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if file_get_properties_from_compute_node_options is not None:<EOL><INDENT>return_client_request_id = file_get_properties_from_compute_node_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if file_get_properties_from_compute_node_options is not None:<EOL><INDENT>ocp_date = file_get_properties_from_compute_node_options.ocp_date<EOL><DEDENT>if_modified_since = None<EOL>if file_get_properties_from_compute_node_options is not None:<EOL><INDENT>if_modified_since = file_get_properties_from_compute_node_options.if_modified_since<EOL><DEDENT>if_unmodified_since = None<EOL>if file_get_properties_from_compute_node_options is not None:<EOL><INDENT>if_unmodified_since = file_get_properties_from_compute_node_options.if_unmodified_since<EOL><DEDENT>url = self.get_properties_from_compute_node.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.batch_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", pool_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", node_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", file_path, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT:int>')<EOL><DEDENT>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>if return_client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", return_client_request_id, '<STR_LIT:bool>')<EOL><DEDENT>if ocp_date is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", ocp_date, '<STR_LIT>')<EOL><DEDENT>if if_modified_since is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_modified_since, '<STR_LIT>')<EOL><DEDENT>if if_unmodified_since is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_unmodified_since, '<STR_LIT>')<EOL><DEDENT>request = self._client.head(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.BatchErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>client_raw_response.add_headers({<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT:bool>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT:Content-Type>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>})<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Gets the properties of the specified compute node file.\n\n        :param pool_id: The ID of the pool that contains the compute node.\n        :type pool_id: str\n        :param node_id: The ID of the compute node that contains the file.\n        :type node_id: str\n        :param file_path: The path to the compute node file that you want to\n         get the properties of.\n        :type file_path: str\n        :param file_get_properties_from_compute_node_options: Additional\n         parameters for the operation\n        :type file_get_properties_from_compute_node_options:\n         ~azure.batch.models.FileGetPropertiesFromComputeNodeOptions\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`BatchErrorException<azure.batch.models.BatchErrorException>`", "id": "f28193:c0:m6"}
{"signature": "def get_from_task(<EOL>self, job_id, task_id, file_path, file_get_from_task_options=None, custom_headers=None, raw=False, callback=None, **operation_config):", "body": "timeout = None<EOL>if file_get_from_task_options is not None:<EOL><INDENT>timeout = file_get_from_task_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if file_get_from_task_options is not None:<EOL><INDENT>client_request_id = file_get_from_task_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if file_get_from_task_options is not None:<EOL><INDENT>return_client_request_id = file_get_from_task_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if file_get_from_task_options is not None:<EOL><INDENT>ocp_date = file_get_from_task_options.ocp_date<EOL><DEDENT>ocp_range = None<EOL>if file_get_from_task_options is not None:<EOL><INDENT>ocp_range = file_get_from_task_options.ocp_range<EOL><DEDENT>if_modified_since = None<EOL>if file_get_from_task_options is not None:<EOL><INDENT>if_modified_since = file_get_from_task_options.if_modified_since<EOL><DEDENT>if_unmodified_since = None<EOL>if file_get_from_task_options is not None:<EOL><INDENT>if_unmodified_since = file_get_from_task_options.if_unmodified_since<EOL><DEDENT>url = self.get_from_task.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.batch_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", job_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", task_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", file_path, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT:int>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>if return_client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", return_client_request_id, '<STR_LIT:bool>')<EOL><DEDENT>if ocp_date is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", ocp_date, '<STR_LIT>')<EOL><DEDENT>if ocp_range is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", ocp_range, '<STR_LIT:str>')<EOL><DEDENT>if if_modified_since is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_modified_since, '<STR_LIT>')<EOL><DEDENT>if if_unmodified_since is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_unmodified_since, '<STR_LIT>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=True, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.BatchErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>header_dict = {}<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._client.stream_download(response, callback)<EOL>header_dict = {<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT:bool>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT:Content-Type>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>}<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>client_raw_response.add_headers(header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Returns the content of the specified task file.\n\n        :param job_id: The ID of the job that contains the task.\n        :type job_id: str\n        :param task_id: The ID of the task whose file you want to retrieve.\n        :type task_id: str\n        :param file_path: The path to the task file that you want to get the\n         content of.\n        :type file_path: str\n        :param file_get_from_task_options: Additional parameters for the\n         operation\n        :type file_get_from_task_options:\n         ~azure.batch.models.FileGetFromTaskOptions\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param callback: When specified, will be called with each chunk of\n         data that is streamed. The callback should take two arguments, the\n         bytes of the current chunk of data and the response object. If the\n         data is uploading, response will be None.\n        :type callback: Callable[Bytes, response=None]\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: object or ClientRawResponse if raw=true\n        :rtype: Generator or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`BatchErrorException<azure.batch.models.BatchErrorException>`", "id": "f28193:c0:m2"}
{"signature": "def get(<EOL>self, thumbprint_algorithm, thumbprint, certificate_get_options=None, custom_headers=None, raw=False, **operation_config):", "body": "select = None<EOL>if certificate_get_options is not None:<EOL><INDENT>select = certificate_get_options.select<EOL><DEDENT>timeout = None<EOL>if certificate_get_options is not None:<EOL><INDENT>timeout = certificate_get_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if certificate_get_options is not None:<EOL><INDENT>client_request_id = certificate_get_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if certificate_get_options is not None:<EOL><INDENT>return_client_request_id = certificate_get_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if certificate_get_options is not None:<EOL><INDENT>ocp_date = certificate_get_options.ocp_date<EOL><DEDENT>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.batch_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", thumbprint_algorithm, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", thumbprint, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if select is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", select, '<STR_LIT:str>')<EOL><DEDENT>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT:int>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>if return_client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", return_client_request_id, '<STR_LIT:bool>')<EOL><DEDENT>if ocp_date is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", ocp_date, '<STR_LIT>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.BatchErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>header_dict = {}<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>header_dict = {<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>}<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>client_raw_response.add_headers(header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about the specified certificate.\n\n        :param thumbprint_algorithm: The algorithm used to derive the\n         thumbprint parameter. This must be sha1.\n        :type thumbprint_algorithm: str\n        :param thumbprint: The thumbprint of the certificate to get.\n        :type thumbprint: str\n        :param certificate_get_options: Additional parameters for the\n         operation\n        :type certificate_get_options:\n         ~azure.batch.models.CertificateGetOptions\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Certificate or ClientRawResponse if raw=true\n        :rtype: ~azure.batch.models.Certificate or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`BatchErrorException<azure.batch.models.BatchErrorException>`", "id": "f28194:c0:m5"}
{"signature": "def patch(<EOL>self, job_schedule_id, job_schedule_patch_parameter, job_schedule_patch_options=None, custom_headers=None, raw=False, **operation_config):", "body": "timeout = None<EOL>if job_schedule_patch_options is not None:<EOL><INDENT>timeout = job_schedule_patch_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if job_schedule_patch_options is not None:<EOL><INDENT>client_request_id = job_schedule_patch_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if job_schedule_patch_options is not None:<EOL><INDENT>return_client_request_id = job_schedule_patch_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if job_schedule_patch_options is not None:<EOL><INDENT>ocp_date = job_schedule_patch_options.ocp_date<EOL><DEDENT>if_match = None<EOL>if job_schedule_patch_options is not None:<EOL><INDENT>if_match = job_schedule_patch_options.if_match<EOL><DEDENT>if_none_match = None<EOL>if job_schedule_patch_options is not None:<EOL><INDENT>if_none_match = job_schedule_patch_options.if_none_match<EOL><DEDENT>if_modified_since = None<EOL>if job_schedule_patch_options is not None:<EOL><INDENT>if_modified_since = job_schedule_patch_options.if_modified_since<EOL><DEDENT>if_unmodified_since = None<EOL>if job_schedule_patch_options is not None:<EOL><INDENT>if_unmodified_since = job_schedule_patch_options.if_unmodified_since<EOL><DEDENT>url = self.patch.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.batch_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", job_schedule_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT:int>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>if return_client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", return_client_request_id, '<STR_LIT:bool>')<EOL><DEDENT>if ocp_date is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", ocp_date, '<STR_LIT>')<EOL><DEDENT>if if_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_match, '<STR_LIT:str>')<EOL><DEDENT>if if_none_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_none_match, '<STR_LIT:str>')<EOL><DEDENT>if if_modified_since is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_modified_since, '<STR_LIT>')<EOL><DEDENT>if if_unmodified_since is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_unmodified_since, '<STR_LIT>')<EOL><DEDENT>body_content = self._serialize.body(job_schedule_patch_parameter, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.BatchErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>client_raw_response.add_headers({<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>})<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Updates the properties of the specified job schedule.\n\n        This replaces only the job schedule properties specified in the\n        request. For example, if the schedule property is not specified with\n        this request, then the Batch service will keep the existing schedule.\n        Changes to a job schedule only impact jobs created by the schedule\n        after the update has taken place; currently running jobs are\n        unaffected.\n\n        :param job_schedule_id: The ID of the job schedule to update.\n        :type job_schedule_id: str\n        :param job_schedule_patch_parameter: The parameters for the request.\n        :type job_schedule_patch_parameter:\n         ~azure.batch.models.JobSchedulePatchParameter\n        :param job_schedule_patch_options: Additional parameters for the\n         operation\n        :type job_schedule_patch_options:\n         ~azure.batch.models.JobSchedulePatchOptions\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`BatchErrorException<azure.batch.models.BatchErrorException>`", "id": "f28195:c0:m4"}
{"signature": "def exists(<EOL>self, pool_id, pool_exists_options=None, custom_headers=None, raw=False, **operation_config):", "body": "timeout = None<EOL>if pool_exists_options is not None:<EOL><INDENT>timeout = pool_exists_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if pool_exists_options is not None:<EOL><INDENT>client_request_id = pool_exists_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if pool_exists_options is not None:<EOL><INDENT>return_client_request_id = pool_exists_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if pool_exists_options is not None:<EOL><INDENT>ocp_date = pool_exists_options.ocp_date<EOL><DEDENT>if_match = None<EOL>if pool_exists_options is not None:<EOL><INDENT>if_match = pool_exists_options.if_match<EOL><DEDENT>if_none_match = None<EOL>if pool_exists_options is not None:<EOL><INDENT>if_none_match = pool_exists_options.if_none_match<EOL><DEDENT>if_modified_since = None<EOL>if pool_exists_options is not None:<EOL><INDENT>if_modified_since = pool_exists_options.if_modified_since<EOL><DEDENT>if_unmodified_since = None<EOL>if pool_exists_options is not None:<EOL><INDENT>if_unmodified_since = pool_exists_options.if_unmodified_since<EOL><DEDENT>url = self.exists.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.batch_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", pool_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT:int>')<EOL><DEDENT>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>if return_client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", return_client_request_id, '<STR_LIT:bool>')<EOL><DEDENT>if ocp_date is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", ocp_date, '<STR_LIT>')<EOL><DEDENT>if if_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_match, '<STR_LIT:str>')<EOL><DEDENT>if if_none_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_none_match, '<STR_LIT:str>')<EOL><DEDENT>if if_modified_since is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_modified_since, '<STR_LIT>')<EOL><DEDENT>if if_unmodified_since is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_unmodified_since, '<STR_LIT>')<EOL><DEDENT>request = self._client.head(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.BatchErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = (response.status_code == <NUM_LIT:200>)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>client_raw_response.add_headers({<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>})<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets basic properties of a pool.\n\n        :param pool_id: The ID of the pool to get.\n        :type pool_id: str\n        :param pool_exists_options: Additional parameters for the operation\n        :type pool_exists_options: ~azure.batch.models.PoolExistsOptions\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: bool or ClientRawResponse if raw=true\n        :rtype: bool or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`BatchErrorException<azure.batch.models.BatchErrorException>`", "id": "f28196:c0:m6"}
{"signature": "def resize(<EOL>self, pool_id, pool_resize_parameter, pool_resize_options=None, custom_headers=None, raw=False, **operation_config):", "body": "timeout = None<EOL>if pool_resize_options is not None:<EOL><INDENT>timeout = pool_resize_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if pool_resize_options is not None:<EOL><INDENT>client_request_id = pool_resize_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if pool_resize_options is not None:<EOL><INDENT>return_client_request_id = pool_resize_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if pool_resize_options is not None:<EOL><INDENT>ocp_date = pool_resize_options.ocp_date<EOL><DEDENT>if_match = None<EOL>if pool_resize_options is not None:<EOL><INDENT>if_match = pool_resize_options.if_match<EOL><DEDENT>if_none_match = None<EOL>if pool_resize_options is not None:<EOL><INDENT>if_none_match = pool_resize_options.if_none_match<EOL><DEDENT>if_modified_since = None<EOL>if pool_resize_options is not None:<EOL><INDENT>if_modified_since = pool_resize_options.if_modified_since<EOL><DEDENT>if_unmodified_since = None<EOL>if pool_resize_options is not None:<EOL><INDENT>if_unmodified_since = pool_resize_options.if_unmodified_since<EOL><DEDENT>url = self.resize.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.batch_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", pool_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT:int>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>if return_client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", return_client_request_id, '<STR_LIT:bool>')<EOL><DEDENT>if ocp_date is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", ocp_date, '<STR_LIT>')<EOL><DEDENT>if if_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_match, '<STR_LIT:str>')<EOL><DEDENT>if if_none_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_none_match, '<STR_LIT:str>')<EOL><DEDENT>if if_modified_since is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_modified_since, '<STR_LIT>')<EOL><DEDENT>if if_unmodified_since is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_unmodified_since, '<STR_LIT>')<EOL><DEDENT>body_content = self._serialize.body(pool_resize_parameter, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.BatchErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>client_raw_response.add_headers({<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>})<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Changes the number of compute nodes that are assigned to a pool.\n\n        You can only resize a pool when its allocation state is steady. If the\n        pool is already resizing, the request fails with status code 409. When\n        you resize a pool, the pool's allocation state changes from steady to\n        resizing. You cannot resize pools which are configured for automatic\n        scaling. If you try to do this, the Batch service returns an error 409.\n        If you resize a pool downwards, the Batch service chooses which nodes\n        to remove. To remove specific nodes, use the pool remove nodes API\n        instead.\n\n        :param pool_id: The ID of the pool to resize.\n        :type pool_id: str\n        :param pool_resize_parameter: The parameters for the request.\n        :type pool_resize_parameter: ~azure.batch.models.PoolResizeParameter\n        :param pool_resize_options: Additional parameters for the operation\n        :type pool_resize_options: ~azure.batch.models.PoolResizeOptions\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`BatchErrorException<azure.batch.models.BatchErrorException>`", "id": "f28196:c0:m12"}
{"signature": "def disable_auto_scale(<EOL>self, pool_id, pool_disable_auto_scale_options=None, custom_headers=None, raw=False, **operation_config):", "body": "timeout = None<EOL>if pool_disable_auto_scale_options is not None:<EOL><INDENT>timeout = pool_disable_auto_scale_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if pool_disable_auto_scale_options is not None:<EOL><INDENT>client_request_id = pool_disable_auto_scale_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if pool_disable_auto_scale_options is not None:<EOL><INDENT>return_client_request_id = pool_disable_auto_scale_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if pool_disable_auto_scale_options is not None:<EOL><INDENT>ocp_date = pool_disable_auto_scale_options.ocp_date<EOL><DEDENT>url = self.disable_auto_scale.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.batch_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", pool_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT:int>')<EOL><DEDENT>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>if return_client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", return_client_request_id, '<STR_LIT:bool>')<EOL><DEDENT>if ocp_date is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", ocp_date, '<STR_LIT>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.BatchErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>client_raw_response.add_headers({<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>})<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Disables automatic scaling for a pool.\n\n        :param pool_id: The ID of the pool on which to disable automatic\n         scaling.\n        :type pool_id: str\n        :param pool_disable_auto_scale_options: Additional parameters for the\n         operation\n        :type pool_disable_auto_scale_options:\n         ~azure.batch.models.PoolDisableAutoScaleOptions\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`BatchErrorException<azure.batch.models.BatchErrorException>`", "id": "f28196:c0:m9"}
{"signature": "def get_all_lifetime_statistics(<EOL>self, job_get_all_lifetime_statistics_options=None, custom_headers=None, raw=False, **operation_config):", "body": "timeout = None<EOL>if job_get_all_lifetime_statistics_options is not None:<EOL><INDENT>timeout = job_get_all_lifetime_statistics_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if job_get_all_lifetime_statistics_options is not None:<EOL><INDENT>client_request_id = job_get_all_lifetime_statistics_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if job_get_all_lifetime_statistics_options is not None:<EOL><INDENT>return_client_request_id = job_get_all_lifetime_statistics_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if job_get_all_lifetime_statistics_options is not None:<EOL><INDENT>ocp_date = job_get_all_lifetime_statistics_options.ocp_date<EOL><DEDENT>url = self.get_all_lifetime_statistics.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.batch_url, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT:int>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>if return_client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", return_client_request_id, '<STR_LIT:bool>')<EOL><DEDENT>if ocp_date is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", ocp_date, '<STR_LIT>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.BatchErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>header_dict = {}<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>header_dict = {<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>}<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>client_raw_response.add_headers(header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets lifetime summary statistics for all of the jobs in the specified\n        account.\n\n        Statistics are aggregated across all jobs that have ever existed in the\n        account, from account creation to the last update time of the\n        statistics. The statistics may not be immediately available. The Batch\n        service performs periodic roll-up of statistics. The typical delay is\n        about 30 minutes.\n\n        :param job_get_all_lifetime_statistics_options: Additional parameters\n         for the operation\n        :type job_get_all_lifetime_statistics_options:\n         ~azure.batch.models.JobGetAllLifetimeStatisticsOptions\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: JobStatistics or ClientRawResponse if raw=true\n        :rtype: ~azure.batch.models.JobStatistics or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`BatchErrorException<azure.batch.models.BatchErrorException>`", "id": "f28199:c0:m1"}
{"signature": "def delete(<EOL>self, job_id, job_delete_options=None, custom_headers=None, raw=False, **operation_config):", "body": "timeout = None<EOL>if job_delete_options is not None:<EOL><INDENT>timeout = job_delete_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if job_delete_options is not None:<EOL><INDENT>client_request_id = job_delete_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if job_delete_options is not None:<EOL><INDENT>return_client_request_id = job_delete_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if job_delete_options is not None:<EOL><INDENT>ocp_date = job_delete_options.ocp_date<EOL><DEDENT>if_match = None<EOL>if job_delete_options is not None:<EOL><INDENT>if_match = job_delete_options.if_match<EOL><DEDENT>if_none_match = None<EOL>if job_delete_options is not None:<EOL><INDENT>if_none_match = job_delete_options.if_none_match<EOL><DEDENT>if_modified_since = None<EOL>if job_delete_options is not None:<EOL><INDENT>if_modified_since = job_delete_options.if_modified_since<EOL><DEDENT>if_unmodified_since = None<EOL>if job_delete_options is not None:<EOL><INDENT>if_unmodified_since = job_delete_options.if_unmodified_since<EOL><DEDENT>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.batch_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", job_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT:int>')<EOL><DEDENT>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>if return_client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", return_client_request_id, '<STR_LIT:bool>')<EOL><DEDENT>if ocp_date is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", ocp_date, '<STR_LIT>')<EOL><DEDENT>if if_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_match, '<STR_LIT:str>')<EOL><DEDENT>if if_none_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_none_match, '<STR_LIT:str>')<EOL><DEDENT>if if_modified_since is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_modified_since, '<STR_LIT>')<EOL><DEDENT>if if_unmodified_since is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_unmodified_since, '<STR_LIT>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.BatchErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>client_raw_response.add_headers({<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>})<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes a job.\n\n        Deleting a job also deletes all tasks that are part of that job, and\n        all job statistics. This also overrides the retention period for task\n        data; that is, if the job contains tasks which are still retained on\n        compute nodes, the Batch services deletes those tasks' working\n        directories and all their contents.  When a Delete Job request is\n        received, the Batch service sets the job to the deleting state. All\n        update operations on a job that is in deleting state will fail with\n        status code 409 (Conflict), with additional information indicating that\n        the job is being deleted.\n\n        :param job_id: The ID of the job to delete.\n        :type job_id: str\n        :param job_delete_options: Additional parameters for the operation\n        :type job_delete_options: ~azure.batch.models.JobDeleteOptions\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`BatchErrorException<azure.batch.models.BatchErrorException>`", "id": "f28199:c0:m2"}
{"signature": "def list_from_job_schedule(<EOL>self, job_schedule_id, job_list_from_job_schedule_options=None, custom_headers=None, raw=False, **operation_config):", "body": "filter = None<EOL>if job_list_from_job_schedule_options is not None:<EOL><INDENT>filter = job_list_from_job_schedule_options.filter<EOL><DEDENT>select = None<EOL>if job_list_from_job_schedule_options is not None:<EOL><INDENT>select = job_list_from_job_schedule_options.select<EOL><DEDENT>expand = None<EOL>if job_list_from_job_schedule_options is not None:<EOL><INDENT>expand = job_list_from_job_schedule_options.expand<EOL><DEDENT>max_results = None<EOL>if job_list_from_job_schedule_options is not None:<EOL><INDENT>max_results = job_list_from_job_schedule_options.max_results<EOL><DEDENT>timeout = None<EOL>if job_list_from_job_schedule_options is not None:<EOL><INDENT>timeout = job_list_from_job_schedule_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if job_list_from_job_schedule_options is not None:<EOL><INDENT>client_request_id = job_list_from_job_schedule_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if job_list_from_job_schedule_options is not None:<EOL><INDENT>return_client_request_id = job_list_from_job_schedule_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if job_list_from_job_schedule_options is not None:<EOL><INDENT>ocp_date = job_list_from_job_schedule_options.ocp_date<EOL><DEDENT>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_from_job_schedule.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.batch_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", job_schedule_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if select is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", select, '<STR_LIT:str>')<EOL><DEDENT>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>if max_results is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", max_results, '<STR_LIT:int>', maximum=<NUM_LIT:1000>, minimum=<NUM_LIT:1>)<EOL><DEDENT>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT:int>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>if return_client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", return_client_request_id, '<STR_LIT:bool>')<EOL><DEDENT>if ocp_date is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", ocp_date, '<STR_LIT>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.BatchErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.CloudJobPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.CloudJobPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists the jobs that have been created under the specified job schedule.\n\n        :param job_schedule_id: The ID of the job schedule from which you want\n         to get a list of jobs.\n        :type job_schedule_id: str\n        :param job_list_from_job_schedule_options: Additional parameters for\n         the operation\n        :type job_list_from_job_schedule_options:\n         ~azure.batch.models.JobListFromJobScheduleOptions\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of CloudJob\n        :rtype:\n         ~azure.batch.models.CloudJobPaged[~azure.batch.models.CloudJob]\n        :raises:\n         :class:`BatchErrorException<azure.batch.models.BatchErrorException>`", "id": "f28199:c0:m11"}
{"signature": "def list(<EOL>self, job_id, task_list_options=None, custom_headers=None, raw=False, **operation_config):", "body": "filter = None<EOL>if task_list_options is not None:<EOL><INDENT>filter = task_list_options.filter<EOL><DEDENT>select = None<EOL>if task_list_options is not None:<EOL><INDENT>select = task_list_options.select<EOL><DEDENT>expand = None<EOL>if task_list_options is not None:<EOL><INDENT>expand = task_list_options.expand<EOL><DEDENT>max_results = None<EOL>if task_list_options is not None:<EOL><INDENT>max_results = task_list_options.max_results<EOL><DEDENT>timeout = None<EOL>if task_list_options is not None:<EOL><INDENT>timeout = task_list_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if task_list_options is not None:<EOL><INDENT>client_request_id = task_list_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if task_list_options is not None:<EOL><INDENT>return_client_request_id = task_list_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if task_list_options is not None:<EOL><INDENT>ocp_date = task_list_options.ocp_date<EOL><DEDENT>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.batch_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", job_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if select is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", select, '<STR_LIT:str>')<EOL><DEDENT>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>if max_results is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", max_results, '<STR_LIT:int>', maximum=<NUM_LIT:1000>, minimum=<NUM_LIT:1>)<EOL><DEDENT>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT:int>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>if return_client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", return_client_request_id, '<STR_LIT:bool>')<EOL><DEDENT>if ocp_date is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", ocp_date, '<STR_LIT>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.BatchErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.CloudTaskPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.CloudTaskPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all of the tasks that are associated with the specified job.\n\n        For multi-instance tasks, information such as affinityId, executionInfo\n        and nodeInfo refer to the primary task. Use the list subtasks API to\n        retrieve information about subtasks.\n\n        :param job_id: The ID of the job.\n        :type job_id: str\n        :param task_list_options: Additional parameters for the operation\n        :type task_list_options: ~azure.batch.models.TaskListOptions\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of CloudTask\n        :rtype:\n         ~azure.batch.models.CloudTaskPaged[~azure.batch.models.CloudTask]\n        :raises:\n         :class:`BatchErrorException<azure.batch.models.BatchErrorException>`", "id": "f28200:c0:m2"}
{"signature": "def add(<EOL>self, job_id, task, task_add_options=None, custom_headers=None, raw=False, **operation_config):", "body": "timeout = None<EOL>if task_add_options is not None:<EOL><INDENT>timeout = task_add_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if task_add_options is not None:<EOL><INDENT>client_request_id = task_add_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if task_add_options is not None:<EOL><INDENT>return_client_request_id = task_add_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if task_add_options is not None:<EOL><INDENT>ocp_date = task_add_options.ocp_date<EOL><DEDENT>url = self.add.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.batch_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", job_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT:int>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>if return_client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", return_client_request_id, '<STR_LIT:bool>')<EOL><DEDENT>if ocp_date is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", ocp_date, '<STR_LIT>')<EOL><DEDENT>body_content = self._serialize.body(task, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.BatchErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>client_raw_response.add_headers({<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>})<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Adds a task to the specified job.\n\n        The maximum lifetime of a task from addition to completion is 180 days.\n        If a task has not completed within 180 days of being added it will be\n        terminated by the Batch service and left in whatever state it was in at\n        that time.\n\n        :param job_id: The ID of the job to which the task is to be added.\n        :type job_id: str\n        :param task: The task to be added.\n        :type task: ~azure.batch.models.TaskAddParameter\n        :param task_add_options: Additional parameters for the operation\n        :type task_add_options: ~azure.batch.models.TaskAddOptions\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`BatchErrorException<azure.batch.models.BatchErrorException>`", "id": "f28200:c0:m1"}
{"signature": "def get(<EOL>self, job_id, task_id, task_get_options=None, custom_headers=None, raw=False, **operation_config):", "body": "select = None<EOL>if task_get_options is not None:<EOL><INDENT>select = task_get_options.select<EOL><DEDENT>expand = None<EOL>if task_get_options is not None:<EOL><INDENT>expand = task_get_options.expand<EOL><DEDENT>timeout = None<EOL>if task_get_options is not None:<EOL><INDENT>timeout = task_get_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if task_get_options is not None:<EOL><INDENT>client_request_id = task_get_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if task_get_options is not None:<EOL><INDENT>return_client_request_id = task_get_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if task_get_options is not None:<EOL><INDENT>ocp_date = task_get_options.ocp_date<EOL><DEDENT>if_match = None<EOL>if task_get_options is not None:<EOL><INDENT>if_match = task_get_options.if_match<EOL><DEDENT>if_none_match = None<EOL>if task_get_options is not None:<EOL><INDENT>if_none_match = task_get_options.if_none_match<EOL><DEDENT>if_modified_since = None<EOL>if task_get_options is not None:<EOL><INDENT>if_modified_since = task_get_options.if_modified_since<EOL><DEDENT>if_unmodified_since = None<EOL>if task_get_options is not None:<EOL><INDENT>if_unmodified_since = task_get_options.if_unmodified_since<EOL><DEDENT>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.batch_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", job_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", task_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if select is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", select, '<STR_LIT:str>')<EOL><DEDENT>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT:int>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>if return_client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", return_client_request_id, '<STR_LIT:bool>')<EOL><DEDENT>if ocp_date is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", ocp_date, '<STR_LIT>')<EOL><DEDENT>if if_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_match, '<STR_LIT:str>')<EOL><DEDENT>if if_none_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_none_match, '<STR_LIT:str>')<EOL><DEDENT>if if_modified_since is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_modified_since, '<STR_LIT>')<EOL><DEDENT>if if_unmodified_since is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_unmodified_since, '<STR_LIT>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.BatchErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>header_dict = {}<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>header_dict = {<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>}<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>client_raw_response.add_headers(header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about the specified task.\n\n        For multi-instance tasks, information such as affinityId, executionInfo\n        and nodeInfo refer to the primary task. Use the list subtasks API to\n        retrieve information about subtasks.\n\n        :param job_id: The ID of the job that contains the task.\n        :type job_id: str\n        :param task_id: The ID of the task to get information about.\n        :type task_id: str\n        :param task_get_options: Additional parameters for the operation\n        :type task_get_options: ~azure.batch.models.TaskGetOptions\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: CloudTask or ClientRawResponse if raw=true\n        :rtype: ~azure.batch.models.CloudTask or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`BatchErrorException<azure.batch.models.BatchErrorException>`", "id": "f28200:c0:m5"}
{"signature": "def update(<EOL>self, job_id, task_id, constraints=None, task_update_options=None, custom_headers=None, raw=False, **operation_config):", "body": "timeout = None<EOL>if task_update_options is not None:<EOL><INDENT>timeout = task_update_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if task_update_options is not None:<EOL><INDENT>client_request_id = task_update_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if task_update_options is not None:<EOL><INDENT>return_client_request_id = task_update_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if task_update_options is not None:<EOL><INDENT>ocp_date = task_update_options.ocp_date<EOL><DEDENT>if_match = None<EOL>if task_update_options is not None:<EOL><INDENT>if_match = task_update_options.if_match<EOL><DEDENT>if_none_match = None<EOL>if task_update_options is not None:<EOL><INDENT>if_none_match = task_update_options.if_none_match<EOL><DEDENT>if_modified_since = None<EOL>if task_update_options is not None:<EOL><INDENT>if_modified_since = task_update_options.if_modified_since<EOL><DEDENT>if_unmodified_since = None<EOL>if task_update_options is not None:<EOL><INDENT>if_unmodified_since = task_update_options.if_unmodified_since<EOL><DEDENT>task_update_parameter = models.TaskUpdateParameter(constraints=constraints)<EOL>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.batch_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", job_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", task_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timeout, '<STR_LIT:int>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>if return_client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", return_client_request_id, '<STR_LIT:bool>')<EOL><DEDENT>if ocp_date is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", ocp_date, '<STR_LIT>')<EOL><DEDENT>if if_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_match, '<STR_LIT:str>')<EOL><DEDENT>if if_none_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_none_match, '<STR_LIT:str>')<EOL><DEDENT>if if_modified_since is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_modified_since, '<STR_LIT>')<EOL><DEDENT>if if_unmodified_since is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_unmodified_since, '<STR_LIT>')<EOL><DEDENT>body_content = self._serialize.body(task_update_parameter, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.BatchErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>client_raw_response.add_headers({<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>})<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Updates the properties of the specified task.\n\n        :param job_id: The ID of the job containing the task.\n        :type job_id: str\n        :param task_id: The ID of the task to update.\n        :type task_id: str\n        :param constraints: Constraints that apply to this task. If omitted,\n         the task is given the default constraints. For multi-instance tasks,\n         updating the retention time applies only to the primary task and not\n         subtasks.\n        :type constraints: ~azure.batch.models.TaskConstraints\n        :param task_update_options: Additional parameters for the operation\n        :type task_update_options: ~azure.batch.models.TaskUpdateOptions\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`BatchErrorException<azure.batch.models.BatchErrorException>`", "id": "f28200:c0:m6"}
{"signature": "def check_dns_name_availability(<EOL>self, location, domain_name_label, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.check_dns_name_availability.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", domain_name_label, '<STR_LIT:str>')<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Checks whether a domain name in the cloudapp.azure.com zone is\n        available for use.\n\n        :param location: The location of the domain name.\n        :type location: str\n        :param domain_name_label: The domain name to be verified. It must\n         conform to the following regular expression:\n         ^[a-z][a-z0-9-]{1,61}[a-z0-9]$.\n        :type domain_name_label: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DnsNameAvailabilityResult or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2017_11_01.models.DnsNameAvailabilityResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28203:c1:m1"}
{"signature": "def get(<EOL>self, resource_group_name, load_balancer_name, backend_address_pool_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", backend_address_pool_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets load balancer backend address pool.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param backend_address_pool_name: The name of the backend address\n         pool.\n        :type backend_address_pool_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: BackendAddressPool or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_11_01.models.BackendAddressPool or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28606:c0:m2"}
{"signature": "def list(<EOL>self, resource_group_name, load_balancer_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.BackendAddressPoolPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.BackendAddressPoolPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the load balancer backed address pools.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of BackendAddressPool\n        :rtype:\n         ~azure.mgmt.network.v2017_11_01.models.BackendAddressPoolPaged[~azure.mgmt.network.v2017_11_01.models.BackendAddressPool]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28606:c0:m1"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, load_balancer_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>load_balancer_name=load_balancer_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a load balancer.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param parameters: Parameters supplied to the create or update load\n         balancer operation.\n        :type parameters: ~azure.mgmt.network.v2017_11_01.models.LoadBalancer\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns LoadBalancer or\n         ClientRawResponse<LoadBalancer> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_11_01.models.LoadBalancer]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_11_01.models.LoadBalancer]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28607:c0:m5"}
{"signature": "def delete(<EOL>self, resource_group_name, load_balancer_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>load_balancer_name=load_balancer_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified load balancer.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28607:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, network_interface_name, ip_configuration_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_interface_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", ip_configuration_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified network interface ip configuration.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param ip_configuration_name: The name of the ip configuration name.\n        :type ip_configuration_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: NetworkInterfaceIPConfiguration or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.network.v2017_11_01.models.NetworkInterfaceIPConfiguration\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28608:c0:m2"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.OperationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.OperationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all of the available Network Rest API operations.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Operation\n        :rtype:\n         ~azure.mgmt.network.v2017_11_01.models.OperationPaged[~azure.mgmt.network.v2017_11_01.models.Operation]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28609:c0:m1"}
{"signature": "def get_status(<EOL>self, resource_group_name, network_watcher_name, packet_capture_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_status_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>packet_capture_name=packet_capture_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT:location>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Query the status of a running packet capture session.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the Network Watcher resource.\n        :type network_watcher_name: str\n        :param packet_capture_name: The name given to the packet capture\n         session.\n        :type packet_capture_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         PacketCaptureQueryStatusResult or\n         ClientRawResponse<PacketCaptureQueryStatusResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_11_01.models.PacketCaptureQueryStatusResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_11_01.models.PacketCaptureQueryStatusResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28611:c0:m9"}
{"signature": "def create(<EOL>self, resource_group_name, network_watcher_name, packet_capture_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>packet_capture_name=packet_capture_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Create and start a packet capture on the specified VM.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param packet_capture_name: The name of the packet capture session.\n        :type packet_capture_name: str\n        :param parameters: Parameters that define the create packet capture\n         operation.\n        :type parameters: ~azure.mgmt.network.v2017_11_01.models.PacketCapture\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns PacketCaptureResult or\n         ClientRawResponse<PacketCaptureResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_11_01.models.PacketCaptureResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_11_01.models.PacketCaptureResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28611:c0:m2"}
{"signature": "def get_shared_key(<EOL>self, resource_group_name, virtual_network_gateway_connection_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_shared_key.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_gateway_connection_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "The Get VirtualNetworkGatewayConnectionSharedKey operation retrieves\n        information about the specified virtual network gateway connection\n        shared key through Network resource provider.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_connection_name: The virtual network\n         gateway connection shared key name.\n        :type virtual_network_gateway_connection_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ConnectionSharedKey or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_11_01.models.ConnectionSharedKey or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28612:c0:m10"}
{"signature": "def delete(<EOL>self, resource_group_name, virtual_network_gateway_connection_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_connection_name=virtual_network_gateway_connection_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified virtual network Gateway connection.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_connection_name: The name of the\n         virtual network gateway connection.\n        :type virtual_network_gateway_connection_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28612:c0:m5"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualNetworkGatewayConnectionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualNetworkGatewayConnectionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "The List VirtualNetworkGatewayConnections operation retrieves all the\n        virtual network gateways connections created.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualNetworkGatewayConnection\n        :rtype:\n         ~azure.mgmt.network.v2017_11_01.models.VirtualNetworkGatewayConnectionPaged[~azure.mgmt.network.v2017_11_01.models.VirtualNetworkGatewayConnection]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28612:c0:m11"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ApplicationGatewayPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ApplicationGatewayPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all application gateways in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ApplicationGateway\n        :rtype:\n         ~azure.mgmt.network.v2017_11_01.models.ApplicationGatewayPaged[~azure.mgmt.network.v2017_11_01.models.ApplicationGateway]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28614:c0:m8"}
{"signature": "def backend_health(<EOL>self, resource_group_name, application_gateway_name, expand=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._backend_health_initial(<EOL>resource_group_name=resource_group_name,<EOL>application_gateway_name=application_gateway_name,<EOL>expand=expand,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the backend health of the specified application gateway in a\n        resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param application_gateway_name: The name of the application gateway.\n        :type application_gateway_name: str\n        :param expand: Expands BackendAddressPool and BackendHttpSettings\n         referenced in backend health.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ApplicationGatewayBackendHealth or\n         ClientRawResponse<ApplicationGatewayBackendHealth> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_11_01.models.ApplicationGatewayBackendHealth]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_11_01.models.ApplicationGatewayBackendHealth]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28614:c0:m15"}
{"signature": "def update(<EOL>self, resource_group_name, route_filter_name, route_filter_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_filter_name=route_filter_name,<EOL>route_filter_parameters=route_filter_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a route filter in a specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param route_filter_parameters: Parameters supplied to the update\n         route filter operation.\n        :type route_filter_parameters:\n         ~azure.mgmt.network.v2017_11_01.models.PatchRouteFilter\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns RouteFilter or\n         ClientRawResponse<RouteFilter> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_11_01.models.RouteFilter]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_11_01.models.RouteFilter]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28615:c0:m7"}
{"signature": "def delete(<EOL>self, resource_group_name, route_filter_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_filter_name=route_filter_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified route filter.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28615:c0:m2"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, route_filter_name, route_filter_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_filter_name=route_filter_name,<EOL>route_filter_parameters=route_filter_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a route filter in a specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param route_filter_parameters: Parameters supplied to the create or\n         update route filter operation.\n        :type route_filter_parameters:\n         ~azure.mgmt.network.v2017_11_01.models.RouteFilter\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns RouteFilter or\n         ClientRawResponse<RouteFilter> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_11_01.models.RouteFilter]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_11_01.models.RouteFilter]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28615:c0:m5"}
{"signature": "def query(<EOL>self, resource_group_name, network_watcher_name, connection_monitor_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._query_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>connection_monitor_name=connection_monitor_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Query a snapshot of the most recent connection states.\n\n        :param resource_group_name: The name of the resource group containing\n         Network Watcher.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the Network Watcher resource.\n        :type network_watcher_name: str\n        :param connection_monitor_name: The name given to the connection\n         monitor.\n        :type connection_monitor_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ConnectionMonitorQueryResult or\n         ClientRawResponse<ConnectionMonitorQueryResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_11_01.models.ConnectionMonitorQueryResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_11_01.models.ConnectionMonitorQueryResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28616:c0:m11"}
{"signature": "def get(<EOL>self, resource_group_name, network_watcher_name, connection_monitor_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_watcher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", connection_monitor_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a connection monitor by name.\n\n        :param resource_group_name: The name of the resource group containing\n         Network Watcher.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the Network Watcher resource.\n        :type network_watcher_name: str\n        :param connection_monitor_name: The name of the connection monitor.\n        :type connection_monitor_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ConnectionMonitorResult or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_11_01.models.ConnectionMonitorResult\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28616:c0:m3"}
{"signature": "def delete(<EOL>self, resource_group_name, network_watcher_name, connection_monitor_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>connection_monitor_name=connection_monitor_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified connection monitor.\n\n        :param resource_group_name: The name of the resource group containing\n         Network Watcher.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the Network Watcher resource.\n        :type network_watcher_name: str\n        :param connection_monitor_name: The name of the connection monitor.\n        :type connection_monitor_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28616:c0:m5"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, local_network_gateway_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>local_network_gateway_name=local_network_gateway_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a local network gateway in the specified resource\n        group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param local_network_gateway_name: The name of the local network\n         gateway.\n        :type local_network_gateway_name: str\n        :param parameters: Parameters supplied to the create or update local\n         network gateway operation.\n        :type parameters:\n         ~azure.mgmt.network.v2017_11_01.models.LocalNetworkGateway\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns LocalNetworkGateway or\n         ClientRawResponse<LocalNetworkGateway> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_11_01.models.LocalNetworkGateway]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_11_01.models.LocalNetworkGateway]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28617:c0:m2"}
{"signature": "def update_tags(<EOL>self, resource_group_name, local_network_gateway_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>local_network_gateway_name=local_network_gateway_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a local network gateway tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param local_network_gateway_name: The name of the local network\n         gateway.\n        :type local_network_gateway_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns LocalNetworkGateway or\n         ClientRawResponse<LocalNetworkGateway> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_11_01.models.LocalNetworkGateway]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_11_01.models.LocalNetworkGateway]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28617:c0:m7"}
{"signature": "def get(<EOL>self, resource_group_name, network_security_group_name, default_security_rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_security_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", default_security_rule_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the specified default network security rule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param default_security_rule_name: The name of the default security\n         rule.\n        :type default_security_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SecurityRule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_11_01.models.SecurityRule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28618:c0:m2"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RouteTablePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RouteTablePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all route tables in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of RouteTable\n        :rtype:\n         ~azure.mgmt.network.v2017_11_01.models.RouteTablePaged[~azure.mgmt.network.v2017_11_01.models.RouteTable]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28619:c0:m9"}
{"signature": "def get(<EOL>self, resource_group_name, route_table_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", route_table_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified route table.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RouteTable or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_11_01.models.RouteTable or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28619:c0:m3"}
{"signature": "def update_tags(<EOL>self, resource_group_name, virtual_network_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_name=virtual_network_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a virtual network tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualNetwork or\n         ClientRawResponse<VirtualNetwork> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_11_01.models.VirtualNetwork]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_11_01.models.VirtualNetwork]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28622:c0:m7"}
{"signature": "def get(<EOL>self, resource_group_name, load_balancer_name, inbound_nat_rule_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", inbound_nat_rule_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified load balancer inbound nat rule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param inbound_nat_rule_name: The name of the inbound nat rule.\n        :type inbound_nat_rule_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: InboundNatRule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_11_01.models.InboundNatRule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28623:c0:m4"}
{"signature": "def get_stats(<EOL>self, resource_group_name, circuit_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_stats.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the stats from an express route circuit in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteCircuitStats or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2017_11_01.models.ExpressRouteCircuitStats or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28624:c0:m14"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ExpressRouteCircuitPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ExpressRouteCircuitPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the express route circuits in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ExpressRouteCircuit\n        :rtype:\n         ~azure.mgmt.network.v2017_11_01.models.ExpressRouteCircuitPaged[~azure.mgmt.network.v2017_11_01.models.ExpressRouteCircuit]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28624:c0:m17"}
{"signature": "def get_peering_stats(<EOL>self, resource_group_name, circuit_name, peering_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_peering_stats.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", peering_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all stats from an express route circuit in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteCircuitStats or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2017_11_01.models.ExpressRouteCircuitStats or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28624:c0:m15"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, circuit_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates an express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the circuit.\n        :type circuit_name: str\n        :param parameters: Parameters supplied to the create or update express\n         route circuit operation.\n        :type parameters:\n         ~azure.mgmt.network.v2017_11_01.models.ExpressRouteCircuit\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ExpressRouteCircuit or\n         ClientRawResponse<ExpressRouteCircuit> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_11_01.models.ExpressRouteCircuit]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_11_01.models.ExpressRouteCircuit]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28624:c0:m5"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ExpressRouteCircuitPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ExpressRouteCircuitPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the express route circuits in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ExpressRouteCircuit\n        :rtype:\n         ~azure.mgmt.network.v2017_11_01.models.ExpressRouteCircuitPaged[~azure.mgmt.network.v2017_11_01.models.ExpressRouteCircuit]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28624:c0:m16"}
{"signature": "def update_tags(<EOL>self, resource_group_name, circuit_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates an express route circuit tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the circuit.\n        :type circuit_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ExpressRouteCircuit or\n         ClientRawResponse<ExpressRouteCircuit> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_11_01.models.ExpressRouteCircuit]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_11_01.models.ExpressRouteCircuit]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28624:c0:m7"}
{"signature": "def get(<EOL>self, resource_group_name, circuit_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about the specified express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of express route circuit.\n        :type circuit_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteCircuit or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_11_01.models.ExpressRouteCircuit or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28624:c0:m3"}
{"signature": "def delete(<EOL>self, resource_group_name, application_security_group_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>application_security_group_name=application_security_group_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified application security group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param application_security_group_name: The name of the application\n         security group.\n        :type application_security_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28625:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, network_security_group_name, security_rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_security_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", security_rule_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the specified network security rule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param security_rule_name: The name of the security rule.\n        :type security_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SecurityRule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_11_01.models.SecurityRule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28628:c0:m3"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, network_security_group_name, security_rule_name, security_rule_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_security_group_name=network_security_group_name,<EOL>security_rule_name=security_rule_name,<EOL>security_rule_parameters=security_rule_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a security rule in the specified network security\n        group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param security_rule_name: The name of the security rule.\n        :type security_rule_name: str\n        :param security_rule_parameters: Parameters supplied to the create or\n         update network security rule operation.\n        :type security_rule_parameters:\n         ~azure.mgmt.network.v2017_11_01.models.SecurityRule\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns SecurityRule or\n         ClientRawResponse<SecurityRule> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_11_01.models.SecurityRule]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_11_01.models.SecurityRule]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28628:c0:m5"}
{"signature": "def list(<EOL>self, resource_group_name, virtual_network_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SubnetPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SubnetPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all subnets in a virtual network.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Subnet\n        :rtype:\n         ~azure.mgmt.network.v2017_11_01.models.SubnetPaged[~azure.mgmt.network.v2017_11_01.models.Subnet]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28629:c0:m6"}
{"signature": "def update_tags(<EOL>self, resource_group_name, public_ip_address_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>public_ip_address_name=public_ip_address_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates public IP address tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param public_ip_address_name: The name of the public IP address.\n        :type public_ip_address_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns PublicIPAddress or\n         ClientRawResponse<PublicIPAddress> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_11_01.models.PublicIPAddress]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_11_01.models.PublicIPAddress]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28630:c0:m7"}
{"signature": "def list(<EOL>self, resource_group_name, load_balancer_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets associated load balancer network interfaces.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkInterface\n        :rtype:\n         ~azure.mgmt.network.v2017_11_01.models.NetworkInterfacePaged[~azure.mgmt.network.v2017_11_01.models.NetworkInterface]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28632:c0:m1"}
{"signature": "def get_azure_reachability_report(<EOL>self, resource_group_name, network_watcher_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_azure_reachability_report_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the relative latency score for internet service providers from a\n        specified location to Azure regions.\n\n        :param resource_group_name: The name of the network watcher resource\n         group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher resource.\n        :type network_watcher_name: str\n        :param parameters: Parameters that determine Azure reachability report\n         configuration.\n        :type parameters:\n         ~azure.mgmt.network.v2017_11_01.models.AzureReachabilityReportParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns AzureReachabilityReport\n         or ClientRawResponse<AzureReachabilityReport> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_11_01.models.AzureReachabilityReport]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_11_01.models.AzureReachabilityReport]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28634:c0:m26"}
{"signature": "def get(<EOL>self, resource_group_name, network_watcher_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_watcher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified network watcher by resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: NetworkWatcher or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_11_01.models.NetworkWatcher or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28634:c0:m2"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkWatcherPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkWatcherPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all network watchers by subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkWatcher\n        :rtype:\n         ~azure.mgmt.network.v2017_11_01.models.NetworkWatcherPaged[~azure.mgmt.network.v2017_11_01.models.NetworkWatcher]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28634:c0:m7"}
{"signature": "def get_vm_security_rules(<EOL>self, resource_group_name, network_watcher_name, target_resource_id, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_vm_security_rules_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>target_resource_id=target_resource_id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the configured and effective security group rules on the specified\n        VM.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param target_resource_id: ID of the target VM.\n        :type target_resource_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns SecurityGroupViewResult\n         or ClientRawResponse<SecurityGroupViewResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_11_01.models.SecurityGroupViewResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_11_01.models.SecurityGroupViewResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28634:c0:m14"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, network_watcher_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_watcher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or updates a network watcher in the specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param parameters: Parameters that define the network watcher\n         resource.\n        :type parameters:\n         ~azure.mgmt.network.v2017_11_01.models.NetworkWatcher\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: NetworkWatcher or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_11_01.models.NetworkWatcher or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28634:c0:m1"}
{"signature": "def list(<EOL>self, resource_group_name, route_table_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", route_table_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RoutePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RoutePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all routes in a route table.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Route\n        :rtype:\n         ~azure.mgmt.network.v2017_11_01.models.RoutePaged[~azure.mgmt.network.v2017_11_01.models.Route]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28638:c0:m6"}
{"signature": "def generatevpnclientpackage(<EOL>self, resource_group_name, virtual_network_gateway_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._generatevpnclientpackage_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_name=virtual_network_gateway_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT:str>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT:location>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Generates VPN client package for P2S client of the virtual network\n        gateway in the specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param parameters: Parameters supplied to the generate virtual network\n         gateway VPN client package operation.\n        :type parameters:\n         ~azure.mgmt.network.v2017_11_01.models.VpnClientParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns str or\n         ClientRawResponse<str> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[str] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[str]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28639:c0:m13"}
{"signature": "def get_bgp_peer_status(<EOL>self, resource_group_name, virtual_network_gateway_name, peer=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_bgp_peer_status_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_name=virtual_network_gateway_name,<EOL>peer=peer,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The GetBgpPeerStatus operation retrieves the status of all BGP peers.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param peer: The IP address of the peer to retrieve the status of.\n        :type peer: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns BgpPeerStatusListResult\n         or ClientRawResponse<BgpPeerStatusListResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_11_01.models.BgpPeerStatusListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_11_01.models.BgpPeerStatusListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28639:c0:m18"}
{"signature": "def vpn_device_configuration_script(<EOL>self, resource_group_name, virtual_network_gateway_connection_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.vpn_device_configuration_script.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_gateway_connection_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT:str>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a xml format representation for vpn device configuration script.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_connection_name: The name of the\n         virtual network gateway connection for which the configuration script\n         is generated.\n        :type virtual_network_gateway_connection_name: str\n        :param parameters: Parameters supplied to the generate vpn device\n         script operation.\n        :type parameters:\n         ~azure.mgmt.network.v2017_11_01.models.VpnDeviceScriptParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: str or ClientRawResponse if raw=true\n        :rtype: str or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28639:c0:m24"}
{"signature": "def delete(<EOL>self, resource_group_name, route_filter_name, rule_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_filter_name=route_filter_name,<EOL>rule_name=rule_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified rule from a route filter.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param rule_name: The name of the rule.\n        :type rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28641:c0:m2"}
{"signature": "def update(<EOL>self, resource_group_name, route_filter_name, rule_name, route_filter_rule_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_filter_name=route_filter_name,<EOL>rule_name=rule_name,<EOL>route_filter_rule_parameters=route_filter_rule_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a route in the specified route filter.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param rule_name: The name of the route filter rule.\n        :type rule_name: str\n        :param route_filter_rule_parameters: Parameters supplied to the update\n         route filter rule operation.\n        :type route_filter_rule_parameters:\n         ~azure.mgmt.network.v2017_11_01.models.PatchRouteFilterRule\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns RouteFilterRule or\n         ClientRawResponse<RouteFilterRule> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_11_01.models.RouteFilterRule]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_11_01.models.RouteFilterRule]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28641:c0:m7"}
{"signature": "def get(<EOL>self, resource_group_name, network_interface_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_interface_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about the specified network interface.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: NetworkInterface or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_11_01.models.NetworkInterface or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28642:c0:m3"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all network interfaces in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkInterface\n        :rtype:\n         ~azure.mgmt.network.v2017_11_01.models.NetworkInterfacePaged[~azure.mgmt.network.v2017_11_01.models.NetworkInterface]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28642:c0:m9"}
{"signature": "def list_virtual_machine_scale_set_ip_configurations(<EOL>self, resource_group_name, virtual_machine_scale_set_name, virtualmachine_index, network_interface_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_virtual_machine_scale_set_ip_configurations.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_machine_scale_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtualmachine_index, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_interface_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkInterfaceIPConfigurationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkInterfaceIPConfigurationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the specified network interface ip configuration in a virtual\n        machine scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_machine_scale_set_name: The name of the virtual machine\n         scale set.\n        :type virtual_machine_scale_set_name: str\n        :param virtualmachine_index: The virtual machine index.\n        :type virtualmachine_index: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkInterfaceIPConfiguration\n        :rtype:\n         ~azure.mgmt.network.v2017_11_01.models.NetworkInterfaceIPConfigurationPaged[~azure.mgmt.network.v2017_11_01.models.NetworkInterfaceIPConfiguration]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28642:c0:m17"}
{"signature": "def get_virtual_machine_scale_set_network_interface(<EOL>self, resource_group_name, virtual_machine_scale_set_name, virtualmachine_index, network_interface_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get_virtual_machine_scale_set_network_interface.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_machine_scale_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtualmachine_index, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_interface_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the specified network interface in a virtual machine scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_machine_scale_set_name: The name of the virtual machine\n         scale set.\n        :type virtual_machine_scale_set_name: str\n        :param virtualmachine_index: The virtual machine index.\n        :type virtualmachine_index: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: NetworkInterface or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_11_01.models.NetworkInterface or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28642:c0:m16"}
{"signature": "def delete(<EOL>self, resource_group_name, network_interface_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_interface_name=network_interface_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified network interface.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28642:c0:m2"}
{"signature": "def update_tags(<EOL>self, resource_group_name, network_interface_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_interface_name=network_interface_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a network interface tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns NetworkInterface or\n         ClientRawResponse<NetworkInterface> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_11_01.models.NetworkInterface]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_11_01.models.NetworkInterface]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28642:c0:m7"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, network_interface_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_interface_name=network_interface_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a network interface.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param parameters: Parameters supplied to the create or update network\n         interface operation.\n        :type parameters:\n         ~azure.mgmt.network.v2017_11_01.models.NetworkInterface\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns NetworkInterface or\n         ClientRawResponse<NetworkInterface> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_11_01.models.NetworkInterface]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_11_01.models.NetworkInterface]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28642:c0:m5"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all network interfaces in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkInterface\n        :rtype:\n         ~azure.mgmt.network.v2017_11_01.models.NetworkInterfacePaged[~azure.mgmt.network.v2017_11_01.models.NetworkInterface]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f28642:c0:m8"}
{"signature": "def list(<EOL>self, resource_group_name, load_balancer_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.BackendAddressPoolPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.BackendAddressPoolPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the load balancer backed address pools.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of BackendAddressPool\n        :rtype:\n         ~azure.mgmt.network.v2018_12_01.models.BackendAddressPoolPaged[~azure.mgmt.network.v2018_12_01.models.BackendAddressPool]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29196:c0:m1"}
{"signature": "def update_tags(<EOL>self, resource_group_name, load_balancer_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>load_balancer_name=load_balancer_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a load balancer tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns LoadBalancer or\n         ClientRawResponse<LoadBalancer> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_12_01.models.LoadBalancer]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_12_01.models.LoadBalancer]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29197:c0:m7"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.LoadBalancerPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.LoadBalancerPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the load balancers in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of LoadBalancer\n        :rtype:\n         ~azure.mgmt.network.v2018_12_01.models.LoadBalancerPaged[~azure.mgmt.network.v2018_12_01.models.LoadBalancer]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29197:c0:m9"}
{"signature": "def get(<EOL>self, resource_group_name, express_route_gateway_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", express_route_gateway_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Fetches the details of a ExpressRoute gateway in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param express_route_gateway_name: The name of the ExpressRoute\n         gateway.\n        :type express_route_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteGateway or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_12_01.models.ExpressRouteGateway or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29200:c0:m5"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, express_route_gateway_name, put_express_route_gateway_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>express_route_gateway_name=express_route_gateway_name,<EOL>put_express_route_gateway_parameters=put_express_route_gateway_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a ExpressRoute gateway in a specified resource\n        group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param express_route_gateway_name: The name of the ExpressRoute\n         gateway.\n        :type express_route_gateway_name: str\n        :param put_express_route_gateway_parameters: Parameters required in an\n         ExpressRoute gateway PUT operation.\n        :type put_express_route_gateway_parameters:\n         ~azure.mgmt.network.v2018_12_01.models.ExpressRouteGateway\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ExpressRouteGateway or\n         ClientRawResponse<ExpressRouteGateway> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_12_01.models.ExpressRouteGateway]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_12_01.models.ExpressRouteGateway]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29200:c0:m4"}
{"signature": "def list_routes_table(<EOL>self, resource_group_name, cross_connection_name, peering_name, device_path, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._list_routes_table_initial(<EOL>resource_group_name=resource_group_name,<EOL>cross_connection_name=cross_connection_name,<EOL>peering_name=peering_name,<EOL>device_path=device_path,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the currently advertised routes table associated with the express\n        route cross connection in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param cross_connection_name: The name of the\n         ExpressRouteCrossConnection.\n        :type cross_connection_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param device_path: The path of the device.\n        :type device_path: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCircuitsRoutesTableListResult or\n         ClientRawResponse<ExpressRouteCircuitsRoutesTableListResult> if\n         raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_12_01.models.ExpressRouteCircuitsRoutesTableListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_12_01.models.ExpressRouteCircuitsRoutesTableListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29201:c0:m13"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ExpressRouteCrossConnectionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ExpressRouteCrossConnectionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves all the ExpressRouteCrossConnections in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ExpressRouteCrossConnection\n        :rtype:\n         ~azure.mgmt.network.v2018_12_01.models.ExpressRouteCrossConnectionPaged[~azure.mgmt.network.v2018_12_01.models.ExpressRouteCrossConnection]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29201:c0:m1"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ExpressRouteCrossConnectionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ExpressRouteCrossConnectionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves all the ExpressRouteCrossConnections in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ExpressRouteCrossConnection\n        :rtype:\n         ~azure.mgmt.network.v2018_12_01.models.ExpressRouteCrossConnectionPaged[~azure.mgmt.network.v2018_12_01.models.ExpressRouteCrossConnection]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29201:c0:m2"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.OperationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.OperationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all of the available Network Rest API operations.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Operation\n        :rtype:\n         ~azure.mgmt.network.v2018_12_01.models.OperationPaged[~azure.mgmt.network.v2018_12_01.models.Operation]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29202:c0:m1"}
{"signature": "def list(<EOL>self, resource_group_name, circuit_name, peering_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", peering_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PeerExpressRouteCircuitConnectionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PeerExpressRouteCircuitConnectionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all global reach peer connections associated with a private\n        peering in an express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of\n         PeerExpressRouteCircuitConnection\n        :rtype:\n         ~azure.mgmt.network.v2018_12_01.models.PeerExpressRouteCircuitConnectionPaged[~azure.mgmt.network.v2018_12_01.models.PeerExpressRouteCircuitConnection]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29203:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, load_balancer_name, probe_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", probe_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets load balancer probe.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param probe_name: The name of the probe.\n        :type probe_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Probe or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_12_01.models.Probe or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29204:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, network_watcher_name, packet_capture_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>packet_capture_name=packet_capture_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified packet capture session.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param packet_capture_name: The name of the packet capture session.\n        :type packet_capture_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_12_01.models.ErrorResponseException>`", "id": "f29205:c0:m5"}
{"signature": "def stop(<EOL>self, resource_group_name, network_watcher_name, packet_capture_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._stop_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>packet_capture_name=packet_capture_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Stops a specified packet capture session.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param packet_capture_name: The name of the packet capture session.\n        :type packet_capture_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_12_01.models.ErrorResponseException>`", "id": "f29205:c0:m7"}
{"signature": "def set_shared_key(<EOL>self, resource_group_name, virtual_network_gateway_connection_name, value, id=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._set_shared_key_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_connection_name=virtual_network_gateway_connection_name,<EOL>value=value,<EOL>id=id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The Put VirtualNetworkGatewayConnectionSharedKey operation sets the\n        virtual network gateway connection shared key for passed virtual\n        network gateway connection in the specified resource group through\n        Network resource provider.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_connection_name: The virtual network\n         gateway connection name.\n        :type virtual_network_gateway_connection_name: str\n        :param value: The virtual network connection shared key value.\n        :type value: str\n        :param id: Resource ID.\n        :type id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ConnectionSharedKey or\n         ClientRawResponse<ConnectionSharedKey> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_12_01.models.ConnectionSharedKey]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_12_01.models.ConnectionSharedKey]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29206:c0:m9"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, virtual_network_gateway_connection_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_connection_name=virtual_network_gateway_connection_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a virtual network gateway connection in the\n        specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_connection_name: The name of the\n         virtual network gateway connection.\n        :type virtual_network_gateway_connection_name: str\n        :param parameters: Parameters supplied to the create or update virtual\n         network gateway connection operation.\n        :type parameters:\n         ~azure.mgmt.network.v2018_12_01.models.VirtualNetworkGatewayConnection\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         VirtualNetworkGatewayConnection or\n         ClientRawResponse<VirtualNetworkGatewayConnection> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_12_01.models.VirtualNetworkGatewayConnection]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_12_01.models.VirtualNetworkGatewayConnection]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29206:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, virtual_network_gateway_connection_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_connection_name=virtual_network_gateway_connection_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified virtual network Gateway connection.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_connection_name: The name of the\n         virtual network gateway connection.\n        :type virtual_network_gateway_connection_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29206:c0:m5"}
{"signature": "def reset_shared_key(<EOL>self, resource_group_name, virtual_network_gateway_connection_name, key_length, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._reset_shared_key_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_connection_name=virtual_network_gateway_connection_name,<EOL>key_length=key_length,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The VirtualNetworkGatewayConnectionResetSharedKey operation resets the\n        virtual network gateway connection shared key for passed virtual\n        network gateway connection in the specified resource group through\n        Network resource provider.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_connection_name: The virtual network\n         gateway connection reset shared key Name.\n        :type virtual_network_gateway_connection_name: str\n        :param key_length: The virtual network connection reset shared key\n         length, should between 1 and 128.\n        :type key_length: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ConnectionResetSharedKey or\n         ClientRawResponse<ConnectionResetSharedKey> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_12_01.models.ConnectionResetSharedKey]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_12_01.models.ConnectionResetSharedKey]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29206:c0:m13"}
{"signature": "def get(<EOL>self, resource_group_name, gateway_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", gateway_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves the details of a virtual wan p2s vpn gateway.\n\n        :param resource_group_name: The resource group name of the\n         P2SVpnGateway.\n        :type resource_group_name: str\n        :param gateway_name: The name of the gateway.\n        :type gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: P2SVpnGateway or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_12_01.models.P2SVpnGateway or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_12_01.models.ErrorException>`", "id": "f29210:c0:m1"}
{"signature": "def update_tags(<EOL>self, resource_group_name, gateway_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>gateway_name=gateway_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates virtual wan p2s vpn gateway tags.\n\n        :param resource_group_name: The resource group name of the\n         P2SVpnGateway.\n        :type resource_group_name: str\n        :param gateway_name: The name of the gateway.\n        :type gateway_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns P2SVpnGateway or\n         ClientRawResponse<P2SVpnGateway> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_12_01.models.P2SVpnGateway]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_12_01.models.P2SVpnGateway]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_12_01.models.ErrorException>`", "id": "f29210:c0:m5"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.P2SVpnGatewayPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.P2SVpnGatewayPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all the P2SVpnGateways in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of P2SVpnGateway\n        :rtype:\n         ~azure.mgmt.network.v2018_12_01.models.P2SVpnGatewayPaged[~azure.mgmt.network.v2018_12_01.models.P2SVpnGateway]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_12_01.models.ErrorException>`", "id": "f29210:c0:m9"}
{"signature": "def delete(<EOL>self, resource_group_name, ddos_protection_plan_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>ddos_protection_plan_name=ddos_protection_plan_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified DDoS protection plan.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param ddos_protection_plan_name: The name of the DDoS protection\n         plan.\n        :type ddos_protection_plan_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29211:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, ddos_protection_plan_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", ddos_protection_plan_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about the specified DDoS protection plan.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param ddos_protection_plan_name: The name of the DDoS protection\n         plan.\n        :type ddos_protection_plan_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DdosProtectionPlan or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_12_01.models.DdosProtectionPlan or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29211:c0:m3"}
{"signature": "def get(<EOL>self, resource_group_name, azure_firewall_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", azure_firewall_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified Azure Firewall.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param azure_firewall_name: The name of the Azure Firewall.\n        :type azure_firewall_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: AzureFirewall or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_12_01.models.AzureFirewall or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29212:c0:m3"}
{"signature": "def list_available_response_headers(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_available_response_headers.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all available response headers.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype: list[str] or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_12_01.models.ErrorException>`", "id": "f29213:c0:m18"}
{"signature": "def delete(<EOL>self, resource_group_name, application_gateway_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>application_gateway_name=application_gateway_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified application gateway.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param application_gateway_name: The name of the application gateway.\n        :type application_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29213:c0:m2"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkProfilePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkProfilePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all network profiles in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkProfile\n        :rtype:\n         ~azure.mgmt.network.v2018_12_01.models.NetworkProfilePaged[~azure.mgmt.network.v2018_12_01.models.NetworkProfile]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29214:c0:m9"}
{"signature": "def get(<EOL>self, resource_group_name, network_profile_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_profile_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified network profile in a specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_profile_name: The name of the public IP prefix.\n        :type network_profile_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: NetworkProfile or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_12_01.models.NetworkProfile or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29214:c0:m3"}
{"signature": "def get(<EOL>self, resource_group_name, route_filter_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", route_filter_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified route filter.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param expand: Expands referenced express route bgp peering resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RouteFilter or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_12_01.models.RouteFilter or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29216:c0:m3"}
{"signature": "def delete(<EOL>self, resource_group_name, route_filter_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_filter_name=route_filter_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified route filter.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29216:c0:m2"}
{"signature": "def update(<EOL>self, resource_group_name, route_filter_name, route_filter_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_filter_name=route_filter_name,<EOL>route_filter_parameters=route_filter_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a route filter in a specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param route_filter_parameters: Parameters supplied to the update\n         route filter operation.\n        :type route_filter_parameters:\n         ~azure.mgmt.network.v2018_12_01.models.PatchRouteFilter\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns RouteFilter or\n         ClientRawResponse<RouteFilter> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_12_01.models.RouteFilter]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_12_01.models.RouteFilter]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29216:c0:m7"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RouteFilterPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RouteFilterPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all route filters in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of RouteFilter\n        :rtype:\n         ~azure.mgmt.network.v2018_12_01.models.RouteFilterPaged[~azure.mgmt.network.v2018_12_01.models.RouteFilter]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29216:c0:m9"}
{"signature": "def list(<EOL>self, resource_group_name, load_balancer_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.OutboundRulePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.OutboundRulePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the outbound rules in a load balancer.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of OutboundRule\n        :rtype:\n         ~azure.mgmt.network.v2018_12_01.models.OutboundRulePaged[~azure.mgmt.network.v2018_12_01.models.OutboundRule]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29217:c0:m1"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, network_watcher_name, connection_monitor_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>connection_monitor_name=connection_monitor_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Create or update a connection monitor.\n\n        :param resource_group_name: The name of the resource group containing\n         Network Watcher.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the Network Watcher resource.\n        :type network_watcher_name: str\n        :param connection_monitor_name: The name of the connection monitor.\n        :type connection_monitor_name: str\n        :param parameters: Parameters that define the operation to create a\n         connection monitor.\n        :type parameters:\n         ~azure.mgmt.network.v2018_12_01.models.ConnectionMonitor\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ConnectionMonitorResult\n         or ClientRawResponse<ConnectionMonitorResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_12_01.models.ConnectionMonitorResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_12_01.models.ConnectionMonitorResult]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_12_01.models.ErrorResponseException>`", "id": "f29218:c0:m2"}
{"signature": "def query(<EOL>self, resource_group_name, network_watcher_name, connection_monitor_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._query_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>connection_monitor_name=connection_monitor_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Query a snapshot of the most recent connection states.\n\n        :param resource_group_name: The name of the resource group containing\n         Network Watcher.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the Network Watcher resource.\n        :type network_watcher_name: str\n        :param connection_monitor_name: The name given to the connection\n         monitor.\n        :type connection_monitor_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ConnectionMonitorQueryResult or\n         ClientRawResponse<ConnectionMonitorQueryResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_12_01.models.ConnectionMonitorQueryResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_12_01.models.ConnectionMonitorQueryResult]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_12_01.models.ErrorResponseException>`", "id": "f29218:c0:m11"}
{"signature": "def delete(<EOL>self, resource_group_name, network_watcher_name, connection_monitor_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>connection_monitor_name=connection_monitor_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified connection monitor.\n\n        :param resource_group_name: The name of the resource group containing\n         Network Watcher.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the Network Watcher resource.\n        :type network_watcher_name: str\n        :param connection_monitor_name: The name of the connection monitor.\n        :type connection_monitor_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_12_01.models.ErrorResponseException>`", "id": "f29218:c0:m5"}
{"signature": "def get(<EOL>self, resource_group_name, network_watcher_name, connection_monitor_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_watcher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", connection_monitor_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a connection monitor by name.\n\n        :param resource_group_name: The name of the resource group containing\n         Network Watcher.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the Network Watcher resource.\n        :type network_watcher_name: str\n        :param connection_monitor_name: The name of the connection monitor.\n        :type connection_monitor_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ConnectionMonitorResult or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_12_01.models.ConnectionMonitorResult\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_12_01.models.ErrorResponseException>`", "id": "f29218:c0:m3"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.LocalNetworkGatewayPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.LocalNetworkGatewayPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the local network gateways in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of LocalNetworkGateway\n        :rtype:\n         ~azure.mgmt.network.v2018_12_01.models.LocalNetworkGatewayPaged[~azure.mgmt.network.v2018_12_01.models.LocalNetworkGateway]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29219:c0:m8"}
{"signature": "def get(<EOL>self, resource_group_name, local_network_gateway_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", local_network_gateway_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified local network gateway in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param local_network_gateway_name: The name of the local network\n         gateway.\n        :type local_network_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: LocalNetworkGateway or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_12_01.models.LocalNetworkGateway or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29219:c0:m3"}
{"signature": "def download(<EOL>self, resource_group_name, virtual_wan_name, vpn_sites=None, output_blob_sas_url=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._download_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_wan_name=virtual_wan_name,<EOL>vpn_sites=vpn_sites,<EOL>output_blob_sas_url=output_blob_sas_url,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gives the sas-url to download the configurations for vpn-sites in a\n        resource group.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param virtual_wan_name: The name of the VirtualWAN for which\n         configuration of all vpn-sites is needed.\n        :type virtual_wan_name: str\n        :param vpn_sites: List of resource-ids of the vpn-sites for which\n         config is to be downloaded.\n        :type vpn_sites: list[str]\n        :param output_blob_sas_url: The sas-url to download the configurations\n         for vpn-sites\n        :type output_blob_sas_url: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_12_01.models.ErrorException>`", "id": "f29220:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, tap_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", tap_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about the specified virtual network tap.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param tap_name: The name of virtual network tap.\n        :type tap_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualNetworkTap or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_12_01.models.VirtualNetworkTap or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29221:c0:m3"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualNetworkTapPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualNetworkTapPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the VirtualNetworkTaps in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualNetworkTap\n        :rtype:\n         ~azure.mgmt.network.v2018_12_01.models.VirtualNetworkTapPaged[~azure.mgmt.network.v2018_12_01.models.VirtualNetworkTap]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29221:c0:m8"}
{"signature": "def update_tags(<EOL>self, resource_group_name, gateway_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>gateway_name=gateway_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates virtual wan vpn gateway tags.\n\n        :param resource_group_name: The resource group name of the VpnGateway.\n        :type resource_group_name: str\n        :param gateway_name: The name of the gateway.\n        :type gateway_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VpnGateway or\n         ClientRawResponse<VpnGateway> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_12_01.models.VpnGateway]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_12_01.models.VpnGateway]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_12_01.models.ErrorException>`", "id": "f29223:c0:m5"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VpnGatewayPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VpnGatewayPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all the VpnGateways in a resource group.\n\n        :param resource_group_name: The resource group name of the VpnGateway.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VpnGateway\n        :rtype:\n         ~azure.mgmt.network.v2018_12_01.models.VpnGatewayPaged[~azure.mgmt.network.v2018_12_01.models.VpnGateway]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_12_01.models.ErrorException>`", "id": "f29223:c0:m8"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, route_table_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_table_name=route_table_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Create or updates a route table in a specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param parameters: Parameters supplied to the create or update route\n         table operation.\n        :type parameters: ~azure.mgmt.network.v2018_12_01.models.RouteTable\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns RouteTable or\n         ClientRawResponse<RouteTable> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_12_01.models.RouteTable]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_12_01.models.RouteTable]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29224:c0:m5"}
{"signature": "def list(<EOL>self, resource_group_name, network_interface_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_interface_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.LoadBalancerPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.LoadBalancerPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List all load balancers in a network interface.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of LoadBalancer\n        :rtype:\n         ~azure.mgmt.network.v2018_12_01.models.LoadBalancerPaged[~azure.mgmt.network.v2018_12_01.models.LoadBalancer]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29225:c0:m1"}
{"signature": "def get(<EOL>self, resource_group_name, interface_endpoint_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", interface_endpoint_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified interface endpoint by resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param interface_endpoint_name: The name of the interface endpoint.\n        :type interface_endpoint_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: InterfaceEndpoint or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_12_01.models.InterfaceEndpoint or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29226:c0:m3"}
{"signature": "def list_by_subscription(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_subscription.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.InterfaceEndpointPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.InterfaceEndpointPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all interface endpoints in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of InterfaceEndpoint\n        :rtype:\n         ~azure.mgmt.network.v2018_12_01.models.InterfaceEndpointPaged[~azure.mgmt.network.v2018_12_01.models.InterfaceEndpoint]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29226:c0:m7"}
{"signature": "def delete(<EOL>self, resource_group_name, circuit_name, peering_name, connection_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>peering_name=peering_name,<EOL>connection_name=connection_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified Express Route Circuit Connection from the\n        specified express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param connection_name: The name of the express route circuit\n         connection.\n        :type connection_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29227:c0:m2"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, virtual_network_name, virtual_network_peering_name, virtual_network_peering_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_name=virtual_network_name,<EOL>virtual_network_peering_name=virtual_network_peering_name,<EOL>virtual_network_peering_parameters=virtual_network_peering_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a peering in the specified virtual network.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param virtual_network_peering_name: The name of the peering.\n        :type virtual_network_peering_name: str\n        :param virtual_network_peering_parameters: Parameters supplied to the\n         create or update virtual network peering operation.\n        :type virtual_network_peering_parameters:\n         ~azure.mgmt.network.v2018_12_01.models.VirtualNetworkPeering\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualNetworkPeering\n         or ClientRawResponse<VirtualNetworkPeering> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_12_01.models.VirtualNetworkPeering]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_12_01.models.VirtualNetworkPeering]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29228:c0:m5"}
{"signature": "def list(<EOL>self, resource_group_name, load_balancer_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.InboundNatRulePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.InboundNatRulePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the inbound nat rules in a load balancer.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of InboundNatRule\n        :rtype:\n         ~azure.mgmt.network.v2018_12_01.models.InboundNatRulePaged[~azure.mgmt.network.v2018_12_01.models.InboundNatRule]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29230:c0:m1"}
{"signature": "def delete(<EOL>self, resource_group_name, load_balancer_name, inbound_nat_rule_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>load_balancer_name=load_balancer_name,<EOL>inbound_nat_rule_name=inbound_nat_rule_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified load balancer inbound nat rule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param inbound_nat_rule_name: The name of the inbound nat rule.\n        :type inbound_nat_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29230:c0:m3"}
{"signature": "def list_routes_table_summary(<EOL>self, resource_group_name, circuit_name, peering_name, device_path, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._list_routes_table_summary_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>peering_name=peering_name,<EOL>device_path=device_path,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the currently advertised routes table summary associated with the\n        express route circuit in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param device_path: The path of the device.\n        :type device_path: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCircuitsRoutesTableSummaryListResult or\n         ClientRawResponse<ExpressRouteCircuitsRoutesTableSummaryListResult> if\n         raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_12_01.models.ExpressRouteCircuitsRoutesTableSummaryListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_12_01.models.ExpressRouteCircuitsRoutesTableSummaryListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29231:c0:m13"}
{"signature": "def get_peering_stats(<EOL>self, resource_group_name, circuit_name, peering_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_peering_stats.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", peering_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all stats from an express route circuit in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteCircuitStats or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_12_01.models.ExpressRouteCircuitStats or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29231:c0:m15"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ApplicationSecurityGroupPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ApplicationSecurityGroupPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the application security groups in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ApplicationSecurityGroup\n        :rtype:\n         ~azure.mgmt.network.v2018_12_01.models.ApplicationSecurityGroupPaged[~azure.mgmt.network.v2018_12_01.models.ApplicationSecurityGroup]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29233:c0:m9"}
{"signature": "def get(<EOL>self, resource_group_name, application_security_group_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", application_security_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about the specified application security group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param application_security_group_name: The name of the application\n         security group.\n        :type application_security_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ApplicationSecurityGroup or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_12_01.models.ApplicationSecurityGroup or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29233:c0:m3"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ApplicationSecurityGroupPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ApplicationSecurityGroupPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all application security groups in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ApplicationSecurityGroup\n        :rtype:\n         ~azure.mgmt.network.v2018_12_01.models.ApplicationSecurityGroupPaged[~azure.mgmt.network.v2018_12_01.models.ApplicationSecurityGroup]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29233:c0:m8"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, policy_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", policy_name, '<STR_LIT:str>', max_length=<NUM_LIT>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or update policy with specified rule set name within a resource\n        group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param policy_name: The name of the policy.\n        :type policy_name: str\n        :param parameters: Policy to be created.\n        :type parameters:\n         ~azure.mgmt.network.v2018_12_01.models.WebApplicationFirewallPolicy\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: WebApplicationFirewallPolicy or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_12_01.models.WebApplicationFirewallPolicy or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29235:c0:m4"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, virtual_hub_name, virtual_hub_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_hub_name=virtual_hub_name,<EOL>virtual_hub_parameters=virtual_hub_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates a VirtualHub resource if it doesn't exist else updates the\n        existing VirtualHub.\n\n        :param resource_group_name: The resource group name of the VirtualHub.\n        :type resource_group_name: str\n        :param virtual_hub_name: The name of the VirtualHub.\n        :type virtual_hub_name: str\n        :param virtual_hub_parameters: Parameters supplied to create or update\n         VirtualHub.\n        :type virtual_hub_parameters:\n         ~azure.mgmt.network.v2018_12_01.models.VirtualHub\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualHub or\n         ClientRawResponse<VirtualHub> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_12_01.models.VirtualHub]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_12_01.models.VirtualHub]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_12_01.models.ErrorException>`", "id": "f29237:c0:m3"}
{"signature": "def update_tags(<EOL>self, resource_group_name, virtual_hub_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_hub_name=virtual_hub_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates VirtualHub tags.\n\n        :param resource_group_name: The resource group name of the VirtualHub.\n        :type resource_group_name: str\n        :param virtual_hub_name: The name of the VirtualHub.\n        :type virtual_hub_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualHub or\n         ClientRawResponse<VirtualHub> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_12_01.models.VirtualHub]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_12_01.models.VirtualHub]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_12_01.models.ErrorException>`", "id": "f29237:c0:m5"}
{"signature": "def delete(<EOL>self, resource_group_name, network_security_group_name, security_rule_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_security_group_name=network_security_group_name,<EOL>security_rule_name=security_rule_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified network security rule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param security_rule_name: The name of the security rule.\n        :type security_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29238:c0:m2"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, network_security_group_name, security_rule_name, security_rule_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_security_group_name=network_security_group_name,<EOL>security_rule_name=security_rule_name,<EOL>security_rule_parameters=security_rule_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a security rule in the specified network security\n        group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param security_rule_name: The name of the security rule.\n        :type security_rule_name: str\n        :param security_rule_parameters: Parameters supplied to the create or\n         update network security rule operation.\n        :type security_rule_parameters:\n         ~azure.mgmt.network.v2018_12_01.models.SecurityRule\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns SecurityRule or\n         ClientRawResponse<SecurityRule> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_12_01.models.SecurityRule]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_12_01.models.SecurityRule]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29238:c0:m5"}
{"signature": "def get(<EOL>self, location_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", location_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves a single ExpressRoutePort peering location, including the\n        list of available bandwidths available at said peering location.\n\n        :param location_name: Name of the requested ExpressRoutePort peering\n         location.\n        :type location_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRoutePortsLocation or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_12_01.models.ExpressRoutePortsLocation or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29239:c0:m2"}
{"signature": "def prepare_network_policies(<EOL>self, resource_group_name, virtual_network_name, subnet_name, prepare_network_policies_request_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._prepare_network_policies_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_name=virtual_network_name,<EOL>subnet_name=subnet_name,<EOL>prepare_network_policies_request_parameters=prepare_network_policies_request_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Prepares a subnet by applying network intent policies.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param subnet_name: The name of the subnet.\n        :type subnet_name: str\n        :param prepare_network_policies_request_parameters: Parameters\n         supplied to prepare subnet by applying network intent policies.\n        :type prepare_network_policies_request_parameters:\n         ~azure.mgmt.network.v2018_12_01.models.PrepareNetworkPoliciesRequest\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29240:c0:m7"}
{"signature": "def get(<EOL>self, resource_group_name, virtual_network_name, subnet_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", subnet_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified subnet by virtual network and resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param subnet_name: The name of the subnet.\n        :type subnet_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Subnet or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_12_01.models.Subnet or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29240:c0:m3"}
{"signature": "def list_virtual_machine_scale_set_public_ip_addresses(<EOL>self, resource_group_name, virtual_machine_scale_set_name, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_virtual_machine_scale_set_public_ip_addresses.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_machine_scale_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PublicIPAddressPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PublicIPAddressPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about all public IP addresses on a virtual machine\n        scale set level.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_machine_scale_set_name: The name of the virtual machine\n         scale set.\n        :type virtual_machine_scale_set_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PublicIPAddress\n        :rtype:\n         ~azure.mgmt.network.v2018_12_01.models.PublicIPAddressPaged[~azure.mgmt.network.v2018_12_01.models.PublicIPAddress]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29242:c0:m10"}
{"signature": "def delete(<EOL>self, resource_group_name, public_ip_address_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>public_ip_address_name=public_ip_address_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified public IP address.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param public_ip_address_name: The name of the subnet.\n        :type public_ip_address_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29242:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, public_ip_address_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", public_ip_address_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified public IP address in a specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param public_ip_address_name: The name of the subnet.\n        :type public_ip_address_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PublicIPAddress or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_12_01.models.PublicIPAddress or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29242:c0:m3"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, cross_connection_name, peering_name, peering_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>cross_connection_name=cross_connection_name,<EOL>peering_name=peering_name,<EOL>peering_parameters=peering_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a peering in the specified\n        ExpressRouteCrossConnection.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param cross_connection_name: The name of the\n         ExpressRouteCrossConnection.\n        :type cross_connection_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param peering_parameters: Parameters supplied to the create or update\n         ExpressRouteCrossConnection peering operation.\n        :type peering_parameters:\n         ~azure.mgmt.network.v2018_12_01.models.ExpressRouteCrossConnectionPeering\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCrossConnectionPeering or\n         ClientRawResponse<ExpressRouteCrossConnectionPeering> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_12_01.models.ExpressRouteCrossConnectionPeering]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_12_01.models.ExpressRouteCrossConnectionPeering]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29243:c0:m6"}
{"signature": "def get(<EOL>self, resource_group_name, cross_connection_name, peering_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", cross_connection_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", peering_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified peering for the ExpressRouteCrossConnection.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param cross_connection_name: The name of the\n         ExpressRouteCrossConnection.\n        :type cross_connection_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteCrossConnectionPeering or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_12_01.models.ExpressRouteCrossConnectionPeering\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29243:c0:m4"}
{"signature": "def get(<EOL>self, resource_group_name, express_route_gateway_name, connection_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", express_route_gateway_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", connection_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified ExpressRouteConnection.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param express_route_gateway_name: The name of the ExpressRoute\n         gateway.\n        :type express_route_gateway_name: str\n        :param connection_name: The name of the ExpressRoute connection.\n        :type connection_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteConnection or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_12_01.models.ExpressRouteConnection\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29246:c0:m3"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, network_watcher_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_watcher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or updates a network watcher in the specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param parameters: Parameters that define the network watcher\n         resource.\n        :type parameters:\n         ~azure.mgmt.network.v2018_12_01.models.NetworkWatcher\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: NetworkWatcher or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_12_01.models.NetworkWatcher or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_12_01.models.ErrorResponseException>`", "id": "f29248:c0:m1"}
{"signature": "def get(<EOL>self, resource_group_name, network_watcher_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_watcher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified network watcher by resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: NetworkWatcher or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_12_01.models.NetworkWatcher or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_12_01.models.ErrorResponseException>`", "id": "f29248:c0:m2"}
{"signature": "def get_troubleshooting_result(<EOL>self, resource_group_name, network_watcher_name, target_resource_id, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_troubleshooting_result_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>target_resource_id=target_resource_id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Get the last completed troubleshooting result on a specified resource.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher resource.\n        :type network_watcher_name: str\n        :param target_resource_id: The target resource ID to query the\n         troubleshooting result.\n        :type target_resource_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns TroubleshootingResult\n         or ClientRawResponse<TroubleshootingResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_12_01.models.TroubleshootingResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_12_01.models.TroubleshootingResult]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_12_01.models.ErrorResponseException>`", "id": "f29248:c0:m18"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkWatcherPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkWatcherPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all network watchers by subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkWatcher\n        :rtype:\n         ~azure.mgmt.network.v2018_12_01.models.NetworkWatcherPaged[~azure.mgmt.network.v2018_12_01.models.NetworkWatcher]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_12_01.models.ErrorResponseException>`", "id": "f29248:c0:m7"}
{"signature": "def get_flow_log_status(<EOL>self, resource_group_name, network_watcher_name, target_resource_id, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_flow_log_status_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>target_resource_id=target_resource_id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Queries status of flow log and traffic analytics (optional) on a\n        specified resource.\n\n        :param resource_group_name: The name of the network watcher resource\n         group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher resource.\n        :type network_watcher_name: str\n        :param target_resource_id: The target resource where getting the flow\n         log and traffic analytics (optional) status.\n        :type target_resource_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns FlowLogInformation or\n         ClientRawResponse<FlowLogInformation> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_12_01.models.FlowLogInformation]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_12_01.models.FlowLogInformation]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_12_01.models.ErrorResponseException>`", "id": "f29248:c0:m22"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkWatcherPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkWatcherPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all network watchers by resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkWatcher\n        :rtype:\n         ~azure.mgmt.network.v2018_12_01.models.NetworkWatcherPaged[~azure.mgmt.network.v2018_12_01.models.NetworkWatcher]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_12_01.models.ErrorResponseException>`", "id": "f29248:c0:m6"}
{"signature": "def check_connectivity(<EOL>self, resource_group_name, network_watcher_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._check_connectivity_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Verifies the possibility of establishing a direct TCP connection from a\n        virtual machine to a given endpoint including another VM or an\n        arbitrary remote server.\n\n        :param resource_group_name: The name of the network watcher resource\n         group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher resource.\n        :type network_watcher_name: str\n        :param parameters: Parameters that determine how the connectivity\n         check will be performed.\n        :type parameters:\n         ~azure.mgmt.network.v2018_12_01.models.ConnectivityParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ConnectivityInformation\n         or ClientRawResponse<ConnectivityInformation> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_12_01.models.ConnectivityInformation]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_12_01.models.ConnectivityInformation]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_12_01.models.ErrorResponseException>`", "id": "f29248:c0:m24"}
{"signature": "def get(<EOL>self, resource_group_name, vpn_site_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vpn_site_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves the details of a VPN site.\n\n        :param resource_group_name: The resource group name of the VpnSite.\n        :type resource_group_name: str\n        :param vpn_site_name: The name of the VpnSite being retrieved.\n        :type vpn_site_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VpnSite or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_12_01.models.VpnSite or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_12_01.models.ErrorException>`", "id": "f29249:c0:m1"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ServiceEndpointPolicyPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ServiceEndpointPolicyPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the service endpoint policies in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ServiceEndpointPolicy\n        :rtype:\n         ~azure.mgmt.network.v2018_12_01.models.ServiceEndpointPolicyPaged[~azure.mgmt.network.v2018_12_01.models.ServiceEndpointPolicy]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29251:c0:m8"}
{"signature": "def update_tags(<EOL>self, resource_group_name, virtual_wan_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_wan_name=virtual_wan_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a VirtualWAN tags.\n\n        :param resource_group_name: The resource group name of the VirtualWan.\n        :type resource_group_name: str\n        :param virtual_wan_name: The name of the VirtualWAN being updated.\n        :type virtual_wan_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualWAN or\n         ClientRawResponse<VirtualWAN> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_12_01.models.VirtualWAN]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_12_01.models.VirtualWAN]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_12_01.models.ErrorException>`", "id": "f29252:c0:m5"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualWANPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualWANPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all the VirtualWANs in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualWAN\n        :rtype:\n         ~azure.mgmt.network.v2018_12_01.models.VirtualWANPaged[~azure.mgmt.network.v2018_12_01.models.VirtualWAN]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_12_01.models.ErrorException>`", "id": "f29252:c0:m9"}
{"signature": "def get(<EOL>self, resource_group_name, circuit_name, peering_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", peering_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified peering for the express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteCircuitPeering or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_12_01.models.ExpressRouteCircuitPeering or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29253:c0:m3"}
{"signature": "def get(<EOL>self, resource_group_name, virtual_wan_name, p2_svpn_server_configuration_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_wan_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", p2_svpn_server_configuration_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves the details of a P2SVpnServerConfiguration.\n\n        :param resource_group_name: The resource group name of the\n         P2SVpnServerConfiguration.\n        :type resource_group_name: str\n        :param virtual_wan_name: The name of the VirtualWan.\n        :type virtual_wan_name: str\n        :param p2_svpn_server_configuration_name: The name of the\n         P2SVpnServerConfiguration.\n        :type p2_svpn_server_configuration_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: P2SVpnServerConfiguration or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_12_01.models.P2SVpnServerConfiguration or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_12_01.models.ErrorException>`", "id": "f29254:c0:m1"}
{"signature": "def get(<EOL>self, resource_group_name, load_balancer_name, frontend_ip_configuration_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", frontend_ip_configuration_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets load balancer frontend IP configuration.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param frontend_ip_configuration_name: The name of the frontend IP\n         configuration.\n        :type frontend_ip_configuration_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: FrontendIPConfiguration or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_12_01.models.FrontendIPConfiguration\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29255:c0:m2"}
{"signature": "def list(<EOL>self, resource_group_name, route_table_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", route_table_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RoutePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RoutePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all routes in a route table.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Route\n        :rtype:\n         ~azure.mgmt.network.v2018_12_01.models.RoutePaged[~azure.mgmt.network.v2018_12_01.models.Route]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29256:c0:m6"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, route_table_name, route_name, route_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_table_name=route_table_name,<EOL>route_name=route_name,<EOL>route_parameters=route_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a route in the specified route table.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param route_name: The name of the route.\n        :type route_name: str\n        :param route_parameters: Parameters supplied to the create or update\n         route operation.\n        :type route_parameters: ~azure.mgmt.network.v2018_12_01.models.Route\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Route or\n         ClientRawResponse<Route> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_12_01.models.Route]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_12_01.models.Route]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29256:c0:m5"}
{"signature": "def get_bgp_peer_status(<EOL>self, resource_group_name, virtual_network_gateway_name, peer=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_bgp_peer_status_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_name=virtual_network_gateway_name,<EOL>peer=peer,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The GetBgpPeerStatus operation retrieves the status of all BGP peers.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param peer: The IP address of the peer to retrieve the status of.\n        :type peer: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns BgpPeerStatusListResult\n         or ClientRawResponse<BgpPeerStatusListResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_12_01.models.BgpPeerStatusListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_12_01.models.BgpPeerStatusListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29259:c0:m20"}
{"signature": "def list_connections(<EOL>self, resource_group_name, virtual_network_gateway_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_connections.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_gateway_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualNetworkGatewayConnectionListEntityPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualNetworkGatewayConnectionListEntityPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the connections in a virtual network gateway.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of\n         VirtualNetworkGatewayConnectionListEntity\n        :rtype:\n         ~azure.mgmt.network.v2018_12_01.models.VirtualNetworkGatewayConnectionListEntityPaged[~azure.mgmt.network.v2018_12_01.models.VirtualNetworkGatewayConnectionListEntity]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29259:c0:m9"}
{"signature": "def get_vpnclient_ipsec_parameters(<EOL>self, resource_group_name, virtual_network_gateway_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_vpnclient_ipsec_parameters_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_name=virtual_network_gateway_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The Get VpnclientIpsecParameters operation retrieves information about\n        the vpnclient ipsec policy for P2S client of virtual network gateway in\n        the specified resource group through Network resource provider.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The virtual network gateway name.\n        :type virtual_network_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         VpnClientIPsecParameters or\n         ClientRawResponse<VpnClientIPsecParameters> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_12_01.models.VpnClientIPsecParameters]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_12_01.models.VpnClientIPsecParameters]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29259:c0:m29"}
{"signature": "def generatevpnclientpackage(<EOL>self, resource_group_name, virtual_network_gateway_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._generatevpnclientpackage_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_name=virtual_network_gateway_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT:str>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT:location>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Generates VPN client package for P2S client of the virtual network\n        gateway in the specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param parameters: Parameters supplied to the generate virtual network\n         gateway VPN client package operation.\n        :type parameters:\n         ~azure.mgmt.network.v2018_12_01.models.VpnClientParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns str or\n         ClientRawResponse<str> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[str] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[str]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29259:c0:m15"}
{"signature": "def supported_vpn_devices(<EOL>self, resource_group_name, virtual_network_gateway_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.supported_vpn_devices.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_gateway_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT:str>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a xml format representation for supported vpn devices.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: str or ClientRawResponse if raw=true\n        :rtype: str or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29259:c0:m21"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualNetworkGatewayPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualNetworkGatewayPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all virtual network gateways by resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualNetworkGateway\n        :rtype:\n         ~azure.mgmt.network.v2018_12_01.models.VirtualNetworkGatewayPaged[~azure.mgmt.network.v2018_12_01.models.VirtualNetworkGateway]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29259:c0:m8"}
{"signature": "def generate_vpn_profile(<EOL>self, resource_group_name, virtual_network_gateway_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.generate_vpn_profile.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_gateway_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT:str>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Generates VPN profile for P2S client of the virtual network gateway in\n        the specified resource group. Used for IKEV2 and radius based\n        authentication.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param parameters: Parameters supplied to the generate virtual network\n         gateway VPN client package operation.\n        :type parameters:\n         ~azure.mgmt.network.v2018_12_01.models.VpnClientParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: str or ClientRawResponse if raw=true\n        :rtype: str or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29259:c0:m16"}
{"signature": "def get(<EOL>self, resource_group_name, load_balancer_name, load_balancing_rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancing_rule_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified load balancer load balancing rule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param load_balancing_rule_name: The name of the load balancing rule.\n        :type load_balancing_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: LoadBalancingRule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_12_01.models.LoadBalancingRule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29260:c0:m2"}
{"signature": "def list_by_route_filter(<EOL>self, resource_group_name, route_filter_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_route_filter.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", route_filter_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RouteFilterRulePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RouteFilterRulePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all RouteFilterRules in a route filter.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of RouteFilterRule\n        :rtype:\n         ~azure.mgmt.network.v2018_12_01.models.RouteFilterRulePaged[~azure.mgmt.network.v2018_12_01.models.RouteFilterRule]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29261:c0:m8"}
{"signature": "def delete(<EOL>self, resource_group_name, route_filter_name, rule_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_filter_name=route_filter_name,<EOL>rule_name=rule_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified rule from a route filter.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param rule_name: The name of the rule.\n        :type rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29261:c0:m2"}
{"signature": "def update(<EOL>self, resource_group_name, route_filter_name, rule_name, route_filter_rule_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_filter_name=route_filter_name,<EOL>rule_name=rule_name,<EOL>route_filter_rule_parameters=route_filter_rule_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a route in the specified route filter.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param rule_name: The name of the route filter rule.\n        :type rule_name: str\n        :param route_filter_rule_parameters: Parameters supplied to the update\n         route filter rule operation.\n        :type route_filter_rule_parameters:\n         ~azure.mgmt.network.v2018_12_01.models.PatchRouteFilterRule\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns RouteFilterRule or\n         ClientRawResponse<RouteFilterRule> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_12_01.models.RouteFilterRule]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_12_01.models.RouteFilterRule]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29261:c0:m7"}
{"signature": "def list_by_vpn_gateway(<EOL>self, resource_group_name, gateway_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_vpn_gateway.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", gateway_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VpnConnectionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VpnConnectionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves all vpn connections for a particular virtual wan vpn gateway.\n\n        :param resource_group_name: The resource group name of the VpnGateway.\n        :type resource_group_name: str\n        :param gateway_name: The name of the gateway.\n        :type gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VpnConnection\n        :rtype:\n         ~azure.mgmt.network.v2018_12_01.models.VpnConnectionPaged[~azure.mgmt.network.v2018_12_01.models.VpnConnection]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_12_01.models.ErrorException>`", "id": "f29262:c0:m6"}
{"signature": "def update_tags(<EOL>self, resource_group_name, network_interface_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_interface_name=network_interface_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a network interface tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns NetworkInterface or\n         ClientRawResponse<NetworkInterface> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_12_01.models.NetworkInterface]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_12_01.models.NetworkInterface]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29263:c0:m7"}
{"signature": "def list_virtual_machine_scale_set_vm_network_interfaces(<EOL>self, resource_group_name, virtual_machine_scale_set_name, virtualmachine_index, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_virtual_machine_scale_set_vm_network_interfaces.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_machine_scale_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtualmachine_index, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about all network interfaces in a virtual machine in a\n        virtual machine scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_machine_scale_set_name: The name of the virtual machine\n         scale set.\n        :type virtual_machine_scale_set_name: str\n        :param virtualmachine_index: The virtual machine index.\n        :type virtualmachine_index: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkInterface\n        :rtype:\n         ~azure.mgmt.network.v2018_12_01.models.NetworkInterfacePaged[~azure.mgmt.network.v2018_12_01.models.NetworkInterface]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29263:c0:m14"}
{"signature": "def get_effective_route_table(<EOL>self, resource_group_name, network_interface_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_effective_route_table_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_interface_name=network_interface_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets all route tables applied to a network interface.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         EffectiveRouteListResult or\n         ClientRawResponse<EffectiveRouteListResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_12_01.models.EffectiveRouteListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_12_01.models.EffectiveRouteListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29263:c0:m11"}
{"signature": "def delete(<EOL>self, resource_group_name, network_security_group_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_security_group_name=network_security_group_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified network security group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29264:c0:m2"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkSecurityGroupPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkSecurityGroupPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all network security groups in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkSecurityGroup\n        :rtype:\n         ~azure.mgmt.network.v2018_12_01.models.NetworkSecurityGroupPaged[~azure.mgmt.network.v2018_12_01.models.NetworkSecurityGroup]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29264:c0:m9"}
{"signature": "def update_tags(<EOL>self, resource_group_name, network_security_group_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_security_group_name=network_security_group_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a network security group tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns NetworkSecurityGroup or\n         ClientRawResponse<NetworkSecurityGroup> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_12_01.models.NetworkSecurityGroup]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_12_01.models.NetworkSecurityGroup]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29264:c0:m7"}
{"signature": "def get(<EOL>self, resource_group_name, load_balancer_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified load balancer.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: LoadBalancer or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2016_12_01.models.LoadBalancer or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29493:c0:m3"}
{"signature": "def delete(<EOL>self, resource_group_name, application_gateway_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>application_gateway_name=application_gateway_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified application gateway.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param application_gateway_name: The name of the application gateway.\n        :type application_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29497:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, route_filter_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", route_filter_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified route filter.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param expand: Expands referenced express route bgp peering resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RouteFilter or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2016_12_01.models.RouteFilter or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29498:c0:m3"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RouteFilterPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RouteFilterPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all route filters in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of RouteFilter\n        :rtype:\n         ~azure.mgmt.network.v2016_12_01.models.RouteFilterPaged[~azure.mgmt.network.v2016_12_01.models.RouteFilter]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29498:c0:m8"}
{"signature": "def delete(<EOL>self, resource_group_name, route_filter_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_filter_name=route_filter_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified route filter.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29498:c0:m2"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RouteTablePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RouteTablePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all route tables in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of RouteTable\n        :rtype:\n         ~azure.mgmt.network.v2016_12_01.models.RouteTablePaged[~azure.mgmt.network.v2016_12_01.models.RouteTable]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29500:c0:m7"}
{"signature": "def delete(<EOL>self, resource_group_name, route_table_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_table_name=route_table_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified route table.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29500:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, virtual_network_name, virtual_network_peering_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_peering_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified virtual network peering.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param virtual_network_peering_name: The name of the virtual network\n         peering.\n        :type virtual_network_peering_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualNetworkPeering or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2016_12_01.models.VirtualNetworkPeering\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29501:c0:m3"}
{"signature": "def delete(<EOL>self, resource_group_name, virtual_network_name, virtual_network_peering_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_name=virtual_network_name,<EOL>virtual_network_peering_name=virtual_network_peering_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified virtual network peering.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param virtual_network_peering_name: The name of the virtual network\n         peering.\n        :type virtual_network_peering_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29501:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, virtual_network_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_name=virtual_network_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified virtual network.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29502:c0:m2"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualNetworkPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualNetworkPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all virtual networks in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualNetwork\n        :rtype:\n         ~azure.mgmt.network.v2016_12_01.models.VirtualNetworkPaged[~azure.mgmt.network.v2016_12_01.models.VirtualNetwork]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29502:c0:m7"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ExpressRouteCircuitPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ExpressRouteCircuitPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the express route circuits in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ExpressRouteCircuit\n        :rtype:\n         ~azure.mgmt.network.v2016_12_01.models.ExpressRouteCircuitPaged[~azure.mgmt.network.v2016_12_01.models.ExpressRouteCircuit]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29503:c0:m14"}
{"signature": "def list_routes_table(<EOL>self, resource_group_name, circuit_name, peering_name, device_path, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._list_routes_table_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>peering_name=peering_name,<EOL>device_path=device_path,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the currently advertised routes table associated with the express\n        route circuit in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param device_path: The path of the device.\n        :type device_path: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCircuitsRoutesTableListResult or\n         ClientRawResponse<ExpressRouteCircuitsRoutesTableListResult> if\n         raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2016_12_01.models.ExpressRouteCircuitsRoutesTableListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2016_12_01.models.ExpressRouteCircuitsRoutesTableListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29503:c0:m9"}
{"signature": "def delete(<EOL>self, resource_group_name, circuit_name, authorization_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>authorization_name=authorization_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified authorization from the specified express route\n        circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param authorization_name: The name of the authorization.\n        :type authorization_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29504:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, circuit_name, authorization_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", authorization_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified authorization from the specified express route\n        circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param authorization_name: The name of the authorization.\n        :type authorization_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteCircuitAuthorization or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.network.v2016_12_01.models.ExpressRouteCircuitAuthorization\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29504:c0:m3"}
{"signature": "def list(<EOL>self, resource_group_name, circuit_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ExpressRouteCircuitAuthorizationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ExpressRouteCircuitAuthorizationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all authorizations in an express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the circuit.\n        :type circuit_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ExpressRouteCircuitAuthorization\n        :rtype:\n         ~azure.mgmt.network.v2016_12_01.models.ExpressRouteCircuitAuthorizationPaged[~azure.mgmt.network.v2016_12_01.models.ExpressRouteCircuitAuthorization]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29504:c0:m6"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, virtual_network_name, subnet_name, subnet_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_name=virtual_network_name,<EOL>subnet_name=subnet_name,<EOL>subnet_parameters=subnet_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a subnet in the specified virtual network.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param subnet_name: The name of the subnet.\n        :type subnet_name: str\n        :param subnet_parameters: Parameters supplied to the create or update\n         subnet operation.\n        :type subnet_parameters: ~azure.mgmt.network.v2016_12_01.models.Subnet\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Subnet or\n         ClientRawResponse<Subnet> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2016_12_01.models.Subnet]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2016_12_01.models.Subnet]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29507:c0:m5"}
{"signature": "def list(<EOL>self, resource_group_name, virtual_network_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SubnetPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SubnetPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all subnets in a virtual network.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Subnet\n        :rtype:\n         ~azure.mgmt.network.v2016_12_01.models.SubnetPaged[~azure.mgmt.network.v2016_12_01.models.Subnet]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29507:c0:m6"}
{"signature": "def delete(<EOL>self, resource_group_name, public_ip_address_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>public_ip_address_name=public_ip_address_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified public IP address.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param public_ip_address_name: The name of the subnet.\n        :type public_ip_address_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29508:c0:m2"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, public_ip_address_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>public_ip_address_name=public_ip_address_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a static or dynamic public IP address.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param public_ip_address_name: The name of the public IP address.\n        :type public_ip_address_name: str\n        :param parameters: Parameters supplied to the create or update public\n         IP address operation.\n        :type parameters:\n         ~azure.mgmt.network.v2016_12_01.models.PublicIPAddress\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns PublicIPAddress or\n         ClientRawResponse<PublicIPAddress> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2016_12_01.models.PublicIPAddress]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2016_12_01.models.PublicIPAddress]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29508:c0:m5"}
{"signature": "def get_troubleshooting_result(<EOL>self, resource_group_name, network_watcher_name, target_resource_id, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_troubleshooting_result_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>target_resource_id=target_resource_id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Get the last completed troubleshooting result on a specified resource.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher resource.\n        :type network_watcher_name: str\n        :param target_resource_id: The target resource ID to query the\n         troubleshooting result.\n        :type target_resource_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns TroubleshootingResult\n         or ClientRawResponse<TroubleshootingResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2016_12_01.models.TroubleshootingResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2016_12_01.models.TroubleshootingResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29510:c0:m17"}
{"signature": "def get_troubleshooting(<EOL>self, resource_group_name, network_watcher_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_troubleshooting_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Initiate troubleshooting on a specified resource.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher resource.\n        :type network_watcher_name: str\n        :param parameters: Parameters that define the resource to\n         troubleshoot.\n        :type parameters:\n         ~azure.mgmt.network.v2016_12_01.models.TroubleshootingParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns TroubleshootingResult\n         or ClientRawResponse<TroubleshootingResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2016_12_01.models.TroubleshootingResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2016_12_01.models.TroubleshootingResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29510:c0:m15"}
{"signature": "def get_vm_security_rules(<EOL>self, resource_group_name, network_watcher_name, target_resource_id, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_vm_security_rules_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>target_resource_id=target_resource_id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the configured and effective security group rules on the specified\n        VM.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param target_resource_id: ID of the target VM.\n        :type target_resource_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns SecurityGroupViewResult\n         or ClientRawResponse<SecurityGroupViewResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2016_12_01.models.SecurityGroupViewResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2016_12_01.models.SecurityGroupViewResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29510:c0:m13"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, circuit_name, peering_name, peering_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>peering_name=peering_name,<EOL>peering_parameters=peering_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a peering in the specified express route circuits.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param peering_parameters: Parameters supplied to the create or update\n         express route circuit peering operation.\n        :type peering_parameters:\n         ~azure.mgmt.network.v2016_12_01.models.ExpressRouteCircuitPeering\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCircuitPeering or\n         ClientRawResponse<ExpressRouteCircuitPeering> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2016_12_01.models.ExpressRouteCircuitPeering]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2016_12_01.models.ExpressRouteCircuitPeering]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29512:c0:m5"}
{"signature": "def get_bgp_peer_status(<EOL>self, resource_group_name, virtual_network_gateway_name, peer=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_bgp_peer_status_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_name=virtual_network_gateway_name,<EOL>peer=peer,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The GetBgpPeerStatus operation retrieves the status of all BGP peers.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param peer: The IP address of the peer to retrieve the status of.\n        :type peer: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns BgpPeerStatusListResult\n         or ClientRawResponse<BgpPeerStatusListResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2016_12_01.models.BgpPeerStatusListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2016_12_01.models.BgpPeerStatusListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29514:c0:m11"}
{"signature": "def get_learned_routes(<EOL>self, resource_group_name, virtual_network_gateway_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_learned_routes_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_name=virtual_network_gateway_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "This operation retrieves a list of routes the virtual network gateway\n        has learned, including routes learned from BGP peers.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns GatewayRouteListResult\n         or ClientRawResponse<GatewayRouteListResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2016_12_01.models.GatewayRouteListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2016_12_01.models.GatewayRouteListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29514:c0:m13"}
{"signature": "def get(<EOL>self, resource_group_name, route_filter_name, rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", route_filter_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", rule_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified rule from a route filter.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param rule_name: The name of the rule.\n        :type rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RouteFilterRule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2016_12_01.models.RouteFilterRule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29515:c0:m3"}
{"signature": "def delete(<EOL>self, resource_group_name, network_interface_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_interface_name=network_interface_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified network interface.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29516:c0:m5"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, network_interface_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_interface_name=network_interface_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a network interface.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param parameters: Parameters supplied to the create or update network\n         interface operation.\n        :type parameters:\n         ~azure.mgmt.network.v2016_12_01.models.NetworkInterface\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns NetworkInterface or\n         ClientRawResponse<NetworkInterface> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2016_12_01.models.NetworkInterface]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2016_12_01.models.NetworkInterface]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29516:c0:m8"}
{"signature": "def list_effective_network_security_groups(<EOL>self, resource_group_name, network_interface_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._list_effective_network_security_groups_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_interface_name=network_interface_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets all network security groups applied to a network interface.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         EffectiveNetworkSecurityGroupListResult or\n         ClientRawResponse<EffectiveNetworkSecurityGroupListResult> if\n         raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2016_12_01.models.EffectiveNetworkSecurityGroupListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2016_12_01.models.EffectiveNetworkSecurityGroupListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29516:c0:m14"}
{"signature": "def list_virtual_machine_scale_set_vm_network_interfaces(<EOL>self, resource_group_name, virtual_machine_scale_set_name, virtualmachine_index, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_virtual_machine_scale_set_vm_network_interfaces.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_machine_scale_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtualmachine_index, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about all network interfaces in a virtual machine in a\n        virtual machine scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_machine_scale_set_name: The name of the virtual machine\n         scale set.\n        :type virtual_machine_scale_set_name: str\n        :param virtualmachine_index: The virtual machine index.\n        :type virtualmachine_index: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkInterface\n        :rtype:\n         ~azure.mgmt.network.v2016_12_01.models.NetworkInterfacePaged[~azure.mgmt.network.v2016_12_01.models.NetworkInterface]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29516:c0:m1"}
{"signature": "def get_effective_route_table(<EOL>self, resource_group_name, network_interface_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_effective_route_table_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_interface_name=network_interface_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets all route tables applied to a network interface.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         EffectiveRouteListResult or\n         ClientRawResponse<EffectiveRouteListResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2016_12_01.models.EffectiveRouteListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2016_12_01.models.EffectiveRouteListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29516:c0:m12"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkSecurityGroupPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkSecurityGroupPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all network security groups in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkSecurityGroup\n        :rtype:\n         ~azure.mgmt.network.v2016_12_01.models.NetworkSecurityGroupPaged[~azure.mgmt.network.v2016_12_01.models.NetworkSecurityGroup]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29517:c0:m7"}
{"signature": "def get(<EOL>self, resource_group_name, network_security_group_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_security_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified network security group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: NetworkSecurityGroup or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2016_12_01.models.NetworkSecurityGroup or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29517:c0:m3"}
{"signature": "def check_dns_name_availability(<EOL>self, location, domain_name_label, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.check_dns_name_availability.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", domain_name_label, '<STR_LIT:str>')<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Checks whether a domain name in the cloudapp.azure.com zone is\n        available for use.\n\n        :param location: The location of the domain name.\n        :type location: str\n        :param domain_name_label: The domain name to be verified. It must\n         conform to the following regular expression:\n         ^[a-z][a-z0-9-]{1,61}[a-z0-9]$.\n        :type domain_name_label: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DnsNameAvailabilityResult or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2017_09_01.models.DnsNameAvailabilityResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29519:c1:m1"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, load_balancer_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>load_balancer_name=load_balancer_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a load balancer.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param parameters: Parameters supplied to the create or update load\n         balancer operation.\n        :type parameters: ~azure.mgmt.network.v2017_09_01.models.LoadBalancer\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns LoadBalancer or\n         ClientRawResponse<LoadBalancer> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_09_01.models.LoadBalancer]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_09_01.models.LoadBalancer]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29789:c0:m5"}
{"signature": "def delete(<EOL>self, resource_group_name, load_balancer_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>load_balancer_name=load_balancer_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified load balancer.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29789:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, network_interface_name, ip_configuration_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_interface_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", ip_configuration_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified network interface ip configuration.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param ip_configuration_name: The name of the ip configuration name.\n        :type ip_configuration_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: NetworkInterfaceIPConfiguration or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.network.v2017_09_01.models.NetworkInterfaceIPConfiguration\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29790:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, load_balancer_name, probe_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", probe_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets load balancer probe.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param probe_name: The name of the probe.\n        :type probe_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Probe or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_09_01.models.Probe or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29792:c0:m2"}
{"signature": "def list(<EOL>self, resource_group_name, load_balancer_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ProbePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ProbePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the load balancer probes.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Probe\n        :rtype:\n         ~azure.mgmt.network.v2017_09_01.models.ProbePaged[~azure.mgmt.network.v2017_09_01.models.Probe]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29792:c0:m1"}
{"signature": "def list(<EOL>self, resource_group_name, network_watcher_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_watcher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PacketCaptureResultPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PacketCaptureResultPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all packet capture sessions within the specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the Network Watcher resource.\n        :type network_watcher_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PacketCaptureResult\n        :rtype:\n         ~azure.mgmt.network.v2017_09_01.models.PacketCaptureResultPaged[~azure.mgmt.network.v2017_09_01.models.PacketCaptureResult]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29793:c0:m10"}
{"signature": "def get_status(<EOL>self, resource_group_name, network_watcher_name, packet_capture_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_status_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>packet_capture_name=packet_capture_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT:location>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Query the status of a running packet capture session.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the Network Watcher resource.\n        :type network_watcher_name: str\n        :param packet_capture_name: The name given to the packet capture\n         session.\n        :type packet_capture_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         PacketCaptureQueryStatusResult or\n         ClientRawResponse<PacketCaptureQueryStatusResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_09_01.models.PacketCaptureQueryStatusResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_09_01.models.PacketCaptureQueryStatusResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29793:c0:m9"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, virtual_network_gateway_connection_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_connection_name=virtual_network_gateway_connection_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a virtual network gateway connection in the\n        specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_connection_name: The name of the\n         virtual network gateway connection.\n        :type virtual_network_gateway_connection_name: str\n        :param parameters: Parameters supplied to the create or update virtual\n         network gateway connection operation.\n        :type parameters:\n         ~azure.mgmt.network.v2017_09_01.models.VirtualNetworkGatewayConnection\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         VirtualNetworkGatewayConnection or\n         ClientRawResponse<VirtualNetworkGatewayConnection> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_09_01.models.VirtualNetworkGatewayConnection]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_09_01.models.VirtualNetworkGatewayConnection]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29794:c0:m2"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ApplicationGatewayPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ApplicationGatewayPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all application gateways in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ApplicationGateway\n        :rtype:\n         ~azure.mgmt.network.v2017_09_01.models.ApplicationGatewayPaged[~azure.mgmt.network.v2017_09_01.models.ApplicationGateway]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29796:c0:m8"}
{"signature": "def backend_health(<EOL>self, resource_group_name, application_gateway_name, expand=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._backend_health_initial(<EOL>resource_group_name=resource_group_name,<EOL>application_gateway_name=application_gateway_name,<EOL>expand=expand,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the backend health of the specified application gateway in a\n        resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param application_gateway_name: The name of the application gateway.\n        :type application_gateway_name: str\n        :param expand: Expands BackendAddressPool and BackendHttpSettings\n         referenced in backend health.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ApplicationGatewayBackendHealth or\n         ClientRawResponse<ApplicationGatewayBackendHealth> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_09_01.models.ApplicationGatewayBackendHealth]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_09_01.models.ApplicationGatewayBackendHealth]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29796:c0:m15"}
{"signature": "def get_ssl_predefined_policy(<EOL>self, predefined_policy_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_ssl_predefined_policy.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", predefined_policy_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets Ssl predefined policy with the specified policy name.\n\n        :param predefined_policy_name: Name of Ssl predefined policy.\n        :type predefined_policy_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ApplicationGatewaySslPredefinedPolicy or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.network.v2017_09_01.models.ApplicationGatewaySslPredefinedPolicy\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29796:c0:m19"}
{"signature": "def list_available_ssl_predefined_policies(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_available_ssl_predefined_policies.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ApplicationGatewaySslPredefinedPolicyPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ApplicationGatewaySslPredefinedPolicyPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all SSL predefined policies for configuring Ssl policy.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of\n         ApplicationGatewaySslPredefinedPolicy\n        :rtype:\n         ~azure.mgmt.network.v2017_09_01.models.ApplicationGatewaySslPredefinedPolicyPaged[~azure.mgmt.network.v2017_09_01.models.ApplicationGatewaySslPredefinedPolicy]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29796:c0:m18"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, application_gateway_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>application_gateway_name=application_gateway_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates the specified application gateway.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param application_gateway_name: The name of the application gateway.\n        :type application_gateway_name: str\n        :param parameters: Parameters supplied to the create or update\n         application gateway operation.\n        :type parameters:\n         ~azure.mgmt.network.v2017_09_01.models.ApplicationGateway\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ApplicationGateway or\n         ClientRawResponse<ApplicationGateway> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_09_01.models.ApplicationGateway]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_09_01.models.ApplicationGateway]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29796:c0:m5"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ApplicationGatewayPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ApplicationGatewayPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the application gateways in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ApplicationGateway\n        :rtype:\n         ~azure.mgmt.network.v2017_09_01.models.ApplicationGatewayPaged[~azure.mgmt.network.v2017_09_01.models.ApplicationGateway]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29796:c0:m9"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, route_filter_name, route_filter_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_filter_name=route_filter_name,<EOL>route_filter_parameters=route_filter_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a route filter in a specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param route_filter_parameters: Parameters supplied to the create or\n         update route filter operation.\n        :type route_filter_parameters:\n         ~azure.mgmt.network.v2017_09_01.models.RouteFilter\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns RouteFilter or\n         ClientRawResponse<RouteFilter> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_09_01.models.RouteFilter]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_09_01.models.RouteFilter]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29797:c0:m5"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, local_network_gateway_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>local_network_gateway_name=local_network_gateway_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a local network gateway in the specified resource\n        group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param local_network_gateway_name: The name of the local network\n         gateway.\n        :type local_network_gateway_name: str\n        :param parameters: Parameters supplied to the create or update local\n         network gateway operation.\n        :type parameters:\n         ~azure.mgmt.network.v2017_09_01.models.LocalNetworkGateway\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns LocalNetworkGateway or\n         ClientRawResponse<LocalNetworkGateway> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_09_01.models.LocalNetworkGateway]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_09_01.models.LocalNetworkGateway]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29798:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, local_network_gateway_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>local_network_gateway_name=local_network_gateway_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified local network gateway.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param local_network_gateway_name: The name of the local network\n         gateway.\n        :type local_network_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29798:c0:m5"}
{"signature": "def get(<EOL>self, resource_group_name, local_network_gateway_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", local_network_gateway_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified local network gateway in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param local_network_gateway_name: The name of the local network\n         gateway.\n        :type local_network_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: LocalNetworkGateway or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_09_01.models.LocalNetworkGateway or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29798:c0:m3"}
{"signature": "def delete(<EOL>self, resource_group_name, route_table_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_table_name=route_table_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified route table.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29800:c0:m2"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, route_table_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_table_name=route_table_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Create or updates a route table in a specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param parameters: Parameters supplied to the create or update route\n         table operation.\n        :type parameters: ~azure.mgmt.network.v2017_09_01.models.RouteTable\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns RouteTable or\n         ClientRawResponse<RouteTable> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_09_01.models.RouteTable]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_09_01.models.RouteTable]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29800:c0:m5"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, virtual_network_name, virtual_network_peering_name, virtual_network_peering_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_name=virtual_network_name,<EOL>virtual_network_peering_name=virtual_network_peering_name,<EOL>virtual_network_peering_parameters=virtual_network_peering_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a peering in the specified virtual network.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param virtual_network_peering_name: The name of the peering.\n        :type virtual_network_peering_name: str\n        :param virtual_network_peering_parameters: Parameters supplied to the\n         create or update virtual network peering operation.\n        :type virtual_network_peering_parameters:\n         ~azure.mgmt.network.v2017_09_01.models.VirtualNetworkPeering\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualNetworkPeering\n         or ClientRawResponse<VirtualNetworkPeering> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_09_01.models.VirtualNetworkPeering]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_09_01.models.VirtualNetworkPeering]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29802:c0:m5"}
{"signature": "def get(<EOL>self, resource_group_name, virtual_network_name, virtual_network_peering_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_peering_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified virtual network peering.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param virtual_network_peering_name: The name of the virtual network\n         peering.\n        :type virtual_network_peering_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualNetworkPeering or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_09_01.models.VirtualNetworkPeering\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29802:c0:m3"}
{"signature": "def list_usage(<EOL>self, resource_group_name, virtual_network_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_usage.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualNetworkUsagePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualNetworkUsagePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists usage stats.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualNetworkUsage\n        :rtype:\n         ~azure.mgmt.network.v2017_09_01.models.VirtualNetworkUsagePaged[~azure.mgmt.network.v2017_09_01.models.VirtualNetworkUsage]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29803:c0:m11"}
{"signature": "def get(<EOL>self, resource_group_name, virtual_network_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified virtual network by resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualNetwork or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_09_01.models.VirtualNetwork or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29803:c0:m3"}
{"signature": "def check_ip_address_availability(<EOL>self, resource_group_name, virtual_network_name, ip_address=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.check_ip_address_availability.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if ip_address is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", ip_address, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Checks whether a private IP address is available for use.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param ip_address: The private IP address to be verified.\n        :type ip_address: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: IPAddressAvailabilityResult or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2017_09_01.models.IPAddressAvailabilityResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29803:c0:m10"}
{"signature": "def get(<EOL>self, resource_group_name, load_balancer_name, inbound_nat_rule_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", inbound_nat_rule_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified load balancer inbound nat rule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param inbound_nat_rule_name: The name of the inbound nat rule.\n        :type inbound_nat_rule_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: InboundNatRule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_09_01.models.InboundNatRule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29804:c0:m4"}
{"signature": "def list_routes_table_summary(<EOL>self, resource_group_name, circuit_name, peering_name, device_path, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._list_routes_table_summary_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>peering_name=peering_name,<EOL>device_path=device_path,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the currently advertised routes table summary associated with the\n        express route circuit in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param device_path: The path of the device.\n        :type device_path: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCircuitsRoutesTableSummaryListResult or\n         ClientRawResponse<ExpressRouteCircuitsRoutesTableSummaryListResult> if\n         raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_09_01.models.ExpressRouteCircuitsRoutesTableSummaryListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_09_01.models.ExpressRouteCircuitsRoutesTableSummaryListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29805:c0:m13"}
{"signature": "def get(<EOL>self, resource_group_name, circuit_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about the specified express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of express route circuit.\n        :type circuit_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteCircuit or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_09_01.models.ExpressRouteCircuit or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29805:c0:m3"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ExpressRouteCircuitPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ExpressRouteCircuitPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the express route circuits in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ExpressRouteCircuit\n        :rtype:\n         ~azure.mgmt.network.v2017_09_01.models.ExpressRouteCircuitPaged[~azure.mgmt.network.v2017_09_01.models.ExpressRouteCircuit]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29805:c0:m16"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, circuit_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates an express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the circuit.\n        :type circuit_name: str\n        :param parameters: Parameters supplied to the create or update express\n         route circuit operation.\n        :type parameters:\n         ~azure.mgmt.network.v2017_09_01.models.ExpressRouteCircuit\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ExpressRouteCircuit or\n         ClientRawResponse<ExpressRouteCircuit> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_09_01.models.ExpressRouteCircuit]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_09_01.models.ExpressRouteCircuit]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29805:c0:m5"}
{"signature": "def list_arp_table(<EOL>self, resource_group_name, circuit_name, peering_name, device_path, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._list_arp_table_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>peering_name=peering_name,<EOL>device_path=device_path,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the currently advertised ARP table associated with the express\n        route circuit in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param device_path: The path of the device.\n        :type device_path: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCircuitsArpTableListResult or\n         ClientRawResponse<ExpressRouteCircuitsArpTableListResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_09_01.models.ExpressRouteCircuitsArpTableListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_09_01.models.ExpressRouteCircuitsArpTableListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29805:c0:m9"}
{"signature": "def update_tags(<EOL>self, resource_group_name, circuit_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates an express route circuit tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the circuit.\n        :type circuit_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ExpressRouteCircuit or\n         ClientRawResponse<ExpressRouteCircuit> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_09_01.models.ExpressRouteCircuit]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_09_01.models.ExpressRouteCircuit]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29805:c0:m7"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, application_security_group_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>application_security_group_name=application_security_group_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates an application security group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param application_security_group_name: The name of the application\n         security group.\n        :type application_security_group_name: str\n        :param parameters: Parameters supplied to the create or update\n         ApplicationSecurityGroup operation.\n        :type parameters:\n         ~azure.mgmt.network.v2017_09_01.models.ApplicationSecurityGroup\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ApplicationSecurityGroup or\n         ClientRawResponse<ApplicationSecurityGroup> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_09_01.models.ApplicationSecurityGroup]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_09_01.models.ApplicationSecurityGroup]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29806:c0:m5"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, circuit_name, authorization_name, authorization_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>authorization_name=authorization_name,<EOL>authorization_parameters=authorization_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates an authorization in the specified express route\n        circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param authorization_name: The name of the authorization.\n        :type authorization_name: str\n        :param authorization_parameters: Parameters supplied to the create or\n         update express route circuit authorization operation.\n        :type authorization_parameters:\n         ~azure.mgmt.network.v2017_09_01.models.ExpressRouteCircuitAuthorization\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCircuitAuthorization or\n         ClientRawResponse<ExpressRouteCircuitAuthorization> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_09_01.models.ExpressRouteCircuitAuthorization]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_09_01.models.ExpressRouteCircuitAuthorization]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29807:c0:m5"}
{"signature": "def delete(<EOL>self, resource_group_name, circuit_name, authorization_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>authorization_name=authorization_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified authorization from the specified express route\n        circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param authorization_name: The name of the authorization.\n        :type authorization_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29807:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, network_security_group_name, security_rule_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_security_group_name=network_security_group_name,<EOL>security_rule_name=security_rule_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified network security rule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param security_rule_name: The name of the security rule.\n        :type security_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29809:c0:m2"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, virtual_network_name, subnet_name, subnet_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_name=virtual_network_name,<EOL>subnet_name=subnet_name,<EOL>subnet_parameters=subnet_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a subnet in the specified virtual network.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param subnet_name: The name of the subnet.\n        :type subnet_name: str\n        :param subnet_parameters: Parameters supplied to the create or update\n         subnet operation.\n        :type subnet_parameters: ~azure.mgmt.network.v2017_09_01.models.Subnet\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Subnet or\n         ClientRawResponse<Subnet> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_09_01.models.Subnet]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_09_01.models.Subnet]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29810:c0:m5"}
{"signature": "def delete(<EOL>self, resource_group_name, virtual_network_name, subnet_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_name=virtual_network_name,<EOL>subnet_name=subnet_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified subnet.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param subnet_name: The name of the subnet.\n        :type subnet_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29810:c0:m2"}
{"signature": "def list(<EOL>self, resource_group_name, virtual_network_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SubnetPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SubnetPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all subnets in a virtual network.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Subnet\n        :rtype:\n         ~azure.mgmt.network.v2017_09_01.models.SubnetPaged[~azure.mgmt.network.v2017_09_01.models.Subnet]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29810:c0:m6"}
{"signature": "def get(<EOL>self, resource_group_name, virtual_network_name, subnet_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", subnet_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified subnet by virtual network and resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param subnet_name: The name of the subnet.\n        :type subnet_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Subnet or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_09_01.models.Subnet or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29810:c0:m3"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PublicIPAddressPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PublicIPAddressPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all public IP addresses in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PublicIPAddress\n        :rtype:\n         ~azure.mgmt.network.v2017_09_01.models.PublicIPAddressPaged[~azure.mgmt.network.v2017_09_01.models.PublicIPAddress]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29811:c0:m9"}
{"signature": "def list_virtual_machine_scale_set_vm_public_ip_addresses(<EOL>self, resource_group_name, virtual_machine_scale_set_name, virtualmachine_index, network_interface_name, ip_configuration_name, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_virtual_machine_scale_set_vm_public_ip_addresses.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_machine_scale_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtualmachine_index, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_interface_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", ip_configuration_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PublicIPAddressPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PublicIPAddressPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about all public IP addresses in a virtual machine IP\n        configuration in a virtual machine scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_machine_scale_set_name: The name of the virtual machine\n         scale set.\n        :type virtual_machine_scale_set_name: str\n        :param virtualmachine_index: The virtual machine index.\n        :type virtualmachine_index: str\n        :param network_interface_name: The network interface name.\n        :type network_interface_name: str\n        :param ip_configuration_name: The IP configuration name.\n        :type ip_configuration_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PublicIPAddress\n        :rtype:\n         ~azure.mgmt.network.v2017_09_01.models.PublicIPAddressPaged[~azure.mgmt.network.v2017_09_01.models.PublicIPAddress]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29811:c0:m11"}
{"signature": "def get_next_hop(<EOL>self, resource_group_name, network_watcher_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_next_hop_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the next hop from the specified VM.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param parameters: Parameters that define the source and destination\n         endpoint.\n        :type parameters:\n         ~azure.mgmt.network.v2017_09_01.models.NextHopParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns NextHopResult or\n         ClientRawResponse<NextHopResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_09_01.models.NextHopResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_09_01.models.NextHopResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29815:c0:m12"}
{"signature": "def get_troubleshooting_result(<EOL>self, resource_group_name, network_watcher_name, target_resource_id, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_troubleshooting_result_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>target_resource_id=target_resource_id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Get the last completed troubleshooting result on a specified resource.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher resource.\n        :type network_watcher_name: str\n        :param target_resource_id: The target resource ID to query the\n         troubleshooting result.\n        :type target_resource_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns TroubleshootingResult\n         or ClientRawResponse<TroubleshootingResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_09_01.models.TroubleshootingResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_09_01.models.TroubleshootingResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29815:c0:m18"}
{"signature": "def set_flow_log_configuration(<EOL>self, resource_group_name, network_watcher_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._set_flow_log_configuration_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Configures flow log on a specified resource.\n\n        :param resource_group_name: The name of the network watcher resource\n         group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher resource.\n        :type network_watcher_name: str\n        :param parameters: Parameters that define the configuration of flow\n         log.\n        :type parameters:\n         ~azure.mgmt.network.v2017_09_01.models.FlowLogInformation\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns FlowLogInformation or\n         ClientRawResponse<FlowLogInformation> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_09_01.models.FlowLogInformation]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_09_01.models.FlowLogInformation]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29815:c0:m20"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, network_watcher_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_watcher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or updates a network watcher in the specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param parameters: Parameters that define the network watcher\n         resource.\n        :type parameters:\n         ~azure.mgmt.network.v2017_09_01.models.NetworkWatcher\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: NetworkWatcher or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_09_01.models.NetworkWatcher or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29815:c0:m1"}
{"signature": "def check_connectivity(<EOL>self, resource_group_name, network_watcher_name, source, destination, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._check_connectivity_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>source=source,<EOL>destination=destination,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Verifies the possibility of establishing a direct TCP connection from a\n        virtual machine to a given endpoint including another VM or an\n        arbitrary remote server.\n\n        :param resource_group_name: The name of the network watcher resource\n         group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher resource.\n        :type network_watcher_name: str\n        :param source:\n        :type source:\n         ~azure.mgmt.network.v2017_09_01.models.ConnectivitySource\n        :param destination:\n        :type destination:\n         ~azure.mgmt.network.v2017_09_01.models.ConnectivityDestination\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ConnectivityInformation\n         or ClientRawResponse<ConnectivityInformation> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_09_01.models.ConnectivityInformation]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_09_01.models.ConnectivityInformation]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29815:c0:m24"}
{"signature": "def verify_ip_flow(<EOL>self, resource_group_name, network_watcher_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._verify_ip_flow_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Verify IP flow from the specified VM to a location given the currently\n        configured NSG rules.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param parameters: Parameters that define the IP flow to be verified.\n        :type parameters:\n         ~azure.mgmt.network.v2017_09_01.models.VerificationIPFlowParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         VerificationIPFlowResult or\n         ClientRawResponse<VerificationIPFlowResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_09_01.models.VerificationIPFlowResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_09_01.models.VerificationIPFlowResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29815:c0:m10"}
{"signature": "def delete(<EOL>self, resource_group_name, circuit_name, peering_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>peering_name=peering_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified peering from the specified express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29817:c0:m2"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, route_table_name, route_name, route_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_table_name=route_table_name,<EOL>route_name=route_name,<EOL>route_parameters=route_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a route in the specified route table.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param route_name: The name of the route.\n        :type route_name: str\n        :param route_parameters: Parameters supplied to the create or update\n         route operation.\n        :type route_parameters: ~azure.mgmt.network.v2017_09_01.models.Route\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Route or\n         ClientRawResponse<Route> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_09_01.models.Route]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_09_01.models.Route]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29819:c0:m5"}
{"signature": "def supported_vpn_devices(<EOL>self, resource_group_name, virtual_network_gateway_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.supported_vpn_devices.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_gateway_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT:str>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a xml format representation for supported vpn devices.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: str or ClientRawResponse if raw=true\n        :rtype: str or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29820:c0:m19"}
{"signature": "def reset(<EOL>self, resource_group_name, virtual_network_gateway_name, gateway_vip=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._reset_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_name=virtual_network_gateway_name,<EOL>gateway_vip=gateway_vip,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Resets the primary of the virtual network gateway in the specified\n        resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param gateway_vip: Virtual network gateway vip address supplied to\n         the begin reset of the active-active feature enabled gateway.\n        :type gateway_vip: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualNetworkGateway\n         or ClientRawResponse<VirtualNetworkGateway> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_09_01.models.VirtualNetworkGateway]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_09_01.models.VirtualNetworkGateway]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29820:c0:m11"}
{"signature": "def delete(<EOL>self, resource_group_name, virtual_network_gateway_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_name=virtual_network_gateway_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified virtual network gateway.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29820:c0:m5"}
{"signature": "def list_connections(<EOL>self, resource_group_name, virtual_network_gateway_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_connections.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_gateway_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualNetworkGatewayConnectionListEntityPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualNetworkGatewayConnectionListEntityPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the connections in a virtual network gateway.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of\n         VirtualNetworkGatewayConnectionListEntity\n        :rtype:\n         ~azure.mgmt.network.v2017_09_01.models.VirtualNetworkGatewayConnectionListEntityPaged[~azure.mgmt.network.v2017_09_01.models.VirtualNetworkGatewayConnectionListEntity]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29820:c0:m9"}
{"signature": "def update(<EOL>self, resource_group_name, route_filter_name, rule_name, route_filter_rule_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_filter_name=route_filter_name,<EOL>rule_name=rule_name,<EOL>route_filter_rule_parameters=route_filter_rule_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a route in the specified route filter.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param rule_name: The name of the route filter rule.\n        :type rule_name: str\n        :param route_filter_rule_parameters: Parameters supplied to the update\n         route filter rule operation.\n        :type route_filter_rule_parameters:\n         ~azure.mgmt.network.v2017_09_01.models.PatchRouteFilterRule\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns RouteFilterRule or\n         ClientRawResponse<RouteFilterRule> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_09_01.models.RouteFilterRule]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_09_01.models.RouteFilterRule]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29822:c0:m7"}
{"signature": "def list_effective_network_security_groups(<EOL>self, resource_group_name, network_interface_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._list_effective_network_security_groups_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_interface_name=network_interface_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets all network security groups applied to a network interface.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         EffectiveNetworkSecurityGroupListResult or\n         ClientRawResponse<EffectiveNetworkSecurityGroupListResult> if\n         raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_09_01.models.EffectiveNetworkSecurityGroupListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_09_01.models.EffectiveNetworkSecurityGroupListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29823:c0:m13"}
{"signature": "def get(<EOL>self, resource_group_name, network_interface_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_interface_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about the specified network interface.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: NetworkInterface or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_09_01.models.NetworkInterface or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29823:c0:m3"}
{"signature": "def update_tags(<EOL>self, resource_group_name, network_interface_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_interface_name=network_interface_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a network interface tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns NetworkInterface or\n         ClientRawResponse<NetworkInterface> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_09_01.models.NetworkInterface]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_09_01.models.NetworkInterface]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29823:c0:m7"}
{"signature": "def delete(<EOL>self, resource_group_name, network_interface_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_interface_name=network_interface_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified network interface.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29823:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, network_security_group_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_security_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified network security group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: NetworkSecurityGroup or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_09_01.models.NetworkSecurityGroup or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29824:c0:m3"}
{"signature": "def check_dns_name_availability(<EOL>self, location, domain_name_label, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.check_dns_name_availability.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", domain_name_label, '<STR_LIT:str>')<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Checks whether a domain name in the cloudapp.azure.com zone is\n        available for use.\n\n        :param location: The location of the domain name.\n        :type location: str\n        :param domain_name_label: The domain name to be verified. It must\n         conform to the following regular expression:\n         ^[a-z][a-z0-9-]{1,61}[a-z0-9]$.\n        :type domain_name_label: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DnsNameAvailabilityResult or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_10_01.models.DnsNameAvailabilityResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f29825:c1:m1"}
{"signature": "def list(<EOL>self, resource_group_name, load_balancer_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.BackendAddressPoolPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.BackendAddressPoolPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the load balancer backed address pools.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of BackendAddressPool\n        :rtype:\n         ~azure.mgmt.network.v2018_10_01.models.BackendAddressPoolPaged[~azure.mgmt.network.v2018_10_01.models.BackendAddressPool]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30267:c0:m1"}
{"signature": "def list(<EOL>self, resource_group_name, network_interface_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_interface_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkInterfaceTapConfigurationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkInterfaceTapConfigurationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get all Tap configurations in a network interface.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkInterfaceTapConfiguration\n        :rtype:\n         ~azure.mgmt.network.v2018_10_01.models.NetworkInterfaceTapConfigurationPaged[~azure.mgmt.network.v2018_10_01.models.NetworkInterfaceTapConfiguration]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30269:c0:m6"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, express_route_gateway_name, put_express_route_gateway_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>express_route_gateway_name=express_route_gateway_name,<EOL>put_express_route_gateway_parameters=put_express_route_gateway_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a ExpressRoute gateway in a specified resource\n        group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param express_route_gateway_name: The name of the ExpressRoute\n         gateway.\n        :type express_route_gateway_name: str\n        :param put_express_route_gateway_parameters: Parameters required in an\n         ExpressRoute gateway PUT operation.\n        :type put_express_route_gateway_parameters:\n         ~azure.mgmt.network.v2018_10_01.models.ExpressRouteGateway\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ExpressRouteGateway or\n         ClientRawResponse<ExpressRouteGateway> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_10_01.models.ExpressRouteGateway]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_10_01.models.ExpressRouteGateway]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30271:c0:m4"}
{"signature": "def delete(<EOL>self, resource_group_name, express_route_gateway_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>express_route_gateway_name=express_route_gateway_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified ExpressRoute gateway in a resource group. An\n        ExpressRoute gateway resource can only be deleted when there are no\n        connection subresources.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param express_route_gateway_name: The name of the ExpressRoute\n         gateway.\n        :type express_route_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30271:c0:m7"}
{"signature": "def get(<EOL>self, resource_group_name, express_route_gateway_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", express_route_gateway_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Fetches the details of a ExpressRoute gateway in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param express_route_gateway_name: The name of the ExpressRoute\n         gateway.\n        :type express_route_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteGateway or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_10_01.models.ExpressRouteGateway or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30271:c0:m5"}
{"signature": "def list_routes_table(<EOL>self, resource_group_name, cross_connection_name, peering_name, device_path, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._list_routes_table_initial(<EOL>resource_group_name=resource_group_name,<EOL>cross_connection_name=cross_connection_name,<EOL>peering_name=peering_name,<EOL>device_path=device_path,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the currently advertised routes table associated with the express\n        route cross connection in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param cross_connection_name: The name of the\n         ExpressRouteCrossConnection.\n        :type cross_connection_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param device_path: The path of the device.\n        :type device_path: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCircuitsRoutesTableListResult or\n         ClientRawResponse<ExpressRouteCircuitsRoutesTableListResult> if\n         raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_10_01.models.ExpressRouteCircuitsRoutesTableListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_10_01.models.ExpressRouteCircuitsRoutesTableListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30272:c0:m13"}
{"signature": "def list_arp_table(<EOL>self, resource_group_name, cross_connection_name, peering_name, device_path, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._list_arp_table_initial(<EOL>resource_group_name=resource_group_name,<EOL>cross_connection_name=cross_connection_name,<EOL>peering_name=peering_name,<EOL>device_path=device_path,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the currently advertised ARP table associated with the express\n        route cross connection in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param cross_connection_name: The name of the\n         ExpressRouteCrossConnection.\n        :type cross_connection_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param device_path: The path of the device\n        :type device_path: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCircuitsArpTableListResult or\n         ClientRawResponse<ExpressRouteCircuitsArpTableListResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_10_01.models.ExpressRouteCircuitsArpTableListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_10_01.models.ExpressRouteCircuitsArpTableListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30272:c0:m9"}
{"signature": "def update_tags(<EOL>self, resource_group_name, cross_connection_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>cross_connection_name=cross_connection_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates an express route cross connection tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param cross_connection_name: The name of the cross connection.\n        :type cross_connection_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCrossConnection or\n         ClientRawResponse<ExpressRouteCrossConnection> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_10_01.models.ExpressRouteCrossConnection]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_10_01.models.ExpressRouteCrossConnection]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30272:c0:m7"}
{"signature": "def list(<EOL>self, resource_group_name, load_balancer_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ProbePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ProbePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the load balancer probes.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Probe\n        :rtype:\n         ~azure.mgmt.network.v2018_10_01.models.ProbePaged[~azure.mgmt.network.v2018_10_01.models.Probe]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30274:c0:m1"}
{"signature": "def get(<EOL>self, resource_group_name, network_watcher_name, packet_capture_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_watcher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", packet_capture_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a packet capture session by name.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param packet_capture_name: The name of the packet capture session.\n        :type packet_capture_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PacketCaptureResult or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_10_01.models.PacketCaptureResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_10_01.models.ErrorResponseException>`", "id": "f30275:c0:m3"}
{"signature": "def set_shared_key(<EOL>self, resource_group_name, virtual_network_gateway_connection_name, value, id=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._set_shared_key_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_connection_name=virtual_network_gateway_connection_name,<EOL>value=value,<EOL>id=id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The Put VirtualNetworkGatewayConnectionSharedKey operation sets the\n        virtual network gateway connection shared key for passed virtual\n        network gateway connection in the specified resource group through\n        Network resource provider.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_connection_name: The virtual network\n         gateway connection name.\n        :type virtual_network_gateway_connection_name: str\n        :param value: The virtual network connection shared key value.\n        :type value: str\n        :param id: Resource ID.\n        :type id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ConnectionSharedKey or\n         ClientRawResponse<ConnectionSharedKey> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_10_01.models.ConnectionSharedKey]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_10_01.models.ConnectionSharedKey]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30276:c0:m9"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, virtual_network_gateway_connection_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_connection_name=virtual_network_gateway_connection_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a virtual network gateway connection in the\n        specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_connection_name: The name of the\n         virtual network gateway connection.\n        :type virtual_network_gateway_connection_name: str\n        :param parameters: Parameters supplied to the create or update virtual\n         network gateway connection operation.\n        :type parameters:\n         ~azure.mgmt.network.v2018_10_01.models.VirtualNetworkGatewayConnection\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         VirtualNetworkGatewayConnection or\n         ClientRawResponse<VirtualNetworkGatewayConnection> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_10_01.models.VirtualNetworkGatewayConnection]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_10_01.models.VirtualNetworkGatewayConnection]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30276:c0:m2"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualNetworkGatewayConnectionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualNetworkGatewayConnectionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "The List VirtualNetworkGatewayConnections operation retrieves all the\n        virtual network gateways connections created.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualNetworkGatewayConnection\n        :rtype:\n         ~azure.mgmt.network.v2018_10_01.models.VirtualNetworkGatewayConnectionPaged[~azure.mgmt.network.v2018_10_01.models.VirtualNetworkGatewayConnection]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30276:c0:m11"}
{"signature": "def delete(<EOL>self, resource_group_name, express_route_port_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>express_route_port_name=express_route_port_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified ExpressRoutePort resource.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param express_route_port_name: The name of the ExpressRoutePort\n         resource.\n        :type express_route_port_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30277:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, gateway_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", gateway_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves the details of a virtual wan p2s vpn gateway.\n\n        :param resource_group_name: The resource group name of the\n         P2SVpnGateway.\n        :type resource_group_name: str\n        :param gateway_name: The name of the gateway.\n        :type gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: P2SVpnGateway or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_10_01.models.P2SVpnGateway or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_10_01.models.ErrorException>`", "id": "f30279:c0:m1"}
{"signature": "def get(<EOL>self, resource_group_name, ddos_protection_plan_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", ddos_protection_plan_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about the specified DDoS protection plan.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param ddos_protection_plan_name: The name of the DDoS protection\n         plan.\n        :type ddos_protection_plan_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DdosProtectionPlan or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_10_01.models.DdosProtectionPlan or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30280:c0:m3"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.DdosProtectionPlanPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.DdosProtectionPlanPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all DDoS protection plans in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of DdosProtectionPlan\n        :rtype:\n         ~azure.mgmt.network.v2018_10_01.models.DdosProtectionPlanPaged[~azure.mgmt.network.v2018_10_01.models.DdosProtectionPlan]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30280:c0:m6"}
{"signature": "def delete(<EOL>self, resource_group_name, azure_firewall_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>azure_firewall_name=azure_firewall_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified Azure Firewall.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param azure_firewall_name: The name of the Azure Firewall.\n        :type azure_firewall_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30281:c0:m2"}
{"signature": "def backend_health(<EOL>self, resource_group_name, application_gateway_name, expand=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._backend_health_initial(<EOL>resource_group_name=resource_group_name,<EOL>application_gateway_name=application_gateway_name,<EOL>expand=expand,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the backend health of the specified application gateway in a\n        resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param application_gateway_name: The name of the application gateway.\n        :type application_gateway_name: str\n        :param expand: Expands BackendAddressPool and BackendHttpSettings\n         referenced in backend health.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ApplicationGatewayBackendHealth or\n         ClientRawResponse<ApplicationGatewayBackendHealth> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_10_01.models.ApplicationGatewayBackendHealth]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_10_01.models.ApplicationGatewayBackendHealth]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30282:c0:m15"}
{"signature": "def list_available_ssl_options(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_available_ssl_options.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists available Ssl options for configuring Ssl policy.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ApplicationGatewayAvailableSslOptions or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_10_01.models.ApplicationGatewayAvailableSslOptions\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30282:c0:m17"}
{"signature": "def update_tags(<EOL>self, resource_group_name, application_gateway_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>application_gateway_name=application_gateway_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates the specified application gateway tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param application_gateway_name: The name of the application gateway.\n        :type application_gateway_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ApplicationGateway or\n         ClientRawResponse<ApplicationGateway> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_10_01.models.ApplicationGateway]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_10_01.models.ApplicationGateway]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30282:c0:m7"}
{"signature": "def delete(<EOL>self, resource_group_name, application_gateway_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>application_gateway_name=application_gateway_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified application gateway.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param application_gateway_name: The name of the application gateway.\n        :type application_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30282:c0:m2"}
{"signature": "def update_tags(<EOL>self, resource_group_name, network_profile_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_profile_name=network_profile_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates network profile tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_profile_name: The name of the network profile.\n        :type network_profile_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns NetworkProfile or\n         ClientRawResponse<NetworkProfile> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_10_01.models.NetworkProfile]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_10_01.models.NetworkProfile]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30283:c0:m7"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, network_profile_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_profile_name=network_profile_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a network profile.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_profile_name: The name of the network profile.\n        :type network_profile_name: str\n        :param parameters: Parameters supplied to the create or update network\n         profile operation.\n        :type parameters:\n         ~azure.mgmt.network.v2018_10_01.models.NetworkProfile\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns NetworkProfile or\n         ClientRawResponse<NetworkProfile> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_10_01.models.NetworkProfile]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_10_01.models.NetworkProfile]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30283:c0:m5"}
{"signature": "def delete(<EOL>self, resource_group_name, network_profile_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_profile_name=network_profile_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified network profile.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_profile_name: The name of the NetworkProfile.\n        :type network_profile_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30283:c0:m2"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, service_endpoint_policy_name, service_endpoint_policy_definition_name, service_endpoint_policy_definitions, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>service_endpoint_policy_name=service_endpoint_policy_name,<EOL>service_endpoint_policy_definition_name=service_endpoint_policy_definition_name,<EOL>service_endpoint_policy_definitions=service_endpoint_policy_definitions,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a service endpoint policy definition in the\n        specified service endpoint policy.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param service_endpoint_policy_name: The name of the service endpoint\n         policy.\n        :type service_endpoint_policy_name: str\n        :param service_endpoint_policy_definition_name: The name of the\n         service endpoint policy definition name.\n        :type service_endpoint_policy_definition_name: str\n        :param service_endpoint_policy_definitions: Parameters supplied to the\n         create or update service endpoint policy operation.\n        :type service_endpoint_policy_definitions:\n         ~azure.mgmt.network.v2018_10_01.models.ServiceEndpointPolicyDefinition\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ServiceEndpointPolicyDefinition or\n         ClientRawResponse<ServiceEndpointPolicyDefinition> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_10_01.models.ServiceEndpointPolicyDefinition]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_10_01.models.ServiceEndpointPolicyDefinition]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30284:c0:m5"}
{"signature": "def delete(<EOL>self, resource_group_name, route_filter_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_filter_name=route_filter_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified route filter.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30285:c0:m2"}
{"signature": "def list(<EOL>self, resource_group_name, network_watcher_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_watcher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ConnectionMonitorResultPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ConnectionMonitorResultPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all connection monitors for the specified Network Watcher.\n\n        :param resource_group_name: The name of the resource group containing\n         Network Watcher.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the Network Watcher resource.\n        :type network_watcher_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ConnectionMonitorResult\n        :rtype:\n         ~azure.mgmt.network.v2018_10_01.models.ConnectionMonitorResultPaged[~azure.mgmt.network.v2018_10_01.models.ConnectionMonitorResult]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_10_01.models.ErrorResponseException>`", "id": "f30287:c0:m12"}
{"signature": "def get(<EOL>self, resource_group_name, network_watcher_name, connection_monitor_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_watcher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", connection_monitor_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a connection monitor by name.\n\n        :param resource_group_name: The name of the resource group containing\n         Network Watcher.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the Network Watcher resource.\n        :type network_watcher_name: str\n        :param connection_monitor_name: The name of the connection monitor.\n        :type connection_monitor_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ConnectionMonitorResult or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_10_01.models.ConnectionMonitorResult\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_10_01.models.ErrorResponseException>`", "id": "f30287:c0:m3"}
{"signature": "def delete(<EOL>self, resource_group_name, network_watcher_name, connection_monitor_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>connection_monitor_name=connection_monitor_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified connection monitor.\n\n        :param resource_group_name: The name of the resource group containing\n         Network Watcher.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the Network Watcher resource.\n        :type network_watcher_name: str\n        :param connection_monitor_name: The name of the connection monitor.\n        :type connection_monitor_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_10_01.models.ErrorResponseException>`", "id": "f30287:c0:m5"}
{"signature": "def stop(<EOL>self, resource_group_name, network_watcher_name, connection_monitor_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._stop_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>connection_monitor_name=connection_monitor_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Stops the specified connection monitor.\n\n        :param resource_group_name: The name of the resource group containing\n         Network Watcher.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the Network Watcher resource.\n        :type network_watcher_name: str\n        :param connection_monitor_name: The name of the connection monitor.\n        :type connection_monitor_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_10_01.models.ErrorResponseException>`", "id": "f30287:c0:m7"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, local_network_gateway_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>local_network_gateway_name=local_network_gateway_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a local network gateway in the specified resource\n        group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param local_network_gateway_name: The name of the local network\n         gateway.\n        :type local_network_gateway_name: str\n        :param parameters: Parameters supplied to the create or update local\n         network gateway operation.\n        :type parameters:\n         ~azure.mgmt.network.v2018_10_01.models.LocalNetworkGateway\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns LocalNetworkGateway or\n         ClientRawResponse<LocalNetworkGateway> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_10_01.models.LocalNetworkGateway]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_10_01.models.LocalNetworkGateway]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30288:c0:m2"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.LocalNetworkGatewayPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.LocalNetworkGatewayPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the local network gateways in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of LocalNetworkGateway\n        :rtype:\n         ~azure.mgmt.network.v2018_10_01.models.LocalNetworkGatewayPaged[~azure.mgmt.network.v2018_10_01.models.LocalNetworkGateway]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30288:c0:m8"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualNetworkTapPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualNetworkTapPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the VirtualNetworkTaps in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualNetworkTap\n        :rtype:\n         ~azure.mgmt.network.v2018_10_01.models.VirtualNetworkTapPaged[~azure.mgmt.network.v2018_10_01.models.VirtualNetworkTap]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30290:c0:m8"}
{"signature": "def list(<EOL>self, resource_group_name, network_security_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_security_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SecurityRulePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SecurityRulePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all default security rules in a network security group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of SecurityRule\n        :rtype:\n         ~azure.mgmt.network.v2018_10_01.models.SecurityRulePaged[~azure.mgmt.network.v2018_10_01.models.SecurityRule]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30291:c0:m1"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VpnGatewayPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VpnGatewayPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all the VpnGateways in a resource group.\n\n        :param resource_group_name: The resource group name of the VpnGateway.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VpnGateway\n        :rtype:\n         ~azure.mgmt.network.v2018_10_01.models.VpnGatewayPaged[~azure.mgmt.network.v2018_10_01.models.VpnGateway]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_10_01.models.ErrorException>`", "id": "f30292:c0:m8"}
{"signature": "def update_tags(<EOL>self, resource_group_name, route_table_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_table_name=route_table_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a route table tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns RouteTable or\n         ClientRawResponse<RouteTable> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_10_01.models.RouteTable]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_10_01.models.RouteTable]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30293:c0:m7"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RouteTablePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RouteTablePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all route tables in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of RouteTable\n        :rtype:\n         ~azure.mgmt.network.v2018_10_01.models.RouteTablePaged[~azure.mgmt.network.v2018_10_01.models.RouteTable]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30293:c0:m9"}
{"signature": "def list(<EOL>self, resource_group_name, circuit_name, peering_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", peering_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ExpressRouteCircuitConnectionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ExpressRouteCircuitConnectionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all global reach connections associated with a private peering in\n        an express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ExpressRouteCircuitConnection\n        :rtype:\n         ~azure.mgmt.network.v2018_10_01.models.ExpressRouteCircuitConnectionPaged[~azure.mgmt.network.v2018_10_01.models.ExpressRouteCircuitConnection]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30296:c0:m6"}
{"signature": "def list_usage(<EOL>self, resource_group_name, virtual_network_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_usage.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualNetworkUsagePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualNetworkUsagePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists usage stats.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualNetworkUsage\n        :rtype:\n         ~azure.mgmt.network.v2018_10_01.models.VirtualNetworkUsagePaged[~azure.mgmt.network.v2018_10_01.models.VirtualNetworkUsage]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30298:c0:m11"}
{"signature": "def update_tags(<EOL>self, resource_group_name, virtual_network_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_name=virtual_network_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a virtual network tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualNetwork or\n         ClientRawResponse<VirtualNetwork> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_10_01.models.VirtualNetwork]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_10_01.models.VirtualNetwork]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30298:c0:m7"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, load_balancer_name, inbound_nat_rule_name, inbound_nat_rule_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>load_balancer_name=load_balancer_name,<EOL>inbound_nat_rule_name=inbound_nat_rule_name,<EOL>inbound_nat_rule_parameters=inbound_nat_rule_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a load balancer inbound nat rule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param inbound_nat_rule_name: The name of the inbound nat rule.\n        :type inbound_nat_rule_name: str\n        :param inbound_nat_rule_parameters: Parameters supplied to the create\n         or update inbound nat rule operation.\n        :type inbound_nat_rule_parameters:\n         ~azure.mgmt.network.v2018_10_01.models.InboundNatRule\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns InboundNatRule or\n         ClientRawResponse<InboundNatRule> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_10_01.models.InboundNatRule]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_10_01.models.InboundNatRule]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30299:c0:m6"}
{"signature": "def delete(<EOL>self, resource_group_name, load_balancer_name, inbound_nat_rule_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>load_balancer_name=load_balancer_name,<EOL>inbound_nat_rule_name=inbound_nat_rule_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified load balancer inbound nat rule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param inbound_nat_rule_name: The name of the inbound nat rule.\n        :type inbound_nat_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30299:c0:m3"}
{"signature": "def get(<EOL>self, resource_group_name, circuit_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about the specified express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of express route circuit.\n        :type circuit_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteCircuit or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_10_01.models.ExpressRouteCircuit or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30300:c0:m3"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ExpressRouteCircuitPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ExpressRouteCircuitPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the express route circuits in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ExpressRouteCircuit\n        :rtype:\n         ~azure.mgmt.network.v2018_10_01.models.ExpressRouteCircuitPaged[~azure.mgmt.network.v2018_10_01.models.ExpressRouteCircuit]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30300:c0:m17"}
{"signature": "def delete(<EOL>self, resource_group_name, circuit_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30300:c0:m2"}
{"signature": "def list_routes_table_summary(<EOL>self, resource_group_name, circuit_name, peering_name, device_path, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._list_routes_table_summary_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>peering_name=peering_name,<EOL>device_path=device_path,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the currently advertised routes table summary associated with the\n        express route circuit in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param device_path: The path of the device.\n        :type device_path: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCircuitsRoutesTableSummaryListResult or\n         ClientRawResponse<ExpressRouteCircuitsRoutesTableSummaryListResult> if\n         raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_10_01.models.ExpressRouteCircuitsRoutesTableSummaryListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_10_01.models.ExpressRouteCircuitsRoutesTableSummaryListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30300:c0:m13"}
{"signature": "def update_tags(<EOL>self, resource_group_name, public_ip_prefix_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>public_ip_prefix_name=public_ip_prefix_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates public IP prefix tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param public_ip_prefix_name: The name of the public IP prefix.\n        :type public_ip_prefix_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns PublicIPPrefix or\n         ClientRawResponse<PublicIPPrefix> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_10_01.models.PublicIPPrefix]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_10_01.models.PublicIPPrefix]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30301:c0:m7"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, circuit_name, authorization_name, authorization_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>authorization_name=authorization_name,<EOL>authorization_parameters=authorization_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates an authorization in the specified express route\n        circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param authorization_name: The name of the authorization.\n        :type authorization_name: str\n        :param authorization_parameters: Parameters supplied to the create or\n         update express route circuit authorization operation.\n        :type authorization_parameters:\n         ~azure.mgmt.network.v2018_10_01.models.ExpressRouteCircuitAuthorization\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCircuitAuthorization or\n         ClientRawResponse<ExpressRouteCircuitAuthorization> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_10_01.models.ExpressRouteCircuitAuthorization]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_10_01.models.ExpressRouteCircuitAuthorization]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30303:c0:m5"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualHubPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualHubPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all the VirtualHubs in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualHub\n        :rtype:\n         ~azure.mgmt.network.v2018_10_01.models.VirtualHubPaged[~azure.mgmt.network.v2018_10_01.models.VirtualHub]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_10_01.models.ErrorException>`", "id": "f30305:c0:m9"}
{"signature": "def update_tags(<EOL>self, resource_group_name, virtual_hub_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_hub_name=virtual_hub_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates VirtualHub tags.\n\n        :param resource_group_name: The resource group name of the VirtualHub.\n        :type resource_group_name: str\n        :param virtual_hub_name: The name of the VirtualHub.\n        :type virtual_hub_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualHub or\n         ClientRawResponse<VirtualHub> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_10_01.models.VirtualHub]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_10_01.models.VirtualHub]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_10_01.models.ErrorException>`", "id": "f30305:c0:m5"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, virtual_hub_name, virtual_hub_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_hub_name=virtual_hub_name,<EOL>virtual_hub_parameters=virtual_hub_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates a VirtualHub resource if it doesn't exist else updates the\n        existing VirtualHub.\n\n        :param resource_group_name: The resource group name of the VirtualHub.\n        :type resource_group_name: str\n        :param virtual_hub_name: The name of the VirtualHub.\n        :type virtual_hub_name: str\n        :param virtual_hub_parameters: Parameters supplied to create or update\n         VirtualHub.\n        :type virtual_hub_parameters:\n         ~azure.mgmt.network.v2018_10_01.models.VirtualHub\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualHub or\n         ClientRawResponse<VirtualHub> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_10_01.models.VirtualHub]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_10_01.models.VirtualHub]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_10_01.models.ErrorException>`", "id": "f30305:c0:m3"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, virtual_network_name, subnet_name, subnet_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_name=virtual_network_name,<EOL>subnet_name=subnet_name,<EOL>subnet_parameters=subnet_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a subnet in the specified virtual network.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param subnet_name: The name of the subnet.\n        :type subnet_name: str\n        :param subnet_parameters: Parameters supplied to the create or update\n         subnet operation.\n        :type subnet_parameters: ~azure.mgmt.network.v2018_10_01.models.Subnet\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Subnet or\n         ClientRawResponse<Subnet> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_10_01.models.Subnet]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_10_01.models.Subnet]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30308:c0:m5"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PublicIPAddressPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PublicIPAddressPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the public IP addresses in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PublicIPAddress\n        :rtype:\n         ~azure.mgmt.network.v2018_10_01.models.PublicIPAddressPaged[~azure.mgmt.network.v2018_10_01.models.PublicIPAddress]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30310:c0:m8"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PublicIPAddressPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PublicIPAddressPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all public IP addresses in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PublicIPAddress\n        :rtype:\n         ~azure.mgmt.network.v2018_10_01.models.PublicIPAddressPaged[~azure.mgmt.network.v2018_10_01.models.PublicIPAddress]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30310:c0:m9"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, cross_connection_name, peering_name, peering_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>cross_connection_name=cross_connection_name,<EOL>peering_name=peering_name,<EOL>peering_parameters=peering_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a peering in the specified\n        ExpressRouteCrossConnection.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param cross_connection_name: The name of the\n         ExpressRouteCrossConnection.\n        :type cross_connection_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param peering_parameters: Parameters supplied to the create or update\n         ExpressRouteCrossConnection peering operation.\n        :type peering_parameters:\n         ~azure.mgmt.network.v2018_10_01.models.ExpressRouteCrossConnectionPeering\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCrossConnectionPeering or\n         ClientRawResponse<ExpressRouteCrossConnectionPeering> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_10_01.models.ExpressRouteCrossConnectionPeering]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_10_01.models.ExpressRouteCrossConnectionPeering]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30311:c0:m6"}
{"signature": "def delete(<EOL>self, resource_group_name, express_route_gateway_name, connection_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>express_route_gateway_name=express_route_gateway_name,<EOL>connection_name=connection_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes a connection to a ExpressRoute circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param express_route_gateway_name: The name of the ExpressRoute\n         gateway.\n        :type express_route_gateway_name: str\n        :param connection_name: The name of the connection subresource.\n        :type connection_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30314:c0:m5"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, express_route_gateway_name, connection_name, put_express_route_connection_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>express_route_gateway_name=express_route_gateway_name,<EOL>connection_name=connection_name,<EOL>put_express_route_connection_parameters=put_express_route_connection_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates a connection between an ExpressRoute gateway and an\n        ExpressRoute circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param express_route_gateway_name: The name of the ExpressRoute\n         gateway.\n        :type express_route_gateway_name: str\n        :param connection_name: The name of the connection subresource.\n        :type connection_name: str\n        :param put_express_route_connection_parameters: Parameters required in\n         an ExpressRouteConnection PUT operation.\n        :type put_express_route_connection_parameters:\n         ~azure.mgmt.network.v2018_10_01.models.ExpressRouteConnection\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ExpressRouteConnection\n         or ClientRawResponse<ExpressRouteConnection> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_10_01.models.ExpressRouteConnection]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_10_01.models.ExpressRouteConnection]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30314:c0:m2"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkWatcherPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkWatcherPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all network watchers by resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkWatcher\n        :rtype:\n         ~azure.mgmt.network.v2018_10_01.models.NetworkWatcherPaged[~azure.mgmt.network.v2018_10_01.models.NetworkWatcher]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_10_01.models.ErrorResponseException>`", "id": "f30316:c0:m6"}
{"signature": "def get_next_hop(<EOL>self, resource_group_name, network_watcher_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_next_hop_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the next hop from the specified VM.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param parameters: Parameters that define the source and destination\n         endpoint.\n        :type parameters:\n         ~azure.mgmt.network.v2018_10_01.models.NextHopParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns NextHopResult or\n         ClientRawResponse<NextHopResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_10_01.models.NextHopResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_10_01.models.NextHopResult]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_10_01.models.ErrorResponseException>`", "id": "f30316:c0:m12"}
{"signature": "def list_available_providers(<EOL>self, resource_group_name, network_watcher_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._list_available_providers_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Lists all available internet service providers for a specified Azure\n        region.\n\n        :param resource_group_name: The name of the network watcher resource\n         group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher resource.\n        :type network_watcher_name: str\n        :param parameters: Parameters that scope the list of available\n         providers.\n        :type parameters:\n         ~azure.mgmt.network.v2018_10_01.models.AvailableProvidersListParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns AvailableProvidersList\n         or ClientRawResponse<AvailableProvidersList> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_10_01.models.AvailableProvidersList]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_10_01.models.AvailableProvidersList]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_10_01.models.ErrorResponseException>`", "id": "f30316:c0:m28"}
{"signature": "def verify_ip_flow(<EOL>self, resource_group_name, network_watcher_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._verify_ip_flow_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Verify IP flow from the specified VM to a location given the currently\n        configured NSG rules.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param parameters: Parameters that define the IP flow to be verified.\n        :type parameters:\n         ~azure.mgmt.network.v2018_10_01.models.VerificationIPFlowParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         VerificationIPFlowResult or\n         ClientRawResponse<VerificationIPFlowResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_10_01.models.VerificationIPFlowResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_10_01.models.VerificationIPFlowResult]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_10_01.models.ErrorResponseException>`", "id": "f30316:c0:m10"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkWatcherPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkWatcherPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all network watchers by subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkWatcher\n        :rtype:\n         ~azure.mgmt.network.v2018_10_01.models.NetworkWatcherPaged[~azure.mgmt.network.v2018_10_01.models.NetworkWatcher]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_10_01.models.ErrorResponseException>`", "id": "f30316:c0:m7"}
{"signature": "def get_vm_security_rules(<EOL>self, resource_group_name, network_watcher_name, target_resource_id, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_vm_security_rules_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>target_resource_id=target_resource_id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the configured and effective security group rules on the specified\n        VM.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param target_resource_id: ID of the target VM.\n        :type target_resource_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns SecurityGroupViewResult\n         or ClientRawResponse<SecurityGroupViewResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_10_01.models.SecurityGroupViewResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_10_01.models.SecurityGroupViewResult]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_10_01.models.ErrorResponseException>`", "id": "f30316:c0:m14"}
{"signature": "def delete(<EOL>self, resource_group_name, vpn_site_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>vpn_site_name=vpn_site_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes a VpnSite.\n\n        :param resource_group_name: The resource group name of the VpnSite.\n        :type resource_group_name: str\n        :param vpn_site_name: The name of the VpnSite being deleted.\n        :type vpn_site_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_10_01.models.ErrorException>`", "id": "f30317:c0:m7"}
{"signature": "def update_tags(<EOL>self, resource_group_name, vpn_site_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>vpn_site_name=vpn_site_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates VpnSite tags.\n\n        :param resource_group_name: The resource group name of the VpnSite.\n        :type resource_group_name: str\n        :param vpn_site_name: The name of the VpnSite being updated.\n        :type vpn_site_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VpnSite or\n         ClientRawResponse<VpnSite> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_10_01.models.VpnSite]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_10_01.models.VpnSite]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_10_01.models.ErrorException>`", "id": "f30317:c0:m5"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ServiceEndpointPolicyPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ServiceEndpointPolicyPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all service endpoint Policies in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ServiceEndpointPolicy\n        :rtype:\n         ~azure.mgmt.network.v2018_10_01.models.ServiceEndpointPolicyPaged[~azure.mgmt.network.v2018_10_01.models.ServiceEndpointPolicy]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30319:c0:m9"}
{"signature": "def delete(<EOL>self, resource_group_name, service_endpoint_policy_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>service_endpoint_policy_name=service_endpoint_policy_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified service endpoint policy.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param service_endpoint_policy_name: The name of the service endpoint\n         policy.\n        :type service_endpoint_policy_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30319:c0:m2"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualWANPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualWANPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all the VirtualWANs in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualWAN\n        :rtype:\n         ~azure.mgmt.network.v2018_10_01.models.VirtualWANPaged[~azure.mgmt.network.v2018_10_01.models.VirtualWAN]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_10_01.models.ErrorException>`", "id": "f30320:c0:m9"}
{"signature": "def delete(<EOL>self, resource_group_name, virtual_wan_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_wan_name=virtual_wan_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes a VirtualWAN.\n\n        :param resource_group_name: The resource group name of the VirtualWan.\n        :type resource_group_name: str\n        :param virtual_wan_name: The name of the VirtualWAN being deleted.\n        :type virtual_wan_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_10_01.models.ErrorException>`", "id": "f30320:c0:m7"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, circuit_name, peering_name, peering_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>peering_name=peering_name,<EOL>peering_parameters=peering_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a peering in the specified express route circuits.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param peering_parameters: Parameters supplied to the create or update\n         express route circuit peering operation.\n        :type peering_parameters:\n         ~azure.mgmt.network.v2018_10_01.models.ExpressRouteCircuitPeering\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCircuitPeering or\n         ClientRawResponse<ExpressRouteCircuitPeering> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_10_01.models.ExpressRouteCircuitPeering]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_10_01.models.ExpressRouteCircuitPeering]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30321:c0:m5"}
{"signature": "def list(<EOL>self, resource_group_name, circuit_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ExpressRouteCircuitPeeringPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ExpressRouteCircuitPeeringPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all peerings in a specified express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ExpressRouteCircuitPeering\n        :rtype:\n         ~azure.mgmt.network.v2018_10_01.models.ExpressRouteCircuitPeeringPaged[~azure.mgmt.network.v2018_10_01.models.ExpressRouteCircuitPeering]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30321:c0:m6"}
{"signature": "def get(<EOL>self, resource_group_name, circuit_name, peering_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", peering_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified peering for the express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteCircuitPeering or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_10_01.models.ExpressRouteCircuitPeering or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30321:c0:m3"}
{"signature": "def get(<EOL>self, resource_group_name, virtual_wan_name, p2_svpn_server_configuration_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_wan_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", p2_svpn_server_configuration_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves the details of a P2SVpnServerConfiguration.\n\n        :param resource_group_name: The resource group name of the\n         P2SVpnServerConfiguration.\n        :type resource_group_name: str\n        :param virtual_wan_name: The name of the VirtualWan.\n        :type virtual_wan_name: str\n        :param p2_svpn_server_configuration_name: The name of the\n         P2SVpnServerConfiguration.\n        :type p2_svpn_server_configuration_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: P2SVpnServerConfiguration or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_10_01.models.P2SVpnServerConfiguration or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_10_01.models.ErrorException>`", "id": "f30322:c0:m1"}
{"signature": "def list(<EOL>self, resource_group_name, virtual_hub_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_hub_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.HubVirtualNetworkConnectionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.HubVirtualNetworkConnectionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves the details of all HubVirtualNetworkConnections.\n\n        :param resource_group_name: The resource group name of the VirtualHub.\n        :type resource_group_name: str\n        :param virtual_hub_name: The name of the VirtualHub.\n        :type virtual_hub_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of HubVirtualNetworkConnection\n        :rtype:\n         ~azure.mgmt.network.v2018_10_01.models.HubVirtualNetworkConnectionPaged[~azure.mgmt.network.v2018_10_01.models.HubVirtualNetworkConnection]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_10_01.models.ErrorException>`", "id": "f30325:c0:m2"}
{"signature": "def reset(<EOL>self, resource_group_name, virtual_network_gateway_name, gateway_vip=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._reset_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_name=virtual_network_gateway_name,<EOL>gateway_vip=gateway_vip,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Resets the primary of the virtual network gateway in the specified\n        resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param gateway_vip: Virtual network gateway vip address supplied to\n         the begin reset of the active-active feature enabled gateway.\n        :type gateway_vip: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualNetworkGateway\n         or ClientRawResponse<VirtualNetworkGateway> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_10_01.models.VirtualNetworkGateway]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_10_01.models.VirtualNetworkGateway]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30327:c0:m11"}
{"signature": "def set_vpnclient_ipsec_parameters(<EOL>self, resource_group_name, virtual_network_gateway_name, vpnclient_ipsec_params, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._set_vpnclient_ipsec_parameters_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_name=virtual_network_gateway_name,<EOL>vpnclient_ipsec_params=vpnclient_ipsec_params,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The Set VpnclientIpsecParameters operation sets the vpnclient ipsec\n        policy for P2S client of virtual network gateway in the specified\n        resource group through Network resource provider.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param vpnclient_ipsec_params: Parameters supplied to the Begin Set\n         vpnclient ipsec parameters of Virtual Network Gateway P2S client\n         operation through Network resource provider.\n        :type vpnclient_ipsec_params:\n         ~azure.mgmt.network.v2018_10_01.models.VpnClientIPsecParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         VpnClientIPsecParameters or\n         ClientRawResponse<VpnClientIPsecParameters> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_10_01.models.VpnClientIPsecParameters]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_10_01.models.VpnClientIPsecParameters]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30327:c0:m27"}
{"signature": "def get(<EOL>self, resource_group_name, load_balancer_name, load_balancing_rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancing_rule_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified load balancer load balancing rule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param load_balancing_rule_name: The name of the load balancing rule.\n        :type load_balancing_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: LoadBalancingRule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_10_01.models.LoadBalancingRule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30328:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, route_filter_name, rule_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_filter_name=route_filter_name,<EOL>rule_name=rule_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified rule from a route filter.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param rule_name: The name of the rule.\n        :type rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30329:c0:m2"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all network interfaces in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkInterface\n        :rtype:\n         ~azure.mgmt.network.v2018_10_01.models.NetworkInterfacePaged[~azure.mgmt.network.v2018_10_01.models.NetworkInterface]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30331:c0:m8"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all network interfaces in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkInterface\n        :rtype:\n         ~azure.mgmt.network.v2018_10_01.models.NetworkInterfacePaged[~azure.mgmt.network.v2018_10_01.models.NetworkInterface]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30331:c0:m9"}
{"signature": "def list_effective_network_security_groups(<EOL>self, resource_group_name, network_interface_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._list_effective_network_security_groups_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_interface_name=network_interface_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets all network security groups applied to a network interface.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         EffectiveNetworkSecurityGroupListResult or\n         ClientRawResponse<EffectiveNetworkSecurityGroupListResult> if\n         raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_10_01.models.EffectiveNetworkSecurityGroupListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_10_01.models.EffectiveNetworkSecurityGroupListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30331:c0:m13"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, network_interface_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_interface_name=network_interface_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a network interface.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param parameters: Parameters supplied to the create or update network\n         interface operation.\n        :type parameters:\n         ~azure.mgmt.network.v2018_10_01.models.NetworkInterface\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns NetworkInterface or\n         ClientRawResponse<NetworkInterface> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_10_01.models.NetworkInterface]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_10_01.models.NetworkInterface]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30331:c0:m5"}
{"signature": "def list_virtual_machine_scale_set_vm_network_interfaces(<EOL>self, resource_group_name, virtual_machine_scale_set_name, virtualmachine_index, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_virtual_machine_scale_set_vm_network_interfaces.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_machine_scale_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtualmachine_index, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about all network interfaces in a virtual machine in a\n        virtual machine scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_machine_scale_set_name: The name of the virtual machine\n         scale set.\n        :type virtual_machine_scale_set_name: str\n        :param virtualmachine_index: The virtual machine index.\n        :type virtualmachine_index: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkInterface\n        :rtype:\n         ~azure.mgmt.network.v2018_10_01.models.NetworkInterfacePaged[~azure.mgmt.network.v2018_10_01.models.NetworkInterface]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30331:c0:m14"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, network_security_group_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_security_group_name=network_security_group_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a network security group in the specified resource\n        group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param parameters: Parameters supplied to the create or update network\n         security group operation.\n        :type parameters:\n         ~azure.mgmt.network.v2018_10_01.models.NetworkSecurityGroup\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns NetworkSecurityGroup or\n         ClientRawResponse<NetworkSecurityGroup> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_10_01.models.NetworkSecurityGroup]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_10_01.models.NetworkSecurityGroup]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30332:c0:m5"}
{"signature": "def get(<EOL>self, resource_group_name, network_security_group_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_security_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified network security group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: NetworkSecurityGroup or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_10_01.models.NetworkSecurityGroup or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30332:c0:m3"}
{"signature": "@property<EOL><INDENT>def express_route_circuit_connections(self):<DEDENT>", "body": "api_version = self._get_api_version('<STR_LIT>')<EOL>if api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_02_01.operations import ExpressRouteCircuitConnectionsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_04_01.operations import ExpressRouteCircuitConnectionsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_06_01.operations import ExpressRouteCircuitConnectionsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_07_01.operations import ExpressRouteCircuitConnectionsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_08_01.operations import ExpressRouteCircuitConnectionsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_10_01.operations import ExpressRouteCircuitConnectionsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_11_01.operations import ExpressRouteCircuitConnectionsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_12_01.operations import ExpressRouteCircuitConnectionsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2019_02_01.operations import ExpressRouteCircuitConnectionsOperations as OperationClass<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\".format(api_version))<EOL><DEDENT>return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))<EOL>", "docstring": "Instance depends on the API version:\n\n           * 2018-02-01: :class:`ExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2018_02_01.operations.ExpressRouteCircuitConnectionsOperations>`\n           * 2018-04-01: :class:`ExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2018_04_01.operations.ExpressRouteCircuitConnectionsOperations>`\n           * 2018-06-01: :class:`ExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2018_06_01.operations.ExpressRouteCircuitConnectionsOperations>`\n           * 2018-07-01: :class:`ExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2018_07_01.operations.ExpressRouteCircuitConnectionsOperations>`\n           * 2018-08-01: :class:`ExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2018_08_01.operations.ExpressRouteCircuitConnectionsOperations>`\n           * 2018-10-01: :class:`ExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2018_10_01.operations.ExpressRouteCircuitConnectionsOperations>`\n           * 2018-11-01: :class:`ExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2018_11_01.operations.ExpressRouteCircuitConnectionsOperations>`\n           * 2018-12-01: :class:`ExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2018_12_01.operations.ExpressRouteCircuitConnectionsOperations>`\n           * 2019-02-01: :class:`ExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2019_02_01.operations.ExpressRouteCircuitConnectionsOperations>`", "id": "f30333:c1:m17"}
{"signature": "@property<EOL><INDENT>def ddos_custom_policies(self):<DEDENT>", "body": "api_version = self._get_api_version('<STR_LIT>')<EOL>if api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_11_01.operations import DdosCustomPoliciesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_12_01.operations import DdosCustomPoliciesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2019_02_01.operations import DdosCustomPoliciesOperations as OperationClass<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\".format(api_version))<EOL><DEDENT>return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))<EOL>", "docstring": "Instance depends on the API version:\n\n           * 2018-11-01: :class:`DdosCustomPoliciesOperations<azure.mgmt.network.v2018_11_01.operations.DdosCustomPoliciesOperations>`\n           * 2018-12-01: :class:`DdosCustomPoliciesOperations<azure.mgmt.network.v2018_12_01.operations.DdosCustomPoliciesOperations>`\n           * 2019-02-01: :class:`DdosCustomPoliciesOperations<azure.mgmt.network.v2019_02_01.operations.DdosCustomPoliciesOperations>`", "id": "f30333:c1:m13"}
{"signature": "@property<EOL><INDENT>def local_network_gateways(self):<DEDENT>", "body": "api_version = self._get_api_version('<STR_LIT>')<EOL>if api_version == '<STR_LIT>':<EOL><INDENT>from .v2015_06_15.operations import LocalNetworkGatewaysOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2016_09_01.operations import LocalNetworkGatewaysOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2016_12_01.operations import LocalNetworkGatewaysOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_03_01.operations import LocalNetworkGatewaysOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_06_01.operations import LocalNetworkGatewaysOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_08_01.operations import LocalNetworkGatewaysOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_09_01.operations import LocalNetworkGatewaysOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_10_01.operations import LocalNetworkGatewaysOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_11_01.operations import LocalNetworkGatewaysOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_01_01.operations import LocalNetworkGatewaysOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_02_01.operations import LocalNetworkGatewaysOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_04_01.operations import LocalNetworkGatewaysOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_06_01.operations import LocalNetworkGatewaysOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_07_01.operations import LocalNetworkGatewaysOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_08_01.operations import LocalNetworkGatewaysOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_10_01.operations import LocalNetworkGatewaysOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_11_01.operations import LocalNetworkGatewaysOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_12_01.operations import LocalNetworkGatewaysOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2019_02_01.operations import LocalNetworkGatewaysOperations as OperationClass<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\".format(api_version))<EOL><DEDENT>return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))<EOL>", "docstring": "Instance depends on the API version:\n\n           * 2015-06-15: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2015_06_15.operations.LocalNetworkGatewaysOperations>`\n           * 2016-09-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2016_09_01.operations.LocalNetworkGatewaysOperations>`\n           * 2016-12-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2016_12_01.operations.LocalNetworkGatewaysOperations>`\n           * 2017-03-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2017_03_01.operations.LocalNetworkGatewaysOperations>`\n           * 2017-06-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2017_06_01.operations.LocalNetworkGatewaysOperations>`\n           * 2017-08-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2017_08_01.operations.LocalNetworkGatewaysOperations>`\n           * 2017-09-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2017_09_01.operations.LocalNetworkGatewaysOperations>`\n           * 2017-10-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2017_10_01.operations.LocalNetworkGatewaysOperations>`\n           * 2017-11-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2017_11_01.operations.LocalNetworkGatewaysOperations>`\n           * 2018-01-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2018_01_01.operations.LocalNetworkGatewaysOperations>`\n           * 2018-02-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2018_02_01.operations.LocalNetworkGatewaysOperations>`\n           * 2018-04-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2018_04_01.operations.LocalNetworkGatewaysOperations>`\n           * 2018-06-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2018_06_01.operations.LocalNetworkGatewaysOperations>`\n           * 2018-07-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2018_07_01.operations.LocalNetworkGatewaysOperations>`\n           * 2018-08-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2018_08_01.operations.LocalNetworkGatewaysOperations>`\n           * 2018-10-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2018_10_01.operations.LocalNetworkGatewaysOperations>`\n           * 2018-11-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2018_11_01.operations.LocalNetworkGatewaysOperations>`\n           * 2018-12-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2018_12_01.operations.LocalNetworkGatewaysOperations>`\n           * 2019-02-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2019_02_01.operations.LocalNetworkGatewaysOperations>`", "id": "f30333:c1:m38"}
{"signature": "@property<EOL><INDENT>def network_interface_load_balancers(self):<DEDENT>", "body": "api_version = self._get_api_version('<STR_LIT>')<EOL>if api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_06_01.operations import NetworkInterfaceLoadBalancersOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_08_01.operations import NetworkInterfaceLoadBalancersOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_09_01.operations import NetworkInterfaceLoadBalancersOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_10_01.operations import NetworkInterfaceLoadBalancersOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_11_01.operations import NetworkInterfaceLoadBalancersOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_01_01.operations import NetworkInterfaceLoadBalancersOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_02_01.operations import NetworkInterfaceLoadBalancersOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_04_01.operations import NetworkInterfaceLoadBalancersOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_06_01.operations import NetworkInterfaceLoadBalancersOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_07_01.operations import NetworkInterfaceLoadBalancersOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_08_01.operations import NetworkInterfaceLoadBalancersOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_10_01.operations import NetworkInterfaceLoadBalancersOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_11_01.operations import NetworkInterfaceLoadBalancersOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_12_01.operations import NetworkInterfaceLoadBalancersOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2019_02_01.operations import NetworkInterfaceLoadBalancersOperations as OperationClass<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\".format(api_version))<EOL><DEDENT>return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))<EOL>", "docstring": "Instance depends on the API version:\n\n           * 2017-06-01: :class:`NetworkInterfaceLoadBalancersOperations<azure.mgmt.network.v2017_06_01.operations.NetworkInterfaceLoadBalancersOperations>`\n           * 2017-08-01: :class:`NetworkInterfaceLoadBalancersOperations<azure.mgmt.network.v2017_08_01.operations.NetworkInterfaceLoadBalancersOperations>`\n           * 2017-09-01: :class:`NetworkInterfaceLoadBalancersOperations<azure.mgmt.network.v2017_09_01.operations.NetworkInterfaceLoadBalancersOperations>`\n           * 2017-10-01: :class:`NetworkInterfaceLoadBalancersOperations<azure.mgmt.network.v2017_10_01.operations.NetworkInterfaceLoadBalancersOperations>`\n           * 2017-11-01: :class:`NetworkInterfaceLoadBalancersOperations<azure.mgmt.network.v2017_11_01.operations.NetworkInterfaceLoadBalancersOperations>`\n           * 2018-01-01: :class:`NetworkInterfaceLoadBalancersOperations<azure.mgmt.network.v2018_01_01.operations.NetworkInterfaceLoadBalancersOperations>`\n           * 2018-02-01: :class:`NetworkInterfaceLoadBalancersOperations<azure.mgmt.network.v2018_02_01.operations.NetworkInterfaceLoadBalancersOperations>`\n           * 2018-04-01: :class:`NetworkInterfaceLoadBalancersOperations<azure.mgmt.network.v2018_04_01.operations.NetworkInterfaceLoadBalancersOperations>`\n           * 2018-06-01: :class:`NetworkInterfaceLoadBalancersOperations<azure.mgmt.network.v2018_06_01.operations.NetworkInterfaceLoadBalancersOperations>`\n           * 2018-07-01: :class:`NetworkInterfaceLoadBalancersOperations<azure.mgmt.network.v2018_07_01.operations.NetworkInterfaceLoadBalancersOperations>`\n           * 2018-08-01: :class:`NetworkInterfaceLoadBalancersOperations<azure.mgmt.network.v2018_08_01.operations.NetworkInterfaceLoadBalancersOperations>`\n           * 2018-10-01: :class:`NetworkInterfaceLoadBalancersOperations<azure.mgmt.network.v2018_10_01.operations.NetworkInterfaceLoadBalancersOperations>`\n           * 2018-11-01: :class:`NetworkInterfaceLoadBalancersOperations<azure.mgmt.network.v2018_11_01.operations.NetworkInterfaceLoadBalancersOperations>`\n           * 2018-12-01: :class:`NetworkInterfaceLoadBalancersOperations<azure.mgmt.network.v2018_12_01.operations.NetworkInterfaceLoadBalancersOperations>`\n           * 2019-02-01: :class:`NetworkInterfaceLoadBalancersOperations<azure.mgmt.network.v2019_02_01.operations.NetworkInterfaceLoadBalancersOperations>`", "id": "f30333:c1:m41"}
{"signature": "@property<EOL><INDENT>def load_balancer_backend_address_pools(self):<DEDENT>", "body": "api_version = self._get_api_version('<STR_LIT>')<EOL>if api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_06_01.operations import LoadBalancerBackendAddressPoolsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_08_01.operations import LoadBalancerBackendAddressPoolsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_09_01.operations import LoadBalancerBackendAddressPoolsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_10_01.operations import LoadBalancerBackendAddressPoolsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_11_01.operations import LoadBalancerBackendAddressPoolsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_01_01.operations import LoadBalancerBackendAddressPoolsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_02_01.operations import LoadBalancerBackendAddressPoolsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_04_01.operations import LoadBalancerBackendAddressPoolsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_06_01.operations import LoadBalancerBackendAddressPoolsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_07_01.operations import LoadBalancerBackendAddressPoolsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_08_01.operations import LoadBalancerBackendAddressPoolsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_10_01.operations import LoadBalancerBackendAddressPoolsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_11_01.operations import LoadBalancerBackendAddressPoolsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_12_01.operations import LoadBalancerBackendAddressPoolsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2019_02_01.operations import LoadBalancerBackendAddressPoolsOperations as OperationClass<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\".format(api_version))<EOL><DEDENT>return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))<EOL>", "docstring": "Instance depends on the API version:\n\n           * 2017-06-01: :class:`LoadBalancerBackendAddressPoolsOperations<azure.mgmt.network.v2017_06_01.operations.LoadBalancerBackendAddressPoolsOperations>`\n           * 2017-08-01: :class:`LoadBalancerBackendAddressPoolsOperations<azure.mgmt.network.v2017_08_01.operations.LoadBalancerBackendAddressPoolsOperations>`\n           * 2017-09-01: :class:`LoadBalancerBackendAddressPoolsOperations<azure.mgmt.network.v2017_09_01.operations.LoadBalancerBackendAddressPoolsOperations>`\n           * 2017-10-01: :class:`LoadBalancerBackendAddressPoolsOperations<azure.mgmt.network.v2017_10_01.operations.LoadBalancerBackendAddressPoolsOperations>`\n           * 2017-11-01: :class:`LoadBalancerBackendAddressPoolsOperations<azure.mgmt.network.v2017_11_01.operations.LoadBalancerBackendAddressPoolsOperations>`\n           * 2018-01-01: :class:`LoadBalancerBackendAddressPoolsOperations<azure.mgmt.network.v2018_01_01.operations.LoadBalancerBackendAddressPoolsOperations>`\n           * 2018-02-01: :class:`LoadBalancerBackendAddressPoolsOperations<azure.mgmt.network.v2018_02_01.operations.LoadBalancerBackendAddressPoolsOperations>`\n           * 2018-04-01: :class:`LoadBalancerBackendAddressPoolsOperations<azure.mgmt.network.v2018_04_01.operations.LoadBalancerBackendAddressPoolsOperations>`\n           * 2018-06-01: :class:`LoadBalancerBackendAddressPoolsOperations<azure.mgmt.network.v2018_06_01.operations.LoadBalancerBackendAddressPoolsOperations>`\n           * 2018-07-01: :class:`LoadBalancerBackendAddressPoolsOperations<azure.mgmt.network.v2018_07_01.operations.LoadBalancerBackendAddressPoolsOperations>`\n           * 2018-08-01: :class:`LoadBalancerBackendAddressPoolsOperations<azure.mgmt.network.v2018_08_01.operations.LoadBalancerBackendAddressPoolsOperations>`\n           * 2018-10-01: :class:`LoadBalancerBackendAddressPoolsOperations<azure.mgmt.network.v2018_10_01.operations.LoadBalancerBackendAddressPoolsOperations>`\n           * 2018-11-01: :class:`LoadBalancerBackendAddressPoolsOperations<azure.mgmt.network.v2018_11_01.operations.LoadBalancerBackendAddressPoolsOperations>`\n           * 2018-12-01: :class:`LoadBalancerBackendAddressPoolsOperations<azure.mgmt.network.v2018_12_01.operations.LoadBalancerBackendAddressPoolsOperations>`\n           * 2019-02-01: :class:`LoadBalancerBackendAddressPoolsOperations<azure.mgmt.network.v2019_02_01.operations.LoadBalancerBackendAddressPoolsOperations>`", "id": "f30333:c1:m31"}
{"signature": "@property<EOL><INDENT>def express_route_links(self):<DEDENT>", "body": "api_version = self._get_api_version('<STR_LIT>')<EOL>if api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_08_01.operations import ExpressRouteLinksOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_10_01.operations import ExpressRouteLinksOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_11_01.operations import ExpressRouteLinksOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_12_01.operations import ExpressRouteLinksOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2019_02_01.operations import ExpressRouteLinksOperations as OperationClass<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\".format(api_version))<EOL><DEDENT>return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))<EOL>", "docstring": "Instance depends on the API version:\n\n           * 2018-08-01: :class:`ExpressRouteLinksOperations<azure.mgmt.network.v2018_08_01.operations.ExpressRouteLinksOperations>`\n           * 2018-10-01: :class:`ExpressRouteLinksOperations<azure.mgmt.network.v2018_10_01.operations.ExpressRouteLinksOperations>`\n           * 2018-11-01: :class:`ExpressRouteLinksOperations<azure.mgmt.network.v2018_11_01.operations.ExpressRouteLinksOperations>`\n           * 2018-12-01: :class:`ExpressRouteLinksOperations<azure.mgmt.network.v2018_12_01.operations.ExpressRouteLinksOperations>`\n           * 2019-02-01: :class:`ExpressRouteLinksOperations<azure.mgmt.network.v2019_02_01.operations.ExpressRouteLinksOperations>`", "id": "f30333:c1:m24"}
{"signature": "@property<EOL><INDENT>def virtual_network_peerings(self):<DEDENT>", "body": "api_version = self._get_api_version('<STR_LIT>')<EOL>if api_version == '<STR_LIT>':<EOL><INDENT>from .v2016_09_01.operations import VirtualNetworkPeeringsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2016_12_01.operations import VirtualNetworkPeeringsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_03_01.operations import VirtualNetworkPeeringsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_06_01.operations import VirtualNetworkPeeringsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_08_01.operations import VirtualNetworkPeeringsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_09_01.operations import VirtualNetworkPeeringsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_10_01.operations import VirtualNetworkPeeringsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_11_01.operations import VirtualNetworkPeeringsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_01_01.operations import VirtualNetworkPeeringsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_02_01.operations import VirtualNetworkPeeringsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_04_01.operations import VirtualNetworkPeeringsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_06_01.operations import VirtualNetworkPeeringsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_07_01.operations import VirtualNetworkPeeringsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_08_01.operations import VirtualNetworkPeeringsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_10_01.operations import VirtualNetworkPeeringsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_11_01.operations import VirtualNetworkPeeringsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_12_01.operations import VirtualNetworkPeeringsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2019_02_01.operations import VirtualNetworkPeeringsOperations as OperationClass<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\".format(api_version))<EOL><DEDENT>return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))<EOL>", "docstring": "Instance depends on the API version:\n\n           * 2016-09-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2016_09_01.operations.VirtualNetworkPeeringsOperations>`\n           * 2016-12-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2016_12_01.operations.VirtualNetworkPeeringsOperations>`\n           * 2017-03-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2017_03_01.operations.VirtualNetworkPeeringsOperations>`\n           * 2017-06-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2017_06_01.operations.VirtualNetworkPeeringsOperations>`\n           * 2017-08-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2017_08_01.operations.VirtualNetworkPeeringsOperations>`\n           * 2017-09-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2017_09_01.operations.VirtualNetworkPeeringsOperations>`\n           * 2017-10-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2017_10_01.operations.VirtualNetworkPeeringsOperations>`\n           * 2017-11-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2017_11_01.operations.VirtualNetworkPeeringsOperations>`\n           * 2018-01-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2018_01_01.operations.VirtualNetworkPeeringsOperations>`\n           * 2018-02-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2018_02_01.operations.VirtualNetworkPeeringsOperations>`\n           * 2018-04-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2018_04_01.operations.VirtualNetworkPeeringsOperations>`\n           * 2018-06-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2018_06_01.operations.VirtualNetworkPeeringsOperations>`\n           * 2018-07-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2018_07_01.operations.VirtualNetworkPeeringsOperations>`\n           * 2018-08-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2018_08_01.operations.VirtualNetworkPeeringsOperations>`\n           * 2018-10-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2018_10_01.operations.VirtualNetworkPeeringsOperations>`\n           * 2018-11-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2018_11_01.operations.VirtualNetworkPeeringsOperations>`\n           * 2018-12-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2018_12_01.operations.VirtualNetworkPeeringsOperations>`\n           * 2019-02-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2019_02_01.operations.VirtualNetworkPeeringsOperations>`", "id": "f30333:c1:m64"}
{"signature": "@property<EOL><INDENT>def vpn_sites_configuration(self):<DEDENT>", "body": "api_version = self._get_api_version('<STR_LIT>')<EOL>if api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_04_01.operations import VpnSitesConfigurationOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_06_01.operations import VpnSitesConfigurationOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_07_01.operations import VpnSitesConfigurationOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_08_01.operations import VpnSitesConfigurationOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_10_01.operations import VpnSitesConfigurationOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_11_01.operations import VpnSitesConfigurationOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_12_01.operations import VpnSitesConfigurationOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2019_02_01.operations import VpnSitesConfigurationOperations as OperationClass<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\".format(api_version))<EOL><DEDENT>return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))<EOL>", "docstring": "Instance depends on the API version:\n\n           * 2018-04-01: :class:`VpnSitesConfigurationOperations<azure.mgmt.network.v2018_04_01.operations.VpnSitesConfigurationOperations>`\n           * 2018-06-01: :class:`VpnSitesConfigurationOperations<azure.mgmt.network.v2018_06_01.operations.VpnSitesConfigurationOperations>`\n           * 2018-07-01: :class:`VpnSitesConfigurationOperations<azure.mgmt.network.v2018_07_01.operations.VpnSitesConfigurationOperations>`\n           * 2018-08-01: :class:`VpnSitesConfigurationOperations<azure.mgmt.network.v2018_08_01.operations.VpnSitesConfigurationOperations>`\n           * 2018-10-01: :class:`VpnSitesConfigurationOperations<azure.mgmt.network.v2018_10_01.operations.VpnSitesConfigurationOperations>`\n           * 2018-11-01: :class:`VpnSitesConfigurationOperations<azure.mgmt.network.v2018_11_01.operations.VpnSitesConfigurationOperations>`\n           * 2018-12-01: :class:`VpnSitesConfigurationOperations<azure.mgmt.network.v2018_12_01.operations.VpnSitesConfigurationOperations>`\n           * 2019-02-01: :class:`VpnSitesConfigurationOperations<azure.mgmt.network.v2019_02_01.operations.VpnSitesConfigurationOperations>`", "id": "f30333:c1:m72"}
{"signature": "@property<EOL><INDENT>def security_rules(self):<DEDENT>", "body": "api_version = self._get_api_version('<STR_LIT>')<EOL>if api_version == '<STR_LIT>':<EOL><INDENT>from .v2015_06_15.operations import SecurityRulesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2016_09_01.operations import SecurityRulesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2016_12_01.operations import SecurityRulesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_03_01.operations import SecurityRulesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_06_01.operations import SecurityRulesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_08_01.operations import SecurityRulesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_09_01.operations import SecurityRulesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_10_01.operations import SecurityRulesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_11_01.operations import SecurityRulesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_01_01.operations import SecurityRulesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_02_01.operations import SecurityRulesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_04_01.operations import SecurityRulesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_06_01.operations import SecurityRulesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_07_01.operations import SecurityRulesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_08_01.operations import SecurityRulesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_10_01.operations import SecurityRulesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_11_01.operations import SecurityRulesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_12_01.operations import SecurityRulesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2019_02_01.operations import SecurityRulesOperations as OperationClass<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\".format(api_version))<EOL><DEDENT>return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))<EOL>", "docstring": "Instance depends on the API version:\n\n           * 2015-06-15: :class:`SecurityRulesOperations<azure.mgmt.network.v2015_06_15.operations.SecurityRulesOperations>`\n           * 2016-09-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2016_09_01.operations.SecurityRulesOperations>`\n           * 2016-12-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2016_12_01.operations.SecurityRulesOperations>`\n           * 2017-03-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2017_03_01.operations.SecurityRulesOperations>`\n           * 2017-06-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2017_06_01.operations.SecurityRulesOperations>`\n           * 2017-08-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2017_08_01.operations.SecurityRulesOperations>`\n           * 2017-09-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2017_09_01.operations.SecurityRulesOperations>`\n           * 2017-10-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2017_10_01.operations.SecurityRulesOperations>`\n           * 2017-11-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2017_11_01.operations.SecurityRulesOperations>`\n           * 2018-01-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2018_01_01.operations.SecurityRulesOperations>`\n           * 2018-02-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2018_02_01.operations.SecurityRulesOperations>`\n           * 2018-04-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2018_04_01.operations.SecurityRulesOperations>`\n           * 2018-06-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2018_06_01.operations.SecurityRulesOperations>`\n           * 2018-07-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2018_07_01.operations.SecurityRulesOperations>`\n           * 2018-08-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2018_08_01.operations.SecurityRulesOperations>`\n           * 2018-10-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2018_10_01.operations.SecurityRulesOperations>`\n           * 2018-11-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2018_11_01.operations.SecurityRulesOperations>`\n           * 2018-12-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2018_12_01.operations.SecurityRulesOperations>`\n           * 2019-02-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2019_02_01.operations.SecurityRulesOperations>`", "id": "f30333:c1:m56"}
{"signature": "@property<EOL><INDENT>def azure_firewalls(self):<DEDENT>", "body": "api_version = self._get_api_version('<STR_LIT>')<EOL>if api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_04_01.operations import AzureFirewallsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_06_01.operations import AzureFirewallsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_07_01.operations import AzureFirewallsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_08_01.operations import AzureFirewallsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_10_01.operations import AzureFirewallsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_11_01.operations import AzureFirewallsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_12_01.operations import AzureFirewallsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2019_02_01.operations import AzureFirewallsOperations as OperationClass<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\".format(api_version))<EOL><DEDENT>return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))<EOL>", "docstring": "Instance depends on the API version:\n\n           * 2018-04-01: :class:`AzureFirewallsOperations<azure.mgmt.network.v2018_04_01.operations.AzureFirewallsOperations>`\n           * 2018-06-01: :class:`AzureFirewallsOperations<azure.mgmt.network.v2018_06_01.operations.AzureFirewallsOperations>`\n           * 2018-07-01: :class:`AzureFirewallsOperations<azure.mgmt.network.v2018_07_01.operations.AzureFirewallsOperations>`\n           * 2018-08-01: :class:`AzureFirewallsOperations<azure.mgmt.network.v2018_08_01.operations.AzureFirewallsOperations>`\n           * 2018-10-01: :class:`AzureFirewallsOperations<azure.mgmt.network.v2018_10_01.operations.AzureFirewallsOperations>`\n           * 2018-11-01: :class:`AzureFirewallsOperations<azure.mgmt.network.v2018_11_01.operations.AzureFirewallsOperations>`\n           * 2018-12-01: :class:`AzureFirewallsOperations<azure.mgmt.network.v2018_12_01.operations.AzureFirewallsOperations>`\n           * 2019-02-01: :class:`AzureFirewallsOperations<azure.mgmt.network.v2019_02_01.operations.AzureFirewallsOperations>`", "id": "f30333:c1:m10"}
{"signature": "@property<EOL><INDENT>def load_balancer_probes(self):<DEDENT>", "body": "api_version = self._get_api_version('<STR_LIT>')<EOL>if api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_06_01.operations import LoadBalancerProbesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_08_01.operations import LoadBalancerProbesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_09_01.operations import LoadBalancerProbesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_10_01.operations import LoadBalancerProbesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_11_01.operations import LoadBalancerProbesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_01_01.operations import LoadBalancerProbesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_02_01.operations import LoadBalancerProbesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_04_01.operations import LoadBalancerProbesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_06_01.operations import LoadBalancerProbesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_07_01.operations import LoadBalancerProbesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_08_01.operations import LoadBalancerProbesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_10_01.operations import LoadBalancerProbesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_11_01.operations import LoadBalancerProbesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_12_01.operations import LoadBalancerProbesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2019_02_01.operations import LoadBalancerProbesOperations as OperationClass<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\".format(api_version))<EOL><DEDENT>return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))<EOL>", "docstring": "Instance depends on the API version:\n\n           * 2017-06-01: :class:`LoadBalancerProbesOperations<azure.mgmt.network.v2017_06_01.operations.LoadBalancerProbesOperations>`\n           * 2017-08-01: :class:`LoadBalancerProbesOperations<azure.mgmt.network.v2017_08_01.operations.LoadBalancerProbesOperations>`\n           * 2017-09-01: :class:`LoadBalancerProbesOperations<azure.mgmt.network.v2017_09_01.operations.LoadBalancerProbesOperations>`\n           * 2017-10-01: :class:`LoadBalancerProbesOperations<azure.mgmt.network.v2017_10_01.operations.LoadBalancerProbesOperations>`\n           * 2017-11-01: :class:`LoadBalancerProbesOperations<azure.mgmt.network.v2017_11_01.operations.LoadBalancerProbesOperations>`\n           * 2018-01-01: :class:`LoadBalancerProbesOperations<azure.mgmt.network.v2018_01_01.operations.LoadBalancerProbesOperations>`\n           * 2018-02-01: :class:`LoadBalancerProbesOperations<azure.mgmt.network.v2018_02_01.operations.LoadBalancerProbesOperations>`\n           * 2018-04-01: :class:`LoadBalancerProbesOperations<azure.mgmt.network.v2018_04_01.operations.LoadBalancerProbesOperations>`\n           * 2018-06-01: :class:`LoadBalancerProbesOperations<azure.mgmt.network.v2018_06_01.operations.LoadBalancerProbesOperations>`\n           * 2018-07-01: :class:`LoadBalancerProbesOperations<azure.mgmt.network.v2018_07_01.operations.LoadBalancerProbesOperations>`\n           * 2018-08-01: :class:`LoadBalancerProbesOperations<azure.mgmt.network.v2018_08_01.operations.LoadBalancerProbesOperations>`\n           * 2018-10-01: :class:`LoadBalancerProbesOperations<azure.mgmt.network.v2018_10_01.operations.LoadBalancerProbesOperations>`\n           * 2018-11-01: :class:`LoadBalancerProbesOperations<azure.mgmt.network.v2018_11_01.operations.LoadBalancerProbesOperations>`\n           * 2018-12-01: :class:`LoadBalancerProbesOperations<azure.mgmt.network.v2018_12_01.operations.LoadBalancerProbesOperations>`\n           * 2019-02-01: :class:`LoadBalancerProbesOperations<azure.mgmt.network.v2019_02_01.operations.LoadBalancerProbesOperations>`", "id": "f30333:c1:m36"}
{"signature": "@property<EOL><INDENT>def network_interface_tap_configurations(self):<DEDENT>", "body": "api_version = self._get_api_version('<STR_LIT>')<EOL>if api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_08_01.operations import NetworkInterfaceTapConfigurationsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_10_01.operations import NetworkInterfaceTapConfigurationsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_11_01.operations import NetworkInterfaceTapConfigurationsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_12_01.operations import NetworkInterfaceTapConfigurationsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2019_02_01.operations import NetworkInterfaceTapConfigurationsOperations as OperationClass<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\".format(api_version))<EOL><DEDENT>return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))<EOL>", "docstring": "Instance depends on the API version:\n\n           * 2018-08-01: :class:`NetworkInterfaceTapConfigurationsOperations<azure.mgmt.network.v2018_08_01.operations.NetworkInterfaceTapConfigurationsOperations>`\n           * 2018-10-01: :class:`NetworkInterfaceTapConfigurationsOperations<azure.mgmt.network.v2018_10_01.operations.NetworkInterfaceTapConfigurationsOperations>`\n           * 2018-11-01: :class:`NetworkInterfaceTapConfigurationsOperations<azure.mgmt.network.v2018_11_01.operations.NetworkInterfaceTapConfigurationsOperations>`\n           * 2018-12-01: :class:`NetworkInterfaceTapConfigurationsOperations<azure.mgmt.network.v2018_12_01.operations.NetworkInterfaceTapConfigurationsOperations>`\n           * 2019-02-01: :class:`NetworkInterfaceTapConfigurationsOperations<azure.mgmt.network.v2019_02_01.operations.NetworkInterfaceTapConfigurationsOperations>`", "id": "f30333:c1:m42"}
{"signature": "@property<EOL><INDENT>def application_security_groups(self):<DEDENT>", "body": "api_version = self._get_api_version('<STR_LIT>')<EOL>if api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_09_01.operations import ApplicationSecurityGroupsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_10_01.operations import ApplicationSecurityGroupsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_11_01.operations import ApplicationSecurityGroupsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_01_01.operations import ApplicationSecurityGroupsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_02_01.operations import ApplicationSecurityGroupsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_04_01.operations import ApplicationSecurityGroupsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_06_01.operations import ApplicationSecurityGroupsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_07_01.operations import ApplicationSecurityGroupsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_08_01.operations import ApplicationSecurityGroupsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_10_01.operations import ApplicationSecurityGroupsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_11_01.operations import ApplicationSecurityGroupsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_12_01.operations import ApplicationSecurityGroupsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2019_02_01.operations import ApplicationSecurityGroupsOperations as OperationClass<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\".format(api_version))<EOL><DEDENT>return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))<EOL>", "docstring": "Instance depends on the API version:\n\n           * 2017-09-01: :class:`ApplicationSecurityGroupsOperations<azure.mgmt.network.v2017_09_01.operations.ApplicationSecurityGroupsOperations>`\n           * 2017-10-01: :class:`ApplicationSecurityGroupsOperations<azure.mgmt.network.v2017_10_01.operations.ApplicationSecurityGroupsOperations>`\n           * 2017-11-01: :class:`ApplicationSecurityGroupsOperations<azure.mgmt.network.v2017_11_01.operations.ApplicationSecurityGroupsOperations>`\n           * 2018-01-01: :class:`ApplicationSecurityGroupsOperations<azure.mgmt.network.v2018_01_01.operations.ApplicationSecurityGroupsOperations>`\n           * 2018-02-01: :class:`ApplicationSecurityGroupsOperations<azure.mgmt.network.v2018_02_01.operations.ApplicationSecurityGroupsOperations>`\n           * 2018-04-01: :class:`ApplicationSecurityGroupsOperations<azure.mgmt.network.v2018_04_01.operations.ApplicationSecurityGroupsOperations>`\n           * 2018-06-01: :class:`ApplicationSecurityGroupsOperations<azure.mgmt.network.v2018_06_01.operations.ApplicationSecurityGroupsOperations>`\n           * 2018-07-01: :class:`ApplicationSecurityGroupsOperations<azure.mgmt.network.v2018_07_01.operations.ApplicationSecurityGroupsOperations>`\n           * 2018-08-01: :class:`ApplicationSecurityGroupsOperations<azure.mgmt.network.v2018_08_01.operations.ApplicationSecurityGroupsOperations>`\n           * 2018-10-01: :class:`ApplicationSecurityGroupsOperations<azure.mgmt.network.v2018_10_01.operations.ApplicationSecurityGroupsOperations>`\n           * 2018-11-01: :class:`ApplicationSecurityGroupsOperations<azure.mgmt.network.v2018_11_01.operations.ApplicationSecurityGroupsOperations>`\n           * 2018-12-01: :class:`ApplicationSecurityGroupsOperations<azure.mgmt.network.v2018_12_01.operations.ApplicationSecurityGroupsOperations>`\n           * 2019-02-01: :class:`ApplicationSecurityGroupsOperations<azure.mgmt.network.v2019_02_01.operations.ApplicationSecurityGroupsOperations>`", "id": "f30333:c1:m5"}
{"signature": "@property<EOL><INDENT>def virtual_network_taps(self):<DEDENT>", "body": "api_version = self._get_api_version('<STR_LIT>')<EOL>if api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_08_01.operations import VirtualNetworkTapsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_10_01.operations import VirtualNetworkTapsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_11_01.operations import VirtualNetworkTapsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_12_01.operations import VirtualNetworkTapsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2019_02_01.operations import VirtualNetworkTapsOperations as OperationClass<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\".format(api_version))<EOL><DEDENT>return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))<EOL>", "docstring": "Instance depends on the API version:\n\n           * 2018-08-01: :class:`VirtualNetworkTapsOperations<azure.mgmt.network.v2018_08_01.operations.VirtualNetworkTapsOperations>`\n           * 2018-10-01: :class:`VirtualNetworkTapsOperations<azure.mgmt.network.v2018_10_01.operations.VirtualNetworkTapsOperations>`\n           * 2018-11-01: :class:`VirtualNetworkTapsOperations<azure.mgmt.network.v2018_11_01.operations.VirtualNetworkTapsOperations>`\n           * 2018-12-01: :class:`VirtualNetworkTapsOperations<azure.mgmt.network.v2018_12_01.operations.VirtualNetworkTapsOperations>`\n           * 2019-02-01: :class:`VirtualNetworkTapsOperations<azure.mgmt.network.v2019_02_01.operations.VirtualNetworkTapsOperations>`", "id": "f30333:c1:m65"}
{"signature": "@property<EOL><INDENT>def subnets(self):<DEDENT>", "body": "api_version = self._get_api_version('<STR_LIT>')<EOL>if api_version == '<STR_LIT>':<EOL><INDENT>from .v2015_06_15.operations import SubnetsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2016_09_01.operations import SubnetsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2016_12_01.operations import SubnetsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_03_01.operations import SubnetsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_06_01.operations import SubnetsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_08_01.operations import SubnetsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_09_01.operations import SubnetsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_10_01.operations import SubnetsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_11_01.operations import SubnetsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_01_01.operations import SubnetsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_02_01.operations import SubnetsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_04_01.operations import SubnetsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_06_01.operations import SubnetsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_07_01.operations import SubnetsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_08_01.operations import SubnetsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_10_01.operations import SubnetsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_11_01.operations import SubnetsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_12_01.operations import SubnetsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2019_02_01.operations import SubnetsOperations as OperationClass<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\".format(api_version))<EOL><DEDENT>return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))<EOL>", "docstring": "Instance depends on the API version:\n\n           * 2015-06-15: :class:`SubnetsOperations<azure.mgmt.network.v2015_06_15.operations.SubnetsOperations>`\n           * 2016-09-01: :class:`SubnetsOperations<azure.mgmt.network.v2016_09_01.operations.SubnetsOperations>`\n           * 2016-12-01: :class:`SubnetsOperations<azure.mgmt.network.v2016_12_01.operations.SubnetsOperations>`\n           * 2017-03-01: :class:`SubnetsOperations<azure.mgmt.network.v2017_03_01.operations.SubnetsOperations>`\n           * 2017-06-01: :class:`SubnetsOperations<azure.mgmt.network.v2017_06_01.operations.SubnetsOperations>`\n           * 2017-08-01: :class:`SubnetsOperations<azure.mgmt.network.v2017_08_01.operations.SubnetsOperations>`\n           * 2017-09-01: :class:`SubnetsOperations<azure.mgmt.network.v2017_09_01.operations.SubnetsOperations>`\n           * 2017-10-01: :class:`SubnetsOperations<azure.mgmt.network.v2017_10_01.operations.SubnetsOperations>`\n           * 2017-11-01: :class:`SubnetsOperations<azure.mgmt.network.v2017_11_01.operations.SubnetsOperations>`\n           * 2018-01-01: :class:`SubnetsOperations<azure.mgmt.network.v2018_01_01.operations.SubnetsOperations>`\n           * 2018-02-01: :class:`SubnetsOperations<azure.mgmt.network.v2018_02_01.operations.SubnetsOperations>`\n           * 2018-04-01: :class:`SubnetsOperations<azure.mgmt.network.v2018_04_01.operations.SubnetsOperations>`\n           * 2018-06-01: :class:`SubnetsOperations<azure.mgmt.network.v2018_06_01.operations.SubnetsOperations>`\n           * 2018-07-01: :class:`SubnetsOperations<azure.mgmt.network.v2018_07_01.operations.SubnetsOperations>`\n           * 2018-08-01: :class:`SubnetsOperations<azure.mgmt.network.v2018_08_01.operations.SubnetsOperations>`\n           * 2018-10-01: :class:`SubnetsOperations<azure.mgmt.network.v2018_10_01.operations.SubnetsOperations>`\n           * 2018-11-01: :class:`SubnetsOperations<azure.mgmt.network.v2018_11_01.operations.SubnetsOperations>`\n           * 2018-12-01: :class:`SubnetsOperations<azure.mgmt.network.v2018_12_01.operations.SubnetsOperations>`\n           * 2019-02-01: :class:`SubnetsOperations<azure.mgmt.network.v2019_02_01.operations.SubnetsOperations>`", "id": "f30333:c1:m59"}
{"signature": "@property<EOL><INDENT>def express_route_cross_connection_peerings(self):<DEDENT>", "body": "api_version = self._get_api_version('<STR_LIT>')<EOL>if api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_02_01.operations import ExpressRouteCrossConnectionPeeringsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_04_01.operations import ExpressRouteCrossConnectionPeeringsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_06_01.operations import ExpressRouteCrossConnectionPeeringsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_07_01.operations import ExpressRouteCrossConnectionPeeringsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_08_01.operations import ExpressRouteCrossConnectionPeeringsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_10_01.operations import ExpressRouteCrossConnectionPeeringsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_11_01.operations import ExpressRouteCrossConnectionPeeringsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_12_01.operations import ExpressRouteCrossConnectionPeeringsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2019_02_01.operations import ExpressRouteCrossConnectionPeeringsOperations as OperationClass<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\".format(api_version))<EOL><DEDENT>return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))<EOL>", "docstring": "Instance depends on the API version:\n\n           * 2018-02-01: :class:`ExpressRouteCrossConnectionPeeringsOperations<azure.mgmt.network.v2018_02_01.operations.ExpressRouteCrossConnectionPeeringsOperations>`\n           * 2018-04-01: :class:`ExpressRouteCrossConnectionPeeringsOperations<azure.mgmt.network.v2018_04_01.operations.ExpressRouteCrossConnectionPeeringsOperations>`\n           * 2018-06-01: :class:`ExpressRouteCrossConnectionPeeringsOperations<azure.mgmt.network.v2018_06_01.operations.ExpressRouteCrossConnectionPeeringsOperations>`\n           * 2018-07-01: :class:`ExpressRouteCrossConnectionPeeringsOperations<azure.mgmt.network.v2018_07_01.operations.ExpressRouteCrossConnectionPeeringsOperations>`\n           * 2018-08-01: :class:`ExpressRouteCrossConnectionPeeringsOperations<azure.mgmt.network.v2018_08_01.operations.ExpressRouteCrossConnectionPeeringsOperations>`\n           * 2018-10-01: :class:`ExpressRouteCrossConnectionPeeringsOperations<azure.mgmt.network.v2018_10_01.operations.ExpressRouteCrossConnectionPeeringsOperations>`\n           * 2018-11-01: :class:`ExpressRouteCrossConnectionPeeringsOperations<azure.mgmt.network.v2018_11_01.operations.ExpressRouteCrossConnectionPeeringsOperations>`\n           * 2018-12-01: :class:`ExpressRouteCrossConnectionPeeringsOperations<azure.mgmt.network.v2018_12_01.operations.ExpressRouteCrossConnectionPeeringsOperations>`\n           * 2019-02-01: :class:`ExpressRouteCrossConnectionPeeringsOperations<azure.mgmt.network.v2019_02_01.operations.ExpressRouteCrossConnectionPeeringsOperations>`", "id": "f30333:c1:m21"}
{"signature": "@property<EOL><INDENT>def public_ip_prefixes(self):<DEDENT>", "body": "api_version = self._get_api_version('<STR_LIT>')<EOL>if api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_07_01.operations import PublicIPPrefixesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_08_01.operations import PublicIPPrefixesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_10_01.operations import PublicIPPrefixesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_11_01.operations import PublicIPPrefixesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_12_01.operations import PublicIPPrefixesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2019_02_01.operations import PublicIPPrefixesOperations as OperationClass<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\".format(api_version))<EOL><DEDENT>return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))<EOL>", "docstring": "Instance depends on the API version:\n\n           * 2018-07-01: :class:`PublicIPPrefixesOperations<azure.mgmt.network.v2018_07_01.operations.PublicIPPrefixesOperations>`\n           * 2018-08-01: :class:`PublicIPPrefixesOperations<azure.mgmt.network.v2018_08_01.operations.PublicIPPrefixesOperations>`\n           * 2018-10-01: :class:`PublicIPPrefixesOperations<azure.mgmt.network.v2018_10_01.operations.PublicIPPrefixesOperations>`\n           * 2018-11-01: :class:`PublicIPPrefixesOperations<azure.mgmt.network.v2018_11_01.operations.PublicIPPrefixesOperations>`\n           * 2018-12-01: :class:`PublicIPPrefixesOperations<azure.mgmt.network.v2018_12_01.operations.PublicIPPrefixesOperations>`\n           * 2019-02-01: :class:`PublicIPPrefixesOperations<azure.mgmt.network.v2019_02_01.operations.PublicIPPrefixesOperations>`", "id": "f30333:c1:m51"}
{"signature": "@property<EOL><INDENT>def virtual_networks(self):<DEDENT>", "body": "api_version = self._get_api_version('<STR_LIT>')<EOL>if api_version == '<STR_LIT>':<EOL><INDENT>from .v2015_06_15.operations import VirtualNetworksOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2016_09_01.operations import VirtualNetworksOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2016_12_01.operations import VirtualNetworksOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_03_01.operations import VirtualNetworksOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_06_01.operations import VirtualNetworksOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_08_01.operations import VirtualNetworksOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_09_01.operations import VirtualNetworksOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_10_01.operations import VirtualNetworksOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_11_01.operations import VirtualNetworksOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_01_01.operations import VirtualNetworksOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_02_01.operations import VirtualNetworksOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_04_01.operations import VirtualNetworksOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_06_01.operations import VirtualNetworksOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_07_01.operations import VirtualNetworksOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_08_01.operations import VirtualNetworksOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_10_01.operations import VirtualNetworksOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_11_01.operations import VirtualNetworksOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_12_01.operations import VirtualNetworksOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2019_02_01.operations import VirtualNetworksOperations as OperationClass<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\".format(api_version))<EOL><DEDENT>return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))<EOL>", "docstring": "Instance depends on the API version:\n\n           * 2015-06-15: :class:`VirtualNetworksOperations<azure.mgmt.network.v2015_06_15.operations.VirtualNetworksOperations>`\n           * 2016-09-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2016_09_01.operations.VirtualNetworksOperations>`\n           * 2016-12-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2016_12_01.operations.VirtualNetworksOperations>`\n           * 2017-03-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2017_03_01.operations.VirtualNetworksOperations>`\n           * 2017-06-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2017_06_01.operations.VirtualNetworksOperations>`\n           * 2017-08-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2017_08_01.operations.VirtualNetworksOperations>`\n           * 2017-09-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2017_09_01.operations.VirtualNetworksOperations>`\n           * 2017-10-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2017_10_01.operations.VirtualNetworksOperations>`\n           * 2017-11-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2017_11_01.operations.VirtualNetworksOperations>`\n           * 2018-01-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2018_01_01.operations.VirtualNetworksOperations>`\n           * 2018-02-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2018_02_01.operations.VirtualNetworksOperations>`\n           * 2018-04-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2018_04_01.operations.VirtualNetworksOperations>`\n           * 2018-06-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2018_06_01.operations.VirtualNetworksOperations>`\n           * 2018-07-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2018_07_01.operations.VirtualNetworksOperations>`\n           * 2018-08-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2018_08_01.operations.VirtualNetworksOperations>`\n           * 2018-10-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2018_10_01.operations.VirtualNetworksOperations>`\n           * 2018-11-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2018_11_01.operations.VirtualNetworksOperations>`\n           * 2018-12-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2018_12_01.operations.VirtualNetworksOperations>`\n           * 2019-02-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2019_02_01.operations.VirtualNetworksOperations>`", "id": "f30333:c1:m66"}
{"signature": "def check_dns_name_availability(<EOL>self, location, domain_name_label=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.check_dns_name_availability.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if domain_name_label is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", domain_name_label, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Checks whether a domain name in the cloudapp.net zone is available for\n        use.\n\n        :param location: The location of the domain name.\n        :type location: str\n        :param domain_name_label: The domain name to be verified. It must\n         conform to the following regular expression:\n         ^[a-z][a-z0-9-]{1,61}[a-z0-9]$.\n        :type domain_name_label: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DnsNameAvailabilityResult or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2016_09_01.models.DnsNameAvailabilityResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30335:c1:m1"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.LoadBalancerPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.LoadBalancerPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the load balancers in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of LoadBalancer\n        :rtype:\n         ~azure.mgmt.network.v2016_09_01.models.LoadBalancerPaged[~azure.mgmt.network.v2016_09_01.models.LoadBalancer]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30529:c0:m7"}
{"signature": "def create(<EOL>self, resource_group_name, network_watcher_name, packet_capture_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>packet_capture_name=packet_capture_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Create and start a packet capture on the specified VM.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param packet_capture_name: The name of the packet capture session.\n        :type packet_capture_name: str\n        :param parameters: Parameters that define the create packet capture\n         operation.\n        :type parameters: ~azure.mgmt.network.v2016_09_01.models.PacketCapture\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns PacketCaptureResult or\n         ClientRawResponse<PacketCaptureResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2016_09_01.models.PacketCaptureResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2016_09_01.models.PacketCaptureResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30530:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, network_watcher_name, packet_capture_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_watcher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", packet_capture_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a packet capture session by name.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param packet_capture_name: The name of the packet capture session.\n        :type packet_capture_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PacketCaptureResult or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2016_09_01.models.PacketCaptureResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30530:c0:m3"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualNetworkGatewayConnectionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualNetworkGatewayConnectionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "The List VirtualNetworkGatewayConnections operation retrieves all the\n        virtual network gateways connections created.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualNetworkGatewayConnection\n        :rtype:\n         ~azure.mgmt.network.v2016_09_01.models.VirtualNetworkGatewayConnectionPaged[~azure.mgmt.network.v2016_09_01.models.VirtualNetworkGatewayConnection]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30531:c0:m9"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, virtual_network_gateway_connection_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_connection_name=virtual_network_gateway_connection_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a virtual network gateway connection in the\n        specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_connection_name: The name of the\n         virtual network gateway connection.\n        :type virtual_network_gateway_connection_name: str\n        :param parameters: Parameters supplied to the create or update virtual\n         network gateway connection operation.\n        :type parameters:\n         ~azure.mgmt.network.v2016_09_01.models.VirtualNetworkGatewayConnection\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         VirtualNetworkGatewayConnection or\n         ClientRawResponse<VirtualNetworkGatewayConnection> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2016_09_01.models.VirtualNetworkGatewayConnection]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2016_09_01.models.VirtualNetworkGatewayConnection]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30531:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, virtual_network_gateway_connection_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_gateway_connection_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified virtual network gateway connection by resource\n        group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_connection_name: The name of the\n         virtual network gateway connection.\n        :type virtual_network_gateway_connection_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualNetworkGatewayConnection or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.network.v2016_09_01.models.VirtualNetworkGatewayConnection\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30531:c0:m3"}
{"signature": "def get(<EOL>self, resource_group_name, application_gateway_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", application_gateway_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified application gateway.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param application_gateway_name: The name of the application gateway.\n        :type application_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ApplicationGateway or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2016_09_01.models.ApplicationGateway or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30532:c0:m3"}
{"signature": "def backend_health(<EOL>self, resource_group_name, application_gateway_name, expand=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._backend_health_initial(<EOL>resource_group_name=resource_group_name,<EOL>application_gateway_name=application_gateway_name,<EOL>expand=expand,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the backend health of the specified application gateway in a\n        resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param application_gateway_name: The name of the application gateway.\n        :type application_gateway_name: str\n        :param expand: Expands BackendAddressPool and BackendHttpSettings\n         referenced in backend health.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ApplicationGatewayBackendHealth or\n         ClientRawResponse<ApplicationGatewayBackendHealth> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2016_09_01.models.ApplicationGatewayBackendHealth]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2016_09_01.models.ApplicationGatewayBackendHealth]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30532:c0:m13"}
{"signature": "def delete(<EOL>self, resource_group_name, application_gateway_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>application_gateway_name=application_gateway_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified application gateway.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param application_gateway_name: The name of the application gateway.\n        :type application_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30532:c0:m2"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, application_gateway_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>application_gateway_name=application_gateway_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates the specified application gateway.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param application_gateway_name: The name of the application gateway.\n        :type application_gateway_name: str\n        :param parameters: Parameters supplied to the create or update\n         application gateway operation.\n        :type parameters:\n         ~azure.mgmt.network.v2016_09_01.models.ApplicationGateway\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ApplicationGateway or\n         ClientRawResponse<ApplicationGateway> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2016_09_01.models.ApplicationGateway]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2016_09_01.models.ApplicationGateway]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30532:c0:m5"}
{"signature": "def start(<EOL>self, resource_group_name, application_gateway_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._start_initial(<EOL>resource_group_name=resource_group_name,<EOL>application_gateway_name=application_gateway_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Starts the specified application gateway.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param application_gateway_name: The name of the application gateway.\n        :type application_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30532:c0:m9"}
{"signature": "def get(<EOL>self, resource_group_name, local_network_gateway_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", local_network_gateway_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified local network gateway in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param local_network_gateway_name: The name of the local network\n         gateway.\n        :type local_network_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: LocalNetworkGateway or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2016_09_01.models.LocalNetworkGateway or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30533:c0:m3"}
{"signature": "def delete(<EOL>self, resource_group_name, virtual_network_name, virtual_network_peering_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_name=virtual_network_name,<EOL>virtual_network_peering_name=virtual_network_peering_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified virtual network peering.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param virtual_network_peering_name: The name of the virtual network\n         peering.\n        :type virtual_network_peering_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30535:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, virtual_network_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified virtual network by resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualNetwork or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2016_09_01.models.VirtualNetwork or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30536:c0:m3"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualNetworkPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualNetworkPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all virtual networks in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualNetwork\n        :rtype:\n         ~azure.mgmt.network.v2016_09_01.models.VirtualNetworkPaged[~azure.mgmt.network.v2016_09_01.models.VirtualNetwork]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30536:c0:m6"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ExpressRouteCircuitPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ExpressRouteCircuitPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the express route circuits in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ExpressRouteCircuit\n        :rtype:\n         ~azure.mgmt.network.v2016_09_01.models.ExpressRouteCircuitPaged[~azure.mgmt.network.v2016_09_01.models.ExpressRouteCircuit]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30537:c0:m15"}
{"signature": "def list_arp_table(<EOL>self, resource_group_name, circuit_name, peering_name, device_path, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._list_arp_table_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>peering_name=peering_name,<EOL>device_path=device_path,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the currently advertised ARP table associated with the express\n        route circuit in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param device_path: The path of the device.\n        :type device_path: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCircuitsArpTableListResult or\n         ClientRawResponse<ExpressRouteCircuitsArpTableListResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2016_09_01.models.ExpressRouteCircuitsArpTableListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2016_09_01.models.ExpressRouteCircuitsArpTableListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30537:c0:m7"}
{"signature": "def get(<EOL>self, resource_group_name, circuit_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about the specified express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of express route circuit.\n        :type circuit_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteCircuit or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2016_09_01.models.ExpressRouteCircuit or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30537:c0:m3"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, network_security_group_name, security_rule_name, security_rule_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_security_group_name=network_security_group_name,<EOL>security_rule_name=security_rule_name,<EOL>security_rule_parameters=security_rule_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a security rule in the specified network security\n        group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param security_rule_name: The name of the security rule.\n        :type security_rule_name: str\n        :param security_rule_parameters: Parameters supplied to the create or\n         update network security rule operation.\n        :type security_rule_parameters:\n         ~azure.mgmt.network.v2016_09_01.models.SecurityRule\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns SecurityRule or\n         ClientRawResponse<SecurityRule> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2016_09_01.models.SecurityRule]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2016_09_01.models.SecurityRule]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30540:c0:m5"}
{"signature": "def get(<EOL>self, resource_group_name, virtual_network_name, subnet_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", subnet_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified subnet by virtual network and resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param subnet_name: The name of the subnet.\n        :type subnet_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Subnet or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2016_09_01.models.Subnet or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30541:c0:m3"}
{"signature": "def list(<EOL>self, resource_group_name, virtual_network_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SubnetPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SubnetPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all subnets in a virtual network.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Subnet\n        :rtype:\n         ~azure.mgmt.network.v2016_09_01.models.SubnetPaged[~azure.mgmt.network.v2016_09_01.models.Subnet]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30541:c0:m6"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PublicIPAddressPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PublicIPAddressPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the public IP addresses in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PublicIPAddress\n        :rtype:\n         ~azure.mgmt.network.v2016_09_01.models.PublicIPAddressPaged[~azure.mgmt.network.v2016_09_01.models.PublicIPAddress]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30542:c0:m6"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PublicIPAddressPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PublicIPAddressPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all public IP addresses in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PublicIPAddress\n        :rtype:\n         ~azure.mgmt.network.v2016_09_01.models.PublicIPAddressPaged[~azure.mgmt.network.v2016_09_01.models.PublicIPAddress]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30542:c0:m7"}
{"signature": "def get_troubleshooting(<EOL>self, resource_group_name, network_watcher_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_troubleshooting_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Initiate troubleshooting on a specified resource.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher resource.\n        :type network_watcher_name: str\n        :param parameters: Parameters that define the resource to\n         troubleshoot.\n        :type parameters:\n         ~azure.mgmt.network.v2016_09_01.models.TroubleshootingParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns TroubleshootingResult\n         or ClientRawResponse<TroubleshootingResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2016_09_01.models.TroubleshootingResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2016_09_01.models.TroubleshootingResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30544:c0:m15"}
{"signature": "def delete(<EOL>self, resource_group_name, network_watcher_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified network watcher resource.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30544:c0:m4"}
{"signature": "def get_topology(<EOL>self, resource_group_name, network_watcher_name, target_resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.TopologyParameters(target_resource_group_name=target_resource_group_name)<EOL>url = self.get_topology.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_watcher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the current network topology by resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param target_resource_group_name: The name of the target resource\n         group to perform topology on.\n        :type target_resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Topology or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2016_09_01.models.Topology or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30544:c0:m7"}
{"signature": "def get_flow_log_status(<EOL>self, resource_group_name, network_watcher_name, target_resource_id, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_flow_log_status_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>target_resource_id=target_resource_id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Queries status of flow log on a specified resource.\n\n        :param resource_group_name: The name of the network watcher resource\n         group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher resource.\n        :type network_watcher_name: str\n        :param target_resource_id: The target resource where getting the flow\n         logging status.\n        :type target_resource_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns FlowLogInformation or\n         ClientRawResponse<FlowLogInformation> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2016_09_01.models.FlowLogInformation]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2016_09_01.models.FlowLogInformation]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30544:c0:m21"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, circuit_name, peering_name, peering_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>peering_name=peering_name,<EOL>peering_parameters=peering_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a peering in the specified express route circuits.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param peering_parameters: Parameters supplied to the create or update\n         express route circuit peering operation.\n        :type peering_parameters:\n         ~azure.mgmt.network.v2016_09_01.models.ExpressRouteCircuitPeering\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCircuitPeering or\n         ClientRawResponse<ExpressRouteCircuitPeering> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2016_09_01.models.ExpressRouteCircuitPeering]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2016_09_01.models.ExpressRouteCircuitPeering]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30546:c0:m5"}
{"signature": "def delete(<EOL>self, resource_group_name, route_table_name, route_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_table_name=route_table_name,<EOL>route_name=route_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified route from a route table.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param route_name: The name of the route.\n        :type route_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30547:c0:m2"}
{"signature": "def get_bgp_peer_status(<EOL>self, resource_group_name, virtual_network_gateway_name, peer=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_bgp_peer_status_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_name=virtual_network_gateway_name,<EOL>peer=peer,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The GetBgpPeerStatus operation retrieves the status of all BGP peers.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param peer: The IP address of the peer to retrieve the status of.\n        :type peer: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns BgpPeerStatusListResult\n         or ClientRawResponse<BgpPeerStatusListResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2016_09_01.models.BgpPeerStatusListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2016_09_01.models.BgpPeerStatusListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30548:c0:m11"}
{"signature": "def get(<EOL>self, resource_group_name, virtual_network_gateway_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_gateway_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified virtual network gateway by resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualNetworkGateway or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2016_09_01.models.VirtualNetworkGateway\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30548:c0:m3"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualNetworkGatewayPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualNetworkGatewayPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all virtual network gateways by resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualNetworkGateway\n        :rtype:\n         ~azure.mgmt.network.v2016_09_01.models.VirtualNetworkGatewayPaged[~azure.mgmt.network.v2016_09_01.models.VirtualNetworkGateway]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30548:c0:m6"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, network_interface_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_interface_name=network_interface_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a network interface.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param parameters: Parameters supplied to the create or update network\n         interface operation.\n        :type parameters:\n         ~azure.mgmt.network.v2016_09_01.models.NetworkInterface\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns NetworkInterface or\n         ClientRawResponse<NetworkInterface> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2016_09_01.models.NetworkInterface]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2016_09_01.models.NetworkInterface]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30549:c0:m8"}
{"signature": "def get_effective_route_table(<EOL>self, resource_group_name, network_interface_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_effective_route_table_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_interface_name=network_interface_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets all route tables applied to a network interface.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         EffectiveRouteListResult or\n         ClientRawResponse<EffectiveRouteListResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2016_09_01.models.EffectiveRouteListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2016_09_01.models.EffectiveRouteListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30549:c0:m12"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkSecurityGroupPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkSecurityGroupPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all network security groups in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkSecurityGroup\n        :rtype:\n         ~azure.mgmt.network.v2016_09_01.models.NetworkSecurityGroupPaged[~azure.mgmt.network.v2016_09_01.models.NetworkSecurityGroup]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30550:c0:m6"}
{"signature": "def get(<EOL>self, resource_group_name, network_security_group_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_security_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified network security group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: NetworkSecurityGroup or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2016_09_01.models.NetworkSecurityGroup or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30550:c0:m3"}
{"signature": "def list(<EOL>self, resource_group_name, load_balancer_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.BackendAddressPoolPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.BackendAddressPoolPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the load balancer backed address pools.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of BackendAddressPool\n        :rtype:\n         ~azure.mgmt.network.v2018_06_01.models.BackendAddressPoolPaged[~azure.mgmt.network.v2018_06_01.models.BackendAddressPool]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30915:c0:m1"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.LoadBalancerPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.LoadBalancerPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the load balancers in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of LoadBalancer\n        :rtype:\n         ~azure.mgmt.network.v2018_06_01.models.LoadBalancerPaged[~azure.mgmt.network.v2018_06_01.models.LoadBalancer]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30916:c0:m8"}
{"signature": "def get(<EOL>self, resource_group_name, load_balancer_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified load balancer.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: LoadBalancer or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_06_01.models.LoadBalancer or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30916:c0:m3"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, load_balancer_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>load_balancer_name=load_balancer_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a load balancer.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param parameters: Parameters supplied to the create or update load\n         balancer operation.\n        :type parameters: ~azure.mgmt.network.v2018_06_01.models.LoadBalancer\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns LoadBalancer or\n         ClientRawResponse<LoadBalancer> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_06_01.models.LoadBalancer]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_06_01.models.LoadBalancer]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30916:c0:m5"}
{"signature": "def list(<EOL>self, resource_group_name, network_interface_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_interface_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkInterfaceIPConfigurationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkInterfaceIPConfigurationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get all ip configurations in a network interface.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkInterfaceIPConfiguration\n        :rtype:\n         ~azure.mgmt.network.v2018_06_01.models.NetworkInterfaceIPConfigurationPaged[~azure.mgmt.network.v2018_06_01.models.NetworkInterfaceIPConfiguration]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30917:c0:m1"}
{"signature": "def list_routes_table_summary(<EOL>self, resource_group_name, cross_connection_name, peering_name, device_path, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._list_routes_table_summary_initial(<EOL>resource_group_name=resource_group_name,<EOL>cross_connection_name=cross_connection_name,<EOL>peering_name=peering_name,<EOL>device_path=device_path,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the route table summary associated with the express route cross\n        connection in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param cross_connection_name: The name of the\n         ExpressRouteCrossConnection.\n        :type cross_connection_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param device_path: The path of the device.\n        :type device_path: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCrossConnectionsRoutesTableSummaryListResult or\n         ClientRawResponse<ExpressRouteCrossConnectionsRoutesTableSummaryListResult>\n         if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_06_01.models.ExpressRouteCrossConnectionsRoutesTableSummaryListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_06_01.models.ExpressRouteCrossConnectionsRoutesTableSummaryListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30918:c0:m11"}
{"signature": "def get(<EOL>self, resource_group_name, cross_connection_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", cross_connection_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets details about the specified ExpressRouteCrossConnection.\n\n        :param resource_group_name: The name of the resource group (peering\n         location of the circuit).\n        :type resource_group_name: str\n        :param cross_connection_name: The name of the\n         ExpressRouteCrossConnection (service key of the circuit).\n        :type cross_connection_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteCrossConnection or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_06_01.models.ExpressRouteCrossConnection or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30918:c0:m3"}
{"signature": "def update_tags(<EOL>self, resource_group_name, cross_connection_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>cross_connection_name=cross_connection_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates an express route cross connection tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param cross_connection_name: The name of the cross connection.\n        :type cross_connection_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCrossConnection or\n         ClientRawResponse<ExpressRouteCrossConnection> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_06_01.models.ExpressRouteCrossConnection]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_06_01.models.ExpressRouteCrossConnection]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30918:c0:m7"}
{"signature": "def list_arp_table(<EOL>self, resource_group_name, cross_connection_name, peering_name, device_path, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._list_arp_table_initial(<EOL>resource_group_name=resource_group_name,<EOL>cross_connection_name=cross_connection_name,<EOL>peering_name=peering_name,<EOL>device_path=device_path,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the currently advertised ARP table associated with the express\n        route cross connection in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param cross_connection_name: The name of the\n         ExpressRouteCrossConnection.\n        :type cross_connection_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param device_path: The path of the device\n        :type device_path: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCircuitsArpTableListResult or\n         ClientRawResponse<ExpressRouteCircuitsArpTableListResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_06_01.models.ExpressRouteCircuitsArpTableListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_06_01.models.ExpressRouteCircuitsArpTableListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30918:c0:m9"}
{"signature": "def delete(<EOL>self, resource_group_name, network_watcher_name, packet_capture_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>packet_capture_name=packet_capture_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified packet capture session.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param packet_capture_name: The name of the packet capture session.\n        :type packet_capture_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_06_01.models.ErrorResponseException>`", "id": "f30921:c0:m5"}
{"signature": "def get_status(<EOL>self, resource_group_name, network_watcher_name, packet_capture_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_status_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>packet_capture_name=packet_capture_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT:location>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Query the status of a running packet capture session.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the Network Watcher resource.\n        :type network_watcher_name: str\n        :param packet_capture_name: The name given to the packet capture\n         session.\n        :type packet_capture_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         PacketCaptureQueryStatusResult or\n         ClientRawResponse<PacketCaptureQueryStatusResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_06_01.models.PacketCaptureQueryStatusResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_06_01.models.PacketCaptureQueryStatusResult]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_06_01.models.ErrorResponseException>`", "id": "f30921:c0:m9"}
{"signature": "def create(<EOL>self, resource_group_name, network_watcher_name, packet_capture_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>packet_capture_name=packet_capture_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Create and start a packet capture on the specified VM.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param packet_capture_name: The name of the packet capture session.\n        :type packet_capture_name: str\n        :param parameters: Parameters that define the create packet capture\n         operation.\n        :type parameters: ~azure.mgmt.network.v2018_06_01.models.PacketCapture\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns PacketCaptureResult or\n         ClientRawResponse<PacketCaptureResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_06_01.models.PacketCaptureResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_06_01.models.PacketCaptureResult]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_06_01.models.ErrorResponseException>`", "id": "f30921:c0:m2"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, virtual_network_gateway_connection_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_connection_name=virtual_network_gateway_connection_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a virtual network gateway connection in the\n        specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_connection_name: The name of the\n         virtual network gateway connection.\n        :type virtual_network_gateway_connection_name: str\n        :param parameters: Parameters supplied to the create or update virtual\n         network gateway connection operation.\n        :type parameters:\n         ~azure.mgmt.network.v2018_06_01.models.VirtualNetworkGatewayConnection\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         VirtualNetworkGatewayConnection or\n         ClientRawResponse<VirtualNetworkGatewayConnection> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_06_01.models.VirtualNetworkGatewayConnection]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_06_01.models.VirtualNetworkGatewayConnection]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30922:c0:m2"}
{"signature": "def get_shared_key(<EOL>self, resource_group_name, virtual_network_gateway_connection_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_shared_key.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_gateway_connection_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "The Get VirtualNetworkGatewayConnectionSharedKey operation retrieves\n        information about the specified virtual network gateway connection\n        shared key through Network resource provider.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_connection_name: The virtual network\n         gateway connection shared key name.\n        :type virtual_network_gateway_connection_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ConnectionSharedKey or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_06_01.models.ConnectionSharedKey or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30922:c0:m10"}
{"signature": "def get(<EOL>self, resource_group_name, virtual_wan_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_wan_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves the details of a VirtualWAN.\n\n        :param resource_group_name: The resource group name of the VirtualWan.\n        :type resource_group_name: str\n        :param virtual_wan_name: The name of the VirtualWAN being retrieved.\n        :type virtual_wan_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualWAN or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_06_01.models.VirtualWAN or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_06_01.models.ErrorException>`", "id": "f30924:c0:m1"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualWANPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualWANPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all the VirtualWANs in a resource group.\n\n        :param resource_group_name: The resource group name of the VirtualWan.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualWAN\n        :rtype:\n         ~azure.mgmt.network.v2018_06_01.models.VirtualWANPaged[~azure.mgmt.network.v2018_06_01.models.VirtualWAN]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_06_01.models.ErrorException>`", "id": "f30924:c0:m8"}
{"signature": "def update_tags(<EOL>self, resource_group_name, virtual_wan_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_wan_name=virtual_wan_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a VirtualWAN tags.\n\n        :param resource_group_name: The resource group name of the VirtualWan.\n        :type resource_group_name: str\n        :param virtual_wan_name: The name of the VirtualWAN being updated.\n        :type virtual_wan_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualWAN or\n         ClientRawResponse<VirtualWAN> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_06_01.models.VirtualWAN]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_06_01.models.VirtualWAN]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_06_01.models.ErrorException>`", "id": "f30924:c0:m5"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.DdosProtectionPlanPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.DdosProtectionPlanPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all DDoS protection plans in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of DdosProtectionPlan\n        :rtype:\n         ~azure.mgmt.network.v2018_06_01.models.DdosProtectionPlanPaged[~azure.mgmt.network.v2018_06_01.models.DdosProtectionPlan]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30925:c0:m6"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.AzureFirewallPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.AzureFirewallPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all Azure Firewalls in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of AzureFirewall\n        :rtype:\n         ~azure.mgmt.network.v2018_06_01.models.AzureFirewallPaged[~azure.mgmt.network.v2018_06_01.models.AzureFirewall]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30926:c0:m6"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, azure_firewall_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>azure_firewall_name=azure_firewall_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates the specified Azure Firewall.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param azure_firewall_name: The name of the Azure Firewall.\n        :type azure_firewall_name: str\n        :param parameters: Parameters supplied to the create or update Azure\n         Firewall operation.\n        :type parameters: ~azure.mgmt.network.v2018_06_01.models.AzureFirewall\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns AzureFirewall or\n         ClientRawResponse<AzureFirewall> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_06_01.models.AzureFirewall]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_06_01.models.AzureFirewall]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30926:c0:m5"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.AzureFirewallPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.AzureFirewallPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the Azure Firewalls in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of AzureFirewall\n        :rtype:\n         ~azure.mgmt.network.v2018_06_01.models.AzureFirewallPaged[~azure.mgmt.network.v2018_06_01.models.AzureFirewall]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30926:c0:m7"}
{"signature": "def get(<EOL>self, resource_group_name, azure_firewall_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", azure_firewall_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified Azure Firewall.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param azure_firewall_name: The name of the Azure Firewall.\n        :type azure_firewall_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: AzureFirewall or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_06_01.models.AzureFirewall or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30926:c0:m3"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, local_network_gateway_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>local_network_gateway_name=local_network_gateway_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a local network gateway in the specified resource\n        group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param local_network_gateway_name: The name of the local network\n         gateway.\n        :type local_network_gateway_name: str\n        :param parameters: Parameters supplied to the create or update local\n         network gateway operation.\n        :type parameters:\n         ~azure.mgmt.network.v2018_06_01.models.LocalNetworkGateway\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns LocalNetworkGateway or\n         ClientRawResponse<LocalNetworkGateway> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_06_01.models.LocalNetworkGateway]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_06_01.models.LocalNetworkGateway]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30930:c0:m2"}
{"signature": "def download(<EOL>self, resource_group_name, virtual_wan_name, vpn_sites=None, output_blob_sas_url=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._download_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_wan_name=virtual_wan_name,<EOL>vpn_sites=vpn_sites,<EOL>output_blob_sas_url=output_blob_sas_url,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gives the sas-url to download the configurations for vpn-sites in a\n        resource group.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param virtual_wan_name: The name of the VirtualWAN for which\n         configuration of all vpn-sites is needed.\n        :type virtual_wan_name: str\n        :param vpn_sites: List of resource-ids of the vpn-sites for which\n         config is to be downloaded.\n        :type vpn_sites:\n         list[~azure.mgmt.network.v2018_06_01.models.SubResource]\n        :param output_blob_sas_url: The sas-url to download the configurations\n         for vpn-sites\n        :type output_blob_sas_url: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_06_01.models.ErrorException>`", "id": "f30931:c0:m2"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VpnGatewayPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VpnGatewayPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all the VpnGateways in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VpnGateway\n        :rtype:\n         ~azure.mgmt.network.v2018_06_01.models.VpnGatewayPaged[~azure.mgmt.network.v2018_06_01.models.VpnGateway]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_06_01.models.ErrorException>`", "id": "f30933:c0:m9"}
{"signature": "def update_tags(<EOL>self, resource_group_name, route_table_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_table_name=route_table_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a route table tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns RouteTable or\n         ClientRawResponse<RouteTable> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_06_01.models.RouteTable]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_06_01.models.RouteTable]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30934:c0:m7"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RouteTablePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RouteTablePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all route tables in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of RouteTable\n        :rtype:\n         ~azure.mgmt.network.v2018_06_01.models.RouteTablePaged[~azure.mgmt.network.v2018_06_01.models.RouteTable]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30934:c0:m8"}
{"signature": "def get(<EOL>self, resource_group_name, circuit_name, peering_name, connection_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", peering_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", connection_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified Express Route Circuit Connection from the specified\n        express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param connection_name: The name of the express route circuit\n         connection.\n        :type connection_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteCircuitConnection or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_06_01.models.ExpressRouteCircuitConnection\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30936:c0:m3"}
{"signature": "def get(<EOL>self, resource_group_name, load_balancer_name, inbound_nat_rule_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", inbound_nat_rule_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified load balancer inbound nat rule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param inbound_nat_rule_name: The name of the inbound nat rule.\n        :type inbound_nat_rule_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: InboundNatRule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_06_01.models.InboundNatRule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30939:c0:m4"}
{"signature": "def get_stats(<EOL>self, resource_group_name, circuit_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_stats.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the stats from an express route circuit in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteCircuitStats or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_06_01.models.ExpressRouteCircuitStats or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30940:c0:m14"}
{"signature": "def update_tags(<EOL>self, resource_group_name, circuit_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates an express route circuit tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the circuit.\n        :type circuit_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ExpressRouteCircuit or\n         ClientRawResponse<ExpressRouteCircuit> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_06_01.models.ExpressRouteCircuit]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_06_01.models.ExpressRouteCircuit]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30940:c0:m7"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, circuit_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates an express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the circuit.\n        :type circuit_name: str\n        :param parameters: Parameters supplied to the create or update express\n         route circuit operation.\n        :type parameters:\n         ~azure.mgmt.network.v2018_06_01.models.ExpressRouteCircuit\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ExpressRouteCircuit or\n         ClientRawResponse<ExpressRouteCircuit> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_06_01.models.ExpressRouteCircuit]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_06_01.models.ExpressRouteCircuit]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30940:c0:m5"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ExpressRouteCircuitPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ExpressRouteCircuitPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the express route circuits in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ExpressRouteCircuit\n        :rtype:\n         ~azure.mgmt.network.v2018_06_01.models.ExpressRouteCircuitPaged[~azure.mgmt.network.v2018_06_01.models.ExpressRouteCircuit]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30940:c0:m16"}
{"signature": "def delete(<EOL>self, resource_group_name, circuit_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30940:c0:m2"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ApplicationSecurityGroupPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ApplicationSecurityGroupPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all application security groups in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ApplicationSecurityGroup\n        :rtype:\n         ~azure.mgmt.network.v2018_06_01.models.ApplicationSecurityGroupPaged[~azure.mgmt.network.v2018_06_01.models.ApplicationSecurityGroup]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30941:c0:m6"}
{"signature": "def list(<EOL>self, resource_group_name, circuit_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ExpressRouteCircuitAuthorizationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ExpressRouteCircuitAuthorizationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all authorizations in an express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the circuit.\n        :type circuit_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ExpressRouteCircuitAuthorization\n        :rtype:\n         ~azure.mgmt.network.v2018_06_01.models.ExpressRouteCircuitAuthorizationPaged[~azure.mgmt.network.v2018_06_01.models.ExpressRouteCircuitAuthorization]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30942:c0:m6"}
{"signature": "def get(<EOL>self, resource_group_name, virtual_hub_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_hub_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves the details of a VirtualHub.\n\n        :param resource_group_name: The resource group name of the VirtualHub.\n        :type resource_group_name: str\n        :param virtual_hub_name: The name of the VirtualHub.\n        :type virtual_hub_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualHub or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_06_01.models.VirtualHub or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_06_01.models.ErrorException>`", "id": "f30944:c0:m1"}
{"signature": "def delete(<EOL>self, resource_group_name, virtual_hub_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_hub_name=virtual_hub_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes a VirtualHub.\n\n        :param resource_group_name: The resource group name of the VirtualHub.\n        :type resource_group_name: str\n        :param virtual_hub_name: The name of the VirtualHub.\n        :type virtual_hub_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_06_01.models.ErrorException>`", "id": "f30944:c0:m7"}
{"signature": "def list(<EOL>self, resource_group_name, network_security_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_security_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SecurityRulePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SecurityRulePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all security rules in a network security group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of SecurityRule\n        :rtype:\n         ~azure.mgmt.network.v2018_06_01.models.SecurityRulePaged[~azure.mgmt.network.v2018_06_01.models.SecurityRule]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30945:c0:m6"}
{"signature": "def delete(<EOL>self, resource_group_name, network_security_group_name, security_rule_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_security_group_name=network_security_group_name,<EOL>security_rule_name=security_rule_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified network security rule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param security_rule_name: The name of the security rule.\n        :type security_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30945:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, virtual_network_name, subnet_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", subnet_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified subnet by virtual network and resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param subnet_name: The name of the subnet.\n        :type subnet_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Subnet or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_06_01.models.Subnet or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30946:c0:m3"}
{"signature": "def list_virtual_machine_scale_set_vm_public_ip_addresses(<EOL>self, resource_group_name, virtual_machine_scale_set_name, virtualmachine_index, network_interface_name, ip_configuration_name, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_virtual_machine_scale_set_vm_public_ip_addresses.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_machine_scale_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtualmachine_index, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_interface_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", ip_configuration_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PublicIPAddressPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PublicIPAddressPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about all public IP addresses in a virtual machine IP\n        configuration in a virtual machine scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_machine_scale_set_name: The name of the virtual machine\n         scale set.\n        :type virtual_machine_scale_set_name: str\n        :param virtualmachine_index: The virtual machine index.\n        :type virtualmachine_index: str\n        :param network_interface_name: The network interface name.\n        :type network_interface_name: str\n        :param ip_configuration_name: The IP configuration name.\n        :type ip_configuration_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PublicIPAddress\n        :rtype:\n         ~azure.mgmt.network.v2018_06_01.models.PublicIPAddressPaged[~azure.mgmt.network.v2018_06_01.models.PublicIPAddress]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30947:c0:m11"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PublicIPAddressPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PublicIPAddressPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the public IP addresses in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PublicIPAddress\n        :rtype:\n         ~azure.mgmt.network.v2018_06_01.models.PublicIPAddressPaged[~azure.mgmt.network.v2018_06_01.models.PublicIPAddress]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30947:c0:m8"}
{"signature": "def update_tags(<EOL>self, resource_group_name, public_ip_address_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>public_ip_address_name=public_ip_address_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates public IP address tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param public_ip_address_name: The name of the public IP address.\n        :type public_ip_address_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns PublicIPAddress or\n         ClientRawResponse<PublicIPAddress> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_06_01.models.PublicIPAddress]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_06_01.models.PublicIPAddress]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30947:c0:m7"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, public_ip_address_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>public_ip_address_name=public_ip_address_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a static or dynamic public IP address.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param public_ip_address_name: The name of the public IP address.\n        :type public_ip_address_name: str\n        :param parameters: Parameters supplied to the create or update public\n         IP address operation.\n        :type parameters:\n         ~azure.mgmt.network.v2018_06_01.models.PublicIPAddress\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns PublicIPAddress or\n         ClientRawResponse<PublicIPAddress> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_06_01.models.PublicIPAddress]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_06_01.models.PublicIPAddress]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30947:c0:m5"}
{"signature": "def list_virtual_machine_scale_set_public_ip_addresses(<EOL>self, resource_group_name, virtual_machine_scale_set_name, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_virtual_machine_scale_set_public_ip_addresses.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_machine_scale_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PublicIPAddressPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PublicIPAddressPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about all public IP addresses on a virtual machine\n        scale set level.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_machine_scale_set_name: The name of the virtual machine\n         scale set.\n        :type virtual_machine_scale_set_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PublicIPAddress\n        :rtype:\n         ~azure.mgmt.network.v2018_06_01.models.PublicIPAddressPaged[~azure.mgmt.network.v2018_06_01.models.PublicIPAddress]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30947:c0:m10"}
{"signature": "def delete(<EOL>self, resource_group_name, cross_connection_name, peering_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>cross_connection_name=cross_connection_name,<EOL>peering_name=peering_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified peering from the ExpressRouteCrossConnection.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param cross_connection_name: The name of the\n         ExpressRouteCrossConnection.\n        :type cross_connection_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30948:c0:m3"}
{"signature": "def get(<EOL>self, resource_group_name, cross_connection_name, peering_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", cross_connection_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", peering_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified peering for the ExpressRouteCrossConnection.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param cross_connection_name: The name of the\n         ExpressRouteCrossConnection.\n        :type cross_connection_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteCrossConnectionPeering or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_06_01.models.ExpressRouteCrossConnectionPeering\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30948:c0:m4"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkWatcherPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkWatcherPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all network watchers by resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkWatcher\n        :rtype:\n         ~azure.mgmt.network.v2018_06_01.models.NetworkWatcherPaged[~azure.mgmt.network.v2018_06_01.models.NetworkWatcher]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_06_01.models.ErrorResponseException>`", "id": "f30952:c0:m6"}
{"signature": "def get_azure_reachability_report(<EOL>self, resource_group_name, network_watcher_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_azure_reachability_report_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the relative latency score for internet service providers from a\n        specified location to Azure regions.\n\n        :param resource_group_name: The name of the network watcher resource\n         group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher resource.\n        :type network_watcher_name: str\n        :param parameters: Parameters that determine Azure reachability report\n         configuration.\n        :type parameters:\n         ~azure.mgmt.network.v2018_06_01.models.AzureReachabilityReportParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns AzureReachabilityReport\n         or ClientRawResponse<AzureReachabilityReport> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_06_01.models.AzureReachabilityReport]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_06_01.models.AzureReachabilityReport]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_06_01.models.ErrorResponseException>`", "id": "f30952:c0:m26"}
{"signature": "def delete(<EOL>self, resource_group_name, network_watcher_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified network watcher resource.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_06_01.models.ErrorResponseException>`", "id": "f30952:c0:m4"}
{"signature": "def get_flow_log_status(<EOL>self, resource_group_name, network_watcher_name, target_resource_id, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_flow_log_status_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>target_resource_id=target_resource_id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Queries status of flow log and traffic analytics (optional) on a\n        specified resource.\n\n        :param resource_group_name: The name of the network watcher resource\n         group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher resource.\n        :type network_watcher_name: str\n        :param target_resource_id: The target resource where getting the flow\n         log and traffic analytics (optional) status.\n        :type target_resource_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns FlowLogInformation or\n         ClientRawResponse<FlowLogInformation> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_06_01.models.FlowLogInformation]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_06_01.models.FlowLogInformation]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_06_01.models.ErrorResponseException>`", "id": "f30952:c0:m22"}
{"signature": "def get_troubleshooting(<EOL>self, resource_group_name, network_watcher_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_troubleshooting_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Initiate troubleshooting on a specified resource.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher resource.\n        :type network_watcher_name: str\n        :param parameters: Parameters that define the resource to\n         troubleshoot.\n        :type parameters:\n         ~azure.mgmt.network.v2018_06_01.models.TroubleshootingParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns TroubleshootingResult\n         or ClientRawResponse<TroubleshootingResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_06_01.models.TroubleshootingResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_06_01.models.TroubleshootingResult]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_06_01.models.ErrorResponseException>`", "id": "f30952:c0:m16"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VpnSitePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VpnSitePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all the vpnSites in a resource group.\n\n        :param resource_group_name: The resource group name of the VpnSite.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VpnSite\n        :rtype:\n         ~azure.mgmt.network.v2018_06_01.models.VpnSitePaged[~azure.mgmt.network.v2018_06_01.models.VpnSite]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_06_01.models.ErrorException>`", "id": "f30953:c0:m8"}
{"signature": "def update_tags(<EOL>self, resource_group_name, vpn_site_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>vpn_site_name=vpn_site_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates VpnSite tags.\n\n        :param resource_group_name: The resource group name of the VpnSite.\n        :type resource_group_name: str\n        :param vpn_site_name: The name of the VpnSite being updated.\n        :type vpn_site_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VpnSite or\n         ClientRawResponse<VpnSite> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_06_01.models.VpnSite]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_06_01.models.VpnSite]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_06_01.models.ErrorException>`", "id": "f30953:c0:m5"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VpnSitePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VpnSitePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all the VpnSites in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VpnSite\n        :rtype:\n         ~azure.mgmt.network.v2018_06_01.models.VpnSitePaged[~azure.mgmt.network.v2018_06_01.models.VpnSite]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_06_01.models.ErrorException>`", "id": "f30953:c0:m9"}
{"signature": "def get(<EOL>self, resource_group_name, circuit_name, peering_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", peering_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified peering for the express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteCircuitPeering or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_06_01.models.ExpressRouteCircuitPeering or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30955:c0:m3"}
{"signature": "def delete(<EOL>self, resource_group_name, circuit_name, peering_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>peering_name=peering_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified peering from the specified express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30955:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, route_table_name, route_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_table_name=route_table_name,<EOL>route_name=route_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified route from a route table.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param route_name: The name of the route.\n        :type route_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30957:c0:m2"}
{"signature": "def list(<EOL>self, resource_group_name, route_table_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", route_table_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RoutePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RoutePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all routes in a route table.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Route\n        :rtype:\n         ~azure.mgmt.network.v2018_06_01.models.RoutePaged[~azure.mgmt.network.v2018_06_01.models.Route]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30957:c0:m6"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, route_table_name, route_name, route_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_table_name=route_table_name,<EOL>route_name=route_name,<EOL>route_parameters=route_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a route in the specified route table.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param route_name: The name of the route.\n        :type route_name: str\n        :param route_parameters: Parameters supplied to the create or update\n         route operation.\n        :type route_parameters: ~azure.mgmt.network.v2018_06_01.models.Route\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Route or\n         ClientRawResponse<Route> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_06_01.models.Route]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_06_01.models.Route]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30957:c0:m5"}
{"signature": "def update_tags(<EOL>self, resource_group_name, virtual_network_gateway_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_name=virtual_network_gateway_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a virtual network gateway tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualNetworkGateway\n         or ClientRawResponse<VirtualNetworkGateway> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_06_01.models.VirtualNetworkGateway]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_06_01.models.VirtualNetworkGateway]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30959:c0:m7"}
{"signature": "def get_vpn_profile_package_url(<EOL>self, resource_group_name, virtual_network_gateway_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_vpn_profile_package_url_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_name=virtual_network_gateway_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT:str>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets pre-generated VPN profile for P2S client of the virtual network\n        gateway in the specified resource group. The profile needs to be\n        generated first using generateVpnProfile.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns str or\n         ClientRawResponse<str> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[str] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[str]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30959:c0:m18"}
{"signature": "def reset(<EOL>self, resource_group_name, virtual_network_gateway_name, gateway_vip=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._reset_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_name=virtual_network_gateway_name,<EOL>gateway_vip=gateway_vip,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Resets the primary of the virtual network gateway in the specified\n        resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param gateway_vip: Virtual network gateway vip address supplied to\n         the begin reset of the active-active feature enabled gateway.\n        :type gateway_vip: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualNetworkGateway\n         or ClientRawResponse<VirtualNetworkGateway> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_06_01.models.VirtualNetworkGateway]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_06_01.models.VirtualNetworkGateway]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30959:c0:m11"}
{"signature": "def get(<EOL>self, resource_group_name, load_balancer_name, load_balancing_rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancing_rule_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified load balancer load balancing rule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param load_balancing_rule_name: The name of the load balancing rule.\n        :type load_balancing_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: LoadBalancingRule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_06_01.models.LoadBalancingRule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30960:c0:m2"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, route_filter_name, rule_name, route_filter_rule_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_filter_name=route_filter_name,<EOL>rule_name=rule_name,<EOL>route_filter_rule_parameters=route_filter_rule_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a route in the specified route filter.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param rule_name: The name of the route filter rule.\n        :type rule_name: str\n        :param route_filter_rule_parameters: Parameters supplied to the create\n         or update route filter rule operation.\n        :type route_filter_rule_parameters:\n         ~azure.mgmt.network.v2018_06_01.models.RouteFilterRule\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns RouteFilterRule or\n         ClientRawResponse<RouteFilterRule> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_06_01.models.RouteFilterRule]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_06_01.models.RouteFilterRule]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30961:c0:m5"}
{"signature": "def get(<EOL>self, resource_group_name, route_filter_name, rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", route_filter_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", rule_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified rule from a route filter.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param rule_name: The name of the rule.\n        :type rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RouteFilterRule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_06_01.models.RouteFilterRule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30961:c0:m3"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, gateway_name, connection_name, vpn_connection_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>gateway_name=gateway_name,<EOL>connection_name=connection_name,<EOL>vpn_connection_parameters=vpn_connection_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates a vpn connection to a scalable vpn gateway if it doesn't exist\n        else updates the existing connection.\n\n        :param resource_group_name: The resource group name of the VpnGateway.\n        :type resource_group_name: str\n        :param gateway_name: The name of the gateway.\n        :type gateway_name: str\n        :param connection_name: The name of the connection.\n        :type connection_name: str\n        :param vpn_connection_parameters: Parameters supplied to create or\n         Update a VPN Connection.\n        :type vpn_connection_parameters:\n         ~azure.mgmt.network.v2018_06_01.models.VpnConnection\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VpnConnection or\n         ClientRawResponse<VpnConnection> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_06_01.models.VpnConnection]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_06_01.models.VpnConnection]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_06_01.models.ErrorException>`", "id": "f30962:c0:m3"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all network interfaces in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkInterface\n        :rtype:\n         ~azure.mgmt.network.v2018_06_01.models.NetworkInterfacePaged[~azure.mgmt.network.v2018_06_01.models.NetworkInterface]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30963:c0:m8"}
{"signature": "def list_virtual_machine_scale_set_ip_configurations(<EOL>self, resource_group_name, virtual_machine_scale_set_name, virtualmachine_index, network_interface_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_virtual_machine_scale_set_ip_configurations.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_machine_scale_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtualmachine_index, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_interface_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkInterfaceIPConfigurationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkInterfaceIPConfigurationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the specified network interface ip configuration in a virtual\n        machine scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_machine_scale_set_name: The name of the virtual machine\n         scale set.\n        :type virtual_machine_scale_set_name: str\n        :param virtualmachine_index: The virtual machine index.\n        :type virtualmachine_index: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkInterfaceIPConfiguration\n        :rtype:\n         ~azure.mgmt.network.v2018_06_01.models.NetworkInterfaceIPConfigurationPaged[~azure.mgmt.network.v2018_06_01.models.NetworkInterfaceIPConfiguration]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30963:c0:m17"}
{"signature": "def list_effective_network_security_groups(<EOL>self, resource_group_name, network_interface_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._list_effective_network_security_groups_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_interface_name=network_interface_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets all network security groups applied to a network interface.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         EffectiveNetworkSecurityGroupListResult or\n         ClientRawResponse<EffectiveNetworkSecurityGroupListResult> if\n         raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_06_01.models.EffectiveNetworkSecurityGroupListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_06_01.models.EffectiveNetworkSecurityGroupListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30963:c0:m13"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all network interfaces in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkInterface\n        :rtype:\n         ~azure.mgmt.network.v2018_06_01.models.NetworkInterfacePaged[~azure.mgmt.network.v2018_06_01.models.NetworkInterface]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30963:c0:m9"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, network_interface_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_interface_name=network_interface_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a network interface.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param parameters: Parameters supplied to the create or update network\n         interface operation.\n        :type parameters:\n         ~azure.mgmt.network.v2018_06_01.models.NetworkInterface\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns NetworkInterface or\n         ClientRawResponse<NetworkInterface> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_06_01.models.NetworkInterface]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_06_01.models.NetworkInterface]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30963:c0:m5"}
{"signature": "def delete(<EOL>self, resource_group_name, network_security_group_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_security_group_name=network_security_group_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified network security group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30964:c0:m2"}
{"signature": "def check_dns_name_availability(<EOL>self, location, domain_name_label=None, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.check_dns_name_availability.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if domain_name_label is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", domain_name_label, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Checks whether a domain name in the cloudapp.net zone is available for\n        use.\n\n        :param location: The location of the domain name.\n        :type location: str\n        :param domain_name_label: The domain name to be verified. It must\n         conform to the following regular expression:\n         ^[a-z][a-z0-9-]{1,61}[a-z0-9]$.\n        :type domain_name_label: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DnsNameAvailabilityResult or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2017_03_01.models.DnsNameAvailabilityResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f30965:c1:m1"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.LoadBalancerPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.LoadBalancerPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the load balancers in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of LoadBalancer\n        :rtype:\n         ~azure.mgmt.network.v2017_03_01.models.LoadBalancerPaged[~azure.mgmt.network.v2017_03_01.models.LoadBalancer]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31193:c0:m6"}
{"signature": "def create(<EOL>self, resource_group_name, network_watcher_name, packet_capture_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>packet_capture_name=packet_capture_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Create and start a packet capture on the specified VM.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param packet_capture_name: The name of the packet capture session.\n        :type packet_capture_name: str\n        :param parameters: Parameters that define the create packet capture\n         operation.\n        :type parameters: ~azure.mgmt.network.v2017_03_01.models.PacketCapture\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns PacketCaptureResult or\n         ClientRawResponse<PacketCaptureResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_03_01.models.PacketCaptureResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_03_01.models.PacketCaptureResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31194:c0:m2"}
{"signature": "def stop(<EOL>self, resource_group_name, network_watcher_name, packet_capture_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._stop_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>packet_capture_name=packet_capture_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Stops a specified packet capture session.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param packet_capture_name: The name of the packet capture session.\n        :type packet_capture_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31194:c0:m7"}
{"signature": "def get(<EOL>self, resource_group_name, network_watcher_name, packet_capture_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_watcher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", packet_capture_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a packet capture session by name.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param packet_capture_name: The name of the packet capture session.\n        :type packet_capture_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PacketCaptureResult or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_03_01.models.PacketCaptureResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31194:c0:m3"}
{"signature": "def get_status(<EOL>self, resource_group_name, network_watcher_name, packet_capture_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_status_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>packet_capture_name=packet_capture_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT:location>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Query the status of a running packet capture session.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the Network Watcher resource.\n        :type network_watcher_name: str\n        :param packet_capture_name: The name given to the packet capture\n         session.\n        :type packet_capture_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         PacketCaptureQueryStatusResult or\n         ClientRawResponse<PacketCaptureQueryStatusResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_03_01.models.PacketCaptureQueryStatusResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_03_01.models.PacketCaptureQueryStatusResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31194:c0:m9"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualNetworkGatewayConnectionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualNetworkGatewayConnectionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "The List VirtualNetworkGatewayConnections operation retrieves all the\n        virtual network gateways connections created.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualNetworkGatewayConnection\n        :rtype:\n         ~azure.mgmt.network.v2017_03_01.models.VirtualNetworkGatewayConnectionPaged[~azure.mgmt.network.v2017_03_01.models.VirtualNetworkGatewayConnection]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31195:c0:m9"}
{"signature": "def get(<EOL>self, resource_group_name, virtual_network_gateway_connection_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_gateway_connection_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified virtual network gateway connection by resource\n        group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_connection_name: The name of the\n         virtual network gateway connection.\n        :type virtual_network_gateway_connection_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualNetworkGatewayConnection or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.network.v2017_03_01.models.VirtualNetworkGatewayConnection\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31195:c0:m3"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, virtual_network_gateway_connection_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_connection_name=virtual_network_gateway_connection_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a virtual network gateway connection in the\n        specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_connection_name: The name of the\n         virtual network gateway connection.\n        :type virtual_network_gateway_connection_name: str\n        :param parameters: Parameters supplied to the create or update virtual\n         network gateway connection operation.\n        :type parameters:\n         ~azure.mgmt.network.v2017_03_01.models.VirtualNetworkGatewayConnection\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         VirtualNetworkGatewayConnection or\n         ClientRawResponse<VirtualNetworkGatewayConnection> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_03_01.models.VirtualNetworkGatewayConnection]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_03_01.models.VirtualNetworkGatewayConnection]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31195:c0:m2"}
{"signature": "def reset_shared_key(<EOL>self, resource_group_name, virtual_network_gateway_connection_name, key_length, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._reset_shared_key_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_connection_name=virtual_network_gateway_connection_name,<EOL>key_length=key_length,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The VirtualNetworkGatewayConnectionResetSharedKey operation resets the\n        virtual network gateway connection shared key for passed virtual\n        network gateway connection in the specified resource group through\n        Network resource provider.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_connection_name: The virtual network\n         gateway connection reset shared key Name.\n        :type virtual_network_gateway_connection_name: str\n        :param key_length: The virtual network connection reset shared key\n         length, should between 1 and 128.\n        :type key_length: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ConnectionResetSharedKey or\n         ClientRawResponse<ConnectionResetSharedKey> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_03_01.models.ConnectionResetSharedKey]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_03_01.models.ConnectionResetSharedKey]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31195:c0:m11"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.BgpServiceCommunityPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.BgpServiceCommunityPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the available bgp service communities.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of BgpServiceCommunity\n        :rtype:\n         ~azure.mgmt.network.v2017_03_01.models.BgpServiceCommunityPaged[~azure.mgmt.network.v2017_03_01.models.BgpServiceCommunity]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31196:c0:m1"}
{"signature": "def stop(<EOL>self, resource_group_name, application_gateway_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._stop_initial(<EOL>resource_group_name=resource_group_name,<EOL>application_gateway_name=application_gateway_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Stops the specified application gateway in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param application_gateway_name: The name of the application gateway.\n        :type application_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31197:c0:m11"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ApplicationGatewayPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ApplicationGatewayPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the application gateways in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ApplicationGateway\n        :rtype:\n         ~azure.mgmt.network.v2017_03_01.models.ApplicationGatewayPaged[~azure.mgmt.network.v2017_03_01.models.ApplicationGateway]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31197:c0:m7"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ApplicationGatewayPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ApplicationGatewayPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all application gateways in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ApplicationGateway\n        :rtype:\n         ~azure.mgmt.network.v2017_03_01.models.ApplicationGatewayPaged[~azure.mgmt.network.v2017_03_01.models.ApplicationGateway]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31197:c0:m6"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RouteFilterPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RouteFilterPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all route filters in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of RouteFilter\n        :rtype:\n         ~azure.mgmt.network.v2017_03_01.models.RouteFilterPaged[~azure.mgmt.network.v2017_03_01.models.RouteFilter]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31198:c0:m9"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, route_filter_name, route_filter_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_filter_name=route_filter_name,<EOL>route_filter_parameters=route_filter_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a route filter in a specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param route_filter_parameters: Parameters supplied to the create or\n         update route filter operation.\n        :type route_filter_parameters:\n         ~azure.mgmt.network.v2017_03_01.models.RouteFilter\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns RouteFilter or\n         ClientRawResponse<RouteFilter> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_03_01.models.RouteFilter]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_03_01.models.RouteFilter]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31198:c0:m5"}
{"signature": "def delete(<EOL>self, resource_group_name, virtual_network_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_name=virtual_network_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified virtual network.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31202:c0:m2"}
{"signature": "def list_routes_table(<EOL>self, resource_group_name, circuit_name, peering_name, device_path, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._list_routes_table_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>peering_name=peering_name,<EOL>device_path=device_path,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the currently advertised routes table associated with the express\n        route circuit in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param device_path: The path of the device.\n        :type device_path: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCircuitsRoutesTableListResult or\n         ClientRawResponse<ExpressRouteCircuitsRoutesTableListResult> if\n         raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_03_01.models.ExpressRouteCircuitsRoutesTableListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_03_01.models.ExpressRouteCircuitsRoutesTableListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31203:c0:m9"}
{"signature": "def list_routes_table_summary(<EOL>self, resource_group_name, circuit_name, peering_name, device_path, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._list_routes_table_summary_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>peering_name=peering_name,<EOL>device_path=device_path,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the currently advertised routes table summary associated with the\n        express route circuit in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param device_path: The path of the device.\n        :type device_path: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCircuitsRoutesTableSummaryListResult or\n         ClientRawResponse<ExpressRouteCircuitsRoutesTableSummaryListResult> if\n         raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_03_01.models.ExpressRouteCircuitsRoutesTableSummaryListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_03_01.models.ExpressRouteCircuitsRoutesTableSummaryListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31203:c0:m11"}
{"signature": "def list(<EOL>self, resource_group_name, circuit_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ExpressRouteCircuitAuthorizationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ExpressRouteCircuitAuthorizationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all authorizations in an express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the circuit.\n        :type circuit_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ExpressRouteCircuitAuthorization\n        :rtype:\n         ~azure.mgmt.network.v2017_03_01.models.ExpressRouteCircuitAuthorizationPaged[~azure.mgmt.network.v2017_03_01.models.ExpressRouteCircuitAuthorization]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31204:c0:m6"}
{"signature": "def list(<EOL>self, resource_group_name, network_security_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_security_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SecurityRulePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SecurityRulePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all security rules in a network security group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of SecurityRule\n        :rtype:\n         ~azure.mgmt.network.v2017_03_01.models.SecurityRulePaged[~azure.mgmt.network.v2017_03_01.models.SecurityRule]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31206:c0:m6"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, network_security_group_name, security_rule_name, security_rule_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_security_group_name=network_security_group_name,<EOL>security_rule_name=security_rule_name,<EOL>security_rule_parameters=security_rule_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a security rule in the specified network security\n        group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param security_rule_name: The name of the security rule.\n        :type security_rule_name: str\n        :param security_rule_parameters: Parameters supplied to the create or\n         update network security rule operation.\n        :type security_rule_parameters:\n         ~azure.mgmt.network.v2017_03_01.models.SecurityRule\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns SecurityRule or\n         ClientRawResponse<SecurityRule> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_03_01.models.SecurityRule]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_03_01.models.SecurityRule]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31206:c0:m5"}
{"signature": "def get(<EOL>self, resource_group_name, network_security_group_name, security_rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_security_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", security_rule_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the specified network security rule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param security_rule_name: The name of the security rule.\n        :type security_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SecurityRule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_03_01.models.SecurityRule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31206:c0:m3"}
{"signature": "def get(<EOL>self, resource_group_name, virtual_network_name, subnet_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", subnet_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified subnet by virtual network and resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param subnet_name: The name of the subnet.\n        :type subnet_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Subnet or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_03_01.models.Subnet or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31207:c0:m3"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, network_watcher_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_watcher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or updates a network watcher in the specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param parameters: Parameters that define the network watcher\n         resource.\n        :type parameters:\n         ~azure.mgmt.network.v2017_03_01.models.NetworkWatcher\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: NetworkWatcher or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_03_01.models.NetworkWatcher or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31210:c0:m1"}
{"signature": "def get_vm_security_rules(<EOL>self, resource_group_name, network_watcher_name, target_resource_id, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_vm_security_rules_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>target_resource_id=target_resource_id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the configured and effective security group rules on the specified\n        VM.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param target_resource_id: ID of the target VM.\n        :type target_resource_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns SecurityGroupViewResult\n         or ClientRawResponse<SecurityGroupViewResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_03_01.models.SecurityGroupViewResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_03_01.models.SecurityGroupViewResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31210:c0:m13"}
{"signature": "def get_next_hop(<EOL>self, resource_group_name, network_watcher_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_next_hop_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the next hop from the specified VM.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param parameters: Parameters that define the source and destination\n         endpoint.\n        :type parameters:\n         ~azure.mgmt.network.v2017_03_01.models.NextHopParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns NextHopResult or\n         ClientRawResponse<NextHopResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_03_01.models.NextHopResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_03_01.models.NextHopResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31210:c0:m11"}
{"signature": "def get_troubleshooting(<EOL>self, resource_group_name, network_watcher_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_troubleshooting_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Initiate troubleshooting on a specified resource.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher resource.\n        :type network_watcher_name: str\n        :param parameters: Parameters that define the resource to\n         troubleshoot.\n        :type parameters:\n         ~azure.mgmt.network.v2017_03_01.models.TroubleshootingParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns TroubleshootingResult\n         or ClientRawResponse<TroubleshootingResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_03_01.models.TroubleshootingResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_03_01.models.TroubleshootingResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31210:c0:m15"}
{"signature": "def get_topology(<EOL>self, resource_group_name, network_watcher_name, target_resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.TopologyParameters(target_resource_group_name=target_resource_group_name)<EOL>url = self.get_topology.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_watcher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the current network topology by resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param target_resource_group_name: The name of the target resource\n         group to perform topology on.\n        :type target_resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Topology or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_03_01.models.Topology or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31210:c0:m7"}
{"signature": "def get_flow_log_status(<EOL>self, resource_group_name, network_watcher_name, target_resource_id, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_flow_log_status_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>target_resource_id=target_resource_id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Queries status of flow log on a specified resource.\n\n        :param resource_group_name: The name of the network watcher resource\n         group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher resource.\n        :type network_watcher_name: str\n        :param target_resource_id: The target resource where getting the flow\n         logging status.\n        :type target_resource_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns FlowLogInformation or\n         ClientRawResponse<FlowLogInformation> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_03_01.models.FlowLogInformation]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_03_01.models.FlowLogInformation]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31210:c0:m21"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkWatcherPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkWatcherPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all network watchers by resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkWatcher\n        :rtype:\n         ~azure.mgmt.network.v2017_03_01.models.NetworkWatcherPaged[~azure.mgmt.network.v2017_03_01.models.NetworkWatcher]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31210:c0:m5"}
{"signature": "def list(<EOL>self, location, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>', pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.UsagePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.UsagePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists compute usages for a subscription.\n\n        :param location: The location where resource usage is queried.\n        :type location: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Usage\n        :rtype:\n         ~azure.mgmt.network.v2017_03_01.models.UsagePaged[~azure.mgmt.network.v2017_03_01.models.Usage]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31211:c0:m1"}
{"signature": "def list(<EOL>self, resource_group_name, circuit_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ExpressRouteCircuitPeeringPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ExpressRouteCircuitPeeringPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all peerings in a specified express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ExpressRouteCircuitPeering\n        :rtype:\n         ~azure.mgmt.network.v2017_03_01.models.ExpressRouteCircuitPeeringPaged[~azure.mgmt.network.v2017_03_01.models.ExpressRouteCircuitPeering]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31212:c0:m6"}
{"signature": "def delete(<EOL>self, resource_group_name, route_table_name, route_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_table_name=route_table_name,<EOL>route_name=route_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified route from a route table.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param route_name: The name of the route.\n        :type route_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31213:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, virtual_network_gateway_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_gateway_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified virtual network gateway by resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualNetworkGateway or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_03_01.models.VirtualNetworkGateway\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31214:c0:m3"}
{"signature": "def get_advertised_routes(<EOL>self, resource_group_name, virtual_network_gateway_name, peer, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_advertised_routes_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_name=virtual_network_gateway_name,<EOL>peer=peer,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "This operation retrieves a list of routes the virtual network gateway\n        is advertising to the specified peer.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param peer: The IP address of the peer\n        :type peer: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns GatewayRouteListResult\n         or ClientRawResponse<GatewayRouteListResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_03_01.models.GatewayRouteListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_03_01.models.GatewayRouteListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31214:c0:m15"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, route_filter_name, rule_name, route_filter_rule_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_filter_name=route_filter_name,<EOL>rule_name=rule_name,<EOL>route_filter_rule_parameters=route_filter_rule_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a route in the specified route filter.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param rule_name: The name of the route filter rule.\n        :type rule_name: str\n        :param route_filter_rule_parameters: Parameters supplied to the create\n         or update route filter rule operation.\n        :type route_filter_rule_parameters:\n         ~azure.mgmt.network.v2017_03_01.models.RouteFilterRule\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns RouteFilterRule or\n         ClientRawResponse<RouteFilterRule> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_03_01.models.RouteFilterRule]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_03_01.models.RouteFilterRule]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31215:c0:m5"}
{"signature": "def update(<EOL>self, resource_group_name, route_filter_name, rule_name, route_filter_rule_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_filter_name=route_filter_name,<EOL>rule_name=rule_name,<EOL>route_filter_rule_parameters=route_filter_rule_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a route in the specified route filter.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param rule_name: The name of the route filter rule.\n        :type rule_name: str\n        :param route_filter_rule_parameters: Parameters supplied to the update\n         route filter rule operation.\n        :type route_filter_rule_parameters:\n         ~azure.mgmt.network.v2017_03_01.models.PatchRouteFilterRule\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns RouteFilterRule or\n         ClientRawResponse<RouteFilterRule> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_03_01.models.RouteFilterRule]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_03_01.models.RouteFilterRule]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31215:c0:m7"}
{"signature": "def list_virtual_machine_scale_set_vm_network_interfaces(<EOL>self, resource_group_name, virtual_machine_scale_set_name, virtualmachine_index, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_virtual_machine_scale_set_vm_network_interfaces.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_machine_scale_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtualmachine_index, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about all network interfaces in a virtual machine in a\n        virtual machine scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_machine_scale_set_name: The name of the virtual machine\n         scale set.\n        :type virtual_machine_scale_set_name: str\n        :param virtualmachine_index: The virtual machine index.\n        :type virtualmachine_index: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkInterface\n        :rtype:\n         ~azure.mgmt.network.v2017_03_01.models.NetworkInterfacePaged[~azure.mgmt.network.v2017_03_01.models.NetworkInterface]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31216:c0:m12"}
{"signature": "def list_effective_network_security_groups(<EOL>self, resource_group_name, network_interface_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._list_effective_network_security_groups_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_interface_name=network_interface_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets all network security groups applied to a network interface.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         EffectiveNetworkSecurityGroupListResult or\n         ClientRawResponse<EffectiveNetworkSecurityGroupListResult> if\n         raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_03_01.models.EffectiveNetworkSecurityGroupListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_03_01.models.EffectiveNetworkSecurityGroupListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31216:c0:m11"}
{"signature": "def get(<EOL>self, resource_group_name, network_security_group_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_security_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified network security group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: NetworkSecurityGroup or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_03_01.models.NetworkSecurityGroup or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31217:c0:m3"}
{"signature": "def delete(<EOL>self, resource_group_name, network_security_group_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_security_group_name=network_security_group_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified network security group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31217:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, load_balancer_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>load_balancer_name=load_balancer_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified load balancer.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31646:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, network_interface_name, tap_configuration_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_interface_name=network_interface_name,<EOL>tap_configuration_name=tap_configuration_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified tap configuration from the NetworkInterface.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param tap_configuration_name: The name of the tap configuration.\n        :type tap_configuration_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31647:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, network_interface_name, ip_configuration_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_interface_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", ip_configuration_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified network interface ip configuration.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param ip_configuration_name: The name of the ip configuration name.\n        :type ip_configuration_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: NetworkInterfaceIPConfiguration or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_08_01.models.NetworkInterfaceIPConfiguration\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31648:c0:m2"}
{"signature": "def list(<EOL>self, resource_group_name, network_interface_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_interface_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkInterfaceIPConfigurationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkInterfaceIPConfigurationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get all ip configurations in a network interface.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkInterfaceIPConfiguration\n        :rtype:\n         ~azure.mgmt.network.v2018_08_01.models.NetworkInterfaceIPConfigurationPaged[~azure.mgmt.network.v2018_08_01.models.NetworkInterfaceIPConfiguration]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31648:c0:m1"}
{"signature": "def get(<EOL>self, resource_group_name, express_route_gateway_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", express_route_gateway_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Fetches the details of a ExpressRoute gateway in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param express_route_gateway_name: The name of the ExpressRoute\n         gateway.\n        :type express_route_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteGateway or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_08_01.models.ExpressRouteGateway or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31649:c0:m5"}
{"signature": "def update_tags(<EOL>self, resource_group_name, cross_connection_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>cross_connection_name=cross_connection_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates an express route cross connection tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param cross_connection_name: The name of the cross connection.\n        :type cross_connection_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCrossConnection or\n         ClientRawResponse<ExpressRouteCrossConnection> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_08_01.models.ExpressRouteCrossConnection]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_08_01.models.ExpressRouteCrossConnection]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31650:c0:m7"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.OperationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.OperationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all of the available Network Rest API operations.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Operation\n        :rtype:\n         ~azure.mgmt.network.v2018_08_01.models.OperationPaged[~azure.mgmt.network.v2018_08_01.models.Operation]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31651:c0:m1"}
{"signature": "def list(<EOL>self, resource_group_name, load_balancer_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ProbePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ProbePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the load balancer probes.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Probe\n        :rtype:\n         ~azure.mgmt.network.v2018_08_01.models.ProbePaged[~azure.mgmt.network.v2018_08_01.models.Probe]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31652:c0:m1"}
{"signature": "def list(<EOL>self, resource_group_name, network_watcher_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_watcher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PacketCaptureResultPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PacketCaptureResultPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all packet capture sessions within the specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the Network Watcher resource.\n        :type network_watcher_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PacketCaptureResult\n        :rtype:\n         ~azure.mgmt.network.v2018_08_01.models.PacketCaptureResultPaged[~azure.mgmt.network.v2018_08_01.models.PacketCaptureResult]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_08_01.models.ErrorResponseException>`", "id": "f31653:c0:m10"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualNetworkGatewayConnectionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualNetworkGatewayConnectionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "The List VirtualNetworkGatewayConnections operation retrieves all the\n        virtual network gateways connections created.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualNetworkGatewayConnection\n        :rtype:\n         ~azure.mgmt.network.v2018_08_01.models.VirtualNetworkGatewayConnectionPaged[~azure.mgmt.network.v2018_08_01.models.VirtualNetworkGatewayConnection]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31654:c0:m11"}
{"signature": "def delete(<EOL>self, resource_group_name, express_route_port_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>express_route_port_name=express_route_port_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified ExpressRoutePort resource.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param express_route_port_name: The name of the ExpressRoutePort\n         resource.\n        :type express_route_port_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31655:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, gateway_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>gateway_name=gateway_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes a virtual wan p2s vpn gateway.\n\n        :param resource_group_name: The resource group name of the\n         P2SVpnGateway.\n        :type resource_group_name: str\n        :param gateway_name: The name of the gateway.\n        :type gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_08_01.models.ErrorException>`", "id": "f31657:c0:m7"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.DdosProtectionPlanPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.DdosProtectionPlanPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the DDoS protection plans in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of DdosProtectionPlan\n        :rtype:\n         ~azure.mgmt.network.v2018_08_01.models.DdosProtectionPlanPaged[~azure.mgmt.network.v2018_08_01.models.DdosProtectionPlan]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31658:c0:m7"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, azure_firewall_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>azure_firewall_name=azure_firewall_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates the specified Azure Firewall.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param azure_firewall_name: The name of the Azure Firewall.\n        :type azure_firewall_name: str\n        :param parameters: Parameters supplied to the create or update Azure\n         Firewall operation.\n        :type parameters: ~azure.mgmt.network.v2018_08_01.models.AzureFirewall\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns AzureFirewall or\n         ClientRawResponse<AzureFirewall> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_08_01.models.AzureFirewall]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_08_01.models.AzureFirewall]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31659:c0:m5"}
{"signature": "def delete(<EOL>self, resource_group_name, azure_firewall_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>azure_firewall_name=azure_firewall_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified Azure Firewall.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param azure_firewall_name: The name of the Azure Firewall.\n        :type azure_firewall_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31659:c0:m2"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.AzureFirewallPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.AzureFirewallPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the Azure Firewalls in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of AzureFirewall\n        :rtype:\n         ~azure.mgmt.network.v2018_08_01.models.AzureFirewallPaged[~azure.mgmt.network.v2018_08_01.models.AzureFirewall]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31659:c0:m7"}
{"signature": "def list_available_ssl_options(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_available_ssl_options.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists available Ssl options for configuring Ssl policy.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ApplicationGatewayAvailableSslOptions or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_08_01.models.ApplicationGatewayAvailableSslOptions\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31660:c0:m17"}
{"signature": "def backend_health(<EOL>self, resource_group_name, application_gateway_name, expand=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._backend_health_initial(<EOL>resource_group_name=resource_group_name,<EOL>application_gateway_name=application_gateway_name,<EOL>expand=expand,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the backend health of the specified application gateway in a\n        resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param application_gateway_name: The name of the application gateway.\n        :type application_gateway_name: str\n        :param expand: Expands BackendAddressPool and BackendHttpSettings\n         referenced in backend health.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ApplicationGatewayBackendHealth or\n         ClientRawResponse<ApplicationGatewayBackendHealth> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_08_01.models.ApplicationGatewayBackendHealth]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_08_01.models.ApplicationGatewayBackendHealth]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31660:c0:m15"}
{"signature": "def start(<EOL>self, resource_group_name, application_gateway_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._start_initial(<EOL>resource_group_name=resource_group_name,<EOL>application_gateway_name=application_gateway_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Starts the specified application gateway.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param application_gateway_name: The name of the application gateway.\n        :type application_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31660:c0:m11"}
{"signature": "def list_available_ssl_predefined_policies(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_available_ssl_predefined_policies.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ApplicationGatewaySslPredefinedPolicyPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ApplicationGatewaySslPredefinedPolicyPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all SSL predefined policies for configuring Ssl policy.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of\n         ApplicationGatewaySslPredefinedPolicy\n        :rtype:\n         ~azure.mgmt.network.v2018_08_01.models.ApplicationGatewaySslPredefinedPolicyPaged[~azure.mgmt.network.v2018_08_01.models.ApplicationGatewaySslPredefinedPolicy]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31660:c0:m18"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ApplicationGatewayPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ApplicationGatewayPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all application gateways in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ApplicationGateway\n        :rtype:\n         ~azure.mgmt.network.v2018_08_01.models.ApplicationGatewayPaged[~azure.mgmt.network.v2018_08_01.models.ApplicationGateway]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31660:c0:m8"}
{"signature": "def delete(<EOL>self, resource_group_name, application_gateway_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>application_gateway_name=application_gateway_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified application gateway.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param application_gateway_name: The name of the application gateway.\n        :type application_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31660:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, network_profile_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_profile_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified network profile in a specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_profile_name: The name of the Public IP Prefix.\n        :type network_profile_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: NetworkProfile or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_08_01.models.NetworkProfile or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31661:c0:m3"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, service_endpoint_policy_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", service_endpoint_policy_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ServiceEndpointPolicyDefinitionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ServiceEndpointPolicyDefinitionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all service endpoint policy definitions in a service end point\n        policy.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param service_endpoint_policy_name: The name of the service endpoint\n         policy name.\n        :type service_endpoint_policy_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ServiceEndpointPolicyDefinition\n        :rtype:\n         ~azure.mgmt.network.v2018_08_01.models.ServiceEndpointPolicyDefinitionPaged[~azure.mgmt.network.v2018_08_01.models.ServiceEndpointPolicyDefinition]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31662:c0:m6"}
{"signature": "def update(<EOL>self, resource_group_name, route_filter_name, route_filter_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_filter_name=route_filter_name,<EOL>route_filter_parameters=route_filter_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a route filter in a specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param route_filter_parameters: Parameters supplied to the update\n         route filter operation.\n        :type route_filter_parameters:\n         ~azure.mgmt.network.v2018_08_01.models.PatchRouteFilter\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns RouteFilter or\n         ClientRawResponse<RouteFilter> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_08_01.models.RouteFilter]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_08_01.models.RouteFilter]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31663:c0:m7"}
{"signature": "def list(<EOL>self, resource_group_name, network_watcher_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_watcher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ConnectionMonitorResultPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ConnectionMonitorResultPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all connection monitors for the specified Network Watcher.\n\n        :param resource_group_name: The name of the resource group containing\n         Network Watcher.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the Network Watcher resource.\n        :type network_watcher_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ConnectionMonitorResult\n        :rtype:\n         ~azure.mgmt.network.v2018_08_01.models.ConnectionMonitorResultPaged[~azure.mgmt.network.v2018_08_01.models.ConnectionMonitorResult]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_08_01.models.ErrorResponseException>`", "id": "f31665:c0:m12"}
{"signature": "def start(<EOL>self, resource_group_name, network_watcher_name, connection_monitor_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._start_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>connection_monitor_name=connection_monitor_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Starts the specified connection monitor.\n\n        :param resource_group_name: The name of the resource group containing\n         Network Watcher.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the Network Watcher resource.\n        :type network_watcher_name: str\n        :param connection_monitor_name: The name of the connection monitor.\n        :type connection_monitor_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_08_01.models.ErrorResponseException>`", "id": "f31665:c0:m9"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, local_network_gateway_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>local_network_gateway_name=local_network_gateway_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a local network gateway in the specified resource\n        group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param local_network_gateway_name: The name of the local network\n         gateway.\n        :type local_network_gateway_name: str\n        :param parameters: Parameters supplied to the create or update local\n         network gateway operation.\n        :type parameters:\n         ~azure.mgmt.network.v2018_08_01.models.LocalNetworkGateway\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns LocalNetworkGateway or\n         ClientRawResponse<LocalNetworkGateway> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_08_01.models.LocalNetworkGateway]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_08_01.models.LocalNetworkGateway]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31666:c0:m2"}
{"signature": "def download(<EOL>self, resource_group_name, virtual_wan_name, vpn_sites=None, output_blob_sas_url=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._download_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_wan_name=virtual_wan_name,<EOL>vpn_sites=vpn_sites,<EOL>output_blob_sas_url=output_blob_sas_url,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gives the sas-url to download the configurations for vpn-sites in a\n        resource group.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param virtual_wan_name: The name of the VirtualWAN for which\n         configuration of all vpn-sites is needed.\n        :type virtual_wan_name: str\n        :param vpn_sites: List of resource-ids of the vpn-sites for which\n         config is to be downloaded.\n        :type vpn_sites: list[str]\n        :param output_blob_sas_url: The sas-url to download the configurations\n         for vpn-sites\n        :type output_blob_sas_url: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_08_01.models.ErrorException>`", "id": "f31667:c0:m2"}
{"signature": "def update_tags(<EOL>self, resource_group_name, tap_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>tap_name=tap_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates an VirtualNetworkTap tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param tap_name: The name of the tap.\n        :type tap_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualNetworkTap or\n         ClientRawResponse<VirtualNetworkTap> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_08_01.models.VirtualNetworkTap]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_08_01.models.VirtualNetworkTap]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31668:c0:m7"}
{"signature": "def get(<EOL>self, resource_group_name, tap_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", tap_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about the specified virtual network tap.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param tap_name: The name of virtual network tap.\n        :type tap_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualNetworkTap or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_08_01.models.VirtualNetworkTap or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31668:c0:m3"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualNetworkTapPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualNetworkTapPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the VirtualNetworkTaps in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualNetworkTap\n        :rtype:\n         ~azure.mgmt.network.v2018_08_01.models.VirtualNetworkTapPaged[~azure.mgmt.network.v2018_08_01.models.VirtualNetworkTap]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31668:c0:m8"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VpnGatewayPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VpnGatewayPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all the VpnGateways in a resource group.\n\n        :param resource_group_name: The resource group name of the VpnGateway.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VpnGateway\n        :rtype:\n         ~azure.mgmt.network.v2018_08_01.models.VpnGatewayPaged[~azure.mgmt.network.v2018_08_01.models.VpnGateway]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_08_01.models.ErrorException>`", "id": "f31670:c0:m8"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, gateway_name, vpn_gateway_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>gateway_name=gateway_name,<EOL>vpn_gateway_parameters=vpn_gateway_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates a virtual wan vpn gateway if it doesn't exist else updates the\n        existing gateway.\n\n        :param resource_group_name: The resource group name of the VpnGateway.\n        :type resource_group_name: str\n        :param gateway_name: The name of the gateway.\n        :type gateway_name: str\n        :param vpn_gateway_parameters: Parameters supplied to create or Update\n         a virtual wan vpn gateway.\n        :type vpn_gateway_parameters:\n         ~azure.mgmt.network.v2018_08_01.models.VpnGateway\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VpnGateway or\n         ClientRawResponse<VpnGateway> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_08_01.models.VpnGateway]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_08_01.models.VpnGateway]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_08_01.models.ErrorException>`", "id": "f31670:c0:m3"}
{"signature": "def delete(<EOL>self, resource_group_name, route_table_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_table_name=route_table_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified route table.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31671:c0:m2"}
{"signature": "def update_tags(<EOL>self, resource_group_name, route_table_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_table_name=route_table_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a route table tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns RouteTable or\n         ClientRawResponse<RouteTable> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_08_01.models.RouteTable]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_08_01.models.RouteTable]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31671:c0:m7"}
{"signature": "def get(<EOL>self, resource_group_name, interface_endpoint_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", interface_endpoint_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified interface endpoint by resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param interface_endpoint_name: The name of the interface endpoint.\n        :type interface_endpoint_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: InterfaceEndpoint or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_08_01.models.InterfaceEndpoint or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31673:c0:m3"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, circuit_name, peering_name, connection_name, express_route_circuit_connection_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>peering_name=peering_name,<EOL>connection_name=connection_name,<EOL>express_route_circuit_connection_parameters=express_route_circuit_connection_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a Express Route Circuit Connection in the specified\n        express route circuits.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param connection_name: The name of the express route circuit\n         connection.\n        :type connection_name: str\n        :param express_route_circuit_connection_parameters: Parameters\n         supplied to the create or update express route circuit connection\n         operation.\n        :type express_route_circuit_connection_parameters:\n         ~azure.mgmt.network.v2018_08_01.models.ExpressRouteCircuitConnection\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCircuitConnection or\n         ClientRawResponse<ExpressRouteCircuitConnection> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_08_01.models.ExpressRouteCircuitConnection]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_08_01.models.ExpressRouteCircuitConnection]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31674:c0:m5"}
{"signature": "def list_usage(<EOL>self, resource_group_name, virtual_network_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_usage.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualNetworkUsagePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualNetworkUsagePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists usage stats.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualNetworkUsage\n        :rtype:\n         ~azure.mgmt.network.v2018_08_01.models.VirtualNetworkUsagePaged[~azure.mgmt.network.v2018_08_01.models.VirtualNetworkUsage]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31676:c0:m11"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualNetworkPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualNetworkPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all virtual networks in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualNetwork\n        :rtype:\n         ~azure.mgmt.network.v2018_08_01.models.VirtualNetworkPaged[~azure.mgmt.network.v2018_08_01.models.VirtualNetwork]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31676:c0:m8"}
{"signature": "def delete(<EOL>self, resource_group_name, virtual_network_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_name=virtual_network_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified virtual network.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31676:c0:m2"}
{"signature": "def check_ip_address_availability(<EOL>self, resource_group_name, virtual_network_name, ip_address, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.check_ip_address_availability.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", ip_address, '<STR_LIT:str>')<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Checks whether a private IP address is available for use.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param ip_address: The private IP address to be verified.\n        :type ip_address: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: IPAddressAvailabilityResult or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_08_01.models.IPAddressAvailabilityResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31676:c0:m10"}
{"signature": "def get(<EOL>self, resource_group_name, load_balancer_name, inbound_nat_rule_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", inbound_nat_rule_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified load balancer inbound nat rule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param inbound_nat_rule_name: The name of the inbound nat rule.\n        :type inbound_nat_rule_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: InboundNatRule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_08_01.models.InboundNatRule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31677:c0:m4"}
{"signature": "def delete(<EOL>self, resource_group_name, load_balancer_name, inbound_nat_rule_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>load_balancer_name=load_balancer_name,<EOL>inbound_nat_rule_name=inbound_nat_rule_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified load balancer inbound nat rule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param inbound_nat_rule_name: The name of the inbound nat rule.\n        :type inbound_nat_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31677:c0:m3"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ExpressRouteCircuitPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ExpressRouteCircuitPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the express route circuits in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ExpressRouteCircuit\n        :rtype:\n         ~azure.mgmt.network.v2018_08_01.models.ExpressRouteCircuitPaged[~azure.mgmt.network.v2018_08_01.models.ExpressRouteCircuit]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31678:c0:m16"}
{"signature": "def list_arp_table(<EOL>self, resource_group_name, circuit_name, peering_name, device_path, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._list_arp_table_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>peering_name=peering_name,<EOL>device_path=device_path,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the currently advertised ARP table associated with the express\n        route circuit in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param device_path: The path of the device.\n        :type device_path: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCircuitsArpTableListResult or\n         ClientRawResponse<ExpressRouteCircuitsArpTableListResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_08_01.models.ExpressRouteCircuitsArpTableListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_08_01.models.ExpressRouteCircuitsArpTableListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31678:c0:m9"}
{"signature": "def get(<EOL>self, resource_group_name, circuit_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about the specified express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of express route circuit.\n        :type circuit_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteCircuit or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_08_01.models.ExpressRouteCircuit or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31678:c0:m3"}
{"signature": "def update_tags(<EOL>self, resource_group_name, public_ip_prefix_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>public_ip_prefix_name=public_ip_prefix_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates public IP prefix tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param public_ip_prefix_name: The name of the public IP prefix.\n        :type public_ip_prefix_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns PublicIPPrefix or\n         ClientRawResponse<PublicIPPrefix> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_08_01.models.PublicIPPrefix]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_08_01.models.PublicIPPrefix]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31679:c0:m7"}
{"signature": "def get(<EOL>self, resource_group_name, public_ip_prefix_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", public_ip_prefix_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified public IP prefix in a specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param public_ip_prefix_name: The name of the Public IP Prefix.\n        :type public_ip_prefix_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PublicIPPrefix or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_08_01.models.PublicIPPrefix or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31679:c0:m3"}
{"signature": "def delete(<EOL>self, resource_group_name, network_security_group_name, security_rule_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_security_group_name=network_security_group_name,<EOL>security_rule_name=security_rule_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified network security rule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param security_rule_name: The name of the security rule.\n        :type security_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31684:c0:m2"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, network_security_group_name, security_rule_name, security_rule_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_security_group_name=network_security_group_name,<EOL>security_rule_name=security_rule_name,<EOL>security_rule_parameters=security_rule_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a security rule in the specified network security\n        group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param security_rule_name: The name of the security rule.\n        :type security_rule_name: str\n        :param security_rule_parameters: Parameters supplied to the create or\n         update network security rule operation.\n        :type security_rule_parameters:\n         ~azure.mgmt.network.v2018_08_01.models.SecurityRule\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns SecurityRule or\n         ClientRawResponse<SecurityRule> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_08_01.models.SecurityRule]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_08_01.models.SecurityRule]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31684:c0:m5"}
{"signature": "def get(<EOL>self, location_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", location_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves a single ExpressRoutePort peering location, including the\n        list of available bandwidths available at said peering location.\n\n        :param location_name: Name of the requested ExpressRoutePort peering\n         location.\n        :type location_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRoutePortsLocation or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_08_01.models.ExpressRoutePortsLocation or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31685:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, virtual_network_name, subnet_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_name=virtual_network_name,<EOL>subnet_name=subnet_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified subnet.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param subnet_name: The name of the subnet.\n        :type subnet_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31686:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, virtual_network_name, subnet_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", subnet_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified subnet by virtual network and resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param subnet_name: The name of the subnet.\n        :type subnet_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Subnet or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_08_01.models.Subnet or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31686:c0:m3"}
{"signature": "def list(<EOL>self, location, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.AvailableDelegationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.AvailableDelegationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all of the available subnet delegations for this resource group in\n        this region.\n\n        :param location: The location of the domain name.\n        :type location: str\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of AvailableDelegation\n        :rtype:\n         ~azure.mgmt.network.v2018_08_01.models.AvailableDelegationPaged[~azure.mgmt.network.v2018_08_01.models.AvailableDelegation]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31687:c0:m1"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PublicIPAddressPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PublicIPAddressPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the public IP addresses in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PublicIPAddress\n        :rtype:\n         ~azure.mgmt.network.v2018_08_01.models.PublicIPAddressPaged[~azure.mgmt.network.v2018_08_01.models.PublicIPAddress]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31688:c0:m8"}
{"signature": "def get(<EOL>self, resource_group_name, public_ip_address_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", public_ip_address_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified public IP address in a specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param public_ip_address_name: The name of the subnet.\n        :type public_ip_address_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PublicIPAddress or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_08_01.models.PublicIPAddress or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31688:c0:m3"}
{"signature": "def list(<EOL>self, resource_group_name, cross_connection_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", cross_connection_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ExpressRouteCrossConnectionPeeringPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ExpressRouteCrossConnectionPeeringPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all peerings in a specified ExpressRouteCrossConnection.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param cross_connection_name: The name of the\n         ExpressRouteCrossConnection.\n        :type cross_connection_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of\n         ExpressRouteCrossConnectionPeering\n        :rtype:\n         ~azure.mgmt.network.v2018_08_01.models.ExpressRouteCrossConnectionPeeringPaged[~azure.mgmt.network.v2018_08_01.models.ExpressRouteCrossConnectionPeering]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31689:c0:m1"}
{"signature": "def delete(<EOL>self, resource_group_name, cross_connection_name, peering_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>cross_connection_name=cross_connection_name,<EOL>peering_name=peering_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified peering from the ExpressRouteCrossConnection.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param cross_connection_name: The name of the\n         ExpressRouteCrossConnection.\n        :type cross_connection_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31689:c0:m3"}
{"signature": "def list(<EOL>self, resource_group_name, load_balancer_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets associated load balancer network interfaces.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkInterface\n        :rtype:\n         ~azure.mgmt.network.v2018_08_01.models.NetworkInterfacePaged[~azure.mgmt.network.v2018_08_01.models.NetworkInterface]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31691:c0:m1"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, express_route_gateway_name, connection_name, put_express_route_connection_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>express_route_gateway_name=express_route_gateway_name,<EOL>connection_name=connection_name,<EOL>put_express_route_connection_parameters=put_express_route_connection_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates a connection between an ExpressRoute gateway and an\n        ExpressRoute circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param express_route_gateway_name: The name of the ExpressRoute\n         gateway.\n        :type express_route_gateway_name: str\n        :param connection_name: The name of the connection subresource.\n        :type connection_name: str\n        :param put_express_route_connection_parameters: Parameters required in\n         an ExpressRouteConnection PUT operation.\n        :type put_express_route_connection_parameters:\n         ~azure.mgmt.network.v2018_08_01.models.ExpressRouteConnection\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ExpressRouteConnection\n         or ClientRawResponse<ExpressRouteConnection> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_08_01.models.ExpressRouteConnection]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_08_01.models.ExpressRouteConnection]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31692:c0:m2"}
{"signature": "def get_troubleshooting_result(<EOL>self, resource_group_name, network_watcher_name, target_resource_id, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_troubleshooting_result_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>target_resource_id=target_resource_id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Get the last completed troubleshooting result on a specified resource.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher resource.\n        :type network_watcher_name: str\n        :param target_resource_id: The target resource ID to query the\n         troubleshooting result.\n        :type target_resource_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns TroubleshootingResult\n         or ClientRawResponse<TroubleshootingResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_08_01.models.TroubleshootingResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_08_01.models.TroubleshootingResult]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_08_01.models.ErrorResponseException>`", "id": "f31694:c0:m18"}
{"signature": "def get_vm_security_rules(<EOL>self, resource_group_name, network_watcher_name, target_resource_id, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_vm_security_rules_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>target_resource_id=target_resource_id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the configured and effective security group rules on the specified\n        VM.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param target_resource_id: ID of the target VM.\n        :type target_resource_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns SecurityGroupViewResult\n         or ClientRawResponse<SecurityGroupViewResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_08_01.models.SecurityGroupViewResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_08_01.models.SecurityGroupViewResult]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_08_01.models.ErrorResponseException>`", "id": "f31694:c0:m14"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkWatcherPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkWatcherPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all network watchers by resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkWatcher\n        :rtype:\n         ~azure.mgmt.network.v2018_08_01.models.NetworkWatcherPaged[~azure.mgmt.network.v2018_08_01.models.NetworkWatcher]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_08_01.models.ErrorResponseException>`", "id": "f31694:c0:m6"}
{"signature": "def get_network_configuration_diagnostic(<EOL>self, resource_group_name, network_watcher_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_network_configuration_diagnostic_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT:location>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Get network configuration diagnostic.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param parameters: Parameters to get network configuration diagnostic.\n        :type parameters:\n         ~azure.mgmt.network.v2018_08_01.models.NetworkConfigurationDiagnosticParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         NetworkConfigurationDiagnosticResponse or\n         ClientRawResponse<NetworkConfigurationDiagnosticResponse> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_08_01.models.NetworkConfigurationDiagnosticResponse]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_08_01.models.NetworkConfigurationDiagnosticResponse]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_08_01.models.ErrorResponseException>`", "id": "f31694:c0:m30"}
{"signature": "def get(<EOL>self, resource_group_name, network_watcher_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_watcher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified network watcher by resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: NetworkWatcher or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_08_01.models.NetworkWatcher or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_08_01.models.ErrorResponseException>`", "id": "f31694:c0:m2"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, vpn_site_name, vpn_site_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>vpn_site_name=vpn_site_name,<EOL>vpn_site_parameters=vpn_site_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates a VpnSite resource if it doesn't exist else updates the\n        existing VpnSite.\n\n        :param resource_group_name: The resource group name of the VpnSite.\n        :type resource_group_name: str\n        :param vpn_site_name: The name of the VpnSite being created or\n         updated.\n        :type vpn_site_name: str\n        :param vpn_site_parameters: Parameters supplied to create or update\n         VpnSite.\n        :type vpn_site_parameters:\n         ~azure.mgmt.network.v2018_08_01.models.VpnSite\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VpnSite or\n         ClientRawResponse<VpnSite> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_08_01.models.VpnSite]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_08_01.models.VpnSite]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_08_01.models.ErrorException>`", "id": "f31695:c0:m3"}
{"signature": "def update_tags(<EOL>self, resource_group_name, vpn_site_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>vpn_site_name=vpn_site_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates VpnSite tags.\n\n        :param resource_group_name: The resource group name of the VpnSite.\n        :type resource_group_name: str\n        :param vpn_site_name: The name of the VpnSite being updated.\n        :type vpn_site_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VpnSite or\n         ClientRawResponse<VpnSite> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_08_01.models.VpnSite]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_08_01.models.VpnSite]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_08_01.models.ErrorException>`", "id": "f31695:c0:m5"}
{"signature": "def get(<EOL>self, resource_group_name, service_endpoint_policy_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", service_endpoint_policy_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified service Endpoint Policies in a specified resource\n        group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param service_endpoint_policy_name: The name of the service endpoint\n         policy.\n        :type service_endpoint_policy_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ServiceEndpointPolicy or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_08_01.models.ServiceEndpointPolicy\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31697:c0:m3"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualWANPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualWANPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all the VirtualWANs in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualWAN\n        :rtype:\n         ~azure.mgmt.network.v2018_08_01.models.VirtualWANPaged[~azure.mgmt.network.v2018_08_01.models.VirtualWAN]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_08_01.models.ErrorException>`", "id": "f31698:c0:m9"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualWANPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualWANPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all the VirtualWANs in a resource group.\n\n        :param resource_group_name: The resource group name of the VirtualWan.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualWAN\n        :rtype:\n         ~azure.mgmt.network.v2018_08_01.models.VirtualWANPaged[~azure.mgmt.network.v2018_08_01.models.VirtualWAN]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_08_01.models.ErrorException>`", "id": "f31698:c0:m8"}
{"signature": "def get(<EOL>self, resource_group_name, circuit_name, peering_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", peering_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified peering for the express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteCircuitPeering or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_08_01.models.ExpressRouteCircuitPeering or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31699:c0:m3"}
{"signature": "def list(<EOL>self, resource_group_name, circuit_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ExpressRouteCircuitPeeringPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ExpressRouteCircuitPeeringPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all peerings in a specified express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ExpressRouteCircuitPeering\n        :rtype:\n         ~azure.mgmt.network.v2018_08_01.models.ExpressRouteCircuitPeeringPaged[~azure.mgmt.network.v2018_08_01.models.ExpressRouteCircuitPeering]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31699:c0:m6"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, virtual_wan_name, p2_svpn_server_configuration_name, p2_svpn_server_configuration_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_wan_name=virtual_wan_name,<EOL>p2_svpn_server_configuration_name=p2_svpn_server_configuration_name,<EOL>p2_svpn_server_configuration_parameters=p2_svpn_server_configuration_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates a P2SVpnServerConfiguration to associate with a VirtualWan if\n        it doesn't exist else updates the existing P2SVpnServerConfiguration.\n\n        :param resource_group_name: The resource group name of the VirtualWan.\n        :type resource_group_name: str\n        :param virtual_wan_name: The name of the VirtualWan.\n        :type virtual_wan_name: str\n        :param p2_svpn_server_configuration_name: The name of the\n         P2SVpnServerConfiguration.\n        :type p2_svpn_server_configuration_name: str\n        :param p2_svpn_server_configuration_parameters: Parameters supplied to\n         create or Update a P2SVpnServerConfiguration.\n        :type p2_svpn_server_configuration_parameters:\n         ~azure.mgmt.network.v2018_08_01.models.P2SVpnServerConfiguration\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         P2SVpnServerConfiguration or\n         ClientRawResponse<P2SVpnServerConfiguration> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_08_01.models.P2SVpnServerConfiguration]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_08_01.models.P2SVpnServerConfiguration]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_08_01.models.ErrorException>`", "id": "f31700:c0:m3"}
{"signature": "def get(<EOL>self, resource_group_name, virtual_wan_name, p2_svpn_server_configuration_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_wan_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", p2_svpn_server_configuration_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves the details of a P2SVpnServerConfiguration.\n\n        :param resource_group_name: The resource group name of the\n         P2SVpnServerConfiguration.\n        :type resource_group_name: str\n        :param virtual_wan_name: The name of the VirtualWan.\n        :type virtual_wan_name: str\n        :param p2_svpn_server_configuration_name: The name of the\n         P2SVpnServerConfiguration.\n        :type p2_svpn_server_configuration_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: P2SVpnServerConfiguration or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_08_01.models.P2SVpnServerConfiguration or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_08_01.models.ErrorException>`", "id": "f31700:c0:m1"}
{"signature": "def list(<EOL>self, resource_group_name, load_balancer_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.FrontendIPConfigurationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.FrontendIPConfigurationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the load balancer frontend IP configurations.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of FrontendIPConfiguration\n        :rtype:\n         ~azure.mgmt.network.v2018_08_01.models.FrontendIPConfigurationPaged[~azure.mgmt.network.v2018_08_01.models.FrontendIPConfiguration]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31701:c0:m1"}
{"signature": "def list(<EOL>self, resource_group_name, route_table_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", route_table_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RoutePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RoutePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all routes in a route table.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Route\n        :rtype:\n         ~azure.mgmt.network.v2018_08_01.models.RoutePaged[~azure.mgmt.network.v2018_08_01.models.Route]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31702:c0:m6"}
{"signature": "def get(<EOL>self, resource_group_name, virtual_hub_name, connection_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_hub_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", connection_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves the details of a HubVirtualNetworkConnection.\n\n        :param resource_group_name: The resource group name of the VirtualHub.\n        :type resource_group_name: str\n        :param virtual_hub_name: The name of the VirtualHub.\n        :type virtual_hub_name: str\n        :param connection_name: The name of the vpn connection.\n        :type connection_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: HubVirtualNetworkConnection or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_08_01.models.HubVirtualNetworkConnection or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_08_01.models.ErrorException>`", "id": "f31703:c0:m1"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualNetworkGatewayPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualNetworkGatewayPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all virtual network gateways by resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualNetworkGateway\n        :rtype:\n         ~azure.mgmt.network.v2018_08_01.models.VirtualNetworkGatewayPaged[~azure.mgmt.network.v2018_08_01.models.VirtualNetworkGateway]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31705:c0:m8"}
{"signature": "def generatevpnclientpackage(<EOL>self, resource_group_name, virtual_network_gateway_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._generatevpnclientpackage_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_name=virtual_network_gateway_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT:str>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT:location>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Generates VPN client package for P2S client of the virtual network\n        gateway in the specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param parameters: Parameters supplied to the generate virtual network\n         gateway VPN client package operation.\n        :type parameters:\n         ~azure.mgmt.network.v2018_08_01.models.VpnClientParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns str or\n         ClientRawResponse<str> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[str] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[str]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31705:c0:m15"}
{"signature": "def delete(<EOL>self, resource_group_name, virtual_network_gateway_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_name=virtual_network_gateway_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified virtual network gateway.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31705:c0:m5"}
{"signature": "def vpn_device_configuration_script(<EOL>self, resource_group_name, virtual_network_gateway_connection_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.vpn_device_configuration_script.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_gateway_connection_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT:str>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a xml format representation for vpn device configuration script.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_connection_name: The name of the\n         virtual network gateway connection for which the configuration script\n         is generated.\n        :type virtual_network_gateway_connection_name: str\n        :param parameters: Parameters supplied to the generate vpn device\n         script operation.\n        :type parameters:\n         ~azure.mgmt.network.v2018_08_01.models.VpnDeviceScriptParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: str or ClientRawResponse if raw=true\n        :rtype: str or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31705:c0:m30"}
{"signature": "def get(<EOL>self, resource_group_name, route_filter_name, rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", route_filter_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", rule_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified rule from a route filter.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param rule_name: The name of the rule.\n        :type rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RouteFilterRule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_08_01.models.RouteFilterRule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31707:c0:m3"}
{"signature": "def get(<EOL>self, resource_group_name, gateway_name, connection_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", gateway_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", connection_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves the details of a vpn connection.\n\n        :param resource_group_name: The resource group name of the VpnGateway.\n        :type resource_group_name: str\n        :param gateway_name: The name of the gateway.\n        :type gateway_name: str\n        :param connection_name: The name of the vpn connection.\n        :type connection_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VpnConnection or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_08_01.models.VpnConnection or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_08_01.models.ErrorException>`", "id": "f31708:c0:m1"}
{"signature": "def list_by_vpn_gateway(<EOL>self, resource_group_name, gateway_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_vpn_gateway.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", gateway_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VpnConnectionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VpnConnectionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves all vpn connections for a particular virtual wan vpn gateway.\n\n        :param resource_group_name: The resource group name of the VpnGateway.\n        :type resource_group_name: str\n        :param gateway_name: The name of the gateway.\n        :type gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VpnConnection\n        :rtype:\n         ~azure.mgmt.network.v2018_08_01.models.VpnConnectionPaged[~azure.mgmt.network.v2018_08_01.models.VpnConnection]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_08_01.models.ErrorException>`", "id": "f31708:c0:m6"}
{"signature": "def list_virtual_machine_scale_set_network_interfaces(<EOL>self, resource_group_name, virtual_machine_scale_set_name, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_virtual_machine_scale_set_network_interfaces.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_machine_scale_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all network interfaces in a virtual machine scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_machine_scale_set_name: The name of the virtual machine\n         scale set.\n        :type virtual_machine_scale_set_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkInterface\n        :rtype:\n         ~azure.mgmt.network.v2018_08_01.models.NetworkInterfacePaged[~azure.mgmt.network.v2018_08_01.models.NetworkInterface]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31709:c0:m15"}
{"signature": "def list_virtual_machine_scale_set_ip_configurations(<EOL>self, resource_group_name, virtual_machine_scale_set_name, virtualmachine_index, network_interface_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_virtual_machine_scale_set_ip_configurations.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_machine_scale_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtualmachine_index, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_interface_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkInterfaceIPConfigurationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkInterfaceIPConfigurationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the specified network interface ip configuration in a virtual\n        machine scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_machine_scale_set_name: The name of the virtual machine\n         scale set.\n        :type virtual_machine_scale_set_name: str\n        :param virtualmachine_index: The virtual machine index.\n        :type virtualmachine_index: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkInterfaceIPConfiguration\n        :rtype:\n         ~azure.mgmt.network.v2018_08_01.models.NetworkInterfaceIPConfigurationPaged[~azure.mgmt.network.v2018_08_01.models.NetworkInterfaceIPConfiguration]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31709:c0:m17"}
{"signature": "def update_tags(<EOL>self, resource_group_name, network_interface_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_interface_name=network_interface_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a network interface tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns NetworkInterface or\n         ClientRawResponse<NetworkInterface> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_08_01.models.NetworkInterface]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_08_01.models.NetworkInterface]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31709:c0:m7"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, network_security_group_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_security_group_name=network_security_group_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a network security group in the specified resource\n        group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param parameters: Parameters supplied to the create or update network\n         security group operation.\n        :type parameters:\n         ~azure.mgmt.network.v2018_08_01.models.NetworkSecurityGroup\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns NetworkSecurityGroup or\n         ClientRawResponse<NetworkSecurityGroup> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_08_01.models.NetworkSecurityGroup]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_08_01.models.NetworkSecurityGroup]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31710:c0:m5"}
{"signature": "def list(<EOL>self, resource_group_name, network_interface_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_interface_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkInterfaceIPConfigurationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkInterfaceIPConfigurationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get all ip configurations in a network interface.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkInterfaceIPConfiguration\n        :rtype:\n         ~azure.mgmt.network.v2018_01_01.models.NetworkInterfaceIPConfigurationPaged[~azure.mgmt.network.v2018_01_01.models.NetworkInterfaceIPConfiguration]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31996:c0:m1"}
{"signature": "def get(<EOL>self, resource_group_name, load_balancer_name, probe_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", probe_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets load balancer probe.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param probe_name: The name of the probe.\n        :type probe_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Probe or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_01_01.models.Probe or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f31998:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, virtual_network_gateway_connection_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_connection_name=virtual_network_gateway_connection_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified virtual network Gateway connection.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_connection_name: The name of the\n         virtual network gateway connection.\n        :type virtual_network_gateway_connection_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32000:c0:m5"}
{"signature": "def get_shared_key(<EOL>self, resource_group_name, virtual_network_gateway_connection_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_shared_key.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_gateway_connection_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "The Get VirtualNetworkGatewayConnectionSharedKey operation retrieves\n        information about the specified virtual network gateway connection\n        shared key through Network resource provider.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_connection_name: The virtual network\n         gateway connection shared key name.\n        :type virtual_network_gateway_connection_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ConnectionSharedKey or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_01_01.models.ConnectionSharedKey or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32000:c0:m10"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualNetworkGatewayConnectionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualNetworkGatewayConnectionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "The List VirtualNetworkGatewayConnections operation retrieves all the\n        virtual network gateways connections created.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualNetworkGatewayConnection\n        :rtype:\n         ~azure.mgmt.network.v2018_01_01.models.VirtualNetworkGatewayConnectionPaged[~azure.mgmt.network.v2018_01_01.models.VirtualNetworkGatewayConnection]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32000:c0:m11"}
{"signature": "def get(<EOL>self, resource_group_name, virtual_network_gateway_connection_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_gateway_connection_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified virtual network gateway connection by resource\n        group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_connection_name: The name of the\n         virtual network gateway connection.\n        :type virtual_network_gateway_connection_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualNetworkGatewayConnection or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_01_01.models.VirtualNetworkGatewayConnection\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32000:c0:m3"}
{"signature": "def update_tags(<EOL>self, resource_group_name, application_gateway_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>application_gateway_name=application_gateway_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates the specified application gateway tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param application_gateway_name: The name of the application gateway.\n        :type application_gateway_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ApplicationGateway or\n         ClientRawResponse<ApplicationGateway> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_01_01.models.ApplicationGateway]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_01_01.models.ApplicationGateway]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32002:c0:m7"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ApplicationGatewayPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ApplicationGatewayPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all application gateways in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ApplicationGateway\n        :rtype:\n         ~azure.mgmt.network.v2018_01_01.models.ApplicationGatewayPaged[~azure.mgmt.network.v2018_01_01.models.ApplicationGateway]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32002:c0:m8"}
{"signature": "def stop(<EOL>self, resource_group_name, application_gateway_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._stop_initial(<EOL>resource_group_name=resource_group_name,<EOL>application_gateway_name=application_gateway_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Stops the specified application gateway in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param application_gateway_name: The name of the application gateway.\n        :type application_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32002:c0:m13"}
{"signature": "def list_available_ssl_predefined_policies(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_available_ssl_predefined_policies.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ApplicationGatewaySslPredefinedPolicyPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ApplicationGatewaySslPredefinedPolicyPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all SSL predefined policies for configuring Ssl policy.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of\n         ApplicationGatewaySslPredefinedPolicy\n        :rtype:\n         ~azure.mgmt.network.v2018_01_01.models.ApplicationGatewaySslPredefinedPolicyPaged[~azure.mgmt.network.v2018_01_01.models.ApplicationGatewaySslPredefinedPolicy]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32002:c0:m18"}
{"signature": "def get(<EOL>self, resource_group_name, route_filter_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", route_filter_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified route filter.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param expand: Expands referenced express route bgp peering resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RouteFilter or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_01_01.models.RouteFilter or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32003:c0:m3"}
{"signature": "def delete(<EOL>self, resource_group_name, route_filter_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_filter_name=route_filter_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified route filter.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32003:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, network_watcher_name, connection_monitor_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>connection_monitor_name=connection_monitor_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified connection monitor.\n\n        :param resource_group_name: The name of the resource group containing\n         Network Watcher.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the Network Watcher resource.\n        :type network_watcher_name: str\n        :param connection_monitor_name: The name of the connection monitor.\n        :type connection_monitor_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32004:c0:m5"}
{"signature": "def start(<EOL>self, resource_group_name, network_watcher_name, connection_monitor_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._start_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>connection_monitor_name=connection_monitor_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Starts the specified connection monitor.\n\n        :param resource_group_name: The name of the resource group containing\n         Network Watcher.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the Network Watcher resource.\n        :type network_watcher_name: str\n        :param connection_monitor_name: The name of the connection monitor.\n        :type connection_monitor_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32004:c0:m9"}
{"signature": "def get(<EOL>self, resource_group_name, route_table_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", route_table_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified route table.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RouteTable or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_01_01.models.RouteTable or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32007:c0:m3"}
{"signature": "def delete(<EOL>self, resource_group_name, route_table_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_table_name=route_table_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified route table.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32007:c0:m2"}
{"signature": "def list(<EOL>self, resource_group_name, network_interface_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_interface_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.LoadBalancerPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.LoadBalancerPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List all load balancers in a network interface.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of LoadBalancer\n        :rtype:\n         ~azure.mgmt.network.v2018_01_01.models.LoadBalancerPaged[~azure.mgmt.network.v2018_01_01.models.LoadBalancer]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32008:c0:m1"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, virtual_network_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_name=virtual_network_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a virtual network in the specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param parameters: Parameters supplied to the create or update virtual\n         network operation\n        :type parameters:\n         ~azure.mgmt.network.v2018_01_01.models.VirtualNetwork\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualNetwork or\n         ClientRawResponse<VirtualNetwork> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_01_01.models.VirtualNetwork]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_01_01.models.VirtualNetwork]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32010:c0:m5"}
{"signature": "def delete(<EOL>self, resource_group_name, load_balancer_name, inbound_nat_rule_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>load_balancer_name=load_balancer_name,<EOL>inbound_nat_rule_name=inbound_nat_rule_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified load balancer inbound nat rule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param inbound_nat_rule_name: The name of the inbound nat rule.\n        :type inbound_nat_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32011:c0:m3"}
{"signature": "def get(<EOL>self, resource_group_name, circuit_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about the specified express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of express route circuit.\n        :type circuit_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteCircuit or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_01_01.models.ExpressRouteCircuit or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32012:c0:m3"}
{"signature": "def get_peering_stats(<EOL>self, resource_group_name, circuit_name, peering_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_peering_stats.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", peering_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all stats from an express route circuit in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteCircuitStats or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_01_01.models.ExpressRouteCircuitStats or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32012:c0:m15"}
{"signature": "def update_tags(<EOL>self, resource_group_name, circuit_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates an express route circuit tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the circuit.\n        :type circuit_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ExpressRouteCircuit or\n         ClientRawResponse<ExpressRouteCircuit> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_01_01.models.ExpressRouteCircuit]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_01_01.models.ExpressRouteCircuit]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32012:c0:m7"}
{"signature": "def list_routes_table(<EOL>self, resource_group_name, circuit_name, peering_name, device_path, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._list_routes_table_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>peering_name=peering_name,<EOL>device_path=device_path,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the currently advertised routes table associated with the express\n        route circuit in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param device_path: The path of the device.\n        :type device_path: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCircuitsRoutesTableListResult or\n         ClientRawResponse<ExpressRouteCircuitsRoutesTableListResult> if\n         raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_01_01.models.ExpressRouteCircuitsRoutesTableListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_01_01.models.ExpressRouteCircuitsRoutesTableListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32012:c0:m11"}
{"signature": "def get_stats(<EOL>self, resource_group_name, circuit_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_stats.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the stats from an express route circuit in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteCircuitStats or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_01_01.models.ExpressRouteCircuitStats or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32012:c0:m14"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ExpressRouteCircuitPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ExpressRouteCircuitPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the express route circuits in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ExpressRouteCircuit\n        :rtype:\n         ~azure.mgmt.network.v2018_01_01.models.ExpressRouteCircuitPaged[~azure.mgmt.network.v2018_01_01.models.ExpressRouteCircuit]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32012:c0:m17"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, application_security_group_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>application_security_group_name=application_security_group_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates an application security group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param application_security_group_name: The name of the application\n         security group.\n        :type application_security_group_name: str\n        :param parameters: Parameters supplied to the create or update\n         ApplicationSecurityGroup operation.\n        :type parameters:\n         ~azure.mgmt.network.v2018_01_01.models.ApplicationSecurityGroup\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ApplicationSecurityGroup or\n         ClientRawResponse<ApplicationSecurityGroup> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_01_01.models.ApplicationSecurityGroup]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_01_01.models.ApplicationSecurityGroup]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32013:c0:m5"}
{"signature": "def get(<EOL>self, resource_group_name, application_security_group_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", application_security_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about the specified application security group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param application_security_group_name: The name of the application\n         security group.\n        :type application_security_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ApplicationSecurityGroup or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_01_01.models.ApplicationSecurityGroup or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32013:c0:m3"}
{"signature": "def get(<EOL>self, resource_group_name, circuit_name, authorization_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", authorization_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified authorization from the specified express route\n        circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param authorization_name: The name of the authorization.\n        :type authorization_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteCircuitAuthorization or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_01_01.models.ExpressRouteCircuitAuthorization\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32014:c0:m3"}
{"signature": "def delete(<EOL>self, resource_group_name, network_security_group_name, security_rule_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_security_group_name=network_security_group_name,<EOL>security_rule_name=security_rule_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified network security rule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param security_rule_name: The name of the security rule.\n        :type security_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32016:c0:m2"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, virtual_network_name, subnet_name, subnet_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_name=virtual_network_name,<EOL>subnet_name=subnet_name,<EOL>subnet_parameters=subnet_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a subnet in the specified virtual network.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param subnet_name: The name of the subnet.\n        :type subnet_name: str\n        :param subnet_parameters: Parameters supplied to the create or update\n         subnet operation.\n        :type subnet_parameters: ~azure.mgmt.network.v2018_01_01.models.Subnet\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Subnet or\n         ClientRawResponse<Subnet> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_01_01.models.Subnet]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_01_01.models.Subnet]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32017:c0:m5"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PublicIPAddressPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PublicIPAddressPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the public IP addresses in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PublicIPAddress\n        :rtype:\n         ~azure.mgmt.network.v2018_01_01.models.PublicIPAddressPaged[~azure.mgmt.network.v2018_01_01.models.PublicIPAddress]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32018:c0:m8"}
{"signature": "def list(<EOL>self, location, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.EndpointServiceResultPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.EndpointServiceResultPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List what values of endpoint services are available for use.\n\n        :param location: The location to check available endpoint services.\n        :type location: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of EndpointServiceResult\n        :rtype:\n         ~azure.mgmt.network.v2018_01_01.models.EndpointServiceResultPaged[~azure.mgmt.network.v2018_01_01.models.EndpointServiceResult]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32020:c0:m1"}
{"signature": "def get_topology(<EOL>self, resource_group_name, network_watcher_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_topology.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_watcher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the current network topology by resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param parameters: Parameters that define the representation of\n         topology.\n        :type parameters:\n         ~azure.mgmt.network.v2018_01_01.models.TopologyParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Topology or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_01_01.models.Topology or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32021:c0:m8"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkWatcherPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkWatcherPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all network watchers by subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkWatcher\n        :rtype:\n         ~azure.mgmt.network.v2018_01_01.models.NetworkWatcherPaged[~azure.mgmt.network.v2018_01_01.models.NetworkWatcher]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32021:c0:m7"}
{"signature": "def get_flow_log_status(<EOL>self, resource_group_name, network_watcher_name, target_resource_id, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_flow_log_status_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>target_resource_id=target_resource_id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Queries status of flow log and traffic analytics (optional) on a\n        specified resource.\n\n        :param resource_group_name: The name of the network watcher resource\n         group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher resource.\n        :type network_watcher_name: str\n        :param target_resource_id: The target resource where getting the flow\n         logging and traffic analytics (optional) status.\n        :type target_resource_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns FlowLogInformation or\n         ClientRawResponse<FlowLogInformation> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_01_01.models.FlowLogInformation]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_01_01.models.FlowLogInformation]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32021:c0:m22"}
{"signature": "def get(<EOL>self, resource_group_name, network_watcher_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_watcher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified network watcher by resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: NetworkWatcher or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_01_01.models.NetworkWatcher or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32021:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, route_table_name, route_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", route_table_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", route_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified route from a route table.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param route_name: The name of the route.\n        :type route_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Route or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_01_01.models.Route or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32025:c0:m3"}
{"signature": "def list(<EOL>self, resource_group_name, route_table_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", route_table_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RoutePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RoutePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all routes in a route table.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Route\n        :rtype:\n         ~azure.mgmt.network.v2018_01_01.models.RoutePaged[~azure.mgmt.network.v2018_01_01.models.Route]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32025:c0:m6"}
{"signature": "def get_bgp_peer_status(<EOL>self, resource_group_name, virtual_network_gateway_name, peer=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_bgp_peer_status_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_name=virtual_network_gateway_name,<EOL>peer=peer,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The GetBgpPeerStatus operation retrieves the status of all BGP peers.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param peer: The IP address of the peer to retrieve the status of.\n        :type peer: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns BgpPeerStatusListResult\n         or ClientRawResponse<BgpPeerStatusListResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_01_01.models.BgpPeerStatusListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_01_01.models.BgpPeerStatusListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32026:c0:m18"}
{"signature": "def supported_vpn_devices(<EOL>self, resource_group_name, virtual_network_gateway_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.supported_vpn_devices.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_gateway_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT:str>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a xml format representation for supported vpn devices.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: str or ClientRawResponse if raw=true\n        :rtype: str or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32026:c0:m19"}
{"signature": "def reset(<EOL>self, resource_group_name, virtual_network_gateway_name, gateway_vip=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._reset_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_name=virtual_network_gateway_name,<EOL>gateway_vip=gateway_vip,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Resets the primary of the virtual network gateway in the specified\n        resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param gateway_vip: Virtual network gateway vip address supplied to\n         the begin reset of the active-active feature enabled gateway.\n        :type gateway_vip: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualNetworkGateway\n         or ClientRawResponse<VirtualNetworkGateway> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_01_01.models.VirtualNetworkGateway]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_01_01.models.VirtualNetworkGateway]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32026:c0:m11"}
{"signature": "def delete(<EOL>self, resource_group_name, virtual_network_gateway_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_name=virtual_network_gateway_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified virtual network gateway.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32026:c0:m5"}
{"signature": "def get_learned_routes(<EOL>self, resource_group_name, virtual_network_gateway_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_learned_routes_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_name=virtual_network_gateway_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "This operation retrieves a list of routes the virtual network gateway\n        has learned, including routes learned from BGP peers.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns GatewayRouteListResult\n         or ClientRawResponse<GatewayRouteListResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_01_01.models.GatewayRouteListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_01_01.models.GatewayRouteListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32026:c0:m21"}
{"signature": "def get_vpn_profile_package_url(<EOL>self, resource_group_name, virtual_network_gateway_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_vpn_profile_package_url_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_name=virtual_network_gateway_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT:str>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets pre-generated VPN profile for P2S client of the virtual network\n        gateway in the specified resource group. The profile needs to be\n        generated first using generateVpnProfile.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns str or\n         ClientRawResponse<str> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[str] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[str]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32026:c0:m16"}
{"signature": "def update_tags(<EOL>self, resource_group_name, virtual_network_gateway_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_name=virtual_network_gateway_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a virtual network gateway tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualNetworkGateway\n         or ClientRawResponse<VirtualNetworkGateway> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_01_01.models.VirtualNetworkGateway]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_01_01.models.VirtualNetworkGateway]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32026:c0:m7"}
{"signature": "def list(<EOL>self, resource_group_name, load_balancer_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.LoadBalancingRulePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.LoadBalancingRulePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the load balancing rules in a load balancer.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of LoadBalancingRule\n        :rtype:\n         ~azure.mgmt.network.v2018_01_01.models.LoadBalancingRulePaged[~azure.mgmt.network.v2018_01_01.models.LoadBalancingRule]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32027:c0:m1"}
{"signature": "def get(<EOL>self, resource_group_name, route_filter_name, rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", route_filter_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", rule_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified rule from a route filter.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param rule_name: The name of the rule.\n        :type rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RouteFilterRule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_01_01.models.RouteFilterRule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32028:c0:m3"}
{"signature": "def list_by_route_filter(<EOL>self, resource_group_name, route_filter_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_route_filter.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", route_filter_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RouteFilterRulePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RouteFilterRulePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all RouteFilterRules in a route filter.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of RouteFilterRule\n        :rtype:\n         ~azure.mgmt.network.v2018_01_01.models.RouteFilterRulePaged[~azure.mgmt.network.v2018_01_01.models.RouteFilterRule]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32028:c0:m8"}
{"signature": "def list_virtual_machine_scale_set_network_interfaces(<EOL>self, resource_group_name, virtual_machine_scale_set_name, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_virtual_machine_scale_set_network_interfaces.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_machine_scale_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all network interfaces in a virtual machine scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_machine_scale_set_name: The name of the virtual machine\n         scale set.\n        :type virtual_machine_scale_set_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkInterface\n        :rtype:\n         ~azure.mgmt.network.v2018_01_01.models.NetworkInterfacePaged[~azure.mgmt.network.v2018_01_01.models.NetworkInterface]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32029:c0:m15"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, network_interface_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_interface_name=network_interface_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a network interface.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param parameters: Parameters supplied to the create or update network\n         interface operation.\n        :type parameters:\n         ~azure.mgmt.network.v2018_01_01.models.NetworkInterface\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns NetworkInterface or\n         ClientRawResponse<NetworkInterface> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_01_01.models.NetworkInterface]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_01_01.models.NetworkInterface]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32029:c0:m5"}
{"signature": "def update_tags(<EOL>self, resource_group_name, network_interface_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_interface_name=network_interface_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a network interface tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns NetworkInterface or\n         ClientRawResponse<NetworkInterface> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_01_01.models.NetworkInterface]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_01_01.models.NetworkInterface]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32029:c0:m7"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, network_security_group_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_security_group_name=network_security_group_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a network security group in the specified resource\n        group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param parameters: Parameters supplied to the create or update network\n         security group operation.\n        :type parameters:\n         ~azure.mgmt.network.v2018_01_01.models.NetworkSecurityGroup\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns NetworkSecurityGroup or\n         ClientRawResponse<NetworkSecurityGroup> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_01_01.models.NetworkSecurityGroup]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_01_01.models.NetworkSecurityGroup]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32030:c0:m5"}
{"signature": "def delete(<EOL>self, resource_group_name, network_security_group_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_security_group_name=network_security_group_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified network security group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32030:c0:m2"}
{"signature": "def check_dns_name_availability(<EOL>self, location, domain_name_label=None, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.check_dns_name_availability.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if domain_name_label is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", domain_name_label, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Checks whether a domain name in the cloudapp.net zone is available for\n        use.\n\n        :param location: The location of the domain name.\n        :type location: str\n        :param domain_name_label: The domain name to be verified. It must\n         conform to the following regular expression:\n         ^[a-z][a-z0-9-]{1,61}[a-z0-9]$.\n        :type domain_name_label: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DnsNameAvailabilityResult or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2017_06_01.models.DnsNameAvailabilityResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32031:c1:m1"}
{"signature": "def get(<EOL>self, resource_group_name, load_balancer_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified load balancer.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: LoadBalancer or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_06_01.models.LoadBalancer or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32277:c0:m3"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.LoadBalancerPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.LoadBalancerPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the load balancers in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of LoadBalancer\n        :rtype:\n         ~azure.mgmt.network.v2017_06_01.models.LoadBalancerPaged[~azure.mgmt.network.v2017_06_01.models.LoadBalancer]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32277:c0:m7"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.LoadBalancerPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.LoadBalancerPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the load balancers in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of LoadBalancer\n        :rtype:\n         ~azure.mgmt.network.v2017_06_01.models.LoadBalancerPaged[~azure.mgmt.network.v2017_06_01.models.LoadBalancer]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32277:c0:m6"}
{"signature": "def list(<EOL>self, resource_group_name, network_interface_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_interface_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkInterfaceIPConfigurationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkInterfaceIPConfigurationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get all ip configurations in a network interface.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkInterfaceIPConfiguration\n        :rtype:\n         ~azure.mgmt.network.v2017_06_01.models.NetworkInterfaceIPConfigurationPaged[~azure.mgmt.network.v2017_06_01.models.NetworkInterfaceIPConfiguration]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32278:c0:m1"}
{"signature": "def get(<EOL>self, resource_group_name, network_interface_name, ip_configuration_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_interface_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", ip_configuration_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified network interface ip configuration.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param ip_configuration_name: The name of the ip configuration name.\n        :type ip_configuration_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: NetworkInterfaceIPConfiguration or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.network.v2017_06_01.models.NetworkInterfaceIPConfiguration\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32278:c0:m2"}
{"signature": "def get_status(<EOL>self, resource_group_name, network_watcher_name, packet_capture_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_status_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>packet_capture_name=packet_capture_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT:location>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Query the status of a running packet capture session.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the Network Watcher resource.\n        :type network_watcher_name: str\n        :param packet_capture_name: The name given to the packet capture\n         session.\n        :type packet_capture_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         PacketCaptureQueryStatusResult or\n         ClientRawResponse<PacketCaptureQueryStatusResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_06_01.models.PacketCaptureQueryStatusResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_06_01.models.PacketCaptureQueryStatusResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32280:c0:m9"}
{"signature": "def create(<EOL>self, resource_group_name, network_watcher_name, packet_capture_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>packet_capture_name=packet_capture_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Create and start a packet capture on the specified VM.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param packet_capture_name: The name of the packet capture session.\n        :type packet_capture_name: str\n        :param parameters: Parameters that define the create packet capture\n         operation.\n        :type parameters: ~azure.mgmt.network.v2017_06_01.models.PacketCapture\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns PacketCaptureResult or\n         ClientRawResponse<PacketCaptureResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_06_01.models.PacketCaptureResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_06_01.models.PacketCaptureResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32280:c0:m2"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualNetworkGatewayConnectionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualNetworkGatewayConnectionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "The List VirtualNetworkGatewayConnections operation retrieves all the\n        virtual network gateways connections created.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualNetworkGatewayConnection\n        :rtype:\n         ~azure.mgmt.network.v2017_06_01.models.VirtualNetworkGatewayConnectionPaged[~azure.mgmt.network.v2017_06_01.models.VirtualNetworkGatewayConnection]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32281:c0:m9"}
{"signature": "def delete(<EOL>self, resource_group_name, virtual_network_gateway_connection_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_connection_name=virtual_network_gateway_connection_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified virtual network Gateway connection.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_connection_name: The name of the\n         virtual network gateway connection.\n        :type virtual_network_gateway_connection_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32281:c0:m5"}
{"signature": "def set_shared_key(<EOL>self, resource_group_name, virtual_network_gateway_connection_name, value, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._set_shared_key_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_connection_name=virtual_network_gateway_connection_name,<EOL>value=value,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The Put VirtualNetworkGatewayConnectionSharedKey operation sets the\n        virtual network gateway connection shared key for passed virtual\n        network gateway connection in the specified resource group through\n        Network resource provider.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_connection_name: The virtual network\n         gateway connection name.\n        :type virtual_network_gateway_connection_name: str\n        :param value: The virtual network connection shared key value.\n        :type value: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ConnectionSharedKey or\n         ClientRawResponse<ConnectionSharedKey> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_06_01.models.ConnectionSharedKey]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_06_01.models.ConnectionSharedKey]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32281:c0:m7"}
{"signature": "def get(<EOL>self, resource_group_name, virtual_network_gateway_connection_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_gateway_connection_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified virtual network gateway connection by resource\n        group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_connection_name: The name of the\n         virtual network gateway connection.\n        :type virtual_network_gateway_connection_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualNetworkGatewayConnection or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.network.v2017_06_01.models.VirtualNetworkGatewayConnection\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32281:c0:m3"}
{"signature": "def list_available_waf_rule_sets(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_available_waf_rule_sets.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all available web application firewall rule sets.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ApplicationGatewayAvailableWafRuleSetsResult or\n         ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2017_06_01.models.ApplicationGatewayAvailableWafRuleSetsResult\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32283:c0:m14"}
{"signature": "def delete(<EOL>self, resource_group_name, application_gateway_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>application_gateway_name=application_gateway_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified application gateway.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param application_gateway_name: The name of the application gateway.\n        :type application_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32283:c0:m2"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RouteFilterPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RouteFilterPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all route filters in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of RouteFilter\n        :rtype:\n         ~azure.mgmt.network.v2017_06_01.models.RouteFilterPaged[~azure.mgmt.network.v2017_06_01.models.RouteFilter]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32284:c0:m8"}
{"signature": "def delete(<EOL>self, resource_group_name, route_filter_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_filter_name=route_filter_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified route filter.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32284:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, local_network_gateway_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>local_network_gateway_name=local_network_gateway_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified local network gateway.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param local_network_gateway_name: The name of the local network\n         gateway.\n        :type local_network_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32285:c0:m5"}
{"signature": "def get(<EOL>self, resource_group_name, network_security_group_name, default_security_rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_security_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", default_security_rule_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the specified default network security rule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param default_security_rule_name: The name of the default security\n         rule.\n        :type default_security_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SecurityRule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_06_01.models.SecurityRule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32286:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, route_table_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_table_name=route_table_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified route table.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32287:c0:m2"}
{"signature": "def list(<EOL>self, resource_group_name, network_interface_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_interface_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.LoadBalancerPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.LoadBalancerPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get all load balancers in a network interface.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of LoadBalancer\n        :rtype:\n         ~azure.mgmt.network.v2017_06_01.models.LoadBalancerPaged[~azure.mgmt.network.v2017_06_01.models.LoadBalancer]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32288:c0:m1"}
{"signature": "def check_ip_address_availability(<EOL>self, resource_group_name, virtual_network_name, ip_address=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.check_ip_address_availability.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if ip_address is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", ip_address, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Checks whether a private IP address is available for use.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param ip_address: The private IP address to be verified.\n        :type ip_address: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: IPAddressAvailabilityResult or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2017_06_01.models.IPAddressAvailabilityResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32290:c0:m8"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualNetworkPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualNetworkPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all virtual networks in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualNetwork\n        :rtype:\n         ~azure.mgmt.network.v2017_06_01.models.VirtualNetworkPaged[~azure.mgmt.network.v2017_06_01.models.VirtualNetwork]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32290:c0:m7"}
{"signature": "def list_usage(<EOL>self, resource_group_name, virtual_network_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_usage.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualNetworkUsagePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualNetworkUsagePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists usage stats.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualNetworkUsage\n        :rtype:\n         ~azure.mgmt.network.v2017_06_01.models.VirtualNetworkUsagePaged[~azure.mgmt.network.v2017_06_01.models.VirtualNetworkUsage]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32290:c0:m9"}
{"signature": "def get(<EOL>self, resource_group_name, load_balancer_name, inbound_nat_rule_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", inbound_nat_rule_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified load balancer inbound nat rule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param inbound_nat_rule_name: The name of the inbound nat rule.\n        :type inbound_nat_rule_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: InboundNatRule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_06_01.models.InboundNatRule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32291:c0:m4"}
{"signature": "def get_stats(<EOL>self, resource_group_name, circuit_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_stats.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the stats from an express route circuit in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteCircuitStats or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2017_06_01.models.ExpressRouteCircuitStats or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32292:c0:m12"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ExpressRouteCircuitPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ExpressRouteCircuitPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the express route circuits in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ExpressRouteCircuit\n        :rtype:\n         ~azure.mgmt.network.v2017_06_01.models.ExpressRouteCircuitPaged[~azure.mgmt.network.v2017_06_01.models.ExpressRouteCircuit]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32292:c0:m15"}
{"signature": "def get(<EOL>self, resource_group_name, network_security_group_name, security_rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_security_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", security_rule_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the specified network security rule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param security_rule_name: The name of the security rule.\n        :type security_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SecurityRule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_06_01.models.SecurityRule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32295:c0:m3"}
{"signature": "def list(<EOL>self, resource_group_name, network_security_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_security_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SecurityRulePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SecurityRulePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all security rules in a network security group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of SecurityRule\n        :rtype:\n         ~azure.mgmt.network.v2017_06_01.models.SecurityRulePaged[~azure.mgmt.network.v2017_06_01.models.SecurityRule]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32295:c0:m6"}
{"signature": "def get_virtual_machine_scale_set_public_ip_address(<EOL>self, resource_group_name, virtual_machine_scale_set_name, virtualmachine_index, network_interface_name, ip_configuration_name, public_ip_address_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get_virtual_machine_scale_set_public_ip_address.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_machine_scale_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtualmachine_index, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_interface_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", ip_configuration_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", public_ip_address_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the specified public IP address in a virtual machine scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_machine_scale_set_name: The name of the virtual machine\n         scale set.\n        :type virtual_machine_scale_set_name: str\n        :param virtualmachine_index: The virtual machine index.\n        :type virtualmachine_index: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param ip_configuration_name: The name of the IP configuration.\n        :type ip_configuration_name: str\n        :param public_ip_address_name: The name of the public IP Address.\n        :type public_ip_address_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PublicIPAddress or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_06_01.models.PublicIPAddress or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32297:c0:m10"}
{"signature": "def get_troubleshooting_result(<EOL>self, resource_group_name, network_watcher_name, target_resource_id, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_troubleshooting_result_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>target_resource_id=target_resource_id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Get the last completed troubleshooting result on a specified resource.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher resource.\n        :type network_watcher_name: str\n        :param target_resource_id: The target resource ID to query the\n         troubleshooting result.\n        :type target_resource_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns TroubleshootingResult\n         or ClientRawResponse<TroubleshootingResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_06_01.models.TroubleshootingResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_06_01.models.TroubleshootingResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32301:c0:m17"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, network_watcher_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_watcher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or updates a network watcher in the specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param parameters: Parameters that define the network watcher\n         resource.\n        :type parameters:\n         ~azure.mgmt.network.v2017_06_01.models.NetworkWatcher\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: NetworkWatcher or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_06_01.models.NetworkWatcher or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32301:c0:m1"}
{"signature": "def check_connectivity(<EOL>self, resource_group_name, network_watcher_name, source, destination, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._check_connectivity_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>source=source,<EOL>destination=destination,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Verifies the possibility of establishing a direct TCP connection from a\n        virtual machine to a given endpoint including another VM or an\n        arbitrary remote server.\n\n        :param resource_group_name: The name of the network watcher resource\n         group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher resource.\n        :type network_watcher_name: str\n        :param source:\n        :type source:\n         ~azure.mgmt.network.v2017_06_01.models.ConnectivitySource\n        :param destination:\n        :type destination:\n         ~azure.mgmt.network.v2017_06_01.models.ConnectivityDestination\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ConnectivityInformation\n         or ClientRawResponse<ConnectivityInformation> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_06_01.models.ConnectivityInformation]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_06_01.models.ConnectivityInformation]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32301:c0:m23"}
{"signature": "def get_vm_security_rules(<EOL>self, resource_group_name, network_watcher_name, target_resource_id, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_vm_security_rules_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>target_resource_id=target_resource_id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the configured and effective security group rules on the specified\n        VM.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param target_resource_id: ID of the target VM.\n        :type target_resource_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns SecurityGroupViewResult\n         or ClientRawResponse<SecurityGroupViewResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_06_01.models.SecurityGroupViewResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_06_01.models.SecurityGroupViewResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32301:c0:m13"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkWatcherPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkWatcherPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all network watchers by resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkWatcher\n        :rtype:\n         ~azure.mgmt.network.v2017_06_01.models.NetworkWatcherPaged[~azure.mgmt.network.v2017_06_01.models.NetworkWatcher]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32301:c0:m5"}
{"signature": "def list(<EOL>self, resource_group_name, load_balancer_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.FrontendIPConfigurationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.FrontendIPConfigurationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the load balancer frontend IP configurations.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of FrontendIPConfiguration\n        :rtype:\n         ~azure.mgmt.network.v2017_06_01.models.FrontendIPConfigurationPaged[~azure.mgmt.network.v2017_06_01.models.FrontendIPConfiguration]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32304:c0:m1"}
{"signature": "def delete(<EOL>self, resource_group_name, route_table_name, route_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_table_name=route_table_name,<EOL>route_name=route_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified route from a route table.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param route_name: The name of the route.\n        :type route_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32305:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, route_table_name, route_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", route_table_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", route_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified route from a route table.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param route_name: The name of the route.\n        :type route_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Route or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_06_01.models.Route or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32305:c0:m3"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, route_table_name, route_name, route_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_table_name=route_table_name,<EOL>route_name=route_name,<EOL>route_parameters=route_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a route in the specified route table.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param route_name: The name of the route.\n        :type route_name: str\n        :param route_parameters: Parameters supplied to the create or update\n         route operation.\n        :type route_parameters: ~azure.mgmt.network.v2017_06_01.models.Route\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Route or\n         ClientRawResponse<Route> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_06_01.models.Route]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_06_01.models.Route]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32305:c0:m5"}
{"signature": "def delete(<EOL>self, resource_group_name, virtual_network_gateway_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_name=virtual_network_gateway_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified virtual network gateway.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32306:c0:m5"}
{"signature": "def generate_vpn_profile(<EOL>self, resource_group_name, virtual_network_gateway_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.generate_vpn_profile.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_gateway_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT:str>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Generates VPN profile for P2S client of the virtual network gateway in\n        the specified resource group. Used for IKEV2 and radius based\n        authentication.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param parameters: Parameters supplied to the generate virtual network\n         gateway VPN client package operation.\n        :type parameters:\n         ~azure.mgmt.network.v2017_06_01.models.VpnClientParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: str or ClientRawResponse if raw=true\n        :rtype: str or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32306:c0:m12"}
{"signature": "def reset(<EOL>self, resource_group_name, virtual_network_gateway_name, gateway_vip=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._reset_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_name=virtual_network_gateway_name,<EOL>gateway_vip=gateway_vip,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Resets the primary of the virtual network gateway in the specified\n        resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param gateway_vip: Virtual network gateway vip address supplied to\n         the begin reset of the active-active feature enabled gateway.\n        :type gateway_vip: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualNetworkGateway\n         or ClientRawResponse<VirtualNetworkGateway> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_06_01.models.VirtualNetworkGateway]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_06_01.models.VirtualNetworkGateway]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32306:c0:m9"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, virtual_network_gateway_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_name=virtual_network_gateway_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a virtual network gateway in the specified resource\n        group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param parameters: Parameters supplied to create or update virtual\n         network gateway operation.\n        :type parameters:\n         ~azure.mgmt.network.v2017_06_01.models.VirtualNetworkGateway\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualNetworkGateway\n         or ClientRawResponse<VirtualNetworkGateway> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_06_01.models.VirtualNetworkGateway]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_06_01.models.VirtualNetworkGateway]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32306:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, route_filter_name, rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", route_filter_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", rule_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified rule from a route filter.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param rule_name: The name of the rule.\n        :type rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RouteFilterRule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_06_01.models.RouteFilterRule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32308:c0:m3"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, route_filter_name, rule_name, route_filter_rule_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_filter_name=route_filter_name,<EOL>rule_name=rule_name,<EOL>route_filter_rule_parameters=route_filter_rule_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a route in the specified route filter.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param rule_name: The name of the route filter rule.\n        :type rule_name: str\n        :param route_filter_rule_parameters: Parameters supplied to the create\n         or update route filter rule operation.\n        :type route_filter_rule_parameters:\n         ~azure.mgmt.network.v2017_06_01.models.RouteFilterRule\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns RouteFilterRule or\n         ClientRawResponse<RouteFilterRule> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_06_01.models.RouteFilterRule]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_06_01.models.RouteFilterRule]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32308:c0:m5"}
{"signature": "def delete(<EOL>self, resource_group_name, route_filter_name, rule_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_filter_name=route_filter_name,<EOL>rule_name=rule_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified rule from a route filter.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param rule_name: The name of the rule.\n        :type rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32308:c0:m2"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all network interfaces in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkInterface\n        :rtype:\n         ~azure.mgmt.network.v2017_06_01.models.NetworkInterfacePaged[~azure.mgmt.network.v2017_06_01.models.NetworkInterface]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32309:c0:m7"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all network interfaces in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkInterface\n        :rtype:\n         ~azure.mgmt.network.v2017_06_01.models.NetworkInterfacePaged[~azure.mgmt.network.v2017_06_01.models.NetworkInterface]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32309:c0:m6"}
{"signature": "def supported_security_providers(<EOL>self, resource_group_name, virtual_wan_name, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.supported_security_providers.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_wan_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gives the supported security providers for the virtual wan.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param virtual_wan_name: The name of the VirtualWAN for which\n         supported security providers are needed.\n        :type virtual_wan_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualWanSecurityProviders or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.VirtualWanSecurityProviders or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_11_01.models.ErrorException>`", "id": "f32312:c1:m2"}
{"signature": "def list(<EOL>self, resource_group_name, express_route_port_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", express_route_port_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ExpressRouteLinkPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ExpressRouteLinkPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieve the ExpressRouteLink sub-resources of the specified\n        ExpressRoutePort resource.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param express_route_port_name: The name of the ExpressRoutePort\n         resource.\n        :type express_route_port_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ExpressRouteLink\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.ExpressRouteLinkPaged[~azure.mgmt.network.v2018_11_01.models.ExpressRouteLink]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32758:c0:m2"}
{"signature": "def list(<EOL>self, resource_group_name, load_balancer_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.BackendAddressPoolPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.BackendAddressPoolPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the load balancer backed address pools.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of BackendAddressPool\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.BackendAddressPoolPaged[~azure.mgmt.network.v2018_11_01.models.BackendAddressPool]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32760:c0:m1"}
{"signature": "def delete(<EOL>self, resource_group_name, express_route_gateway_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>express_route_gateway_name=express_route_gateway_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified ExpressRoute gateway in a resource group. An\n        ExpressRoute gateway resource can only be deleted when there are no\n        connection subresources.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param express_route_gateway_name: The name of the ExpressRoute\n         gateway.\n        :type express_route_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32764:c0:m7"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, express_route_gateway_name, put_express_route_gateway_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>express_route_gateway_name=express_route_gateway_name,<EOL>put_express_route_gateway_parameters=put_express_route_gateway_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a ExpressRoute gateway in a specified resource\n        group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param express_route_gateway_name: The name of the ExpressRoute\n         gateway.\n        :type express_route_gateway_name: str\n        :param put_express_route_gateway_parameters: Parameters required in an\n         ExpressRoute gateway PUT operation.\n        :type put_express_route_gateway_parameters:\n         ~azure.mgmt.network.v2018_11_01.models.ExpressRouteGateway\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ExpressRouteGateway or\n         ClientRawResponse<ExpressRouteGateway> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_11_01.models.ExpressRouteGateway]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_11_01.models.ExpressRouteGateway]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32764:c0:m4"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ExpressRouteCrossConnectionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ExpressRouteCrossConnectionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves all the ExpressRouteCrossConnections in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ExpressRouteCrossConnection\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.ExpressRouteCrossConnectionPaged[~azure.mgmt.network.v2018_11_01.models.ExpressRouteCrossConnection]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32765:c0:m1"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.OperationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.OperationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all of the available Network Rest API operations.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Operation\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.OperationPaged[~azure.mgmt.network.v2018_11_01.models.Operation]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32766:c0:m1"}
{"signature": "def list(<EOL>self, resource_group_name, network_watcher_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_watcher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PacketCaptureResultPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PacketCaptureResultPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all packet capture sessions within the specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the Network Watcher resource.\n        :type network_watcher_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PacketCaptureResult\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.PacketCaptureResultPaged[~azure.mgmt.network.v2018_11_01.models.PacketCaptureResult]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_11_01.models.ErrorResponseException>`", "id": "f32768:c0:m10"}
{"signature": "def get(<EOL>self, resource_group_name, network_watcher_name, packet_capture_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_watcher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", packet_capture_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a packet capture session by name.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param packet_capture_name: The name of the packet capture session.\n        :type packet_capture_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PacketCaptureResult or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_11_01.models.PacketCaptureResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_11_01.models.ErrorResponseException>`", "id": "f32768:c0:m3"}
{"signature": "def get_shared_key(<EOL>self, resource_group_name, virtual_network_gateway_connection_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_shared_key.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_gateway_connection_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "The Get VirtualNetworkGatewayConnectionSharedKey operation retrieves\n        information about the specified virtual network gateway connection\n        shared key through Network resource provider.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_connection_name: The virtual network\n         gateway connection shared key name.\n        :type virtual_network_gateway_connection_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ConnectionSharedKey or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_11_01.models.ConnectionSharedKey or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32769:c0:m10"}
{"signature": "def set_shared_key(<EOL>self, resource_group_name, virtual_network_gateway_connection_name, value, id=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._set_shared_key_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_connection_name=virtual_network_gateway_connection_name,<EOL>value=value,<EOL>id=id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The Put VirtualNetworkGatewayConnectionSharedKey operation sets the\n        virtual network gateway connection shared key for passed virtual\n        network gateway connection in the specified resource group through\n        Network resource provider.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_connection_name: The virtual network\n         gateway connection name.\n        :type virtual_network_gateway_connection_name: str\n        :param value: The virtual network connection shared key value.\n        :type value: str\n        :param id: Resource ID.\n        :type id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ConnectionSharedKey or\n         ClientRawResponse<ConnectionSharedKey> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_11_01.models.ConnectionSharedKey]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_11_01.models.ConnectionSharedKey]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32769:c0:m9"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, virtual_network_gateway_connection_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_connection_name=virtual_network_gateway_connection_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a virtual network gateway connection in the\n        specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_connection_name: The name of the\n         virtual network gateway connection.\n        :type virtual_network_gateway_connection_name: str\n        :param parameters: Parameters supplied to the create or update virtual\n         network gateway connection operation.\n        :type parameters:\n         ~azure.mgmt.network.v2018_11_01.models.VirtualNetworkGatewayConnection\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         VirtualNetworkGatewayConnection or\n         ClientRawResponse<VirtualNetworkGatewayConnection> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_11_01.models.VirtualNetworkGatewayConnection]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_11_01.models.VirtualNetworkGatewayConnection]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32769:c0:m2"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ExpressRoutePortPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ExpressRoutePortPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List all the ExpressRoutePort resources in the specified resource\n        group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ExpressRoutePort\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.ExpressRoutePortPaged[~azure.mgmt.network.v2018_11_01.models.ExpressRoutePort]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32770:c0:m8"}
{"signature": "def delete(<EOL>self, resource_group_name, express_route_port_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>express_route_port_name=express_route_port_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified ExpressRoutePort resource.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param express_route_port_name: The name of the ExpressRoutePort\n         resource.\n        :type express_route_port_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32770:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, ddos_custom_policy_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>ddos_custom_policy_name=ddos_custom_policy_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified DDoS custom policy.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param ddos_custom_policy_name: The name of the DDoS custom policy.\n        :type ddos_custom_policy_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32772:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, gateway_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", gateway_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves the details of a virtual wan p2s vpn gateway.\n\n        :param resource_group_name: The resource group name of the\n         P2SVpnGateway.\n        :type resource_group_name: str\n        :param gateway_name: The name of the gateway.\n        :type gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: P2SVpnGateway or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_11_01.models.P2SVpnGateway or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_11_01.models.ErrorException>`", "id": "f32773:c0:m1"}
{"signature": "def generate_vpn_profile(<EOL>self, resource_group_name, gateway_name, authentication_method=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._generate_vpn_profile_initial(<EOL>resource_group_name=resource_group_name,<EOL>gateway_name=gateway_name,<EOL>authentication_method=authentication_method,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Generates VPN profile for P2S client of the P2SVpnGateway in the\n        specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param gateway_name: The name of the P2SVpnGateway.\n        :type gateway_name: str\n        :param authentication_method: VPN client Authentication Method.\n         Possible values are: 'EAPTLS' and 'EAPMSCHAPv2'. Possible values\n         include: 'EAPTLS', 'EAPMSCHAPv2'\n        :type authentication_method: str or\n         ~azure.mgmt.network.v2018_11_01.models.AuthenticationMethod\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VpnProfileResponse or\n         ClientRawResponse<VpnProfileResponse> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_11_01.models.VpnProfileResponse]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_11_01.models.VpnProfileResponse]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32773:c0:m11"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.DdosProtectionPlanPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.DdosProtectionPlanPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the DDoS protection plans in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of DdosProtectionPlan\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.DdosProtectionPlanPaged[~azure.mgmt.network.v2018_11_01.models.DdosProtectionPlan]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32774:c0:m9"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, ddos_protection_plan_name, location=None, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>ddos_protection_plan_name=ddos_protection_plan_name,<EOL>location=location,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a DDoS protection plan.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param ddos_protection_plan_name: The name of the DDoS protection\n         plan.\n        :type ddos_protection_plan_name: str\n        :param location: Resource location.\n        :type location: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns DdosProtectionPlan or\n         ClientRawResponse<DdosProtectionPlan> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_11_01.models.DdosProtectionPlan]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_11_01.models.DdosProtectionPlan]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32774:c0:m5"}
{"signature": "def delete(<EOL>self, resource_group_name, azure_firewall_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>azure_firewall_name=azure_firewall_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified Azure Firewall.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param azure_firewall_name: The name of the Azure Firewall.\n        :type azure_firewall_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32775:c0:m2"}
{"signature": "def get_ssl_predefined_policy(<EOL>self, predefined_policy_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_ssl_predefined_policy.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", predefined_policy_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets Ssl predefined policy with the specified policy name.\n\n        :param predefined_policy_name: Name of Ssl predefined policy.\n        :type predefined_policy_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ApplicationGatewaySslPredefinedPolicy or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.ApplicationGatewaySslPredefinedPolicy\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32776:c0:m22"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ApplicationGatewayPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ApplicationGatewayPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all application gateways in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ApplicationGateway\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.ApplicationGatewayPaged[~azure.mgmt.network.v2018_11_01.models.ApplicationGateway]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32776:c0:m8"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ApplicationGatewayPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ApplicationGatewayPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the application gateways in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ApplicationGateway\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.ApplicationGatewayPaged[~azure.mgmt.network.v2018_11_01.models.ApplicationGateway]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32776:c0:m9"}
{"signature": "def list_available_waf_rule_sets(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_available_waf_rule_sets.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all available web application firewall rule sets.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ApplicationGatewayAvailableWafRuleSetsResult or\n         ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.ApplicationGatewayAvailableWafRuleSetsResult\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32776:c0:m19"}
{"signature": "def list_available_server_variables(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_available_server_variables.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all available server variables.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ApplicationGatewayAvailableServerVariablesResult or\n         ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.ApplicationGatewayAvailableServerVariablesResult\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_11_01.models.ErrorException>`", "id": "f32776:c0:m16"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkProfilePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkProfilePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the network profiles in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkProfile\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.NetworkProfilePaged[~azure.mgmt.network.v2018_11_01.models.NetworkProfile]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32777:c0:m8"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkProfilePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkProfilePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all network profiles in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkProfile\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.NetworkProfilePaged[~azure.mgmt.network.v2018_11_01.models.NetworkProfile]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32777:c0:m9"}
{"signature": "def get(<EOL>self, resource_group_name, service_endpoint_policy_name, service_endpoint_policy_definition_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", service_endpoint_policy_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", service_endpoint_policy_definition_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the specified service endpoint policy definitions from service\n        endpoint policy.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param service_endpoint_policy_name: The name of the service endpoint\n         policy name.\n        :type service_endpoint_policy_name: str\n        :param service_endpoint_policy_definition_name: The name of the\n         service endpoint policy definition name.\n        :type service_endpoint_policy_definition_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ServiceEndpointPolicyDefinition or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.ServiceEndpointPolicyDefinition\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32778:c0:m3"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RouteFilterPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RouteFilterPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all route filters in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of RouteFilter\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.RouteFilterPaged[~azure.mgmt.network.v2018_11_01.models.RouteFilter]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32779:c0:m8"}
{"signature": "def get(<EOL>self, resource_group_name, route_filter_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", route_filter_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified route filter.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param expand: Expands referenced express route bgp peering resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RouteFilter or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_11_01.models.RouteFilter or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32779:c0:m3"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, network_watcher_name, connection_monitor_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>connection_monitor_name=connection_monitor_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Create or update a connection monitor.\n\n        :param resource_group_name: The name of the resource group containing\n         Network Watcher.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the Network Watcher resource.\n        :type network_watcher_name: str\n        :param connection_monitor_name: The name of the connection monitor.\n        :type connection_monitor_name: str\n        :param parameters: Parameters that define the operation to create a\n         connection monitor.\n        :type parameters:\n         ~azure.mgmt.network.v2018_11_01.models.ConnectionMonitor\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ConnectionMonitorResult\n         or ClientRawResponse<ConnectionMonitorResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_11_01.models.ConnectionMonitorResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_11_01.models.ConnectionMonitorResult]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_11_01.models.ErrorResponseException>`", "id": "f32781:c0:m2"}
{"signature": "def download(<EOL>self, resource_group_name, virtual_wan_name, vpn_sites=None, output_blob_sas_url=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._download_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_wan_name=virtual_wan_name,<EOL>vpn_sites=vpn_sites,<EOL>output_blob_sas_url=output_blob_sas_url,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gives the sas-url to download the configurations for vpn-sites in a\n        resource group.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param virtual_wan_name: The name of the VirtualWAN for which\n         configuration of all vpn-sites is needed.\n        :type virtual_wan_name: str\n        :param vpn_sites: List of resource-ids of the vpn-sites for which\n         config is to be downloaded.\n        :type vpn_sites: list[str]\n        :param output_blob_sas_url: The sas-url to download the configurations\n         for vpn-sites\n        :type output_blob_sas_url: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_11_01.models.ErrorException>`", "id": "f32783:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, tap_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", tap_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about the specified virtual network tap.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param tap_name: The name of virtual network tap.\n        :type tap_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualNetworkTap or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_11_01.models.VirtualNetworkTap or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32784:c0:m3"}
{"signature": "def get(<EOL>self, resource_group_name, gateway_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", gateway_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves the details of a virtual wan vpn gateway.\n\n        :param resource_group_name: The resource group name of the VpnGateway.\n        :type resource_group_name: str\n        :param gateway_name: The name of the gateway.\n        :type gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VpnGateway or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_11_01.models.VpnGateway or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_11_01.models.ErrorException>`", "id": "f32786:c0:m1"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VpnGatewayPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VpnGatewayPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all the VpnGateways in a resource group.\n\n        :param resource_group_name: The resource group name of the VpnGateway.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VpnGateway\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.VpnGatewayPaged[~azure.mgmt.network.v2018_11_01.models.VpnGateway]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_11_01.models.ErrorException>`", "id": "f32786:c0:m8"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, gateway_name, vpn_gateway_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>gateway_name=gateway_name,<EOL>vpn_gateway_parameters=vpn_gateway_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates a virtual wan vpn gateway if it doesn't exist else updates the\n        existing gateway.\n\n        :param resource_group_name: The resource group name of the VpnGateway.\n        :type resource_group_name: str\n        :param gateway_name: The name of the gateway.\n        :type gateway_name: str\n        :param vpn_gateway_parameters: Parameters supplied to create or Update\n         a virtual wan vpn gateway.\n        :type vpn_gateway_parameters:\n         ~azure.mgmt.network.v2018_11_01.models.VpnGateway\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VpnGateway or\n         ClientRawResponse<VpnGateway> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_11_01.models.VpnGateway]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_11_01.models.VpnGateway]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_11_01.models.ErrorException>`", "id": "f32786:c0:m3"}
{"signature": "def delete(<EOL>self, resource_group_name, gateway_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>gateway_name=gateway_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes a virtual wan vpn gateway.\n\n        :param resource_group_name: The resource group name of the VpnGateway.\n        :type resource_group_name: str\n        :param gateway_name: The name of the gateway.\n        :type gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_11_01.models.ErrorException>`", "id": "f32786:c0:m7"}
{"signature": "def get(<EOL>self, resource_group_name, route_table_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", route_table_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified route table.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RouteTable or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_11_01.models.RouteTable or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32787:c0:m3"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, route_table_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_table_name=route_table_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Create or updates a route table in a specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param parameters: Parameters supplied to the create or update route\n         table operation.\n        :type parameters: ~azure.mgmt.network.v2018_11_01.models.RouteTable\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns RouteTable or\n         ClientRawResponse<RouteTable> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_11_01.models.RouteTable]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_11_01.models.RouteTable]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32787:c0:m5"}
{"signature": "def update_tags(<EOL>self, resource_group_name, route_table_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_table_name=route_table_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a route table tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns RouteTable or\n         ClientRawResponse<RouteTable> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_11_01.models.RouteTable]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_11_01.models.RouteTable]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32787:c0:m7"}
{"signature": "def list_by_subscription(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_subscription.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.InterfaceEndpointPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.InterfaceEndpointPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all interface endpoints in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of InterfaceEndpoint\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.InterfaceEndpointPaged[~azure.mgmt.network.v2018_11_01.models.InterfaceEndpoint]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32789:c0:m7"}
{"signature": "def get(<EOL>self, resource_group_name, interface_endpoint_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", interface_endpoint_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified interface endpoint by resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param interface_endpoint_name: The name of the interface endpoint.\n        :type interface_endpoint_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: InterfaceEndpoint or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_11_01.models.InterfaceEndpoint or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32789:c0:m3"}
{"signature": "def list(<EOL>self, resource_group_name, circuit_name, peering_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", peering_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ExpressRouteCircuitConnectionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ExpressRouteCircuitConnectionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all global reach connections associated with a private peering in\n        an express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ExpressRouteCircuitConnection\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.ExpressRouteCircuitConnectionPaged[~azure.mgmt.network.v2018_11_01.models.ExpressRouteCircuitConnection]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32790:c0:m6"}
{"signature": "def delete(<EOL>self, resource_group_name, circuit_name, peering_name, connection_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>peering_name=peering_name,<EOL>connection_name=connection_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified Express Route Circuit Connection from the\n        specified express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param connection_name: The name of the express route circuit\n         connection.\n        :type connection_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32790:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, virtual_network_name, virtual_network_peering_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_name=virtual_network_name,<EOL>virtual_network_peering_name=virtual_network_peering_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified virtual network peering.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param virtual_network_peering_name: The name of the virtual network\n         peering.\n        :type virtual_network_peering_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32791:c0:m2"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualNetworkPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualNetworkPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all virtual networks in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualNetwork\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.VirtualNetworkPaged[~azure.mgmt.network.v2018_11_01.models.VirtualNetwork]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32792:c0:m9"}
{"signature": "def list_usage(<EOL>self, resource_group_name, virtual_network_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_usage.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualNetworkUsagePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualNetworkUsagePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists usage stats.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualNetworkUsage\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.VirtualNetworkUsagePaged[~azure.mgmt.network.v2018_11_01.models.VirtualNetworkUsage]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32792:c0:m11"}
{"signature": "def check_ip_address_availability(<EOL>self, resource_group_name, virtual_network_name, ip_address, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.check_ip_address_availability.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", ip_address, '<STR_LIT:str>')<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Checks whether a private IP address is available for use.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param ip_address: The private IP address to be verified.\n        :type ip_address: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: IPAddressAvailabilityResult or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.IPAddressAvailabilityResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32792:c0:m10"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, circuit_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates an express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the circuit.\n        :type circuit_name: str\n        :param parameters: Parameters supplied to the create or update express\n         route circuit operation.\n        :type parameters:\n         ~azure.mgmt.network.v2018_11_01.models.ExpressRouteCircuit\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ExpressRouteCircuit or\n         ClientRawResponse<ExpressRouteCircuit> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_11_01.models.ExpressRouteCircuit]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_11_01.models.ExpressRouteCircuit]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32794:c0:m5"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ExpressRouteCircuitPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ExpressRouteCircuitPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the express route circuits in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ExpressRouteCircuit\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.ExpressRouteCircuitPaged[~azure.mgmt.network.v2018_11_01.models.ExpressRouteCircuit]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32794:c0:m17"}
{"signature": "def get_stats(<EOL>self, resource_group_name, circuit_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_stats.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the stats from an express route circuit in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteCircuitStats or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.ExpressRouteCircuitStats or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32794:c0:m14"}
{"signature": "def get(<EOL>self, resource_group_name, circuit_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about the specified express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of express route circuit.\n        :type circuit_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteCircuit or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_11_01.models.ExpressRouteCircuit or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32794:c0:m3"}
{"signature": "def get_peering_stats(<EOL>self, resource_group_name, circuit_name, peering_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_peering_stats.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", peering_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all stats from an express route circuit in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteCircuitStats or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.ExpressRouteCircuitStats or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32794:c0:m15"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PublicIPPrefixPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PublicIPPrefixPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all public IP prefixes in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PublicIPPrefix\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.PublicIPPrefixPaged[~azure.mgmt.network.v2018_11_01.models.PublicIPPrefix]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32795:c0:m9"}
{"signature": "def update_tags(<EOL>self, resource_group_name, public_ip_prefix_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>public_ip_prefix_name=public_ip_prefix_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates public IP prefix tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param public_ip_prefix_name: The name of the public IP prefix.\n        :type public_ip_prefix_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns PublicIPPrefix or\n         ClientRawResponse<PublicIPPrefix> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_11_01.models.PublicIPPrefix]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_11_01.models.PublicIPPrefix]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32795:c0:m7"}
{"signature": "def update_tags(<EOL>self, resource_group_name, application_security_group_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>application_security_group_name=application_security_group_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates an application security group's tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param application_security_group_name: The name of the application\n         security group.\n        :type application_security_group_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ApplicationSecurityGroup or\n         ClientRawResponse<ApplicationSecurityGroup> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_11_01.models.ApplicationSecurityGroup]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_11_01.models.ApplicationSecurityGroup]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32796:c0:m7"}
{"signature": "def get(<EOL>self, resource_group_name, application_security_group_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", application_security_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about the specified application security group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param application_security_group_name: The name of the application\n         security group.\n        :type application_security_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ApplicationSecurityGroup or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.ApplicationSecurityGroup or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32796:c0:m3"}
{"signature": "def list(<EOL>self, resource_group_name, circuit_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ExpressRouteCircuitAuthorizationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ExpressRouteCircuitAuthorizationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all authorizations in an express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the circuit.\n        :type circuit_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ExpressRouteCircuitAuthorization\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.ExpressRouteCircuitAuthorizationPaged[~azure.mgmt.network.v2018_11_01.models.ExpressRouteCircuitAuthorization]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32797:c0:m6"}
{"signature": "def get(<EOL>self, resource_group_name, circuit_name, authorization_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", authorization_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified authorization from the specified express route\n        circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param authorization_name: The name of the authorization.\n        :type authorization_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteCircuitAuthorization or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.ExpressRouteCircuitAuthorization\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32797:c0:m3"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ExpressRouteServiceProviderPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ExpressRouteServiceProviderPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the available express route service providers.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ExpressRouteServiceProvider\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.ExpressRouteServiceProviderPaged[~azure.mgmt.network.v2018_11_01.models.ExpressRouteServiceProvider]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32798:c0:m1"}
{"signature": "def get(<EOL>self, resource_group_name, virtual_hub_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_hub_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves the details of a VirtualHub.\n\n        :param resource_group_name: The resource group name of the VirtualHub.\n        :type resource_group_name: str\n        :param virtual_hub_name: The name of the VirtualHub.\n        :type virtual_hub_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualHub or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_11_01.models.VirtualHub or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_11_01.models.ErrorException>`", "id": "f32799:c0:m1"}
{"signature": "def update_tags(<EOL>self, resource_group_name, virtual_hub_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_hub_name=virtual_hub_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates VirtualHub tags.\n\n        :param resource_group_name: The resource group name of the VirtualHub.\n        :type resource_group_name: str\n        :param virtual_hub_name: The name of the VirtualHub.\n        :type virtual_hub_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualHub or\n         ClientRawResponse<VirtualHub> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_11_01.models.VirtualHub]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_11_01.models.VirtualHub]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_11_01.models.ErrorException>`", "id": "f32799:c0:m5"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualHubPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualHubPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all the VirtualHubs in a resource group.\n\n        :param resource_group_name: The resource group name of the VirtualHub.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualHub\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.VirtualHubPaged[~azure.mgmt.network.v2018_11_01.models.VirtualHub]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_11_01.models.ErrorException>`", "id": "f32799:c0:m8"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, virtual_hub_name, virtual_hub_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_hub_name=virtual_hub_name,<EOL>virtual_hub_parameters=virtual_hub_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates a VirtualHub resource if it doesn't exist else updates the\n        existing VirtualHub.\n\n        :param resource_group_name: The resource group name of the VirtualHub.\n        :type resource_group_name: str\n        :param virtual_hub_name: The name of the VirtualHub.\n        :type virtual_hub_name: str\n        :param virtual_hub_parameters: Parameters supplied to create or update\n         VirtualHub.\n        :type virtual_hub_parameters:\n         ~azure.mgmt.network.v2018_11_01.models.VirtualHub\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualHub or\n         ClientRawResponse<VirtualHub> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_11_01.models.VirtualHub]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_11_01.models.VirtualHub]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_11_01.models.ErrorException>`", "id": "f32799:c0:m3"}
{"signature": "def get(<EOL>self, location_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", location_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves a single ExpressRoutePort peering location, including the\n        list of available bandwidths available at said peering location.\n\n        :param location_name: Name of the requested ExpressRoutePort peering\n         location.\n        :type location_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRoutePortsLocation or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.ExpressRoutePortsLocation or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32801:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, virtual_network_name, subnet_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_name=virtual_network_name,<EOL>subnet_name=subnet_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified subnet.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param subnet_name: The name of the subnet.\n        :type subnet_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32802:c0:m2"}
{"signature": "def list(<EOL>self, location, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.AvailableDelegationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.AvailableDelegationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all of the available subnet delegations for this resource group in\n        this region.\n\n        :param location: The location of the domain name.\n        :type location: str\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of AvailableDelegation\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.AvailableDelegationPaged[~azure.mgmt.network.v2018_11_01.models.AvailableDelegation]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32803:c0:m1"}
{"signature": "def get(<EOL>self, resource_group_name, public_ip_address_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", public_ip_address_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified public IP address in a specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param public_ip_address_name: The name of the subnet.\n        :type public_ip_address_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PublicIPAddress or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_11_01.models.PublicIPAddress or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32804:c0:m3"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, public_ip_address_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>public_ip_address_name=public_ip_address_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a static or dynamic public IP address.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param public_ip_address_name: The name of the public IP address.\n        :type public_ip_address_name: str\n        :param parameters: Parameters supplied to the create or update public\n         IP address operation.\n        :type parameters:\n         ~azure.mgmt.network.v2018_11_01.models.PublicIPAddress\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns PublicIPAddress or\n         ClientRawResponse<PublicIPAddress> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_11_01.models.PublicIPAddress]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_11_01.models.PublicIPAddress]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32804:c0:m5"}
{"signature": "def get(<EOL>self, resource_group_name, cross_connection_name, peering_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", cross_connection_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", peering_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified peering for the ExpressRouteCrossConnection.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param cross_connection_name: The name of the\n         ExpressRouteCrossConnection.\n        :type cross_connection_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteCrossConnectionPeering or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.ExpressRouteCrossConnectionPeering\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32805:c0:m4"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, cross_connection_name, peering_name, peering_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>cross_connection_name=cross_connection_name,<EOL>peering_name=peering_name,<EOL>peering_parameters=peering_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a peering in the specified\n        ExpressRouteCrossConnection.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param cross_connection_name: The name of the\n         ExpressRouteCrossConnection.\n        :type cross_connection_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param peering_parameters: Parameters supplied to the create or update\n         ExpressRouteCrossConnection peering operation.\n        :type peering_parameters:\n         ~azure.mgmt.network.v2018_11_01.models.ExpressRouteCrossConnectionPeering\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCrossConnectionPeering or\n         ClientRawResponse<ExpressRouteCrossConnectionPeering> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_11_01.models.ExpressRouteCrossConnectionPeering]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_11_01.models.ExpressRouteCrossConnectionPeering]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32805:c0:m6"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, express_route_gateway_name, connection_name, put_express_route_connection_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>express_route_gateway_name=express_route_gateway_name,<EOL>connection_name=connection_name,<EOL>put_express_route_connection_parameters=put_express_route_connection_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates a connection between an ExpressRoute gateway and an\n        ExpressRoute circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param express_route_gateway_name: The name of the ExpressRoute\n         gateway.\n        :type express_route_gateway_name: str\n        :param connection_name: The name of the connection subresource.\n        :type connection_name: str\n        :param put_express_route_connection_parameters: Parameters required in\n         an ExpressRouteConnection PUT operation.\n        :type put_express_route_connection_parameters:\n         ~azure.mgmt.network.v2018_11_01.models.ExpressRouteConnection\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ExpressRouteConnection\n         or ClientRawResponse<ExpressRouteConnection> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_11_01.models.ExpressRouteConnection]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_11_01.models.ExpressRouteConnection]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32808:c0:m2"}
{"signature": "def list(<EOL>self, location, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.EndpointServiceResultPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.EndpointServiceResultPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List what values of endpoint services are available for use.\n\n        :param location: The location to check available endpoint services.\n        :type location: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of EndpointServiceResult\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.EndpointServiceResultPaged[~azure.mgmt.network.v2018_11_01.models.EndpointServiceResult]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32809:c0:m1"}
{"signature": "def verify_ip_flow(<EOL>self, resource_group_name, network_watcher_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._verify_ip_flow_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Verify IP flow from the specified VM to a location given the currently\n        configured NSG rules.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param parameters: Parameters that define the IP flow to be verified.\n        :type parameters:\n         ~azure.mgmt.network.v2018_11_01.models.VerificationIPFlowParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         VerificationIPFlowResult or\n         ClientRawResponse<VerificationIPFlowResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_11_01.models.VerificationIPFlowResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_11_01.models.VerificationIPFlowResult]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_11_01.models.ErrorResponseException>`", "id": "f32810:c0:m10"}
{"signature": "def get(<EOL>self, resource_group_name, network_watcher_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_watcher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified network watcher by resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: NetworkWatcher or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_11_01.models.NetworkWatcher or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_11_01.models.ErrorResponseException>`", "id": "f32810:c0:m2"}
{"signature": "def list_available_providers(<EOL>self, resource_group_name, network_watcher_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._list_available_providers_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Lists all available internet service providers for a specified Azure\n        region.\n\n        :param resource_group_name: The name of the network watcher resource\n         group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher resource.\n        :type network_watcher_name: str\n        :param parameters: Parameters that scope the list of available\n         providers.\n        :type parameters:\n         ~azure.mgmt.network.v2018_11_01.models.AvailableProvidersListParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns AvailableProvidersList\n         or ClientRawResponse<AvailableProvidersList> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_11_01.models.AvailableProvidersList]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_11_01.models.AvailableProvidersList]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_11_01.models.ErrorResponseException>`", "id": "f32810:c0:m28"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkWatcherPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkWatcherPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all network watchers by subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkWatcher\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.NetworkWatcherPaged[~azure.mgmt.network.v2018_11_01.models.NetworkWatcher]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_11_01.models.ErrorResponseException>`", "id": "f32810:c0:m7"}
{"signature": "def get_network_configuration_diagnostic(<EOL>self, resource_group_name, network_watcher_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_network_configuration_diagnostic_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT:location>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Get network configuration diagnostic.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param parameters: Parameters to get network configuration diagnostic.\n        :type parameters:\n         ~azure.mgmt.network.v2018_11_01.models.NetworkConfigurationDiagnosticParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         NetworkConfigurationDiagnosticResponse or\n         ClientRawResponse<NetworkConfigurationDiagnosticResponse> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_11_01.models.NetworkConfigurationDiagnosticResponse]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_11_01.models.NetworkConfigurationDiagnosticResponse]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_11_01.models.ErrorResponseException>`", "id": "f32810:c0:m30"}
{"signature": "def get_next_hop(<EOL>self, resource_group_name, network_watcher_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_next_hop_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the next hop from the specified VM.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param parameters: Parameters that define the source and destination\n         endpoint.\n        :type parameters:\n         ~azure.mgmt.network.v2018_11_01.models.NextHopParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns NextHopResult or\n         ClientRawResponse<NextHopResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_11_01.models.NextHopResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_11_01.models.NextHopResult]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_11_01.models.ErrorResponseException>`", "id": "f32810:c0:m12"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VpnSitePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VpnSitePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all the vpnSites in a resource group.\n\n        :param resource_group_name: The resource group name of the VpnSite.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VpnSite\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.VpnSitePaged[~azure.mgmt.network.v2018_11_01.models.VpnSite]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_11_01.models.ErrorException>`", "id": "f32811:c0:m8"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VpnSitePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VpnSitePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all the VpnSites in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VpnSite\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.VpnSitePaged[~azure.mgmt.network.v2018_11_01.models.VpnSite]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_11_01.models.ErrorException>`", "id": "f32811:c0:m9"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, vpn_site_name, vpn_site_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>vpn_site_name=vpn_site_name,<EOL>vpn_site_parameters=vpn_site_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates a VpnSite resource if it doesn't exist else updates the\n        existing VpnSite.\n\n        :param resource_group_name: The resource group name of the VpnSite.\n        :type resource_group_name: str\n        :param vpn_site_name: The name of the VpnSite being created or\n         updated.\n        :type vpn_site_name: str\n        :param vpn_site_parameters: Parameters supplied to create or update\n         VpnSite.\n        :type vpn_site_parameters:\n         ~azure.mgmt.network.v2018_11_01.models.VpnSite\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VpnSite or\n         ClientRawResponse<VpnSite> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_11_01.models.VpnSite]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_11_01.models.VpnSite]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_11_01.models.ErrorException>`", "id": "f32811:c0:m3"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ServiceEndpointPolicyPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ServiceEndpointPolicyPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all service endpoint Policies in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ServiceEndpointPolicy\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.ServiceEndpointPolicyPaged[~azure.mgmt.network.v2018_11_01.models.ServiceEndpointPolicy]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32813:c0:m9"}
{"signature": "def get(<EOL>self, resource_group_name, service_endpoint_policy_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", service_endpoint_policy_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified service Endpoint Policies in a specified resource\n        group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param service_endpoint_policy_name: The name of the service endpoint\n         policy.\n        :type service_endpoint_policy_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ServiceEndpointPolicy or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_11_01.models.ServiceEndpointPolicy\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32813:c0:m3"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ServiceEndpointPolicyPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ServiceEndpointPolicyPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the service endpoint policies in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ServiceEndpointPolicy\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.ServiceEndpointPolicyPaged[~azure.mgmt.network.v2018_11_01.models.ServiceEndpointPolicy]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32813:c0:m8"}
{"signature": "def get(<EOL>self, resource_group_name, virtual_wan_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_wan_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves the details of a VirtualWAN.\n\n        :param resource_group_name: The resource group name of the VirtualWan.\n        :type resource_group_name: str\n        :param virtual_wan_name: The name of the VirtualWAN being retrieved.\n        :type virtual_wan_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualWAN or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_11_01.models.VirtualWAN or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_11_01.models.ErrorException>`", "id": "f32814:c0:m1"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualWANPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualWANPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all the VirtualWANs in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualWAN\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.VirtualWANPaged[~azure.mgmt.network.v2018_11_01.models.VirtualWAN]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_11_01.models.ErrorException>`", "id": "f32814:c0:m9"}
{"signature": "def delete(<EOL>self, resource_group_name, virtual_wan_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_wan_name=virtual_wan_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes a VirtualWAN.\n\n        :param resource_group_name: The resource group name of the VirtualWan.\n        :type resource_group_name: str\n        :param virtual_wan_name: The name of the VirtualWAN being deleted.\n        :type virtual_wan_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_11_01.models.ErrorException>`", "id": "f32814:c0:m7"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, virtual_wan_name, wan_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_wan_name=virtual_wan_name,<EOL>wan_parameters=wan_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates a VirtualWAN resource if it doesn't exist else updates the\n        existing VirtualWAN.\n\n        :param resource_group_name: The resource group name of the VirtualWan.\n        :type resource_group_name: str\n        :param virtual_wan_name: The name of the VirtualWAN being created or\n         updated.\n        :type virtual_wan_name: str\n        :param wan_parameters: Parameters supplied to create or update\n         VirtualWAN.\n        :type wan_parameters:\n         ~azure.mgmt.network.v2018_11_01.models.VirtualWAN\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualWAN or\n         ClientRawResponse<VirtualWAN> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_11_01.models.VirtualWAN]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_11_01.models.VirtualWAN]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_11_01.models.ErrorException>`", "id": "f32814:c0:m3"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualWANPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualWANPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all the VirtualWANs in a resource group.\n\n        :param resource_group_name: The resource group name of the VirtualWan.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualWAN\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.VirtualWANPaged[~azure.mgmt.network.v2018_11_01.models.VirtualWAN]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_11_01.models.ErrorException>`", "id": "f32814:c0:m8"}
{"signature": "def delete(<EOL>self, resource_group_name, circuit_name, peering_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>peering_name=peering_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified peering from the specified express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32815:c0:m2"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, circuit_name, peering_name, peering_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>peering_name=peering_name,<EOL>peering_parameters=peering_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a peering in the specified express route circuits.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param peering_parameters: Parameters supplied to the create or update\n         express route circuit peering operation.\n        :type peering_parameters:\n         ~azure.mgmt.network.v2018_11_01.models.ExpressRouteCircuitPeering\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCircuitPeering or\n         ClientRawResponse<ExpressRouteCircuitPeering> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_11_01.models.ExpressRouteCircuitPeering]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_11_01.models.ExpressRouteCircuitPeering]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32815:c0:m5"}
{"signature": "def list_by_virtual_wan(<EOL>self, resource_group_name, virtual_wan_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_virtual_wan.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_wan_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.P2SVpnServerConfigurationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.P2SVpnServerConfigurationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves all P2SVpnServerConfigurations for a particular VirtualWan.\n\n        :param resource_group_name: The resource group name of the VirtualWan.\n        :type resource_group_name: str\n        :param virtual_wan_name: The name of the VirtualWan.\n        :type virtual_wan_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of P2SVpnServerConfiguration\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.P2SVpnServerConfigurationPaged[~azure.mgmt.network.v2018_11_01.models.P2SVpnServerConfiguration]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_11_01.models.ErrorException>`", "id": "f32816:c0:m6"}
{"signature": "def delete(<EOL>self, resource_group_name, virtual_wan_name, p2_svpn_server_configuration_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_wan_name=virtual_wan_name,<EOL>p2_svpn_server_configuration_name=p2_svpn_server_configuration_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes a P2SVpnServerConfiguration.\n\n        :param resource_group_name: The resource group name of the\n         P2SVpnServerConfiguration.\n        :type resource_group_name: str\n        :param virtual_wan_name: The name of the VirtualWan.\n        :type virtual_wan_name: str\n        :param p2_svpn_server_configuration_name: The name of the\n         P2SVpnServerConfiguration.\n        :type p2_svpn_server_configuration_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_11_01.models.ErrorException>`", "id": "f32816:c0:m5"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, virtual_wan_name, p2_svpn_server_configuration_name, p2_svpn_server_configuration_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_wan_name=virtual_wan_name,<EOL>p2_svpn_server_configuration_name=p2_svpn_server_configuration_name,<EOL>p2_svpn_server_configuration_parameters=p2_svpn_server_configuration_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates a P2SVpnServerConfiguration to associate with a VirtualWan if\n        it doesn't exist else updates the existing P2SVpnServerConfiguration.\n\n        :param resource_group_name: The resource group name of the VirtualWan.\n        :type resource_group_name: str\n        :param virtual_wan_name: The name of the VirtualWan.\n        :type virtual_wan_name: str\n        :param p2_svpn_server_configuration_name: The name of the\n         P2SVpnServerConfiguration.\n        :type p2_svpn_server_configuration_name: str\n        :param p2_svpn_server_configuration_parameters: Parameters supplied to\n         create or Update a P2SVpnServerConfiguration.\n        :type p2_svpn_server_configuration_parameters:\n         ~azure.mgmt.network.v2018_11_01.models.P2SVpnServerConfiguration\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         P2SVpnServerConfiguration or\n         ClientRawResponse<P2SVpnServerConfiguration> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_11_01.models.P2SVpnServerConfiguration]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_11_01.models.P2SVpnServerConfiguration]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_11_01.models.ErrorException>`", "id": "f32816:c0:m3"}
{"signature": "def list(<EOL>self, resource_group_name, load_balancer_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.FrontendIPConfigurationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.FrontendIPConfigurationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the load balancer frontend IP configurations.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of FrontendIPConfiguration\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.FrontendIPConfigurationPaged[~azure.mgmt.network.v2018_11_01.models.FrontendIPConfiguration]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32817:c0:m1"}
{"signature": "def get(<EOL>self, resource_group_name, route_table_name, route_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", route_table_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", route_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified route from a route table.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param route_name: The name of the route.\n        :type route_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Route or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_11_01.models.Route or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32818:c0:m3"}
{"signature": "def get(<EOL>self, resource_group_name, virtual_hub_name, connection_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_hub_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", connection_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves the details of a HubVirtualNetworkConnection.\n\n        :param resource_group_name: The resource group name of the VirtualHub.\n        :type resource_group_name: str\n        :param virtual_hub_name: The name of the VirtualHub.\n        :type virtual_hub_name: str\n        :param connection_name: The name of the vpn connection.\n        :type connection_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: HubVirtualNetworkConnection or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.HubVirtualNetworkConnection or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_11_01.models.ErrorException>`", "id": "f32819:c0:m1"}
{"signature": "def list(<EOL>self, resource_group_name, virtual_hub_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_hub_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.HubVirtualNetworkConnectionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.HubVirtualNetworkConnectionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves the details of all HubVirtualNetworkConnections.\n\n        :param resource_group_name: The resource group name of the VirtualHub.\n        :type resource_group_name: str\n        :param virtual_hub_name: The name of the VirtualHub.\n        :type virtual_hub_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of HubVirtualNetworkConnection\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.HubVirtualNetworkConnectionPaged[~azure.mgmt.network.v2018_11_01.models.HubVirtualNetworkConnection]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_11_01.models.ErrorException>`", "id": "f32819:c0:m2"}
{"signature": "def generatevpnclientpackage(<EOL>self, resource_group_name, virtual_network_gateway_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._generatevpnclientpackage_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_name=virtual_network_gateway_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT:str>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT:location>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Generates VPN client package for P2S client of the virtual network\n        gateway in the specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param parameters: Parameters supplied to the generate virtual network\n         gateway VPN client package operation.\n        :type parameters:\n         ~azure.mgmt.network.v2018_11_01.models.VpnClientParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns str or\n         ClientRawResponse<str> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[str] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[str]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32821:c0:m15"}
{"signature": "def list_connections(<EOL>self, resource_group_name, virtual_network_gateway_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_connections.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_gateway_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualNetworkGatewayConnectionListEntityPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualNetworkGatewayConnectionListEntityPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the connections in a virtual network gateway.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of\n         VirtualNetworkGatewayConnectionListEntity\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.VirtualNetworkGatewayConnectionListEntityPaged[~azure.mgmt.network.v2018_11_01.models.VirtualNetworkGatewayConnectionListEntity]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32821:c0:m9"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, virtual_network_gateway_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_name=virtual_network_gateway_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a virtual network gateway in the specified resource\n        group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param parameters: Parameters supplied to create or update virtual\n         network gateway operation.\n        :type parameters:\n         ~azure.mgmt.network.v2018_11_01.models.VirtualNetworkGateway\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualNetworkGateway\n         or ClientRawResponse<VirtualNetworkGateway> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_11_01.models.VirtualNetworkGateway]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_11_01.models.VirtualNetworkGateway]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32821:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, virtual_network_gateway_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_name=virtual_network_gateway_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified virtual network gateway.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32821:c0:m5"}
{"signature": "def update(<EOL>self, resource_group_name, route_filter_name, rule_name, route_filter_rule_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_filter_name=route_filter_name,<EOL>rule_name=rule_name,<EOL>route_filter_rule_parameters=route_filter_rule_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a route in the specified route filter.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param rule_name: The name of the route filter rule.\n        :type rule_name: str\n        :param route_filter_rule_parameters: Parameters supplied to the update\n         route filter rule operation.\n        :type route_filter_rule_parameters:\n         ~azure.mgmt.network.v2018_11_01.models.PatchRouteFilterRule\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns RouteFilterRule or\n         ClientRawResponse<RouteFilterRule> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_11_01.models.RouteFilterRule]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_11_01.models.RouteFilterRule]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32823:c0:m7"}
{"signature": "def list_virtual_machine_scale_set_vm_network_interfaces(<EOL>self, resource_group_name, virtual_machine_scale_set_name, virtualmachine_index, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_virtual_machine_scale_set_vm_network_interfaces.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_machine_scale_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtualmachine_index, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about all network interfaces in a virtual machine in a\n        virtual machine scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_machine_scale_set_name: The name of the virtual machine\n         scale set.\n        :type virtual_machine_scale_set_name: str\n        :param virtualmachine_index: The virtual machine index.\n        :type virtualmachine_index: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkInterface\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.NetworkInterfacePaged[~azure.mgmt.network.v2018_11_01.models.NetworkInterface]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32825:c0:m14"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all network interfaces in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkInterface\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.NetworkInterfacePaged[~azure.mgmt.network.v2018_11_01.models.NetworkInterface]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32825:c0:m8"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkSecurityGroupPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkSecurityGroupPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all network security groups in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkSecurityGroup\n        :rtype:\n         ~azure.mgmt.network.v2018_11_01.models.NetworkSecurityGroupPaged[~azure.mgmt.network.v2018_11_01.models.NetworkSecurityGroup]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f32826:c0:m9"}
{"signature": "def list(<EOL>self, resource_group_name, network_interface_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_interface_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkInterfaceIPConfigurationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkInterfaceIPConfigurationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get all ip configurations in a network interface.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkInterfaceIPConfiguration\n        :rtype:\n         ~azure.mgmt.network.v2017_10_01.models.NetworkInterfaceIPConfigurationPaged[~azure.mgmt.network.v2017_10_01.models.NetworkInterfaceIPConfiguration]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33110:c0:m1"}
{"signature": "def get_status(<EOL>self, resource_group_name, network_watcher_name, packet_capture_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_status_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>packet_capture_name=packet_capture_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT:location>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Query the status of a running packet capture session.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the Network Watcher resource.\n        :type network_watcher_name: str\n        :param packet_capture_name: The name given to the packet capture\n         session.\n        :type packet_capture_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         PacketCaptureQueryStatusResult or\n         ClientRawResponse<PacketCaptureQueryStatusResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_10_01.models.PacketCaptureQueryStatusResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_10_01.models.PacketCaptureQueryStatusResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33113:c0:m9"}
{"signature": "def create(<EOL>self, resource_group_name, network_watcher_name, packet_capture_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>packet_capture_name=packet_capture_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Create and start a packet capture on the specified VM.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param packet_capture_name: The name of the packet capture session.\n        :type packet_capture_name: str\n        :param parameters: Parameters that define the create packet capture\n         operation.\n        :type parameters: ~azure.mgmt.network.v2017_10_01.models.PacketCapture\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns PacketCaptureResult or\n         ClientRawResponse<PacketCaptureResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_10_01.models.PacketCaptureResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_10_01.models.PacketCaptureResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33113:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, network_watcher_name, packet_capture_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>packet_capture_name=packet_capture_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified packet capture session.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param packet_capture_name: The name of the packet capture session.\n        :type packet_capture_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33113:c0:m5"}
{"signature": "def list(<EOL>self, resource_group_name, network_watcher_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_watcher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PacketCaptureResultPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PacketCaptureResultPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all packet capture sessions within the specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the Network Watcher resource.\n        :type network_watcher_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PacketCaptureResult\n        :rtype:\n         ~azure.mgmt.network.v2017_10_01.models.PacketCaptureResultPaged[~azure.mgmt.network.v2017_10_01.models.PacketCaptureResult]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33113:c0:m10"}
{"signature": "def set_shared_key(<EOL>self, resource_group_name, virtual_network_gateway_connection_name, value, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._set_shared_key_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_connection_name=virtual_network_gateway_connection_name,<EOL>value=value,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The Put VirtualNetworkGatewayConnectionSharedKey operation sets the\n        virtual network gateway connection shared key for passed virtual\n        network gateway connection in the specified resource group through\n        Network resource provider.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_connection_name: The virtual network\n         gateway connection name.\n        :type virtual_network_gateway_connection_name: str\n        :param value: The virtual network connection shared key value.\n        :type value: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ConnectionSharedKey or\n         ClientRawResponse<ConnectionSharedKey> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_10_01.models.ConnectionSharedKey]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_10_01.models.ConnectionSharedKey]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33114:c0:m9"}
{"signature": "def reset_shared_key(<EOL>self, resource_group_name, virtual_network_gateway_connection_name, key_length, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._reset_shared_key_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_connection_name=virtual_network_gateway_connection_name,<EOL>key_length=key_length,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The VirtualNetworkGatewayConnectionResetSharedKey operation resets the\n        virtual network gateway connection shared key for passed virtual\n        network gateway connection in the specified resource group through\n        Network resource provider.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_connection_name: The virtual network\n         gateway connection reset shared key Name.\n        :type virtual_network_gateway_connection_name: str\n        :param key_length: The virtual network connection reset shared key\n         length, should between 1 and 128.\n        :type key_length: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ConnectionResetSharedKey or\n         ClientRawResponse<ConnectionResetSharedKey> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_10_01.models.ConnectionResetSharedKey]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_10_01.models.ConnectionResetSharedKey]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33114:c0:m13"}
{"signature": "def delete(<EOL>self, resource_group_name, virtual_network_gateway_connection_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_connection_name=virtual_network_gateway_connection_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified virtual network Gateway connection.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_connection_name: The name of the\n         virtual network gateway connection.\n        :type virtual_network_gateway_connection_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33114:c0:m5"}
{"signature": "def get_shared_key(<EOL>self, resource_group_name, virtual_network_gateway_connection_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_shared_key.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_gateway_connection_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "The Get VirtualNetworkGatewayConnectionSharedKey operation retrieves\n        information about the specified virtual network gateway connection\n        shared key through Network resource provider.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_connection_name: The virtual network\n         gateway connection shared key name.\n        :type virtual_network_gateway_connection_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ConnectionSharedKey or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_10_01.models.ConnectionSharedKey or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33114:c0:m10"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.BgpServiceCommunityPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.BgpServiceCommunityPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the available bgp service communities.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of BgpServiceCommunity\n        :rtype:\n         ~azure.mgmt.network.v2017_10_01.models.BgpServiceCommunityPaged[~azure.mgmt.network.v2017_10_01.models.BgpServiceCommunity]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33115:c0:m1"}
{"signature": "def get(<EOL>self, resource_group_name, application_gateway_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", application_gateway_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified application gateway.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param application_gateway_name: The name of the application gateway.\n        :type application_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ApplicationGateway or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_10_01.models.ApplicationGateway or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33116:c0:m3"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RouteFilterPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RouteFilterPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all route filters in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of RouteFilter\n        :rtype:\n         ~azure.mgmt.network.v2017_10_01.models.RouteFilterPaged[~azure.mgmt.network.v2017_10_01.models.RouteFilter]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33117:c0:m8"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RouteFilterPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RouteFilterPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all route filters in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of RouteFilter\n        :rtype:\n         ~azure.mgmt.network.v2017_10_01.models.RouteFilterPaged[~azure.mgmt.network.v2017_10_01.models.RouteFilter]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33117:c0:m9"}
{"signature": "def delete(<EOL>self, resource_group_name, network_watcher_name, connection_monitor_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>connection_monitor_name=connection_monitor_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified connection monitor.\n\n        :param resource_group_name: The name of the resource group containing\n         Network Watcher.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the Network Watcher resource.\n        :type network_watcher_name: str\n        :param connection_monitor_name: The name of the connection monitor.\n        :type connection_monitor_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33118:c0:m5"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, network_watcher_name, connection_monitor_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>connection_monitor_name=connection_monitor_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Create or update a connection monitor.\n\n        :param resource_group_name: The name of the resource group containing\n         Network Watcher.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the Network Watcher resource.\n        :type network_watcher_name: str\n        :param connection_monitor_name: The name of the connection monitor.\n        :type connection_monitor_name: str\n        :param parameters: Parameters that define the operation to create a\n         connection monitor.\n        :type parameters:\n         ~azure.mgmt.network.v2017_10_01.models.ConnectionMonitor\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ConnectionMonitorResult\n         or ClientRawResponse<ConnectionMonitorResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_10_01.models.ConnectionMonitorResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_10_01.models.ConnectionMonitorResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33118:c0:m2"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, local_network_gateway_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>local_network_gateway_name=local_network_gateway_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a local network gateway in the specified resource\n        group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param local_network_gateway_name: The name of the local network\n         gateway.\n        :type local_network_gateway_name: str\n        :param parameters: Parameters supplied to the create or update local\n         network gateway operation.\n        :type parameters:\n         ~azure.mgmt.network.v2017_10_01.models.LocalNetworkGateway\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns LocalNetworkGateway or\n         ClientRawResponse<LocalNetworkGateway> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_10_01.models.LocalNetworkGateway]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_10_01.models.LocalNetworkGateway]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33119:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, local_network_gateway_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", local_network_gateway_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified local network gateway in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param local_network_gateway_name: The name of the local network\n         gateway.\n        :type local_network_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: LocalNetworkGateway or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_10_01.models.LocalNetworkGateway or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33119:c0:m3"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RouteTablePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RouteTablePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all route tables in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of RouteTable\n        :rtype:\n         ~azure.mgmt.network.v2017_10_01.models.RouteTablePaged[~azure.mgmt.network.v2017_10_01.models.RouteTable]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33121:c0:m9"}
{"signature": "def update_tags(<EOL>self, resource_group_name, route_table_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_table_name=route_table_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a route table tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns RouteTable or\n         ClientRawResponse<RouteTable> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_10_01.models.RouteTable]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_10_01.models.RouteTable]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33121:c0:m7"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, route_table_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_table_name=route_table_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Create or updates a route table in a specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param parameters: Parameters supplied to the create or update route\n         table operation.\n        :type parameters: ~azure.mgmt.network.v2017_10_01.models.RouteTable\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns RouteTable or\n         ClientRawResponse<RouteTable> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_10_01.models.RouteTable]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_10_01.models.RouteTable]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33121:c0:m5"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, virtual_network_name, virtual_network_peering_name, virtual_network_peering_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_name=virtual_network_name,<EOL>virtual_network_peering_name=virtual_network_peering_name,<EOL>virtual_network_peering_parameters=virtual_network_peering_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a peering in the specified virtual network.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param virtual_network_peering_name: The name of the peering.\n        :type virtual_network_peering_name: str\n        :param virtual_network_peering_parameters: Parameters supplied to the\n         create or update virtual network peering operation.\n        :type virtual_network_peering_parameters:\n         ~azure.mgmt.network.v2017_10_01.models.VirtualNetworkPeering\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualNetworkPeering\n         or ClientRawResponse<VirtualNetworkPeering> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_10_01.models.VirtualNetworkPeering]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_10_01.models.VirtualNetworkPeering]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33123:c0:m5"}
{"signature": "def list(<EOL>self, resource_group_name, virtual_network_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualNetworkPeeringPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualNetworkPeeringPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all virtual network peerings in a virtual network.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualNetworkPeering\n        :rtype:\n         ~azure.mgmt.network.v2017_10_01.models.VirtualNetworkPeeringPaged[~azure.mgmt.network.v2017_10_01.models.VirtualNetworkPeering]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33123:c0:m6"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualNetworkPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualNetworkPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all virtual networks in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualNetwork\n        :rtype:\n         ~azure.mgmt.network.v2017_10_01.models.VirtualNetworkPaged[~azure.mgmt.network.v2017_10_01.models.VirtualNetwork]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33124:c0:m8"}
{"signature": "def list_usage(<EOL>self, resource_group_name, virtual_network_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_usage.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualNetworkUsagePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualNetworkUsagePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists usage stats.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualNetworkUsage\n        :rtype:\n         ~azure.mgmt.network.v2017_10_01.models.VirtualNetworkUsagePaged[~azure.mgmt.network.v2017_10_01.models.VirtualNetworkUsage]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33124:c0:m11"}
{"signature": "def check_ip_address_availability(<EOL>self, resource_group_name, virtual_network_name, ip_address=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.check_ip_address_availability.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if ip_address is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", ip_address, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Checks whether a private IP address is available for use.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param ip_address: The private IP address to be verified.\n        :type ip_address: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: IPAddressAvailabilityResult or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2017_10_01.models.IPAddressAvailabilityResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33124:c0:m10"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, circuit_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates an express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the circuit.\n        :type circuit_name: str\n        :param parameters: Parameters supplied to the create or update express\n         route circuit operation.\n        :type parameters:\n         ~azure.mgmt.network.v2017_10_01.models.ExpressRouteCircuit\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ExpressRouteCircuit or\n         ClientRawResponse<ExpressRouteCircuit> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_10_01.models.ExpressRouteCircuit]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_10_01.models.ExpressRouteCircuit]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33126:c0:m5"}
{"signature": "def get_stats(<EOL>self, resource_group_name, circuit_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_stats.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the stats from an express route circuit in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteCircuitStats or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2017_10_01.models.ExpressRouteCircuitStats or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33126:c0:m14"}
{"signature": "def update_tags(<EOL>self, resource_group_name, circuit_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates an express route circuit tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the circuit.\n        :type circuit_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ExpressRouteCircuit or\n         ClientRawResponse<ExpressRouteCircuit> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_10_01.models.ExpressRouteCircuit]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_10_01.models.ExpressRouteCircuit]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33126:c0:m7"}
{"signature": "def list_routes_table(<EOL>self, resource_group_name, circuit_name, peering_name, device_path, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._list_routes_table_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>peering_name=peering_name,<EOL>device_path=device_path,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the currently advertised routes table associated with the express\n        route circuit in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param device_path: The path of the device.\n        :type device_path: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCircuitsRoutesTableListResult or\n         ClientRawResponse<ExpressRouteCircuitsRoutesTableListResult> if\n         raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_10_01.models.ExpressRouteCircuitsRoutesTableListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_10_01.models.ExpressRouteCircuitsRoutesTableListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33126:c0:m11"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, application_security_group_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>application_security_group_name=application_security_group_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates an application security group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param application_security_group_name: The name of the application\n         security group.\n        :type application_security_group_name: str\n        :param parameters: Parameters supplied to the create or update\n         ApplicationSecurityGroup operation.\n        :type parameters:\n         ~azure.mgmt.network.v2017_10_01.models.ApplicationSecurityGroup\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ApplicationSecurityGroup or\n         ClientRawResponse<ApplicationSecurityGroup> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_10_01.models.ApplicationSecurityGroup]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_10_01.models.ApplicationSecurityGroup]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33127:c0:m5"}
{"signature": "def delete(<EOL>self, resource_group_name, circuit_name, authorization_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>authorization_name=authorization_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified authorization from the specified express route\n        circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param authorization_name: The name of the authorization.\n        :type authorization_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33128:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, network_security_group_name, security_rule_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_security_group_name=network_security_group_name,<EOL>security_rule_name=security_rule_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified network security rule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param security_rule_name: The name of the security rule.\n        :type security_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33130:c0:m2"}
{"signature": "def list(<EOL>self, resource_group_name, virtual_network_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SubnetPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SubnetPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all subnets in a virtual network.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Subnet\n        :rtype:\n         ~azure.mgmt.network.v2017_10_01.models.SubnetPaged[~azure.mgmt.network.v2017_10_01.models.Subnet]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33131:c0:m6"}
{"signature": "def get(<EOL>self, resource_group_name, virtual_network_name, subnet_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", subnet_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified subnet by virtual network and resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param subnet_name: The name of the subnet.\n        :type subnet_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Subnet or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_10_01.models.Subnet or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33131:c0:m3"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, virtual_network_name, subnet_name, subnet_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_name=virtual_network_name,<EOL>subnet_name=subnet_name,<EOL>subnet_parameters=subnet_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a subnet in the specified virtual network.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param subnet_name: The name of the subnet.\n        :type subnet_name: str\n        :param subnet_parameters: Parameters supplied to the create or update\n         subnet operation.\n        :type subnet_parameters: ~azure.mgmt.network.v2017_10_01.models.Subnet\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Subnet or\n         ClientRawResponse<Subnet> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_10_01.models.Subnet]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_10_01.models.Subnet]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33131:c0:m5"}
{"signature": "def list_virtual_machine_scale_set_public_ip_addresses(<EOL>self, resource_group_name, virtual_machine_scale_set_name, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_virtual_machine_scale_set_public_ip_addresses.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_machine_scale_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PublicIPAddressPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PublicIPAddressPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about all public IP addresses on a virtual machine\n        scale set level.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_machine_scale_set_name: The name of the virtual machine\n         scale set.\n        :type virtual_machine_scale_set_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PublicIPAddress\n        :rtype:\n         ~azure.mgmt.network.v2017_10_01.models.PublicIPAddressPaged[~azure.mgmt.network.v2017_10_01.models.PublicIPAddress]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33132:c0:m10"}
{"signature": "def update_tags(<EOL>self, resource_group_name, public_ip_address_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>public_ip_address_name=public_ip_address_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates public IP address tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param public_ip_address_name: The name of the public IP address.\n        :type public_ip_address_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns PublicIPAddress or\n         ClientRawResponse<PublicIPAddress> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_10_01.models.PublicIPAddress]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_10_01.models.PublicIPAddress]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33132:c0:m7"}
{"signature": "def delete(<EOL>self, resource_group_name, public_ip_address_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>public_ip_address_name=public_ip_address_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified public IP address.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param public_ip_address_name: The name of the subnet.\n        :type public_ip_address_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33132:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, network_watcher_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified network watcher resource.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33135:c0:m4"}
{"signature": "def set_flow_log_configuration(<EOL>self, resource_group_name, network_watcher_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._set_flow_log_configuration_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Configures flow log on a specified resource.\n\n        :param resource_group_name: The name of the network watcher resource\n         group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher resource.\n        :type network_watcher_name: str\n        :param parameters: Parameters that define the configuration of flow\n         log.\n        :type parameters:\n         ~azure.mgmt.network.v2017_10_01.models.FlowLogInformation\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns FlowLogInformation or\n         ClientRawResponse<FlowLogInformation> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_10_01.models.FlowLogInformation]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_10_01.models.FlowLogInformation]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33135:c0:m20"}
{"signature": "def update_tags(<EOL>self, resource_group_name, network_watcher_name, tags=None, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.TagsObject(tags=tags)<EOL>url = self.update_tags.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_watcher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Updates a network watcher tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: NetworkWatcher or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_10_01.models.NetworkWatcher or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33135:c0:m5"}
{"signature": "def get_vm_security_rules(<EOL>self, resource_group_name, network_watcher_name, target_resource_id, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_vm_security_rules_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>target_resource_id=target_resource_id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the configured and effective security group rules on the specified\n        VM.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param target_resource_id: ID of the target VM.\n        :type target_resource_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns SecurityGroupViewResult\n         or ClientRawResponse<SecurityGroupViewResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_10_01.models.SecurityGroupViewResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_10_01.models.SecurityGroupViewResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33135:c0:m14"}
{"signature": "def get(<EOL>self, resource_group_name, circuit_name, peering_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", peering_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified authorization from the specified express route\n        circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteCircuitPeering or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2017_10_01.models.ExpressRouteCircuitPeering or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33137:c0:m3"}
{"signature": "def list(<EOL>self, resource_group_name, load_balancer_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.FrontendIPConfigurationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.FrontendIPConfigurationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the load balancer frontend IP configurations.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of FrontendIPConfiguration\n        :rtype:\n         ~azure.mgmt.network.v2017_10_01.models.FrontendIPConfigurationPaged[~azure.mgmt.network.v2017_10_01.models.FrontendIPConfiguration]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33138:c0:m1"}
{"signature": "def get(<EOL>self, resource_group_name, load_balancer_name, frontend_ip_configuration_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", frontend_ip_configuration_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets load balancer frontend IP configuration.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param frontend_ip_configuration_name: The name of the frontend IP\n         configuration.\n        :type frontend_ip_configuration_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: FrontendIPConfiguration or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_10_01.models.FrontendIPConfiguration\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33138:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, route_table_name, route_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", route_table_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", route_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified route from a route table.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param route_name: The name of the route.\n        :type route_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Route or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_10_01.models.Route or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33139:c0:m3"}
{"signature": "def list(<EOL>self, resource_group_name, route_table_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", route_table_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RoutePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RoutePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all routes in a route table.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Route\n        :rtype:\n         ~azure.mgmt.network.v2017_10_01.models.RoutePaged[~azure.mgmt.network.v2017_10_01.models.Route]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33139:c0:m6"}
{"signature": "def list_connections(<EOL>self, resource_group_name, virtual_network_gateway_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_connections.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_gateway_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualNetworkGatewayConnectionListEntityPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualNetworkGatewayConnectionListEntityPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the connections in a virtual network gateway.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of\n         VirtualNetworkGatewayConnectionListEntity\n        :rtype:\n         ~azure.mgmt.network.v2017_10_01.models.VirtualNetworkGatewayConnectionListEntityPaged[~azure.mgmt.network.v2017_10_01.models.VirtualNetworkGatewayConnectionListEntity]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33140:c0:m9"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualNetworkGatewayPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualNetworkGatewayPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all virtual network gateways by resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualNetworkGateway\n        :rtype:\n         ~azure.mgmt.network.v2017_10_01.models.VirtualNetworkGatewayPaged[~azure.mgmt.network.v2017_10_01.models.VirtualNetworkGateway]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33140:c0:m8"}
{"signature": "def update_tags(<EOL>self, resource_group_name, virtual_network_gateway_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_name=virtual_network_gateway_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a virtual network gateway tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualNetworkGateway\n         or ClientRawResponse<VirtualNetworkGateway> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_10_01.models.VirtualNetworkGateway]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_10_01.models.VirtualNetworkGateway]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33140:c0:m7"}
{"signature": "def get_advertised_routes(<EOL>self, resource_group_name, virtual_network_gateway_name, peer, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_advertised_routes_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_name=virtual_network_gateway_name,<EOL>peer=peer,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "This operation retrieves a list of routes the virtual network gateway\n        is advertising to the specified peer.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param peer: The IP address of the peer\n        :type peer: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns GatewayRouteListResult\n         or ClientRawResponse<GatewayRouteListResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_10_01.models.GatewayRouteListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_10_01.models.GatewayRouteListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33140:c0:m23"}
{"signature": "def reset(<EOL>self, resource_group_name, virtual_network_gateway_name, gateway_vip=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._reset_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_name=virtual_network_gateway_name,<EOL>gateway_vip=gateway_vip,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Resets the primary of the virtual network gateway in the specified\n        resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param gateway_vip: Virtual network gateway vip address supplied to\n         the begin reset of the active-active feature enabled gateway.\n        :type gateway_vip: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualNetworkGateway\n         or ClientRawResponse<VirtualNetworkGateway> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_10_01.models.VirtualNetworkGateway]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_10_01.models.VirtualNetworkGateway]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33140:c0:m11"}
{"signature": "def delete(<EOL>self, resource_group_name, virtual_network_gateway_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_name=virtual_network_gateway_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified virtual network gateway.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33140:c0:m5"}
{"signature": "def get_bgp_peer_status(<EOL>self, resource_group_name, virtual_network_gateway_name, peer=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_bgp_peer_status_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_name=virtual_network_gateway_name,<EOL>peer=peer,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The GetBgpPeerStatus operation retrieves the status of all BGP peers.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param peer: The IP address of the peer to retrieve the status of.\n        :type peer: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns BgpPeerStatusListResult\n         or ClientRawResponse<BgpPeerStatusListResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_10_01.models.BgpPeerStatusListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_10_01.models.BgpPeerStatusListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33140:c0:m18"}
{"signature": "def vpn_device_configuration_script(<EOL>self, resource_group_name, virtual_network_gateway_connection_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.vpn_device_configuration_script.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_gateway_connection_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT:str>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a xml format representation for vpn device configuration script.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_connection_name: The name of the\n         virtual network gateway connection for which the configuration script\n         is generated.\n        :type virtual_network_gateway_connection_name: str\n        :param parameters: Parameters supplied to the generate vpn device\n         script operation.\n        :type parameters:\n         ~azure.mgmt.network.v2017_10_01.models.VpnDeviceScriptParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: str or ClientRawResponse if raw=true\n        :rtype: str or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33140:c0:m24"}
{"signature": "def delete(<EOL>self, resource_group_name, route_filter_name, rule_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_filter_name=route_filter_name,<EOL>rule_name=rule_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified rule from a route filter.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param rule_name: The name of the rule.\n        :type rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33142:c0:m2"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all network interfaces in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkInterface\n        :rtype:\n         ~azure.mgmt.network.v2017_10_01.models.NetworkInterfacePaged[~azure.mgmt.network.v2017_10_01.models.NetworkInterface]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33143:c0:m9"}
{"signature": "def get(<EOL>self, resource_group_name, network_interface_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_interface_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about the specified network interface.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: NetworkInterface or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_10_01.models.NetworkInterface or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33143:c0:m3"}
{"signature": "def check_dns_name_availability(<EOL>self, location, domain_name_label, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.check_dns_name_availability.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", domain_name_label, '<STR_LIT:str>')<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Checks whether a domain name in the cloudapp.azure.com zone is\n        available for use.\n\n        :param location: The location of the domain name.\n        :type location: str\n        :param domain_name_label: The domain name to be verified. It must\n         conform to the following regular expression:\n         ^[a-z][a-z0-9-]{1,61}[a-z0-9]$.\n        :type domain_name_label: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DnsNameAvailabilityResult or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2017_08_01.models.DnsNameAvailabilityResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33145:c1:m1"}
{"signature": "def get(<EOL>self, resource_group_name, load_balancer_name, probe_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", probe_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets load balancer probe.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param probe_name: The name of the probe.\n        :type probe_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Probe or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_08_01.models.Probe or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33397:c0:m2"}
{"signature": "def get_status(<EOL>self, resource_group_name, network_watcher_name, packet_capture_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_status_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>packet_capture_name=packet_capture_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT:location>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Query the status of a running packet capture session.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the Network Watcher resource.\n        :type network_watcher_name: str\n        :param packet_capture_name: The name given to the packet capture\n         session.\n        :type packet_capture_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         PacketCaptureQueryStatusResult or\n         ClientRawResponse<PacketCaptureQueryStatusResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_08_01.models.PacketCaptureQueryStatusResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_08_01.models.PacketCaptureQueryStatusResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33398:c0:m9"}
{"signature": "def stop(<EOL>self, resource_group_name, network_watcher_name, packet_capture_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._stop_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>packet_capture_name=packet_capture_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Stops a specified packet capture session.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param packet_capture_name: The name of the packet capture session.\n        :type packet_capture_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33398:c0:m7"}
{"signature": "def get(<EOL>self, resource_group_name, virtual_network_gateway_connection_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_gateway_connection_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified virtual network gateway connection by resource\n        group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_connection_name: The name of the\n         virtual network gateway connection.\n        :type virtual_network_gateway_connection_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualNetworkGatewayConnection or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.network.v2017_08_01.models.VirtualNetworkGatewayConnection\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33399:c0:m3"}
{"signature": "def delete(<EOL>self, resource_group_name, virtual_network_gateway_connection_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_connection_name=virtual_network_gateway_connection_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified virtual network Gateway connection.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_connection_name: The name of the\n         virtual network gateway connection.\n        :type virtual_network_gateway_connection_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33399:c0:m5"}
{"signature": "def get(<EOL>self, resource_group_name, application_gateway_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", application_gateway_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified application gateway.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param application_gateway_name: The name of the application gateway.\n        :type application_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ApplicationGateway or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_08_01.models.ApplicationGateway or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33401:c0:m3"}
{"signature": "def list_available_ssl_options(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_available_ssl_options.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists available Ssl options for configuring Ssl policy.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ApplicationGatewayAvailableSslOptions or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.network.v2017_08_01.models.ApplicationGatewayAvailableSslOptions\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33401:c0:m15"}
{"signature": "def list_available_waf_rule_sets(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_available_waf_rule_sets.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all available web application firewall rule sets.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ApplicationGatewayAvailableWafRuleSetsResult or\n         ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2017_08_01.models.ApplicationGatewayAvailableWafRuleSetsResult\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33401:c0:m14"}
{"signature": "def backend_health(<EOL>self, resource_group_name, application_gateway_name, expand=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._backend_health_initial(<EOL>resource_group_name=resource_group_name,<EOL>application_gateway_name=application_gateway_name,<EOL>expand=expand,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the backend health of the specified application gateway in a\n        resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param application_gateway_name: The name of the application gateway.\n        :type application_gateway_name: str\n        :param expand: Expands BackendAddressPool and BackendHttpSettings\n         referenced in backend health.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ApplicationGatewayBackendHealth or\n         ClientRawResponse<ApplicationGatewayBackendHealth> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_08_01.models.ApplicationGatewayBackendHealth]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_08_01.models.ApplicationGatewayBackendHealth]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33401:c0:m13"}
{"signature": "def delete(<EOL>self, resource_group_name, route_filter_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_filter_name=route_filter_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified route filter.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33402:c0:m2"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RouteFilterPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RouteFilterPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all route filters in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of RouteFilter\n        :rtype:\n         ~azure.mgmt.network.v2017_08_01.models.RouteFilterPaged[~azure.mgmt.network.v2017_08_01.models.RouteFilter]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33402:c0:m9"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.LocalNetworkGatewayPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.LocalNetworkGatewayPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the local network gateways in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of LocalNetworkGateway\n        :rtype:\n         ~azure.mgmt.network.v2017_08_01.models.LocalNetworkGatewayPaged[~azure.mgmt.network.v2017_08_01.models.LocalNetworkGateway]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33403:c0:m6"}
{"signature": "def get(<EOL>self, resource_group_name, local_network_gateway_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", local_network_gateway_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified local network gateway in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param local_network_gateway_name: The name of the local network\n         gateway.\n        :type local_network_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: LocalNetworkGateway or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_08_01.models.LocalNetworkGateway or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33403:c0:m3"}
{"signature": "def get(<EOL>self, resource_group_name, network_security_group_name, default_security_rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_security_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", default_security_rule_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the specified default network security rule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param default_security_rule_name: The name of the default security\n         rule.\n        :type default_security_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SecurityRule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_08_01.models.SecurityRule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33404:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, route_table_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_table_name=route_table_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified route table.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33405:c0:m2"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RouteTablePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RouteTablePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all route tables in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of RouteTable\n        :rtype:\n         ~azure.mgmt.network.v2017_08_01.models.RouteTablePaged[~azure.mgmt.network.v2017_08_01.models.RouteTable]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33405:c0:m7"}
{"signature": "def list(<EOL>self, resource_group_name, network_interface_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_interface_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.LoadBalancerPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.LoadBalancerPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List all load balancers in a network interface.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of LoadBalancer\n        :rtype:\n         ~azure.mgmt.network.v2017_08_01.models.LoadBalancerPaged[~azure.mgmt.network.v2017_08_01.models.LoadBalancer]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33406:c0:m1"}
{"signature": "def delete(<EOL>self, resource_group_name, virtual_network_name, virtual_network_peering_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_name=virtual_network_name,<EOL>virtual_network_peering_name=virtual_network_peering_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified virtual network peering.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param virtual_network_peering_name: The name of the virtual network\n         peering.\n        :type virtual_network_peering_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33407:c0:m2"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, load_balancer_name, inbound_nat_rule_name, inbound_nat_rule_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>load_balancer_name=load_balancer_name,<EOL>inbound_nat_rule_name=inbound_nat_rule_name,<EOL>inbound_nat_rule_parameters=inbound_nat_rule_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a load balancer inbound nat rule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param inbound_nat_rule_name: The name of the inbound nat rule.\n        :type inbound_nat_rule_name: str\n        :param inbound_nat_rule_parameters: Parameters supplied to the create\n         or update inbound nat rule operation.\n        :type inbound_nat_rule_parameters:\n         ~azure.mgmt.network.v2017_08_01.models.InboundNatRule\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns InboundNatRule or\n         ClientRawResponse<InboundNatRule> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_08_01.models.InboundNatRule]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_08_01.models.InboundNatRule]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33409:c0:m6"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ExpressRouteCircuitPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ExpressRouteCircuitPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the express route circuits in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ExpressRouteCircuit\n        :rtype:\n         ~azure.mgmt.network.v2017_08_01.models.ExpressRouteCircuitPaged[~azure.mgmt.network.v2017_08_01.models.ExpressRouteCircuit]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33410:c0:m14"}
{"signature": "def list_arp_table(<EOL>self, resource_group_name, circuit_name, peering_name, device_path, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._list_arp_table_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>peering_name=peering_name,<EOL>device_path=device_path,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the currently advertised ARP table associated with the express\n        route circuit in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param device_path: The path of the device.\n        :type device_path: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCircuitsArpTableListResult or\n         ClientRawResponse<ExpressRouteCircuitsArpTableListResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_08_01.models.ExpressRouteCircuitsArpTableListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_08_01.models.ExpressRouteCircuitsArpTableListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33410:c0:m7"}
{"signature": "def get_peering_stats(<EOL>self, resource_group_name, circuit_name, peering_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_peering_stats.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", peering_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all stats from an express route circuit in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteCircuitStats or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2017_08_01.models.ExpressRouteCircuitStats or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33410:c0:m13"}
{"signature": "def list(<EOL>self, resource_group_name, circuit_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ExpressRouteCircuitAuthorizationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ExpressRouteCircuitAuthorizationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all authorizations in an express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the circuit.\n        :type circuit_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ExpressRouteCircuitAuthorization\n        :rtype:\n         ~azure.mgmt.network.v2017_08_01.models.ExpressRouteCircuitAuthorizationPaged[~azure.mgmt.network.v2017_08_01.models.ExpressRouteCircuitAuthorization]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33411:c0:m6"}
{"signature": "def delete(<EOL>self, resource_group_name, circuit_name, authorization_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>authorization_name=authorization_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified authorization from the specified express route\n        circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param authorization_name: The name of the authorization.\n        :type authorization_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33411:c0:m2"}
{"signature": "def list(<EOL>self, resource_group_name, network_security_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_security_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SecurityRulePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SecurityRulePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all security rules in a network security group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of SecurityRule\n        :rtype:\n         ~azure.mgmt.network.v2017_08_01.models.SecurityRulePaged[~azure.mgmt.network.v2017_08_01.models.SecurityRule]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33413:c0:m6"}
{"signature": "def get(<EOL>self, resource_group_name, virtual_network_name, subnet_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", subnet_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified subnet by virtual network and resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param subnet_name: The name of the subnet.\n        :type subnet_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Subnet or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_08_01.models.Subnet or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33414:c0:m3"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PublicIPAddressPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PublicIPAddressPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all public IP addresses in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PublicIPAddress\n        :rtype:\n         ~azure.mgmt.network.v2017_08_01.models.PublicIPAddressPaged[~azure.mgmt.network.v2017_08_01.models.PublicIPAddress]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33415:c0:m7"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, public_ip_address_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>public_ip_address_name=public_ip_address_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a static or dynamic public IP address.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param public_ip_address_name: The name of the public IP address.\n        :type public_ip_address_name: str\n        :param parameters: Parameters supplied to the create or update public\n         IP address operation.\n        :type parameters:\n         ~azure.mgmt.network.v2017_08_01.models.PublicIPAddress\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns PublicIPAddress or\n         ClientRawResponse<PublicIPAddress> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_08_01.models.PublicIPAddress]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_08_01.models.PublicIPAddress]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33415:c0:m5"}
{"signature": "def list(<EOL>self, location, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.EndpointServiceResultPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.EndpointServiceResultPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List what values of endpoint services are available for use.\n\n        :param location: The location to check available endpoint services.\n        :type location: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of EndpointServiceResult\n        :rtype:\n         ~azure.mgmt.network.v2017_08_01.models.EndpointServiceResultPaged[~azure.mgmt.network.v2017_08_01.models.EndpointServiceResult]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33417:c0:m1"}
{"signature": "def get_troubleshooting(<EOL>self, resource_group_name, network_watcher_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_troubleshooting_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Initiate troubleshooting on a specified resource.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher resource.\n        :type network_watcher_name: str\n        :param parameters: Parameters that define the resource to\n         troubleshoot.\n        :type parameters:\n         ~azure.mgmt.network.v2017_08_01.models.TroubleshootingParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns TroubleshootingResult\n         or ClientRawResponse<TroubleshootingResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_08_01.models.TroubleshootingResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_08_01.models.TroubleshootingResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33418:c0:m15"}
{"signature": "def get_topology(<EOL>self, resource_group_name, network_watcher_name, target_resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.TopologyParameters(target_resource_group_name=target_resource_group_name)<EOL>url = self.get_topology.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_watcher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the current network topology by resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param target_resource_group_name: The name of the target resource\n         group to perform topology on.\n        :type target_resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Topology or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_08_01.models.Topology or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33418:c0:m7"}
{"signature": "def get_next_hop(<EOL>self, resource_group_name, network_watcher_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_next_hop_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the next hop from the specified VM.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param parameters: Parameters that define the source and destination\n         endpoint.\n        :type parameters:\n         ~azure.mgmt.network.v2017_08_01.models.NextHopParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns NextHopResult or\n         ClientRawResponse<NextHopResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_08_01.models.NextHopResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_08_01.models.NextHopResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33418:c0:m11"}
{"signature": "def get_flow_log_status(<EOL>self, resource_group_name, network_watcher_name, target_resource_id, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_flow_log_status_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>target_resource_id=target_resource_id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Queries status of flow log on a specified resource.\n\n        :param resource_group_name: The name of the network watcher resource\n         group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher resource.\n        :type network_watcher_name: str\n        :param target_resource_id: The target resource where getting the flow\n         logging status.\n        :type target_resource_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns FlowLogInformation or\n         ClientRawResponse<FlowLogInformation> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_08_01.models.FlowLogInformation]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_08_01.models.FlowLogInformation]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33418:c0:m21"}
{"signature": "def verify_ip_flow(<EOL>self, resource_group_name, network_watcher_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._verify_ip_flow_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Verify IP flow from the specified VM to a location given the currently\n        configured NSG rules.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param parameters: Parameters that define the IP flow to be verified.\n        :type parameters:\n         ~azure.mgmt.network.v2017_08_01.models.VerificationIPFlowParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         VerificationIPFlowResult or\n         ClientRawResponse<VerificationIPFlowResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_08_01.models.VerificationIPFlowResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_08_01.models.VerificationIPFlowResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33418:c0:m9"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkWatcherPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkWatcherPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all network watchers by subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkWatcher\n        :rtype:\n         ~azure.mgmt.network.v2017_08_01.models.NetworkWatcherPaged[~azure.mgmt.network.v2017_08_01.models.NetworkWatcher]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33418:c0:m6"}
{"signature": "def set_flow_log_configuration(<EOL>self, resource_group_name, network_watcher_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._set_flow_log_configuration_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Configures flow log on a specified resource.\n\n        :param resource_group_name: The name of the network watcher resource\n         group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher resource.\n        :type network_watcher_name: str\n        :param parameters: Parameters that define the configuration of flow\n         log.\n        :type parameters:\n         ~azure.mgmt.network.v2017_08_01.models.FlowLogInformation\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns FlowLogInformation or\n         ClientRawResponse<FlowLogInformation> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_08_01.models.FlowLogInformation]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_08_01.models.FlowLogInformation]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33418:c0:m19"}
{"signature": "def get(<EOL>self, resource_group_name, circuit_name, peering_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", peering_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified authorization from the specified express route\n        circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteCircuitPeering or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2017_08_01.models.ExpressRouteCircuitPeering or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33420:c0:m3"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, circuit_name, peering_name, peering_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>peering_name=peering_name,<EOL>peering_parameters=peering_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a peering in the specified express route circuits.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param peering_parameters: Parameters supplied to the create or update\n         express route circuit peering operation.\n        :type peering_parameters:\n         ~azure.mgmt.network.v2017_08_01.models.ExpressRouteCircuitPeering\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCircuitPeering or\n         ClientRawResponse<ExpressRouteCircuitPeering> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_08_01.models.ExpressRouteCircuitPeering]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_08_01.models.ExpressRouteCircuitPeering]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33420:c0:m5"}
{"signature": "def delete(<EOL>self, resource_group_name, route_table_name, route_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_table_name=route_table_name,<EOL>route_name=route_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified route from a route table.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param route_name: The name of the route.\n        :type route_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33422:c0:m2"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualNetworkGatewayPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualNetworkGatewayPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all virtual network gateways by resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualNetworkGateway\n        :rtype:\n         ~azure.mgmt.network.v2017_08_01.models.VirtualNetworkGatewayPaged[~azure.mgmt.network.v2017_08_01.models.VirtualNetworkGateway]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33423:c0:m6"}
{"signature": "def get(<EOL>self, resource_group_name, virtual_network_gateway_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_gateway_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified virtual network gateway by resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualNetworkGateway or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_08_01.models.VirtualNetworkGateway\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33423:c0:m3"}
{"signature": "def get_advertised_routes(<EOL>self, resource_group_name, virtual_network_gateway_name, peer, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_advertised_routes_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_name=virtual_network_gateway_name,<EOL>peer=peer,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "This operation retrieves a list of routes the virtual network gateway\n        is advertising to the specified peer.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param peer: The IP address of the peer\n        :type peer: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns GatewayRouteListResult\n         or ClientRawResponse<GatewayRouteListResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_08_01.models.GatewayRouteListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_08_01.models.GatewayRouteListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33423:c0:m20"}
{"signature": "def list(<EOL>self, resource_group_name, load_balancer_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.LoadBalancingRulePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.LoadBalancingRulePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the load balancing rules in a load balancer.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of LoadBalancingRule\n        :rtype:\n         ~azure.mgmt.network.v2017_08_01.models.LoadBalancingRulePaged[~azure.mgmt.network.v2017_08_01.models.LoadBalancingRule]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33424:c0:m1"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all network interfaces in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkInterface\n        :rtype:\n         ~azure.mgmt.network.v2017_08_01.models.NetworkInterfacePaged[~azure.mgmt.network.v2017_08_01.models.NetworkInterface]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33426:c0:m7"}
{"signature": "def get_effective_route_table(<EOL>self, resource_group_name, network_interface_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_effective_route_table_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_interface_name=network_interface_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets all route tables applied to a network interface.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         EffectiveRouteListResult or\n         ClientRawResponse<EffectiveRouteListResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2017_08_01.models.EffectiveRouteListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2017_08_01.models.EffectiveRouteListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33426:c0:m9"}
{"signature": "def delete(<EOL>self, resource_group_name, network_security_group_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_security_group_name=network_security_group_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified network security group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33427:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, network_security_group_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_security_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified network security group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: NetworkSecurityGroup or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2017_08_01.models.NetworkSecurityGroup or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33427:c0:m3"}
{"signature": "def list(<EOL>self, resource_group_name, load_balancer_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.BackendAddressPoolPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.BackendAddressPoolPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the load balancer backed address pools.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of BackendAddressPool\n        :rtype:\n         ~azure.mgmt.network.v2018_04_01.models.BackendAddressPoolPaged[~azure.mgmt.network.v2018_04_01.models.BackendAddressPool]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33769:c0:m1"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, load_balancer_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>load_balancer_name=load_balancer_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a load balancer.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param parameters: Parameters supplied to the create or update load\n         balancer operation.\n        :type parameters: ~azure.mgmt.network.v2018_04_01.models.LoadBalancer\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns LoadBalancer or\n         ClientRawResponse<LoadBalancer> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_04_01.models.LoadBalancer]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_04_01.models.LoadBalancer]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33770:c0:m5"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.LoadBalancerPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.LoadBalancerPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the load balancers in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of LoadBalancer\n        :rtype:\n         ~azure.mgmt.network.v2018_04_01.models.LoadBalancerPaged[~azure.mgmt.network.v2018_04_01.models.LoadBalancer]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33770:c0:m8"}
{"signature": "def get(<EOL>self, resource_group_name, load_balancer_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified load balancer.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: LoadBalancer or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_04_01.models.LoadBalancer or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33770:c0:m3"}
{"signature": "def list_routes_table_summary(<EOL>self, resource_group_name, cross_connection_name, peering_name, device_path, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._list_routes_table_summary_initial(<EOL>resource_group_name=resource_group_name,<EOL>cross_connection_name=cross_connection_name,<EOL>peering_name=peering_name,<EOL>device_path=device_path,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the route table summary associated with the express route cross\n        connection in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param cross_connection_name: The name of the\n         ExpressRouteCrossConnection.\n        :type cross_connection_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param device_path: The path of the device.\n        :type device_path: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCrossConnectionsRoutesTableSummaryListResult or\n         ClientRawResponse<ExpressRouteCrossConnectionsRoutesTableSummaryListResult>\n         if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_04_01.models.ExpressRouteCrossConnectionsRoutesTableSummaryListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_04_01.models.ExpressRouteCrossConnectionsRoutesTableSummaryListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33772:c0:m11"}
{"signature": "def list_routes_table(<EOL>self, resource_group_name, cross_connection_name, peering_name, device_path, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._list_routes_table_initial(<EOL>resource_group_name=resource_group_name,<EOL>cross_connection_name=cross_connection_name,<EOL>peering_name=peering_name,<EOL>device_path=device_path,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the currently advertised routes table associated with the express\n        route cross connection in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param cross_connection_name: The name of the\n         ExpressRouteCrossConnection.\n        :type cross_connection_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param device_path: The path of the device.\n        :type device_path: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCircuitsRoutesTableListResult or\n         ClientRawResponse<ExpressRouteCircuitsRoutesTableListResult> if\n         raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_04_01.models.ExpressRouteCircuitsRoutesTableListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_04_01.models.ExpressRouteCircuitsRoutesTableListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33772:c0:m13"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ExpressRouteCrossConnectionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ExpressRouteCrossConnectionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves all the ExpressRouteCrossConnections in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ExpressRouteCrossConnection\n        :rtype:\n         ~azure.mgmt.network.v2018_04_01.models.ExpressRouteCrossConnectionPaged[~azure.mgmt.network.v2018_04_01.models.ExpressRouteCrossConnection]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33772:c0:m2"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.OperationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.OperationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all of the available Network Rest API operations.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Operation\n        :rtype:\n         ~azure.mgmt.network.v2018_04_01.models.OperationPaged[~azure.mgmt.network.v2018_04_01.models.Operation]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33773:c0:m1"}
{"signature": "def get(<EOL>self, resource_group_name, load_balancer_name, probe_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", probe_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets load balancer probe.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param probe_name: The name of the probe.\n        :type probe_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Probe or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_04_01.models.Probe or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33774:c0:m2"}
{"signature": "def get_status(<EOL>self, resource_group_name, network_watcher_name, packet_capture_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_status_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>packet_capture_name=packet_capture_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT:location>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Query the status of a running packet capture session.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the Network Watcher resource.\n        :type network_watcher_name: str\n        :param packet_capture_name: The name given to the packet capture\n         session.\n        :type packet_capture_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         PacketCaptureQueryStatusResult or\n         ClientRawResponse<PacketCaptureQueryStatusResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_04_01.models.PacketCaptureQueryStatusResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_04_01.models.PacketCaptureQueryStatusResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33775:c0:m9"}
{"signature": "def get(<EOL>self, resource_group_name, network_watcher_name, packet_capture_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_watcher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", packet_capture_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a packet capture session by name.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param packet_capture_name: The name of the packet capture session.\n        :type packet_capture_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PacketCaptureResult or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_04_01.models.PacketCaptureResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33775:c0:m3"}
{"signature": "def list(<EOL>self, resource_group_name, network_watcher_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_watcher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PacketCaptureResultPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PacketCaptureResultPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all packet capture sessions within the specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the Network Watcher resource.\n        :type network_watcher_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PacketCaptureResult\n        :rtype:\n         ~azure.mgmt.network.v2018_04_01.models.PacketCaptureResultPaged[~azure.mgmt.network.v2018_04_01.models.PacketCaptureResult]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33775:c0:m10"}
{"signature": "def get_shared_key(<EOL>self, resource_group_name, virtual_network_gateway_connection_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_shared_key.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_gateway_connection_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "The Get VirtualNetworkGatewayConnectionSharedKey operation retrieves\n        information about the specified virtual network gateway connection\n        shared key through Network resource provider.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_connection_name: The virtual network\n         gateway connection shared key name.\n        :type virtual_network_gateway_connection_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ConnectionSharedKey or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_04_01.models.ConnectionSharedKey or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33776:c0:m10"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, virtual_network_gateway_connection_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_connection_name=virtual_network_gateway_connection_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a virtual network gateway connection in the\n        specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_connection_name: The name of the\n         virtual network gateway connection.\n        :type virtual_network_gateway_connection_name: str\n        :param parameters: Parameters supplied to the create or update virtual\n         network gateway connection operation.\n        :type parameters:\n         ~azure.mgmt.network.v2018_04_01.models.VirtualNetworkGatewayConnection\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         VirtualNetworkGatewayConnection or\n         ClientRawResponse<VirtualNetworkGatewayConnection> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_04_01.models.VirtualNetworkGatewayConnection]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_04_01.models.VirtualNetworkGatewayConnection]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33776:c0:m2"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualWANPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualWANPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all the VirtualWANs in a resource group.\n\n        :param resource_group_name: The resource group name of the VirtualWan.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualWAN\n        :rtype:\n         ~azure.mgmt.network.v2018_04_01.models.VirtualWANPaged[~azure.mgmt.network.v2018_04_01.models.VirtualWAN]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_04_01.models.ErrorException>`", "id": "f33778:c0:m8"}
{"signature": "def get(<EOL>self, resource_group_name, virtual_wan_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_wan_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves the details of a VirtualWAN.\n\n        :param resource_group_name: The resource group name of the VirtualWan.\n        :type resource_group_name: str\n        :param virtual_wan_name: The name of the VirtualWAN being retrieved.\n        :type virtual_wan_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualWAN or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_04_01.models.VirtualWAN or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_04_01.models.ErrorException>`", "id": "f33778:c0:m1"}
{"signature": "def get(<EOL>self, resource_group_name, azure_firewall_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", azure_firewall_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified Azure Firewall.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param azure_firewall_name: The name of the Azure Firewall.\n        :type azure_firewall_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: AzureFirewall or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_04_01.models.AzureFirewall or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33780:c0:m3"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, azure_firewall_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>azure_firewall_name=azure_firewall_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates the specified Azure Firewall.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param azure_firewall_name: The name of the Azure Firewall.\n        :type azure_firewall_name: str\n        :param parameters: Parameters supplied to the create or update Azure\n         Firewall operation.\n        :type parameters: ~azure.mgmt.network.v2018_04_01.models.AzureFirewall\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns AzureFirewall or\n         ClientRawResponse<AzureFirewall> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_04_01.models.AzureFirewall]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_04_01.models.AzureFirewall]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33780:c0:m5"}
{"signature": "def delete(<EOL>self, resource_group_name, azure_firewall_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>azure_firewall_name=azure_firewall_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified Azure Firewall.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param azure_firewall_name: The name of the Azure Firewall.\n        :type azure_firewall_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33780:c0:m2"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ApplicationGatewayPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ApplicationGatewayPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all application gateways in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ApplicationGateway\n        :rtype:\n         ~azure.mgmt.network.v2018_04_01.models.ApplicationGatewayPaged[~azure.mgmt.network.v2018_04_01.models.ApplicationGateway]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33781:c0:m8"}
{"signature": "def get(<EOL>self, resource_group_name, route_filter_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", route_filter_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified route filter.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param expand: Expands referenced express route bgp peering resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RouteFilter or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_04_01.models.RouteFilter or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33782:c0:m3"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RouteFilterPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RouteFilterPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all route filters in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of RouteFilter\n        :rtype:\n         ~azure.mgmt.network.v2018_04_01.models.RouteFilterPaged[~azure.mgmt.network.v2018_04_01.models.RouteFilter]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33782:c0:m8"}
{"signature": "def get(<EOL>self, resource_group_name, network_watcher_name, connection_monitor_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_watcher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", connection_monitor_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a connection monitor by name.\n\n        :param resource_group_name: The name of the resource group containing\n         Network Watcher.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the Network Watcher resource.\n        :type network_watcher_name: str\n        :param connection_monitor_name: The name of the connection monitor.\n        :type connection_monitor_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ConnectionMonitorResult or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_04_01.models.ConnectionMonitorResult\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33783:c0:m3"}
{"signature": "def query(<EOL>self, resource_group_name, network_watcher_name, connection_monitor_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._query_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>connection_monitor_name=connection_monitor_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Query a snapshot of the most recent connection states.\n\n        :param resource_group_name: The name of the resource group containing\n         Network Watcher.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the Network Watcher resource.\n        :type network_watcher_name: str\n        :param connection_monitor_name: The name given to the connection\n         monitor.\n        :type connection_monitor_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ConnectionMonitorQueryResult or\n         ClientRawResponse<ConnectionMonitorQueryResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_04_01.models.ConnectionMonitorQueryResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_04_01.models.ConnectionMonitorQueryResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33783:c0:m11"}
{"signature": "def delete(<EOL>self, resource_group_name, local_network_gateway_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>local_network_gateway_name=local_network_gateway_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified local network gateway.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param local_network_gateway_name: The name of the local network\n         gateway.\n        :type local_network_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33784:c0:m5"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, local_network_gateway_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>local_network_gateway_name=local_network_gateway_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a local network gateway in the specified resource\n        group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param local_network_gateway_name: The name of the local network\n         gateway.\n        :type local_network_gateway_name: str\n        :param parameters: Parameters supplied to the create or update local\n         network gateway operation.\n        :type parameters:\n         ~azure.mgmt.network.v2018_04_01.models.LocalNetworkGateway\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns LocalNetworkGateway or\n         ClientRawResponse<LocalNetworkGateway> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_04_01.models.LocalNetworkGateway]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_04_01.models.LocalNetworkGateway]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33784:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, route_table_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_table_name=route_table_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified route table.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33788:c0:m2"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RouteTablePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RouteTablePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all route tables in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of RouteTable\n        :rtype:\n         ~azure.mgmt.network.v2018_04_01.models.RouteTablePaged[~azure.mgmt.network.v2018_04_01.models.RouteTable]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33788:c0:m9"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, route_table_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_table_name=route_table_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Create or updates a route table in a specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param parameters: Parameters supplied to the create or update route\n         table operation.\n        :type parameters: ~azure.mgmt.network.v2018_04_01.models.RouteTable\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns RouteTable or\n         ClientRawResponse<RouteTable> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_04_01.models.RouteTable]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_04_01.models.RouteTable]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33788:c0:m5"}
{"signature": "def list(<EOL>self, resource_group_name, network_interface_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_interface_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.LoadBalancerPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.LoadBalancerPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List all load balancers in a network interface.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of LoadBalancer\n        :rtype:\n         ~azure.mgmt.network.v2018_04_01.models.LoadBalancerPaged[~azure.mgmt.network.v2018_04_01.models.LoadBalancer]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33789:c0:m1"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, circuit_name, peering_name, connection_name, express_route_circuit_connection_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>peering_name=peering_name,<EOL>connection_name=connection_name,<EOL>express_route_circuit_connection_parameters=express_route_circuit_connection_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a Express Route Circuit Connection in the specified\n        express route circuits.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param connection_name: The name of the express route circuit\n         connection.\n        :type connection_name: str\n        :param express_route_circuit_connection_parameters: Parameters\n         supplied to the create or update express route circuit connection\n         operation.\n        :type express_route_circuit_connection_parameters:\n         ~azure.mgmt.network.v2018_04_01.models.ExpressRouteCircuitConnection\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCircuitConnection or\n         ClientRawResponse<ExpressRouteCircuitConnection> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_04_01.models.ExpressRouteCircuitConnection]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_04_01.models.ExpressRouteCircuitConnection]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33790:c0:m5"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualNetworkPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualNetworkPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all virtual networks in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualNetwork\n        :rtype:\n         ~azure.mgmt.network.v2018_04_01.models.VirtualNetworkPaged[~azure.mgmt.network.v2018_04_01.models.VirtualNetwork]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33792:c0:m8"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualNetworkPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualNetworkPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all virtual networks in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualNetwork\n        :rtype:\n         ~azure.mgmt.network.v2018_04_01.models.VirtualNetworkPaged[~azure.mgmt.network.v2018_04_01.models.VirtualNetwork]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33792:c0:m9"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, load_balancer_name, inbound_nat_rule_name, inbound_nat_rule_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>load_balancer_name=load_balancer_name,<EOL>inbound_nat_rule_name=inbound_nat_rule_name,<EOL>inbound_nat_rule_parameters=inbound_nat_rule_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a load balancer inbound nat rule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param inbound_nat_rule_name: The name of the inbound nat rule.\n        :type inbound_nat_rule_name: str\n        :param inbound_nat_rule_parameters: Parameters supplied to the create\n         or update inbound nat rule operation.\n        :type inbound_nat_rule_parameters:\n         ~azure.mgmt.network.v2018_04_01.models.InboundNatRule\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns InboundNatRule or\n         ClientRawResponse<InboundNatRule> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_04_01.models.InboundNatRule]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_04_01.models.InboundNatRule]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33793:c0:m6"}
{"signature": "def get_stats(<EOL>self, resource_group_name, circuit_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_stats.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the stats from an express route circuit in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteCircuitStats or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_04_01.models.ExpressRouteCircuitStats or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33794:c0:m14"}
{"signature": "def delete(<EOL>self, resource_group_name, circuit_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33794:c0:m2"}
{"signature": "def get_peering_stats(<EOL>self, resource_group_name, circuit_name, peering_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_peering_stats.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", peering_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all stats from an express route circuit in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteCircuitStats or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_04_01.models.ExpressRouteCircuitStats or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33794:c0:m15"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ExpressRouteCircuitPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ExpressRouteCircuitPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the express route circuits in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ExpressRouteCircuit\n        :rtype:\n         ~azure.mgmt.network.v2018_04_01.models.ExpressRouteCircuitPaged[~azure.mgmt.network.v2018_04_01.models.ExpressRouteCircuit]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33794:c0:m16"}
{"signature": "def delete(<EOL>self, resource_group_name, application_security_group_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>application_security_group_name=application_security_group_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified application security group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param application_security_group_name: The name of the application\n         security group.\n        :type application_security_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33795:c0:m2"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, application_security_group_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>application_security_group_name=application_security_group_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates an application security group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param application_security_group_name: The name of the application\n         security group.\n        :type application_security_group_name: str\n        :param parameters: Parameters supplied to the create or update\n         ApplicationSecurityGroup operation.\n        :type parameters:\n         ~azure.mgmt.network.v2018_04_01.models.ApplicationSecurityGroup\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ApplicationSecurityGroup or\n         ClientRawResponse<ApplicationSecurityGroup> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_04_01.models.ApplicationSecurityGroup]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_04_01.models.ApplicationSecurityGroup]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33795:c0:m5"}
{"signature": "def delete(<EOL>self, resource_group_name, circuit_name, authorization_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>authorization_name=authorization_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified authorization from the specified express route\n        circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param authorization_name: The name of the authorization.\n        :type authorization_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33796:c0:m2"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, circuit_name, authorization_name, authorization_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>authorization_name=authorization_name,<EOL>authorization_parameters=authorization_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates an authorization in the specified express route\n        circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param authorization_name: The name of the authorization.\n        :type authorization_name: str\n        :param authorization_parameters: Parameters supplied to the create or\n         update express route circuit authorization operation.\n        :type authorization_parameters:\n         ~azure.mgmt.network.v2018_04_01.models.ExpressRouteCircuitAuthorization\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCircuitAuthorization or\n         ClientRawResponse<ExpressRouteCircuitAuthorization> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_04_01.models.ExpressRouteCircuitAuthorization]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_04_01.models.ExpressRouteCircuitAuthorization]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33796:c0:m5"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ExpressRouteServiceProviderPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ExpressRouteServiceProviderPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the available express route service providers.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ExpressRouteServiceProvider\n        :rtype:\n         ~azure.mgmt.network.v2018_04_01.models.ExpressRouteServiceProviderPaged[~azure.mgmt.network.v2018_04_01.models.ExpressRouteServiceProvider]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33797:c0:m1"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualHubPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualHubPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all the VirtualHubs in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualHub\n        :rtype:\n         ~azure.mgmt.network.v2018_04_01.models.VirtualHubPaged[~azure.mgmt.network.v2018_04_01.models.VirtualHub]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_04_01.models.ErrorException>`", "id": "f33798:c0:m9"}
{"signature": "def update_tags(<EOL>self, resource_group_name, virtual_hub_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_hub_name=virtual_hub_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates VirtualHub tags.\n\n        :param resource_group_name: The resource group name of the VirtualHub.\n        :type resource_group_name: str\n        :param virtual_hub_name: The name of the VirtualHub.\n        :type virtual_hub_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualHub or\n         ClientRawResponse<VirtualHub> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_04_01.models.VirtualHub]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_04_01.models.VirtualHub]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_04_01.models.ErrorException>`", "id": "f33798:c0:m5"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualHubPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualHubPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all the VirtualHubs in a resource group.\n\n        :param resource_group_name: The resource group name of the VirtualHub.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualHub\n        :rtype:\n         ~azure.mgmt.network.v2018_04_01.models.VirtualHubPaged[~azure.mgmt.network.v2018_04_01.models.VirtualHub]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_04_01.models.ErrorException>`", "id": "f33798:c0:m8"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, virtual_network_name, subnet_name, subnet_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_name=virtual_network_name,<EOL>subnet_name=subnet_name,<EOL>subnet_parameters=subnet_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a subnet in the specified virtual network.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param subnet_name: The name of the subnet.\n        :type subnet_name: str\n        :param subnet_parameters: Parameters supplied to the create or update\n         subnet operation.\n        :type subnet_parameters: ~azure.mgmt.network.v2018_04_01.models.Subnet\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Subnet or\n         ClientRawResponse<Subnet> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_04_01.models.Subnet]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_04_01.models.Subnet]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33800:c0:m5"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PublicIPAddressPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PublicIPAddressPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the public IP addresses in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PublicIPAddress\n        :rtype:\n         ~azure.mgmt.network.v2018_04_01.models.PublicIPAddressPaged[~azure.mgmt.network.v2018_04_01.models.PublicIPAddress]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33801:c0:m8"}
{"signature": "def list(<EOL>self, resource_group_name, cross_connection_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", cross_connection_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ExpressRouteCrossConnectionPeeringPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ExpressRouteCrossConnectionPeeringPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all peerings in a specified ExpressRouteCrossConnection.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param cross_connection_name: The name of the\n         ExpressRouteCrossConnection.\n        :type cross_connection_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of\n         ExpressRouteCrossConnectionPeering\n        :rtype:\n         ~azure.mgmt.network.v2018_04_01.models.ExpressRouteCrossConnectionPeeringPaged[~azure.mgmt.network.v2018_04_01.models.ExpressRouteCrossConnectionPeering]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33802:c0:m1"}
{"signature": "def get_next_hop(<EOL>self, resource_group_name, network_watcher_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_next_hop_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the next hop from the specified VM.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param parameters: Parameters that define the source and destination\n         endpoint.\n        :type parameters:\n         ~azure.mgmt.network.v2018_04_01.models.NextHopParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns NextHopResult or\n         ClientRawResponse<NextHopResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_04_01.models.NextHopResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_04_01.models.NextHopResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33805:c0:m12"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkWatcherPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkWatcherPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all network watchers by subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkWatcher\n        :rtype:\n         ~azure.mgmt.network.v2018_04_01.models.NetworkWatcherPaged[~azure.mgmt.network.v2018_04_01.models.NetworkWatcher]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33805:c0:m7"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VpnSitePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VpnSitePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all the VpnSites in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VpnSite\n        :rtype:\n         ~azure.mgmt.network.v2018_04_01.models.VpnSitePaged[~azure.mgmt.network.v2018_04_01.models.VpnSite]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_04_01.models.ErrorException>`", "id": "f33806:c0:m9"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VpnSitePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VpnSitePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all the vpnSites in a resource group.\n\n        :param resource_group_name: The resource group name of the VpnSite.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VpnSite\n        :rtype:\n         ~azure.mgmt.network.v2018_04_01.models.VpnSitePaged[~azure.mgmt.network.v2018_04_01.models.VpnSite]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_04_01.models.ErrorException>`", "id": "f33806:c0:m8"}
{"signature": "def list(<EOL>self, location, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>', pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.UsagePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.UsagePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List network usages for a subscription.\n\n        :param location: The location where resource usage is queried.\n        :type location: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Usage\n        :rtype:\n         ~azure.mgmt.network.v2018_04_01.models.UsagePaged[~azure.mgmt.network.v2018_04_01.models.Usage]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33807:c0:m1"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, circuit_name, peering_name, peering_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>peering_name=peering_name,<EOL>peering_parameters=peering_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a peering in the specified express route circuits.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param peering_parameters: Parameters supplied to the create or update\n         express route circuit peering operation.\n        :type peering_parameters:\n         ~azure.mgmt.network.v2018_04_01.models.ExpressRouteCircuitPeering\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCircuitPeering or\n         ClientRawResponse<ExpressRouteCircuitPeering> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_04_01.models.ExpressRouteCircuitPeering]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_04_01.models.ExpressRouteCircuitPeering]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33808:c0:m5"}
{"signature": "def delete(<EOL>self, resource_group_name, route_table_name, route_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_table_name=route_table_name,<EOL>route_name=route_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified route from a route table.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param route_name: The name of the route.\n        :type route_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33810:c0:m2"}
{"signature": "def list(<EOL>self, resource_group_name, route_table_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", route_table_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RoutePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RoutePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all routes in a route table.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Route\n        :rtype:\n         ~azure.mgmt.network.v2018_04_01.models.RoutePaged[~azure.mgmt.network.v2018_04_01.models.Route]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33810:c0:m6"}
{"signature": "def get(<EOL>self, resource_group_name, route_table_name, route_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", route_table_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", route_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified route from a route table.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param route_name: The name of the route.\n        :type route_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Route or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_04_01.models.Route or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33810:c0:m3"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, route_table_name, route_name, route_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_table_name=route_table_name,<EOL>route_name=route_name,<EOL>route_parameters=route_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a route in the specified route table.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param route_name: The name of the route.\n        :type route_name: str\n        :param route_parameters: Parameters supplied to the create or update\n         route operation.\n        :type route_parameters: ~azure.mgmt.network.v2018_04_01.models.Route\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Route or\n         ClientRawResponse<Route> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_04_01.models.Route]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_04_01.models.Route]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33810:c0:m5"}
{"signature": "def list(<EOL>self, resource_group_name, virtual_hub_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_hub_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.HubVirtualNetworkConnectionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.HubVirtualNetworkConnectionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves the details of all HubVirtualNetworkConnections.\n\n        :param resource_group_name: The resource group name of the VirtualHub.\n        :type resource_group_name: str\n        :param virtual_hub_name: The name of the VirtualHub.\n        :type virtual_hub_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of HubVirtualNetworkConnection\n        :rtype:\n         ~azure.mgmt.network.v2018_04_01.models.HubVirtualNetworkConnectionPaged[~azure.mgmt.network.v2018_04_01.models.HubVirtualNetworkConnection]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_04_01.models.ErrorException>`", "id": "f33811:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, virtual_hub_name, connection_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_hub_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", connection_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves the details of a HubVirtualNetworkConnection.\n\n        :param resource_group_name: The resource group name of the VirtualHub.\n        :type resource_group_name: str\n        :param virtual_hub_name: The name of the VirtualHub.\n        :type virtual_hub_name: str\n        :param connection_name: The name of the vpn connection.\n        :type connection_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: HubVirtualNetworkConnection or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_04_01.models.HubVirtualNetworkConnection or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_04_01.models.ErrorException>`", "id": "f33811:c0:m1"}
{"signature": "def list_connections(<EOL>self, resource_group_name, virtual_network_gateway_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_connections.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_gateway_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualNetworkGatewayConnectionListEntityPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualNetworkGatewayConnectionListEntityPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the connections in a virtual network gateway.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of\n         VirtualNetworkGatewayConnectionListEntity\n        :rtype:\n         ~azure.mgmt.network.v2018_04_01.models.VirtualNetworkGatewayConnectionListEntityPaged[~azure.mgmt.network.v2018_04_01.models.VirtualNetworkGatewayConnectionListEntity]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33812:c0:m9"}
{"signature": "def set_vpnclient_ipsec_parameters(<EOL>self, resource_group_name, virtual_network_gateway_name, vpnclient_ipsec_params, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._set_vpnclient_ipsec_parameters_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_name=virtual_network_gateway_name,<EOL>vpnclient_ipsec_params=vpnclient_ipsec_params,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The Set VpnclientIpsecParameters operation sets the vpnclient ipsec\n        policy for P2S client of virtual network gateway in the specified\n        resource group through Network resource provider.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param vpnclient_ipsec_params: Parameters supplied to the Begin Set\n         vpnclient ipsec parameters of Virtual Network Gateway P2S client\n         operation through Network resource provider.\n        :type vpnclient_ipsec_params:\n         ~azure.mgmt.network.v2018_04_01.models.VpnClientIPsecParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         VpnClientIPsecParameters or\n         ClientRawResponse<VpnClientIPsecParameters> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_04_01.models.VpnClientIPsecParameters]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_04_01.models.VpnClientIPsecParameters]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33812:c0:m25"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualNetworkGatewayPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualNetworkGatewayPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all virtual network gateways by resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualNetworkGateway\n        :rtype:\n         ~azure.mgmt.network.v2018_04_01.models.VirtualNetworkGatewayPaged[~azure.mgmt.network.v2018_04_01.models.VirtualNetworkGateway]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33812:c0:m8"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, virtual_network_gateway_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_name=virtual_network_gateway_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a virtual network gateway in the specified resource\n        group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param parameters: Parameters supplied to create or update virtual\n         network gateway operation.\n        :type parameters:\n         ~azure.mgmt.network.v2018_04_01.models.VirtualNetworkGateway\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualNetworkGateway\n         or ClientRawResponse<VirtualNetworkGateway> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_04_01.models.VirtualNetworkGateway]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_04_01.models.VirtualNetworkGateway]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33812:c0:m2"}
{"signature": "def list_by_route_filter(<EOL>self, resource_group_name, route_filter_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_route_filter.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", route_filter_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RouteFilterRulePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RouteFilterRulePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all RouteFilterRules in a route filter.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of RouteFilterRule\n        :rtype:\n         ~azure.mgmt.network.v2018_04_01.models.RouteFilterRulePaged[~azure.mgmt.network.v2018_04_01.models.RouteFilterRule]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33814:c0:m8"}
{"signature": "def delete(<EOL>self, resource_group_name, route_filter_name, rule_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_filter_name=route_filter_name,<EOL>rule_name=rule_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified rule from a route filter.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param rule_name: The name of the rule.\n        :type rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33814:c0:m2"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, gateway_name, connection_name, vpn_connection_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>gateway_name=gateway_name,<EOL>connection_name=connection_name,<EOL>vpn_connection_parameters=vpn_connection_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates a vpn connection to a scalable vpn gateway if it doesn't exist\n        else updates the existing connection.\n\n        :param resource_group_name: The resource group name of the VpnGateway.\n        :type resource_group_name: str\n        :param gateway_name: The name of the gateway.\n        :type gateway_name: str\n        :param connection_name: The name of the connection.\n        :type connection_name: str\n        :param vpn_connection_parameters: Parameters supplied to create or\n         Update a VPN Connection.\n        :type vpn_connection_parameters:\n         ~azure.mgmt.network.v2018_04_01.models.VpnConnection\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VpnConnection or\n         ClientRawResponse<VpnConnection> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_04_01.models.VpnConnection]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_04_01.models.VpnConnection]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_04_01.models.ErrorException>`", "id": "f33815:c0:m3"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, network_interface_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_interface_name=network_interface_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a network interface.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param parameters: Parameters supplied to the create or update network\n         interface operation.\n        :type parameters:\n         ~azure.mgmt.network.v2018_04_01.models.NetworkInterface\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns NetworkInterface or\n         ClientRawResponse<NetworkInterface> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_04_01.models.NetworkInterface]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_04_01.models.NetworkInterface]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33816:c0:m5"}
{"signature": "def get_virtual_machine_scale_set_ip_configuration(<EOL>self, resource_group_name, virtual_machine_scale_set_name, virtualmachine_index, network_interface_name, ip_configuration_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get_virtual_machine_scale_set_ip_configuration.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_machine_scale_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtualmachine_index, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_interface_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", ip_configuration_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the specified network interface ip configuration in a virtual\n        machine scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_machine_scale_set_name: The name of the virtual machine\n         scale set.\n        :type virtual_machine_scale_set_name: str\n        :param virtualmachine_index: The virtual machine index.\n        :type virtualmachine_index: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param ip_configuration_name: The name of the ip configuration.\n        :type ip_configuration_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: NetworkInterfaceIPConfiguration or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_04_01.models.NetworkInterfaceIPConfiguration\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33816:c0:m18"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all network interfaces in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkInterface\n        :rtype:\n         ~azure.mgmt.network.v2018_04_01.models.NetworkInterfacePaged[~azure.mgmt.network.v2018_04_01.models.NetworkInterface]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33816:c0:m9"}
{"signature": "def list_virtual_machine_scale_set_vm_network_interfaces(<EOL>self, resource_group_name, virtual_machine_scale_set_name, virtualmachine_index, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_virtual_machine_scale_set_vm_network_interfaces.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_machine_scale_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtualmachine_index, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about all network interfaces in a virtual machine in a\n        virtual machine scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_machine_scale_set_name: The name of the virtual machine\n         scale set.\n        :type virtual_machine_scale_set_name: str\n        :param virtualmachine_index: The virtual machine index.\n        :type virtualmachine_index: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkInterface\n        :rtype:\n         ~azure.mgmt.network.v2018_04_01.models.NetworkInterfacePaged[~azure.mgmt.network.v2018_04_01.models.NetworkInterface]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33816:c0:m14"}
{"signature": "def update_tags(<EOL>self, resource_group_name, network_security_group_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_security_group_name=network_security_group_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a network security group tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns NetworkSecurityGroup or\n         ClientRawResponse<NetworkSecurityGroup> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_04_01.models.NetworkSecurityGroup]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_04_01.models.NetworkSecurityGroup]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33817:c0:m7"}
{"signature": "def delete(<EOL>self, resource_group_name, network_security_group_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_security_group_name=network_security_group_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified network security group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33817:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, network_security_group_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_security_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified network security group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: NetworkSecurityGroup or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_04_01.models.NetworkSecurityGroup or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33817:c0:m3"}
{"signature": "def check_dns_name_availability(<EOL>self, location, domain_name_label, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.check_dns_name_availability.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", domain_name_label, '<STR_LIT:str>')<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Checks whether a domain name in the cloudapp.azure.com zone is\n        available for use.\n\n        :param location: The location of the domain name.\n        :type location: str\n        :param domain_name_label: The domain name to be verified. It must\n         conform to the following regular expression:\n         ^[a-z][a-z0-9-]{1,61}[a-z0-9]$.\n        :type domain_name_label: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DnsNameAvailabilityResult or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_07_01.models.DnsNameAvailabilityResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f33818:c1:m1"}
{"signature": "def list(<EOL>self, resource_group_name, load_balancer_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.BackendAddressPoolPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.BackendAddressPoolPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the load balancer backed address pools.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of BackendAddressPool\n        :rtype:\n         ~azure.mgmt.network.v2018_07_01.models.BackendAddressPoolPaged[~azure.mgmt.network.v2018_07_01.models.BackendAddressPool]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34185:c0:m1"}
{"signature": "def update_tags(<EOL>self, resource_group_name, load_balancer_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>load_balancer_name=load_balancer_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a load balancer tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns LoadBalancer or\n         ClientRawResponse<LoadBalancer> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_07_01.models.LoadBalancer]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_07_01.models.LoadBalancer]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34186:c0:m7"}
{"signature": "def delete(<EOL>self, resource_group_name, load_balancer_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>load_balancer_name=load_balancer_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified load balancer.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34186:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, load_balancer_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified load balancer.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: LoadBalancer or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_07_01.models.LoadBalancer or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34186:c0:m3"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.LoadBalancerPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.LoadBalancerPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the load balancers in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of LoadBalancer\n        :rtype:\n         ~azure.mgmt.network.v2018_07_01.models.LoadBalancerPaged[~azure.mgmt.network.v2018_07_01.models.LoadBalancer]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34186:c0:m9"}
{"signature": "def list_routes_table(<EOL>self, resource_group_name, cross_connection_name, peering_name, device_path, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._list_routes_table_initial(<EOL>resource_group_name=resource_group_name,<EOL>cross_connection_name=cross_connection_name,<EOL>peering_name=peering_name,<EOL>device_path=device_path,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the currently advertised routes table associated with the express\n        route cross connection in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param cross_connection_name: The name of the\n         ExpressRouteCrossConnection.\n        :type cross_connection_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param device_path: The path of the device.\n        :type device_path: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCircuitsRoutesTableListResult or\n         ClientRawResponse<ExpressRouteCircuitsRoutesTableListResult> if\n         raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_07_01.models.ExpressRouteCircuitsRoutesTableListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_07_01.models.ExpressRouteCircuitsRoutesTableListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34188:c0:m13"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ExpressRouteCrossConnectionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ExpressRouteCrossConnectionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves all the ExpressRouteCrossConnections in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ExpressRouteCrossConnection\n        :rtype:\n         ~azure.mgmt.network.v2018_07_01.models.ExpressRouteCrossConnectionPaged[~azure.mgmt.network.v2018_07_01.models.ExpressRouteCrossConnection]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34188:c0:m2"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, cross_connection_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>cross_connection_name=cross_connection_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Update the specified ExpressRouteCrossConnection.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param cross_connection_name: The name of the\n         ExpressRouteCrossConnection.\n        :type cross_connection_name: str\n        :param parameters: Parameters supplied to the update express route\n         crossConnection operation.\n        :type parameters:\n         ~azure.mgmt.network.v2018_07_01.models.ExpressRouteCrossConnection\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCrossConnection or\n         ClientRawResponse<ExpressRouteCrossConnection> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_07_01.models.ExpressRouteCrossConnection]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_07_01.models.ExpressRouteCrossConnection]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34188:c0:m5"}
{"signature": "def get(<EOL>self, resource_group_name, virtual_network_gateway_connection_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_gateway_connection_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified virtual network gateway connection by resource\n        group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_connection_name: The name of the\n         virtual network gateway connection.\n        :type virtual_network_gateway_connection_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualNetworkGatewayConnection or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_07_01.models.VirtualNetworkGatewayConnection\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34192:c0:m3"}
{"signature": "def delete(<EOL>self, resource_group_name, virtual_network_gateway_connection_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_connection_name=virtual_network_gateway_connection_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified virtual network Gateway connection.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_connection_name: The name of the\n         virtual network gateway connection.\n        :type virtual_network_gateway_connection_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34192:c0:m5"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, virtual_network_gateway_connection_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_connection_name=virtual_network_gateway_connection_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a virtual network gateway connection in the\n        specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_connection_name: The name of the\n         virtual network gateway connection.\n        :type virtual_network_gateway_connection_name: str\n        :param parameters: Parameters supplied to the create or update virtual\n         network gateway connection operation.\n        :type parameters:\n         ~azure.mgmt.network.v2018_07_01.models.VirtualNetworkGatewayConnection\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         VirtualNetworkGatewayConnection or\n         ClientRawResponse<VirtualNetworkGatewayConnection> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_07_01.models.VirtualNetworkGatewayConnection]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_07_01.models.VirtualNetworkGatewayConnection]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34192:c0:m2"}
{"signature": "def update_tags(<EOL>self, resource_group_name, virtual_network_gateway_connection_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_connection_name=virtual_network_gateway_connection_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a virtual network gateway connection tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_connection_name: The name of the\n         virtual network gateway connection.\n        :type virtual_network_gateway_connection_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         VirtualNetworkGatewayConnection or\n         ClientRawResponse<VirtualNetworkGatewayConnection> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_07_01.models.VirtualNetworkGatewayConnection]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_07_01.models.VirtualNetworkGatewayConnection]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34192:c0:m7"}
{"signature": "def get(<EOL>self, resource_group_name, ddos_protection_plan_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", ddos_protection_plan_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about the specified DDoS protection plan.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param ddos_protection_plan_name: The name of the DDoS protection\n         plan.\n        :type ddos_protection_plan_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DdosProtectionPlan or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_07_01.models.DdosProtectionPlan or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34195:c0:m3"}
{"signature": "def delete(<EOL>self, resource_group_name, azure_firewall_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>azure_firewall_name=azure_firewall_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified Azure Firewall.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param azure_firewall_name: The name of the Azure Firewall.\n        :type azure_firewall_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34196:c0:m2"}
{"signature": "def backend_health(<EOL>self, resource_group_name, application_gateway_name, expand=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._backend_health_initial(<EOL>resource_group_name=resource_group_name,<EOL>application_gateway_name=application_gateway_name,<EOL>expand=expand,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the backend health of the specified application gateway in a\n        resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param application_gateway_name: The name of the application gateway.\n        :type application_gateway_name: str\n        :param expand: Expands BackendAddressPool and BackendHttpSettings\n         referenced in backend health.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ApplicationGatewayBackendHealth or\n         ClientRawResponse<ApplicationGatewayBackendHealth> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_07_01.models.ApplicationGatewayBackendHealth]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_07_01.models.ApplicationGatewayBackendHealth]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34197:c0:m15"}
{"signature": "def list_available_ssl_predefined_policies(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_available_ssl_predefined_policies.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ApplicationGatewaySslPredefinedPolicyPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ApplicationGatewaySslPredefinedPolicyPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all SSL predefined policies for configuring Ssl policy.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of\n         ApplicationGatewaySslPredefinedPolicy\n        :rtype:\n         ~azure.mgmt.network.v2018_07_01.models.ApplicationGatewaySslPredefinedPolicyPaged[~azure.mgmt.network.v2018_07_01.models.ApplicationGatewaySslPredefinedPolicy]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34197:c0:m18"}
{"signature": "def get_ssl_predefined_policy(<EOL>self, predefined_policy_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_ssl_predefined_policy.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", predefined_policy_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets Ssl predefined policy with the specified policy name.\n\n        :param predefined_policy_name: Name of Ssl predefined policy.\n        :type predefined_policy_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ApplicationGatewaySslPredefinedPolicy or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_07_01.models.ApplicationGatewaySslPredefinedPolicy\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34197:c0:m19"}
{"signature": "def list(<EOL>self, resource_group_name, network_watcher_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_watcher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ConnectionMonitorResultPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ConnectionMonitorResultPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all connection monitors for the specified Network Watcher.\n\n        :param resource_group_name: The name of the resource group containing\n         Network Watcher.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the Network Watcher resource.\n        :type network_watcher_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ConnectionMonitorResult\n        :rtype:\n         ~azure.mgmt.network.v2018_07_01.models.ConnectionMonitorResultPaged[~azure.mgmt.network.v2018_07_01.models.ConnectionMonitorResult]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_07_01.models.ErrorResponseException>`", "id": "f34200:c0:m12"}
{"signature": "def get(<EOL>self, resource_group_name, network_watcher_name, connection_monitor_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_watcher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", connection_monitor_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a connection monitor by name.\n\n        :param resource_group_name: The name of the resource group containing\n         Network Watcher.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the Network Watcher resource.\n        :type network_watcher_name: str\n        :param connection_monitor_name: The name of the connection monitor.\n        :type connection_monitor_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ConnectionMonitorResult or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_07_01.models.ConnectionMonitorResult\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_07_01.models.ErrorResponseException>`", "id": "f34200:c0:m3"}
{"signature": "def get(<EOL>self, resource_group_name, local_network_gateway_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", local_network_gateway_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified local network gateway in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param local_network_gateway_name: The name of the local network\n         gateway.\n        :type local_network_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: LocalNetworkGateway or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_07_01.models.LocalNetworkGateway or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34201:c0:m3"}
{"signature": "def download(<EOL>self, resource_group_name, virtual_wan_name, vpn_sites=None, output_blob_sas_url=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._download_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_wan_name=virtual_wan_name,<EOL>vpn_sites=vpn_sites,<EOL>output_blob_sas_url=output_blob_sas_url,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gives the sas-url to download the configurations for vpn-sites in a\n        resource group.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param virtual_wan_name: The name of the VirtualWAN for which\n         configuration of all vpn-sites is needed.\n        :type virtual_wan_name: str\n        :param vpn_sites: List of resource-ids of the vpn-sites for which\n         config is to be downloaded.\n        :type vpn_sites:\n         list[~azure.mgmt.network.v2018_07_01.models.SubResource]\n        :param output_blob_sas_url: The sas-url to download the configurations\n         for vpn-sites\n        :type output_blob_sas_url: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_07_01.models.ErrorException>`", "id": "f34202:c0:m2"}
{"signature": "def list(<EOL>self, resource_group_name, network_security_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_security_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SecurityRulePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SecurityRulePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all default security rules in a network security group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of SecurityRule\n        :rtype:\n         ~azure.mgmt.network.v2018_07_01.models.SecurityRulePaged[~azure.mgmt.network.v2018_07_01.models.SecurityRule]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34203:c0:m1"}
{"signature": "def get(<EOL>self, resource_group_name, network_security_group_name, default_security_rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_security_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", default_security_rule_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the specified default network security rule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param default_security_rule_name: The name of the default security\n         rule.\n        :type default_security_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SecurityRule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_07_01.models.SecurityRule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34203:c0:m2"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VpnGatewayPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VpnGatewayPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all the VpnGateways in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VpnGateway\n        :rtype:\n         ~azure.mgmt.network.v2018_07_01.models.VpnGatewayPaged[~azure.mgmt.network.v2018_07_01.models.VpnGateway]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_07_01.models.ErrorException>`", "id": "f34204:c0:m9"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RouteTablePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RouteTablePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all route tables in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of RouteTable\n        :rtype:\n         ~azure.mgmt.network.v2018_07_01.models.RouteTablePaged[~azure.mgmt.network.v2018_07_01.models.RouteTable]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34205:c0:m8"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, circuit_name, peering_name, connection_name, express_route_circuit_connection_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>peering_name=peering_name,<EOL>connection_name=connection_name,<EOL>express_route_circuit_connection_parameters=express_route_circuit_connection_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a Express Route Circuit Connection in the specified\n        express route circuits.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param connection_name: The name of the express route circuit\n         connection.\n        :type connection_name: str\n        :param express_route_circuit_connection_parameters: Parameters\n         supplied to the create or update express route circuit connection\n         operation.\n        :type express_route_circuit_connection_parameters:\n         ~azure.mgmt.network.v2018_07_01.models.ExpressRouteCircuitConnection\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCircuitConnection or\n         ClientRawResponse<ExpressRouteCircuitConnection> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_07_01.models.ExpressRouteCircuitConnection]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_07_01.models.ExpressRouteCircuitConnection]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34207:c0:m5"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualNetworkPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualNetworkPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all virtual networks in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualNetwork\n        :rtype:\n         ~azure.mgmt.network.v2018_07_01.models.VirtualNetworkPaged[~azure.mgmt.network.v2018_07_01.models.VirtualNetwork]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34209:c0:m9"}
{"signature": "def get(<EOL>self, resource_group_name, load_balancer_name, inbound_nat_rule_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", inbound_nat_rule_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified load balancer inbound nat rule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param inbound_nat_rule_name: The name of the inbound nat rule.\n        :type inbound_nat_rule_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: InboundNatRule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_07_01.models.InboundNatRule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34210:c0:m4"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, load_balancer_name, inbound_nat_rule_name, inbound_nat_rule_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>load_balancer_name=load_balancer_name,<EOL>inbound_nat_rule_name=inbound_nat_rule_name,<EOL>inbound_nat_rule_parameters=inbound_nat_rule_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a load balancer inbound nat rule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param inbound_nat_rule_name: The name of the inbound nat rule.\n        :type inbound_nat_rule_name: str\n        :param inbound_nat_rule_parameters: Parameters supplied to the create\n         or update inbound nat rule operation.\n        :type inbound_nat_rule_parameters:\n         ~azure.mgmt.network.v2018_07_01.models.InboundNatRule\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns InboundNatRule or\n         ClientRawResponse<InboundNatRule> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_07_01.models.InboundNatRule]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_07_01.models.InboundNatRule]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34210:c0:m6"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, circuit_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates an express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the circuit.\n        :type circuit_name: str\n        :param parameters: Parameters supplied to the create or update express\n         route circuit operation.\n        :type parameters:\n         ~azure.mgmt.network.v2018_07_01.models.ExpressRouteCircuit\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ExpressRouteCircuit or\n         ClientRawResponse<ExpressRouteCircuit> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_07_01.models.ExpressRouteCircuit]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_07_01.models.ExpressRouteCircuit]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34211:c0:m5"}
{"signature": "def update_tags(<EOL>self, resource_group_name, circuit_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates an express route circuit tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the circuit.\n        :type circuit_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ExpressRouteCircuit or\n         ClientRawResponse<ExpressRouteCircuit> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_07_01.models.ExpressRouteCircuit]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_07_01.models.ExpressRouteCircuit]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34211:c0:m7"}
{"signature": "def list_routes_table_summary(<EOL>self, resource_group_name, circuit_name, peering_name, device_path, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._list_routes_table_summary_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>peering_name=peering_name,<EOL>device_path=device_path,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the currently advertised routes table summary associated with the\n        express route circuit in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param device_path: The path of the device.\n        :type device_path: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCircuitsRoutesTableSummaryListResult or\n         ClientRawResponse<ExpressRouteCircuitsRoutesTableSummaryListResult> if\n         raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_07_01.models.ExpressRouteCircuitsRoutesTableSummaryListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_07_01.models.ExpressRouteCircuitsRoutesTableSummaryListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34211:c0:m13"}
{"signature": "def delete(<EOL>self, resource_group_name, circuit_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34211:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, circuit_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about the specified express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of express route circuit.\n        :type circuit_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteCircuit or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_07_01.models.ExpressRouteCircuit or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34211:c0:m3"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PublicIPPrefixPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PublicIPPrefixPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all public IP prefixes in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PublicIPPrefix\n        :rtype:\n         ~azure.mgmt.network.v2018_07_01.models.PublicIPPrefixPaged[~azure.mgmt.network.v2018_07_01.models.PublicIPPrefix]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34212:c0:m9"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ApplicationSecurityGroupPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ApplicationSecurityGroupPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all application security groups in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ApplicationSecurityGroup\n        :rtype:\n         ~azure.mgmt.network.v2018_07_01.models.ApplicationSecurityGroupPaged[~azure.mgmt.network.v2018_07_01.models.ApplicationSecurityGroup]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34213:c0:m6"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, application_security_group_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>application_security_group_name=application_security_group_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates an application security group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param application_security_group_name: The name of the application\n         security group.\n        :type application_security_group_name: str\n        :param parameters: Parameters supplied to the create or update\n         ApplicationSecurityGroup operation.\n        :type parameters:\n         ~azure.mgmt.network.v2018_07_01.models.ApplicationSecurityGroup\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ApplicationSecurityGroup or\n         ClientRawResponse<ApplicationSecurityGroup> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_07_01.models.ApplicationSecurityGroup]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_07_01.models.ApplicationSecurityGroup]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34213:c0:m5"}
{"signature": "def delete(<EOL>self, resource_group_name, application_security_group_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>application_security_group_name=application_security_group_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified application security group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param application_security_group_name: The name of the application\n         security group.\n        :type application_security_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34213:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, circuit_name, authorization_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", authorization_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified authorization from the specified express route\n        circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param authorization_name: The name of the authorization.\n        :type authorization_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteCircuitAuthorization or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_07_01.models.ExpressRouteCircuitAuthorization\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34214:c0:m3"}
{"signature": "def list(<EOL>self, resource_group_name, circuit_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ExpressRouteCircuitAuthorizationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ExpressRouteCircuitAuthorizationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all authorizations in an express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the circuit.\n        :type circuit_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ExpressRouteCircuitAuthorization\n        :rtype:\n         ~azure.mgmt.network.v2018_07_01.models.ExpressRouteCircuitAuthorizationPaged[~azure.mgmt.network.v2018_07_01.models.ExpressRouteCircuitAuthorization]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34214:c0:m6"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualHubPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualHubPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all the VirtualHubs in a resource group.\n\n        :param resource_group_name: The resource group name of the VirtualHub.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualHub\n        :rtype:\n         ~azure.mgmt.network.v2018_07_01.models.VirtualHubPaged[~azure.mgmt.network.v2018_07_01.models.VirtualHub]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_07_01.models.ErrorException>`", "id": "f34216:c0:m8"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, network_security_group_name, security_rule_name, security_rule_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_security_group_name=network_security_group_name,<EOL>security_rule_name=security_rule_name,<EOL>security_rule_parameters=security_rule_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a security rule in the specified network security\n        group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param security_rule_name: The name of the security rule.\n        :type security_rule_name: str\n        :param security_rule_parameters: Parameters supplied to the create or\n         update network security rule operation.\n        :type security_rule_parameters:\n         ~azure.mgmt.network.v2018_07_01.models.SecurityRule\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns SecurityRule or\n         ClientRawResponse<SecurityRule> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_07_01.models.SecurityRule]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_07_01.models.SecurityRule]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34217:c0:m5"}
{"signature": "def get(<EOL>self, resource_group_name, network_security_group_name, security_rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_security_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", security_rule_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the specified network security rule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param security_rule_name: The name of the security rule.\n        :type security_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SecurityRule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_07_01.models.SecurityRule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34217:c0:m3"}
{"signature": "def get(<EOL>self, resource_group_name, virtual_network_name, subnet_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", subnet_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified subnet by virtual network and resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param subnet_name: The name of the subnet.\n        :type subnet_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Subnet or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_07_01.models.Subnet or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34218:c0:m3"}
{"signature": "def delete(<EOL>self, resource_group_name, virtual_network_name, subnet_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_name=virtual_network_name,<EOL>subnet_name=subnet_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified subnet.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param subnet_name: The name of the subnet.\n        :type subnet_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34218:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, public_ip_address_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>public_ip_address_name=public_ip_address_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified public IP address.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param public_ip_address_name: The name of the subnet.\n        :type public_ip_address_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34219:c0:m2"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PublicIPAddressPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PublicIPAddressPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the public IP addresses in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PublicIPAddress\n        :rtype:\n         ~azure.mgmt.network.v2018_07_01.models.PublicIPAddressPaged[~azure.mgmt.network.v2018_07_01.models.PublicIPAddress]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34219:c0:m8"}
{"signature": "def get_virtual_machine_scale_set_public_ip_address(<EOL>self, resource_group_name, virtual_machine_scale_set_name, virtualmachine_index, network_interface_name, ip_configuration_name, public_ip_address_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get_virtual_machine_scale_set_public_ip_address.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_machine_scale_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtualmachine_index, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_interface_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", ip_configuration_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", public_ip_address_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the specified public IP address in a virtual machine scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_machine_scale_set_name: The name of the virtual machine\n         scale set.\n        :type virtual_machine_scale_set_name: str\n        :param virtualmachine_index: The virtual machine index.\n        :type virtualmachine_index: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param ip_configuration_name: The name of the IP configuration.\n        :type ip_configuration_name: str\n        :param public_ip_address_name: The name of the public IP Address.\n        :type public_ip_address_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PublicIPAddress or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_07_01.models.PublicIPAddress or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34219:c0:m12"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PublicIPAddressPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PublicIPAddressPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all public IP addresses in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PublicIPAddress\n        :rtype:\n         ~azure.mgmt.network.v2018_07_01.models.PublicIPAddressPaged[~azure.mgmt.network.v2018_07_01.models.PublicIPAddress]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34219:c0:m9"}
{"signature": "def get(<EOL>self, resource_group_name, cross_connection_name, peering_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", cross_connection_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", peering_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified peering for the ExpressRouteCrossConnection.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param cross_connection_name: The name of the\n         ExpressRouteCrossConnection.\n        :type cross_connection_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteCrossConnectionPeering or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_07_01.models.ExpressRouteCrossConnectionPeering\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34220:c0:m4"}
{"signature": "def list(<EOL>self, location, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.EndpointServiceResultPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.EndpointServiceResultPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List what values of endpoint services are available for use.\n\n        :param location: The location to check available endpoint services.\n        :type location: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of EndpointServiceResult\n        :rtype:\n         ~azure.mgmt.network.v2018_07_01.models.EndpointServiceResultPaged[~azure.mgmt.network.v2018_07_01.models.EndpointServiceResult]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34223:c0:m1"}
{"signature": "def verify_ip_flow(<EOL>self, resource_group_name, network_watcher_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._verify_ip_flow_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Verify IP flow from the specified VM to a location given the currently\n        configured NSG rules.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param parameters: Parameters that define the IP flow to be verified.\n        :type parameters:\n         ~azure.mgmt.network.v2018_07_01.models.VerificationIPFlowParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         VerificationIPFlowResult or\n         ClientRawResponse<VerificationIPFlowResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_07_01.models.VerificationIPFlowResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_07_01.models.VerificationIPFlowResult]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_07_01.models.ErrorResponseException>`", "id": "f34224:c0:m10"}
{"signature": "def get_next_hop(<EOL>self, resource_group_name, network_watcher_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_next_hop_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the next hop from the specified VM.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param parameters: Parameters that define the source and destination\n         endpoint.\n        :type parameters:\n         ~azure.mgmt.network.v2018_07_01.models.NextHopParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns NextHopResult or\n         ClientRawResponse<NextHopResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_07_01.models.NextHopResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_07_01.models.NextHopResult]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_07_01.models.ErrorResponseException>`", "id": "f34224:c0:m12"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkWatcherPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkWatcherPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all network watchers by resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkWatcher\n        :rtype:\n         ~azure.mgmt.network.v2018_07_01.models.NetworkWatcherPaged[~azure.mgmt.network.v2018_07_01.models.NetworkWatcher]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_07_01.models.ErrorResponseException>`", "id": "f34224:c0:m6"}
{"signature": "def delete(<EOL>self, resource_group_name, network_watcher_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified network watcher resource.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_07_01.models.ErrorResponseException>`", "id": "f34224:c0:m4"}
{"signature": "def list_available_providers(<EOL>self, resource_group_name, network_watcher_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._list_available_providers_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Lists all available internet service providers for a specified Azure\n        region.\n\n        :param resource_group_name: The name of the network watcher resource\n         group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher resource.\n        :type network_watcher_name: str\n        :param parameters: Parameters that scope the list of available\n         providers.\n        :type parameters:\n         ~azure.mgmt.network.v2018_07_01.models.AvailableProvidersListParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns AvailableProvidersList\n         or ClientRawResponse<AvailableProvidersList> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_07_01.models.AvailableProvidersList]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_07_01.models.AvailableProvidersList]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_07_01.models.ErrorResponseException>`", "id": "f34224:c0:m28"}
{"signature": "def check_connectivity(<EOL>self, resource_group_name, network_watcher_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._check_connectivity_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Verifies the possibility of establishing a direct TCP connection from a\n        virtual machine to a given endpoint including another VM or an\n        arbitrary remote server.\n\n        :param resource_group_name: The name of the network watcher resource\n         group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher resource.\n        :type network_watcher_name: str\n        :param parameters: Parameters that determine how the connectivity\n         check will be performed.\n        :type parameters:\n         ~azure.mgmt.network.v2018_07_01.models.ConnectivityParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ConnectivityInformation\n         or ClientRawResponse<ConnectivityInformation> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_07_01.models.ConnectivityInformation]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_07_01.models.ConnectivityInformation]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2018_07_01.models.ErrorResponseException>`", "id": "f34224:c0:m24"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, vpn_site_name, vpn_site_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>vpn_site_name=vpn_site_name,<EOL>vpn_site_parameters=vpn_site_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates a VpnSite resource if it doesn't exist else updates the\n        existing VpnSite.\n\n        :param resource_group_name: The resource group name of the VpnSite.\n        :type resource_group_name: str\n        :param vpn_site_name: The name of the VpnSite being created or\n         updated.\n        :type vpn_site_name: str\n        :param vpn_site_parameters: Parameters supplied to create or update\n         VpnSite.\n        :type vpn_site_parameters:\n         ~azure.mgmt.network.v2018_07_01.models.VpnSite\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VpnSite or\n         ClientRawResponse<VpnSite> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_07_01.models.VpnSite]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_07_01.models.VpnSite]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_07_01.models.ErrorException>`", "id": "f34225:c0:m3"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VpnSitePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VpnSitePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all the VpnSites in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VpnSite\n        :rtype:\n         ~azure.mgmt.network.v2018_07_01.models.VpnSitePaged[~azure.mgmt.network.v2018_07_01.models.VpnSite]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2018_07_01.models.ErrorException>`", "id": "f34225:c0:m9"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ServiceEndpointPolicyPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ServiceEndpointPolicyPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all service endpoint Policies in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ServiceEndpointPolicy\n        :rtype:\n         ~azure.mgmt.network.v2018_07_01.models.ServiceEndpointPolicyPaged[~azure.mgmt.network.v2018_07_01.models.ServiceEndpointPolicy]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34227:c0:m9"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ServiceEndpointPolicyPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ServiceEndpointPolicyPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the service endpoint policies in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ServiceEndpointPolicy\n        :rtype:\n         ~azure.mgmt.network.v2018_07_01.models.ServiceEndpointPolicyPaged[~azure.mgmt.network.v2018_07_01.models.ServiceEndpointPolicy]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34227:c0:m8"}
{"signature": "def delete(<EOL>self, resource_group_name, circuit_name, peering_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>peering_name=peering_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified peering from the specified express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34228:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, load_balancer_name, frontend_ip_configuration_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", frontend_ip_configuration_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets load balancer frontend IP configuration.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param frontend_ip_configuration_name: The name of the frontend IP\n         configuration.\n        :type frontend_ip_configuration_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: FrontendIPConfiguration or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_07_01.models.FrontendIPConfiguration\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34229:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, route_table_name, route_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_table_name=route_table_name,<EOL>route_name=route_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified route from a route table.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param route_name: The name of the route.\n        :type route_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34230:c0:m2"}
{"signature": "def set_vpnclient_ipsec_parameters(<EOL>self, resource_group_name, virtual_network_gateway_name, vpnclient_ipsec_params, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._set_vpnclient_ipsec_parameters_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_name=virtual_network_gateway_name,<EOL>vpnclient_ipsec_params=vpnclient_ipsec_params,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The Set VpnclientIpsecParameters operation sets the vpnclient ipsec\n        policy for P2S client of virtual network gateway in the specified\n        resource group through Network resource provider.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param vpnclient_ipsec_params: Parameters supplied to the Begin Set\n         vpnclient ipsec parameters of Virtual Network Gateway P2S client\n         operation through Network resource provider.\n        :type vpnclient_ipsec_params:\n         ~azure.mgmt.network.v2018_07_01.models.VpnClientIPsecParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         VpnClientIPsecParameters or\n         ClientRawResponse<VpnClientIPsecParameters> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_07_01.models.VpnClientIPsecParameters]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_07_01.models.VpnClientIPsecParameters]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34232:c0:m25"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, virtual_network_gateway_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_name=virtual_network_gateway_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a virtual network gateway in the specified resource\n        group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param parameters: Parameters supplied to create or update virtual\n         network gateway operation.\n        :type parameters:\n         ~azure.mgmt.network.v2018_07_01.models.VirtualNetworkGateway\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualNetworkGateway\n         or ClientRawResponse<VirtualNetworkGateway> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_07_01.models.VirtualNetworkGateway]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_07_01.models.VirtualNetworkGateway]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34232:c0:m2"}
{"signature": "def vpn_device_configuration_script(<EOL>self, resource_group_name, virtual_network_gateway_connection_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.vpn_device_configuration_script.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_gateway_connection_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT:str>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a xml format representation for vpn device configuration script.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_connection_name: The name of the\n         virtual network gateway connection for which the configuration script\n         is generated.\n        :type virtual_network_gateway_connection_name: str\n        :param parameters: Parameters supplied to the generate vpn device\n         script operation.\n        :type parameters:\n         ~azure.mgmt.network.v2018_07_01.models.VpnDeviceScriptParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: str or ClientRawResponse if raw=true\n        :rtype: str or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34232:c0:m28"}
{"signature": "def generatevpnclientpackage(<EOL>self, resource_group_name, virtual_network_gateway_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._generatevpnclientpackage_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_name=virtual_network_gateway_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT:str>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT:location>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Generates VPN client package for P2S client of the virtual network\n        gateway in the specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param parameters: Parameters supplied to the generate virtual network\n         gateway VPN client package operation.\n        :type parameters:\n         ~azure.mgmt.network.v2018_07_01.models.VpnClientParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns str or\n         ClientRawResponse<str> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[str] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[str]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34232:c0:m13"}
{"signature": "def get_learned_routes(<EOL>self, resource_group_name, virtual_network_gateway_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_learned_routes_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_name=virtual_network_gateway_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "This operation retrieves a list of routes the virtual network gateway\n        has learned, including routes learned from BGP peers.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns GatewayRouteListResult\n         or ClientRawResponse<GatewayRouteListResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_07_01.models.GatewayRouteListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_07_01.models.GatewayRouteListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34232:c0:m21"}
{"signature": "def get_vpn_profile_package_url(<EOL>self, resource_group_name, virtual_network_gateway_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_vpn_profile_package_url_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_name=virtual_network_gateway_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT:str>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets pre-generated VPN profile for P2S client of the virtual network\n        gateway in the specified resource group. The profile needs to be\n        generated first using generateVpnProfile.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns str or\n         ClientRawResponse<str> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[str] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[str]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34232:c0:m16"}
{"signature": "def supported_vpn_devices(<EOL>self, resource_group_name, virtual_network_gateway_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.supported_vpn_devices.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_gateway_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT:str>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a xml format representation for supported vpn devices.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: str or ClientRawResponse if raw=true\n        :rtype: str or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34232:c0:m19"}
{"signature": "def update(<EOL>self, resource_group_name, route_filter_name, rule_name, route_filter_rule_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_filter_name=route_filter_name,<EOL>rule_name=rule_name,<EOL>route_filter_rule_parameters=route_filter_rule_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a route in the specified route filter.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param rule_name: The name of the route filter rule.\n        :type rule_name: str\n        :param route_filter_rule_parameters: Parameters supplied to the update\n         route filter rule operation.\n        :type route_filter_rule_parameters:\n         ~azure.mgmt.network.v2018_07_01.models.PatchRouteFilterRule\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns RouteFilterRule or\n         ClientRawResponse<RouteFilterRule> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_07_01.models.RouteFilterRule]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_07_01.models.RouteFilterRule]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34234:c0:m7"}
{"signature": "def get(<EOL>self, resource_group_name, route_filter_name, rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", route_filter_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", rule_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified rule from a route filter.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param rule_name: The name of the rule.\n        :type rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RouteFilterRule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_07_01.models.RouteFilterRule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34234:c0:m3"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all network interfaces in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkInterface\n        :rtype:\n         ~azure.mgmt.network.v2018_07_01.models.NetworkInterfacePaged[~azure.mgmt.network.v2018_07_01.models.NetworkInterface]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34236:c0:m8"}
{"signature": "def delete(<EOL>self, resource_group_name, network_interface_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_interface_name=network_interface_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified network interface.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34236:c0:m2"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkSecurityGroupPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkSecurityGroupPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all network security groups in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkSecurityGroup\n        :rtype:\n         ~azure.mgmt.network.v2018_07_01.models.NetworkSecurityGroupPaged[~azure.mgmt.network.v2018_07_01.models.NetworkSecurityGroup]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34237:c0:m9"}
{"signature": "def check_dns_name_availability(<EOL>self, location, domain_name_label=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.check_dns_name_availability.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if domain_name_label is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", domain_name_label, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Checks whether a domain name in the cloudapp.net zone is available for\n        use.\n\n        :param location: The location of the domain name.\n        :type location: str\n        :param domain_name_label: The domain name to be verified. It must\n         conform to the following regular expression:\n         ^[a-z][a-z0-9-]{1,61}[a-z0-9]$.\n        :type domain_name_label: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DnsNameAvailabilityResult or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2015_06_15.models.DnsNameAvailabilityResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34238:c1:m1"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.LoadBalancerPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.LoadBalancerPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the load balancers in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of LoadBalancer\n        :rtype:\n         ~azure.mgmt.network.v2015_06_15.models.LoadBalancerPaged[~azure.mgmt.network.v2015_06_15.models.LoadBalancer]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34382:c0:m7"}
{"signature": "def get(<EOL>self, resource_group_name, virtual_network_gateway_connection_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_gateway_connection_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified virtual network gateway connection by resource\n        group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_connection_name: The name of the\n         virtual network gateway connection.\n        :type virtual_network_gateway_connection_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualNetworkGatewayConnection or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.network.v2015_06_15.models.VirtualNetworkGatewayConnection\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34383:c0:m3"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ApplicationGatewayPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ApplicationGatewayPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all application gateways in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ApplicationGateway\n        :rtype:\n         ~azure.mgmt.network.v2015_06_15.models.ApplicationGatewayPaged[~azure.mgmt.network.v2015_06_15.models.ApplicationGateway]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34384:c0:m6"}
{"signature": "def get(<EOL>self, resource_group_name, local_network_gateway_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", local_network_gateway_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified local network gateway in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param local_network_gateway_name: The name of the local network\n         gateway.\n        :type local_network_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: LocalNetworkGateway or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2015_06_15.models.LocalNetworkGateway or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34385:c0:m3"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, local_network_gateway_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>local_network_gateway_name=local_network_gateway_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a local network gateway in the specified resource\n        group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param local_network_gateway_name: The name of the local network\n         gateway.\n        :type local_network_gateway_name: str\n        :param parameters: Parameters supplied to the create or update local\n         network gateway operation.\n        :type parameters:\n         ~azure.mgmt.network.v2015_06_15.models.LocalNetworkGateway\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns LocalNetworkGateway or\n         ClientRawResponse<LocalNetworkGateway> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2015_06_15.models.LocalNetworkGateway]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2015_06_15.models.LocalNetworkGateway]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34385:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, route_table_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", route_table_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified route table.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RouteTable or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2015_06_15.models.RouteTable or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34386:c0:m3"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RouteTablePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RouteTablePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all route tables in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of RouteTable\n        :rtype:\n         ~azure.mgmt.network.v2015_06_15.models.RouteTablePaged[~azure.mgmt.network.v2015_06_15.models.RouteTable]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34386:c0:m6"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualNetworkPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualNetworkPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all virtual networks in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualNetwork\n        :rtype:\n         ~azure.mgmt.network.v2015_06_15.models.VirtualNetworkPaged[~azure.mgmt.network.v2015_06_15.models.VirtualNetwork]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34387:c0:m6"}
{"signature": "def get(<EOL>self, resource_group_name, circuit_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about the specified express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of express route circuit.\n        :type circuit_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteCircuit or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2015_06_15.models.ExpressRouteCircuit or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34388:c0:m3"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ExpressRouteCircuitPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ExpressRouteCircuitPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the express route circuits in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ExpressRouteCircuit\n        :rtype:\n         ~azure.mgmt.network.v2015_06_15.models.ExpressRouteCircuitPaged[~azure.mgmt.network.v2015_06_15.models.ExpressRouteCircuit]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34388:c0:m9"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, circuit_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates an express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the circuit.\n        :type circuit_name: str\n        :param parameters: Parameters supplied to the create or update express\n         route circuit operation.\n        :type parameters:\n         ~azure.mgmt.network.v2015_06_15.models.ExpressRouteCircuit\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ExpressRouteCircuit or\n         ClientRawResponse<ExpressRouteCircuit> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2015_06_15.models.ExpressRouteCircuit]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2015_06_15.models.ExpressRouteCircuit]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34388:c0:m5"}
{"signature": "def get(<EOL>self, resource_group_name, circuit_name, authorization_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", authorization_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified authorization from the specified express route\n        circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param authorization_name: The name of the authorization.\n        :type authorization_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteCircuitAuthorization or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.network.v2015_06_15.models.ExpressRouteCircuitAuthorization\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34389:c0:m3"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, circuit_name, authorization_name, authorization_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>authorization_name=authorization_name,<EOL>authorization_parameters=authorization_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates an authorization in the specified express route\n        circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param authorization_name: The name of the authorization.\n        :type authorization_name: str\n        :param authorization_parameters: Parameters supplied to the create or\n         update express route circuit authorization operation.\n        :type authorization_parameters:\n         ~azure.mgmt.network.v2015_06_15.models.ExpressRouteCircuitAuthorization\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCircuitAuthorization or\n         ClientRawResponse<ExpressRouteCircuitAuthorization> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2015_06_15.models.ExpressRouteCircuitAuthorization]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2015_06_15.models.ExpressRouteCircuitAuthorization]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34389:c0:m5"}
{"signature": "def delete(<EOL>self, resource_group_name, public_ip_address_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>public_ip_address_name=public_ip_address_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified public IP address.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param public_ip_address_name: The name of the subnet.\n        :type public_ip_address_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34393:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, public_ip_address_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", public_ip_address_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified public IP address in a specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param public_ip_address_name: The name of the subnet.\n        :type public_ip_address_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PublicIPAddress or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2015_06_15.models.PublicIPAddress or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34393:c0:m3"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PublicIPAddressPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PublicIPAddressPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all public IP addresses in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PublicIPAddress\n        :rtype:\n         ~azure.mgmt.network.v2015_06_15.models.PublicIPAddressPaged[~azure.mgmt.network.v2015_06_15.models.PublicIPAddress]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34393:c0:m7"}
{"signature": "def list(<EOL>self, location, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>', pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.UsagePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.UsagePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists compute usages for a subscription.\n\n        :param location: The location where resource usage is queried.\n        :type location: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Usage\n        :rtype:\n         ~azure.mgmt.network.v2015_06_15.models.UsagePaged[~azure.mgmt.network.v2015_06_15.models.Usage]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34395:c0:m1"}
{"signature": "def list(<EOL>self, resource_group_name, route_table_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", route_table_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RoutePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RoutePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all routes in a route table.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Route\n        :rtype:\n         ~azure.mgmt.network.v2015_06_15.models.RoutePaged[~azure.mgmt.network.v2015_06_15.models.Route]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34397:c0:m6"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, route_table_name, route_name, route_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_table_name=route_table_name,<EOL>route_name=route_name,<EOL>route_parameters=route_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a route in the specified route table.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param route_name: The name of the route.\n        :type route_name: str\n        :param route_parameters: Parameters supplied to the create or update\n         route operation.\n        :type route_parameters: ~azure.mgmt.network.v2015_06_15.models.Route\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Route or\n         ClientRawResponse<Route> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2015_06_15.models.Route]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2015_06_15.models.Route]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34397:c0:m5"}
{"signature": "def delete(<EOL>self, resource_group_name, virtual_network_gateway_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_name=virtual_network_gateway_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified virtual network gateway.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34398:c0:m5"}
{"signature": "def list_virtual_machine_scale_set_network_interfaces(<EOL>self, resource_group_name, virtual_machine_scale_set_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_virtual_machine_scale_set_network_interfaces.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_machine_scale_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all network interfaces in a virtual machine scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_machine_scale_set_name: The name of the virtual machine\n         scale set.\n        :type virtual_machine_scale_set_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkInterface\n        :rtype:\n         ~azure.mgmt.network.v2015_06_15.models.NetworkInterfacePaged[~azure.mgmt.network.v2015_06_15.models.NetworkInterface]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34399:c0:m9"}
{"signature": "def delete(<EOL>self, resource_group_name, network_interface_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_interface_name=network_interface_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified network interface.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34399:c0:m2"}
{"signature": "def get_virtual_machine_scale_set_network_interface(<EOL>self, resource_group_name, virtual_machine_scale_set_name, virtualmachine_index, network_interface_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_virtual_machine_scale_set_network_interface.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_machine_scale_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtualmachine_index, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_interface_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the specified network interface in a virtual machine scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_machine_scale_set_name: The name of the virtual machine\n         scale set.\n        :type virtual_machine_scale_set_name: str\n        :param virtualmachine_index: The virtual machine index.\n        :type virtualmachine_index: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: NetworkInterface or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2015_06_15.models.NetworkInterface or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34399:c0:m10"}
{"signature": "def list(<EOL>self, resource_group_name, express_route_port_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", express_route_port_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ExpressRouteLinkPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ExpressRouteLinkPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieve the ExpressRouteLink sub-resources of the specified\n        ExpressRoutePort resource.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param express_route_port_name: The name of the ExpressRoutePort\n         resource.\n        :type express_route_port_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ExpressRouteLink\n        :rtype:\n         ~azure.mgmt.network.v2019_02_01.models.ExpressRouteLinkPaged[~azure.mgmt.network.v2019_02_01.models.ExpressRouteLink]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34876:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, load_balancer_name, backend_address_pool_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", backend_address_pool_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets load balancer backend address pool.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param backend_address_pool_name: The name of the backend address\n         pool.\n        :type backend_address_pool_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: BackendAddressPool or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2019_02_01.models.BackendAddressPool or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34878:c0:m2"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, network_interface_name, tap_configuration_name, tap_configuration_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_interface_name=network_interface_name,<EOL>tap_configuration_name=tap_configuration_name,<EOL>tap_configuration_parameters=tap_configuration_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a Tap configuration in the specified\n        NetworkInterface.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param tap_configuration_name: The name of the tap configuration.\n        :type tap_configuration_name: str\n        :param tap_configuration_parameters: Parameters supplied to the create\n         or update tap configuration operation.\n        :type tap_configuration_parameters:\n         ~azure.mgmt.network.v2019_02_01.models.NetworkInterfaceTapConfiguration\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         NetworkInterfaceTapConfiguration or\n         ClientRawResponse<NetworkInterfaceTapConfiguration> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2019_02_01.models.NetworkInterfaceTapConfiguration]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2019_02_01.models.NetworkInterfaceTapConfiguration]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34880:c0:m5"}
{"signature": "def get(<EOL>self, resource_group_name, network_interface_name, tap_configuration_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_interface_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", tap_configuration_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the specified tap configuration on a network interface.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param tap_configuration_name: The name of the tap configuration.\n        :type tap_configuration_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: NetworkInterfaceTapConfiguration or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.network.v2019_02_01.models.NetworkInterfaceTapConfiguration\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34880:c0:m3"}
{"signature": "def list(<EOL>self, resource_group_name, network_interface_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_interface_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkInterfaceTapConfigurationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkInterfaceTapConfigurationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get all Tap configurations in a network interface.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkInterfaceTapConfiguration\n        :rtype:\n         ~azure.mgmt.network.v2019_02_01.models.NetworkInterfaceTapConfigurationPaged[~azure.mgmt.network.v2019_02_01.models.NetworkInterfaceTapConfiguration]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34880:c0:m6"}
{"signature": "def get(<EOL>self, resource_group_name, network_interface_name, ip_configuration_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_interface_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", ip_configuration_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified network interface ip configuration.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param ip_configuration_name: The name of the ip configuration name.\n        :type ip_configuration_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: NetworkInterfaceIPConfiguration or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.network.v2019_02_01.models.NetworkInterfaceIPConfiguration\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34881:c0:m2"}
{"signature": "def list_by_subscription(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_by_subscription.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists ExpressRoute gateways under a given subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteGatewayList or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2019_02_01.models.ExpressRouteGatewayList\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34882:c0:m1"}
{"signature": "def get(<EOL>self, resource_group_name, express_route_gateway_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", express_route_gateway_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Fetches the details of a ExpressRoute gateway in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param express_route_gateway_name: The name of the ExpressRoute\n         gateway.\n        :type express_route_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteGateway or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2019_02_01.models.ExpressRouteGateway or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34882:c0:m5"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists ExpressRoute gateways in a given resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteGatewayList or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2019_02_01.models.ExpressRouteGatewayList\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34882:c0:m2"}
{"signature": "def update_tags(<EOL>self, resource_group_name, cross_connection_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>cross_connection_name=cross_connection_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates an express route cross connection tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param cross_connection_name: The name of the cross connection.\n        :type cross_connection_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCrossConnection or\n         ClientRawResponse<ExpressRouteCrossConnection> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2019_02_01.models.ExpressRouteCrossConnection]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2019_02_01.models.ExpressRouteCrossConnection]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34883:c0:m7"}
{"signature": "def list_routes_table_summary(<EOL>self, resource_group_name, cross_connection_name, peering_name, device_path, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._list_routes_table_summary_initial(<EOL>resource_group_name=resource_group_name,<EOL>cross_connection_name=cross_connection_name,<EOL>peering_name=peering_name,<EOL>device_path=device_path,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT:location>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the route table summary associated with the express route cross\n        connection in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param cross_connection_name: The name of the\n         ExpressRouteCrossConnection.\n        :type cross_connection_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param device_path: The path of the device.\n        :type device_path: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCrossConnectionsRoutesTableSummaryListResult or\n         ClientRawResponse<ExpressRouteCrossConnectionsRoutesTableSummaryListResult>\n         if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2019_02_01.models.ExpressRouteCrossConnectionsRoutesTableSummaryListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2019_02_01.models.ExpressRouteCrossConnectionsRoutesTableSummaryListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34883:c0:m11"}
{"signature": "def get(<EOL>self, resource_group_name, circuit_name, peering_name, connection_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", peering_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", connection_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified Peer Express Route Circuit Connection from the\n        specified express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param connection_name: The name of the peer express route circuit\n         connection.\n        :type connection_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PeerExpressRouteCircuitConnection or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.network.v2019_02_01.models.PeerExpressRouteCircuitConnection\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34885:c0:m1"}
{"signature": "def get(<EOL>self, resource_group_name, network_watcher_name, packet_capture_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_watcher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", packet_capture_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a packet capture session by name.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param packet_capture_name: The name of the packet capture session.\n        :type packet_capture_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PacketCaptureResult or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2019_02_01.models.PacketCaptureResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2019_02_01.models.ErrorResponseException>`", "id": "f34887:c0:m3"}
{"signature": "def list(<EOL>self, resource_group_name, network_watcher_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_watcher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PacketCaptureResultPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PacketCaptureResultPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all packet capture sessions within the specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the Network Watcher resource.\n        :type network_watcher_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PacketCaptureResult\n        :rtype:\n         ~azure.mgmt.network.v2019_02_01.models.PacketCaptureResultPaged[~azure.mgmt.network.v2019_02_01.models.PacketCaptureResult]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2019_02_01.models.ErrorResponseException>`", "id": "f34887:c0:m10"}
{"signature": "def set_shared_key(<EOL>self, resource_group_name, virtual_network_gateway_connection_name, value, id=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._set_shared_key_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_connection_name=virtual_network_gateway_connection_name,<EOL>value=value,<EOL>id=id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The Put VirtualNetworkGatewayConnectionSharedKey operation sets the\n        virtual network gateway connection shared key for passed virtual\n        network gateway connection in the specified resource group through\n        Network resource provider.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_connection_name: The virtual network\n         gateway connection name.\n        :type virtual_network_gateway_connection_name: str\n        :param value: The virtual network connection shared key value.\n        :type value: str\n        :param id: Resource ID.\n        :type id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ConnectionSharedKey or\n         ClientRawResponse<ConnectionSharedKey> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2019_02_01.models.ConnectionSharedKey]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2019_02_01.models.ConnectionSharedKey]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34888:c0:m9"}
{"signature": "def reset_shared_key(<EOL>self, resource_group_name, virtual_network_gateway_connection_name, key_length, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._reset_shared_key_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_connection_name=virtual_network_gateway_connection_name,<EOL>key_length=key_length,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT:location>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The VirtualNetworkGatewayConnectionResetSharedKey operation resets the\n        virtual network gateway connection shared key for passed virtual\n        network gateway connection in the specified resource group through\n        Network resource provider.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_connection_name: The virtual network\n         gateway connection reset shared key Name.\n        :type virtual_network_gateway_connection_name: str\n        :param key_length: The virtual network connection reset shared key\n         length, should between 1 and 128.\n        :type key_length: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ConnectionResetSharedKey or\n         ClientRawResponse<ConnectionResetSharedKey> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2019_02_01.models.ConnectionResetSharedKey]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2019_02_01.models.ConnectionResetSharedKey]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34888:c0:m13"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, express_route_port_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>express_route_port_name=express_route_port_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates the specified ExpressRoutePort resource.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param express_route_port_name: The name of the ExpressRoutePort\n         resource.\n        :type express_route_port_name: str\n        :param parameters: Parameters supplied to the create ExpressRoutePort\n         operation.\n        :type parameters:\n         ~azure.mgmt.network.v2019_02_01.models.ExpressRoutePort\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ExpressRoutePort or\n         ClientRawResponse<ExpressRoutePort> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2019_02_01.models.ExpressRoutePort]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2019_02_01.models.ExpressRoutePort]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34889:c0:m5"}
{"signature": "def update_tags(<EOL>self, resource_group_name, ddos_custom_policy_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>ddos_custom_policy_name=ddos_custom_policy_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Update a DDoS custom policy tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param ddos_custom_policy_name: The name of the DDoS custom policy.\n        :type ddos_custom_policy_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns DdosCustomPolicy or\n         ClientRawResponse<DdosCustomPolicy> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2019_02_01.models.DdosCustomPolicy]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2019_02_01.models.DdosCustomPolicy]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34891:c0:m7"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.P2SVpnGatewayPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.P2SVpnGatewayPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all the P2SVpnGateways in a resource group.\n\n        :param resource_group_name: The resource group name of the\n         P2SVpnGateway.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of P2SVpnGateway\n        :rtype:\n         ~azure.mgmt.network.v2019_02_01.models.P2SVpnGatewayPaged[~azure.mgmt.network.v2019_02_01.models.P2SVpnGateway]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2019_02_01.models.ErrorException>`", "id": "f34892:c0:m8"}
{"signature": "def update_tags(<EOL>self, resource_group_name, gateway_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>gateway_name=gateway_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates virtual wan p2s vpn gateway tags.\n\n        :param resource_group_name: The resource group name of the\n         P2SVpnGateway.\n        :type resource_group_name: str\n        :param gateway_name: The name of the gateway.\n        :type gateway_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns P2SVpnGateway or\n         ClientRawResponse<P2SVpnGateway> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2019_02_01.models.P2SVpnGateway]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2019_02_01.models.P2SVpnGateway]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2019_02_01.models.ErrorException>`", "id": "f34892:c0:m5"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, gateway_name, p2_svpn_gateway_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>gateway_name=gateway_name,<EOL>p2_svpn_gateway_parameters=p2_svpn_gateway_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates a virtual wan p2s vpn gateway if it doesn't exist else updates\n        the existing gateway.\n\n        :param resource_group_name: The resource group name of the\n         P2SVpnGateway.\n        :type resource_group_name: str\n        :param gateway_name: The name of the gateway.\n        :type gateway_name: str\n        :param p2_svpn_gateway_parameters: Parameters supplied to create or\n         Update a virtual wan p2s vpn gateway.\n        :type p2_svpn_gateway_parameters:\n         ~azure.mgmt.network.v2019_02_01.models.P2SVpnGateway\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns P2SVpnGateway or\n         ClientRawResponse<P2SVpnGateway> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2019_02_01.models.P2SVpnGateway]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2019_02_01.models.P2SVpnGateway]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2019_02_01.models.ErrorException>`", "id": "f34892:c0:m3"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, ddos_protection_plan_name, location=None, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>ddos_protection_plan_name=ddos_protection_plan_name,<EOL>location=location,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a DDoS protection plan.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param ddos_protection_plan_name: The name of the DDoS protection\n         plan.\n        :type ddos_protection_plan_name: str\n        :param location: Resource location.\n        :type location: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns DdosProtectionPlan or\n         ClientRawResponse<DdosProtectionPlan> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2019_02_01.models.DdosProtectionPlan]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2019_02_01.models.DdosProtectionPlan]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34893:c0:m5"}
{"signature": "def get(<EOL>self, resource_group_name, azure_firewall_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", azure_firewall_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified Azure Firewall.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param azure_firewall_name: The name of the Azure Firewall.\n        :type azure_firewall_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: AzureFirewall or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2019_02_01.models.AzureFirewall or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34894:c0:m3"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NatGatewayPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NatGatewayPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the Nat Gateways in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NatGateway\n        :rtype:\n         ~azure.mgmt.network.v2019_02_01.models.NatGatewayPaged[~azure.mgmt.network.v2019_02_01.models.NatGateway]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34895:c0:m7"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, nat_gateway_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>nat_gateway_name=nat_gateway_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a nat gateway.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param nat_gateway_name: The name of the nat gateway.\n        :type nat_gateway_name: str\n        :param parameters: Parameters supplied to the create or update nat\n         gateway operation.\n        :type parameters: ~azure.mgmt.network.v2019_02_01.models.NatGateway\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns NatGateway or\n         ClientRawResponse<NatGateway> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2019_02_01.models.NatGateway]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2019_02_01.models.NatGateway]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34895:c0:m5"}
{"signature": "def get(<EOL>self, resource_group_name, application_gateway_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", application_gateway_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified application gateway.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param application_gateway_name: The name of the application gateway.\n        :type application_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ApplicationGateway or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2019_02_01.models.ApplicationGateway or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34896:c0:m3"}
{"signature": "def list_available_ssl_predefined_policies(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_available_ssl_predefined_policies.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ApplicationGatewaySslPredefinedPolicyPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ApplicationGatewaySslPredefinedPolicyPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all SSL predefined policies for configuring Ssl policy.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of\n         ApplicationGatewaySslPredefinedPolicy\n        :rtype:\n         ~azure.mgmt.network.v2019_02_01.models.ApplicationGatewaySslPredefinedPolicyPaged[~azure.mgmt.network.v2019_02_01.models.ApplicationGatewaySslPredefinedPolicy]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34896:c0:m23"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ApplicationGatewayPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ApplicationGatewayPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all application gateways in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ApplicationGateway\n        :rtype:\n         ~azure.mgmt.network.v2019_02_01.models.ApplicationGatewayPaged[~azure.mgmt.network.v2019_02_01.models.ApplicationGateway]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34896:c0:m8"}
{"signature": "def list_available_server_variables(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_available_server_variables.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all available server variables.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype: list[str] or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2019_02_01.models.ErrorException>`", "id": "f34896:c0:m18"}
{"signature": "def delete(<EOL>self, resource_group_name, application_gateway_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>application_gateway_name=application_gateway_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified application gateway.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param application_gateway_name: The name of the application gateway.\n        :type application_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34896:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, network_profile_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_profile_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified network profile in a specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_profile_name: The name of the public IP prefix.\n        :type network_profile_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: NetworkProfile or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2019_02_01.models.NetworkProfile or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34897:c0:m3"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkProfilePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkProfilePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all network profiles in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkProfile\n        :rtype:\n         ~azure.mgmt.network.v2019_02_01.models.NetworkProfilePaged[~azure.mgmt.network.v2019_02_01.models.NetworkProfile]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34897:c0:m9"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, service_endpoint_policy_name, service_endpoint_policy_definition_name, service_endpoint_policy_definitions, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>service_endpoint_policy_name=service_endpoint_policy_name,<EOL>service_endpoint_policy_definition_name=service_endpoint_policy_definition_name,<EOL>service_endpoint_policy_definitions=service_endpoint_policy_definitions,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a service endpoint policy definition in the\n        specified service endpoint policy.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param service_endpoint_policy_name: The name of the service endpoint\n         policy.\n        :type service_endpoint_policy_name: str\n        :param service_endpoint_policy_definition_name: The name of the\n         service endpoint policy definition name.\n        :type service_endpoint_policy_definition_name: str\n        :param service_endpoint_policy_definitions: Parameters supplied to the\n         create or update service endpoint policy operation.\n        :type service_endpoint_policy_definitions:\n         ~azure.mgmt.network.v2019_02_01.models.ServiceEndpointPolicyDefinition\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ServiceEndpointPolicyDefinition or\n         ClientRawResponse<ServiceEndpointPolicyDefinition> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2019_02_01.models.ServiceEndpointPolicyDefinition]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2019_02_01.models.ServiceEndpointPolicyDefinition]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34898:c0:m5"}
{"signature": "def get(<EOL>self, resource_group_name, service_endpoint_policy_name, service_endpoint_policy_definition_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", service_endpoint_policy_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", service_endpoint_policy_definition_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the specified service endpoint policy definitions from service\n        endpoint policy.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param service_endpoint_policy_name: The name of the service endpoint\n         policy name.\n        :type service_endpoint_policy_name: str\n        :param service_endpoint_policy_definition_name: The name of the\n         service endpoint policy definition name.\n        :type service_endpoint_policy_definition_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ServiceEndpointPolicyDefinition or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.network.v2019_02_01.models.ServiceEndpointPolicyDefinition\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34898:c0:m3"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, route_filter_name, route_filter_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_filter_name=route_filter_name,<EOL>route_filter_parameters=route_filter_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a route filter in a specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param route_filter_parameters: Parameters supplied to the create or\n         update route filter operation.\n        :type route_filter_parameters:\n         ~azure.mgmt.network.v2019_02_01.models.RouteFilter\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns RouteFilter or\n         ClientRawResponse<RouteFilter> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2019_02_01.models.RouteFilter]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2019_02_01.models.RouteFilter]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34899:c0:m5"}
{"signature": "def get(<EOL>self, resource_group_name, route_filter_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", route_filter_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified route filter.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param expand: Expands referenced express route bgp peering resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RouteFilter or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2019_02_01.models.RouteFilter or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34899:c0:m3"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RouteFilterPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RouteFilterPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all route filters in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of RouteFilter\n        :rtype:\n         ~azure.mgmt.network.v2019_02_01.models.RouteFilterPaged[~azure.mgmt.network.v2019_02_01.models.RouteFilter]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34899:c0:m8"}
{"signature": "def get(<EOL>self, resource_group_name, load_balancer_name, outbound_rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", outbound_rule_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified load balancer outbound rule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param outbound_rule_name: The name of the outbound rule.\n        :type outbound_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: OutboundRule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2019_02_01.models.OutboundRule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34900:c0:m2"}
{"signature": "def list(<EOL>self, resource_group_name, network_watcher_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_watcher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ConnectionMonitorResultPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ConnectionMonitorResultPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all connection monitors for the specified Network Watcher.\n\n        :param resource_group_name: The name of the resource group containing\n         Network Watcher.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the Network Watcher resource.\n        :type network_watcher_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ConnectionMonitorResult\n        :rtype:\n         ~azure.mgmt.network.v2019_02_01.models.ConnectionMonitorResultPaged[~azure.mgmt.network.v2019_02_01.models.ConnectionMonitorResult]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2019_02_01.models.ErrorResponseException>`", "id": "f34901:c0:m12"}
{"signature": "def delete(<EOL>self, resource_group_name, local_network_gateway_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>local_network_gateway_name=local_network_gateway_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified local network gateway.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param local_network_gateway_name: The name of the local network\n         gateway.\n        :type local_network_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34902:c0:m5"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, local_network_gateway_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>local_network_gateway_name=local_network_gateway_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a local network gateway in the specified resource\n        group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param local_network_gateway_name: The name of the local network\n         gateway.\n        :type local_network_gateway_name: str\n        :param parameters: Parameters supplied to the create or update local\n         network gateway operation.\n        :type parameters:\n         ~azure.mgmt.network.v2019_02_01.models.LocalNetworkGateway\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns LocalNetworkGateway or\n         ClientRawResponse<LocalNetworkGateway> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2019_02_01.models.LocalNetworkGateway]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2019_02_01.models.LocalNetworkGateway]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34902:c0:m2"}
{"signature": "def download(<EOL>self, resource_group_name, virtual_wan_name, output_blob_sas_url, vpn_sites=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._download_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_wan_name=virtual_wan_name,<EOL>output_blob_sas_url=output_blob_sas_url,<EOL>vpn_sites=vpn_sites,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT:location>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gives the sas-url to download the configurations for vpn-sites in a\n        resource group.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param virtual_wan_name: The name of the VirtualWAN for which\n         configuration of all vpn-sites is needed.\n        :type virtual_wan_name: str\n        :param output_blob_sas_url: The sas-url to download the configurations\n         for vpn-sites\n        :type output_blob_sas_url: str\n        :param vpn_sites: List of resource-ids of the vpn-sites for which\n         config is to be downloaded.\n        :type vpn_sites: list[str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2019_02_01.models.ErrorException>`", "id": "f34903:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, network_security_group_name, default_security_rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_security_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", default_security_rule_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the specified default network security rule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param default_security_rule_name: The name of the default security\n         rule.\n        :type default_security_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SecurityRule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2019_02_01.models.SecurityRule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34905:c0:m2"}
{"signature": "def update_tags(<EOL>self, resource_group_name, gateway_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>gateway_name=gateway_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates virtual wan vpn gateway tags.\n\n        :param resource_group_name: The resource group name of the VpnGateway.\n        :type resource_group_name: str\n        :param gateway_name: The name of the gateway.\n        :type gateway_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VpnGateway or\n         ClientRawResponse<VpnGateway> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2019_02_01.models.VpnGateway]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2019_02_01.models.VpnGateway]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2019_02_01.models.ErrorException>`", "id": "f34906:c0:m5"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VpnGatewayPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VpnGatewayPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all the VpnGateways in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VpnGateway\n        :rtype:\n         ~azure.mgmt.network.v2019_02_01.models.VpnGatewayPaged[~azure.mgmt.network.v2019_02_01.models.VpnGateway]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2019_02_01.models.ErrorException>`", "id": "f34906:c0:m9"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, route_table_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_table_name=route_table_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Create or updates a route table in a specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param parameters: Parameters supplied to the create or update route\n         table operation.\n        :type parameters: ~azure.mgmt.network.v2019_02_01.models.RouteTable\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns RouteTable or\n         ClientRawResponse<RouteTable> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2019_02_01.models.RouteTable]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2019_02_01.models.RouteTable]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34907:c0:m5"}
{"signature": "def list(<EOL>self, resource_group_name, network_interface_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_interface_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.LoadBalancerPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.LoadBalancerPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List all load balancers in a network interface.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of LoadBalancer\n        :rtype:\n         ~azure.mgmt.network.v2019_02_01.models.LoadBalancerPaged[~azure.mgmt.network.v2019_02_01.models.LoadBalancer]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34908:c0:m1"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.InterfaceEndpointPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.InterfaceEndpointPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all interface endpoints in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of InterfaceEndpoint\n        :rtype:\n         ~azure.mgmt.network.v2019_02_01.models.InterfaceEndpointPaged[~azure.mgmt.network.v2019_02_01.models.InterfaceEndpoint]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34909:c0:m6"}
{"signature": "def list_by_subscription(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_subscription.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.InterfaceEndpointPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.InterfaceEndpointPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all interface endpoints in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of InterfaceEndpoint\n        :rtype:\n         ~azure.mgmt.network.v2019_02_01.models.InterfaceEndpointPaged[~azure.mgmt.network.v2019_02_01.models.InterfaceEndpoint]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34909:c0:m7"}
{"signature": "def get(<EOL>self, resource_group_name, circuit_name, peering_name, connection_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", peering_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", connection_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified Express Route Circuit Connection from the specified\n        express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param connection_name: The name of the express route circuit\n         connection.\n        :type connection_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteCircuitConnection or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.network.v2019_02_01.models.ExpressRouteCircuitConnection\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34910:c0:m3"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, circuit_name, peering_name, connection_name, express_route_circuit_connection_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>peering_name=peering_name,<EOL>connection_name=connection_name,<EOL>express_route_circuit_connection_parameters=express_route_circuit_connection_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a Express Route Circuit Connection in the specified\n        express route circuits.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param connection_name: The name of the express route circuit\n         connection.\n        :type connection_name: str\n        :param express_route_circuit_connection_parameters: Parameters\n         supplied to the create or update express route circuit connection\n         operation.\n        :type express_route_circuit_connection_parameters:\n         ~azure.mgmt.network.v2019_02_01.models.ExpressRouteCircuitConnection\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCircuitConnection or\n         ClientRawResponse<ExpressRouteCircuitConnection> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2019_02_01.models.ExpressRouteCircuitConnection]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2019_02_01.models.ExpressRouteCircuitConnection]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34910:c0:m5"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, virtual_network_name, virtual_network_peering_name, virtual_network_peering_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_name=virtual_network_name,<EOL>virtual_network_peering_name=virtual_network_peering_name,<EOL>virtual_network_peering_parameters=virtual_network_peering_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a peering in the specified virtual network.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param virtual_network_peering_name: The name of the peering.\n        :type virtual_network_peering_name: str\n        :param virtual_network_peering_parameters: Parameters supplied to the\n         create or update virtual network peering operation.\n        :type virtual_network_peering_parameters:\n         ~azure.mgmt.network.v2019_02_01.models.VirtualNetworkPeering\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualNetworkPeering\n         or ClientRawResponse<VirtualNetworkPeering> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2019_02_01.models.VirtualNetworkPeering]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2019_02_01.models.VirtualNetworkPeering]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34911:c0:m5"}
{"signature": "def get(<EOL>self, resource_group_name, virtual_network_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified virtual network by resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualNetwork or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2019_02_01.models.VirtualNetwork or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34912:c0:m3"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualNetworkPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualNetworkPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all virtual networks in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualNetwork\n        :rtype:\n         ~azure.mgmt.network.v2019_02_01.models.VirtualNetworkPaged[~azure.mgmt.network.v2019_02_01.models.VirtualNetwork]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34912:c0:m9"}
{"signature": "def get(<EOL>self, resource_group_name, load_balancer_name, inbound_nat_rule_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", inbound_nat_rule_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified load balancer inbound nat rule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param inbound_nat_rule_name: The name of the inbound nat rule.\n        :type inbound_nat_rule_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: InboundNatRule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2019_02_01.models.InboundNatRule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34913:c0:m4"}
{"signature": "def update_tags(<EOL>self, resource_group_name, circuit_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates an express route circuit tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the circuit.\n        :type circuit_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ExpressRouteCircuit or\n         ClientRawResponse<ExpressRouteCircuit> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2019_02_01.models.ExpressRouteCircuit]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2019_02_01.models.ExpressRouteCircuit]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34914:c0:m7"}
{"signature": "def list_arp_table(<EOL>self, resource_group_name, circuit_name, peering_name, device_path, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._list_arp_table_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>peering_name=peering_name,<EOL>device_path=device_path,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT:location>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the currently advertised ARP table associated with the express\n        route circuit in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param device_path: The path of the device.\n        :type device_path: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCircuitsArpTableListResult or\n         ClientRawResponse<ExpressRouteCircuitsArpTableListResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2019_02_01.models.ExpressRouteCircuitsArpTableListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2019_02_01.models.ExpressRouteCircuitsArpTableListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34914:c0:m9"}
{"signature": "def list_routes_table_summary(<EOL>self, resource_group_name, circuit_name, peering_name, device_path, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._list_routes_table_summary_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>peering_name=peering_name,<EOL>device_path=device_path,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT:location>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the currently advertised routes table summary associated with the\n        express route circuit in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param device_path: The path of the device.\n        :type device_path: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCircuitsRoutesTableSummaryListResult or\n         ClientRawResponse<ExpressRouteCircuitsRoutesTableSummaryListResult> if\n         raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2019_02_01.models.ExpressRouteCircuitsRoutesTableSummaryListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2019_02_01.models.ExpressRouteCircuitsRoutesTableSummaryListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34914:c0:m13"}
{"signature": "def get_peering_stats(<EOL>self, resource_group_name, circuit_name, peering_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_peering_stats.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", peering_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all stats from an express route circuit in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteCircuitStats or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2019_02_01.models.ExpressRouteCircuitStats or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34914:c0:m15"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ApplicationSecurityGroupPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ApplicationSecurityGroupPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all application security groups in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ApplicationSecurityGroup\n        :rtype:\n         ~azure.mgmt.network.v2019_02_01.models.ApplicationSecurityGroupPaged[~azure.mgmt.network.v2019_02_01.models.ApplicationSecurityGroup]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34916:c0:m8"}
{"signature": "def get(<EOL>self, resource_group_name, application_security_group_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", application_security_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about the specified application security group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param application_security_group_name: The name of the application\n         security group.\n        :type application_security_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ApplicationSecurityGroup or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2019_02_01.models.ApplicationSecurityGroup or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34916:c0:m3"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, policy_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", policy_name, '<STR_LIT:str>', max_length=<NUM_LIT>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or update policy with specified rule set name within a resource\n        group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param policy_name: The name of the policy.\n        :type policy_name: str\n        :param parameters: Policy to be created.\n        :type parameters:\n         ~azure.mgmt.network.v2019_02_01.models.WebApplicationFirewallPolicy\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: WebApplicationFirewallPolicy or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2019_02_01.models.WebApplicationFirewallPolicy or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34918:c0:m4"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ExpressRouteServiceProviderPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ExpressRouteServiceProviderPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the available express route service providers.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ExpressRouteServiceProvider\n        :rtype:\n         ~azure.mgmt.network.v2019_02_01.models.ExpressRouteServiceProviderPaged[~azure.mgmt.network.v2019_02_01.models.ExpressRouteServiceProvider]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34919:c0:m1"}
{"signature": "def get(<EOL>self, resource_group_name, virtual_hub_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_hub_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves the details of a VirtualHub.\n\n        :param resource_group_name: The resource group name of the VirtualHub.\n        :type resource_group_name: str\n        :param virtual_hub_name: The name of the VirtualHub.\n        :type virtual_hub_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualHub or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2019_02_01.models.VirtualHub or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2019_02_01.models.ErrorException>`", "id": "f34920:c0:m1"}
{"signature": "def delete(<EOL>self, resource_group_name, virtual_hub_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_hub_name=virtual_hub_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes a VirtualHub.\n\n        :param resource_group_name: The resource group name of the VirtualHub.\n        :type resource_group_name: str\n        :param virtual_hub_name: The name of the VirtualHub.\n        :type virtual_hub_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2019_02_01.models.ErrorException>`", "id": "f34920:c0:m7"}
{"signature": "def get(<EOL>self, resource_group_name, network_security_group_name, security_rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_security_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", security_rule_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the specified network security rule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param security_rule_name: The name of the security rule.\n        :type security_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SecurityRule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2019_02_01.models.SecurityRule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34921:c0:m3"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ExpressRoutePortsLocationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ExpressRoutePortsLocationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves all ExpressRoutePort peering locations. Does not return\n        available bandwidths for each location. Available bandwidths can only\n        be obtained when retrieving a specific peering location.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ExpressRoutePortsLocation\n        :rtype:\n         ~azure.mgmt.network.v2019_02_01.models.ExpressRoutePortsLocationPaged[~azure.mgmt.network.v2019_02_01.models.ExpressRoutePortsLocation]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34922:c0:m1"}
{"signature": "def get(<EOL>self, location_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", location_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves a single ExpressRoutePort peering location, including the\n        list of available bandwidths available at said peering location.\n\n        :param location_name: Name of the requested ExpressRoutePort peering\n         location.\n        :type location_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRoutePortsLocation or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2019_02_01.models.ExpressRoutePortsLocation or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34922:c0:m2"}
{"signature": "def list(<EOL>self, resource_group_name, virtual_network_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SubnetPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SubnetPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all subnets in a virtual network.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Subnet\n        :rtype:\n         ~azure.mgmt.network.v2019_02_01.models.SubnetPaged[~azure.mgmt.network.v2019_02_01.models.Subnet]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34923:c0:m8"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, virtual_network_name, subnet_name, subnet_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_name=virtual_network_name,<EOL>subnet_name=subnet_name,<EOL>subnet_parameters=subnet_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a subnet in the specified virtual network.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param subnet_name: The name of the subnet.\n        :type subnet_name: str\n        :param subnet_parameters: Parameters supplied to the create or update\n         subnet operation.\n        :type subnet_parameters: ~azure.mgmt.network.v2019_02_01.models.Subnet\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Subnet or\n         ClientRawResponse<Subnet> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2019_02_01.models.Subnet]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2019_02_01.models.Subnet]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34923:c0:m5"}
{"signature": "def list(<EOL>self, location, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.AvailableDelegationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.AvailableDelegationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all of the available subnet delegations for this resource group in\n        this region.\n\n        :param location: The location of the domain name.\n        :type location: str\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of AvailableDelegation\n        :rtype:\n         ~azure.mgmt.network.v2019_02_01.models.AvailableDelegationPaged[~azure.mgmt.network.v2019_02_01.models.AvailableDelegation]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34924:c0:m1"}
{"signature": "def get_virtual_machine_scale_set_public_ip_address(<EOL>self, resource_group_name, virtual_machine_scale_set_name, virtualmachine_index, network_interface_name, ip_configuration_name, public_ip_address_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get_virtual_machine_scale_set_public_ip_address.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_machine_scale_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtualmachine_index, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_interface_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", ip_configuration_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", public_ip_address_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the specified public IP address in a virtual machine scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_machine_scale_set_name: The name of the virtual machine\n         scale set.\n        :type virtual_machine_scale_set_name: str\n        :param virtualmachine_index: The virtual machine index.\n        :type virtualmachine_index: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param ip_configuration_name: The name of the IP configuration.\n        :type ip_configuration_name: str\n        :param public_ip_address_name: The name of the public IP Address.\n        :type public_ip_address_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PublicIPAddress or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2019_02_01.models.PublicIPAddress or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34925:c0:m12"}
{"signature": "def update_tags(<EOL>self, resource_group_name, public_ip_address_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>public_ip_address_name=public_ip_address_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates public IP address tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param public_ip_address_name: The name of the public IP address.\n        :type public_ip_address_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns PublicIPAddress or\n         ClientRawResponse<PublicIPAddress> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2019_02_01.models.PublicIPAddress]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2019_02_01.models.PublicIPAddress]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34925:c0:m7"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PublicIPAddressPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PublicIPAddressPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all public IP addresses in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PublicIPAddress\n        :rtype:\n         ~azure.mgmt.network.v2019_02_01.models.PublicIPAddressPaged[~azure.mgmt.network.v2019_02_01.models.PublicIPAddress]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34925:c0:m9"}
{"signature": "def delete(<EOL>self, resource_group_name, cross_connection_name, peering_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>cross_connection_name=cross_connection_name,<EOL>peering_name=peering_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified peering from the ExpressRouteCrossConnection.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param cross_connection_name: The name of the\n         ExpressRouteCrossConnection.\n        :type cross_connection_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34926:c0:m3"}
{"signature": "def list(<EOL>self, resource_group_name, express_route_gateway_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", express_route_gateway_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists ExpressRouteConnections.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param express_route_gateway_name: The name of the ExpressRoute\n         gateway.\n        :type express_route_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteConnectionList or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2019_02_01.models.ExpressRouteConnectionList or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34929:c0:m6"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, express_route_gateway_name, connection_name, put_express_route_connection_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>express_route_gateway_name=express_route_gateway_name,<EOL>connection_name=connection_name,<EOL>put_express_route_connection_parameters=put_express_route_connection_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates a connection between an ExpressRoute gateway and an\n        ExpressRoute circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param express_route_gateway_name: The name of the ExpressRoute\n         gateway.\n        :type express_route_gateway_name: str\n        :param connection_name: The name of the connection subresource.\n        :type connection_name: str\n        :param put_express_route_connection_parameters: Parameters required in\n         an ExpressRouteConnection PUT operation.\n        :type put_express_route_connection_parameters:\n         ~azure.mgmt.network.v2019_02_01.models.ExpressRouteConnection\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ExpressRouteConnection\n         or ClientRawResponse<ExpressRouteConnection> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2019_02_01.models.ExpressRouteConnection]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2019_02_01.models.ExpressRouteConnection]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34929:c0:m2"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkWatcherPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkWatcherPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all network watchers by resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkWatcher\n        :rtype:\n         ~azure.mgmt.network.v2019_02_01.models.NetworkWatcherPaged[~azure.mgmt.network.v2019_02_01.models.NetworkWatcher]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2019_02_01.models.ErrorResponseException>`", "id": "f34931:c0:m6"}
{"signature": "def get_troubleshooting(<EOL>self, resource_group_name, network_watcher_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_troubleshooting_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT:location>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Initiate troubleshooting on a specified resource.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher resource.\n        :type network_watcher_name: str\n        :param parameters: Parameters that define the resource to\n         troubleshoot.\n        :type parameters:\n         ~azure.mgmt.network.v2019_02_01.models.TroubleshootingParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns TroubleshootingResult\n         or ClientRawResponse<TroubleshootingResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2019_02_01.models.TroubleshootingResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2019_02_01.models.TroubleshootingResult]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2019_02_01.models.ErrorResponseException>`", "id": "f34931:c0:m16"}
{"signature": "def get_troubleshooting_result(<EOL>self, resource_group_name, network_watcher_name, target_resource_id, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_troubleshooting_result_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>target_resource_id=target_resource_id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT:location>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Get the last completed troubleshooting result on a specified resource.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher resource.\n        :type network_watcher_name: str\n        :param target_resource_id: The target resource ID to query the\n         troubleshooting result.\n        :type target_resource_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns TroubleshootingResult\n         or ClientRawResponse<TroubleshootingResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2019_02_01.models.TroubleshootingResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2019_02_01.models.TroubleshootingResult]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2019_02_01.models.ErrorResponseException>`", "id": "f34931:c0:m18"}
{"signature": "def list_available_providers(<EOL>self, resource_group_name, network_watcher_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._list_available_providers_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT:location>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Lists all available internet service providers for a specified Azure\n        region.\n\n        :param resource_group_name: The name of the network watcher resource\n         group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher resource.\n        :type network_watcher_name: str\n        :param parameters: Parameters that scope the list of available\n         providers.\n        :type parameters:\n         ~azure.mgmt.network.v2019_02_01.models.AvailableProvidersListParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns AvailableProvidersList\n         or ClientRawResponse<AvailableProvidersList> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2019_02_01.models.AvailableProvidersList]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2019_02_01.models.AvailableProvidersList]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2019_02_01.models.ErrorResponseException>`", "id": "f34931:c0:m28"}
{"signature": "def get(<EOL>self, resource_group_name, network_watcher_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_watcher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified network watcher by resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: NetworkWatcher or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2019_02_01.models.NetworkWatcher or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2019_02_01.models.ErrorResponseException>`", "id": "f34931:c0:m2"}
{"signature": "def get_azure_reachability_report(<EOL>self, resource_group_name, network_watcher_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_azure_reachability_report_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT:location>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the relative latency score for internet service providers from a\n        specified location to Azure regions.\n\n        :param resource_group_name: The name of the network watcher resource\n         group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher resource.\n        :type network_watcher_name: str\n        :param parameters: Parameters that determine Azure reachability report\n         configuration.\n        :type parameters:\n         ~azure.mgmt.network.v2019_02_01.models.AzureReachabilityReportParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns AzureReachabilityReport\n         or ClientRawResponse<AzureReachabilityReport> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2019_02_01.models.AzureReachabilityReport]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2019_02_01.models.AzureReachabilityReport]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.network.v2019_02_01.models.ErrorResponseException>`", "id": "f34931:c0:m26"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VpnSitePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VpnSitePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all the vpnSites in a resource group.\n\n        :param resource_group_name: The resource group name of the VpnSite.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VpnSite\n        :rtype:\n         ~azure.mgmt.network.v2019_02_01.models.VpnSitePaged[~azure.mgmt.network.v2019_02_01.models.VpnSite]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2019_02_01.models.ErrorException>`", "id": "f34932:c0:m8"}
{"signature": "def delete(<EOL>self, resource_group_name, vpn_site_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>vpn_site_name=vpn_site_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes a VpnSite.\n\n        :param resource_group_name: The resource group name of the VpnSite.\n        :type resource_group_name: str\n        :param vpn_site_name: The name of the VpnSite being deleted.\n        :type vpn_site_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2019_02_01.models.ErrorException>`", "id": "f34932:c0:m7"}
{"signature": "def update(<EOL>self, resource_group_name, service_endpoint_policy_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_initial(<EOL>resource_group_name=resource_group_name,<EOL>service_endpoint_policy_name=service_endpoint_policy_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates service Endpoint Policies.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param service_endpoint_policy_name: The name of the service endpoint\n         policy.\n        :type service_endpoint_policy_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ServiceEndpointPolicy\n         or ClientRawResponse<ServiceEndpointPolicy> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2019_02_01.models.ServiceEndpointPolicy]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2019_02_01.models.ServiceEndpointPolicy]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34934:c0:m7"}
{"signature": "def delete(<EOL>self, resource_group_name, service_endpoint_policy_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>service_endpoint_policy_name=service_endpoint_policy_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified service endpoint policy.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param service_endpoint_policy_name: The name of the service endpoint\n         policy.\n        :type service_endpoint_policy_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34934:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, service_endpoint_policy_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", service_endpoint_policy_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified service Endpoint Policies in a specified resource\n        group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param service_endpoint_policy_name: The name of the service endpoint\n         policy.\n        :type service_endpoint_policy_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ServiceEndpointPolicy or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2019_02_01.models.ServiceEndpointPolicy\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34934:c0:m3"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ServiceEndpointPolicyPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ServiceEndpointPolicyPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all service endpoint Policies in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ServiceEndpointPolicy\n        :rtype:\n         ~azure.mgmt.network.v2019_02_01.models.ServiceEndpointPolicyPaged[~azure.mgmt.network.v2019_02_01.models.ServiceEndpointPolicy]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34934:c0:m9"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualWANPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualWANPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all the VirtualWANs in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualWAN\n        :rtype:\n         ~azure.mgmt.network.v2019_02_01.models.VirtualWANPaged[~azure.mgmt.network.v2019_02_01.models.VirtualWAN]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2019_02_01.models.ErrorException>`", "id": "f34935:c0:m9"}
{"signature": "def list(<EOL>self, resource_group_name, circuit_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ExpressRouteCircuitPeeringPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ExpressRouteCircuitPeeringPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all peerings in a specified express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ExpressRouteCircuitPeering\n        :rtype:\n         ~azure.mgmt.network.v2019_02_01.models.ExpressRouteCircuitPeeringPaged[~azure.mgmt.network.v2019_02_01.models.ExpressRouteCircuitPeering]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34936:c0:m6"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, virtual_wan_name, p2_svpn_server_configuration_name, p2_svpn_server_configuration_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_wan_name=virtual_wan_name,<EOL>p2_svpn_server_configuration_name=p2_svpn_server_configuration_name,<EOL>p2_svpn_server_configuration_parameters=p2_svpn_server_configuration_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates a P2SVpnServerConfiguration to associate with a VirtualWan if\n        it doesn't exist else updates the existing P2SVpnServerConfiguration.\n\n        :param resource_group_name: The resource group name of the VirtualWan.\n        :type resource_group_name: str\n        :param virtual_wan_name: The name of the VirtualWan.\n        :type virtual_wan_name: str\n        :param p2_svpn_server_configuration_name: The name of the\n         P2SVpnServerConfiguration.\n        :type p2_svpn_server_configuration_name: str\n        :param p2_svpn_server_configuration_parameters: Parameters supplied to\n         create or Update a P2SVpnServerConfiguration.\n        :type p2_svpn_server_configuration_parameters:\n         ~azure.mgmt.network.v2019_02_01.models.P2SVpnServerConfiguration\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         P2SVpnServerConfiguration or\n         ClientRawResponse<P2SVpnServerConfiguration> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2019_02_01.models.P2SVpnServerConfiguration]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2019_02_01.models.P2SVpnServerConfiguration]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2019_02_01.models.ErrorException>`", "id": "f34937:c0:m3"}
{"signature": "def list_by_virtual_wan(<EOL>self, resource_group_name, virtual_wan_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_virtual_wan.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_wan_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.P2SVpnServerConfigurationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.P2SVpnServerConfigurationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves all P2SVpnServerConfigurations for a particular VirtualWan.\n\n        :param resource_group_name: The resource group name of the VirtualWan.\n        :type resource_group_name: str\n        :param virtual_wan_name: The name of the VirtualWan.\n        :type virtual_wan_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of P2SVpnServerConfiguration\n        :rtype:\n         ~azure.mgmt.network.v2019_02_01.models.P2SVpnServerConfigurationPaged[~azure.mgmt.network.v2019_02_01.models.P2SVpnServerConfiguration]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2019_02_01.models.ErrorException>`", "id": "f34937:c0:m6"}
{"signature": "def list(<EOL>self, resource_group_name, virtual_hub_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_hub_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.HubVirtualNetworkConnectionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.HubVirtualNetworkConnectionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves the details of all HubVirtualNetworkConnections.\n\n        :param resource_group_name: The resource group name of the VirtualHub.\n        :type resource_group_name: str\n        :param virtual_hub_name: The name of the VirtualHub.\n        :type virtual_hub_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of HubVirtualNetworkConnection\n        :rtype:\n         ~azure.mgmt.network.v2019_02_01.models.HubVirtualNetworkConnectionPaged[~azure.mgmt.network.v2019_02_01.models.HubVirtualNetworkConnection]\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2019_02_01.models.ErrorException>`", "id": "f34940:c0:m2"}
{"signature": "def get_vpnclient_ipsec_parameters(<EOL>self, resource_group_name, virtual_network_gateway_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_vpnclient_ipsec_parameters_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_name=virtual_network_gateway_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT:location>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The Get VpnclientIpsecParameters operation retrieves information about\n        the vpnclient ipsec policy for P2S client of virtual network gateway in\n        the specified resource group through Network resource provider.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The virtual network gateway name.\n        :type virtual_network_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         VpnClientIPsecParameters or\n         ClientRawResponse<VpnClientIPsecParameters> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2019_02_01.models.VpnClientIPsecParameters]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2019_02_01.models.VpnClientIPsecParameters]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34942:c0:m28"}
{"signature": "def generatevpnclientpackage(<EOL>self, resource_group_name, virtual_network_gateway_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.generatevpnclientpackage.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_gateway_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT:str>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Generates VPN client package for P2S client of the virtual network\n        gateway in the specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param parameters: Parameters supplied to the generate virtual network\n         gateway VPN client package operation.\n        :type parameters:\n         ~azure.mgmt.network.v2019_02_01.models.VpnClientParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: str or ClientRawResponse if raw=true\n        :rtype: str or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34942:c0:m14"}
{"signature": "def reset_vpn_client_shared_key(<EOL>self, resource_group_name, virtual_network_gateway_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._reset_vpn_client_shared_key_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_network_gateway_name=virtual_network_gateway_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT:location>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Resets the VPN client shared key of the virtual network gateway in the\n        specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34942:c0:m13"}
{"signature": "def supported_vpn_devices(<EOL>self, resource_group_name, virtual_network_gateway_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.supported_vpn_devices.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_gateway_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT:str>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a xml format representation for supported vpn devices.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: str or ClientRawResponse if raw=true\n        :rtype: str or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34942:c0:m20"}
{"signature": "def delete(<EOL>self, resource_group_name, route_filter_name, rule_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_filter_name=route_filter_name,<EOL>rule_name=rule_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified rule from a route filter.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param rule_name: The name of the rule.\n        :type rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34944:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, route_filter_name, rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", route_filter_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", rule_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified rule from a route filter.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param rule_name: The name of the rule.\n        :type rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RouteFilterRule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2019_02_01.models.RouteFilterRule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34944:c0:m3"}
{"signature": "def list_by_route_filter(<EOL>self, resource_group_name, route_filter_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_route_filter.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", route_filter_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RouteFilterRulePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RouteFilterRulePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all RouteFilterRules in a route filter.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of RouteFilterRule\n        :rtype:\n         ~azure.mgmt.network.v2019_02_01.models.RouteFilterRulePaged[~azure.mgmt.network.v2019_02_01.models.RouteFilterRule]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34944:c0:m8"}
{"signature": "def update(<EOL>self, resource_group_name, route_filter_name, rule_name, route_filter_rule_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_filter_name=route_filter_name,<EOL>rule_name=rule_name,<EOL>route_filter_rule_parameters=route_filter_rule_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a route in the specified route filter.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param rule_name: The name of the route filter rule.\n        :type rule_name: str\n        :param route_filter_rule_parameters: Parameters supplied to the update\n         route filter rule operation.\n        :type route_filter_rule_parameters:\n         ~azure.mgmt.network.v2019_02_01.models.PatchRouteFilterRule\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns RouteFilterRule or\n         ClientRawResponse<RouteFilterRule> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2019_02_01.models.RouteFilterRule]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2019_02_01.models.RouteFilterRule]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34944:c0:m7"}
{"signature": "def get(<EOL>self, resource_group_name, gateway_name, connection_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", gateway_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", connection_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves the details of a vpn connection.\n\n        :param resource_group_name: The resource group name of the VpnGateway.\n        :type resource_group_name: str\n        :param gateway_name: The name of the gateway.\n        :type gateway_name: str\n        :param connection_name: The name of the vpn connection.\n        :type connection_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VpnConnection or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2019_02_01.models.VpnConnection or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorException<azure.mgmt.network.v2019_02_01.models.ErrorException>`", "id": "f34945:c0:m1"}
{"signature": "def list_virtual_machine_scale_set_vm_network_interfaces(<EOL>self, resource_group_name, virtual_machine_scale_set_name, virtualmachine_index, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_virtual_machine_scale_set_vm_network_interfaces.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_machine_scale_set_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtualmachine_index, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about all network interfaces in a virtual machine in a\n        virtual machine scale set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_machine_scale_set_name: The name of the virtual machine\n         scale set.\n        :type virtual_machine_scale_set_name: str\n        :param virtualmachine_index: The virtual machine index.\n        :type virtualmachine_index: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkInterface\n        :rtype:\n         ~azure.mgmt.network.v2019_02_01.models.NetworkInterfacePaged[~azure.mgmt.network.v2019_02_01.models.NetworkInterface]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34946:c0:m14"}
{"signature": "def list_effective_network_security_groups(<EOL>self, resource_group_name, network_interface_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._list_effective_network_security_groups_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_interface_name=network_interface_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT:location>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets all network security groups applied to a network interface.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         EffectiveNetworkSecurityGroupListResult or\n         ClientRawResponse<EffectiveNetworkSecurityGroupListResult> if\n         raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2019_02_01.models.EffectiveNetworkSecurityGroupListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2019_02_01.models.EffectiveNetworkSecurityGroupListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34946:c0:m13"}
{"signature": "def delete(<EOL>self, resource_group_name, network_interface_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_interface_name=network_interface_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified network interface.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34946:c0:m2"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, network_interface_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_interface_name=network_interface_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a network interface.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param parameters: Parameters supplied to the create or update network\n         interface operation.\n        :type parameters:\n         ~azure.mgmt.network.v2019_02_01.models.NetworkInterface\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns NetworkInterface or\n         ClientRawResponse<NetworkInterface> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2019_02_01.models.NetworkInterface]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2019_02_01.models.NetworkInterface]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34946:c0:m5"}
{"signature": "def get(<EOL>self, resource_group_name, network_security_group_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_security_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified network security group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: NetworkSecurityGroup or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2019_02_01.models.NetworkSecurityGroup or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34947:c0:m3"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkSecurityGroupPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkSecurityGroupPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all network security groups in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkSecurityGroup\n        :rtype:\n         ~azure.mgmt.network.v2019_02_01.models.NetworkSecurityGroupPaged[~azure.mgmt.network.v2019_02_01.models.NetworkSecurityGroup]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34947:c0:m8"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkSecurityGroupPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkSecurityGroupPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all network security groups in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkSecurityGroup\n        :rtype:\n         ~azure.mgmt.network.v2019_02_01.models.NetworkSecurityGroupPaged[~azure.mgmt.network.v2019_02_01.models.NetworkSecurityGroup]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34947:c0:m9"}
{"signature": "def delete(<EOL>self, resource_group_name, network_security_group_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_security_group_name=network_security_group_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified network security group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f34947:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, network_interface_name, ip_configuration_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_interface_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", ip_configuration_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified network interface ip configuration.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param ip_configuration_name: The name of the ip configuration name.\n        :type ip_configuration_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: NetworkInterfaceIPConfiguration or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_02_01.models.NetworkInterfaceIPConfiguration\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35252:c0:m2"}
{"signature": "def list_routes_table(<EOL>self, resource_group_name, cross_connection_name, peering_name, device_path, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._list_routes_table_initial(<EOL>resource_group_name=resource_group_name,<EOL>cross_connection_name=cross_connection_name,<EOL>peering_name=peering_name,<EOL>device_path=device_path,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the currently advertised routes table associated with the express\n        route cross connection in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param cross_connection_name: The name of the\n         ExpressRouteCrossConnection.\n        :type cross_connection_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param device_path: The path of the device.\n        :type device_path: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCircuitsRoutesTableListResult or\n         ClientRawResponse<ExpressRouteCircuitsRoutesTableListResult> if\n         raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_02_01.models.ExpressRouteCircuitsRoutesTableListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_02_01.models.ExpressRouteCircuitsRoutesTableListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35253:c0:m13"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.OperationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.OperationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all of the available Network Rest API operations.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Operation\n        :rtype:\n         ~azure.mgmt.network.v2018_02_01.models.OperationPaged[~azure.mgmt.network.v2018_02_01.models.Operation]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35254:c0:m1"}
{"signature": "def delete(<EOL>self, resource_group_name, network_watcher_name, packet_capture_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>packet_capture_name=packet_capture_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified packet capture session.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param packet_capture_name: The name of the packet capture session.\n        :type packet_capture_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35256:c0:m5"}
{"signature": "def stop(<EOL>self, resource_group_name, network_watcher_name, packet_capture_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._stop_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>packet_capture_name=packet_capture_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Stops a specified packet capture session.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param packet_capture_name: The name of the packet capture session.\n        :type packet_capture_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35256:c0:m7"}
{"signature": "def get(<EOL>self, resource_group_name, network_watcher_name, packet_capture_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_watcher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", packet_capture_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a packet capture session by name.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param packet_capture_name: The name of the packet capture session.\n        :type packet_capture_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PacketCaptureResult or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_02_01.models.PacketCaptureResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35256:c0:m3"}
{"signature": "def get_status(<EOL>self, resource_group_name, network_watcher_name, packet_capture_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_status_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>packet_capture_name=packet_capture_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'<STR_LIT>': '<STR_LIT:location>'}, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Query the status of a running packet capture session.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the Network Watcher resource.\n        :type network_watcher_name: str\n        :param packet_capture_name: The name given to the packet capture\n         session.\n        :type packet_capture_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         PacketCaptureQueryStatusResult or\n         ClientRawResponse<PacketCaptureQueryStatusResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_02_01.models.PacketCaptureQueryStatusResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_02_01.models.PacketCaptureQueryStatusResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35256:c0:m9"}
{"signature": "def list(<EOL>self, resource_group_name, network_watcher_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_watcher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PacketCaptureResultPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PacketCaptureResultPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all packet capture sessions within the specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the Network Watcher resource.\n        :type network_watcher_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PacketCaptureResult\n        :rtype:\n         ~azure.mgmt.network.v2018_02_01.models.PacketCaptureResultPaged[~azure.mgmt.network.v2018_02_01.models.PacketCaptureResult]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35256:c0:m10"}
{"signature": "def get_shared_key(<EOL>self, resource_group_name, virtual_network_gateway_connection_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_shared_key.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_gateway_connection_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "The Get VirtualNetworkGatewayConnectionSharedKey operation retrieves\n        information about the specified virtual network gateway connection\n        shared key through Network resource provider.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_connection_name: The virtual network\n         gateway connection shared key name.\n        :type virtual_network_gateway_connection_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ConnectionSharedKey or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_02_01.models.ConnectionSharedKey or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35257:c0:m10"}
{"signature": "def get(<EOL>self, resource_group_name, virtual_network_gateway_connection_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_gateway_connection_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified virtual network gateway connection by resource\n        group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_connection_name: The name of the\n         virtual network gateway connection.\n        :type virtual_network_gateway_connection_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualNetworkGatewayConnection or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_02_01.models.VirtualNetworkGatewayConnection\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35257:c0:m3"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualNetworkGatewayConnectionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualNetworkGatewayConnectionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "The List VirtualNetworkGatewayConnections operation retrieves all the\n        virtual network gateways connections created.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualNetworkGatewayConnection\n        :rtype:\n         ~azure.mgmt.network.v2018_02_01.models.VirtualNetworkGatewayConnectionPaged[~azure.mgmt.network.v2018_02_01.models.VirtualNetworkGatewayConnection]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35257:c0:m11"}
{"signature": "def delete(<EOL>self, resource_group_name, ddos_protection_plan_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>ddos_protection_plan_name=ddos_protection_plan_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified DDoS protection plan.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param ddos_protection_plan_name: The name of the DDoS protection\n         plan.\n        :type ddos_protection_plan_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35259:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, application_gateway_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>application_gateway_name=application_gateway_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified application gateway.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param application_gateway_name: The name of the application gateway.\n        :type application_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35260:c0:m2"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, application_gateway_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>application_gateway_name=application_gateway_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates the specified application gateway.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param application_gateway_name: The name of the application gateway.\n        :type application_gateway_name: str\n        :param parameters: Parameters supplied to the create or update\n         application gateway operation.\n        :type parameters:\n         ~azure.mgmt.network.v2018_02_01.models.ApplicationGateway\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ApplicationGateway or\n         ClientRawResponse<ApplicationGateway> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_02_01.models.ApplicationGateway]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_02_01.models.ApplicationGateway]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35260:c0:m5"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ApplicationGatewayPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ApplicationGatewayPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the application gateways in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ApplicationGateway\n        :rtype:\n         ~azure.mgmt.network.v2018_02_01.models.ApplicationGatewayPaged[~azure.mgmt.network.v2018_02_01.models.ApplicationGateway]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35260:c0:m9"}
{"signature": "def update_tags(<EOL>self, resource_group_name, application_gateway_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>application_gateway_name=application_gateway_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates the specified application gateway tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param application_gateway_name: The name of the application gateway.\n        :type application_gateway_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ApplicationGateway or\n         ClientRawResponse<ApplicationGateway> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_02_01.models.ApplicationGateway]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_02_01.models.ApplicationGateway]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35260:c0:m7"}
{"signature": "def list_available_ssl_predefined_policies(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_available_ssl_predefined_policies.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ApplicationGatewaySslPredefinedPolicyPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ApplicationGatewaySslPredefinedPolicyPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all SSL predefined policies for configuring Ssl policy.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of\n         ApplicationGatewaySslPredefinedPolicy\n        :rtype:\n         ~azure.mgmt.network.v2018_02_01.models.ApplicationGatewaySslPredefinedPolicyPaged[~azure.mgmt.network.v2018_02_01.models.ApplicationGatewaySslPredefinedPolicy]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35260:c0:m18"}
{"signature": "def stop(<EOL>self, resource_group_name, application_gateway_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._stop_initial(<EOL>resource_group_name=resource_group_name,<EOL>application_gateway_name=application_gateway_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Stops the specified application gateway in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param application_gateway_name: The name of the application gateway.\n        :type application_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35260:c0:m13"}
{"signature": "def get(<EOL>self, resource_group_name, route_filter_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", route_filter_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified route filter.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param expand: Expands referenced express route bgp peering resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RouteFilter or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_02_01.models.RouteFilter or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35261:c0:m3"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, route_filter_name, route_filter_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_filter_name=route_filter_name,<EOL>route_filter_parameters=route_filter_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a route filter in a specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param route_filter_parameters: Parameters supplied to the create or\n         update route filter operation.\n        :type route_filter_parameters:\n         ~azure.mgmt.network.v2018_02_01.models.RouteFilter\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns RouteFilter or\n         ClientRawResponse<RouteFilter> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_02_01.models.RouteFilter]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_02_01.models.RouteFilter]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35261:c0:m5"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, network_watcher_name, connection_monitor_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>connection_monitor_name=connection_monitor_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Create or update a connection monitor.\n\n        :param resource_group_name: The name of the resource group containing\n         Network Watcher.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the Network Watcher resource.\n        :type network_watcher_name: str\n        :param connection_monitor_name: The name of the connection monitor.\n        :type connection_monitor_name: str\n        :param parameters: Parameters that define the operation to create a\n         connection monitor.\n        :type parameters:\n         ~azure.mgmt.network.v2018_02_01.models.ConnectionMonitor\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ConnectionMonitorResult\n         or ClientRawResponse<ConnectionMonitorResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_02_01.models.ConnectionMonitorResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_02_01.models.ConnectionMonitorResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35262:c0:m2"}
{"signature": "def query(<EOL>self, resource_group_name, network_watcher_name, connection_monitor_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._query_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>connection_monitor_name=connection_monitor_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Query a snapshot of the most recent connection states.\n\n        :param resource_group_name: The name of the resource group containing\n         Network Watcher.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the Network Watcher resource.\n        :type network_watcher_name: str\n        :param connection_monitor_name: The name given to the connection\n         monitor.\n        :type connection_monitor_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ConnectionMonitorQueryResult or\n         ClientRawResponse<ConnectionMonitorQueryResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_02_01.models.ConnectionMonitorQueryResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_02_01.models.ConnectionMonitorQueryResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35262:c0:m11"}
{"signature": "def list(<EOL>self, resource_group_name, network_watcher_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_watcher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ConnectionMonitorResultPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ConnectionMonitorResultPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all connection monitors for the specified Network Watcher.\n\n        :param resource_group_name: The name of the resource group containing\n         Network Watcher.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the Network Watcher resource.\n        :type network_watcher_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ConnectionMonitorResult\n        :rtype:\n         ~azure.mgmt.network.v2018_02_01.models.ConnectionMonitorResultPaged[~azure.mgmt.network.v2018_02_01.models.ConnectionMonitorResult]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35262:c0:m12"}
{"signature": "def list(<EOL>self, resource_group_name, network_security_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_security_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SecurityRulePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SecurityRulePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all default security rules in a network security group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of SecurityRule\n        :rtype:\n         ~azure.mgmt.network.v2018_02_01.models.SecurityRulePaged[~azure.mgmt.network.v2018_02_01.models.SecurityRule]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35264:c0:m1"}
{"signature": "def get(<EOL>self, resource_group_name, network_security_group_name, default_security_rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_security_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", default_security_rule_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the specified default network security rule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param default_security_rule_name: The name of the default security\n         rule.\n        :type default_security_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SecurityRule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_02_01.models.SecurityRule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35264:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, route_table_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_table_name=route_table_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified route table.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35265:c0:m2"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RouteTablePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RouteTablePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all route tables in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of RouteTable\n        :rtype:\n         ~azure.mgmt.network.v2018_02_01.models.RouteTablePaged[~azure.mgmt.network.v2018_02_01.models.RouteTable]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35265:c0:m8"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, route_table_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_table_name=route_table_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Create or updates a route table in a specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param parameters: Parameters supplied to the create or update route\n         table operation.\n        :type parameters: ~azure.mgmt.network.v2018_02_01.models.RouteTable\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns RouteTable or\n         ClientRawResponse<RouteTable> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_02_01.models.RouteTable]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_02_01.models.RouteTable]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35265:c0:m5"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, circuit_name, peering_name, connection_name, express_route_circuit_connection_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>peering_name=peering_name,<EOL>connection_name=connection_name,<EOL>express_route_circuit_connection_parameters=express_route_circuit_connection_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a Express Route Circuit Connection in the specified\n        express route circuits.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param connection_name: The name of the express route circuit\n         connection.\n        :type connection_name: str\n        :param express_route_circuit_connection_parameters: Parameters\n         supplied to the create or update express route circuit connection\n         operation.\n        :type express_route_circuit_connection_parameters:\n         ~azure.mgmt.network.v2018_02_01.models.ExpressRouteCircuitConnection\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCircuitConnection or\n         ClientRawResponse<ExpressRouteCircuitConnection> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_02_01.models.ExpressRouteCircuitConnection]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_02_01.models.ExpressRouteCircuitConnection]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35267:c0:m5"}
{"signature": "def get(<EOL>self, resource_group_name, virtual_network_name, virtual_network_peering_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_peering_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified virtual network peering.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param virtual_network_peering_name: The name of the virtual network\n         peering.\n        :type virtual_network_peering_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualNetworkPeering or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_02_01.models.VirtualNetworkPeering\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35268:c0:m3"}
{"signature": "def get(<EOL>self, resource_group_name, virtual_network_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified virtual network by resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualNetwork or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_02_01.models.VirtualNetwork or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35269:c0:m3"}
{"signature": "def delete(<EOL>self, resource_group_name, load_balancer_name, inbound_nat_rule_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>load_balancer_name=load_balancer_name,<EOL>inbound_nat_rule_name=inbound_nat_rule_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified load balancer inbound nat rule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param inbound_nat_rule_name: The name of the inbound nat rule.\n        :type inbound_nat_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35270:c0:m3"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, load_balancer_name, inbound_nat_rule_name, inbound_nat_rule_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>load_balancer_name=load_balancer_name,<EOL>inbound_nat_rule_name=inbound_nat_rule_name,<EOL>inbound_nat_rule_parameters=inbound_nat_rule_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a load balancer inbound nat rule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param inbound_nat_rule_name: The name of the inbound nat rule.\n        :type inbound_nat_rule_name: str\n        :param inbound_nat_rule_parameters: Parameters supplied to the create\n         or update inbound nat rule operation.\n        :type inbound_nat_rule_parameters:\n         ~azure.mgmt.network.v2018_02_01.models.InboundNatRule\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns InboundNatRule or\n         ClientRawResponse<InboundNatRule> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_02_01.models.InboundNatRule]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_02_01.models.InboundNatRule]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35270:c0:m6"}
{"signature": "def get(<EOL>self, resource_group_name, circuit_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about the specified express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of express route circuit.\n        :type circuit_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteCircuit or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_02_01.models.ExpressRouteCircuit or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35271:c0:m3"}
{"signature": "def list_routes_table(<EOL>self, resource_group_name, circuit_name, peering_name, device_path, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._list_routes_table_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>peering_name=peering_name,<EOL>device_path=device_path,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the currently advertised routes table associated with the express\n        route circuit in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param device_path: The path of the device.\n        :type device_path: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExpressRouteCircuitsRoutesTableListResult or\n         ClientRawResponse<ExpressRouteCircuitsRoutesTableListResult> if\n         raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_02_01.models.ExpressRouteCircuitsRoutesTableListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_02_01.models.ExpressRouteCircuitsRoutesTableListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35271:c0:m11"}
{"signature": "def get_peering_stats(<EOL>self, resource_group_name, circuit_name, peering_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_peering_stats.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", peering_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all stats from an express route circuit in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteCircuitStats or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_02_01.models.ExpressRouteCircuitStats or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35271:c0:m15"}
{"signature": "def delete(<EOL>self, resource_group_name, application_security_group_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>application_security_group_name=application_security_group_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified application security group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param application_security_group_name: The name of the application\n         security group.\n        :type application_security_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35272:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, application_security_group_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", application_security_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about the specified application security group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param application_security_group_name: The name of the application\n         security group.\n        :type application_security_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ApplicationSecurityGroup or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_02_01.models.ApplicationSecurityGroup or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35272:c0:m3"}
{"signature": "def delete(<EOL>self, resource_group_name, circuit_name, authorization_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>authorization_name=authorization_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified authorization from the specified express route\n        circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param authorization_name: The name of the authorization.\n        :type authorization_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35273:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, circuit_name, authorization_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", circuit_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", authorization_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified authorization from the specified express route\n        circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param authorization_name: The name of the authorization.\n        :type authorization_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExpressRouteCircuitAuthorization or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.network.v2018_02_01.models.ExpressRouteCircuitAuthorization\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35273:c0:m3"}
{"signature": "def list(<EOL>self, resource_group_name, network_security_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_security_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SecurityRulePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SecurityRulePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all security rules in a network security group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of SecurityRule\n        :rtype:\n         ~azure.mgmt.network.v2018_02_01.models.SecurityRulePaged[~azure.mgmt.network.v2018_02_01.models.SecurityRule]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35275:c0:m6"}
{"signature": "def update_tags(<EOL>self, resource_group_name, public_ip_address_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>public_ip_address_name=public_ip_address_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates public IP address tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param public_ip_address_name: The name of the public IP address.\n        :type public_ip_address_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns PublicIPAddress or\n         ClientRawResponse<PublicIPAddress> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_02_01.models.PublicIPAddress]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_02_01.models.PublicIPAddress]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35277:c0:m7"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, public_ip_address_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>public_ip_address_name=public_ip_address_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a static or dynamic public IP address.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param public_ip_address_name: The name of the public IP address.\n        :type public_ip_address_name: str\n        :param parameters: Parameters supplied to the create or update public\n         IP address operation.\n        :type parameters:\n         ~azure.mgmt.network.v2018_02_01.models.PublicIPAddress\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns PublicIPAddress or\n         ClientRawResponse<PublicIPAddress> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_02_01.models.PublicIPAddress]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_02_01.models.PublicIPAddress]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35277:c0:m5"}
{"signature": "def verify_ip_flow(<EOL>self, resource_group_name, network_watcher_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._verify_ip_flow_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Verify IP flow from the specified VM to a location given the currently\n        configured NSG rules.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param parameters: Parameters that define the IP flow to be verified.\n        :type parameters:\n         ~azure.mgmt.network.v2018_02_01.models.VerificationIPFlowParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         VerificationIPFlowResult or\n         ClientRawResponse<VerificationIPFlowResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_02_01.models.VerificationIPFlowResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_02_01.models.VerificationIPFlowResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35282:c0:m10"}
{"signature": "def get_vm_security_rules(<EOL>self, resource_group_name, network_watcher_name, target_resource_id, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._get_vm_security_rules_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>target_resource_id=target_resource_id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets the configured and effective security group rules on the specified\n        VM.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param target_resource_id: ID of the target VM.\n        :type target_resource_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns SecurityGroupViewResult\n         or ClientRawResponse<SecurityGroupViewResult> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_02_01.models.SecurityGroupViewResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_02_01.models.SecurityGroupViewResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35282:c0:m14"}
{"signature": "def set_flow_log_configuration(<EOL>self, resource_group_name, network_watcher_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._set_flow_log_configuration_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Configures flow log on a specified resource.\n\n        :param resource_group_name: The name of the network watcher resource\n         group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher resource.\n        :type network_watcher_name: str\n        :param parameters: Parameters that define the configuration of flow\n         log.\n        :type parameters:\n         ~azure.mgmt.network.v2018_02_01.models.FlowLogInformation\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns FlowLogInformation or\n         ClientRawResponse<FlowLogInformation> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_02_01.models.FlowLogInformation]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_02_01.models.FlowLogInformation]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35282:c0:m20"}
{"signature": "def list_available_providers(<EOL>self, resource_group_name, network_watcher_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._list_available_providers_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_watcher_name=network_watcher_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Lists all available internet service providers for a specified Azure\n        region.\n\n        :param resource_group_name: The name of the network watcher resource\n         group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher resource.\n        :type network_watcher_name: str\n        :param parameters: Parameters that scope the list of available\n         providers.\n        :type parameters:\n         ~azure.mgmt.network.v2018_02_01.models.AvailableProvidersListParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns AvailableProvidersList\n         or ClientRawResponse<AvailableProvidersList> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_02_01.models.AvailableProvidersList]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_02_01.models.AvailableProvidersList]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35282:c0:m28"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, network_watcher_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_watcher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or updates a network watcher in the specified resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_watcher_name: The name of the network watcher.\n        :type network_watcher_name: str\n        :param parameters: Parameters that define the network watcher\n         resource.\n        :type parameters:\n         ~azure.mgmt.network.v2018_02_01.models.NetworkWatcher\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: NetworkWatcher or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_02_01.models.NetworkWatcher or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35282:c0:m1"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkWatcherPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkWatcherPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all network watchers by resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkWatcher\n        :rtype:\n         ~azure.mgmt.network.v2018_02_01.models.NetworkWatcherPaged[~azure.mgmt.network.v2018_02_01.models.NetworkWatcher]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35282:c0:m6"}
{"signature": "def delete(<EOL>self, resource_group_name, circuit_name, peering_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>circuit_name=circuit_name,<EOL>peering_name=peering_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified peering from the specified express route circuit.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param circuit_name: The name of the express route circuit.\n        :type circuit_name: str\n        :param peering_name: The name of the peering.\n        :type peering_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35284:c0:m2"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, route_table_name, route_name, route_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>route_table_name=route_table_name,<EOL>route_name=route_name,<EOL>route_parameters=route_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a route in the specified route table.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_table_name: The name of the route table.\n        :type route_table_name: str\n        :param route_name: The name of the route.\n        :type route_name: str\n        :param route_parameters: Parameters supplied to the create or update\n         route operation.\n        :type route_parameters: ~azure.mgmt.network.v2018_02_01.models.Route\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Route or\n         ClientRawResponse<Route> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_02_01.models.Route]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_02_01.models.Route]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35286:c0:m5"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualNetworkGatewayPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualNetworkGatewayPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all virtual network gateways by resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualNetworkGateway\n        :rtype:\n         ~azure.mgmt.network.v2018_02_01.models.VirtualNetworkGatewayPaged[~azure.mgmt.network.v2018_02_01.models.VirtualNetworkGateway]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35287:c0:m8"}
{"signature": "def get(<EOL>self, resource_group_name, virtual_network_gateway_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_gateway_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified virtual network gateway by resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_gateway_name: The name of the virtual network\n         gateway.\n        :type virtual_network_gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VirtualNetworkGateway or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_02_01.models.VirtualNetworkGateway\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35287:c0:m3"}
{"signature": "def list(<EOL>self, resource_group_name, load_balancer_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.LoadBalancingRulePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.LoadBalancingRulePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the load balancing rules in a load balancer.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of LoadBalancingRule\n        :rtype:\n         ~azure.mgmt.network.v2018_02_01.models.LoadBalancingRulePaged[~azure.mgmt.network.v2018_02_01.models.LoadBalancingRule]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35288:c0:m1"}
{"signature": "def get(<EOL>self, resource_group_name, load_balancer_name, load_balancing_rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", load_balancing_rule_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified load balancer load balancing rule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param load_balancer_name: The name of the load balancer.\n        :type load_balancer_name: str\n        :param load_balancing_rule_name: The name of the load balancing rule.\n        :type load_balancing_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: LoadBalancingRule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_02_01.models.LoadBalancingRule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35288:c0:m2"}
{"signature": "def list_by_route_filter(<EOL>self, resource_group_name, route_filter_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_route_filter.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", route_filter_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RouteFilterRulePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RouteFilterRulePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all RouteFilterRules in a route filter.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param route_filter_name: The name of the route filter.\n        :type route_filter_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of RouteFilterRule\n        :rtype:\n         ~azure.mgmt.network.v2018_02_01.models.RouteFilterRulePaged[~azure.mgmt.network.v2018_02_01.models.RouteFilterRule]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35289:c0:m8"}
{"signature": "def get(<EOL>self, resource_group_name, network_interface_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_interface_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about the specified network interface.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: NetworkInterface or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_02_01.models.NetworkInterface or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35290:c0:m3"}
{"signature": "def list(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NetworkInterfacePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all network interfaces in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NetworkInterface\n        :rtype:\n         ~azure.mgmt.network.v2018_02_01.models.NetworkInterfacePaged[~azure.mgmt.network.v2018_02_01.models.NetworkInterface]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35290:c0:m9"}
{"signature": "def list_effective_network_security_groups(<EOL>self, resource_group_name, network_interface_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._list_effective_network_security_groups_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_interface_name=network_interface_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Gets all network security groups applied to a network interface.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_interface_name: The name of the network interface.\n        :type network_interface_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         EffectiveNetworkSecurityGroupListResult or\n         ClientRawResponse<EffectiveNetworkSecurityGroupListResult> if\n         raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_02_01.models.EffectiveNetworkSecurityGroupListResult]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_02_01.models.EffectiveNetworkSecurityGroupListResult]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35290:c0:m13"}
{"signature": "def get(<EOL>self, resource_group_name, network_security_group_name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", network_security_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified network security group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param expand: Expands referenced resources.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: NetworkSecurityGroup or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.network.v2018_02_01.models.NetworkSecurityGroup or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35291:c0:m3"}
{"signature": "def update_tags(<EOL>self, resource_group_name, network_security_group_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>network_security_group_name=network_security_group_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a network security group tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param network_security_group_name: The name of the network security\n         group.\n        :type network_security_group_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns NetworkSecurityGroup or\n         ClientRawResponse<NetworkSecurityGroup> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.network.v2018_02_01.models.NetworkSecurityGroup]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.network.v2018_02_01.models.NetworkSecurityGroup]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35291:c0:m7"}
{"signature": "def list(<EOL>self, cache_control=\"<STR_LIT>\", skiptoken=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if skiptoken is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", skiptoken, '<STR_LIT:str>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if cache_control is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", cache_control, '<STR_LIT:str>')<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ManagementGroupInfoPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ManagementGroupInfoPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List management groups for the authenticated user.\n\n        :param cache_control: Indicates that the request shouldn't utilize any\n         caches.\n        :type cache_control: str\n        :param skiptoken: Page continuation token is only used if a previous\n         operation returned a partial result. If a previous response contains a\n         nextLink element, the value of the nextLink element will include a\n         token parameter that specifies a starting point to use for subsequent\n         calls.\n        :type skiptoken: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ManagementGroupInfo\n        :rtype:\n         ~azure.mgmt.managementgroups.models.ManagementGroupInfoPaged[~azure.mgmt.managementgroups.models.ManagementGroupInfo]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.managementgroups.models.ErrorResponseException>`", "id": "f35344:c0:m1"}
{"signature": "def delete(<EOL>self, group_id, cache_control=\"<STR_LIT>\", custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>group_id=group_id,<EOL>cache_control=cache_control,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Delete management group. If a management group contains child\n        resources, the request will fail.\n\n        :param group_id: Management Group ID.\n        :type group_id: str\n        :param cache_control: Indicates that the request shouldn't utilize any\n         caches.\n        :type cache_control: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns OperationResults or\n         ClientRawResponse<OperationResults> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.managementgroups.models.OperationResults]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.managementgroups.models.OperationResults]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.managementgroups.models.ErrorResponseException>`", "id": "f35344:c0:m7"}
{"signature": "def delete(<EOL>self, group_id, subscription_id, cache_control=\"<STR_LIT>\", custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", group_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if cache_control is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", cache_control, '<STR_LIT:str>')<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "De-associates subscription from the management group.\n\n        :param group_id: Management Group ID.\n        :type group_id: str\n        :param subscription_id: Subscription ID.\n        :type subscription_id: str\n        :param cache_control: Indicates that the request shouldn't utilize any\n         caches.\n        :type cache_control: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.managementgroups.models.ErrorResponseException>`", "id": "f35345:c0:m2"}
{"signature": "def list_by_server(<EOL>self, resource_group_name, server_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_server.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.DatabasePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.DatabasePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List all the databases in a given server.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Database\n        :rtype:\n         ~azure.mgmt.rdbms.postgresql.models.DatabasePaged[~azure.mgmt.rdbms.postgresql.models.Database]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35410:c0:m6"}
{"signature": "def delete(<EOL>self, resource_group_name, server_name, database_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>server_name=server_name,<EOL>database_name=database_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes a database.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param database_name: The name of the database.\n        :type database_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35410:c0:m4"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, server_name, firewall_rule_name, start_ip_address, end_ip_address, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>server_name=server_name,<EOL>firewall_rule_name=firewall_rule_name,<EOL>start_ip_address=start_ip_address,<EOL>end_ip_address=end_ip_address,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates a new firewall rule or updates an existing firewall rule.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param firewall_rule_name: The name of the server firewall rule.\n        :type firewall_rule_name: str\n        :param start_ip_address: The start IP address of the server firewall\n         rule. Must be IPv4 format.\n        :type start_ip_address: str\n        :param end_ip_address: The end IP address of the server firewall rule.\n         Must be IPv4 format.\n        :type end_ip_address: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns FirewallRule or\n         ClientRawResponse<FirewallRule> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.rdbms.postgresql.models.FirewallRule]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.rdbms.postgresql.models.FirewallRule]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35411:c0:m2"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ServerPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ServerPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List all the servers in a given resource group.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Server\n        :rtype:\n         ~azure.mgmt.rdbms.postgresql.models.ServerPaged[~azure.mgmt.rdbms.postgresql.models.Server]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35414:c0:m8"}
{"signature": "def get(<EOL>self, resource_group_name, server_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about a server.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Server or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.rdbms.postgresql.models.Server or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35414:c0:m7"}
{"signature": "def update(<EOL>self, resource_group_name, server_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_initial(<EOL>resource_group_name=resource_group_name,<EOL>server_name=server_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates an existing server. The request body can contain one to many of\n        the properties present in the normal server definition.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param parameters: The required parameters for updating a server.\n        :type parameters:\n         ~azure.mgmt.rdbms.postgresql.models.ServerUpdateParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Server or\n         ClientRawResponse<Server> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.rdbms.postgresql.models.Server]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.rdbms.postgresql.models.Server]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35414:c0:m4"}
{"signature": "def delete(<EOL>self, resource_group_name, server_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>server_name=server_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes a server.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35414:c0:m6"}
{"signature": "def get(<EOL>self, resource_group_name, server_name, configuration_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", configuration_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about a configuration of server.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param configuration_name: The name of the server configuration.\n        :type configuration_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Configuration or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.rdbms.postgresql.models.Configuration or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35420:c0:m3"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, server_name, firewall_rule_name, start_ip_address, end_ip_address, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>server_name=server_name,<EOL>firewall_rule_name=firewall_rule_name,<EOL>start_ip_address=start_ip_address,<EOL>end_ip_address=end_ip_address,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates a new firewall rule or updates an existing firewall rule.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param firewall_rule_name: The name of the server firewall rule.\n        :type firewall_rule_name: str\n        :param start_ip_address: The start IP address of the server firewall\n         rule. Must be IPv4 format.\n        :type start_ip_address: str\n        :param end_ip_address: The end IP address of the server firewall rule.\n         Must be IPv4 format.\n        :type end_ip_address: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns FirewallRule or\n         ClientRawResponse<FirewallRule> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.rdbms.mariadb.models.FirewallRule]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.rdbms.mariadb.models.FirewallRule]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35466:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, server_name, firewall_rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", firewall_rule_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about a server firewall rule.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param firewall_rule_name: The name of the server firewall rule.\n        :type firewall_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: FirewallRule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.rdbms.mariadb.models.FirewallRule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35466:c0:m5"}
{"signature": "def delete(<EOL>self, resource_group_name, server_name, virtual_network_rule_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>server_name=server_name,<EOL>virtual_network_rule_name=virtual_network_rule_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the virtual network rule with the given name.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param virtual_network_rule_name: The name of the virtual network\n         rule.\n        :type virtual_network_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35467:c0:m5"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ServerPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ServerPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List all the servers in a given subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Server\n        :rtype:\n         ~azure.mgmt.rdbms.mariadb.models.ServerPaged[~azure.mgmt.rdbms.mariadb.models.Server]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35469:c0:m9"}
{"signature": "def list_by_server(<EOL>self, resource_group_name, server_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_server.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.LogFilePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.LogFilePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List all the log files in a given server.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of LogFile\n        :rtype:\n         ~azure.mgmt.rdbms.mariadb.models.LogFilePaged[~azure.mgmt.rdbms.mariadb.models.LogFile]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35471:c0:m1"}
{"signature": "def list_by_server(<EOL>self, resource_group_name, server_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_server.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ServerPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ServerPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List all the replicas for a given server.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Server\n        :rtype:\n         ~azure.mgmt.rdbms.mariadb.models.ServerPaged[~azure.mgmt.rdbms.mariadb.models.Server]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35472:c0:m1"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, server_name, database_name, charset=None, collation=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>server_name=server_name,<EOL>database_name=database_name,<EOL>charset=charset,<EOL>collation=collation,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates a new database or updates an existing database.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param database_name: The name of the database.\n        :type database_name: str\n        :param charset: The charset of the database.\n        :type charset: str\n        :param collation: The collation of the database.\n        :type collation: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Database or\n         ClientRawResponse<Database> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.rdbms.mysql.models.Database]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.rdbms.mysql.models.Database]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35517:c0:m2"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, server_name, firewall_rule_name, start_ip_address, end_ip_address, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>server_name=server_name,<EOL>firewall_rule_name=firewall_rule_name,<EOL>start_ip_address=start_ip_address,<EOL>end_ip_address=end_ip_address,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates a new firewall rule or updates an existing firewall rule.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param firewall_rule_name: The name of the server firewall rule.\n        :type firewall_rule_name: str\n        :param start_ip_address: The start IP address of the server firewall\n         rule. Must be IPv4 format.\n        :type start_ip_address: str\n        :param end_ip_address: The end IP address of the server firewall rule.\n         Must be IPv4 format.\n        :type end_ip_address: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns FirewallRule or\n         ClientRawResponse<FirewallRule> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.rdbms.mysql.models.FirewallRule]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.rdbms.mysql.models.FirewallRule]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35518:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, server_name, firewall_rule_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>server_name=server_name,<EOL>firewall_rule_name=firewall_rule_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes a server firewall rule.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param firewall_rule_name: The name of the server firewall rule.\n        :type firewall_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35518:c0:m4"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, server_name, virtual_network_rule_name, virtual_network_subnet_id, ignore_missing_vnet_service_endpoint=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>server_name=server_name,<EOL>virtual_network_rule_name=virtual_network_rule_name,<EOL>virtual_network_subnet_id=virtual_network_subnet_id,<EOL>ignore_missing_vnet_service_endpoint=ignore_missing_vnet_service_endpoint,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates an existing virtual network rule.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param virtual_network_rule_name: The name of the virtual network\n         rule.\n        :type virtual_network_rule_name: str\n        :param virtual_network_subnet_id: The ARM resource id of the virtual\n         network subnet.\n        :type virtual_network_subnet_id: str\n        :param ignore_missing_vnet_service_endpoint: Create firewall rule\n         before the virtual network has vnet service endpoint enabled.\n        :type ignore_missing_vnet_service_endpoint: bool\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualNetworkRule or\n         ClientRawResponse<VirtualNetworkRule> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.rdbms.mysql.models.VirtualNetworkRule]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.rdbms.mysql.models.VirtualNetworkRule]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35519:c0:m3"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all of the available REST API operations.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: OperationListResult or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.rdbms.mysql.models.OperationListResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35520:c0:m1"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ServerPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ServerPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List all the servers in a given subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Server\n        :rtype:\n         ~azure.mgmt.rdbms.mysql.models.ServerPaged[~azure.mgmt.rdbms.mysql.models.Server]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35521:c0:m9"}
{"signature": "def restart(<EOL>self, resource_group_name, server_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._restart_initial(<EOL>resource_group_name=resource_group_name,<EOL>server_name=server_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Restarts a server.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35521:c0:m11"}
{"signature": "def update(<EOL>self, resource_group_name, server_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_initial(<EOL>resource_group_name=resource_group_name,<EOL>server_name=server_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates an existing server. The request body can contain one to many of\n        the properties present in the normal server definition.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param parameters: The required parameters for updating a server.\n        :type parameters:\n         ~azure.mgmt.rdbms.mysql.models.ServerUpdateParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Server or\n         ClientRawResponse<Server> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.rdbms.mysql.models.Server]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.rdbms.mysql.models.Server]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35521:c0:m4"}
{"signature": "def delete(<EOL>self, resource_group_name, server_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>server_name=server_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes a server.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35521:c0:m6"}
{"signature": "def list_by_server(<EOL>self, resource_group_name, server_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_server.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ServerPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ServerPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List all the replicas for a given server.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Server\n        :rtype:\n         ~azure.mgmt.rdbms.mysql.models.ServerPaged[~azure.mgmt.rdbms.mysql.models.Server]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35524:c0:m1"}
{"signature": "def search(<EOL>self, query, accept_language=None, pragma=None, user_agent=None, client_id=None, client_ip=None, location=None, answer_count=None, country_code=None, count=None, freshness=None, market=\"<STR_LIT>\", offset=None, promote=None, response_filter=None, safe_search=None, set_lang=None, text_decorations=None, text_format=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.search.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>if answer_count is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", answer_count, '<STR_LIT:int>')<EOL><DEDENT>if country_code is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", country_code, '<STR_LIT:str>')<EOL><DEDENT>if count is not None:<EOL><INDENT>query_parameters['<STR_LIT:count>'] = self._serialize.query(\"<STR_LIT:count>\", count, '<STR_LIT:int>')<EOL><DEDENT>if freshness is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", freshness, '<STR_LIT:str>')<EOL><DEDENT>if market is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", market, '<STR_LIT:str>')<EOL><DEDENT>if offset is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", offset, '<STR_LIT:int>')<EOL><DEDENT>if promote is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", promote, '<STR_LIT>', div='<STR_LIT:U+002C>')<EOL><DEDENT>query_parameters['<STR_LIT:q>'] = self._serialize.query(\"<STR_LIT>\", query, '<STR_LIT:str>')<EOL>if response_filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", response_filter, '<STR_LIT>', div='<STR_LIT:U+002C>')<EOL><DEDENT>if safe_search is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", safe_search, '<STR_LIT:str>')<EOL><DEDENT>if set_lang is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", set_lang, '<STR_LIT:str>')<EOL><DEDENT>if text_decorations is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", text_decorations, '<STR_LIT:bool>')<EOL><DEDENT>if text_format is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", text_format, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.x_bing_apis_sdk, '<STR_LIT:str>')<EOL>if accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", accept_language, '<STR_LIT:str>')<EOL><DEDENT>if pragma is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", pragma, '<STR_LIT:str>')<EOL><DEDENT>if user_agent is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", user_agent, '<STR_LIT:str>')<EOL><DEDENT>if client_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", client_id, '<STR_LIT:str>')<EOL><DEDENT>if client_ip is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", client_ip, '<STR_LIT:str>')<EOL><DEDENT>if location is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT:location>\", location, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "The Web Search API lets you send a search query to Bing and get back\n        search results that include links to webpages, images, and more.\n\n        :param query: The user's search query term. The term may not be empty.\n         The term may contain Bing Advanced Operators. For example, to limit\n         results to a specific domain, use the site: operator.\n        :type query: str\n        :param accept_language: A comma-delimited list of one or more\n         languages to use for user interface strings. The list is in decreasing\n         order of preference. For additional information, including expected\n         format, see\n         [RFC2616](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html).\n         This header and the setLang query parameter are mutually exclusive; do\n         not specify both. If you set this header, you must also specify the cc\n         query parameter. Bing will use the first supported language it finds\n         from the list, and combine that language with the cc parameter value\n         to determine the market to return results for. If the list does not\n         include a supported language, Bing will find the closest language and\n         market that supports the request, and may use an aggregated or default\n         market for the results instead of a specified one. You should use this\n         header and the cc query parameter only if you specify multiple\n         languages; otherwise, you should use the mkt and setLang query\n         parameters. A user interface string is a string that's used as a label\n         in a user interface. There are very few user interface strings in the\n         JSON response objects. Any links in the response objects to Bing.com\n         properties will apply the specified language.\n        :type accept_language: str\n        :param pragma: By default, Bing returns cached content, if available.\n         To prevent Bing from returning cached content, set the Pragma header\n         to no-cache (for example, Pragma: no-cache).\n        :type pragma: str\n        :param user_agent: The user agent originating the request. Bing uses\n         the user agent to provide mobile users with an optimized experience.\n         Although optional, you are strongly encouraged to always specify this\n         header. The user-agent should be the same string that any commonly\n         used browser would send. For information about user agents, see [RFC\n         2616](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html).\n        :type user_agent: str\n        :param client_id: Bing uses this header to provide users with\n         consistent behavior across Bing API calls. Bing often flights new\n         features and improvements, and it uses the client ID as a key for\n         assigning traffic on different flights. If you do not use the same\n         client ID for a user across multiple requests, then Bing may assign\n         the user to multiple conflicting flights. Being assigned to multiple\n         conflicting flights can lead to an inconsistent user experience. For\n         example, if the second request has a different flight assignment than\n         the first, the experience may be unexpected. Also, Bing can use the\n         client ID to tailor web results to that client ID\u2019s search history,\n         providing a richer experience for the user. Bing also uses this header\n         to help improve result rankings by analyzing the activity generated by\n         a client ID. The relevance improvements help with better quality of\n         results delivered by Bing APIs and in turn enables higher\n         click-through rates for the API consumer. IMPORTANT: Although\n         optional, you should consider this header required. Persisting the\n         client ID across multiple requests for the same end user and device\n         combination enables 1) the API consumer to receive a consistent user\n         experience, and 2) higher click-through rates via better quality of\n         results from the Bing APIs. Each user that uses your application on\n         the device must have a unique, Bing generated client ID. If you do not\n         include this header in the request, Bing generates an ID and returns\n         it in the X-MSEdge-ClientID response header. The only time that you\n         should NOT include this header in a request is the first time the user\n         uses your app on that device. Use the client ID for each Bing API\n         request that your app makes for this user on the device. Persist the\n         client ID. To persist the ID in a browser app, use a persistent HTTP\n         cookie to ensure the ID is used across all sessions. Do not use a\n         session cookie. For other apps such as mobile apps, use the device's\n         persistent storage to persist the ID. The next time the user uses your\n         app on that device, get the client ID that you persisted. Bing\n         responses may or may not include this header. If the response includes\n         this header, capture the client ID and use it for all subsequent Bing\n         requests for the user on that device. If you include the\n         X-MSEdge-ClientID, you must not include cookies in the request.\n        :type client_id: str\n        :param client_ip: The IPv4 or IPv6 address of the client device. The\n         IP address is used to discover the user's location. Bing uses the\n         location information to determine safe search behavior. Although\n         optional, you are encouraged to always specify this header and the\n         X-Search-Location header. Do not obfuscate the address (for example,\n         by changing the last octet to 0). Obfuscating the address results in\n         the location not being anywhere near the device's actual location,\n         which may result in Bing serving erroneous results.\n        :type client_ip: str\n        :param location: A semicolon-delimited list of key/value pairs that\n         describe the client's geographical location. Bing uses the location\n         information to determine safe search behavior and to return relevant\n         local content. Specify the key/value pair as <key>:<value>. The\n         following are the keys that you use to specify the user's location.\n         lat (required): The latitude of the client's location, in degrees. The\n         latitude must be greater than or equal to -90.0 and less than or equal\n         to +90.0. Negative values indicate southern latitudes and positive\n         values indicate northern latitudes. long (required): The longitude of\n         the client's location, in degrees. The longitude must be greater than\n         or equal to -180.0 and less than or equal to +180.0. Negative values\n         indicate western longitudes and positive values indicate eastern\n         longitudes. re (required): The radius, in meters, which specifies the\n         horizontal accuracy of the coordinates. Pass the value returned by the\n         device's location service. Typical values might be 22m for GPS/Wi-Fi,\n         380m for cell tower triangulation, and 18,000m for reverse IP lookup.\n         ts (optional): The UTC UNIX timestamp of when the client was at the\n         location. (The UNIX timestamp is the number of seconds since January\n         1, 1970.) head (optional): The client's relative heading or direction\n         of travel. Specify the direction of travel as degrees from 0 through\n         360, counting clockwise relative to true north. Specify this key only\n         if the sp key is nonzero. sp (optional): The horizontal velocity\n         (speed), in meters per second, that the client device is traveling.\n         alt (optional): The altitude of the client device, in meters. are\n         (optional): The radius, in meters, that specifies the vertical\n         accuracy of the coordinates. Specify this key only if you specify the\n         alt key. Although many of the keys are optional, the more information\n         that you provide, the more accurate the location results are. Although\n         optional, you are encouraged to always specify the user's geographical\n         location. Providing the location is especially important if the\n         client's IP address does not accurately reflect the user's physical\n         location (for example, if the client uses VPN). For optimal results,\n         you should include this header and the X-MSEdge-ClientIP header, but\n         at a minimum, you should include this header.\n        :type location: str\n        :param answer_count: The number of answers that you want the response\n         to include. The answers that Bing returns are based on ranking. For\n         example, if Bing returns webpages, images, videos, and relatedSearches\n         for a request and you set this parameter to two (2), the response\n         includes webpages and images.If you included the responseFilter query\n         parameter in the same request and set it to webpages and news, the\n         response would include only webpages.\n        :type answer_count: int\n        :param country_code: A 2-character country code of the country where\n         the results come from. This API supports only the United States\n         market. If you specify this query parameter, it must be set to us. If\n         you set this parameter, you must also specify the Accept-Language\n         header. Bing uses the first supported language it finds from the\n         languages list, and combine that language with the country code that\n         you specify to determine the market to return results for. If the\n         languages list does not include a supported language, Bing finds the\n         closest language and market that supports the request, or it may use\n         an aggregated or default market for the results instead of a specified\n         one. You should use this query parameter and the Accept-Language query\n         parameter only if you specify multiple languages; otherwise, you\n         should use the mkt and setLang query parameters. This parameter and\n         the mkt query parameter are mutually exclusive\u2014do not specify both.\n        :type country_code: str\n        :param count: The number of search results to return in the response.\n         The default is 10 and the maximum value is 50. The actual number\n         delivered may be less than requested.Use this parameter along with the\n         offset parameter to page results.For example, if your user interface\n         displays 10 search results per page, set count to 10 and offset to 0\n         to get the first page of results. For each subsequent page, increment\n         offset by 10 (for example, 0, 10, 20). It is possible for multiple\n         pages to include some overlap in results.\n        :type count: int\n        :param freshness: Filter search results by the following age values:\n         Day\u2014Return webpages that Bing discovered within the last 24 hours.\n         Week\u2014Return webpages that Bing discovered within the last 7 days.\n         Month\u2014Return webpages that discovered within the last 30 days. This\n         filter applies only to webpage results and not to the other results\n         such as news and images. Possible values include: 'Day', 'Week',\n         'Month'\n        :type freshness: str or\n         ~azure.cognitiveservices.search.websearch.models.Freshness\n        :param market: The market where the results come from. Typically, mkt\n         is the country where the user is making the request from. However, it\n         could be a different country if the user is not located in a country\n         where Bing delivers results. The market must be in the form <language\n         code>-<country code>. For example, en-US. The string is case\n         insensitive. If known, you are encouraged to always specify the\n         market. Specifying the market helps Bing route the request and return\n         an appropriate and optimal response. If you specify a market that is\n         not listed in Market Codes, Bing uses a best fit market code based on\n         an internal mapping that is subject to change. This parameter and the\n         cc query parameter are mutually exclusive\u2014do not specify both.\n        :type market: str\n        :param offset: The zero-based offset that indicates the number of\n         search results to skip before returning results. The default is 0. The\n         offset should be less than (totalEstimatedMatches - count). Use this\n         parameter along with the count parameter to page results. For example,\n         if your user interface displays 10 search results per page, set count\n         to 10 and offset to 0 to get the first page of results. For each\n         subsequent page, increment offset by 10 (for example, 0, 10, 20). it\n         is possible for multiple pages to include some overlap in results.\n        :type offset: int\n        :param promote: A comma-delimited list of answers that you want the\n         response to include regardless of their ranking. For example, if you\n         set answerCount) to two (2) so Bing returns the top two ranked\n         answers, but you also want the response to include news, you'd set\n         promote to news. If the top ranked answers are webpages, images,\n         videos, and relatedSearches, the response includes webpages and images\n         because news is not a ranked answer. But if you set promote to video,\n         Bing would promote the video answer into the response and return\n         webpages, images, and videos. The answers that you want to promote do\n         not count against the answerCount limit. For example, if the ranked\n         answers are news, images, and videos, and you set answerCount to 1 and\n         promote to news, the response contains news and images. Or, if the\n         ranked answers are videos, images, and news, the response contains\n         videos and news. Possible values are Computation, Images, News,\n         RelatedSearches, SpellSuggestions, TimeZone, Videos, Webpages. Use\n         only if you specify answerCount.\n        :type promote: list[str or\n         ~azure.cognitiveservices.search.websearch.models.AnswerType]\n        :param response_filter: A comma-delimited list of answers to include\n         in the response. If you do not specify this parameter, the response\n         includes all search answers for which there's relevant data. Possible\n         filter values are Computation, Images, News, RelatedSearches,\n         SpellSuggestions, TimeZone, Videos, Webpages. Although you may use\n         this filter to get a single answer, you should instead use the\n         answer-specific endpoint in order to get richer results. For example,\n         to receive only images, send the request to one of the Image Search\n         API endpoints. The RelatedSearches and SpellSuggestions answers do not\n         support a separate endpoint like the Image Search API does (only the\n         Web Search API returns them). To include answers that would otherwise\n         be excluded because of ranking, see the promote query parameter.\n        :type response_filter: list[str or\n         ~azure.cognitiveservices.search.websearch.models.AnswerType]\n        :param safe_search: A filter used to filter adult content. Off: Return\n         webpages with adult text, images, or videos. Moderate: Return webpages\n         with adult text, but not adult images or videos. Strict: Do not return\n         webpages with adult text, images, or videos. The default is Moderate.\n         If the request comes from a market that Bing's adult policy requires\n         that safeSearch is set to Strict, Bing ignores the safeSearch value\n         and uses Strict. If you use the site: query operator, there is the\n         chance that the response may contain adult content regardless of what\n         the safeSearch query parameter is set to. Use site: only if you are\n         aware of the content on the site and your scenario supports the\n         possibility of adult content. Possible values include: 'Off',\n         'Moderate', 'Strict'\n        :type safe_search: str or\n         ~azure.cognitiveservices.search.websearch.models.SafeSearch\n        :param set_lang: The language to use for user interface strings.\n         Specify the language using the ISO 639-1 2-letter language code. For\n         example, the language code for English is EN. The default is EN\n         (English). Although optional, you should always specify the language.\n         Typically, you set setLang to the same language specified by mkt\n         unless the user wants the user interface strings displayed in a\n         different language. This parameter and the Accept-Language header are\n         mutually exclusive; do not specify both. A user interface string is a\n         string that's used as a label in a user interface. There are few user\n         interface strings in the JSON response objects. Also, any links to\n         Bing.com properties in the response objects apply the specified\n         language.\n        :type set_lang: str\n        :param text_decorations: A Boolean value that determines whether\n         display strings should contain decoration markers such as hit\n         highlighting characters. If true, the strings may include markers. The\n         default is false. To specify whether to use Unicode characters or HTML\n         tags as the markers, see the textFormat query parameter.\n        :type text_decorations: bool\n        :param text_format: The type of markers to use for text decorations\n         (see the textDecorations query parameter). Possible values are Raw\u2014Use\n         Unicode characters to mark content that needs special formatting. The\n         Unicode characters are in the range E000 through E019. For example,\n         Bing uses E000 and E001 to mark the beginning and end of query terms\n         for hit highlighting. HTML\u2014Use HTML tags to mark content that needs\n         special formatting. For example, use <b> tags to highlight query terms\n         in display strings. The default is Raw. For display strings that\n         contain escapable HTML characters such as <, >, and &, if textFormat\n         is set to HTML, Bing escapes the characters as appropriate (for\n         example, < is escaped to &lt;). Possible values include: 'Raw', 'Html'\n        :type text_format: str or\n         ~azure.cognitiveservices.search.websearch.models.TextFormat\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SearchResponse or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.cognitiveservices.search.websearch.models.SearchResponse or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.search.websearch.models.ErrorResponseException>`", "id": "f35599:c0:m1"}
{"signature": "def create_account_sas_definition(self, storage_account_name, vault_url):", "body": "from azure.storage.common import SharedAccessSignature, CloudStorageAccount<EOL>from azure.keyvault.models import SasTokenType, SasDefinitionAttributes<EOL>from azure.keyvault import SecretId<EOL>sas = SharedAccessSignature(account_name=storage_account_name,<EOL>account_key='<STR_LIT>')<EOL>account_sas_template = sas.generate_account(services='<STR_LIT>',  <EOL>resource_types='<STR_LIT>',  <EOL>permission='<STR_LIT>',<EOL>expiry='<STR_LIT>')  <EOL>attributes = SasDefinitionAttributes(enabled=True)<EOL>sas_def = self.client.set_sas_definition(vault_base_url=vault_url,<EOL>storage_account_name=storage_account_name,<EOL>sas_definition_name='<STR_LIT>',<EOL>template_uri=account_sas_template,<EOL>sas_type=SasTokenType.account,<EOL>validity_period='<STR_LIT>',<EOL>sas_definition_attributes=attributes)<EOL>sas_secret_id = SecretId(uri=sas_def.secret_id)<EOL>acct_sas_token = self.client.get_secret(vault_base_url=sas_secret_id.vault,<EOL>secret_name=sas_secret_id.name,<EOL>secret_version=sas_secret_id.version).value<EOL>cloud_storage_account = CloudStorageAccount(account_name=storage_account_name,<EOL>sas_token=acct_sas_token)<EOL>blob_service = cloud_storage_account.create_block_blob_service()<EOL>blob_service.create_container('<STR_LIT>')<EOL>blob_service.create_blob_from_text(container_name='<STR_LIT>',<EOL>blob_name='<STR_LIT>',<EOL>text=u'<STR_LIT>')<EOL>", "docstring": "Creates an account sas definition, to manage storage account and its entities.", "id": "f35602:c0:m1"}
{"signature": "def get_sas_definitions(self, storage_account_name, vault_url):", "body": "from azure.keyvault import StorageSasDefinitionId<EOL>print('<STR_LIT>')<EOL>sas_defs = list(self.client.get_sas_definitions(vault_base_url=vault_url,<EOL>storage_account_name=storage_account_name,<EOL>maxresults=<NUM_LIT:5>))<EOL>for s in sas_defs:<EOL><INDENT>sas_def_id = StorageSasDefinitionId(uri=s.id)<EOL>sas_def = self.client.get_sas_definition(vault_base_url=sas_def_id.vault,<EOL>storage_account_name=sas_def_id.account_name,<EOL>sas_definition_name=sas_def_id.sas_definition)<EOL>print(sas_def_id.sas_definition, sas_def.template_uri)<EOL><DEDENT>", "docstring": "List the sas definitions for the storage account, and get each.", "id": "f35602:c0:m3"}
{"signature": "def create_blob_sas_defintion(self, storage_account_name, vault_url):", "body": "from azure.storage.blob import BlockBlobService, ContainerPermissions<EOL>from azure.keyvault.models import SasTokenType, SasDefinitionAttributes<EOL>from azure.keyvault import SecretId<EOL>service = BlockBlobService(account_name=storage_account_name,<EOL>account_key='<STR_LIT>')<EOL>permissions = ContainerPermissions(read=True, write=True, delete=True, list=True)<EOL>temp_token = service.generate_container_shared_access_signature(container_name='<STR_LIT>',<EOL>permission=permissions,<EOL>expiry='<STR_LIT>')<EOL>blob_sas_template_uri = service.make_container_url(container_name='<STR_LIT>',<EOL>protocol='<STR_LIT>',<EOL>sas_token=temp_token)<EOL>attributes = SasDefinitionAttributes(enabled=True)<EOL>blob_sas_def = self.client.set_sas_definition(vault_base_url=vault_url,<EOL>storage_account_name=storage_account_name,<EOL>sas_definition_name='<STR_LIT>',<EOL>template_uri=blob_sas_template_uri,<EOL>sas_type=SasTokenType.service,<EOL>validity_period='<STR_LIT>',<EOL>sas_definition_attributes=attributes)<EOL>sas_secret_id = SecretId(uri=blob_sas_def.secret_id)<EOL>blob_sas_token = self.client.get_secret(vault_base_url=sas_secret_id.vault,<EOL>secret_name=sas_secret_id.name,<EOL>secret_version=sas_secret_id.version).value<EOL>service = BlockBlobService(account_name=storage_account_name,<EOL>sas_token=blob_sas_token)<EOL>service.create_blob_from_text(container_name='<STR_LIT>',<EOL>blob_name='<STR_LIT>',<EOL>text=u'<STR_LIT>')<EOL>blobs = list(service.list_blobs(container_name='<STR_LIT>'))<EOL>for blob in blobs:<EOL><INDENT>service.delete_blob(container_name='<STR_LIT>',<EOL>blob_name=blob.name)<EOL><DEDENT>", "docstring": "Creates a service SAS definition with access to a blob container.", "id": "f35602:c0:m2"}
{"signature": "def set_challenge_for_url(url, challenge):", "body": "if not url:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>if not challenge:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>src_url = parse.urlparse(url)<EOL>if src_url.netloc != challenge.source_authority:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>_lock.acquire()<EOL>_cache[src_url.netloc] = challenge<EOL>_lock.release()<EOL>", "docstring": "Caches the challenge for the specified URL.\n    :param url: the URL for which to cache the challenge\n    :param challenge: the challenge to cache", "id": "f35610:m2"}
{"signature": "def get_scope(self):", "body": "return self.get_value('<STR_LIT>') or '<STR_LIT>'<EOL>", "docstring": "Returns the scope if present, otherwise empty string.", "id": "f35612:c0:m6"}
{"signature": "def _validate_challenge(self, challenge):", "body": "if not challenge:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return challenge.strip()<EOL>", "docstring": "Verifies that the challenge is a valid auth challenge and returns the key=value pairs.", "id": "f35612:c0:m9"}
{"signature": "def decrypt(<EOL>self, vault_base_url, key_name, key_version, algorithm, value, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.KeyOperationsParameters(algorithm=algorithm, value=value)<EOL>url = self.decrypt.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_base_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", key_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", key_version, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, body_content, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.KeyVaultErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Decrypts a single block of encrypted data.\n\n        The DECRYPT operation decrypts a well-formed block of ciphertext using\n        the target encryption key and specified algorithm. This operation is\n        the reverse of the ENCRYPT operation; only a single block of data may\n        be decrypted, the size of this block is dependent on the target key and\n        the algorithm to be used. The DECRYPT operation applies to asymmetric\n        and symmetric keys stored in Azure Key Vault since it uses the private\n        portion of the key. This operation requires the keys/decrypt\n        permission.\n\n        :param vault_base_url: The vault name, for example\n         https://myvault.vault.azure.net.\n        :type vault_base_url: str\n        :param key_name: The name of the key.\n        :type key_name: str\n        :param key_version: The version of the key.\n        :type key_version: str\n        :param algorithm: algorithm identifier. Possible values include:\n         'RSA-OAEP', 'RSA-OAEP-256', 'RSA1_5'\n        :type algorithm: str or\n         ~azure.keyvault.v2016_10_01.models.JsonWebKeyEncryptionAlgorithm\n        :param value:\n        :type value: bytes\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: KeyOperationResult or ClientRawResponse if raw=true\n        :rtype: ~azure.keyvault.v2016_10_01.models.KeyOperationResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`KeyVaultErrorException<azure.keyvault.v2016_10_01.models.KeyVaultErrorException>`", "id": "f35614:c1:m11"}
{"signature": "def get_storage_account(<EOL>self, vault_base_url, storage_account_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_storage_account.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_base_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", storage_account_name, '<STR_LIT:str>', pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.KeyVaultErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about a specified storage account. This operation\n        requires the storage/get permission.\n\n        :param vault_base_url: The vault name, for example\n         https://myvault.vault.azure.net.\n        :type vault_base_url: str\n        :param storage_account_name: The name of the storage account.\n        :type storage_account_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: StorageBundle or ClientRawResponse if raw=true\n        :rtype: ~azure.keyvault.v2016_10_01.models.StorageBundle or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`KeyVaultErrorException<azure.keyvault.v2016_10_01.models.KeyVaultErrorException>`", "id": "f35614:c1:m59"}
{"signature": "def create_key(<EOL>self, vault_base_url, key_name, kty, key_size=None, key_ops=None, key_attributes=None, tags=None, curve=None, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.KeyCreateParameters(kty=kty, key_size=key_size, key_ops=key_ops, key_attributes=key_attributes, tags=tags, curve=curve)<EOL>url = self.create_key.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_base_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", key_name, '<STR_LIT:str>', pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, body_content, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.KeyVaultErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates a new key, stores it, then returns key parameters and\n        attributes to the client.\n\n        The create key operation can be used to create any key type in Azure\n        Key Vault. If the named key already exists, Azure Key Vault creates a\n        new version of the key. It requires the keys/create permission.\n\n        :param vault_base_url: The vault name, for example\n         https://myvault.vault.azure.net.\n        :type vault_base_url: str\n        :param key_name: The name for the new key. The system will generate\n         the version name for the new key.\n        :type key_name: str\n        :param kty: The type of key to create. For valid values, see\n         JsonWebKeyType. Possible values include: 'EC', 'EC-HSM', 'RSA',\n         'RSA-HSM', 'oct'\n        :type kty: str or ~azure.keyvault.v2016_10_01.models.JsonWebKeyType\n        :param key_size: The key size in bits. For example: 2048, 3072, or\n         4096 for RSA.\n        :type key_size: int\n        :param key_ops:\n        :type key_ops: list[str or\n         ~azure.keyvault.v2016_10_01.models.JsonWebKeyOperation]\n        :param key_attributes:\n        :type key_attributes: ~azure.keyvault.v2016_10_01.models.KeyAttributes\n        :param tags: Application specific metadata in the form of key-value\n         pairs.\n        :type tags: dict[str, str]\n        :param curve: Elliptic curve name. For valid values, see\n         JsonWebKeyCurveName. Possible values include: 'P-256', 'P-384',\n         'P-521', 'SECP256K1'\n        :type curve: str or\n         ~azure.keyvault.v2016_10_01.models.JsonWebKeyCurveName\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: KeyBundle or ClientRawResponse if raw=true\n        :rtype: ~azure.keyvault.v2016_10_01.models.KeyBundle or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`KeyVaultErrorException<azure.keyvault.v2016_10_01.models.KeyVaultErrorException>`", "id": "f35614:c1:m1"}
{"signature": "def update_certificate_issuer(<EOL>self, vault_base_url, issuer_name, provider=None, credentials=None, organization_details=None, attributes=None, custom_headers=None, raw=False, **operation_config):", "body": "parameter = models.CertificateIssuerUpdateParameters(provider=provider, credentials=credentials, organization_details=organization_details, attributes=attributes)<EOL>url = self.update_certificate_issuer.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_base_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", issuer_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameter, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, body_content, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.KeyVaultErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Updates the specified certificate issuer.\n\n        The UpdateCertificateIssuer operation performs an update on the\n        specified certificate issuer entity. This operation requires the\n        certificates/setissuers permission.\n\n        :param vault_base_url: The vault name, for example\n         https://myvault.vault.azure.net.\n        :type vault_base_url: str\n        :param issuer_name: The name of the issuer.\n        :type issuer_name: str\n        :param provider: The issuer provider.\n        :type provider: str\n        :param credentials: The credentials to be used for the issuer.\n        :type credentials:\n         ~azure.keyvault.v2016_10_01.models.IssuerCredentials\n        :param organization_details: Details of the organization as provided\n         to the issuer.\n        :type organization_details:\n         ~azure.keyvault.v2016_10_01.models.OrganizationDetails\n        :param attributes: Attributes of the issuer object.\n        :type attributes: ~azure.keyvault.v2016_10_01.models.IssuerAttributes\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: IssuerBundle or ClientRawResponse if raw=true\n        :rtype: ~azure.keyvault.v2016_10_01.models.IssuerBundle or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`KeyVaultErrorException<azure.keyvault.v2016_10_01.models.KeyVaultErrorException>`", "id": "f35614:c1:m39"}
{"signature": "def get_certificate(<EOL>self, vault_base_url, certificate_name, certificate_version, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_certificate.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_base_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", certificate_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", certificate_version, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.KeyVaultErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about a certificate.\n\n        Gets information about a specific certificate. This operation requires\n        the certificates/get permission.\n\n        :param vault_base_url: The vault name, for example\n         https://myvault.vault.azure.net.\n        :type vault_base_url: str\n        :param certificate_name: The name of the certificate in the given\n         vault.\n        :type certificate_name: str\n        :param certificate_version: The version of the certificate.\n        :type certificate_version: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: CertificateBundle or ClientRawResponse if raw=true\n        :rtype: ~azure.keyvault.v2016_10_01.models.CertificateBundle or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`KeyVaultErrorException<azure.keyvault.v2016_10_01.models.KeyVaultErrorException>`", "id": "f35614:c1:m48"}
{"signature": "def get_certificate_contacts(<EOL>self, vault_base_url, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_certificate_contacts.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_base_url, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.KeyVaultErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists the certificate contacts for a specified key vault.\n\n        The GetCertificateContacts operation returns the set of certificate\n        contact resources in the specified key vault. This operation requires\n        the certificates/managecontacts permission.\n\n        :param vault_base_url: The vault name, for example\n         https://myvault.vault.azure.net.\n        :type vault_base_url: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Contacts or ClientRawResponse if raw=true\n        :rtype: ~azure.keyvault.v2016_10_01.models.Contacts or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`KeyVaultErrorException<azure.keyvault.v2016_10_01.models.KeyVaultErrorException>`", "id": "f35614:c1:m35"}
{"signature": "def update_sas_definition(<EOL>self, vault_base_url, storage_account_name, sas_definition_name, parameters=None, sas_definition_attributes=None, tags=None, custom_headers=None, raw=False, **operation_config):", "body": "parameters1 = models.SasDefinitionUpdateParameters(parameters=parameters, sas_definition_attributes=sas_definition_attributes, tags=tags)<EOL>url = self.update_sas_definition.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_base_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", storage_account_name, '<STR_LIT:str>', pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", sas_definition_name, '<STR_LIT:str>', pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters1, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, body_content, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.KeyVaultErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Updates the specified attributes associated with the given SAS\n        definition. This operation requires the storage/setsas permission.\n\n        :param vault_base_url: The vault name, for example\n         https://myvault.vault.azure.net.\n        :type vault_base_url: str\n        :param storage_account_name: The name of the storage account.\n        :type storage_account_name: str\n        :param sas_definition_name: The name of the SAS definition.\n        :type sas_definition_name: str\n        :param parameters: Sas definition update metadata in the form of\n         key-value pairs.\n        :type parameters: dict[str, str]\n        :param sas_definition_attributes: The attributes of the SAS\n         definition.\n        :type sas_definition_attributes:\n         ~azure.keyvault.v2016_10_01.models.SasDefinitionAttributes\n        :param tags: Application specific metadata in the form of key-value\n         pairs.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SasDefinitionBundle or ClientRawResponse if raw=true\n        :rtype: ~azure.keyvault.v2016_10_01.models.SasDefinitionBundle or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`KeyVaultErrorException<azure.keyvault.v2016_10_01.models.KeyVaultErrorException>`", "id": "f35614:c1:m67"}
{"signature": "def sign(<EOL>self, vault_base_url, key_name, key_version, algorithm, value, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.KeySignParameters(algorithm=algorithm, value=value)<EOL>url = self.sign.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_base_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", key_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", key_version, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, body_content, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.KeyVaultErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates a signature from a digest using the specified key.\n\n        The SIGN operation is applicable to asymmetric and symmetric keys\n        stored in Azure Key Vault since this operation uses the private portion\n        of the key. This operation requires the keys/sign permission.\n\n        :param vault_base_url: The vault name, for example\n         https://myvault.vault.azure.net.\n        :type vault_base_url: str\n        :param key_name: The name of the key.\n        :type key_name: str\n        :param key_version: The version of the key.\n        :type key_version: str\n        :param algorithm: The signing/verification algorithm identifier. For\n         more information on possible algorithm types, see\n         JsonWebKeySignatureAlgorithm. Possible values include: 'PS256',\n         'PS384', 'PS512', 'RS256', 'RS384', 'RS512', 'RSNULL', 'ES256',\n         'ES384', 'ES512', 'ECDSA256'\n        :type algorithm: str or\n         ~azure.keyvault.v2016_10_01.models.JsonWebKeySignatureAlgorithm\n        :param value:\n        :type value: bytes\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: KeyOperationResult or ClientRawResponse if raw=true\n        :rtype: ~azure.keyvault.v2016_10_01.models.KeyOperationResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`KeyVaultErrorException<azure.keyvault.v2016_10_01.models.KeyVaultErrorException>`", "id": "f35614:c1:m12"}
{"signature": "def get_certificate_operation(<EOL>self, vault_base_url, certificate_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_certificate_operation.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_base_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", certificate_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.KeyVaultErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the creation operation of a certificate.\n\n        Gets the creation operation associated with a specified certificate.\n        This operation requires the certificates/get permission.\n\n        :param vault_base_url: The vault name, for example\n         https://myvault.vault.azure.net.\n        :type vault_base_url: str\n        :param certificate_name: The name of the certificate.\n        :type certificate_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: CertificateOperation or ClientRawResponse if raw=true\n        :rtype: ~azure.keyvault.v2016_10_01.models.CertificateOperation or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`KeyVaultErrorException<azure.keyvault.v2016_10_01.models.KeyVaultErrorException>`", "id": "f35614:c1:m50"}
{"signature": "def get_secrets(<EOL>self, vault_base_url, maxresults=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.get_secrets.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_base_url, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if maxresults is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", maxresults, '<STR_LIT:int>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.KeyVaultErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SecretItemPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SecretItemPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List secrets in a specified key vault.\n\n        The Get Secrets operation is applicable to the entire vault. However,\n        only the base secret identifier and its attributes are provided in the\n        response. Individual secret versions are not listed in the response.\n        This operation requires the secrets/list permission.\n\n        :param vault_base_url: The vault name, for example\n         https://myvault.vault.azure.net.\n        :type vault_base_url: str\n        :param maxresults: Maximum number of results to return in a page. If\n         not specified, the service will return up to 25 results.\n        :type maxresults: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of SecretItem\n        :rtype:\n         ~azure.keyvault.v2016_10_01.models.SecretItemPaged[~azure.keyvault.v2016_10_01.models.SecretItem]\n        :raises:\n         :class:`KeyVaultErrorException<azure.keyvault.v2016_10_01.models.KeyVaultErrorException>`", "id": "f35614:c1:m24"}
{"signature": "def get_certificate_versions(<EOL>self, vault_base_url, certificate_name, maxresults=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.get_certificate_versions.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_base_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", certificate_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if maxresults is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", maxresults, '<STR_LIT:int>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.KeyVaultErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.CertificateItemPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.CertificateItemPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List the versions of a certificate.\n\n        The GetCertificateVersions operation returns the versions of a\n        certificate in the specified key vault. This operation requires the\n        certificates/list permission.\n\n        :param vault_base_url: The vault name, for example\n         https://myvault.vault.azure.net.\n        :type vault_base_url: str\n        :param certificate_name: The name of the certificate.\n        :type certificate_name: str\n        :param maxresults: Maximum number of results to return in a page. If\n         not specified the service will return up to 25 results.\n        :type maxresults: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of CertificateItem\n        :rtype:\n         ~azure.keyvault.v2016_10_01.models.CertificateItemPaged[~azure.keyvault.v2016_10_01.models.CertificateItem]\n        :raises:\n         :class:`KeyVaultErrorException<azure.keyvault.v2016_10_01.models.KeyVaultErrorException>`", "id": "f35614:c1:m44"}
{"signature": "def get_certificate_policy(<EOL>self, vault_base_url, certificate_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_certificate_policy.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_base_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", certificate_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.KeyVaultErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists the policy for a certificate.\n\n        The GetCertificatePolicy operation returns the specified certificate\n        policy resources in the specified key vault. This operation requires\n        the certificates/get permission.\n\n        :param vault_base_url: The vault name, for example\n         https://myvault.vault.azure.net.\n        :type vault_base_url: str\n        :param certificate_name: The name of the certificate in a given key\n         vault.\n        :type certificate_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: CertificatePolicy or ClientRawResponse if raw=true\n        :rtype: ~azure.keyvault.v2016_10_01.models.CertificatePolicy or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`KeyVaultErrorException<azure.keyvault.v2016_10_01.models.KeyVaultErrorException>`", "id": "f35614:c1:m45"}
{"signature": "def get_keys(<EOL>self, vault_base_url, maxresults=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.get_keys.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_base_url, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if maxresults is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", maxresults, '<STR_LIT:int>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.KeyVaultErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.KeyItemPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.KeyItemPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List keys in the specified vault.\n\n        Retrieves a list of the keys in the Key Vault as JSON Web Key\n        structures that contain the public part of a stored key. The LIST\n        operation is applicable to all key types, however only the base key\n        identifier, attributes, and tags are provided in the response.\n        Individual versions of a key are not listed in the response. This\n        operation requires the keys/list permission.\n\n        :param vault_base_url: The vault name, for example\n         https://myvault.vault.azure.net.\n        :type vault_base_url: str\n        :param maxresults: Maximum number of results to return in a page. If\n         not specified the service will return up to 25 results.\n        :type maxresults: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of KeyItem\n        :rtype:\n         ~azure.keyvault.v2016_10_01.models.KeyItemPaged[~azure.keyvault.v2016_10_01.models.KeyItem]\n        :raises:\n         :class:`KeyVaultErrorException<azure.keyvault.v2016_10_01.models.KeyVaultErrorException>`", "id": "f35614:c1:m7"}
{"signature": "def get_sas_definitions(<EOL>self, vault_base_url, storage_account_name, maxresults=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.get_sas_definitions.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_base_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", storage_account_name, '<STR_LIT:str>', pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if maxresults is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", maxresults, '<STR_LIT:int>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.KeyVaultErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SasDefinitionItemPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SasDefinitionItemPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List storage SAS definitions for the given storage account. This\n        operation requires the storage/listsas permission.\n\n        :param vault_base_url: The vault name, for example\n         https://myvault.vault.azure.net.\n        :type vault_base_url: str\n        :param storage_account_name: The name of the storage account.\n        :type storage_account_name: str\n        :param maxresults: Maximum number of results to return in a page. If\n         not specified the service will return up to 25 results.\n        :type maxresults: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of SasDefinitionItem\n        :rtype:\n         ~azure.keyvault.v2016_10_01.models.SasDefinitionItemPaged[~azure.keyvault.v2016_10_01.models.SasDefinitionItem]\n        :raises:\n         :class:`KeyVaultErrorException<azure.keyvault.v2016_10_01.models.KeyVaultErrorException>`", "id": "f35614:c1:m63"}
{"signature": "def delete_secret(<EOL>self, vault_base_url, secret_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete_secret.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_base_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", secret_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.KeyVaultErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Deletes a secret from a specified key vault.\n\n        The DELETE operation applies to any secret stored in Azure Key Vault.\n        DELETE cannot be applied to an individual version of a secret. This\n        operation requires the secrets/delete permission.\n\n        :param vault_base_url: The vault name, for example\n         https://myvault.vault.azure.net.\n        :type vault_base_url: str\n        :param secret_name: The name of the secret.\n        :type secret_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DeletedSecretBundle or ClientRawResponse if raw=true\n        :rtype: ~azure.keyvault.v2016_10_01.models.DeletedSecretBundle or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`KeyVaultErrorException<azure.keyvault.v2016_10_01.models.KeyVaultErrorException>`", "id": "f35614:c1:m21"}
{"signature": "def update_certificate(<EOL>self, vault_base_url, certificate_name, certificate_version, certificate_policy=None, certificate_attributes=None, tags=None, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.CertificateUpdateParameters(certificate_policy=certificate_policy, certificate_attributes=certificate_attributes, tags=tags)<EOL>url = self.update_certificate.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_base_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", certificate_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", certificate_version, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, body_content, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.KeyVaultErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Updates the specified attributes associated with the given certificate.\n\n        The UpdateCertificate operation applies the specified update on the\n        given certificate; the only elements updated are the certificate's\n        attributes. This operation requires the certificates/update permission.\n\n        :param vault_base_url: The vault name, for example\n         https://myvault.vault.azure.net.\n        :type vault_base_url: str\n        :param certificate_name: The name of the certificate in the given key\n         vault.\n        :type certificate_name: str\n        :param certificate_version: The version of the certificate.\n        :type certificate_version: str\n        :param certificate_policy: The management policy for the certificate.\n        :type certificate_policy:\n         ~azure.keyvault.v2016_10_01.models.CertificatePolicy\n        :param certificate_attributes: The attributes of the certificate\n         (optional).\n        :type certificate_attributes:\n         ~azure.keyvault.v2016_10_01.models.CertificateAttributes\n        :param tags: Application specific metadata in the form of key-value\n         pairs.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: CertificateBundle or ClientRawResponse if raw=true\n        :rtype: ~azure.keyvault.v2016_10_01.models.CertificateBundle or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`KeyVaultErrorException<azure.keyvault.v2016_10_01.models.KeyVaultErrorException>`", "id": "f35614:c1:m47"}
{"signature": "def get_deleted_secrets(<EOL>self, vault_base_url, maxresults=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.get_deleted_secrets.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_base_url, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if maxresults is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", maxresults, '<STR_LIT:int>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.KeyVaultErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.DeletedSecretItemPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.DeletedSecretItemPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists deleted secrets for the specified vault.\n\n        The Get Deleted Secrets operation returns the secrets that have been\n        deleted for a vault enabled for soft-delete. This operation requires\n        the secrets/list permission.\n\n        :param vault_base_url: The vault name, for example\n         https://myvault.vault.azure.net.\n        :type vault_base_url: str\n        :param maxresults: Maximum number of results to return in a page. If\n         not specified the service will return up to 25 results.\n        :type maxresults: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of DeletedSecretItem\n        :rtype:\n         ~azure.keyvault.v2016_10_01.models.DeletedSecretItemPaged[~azure.keyvault.v2016_10_01.models.DeletedSecretItem]\n        :raises:\n         :class:`KeyVaultErrorException<azure.keyvault.v2016_10_01.models.KeyVaultErrorException>`", "id": "f35614:c1:m26"}
{"signature": "def update_storage_account(<EOL>self, vault_base_url, storage_account_name, active_key_name=None, auto_regenerate_key=None, regeneration_period=None, storage_account_attributes=None, tags=None, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.StorageAccountUpdateParameters(active_key_name=active_key_name, auto_regenerate_key=auto_regenerate_key, regeneration_period=regeneration_period, storage_account_attributes=storage_account_attributes, tags=tags)<EOL>url = self.update_storage_account.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_base_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", storage_account_name, '<STR_LIT:str>', pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, body_content, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.KeyVaultErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Updates the specified attributes associated with the given storage\n        account. This operation requires the storage/set/update permission.\n\n        :param vault_base_url: The vault name, for example\n         https://myvault.vault.azure.net.\n        :type vault_base_url: str\n        :param storage_account_name: The name of the storage account.\n        :type storage_account_name: str\n        :param active_key_name: The current active storage account key name.\n        :type active_key_name: str\n        :param auto_regenerate_key: whether keyvault should manage the storage\n         account for the user.\n        :type auto_regenerate_key: bool\n        :param regeneration_period: The key regeneration time duration\n         specified in ISO-8601 format.\n        :type regeneration_period: str\n        :param storage_account_attributes: The attributes of the storage\n         account.\n        :type storage_account_attributes:\n         ~azure.keyvault.v2016_10_01.models.StorageAccountAttributes\n        :param tags: Application specific metadata in the form of key-value\n         pairs.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: StorageBundle or ClientRawResponse if raw=true\n        :rtype: ~azure.keyvault.v2016_10_01.models.StorageBundle or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`KeyVaultErrorException<azure.keyvault.v2016_10_01.models.KeyVaultErrorException>`", "id": "f35614:c1:m61"}
{"signature": "def __setattr__(self, name, attr):", "body": "if self._init_complete and not hasattr(self, name):<EOL><INDENT>impl = self._get_client_impl()<EOL>setattr(impl, name, attr)<EOL><DEDENT>else:<EOL><INDENT>super(KeyVaultClient, self).__setattr__(name, attr)<EOL><DEDENT>", "docstring": "Sets the specified attribute either on the custom KeyVaultClient or the current underlying implementation.\n:param name: Name of the attribute to set\n:param attr: Value of the attribute to set\n:return: None", "id": "f35767:c1:m7"}
{"signature": "def _create_client_impl(self, api_version):", "body": "if api_version == v7_0_VERSION:<EOL><INDENT>from azure.keyvault.v7_0 import KeyVaultClient as ImplClient<EOL><DEDENT>elif api_version == v2016_10_01_VERSION:<EOL><INDENT>from azure.keyvault.v2016_10_01 import KeyVaultClient as ImplClient<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\".format(api_version))<EOL><DEDENT>impl = ImplClient(credentials=self._credentials)<EOL>impl.config = self.config<EOL>if self._entered and hasattr(impl, '<STR_LIT>'):<EOL><INDENT>impl.__enter__()<EOL><DEDENT>self._client_impls[api_version] = impl<EOL>return impl<EOL>", "docstring": "Creates the client implementation corresponding to the specifeid api_version.\n:param api_version:\n:return:", "id": "f35767:c1:m3"}
{"signature": "def _get_client_impl(self):", "body": "api_version = self._get_api_version(None)<EOL>if api_version not in self._client_impls:<EOL><INDENT>self._create_client_impl(api_version)<EOL><DEDENT>return self._client_impls[api_version]<EOL>", "docstring": "Get the versioned client implementation corresponding to the current profile.\n:return:  The versioned client implementation.", "id": "f35767:c1:m2"}
{"signature": "def _validate_challenge(self, challenge):", "body": "bearer_string = '<STR_LIT>'<EOL>if not challenge:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>challenge = challenge.strip()<EOL>if not challenge.startswith(bearer_string):<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>return challenge[len(bearer_string):]<EOL>", "docstring": "Verifies that the challenge is a Bearer challenge and returns the key=value pairs.", "id": "f35768:c0:m6"}
{"signature": "@staticmethod<EOL><INDENT>def parse_certificate_operation_id(id):<DEDENT>", "body": "return CertificateOperationId(id)<EOL>", "docstring": ":param id: The resource collection type.\n:type id: str\n:rtype: KeyVaultId", "id": "f35770:c1:m13"}
{"signature": "@staticmethod<EOL><INDENT>def create_certificate_operation_id(vault, name):<DEDENT>", "body": "return CertificateOperationId(vault=vault, name=name)<EOL>", "docstring": ":param vault: The vault uri.\n:type vault: str\n:param name: The certificate name.\n:type name: str\n:rtype: KeyVaultId", "id": "f35770:c1:m12"}
{"signature": "def __init__(self, uri=None, vault=None, name=None, version=None):", "body": "super(SecretId, self).__init__(uri=uri, collection='<STR_LIT>', vault=vault, name=name, version=version)<EOL>", "docstring": "Creates a key vault secret id.  If uri is specified the id properties are parsed from the uri, otherwise \nbuilds the id from the specified vault, name and version.\n:param uri:  The uri of the key vault secret\n:param vault: The vault uri\n:param name: The secret name\n:param version: The secret version", "id": "f35770:c4:m0"}
{"signature": "@staticmethod<EOL><INDENT>def create_certificate_id(vault, name, version=None):<DEDENT>", "body": "return CertificateId(vault=vault, name=name, version=version)<EOL>", "docstring": ":param vault: The vault uri.\n:type vault: str\n:param name: The certificate name.\n:type name: str\n:param version: The certificate version.\n:type version: str\n:rtype: KeyVaultId", "id": "f35770:c1:m10"}
{"signature": "@staticmethod<EOL><INDENT>def parse_secret_id(id):<DEDENT>", "body": "return SecretId(id)<EOL>", "docstring": ":param id: The secret uri.\n:type id: str\n:rtype: KeyVaultId", "id": "f35770:c1:m9"}
{"signature": "def __init__(self, collection, vault, name, version):", "body": "self.vault = vault<EOL>self.name = name<EOL>self.collection = collection<EOL>self.version = version or KeyVaultId.version_none<EOL>", "docstring": ":param collection: The resource collection type.\n:type collection: str\n:param vault: The vault URI.\n:type vault: str\n:param name: The resource name.\n:type name: str\n:param version: The resource version.\n:type version: str", "id": "f35770:c1:m0"}
{"signature": "def get_key(<EOL>self, vault_base_url, key_name, key_version, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_key.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_base_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", key_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", key_version, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.KeyVaultErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the public part of a stored key.\n\n        The get key operation is applicable to all key types. If the requested\n        key is symmetric, then no key material is released in the response.\n        This operation requires the keys/get permission.\n\n        :param vault_base_url: The vault name, for example\n         https://myvault.vault.azure.net.\n        :type vault_base_url: str\n        :param key_name: The name of the key to get.\n        :type key_name: str\n        :param key_version: Adding the version parameter retrieves a specific\n         version of a key.\n        :type key_version: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: KeyBundle or ClientRawResponse if raw=true\n        :rtype: ~azure.keyvault.v7_0.models.KeyBundle or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`KeyVaultErrorException<azure.keyvault.v7_0.models.KeyVaultErrorException>`", "id": "f35772:c1:m5"}
{"signature": "def recover_deleted_certificate(<EOL>self, vault_base_url, certificate_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.recover_deleted_certificate.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_base_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", certificate_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.KeyVaultErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Recovers the deleted certificate back to its current version under\n        /certificates.\n\n        The RecoverDeletedCertificate operation performs the reversal of the\n        Delete operation. The operation is applicable in vaults enabled for\n        soft-delete, and must be issued during the retention interval\n        (available in the deleted certificate's attributes). This operation\n        requires the certificates/recover permission.\n\n        :param vault_base_url: The vault name, for example\n         https://myvault.vault.azure.net.\n        :type vault_base_url: str\n        :param certificate_name: The name of the deleted certificate\n        :type certificate_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: CertificateBundle or ClientRawResponse if raw=true\n        :rtype: ~azure.keyvault.v7_0.models.CertificateBundle or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`KeyVaultErrorException<azure.keyvault.v7_0.models.KeyVaultErrorException>`", "id": "f35772:c1:m58"}
{"signature": "def purge_deleted_storage_account(<EOL>self, vault_base_url, storage_account_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.purge_deleted_storage_account.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_base_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", storage_account_name, '<STR_LIT:str>', pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.KeyVaultErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Permanently deletes the specified storage account.\n\n        The purge deleted storage account operation removes the secret\n        permanently, without the possibility of recovery. This operation can\n        only be performed on a soft-delete enabled vault. This operation\n        requires the storage/purge permission.\n\n        :param vault_base_url: The vault name, for example\n         https://myvault.vault.azure.net.\n        :type vault_base_url: str\n        :param storage_account_name: The name of the storage account.\n        :type storage_account_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`KeyVaultErrorException<azure.keyvault.v7_0.models.KeyVaultErrorException>`", "id": "f35772:c1:m62"}
{"signature": "def recover_deleted_sas_definition(<EOL>self, vault_base_url, storage_account_name, sas_definition_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.recover_deleted_sas_definition.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_base_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", storage_account_name, '<STR_LIT:str>', pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", sas_definition_name, '<STR_LIT:str>', pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.KeyVaultErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Recovers the deleted SAS definition.\n\n        Recovers the deleted SAS definition for the specified storage account.\n        This operation can only be performed on a soft-delete enabled vault.\n        This operation requires the storage/recover permission.\n\n        :param vault_base_url: The vault name, for example\n         https://myvault.vault.azure.net.\n        :type vault_base_url: str\n        :param storage_account_name: The name of the storage account.\n        :type storage_account_name: str\n        :param sas_definition_name: The name of the SAS definition.\n        :type sas_definition_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SasDefinitionBundle or ClientRawResponse if raw=true\n        :rtype: ~azure.keyvault.v7_0.models.SasDefinitionBundle or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`KeyVaultErrorException<azure.keyvault.v7_0.models.KeyVaultErrorException>`", "id": "f35772:c1:m74"}
{"signature": "def import_certificate(<EOL>self, vault_base_url, certificate_name, base64_encoded_certificate, password=None, certificate_policy=None, certificate_attributes=None, tags=None, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.CertificateImportParameters(base64_encoded_certificate=base64_encoded_certificate, password=password, certificate_policy=certificate_policy, certificate_attributes=certificate_attributes, tags=tags)<EOL>url = self.import_certificate.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_base_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", certificate_name, '<STR_LIT:str>', pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, body_content, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.KeyVaultErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Imports a certificate into a specified key vault.\n\n        Imports an existing valid certificate, containing a private key, into\n        Azure Key Vault. The certificate to be imported can be in either PFX or\n        PEM format. If the certificate is in PEM format the PEM file must\n        contain the key as well as x509 certificates. This operation requires\n        the certificates/import permission.\n\n        :param vault_base_url: The vault name, for example\n         https://myvault.vault.azure.net.\n        :type vault_base_url: str\n        :param certificate_name: The name of the certificate.\n        :type certificate_name: str\n        :param base64_encoded_certificate: Base64 encoded representation of\n         the certificate object to import. This certificate needs to contain\n         the private key.\n        :type base64_encoded_certificate: str\n        :param password: If the private key in base64EncodedCertificate is\n         encrypted, the password used for encryption.\n        :type password: str\n        :param certificate_policy: The management policy for the certificate.\n        :type certificate_policy:\n         ~azure.keyvault.v7_0.models.CertificatePolicy\n        :param certificate_attributes: The attributes of the certificate\n         (optional).\n        :type certificate_attributes:\n         ~azure.keyvault.v7_0.models.CertificateAttributes\n        :param tags: Application specific metadata in the form of key-value\n         pairs.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: CertificateBundle or ClientRawResponse if raw=true\n        :rtype: ~azure.keyvault.v7_0.models.CertificateBundle or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`KeyVaultErrorException<azure.keyvault.v7_0.models.KeyVaultErrorException>`", "id": "f35772:c1:m43"}
{"signature": "def verify(<EOL>self, vault_base_url, key_name, key_version, algorithm, digest, signature, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.KeyVerifyParameters(algorithm=algorithm, digest=digest, signature=signature)<EOL>url = self.verify.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_base_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", key_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", key_version, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, body_content, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.KeyVaultErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Verifies a signature using a specified key.\n\n        The VERIFY operation is applicable to symmetric keys stored in Azure\n        Key Vault. VERIFY is not strictly necessary for asymmetric keys stored\n        in Azure Key Vault since signature verification can be performed using\n        the public portion of the key but this operation is supported as a\n        convenience for callers that only have a key-reference and not the\n        public portion of the key. This operation requires the keys/verify\n        permission.\n\n        :param vault_base_url: The vault name, for example\n         https://myvault.vault.azure.net.\n        :type vault_base_url: str\n        :param key_name: The name of the key.\n        :type key_name: str\n        :param key_version: The version of the key.\n        :type key_version: str\n        :param algorithm: The signing/verification algorithm. For more\n         information on possible algorithm types, see\n         JsonWebKeySignatureAlgorithm. Possible values include: 'PS256',\n         'PS384', 'PS512', 'RS256', 'RS384', 'RS512', 'RSNULL', 'ES256',\n         'ES384', 'ES512', 'ES256K'\n        :type algorithm: str or\n         ~azure.keyvault.v7_0.models.JsonWebKeySignatureAlgorithm\n        :param digest: The digest used for signing.\n        :type digest: bytes\n        :param signature: The signature to be verified.\n        :type signature: bytes\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: KeyVerifyResult or ClientRawResponse if raw=true\n        :rtype: ~azure.keyvault.v7_0.models.KeyVerifyResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`KeyVaultErrorException<azure.keyvault.v7_0.models.KeyVaultErrorException>`", "id": "f35772:c1:m13"}
{"signature": "def backup_storage_account(<EOL>self, vault_base_url, storage_account_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.backup_storage_account.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_base_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", storage_account_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.KeyVaultErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Backs up the specified storage account.\n\n        Requests that a backup of the specified storage account be downloaded\n        to the client. This operation requires the storage/backup permission.\n\n        :param vault_base_url: The vault name, for example\n         https://myvault.vault.azure.net.\n        :type vault_base_url: str\n        :param storage_account_name: The name of the storage account.\n        :type storage_account_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: BackupStorageResult or ClientRawResponse if raw=true\n        :rtype: ~azure.keyvault.v7_0.models.BackupStorageResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`KeyVaultErrorException<azure.keyvault.v7_0.models.KeyVaultErrorException>`", "id": "f35772:c1:m64"}
{"signature": "def get_deleted_keys(<EOL>self, vault_base_url, maxresults=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.get_deleted_keys.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_base_url, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if maxresults is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", maxresults, '<STR_LIT:int>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.KeyVaultErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.DeletedKeyItemPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.DeletedKeyItemPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists the deleted keys in the specified vault.\n\n        Retrieves a list of the keys in the Key Vault as JSON Web Key\n        structures that contain the public part of a deleted key. This\n        operation includes deletion-specific information. The Get Deleted Keys\n        operation is applicable for vaults enabled for soft-delete. While the\n        operation can be invoked on any vault, it will return an error if\n        invoked on a non soft-delete enabled vault. This operation requires the\n        keys/list permission.\n\n        :param vault_base_url: The vault name, for example\n         https://myvault.vault.azure.net.\n        :type vault_base_url: str\n        :param maxresults: Maximum number of results to return in a page. If\n         not specified the service will return up to 25 results.\n        :type maxresults: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of DeletedKeyItem\n        :rtype:\n         ~azure.keyvault.v7_0.models.DeletedKeyItemPaged[~azure.keyvault.v7_0.models.DeletedKeyItem]\n        :raises:\n         :class:`KeyVaultErrorException<azure.keyvault.v7_0.models.KeyVaultErrorException>`", "id": "f35772:c1:m16"}
{"signature": "def get_deleted_sas_definition(<EOL>self, vault_base_url, storage_account_name, sas_definition_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_deleted_sas_definition.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_base_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", storage_account_name, '<STR_LIT:str>', pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", sas_definition_name, '<STR_LIT:str>', pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.KeyVaultErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified deleted sas definition.\n\n        The Get Deleted SAS Definition operation returns the specified deleted\n        SAS definition along with its attributes. This operation requires the\n        storage/getsas permission.\n\n        :param vault_base_url: The vault name, for example\n         https://myvault.vault.azure.net.\n        :type vault_base_url: str\n        :param storage_account_name: The name of the storage account.\n        :type storage_account_name: str\n        :param sas_definition_name: The name of the SAS definition.\n        :type sas_definition_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DeletedSasDefinitionBundle or ClientRawResponse if raw=true\n        :rtype: ~azure.keyvault.v7_0.models.DeletedSasDefinitionBundle or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`KeyVaultErrorException<azure.keyvault.v7_0.models.KeyVaultErrorException>`", "id": "f35772:c1:m73"}
{"signature": "def backup_certificate(<EOL>self, vault_base_url, certificate_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.backup_certificate.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_base_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", certificate_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.KeyVaultErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Backs up the specified certificate.\n\n        Requests that a backup of the specified certificate be downloaded to\n        the client. All versions of the certificate will be downloaded. This\n        operation requires the certificates/backup permission.\n\n        :param vault_base_url: The vault name, for example\n         https://myvault.vault.azure.net.\n        :type vault_base_url: str\n        :param certificate_name: The name of the certificate.\n        :type certificate_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: BackupCertificateResult or ClientRawResponse if raw=true\n        :rtype: ~azure.keyvault.v7_0.models.BackupCertificateResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`KeyVaultErrorException<azure.keyvault.v7_0.models.KeyVaultErrorException>`", "id": "f35772:c1:m53"}
{"signature": "def update_key(<EOL>self, vault_base_url, key_name, key_version, key_ops=None, key_attributes=None, tags=None, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.KeyUpdateParameters(key_ops=key_ops, key_attributes=key_attributes, tags=tags)<EOL>url = self.update_key.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_base_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", key_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", key_version, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, body_content, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.KeyVaultErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "The update key operation changes specified attributes of a stored key\n        and can be applied to any key type and key version stored in Azure Key\n        Vault.\n\n        In order to perform this operation, the key must already exist in the\n        Key Vault. Note: The cryptographic material of a key itself cannot be\n        changed. This operation requires the keys/update permission.\n\n        :param vault_base_url: The vault name, for example\n         https://myvault.vault.azure.net.\n        :type vault_base_url: str\n        :param key_name: The name of key to update.\n        :type key_name: str\n        :param key_version: The version of the key to update.\n        :type key_version: str\n        :param key_ops: Json web key operations. For more information on\n         possible key operations, see JsonWebKeyOperation.\n        :type key_ops: list[str or\n         ~azure.keyvault.v7_0.models.JsonWebKeyOperation]\n        :param key_attributes:\n        :type key_attributes: ~azure.keyvault.v7_0.models.KeyAttributes\n        :param tags: Application specific metadata in the form of key-value\n         pairs.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: KeyBundle or ClientRawResponse if raw=true\n        :rtype: ~azure.keyvault.v7_0.models.KeyBundle or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`KeyVaultErrorException<azure.keyvault.v7_0.models.KeyVaultErrorException>`", "id": "f35772:c1:m4"}
{"signature": "def get_certificate_operation(<EOL>self, vault_base_url, certificate_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_certificate_operation.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_base_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", certificate_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.KeyVaultErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the creation operation of a certificate.\n\n        Gets the creation operation associated with a specified certificate.\n        This operation requires the certificates/get permission.\n\n        :param vault_base_url: The vault name, for example\n         https://myvault.vault.azure.net.\n        :type vault_base_url: str\n        :param certificate_name: The name of the certificate.\n        :type certificate_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: CertificateOperation or ClientRawResponse if raw=true\n        :rtype: ~azure.keyvault.v7_0.models.CertificateOperation or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`KeyVaultErrorException<azure.keyvault.v7_0.models.KeyVaultErrorException>`", "id": "f35772:c1:m50"}
{"signature": "def delete_secret(<EOL>self, vault_base_url, secret_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete_secret.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_base_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", secret_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.KeyVaultErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Deletes a secret from a specified key vault.\n\n        The DELETE operation applies to any secret stored in Azure Key Vault.\n        DELETE cannot be applied to an individual version of a secret. This\n        operation requires the secrets/delete permission.\n\n        :param vault_base_url: The vault name, for example\n         https://myvault.vault.azure.net.\n        :type vault_base_url: str\n        :param secret_name: The name of the secret.\n        :type secret_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DeletedSecretBundle or ClientRawResponse if raw=true\n        :rtype: ~azure.keyvault.v7_0.models.DeletedSecretBundle or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`KeyVaultErrorException<azure.keyvault.v7_0.models.KeyVaultErrorException>`", "id": "f35772:c1:m21"}
{"signature": "def get_sas_definitions(<EOL>self, vault_base_url, storage_account_name, maxresults=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.get_sas_definitions.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_base_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", storage_account_name, '<STR_LIT:str>', pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if maxresults is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", maxresults, '<STR_LIT:int>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.KeyVaultErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SasDefinitionItemPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SasDefinitionItemPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List storage SAS definitions for the given storage account. This\n        operation requires the storage/listsas permission.\n\n        :param vault_base_url: The vault name, for example\n         https://myvault.vault.azure.net.\n        :type vault_base_url: str\n        :param storage_account_name: The name of the storage account.\n        :type storage_account_name: str\n        :param maxresults: Maximum number of results to return in a page. If\n         not specified the service will return up to 25 results.\n        :type maxresults: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of SasDefinitionItem\n        :rtype:\n         ~azure.keyvault.v7_0.models.SasDefinitionItemPaged[~azure.keyvault.v7_0.models.SasDefinitionItem]\n        :raises:\n         :class:`KeyVaultErrorException<azure.keyvault.v7_0.models.KeyVaultErrorException>`", "id": "f35772:c1:m71"}
{"signature": "def get_deleted_sas_definitions(<EOL>self, vault_base_url, storage_account_name, maxresults=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.get_deleted_sas_definitions.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_base_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", storage_account_name, '<STR_LIT:str>', pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if maxresults is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", maxresults, '<STR_LIT:int>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.KeyVaultErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.DeletedSasDefinitionItemPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.DeletedSasDefinitionItemPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists deleted SAS definitions for the specified vault and storage\n        account.\n\n        The Get Deleted Sas Definitions operation returns the SAS definitions\n        that have been deleted for a vault enabled for soft-delete. This\n        operation requires the storage/listsas permission.\n\n        :param vault_base_url: The vault name, for example\n         https://myvault.vault.azure.net.\n        :type vault_base_url: str\n        :param storage_account_name: The name of the storage account.\n        :type storage_account_name: str\n        :param maxresults: Maximum number of results to return in a page. If\n         not specified the service will return up to 25 results.\n        :type maxresults: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of DeletedSasDefinitionItem\n        :rtype:\n         ~azure.keyvault.v7_0.models.DeletedSasDefinitionItemPaged[~azure.keyvault.v7_0.models.DeletedSasDefinitionItem]\n        :raises:\n         :class:`KeyVaultErrorException<azure.keyvault.v7_0.models.KeyVaultErrorException>`", "id": "f35772:c1:m72"}
{"signature": "def delete_certificate_issuer(<EOL>self, vault_base_url, issuer_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete_certificate_issuer.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_base_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", issuer_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.KeyVaultErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Deletes the specified certificate issuer.\n\n        The DeleteCertificateIssuer operation permanently removes the specified\n        certificate issuer from the vault. This operation requires the\n        certificates/manageissuers/deleteissuers permission.\n\n        :param vault_base_url: The vault name, for example\n         https://myvault.vault.azure.net.\n        :type vault_base_url: str\n        :param issuer_name: The name of the issuer.\n        :type issuer_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: IssuerBundle or ClientRawResponse if raw=true\n        :rtype: ~azure.keyvault.v7_0.models.IssuerBundle or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`KeyVaultErrorException<azure.keyvault.v7_0.models.KeyVaultErrorException>`", "id": "f35772:c1:m41"}
{"signature": "def backup_key(<EOL>self, vault_base_url, key_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.backup_key.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_base_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", key_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.KeyVaultErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Requests that a backup of the specified key be downloaded to the\n        client.\n\n        The Key Backup operation exports a key from Azure Key Vault in a\n        protected form. Note that this operation does NOT return key material\n        in a form that can be used outside the Azure Key Vault system, the\n        returned key material is either protected to a Azure Key Vault HSM or\n        to Azure Key Vault itself. The intent of this operation is to allow a\n        client to GENERATE a key in one Azure Key Vault instance, BACKUP the\n        key, and then RESTORE it into another Azure Key Vault instance. The\n        BACKUP operation may be used to export, in protected form, any key type\n        from Azure Key Vault. Individual versions of a key cannot be backed up.\n        BACKUP / RESTORE can be performed within geographical boundaries only;\n        meaning that a BACKUP from one geographical area cannot be restored to\n        another geographical area. For example, a backup from the US\n        geographical area cannot be restored in an EU geographical area. This\n        operation requires the key/backup permission.\n\n        :param vault_base_url: The vault name, for example\n         https://myvault.vault.azure.net.\n        :type vault_base_url: str\n        :param key_name: The name of the key.\n        :type key_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: BackupKeyResult or ClientRawResponse if raw=true\n        :rtype: ~azure.keyvault.v7_0.models.BackupKeyResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`KeyVaultErrorException<azure.keyvault.v7_0.models.KeyVaultErrorException>`", "id": "f35772:c1:m8"}
{"signature": "def get_deleted_key(<EOL>self, vault_base_url, key_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_deleted_key.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_base_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", key_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.KeyVaultErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the public part of a deleted key.\n\n        The Get Deleted Key operation is applicable for soft-delete enabled\n        vaults. While the operation can be invoked on any vault, it will return\n        an error if invoked on a non soft-delete enabled vault. This operation\n        requires the keys/get permission. .\n\n        :param vault_base_url: The vault name, for example\n         https://myvault.vault.azure.net.\n        :type vault_base_url: str\n        :param key_name: The name of the key.\n        :type key_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DeletedKeyBundle or ClientRawResponse if raw=true\n        :rtype: ~azure.keyvault.v7_0.models.DeletedKeyBundle or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`KeyVaultErrorException<azure.keyvault.v7_0.models.KeyVaultErrorException>`", "id": "f35772:c1:m17"}
{"signature": "def purge_deleted_certificate(<EOL>self, vault_base_url, certificate_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.purge_deleted_certificate.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_base_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", certificate_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.KeyVaultErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Permanently deletes the specified deleted certificate.\n\n        The PurgeDeletedCertificate operation performs an irreversible deletion\n        of the specified certificate, without possibility for recovery. The\n        operation is not available if the recovery level does not specify\n        'Purgeable'. This operation requires the certificate/purge permission.\n\n        :param vault_base_url: The vault name, for example\n         https://myvault.vault.azure.net.\n        :type vault_base_url: str\n        :param certificate_name: The name of the certificate\n        :type certificate_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`KeyVaultErrorException<azure.keyvault.v7_0.models.KeyVaultErrorException>`", "id": "f35772:c1:m57"}
{"signature": "def delete_key(<EOL>self, vault_base_url, key_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete_key.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_base_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", key_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.KeyVaultErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Deletes a key of any type from storage in Azure Key Vault.\n\n        The delete key operation cannot be used to remove individual versions\n        of a key. This operation removes the cryptographic material associated\n        with the key, which means the key is not usable for Sign/Verify,\n        Wrap/Unwrap or Encrypt/Decrypt operations. This operation requires the\n        keys/delete permission.\n\n        :param vault_base_url: The vault name, for example\n         https://myvault.vault.azure.net.\n        :type vault_base_url: str\n        :param key_name: The name of the key to delete.\n        :type key_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DeletedKeyBundle or ClientRawResponse if raw=true\n        :rtype: ~azure.keyvault.v7_0.models.DeletedKeyBundle or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`KeyVaultErrorException<azure.keyvault.v7_0.models.KeyVaultErrorException>`", "id": "f35772:c1:m3"}
{"signature": "def _str_to_b64url(s, **kwargs):", "body": "return _bstr_to_b64url(s.encode(encoding='<STR_LIT:utf8>'))<EOL>", "docstring": "Serialize str into base-64 string.\n    :param str: Object to be serialized.\n    :rtype: str", "id": "f35907:m5"}
{"signature": "def __init__(self, authorization_callback=None, credentials=None):", "body": "if not authorization_callback and not credentials:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self._credentials = credentials<EOL>if not authorization_callback:<EOL><INDENT>def auth_callback(server, resource, scope, scheme):<EOL><INDENT>if self._credentials.resource != resource:<EOL><INDENT>self._credentials.resource = resource<EOL>self._credentials.set_token()<EOL><DEDENT>token = self._credentials.token<EOL>return AccessToken(scheme=token['<STR_LIT>'], token=token['<STR_LIT>'], key=None)<EOL><DEDENT>authorization_callback = auth_callback<EOL><DEDENT>self.auth = KeyVaultAuthBase(authorization_callback)<EOL>self._callback = authorization_callback<EOL>", "docstring": "Creates a new KeyVaultAuthentication instance used for authentication in the KeyVaultClient\n:param authorization_callback: A callback used to provide authentication credentials to the key vault data service.  \nThis callback should take three str arguments: authorization uri, resource, and scope, and return \na tuple of (token type, access token).\n:param credentials:: Credentials needed for the client to connect to Azure.\n:type credentials: :mod:`A msrestazure Credentials\n object<msrestazure.azure_active_directory>`", "id": "f35909:c1:m0"}
{"signature": "def refresh_session(self):", "body": "if self._credentials:<EOL><INDENT>self._credentials.refresh_session()<EOL><DEDENT>return self.signed_session()<EOL>", "docstring": "Return updated session if token has expired, attempts to\n        refresh using refresh token.\n\n        :rtype: requests.Session.", "id": "f35909:c1:m2"}
{"signature": "@property<EOL><INDENT>def managed_clusters(self):<DEDENT>", "body": "api_version = self._get_api_version('<STR_LIT>')<EOL>if api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_03_31.operations import ManagedClustersOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_08_01_preview.operations import ManagedClustersOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2019_02_01.operations import ManagedClustersOperations as OperationClass<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\".format(api_version))<EOL><DEDENT>return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))<EOL>", "docstring": "Instance depends on the API version:\n\n           * 2018-03-31: :class:`ManagedClustersOperations<azure.mgmt.containerservice.v2018_03_31.operations.ManagedClustersOperations>`\n           * 2018-08-01-preview: :class:`ManagedClustersOperations<azure.mgmt.containerservice.v2018_08_01_preview.operations.ManagedClustersOperations>`\n           * 2019-02-01: :class:`ManagedClustersOperations<azure.mgmt.containerservice.v2019_02_01.operations.ManagedClustersOperations>`", "id": "f35913:c1:m5"}
{"signature": "@property<EOL><INDENT>def container_services(self):<DEDENT>", "body": "api_version = self._get_api_version('<STR_LIT>')<EOL>if api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_07_01.operations import ContainerServicesOperations as OperationClass<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\".format(api_version))<EOL><DEDENT>return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))<EOL>", "docstring": "Instance depends on the API version:\n\n           * 2017-07-01: :class:`ContainerServicesOperations<azure.mgmt.containerservice.v2017_07_01.operations.ContainerServicesOperations>`", "id": "f35913:c1:m4"}
{"signature": "def list_cluster_admin_credentials(<EOL>self, resource_group_name, resource_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_cluster_admin_credentials.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets cluster admin credential of a managed cluster.\n\n        Gets cluster admin credential of the managed cluster with a specified\n        resource group and name.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param resource_name: The name of the managed cluster resource.\n        :type resource_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: CredentialResults or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.containerservice.v2018_08_01_preview.models.CredentialResults\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35992:c0:m5"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ManagedClusterPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ManagedClusterPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists managed clusters in the specified subscription and resource\n        group.\n\n        Lists managed clusters in the specified subscription and resource\n        group. The operation returns properties of each managed cluster.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ManagedCluster\n        :rtype:\n         ~azure.mgmt.containerservice.v2018_08_01_preview.models.ManagedClusterPaged[~azure.mgmt.containerservice.v2018_08_01_preview.models.ManagedCluster]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35992:c0:m2"}
{"signature": "def get_upgrade_profile(<EOL>self, resource_group_name, resource_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_upgrade_profile.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets upgrade profile for a managed cluster.\n\n        Gets the details of the upgrade profile for a managed cluster with a\n        specified resource group and name.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param resource_name: The name of the managed cluster resource.\n        :type resource_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ManagedClusterUpgradeProfile or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.containerservice.v2018_08_01_preview.models.ManagedClusterUpgradeProfile\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35992:c0:m3"}
{"signature": "def delete(<EOL>self, resource_group_name, resource_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>resource_name=resource_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes a managed cluster.\n\n        Deletes the managed cluster with a specified resource group and name.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param resource_name: The name of the managed cluster resource.\n        :type resource_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f35992:c0:m13"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.OperationValuePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.OperationValuePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of compute operations.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of OperationValue\n        :rtype:\n         ~azure.mgmt.containerservice.v2019_02_01.models.OperationValuePaged[~azure.mgmt.containerservice.v2019_02_01.models.OperationValue]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f36027:c0:m1"}
{"signature": "def update_tags(<EOL>self, resource_group_name, resource_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>resource_name=resource_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates tags on a managed cluster.\n\n        Updates a managed cluster with the specified tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param resource_name: The name of the managed cluster resource.\n        :type resource_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ManagedCluster or\n         ClientRawResponse<ManagedCluster> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.containerservice.v2019_02_01.models.ManagedCluster]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.containerservice.v2019_02_01.models.ManagedCluster]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f36028:c0:m11"}
{"signature": "def list(<EOL>self, resource_group_name, managed_cluster_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", managed_cluster_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.AgentPoolPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.AgentPoolPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of agent pools in the specified managed cluster.\n\n        Gets a list of agent pools in the specified managed cluster. The\n        operation returns properties of each agent pool.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param managed_cluster_name: The name of the managed cluster resource.\n        :type managed_cluster_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of AgentPool\n        :rtype:\n         ~azure.mgmt.containerservice.v2019_02_01.models.AgentPoolPaged[~azure.mgmt.containerservice.v2019_02_01.models.AgentPool]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f36029:c0:m1"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, managed_cluster_name, agent_pool_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>managed_cluster_name=managed_cluster_name,<EOL>agent_pool_name=agent_pool_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates an agent pool.\n\n        Creates or updates an agent pool in the specified managed cluster.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param managed_cluster_name: The name of the managed cluster resource.\n        :type managed_cluster_name: str\n        :param agent_pool_name: The name of the agent pool.\n        :type agent_pool_name: str\n        :param parameters: Parameters supplied to the Create or Update an\n         agent pool operation.\n        :type parameters:\n         ~azure.mgmt.containerservice.v2019_02_01.models.AgentPool\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns AgentPool or\n         ClientRawResponse<AgentPool> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.containerservice.v2019_02_01.models.AgentPool]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.containerservice.v2019_02_01.models.AgentPool]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f36029:c0:m4"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.OpenShiftManagedClusterPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.OpenShiftManagedClusterPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists OpenShift managed clusters in the specified subscription and\n        resource group.\n\n        Lists OpenShift managed clusters in the specified subscription and\n        resource group. The operation returns properties of each OpenShift\n        managed cluster.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of OpenShiftManagedCluster\n        :rtype:\n         ~azure.mgmt.containerservice.v2018_09_30_preview.models.OpenShiftManagedClusterPaged[~azure.mgmt.containerservice.v2018_09_30_preview.models.OpenShiftManagedCluster]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f36085:c0:m2"}
{"signature": "def update_tags(<EOL>self, resource_group_name, resource_name, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_tags_initial(<EOL>resource_group_name=resource_group_name,<EOL>resource_name=resource_name,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates tags on an OpenShift managed cluster.\n\n        Updates an OpenShift managed cluster with the specified tags.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param resource_name: The name of the OpenShift managed cluster\n         resource.\n        :type resource_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns OpenShiftManagedCluster\n         or ClientRawResponse<OpenShiftManagedCluster> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.containerservice.v2018_09_30_preview.models.OpenShiftManagedCluster]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.containerservice.v2018_09_30_preview.models.OpenShiftManagedCluster]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f36085:c0:m7"}
{"signature": "def get(<EOL>self, resource_group_name, resource_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a OpenShift managed cluster.\n\n        Gets the details of the managed OpenShift cluster with a specified\n        resource group and name.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param resource_name: The name of the OpenShift managed cluster\n         resource.\n        :type resource_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: OpenShiftManagedCluster or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.containerservice.v2018_09_30_preview.models.OpenShiftManagedCluster\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f36085:c0:m3"}
{"signature": "def list_by_alert_rule(<EOL>self, resource_group_name, rule_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_alert_rule.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", rule_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.IncidentPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.IncidentPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of incidents associated to an alert rule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param rule_name: The name of the rule.\n        :type rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Incident\n        :rtype:\n         ~azure.mgmt.monitor.models.IncidentPaged[~azure.mgmt.monitor.models.Incident]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f36327:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, rule_name, incident_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", rule_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", incident_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets an incident associated to an alert rule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param rule_name: The name of the rule.\n        :type rule_name: str\n        :param incident_name: The name of the incident to retrieve.\n        :type incident_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Incident or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.monitor.models.Incident or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.monitor.models.ErrorResponseException>`", "id": "f36327:c0:m1"}
{"signature": "def delete(<EOL>self, resource_uri, name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_uri, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes existing diagnostic settings for the specified resource.\n\n        :param resource_uri: The identifier of the resource.\n        :type resource_uri: str\n        :param name: The name of the diagnostic setting.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.monitor.models.ErrorResponseException>`", "id": "f36330:c0:m3"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ActivityLogAlertResourcePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ActivityLogAlertResourcePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get a list of all activity log alerts in a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ActivityLogAlertResource\n        :rtype:\n         ~azure.mgmt.monitor.models.ActivityLogAlertResourcePaged[~azure.mgmt.monitor.models.ActivityLogAlertResource]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.monitor.models.ErrorResponseException>`", "id": "f36331:c0:m6"}
{"signature": "def delete(<EOL>self, resource_group_name, activity_log_alert_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", activity_log_alert_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Delete an activity log alert.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param activity_log_alert_name: The name of the activity log alert.\n        :type activity_log_alert_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.monitor.models.ErrorResponseException>`", "id": "f36331:c0:m3"}
{"signature": "def get(<EOL>self, resource_uri, metric_name, timespan=None, interval=None, aggregation=None, sensitivities=None, result_type=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_uri, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", metric_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if timespan is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timespan, '<STR_LIT:str>')<EOL><DEDENT>if interval is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", interval, '<STR_LIT>')<EOL><DEDENT>if aggregation is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", aggregation, '<STR_LIT:str>')<EOL><DEDENT>if sensitivities is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", sensitivities, '<STR_LIT:str>')<EOL><DEDENT>if result_type is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", result_type, '<STR_LIT>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "**Gets the baseline values for a specific metric**.\n\n        :param resource_uri: The identifier of the resource. It has the\n         following structure:\n         subscriptions/{subscriptionName}/resourceGroups/{resourceGroupName}/providers/{providerName}/{resourceName}.\n         For example:\n         subscriptions/b368ca2f-e298-46b7-b0ab-012281956afa/resourceGroups/vms/providers/Microsoft.Compute/virtualMachines/vm1\n        :type resource_uri: str\n        :param metric_name: The name of the metric to retrieve the baseline\n         for.\n        :type metric_name: str\n        :param timespan: The timespan of the query. It is a string with the\n         following format 'startDateTime_ISO/endDateTime_ISO'.\n        :type timespan: str\n        :param interval: The interval (i.e. timegrain) of the query.\n        :type interval: timedelta\n        :param aggregation: The aggregation type of the metric to retrieve the\n         baseline for.\n        :type aggregation: str\n        :param sensitivities: The list of sensitivities (comma separated) to\n         retrieve.\n        :type sensitivities: str\n        :param result_type: Allows retrieving only metadata of the baseline.\n         On data request all information is retrieved. Possible values include:\n         'Data', 'Metadata'\n        :type result_type: str or ~azure.mgmt.monitor.models.ResultType\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: BaselineResponse or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.monitor.models.BaselineResponse or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.monitor.models.ErrorResponseException>`", "id": "f36332:c0:m1"}
{"signature": "def get(<EOL>self, resource_group_name, autoscale_setting_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", autoscale_setting_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets an autoscale setting.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param autoscale_setting_name: The autoscale setting name.\n        :type autoscale_setting_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: AutoscaleSettingResource or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.monitor.models.AutoscaleSettingResource or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.monitor.models.ErrorResponseException>`", "id": "f36333:c0:m4"}
{"signature": "def delete(<EOL>self, resource_group_name, autoscale_setting_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", autoscale_setting_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes and autoscale setting.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param autoscale_setting_name: The autoscale setting name.\n        :type autoscale_setting_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.monitor.models.ErrorResponseException>`", "id": "f36333:c0:m3"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, rule_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", rule_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Create or update an metric alert definition.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param rule_name: The name of the rule.\n        :type rule_name: str\n        :param parameters: The parameters of the rule to create or update.\n        :type parameters: ~azure.mgmt.monitor.models.MetricAlertResource\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: MetricAlertResource or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.monitor.models.MetricAlertResource or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.monitor.models.ErrorResponseException>`", "id": "f36334:c0:m4"}
{"signature": "def delete(<EOL>self, resource_group_name, rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", rule_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes an alert rule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param rule_name: The name of the rule.\n        :type rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f36335:c0:m2"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.AlertRuleResourcePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.AlertRuleResourcePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List the alert rules within a resource group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of AlertRuleResource\n        :rtype:\n         ~azure.mgmt.monitor.models.AlertRuleResourcePaged[~azure.mgmt.monitor.models.AlertRuleResource]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f36335:c0:m5"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.LogProfileResourcePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.LogProfileResourcePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List the log profiles.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of LogProfileResource\n        :rtype:\n         ~azure.mgmt.monitor.models.LogProfileResourcePaged[~azure.mgmt.monitor.models.LogProfileResource]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f36336:c0:m5"}
{"signature": "def delete(<EOL>self, resource_group_name, rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", rule_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes a Log Search rule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param rule_name: The name of the rule.\n        :type rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.monitor.models.ErrorResponseException>`", "id": "f36340:c0:m4"}
{"signature": "def list_by_subscription(<EOL>self, filter=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_subscription.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.LogSearchRuleResourcePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.LogSearchRuleResourcePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List the Log Search rules within a subscription group.\n\n        :param filter: The filter to apply on the operation. For more\n         information please see\n         https://msdn.microsoft.com/en-us/library/azure/dn931934.aspx\n        :type filter: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of LogSearchRuleResource\n        :rtype:\n         ~azure.mgmt.monitor.models.LogSearchRuleResourcePaged[~azure.mgmt.monitor.models.LogSearchRuleResource]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.monitor.models.ErrorResponseException>`", "id": "f36340:c0:m5"}
{"signature": "def get(<EOL>self, resource_group_name, rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", rule_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets an Log Search rule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param rule_name: The name of the rule.\n        :type rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: LogSearchRuleResource or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.monitor.models.LogSearchRuleResource or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.monitor.models.ErrorResponseException>`", "id": "f36340:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, action_group_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", action_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Delete an action group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param action_group_name: The name of the action group.\n        :type action_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.monitor.models.ErrorResponseException>`", "id": "f36341:c0:m3"}
{"signature": "def update(<EOL>self, resource_group_name, action_group_name, tags=None, enabled=True, custom_headers=None, raw=False, **operation_config):", "body": "action_group_patch = models.ActionGroupPatchBody(tags=tags, enabled=enabled)<EOL>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", action_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(action_group_patch, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Updates an existing action group's tags. To update other fields use the\n        CreateOrUpdate method.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param action_group_name: The name of the action group.\n        :type action_group_name: str\n        :param tags: Resource tags\n        :type tags: dict[str, str]\n        :param enabled: Indicates whether this action group is enabled. If an\n         action group is not enabled, then none of its actions will be\n         activated.\n        :type enabled: bool\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ActionGroupResource or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.monitor.models.ActionGroupResource or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.monitor.models.ErrorResponseException>`", "id": "f36341:c0:m4"}
{"signature": "def list(<EOL>self, resource_uri, timespan=None, interval=None, metricnames=None, aggregation=None, top=None, orderby=None, filter=None, result_type=None, metricnamespace=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_uri, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if timespan is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timespan, '<STR_LIT:str>')<EOL><DEDENT>if interval is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", interval, '<STR_LIT>')<EOL><DEDENT>if metricnames is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", metricnames, '<STR_LIT:str>')<EOL><DEDENT>if aggregation is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", aggregation, '<STR_LIT:str>')<EOL><DEDENT>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>')<EOL><DEDENT>if orderby is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", orderby, '<STR_LIT:str>')<EOL><DEDENT>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if result_type is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", result_type, '<STR_LIT>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if metricnamespace is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", metricnamespace, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "**Lists the metric values for a resource**.\n\n        :param resource_uri: The identifier of the resource.\n        :type resource_uri: str\n        :param timespan: The timespan of the query. It is a string with the\n         following format 'startDateTime_ISO/endDateTime_ISO'.\n        :type timespan: str\n        :param interval: The interval (i.e. timegrain) of the query.\n        :type interval: timedelta\n        :param metricnames: The names of the metrics (comma separated) to\n         retrieve.\n        :type metricnames: str\n        :param aggregation: The list of aggregation types (comma separated) to\n         retrieve.\n        :type aggregation: str\n        :param top: The maximum number of records to retrieve.\n         Valid only if $filter is specified.\n         Defaults to 10.\n        :type top: int\n        :param orderby: The aggregation to use for sorting results and the\n         direction of the sort.\n         Only one order can be specified.\n         Examples: sum asc.\n        :type orderby: str\n        :param filter: The **$filter** is used to reduce the set of metric\n         data returned.<br>Example:<br>Metric contains metadata A, B and\n         C.<br>- Return all time series of C where A = a1 and B = b1 or\n         b2<br>**$filter=A eq \u2018a1\u2019 and B eq \u2018b1\u2019 or B eq \u2018b2\u2019 and C eq\n         \u2018*\u2019**<br>- Invalid variant:<br>**$filter=A eq \u2018a1\u2019 and B eq \u2018b1\u2019 and C\n         eq \u2018*\u2019 or B = \u2018b2\u2019**<br>This is invalid because the logical or\n         operator cannot separate two different metadata names.<br>- Return all\n         time series where A = a1, B = b1 and C = c1:<br>**$filter=A eq \u2018a1\u2019\n         and B eq \u2018b1\u2019 and C eq \u2018c1\u2019**<br>- Return all time series where A =\n         a1<br>**$filter=A eq \u2018a1\u2019 and B eq \u2018*\u2019 and C eq \u2018*\u2019**.\n        :type filter: str\n        :param result_type: Reduces the set of data collected. The syntax\n         allowed depends on the operation. See the operation's description for\n         details. Possible values include: 'Data', 'Metadata'\n        :type result_type: str or ~azure.mgmt.monitor.models.ResultType\n        :param metricnamespace: Metric namespace to query metric definitions\n         for.\n        :type metricnamespace: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Response or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.monitor.models.Response or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.monitor.models.ErrorResponseException>`", "id": "f36342:c0:m1"}
{"signature": "def trending(<EOL>self, accept_language=None, user_agent=None, client_id=None, client_ip=None, location=None, country_code=None, market=None, safe_search=None, set_lang=None, text_decorations=None, text_format=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.trending.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>if country_code is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", country_code, '<STR_LIT:str>')<EOL><DEDENT>if market is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", market, '<STR_LIT:str>')<EOL><DEDENT>if safe_search is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", safe_search, '<STR_LIT>')<EOL><DEDENT>if set_lang is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", set_lang, '<STR_LIT:str>')<EOL><DEDENT>if text_decorations is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", text_decorations, '<STR_LIT:bool>')<EOL><DEDENT>if text_format is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", text_format, '<STR_LIT>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.x_bing_apis_sdk, '<STR_LIT:str>')<EOL>if accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", accept_language, '<STR_LIT:str>')<EOL><DEDENT>if user_agent is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", user_agent, '<STR_LIT:str>')<EOL><DEDENT>if client_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", client_id, '<STR_LIT:str>')<EOL><DEDENT>if client_ip is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", client_ip, '<STR_LIT:str>')<EOL><DEDENT>if location is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT:location>\", location, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "The Video Trending Search API lets you search on Bing and get back a\n        list of videos that are trending based on search requests made by\n        others. The videos are broken out into different categories. For\n        example, Top Music Videos. For a list of markets that support trending\n        videos, see [Trending\n        Videos](https://docs.microsoft.com/azure/cognitive-services/bing-video-search/trending-videos).\n\n        :param accept_language: A comma-delimited list of one or more\n         languages to use for user interface strings. The list is in decreasing\n         order of preference. For additional information, including expected\n         format, see\n         [RFC2616](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html).\n         This header and the\n         [setLang](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-video-api-v7-reference#setlang)\n         query parameter are mutually exclusive; do not specify both. If you\n         set this header, you must also specify the\n         [cc](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-video-api-v7-reference#cc)\n         query parameter. To determine the market to return results for, Bing\n         uses the first supported language it finds from the list and combines\n         it with the cc parameter value. If the list does not include a\n         supported language, Bing finds the closest language and market that\n         supports the request or it uses an aggregated or default market for\n         the results. To determine the market that Bing used, see the\n         BingAPIs-Market header. Use this header and the cc query parameter\n         only if you specify multiple languages. Otherwise, use the\n         [mkt](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-video-api-v7-reference#mkt)\n         and\n         [setLang](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-video-api-v7-reference#setlang)\n         query parameters. A user interface string is a string that's used as a\n         label in a user interface. There are few user interface strings in the\n         JSON response objects. Any links to Bing.com properties in the\n         response objects apply the specified language.\n        :type accept_language: str\n        :param user_agent: The user agent originating the request. Bing uses\n         the user agent to provide mobile users with an optimized experience.\n         Although optional, you are encouraged to always specify this header.\n         The user-agent should be the same string that any commonly used\n         browser sends. For information about user agents, see [RFC\n         2616](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html). The\n         following are examples of user-agent strings. Windows Phone:\n         Mozilla/5.0 (compatible; MSIE 10.0; Windows Phone 8.0; Trident/6.0;\n         IEMobile/10.0; ARM; Touch; NOKIA; Lumia 822). Android: Mozilla / 5.0\n         (Linux; U; Android 2.3.5; en - us; SCH - I500 Build / GINGERBREAD)\n         AppleWebKit / 533.1 (KHTML; like Gecko) Version / 4.0 Mobile Safari /\n         533.1. iPhone: Mozilla / 5.0 (iPhone; CPU iPhone OS 6_1 like Mac OS X)\n         AppleWebKit / 536.26 (KHTML; like Gecko) Mobile / 10B142 iPhone4; 1\n         BingWeb / 3.03.1428.20120423. PC: Mozilla / 5.0 (Windows NT 6.3;\n         WOW64; Trident / 7.0; Touch; rv:11.0) like Gecko. iPad: Mozilla / 5.0\n         (iPad; CPU OS 7_0 like Mac OS X) AppleWebKit / 537.51.1 (KHTML, like\n         Gecko) Version / 7.0 Mobile / 11A465 Safari / 9537.53\n        :type user_agent: str\n        :param client_id: Bing uses this header to provide users with\n         consistent behavior across Bing API calls. Bing often flights new\n         features and improvements, and it uses the client ID as a key for\n         assigning traffic on different flights. If you do not use the same\n         client ID for a user across multiple requests, then Bing may assign\n         the user to multiple conflicting flights. Being assigned to multiple\n         conflicting flights can lead to an inconsistent user experience. For\n         example, if the second request has a different flight assignment than\n         the first, the experience may be unexpected. Also, Bing can use the\n         client ID to tailor web results to that client ID\u2019s search history,\n         providing a richer experience for the user. Bing also uses this header\n         to help improve result rankings by analyzing the activity generated by\n         a client ID. The relevance improvements help with better quality of\n         results delivered by Bing APIs and in turn enables higher\n         click-through rates for the API consumer. IMPORTANT: Although\n         optional, you should consider this header required. Persisting the\n         client ID across multiple requests for the same end user and device\n         combination enables 1) the API consumer to receive a consistent user\n         experience, and 2) higher click-through rates via better quality of\n         results from the Bing APIs. Each user that uses your application on\n         the device must have a unique, Bing generated client ID. If you do not\n         include this header in the request, Bing generates an ID and returns\n         it in the X-MSEdge-ClientID response header. The only time that you\n         should NOT include this header in a request is the first time the user\n         uses your app on that device. Use the client ID for each Bing API\n         request that your app makes for this user on the device. Persist the\n         client ID. To persist the ID in a browser app, use a persistent HTTP\n         cookie to ensure the ID is used across all sessions. Do not use a\n         session cookie. For other apps such as mobile apps, use the device's\n         persistent storage to persist the ID. The next time the user uses your\n         app on that device, get the client ID that you persisted. Bing\n         responses may or may not include this header. If the response includes\n         this header, capture the client ID and use it for all subsequent Bing\n         requests for the user on that device. If you include the\n         X-MSEdge-ClientID, you must not include cookies in the request.\n        :type client_id: str\n        :param client_ip: The IPv4 or IPv6 address of the client device. The\n         IP address is used to discover the user's location. Bing uses the\n         location information to determine safe search behavior. Although\n         optional, you are encouraged to always specify this header and the\n         X-Search-Location header. Do not obfuscate the address (for example,\n         by changing the last octet to 0). Obfuscating the address results in\n         the location not being anywhere near the device's actual location,\n         which may result in Bing serving erroneous results.\n        :type client_ip: str\n        :param location: A semicolon-delimited list of key/value pairs that\n         describe the client's geographical location. Bing uses the location\n         information to determine safe search behavior and to return relevant\n         local content. Specify the key/value pair as <key>:<value>. The\n         following are the keys that you use to specify the user's location.\n         lat (required): The latitude of the client's location, in degrees. The\n         latitude must be greater than or equal to -90.0 and less than or equal\n         to +90.0. Negative values indicate southern latitudes and positive\n         values indicate northern latitudes. long (required): The longitude of\n         the client's location, in degrees. The longitude must be greater than\n         or equal to -180.0 and less than or equal to +180.0. Negative values\n         indicate western longitudes and positive values indicate eastern\n         longitudes. re (required): The radius, in meters, which specifies the\n         horizontal accuracy of the coordinates. Pass the value returned by the\n         device's location service. Typical values might be 22m for GPS/Wi-Fi,\n         380m for cell tower triangulation, and 18,000m for reverse IP lookup.\n         ts (optional): The UTC UNIX timestamp of when the client was at the\n         location. (The UNIX timestamp is the number of seconds since January\n         1, 1970.) head (optional): The client's relative heading or direction\n         of travel. Specify the direction of travel as degrees from 0 through\n         360, counting clockwise relative to true north. Specify this key only\n         if the sp key is nonzero. sp (optional): The horizontal velocity\n         (speed), in meters per second, that the client device is traveling.\n         alt (optional): The altitude of the client device, in meters. are\n         (optional): The radius, in meters, that specifies the vertical\n         accuracy of the coordinates. Specify this key only if you specify the\n         alt key. Although many of the keys are optional, the more information\n         that you provide, the more accurate the location results are. Although\n         optional, you are encouraged to always specify the user's geographical\n         location. Providing the location is especially important if the\n         client's IP address does not accurately reflect the user's physical\n         location (for example, if the client uses VPN). For optimal results,\n         you should include this header and the X-MSEdge-ClientIP header, but\n         at a minimum, you should include this header.\n        :type location: str\n        :param country_code: A 2-character country code of the country where\n         the results come from. This API supports only the United States\n         market. If you specify this query parameter, it must be set to us. If\n         you set this parameter, you must also specify the Accept-Language\n         header. Bing uses the first supported language it finds from the\n         languages list, and combine that language with the country code that\n         you specify to determine the market to return results for. If the\n         languages list does not include a supported language, Bing finds the\n         closest language and market that supports the request, or it may use\n         an aggregated or default market for the results instead of a specified\n         one. You should use this query parameter and the Accept-Language query\n         parameter only if you specify multiple languages; otherwise, you\n         should use the mkt and setLang query parameters. This parameter and\n         the mkt query parameter are mutually exclusive\u2014do not specify both.\n        :type country_code: str\n        :param market: The market where the results come from. Typically, mkt\n         is the country where the user is making the request from. However, it\n         could be a different country if the user is not located in a country\n         where Bing delivers results. The market must be in the form <language\n         code>-<country code>. For example, en-US. The string is case\n         insensitive. For a list of possible market values, see [Market\n         Codes](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-video-api-v7-reference#market-codes).\n         NOTE: If known, you are encouraged to always specify the market.\n         Specifying the market helps Bing route the request and return an\n         appropriate and optimal response. If you specify a market that is not\n         listed in [Market\n         Codes](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-video-api-v7-reference#market-codes),\n         Bing uses a best fit market code based on an internal mapping that is\n         subject to change. This parameter and the\n         [cc](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-video-api-v7-reference#cc)\n         query parameter are mutually exclusive\u2014do not specify both.\n        :type market: str\n        :param safe_search: Filter videos for adult content. The following are\n         the possible filter values. Off: If the request is through the Video\n         Search API, the response includes adult videos and the thumbnail\n         images of the videos are clear (non-fuzzy). If the request is through\n         the Web Search API, the response includes adult videos but the\n         thumbnail images of the videos are pixelated (fuzzy). Moderate: If the\n         request is through the Video Search API, the response does not include\n         videos with adult content. If the request is through the Web Search\n         API, the response may include videos with adult content but the\n         thumbnail images of the videos are pixelated (fuzzy). Strict: Does not\n         return videos with adult content. The default is Moderate. If the\n         request comes from a market that Bing's adult policy requires that\n         safeSearch is set to Strict, Bing ignores the safeSearch value and\n         uses Strict. If you use the site: query operator, there is the chance\n         that the response may contain adult content regardless of what the\n         safeSearch query parameter is set to. Use site: only if you are aware\n         of the content on the site and your scenario supports the possibility\n         of adult content. Possible values include: 'Off', 'Moderate', 'Strict'\n        :type safe_search: str or\n         ~azure.cognitiveservices.search.videosearch.models.SafeSearch\n        :param set_lang: The language to use for user interface strings.\n         Specify the language using the ISO 639-1 2-letter language code. For\n         example, the language code for English is EN. The default is EN\n         (English). Although optional, you should always specify the language.\n         Typically, you set setLang to the same language specified by mkt\n         unless the user wants the user interface strings displayed in a\n         different language. This parameter and the\n         [Accept-Language](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-video-api-v7-reference#acceptlanguage)\n         header are mutually exclusive; do not specify both. A user interface\n         string is a string that's used as a label in a user interface. There\n         are few user interface strings in the JSON response objects. Also, any\n         links to Bing.com properties in the response objects apply the\n         specified language.\n        :type set_lang: str\n        :param text_decorations: A Boolean value that determines whether\n         display strings contain decoration markers such as hit highlighting\n         characters. If true, the strings may include markers. The default is\n         false. To specify whether to use Unicode characters or HTML tags as\n         the markers, see the\n         [textFormat](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-video-api-v7-reference#textformat)\n         query parameter. For information about hit highlighting, see [Hit\n         Highlighting](https://docs.microsoft.com/azure/cognitive-services/bing-news-search/hit-highlighting).\n        :type text_decorations: bool\n        :param text_format: The type of markers to use for text decorations\n         (see the textDecorations query parameter). Possible values are Raw\u2014Use\n         Unicode characters to mark content that needs special formatting. The\n         Unicode characters are in the range E000 through E019. For example,\n         Bing uses E000 and E001 to mark the beginning and end of query terms\n         for hit highlighting. HTML\u2014Use HTML tags to mark content that needs\n         special formatting. For example, use <b> tags to highlight query terms\n         in display strings. The default is Raw. For display strings that\n         contain escapable HTML characters such as <, >, and &, if textFormat\n         is set to HTML, Bing escapes the characters as appropriate (for\n         example, < is escaped to &lt;). Possible values include: 'Raw', 'Html'\n        :type text_format: str or\n         ~azure.cognitiveservices.search.videosearch.models.TextFormat\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: TrendingVideos or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.cognitiveservices.search.videosearch.models.TrendingVideos or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.search.videosearch.models.ErrorResponseException>`", "id": "f36392:c0:m3"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, namespace_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>namespace_name=namespace_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a namespace. Once created, this namespace's resource\n        manifest is immutable. This operation is idempotent.\n\n        :param resource_group_name: Name of the resource group within the\n         azure subscription.\n        :type resource_group_name: str\n        :param namespace_name: The Namespace name\n        :type namespace_name: str\n        :param parameters: Parameters for creating a namespace resource.\n        :type parameters:\n         ~azure.mgmt.eventhub.v2015_08_01.models.NamespaceCreateOrUpdateParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns NamespaceResource or\n         ClientRawResponse<NamespaceResource> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.eventhub.v2015_08_01.models.NamespaceResource]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.eventhub.v2015_08_01.models.NamespaceResource]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f36445:c0:m5"}
{"signature": "def get_authorization_rule(<EOL>self, resource_group_name, namespace_name, authorization_rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_authorization_rule.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:6>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", authorization_rule_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets an AuthorizationRule for a Namespace by rule name.\n\n        :param resource_group_name: Name of the resource group within the\n         azure subscription.\n        :type resource_group_name: str\n        :param namespace_name: The Namespace name\n        :type namespace_name: str\n        :param authorization_rule_name: The authorization rule name.\n        :type authorization_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SharedAccessAuthorizationRuleResource or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.eventhub.v2015_08_01.models.SharedAccessAuthorizationRuleResource\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f36445:c0:m13"}
{"signature": "def get(<EOL>self, resource_group_name, namespace_name, event_hub_name, consumer_group_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:6>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", event_hub_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", consumer_group_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a description for the specified consumer group.\n\n        :param resource_group_name: Name of the resource group within the\n         azure subscription.\n        :type resource_group_name: str\n        :param namespace_name: The Namespace name\n        :type namespace_name: str\n        :param event_hub_name: The Event Hub name\n        :type event_hub_name: str\n        :param consumer_group_name: The consumer group name\n        :type consumer_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ConsumerGroupResource or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.eventhub.v2015_08_01.models.ConsumerGroupResource\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f36446:c0:m3"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, namespace_name, event_hub_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:6>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", event_hub_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or updates a new Event Hub as a nested resource within a\n        Namespace.\n\n        :param resource_group_name: Name of the resource group within the\n         azure subscription.\n        :type resource_group_name: str\n        :param namespace_name: The Namespace name\n        :type namespace_name: str\n        :param event_hub_name: The Event Hub name\n        :type event_hub_name: str\n        :param parameters: Parameters supplied to create an Event Hub\n         resource.\n        :type parameters:\n         ~azure.mgmt.eventhub.v2015_08_01.models.EventHubCreateOrUpdateParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: EventHubResource or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.eventhub.v2015_08_01.models.EventHubResource or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f36447:c0:m2"}
{"signature": "def delete_authorization_rule(<EOL>self, resource_group_name, namespace_name, event_hub_name, authorization_rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete_authorization_rule.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:6>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", event_hub_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", authorization_rule_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes an Event Hub AuthorizationRule.\n\n        :param resource_group_name: Name of the resource group within the\n         azure subscription.\n        :type resource_group_name: str\n        :param namespace_name: The Namespace name\n        :type namespace_name: str\n        :param event_hub_name: The Event Hub name\n        :type event_hub_name: str\n        :param authorization_rule_name: The authorization rule name.\n        :type authorization_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f36447:c0:m9"}
{"signature": "def create_or_update_authorization_rule(<EOL>self, resource_group_name, namespace_name, authorization_rule_name, rights, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.AuthorizationRule(rights=rights)<EOL>url = self.create_or_update_authorization_rule.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:6>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", authorization_rule_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or updates an AuthorizationRule for a Namespace.\n\n        :param resource_group_name: Name of the resource group within the\n         azure subscription.\n        :type resource_group_name: str\n        :param namespace_name: The Namespace name\n        :type namespace_name: str\n        :param authorization_rule_name: The authorization rule name.\n        :type authorization_rule_name: str\n        :param rights: The rights associated with the rule.\n        :type rights: list[str or\n         ~azure.mgmt.eventhub.v2017_04_01.models.AccessRights]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: AuthorizationRule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.eventhub.v2017_04_01.models.AuthorizationRule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.eventhub.v2017_04_01.models.ErrorResponseException>`", "id": "f36506:c0:m12"}
{"signature": "def get_authorization_rule(<EOL>self, resource_group_name, namespace_name, authorization_rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_authorization_rule.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:6>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", authorization_rule_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets an AuthorizationRule for a Namespace by rule name.\n\n        :param resource_group_name: Name of the resource group within the\n         azure subscription.\n        :type resource_group_name: str\n        :param namespace_name: The Namespace name\n        :type namespace_name: str\n        :param authorization_rule_name: The authorization rule name.\n        :type authorization_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: AuthorizationRule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.eventhub.v2017_04_01.models.AuthorizationRule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.eventhub.v2017_04_01.models.ErrorResponseException>`", "id": "f36506:c0:m14"}
{"signature": "def get_network_rule_set(<EOL>self, resource_group_name, namespace_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_network_rule_set.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:6>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets NetworkRuleSet for a Namespace.\n\n        :param resource_group_name: Name of the resource group within the\n         azure subscription.\n        :type resource_group_name: str\n        :param namespace_name: The Namespace name\n        :type namespace_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: NetworkRuleSet or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.eventhub.v2017_04_01.models.NetworkRuleSet or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.eventhub.v2017_04_01.models.ErrorResponseException>`", "id": "f36506:c0:m18"}
{"signature": "def check_name_availability(<EOL>self, name, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.CheckNameAvailabilityParameter(name=name)<EOL>url = self.check_name_availability.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Check the give Namespace name availability.\n\n        :param name: Name to check the namespace name availability\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: CheckNameAvailabilityResult or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.eventhub.v2017_04_01.models.CheckNameAvailabilityResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.eventhub.v2017_04_01.models.ErrorResponseException>`", "id": "f36506:c0:m1"}
{"signature": "def get_messaging_plan(<EOL>self, resource_group_name, namespace_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_messaging_plan.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:6>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets messaging plan for specified namespace.\n\n        :param resource_group_name: Name of the resource group within the\n         azure subscription.\n        :type resource_group_name: str\n        :param namespace_name: The Namespace name\n        :type namespace_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: MessagingPlan or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.eventhub.v2017_04_01.models.MessagingPlan or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.eventhub.v2017_04_01.models.ErrorResponseException>`", "id": "f36506:c0:m10"}
{"signature": "def list_by_event_hub(<EOL>self, resource_group_name, namespace_name, event_hub_name, skip=None, top=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_event_hub.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:6>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", event_hub_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if skip is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", skip, '<STR_LIT:int>', maximum=<NUM_LIT:1000>, minimum=<NUM_LIT:0>)<EOL><DEDENT>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>', maximum=<NUM_LIT:1000>, minimum=<NUM_LIT:1>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ConsumerGroupPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ConsumerGroupPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the consumer groups in a Namespace. An empty feed is returned\n        if no consumer group exists in the Namespace.\n\n        :param resource_group_name: Name of the resource group within the\n         azure subscription.\n        :type resource_group_name: str\n        :param namespace_name: The Namespace name\n        :type namespace_name: str\n        :param event_hub_name: The Event Hub name\n        :type event_hub_name: str\n        :param skip: Skip is only used if a previous operation returned a\n         partial result. If a previous response contains a nextLink element,\n         the value of the nextLink element will include a skip parameter that\n         specifies a starting point to use for subsequent calls.\n        :type skip: int\n        :param top: May be used to limit the number of results to the most\n         recent N usageDetails.\n        :type top: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ConsumerGroup\n        :rtype:\n         ~azure.mgmt.eventhub.v2017_04_01.models.ConsumerGroupPaged[~azure.mgmt.eventhub.v2017_04_01.models.ConsumerGroup]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.eventhub.v2017_04_01.models.ErrorResponseException>`", "id": "f36507:c0:m4"}
{"signature": "def delete(<EOL>self, resource_group_name, namespace_name, event_hub_name, consumer_group_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:6>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", event_hub_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", consumer_group_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes a consumer group from the specified Event Hub and resource\n        group.\n\n        :param resource_group_name: Name of the resource group within the\n         azure subscription.\n        :type resource_group_name: str\n        :param namespace_name: The Namespace name\n        :type namespace_name: str\n        :param event_hub_name: The Event Hub name\n        :type event_hub_name: str\n        :param consumer_group_name: The consumer group name\n        :type consumer_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.eventhub.v2017_04_01.models.ErrorResponseException>`", "id": "f36507:c0:m2"}
{"signature": "def delete_authorization_rule(<EOL>self, resource_group_name, namespace_name, event_hub_name, authorization_rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete_authorization_rule.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:6>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", event_hub_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", authorization_rule_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes an Event Hub AuthorizationRule.\n\n        :param resource_group_name: Name of the resource group within the\n         azure subscription.\n        :type resource_group_name: str\n        :param namespace_name: The Namespace name\n        :type namespace_name: str\n        :param event_hub_name: The Event Hub name\n        :type event_hub_name: str\n        :param authorization_rule_name: The authorization rule name.\n        :type authorization_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.eventhub.v2017_04_01.models.ErrorResponseException>`", "id": "f36508:c0:m8"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, namespace_name, event_hub_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:6>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", event_hub_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or updates a new Event Hub as a nested resource within a\n        Namespace.\n\n        :param resource_group_name: Name of the resource group within the\n         azure subscription.\n        :type resource_group_name: str\n        :param namespace_name: The Namespace name\n        :type namespace_name: str\n        :param event_hub_name: The Event Hub name\n        :type event_hub_name: str\n        :param parameters: Parameters supplied to create an Event Hub\n         resource.\n        :type parameters: ~azure.mgmt.eventhub.v2017_04_01.models.Eventhub\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Eventhub or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.eventhub.v2017_04_01.models.Eventhub or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.eventhub.v2017_04_01.models.ErrorResponseException>`", "id": "f36508:c0:m2"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, namespace_name, alias, partner_namespace=None, alternate_name=None, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.ArmDisasterRecovery(partner_namespace=partner_namespace, alternate_name=alternate_name)<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:6>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", alias, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or updates a new Alias(Disaster Recovery configuration).\n\n        :param resource_group_name: Name of the resource group within the\n         azure subscription.\n        :type resource_group_name: str\n        :param namespace_name: The Namespace name\n        :type namespace_name: str\n        :param alias: The Disaster Recovery configuration name\n        :type alias: str\n        :param partner_namespace: ARM Id of the Primary/Secondary eventhub\n         namespace name, which is part of GEO DR pairing\n        :type partner_namespace: str\n        :param alternate_name: Alternate name specified when alias and\n         namespace names are same.\n        :type alternate_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ArmDisasterRecovery or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.eventhub.v2017_04_01.models.ArmDisasterRecovery or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.eventhub.v2017_04_01.models.ErrorResponseException>`", "id": "f36510:c0:m3"}
{"signature": "def get_authorization_rule(<EOL>self, resource_group_name, namespace_name, alias, authorization_rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_authorization_rule.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:6>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", alias, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", authorization_rule_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets an AuthorizationRule for a Namespace by rule name.\n\n        :param resource_group_name: Name of the resource group within the\n         azure subscription.\n        :type resource_group_name: str\n        :param namespace_name: The Namespace name\n        :type namespace_name: str\n        :param alias: The Disaster Recovery configuration name\n        :type alias: str\n        :param authorization_rule_name: The authorization rule name.\n        :type authorization_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: AuthorizationRule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.eventhub.v2017_04_01.models.AuthorizationRule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.eventhub.v2017_04_01.models.ErrorResponseException>`", "id": "f36510:c0:m9"}
{"signature": "def list_keys(<EOL>self, resource_group_name, namespace_name, alias, authorization_rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_keys.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:6>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", alias, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", authorization_rule_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the primary and secondary connection strings for the Namespace.\n\n        :param resource_group_name: Name of the resource group within the\n         azure subscription.\n        :type resource_group_name: str\n        :param namespace_name: The Namespace name\n        :type namespace_name: str\n        :param alias: The Disaster Recovery configuration name\n        :type alias: str\n        :param authorization_rule_name: The authorization rule name.\n        :type authorization_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: AccessKeys or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.eventhub.v2017_04_01.models.AccessKeys or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.eventhub.v2017_04_01.models.ErrorResponseException>`", "id": "f36510:c0:m10"}
{"signature": "def put(<EOL>self, resource_group_name, cluster_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._put_initial(<EOL>resource_group_name=resource_group_name,<EOL>cluster_name=cluster_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates an instance of an Event Hubs Cluster.\n\n        :param resource_group_name: Name of the resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param cluster_name: The name of the Event Hubs Cluster.\n        :type cluster_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Cluster or\n         ClientRawResponse<Cluster> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.eventhub.v2018_01_01_preview.models.Cluster]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.eventhub.v2018_01_01_preview.models.Cluster]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.eventhub.v2018_01_01_preview.models.ErrorResponseException>`", "id": "f36556:c0:m5"}
{"signature": "def list_namespaces(<EOL>self, resource_group_name, cluster_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_namespaces.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", cluster_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:6>)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List all Event Hubs Namespace IDs in an Event Hubs Dedicated Cluster.\n\n        :param resource_group_name: Name of the resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param cluster_name: The name of the Event Hubs Cluster.\n        :type cluster_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: EHNamespaceIdListResult or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.eventhub.v2018_01_01_preview.models.EHNamespaceIdListResult\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.eventhub.v2018_01_01_preview.models.ErrorResponseException>`", "id": "f36556:c0:m10"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ClusterPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ClusterPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists the available Event Hubs Clusters within an ARM resource group.\n\n        :param resource_group_name: Name of the resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Cluster\n        :rtype:\n         ~azure.mgmt.eventhub.v2018_01_01_preview.models.ClusterPaged[~azure.mgmt.eventhub.v2018_01_01_preview.models.Cluster]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.eventhub.v2018_01_01_preview.models.ErrorResponseException>`", "id": "f36556:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, cluster_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", cluster_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:6>)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the resource description of the specified Event Hubs Cluster.\n\n        :param resource_group_name: Name of the resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param cluster_name: The name of the Event Hubs Cluster.\n        :type cluster_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Cluster or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.eventhub.v2018_01_01_preview.models.Cluster or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.eventhub.v2018_01_01_preview.models.ErrorResponseException>`", "id": "f36556:c0:m3"}
{"signature": "def create_or_update_network_rule_set(<EOL>self, resource_group_name, namespace_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update_network_rule_set.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:6>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Create or update NetworkRuleSet for a Namespace.\n\n        :param resource_group_name: Name of the resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param namespace_name: The Namespace name\n        :type namespace_name: str\n        :param parameters: The Namespace IpFilterRule.\n        :type parameters:\n         ~azure.mgmt.eventhub.v2018_01_01_preview.models.NetworkRuleSet\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: NetworkRuleSet or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.eventhub.v2018_01_01_preview.models.NetworkRuleSet\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.eventhub.v2018_01_01_preview.models.ErrorResponseException>`", "id": "f36558:c0:m17"}
{"signature": "def create_or_update_ip_filter_rule(<EOL>self, resource_group_name, namespace_name, ip_filter_rule_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update_ip_filter_rule.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:6>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", ip_filter_rule_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or updates an IpFilterRule for a Namespace.\n\n        :param resource_group_name: Name of the resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param namespace_name: The Namespace name\n        :type namespace_name: str\n        :param ip_filter_rule_name: The IP Filter Rule name.\n        :type ip_filter_rule_name: str\n        :param parameters: The Namespace IpFilterRule.\n        :type parameters:\n         ~azure.mgmt.eventhub.v2018_01_01_preview.models.IpFilterRule\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: IpFilterRule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.eventhub.v2018_01_01_preview.models.IpFilterRule\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.eventhub.v2018_01_01_preview.models.ErrorResponseException>`", "id": "f36558:c0:m10"}
{"signature": "@property<EOL><INDENT>def operations(self):<DEDENT>", "body": "api_version = self._get_api_version('<STR_LIT>')<EOL>if api_version == '<STR_LIT>':<EOL><INDENT>from .v2015_08_01.operations import Operations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_04_01.operations import Operations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_01_01_preview.operations import Operations as OperationClass<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\".format(api_version))<EOL><DEDENT>return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))<EOL>", "docstring": "Instance depends on the API version:\n\n           * 2015-08-01: :class:`Operations<azure.mgmt.eventhub.v2015_08_01.operations.Operations>`\n           * 2017-04-01: :class:`Operations<azure.mgmt.eventhub.v2017_04_01.operations.Operations>`\n           * 2018-01-01-preview: :class:`Operations<azure.mgmt.eventhub.v2018_01_01_preview.operations.Operations>`", "id": "f36562:c1:m9"}
{"signature": "@property<EOL><INDENT>def clusters(self):<DEDENT>", "body": "api_version = self._get_api_version('<STR_LIT>')<EOL>if api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_01_01_preview.operations import ClustersOperations as OperationClass<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\".format(api_version))<EOL><DEDENT>return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))<EOL>", "docstring": "Instance depends on the API version:\n\n           * 2018-01-01-preview: :class:`ClustersOperations<azure.mgmt.eventhub.v2018_01_01_preview.operations.ClustersOperations>`", "id": "f36562:c1:m3"}
{"signature": "def update(<EOL>self, body, resource_group_name, account_name, pool_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", pool_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(body, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Patch a capacity pool.\n\n        :param body: Capacity pool object supplied in the body of the\n         operation.\n        :type body: ~azure.mgmt.netapp.models.CapacityPoolPatch\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param account_name: The name of the NetApp account\n        :type account_name: str\n        :param pool_name: The name of the capacity pool\n        :type pool_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: CapacityPool or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.netapp.models.CapacityPool or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorException<azure.mgmt.netapp.models.ErrorException>`", "id": "f36618:c0:m5"}
{"signature": "def list(<EOL>self, resource_group_name, account_name, pool_name, volume_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", pool_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", volume_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SnapshotPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SnapshotPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List snapshots.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param account_name: The name of the NetApp account\n        :type account_name: str\n        :param pool_name: The name of the capacity pool\n        :type pool_name: str\n        :param volume_name: The name of the volume\n        :type volume_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Snapshot\n        :rtype:\n         ~azure.mgmt.netapp.models.SnapshotPaged[~azure.mgmt.netapp.models.Snapshot]\n        :raises:\n         :class:`ErrorException<azure.mgmt.netapp.models.ErrorException>`", "id": "f36622:c0:m1"}
{"signature": "def create_or_update(<EOL>self, body, resource_group_name, account_name, pool_name, volume_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>body=body,<EOL>resource_group_name=resource_group_name,<EOL>account_name=account_name,<EOL>pool_name=pool_name,<EOL>volume_name=volume_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Create or update a volume.\n\n        :param body: Volume object supplied in the body of the operation.\n        :type body: ~azure.mgmt.netapp.models.Volume\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param account_name: The name of the NetApp account\n        :type account_name: str\n        :param pool_name: The name of the capacity pool\n        :type pool_name: str\n        :param volume_name: The name of the volume\n        :type volume_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Volume or\n         ClientRawResponse<Volume> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.netapp.models.Volume]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.netapp.models.Volume]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.netapp.models.ErrorException>`", "id": "f36624:c0:m4"}
{"signature": "def update(<EOL>self, body, resource_group_name, account_name, pool_name, volume_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", pool_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", volume_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(body, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Patch a volume.\n\n        :param body: Volume object supplied in the body of the operation.\n        :type body: ~azure.mgmt.netapp.models.VolumePatch\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param account_name: The name of the NetApp account\n        :type account_name: str\n        :param pool_name: The name of the capacity pool\n        :type pool_name: str\n        :param volume_name: The name of the volume\n        :type volume_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Volume or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.netapp.models.Volume or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorException<azure.mgmt.netapp.models.ErrorException>`", "id": "f36624:c0:m5"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, account_name, firewall_rule_name, start_ip_address, end_ip_address, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.CreateOrUpdateFirewallRuleParameters(start_ip_address=start_ip_address, end_ip_address=end_ip_address)<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", firewall_rule_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, body_content, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or updates the specified firewall rule. During update, the\n        firewall rule with the specified name will be replaced with this new\n        firewall rule.\n\n        :param resource_group_name: The name of the Azure resource group.\n        :type resource_group_name: str\n        :param account_name: The name of the Data Lake Store account.\n        :type account_name: str\n        :param firewall_rule_name: The name of the firewall rule to create or\n         update.\n        :type firewall_rule_name: str\n        :param start_ip_address: The start IP address for the firewall rule.\n         This can be either ipv4 or ipv6. Start and End should be in the same\n         protocol.\n        :type start_ip_address: str\n        :param end_ip_address: The end IP address for the firewall rule. This\n         can be either ipv4 or ipv6. Start and End should be in the same\n         protocol.\n        :type end_ip_address: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: FirewallRule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.datalake.store.models.FirewallRule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f36700:c0:m2"}
{"signature": "def update(<EOL>self, resource_group_name, account_name, firewall_rule_name, start_ip_address=None, end_ip_address=None, custom_headers=None, raw=False, **operation_config):", "body": "parameters = None<EOL>if start_ip_address is not None or end_ip_address is not None:<EOL><INDENT>parameters = models.UpdateFirewallRuleParameters(start_ip_address=start_ip_address, end_ip_address=end_ip_address)<EOL><DEDENT>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", firewall_rule_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if parameters is not None:<EOL><INDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>body_content = None<EOL><DEDENT>request = self._client.patch(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, body_content, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Updates the specified firewall rule.\n\n        :param resource_group_name: The name of the Azure resource group.\n        :type resource_group_name: str\n        :param account_name: The name of the Data Lake Store account.\n        :type account_name: str\n        :param firewall_rule_name: The name of the firewall rule to update.\n        :type firewall_rule_name: str\n        :param start_ip_address: The start IP address for the firewall rule.\n         This can be either ipv4 or ipv6. Start and End should be in the same\n         protocol.\n        :type start_ip_address: str\n        :param end_ip_address: The end IP address for the firewall rule. This\n         can be either ipv4 or ipv6. Start and End should be in the same\n         protocol.\n        :type end_ip_address: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: FirewallRule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.datalake.store.models.FirewallRule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f36700:c0:m4"}
{"signature": "def create(<EOL>self, resource_group_name, account_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_initial(<EOL>resource_group_name=resource_group_name,<EOL>account_name=account_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates the specified Data Lake Store account.\n\n        :param resource_group_name: The name of the Azure resource group.\n        :type resource_group_name: str\n        :param account_name: The name of the Data Lake Store account.\n        :type account_name: str\n        :param parameters: Parameters supplied to create the Data Lake Store\n         account.\n        :type parameters:\n         ~azure.mgmt.datalake.store.models.CreateDataLakeStoreAccountParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns DataLakeStoreAccount or\n         ClientRawResponse<DataLakeStoreAccount> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.datalake.store.models.DataLakeStoreAccount]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.datalake.store.models.DataLakeStoreAccount]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f36703:c0:m4"}
{"signature": "def enable_key_vault(<EOL>self, resource_group_name, account_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.enable_key_vault.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Attempts to enable a user managed Key Vault for encryption of the\n        specified Data Lake Store account.\n\n        :param resource_group_name: The name of the Azure resource group.\n        :type resource_group_name: str\n        :param account_name: The name of the Data Lake Store account.\n        :type account_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f36703:c0:m10"}
{"signature": "def get(<EOL>self, resource_group_name, account_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified Data Lake Store account.\n\n        :param resource_group_name: The name of the Azure resource group.\n        :type resource_group_name: str\n        :param account_name: The name of the Data Lake Store account.\n        :type account_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DataLakeStoreAccount or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.datalake.store.models.DataLakeStoreAccount or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f36703:c0:m5"}
{"signature": "def update(<EOL>self, resource_group_name, account_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_initial(<EOL>resource_group_name=resource_group_name,<EOL>account_name=account_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates the specified Data Lake Store account information.\n\n        :param resource_group_name: The name of the Azure resource group.\n        :type resource_group_name: str\n        :param account_name: The name of the Data Lake Store account.\n        :type account_name: str\n        :param parameters: Parameters supplied to update the Data Lake Store\n         account.\n        :type parameters:\n         ~azure.mgmt.datalake.store.models.UpdateDataLakeStoreAccountParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns DataLakeStoreAccount or\n         ClientRawResponse<DataLakeStoreAccount> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.datalake.store.models.DataLakeStoreAccount]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.datalake.store.models.DataLakeStoreAccount]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f36703:c0:m7"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, account_name, trusted_id_provider_name, id_provider, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.CreateOrUpdateTrustedIdProviderParameters(id_provider=id_provider)<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", trusted_id_provider_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, body_content, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or updates the specified trusted identity provider. During\n        update, the trusted identity provider with the specified name will be\n        replaced with this new provider.\n\n        :param resource_group_name: The name of the Azure resource group.\n        :type resource_group_name: str\n        :param account_name: The name of the Data Lake Store account.\n        :type account_name: str\n        :param trusted_id_provider_name: The name of the trusted identity\n         provider. This is used for differentiation of providers in the\n         account.\n        :type trusted_id_provider_name: str\n        :param id_provider: The URL of this trusted identity provider.\n        :type id_provider: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: TrustedIdProvider or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.datalake.store.models.TrustedIdProvider or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f36704:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, account_name, trusted_id_provider_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", trusted_id_provider_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes the specified trusted identity provider from the specified Data\n        Lake Store account.\n\n        :param resource_group_name: The name of the Azure resource group.\n        :type resource_group_name: str\n        :param account_name: The name of the Data Lake Store account.\n        :type account_name: str\n        :param trusted_id_provider_name: The name of the trusted identity\n         provider to delete.\n        :type trusted_id_provider_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f36704:c0:m5"}
{"signature": "def update(<EOL>self, resource_group_name, account_name, trusted_id_provider_name, id_provider=None, custom_headers=None, raw=False, **operation_config):", "body": "parameters = None<EOL>if id_provider is not None:<EOL><INDENT>parameters = models.UpdateTrustedIdProviderParameters(id_provider=id_provider)<EOL><DEDENT>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", trusted_id_provider_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if parameters is not None:<EOL><INDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>body_content = None<EOL><DEDENT>request = self._client.patch(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, body_content, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Updates the specified trusted identity provider.\n\n        :param resource_group_name: The name of the Azure resource group.\n        :type resource_group_name: str\n        :param account_name: The name of the Data Lake Store account.\n        :type account_name: str\n        :param trusted_id_provider_name: The name of the trusted identity\n         provider. This is used for differentiation of providers in the\n         account.\n        :type trusted_id_provider_name: str\n        :param id_provider: The URL of this trusted identity provider.\n        :type id_provider: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: TrustedIdProvider or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.datalake.store.models.TrustedIdProvider or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f36704:c0:m4"}
{"signature": "def get_environment(<EOL>self, user_name, environment_id, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "environment_operations_payload = models.EnvironmentOperationsPayload(environment_id=environment_id)<EOL>url = self.get_environment.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", user_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(environment_operations_payload, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the virtual machine details.\n\n        :param user_name: The name of the user.\n        :type user_name: str\n        :param environment_id: The resourceId of the environment\n        :type environment_id: str\n        :param expand: Specify the $expand query. Example:\n         'properties($expand=environment)'\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: GetEnvironmentResponse or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.labservices.models.GetEnvironmentResponse or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f36843:c0:m1"}
{"signature": "def get_operation_status(<EOL>self, user_name, operation_url, custom_headers=None, raw=False, **operation_config):", "body": "operation_status_payload = models.OperationStatusPayload(operation_url=operation_url)<EOL>url = self.get_operation_status.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", user_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(operation_status_payload, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the status of long running operation.\n\n        :param user_name: The name of the user.\n        :type user_name: str\n        :param operation_url: The operation url of long running operation\n        :type operation_url: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: OperationStatusResponse or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.labservices.models.OperationStatusResponse or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f36843:c0:m3"}
{"signature": "def get_personal_preferences(<EOL>self, user_name, personal_preferences_operations_payload, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_personal_preferences.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", user_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(personal_preferences_operations_payload, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get personal preferences for a user.\n\n        :param user_name: The name of the user.\n        :type user_name: str\n        :param personal_preferences_operations_payload: Represents payload for\n         any Environment operations like get, start, stop, connect\n        :type personal_preferences_operations_payload:\n         ~azure.mgmt.labservices.models.PersonalPreferencesOperationsPayload\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: GetPersonalPreferencesResponse or ClientRawResponse if\n         raw=true\n        :rtype: ~azure.mgmt.labservices.models.GetPersonalPreferencesResponse\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f36843:c0:m4"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, lab_account_name, lab_name, lab, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", lab_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", lab_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(lab, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Create or replace an existing Lab.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param lab_account_name: The name of the lab Account.\n        :type lab_account_name: str\n        :param lab_name: The name of the lab.\n        :type lab_name: str\n        :param lab: Represents a lab.\n        :type lab: ~azure.mgmt.labservices.models.Lab\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Lab or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.labservices.models.Lab or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f36844:c0:m3"}
{"signature": "def update(<EOL>self, resource_group_name, lab_account_name, lab_name, lab, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", lab_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", lab_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(lab, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Modify properties of labs.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param lab_account_name: The name of the lab Account.\n        :type lab_account_name: str\n        :param lab_name: The name of the lab.\n        :type lab_name: str\n        :param lab: Represents a lab.\n        :type lab: ~azure.mgmt.labservices.models.LabFragment\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Lab or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.labservices.models.Lab or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f36844:c0:m6"}
{"signature": "def delete(<EOL>self, resource_group_name, lab_account_name, lab_name, user_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>lab_account_name=lab_account_name,<EOL>lab_name=lab_name,<EOL>user_name=user_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Delete user. This operation can take a while to complete.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param lab_account_name: The name of the lab Account.\n        :type lab_account_name: str\n        :param lab_name: The name of the lab.\n        :type lab_name: str\n        :param user_name: The name of the user.\n        :type user_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f36845:c0:m5"}
{"signature": "def update(<EOL>self, resource_group_name, lab_account_name, lab_name, user_name, user, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", lab_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", lab_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", user_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(user, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Modify properties of users.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param lab_account_name: The name of the lab Account.\n        :type lab_account_name: str\n        :param lab_name: The name of the lab.\n        :type lab_name: str\n        :param user_name: The name of the user.\n        :type user_name: str\n        :param user: The User registered to a lab\n        :type user: ~azure.mgmt.labservices.models.UserFragment\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: User or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.labservices.models.User or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f36845:c0:m6"}
{"signature": "def delete(<EOL>self, resource_group_name, lab_account_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>lab_account_name=lab_account_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Delete lab account. This operation can take a while to complete.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param lab_account_name: The name of the lab Account.\n        :type lab_account_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f36847:c0:m6"}
{"signature": "def update(<EOL>self, resource_group_name, lab_account_name, lab_account, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", lab_account_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(lab_account, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Modify properties of lab accounts.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param lab_account_name: The name of the lab Account.\n        :type lab_account_name: str\n        :param lab_account: Represents a lab account.\n        :type lab_account: ~azure.mgmt.labservices.models.LabAccountFragment\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: LabAccount or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.labservices.models.LabAccount or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f36847:c0:m7"}
{"signature": "def update(<EOL>self, resource_group_name, lab_account_name, lab_name, environment_setting_name, environment_name, environment, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", lab_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", lab_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", environment_setting_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", environment_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(environment, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Modify properties of environments.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param lab_account_name: The name of the lab Account.\n        :type lab_account_name: str\n        :param lab_name: The name of the lab.\n        :type lab_name: str\n        :param environment_setting_name: The name of the environment Setting.\n        :type environment_setting_name: str\n        :param environment_name: The name of the environment.\n        :type environment_name: str\n        :param environment: Represents an environment instance\n        :type environment: ~azure.mgmt.labservices.models.EnvironmentFragment\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Environment or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.labservices.models.Environment or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f36848:c0:m6"}
{"signature": "def stop(<EOL>self, resource_group_name, lab_account_name, lab_name, environment_setting_name, environment_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._stop_initial(<EOL>resource_group_name=resource_group_name,<EOL>lab_account_name=lab_account_name,<EOL>lab_name=lab_name,<EOL>environment_setting_name=environment_setting_name,<EOL>environment_name=environment_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Stops an environment by stopping all resources inside the environment\n        This operation can take a while to complete.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param lab_account_name: The name of the lab Account.\n        :type lab_account_name: str\n        :param lab_name: The name of the lab.\n        :type lab_name: str\n        :param environment_setting_name: The name of the environment Setting.\n        :type environment_setting_name: str\n        :param environment_name: The name of the environment.\n        :type environment_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f36848:c0:m13"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, lab_account_name, lab_name, environment_setting_name, environment_name, environment, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", lab_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", lab_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", environment_setting_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", environment_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(environment, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Create or replace an existing Environment.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param lab_account_name: The name of the lab Account.\n        :type lab_account_name: str\n        :param lab_name: The name of the lab.\n        :type lab_name: str\n        :param environment_setting_name: The name of the environment Setting.\n        :type environment_setting_name: str\n        :param environment_name: The name of the environment.\n        :type environment_name: str\n        :param environment: Represents an environment instance\n        :type environment: ~azure.mgmt.labservices.models.Environment\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Environment or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.labservices.models.Environment or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f36848:c0:m3"}
{"signature": "def stop(<EOL>self, resource_group_name, lab_account_name, lab_name, environment_setting_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._stop_initial(<EOL>resource_group_name=resource_group_name,<EOL>lab_account_name=lab_account_name,<EOL>lab_name=lab_name,<EOL>environment_setting_name=environment_setting_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Starts a template by starting all resources inside the template. This\n        operation can take a while to complete.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param lab_account_name: The name of the lab Account.\n        :type lab_account_name: str\n        :param lab_name: The name of the lab.\n        :type lab_name: str\n        :param environment_setting_name: The name of the environment Setting.\n        :type environment_setting_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f36849:c0:m13"}
{"signature": "def delete(<EOL>self, resource_group_name, lab_account_name, lab_name, environment_setting_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>lab_account_name=lab_account_name,<EOL>lab_name=lab_name,<EOL>environment_setting_name=environment_setting_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Delete environment setting. This operation can take a while to\n        complete.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param lab_account_name: The name of the lab Account.\n        :type lab_account_name: str\n        :param lab_name: The name of the lab.\n        :type lab_name: str\n        :param environment_setting_name: The name of the environment Setting.\n        :type environment_setting_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f36849:c0:m6"}
{"signature": "def publish(<EOL>self, resource_group_name, lab_account_name, lab_name, environment_setting_name, use_existing_image=None, custom_headers=None, raw=False, **operation_config):", "body": "publish_payload = models.PublishPayload(use_existing_image=use_existing_image)<EOL>url = self.publish.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", lab_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", lab_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", environment_setting_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(publish_payload, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Provisions/deprovisions required resources for an environment setting\n        based on current state of the lab/environment setting.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param lab_account_name: The name of the lab Account.\n        :type lab_account_name: str\n        :param lab_name: The name of the lab.\n        :type lab_name: str\n        :param environment_setting_name: The name of the environment Setting.\n        :type environment_setting_name: str\n        :param use_existing_image: Whether to use existing VM custom image\n         when publishing.\n        :type use_existing_image: bool\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f36849:c0:m9"}
{"signature": "def start(<EOL>self, resource_group_name, lab_account_name, lab_name, environment_setting_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._start_initial(<EOL>resource_group_name=resource_group_name,<EOL>lab_account_name=lab_account_name,<EOL>lab_name=lab_name,<EOL>environment_setting_name=environment_setting_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Starts a template by starting all resources inside the template. This\n        operation can take a while to complete.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param lab_account_name: The name of the lab Account.\n        :type lab_account_name: str\n        :param lab_name: The name of the lab.\n        :type lab_name: str\n        :param environment_setting_name: The name of the environment Setting.\n        :type environment_setting_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f36849:c0:m11"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.OperationMetadataPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.OperationMetadataPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Result of the request to list REST API operations.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of OperationMetadata\n        :rtype:\n         ~azure.mgmt.labservices.models.OperationMetadataPaged[~azure.mgmt.labservices.models.OperationMetadata]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f36850:c0:m1"}
{"signature": "def delete(<EOL>self, resource_group_name, lab_account_name, gallery_image_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", lab_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", gallery_image_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Delete gallery image.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param lab_account_name: The name of the lab Account.\n        :type lab_account_name: str\n        :param gallery_image_name: The name of the gallery Image.\n        :type gallery_image_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f36852:c0:m4"}
{"signature": "def list(<EOL>self, resource_group_name, lab_account_name, expand=None, filter=None, top=None, orderby=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", lab_account_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>')<EOL><DEDENT>if orderby is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", orderby, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.GalleryImagePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.GalleryImagePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List gallery images in a given lab account.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param lab_account_name: The name of the lab Account.\n        :type lab_account_name: str\n        :param expand: Specify the $expand query. Example:\n         'properties($select=author)'\n        :type expand: str\n        :param filter: The filter to apply to the operation.\n        :type filter: str\n        :param top: The maximum number of resources to return from the\n         operation.\n        :type top: int\n        :param orderby: The ordering expression for the results, using OData\n         notation.\n        :type orderby: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of GalleryImage\n        :rtype:\n         ~azure.mgmt.labservices.models.GalleryImagePaged[~azure.mgmt.labservices.models.GalleryImage]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f36852:c0:m1"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, lab_account_name, gallery_image_name, gallery_image, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", lab_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", gallery_image_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(gallery_image, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Create or replace an existing Gallery Image.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param lab_account_name: The name of the lab Account.\n        :type lab_account_name: str\n        :param gallery_image_name: The name of the gallery Image.\n        :type gallery_image_name: str\n        :param gallery_image: Represents an image from the Azure Marketplace\n        :type gallery_image: ~azure.mgmt.labservices.models.GalleryImage\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: GalleryImage or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.labservices.models.GalleryImage or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f36852:c0:m3"}
{"signature": "def list_query_results_for_subscription(<EOL>self, subscription_id, query_options=None, custom_headers=None, raw=False, **operation_config):", "body": "top = None<EOL>if query_options is not None:<EOL><INDENT>top = query_options.top<EOL><DEDENT>filter = None<EOL>if query_options is not None:<EOL><INDENT>filter = query_options.filter<EOL><DEDENT>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_query_results_for_subscription.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.policy_tracked_resources_resource, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>', minimum=<NUM_LIT:0>)<EOL><DEDENT>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.QueryFailureException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PolicyTrackedResourcePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PolicyTrackedResourcePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Queries policy tracked resources under the subscription.\n\n        :param subscription_id: Microsoft Azure subscription ID.\n        :type subscription_id: str\n        :param query_options: Additional parameters for the operation\n        :type query_options: ~azure.mgmt.policyinsights.models.QueryOptions\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PolicyTrackedResource\n        :rtype:\n         ~azure.mgmt.policyinsights.models.PolicyTrackedResourcePaged[~azure.mgmt.policyinsights.models.PolicyTrackedResource]\n        :raises:\n         :class:`QueryFailureException<azure.mgmt.policyinsights.models.QueryFailureException>`", "id": "f36918:c0:m2"}
{"signature": "def list_query_results_for_resource(<EOL>self, policy_states_resource, resource_id, query_options=None, custom_headers=None, raw=False, **operation_config):", "body": "top = None<EOL>if query_options is not None:<EOL><INDENT>top = query_options.top<EOL><DEDENT>order_by = None<EOL>if query_options is not None:<EOL><INDENT>order_by = query_options.order_by<EOL><DEDENT>select = None<EOL>if query_options is not None:<EOL><INDENT>select = query_options.select<EOL><DEDENT>from_parameter = None<EOL>if query_options is not None:<EOL><INDENT>from_parameter = query_options.from_property<EOL><DEDENT>to = None<EOL>if query_options is not None:<EOL><INDENT>to = query_options.to<EOL><DEDENT>filter = None<EOL>if query_options is not None:<EOL><INDENT>filter = query_options.filter<EOL><DEDENT>apply = None<EOL>if query_options is not None:<EOL><INDENT>apply = query_options.apply<EOL><DEDENT>expand = None<EOL>if query_options is not None:<EOL><INDENT>expand = query_options.expand<EOL><DEDENT>url = self.list_query_results_for_resource.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", policy_states_resource, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>', minimum=<NUM_LIT:0>)<EOL><DEDENT>if order_by is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", order_by, '<STR_LIT:str>')<EOL><DEDENT>if select is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", select, '<STR_LIT:str>')<EOL><DEDENT>if from_parameter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", from_parameter, '<STR_LIT>')<EOL><DEDENT>if to is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT:to>\", to, '<STR_LIT>')<EOL><DEDENT>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if apply is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", apply, '<STR_LIT:str>')<EOL><DEDENT>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.QueryFailureException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Queries policy states for the resource.\n\n        :param policy_states_resource: The virtual resource under PolicyStates\n         resource type. In a given time range, 'latest' represents the latest\n         policy state(s), whereas 'default' represents all policy state(s).\n         Possible values include: 'default', 'latest'\n        :type policy_states_resource: str or\n         ~azure.mgmt.policyinsights.models.PolicyStatesResource\n        :param resource_id: Resource ID.\n        :type resource_id: str\n        :param query_options: Additional parameters for the operation\n        :type query_options: ~azure.mgmt.policyinsights.models.QueryOptions\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PolicyStatesQueryResults or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.policyinsights.models.PolicyStatesQueryResults or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`QueryFailureException<azure.mgmt.policyinsights.models.QueryFailureException>`", "id": "f36919:c0:m7"}
{"signature": "def list_query_results_for_subscription(<EOL>self, policy_states_resource, subscription_id, query_options=None, custom_headers=None, raw=False, **operation_config):", "body": "top = None<EOL>if query_options is not None:<EOL><INDENT>top = query_options.top<EOL><DEDENT>order_by = None<EOL>if query_options is not None:<EOL><INDENT>order_by = query_options.order_by<EOL><DEDENT>select = None<EOL>if query_options is not None:<EOL><INDENT>select = query_options.select<EOL><DEDENT>from_parameter = None<EOL>if query_options is not None:<EOL><INDENT>from_parameter = query_options.from_property<EOL><DEDENT>to = None<EOL>if query_options is not None:<EOL><INDENT>to = query_options.to<EOL><DEDENT>filter = None<EOL>if query_options is not None:<EOL><INDENT>filter = query_options.filter<EOL><DEDENT>apply = None<EOL>if query_options is not None:<EOL><INDENT>apply = query_options.apply<EOL><DEDENT>url = self.list_query_results_for_subscription.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", policy_states_resource, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>', minimum=<NUM_LIT:0>)<EOL><DEDENT>if order_by is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", order_by, '<STR_LIT:str>')<EOL><DEDENT>if select is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", select, '<STR_LIT:str>')<EOL><DEDENT>if from_parameter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", from_parameter, '<STR_LIT>')<EOL><DEDENT>if to is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT:to>\", to, '<STR_LIT>')<EOL><DEDENT>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if apply is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", apply, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.QueryFailureException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Queries policy states for the resources under the subscription.\n\n        :param policy_states_resource: The virtual resource under PolicyStates\n         resource type. In a given time range, 'latest' represents the latest\n         policy state(s), whereas 'default' represents all policy state(s).\n         Possible values include: 'default', 'latest'\n        :type policy_states_resource: str or\n         ~azure.mgmt.policyinsights.models.PolicyStatesResource\n        :param subscription_id: Microsoft Azure subscription ID.\n        :type subscription_id: str\n        :param query_options: Additional parameters for the operation\n        :type query_options: ~azure.mgmt.policyinsights.models.QueryOptions\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PolicyStatesQueryResults or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.policyinsights.models.PolicyStatesQueryResults or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`QueryFailureException<azure.mgmt.policyinsights.models.QueryFailureException>`", "id": "f36919:c0:m3"}
{"signature": "def summarize_for_policy_set_definition(<EOL>self, subscription_id, policy_set_definition_name, query_options=None, custom_headers=None, raw=False, **operation_config):", "body": "top = None<EOL>if query_options is not None:<EOL><INDENT>top = query_options.top<EOL><DEDENT>from_parameter = None<EOL>if query_options is not None:<EOL><INDENT>from_parameter = query_options.from_property<EOL><DEDENT>to = None<EOL>if query_options is not None:<EOL><INDENT>to = query_options.to<EOL><DEDENT>filter = None<EOL>if query_options is not None:<EOL><INDENT>filter = query_options.filter<EOL><DEDENT>url = self.summarize_for_policy_set_definition.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.policy_states_summary_resource, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.authorization_namespace, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", policy_set_definition_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>', minimum=<NUM_LIT:0>)<EOL><DEDENT>if from_parameter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", from_parameter, '<STR_LIT>')<EOL><DEDENT>if to is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT:to>\", to, '<STR_LIT>')<EOL><DEDENT>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.QueryFailureException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Summarizes policy states for the subscription level policy set\n        definition.\n\n        :param subscription_id: Microsoft Azure subscription ID.\n        :type subscription_id: str\n        :param policy_set_definition_name: Policy set definition name.\n        :type policy_set_definition_name: str\n        :param query_options: Additional parameters for the operation\n        :type query_options: ~azure.mgmt.policyinsights.models.QueryOptions\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SummarizeResults or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.policyinsights.models.SummarizeResults or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`QueryFailureException<azure.mgmt.policyinsights.models.QueryFailureException>`", "id": "f36919:c0:m10"}
{"signature": "def summarize_for_policy_definition(<EOL>self, subscription_id, policy_definition_name, query_options=None, custom_headers=None, raw=False, **operation_config):", "body": "top = None<EOL>if query_options is not None:<EOL><INDENT>top = query_options.top<EOL><DEDENT>from_parameter = None<EOL>if query_options is not None:<EOL><INDENT>from_parameter = query_options.from_property<EOL><DEDENT>to = None<EOL>if query_options is not None:<EOL><INDENT>to = query_options.to<EOL><DEDENT>filter = None<EOL>if query_options is not None:<EOL><INDENT>filter = query_options.filter<EOL><DEDENT>url = self.summarize_for_policy_definition.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.policy_states_summary_resource, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.authorization_namespace, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", policy_definition_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>', minimum=<NUM_LIT:0>)<EOL><DEDENT>if from_parameter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", from_parameter, '<STR_LIT>')<EOL><DEDENT>if to is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT:to>\", to, '<STR_LIT>')<EOL><DEDENT>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.QueryFailureException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Summarizes policy states for the subscription level policy definition.\n\n        :param subscription_id: Microsoft Azure subscription ID.\n        :type subscription_id: str\n        :param policy_definition_name: Policy definition name.\n        :type policy_definition_name: str\n        :param query_options: Additional parameters for the operation\n        :type query_options: ~azure.mgmt.policyinsights.models.QueryOptions\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SummarizeResults or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.policyinsights.models.SummarizeResults or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`QueryFailureException<azure.mgmt.policyinsights.models.QueryFailureException>`", "id": "f36919:c0:m12"}
{"signature": "def list_query_results_for_resource_group(<EOL>self, policy_states_resource, subscription_id, resource_group_name, query_options=None, custom_headers=None, raw=False, **operation_config):", "body": "top = None<EOL>if query_options is not None:<EOL><INDENT>top = query_options.top<EOL><DEDENT>order_by = None<EOL>if query_options is not None:<EOL><INDENT>order_by = query_options.order_by<EOL><DEDENT>select = None<EOL>if query_options is not None:<EOL><INDENT>select = query_options.select<EOL><DEDENT>from_parameter = None<EOL>if query_options is not None:<EOL><INDENT>from_parameter = query_options.from_property<EOL><DEDENT>to = None<EOL>if query_options is not None:<EOL><INDENT>to = query_options.to<EOL><DEDENT>filter = None<EOL>if query_options is not None:<EOL><INDENT>filter = query_options.filter<EOL><DEDENT>apply = None<EOL>if query_options is not None:<EOL><INDENT>apply = query_options.apply<EOL><DEDENT>url = self.list_query_results_for_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", policy_states_resource, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>', minimum=<NUM_LIT:0>)<EOL><DEDENT>if order_by is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", order_by, '<STR_LIT:str>')<EOL><DEDENT>if select is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", select, '<STR_LIT:str>')<EOL><DEDENT>if from_parameter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", from_parameter, '<STR_LIT>')<EOL><DEDENT>if to is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT:to>\", to, '<STR_LIT>')<EOL><DEDENT>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if apply is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", apply, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.QueryFailureException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Queries policy states for the resources under the resource group.\n\n        :param policy_states_resource: The virtual resource under PolicyStates\n         resource type. In a given time range, 'latest' represents the latest\n         policy state(s), whereas 'default' represents all policy state(s).\n         Possible values include: 'default', 'latest'\n        :type policy_states_resource: str or\n         ~azure.mgmt.policyinsights.models.PolicyStatesResource\n        :param subscription_id: Microsoft Azure subscription ID.\n        :type subscription_id: str\n        :param resource_group_name: Resource group name.\n        :type resource_group_name: str\n        :param query_options: Additional parameters for the operation\n        :type query_options: ~azure.mgmt.policyinsights.models.QueryOptions\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PolicyStatesQueryResults or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.policyinsights.models.PolicyStatesQueryResults or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`QueryFailureException<azure.mgmt.policyinsights.models.QueryFailureException>`", "id": "f36919:c0:m5"}
{"signature": "def list_query_results_for_management_group(<EOL>self, policy_states_resource, management_group_name, query_options=None, custom_headers=None, raw=False, **operation_config):", "body": "top = None<EOL>if query_options is not None:<EOL><INDENT>top = query_options.top<EOL><DEDENT>order_by = None<EOL>if query_options is not None:<EOL><INDENT>order_by = query_options.order_by<EOL><DEDENT>select = None<EOL>if query_options is not None:<EOL><INDENT>select = query_options.select<EOL><DEDENT>from_parameter = None<EOL>if query_options is not None:<EOL><INDENT>from_parameter = query_options.from_property<EOL><DEDENT>to = None<EOL>if query_options is not None:<EOL><INDENT>to = query_options.to<EOL><DEDENT>filter = None<EOL>if query_options is not None:<EOL><INDENT>filter = query_options.filter<EOL><DEDENT>apply = None<EOL>if query_options is not None:<EOL><INDENT>apply = query_options.apply<EOL><DEDENT>url = self.list_query_results_for_management_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", policy_states_resource, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.management_groups_namespace, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", management_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>', minimum=<NUM_LIT:0>)<EOL><DEDENT>if order_by is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", order_by, '<STR_LIT:str>')<EOL><DEDENT>if select is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", select, '<STR_LIT:str>')<EOL><DEDENT>if from_parameter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", from_parameter, '<STR_LIT>')<EOL><DEDENT>if to is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT:to>\", to, '<STR_LIT>')<EOL><DEDENT>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if apply is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", apply, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.QueryFailureException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Queries policy states for the resources under the management group.\n\n        :param policy_states_resource: The virtual resource under PolicyStates\n         resource type. In a given time range, 'latest' represents the latest\n         policy state(s), whereas 'default' represents all policy state(s).\n         Possible values include: 'default', 'latest'\n        :type policy_states_resource: str or\n         ~azure.mgmt.policyinsights.models.PolicyStatesResource\n        :param management_group_name: Management group name.\n        :type management_group_name: str\n        :param query_options: Additional parameters for the operation\n        :type query_options: ~azure.mgmt.policyinsights.models.QueryOptions\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PolicyStatesQueryResults or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.policyinsights.models.PolicyStatesQueryResults or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`QueryFailureException<azure.mgmt.policyinsights.models.QueryFailureException>`", "id": "f36919:c0:m1"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.QueryFailureException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists available operations.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: OperationsListResults or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.policyinsights.models.OperationsListResults or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`QueryFailureException<azure.mgmt.policyinsights.models.QueryFailureException>`", "id": "f36920:c0:m1"}
{"signature": "def cancel_at_resource(<EOL>self, resource_id, remediation_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.cancel_at_resource.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_id, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", remediation_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Cancel a remediation at resource scope.\n\n        :param resource_id: Resource ID.\n        :type resource_id: str\n        :param remediation_name: The name of the remediation.\n        :type remediation_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Remediation or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.policyinsights.models.Remediation or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.policyinsights.models.ErrorResponseException>`", "id": "f36921:c0:m20"}
{"signature": "def delete_at_management_group(<EOL>self, management_group_id, remediation_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete_at_management_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.management_groups_namespace, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", management_group_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", remediation_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Deletes an existing remediation at management group scope.\n\n        :param management_group_id: Management group ID.\n        :type management_group_id: str\n        :param remediation_name: The name of the remediation.\n        :type remediation_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Remediation or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.policyinsights.models.Remediation or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.policyinsights.models.ErrorResponseException>`", "id": "f36921:c0:m6"}
{"signature": "def list_deployments_at_resource_group(<EOL>self, subscription_id, resource_group_name, remediation_name, query_options=None, custom_headers=None, raw=False, **operation_config):", "body": "top = None<EOL>if query_options is not None:<EOL><INDENT>top = query_options.top<EOL><DEDENT>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_deployments_at_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", remediation_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>', minimum=<NUM_LIT:0>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RemediationDeploymentPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RemediationDeploymentPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all deployments for a remediation at resource group scope.\n\n        :param subscription_id: Microsoft Azure subscription ID.\n        :type subscription_id: str\n        :param resource_group_name: Resource group name.\n        :type resource_group_name: str\n        :param remediation_name: The name of the remediation.\n        :type remediation_name: str\n        :param query_options: Additional parameters for the operation\n        :type query_options: ~azure.mgmt.policyinsights.models.QueryOptions\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of RemediationDeployment\n        :rtype:\n         ~azure.mgmt.policyinsights.models.RemediationDeploymentPaged[~azure.mgmt.policyinsights.models.RemediationDeployment]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.policyinsights.models.ErrorResponseException>`", "id": "f36921:c0:m13"}
{"signature": "def list_deployments_at_management_group(<EOL>self, management_group_id, remediation_name, query_options=None, custom_headers=None, raw=False, **operation_config):", "body": "top = None<EOL>if query_options is not None:<EOL><INDENT>top = query_options.top<EOL><DEDENT>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_deployments_at_management_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.management_groups_namespace, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", management_group_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", remediation_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>', minimum=<NUM_LIT:0>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RemediationDeploymentPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RemediationDeploymentPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all deployments for a remediation at management group scope.\n\n        :param management_group_id: Management group ID.\n        :type management_group_id: str\n        :param remediation_name: The name of the remediation.\n        :type remediation_name: str\n        :param query_options: Additional parameters for the operation\n        :type query_options: ~azure.mgmt.policyinsights.models.QueryOptions\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of RemediationDeployment\n        :rtype:\n         ~azure.mgmt.policyinsights.models.RemediationDeploymentPaged[~azure.mgmt.policyinsights.models.RemediationDeployment]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.policyinsights.models.ErrorResponseException>`", "id": "f36921:c0:m1"}
{"signature": "def list_query_results_for_management_group(<EOL>self, management_group_name, query_options=None, custom_headers=None, raw=False, **operation_config):", "body": "top = None<EOL>if query_options is not None:<EOL><INDENT>top = query_options.top<EOL><DEDENT>order_by = None<EOL>if query_options is not None:<EOL><INDENT>order_by = query_options.order_by<EOL><DEDENT>select = None<EOL>if query_options is not None:<EOL><INDENT>select = query_options.select<EOL><DEDENT>from_parameter = None<EOL>if query_options is not None:<EOL><INDENT>from_parameter = query_options.from_property<EOL><DEDENT>to = None<EOL>if query_options is not None:<EOL><INDENT>to = query_options.to<EOL><DEDENT>filter = None<EOL>if query_options is not None:<EOL><INDENT>filter = query_options.filter<EOL><DEDENT>apply = None<EOL>if query_options is not None:<EOL><INDENT>apply = query_options.apply<EOL><DEDENT>url = self.list_query_results_for_management_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.policy_events_resource, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.management_groups_namespace, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", management_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>', minimum=<NUM_LIT:0>)<EOL><DEDENT>if order_by is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", order_by, '<STR_LIT:str>')<EOL><DEDENT>if select is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", select, '<STR_LIT:str>')<EOL><DEDENT>if from_parameter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", from_parameter, '<STR_LIT>')<EOL><DEDENT>if to is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT:to>\", to, '<STR_LIT>')<EOL><DEDENT>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if apply is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", apply, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.QueryFailureException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Queries policy events for the resources under the management group.\n\n        :param management_group_name: Management group name.\n        :type management_group_name: str\n        :param query_options: Additional parameters for the operation\n        :type query_options: ~azure.mgmt.policyinsights.models.QueryOptions\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PolicyEventsQueryResults or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.policyinsights.models.PolicyEventsQueryResults or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`QueryFailureException<azure.mgmt.policyinsights.models.QueryFailureException>`", "id": "f36923:c0:m1"}
{"signature": "def get_metadata(<EOL>self, scope, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_metadata.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", scope, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.QueryFailureException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT:str>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets OData metadata XML document.\n\n        :param scope: A valid scope, i.e. management group, subscription,\n         resource group, or resource ID. Scope used has no effect on metadata\n         returned.\n        :type scope: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: str or ClientRawResponse if raw=true\n        :rtype: str or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`QueryFailureException<azure.mgmt.policyinsights.models.QueryFailureException>`", "id": "f36923:c0:m9"}
{"signature": "def list_query_results_for_policy_definition(<EOL>self, subscription_id, policy_definition_name, query_options=None, custom_headers=None, raw=False, **operation_config):", "body": "top = None<EOL>if query_options is not None:<EOL><INDENT>top = query_options.top<EOL><DEDENT>order_by = None<EOL>if query_options is not None:<EOL><INDENT>order_by = query_options.order_by<EOL><DEDENT>select = None<EOL>if query_options is not None:<EOL><INDENT>select = query_options.select<EOL><DEDENT>from_parameter = None<EOL>if query_options is not None:<EOL><INDENT>from_parameter = query_options.from_property<EOL><DEDENT>to = None<EOL>if query_options is not None:<EOL><INDENT>to = query_options.to<EOL><DEDENT>filter = None<EOL>if query_options is not None:<EOL><INDENT>filter = query_options.filter<EOL><DEDENT>apply = None<EOL>if query_options is not None:<EOL><INDENT>apply = query_options.apply<EOL><DEDENT>url = self.list_query_results_for_policy_definition.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.policy_events_resource, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.authorization_namespace, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", policy_definition_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>', minimum=<NUM_LIT:0>)<EOL><DEDENT>if order_by is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", order_by, '<STR_LIT:str>')<EOL><DEDENT>if select is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", select, '<STR_LIT:str>')<EOL><DEDENT>if from_parameter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", from_parameter, '<STR_LIT>')<EOL><DEDENT>if to is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT:to>\", to, '<STR_LIT>')<EOL><DEDENT>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if apply is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", apply, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.QueryFailureException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Queries policy events for the subscription level policy definition.\n\n        :param subscription_id: Microsoft Azure subscription ID.\n        :type subscription_id: str\n        :param policy_definition_name: Policy definition name.\n        :type policy_definition_name: str\n        :param query_options: Additional parameters for the operation\n        :type query_options: ~azure.mgmt.policyinsights.models.QueryOptions\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PolicyEventsQueryResults or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.policyinsights.models.PolicyEventsQueryResults or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`QueryFailureException<azure.mgmt.policyinsights.models.QueryFailureException>`", "id": "f36923:c0:m6"}
{"signature": "def create_or_update(<EOL>self, device_name, name, resource_group_name, encrypted_password=None, share_access_rights=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>device_name=device_name,<EOL>name=name,<EOL>resource_group_name=resource_group_name,<EOL>encrypted_password=encrypted_password,<EOL>share_access_rights=share_access_rights,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates a new user or updates an existing user's information on a data\n        box edge/gateway device.\n\n        :param device_name: The device name.\n        :type device_name: str\n        :param name: The user name.\n        :type name: str\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param encrypted_password: The password details.\n        :type encrypted_password:\n         ~azure.mgmt.edgegateway.models.AsymmetricEncryptedSecret\n        :param share_access_rights: List of shares that the user has rights\n         on. This field should not be specified during user creation.\n        :type share_access_rights:\n         list[~azure.mgmt.edgegateway.models.ShareAccessRight]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns User or\n         ClientRawResponse<User> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.edgegateway.models.User]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.edgegateway.models.User]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37045:c0:m4"}
{"signature": "def get(<EOL>self, device_name, name, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", device_name, '<STR_LIT:str>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a specific role by name.\n\n        :param device_name: The device name.\n        :type device_name: str\n        :param name: The role name.\n        :type name: str\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Role or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.edgegateway.models.Role or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37047:c0:m2"}
{"signature": "def delete(<EOL>self, device_name, name, resource_group_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>device_name=device_name,<EOL>name=name,<EOL>resource_group_name=resource_group_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the role on the data box edge device.\n\n        :param device_name: The device name.\n        :type device_name: str\n        :param name: The role name.\n        :type name: str\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37047:c0:m6"}
{"signature": "def get(<EOL>self, device_name, name, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", device_name, '<STR_LIT:str>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the details of a specified job on a data box edge/gateway device.\n\n        :param device_name: The device name.\n        :type device_name: str\n        :param name: The job name.\n        :type name: str\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Job or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.edgegateway.models.Job or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37049:c0:m1"}
{"signature": "def create_or_update(<EOL>self, device_name, name, trigger, resource_group_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>device_name=device_name,<EOL>name=name,<EOL>trigger=trigger,<EOL>resource_group_name=resource_group_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a trigger.\n\n        :param device_name: Creates or updates a trigger\n        :type device_name: str\n        :param name: The trigger name.\n        :type name: str\n        :param trigger: The trigger.\n        :type trigger: ~azure.mgmt.edgegateway.models.Trigger\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Trigger or\n         ClientRawResponse<Trigger> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.edgegateway.models.Trigger]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.edgegateway.models.Trigger]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37050:c0:m4"}
{"signature": "def list_by_data_box_edge_device(<EOL>self, device_name, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_data_box_edge_device.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", device_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.StorageAccountCredentialPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.StorageAccountCredentialPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the storage account credentials in a data box edge/gateway\n        device.\n\n        :param device_name: The device name.\n        :type device_name: str\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of StorageAccountCredential\n        :rtype:\n         ~azure.mgmt.edgegateway.models.StorageAccountCredentialPaged[~azure.mgmt.edgegateway.models.StorageAccountCredential]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37052:c0:m1"}
{"signature": "def delete(<EOL>self, device_name, name, resource_group_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>device_name=device_name,<EOL>name=name,<EOL>resource_group_name=resource_group_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the storage account credential.\n\n        :param device_name: The device name.\n        :type device_name: str\n        :param name: The storage account credential name.\n        :type name: str\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37052:c0:m6"}
{"signature": "def create_or_update(<EOL>self, device_name, name, storage_account_credential, resource_group_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>device_name=device_name,<EOL>name=name,<EOL>storage_account_credential=storage_account_credential,<EOL>resource_group_name=resource_group_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates the storage account credential.\n\n        :param device_name: The device name.\n        :type device_name: str\n        :param name: The storage account credential name.\n        :type name: str\n        :param storage_account_credential: The storage account credential.\n        :type storage_account_credential:\n         ~azure.mgmt.edgegateway.models.StorageAccountCredential\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         StorageAccountCredential or\n         ClientRawResponse<StorageAccountCredential> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.edgegateway.models.StorageAccountCredential]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.edgegateway.models.StorageAccountCredential]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37052:c0:m4"}
{"signature": "def get_update_summary(<EOL>self, device_name, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_update_summary.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", device_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about the availability of updates based on the last\n        scan of the device. It also gets information about any ongoing download\n        or install jobs on the device.\n\n        :param device_name: The device name.\n        :type device_name: str\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: UpdateSummary or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.edgegateway.models.UpdateSummary or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37055:c0:m19"}
{"signature": "def download_updates(<EOL>self, device_name, resource_group_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._download_updates_initial(<EOL>device_name=device_name,<EOL>resource_group_name=resource_group_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Downloads the updates on a data box edge/gateway device.\n\n        :param device_name: The device name.\n        :type device_name: str\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37055:c0:m10"}
{"signature": "def create_or_update_security_settings(<EOL>self, device_name, resource_group_name, device_admin_password, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_security_settings_initial(<EOL>device_name=device_name,<EOL>resource_group_name=resource_group_name,<EOL>device_admin_password=device_admin_password,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates the security settings on a data box edge/gateway device.\n\n        :param device_name: The device name.\n        :type device_name: str\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param device_admin_password: Device administrator password as an\n         encrypted string (encrypted using RSA PKCS #1) is used to sign into\n         the  local web UI of the device. The Actual password should have at\n         least 8 characters that are a combination of  uppercase, lowercase,\n         numeric, and special characters.\n        :type device_admin_password:\n         ~azure.mgmt.edgegateway.models.AsymmetricEncryptedSecret\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37055:c0:m18"}
{"signature": "def list_by_data_box_edge_device(<EOL>self, device_name, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_data_box_edge_device.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", device_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SharePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SharePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all the shares in a data box edge/gateway device.\n\n        :param device_name: The device name.\n        :type device_name: str\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Share\n        :rtype:\n         ~azure.mgmt.edgegateway.models.SharePaged[~azure.mgmt.edgegateway.models.Share]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37057:c0:m1"}
{"signature": "def get(<EOL>self, upn_or_object_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", upn_or_object_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.tenant_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.GraphErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets user information from the directory.\n\n        :param upn_or_object_id: The object ID or principal name of the user\n         for which to get information.\n        :type upn_or_object_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: User or ClientRawResponse if raw=true\n        :rtype: ~azure.graphrbac.models.User or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`GraphErrorException<azure.graphrbac.models.GraphErrorException>`", "id": "f37158:c0:m3"}
{"signature": "def get(<EOL>self, domain_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", domain_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.tenant_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a specific domain in the current tenant.\n\n        :param domain_name: name of the domain.\n        :type domain_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Domain or ClientRawResponse if raw=true\n        :rtype: ~azure.graphrbac.models.Domain or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37160:c0:m2"}
{"signature": "def list_owned_objects(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_owned_objects.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.tenant_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = '<STR_LIT>'<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", next_link, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.tenant_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.GraphErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.DirectoryObjectPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.DirectoryObjectPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the list of directory objects that are owned by the user.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of DirectoryObject\n        :rtype:\n         ~azure.graphrbac.models.DirectoryObjectPaged[~azure.graphrbac.models.DirectoryObject]\n        :raises:\n         :class:`GraphErrorException<azure.graphrbac.models.GraphErrorException>`", "id": "f37162:c0:m2"}
{"signature": "def get_service_principals_id_by_app_id(<EOL>self, application_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_service_principals_id_by_app_id.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.tenant_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", application_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.GraphErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets an object id for a given application id from the current tenant.\n\n        :param application_id: The application ID.\n        :type application_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ServicePrincipalObjectResult or ClientRawResponse if raw=true\n        :rtype: ~azure.graphrbac.models.ServicePrincipalObjectResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`GraphErrorException<azure.graphrbac.models.GraphErrorException>`", "id": "f37163:c0:m13"}
{"signature": "def update_password_credentials(<EOL>self, application_object_id, value, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.PasswordCredentialsUpdateParameters(value=value)<EOL>url = self.update_password_credentials.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", application_object_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.tenant_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.GraphErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Update passwordCredentials associated with an application.\n\n        :param application_object_id: Application object ID.\n        :type application_object_id: str\n        :param value: A collection of PasswordCredentials.\n        :type value: list[~azure.graphrbac.models.PasswordCredential]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`GraphErrorException<azure.graphrbac.models.GraphErrorException>`", "id": "f37163:c0:m12"}
{"signature": "def add_owner(<EOL>self, application_object_id, url, additional_properties=None, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.AddOwnerParameters(additional_properties=additional_properties, url=url)<EOL>url = self.add_owner.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", application_object_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.tenant_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.GraphErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Add an owner to an application.\n\n        :param application_object_id: The object ID of the application to\n         which to add the owner.\n        :type application_object_id: str\n        :param url: A owner object URL, such as\n         \"https://graph.windows.net/0b1f9851-1bf0-433f-aec3-cb9272f093dc/directoryObjects/f260bbc4-c254-447b-94cf-293b5ec434dd\",\n         where \"0b1f9851-1bf0-433f-aec3-cb9272f093dc\" is the tenantId and\n         \"f260bbc4-c254-447b-94cf-293b5ec434dd\" is the objectId of the owner\n         (user, application, servicePrincipal, group) to be added.\n        :type url: str\n        :param additional_properties: Unmatched properties from the message\n         are deserialized this collection\n        :type additional_properties: dict[str, object]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`GraphErrorException<azure.graphrbac.models.GraphErrorException>`", "id": "f37163:c0:m7"}
{"signature": "def list_key_credentials(<EOL>self, application_object_id, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_key_credentials.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", application_object_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.tenant_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.GraphErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.KeyCredentialPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.KeyCredentialPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the keyCredentials associated with an application.\n\n        :param application_object_id: Application object ID.\n        :type application_object_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of KeyCredential\n        :rtype:\n         ~azure.graphrbac.models.KeyCredentialPaged[~azure.graphrbac.models.KeyCredential]\n        :raises:\n         :class:`GraphErrorException<azure.graphrbac.models.GraphErrorException>`", "id": "f37163:c0:m9"}
{"signature": "def delete(<EOL>self, application_object_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", application_object_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.tenant_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.GraphErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Delete an application.\n\n        :param application_object_id: Application object ID.\n        :type application_object_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`GraphErrorException<azure.graphrbac.models.GraphErrorException>`", "id": "f37163:c0:m3"}
{"signature": "def list(<EOL>self, filter=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.tenant_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = '<STR_LIT>'<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", next_link, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.tenant_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.GraphErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ServicePrincipalPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ServicePrincipalPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of service principals from the current tenant.\n\n        :param filter: The filter to apply to the operation.\n        :type filter: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ServicePrincipal\n        :rtype:\n         ~azure.graphrbac.models.ServicePrincipalPaged[~azure.graphrbac.models.ServicePrincipal]\n        :raises:\n         :class:`GraphErrorException<azure.graphrbac.models.GraphErrorException>`", "id": "f37164:c0:m2"}
{"signature": "def list_owners(<EOL>self, object_id, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_owners.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", object_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.tenant_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.GraphErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.DirectoryObjectPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.DirectoryObjectPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Directory objects that are owners of this service principal.\n\n        The owners are a set of non-admin users who are allowed to modify this\n        object.\n\n        :param object_id: The object ID of the service principal for which to\n         get owners.\n        :type object_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of DirectoryObject\n        :rtype:\n         ~azure.graphrbac.models.DirectoryObjectPaged[~azure.graphrbac.models.DirectoryObject]\n        :raises:\n         :class:`GraphErrorException<azure.graphrbac.models.GraphErrorException>`", "id": "f37164:c0:m6"}
{"signature": "def delete(<EOL>self, object_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", object_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.tenant_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.GraphErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes a service principal from the directory.\n\n        :param object_id: The object ID of the service principal to delete.\n        :type object_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`GraphErrorException<azure.graphrbac.models.GraphErrorException>`", "id": "f37164:c0:m4"}
{"signature": "def is_member_of(<EOL>self, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.is_member_of.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.tenant_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.GraphErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Checks whether the specified user, group, contact, or service principal\n        is a direct or transitive member of the specified group.\n\n        :param parameters: The check group membership parameters.\n        :type parameters:\n         ~azure.graphrbac.models.CheckGroupMembershipParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: CheckGroupMembershipResult or ClientRawResponse if raw=true\n        :rtype: ~azure.graphrbac.models.CheckGroupMembershipResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`GraphErrorException<azure.graphrbac.models.GraphErrorException>`", "id": "f37166:c0:m1"}
{"signature": "def list_owners(<EOL>self, object_id, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_owners.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", object_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.tenant_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.GraphErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.DirectoryObjectPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.DirectoryObjectPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Directory objects that are owners of the group.\n\n        The owners are a set of non-admin users who are allowed to modify this\n        object.\n\n        :param object_id: The object ID of the group for which to get owners.\n        :type object_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of DirectoryObject\n        :rtype:\n         ~azure.graphrbac.models.DirectoryObjectPaged[~azure.graphrbac.models.DirectoryObject]\n        :raises:\n         :class:`GraphErrorException<azure.graphrbac.models.GraphErrorException>`", "id": "f37166:c0:m10"}
{"signature": "def get_group_members(<EOL>self, object_id, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.get_group_members.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", object_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.tenant_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = '<STR_LIT>'<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", next_link, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.tenant_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.GraphErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.DirectoryObjectPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.DirectoryObjectPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the members of a group.\n\n        :param object_id: The object ID of the group whose members should be\n         retrieved.\n        :type object_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of DirectoryObject\n        :rtype:\n         ~azure.graphrbac.models.DirectoryObjectPaged[~azure.graphrbac.models.DirectoryObject]\n        :raises:\n         :class:`GraphErrorException<azure.graphrbac.models.GraphErrorException>`", "id": "f37166:c0:m6"}
{"signature": "def remove_owner(<EOL>self, object_id, owner_object_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.remove_owner.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", object_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", owner_object_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.tenant_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.GraphErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Remove a member from owners.\n\n        :param object_id: The object ID of the group from which to remove the\n         owner.\n        :type object_id: str\n        :param owner_object_id: Owner object id\n        :type owner_object_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`GraphErrorException<azure.graphrbac.models.GraphErrorException>`", "id": "f37166:c0:m12"}
{"signature": "def add_owner(<EOL>self, object_id, url, additional_properties=None, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.AddOwnerParameters(additional_properties=additional_properties, url=url)<EOL>url = self.add_owner.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", object_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.tenant_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.GraphErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Add an owner to a group.\n\n        :param object_id: The object ID of the application to which to add the\n         owner.\n        :type object_id: str\n        :param url: A owner object URL, such as\n         \"https://graph.windows.net/0b1f9851-1bf0-433f-aec3-cb9272f093dc/directoryObjects/f260bbc4-c254-447b-94cf-293b5ec434dd\",\n         where \"0b1f9851-1bf0-433f-aec3-cb9272f093dc\" is the tenantId and\n         \"f260bbc4-c254-447b-94cf-293b5ec434dd\" is the objectId of the owner\n         (user, application, servicePrincipal, group) to be added.\n        :type url: str\n        :param additional_properties: Unmatched properties from the message\n         are deserialized this collection\n        :type additional_properties: dict[str, object]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`GraphErrorException<azure.graphrbac.models.GraphErrorException>`", "id": "f37166:c0:m11"}
{"signature": "def get(<EOL>self, object_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", object_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.tenant_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.GraphErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets group information from the directory.\n\n        :param object_id: The object ID of the user for which to get group\n         information.\n        :type object_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ADGroup or ClientRawResponse if raw=true\n        :rtype: ~azure.graphrbac.models.ADGroup or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`GraphErrorException<azure.graphrbac.models.GraphErrorException>`", "id": "f37166:c0:m7"}
{"signature": "def hard_delete(<EOL>self, application_object_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.hard_delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", application_object_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.tenant_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.GraphErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Hard-delete an application.\n\n        :param application_object_id: Application object ID.\n        :type application_object_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`GraphErrorException<azure.graphrbac.models.GraphErrorException>`", "id": "f37167:c0:m3"}
{"signature": "def list(<EOL>self, filter=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.tenant_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = '<STR_LIT>'<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", next_link, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.tenant_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.GraphErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ApplicationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ApplicationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of deleted applications in the directory.\n\n        :param filter: The filter to apply to the operation.\n        :type filter: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Application\n        :rtype:\n         ~azure.graphrbac.models.ApplicationPaged[~azure.graphrbac.models.Application]\n        :raises:\n         :class:`GraphErrorException<azure.graphrbac.models.GraphErrorException>`", "id": "f37167:c0:m2"}
{"signature": "def list_keys_for_key_name(<EOL>self, provisioning_service_name, key_name, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_keys_for_key_name.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", provisioning_service_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", key_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorDetailsException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get a shared access policy by name from a provisioning service.\n\n        List primary and secondary keys for a specific key name.\n\n        :param provisioning_service_name: Name of the provisioning service.\n        :type provisioning_service_name: str\n        :param key_name: Logical key name to get key-values for.\n        :type key_name: str\n        :param resource_group_name: The name of the resource group that\n         contains the provisioning service.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SharedAccessSignatureAuthorizationRuleAccessRightsDescription\n         or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.iothubprovisioningservices.models.SharedAccessSignatureAuthorizationRuleAccessRightsDescription\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorDetailsException<azure.mgmt.iothubprovisioningservices.models.ErrorDetailsException>`", "id": "f37223:c0:m14"}
{"signature": "def get(<EOL>self, provisioning_service_name, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", provisioning_service_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorDetailsException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the non-security related metadata of the provisioning service.\n\n        Get the metadata of the provisioning service without SAS keys.\n\n        :param provisioning_service_name: Name of the provisioning service to\n         retrieve.\n        :type provisioning_service_name: str\n        :param resource_group_name: Resource group name.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ProvisioningServiceDescription or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.iothubprovisioningservices.models.ProvisioningServiceDescription\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorDetailsException<azure.mgmt.iothubprovisioningservices.models.ErrorDetailsException>`", "id": "f37223:c0:m1"}
{"signature": "def list_by_subscription(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_subscription.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorDetailsException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ProvisioningServiceDescriptionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ProvisioningServiceDescriptionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get all the provisioning services in a subscription.\n\n        List all the provisioning services for a given subscription id.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ProvisioningServiceDescription\n        :rtype:\n         ~azure.mgmt.iothubprovisioningservices.models.ProvisioningServiceDescriptionPaged[~azure.mgmt.iothubprovisioningservices.models.ProvisioningServiceDescription]\n        :raises:\n         :class:`ErrorDetailsException<azure.mgmt.iothubprovisioningservices.models.ErrorDetailsException>`", "id": "f37223:c0:m8"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorDetailsException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ProvisioningServiceDescriptionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ProvisioningServiceDescriptionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get a list of all provisioning services in the given resource group.\n\n        :param resource_group_name: Resource group identifier.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ProvisioningServiceDescription\n        :rtype:\n         ~azure.mgmt.iothubprovisioningservices.models.ProvisioningServiceDescriptionPaged[~azure.mgmt.iothubprovisioningservices.models.ProvisioningServiceDescription]\n        :raises:\n         :class:`ErrorDetailsException<azure.mgmt.iothubprovisioningservices.models.ErrorDetailsException>`", "id": "f37223:c0:m9"}
{"signature": "def image_search(<EOL>self, custom_config, query, accept_language=None, user_agent=None, client_id=None, client_ip=None, location=None, aspect=None, color=None, country_code=None, count=None, freshness=None, height=None, id=None, image_content=None, image_type=None, license=None, market=None, max_file_size=None, max_height=None, max_width=None, min_file_size=None, min_height=None, min_width=None, offset=None, safe_search=None, size=None, set_lang=None, width=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.image_search.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", custom_config, '<STR_LIT>', minimum=<NUM_LIT:0>)<EOL>if aspect is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", aspect, '<STR_LIT:str>')<EOL><DEDENT>if color is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", color, '<STR_LIT:str>')<EOL><DEDENT>if country_code is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", country_code, '<STR_LIT:str>')<EOL><DEDENT>if count is not None:<EOL><INDENT>query_parameters['<STR_LIT:count>'] = self._serialize.query(\"<STR_LIT:count>\", count, '<STR_LIT:int>')<EOL><DEDENT>if freshness is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", freshness, '<STR_LIT:str>')<EOL><DEDENT>if height is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", height, '<STR_LIT:int>')<EOL><DEDENT>if id is not None:<EOL><INDENT>query_parameters['<STR_LIT:id>'] = self._serialize.query(\"<STR_LIT:id>\", id, '<STR_LIT:str>')<EOL><DEDENT>if image_content is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", image_content, '<STR_LIT:str>')<EOL><DEDENT>if image_type is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", image_type, '<STR_LIT:str>')<EOL><DEDENT>if license is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", license, '<STR_LIT:str>')<EOL><DEDENT>if market is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", market, '<STR_LIT:str>')<EOL><DEDENT>if max_file_size is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", max_file_size, '<STR_LIT>')<EOL><DEDENT>if max_height is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", max_height, '<STR_LIT>')<EOL><DEDENT>if max_width is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", max_width, '<STR_LIT>')<EOL><DEDENT>if min_file_size is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", min_file_size, '<STR_LIT>')<EOL><DEDENT>if min_height is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", min_height, '<STR_LIT>')<EOL><DEDENT>if min_width is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", min_width, '<STR_LIT>')<EOL><DEDENT>if offset is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", offset, '<STR_LIT>')<EOL><DEDENT>query_parameters['<STR_LIT:q>'] = self._serialize.query(\"<STR_LIT>\", query, '<STR_LIT:str>')<EOL>if safe_search is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", safe_search, '<STR_LIT:str>')<EOL><DEDENT>if size is not None:<EOL><INDENT>query_parameters['<STR_LIT:size>'] = self._serialize.query(\"<STR_LIT:size>\", size, '<STR_LIT:str>')<EOL><DEDENT>if set_lang is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", set_lang, '<STR_LIT:str>')<EOL><DEDENT>if width is not None:<EOL><INDENT>query_parameters['<STR_LIT:width>'] = self._serialize.query(\"<STR_LIT:width>\", width, '<STR_LIT:int>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.x_bing_apis_sdk, '<STR_LIT:str>')<EOL>if accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", accept_language, '<STR_LIT:str>')<EOL><DEDENT>if user_agent is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", user_agent, '<STR_LIT:str>')<EOL><DEDENT>if client_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", client_id, '<STR_LIT:str>')<EOL><DEDENT>if client_ip is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", client_ip, '<STR_LIT:str>')<EOL><DEDENT>if location is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT:location>\", location, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "The Custom Image Search API lets you send an image search query to Bing\n        and get image results found in your custom view of the web.\n\n        :param custom_config: The identifier for the custom search\n         configuration\n        :type custom_config: long\n        :param query: The user's search query term. The term cannot be empty.\n         The term may contain [Bing Advanced\n         Operators](http://msdn.microsoft.com/library/ff795620.aspx). For\n         example, to limit images to a specific domain, use the\n         [site:](http://msdn.microsoft.com/library/ff795613.aspx) operator. To\n         help improve relevance of an insights query (see\n         [insightsToken](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#insightstoken)),\n         you should always include the user's query term. Use this parameter\n         only with the Image Search API.Do not specify this parameter when\n         calling the Trending Images API.\n        :type query: str\n        :param accept_language: A comma-delimited list of one or more\n         languages to use for user interface strings. The list is in decreasing\n         order of preference. For additional information, including expected\n         format, see\n         [RFC2616](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html).\n         This header and the\n         [setLang](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#setlang)\n         query parameter are mutually exclusive; do not specify both. If you\n         set this header, you must also specify the\n         [cc](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#cc)\n         query parameter. To determine the market to return results for, Bing\n         uses the first supported language it finds from the list and combines\n         it with the cc parameter value. If the list does not include a\n         supported language, Bing finds the closest language and market that\n         supports the request or it uses an aggregated or default market for\n         the results. To determine the market that Bing used, see the\n         BingAPIs-Market header. Use this header and the cc query parameter\n         only if you specify multiple languages. Otherwise, use the\n         [mkt](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#mkt)\n         and\n         [setLang](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#setlang)\n         query parameters. A user interface string is a string that's used as a\n         label in a user interface. There are few user interface strings in the\n         JSON response objects. Any links to Bing.com properties in the\n         response objects apply the specified language.\n        :type accept_language: str\n        :param user_agent: The user agent originating the request. Bing uses\n         the user agent to provide mobile users with an optimized experience.\n         Although optional, you are encouraged to always specify this header.\n         The user-agent should be the same string that any commonly used\n         browser sends. For information about user agents, see [RFC\n         2616](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html). The\n         following are examples of user-agent strings. Windows Phone:\n         Mozilla/5.0 (compatible; MSIE 10.0; Windows Phone 8.0; Trident/6.0;\n         IEMobile/10.0; ARM; Touch; NOKIA; Lumia 822). Android: Mozilla / 5.0\n         (Linux; U; Android 2.3.5; en - us; SCH - I500 Build / GINGERBREAD)\n         AppleWebKit / 533.1 (KHTML; like Gecko) Version / 4.0 Mobile Safari /\n         533.1. iPhone: Mozilla / 5.0 (iPhone; CPU iPhone OS 6_1 like Mac OS X)\n         AppleWebKit / 536.26 (KHTML; like Gecko) Mobile / 10B142 iPhone4; 1\n         BingWeb / 3.03.1428.20120423. PC: Mozilla / 5.0 (Windows NT 6.3;\n         WOW64; Trident / 7.0; Touch; rv:11.0) like Gecko. iPad: Mozilla / 5.0\n         (iPad; CPU OS 7_0 like Mac OS X) AppleWebKit / 537.51.1 (KHTML, like\n         Gecko) Version / 7.0 Mobile / 11A465 Safari / 9537.53\n        :type user_agent: str\n        :param client_id: Bing uses this header to provide users with\n         consistent behavior across Bing API calls. Bing often flights new\n         features and improvements, and it uses the client ID as a key for\n         assigning traffic on different flights. If you do not use the same\n         client ID for a user across multiple requests, then Bing may assign\n         the user to multiple conflicting flights. Being assigned to multiple\n         conflicting flights can lead to an inconsistent user experience. For\n         example, if the second request has a different flight assignment than\n         the first, the experience may be unexpected. Also, Bing can use the\n         client ID to tailor web results to that client ID\u2019s search history,\n         providing a richer experience for the user. Bing also uses this header\n         to help improve result rankings by analyzing the activity generated by\n         a client ID. The relevance improvements help with better quality of\n         results delivered by Bing APIs and in turn enables higher\n         click-through rates for the API consumer. IMPORTANT: Although\n         optional, you should consider this header required. Persisting the\n         client ID across multiple requests for the same end user and device\n         combination enables 1) the API consumer to receive a consistent user\n         experience, and 2) higher click-through rates via better quality of\n         results from the Bing APIs. Each user that uses your application on\n         the device must have a unique, Bing generated client ID. If you do not\n         include this header in the request, Bing generates an ID and returns\n         it in the X-MSEdge-ClientID response header. The only time that you\n         should NOT include this header in a request is the first time the user\n         uses your app on that device. Use the client ID for each Bing API\n         request that your app makes for this user on the device. Persist the\n         client ID. To persist the ID in a browser app, use a persistent HTTP\n         cookie to ensure the ID is used across all sessions. Do not use a\n         session cookie. For other apps such as mobile apps, use the device's\n         persistent storage to persist the ID. The next time the user uses your\n         app on that device, get the client ID that you persisted. Bing\n         responses may or may not include this header. If the response includes\n         this header, capture the client ID and use it for all subsequent Bing\n         requests for the user on that device. If you include the\n         X-MSEdge-ClientID, you must not include cookies in the request.\n        :type client_id: str\n        :param client_ip: The IPv4 or IPv6 address of the client device. The\n         IP address is used to discover the user's location. Bing uses the\n         location information to determine safe search behavior. Although\n         optional, you are encouraged to always specify this header and the\n         X-Search-Location header. Do not obfuscate the address (for example,\n         by changing the last octet to 0). Obfuscating the address results in\n         the location not being anywhere near the device's actual location,\n         which may result in Bing serving erroneous results.\n        :type client_ip: str\n        :param location: A semicolon-delimited list of key/value pairs that\n         describe the client's geographical location. Bing uses the location\n         information to determine safe search behavior and to return relevant\n         local content. Specify the key/value pair as <key>:<value>. The\n         following are the keys that you use to specify the user's location.\n         lat (required): The latitude of the client's location, in degrees. The\n         latitude must be greater than or equal to -90.0 and less than or equal\n         to +90.0. Negative values indicate southern latitudes and positive\n         values indicate northern latitudes. long (required): The longitude of\n         the client's location, in degrees. The longitude must be greater than\n         or equal to -180.0 and less than or equal to +180.0. Negative values\n         indicate western longitudes and positive values indicate eastern\n         longitudes. re (required): The radius, in meters, which specifies the\n         horizontal accuracy of the coordinates. Pass the value returned by the\n         device's location service. Typical values might be 22m for GPS/Wi-Fi,\n         380m for cell tower triangulation, and 18,000m for reverse IP lookup.\n         ts (optional): The UTC UNIX timestamp of when the client was at the\n         location. (The UNIX timestamp is the number of seconds since January\n         1, 1970.) head (optional): The client's relative heading or direction\n         of travel. Specify the direction of travel as degrees from 0 through\n         360, counting clockwise relative to true north. Specify this key only\n         if the sp key is nonzero. sp (optional): The horizontal velocity\n         (speed), in meters per second, that the client device is traveling.\n         alt (optional): The altitude of the client device, in meters. are\n         (optional): The radius, in meters, that specifies the vertical\n         accuracy of the coordinates. Specify this key only if you specify the\n         alt key. Although many of the keys are optional, the more information\n         that you provide, the more accurate the location results are. Although\n         optional, you are encouraged to always specify the user's geographical\n         location. Providing the location is especially important if the\n         client's IP address does not accurately reflect the user's physical\n         location (for example, if the client uses VPN). For optimal results,\n         you should include this header and the X-MSEdge-ClientIP header, but\n         at a minimum, you should include this header.\n        :type location: str\n        :param aspect: Filter images by the following aspect ratios. All: Do\n         not filter by aspect.Specifying this value is the same as not\n         specifying the aspect parameter. Square: Return images with standard\n         aspect ratio. Wide: Return images with wide screen aspect ratio. Tall:\n         Return images with tall aspect ratio. Possible values include: 'All',\n         'Square', 'Wide', 'Tall'\n        :type aspect: str or\n         ~azure.cognitiveservices.search.customimagesearch.models.ImageAspect\n        :param color: Filter images by the following color options. ColorOnly:\n         Return color images. Monochrome: Return black and white images. Return\n         images with one of the following dominant colors: Black, Blue, Brown,\n         Gray, Green, Orange, Pink, Purple, Red, Teal, White, Yellow. Possible\n         values include: 'ColorOnly', 'Monochrome', 'Black', 'Blue', 'Brown',\n         'Gray', 'Green', 'Orange', 'Pink', 'Purple', 'Red', 'Teal', 'White',\n         'Yellow'\n        :type color: str or\n         ~azure.cognitiveservices.search.customimagesearch.models.ImageColor\n        :param country_code: A 2-character country code of the country where\n         the results come from. For a list of possible values, see [Market\n         Codes](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#market-codes).\n         If you set this parameter, you must also specify the\n         [Accept-Language](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#acceptlanguage)\n         header. Bing uses the first supported language it finds from the\n         languages list, and combine that language with the country code that\n         you specify to determine the market to return results for. If the\n         languages list does not include a supported language, Bing finds the\n         closest language and market that supports the request, or it may use\n         an aggregated or default market for the results instead of a specified\n         one. You should use this query parameter and the Accept-Language query\n         parameter only if you specify multiple languages; otherwise, you\n         should use the mkt and setLang query parameters. This parameter and\n         the\n         [mkt](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#mkt)\n         query parameter are mutually exclusive\u2014do not specify both.\n        :type country_code: str\n        :param count: The number of images to return in the response. The\n         actual number delivered may be less than requested. The default is 35.\n         The maximum value is 150. You use this parameter along with the offset\n         parameter to page results.For example, if your user interface displays\n         20 images per page, set count to 20 and offset to 0 to get the first\n         page of results.For each subsequent page, increment offset by 20 (for\n         example, 0, 20, 40). Use this parameter only with the Image Search\n         API.Do not specify this parameter when calling the Insights, Trending\n         Images, or Web Search APIs.\n        :type count: int\n        :param freshness: Filter images by the following discovery options.\n         Day: Return images discovered by Bing within the last 24 hours. Week:\n         Return images discovered by Bing within the last 7 days. Month: Return\n         images discovered by Bing within the last 30 days. Possible values\n         include: 'Day', 'Week', 'Month'\n        :type freshness: str or\n         ~azure.cognitiveservices.search.customimagesearch.models.Freshness\n        :param height: Filter images that have the specified height, in\n         pixels. You may use this filter with the size filter to return small\n         images that have a height of 150 pixels.\n        :type height: int\n        :param id: An ID that uniquely identifies an image. Use this parameter\n         to ensure that the specified image is the first image in the list of\n         images that Bing returns. The\n         [Image](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#image)\n         object's imageId field contains the ID that you set this parameter to.\n        :type id: str\n        :param image_content: Filter images by the following content types.\n         Face: Return images that show only a person's face. Portrait: Return\n         images that show only a person's head and shoulders. Possible values\n         include: 'Face', 'Portrait'\n        :type image_content: str or\n         ~azure.cognitiveservices.search.customimagesearch.models.ImageContent\n        :param image_type: Filter images by the following image types.\n         AnimatedGif: Return only animated GIFs. Clipart: Return only clip art\n         images. Line: Return only line drawings. Photo: Return only\n         photographs(excluding line drawings, animated Gifs, and clip art).\n         Shopping: Return only images that contain items where Bing knows of a\n         merchant that is selling the items. This option is valid in the en -\n         US market only.Transparent: Return only images with a transparent\n         background. Possible values include: 'AnimatedGif', 'Clipart', 'Line',\n         'Photo', 'Shopping', 'Transparent'\n        :type image_type: str or\n         ~azure.cognitiveservices.search.customimagesearch.models.ImageType\n        :param license: Filter images by the following license types. All: Do\n         not filter by license type.Specifying this value is the same as not\n         specifying the license parameter. Any: Return images that are under\n         any license type. The response doesn't include images that do not\n         specify a license or the license is unknown. Public: Return images\n         where the creator has waived their exclusive rights, to the fullest\n         extent allowed by law. Share: Return images that may be shared with\n         others. Changing or editing the image might not be allowed. Also,\n         modifying, sharing, and using the image for commercial purposes might\n         not be allowed. Typically, this option returns the most images.\n         ShareCommercially: Return images that may be shared with others for\n         personal or commercial purposes. Changing or editing the image might\n         not be allowed. Modify: Return images that may be modified, shared,\n         and used. Changing or editing the image might not be allowed.\n         Modifying, sharing, and using the image for commercial purposes might\n         not be allowed. ModifyCommercially: Return images that may be\n         modified, shared, and used for personal or commercial purposes.\n         Typically, this option returns the fewest images. For more information\n         about these license types, see [Filter Images By License\n         Type](http://go.microsoft.com/fwlink/?LinkId=309768). Possible values\n         include: 'All', 'Any', 'Public', 'Share', 'ShareCommercially',\n         'Modify', 'ModifyCommercially'\n        :type license: str or\n         ~azure.cognitiveservices.search.customimagesearch.models.ImageLicense\n        :param market: The market where the results come from. Typically, mkt\n         is the country where the user is making the request from. However, it\n         could be a different country if the user is not located in a country\n         where Bing delivers results. The market must be in the form <language\n         code>-<country code>. For example, en-US. The string is case\n         insensitive. For a list of possible market values, see [Market\n         Codes](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#market-codes).\n         NOTE: If known, you are encouraged to always specify the market.\n         Specifying the market helps Bing route the request and return an\n         appropriate and optimal response. If you specify a market that is not\n         listed in [Market\n         Codes](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#market-codes),\n         Bing uses a best fit market code based on an internal mapping that is\n         subject to change. This parameter and the\n         [cc](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#cc)\n         query parameter are mutually exclusive\u2014do not specify both.\n        :type market: str\n        :param max_file_size: Filter images that are less than or equal to the\n         specified file size. The maximum file size that you may specify is\n         520,192 bytes. If you specify a larger value, the API uses 520,192. It\n         is possible that the response may include images that are slightly\n         larger than the specified maximum. You may specify this filter and\n         minFileSize to filter images within a range of file sizes.\n        :type max_file_size: long\n        :param max_height: Filter images that have a height that is less than\n         or equal to the specified height. Specify the height in pixels. You\n         may specify this filter and minHeight to filter images within a range\n         of heights. This filter and the height filter are mutually exclusive.\n        :type max_height: long\n        :param max_width: Filter images that have a width that is less than or\n         equal to the specified width. Specify the width in pixels. You may\n         specify this filter and maxWidth to filter images within a range of\n         widths. This filter and the width filter are mutually exclusive.\n        :type max_width: long\n        :param min_file_size: Filter images that are greater than or equal to\n         the specified file size. The maximum file size that you may specify is\n         520,192 bytes. If you specify a larger value, the API uses 520,192. It\n         is possible that the response may include images that are slightly\n         smaller than the specified minimum. You may specify this filter and\n         maxFileSize to filter images within a range of file sizes.\n        :type min_file_size: long\n        :param min_height: Filter images that have a height that is greater\n         than or equal to the specified height. Specify the height in pixels.\n         You may specify this filter and maxHeight to filter images within a\n         range of heights. This filter and the height filter are mutually\n         exclusive.\n        :type min_height: long\n        :param min_width: Filter images that have a width that is greater than\n         or equal to the specified width. Specify the width in pixels. You may\n         specify this filter and maxWidth to filter images within a range of\n         widths. This filter and the width filter are mutually exclusive.\n        :type min_width: long\n        :param offset: The zero-based offset that indicates the number of\n         images to skip before returning images. The default is 0. The offset\n         should be less than\n         ([totalEstimatedMatches](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#totalestimatedmatches)\n         - count). Use this parameter along with the count parameter to page\n         results. For example, if your user interface displays 20 images per\n         page, set count to 20 and offset to 0 to get the first page of\n         results. For each subsequent page, increment offset by 20 (for\n         example, 0, 20, 40). It is possible for multiple pages to include some\n         overlap in results. To prevent duplicates, see\n         [nextOffset](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#nextoffset).\n         Use this parameter only with the Image API. Do not specify this\n         parameter when calling the Trending Images API or the Web Search API.\n        :type offset: long\n        :param safe_search: Filter images for adult content. The following are\n         the possible filter values. Off: May return images with adult content.\n         If the request is through the Image Search API, the response includes\n         thumbnail images that are clear (non-fuzzy). However, if the request\n         is through the Web Search API, the response includes thumbnail images\n         that are pixelated (fuzzy). Moderate: If the request is through the\n         Image Search API, the response doesn't include images with adult\n         content. If the request is through the Web Search API, the response\n         may include images with adult content (the thumbnail images are\n         pixelated (fuzzy)). Strict: Do not return images with adult content.\n         The default is Moderate. If the request comes from a market that\n         Bing's adult policy requires that safeSearch is set to Strict, Bing\n         ignores the safeSearch value and uses Strict. If you use the site:\n         query operator, there is the chance that the response may contain\n         adult content regardless of what the safeSearch query parameter is set\n         to. Use site: only if you are aware of the content on the site and\n         your scenario supports the possibility of adult content. Possible\n         values include: 'Off', 'Moderate', 'Strict'\n        :type safe_search: str or\n         ~azure.cognitiveservices.search.customimagesearch.models.SafeSearch\n        :param size: Filter images by the following sizes. All: Do not filter\n         by size. Specifying this value is the same as not specifying the size\n         parameter. Small: Return images that are less than 200x200 pixels.\n         Medium: Return images that are greater than or equal to 200x200 pixels\n         but less than 500x500 pixels. Large: Return images that are 500x500\n         pixels or larger. Wallpaper: Return wallpaper images. You may use this\n         parameter along with the height or width parameters. For example, you\n         may use height and size to request small images that are 150 pixels\n         tall. Possible values include: 'All', 'Small', 'Medium', 'Large',\n         'Wallpaper'\n        :type size: str or\n         ~azure.cognitiveservices.search.customimagesearch.models.ImageSize\n        :param set_lang: The language to use for user interface strings.\n         Specify the language using the ISO 639-1 2-letter language code. For\n         example, the language code for English is EN. The default is EN\n         (English). Although optional, you should always specify the language.\n         Typically, you set setLang to the same language specified by mkt\n         unless the user wants the user interface strings displayed in a\n         different language. This parameter and the\n         [Accept-Language](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#acceptlanguage)\n         header are mutually exclusive; do not specify both. A user interface\n         string is a string that's used as a label in a user interface. There\n         are few user interface strings in the JSON response objects. Also, any\n         links to Bing.com properties in the response objects apply the\n         specified language.\n        :type set_lang: str\n        :param width: Filter images that have the specified width, in pixels.\n         You may use this filter with the size filter to return small images\n         that have a width of 150 pixels.\n        :type width: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Images or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.cognitiveservices.search.customimagesearch.models.Images or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.search.customimagesearch.models.ErrorResponseException>`", "id": "f37258:c0:m1"}
{"signature": "def list(<EOL>self, filter=None, top=None, skip_token=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>')<EOL><DEDENT>if skip_token is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", skip_token, '<STR_LIT:str>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ResourceRecommendationBasePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ResourceRecommendationBasePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Obtains cached recommendations for a subscription. The recommendations\n        are generated or computed by invoking generateRecommendations.\n\n        :param filter: The filter to apply to the recommendations.\n        :type filter: str\n        :param top: The number of recommendations per page if a paged version\n         of this API is being used.\n        :type top: int\n        :param skip_token: The page-continuation token to use with a paged\n         version of this API.\n        :type skip_token: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ResourceRecommendationBase\n        :rtype:\n         ~azure.mgmt.advisor.models.ResourceRecommendationBasePaged[~azure.mgmt.advisor.models.ResourceRecommendationBase]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37289:c0:m3"}
{"signature": "def get(<EOL>self, resource_uri, recommendation_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_uri, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", recommendation_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Obtains details of a cached recommendation.\n\n        :param resource_uri: The fully qualified Azure Resource Manager\n         identifier of the resource to which the recommendation applies.\n        :type resource_uri: str\n        :param recommendation_id: The recommendation ID.\n        :type recommendation_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ResourceRecommendationBase or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.advisor.models.ResourceRecommendationBase or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37289:c0:m4"}
{"signature": "def list(<EOL>self, top=None, skip_token=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>')<EOL><DEDENT>if skip_token is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", skip_token, '<STR_LIT:str>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SuppressionContractPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SuppressionContractPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves the list of snoozed or dismissed suppressions for a\n        subscription. The snoozed or dismissed attribute of a recommendation is\n        referred to as a suppression.\n\n        :param top: The number of suppressions per page if a paged version of\n         this API is being used.\n        :type top: int\n        :param skip_token: The page-continuation token to use with a paged\n         version of this API.\n        :type skip_token: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of SuppressionContract\n        :rtype:\n         ~azure.mgmt.advisor.models.SuppressionContractPaged[~azure.mgmt.advisor.models.SuppressionContract]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37290:c0:m4"}
{"signature": "def get_at_subscription_level(<EOL>self, lock_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_at_subscription_level.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", lock_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a management lock at the subscription level.\n\n        :param lock_name: The name of the lock to get.\n        :type lock_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ManagementLockObject or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.locks.v2016_09_01.models.ManagementLockObject or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37316:c0:m12"}
{"signature": "def delete_at_resource_group_level(<EOL>self, resource_group_name, lock_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete_at_resource_group_level.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", lock_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes a management lock at the resource group level.\n\n        To delete management locks, you must have access to\n        Microsoft.Authorization/* or Microsoft.Authorization/locks/* actions.\n        Of the built-in roles, only Owner and User Access Administrator are\n        granted those actions.\n\n        :param resource_group_name: The name of the resource group containing\n         the lock.\n        :type resource_group_name: str\n        :param lock_name: The name of lock to delete.\n        :type lock_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37316:c0:m2"}
{"signature": "def create_or_update_at_resource_level(<EOL>self, resource_group_name, resource_provider_namespace, parent_resource_path, resource_type, resource_name, lock_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update_at_resource_level.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_provider_namespace, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", parent_resource_path, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_type, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", lock_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Create or update a management lock at the resource level or any level\n        below resource.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param resource_provider_namespace: Resource identity.\n        :type resource_provider_namespace: str\n        :param parent_resource_path: Resource identity.\n        :type parent_resource_path: str\n        :param resource_type: Resource identity.\n        :type resource_type: str\n        :param resource_name: Resource identity.\n        :type resource_name: str\n        :param lock_name: The name of lock.\n        :type lock_name: str\n        :param parameters: Create or update management lock parameters.\n        :type parameters:\n         ~azure.mgmt.resource.locks.v2015_01_01.models.ManagementLockObject\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ManagementLockObject or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.locks.v2015_01_01.models.ManagementLockObject or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37325:c0:m4"}
{"signature": "def delete_at_resource_group_level(<EOL>self, resource_group_name, lock_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete_at_resource_group_level.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", lock_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes the management lock of a resource group.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param lock_name: The name of lock.\n        :type lock_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37325:c0:m2"}
{"signature": "def get_at_resource_group_level(<EOL>self, resource_group_name, lock_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_at_resource_group_level.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", lock_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a management lock at the resource group level.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param lock_name: The lock name.\n        :type lock_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ManagementLockObject or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.locks.v2015_01_01.models.ManagementLockObject or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37325:c0:m3"}
{"signature": "def delete_at_resource_level(<EOL>self, resource_group_name, resource_provider_namespace, parent_resource_path, resource_type, resource_name, lock_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete_at_resource_level.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_provider_namespace, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", parent_resource_path, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_type, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", lock_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes the management lock of a resource or any level below resource.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param resource_provider_namespace: Resource identity.\n        :type resource_provider_namespace: str\n        :param parent_resource_path: Resource identity.\n        :type parent_resource_path: str\n        :param resource_type: Resource identity.\n        :type resource_type: str\n        :param resource_name: Resource identity.\n        :type resource_name: str\n        :param lock_name: The name of lock.\n        :type lock_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37325:c0:m5"}
{"signature": "def delete_at_subscription_level(<EOL>self, lock_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete_at_subscription_level.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", lock_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes the management lock of a subscription.\n\n        :param lock_name: The name of lock.\n        :type lock_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37325:c0:m7"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.OperationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.OperationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all of the available Microsoft.Resources REST API operations.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Operation\n        :rtype:\n         ~azure.mgmt.resource.subscriptions.v2016_06_01.models.OperationPaged[~azure.mgmt.resource.subscriptions.v2016_06_01.models.Operation]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37349:c0:m1"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SubscriptionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SubscriptionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all subscriptions for a tenant.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Subscription\n        :rtype:\n         ~azure.mgmt.resource.subscriptions.v2016_06_01.models.SubscriptionPaged[~azure.mgmt.resource.subscriptions.v2016_06_01.models.Subscription]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37350:c0:m3"}
{"signature": "def get(<EOL>self, subscription_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets details about a specified subscription.\n\n        :param subscription_id: The ID of the target subscription.\n        :type subscription_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Subscription or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.subscriptions.v2016_06_01.models.Subscription or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37350:c0:m2"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.TenantIdDescriptionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.TenantIdDescriptionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the tenants for your account.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of TenantIdDescription\n        :rtype:\n         ~azure.mgmt.resource.subscriptions.v2016_06_01.models.TenantIdDescriptionPaged[~azure.mgmt.resource.subscriptions.v2016_06_01.models.TenantIdDescription]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37351:c0:m1"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ApplicationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ApplicationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the applications within a resource group.\n\n        :param resource_group_name: The name of the resource group. The name\n         is case insensitive.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Application\n        :rtype:\n         ~azure.mgmt.resource.managedapplications.models.ApplicationPaged[~azure.mgmt.resource.managedapplications.models.Application]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.resource.managedapplications.models.ErrorResponseException>`", "id": "f37387:c0:m7"}
{"signature": "def update_by_id(<EOL>self, application_id, parameters=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.update_by_id.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", application_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if parameters is not None:<EOL><INDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>body_content = None<EOL><DEDENT>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Updates an existing managed application. The only value that can be\n        updated via PATCH currently is the tags.\n\n        :param application_id: The fully qualified ID of the managed\n         application, including the managed application name and the managed\n         application resource type. Use the format,\n         /subscriptions/{guid}/resourceGroups/{resource-group-name}/Microsoft.Solutions/applications/{application-name}\n        :type application_id: str\n        :param parameters: Parameters supplied to update an existing managed\n         application.\n        :type parameters:\n         ~azure.mgmt.resource.managedapplications.models.Application\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Application or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.resource.managedapplications.models.Application or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.resource.managedapplications.models.ErrorResponseException>`", "id": "f37387:c0:m14"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, application_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>application_name=application_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates a new managed application.\n\n        :param resource_group_name: The name of the resource group. The name\n         is case insensitive.\n        :type resource_group_name: str\n        :param application_name: The name of the managed application.\n        :type application_name: str\n        :param parameters: Parameters supplied to the create or update a\n         managed application.\n        :type parameters:\n         ~azure.mgmt.resource.managedapplications.models.Application\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Application or\n         ClientRawResponse<Application> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.resource.managedapplications.models.Application]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.resource.managedapplications.models.Application]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.resource.managedapplications.models.ErrorResponseException>`", "id": "f37387:c0:m5"}
{"signature": "def get_by_id(<EOL>self, application_definition_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_by_id.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", application_definition_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the managed application definition.\n\n        :param application_definition_id: The fully qualified ID of the\n         managed application definition, including the managed application name\n         and the managed application definition resource type. Use the format,\n         /subscriptions/{guid}/resourceGroups/{resource-group-name}/Microsoft.Solutions/applicationDefinitions/{applicationDefinition-name}\n        :type application_definition_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ApplicationDefinition or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.managedapplications.models.ApplicationDefinition\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.resource.managedapplications.models.ErrorResponseException>`", "id": "f37389:c0:m7"}
{"signature": "def delete(<EOL>self, resource_group_name, application_definition_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>application_definition_name=application_definition_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the managed application definition.\n\n        :param resource_group_name: The name of the resource group. The name\n         is case insensitive.\n        :type resource_group_name: str\n        :param application_definition_name: The name of the managed\n         application definition to delete.\n        :type application_definition_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.resource.managedapplications.models.ErrorResponseException>`", "id": "f37389:c0:m3"}
{"signature": "def create_by_id(<EOL>self, policy_assignment_id, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_by_id.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", policy_assignment_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates a policy assignment by ID.\n\n        Policy assignments are inherited by child resources. For example, when\n        you apply a policy to a resource group that policy is assigned to all\n        resources in the group. When providing a scope for the assignment, use\n        '/subscriptions/{subscription-id}/' for subscriptions,\n        '/subscriptions/{subscription-id}/resourceGroups/{resource-group-name}'\n        for resource groups, and\n        '/subscriptions/{subscription-id}/resourceGroups/{resource-group-name}/providers/{resource-provider-namespace}/{resource-type}/{resource-name}'\n        for resources.\n\n        :param policy_assignment_id: The ID of the policy assignment to\n         create. Use the format\n         '/{scope}/providers/Microsoft.Authorization/policyAssignments/{policy-assignment-name}'.\n        :type policy_assignment_id: str\n        :param parameters: Parameters for policy assignment.\n        :type parameters:\n         ~azure.mgmt.resource.policy.v2016_12_01.models.PolicyAssignment\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PolicyAssignment or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.policy.v2016_12_01.models.PolicyAssignment or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37401:c0:m8"}
{"signature": "def list_for_resource_group(<EOL>self, resource_group_name, filter=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_for_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>', skip_quote=True)<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PolicyAssignmentPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PolicyAssignmentPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets policy assignments for the resource group.\n\n        :param resource_group_name: The name of the resource group that\n         contains policy assignments.\n        :type resource_group_name: str\n        :param filter: The filter to apply on the operation.\n        :type filter: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PolicyAssignment\n        :rtype:\n         ~azure.mgmt.resource.policy.v2016_12_01.models.PolicyAssignmentPaged[~azure.mgmt.resource.policy.v2016_12_01.models.PolicyAssignment]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37401:c0:m4"}
{"signature": "def create(<EOL>self, scope, policy_assignment_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", scope, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", policy_assignment_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates a policy assignment.\n\n        Policy assignments are inherited by child resources. For example, when\n        you apply a policy to a resource group that policy is assigned to all\n        resources in the group.\n\n        :param scope: The scope of the policy assignment.\n        :type scope: str\n        :param policy_assignment_name: The name of the policy assignment.\n        :type policy_assignment_name: str\n        :param parameters: Parameters for the policy assignment.\n        :type parameters:\n         ~azure.mgmt.resource.policy.v2016_12_01.models.PolicyAssignment\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PolicyAssignment or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.policy.v2016_12_01.models.PolicyAssignment or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37401:c0:m2"}
{"signature": "def list_built_in(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_built_in.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PolicyDefinitionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PolicyDefinitionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the built in policy definitions.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PolicyDefinition\n        :rtype:\n         ~azure.mgmt.resource.policy.v2016_12_01.models.PolicyDefinitionPaged[~azure.mgmt.resource.policy.v2016_12_01.models.PolicyDefinition]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37403:c0:m9"}
{"signature": "def create_or_update_at_management_group(<EOL>self, policy_definition_name, parameters, management_group_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update_at_management_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", policy_definition_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", management_group_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or updates a policy definition at management group level.\n\n        :param policy_definition_name: The name of the policy definition to\n         create.\n        :type policy_definition_name: str\n        :param parameters: The policy definition properties.\n        :type parameters:\n         ~azure.mgmt.resource.policy.v2016_12_01.models.PolicyDefinition\n        :param management_group_id: The ID of the management group.\n        :type management_group_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PolicyDefinition or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.policy.v2016_12_01.models.PolicyDefinition or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37403:c0:m5"}
{"signature": "def delete_by_id(<EOL>self, policy_assignment_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete_by_id.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", policy_assignment_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Deletes a policy assignment by ID.\n\n        When providing a scope for the assignment, use\n        '/subscriptions/{subscription-id}/' for subscriptions,\n        '/subscriptions/{subscription-id}/resourceGroups/{resource-group-name}'\n        for resource groups, and\n        '/subscriptions/{subscription-id}/resourceGroups/{resource-group-name}/providers/{resource-provider-namespace}/{resource-type}/{resource-name}'\n        for resources.\n\n        :param policy_assignment_id: The ID of the policy assignment to\n         delete. Use the format\n         '/{scope}/providers/Microsoft.Authorization/policyAssignments/{policy-assignment-name}'.\n        :type policy_assignment_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PolicyAssignment or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.policy.v2016_04_01.models.PolicyAssignment or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37413:c0:m7"}
{"signature": "def list(<EOL>self, filter=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PolicyAssignmentPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PolicyAssignmentPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the policy assignments for a subscription.\n\n        :param filter: The filter to apply on the operation.\n        :type filter: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PolicyAssignment\n        :rtype:\n         ~azure.mgmt.resource.policy.v2016_04_01.models.PolicyAssignmentPaged[~azure.mgmt.resource.policy.v2016_04_01.models.PolicyAssignment]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37413:c0:m6"}
{"signature": "def create(<EOL>self, scope, policy_assignment_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", scope, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", policy_assignment_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates a policy assignment.\n\n        Policy assignments are inherited by child resources. For example, when\n        you apply a policy to a resource group that policy is assigned to all\n        resources in the group.\n\n        :param scope: The scope of the policy assignment.\n        :type scope: str\n        :param policy_assignment_name: The name of the policy assignment.\n        :type policy_assignment_name: str\n        :param parameters: Parameters for the policy assignment.\n        :type parameters:\n         ~azure.mgmt.resource.policy.v2015_10_01_preview.models.PolicyAssignment\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PolicyAssignment or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.policy.v2015_10_01_preview.models.PolicyAssignment\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37422:c0:m2"}
{"signature": "def list_for_resource(<EOL>self, resource_group_name, resource_provider_namespace, parent_resource_path, resource_type, resource_name, filter=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_for_resource.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_provider_namespace, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", parent_resource_path, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_type, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PolicyAssignmentPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PolicyAssignmentPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets policy assignments for a  resource.\n\n        :param resource_group_name: The name of the resource group containing\n         the resource. The name is case insensitive.\n        :type resource_group_name: str\n        :param resource_provider_namespace: The namespace of the resource\n         provider.\n        :type resource_provider_namespace: str\n        :param parent_resource_path: The parent resource path.\n        :type parent_resource_path: str\n        :param resource_type: The resource type.\n        :type resource_type: str\n        :param resource_name: The name of the resource with policy\n         assignments.\n        :type resource_name: str\n        :param filter: The filter to apply on the operation.\n        :type filter: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PolicyAssignment\n        :rtype:\n         ~azure.mgmt.resource.policy.v2015_10_01_preview.models.PolicyAssignmentPaged[~azure.mgmt.resource.policy.v2015_10_01_preview.models.PolicyAssignment]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37422:c0:m5"}
{"signature": "def delete_by_id(<EOL>self, policy_assignment_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete_by_id.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", policy_assignment_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Deletes a policy assignment by ID.\n\n        When providing a scope for the assignment, use\n        '/subscriptions/{subscription-id}/' for subscriptions,\n        '/subscriptions/{subscription-id}/resourceGroups/{resource-group-name}'\n        for resource groups, and\n        '/subscriptions/{subscription-id}/resourceGroups/{resource-group-name}/providers/{resource-provider-namespace}/{resource-type}/{resource-name}'\n        for resources.\n\n        :param policy_assignment_id: The ID of the policy assignment to\n         delete. Use the format\n         '/{scope}/providers/Microsoft.Authorization/policyAssignments/{policy-assignment-name}'.\n        :type policy_assignment_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PolicyAssignment or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.policy.v2015_10_01_preview.models.PolicyAssignment\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37422:c0:m7"}
{"signature": "def delete(<EOL>self, scope, policy_assignment_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", scope, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", policy_assignment_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Deletes a policy assignment.\n\n        :param scope: The scope of the policy assignment.\n        :type scope: str\n        :param policy_assignment_name: The name of the policy assignment to\n         delete.\n        :type policy_assignment_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PolicyAssignment or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.policy.v2015_10_01_preview.models.PolicyAssignment\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37422:c0:m1"}
{"signature": "def delete(<EOL>self, policy_definition_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", policy_definition_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes a policy definition.\n\n        :param policy_definition_name: The name of the policy definition to\n         delete.\n        :type policy_definition_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37423:c0:m2"}
{"signature": "def delete(<EOL>self, scope, policy_assignment_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", scope, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", policy_assignment_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Deletes a policy assignment.\n\n        This operation deletes a policy assignment, given its name and the\n        scope it was created in. The scope of a policy assignment is the part\n        of its ID preceding\n        '/providers/Microsoft.Authorization/policyAssignments/{policyAssignmentName}'.\n\n        :param scope: The scope of the policy assignment. Valid scopes are:\n         management group (format:\n         '/providers/Microsoft.Management/managementGroups/{managementGroup}'),\n         subscription (format: '/subscriptions/{subscriptionId}'), resource\n         group (format:\n         '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}',\n         or resource (format:\n         '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/[{parentResourcePath}/]{resourceType}/{resourceName}'\n        :type scope: str\n        :param policy_assignment_name: The name of the policy assignment to\n         delete.\n        :type policy_assignment_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PolicyAssignment or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.policy.v2018_03_01.models.PolicyAssignment or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.resource.policy.v2018_03_01.models.ErrorResponseException>`", "id": "f37442:c0:m1"}
{"signature": "def list_for_resource_group(<EOL>self, resource_group_name, filter=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_for_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>', skip_quote=True)<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PolicyAssignmentPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PolicyAssignmentPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves all policy assignments that apply to a resource group.\n\n        This operation retrieves the list of all policy assignments associated\n        with the given resource group in the given subscription that match the\n        optional given $filter. Valid values for $filter are: 'atScope()' or\n        'policyDefinitionId eq '{value}''. If $filter is not provided, the\n        unfiltered list includes all policy assignments associated with the\n        resource group, including those that apply directly or apply from\n        containing scopes, as well as any applied to resources contained within\n        the resource group. If $filter=atScope() is provided, the returned list\n        includes all policy assignments that apply to the resource group, which\n        is everything in the unfiltered list except those applied to resources\n        contained within the resource group. If $filter=policyDefinitionId eq\n        '{value}' is provided, the returned list includes only policy\n        assignments that apply to the resource group and assign the policy\n        definition whose id is {value}.\n\n        :param resource_group_name: The name of the resource group that\n         contains policy assignments.\n        :type resource_group_name: str\n        :param filter: The filter to apply on the operation. Valid values for\n         $filter are: 'atScope()' or 'policyDefinitionId eq '{value}''. If\n         $filter is not provided, no filtering is performed.\n        :type filter: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PolicyAssignment\n        :rtype:\n         ~azure.mgmt.resource.policy.v2018_03_01.models.PolicyAssignmentPaged[~azure.mgmt.resource.policy.v2018_03_01.models.PolicyAssignment]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.resource.policy.v2018_03_01.models.ErrorResponseException>`", "id": "f37442:c0:m4"}
{"signature": "def create_or_update_at_management_group(<EOL>self, policy_set_definition_name, parameters, management_group_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update_at_management_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", policy_set_definition_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", management_group_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or updates a policy set definition.\n\n        This operation creates or updates a policy set definition in the given\n        management group with the given name.\n\n        :param policy_set_definition_name: The name of the policy set\n         definition to create.\n        :type policy_set_definition_name: str\n        :param parameters: The policy set definition properties.\n        :type parameters:\n         ~azure.mgmt.resource.policy.v2018_03_01.models.PolicySetDefinition\n        :param management_group_id: The ID of the management group.\n        :type management_group_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PolicySetDefinition or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.policy.v2018_03_01.models.PolicySetDefinition or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.resource.policy.v2018_03_01.models.ErrorResponseException>`", "id": "f37443:c0:m7"}
{"signature": "def get_built_in(<EOL>self, policy_set_definition_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_built_in.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", policy_set_definition_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves a built in policy set definition.\n\n        This operation retrieves the built-in policy set definition with the\n        given name.\n\n        :param policy_set_definition_name: The name of the policy set\n         definition to get.\n        :type policy_set_definition_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PolicySetDefinition or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.policy.v2018_03_01.models.PolicySetDefinition or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.resource.policy.v2018_03_01.models.ErrorResponseException>`", "id": "f37443:c0:m4"}
{"signature": "def delete_at_management_group(<EOL>self, policy_set_definition_name, management_group_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete_at_management_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", policy_set_definition_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", management_group_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes a policy set definition.\n\n        This operation deletes the policy set definition in the given\n        management group with the given name.\n\n        :param policy_set_definition_name: The name of the policy set\n         definition to delete.\n        :type policy_set_definition_name: str\n        :param management_group_id: The ID of the management group.\n        :type management_group_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.resource.policy.v2018_03_01.models.ErrorResponseException>`", "id": "f37443:c0:m8"}
{"signature": "def get(<EOL>self, policy_definition_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", policy_definition_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves a policy definition in a subscription.\n\n        This operation retrieves the policy definition in the given\n        subscription with the given name.\n\n        :param policy_definition_name: The name of the policy definition to\n         get.\n        :type policy_definition_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PolicyDefinition or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.policy.v2018_03_01.models.PolicyDefinition or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37445:c0:m3"}
{"signature": "def create_or_update(<EOL>self, policy_definition_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", policy_definition_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or updates a policy definition in a subscription.\n\n        This operation creates or updates a policy definition in the given\n        subscription with the given name.\n\n        :param policy_definition_name: The name of the policy definition to\n         create.\n        :type policy_definition_name: str\n        :param parameters: The policy definition properties.\n        :type parameters:\n         ~azure.mgmt.resource.policy.v2018_03_01.models.PolicyDefinition\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PolicyDefinition or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.policy.v2018_03_01.models.PolicyDefinition or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37445:c0:m1"}
{"signature": "def get(<EOL>self, scope, policy_assignment_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", scope, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", policy_assignment_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves a policy assignment.\n\n        This operation retrieves a single policy assignment, given its name and\n        the scope it was created at.\n\n        :param scope: The scope of the policy assignment. Valid scopes are:\n         management group (format:\n         '/providers/Microsoft.Management/managementGroups/{managementGroup}'),\n         subscription (format: '/subscriptions/{subscriptionId}'), resource\n         group (format:\n         '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}',\n         or resource (format:\n         '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/[{parentResourcePath}/]{resourceType}/{resourceName}'\n        :type scope: str\n        :param policy_assignment_name: The name of the policy assignment to\n         get.\n        :type policy_assignment_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PolicyAssignment or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.policy.v2018_05_01.models.PolicyAssignment or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.resource.policy.v2018_05_01.models.ErrorResponseException>`", "id": "f37463:c0:m3"}
{"signature": "def get_by_id(<EOL>self, policy_assignment_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_by_id.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", policy_assignment_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves the policy assignment with the given ID.\n\n        The operation retrieves the policy assignment with the given ID. Policy\n        assignment IDs have this format:\n        '{scope}/providers/Microsoft.Authorization/policyAssignments/{policyAssignmentName}'.\n        Valid scopes are: management group (format:\n        '/providers/Microsoft.Management/managementGroups/{managementGroup}'),\n        subscription (format: '/subscriptions/{subscriptionId}'), resource\n        group (format:\n        '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}',\n        or resource (format:\n        '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/[{parentResourcePath}/]{resourceType}/{resourceName}'.\n\n        :param policy_assignment_id: The ID of the policy assignment to get.\n         Use the format\n         '{scope}/providers/Microsoft.Authorization/policyAssignments/{policyAssignmentName}'.\n        :type policy_assignment_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PolicyAssignment or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.policy.v2018_05_01.models.PolicyAssignment or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.resource.policy.v2018_05_01.models.ErrorResponseException>`", "id": "f37463:c0:m9"}
{"signature": "def list_for_resource(<EOL>self, resource_group_name, resource_provider_namespace, parent_resource_path, resource_type, resource_name, filter=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_for_resource.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_provider_namespace, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", parent_resource_path, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_type, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PolicyAssignmentPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PolicyAssignmentPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves all policy assignments that apply to a resource.\n\n        This operation retrieves the list of all policy assignments associated\n        with the specified resource in the given resource group and\n        subscription that match the optional given $filter. Valid values for\n        $filter are: 'atScope()' or 'policyDefinitionId eq '{value}''. If\n        $filter is not provided, the unfiltered list includes all policy\n        assignments associated with the resource, including those that apply\n        directly or from all containing scopes, as well as any applied to\n        resources contained within the resource. If $filter=atScope() is\n        provided, the returned list includes all policy assignments that apply\n        to the resource, which is everything in the unfiltered list except\n        those applied to resources contained within the resource. If\n        $filter=policyDefinitionId eq '{value}' is provided, the returned list\n        includes only policy assignments that apply to the resource and assign\n        the policy definition whose id is {value}. Three parameters plus the\n        resource name are used to identify a specific resource. If the resource\n        is not part of a parent resource (the more common case), the parent\n        resource path should not be provided (or provided as ''). For example a\n        web app could be specified as ({resourceProviderNamespace} ==\n        'Microsoft.Web', {parentResourcePath} == '', {resourceType} == 'sites',\n        {resourceName} == 'MyWebApp'). If the resource is part of a parent\n        resource, then all parameters should be provided. For example a virtual\n        machine DNS name could be specified as ({resourceProviderNamespace} ==\n        'Microsoft.Compute', {parentResourcePath} ==\n        'virtualMachines/MyVirtualMachine', {resourceType} == 'domainNames',\n        {resourceName} == 'MyComputerName'). A convenient alternative to\n        providing the namespace and type name separately is to provide both in\n        the {resourceType} parameter, format: ({resourceProviderNamespace} ==\n        '', {parentResourcePath} == '', {resourceType} ==\n        'Microsoft.Web/sites', {resourceName} == 'MyWebApp').\n\n        :param resource_group_name: The name of the resource group containing\n         the resource.\n        :type resource_group_name: str\n        :param resource_provider_namespace: The namespace of the resource\n         provider. For example, the namespace of a virtual machine is\n         Microsoft.Compute (from Microsoft.Compute/virtualMachines)\n        :type resource_provider_namespace: str\n        :param parent_resource_path: The parent resource path. Use empty\n         string if there is none.\n        :type parent_resource_path: str\n        :param resource_type: The resource type name. For example the type\n         name of a web app is 'sites' (from Microsoft.Web/sites).\n        :type resource_type: str\n        :param resource_name: The name of the resource.\n        :type resource_name: str\n        :param filter: The filter to apply on the operation. Valid values for\n         $filter are: 'atScope()' or 'policyDefinitionId eq '{value}''. If\n         $filter is not provided, no filtering is performed.\n        :type filter: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PolicyAssignment\n        :rtype:\n         ~azure.mgmt.resource.policy.v2018_05_01.models.PolicyAssignmentPaged[~azure.mgmt.resource.policy.v2018_05_01.models.PolicyAssignment]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.resource.policy.v2018_05_01.models.ErrorResponseException>`", "id": "f37463:c0:m5"}
{"signature": "def delete_by_id(<EOL>self, policy_assignment_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete_by_id.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", policy_assignment_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Deletes a policy assignment.\n\n        This operation deletes the policy with the given ID. Policy assignment\n        IDs have this format:\n        '{scope}/providers/Microsoft.Authorization/policyAssignments/{policyAssignmentName}'.\n        Valid formats for {scope} are:\n        '/providers/Microsoft.Management/managementGroups/{managementGroup}'\n        (management group), '/subscriptions/{subscriptionId}' (subscription),\n        '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}'\n        (resource group), or\n        '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/[{parentResourcePath}/]{resourceType}/{resourceName}'\n        (resource).\n\n        :param policy_assignment_id: The ID of the policy assignment to\n         delete. Use the format\n         '{scope}/providers/Microsoft.Authorization/policyAssignments/{policyAssignmentName}'.\n        :type policy_assignment_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PolicyAssignment or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.policy.v2018_05_01.models.PolicyAssignment or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.resource.policy.v2018_05_01.models.ErrorResponseException>`", "id": "f37463:c0:m7"}
{"signature": "def create_by_id(<EOL>self, policy_assignment_id, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_by_id.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", policy_assignment_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or updates a policy assignment.\n\n        This operation creates or updates the policy assignment with the given\n        ID. Policy assignments made on a scope apply to all resources contained\n        in that scope. For example, when you assign a policy to a resource\n        group that policy applies to all resources in the group. Policy\n        assignment IDs have this format:\n        '{scope}/providers/Microsoft.Authorization/policyAssignments/{policyAssignmentName}'.\n        Valid scopes are: management group (format:\n        '/providers/Microsoft.Management/managementGroups/{managementGroup}'),\n        subscription (format: '/subscriptions/{subscriptionId}'), resource\n        group (format:\n        '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}',\n        or resource (format:\n        '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/[{parentResourcePath}/]{resourceType}/{resourceName}'.\n\n        :param policy_assignment_id: The ID of the policy assignment to\n         create. Use the format\n         '{scope}/providers/Microsoft.Authorization/policyAssignments/{policyAssignmentName}'.\n        :type policy_assignment_id: str\n        :param parameters: Parameters for policy assignment.\n        :type parameters:\n         ~azure.mgmt.resource.policy.v2018_05_01.models.PolicyAssignment\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PolicyAssignment or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.policy.v2018_05_01.models.PolicyAssignment or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.resource.policy.v2018_05_01.models.ErrorResponseException>`", "id": "f37463:c0:m8"}
{"signature": "def get(<EOL>self, policy_set_definition_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", policy_set_definition_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves a policy set definition.\n\n        This operation retrieves the policy set definition in the given\n        subscription with the given name.\n\n        :param policy_set_definition_name: The name of the policy set\n         definition to get.\n        :type policy_set_definition_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PolicySetDefinition or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.policy.v2018_05_01.models.PolicySetDefinition or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.resource.policy.v2018_05_01.models.ErrorResponseException>`", "id": "f37464:c0:m3"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PolicySetDefinitionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PolicySetDefinitionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves the policy set definitions for a subscription.\n\n        This operation retrieves a list of all the policy set definitions in\n        the given subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PolicySetDefinition\n        :rtype:\n         ~azure.mgmt.resource.policy.v2018_05_01.models.PolicySetDefinitionPaged[~azure.mgmt.resource.policy.v2018_05_01.models.PolicySetDefinition]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.resource.policy.v2018_05_01.models.ErrorResponseException>`", "id": "f37464:c0:m5"}
{"signature": "def delete_at_management_group(<EOL>self, policy_set_definition_name, management_group_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete_at_management_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", policy_set_definition_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", management_group_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes a policy set definition.\n\n        This operation deletes the policy set definition in the given\n        management group with the given name.\n\n        :param policy_set_definition_name: The name of the policy set\n         definition to delete.\n        :type policy_set_definition_name: str\n        :param management_group_id: The ID of the management group.\n        :type management_group_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.resource.policy.v2018_05_01.models.ErrorResponseException>`", "id": "f37464:c0:m8"}
{"signature": "def list_by_management_group(<EOL>self, management_group_id, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_management_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", management_group_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PolicySetDefinitionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PolicySetDefinitionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves all policy set definitions in management group.\n\n        This operation retrieves a list of all the a policy set definition in\n        the given management group.\n\n        :param management_group_id: The ID of the management group.\n        :type management_group_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PolicySetDefinition\n        :rtype:\n         ~azure.mgmt.resource.policy.v2018_05_01.models.PolicySetDefinitionPaged[~azure.mgmt.resource.policy.v2018_05_01.models.PolicySetDefinition]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.resource.policy.v2018_05_01.models.ErrorResponseException>`", "id": "f37464:c0:m10"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PolicyDefinitionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PolicyDefinitionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves policy definitions in a subscription.\n\n        This operation retrieves a list of all the policy definitions in a\n        given subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PolicyDefinition\n        :rtype:\n         ~azure.mgmt.resource.policy.v2018_05_01.models.PolicyDefinitionPaged[~azure.mgmt.resource.policy.v2018_05_01.models.PolicyDefinition]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37465:c0:m8"}
{"signature": "def delete(<EOL>self, policy_definition_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", policy_definition_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes a policy definition in a subscription.\n\n        This operation deletes the policy definition in the given subscription\n        with the given name.\n\n        :param policy_definition_name: The name of the policy definition to\n         delete.\n        :type policy_definition_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37465:c0:m2"}
{"signature": "def get(<EOL>self, policy_definition_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", policy_definition_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves a policy definition in a subscription.\n\n        This operation retrieves the policy definition in the given\n        subscription with the given name.\n\n        :param policy_definition_name: The name of the policy definition to\n         get.\n        :type policy_definition_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PolicyDefinition or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.policy.v2018_05_01.models.PolicyDefinition or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37465:c0:m3"}
{"signature": "def delete_by_id(<EOL>self, policy_assignment_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete_by_id.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", policy_assignment_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Deletes a policy assignment by ID.\n\n        When providing a scope for the assignment, use\n        '/subscriptions/{subscription-id}/' for subscriptions,\n        '/subscriptions/{subscription-id}/resourceGroups/{resource-group-name}'\n        for resource groups, and\n        '/subscriptions/{subscription-id}/resourceGroups/{resource-group-name}/providers/{resource-provider-namespace}/{resource-type}/{resource-name}'\n        for resources.\n\n        :param policy_assignment_id: The ID of the policy assignment to\n         delete. Use the format\n         '/{scope}/providers/Microsoft.Authorization/policyAssignments/{policy-assignment-name}'.\n        :type policy_assignment_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PolicyAssignment or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.policy.v2017_06_01_preview.models.PolicyAssignment\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.resource.policy.v2017_06_01_preview.models.ErrorResponseException>`", "id": "f37481:c0:m7"}
{"signature": "def create(<EOL>self, scope, policy_assignment_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", scope, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", policy_assignment_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates a policy assignment.\n\n        Policy assignments are inherited by child resources. For example, when\n        you apply a policy to a resource group that policy is assigned to all\n        resources in the group.\n\n        :param scope: The scope of the policy assignment.\n        :type scope: str\n        :param policy_assignment_name: The name of the policy assignment.\n        :type policy_assignment_name: str\n        :param parameters: Parameters for the policy assignment.\n        :type parameters:\n         ~azure.mgmt.resource.policy.v2017_06_01_preview.models.PolicyAssignment\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PolicyAssignment or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.policy.v2017_06_01_preview.models.PolicyAssignment\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.resource.policy.v2017_06_01_preview.models.ErrorResponseException>`", "id": "f37481:c0:m2"}
{"signature": "def list_for_resource_group(<EOL>self, resource_group_name, filter=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_for_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>', skip_quote=True)<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PolicyAssignmentPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PolicyAssignmentPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets policy assignments for the resource group.\n\n        :param resource_group_name: The name of the resource group that\n         contains policy assignments.\n        :type resource_group_name: str\n        :param filter: The filter to apply on the operation.\n        :type filter: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PolicyAssignment\n        :rtype:\n         ~azure.mgmt.resource.policy.v2017_06_01_preview.models.PolicyAssignmentPaged[~azure.mgmt.resource.policy.v2017_06_01_preview.models.PolicyAssignment]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.resource.policy.v2017_06_01_preview.models.ErrorResponseException>`", "id": "f37481:c0:m4"}
{"signature": "def get_by_id(<EOL>self, policy_assignment_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_by_id.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", policy_assignment_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a policy assignment by ID.\n\n        When providing a scope for the assignment, use\n        '/subscriptions/{subscription-id}/' for subscriptions,\n        '/subscriptions/{subscription-id}/resourceGroups/{resource-group-name}'\n        for resource groups, and\n        '/subscriptions/{subscription-id}/resourceGroups/{resource-group-name}/providers/{resource-provider-namespace}/{resource-type}/{resource-name}'\n        for resources.\n\n        :param policy_assignment_id: The ID of the policy assignment to get.\n         Use the format\n         '/{scope}/providers/Microsoft.Authorization/policyAssignments/{policy-assignment-name}'.\n        :type policy_assignment_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PolicyAssignment or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.policy.v2017_06_01_preview.models.PolicyAssignment\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.resource.policy.v2017_06_01_preview.models.ErrorResponseException>`", "id": "f37481:c0:m9"}
{"signature": "def list_for_resource(<EOL>self, resource_group_name, resource_provider_namespace, parent_resource_path, resource_type, resource_name, filter=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_for_resource.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_provider_namespace, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", parent_resource_path, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_type, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PolicyAssignmentPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PolicyAssignmentPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets policy assignments for a resource.\n\n        :param resource_group_name: The name of the resource group containing\n         the resource. The name is case insensitive.\n        :type resource_group_name: str\n        :param resource_provider_namespace: The namespace of the resource\n         provider.\n        :type resource_provider_namespace: str\n        :param parent_resource_path: The parent resource path.\n        :type parent_resource_path: str\n        :param resource_type: The resource type.\n        :type resource_type: str\n        :param resource_name: The name of the resource with policy\n         assignments.\n        :type resource_name: str\n        :param filter: The filter to apply on the operation.\n        :type filter: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PolicyAssignment\n        :rtype:\n         ~azure.mgmt.resource.policy.v2017_06_01_preview.models.PolicyAssignmentPaged[~azure.mgmt.resource.policy.v2017_06_01_preview.models.PolicyAssignment]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.resource.policy.v2017_06_01_preview.models.ErrorResponseException>`", "id": "f37481:c0:m5"}
{"signature": "def delete(<EOL>self, scope, policy_assignment_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", scope, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", policy_assignment_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Deletes a policy assignment.\n\n        :param scope: The scope of the policy assignment.\n        :type scope: str\n        :param policy_assignment_name: The name of the policy assignment to\n         delete.\n        :type policy_assignment_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PolicyAssignment or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.policy.v2017_06_01_preview.models.PolicyAssignment\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.resource.policy.v2017_06_01_preview.models.ErrorResponseException>`", "id": "f37481:c0:m1"}
{"signature": "def get(<EOL>self, policy_definition_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", policy_definition_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the policy definition.\n\n        :param policy_definition_name: The name of the policy definition to\n         get.\n        :type policy_definition_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PolicyDefinition or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.policy.v2017_06_01_preview.models.PolicyDefinition\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37484:c0:m3"}
{"signature": "def get(<EOL>self, link_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", link_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a resource link with the specified ID.\n\n        :param link_id: The fully qualified Id of the resource link. For\n         example,\n         /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myGroup/Microsoft.Web/sites/mySite/Microsoft.Resources/links/myLink\n        :type link_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ResourceLink or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.resource.links.v2016_09_01.models.ResourceLink or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37500:c0:m3"}
{"signature": "def list(<EOL>self, resource_provider_namespace, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_provider_namespace, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.FeatureResultPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.FeatureResultPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the preview features in a provider namespace that are\n        available through AFEC for the subscription.\n\n        :param resource_provider_namespace: The namespace of the resource\n         provider for getting features.\n        :type resource_provider_namespace: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of FeatureResult\n        :rtype:\n         ~azure.mgmt.resource.features.v2015_12_01.models.FeatureResultPaged[~azure.mgmt.resource.features.v2015_12_01.models.FeatureResult]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37521:c0:m2"}
{"signature": "@property<EOL><INDENT>def tags(self):<DEDENT>", "body": "api_version = self._get_api_version('<STR_LIT>')<EOL>if api_version == '<STR_LIT>':<EOL><INDENT>from .v2016_02_01.operations import TagsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2016_09_01.operations import TagsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_05_10.operations import TagsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_02_01.operations import TagsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_05_01.operations import TagsOperations as OperationClass<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\".format(api_version))<EOL><DEDENT>return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))<EOL>", "docstring": "Instance depends on the API version:\n\n           * 2016-02-01: :class:`TagsOperations<azure.mgmt.resource.resources.v2016_02_01.operations.TagsOperations>`\n           * 2016-09-01: :class:`TagsOperations<azure.mgmt.resource.resources.v2016_09_01.operations.TagsOperations>`\n           * 2017-05-10: :class:`TagsOperations<azure.mgmt.resource.resources.v2017_05_10.operations.TagsOperations>`\n           * 2018-02-01: :class:`TagsOperations<azure.mgmt.resource.resources.v2018_02_01.operations.TagsOperations>`\n           * 2018-05-01: :class:`TagsOperations<azure.mgmt.resource.resources.v2018_05_01.operations.TagsOperations>`", "id": "f37523:c1:m9"}
{"signature": "@property<EOL><INDENT>def resources(self):<DEDENT>", "body": "api_version = self._get_api_version('<STR_LIT>')<EOL>if api_version == '<STR_LIT>':<EOL><INDENT>from .v2016_02_01.operations import ResourcesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2016_09_01.operations import ResourcesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_05_10.operations import ResourcesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_02_01.operations import ResourcesOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_05_01.operations import ResourcesOperations as OperationClass<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\".format(api_version))<EOL><DEDENT>return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))<EOL>", "docstring": "Instance depends on the API version:\n\n           * 2016-02-01: :class:`ResourcesOperations<azure.mgmt.resource.resources.v2016_02_01.operations.ResourcesOperations>`\n           * 2016-09-01: :class:`ResourcesOperations<azure.mgmt.resource.resources.v2016_09_01.operations.ResourcesOperations>`\n           * 2017-05-10: :class:`ResourcesOperations<azure.mgmt.resource.resources.v2017_05_10.operations.ResourcesOperations>`\n           * 2018-02-01: :class:`ResourcesOperations<azure.mgmt.resource.resources.v2018_02_01.operations.ResourcesOperations>`\n           * 2018-05-01: :class:`ResourcesOperations<azure.mgmt.resource.resources.v2018_05_01.operations.ResourcesOperations>`", "id": "f37523:c1:m8"}
{"signature": "def delete(<EOL>self, tag_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", tag_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes a tag from the subscription.\n\n        You must remove all values from a resource tag before you can delete\n        it.\n\n        :param tag_name: The name of the tag.\n        :type tag_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37610:c0:m4"}
{"signature": "def get(<EOL>self, resource_group_name, resource_provider_namespace, parent_resource_path, resource_type, resource_name, api_version, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_provider_namespace, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", parent_resource_path, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_type, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a resource.\n\n        :param resource_group_name: The name of the resource group containing\n         the resource to get. The name is case insensitive.\n        :type resource_group_name: str\n        :param resource_provider_namespace: The namespace of the resource\n         provider.\n        :type resource_provider_namespace: str\n        :param parent_resource_path: The parent resource identity.\n        :type parent_resource_path: str\n        :param resource_type: The resource type of the resource.\n        :type resource_type: str\n        :param resource_name: The name of the resource to get.\n        :type resource_name: str\n        :param api_version: The API version to use for the operation.\n        :type api_version: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: GenericResource or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.resources.v2016_09_01.models.GenericResource or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37611:c0:m11"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, resource_provider_namespace, parent_resource_path, resource_type, resource_name, api_version, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>resource_provider_namespace=resource_provider_namespace,<EOL>parent_resource_path=parent_resource_path,<EOL>resource_type=resource_type,<EOL>resource_name=resource_name,<EOL>api_version=api_version,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates a resource.\n\n        :param resource_group_name: The name of the resource group for the\n         resource. The name is case insensitive.\n        :type resource_group_name: str\n        :param resource_provider_namespace: The namespace of the resource\n         provider.\n        :type resource_provider_namespace: str\n        :param parent_resource_path: The parent resource identity.\n        :type parent_resource_path: str\n        :param resource_type: The resource type of the resource to create.\n        :type resource_type: str\n        :param resource_name: The name of the resource to create.\n        :type resource_name: str\n        :param api_version: The API version to use for the operation.\n        :type api_version: str\n        :param parameters: Parameters for creating or updating the resource.\n        :type parameters:\n         ~azure.mgmt.resource.resources.v2016_09_01.models.GenericResource\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns GenericResource or\n         ClientRawResponse<GenericResource> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.resource.resources.v2016_09_01.models.GenericResource]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.resource.resources.v2016_09_01.models.GenericResource]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37611:c0:m8"}
{"signature": "def check_existence(<EOL>self, resource_group_name, resource_provider_namespace, parent_resource_path, resource_type, resource_name, api_version, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.check_existence.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_provider_namespace, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", parent_resource_path, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_type, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.head(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = (response.status_code == <NUM_LIT>)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Checks whether a resource exists.\n\n        :param resource_group_name: The name of the resource group containing\n         the resource to check. The name is case insensitive.\n        :type resource_group_name: str\n        :param resource_provider_namespace: The resource provider of the\n         resource to check.\n        :type resource_provider_namespace: str\n        :param parent_resource_path: The parent resource identity.\n        :type parent_resource_path: str\n        :param resource_type: The resource type.\n        :type resource_type: str\n        :param resource_name: The name of the resource to check whether it\n         exists.\n        :type resource_name: str\n        :param api_version: The API version to use for the operation.\n        :type api_version: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: bool or ClientRawResponse if raw=true\n        :rtype: bool or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37611:c0:m4"}
{"signature": "def update_by_id(<EOL>self, resource_id, api_version, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_by_id_initial(<EOL>resource_id=resource_id,<EOL>api_version=api_version,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a resource by ID.\n\n        :param resource_id: The fully qualified ID of the resource, including\n         the resource name and resource type. Use the format,\n         /subscriptions/{guid}/resourceGroups/{resource-group-name}/{resource-provider-namespace}/{resource-type}/{resource-name}\n        :type resource_id: str\n        :param api_version: The API version to use for the operation.\n        :type api_version: str\n        :param parameters: Update resource parameters.\n        :type parameters:\n         ~azure.mgmt.resource.resources.v2016_09_01.models.GenericResource\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns GenericResource or\n         ClientRawResponse<GenericResource> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.resource.resources.v2016_09_01.models.GenericResource]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.resource.resources.v2016_09_01.models.GenericResource]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37611:c0:m18"}
{"signature": "def create_or_update_by_id(<EOL>self, resource_id, api_version, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_by_id_initial(<EOL>resource_id=resource_id,<EOL>api_version=api_version,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Create a resource by ID.\n\n        :param resource_id: The fully qualified ID of the resource, including\n         the resource name and resource type. Use the format,\n         /subscriptions/{guid}/resourceGroups/{resource-group-name}/{resource-provider-namespace}/{resource-type}/{resource-name}\n        :type resource_id: str\n        :param api_version: The API version to use for the operation.\n        :type api_version: str\n        :param parameters: Create or update resource parameters.\n        :type parameters:\n         ~azure.mgmt.resource.resources.v2016_09_01.models.GenericResource\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns GenericResource or\n         ClientRawResponse<GenericResource> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.resource.resources.v2016_09_01.models.GenericResource]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.resource.resources.v2016_09_01.models.GenericResource]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37611:c0:m16"}
{"signature": "def delete(<EOL>self, resource_group_name, resource_provider_namespace, parent_resource_path, resource_type, resource_name, api_version, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>resource_provider_namespace=resource_provider_namespace,<EOL>parent_resource_path=parent_resource_path,<EOL>resource_type=resource_type,<EOL>resource_name=resource_name,<EOL>api_version=api_version,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes a resource.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource to delete. The name is case insensitive.\n        :type resource_group_name: str\n        :param resource_provider_namespace: The namespace of the resource\n         provider.\n        :type resource_provider_namespace: str\n        :param parent_resource_path: The parent resource identity.\n        :type parent_resource_path: str\n        :param resource_type: The resource type.\n        :type resource_type: str\n        :param resource_name: The name of the resource to delete.\n        :type resource_name: str\n        :param api_version: The API version to use for the operation.\n        :type api_version: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37611:c0:m6"}
{"signature": "def move_resources(<EOL>self, source_resource_group_name, resources=None, target_resource_group=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._move_resources_initial(<EOL>source_resource_group_name=source_resource_group_name,<EOL>resources=resources,<EOL>target_resource_group=target_resource_group,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Moves resources from one resource group to another resource group.\n\n        The resources to move must be in the same source resource group. The\n        target resource group may be in a different subscription. When moving\n        resources, both the source group and the target group are locked for\n        the duration of the operation. Write and delete operations are blocked\n        on the groups until the move completes. .\n\n        :param source_resource_group_name: The name of the resource group\n         containing the resources to move.\n        :type source_resource_group_name: str\n        :param resources: The IDs of the resources.\n        :type resources: list[str]\n        :param target_resource_group: The target resource group.\n        :type target_resource_group: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37611:c0:m2"}
{"signature": "def delete_by_id(<EOL>self, resource_id, api_version, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_by_id_initial(<EOL>resource_id=resource_id,<EOL>api_version=api_version,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes a resource by ID.\n\n        :param resource_id: The fully qualified ID of the resource, including\n         the resource name and resource type. Use the format,\n         /subscriptions/{guid}/resourceGroups/{resource-group-name}/{resource-provider-namespace}/{resource-type}/{resource-name}\n        :type resource_id: str\n        :param api_version: The API version to use for the operation.\n        :type api_version: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37611:c0:m14"}
{"signature": "def list(<EOL>self, resource_group_name, deployment_name, top=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", deployment_name, '<STR_LIT:str>', max_length=<NUM_LIT:64>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.DeploymentOperationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.DeploymentOperationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all deployments operations for a deployment.\n\n        :param resource_group_name: The name of the resource group. The name\n         is case insensitive.\n        :type resource_group_name: str\n        :param deployment_name: The name of the deployment with the operation\n         to get.\n        :type deployment_name: str\n        :param top: The number of results to return.\n        :type top: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of DeploymentOperation\n        :rtype:\n         ~azure.mgmt.resource.resources.v2016_09_01.models.DeploymentOperationPaged[~azure.mgmt.resource.resources.v2016_09_01.models.DeploymentOperation]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37612:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, deployment_name, operation_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", deployment_name, '<STR_LIT:str>', max_length=<NUM_LIT:64>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", operation_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a deployments operation.\n\n        :param resource_group_name: The name of the resource group. The name\n         is case insensitive.\n        :type resource_group_name: str\n        :param deployment_name: The name of the deployment.\n        :type deployment_name: str\n        :param operation_id: The ID of the operation to get.\n        :type operation_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DeploymentOperation or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.resources.v2016_09_01.models.DeploymentOperation\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37612:c0:m1"}
{"signature": "def unregister(<EOL>self, resource_provider_namespace, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.unregister.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_provider_namespace, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Unregisters a subscription from a resource provider.\n\n        :param resource_provider_namespace: The namespace of the resource\n         provider to unregister.\n        :type resource_provider_namespace: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Provider or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.resource.resources.v2016_09_01.models.Provider or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37613:c0:m1"}
{"signature": "def register(<EOL>self, resource_provider_namespace, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.register.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_provider_namespace, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Registers a subscription with a resource provider.\n\n        :param resource_provider_namespace: The namespace of the resource\n         provider to register.\n        :type resource_provider_namespace: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Provider or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.resource.resources.v2016_09_01.models.Provider or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37613:c0:m2"}
{"signature": "def check_existence(<EOL>self, resource_group_name, deployment_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.check_existence.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", deployment_name, '<STR_LIT:str>', max_length=<NUM_LIT:64>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.head(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = (response.status_code == <NUM_LIT>)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Checks whether the deployment exists.\n\n        :param resource_group_name: The name of the resource group with the\n         deployment to check. The name is case insensitive.\n        :type resource_group_name: str\n        :param deployment_name: The name of the deployment to check.\n        :type deployment_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: bool or ClientRawResponse if raw=true\n        :rtype: bool or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37614:c0:m3"}
{"signature": "def delete(<EOL>self, resource_group_name, deployment_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>deployment_name=deployment_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes a deployment from the deployment history.\n\n        A template deployment that is currently running cannot be deleted.\n        Deleting a template deployment removes the associated deployment\n        operations. Deleting a template deployment does not affect the state of\n        the resource group. This is an asynchronous operation that returns a\n        status of 202 until the template deployment is successfully deleted.\n        The Location response header contains the URI that is used to obtain\n        the status of the process. While the process is running, a call to the\n        URI in the Location header returns a status of 202. When the process\n        finishes, the URI in the Location header returns a status of 204 on\n        success. If the asynchronous request failed, the URI in the Location\n        header returns an error-level status code.\n\n        :param resource_group_name: The name of the resource group with the\n         deployment to delete. The name is case insensitive.\n        :type resource_group_name: str\n        :param deployment_name: The name of the deployment to delete.\n        :type deployment_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37614:c0:m2"}
{"signature": "def validate(<EOL>self, resource_group_name, deployment_name, properties, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.Deployment(properties=properties)<EOL>url = self.validate.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", deployment_name, '<STR_LIT:str>', max_length=<NUM_LIT:64>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Validates whether the specified template is syntactically correct and\n        will be accepted by Azure Resource Manager..\n\n        :param resource_group_name: The name of the resource group the\n         template will be deployed to. The name is case insensitive.\n        :type resource_group_name: str\n        :param deployment_name: The name of the deployment.\n        :type deployment_name: str\n        :param properties: The deployment properties.\n        :type properties:\n         ~azure.mgmt.resource.resources.v2016_09_01.models.DeploymentProperties\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DeploymentValidateResult or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.resources.v2016_09_01.models.DeploymentValidateResult\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37614:c0:m8"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates a resource group.\n\n        :param resource_group_name: The name of the resource group to create\n         or update.\n        :type resource_group_name: str\n        :param parameters: Parameters supplied to the create or update a\n         resource group.\n        :type parameters:\n         ~azure.mgmt.resource.resources.v2016_09_01.models.ResourceGroup\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ResourceGroup or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.resources.v2016_09_01.models.ResourceGroup or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37616:c0:m3"}
{"signature": "def get(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a resource group.\n\n        :param resource_group_name: The name of the resource group to get. The\n         name is case insensitive.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ResourceGroup or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.resources.v2016_09_01.models.ResourceGroup or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37616:c0:m6"}
{"signature": "def export_template(<EOL>self, resource_group_name, resources=None, options=None, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.ExportTemplateRequest(resources=resources, options=options)<EOL>url = self.export_template.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Captures the specified resource group as a template.\n\n        :param resource_group_name: The name of the resource group to export\n         as a template.\n        :type resource_group_name: str\n        :param resources: The IDs of the resources. The only supported string\n         currently is '*' (all resources). Future updates will support\n         exporting specific resources.\n        :type resources: list[str]\n        :param options: The export template options. Supported values include\n         'IncludeParameterDefaultValue', 'IncludeComments' or\n         'IncludeParameterDefaultValue, IncludeComments\n        :type options: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ResourceGroupExportResult or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.resources.v2016_09_01.models.ResourceGroupExportResult\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37616:c0:m8"}
{"signature": "def patch(<EOL>self, resource_group_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.patch.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Updates a resource group.\n\n        Resource groups can be updated through a simple PATCH operation to a\n        group address. The format of the request is the same as that for\n        creating a resource group. If a field is unspecified, the current value\n        is retained.\n\n        :param resource_group_name: The name of the resource group to update.\n         The name is case insensitive.\n        :type resource_group_name: str\n        :param parameters: Parameters supplied to update a resource group.\n        :type parameters:\n         ~azure.mgmt.resource.resources.v2016_09_01.models.ResourceGroup\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ResourceGroup or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.resources.v2016_09_01.models.ResourceGroup or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37616:c0:m7"}
{"signature": "def delete(<EOL>self, resource_group_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes a resource group.\n\n        When you delete a resource group, all of its resources are also\n        deleted. Deleting a resource group deletes all of its template\n        deployments and currently stored operations.\n\n        :param resource_group_name: The name of the resource group to delete.\n         The name is case insensitive.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37616:c0:m5"}
{"signature": "def list(<EOL>self, filter=None, expand=None, top=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.GenericResourcePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.GenericResourcePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get all of the resources under a subscription.\n\n        :param filter: The filter to apply on the operation.\n        :type filter: str\n        :param expand: The $expand query parameter.\n        :type expand: str\n        :param top: Query parameters. If null is passed returns all resource\n         groups.\n        :type top: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of GenericResource\n        :rtype:\n         ~azure.mgmt.resource.resources.v2016_02_01.models.GenericResourcePaged[~azure.mgmt.resource.resources.v2016_02_01.models.GenericResource]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37682:c0:m3"}
{"signature": "def update(<EOL>self, resource_group_name, resource_provider_namespace, parent_resource_path, resource_type, resource_name, api_version, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_initial(<EOL>resource_group_name=resource_group_name,<EOL>resource_provider_namespace=resource_provider_namespace,<EOL>parent_resource_path=parent_resource_path,<EOL>resource_type=resource_type,<EOL>resource_name=resource_name,<EOL>api_version=api_version,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a resource.\n\n        :param resource_group_name: The name of the resource group for the\n         resource. The name is case insensitive.\n        :type resource_group_name: str\n        :param resource_provider_namespace: The namespace of the resource\n         provider.\n        :type resource_provider_namespace: str\n        :param parent_resource_path: The parent resource identity.\n        :type parent_resource_path: str\n        :param resource_type: The resource type of the resource to update.\n        :type resource_type: str\n        :param resource_name: The name of the resource to update.\n        :type resource_name: str\n        :param api_version: The API version to use for the operation.\n        :type api_version: str\n        :param parameters: Parameters for updating the resource.\n        :type parameters:\n         ~azure.mgmt.resource.resources.v2016_02_01.models.GenericResource\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns GenericResource or\n         ClientRawResponse<GenericResource> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.resource.resources.v2016_02_01.models.GenericResource]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.resource.resources.v2016_02_01.models.GenericResource]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37682:c0:m8"}
{"signature": "def get(<EOL>self, resource_group_name, resource_provider_namespace, parent_resource_path, resource_type, resource_name, api_version, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_provider_namespace, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", parent_resource_path, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_type, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Returns a resource belonging to a resource group.\n\n        :param resource_group_name: The name of the resource group. The name\n         is case insensitive.\n        :type resource_group_name: str\n        :param resource_provider_namespace: Resource identity.\n        :type resource_provider_namespace: str\n        :param parent_resource_path: Resource identity.\n        :type parent_resource_path: str\n        :param resource_type: Resource identity.\n        :type resource_type: str\n        :param resource_name: Resource identity.\n        :type resource_name: str\n        :param api_version:\n        :type api_version: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: GenericResource or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.resources.v2016_02_01.models.GenericResource or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37682:c0:m9"}
{"signature": "def delete(<EOL>self, resource_group_name, resource_provider_namespace, parent_resource_path, resource_type, resource_name, api_version, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_provider_namespace, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", parent_resource_path, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_type, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Delete resource and all of its resources. .\n\n        :param resource_group_name: The name of the resource group. The name\n         is case insensitive.\n        :type resource_group_name: str\n        :param resource_provider_namespace: Resource identity.\n        :type resource_provider_namespace: str\n        :param parent_resource_path: Resource identity.\n        :type parent_resource_path: str\n        :param resource_type: Resource identity.\n        :type resource_type: str\n        :param resource_name: Resource identity.\n        :type resource_name: str\n        :param api_version:\n        :type api_version: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37682:c0:m5"}
{"signature": "def list(<EOL>self, resource_group_name, deployment_name, top=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", deployment_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.DeploymentOperationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.DeploymentOperationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of deployments operations.\n\n        :param resource_group_name: The name of the resource group. The name\n         is case insensitive.\n        :type resource_group_name: str\n        :param deployment_name: The name of the deployment.\n        :type deployment_name: str\n        :param top: Query parameters.\n        :type top: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of DeploymentOperation\n        :rtype:\n         ~azure.mgmt.resource.resources.v2016_02_01.models.DeploymentOperationPaged[~azure.mgmt.resource.resources.v2016_02_01.models.DeploymentOperation]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37683:c0:m2"}
{"signature": "def unregister(<EOL>self, resource_provider_namespace, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.unregister.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_provider_namespace, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Unregisters provider from a subscription.\n\n        :param resource_provider_namespace: Namespace of the resource\n         provider.\n        :type resource_provider_namespace: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Provider or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.resource.resources.v2016_02_01.models.Provider or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37684:c0:m1"}
{"signature": "def get(<EOL>self, resource_provider_namespace, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_provider_namespace, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a resource provider.\n\n        :param resource_provider_namespace: Namespace of the resource\n         provider.\n        :type resource_provider_namespace: str\n        :param expand: The $expand query parameter. e.g. To include property\n         aliases in response, use $expand=resourceTypes/aliases.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Provider or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.resource.resources.v2016_02_01.models.Provider or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37684:c0:m4"}
{"signature": "def delete(<EOL>self, resource_group_name, deployment_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>deployment_name=deployment_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Delete deployment.\n\n        :param resource_group_name: The name of the resource group. The name\n         is case insensitive.\n        :type resource_group_name: str\n        :param deployment_name: The name of the deployment to be deleted.\n        :type deployment_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37685:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Delete resource group.\n\n        :param resource_group_name: The name of the resource group to be\n         deleted. The name is case insensitive.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37686:c0:m5"}
{"signature": "def list_resources(<EOL>self, resource_group_name, filter=None, expand=None, top=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_resources.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.GenericResourcePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.GenericResourcePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get all of the resources under a subscription.\n\n        :param resource_group_name: Query parameters. If null is passed\n         returns all resource groups.\n        :type resource_group_name: str\n        :param filter: The filter to apply on the operation.\n        :type filter: str\n        :param expand: The $expand query parameter\n        :type expand: str\n        :param top: Query parameters. If null is passed returns all resource\n         groups.\n        :type top: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of GenericResource\n        :rtype:\n         ~azure.mgmt.resource.resources.v2016_02_01.models.GenericResourcePaged[~azure.mgmt.resource.resources.v2016_02_01.models.GenericResource]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37686:c0:m1"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Create a resource group.\n\n        :param resource_group_name: The name of the resource group to be\n         created or updated.\n        :type resource_group_name: str\n        :param parameters: Parameters supplied to the create or update\n         resource group service operation.\n        :type parameters:\n         ~azure.mgmt.resource.resources.v2016_02_01.models.ResourceGroup\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ResourceGroup or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.resources.v2016_02_01.models.ResourceGroup or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37686:c0:m3"}
{"signature": "def list(<EOL>self, filter=None, top=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ResourceGroupPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ResourceGroupPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a collection of resource groups.\n\n        :param filter: The filter to apply on the operation.\n        :type filter: str\n        :param top: Query parameters. If null is passed returns all resource\n         groups.\n        :type top: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ResourceGroup\n        :rtype:\n         ~azure.mgmt.resource.resources.v2016_02_01.models.ResourceGroupPaged[~azure.mgmt.resource.resources.v2016_02_01.models.ResourceGroup]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37686:c0:m9"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.TagDetailsPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.TagDetailsPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the names and values of all resource tags that are defined in a\n        subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of TagDetails\n        :rtype:\n         ~azure.mgmt.resource.resources.v2017_05_10.models.TagDetailsPaged[~azure.mgmt.resource.resources.v2017_05_10.models.TagDetails]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37745:c0:m5"}
{"signature": "def create_or_update_value(<EOL>self, tag_name, tag_value, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update_value.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", tag_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", tag_value, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.put(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates a tag value. The name of the tag must already exist.\n\n        :param tag_name: The name of the tag.\n        :type tag_name: str\n        :param tag_value: The value of the tag to create.\n        :type tag_value: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: TagValue or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.resource.resources.v2017_05_10.models.TagValue or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37745:c0:m2"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, resource_provider_namespace, parent_resource_path, resource_type, resource_name, api_version, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>resource_provider_namespace=resource_provider_namespace,<EOL>parent_resource_path=parent_resource_path,<EOL>resource_type=resource_type,<EOL>resource_name=resource_name,<EOL>api_version=api_version,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates a resource.\n\n        :param resource_group_name: The name of the resource group for the\n         resource. The name is case insensitive.\n        :type resource_group_name: str\n        :param resource_provider_namespace: The namespace of the resource\n         provider.\n        :type resource_provider_namespace: str\n        :param parent_resource_path: The parent resource identity.\n        :type parent_resource_path: str\n        :param resource_type: The resource type of the resource to create.\n        :type resource_type: str\n        :param resource_name: The name of the resource to create.\n        :type resource_name: str\n        :param api_version: The API version to use for the operation.\n        :type api_version: str\n        :param parameters: Parameters for creating or updating the resource.\n        :type parameters:\n         ~azure.mgmt.resource.resources.v2017_05_10.models.GenericResource\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns GenericResource or\n         ClientRawResponse<GenericResource> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.resource.resources.v2017_05_10.models.GenericResource]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.resource.resources.v2017_05_10.models.GenericResource]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37746:c0:m11"}
{"signature": "def move_resources(<EOL>self, source_resource_group_name, resources=None, target_resource_group=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._move_resources_initial(<EOL>source_resource_group_name=source_resource_group_name,<EOL>resources=resources,<EOL>target_resource_group=target_resource_group,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Moves resources from one resource group to another resource group.\n\n        The resources to move must be in the same source resource group. The\n        target resource group may be in a different subscription. When moving\n        resources, both the source group and the target group are locked for\n        the duration of the operation. Write and delete operations are blocked\n        on the groups until the move completes. .\n\n        :param source_resource_group_name: The name of the resource group\n         containing the resources to move.\n        :type source_resource_group_name: str\n        :param resources: The IDs of the resources.\n        :type resources: list[str]\n        :param target_resource_group: The target resource group.\n        :type target_resource_group: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37746:c0:m3"}
{"signature": "def delete_by_id(<EOL>self, resource_id, api_version, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_by_id_initial(<EOL>resource_id=resource_id,<EOL>api_version=api_version,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes a resource by ID.\n\n        :param resource_id: The fully qualified ID of the resource, including\n         the resource name and resource type. Use the format,\n         /subscriptions/{guid}/resourceGroups/{resource-group-name}/{resource-provider-namespace}/{resource-type}/{resource-name}\n        :type resource_id: str\n        :param api_version: The API version to use for the operation.\n        :type api_version: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37746:c0:m17"}
{"signature": "def get_by_id(<EOL>self, resource_id, api_version, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_by_id.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a resource by ID.\n\n        :param resource_id: The fully qualified ID of the resource, including\n         the resource name and resource type. Use the format,\n         /subscriptions/{guid}/resourceGroups/{resource-group-name}/{resource-provider-namespace}/{resource-type}/{resource-name}\n        :type resource_id: str\n        :param api_version: The API version to use for the operation.\n        :type api_version: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: GenericResource or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.resources.v2017_05_10.models.GenericResource or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37746:c0:m22"}
{"signature": "def list(<EOL>self, resource_group_name, deployment_name, top=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", deployment_name, '<STR_LIT:str>', max_length=<NUM_LIT:64>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.DeploymentOperationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.DeploymentOperationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all deployments operations for a deployment.\n\n        :param resource_group_name: The name of the resource group. The name\n         is case insensitive.\n        :type resource_group_name: str\n        :param deployment_name: The name of the deployment with the operation\n         to get.\n        :type deployment_name: str\n        :param top: The number of results to return.\n        :type top: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of DeploymentOperation\n        :rtype:\n         ~azure.mgmt.resource.resources.v2017_05_10.models.DeploymentOperationPaged[~azure.mgmt.resource.resources.v2017_05_10.models.DeploymentOperation]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37747:c0:m2"}
{"signature": "def get(<EOL>self, resource_provider_namespace, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_provider_namespace, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified resource provider.\n\n        :param resource_provider_namespace: The namespace of the resource\n         provider.\n        :type resource_provider_namespace: str\n        :param expand: The $expand query parameter. For example, to include\n         property aliases in response, use $expand=resourceTypes/aliases.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Provider or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.resource.resources.v2017_05_10.models.Provider or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37748:c0:m4"}
{"signature": "def register(<EOL>self, resource_provider_namespace, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.register.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_provider_namespace, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Registers a subscription with a resource provider.\n\n        :param resource_provider_namespace: The namespace of the resource\n         provider to register.\n        :type resource_provider_namespace: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Provider or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.resource.resources.v2017_05_10.models.Provider or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37748:c0:m2"}
{"signature": "def cancel(<EOL>self, resource_group_name, deployment_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.cancel.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", deployment_name, '<STR_LIT:str>', max_length=<NUM_LIT:64>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Cancels a currently running template deployment.\n\n        You can cancel a deployment only if the provisioningState is Accepted\n        or Running. After the deployment is canceled, the provisioningState is\n        set to Canceled. Canceling a template deployment stops the currently\n        running template deployment and leaves the resource group partially\n        deployed.\n\n        :param resource_group_name: The name of the resource group. The name\n         is case insensitive.\n        :type resource_group_name: str\n        :param deployment_name: The name of the deployment to cancel.\n        :type deployment_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37749:c0:m7"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.OperationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.OperationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all of the available Microsoft.Resources REST API operations.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Operation\n        :rtype:\n         ~azure.mgmt.resource.resources.v2018_05_01.models.OperationPaged[~azure.mgmt.resource.resources.v2018_05_01.models.Operation]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37813:c0:m1"}
{"signature": "def create_or_update_value(<EOL>self, tag_name, tag_value, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update_value.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", tag_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", tag_value, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.put(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates a tag value. The name of the tag must already exist.\n\n        :param tag_name: The name of the tag.\n        :type tag_name: str\n        :param tag_value: The value of the tag to create.\n        :type tag_value: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: TagValue or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.resource.resources.v2018_05_01.models.TagValue or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37814:c0:m2"}
{"signature": "def delete_value(<EOL>self, tag_name, tag_value, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete_value.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", tag_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", tag_value, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes a tag value.\n\n        :param tag_name: The name of the tag.\n        :type tag_name: str\n        :param tag_value: The value of the tag to delete.\n        :type tag_value: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37814:c0:m1"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.TagDetailsPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.TagDetailsPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the names and values of all resource tags that are defined in a\n        subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of TagDetails\n        :rtype:\n         ~azure.mgmt.resource.resources.v2018_05_01.models.TagDetailsPaged[~azure.mgmt.resource.resources.v2018_05_01.models.TagDetails]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37814:c0:m5"}
{"signature": "def check_existence_by_id(<EOL>self, resource_id, api_version, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.check_existence_by_id.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.head(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = (response.status_code == <NUM_LIT>)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Checks by ID whether a resource exists.\n\n        :param resource_id: The fully qualified ID of the resource, including\n         the resource name and resource type. Use the format,\n         /subscriptions/{guid}/resourceGroups/{resource-group-name}/{resource-provider-namespace}/{resource-type}/{resource-name}\n        :type resource_id: str\n        :param api_version: The API version to use for the operation.\n        :type api_version: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: bool or ClientRawResponse if raw=true\n        :rtype: bool or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37815:c0:m15"}
{"signature": "def update_by_id(<EOL>self, resource_id, api_version, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_by_id_initial(<EOL>resource_id=resource_id,<EOL>api_version=api_version,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a resource by ID.\n\n        :param resource_id: The fully qualified ID of the resource, including\n         the resource name and resource type. Use the format,\n         /subscriptions/{guid}/resourceGroups/{resource-group-name}/{resource-provider-namespace}/{resource-type}/{resource-name}\n        :type resource_id: str\n        :param api_version: The API version to use for the operation.\n        :type api_version: str\n        :param parameters: Update resource parameters.\n        :type parameters:\n         ~azure.mgmt.resource.resources.v2018_05_01.models.GenericResource\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns GenericResource or\n         ClientRawResponse<GenericResource> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.resource.resources.v2018_05_01.models.GenericResource]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.resource.resources.v2018_05_01.models.GenericResource]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37815:c0:m21"}
{"signature": "def delete_by_id(<EOL>self, resource_id, api_version, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_by_id_initial(<EOL>resource_id=resource_id,<EOL>api_version=api_version,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes a resource by ID.\n\n        :param resource_id: The fully qualified ID of the resource, including\n         the resource name and resource type. Use the format,\n         /subscriptions/{guid}/resourceGroups/{resource-group-name}/{resource-provider-namespace}/{resource-type}/{resource-name}\n        :type resource_id: str\n        :param api_version: The API version to use for the operation.\n        :type api_version: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37815:c0:m17"}
{"signature": "def create_or_update_by_id(<EOL>self, resource_id, api_version, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_by_id_initial(<EOL>resource_id=resource_id,<EOL>api_version=api_version,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Create a resource by ID.\n\n        :param resource_id: The fully qualified ID of the resource, including\n         the resource name and resource type. Use the format,\n         /subscriptions/{guid}/resourceGroups/{resource-group-name}/{resource-provider-namespace}/{resource-type}/{resource-name}\n        :type resource_id: str\n        :param api_version: The API version to use for the operation.\n        :type api_version: str\n        :param parameters: Create or update resource parameters.\n        :type parameters:\n         ~azure.mgmt.resource.resources.v2018_05_01.models.GenericResource\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns GenericResource or\n         ClientRawResponse<GenericResource> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.resource.resources.v2018_05_01.models.GenericResource]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.resource.resources.v2018_05_01.models.GenericResource]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37815:c0:m19"}
{"signature": "def list(<EOL>self, resource_group_name, deployment_name, top=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", deployment_name, '<STR_LIT:str>', max_length=<NUM_LIT:64>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.DeploymentOperationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.DeploymentOperationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all deployments operations for a deployment.\n\n        :param resource_group_name: The name of the resource group. The name\n         is case insensitive.\n        :type resource_group_name: str\n        :param deployment_name: The name of the deployment with the operation\n         to get.\n        :type deployment_name: str\n        :param top: The number of results to return.\n        :type top: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of DeploymentOperation\n        :rtype:\n         ~azure.mgmt.resource.resources.v2018_05_01.models.DeploymentOperationPaged[~azure.mgmt.resource.resources.v2018_05_01.models.DeploymentOperation]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37816:c0:m4"}
{"signature": "def get_at_subscription_scope(<EOL>self, deployment_name, operation_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_at_subscription_scope.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", deployment_name, '<STR_LIT:str>', max_length=<NUM_LIT:64>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", operation_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a deployments operation.\n\n        :param deployment_name: The name of the deployment.\n        :type deployment_name: str\n        :param operation_id: The ID of the operation to get.\n        :type operation_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DeploymentOperation or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.resources.v2018_05_01.models.DeploymentOperation\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37816:c0:m1"}
{"signature": "def delete(<EOL>self, resource_group_name, deployment_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>deployment_name=deployment_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes a deployment from the deployment history.\n\n        A template deployment that is currently running cannot be deleted.\n        Deleting a template deployment removes the associated deployment\n        operations. Deleting a template deployment does not affect the state of\n        the resource group. This is an asynchronous operation that returns a\n        status of 202 until the template deployment is successfully deleted.\n        The Location response header contains the URI that is used to obtain\n        the status of the process. While the process is running, a call to the\n        URI in the Location header returns a status of 202. When the process\n        finishes, the URI in the Location header returns a status of 204 on\n        success. If the asynchronous request failed, the URI in the Location\n        header returns an error-level status code.\n\n        :param resource_group_name: The name of the resource group with the\n         deployment to delete. The name is case insensitive.\n        :type resource_group_name: str\n        :param deployment_name: The name of the deployment to delete.\n        :type deployment_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37818:c0:m12"}
{"signature": "def validate_at_subscription_scope(<EOL>self, deployment_name, properties, location=None, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.Deployment(location=location, properties=properties)<EOL>url = self.validate_at_subscription_scope.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", deployment_name, '<STR_LIT:str>', max_length=<NUM_LIT:64>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Validates whether the specified template is syntactically correct and\n        will be accepted by Azure Resource Manager..\n\n        :param deployment_name: The name of the deployment.\n        :type deployment_name: str\n        :param properties: The deployment properties.\n        :type properties:\n         ~azure.mgmt.resource.resources.v2018_05_01.models.DeploymentProperties\n        :param location: The location to store the deployment data.\n        :type location: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DeploymentValidateResult or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.resources.v2018_05_01.models.DeploymentValidateResult\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37818:c0:m8"}
{"signature": "def list_at_subscription_scope(<EOL>self, filter=None, top=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_at_subscription_scope.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.DeploymentExtendedPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.DeploymentExtendedPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get all the deployments for a subscription.\n\n        :param filter: The filter to apply on the operation. For example, you\n         can use $filter=provisioningState eq '{state}'.\n        :type filter: str\n        :param top: The number of results to get. If null is passed, returns\n         all deployments.\n        :type top: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of DeploymentExtended\n        :rtype:\n         ~azure.mgmt.resource.resources.v2018_05_01.models.DeploymentExtendedPaged[~azure.mgmt.resource.resources.v2018_05_01.models.DeploymentExtended]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37818:c0:m10"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, filter=None, top=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.DeploymentExtendedPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.DeploymentExtendedPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get all the deployments for a resource group.\n\n        :param resource_group_name: The name of the resource group with the\n         deployments to get. The name is case insensitive.\n        :type resource_group_name: str\n        :param filter: The filter to apply on the operation. For example, you\n         can use $filter=provisioningState eq '{state}'.\n        :type filter: str\n        :param top: The number of results to get. If null is passed, returns\n         all deployments.\n        :type top: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of DeploymentExtended\n        :rtype:\n         ~azure.mgmt.resource.resources.v2018_05_01.models.DeploymentExtendedPaged[~azure.mgmt.resource.resources.v2018_05_01.models.DeploymentExtended]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37818:c0:m20"}
{"signature": "def validate(<EOL>self, resource_group_name, deployment_name, properties, location=None, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.Deployment(location=location, properties=properties)<EOL>url = self.validate.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", deployment_name, '<STR_LIT:str>', max_length=<NUM_LIT:64>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Validates whether the specified template is syntactically correct and\n        will be accepted by Azure Resource Manager..\n\n        :param resource_group_name: The name of the resource group the\n         template will be deployed to. The name is case insensitive.\n        :type resource_group_name: str\n        :param deployment_name: The name of the deployment.\n        :type deployment_name: str\n        :param properties: The deployment properties.\n        :type properties:\n         ~azure.mgmt.resource.resources.v2018_05_01.models.DeploymentProperties\n        :param location: The location to store the deployment data.\n        :type location: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DeploymentValidateResult or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.resources.v2018_05_01.models.DeploymentValidateResult\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37818:c0:m18"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or updates a resource group.\n\n        :param resource_group_name: The name of the resource group to create\n         or update. Can include alphanumeric, underscore, parentheses, hyphen,\n         period (except at end), and Unicode characters that match the allowed\n         characters.\n        :type resource_group_name: str\n        :param parameters: Parameters supplied to the create or update a\n         resource group.\n        :type parameters:\n         ~azure.mgmt.resource.resources.v2018_05_01.models.ResourceGroup\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ResourceGroup or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.resources.v2018_05_01.models.ResourceGroup or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37820:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes a resource group.\n\n        When you delete a resource group, all of its resources are also\n        deleted. Deleting a resource group deletes all of its template\n        deployments and currently stored operations.\n\n        :param resource_group_name: The name of the resource group to delete.\n         The name is case insensitive.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37820:c0:m4"}
{"signature": "def create_or_update_value(<EOL>self, tag_name, tag_value, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update_value.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", tag_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", tag_value, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.put(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates a tag value. The name of the tag must already exist.\n\n        :param tag_name: The name of the tag.\n        :type tag_name: str\n        :param tag_value: The value of the tag to create.\n        :type tag_value: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: TagValue or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.resource.resources.v2018_02_01.models.TagValue or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37872:c0:m2"}
{"signature": "def delete(<EOL>self, tag_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", tag_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes a tag from the subscription.\n\n        You must remove all values from a resource tag before you can delete\n        it.\n\n        :param tag_name: The name of the tag.\n        :type tag_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37872:c0:m4"}
{"signature": "def get_by_id(<EOL>self, resource_id, api_version, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_by_id.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a resource by ID.\n\n        :param resource_id: The fully qualified ID of the resource, including\n         the resource name and resource type. Use the format,\n         /subscriptions/{guid}/resourceGroups/{resource-group-name}/{resource-provider-namespace}/{resource-type}/{resource-name}\n        :type resource_id: str\n        :param api_version: The API version to use for the operation.\n        :type api_version: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: GenericResource or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.resources.v2018_02_01.models.GenericResource or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37873:c0:m22"}
{"signature": "def create_or_update_by_id(<EOL>self, resource_id, api_version, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_by_id_initial(<EOL>resource_id=resource_id,<EOL>api_version=api_version,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Create a resource by ID.\n\n        :param resource_id: The fully qualified ID of the resource, including\n         the resource name and resource type. Use the format,\n         /subscriptions/{guid}/resourceGroups/{resource-group-name}/{resource-provider-namespace}/{resource-type}/{resource-name}\n        :type resource_id: str\n        :param api_version: The API version to use for the operation.\n        :type api_version: str\n        :param parameters: Create or update resource parameters.\n        :type parameters:\n         ~azure.mgmt.resource.resources.v2018_02_01.models.GenericResource\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns GenericResource or\n         ClientRawResponse<GenericResource> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.resource.resources.v2018_02_01.models.GenericResource]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.resource.resources.v2018_02_01.models.GenericResource]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37873:c0:m19"}
{"signature": "def move_resources(<EOL>self, source_resource_group_name, resources=None, target_resource_group=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._move_resources_initial(<EOL>source_resource_group_name=source_resource_group_name,<EOL>resources=resources,<EOL>target_resource_group=target_resource_group,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Moves resources from one resource group to another resource group.\n\n        The resources to move must be in the same source resource group. The\n        target resource group may be in a different subscription. When moving\n        resources, both the source group and the target group are locked for\n        the duration of the operation. Write and delete operations are blocked\n        on the groups until the move completes. .\n\n        :param source_resource_group_name: The name of the resource group\n         containing the resources to move.\n        :type source_resource_group_name: str\n        :param resources: The IDs of the resources.\n        :type resources: list[str]\n        :param target_resource_group: The target resource group.\n        :type target_resource_group: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37873:c0:m3"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, filter=None, expand=None, top=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.GenericResourcePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.GenericResourcePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get all the resources for a resource group.\n\n        :param resource_group_name: The resource group with the resources to\n         get.\n        :type resource_group_name: str\n        :param filter: The filter to apply on the operation.\n        :type filter: str\n        :param expand: The $expand query parameter\n        :type expand: str\n        :param top: The number of results to return. If null is passed,\n         returns all resources.\n        :type top: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of GenericResource\n        :rtype:\n         ~azure.mgmt.resource.resources.v2018_02_01.models.GenericResourcePaged[~azure.mgmt.resource.resources.v2018_02_01.models.GenericResource]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37873:c0:m1"}
{"signature": "def delete(<EOL>self, resource_group_name, resource_provider_namespace, parent_resource_path, resource_type, resource_name, api_version, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>resource_provider_namespace=resource_provider_namespace,<EOL>parent_resource_path=parent_resource_path,<EOL>resource_type=resource_type,<EOL>resource_name=resource_name,<EOL>api_version=api_version,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes a resource.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource to delete. The name is case insensitive.\n        :type resource_group_name: str\n        :param resource_provider_namespace: The namespace of the resource\n         provider.\n        :type resource_provider_namespace: str\n        :param parent_resource_path: The parent resource identity.\n        :type parent_resource_path: str\n        :param resource_type: The resource type.\n        :type resource_type: str\n        :param resource_name: The name of the resource to delete.\n        :type resource_name: str\n        :param api_version: The API version to use for the operation.\n        :type api_version: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37873:c0:m9"}
{"signature": "def get(<EOL>self, resource_group_name, deployment_name, operation_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", deployment_name, '<STR_LIT:str>', max_length=<NUM_LIT:64>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", operation_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a deployments operation.\n\n        :param resource_group_name: The name of the resource group. The name\n         is case insensitive.\n        :type resource_group_name: str\n        :param deployment_name: The name of the deployment.\n        :type deployment_name: str\n        :param operation_id: The ID of the operation to get.\n        :type operation_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DeploymentOperation or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.resources.v2018_02_01.models.DeploymentOperation\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37874:c0:m1"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, deployment_name, properties, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>deployment_name=deployment_name,<EOL>properties=properties,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deploys resources to a resource group.\n\n        You can provide the template and parameters directly in the request or\n        link to JSON files.\n\n        :param resource_group_name: The name of the resource group to deploy\n         the resources to. The name is case insensitive. The resource group\n         must already exist.\n        :type resource_group_name: str\n        :param deployment_name: The name of the deployment.\n        :type deployment_name: str\n        :param properties: The deployment properties.\n        :type properties:\n         ~azure.mgmt.resource.resources.v2018_02_01.models.DeploymentProperties\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns DeploymentExtended or\n         ClientRawResponse<DeploymentExtended> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.resource.resources.v2018_02_01.models.DeploymentExtended]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.resource.resources.v2018_02_01.models.DeploymentExtended]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37876:c0:m5"}
{"signature": "def get(<EOL>self, resource_group_name, deployment_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", deployment_name, '<STR_LIT:str>', max_length=<NUM_LIT:64>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a deployment.\n\n        :param resource_group_name: The name of the resource group. The name\n         is case insensitive.\n        :type resource_group_name: str\n        :param deployment_name: The name of the deployment to get.\n        :type deployment_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DeploymentExtended or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.resources.v2018_02_01.models.DeploymentExtended\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37876:c0:m6"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or updates a resource group.\n\n        :param resource_group_name: The name of the resource group to create\n         or update.\n        :type resource_group_name: str\n        :param parameters: Parameters supplied to the create or update a\n         resource group.\n        :type parameters:\n         ~azure.mgmt.resource.resources.v2018_02_01.models.ResourceGroup\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ResourceGroup or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.resources.v2018_02_01.models.ResourceGroup or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37877:c0:m2"}
{"signature": "def export_template(<EOL>self, resource_group_name, resources=None, options=None, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.ExportTemplateRequest(resources=resources, options=options)<EOL>url = self.export_template.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Captures the specified resource group as a template.\n\n        :param resource_group_name: The name of the resource group to export\n         as a template.\n        :type resource_group_name: str\n        :param resources: The IDs of the resources. The only supported string\n         currently is '*' (all resources). Future updates will support\n         exporting specific resources.\n        :type resources: list[str]\n        :param options: The export template options. Supported values include\n         'IncludeParameterDefaultValue', 'IncludeComments' or\n         'IncludeParameterDefaultValue, IncludeComments\n        :type options: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ResourceGroupExportResult or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.resource.resources.v2018_02_01.models.ResourceGroupExportResult\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f37877:c0:m7"}
{"signature": "def delete(<EOL>self, resource_group_name, gateway_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', min_length=<NUM_LIT:3>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", gateway_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes a gateway from a resource group.\n\n        :param resource_group_name: The resource group name uniquely\n         identifies the resource group within the user subscriptionId.\n        :type resource_group_name: str\n        :param gateway_name: The gateway name (256 characters maximum).\n        :type gateway_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorException<azure.mgmt.servermanager.models.ErrorException>`", "id": "f37929:c0:m5"}
{"signature": "def create(<EOL>self, resource_group_name, gateway_name, location=None, tags=None, upgrade_mode=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_initial(<EOL>resource_group_name=resource_group_name,<EOL>gateway_name=gateway_name,<EOL>location=location,<EOL>tags=tags,<EOL>upgrade_mode=upgrade_mode,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a ManagementService gateway.\n\n        :param resource_group_name: The resource group name uniquely\n         identifies the resource group within the user subscriptionId.\n        :type resource_group_name: str\n        :param gateway_name: The gateway name (256 characters maximum).\n        :type gateway_name: str\n        :param location: Location of the resource.\n        :type location: str\n        :param tags: Resource tags.\n        :type tags: object\n        :param upgrade_mode: The upgradeMode property gives the flexibility to\n         gateway to auto upgrade itself. If properties value not specified,\n         then we assume upgradeMode = Automatic. Possible values include:\n         'Manual', 'Automatic'\n        :type upgrade_mode: str or\n         ~azure.mgmt.servermanager.models.UpgradeMode\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns GatewayResource or\n         ClientRawResponse<GatewayResource> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.servermanager.models.GatewayResource]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.servermanager.models.GatewayResource]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.servermanager.models.ErrorException>`", "id": "f37929:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, node_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', min_length=<NUM_LIT:3>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", node_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "deletes a management node.\n\n        :param resource_group_name: The resource group name uniquely\n         identifies the resource group within the user subscriptionId.\n        :type resource_group_name: str\n        :param node_name: The node name (256 characters maximum).\n        :type node_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorException<azure.mgmt.servermanager.models.ErrorException>`", "id": "f37930:c0:m5"}
{"signature": "def update(<EOL>self, resource_group_name, node_name, location=None, tags=None, gateway_id=None, connection_name=None, user_name=None, password=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_initial(<EOL>resource_group_name=resource_group_name,<EOL>node_name=node_name,<EOL>location=location,<EOL>tags=tags,<EOL>gateway_id=gateway_id,<EOL>connection_name=connection_name,<EOL>user_name=user_name,<EOL>password=password,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a management node.\n\n        :param resource_group_name: The resource group name uniquely\n         identifies the resource group within the user subscriptionId.\n        :type resource_group_name: str\n        :param node_name: The node name (256 characters maximum).\n        :type node_name: str\n        :param location: Location of the resource.\n        :type location: str\n        :param tags: Resource tags.\n        :type tags: object\n        :param gateway_id: Gateway ID which will manage this node.\n        :type gateway_id: str\n        :param connection_name: myhost.domain.com\n        :type connection_name: str\n        :param user_name: User name to be used to connect to node.\n        :type user_name: str\n        :param password: Password associated with user name.\n        :type password: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns NodeResource or\n         ClientRawResponse<NodeResource> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.servermanager.models.NodeResource]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.servermanager.models.NodeResource]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.servermanager.models.ErrorException>`", "id": "f37930:c0:m4"}
{"signature": "def create(<EOL>self, resource_group_name, node_name, session, user_name=None, password=None, retention_period=None, credential_data_format=None, encryption_certificate_thumbprint=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_initial(<EOL>resource_group_name=resource_group_name,<EOL>node_name=node_name,<EOL>session=session,<EOL>user_name=user_name,<EOL>password=password,<EOL>retention_period=retention_period,<EOL>credential_data_format=credential_data_format,<EOL>encryption_certificate_thumbprint=encryption_certificate_thumbprint,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates a session for a node.\n\n        :param resource_group_name: The resource group name uniquely\n         identifies the resource group within the user subscriptionId.\n        :type resource_group_name: str\n        :param node_name: The node name (256 characters maximum).\n        :type node_name: str\n        :param session: The sessionId from the user.\n        :type session: str\n        :param user_name: Encrypted User name to be used to connect to node.\n        :type user_name: str\n        :param password: Encrypted Password associated with user name.\n        :type password: str\n        :param retention_period: Session retention period. Possible values\n         include: 'Session', 'Persistent'\n        :type retention_period: str or\n         ~azure.mgmt.servermanager.models.RetentionPeriod\n        :param credential_data_format: Credential data format. Possible values\n         include: 'RsaEncrypted'\n        :type credential_data_format: str or\n         ~azure.mgmt.servermanager.models.CredentialDataFormat\n        :param encryption_certificate_thumbprint: Encryption certificate\n         thumbprint.\n        :type encryption_certificate_thumbprint: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns SessionResource or\n         ClientRawResponse<SessionResource> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.servermanager.models.SessionResource]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.servermanager.models.SessionResource]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.servermanager.models.ErrorException>`", "id": "f37931:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, node_name, session, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', min_length=<NUM_LIT:3>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", node_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", session, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a session for a node.\n\n        :param resource_group_name: The resource group name uniquely\n         identifies the resource group within the user subscriptionId.\n        :type resource_group_name: str\n        :param node_name: The node name (256 characters maximum).\n        :type node_name: str\n        :param session: The sessionId from the user.\n        :type session: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SessionResource or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.servermanager.models.SessionResource or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorException<azure.mgmt.servermanager.models.ErrorException>`", "id": "f37931:c0:m4"}
{"signature": "def invoke_command(<EOL>self, resource_group_name, node_name, session, pssession, command=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._invoke_command_initial(<EOL>resource_group_name=resource_group_name,<EOL>node_name=node_name,<EOL>session=session,<EOL>pssession=pssession,<EOL>command=command,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates a PowerShell script and invokes it.\n\n        :param resource_group_name: The resource group name uniquely\n         identifies the resource group within the user subscriptionId.\n        :type resource_group_name: str\n        :param node_name: The node name (256 characters maximum).\n        :type node_name: str\n        :param session: The sessionId from the user.\n        :type session: str\n        :param pssession: The PowerShell sessionId from the user.\n        :type pssession: str\n        :param command: Script to execute.\n        :type command: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         PowerShellCommandResults or\n         ClientRawResponse<PowerShellCommandResults> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.servermanager.models.PowerShellCommandResults]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.servermanager.models.PowerShellCommandResults]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.servermanager.models.ErrorException>`", "id": "f37933:c0:m8"}
{"signature": "def get_command_status(<EOL>self, resource_group_name, node_name, session, pssession, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_command_status.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', min_length=<NUM_LIT:3>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", node_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", session, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", pssession, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the status of a command.\n\n        :param resource_group_name: The resource group name uniquely\n         identifies the resource group within the user subscriptionId.\n        :type resource_group_name: str\n        :param node_name: The node name (256 characters maximum).\n        :type node_name: str\n        :param session: The sessionId from the user.\n        :type session: str\n        :param pssession: The PowerShell sessionId from the user.\n        :type pssession: str\n        :param expand: Gets current output from an ongoing call. Possible\n         values include: 'output'\n        :type expand: str or\n         ~azure.mgmt.servermanager.models.PowerShellExpandOption\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PowerShellCommandStatus or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.servermanager.models.PowerShellCommandStatus or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorException<azure.mgmt.servermanager.models.ErrorException>`", "id": "f37933:c0:m4"}
{"signature": "def tab_completion(<EOL>self, resource_group_name, node_name, session, pssession, command=None, custom_headers=None, raw=False, **operation_config):", "body": "power_shell_tab_completion_paramters = models.PowerShellTabCompletionParameters(command=command)<EOL>url = self.tab_completion.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', min_length=<NUM_LIT:3>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", node_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", session, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", pssession, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(power_shell_tab_completion_paramters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, body_content, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets tab completion values for a command.\n\n        :param resource_group_name: The resource group name uniquely\n         identifies the resource group within the user subscriptionId.\n        :type resource_group_name: str\n        :param node_name: The node name (256 characters maximum).\n        :type node_name: str\n        :param session: The sessionId from the user.\n        :type session: str\n        :param pssession: The PowerShell sessionId from the user.\n        :type pssession: str\n        :param command: Command to get tab completion for.\n        :type command: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PowerShellTabCompletionResults or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.servermanager.models.PowerShellTabCompletionResults or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorException<azure.mgmt.servermanager.models.ErrorException>`", "id": "f37933:c0:m11"}
{"signature": "def cancel_command(<EOL>self, resource_group_name, node_name, session, pssession, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._cancel_command_initial(<EOL>resource_group_name=resource_group_name,<EOL>node_name=node_name,<EOL>session=session,<EOL>pssession=pssession,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Cancels a PowerShell command.\n\n        :param resource_group_name: The resource group name uniquely\n         identifies the resource group within the user subscriptionId.\n        :type resource_group_name: str\n        :param node_name: The node name (256 characters maximum).\n        :type node_name: str\n        :param session: The sessionId from the user.\n        :type session: str\n        :param pssession: The PowerShell sessionId from the user.\n        :type pssession: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         PowerShellCommandResults or\n         ClientRawResponse<PowerShellCommandResults> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.servermanager.models.PowerShellCommandResults]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.servermanager.models.PowerShellCommandResults]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.servermanager.models.ErrorException>`", "id": "f37933:c0:m10"}
{"signature": "def update_command(<EOL>self, resource_group_name, node_name, session, pssession, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_command_initial(<EOL>resource_group_name=resource_group_name,<EOL>node_name=node_name,<EOL>session=session,<EOL>pssession=pssession,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a running PowerShell command with more data.\n\n        :param resource_group_name: The resource group name uniquely\n         identifies the resource group within the user subscriptionId.\n        :type resource_group_name: str\n        :param node_name: The node name (256 characters maximum).\n        :type node_name: str\n        :param session: The sessionId from the user.\n        :type session: str\n        :param pssession: The PowerShell sessionId from the user.\n        :type pssession: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         PowerShellCommandResults or\n         ClientRawResponse<PowerShellCommandResults> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.servermanager.models.PowerShellCommandResults]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.servermanager.models.PowerShellCommandResults]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.servermanager.models.ErrorException>`", "id": "f37933:c0:m6"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.OperationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.OperationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all of the available billing REST API operations.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Operation\n        :rtype:\n         ~azure.mgmt.billing.models.OperationPaged[~azure.mgmt.billing.models.Operation]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.billing.models.ErrorResponseException>`", "id": "f37953:c0:m1"}
{"signature": "def get(<EOL>self, name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a enrollment account by name.\n\n        :param name: Enrollment Account name.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: EnrollmentAccount or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.billing.models.EnrollmentAccount or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.billing.models.ErrorResponseException>`", "id": "f37954:c0:m2"}
{"signature": "def get(<EOL>self, billing_period_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", billing_period_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a named billing period.  This is only supported for Azure\n        Web-Direct subscriptions. Other subscription types which were not\n        purchased directly through the Azure web portal are not supported\n        through this preview API.\n\n        :param billing_period_name: The name of a BillingPeriod resource.\n        :type billing_period_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: BillingPeriod or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.billing.models.BillingPeriod or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.billing.models.ErrorResponseException>`", "id": "f37955:c0:m2"}
{"signature": "def create_import_operation(<EOL>self, resource_group_name, server_name, database_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_import_operation_initial(<EOL>resource_group_name=resource_group_name,<EOL>server_name=server_name,<EOL>database_name=database_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates an import operation that imports a bacpac into an existing\n        database. The existing database must be empty.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param database_name: The name of the database to import into\n        :type database_name: str\n        :param parameters: The required parameters for importing a Bacpac into\n         a database.\n        :type parameters: ~azure.mgmt.sql.models.ImportExtensionRequest\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ImportExportResponse or\n         ClientRawResponse<ImportExportResponse> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.sql.models.ImportExportResponse]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.sql.models.ImportExportResponse]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38343:c0:m4"}
{"signature": "def list_by_elastic_pool(<EOL>self, resource_group_name, server_name, elastic_pool_name, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_elastic_pool.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", elastic_pool_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.DatabasePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.DatabasePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of databases in an elastic pool.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param elastic_pool_name: The name of the elastic pool.\n        :type elastic_pool_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Database\n        :rtype:\n         ~azure.mgmt.sql.models.DatabasePaged[~azure.mgmt.sql.models.Database]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38343:c0:m19"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, server_name, database_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>server_name=server_name,<EOL>database_name=database_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates a new database or updates an existing database.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param database_name: The name of the database.\n        :type database_name: str\n        :param parameters: The requested database resource state.\n        :type parameters: ~azure.mgmt.sql.models.Database\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Database or\n         ClientRawResponse<Database> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.sql.models.Database]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.sql.models.Database]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38343:c0:m14"}
{"signature": "def resume(<EOL>self, resource_group_name, server_name, database_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._resume_initial(<EOL>resource_group_name=resource_group_name,<EOL>server_name=server_name,<EOL>database_name=database_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Resumes a database.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param database_name: The name of the database to be resumed.\n        :type database_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Database or\n         ClientRawResponse<Database> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.sql.models.Database]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.sql.models.Database]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38343:c0:m23"}
{"signature": "def list_by_server(<EOL>self, resource_group_name, server_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_server.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.FirewallRulePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.FirewallRulePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Returns a list of firewall rules.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of FirewallRule\n        :rtype:\n         ~azure.mgmt.sql.models.FirewallRulePaged[~azure.mgmt.sql.models.FirewallRule]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38344:c0:m4"}
{"signature": "def delete(<EOL>self, resource_group_name, server_name, firewall_rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", firewall_rule_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes a firewall rule.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param firewall_rule_name: The name of the firewall rule.\n        :type firewall_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38344:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, server_name, firewall_rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", firewall_rule_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a firewall rule.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param firewall_rule_name: The name of the firewall rule.\n        :type firewall_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: FirewallRule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.sql.models.FirewallRule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38344:c0:m3"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, server_name, firewall_rule_name, start_ip_address, end_ip_address, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.FirewallRule(start_ip_address=start_ip_address, end_ip_address=end_ip_address)<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", firewall_rule_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or updates a firewall rule.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param firewall_rule_name: The name of the firewall rule.\n        :type firewall_rule_name: str\n        :param start_ip_address: The start IP address of the firewall rule.\n         Must be IPv4 format. Use value '0.0.0.0' to represent all\n         Azure-internal IP addresses.\n        :type start_ip_address: str\n        :param end_ip_address: The end IP address of the firewall rule. Must\n         be IPv4 format. Must be greater than or equal to startIpAddress. Use\n         value '0.0.0.0' to represent all Azure-internal IP addresses.\n        :type end_ip_address: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: FirewallRule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.sql.models.FirewallRule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38344:c0:m1"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, managed_instance_name, database_name, rule_id, baseline_name, baseline_results, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.DatabaseVulnerabilityAssessmentRuleBaseline(baseline_results=baseline_results)<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", managed_instance_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", database_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.vulnerability_assessment_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", rule_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", baseline_name, '<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or updates a database's vulnerability assessment rule baseline.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param managed_instance_name: The name of the managed instance.\n        :type managed_instance_name: str\n        :param database_name: The name of the database for which the\n         vulnerability assessment rule baseline is defined.\n        :type database_name: str\n        :param rule_id: The vulnerability assessment rule ID.\n        :type rule_id: str\n        :param baseline_name: The name of the vulnerability assessment rule\n         baseline (default implies a baseline on a database level rule and\n         master for server level rule). Possible values include: 'master',\n         'default'\n        :type baseline_name: str or\n         ~azure.mgmt.sql.models.VulnerabilityAssessmentPolicyBaselineName\n        :param baseline_results: The rule baseline result\n        :type baseline_results:\n         list[~azure.mgmt.sql.models.DatabaseVulnerabilityAssessmentRuleBaselineItem]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DatabaseVulnerabilityAssessmentRuleBaseline or\n         ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.sql.models.DatabaseVulnerabilityAssessmentRuleBaseline or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38345:c0:m2"}
{"signature": "def get(<EOL>self, location_name, long_term_retention_server_name, long_term_retention_database_name, backup_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", location_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", long_term_retention_server_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", long_term_retention_database_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", backup_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a long term retention backup.\n\n        :param location_name: The location of the database.\n        :type location_name: str\n        :param long_term_retention_server_name: The name of the server\n        :type long_term_retention_server_name: str\n        :param long_term_retention_database_name: The name of the database\n        :type long_term_retention_database_name: str\n        :param backup_name: The backup name.\n        :type backup_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: LongTermRetentionBackup or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.sql.models.LongTermRetentionBackup or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38346:c0:m1"}
{"signature": "def delete(<EOL>self, resource_group_name, server_name, virtual_network_rule_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>server_name=server_name,<EOL>virtual_network_rule_name=virtual_network_rule_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the virtual network rule with the given name.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param virtual_network_rule_name: The name of the virtual network\n         rule.\n        :type virtual_network_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38349:c0:m5"}
{"signature": "def update(<EOL>self, resource_group_name, virtual_cluster_name, family=None, tags=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_cluster_name=virtual_cluster_name,<EOL>family=family,<EOL>tags=tags,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a virtual cluster.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param virtual_cluster_name: The name of the virtual cluster.\n        :type virtual_cluster_name: str\n        :param family: If the service has different generations of hardware,\n         for the same SKU, then that can be captured here.\n        :type family: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns VirtualCluster or\n         ClientRawResponse<VirtualCluster> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.sql.models.VirtualCluster]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.sql.models.VirtualCluster]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38350:c0:m7"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualClusterPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualClusterPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of all virtualClusters in the subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualCluster\n        :rtype:\n         ~azure.mgmt.sql.models.VirtualClusterPaged[~azure.mgmt.sql.models.VirtualCluster]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38350:c0:m1"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualClusterPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualClusterPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of virtual clusters in a resource group.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualCluster\n        :rtype:\n         ~azure.mgmt.sql.models.VirtualClusterPaged[~azure.mgmt.sql.models.VirtualCluster]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38350:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, virtual_cluster_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>virtual_cluster_name=virtual_cluster_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes a virtual cluster.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param virtual_cluster_name: The name of the virtual cluster.\n        :type virtual_cluster_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38350:c0:m5"}
{"signature": "def get(<EOL>self, resource_group_name, server_name, job_agent_name, target_group_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", job_agent_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", target_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a target group.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param job_agent_name: The name of the job agent.\n        :type job_agent_name: str\n        :param target_group_name: The name of the target group.\n        :type target_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: JobTargetGroup or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.sql.models.JobTargetGroup or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38351:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, server_name, database_name, link_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", database_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", link_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes a database replication link. Cannot be done during failover.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param database_name: The name of the database that has the\n         replication link to be dropped.\n        :type database_name: str\n        :param link_id: The ID of the replication link to be deleted.\n        :type link_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38352:c0:m1"}
{"signature": "def list_by_database(<EOL>self, resource_group_name, server_name, database_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_database.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", database_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ReplicationLinkPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ReplicationLinkPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists a database's replication links.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param database_name: The name of the database to retrieve links for.\n        :type database_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ReplicationLink\n        :rtype:\n         ~azure.mgmt.sql.models.ReplicationLinkPaged[~azure.mgmt.sql.models.ReplicationLink]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38352:c0:m7"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, server_name, job_agent_name, job_name, job_execution_id, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>server_name=server_name,<EOL>job_agent_name=job_agent_name,<EOL>job_name=job_name,<EOL>job_execution_id=job_execution_id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a job execution.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param job_agent_name: The name of the job agent.\n        :type job_agent_name: str\n        :param job_name: The name of the job to get.\n        :type job_name: str\n        :param job_execution_id: The job execution id to create the job\n         execution under.\n        :type job_execution_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns JobExecution or\n         ClientRawResponse<JobExecution> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.sql.models.JobExecution]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.sql.models.JobExecution]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38353:c0:m8"}
{"signature": "def get(<EOL>self, resource_group_name, server_name, job_agent_name, job_name, job_execution_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", job_agent_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", job_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", job_execution_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a job execution.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param job_agent_name: The name of the job agent.\n        :type job_agent_name: str\n        :param job_name: The name of the job.\n        :type job_name: str\n        :param job_execution_id: The id of the job execution\n        :type job_execution_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: JobExecution or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.sql.models.JobExecution or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38353:c0:m6"}
{"signature": "def list_by_agent(<EOL>self, resource_group_name, server_name, job_agent_name, create_time_min=None, create_time_max=None, end_time_min=None, end_time_max=None, is_active=None, skip=None, top=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_agent.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", job_agent_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if create_time_min is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", create_time_min, '<STR_LIT>')<EOL><DEDENT>if create_time_max is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", create_time_max, '<STR_LIT>')<EOL><DEDENT>if end_time_min is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", end_time_min, '<STR_LIT>')<EOL><DEDENT>if end_time_max is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", end_time_max, '<STR_LIT>')<EOL><DEDENT>if is_active is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", is_active, '<STR_LIT:bool>')<EOL><DEDENT>if skip is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", skip, '<STR_LIT:int>')<EOL><DEDENT>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.JobExecutionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.JobExecutionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all executions in a job agent.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param job_agent_name: The name of the job agent.\n        :type job_agent_name: str\n        :param create_time_min: If specified, only job executions created at\n         or after the specified time are included.\n        :type create_time_min: datetime\n        :param create_time_max: If specified, only job executions created\n         before the specified time are included.\n        :type create_time_max: datetime\n        :param end_time_min: If specified, only job executions completed at or\n         after the specified time are included.\n        :type end_time_min: datetime\n        :param end_time_max: If specified, only job executions completed\n         before the specified time are included.\n        :type end_time_max: datetime\n        :param is_active: If specified, only active or only completed job\n         executions are included.\n        :type is_active: bool\n        :param skip: The number of elements in the collection to skip.\n        :type skip: int\n        :param top: The number of elements to return from the collection.\n        :type top: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of JobExecution\n        :rtype:\n         ~azure.mgmt.sql.models.JobExecutionPaged[~azure.mgmt.sql.models.JobExecution]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38353:c0:m1"}
{"signature": "def list_by_database(<EOL>self, resource_group_name, managed_instance_name, database_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_database.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", managed_instance_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", database_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ManagedDatabaseSecurityAlertPolicyPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ManagedDatabaseSecurityAlertPolicyPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of managed database's security alert policies.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param managed_instance_name: The name of the managed instance.\n        :type managed_instance_name: str\n        :param database_name: The name of the managed database for which the\n         security alert policies are defined.\n        :type database_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of\n         ManagedDatabaseSecurityAlertPolicy\n        :rtype:\n         ~azure.mgmt.sql.models.ManagedDatabaseSecurityAlertPolicyPaged[~azure.mgmt.sql.models.ManagedDatabaseSecurityAlertPolicy]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38355:c0:m3"}
{"signature": "def get(<EOL>self, resource_group_name, managed_instance_name, database_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", managed_instance_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", database_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.security_alert_policy_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a managed database's security alert policy.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param managed_instance_name: The name of the managed instance.\n        :type managed_instance_name: str\n        :param database_name: The name of the managed database for which the\n         security alert policy is defined.\n        :type database_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ManagedDatabaseSecurityAlertPolicy or ClientRawResponse if\n         raw=true\n        :rtype: ~azure.mgmt.sql.models.ManagedDatabaseSecurityAlertPolicy or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38355:c0:m1"}
{"signature": "def list_by_server(<EOL>self, resource_group_name, server_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_server.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RecoverableDatabasePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RecoverableDatabasePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of recoverable databases.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of RecoverableDatabase\n        :rtype:\n         ~azure.mgmt.sql.models.RecoverableDatabasePaged[~azure.mgmt.sql.models.RecoverableDatabase]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38356:c0:m2"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.OperationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.OperationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all of the available SQL Rest API operations.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Operation\n        :rtype:\n         ~azure.mgmt.sql.models.OperationPaged[~azure.mgmt.sql.models.Operation]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38357:c0:m1"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, server_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>server_name=server_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates an extended server's blob auditing policy.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param parameters: Properties of extended blob auditing policy\n        :type parameters:\n         ~azure.mgmt.sql.models.ExtendedServerBlobAuditingPolicy\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ExtendedServerBlobAuditingPolicy or\n         ClientRawResponse<ExtendedServerBlobAuditingPolicy> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.sql.models.ExtendedServerBlobAuditingPolicy]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.sql.models.ExtendedServerBlobAuditingPolicy]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38358:c0:m3"}
{"signature": "def list_by_instance(<EOL>self, resource_group_name, managed_instance_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_instance.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", managed_instance_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ManagedInstanceEncryptionProtectorPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ManagedInstanceEncryptionProtectorPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of managed instance encryption protectors.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param managed_instance_name: The name of the managed instance.\n        :type managed_instance_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of\n         ManagedInstanceEncryptionProtector\n        :rtype:\n         ~azure.mgmt.sql.models.ManagedInstanceEncryptionProtectorPaged[~azure.mgmt.sql.models.ManagedInstanceEncryptionProtector]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38359:c0:m1"}
{"signature": "def list_by_location(<EOL>self, location_name, include=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_by_location.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", location_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if include is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", include, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the subscription capabilities available for the specified\n        location.\n\n        :param location_name: The location name whose capabilities are\n         retrieved.\n        :type location_name: str\n        :param include: If specified, restricts the response to only include\n         the selected item. Possible values include: 'supportedEditions',\n         'supportedElasticPoolEditions', 'supportedManagedInstanceVersions'\n        :type include: str or ~azure.mgmt.sql.models.CapabilityGroup\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: LocationCapabilities or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.sql.models.LocationCapabilities or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38361:c0:m1"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, server_name, job_agent_name, job_name, description=\"<STR_LIT>\", schedule=None, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.Job(description=description, schedule=schedule)<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", job_agent_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", job_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or updates a job.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param job_agent_name: The name of the job agent.\n        :type job_agent_name: str\n        :param job_name: The name of the job to get.\n        :type job_name: str\n        :param description: User-defined description of the job.\n        :type description: str\n        :param schedule: Schedule properties of the job.\n        :type schedule: ~azure.mgmt.sql.models.JobSchedule\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Job or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.sql.models.Job or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38362:c0:m3"}
{"signature": "def delete(<EOL>self, resource_group_name, server_name, job_agent_name, job_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", job_agent_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", job_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes a job.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param job_agent_name: The name of the job agent.\n        :type job_agent_name: str\n        :param job_name: The name of the job to delete.\n        :type job_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38362:c0:m4"}
{"signature": "def update(<EOL>self, resource_group_name, server_name, database_name, desired_state=None, options=None, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.DatabaseAutomaticTuning(desired_state=desired_state, options=options)<EOL>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", database_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Update automatic tuning properties for target database.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param database_name: The name of the database.\n        :type database_name: str\n        :param desired_state: Automatic tuning desired state. Possible values\n         include: 'Inherit', 'Custom', 'Auto', 'Unspecified'\n        :type desired_state: str or ~azure.mgmt.sql.models.AutomaticTuningMode\n        :param options: Automatic tuning options definition.\n        :type options: dict[str,\n         ~azure.mgmt.sql.models.AutomaticTuningOptions]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DatabaseAutomaticTuning or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.sql.models.DatabaseAutomaticTuning or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38363:c0:m2"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ServerPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ServerPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of all servers in the subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Server\n        :rtype:\n         ~azure.mgmt.sql.models.ServerPaged[~azure.mgmt.sql.models.Server]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38364:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, server_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>server_name=server_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes a server.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38364:c0:m8"}
{"signature": "def update(<EOL>self, resource_group_name, server_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_initial(<EOL>resource_group_name=resource_group_name,<EOL>server_name=server_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a server.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param parameters: The requested server resource state.\n        :type parameters: ~azure.mgmt.sql.models.ServerUpdate\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Server or\n         ClientRawResponse<Server> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.sql.models.Server]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.sql.models.Server]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38364:c0:m10"}
{"signature": "def get(<EOL>self, resource_group_name, server_name, communication_link_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", communication_link_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Returns a server communication link.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param communication_link_name: The name of the server communication\n         link.\n        :type communication_link_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ServerCommunicationLink or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.sql.models.ServerCommunicationLink or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38365:c0:m2"}
{"signature": "def export(<EOL>self, resource_group_name, managed_instance_name, database_name, scan_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.export.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", managed_instance_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", database_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.vulnerability_assessment_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", scan_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Convert an existing scan result to a human readable format. If already\n        exists nothing happens.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param managed_instance_name: The name of the managed instance.\n        :type managed_instance_name: str\n        :param database_name: The name of the scanned database.\n        :type database_name: str\n        :param scan_id: The vulnerability assessment scan Id.\n        :type scan_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DatabaseVulnerabilityAssessmentScansExport or\n         ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.sql.models.DatabaseVulnerabilityAssessmentScansExport or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38366:c0:m5"}
{"signature": "def list_by_server(<EOL>self, resource_group_name, server_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_server.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ServerKeyPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ServerKeyPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of server keys.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ServerKey\n        :rtype:\n         ~azure.mgmt.sql.models.ServerKeyPaged[~azure.mgmt.sql.models.ServerKey]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38370:c0:m1"}
{"signature": "def get(<EOL>self, resource_group_name, server_name, key_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", key_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a server key.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param key_name: The name of the server key to be retrieved.\n        :type key_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ServerKey or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.sql.models.ServerKey or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38370:c0:m2"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, managed_instance_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>managed_instance_name=managed_instance_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a threat detection policy.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param managed_instance_name: The name of the managed instance.\n        :type managed_instance_name: str\n        :param parameters: The managed server security alert policy.\n        :type parameters:\n         ~azure.mgmt.sql.models.ManagedServerSecurityAlertPolicy\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ManagedServerSecurityAlertPolicy or\n         ClientRawResponse<ManagedServerSecurityAlertPolicy> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.sql.models.ManagedServerSecurityAlertPolicy]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.sql.models.ManagedServerSecurityAlertPolicy]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38371:c0:m3"}
{"signature": "def get(<EOL>self, resource_group_name, managed_instance_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", managed_instance_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.security_alert_policy_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get a managed server's threat detection policy.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param managed_instance_name: The name of the managed instance.\n        :type managed_instance_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ManagedServerSecurityAlertPolicy or ClientRawResponse if\n         raw=true\n        :rtype: ~azure.mgmt.sql.models.ManagedServerSecurityAlertPolicy or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38371:c0:m1"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, managed_instance_name, restorable_dropped_database_id, retention_days=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>managed_instance_name=managed_instance_name,<EOL>restorable_dropped_database_id=restorable_dropped_database_id,<EOL>retention_days=retention_days,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Sets a database's long term retention policy.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param managed_instance_name: The name of the managed instance.\n        :type managed_instance_name: str\n        :param restorable_dropped_database_id:\n        :type restorable_dropped_database_id: str\n        :param retention_days: The backup retention period in days. This is\n         how many days Point-in-Time Restore will be supported.\n        :type retention_days: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ManagedBackupShortTermRetentionPolicy or\n         ClientRawResponse<ManagedBackupShortTermRetentionPolicy> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.sql.models.ManagedBackupShortTermRetentionPolicy]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.sql.models.ManagedBackupShortTermRetentionPolicy]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38373:c0:m3"}
{"signature": "def update(<EOL>self, resource_group_name, managed_instance_name, restorable_dropped_database_id, retention_days=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_initial(<EOL>resource_group_name=resource_group_name,<EOL>managed_instance_name=managed_instance_name,<EOL>restorable_dropped_database_id=restorable_dropped_database_id,<EOL>retention_days=retention_days,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Sets a database's long term retention policy.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param managed_instance_name: The name of the managed instance.\n        :type managed_instance_name: str\n        :param restorable_dropped_database_id:\n        :type restorable_dropped_database_id: str\n        :param retention_days: The backup retention period in days. This is\n         how many days Point-in-Time Restore will be supported.\n        :type retention_days: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ManagedBackupShortTermRetentionPolicy or\n         ClientRawResponse<ManagedBackupShortTermRetentionPolicy> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.sql.models.ManagedBackupShortTermRetentionPolicy]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.sql.models.ManagedBackupShortTermRetentionPolicy]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38373:c0:m5"}
{"signature": "def get(<EOL>self, resource_group_name, managed_instance_name, restorable_dropped_database_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", managed_instance_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", restorable_dropped_database_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.policy_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a dropped database's short term retention policy.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param managed_instance_name: The name of the managed instance.\n        :type managed_instance_name: str\n        :param restorable_dropped_database_id:\n        :type restorable_dropped_database_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ManagedBackupShortTermRetentionPolicy or ClientRawResponse if\n         raw=true\n        :rtype: ~azure.mgmt.sql.models.ManagedBackupShortTermRetentionPolicy\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38373:c0:m1"}
{"signature": "def list_by_database(<EOL>self, resource_group_name, server_name, database_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_database.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", database_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.BackupShortTermRetentionPolicyPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.BackupShortTermRetentionPolicyPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a database's short term retention policy.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param database_name: The name of the database.\n        :type database_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of BackupShortTermRetentionPolicy\n        :rtype:\n         ~azure.mgmt.sql.models.BackupShortTermRetentionPolicyPaged[~azure.mgmt.sql.models.BackupShortTermRetentionPolicy]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38374:c0:m6"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, server_name, database_name, retention_days=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>server_name=server_name,<EOL>database_name=database_name,<EOL>retention_days=retention_days,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a database's short term retention policy.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param database_name: The name of the database.\n        :type database_name: str\n        :param retention_days: The backup retention period in days. This is\n         how many days Point-in-Time Restore will be supported.\n        :type retention_days: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         BackupShortTermRetentionPolicy or\n         ClientRawResponse<BackupShortTermRetentionPolicy> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.sql.models.BackupShortTermRetentionPolicy]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.sql.models.BackupShortTermRetentionPolicy]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38374:c0:m3"}
{"signature": "def update(<EOL>self, resource_group_name, server_name, database_name, retention_days=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_initial(<EOL>resource_group_name=resource_group_name,<EOL>server_name=server_name,<EOL>database_name=database_name,<EOL>retention_days=retention_days,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a database's short term retention policy.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param database_name: The name of the database.\n        :type database_name: str\n        :param retention_days: The backup retention period in days. This is\n         how many days Point-in-Time Restore will be supported.\n        :type retention_days: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         BackupShortTermRetentionPolicy or\n         ClientRawResponse<BackupShortTermRetentionPolicy> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.sql.models.BackupShortTermRetentionPolicy]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.sql.models.BackupShortTermRetentionPolicy]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38374:c0:m5"}
{"signature": "def list_by_server(<EOL>self, resource_group_name, server_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_server.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ServerDnsAliasPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ServerDnsAliasPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of server DNS aliases for a server.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server that the alias is pointing\n         to.\n        :type server_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ServerDnsAlias\n        :rtype:\n         ~azure.mgmt.sql.models.ServerDnsAliasPaged[~azure.mgmt.sql.models.ServerDnsAlias]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38375:c0:m6"}
{"signature": "def delete(<EOL>self, resource_group_name, location_name, failover_group_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>location_name=location_name,<EOL>failover_group_name=failover_group_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes a failover group.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param location_name: The name of the region where the resource is\n         located.\n        :type location_name: str\n        :param failover_group_name: The name of the failover group.\n        :type failover_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38376:c0:m5"}
{"signature": "def list_by_elastic_pool(<EOL>self, resource_group_name, server_name, elastic_pool_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_elastic_pool.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", elastic_pool_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ElasticPoolOperationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ElasticPoolOperationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of operations performed on the elastic pool.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param elastic_pool_name:\n        :type elastic_pool_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ElasticPoolOperation\n        :rtype:\n         ~azure.mgmt.sql.models.ElasticPoolOperationPaged[~azure.mgmt.sql.models.ElasticPoolOperation]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38380:c0:m2"}
{"signature": "def list_by_location(<EOL>self, location_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_location.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", location_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SubscriptionUsagePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SubscriptionUsagePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all subscription usage metrics in a given location.\n\n        :param location_name: The name of the region where the resource is\n         located.\n        :type location_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of SubscriptionUsage\n        :rtype:\n         ~azure.mgmt.sql.models.SubscriptionUsagePaged[~azure.mgmt.sql.models.SubscriptionUsage]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38381:c0:m1"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, server_name, database_name, rule_id, baseline_name, baseline_results, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.DatabaseVulnerabilityAssessmentRuleBaseline(baseline_results=baseline_results)<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", database_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.vulnerability_assessment_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", rule_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", baseline_name, '<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or updates a database's vulnerability assessment rule baseline.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param database_name: The name of the database for which the\n         vulnerability assessment rule baseline is defined.\n        :type database_name: str\n        :param rule_id: The vulnerability assessment rule ID.\n        :type rule_id: str\n        :param baseline_name: The name of the vulnerability assessment rule\n         baseline (default implies a baseline on a database level rule and\n         master for server level rule). Possible values include: 'master',\n         'default'\n        :type baseline_name: str or\n         ~azure.mgmt.sql.models.VulnerabilityAssessmentPolicyBaselineName\n        :param baseline_results: The rule baseline result\n        :type baseline_results:\n         list[~azure.mgmt.sql.models.DatabaseVulnerabilityAssessmentRuleBaselineItem]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DatabaseVulnerabilityAssessmentRuleBaseline or\n         ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.sql.models.DatabaseVulnerabilityAssessmentRuleBaseline or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38382:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, server_name, database_name, rule_id, baseline_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", database_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.vulnerability_assessment_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", rule_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", baseline_name, '<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a database's vulnerability assessment rule baseline.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param database_name: The name of the database for which the\n         vulnerability assessment rule baseline is defined.\n        :type database_name: str\n        :param rule_id: The vulnerability assessment rule ID.\n        :type rule_id: str\n        :param baseline_name: The name of the vulnerability assessment rule\n         baseline (default implies a baseline on a database level rule and\n         master for server level rule). Possible values include: 'master',\n         'default'\n        :type baseline_name: str or\n         ~azure.mgmt.sql.models.VulnerabilityAssessmentPolicyBaselineName\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DatabaseVulnerabilityAssessmentRuleBaseline or\n         ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.sql.models.DatabaseVulnerabilityAssessmentRuleBaseline or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38382:c0:m1"}
{"signature": "def get(<EOL>self, resource_group_name, server_name, job_agent_name, credential_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", job_agent_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", credential_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a jobs credential.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param job_agent_name: The name of the job agent.\n        :type job_agent_name: str\n        :param credential_name: The name of the credential.\n        :type credential_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: JobCredential or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.sql.models.JobCredential or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38383:c0:m2"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, server_name, job_agent_name, credential_name, username, password, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.JobCredential(username=username, password=password)<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", job_agent_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", credential_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or updates a job credential.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param job_agent_name: The name of the job agent.\n        :type job_agent_name: str\n        :param credential_name: The name of the credential.\n        :type credential_name: str\n        :param username: The credential user name.\n        :type username: str\n        :param password: The credential password.\n        :type password: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: JobCredential or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.sql.models.JobCredential or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38383:c0:m3"}
{"signature": "def list_by_agent(<EOL>self, resource_group_name, server_name, job_agent_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_agent.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", job_agent_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.JobCredentialPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.JobCredentialPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of jobs credentials.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param job_agent_name: The name of the job agent.\n        :type job_agent_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of JobCredential\n        :rtype:\n         ~azure.mgmt.sql.models.JobCredentialPaged[~azure.mgmt.sql.models.JobCredential]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38383:c0:m1"}
{"signature": "def list_by_instance(<EOL>self, resource_group_name, managed_instance_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_instance.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", managed_instance_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ManagedDatabasePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ManagedDatabasePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of managed databases.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param managed_instance_name: The name of the managed instance.\n        :type managed_instance_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ManagedDatabase\n        :rtype:\n         ~azure.mgmt.sql.models.ManagedDatabasePaged[~azure.mgmt.sql.models.ManagedDatabase]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38384:c0:m3"}
{"signature": "def complete_restore(<EOL>self, location_name, operation_id, last_backup_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._complete_restore_initial(<EOL>location_name=location_name,<EOL>operation_id=operation_id,<EOL>last_backup_name=last_backup_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Completes the restore operation on a managed database.\n\n        :param location_name: The name of the region where the resource is\n         located.\n        :type location_name: str\n        :param operation_id: Management operation id that this request tries\n         to complete.\n        :type operation_id: str\n        :param last_backup_name: The last backup name to apply\n        :type last_backup_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38384:c0:m2"}
{"signature": "def list_recommended_by_database(<EOL>self, resource_group_name, managed_instance_name, database_name, skip_token=None, filter=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_recommended_by_database.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", managed_instance_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", database_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if skip_token is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", skip_token, '<STR_LIT:str>')<EOL><DEDENT>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SensitivityLabelPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SensitivityLabelPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the sensitivity labels of a given database.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param managed_instance_name: The name of the managed instance.\n        :type managed_instance_name: str\n        :param database_name: The name of the database.\n        :type database_name: str\n        :param skip_token:\n        :type skip_token: str\n        :param filter: An OData filter expression that filters elements in the\n         collection.\n        :type filter: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of SensitivityLabel\n        :rtype:\n         ~azure.mgmt.sql.models.SensitivityLabelPaged[~azure.mgmt.sql.models.SensitivityLabel]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38385:c0:m5"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, managed_instance_name, database_name, schema_name, table_name, column_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", managed_instance_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", database_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", schema_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", table_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", column_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.sensitivity_label_source, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or updates the sensitivity label of a given column.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param managed_instance_name: The name of the managed instance.\n        :type managed_instance_name: str\n        :param database_name: The name of the database.\n        :type database_name: str\n        :param schema_name: The name of the schema.\n        :type schema_name: str\n        :param table_name: The name of the table.\n        :type table_name: str\n        :param column_name: The name of the column.\n        :type column_name: str\n        :param parameters: The column sensitivity label resource.\n        :type parameters: ~azure.mgmt.sql.models.SensitivityLabel\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SensitivityLabel or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.sql.models.SensitivityLabel or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38385:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, server_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.vulnerability_assessment_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the server's vulnerability assessment.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server for which the vulnerability\n         assessment is defined.\n        :type server_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ServerVulnerabilityAssessment or ClientRawResponse if\n         raw=true\n        :rtype: ~azure.mgmt.sql.models.ServerVulnerabilityAssessment or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38386:c0:m1"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, server_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.vulnerability_assessment_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or updates the server's vulnerability assessment.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server for which the vulnerability\n         assessment is defined.\n        :type server_name: str\n        :param parameters: The requested resource.\n        :type parameters: ~azure.mgmt.sql.models.ServerVulnerabilityAssessment\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ServerVulnerabilityAssessment or ClientRawResponse if\n         raw=true\n        :rtype: ~azure.mgmt.sql.models.ServerVulnerabilityAssessment or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38386:c0:m2"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, server_name, database_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", database_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.security_alert_policy_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or updates a database's threat detection policy.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param database_name: The name of the database for which database\n         Threat Detection policy is defined.\n        :type database_name: str\n        :param parameters: The database Threat Detection policy.\n        :type parameters: ~azure.mgmt.sql.models.DatabaseSecurityAlertPolicy\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DatabaseSecurityAlertPolicy or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.sql.models.DatabaseSecurityAlertPolicy or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38388:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, server_name, database_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", database_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.security_alert_policy_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a database's threat detection policy.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param database_name: The name of the database for which database\n         Threat Detection policy is defined.\n        :type database_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DatabaseSecurityAlertPolicy or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.sql.models.DatabaseSecurityAlertPolicy or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38388:c0:m1"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, server_name, connection_type, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.ServerConnectionPolicy(connection_type=connection_type)<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.connection_policy_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or updates the server's connection policy.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param connection_type: The server connection type. Possible values\n         include: 'Default', 'Proxy', 'Redirect'\n        :type connection_type: str or\n         ~azure.mgmt.sql.models.ServerConnectionType\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ServerConnectionPolicy or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.sql.models.ServerConnectionPolicy or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38390:c0:m1"}
{"signature": "def list_by_database(<EOL>self, resource_group_name, server_name, database_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_database.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", database_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RestorePointPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RestorePointPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of database restore points.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param database_name: The name of the database.\n        :type database_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of RestorePoint\n        :rtype:\n         ~azure.mgmt.sql.models.RestorePointPaged[~azure.mgmt.sql.models.RestorePoint]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38392:c0:m1"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, server_name, job_agent_name, job_name, step_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", job_agent_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", job_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", step_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or updates a job step. This will implicitly create a new job\n        version.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param job_agent_name: The name of the job agent.\n        :type job_agent_name: str\n        :param job_name: The name of the job.\n        :type job_name: str\n        :param step_name: The name of the job step.\n        :type step_name: str\n        :param parameters: The requested state of the job step.\n        :type parameters: ~azure.mgmt.sql.models.JobStep\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: JobStep or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.sql.models.JobStep or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38395:c0:m5"}
{"signature": "def get(<EOL>self, resource_group_name, server_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves server automatic tuning options.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ServerAutomaticTuning or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.sql.models.ServerAutomaticTuning or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38398:c0:m1"}
{"signature": "def list_by_database(<EOL>self, resource_group_name, server_name, database_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_database.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", database_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.vulnerability_assessment_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VulnerabilityAssessmentScanRecordPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VulnerabilityAssessmentScanRecordPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists the vulnerability assessment scans of a database.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param database_name: The name of the database.\n        :type database_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of\n         VulnerabilityAssessmentScanRecord\n        :rtype:\n         ~azure.mgmt.sql.models.VulnerabilityAssessmentScanRecordPaged[~azure.mgmt.sql.models.VulnerabilityAssessmentScanRecord]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38399:c0:m1"}
{"signature": "def initiate_scan(<EOL>self, resource_group_name, server_name, database_name, scan_id, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._initiate_scan_initial(<EOL>resource_group_name=resource_group_name,<EOL>server_name=server_name,<EOL>database_name=database_name,<EOL>scan_id=scan_id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Executes a Vulnerability Assessment database scan.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param database_name: The name of the database.\n        :type database_name: str\n        :param scan_id: The vulnerability assessment scan Id of the scan to\n         retrieve.\n        :type scan_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38399:c0:m4"}
{"signature": "def delete(<EOL>self, resource_group_name, server_name, sync_agent_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>server_name=server_name,<EOL>sync_agent_name=sync_agent_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes a sync agent.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server on which the sync agent is\n         hosted.\n        :type server_name: str\n        :param sync_agent_name: The name of the sync agent.\n        :type sync_agent_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38400:c0:m5"}
{"signature": "def generate_key(<EOL>self, resource_group_name, server_name, sync_agent_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.generate_key.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", sync_agent_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Generates a sync agent key.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server on which the sync agent is\n         hosted.\n        :type server_name: str\n        :param sync_agent_name: The name of the sync agent.\n        :type sync_agent_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SyncAgentKeyProperties or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.sql.models.SyncAgentKeyProperties or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38400:c0:m7"}
{"signature": "def get(<EOL>self, resource_group_name, server_name, sync_agent_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", sync_agent_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a sync agent.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server on which the sync agent is\n         hosted.\n        :type server_name: str\n        :param sync_agent_name: The name of the sync agent.\n        :type sync_agent_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SyncAgent or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.sql.models.SyncAgent or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38400:c0:m1"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, server_name, database_name, schema_name, table_name, column_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", database_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", schema_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", table_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", column_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.sensitivity_label_source, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or updates the sensitivity label of a given column.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param database_name: The name of the database.\n        :type database_name: str\n        :param schema_name: The name of the schema.\n        :type schema_name: str\n        :param table_name: The name of the table.\n        :type table_name: str\n        :param column_name: The name of the column.\n        :type column_name: str\n        :param parameters: The column sensitivity label resource.\n        :type parameters: ~azure.mgmt.sql.models.SensitivityLabel\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SensitivityLabel or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.sql.models.SensitivityLabel or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38401:c0:m4"}
{"signature": "def delete(<EOL>self, resource_group_name, server_name, database_name, schema_name, table_name, column_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", database_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", schema_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", table_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", column_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.sensitivity_label_source, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes the sensitivity label of a given column.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param database_name: The name of the database.\n        :type database_name: str\n        :param schema_name: The name of the schema.\n        :type schema_name: str\n        :param table_name: The name of the table.\n        :type table_name: str\n        :param column_name: The name of the column.\n        :type column_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38401:c0:m5"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, server_name, failover_group_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>server_name=server_name,<EOL>failover_group_name=failover_group_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a failover group.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server containing the failover\n         group.\n        :type server_name: str\n        :param failover_group_name: The name of the failover group.\n        :type failover_group_name: str\n        :param parameters: The failover group parameters.\n        :type parameters: ~azure.mgmt.sql.models.FailoverGroup\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns FailoverGroup or\n         ClientRawResponse<FailoverGroup> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.sql.models.FailoverGroup]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.sql.models.FailoverGroup]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38406:c0:m3"}
{"signature": "def delete(<EOL>self, resource_group_name, server_name, failover_group_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>server_name=server_name,<EOL>failover_group_name=failover_group_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes a failover group.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server containing the failover\n         group.\n        :type server_name: str\n        :param failover_group_name: The name of the failover group.\n        :type failover_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38406:c0:m5"}
{"signature": "def update(<EOL>self, resource_group_name, server_name, failover_group_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_initial(<EOL>resource_group_name=resource_group_name,<EOL>server_name=server_name,<EOL>failover_group_name=failover_group_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a failover group.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server containing the failover\n         group.\n        :type server_name: str\n        :param failover_group_name: The name of the failover group.\n        :type failover_group_name: str\n        :param parameters: The failover group parameters.\n        :type parameters: ~azure.mgmt.sql.models.FailoverGroupUpdate\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns FailoverGroup or\n         ClientRawResponse<FailoverGroup> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.sql.models.FailoverGroup]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.sql.models.FailoverGroup]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38406:c0:m7"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, server_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>server_name=server_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a server's blob auditing policy.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param parameters: Properties of blob auditing policy\n        :type parameters: ~azure.mgmt.sql.models.ServerBlobAuditingPolicy\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         ServerBlobAuditingPolicy or\n         ClientRawResponse<ServerBlobAuditingPolicy> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.sql.models.ServerBlobAuditingPolicy]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.sql.models.ServerBlobAuditingPolicy]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38407:c0:m3"}
{"signature": "def list_by_job(<EOL>self, resource_group_name, server_name, job_agent_name, job_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_job.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", job_agent_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", job_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.JobVersionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.JobVersionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all versions of a job.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param job_agent_name: The name of the job agent.\n        :type job_agent_name: str\n        :param job_name: The name of the job to get.\n        :type job_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of JobVersion\n        :rtype:\n         ~azure.mgmt.sql.models.JobVersionPaged[~azure.mgmt.sql.models.JobVersion]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38408:c0:m1"}
{"signature": "def get(<EOL>self, resource_group_name, server_name, job_agent_name, job_name, job_version, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", job_agent_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", job_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", job_version, '<STR_LIT:int>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a job version.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param job_agent_name: The name of the job agent.\n        :type job_agent_name: str\n        :param job_name: The name of the job.\n        :type job_name: str\n        :param job_version: The version of the job to get.\n        :type job_version: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: JobVersion or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.sql.models.JobVersion or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38408:c0:m2"}
{"signature": "def list_by_instance(<EOL>self, resource_group_name, managed_instance_name, filter=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_instance.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", managed_instance_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ManagedInstanceKeyPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ManagedInstanceKeyPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of managed instance keys.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param managed_instance_name: The name of the managed instance.\n        :type managed_instance_name: str\n        :param filter: An OData filter expression that filters elements in the\n         collection.\n        :type filter: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ManagedInstanceKey\n        :rtype:\n         ~azure.mgmt.sql.models.ManagedInstanceKeyPaged[~azure.mgmt.sql.models.ManagedInstanceKey]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38409:c0:m1"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, server_name, job_agent_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>server_name=server_name,<EOL>job_agent_name=job_agent_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a job agent.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param job_agent_name: The name of the job agent to be created or\n         updated.\n        :type job_agent_name: str\n        :param parameters: The requested job agent resource state.\n        :type parameters: ~azure.mgmt.sql.models.JobAgent\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns JobAgent or\n         ClientRawResponse<JobAgent> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.sql.models.JobAgent]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.sql.models.JobAgent]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38410:c0:m4"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, server_name, database_name, sync_group_name, sync_member_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>server_name=server_name,<EOL>database_name=database_name,<EOL>sync_group_name=sync_group_name,<EOL>sync_member_name=sync_member_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a sync member.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param database_name: The name of the database on which the sync group\n         is hosted.\n        :type database_name: str\n        :param sync_group_name: The name of the sync group on which the sync\n         member is hosted.\n        :type sync_group_name: str\n        :param sync_member_name: The name of the sync member.\n        :type sync_member_name: str\n        :param parameters: The requested sync member resource state.\n        :type parameters: ~azure.mgmt.sql.models.SyncMember\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns SyncMember or\n         ClientRawResponse<SyncMember> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.sql.models.SyncMember]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.sql.models.SyncMember]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38411:c0:m3"}
{"signature": "def refresh_member_schema(<EOL>self, resource_group_name, server_name, database_name, sync_group_name, sync_member_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._refresh_member_schema_initial(<EOL>resource_group_name=resource_group_name,<EOL>server_name=server_name,<EOL>database_name=database_name,<EOL>sync_group_name=sync_group_name,<EOL>sync_member_name=sync_member_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Refreshes a sync member database schema.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param database_name: The name of the database on which the sync group\n         is hosted.\n        :type database_name: str\n        :param sync_group_name: The name of the sync group on which the sync\n         member is hosted.\n        :type sync_group_name: str\n        :param sync_member_name: The name of the sync member.\n        :type sync_member_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38411:c0:m11"}
{"signature": "def list_by_step(<EOL>self, resource_group_name, server_name, job_agent_name, job_name, job_execution_id, step_name, create_time_min=None, create_time_max=None, end_time_min=None, end_time_max=None, is_active=None, skip=None, top=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_step.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", job_agent_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", job_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", job_execution_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", step_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if create_time_min is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", create_time_min, '<STR_LIT>')<EOL><DEDENT>if create_time_max is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", create_time_max, '<STR_LIT>')<EOL><DEDENT>if end_time_min is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", end_time_min, '<STR_LIT>')<EOL><DEDENT>if end_time_max is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", end_time_max, '<STR_LIT>')<EOL><DEDENT>if is_active is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", is_active, '<STR_LIT:bool>')<EOL><DEDENT>if skip is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", skip, '<STR_LIT:int>')<EOL><DEDENT>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.JobExecutionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.JobExecutionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists the target executions of a job step execution.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param job_agent_name: The name of the job agent.\n        :type job_agent_name: str\n        :param job_name: The name of the job to get.\n        :type job_name: str\n        :param job_execution_id: The id of the job execution\n        :type job_execution_id: str\n        :param step_name: The name of the step.\n        :type step_name: str\n        :param create_time_min: If specified, only job executions created at\n         or after the specified time are included.\n        :type create_time_min: datetime\n        :param create_time_max: If specified, only job executions created\n         before the specified time are included.\n        :type create_time_max: datetime\n        :param end_time_min: If specified, only job executions completed at or\n         after the specified time are included.\n        :type end_time_min: datetime\n        :param end_time_max: If specified, only job executions completed\n         before the specified time are included.\n        :type end_time_max: datetime\n        :param is_active: If specified, only active or only completed job\n         executions are included.\n        :type is_active: bool\n        :param skip: The number of elements in the collection to skip.\n        :type skip: int\n        :param top: The number of elements to return from the collection.\n        :type top: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of JobExecution\n        :rtype:\n         ~azure.mgmt.sql.models.JobExecutionPaged[~azure.mgmt.sql.models.JobExecution]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38412:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, server_name, database_name, sync_group_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>server_name=server_name,<EOL>database_name=database_name,<EOL>sync_group_name=sync_group_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes a sync group.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param database_name: The name of the database on which the sync group\n         is hosted.\n        :type database_name: str\n        :param sync_group_name: The name of the sync group.\n        :type sync_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38413:c0:m12"}
{"signature": "def list_logs(<EOL>self, resource_group_name, server_name, database_name, sync_group_name, start_time, end_time, type, continuation_token=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_logs.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", database_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", sync_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", start_time, '<STR_LIT:str>')<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", end_time, '<STR_LIT:str>')<EOL>query_parameters['<STR_LIT:type>'] = self._serialize.query(\"<STR_LIT:type>\", type, '<STR_LIT:str>')<EOL>if continuation_token is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", continuation_token, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SyncGroupLogPropertiesPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SyncGroupLogPropertiesPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a collection of sync group logs.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param database_name: The name of the database on which the sync group\n         is hosted.\n        :type database_name: str\n        :param sync_group_name: The name of the sync group.\n        :type sync_group_name: str\n        :param start_time: Get logs generated after this time.\n        :type start_time: str\n        :param end_time: Get logs generated before this time.\n        :type end_time: str\n        :param type: The types of logs to retrieve. Possible values include:\n         'All', 'Error', 'Warning', 'Success'\n        :type type: str\n        :param continuation_token: The continuation token for this operation.\n        :type continuation_token: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of SyncGroupLogProperties\n        :rtype:\n         ~azure.mgmt.sql.models.SyncGroupLogPropertiesPaged[~azure.mgmt.sql.models.SyncGroupLogProperties]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38413:c0:m5"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, server_name, database_name, sync_group_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>server_name=server_name,<EOL>database_name=database_name,<EOL>sync_group_name=sync_group_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a sync group.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param database_name: The name of the database on which the sync group\n         is hosted.\n        :type database_name: str\n        :param sync_group_name: The name of the sync group.\n        :type sync_group_name: str\n        :param parameters: The requested sync group resource state.\n        :type parameters: ~azure.mgmt.sql.models.SyncGroup\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns SyncGroup or\n         ClientRawResponse<SyncGroup> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.sql.models.SyncGroup]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.sql.models.SyncGroup]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38413:c0:m10"}
{"signature": "def get(<EOL>self, resource_group_name, server_name, database_name, sync_group_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", database_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", sync_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a sync group.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param database_name: The name of the database on which the sync group\n         is hosted.\n        :type database_name: str\n        :param sync_group_name: The name of the sync group.\n        :type sync_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SyncGroup or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.sql.models.SyncGroup or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38413:c0:m8"}
{"signature": "def list_by_server(<EOL>self, resource_group_name, server_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_server.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ServiceObjectivePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ServiceObjectivePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Returns database service objectives.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ServiceObjective\n        :rtype:\n         ~azure.mgmt.sql.models.ServiceObjectivePaged[~azure.mgmt.sql.models.ServiceObjective]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38414:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, server_name, elastic_pool_name, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", elastic_pool_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets an elastic pool.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param elastic_pool_name: The name of the elastic pool.\n        :type elastic_pool_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ElasticPool or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.sql.models.ElasticPool or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38417:c0:m4"}
{"signature": "def update(<EOL>self, resource_group_name, server_name, elastic_pool_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_initial(<EOL>resource_group_name=resource_group_name,<EOL>server_name=server_name,<EOL>elastic_pool_name=elastic_pool_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates an elastic pool.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param elastic_pool_name: The name of the elastic pool.\n        :type elastic_pool_name: str\n        :param parameters: The elastic pool update parameters.\n        :type parameters: ~azure.mgmt.sql.models.ElasticPoolUpdate\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ElasticPool or\n         ClientRawResponse<ElasticPool> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.sql.models.ElasticPool]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.sql.models.ElasticPool]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38417:c0:m10"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, server_name, elastic_pool_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>server_name=server_name,<EOL>elastic_pool_name=elastic_pool_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates an elastic pool.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param server_name: The name of the server.\n        :type server_name: str\n        :param elastic_pool_name: The name of the elastic pool.\n        :type elastic_pool_name: str\n        :param parameters: The elastic pool parameters.\n        :type parameters: ~azure.mgmt.sql.models.ElasticPool\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ElasticPool or\n         ClientRawResponse<ElasticPool> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.sql.models.ElasticPool]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.sql.models.ElasticPool]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38417:c0:m6"}
{"signature": "def list(<EOL>self, top=None, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.filter, '<STR_LIT:str>')<EOL>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ResourcePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ResourcePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "The List operation gets information about the vaults associated with\n        the subscription.\n\n        :param top: Maximum number of results to return.\n        :type top: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Resource\n        :rtype:\n         ~azure.mgmt.keyvault.v2016_10_01.models.ResourcePaged[~azure.mgmt.keyvault.v2016_10_01.models.Resource]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38475:c0:m12"}
{"signature": "def update(<EOL>self, resource_group_name, vault_name, tags=None, properties=None, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.VaultPatchParameters(tags=tags, properties=properties)<EOL>api_version = \"<STR_LIT>\"<EOL>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_name, '<STR_LIT:str>', pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, body_content, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Update a key vault in the specified subscription.\n\n        :param resource_group_name: The name of the Resource Group to which\n         the server belongs.\n        :type resource_group_name: str\n        :param vault_name: Name of the vault\n        :type vault_name: str\n        :param tags: The tags that will be assigned to the key vault.\n        :type tags: dict[str, str]\n        :param properties: Properties of the vault\n        :type properties:\n         ~azure.mgmt.keyvault.v2016_10_01.models.VaultPatchProperties\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Vault or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.keyvault.v2016_10_01.models.Vault or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38475:c0:m2"}
{"signature": "def get_deleted(<EOL>self, vault_name, location, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get_deleted.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_name, '<STR_LIT:str>'),<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the deleted Azure key vault.\n\n        :param vault_name: The name of the vault.\n        :type vault_name: str\n        :param location: The location of the deleted vault.\n        :type location: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DeletedVault or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.keyvault.v2016_10_01.models.DeletedVault or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38475:c0:m9"}
{"signature": "def get(<EOL>self, resource_group_name, vault_name, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified Azure key vault.\n\n        :param resource_group_name: The name of the Resource Group to which\n         the vault belongs.\n        :type resource_group_name: str\n        :param vault_name: The name of the vault.\n        :type vault_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Vault or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.keyvault.v2016_10_01.models.Vault or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38475:c0:m4"}
{"signature": "def purge_deleted(<EOL>self, vault_name, location, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._purge_deleted_initial(<EOL>vault_name=vault_name,<EOL>location=location,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Permanently deletes the specified vault. aka Purges the deleted Azure\n        key vault.\n\n        :param vault_name: The name of the soft-deleted vault.\n        :type vault_name: str\n        :param location: The location of the soft-deleted vault.\n        :type location: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38475:c0:m11"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, top=None, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VaultPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VaultPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "The List operation gets information about the vaults associated with\n        the subscription and within the specified resource group.\n\n        :param resource_group_name: The name of the Resource Group to which\n         the vault belongs.\n        :type resource_group_name: str\n        :param top: Maximum number of results to return.\n        :type top: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Vault\n        :rtype:\n         ~azure.mgmt.keyvault.v2018_02_14.models.VaultPaged[~azure.mgmt.keyvault.v2018_02_14.models.Vault]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38521:c0:m7"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, vault_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>vault_name=vault_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Create or update a key vault in the specified subscription.\n\n        :param resource_group_name: The name of the Resource Group to which\n         the server belongs.\n        :type resource_group_name: str\n        :param vault_name: Name of the vault\n        :type vault_name: str\n        :param parameters: Parameters to create or update the vault\n        :type parameters:\n         ~azure.mgmt.keyvault.v2018_02_14.models.VaultCreateOrUpdateParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Vault or\n         ClientRawResponse<Vault> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.keyvault.v2018_02_14.models.Vault]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.keyvault.v2018_02_14.models.Vault]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38521:c0:m2"}
{"signature": "def update(<EOL>self, resource_group_name, resource_name, data_volume_cap=None, current_billing_features=None, custom_headers=None, raw=False, **operation_config):", "body": "billing_features_properties = models.ApplicationInsightsComponentBillingFeatures(data_volume_cap=data_volume_cap, current_billing_features=current_billing_features)<EOL>url = '<STR_LIT>'<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(billing_features_properties, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, body_content, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Update current billing features for an Application Insights component.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param resource_name: The name of the Application Insights component\n         resource.\n        :type resource_name: str\n        :param data_volume_cap: An Application Insights component daily data\n         volumne cap\n        :type data_volume_cap:\n         ~azure.mgmt.applicationinsights.models.ApplicationInsightsComponentDataVolumeCap\n        :param current_billing_features: Current enabled pricing plan. When\n         the component is in the Enterprise plan, this will list both 'Basic'\n         and 'Application Insights Enterprise'.\n        :type current_billing_features: list[str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ApplicationInsightsComponentBillingFeatures or\n         ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.applicationinsights.models.ApplicationInsightsComponentBillingFeatures\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38552:c0:m2"}
{"signature": "def create(<EOL>self, resource_group_name, resource_name, api_key_properties, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = '<STR_LIT>'<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(api_key_properties, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, body_content, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Create an API Key of an Application Insights component.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param resource_name: The name of the Application Insights component\n         resource.\n        :type resource_name: str\n        :param api_key_properties: Properties that need to be specified to\n         create an API key of a Application Insights component.\n        :type api_key_properties:\n         ~azure.mgmt.applicationinsights.models.APIKeyRequest\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ApplicationInsightsComponentAPIKey or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.applicationinsights.models.ApplicationInsightsComponentAPIKey\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38553:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, resource_name, key_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = '<STR_LIT>'<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", key_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the API Key for this key id.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param resource_name: The name of the Application Insights component\n         resource.\n        :type resource_name: str\n        :param key_id: The API Key ID. This is unique within a Application\n         Insights component.\n        :type key_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ApplicationInsightsComponentAPIKey or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.applicationinsights.models.ApplicationInsightsComponentAPIKey\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38553:c0:m4"}
{"signature": "def get(<EOL>self, resource_group_name, resource_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = '<STR_LIT>'<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Returns daily data volume cap (quota) status for an Application\n        Insights component.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param resource_name: The name of the Application Insights component\n         resource.\n        :type resource_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ApplicationInsightsComponentQuotaStatus or ClientRawResponse\n         if raw=true\n        :rtype:\n         ~azure.mgmt.applicationinsights.models.ApplicationInsightsComponentQuotaStatus\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38554:c0:m1"}
{"signature": "def delete(<EOL>self, resource_group_name, resource_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = '<STR_LIT>'<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes an Application Insights component.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param resource_name: The name of the Application Insights component\n         resource.\n        :type resource_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38558:c0:m3"}
{"signature": "def update_tags(<EOL>self, resource_group_name, resource_name, tags=None, custom_headers=None, raw=False, **operation_config):", "body": "component_tags = models.TagsResource(tags=tags)<EOL>url = '<STR_LIT>'<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(component_tags, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, body_content, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Updates an existing component's tags. To update other fields use the\n        CreateOrUpdate method.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param resource_name: The name of the Application Insights component\n         resource.\n        :type resource_name: str\n        :param tags: Resource tags\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ApplicationInsightsComponent or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.applicationinsights.models.ApplicationInsightsComponent or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38558:c0:m6"}
{"signature": "def delete(<EOL>self, resource_group_name, resource_name, export_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = '<STR_LIT>'<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", export_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Delete a Continuous Export configuration of an Application Insights\n        component.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param resource_name: The name of the Application Insights component\n         resource.\n        :type resource_name: str\n        :param export_id: The Continuous Export configuration ID. This is\n         unique within a Application Insights component.\n        :type export_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ApplicationInsightsComponentExportConfiguration or\n         ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.applicationinsights.models.ApplicationInsightsComponentExportConfiguration\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38559:c0:m3"}
{"signature": "def create(<EOL>self, resource_group_name, resource_name, export_properties, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = '<STR_LIT>'<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(export_properties, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, body_content, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Create a Continuous Export configuration of an Application Insights\n        component.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param resource_name: The name of the Application Insights component\n         resource.\n        :type resource_name: str\n        :param export_properties: Properties that need to be specified to\n         create a Continuous Export configuration of a Application Insights\n         component.\n        :type export_properties:\n         ~azure.mgmt.applicationinsights.models.ApplicationInsightsComponentExportRequest\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype:\n         list[~azure.mgmt.applicationinsights.models.ApplicationInsightsComponentExportConfiguration]\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38559:c0:m2"}
{"signature": "def list(<EOL>self, resource_group_name, private_zone_name, top=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", private_zone_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.VirtualNetworkLinkPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.VirtualNetworkLinkPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists the virtual network links to the specified Private DNS zone.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param private_zone_name: The name of the Private DNS zone (without a\n         terminating dot).\n        :type private_zone_name: str\n        :param top: The maximum number of virtual network links to return. If\n         not specified, returns up to 100 virtual network links.\n        :type top: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of VirtualNetworkLink\n        :rtype:\n         ~azure.mgmt.privatedns.models.VirtualNetworkLinkPaged[~azure.mgmt.privatedns.models.VirtualNetworkLink]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38582:c0:m8"}
{"signature": "def list(<EOL>self, top=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PrivateZonePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PrivateZonePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists the Private DNS zones in all resource groups in a subscription.\n\n        :param top: The maximum number of Private DNS zones to return. If not\n         specified, returns up to 100 zones.\n        :type top: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PrivateZone\n        :rtype:\n         ~azure.mgmt.privatedns.models.PrivateZonePaged[~azure.mgmt.privatedns.models.PrivateZone]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38583:c0:m8"}
{"signature": "def get(<EOL>self, resource_group_name, private_zone_name, record_type, relative_record_set_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", private_zone_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", record_type, '<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", relative_record_set_name, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a record set.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param private_zone_name: The name of the Private DNS zone (without a\n         terminating dot).\n        :type private_zone_name: str\n        :param record_type: The type of DNS record in this record set.\n         Possible values include: 'A', 'AAAA', 'CNAME', 'MX', 'PTR', 'SOA',\n         'SRV', 'TXT'\n        :type record_type: str or ~azure.mgmt.privatedns.models.RecordType\n        :param relative_record_set_name: The name of the record set, relative\n         to the name of the zone.\n        :type relative_record_set_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RecordSet or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.privatedns.models.RecordSet or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38585:c0:m4"}
{"signature": "def update(<EOL>self, resource_group_name, private_zone_name, record_type, relative_record_set_name, parameters, if_match=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", private_zone_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", record_type, '<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", relative_record_set_name, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if if_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_match, '<STR_LIT:str>')<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Updates a record set within a Private DNS zone.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param private_zone_name: The name of the Private DNS zone (without a\n         terminating dot).\n        :type private_zone_name: str\n        :param record_type: The type of DNS record in this record set.\n         Possible values include: 'A', 'AAAA', 'CNAME', 'MX', 'PTR', 'SOA',\n         'SRV', 'TXT'\n        :type record_type: str or ~azure.mgmt.privatedns.models.RecordType\n        :param relative_record_set_name: The name of the record set, relative\n         to the name of the zone.\n        :type relative_record_set_name: str\n        :param parameters: Parameters supplied to the Update operation.\n        :type parameters: ~azure.mgmt.privatedns.models.RecordSet\n        :param if_match: The ETag of the record set. Omit this value to always\n         overwrite the current record set. Specify the last-seen ETag value to\n         prevent accidentally overwriting concurrent changes.\n        :type if_match: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RecordSet or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.privatedns.models.RecordSet or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38585:c0:m2"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.OperationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.OperationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all of the available Microsoft.MarketplaceOrdering REST API\n        operations.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Operation\n        :rtype:\n         ~azure.mgmt.marketplaceordering.models.OperationPaged[~azure.mgmt.marketplaceordering.models.Operation]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.marketplaceordering.models.ErrorResponseException>`", "id": "f38603:c0:m1"}
{"signature": "def get(<EOL>self, publisher_id, offer_id, plan_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.offer_type, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", publisher_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", offer_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", plan_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get marketplace terms.\n\n        :param publisher_id: Publisher identifier string of image being\n         deployed.\n        :type publisher_id: str\n        :param offer_id: Offer identifier string of image being deployed.\n        :type offer_id: str\n        :param plan_id: Plan identifier string of image being deployed.\n        :type plan_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: AgreementTerms or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.marketplaceordering.models.AgreementTerms or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38604:c0:m1"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.DiscoveredSecuritySolutionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.DiscoveredSecuritySolutionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of discovered Security Solutions for the subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of DiscoveredSecuritySolution\n        :rtype:\n         ~azure.mgmt.security.models.DiscoveredSecuritySolutionPaged[~azure.mgmt.security.models.DiscoveredSecuritySolution]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38734:c0:m1"}
{"signature": "def list_by_home_region(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_home_region.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.asc_location, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.DiscoveredSecuritySolutionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.DiscoveredSecuritySolutionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of discovered Security Solutions for the subscription and\n        location.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of DiscoveredSecuritySolution\n        :rtype:\n         ~azure.mgmt.security.models.DiscoveredSecuritySolutionPaged[~azure.mgmt.security.models.DiscoveredSecuritySolution]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38734:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, discovered_security_solution_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.asc_location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", discovered_security_solution_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a specific discovered Security Solution.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription. The name is case insensitive.\n        :type resource_group_name: str\n        :param discovered_security_solution_name: Name of a discovered\n         security solution.\n        :type discovered_security_solution_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DiscoveredSecuritySolution or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.security.models.DiscoveredSecuritySolution or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38734:c0:m3"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Security pricing configurations in the subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PricingList or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.security.models.PricingList or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38735:c0:m1"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.OperationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.OperationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Exposes all available operations for discovery purposes.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Operation\n        :rtype:\n         ~azure.mgmt.security.models.OperationPaged[~azure.mgmt.security.models.Operation]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38736:c0:m1"}
{"signature": "def get(<EOL>self, workspace_setting_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", workspace_setting_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Settings about where we should store your security data and logs. If\n        the result is empty, it means that no custom-workspace configuration\n        was set.\n\n        :param workspace_setting_name: Name of the security setting\n        :type workspace_setting_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: WorkspaceSetting or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.security.models.WorkspaceSetting or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38737:c0:m2"}
{"signature": "def update(<EOL>self, workspace_setting_name, workspace_id, scope, custom_headers=None, raw=False, **operation_config):", "body": "workspace_setting = models.WorkspaceSetting(workspace_id=workspace_id, scope=scope)<EOL>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", workspace_setting_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(workspace_setting, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Settings about where we should store your security data and logs.\n\n        :param workspace_setting_name: Name of the security setting\n        :type workspace_setting_name: str\n        :param workspace_id: The full Azure ID of the workspace to save the\n         data in\n        :type workspace_id: str\n        :param scope: All the VMs in this scope will send their security data\n         to the mentioned workspace unless overridden by a setting with more\n         specific scope\n        :type scope: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: WorkspaceSetting or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.security.models.WorkspaceSetting or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38737:c0:m4"}
{"signature": "def delete(<EOL>self, workspace_setting_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", workspace_setting_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes the custom workspace settings for this subscription. new VMs\n        will report to the default workspace.\n\n        :param workspace_setting_name: Name of the security setting\n        :type workspace_setting_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38737:c0:m5"}
{"signature": "def create(<EOL>self, resource_id, is_enabled=None, custom_headers=None, raw=False, **operation_config):", "body": "advanced_threat_protection_setting = models.AdvancedThreatProtectionSetting(is_enabled=is_enabled)<EOL>url = self.create.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.setting_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(advanced_threat_protection_setting, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or updates the Advanced Threat Protection settings on a\n        specified resource.\n\n        :param resource_id: The identifier of the resource.\n        :type resource_id: str\n        :param is_enabled: Indicates whether Advanced Threat Protection is\n         enabled.\n        :type is_enabled: bool\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: AdvancedThreatProtectionSetting or ClientRawResponse if\n         raw=true\n        :rtype: ~azure.mgmt.security.models.AdvancedThreatProtectionSetting or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38738:c0:m2"}
{"signature": "def get(<EOL>self, setting_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", setting_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Settings of different configurations in security center.\n\n        :param setting_name: Name of setting: (MCAS/WDATP). Possible values\n         include: 'MCAS', 'WDATP'\n        :type setting_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Setting or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.security.models.Setting or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38740:c0:m2"}
{"signature": "def update(<EOL>self, setting_name, kind, custom_headers=None, raw=False, **operation_config):", "body": "setting = models.Setting(kind=kind)<EOL>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", setting_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(setting, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "updating settings about different configurations in security center.\n\n        :param setting_name: Name of setting: (MCAS/WDATP). Possible values\n         include: 'MCAS', 'WDATP'\n        :type setting_name: str\n        :param kind: the kind of the settings string (DataExportSetting).\n         Possible values include: 'DataExportSetting',\n         'AlertSuppressionSetting'\n        :type kind: str or ~azure.mgmt.security.models.SettingKind\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Setting or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.security.models.Setting or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38740:c0:m3"}
{"signature": "def list_by_resource_group_and_region(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group_and_region.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.asc_location, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.JitNetworkAccessPolicyPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.JitNetworkAccessPolicyPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Policies for protecting resources using Just-in-Time access control for\n        the subscription, location.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription. The name is case insensitive.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of JitNetworkAccessPolicy\n        :rtype:\n         ~azure.mgmt.security.models.JitNetworkAccessPolicyPaged[~azure.mgmt.security.models.JitNetworkAccessPolicy]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38741:c0:m4"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.JitNetworkAccessPolicyPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.JitNetworkAccessPolicyPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Policies for protecting resources using Just-in-Time access control.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of JitNetworkAccessPolicy\n        :rtype:\n         ~azure.mgmt.security.models.JitNetworkAccessPolicyPaged[~azure.mgmt.security.models.JitNetworkAccessPolicy]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38741:c0:m1"}
{"signature": "def list_by_region(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_region.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.asc_location, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.JitNetworkAccessPolicyPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.JitNetworkAccessPolicyPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Policies for protecting resources using Just-in-Time access control for\n        the subscription, location.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of JitNetworkAccessPolicy\n        :rtype:\n         ~azure.mgmt.security.models.JitNetworkAccessPolicyPaged[~azure.mgmt.security.models.JitNetworkAccessPolicy]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38741:c0:m2"}
{"signature": "def get(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.asc_location, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Details of a specific location.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: AscLocation or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.security.models.AscLocation or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38742:c0:m2"}
{"signature": "def list(<EOL>self, scope, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", scope, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.InformationProtectionPolicyPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.InformationProtectionPolicyPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Information protection policies of a specific management group.\n\n        :param scope: Scope of the query, can be subscription\n         (/subscriptions/0b06d9ea-afe6-4779-bd59-30e5c2d9d13f) or management\n         group (/providers/Microsoft.Management/managementGroups/mgName).\n        :type scope: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of InformationProtectionPolicy\n        :rtype:\n         ~azure.mgmt.security.models.InformationProtectionPolicyPaged[~azure.mgmt.security.models.InformationProtectionPolicy]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38743:c0:m3"}
{"signature": "def list_by_home_region(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_home_region.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.asc_location, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.AllowedConnectionsResourcePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.AllowedConnectionsResourcePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the list of all possible traffic between resources for the\n        subscription and location.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of AllowedConnectionsResource\n        :rtype:\n         ~azure.mgmt.security.models.AllowedConnectionsResourcePaged[~azure.mgmt.security.models.AllowedConnectionsResource]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38746:c0:m2"}
{"signature": "def list(<EOL>self, filter=None, select=None, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if select is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", select, '<STR_LIT:str>')<EOL><DEDENT>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.AlertPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.AlertPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List all the alerts that are associated with the subscription.\n\n        :param filter: OData filter. Optional.\n        :type filter: str\n        :param select: OData select. Optional.\n        :type select: str\n        :param expand: OData expand. Optional.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Alert\n        :rtype:\n         ~azure.mgmt.security.models.AlertPaged[~azure.mgmt.security.models.Alert]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38749:c0:m1"}
{"signature": "def get(<EOL>self, resource_group_name, external_security_solutions_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.asc_location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", external_security_solutions_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a specific external Security Solution.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription. The name is case insensitive.\n        :type resource_group_name: str\n        :param external_security_solutions_name: Name of an external security\n         solution.\n        :type external_security_solutions_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ExternalSecuritySolution or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.security.models.ExternalSecuritySolution or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38750:c0:m3"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.TopologyResourcePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.TopologyResourcePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list that allows to build a topology view of a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of TopologyResource\n        :rtype:\n         ~azure.mgmt.security.models.TopologyResourcePaged[~azure.mgmt.security.models.TopologyResource]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38751:c0:m1"}
{"signature": "def delete(<EOL>self, resource_group_name, account_name, application_name, version_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", application_name, '<STR_LIT:str>', max_length=<NUM_LIT:64>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", version_name, '<STR_LIT:str>', max_length=<NUM_LIT:64>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes an application package record and its associated binary file.\n\n        :param resource_group_name: The name of the resource group that\n         contains the Batch account.\n        :type resource_group_name: str\n        :param account_name: The name of the Batch account.\n        :type account_name: str\n        :param application_name: The name of the application. This must be\n         unique within the account.\n        :type application_name: str\n        :param version_name: The version of the application.\n        :type version_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38763:c0:m3"}
{"signature": "def create(<EOL>self, resource_group_name, account_name, pool_name, parameters, if_match=None, if_none_match=None, custom_headers=None, raw=False, **operation_config):", "body": "raw_result = self._create_initial(<EOL>resource_group_name=resource_group_name,<EOL>account_name=account_name,<EOL>pool_name=pool_name,<EOL>parameters=parameters,<EOL>if_match=if_match,<EOL>if_none_match=if_none_match,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>if raw:<EOL><INDENT>return raw_result<EOL><DEDENT>def long_running_send():<EOL><INDENT>return raw_result.response<EOL><DEDENT>def get_long_running_status(status_link, headers=None):<EOL><INDENT>request = self._client.get(status_link)<EOL>if headers:<EOL><INDENT>request.headers.update(headers)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = raw_result.response.request.headers['<STR_LIT>']<EOL>return self._client.send(<EOL>request, header_parameters, stream=False, **operation_config)<EOL><DEDENT>def get_long_running_output(response):<EOL><INDENT>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>header_dict = {<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>}<EOL>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>client_raw_response.add_headers(header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>long_running_operation_timeout = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>return AzureOperationPoller(<EOL>long_running_send, get_long_running_output,<EOL>get_long_running_status, long_running_operation_timeout)<EOL>", "docstring": "Creates a new pool inside the specified account.\n\n        :param resource_group_name: The name of the resource group that\n         contains the Batch account.\n        :type resource_group_name: str\n        :param account_name: The name of the Batch account.\n        :type account_name: str\n        :param pool_name: The pool name. This must be unique within the\n         account.\n        :type pool_name: str\n        :param parameters: Additional parameters for pool creation.\n        :type parameters: ~azure.mgmt.batch.models.Pool\n        :param if_match: The entity state (ETag) version of the pool to\n         update. A value of \"*\" can be used to apply the operation only if the\n         pool already exists. If omitted, this operation will always be\n         applied.\n        :type if_match: str\n        :param if_none_match: Set to '*' to allow a new pool to be created,\n         but to prevent updating an existing pool. Other values will be\n         ignored.\n        :type if_none_match: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :return: An instance of AzureOperationPoller that returns Pool or\n         ClientRawResponse if raw=true\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.batch.models.Pool]\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38765:c0:m3"}
{"signature": "def delete(<EOL>self, resource_group_name, account_name, application_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", application_name, '<STR_LIT:str>', max_length=<NUM_LIT:64>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes an application.\n\n        :param resource_group_name: The name of the resource group that\n         contains the Batch account.\n        :type resource_group_name: str\n        :param account_name: The name of the Batch account.\n        :type account_name: str\n        :param application_name: The name of the application. This must be\n         unique within the account.\n        :type application_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38766:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, account_name, application_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", application_name, '<STR_LIT:str>', max_length=<NUM_LIT:64>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about the specified application.\n\n        :param resource_group_name: The name of the resource group that\n         contains the Batch account.\n        :type resource_group_name: str\n        :param account_name: The name of the Batch account.\n        :type account_name: str\n        :param application_name: The name of the application. This must be\n         unique within the account.\n        :type application_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Application or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.batch.models.Application or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38766:c0:m3"}
{"signature": "def update(<EOL>self, resource_group_name, account_name, tags=None, auto_storage=None, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.BatchAccountUpdateParameters(tags=tags, auto_storage=auto_storage)<EOL>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, body_content, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Updates the properties of an existing Batch account.\n\n        :param resource_group_name: The name of the resource group that\n         contains the Batch account.\n        :type resource_group_name: str\n        :param account_name: The name of the Batch account.\n        :type account_name: str\n        :param tags: The user-specified tags associated with the account.\n        :type tags: dict[str, str]\n        :param auto_storage: The properties related to the auto-storage\n         account.\n        :type auto_storage: ~azure.mgmt.batch.models.AutoStorageBaseProperties\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: BatchAccount or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.batch.models.BatchAccount or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38769:c0:m3"}
{"signature": "def get(<EOL>self, resource_group_name, account_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about the specified Batch account.\n\n        :param resource_group_name: The name of the resource group that\n         contains the Batch account.\n        :type resource_group_name: str\n        :param account_name: The name of the Batch account.\n        :type account_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: BatchAccount or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.batch.models.BatchAccount or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38769:c0:m6"}
{"signature": "def synchronize_auto_storage_keys(<EOL>self, resource_group_name, account_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.synchronize_auto_storage_keys.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Synchronizes access keys for the auto-storage account configured for\n        the specified Batch account.\n\n        :param resource_group_name: The name of the resource group that\n         contains the Batch account.\n        :type resource_group_name: str\n        :param account_name: The name of the Batch account.\n        :type account_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38769:c0:m9"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.HanaInstancePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.HanaInstancePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of SAP HANA instances in the specified subscription.\n\n        Gets a list of SAP HANA instances in the specified subscription. The\n        operations returns various properties of each SAP HANA on Azure\n        instance.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of HanaInstance\n        :rtype:\n         ~azure.mgmt.hanaonazure.models.HanaInstancePaged[~azure.mgmt.hanaonazure.models.HanaInstance]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.hanaonazure.models.ErrorResponseException>`", "id": "f38803:c0:m1"}
{"signature": "def enable_monitoring(<EOL>self, resource_group_name, hana_instance_name, monitoring_parameter, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._enable_monitoring_initial(<EOL>resource_group_name=resource_group_name,<EOL>hana_instance_name=hana_instance_name,<EOL>monitoring_parameter=monitoring_parameter,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "The operation to add a monitor to an SAP HANA instance.\n\n        :param resource_group_name: Name of the resource group.\n        :type resource_group_name: str\n        :param hana_instance_name: Name of the SAP HANA on Azure instance.\n        :type hana_instance_name: str\n        :param monitoring_parameter: Request body that only contains\n         monitoring attributes\n        :type monitoring_parameter:\n         ~azure.mgmt.hanaonazure.models.MonitoringDetails\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38803:c0:m8"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.HanaInstancePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.HanaInstancePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of SAP HANA instances in the specified subscription and the\n        resource group.\n\n        Gets a list of SAP HANA instances in the specified subscription and the\n        resource group. The operations returns various properties of each SAP\n        HANA on Azure instance.\n\n        :param resource_group_name: Name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of HanaInstance\n        :rtype:\n         ~azure.mgmt.hanaonazure.models.HanaInstancePaged[~azure.mgmt.hanaonazure.models.HanaInstance]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.hanaonazure.models.ErrorResponseException>`", "id": "f38803:c0:m2"}
{"signature": "def get(<EOL>self, operation_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", operation_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>header_dict = {}<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>header_dict = {<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:int>',<EOL>}<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>client_raw_response.add_headers(header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the status of the pending Microsoft.Subscription API operations.\n\n        :param operation_id: The operation ID, which can be found from the\n         Location field in the generate recommendation response header.\n        :type operation_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SubscriptionCreationResult or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.subscription.models.SubscriptionCreationResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f38833:c0:m1"}
{"signature": "def get_details(<EOL>self, operation_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_details.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", operation_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>header_dict = {}<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>header_dict = {<EOL>'<STR_LIT>': '<STR_LIT:int>',<EOL>}<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>client_raw_response.add_headers(header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets details of a specific long running operation.\n\n        :param operation_id: Operation id.\n        :type operation_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Operation or ClientRawResponse if raw=true\n        :rtype: ~azure.cognitiveservices.knowledge.qnamaker.models.Operation\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.knowledge.qnamaker.models.ErrorResponseException>`", "id": "f38900:c0:m1"}
{"signature": "def list_all(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all knowledgebases for a user.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: KnowledgebasesDTO or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.cognitiveservices.knowledge.qnamaker.models.KnowledgebasesDTO\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.knowledge.qnamaker.models.ErrorResponseException>`", "id": "f38901:c0:m1"}
{"signature": "def replace(<EOL>self, kb_id, qn_alist, custom_headers=None, raw=False, **operation_config):", "body": "replace_kb = models.ReplaceKbDTO(qn_alist=qn_alist)<EOL>url = self.replace.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", kb_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(replace_kb, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Replace knowledgebase contents.\n\n        :param kb_id: Knowledgebase id.\n        :type kb_id: str\n        :param qn_alist: List of Q-A (QnADTO) to be added to the\n         knowledgebase. Q-A Ids are assigned by the service and should be\n         omitted.\n        :type qn_alist:\n         list[~azure.cognitiveservices.knowledge.qnamaker.models.QnADTO]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.knowledge.qnamaker.models.ErrorResponseException>`", "id": "f38901:c0:m5"}
{"signature": "def refresh_keys(<EOL>self, key_type, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.refresh_keys.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", key_type, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.patch(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Re-generates an endpoint key.\n\n        :param key_type: Type of Key\n        :type key_type: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: EndpointKeysDTO or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.cognitiveservices.knowledge.qnamaker.models.EndpointKeysDTO or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.knowledge.qnamaker.models.ErrorResponseException>`", "id": "f38903:c0:m2"}
{"signature": "def list(<EOL>self, start=None, top=<NUM_LIT:1000>, return_recognition_model=False, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if start is not None:<EOL><INDENT>query_parameters['<STR_LIT:start>'] = self._serialize.query(\"<STR_LIT:start>\", start, '<STR_LIT:str>', max_length=<NUM_LIT:64>)<EOL><DEDENT>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>', maximum=<NUM_LIT:1000>, minimum=<NUM_LIT:1>)<EOL><DEDENT>if return_recognition_model is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", return_recognition_model, '<STR_LIT:bool>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.APIErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List all existing large person groups\u2019 largePersonGroupId, name,\n        userData and recognitionModel.<br />\n        * Large person groups are stored in alphabetical order of\n        largePersonGroupId.\n        * \"start\" parameter (string, optional) is a user-provided\n        largePersonGroupId value that returned entries have larger ids by\n        string comparison. \"start\" set to empty to indicate return from the\n        first item.\n        * \"top\" parameter (int, optional) specifies the number of entries to\n        return. A maximal of 1000 entries can be returned in one call. To fetch\n        more, you can specify \"start\" with the last returned entry\u2019s Id of the\n        current call.\n        <br />\n        For example, total 5 large person groups: \"group1\", ..., \"group5\".\n        <br /> \"start=&top=\" will return all 5 groups.\n        <br /> \"start=&top=2\" will return \"group1\", \"group2\".\n        <br /> \"start=group2&top=3\" will return \"group3\", \"group4\", \"group5\".\n        .\n\n        :param start: List large person groups from the least\n         largePersonGroupId greater than the \"start\".\n        :type start: str\n        :param top: The number of large person groups to list.\n        :type top: int\n        :param return_recognition_model: A value indicating whether the\n         operation should return 'recognitionModel' in response.\n        :type return_recognition_model: bool\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype:\n         list[~azure.cognitiveservices.vision.face.models.LargePersonGroup] or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`APIErrorException<azure.cognitiveservices.vision.face.models.APIErrorException>`", "id": "f38999:c0:m6"}
{"signature": "def get(<EOL>self, large_person_group_id, return_recognition_model=False, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", large_person_group_id, '<STR_LIT:str>', max_length=<NUM_LIT:64>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if return_recognition_model is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", return_recognition_model, '<STR_LIT:bool>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.APIErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieve the information of a large person group, including its name,\n        userData and recognitionModel. This API returns large person group\n        information only, use [LargePersonGroup Person -\n        List](/docs/services/563879b61984550e40cbbe8d/operations/599adda06ac60f11b48b5aa1)\n        instead to retrieve person information under the large person group.\n        .\n\n        :param large_person_group_id: Id referencing a particular large person\n         group.\n        :type large_person_group_id: str\n        :param return_recognition_model: A value indicating whether the\n         operation should return 'recognitionModel' in response.\n        :type return_recognition_model: bool\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: LargePersonGroup or ClientRawResponse if raw=true\n        :rtype: ~azure.cognitiveservices.vision.face.models.LargePersonGroup\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`APIErrorException<azure.cognitiveservices.vision.face.models.APIErrorException>`", "id": "f38999:c0:m3"}
{"signature": "def add_face_from_stream(<EOL>self, large_face_list_id, image, user_data=None, target_face=None, custom_headers=None, raw=False, callback=None, **operation_config):", "body": "<EOL>url = self.add_face_from_stream.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", large_face_list_id, '<STR_LIT:str>', max_length=<NUM_LIT:64>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if user_data is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", user_data, '<STR_LIT:str>', max_length=<NUM_LIT>)<EOL><DEDENT>if target_face is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", target_face, '<STR_LIT>', div='<STR_LIT:U+002C>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._client.stream_upload(image, callback)<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.APIErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Add a face to a large face list. The input face is specified as an\n        image with a targetFace rectangle. It returns a persistedFaceId\n        representing the added face, and persistedFaceId will not expire.\n\n        :param large_face_list_id: Id referencing a particular large face\n         list.\n        :type large_face_list_id: str\n        :param image: An image stream.\n        :type image: Generator\n        :param user_data: User-specified data about the face for any purpose.\n         The maximum length is 1KB.\n        :type user_data: str\n        :param target_face: A face rectangle to specify the target face to be\n         added to a person in the format of \"targetFace=left,top,width,height\".\n         E.g. \"targetFace=10,10,100,100\". If there is more than one face in the\n         image, targetFace is required to specify which face to add. No\n         targetFace means there is only one face detected in the entire image.\n        :type target_face: list[int]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param callback: When specified, will be called with each chunk of\n         data that is streamed. The callback should take two arguments, the\n         bytes of the current chunk of data and the response object. If the\n         data is uploading, response will be None.\n        :type callback: Callable[Bytes, response=None]\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PersistedFace or ClientRawResponse if raw=true\n        :rtype: ~azure.cognitiveservices.vision.face.models.PersistedFace or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`APIErrorException<azure.cognitiveservices.vision.face.models.APIErrorException>`", "id": "f39000:c0:m13"}
{"signature": "def add_face_from_url(<EOL>self, large_face_list_id, url, user_data=None, target_face=None, custom_headers=None, raw=False, **operation_config):", "body": "image_url = models.ImageUrl(url=url)<EOL>url = self.add_face_from_url.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", large_face_list_id, '<STR_LIT:str>', max_length=<NUM_LIT:64>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if user_data is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", user_data, '<STR_LIT:str>', max_length=<NUM_LIT>)<EOL><DEDENT>if target_face is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", target_face, '<STR_LIT>', div='<STR_LIT:U+002C>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(image_url, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.APIErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Add a face to a large face list. The input face is specified as an\n        image with a targetFace rectangle. It returns a persistedFaceId\n        representing the added face, and persistedFaceId will not expire.\n\n        :param large_face_list_id: Id referencing a particular large face\n         list.\n        :type large_face_list_id: str\n        :param url: Publicly reachable URL of an image\n        :type url: str\n        :param user_data: User-specified data about the face for any purpose.\n         The maximum length is 1KB.\n        :type user_data: str\n        :param target_face: A face rectangle to specify the target face to be\n         added to a person in the format of \"targetFace=left,top,width,height\".\n         E.g. \"targetFace=10,10,100,100\". If there is more than one face in the\n         image, targetFace is required to specify which face to add. No\n         targetFace means there is only one face detected in the entire image.\n        :type target_face: list[int]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PersistedFace or ClientRawResponse if raw=true\n        :rtype: ~azure.cognitiveservices.vision.face.models.PersistedFace or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`APIErrorException<azure.cognitiveservices.vision.face.models.APIErrorException>`", "id": "f39000:c0:m11"}
{"signature": "def delete(<EOL>self, person_group_id, person_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", person_group_id, '<STR_LIT:str>', max_length=<NUM_LIT:64>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", person_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.APIErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Delete an existing person from a person group. All stored person data,\n        and face features in the person entry will be deleted.\n\n        :param person_group_id: Id referencing a particular person group.\n        :type person_group_id: str\n        :param person_id: Id referencing a particular person.\n        :type person_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`APIErrorException<azure.cognitiveservices.vision.face.models.APIErrorException>`", "id": "f39001:c0:m3"}
{"signature": "def get_face(<EOL>self, person_group_id, person_id, persisted_face_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_face.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", person_group_id, '<STR_LIT:str>', max_length=<NUM_LIT:64>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", person_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", persisted_face_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.APIErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieve information about a persisted face (specified by\n        persistedFaceId, personId and its belonging personGroupId).\n\n        :param person_group_id: Id referencing a particular person group.\n        :type person_group_id: str\n        :param person_id: Id referencing a particular person.\n        :type person_id: str\n        :param persisted_face_id: Id referencing a particular persistedFaceId\n         of an existing face.\n        :type persisted_face_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PersistedFace or ClientRawResponse if raw=true\n        :rtype: ~azure.cognitiveservices.vision.face.models.PersistedFace or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`APIErrorException<azure.cognitiveservices.vision.face.models.APIErrorException>`", "id": "f39001:c0:m7"}
{"signature": "def get(<EOL>self, person_group_id, person_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", person_group_id, '<STR_LIT:str>', max_length=<NUM_LIT:64>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", person_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.APIErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieve a person's information, including registered persisted faces,\n        name and userData.\n\n        :param person_group_id: Id referencing a particular person group.\n        :type person_group_id: str\n        :param person_id: Id referencing a particular person.\n        :type person_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Person or ClientRawResponse if raw=true\n        :rtype: ~azure.cognitiveservices.vision.face.models.Person or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`APIErrorException<azure.cognitiveservices.vision.face.models.APIErrorException>`", "id": "f39001:c0:m4"}
{"signature": "def update(<EOL>self, person_group_id, person_id, name=None, user_data=None, custom_headers=None, raw=False, **operation_config):", "body": "body = models.NameAndUserDataContract(name=name, user_data=user_data)<EOL>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", person_group_id, '<STR_LIT:str>', max_length=<NUM_LIT:64>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", person_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(body, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.APIErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Update name or userData of a person.\n\n        :param person_group_id: Id referencing a particular person group.\n        :type person_group_id: str\n        :param person_id: Id referencing a particular person.\n        :type person_id: str\n        :param name: User defined name, maximum length is 128.\n        :type name: str\n        :param user_data: User specified data. Length should not exceed 16KB.\n        :type user_data: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`APIErrorException<azure.cognitiveservices.vision.face.models.APIErrorException>`", "id": "f39001:c0:m5"}
{"signature": "def update_face(<EOL>self, person_group_id, person_id, persisted_face_id, user_data=None, custom_headers=None, raw=False, **operation_config):", "body": "body = models.UpdateFaceRequest(user_data=user_data)<EOL>url = self.update_face.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", person_group_id, '<STR_LIT:str>', max_length=<NUM_LIT:64>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", person_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", persisted_face_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(body, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.APIErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Update a person persisted face's userData field.\n\n        :param person_group_id: Id referencing a particular person group.\n        :type person_group_id: str\n        :param person_id: Id referencing a particular person.\n        :type person_id: str\n        :param persisted_face_id: Id referencing a particular persistedFaceId\n         of an existing face.\n        :type persisted_face_id: str\n        :param user_data: User-provided data attached to the face. The size\n         limit is 1KB.\n        :type user_data: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`APIErrorException<azure.cognitiveservices.vision.face.models.APIErrorException>`", "id": "f39001:c0:m8"}
{"signature": "def list(<EOL>self, start=None, top=<NUM_LIT:1000>, return_recognition_model=False, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if start is not None:<EOL><INDENT>query_parameters['<STR_LIT:start>'] = self._serialize.query(\"<STR_LIT:start>\", start, '<STR_LIT:str>', max_length=<NUM_LIT:64>)<EOL><DEDENT>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>', maximum=<NUM_LIT:1000>, minimum=<NUM_LIT:1>)<EOL><DEDENT>if return_recognition_model is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", return_recognition_model, '<STR_LIT:bool>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.APIErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List person groups\u2019 personGroupId, name, userData and\n        recognitionModel.<br />\n        * Person groups are stored in alphabetical order of personGroupId.\n        * \"start\" parameter (string, optional) is a user-provided personGroupId\n        value that returned entries have larger ids by string comparison.\n        \"start\" set to empty to indicate return from the first item.\n        * \"top\" parameter (int, optional) specifies the number of entries to\n        return. A maximal of 1000 entries can be returned in one call. To fetch\n        more, you can specify \"start\" with the last returned entry\u2019s Id of the\n        current call.\n        <br />\n        For example, total 5 person groups: \"group1\", ..., \"group5\".\n        <br /> \"start=&top=\" will return all 5 groups.\n        <br /> \"start=&top=2\" will return \"group1\", \"group2\".\n        <br /> \"start=group2&top=3\" will return \"group3\", \"group4\", \"group5\".\n        .\n\n        :param start: List person groups from the least personGroupId greater\n         than the \"start\".\n        :type start: str\n        :param top: The number of person groups to list.\n        :type top: int\n        :param return_recognition_model: A value indicating whether the\n         operation should return 'recognitionModel' in response.\n        :type return_recognition_model: bool\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype: list[~azure.cognitiveservices.vision.face.models.PersonGroup]\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`APIErrorException<azure.cognitiveservices.vision.face.models.APIErrorException>`", "id": "f39002:c0:m6"}
{"signature": "def update(<EOL>self, person_group_id, name=None, user_data=None, custom_headers=None, raw=False, **operation_config):", "body": "body = models.NameAndUserDataContract(name=name, user_data=user_data)<EOL>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", person_group_id, '<STR_LIT:str>', max_length=<NUM_LIT:64>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(body, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.APIErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Update an existing person group's display name and userData. The\n        properties which does not appear in request body will not be updated.\n\n        :param person_group_id: Id referencing a particular person group.\n        :type person_group_id: str\n        :param name: User defined name, maximum length is 128.\n        :type name: str\n        :param user_data: User specified data. Length should not exceed 16KB.\n        :type user_data: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`APIErrorException<azure.cognitiveservices.vision.face.models.APIErrorException>`", "id": "f39002:c0:m4"}
{"signature": "def get_training_status(<EOL>self, person_group_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_training_status.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", person_group_id, '<STR_LIT:str>', max_length=<NUM_LIT:64>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.APIErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieve the training status of a person group (completed or ongoing).\n\n        :param person_group_id: Id referencing a particular person group.\n        :type person_group_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: TrainingStatus or ClientRawResponse if raw=true\n        :rtype: ~azure.cognitiveservices.vision.face.models.TrainingStatus or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`APIErrorException<azure.cognitiveservices.vision.face.models.APIErrorException>`", "id": "f39002:c0:m5"}
{"signature": "def create(<EOL>self, person_group_id, name=None, user_data=None, recognition_model=\"<STR_LIT>\", custom_headers=None, raw=False, **operation_config):", "body": "body = models.MetaDataContract(name=name, user_data=user_data, recognition_model=recognition_model)<EOL>url = self.create.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", person_group_id, '<STR_LIT:str>', max_length=<NUM_LIT:64>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(body, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.APIErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Create a new person group with specified personGroupId, name,\n        user-provided userData and recognitionModel.\n        <br /> A person group is the container of the uploaded person data,\n        including face images and face recognition features.\n        <br /> After creation, use [PersonGroup Person -\n        Create](/docs/services/563879b61984550e40cbbe8d/operations/563879b61984550f3039523c)\n        to add persons into the group, and then call [PersonGroup -\n        Train](/docs/services/563879b61984550e40cbbe8d/operations/563879b61984550f30395249)\n        to get this group ready for [Face -\n        Identify](/docs/services/563879b61984550e40cbbe8d/operations/563879b61984550f30395239).\n        <br /> The person's face, image, and userData will be stored on server\n        until [PersonGroup Person -\n        Delete](/docs/services/563879b61984550e40cbbe8d/operations/563879b61984550f3039523d)\n        or [PersonGroup -\n        Delete](/docs/services/563879b61984550e40cbbe8d/operations/563879b61984550f30395245)\n        is called.\n        <br />\n        * Free-tier subscription quota: 1,000 person groups. Each holds up to\n        1,000 persons.\n        * S0-tier subscription quota: 1,000,000 person groups. Each holds up to\n        10,000 persons.\n        * to handle larger scale face identification problem, please consider\n        using\n        [LargePersonGroup](/docs/services/563879b61984550e40cbbe8d/operations/599acdee6ac60f11b48b5a9d).\n        <br />\n        'recognitionModel' should be specified to associate with this person\n        group. The default value for 'recognitionModel' is 'recognition_01', if\n        the latest model needed, please explicitly specify the model you need\n        in this parameter. New faces that are added to an existing person group\n        will use the recognition model that's already associated with the\n        collection. Existing face features in a person group can't be updated\n        to features extracted by another version of recognition model.\n        .\n\n        :param person_group_id: Id referencing a particular person group.\n        :type person_group_id: str\n        :param name: User defined name, maximum length is 128.\n        :type name: str\n        :param user_data: User specified data. Length should not exceed 16KB.\n        :type user_data: str\n        :param recognition_model: Possible values include: 'recognition_01',\n         'recognition_02'\n        :type recognition_model: str or\n         ~azure.cognitiveservices.vision.face.models.RecognitionModel\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`APIErrorException<azure.cognitiveservices.vision.face.models.APIErrorException>`", "id": "f39002:c0:m1"}
{"signature": "def delete(<EOL>self, person_group_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", person_group_id, '<STR_LIT:str>', max_length=<NUM_LIT:64>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.APIErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Delete an existing person group. Persisted face features of all people\n        in the person group will also be deleted.\n\n        :param person_group_id: Id referencing a particular person group.\n        :type person_group_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`APIErrorException<azure.cognitiveservices.vision.face.models.APIErrorException>`", "id": "f39002:c0:m2"}
{"signature": "def train(<EOL>self, person_group_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.train.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", person_group_id, '<STR_LIT:str>', max_length=<NUM_LIT:64>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.APIErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Queue a person group training task, the training task may not be\n        started immediately.\n\n        :param person_group_id: Id referencing a particular person group.\n        :type person_group_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`APIErrorException<azure.cognitiveservices.vision.face.models.APIErrorException>`", "id": "f39002:c0:m7"}
{"signature": "def get(<EOL>self, person_group_id, return_recognition_model=False, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", person_group_id, '<STR_LIT:str>', max_length=<NUM_LIT:64>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if return_recognition_model is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", return_recognition_model, '<STR_LIT:bool>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.APIErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieve person group name, userData and recognitionModel. To get\n        person information under this personGroup, use [PersonGroup Person -\n        List](/docs/services/563879b61984550e40cbbe8d/operations/563879b61984550f30395241).\n\n        :param person_group_id: Id referencing a particular person group.\n        :type person_group_id: str\n        :param return_recognition_model: A value indicating whether the\n         operation should return 'recognitionModel' in response.\n        :type return_recognition_model: bool\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PersonGroup or ClientRawResponse if raw=true\n        :rtype: ~azure.cognitiveservices.vision.face.models.PersonGroup or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`APIErrorException<azure.cognitiveservices.vision.face.models.APIErrorException>`", "id": "f39002:c0:m3"}
{"signature": "def verify_face_to_person(<EOL>self, face_id, person_id, person_group_id=None, large_person_group_id=None, custom_headers=None, raw=False, **operation_config):", "body": "body = models.VerifyFaceToPersonRequest(face_id=face_id, person_group_id=person_group_id, large_person_group_id=large_person_group_id, person_id=person_id)<EOL>url = self.verify_face_to_person.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(body, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.APIErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Verify whether two faces belong to a same person. Compares a face Id\n        with a Person Id.\n\n        :param face_id: FaceId of the face, comes from Face - Detect\n        :type face_id: str\n        :param person_id: Specify a certain person in a person group or a\n         large person group. personId is created in PersonGroup Person - Create\n         or LargePersonGroup Person - Create.\n        :type person_id: str\n        :param person_group_id: Using existing personGroupId and personId for\n         fast loading a specified person. personGroupId is created in\n         PersonGroup - Create. Parameter personGroupId and largePersonGroupId\n         should not be provided at the same time.\n        :type person_group_id: str\n        :param large_person_group_id: Using existing largePersonGroupId and\n         personId for fast loading a specified person. largePersonGroupId is\n         created in LargePersonGroup - Create. Parameter personGroupId and\n         largePersonGroupId should not be provided at the same time.\n        :type large_person_group_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VerifyResult or ClientRawResponse if raw=true\n        :rtype: ~azure.cognitiveservices.vision.face.models.VerifyResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`APIErrorException<azure.cognitiveservices.vision.face.models.APIErrorException>`", "id": "f39003:c0:m6"}
{"signature": "def detect_with_url(<EOL>self, url, return_face_id=True, return_face_landmarks=False, return_face_attributes=None, recognition_model=\"<STR_LIT>\", return_recognition_model=False, custom_headers=None, raw=False, **operation_config):", "body": "image_url = models.ImageUrl(url=url)<EOL>url = self.detect_with_url.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if return_face_id is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", return_face_id, '<STR_LIT:bool>')<EOL><DEDENT>if return_face_landmarks is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", return_face_landmarks, '<STR_LIT:bool>')<EOL><DEDENT>if return_face_attributes is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", return_face_attributes, '<STR_LIT>', div='<STR_LIT:U+002C>')<EOL><DEDENT>if recognition_model is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", recognition_model, '<STR_LIT:str>')<EOL><DEDENT>if return_recognition_model is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", return_recognition_model, '<STR_LIT:bool>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(image_url, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.APIErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Detect human faces in an image, return face rectangles, and optionally\n        with faceIds, landmarks, and attributes.<br />\n        * Optional parameters including faceId, landmarks, and attributes.\n        Attributes include age, gender, headPose, smile, facialHair, glasses,\n        emotion, hair, makeup, occlusion, accessories, blur, exposure and\n        noise.\n        * The extracted face feature, instead of the actual image, will be\n        stored on server. The faceId is an identifier of the face feature and\n        will be used in [Face -\n        Identify](/docs/services/563879b61984550e40cbbe8d/operations/563879b61984550f30395239),\n        [Face -\n        Verify](/docs/services/563879b61984550e40cbbe8d/operations/563879b61984550f3039523a),\n        and [Face - Find\n        Similar](/docs/services/563879b61984550e40cbbe8d/operations/563879b61984550f30395237).\n        It will expire 24 hours after the detection call.\n        * Higher face image quality means better detection and recognition\n        precision. Please consider high-quality faces: frontal, clear, and face\n        size is 200x200 pixels (100 pixels between eyes) or bigger.\n        * JPEG, PNG, GIF (the first frame), and BMP format are supported. The\n        allowed image file size is from 1KB to 6MB.\n        * Faces are detectable when its size is 36x36 to 4096x4096 pixels. If\n        need to detect very small but clear faces, please try to enlarge the\n        input image.\n        * Up to 64 faces can be returned for an image. Faces are ranked by face\n        rectangle size from large to small.\n        * Face detector prefer frontal and near-frontal faces. There are cases\n        that faces may not be detected, e.g. exceptionally large face angles\n        (head-pose) or being occluded, or wrong image orientation.\n        * Attributes (age, gender, headPose, smile, facialHair, glasses,\n        emotion, hair, makeup, occlusion, accessories, blur, exposure and\n        noise) may not be perfectly accurate. HeadPose's pitch value is a\n        reserved field and will always return 0.\n        * Different 'recognitionModel' values are provided. If follow-up\n        operations like Verify, Identify, Find Similar are needed, please\n        specify the recognition model with 'recognitionModel' parameter. The\n        default value for 'recognitionModel' is 'recognition_01', if latest\n        model needed, please explicitly specify the model you need in this\n        parameter. Once specified, the detected faceIds will be associated with\n        the specified recognition model. More details, please refer to [How to\n        specify a recognition\n        model](https://docs.microsoft.com/en-us/azure/cognitive-services/face/face-api-how-to-topics/specify-recognition-model)\n        .\n\n        :param url: Publicly reachable URL of an image\n        :type url: str\n        :param return_face_id: A value indicating whether the operation should\n         return faceIds of detected faces.\n        :type return_face_id: bool\n        :param return_face_landmarks: A value indicating whether the operation\n         should return landmarks of the detected faces.\n        :type return_face_landmarks: bool\n        :param return_face_attributes: Analyze and return the one or more\n         specified face attributes in the comma-separated string like\n         \"returnFaceAttributes=age,gender\". Supported face attributes include\n         age, gender, headPose, smile, facialHair, glasses and emotion. Note\n         that each face attribute analysis has additional computational and\n         time cost.\n        :type return_face_attributes: list[str or\n         ~azure.cognitiveservices.vision.face.models.FaceAttributeType]\n        :param recognition_model: Name of recognition model. Recognition model\n         is used when the face features are extracted and associated with\n         detected faceIds, (Large)FaceList or (Large)PersonGroup. A recognition\n         model name can be provided when performing Face - Detect or\n         (Large)FaceList - Create or (Large)PersonGroup - Create. The default\n         value is 'recognition_01', if latest model needed, please explicitly\n         specify the model you need. Possible values include: 'recognition_01',\n         'recognition_02'\n        :type recognition_model: str or\n         ~azure.cognitiveservices.vision.face.models.RecognitionModel\n        :param return_recognition_model: A value indicating whether the\n         operation should return 'recognitionModel' in response.\n        :type return_recognition_model: bool\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype: list[~azure.cognitiveservices.vision.face.models.DetectedFace]\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`APIErrorException<azure.cognitiveservices.vision.face.models.APIErrorException>`", "id": "f39003:c0:m5"}
{"signature": "def take(<EOL>self, type, object_id, apply_scope, user_data=None, custom_headers=None, raw=False, **operation_config):", "body": "body = models.TakeSnapshotRequest(type=type, object_id=object_id, apply_scope=apply_scope, user_data=user_data)<EOL>url = self.take.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(body, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.APIErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>client_raw_response.add_headers({<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>})<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Submit an operation to take a snapshot of face list, large face list,\n        person group or large person group, with user-specified snapshot type,\n        source object id, apply scope and an optional user data.<br />\n        The snapshot interfaces are for users to backup and restore their face\n        data from one face subscription to another, inside same region or\n        across regions. The workflow contains two phases, user first calls\n        Snapshot - Take to create a copy of the source object and store it as a\n        snapshot, then calls Snapshot - Apply to paste the snapshot to target\n        subscription. The snapshots are stored in a centralized location (per\n        Azure instance), so that they can be applied cross accounts and\n        regions.<br />\n        Taking snapshot is an asynchronous operation. An operation id can be\n        obtained from the \"Operation-Location\" field in response header, to be\n        used in OperationStatus - Get for tracking the progress of creating the\n        snapshot. The snapshot id will be included in the \"resourceLocation\"\n        field in OperationStatus - Get response when the operation status is\n        \"succeeded\".<br />\n        Snapshot taking time depends on the number of person and face entries\n        in the source object. It could be in seconds, or up to several hours\n        for 1,000,000 persons with multiple faces.<br />\n        Snapshots will be automatically expired and cleaned in 48 hours after\n        it is created by Snapshot - Take. User can delete the snapshot using\n        Snapshot - Delete by themselves any time before expiration.<br />\n        Taking snapshot for a certain object will not block any other\n        operations against the object. All read-only operations (Get/List and\n        Identify/FindSimilar/Verify) can be conducted as usual. For all\n        writable operations, including Add/Update/Delete the source object or\n        its persons/faces and Train, they are not blocked but not recommended\n        because writable updates may not be reflected on the snapshot during\n        its taking. After snapshot taking is completed, all readable and\n        writable operations can work as normal. Snapshot will also include the\n        training results of the source object, which means target subscription\n        the snapshot applied to does not need re-train the target object before\n        calling Identify/FindSimilar.<br />\n        * Free-tier subscription quota: 100 take operations per month.\n        * S0-tier subscription quota: 100 take operations per day.\n\n        :param type: User specified type for the source object to take\n         snapshot from. Currently FaceList, PersonGroup, LargeFaceList and\n         LargePersonGroup are supported. Possible values include: 'FaceList',\n         'LargeFaceList', 'LargePersonGroup', 'PersonGroup'\n        :type type: str or\n         ~azure.cognitiveservices.vision.face.models.SnapshotObjectType\n        :param object_id: User specified source object id to take snapshot\n         from.\n        :type object_id: str\n        :param apply_scope: User specified array of target Face subscription\n         ids for the snapshot. For each snapshot, only subscriptions included\n         in the applyScope of Snapshot - Take can apply it.\n        :type apply_scope: list[str]\n        :param user_data: User specified data about the snapshot for any\n         purpose. Length should not exceed 16KB.\n        :type user_data: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`APIErrorException<azure.cognitiveservices.vision.face.models.APIErrorException>`", "id": "f39004:c0:m1"}
{"signature": "def delete(<EOL>self, snapshot_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", snapshot_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.APIErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Delete an existing snapshot according to the snapshotId. All object\n        data and information in the snapshot will also be deleted. Only the\n        source subscription who took the snapshot can delete the snapshot. If\n        the user does not delete a snapshot with this API, the snapshot will\n        still be automatically deleted in 48 hours after creation.\n\n        :param snapshot_id: Id referencing a particular snapshot.\n        :type snapshot_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`APIErrorException<azure.cognitiveservices.vision.face.models.APIErrorException>`", "id": "f39004:c0:m5"}
{"signature": "def update(<EOL>self, large_person_group_id, person_id, name=None, user_data=None, custom_headers=None, raw=False, **operation_config):", "body": "body = models.NameAndUserDataContract(name=name, user_data=user_data)<EOL>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", large_person_group_id, '<STR_LIT:str>', max_length=<NUM_LIT:64>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", person_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(body, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.APIErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Update name or userData of a person.\n\n        :param large_person_group_id: Id referencing a particular large person\n         group.\n        :type large_person_group_id: str\n        :param person_id: Id referencing a particular person.\n        :type person_id: str\n        :param name: User defined name, maximum length is 128.\n        :type name: str\n        :param user_data: User specified data. Length should not exceed 16KB.\n        :type user_data: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`APIErrorException<azure.cognitiveservices.vision.face.models.APIErrorException>`", "id": "f39006:c0:m5"}
{"signature": "def list(<EOL>self, large_person_group_id, start=None, top=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", large_person_group_id, '<STR_LIT:str>', max_length=<NUM_LIT:64>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if start is not None:<EOL><INDENT>query_parameters['<STR_LIT:start>'] = self._serialize.query(\"<STR_LIT:start>\", start, '<STR_LIT:str>')<EOL><DEDENT>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>', maximum=<NUM_LIT:1000>, minimum=<NUM_LIT:1>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.APIErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List all persons in a large person group, and retrieve person\n        information (including personId, name, userData and persistedFaceIds of\n        registered faces of the person).\n\n        :param large_person_group_id: Id referencing a particular large person\n         group.\n        :type large_person_group_id: str\n        :param start: Starting person id to return (used to list a range of\n         persons).\n        :type start: str\n        :param top: Number of persons to return starting with the person id\n         indicated by the 'start' parameter.\n        :type top: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype: list[~azure.cognitiveservices.vision.face.models.Person] or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`APIErrorException<azure.cognitiveservices.vision.face.models.APIErrorException>`", "id": "f39006:c0:m2"}
{"signature": "def create(<EOL>self, large_person_group_id, name=None, user_data=None, custom_headers=None, raw=False, **operation_config):", "body": "body = models.NameAndUserDataContract(name=name, user_data=user_data)<EOL>url = self.create.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", large_person_group_id, '<STR_LIT:str>', max_length=<NUM_LIT:64>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(body, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.APIErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Create a new person in a specified large person group.\n\n        :param large_person_group_id: Id referencing a particular large person\n         group.\n        :type large_person_group_id: str\n        :param name: User defined name, maximum length is 128.\n        :type name: str\n        :param user_data: User specified data. Length should not exceed 16KB.\n        :type user_data: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Person or ClientRawResponse if raw=true\n        :rtype: ~azure.cognitiveservices.vision.face.models.Person or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`APIErrorException<azure.cognitiveservices.vision.face.models.APIErrorException>`", "id": "f39006:c0:m1"}
{"signature": "def delete(<EOL>self, large_person_group_id, person_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", large_person_group_id, '<STR_LIT:str>', max_length=<NUM_LIT:64>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", person_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.APIErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Delete an existing person from a large person group. All stored person\n        data, and face features in the person entry will be deleted.\n\n        :param large_person_group_id: Id referencing a particular large person\n         group.\n        :type large_person_group_id: str\n        :param person_id: Id referencing a particular person.\n        :type person_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`APIErrorException<azure.cognitiveservices.vision.face.models.APIErrorException>`", "id": "f39006:c0:m3"}
{"signature": "def add_face_from_url(<EOL>self, large_person_group_id, person_id, url, user_data=None, target_face=None, custom_headers=None, raw=False, **operation_config):", "body": "image_url = models.ImageUrl(url=url)<EOL>url = self.add_face_from_url.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", large_person_group_id, '<STR_LIT:str>', max_length=<NUM_LIT:64>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", person_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if user_data is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", user_data, '<STR_LIT:str>', max_length=<NUM_LIT>)<EOL><DEDENT>if target_face is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", target_face, '<STR_LIT>', div='<STR_LIT:U+002C>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(image_url, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.APIErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Add a representative face to a person for identification. The input\n        face is specified as an image with a targetFace rectangle.\n\n        :param large_person_group_id: Id referencing a particular large person\n         group.\n        :type large_person_group_id: str\n        :param person_id: Id referencing a particular person.\n        :type person_id: str\n        :param url: Publicly reachable URL of an image\n        :type url: str\n        :param user_data: User-specified data about the face for any purpose.\n         The maximum length is 1KB.\n        :type user_data: str\n        :param target_face: A face rectangle to specify the target face to be\n         added to a person in the format of \"targetFace=left,top,width,height\".\n         E.g. \"targetFace=10,10,100,100\". If there is more than one face in the\n         image, targetFace is required to specify which face to add. No\n         targetFace means there is only one face detected in the entire image.\n        :type target_face: list[int]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PersistedFace or ClientRawResponse if raw=true\n        :rtype: ~azure.cognitiveservices.vision.face.models.PersistedFace or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`APIErrorException<azure.cognitiveservices.vision.face.models.APIErrorException>`", "id": "f39006:c0:m9"}
{"signature": "def add_face_from_stream(<EOL>self, face_list_id, image, user_data=None, target_face=None, custom_headers=None, raw=False, callback=None, **operation_config):", "body": "<EOL>url = self.add_face_from_stream.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", face_list_id, '<STR_LIT:str>', max_length=<NUM_LIT:64>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if user_data is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", user_data, '<STR_LIT:str>', max_length=<NUM_LIT>)<EOL><DEDENT>if target_face is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", target_face, '<STR_LIT>', div='<STR_LIT:U+002C>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._client.stream_upload(image, callback)<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.APIErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Add a face to a face list. The input face is specified as an image with\n        a targetFace rectangle. It returns a persistedFaceId representing the\n        added face, and persistedFaceId will not expire.\n\n        :param face_list_id: Id referencing a particular face list.\n        :type face_list_id: str\n        :param image: An image stream.\n        :type image: Generator\n        :param user_data: User-specified data about the face for any purpose.\n         The maximum length is 1KB.\n        :type user_data: str\n        :param target_face: A face rectangle to specify the target face to be\n         added to a person in the format of \"targetFace=left,top,width,height\".\n         E.g. \"targetFace=10,10,100,100\". If there is more than one face in the\n         image, targetFace is required to specify which face to add. No\n         targetFace means there is only one face detected in the entire image.\n        :type target_face: list[int]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param callback: When specified, will be called with each chunk of\n         data that is streamed. The callback should take two arguments, the\n         bytes of the current chunk of data and the response object. If the\n         data is uploading, response will be None.\n        :type callback: Callable[Bytes, response=None]\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PersistedFace or ClientRawResponse if raw=true\n        :rtype: ~azure.cognitiveservices.vision.face.models.PersistedFace or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`APIErrorException<azure.cognitiveservices.vision.face.models.APIErrorException>`", "id": "f39007:c0:m8"}
{"signature": "def delete(<EOL>self, face_list_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", face_list_id, '<STR_LIT:str>', max_length=<NUM_LIT:64>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.APIErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Delete an existing face list according to faceListId. Persisted face\n        images in the face list will also be deleted.\n\n        :param face_list_id: Id referencing a particular face list.\n        :type face_list_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`APIErrorException<azure.cognitiveservices.vision.face.models.APIErrorException>`", "id": "f39007:c0:m4"}
{"signature": "def add_face_from_url(<EOL>self, face_list_id, url, user_data=None, target_face=None, custom_headers=None, raw=False, **operation_config):", "body": "image_url = models.ImageUrl(url=url)<EOL>url = self.add_face_from_url.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", face_list_id, '<STR_LIT:str>', max_length=<NUM_LIT:64>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if user_data is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", user_data, '<STR_LIT:str>', max_length=<NUM_LIT>)<EOL><DEDENT>if target_face is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", target_face, '<STR_LIT>', div='<STR_LIT:U+002C>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(image_url, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.APIErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Add a face to a face list. The input face is specified as an image with\n        a targetFace rectangle. It returns a persistedFaceId representing the\n        added face, and persistedFaceId will not expire.\n\n        :param face_list_id: Id referencing a particular face list.\n        :type face_list_id: str\n        :param url: Publicly reachable URL of an image\n        :type url: str\n        :param user_data: User-specified data about the face for any purpose.\n         The maximum length is 1KB.\n        :type user_data: str\n        :param target_face: A face rectangle to specify the target face to be\n         added to a person in the format of \"targetFace=left,top,width,height\".\n         E.g. \"targetFace=10,10,100,100\". If there is more than one face in the\n         image, targetFace is required to specify which face to add. No\n         targetFace means there is only one face detected in the entire image.\n        :type target_face: list[int]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PersistedFace or ClientRawResponse if raw=true\n        :rtype: ~azure.cognitiveservices.vision.face.models.PersistedFace or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`APIErrorException<azure.cognitiveservices.vision.face.models.APIErrorException>`", "id": "f39007:c0:m7"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, cluster_name, database_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>cluster_name=cluster_name,<EOL>database_name=database_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a database.\n\n        :param resource_group_name: The name of the resource group containing\n         the Kusto cluster.\n        :type resource_group_name: str\n        :param cluster_name: The name of the Kusto cluster.\n        :type cluster_name: str\n        :param database_name: The name of the database in the Kusto cluster.\n        :type database_name: str\n        :param parameters: The database parameters supplied to the\n         CreateOrUpdate operation.\n        :type parameters: ~azure.mgmt.kusto.models.Database\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Database or\n         ClientRawResponse<Database> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.kusto.models.Database]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.kusto.models.Database]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39066:c0:m5"}
{"signature": "def list_principals(<EOL>self, resource_group_name, cluster_name, database_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_principals.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", cluster_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", database_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.DatabasePrincipalPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.DatabasePrincipalPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Returns a list of database principals of the given Kusto cluster and\n        database.\n\n        :param resource_group_name: The name of the resource group containing\n         the Kusto cluster.\n        :type resource_group_name: str\n        :param cluster_name: The name of the Kusto cluster.\n        :type cluster_name: str\n        :param database_name: The name of the database in the Kusto cluster.\n        :type database_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of DatabasePrincipal\n        :rtype:\n         ~azure.mgmt.kusto.models.DatabasePrincipalPaged[~azure.mgmt.kusto.models.DatabasePrincipal]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39066:c0:m10"}
{"signature": "def delete(<EOL>self, resource_group_name, cluster_name, database_name, data_connection_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>cluster_name=cluster_name,<EOL>database_name=database_name,<EOL>data_connection_name=data_connection_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the data connection with the given name.\n\n        :param resource_group_name: The name of the resource group containing\n         the Kusto cluster.\n        :type resource_group_name: str\n        :param cluster_name: The name of the Kusto cluster.\n        :type cluster_name: str\n        :param database_name: The name of the database in the Kusto cluster.\n        :type database_name: str\n        :param data_connection_name: The name of the data connection.\n        :type data_connection_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39067:c0:m9"}
{"signature": "def data_connection_validation_method(<EOL>self, resource_group_name, cluster_name, database_name, data_connection_name=None, properties=None, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.DataConnectionValidation(data_connection_name=data_connection_name, properties=properties)<EOL>url = self.data_connection_validation_method.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", cluster_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", database_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Checks that the data connection parameters are valid.\n\n        :param resource_group_name: The name of the resource group containing\n         the Kusto cluster.\n        :type resource_group_name: str\n        :param cluster_name: The name of the Kusto cluster.\n        :type cluster_name: str\n        :param database_name: The name of the database in the Kusto cluster.\n        :type database_name: str\n        :param data_connection_name: The name of the data connection.\n        :type data_connection_name: str\n        :param properties: The data connection properties to validate.\n        :type properties: ~azure.mgmt.kusto.models.DataConnection\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DataConnectionValidationListResult or ClientRawResponse if\n         raw=true\n        :rtype: ~azure.mgmt.kusto.models.DataConnectionValidationListResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39067:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, cluster_name, database_name, data_connection_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", cluster_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", database_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", data_connection_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Returns a data connection.\n\n        :param resource_group_name: The name of the resource group containing\n         the Kusto cluster.\n        :type resource_group_name: str\n        :param cluster_name: The name of the Kusto cluster.\n        :type cluster_name: str\n        :param database_name: The name of the database in the Kusto cluster.\n        :type database_name: str\n        :param data_connection_name: The name of the data connection.\n        :type data_connection_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DataConnection or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.kusto.models.DataConnection or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39067:c0:m3"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ClusterPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ClusterPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all Kusto clusters within a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Cluster\n        :rtype:\n         ~azure.mgmt.kusto.models.ClusterPaged[~azure.mgmt.kusto.models.Cluster]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39068:c0:m13"}
{"signature": "def list_skus(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_skus.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.AzureSkuPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.AzureSkuPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists eligible SKUs for Kusto resource provider.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of AzureSku\n        :rtype:\n         ~azure.mgmt.kusto.models.AzureSkuPaged[~azure.mgmt.kusto.models.AzureSku]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39068:c0:m14"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.JobCollectionDefinitionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.JobCollectionDefinitionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all job collections under specified resource group.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of JobCollectionDefinition\n        :rtype:\n         ~azure.mgmt.scheduler.models.JobCollectionDefinitionPaged[~azure.mgmt.scheduler.models.JobCollectionDefinition]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39169:c0:m2"}
{"signature": "def list_by_subscription(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_subscription.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.JobCollectionDefinitionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.JobCollectionDefinitionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all job collections under specified subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of JobCollectionDefinition\n        :rtype:\n         ~azure.mgmt.scheduler.models.JobCollectionDefinitionPaged[~azure.mgmt.scheduler.models.JobCollectionDefinition]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39169:c0:m1"}
{"signature": "def disable(<EOL>self, resource_group_name, job_collection_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._disable_initial(<EOL>resource_group_name=resource_group_name,<EOL>job_collection_name=job_collection_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Disables all of the jobs in the job collection.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param job_collection_name: The job collection name.\n        :type job_collection_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39169:c0:m11"}
{"signature": "def list(<EOL>self, resource_group_name, job_collection_name, top=None, skip=None, filter=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", job_collection_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>', maximum=<NUM_LIT:100>, minimum=<NUM_LIT:1>)<EOL><DEDENT>if skip is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", skip, '<STR_LIT:int>')<EOL><DEDENT>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.JobDefinitionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.JobDefinitionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all jobs under the specified job collection.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param job_collection_name: The job collection name.\n        :type job_collection_name: str\n        :param top: The number of jobs to request, in the of range of\n         [1..100].\n        :type top: int\n        :param skip: The (0-based) index of the job history list from which to\n         begin requesting entries.\n        :type skip: int\n        :param filter: The filter to apply on the job state.\n        :type filter: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of JobDefinition\n        :rtype:\n         ~azure.mgmt.scheduler.models.JobDefinitionPaged[~azure.mgmt.scheduler.models.JobDefinition]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39170:c0:m6"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, job_collection_name, job_name, properties=None, custom_headers=None, raw=False, **operation_config):", "body": "job = models.JobDefinition(properties=properties)<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", job_collection_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", job_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(job, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, body_content, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Provisions a new job or updates an existing job.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param job_collection_name: The job collection name.\n        :type job_collection_name: str\n        :param job_name: The job name.\n        :type job_name: str\n        :param properties: Gets or sets the job properties.\n        :type properties: ~azure.mgmt.scheduler.models.JobProperties\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: JobDefinition or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.scheduler.models.JobDefinition or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39170:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, job_collection_name, job_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", job_collection_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", job_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes a job.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param job_collection_name: The job collection name.\n        :type job_collection_name: str\n        :param job_name: The job name.\n        :type job_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39170:c0:m4"}
{"signature": "def list(<EOL>self, resource_group_name, workspace_collection_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", workspace_collection_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.WorkspacePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.WorkspacePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves all existing Power BI workspaces in the specified workspace\n        collection.\n\n        :param resource_group_name: Azure resource group\n        :type resource_group_name: str\n        :param workspace_collection_name: Power BI Embedded Workspace\n         Collection name\n        :type workspace_collection_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Workspace\n        :rtype:\n         ~azure.mgmt.powerbiembedded.models.WorkspacePaged[~azure.mgmt.powerbiembedded.models.Workspace]\n        :raises:\n         :class:`ErrorException<azure.mgmt.powerbiembedded.models.ErrorException>`", "id": "f39208:c0:m1"}
{"signature": "def check_name_availability(<EOL>self, location, name=None, type=\"<STR_LIT>\", custom_headers=None, raw=False, **operation_config):", "body": "body = models.CheckNameRequest(name=name, type=type)<EOL>url = self.check_name_availability.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(body, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, body_content, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Verify the specified Power BI Workspace Collection name is valid and\n        not already in use.\n\n        :param location: Azure location\n        :type location: str\n        :param name: Workspace collection name\n        :type name: str\n        :param type: Resource type\n        :type type: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: CheckNameResponse or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.powerbiembedded.models.CheckNameResponse or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorException<azure.mgmt.powerbiembedded.models.ErrorException>`", "id": "f39209:c0:m6"}
{"signature": "def get_access_keys(<EOL>self, resource_group_name, workspace_collection_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_access_keys.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", workspace_collection_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves the primary and secondary access keys for the specified Power\n        BI Workspace Collection.\n\n        :param resource_group_name: Azure resource group\n        :type resource_group_name: str\n        :param workspace_collection_name: Power BI Embedded Workspace\n         Collection name\n        :type workspace_collection_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: WorkspaceCollectionAccessKeys or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.powerbiembedded.models.WorkspaceCollectionAccessKeys or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorException<azure.mgmt.powerbiembedded.models.ErrorException>`", "id": "f39209:c0:m9"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.WorkspaceCollectionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.WorkspaceCollectionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves all existing Power BI workspace collections in the specified\n        resource group.\n\n        :param resource_group_name: Azure resource group\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of WorkspaceCollection\n        :rtype:\n         ~azure.mgmt.powerbiembedded.models.WorkspaceCollectionPaged[~azure.mgmt.powerbiembedded.models.WorkspaceCollection]\n        :raises:\n         :class:`ErrorException<azure.mgmt.powerbiembedded.models.ErrorException>`", "id": "f39209:c0:m7"}
{"signature": "def list_by_subscription(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_subscription.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.WorkspaceCollectionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.WorkspaceCollectionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves all existing Power BI workspace collections in the specified\n        subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of WorkspaceCollection\n        :rtype:\n         ~azure.mgmt.powerbiembedded.models.WorkspaceCollectionPaged[~azure.mgmt.powerbiembedded.models.WorkspaceCollection]\n        :raises:\n         :class:`ErrorException<azure.mgmt.powerbiembedded.models.ErrorException>`", "id": "f39209:c0:m8"}
{"signature": "def update(<EOL>self, resource_group_name, workspace_collection_name, tags=None, custom_headers=None, raw=False, **operation_config):", "body": "body = models.UpdateWorkspaceCollectionRequest(tags=tags)<EOL>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", workspace_collection_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(body, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, body_content, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Update an existing Power BI Workspace Collection with the specified\n        properties.\n\n        :param resource_group_name: Azure resource group\n        :type resource_group_name: str\n        :param workspace_collection_name: Power BI Embedded Workspace\n         Collection name\n        :type workspace_collection_name: str\n        :param tags:\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: WorkspaceCollection or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.powerbiembedded.models.WorkspaceCollection or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorException<azure.mgmt.powerbiembedded.models.ErrorException>`", "id": "f39209:c0:m3"}
{"signature": "def get_catalog(<EOL>self, subscription_id, reserved_resource_type, location=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_catalog.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", reserved_resource_type, '<STR_LIT:str>')<EOL>if location is not None:<EOL><INDENT>query_parameters['<STR_LIT:location>'] = self._serialize.query(\"<STR_LIT:location>\", location, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the regions and skus that are available for RI purchase for the\n        specified Azure subscription.\n\n        :param subscription_id: Id of the subscription\n        :type subscription_id: str\n        :param reserved_resource_type: The type of the resource for which the\n         skus should be provided.\n        :type reserved_resource_type: str\n        :param location: Filters the skus based on the location specified in\n         this parameter. This can be an azure region or global\n        :type location: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype: list[~azure.mgmt.reservations.models.Catalog] or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorException<azure.mgmt.reservations.models.ErrorException>`", "id": "f39270:c1:m1"}
{"signature": "def update(<EOL>self, reservation_order_id, reservation_id, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_initial(<EOL>reservation_order_id=reservation_order_id,<EOL>reservation_id=reservation_id,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a `Reservation`.\n\n        Updates the applied scopes of the `Reservation`.\n\n        :param reservation_order_id: Order Id of the reservation\n        :type reservation_order_id: str\n        :param reservation_id: Id of the Reservation Item\n        :type reservation_id: str\n        :param parameters: Information needed to patch a reservation item\n        :type parameters: ~azure.mgmt.reservations.models.Patch\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ReservationResponse or\n         ClientRawResponse<ReservationResponse> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.reservations.models.ReservationResponse]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.reservations.models.ReservationResponse]]\n        :raises:\n         :class:`ErrorException<azure.mgmt.reservations.models.ErrorException>`", "id": "f39272:c0:m8"}
{"signature": "def list(<EOL>self, reservation_order_id, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", reservation_order_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ReservationResponsePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ReservationResponsePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get `Reservation`s in a given reservation Order.\n\n        List `Reservation`s within a single `ReservationOrder`.\n\n        :param reservation_order_id: Order Id of the reservation\n        :type reservation_order_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ReservationResponse\n        :rtype:\n         ~azure.mgmt.reservations.models.ReservationResponsePaged[~azure.mgmt.reservations.models.ReservationResponse]\n        :raises:\n         :class:`ErrorException<azure.mgmt.reservations.models.ErrorException>`", "id": "f39272:c0:m5"}
{"signature": "@staticmethod<EOL><INDENT>def print_file_server(file_server):<DEDENT>", "body": "print(\"<STR_LIT>\")<EOL>print(file_server.serialize())<EOL>", "docstring": "Output information about file server\n\n        :param models.FileServer file_server: file server.", "id": "f39281:c0:m8"}
{"signature": "@staticmethod<EOL><INDENT>def create_batchai_client(preparer):<DEDENT>", "body": "try:<EOL><INDENT>from custom_client import create as create_custom_client<EOL>return create_custom_client()<EOL><DEDENT>except ImportError:<EOL><INDENT>return preparer.create_mgmt_client(BatchAIManagementClient)<EOL><DEDENT>", "docstring": "Creates a Batch AI management client for tests.\n\n        To create a custom version of the client (e.g. for integration environment), create\n        custom_client.py file with create() method returning the instance of the client.\n\n        :param AzureMgmtPreparer preparer: an instance of AzureMgmtPreparer\n        :returns BatchAIManagementClient: an instance of Batch AI management client", "id": "f39281:c0:m17"}
{"signature": "@staticmethod<EOL><INDENT>def _create_file_share(storage_account, storage_account_key):<DEDENT>", "body": "if storage_account == Helpers.FAKE_STORAGE.name:<EOL><INDENT>return<EOL><DEDENT>service = FileService(storage_account, storage_account_key)<EOL>service.create_share(Helpers.AZURE_FILES_NAME)<EOL>", "docstring": "Creates Azure Files in the storage account to be mounted into a cluster\n\n        :param str storage_account: name of the storage account.\n        :param str storage_account_key: storage account key.", "id": "f39281:c0:m1"}
{"signature": "def get(<EOL>self, resource_group_name, workspace_name, cluster_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", workspace_name, '<STR_LIT:str>', max_length=<NUM_LIT:64>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", cluster_name, '<STR_LIT:str>', max_length=<NUM_LIT:64>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about a Cluster.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param workspace_name: The name of the workspace. Workspace names can\n         only contain a combination of alphanumeric characters along with dash\n         (-) and underscore (_). The name must be from 1 through 64 characters\n         long.\n        :type workspace_name: str\n        :param cluster_name: The name of the cluster within the specified\n         resource group. Cluster names can only contain a combination of\n         alphanumeric characters along with dash (-) and underscore (_). The\n         name must be from 1 through 64 characters long.\n        :type cluster_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Cluster or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.batchai.models.Cluster or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39438:c0:m6"}
{"signature": "def terminate(<EOL>self, resource_group_name, workspace_name, experiment_name, job_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._terminate_initial(<EOL>resource_group_name=resource_group_name,<EOL>workspace_name=workspace_name,<EOL>experiment_name=experiment_name,<EOL>job_name=job_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Terminates a job.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param workspace_name: The name of the workspace. Workspace names can\n         only contain a combination of alphanumeric characters along with dash\n         (-) and underscore (_). The name must be from 1 through 64 characters\n         long.\n        :type workspace_name: str\n        :param experiment_name: The name of the experiment. Experiment names\n         can only contain a combination of alphanumeric characters along with\n         dash (-) and underscore (_). The name must be from 1 through 64\n         characters long.\n        :type experiment_name: str\n        :param job_name: The name of the job within the specified resource\n         group. Job names can only contain a combination of alphanumeric\n         characters along with dash (-) and underscore (_). The name must be\n         from 1 through 64 characters long.\n        :type job_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39440:c0:m10"}
{"signature": "def list(<EOL>self, location, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>', pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.UsagePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.UsagePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the current usage information as well as limits for Batch AI\n        resources for given subscription.\n\n        :param location: The location for which resource usage is queried.\n        :type location: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Usage\n        :rtype:\n         ~azure.mgmt.batchai.models.UsagePaged[~azure.mgmt.batchai.models.Usage]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39444:c0:m1"}
{"signature": "def receive_deferred_messages(self, sequence_numbers, mode=ReceiveSettleMode.PeekLock):", "body": "if not sequence_numbers:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self._can_run()<EOL>try:<EOL><INDENT>receive_mode = mode.value.value<EOL><DEDENT>except AttributeError:<EOL><INDENT>receive_mode = int(mode)<EOL><DEDENT>message = {<EOL>'<STR_LIT>': types.AMQPArray([types.AMQPLong(s) for s in sequence_numbers]),<EOL>'<STR_LIT>': types.AMQPuInt(receive_mode),<EOL>'<STR_LIT>': self.session_id<EOL>}<EOL>handler = functools.partial(mgmt_handlers.deferred_message_op, mode=receive_mode)<EOL>messages = self._mgmt_request_response(<EOL>REQUEST_RESPONSE_RECEIVE_BY_SEQUENCE_NUMBER,<EOL>message,<EOL>handler)<EOL>for m in messages:<EOL><INDENT>m._receiver = self  <EOL><DEDENT>return messages<EOL>", "docstring": "Receive messages that have previously been deferred.\n\n        This operation can only receive deferred messages from the current session.\n        When receiving deferred messages from a partitioned entity, all of the supplied\n        sequence numbers must be messages from the same partition.\n\n        :param sequence_numbers: A list of the sequence numbers of messages that have been\n         deferred.\n        :type sequence_numbers: list[int]\n        :param mode: The receive mode, default value is PeekLock.\n        :type mode: ~azure.servicebus.common.constants.ReceiveSettleMode\n        :rtype: list[~azure.servicebus.common.message.DeferredMessage]\n\n        Example:\n            .. literalinclude:: ../examples/test_examples.py\n                :start-after: [START receive_deferred_messages]\n                :end-before: [END receive_deferred_messages]\n                :language: python\n                :dedent: 4\n                :caption: Get the messages which were previously deferred in the session", "id": "f39481:c1:m9"}
{"signature": "def renew_lock(self):", "body": "self._can_run()<EOL>expiry = self._mgmt_request_response(<EOL>REQUEST_RESPONSE_RENEW_SESSION_LOCK_OPERATION,<EOL>{'<STR_LIT>': self.session_id},<EOL>mgmt_handlers.default)<EOL>self.locked_until = datetime.datetime.fromtimestamp(expiry[b'<STR_LIT>']/<NUM_LIT>)<EOL>", "docstring": "Renew the session lock.\n\n        This operation must be performed periodically in order to retain a lock on the\n        session to continue message processing.\n        Once the lock is lost the connection will be closed. This operation can\n        also be performed as a threaded background task by registering the session\n        with an `azure.servicebus.AutoLockRenew` instance.\n\n        Example:\n            .. literalinclude:: ../examples/test_examples.py\n                :start-after: [START renew_lock]\n                :end-before: [END renew_lock]\n                :language: python\n                :dedent: 4\n                :caption: Renew the session lock before it expires", "id": "f39481:c1:m7"}
{"signature": "def peek(self, count=<NUM_LIT:1>, start_from=None):", "body": "if not start_from:<EOL><INDENT>start_from = self.last_received or <NUM_LIT:1><EOL><DEDENT>if int(count) < <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if int(start_from) < <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self._can_run()<EOL>message = {<EOL>'<STR_LIT>': types.AMQPLong(start_from),<EOL>'<STR_LIT>': count<EOL>}<EOL>return self._mgmt_request_response(<EOL>REQUEST_RESPONSE_PEEK_OPERATION,<EOL>message,<EOL>mgmt_handlers.peek_op)<EOL>", "docstring": "Browse messages currently pending in the queue.\n\n        Peeked messages are not removed from queue, nor are they locked. They cannot be completed,\n        deferred or dead-lettered.\n\n        :param count: The maximum number of messages to try and peek. The default\n         value is 1.\n        :type count: int\n        :param start_from: A message sequence number from which to start browsing messages.\n        :type start_from: int\n        :rtype: list[~azure.servicebus.common.message.PeekMessage]\n\n        Example:\n            .. literalinclude:: ../examples/test_examples.py\n                :start-after: [START peek_messages]\n                :end-before: [END peek_messages]\n                :language: python\n                :dedent: 4\n                :caption: Look at pending messages in the queue", "id": "f39481:c0:m13"}
{"signature": "def list_sessions(self, updated_since=None, max_results=<NUM_LIT:100>, skip=<NUM_LIT:0>):", "body": "if int(max_results) < <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self._can_run()<EOL>message = {<EOL>'<STR_LIT>': updated_since or datetime.datetime.utcfromtimestamp(<NUM_LIT:0>),<EOL>'<STR_LIT>': skip,<EOL>'<STR_LIT>': max_results,<EOL>}<EOL>return self._mgmt_request_response(<EOL>REQUEST_RESPONSE_GET_MESSAGE_SESSIONS_OPERATION,<EOL>message,<EOL>mgmt_handlers.list_sessions_op)<EOL>", "docstring": "List session IDs.\n\n        List the Session IDs with pending messages in the queue where the state of the session\n        has been updated since the timestamp provided. If no timestamp is provided, all will be returned.\n        If the state of a Session has never been set, it will not be returned regardless of whether\n        there are messages pending.\n\n        :param updated_since: The UTC datetime from which to return updated pending Session IDs.\n        :type updated_since: datetime.datetime\n        :param max_results: The maximum number of Session IDs to return. Default value is 100.\n        :type max_results: int\n        :param skip: The page value to jump to. Default value is 0.\n        :type skip: int\n        :rtype: list[str]\n\n        Example:\n            .. literalinclude:: ../examples/test_examples.py\n                :start-after: [START list_sessions]\n                :end-before: [END list_sessions]\n                :language: python\n                :dedent: 4\n                :caption: List the ids of sessions with pending messages", "id": "f39481:c1:m10"}
{"signature": "def get_session_state(self):", "body": "self._can_run()<EOL>response = self._mgmt_request_response(<EOL>REQUEST_RESPONSE_GET_SESSION_STATE_OPERATION,<EOL>{'<STR_LIT>': self.session_id},<EOL>mgmt_handlers.default)<EOL>session_state = response.get(b'<STR_LIT>')<EOL>if isinstance(session_state, six.binary_type):<EOL><INDENT>session_state = session_state.decode('<STR_LIT>')<EOL><DEDENT>return session_state<EOL>", "docstring": "Get the session state.\n\n        Returns None if no state has been set.\n\n        :rtype: str\n\n        Example:\n            .. literalinclude:: ../examples/test_examples.py\n                :start-after: [START get_session_state]\n                :end-before: [END get_session_state]\n                :language: python\n                :dedent: 4\n                :caption: Get the session state of the receiver", "id": "f39481:c1:m5"}
{"signature": "def _build_receiver(self):", "body": "<EOL>self._handler.message_handler = self._handler.receiver_type(<EOL>self._handler._session,<EOL>self._handler._remote_address,<EOL>self._handler._name,<EOL>on_message_received=self._handler._message_received,<EOL>name='<STR_LIT>'.format(uuid.uuid4()),<EOL>debug=self._handler._debug_trace,<EOL>prefetch=self._handler._prefetch,<EOL>max_message_size=self._handler._max_message_size,<EOL>properties=self._handler._link_properties,<EOL>error_policy=self._handler._error_policy,<EOL>encoding=self._handler._encoding)<EOL>if self.mode != ReceiveSettleMode.PeekLock:<EOL><INDENT>self._handler.message_handler.send_settle_mode = constants.SenderSettleMode.Settled<EOL>self._handler.message_handler.receive_settle_mode = constants.ReceiverSettleMode.ReceiveAndDelete<EOL>self._handler.message_handler._settle_mode = constants.ReceiverSettleMode.ReceiveAndDelete<EOL><DEDENT>self._handler.message_handler.open()<EOL>", "docstring": "This is a temporary patch pending a fix in uAMQP.", "id": "f39481:c0:m8"}
{"signature": "def open(self):", "body": "if self.running:<EOL><INDENT>return<EOL><DEDENT>self.running = True<EOL>try:<EOL><INDENT>self._handler.open(connection=self.connection)<EOL>while not self._handler.client_ready():<EOL><INDENT>time.sleep(<NUM_LIT>)<EOL><DEDENT><DEDENT>except Exception as e:  <EOL><INDENT>try:<EOL><INDENT>self._handle_exception(e)<EOL><DEDENT>except:<EOL><INDENT>self.running = False<EOL>raise<EOL><DEDENT><DEDENT>", "docstring": "Open handler connection and authenticate session.\n\n        If the handler is already open, this operation will do nothing.\n        A handler opened with this method must be explicitly closed.\n        It is recommended to open a handler within a context manager as\n        opposed to calling the method directly.\n\n        .. note:: This operation is not thread-safe.", "id": "f39482:c0:m7"}
{"signature": "def list_queues(self):", "body": "try:<EOL><INDENT>queues = self.mgmt_client.list_queues()<EOL><DEDENT>except requests.exceptions.ConnectionError as e:<EOL><INDENT>raise ServiceBusConnectionError(\"<STR_LIT>\".format(self.service_namespace), e)<EOL><DEDENT>queue_clients = []<EOL>for queue in queues:<EOL><INDENT>queue_clients.append(QueueClient.from_entity(<EOL>self._get_host(), queue,<EOL>shared_access_key_name=self.shared_access_key_name,<EOL>shared_access_key_value=self.shared_access_key_value,<EOL>mgmt_client=self.mgmt_client,<EOL>debug=self.debug))<EOL><DEDENT>return queue_clients<EOL>", "docstring": "Get clients for all queue entities in the namespace.\n\n        :rtype: list[~azure.servicebus.servicebus_client.QueueClient]\n        :raises: ~azure.servicebus.common.errors.ServiceBusConnectionError if the namespace is not found.\n\n        Example:\n            .. literalinclude:: ../examples/test_examples.py\n                :start-after: [START list_queues]\n                :end-before: [END list_queues]\n                :language: python\n                :dedent: 4\n                :caption: List the queues from Service Bus client", "id": "f39483:c0:m4"}
{"signature": "def get_deadletter_receiver(<EOL>self, transfer_deadletter=False, prefetch=<NUM_LIT:0>,<EOL>mode=ReceiveSettleMode.PeekLock, idle_timeout=<NUM_LIT:0>, **kwargs):", "body": "if int(prefetch) < <NUM_LIT:0> or int(prefetch) > <NUM_LIT>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>prefetch += <NUM_LIT:1><EOL>handler_id = str(uuid.uuid4())<EOL>if transfer_deadletter:<EOL><INDENT>entity_uri = self.mgmt_client.format_transfer_dead_letter_queue_name(self.entity_uri)<EOL><DEDENT>else:<EOL><INDENT>entity_uri = self.mgmt_client.format_dead_letter_queue_name(self.entity_uri)<EOL><DEDENT>return Receiver(<EOL>handler_id,<EOL>entity_uri,<EOL>self.auth_config,<EOL>debug=self.debug,<EOL>timeout=int(idle_timeout * <NUM_LIT:1000>),<EOL>prefetch=prefetch,<EOL>mode=mode,<EOL>**kwargs)<EOL>", "docstring": "Get a Receiver for the deadletter endpoint of the queue.\n\n        A Receiver represents a single open Connection with which multiple receive operations can be made.\n\n        :param transfer_deadletter: Whether to connect to the transfer deadletter queue, or the standard\n         deadletter queue. Default is False, using the standard deadletter endpoint.\n        :type transfer_deadletter: bool\n        :param prefetch: The maximum number of messages to cache with each request to the service.\n         The default value is 0, meaning messages will be received from the service and processed\n         one at a time. Increasing this value will improve message throughput performance but increase\n         the change that messages will expire while they are cached if they're not processed fast enough.\n        :type prefetch: int\n        :param mode: The mode with which messages will be retrieved from the entity. The two options\n         are PeekLock and ReceiveAndDelete. Messages received with PeekLock must be settled within a given\n         lock period before they will be removed from the queue. Messages received with ReceiveAndDelete\n         will be immediately removed from the queue, and cannot be subsequently rejected or re-received if\n         the client fails to process the message. The default mode is PeekLock.\n        :type mode: ~azure.servicebus.common.constants.ReceiveSettleMode\n        :param idle_timeout: The timeout in seconds between received messages after which the receiver will\n         automatically shutdown. The default value is 0, meaning no timeout.\n        :type idle_timeout: int\n        :returns: A Receiver instance with an unopened Connection.\n        :rtype: ~azure.servicebus.receive_handler.Receiver\n\n        Example:\n            .. literalinclude:: ../examples/test_examples.py\n                :start-after: [START get_dead_letter_receiver]\n                :end-before: [END get_dead_letter_receiver]\n                :language: python\n                :dedent: 4\n                :caption: Get the dead lettered messages", "id": "f39483:c2:m5"}
{"signature": "def get_topic(self, topic_name):", "body": "try:<EOL><INDENT>topic = self.mgmt_client.get_topic(topic_name)<EOL><DEDENT>except requests.exceptions.ConnectionError as e:<EOL><INDENT>raise ServiceBusConnectionError(\"<STR_LIT>\".format(self.service_namespace), e)<EOL><DEDENT>except AzureServiceBusResourceNotFound:<EOL><INDENT>raise ServiceBusResourceNotFound(\"<STR_LIT>\")<EOL><DEDENT>return TopicClient.from_entity(<EOL>self._get_host(), topic,<EOL>shared_access_key_name=self.shared_access_key_name,<EOL>shared_access_key_value=self.shared_access_key_value,<EOL>debug=self.debug)<EOL>", "docstring": "Get a client for a topic entity.\n\n        :param topic_name: The name of the topic.\n        :type topic_name: str\n        :rtype: ~azure.servicebus.servicebus_client.TopicClient\n        :raises: ~azure.servicebus.common.errors.ServiceBusConnectionError if the namespace is not found.\n        :raises: ~azure.servicebus.common.errors.ServiceBusResourceNotFound if the topic is not found.\n\n        Example:\n            .. literalinclude:: ../examples/test_examples.py\n                :start-after: [START get_topic_client]\n                :end-before: [END get_topic_client]\n                :language: python\n                :dedent: 8\n                :caption: Get the specific topic client from Service Bus client", "id": "f39483:c0:m5"}
{"signature": "@classmethod<EOL><INDENT>def from_connection_string(cls, conn_str, name, topic=None, **kwargs):  <DEDENT>", "body": "address, policy, key, entity = parse_conn_str(conn_str)<EOL>entity = topic or entity<EOL>address = build_uri(address, entity)<EOL>address += \"<STR_LIT>\" + name<EOL>return cls(address, name, shared_access_key_name=policy, shared_access_key_value=key, **kwargs)<EOL>", "docstring": "Create a SubscriptionClient from a connection string.\n\n        :param conn_str: The connection string.\n        :type conn_str: str\n        :param name: The name of the Subscription.\n        :type name: str\n        :param topic: The name of the Topic, if the EntityName is\n         not included in the connection string.\n        :type topic: str", "id": "f39483:c5:m1"}
{"signature": "def settle_deferred_messages(self, settlement, messages, **kwargs):", "body": "if (self.entity and self.requires_session) or kwargs.get('<STR_LIT>'):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if settlement.lower() not in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not messages:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>message = {<EOL>'<STR_LIT>': settlement.lower(),<EOL>'<STR_LIT>': types.AMQPArray([m.lock_token for m in messages])}<EOL>with BaseHandler(self.entity_uri, self.auth_config, debug=self.debug, **kwargs) as handler:<EOL><INDENT>return handler._mgmt_request_response(  <EOL>REQUEST_RESPONSE_UPDATE_DISPOSTION_OPERATION,<EOL>message,<EOL>mgmt_handlers.default)<EOL><DEDENT>", "docstring": "Settle messages that have been previously deferred.\n\n        :param settlement: How the messages are to be settled. This must be a string\n         of one of the following values: 'completed', 'suspended', 'abandoned'.\n        :type settlement: str\n        :param messages: A list of deferred messages to be settled.\n        :type messages: list[~azure.servicebus.common.message.DeferredMessage]\n\n        Example:\n            .. literalinclude:: ../examples/test_examples.py\n                :start-after: [START settle_deferred_messages_service_bus]\n                :end-before: [END settle_deferred_messages_service_bus]\n                :language: python\n                :dedent: 8\n                :caption: Settle deferred messages.", "id": "f39483:c2:m3"}
{"signature": "def get_queue(self, queue_name):", "body": "try:<EOL><INDENT>queue = self.mgmt_client.get_queue(queue_name)<EOL><DEDENT>except requests.exceptions.ConnectionError as e:<EOL><INDENT>raise ServiceBusConnectionError(\"<STR_LIT>\".format(self.service_namespace), e)<EOL><DEDENT>except AzureServiceBusResourceNotFound:<EOL><INDENT>raise ServiceBusResourceNotFound(\"<STR_LIT>\")<EOL><DEDENT>return QueueClient.from_entity(<EOL>self._get_host(), queue,<EOL>shared_access_key_name=self.shared_access_key_name,<EOL>shared_access_key_value=self.shared_access_key_value,<EOL>mgmt_client=self.mgmt_client,<EOL>debug=self.debug)<EOL>", "docstring": "Get a client for a queue entity.\n\n        :param queue_name: The name of the queue.\n        :type queue_name: str\n        :rtype: ~azure.servicebus.servicebus_client.QueueClient\n        :raises: ~azure.servicebus.common.errors.ServiceBusConnectionError if the namespace is not found.\n        :raises: ~azure.servicebus.common.errors.ServiceBusResourceNotFound if the queue is not found.\n\n        Example:\n            .. literalinclude:: ../examples/test_examples.py\n                :start-after: [START get_queue_client]\n                :end-before: [END get_queue_client]\n                :language: python\n                :dedent: 8\n                :caption: Get the specific queue client from Service Bus client", "id": "f39483:c0:m3"}
{"signature": "def list_subscriptions(self, topic_name):", "body": "try:<EOL><INDENT>subs = self.mgmt_client.list_subscriptions(topic_name)<EOL><DEDENT>except requests.exceptions.ConnectionError as e:<EOL><INDENT>raise ServiceBusConnectionError(\"<STR_LIT>\".format(self.service_namespace), e)<EOL><DEDENT>except AzureServiceBusResourceNotFound:<EOL><INDENT>raise ServiceBusResourceNotFound(\"<STR_LIT>\")<EOL><DEDENT>sub_clients = []<EOL>for sub in subs:<EOL><INDENT>sub_clients.append(SubscriptionClient.from_entity(<EOL>self._get_host(), topic_name, sub,<EOL>shared_access_key_name=self.shared_access_key_name,<EOL>shared_access_key_value=self.shared_access_key_value,<EOL>debug=self.debug))<EOL><DEDENT>return sub_clients<EOL>", "docstring": "Get a client for all subscription entities in the topic.\n\n        :param topic_name: The topic to list subscriptions for.\n        :type topic_name: str\n        :rtype: list[~azure.servicebus.servicebus_client.SubscriptionClient]\n        :raises: ~azure.servicebus.common.errors.ServiceBusConnectionError if the namespace is not found.\n        :raises: ~azure.servicebus.common.errors.ServiceBusResourceNotFound if the topic is not found.\n\n        Example:\n            .. literalinclude:: ../examples/test_examples.py\n                :start-after: [START list_subscriptions]\n                :end-before: [END list_subscriptions]\n                :language: python\n                :dedent: 4\n                :caption: List the subscriptions from Service Bus client", "id": "f39483:c0:m8"}
{"signature": "def list_sessions(self, updated_since=None, max_results=<NUM_LIT:100>, skip=<NUM_LIT:0>, **kwargs):", "body": "if self.entity and not self.requires_session:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>message = {<EOL>'<STR_LIT>': updated_since or datetime.datetime.utcfromtimestamp(<NUM_LIT:0>),<EOL>'<STR_LIT>': types.AMQPInt(skip),<EOL>'<STR_LIT>': types.AMQPInt(max_results),<EOL>}<EOL>with BaseHandler(self.entity_uri, self.auth_config, debug=self.debug, **kwargs) as handler:<EOL><INDENT>return handler._mgmt_request_response(  <EOL>REQUEST_RESPONSE_GET_MESSAGE_SESSIONS_OPERATION,<EOL>message,<EOL>mgmt_handlers.list_sessions_op)<EOL><DEDENT>", "docstring": "List session IDs.\n\n        List the Session IDs with pending messages in the queue where the state of the session\n        has been updated since the timestamp provided. If no timestamp is provided, all will be returned.\n        If the state of a session has never been set, it will not be returned regardless of whether\n        there are messages pending.\n\n        :param updated_since: The UTC datetime from which to return updated pending Session IDs.\n        :type updated_since: datetime.datetime\n        :param max_results: The maximum number of Session IDs to return. Default value is 100.\n        :type max_results: int\n        :param skip: The page value to jump to. Default value is 0.\n        :type skip: int\n        :rtype: list[str]\n\n        Example:\n            .. literalinclude:: ../examples/test_examples.py\n                :start-after: [START list_sessions_service_bus]\n                :end-before: [END list_sessions_service_bus]\n                :language: python\n                :dedent: 4\n                :caption: Get the Ids of session which have messages pending in the queue", "id": "f39483:c2:m1"}
{"signature": "def list_topics(self):", "body": "try:<EOL><INDENT>topics = self.mgmt_client.list_topics()<EOL><DEDENT>except requests.exceptions.ConnectionError as e:<EOL><INDENT>raise ServiceBusConnectionError(\"<STR_LIT>\".format(self.service_namespace), e)<EOL><DEDENT>topic_clients = []<EOL>for topic in topics:<EOL><INDENT>topic_clients.append(TopicClient.from_entity(<EOL>self._get_host(), topic,<EOL>shared_access_key_name=self.shared_access_key_name,<EOL>shared_access_key_value=self.shared_access_key_value,<EOL>debug=self.debug))<EOL><DEDENT>return topic_clients<EOL>", "docstring": "Get a client for all topic entities in the namespace.\n\n        :rtype: list[~azure.servicebus.servicebus_client.TopicClient]\n        :raises: ~azure.servicebus.common.errors.ServiceBusConnectionError if the namespace is not found.\n\n        Example:\n            .. literalinclude:: ../examples/test_examples.py\n                :start-after: [START list_topics]\n                :end-before: [END list_topics]\n                :language: python\n                :dedent: 4\n                :caption: List the topics from Service Bus client", "id": "f39483:c0:m6"}
{"signature": "async def schedule_messages(self, schedule_time, *messages):", "body": "for message in messages:<EOL><INDENT>if not self.session_id and not message.properties.group_id:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>return await super(SessionSender, self).schedule(schedule_time, *messages)<EOL>", "docstring": "Send one or more messages to be enqueued at a specific time.\n\n        Returns a list of the sequence numbers of the enqueued messages.\n        If neither the Sender nor the message has a session ID, a `ValueError` will be raised.\n\n        :param schedule_time: The date and time to enqueue the messages.\n        :type schedule_time: ~datetime.datetime\n        :param messages: The messages to schedule.\n        :type messages: ~azure.servicebus.aio.async_message.Message\n        :rtype: list[int]\n\n        Example:\n            .. literalinclude:: ../examples/async_examples/test_examples_async.py\n                :start-after: [START schedule_session_messages]\n                :end-before: [END schedule_session_messages]\n                :language: python\n                :dedent: 4\n                :caption: Schedule messages.", "id": "f39484:c1:m2"}
{"signature": "async def send(self, message):", "body": "if not isinstance(message, Message):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if not self.session_id and not message.properties.group_id:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>return await super(SessionSender, self).send(message)<EOL>", "docstring": "Send a message and blocks until acknowledgement is received or the operation fails.\n\n        If neither the Sender nor the message has a session ID, a `ValueError` will be raised.\n\n        :param message: The message to be sent.\n        :type message: ~azure.servicebus.aio.async_message.Message\n        :raises: ~azure.servicebus.common.errors.MessageSendFailed if the message fails to\n         send.\n\n        Example:\n            .. literalinclude:: ../examples/async_examples/test_examples_async.py\n                :start-after: [START open_close_session_sender_context]\n                :end-before: [END open_close_session_sender_context]\n                :language: python\n                :dedent: 4\n                :caption: Open a sessionful Sender and send messages.", "id": "f39484:c1:m0"}
{"signature": "async def send(self, messages, message_timeout=<NUM_LIT:0>, session=None, **kwargs):", "body": "async with self.get_sender(message_timeout=message_timeout, session=session, **kwargs) as sender:<EOL><INDENT>if isinstance(messages, Message):<EOL><INDENT>sender.queue_message(messages)<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>messages = list(messages)<EOL><DEDENT>except TypeError:<EOL><INDENT>raise TypeError(<EOL>\"<STR_LIT>\")<EOL><DEDENT>for m in messages:<EOL><INDENT>if not isinstance(m, Message):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>sender.queue_message(m)<EOL><DEDENT><DEDENT>return await sender.send_pending_messages()<EOL><DEDENT>", "docstring": "Send one or more messages to the current entity.\n\n        This operation will open a single-use connection, send the supplied messages, and close\n        connection. If the entity requires sessions, a session ID must be either\n        provided here, or set on each outgoing message.\n\n        :param messages: One or more messages to be sent.\n        :type messages: ~azure.servicebus.aio.async_message.Message or\n         list[~azure.servicebus.aio.async_message.Message]\n        :param message_timeout: The period in seconds during which the Message must be\n         sent. If the send is not completed in this time it will return a failure result.\n        :type message_timeout: int\n        :param session: An optional session ID. If supplied this session ID will be\n         applied to every outgoing message sent with this Sender.\n         If an individual message already has a session ID, that will be\n         used instead. If no session ID is supplied here, nor set on an outgoing\n         message, a ValueError will be raised if the entity is sessionful.\n        :type session: str or ~uuid.Guid\n        :raises: ~azure.servicebus.common.errors.MessageSendFailed\n        :returns: A list of the send results of all the messages. Each\n         send result is a tuple with two values. The first is a boolean, indicating `True`\n         if the message sent, or `False` if it failed. The second is an error if the message\n         failed, otherwise it will be `None`.\n        :rtype: list[tuple[bool, ~azure.servicebus.common.errors.MessageSendFailed]]\n\n        Example:\n            .. literalinclude:: ../examples/async_examples/test_examples_async.py\n                :start-after: [START queue_client_send]\n                :end-before: [END queue_client_send]\n                :language: python\n                :dedent: 4\n                :caption: Send a single message.\n\n            .. literalinclude:: ../examples/async_examples/test_examples_async.py\n                :start-after: [START queue_client_send_multiple]\n                :end-before: [END queue_client_send_multiple]\n                :language: python\n                :dedent: 4\n                :caption: Send multiple messages.", "id": "f39487:c1:m0"}
{"signature": "def get_subscription(self, topic_name, subscription_name):", "body": "try:<EOL><INDENT>subscription = self.mgmt_client.get_subscription(topic_name, subscription_name)<EOL><DEDENT>except requests.exceptions.ConnectionError as e:<EOL><INDENT>raise ServiceBusConnectionError(\"<STR_LIT>\".format(self.service_namespace), e)<EOL><DEDENT>except AzureServiceBusResourceNotFound:<EOL><INDENT>raise ServiceBusResourceNotFound(\"<STR_LIT>\")<EOL><DEDENT>return SubscriptionClient.from_entity(<EOL>self._get_host(), topic_name, subscription,<EOL>shared_access_key_name=self.shared_access_key_name,<EOL>shared_access_key_value=self.shared_access_key_value,<EOL>loop=self.loop,<EOL>debug=self.debug)<EOL>", "docstring": "Get an async client for a subscription entity.\n\n        :param topic_name: The name of the topic.\n        :type topic_name: str\n        :param subscription_name: The name of the subscription.\n        :type subscription_name: str\n        :rtype: ~azure.servicebus.aio.async_client.SubscriptionClient\n        :raises: ~azure.servicebus.common.errors.ServiceBusConnectionError if the namespace is not found.\n        :raises: ~azure.servicebus.common.errors.ServiceBusResourceNotFound if the subscription is not found.\n\n        Example:\n            .. literalinclude:: ../examples/async_examples/test_examples_async.py\n                :start-after: [START get_async_subscription_client]\n                :end-before: [END get_async_subscription_client]\n                :language: python\n                :dedent: 4\n                :caption: Get a TopicClient for the specified topic.", "id": "f39487:c0:m6"}
{"signature": "async def settle_deferred_messages(self, settlement, messages, **kwargs):", "body": "if (self.entity and self.requires_session) or kwargs.get('<STR_LIT>'):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if settlement.lower() not in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>if not messages:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>message = {<EOL>'<STR_LIT>': settlement.lower(),<EOL>'<STR_LIT>': types.AMQPArray([m.lock_token for m in messages])}<EOL>async with BaseHandler(<EOL>self.entity_uri, self.auth_config, loop=self.loop, debug=self.debug, **kwargs) as handler:<EOL><INDENT>return await handler._mgmt_request_response(  <EOL>REQUEST_RESPONSE_UPDATE_DISPOSTION_OPERATION,<EOL>message,<EOL>mgmt_handlers.default)<EOL><DEDENT>", "docstring": "Settle messages that have been previously deferred.\n\n        :param settlement: How the messages are to be settled. This must be a string\n         of one of the following values: 'completed', 'suspended', 'abandoned'.\n        :type settlement: str\n        :param messages: A list of deferred messages to be settled.\n        :type messages: list[~azure.servicebus.aio.async_message.DeferredMessage]\n\n        Example:\n            .. literalinclude:: ../examples/async_examples/test_examples_async.py\n                :start-after: [START client_settle_deferred_messages]\n                :end-before: [END client_settle_deferred_messages]\n                :language: python\n                :dedent: 4\n                :caption: Settle deferred messages.", "id": "f39487:c2:m2"}
{"signature": "async def peek(self, count=<NUM_LIT:1>, start_from=<NUM_LIT:0>, session=None, **kwargs):", "body": "message = {<EOL>'<STR_LIT>': types.AMQPLong(start_from),<EOL>'<STR_LIT>': int(count)}<EOL>if self.entity and self.requires_session:<EOL><INDENT>if not session:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>message['<STR_LIT>'] = session<EOL><DEDENT>async with BaseHandler(<EOL>self.entity_uri, self.auth_config, loop=self.loop, debug=self.debug, **kwargs) as handler:<EOL><INDENT>return await handler._mgmt_request_response(  <EOL>REQUEST_RESPONSE_PEEK_OPERATION,<EOL>message,<EOL>mgmt_handlers.peek_op)<EOL><DEDENT>", "docstring": "Browse messages currently pending in the queue.\n\n        Peeked messages are not removed from queue, nor are they locked. They cannot be completed,\n        deferred or dead-lettered.\n\n        :param count: The maximum number of messages to try and peek. The default\n         value is 1.\n        :type count: int\n        :param start_from: A message sequence number from which to start browsing messages.\n        :type start_from: int\n        :param session: If the entity requires sessions, a session ID must be supplied\n         in order that only messages from that session will be browsed. If the entity\n         does not require sessions this value will be ignored.\n        :type session: str\n        :rtype: list[~azure.servicebus.common.message.PeekMessage]\n\n        Example:\n            .. literalinclude:: ../examples/async_examples/test_examples_async.py\n                :start-after: [START client_peek_messages]\n                :end-before: [END client_peek_messages]\n                :language: python\n                :dedent: 4\n                :caption: Peek messages in the queue.", "id": "f39487:c2:m0"}
{"signature": "def list_topics(self):", "body": "try:<EOL><INDENT>topics = self.mgmt_client.list_topics()<EOL><DEDENT>except requests.exceptions.ConnectionError as e:<EOL><INDENT>raise ServiceBusConnectionError(\"<STR_LIT>\".format(self.service_namespace), e)<EOL><DEDENT>topic_clients = []<EOL>for topic in topics:<EOL><INDENT>topic_clients.append(TopicClient.from_entity(<EOL>self._get_host(), topic,<EOL>shared_access_key_name=self.shared_access_key_name,<EOL>shared_access_key_value=self.shared_access_key_value,<EOL>loop=self.loop,<EOL>debug=self.debug))<EOL><DEDENT>return topic_clients<EOL>", "docstring": "Get an async client for all topic entities in the namespace.\n\n        :rtype: list[~azure.servicebus.aio.async_client.TopicClient]\n        :raises: ~azure.servicebus.common.errors.ServiceBusConnectionError if the namespace is not found.", "id": "f39487:c0:m5"}
{"signature": "def list_subscriptions(self, topic_name):", "body": "try:<EOL><INDENT>subs = self.mgmt_client.list_subscriptions(topic_name)<EOL><DEDENT>except requests.exceptions.ConnectionError as e:<EOL><INDENT>raise ServiceBusConnectionError(\"<STR_LIT>\".format(self.service_namespace), e)<EOL><DEDENT>except AzureServiceBusResourceNotFound:<EOL><INDENT>raise ServiceBusResourceNotFound(\"<STR_LIT>\")<EOL><DEDENT>sub_clients = []<EOL>for sub in subs:<EOL><INDENT>sub_clients.append(SubscriptionClient.from_entity(<EOL>self._get_host(), topic_name, sub,<EOL>shared_access_key_name=self.shared_access_key_name,<EOL>shared_access_key_value=self.shared_access_key_value,<EOL>loop=self.loop,<EOL>debug=self.debug))<EOL><DEDENT>return sub_clients<EOL>", "docstring": "Get an async client for all subscription entities in the topic.\n\n        :param topic_name: The topic to list subscriptions for.\n        :type topic_name: str\n        :rtype: list[~azure.servicebus.aio.async_client.SubscriptionClient]\n        :raises: ~azure.servicebus.common.errors.ServiceBusConnectionError if the namespace is not found.\n        :raises: ~azure.servicebus.common.errors.ServiceBusResourceNotFound if the topic is not found.", "id": "f39487:c0:m7"}
{"signature": "async def shutdown(self):", "body": "self._shutdown.set()<EOL>await asyncio.wait(self._futures)<EOL>", "docstring": "Cancel remaining open lock renewal futures.", "id": "f39488:c0:m6"}
{"signature": "async def close(self, exception=None):", "body": "self.running = False<EOL>if self.error:<EOL><INDENT>return<EOL><DEDENT>if isinstance(exception, ServiceBusError):<EOL><INDENT>self.error = exception<EOL><DEDENT>elif exception:<EOL><INDENT>self.error = ServiceBusError(str(exception))<EOL><DEDENT>else:<EOL><INDENT>self.error = ServiceBusError(\"<STR_LIT>\")<EOL><DEDENT>await self._handler.close_async()<EOL>", "docstring": "Close down the handler connection.\n\n        If the handler has already closed,\n        this operation will do nothing. An optional exception can be passed in to\n        indicate that the handler was shutdown due to error.\n        It is recommended to open a handler within a context manager as\n        opposed to calling the method directly.\n\n        .. note:: This operation is not thread-safe.\n\n        :param exception: An optional exception if the handler is closing\n         due to an error.\n        :type exception: Exception\n\n        Example:\n            .. literalinclude:: ../examples/async_examples/test_examples_async.py\n                :start-after: [START open_close_sender_directly]\n                :end-before: [END open_close_sender_directly]\n                :language: python\n                :dedent: 4\n                :caption: Explicitly open and close a Sender.", "id": "f39489:c0:m8"}
{"signature": "async def __aenter__(self):", "body": "await self.open()<EOL>return self<EOL>", "docstring": "Open the handler in a context manager.", "id": "f39489:c0:m1"}
{"signature": "async def list_sessions(self, updated_since=None, max_results=<NUM_LIT:100>, skip=<NUM_LIT:0>):", "body": "if int(max_results) < <NUM_LIT:1>:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>await self._can_run()<EOL>message = {<EOL>'<STR_LIT>': updated_since or datetime.datetime.utcfromtimestamp(<NUM_LIT:0>),<EOL>'<STR_LIT>': skip,<EOL>'<STR_LIT>': max_results,<EOL>}<EOL>return await self._mgmt_request_response(<EOL>REQUEST_RESPONSE_GET_MESSAGE_SESSIONS_OPERATION,<EOL>message,<EOL>mgmt_handlers.list_sessions_op)<EOL>", "docstring": "List session IDs.\n\n        List the IDs of sessions in the queue with pending messages and where the state of the session\n        has been updated since the timestamp provided. If no timestamp is provided, all will be returned.\n        If the state of a session has never been set, it will not be returned regardless of whether\n        there are messages pending.\n\n        :param updated_since: The UTC datetime from which to return updated pending session IDs.\n        :type updated_since: ~datetime.datetime\n        :param max_results: The maximum number of session IDs to return. Default value is 100.\n        :type max_results: int\n        :param skip: The page value to jump to. Default value is 0.\n        :type skip: int\n        :rtype: list[str]", "id": "f39490:c1:m10"}
{"signature": "async def renew_lock(self):", "body": "await self._can_run()<EOL>expiry = await self._mgmt_request_response(<EOL>REQUEST_RESPONSE_RENEW_SESSION_LOCK_OPERATION,<EOL>{'<STR_LIT>': self.session_id},<EOL>mgmt_handlers.default)<EOL>self.locked_until = datetime.datetime.fromtimestamp(expiry[b'<STR_LIT>']/<NUM_LIT>)<EOL>", "docstring": "Renew the session lock.\n\n        This operation must be performed periodically in order to retain a lock on the session\n        to continue message processing. Once the lock is lost the connection will be closed.\n        This operation can also be performed as an asynchronous background task by registering the session\n        with an `azure.servicebus.aio.AutoLockRenew` instance.\n\n        Example:\n            .. literalinclude:: ../examples/async_examples/test_examples_async.py\n                :start-after: [START receiver_renew_session_lock]\n                :end-before: [END receiver_renew_session_lock]\n                :language: python\n                :dedent: 4\n                :caption: Renew the sesison lock.", "id": "f39490:c1:m7"}
{"signature": "def _general_error_handler(http_error):", "body": "message = str(http_error)<EOL>if http_error.respbody is not None:<EOL><INDENT>message += '<STR_LIT:\\n>' + http_error.respbody.decode('<STR_LIT>')<EOL><DEDENT>raise AzureHttpError(message, http_error.status)<EOL>", "docstring": "Simple error handler for azure.", "id": "f39491:m0"}
{"signature": "def _dont_fail_on_exist(error):", "body": "if isinstance(error, AzureConflictHttpError):<EOL><INDENT>return False<EOL><DEDENT>raise error<EOL>", "docstring": "don't throw exception if the resource exists.\n    This is called by create_* APIs with fail_on_exist=False", "id": "f39491:m1"}
{"signature": "def __init__(self, status, message, respheader, respbody):", "body": "self.status = status<EOL>self.respheader = respheader<EOL>self.respbody = respbody<EOL>Exception.__init__(self, message)<EOL>", "docstring": "Creates a new HTTPError with the specified status, message,\n        response headers and body", "id": "f39493:c0:m0"}
{"signature": "def get_connection(self, request):", "body": "protocol = request.protocol_overrideif request.protocol_override else self.protocol<EOL>protocol = protocol.lower()<EOL>target_host = request.host<EOL>connection = _RequestsConnection(<EOL>target_host, protocol, self.request_session, self.timeout)<EOL>proxy_host = self.proxy_host<EOL>proxy_port = self.proxy_port<EOL>if self.proxy_host:<EOL><INDENT>headers = None<EOL>if self.proxy_user and self.proxy_password:<EOL><INDENT>auth = base64.b64encode(\"<STR_LIT>\".format(self.proxy_user, self.proxy_password).encode())<EOL>headers = {'<STR_LIT>': '<STR_LIT>'.format(auth.decode())}<EOL><DEDENT>connection.set_tunnel(proxy_host, int(proxy_port), headers)<EOL><DEDENT>return connection<EOL>", "docstring": "Create connection for the request.", "id": "f39494:c0:m3"}
{"signature": "def set_proxy(self, host, port, user, password):", "body": "self.proxy_host = host<EOL>self.proxy_port = port<EOL>self.proxy_user = user<EOL>self.proxy_password = password<EOL>", "docstring": "Sets the proxy server host and port for the HTTP CONNECT Tunnelling.\n\nhost:\n    Address of the proxy. Ex: '192.168.0.100'\nport:\n    Port of the proxy. Ex: 6000\nuser:\n    User for proxy authorization.\npassword:\n    Password for proxy authorization.", "id": "f39494:c0:m1"}
{"signature": "@staticmethod<EOL><INDENT>def _fill_scalar_list_of(xmldoc, element_type, parent_xml_element_name,<EOL>xml_element_name):<DEDENT>", "body": "raise NotImplementedError('<STR_LIT>')<EOL>", "docstring": "Converts an xml fragment into a list of scalar types.  The parent xml\n        element contains a flat list of xml elements which are converted into the\n        specified scalar type and added to the list.\n        Example:\n        xmldoc=\n    <Endpoints>\n        <Endpoint>http://{storage-service-name}.blob.core.windows.net/</Endpoint>\n        <Endpoint>http://{storage-service-name}.queue.core.windows.net/</Endpoint>\n        <Endpoint>http://{storage-service-name}.table.core.windows.net/</Endpoint>\n    </Endpoints>\n        element_type=str\n        parent_xml_element_name='Endpoints'\n        xml_element_name='Endpoint'", "id": "f39498:c0:m11"}
{"signature": "def _get_readable_id(id_name, id_prefix_to_skip):", "body": "<EOL>pos = id_name.find('<STR_LIT>')<EOL>if pos != -<NUM_LIT:1>:<EOL><INDENT>pos += <NUM_LIT:2><EOL>if id_prefix_to_skip:<EOL><INDENT>pos = id_name.find(id_prefix_to_skip, pos)<EOL>if pos != -<NUM_LIT:1>:<EOL><INDENT>pos += len(id_prefix_to_skip)<EOL><DEDENT><DEDENT>pos = id_name.find('<STR_LIT:/>', pos)<EOL>if pos != -<NUM_LIT:1>:<EOL><INDENT>return id_name[pos + <NUM_LIT:1>:]<EOL><DEDENT><DEDENT>return id_name<EOL>", "docstring": "simplified an id to be more friendly for us people", "id": "f39498:m3"}
{"signature": "def _get_serialization_name(element_name):", "body": "known = _KNOWN_SERIALIZATION_XFORMS.get(element_name)<EOL>if known is not None:<EOL><INDENT>return known<EOL><DEDENT>if element_name.startswith('<STR_LIT>'):<EOL><INDENT>return element_name.replace('<STR_LIT:_>', '<STR_LIT:->')<EOL><DEDENT>if element_name.endswith('<STR_LIT>'):<EOL><INDENT>element_name = element_name.replace('<STR_LIT>', '<STR_LIT>')<EOL><DEDENT>for name in ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>if element_name.startswith(name):<EOL><INDENT>element_name = element_name.replace('<STR_LIT:_>', '<STR_LIT>')<EOL><DEDENT><DEDENT>return '<STR_LIT>'.join(name.capitalize() for name in element_name.split('<STR_LIT:_>'))<EOL>", "docstring": "converts a Python name into a serializable name", "id": "f39498:m5"}
{"signature": "@staticmethod<EOL><INDENT>def _fill_instance_child(xmldoc, element_name, return_type):<DEDENT>", "body": "element = xmldoc.find(_get_serialization_name(element_name))<EOL>if element is None:<EOL><INDENT>return None<EOL><DEDENT>return_obj = return_type()<EOL>_ETreeXmlToObject._fill_data_to_return_object(element, return_obj)<EOL>return return_obj<EOL>", "docstring": "Converts a child of the current dom element to the specified type.", "id": "f39498:c0:m8"}
{"signature": "def receive_subscription_message(self, topic_name, subscription_name,<EOL>peek_lock=True, timeout=<NUM_LIT>):", "body": "if peek_lock:<EOL><INDENT>return self.peek_lock_subscription_message(topic_name,<EOL>subscription_name,<EOL>timeout)<EOL><DEDENT>return self.read_delete_subscription_message(topic_name,<EOL>subscription_name,<EOL>timeout)<EOL>", "docstring": "Receive a message from a subscription for processing.\n\ntopic_name:\n    Name of the topic.\nsubscription_name:\n    Name of the subscription.\npeek_lock:\n    Optional. True to retrieve and lock the message. False to read and\n    delete the message. Default is True (lock).\ntimeout:\n    Optional. The timeout parameter is expressed in seconds.", "id": "f39500:c0:m44"}
{"signature": "@staticmethod<EOL><INDENT>def format_transfer_dead_letter_topic_name(topic_name):<DEDENT>", "body": "return topic_name + '<STR_LIT>' + '<STR_LIT>'<EOL>", "docstring": "Get the dead letter name of this topic", "id": "f39500:c0:m4"}
{"signature": "def send_event(self, hub_name, message, device_id=None,<EOL>broker_properties=None):", "body": "_validate_not_none('<STR_LIT>', hub_name)<EOL>request = HTTPRequest()<EOL>request.method = '<STR_LIT:POST>'<EOL>request.host = self._get_host()<EOL>if device_id:<EOL><INDENT>request.path = '<STR_LIT>'.format(hub_name, device_id)<EOL><DEDENT>else:<EOL><INDENT>request.path = '<STR_LIT>'.format(hub_name)<EOL><DEDENT>if broker_properties:<EOL><INDENT>request.headers.append(<EOL>('<STR_LIT>', str(broker_properties)))<EOL><DEDENT>request.body = _get_request_body(message)<EOL>request.path, request.query = self._httpclient._update_request_uri_query(request)  <EOL>request.headers = self._update_service_bus_header(request)<EOL>self._perform_request(request)<EOL>", "docstring": "Sends a new message event to an Event Hub.", "id": "f39500:c0:m49"}
{"signature": "def create_event_hub(self, hub_name, hub=None, fail_on_exist=False):", "body": "_validate_not_none('<STR_LIT>', hub_name)<EOL>request = HTTPRequest()<EOL>request.method = '<STR_LIT>'<EOL>request.host = self._get_host()<EOL>request.path = '<STR_LIT:/>' + _str(hub_name) + '<STR_LIT>'<EOL>request.body = _get_request_body(_convert_event_hub_to_xml(hub))<EOL>request.path, request.query = self._httpclient._update_request_uri_query(request)  <EOL>request.headers = self._update_service_bus_header(request)<EOL>if not fail_on_exist:<EOL><INDENT>try:<EOL><INDENT>self._perform_request(request)<EOL>return True<EOL><DEDENT>except AzureHttpError as ex:<EOL><INDENT>_dont_fail_on_exist(ex)<EOL>return False<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self._perform_request(request)<EOL>return True<EOL><DEDENT>", "docstring": "Creates a new Event Hub.\n\nhub_name:\n    Name of event hub.\nhub:\n    Optional. Event hub properties. Instance of EventHub class.\nhub.message_retention_in_days:\n    Number of days to retain the events for this Event Hub.\nhub.status:\n    Status of the Event Hub (enabled or disabled).\nhub.user_metadata:\n    User metadata.\nhub.partition_count:\n    Number of shards on the Event Hub.\nfail_on_exist:\n    Specify whether to throw an exception when the event hub exists.", "id": "f39500:c0:m45"}
{"signature": "def get_queue(self, queue_name):", "body": "_validate_not_none('<STR_LIT>', queue_name)<EOL>request = HTTPRequest()<EOL>request.method = '<STR_LIT:GET>'<EOL>request.host = self._get_host()<EOL>request.path = '<STR_LIT:/>' + _str(queue_name) + '<STR_LIT>'<EOL>request.path, request.query = self._httpclient._update_request_uri_query(request)  <EOL>request.headers = self._update_service_bus_header(request)<EOL>response = self._perform_request(request)<EOL>return _convert_response_to_queue(response)<EOL>", "docstring": "Retrieves an existing queue.\n\nqueue_name:\n    Name of the queue.", "id": "f39500:c0:m15"}
{"signature": "def get_subscription(self, topic_name, subscription_name):", "body": "_validate_not_none('<STR_LIT>', topic_name)<EOL>_validate_not_none('<STR_LIT>', subscription_name)<EOL>request = HTTPRequest()<EOL>request.method = '<STR_LIT:GET>'<EOL>request.host = self._get_host()<EOL>request.path = '<STR_LIT:/>' +_str(topic_name) + '<STR_LIT>' + _str(subscription_name) + '<STR_LIT>'<EOL>request.path, request.query = self._httpclient._update_request_uri_query(request)  <EOL>request.headers = self._update_service_bus_header(request)<EOL>response = self._perform_request(request)<EOL>return _convert_response_to_subscription(response)<EOL>", "docstring": "Gets an existing subscription.\n\ntopic_name:\n    Name of the topic.\nsubscription_name:\n    Name of the subscription.", "id": "f39500:c0:m27"}
{"signature": "def send_topic_message_batch(self, topic_name, messages=None):", "body": "_validate_not_none('<STR_LIT>', topic_name)<EOL>_validate_not_none('<STR_LIT>', messages)<EOL>request = HTTPRequest()<EOL>request.method = '<STR_LIT:POST>'<EOL>request.host = self._get_host()<EOL>request.path = '<STR_LIT:/>' + _str(topic_name) + '<STR_LIT>'<EOL>request.headers.append(('<STR_LIT:Content-Type>', '<STR_LIT>'))<EOL>request.body = _get_request_body(json.dumps([m.as_batch_body() for m in messages]))<EOL>request.path, request.query = self._httpclient._update_request_uri_query(request)  <EOL>request.headers = self._update_service_bus_header(request)<EOL>self._perform_request(request)<EOL>", "docstring": "Sends a batch of messages into the specified topic. The limit to the number of\nmessages which may be present in the topic is governed by the message\nsize the MaxTopicSizeInMegaBytes. If this message will cause the topic\nto exceed its quota, a quota exceeded error is returned and the\nmessage will be rejected.\n\ntopic_name:\n    Name of the topic.\nmessages:\n    List of message objects containing message body and properties.", "id": "f39500:c0:m30"}
{"signature": "def create_queue(self, queue_name, queue=None, fail_on_exist=False):", "body": "_validate_not_none('<STR_LIT>', queue_name)<EOL>request = HTTPRequest()<EOL>request.method = '<STR_LIT>'<EOL>request.host = self._get_host()<EOL>request.path = '<STR_LIT:/>' + _str(queue_name) + '<STR_LIT>'<EOL>request.body = _get_request_body(_convert_queue_to_xml(queue))<EOL>request.path, request.query = self._httpclient._update_request_uri_query(request)  <EOL>request.headers = self._update_service_bus_header(request)<EOL>if not fail_on_exist:<EOL><INDENT>try:<EOL><INDENT>self._perform_request(request)<EOL>return True<EOL><DEDENT>except AzureHttpError as ex:<EOL><INDENT>_dont_fail_on_exist(ex)<EOL>return False<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self._perform_request(request)<EOL>return True<EOL><DEDENT>", "docstring": "Creates a new queue. Once created, this queue's resource manifest is\nimmutable.\n\nqueue_name:\n    Name of the queue to create.\nqueue:\n    Queue object to create.\nfail_on_exist:\n    Specify whether to throw an exception when the queue exists.", "id": "f39500:c0:m13"}
{"signature": "def with_filter(self, filter_func):", "body": "res = ServiceBusService(<EOL>service_namespace=self.service_namespace,<EOL>authentication=self.authentication)<EOL>old_filter = self._filter<EOL>def new_filter(request):<EOL><INDENT>return filter_func(request, old_filter)<EOL><DEDENT>res._filter = new_filter  <EOL>return res<EOL>", "docstring": "Returns a new service which will process requests with the specified\nfilter.  Filtering operations can include logging, automatic retrying,\netc...  The filter is a lambda which receives the HTTPRequest and\nanother lambda.  The filter can perform any pre-processing on the\nrequest, pass it off to the next lambda, and then perform any\npost-processing on the response.", "id": "f39500:c0:m9"}
{"signature": "def renew_lock_queue_message(self, queue_name, sequence_number, lock_token):", "body": "_validate_not_none('<STR_LIT>', queue_name)<EOL>_validate_not_none('<STR_LIT>', sequence_number)<EOL>_validate_not_none('<STR_LIT>', lock_token)<EOL>request = HTTPRequest()<EOL>request.method = '<STR_LIT:POST>'<EOL>request.host = self._get_host()<EOL>request.path = '<STR_LIT:/>' + _str(queue_name) +'<STR_LIT>' + _str(sequence_number) +'<STR_LIT:/>' + _str(lock_token) + '<STR_LIT>'<EOL>request.path, request.query = self._httpclient._update_request_uri_query(request)  <EOL>request.headers = self._update_service_bus_header(request)<EOL>self._perform_request(request)<EOL>", "docstring": "Renew lock on an already locked message on a given\nqueue. A message must have first been locked by a\nreceiver before this operation is called.\n\nqueue_name:\n    Name of the queue.\nsequence_number:\n    The sequence number of the message to be unlocked as returned in\n    BrokerProperties['SequenceNumber'] by the Peek Message operation.\nlock_token:\n    The ID of the lock as returned by the Peek Message operation in\n    BrokerProperties['LockToken']", "id": "f39500:c0:m40"}
{"signature": "def set_proxy(self, host, port, user=None, password=None):", "body": "self._httpclient.set_proxy(host, port, user, password)<EOL>", "docstring": "Sets the proxy server host and port for the HTTP CONNECT Tunnelling.\n\nhost:\n    Address of the proxy. Ex: '192.168.0.100'\nport:\n    Port of the proxy. Ex: 6000\nuser:\n    User for proxy authorization.\npassword:\n    Password for proxy authorization.", "id": "f39500:c0:m10"}
{"signature": "def renew_lock_subscription_message(self, topic_name, subscription_name,<EOL>sequence_number, lock_token):", "body": "_validate_not_none('<STR_LIT>', topic_name)<EOL>_validate_not_none('<STR_LIT>', subscription_name)<EOL>_validate_not_none('<STR_LIT>', sequence_number)<EOL>_validate_not_none('<STR_LIT>', lock_token)<EOL>request = HTTPRequest()<EOL>request.method = '<STR_LIT:POST>'<EOL>request.host = self._get_host()<EOL>request.path = '<STR_LIT:/>' + _str(topic_name) +'<STR_LIT>' + str(subscription_name) +'<STR_LIT>' + _str(sequence_number) +'<STR_LIT:/>' + _str(lock_token) + '<STR_LIT>'<EOL>request.path, request.query = self._httpclient._update_request_uri_query(request)  <EOL>request.headers = self._update_service_bus_header(request)<EOL>self._perform_request(request)<EOL>", "docstring": "Renew the lock on an already locked message on a given\nsubscription. A message must have first been locked by a\nreceiver before this operation is called.\n\ntopic_name:\n    Name of the topic.\nsubscription_name:\n    Name of the subscription.\nsequence_number:\n    The sequence number of the message to be unlocked as returned in\n    BrokerProperties['SequenceNumber'] by the Peek Message operation.\nlock_token:\n    The ID of the lock as returned by the Peek Message operation in\n    BrokerProperties['LockToken']", "id": "f39500:c0:m33"}
{"signature": "def update_event_hub(self, hub_name, hub=None):", "body": "_validate_not_none('<STR_LIT>', hub_name)<EOL>request = HTTPRequest()<EOL>request.method = '<STR_LIT>'<EOL>request.host = self._get_host()<EOL>request.path = '<STR_LIT:/>' + _str(hub_name) + '<STR_LIT>'<EOL>request.body = _get_request_body(_convert_event_hub_to_xml(hub))<EOL>request.path, request.query = self._httpclient._update_request_uri_query(request)  <EOL>request.headers.append(('<STR_LIT>', '<STR_LIT:*>'))<EOL>request.headers = self._update_service_bus_header(request)<EOL>response = self._perform_request(request)<EOL>return _convert_response_to_event_hub(response)<EOL>", "docstring": "Updates an Event Hub.\n\nhub_name:\n    Name of event hub.\nhub:\n    Optional. Event hub properties. Instance of EventHub class.\nhub.message_retention_in_days:\n    Number of days to retain the events for this Event Hub.", "id": "f39500:c0:m46"}
{"signature": "def send_queue_message_batch(self, queue_name, messages=None):", "body": "_validate_not_none('<STR_LIT>', queue_name)<EOL>_validate_not_none('<STR_LIT>', messages)<EOL>request = HTTPRequest()<EOL>request.method = '<STR_LIT:POST>'<EOL>request.host = self._get_host()<EOL>request.path = '<STR_LIT:/>' + _str(queue_name) + '<STR_LIT>'<EOL>request.headers.append(('<STR_LIT:Content-Type>', '<STR_LIT>'))<EOL>request.body = _get_request_body(json.dumps([m.as_batch_body() for m in messages]))<EOL>request.path, request.query = self._httpclient._update_request_uri_query(request)  <EOL>request.headers = self._update_service_bus_header(request)<EOL>self._perform_request(request)<EOL>", "docstring": "Sends a batch of messages into the specified queue. The limit to the number of\nmessages which may be present in the topic is governed by the message\nsize the MaxTopicSizeInMegaBytes. If this message will cause the queue\nto exceed its quota, a quota exceeded error is returned and the\nmessage will be rejected.\n\nqueue_name:\n    Name of the queue.\nmessages:\n    List of message objects containing message body and properties.", "id": "f39500:c0:m37"}
{"signature": "def list_queues(self):", "body": "request = HTTPRequest()<EOL>request.method = '<STR_LIT:GET>'<EOL>request.host = self._get_host()<EOL>request.path = '<STR_LIT>'<EOL>request.path, request.query = self._httpclient._update_request_uri_query(request)  <EOL>request.headers = self._update_service_bus_header(request)<EOL>response = self._perform_request(request)<EOL>return _ETreeXmlToObject.convert_response_to_feeds(<EOL>response, _convert_etree_element_to_queue)<EOL>", "docstring": "Enumerates the queues in the service namespace.", "id": "f39500:c0:m16"}
{"signature": "def renew_lock(self):", "body": "if self._queue_name:<EOL><INDENT>self.service_bus_service.renew_lock_queue_message(<EOL>self._queue_name,<EOL>self.broker_properties['<STR_LIT>'],<EOL>self.broker_properties['<STR_LIT>'])<EOL><DEDENT>elif self._topic_name and self._subscription_name:<EOL><INDENT>self.service_bus_service.renew_lock_subscription_message(<EOL>self._topic_name,<EOL>self._subscription_name,<EOL>self.broker_properties['<STR_LIT>'],<EOL>self.broker_properties['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>raise AzureServiceBusPeekLockError(_ERROR_MESSAGE_NOT_PEEK_LOCKED_ON_RENEW_LOCK)<EOL><DEDENT>", "docstring": "Renew lock on itself if find queue name or topic name and subscription\n        name.", "id": "f39501:c8:m3"}
{"signature": "def _convert_etree_element_to_subscription(entry_element):", "body": "subscription = Subscription()<EOL>subscription_element = entry_element.find('<STR_LIT>', _etree_sb_feed_namespaces)<EOL>if subscription_element is not None:<EOL><INDENT>mappings = [<EOL>('<STR_LIT>', '<STR_LIT>', None),<EOL>('<STR_LIT>', '<STR_LIT>', _parse_bool),<EOL>('<STR_LIT>', '<STR_LIT>', None),<EOL>('<STR_LIT>', '<STR_LIT>', _parse_bool),  <EOL>('<STR_LIT>', '<STR_LIT>', _parse_bool),<EOL>('<STR_LIT>', '<STR_LIT>', _parse_bool),<EOL>('<STR_LIT>', '<STR_LIT>', int),<EOL>('<STR_LIT>', '<STR_LIT>', int),<EOL>]<EOL>for mapping in mappings:<EOL><INDENT>_read_etree_element(subscription_element, mapping[<NUM_LIT:0>], subscription, mapping[<NUM_LIT:1>], mapping[<NUM_LIT:2>])<EOL><DEDENT><DEDENT>for name, value in _ETreeXmlToObject.get_entry_properties_from_element(<EOL>entry_element, True, '<STR_LIT>').items():<EOL><INDENT>setattr(subscription, name, value)<EOL><DEDENT>return subscription<EOL>", "docstring": "Converts entry element to subscription\n\n    The xml format for subscription:\n<entry xmlns='http://www.w3.org/2005/Atom'>\n    <content type='application/xml'>\n    <SubscriptionDescription\n        xmlns:i=\"http://www.w3.org/2001/XMLSchema-instance\"\n        xmlns=\"http://schemas.microsoft.com/netservices/2010/10/servicebus/connect\">\n        <LockDuration>PT5M</LockDuration>\n        <RequiresSession>false</RequiresSession>\n        <DefaultMessageTimeToLive>P10675199DT2H48M5.4775807S</DefaultMessageTimeToLive>\n        <DeadLetteringOnMessageExpiration>false</DeadLetteringOnMessageExpiration>\n        <DeadLetteringOnFilterEvaluationExceptions>true</DeadLetteringOnFilterEvaluationExceptions>\n    </SubscriptionDescription>\n    </content>\n</entry>", "id": "f39502:m11"}
{"signature": "def _service_bus_error_handler(http_error):", "body": "return _general_error_handler(http_error)<EOL>", "docstring": "Simple error handler for Service Bus service.", "id": "f39502:m19"}
{"signature": "def _create_message(response, service_instance):", "body": "respbody = response.body<EOL>custom_properties = {}<EOL>broker_properties = None<EOL>message_type = None<EOL>message_location = None<EOL>for name, value in response.headers:<EOL><INDENT>if name.lower() == '<STR_LIT>':<EOL><INDENT>broker_properties = json.loads(value)<EOL><DEDENT>elif name.lower() == '<STR_LIT>':<EOL><INDENT>message_type = value<EOL><DEDENT>elif name.lower() == '<STR_LIT:location>':<EOL><INDENT>message_location = value<EOL><DEDENT>elif name.lower() not in ['<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT:date>',<EOL>'<STR_LIT>']:<EOL><INDENT>if '<STR_LIT:\">' in value:<EOL><INDENT>value = value[<NUM_LIT:1>:-<NUM_LIT:1>].replace('<STR_LIT>', '<STR_LIT:\">')<EOL>try:<EOL><INDENT>custom_properties[name] = datetime.strptime(<EOL>value, '<STR_LIT>')<EOL><DEDENT>except ValueError:<EOL><INDENT>custom_properties[name] = value<EOL><DEDENT><DEDENT>elif value.lower() == '<STR_LIT:true>':<EOL><INDENT>custom_properties[name] = True<EOL><DEDENT>elif value.lower() == '<STR_LIT:false>':<EOL><INDENT>custom_properties[name] = False<EOL><DEDENT>else:  <EOL><INDENT>try:<EOL><INDENT>float_value = float(value)<EOL>if str(int(float_value)) == value:<EOL><INDENT>custom_properties[name] = int(value)<EOL><DEDENT>else:<EOL><INDENT>custom_properties[name] = float_value<EOL><DEDENT><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT><DEDENT><DEDENT>if message_type is None:<EOL><INDENT>message = Message(<EOL>respbody, service_instance, message_location, custom_properties,<EOL>'<STR_LIT>', broker_properties)<EOL><DEDENT>else:<EOL><INDENT>message = Message(respbody, service_instance, message_location,<EOL>custom_properties, message_type, broker_properties)<EOL><DEDENT>return message<EOL>", "docstring": "Create message from response.\n\n    response:\n        response from Service Bus cloud server.\n    service_instance:\n        the Service Bus client.", "id": "f39502:m0"}
{"signature": "def schedule(self, schedule_time, *messages):", "body": "for message in messages:<EOL><INDENT>if not self.session_id and not message.properties.group_id:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT><DEDENT>return super(SessionSender, self).schedule(schedule_time, *messages)<EOL>", "docstring": "Send one or more messages to be enqueued at a specific time.\n\n        Returns a list of the sequence numbers of the enqueued messages.\n\n        :param schedule_time: The date and time to enqueue the messages.\n        :type schedule_time: ~datetime.datetime\n        :param messages: The messages to schedule.\n        :type messages: ~azure.servicebus.common.message.Message\n        :rtype: list[int]\n\n        Example:\n            .. literalinclude:: ../examples/test_examples.py\n                :start-after: [START scheduling_messages]\n                :end-before: [END scheduling_messages]\n                :language: python\n                :dedent: 4\n                :caption: Schedule a message to be sent in future", "id": "f39504:c1:m2"}
{"signature": "def send(self, message):", "body": "if not isinstance(message, Message):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if not self.running:<EOL><INDENT>self.open()<EOL><DEDENT>if self.session_id and not message.properties.group_id:<EOL><INDENT>message.properties.group_id = self.session_id<EOL><DEDENT>try:<EOL><INDENT>self._handler.send_message(message.message)<EOL><DEDENT>except Exception as e:<EOL><INDENT>raise MessageSendFailed(e)<EOL><DEDENT>", "docstring": "Send a message and blocks until acknowledgement is received or the operation fails.\n\n        :param message: The message to be sent.\n        :type message: ~azure.servicebus.common.message.Message\n        :raises: ~azure.servicebus.common.errors.MessageSendFailed if the message fails to send.\n\n        Example:\n            .. literalinclude:: ../examples/test_examples.py\n                :start-after: [START send_message]\n                :end-before: [END send_message]\n                :language: python\n                :dedent: 4\n                :caption: Send a message and block", "id": "f39504:c0:m2"}
{"signature": "def send(self, message):", "body": "if not isinstance(message, Message):<EOL><INDENT>raise TypeError(\"<STR_LIT>\")<EOL><DEDENT>if not self.session_id and not message.properties.group_id:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>super(SessionSender, self).send(message)<EOL>", "docstring": "Send a message and blocks until acknowledgement is received or the operation fails.\n\n        If neither the Sender nor the message has a session ID, a `ValueError` will be raised.\n\n        :param message: The message to be sent.\n        :type message: ~azure.servicebus.common.message.Message\n        :raises: ~azure.servicebus.common.errors.MessageSendFailed if the message fails to\n         send.\n        :raises: ValueError if there is no session ID specified.\n\n        Example:\n            .. literalinclude:: ../examples/test_examples.py\n                :start-after: [START send_message]\n                :end-before: [END send_message]\n                :language: python\n                :dedent: 4\n                :caption: Send a message and block", "id": "f39504:c1:m0"}
{"signature": "def cancel_scheduled_messages(self, *sequence_numbers):", "body": "if not self.running:<EOL><INDENT>self.open()<EOL><DEDENT>numbers = [types.AMQPLong(s) for s in sequence_numbers]<EOL>request_body = {'<STR_LIT>': types.AMQPArray(numbers)}<EOL>return self._mgmt_request_response(<EOL>REQUEST_RESPONSE_CANCEL_SCHEDULED_MESSAGE_OPERATION,<EOL>request_body,<EOL>mgmt_handlers.default)<EOL>", "docstring": "Cancel one or more messages that have previsouly been scheduled and are still pending.\n\n        :param sequence_numbers: The seqeuence numbers of the scheduled messages.\n        :type sequence_numbers: int\n\n        Example:\n            .. literalinclude:: ../examples/test_examples.py\n                :start-after: [START cancel_scheduled_messages]\n                :end-before: [END cancel_scheduled_messages]\n                :language: python\n                :dedent: 4\n                :caption: Cancelling messages scheduled to be sent in future", "id": "f39504:c0:m4"}
{"signature": "def queue_message(self, message):", "body": "if not self.running:<EOL><INDENT>self.open()<EOL><DEDENT>if self.session_id and not message.properties.group_id:<EOL><INDENT>message.properties.group_id = self.session_id<EOL><DEDENT>self._handler.queue_message(message.message)<EOL>", "docstring": "Queue a message to be sent later.\n\n        This operation should be followed up with send_pending_messages.\n\n        :param message: The message to be sent.\n        :type message: ~azure.servicebus.common.message.Message\n\n        Example:\n            .. literalinclude:: ../examples/test_examples.py\n                :start-after: [START queue_and_send_messages]\n                :end-before: [END queue_and_send_messages]\n                :language: python\n                :dedent: 4\n                :caption: Send the queued messages\n                :name: sender_queue", "id": "f39505:c3:m1"}
{"signature": "def __init__(self, address, name, shared_access_key_name=None,<EOL>shared_access_key_value=None, debug=False, **kwargs):", "body": "self.container_id = \"<STR_LIT>\" + str(uuid.uuid4())[:<NUM_LIT:8>]<EOL>self.address = urlparse(address)<EOL>self.name = name<EOL>self.debug = debug<EOL>self.encoding = '<STR_LIT>'<EOL>self.connection = None<EOL>self.entity = kwargs.get('<STR_LIT>')<EOL>self.properties = dict(self.entity) if self.entity else {}<EOL>self.requires_session = self.properties.get('<STR_LIT>', False)<EOL>namespace, _, host_base = self.address.hostname.partition('<STR_LIT:.>')<EOL>url_username = unquote_plus(self.address.username) if self.address.username else None<EOL>shared_access_key_name = shared_access_key_name or url_username<EOL>url_password = unquote_plus(self.address.password) if self.address.password else None<EOL>shared_access_key_value = shared_access_key_value or url_password<EOL>if not shared_access_key_name or not shared_access_key_value:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>self.entity_uri = \"<STR_LIT>\".format(self.address.hostname, self.address.path)<EOL>self.auth_config = {<EOL>'<STR_LIT>': \"<STR_LIT>\".format(self.address.hostname, self.address.path),<EOL>'<STR_LIT>': shared_access_key_name,<EOL>'<STR_LIT>': shared_access_key_value}<EOL>self.mgmt_client = kwargs.get('<STR_LIT>') or ServiceBusService(<EOL>service_namespace=namespace,<EOL>shared_access_key_name=shared_access_key_name,<EOL>shared_access_key_value=shared_access_key_value,<EOL>host_base=\"<STR_LIT:.>\" + host_base)<EOL>", "docstring": "Construct a new Client to interact with the named Service Bus entity.\n\n        :param address: The full URI of the Service Bus namespace. This can optionally\n         include URL-encoded access name and key.\n        :type address: str\n        :param name: The name of the entity to which the Client will connect.\n        :type name: str\n        :param shared_access_key_name: The name of the shared access policy. This must be supplied\n         if not encoded into the address.\n        :type shared_access_key_name: str\n        :param shared_access_key_value: The shared access key. This must be supplied if not encoded\n         into the address.\n        :type shared_access_key_value: str\n        :param debug: Whether to output network trace logs to the logger. Default is `False`.\n        :type debug: bool", "id": "f39505:c1:m0"}
{"signature": "def defer(self):", "body": "raise ValueError(\"<STR_LIT>\")<EOL>", "docstring": "A DeferredMessage cannot be deferred. Raises `ValueError`.", "id": "f39509:c3:m7"}
{"signature": "@user_properties.setter<EOL><INDENT>def user_properties(self, value):<DEDENT>", "body": "self.message.application_properties = value<EOL>", "docstring": "User defined properties on the message.\n\n        :param value: The application properties for the Message.\n        :type value: dict", "id": "f39509:c0:m8"}
{"signature": "def complete(self):", "body": "self._is_live('<STR_LIT>')<EOL>self._receiver._settle_deferred('<STR_LIT>', [self.lock_token])  <EOL>self._settled = True<EOL>", "docstring": "Complete the message.\n\n        This removes the message from the queue.\n\n        :raises: ~azure.servicebus.common.errors.MessageAlreadySettled if the message has been settled.\n        :raises: ~azure.servicebus.common.errors.MessageLockExpired if message lock has already expired.\n        :raises: ~azure.servicebus.common.errors.SessionLockExpired if session lock has already expired.\n        :raises: ~azure.servicebus.common.errors.MessageSettleFailed if message settle operation fails.", "id": "f39509:c3:m4"}
{"signature": "@property<EOL><INDENT>def body(self):<DEDENT>", "body": "return self.message.get_data()<EOL>", "docstring": "The body of the Message.\n\n        :rtype: bytes or generator[bytes]", "id": "f39509:c0:m26"}
{"signature": "def complete(self):", "body": "self._is_live('<STR_LIT>')<EOL>try:<EOL><INDENT>self.message.accept()<EOL><DEDENT>except Exception as e:<EOL><INDENT>raise MessageSettleFailed(\"<STR_LIT>\", e)<EOL><DEDENT>", "docstring": "Complete the message.\n\n        This removes the message from the queue.\n\n        :raises: ~azure.servicebus.common.errors.MessageAlreadySettled if the message has been settled.\n        :raises: ~azure.servicebus.common.errors.MessageLockExpired if message lock has already expired.\n        :raises: ~azure.servicebus.common.errors.SessionLockExpired if session lock has already expired.\n        :raises: ~azure.servicebus.common.errors.MessageSettleFailed if message settle operation fails.", "id": "f39509:c0:m29"}
{"signature": "def regenerate_keys(<EOL>self, resource_group_name, spatial_anchors_account_name, serial=<NUM_LIT:1>, custom_headers=None, raw=False, **operation_config):", "body": "spatial_anchors_account_key_regenerate = models.SpatialAnchorsAccountKeyRegenerateRequest(serial=serial)<EOL>url = self.regenerate_keys.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", spatial_anchors_account_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(spatial_anchors_account_key_regenerate, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Regenerate 1 Key of a Spatial Anchors Account.\n\n        :param resource_group_name: Name of an Azure resource group.\n        :type resource_group_name: str\n        :param spatial_anchors_account_name: Name of an Mixed Reality Spatial\n         Anchors Account.\n        :type spatial_anchors_account_name: str\n        :param serial: serial of key to be regenerated\n        :type serial: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SpatialAnchorsAccountKeys or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.mixedreality.models.SpatialAnchorsAccountKeys or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.mixedreality.models.ErrorResponseException>`", "id": "f39536:c0:m8"}
{"signature": "def delete(<EOL>self, resource_group_name, spatial_anchors_account_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", spatial_anchors_account_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Delete a Spatial Anchors Account.\n\n        :param resource_group_name: Name of an Azure resource group.\n        :type resource_group_name: str\n        :param spatial_anchors_account_name: Name of an Mixed Reality Spatial\n         Anchors Account.\n        :type spatial_anchors_account_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.mixedreality.models.ErrorResponseException>`", "id": "f39536:c0:m3"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SpatialAnchorsAccountPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SpatialAnchorsAccountPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List Resources by Resource Group.\n\n        :param resource_group_name: Name of an Azure resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of SpatialAnchorsAccount\n        :rtype:\n         ~azure.mgmt.mixedreality.models.SpatialAnchorsAccountPaged[~azure.mgmt.mixedreality.models.SpatialAnchorsAccount]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.mixedreality.models.ErrorResponseException>`", "id": "f39536:c0:m2"}
{"signature": "def get_by_id(<EOL>self, smart_group_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_by_id.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", smart_group_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>header_dict = {}<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>header_dict = {<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>}<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>client_raw_response.add_headers(header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get information of smart alerts group.\n\n        Get details of smart group.\n\n        :param smart_group_id: Smart group unique id.\n        :type smart_group_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SmartGroup or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.alertsmanagement.models.SmartGroup or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.alertsmanagement.models.ErrorResponseException>`", "id": "f39587:c0:m2"}
{"signature": "def get_all(<EOL>self, target_resource=None, target_resource_group=None, target_resource_type=None, monitor_service=None, monitor_condition=None, severity=None, smart_group_state=None, time_range=None, page_count=None, sort_by=None, sort_order=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if target_resource is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", target_resource, '<STR_LIT:str>')<EOL><DEDENT>if target_resource_group is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", target_resource_group, '<STR_LIT:str>')<EOL><DEDENT>if target_resource_type is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", target_resource_type, '<STR_LIT:str>')<EOL><DEDENT>if monitor_service is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", monitor_service, '<STR_LIT:str>')<EOL><DEDENT>if monitor_condition is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", monitor_condition, '<STR_LIT:str>')<EOL><DEDENT>if severity is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", severity, '<STR_LIT:str>')<EOL><DEDENT>if smart_group_state is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", smart_group_state, '<STR_LIT:str>')<EOL><DEDENT>if time_range is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", time_range, '<STR_LIT:str>')<EOL><DEDENT>if page_count is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", page_count, '<STR_LIT:int>')<EOL><DEDENT>if sort_by is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", sort_by, '<STR_LIT:str>')<EOL><DEDENT>if sort_order is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", sort_order, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get all smartGroups within the subscription.\n\n        List all the smartGroups within the specified subscription. .\n\n        :param target_resource: Filter by target resource( which is full ARM\n         ID) Default value is select all.\n        :type target_resource: str\n        :param target_resource_group: Filter by target resource group name.\n         Default value is select all.\n        :type target_resource_group: str\n        :param target_resource_type: Filter by target resource type. Default\n         value is select all.\n        :type target_resource_type: str\n        :param monitor_service: Filter by monitor service which is the source\n         of the alert instance. Default value is select all. Possible values\n         include: 'Application Insights', 'ActivityLog Administrative',\n         'ActivityLog Security', 'ActivityLog Recommendation', 'ActivityLog\n         Policy', 'ActivityLog Autoscale', 'Log Analytics', 'Nagios',\n         'Platform', 'SCOM', 'ServiceHealth', 'SmartDetector', 'VM Insights',\n         'Zabbix'\n        :type monitor_service: str or\n         ~azure.mgmt.alertsmanagement.models.MonitorService\n        :param monitor_condition: Filter by monitor condition which is the\n         state of the  monitor(alertRule) at monitor service. Default value is\n         to select all. Possible values include: 'Fired', 'Resolved'\n        :type monitor_condition: str or\n         ~azure.mgmt.alertsmanagement.models.MonitorCondition\n        :param severity: Filter by severity.  Defaut value is select all.\n         Possible values include: 'Sev0', 'Sev1', 'Sev2', 'Sev3', 'Sev4'\n        :type severity: str or ~azure.mgmt.alertsmanagement.models.Severity\n        :param smart_group_state: Filter by state of the smart group. Default\n         value is to select all. Possible values include: 'New',\n         'Acknowledged', 'Closed'\n        :type smart_group_state: str or\n         ~azure.mgmt.alertsmanagement.models.AlertState\n        :param time_range: Filter by time range by below listed values.\n         Default value is 1 day. Possible values include: '1h', '1d', '7d',\n         '30d'\n        :type time_range: str or ~azure.mgmt.alertsmanagement.models.TimeRange\n        :param page_count: Determines number of alerts returned per page in\n         response. Permissible value is between 1 to 250. When the\n         \"includeContent\"  filter is selected, maximum value allowed is 25.\n         Default value is 25.\n        :type page_count: int\n        :param sort_by: Sort the query results by input field  Default value\n         is sort by 'lastModifiedDateTime'. Possible values include:\n         'alertsCount', 'state', 'severity', 'startDateTime',\n         'lastModifiedDateTime'\n        :type sort_by: str or\n         ~azure.mgmt.alertsmanagement.models.SmartGroupsSortByFields\n        :param sort_order: Sort the query results order in either ascending or\n         descending.  Default value is 'desc' for time fields and 'asc' for\n         others. Possible values include: 'asc', 'desc'\n        :type sort_order: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SmartGroupsList or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.alertsmanagement.models.SmartGroupsList or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.alertsmanagement.models.ErrorResponseException>`", "id": "f39587:c0:m1"}
{"signature": "def get_history(<EOL>self, smart_group_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_history.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", smart_group_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the history of the changes of smart group.\n\n        :param smart_group_id: Smart group unique id.\n        :type smart_group_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SmartGroupModification or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.alertsmanagement.models.SmartGroupModification or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.alertsmanagement.models.ErrorResponseException>`", "id": "f39587:c0:m4"}
{"signature": "def get_by_id(<EOL>self, alert_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_by_id.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", alert_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get a specific alert.\n\n        Get information related to a specific alert.\n\n        :param alert_id: Unique ID of an alert instance.\n        :type alert_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Alert or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.alertsmanagement.models.Alert or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.alertsmanagement.models.ErrorResponseException>`", "id": "f39589:c0:m2"}
{"signature": "def change_state(<EOL>self, alert_id, new_state, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.change_state.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", alert_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", new_state, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Change the state of the alert.\n\n        :param alert_id: Unique ID of an alert instance.\n        :type alert_id: str\n        :param new_state: New state of the alert. Possible values include:\n         'New', 'Acknowledged', 'Closed'\n        :type new_state: str or ~azure.mgmt.alertsmanagement.models.AlertState\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Alert or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.alertsmanagement.models.Alert or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.alertsmanagement.models.ErrorResponseException>`", "id": "f39589:c0:m3"}
{"signature": "def get_all(<EOL>self, target_resource=None, target_resource_type=None, target_resource_group=None, monitor_service=None, monitor_condition=None, severity=None, alert_state=None, alert_rule=None, smart_group_id=None, include_context=None, include_egress_config=None, page_count=None, sort_by=None, sort_order=None, select=None, time_range=None, custom_time_range=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.get_all.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if target_resource is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", target_resource, '<STR_LIT:str>')<EOL><DEDENT>if target_resource_type is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", target_resource_type, '<STR_LIT:str>')<EOL><DEDENT>if target_resource_group is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", target_resource_group, '<STR_LIT:str>')<EOL><DEDENT>if monitor_service is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", monitor_service, '<STR_LIT:str>')<EOL><DEDENT>if monitor_condition is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", monitor_condition, '<STR_LIT:str>')<EOL><DEDENT>if severity is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", severity, '<STR_LIT:str>')<EOL><DEDENT>if alert_state is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", alert_state, '<STR_LIT:str>')<EOL><DEDENT>if alert_rule is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", alert_rule, '<STR_LIT:str>')<EOL><DEDENT>if smart_group_id is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", smart_group_id, '<STR_LIT:str>')<EOL><DEDENT>if include_context is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", include_context, '<STR_LIT:bool>')<EOL><DEDENT>if include_egress_config is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", include_egress_config, '<STR_LIT:bool>')<EOL><DEDENT>if page_count is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", page_count, '<STR_LIT:int>')<EOL><DEDENT>if sort_by is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", sort_by, '<STR_LIT:str>')<EOL><DEDENT>if sort_order is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", sort_order, '<STR_LIT:str>')<EOL><DEDENT>if select is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", select, '<STR_LIT:str>')<EOL><DEDENT>if time_range is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", time_range, '<STR_LIT:str>')<EOL><DEDENT>if custom_time_range is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", custom_time_range, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.AlertPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.AlertPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List all the existing alerts, where the results can be selective by\n        passing multiple filter parameters including time range and sorted on\n        specific fields. .\n\n        :param target_resource: Filter by target resource( which is full ARM\n         ID) Default value is select all.\n        :type target_resource: str\n        :param target_resource_type: Filter by target resource type. Default\n         value is select all.\n        :type target_resource_type: str\n        :param target_resource_group: Filter by target resource group name.\n         Default value is select all.\n        :type target_resource_group: str\n        :param monitor_service: Filter by monitor service which is the source\n         of the alert instance. Default value is select all. Possible values\n         include: 'Application Insights', 'ActivityLog Administrative',\n         'ActivityLog Security', 'ActivityLog Recommendation', 'ActivityLog\n         Policy', 'ActivityLog Autoscale', 'Log Analytics', 'Nagios',\n         'Platform', 'SCOM', 'ServiceHealth', 'SmartDetector', 'VM Insights',\n         'Zabbix'\n        :type monitor_service: str or\n         ~azure.mgmt.alertsmanagement.models.MonitorService\n        :param monitor_condition: Filter by monitor condition which is the\n         state of the  monitor(alertRule) at monitor service. Default value is\n         to select all. Possible values include: 'Fired', 'Resolved'\n        :type monitor_condition: str or\n         ~azure.mgmt.alertsmanagement.models.MonitorCondition\n        :param severity: Filter by severity.  Defaut value is select all.\n         Possible values include: 'Sev0', 'Sev1', 'Sev2', 'Sev3', 'Sev4'\n        :type severity: str or ~azure.mgmt.alertsmanagement.models.Severity\n        :param alert_state: Filter by state of the alert instance. Default\n         value is to select all. Possible values include: 'New',\n         'Acknowledged', 'Closed'\n        :type alert_state: str or\n         ~azure.mgmt.alertsmanagement.models.AlertState\n        :param alert_rule: Filter by alert rule(monitor) which fired alert\n         instance.  Default value is to select all.\n        :type alert_rule: str\n        :param smart_group_id: Filter the alerts list by the Smart Group Id.\n         Default value is none.\n        :type smart_group_id: str\n        :param include_context: Include context which has data contextual to\n         the monitor service. Default value is false'\n        :type include_context: bool\n        :param include_egress_config: Include egress config which would be\n         used for displaying the content in portal.  Default value is 'false'.\n        :type include_egress_config: bool\n        :param page_count: Determines number of alerts returned per page in\n         response. Permissible value is between 1 to 250. When the\n         \"includeContent\"  filter is selected, maximum value allowed is 25.\n         Default value is 25.\n        :type page_count: int\n        :param sort_by: Sort the query results by input field,  Default value\n         is 'lastModifiedDateTime'. Possible values include: 'name',\n         'severity', 'alertState', 'monitorCondition', 'targetResource',\n         'targetResourceName', 'targetResourceGroup', 'targetResourceType',\n         'startDateTime', 'lastModifiedDateTime'\n        :type sort_by: str or\n         ~azure.mgmt.alertsmanagement.models.AlertsSortByFields\n        :param sort_order: Sort the query results order in either ascending or\n         descending.  Default value is 'desc' for time fields and 'asc' for\n         others. Possible values include: 'asc', 'desc'\n        :type sort_order: str\n        :param select: This filter allows to selection of the fields(comma\n         seperated) which would  be part of the the essential section. This\n         would allow to project only the  required fields rather than getting\n         entire content.  Default is to fetch all the fields in the essentials\n         section.\n        :type select: str\n        :param time_range: Filter by time range by below listed values.\n         Default value is 1 day. Possible values include: '1h', '1d', '7d',\n         '30d'\n        :type time_range: str or ~azure.mgmt.alertsmanagement.models.TimeRange\n        :param custom_time_range: Filter by custom time range in the format\n         <start-time>/<end-time>  where time is in (ISO-8601 format)'.\n         Permissible values is within 30 days from  query time. Either\n         timeRange or customTimeRange could be used but not both. Default is\n         none.\n        :type custom_time_range: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Alert\n        :rtype:\n         ~azure.mgmt.alertsmanagement.models.AlertPaged[~azure.mgmt.alertsmanagement.models.Alert]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.alertsmanagement.models.ErrorResponseException>`", "id": "f39589:c0:m1"}
{"signature": "def get_history(<EOL>self, alert_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_history.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", alert_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the history of the changes of an alert.\n\n        :param alert_id: Unique ID of an alert instance.\n        :type alert_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: AlertModification or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.alertsmanagement.models.AlertModification or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.alertsmanagement.models.ErrorResponseException>`", "id": "f39589:c0:m4"}
{"signature": "def use(self, profile):", "body": "if not isinstance(profile, (KnownProfiles, ProfileDefinition)):<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>type(self).profile = profile<EOL>", "docstring": "Define a new default profile.", "id": "f39597:c1:m0"}
{"signature": "def get_cli_active_cloud():", "body": "try:<EOL><INDENT>from azure.cli.core.cloud import get_active_cloud<EOL><DEDENT>except ImportError:<EOL><INDENT>raise ImportError(\"<STR_LIT>\")<EOL><DEDENT>return get_active_cloud()<EOL>", "docstring": "Return a CLI active cloud.\n\n    .. versionadded:: 1.1.6\n\n    :return: A CLI Cloud\n    :rtype: azure.cli.core.cloud.Cloud\n    :raises: ImportError if azure-cli-core package is not available", "id": "f39601:m0"}
{"signature": "def _instantiate_client(client_class, **kwargs):", "body": "args = get_arg_spec(client_class.__init__).args<EOL>for key in ['<STR_LIT>', '<STR_LIT>']:<EOL><INDENT>if key not in kwargs:<EOL><INDENT>continue<EOL><DEDENT>if key not in args:<EOL><INDENT>del kwargs[key]<EOL><DEDENT>elif sys.version_info < (<NUM_LIT:3>, <NUM_LIT:0>) and isinstance(kwargs[key], unicode):<EOL><INDENT>kwargs[key] = kwargs[key].encode('<STR_LIT:utf-8>')<EOL><DEDENT><DEDENT>return client_class(**kwargs)<EOL>", "docstring": "Instantiate a client from kwargs, removing the subscription_id/tenant_id argument if unsupported.", "id": "f39602:m0"}
{"signature": "def get_client_from_cli_profile(client_class, **kwargs):", "body": "cloud = get_cli_active_cloud()<EOL>parameters = {}<EOL>if '<STR_LIT>' not in kwargs or '<STR_LIT>' not in kwargs:<EOL><INDENT>resource, _ = _client_resource(client_class, cloud)<EOL>credentials, subscription_id, tenant_id = get_azure_cli_credentials(resource=resource,<EOL>with_tenant=True)<EOL>parameters.update({<EOL>'<STR_LIT>': kwargs.get('<STR_LIT>', credentials),<EOL>'<STR_LIT>': kwargs.get('<STR_LIT>', subscription_id)<EOL>})<EOL><DEDENT>args = get_arg_spec(client_class.__init__).args<EOL>if '<STR_LIT>' in args and '<STR_LIT>' not in kwargs:  <EOL><INDENT>parameters['<STR_LIT>'] = cloud.suffixes.azure_datalake_analytics_catalog_and_job_endpoint<EOL><DEDENT>elif '<STR_LIT>' in args and '<STR_LIT>' not in kwargs:<EOL><INDENT>_, base_url = _client_resource(client_class, cloud)<EOL>if base_url:<EOL><INDENT>parameters['<STR_LIT>'] = base_url<EOL><DEDENT>else:<EOL><INDENT>parameters['<STR_LIT>'] = cloud.endpoints.resource_manager<EOL><DEDENT><DEDENT>if '<STR_LIT>' in args and '<STR_LIT>' not in kwargs:<EOL><INDENT>parameters['<STR_LIT>'] = tenant_id<EOL><DEDENT>parameters.update(kwargs)<EOL>return _instantiate_client(client_class, **parameters)<EOL>", "docstring": "Return a SDK client initialized with current CLI credentials, CLI default subscription and CLI default cloud.\n\n    This method will fill automatically the following client parameters:\n    - credentials\n    - subscription_id\n    - base_url\n\n    Parameters provided in kwargs will override CLI parameters and be passed directly to the client.\n\n    :Example:\n\n    .. code:: python\n\n        from azure.common.client_factory import get_client_from_cli_profile\n        from azure.mgmt.compute import ComputeManagementClient\n        client = get_client_from_cli_profile(ComputeManagementClient)\n\n    .. versionadded:: 1.1.6\n\n    :param client_class: A SDK client class\n    :return: An instantiated client\n    :raises: ImportError if azure-cli-core package is not available", "id": "f39602:m2"}
{"signature": "def get_client_from_json_dict(client_class, config_dict, **kwargs):", "body": "is_graphrbac = client_class.__name__ == '<STR_LIT>'<EOL>parameters = {<EOL>'<STR_LIT>': config_dict.get('<STR_LIT>'),<EOL>'<STR_LIT>': config_dict.get('<STR_LIT>'),<EOL>'<STR_LIT>': config_dict.get('<STR_LIT>')  <EOL>}<EOL>if is_graphrbac:<EOL><INDENT>parameters['<STR_LIT>'] = config_dict['<STR_LIT>']<EOL><DEDENT>if '<STR_LIT>' not in kwargs:<EOL><INDENT>if is_graphrbac:<EOL><INDENT>resource = config_dict['<STR_LIT>']<EOL><DEDENT>else:<EOL><INDENT>if \"<STR_LIT>\" not in config_dict and '<STR_LIT>' not in config_dict:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>resource = config_dict.get('<STR_LIT>', config_dict['<STR_LIT>'])<EOL><DEDENT>authority_url = config_dict['<STR_LIT>']<EOL>is_adfs = bool(re.match('<STR_LIT>', authority_url, re.I))<EOL>if is_adfs:<EOL><INDENT>authority_url = authority_url.rstrip('<STR_LIT:/>')  <EOL><DEDENT>else:<EOL><INDENT>authority_url = authority_url + '<STR_LIT:/>' + config_dict['<STR_LIT>']<EOL><DEDENT>context = adal.AuthenticationContext(<EOL>authority_url,<EOL>api_version=None,<EOL>validate_authority=not is_adfs<EOL>)<EOL>parameters['<STR_LIT>'] = AdalAuthentication(<EOL>context.acquire_token_with_client_credentials,<EOL>resource,<EOL>config_dict['<STR_LIT>'],<EOL>config_dict['<STR_LIT>']<EOL>)<EOL><DEDENT>parameters.update(kwargs)<EOL>return _instantiate_client(client_class, **parameters)<EOL>", "docstring": "Return a SDK client initialized with a JSON auth dict.\n\n    The easiest way to obtain this content is to call the following CLI commands:\n\n    .. code:: bash\n\n        az ad sp create-for-rbac --sdk-auth\n\n    This method will fill automatically the following client parameters:\n    - credentials\n    - subscription_id\n    - base_url\n    - tenant_id\n\n    Parameters provided in kwargs will override parameters and be passed directly to the client.\n\n    :Example:\n\n    .. code:: python\n\n        from azure.common.client_factory import get_client_from_auth_file\n        from azure.mgmt.compute import ComputeManagementClient\n        config_dict = {\n            \"clientId\": \"ad735158-65ca-11e7-ba4d-ecb1d756380e\",\n            \"clientSecret\": \"b70bb224-65ca-11e7-810c-ecb1d756380e\",\n            \"subscriptionId\": \"bfc42d3a-65ca-11e7-95cf-ecb1d756380e\",\n            \"tenantId\": \"c81da1d8-65ca-11e7-b1d1-ecb1d756380e\",\n            \"activeDirectoryEndpointUrl\": \"https://login.microsoftonline.com\",\n            \"resourceManagerEndpointUrl\": \"https://management.azure.com/\",\n            \"activeDirectoryGraphResourceId\": \"https://graph.windows.net/\",\n            \"sqlManagementEndpointUrl\": \"https://management.core.windows.net:8443/\",\n            \"galleryEndpointUrl\": \"https://gallery.azure.com/\",\n            \"managementEndpointUrl\": \"https://management.core.windows.net/\"\n        }\n        client = get_client_from_json_dict(ComputeManagementClient, config_dict)\n\n    .. versionadded:: 1.1.7\n\n    :param client_class: A SDK client class\n    :param dict config_dict: A config dict.\n    :return: An instantiated client", "id": "f39602:m3"}
{"signature": "def get_client_from_auth_file(client_class, auth_path=None, **kwargs):", "body": "auth_path = auth_path or os.environ['<STR_LIT>']<EOL>with io.open(auth_path, '<STR_LIT:r>', encoding='<STR_LIT>') as auth_fd:<EOL><INDENT>config_dict = json.load(auth_fd)<EOL><DEDENT>return get_client_from_json_dict(client_class, config_dict, **kwargs)<EOL>", "docstring": "Return a SDK client initialized with auth file.\n\n    The easiest way to obtain this file is to call the following CLI commands:\n\n    .. code:: bash\n\n        az ad sp create-for-rbac --sdk-auth\n\n    You can specific the file path directly, or fill the environment variable AZURE_AUTH_LOCATION.\n    File must be UTF-8.\n\n    This method will fill automatically the following client parameters:\n    - credentials\n    - subscription_id\n    - base_url\n\n    Parameters provided in kwargs will override parameters and be passed directly to the client.\n\n    :Example:\n\n    .. code:: python\n\n        from azure.common.client_factory import get_client_from_auth_file\n        from azure.mgmt.compute import ComputeManagementClient\n        client = get_client_from_auth_file(ComputeManagementClient)\n\n    Example of file:\n\n    .. code:: json\n\n        {\n            \"clientId\": \"ad735158-65ca-11e7-ba4d-ecb1d756380e\",\n            \"clientSecret\": \"b70bb224-65ca-11e7-810c-ecb1d756380e\",\n            \"subscriptionId\": \"bfc42d3a-65ca-11e7-95cf-ecb1d756380e\",\n            \"tenantId\": \"c81da1d8-65ca-11e7-b1d1-ecb1d756380e\",\n            \"activeDirectoryEndpointUrl\": \"https://login.microsoftonline.com\",\n            \"resourceManagerEndpointUrl\": \"https://management.azure.com/\",\n            \"activeDirectoryGraphResourceId\": \"https://graph.windows.net/\",\n            \"sqlManagementEndpointUrl\": \"https://management.core.windows.net:8443/\",\n            \"galleryEndpointUrl\": \"https://gallery.azure.com/\",\n            \"managementEndpointUrl\": \"https://management.core.windows.net/\"\n        }\n\n    .. versionadded:: 1.1.7\n\n    :param client_class: A SDK client class\n    :param str auth_path: Path to the file.\n    :return: An instantiated client\n    :raises: KeyError if AZURE_AUTH_LOCATION is not an environment variable and no path is provided\n    :raises: FileNotFoundError if provided file path does not exists\n    :raises: json.JSONDecodeError if provided file is not JSON valid\n    :raises: UnicodeDecodeError if file is not UTF8 compliant", "id": "f39602:m4"}
{"signature": "def update(<EOL>self, resource_group_name, integration_account_name, integration_account, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", integration_account_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(integration_account, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Updates an integration account.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param integration_account_name: The integration account name.\n        :type integration_account_name: str\n        :param integration_account: The integration account.\n        :type integration_account: ~azure.mgmt.logic.models.IntegrationAccount\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: IntegrationAccount or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.logic.models.IntegrationAccount or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39882:c0:m5"}
{"signature": "def get(<EOL>self, resource_group_name, integration_account_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", integration_account_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets an integration account.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param integration_account_name: The integration account name.\n        :type integration_account_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: IntegrationAccount or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.logic.models.IntegrationAccount or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39882:c0:m3"}
{"signature": "def delete(<EOL>self, resource_group_name, integration_account_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", integration_account_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes an integration account.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param integration_account_name: The integration account name.\n        :type integration_account_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39882:c0:m6"}
{"signature": "def list_callback_url(<EOL>self, resource_group_name, integration_account_name, not_after=None, key_type=None, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.GetCallbackUrlParameters(not_after=not_after, key_type=key_type)<EOL>url = self.list_callback_url.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", integration_account_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the integration account callback URL.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param integration_account_name: The integration account name.\n        :type integration_account_name: str\n        :param not_after: The expiry time.\n        :type not_after: datetime\n        :param key_type: The key type. Possible values include:\n         'NotSpecified', 'Primary', 'Secondary'\n        :type key_type: str or ~azure.mgmt.logic.models.KeyType\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: CallbackUrl or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.logic.models.CallbackUrl or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39882:c0:m7"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, integration_account_name, integration_account, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", integration_account_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(integration_account, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or updates an integration account.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param integration_account_name: The integration account name.\n        :type integration_account_name: str\n        :param integration_account: The integration account.\n        :type integration_account: ~azure.mgmt.logic.models.IntegrationAccount\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: IntegrationAccount or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.logic.models.IntegrationAccount or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39882:c0:m4"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.OperationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.OperationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all of the available Logic REST API operations.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Operation\n        :rtype:\n         ~azure.mgmt.logic.models.OperationPaged[~azure.mgmt.logic.models.Operation]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.logic.models.ErrorResponseException>`", "id": "f39883:c0:m1"}
{"signature": "def validate_by_location(<EOL>self, resource_group_name, location, workflow_name, workflow, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.validate_by_location.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", workflow_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(workflow, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Validates the workflow definition.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param location: The workflow location.\n        :type location: str\n        :param workflow_name: The workflow name.\n        :type workflow_name: str\n        :param workflow: The workflow definition.\n        :type workflow: ~azure.mgmt.logic.models.Workflow\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39884:c0:m15"}
{"signature": "def enable(<EOL>self, resource_group_name, workflow_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.enable.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", workflow_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Enables a workflow.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param workflow_name: The workflow name.\n        :type workflow_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39884:c0:m8"}
{"signature": "def get(<EOL>self, resource_group_name, workflow_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", workflow_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a workflow.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param workflow_name: The workflow name.\n        :type workflow_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Workflow or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.logic.models.Workflow or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39884:c0:m3"}
{"signature": "def generate_upgraded_definition(<EOL>self, resource_group_name, workflow_name, target_schema_version=None, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.GenerateUpgradedDefinitionParameters(target_schema_version=target_schema_version)<EOL>url = self.generate_upgraded_definition.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", workflow_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT:object>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Generates the upgraded definition for a workflow.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param workflow_name: The workflow name.\n        :type workflow_name: str\n        :param target_schema_version: The target schema version.\n        :type target_schema_version: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: object or ClientRawResponse if raw=true\n        :rtype: object or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39884:c0:m9"}
{"signature": "def list(<EOL>self, resource_group_name, workflow_name, run_name, action_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", workflow_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", run_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", action_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List the workflow run action scoped repetitions.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param workflow_name: The workflow name.\n        :type workflow_name: str\n        :param run_name: The workflow run name.\n        :type run_name: str\n        :param action_name: The workflow action name.\n        :type action_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: WorkflowRunActionRepetitionDefinitionCollection or\n         ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.logic.models.WorkflowRunActionRepetitionDefinitionCollection\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39885:c0:m1"}
{"signature": "def get(<EOL>self, resource_group_name, workflow_name, run_name, action_name, repetition_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", workflow_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", run_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", action_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", repetition_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get a workflow run action scoped repetition.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param workflow_name: The workflow name.\n        :type workflow_name: str\n        :param run_name: The workflow run name.\n        :type run_name: str\n        :param action_name: The workflow action name.\n        :type action_name: str\n        :param repetition_name: The workflow repetition.\n        :type repetition_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: WorkflowRunActionRepetitionDefinition or ClientRawResponse if\n         raw=true\n        :rtype: ~azure.mgmt.logic.models.WorkflowRunActionRepetitionDefinition\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39885:c0:m2"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, integration_account_name, schema_name, schema, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", integration_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", schema_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(schema, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or updates an integration account schema.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param integration_account_name: The integration account name.\n        :type integration_account_name: str\n        :param schema_name: The integration account schema name.\n        :type schema_name: str\n        :param schema: The integration account schema.\n        :type schema: ~azure.mgmt.logic.models.IntegrationAccountSchema\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: IntegrationAccountSchema or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.logic.models.IntegrationAccountSchema or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39886:c0:m3"}
{"signature": "def list(<EOL>self, resource_group_name, workflow_name, run_name, action_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", workflow_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", run_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", action_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RequestHistoryPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RequestHistoryPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List a workflow run request history.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param workflow_name: The workflow name.\n        :type workflow_name: str\n        :param run_name: The workflow run name.\n        :type run_name: str\n        :param action_name: The workflow action name.\n        :type action_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of RequestHistory\n        :rtype:\n         ~azure.mgmt.logic.models.RequestHistoryPaged[~azure.mgmt.logic.models.RequestHistory]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.logic.models.ErrorResponseException>`", "id": "f39887:c0:m1"}
{"signature": "def list(<EOL>self, resource_group_name, integration_account_name, top=None, filter=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", integration_account_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>')<EOL><DEDENT>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.IntegrationAccountPartnerPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.IntegrationAccountPartnerPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of integration account partners.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param integration_account_name: The integration account name.\n        :type integration_account_name: str\n        :param top: The number of items to be included in the result.\n        :type top: int\n        :param filter: The filter to apply on the operation. Options for\n         filters include: PartnerType.\n        :type filter: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of IntegrationAccountPartner\n        :rtype:\n         ~azure.mgmt.logic.models.IntegrationAccountPartnerPaged[~azure.mgmt.logic.models.IntegrationAccountPartner]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39889:c0:m1"}
{"signature": "def delete(<EOL>self, resource_group_name, integration_account_name, partner_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", integration_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", partner_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes an integration account partner.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param integration_account_name: The integration account name.\n        :type integration_account_name: str\n        :param partner_name: The integration account partner name.\n        :type partner_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39889:c0:m4"}
{"signature": "def list_content_callback_url(<EOL>self, resource_group_name, integration_account_name, partner_name, not_after=None, key_type=None, custom_headers=None, raw=False, **operation_config):", "body": "list_content_callback_url1 = models.GetCallbackUrlParameters(not_after=not_after, key_type=key_type)<EOL>url = self.list_content_callback_url.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", integration_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", partner_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(list_content_callback_url1, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the content callback url.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param integration_account_name: The integration account name.\n        :type integration_account_name: str\n        :param partner_name: The integration account partner name.\n        :type partner_name: str\n        :param not_after: The expiry time.\n        :type not_after: datetime\n        :param key_type: The key type. Possible values include:\n         'NotSpecified', 'Primary', 'Secondary'\n        :type key_type: str or ~azure.mgmt.logic.models.KeyType\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: WorkflowTriggerCallbackUrl or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.logic.models.WorkflowTriggerCallbackUrl or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39889:c0:m5"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, integration_account_name, certificate_name, certificate, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", integration_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", certificate_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(certificate, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or updates an integration account certificate.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param integration_account_name: The integration account name.\n        :type integration_account_name: str\n        :param certificate_name: The integration account certificate name.\n        :type certificate_name: str\n        :param certificate: The integration account certificate.\n        :type certificate:\n         ~azure.mgmt.logic.models.IntegrationAccountCertificate\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: IntegrationAccountCertificate or ClientRawResponse if\n         raw=true\n        :rtype: ~azure.mgmt.logic.models.IntegrationAccountCertificate or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39890:c0:m3"}
{"signature": "def list(<EOL>self, resource_group_name, integration_account_name, top=None, filter=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", integration_account_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>')<EOL><DEDENT>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.IntegrationAccountSessionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.IntegrationAccountSessionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of integration account sessions.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param integration_account_name: The integration account name.\n        :type integration_account_name: str\n        :param top: The number of items to be included in the result.\n        :type top: int\n        :param filter: The filter to apply on the operation. Options for\n         filters include: ChangedTime.\n        :type filter: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of IntegrationAccountSession\n        :rtype:\n         ~azure.mgmt.logic.models.IntegrationAccountSessionPaged[~azure.mgmt.logic.models.IntegrationAccountSession]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39891:c0:m1"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, integration_account_name, assembly_artifact_name, assembly_artifact, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", integration_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", assembly_artifact_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(assembly_artifact, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Create or update an assembly for an integration account.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param integration_account_name: The integration account name.\n        :type integration_account_name: str\n        :param assembly_artifact_name: The assembly artifact name.\n        :type assembly_artifact_name: str\n        :param assembly_artifact: The assembly artifact.\n        :type assembly_artifact: ~azure.mgmt.logic.models.AssemblyDefinition\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: AssemblyDefinition or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.logic.models.AssemblyDefinition or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39894:c0:m3"}
{"signature": "def get(<EOL>self, resource_group_name, integration_account_name, assembly_artifact_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", integration_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", assembly_artifact_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get an assembly for an integration account.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param integration_account_name: The integration account name.\n        :type integration_account_name: str\n        :param assembly_artifact_name: The assembly artifact name.\n        :type assembly_artifact_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: AssemblyDefinition or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.logic.models.AssemblyDefinition or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39894:c0:m2"}
{"signature": "def list(<EOL>self, resource_group_name, integration_account_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", integration_account_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.AssemblyDefinitionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.AssemblyDefinitionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List the assemblies for an integration account.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param integration_account_name: The integration account name.\n        :type integration_account_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of AssemblyDefinition\n        :rtype:\n         ~azure.mgmt.logic.models.AssemblyDefinitionPaged[~azure.mgmt.logic.models.AssemblyDefinition]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39894:c0:m1"}
{"signature": "def list_content_callback_url(<EOL>self, resource_group_name, integration_account_name, assembly_artifact_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_content_callback_url.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", integration_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", assembly_artifact_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the content callback url for an integration account assembly.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param integration_account_name: The integration account name.\n        :type integration_account_name: str\n        :param assembly_artifact_name: The assembly artifact name.\n        :type assembly_artifact_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: WorkflowTriggerCallbackUrl or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.logic.models.WorkflowTriggerCallbackUrl or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39894:c0:m5"}
{"signature": "def get(<EOL>self, resource_group_name, workflow_name, run_name, action_name, repetition_name, request_history_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", workflow_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", run_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", action_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", repetition_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", request_history_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a workflow run repetition request history.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param workflow_name: The workflow name.\n        :type workflow_name: str\n        :param run_name: The workflow run name.\n        :type run_name: str\n        :param action_name: The workflow action name.\n        :type action_name: str\n        :param repetition_name: The workflow repetition.\n        :type repetition_name: str\n        :param request_history_name: The request history name.\n        :type request_history_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RequestHistory or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.logic.models.RequestHistory or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.logic.models.ErrorResponseException>`", "id": "f39896:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, integration_account_name, map_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", integration_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", map_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets an integration account map.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param integration_account_name: The integration account name.\n        :type integration_account_name: str\n        :param map_name: The integration account map name.\n        :type map_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: IntegrationAccountMap or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.logic.models.IntegrationAccountMap or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39897:c0:m2"}
{"signature": "def list(<EOL>self, resource_group_name, integration_account_name, top=None, filter=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", integration_account_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>')<EOL><DEDENT>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.IntegrationAccountMapPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.IntegrationAccountMapPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of integration account maps.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param integration_account_name: The integration account name.\n        :type integration_account_name: str\n        :param top: The number of items to be included in the result.\n        :type top: int\n        :param filter: The filter to apply on the operation. Options for\n         filters include: MapType.\n        :type filter: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of IntegrationAccountMap\n        :rtype:\n         ~azure.mgmt.logic.models.IntegrationAccountMapPaged[~azure.mgmt.logic.models.IntegrationAccountMap]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39897:c0:m1"}
{"signature": "def delete(<EOL>self, resource_group_name, integration_account_name, map_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", integration_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", map_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes an integration account map.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param integration_account_name: The integration account name.\n        :type integration_account_name: str\n        :param map_name: The integration account map name.\n        :type map_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39897:c0:m4"}
{"signature": "def list_content_callback_url(<EOL>self, resource_group_name, integration_account_name, map_name, not_after=None, key_type=None, custom_headers=None, raw=False, **operation_config):", "body": "list_content_callback_url1 = models.GetCallbackUrlParameters(not_after=not_after, key_type=key_type)<EOL>url = self.list_content_callback_url.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", integration_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", map_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(list_content_callback_url1, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the content callback url.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param integration_account_name: The integration account name.\n        :type integration_account_name: str\n        :param map_name: The integration account map name.\n        :type map_name: str\n        :param not_after: The expiry time.\n        :type not_after: datetime\n        :param key_type: The key type. Possible values include:\n         'NotSpecified', 'Primary', 'Secondary'\n        :type key_type: str or ~azure.mgmt.logic.models.KeyType\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: WorkflowTriggerCallbackUrl or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.logic.models.WorkflowTriggerCallbackUrl or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39897:c0:m5"}
{"signature": "def set_state(<EOL>self, resource_group_name, workflow_name, trigger_name, source, custom_headers=None, raw=False, **operation_config):", "body": "set_state1 = models.SetTriggerStateActionDefinition(source=source)<EOL>url = self.set_state.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", workflow_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", trigger_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(set_state1, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Sets the state of a workflow trigger.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param workflow_name: The workflow name.\n        :type workflow_name: str\n        :param trigger_name: The workflow trigger name.\n        :type trigger_name: str\n        :param source:\n        :type source: ~azure.mgmt.logic.models.WorkflowTrigger\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39898:c0:m6"}
{"signature": "def get(<EOL>self, resource_group_name, workflow_name, trigger_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", workflow_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", trigger_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a workflow trigger.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param workflow_name: The workflow name.\n        :type workflow_name: str\n        :param trigger_name: The workflow trigger name.\n        :type trigger_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: WorkflowTrigger or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.logic.models.WorkflowTrigger or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39898:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, workflow_name, run_name, operation_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", workflow_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", run_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", operation_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets an operation for a run.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param workflow_name: The workflow name.\n        :type workflow_name: str\n        :param run_name: The workflow run name.\n        :type run_name: str\n        :param operation_id: The workflow operation id.\n        :type operation_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: WorkflowRun or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.logic.models.WorkflowRun or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39899:c0:m1"}
{"signature": "def list(<EOL>self, resource_group_name, workflow_name, trigger_name, top=None, filter=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", workflow_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", trigger_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>')<EOL><DEDENT>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.WorkflowTriggerHistoryPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.WorkflowTriggerHistoryPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of workflow trigger histories.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param workflow_name: The workflow name.\n        :type workflow_name: str\n        :param trigger_name: The workflow trigger name.\n        :type trigger_name: str\n        :param top: The number of items to be included in the result.\n        :type top: int\n        :param filter: The filter to apply on the operation. Options for\n         filters include: Status, StartTime, and ClientTrackingId.\n        :type filter: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of WorkflowTriggerHistory\n        :rtype:\n         ~azure.mgmt.logic.models.WorkflowTriggerHistoryPaged[~azure.mgmt.logic.models.WorkflowTriggerHistory]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39900:c0:m1"}
{"signature": "def resubmit(<EOL>self, resource_group_name, workflow_name, trigger_name, history_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.resubmit.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", workflow_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", trigger_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", history_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Resubmits a workflow run based on the trigger history.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param workflow_name: The workflow name.\n        :type workflow_name: str\n        :param trigger_name: The workflow trigger name.\n        :type trigger_name: str\n        :param history_name: The workflow trigger history name. Corresponds to\n         the run name for triggers that resulted in a run.\n        :type history_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39900:c0:m3"}
{"signature": "def list_expression_traces(<EOL>self, resource_group_name, workflow_name, run_name, action_name, repetition_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_expression_traces.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", workflow_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", run_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", action_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", repetition_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ExpressionRootPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ExpressionRootPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists a workflow run expression trace.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param workflow_name: The workflow name.\n        :type workflow_name: str\n        :param run_name: The workflow run name.\n        :type run_name: str\n        :param action_name: The workflow action name.\n        :type action_name: str\n        :param repetition_name: The workflow repetition.\n        :type repetition_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ExpressionRoot\n        :rtype:\n         ~azure.mgmt.logic.models.ExpressionRootPaged[~azure.mgmt.logic.models.ExpressionRoot]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39902:c0:m3"}
{"signature": "def get(<EOL>self, resource_group_name, workflow_name, run_name, action_name, repetition_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", workflow_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", run_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", action_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", repetition_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get a workflow run action repetition.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param workflow_name: The workflow name.\n        :type workflow_name: str\n        :param run_name: The workflow run name.\n        :type run_name: str\n        :param action_name: The workflow action name.\n        :type action_name: str\n        :param repetition_name: The workflow repetition.\n        :type repetition_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: WorkflowRunActionRepetitionDefinition or ClientRawResponse if\n         raw=true\n        :rtype: ~azure.mgmt.logic.models.WorkflowRunActionRepetitionDefinition\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39902:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, integration_account_name, batch_configuration_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", integration_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", batch_configuration_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get a batch configuration for an integration account.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param integration_account_name: The integration account name.\n        :type integration_account_name: str\n        :param batch_configuration_name: The batch configuration name.\n        :type batch_configuration_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: BatchConfiguration or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.logic.models.BatchConfiguration or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f39903:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, factory_name, if_none_match=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", factory_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if if_none_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_none_match, '<STR_LIT:str>')<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a factory.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param factory_name: The factory name.\n        :type factory_name: str\n        :param if_none_match: ETag of the factory entity. Should only be\n         specified for get. If the ETag matches the existing entity tag, or if\n         * was provided, then no content will be returned.\n        :type if_none_match: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Factory or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.datafactory.models.Factory or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f40648:c0:m6"}
{"signature": "def delete(<EOL>self, resource_group_name, factory_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", factory_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes a factory.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param factory_name: The factory name.\n        :type factory_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f40648:c0:m7"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.OperationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.OperationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists the available Azure Data Factory API operations.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Operation\n        :rtype:\n         ~azure.mgmt.datafactory.models.OperationPaged[~azure.mgmt.datafactory.models.Operation]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f40649:c0:m1"}
{"signature": "def cancel(<EOL>self, resource_group_name, factory_name, run_id, is_recursive=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.cancel.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", factory_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", run_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if is_recursive is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", is_recursive, '<STR_LIT:bool>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Cancel a pipeline run by its run ID.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param factory_name: The factory name.\n        :type factory_name: str\n        :param run_id: The pipeline run identifier.\n        :type run_id: str\n        :param is_recursive: If true, cancel all the Child pipelines that are\n         triggered by the current pipeline.\n        :type is_recursive: bool\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f40650:c0:m3"}
{"signature": "def query_by_factory(<EOL>self, resource_group_name, factory_name, filter_parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.query_by_factory.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", factory_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(filter_parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Query pipeline runs in the factory based on input filter conditions.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param factory_name: The factory name.\n        :type factory_name: str\n        :param filter_parameters: Parameters to filter the pipeline run.\n        :type filter_parameters:\n         ~azure.mgmt.datafactory.models.RunFilterParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PipelineRunsQueryResponse or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.datafactory.models.PipelineRunsQueryResponse or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f40650:c0:m1"}
{"signature": "def stop(<EOL>self, resource_group_name, factory_name, trigger_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._stop_initial(<EOL>resource_group_name=resource_group_name,<EOL>factory_name=factory_name,<EOL>trigger_name=trigger_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Stops a trigger.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param factory_name: The factory name.\n        :type factory_name: str\n        :param trigger_name: The trigger name.\n        :type trigger_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f40652:c0:m8"}
{"signature": "def start(<EOL>self, resource_group_name, factory_name, trigger_name, rerun_trigger_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._start_initial(<EOL>resource_group_name=resource_group_name,<EOL>factory_name=factory_name,<EOL>trigger_name=trigger_name,<EOL>rerun_trigger_name=rerun_trigger_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Starts a trigger.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param factory_name: The factory name.\n        :type factory_name: str\n        :param trigger_name: The trigger name.\n        :type trigger_name: str\n        :param rerun_trigger_name: The rerun trigger name.\n        :type rerun_trigger_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f40653:c0:m3"}
{"signature": "def list_by_trigger(<EOL>self, resource_group_name, factory_name, trigger_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_trigger.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", factory_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", trigger_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RerunTriggerResourcePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RerunTriggerResourcePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists rerun triggers by an original trigger name.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param factory_name: The factory name.\n        :type factory_name: str\n        :param trigger_name: The trigger name.\n        :type trigger_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of RerunTriggerResource\n        :rtype:\n         ~azure.mgmt.datafactory.models.RerunTriggerResourcePaged[~azure.mgmt.datafactory.models.RerunTriggerResource]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f40653:c0:m8"}
{"signature": "def create(<EOL>self, resource_group_name, factory_name, trigger_name, rerun_trigger_name, rerun_tumbling_window_trigger_action_parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", factory_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", trigger_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", rerun_trigger_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(rerun_tumbling_window_trigger_action_parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates a rerun trigger.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param factory_name: The factory name.\n        :type factory_name: str\n        :param trigger_name: The trigger name.\n        :type trigger_name: str\n        :param rerun_trigger_name: The rerun trigger name.\n        :type rerun_trigger_name: str\n        :param rerun_tumbling_window_trigger_action_parameters: Rerun tumbling\n         window trigger action parameters.\n        :type rerun_tumbling_window_trigger_action_parameters:\n         ~azure.mgmt.datafactory.models.RerunTumblingWindowTriggerActionParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: TriggerResource or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.datafactory.models.TriggerResource or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f40653:c0:m1"}
{"signature": "def get(<EOL>self, resource_group_name, factory_name, integration_runtime_name, node_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", factory_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", integration_runtime_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", node_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a self-hosted integration runtime node.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param factory_name: The factory name.\n        :type factory_name: str\n        :param integration_runtime_name: The integration runtime name.\n        :type integration_runtime_name: str\n        :param node_name: The integration runtime node name.\n        :type node_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SelfHostedIntegrationRuntimeNode or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.datafactory.models.SelfHostedIntegrationRuntimeNode or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f40656:c0:m1"}
{"signature": "def delete(<EOL>self, resource_group_name, factory_name, integration_runtime_name, node_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", factory_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", integration_runtime_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", node_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes a self-hosted integration runtime node.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param factory_name: The factory name.\n        :type factory_name: str\n        :param integration_runtime_name: The integration runtime name.\n        :type integration_runtime_name: str\n        :param node_name: The integration runtime node name.\n        :type node_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f40656:c0:m2"}
{"signature": "def get_monitoring_data(<EOL>self, resource_group_name, factory_name, integration_runtime_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_monitoring_data.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", factory_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", integration_runtime_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the integration runtime monitoring data, which includes the monitor\n        data for all the nodes under this integration runtime.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param factory_name: The factory name.\n        :type factory_name: str\n        :param integration_runtime_name: The integration runtime name.\n        :type integration_runtime_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: IntegrationRuntimeMonitoringData or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.datafactory.models.IntegrationRuntimeMonitoringData or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f40657:c0:m15"}
{"signature": "def get(<EOL>self, resource_group_name, factory_name, integration_runtime_name, if_none_match=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", factory_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", integration_runtime_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if if_none_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_none_match, '<STR_LIT:str>')<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets an integration runtime.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param factory_name: The factory name.\n        :type factory_name: str\n        :param integration_runtime_name: The integration runtime name.\n        :type integration_runtime_name: str\n        :param if_none_match: ETag of the integration runtime entity. Should\n         only be specified for get. If the ETag matches the existing entity\n         tag, or if * was provided, then no content will be returned.\n        :type if_none_match: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: IntegrationRuntimeResource or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.datafactory.models.IntegrationRuntimeResource or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f40657:c0:m3"}
{"signature": "def update(<EOL>self, resource_group_name, factory_name, integration_runtime_name, auto_update=None, update_delay_offset=None, custom_headers=None, raw=False, **operation_config):", "body": "update_integration_runtime_request = models.UpdateIntegrationRuntimeRequest(auto_update=auto_update, update_delay_offset=update_delay_offset)<EOL>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", factory_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", integration_runtime_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(update_integration_runtime_request, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Updates an integration runtime.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param factory_name: The factory name.\n        :type factory_name: str\n        :param integration_runtime_name: The integration runtime name.\n        :type integration_runtime_name: str\n        :param auto_update: Enables or disables the auto-update feature of the\n         self-hosted integration runtime. See\n         https://go.microsoft.com/fwlink/?linkid=854189. Possible values\n         include: 'On', 'Off'\n        :type auto_update: str or\n         ~azure.mgmt.datafactory.models.IntegrationRuntimeAutoUpdate\n        :param update_delay_offset: The time offset (in hours) in the day,\n         e.g., PT03H is 3 hours. The integration runtime auto update will\n         happen on that time.\n        :type update_delay_offset: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: IntegrationRuntimeResource or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.datafactory.models.IntegrationRuntimeResource or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f40657:c0:m4"}
{"signature": "def list_auth_keys(<EOL>self, resource_group_name, factory_name, integration_runtime_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_auth_keys.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", factory_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", integration_runtime_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves the authentication keys for an integration runtime.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param factory_name: The factory name.\n        :type factory_name: str\n        :param integration_runtime_name: The integration runtime name.\n        :type integration_runtime_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: IntegrationRuntimeAuthKeys or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.datafactory.models.IntegrationRuntimeAuthKeys or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f40657:c0:m9"}
{"signature": "def start(<EOL>self, resource_group_name, factory_name, integration_runtime_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._start_initial(<EOL>resource_group_name=resource_group_name,<EOL>factory_name=factory_name,<EOL>integration_runtime_name=integration_runtime_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Starts a ManagedReserved type integration runtime.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param factory_name: The factory name.\n        :type factory_name: str\n        :param integration_runtime_name: The integration runtime name.\n        :type integration_runtime_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         IntegrationRuntimeStatusResponse or\n         ClientRawResponse<IntegrationRuntimeStatusResponse> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.datafactory.models.IntegrationRuntimeStatusResponse]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.datafactory.models.IntegrationRuntimeStatusResponse]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f40657:c0:m11"}
{"signature": "def get(<EOL>self, resource_group_name, factory_name, linked_service_name, if_none_match=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", factory_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", linked_service_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if if_none_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_none_match, '<STR_LIT:str>')<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a linked service.\n\n        :param resource_group_name: The resource group name.\n        :type resource_group_name: str\n        :param factory_name: The factory name.\n        :type factory_name: str\n        :param linked_service_name: The linked service name.\n        :type linked_service_name: str\n        :param if_none_match: ETag of the linked service entity. Should only\n         be specified for get. If the ETag matches the existing entity tag, or\n         if * was provided, then no content will be returned.\n        :type if_none_match: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: LinkedServiceResource or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.datafactory.models.LinkedServiceResource or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f40660:c0:m3"}
{"signature": "def make_title(title):", "body": "return \"<STR_LIT:\\n>\".join([title, len(title)*\"<STR_LIT:=>\"])<EOL>", "docstring": "Create a underlined title with the correct number of =.", "id": "f40663:m0"}
{"signature": "def get(<EOL>self, resource_group_name, workspace_name, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", workspace_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a workspace instance.\n\n        :param resource_group_name: The resource group name of the workspace.\n        :type resource_group_name: str\n        :param workspace_name: Name of the Log Analytics Workspace.\n        :type workspace_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Workspace or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.loganalytics.models.Workspace or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f40747:c0:m19"}
{"signature": "def delete(<EOL>self, resource_group_name, workspace_name, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", workspace_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes a workspace instance.\n\n        :param resource_group_name: The resource group name of the workspace.\n        :type resource_group_name: str\n        :param workspace_name: Name of the Log Analytics Workspace.\n        :type workspace_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f40747:c0:m18"}
{"signature": "def list_management_groups(<EOL>self, resource_group_name, workspace_name, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_management_groups.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", workspace_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ManagementGroupPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ManagementGroupPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of management groups connected to a workspace.\n\n        :param resource_group_name: The name of the resource group to get. The\n         name is case insensitive.\n        :type resource_group_name: str\n        :param workspace_name: The name of the workspace.\n        :type workspace_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ManagementGroup\n        :rtype:\n         ~azure.mgmt.loganalytics.models.ManagementGroupPaged[~azure.mgmt.loganalytics.models.ManagementGroup]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f40747:c0:m13"}
{"signature": "def get(<EOL>self, resource_group_name, workspace_name, data_source_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", workspace_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", data_source_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a datasource instance.\n\n        :param resource_group_name: The name of the resource group to get. The\n         name is case insensitive.\n        :type resource_group_name: str\n        :param workspace_name: Name of the Log Analytics Workspace that\n         contains the datasource.\n        :type workspace_name: str\n        :param data_source_name: Name of the datasource\n        :type data_source_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DataSource or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.loganalytics.models.DataSource or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f40748:c0:m3"}
{"signature": "def delete(<EOL>self, resource_group_name, workspace_name, data_source_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", workspace_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", data_source_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes a data source instance.\n\n        :param resource_group_name: The name of the resource group to get. The\n         name is case insensitive.\n        :type resource_group_name: str\n        :param workspace_name: Name of the Log Analytics Workspace that\n         contains the datasource.\n        :type workspace_name: str\n        :param data_source_name: Name of the datasource.\n        :type data_source_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f40748:c0:m2"}
{"signature": "def list_by_workspace(<EOL>self, resource_group_name, workspace_name, filter, skiptoken=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_workspace.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", workspace_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL>if skiptoken is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", skiptoken, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.DataSourcePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.DataSourcePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the first page of data source instances in a workspace with the\n        link to the next page.\n\n        :param resource_group_name: The name of the resource group to get. The\n         name is case insensitive.\n        :type resource_group_name: str\n        :param workspace_name: The workspace that contains the data sources.\n        :type workspace_name: str\n        :param filter: The filter to apply on the operation.\n        :type filter: str\n        :param skiptoken: Starting point of the collection of data source\n         instances.\n        :type skiptoken: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of DataSource\n        :rtype:\n         ~azure.mgmt.loganalytics.models.DataSourcePaged[~azure.mgmt.loganalytics.models.DataSource]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f40748:c0:m4"}
{"signature": "def delete(<EOL>self, resource_group_name, workspace_name, storage_insight_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", workspace_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", storage_insight_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes a storageInsightsConfigs resource.\n\n        :param resource_group_name: The name of the resource group to get. The\n         name is case insensitive.\n        :type resource_group_name: str\n        :param workspace_name: Log Analytics Workspace name that contains the\n         storageInsightsConfigs resource\n        :type workspace_name: str\n        :param storage_insight_name: Name of the storageInsightsConfigs\n         resource\n        :type storage_insight_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f40751:c0:m3"}
{"signature": "def get(<EOL>self, resource_group_name, workspace_name, storage_insight_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", workspace_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", storage_insight_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a storage insight instance.\n\n        :param resource_group_name: The name of the resource group to get. The\n         name is case insensitive.\n        :type resource_group_name: str\n        :param workspace_name: Log Analytics Workspace name that contains the\n         storageInsightsConfigs resource\n        :type workspace_name: str\n        :param storage_insight_name: Name of the storageInsightsConfigs\n         resource\n        :type storage_insight_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: StorageInsight or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.loganalytics.models.StorageInsight or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f40751:c0:m2"}
{"signature": "def update(<EOL>self, resource_group_name, vault_name, vault, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(vault, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Updates the vault.\n\n        :param resource_group_name: The name of the resource group where the\n         recovery services vault is present.\n        :type resource_group_name: str\n        :param vault_name: The name of the recovery services vault.\n        :type vault_name: str\n        :param vault: Recovery Services Vault to be created.\n        :type vault: ~azure.mgmt.recoveryservices.models.PatchVault\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Vault or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.recoveryservices.models.Vault or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f40822:c0:m6"}
{"signature": "def delete(<EOL>self, resource_group_name, vault_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes a vault.\n\n        :param resource_group_name: The name of the resource group where the\n         recovery services vault is present.\n        :type resource_group_name: str\n        :param vault_name: The name of the recovery services vault.\n        :type vault_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f40822:c0:m5"}
{"signature": "def start(<EOL>self, resource_group_name, profile_name, endpoint_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._start_initial(<EOL>resource_group_name=resource_group_name,<EOL>profile_name=profile_name,<EOL>endpoint_name=endpoint_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Starts an existing CDN endpoint that is on a stopped state.\n\n        :param resource_group_name: Name of the Resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param profile_name: Name of the CDN profile which is unique within\n         the resource group.\n        :type profile_name: str\n        :param endpoint_name: Name of the endpoint under the profile which is\n         unique globally.\n        :type endpoint_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Endpoint or\n         ClientRawResponse<Endpoint> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.cdn.models.Endpoint]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.cdn.models.Endpoint]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.cdn.models.ErrorResponseException>`", "id": "f40938:c0:m10"}
{"signature": "def load_content(<EOL>self, resource_group_name, profile_name, endpoint_name, content_paths, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._load_content_initial(<EOL>resource_group_name=resource_group_name,<EOL>profile_name=profile_name,<EOL>endpoint_name=endpoint_name,<EOL>content_paths=content_paths,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Pre-loads a content to CDN. Available for Verizon Profiles.\n\n        :param resource_group_name: Name of the Resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param profile_name: Name of the CDN profile which is unique within\n         the resource group.\n        :type profile_name: str\n        :param endpoint_name: Name of the endpoint under the profile which is\n         unique globally.\n        :type endpoint_name: str\n        :param content_paths: The path to the content to be loaded. Path\n         should be a relative file URL of the origin.\n        :type content_paths: list[str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.cdn.models.ErrorResponseException>`", "id": "f40938:c0:m16"}
{"signature": "def update(<EOL>self, resource_group_name, profile_name, endpoint_name, endpoint_update_properties, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_initial(<EOL>resource_group_name=resource_group_name,<EOL>profile_name=profile_name,<EOL>endpoint_name=endpoint_name,<EOL>endpoint_update_properties=endpoint_update_properties,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates an existing CDN endpoint with the specified endpoint name under\n        the specified subscription, resource group and profile. Only tags and\n        Origin HostHeader can be updated after creating an endpoint. To update\n        origins, use the Update Origin operation. To update custom domains, use\n        the Update Custom Domain operation.\n\n        :param resource_group_name: Name of the Resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param profile_name: Name of the CDN profile which is unique within\n         the resource group.\n        :type profile_name: str\n        :param endpoint_name: Name of the endpoint under the profile which is\n         unique globally.\n        :type endpoint_name: str\n        :param endpoint_update_properties: Endpoint update properties\n        :type endpoint_update_properties:\n         ~azure.mgmt.cdn.models.EndpointUpdateParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Endpoint or\n         ClientRawResponse<Endpoint> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.cdn.models.Endpoint]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.cdn.models.Endpoint]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.cdn.models.ErrorResponseException>`", "id": "f40938:c0:m6"}
{"signature": "def enable_custom_https(<EOL>self, resource_group_name, profile_name, endpoint_name, custom_domain_name, custom_domain_https_parameters=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.enable_custom_https.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", profile_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", endpoint_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", custom_domain_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if custom_domain_https_parameters is not None:<EOL><INDENT>body_content = self._serialize.body(custom_domain_https_parameters, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>body_content = None<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Enable https delivery of the custom domain.\n\n        :param resource_group_name: Name of the Resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param profile_name: Name of the CDN profile which is unique within\n         the resource group.\n        :type profile_name: str\n        :param endpoint_name: Name of the endpoint under the profile which is\n         unique globally.\n        :type endpoint_name: str\n        :param custom_domain_name: Name of the custom domain within an\n         endpoint.\n        :type custom_domain_name: str\n        :param custom_domain_https_parameters: The configuration specifying\n         how to enable HTTPS for the custom domain - using CDN managed\n         certificate or user's own certificate. If not specified, enabling ssl\n         uses CDN managed certificate by default.\n        :type custom_domain_https_parameters:\n         ~azure.mgmt.cdn.models.CustomDomainHttpsParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: CustomDomain or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.cdn.models.CustomDomain or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.cdn.models.ErrorResponseException>`", "id": "f40939:c0:m8"}
{"signature": "def list_supported_optimization_types(<EOL>self, resource_group_name, profile_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_supported_optimization_types.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", profile_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the supported optimization types for the current profile. A user\n        can create an endpoint with an optimization type from the listed\n        values.\n\n        :param resource_group_name: Name of the Resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param profile_name: Name of the CDN profile which is unique within\n         the resource group.\n        :type profile_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SupportedOptimizationTypesListResult or ClientRawResponse if\n         raw=true\n        :rtype: ~azure.mgmt.cdn.models.SupportedOptimizationTypesListResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.cdn.models.ErrorResponseException>`", "id": "f40944:c0:m11"}
{"signature": "def get(<EOL>self, resource_group_name, profile_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", profile_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a CDN profile with the specified profile name under the specified\n        subscription and resource group.\n\n        :param resource_group_name: Name of the Resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param profile_name: Name of the CDN profile which is unique within\n         the resource group.\n        :type profile_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Profile or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.cdn.models.Profile or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.cdn.models.ErrorResponseException>`", "id": "f40944:c0:m3"}
{"signature": "def check_name_availability_with_subscription(<EOL>self, name, custom_headers=None, raw=False, **operation_config):", "body": "check_name_availability_input = models.CheckNameAvailabilityInput(name=name)<EOL>url = self.check_name_availability_with_subscription.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(check_name_availability_input, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Check the availability of a resource name. This is needed for resources\n        where name is globally unique, such as a CDN endpoint.\n\n        :param name: The resource name to validate.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: CheckNameAvailabilityOutput or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.cdn.models.CheckNameAvailabilityOutput or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.cdn.models.ErrorResponseException>`", "id": "f40945:c1:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, service_topology_name, service_name, service_unit_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", service_topology_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", service_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", service_unit_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes the service unit.\n\n        :param resource_group_name: The name of the resource group. The name\n         is case insensitive.\n        :type resource_group_name: str\n        :param service_topology_name: The name of the service topology .\n        :type service_topology_name: str\n        :param service_name: The name of the service resource.\n        :type service_name: str\n        :param service_unit_name: The name of the service unit resource.\n        :type service_unit_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41016:c0:m4"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, service_topology_name, service_name, service_unit_name, service_unit_info, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>service_topology_name=service_topology_name,<EOL>service_name=service_name,<EOL>service_unit_name=service_unit_name,<EOL>service_unit_info=service_unit_info,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>header_dict = {<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>}<EOL>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>client_raw_response.add_headers(header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a service unit under the service in the service\n        topology.\n\n        This is an asynchronous operation and can be polled to completion using\n        the operation resource returned by this operation.\n\n        :param resource_group_name: The name of the resource group. The name\n         is case insensitive.\n        :type resource_group_name: str\n        :param service_topology_name: The name of the service topology .\n        :type service_topology_name: str\n        :param service_name: The name of the service resource.\n        :type service_name: str\n        :param service_unit_name: The name of the service unit resource.\n        :type service_unit_name: str\n        :param service_unit_info: The service unit resource object.\n        :type service_unit_info:\n         ~azure.mgmt.deploymentmanager.models.ServiceUnitResource\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ServiceUnitResource or\n         ClientRawResponse<ServiceUnitResource> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.deploymentmanager.models.ServiceUnitResource]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.deploymentmanager.models.ServiceUnitResource]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41016:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, service_topology_name, service_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", service_topology_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", service_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the service.\n\n        :param resource_group_name: The name of the resource group. The name\n         is case insensitive.\n        :type resource_group_name: str\n        :param service_topology_name: The name of the service topology .\n        :type service_topology_name: str\n        :param service_name: The name of the service resource.\n        :type service_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ServiceResource or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.deploymentmanager.models.ServiceResource or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41017:c0:m2"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, service_topology_name, service_name, service_info, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", service_topology_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", service_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(service_info, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or updates a service in the service topology.\n\n        Synchronously creates a new service or updates an existing service.\n\n        :param resource_group_name: The name of the resource group. The name\n         is case insensitive.\n        :type resource_group_name: str\n        :param service_topology_name: The name of the service topology .\n        :type service_topology_name: str\n        :param service_name: The name of the service resource.\n        :type service_name: str\n        :param service_info: The service object\n        :type service_info:\n         ~azure.mgmt.deploymentmanager.models.ServiceResource\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ServiceResource or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.deploymentmanager.models.ServiceResource or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41017:c0:m1"}
{"signature": "def delete(<EOL>self, resource_group_name, service_topology_name, service_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", service_topology_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", service_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes the service.\n\n        :param resource_group_name: The name of the resource group. The name\n         is case insensitive.\n        :type resource_group_name: str\n        :param service_topology_name: The name of the service topology .\n        :type service_topology_name: str\n        :param service_name: The name of the service resource.\n        :type service_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41017:c0:m3"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, step_name, step_info=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", step_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if step_info is not None:<EOL><INDENT>body_content = self._serialize.body(step_info, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>body_content = None<EOL><DEDENT>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or updates a rollout step with the given step properties.\n\n        Synchronously creates a new step or updates an existing step.\n\n        :param resource_group_name: The name of the resource group. The name\n         is case insensitive.\n        :type resource_group_name: str\n        :param step_name: The name of the deployment step.\n        :type step_name: str\n        :param step_info: The step object.\n        :type step_info: ~azure.mgmt.deploymentmanager.models.StepResource\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: StepResource or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.deploymentmanager.models.StepResource or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41020:c0:m1"}
{"signature": "def read(<EOL>self, group_name, service_name, project_name, file_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.read.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", service_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", project_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", file_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ApiErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Request storage information for downloading the file content.\n\n        This method is used for requesting storage information using which\n        contents of the file can be downloaded.\n\n        :param group_name: Name of the resource group\n        :type group_name: str\n        :param service_name: Name of the service\n        :type service_name: str\n        :param project_name: Name of the project\n        :type project_name: str\n        :param file_name: Name of the File\n        :type file_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: FileStorageInfo or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.datamigration.models.FileStorageInfo or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ApiErrorException<azure.mgmt.datamigration.models.ApiErrorException>`", "id": "f41411:c0:m6"}
{"signature": "def delete(<EOL>self, group_name, service_name, delete_running_tasks=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>group_name=group_name,<EOL>service_name=service_name,<EOL>delete_running_tasks=delete_running_tasks,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Delete DMS Service Instance.\n\n        The services resource is the top-level resource that represents the\n        Database Migration Service. The DELETE method deletes a service. Any\n        running tasks will be canceled.\n\n        :param group_name: Name of the resource group\n        :type group_name: str\n        :param service_name: Name of the service\n        :type service_name: str\n        :param delete_running_tasks: Delete the resource even if it contains\n         running tasks\n        :type delete_running_tasks: bool\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises:\n         :class:`ApiErrorException<azure.mgmt.datamigration.models.ApiErrorException>`", "id": "f41413:c0:m5"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ApiErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.DataMigrationServicePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.DataMigrationServicePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get services in subscription.\n\n        The services resource is the top-level resource that represents the\n        Database Migration Service. This method returns a list of service\n        resources in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of DataMigrationService\n        :rtype:\n         ~azure.mgmt.datamigration.models.DataMigrationServicePaged[~azure.mgmt.datamigration.models.DataMigrationService]\n        :raises:\n         :class:`ApiErrorException<azure.mgmt.datamigration.models.ApiErrorException>`", "id": "f41413:c0:m16"}
{"signature": "def check_children_name_availability(<EOL>self, group_name, service_name, name=None, type=None, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.NameAvailabilityRequest(name=name, type=type)<EOL>url = self.check_children_name_availability.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", service_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ApiErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Check nested resource name validity and availability.\n\n        This method checks whether a proposed nested resource name is valid and\n        available.\n\n        :param group_name: Name of the resource group\n        :type group_name: str\n        :param service_name: Name of the service\n        :type service_name: str\n        :param name: The proposed resource name\n        :type name: str\n        :param type: The resource type chain (e.g. virtualMachines/extensions)\n        :type type: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: NameAvailabilityResponse or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.datamigration.models.NameAvailabilityResponse or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ApiErrorException<azure.mgmt.datamigration.models.ApiErrorException>`", "id": "f41413:c0:m14"}
{"signature": "def list_skus(<EOL>self, group_name, service_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_skus.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", service_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ApiErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.AvailableServiceSkuPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.AvailableServiceSkuPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get compatible SKUs.\n\n        The services resource is the top-level resource that represents the\n        Database Migration Service. The skus action returns the list of SKUs\n        that a service resource can be updated to.\n\n        :param group_name: Name of the resource group\n        :type group_name: str\n        :param service_name: Name of the service\n        :type service_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of AvailableServiceSku\n        :rtype:\n         ~azure.mgmt.datamigration.models.AvailableServiceSkuPaged[~azure.mgmt.datamigration.models.AvailableServiceSku]\n        :raises:\n         :class:`ApiErrorException<azure.mgmt.datamigration.models.ApiErrorException>`", "id": "f41413:c0:m13"}
{"signature": "def list_by_resource_group(<EOL>self, group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ApiErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.DataMigrationServicePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.DataMigrationServicePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get services in resource group.\n\n        The Services resource is the top-level resource that represents the\n        Database Migration Service. This method returns a list of service\n        resources in a resource group.\n\n        :param group_name: Name of the resource group\n        :type group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of DataMigrationService\n        :rtype:\n         ~azure.mgmt.datamigration.models.DataMigrationServicePaged[~azure.mgmt.datamigration.models.DataMigrationService]\n        :raises:\n         :class:`ApiErrorException<azure.mgmt.datamigration.models.ApiErrorException>`", "id": "f41413:c0:m15"}
{"signature": "def create_or_update(<EOL>self, parameters, group_name, service_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>parameters=parameters,<EOL>group_name=group_name,<EOL>service_name=service_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Create or update DMS Instance.\n\n        The services resource is the top-level resource that represents the\n        Database Migration Service. The PUT method creates a new service or\n        updates an existing one. When a service is updated, existing child\n        resources (i.e. tasks) are unaffected. Services currently support a\n        single kind, \"vm\", which refers to a VM-based service, although other\n        kinds may be added in the future. This method can change the kind, SKU,\n        and network of the service, but if tasks are currently running (i.e.\n        the service is busy), this will fail with 400 Bad Request\n        (\"ServiceIsBusy\"). The provider will reply when successful with 200 OK\n        or 201 Created. Long-running operations use the provisioningState\n        property.\n\n        :param parameters: Information about the service\n        :type parameters:\n         ~azure.mgmt.datamigration.models.DataMigrationService\n        :param group_name: Name of the resource group\n        :type group_name: str\n        :param service_name: Name of the service\n        :type service_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns DataMigrationService or\n         ClientRawResponse<DataMigrationService> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.datamigration.models.DataMigrationService]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.datamigration.models.DataMigrationService]]\n        :raises:\n         :class:`ApiErrorException<azure.mgmt.datamigration.models.ApiErrorException>`", "id": "f41413:c0:m2"}
{"signature": "def stop(<EOL>self, group_name, service_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._stop_initial(<EOL>group_name=group_name,<EOL>service_name=service_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Stop service.\n\n        The services resource is the top-level resource that represents the\n        Database Migration Service. This action stops the service and the\n        service cannot be used for data migration. The service owner won't be\n        billed when the service is stopped.\n\n        :param group_name: Name of the resource group\n        :type group_name: str\n        :param service_name: Name of the service\n        :type service_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises:\n         :class:`ApiErrorException<azure.mgmt.datamigration.models.ApiErrorException>`", "id": "f41413:c0:m12"}
{"signature": "def delete(<EOL>self, group_name, service_name, project_name, delete_running_tasks=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", service_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", project_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if delete_running_tasks is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", delete_running_tasks, '<STR_LIT:bool>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ApiErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Delete project.\n\n        The project resource is a nested resource representing a stored\n        migration project. The DELETE method deletes a project.\n\n        :param group_name: Name of the resource group\n        :type group_name: str\n        :param service_name: Name of the service\n        :type service_name: str\n        :param project_name: Name of the project\n        :type project_name: str\n        :param delete_running_tasks: Delete the resource even if it contains\n         running tasks\n        :type delete_running_tasks: bool\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ApiErrorException<azure.mgmt.datamigration.models.ApiErrorException>`", "id": "f41414:c0:m4"}
{"signature": "def get(<EOL>self, group_name, service_name, project_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", service_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", project_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ApiErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get project information.\n\n        The project resource is a nested resource representing a stored\n        migration project. The GET method retrieves information about a\n        project.\n\n        :param group_name: Name of the resource group\n        :type group_name: str\n        :param service_name: Name of the service\n        :type service_name: str\n        :param project_name: Name of the project\n        :type project_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Project or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.datamigration.models.Project or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ApiErrorException<azure.mgmt.datamigration.models.ApiErrorException>`", "id": "f41414:c0:m3"}
{"signature": "def update(<EOL>self, group_name, service_name, project_name, task_name, etag=None, properties=None, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.ProjectTask(etag=etag, properties=properties)<EOL>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", service_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", project_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", task_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ApiErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Create or update task.\n\n        The tasks resource is a nested, proxy-only resource representing work\n        performed by a DMS instance. The PATCH method updates an existing task,\n        but since tasks have no mutable custom properties, there is little\n        reason to do so.\n\n        :param group_name: Name of the resource group\n        :type group_name: str\n        :param service_name: Name of the service\n        :type service_name: str\n        :param project_name: Name of the project\n        :type project_name: str\n        :param task_name: Name of the Task\n        :type task_name: str\n        :param etag: HTTP strong entity tag value. This is ignored if\n         submitted.\n        :type etag: str\n        :param properties: Custom task properties\n        :type properties:\n         ~azure.mgmt.datamigration.models.ProjectTaskProperties\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ProjectTask or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.datamigration.models.ProjectTask or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ApiErrorException<azure.mgmt.datamigration.models.ApiErrorException>`", "id": "f41416:c0:m5"}
{"signature": "def delete(<EOL>self, group_name, service_name, project_name, task_name, delete_running_tasks=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", service_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", project_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", task_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if delete_running_tasks is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", delete_running_tasks, '<STR_LIT:bool>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ApiErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Delete task.\n\n        The tasks resource is a nested, proxy-only resource representing work\n        performed by a DMS instance. The DELETE method deletes a task,\n        canceling it first if it's running.\n\n        :param group_name: Name of the resource group\n        :type group_name: str\n        :param service_name: Name of the service\n        :type service_name: str\n        :param project_name: Name of the project\n        :type project_name: str\n        :param task_name: Name of the Task\n        :type task_name: str\n        :param delete_running_tasks: Delete the resource even if it contains\n         running tasks\n        :type delete_running_tasks: bool\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ApiErrorException<azure.mgmt.datamigration.models.ApiErrorException>`", "id": "f41416:c0:m4"}
{"signature": "def cancel(<EOL>self, group_name, service_name, project_name, task_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.cancel.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", service_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", project_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", task_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ApiErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Cancel a task.\n\n        The tasks resource is a nested, proxy-only resource representing work\n        performed by a DMS instance. This method cancels a task if it's\n        currently queued or running.\n\n        :param group_name: Name of the resource group\n        :type group_name: str\n        :param service_name: Name of the service\n        :type service_name: str\n        :param project_name: Name of the project\n        :type project_name: str\n        :param task_name: Name of the Task\n        :type task_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ProjectTask or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.datamigration.models.ProjectTask or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ApiErrorException<azure.mgmt.datamigration.models.ApiErrorException>`", "id": "f41416:c0:m6"}
{"signature": "def create_or_update(<EOL>self, group_name, service_name, project_name, task_name, etag=None, properties=None, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.ProjectTask(etag=etag, properties=properties)<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", service_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", project_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", task_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ApiErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Create or update task.\n\n        The tasks resource is a nested, proxy-only resource representing work\n        performed by a DMS instance. The PUT method creates a new task or\n        updates an existing one, although since tasks have no mutable custom\n        properties, there is little reason to update an exising one.\n\n        :param group_name: Name of the resource group\n        :type group_name: str\n        :param service_name: Name of the service\n        :type service_name: str\n        :param project_name: Name of the project\n        :type project_name: str\n        :param task_name: Name of the Task\n        :type task_name: str\n        :param etag: HTTP strong entity tag value. This is ignored if\n         submitted.\n        :type etag: str\n        :param properties: Custom task properties\n        :type properties:\n         ~azure.mgmt.datamigration.models.ProjectTaskProperties\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ProjectTask or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.datamigration.models.ProjectTask or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ApiErrorException<azure.mgmt.datamigration.models.ApiErrorException>`", "id": "f41416:c0:m2"}
{"signature": "def list_skus(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_skus.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ApiErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ResourceSkuPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ResourceSkuPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get supported SKUs.\n\n        The skus action returns the list of SKUs that DMS supports.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ResourceSku\n        :rtype:\n         ~azure.mgmt.datamigration.models.ResourceSkuPaged[~azure.mgmt.datamigration.models.ResourceSku]\n        :raises:\n         :class:`ApiErrorException<azure.mgmt.datamigration.models.ApiErrorException>`", "id": "f41417:c0:m1"}
{"signature": "def list(<EOL>self, location, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ApiErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.QuotaPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.QuotaPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get resource quotas and usage information.\n\n        This method returns region-specific quotas and resource usage\n        information for the Database Migration Service.\n\n        :param location: The Azure region of the operation\n        :type location: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Quota\n        :rtype:\n         ~azure.mgmt.datamigration.models.QuotaPaged[~azure.mgmt.datamigration.models.Quota]\n        :raises:\n         :class:`ApiErrorException<azure.mgmt.datamigration.models.ApiErrorException>`", "id": "f41418:c0:m1"}
{"signature": "def check_system_services_updates_available(<EOL>self, resource_group_name, cluster_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = '<STR_LIT>'<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", cluster_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Checks if updates are available for system services in the cluster.\n\n        :param resource_group_name: Name of the resource group in which the\n         cluster is located.\n        :type resource_group_name: str\n        :param cluster_name: The name of the cluster.\n        :type cluster_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: CheckSystemServicesUpdatesAvailableResponse or\n         ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.machinelearningcompute.models.CheckSystemServicesUpdatesAvailableResponse\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41455:c0:m6"}
{"signature": "def update(<EOL>self, resource_group_name, cluster_name, tags=None, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.OperationalizationClusterUpdateParameters(tags=tags)<EOL>url = '<STR_LIT>'<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", cluster_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, body_content, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseWrapperException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "The PATCH operation can be used to update only the tags for a cluster.\n        Use PUT operation to update other properties.\n\n        :param resource_group_name: Name of the resource group in which the\n         cluster is located.\n        :type resource_group_name: str\n        :param cluster_name: The name of the cluster.\n        :type cluster_name: str\n        :param tags: Gets or sets a list of key value pairs that describe the\n         resource. These tags can be used in viewing and grouping this resource\n         (across resource groups). A maximum of 15 tags can be provided for a\n         resource. Each tag must have a key no greater in length than 128\n         characters and a value no greater in length than 256 characters.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: OperationalizationCluster or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.machinelearningcompute.models.OperationalizationCluster or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseWrapperException<azure.mgmt.machinelearningcompute.models.ErrorResponseWrapperException>`", "id": "f41455:c0:m3"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, cluster_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = '<STR_LIT>'<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", cluster_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>def long_running_send():<EOL><INDENT>request = self._client.put(url, query_parameters)<EOL>return self._client.send(<EOL>request, header_parameters, body_content, **operation_config)<EOL><DEDENT>def get_long_running_status(status_link, headers=None):<EOL><INDENT>request = self._client.get(status_link)<EOL>if headers:<EOL><INDENT>request.headers.update(headers)<EOL><DEDENT>return self._client.send(<EOL>request, header_parameters, **operation_config)<EOL><DEDENT>def get_long_running_output(response):<EOL><INDENT>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseWrapperException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>if raw:<EOL><INDENT>response = long_running_send()<EOL>return get_long_running_output(response)<EOL><DEDENT>long_running_operation_timeout = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>return AzureOperationPoller(<EOL>long_running_send, get_long_running_output,<EOL>get_long_running_status, long_running_operation_timeout)<EOL>", "docstring": "Create or update an operationalization cluster.\n\n        :param resource_group_name: Name of the resource group in which the\n         cluster is located.\n        :type resource_group_name: str\n        :param cluster_name: The name of the cluster.\n        :type cluster_name: str\n        :param parameters: Parameters supplied to create or update an\n         Operationalization cluster.\n        :type parameters:\n         ~azure.mgmt.machinelearningcompute.models.OperationalizationCluster\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :return: An instance of AzureOperationPoller that returns\n         OperationalizationCluster or ClientRawResponse if raw=true\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.machinelearningcompute.models.OperationalizationCluster]\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseWrapperException<azure.mgmt.machinelearningcompute.models.ErrorResponseWrapperException>`", "id": "f41455:c0:m1"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorDetailsException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.OperationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.OperationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all of the available IoT Central application REST API operations.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Operation\n        :rtype:\n         ~azure.mgmt.iotcentral.models.OperationPaged[~azure.mgmt.iotcentral.models.Operation]\n        :raises:\n         :class:`ErrorDetailsException<azure.mgmt.iotcentral.models.ErrorDetailsException>`", "id": "f41485:c0:m1"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorDetailsException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.AppPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.AppPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get all the IoT Central Applications in a resource group.\n\n        :param resource_group_name: The name of the resource group that\n         contains the IoT Central application.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of App\n        :rtype:\n         ~azure.mgmt.iotcentral.models.AppPaged[~azure.mgmt.iotcentral.models.App]\n        :raises:\n         :class:`ErrorDetailsException<azure.mgmt.iotcentral.models.ErrorDetailsException>`", "id": "f41486:c0:m9"}
{"signature": "def check_subdomain_availability(<EOL>self, name, type=\"<STR_LIT>\", custom_headers=None, raw=False, **operation_config):", "body": "operation_inputs = models.OperationInputs(name=name, type=type)<EOL>url = self.check_subdomain_availability.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(operation_inputs, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorDetailsException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Check if an IoT Central application subdomain is available.\n\n        :param name: The name of the IoT Central application instance to\n         check.\n        :type name: str\n        :param type: The type of the IoT Central resource to query.\n        :type type: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: AppAvailabilityInfo or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.iotcentral.models.AppAvailabilityInfo or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorDetailsException<azure.mgmt.iotcentral.models.ErrorDetailsException>`", "id": "f41486:c0:m11"}
{"signature": "def create_namespace(self, name, region):", "body": "_validate_not_none('<STR_LIT:name>', name)<EOL>return self._perform_put(<EOL>self._get_path('<STR_LIT>', name),<EOL>_ServiceBusManagementXmlSerializer.namespace_to_xml(region))<EOL>", "docstring": "Create a new service bus namespace.\n\nname:\n    Name of the service bus namespace to create.\nregion:\n    Region to create the namespace in.", "id": "f41499:c0:m4"}
{"signature": "def delete_namespace(self, name):", "body": "_validate_not_none('<STR_LIT:name>', name)<EOL>return self._perform_delete(<EOL>self._get_path('<STR_LIT>', name),<EOL>None)<EOL>", "docstring": "Delete a service bus namespace.\n\nname:\n    Name of the service bus namespace to delete.", "id": "f41499:c0:m5"}
{"signature": "def get_metrics_data_notification_hub(self, name, hub_name, metric, rollup, filter_expresssion):", "body": "response = self._perform_get(<EOL>self._get_get_metrics_data_hub_path(name, hub_name, metric, rollup, filter_expresssion),<EOL>None)<EOL>return _MinidomXmlToObject.convert_response_to_feeds(<EOL>response,<EOL>partial(<EOL>_ServiceBusManagementXmlSerializer.xml_to_metrics,<EOL>object_type=MetricValues<EOL>)<EOL>)<EOL>", "docstring": "Retrieves the list of supported metrics for this namespace and topic\n\nname:\n    Name of the service bus namespace.\nhub_name:\n    Name of the service bus notification hub in this namespace.\nmetric:\n    name of a supported metric\nrollup:\n    name of a supported rollup\nfilter_expression:\n    filter, for instance \"$filter=Timestamp gt datetime'2014-10-01T00:00:00Z'\"", "id": "f41499:c0:m17"}
{"signature": "def list_namespaces(self):", "body": "response = self._perform_get(<EOL>self._get_path('<STR_LIT>', None),<EOL>None)<EOL>return _MinidomXmlToObject.convert_response_to_feeds(<EOL>response,<EOL>_ServiceBusManagementXmlSerializer.xml_to_namespace)<EOL>", "docstring": "List the service bus namespaces defined on the account.", "id": "f41499:c0:m2"}
{"signature": "def get_metrics_data_queue(self, name, queue_name, metric, rollup, filter_expresssion):", "body": "response = self._perform_get(<EOL>self._get_get_metrics_data_queue_path(name, queue_name, metric, rollup, filter_expresssion),<EOL>None)<EOL>return _MinidomXmlToObject.convert_response_to_feeds(<EOL>response,<EOL>partial(<EOL>_ServiceBusManagementXmlSerializer.xml_to_metrics,<EOL>object_type=MetricValues<EOL>)<EOL>)<EOL>", "docstring": "Retrieves the list of supported metrics for this namespace and queue\n\nname:\n    Name of the service bus namespace.\nqueue_name:\n    Name of the service bus queue in this namespace.\nmetric:\n    name of a supported metric\nrollup:\n    name of a supported rollup\nfilter_expression:\n    filter, for instance \"$filter=Timestamp gt datetime'2014-10-01T00:00:00Z'\"", "id": "f41499:c0:m15"}
{"signature": "def get_metrics_data_relay(self, name, relay_name, metric, rollup, filter_expresssion):", "body": "response = self._perform_get(<EOL>self._get_get_metrics_data_relay_path(name, relay_name, metric, rollup, filter_expresssion),<EOL>None)<EOL>return _MinidomXmlToObject.convert_response_to_feeds(<EOL>response,<EOL>partial(<EOL>_ServiceBusManagementXmlSerializer.xml_to_metrics,<EOL>object_type=MetricValues<EOL>)<EOL>)<EOL>", "docstring": "Retrieves the list of supported metrics for this namespace and relay\n\nname:\n    Name of the service bus namespace.\nrelay_name:\n    Name of the service bus relay in this namespace.\nmetric:\n    name of a supported metric\nrollup:\n    name of a supported rollup\nfilter_expression:\n    filter, for instance \"$filter=Timestamp gt datetime'2014-10-01T00:00:00Z'\"", "id": "f41499:c0:m18"}
{"signature": "def get_metrics_data_topic(self, name, topic_name, metric, rollup, filter_expresssion):", "body": "response = self._perform_get(<EOL>self._get_get_metrics_data_topic_path(name, topic_name, metric, rollup, filter_expresssion),<EOL>None)<EOL>return _MinidomXmlToObject.convert_response_to_feeds(<EOL>response,<EOL>partial(<EOL>_ServiceBusManagementXmlSerializer.xml_to_metrics,<EOL>object_type=MetricValues<EOL>)<EOL>)<EOL>", "docstring": "Retrieves the list of supported metrics for this namespace and topic\n\nname:\n    Name of the service bus namespace.\ntopic_name:\n    Name of the service bus queue in this namespace.\nmetric:\n    name of a supported metric\nrollup:\n    name of a supported rollup\nfilter_expression:\n    filter, for instance \"$filter=Timestamp gt datetime'2014-10-01T00:00:00Z'\"", "id": "f41499:c0:m16"}
{"signature": "def list_topics(self, name):", "body": "response = self._perform_get(<EOL>self._get_list_topics_path(name),<EOL>None)<EOL>return _MinidomXmlToObject.convert_response_to_feeds(<EOL>response,<EOL>partial(<EOL>_MinidomXmlToObject.convert_xml_to_azure_object,<EOL>azure_type=TopicDescription<EOL>)<EOL>)<EOL>", "docstring": "Retrieves the topics in the service namespace.\n\nname:\n    Name of the service bus namespace.", "id": "f41499:c0:m8"}
{"signature": "def _general_error_handler(http_error):", "body": "message = str(http_error)<EOL>if http_error.respbody is not None:<EOL><INDENT>message += '<STR_LIT:\\n>' + http_error.respbody.decode('<STR_LIT>')<EOL><DEDENT>raise AzureHttpError(message, http_error.status)<EOL>", "docstring": "Simple error handler for azure.", "id": "f41500:m0"}
{"signature": "def get_metric_definitions(self, webspace_name, website_name):", "body": "return self._perform_get(self._get_metric_definitions_path(webspace_name, website_name),<EOL>MetricDefinitions)<EOL>", "docstring": "Get metric definitions of metrics available of this web site.\n\nwebspace_name:\n    The name of the webspace.\nwebsite_name:\n    The name of the website.", "id": "f41501:c0:m10"}
{"signature": "def __init__(self, subscription_id=None, cert_file=None,<EOL>host=MANAGEMENT_HOST, request_session=None,<EOL>timeout=DEFAULT_HTTP_TIMEOUT):", "body": "super(WebsiteManagementService, self).__init__(<EOL>subscription_id, cert_file, host, request_session, timeout)<EOL>", "docstring": "Initializes the website management service.\n\nsubscription_id:\n    Subscription to manage.\ncert_file:\n    Path to .pem certificate file (httplib), or location of the\n    certificate in your Personal certificate store (winhttp) in the\n    CURRENT_USER\\my\\CertificateName format.\n    If a request_session is specified, then this is unused.\nhost:\n    Live ServiceClient URL. Defaults to Azure public cloud.\nrequest_session:\n    Session object to use for http requests. If this is specified, it\n    replaces the default use of httplib or winhttp. Also, the cert_file\n    parameter is unused when a session is passed in.\n    The session object handles authentication, and as such can support\n    multiple types of authentication: .pem certificate, oauth.\n    For example, you can pass in a Session instance from the requests\n    library. To use .pem certificate authentication with requests\n    library, set the path to the .pem file on the session.cert\n    attribute.\ntimeout:\n    Optional. Timeout for the http request, in seconds.", "id": "f41501:c0:m0"}
{"signature": "def get_publish_profile_xml(self, webspace_name, website_name):", "body": "return self._perform_get(self._get_publishxml_path(webspace_name, website_name),<EOL>None).body.decode(\"<STR_LIT:utf-8>\")<EOL>", "docstring": "Get a site's publish profile as a string\n\nwebspace_name:\n    The name of the webspace.\nwebsite_name:\n    The name of the website.", "id": "f41501:c0:m11"}
{"signature": "def list_webspaces(self):", "body": "return self._perform_get(self._get_list_webspaces_path(),<EOL>WebSpaces)<EOL>", "docstring": "List the webspaces defined on the account.", "id": "f41501:c0:m1"}
{"signature": "def get_historical_usage_metrics(self, webspace_name, website_name,<EOL>metrics = None, start_time=None, end_time=None, time_grain=None):", "body": "metrics = ('<STR_LIT>'+'<STR_LIT:U+002C>'.join(metrics)) if metrics else '<STR_LIT>'<EOL>start_time = ('<STR_LIT>'+start_time) if start_time else '<STR_LIT>'<EOL>end_time = ('<STR_LIT>'+end_time) if end_time else '<STR_LIT>'<EOL>time_grain = ('<STR_LIT>'+time_grain) if time_grain else '<STR_LIT>'<EOL>parameters = ('<STR_LIT:&>'.join(v for v in (metrics, start_time, end_time, time_grain) if v))<EOL>parameters = '<STR_LIT:?>'+parameters if parameters else '<STR_LIT>'<EOL>return self._perform_get(self._get_historical_usage_metrics_path(webspace_name, website_name) + parameters,<EOL>MetricResponses)<EOL>", "docstring": "Get historical usage metrics.\n\nwebspace_name:\n    The name of the webspace.\nwebsite_name:\n    The name of the website.\nmetrics:\n    Optional. List of metrics name. Otherwise, all metrics returned.\nstart_time:\n    Optional. An ISO8601 date. Otherwise, current hour is used.\nend_time:\n    Optional. An ISO8601 date. Otherwise, current time is used.\ntime_grain:\n    Optional. A rollup name, as P1D. OTherwise, default rollup for the metrics is used.\nMore information and metrics name at:\nhttp://msdn.microsoft.com/en-us/library/azure/dn166964.aspx", "id": "f41501:c0:m9"}
{"signature": "def list_vm_images(self, location=None, publisher=None, category=None):", "body": "path = self._get_vm_image_path()<EOL>query = '<STR_LIT>'<EOL>if location:<EOL><INDENT>query += '<STR_LIT>' + location<EOL><DEDENT>if publisher:<EOL><INDENT>query += '<STR_LIT>' + publisher<EOL><DEDENT>if category:<EOL><INDENT>query += '<STR_LIT>' + category<EOL><DEDENT>if query:<EOL><INDENT>path = path + '<STR_LIT:?>' + query.lstrip('<STR_LIT:&>')<EOL><DEDENT>return self._perform_get(path, VMImages)<EOL>", "docstring": "Retrieves a list of the VM Images from the image repository that is\nassociated with the specified subscription.", "id": "f41502:c0:m77"}
{"signature": "def list_hosted_services(self):", "body": "return self._perform_get(self._get_hosted_service_path(),<EOL>HostedServices)<EOL>", "docstring": "Lists the hosted services available under the current subscription.\n\nNote that you will receive a list of HostedService instances, without\nall details inside. For instance, deployments will be None. If you\nwant deployments information for a specific host service, you have to\ncall get_hosted_service_properties with embed_detail=True.", "id": "f41502:c0:m11"}
{"signature": "def list_subscription_operations(self, start_time=None, end_time=None, object_id_filter=None,<EOL>operation_result_filter=None, continuation_token=None):", "body": "start_time = ('<STR_LIT>' + start_time) if start_time else '<STR_LIT>'<EOL>end_time = ('<STR_LIT>' + end_time) if end_time else '<STR_LIT>'<EOL>object_id_filter = ('<STR_LIT>' + object_id_filter) if object_id_filter else '<STR_LIT>'<EOL>operation_result_filter = ('<STR_LIT>' + operation_result_filter) if operation_result_filter else '<STR_LIT>'<EOL>continuation_token = ('<STR_LIT>' + continuation_token) if continuation_token else '<STR_LIT>'<EOL>parameters = ('<STR_LIT:&>'.join(v for v in (start_time, end_time, object_id_filter, operation_result_filter, continuation_token) if v))<EOL>parameters = '<STR_LIT:?>' + parameters if parameters else '<STR_LIT>'<EOL>return self._perform_get(self._get_list_subscription_operations_path() + parameters,<EOL>SubscriptionOperationCollection)<EOL>", "docstring": "List subscription operations.\n\nstart_time: Required. An ISO8601 date.\nend_time: Required. An ISO8601 date.\nobject_id_filter: Optional. Returns subscription operations only for the specified object type and object ID\noperation_result_filter: Optional. Returns subscription operations only for the specified result status, either Succeeded, Failed, or InProgress.\ncontinuation_token: Optional.\nMore information at:\nhttps://msdn.microsoft.com/en-us/library/azure/gg715318.aspx", "id": "f41502:c0:m48"}
{"signature": "def start_roles(self, service_name, deployment_name, role_names):", "body": "_validate_not_none('<STR_LIT>', service_name)<EOL>_validate_not_none('<STR_LIT>', deployment_name)<EOL>_validate_not_none('<STR_LIT>', role_names)<EOL>return self._perform_post(<EOL>self._get_roles_operations_path(service_name, deployment_name),<EOL>_XmlSerializer.start_roles_operation_to_xml(role_names),<EOL>as_async=True)<EOL>", "docstring": "Starts the specified virtual machines.\n\nservice_name:\n    The name of the service.\ndeployment_name:\n    The name of the deployment.\nrole_names:\n    The names of the roles, as an enumerable of strings.", "id": "f41502:c0:m62"}
{"signature": "def update_role(self, service_name, deployment_name, role_name,<EOL>os_virtual_hard_disk=None, network_config=None,<EOL>availability_set_name=None, data_virtual_hard_disks=None,<EOL>role_size=None, role_type='<STR_LIT>',<EOL>resource_extension_references=None,<EOL>provision_guest_agent=None):", "body": "_validate_not_none('<STR_LIT>', service_name)<EOL>_validate_not_none('<STR_LIT>', deployment_name)<EOL>_validate_not_none('<STR_LIT>', role_name)<EOL>return self._perform_put(<EOL>self._get_role_path(service_name, deployment_name, role_name),<EOL>_XmlSerializer.update_role_to_xml(<EOL>role_name,<EOL>os_virtual_hard_disk,<EOL>role_type,<EOL>network_config,<EOL>availability_set_name,<EOL>data_virtual_hard_disks,<EOL>role_size,<EOL>resource_extension_references,<EOL>provision_guest_agent),<EOL>as_async=True)<EOL>", "docstring": "Updates the specified virtual machine.\n\nservice_name:\n    The name of the service.\ndeployment_name:\n    The name of the deployment.\nrole_name:\n    The name of the role.\nos_virtual_hard_disk:\n    Contains the parameters Windows Azure uses to create the operating\n    system disk for the virtual machine.\nnetwork_config:\n    Encapsulates the metadata required to create the virtual network\n    configuration for a virtual machine. If you do not include a\n    network configuration set you will not be able to access the VM\n    through VIPs over the internet. If your virtual machine belongs to\n    a virtual network you can not specify which subnet address space\n    it resides under.\navailability_set_name:\n    Specifies the name of an availability set to which to add the\n    virtual machine. This value controls the virtual machine allocation\n    in the Windows Azure environment. Virtual machines specified in the\n    same availability set are allocated to different nodes to maximize\n    availability.\ndata_virtual_hard_disks:\n    Contains the parameters Windows Azure uses to create a data disk\n    for a virtual machine.\nrole_size:\n    The size of the virtual machine to allocate. The default value is\n    Small. Possible values are: ExtraSmall, Small, Medium, Large,\n    ExtraLarge. The specified value must be compatible with the disk\n    selected in the OSVirtualHardDisk values.\nrole_type:\n    The type of the role for the virtual machine. The only supported\n    value is PersistentVMRole.\nresource_extension_references:\n    Optional. Contains a collection of resource extensions that are to\n    be installed on the Virtual Machine. This element is used if\n    provision_guest_agent is set to True.\nprovision_guest_agent:\n    Optional. Indicates whether the VM Agent is installed on the\n    Virtual Machine. To run a resource extension in a Virtual Machine,\n    this service must be installed.", "id": "f41502:c0:m58"}
{"signature": "def delete_os_image(self, image_name, delete_vhd=False):", "body": "_validate_not_none('<STR_LIT>', image_name)<EOL>path = self._get_image_path(image_name)<EOL>if delete_vhd:<EOL><INDENT>path += '<STR_LIT>'<EOL><DEDENT>return self._perform_delete(path, as_async=True)<EOL>", "docstring": "Deletes the specified OS image from your image repository.\n\nimage_name:\n    The name of the image.\ndelete_vhd:\n    Deletes the underlying vhd blob in Azure storage.", "id": "f41502:c0:m85"}
{"signature": "def associate_reserved_ip_address(<EOL>self, name, service_name, deployment_name, virtual_ip_name=None<EOL>):", "body": "_validate_not_none('<STR_LIT:name>', name)<EOL>_validate_not_none('<STR_LIT>', service_name)<EOL>_validate_not_none('<STR_LIT>', deployment_name)<EOL>return self._perform_post(<EOL>self._get_reserved_ip_path_for_association(name),<EOL>_XmlSerializer.associate_reserved_ip_to_xml(<EOL>service_name, deployment_name, virtual_ip_name<EOL>),<EOL>as_async=True,<EOL>x_ms_version='<STR_LIT>'<EOL>)<EOL>", "docstring": "Associate an existing reservedIP to a deployment.\n\nname:\n    Required. Name of the reserved IP address.\n\nservice_name:\n    Required. Name of the hosted service.\n\ndeployment_name:\n    Required. Name of the deployment.\n\nvirtual_ip_name:\n    Optional. Name of the VirtualIP in case of multi Vip tenant.\n    If this value is not specified default virtualIP is used\n    for this operation.", "id": "f41502:c0:m51"}
{"signature": "def replicate_vm_image(self, vm_image_name, regions, offer, sku, version):", "body": "_validate_not_none('<STR_LIT>', vm_image_name)<EOL>_validate_not_none('<STR_LIT>', regions)<EOL>_validate_not_none('<STR_LIT>', offer)<EOL>_validate_not_none('<STR_LIT>', sku)<EOL>_validate_not_none('<STR_LIT:version>', version)<EOL>return self._perform_put(<EOL>self._get_replication_path_using_vm_image_name(vm_image_name),<EOL>_XmlSerializer.replicate_image_to_xml(<EOL>regions,<EOL>offer,<EOL>sku,<EOL>version<EOL>),<EOL>as_async=True,<EOL>x_ms_version='<STR_LIT>'<EOL>)<EOL>", "docstring": "Replicate a VM image to multiple target locations. This operation\nis only for publishers. You have to be registered as image publisher\nwith Microsoft Azure to be able to call this.\n\nvm_image_name:\n    Specifies the name of the VM Image that is to be used for\n    replication\nregions:\n    Specified a list of regions to replicate the image to\n    Note: The regions in the request body are not additive. If a VM\n    Image has already been replicated to Regions A, B, and C, and\n    a request is made to replicate to Regions A and D, the VM\n    Image will remain in Region A, will be replicated in Region D,\n    and will be unreplicated from Regions B and C\noffer:\n    Specifies the publisher defined name of the offer. The allowed\n    characters are uppercase or lowercase letters, digit,\n    hypen(-), period (.).The maximum allowed length is 64 characters.\nsku:\n    Specifies the publisher defined name of the Sku. The allowed\n    characters are uppercase or lowercase letters, digit,\n    hypen(-), period (.). The maximum allowed length is 64 characters.\nversion:\n    Specifies the publisher defined version of the image.\n    The allowed characters are digit and period.\n    Format: <MajorVersion>.<MinorVersion>.<Patch>\n    Example: '1.0.0' or '1.1.0' The 3 version number to\n    follow standard of most of the RPs. See http://semver.org", "id": "f41502:c0:m71"}
{"signature": "def list_role_sizes(self):", "body": "return self._perform_get(self._get_role_sizes_path(),<EOL>RoleSizes)<EOL>", "docstring": "Lists the role sizes that are available under the specified\nsubscription.", "id": "f41502:c0:m1"}
{"signature": "def delete_service_certificate(self, service_name, thumbalgorithm,<EOL>thumbprint):", "body": "_validate_not_none('<STR_LIT>', service_name)<EOL>_validate_not_none('<STR_LIT>', thumbalgorithm)<EOL>_validate_not_none('<STR_LIT>', thumbprint)<EOL>return self._perform_delete(<EOL>'<STR_LIT:/>' + self.subscription_id + '<STR_LIT>' +<EOL>_str(service_name) + '<STR_LIT>' +<EOL>_str(thumbalgorithm) + '<STR_LIT:->' + _str(thumbprint),<EOL>as_async=True)<EOL>", "docstring": "Deletes a service certificate from the certificate store of a hosted\nservice.\n\nservice_name:\n    Name of the hosted service.\nthumbalgorithm:\n    The algorithm for the certificate's thumbprint.\nthumbprint:\n    The hexadecimal representation of the thumbprint.", "id": "f41502:c0:m34"}
{"signature": "def delete_role_instances(self, service_name, deployment_name,<EOL>role_instance_names):", "body": "_validate_not_none('<STR_LIT>', service_name)<EOL>_validate_not_none('<STR_LIT>', deployment_name)<EOL>_validate_not_none('<STR_LIT>', role_instance_names)<EOL>return self._perform_post(<EOL>self._get_deployment_path_using_name(<EOL>service_name, deployment_name) + '<STR_LIT>',<EOL>_XmlSerializer.role_instances_to_xml(role_instance_names),<EOL>as_async=True)<EOL>", "docstring": "Reinstalls the operating system on instances of web roles or worker\nroles and initializes the storage resources that are used by them. If\nyou do not want to initialize storage resources, you can use\nreimage_role_instance.\n\nservice_name:\n    Name of the hosted service.\ndeployment_name:\n    The name of the deployment.\nrole_instance_names:\n    List of role instance names.", "id": "f41502:c0:m29"}
{"signature": "def delete_hosted_service(self, service_name, complete=False):", "body": "_validate_not_none('<STR_LIT>', service_name)<EOL>path = self._get_hosted_service_path(service_name)<EOL>if complete == True:<EOL><INDENT>path = path +'<STR_LIT>'<EOL><DEDENT>return self._perform_delete(path, as_async=True)<EOL>", "docstring": "Deletes the specified hosted service from Windows Azure.\n\nservice_name:\n    Name of the hosted service.\ncomplete:\n    True if all OS/data disks and the source blobs for the disks should\n    also be deleted from storage.", "id": "f41502:c0:m15"}
{"signature": "def delete_management_certificate(self, thumbprint):", "body": "_validate_not_none('<STR_LIT>', thumbprint)<EOL>return self._perform_delete(<EOL>'<STR_LIT:/>' + self.subscription_id + '<STR_LIT>' + _str(thumbprint))<EOL>", "docstring": "The Delete Management Certificate operation deletes a certificate from\nthe list of management certificates. Management certificates, which\nare also known as subscription certificates, authenticate clients\nattempting to connect to resources associated with your Windows Azure\nsubscription.\n\nthumbprint:\n    The thumb print that uniquely identifies the management\n    certificate.", "id": "f41502:c0:m38"}
{"signature": "def list_service_certificates(self, service_name):", "body": "_validate_not_none('<STR_LIT>', service_name)<EOL>return self._perform_get(<EOL>'<STR_LIT:/>' + self.subscription_id + '<STR_LIT>' +<EOL>_str(service_name) + '<STR_LIT>',<EOL>Certificates)<EOL>", "docstring": "Lists all of the service certificates associated with the specified\nhosted service.\n\nservice_name:\n    Name of the hosted service.", "id": "f41502:c0:m31"}
{"signature": "def get_os_image(self, image_name):", "body": "return self._perform_get(self._get_image_path(image_name),<EOL>OSImage)<EOL>", "docstring": "Retrieves an OS image from the image repository.", "id": "f41502:c0:m80"}
{"signature": "def delete_dns_server(self, service_name, deployment_name, dns_server_name):", "body": "_validate_not_none('<STR_LIT>', service_name)<EOL>_validate_not_none('<STR_LIT>', deployment_name)<EOL>_validate_not_none('<STR_LIT>', dns_server_name)<EOL>return self._perform_delete(<EOL>self._get_dns_server_path(service_name,<EOL>deployment_name,<EOL>dns_server_name),<EOL>as_async=True)<EOL>", "docstring": "Deletes a DNS server from a deployment.\n\nservice_name:\n    The name of the service.\ndeployment_name:\n    The name of the deployment.\ndns_server_name:\n    Name of the DNS server that you want to delete.", "id": "f41502:c0:m68"}
{"signature": "def capture_role(self, service_name, deployment_name, role_name,<EOL>post_capture_action, target_image_name,<EOL>target_image_label, provisioning_configuration=None):", "body": "_validate_not_none('<STR_LIT>', service_name)<EOL>_validate_not_none('<STR_LIT>', deployment_name)<EOL>_validate_not_none('<STR_LIT>', role_name)<EOL>_validate_not_none('<STR_LIT>', post_capture_action)<EOL>_validate_not_none('<STR_LIT>', target_image_name)<EOL>_validate_not_none('<STR_LIT>', target_image_label)<EOL>return self._perform_post(<EOL>self._get_role_instance_operations_path(<EOL>service_name, deployment_name, role_name),<EOL>_XmlSerializer.capture_role_to_xml(<EOL>post_capture_action,<EOL>target_image_name,<EOL>target_image_label,<EOL>provisioning_configuration),<EOL>as_async=True)<EOL>", "docstring": "The Capture Role operation captures a virtual machine image to your\nimage gallery. From the captured image, you can create additional\ncustomized virtual machines.\n\nservice_name:\n    The name of the service.\ndeployment_name:\n    The name of the deployment.\nrole_name:\n    The name of the role.\npost_capture_action:\n    Specifies the action after capture operation completes. Possible\n    values are: Delete, Reprovision.\ntarget_image_name:\n    Specifies the image name of the captured virtual machine.\ntarget_image_label:\n    Specifies the friendly name of the captured virtual machine.\nprovisioning_configuration:\n    Use an instance of WindowsConfigurationSet or LinuxConfigurationSet.", "id": "f41502:c0:m60"}
{"signature": "def delete_data_disk(self, service_name, deployment_name, role_name, lun, delete_vhd=False):", "body": "_validate_not_none('<STR_LIT>', service_name)<EOL>_validate_not_none('<STR_LIT>', deployment_name)<EOL>_validate_not_none('<STR_LIT>', role_name)<EOL>_validate_not_none('<STR_LIT>', lun)<EOL>path = self._get_data_disk_path(service_name, deployment_name, role_name, lun)<EOL>if delete_vhd:<EOL><INDENT>path += '<STR_LIT>'<EOL><DEDENT>return self._perform_delete(path, as_async=True)<EOL>", "docstring": "Removes the specified data disk from a virtual machine.\n\nservice_name:\n    The name of the service.\ndeployment_name:\n    The name of the deployment.\nrole_name:\n    The name of the role.\nlun:\n    The Logical Unit Number (LUN) for the disk.\ndelete_vhd:\n    Deletes the underlying vhd blob in Azure storage.", "id": "f41502:c0:m89"}
{"signature": "def add_management_certificate(self, public_key, thumbprint, data):", "body": "_validate_not_none('<STR_LIT>', public_key)<EOL>_validate_not_none('<STR_LIT>', thumbprint)<EOL>_validate_not_none('<STR_LIT:data>', data)<EOL>return self._perform_post(<EOL>'<STR_LIT:/>' + self.subscription_id + '<STR_LIT>',<EOL>_XmlSerializer.subscription_certificate_to_xml(<EOL>public_key, thumbprint, data))<EOL>", "docstring": "The Add Management Certificate operation adds a certificate to the\nlist of management certificates. Management certificates, which are\nalso known as subscription certificates, authenticate clients\nattempting to connect to resources associated with your Windows Azure\nsubscription.\n\npublic_key:\n    A base64 representation of the management certificate public key.\nthumbprint:\n    The thumb print that uniquely identifies the management\n    certificate.\ndata:\n    The certificate's raw data in base-64 encoded .cer format.", "id": "f41502:c0:m37"}
{"signature": "def list_affinity_groups(self):", "body": "return self._perform_get(<EOL>'<STR_LIT:/>' + self.subscription_id + '<STR_LIT>',<EOL>AffinityGroups)<EOL>", "docstring": "Lists the affinity groups associated with the specified subscription.", "id": "f41502:c0:m39"}
{"signature": "def update_vm_image(self, vm_image_name, vm_image):", "body": "_validate_not_none('<STR_LIT>', vm_image_name)<EOL>_validate_not_none('<STR_LIT>', vm_image)<EOL>return self._perform_put(self._get_vm_image_path(vm_image_name),<EOL>_XmlSerializer.update_vm_image_to_xml(vm_image),<EOL>as_async=True)<EOL>", "docstring": "Updates a VM Image in the image repository that is associated with the\nspecified subscription.\n\nvm_image_name:\n    Name of image to update.\nvm_image:\n    An instance of VMImage class.\nvm_image.label: Optional. Specifies an identifier for the image.\nvm_image.os_disk_configuration:\n    Required. Specifies configuration information for the operating \n    system disk that is associated with the image.\nvm_image.os_disk_configuration.host_caching:\n    Optional. Specifies the caching behavior of the operating system disk.\n    Possible values are: None, ReadOnly, ReadWrite \nvm_image.data_disk_configurations:\n    Optional. Specifies configuration information for the data disks\n    that are associated with the image. A VM Image might not have data\n    disks associated with it.\nvm_image.data_disk_configurations[].name:\n    Required. Specifies the name of the data disk.\nvm_image.data_disk_configurations[].host_caching:\n    Optional. Specifies the caching behavior of the data disk.\n    Possible values are: None, ReadOnly, ReadWrite \nvm_image.data_disk_configurations[].lun:\n    Optional if the lun for the disk is 0. Specifies the Logical Unit\n    Number (LUN) for the data disk.\nvm_image.description: Optional. Specifies the description of the image.\nvm_image.language: Optional. Specifies the language of the image.\nvm_image.image_family:\n    Optional. Specifies a value that can be used to group VM Images.\nvm_image.recommended_vm_size:\n    Optional. Specifies the size to use for the Virtual Machine that\n    is created from the VM Image.\nvm_image.eula:\n    Optional. Specifies the End User License Agreement that is\n    associated with the image. The value for this element is a string,\n    but it is recommended that the value be a URL that points to a EULA.\nvm_image.icon_uri:\n    Optional. Specifies the URI to the icon that is displayed for the\n    image in the Management Portal.\nvm_image.small_icon_uri:\n    Optional. Specifies the URI to the small icon that is displayed for\n    the image in the Management Portal.\nvm_image.privacy_uri:\n    Optional. Specifies the URI that points to a document that contains\n    the privacy policy related to the image.\nvm_image.published_date:\n    Optional. Specifies the date when the image was added to the image\n    repository.\nvm_image.show_in_gui:\n    Optional. Indicates whether the VM Images should be listed in the\n    portal.", "id": "f41502:c0:m78"}
{"signature": "def get_affinity_group_properties(self, affinity_group_name):", "body": "_validate_not_none('<STR_LIT>', affinity_group_name)<EOL>return self._perform_get(<EOL>'<STR_LIT:/>' + self.subscription_id + '<STR_LIT>' +<EOL>_str(affinity_group_name) + '<STR_LIT>',<EOL>AffinityGroup)<EOL>", "docstring": "Returns the system properties associated with the specified affinity\ngroup.\n\naffinity_group_name:\n    The name of the affinity group.", "id": "f41502:c0:m40"}
{"signature": "def delete_disk(self, disk_name, delete_vhd=False):", "body": "_validate_not_none('<STR_LIT>', disk_name)<EOL>path = self._get_disk_path(disk_name)<EOL>if delete_vhd:<EOL><INDENT>path += '<STR_LIT>'<EOL><DEDENT>return self._perform_delete(path)<EOL>", "docstring": "Deletes the specified data or operating system disk from your image\nrepository.\n\ndisk_name:\n    The name of the disk to delete.\ndelete_vhd:\n    Deletes the underlying vhd blob in Azure storage.", "id": "f41502:c0:m94"}
{"signature": "def update_storage_account(self, service_name, description=None,<EOL>label=None, geo_replication_enabled=None,<EOL>extended_properties=None,<EOL>account_type='<STR_LIT>'):", "body": "_validate_not_none('<STR_LIT>', service_name)<EOL>if geo_replication_enabled == False:<EOL><INDENT>account_type = '<STR_LIT>'<EOL><DEDENT>return self._perform_put(<EOL>self._get_storage_service_path(service_name),<EOL>_XmlSerializer.update_storage_service_input_to_xml(<EOL>description,<EOL>label,<EOL>account_type,<EOL>extended_properties))<EOL>", "docstring": "Updates the label, the description, and enables or disables the\ngeo-replication status for a storage account in Windows Azure.\n\nservice_name:\n    Name of the storage service account.\ndescription:\n    A description for the storage account. The description may be up\n    to 1024 characters in length.\nlabel:\n    A name for the storage account. The name may be up to 100\n    characters in length. The name can be used to identify the storage\n    account for your tracking purposes.\ngeo_replication_enabled:\n    Deprecated. Replaced by the account_type parameter.\nextended_properties:\n    Dictionary containing name/value pairs of storage account\n    properties. You can have a maximum of 50 extended property\n    name/value pairs. The maximum length of the Name element is 64\n    characters, only alphanumeric characters and underscores are valid\n    in the Name, and the name must start with a letter. The value has\n    a maximum length of 255 characters.\naccount_type:\n    Specifies whether the account supports locally-redundant storage,\n    geo-redundant storage, zone-redundant storage, or read access\n    geo-redundant storage.\n    Possible values are:\n        Standard_LRS, Standard_ZRS, Standard_GRS, Standard_RAGRS", "id": "f41502:c0:m8"}
{"signature": "def update_dns_server(self, service_name, deployment_name, dns_server_name, address):", "body": "_validate_not_none('<STR_LIT>', service_name)<EOL>_validate_not_none('<STR_LIT>', deployment_name)<EOL>_validate_not_none('<STR_LIT>', dns_server_name)<EOL>_validate_not_none('<STR_LIT:address>', address)<EOL>return self._perform_put(<EOL>self._get_dns_server_path(service_name,<EOL>deployment_name,<EOL>dns_server_name),<EOL>_XmlSerializer.dns_server_to_xml(dns_server_name, address),<EOL>as_async=True)<EOL>", "docstring": "Updates the ip address of a DNS server.\n\nservice_name:\n    The name of the service.\ndeployment_name:\n    The name of the deployment.\ndns_server_name:\n    Specifies the name of the DNS server.\naddress:\n    Specifies the IP address of the DNS server.", "id": "f41502:c0:m67"}
{"signature": "def create_affinity_group(self, name, label, location, description=None):", "body": "_validate_not_none('<STR_LIT:name>', name)<EOL>_validate_not_none('<STR_LIT:label>', label)<EOL>_validate_not_none('<STR_LIT:location>', location)<EOL>return self._perform_post(<EOL>'<STR_LIT:/>' + self.subscription_id + '<STR_LIT>',<EOL>_XmlSerializer.create_affinity_group_to_xml(name,<EOL>label,<EOL>description,<EOL>location))<EOL>", "docstring": "Creates a new affinity group for the specified subscription.\n\nname:\n    A name for the affinity group that is unique to the subscription.\nlabel:\n    A name for the affinity group. The name can be up to 100 characters\n    in length.\nlocation:\n    The data center location where the affinity group will be created.\n    To list available locations, use the list_location function.\ndescription:\n    A description for the affinity group. The description can be up to\n    1024 characters in length.", "id": "f41502:c0:m41"}
{"signature": "def create_deployment(self, service_name, deployment_slot, name,<EOL>package_url, label, configuration,<EOL>start_deployment=False,<EOL>treat_warnings_as_error=False,<EOL>extended_properties=None):", "body": "_validate_not_none('<STR_LIT>', service_name)<EOL>_validate_not_none('<STR_LIT>', deployment_slot)<EOL>_validate_not_none('<STR_LIT:name>', name)<EOL>_validate_not_none('<STR_LIT>', package_url)<EOL>_validate_not_none('<STR_LIT:label>', label)<EOL>_validate_not_none('<STR_LIT>', configuration)<EOL>return self._perform_post(<EOL>self._get_deployment_path_using_slot(<EOL>service_name, deployment_slot),<EOL>_XmlSerializer.create_deployment_to_xml(<EOL>name,<EOL>package_url,<EOL>label,<EOL>configuration,<EOL>start_deployment,<EOL>treat_warnings_as_error,<EOL>extended_properties),<EOL>as_async=True)<EOL>", "docstring": "Uploads a new service package and creates a new deployment on staging\nor production.\n\nservice_name:\n    Name of the hosted service.\ndeployment_slot:\n    The environment to which the hosted service is deployed. Valid\n    values are: staging, production\nname:\n    The name for the deployment. The deployment name must be unique\n    among other deployments for the hosted service.\npackage_url:\n    A URL that refers to the location of the service package in the\n    Blob service. The service package can be located either in a\n    storage account beneath the same subscription or a Shared Access\n    Signature (SAS) URI from any storage account.\nlabel:\n    A name for the hosted service. The name can be up to 100 characters\n    in length. It is recommended that the label be unique within the\n    subscription. The name can be used to identify the hosted service\n    for your tracking purposes.\nconfiguration:\n    The base-64 encoded service configuration file for the deployment.\nstart_deployment:\n    Indicates whether to start the deployment immediately after it is\n    created. If false, the service model is still deployed to the\n    virtual machines but the code is not run immediately. Instead, the\n    service is Suspended until you call Update Deployment Status and\n    set the status to Running, at which time the service will be\n    started. A deployed service still incurs charges, even if it is\n    suspended.\ntreat_warnings_as_error:\n    Indicates whether to treat package validation warnings as errors.\n    If set to true, the Created Deployment operation fails if there\n    are validation warnings on the service package.\nextended_properties:\n    Dictionary containing name/value pairs of storage account\n    properties. You can have a maximum of 50 extended property\n    name/value pairs. The maximum length of the Name element is 64\n    characters, only alphanumeric characters and underscores are valid\n    in the Name, and the name must start with a letter. The value has\n    a maximum length of 255 characters.", "id": "f41502:c0:m18"}
{"signature": "def share_vm_image(self, vm_image_name, permission):", "body": "_validate_not_none('<STR_LIT>', vm_image_name)<EOL>_validate_not_none('<STR_LIT>', permission)<EOL>path = self._get_sharing_path_using_vm_image_name(vm_image_name)<EOL>query = '<STR_LIT>' + permission<EOL>path = path + '<STR_LIT:?>' + query.lstrip('<STR_LIT:&>')<EOL>return self._perform_put(<EOL>path, None, as_async=True, x_ms_version='<STR_LIT>'<EOL>)<EOL>", "docstring": "Share an already replicated OS image. This operation is only for\npublishers. You have to be registered as image publisher with Windows\nAzure to be able to call this.\n\nvm_image_name:\n    The name of the virtual machine image to share\npermission:\n    The sharing permission: public, msdn, or private", "id": "f41502:c0:m73"}
{"signature": "def capture_vm_image(self, service_name, deployment_name, role_name, options):", "body": "_validate_not_none('<STR_LIT>', service_name)<EOL>_validate_not_none('<STR_LIT>', deployment_name)<EOL>_validate_not_none('<STR_LIT>', role_name)<EOL>_validate_not_none('<STR_LIT>', options)<EOL>_validate_not_none('<STR_LIT>', options.os_state)<EOL>_validate_not_none('<STR_LIT>', options.vm_image_name)<EOL>_validate_not_none('<STR_LIT>', options.vm_image_label)<EOL>return self._perform_post(<EOL>self._get_capture_vm_image_path(service_name, deployment_name, role_name),<EOL>_XmlSerializer.capture_vm_image_to_xml(options),<EOL>as_async=True)<EOL>", "docstring": "Creates a copy of the operating system virtual hard disk (VHD) and all\nof the data VHDs that are associated with the Virtual Machine, saves\nthe VHD copies in the same storage location as the original VHDs, and\nregisters the copies as a VM Image in the image repository that is\nassociated with the specified subscription.\n\nservice_name:\n    The name of the service.\ndeployment_name:\n    The name of the deployment.\nrole_name:\n    The name of the role.\noptions:\n    An instance of CaptureRoleAsVMImage class.\noptions.os_state:\n    Required. Specifies the state of the operating system in the image.\n    Possible values are: Generalized, Specialized \n    A Virtual Machine that is fully configured and running contains a\n    Specialized operating system. A Virtual Machine on which the\n    Sysprep command has been run with the generalize option contains a\n    Generalized operating system. If you capture an image from a\n    generalized Virtual Machine, the machine is deleted after the image\n    is captured. It is recommended that all Virtual Machines are shut\n    down before capturing an image.\noptions.vm_image_name:\n    Required. Specifies the name of the VM Image.\noptions.vm_image_label:\n    Required. Specifies the label of the VM Image.\noptions.description:\n    Optional. Specifies the description of the VM Image.\noptions.language:\n    Optional. Specifies the language of the VM Image.\noptions.image_family:\n    Optional. Specifies a value that can be used to group VM Images.\noptions.recommended_vm_size:\n    Optional. Specifies the size to use for the Virtual Machine that\n    is created from the VM Image.", "id": "f41502:c0:m74"}
{"signature": "def list_resource_extension_versions(self, publisher_name, extension_name):", "body": "return self._perform_get(self._get_resource_extension_versions_path(<EOL>publisher_name, extension_name),<EOL>ResourceExtensions)<EOL>", "docstring": "Lists the versions of a resource extension that are available to add\nto a Virtual Machine.\n\npublisher_name:\n    Name of the resource extension publisher.\nextension_name:\n    Name of the resource extension.", "id": "f41502:c0:m70"}
{"signature": "def getheaders(self):", "body": "return self.headers<EOL>", "docstring": "Returns response headers.", "id": "f41503:c0:m1"}
{"signature": "def set_tunnel(self, host, port=None, headers=None):", "body": "self._httprequest.set_tunnel(unicode(host), unicode(str(port)))<EOL>", "docstring": "Sets up the host and the port for the HTTP CONNECT Tunnelling.", "id": "f41505:c5:m2"}
{"signature": "def endheaders(self):", "body": "pass<EOL>", "docstring": "No operation. Exists only to provide the same interface of httplib\n        HTTPConnection.", "id": "f41505:c5:m6"}
{"signature": "def send(self, request=None):", "body": "<EOL>if request is None:<EOL><INDENT>var_empty = VARIANT.create_empty()<EOL>_WinHttpRequest._Send(self, var_empty)<EOL><DEDENT>else:  <EOL><INDENT>_request = VARIANT.create_safearray_from_str(request)<EOL>_WinHttpRequest._Send(self, _request)<EOL><DEDENT>", "docstring": "Sends the request body.", "id": "f41505:c3:m4"}
{"signature": "def getresponse(self):", "body": "status = self._httprequest.status()<EOL>status_text = self._httprequest.status_text()<EOL>resp_headers = self._httprequest.get_all_response_headers()<EOL>fixed_headers = []<EOL>for resp_header in resp_headers.split('<STR_LIT:\\n>'):<EOL><INDENT>if (resp_header.startswith('<STR_LIT:\\t>') orresp_header.startswith('<STR_LIT:U+0020>')) and fixed_headers:<EOL><INDENT>fixed_headers[-<NUM_LIT:1>] += resp_header<EOL><DEDENT>else:<EOL><INDENT>fixed_headers.append(resp_header)<EOL><DEDENT><DEDENT>headers = []<EOL>for resp_header in fixed_headers:<EOL><INDENT>if '<STR_LIT::>' in resp_header:<EOL><INDENT>pos = resp_header.find('<STR_LIT::>')<EOL>headers.append(<EOL>(resp_header[:pos].lower(), resp_header[pos + <NUM_LIT:1>:].strip()))<EOL><DEDENT><DEDENT>body = self._httprequest.response_body()<EOL>length = len(body)<EOL>return _Response(status, status_text, length, headers, body)<EOL>", "docstring": "Gets the response and generates the _Response object", "id": "f41505:c5:m8"}
{"signature": "def putrequest(self, method, uri):", "body": "protocol = unicode(self.protocol + '<STR_LIT>')<EOL>url = protocol + self.host + unicode(uri)<EOL>self._httprequest.set_timeout(self.timeout)<EOL>self._httprequest.open(unicode(method), url)<EOL>if self.cert_file is not None:<EOL><INDENT>self._httprequest.set_client_certificate(unicode(self.cert_file))<EOL><DEDENT>", "docstring": "Connects to host and sends the request.", "id": "f41505:c5:m4"}
{"signature": "def perform_request(self, request):", "body": "connection = self.get_connection(request)<EOL>try:<EOL><INDENT>connection.putrequest(request.method, request.path)<EOL>if not self.request_session:<EOL><INDENT>if self.proxy_host and self.proxy_user:<EOL><INDENT>connection.set_proxy_credentials(<EOL>self.proxy_user, self.proxy_password)<EOL><DEDENT><DEDENT>self.send_request_headers(connection, request.headers)<EOL>self.send_request_body(connection, request.body)<EOL>if DEBUG_REQUESTS and request.body:<EOL><INDENT>print('<STR_LIT>')<EOL>try:<EOL><INDENT>print(request.body)<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>resp = connection.getresponse()<EOL>status = int(resp.status)<EOL>message = resp.reason<EOL>respheaders = resp.getheaders()<EOL>for i, value in enumerate(respheaders):<EOL><INDENT>respheaders[i] = (value[<NUM_LIT:0>].lower(), value[<NUM_LIT:1>])<EOL><DEDENT>respbody = None<EOL>if resp.length is None:<EOL><INDENT>respbody = resp.read()<EOL><DEDENT>elif resp.length > <NUM_LIT:0>:<EOL><INDENT>respbody = resp.read(resp.length)<EOL><DEDENT>if DEBUG_RESPONSES and respbody:<EOL><INDENT>print('<STR_LIT>')<EOL>try:<EOL><INDENT>print(respbody)<EOL><DEDENT>except:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>response = HTTPResponse(<EOL>status, resp.reason, respheaders, respbody)<EOL>if status == <NUM_LIT>:<EOL><INDENT>new_url = urlparse(dict(respheaders)['<STR_LIT:location>'])<EOL>request.host = new_url.hostname<EOL>request.path = new_url.path<EOL>request.path, request.query = self._update_request_uri_query(request)<EOL>return self.perform_request(request)<EOL><DEDENT>if status >= <NUM_LIT>:<EOL><INDENT>raise HTTPError(status, message, respheaders, respbody)<EOL><DEDENT>return response<EOL><DEDENT>finally:<EOL><INDENT>connection.close()<EOL><DEDENT>", "docstring": "Sends request to cloud service server and return the response.", "id": "f41506:c0:m7"}
{"signature": "def __init__(self, service_instance, cert_file=None, protocol='<STR_LIT>',<EOL>request_session=None, timeout=<NUM_LIT>, user_agent='<STR_LIT>'):", "body": "self.service_instance = service_instance<EOL>self.cert_file = cert_file<EOL>self.protocol = protocol<EOL>self.proxy_host = None<EOL>self.proxy_port = None<EOL>self.proxy_user = None<EOL>self.proxy_password = None<EOL>self.request_session = request_session<EOL>self.timeout = timeout<EOL>self.user_agent = user_agent<EOL>", "docstring": "service_instance:\n    service client instance.\ncert_file:\n    certificate file path or location in windows certificate store.\nprotocol:\n    http or https.\nrequest_session:\n    session object created with requests library (or compatible).\ntimeout:\n    timeout for the http request, in seconds.\nuser_agent:\n    user agent string to set in http header.", "id": "f41506:c0:m0"}
{"signature": "def get_server_event_logs(self, server_name, start_date,<EOL>interval_size_in_minutes, event_types='<STR_LIT>'):", "body": "_validate_not_none('<STR_LIT>', server_name)<EOL>_validate_not_none('<STR_LIT>', start_date)<EOL>_validate_not_none('<STR_LIT>', interval_size_in_minutes)<EOL>_validate_not_none('<STR_LIT>', event_types)<EOL>path = self._get_server_event_logs_path(server_name) +'<STR_LIT>'.format(<EOL>start_date, interval_size_in_minutes, event_types)<EOL>response = self._perform_get(path, None)<EOL>return _MinidomXmlToObject.parse_service_resources_response(<EOL>response, EventLog)<EOL>", "docstring": "Gets the event logs for an Azure SQL Database Server.\n\nserver_name:\n    Name of the server to retrieve the event logs from.\nstart_date:\n    The starting date and time of the events to retrieve in UTC format,\n    for example '2011-09-28 16:05:00'.\ninterval_size_in_minutes:\n    Size of the event logs to retrieve (in minutes).\n    Valid values are: 5, 60, or 1440.\nevent_types:\n    The event type of the log entries you want to retrieve.\n    Valid values are: \n        - connection_successful\n        - connection_failed\n        - connection_terminated\n        - deadlock\n        - throttling\n        - throttling_long_transaction\n    To return all event types pass in an empty string.", "id": "f41511:c0:m6"}
{"signature": "def set_server_admin_password(self, server_name, admin_password):", "body": "_validate_not_none('<STR_LIT>', server_name)<EOL>_validate_not_none('<STR_LIT>', admin_password)<EOL>return self._perform_post(<EOL>self._get_servers_path(server_name) + '<STR_LIT>',<EOL>_SqlManagementXmlSerializer.set_server_admin_password_to_xml(<EOL>admin_password<EOL>)<EOL>)<EOL>", "docstring": "Reset the administrator password for a server.\n\nserver_name:\n    Name of the server to change the password.\nadmin_password:\n    The new administrator password for the server.", "id": "f41511:c0:m2"}
{"signature": "def list_servers(self):", "body": "return self._perform_get(self._get_servers_path(),<EOL>Servers)<EOL>", "docstring": "List the SQL servers defined on the account.", "id": "f41511:c0:m4"}
{"signature": "def delete_firewall_rule(self, server_name, name):", "body": "_validate_not_none('<STR_LIT>', server_name)<EOL>_validate_not_none('<STR_LIT:name>', name)<EOL>return self._perform_delete(<EOL>self._get_firewall_rules_path(server_name, name))<EOL>", "docstring": "Deletes an Azure SQL Database server firewall rule.\n\nserver_name:\n    Name of the server with the firewall rule you want to delete.\nname:\n    Name of the firewall rule you want to delete.", "id": "f41511:c0:m9"}
{"signature": "def create_firewall_rule(self, server_name, name, start_ip_address,<EOL>end_ip_address):", "body": "_validate_not_none('<STR_LIT>', server_name)<EOL>_validate_not_none('<STR_LIT:name>', name)<EOL>_validate_not_none('<STR_LIT>', start_ip_address)<EOL>_validate_not_none('<STR_LIT>', end_ip_address)<EOL>return self._perform_post(<EOL>self._get_firewall_rules_path(server_name),<EOL>_SqlManagementXmlSerializer.create_firewall_rule_to_xml(<EOL>name, start_ip_address, end_ip_address<EOL>)<EOL>)<EOL>", "docstring": "Creates an Azure SQL Database server firewall rule.\n\nserver_name:\n    Name of the server to set the firewall rule on. \nname:\n    The name of the new firewall rule.\nstart_ip_address:\n    The lowest IP address in the range of the server-level firewall\n    setting. IP addresses equal to or greater than this can attempt to\n    connect to the server. The lowest possible IP address is 0.0.0.0.\nend_ip_address:\n    The highest IP address in the range of the server-level firewall\n    setting. IP addresses equal to or less than this can attempt to\n    connect to the server. The highest possible IP address is\n    255.255.255.255.", "id": "f41511:c0:m7"}
{"signature": "def create_server(self, admin_login, admin_password, location):", "body": "_validate_not_none('<STR_LIT>', admin_login)<EOL>_validate_not_none('<STR_LIT>', admin_password)<EOL>_validate_not_none('<STR_LIT:location>', location)<EOL>response = self.perform_post(<EOL>self._get_servers_path(),<EOL>_SqlManagementXmlSerializer.create_server_to_xml(<EOL>admin_login,<EOL>admin_password,<EOL>location<EOL>)<EOL>)<EOL>return _SqlManagementXmlSerializer.xml_to_create_server_response(<EOL>response.body)<EOL>", "docstring": "Create a new Azure SQL Database server.\n\nadmin_login:\n    The administrator login name for the new server.\nadmin_password:\n    The administrator login password for the new server.\nlocation:\n    The region to deploy the new server.", "id": "f41511:c0:m1"}
{"signature": "def _create_entry(entry_body):", "body": "updated_str = datetime.utcnow().isoformat()<EOL>if datetime.utcnow().utcoffset() is None:<EOL><INDENT>updated_str += '<STR_LIT>'<EOL><DEDENT>entry_start = '''<STR_LIT>'''<EOL>return entry_start.format(updated=updated_str, body=entry_body)<EOL>", "docstring": "Adds common part of entry to a given entry body and return the whole\n    xml.", "id": "f41512:m1"}
{"signature": "def _get_request_body(request_body):", "body": "if request_body is None:<EOL><INDENT>return b'<STR_LIT>'<EOL><DEDENT>if isinstance(request_body, WindowsAzureData):<EOL><INDENT>request_body = _convert_class_to_xml(request_body)<EOL><DEDENT>if isinstance(request_body, bytes):<EOL><INDENT>return request_body<EOL><DEDENT>if isinstance(request_body, _unicode_type):<EOL><INDENT>return request_body.encode('<STR_LIT:utf-8>')<EOL><DEDENT>request_body = str(request_body)<EOL>if isinstance(request_body, _unicode_type):<EOL><INDENT>return request_body.encode('<STR_LIT:utf-8>')<EOL><DEDENT>return request_body<EOL>", "docstring": "Converts an object into a request body.  If it's None\n    we'll return an empty string, if it's one of our objects it'll\n    convert it to XML and return it.  Otherwise we just use the object\n    directly", "id": "f41512:m6"}
{"signature": "def wait_for_operation_status(self,<EOL>request_id, wait_for_status='<STR_LIT>', timeout=<NUM_LIT:30>, sleep_interval=<NUM_LIT:5>,<EOL>progress_callback=wait_for_operation_status_progress_default_callback,<EOL>success_callback=wait_for_operation_status_success_default_callback,<EOL>failure_callback=wait_for_operation_status_failure_default_callback):", "body": "loops = timeout // sleep_interval + <NUM_LIT:1><EOL>start_time = time.time()<EOL>for _ in range(int(loops)):<EOL><INDENT>result = self.get_operation_status(request_id)<EOL>elapsed = time.time() - start_time<EOL>if result.status == wait_for_status:<EOL><INDENT>if success_callback is not None:<EOL><INDENT>success_callback(elapsed)<EOL><DEDENT>return result<EOL><DEDENT>elif result.error:<EOL><INDENT>if failure_callback is not None:<EOL><INDENT>ex = AzureAsyncOperationHttpError(_ERROR_ASYNC_OP_FAILURE, result.status, result)<EOL>failure_callback(elapsed, ex)<EOL><DEDENT>return result<EOL><DEDENT>else:<EOL><INDENT>if progress_callback is not None:<EOL><INDENT>progress_callback(elapsed)<EOL><DEDENT>time.sleep(sleep_interval)<EOL><DEDENT><DEDENT>if failure_callback is not None:<EOL><INDENT>ex = AzureAsyncOperationHttpError(_ERROR_ASYNC_OP_TIMEOUT, result.status, result)<EOL>failure_callback(elapsed, ex)<EOL><DEDENT>return result<EOL>", "docstring": "Waits for an asynchronous operation to complete.\n\nThis calls get_operation_status in a loop and returns when the expected\nstatus is reached. The result of get_operation_status is returned. By\ndefault, an exception is raised on timeout or error status.\n\nrequest_id:\n    The request ID for the request you wish to track.\nwait_for_status:\n    Status to wait for. Default is 'Succeeded'.\ntimeout:\n    Total timeout in seconds. Default is 30s.\nsleep_interval:\n    Sleep time in seconds for each iteration. Default is 5s.\nprogress_callback:\n    Callback for each iteration.\n    Default prints '.'.\n    Set it to None for no progress notification.\nsuccess_callback:\n    Callback on success. Default prints newline.\n    Set it to None for no success notification.\nfailure_callback:\n    Callback on failure. Default prints newline+error details then\n    raises exception.\n    Set it to None for no failure notification.", "id": "f41514:c0:m13"}
{"signature": "def perform_put(self, path, body, x_ms_version=None):", "body": "request = HTTPRequest()<EOL>request.method = '<STR_LIT>'<EOL>request.host = self.host<EOL>request.path = path<EOL>request.body = _get_request_body(body)<EOL>request.path, request.query = self._httpclient._update_request_uri_query(request)<EOL>request.headers = self._update_management_header(request, x_ms_version)<EOL>response = self._perform_request(request)<EOL>return response<EOL>", "docstring": "Performs a PUT request and returns the response.\n\npath:\n    Path to the resource.\n    Ex: '/<subscription-id>/services/hostedservices/<service-name>'\nbody:\n    Body for the PUT request.\nx_ms_version:\n    If specified, this is used for the x-ms-version header.\n    Otherwise, self.x_ms_version is used.", "id": "f41514:c0:m7"}
{"signature": "def set_proxy(self, host, port, user=None, password=None):", "body": "self._httpclient.set_proxy(host, port, user, password)<EOL>", "docstring": "Sets the proxy server host and port for the HTTP CONNECT Tunnelling.\n\nhost:\n    Address of the proxy. Ex: '192.168.0.100'\nport:\n    Port of the proxy. Ex: 6000\nuser:\n    User for proxy authorization.\npassword:\n    Password for proxy authorization.", "id": "f41514:c0:m3"}
{"signature": "def parse_response_for_async_op(response):", "body": "if response is None:<EOL><INDENT>return None<EOL><DEDENT>result = AsynchronousOperationResult()<EOL>if response.headers:<EOL><INDENT>for name, value in response.headers:<EOL><INDENT>if name.lower() == '<STR_LIT>':<EOL><INDENT>result.request_id = value<EOL><DEDENT><DEDENT><DEDENT>return result<EOL>", "docstring": "Extracts request id from response header.", "id": "f41514:m1"}
{"signature": "def get_operation_status(self, request_id):", "body": "_validate_not_none('<STR_LIT>', request_id)<EOL>return self._perform_get(<EOL>'<STR_LIT:/>' + self.subscription_id + '<STR_LIT>' + _str(request_id),<EOL>Operation)<EOL>", "docstring": "Returns the status of the specified operation. After calling an\nasynchronous operation, you can call Get Operation Status to determine\nwhether the operation has succeeded, failed, or is still in progress.\n\nrequest_id:\n    The request ID for the request you wish to track.", "id": "f41514:c0:m14"}
{"signature": "def perform_post(self, path, body, x_ms_version=None):", "body": "request = HTTPRequest()<EOL>request.method = '<STR_LIT:POST>'<EOL>request.host = self.host<EOL>request.path = path<EOL>request.body = _get_request_body(body)<EOL>request.path, request.query = self._httpclient._update_request_uri_query(request)<EOL>request.headers = self._update_management_header(request, x_ms_version)<EOL>response = self._perform_request(request)<EOL>return response<EOL>", "docstring": "Performs a POST request and returns the response.\n\npath:\n    Path to the resource.\n    Ex: '/<subscription-id>/services/hostedservices/<service-name>'\nbody:\n    Body for the POST request.\nx_ms_version:\n    If specified, this is used for the x-ms-version header.\n    Otherwise, self.x_ms_version is used.", "id": "f41514:c0:m8"}
{"signature": "@staticmethod<EOL><INDENT>def namespace_to_xml(region):<DEDENT>", "body": "body = '<STR_LIT>'<EOL>body += '<STR_LIT>'.join(['<STR_LIT>', region, '<STR_LIT>'])<EOL>body += '<STR_LIT>'<EOL>return _create_entry(body)<EOL>", "docstring": "Converts a service bus namespace description to xml\n\n        The xml format:\n<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"yes\"?>\n<entry xmlns=\"http://www.w3.org/2005/Atom\">\n    <content type=\"application/xml\">\n        <NamespaceDescription\n            xmlns=\"http://schemas.microsoft.com/netservices/2010/10/servicebus/connect\">\n            <Region>West US</Region>\n        </NamespaceDescription>\n    </content>\n</entry>", "id": "f41516:c4:m0"}
{"signature": "@staticmethod<EOL><INDENT>def xml_to_namespace_availability(xmlstr):<DEDENT>", "body": "xmldoc = minidom.parseString(xmlstr)<EOL>availability = AvailabilityResponse()<EOL>for desc in _MinidomXmlToObject.get_children_from_path(xmldoc, '<STR_LIT>', '<STR_LIT:content>',<EOL>'<STR_LIT>'):<EOL><INDENT>node_value = _MinidomXmlToObject.get_first_child_node_value(desc, '<STR_LIT>')<EOL>if node_value is not None:<EOL><INDENT>availability.result = _parse_bool(node_value)<EOL><DEDENT><DEDENT>return availability<EOL>", "docstring": "Converts xml response to service bus namespace availability\n\n        The xml format:\n<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<entry xmlns=\"http://www.w3.org/2005/Atom\">\n    <id>uuid:9fc7c652-1856-47ab-8d74-cd31502ea8e6;id=3683292</id>\n    <title type=\"text\"></title>\n    <updated>2013-04-16T03:03:37Z</updated>\n    <content type=\"application/xml\">\n        <NamespaceAvailability\n            xmlns=\"http://schemas.microsoft.com/netservices/2010/10/servicebus/connect\"\n            xmlns:i=\"http://www.w3.org/2001/XMLSchema-instance\">\n            <Result>false</Result>\n        </NamespaceAvailability>\n    </content>\n</entry>", "id": "f41516:c4:m3"}
{"signature": "@staticmethod<EOL><INDENT>def create_job_collection_to_xml(plan):<DEDENT>", "body": "if plan not in [\"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>raise ValueError(\"<STR_LIT>\")<EOL><DEDENT>body = '<STR_LIT>'<EOL>body += '<STR_LIT>'.join(['<STR_LIT>', plan, '<STR_LIT>'])<EOL>body += '<STR_LIT>'<EOL>return body<EOL>", "docstring": "<Resource xmlns:i=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns=\"http://schemas.microsoft.com/windowsazure\">\n<IntrinsicSettings>\n    <Plan>Standard</Plan>\n    <Quota>\n        <MaxJobCount>10</MaxJobCount>\n        <MaxRecurrence>\n            <Frequency>Second</Frequency>\n            <Interval>1</Interval>\n        </MaxRecurrence>\n    </Quota>\n</IntrinsicSettings>\n</Resource>", "id": "f41516:c5:m1"}
{"signature": "@staticmethod<EOL><INDENT>def _fill_scalar_list_of(xmldoc, element_type, parent_xml_element_name,<EOL>xml_element_name):<DEDENT>", "body": "xmlelements = _MinidomXmlToObject.get_child_nodes(xmldoc, parent_xml_element_name)<EOL>if xmlelements:<EOL><INDENT>xmlelements = _MinidomXmlToObject.get_child_nodes(xmlelements[<NUM_LIT:0>], xml_element_name)<EOL>return [_MinidomXmlToObject._get_node_value(xmlelement, element_type)for xmlelement in xmlelements]<EOL><DEDENT>", "docstring": "Converts an xml fragment into a list of scalar types.  The parent xml\n        element contains a flat list of xml elements which are converted into the\n        specified scalar type and added to the list.\n        Example:\n        xmldoc=\n    <Endpoints>\n        <Endpoint>http://{storage-service-name}.blob.core.windows.net/</Endpoint>\n        <Endpoint>http://{storage-service-name}.queue.core.windows.net/</Endpoint>\n        <Endpoint>http://{storage-service-name}.table.core.windows.net/</Endpoint>\n    </Endpoints>\n        element_type=str\n        parent_xml_element_name='Endpoints'\n        xml_element_name='Endpoint'", "id": "f41516:c1:m12"}
{"signature": "@staticmethod<EOL><INDENT>def parse_service_resources_response(response, return_type):<DEDENT>", "body": "doc = minidom.parseString(response.body)<EOL>return_obj = _list_of(return_type)<EOL>for node in _MinidomXmlToObject.get_children_from_path(doc, \"<STR_LIT>\", \"<STR_LIT>\"):<EOL><INDENT>local_obj = return_type()<EOL>_MinidomXmlToObject._fill_data_to_return_object(node, local_obj)<EOL>return_obj.append(local_obj)<EOL><DEDENT>return return_obj<EOL>", "docstring": "Parse the HTTPResponse's body and fill all the data into a class of\nreturn_type.", "id": "f41516:c1:m1"}
{"signature": "@staticmethod<EOL><INDENT>def odata_converter(data, str_type):<DEDENT>", "body": "if not str_type:<EOL><INDENT>return _str(data)<EOL><DEDENT>if str_type in [\"<STR_LIT>\", \"<STR_LIT>\"]:<EOL><INDENT>return float(data)<EOL><DEDENT>elif \"<STR_LIT>\" in str_type:<EOL><INDENT>return int(data)<EOL><DEDENT>else:<EOL><INDENT>return _str(data)<EOL><DEDENT>", "docstring": "Convert odata type\n        http://www.odata.org/documentation/odata-version-2-0/overview#AbstractTypeSystem\n        To be completed", "id": "f41516:c4:m4"}
{"signature": "@staticmethod<EOL><INDENT>def doc_from_xml(document_element_name, inner_xml,<EOL>xmlns='<STR_LIT>'):<DEDENT>", "body": "xml = '<STR_LIT>'.join(['<STR_LIT:<>', document_element_name,<EOL>'<STR_LIT>'.format(xmlns)])<EOL>xml += inner_xml<EOL>xml += '<STR_LIT>'.join(['<STR_LIT>', document_element_name, '<STR_LIT:>>'])<EOL>return xml<EOL>", "docstring": "Wraps the specified xml in an xml root element with default azure\n        namespaces", "id": "f41516:c3:m8"}
{"signature": "@staticmethod<EOL><INDENT>def _parse_response_body_from_xml_node(node, return_type):<DEDENT>", "body": "return_obj = return_type()<EOL>_MinidomXmlToObject._fill_data_to_return_object(node, return_obj)<EOL>return return_obj<EOL>", "docstring": "parse the xml and fill all the data into a class of return_type", "id": "f41516:c1:m10"}
{"signature": "def check_job_collection_name(self, cloud_service_id, job_collection_id):", "body": "_validate_not_none('<STR_LIT>', cloud_service_id)<EOL>_validate_not_none('<STR_LIT>', job_collection_id)<EOL>path = self._get_cloud_services_path(<EOL>cloud_service_id, \"<STR_LIT>\", \"<STR_LIT>\")<EOL>path += \"<STR_LIT>\" + job_collection_id<EOL>return self._perform_post(path, None, AvailabilityResponse)<EOL>", "docstring": "The Check Name Availability operation checks if a new job collection with\nthe given name may be created, or if it is unavailable. The result of the\noperation is a Boolean true or false.\n\ncloud_service_id:\n    The cloud service id\njob_collection_id:\n    The name of the job_collection_id.", "id": "f41517:c0:m5"}
{"signature": "def create_job_collection(self, cloud_service_id, job_collection_id, plan=\"<STR_LIT>\"):", "body": "_validate_not_none('<STR_LIT>', cloud_service_id)<EOL>_validate_not_none('<STR_LIT>', job_collection_id)<EOL>path = self._get_cloud_services_path(<EOL>cloud_service_id, \"<STR_LIT>\", \"<STR_LIT>\")<EOL>path += '<STR_LIT:/>' + _str(job_collection_id)<EOL>body = _SchedulerManagementXmlSerializer.create_job_collection_to_xml(<EOL>plan)<EOL>return self._perform_put(path, body, as_async=True)<EOL>", "docstring": "The Create Job Collection request is specified as follows. Replace <subscription-id>\nwith your subscription ID, <cloud-service-id> with your cloud service ID, and\n<job-collection-id> with the ID of the job collection you\\'d like to create.\nThere are no \"default\" pre-existing job collections every job collection\nmust be manually created.\n\ncloud_service_id:\n    The cloud service id\njob_collection_id:\n    Name of the hosted service.", "id": "f41517:c0:m6"}
{"signature": "def get_all_jobs(self, cloud_service_id, job_collection_id):", "body": "_validate_not_none('<STR_LIT>', cloud_service_id)<EOL>_validate_not_none('<STR_LIT>', job_collection_id)<EOL>path = self._get_job_collection_path(cloud_service_id, job_collection_id,\"<STR_LIT>\")<EOL>self.content_type = \"<STR_LIT:application/json>\"<EOL>payload = self._perform_get(path).body.decode()<EOL>return json.loads(payload)<EOL>", "docstring": "The Get All Jobs operation gets all the jobs in a job collection.\nThe full list of jobs can be accessed by excluding any job ID in the\nGET call (i.e. /jobs.)\n\nThe return type is\n\ncloud_service_id:\n    The cloud service id\njob_collection_id:\n    Name of the hosted service.", "id": "f41517:c0:m12"}
{"signature": "def move(<EOL>self, resource_group_name, target_resource_group, resource_ids, custom_headers=None, raw=False, **operation_config):", "body": "move_request = models.MapsAccountsMoveRequest(target_resource_group=target_resource_group, resource_ids=resource_ids)<EOL>url = self.move.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(move_request, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, body_content, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Moves Maps Accounts from one ResourceGroup (or Subscription) to\n        another.\n\n        :param resource_group_name: The name of the resource group that\n         contains Maps Account to move.\n        :type resource_group_name: str\n        :param target_resource_group: The name of the destination resource\n         group.\n        :type target_resource_group: str\n        :param resource_ids: A list of resource names to move from the source\n         resource group.\n        :type resource_ids: list[str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorException<azure.mgmt.maps.models.ErrorException>`", "id": "f41550:c0:m7"}
{"signature": "def list_operations(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_operations.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.MapsOperationsValueItemPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.MapsOperationsValueItemPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List operations available for the Maps Resource Provider.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of MapsOperationsValueItem\n        :rtype:\n         ~azure.mgmt.maps.models.MapsOperationsValueItemPaged[~azure.mgmt.maps.models.MapsOperationsValueItem]\n        :raises:\n         :class:`ErrorException<azure.mgmt.maps.models.ErrorException>`", "id": "f41550:c0:m10"}
{"signature": "def delete(<EOL>self, resource_group_name, account_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Delete a Maps Account.\n\n        :param resource_group_name: The name of the Azure Resource Group.\n        :type resource_group_name: str\n        :param account_name: The name of the Maps Account.\n        :type account_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorException<azure.mgmt.maps.models.ErrorException>`", "id": "f41550:c0:m3"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, account_name, maps_account_create_parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(maps_account_create_parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, body_content, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Create or update a Maps Account. A Maps Account holds the keys which\n        allow access to the Maps REST APIs.\n\n        :param resource_group_name: The name of the Azure Resource Group.\n        :type resource_group_name: str\n        :param account_name: The name of the Maps Account.\n        :type account_name: str\n        :param maps_account_create_parameters: The new or updated parameters\n         for the Maps Account.\n        :type maps_account_create_parameters:\n         ~azure.mgmt.maps.models.MapsAccountCreateParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: MapsAccount or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.maps.models.MapsAccount or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorException<azure.mgmt.maps.models.ErrorException>`", "id": "f41550:c0:m1"}
{"signature": "def list_keys(<EOL>self, resource_group_name, account_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_keys.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the keys to use with the Maps APIs. A key is used to authenticate\n        and authorize access to the Maps REST APIs. Only one key is needed at a\n        time; two are given to provide seamless key regeneration.\n\n        :param resource_group_name: The name of the Azure Resource Group.\n        :type resource_group_name: str\n        :param account_name: The name of the Maps Account.\n        :type account_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: MapsAccountKeys or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.maps.models.MapsAccountKeys or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorException<azure.mgmt.maps.models.ErrorException>`", "id": "f41550:c0:m8"}
{"signature": "def add_video_frame_url(<EOL>self, content_type, team_name, review_id, video_frame_body, timescale=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.add_video_frame_url.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", team_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", review_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if timescale is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timescale, '<STR_LIT:int>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>header_parameters['<STR_LIT:Content-Type>'] = self._serialize.header(\"<STR_LIT>\", content_type, '<STR_LIT:str>')<EOL>body_content = self._serialize.body(video_frame_body, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.APIErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Use this method to add frames for a video review.Timescale: This\n        parameter is a factor which is used to convert the timestamp on a frame\n        into milliseconds. Timescale is provided in the output of the Content\n        Moderator video media processor on the Azure Media Services\n        platform.Timescale in the Video Moderation output is Ticks/Second.\n\n        :param content_type: The content type.\n        :type content_type: str\n        :param team_name: Your team name.\n        :type team_name: str\n        :param review_id: Id of the review.\n        :type review_id: str\n        :param video_frame_body: Body for add video frames API\n        :type video_frame_body:\n         list[~azure.cognitiveservices.vision.contentmoderator.models.VideoFrameBodyItem]\n        :param timescale: Timescale of the video.\n        :type timescale: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`APIErrorException<azure.cognitiveservices.vision.contentmoderator.models.APIErrorException>`", "id": "f41559:c0:m11"}
{"signature": "def get_video_frames(<EOL>self, team_name, review_id, start_seed=None, no_of_records=None, filter=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_video_frames.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", team_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", review_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if start_seed is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", start_seed, '<STR_LIT:int>')<EOL><DEDENT>if no_of_records is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", no_of_records, '<STR_LIT:int>')<EOL><DEDENT>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.APIErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "The reviews created would show up for Reviewers on your team. As\n        Reviewers complete reviewing, results of the Review would be POSTED\n        (i.e. HTTP POST) on the specified CallBackEndpoint.\n        <h3>CallBack Schemas </h3>\n        <h4>Review Completion CallBack Sample</h4>\n        <p>\n        {<br/>\n        \"ReviewId\": \"<Review Id>\",<br/>\n        \"ModifiedOn\": \"2016-10-11T22:36:32.9934851Z\",<br/>\n        \"ModifiedBy\": \"<Name of the Reviewer>\",<br/>\n        \"CallBackType\": \"Review\",<br/>\n        \"ContentId\": \"<The ContentId that was specified input>\",<br/>\n        \"Metadata\": {<br/>\n        \"adultscore\": \"0.xxx\",<br/>\n        \"a\": \"False\",<br/>\n        \"racyscore\": \"0.xxx\",<br/>\n        \"r\": \"True\"<br/>\n        },<br/>\n        \"ReviewerResultTags\": {<br/>\n        \"a\": \"False\",<br/>\n        \"r\": \"True\"<br/>\n        }<br/>\n        }<br/>\n        </p>.\n\n        :param team_name: Your team name.\n        :type team_name: str\n        :param review_id: Id of the review.\n        :type review_id: str\n        :param start_seed: Time stamp of the frame from where you want to\n         start fetching the frames.\n        :type start_seed: int\n        :param no_of_records: Number of frames to fetch.\n        :type no_of_records: int\n        :param filter: Get frames filtered by tags.\n        :type filter: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Frames or ClientRawResponse if raw=true\n        :rtype: ~azure.cognitiveservices.vision.contentmoderator.models.Frames\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`APIErrorException<azure.cognitiveservices.vision.contentmoderator.models.APIErrorException>`", "id": "f41559:c0:m6"}
{"signature": "def add_video_frame_stream(<EOL>self, content_type, team_name, review_id, frame_image_zip, frame_metadata, timescale=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.add_video_frame_stream.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", team_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", review_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if timescale is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timescale, '<STR_LIT:int>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>header_parameters['<STR_LIT:Content-Type>'] = self._serialize.header(\"<STR_LIT>\", content_type, '<STR_LIT:str>')<EOL>form_data_content = {<EOL>'<STR_LIT>': frame_image_zip,<EOL>'<STR_LIT>': frame_metadata,<EOL>}<EOL>request = self._client.post(url, query_parameters, header_parameters, form_content=form_data_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.APIErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Use this method to add frames for a video review.Timescale: This\n        parameter is a factor which is used to convert the timestamp on a frame\n        into milliseconds. Timescale is provided in the output of the Content\n        Moderator video media processor on the Azure Media Services\n        platform.Timescale in the Video Moderation output is Ticks/Second.\n\n        :param content_type: The content type.\n        :type content_type: str\n        :param team_name: Your team name.\n        :type team_name: str\n        :param review_id: Id of the review.\n        :type review_id: str\n        :param frame_image_zip: Zip file containing frame images.\n        :type frame_image_zip: Generator\n        :param frame_metadata: Metadata of the frame.\n        :type frame_metadata: str\n        :param timescale: Timescale of the video .\n        :type timescale: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`APIErrorException<azure.cognitiveservices.vision.contentmoderator.models.APIErrorException>`", "id": "f41559:c0:m12"}
{"signature": "def get_details(<EOL>self, list_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_details.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", list_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.APIErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Returns the details of the image list with list Id equal to list Id\n        passed.\n\n        :param list_id: List Id of the image list.\n        :type list_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ImageList or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.cognitiveservices.vision.contentmoderator.models.ImageList or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`APIErrorException<azure.cognitiveservices.vision.contentmoderator.models.APIErrorException>`", "id": "f41561:c0:m1"}
{"signature": "def create(<EOL>self, content_type, body, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>header_parameters['<STR_LIT:Content-Type>'] = self._serialize.header(\"<STR_LIT>\", content_type, '<STR_LIT:str>')<EOL>body_content = self._serialize.body(body, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.APIErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates a Term List.\n\n        :param content_type: The content type.\n        :type content_type: str\n        :param body: Schema of the body.\n        :type body:\n         ~azure.cognitiveservices.vision.contentmoderator.models.Body\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: TermList or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.cognitiveservices.vision.contentmoderator.models.TermList or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`APIErrorException<azure.cognitiveservices.vision.contentmoderator.models.APIErrorException>`", "id": "f41562:c0:m4"}
{"signature": "def get_details(<EOL>self, list_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_details.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", list_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.APIErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Returns list Id details of the term list with list Id equal to list Id\n        passed.\n\n        :param list_id: List Id of the image list.\n        :type list_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: TermList or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.cognitiveservices.vision.contentmoderator.models.TermList or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`APIErrorException<azure.cognitiveservices.vision.contentmoderator.models.APIErrorException>`", "id": "f41562:c0:m1"}
{"signature": "def find_faces_url_input(<EOL>self, content_type, cache_image=None, data_representation=\"<STR_LIT>\", value=None, custom_headers=None, raw=False, **operation_config):", "body": "image_url = models.BodyModel(data_representation=data_representation, value=value)<EOL>url = self.find_faces_url_input.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if cache_image is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", cache_image, '<STR_LIT:bool>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>header_parameters['<STR_LIT:Content-Type>'] = self._serialize.header(\"<STR_LIT>\", content_type, '<STR_LIT:str>')<EOL>body_content = self._serialize.body(image_url, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.APIErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Returns the list of faces found.\n\n        :param content_type: The content type.\n        :type content_type: str\n        :param cache_image: Whether to retain the submitted image for future\n         use; defaults to false if omitted.\n        :type cache_image: bool\n        :param data_representation:\n        :type data_representation: str\n        :param value:\n        :type value: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: FoundFaces or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.cognitiveservices.vision.contentmoderator.models.FoundFaces or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`APIErrorException<azure.cognitiveservices.vision.contentmoderator.models.APIErrorException>`", "id": "f41563:c0:m6"}
{"signature": "def ocr_file_input(<EOL>self, language, image_stream, cache_image=None, enhanced=False, custom_headers=None, raw=False, callback=None, **operation_config):", "body": "<EOL>url = self.ocr_file_input.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", language, '<STR_LIT:str>')<EOL>if cache_image is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", cache_image, '<STR_LIT:bool>')<EOL><DEDENT>if enhanced is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", enhanced, '<STR_LIT:bool>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._client.stream_upload(image_stream, callback)<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.APIErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Returns any text found in the image for the language specified. If no\n        language is specified in input then the detection defaults to English.\n\n        :param language: Language of the terms.\n        :type language: str\n        :param image_stream: The image file.\n        :type image_stream: Generator\n        :param cache_image: Whether to retain the submitted image for future\n         use; defaults to false if omitted.\n        :type cache_image: bool\n        :param enhanced: When set to True, the image goes through additional\n         processing to come with additional candidates.\n         image/tiff is not supported when enhanced is set to true\n         Note: This impacts the response time.\n        :type enhanced: bool\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param callback: When specified, will be called with each chunk of\n         data that is streamed. The callback should take two arguments, the\n         bytes of the current chunk of data and the response object. If the\n         data is uploading, response will be None.\n        :type callback: Callable[Bytes, response=None]\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: OCR or ClientRawResponse if raw=true\n        :rtype: ~azure.cognitiveservices.vision.contentmoderator.models.OCR or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`APIErrorException<azure.cognitiveservices.vision.contentmoderator.models.APIErrorException>`", "id": "f41563:c0:m8"}
{"signature": "def evaluate_method(<EOL>self, cache_image=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.evaluate_method.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if cache_image is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", cache_image, '<STR_LIT:bool>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.APIErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Returns probabilities of the image containing racy or adult content.\n\n        :param cache_image: Whether to retain the submitted image for future\n         use; defaults to false if omitted.\n        :type cache_image: bool\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Evaluate or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.cognitiveservices.vision.contentmoderator.models.Evaluate or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`APIErrorException<azure.cognitiveservices.vision.contentmoderator.models.APIErrorException>`", "id": "f41563:c0:m3"}
{"signature": "def add_image(<EOL>self, list_id, tag=None, label=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.add_image.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", list_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if tag is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", tag, '<STR_LIT:int>')<EOL><DEDENT>if label is not None:<EOL><INDENT>query_parameters['<STR_LIT:label>'] = self._serialize.query(\"<STR_LIT:label>\", label, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.APIErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Add an image to the list with list Id equal to list Id passed.\n\n        :param list_id: List Id of the image list.\n        :type list_id: str\n        :param tag: Tag for the image.\n        :type tag: int\n        :param label: The image label.\n        :type label: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Image or ClientRawResponse if raw=true\n        :rtype: ~azure.cognitiveservices.vision.contentmoderator.models.Image\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`APIErrorException<azure.cognitiveservices.vision.contentmoderator.models.APIErrorException>`", "id": "f41565:c0:m1"}
{"signature": "def add_image_file_input(<EOL>self, list_id, image_stream, tag=None, label=None, custom_headers=None, raw=False, callback=None, **operation_config):", "body": "<EOL>url = self.add_image_file_input.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", list_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if tag is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", tag, '<STR_LIT:int>')<EOL><DEDENT>if label is not None:<EOL><INDENT>query_parameters['<STR_LIT:label>'] = self._serialize.query(\"<STR_LIT:label>\", label, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._client.stream_upload(image_stream, callback)<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.APIErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Add an image to the list with list Id equal to list Id passed.\n\n        :param list_id: List Id of the image list.\n        :type list_id: str\n        :param image_stream: The image file.\n        :type image_stream: Generator\n        :param tag: Tag for the image.\n        :type tag: int\n        :param label: The image label.\n        :type label: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param callback: When specified, will be called with each chunk of\n         data that is streamed. The callback should take two arguments, the\n         bytes of the current chunk of data and the response object. If the\n         data is uploading, response will be None.\n        :type callback: Callable[Bytes, response=None]\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Image or ClientRawResponse if raw=true\n        :rtype: ~azure.cognitiveservices.vision.contentmoderator.models.Image\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`APIErrorException<azure.cognitiveservices.vision.contentmoderator.models.APIErrorException>`", "id": "f41565:c0:m6"}
{"signature": "def add_image_url_input(<EOL>self, list_id, content_type, tag=None, label=None, data_representation=\"<STR_LIT>\", value=None, custom_headers=None, raw=False, **operation_config):", "body": "image_url = models.BodyModel(data_representation=data_representation, value=value)<EOL>url = self.add_image_url_input.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", list_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if tag is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", tag, '<STR_LIT:int>')<EOL><DEDENT>if label is not None:<EOL><INDENT>query_parameters['<STR_LIT:label>'] = self._serialize.query(\"<STR_LIT:label>\", label, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>header_parameters['<STR_LIT:Content-Type>'] = self._serialize.header(\"<STR_LIT>\", content_type, '<STR_LIT:str>')<EOL>body_content = self._serialize.body(image_url, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.APIErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Add an image to the list with list Id equal to list Id passed.\n\n        :param list_id: List Id of the image list.\n        :type list_id: str\n        :param content_type: The content type.\n        :type content_type: str\n        :param tag: Tag for the image.\n        :type tag: int\n        :param label: The image label.\n        :type label: str\n        :param data_representation:\n        :type data_representation: str\n        :param value:\n        :type value: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Image or ClientRawResponse if raw=true\n        :rtype: ~azure.cognitiveservices.vision.contentmoderator.models.Image\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`APIErrorException<azure.cognitiveservices.vision.contentmoderator.models.APIErrorException>`", "id": "f41565:c0:m5"}
{"signature": "def delete_all_terms(<EOL>self, list_id, language, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete_all_terms.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", list_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", language, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.APIErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT:str>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Deletes all terms from the list with list Id equal to the list Id\n        passed.\n\n        :param list_id: List Id of the image list.\n        :type list_id: str\n        :param language: Language of the terms.\n        :type language: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: str or ClientRawResponse if raw=true\n        :rtype: str or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`APIErrorException<azure.cognitiveservices.vision.contentmoderator.models.APIErrorException>`", "id": "f41566:c0:m4"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.UsagePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.UsagePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the current usage count and the limit for the resources under the\n        subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Usage\n        :rtype:\n         ~azure.mgmt.storage.v2016_01_01.models.UsagePaged[~azure.mgmt.storage.v2016_01_01.models.Usage]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41610:c0:m1"}
{"signature": "def get_properties(<EOL>self, resource_group_name, account_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_properties.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Returns the properties for the specified storage account including but\n        not limited to name, SKU name, location, and account status. The\n        ListKeys operation should be used to retrieve storage keys.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription.\n        :type resource_group_name: str\n        :param account_name: The name of the storage account within the\n         specified resource group. Storage account names must be between 3 and\n         24 characters in length and use numbers and lower-case letters only.\n        :type account_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: StorageAccount or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.storage.v2016_01_01.models.StorageAccount or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41612:c0:m5"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.StorageAccountPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.StorageAccountPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all the storage accounts available under the subscription. Note\n        that storage keys are not returned; use the ListKeys operation for\n        this.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of StorageAccount\n        :rtype:\n         ~azure.mgmt.storage.v2016_01_01.models.StorageAccountPaged[~azure.mgmt.storage.v2016_01_01.models.StorageAccount]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41612:c0:m7"}
{"signature": "def regenerate_key(<EOL>self, resource_group_name, account_name, key_name, custom_headers=None, raw=False, **operation_config):", "body": "regenerate_key1 = models.StorageAccountRegenerateKeyParameters(key_name=key_name)<EOL>url = self.regenerate_key.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(regenerate_key1, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Regenerates one of the access keys for the specified storage account.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription.\n        :type resource_group_name: str\n        :param account_name: The name of the storage account within the\n         specified resource group. Storage account names must be between 3 and\n         24 characters in length and use numbers and lower-case letters only.\n        :type account_name: str\n        :param key_name:\n        :type key_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: StorageAccountListKeysResult or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.storage.v2016_01_01.models.StorageAccountListKeysResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41612:c0:m10"}
{"signature": "def update(<EOL>self, resource_group_name, account_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "The update operation can be used to update the SKU, encryption, access\n        tier, or tags for a storage account. It can also be used to map the\n        account to a custom domain. Only one custom domain is supported per\n        storage account; the replacement/change of custom domain is not\n        supported. In order to replace an old custom domain, the old value must\n        be cleared/unregistered before a new value can be set. The update of\n        multiple properties is supported. This call does not change the storage\n        keys for the account. If you want to change the storage account keys,\n        use the regenerate keys operation. The location and name of the storage\n        account cannot be changed after creation.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription.\n        :type resource_group_name: str\n        :param account_name: The name of the storage account within the\n         specified resource group. Storage account names must be between 3 and\n         24 characters in length and use numbers and lower-case letters only.\n        :type account_name: str\n        :param parameters: The parameters to provide for the updated account.\n        :type parameters:\n         ~azure.mgmt.storage.v2016_01_01.models.StorageAccountUpdateParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: StorageAccount or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.storage.v2016_01_01.models.StorageAccount or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41612:c0:m6"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.UsagePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.UsagePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the current usage count and the limit for the resources under the\n        subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Usage\n        :rtype:\n         ~azure.mgmt.storage.v2016_12_01.models.UsagePaged[~azure.mgmt.storage.v2016_12_01.models.Usage]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41652:c0:m1"}
{"signature": "def list_keys(<EOL>self, resource_group_name, account_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_keys.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists the access keys for the specified storage account.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription. The name is case insensitive.\n        :type resource_group_name: str\n        :param account_name: The name of the storage account within the\n         specified resource group. Storage account names must be between 3 and\n         24 characters in length and use numbers and lower-case letters only.\n        :type account_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: StorageAccountListKeysResult or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.storage.v2016_12_01.models.StorageAccountListKeysResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41653:c0:m9"}
{"signature": "def update(<EOL>self, resource_group_name, account_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "The update operation can be used to update the SKU, encryption, access\n        tier, or tags for a storage account. It can also be used to map the\n        account to a custom domain. Only one custom domain is supported per\n        storage account; the replacement/change of custom domain is not\n        supported. In order to replace an old custom domain, the old value must\n        be cleared/unregistered before a new value can be set. The update of\n        multiple properties is supported. This call does not change the storage\n        keys for the account. If you want to change the storage account keys,\n        use the regenerate keys operation. The location and name of the storage\n        account cannot be changed after creation.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription. The name is case insensitive.\n        :type resource_group_name: str\n        :param account_name: The name of the storage account within the\n         specified resource group. Storage account names must be between 3 and\n         24 characters in length and use numbers and lower-case letters only.\n        :type account_name: str\n        :param parameters: The parameters to provide for the updated account.\n        :type parameters:\n         ~azure.mgmt.storage.v2016_12_01.models.StorageAccountUpdateParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: StorageAccount or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.storage.v2016_12_01.models.StorageAccount or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41653:c0:m6"}
{"signature": "def regenerate_key(<EOL>self, resource_group_name, account_name, key_name, custom_headers=None, raw=False, **operation_config):", "body": "regenerate_key1 = models.StorageAccountRegenerateKeyParameters(key_name=key_name)<EOL>url = self.regenerate_key.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(regenerate_key1, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Regenerates one of the access keys for the specified storage account.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription. The name is case insensitive.\n        :type resource_group_name: str\n        :param account_name: The name of the storage account within the\n         specified resource group. Storage account names must be between 3 and\n         24 characters in length and use numbers and lower-case letters only.\n        :type account_name: str\n        :param key_name:\n        :type key_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: StorageAccountListKeysResult or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.storage.v2016_12_01.models.StorageAccountListKeysResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41653:c0:m10"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SkuPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SkuPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists the available SKUs supported by Microsoft.Storage for given\n        subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Sku\n        :rtype:\n         ~azure.mgmt.storage.v2017_06_01.models.SkuPaged[~azure.mgmt.storage.v2017_06_01.models.Sku]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41714:c0:m1"}
{"signature": "def list_service_sas(<EOL>self, resource_group_name, account_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_service_sas.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List service SAS credentials of a specific resource.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription. The name is case insensitive.\n        :type resource_group_name: str\n        :param account_name: The name of the storage account within the\n         specified resource group. Storage account names must be between 3 and\n         24 characters in length and use numbers and lower-case letters only.\n        :type account_name: str\n        :param parameters: The parameters to provide to list service SAS\n         credentials.\n        :type parameters:\n         ~azure.mgmt.storage.v2017_06_01.models.ServiceSasParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ListServiceSasResponse or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.storage.v2017_06_01.models.ListServiceSasResponse\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41717:c0:m12"}
{"signature": "def check_name_availability(<EOL>self, name, custom_headers=None, raw=False, **operation_config):", "body": "account_name = models.StorageAccountCheckNameAvailabilityParameters(name=name)<EOL>url = self.check_name_availability.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(account_name, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Checks that the storage account name is valid and is not already in\n        use.\n\n        :param name: The storage account name.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: CheckNameAvailabilityResult or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.storage.v2017_06_01.models.CheckNameAvailabilityResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41717:c0:m1"}
{"signature": "def create(<EOL>self, resource_group_name, account_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_initial(<EOL>resource_group_name=resource_group_name,<EOL>account_name=account_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Asynchronously creates a new storage account with the specified\n        parameters. If an account is already created and a subsequent create\n        request is issued with different properties, the account properties\n        will be updated. If an account is already created and a subsequent\n        create or update request is issued with the exact same set of\n        properties, the request will succeed.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription. The name is case insensitive.\n        :type resource_group_name: str\n        :param account_name: The name of the storage account within the\n         specified resource group. Storage account names must be between 3 and\n         24 characters in length and use numbers and lower-case letters only.\n        :type account_name: str\n        :param parameters: The parameters to provide for the created account.\n        :type parameters:\n         ~azure.mgmt.storage.v2017_06_01.models.StorageAccountCreateParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns StorageAccount or\n         ClientRawResponse<StorageAccount> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.storage.v2017_06_01.models.StorageAccount]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.storage.v2017_06_01.models.StorageAccount]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41717:c0:m3"}
{"signature": "def get_properties(<EOL>self, resource_group_name, account_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_properties.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Returns the properties for the specified storage account including but\n        not limited to name, SKU name, location, and account status. The\n        ListKeys operation should be used to retrieve storage keys.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription. The name is case insensitive.\n        :type resource_group_name: str\n        :param account_name: The name of the storage account within the\n         specified resource group. Storage account names must be between 3 and\n         24 characters in length and use numbers and lower-case letters only.\n        :type account_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: StorageAccount or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.storage.v2017_06_01.models.StorageAccount or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41717:c0:m5"}
{"signature": "def list_account_sas(<EOL>self, resource_group_name, account_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_account_sas.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List SAS credentials of a storage account.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription. The name is case insensitive.\n        :type resource_group_name: str\n        :param account_name: The name of the storage account within the\n         specified resource group. Storage account names must be between 3 and\n         24 characters in length and use numbers and lower-case letters only.\n        :type account_name: str\n        :param parameters: The parameters to provide to list SAS credentials\n         for the storage account.\n        :type parameters:\n         ~azure.mgmt.storage.v2017_06_01.models.AccountSasParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ListAccountSasResponse or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.storage.v2017_06_01.models.ListAccountSasResponse\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41717:c0:m11"}
{"signature": "def update(<EOL>self, resource_group_name, account_name, container_name, public_access=None, metadata=None, custom_headers=None, raw=False, **operation_config):", "body": "blob_container = models.BlobContainer(public_access=public_access, metadata=metadata)<EOL>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", container_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(blob_container, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Updates container properties as specified in request body. Properties\n        not mentioned in the request will be unchanged. Update fails if the\n        specified container doesn't already exist. .\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription. The name is case insensitive.\n        :type resource_group_name: str\n        :param account_name: The name of the storage account within the\n         specified resource group. Storage account names must be between 3 and\n         24 characters in length and use numbers and lower-case letters only.\n        :type account_name: str\n        :param container_name: The name of the blob container within the\n         specified storage account. Blob container names must be between 3 and\n         63 characters in length and use numbers, lower-case letters and dash\n         (-) only. Every dash (-) character must be immediately preceded and\n         followed by a letter or number.\n        :type container_name: str\n        :param public_access: Specifies whether data in the container may be\n         accessed publicly and the level of access. Possible values include:\n         'Container', 'Blob', 'None'\n        :type public_access: str or\n         ~azure.mgmt.storage.v2018_03_01_preview.models.PublicAccess\n        :param metadata: A name-value pair to associate with the container as\n         metadata.\n        :type metadata: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: BlobContainer or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.storage.v2018_03_01_preview.models.BlobContainer\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41790:c0:m3"}
{"signature": "def list(<EOL>self, resource_group_name, account_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all containers and does not support a prefix like data plane.\n        Also SRP today does not return continuation token.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription. The name is case insensitive.\n        :type resource_group_name: str\n        :param account_name: The name of the storage account within the\n         specified resource group. Storage account names must be between 3 and\n         24 characters in length and use numbers and lower-case letters only.\n        :type account_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ListContainerItems or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.storage.v2018_03_01_preview.models.ListContainerItems or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41790:c0:m1"}
{"signature": "def delete(<EOL>self, resource_group_name, account_name, container_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", container_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes specified container under its account.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription. The name is case insensitive.\n        :type resource_group_name: str\n        :param account_name: The name of the storage account within the\n         specified resource group. Storage account names must be between 3 and\n         24 characters in length and use numbers and lower-case letters only.\n        :type account_name: str\n        :param container_name: The name of the blob container within the\n         specified storage account. Blob container names must be between 3 and\n         63 characters in length and use numbers, lower-case letters and dash\n         (-) only. Every dash (-) character must be immediately preceded and\n         followed by a letter or number.\n        :type container_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41790:c0:m5"}
{"signature": "def lock_immutability_policy(<EOL>self, resource_group_name, account_name, container_name, if_match, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.lock_immutability_policy.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", container_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_match, '<STR_LIT:str>')<EOL>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>header_dict = {}<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>header_dict = {<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>}<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>client_raw_response.add_headers(header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Sets the ImmutabilityPolicy to Locked state. The only action allowed on\n        a Locked policy is ExtendImmutabilityPolicy action. ETag in If-Match is\n        required for this operation.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription. The name is case insensitive.\n        :type resource_group_name: str\n        :param account_name: The name of the storage account within the\n         specified resource group. Storage account names must be between 3 and\n         24 characters in length and use numbers and lower-case letters only.\n        :type account_name: str\n        :param container_name: The name of the blob container within the\n         specified storage account. Blob container names must be between 3 and\n         63 characters in length and use numbers, lower-case letters and dash\n         (-) only. Every dash (-) character must be immediately preceded and\n         followed by a letter or number.\n        :type container_name: str\n        :param if_match: The entity state (ETag) version of the immutability\n         policy to update. A value of \"*\" can be used to apply the operation\n         only if the immutability policy already exists. If omitted, this\n         operation will always be applied.\n        :type if_match: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ImmutabilityPolicy or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.storage.v2018_03_01_preview.models.ImmutabilityPolicy or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41790:c0:m11"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.OperationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.OperationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all of the available Storage Rest API operations.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Operation\n        :rtype:\n         ~azure.mgmt.storage.v2018_03_01_preview.models.OperationPaged[~azure.mgmt.storage.v2018_03_01_preview.models.Operation]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41791:c0:m1"}
{"signature": "def get_management_policies(<EOL>self, resource_group_name, account_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_management_policies.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.management_policy_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the data policy rules associated with the specified storage\n        account.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription. The name is case insensitive.\n        :type resource_group_name: str\n        :param account_name: The name of the storage account within the\n         specified resource group. Storage account names must be between 3 and\n         24 characters in length and use numbers and lower-case letters only.\n        :type account_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: StorageAccountManagementPolicies or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.storage.v2018_03_01_preview.models.StorageAccountManagementPolicies\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41794:c0:m13"}
{"signature": "def update(<EOL>self, resource_group_name, account_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "The update operation can be used to update the SKU, encryption, access\n        tier, or tags for a storage account. It can also be used to map the\n        account to a custom domain. Only one custom domain is supported per\n        storage account; the replacement/change of custom domain is not\n        supported. In order to replace an old custom domain, the old value must\n        be cleared/unregistered before a new value can be set. The update of\n        multiple properties is supported. This call does not change the storage\n        keys for the account. If you want to change the storage account keys,\n        use the regenerate keys operation. The location and name of the storage\n        account cannot be changed after creation.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription. The name is case insensitive.\n        :type resource_group_name: str\n        :param account_name: The name of the storage account within the\n         specified resource group. Storage account names must be between 3 and\n         24 characters in length and use numbers and lower-case letters only.\n        :type account_name: str\n        :param parameters: The parameters to provide for the updated account.\n        :type parameters:\n         ~azure.mgmt.storage.v2018_03_01_preview.models.StorageAccountUpdateParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: StorageAccount or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.storage.v2018_03_01_preview.models.StorageAccount\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41794:c0:m6"}
{"signature": "def check_name_availability(<EOL>self, name, custom_headers=None, raw=False, **operation_config):", "body": "account_name = models.StorageAccountCheckNameAvailabilityParameters(name=name)<EOL>url = self.check_name_availability.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(account_name, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Checks that the storage account name is valid and is not already in\n        use.\n\n        :param name: The storage account name.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: CheckNameAvailabilityResult or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.storage.v2018_03_01_preview.models.CheckNameAvailabilityResult\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41794:c0:m1"}
{"signature": "def list_service_sas(<EOL>self, resource_group_name, account_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_service_sas.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List service SAS credentials of a specific resource.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription. The name is case insensitive.\n        :type resource_group_name: str\n        :param account_name: The name of the storage account within the\n         specified resource group. Storage account names must be between 3 and\n         24 characters in length and use numbers and lower-case letters only.\n        :type account_name: str\n        :param parameters: The parameters to provide to list service SAS\n         credentials.\n        :type parameters:\n         ~azure.mgmt.storage.v2018_03_01_preview.models.ServiceSasParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ListServiceSasResponse or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.storage.v2018_03_01_preview.models.ListServiceSasResponse\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41794:c0:m12"}
{"signature": "def create_or_update_management_policies(<EOL>self, resource_group_name, account_name, policy=None, custom_headers=None, raw=False, **operation_config):", "body": "properties = models.ManagementPoliciesRulesSetParameter(policy=policy)<EOL>url = self.create_or_update_management_policies.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.management_policy_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(properties, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Sets the data policy rules associated with the specified storage\n        account.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription. The name is case insensitive.\n        :type resource_group_name: str\n        :param account_name: The name of the storage account within the\n         specified resource group. Storage account names must be between 3 and\n         24 characters in length and use numbers and lower-case letters only.\n        :type account_name: str\n        :param policy: The Storage Account ManagementPolicies Rules, in JSON\n         format. See more details in:\n         https://docs.microsoft.com/en-us/azure/storage/common/storage-lifecycle-managment-concepts.\n        :type policy: object\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: StorageAccountManagementPolicies or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.storage.v2018_03_01_preview.models.StorageAccountManagementPolicies\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41794:c0:m14"}
{"signature": "def regenerate_key(<EOL>self, resource_group_name, account_name, key_name, custom_headers=None, raw=False, **operation_config):", "body": "regenerate_key1 = models.StorageAccountRegenerateKeyParameters(key_name=key_name)<EOL>url = self.regenerate_key.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(regenerate_key1, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Regenerates one of the access keys for the specified storage account.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription. The name is case insensitive.\n        :type resource_group_name: str\n        :param account_name: The name of the storage account within the\n         specified resource group. Storage account names must be between 3 and\n         24 characters in length and use numbers and lower-case letters only.\n        :type account_name: str\n        :param key_name: The name of storage keys that want to be regenerated,\n         possible values are key1, key2.\n        :type key_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: StorageAccountListKeysResult or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.storage.v2018_03_01_preview.models.StorageAccountListKeysResult\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41794:c0:m10"}
{"signature": "def delete_management_policies(<EOL>self, resource_group_name, account_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete_management_policies.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.management_policy_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes the data policy rules associated with the specified storage\n        account.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription. The name is case insensitive.\n        :type resource_group_name: str\n        :param account_name: The name of the storage account within the\n         specified resource group. Storage account names must be between 3 and\n         24 characters in length and use numbers and lower-case letters only.\n        :type account_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41794:c0:m15"}
{"signature": "def list_keys(<EOL>self, resource_group_name, account_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_keys.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists the access keys for the specified storage account.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription. The name is case insensitive.\n        :type resource_group_name: str\n        :param account_name: The name of the storage account within the\n         specified resource group. Storage account names must be between 3 and\n         24 characters in length and use numbers and lower-case letters only.\n        :type account_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: StorageAccountListKeysResult or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.storage.v2018_03_01_preview.models.StorageAccountListKeysResult\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41794:c0:m9"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.UsagePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.UsagePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the current usage count and the limit for the resources under the\n        subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Usage\n        :rtype:\n         ~azure.mgmt.storage.v2017_10_01.models.UsagePaged[~azure.mgmt.storage.v2017_10_01.models.Usage]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41842:c0:m1"}
{"signature": "def regenerate_key(<EOL>self, resource_group_name, account_name, key_name, custom_headers=None, raw=False, **operation_config):", "body": "regenerate_key1 = models.StorageAccountRegenerateKeyParameters(key_name=key_name)<EOL>url = self.regenerate_key.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(regenerate_key1, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Regenerates one of the access keys for the specified storage account.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription. The name is case insensitive.\n        :type resource_group_name: str\n        :param account_name: The name of the storage account within the\n         specified resource group. Storage account names must be between 3 and\n         24 characters in length and use numbers and lower-case letters only.\n        :type account_name: str\n        :param key_name: The name of storage keys that want to be regenerated,\n         possible values are key1, key2.\n        :type key_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: StorageAccountListKeysResult or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.storage.v2017_10_01.models.StorageAccountListKeysResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41843:c0:m10"}
{"signature": "def get_immutability_policy(<EOL>self, resource_group_name, account_name, container_name, if_match=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_immutability_policy.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", container_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.immutability_policy_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if if_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_match, '<STR_LIT:str>')<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>header_dict = {}<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>header_dict = {<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>}<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>client_raw_response.add_headers(header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the existing immutability policy along with the corresponding ETag\n        in response headers and body.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription. The name is case insensitive.\n        :type resource_group_name: str\n        :param account_name: The name of the storage account within the\n         specified resource group. Storage account names must be between 3 and\n         24 characters in length and use numbers and lower-case letters only.\n        :type account_name: str\n        :param container_name: The name of the blob container within the\n         specified storage account. Blob container names must be between 3 and\n         63 characters in length and use numbers, lower-case letters and dash\n         (-) only. Every dash (-) character must be immediately preceded and\n         followed by a letter or number.\n        :type container_name: str\n        :param if_match: The entity state (ETag) version of the immutability\n         policy to update. A value of \"*\" can be used to apply the operation\n         only if the immutability policy already exists. If omitted, this\n         operation will always be applied.\n        :type if_match: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ImmutabilityPolicy or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.storage.v2018_07_01.models.ImmutabilityPolicy or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41915:c0:m9"}
{"signature": "def set_legal_hold(<EOL>self, resource_group_name, account_name, container_name, tags, custom_headers=None, raw=False, **operation_config):", "body": "legal_hold = models.LegalHold(tags=tags)<EOL>url = self.set_legal_hold.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", container_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(legal_hold, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Sets legal hold tags. Setting the same tag results in an idempotent\n        operation. SetLegalHold follows an append pattern and does not clear\n        out the existing tags that are not specified in the request.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription. The name is case insensitive.\n        :type resource_group_name: str\n        :param account_name: The name of the storage account within the\n         specified resource group. Storage account names must be between 3 and\n         24 characters in length and use numbers and lower-case letters only.\n        :type account_name: str\n        :param container_name: The name of the blob container within the\n         specified storage account. Blob container names must be between 3 and\n         63 characters in length and use numbers, lower-case letters and dash\n         (-) only. Every dash (-) character must be immediately preceded and\n         followed by a letter or number.\n        :type container_name: str\n        :param tags: Each tag should be 3 to 23 alphanumeric characters and is\n         normalized to lower case at SRP.\n        :type tags: list[str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: LegalHold or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.storage.v2018_07_01.models.LegalHold or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41915:c0:m6"}
{"signature": "def list(<EOL>self, resource_group_name, account_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all containers and does not support a prefix like data plane.\n        Also SRP today does not return continuation token.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription. The name is case insensitive.\n        :type resource_group_name: str\n        :param account_name: The name of the storage account within the\n         specified resource group. Storage account names must be between 3 and\n         24 characters in length and use numbers and lower-case letters only.\n        :type account_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ListContainerItems or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.storage.v2018_07_01.models.ListContainerItems or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41915:c0:m1"}
{"signature": "def create_or_update_immutability_policy(<EOL>self, resource_group_name, account_name, container_name, immutability_period_since_creation_in_days, if_match=None, custom_headers=None, raw=False, **operation_config):", "body": "parameters = None<EOL>if immutability_period_since_creation_in_days is not None:<EOL><INDENT>parameters = models.ImmutabilityPolicy(immutability_period_since_creation_in_days=immutability_period_since_creation_in_days)<EOL><DEDENT>url = self.create_or_update_immutability_policy.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", container_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.immutability_policy_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if if_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_match, '<STR_LIT:str>')<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if parameters is not None:<EOL><INDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>body_content = None<EOL><DEDENT>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>header_dict = {}<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>header_dict = {<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>}<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>client_raw_response.add_headers(header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or updates an unlocked immutability policy. ETag in If-Match is\n        honored if given but not required for this operation.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription. The name is case insensitive.\n        :type resource_group_name: str\n        :param account_name: The name of the storage account within the\n         specified resource group. Storage account names must be between 3 and\n         24 characters in length and use numbers and lower-case letters only.\n        :type account_name: str\n        :param container_name: The name of the blob container within the\n         specified storage account. Blob container names must be between 3 and\n         63 characters in length and use numbers, lower-case letters and dash\n         (-) only. Every dash (-) character must be immediately preceded and\n         followed by a letter or number.\n        :type container_name: str\n        :param immutability_period_since_creation_in_days: The immutability\n         period for the blobs in the container since the policy creation, in\n         days.\n        :type immutability_period_since_creation_in_days: int\n        :param if_match: The entity state (ETag) version of the immutability\n         policy to update. A value of \"*\" can be used to apply the operation\n         only if the immutability policy already exists. If omitted, this\n         operation will always be applied.\n        :type if_match: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ImmutabilityPolicy or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.storage.v2018_07_01.models.ImmutabilityPolicy or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41915:c0:m8"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SkuPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SkuPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists the available SKUs supported by Microsoft.Storage for given\n        subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Sku\n        :rtype:\n         ~azure.mgmt.storage.v2018_07_01.models.SkuPaged[~azure.mgmt.storage.v2018_07_01.models.Sku]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41917:c0:m1"}
{"signature": "def get(<EOL>self, resource_group_name, account_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.management_policy_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the data policy rules associated with the specified storage\n        account.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription. The name is case insensitive.\n        :type resource_group_name: str\n        :param account_name: The name of the storage account within the\n         specified resource group. Storage account names must be between 3 and\n         24 characters in length and use numbers and lower-case letters only.\n        :type account_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: StorageAccountManagementPolicies or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.storage.v2018_07_01.models.StorageAccountManagementPolicies\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41918:c0:m1"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.StorageAccountPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.StorageAccountPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all the storage accounts available under the given resource\n        group. Note that storage keys are not returned; use the ListKeys\n        operation for this.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription. The name is case insensitive.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of StorageAccount\n        :rtype:\n         ~azure.mgmt.storage.v2018_07_01.models.StorageAccountPaged[~azure.mgmt.storage.v2018_07_01.models.StorageAccount]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41921:c0:m8"}
{"signature": "def create(<EOL>self, resource_group_name, account_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_initial(<EOL>resource_group_name=resource_group_name,<EOL>account_name=account_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Asynchronously creates a new storage account with the specified\n        parameters. If an account is already created and a subsequent create\n        request is issued with different properties, the account properties\n        will be updated. If an account is already created and a subsequent\n        create or update request is issued with the exact same set of\n        properties, the request will succeed.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription. The name is case insensitive.\n        :type resource_group_name: str\n        :param account_name: The name of the storage account within the\n         specified resource group. Storage account names must be between 3 and\n         24 characters in length and use numbers and lower-case letters only.\n        :type account_name: str\n        :param parameters: The parameters to provide for the created account.\n        :type parameters:\n         ~azure.mgmt.storage.v2018_07_01.models.StorageAccountCreateParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns StorageAccount or\n         ClientRawResponse<StorageAccount> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.storage.v2018_07_01.models.StorageAccount]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.storage.v2018_07_01.models.StorageAccount]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41921:c0:m3"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.StorageAccountPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.StorageAccountPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all the storage accounts available under the subscription. Note\n        that storage keys are not returned; use the ListKeys operation for\n        this.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of StorageAccount\n        :rtype:\n         ~azure.mgmt.storage.v2018_07_01.models.StorageAccountPaged[~azure.mgmt.storage.v2018_07_01.models.StorageAccount]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41921:c0:m7"}
{"signature": "def update(<EOL>self, resource_group_name, account_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "The update operation can be used to update the SKU, encryption, access\n        tier, or tags for a storage account. It can also be used to map the\n        account to a custom domain. Only one custom domain is supported per\n        storage account; the replacement/change of custom domain is not\n        supported. In order to replace an old custom domain, the old value must\n        be cleared/unregistered before a new value can be set. The update of\n        multiple properties is supported. This call does not change the storage\n        keys for the account. If you want to change the storage account keys,\n        use the regenerate keys operation. The location and name of the storage\n        account cannot be changed after creation.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription. The name is case insensitive.\n        :type resource_group_name: str\n        :param account_name: The name of the storage account within the\n         specified resource group. Storage account names must be between 3 and\n         24 characters in length and use numbers and lower-case letters only.\n        :type account_name: str\n        :param parameters: The parameters to provide for the updated account.\n        :type parameters:\n         ~azure.mgmt.storage.v2018_07_01.models.StorageAccountUpdateParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: StorageAccount or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.storage.v2018_07_01.models.StorageAccount or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41921:c0:m6"}
{"signature": "def delete(<EOL>self, resource_group_name, account_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes a storage account in Microsoft Azure.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription. The name is case insensitive.\n        :type resource_group_name: str\n        :param account_name: The name of the storage account within the\n         specified resource group. Storage account names must be between 3 and\n         24 characters in length and use numbers and lower-case letters only.\n        :type account_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41921:c0:m4"}
{"signature": "def list_account_sas(<EOL>self, resource_group_name, account_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_account_sas.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List SAS credentials of a storage account.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription. The name is case insensitive.\n        :type resource_group_name: str\n        :param account_name: The name of the storage account within the\n         specified resource group. Storage account names must be between 3 and\n         24 characters in length and use numbers and lower-case letters only.\n        :type account_name: str\n        :param parameters: The parameters to provide to list SAS credentials\n         for the storage account.\n        :type parameters:\n         ~azure.mgmt.storage.v2018_07_01.models.AccountSasParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ListAccountSasResponse or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.storage.v2018_07_01.models.ListAccountSasResponse\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41921:c0:m11"}
{"signature": "def get_properties(<EOL>self, resource_group_name, account_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_properties.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Returns the properties for the specified storage account including but\n        not limited to name, SKU name, location, and account status. The\n        ListKeys operation should be used to retrieve storage keys.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription. The name is case insensitive.\n        :type resource_group_name: str\n        :param account_name: The name of the storage account within the\n         specified resource group. Storage account names must be between 3 and\n         24 characters in length and use numbers and lower-case letters only.\n        :type account_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: StorageAccount or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.storage.v2015_06_15.models.StorageAccount or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41951:c0:m5"}
{"signature": "def list_keys(<EOL>self, resource_group_name, account_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_keys.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists the access keys for the specified storage account.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription. The name is case insensitive.\n        :type resource_group_name: str\n        :param account_name: The name of the storage account within the\n         specified resource group. Storage account names must be between 3 and\n         24 characters in length and use numbers and lower-case letters only.\n        :type account_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: StorageAccountKeys or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.storage.v2015_06_15.models.StorageAccountKeys or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41951:c0:m9"}
{"signature": "def update(<EOL>self, resource_group_name, account_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "The update operation can be used to update the SKU, encryption, access\n        tier, or tags for a storage account. It can also be used to map the\n        account to a custom domain. Only one custom domain is supported per\n        storage account; the replacement/change of custom domain is not\n        supported. In order to replace an old custom domain, the old value must\n        be cleared/unregistered before a new value can be set. The update of\n        multiple properties is supported. This call does not change the storage\n        keys for the account. If you want to change the storage account keys,\n        use the regenerate keys operation. The location and name of the storage\n        account cannot be changed after creation.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription. The name is case insensitive.\n        :type resource_group_name: str\n        :param account_name: The name of the storage account within the\n         specified resource group. Storage account names must be between 3 and\n         24 characters in length and use numbers and lower-case letters only.\n        :type account_name: str\n        :param parameters: The parameters to provide for the updated account.\n        :type parameters:\n         ~azure.mgmt.storage.v2015_06_15.models.StorageAccountUpdateParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: StorageAccount or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.storage.v2015_06_15.models.StorageAccount or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f41951:c0:m6"}
{"signature": "@property<EOL><INDENT>def operations(self):<DEDENT>", "body": "api_version = self._get_api_version('<STR_LIT>')<EOL>if api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_06_01.operations import Operations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_10_01.operations import Operations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_02_01.operations import Operations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_03_01_preview.operations import Operations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_07_01.operations import Operations as OperationClass<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\".format(api_version))<EOL><DEDENT>return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))<EOL>", "docstring": "Instance depends on the API version:\n\n           * 2017-06-01: :class:`Operations<azure.mgmt.storage.v2017_06_01.operations.Operations>`\n           * 2017-10-01: :class:`Operations<azure.mgmt.storage.v2017_10_01.operations.Operations>`\n           * 2018-02-01: :class:`Operations<azure.mgmt.storage.v2018_02_01.operations.Operations>`\n           * 2018-03-01-preview: :class:`Operations<azure.mgmt.storage.v2018_03_01_preview.operations.Operations>`\n           * 2018-07-01: :class:`Operations<azure.mgmt.storage.v2018_07_01.operations.Operations>`", "id": "f41954:c1:m6"}
{"signature": "@property<EOL><INDENT>def storage_accounts(self):<DEDENT>", "body": "api_version = self._get_api_version('<STR_LIT>')<EOL>if api_version == '<STR_LIT>':<EOL><INDENT>from .v2015_06_15.operations import StorageAccountsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2016_01_01.operations import StorageAccountsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2016_12_01.operations import StorageAccountsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_06_01.operations import StorageAccountsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2017_10_01.operations import StorageAccountsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_02_01.operations import StorageAccountsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_03_01_preview.operations import StorageAccountsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_07_01.operations import StorageAccountsOperations as OperationClass<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\".format(api_version))<EOL><DEDENT>return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))<EOL>", "docstring": "Instance depends on the API version:\n\n           * 2015-06-15: :class:`StorageAccountsOperations<azure.mgmt.storage.v2015_06_15.operations.StorageAccountsOperations>`\n           * 2016-01-01: :class:`StorageAccountsOperations<azure.mgmt.storage.v2016_01_01.operations.StorageAccountsOperations>`\n           * 2016-12-01: :class:`StorageAccountsOperations<azure.mgmt.storage.v2016_12_01.operations.StorageAccountsOperations>`\n           * 2017-06-01: :class:`StorageAccountsOperations<azure.mgmt.storage.v2017_06_01.operations.StorageAccountsOperations>`\n           * 2017-10-01: :class:`StorageAccountsOperations<azure.mgmt.storage.v2017_10_01.operations.StorageAccountsOperations>`\n           * 2018-02-01: :class:`StorageAccountsOperations<azure.mgmt.storage.v2018_02_01.operations.StorageAccountsOperations>`\n           * 2018-03-01-preview: :class:`StorageAccountsOperations<azure.mgmt.storage.v2018_03_01_preview.operations.StorageAccountsOperations>`\n           * 2018-07-01: :class:`StorageAccountsOperations<azure.mgmt.storage.v2018_07_01.operations.StorageAccountsOperations>`", "id": "f41954:c1:m8"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.StorageAccountPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.StorageAccountPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all the storage accounts available under the subscription. Note\n        that storage keys are not returned; use the ListKeys operation for\n        this.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of StorageAccount\n        :rtype:\n         ~azure.mgmt.storage.v2018_02_01.models.StorageAccountPaged[~azure.mgmt.storage.v2018_02_01.models.StorageAccount]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f42017:c0:m7"}
{"signature": "def list_service_sas(<EOL>self, resource_group_name, account_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_service_sas.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:3>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List service SAS credentials of a specific resource.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription. The name is case insensitive.\n        :type resource_group_name: str\n        :param account_name: The name of the storage account within the\n         specified resource group. Storage account names must be between 3 and\n         24 characters in length and use numbers and lower-case letters only.\n        :type account_name: str\n        :param parameters: The parameters to provide to list service SAS\n         credentials.\n        :type parameters:\n         ~azure.mgmt.storage.v2018_02_01.models.ServiceSasParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ListServiceSasResponse or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.storage.v2018_02_01.models.ListServiceSasResponse\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f42017:c0:m12"}
{"signature": "def check_name_availability(<EOL>self, name, custom_headers=None, raw=False, **operation_config):", "body": "account_name = models.StorageAccountCheckNameAvailabilityParameters(name=name)<EOL>url = self.check_name_availability.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(account_name, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Checks that the storage account name is valid and is not already in\n        use.\n\n        :param name: The storage account name.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: CheckNameAvailabilityResult or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.storage.v2018_02_01.models.CheckNameAvailabilityResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f42017:c0:m1"}
{"signature": "def resize(<EOL>self, resource_group_name, cluster_name, target_instance_count=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._resize_initial(<EOL>resource_group_name=resource_group_name,<EOL>cluster_name=cluster_name,<EOL>target_instance_count=target_instance_count,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Resizes the specified HDInsight cluster to the specified size.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param cluster_name: The name of the cluster.\n        :type cluster_name: str\n        :param target_instance_count: The target instance count for the\n         operation.\n        :type target_instance_count: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.hdinsight.models.ErrorResponseException>`", "id": "f42136:c0:m9"}
{"signature": "def execute_script_actions(<EOL>self, resource_group_name, cluster_name, persist_on_success, script_actions=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._execute_script_actions_initial(<EOL>resource_group_name=resource_group_name,<EOL>cluster_name=cluster_name,<EOL>persist_on_success=persist_on_success,<EOL>script_actions=script_actions,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Executes script actions on the specified HDInsight cluster.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param cluster_name: The name of the cluster.\n        :type cluster_name: str\n        :param persist_on_success: Gets or sets if the scripts needs to be\n         persisted.\n        :type persist_on_success: bool\n        :param script_actions: The list of run time script actions.\n        :type script_actions:\n         list[~azure.mgmt.hdinsight.models.RuntimeScriptAction]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.hdinsight.models.ErrorResponseException>`", "id": "f42136:c0:m17"}
{"signature": "def get(<EOL>self, resource_group_name, cluster_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", cluster_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified cluster.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param cluster_name: The name of the cluster.\n        :type cluster_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Cluster or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.hdinsight.models.Cluster or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.hdinsight.models.ErrorResponseException>`", "id": "f42136:c0:m6"}
{"signature": "def delete(<EOL>self, resource_group_name, cluster_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>cluster_name=cluster_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes the specified HDInsight cluster.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param cluster_name: The name of the cluster.\n        :type cluster_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.hdinsight.models.ErrorResponseException>`", "id": "f42136:c0:m5"}
{"signature": "def update_gateway_settings(<EOL>self, resource_group_name, cluster_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_gateway_settings_initial(<EOL>resource_group_name=resource_group_name,<EOL>cluster_name=cluster_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Configures the gateway settings on the specified cluster.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param cluster_name: The name of the cluster.\n        :type cluster_name: str\n        :param parameters: The cluster configurations.\n        :type parameters:\n         ~azure.mgmt.hdinsight.models.UpdateGatewaySettingsParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.hdinsight.models.ErrorResponseException>`", "id": "f42136:c0:m15"}
{"signature": "def rotate_disk_encryption_key(<EOL>self, resource_group_name, cluster_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._rotate_disk_encryption_key_initial(<EOL>resource_group_name=resource_group_name,<EOL>cluster_name=cluster_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Rotate disk encryption key of the specified HDInsight cluster.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param cluster_name: The name of the cluster.\n        :type cluster_name: str\n        :param parameters: The parameters for the disk encryption operation.\n        :type parameters:\n         ~azure.mgmt.hdinsight.models.ClusterDiskEncryptionParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.hdinsight.models.ErrorResponseException>`", "id": "f42136:c0:m12"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.OperationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.OperationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all of the available HDInsight REST API operations.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Operation\n        :rtype:\n         ~azure.mgmt.hdinsight.models.OperationPaged[~azure.mgmt.hdinsight.models.Operation]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.hdinsight.models.ErrorResponseException>`", "id": "f42137:c0:m1"}
{"signature": "def promote(<EOL>self, resource_group_name, cluster_name, script_execution_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.promote.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", cluster_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", script_execution_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Promotes the specified ad-hoc script execution to a persisted script.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param cluster_name: The name of the cluster.\n        :type cluster_name: str\n        :param script_execution_id: The script execution Id\n        :type script_execution_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.hdinsight.models.ErrorResponseException>`", "id": "f42138:c0:m2"}
{"signature": "def create(<EOL>self, resource_group_name, cluster_name, application_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_initial(<EOL>resource_group_name=resource_group_name,<EOL>cluster_name=cluster_name,<EOL>application_name=application_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates applications for the HDInsight cluster.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param cluster_name: The name of the cluster.\n        :type cluster_name: str\n        :param application_name: The constant value for the application name.\n        :type application_name: str\n        :param parameters: The application create request.\n        :type parameters: ~azure.mgmt.hdinsight.models.Application\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Application or\n         ClientRawResponse<Application> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.hdinsight.models.Application]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.hdinsight.models.Application]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.hdinsight.models.ErrorResponseException>`", "id": "f42139:c0:m4"}
{"signature": "def list_by_cluster(<EOL>self, resource_group_name, cluster_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_cluster.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", cluster_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ApplicationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ApplicationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all of the applications for the HDInsight cluster.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param cluster_name: The name of the cluster.\n        :type cluster_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Application\n        :rtype:\n         ~azure.mgmt.hdinsight.models.ApplicationPaged[~azure.mgmt.hdinsight.models.Application]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.hdinsight.models.ErrorResponseException>`", "id": "f42139:c0:m1"}
{"signature": "def get_execution_detail(<EOL>self, resource_group_name, cluster_name, script_execution_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_execution_detail.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", cluster_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", script_execution_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the script execution detail for the given script execution ID.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param cluster_name: The name of the cluster.\n        :type cluster_name: str\n        :param script_execution_id: The script execution Id\n        :type script_execution_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RuntimeScriptActionDetail or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.hdinsight.models.RuntimeScriptActionDetail or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.hdinsight.models.ErrorResponseException>`", "id": "f42143:c0:m3"}
{"signature": "def list(<EOL>self, resource_group_name, cluster_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", cluster_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all configuration information for an HDI cluster.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param cluster_name: The name of the cluster.\n        :type cluster_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ClusterConfigurations or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.hdinsight.models.ClusterConfigurations or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.hdinsight.models.ErrorResponseException>`", "id": "f42144:c0:m1"}
{"signature": "def get(<EOL>self, resource_group_name, cluster_name, configuration_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", cluster_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", configuration_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "The configuration object for the specified cluster. This API is not\n        recommended and might be removed in the future. Please consider using\n        List configurations API instead.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param cluster_name: The name of the cluster.\n        :type cluster_name: str\n        :param configuration_name: The name of the cluster configuration.\n        :type configuration_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: dict or ClientRawResponse if raw=true\n        :rtype: dict[str, str] or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.hdinsight.models.ErrorResponseException>`", "id": "f42144:c0:m4"}
{"signature": "def update(<EOL>self, resource_group_name, storage_sync_service_name, sync_group_name, server_endpoint_name, parameters=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._update_initial(<EOL>resource_group_name=resource_group_name,<EOL>storage_sync_service_name=storage_sync_service_name,<EOL>sync_group_name=sync_group_name,<EOL>server_endpoint_name=server_endpoint_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>header_dict = {<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>}<EOL>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>client_raw_response.add_headers(header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Patch a given ServerEndpoint.\n\n        :param resource_group_name: The name of the resource group. The name\n         is case insensitive.\n        :type resource_group_name: str\n        :param storage_sync_service_name: Name of Storage Sync Service\n         resource.\n        :type storage_sync_service_name: str\n        :param sync_group_name: Name of Sync Group resource.\n        :type sync_group_name: str\n        :param server_endpoint_name: Name of Server Endpoint object.\n        :type server_endpoint_name: str\n        :param parameters: Any of the properties applicable in PUT request.\n        :type parameters:\n         ~azure.mgmt.storagesync.models.ServerEndpointUpdateParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ServerEndpoint or\n         ClientRawResponse<ServerEndpoint> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.storagesync.models.ServerEndpoint]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.storagesync.models.ServerEndpoint]]\n        :raises:\n         :class:`StorageSyncErrorException<azure.mgmt.storagesync.models.StorageSyncErrorException>`", "id": "f42265:c0:m4"}
{"signature": "def delete(<EOL>self, resource_group_name, storage_sync_service_name, sync_group_name, server_endpoint_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>storage_sync_service_name=storage_sync_service_name,<EOL>sync_group_name=sync_group_name,<EOL>server_endpoint_name=server_endpoint_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>client_raw_response.add_headers({<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>})<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Delete a given ServerEndpoint.\n\n        :param resource_group_name: The name of the resource group. The name\n         is case insensitive.\n        :type resource_group_name: str\n        :param storage_sync_service_name: Name of Storage Sync Service\n         resource.\n        :type storage_sync_service_name: str\n        :param sync_group_name: Name of Sync Group resource.\n        :type sync_group_name: str\n        :param server_endpoint_name: Name of Server Endpoint object.\n        :type server_endpoint_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises:\n         :class:`StorageSyncErrorException<azure.mgmt.storagesync.models.StorageSyncErrorException>`", "id": "f42265:c0:m7"}
{"signature": "def list_by_storage_sync_service(<EOL>self, resource_group_name, storage_sync_service_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_storage_sync_service.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", storage_sync_service_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.StorageSyncErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.WorkflowPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.WorkflowPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get a Workflow List.\n\n        :param resource_group_name: The name of the resource group. The name\n         is case insensitive.\n        :type resource_group_name: str\n        :param storage_sync_service_name: Name of Storage Sync Service\n         resource.\n        :type storage_sync_service_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Workflow\n        :rtype:\n         ~azure.mgmt.storagesync.models.WorkflowPaged[~azure.mgmt.storagesync.models.Workflow]\n        :raises:\n         :class:`StorageSyncErrorException<azure.mgmt.storagesync.models.StorageSyncErrorException>`", "id": "f42266:c0:m1"}
{"signature": "def get(<EOL>self, resource_group_name, storage_sync_service_name, server_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", storage_sync_service_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", server_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.StorageSyncErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>header_dict = {}<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>header_dict = {<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>}<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>client_raw_response.add_headers(header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get a given registered server.\n\n        :param resource_group_name: The name of the resource group. The name\n         is case insensitive.\n        :type resource_group_name: str\n        :param storage_sync_service_name: Name of Storage Sync Service\n         resource.\n        :type storage_sync_service_name: str\n        :param server_id: GUID identifying the on-premises server.\n        :type server_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RegisteredServer or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.storagesync.models.RegisteredServer or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`StorageSyncErrorException<azure.mgmt.storagesync.models.StorageSyncErrorException>`", "id": "f42267:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, storage_sync_service_name, sync_group_name, cloud_endpoint_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", storage_sync_service_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", sync_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", cloud_endpoint_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.StorageSyncErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>header_dict = {}<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>header_dict = {<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>}<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>client_raw_response.add_headers(header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get a given CloudEndpoint.\n\n        :param resource_group_name: The name of the resource group. The name\n         is case insensitive.\n        :type resource_group_name: str\n        :param storage_sync_service_name: Name of Storage Sync Service\n         resource.\n        :type storage_sync_service_name: str\n        :param sync_group_name: Name of Sync Group resource.\n        :type sync_group_name: str\n        :param cloud_endpoint_name: Name of Cloud Endpoint object.\n        :type cloud_endpoint_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: CloudEndpoint or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.storagesync.models.CloudEndpoint or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`StorageSyncErrorException<azure.mgmt.storagesync.models.StorageSyncErrorException>`", "id": "f42270:c0:m3"}
{"signature": "def restoreheartbeat(<EOL>self, resource_group_name, storage_sync_service_name, sync_group_name, cloud_endpoint_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.restoreheartbeat.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", storage_sync_service_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", sync_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", cloud_endpoint_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.StorageSyncErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>client_raw_response.add_headers({<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>})<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Restore Heartbeat a given CloudEndpoint.\n\n        :param resource_group_name: The name of the resource group. The name\n         is case insensitive.\n        :type resource_group_name: str\n        :param storage_sync_service_name: Name of Storage Sync Service\n         resource.\n        :type storage_sync_service_name: str\n        :param sync_group_name: Name of Sync Group resource.\n        :type sync_group_name: str\n        :param cloud_endpoint_name: Name of Cloud Endpoint object.\n        :type cloud_endpoint_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`StorageSyncErrorException<azure.mgmt.storagesync.models.StorageSyncErrorException>`", "id": "f42270:c0:m13"}
{"signature": "def pre_restore(<EOL>self, resource_group_name, storage_sync_service_name, sync_group_name, cloud_endpoint_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._pre_restore_initial(<EOL>resource_group_name=resource_group_name,<EOL>storage_sync_service_name=storage_sync_service_name,<EOL>sync_group_name=sync_group_name,<EOL>cloud_endpoint_name=cloud_endpoint_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>client_raw_response.add_headers({<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>})<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Pre Restore a given CloudEndpoint.\n\n        :param resource_group_name: The name of the resource group. The name\n         is case insensitive.\n        :type resource_group_name: str\n        :param storage_sync_service_name: Name of Storage Sync Service\n         resource.\n        :type storage_sync_service_name: str\n        :param sync_group_name: Name of Sync Group resource.\n        :type sync_group_name: str\n        :param cloud_endpoint_name: Name of Cloud Endpoint object.\n        :type cloud_endpoint_name: str\n        :param parameters: Body of Cloud Endpoint object.\n        :type parameters: ~azure.mgmt.storagesync.models.PreRestoreRequest\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises:\n         :class:`StorageSyncErrorException<azure.mgmt.storagesync.models.StorageSyncErrorException>`", "id": "f42270:c0:m12"}
{"signature": "def list_by_sync_group(<EOL>self, resource_group_name, storage_sync_service_name, sync_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_sync_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", storage_sync_service_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", sync_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>', min_length=<NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.StorageSyncErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.CloudEndpointPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.CloudEndpointPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get a CloudEndpoint List.\n\n        :param resource_group_name: The name of the resource group. The name\n         is case insensitive.\n        :type resource_group_name: str\n        :param storage_sync_service_name: Name of Storage Sync Service\n         resource.\n        :type storage_sync_service_name: str\n        :param sync_group_name: Name of Sync Group resource.\n        :type sync_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of CloudEndpoint\n        :rtype:\n         ~azure.mgmt.storagesync.models.CloudEndpointPaged[~azure.mgmt.storagesync.models.CloudEndpoint]\n        :raises:\n         :class:`StorageSyncErrorException<azure.mgmt.storagesync.models.StorageSyncErrorException>`", "id": "f42270:c0:m6"}
{"signature": "def post_restore(<EOL>self, resource_group_name, storage_sync_service_name, sync_group_name, cloud_endpoint_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._post_restore_initial(<EOL>resource_group_name=resource_group_name,<EOL>storage_sync_service_name=storage_sync_service_name,<EOL>sync_group_name=sync_group_name,<EOL>cloud_endpoint_name=cloud_endpoint_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>client_raw_response.add_headers({<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>})<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Post Restore a given CloudEndpoint.\n\n        :param resource_group_name: The name of the resource group. The name\n         is case insensitive.\n        :type resource_group_name: str\n        :param storage_sync_service_name: Name of Storage Sync Service\n         resource.\n        :type storage_sync_service_name: str\n        :param sync_group_name: Name of Sync Group resource.\n        :type sync_group_name: str\n        :param cloud_endpoint_name: Name of Cloud Endpoint object.\n        :type cloud_endpoint_name: str\n        :param parameters: Body of Cloud Endpoint object.\n        :type parameters: ~azure.mgmt.storagesync.models.PostRestoreRequest\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises:\n         :class:`StorageSyncErrorException<azure.mgmt.storagesync.models.StorageSyncErrorException>`", "id": "f42270:c0:m15"}
{"signature": "def post_backup(<EOL>self, resource_group_name, storage_sync_service_name, sync_group_name, cloud_endpoint_name, azure_file_share=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._post_backup_initial(<EOL>resource_group_name=resource_group_name,<EOL>storage_sync_service_name=storage_sync_service_name,<EOL>sync_group_name=sync_group_name,<EOL>cloud_endpoint_name=cloud_endpoint_name,<EOL>azure_file_share=azure_file_share,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>header_dict = {<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>}<EOL>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>client_raw_response.add_headers(header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Post Backup a given CloudEndpoint.\n\n        :param resource_group_name: The name of the resource group. The name\n         is case insensitive.\n        :type resource_group_name: str\n        :param storage_sync_service_name: Name of Storage Sync Service\n         resource.\n        :type storage_sync_service_name: str\n        :param sync_group_name: Name of Sync Group resource.\n        :type sync_group_name: str\n        :param cloud_endpoint_name: Name of Cloud Endpoint object.\n        :type cloud_endpoint_name: str\n        :param azure_file_share: Azure File Share.\n        :type azure_file_share: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns PostBackupResponse or\n         ClientRawResponse<PostBackupResponse> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.storagesync.models.PostBackupResponse]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.storagesync.models.PostBackupResponse]]\n        :raises:\n         :class:`StorageSyncErrorException<azure.mgmt.storagesync.models.StorageSyncErrorException>`", "id": "f42270:c0:m10"}
{"signature": "def create(<EOL>self, resource_group_name, storage_sync_service_name, sync_group_name, cloud_endpoint_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_initial(<EOL>resource_group_name=resource_group_name,<EOL>storage_sync_service_name=storage_sync_service_name,<EOL>sync_group_name=sync_group_name,<EOL>cloud_endpoint_name=cloud_endpoint_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>header_dict = {<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>}<EOL>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>client_raw_response.add_headers(header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Create a new CloudEndpoint.\n\n        :param resource_group_name: The name of the resource group. The name\n         is case insensitive.\n        :type resource_group_name: str\n        :param storage_sync_service_name: Name of Storage Sync Service\n         resource.\n        :type storage_sync_service_name: str\n        :param sync_group_name: Name of Sync Group resource.\n        :type sync_group_name: str\n        :param cloud_endpoint_name: Name of Cloud Endpoint object.\n        :type cloud_endpoint_name: str\n        :param parameters: Body of Cloud Endpoint resource.\n        :type parameters:\n         ~azure.mgmt.storagesync.models.CloudEndpointCreateParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns CloudEndpoint or\n         ClientRawResponse<CloudEndpoint> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.storagesync.models.CloudEndpoint]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.storagesync.models.CloudEndpoint]]\n        :raises:\n         :class:`StorageSyncErrorException<azure.mgmt.storagesync.models.StorageSyncErrorException>`", "id": "f42270:c0:m2"}
{"signature": "def auto_suggest(<EOL>self, query, accept_language=None, pragma=None, user_agent=None, client_id=None, client_ip=None, location=None, country_code=None, market=\"<STR_LIT>\", safe_search=None, set_lang=None, response_format=None, custom_headers=None, raw=False, **operation_config):", "body": "x_bing_apis_sdk = \"<STR_LIT:true>\"<EOL>url = self.auto_suggest.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>if country_code is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", country_code, '<STR_LIT:str>')<EOL><DEDENT>if market is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", market, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT:q>'] = self._serialize.query(\"<STR_LIT>\", query, '<STR_LIT:str>')<EOL>if safe_search is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", safe_search, '<STR_LIT:str>')<EOL><DEDENT>if set_lang is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", set_lang, '<STR_LIT:str>')<EOL><DEDENT>if response_format is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", response_format, '<STR_LIT>', div='<STR_LIT:U+002C>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", x_bing_apis_sdk, '<STR_LIT:str>')<EOL>if accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", accept_language, '<STR_LIT:str>')<EOL><DEDENT>if pragma is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", pragma, '<STR_LIT:str>')<EOL><DEDENT>if user_agent is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", user_agent, '<STR_LIT:str>')<EOL><DEDENT>if client_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", client_id, '<STR_LIT:str>')<EOL><DEDENT>if client_ip is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", client_ip, '<STR_LIT:str>')<EOL><DEDENT>if location is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT:location>\", location, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "The AutoSuggest API lets you send a search query to Bing and get back a\n        list of suggestions. This section provides technical details about the\n        query parameters and headers that you use to request suggestions and\n        the JSON response objects that contain them.\n\n        :param query: The user's search term.\n        :type query: str\n        :param accept_language: A comma-delimited list of one or more\n         languages to use for user interface strings. The list is in decreasing\n         order of preference. For additional information, including expected\n         format, see\n         [RFC2616](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html).\n         This header and the setLang query parameter are mutually exclusive; do\n         not specify both. If you set this header, you must also specify the\n         [cc](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-autosuggest-api-v7-reference#cc)\n         query parameter. To determine the market to return results for, Bing\n         uses the first supported language it finds from the list and combines\n         it with the cc parameter value. If the list does not include a\n         supported language, Bing finds the closest language and market that\n         supports the request or it uses an aggregated or default market for\n         the results. To determine the market that Bing used, see the\n         BingAPIs-Market header. Use this header and the cc query parameter\n         only if you specify multiple languages. Otherwise, use the\n         [mkt](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-autosuggest-api-v7-reference#mkt)\n         and\n         [setLang](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-autosuggest-api-v7-reference#setlang)\n         query parameters. A user interface string is a string that's used as a\n         label in a user interface. There are few user interface strings in the\n         JSON response objects. Any links to Bing.com properties in the\n         response objects apply the specified language.\n        :type accept_language: str\n        :param pragma: By default, Bing returns cached content, if available.\n         To prevent Bing from returning cached content, set the Pragma header\n         to no-cache (for example, Pragma: no-cache).\n        :type pragma: str\n        :param user_agent: The user agent originating the request. Bing uses\n         the user agent to provide mobile users with an optimized experience.\n         Although optional, you are encouraged to always specify this header.\n         The user-agent should be the same string that any commonly used\n         browser sends. For information about user agents, see [RFC\n         2616](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html). The\n         following are examples of user-agent strings. Windows Phone:\n         Mozilla/5.0 (compatible; MSIE 10.0; Windows Phone 8.0; Trident/6.0;\n         IEMobile/10.0; ARM; Touch; NOKIA; Lumia 822). Android: Mozilla / 5.0\n         (Linux; U; Android 2.3.5; en - us; SCH - I500 Build / GINGERBREAD)\n         AppleWebKit / 533.1 (KHTML; like Gecko) Version / 4.0 Mobile Safari /\n         533.1. iPhone: Mozilla / 5.0 (iPhone; CPU iPhone OS 6_1 like Mac OS X)\n         AppleWebKit / 536.26 (KHTML; like Gecko) Mobile / 10B142 iPhone4; 1\n         BingWeb / 3.03.1428.20120423. PC: Mozilla / 5.0 (Windows NT 6.3;\n         WOW64; Trident / 7.0; Touch; rv:11.0) like Gecko. iPad: Mozilla / 5.0\n         (iPad; CPU OS 7_0 like Mac OS X) AppleWebKit / 537.51.1 (KHTML, like\n         Gecko) Version / 7.0 Mobile / 11A465 Safari / 9537.53\n        :type user_agent: str\n        :param client_id: Bing uses this header to provide users with\n         consistent behavior across Bing API calls. Bing often flights new\n         features and improvements, and it uses the client ID as a key for\n         assigning traffic on different flights. If you do not use the same\n         client ID for a user across multiple requests, then Bing may assign\n         the user to multiple conflicting flights. Being assigned to multiple\n         conflicting flights can lead to an inconsistent user experience. For\n         example, if the second request has a different flight assignment than\n         the first, the experience may be unexpected. Also, Bing can use the\n         client ID to tailor web results to that client ID\u2019s search history,\n         providing a richer experience for the user. Bing also uses this header\n         to help improve result rankings by analyzing the activity generated by\n         a client ID. The relevance improvements help with better quality of\n         results delivered by Bing APIs and in turn enables higher\n         click-through rates for the API consumer. IMPORTANT: Although\n         optional, you should consider this header required. Persisting the\n         client ID across multiple requests for the same end user and device\n         combination enables 1) the API consumer to receive a consistent user\n         experience, and 2) higher click-through rates via better quality of\n         results from the Bing APIs. Each user that uses your application on\n         the device must have a unique, Bing generated client ID. If you do not\n         include this header in the request, Bing generates an ID and returns\n         it in the X-MSEdge-ClientID response header. The only time that you\n         should NOT include this header in a request is the first time the user\n         uses your app on that device. Use the client ID for each Bing API\n         request that your app makes for this user on the device. Persist the\n         client ID. To persist the ID in a browser app, use a persistent HTTP\n         cookie to ensure the ID is used across all sessions. Do not use a\n         session cookie. For other apps such as mobile apps, use the device's\n         persistent storage to persist the ID. The next time the user uses your\n         app on that device, get the client ID that you persisted. Bing\n         responses may or may not include this header. If the response includes\n         this header, capture the client ID and use it for all subsequent Bing\n         requests for the user on that device. If you include the\n         X-MSEdge-ClientID, you must not include cookies in the request.\n        :type client_id: str\n        :param client_ip: The IPv4 or IPv6 address of the client device. The\n         IP address is used to discover the user's location. Bing uses the\n         location information to determine safe search behavior. Although\n         optional, you are encouraged to always specify this header and the\n         X-Search-Location header. Do not obfuscate the address (for example,\n         by changing the last octet to 0). Obfuscating the address results in\n         the location not being anywhere near the device's actual location,\n         which may result in Bing serving erroneous results.\n        :type client_ip: str\n        :param location: A semicolon-delimited list of key/value pairs that\n         describe the client's geographical location. Bing uses the location\n         information to determine safe search behavior and to return relevant\n         local content. Specify the key/value pair as <key>:<value>. The\n         following are the keys that you use to specify the user's location.\n         lat (required): The latitude of the client's location, in degrees. The\n         latitude must be greater than or equal to -90.0 and less than or equal\n         to +90.0. Negative values indicate southern latitudes and positive\n         values indicate northern latitudes. long (required): The longitude of\n         the client's location, in degrees. The longitude must be greater than\n         or equal to -180.0 and less than or equal to +180.0. Negative values\n         indicate western longitudes and positive values indicate eastern\n         longitudes. re (required): The radius, in meters, which specifies the\n         horizontal accuracy of the coordinates. Pass the value returned by the\n         device's location service. Typical values might be 22m for GPS/Wi-Fi,\n         380m for cell tower triangulation, and 18,000m for reverse IP lookup.\n         ts (optional): The UTC UNIX timestamp of when the client was at the\n         location. (The UNIX timestamp is the number of seconds since January\n         1, 1970.) head (optional): The client's relative heading or direction\n         of travel. Specify the direction of travel as degrees from 0 through\n         360, counting clockwise relative to true north. Specify this key only\n         if the sp key is nonzero. sp (optional): The horizontal velocity\n         (speed), in meters per second, that the client device is traveling.\n         alt (optional): The altitude of the client device, in meters. are\n         (optional): The radius, in meters, that specifies the vertical\n         accuracy of the coordinates. Specify this key only if you specify the\n         alt key. Although many of the keys are optional, the more information\n         that you provide, the more accurate the location results are. Although\n         optional, you are encouraged to always specify the user's geographical\n         location. Providing the location is especially important if the\n         client's IP address does not accurately reflect the user's physical\n         location (for example, if the client uses VPN). For optimal results,\n         you should include this header and the X-MSEdge-ClientIP header, but\n         at a minimum, you should include this header.\n        :type location: str\n        :param country_code: A 2-character country code of the country where\n         the results come from. This API supports only the United States\n         market. If you specify this query parameter, it must be set to us. If\n         you set this parameter, you must also specify the Accept-Language\n         header. Bing uses the first supported language it finds from the\n         languages list, and combine that language with the country code that\n         you specify to determine the market to return results for. If the\n         languages list does not include a supported language, Bing finds the\n         closest language and market that supports the request, or it may use\n         an aggregated or default market for the results instead of a specified\n         one. You should use this query parameter and the Accept-Language query\n         parameter only if you specify multiple languages; otherwise, you\n         should use the mkt and setLang query parameters. This parameter and\n         the mkt query parameter are mutually exclusive\u2014do not specify both.\n        :type country_code: str\n        :param market: The market where the results come from. You are\n         strongly encouraged to always specify the market, if known. Specifying\n         the market helps Bing route the request and return an appropriate and\n         optimal response. This parameter and the cc query parameter are\n         mutually exclusive\u2014do not specify both.\n        :type market: str\n        :param safe_search: Filter suggestions for adult content. The\n         following are the possible filter values. Off: Return suggestions with\n         adult text, images, or videos. Moderate: Return suggestion with adult\n         text but not adult images or videos. Strict: Do not return news\n         articles with adult text, images, or videos. If the request comes from\n         a market that Bing's adult policy requires that safeSearch is set to\n         Strict, Bing ignores the safeSearch value and uses Strict. If you use\n         the site: query operator, there is the chance that the response may\n         contain adult content regardless of what the safeSearch query\n         parameter is set to. Use site: only if you are aware of the content on\n         the site and your scenario supports the possibility of adult content.\n         Possible values include: 'Off', 'Moderate', 'Strict'\n        :type safe_search: str or\n         ~azure.cognitiveservices.search.autosuggest.models.SafeSearch\n        :param set_lang: The language to use for user interface strings.\n         Specify the language using the ISO 639-1 2-letter language code. For\n         example, the language code for English is EN. The default is EN\n         (English). Although optional, you should always specify the language.\n         Typically, you set setLang to the same language specified by mkt\n         unless the user wants the user interface strings displayed in a\n         different language. This parameter and the Accept-Language header are\n         mutually exclusive; do not specify both. A user interface string is a\n         string that's used as a label in a user interface. There are few user\n         interface strings in the JSON response objects. Also, any links to\n         Bing.com properties in the response objects apply the specified\n         language.\n        :type set_lang: str\n        :param response_format: The media type to use for the response. The\n         following are the possible case-insensitive values: JSON, JSONLD. The\n         default is JSON. If you specify JSONLD, the response body includes\n         JSON-LD objects that contain the search results.\n        :type response_format: list[str or\n         ~azure.cognitiveservices.search.autosuggest.models.ResponseFormat]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Suggestions or ClientRawResponse if raw=true\n        :rtype: ~azure.cognitiveservices.search.autosuggest.models.Suggestions\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.search.autosuggest.models.ErrorResponseException>`", "id": "f42273:c1:m1"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ClientDiscoveryValueForSingleApiPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ClientDiscoveryValueForSingleApiPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Returns the list of available operations.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ClientDiscoveryValueForSingleApi\n        :rtype:\n         ~azure.mgmt.recoveryservicesbackup.models.ClientDiscoveryValueForSingleApiPaged[~azure.mgmt.recoveryservicesbackup.models.ClientDiscoveryValueForSingleApi]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f42762:c0:m1"}
{"signature": "def get(<EOL>self, vault_name, resource_group_name, policy_name, operation_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", policy_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", operation_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Provides the status of the asynchronous operations like backup,\n        restore. The status can be in progress, completed or failed. You can\n        refer to the Operation Status enum for all the possible states of an\n        operation. Some operations create jobs. This method returns the list of\n        jobs associated with operation.\n\n        :param vault_name: The name of the recovery services vault.\n        :type vault_name: str\n        :param resource_group_name: The name of the resource group where the\n         recovery services vault is present.\n        :type resource_group_name: str\n        :param policy_name: Backup policy name whose operation's status needs\n         to be fetched.\n        :type policy_name: str\n        :param operation_id: Operation ID which represents an operation whose\n         status needs to be fetched.\n        :type operation_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: OperationStatus or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.recoveryservicesbackup.models.OperationStatus or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f42764:c0:m1"}
{"signature": "def trigger(<EOL>self, vault_name, resource_group_name, fabric_name, container_name, protected_item_name, recovery_point_id, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.trigger.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", fabric_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", container_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", protected_item_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", recovery_point_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, body_content, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Restores the specified backed up data. This is an asynchronous\n        operation. To know the status of this API call, use\n        GetProtectedItemOperationResult API.\n\n        :param vault_name: The name of the recovery services vault.\n        :type vault_name: str\n        :param resource_group_name: The name of the resource group where the\n         recovery services vault is present.\n        :type resource_group_name: str\n        :param fabric_name: Fabric name associated with the backed up items.\n        :type fabric_name: str\n        :param container_name: Container name associated with the backed up\n         items.\n        :type container_name: str\n        :param protected_item_name: Backed up item to be restored.\n        :type protected_item_name: str\n        :param recovery_point_id: Recovery point ID which represents the\n         backed up data to be restored.\n        :type recovery_point_id: str\n        :param parameters: resource restore request\n        :type parameters:\n         ~azure.mgmt.recoveryservicesbackup.models.RestoreRequestResource\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f42769:c0:m1"}
{"signature": "def get(<EOL>self, vault_name, resource_group_name, fabric_name, container_name, protected_item_name, operation_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", fabric_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", container_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", protected_item_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", operation_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Fetches the result of any operation on the backup item.\n\n        :param vault_name: The name of the recovery services vault.\n        :type vault_name: str\n        :param resource_group_name: The name of the resource group where the\n         recovery services vault is present.\n        :type resource_group_name: str\n        :param fabric_name: Fabric name associated with the backup item.\n        :type fabric_name: str\n        :param container_name: Container name associated with the backup item.\n        :type container_name: str\n        :param protected_item_name: Backup item name whose details are to be\n         fetched.\n        :type protected_item_name: str\n        :param operation_id: OperationID which represents the operation whose\n         result needs to be fetched.\n        :type operation_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ProtectedItemResource or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.recoveryservicesbackup.models.ProtectedItemResource or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f42770:c0:m1"}
{"signature": "def get(<EOL>self, vault_name, resource_group_name, job_name, operation_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", job_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", operation_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Fetches the result of any operation.\n        the operation.\n\n        :param vault_name: The name of the recovery services vault.\n        :type vault_name: str\n        :param resource_group_name: The name of the resource group where the\n         recovery services vault is present.\n        :type resource_group_name: str\n        :param job_name: Job name whose operation result has to be fetched.\n        :type job_name: str\n        :param operation_id: OperationID which represents the operation whose\n         result has to be fetched.\n        :type operation_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f42771:c0:m1"}
{"signature": "def get(<EOL>self, vault_name, resource_group_name, fabric_name, container_name, protected_item_name, recovery_point_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", fabric_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", container_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", protected_item_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", recovery_point_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Provides the information of the backed up data identified using\n        RecoveryPointID. This is an asynchronous operation. To know the status\n        of the operation, call the GetProtectedItemOperationResult API.\n\n        :param vault_name: The name of the recovery services vault.\n        :type vault_name: str\n        :param resource_group_name: The name of the resource group where the\n         recovery services vault is present.\n        :type resource_group_name: str\n        :param fabric_name: Fabric name associated with backed up item.\n        :type fabric_name: str\n        :param container_name: Container name associated with backed up item.\n        :type container_name: str\n        :param protected_item_name: Backed up item name whose backup data\n         needs to be fetched.\n        :type protected_item_name: str\n        :param recovery_point_id: RecoveryPointID represents the backed up\n         data to be fetched.\n        :type recovery_point_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RecoveryPointResource or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.recoveryservicesbackup.models.RecoveryPointResource or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f42772:c0:m2"}
{"signature": "def list(<EOL>self, vault_name, resource_group_name, fabric_name, filter=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", fabric_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ProtectableContainerResourcePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ProtectableContainerResourcePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists the containers registered to Recovery Services Vault.\n\n        :param vault_name: The name of the recovery services vault.\n        :type vault_name: str\n        :param resource_group_name: The name of the resource group where the\n         recovery services vault is present.\n        :type resource_group_name: str\n        :param fabric_name: Fabric name associated with the container.\n        :type fabric_name: str\n        :param filter: OData filter options.\n        :type filter: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ProtectableContainerResource\n        :rtype:\n         ~azure.mgmt.recoveryservicesbackup.models.ProtectableContainerResourcePaged[~azure.mgmt.recoveryservicesbackup.models.ProtectableContainerResource]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f42776:c0:m1"}
{"signature": "def create_or_update(<EOL>self, vault_name, resource_group_name, policy_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", policy_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, body_content, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or modifies a backup policy. This is an asynchronous operation.\n        Status of the operation can be fetched using GetPolicyOperationResult\n        API.\n\n        :param vault_name: The name of the recovery services vault.\n        :type vault_name: str\n        :param resource_group_name: The name of the resource group where the\n         recovery services vault is present.\n        :type resource_group_name: str\n        :param policy_name: Backup policy to be created.\n        :type policy_name: str\n        :param parameters: resource backup policy\n        :type parameters:\n         ~azure.mgmt.recoveryservicesbackup.models.ProtectionPolicyResource\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ProtectionPolicyResource or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.recoveryservicesbackup.models.ProtectionPolicyResource or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f42782:c0:m2"}
{"signature": "def get(<EOL>self, vault_name, resource_group_name, policy_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", policy_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Provides the details of the backup policies associated to Recovery\n        Services Vault. This is an asynchronous operation. Status of the\n        operation can be fetched using GetPolicyOperationResult API.\n\n        :param vault_name: The name of the recovery services vault.\n        :type vault_name: str\n        :param resource_group_name: The name of the resource group where the\n         recovery services vault is present.\n        :type resource_group_name: str\n        :param policy_name: Backup policy information to be fetched.\n        :type policy_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ProtectionPolicyResource or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.recoveryservicesbackup.models.ProtectionPolicyResource or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f42782:c0:m1"}
{"signature": "def provision(<EOL>self, vault_name, resource_group_name, fabric_name, container_name, protected_item_name, recovery_point_id, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.provision.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", fabric_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", container_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", protected_item_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", recovery_point_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, body_content, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Provisions a script which invokes an iSCSI connection to the backup\n        data. Executing this script opens a file explorer displaying all the\n        recoverable files and folders. This is an asynchronous operation. To\n        know the status of provisioning, call GetProtectedItemOperationResult\n        API.\n\n        :param vault_name: The name of the recovery services vault.\n        :type vault_name: str\n        :param resource_group_name: The name of the resource group where the\n         recovery services vault is present.\n        :type resource_group_name: str\n        :param fabric_name: Fabric name associated with the backed up items.\n        :type fabric_name: str\n        :param container_name: Container name associated with the backed up\n         items.\n        :type container_name: str\n        :param protected_item_name: Backed up item name whose files/folders\n         are to be restored.\n        :type protected_item_name: str\n        :param recovery_point_id: Recovery point ID which represents backed up\n         data. iSCSI connection will be provisioned for this backed up data.\n        :type recovery_point_id: str\n        :param parameters: resource ILR request\n        :type parameters:\n         ~azure.mgmt.recoveryservicesbackup.models.ILRRequestResource\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f42785:c0:m1"}
{"signature": "def update(<EOL>self, vault_name, resource_group_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, body_content, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Updates vault storage model type.\n\n        :param vault_name: The name of the recovery services vault.\n        :type vault_name: str\n        :param resource_group_name: The name of the resource group where the\n         recovery services vault is present.\n        :type resource_group_name: str\n        :param parameters: Vault storage config request\n        :type parameters:\n         ~azure.mgmt.recoveryservicesbackup.models.BackupResourceConfigResource\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f42790:c0:m2"}
{"signature": "def delete(<EOL>self, vault_name, resource_group_name, fabric_name, container_name, protected_item_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", fabric_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", container_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", protected_item_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Used to disable backup of an item within a container. This is an\n        asynchronous operation. To know the status of the request, call the\n        GetItemOperationResult API.\n\n        :param vault_name: The name of the recovery services vault.\n        :type vault_name: str\n        :param resource_group_name: The name of the resource group where the\n         recovery services vault is present.\n        :type resource_group_name: str\n        :param fabric_name: Fabric name associated with the backed up item.\n        :type fabric_name: str\n        :param container_name: Container name associated with the backed up\n         item.\n        :type container_name: str\n        :param protected_item_name: Backed up item to be deleted.\n        :type protected_item_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f42794:c0:m3"}
{"signature": "def get(<EOL>self, vault_name, resource_group_name, fabric_name, container_name, protected_item_name, filter=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", fabric_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", container_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", protected_item_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Provides the details of the backed up item. This is an asynchronous\n        operation. To know the status of the operation, call the\n        GetItemOperationResult API.\n\n        :param vault_name: The name of the recovery services vault.\n        :type vault_name: str\n        :param resource_group_name: The name of the resource group where the\n         recovery services vault is present.\n        :type resource_group_name: str\n        :param fabric_name: Fabric name associated with the backed up item.\n        :type fabric_name: str\n        :param container_name: Container name associated with the backed up\n         item.\n        :type container_name: str\n        :param protected_item_name: Backed up item name whose details are to\n         be fetched.\n        :type protected_item_name: str\n        :param filter: OData filter options.\n        :type filter: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ProtectedItemResource or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.recoveryservicesbackup.models.ProtectedItemResource or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f42794:c0:m1"}
{"signature": "def get(<EOL>self, vault_name, resource_group_name, backup_engine_name, filter=None, skip_token=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vault_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", backup_engine_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if skip_token is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", skip_token, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Returns backup management server registered to Recovery Services Vault.\n\n        :param vault_name: The name of the recovery services vault.\n        :type vault_name: str\n        :param resource_group_name: The name of the resource group where the\n         recovery services vault is present.\n        :type resource_group_name: str\n        :param backup_engine_name: Name of the backup management server.\n        :type backup_engine_name: str\n        :param filter: OData filter options.\n        :type filter: str\n        :param skip_token: skipToken Filter.\n        :type skip_token: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: BackupEngineBaseResource or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.recoveryservicesbackup.models.BackupEngineBaseResource or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f42795:c0:m2"}
{"signature": "def query(<EOL>self, workspace_id, body, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.query.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", workspace_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(body, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, body_content, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Execute an Analytics query.\n\n        Executes an Analytics query for data.\n        [Here](https://dev.loganalytics.io/documentation/Using-the-API) is an\n        example for using POST with an Analytics query.\n\n        :param workspace_id: ID of the workspace. This is Workspace ID from\n         the Properties blade in the Azure portal.\n        :type workspace_id: str\n        :param body: The Analytics query. Learn more about the [Analytics\n         query\n         syntax](https://azure.microsoft.com/documentation/articles/app-insights-analytics-reference/)\n        :type body: ~azure.loganalytics.models.QueryBody\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: QueryResults or ClientRawResponse if raw=true\n        :rtype: ~azure.loganalytics.models.QueryResults or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.loganalytics.models.ErrorResponseException>`", "id": "f42798:c1:m1"}
{"signature": "def get_authorization_rule(<EOL>self, resource_group_name, namespace_name, authorization_rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = '<STR_LIT>'<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:6>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", authorization_rule_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Authorization rule for a namespace by name.\n\n        :param resource_group_name: Name of the Resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param namespace_name: The namespace name\n        :type namespace_name: str\n        :param authorization_rule_name: The authorization rule name.\n        :type authorization_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: AuthorizationRule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.relay.models.AuthorizationRule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.relay.models.ErrorResponseException>`", "id": "f42841:c0:m11"}
{"signature": "def update(<EOL>self, resource_group_name, namespace_name, tags=None, sku=None, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.RelayUpdateParameters(tags=tags, sku=sku)<EOL>url = '<STR_LIT>'<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:6>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, body_content, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or updates a namespace. Once created, this namespace's resource\n        manifest is immutable. This operation is idempotent.\n\n        :param resource_group_name: Name of the Resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param namespace_name: The namespace name\n        :type namespace_name: str\n        :param tags: Resource tags.\n        :type tags: dict[str, str]\n        :param sku: SKU of the namespace.\n        :type sku: ~azure.mgmt.relay.models.Sku\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RelayNamespace or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.relay.models.RelayNamespace or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.relay.models.ErrorResponseException>`", "id": "f42841:c0:m7"}
{"signature": "def get_authorization_rule(<EOL>self, resource_group_name, namespace_name, relay_name, authorization_rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = '<STR_LIT>'<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:6>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", relay_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", authorization_rule_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get authorizationRule for a WCF relay by name.\n\n        :param resource_group_name: Name of the Resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param namespace_name: The namespace name\n        :type namespace_name: str\n        :param relay_name: The relay name.\n        :type relay_name: str\n        :param authorization_rule_name: The authorization rule name.\n        :type authorization_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: AuthorizationRule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.relay.models.AuthorizationRule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.relay.models.ErrorResponseException>`", "id": "f42842:c0:m8"}
{"signature": "def list_keys(<EOL>self, resource_group_name, namespace_name, relay_name, authorization_rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = '<STR_LIT>'<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:6>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", relay_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", authorization_rule_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Primary and secondary connection strings to the WCF relay.\n\n        :param resource_group_name: Name of the Resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param namespace_name: The namespace name\n        :type namespace_name: str\n        :param relay_name: The relay name.\n        :type relay_name: str\n        :param authorization_rule_name: The authorization rule name.\n        :type authorization_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: AccessKeys or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.relay.models.AccessKeys or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.relay.models.ErrorResponseException>`", "id": "f42842:c0:m9"}
{"signature": "def create_or_update_authorization_rule(<EOL>self, resource_group_name, namespace_name, relay_name, authorization_rule_name, rights=None, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.AuthorizationRule(rights=rights)<EOL>url = '<STR_LIT>'<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:6>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", relay_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", authorization_rule_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, body_content, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or updates an authorization rule for a WCF relay.\n\n        :param resource_group_name: Name of the Resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param namespace_name: The namespace name\n        :type namespace_name: str\n        :param relay_name: The relay name.\n        :type relay_name: str\n        :param authorization_rule_name: The authorization rule name.\n        :type authorization_rule_name: str\n        :param rights: The rights associated with the rule.\n        :type rights: list[str or ~azure.mgmt.relay.models.AccessRights]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: AuthorizationRule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.relay.models.AuthorizationRule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.relay.models.ErrorResponseException>`", "id": "f42842:c0:m6"}
{"signature": "def update(<EOL>self, app_id, emails=None, custom_headers=None, raw=False, **operation_config):", "body": "collaborators = models.CollaboratorsArray(emails=emails)<EOL>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", app_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(collaborators, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Replaces the current user access list with the new list sent in the\n        body. If an empty list is sent, all access to other users will be\n        removed.\n\n        :param app_id: The application ID.\n        :type app_id: str\n        :param emails: The email address of the users.\n        :type emails: list[str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: OperationStatus or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.cognitiveservices.language.luis.authoring.models.OperationStatus\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.language.luis.authoring.models.ErrorResponseException>`", "id": "f43226:c0:m4"}
{"signature": "def delete_explicit_list_item(<EOL>self, app_id, version_id, entity_id, item_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete_explicit_list_item.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", app_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", version_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", entity_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", item_id, '<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Delete an item from the explicit (exception) list for a Pattern.any\n        entity in a version of the application.\n\n        :param app_id: The application ID.\n        :type app_id: str\n        :param version_id: The version ID.\n        :type version_id: str\n        :param entity_id: The pattern.any entity id.\n        :type entity_id: str\n        :param item_id: The explicit list item which will be deleted.\n        :type item_id: long\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: OperationStatus or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.cognitiveservices.language.luis.authoring.models.OperationStatus\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.language.luis.authoring.models.ErrorResponseException>`", "id": "f43227:c0:m106"}
{"signature": "def list_custom_prebuilt_intents(<EOL>self, app_id, version_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_custom_prebuilt_intents.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", app_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", version_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about customizable prebuilt intents added to a version\n        of the application.\n\n        :param app_id: The application ID.\n        :type app_id: str\n        :param version_id: The version ID.\n        :type version_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype:\n         list[~azure.cognitiveservices.language.luis.authoring.models.IntentClassifier]\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.language.luis.authoring.models.ErrorResponseException>`", "id": "f43227:c0:m41"}
{"signature": "def delete_hierarchical_entity_child(<EOL>self, app_id, version_id, h_entity_id, h_child_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete_hierarchical_entity_child.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", app_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", version_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", h_entity_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", h_child_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Deletes a hierarchical entity extractor child in a version of the\n        application.\n\n        :param app_id: The application ID.\n        :type app_id: str\n        :param version_id: The version ID.\n        :type version_id: str\n        :param h_entity_id: The hierarchical entity extractor ID.\n        :type h_entity_id: str\n        :param h_child_id: The hierarchical entity extractor child ID.\n        :type h_child_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: OperationStatus or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.cognitiveservices.language.luis.authoring.models.OperationStatus\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.language.luis.authoring.models.ErrorResponseException>`", "id": "f43227:c0:m48"}
{"signature": "def get_closed_list_entity_role(<EOL>self, app_id, version_id, entity_id, role_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_closed_list_entity_role.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", app_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", version_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", entity_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", role_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get one role for a given list entity in a version of the application.\n\n        :param app_id: The application ID.\n        :type app_id: str\n        :param version_id: The version ID.\n        :type version_id: str\n        :param entity_id: entity ID.\n        :type entity_id: str\n        :param role_id: entity role ID.\n        :type role_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: EntityRole or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.cognitiveservices.language.luis.authoring.models.EntityRole or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.language.luis.authoring.models.ErrorResponseException>`", "id": "f43227:c0:m86"}
{"signature": "def add_entity(<EOL>self, app_id, version_id, name=None, custom_headers=None, raw=False, **operation_config):", "body": "model_create_object = models.ModelCreateObject(name=name)<EOL>url = self.add_entity.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", app_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", version_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(model_create_object, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT:str>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Adds a simple entity extractor to a version of the application.\n\n        :param app_id: The application ID.\n        :type app_id: str\n        :param version_id: The version ID.\n        :type version_id: str\n        :param name: Name of the new entity extractor.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: str or ClientRawResponse if raw=true\n        :rtype: str or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.language.luis.authoring.models.ErrorResponseException>`", "id": "f43227:c0:m3"}
{"signature": "def create_prebuilt_entity_role(<EOL>self, app_id, version_id, entity_id, name=None, custom_headers=None, raw=False, **operation_config):", "body": "entity_role_create_object = models.EntityRoleCreateObject(name=name)<EOL>url = self.create_prebuilt_entity_role.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", app_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", version_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", entity_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(entity_role_create_object, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT:str>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Create a role for a prebuilt entity in a version of the application.\n\n        :param app_id: The application ID.\n        :type app_id: str\n        :param version_id: The version ID.\n        :type version_id: str\n        :param entity_id: The entity model ID.\n        :type entity_id: str\n        :param name: The entity role name.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: str or ClientRawResponse if raw=true\n        :rtype: str or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.language.luis.authoring.models.ErrorResponseException>`", "id": "f43227:c0:m59"}
{"signature": "def delete_closed_list(<EOL>self, app_id, version_id, cl_entity_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete_closed_list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", app_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", version_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", cl_entity_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Deletes a list entity model from a version of the application.\n\n        :param app_id: The application ID.\n        :type app_id: str\n        :param version_id: The version ID.\n        :type version_id: str\n        :param cl_entity_id: The list entity model ID.\n        :type cl_entity_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: OperationStatus or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.cognitiveservices.language.luis.authoring.models.OperationStatus\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.language.luis.authoring.models.ErrorResponseException>`", "id": "f43227:c0:m31"}
{"signature": "def list_intents(<EOL>self, app_id, version_id, skip=<NUM_LIT:0>, take=<NUM_LIT:100>, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_intents.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", app_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", version_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if skip is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", skip, '<STR_LIT:int>', minimum=<NUM_LIT:0>)<EOL><DEDENT>if take is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", take, '<STR_LIT:int>', maximum=<NUM_LIT>, minimum=<NUM_LIT:0>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about the intent models in a version of the\n        application.\n\n        :param app_id: The application ID.\n        :type app_id: str\n        :param version_id: The version ID.\n        :type version_id: str\n        :param skip: The number of entries to skip. Default value is 0.\n        :type skip: int\n        :param take: The number of entries to return. Maximum page size is\n         500. Default is 100.\n        :type take: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype:\n         list[~azure.cognitiveservices.language.luis.authoring.models.IntentClassifier]\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.language.luis.authoring.models.ErrorResponseException>`", "id": "f43227:c0:m2"}
{"signature": "def update_composite_entity(<EOL>self, app_id, version_id, c_entity_id, children=None, name=None, custom_headers=None, raw=False, **operation_config):", "body": "composite_model_update_object = models.CompositeEntityModel(children=children, name=name)<EOL>url = self.update_composite_entity.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", app_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", version_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", c_entity_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(composite_model_update_object, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Updates a composite entity in a version of the application.\n\n        :param app_id: The application ID.\n        :type app_id: str\n        :param version_id: The version ID.\n        :type version_id: str\n        :param c_entity_id: The composite entity extractor ID.\n        :type c_entity_id: str\n        :param children: Child entities.\n        :type children: list[str]\n        :param name: Entity name.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: OperationStatus or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.cognitiveservices.language.luis.authoring.models.OperationStatus\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.language.luis.authoring.models.ErrorResponseException>`", "id": "f43227:c0:m26"}
{"signature": "def update_closed_list_entity_role(<EOL>self, app_id, version_id, entity_id, role_id, name=None, custom_headers=None, raw=False, **operation_config):", "body": "entity_role_update_object = models.EntityRoleUpdateObject(name=name)<EOL>url = self.update_closed_list_entity_role.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", app_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", version_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", entity_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", role_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(entity_role_update_object, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Update a role for a given list entity in a version of the application.\n\n        :param app_id: The application ID.\n        :type app_id: str\n        :param version_id: The version ID.\n        :type version_id: str\n        :param entity_id: The entity ID.\n        :type entity_id: str\n        :param role_id: The entity role ID.\n        :type role_id: str\n        :param name: The entity role name.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: OperationStatus or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.cognitiveservices.language.luis.authoring.models.OperationStatus\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.language.luis.authoring.models.ErrorResponseException>`", "id": "f43227:c0:m87"}
{"signature": "def list_intent_suggestions(<EOL>self, app_id, version_id, intent_id, take=<NUM_LIT:100>, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_intent_suggestions.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", app_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", version_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", intent_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if take is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", take, '<STR_LIT:int>', maximum=<NUM_LIT>, minimum=<NUM_LIT:0>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Suggests example utterances that would improve the accuracy of the\n        intent model in a version of the application.\n\n        :param app_id: The application ID.\n        :type app_id: str\n        :param version_id: The version ID.\n        :type version_id: str\n        :param intent_id: The intent classifier ID.\n        :type intent_id: str\n        :param take: The number of entries to return. Maximum page size is\n         500. Default is 100.\n        :type take: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype:\n         list[~azure.cognitiveservices.language.luis.authoring.models.IntentsSuggestionExample]\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.language.luis.authoring.models.ErrorResponseException>`", "id": "f43227:c0:m36"}
{"signature": "def add_custom_prebuilt_entity(<EOL>self, app_id, version_id, domain_name=None, model_name=None, custom_headers=None, raw=False, **operation_config):", "body": "prebuilt_domain_model_create_object = models.PrebuiltDomainModelCreateObject(domain_name=domain_name, model_name=model_name)<EOL>url = self.add_custom_prebuilt_entity.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", app_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", version_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(prebuilt_domain_model_create_object, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT:str>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Adds a prebuilt entity model to a version of the application.\n\n        :param app_id: The application ID.\n        :type app_id: str\n        :param version_id: The version ID.\n        :type version_id: str\n        :param domain_name: The domain name.\n        :type domain_name: str\n        :param model_name: The intent name or entity name.\n        :type model_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: str or ClientRawResponse if raw=true\n        :rtype: str or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.language.luis.authoring.models.ErrorResponseException>`", "id": "f43227:c0:m42"}
{"signature": "def delete_hierarchical_entity_role(<EOL>self, app_id, version_id, h_entity_id, role_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete_hierarchical_entity_role.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", app_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", version_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", h_entity_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", role_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Delete a role for a given hierarchical role in a version of the\n        application.\n\n        :param app_id: The application ID.\n        :type app_id: str\n        :param version_id: The version ID.\n        :type version_id: str\n        :param h_entity_id: The hierarchical entity extractor ID.\n        :type h_entity_id: str\n        :param role_id: The entity role Id.\n        :type role_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: OperationStatus or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.cognitiveservices.language.luis.authoring.models.OperationStatus\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.language.luis.authoring.models.ErrorResponseException>`", "id": "f43227:c0:m100"}
{"signature": "def delete_custom_entity_role(<EOL>self, app_id, version_id, entity_id, role_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete_custom_entity_role.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", app_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", version_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", entity_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", role_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Delete a role for a given prebuilt entity in a version of the\n        application.\n\n        :param app_id: The application ID.\n        :type app_id: str\n        :param version_id: The version ID.\n        :type version_id: str\n        :param entity_id: The entity ID.\n        :type entity_id: str\n        :param role_id: The entity role Id.\n        :type role_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: OperationStatus or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.cognitiveservices.language.luis.authoring.models.OperationStatus\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.language.luis.authoring.models.ErrorResponseException>`", "id": "f43227:c0:m103"}
{"signature": "def update_entity(<EOL>self, app_id, version_id, entity_id, name=None, custom_headers=None, raw=False, **operation_config):", "body": "model_update_object = models.ModelUpdateObject(name=name)<EOL>url = self.update_entity.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", app_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", version_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", entity_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(model_update_object, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Updates the name of an entity in a version of the application.\n\n        :param app_id: The application ID.\n        :type app_id: str\n        :param version_id: The version ID.\n        :type version_id: str\n        :param entity_id: The entity extractor ID.\n        :type entity_id: str\n        :param name: The entity's new name.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: OperationStatus or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.cognitiveservices.language.luis.authoring.models.OperationStatus\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.language.luis.authoring.models.ErrorResponseException>`", "id": "f43227:c0:m20"}
{"signature": "def list_hierarchical_entities(<EOL>self, app_id, version_id, skip=<NUM_LIT:0>, take=<NUM_LIT:100>, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_hierarchical_entities.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", app_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", version_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if skip is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", skip, '<STR_LIT:int>', minimum=<NUM_LIT:0>)<EOL><DEDENT>if take is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", take, '<STR_LIT:int>', maximum=<NUM_LIT>, minimum=<NUM_LIT:0>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets information about all the hierarchical entity models in a version\n        of the application.\n\n        :param app_id: The application ID.\n        :type app_id: str\n        :param version_id: The version ID.\n        :type version_id: str\n        :param skip: The number of entries to skip. Default value is 0.\n        :type skip: int\n        :param take: The number of entries to return. Maximum page size is\n         500. Default is 100.\n        :type take: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype:\n         list[~azure.cognitiveservices.language.luis.authoring.models.HierarchicalEntityExtractor]\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.language.luis.authoring.models.ErrorResponseException>`", "id": "f43227:c0:m6"}
{"signature": "def delete_prebuilt(<EOL>self, app_id, version_id, prebuilt_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete_prebuilt.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", app_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", version_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", prebuilt_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Deletes a prebuilt entity extractor from a version of the application.\n\n        :param app_id: The application ID.\n        :type app_id: str\n        :param version_id: The version ID.\n        :type version_id: str\n        :param prebuilt_id: The prebuilt entity extractor ID.\n        :type prebuilt_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: OperationStatus or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.cognitiveservices.language.luis.authoring.models.OperationStatus\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.language.luis.authoring.models.ErrorResponseException>`", "id": "f43227:c0:m33"}
{"signature": "def get_composite_entity_role(<EOL>self, app_id, version_id, c_entity_id, role_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_composite_entity_role.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", app_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", version_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", c_entity_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", role_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get one role for a given composite entity in a version of the\n        application.\n\n        :param app_id: The application ID.\n        :type app_id: str\n        :param version_id: The version ID.\n        :type version_id: str\n        :param c_entity_id: The composite entity extractor ID.\n        :type c_entity_id: str\n        :param role_id: entity role ID.\n        :type role_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: EntityRole or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.cognitiveservices.language.luis.authoring.models.EntityRole or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.language.luis.authoring.models.ErrorResponseException>`", "id": "f43227:c0:m92"}
{"signature": "def add_composite_entity(<EOL>self, app_id, version_id, children=None, name=None, custom_headers=None, raw=False, **operation_config):", "body": "composite_model_create_object = models.CompositeEntityModel(children=children, name=name)<EOL>url = self.add_composite_entity.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", app_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", version_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(composite_model_create_object, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT:str>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Adds a composite entity extractor to a version of the application.\n\n        :param app_id: The application ID.\n        :type app_id: str\n        :param version_id: The version ID.\n        :type version_id: str\n        :param children: Child entities.\n        :type children: list[str]\n        :param name: Entity name.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: str or ClientRawResponse if raw=true\n        :rtype: str or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.language.luis.authoring.models.ErrorResponseException>`", "id": "f43227:c0:m7"}
{"signature": "def add_hierarchical_entity(<EOL>self, app_id, version_id, children=None, name=None, custom_headers=None, raw=False, **operation_config):", "body": "hierarchical_model_create_object = models.HierarchicalEntityModel(children=children, name=name)<EOL>url = self.add_hierarchical_entity.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", app_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", version_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(hierarchical_model_create_object, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT:str>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Adds a hierarchical entity extractor to a version of the application.\n\n        :param app_id: The application ID.\n        :type app_id: str\n        :param version_id: The version ID.\n        :type version_id: str\n        :param children: Child entities.\n        :type children: list[str]\n        :param name: Entity name.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: str or ClientRawResponse if raw=true\n        :rtype: str or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.language.luis.authoring.models.ErrorResponseException>`", "id": "f43227:c0:m5"}
{"signature": "def add_prebuilt(<EOL>self, app_id, version_id, prebuilt_extractor_names, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.add_prebuilt.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", app_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", version_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(prebuilt_extractor_names, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Adds a list of prebuilt entities to a version of the application.\n\n        :param app_id: The application ID.\n        :type app_id: str\n        :param version_id: The version ID.\n        :type version_id: str\n        :param prebuilt_extractor_names: An array of prebuilt entity extractor\n         names.\n        :type prebuilt_extractor_names: list[str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype:\n         list[~azure.cognitiveservices.language.luis.authoring.models.PrebuiltEntityExtractor]\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.language.luis.authoring.models.ErrorResponseException>`", "id": "f43227:c0:m11"}
{"signature": "def list_application_version_pattern_features(<EOL>self, app_id, version_id, skip=<NUM_LIT:0>, take=<NUM_LIT:100>, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_application_version_pattern_features.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", app_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", version_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if skip is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", skip, '<STR_LIT:int>', minimum=<NUM_LIT:0>)<EOL><DEDENT>if take is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", take, '<STR_LIT:int>', maximum=<NUM_LIT>, minimum=<NUM_LIT:0>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "[DEPRECATED NOTICE: This operation will soon be removed] Gets all the\n        pattern features.\n\n        :param app_id: The application ID.\n        :type app_id: str\n        :param version_id: The version ID.\n        :type version_id: str\n        :param skip: The number of entries to skip. Default value is 0.\n        :type skip: int\n        :param take: The number of entries to return. Maximum page size is\n         500. Default is 100.\n        :type take: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype:\n         list[~azure.cognitiveservices.language.luis.authoring.models.PatternFeatureInfo]\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.language.luis.authoring.models.ErrorResponseException>`", "id": "f43229:c0:m1"}
{"signature": "def get(<EOL>self, app_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", app_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the application info.\n\n        :param app_id: The application ID.\n        :type app_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ApplicationInfoResponse or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.cognitiveservices.language.luis.authoring.models.ApplicationInfoResponse\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.language.luis.authoring.models.ErrorResponseException>`", "id": "f43230:c0:m9"}
{"signature": "def get_publish_settings(<EOL>self, app_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_publish_settings.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", app_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the application publish settings including 'UseAllTrainingData'.\n\n        :param app_id: The application ID.\n        :type app_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PublishSettings or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.cognitiveservices.language.luis.authoring.models.PublishSettings\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.language.luis.authoring.models.ErrorResponseException>`", "id": "f43230:c0:m15"}
{"signature": "def list_endpoints(<EOL>self, app_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_endpoints.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", app_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Returns the available endpoint deployment regions and URLs.\n\n        :param app_id: The application ID.\n        :type app_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: dict or ClientRawResponse if raw=true\n        :rtype: dict[str, str] or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.language.luis.authoring.models.ErrorResponseException>`", "id": "f43230:c0:m17"}
{"signature": "def list_available_custom_prebuilt_domains_for_culture(<EOL>self, culture, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_available_custom_prebuilt_domains_for_culture.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", culture, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all the available prebuilt domains for a specific culture.\n\n        :param culture: Culture.\n        :type culture: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype:\n         list[~azure.cognitiveservices.language.luis.authoring.models.PrebuiltDomain]\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.language.luis.authoring.models.ErrorResponseException>`", "id": "f43230:c0:m20"}
{"signature": "def list_intent_patterns(<EOL>self, app_id, version_id, intent_id, skip=<NUM_LIT:0>, take=<NUM_LIT:100>, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_intent_patterns.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", app_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", version_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", intent_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if skip is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", skip, '<STR_LIT:int>', minimum=<NUM_LIT:0>)<EOL><DEDENT>if take is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", take, '<STR_LIT:int>', maximum=<NUM_LIT>, minimum=<NUM_LIT:0>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Returns patterns for the specific intent in a version of the\n        application.\n\n        :param app_id: The application ID.\n        :type app_id: str\n        :param version_id: The version ID.\n        :type version_id: str\n        :param intent_id: The intent classifier ID.\n        :type intent_id: str\n        :param skip: The number of entries to skip. Default value is 0.\n        :type skip: int\n        :param take: The number of entries to return. Maximum page size is\n         500. Default is 100.\n        :type take: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype:\n         list[~azure.cognitiveservices.language.luis.authoring.models.PatternRuleInfo]\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.language.luis.authoring.models.ErrorResponseException>`", "id": "f43231:c0:m8"}
{"signature": "def list_patterns(<EOL>self, app_id, version_id, skip=<NUM_LIT:0>, take=<NUM_LIT:100>, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_patterns.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", app_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", version_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if skip is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", skip, '<STR_LIT:int>', minimum=<NUM_LIT:0>)<EOL><DEDENT>if take is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", take, '<STR_LIT:int>', maximum=<NUM_LIT>, minimum=<NUM_LIT:0>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets patterns in a version of the application.\n\n        :param app_id: The application ID.\n        :type app_id: str\n        :param version_id: The version ID.\n        :type version_id: str\n        :param skip: The number of entries to skip. Default value is 0.\n        :type skip: int\n        :param take: The number of entries to return. Maximum page size is\n         500. Default is 100.\n        :type take: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype:\n         list[~azure.cognitiveservices.language.luis.authoring.models.PatternRuleInfo]\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.language.luis.authoring.models.ErrorResponseException>`", "id": "f43231:c0:m2"}
{"signature": "def update_patterns(<EOL>self, app_id, version_id, patterns, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.update_patterns.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", app_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", version_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(patterns, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Updates patterns in a version of the application.\n\n        :param app_id: The application ID.\n        :type app_id: str\n        :param version_id: The version ID.\n        :type version_id: str\n        :param patterns: An array represents the patterns.\n        :type patterns:\n         list[~azure.cognitiveservices.language.luis.authoring.models.PatternRuleUpdateObject]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype:\n         list[~azure.cognitiveservices.language.luis.authoring.models.PatternRuleInfo]\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.language.luis.authoring.models.ErrorResponseException>`", "id": "f43231:c0:m3"}
{"signature": "def add_pattern(<EOL>self, app_id, version_id, pattern=None, intent=None, custom_headers=None, raw=False, **operation_config):", "body": "pattern1 = models.PatternRuleCreateObject(pattern=pattern, intent=intent)<EOL>url = self.add_pattern.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", app_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", version_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(pattern1, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Adds a pattern to a version of the application.\n\n        :param app_id: The application ID.\n        :type app_id: str\n        :param version_id: The version ID.\n        :type version_id: str\n        :param pattern: The pattern text.\n        :type pattern: str\n        :param intent: The intent's name which the pattern belongs to.\n        :type intent: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PatternRuleInfo or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.cognitiveservices.language.luis.authoring.models.PatternRuleInfo\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.language.luis.authoring.models.ErrorResponseException>`", "id": "f43231:c0:m1"}
{"signature": "def update_pattern(<EOL>self, app_id, version_id, pattern_id, pattern, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.update_pattern.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", app_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", version_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", pattern_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(pattern, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Updates a pattern in a version of the application.\n\n        :param app_id: The application ID.\n        :type app_id: str\n        :param version_id: The version ID.\n        :type version_id: str\n        :param pattern_id: The pattern ID.\n        :type pattern_id: str\n        :param pattern: An object representing a pattern.\n        :type pattern:\n         ~azure.cognitiveservices.language.luis.authoring.models.PatternRuleUpdateObject\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PatternRuleInfo or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.cognitiveservices.language.luis.authoring.models.PatternRuleInfo\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.language.luis.authoring.models.ErrorResponseException>`", "id": "f43231:c0:m6"}
{"signature": "def get_status(<EOL>self, app_id, version_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_status.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", app_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", version_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the training status of all models (intents and entities) for the\n        specified LUIS app. You must call the train API to train the LUIS app\n        before you call this API to get training status. \"appID\" specifies the\n        LUIS app ID. \"versionId\" specifies the version number of the LUIS app.\n        For example, \"0.1\".\n\n        :param app_id: The application ID.\n        :type app_id: str\n        :param version_id: The version ID.\n        :type version_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype:\n         list[~azure.cognitiveservices.language.luis.authoring.models.ModelTrainingInfo]\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.language.luis.authoring.models.ErrorResponseException>`", "id": "f43233:c0:m2"}
{"signature": "def remove_from_app(<EOL>self, app_id, azure_account_info_object=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.remove_from_app.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", app_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if azure_account_info_object is not None:<EOL><INDENT>body_content = self._serialize.body(azure_account_info_object, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>body_content = None<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "apps - Removes an assigned LUIS Azure account from an application.\n\n        Removes assigned Azure account from the application.\n\n        :param app_id: The application ID.\n        :type app_id: str\n        :param azure_account_info_object: The Azure account information\n         object.\n        :type azure_account_info_object:\n         ~azure.cognitiveservices.language.luis.authoring.models.AzureAccountInfoObject\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: OperationStatus or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.cognitiveservices.language.luis.authoring.models.OperationStatus\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.language.luis.authoring.models.ErrorResponseException>`", "id": "f43234:c0:m3"}
{"signature": "def list(<EOL>self, app_id, version_id, skip=<NUM_LIT:0>, take=<NUM_LIT:100>, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", app_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", version_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if skip is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", skip, '<STR_LIT:int>', minimum=<NUM_LIT:0>)<EOL><DEDENT>if take is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", take, '<STR_LIT:int>', maximum=<NUM_LIT>, minimum=<NUM_LIT:0>)<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Returns example utterances to be reviewed from a version of the\n        application.\n\n        :param app_id: The application ID.\n        :type app_id: str\n        :param version_id: The version ID.\n        :type version_id: str\n        :param skip: The number of entries to skip. Default value is 0.\n        :type skip: int\n        :param take: The number of entries to return. Maximum page size is\n         500. Default is 100.\n        :type take: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype:\n         list[~azure.cognitiveservices.language.luis.authoring.models.LabeledUtterance]\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.language.luis.authoring.models.ErrorResponseException>`", "id": "f43235:c0:m3"}
{"signature": "def get(<EOL>self, app_id, version_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", app_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", version_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the version information such as date created, last modified date,\n        endpoint URL, count of intents and entities, training and publishing\n        status.\n\n        :param app_id: The application ID.\n        :type app_id: str\n        :param version_id: The version ID.\n        :type version_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VersionInfo or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.cognitiveservices.language.luis.authoring.models.VersionInfo or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.language.luis.authoring.models.ErrorResponseException>`", "id": "f43236:c0:m3"}
{"signature": "def clone(<EOL>self, app_id, version_id, version=None, custom_headers=None, raw=False, **operation_config):", "body": "version_clone_object = models.TaskUpdateObject(version=version)<EOL>url = self.clone.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", app_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", version_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(version_clone_object, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT:str>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates a new version from the selected version.\n\n        :param app_id: The application ID.\n        :type app_id: str\n        :param version_id: The version ID.\n        :type version_id: str\n        :param version: The new version for the cloned model.\n        :type version: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: str or ClientRawResponse if raw=true\n        :rtype: str or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.language.luis.authoring.models.ErrorResponseException>`", "id": "f43236:c0:m1"}
{"signature": "def delete(<EOL>self, app_id, version_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", app_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", version_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Deletes an application version.\n\n        :param app_id: The application ID.\n        :type app_id: str\n        :param version_id: The version ID.\n        :type version_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: OperationStatus or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.cognitiveservices.language.luis.authoring.models.OperationStatus\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.language.luis.authoring.models.ErrorResponseException>`", "id": "f43236:c0:m5"}
{"signature": "def resolve(<EOL>self, app_id, query, timezone_offset=None, verbose=None, staging=None, spell_check=None, bing_spell_check_subscription_key=None, log=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.resolve.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", app_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if timezone_offset is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", timezone_offset, '<STR_LIT:float>')<EOL><DEDENT>if verbose is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", verbose, '<STR_LIT:bool>')<EOL><DEDENT>if staging is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", staging, '<STR_LIT:bool>')<EOL><DEDENT>if spell_check is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", spell_check, '<STR_LIT:bool>')<EOL><DEDENT>if bing_spell_check_subscription_key is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", bing_spell_check_subscription_key, '<STR_LIT:str>')<EOL><DEDENT>if log is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", log, '<STR_LIT:bool>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(query, '<STR_LIT:str>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.APIErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets predictions for a given utterance, in the form of intents and\n        entities. The current maximum query size is 500 characters.\n\n        :param app_id: The LUIS application ID (Guid).\n        :type app_id: str\n        :param query: The utterance to predict.\n        :type query: str\n        :param timezone_offset: The timezone offset for the location of the\n         request.\n        :type timezone_offset: float\n        :param verbose: If true, return all intents instead of just the top\n         scoring intent.\n        :type verbose: bool\n        :param staging: Use the staging endpoint slot.\n        :type staging: bool\n        :param spell_check: Enable spell checking.\n        :type spell_check: bool\n        :param bing_spell_check_subscription_key: The subscription key to use\n         when enabling Bing spell check\n        :type bing_spell_check_subscription_key: str\n        :param log: Log query (default is true)\n        :type log: bool\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: LuisResult or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.cognitiveservices.language.luis.runtime.models.LuisResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`APIErrorException<azure.cognitiveservices.language.luis.runtime.models.APIErrorException>`", "id": "f43258:c0:m1"}
{"signature": "def stop(<EOL>self, resource_group_name, automation_account_name, runbook_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.stop.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", automation_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", runbook_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Stop the test job.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param runbook_name: The runbook name.\n        :type runbook_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43563:c0:m4"}
{"signature": "def get(<EOL>self, resource_group_name, automation_account_name, runbook_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", automation_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", runbook_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieve the test job for the specified runbook.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param runbook_name: The runbook name.\n        :type runbook_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: TestJob or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.automation.models.TestJob or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43563:c0:m2"}
{"signature": "def suspend(<EOL>self, resource_group_name, automation_account_name, runbook_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.suspend.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", automation_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", runbook_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Suspend the test job.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param runbook_name: The runbook name.\n        :type runbook_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43563:c0:m5"}
{"signature": "def delete(<EOL>self, resource_group_name, automation_account_name, connection_type_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", automation_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", connection_type_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Delete the connection type.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param connection_type_name: The name of connection type.\n        :type connection_type_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43564:c0:m1"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.OperationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.OperationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all of the available Automation REST API operations.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Operation\n        :rtype:\n         ~azure.mgmt.automation.models.OperationPaged[~azure.mgmt.automation.models.Operation]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43566:c0:m1"}
{"signature": "def list_by_automation_account(<EOL>self, resource_group_name, automation_account_name, source_control_name, filter=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_automation_account.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", automation_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", source_control_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SourceControlSyncJobPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SourceControlSyncJobPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieve a list of source control sync jobs.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param source_control_name: The source control name.\n        :type source_control_name: str\n        :param filter: The filter to apply on the operation.\n        :type filter: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of SourceControlSyncJob\n        :rtype:\n         ~azure.mgmt.automation.models.SourceControlSyncJobPaged[~azure.mgmt.automation.models.SourceControlSyncJob]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43567:c0:m3"}
{"signature": "def create(<EOL>self, resource_group_name, automation_account_name, source_control_name, source_control_sync_job_id, commit_id, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.SourceControlSyncJobCreateParameters(commit_id=commit_id)<EOL>url = self.create.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", automation_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", source_control_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", source_control_sync_job_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates the sync job for a source control.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param source_control_name: The source control name.\n        :type source_control_name: str\n        :param source_control_sync_job_id: The source control sync job id.\n        :type source_control_sync_job_id: str\n        :param commit_id: The commit id of the source control sync job. If not\n         syncing to a commitId, enter an empty string.\n        :type commit_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SourceControlSyncJob or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.automation.models.SourceControlSyncJob or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43567:c0:m1"}
{"signature": "def get(<EOL>self, resource_group_name, automation_account_name, source_control_name, source_control_sync_job_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", automation_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", source_control_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", source_control_sync_job_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieve the source control sync job identified by job id.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param source_control_name: The source control name.\n        :type source_control_name: str\n        :param source_control_sync_job_id: The source control sync job id.\n        :type source_control_sync_job_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SourceControlSyncJobById or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.automation.models.SourceControlSyncJobById or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43567:c0:m2"}
{"signature": "def undo_edit(<EOL>self, resource_group_name, automation_account_name, runbook_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.undo_edit.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", automation_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", runbook_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Undo draft edit to last known published state identified by runbook\n        name.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param runbook_name: The runbook name.\n        :type runbook_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RunbookDraftUndoEditResult or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.automation.models.RunbookDraftUndoEditResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43569:c0:m5"}
{"signature": "def delete(<EOL>self, resource_group_name, automation_account_name, source_control_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", automation_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", source_control_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Delete the source control.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param source_control_name: The name of source control.\n        :type source_control_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43570:c0:m3"}
{"signature": "def create(<EOL>self, resource_group_name, automation_account_name, compilation_job_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_initial(<EOL>resource_group_name=resource_group_name,<EOL>automation_account_name=automation_account_name,<EOL>compilation_job_name=compilation_job_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates the Dsc compilation job of the configuration.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param compilation_job_name: The the DSC configuration Id.\n        :type compilation_job_name: str\n        :param parameters: The parameters supplied to the create compilation\n         job operation.\n        :type parameters:\n         ~azure.mgmt.automation.models.DscCompilationJobCreateParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns DscCompilationJob or\n         ClientRawResponse<DscCompilationJob> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.automation.models.DscCompilationJob]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.automation.models.DscCompilationJob]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43571:c0:m2"}
{"signature": "def list_by_automation_account(<EOL>self, resource_group_name, automation_account_name, filter=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_automation_account.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", automation_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.DscCompilationJobPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.DscCompilationJobPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieve a list of dsc compilation jobs.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param filter: The filter to apply on the operation.\n        :type filter: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of DscCompilationJob\n        :rtype:\n         ~azure.mgmt.automation.models.DscCompilationJobPaged[~azure.mgmt.automation.models.DscCompilationJob]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43571:c0:m4"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, automation_account_name, certificate_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", automation_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", certificate_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Create a certificate.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param certificate_name: The parameters supplied to the create or\n         update certificate operation.\n        :type certificate_name: str\n        :param parameters: The parameters supplied to the create or update\n         certificate operation.\n        :type parameters:\n         ~azure.mgmt.automation.models.CertificateCreateOrUpdateParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Certificate or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.automation.models.Certificate or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43572:c0:m3"}
{"signature": "def get(<EOL>self, resource_group_name, automation_account_name, certificate_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", automation_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", certificate_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieve the certificate identified by certificate name.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param certificate_name: The name of certificate.\n        :type certificate_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Certificate or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.automation.models.Certificate or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43572:c0:m2"}
{"signature": "def list_by_automation_account(<EOL>self, resource_group_name, automation_account_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_automation_account.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", automation_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ModulePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ModulePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieve a list of python 2 packages.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Module\n        :rtype:\n         ~azure.mgmt.automation.models.ModulePaged[~azure.mgmt.automation.models.Module]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43573:c0:m5"}
{"signature": "def update(<EOL>self, resource_group_name, automation_account_name, package_name, tags=None, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.PythonPackageUpdateParameters(tags=tags)<EOL>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", automation_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", package_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Update the python 2 package identified by package name.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param package_name: The name of python package.\n        :type package_name: str\n        :param tags: Gets or sets the tags attached to the resource.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Module or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.automation.models.Module or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43573:c0:m4"}
{"signature": "def list_by_automation_account(<EOL>self, resource_group_name, automation_account_name, filter=None, skip=None, top=None, inlinecount=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_automation_account.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", automation_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if skip is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", skip, '<STR_LIT:int>')<EOL><DEDENT>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>')<EOL><DEDENT>if inlinecount is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", inlinecount, '<STR_LIT:str>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.DscConfigurationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.DscConfigurationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieve a list of configurations.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param filter: The filter to apply on the operation.\n        :type filter: str\n        :param skip: The number of rows to skip.\n        :type skip: int\n        :param top: The the number of rows to take.\n        :type top: int\n        :param inlinecount: Return total rows.\n        :type inlinecount: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of DscConfiguration\n        :rtype:\n         ~azure.mgmt.automation.models.DscConfigurationPaged[~azure.mgmt.automation.models.DscConfiguration]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43574:c0:m6"}
{"signature": "def delete(<EOL>self, resource_group_name, automation_account_name, configuration_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", automation_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", configuration_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Delete the dsc configuration identified by configuration name.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param configuration_name: The configuration name.\n        :type configuration_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43574:c0:m1"}
{"signature": "def get(<EOL>self, resource_group_name, automation_account_name, configuration_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", automation_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", configuration_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieve the configuration identified by configuration name.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param configuration_name: The configuration name.\n        :type configuration_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DscConfiguration or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.automation.models.DscConfiguration or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43574:c0:m2"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, automation_account_name, configuration_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", automation_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", configuration_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Create the configuration identified by configuration name.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param configuration_name: The create or update parameters for\n         configuration.\n        :type configuration_name: str\n        :param parameters: The create or update parameters for configuration.\n        :type parameters:\n         ~azure.mgmt.automation.models.DscConfigurationCreateOrUpdateParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DscConfiguration or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.automation.models.DscConfiguration or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43574:c0:m3"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, automation_account_name, node_configuration_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>automation_account_name=automation_account_name,<EOL>node_configuration_name=node_configuration_name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Create the node configuration identified by node configuration name.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param node_configuration_name: The Dsc node configuration name.\n        :type node_configuration_name: str\n        :param parameters: The create or update parameters for configuration.\n        :type parameters:\n         ~azure.mgmt.automation.models.DscNodeConfigurationCreateOrUpdateParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns DscNodeConfiguration or\n         ClientRawResponse<DscNodeConfiguration> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.automation.models.DscNodeConfiguration]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.automation.models.DscNodeConfiguration]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43575:c0:m4"}
{"signature": "def list_by_sync_job(<EOL>self, resource_group_name, automation_account_name, source_control_name, source_control_sync_job_id, filter=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_sync_job.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", automation_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", source_control_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", source_control_sync_job_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SourceControlSyncJobStreamPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SourceControlSyncJobStreamPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieve a list of sync job streams identified by sync job id.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param source_control_name: The source control name.\n        :type source_control_name: str\n        :param source_control_sync_job_id: The source control sync job id.\n        :type source_control_sync_job_id: str\n        :param filter: The filter to apply on the operation.\n        :type filter: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of SourceControlSyncJobStream\n        :rtype:\n         ~azure.mgmt.automation.models.SourceControlSyncJobStreamPaged[~azure.mgmt.automation.models.SourceControlSyncJobStream]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43577:c0:m1"}
{"signature": "def list_fields_by_module_and_type(<EOL>self, resource_group_name, automation_account_name, module_name, type_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_fields_by_module_and_type.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", automation_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", module_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", type_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.TypeFieldPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.TypeFieldPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieve a list of fields of a given type identified by module name.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param module_name: The name of module.\n        :type module_name: str\n        :param type_name: The name of type.\n        :type type_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of TypeField\n        :rtype:\n         ~azure.mgmt.automation.models.TypeFieldPaged[~azure.mgmt.automation.models.TypeField]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43578:c0:m1"}
{"signature": "def delete(<EOL>self, resource_group_name, automation_account_name, hybrid_runbook_worker_group_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", automation_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", hybrid_runbook_worker_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Delete a hybrid runbook worker group.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param hybrid_runbook_worker_group_name: The hybrid runbook worker\n         group name\n        :type hybrid_runbook_worker_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43579:c0:m1"}
{"signature": "def create(<EOL>self, resource_group_name, automation_account_name, job_schedule_id, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", automation_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", job_schedule_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Create a job schedule.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param job_schedule_id: The job schedule name.\n        :type job_schedule_id: str\n        :param parameters: The parameters supplied to the create job schedule\n         operation.\n        :type parameters:\n         ~azure.mgmt.automation.models.JobScheduleCreateParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: JobSchedule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.automation.models.JobSchedule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43581:c0:m3"}
{"signature": "def list_by_automation_account(<EOL>self, resource_group_name, automation_account_name, filter=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_automation_account.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", automation_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.JobSchedulePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.JobSchedulePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieve a list of job schedules.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param filter: The filter to apply on the operation.\n        :type filter: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of JobSchedule\n        :rtype:\n         ~azure.mgmt.automation.models.JobSchedulePaged[~azure.mgmt.automation.models.JobSchedule]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43581:c0:m4"}
{"signature": "def list_by_type(<EOL>self, resource_group_name, automation_account_name, module_name, type_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_type.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", automation_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", module_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", type_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.TypeFieldPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.TypeFieldPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieve a list of fields of a given type identified by module name.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param module_name: The name of module.\n        :type module_name: str\n        :param type_name: The name of type.\n        :type type_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of TypeField\n        :rtype:\n         ~azure.mgmt.automation.models.TypeFieldPaged[~azure.mgmt.automation.models.TypeField]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43582:c0:m1"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, automation_account_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", automation_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Create or update automation account.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param parameters: Parameters supplied to the create or update\n         automation account.\n        :type parameters:\n         ~azure.mgmt.automation.models.AutomationAccountCreateOrUpdateParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: AutomationAccount or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.automation.models.AutomationAccount or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43583:c0:m2"}
{"signature": "def list_by_module(<EOL>self, resource_group_name, automation_account_name, module_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_module.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", automation_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", module_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ActivityPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ActivityPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieve a list of activities in the module identified by module name.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param module_name: The name of module.\n        :type module_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Activity\n        :rtype:\n         ~azure.mgmt.automation.models.ActivityPaged[~azure.mgmt.automation.models.Activity]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43584:c0:m2"}
{"signature": "def update(<EOL>self, resource_group_name, automation_account_name, node_id, node_id1=None, properties=None, custom_headers=None, raw=False, **operation_config):", "body": "dsc_node_update_parameters = models.DscNodeUpdateParameters(node_id=node_id1, properties=properties)<EOL>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", automation_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", node_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(dsc_node_update_parameters, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Update the dsc node.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param node_id: Parameters supplied to the update dsc node.\n        :type node_id: str\n        :param node_id1: Gets or sets the id of the dsc node.\n        :type node_id1: str\n        :param properties:\n        :type properties:\n         ~azure.mgmt.automation.models.DscNodeUpdateParametersProperties\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DscNode or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.automation.models.DscNode or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43585:c0:m3"}
{"signature": "def list_by_automation_account(<EOL>self, resource_group_name, automation_account_name, filter=None, skip=None, top=None, inlinecount=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_automation_account.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", automation_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if skip is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", skip, '<STR_LIT:int>')<EOL><DEDENT>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>')<EOL><DEDENT>if inlinecount is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", inlinecount, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.DscNodePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.DscNodePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieve a list of dsc nodes.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param filter: The filter to apply on the operation.\n        :type filter: str\n        :param skip: The number of rows to skip.\n        :type skip: int\n        :param top: The the number of rows to take.\n        :type top: int\n        :param inlinecount: Return total rows.\n        :type inlinecount: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of DscNode\n        :rtype:\n         ~azure.mgmt.automation.models.DscNodePaged[~azure.mgmt.automation.models.DscNode]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43585:c0:m4"}
{"signature": "def start(<EOL>self, resource_group_name, automation_account_name, watcher_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.start.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", automation_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", watcher_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Resume the watcher identified by watcher name.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param watcher_name: The watcher name.\n        :type watcher_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43588:c0:m5"}
{"signature": "def list_by_automation_account(<EOL>self, resource_group_name, automation_account_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_automation_account.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", automation_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ConnectionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ConnectionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieve a list of connections.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Connection\n        :rtype:\n         ~azure.mgmt.automation.models.ConnectionPaged[~azure.mgmt.automation.models.Connection]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43589:c0:m5"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, automation_account_name, connection_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", automation_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", connection_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Create or update a connection.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param connection_name: The parameters supplied to the create or\n         update connection operation.\n        :type connection_name: str\n        :param parameters: The parameters supplied to the create or update\n         connection operation.\n        :type parameters:\n         ~azure.mgmt.automation.models.ConnectionCreateOrUpdateParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Connection or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.automation.models.Connection or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43589:c0:m3"}
{"signature": "def update(<EOL>self, resource_group_name, automation_account_name, connection_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", automation_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", connection_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Update a connection.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param connection_name: The parameters supplied to the update a\n         connection operation.\n        :type connection_name: str\n        :param parameters: The parameters supplied to the update a connection\n         operation.\n        :type parameters:\n         ~azure.mgmt.automation.models.ConnectionUpdateParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Connection or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.automation.models.Connection or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43589:c0:m4"}
{"signature": "def generate_uri(<EOL>self, resource_group_name, automation_account_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.generate_uri.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", automation_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT:str>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Generates a Uri for use in creating a webhook.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: str or ClientRawResponse if raw=true\n        :rtype: str or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43592:c0:m1"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, automation_account_name, credential_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", automation_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", credential_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Create a credential.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param credential_name: The parameters supplied to the create or\n         update credential operation.\n        :type credential_name: str\n        :param parameters: The parameters supplied to the create or update\n         credential operation.\n        :type parameters:\n         ~azure.mgmt.automation.models.CredentialCreateOrUpdateParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Credential or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.automation.models.Credential or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43594:c0:m3"}
{"signature": "def delete(<EOL>self, resource_group_name, automation_account_name, credential_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", automation_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", credential_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Delete the credential.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param credential_name: The name of credential.\n        :type credential_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43594:c0:m1"}
{"signature": "def list_by_automation_account(<EOL>self, resource_group_name, automation_account_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_automation_account.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", automation_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.CredentialPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.CredentialPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieve a list of credentials.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Credential\n        :rtype:\n         ~azure.mgmt.automation.models.CredentialPaged[~azure.mgmt.automation.models.Credential]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f43594:c0:m5"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, automation_account_name, schedule_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", automation_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", schedule_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Create a schedule.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param schedule_name: The schedule name.\n        :type schedule_name: str\n        :param parameters: The parameters supplied to the create or update\n         schedule operation.\n        :type parameters:\n         ~azure.mgmt.automation.models.ScheduleCreateOrUpdateParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Schedule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.automation.models.Schedule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43597:c0:m1"}
{"signature": "def stop(<EOL>self, resource_group_name, automation_account_name, job_name, client_request_id=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.stop.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", automation_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", job_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Stop the job identified by jobName.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param job_name: The job name.\n        :type job_name: str\n        :param client_request_id: Identifies this specific client request.\n        :type client_request_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43599:c0:m4"}
{"signature": "def resume(<EOL>self, resource_group_name, automation_account_name, job_name, client_request_id=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.resume.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", automation_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", job_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Resume the job identified by jobName.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param job_name: The job name.\n        :type job_name: str\n        :param client_request_id: Identifies this specific client request.\n        :type client_request_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43599:c0:m8"}
{"signature": "def create(<EOL>self, resource_group_name, automation_account_name, job_name, parameters, client_request_id=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", automation_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", job_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Create a job of the runbook.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param job_name: The job name.\n        :type job_name: str\n        :param parameters: The parameters supplied to the create job\n         operation.\n        :type parameters: ~azure.mgmt.automation.models.JobCreateParameters\n        :param client_request_id: Identifies this specific client request.\n        :type client_request_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Job or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.automation.models.Job or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43599:c0:m6"}
{"signature": "def list_by_automation_account(<EOL>self, resource_group_name, automation_account_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_automation_account.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", automation_account_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RunbookPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RunbookPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieve a list of runbooks.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Runbook\n        :rtype:\n         ~azure.mgmt.automation.models.RunbookPaged[~azure.mgmt.automation.models.Runbook]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43601:c0:m8"}
{"signature": "def get_by_id(<EOL>self, resource_group_name, automation_account_name, software_update_configuration_run_id, client_request_id=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_by_id.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", automation_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", software_update_configuration_run_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get a single software update configuration Run by Id.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param software_update_configuration_run_id: The Id of the software\n         update configuration run.\n        :type software_update_configuration_run_id: str\n        :param client_request_id: Identifies this specific client request.\n        :type client_request_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SoftwareUpdateConfigurationRun or ClientRawResponse if\n         raw=true\n        :rtype: ~azure.mgmt.automation.models.SoftwareUpdateConfigurationRun\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43603:c0:m1"}
{"signature": "def list(<EOL>self, resource_group_name, automation_account_name, client_request_id=None, filter=None, skip=None, top=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", automation_account_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if skip is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", skip, '<STR_LIT:str>')<EOL><DEDENT>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Return list of software update configuration runs.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param client_request_id: Identifies this specific client request.\n        :type client_request_id: str\n        :param filter: The filter to apply on the operation. You can use the\n         following filters: 'properties/osType', 'properties/status',\n         'properties/startTime', and\n         'properties/softwareUpdateConfiguration/name'\n        :type filter: str\n        :param skip: Number of entries you skip before returning results\n        :type skip: str\n        :param top: Maximum number of entries returned in the results\n         collection\n        :type top: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SoftwareUpdateConfigurationRunListResult or ClientRawResponse\n         if raw=true\n        :rtype:\n         ~azure.mgmt.automation.models.SoftwareUpdateConfigurationRunListResult\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43603:c0:m2"}
{"signature": "def delete(<EOL>self, resource_group_name, automation_account_name, software_update_configuration_name, client_request_id=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", automation_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", software_update_configuration_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "delete a specific software update configuration.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param software_update_configuration_name: The name of the software\n         update configuration to be created.\n        :type software_update_configuration_name: str\n        :param client_request_id: Identifies this specific client request.\n        :type client_request_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43604:c0:m3"}
{"signature": "def create(<EOL>self, resource_group_name, automation_account_name, software_update_configuration_name, parameters, client_request_id=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", automation_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", software_update_configuration_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Create a new software update configuration with the name given in the\n        URI.\n\n        :param resource_group_name: Name of an Azure Resource group.\n        :type resource_group_name: str\n        :param automation_account_name: The name of the automation account.\n        :type automation_account_name: str\n        :param software_update_configuration_name: The name of the software\n         update configuration to be created.\n        :type software_update_configuration_name: str\n        :param parameters: Request body.\n        :type parameters:\n         ~azure.mgmt.automation.models.SoftwareUpdateConfiguration\n        :param client_request_id: Identifies this specific client request.\n        :type client_request_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SoftwareUpdateConfiguration or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.automation.models.SoftwareUpdateConfiguration or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.automation.models.ErrorResponseException>`", "id": "f43604:c0:m1"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, namespace_name, topic_name, subscription_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:6>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", topic_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", subscription_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates a topic subscription.\n\n        :param resource_group_name: Name of the Resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param namespace_name: The namespace name\n        :type namespace_name: str\n        :param topic_name: The topic name.\n        :type topic_name: str\n        :param subscription_name: The subscription name.\n        :type subscription_name: str\n        :param parameters: Parameters supplied to create a subscription\n         resource.\n        :type parameters: ~azure.mgmt.servicebus.models.SBSubscription\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SBSubscription or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.servicebus.models.SBSubscription or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.servicebus.models.ErrorResponseException>`", "id": "f43697:c0:m2"}
{"signature": "def list_keys(<EOL>self, resource_group_name, namespace_name, topic_name, authorization_rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_keys.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:6>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", topic_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", authorization_rule_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the primary and secondary connection strings for the topic.\n\n        :param resource_group_name: Name of the Resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param namespace_name: The namespace name\n        :type namespace_name: str\n        :param topic_name: The topic name.\n        :type topic_name: str\n        :param authorization_rule_name: The authorization rule name.\n        :type authorization_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: AccessKeys or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.servicebus.models.AccessKeys or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.servicebus.models.ErrorResponseException>`", "id": "f43698:c0:m9"}
{"signature": "def migrate(<EOL>self, resource_group_name, namespace_name, target_namespace_type, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.SBNamespaceMigrate(target_namespace_type=target_namespace_type)<EOL>url = self.migrate.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:6>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "This operation Migrate the given namespace to provided name type.\n\n        :param resource_group_name: Name of the Resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param namespace_name: The namespace name\n        :type namespace_name: str\n        :param target_namespace_type: Type of namespaces. Possible values\n         include: 'Messaging', 'NotificationHub', 'Mixed', 'EventHub', 'Relay'\n        :type target_namespace_type: str or\n         ~azure.mgmt.servicebus.models.NameSpaceType\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.servicebus.models.ErrorResponseException>`", "id": "f43700:c0:m16"}
{"signature": "def create_or_update_authorization_rule(<EOL>self, resource_group_name, namespace_name, authorization_rule_name, rights, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.SBAuthorizationRule(rights=rights)<EOL>url = self.create_or_update_authorization_rule.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:6>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", authorization_rule_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or updates an authorization rule for a namespace.\n\n        :param resource_group_name: Name of the Resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param namespace_name: The namespace name\n        :type namespace_name: str\n        :param authorization_rule_name: The authorization rule name.\n        :type authorization_rule_name: str\n        :param rights: The rights associated with the rule.\n        :type rights: list[str or ~azure.mgmt.servicebus.models.AccessRights]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SBAuthorizationRule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.servicebus.models.SBAuthorizationRule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.servicebus.models.ErrorResponseException>`", "id": "f43700:c0:m11"}
{"signature": "def update(<EOL>self, resource_group_name, namespace_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:6>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Updates a service namespace. Once created, this namespace's resource\n        manifest is immutable. This operation is idempotent.\n\n        :param resource_group_name: Name of the Resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param namespace_name: The namespace name\n        :type namespace_name: str\n        :param parameters: Parameters supplied to update a namespace resource.\n        :type parameters:\n         ~azure.mgmt.servicebus.models.SBNamespaceUpdateParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SBNamespace or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.servicebus.models.SBNamespace or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.servicebus.models.ErrorResponseException>`", "id": "f43700:c0:m9"}
{"signature": "def delete_authorization_rule(<EOL>self, resource_group_name, namespace_name, authorization_rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete_authorization_rule.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:6>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", authorization_rule_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes a namespace authorization rule.\n\n        :param resource_group_name: Name of the Resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param namespace_name: The namespace name\n        :type namespace_name: str\n        :param authorization_rule_name: The authorization rule name.\n        :type authorization_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.servicebus.models.ErrorResponseException>`", "id": "f43700:c0:m12"}
{"signature": "def create_and_start_migration(<EOL>self, resource_group_name, namespace_name, target_namespace, post_migration_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_and_start_migration_initial(<EOL>resource_group_name=resource_group_name,<EOL>namespace_name=namespace_name,<EOL>target_namespace=target_namespace,<EOL>post_migration_name=post_migration_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates Migration configuration and starts migration of entities from\n        Standard to Premium namespace.\n\n        :param resource_group_name: Name of the Resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param namespace_name: The namespace name\n        :type namespace_name: str\n        :param target_namespace: Existing premium Namespace ARM Id name which\n         has no entities, will be used for migration\n        :type target_namespace: str\n        :param post_migration_name: Name to access Standard Namespace after\n         migration\n        :type post_migration_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns\n         MigrationConfigProperties or\n         ClientRawResponse<MigrationConfigProperties> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.servicebus.models.MigrationConfigProperties]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.servicebus.models.MigrationConfigProperties]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.servicebus.models.ErrorResponseException>`", "id": "f43703:c0:m3"}
{"signature": "def delete_authorization_rule(<EOL>self, resource_group_name, namespace_name, queue_name, authorization_rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete_authorization_rule.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:6>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", queue_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", authorization_rule_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes a queue authorization rule.\n\n        :param resource_group_name: Name of the Resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param namespace_name: The namespace name\n        :type namespace_name: str\n        :param queue_name: The queue name.\n        :type queue_name: str\n        :param authorization_rule_name: The authorization rule name.\n        :type authorization_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.servicebus.models.ErrorResponseException>`", "id": "f43704:c0:m7"}
{"signature": "def list_by_namespace(<EOL>self, resource_group_name, namespace_name, skip=None, top=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_namespace.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:6>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if skip is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", skip, '<STR_LIT:int>', maximum=<NUM_LIT:1000>, minimum=<NUM_LIT:0>)<EOL><DEDENT>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>', maximum=<NUM_LIT:1000>, minimum=<NUM_LIT:1>)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SBQueuePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SBQueuePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the queues within a namespace.\n\n        :param resource_group_name: Name of the Resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param namespace_name: The namespace name\n        :type namespace_name: str\n        :param skip: Skip is only used if a previous operation returned a\n         partial result. If a previous response contains a nextLink element,\n         the value of the nextLink element will include a skip parameter that\n         specifies a starting point to use for subsequent calls.\n        :type skip: int\n        :param top: May be used to limit the number of results to the most\n         recent N usageDetails.\n        :type top: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of SBQueue\n        :rtype:\n         ~azure.mgmt.servicebus.models.SBQueuePaged[~azure.mgmt.servicebus.models.SBQueue]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.servicebus.models.ErrorResponseException>`", "id": "f43704:c0:m1"}
{"signature": "def regenerate_keys(<EOL>self, resource_group_name, namespace_name, queue_name, authorization_rule_name, key_type, key=None, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.RegenerateAccessKeyParameters(key_type=key_type, key=key)<EOL>url = self.regenerate_keys.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:6>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", queue_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", authorization_rule_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Regenerates the primary or secondary connection strings to the queue.\n\n        :param resource_group_name: Name of the Resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param namespace_name: The namespace name\n        :type namespace_name: str\n        :param queue_name: The queue name.\n        :type queue_name: str\n        :param authorization_rule_name: The authorization rule name.\n        :type authorization_rule_name: str\n        :param key_type: The access key to regenerate. Possible values\n         include: 'PrimaryKey', 'SecondaryKey'\n        :type key_type: str or ~azure.mgmt.servicebus.models.KeyType\n        :param key: Optional, if the key value provided, is reset for KeyType\n         value or autogenerate Key value set for keyType\n        :type key: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: AccessKeys or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.servicebus.models.AccessKeys or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.servicebus.models.ErrorResponseException>`", "id": "f43704:c0:m10"}
{"signature": "def get(<EOL>self, resource_group_name, namespace_name, alias, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:6>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", alias, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves Alias(Disaster Recovery configuration) for primary or\n        secondary namespace.\n\n        :param resource_group_name: Name of the Resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param namespace_name: The namespace name\n        :type namespace_name: str\n        :param alias: The Disaster Recovery configuration name\n        :type alias: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ArmDisasterRecovery or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.servicebus.models.ArmDisasterRecovery or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.servicebus.models.ErrorResponseException>`", "id": "f43706:c0:m5"}
{"signature": "def delete(<EOL>self, resource_group_name, namespace_name, alias, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:6>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", alias, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes an Alias(Disaster Recovery configuration).\n\n        :param resource_group_name: Name of the Resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param namespace_name: The namespace name\n        :type namespace_name: str\n        :param alias: The Disaster Recovery configuration name\n        :type alias: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.servicebus.models.ErrorResponseException>`", "id": "f43706:c0:m4"}
{"signature": "def delete(<EOL>self, resource_group_name, namespace_name, topic_name, subscription_name, rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:6>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", topic_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", subscription_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", rule_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes an existing rule.\n\n        :param resource_group_name: Name of the Resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param namespace_name: The namespace name\n        :type namespace_name: str\n        :param topic_name: The topic name.\n        :type topic_name: str\n        :param subscription_name: The subscription name.\n        :type subscription_name: str\n        :param rule_name: The rule name.\n        :type rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.servicebus.models.ErrorResponseException>`", "id": "f43707:c0:m3"}
{"signature": "def get(<EOL>self, resource_group_name, namespace_name, topic_name, subscription_name, rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:6>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", topic_name, '<STR_LIT:str>', min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", subscription_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", rule_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:1>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves the description for the specified rule.\n\n        :param resource_group_name: Name of the Resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param namespace_name: The namespace name\n        :type namespace_name: str\n        :param topic_name: The topic name.\n        :type topic_name: str\n        :param subscription_name: The subscription name.\n        :type subscription_name: str\n        :param rule_name: The rule name.\n        :type rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Rule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.servicebus.models.Rule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.servicebus.models.ErrorResponseException>`", "id": "f43707:c0:m4"}
{"signature": "def update(<EOL>self, resource_group_name, account_name, sku=None, tags=None, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.CognitiveServicesAccountUpdateParameters(sku=sku, tags=tags)<EOL>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT:64>, min_length=<NUM_LIT:2>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, body_content, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Updates a Cognitive Services account.\n\n        :param resource_group_name: The name of the resource group within the\n         user's subscription.\n        :type resource_group_name: str\n        :param account_name: The name of Cognitive Services account.\n        :type account_name: str\n        :param sku: Gets or sets the SKU of the resource.\n        :type sku: ~azure.mgmt.cognitiveservices.models.Sku\n        :param tags: Gets or sets a list of key value pairs that describe the\n         resource. These tags can be used in viewing and grouping this resource\n         (across resource groups). A maximum of 15 tags can be provided for a\n         resource. Each tag must have a key no greater than 128 characters and\n         value no greater than 256 characters.\n        :type tags: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: CognitiveServicesAccount or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.cognitiveservices.models.CognitiveServicesAccount\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorException<azure.mgmt.cognitiveservices.models.ErrorException>`", "id": "f43757:c0:m2"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.CognitiveServicesAccountPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.CognitiveServicesAccountPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Returns all the resources of a particular type belonging to a\n        subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of CognitiveServicesAccount\n        :rtype:\n         ~azure.mgmt.cognitiveservices.models.CognitiveServicesAccountPaged[~azure.mgmt.cognitiveservices.models.CognitiveServicesAccount]\n        :raises:\n         :class:`ErrorException<azure.mgmt.cognitiveservices.models.ErrorException>`", "id": "f43757:c0:m6"}
{"signature": "def list(<EOL>self, location, skus, kind, type, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.CheckSkuAvailabilityParameter(skus=skus, kind=kind, type=type)<EOL>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, body_content, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Check available SKUs.\n\n        :param location: Resource location.\n        :type location: str\n        :param skus: The SKU of the resource.\n        :type skus: list[str or ~azure.mgmt.cognitiveservices.models.SkuName]\n        :param kind: The Kind of the resource. Possible values include:\n         'Bing.Autosuggest.v7', 'Bing.CustomSearch', 'Bing.Search.v7',\n         'Bing.Speech', 'Bing.SpellCheck.v7', 'ComputerVision',\n         'ContentModerator', 'CustomSpeech', 'CustomVision.Prediction',\n         'CustomVision.Training', 'Emotion', 'Face', 'LUIS', 'QnAMaker',\n         'SpeakerRecognition', 'SpeechTranslation', 'TextAnalytics',\n         'TextTranslation', 'WebLM'\n        :type kind: str or ~azure.mgmt.cognitiveservices.models.Kind\n        :param type: The Type of the resource.\n        :type type: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: CheckSkuAvailabilityResultList or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.cognitiveservices.models.CheckSkuAvailabilityResultList or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f43758:c0:m1"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, front_door_name, routing_rule_name, routing_rule_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>front_door_name=front_door_name,<EOL>routing_rule_name=routing_rule_name,<EOL>routing_rule_parameters=routing_rule_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates a new Routing Rule with the specified Rule name within the\n        specified Front Door.\n\n        :param resource_group_name: Name of the Resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param front_door_name: Name of the Front Door which is globally\n         unique.\n        :type front_door_name: str\n        :param routing_rule_name: Name of the Routing Rule which is unique\n         within the Front Door.\n        :type routing_rule_name: str\n        :param routing_rule_parameters: Routing Rule properties needed to\n         create a new Front Door.\n        :type routing_rule_parameters:\n         ~azure.mgmt.frontdoor.models.RoutingRule\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns RoutingRule or\n         ClientRawResponse<RoutingRule> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.frontdoor.models.RoutingRule]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.frontdoor.models.RoutingRule]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.frontdoor.models.ErrorResponseException>`", "id": "f43837:c0:m4"}
{"signature": "def delete(<EOL>self, resource_group_name, front_door_name, health_probe_settings_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>front_door_name=front_door_name,<EOL>health_probe_settings_name=health_probe_settings_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes an existing HealthProbeSettings with the specified parameters.\n\n        :param resource_group_name: Name of the Resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param front_door_name: Name of the Front Door which is globally\n         unique.\n        :type front_door_name: str\n        :param health_probe_settings_name: Name of the health probe settings\n         which is unique within the Front Door.\n        :type health_probe_settings_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.frontdoor.models.ErrorResponseException>`", "id": "f43839:c0:m6"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, front_door_name, frontend_endpoint_name, frontend_endpoint_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>front_door_name=front_door_name,<EOL>frontend_endpoint_name=frontend_endpoint_name,<EOL>frontend_endpoint_parameters=frontend_endpoint_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates a new frontend endpoint with the specified host name within the\n        specified Front Door.\n\n        :param resource_group_name: Name of the Resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param front_door_name: Name of the Front Door which is globally\n         unique.\n        :type front_door_name: str\n        :param frontend_endpoint_name: Name of the Frontend endpoint which is\n         unique within the Front Door.\n        :type frontend_endpoint_name: str\n        :param frontend_endpoint_parameters: Frontend endpoint properties\n         needed to create a new endpoint.\n        :type frontend_endpoint_parameters:\n         ~azure.mgmt.frontdoor.models.FrontendEndpoint\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns FrontendEndpoint or\n         ClientRawResponse<FrontendEndpoint> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.frontdoor.models.FrontendEndpoint]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.frontdoor.models.FrontendEndpoint]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.frontdoor.models.ErrorResponseException>`", "id": "f43841:c0:m4"}
{"signature": "def enable_https(<EOL>self, resource_group_name, front_door_name, frontend_endpoint_name, custom_https_configuration, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._enable_https_initial(<EOL>resource_group_name=resource_group_name,<EOL>front_door_name=front_door_name,<EOL>frontend_endpoint_name=frontend_endpoint_name,<EOL>custom_https_configuration=custom_https_configuration,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Enables a frontendEndpoint for HTTPS traffic.\n\n        :param resource_group_name: Name of the Resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param front_door_name: Name of the Front Door which is globally\n         unique.\n        :type front_door_name: str\n        :param frontend_endpoint_name: Name of the Frontend endpoint which is\n         unique within the Front Door.\n        :type frontend_endpoint_name: str\n        :param custom_https_configuration: The configuration specifying how to\n         enable HTTPS\n        :type custom_https_configuration:\n         ~azure.mgmt.frontdoor.models.CustomHttpsConfiguration\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.frontdoor.models.ErrorResponseException>`", "id": "f43841:c0:m8"}
{"signature": "def disable_https(<EOL>self, resource_group_name, front_door_name, frontend_endpoint_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._disable_https_initial(<EOL>resource_group_name=resource_group_name,<EOL>front_door_name=front_door_name,<EOL>frontend_endpoint_name=frontend_endpoint_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Disables a frontendEndpoint for HTTPS traffic.\n\n        :param resource_group_name: Name of the Resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param front_door_name: Name of the Front Door which is globally\n         unique.\n        :type front_door_name: str\n        :param frontend_endpoint_name: Name of the Frontend endpoint which is\n         unique within the Front Door.\n        :type frontend_endpoint_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.frontdoor.models.ErrorResponseException>`", "id": "f43841:c0:m10"}
{"signature": "def delete(<EOL>self, resource_group_name, policy_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>policy_name=policy_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes Policy.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param policy_name: The name of the resource group.\n        :type policy_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f43843:c0:m5"}
{"signature": "def get(<EOL>self, resource_group_name, front_door_name, backend_pool_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", front_door_name, '<STR_LIT:str>', max_length=<NUM_LIT:64>, min_length=<NUM_LIT:5>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", backend_pool_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a Backend Pool with the specified Pool name within the specified\n        Front Door.\n\n        :param resource_group_name: Name of the Resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param front_door_name: Name of the Front Door which is globally\n         unique.\n        :type front_door_name: str\n        :param backend_pool_name: Name of the Backend Pool which is unique\n         within the Front Door.\n        :type backend_pool_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: BackendPool or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.frontdoor.models.BackendPool or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.frontdoor.models.ErrorResponseException>`", "id": "f43844:c0:m2"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.FrontDoorPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.FrontDoorPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all of the Front Doors within a resource group under a\n        subscription.\n\n        :param resource_group_name: Name of the Resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of FrontDoor\n        :rtype:\n         ~azure.mgmt.frontdoor.models.FrontDoorPaged[~azure.mgmt.frontdoor.models.FrontDoor]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.frontdoor.models.ErrorResponseException>`", "id": "f43845:c0:m2"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, front_door_name, front_door_parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>front_door_name=front_door_name,<EOL>front_door_parameters=front_door_parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates a new Front Door with a Front Door name under the specified\n        subscription and resource group.\n\n        :param resource_group_name: Name of the Resource group within the\n         Azure subscription.\n        :type resource_group_name: str\n        :param front_door_name: Name of the Front Door which is globally\n         unique.\n        :type front_door_name: str\n        :param front_door_parameters: Front Door properties needed to create a\n         new Front Door.\n        :type front_door_parameters: ~azure.mgmt.frontdoor.models.FrontDoor\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns FrontDoor or\n         ClientRawResponse<FrontDoor> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.frontdoor.models.FrontDoor]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.frontdoor.models.FrontDoor]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.frontdoor.models.ErrorResponseException>`", "id": "f43845:c0:m5"}
{"signature": "def list_metrics(<EOL>self, resource_group_name, account_name, filter, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_metrics.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:3>)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.MetricPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.MetricPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves the metrics determined by the given filter for the given\n        database account.\n\n        :param resource_group_name: Name of an Azure resource group.\n        :type resource_group_name: str\n        :param account_name: Cosmos DB database account name.\n        :type account_name: str\n        :param filter: An OData filter expression that describes a subset of\n         metrics to return. The parameters that can be filtered are name.value\n         (name of the metric, can have an or of multiple names), startTime,\n         endTime, and timeGrain. The supported operator is eq.\n        :type filter: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Metric\n        :rtype:\n         ~azure.mgmt.cosmosdb.models.MetricPaged[~azure.mgmt.cosmosdb.models.Metric]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f43918:c0:m23"}
{"signature": "def online_region(<EOL>self, resource_group_name, account_name, region, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._online_region_initial(<EOL>resource_group_name=resource_group_name,<EOL>account_name=account_name,<EOL>region=region,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Online the specified region for the specified Azure Cosmos DB database\n        account.\n\n        :param resource_group_name: Name of an Azure resource group.\n        :type resource_group_name: str\n        :param account_name: Cosmos DB database account name.\n        :type account_name: str\n        :param region: Cosmos DB region, with spaces between words and each\n         word capitalized.\n        :type region: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises:\n         :class:`ErrorResponseException<azure.mgmt.cosmosdb.models.ErrorResponseException>`", "id": "f43918:c0:m17"}
{"signature": "def patch(<EOL>self, resource_group_name, account_name, tags=None, capabilities=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._patch_initial(<EOL>resource_group_name=resource_group_name,<EOL>account_name=account_name,<EOL>tags=tags,<EOL>capabilities=capabilities,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Patches the properties of an existing Azure Cosmos DB database account.\n\n        :param resource_group_name: Name of an Azure resource group.\n        :type resource_group_name: str\n        :param account_name: Cosmos DB database account name.\n        :type account_name: str\n        :param tags:\n        :type tags: dict[str, str]\n        :param capabilities: List of Cosmos DB capabilities for the account\n        :type capabilities: list[~azure.mgmt.cosmosdb.models.Capability]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns DatabaseAccount or\n         ClientRawResponse<DatabaseAccount> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.cosmosdb.models.DatabaseAccount]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.cosmosdb.models.DatabaseAccount]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f43918:c0:m3"}
{"signature": "def delete(<EOL>self, resource_group_name, account_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>account_name=account_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Deletes an existing Azure Cosmos DB database account.\n\n        :param resource_group_name: Name of an Azure resource group.\n        :type resource_group_name: str\n        :param account_name: Cosmos DB database account name.\n        :type account_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f43918:c0:m7"}
{"signature": "def failover_priority_change(<EOL>self, resource_group_name, account_name, failover_policies, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._failover_priority_change_initial(<EOL>resource_group_name=resource_group_name,<EOL>account_name=account_name,<EOL>failover_policies=failover_policies,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Changes the failover priority for the Azure Cosmos DB database account.\n        A failover priority of 0 indicates a write region. The maximum value\n        for a failover priority = (total number of regions - 1). Failover\n        priority values must be unique for each of the regions in which the\n        database account exists.\n\n        :param resource_group_name: Name of an Azure resource group.\n        :type resource_group_name: str\n        :param account_name: Cosmos DB database account name.\n        :type account_name: str\n        :param failover_policies: List of failover policies.\n        :type failover_policies:\n         list[~azure.mgmt.cosmosdb.models.FailoverPolicy]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f43918:c0:m9"}
{"signature": "def list_metric_definitions(<EOL>self, resource_group_name, account_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_metric_definitions.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:3>)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.MetricDefinitionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.MetricDefinitionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves metric defintions for the given database account.\n\n        :param resource_group_name: Name of an Azure resource group.\n        :type resource_group_name: str\n        :param account_name: Cosmos DB database account name.\n        :type account_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of MetricDefinition\n        :rtype:\n         ~azure.mgmt.cosmosdb.models.MetricDefinitionPaged[~azure.mgmt.cosmosdb.models.MetricDefinition]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f43918:c0:m25"}
{"signature": "def list_read_only_keys(<EOL>self, resource_group_name, account_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_read_only_keys.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:3>)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists the read-only access keys for the specified Azure Cosmos DB\n        database account.\n\n        :param resource_group_name: Name of an Azure resource group.\n        :type resource_group_name: str\n        :param account_name: Cosmos DB database account name.\n        :type account_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DatabaseAccountListReadOnlyKeysResult or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.cosmosdb.models.DatabaseAccountListReadOnlyKeysResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f43918:c0:m19"}
{"signature": "def list_metrics(<EOL>self, resource_group_name, account_name, database_rid, collection_rid, partition_key_range_id, filter, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_metrics.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:3>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", database_rid, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", collection_rid, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", partition_key_range_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PartitionMetricPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PartitionMetricPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves the metrics determined by the given filter for the given\n        partition key range id.\n\n        :param resource_group_name: Name of an Azure resource group.\n        :type resource_group_name: str\n        :param account_name: Cosmos DB database account name.\n        :type account_name: str\n        :param database_rid: Cosmos DB database rid.\n        :type database_rid: str\n        :param collection_rid: Cosmos DB collection rid.\n        :type collection_rid: str\n        :param partition_key_range_id: Partition Key Range Id for which to get\n         data.\n        :type partition_key_range_id: str\n        :param filter: An OData filter expression that describes a subset of\n         metrics to return. The parameters that can be filtered are name.value\n         (name of the metric, can have an or of multiple names), startTime,\n         endTime, and timeGrain. The supported operator is eq.\n        :type filter: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PartitionMetric\n        :rtype:\n         ~azure.mgmt.cosmosdb.models.PartitionMetricPaged[~azure.mgmt.cosmosdb.models.PartitionMetric]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f43920:c0:m1"}
{"signature": "def list_usages(<EOL>self, resource_group_name, account_name, database_rid, collection_rid, filter=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_usages.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:3>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", database_rid, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", collection_rid, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PartitionUsagePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PartitionUsagePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves the usages (most recent storage data) for the given\n        collection, split by partition.\n\n        :param resource_group_name: Name of an Azure resource group.\n        :type resource_group_name: str\n        :param account_name: Cosmos DB database account name.\n        :type account_name: str\n        :param database_rid: Cosmos DB database rid.\n        :type database_rid: str\n        :param collection_rid: Cosmos DB collection rid.\n        :type collection_rid: str\n        :param filter: An OData filter expression that describes a subset of\n         usages to return. The supported parameter is name.value (name of the\n         metric, can have an or of multiple names).\n        :type filter: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PartitionUsage\n        :rtype:\n         ~azure.mgmt.cosmosdb.models.PartitionUsagePaged[~azure.mgmt.cosmosdb.models.PartitionUsage]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f43921:c0:m2"}
{"signature": "def list_metrics(<EOL>self, resource_group_name, account_name, region, database_rid, collection_rid, filter, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_metrics.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:3>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", region, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", database_rid, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", collection_rid, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.MetricPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.MetricPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves the metrics determined by the given filter for the given\n        database account, collection and region.\n\n        :param resource_group_name: Name of an Azure resource group.\n        :type resource_group_name: str\n        :param account_name: Cosmos DB database account name.\n        :type account_name: str\n        :param region: Cosmos DB region, with spaces between words and each\n         word capitalized.\n        :type region: str\n        :param database_rid: Cosmos DB database rid.\n        :type database_rid: str\n        :param collection_rid: Cosmos DB collection rid.\n        :type collection_rid: str\n        :param filter: An OData filter expression that describes a subset of\n         metrics to return. The parameters that can be filtered are name.value\n         (name of the metric, can have an or of multiple names), startTime,\n         endTime, and timeGrain. The supported operator is eq.\n        :type filter: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Metric\n        :rtype:\n         ~azure.mgmt.cosmosdb.models.MetricPaged[~azure.mgmt.cosmosdb.models.Metric]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f43922:c0:m1"}
{"signature": "def list_metrics(<EOL>self, resource_group_name, account_name, database_rid, filter, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_metrics.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:3>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", database_rid, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.MetricPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.MetricPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves the metrics determined by the given filter for the given\n        database account and database.\n\n        :param resource_group_name: Name of an Azure resource group.\n        :type resource_group_name: str\n        :param account_name: Cosmos DB database account name.\n        :type account_name: str\n        :param database_rid: Cosmos DB database rid.\n        :type database_rid: str\n        :param filter: An OData filter expression that describes a subset of\n         metrics to return. The parameters that can be filtered are name.value\n         (name of the metric, can have an or of multiple names), startTime,\n         endTime, and timeGrain. The supported operator is eq.\n        :type filter: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Metric\n        :rtype:\n         ~azure.mgmt.cosmosdb.models.MetricPaged[~azure.mgmt.cosmosdb.models.Metric]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f43928:c0:m1"}
{"signature": "def list_metrics(<EOL>self, resource_group_name, account_name, database_rid, collection_rid, filter, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_metrics.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:3>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", database_rid, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", collection_rid, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.MetricPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.MetricPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves the metrics determined by the given filter for the given\n        database account and collection.\n\n        :param resource_group_name: Name of an Azure resource group.\n        :type resource_group_name: str\n        :param account_name: Cosmos DB database account name.\n        :type account_name: str\n        :param database_rid: Cosmos DB database rid.\n        :type database_rid: str\n        :param collection_rid: Cosmos DB collection rid.\n        :type collection_rid: str\n        :param filter: An OData filter expression that describes a subset of\n         metrics to return. The parameters that can be filtered are name.value\n         (name of the metric, can have an or of multiple names), startTime,\n         endTime, and timeGrain. The supported operator is eq.\n        :type filter: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Metric\n        :rtype:\n         ~azure.mgmt.cosmosdb.models.MetricPaged[~azure.mgmt.cosmosdb.models.Metric]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f43929:c0:m1"}
{"signature": "def list_metrics(<EOL>self, resource_group_name, account_name, region, database_rid, collection_rid, filter, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_metrics.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:3>),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", region, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", database_rid, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", collection_rid, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PartitionMetricPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PartitionMetricPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves the metrics determined by the given filter for the given\n        collection and region, split by partition.\n\n        :param resource_group_name: Name of an Azure resource group.\n        :type resource_group_name: str\n        :param account_name: Cosmos DB database account name.\n        :type account_name: str\n        :param region: Cosmos DB region, with spaces between words and each\n         word capitalized.\n        :type region: str\n        :param database_rid: Cosmos DB database rid.\n        :type database_rid: str\n        :param collection_rid: Cosmos DB collection rid.\n        :type collection_rid: str\n        :param filter: An OData filter expression that describes a subset of\n         metrics to return. The parameters that can be filtered are name.value\n         (name of the metric, can have an or of multiple names), startTime,\n         endTime, and timeGrain. The supported operator is eq.\n        :type filter: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PartitionMetric\n        :rtype:\n         ~azure.mgmt.cosmosdb.models.PartitionMetricPaged[~azure.mgmt.cosmosdb.models.PartitionMetric]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f43930:c0:m1"}
{"signature": "def list_by_subscription(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_subscription.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SignalRResourcePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SignalRResourcePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Handles requests to list all resources in a subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of SignalRResource\n        :rtype:\n         ~azure.mgmt.signalr.models.SignalRResourcePaged[~azure.mgmt.signalr.models.SignalRResource]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f43979:c0:m2"}
{"signature": "def list_keys(<EOL>self, resource_group_name, resource_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_keys.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the access keys of the SignalR resource.\n\n        :param resource_group_name: The name of the resource group that\n         contains the resource. You can obtain this value from the Azure\n         Resource Manager API or the portal.\n        :type resource_group_name: str\n        :param resource_name: The name of the SignalR resource.\n        :type resource_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SignalRKeys or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.signalr.models.SignalRKeys or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f43979:c0:m4"}
{"signature": "def list(<EOL>self, location, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url(\"<STR_LIT:location>\", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SignalRUsagePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SignalRUsagePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List usage quotas for Azure SignalR service by location.\n\n        :param location: the location like \"eastus\"\n        :type location: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of SignalRUsage\n        :rtype:\n         ~azure.mgmt.signalr.models.SignalRUsagePaged[~azure.mgmt.signalr.models.SignalRUsage]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f43980:c0:m1"}
{"signature": "def update(<EOL>self, resource_group_name, resource_name, location=None, tags=None, sku=None, kind=None, etag=None, properties=None, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.Bot(location=location, tags=tags, sku=sku, kind=kind, etag=etag, properties=properties)<EOL>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT:64>, min_length=<NUM_LIT:2>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_name, '<STR_LIT:str>', max_length=<NUM_LIT:64>, min_length=<NUM_LIT:2>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Updates a Bot Service.\n\n        :param resource_group_name: The name of the Bot resource group in the\n         user subscription.\n        :type resource_group_name: str\n        :param resource_name: The name of the Bot resource.\n        :type resource_name: str\n        :param location: Specifies the location of the resource.\n        :type location: str\n        :param tags: Contains resource tags defined as key/value pairs.\n        :type tags: dict[str, str]\n        :param sku: Gets or sets the SKU of the resource.\n        :type sku: ~azure.mgmt.botservice.models.Sku\n        :param kind: Required. Gets or sets the Kind of the resource. Possible\n         values include: 'sdk', 'designer', 'bot', 'function'\n        :type kind: str or ~azure.mgmt.botservice.models.Kind\n        :param etag: Entity Tag\n        :type etag: str\n        :param properties: The set of properties specific to bot resource\n        :type properties: ~azure.mgmt.botservice.models.BotProperties\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Bot or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.botservice.models.Bot or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorException<azure.mgmt.botservice.models.ErrorException>`", "id": "f44111:c0:m2"}
{"signature": "def get(<EOL>self, resource_group_name, resource_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT:64>, min_length=<NUM_LIT:2>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_name, '<STR_LIT:str>', max_length=<NUM_LIT:64>, min_length=<NUM_LIT:2>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Returns a BotService specified by the parameters.\n\n        :param resource_group_name: The name of the Bot resource group in the\n         user subscription.\n        :type resource_group_name: str\n        :param resource_name: The name of the Bot resource.\n        :type resource_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Bot or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.botservice.models.Bot or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorException<azure.mgmt.botservice.models.ErrorException>`", "id": "f44111:c0:m4"}
{"signature": "def list_with_keys(<EOL>self, resource_group_name, resource_name, channel_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_with_keys.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT:64>, min_length=<NUM_LIT:2>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_name, '<STR_LIT:str>', max_length=<NUM_LIT:64>, min_length=<NUM_LIT:2>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", channel_name, '<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists a Channel registration for a Bot Service including secrets.\n\n        :param resource_group_name: The name of the Bot resource group in the\n         user subscription.\n        :type resource_group_name: str\n        :param resource_name: The name of the Bot resource.\n        :type resource_name: str\n        :param channel_name: The name of the Channel resource. Possible values\n         include: 'FacebookChannel', 'EmailChannel', 'KikChannel',\n         'TelegramChannel', 'SlackChannel', 'MsTeamsChannel', 'SkypeChannel',\n         'WebChatChannel', 'DirectLineChannel', 'SmsChannel'\n        :type channel_name: str or ~azure.mgmt.botservice.models.ChannelName\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: BotChannel or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.botservice.models.BotChannel or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorException<azure.mgmt.botservice.models.ErrorException>`", "id": "f44112:c0:m5"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, resource_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT:64>, min_length=<NUM_LIT:2>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_name, '<STR_LIT:str>', max_length=<NUM_LIT:64>, min_length=<NUM_LIT:2>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.BotChannelPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.BotChannelPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Returns all the Channel registrations of a particular BotService\n        resource.\n\n        :param resource_group_name: The name of the Bot resource group in the\n         user subscription.\n        :type resource_group_name: str\n        :param resource_name: The name of the Bot resource.\n        :type resource_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of BotChannel\n        :rtype:\n         ~azure.mgmt.botservice.models.BotChannelPaged[~azure.mgmt.botservice.models.BotChannel]\n        :raises:\n         :class:`ErrorException<azure.mgmt.botservice.models.ErrorException>`", "id": "f44112:c0:m6"}
{"signature": "def update(<EOL>self, resource_group_name, resource_name, connection_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT:64>, min_length=<NUM_LIT:2>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_name, '<STR_LIT:str>', max_length=<NUM_LIT:64>, min_length=<NUM_LIT:2>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", connection_name, '<STR_LIT:str>', max_length=<NUM_LIT:64>, min_length=<NUM_LIT:2>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Updates a Connection Setting registration for a Bot Service.\n\n        :param resource_group_name: The name of the Bot resource group in the\n         user subscription.\n        :type resource_group_name: str\n        :param resource_name: The name of the Bot resource.\n        :type resource_name: str\n        :param connection_name: The name of the Bot Service Connection Setting\n         resource\n        :type connection_name: str\n        :param parameters: The parameters to provide for updating the\n         Connection Setting.\n        :type parameters: ~azure.mgmt.botservice.models.ConnectionSetting\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ConnectionSetting or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.botservice.models.ConnectionSetting or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorException<azure.mgmt.botservice.models.ErrorException>`", "id": "f44115:c0:m4"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, account_name, firewall_rule_name, start_ip_address, end_ip_address, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.CreateOrUpdateFirewallRuleParameters(start_ip_address=start_ip_address, end_ip_address=end_ip_address)<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", firewall_rule_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, body_content, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or updates the specified firewall rule. During update, the\n        firewall rule with the specified name will be replaced with this new\n        firewall rule.\n\n        :param resource_group_name: The name of the Azure resource group.\n        :type resource_group_name: str\n        :param account_name: The name of the Data Lake Analytics account.\n        :type account_name: str\n        :param firewall_rule_name: The name of the firewall rule to create or\n         update.\n        :type firewall_rule_name: str\n        :param start_ip_address: The start IP address for the firewall rule.\n         This can be either ipv4 or ipv6. Start and End should be in the same\n         protocol.\n        :type start_ip_address: str\n        :param end_ip_address: The end IP address for the firewall rule. This\n         can be either ipv4 or ipv6. Start and End should be in the same\n         protocol.\n        :type end_ip_address: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: FirewallRule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.datalake.analytics.account.models.FirewallRule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44191:c0:m2"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all of the available Data Lake Analytics REST API operations.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: OperationListResult or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.datalake.analytics.account.models.OperationListResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44192:c0:m1"}
{"signature": "def get(<EOL>self, resource_group_name, account_name, compute_policy_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", compute_policy_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified Data Lake Analytics compute policy.\n\n        :param resource_group_name: The name of the Azure resource group.\n        :type resource_group_name: str\n        :param account_name: The name of the Data Lake Analytics account.\n        :type account_name: str\n        :param compute_policy_name: The name of the compute policy to\n         retrieve.\n        :type compute_policy_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ComputePolicy or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.datalake.analytics.account.models.ComputePolicy or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44193:c0:m3"}
{"signature": "def delete(<EOL>self, resource_group_name, account_name, compute_policy_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", compute_policy_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes the specified compute policy from the specified Data Lake\n        Analytics account.\n\n        :param resource_group_name: The name of the Azure resource group.\n        :type resource_group_name: str\n        :param account_name: The name of the Data Lake Analytics account.\n        :type account_name: str\n        :param compute_policy_name: The name of the compute policy to delete.\n        :type compute_policy_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44193:c0:m5"}
{"signature": "def update(<EOL>self, resource_group_name, account_name, storage_account_name, access_key=None, suffix=None, custom_headers=None, raw=False, **operation_config):", "body": "parameters = None<EOL>if access_key is not None or suffix is not None:<EOL><INDENT>parameters = models.UpdateStorageAccountParameters(access_key=access_key, suffix=suffix)<EOL><DEDENT>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", storage_account_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if parameters is not None:<EOL><INDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL><DEDENT>else:<EOL><INDENT>body_content = None<EOL><DEDENT>request = self._client.patch(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, body_content, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Updates the Data Lake Analytics account to replace Azure Storage blob\n        account details, such as the access key and/or suffix.\n\n        :param resource_group_name: The name of the Azure resource group.\n        :type resource_group_name: str\n        :param account_name: The name of the Data Lake Analytics account.\n        :type account_name: str\n        :param storage_account_name: The Azure Storage account to modify\n        :type storage_account_name: str\n        :param access_key: The updated access key associated with this Azure\n         Storage account that will be used to connect to it.\n        :type access_key: str\n        :param suffix: The optional suffix for the storage account.\n        :type suffix: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44197:c0:m4"}
{"signature": "def get_storage_container(<EOL>self, resource_group_name, account_name, storage_account_name, container_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_storage_container.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", storage_account_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", container_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the specified Azure Storage container associated with the given\n        Data Lake Analytics and Azure Storage accounts.\n\n        :param resource_group_name: The name of the Azure resource group.\n        :type resource_group_name: str\n        :param account_name: The name of the Data Lake Analytics account.\n        :type account_name: str\n        :param storage_account_name: The name of the Azure storage account\n         from which to retrieve the blob container.\n        :type storage_account_name: str\n        :param container_name: The name of the Azure storage container to\n         retrieve\n        :type container_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: StorageContainer or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.datalake.analytics.account.models.StorageContainer\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44197:c0:m7"}
{"signature": "def list_by_account(<EOL>self, resource_group_name, account_name, filter=None, top=None, skip=None, select=None, orderby=None, count=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_account.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>', minimum=<NUM_LIT:1>)<EOL><DEDENT>if skip is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", skip, '<STR_LIT:int>', minimum=<NUM_LIT:1>)<EOL><DEDENT>if select is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", select, '<STR_LIT:str>')<EOL><DEDENT>if orderby is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", orderby, '<STR_LIT:str>')<EOL><DEDENT>if count is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT:count>\", count, '<STR_LIT:bool>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.DataLakeStoreAccountInformationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.DataLakeStoreAccountInformationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the first page of Data Lake Store accounts linked to the specified\n        Data Lake Analytics account. The response includes a link to the next\n        page, if any.\n\n        :param resource_group_name: The name of the Azure resource group.\n        :type resource_group_name: str\n        :param account_name: The name of the Data Lake Analytics account.\n        :type account_name: str\n        :param filter: OData filter. Optional.\n        :type filter: str\n        :param top: The number of items to return. Optional.\n        :type top: int\n        :param skip: The number of items to skip over before returning\n         elements. Optional.\n        :type skip: int\n        :param select: OData Select statement. Limits the properties on each\n         entry to just those requested, e.g.\n         Categories?$select=CategoryName,Description. Optional.\n        :type select: str\n        :param orderby: OrderBy clause. One or more comma-separated\n         expressions with an optional \"asc\" (the default) or \"desc\" depending\n         on the order you'd like the values sorted, e.g.\n         Categories?$orderby=CategoryName desc. Optional.\n        :type orderby: str\n        :param count: The Boolean value of true or false to request a count of\n         the matching resources included with the resources in the response,\n         e.g. Categories?$count=true. Optional.\n        :type count: bool\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of DataLakeStoreAccountInformation\n        :rtype:\n         ~azure.mgmt.datalake.analytics.account.models.DataLakeStoreAccountInformationPaged[~azure.mgmt.datalake.analytics.account.models.DataLakeStoreAccountInformation]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44198:c0:m1"}
{"signature": "def get_database(<EOL>self, account_name, database_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_database.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.adla_catalog_dns_suffix, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", database_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves the specified database from the Data Lake Analytics catalog.\n\n        :param account_name: The Azure Data Lake Analytics account upon which\n         to execute catalog operations.\n        :type account_name: str\n        :param database_name: The name of the database.\n        :type database_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: USqlDatabase or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.datalake.analytics.catalog.models.USqlDatabase or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44293:c0:m44"}
{"signature": "def revoke_acl_from_database(<EOL>self, account_name, database_name, ace_type, principal_id, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.AclDeleteParameters(ace_type=ace_type, principal_id=principal_id)<EOL>op = \"<STR_LIT>\"<EOL>url = self.revoke_acl_from_database.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.adla_catalog_dns_suffix, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", database_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", op, '<STR_LIT:str>')<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, body_content, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Revokes an access control list (ACL) entry for the database from the\n        Data Lake Analytics catalog.\n\n        :param account_name: The Azure Data Lake Analytics account upon which\n         to execute catalog operations.\n        :type account_name: str\n        :param database_name: The name of the database.\n        :type database_name: str\n        :param ace_type: the access control list (ACL) entry type. UserObj and\n         GroupObj denote the owning user and group, respectively. Possible\n         values include: 'UserObj', 'GroupObj', 'Other', 'User', 'Group'\n        :type ace_type: str or\n         ~azure.mgmt.datalake.analytics.catalog.models.AclType\n        :param principal_id: the Azure AD object ID of the user or group being\n         specified in the access control list (ACL) entry.\n        :type principal_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44293:c0:m49"}
{"signature": "def grant_acl_to_database(<EOL>self, account_name, database_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "op = \"<STR_LIT>\"<EOL>url = self.grant_acl_to_database.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.adla_catalog_dns_suffix, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", database_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", op, '<STR_LIT:str>')<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, body_content, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Grants an access control list (ACL) entry to the database from the Data\n        Lake Analytics catalog.\n\n        :param account_name: The Azure Data Lake Analytics account upon which\n         to execute catalog operations.\n        :type account_name: str\n        :param database_name: The name of the database.\n        :type database_name: str\n        :param parameters: Parameters supplied to create or update an access\n         control list (ACL) entry for a database.\n        :type parameters:\n         ~azure.mgmt.datalake.analytics.catalog.models.AclCreateOrUpdateParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44293:c0:m47"}
{"signature": "def list_assemblies(<EOL>self, account_name, database_name, filter=None, top=None, skip=None, select=None, orderby=None, count=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_assemblies.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.adla_catalog_dns_suffix, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", database_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>', minimum=<NUM_LIT:1>)<EOL><DEDENT>if skip is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", skip, '<STR_LIT:int>', minimum=<NUM_LIT:1>)<EOL><DEDENT>if select is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", select, '<STR_LIT:str>')<EOL><DEDENT>if orderby is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", orderby, '<STR_LIT:str>')<EOL><DEDENT>if count is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT:count>\", count, '<STR_LIT:bool>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.USqlAssemblyClrPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.USqlAssemblyClrPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves the list of assemblies from the Data Lake Analytics catalog.\n\n        :param account_name: The Azure Data Lake Analytics account upon which\n         to execute catalog operations.\n        :type account_name: str\n        :param database_name: The name of the database containing the\n         assembly.\n        :type database_name: str\n        :param filter: OData filter. Optional.\n        :type filter: str\n        :param top: The number of items to return. Optional.\n        :type top: int\n        :param skip: The number of items to skip over before returning\n         elements. Optional.\n        :type skip: int\n        :param select: OData Select statement. Limits the properties on each\n         entry to just those requested, e.g.\n         Categories?$select=CategoryName,Description. Optional.\n        :type select: str\n        :param orderby: OrderBy clause. One or more comma-separated\n         expressions with an optional \"asc\" (the default) or \"desc\" depending\n         on the order you'd like the values sorted, e.g.\n         Categories?$orderby=CategoryName desc. Optional.\n        :type orderby: str\n        :param count: The Boolean value of true or false to request a count of\n         the matching resources included with the resources in the response,\n         e.g. Categories?$count=true. Optional.\n        :type count: bool\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of USqlAssemblyClr\n        :rtype:\n         ~azure.mgmt.datalake.analytics.catalog.models.USqlAssemblyClrPaged[~azure.mgmt.datalake.analytics.catalog.models.USqlAssemblyClr]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44293:c0:m35"}
{"signature": "def list_types(<EOL>self, account_name, database_name, schema_name, filter=None, top=None, skip=None, select=None, orderby=None, count=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_types.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.adla_catalog_dns_suffix, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", database_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", schema_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>', minimum=<NUM_LIT:1>)<EOL><DEDENT>if skip is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", skip, '<STR_LIT:int>', minimum=<NUM_LIT:1>)<EOL><DEDENT>if select is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", select, '<STR_LIT:str>')<EOL><DEDENT>if orderby is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", orderby, '<STR_LIT:str>')<EOL><DEDENT>if count is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT:count>\", count, '<STR_LIT:bool>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.USqlTypePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.USqlTypePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves the list of types within the specified database and schema\n        from the Data Lake Analytics catalog.\n\n        :param account_name: The Azure Data Lake Analytics account upon which\n         to execute catalog operations.\n        :type account_name: str\n        :param database_name: The name of the database containing the types.\n        :type database_name: str\n        :param schema_name: The name of the schema containing the types.\n        :type schema_name: str\n        :param filter: OData filter. Optional.\n        :type filter: str\n        :param top: The number of items to return. Optional.\n        :type top: int\n        :param skip: The number of items to skip over before returning\n         elements. Optional.\n        :type skip: int\n        :param select: OData Select statement. Limits the properties on each\n         entry to just those requested, e.g.\n         Categories?$select=CategoryName,Description. Optional.\n        :type select: str\n        :param orderby: OrderBy clause. One or more comma-separated\n         expressions with an optional \"asc\" (the default) or \"desc\" depending\n         on the order you'd like the values sorted, e.g.\n         Categories?$orderby=CategoryName desc. Optional.\n        :type orderby: str\n        :param count: The Boolean value of true or false to request a count of\n         the matching resources included with the resources in the response,\n         e.g. Categories?$count=true. Optional.\n        :type count: bool\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of USqlType\n        :rtype:\n         ~azure.mgmt.datalake.analytics.catalog.models.USqlTypePaged[~azure.mgmt.datalake.analytics.catalog.models.USqlType]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44293:c0:m31"}
{"signature": "def delete_all_secrets(<EOL>self, account_name, database_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete_all_secrets.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.adla_catalog_dns_suffix, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", database_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes all secrets in the specified database. This is deprecated and\n        will be removed in the next release. In the future, please only drop\n        individual credentials using DeleteCredential.\n\n        :param account_name: The Azure Data Lake Analytics account upon which\n         to execute catalog operations.\n        :type account_name: str\n        :param database_name: The name of the database containing the secret.\n        :type database_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44293:c0:m5"}
{"signature": "def list_schemas(<EOL>self, account_name, database_name, filter=None, top=None, skip=None, select=None, orderby=None, count=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_schemas.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.adla_catalog_dns_suffix, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", database_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>', minimum=<NUM_LIT:1>)<EOL><DEDENT>if skip is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", skip, '<STR_LIT:int>', minimum=<NUM_LIT:1>)<EOL><DEDENT>if select is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", select, '<STR_LIT:str>')<EOL><DEDENT>if orderby is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", orderby, '<STR_LIT:str>')<EOL><DEDENT>if count is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT:count>\", count, '<STR_LIT:bool>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.USqlSchemaPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.USqlSchemaPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves the list of schemas from the Data Lake Analytics catalog.\n\n        :param account_name: The Azure Data Lake Analytics account upon which\n         to execute catalog operations.\n        :type account_name: str\n        :param database_name: The name of the database containing the schema.\n        :type database_name: str\n        :param filter: OData filter. Optional.\n        :type filter: str\n        :param top: The number of items to return. Optional.\n        :type top: int\n        :param skip: The number of items to skip over before returning\n         elements. Optional.\n        :type skip: int\n        :param select: OData Select statement. Limits the properties on each\n         entry to just those requested, e.g.\n         Categories?$select=CategoryName,Description. Optional.\n        :type select: str\n        :param orderby: OrderBy clause. One or more comma-separated\n         expressions with an optional \"asc\" (the default) or \"desc\" depending\n         on the order you'd like the values sorted, e.g.\n         Categories?$orderby=CategoryName desc. Optional.\n        :type orderby: str\n        :param count: The Boolean value of true or false to request a count of\n         the matching resources included with the resources in the response,\n         e.g. Categories?$count=true. Optional.\n        :type count: bool\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of USqlSchema\n        :rtype:\n         ~azure.mgmt.datalake.analytics.catalog.models.USqlSchemaPaged[~azure.mgmt.datalake.analytics.catalog.models.USqlSchema]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44293:c0:m37"}
{"signature": "def list_views(<EOL>self, account_name, database_name, schema_name, filter=None, top=None, skip=None, select=None, orderby=None, count=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_views.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.adla_catalog_dns_suffix, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", database_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", schema_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>', minimum=<NUM_LIT:1>)<EOL><DEDENT>if skip is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", skip, '<STR_LIT:int>', minimum=<NUM_LIT:1>)<EOL><DEDENT>if select is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", select, '<STR_LIT:str>')<EOL><DEDENT>if orderby is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", orderby, '<STR_LIT:str>')<EOL><DEDENT>if count is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT:count>\", count, '<STR_LIT:bool>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.USqlViewPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.USqlViewPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves the list of views from the Data Lake Analytics catalog.\n\n        :param account_name: The Azure Data Lake Analytics account upon which\n         to execute catalog operations.\n        :type account_name: str\n        :param database_name: The name of the database containing the views.\n        :type database_name: str\n        :param schema_name: The name of the schema containing the views.\n        :type schema_name: str\n        :param filter: OData filter. Optional.\n        :type filter: str\n        :param top: The number of items to return. Optional.\n        :type top: int\n        :param skip: The number of items to skip over before returning\n         elements. Optional.\n        :type skip: int\n        :param select: OData Select statement. Limits the properties on each\n         entry to just those requested, e.g.\n         Categories?$select=CategoryName,Description. Optional.\n        :type select: str\n        :param orderby: OrderBy clause. One or more comma-separated\n         expressions with an optional \"asc\" (the default) or \"desc\" depending\n         on the order you'd like the values sorted, e.g.\n         Categories?$orderby=CategoryName desc. Optional.\n        :type orderby: str\n        :param count: The Boolean value of true or false to request a count of\n         the matching resources included with the resources in the response,\n         e.g. Categories?$count=true. Optional.\n        :type count: bool\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of USqlView\n        :rtype:\n         ~azure.mgmt.datalake.analytics.catalog.models.USqlViewPaged[~azure.mgmt.datalake.analytics.catalog.models.USqlView]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44293:c0:m24"}
{"signature": "def list_table_types(<EOL>self, account_name, database_name, schema_name, filter=None, top=None, skip=None, select=None, orderby=None, count=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_table_types.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.adla_catalog_dns_suffix, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", database_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", schema_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>', minimum=<NUM_LIT:1>)<EOL><DEDENT>if skip is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", skip, '<STR_LIT:int>', minimum=<NUM_LIT:1>)<EOL><DEDENT>if select is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", select, '<STR_LIT:str>')<EOL><DEDENT>if orderby is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", orderby, '<STR_LIT:str>')<EOL><DEDENT>if count is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT:count>\", count, '<STR_LIT:bool>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.USqlTableTypePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.USqlTableTypePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves the list of table types from the Data Lake Analytics catalog.\n\n        :param account_name: The Azure Data Lake Analytics account upon which\n         to execute catalog operations.\n        :type account_name: str\n        :param database_name: The name of the database containing the table\n         types.\n        :type database_name: str\n        :param schema_name: The name of the schema containing the table types.\n        :type schema_name: str\n        :param filter: OData filter. Optional.\n        :type filter: str\n        :param top: The number of items to return. Optional.\n        :type top: int\n        :param skip: The number of items to skip over before returning\n         elements. Optional.\n        :type skip: int\n        :param select: OData Select statement. Limits the properties on each\n         entry to just those requested, e.g.\n         Categories?$select=CategoryName,Description. Optional.\n        :type select: str\n        :param orderby: OrderBy clause. One or more comma-separated\n         expressions with an optional \"asc\" (the default) or \"desc\" depending\n         on the order you'd like the values sorted, e.g.\n         Categories?$orderby=CategoryName desc. Optional.\n        :type orderby: str\n        :param count: The Boolean value of true or false to request a count of\n         the matching resources included with the resources in the response,\n         e.g. Categories?$count=true. Optional.\n        :type count: bool\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of USqlTableType\n        :rtype:\n         ~azure.mgmt.datalake.analytics.catalog.models.USqlTableTypePaged[~azure.mgmt.datalake.analytics.catalog.models.USqlTableType]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44293:c0:m20"}
{"signature": "def list_table_partitions(<EOL>self, account_name, database_name, schema_name, table_name, filter=None, top=None, skip=None, select=None, orderby=None, count=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_table_partitions.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.adla_catalog_dns_suffix, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", database_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", schema_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", table_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>', minimum=<NUM_LIT:1>)<EOL><DEDENT>if skip is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", skip, '<STR_LIT:int>', minimum=<NUM_LIT:1>)<EOL><DEDENT>if select is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", select, '<STR_LIT:str>')<EOL><DEDENT>if orderby is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", orderby, '<STR_LIT:str>')<EOL><DEDENT>if count is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT:count>\", count, '<STR_LIT:bool>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.USqlTablePartitionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.USqlTablePartitionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves the list of table partitions from the Data Lake Analytics\n        catalog.\n\n        :param account_name: The Azure Data Lake Analytics account upon which\n         to execute catalog operations.\n        :type account_name: str\n        :param database_name: The name of the database containing the\n         partitions.\n        :type database_name: str\n        :param schema_name: The name of the schema containing the partitions.\n        :type schema_name: str\n        :param table_name: The name of the table containing the partitions.\n        :type table_name: str\n        :param filter: OData filter. Optional.\n        :type filter: str\n        :param top: The number of items to return. Optional.\n        :type top: int\n        :param skip: The number of items to skip over before returning\n         elements. Optional.\n        :type skip: int\n        :param select: OData Select statement. Limits the properties on each\n         entry to just those requested, e.g.\n         Categories?$select=CategoryName,Description. Optional.\n        :type select: str\n        :param orderby: OrderBy clause. One or more comma-separated\n         expressions with an optional \"asc\" (the default) or \"desc\" depending\n         on the order you'd like the values sorted, e.g.\n         Categories?$orderby=CategoryName desc. Optional.\n        :type orderby: str\n        :param count: The Boolean value of true or false to request a count of\n         the matching resources included with the resources in the response,\n         e.g. Categories?$count=true. Optional.\n        :type count: bool\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of USqlTablePartition\n        :rtype:\n         ~azure.mgmt.datalake.analytics.catalog.models.USqlTablePartitionPaged[~azure.mgmt.datalake.analytics.catalog.models.USqlTablePartition]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44293:c0:m30"}
{"signature": "def list_table_valued_functions_by_database(<EOL>self, account_name, database_name, filter=None, top=None, skip=None, select=None, orderby=None, count=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_table_valued_functions_by_database.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.adla_catalog_dns_suffix, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", database_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>', minimum=<NUM_LIT:1>)<EOL><DEDENT>if skip is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", skip, '<STR_LIT:int>', minimum=<NUM_LIT:1>)<EOL><DEDENT>if select is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", select, '<STR_LIT:str>')<EOL><DEDENT>if orderby is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", orderby, '<STR_LIT:str>')<EOL><DEDENT>if count is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT:count>\", count, '<STR_LIT:bool>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.USqlTableValuedFunctionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.USqlTableValuedFunctionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves the list of all table valued functions in a database from the\n        Data Lake Analytics catalog.\n\n        :param account_name: The Azure Data Lake Analytics account upon which\n         to execute catalog operations.\n        :type account_name: str\n        :param database_name: The name of the database containing the table\n         valued functions.\n        :type database_name: str\n        :param filter: OData filter. Optional.\n        :type filter: str\n        :param top: The number of items to return. Optional.\n        :type top: int\n        :param skip: The number of items to skip over before returning\n         elements. Optional.\n        :type skip: int\n        :param select: OData Select statement. Limits the properties on each\n         entry to just those requested, e.g.\n         Categories?$select=CategoryName,Description. Optional.\n        :type select: str\n        :param orderby: OrderBy clause. One or more comma-separated\n         expressions with an optional \"asc\" (the default) or \"desc\" depending\n         on the order you'd like the values sorted, e.g.\n         Categories?$orderby=CategoryName desc. Optional.\n        :type orderby: str\n        :param count: The Boolean value of true or false to request a count of\n         the matching resources included with the resources in the response,\n         e.g. Categories?$count=true. Optional.\n        :type count: bool\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of USqlTableValuedFunction\n        :rtype:\n         ~azure.mgmt.datalake.analytics.catalog.models.USqlTableValuedFunctionPaged[~azure.mgmt.datalake.analytics.catalog.models.USqlTableValuedFunction]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44293:c0:m40"}
{"signature": "def get_assembly(<EOL>self, account_name, database_name, assembly_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_assembly.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.adla_catalog_dns_suffix, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", database_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", assembly_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves the specified assembly from the Data Lake Analytics catalog.\n\n        :param account_name: The Azure Data Lake Analytics account upon which\n         to execute catalog operations.\n        :type account_name: str\n        :param database_name: The name of the database containing the\n         assembly.\n        :type database_name: str\n        :param assembly_name: The name of the assembly.\n        :type assembly_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: USqlAssembly or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.datalake.analytics.catalog.models.USqlAssembly or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44293:c0:m34"}
{"signature": "def get(<EOL>self, account_name, job_identity, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.adla_job_dns_suffix, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", job_identity, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the job information for the specified job ID.\n\n        :param account_name: The Azure Data Lake Analytics account to execute\n         job operations on.\n        :type account_name: str\n        :param job_identity: JobInfo ID.\n        :type job_identity: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: JobInformation or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.datalake.analytics.job.models.JobInformation or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44363:c0:m3"}
{"signature": "def build(<EOL>self, account_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.build.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.adla_job_dns_suffix, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, body_content, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Builds (compiles) the specified job in the specified Data Lake\n        Analytics account for job correctness and validation.\n\n        :param account_name: The Azure Data Lake Analytics account to execute\n         job operations on.\n        :type account_name: str\n        :param parameters: The parameters to build a job.\n        :type parameters:\n         ~azure.mgmt.datalake.analytics.job.models.BuildJobParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: JobInformation or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.datalake.analytics.job.models.JobInformation or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44363:c0:m12"}
{"signature": "def yield_method(<EOL>self, account_name, job_identity, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._yield_method_initial(<EOL>account_name=account_name,<EOL>job_identity=job_identity,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Pauses the specified job and places it back in the job queue, behind\n        other jobs of equal or higher importance, based on priority. (Only for\n        use internally with Scope job type.).\n\n        :param account_name: The Azure Data Lake Analytics account to execute\n         job operations on.\n        :type account_name: str\n        :param job_identity: Job identifier. Uniquely identifies the job\n         across all jobs submitted to the service.\n        :type job_identity: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44363:c0:m11"}
{"signature": "def create(<EOL>self, account_name, job_identity, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", account_name, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.adla_job_dns_suffix, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", job_identity, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, body_content, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Submits a job to the specified Data Lake Analytics account.\n\n        :param account_name: The Azure Data Lake Analytics account to execute\n         job operations on.\n        :type account_name: str\n        :param job_identity: Job identifier. Uniquely identifies the job\n         across all jobs submitted to the service.\n        :type job_identity: str\n        :param parameters: The parameters to submit a job.\n        :type parameters:\n         ~azure.mgmt.datalake.analytics.job.models.CreateJobParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: JobInformation or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.datalake.analytics.job.models.JobInformation or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44363:c0:m2"}
{"signature": "def get(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the subscription-level key used for Real User Metrics collection.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: UserMetricsModel or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.trafficmanager.models.UserMetricsModel or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44415:c0:m1"}
{"signature": "def get(<EOL>self, resource_group_name, profile_name, top_left=None, bot_right=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", profile_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.heat_map_type, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if top_left is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top_left, '<STR_LIT>', div='<STR_LIT:U+002C>', max_items=<NUM_LIT:2>, min_items=<NUM_LIT:2>)<EOL><DEDENT>if bot_right is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", bot_right, '<STR_LIT>', div='<STR_LIT:U+002C>', max_items=<NUM_LIT:2>, min_items=<NUM_LIT:2>)<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets latest heatmap for Traffic Manager profile.\n\n        :param resource_group_name: The name of the resource group containing\n         the Traffic Manager endpoint.\n        :type resource_group_name: str\n        :param profile_name: The name of the Traffic Manager profile.\n        :type profile_name: str\n        :param top_left: The top left latitude,longitude pair of the\n         rectangular viewport to query for.\n        :type top_left: list[float]\n        :param bot_right: The bottom right latitude,longitude pair of the\n         rectangular viewport to query for.\n        :type bot_right: list[float]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: HeatMapModel or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.trafficmanager.models.HeatMapModel or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44418:c0:m1"}
{"signature": "def delete(<EOL>self, resource_group_name, profile_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", profile_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Deletes a Traffic Manager profile.\n\n        :param resource_group_name: The name of the resource group containing\n         the Traffic Manager profile to be deleted.\n        :type resource_group_name: str\n        :param profile_name: The name of the Traffic Manager profile to be\n         deleted.\n        :type profile_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DeleteOperationResult or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.trafficmanager.models.DeleteOperationResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44419:c0:m6"}
{"signature": "def update(<EOL>self, resource_group_name, profile_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", profile_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Update a Traffic Manager profile.\n\n        :param resource_group_name: The name of the resource group containing\n         the Traffic Manager profile.\n        :type resource_group_name: str\n        :param profile_name: The name of the Traffic Manager profile.\n        :type profile_name: str\n        :param parameters: The Traffic Manager profile parameters supplied to\n         the Update operation.\n        :type parameters: ~azure.mgmt.trafficmanager.models.Profile\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Profile or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.trafficmanager.models.Profile or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44419:c0:m7"}
{"signature": "def category(<EOL>self, accept_language=None, user_agent=None, client_id=None, client_ip=None, location=None, country_code=None, category=None, count=None, headline_count=None, market=None, offset=None, original_image=None, safe_search=None, set_lang=None, text_decorations=None, text_format=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.category.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>if country_code is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", country_code, '<STR_LIT:str>')<EOL><DEDENT>if category is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", category, '<STR_LIT:str>')<EOL><DEDENT>if count is not None:<EOL><INDENT>query_parameters['<STR_LIT:count>'] = self._serialize.query(\"<STR_LIT:count>\", count, '<STR_LIT:int>')<EOL><DEDENT>if headline_count is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", headline_count, '<STR_LIT:int>')<EOL><DEDENT>if market is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", market, '<STR_LIT:str>')<EOL><DEDENT>if offset is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", offset, '<STR_LIT:int>')<EOL><DEDENT>if original_image is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", original_image, '<STR_LIT:bool>')<EOL><DEDENT>if safe_search is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", safe_search, '<STR_LIT:str>')<EOL><DEDENT>if set_lang is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", set_lang, '<STR_LIT:str>')<EOL><DEDENT>if text_decorations is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", text_decorations, '<STR_LIT:bool>')<EOL><DEDENT>if text_format is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", text_format, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.x_bing_apis_sdk, '<STR_LIT:str>')<EOL>if accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", accept_language, '<STR_LIT:str>')<EOL><DEDENT>if user_agent is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", user_agent, '<STR_LIT:str>')<EOL><DEDENT>if client_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", client_id, '<STR_LIT:str>')<EOL><DEDENT>if client_ip is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", client_ip, '<STR_LIT:str>')<EOL><DEDENT>if location is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT:location>\", location, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "The News Category API lets lets you search on Bing and get back a list\n        of top news articles by category. This section provides technical\n        details about the query parameters and headers that you use to request\n        news and the JSON response objects that contain them.  For examples\n        that show how to make requests, see [Searching the web for\n        news](https://docs.microsoft.com/en-us/azure/cognitive-services/bing-news-search/search-the-web).\n\n        :param accept_language: A comma-delimited list of one or more\n         languages to use for user interface strings. The list is in decreasing\n         order of preference. For additional information, including expected\n         format, see\n         [RFC2616](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html).\n         This header and the\n         [setLang](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-news-api-v7-reference#setlang)\n         query parameter are mutually exclusive; do not specify both. If you\n         set this header, you must also specify the\n         [cc](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-news-api-v7-reference#cc)\n         query parameter. To determine the market to return results for, Bing\n         uses the first supported language it finds from the list and combines\n         it with the cc parameter value. If the list does not include a\n         supported language, Bing finds the closest language and market that\n         supports the request or it uses an aggregated or default market for\n         the results. To determine the market that Bing used, see the\n         BingAPIs-Market header. Use this header and the cc query parameter\n         only if you specify multiple languages. Otherwise, use the\n         [mkt](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-news-api-v7-reference#mkt)\n         and\n         [setLang](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-news-api-v7-reference#setlang)\n         query parameters. A user interface string is a string that's used as a\n         label in a user interface. There are few user interface strings in the\n         JSON response objects. Any links to Bing.com properties in the\n         response objects apply the specified language.\n        :type accept_language: str\n        :param user_agent: The user agent originating the request. Bing uses\n         the user agent to provide mobile users with an optimized experience.\n         Although optional, you are encouraged to always specify this header.\n         The user-agent should be the same string that any commonly used\n         browser sends. For information about user agents, see [RFC\n         2616](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html). The\n         following are examples of user-agent strings. Windows Phone:\n         Mozilla/5.0 (compatible; MSIE 10.0; Windows Phone 8.0; Trident/6.0;\n         IEMobile/10.0; ARM; Touch; NOKIA; Lumia 822). Android: Mozilla / 5.0\n         (Linux; U; Android 2.3.5; en - us; SCH - I500 Build / GINGERBREAD)\n         AppleWebKit / 533.1 (KHTML; like Gecko) Version / 4.0 Mobile Safari /\n         533.1. iPhone: Mozilla / 5.0 (iPhone; CPU iPhone OS 6_1 like Mac OS X)\n         AppleWebKit / 536.26 (KHTML; like Gecko) Mobile / 10B142 iPhone4; 1\n         BingWeb / 3.03.1428.20120423. PC: Mozilla / 5.0 (Windows NT 6.3;\n         WOW64; Trident / 7.0; Touch; rv:11.0) like Gecko. iPad: Mozilla / 5.0\n         (iPad; CPU OS 7_0 like Mac OS X) AppleWebKit / 537.51.1 (KHTML, like\n         Gecko) Version / 7.0 Mobile / 11A465 Safari / 9537.53\n        :type user_agent: str\n        :param client_id: Bing uses this header to provide users with\n         consistent behavior across Bing API calls. Bing often flights new\n         features and improvements, and it uses the client ID as a key for\n         assigning traffic on different flights. If you do not use the same\n         client ID for a user across multiple requests, then Bing may assign\n         the user to multiple conflicting flights. Being assigned to multiple\n         conflicting flights can lead to an inconsistent user experience. For\n         example, if the second request has a different flight assignment than\n         the first, the experience may be unexpected. Also, Bing can use the\n         client ID to tailor web results to that client ID\u2019s search history,\n         providing a richer experience for the user. Bing also uses this header\n         to help improve result rankings by analyzing the activity generated by\n         a client ID. The relevance improvements help with better quality of\n         results delivered by Bing APIs and in turn enables higher\n         click-through rates for the API consumer. IMPORTANT: Although\n         optional, you should consider this header required. Persisting the\n         client ID across multiple requests for the same end user and device\n         combination enables 1) the API consumer to receive a consistent user\n         experience, and 2) higher click-through rates via better quality of\n         results from the Bing APIs. Each user that uses your application on\n         the device must have a unique, Bing generated client ID. If you do not\n         include this header in the request, Bing generates an ID and returns\n         it in the X-MSEdge-ClientID response header. The only time that you\n         should NOT include this header in a request is the first time the user\n         uses your app on that device. Use the client ID for each Bing API\n         request that your app makes for this user on the device. Persist the\n         client ID. To persist the ID in a browser app, use a persistent HTTP\n         cookie to ensure the ID is used across all sessions. Do not use a\n         session cookie. For other apps such as mobile apps, use the device's\n         persistent storage to persist the ID. The next time the user uses your\n         app on that device, get the client ID that you persisted. Bing\n         responses may or may not include this header. If the response includes\n         this header, capture the client ID and use it for all subsequent Bing\n         requests for the user on that device. If you include the\n         X-MSEdge-ClientID, you must not include cookies in the request.\n        :type client_id: str\n        :param client_ip: The IPv4 or IPv6 address of the client device. The\n         IP address is used to discover the user's location. Bing uses the\n         location information to determine safe search behavior. Although\n         optional, you are encouraged to always specify this header and the\n         X-Search-Location header. Do not obfuscate the address (for example,\n         by changing the last octet to 0). Obfuscating the address results in\n         the location not being anywhere near the device's actual location,\n         which may result in Bing serving erroneous results.\n        :type client_ip: str\n        :param location: A semicolon-delimited list of key/value pairs that\n         describe the client's geographical location. Bing uses the location\n         information to determine safe search behavior and to return relevant\n         local content. Specify the key/value pair as <key>:<value>. The\n         following are the keys that you use to specify the user's location.\n         lat (required): The latitude of the client's location, in degrees. The\n         latitude must be greater than or equal to -90.0 and less than or equal\n         to +90.0. Negative values indicate southern latitudes and positive\n         values indicate northern latitudes. long (required): The longitude of\n         the client's location, in degrees. The longitude must be greater than\n         or equal to -180.0 and less than or equal to +180.0. Negative values\n         indicate western longitudes and positive values indicate eastern\n         longitudes. re (required): The radius, in meters, which specifies the\n         horizontal accuracy of the coordinates. Pass the value returned by the\n         device's location service. Typical values might be 22m for GPS/Wi-Fi,\n         380m for cell tower triangulation, and 18,000m for reverse IP lookup.\n         ts (optional): The UTC UNIX timestamp of when the client was at the\n         location. (The UNIX timestamp is the number of seconds since January\n         1, 1970.) head (optional): The client's relative heading or direction\n         of travel. Specify the direction of travel as degrees from 0 through\n         360, counting clockwise relative to true north. Specify this key only\n         if the sp key is nonzero. sp (optional): The horizontal velocity\n         (speed), in meters per second, that the client device is traveling.\n         alt (optional): The altitude of the client device, in meters. are\n         (optional): The radius, in meters, that specifies the vertical\n         accuracy of the coordinates. Specify this key only if you specify the\n         alt key. Although many of the keys are optional, the more information\n         that you provide, the more accurate the location results are. Although\n         optional, you are encouraged to always specify the user's geographical\n         location. Providing the location is especially important if the\n         client's IP address does not accurately reflect the user's physical\n         location (for example, if the client uses VPN). For optimal results,\n         you should include this header and the X-MSEdge-ClientIP header, but\n         at a minimum, you should include this header.\n        :type location: str\n        :param country_code: A 2-character country code of the country where\n         the results come from. This API supports only the United States\n         market. If you specify this query parameter, it must be set to us. If\n         you set this parameter, you must also specify the Accept-Language\n         header. Bing uses the first supported language it finds from the\n         languages list, and combine that language with the country code that\n         you specify to determine the market to return results for. If the\n         languages list does not include a supported language, Bing finds the\n         closest language and market that supports the request, or it may use\n         an aggregated or default market for the results instead of a specified\n         one. You should use this query parameter and the Accept-Language query\n         parameter only if you specify multiple languages; otherwise, you\n         should use the mkt and setLang query parameters. This parameter and\n         the mkt query parameter are mutually exclusive\u2014do not specify both.\n        :type country_code: str\n        :param category: The category of articles to return. For example,\n         Sports articles or Entertainment articles. For a list of possible\n         categories, see [News Categories by\n         Market](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-news-api-v7-reference#categories-by-market).\n         Use this parameter only with News Category API. If you do not specify\n         this parameter, the response includes both: Headline articles\n         typically published in the last 24 hours from any category and\n         articles from each parent category (up to four articles). If the\n         article is a headline, the article's headline field is set to true. By\n         default, the response includes up to 12 headline articles. To specify\n         the number of headline articles to return, set the\n         [headlineCount](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-news-api-v7-reference#headlineCount)\n         query parameter.\n        :type category: str\n        :param count: The number of news articles to return in the response.\n         The actual number delivered may be less than requested. The default is\n         10 and the maximum value is 100. The actual number delivered may be\n         less than requested.You may use this parameter along with the offset\n         parameter to page results. For example, if your user interface\n         displays 20 articles per page, set count to 20 and offset to 0 to get\n         the first page of results. For each subsequent page, increment offset\n         by 20 (for example, 0, 20, 40). It is possible for multiple pages to\n         include some overlap in results. If you do not specify the\n         [category](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-news-api-v7-reference#category)\n         parameter, Bing ignores this parameter.\n        :type count: int\n        :param headline_count: The number of headline articles to return in\n         the response. The default is 12. Specify this parameter only if you do\n         not specify the\n         [category](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-news-api-v7-reference#category)\n         parameter.\n        :type headline_count: int\n        :param market: The market where the results come from. Typically, mkt\n         is the country where the user is making the request from. However, it\n         could be a different country if the user is not located in a country\n         where Bing delivers results. The market must be in the form <language\n         code>-<country code>. For example, en-US. The string is case\n         insensitive. For a list of possible market values, see [Market\n         Codes](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-news-api-v7-reference#market-codes).\n         NOTE: If known, you are encouraged to always specify the market.\n         Specifying the market helps Bing route the request and return an\n         appropriate and optimal response. If you specify a market that is not\n         listed in [Market\n         Codes](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-news-api-v7-reference#market-codes),\n         Bing uses a best fit market code based on an internal mapping that is\n         subject to change. This parameter and the\n         [cc](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-news-api-v7-reference#cc)\n         query parameter are mutually exclusive\u2014do not specify both.\n        :type market: str\n        :param offset: The zero-based offset that indicates the number of news\n         to skip before returning news. The default is 0. The offset should be\n         less than\n         ([totalEstimatedMatches](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-news-api-v7-reference#news-totalmatches)\n         - count). Use this parameter along with the count parameter to page\n         results. For example, if your user interface displays 20 news per\n         page, set count to 20 and offset to 0 to get the first page of\n         results. For each subsequent page, increment offset by 20 (for\n         example, 0, 20, 40). It is possible for multiple pages to include some\n         overlap in results. If you do not specify the\n         [category](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-news-api-v7-reference#category)\n         parameter, Bing ignores this parameter.\n        :type offset: int\n        :param original_image: A Boolean value that determines whether the\n         image's contentUrl contains a URL that points to a thumbnail of the\n         original article's image or the image itself. If the article includes\n         an image, and this parameter is set to true, the image's contentUrl\n         property contains a URL that you may use to download the original\n         image from the publisher's website. Otherwise, if this parameter is\n         false, the image's contentUrl and thumbnailUrl URLs both point to the\n         same thumbnail image. Use this parameter only with the News Search API\n         or News Category API. Trending Topics API ignore this parameter.\n        :type original_image: bool\n        :param safe_search: Filter news for adult content. The following are\n         the possible filter values. Off: Return news articles with adult text,\n         images, or videos. Moderate: Return news articles with adult text but\n         not adult images or videos. Strict: Do not return news articles with\n         adult text, images, or videos. If the request comes from a market that\n         Bing's adult policy requires that safeSearch is set to Strict, Bing\n         ignores the safeSearch value and uses Strict. If you use the site:\n         query operator, there is the chance that the response may contain\n         adult content regardless of what the safeSearch query parameter is set\n         to. Use site: only if you are aware of the content on the site and\n         your scenario supports the possibility of adult content. Possible\n         values include: 'Off', 'Moderate', 'Strict'\n        :type safe_search: str or\n         ~azure.cognitiveservices.search.newssearch.models.SafeSearch\n        :param set_lang: The language to use for user interface strings.\n         Specify the language using the ISO 639-1 2-letter language code. For\n         example, the language code for English is EN. The default is EN\n         (English). Although optional, you should always specify the language.\n         Typically, you set setLang to the same language specified by mkt\n         unless the user wants the user interface strings displayed in a\n         different language. This parameter and the\n         [Accept-Language](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-news-api-v7-reference#acceptlanguage)\n         header are mutually exclusive; do not specify both. A user interface\n         string is a string that's used as a label in a user interface. There\n         are few user interface strings in the JSON response objects. Also, any\n         links to Bing.com properties in the response objects apply the\n         specified language.\n        :type set_lang: str\n        :param text_decorations: A Boolean value that determines whether\n         display strings contain decoration markers such as hit highlighting\n         characters. If true, the strings may include markers. The default is\n         false. To specify whether to use Unicode characters or HTML tags as\n         the markers, see the\n         [textFormat](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-news-api-v7-reference#textformat)\n         query parameter. For information about hit highlighting, see [Hit\n         Highlighting](https://docs.microsoft.com/azure/cognitive-services/bing-news-search/hit-highlighting).\n        :type text_decorations: bool\n        :param text_format: The type of markers to use for text decorations\n         (see the textDecorations query parameter). Possible values are Raw\u2014Use\n         Unicode characters to mark content that needs special formatting. The\n         Unicode characters are in the range E000 through E019. For example,\n         Bing uses E000 and E001 to mark the beginning and end of query terms\n         for hit highlighting. HTML\u2014Use HTML tags to mark content that needs\n         special formatting. For example, use <b> tags to highlight query terms\n         in display strings. The default is Raw. For display strings that\n         contain escapable HTML characters such as <, >, and &, if textFormat\n         is set to HTML, Bing escapes the characters as appropriate (for\n         example, < is escaped to &lt;). Possible values include: 'Raw', 'Html'\n        :type text_format: str or\n         ~azure.cognitiveservices.search.newssearch.models.TextFormat\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: News or ClientRawResponse if raw=true\n        :rtype: ~azure.cognitiveservices.search.newssearch.models.News or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.search.newssearch.models.ErrorResponseException>`", "id": "f44474:c0:m2"}
{"signature": "def list_billing_meters(<EOL>self, billing_location=None, os_type=None, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_billing_meters.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if billing_location is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", billing_location, '<STR_LIT:str>')<EOL><DEDENT>if os_type is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", os_type, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.BillingMeterPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.BillingMeterPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of meters for a given location.\n\n        Gets a list of meters for a given location.\n\n        :param billing_location: Azure Location of billable resource\n        :type billing_location: str\n        :param os_type: App Service OS type meters used for\n        :type os_type: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of BillingMeter\n        :rtype:\n         ~azure.mgmt.web.models.BillingMeterPaged[~azure.mgmt.web.models.BillingMeter]\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44981:c1:m6"}
{"signature": "def validate_move(<EOL>self, resource_group_name, target_resource_group=None, resources=None, custom_headers=None, raw=False, **operation_config):", "body": "move_resource_envelope = models.CsmMoveResourceEnvelope(target_resource_group=target_resource_group, resources=resources)<EOL>api_version = \"<STR_LIT>\"<EOL>url = self.validate_move.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(move_resource_envelope, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Validate whether a resource can be moved.\n\n        Validate whether a resource can be moved.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param target_resource_group:\n        :type target_resource_group: str\n        :param resources:\n        :type resources: list[str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44981:c1:m17"}
{"signature": "def validate_container_settings(<EOL>self, validate_container_settings_request, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.validate_container_settings.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(validate_container_settings_request, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT:object>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Validate if the container settings are correct.\n\n        Validate if the container settings are correct.\n\n        :param validate_container_settings_request:\n        :type validate_container_settings_request:\n         ~azure.mgmt.web.models.ValidateContainerSettingsRequest\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: object or ClientRawResponse if raw=true\n        :rtype: object or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44981:c1:m16"}
{"signature": "def list_source_controls(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_source_controls.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SourceControlPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SourceControlPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the source controls available for Azure websites.\n\n        Gets the source controls available for Azure websites.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of SourceControl\n        :rtype:\n         ~azure.mgmt.web.models.SourceControlPaged[~azure.mgmt.web.models.SourceControl]\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44981:c1:m3"}
{"signature": "def list_skus(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "api_version = \"<STR_LIT>\"<EOL>url = self.list_skus.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List all SKUs.\n\n        List all SKUs.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SkuInfos or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.SkuInfos or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44981:c1:m12"}
{"signature": "def update_vnet_gateway(<EOL>self, resource_group_name, name, vnet_name, gateway_name, connection_envelope, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.update_vnet_gateway.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vnet_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", gateway_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(connection_envelope, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Update a Virtual Network gateway.\n\n        Update a Virtual Network gateway.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the App Service plan.\n        :type name: str\n        :param vnet_name: Name of the Virtual Network.\n        :type vnet_name: str\n        :param gateway_name: Name of the gateway. Only the 'primary' gateway\n         is supported.\n        :type gateway_name: str\n        :param connection_envelope: Definition of the gateway.\n        :type connection_envelope: ~azure.mgmt.web.models.VnetGateway\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VnetGateway or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.VnetGateway or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44983:c0:m24"}
{"signature": "def list_web_apps(<EOL>self, resource_group_name, name, skip_token=None, filter=None, top=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_web_apps.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if skip_token is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", skip_token, '<STR_LIT:str>')<EOL><DEDENT>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>', skip_quote=True)<EOL><DEDENT>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SitePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SitePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get all apps associated with an App Service plan.\n\n        Get all apps associated with an App Service plan.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the App Service plan.\n        :type name: str\n        :param skip_token: Skip to a web app in the list of webapps associated\n         with app service plan. If specified, the resulting list will contain\n         web apps starting from (including) the skipToken. Otherwise, the\n         resulting list contains web apps from the start of the list\n        :type skip_token: str\n        :param filter: Supported filter: $filter=state eq running. Returns\n         only web apps that are currently running\n        :type filter: str\n        :param top: List page size. If specified, results are paged.\n        :type top: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Site\n        :rtype: ~azure.mgmt.web.models.SitePaged[~azure.mgmt.web.models.Site]\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44983:c0:m18"}
{"signature": "def get_vnet_from_server_farm(<EOL>self, resource_group_name, name, vnet_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_vnet_from_server_farm.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vnet_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get a Virtual Network associated with an App Service plan.\n\n        Get a Virtual Network associated with an App Service plan.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the App Service plan.\n        :type name: str\n        :param vnet_name: Name of the Virtual Network.\n        :type vnet_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VnetInfo or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.VnetInfo or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44983:c0:m22"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, name, app_service_plan, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>name=name,<EOL>app_service_plan=app_service_plan,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates an App Service Plan.\n\n        Creates or updates an App Service Plan.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the App Service plan.\n        :type name: str\n        :param app_service_plan: Details of the App Service plan.\n        :type app_service_plan: ~azure.mgmt.web.models.AppServicePlan\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns AppServicePlan or\n         ClientRawResponse<AppServicePlan> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.web.models.AppServicePlan]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.web.models.AppServicePlan]]\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44983:c0:m5"}
{"signature": "def list_web_apps_by_hybrid_connection(<EOL>self, resource_group_name, name, namespace_name, relay_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_web_apps_by_hybrid_connection.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", relay_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.StrPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.StrPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get all apps that use a Hybrid Connection in an App Service Plan.\n\n        Get all apps that use a Hybrid Connection in an App Service Plan.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the App Service plan.\n        :type name: str\n        :param namespace_name: Name of the Hybrid Connection namespace.\n        :type namespace_name: str\n        :param relay_name: Name of the Hybrid Connection relay.\n        :type relay_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of str\n        :rtype: ~azure.mgmt.web.models.StrPaged[str]\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44983:c0:m12"}
{"signature": "def restart_web_apps(<EOL>self, resource_group_name, name, soft_restart=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.restart_web_apps.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if soft_restart is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", soft_restart, '<STR_LIT:bool>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Restart all apps in an App Service plan.\n\n        Restart all apps in an App Service plan.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the App Service plan.\n        :type name: str\n        :param soft_restart: Specify <code>true</code> to perform a soft\n         restart, applies the configuration settings and restarts the apps if\n         necessary. The default is <code>false</code>, which always restarts\n         and reprovisions the apps\n        :type soft_restart: bool\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44983:c0:m17"}
{"signature": "def list_hybrid_connections(<EOL>self, resource_group_name, name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_hybrid_connections.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.HybridConnectionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.HybridConnectionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieve all Hybrid Connections in use in an App Service plan.\n\n        Retrieve all Hybrid Connections in use in an App Service plan.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the App Service plan.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of HybridConnection\n        :rtype:\n         ~azure.mgmt.web.models.HybridConnectionPaged[~azure.mgmt.web.models.HybridConnection]\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44983:c0:m14"}
{"signature": "def get(<EOL>self, resource_group_name, name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get an App Service plan.\n\n        Get an App Service plan.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the App Service plan.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: AppServicePlan or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.AppServicePlan or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44983:c0:m3"}
{"signature": "def list_metrics(<EOL>self, resource_group_name, name, details=None, filter=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_metrics.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if details is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", details, '<STR_LIT:bool>')<EOL><DEDENT>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>', skip_quote=True)<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ResourceMetricPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ResourceMetricPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get metrics for an App Service plan.\n\n        Get metrics for an App Service plan.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the App Service plan.\n        :type name: str\n        :param details: Specify <code>true</code> to include instance details.\n         The default is <code>false</code>.\n        :type details: bool\n        :param filter: Return only usages/metrics specified in the filter.\n         Filter conforms to odata syntax. Example: $filter=(name.value eq\n         'Metric1' or name.value eq 'Metric2') and startTime eq\n         2014-01-01T00:00:00Z and endTime eq 2014-12-31T23:59:59Z and timeGrain\n         eq duration'[Hour|Minute|Day]'.\n        :type filter: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ResourceMetric\n        :rtype:\n         ~azure.mgmt.web.models.ResourceMetricPaged[~azure.mgmt.web.models.ResourceMetric]\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44983:c0:m16"}
{"signature": "def get_by_site_slot(<EOL>self, resource_group_name, name, slot, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_by_site_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the category of ResourceHealthMetadata to use for the given site.\n\n        Gets the category of ResourceHealthMetadata to use for the given site.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of web app\n        :type name: str\n        :param slot: Name of web app slot. If not specified then will default\n         to production slot.\n        :type slot: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ResourceHealthMetadata or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.ResourceHealthMetadata or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44984:c0:m6"}
{"signature": "def get_by_site(<EOL>self, resource_group_name, name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_by_site.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the category of ResourceHealthMetadata to use for the given site.\n\n        Gets the category of ResourceHealthMetadata to use for the given site.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of web app\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ResourceHealthMetadata or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.ResourceHealthMetadata or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44984:c0:m4"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ResourceHealthMetadataPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ResourceHealthMetadataPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List all ResourceHealthMetadata for all sites in the resource group in\n        the subscription.\n\n        List all ResourceHealthMetadata for all sites in the resource group in\n        the subscription.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ResourceHealthMetadata\n        :rtype:\n         ~azure.mgmt.web.models.ResourceHealthMetadataPaged[~azure.mgmt.web.models.ResourceHealthMetadata]\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44984:c0:m2"}
{"signature": "def get_ownership_identifier(<EOL>self, resource_group_name, domain_name, name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_ownership_identifier.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", domain_name, '<STR_LIT:str>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get ownership identifier for domain.\n\n        Get ownership identifier for domain.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param domain_name: Name of domain.\n        :type domain_name: str\n        :param name: Name of identifier.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DomainOwnershipIdentifier or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.DomainOwnershipIdentifier or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44985:c0:m12"}
{"signature": "def get(<EOL>self, resource_group_name, domain_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", domain_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get a domain.\n\n        Get a domain.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param domain_name: Name of the domain.\n        :type domain_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Domain or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.Domain or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44985:c0:m6"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, domain_name, domain, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>domain_name=domain_name,<EOL>domain=domain,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Creates or updates a domain.\n\n        Creates or updates a domain.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param domain_name: Name of the domain.\n        :type domain_name: str\n        :param domain: Domain registration information.\n        :type domain: ~azure.mgmt.web.models.Domain\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Domain or\n         ClientRawResponse<Domain> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.web.models.Domain]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.web.models.Domain]]\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44985:c0:m8"}
{"signature": "def renew(<EOL>self, resource_group_name, domain_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.renew.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", domain_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Renew a domain.\n\n        Renew a domain.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param domain_name: Name of the domain.\n        :type domain_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44985:c0:m16"}
{"signature": "def create_or_update_ownership_identifier(<EOL>self, resource_group_name, domain_name, name, kind=None, ownership_id=None, custom_headers=None, raw=False, **operation_config):", "body": "domain_ownership_identifier = models.DomainOwnershipIdentifier(kind=kind, ownership_id=ownership_id)<EOL>url = self.create_or_update_ownership_identifier.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", domain_name, '<STR_LIT:str>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(domain_ownership_identifier, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates an ownership identifier for a domain or updates identifier\n        details for an existing identifer.\n\n        Creates an ownership identifier for a domain or updates identifier\n        details for an existing identifer.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param domain_name: Name of domain.\n        :type domain_name: str\n        :param name: Name of identifier.\n        :type name: str\n        :param kind: Kind of resource.\n        :type kind: str\n        :param ownership_id: Ownership Id.\n        :type ownership_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DomainOwnershipIdentifier or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.DomainOwnershipIdentifier or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44985:c0:m13"}
{"signature": "def resend_request_emails(<EOL>self, resource_group_name, certificate_order_name, name=None, custom_headers=None, raw=False, **operation_config):", "body": "name_identifier = models.NameIdentifier(name=name)<EOL>url = self.resend_request_emails.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", certificate_order_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(name_identifier, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Verify domain ownership for this certificate order.\n\n        Verify domain ownership for this certificate order.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param certificate_order_name: Name of the certificate order.\n        :type certificate_order_name: str\n        :param name: Name of the object.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44986:c0:m18"}
{"signature": "def delete(<EOL>self, resource_group_name, certificate_order_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", certificate_order_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Delete an existing certificate order.\n\n        Delete an existing certificate order.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param certificate_order_name: Name of the certificate order.\n        :type certificate_order_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44986:c0:m7"}
{"signature": "def reissue(<EOL>self, resource_group_name, certificate_order_name, reissue_certificate_order_request, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.reissue.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", certificate_order_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(reissue_certificate_order_request, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Reissue an existing certificate order.\n\n        Reissue an existing certificate order.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param certificate_order_name: Name of the certificate order.\n        :type certificate_order_name: str\n        :param reissue_certificate_order_request: Parameters for the reissue.\n        :type reissue_certificate_order_request:\n         ~azure.mgmt.web.models.ReissueCertificateOrderRequest\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44986:c0:m15"}
{"signature": "def disable_recommendation_for_subscription(<EOL>self, name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.disable_recommendation_for_subscription.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Disables the specified rule so it will not apply to a subscription in\n        the future.\n\n        Disables the specified rule so it will not apply to a subscription in\n        the future.\n\n        :param name: Rule name\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44987:c0:m3"}
{"signature": "def disable_recommendation_for_hosting_environment(<EOL>self, resource_group_name, environment_name, name, hosting_environment_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.disable_recommendation_for_hosting_environment.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", hosting_environment_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", environment_name, '<STR_LIT:str>')<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Disables the specific rule for a web site permanently.\n\n        Disables the specific rule for a web site permanently.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param environment_name: Site name\n        :type environment_name: str\n        :param name: Rule name\n        :type name: str\n        :param hosting_environment_name:\n        :type hosting_environment_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44987:c0:m9"}
{"signature": "def delete_instance_process(<EOL>self, resource_group_name, name, process_id, instance_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete_instance_process.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", process_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", instance_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Terminate a process by its ID for a web site, or a deployment slot, or\n        specific scaled-out instance in a web site.\n\n        Terminate a process by its ID for a web site, or a deployment slot, or\n        specific scaled-out instance in a web site.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Site name.\n        :type name: str\n        :param process_id: PID.\n        :type process_id: str\n        :param instance_id: ID of a specific scaled-out instance. This is the\n         value of the name property in the JSON response from \"GET\n         api/sites/{siteName}/instances\".\n        :type instance_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44988:c0:m96"}
{"signature": "def list_sync_function_triggers_slot(<EOL>self, resource_group_name, name, slot, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_sync_function_triggers_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "This is to allow calling via powershell and ARM template.\n\n        This is to allow calling via powershell and ARM template.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param slot: Name of the deployment slot. If a slot is not specified,\n         the API will restore a backup of the production slot.\n        :type slot: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: FunctionSecrets or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.FunctionSecrets or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m259"}
{"signature": "def start_network_trace_slot(<EOL>self, resource_group_name, name, slot, duration_in_seconds=None, max_frame_length=None, sas_url=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._start_network_trace_slot_initial(<EOL>resource_group_name=resource_group_name,<EOL>name=name,<EOL>slot=slot,<EOL>duration_in_seconds=duration_in_seconds,<EOL>max_frame_length=max_frame_length,<EOL>sas_url=sas_url,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Start capturing network packets for the site.\n\n        Start capturing network packets for the site.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: The name of the web app.\n        :type name: str\n        :param slot: The name of the slot for this web app.\n        :type slot: str\n        :param duration_in_seconds: The duration to keep capturing in seconds.\n        :type duration_in_seconds: int\n        :param max_frame_length: The maximum frame length in bytes (Optional).\n        :type max_frame_length: int\n        :param sas_url: The Blob URL to store capture file.\n        :type sas_url: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns list or\n         ClientRawResponse<list> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[list[~azure.mgmt.web.models.NetworkTrace]]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[list[~azure.mgmt.web.models.NetworkTrace]]]\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m324"}
{"signature": "def list_function_secrets(<EOL>self, resource_group_name, name, function_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_function_secrets.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", function_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get function secrets for a function in a web site, or a deployment\n        slot.\n\n        Get function secrets for a function in a web site, or a deployment\n        slot.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Site name.\n        :type name: str\n        :param function_name: Function name.\n        :type function_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: FunctionSecrets or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.FunctionSecrets or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m73"}
{"signature": "def sync_repository(<EOL>self, resource_group_name, name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.sync_repository.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Sync web app repository.\n\n        Sync web app repository.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of web app.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44988:c0:m361"}
{"signature": "def list_continuous_web_jobs_slot(<EOL>self, resource_group_name, name, slot, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_continuous_web_jobs_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ContinuousWebJobPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ContinuousWebJobPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List continuous web jobs for an app, or a deployment slot.\n\n        List continuous web jobs for an app, or a deployment slot.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Site name.\n        :type name: str\n        :param slot: Name of the deployment slot. If a slot is not specified,\n         the API deletes a deployment for the production slot.\n        :type slot: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ContinuousWebJob\n        :rtype:\n         ~azure.mgmt.web.models.ContinuousWebJobPaged[~azure.mgmt.web.models.ContinuousWebJob]\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m203"}
{"signature": "def get_ms_deploy_status_slot(<EOL>self, resource_group_name, name, slot, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_ms_deploy_status_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the status of the last MSDeploy operation.\n\n        Get the status of the last MSDeploy operation.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of web app.\n        :type name: str\n        :param slot: Name of web app slot. If not specified then will default\n         to production slot.\n        :type slot: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: MSDeployStatus or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.MSDeployStatus or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m219"}
{"signature": "def create_or_update_vnet_connection_slot(<EOL>self, resource_group_name, name, vnet_name, connection_envelope, slot, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update_vnet_connection_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vnet_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(connection_envelope, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Adds a Virtual Network connection to an app or slot (PUT) or updates\n        the connection properties (PATCH).\n\n        Adds a Virtual Network connection to an app or slot (PUT) or updates\n        the connection properties (PATCH).\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param vnet_name: Name of an existing Virtual Network.\n        :type vnet_name: str\n        :param connection_envelope: Properties of the Virtual Network\n         connection. See example.\n        :type connection_envelope: ~azure.mgmt.web.models.VnetInfo\n        :param slot: Name of the deployment slot. If a slot is not specified,\n         the API will add or update connections for the production slot.\n        :type slot: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VnetInfo or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.VnetInfo or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m338"}
{"signature": "def swap_slot_slot(<EOL>self, resource_group_name, name, slot, target_slot, preserve_vnet, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._swap_slot_slot_initial(<EOL>resource_group_name=resource_group_name,<EOL>name=name,<EOL>slot=slot,<EOL>target_slot=target_slot,<EOL>preserve_vnet=preserve_vnet,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Swaps two deployment slots of an app.\n\n        Swaps two deployment slots of an app.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param slot: Name of the source slot. If a slot is not specified, the\n         production slot is used as the source slot.\n        :type slot: str\n        :param target_slot: Destination deployment slot during swap operation.\n        :type target_slot: str\n        :param preserve_vnet: <code>true</code> to preserve Virtual Network to\n         the slot during swap; otherwise, <code>false</code>.\n        :type preserve_vnet: bool\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44988:c0:m314"}
{"signature": "def list_metric_definitions(<EOL>self, resource_group_name, name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_metric_definitions.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ResourceMetricDefinitionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ResourceMetricDefinitionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all metric definitions of an app (or deployment slot, if\n        specified).\n\n        Gets all metric definitions of an app (or deployment slot, if\n        specified).\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ResourceMetricDefinition\n        :rtype:\n         ~azure.mgmt.web.models.ResourceMetricDefinitionPaged[~azure.mgmt.web.models.ResourceMetricDefinition]\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m104"}
{"signature": "def list_snapshots_from_dr_secondary(<EOL>self, resource_group_name, name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_snapshots_from_dr_secondary.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SnapshotPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SnapshotPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Returns all Snapshots to the user from DRSecondary endpoint.\n\n        Returns all Snapshots to the user from DRSecondary endpoint.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Website Name.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Snapshot\n        :rtype:\n         ~azure.mgmt.web.models.SnapshotPaged[~azure.mgmt.web.models.Snapshot]\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m350"}
{"signature": "def list_deployment_log_slot(<EOL>self, resource_group_name, name, id, slot, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_deployment_log_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT:id>': self._serialize.url(\"<STR_LIT:id>\", id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List deployment log for specific deployment for an app, or a deployment\n        slot.\n\n        List deployment log for specific deployment for an app, or a deployment\n        slot.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param id: The ID of a specific deployment. This is the value of the\n         name property in the JSON response from \"GET\n         /api/sites/{siteName}/deployments\".\n        :type id: str\n        :param slot: Name of the deployment slot. If a slot is not specified,\n         the API returns deployments for the production slot.\n        :type slot: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Deployment or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.Deployment or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m212"}
{"signature": "def list_metadata(<EOL>self, resource_group_name, name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_metadata.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the metadata of an app.\n\n        Gets the metadata of an app.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: StringDictionary or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.StringDictionary or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m32"}
{"signature": "def list_web_jobs_slot(<EOL>self, resource_group_name, name, slot, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_web_jobs_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.WebJobPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.WebJobPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List webjobs for an app, or a deployment slot.\n\n        List webjobs for an app, or a deployment slot.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Site name.\n        :type name: str\n        :param slot: Name of the deployment slot. If a slot is not specified,\n         the API returns deployments for the production slot.\n        :type slot: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of WebJob\n        :rtype:\n         ~azure.mgmt.web.models.WebJobPaged[~azure.mgmt.web.models.WebJob]\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m344"}
{"signature": "def update_premier_add_on_slot(<EOL>self, resource_group_name, name, premier_add_on_name, premier_add_on, slot, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.update_premier_add_on_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", premier_add_on_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(premier_add_on, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Updates a named add-on of an app.\n\n        Updates a named add-on of an app.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param premier_add_on_name: Add-on name.\n        :type premier_add_on_name: str\n        :param premier_add_on: A JSON representation of the edited premier\n         add-on.\n        :type premier_add_on: ~azure.mgmt.web.models.PremierAddOnPatchResource\n        :param slot: Name of the deployment slot. If a slot is not specified,\n         the API will update the named add-on for the production slot.\n        :type slot: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PremierAddOn or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.PremierAddOn or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m283"}
{"signature": "def list_slots(<EOL>self, resource_group_name, name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_slots.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SitePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SitePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets an app's deployment slots.\n\n        Gets an app's deployment slots.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Site\n        :rtype: ~azure.mgmt.web.models.SitePaged[~azure.mgmt.web.models.Site]\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m160"}
{"signature": "def delete_backup_slot(<EOL>self, resource_group_name, name, backup_id, slot, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete_backup_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", backup_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes a backup of an app by its ID.\n\n        Deletes a backup of an app by its ID.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param backup_id: ID of the backup.\n        :type backup_id: str\n        :param slot: Name of the deployment slot. If a slot is not specified,\n         the API will delete a backup of the production slot.\n        :type slot: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44988:c0:m171"}
{"signature": "def list_site_push_settings_slot(<EOL>self, resource_group_name, name, slot, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_site_push_settings_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the Push settings associated with web app.\n\n        Gets the Push settings associated with web app.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of web app.\n        :type name: str\n        :param slot: Name of web app slot. If not specified then will default\n         to production slot.\n        :type slot: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PushSettings or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.PushSettings or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m194"}
{"signature": "def get_triggered_web_job_history_slot(<EOL>self, resource_group_name, name, web_job_name, id, slot, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_triggered_web_job_history_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", web_job_name, '<STR_LIT:str>'),<EOL>'<STR_LIT:id>': self._serialize.url(\"<STR_LIT:id>\", id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a triggered web job's history by its ID for an app, , or a\n        deployment slot.\n\n        Gets a triggered web job's history by its ID for an app, , or a\n        deployment slot.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Site name.\n        :type name: str\n        :param web_job_name: Name of Web Job.\n        :type web_job_name: str\n        :param id: History ID.\n        :type id: str\n        :param slot: Name of the deployment slot. If a slot is not specified,\n         the API deletes a deployment for the production slot.\n        :type slot: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: TriggeredJobHistory or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.TriggeredJobHistory or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44988:c0:m333"}
{"signature": "def list_deployments(<EOL>self, resource_group_name, name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_deployments.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.DeploymentPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.DeploymentPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List deployments for an app, or a deployment slot.\n\n        List deployments for an app, or a deployment slot.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Deployment\n        :rtype:\n         ~azure.mgmt.web.models.DeploymentPaged[~azure.mgmt.web.models.Deployment]\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m52"}
{"signature": "def stop_network_trace(<EOL>self, resource_group_name, name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.stop_network_trace.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Stop ongoing capturing network packets for the site.\n\n        Stop ongoing capturing network packets for the site.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: The name of the web app.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44988:c0:m360"}
{"signature": "def list_connection_strings_slot(<EOL>self, resource_group_name, name, slot, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_connection_strings_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the connection strings of an app.\n\n        Gets the connection strings of an app.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param slot: Name of the deployment slot. If a slot is not specified,\n         the API will get the connection settings for the production slot.\n        :type slot: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ConnectionStringDictionary or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.ConnectionStringDictionary or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m186"}
{"signature": "def put_private_access_vnet(<EOL>self, resource_group_name, name, access, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.put_private_access_vnet.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(access, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Sets data around private site access enablement and authorized Virtual\n        Networks that can access the site.\n\n        Sets data around private site access enablement and authorized Virtual\n        Networks that can access the site.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: The name of the web app.\n        :type name: str\n        :param access: The information for the private access\n        :type access: ~azure.mgmt.web.models.PrivateAccess\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PrivateAccess or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.PrivateAccess or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m133"}
{"signature": "def list_web_jobs(<EOL>self, resource_group_name, name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_web_jobs.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.WebJobPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.WebJobPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List webjobs for an app, or a deployment slot.\n\n        List webjobs for an app, or a deployment slot.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Site name.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of WebJob\n        :rtype:\n         ~azure.mgmt.web.models.WebJobPaged[~azure.mgmt.web.models.WebJob]\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m378"}
{"signature": "def create_deployment_slot(<EOL>self, resource_group_name, name, id, slot, deployment, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_deployment_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT:id>': self._serialize.url(\"<STR_LIT:id>\", id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(deployment, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Create a deployment for an app, or a deployment slot.\n\n        Create a deployment for an app, or a deployment slot.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param id: ID of an existing deployment.\n        :type id: str\n        :param slot: Name of the deployment slot. If a slot is not specified,\n         the API creates a deployment for the production slot.\n        :type slot: str\n        :param deployment: Deployment details.\n        :type deployment: ~azure.mgmt.web.models.Deployment\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Deployment or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.Deployment or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m210"}
{"signature": "def update_domain_ownership_identifier(<EOL>self, resource_group_name, name, domain_ownership_identifier_name, kind=None, identifier_id=None, custom_headers=None, raw=False, **operation_config):", "body": "domain_ownership_identifier = models.Identifier(kind=kind, identifier_id=identifier_id)<EOL>url = self.update_domain_ownership_identifier.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", domain_ownership_identifier_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(domain_ownership_identifier, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates a domain ownership identifier for web app, or updates an\n        existing ownership identifier.\n\n        Creates a domain ownership identifier for web app, or updates an\n        existing ownership identifier.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param domain_ownership_identifier_name: Name of domain ownership\n         identifier.\n        :type domain_ownership_identifier_name: str\n        :param kind: Kind of resource.\n        :type kind: str\n        :param identifier_id: String representation of the identity.\n        :type identifier_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Identifier or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.Identifier or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m62"}
{"signature": "def list_relay_service_connections_slot(<EOL>self, resource_group_name, name, slot, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_relay_service_connections_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets hybrid connections configured for an app (or deployment slot, if\n        specified).\n\n        Gets hybrid connections configured for an app (or deployment slot, if\n        specified).\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param slot: Name of the deployment slot. If a slot is not specified,\n         the API will get hybrid connections for the production slot.\n        :type slot: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RelayServiceConnectionEntity or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.RelayServiceConnectionEntity or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m240"}
{"signature": "def update_slot_configuration_names(<EOL>self, resource_group_name, name, slot_config_names, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.update_slot_configuration_names.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(slot_config_names, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Updates the names of application settings and connection string that\n        remain with the slot during swap operation.\n\n        Updates the names of application settings and connection string that\n        remain with the slot during swap operation.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param slot_config_names: Names of application settings and connection\n         strings. See example.\n        :type slot_config_names:\n         ~azure.mgmt.web.models.SlotConfigNamesResource\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SlotConfigNamesResource or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.SlotConfigNamesResource or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m38"}
{"signature": "def update_premier_add_on(<EOL>self, resource_group_name, name, premier_add_on_name, premier_add_on, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.update_premier_add_on.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", premier_add_on_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(premier_add_on, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Updates a named add-on of an app.\n\n        Updates a named add-on of an app.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param premier_add_on_name: Add-on name.\n        :type premier_add_on_name: str\n        :param premier_add_on: A JSON representation of the edited premier\n         add-on.\n        :type premier_add_on: ~azure.mgmt.web.models.PremierAddOnPatchResource\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PremierAddOn or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.PremierAddOn or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m131"}
{"signature": "def start_web_site_network_trace(<EOL>self, resource_group_name, name, duration_in_seconds=None, max_frame_length=None, sas_url=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.start_web_site_network_trace.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if duration_in_seconds is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", duration_in_seconds, '<STR_LIT:int>')<EOL><DEDENT>if max_frame_length is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", max_frame_length, '<STR_LIT:int>')<EOL><DEDENT>if sas_url is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", sas_url, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT:str>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Start capturing network packets for the site (To be deprecated).\n\n        Start capturing network packets for the site (To be deprecated).\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: The name of the web app.\n        :type name: str\n        :param duration_in_seconds: The duration to keep capturing in seconds.\n        :type duration_in_seconds: int\n        :param max_frame_length: The maximum frame length in bytes (Optional).\n        :type max_frame_length: int\n        :param sas_url: The Blob URL to store capture file.\n        :type sas_url: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: str or ClientRawResponse if raw=true\n        :rtype: str or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m117"}
{"signature": "def delete_relay_service_connection_slot(<EOL>self, resource_group_name, name, entity_name, slot, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete_relay_service_connection_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", entity_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes a relay service connection by its name.\n\n        Deletes a relay service connection by its name.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param entity_name: Name of the hybrid connection configuration.\n        :type entity_name: str\n        :param slot: Name of the deployment slot. If a slot is not specified,\n         the API will delete a hybrid connection for the production slot.\n        :type slot: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44988:c0:m243"}
{"signature": "def get_hybrid_connection_slot(<EOL>self, resource_group_name, name, namespace_name, relay_name, slot, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_hybrid_connection_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", relay_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieves a specific Service Bus Hybrid Connection used by this Web\n        App.\n\n        Retrieves a specific Service Bus Hybrid Connection used by this Web\n        App.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: The name of the web app.\n        :type name: str\n        :param namespace_name: The namespace for this hybrid connection.\n        :type namespace_name: str\n        :param relay_name: The relay name for this hybrid connection.\n        :type relay_name: str\n        :param slot: The name of the slot for the web app.\n        :type slot: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: HybridConnection or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.HybridConnection or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m234"}
{"signature": "def delete_public_certificate_slot(<EOL>self, resource_group_name, name, slot, public_certificate_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete_public_certificate_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", public_certificate_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes a hostname binding for an app.\n\n        Deletes a hostname binding for an app.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param slot: Name of the deployment slot. If a slot is not specified,\n         the API will delete the binding for the production slot.\n        :type slot: str\n        :param public_certificate_name: Public certificate name.\n        :type public_certificate_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44988:c0:m297"}
{"signature": "def list_application_settings(<EOL>self, resource_group_name, name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_application_settings.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the application settings of an app.\n\n        Gets the application settings of an app.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: StringDictionary or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.StringDictionary or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m19"}
{"signature": "def get_process_thread(<EOL>self, resource_group_name, name, process_id, thread_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_process_thread.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", process_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", thread_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get thread information by Thread ID for a specific process, in a\n        specific scaled-out instance in a web site.\n\n        Get thread information by Thread ID for a specific process, in a\n        specific scaled-out instance in a web site.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Site name.\n        :type name: str\n        :param process_id: PID.\n        :type process_id: str\n        :param thread_id: TID.\n        :type thread_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ProcessThreadInfo or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.ProcessThreadInfo or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44988:c0:m141"}
{"signature": "def list_process_threads_slot(<EOL>self, resource_group_name, name, process_id, slot, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_process_threads_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", process_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ProcessThreadInfoPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ProcessThreadInfoPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List the threads in a process by its ID for a specific scaled-out\n        instance in a web site.\n\n        List the threads in a process by its ID for a specific scaled-out\n        instance in a web site.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Site name.\n        :type name: str\n        :param process_id: PID.\n        :type process_id: str\n        :param slot: Name of the deployment slot. If a slot is not specified,\n         the API returns deployments for the production slot.\n        :type slot: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ProcessThreadInfo\n        :rtype:\n         ~azure.mgmt.web.models.ProcessThreadInfoPaged[~azure.mgmt.web.models.ProcessThreadInfo]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44988:c0:m292"}
{"signature": "def list_triggered_web_job_history(<EOL>self, resource_group_name, name, web_job_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_triggered_web_job_history.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", web_job_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.TriggeredJobHistoryPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.TriggeredJobHistoryPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List a triggered web job's history for an app, or a deployment slot.\n\n        List a triggered web job's history for an app, or a deployment slot.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Site name.\n        :type name: str\n        :param web_job_name: Name of Web Job.\n        :type web_job_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of TriggeredJobHistory\n        :rtype:\n         ~azure.mgmt.web.models.TriggeredJobHistoryPaged[~azure.mgmt.web.models.TriggeredJobHistory]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44988:c0:m366"}
{"signature": "def list_application_settings_slot(<EOL>self, resource_group_name, name, slot, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_application_settings_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the application settings of an app.\n\n        Gets the application settings of an app.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param slot: Name of the deployment slot. If a slot is not specified,\n         the API will get the application settings for the production slot.\n        :type slot: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: StringDictionary or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.StringDictionary or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m177"}
{"signature": "def get_migrate_my_sql_status(<EOL>self, resource_group_name, name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_migrate_my_sql_status.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Returns the status of MySql in app migration, if one is active, and\n        whether or not MySql in app is enabled.\n\n        Returns the status of MySql in app migration, if one is active, and\n        whether or not MySql in app is enabled.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of web app.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: MigrateMySqlStatus or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.MigrateMySqlStatus or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m110"}
{"signature": "def create_or_update_domain_ownership_identifier_slot(<EOL>self, resource_group_name, name, domain_ownership_identifier_name, slot, kind=None, identifier_id=None, custom_headers=None, raw=False, **operation_config):", "body": "domain_ownership_identifier = models.Identifier(kind=kind, identifier_id=identifier_id)<EOL>url = self.create_or_update_domain_ownership_identifier_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", domain_ownership_identifier_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(domain_ownership_identifier, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates a domain ownership identifier for web app, or updates an\n        existing ownership identifier.\n\n        Creates a domain ownership identifier for web app, or updates an\n        existing ownership identifier.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param domain_ownership_identifier_name: Name of domain ownership\n         identifier.\n        :type domain_ownership_identifier_name: str\n        :param slot: Name of the deployment slot. If a slot is not specified,\n         the API will delete the binding for the production slot.\n        :type slot: str\n        :param kind: Kind of resource.\n        :type kind: str\n        :param identifier_id: String representation of the identity.\n        :type identifier_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Identifier or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.Identifier or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m216"}
{"signature": "def start_web_site_network_trace_operation_slot(<EOL>self, resource_group_name, name, slot, duration_in_seconds=None, max_frame_length=None, sas_url=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._start_web_site_network_trace_operation_slot_initial(<EOL>resource_group_name=resource_group_name,<EOL>name=name,<EOL>slot=slot,<EOL>duration_in_seconds=duration_in_seconds,<EOL>max_frame_length=max_frame_length,<EOL>sas_url=sas_url,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Start capturing network packets for the site.\n\n        Start capturing network packets for the site.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: The name of the web app.\n        :type name: str\n        :param slot: The name of the slot for this web app.\n        :type slot: str\n        :param duration_in_seconds: The duration to keep capturing in seconds.\n        :type duration_in_seconds: int\n        :param max_frame_length: The maximum frame length in bytes (Optional).\n        :type max_frame_length: int\n        :param sas_url: The Blob URL to store capture file.\n        :type sas_url: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns list or\n         ClientRawResponse<list> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[list[~azure.mgmt.web.models.NetworkTrace]]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[list[~azure.mgmt.web.models.NetworkTrace]]]\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m271"}
{"signature": "def get_private_access_slot(<EOL>self, resource_group_name, name, slot, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_private_access_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets data around private site access enablement and authorized Virtual\n        Networks that can access the site.\n\n        Gets data around private site access enablement and authorized Virtual\n        Networks that can access the site.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: The name of the web app.\n        :type name: str\n        :param slot: The name of the slot for the web app.\n        :type slot: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PrivateAccess or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.PrivateAccess or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m284"}
{"signature": "def list_public_certificates(<EOL>self, resource_group_name, name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_public_certificates.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PublicCertificatePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PublicCertificatePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get public certificates for an app or a deployment slot.\n\n        Get public certificates for an app or a deployment slot.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PublicCertificate\n        :rtype:\n         ~azure.mgmt.web.models.PublicCertificatePaged[~azure.mgmt.web.models.PublicCertificate]\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m142"}
{"signature": "def get_instance_process_slot(<EOL>self, resource_group_name, name, process_id, slot, instance_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_instance_process_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", process_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", instance_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get process information by its ID for a specific scaled-out instance in\n        a web site.\n\n        Get process information by its ID for a specific scaled-out instance in\n        a web site.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Site name.\n        :type name: str\n        :param process_id: PID.\n        :type process_id: str\n        :param slot: Name of the deployment slot. If a slot is not specified,\n         the API returns deployments for the production slot.\n        :type slot: str\n        :param instance_id: ID of a specific scaled-out instance. This is the\n         value of the name property in the JSON response from \"GET\n         api/sites/{siteName}/instances\".\n        :type instance_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ProcessInfo or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.ProcessInfo or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44988:c0:m251"}
{"signature": "def get_configuration_snapshot_slot(<EOL>self, resource_group_name, name, snapshot_id, slot, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_configuration_snapshot_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", snapshot_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a snapshot of the configuration of an app at a previous point in\n        time.\n\n        Gets a snapshot of the configuration of an app at a previous point in\n        time.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param snapshot_id: The ID of the snapshot to read.\n        :type snapshot_id: str\n        :param slot: Name of the deployment slot. If a slot is not specified,\n         the API will return configuration for the production slot.\n        :type slot: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SiteConfigResource or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.SiteConfigResource or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m199"}
{"signature": "def list_perf_mon_counters(<EOL>self, resource_group_name, name, filter=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_perf_mon_counters.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>', skip_quote=True)<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PerfMonResponsePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PerfMonResponsePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets perfmon counters for web app.\n\n        Gets perfmon counters for web app.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of web app.\n        :type name: str\n        :param filter: Return only usages/metrics specified in the filter.\n         Filter conforms to odata syntax. Example: $filter=(startTime eq\n         2014-01-01T00:00:00Z and endTime eq 2014-12-31T23:59:59Z and timeGrain\n         eq duration'[Hour|Minute|Day]'.\n        :type filter: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PerfMonResponse\n        :rtype:\n         ~azure.mgmt.web.models.PerfMonResponsePaged[~azure.mgmt.web.models.PerfMonResponse]\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m125"}
{"signature": "def restore_snapshot_slot(<EOL>self, resource_group_name, name, restore_request, slot, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._restore_snapshot_slot_initial(<EOL>resource_group_name=resource_group_name,<EOL>name=name,<EOL>restore_request=restore_request,<EOL>slot=slot,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Restores a web app from a snapshot.\n\n        Restores a web app from a snapshot.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of web app.\n        :type name: str\n        :param restore_request: Snapshot restore settings. Snapshot\n         information can be obtained by calling GetDeletedSites or\n         GetSiteSnapshots API.\n        :type restore_request: ~azure.mgmt.web.models.SnapshotRestoreRequest\n        :param slot: Name of web app slot. If not specified then will default\n         to production slot.\n        :type slot: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44988:c0:m306"}
{"signature": "def get_premier_add_on_slot(<EOL>self, resource_group_name, name, premier_add_on_name, slot, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_premier_add_on_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", premier_add_on_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a named add-on of an app.\n\n        Gets a named add-on of an app.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param premier_add_on_name: Add-on name.\n        :type premier_add_on_name: str\n        :param slot: Name of the deployment slot. If a slot is not specified,\n         the API will get the named add-on for the production slot.\n        :type slot: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PremierAddOn or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.PremierAddOn or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m280"}
{"signature": "def list_publishing_profile_xml_with_secrets_slot(<EOL>self, resource_group_name, name, slot, format=None, include_disaster_recovery_endpoints=None, custom_headers=None, raw=False, callback=None, **operation_config):", "body": "publishing_profile_options = models.CsmPublishingProfileOptions(format=format, include_disaster_recovery_endpoints=include_disaster_recovery_endpoints)<EOL>url = self.list_publishing_profile_xml_with_secrets_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(publishing_profile_options, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=True, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._client.stream_download(response, callback)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the publishing profile for an app (or deployment slot, if\n        specified).\n\n        Gets the publishing profile for an app (or deployment slot, if\n        specified).\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param slot: Name of the deployment slot. If a slot is not specified,\n         the API will get the publishing profile for the production slot.\n        :type slot: str\n        :param format: Name of the format. Valid values are:\n         FileZilla3\n         WebDeploy -- default\n         Ftp. Possible values include: 'FileZilla3', 'WebDeploy', 'Ftp'\n        :type format: str or ~azure.mgmt.web.models.PublishingProfileFormat\n        :param include_disaster_recovery_endpoints: Include the\n         DisasterRecover endpoint if true\n        :type include_disaster_recovery_endpoints: bool\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param callback: When specified, will be called with each chunk of\n         data that is streamed. The callback should take two arguments, the\n         bytes of the current chunk of data and the response object. If the\n         data is uploading, response will be None.\n        :type callback: Callable[Bytes, response=None]\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: object or ClientRawResponse if raw=true\n        :rtype: Generator or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m298"}
{"signature": "def list_hybrid_connection_keys_slot(<EOL>self, resource_group_name, name, namespace_name, relay_name, slot, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_hybrid_connection_keys_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", relay_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the send key name and value for a Hybrid Connection.\n\n        Gets the send key name and value for a Hybrid Connection.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: The name of the web app.\n        :type name: str\n        :param namespace_name: The namespace for this hybrid connection.\n        :type namespace_name: str\n        :param relay_name: The relay name for this hybrid connection.\n        :type relay_name: str\n        :param slot: The name of the slot for the web app.\n        :type slot: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: HybridConnectionKey or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.HybridConnectionKey or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m238"}
{"signature": "def update_vnet_connection_slot(<EOL>self, resource_group_name, name, vnet_name, connection_envelope, slot, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.update_vnet_connection_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vnet_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(connection_envelope, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Adds a Virtual Network connection to an app or slot (PUT) or updates\n        the connection properties (PATCH).\n\n        Adds a Virtual Network connection to an app or slot (PUT) or updates\n        the connection properties (PATCH).\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param vnet_name: Name of an existing Virtual Network.\n        :type vnet_name: str\n        :param connection_envelope: Properties of the Virtual Network\n         connection. See example.\n        :type connection_envelope: ~azure.mgmt.web.models.VnetInfo\n        :param slot: Name of the deployment slot. If a slot is not specified,\n         the API will add or update connections for the production slot.\n        :type slot: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VnetInfo or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.VnetInfo or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m340"}
{"signature": "def delete_backup_configuration(<EOL>self, resource_group_name, name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete_backup_configuration.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes the backup configuration of an app.\n\n        Deletes the backup configuration of an app.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44988:c0:m25"}
{"signature": "def create_ms_deploy_operation_slot(<EOL>self, resource_group_name, name, slot, ms_deploy, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_ms_deploy_operation_slot_initial(<EOL>resource_group_name=resource_group_name,<EOL>name=name,<EOL>slot=slot,<EOL>ms_deploy=ms_deploy,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Invoke the MSDeploy web app extension.\n\n        Invoke the MSDeploy web app extension.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of web app.\n        :type name: str\n        :param slot: Name of web app slot. If not specified then will default\n         to production slot.\n        :type slot: str\n        :param ms_deploy: Details of MSDeploy operation\n        :type ms_deploy: ~azure.mgmt.web.models.MSDeploy\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns MSDeployStatus or\n         ClientRawResponse<MSDeployStatus> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.web.models.MSDeployStatus]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.web.models.MSDeployStatus]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44988:c0:m221"}
{"signature": "def get_triggered_web_job(<EOL>self, resource_group_name, name, web_job_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_triggered_web_job.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", web_job_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a triggered web job by its ID for an app, or a deployment slot.\n\n        Gets a triggered web job by its ID for an app, or a deployment slot.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Site name.\n        :type name: str\n        :param web_job_name: Name of Web Job.\n        :type web_job_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: TriggeredWebJob or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.TriggeredWebJob or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44988:c0:m364"}
{"signature": "def update_connection_strings(<EOL>self, resource_group_name, name, kind=None, properties=None, custom_headers=None, raw=False, **operation_config):", "body": "connection_strings = models.ConnectionStringDictionary(kind=kind, properties=properties)<EOL>url = self.update_connection_strings.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(connection_strings, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Replaces the connection strings of an app.\n\n        Replaces the connection strings of an app.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param kind: Kind of resource.\n        :type kind: str\n        :param properties: Connection strings.\n        :type properties: dict[str,\n         ~azure.mgmt.web.models.ConnStringValueTypePair]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ConnectionStringDictionary or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.ConnectionStringDictionary or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m27"}
{"signature": "def install_site_extension_slot(<EOL>self, resource_group_name, name, site_extension_id, slot, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._install_site_extension_slot_initial(<EOL>resource_group_name=resource_group_name,<EOL>name=name,<EOL>site_extension_id=site_extension_id,<EOL>slot=slot,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Install site extension on a web site, or a deployment slot.\n\n        Install site extension on a web site, or a deployment slot.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Site name.\n        :type name: str\n        :param site_extension_id: Site extension name.\n        :type site_extension_id: str\n        :param slot: Name of the deployment slot. If a slot is not specified,\n         the API deletes a deployment for the production slot.\n        :type slot: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns SiteExtensionInfo or\n         ClientRawResponse<SiteExtensionInfo> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.web.models.SiteExtensionInfo]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.web.models.SiteExtensionInfo]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44988:c0:m310"}
{"signature": "def get_public_certificate(<EOL>self, resource_group_name, name, public_certificate_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_public_certificate.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", public_certificate_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the named public certificate for an app (or deployment slot, if\n        specified).\n\n        Get the named public certificate for an app (or deployment slot, if\n        specified).\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param public_certificate_name: Public certificate name.\n        :type public_certificate_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PublicCertificate or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.PublicCertificate or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m143"}
{"signature": "def create_or_update_public_certificate_slot(<EOL>self, resource_group_name, name, public_certificate_name, public_certificate, slot, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update_public_certificate_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", public_certificate_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(public_certificate, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates a hostname binding for an app.\n\n        Creates a hostname binding for an app.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param public_certificate_name: Public certificate name.\n        :type public_certificate_name: str\n        :param public_certificate: Public certificate details. This is the\n         JSON representation of a PublicCertificate object.\n        :type public_certificate: ~azure.mgmt.web.models.PublicCertificate\n        :param slot: Name of the deployment slot. If a slot is not specified,\n         the API will create a binding for the production slot.\n        :type slot: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PublicCertificate or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.PublicCertificate or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m296"}
{"signature": "def create_or_update_public_certificate(<EOL>self, resource_group_name, name, public_certificate_name, public_certificate, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update_public_certificate.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", public_certificate_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(public_certificate, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates a hostname binding for an app.\n\n        Creates a hostname binding for an app.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param public_certificate_name: Public certificate name.\n        :type public_certificate_name: str\n        :param public_certificate: Public certificate details. This is the\n         JSON representation of a PublicCertificate object.\n        :type public_certificate: ~azure.mgmt.web.models.PublicCertificate\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PublicCertificate or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.PublicCertificate or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m144"}
{"signature": "def restore_slot(<EOL>self, resource_group_name, name, backup_id, request, slot, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._restore_slot_initial(<EOL>resource_group_name=resource_group_name,<EOL>name=name,<EOL>backup_id=backup_id,<EOL>request=request,<EOL>slot=slot,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Restores a specific backup to another app (or deployment slot, if\n        specified).\n\n        Restores a specific backup to another app (or deployment slot, if\n        specified).\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param backup_id: ID of the backup.\n        :type backup_id: str\n        :param request: Information on restore request .\n        :type request: ~azure.mgmt.web.models.RestoreRequest\n        :param slot: Name of the deployment slot. If a slot is not specified,\n         the API will restore a backup of the production slot.\n        :type slot: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44988:c0:m174"}
{"signature": "def add_premier_add_on(<EOL>self, resource_group_name, name, premier_add_on_name, premier_add_on, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.add_premier_add_on.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", premier_add_on_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(premier_add_on, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Updates a named add-on of an app.\n\n        Updates a named add-on of an app.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param premier_add_on_name: Add-on name.\n        :type premier_add_on_name: str\n        :param premier_add_on: A JSON representation of the edited premier\n         add-on.\n        :type premier_add_on: ~azure.mgmt.web.models.PremierAddOn\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PremierAddOn or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.PremierAddOn or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m129"}
{"signature": "def list_continuous_web_jobs(<EOL>self, resource_group_name, name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_continuous_web_jobs.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ContinuousWebJobPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ContinuousWebJobPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List continuous web jobs for an app, or a deployment slot.\n\n        List continuous web jobs for an app, or a deployment slot.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Site name.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ContinuousWebJob\n        :rtype:\n         ~azure.mgmt.web.models.ContinuousWebJobPaged[~azure.mgmt.web.models.ContinuousWebJob]\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m47"}
{"signature": "def get_instance_ms_deploy_status(<EOL>self, resource_group_name, name, instance_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_instance_ms_deploy_status.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", instance_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the status of the last MSDeploy operation.\n\n        Get the status of the last MSDeploy operation.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of web app.\n        :type name: str\n        :param instance_id: ID of web app instance.\n        :type instance_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: MSDeployStatus or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.MSDeployStatus or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m90"}
{"signature": "def create_or_update_host_name_binding(<EOL>self, resource_group_name, name, host_name, host_name_binding, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update_host_name_binding.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", host_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(host_name_binding, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates a hostname binding for an app.\n\n        Creates a hostname binding for an app.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param host_name: Hostname in the hostname binding.\n        :type host_name: str\n        :param host_name_binding: Binding details. This is the JSON\n         representation of a HostNameBinding object.\n        :type host_name_binding: ~azure.mgmt.web.models.HostNameBinding\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: HostNameBinding or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.HostNameBinding or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m76"}
{"signature": "def get_network_trace_operation_slot_v2(<EOL>self, resource_group_name, name, operation_id, slot, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_network_trace_operation_slot_v2.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", operation_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a named operation for a network trace capturing (or deployment\n        slot, if specified).\n\n        Gets a named operation for a network trace capturing (or deployment\n        slot, if specified).\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param operation_id: GUID of the operation.\n        :type operation_id: str\n        :param slot: Name of the deployment slot. If a slot is not specified,\n         the API will get an operation for the production slot.\n        :type slot: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype: list[~azure.mgmt.web.models.NetworkTrace] or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m274"}
{"signature": "def get_network_traces(<EOL>self, resource_group_name, name, operation_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_network_traces.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", operation_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a named operation for a network trace capturing (or deployment\n        slot, if specified).\n\n        Gets a named operation for a network trace capturing (or deployment\n        slot, if specified).\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param operation_id: GUID of the operation.\n        :type operation_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype: list[~azure.mgmt.web.models.NetworkTrace] or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m121"}
{"signature": "def list_snapshots(<EOL>self, resource_group_name, name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_snapshots.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SnapshotPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SnapshotPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Returns all Snapshots to the user.\n\n        Returns all Snapshots to the user.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Website Name.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Snapshot\n        :rtype:\n         ~azure.mgmt.web.models.SnapshotPaged[~azure.mgmt.web.models.Snapshot]\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m349"}
{"signature": "def get_configuration_snapshot(<EOL>self, resource_group_name, name, snapshot_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_configuration_snapshot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", snapshot_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a snapshot of the configuration of an app at a previous point in\n        time.\n\n        Gets a snapshot of the configuration of an app at a previous point in\n        time.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param snapshot_id: The ID of the snapshot to read.\n        :type snapshot_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SiteConfigResource or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.SiteConfigResource or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m43"}
{"signature": "def delete_backup_configuration_slot(<EOL>self, resource_group_name, name, slot, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete_backup_configuration_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes the backup configuration of an app.\n\n        Deletes the backup configuration of an app.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param slot: Name of the deployment slot. If a slot is not specified,\n         the API will delete the backup configuration for the production slot.\n        :type slot: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44988:c0:m183"}
{"signature": "def update_relay_service_connection_slot(<EOL>self, resource_group_name, name, entity_name, connection_envelope, slot, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.update_relay_service_connection_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", entity_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(connection_envelope, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates a new hybrid connection configuration (PUT), or updates an\n        existing one (PATCH).\n\n        Creates a new hybrid connection configuration (PUT), or updates an\n        existing one (PATCH).\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param entity_name: Name of the hybrid connection configuration.\n        :type entity_name: str\n        :param connection_envelope: Details of the hybrid connection\n         configuration.\n        :type connection_envelope:\n         ~azure.mgmt.web.models.RelayServiceConnectionEntity\n        :param slot: Name of the deployment slot. If a slot is not specified,\n         the API will create or update a hybrid connection for the production\n         slot.\n        :type slot: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RelayServiceConnectionEntity or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.RelayServiceConnectionEntity or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m244"}
{"signature": "def sync_function_triggers(<EOL>self, resource_group_name, name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.sync_function_triggers.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Syncs function trigger metadata to the scale controller.\n\n        Syncs function trigger metadata to the scale controller.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44988:c0:m362"}
{"signature": "def create_instance_ms_deploy_operation_slot(<EOL>self, resource_group_name, name, slot, instance_id, ms_deploy, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_instance_ms_deploy_operation_slot_initial(<EOL>resource_group_name=resource_group_name,<EOL>name=name,<EOL>slot=slot,<EOL>instance_id=instance_id,<EOL>ms_deploy=ms_deploy,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Invoke the MSDeploy web app extension.\n\n        Invoke the MSDeploy web app extension.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of web app.\n        :type name: str\n        :param slot: Name of web app slot. If not specified then will default\n         to production slot.\n        :type slot: str\n        :param instance_id: ID of web app instance.\n        :type instance_id: str\n        :param ms_deploy: Details of MSDeploy operation\n        :type ms_deploy: ~azure.mgmt.web.models.MSDeploy\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns MSDeployStatus or\n         ClientRawResponse<MSDeployStatus> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.web.models.MSDeployStatus]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.web.models.MSDeployStatus]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44988:c0:m248"}
{"signature": "def get_relay_service_connection(<EOL>self, resource_group_name, name, entity_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_relay_service_connection.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", entity_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a hybrid connection configuration by its name.\n\n        Gets a hybrid connection configuration by its name.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param entity_name: Name of the hybrid connection.\n        :type entity_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RelayServiceConnectionEntity or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.RelayServiceConnectionEntity or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m85"}
{"signature": "def list_usages_slot(<EOL>self, resource_group_name, name, slot, filter=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_usages_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>', skip_quote=True)<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.CsmUsageQuotaPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.CsmUsageQuotaPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the quota usage information of an app (or deployment slot, if\n        specified).\n\n        Gets the quota usage information of an app (or deployment slot, if\n        specified).\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param slot: Name of the deployment slot. If a slot is not specified,\n         the API will get quota information of the production slot.\n        :type slot: str\n        :param filter: Return only information specified in the filter (using\n         OData syntax). For example: $filter=(name.value eq 'Metric1' or\n         name.value eq 'Metric2') and startTime eq 2014-01-01T00:00:00Z and\n         endTime eq 2014-12-31T23:59:59Z and timeGrain eq\n         duration'[Hour|Minute|Day]'.\n        :type filter: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of CsmUsageQuota\n        :rtype:\n         ~azure.mgmt.web.models.CsmUsageQuotaPaged[~azure.mgmt.web.models.CsmUsageQuota]\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m335"}
{"signature": "def stop(<EOL>self, resource_group_name, name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.stop.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Stops an app (or deployment slot, if specified).\n\n        Stops an app (or deployment slot, if specified).\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44988:c0:m359"}
{"signature": "def update_vnet_connection_gateway(<EOL>self, resource_group_name, name, vnet_name, gateway_name, connection_envelope, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.update_vnet_connection_gateway.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vnet_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", gateway_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(connection_envelope, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Adds a gateway to a connected Virtual Network (PUT) or updates it\n        (PATCH).\n\n        Adds a gateway to a connected Virtual Network (PUT) or updates it\n        (PATCH).\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param vnet_name: Name of the Virtual Network.\n        :type vnet_name: str\n        :param gateway_name: Name of the gateway. Currently, the only\n         supported string is \"primary\".\n        :type gateway_name: str\n        :param connection_envelope: The properties to update this gateway\n         with.\n        :type connection_envelope: ~azure.mgmt.web.models.VnetGateway\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VnetGateway or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.VnetGateway or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m377"}
{"signature": "def update_azure_storage_accounts(<EOL>self, resource_group_name, name, kind=None, properties=None, custom_headers=None, raw=False, **operation_config):", "body": "azure_storage_accounts = models.AzureStoragePropertyDictionaryResource(kind=kind, properties=properties)<EOL>url = self.update_azure_storage_accounts.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(azure_storage_accounts, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Updates the Azure storage account configurations of an app.\n\n        Updates the Azure storage account configurations of an app.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param kind: Kind of resource.\n        :type kind: str\n        :param properties: Azure storage accounts.\n        :type properties: dict[str,\n         ~azure.mgmt.web.models.AzureStorageInfoValue]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: AzureStoragePropertyDictionaryResource or ClientRawResponse\n         if raw=true\n        :rtype: ~azure.mgmt.web.models.AzureStoragePropertyDictionaryResource\n         or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m22"}
{"signature": "def create_or_update_vnet_connection_gateway_slot(<EOL>self, resource_group_name, name, vnet_name, gateway_name, connection_envelope, slot, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update_vnet_connection_gateway_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", vnet_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", gateway_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(connection_envelope, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Adds a gateway to a connected Virtual Network (PUT) or updates it\n        (PATCH).\n\n        Adds a gateway to a connected Virtual Network (PUT) or updates it\n        (PATCH).\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param vnet_name: Name of the Virtual Network.\n        :type vnet_name: str\n        :param gateway_name: Name of the gateway. Currently, the only\n         supported string is \"primary\".\n        :type gateway_name: str\n        :param connection_envelope: The properties to update this gateway\n         with.\n        :type connection_envelope: ~azure.mgmt.web.models.VnetGateway\n        :param slot: Name of the deployment slot. If a slot is not specified,\n         the API will add or update a gateway for the production slot's Virtual\n         Network.\n        :type slot: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: VnetGateway or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.VnetGateway or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m342"}
{"signature": "def restart(<EOL>self, resource_group_name, name, soft_restart=None, synchronous=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.restart.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if soft_restart is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", soft_restart, '<STR_LIT:bool>')<EOL><DEDENT>if synchronous is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", synchronous, '<STR_LIT:bool>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Restarts an app (or deployment slot, if specified).\n\n        Restarts an app (or deployment slot, if specified).\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param soft_restart: Specify true to apply the configuration settings\n         and restarts the app only if necessary. By default, the API always\n         restarts and reprovisions the app.\n        :type soft_restart: bool\n        :param synchronous: Specify true to block until the app is restarted.\n         By default, it is set to false, and the API responds immediately\n         (asynchronous).\n        :type synchronous: bool\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44988:c0:m148"}
{"signature": "def list_vnet_connections(<EOL>self, resource_group_name, name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_vnet_connections.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the virtual networks the app (or deployment slot) is connected to.\n\n        Gets the virtual networks the app (or deployment slot) is connected to.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype: list[~azure.mgmt.web.models.VnetInfo] or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m370"}
{"signature": "def get_network_traces_slot_v2(<EOL>self, resource_group_name, name, operation_id, slot, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_network_traces_slot_v2.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", operation_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a named operation for a network trace capturing (or deployment\n        slot, if specified).\n\n        Gets a named operation for a network trace capturing (or deployment\n        slot, if specified).\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param operation_id: GUID of the operation.\n        :type operation_id: str\n        :param slot: Name of the deployment slot. If a slot is not specified,\n         the API will get an operation for the production slot.\n        :type slot: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype: list[~azure.mgmt.web.models.NetworkTrace] or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m275"}
{"signature": "def get_premier_add_on(<EOL>self, resource_group_name, name, premier_add_on_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_premier_add_on.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", premier_add_on_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a named add-on of an app.\n\n        Gets a named add-on of an app.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param premier_add_on_name: Add-on name.\n        :type premier_add_on_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PremierAddOn or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.PremierAddOn or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m128"}
{"signature": "def update_application_settings_slot(<EOL>self, resource_group_name, name, slot, kind=None, properties=None, custom_headers=None, raw=False, **operation_config):", "body": "app_settings = models.StringDictionary(kind=kind, properties=properties)<EOL>url = self.update_application_settings_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(app_settings, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Replaces the application settings of an app.\n\n        Replaces the application settings of an app.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param slot: Name of the deployment slot. If a slot is not specified,\n         the API will update the application settings for the production slot.\n        :type slot: str\n        :param kind: Kind of resource.\n        :type kind: str\n        :param properties: Settings.\n        :type properties: dict[str, str]\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: StringDictionary or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.StringDictionary or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m176"}
{"signature": "def delete_source_control_slot(<EOL>self, resource_group_name, name, slot, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete_source_control_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes the source control configuration of an app.\n\n        Deletes the source control configuration of an app.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param slot: Name of the deployment slot. If a slot is not specified,\n         the API will delete the source control configuration for the\n         production slot.\n        :type slot: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44988:c0:m320"}
{"signature": "def list_instance_process_modules_slot(<EOL>self, resource_group_name, name, process_id, slot, instance_id, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_instance_process_modules_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", process_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", instance_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ProcessModuleInfoPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ProcessModuleInfoPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List module information for a process by its ID for a specific\n        scaled-out instance in a web site.\n\n        List module information for a process by its ID for a specific\n        scaled-out instance in a web site.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Site name.\n        :type name: str\n        :param process_id: PID.\n        :type process_id: str\n        :param slot: Name of the deployment slot. If a slot is not specified,\n         the API returns deployments for the production slot.\n        :type slot: str\n        :param instance_id: ID of a specific scaled-out instance. This is the\n         value of the name property in the JSON response from \"GET\n         api/sites/{siteName}/instances\".\n        :type instance_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ProcessModuleInfo\n        :rtype:\n         ~azure.mgmt.web.models.ProcessModuleInfoPaged[~azure.mgmt.web.models.ProcessModuleInfo]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44988:c0:m254"}
{"signature": "def get_auth_settings_slot(<EOL>self, resource_group_name, name, slot, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_auth_settings_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the Authentication/Authorization settings of an app.\n\n        Gets the Authentication/Authorization settings of an app.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param slot: Name of the deployment slot. If a slot is not specified,\n         the API will get the settings for the production slot.\n        :type slot: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SiteAuthSettings or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.SiteAuthSettings or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m179"}
{"signature": "def get_backup_status(<EOL>self, resource_group_name, name, backup_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_backup_status.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", backup_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a backup of an app by its ID.\n\n        Gets a backup of an app by its ID.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param backup_id: ID of the backup.\n        :type backup_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: BackupItem or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.BackupItem or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m12"}
{"signature": "def delete_backup(<EOL>self, resource_group_name, name, backup_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete_backup.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", backup_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes a backup of an app by its ID.\n\n        Deletes a backup of an app by its ID.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param backup_id: ID of the backup.\n        :type backup_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44988:c0:m13"}
{"signature": "def list_process_threads(<EOL>self, resource_group_name, name, process_id, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_process_threads.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", process_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ProcessThreadInfoPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ProcessThreadInfoPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List the threads in a process by its ID for a specific scaled-out\n        instance in a web site.\n\n        List the threads in a process by its ID for a specific scaled-out\n        instance in a web site.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Site name.\n        :type name: str\n        :param process_id: PID.\n        :type process_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ProcessThreadInfo\n        :rtype:\n         ~azure.mgmt.web.models.ProcessThreadInfoPaged[~azure.mgmt.web.models.ProcessThreadInfo]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44988:c0:m140"}
{"signature": "def delete_instance_function_slot(<EOL>self, resource_group_name, name, function_name, slot, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete_instance_function_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", function_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Delete a function for web site, or a deployment slot.\n\n        Delete a function for web site, or a deployment slot.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Site name.\n        :type name: str\n        :param function_name: Function name.\n        :type function_name: str\n        :param slot: Name of the deployment slot. If a slot is not specified,\n         the API deletes a deployment for the production slot.\n        :type slot: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44988:c0:m228"}
{"signature": "def list_triggered_web_jobs(<EOL>self, resource_group_name, name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_triggered_web_jobs.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.TriggeredWebJobPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.TriggeredWebJobPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List triggered web jobs for an app, or a deployment slot.\n\n        List triggered web jobs for an app, or a deployment slot.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Site name.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of TriggeredWebJob\n        :rtype:\n         ~azure.mgmt.web.models.TriggeredWebJobPaged[~azure.mgmt.web.models.TriggeredWebJob]\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m363"}
{"signature": "def stop_slot(<EOL>self, resource_group_name, name, slot, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.stop_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Stops an app (or deployment slot, if specified).\n\n        Stops an app (or deployment slot, if specified).\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param slot: Name of the deployment slot. If a slot is not specified,\n         the API will stop the production slot.\n        :type slot: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44988:c0:m325"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, include_slots=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if include_slots is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", include_slots, '<STR_LIT:bool>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SitePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SitePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all web, mobile, and API apps in the specified resource group.\n\n        Gets all web, mobile, and API apps in the specified resource group.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param include_slots: Specify <strong>true</strong> to include\n         deployment slots in results. The default is false, which only gives\n         you the production slot of all apps.\n        :type include_slots: bool\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Site\n        :rtype: ~azure.mgmt.web.models.SitePaged[~azure.mgmt.web.models.Site]\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m2"}
{"signature": "def update_site_push_settings(<EOL>self, resource_group_name, name, push_settings, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.update_site_push_settings.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(push_settings, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Updates the Push settings associated with web app.\n\n        Updates the Push settings associated with web app.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of web app.\n        :type name: str\n        :param push_settings: Push settings associated with web app.\n        :type push_settings: ~azure.mgmt.web.models.PushSettings\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PushSettings or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.PushSettings or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m35"}
{"signature": "def list_instance_functions_slot(<EOL>self, resource_group_name, name, slot, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_instance_functions_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.FunctionEnvelopePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.FunctionEnvelopePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List the functions for a web site, or a deployment slot.\n\n        List the functions for a web site, or a deployment slot.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Site name.\n        :type name: str\n        :param slot: Name of the deployment slot. If a slot is not specified,\n         the API deletes a deployment for the production slot.\n        :type slot: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of FunctionEnvelope\n        :rtype:\n         ~azure.mgmt.web.models.FunctionEnvelopePaged[~azure.mgmt.web.models.FunctionEnvelope]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44988:c0:m223"}
{"signature": "def create_or_update_host_name_binding_slot(<EOL>self, resource_group_name, name, host_name, host_name_binding, slot, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update_host_name_binding_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", host_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(host_name_binding, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates a hostname binding for an app.\n\n        Creates a hostname binding for an app.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param host_name: Hostname in the hostname binding.\n        :type host_name: str\n        :param host_name_binding: Binding details. This is the JSON\n         representation of a HostNameBinding object.\n        :type host_name_binding: ~azure.mgmt.web.models.HostNameBinding\n        :param slot: Name of the deployment slot. If a slot is not specified,\n         the API will create a binding for the production slot.\n        :type slot: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: HostNameBinding or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.HostNameBinding or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m232"}
{"signature": "def delete_hybrid_connection(<EOL>self, resource_group_name, name, namespace_name, relay_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete_hybrid_connection.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", relay_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Removes a Hybrid Connection from this site.\n\n        Removes a Hybrid Connection from this site.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: The name of the web app.\n        :type name: str\n        :param namespace_name: The namespace for this hybrid connection.\n        :type namespace_name: str\n        :param relay_name: The relay name for this hybrid connection.\n        :type relay_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44988:c0:m80"}
{"signature": "def start_web_site_network_trace_slot(<EOL>self, resource_group_name, name, slot, duration_in_seconds=None, max_frame_length=None, sas_url=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.start_web_site_network_trace_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if duration_in_seconds is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", duration_in_seconds, '<STR_LIT:int>')<EOL><DEDENT>if max_frame_length is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", max_frame_length, '<STR_LIT:int>')<EOL><DEDENT>if sas_url is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", sas_url, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT:str>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Start capturing network packets for the site (To be deprecated).\n\n        Start capturing network packets for the site (To be deprecated).\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: The name of the web app.\n        :type name: str\n        :param slot: The name of the slot for this web app.\n        :type slot: str\n        :param duration_in_seconds: The duration to keep capturing in seconds.\n        :type duration_in_seconds: int\n        :param max_frame_length: The maximum frame length in bytes (Optional).\n        :type max_frame_length: int\n        :param sas_url: The Blob URL to store capture file.\n        :type sas_url: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: str or ClientRawResponse if raw=true\n        :rtype: str or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m269"}
{"signature": "def get_triggered_web_job_history(<EOL>self, resource_group_name, name, web_job_name, id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_triggered_web_job_history.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", web_job_name, '<STR_LIT:str>'),<EOL>'<STR_LIT:id>': self._serialize.url(\"<STR_LIT:id>\", id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a triggered web job's history by its ID for an app, , or a\n        deployment slot.\n\n        Gets a triggered web job's history by its ID for an app, , or a\n        deployment slot.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Site name.\n        :type name: str\n        :param web_job_name: Name of Web Job.\n        :type web_job_name: str\n        :param id: History ID.\n        :type id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: TriggeredJobHistory or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.TriggeredJobHistory or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44988:c0:m367"}
{"signature": "def get_migrate_my_sql_status_slot(<EOL>self, resource_group_name, name, slot, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_migrate_my_sql_status_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Returns the status of MySql in app migration, if one is active, and\n        whether or not MySql in app is enabled.\n\n        Returns the status of MySql in app migration, if one is active, and\n        whether or not MySql in app is enabled.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of web app.\n        :type name: str\n        :param slot: Name of the deployment slot.\n        :type slot: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: MigrateMySqlStatus or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.MigrateMySqlStatus or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m262"}
{"signature": "def list_configuration_snapshot_info_slot(<EOL>self, resource_group_name, name, slot, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_configuration_snapshot_info_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SiteConfigurationSnapshotInfoPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SiteConfigurationSnapshotInfoPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a list of web app configuration snapshots identifiers. Each\n        element of the list contains a timestamp and the ID of the snapshot.\n\n        Gets a list of web app configuration snapshots identifiers. Each\n        element of the list contains a timestamp and the ID of the snapshot.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param slot: Name of the deployment slot. If a slot is not specified,\n         the API will return configuration for the production slot.\n        :type slot: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of SiteConfigurationSnapshotInfo\n        :rtype:\n         ~azure.mgmt.web.models.SiteConfigurationSnapshotInfoPaged[~azure.mgmt.web.models.SiteConfigurationSnapshotInfo]\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m198"}
{"signature": "def get_functions_admin_token(<EOL>self, resource_group_name, name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_functions_admin_token.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT:str>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Fetch a short lived token that can be exchanged for a master key.\n\n        Fetch a short lived token that can be exchanged for a master key.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of web app.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: str or ClientRawResponse if raw=true\n        :rtype: str or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m68"}
{"signature": "def get_backup_status_slot(<EOL>self, resource_group_name, name, backup_id, slot, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_backup_status_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", backup_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a backup of an app by its ID.\n\n        Gets a backup of an app by its ID.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param backup_id: ID of the backup.\n        :type backup_id: str\n        :param slot: Name of the deployment slot. If a slot is not specified,\n         the API will get a backup of the production slot.\n        :type slot: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: BackupItem or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.BackupItem or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m170"}
{"signature": "def list_public_certificates_slot(<EOL>self, resource_group_name, name, slot, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_public_certificates_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.PublicCertificatePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.PublicCertificatePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get public certificates for an app or a deployment slot.\n\n        Get public certificates for an app or a deployment slot.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param slot: Name of the deployment slot. If a slot is not specified,\n         the API gets hostname bindings for the production slot.\n        :type slot: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of PublicCertificate\n        :rtype:\n         ~azure.mgmt.web.models.PublicCertificatePaged[~azure.mgmt.web.models.PublicCertificate]\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m294"}
{"signature": "def list_site_push_settings(<EOL>self, resource_group_name, name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_site_push_settings.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the Push settings associated with web app.\n\n        Gets the Push settings associated with web app.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of web app.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: PushSettings or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.PushSettings or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44988:c0:m36"}
{"signature": "def generate_new_site_publishing_password(<EOL>self, resource_group_name, name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.generate_new_site_publishing_password.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Generates a new publishing password for an app (or deployment slot, if\n        specified).\n\n        Generates a new publishing password for an app (or deployment slot, if\n        specified).\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the app.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44988:c0:m124"}
{"signature": "def get_hosting_environment_detector_response(<EOL>self, resource_group_name, name, detector_name, start_time=None, end_time=None, time_grain=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_hosting_environment_detector_response.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", detector_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if start_time is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", start_time, '<STR_LIT>')<EOL><DEDENT>if end_time is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", end_time, '<STR_LIT>')<EOL><DEDENT>if time_grain is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", time_grain, '<STR_LIT:str>', pattern=r'<STR_LIT>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get Hosting Environment Detector Response.\n\n        Get Hosting Environment Detector Response.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: App Service Environment Name\n        :type name: str\n        :param detector_name: Detector Resource Name\n        :type detector_name: str\n        :param start_time: Start Time\n        :type start_time: datetime\n        :param end_time: End Time\n        :type end_time: datetime\n        :param time_grain: Time Grain\n        :type time_grain: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DetectorResponse or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.DetectorResponse or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44989:c0:m2"}
{"signature": "def list_site_diagnostic_categories(<EOL>self, resource_group_name, site_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_site_diagnostic_categories.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", site_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.DiagnosticCategoryPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.DiagnosticCategoryPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get Diagnostics Categories.\n\n        Get Diagnostics Categories.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param site_name: Site Name\n        :type site_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of DiagnosticCategory\n        :rtype:\n         ~azure.mgmt.web.models.DiagnosticCategoryPaged[~azure.mgmt.web.models.DiagnosticCategory]\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44989:c0:m5"}
{"signature": "def get_site_diagnostic_category_slot(<EOL>self, resource_group_name, site_name, diagnostic_category, slot, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_site_diagnostic_category_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", site_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", diagnostic_category, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get Diagnostics Category.\n\n        Get Diagnostics Category.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param site_name: Site Name\n        :type site_name: str\n        :param diagnostic_category: Diagnostic Category\n        :type diagnostic_category: str\n        :param slot: Slot Name\n        :type slot: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DiagnosticCategory or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.DiagnosticCategory or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44989:c0:m16"}
{"signature": "def list_site_diagnostic_categories_slot(<EOL>self, resource_group_name, site_name, slot, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_site_diagnostic_categories_slot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", site_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", slot, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.DiagnosticCategoryPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.DiagnosticCategoryPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get Diagnostics Categories.\n\n        Get Diagnostics Categories.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param site_name: Site Name\n        :type site_name: str\n        :param slot: Slot Name\n        :type slot: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of DiagnosticCategory\n        :rtype:\n         ~azure.mgmt.web.models.DiagnosticCategoryPaged[~azure.mgmt.web.models.DiagnosticCategory]\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44989:c0:m15"}
{"signature": "def list_site_detector_responses(<EOL>self, resource_group_name, site_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_site_detector_responses.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", site_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.DetectorResponsePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.DetectorResponsePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List Site Detector Responses.\n\n        List Site Detector Responses.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param site_name: Site Name\n        :type site_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of DetectorResponse\n        :rtype:\n         ~azure.mgmt.web.models.DetectorResponsePaged[~azure.mgmt.web.models.DetectorResponse]\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44989:c0:m3"}
{"signature": "def execute_site_analysis(<EOL>self, resource_group_name, site_name, diagnostic_category, analysis_name, start_time=None, end_time=None, time_grain=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.execute_site_analysis.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", site_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", diagnostic_category, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", analysis_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if start_time is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", start_time, '<STR_LIT>')<EOL><DEDENT>if end_time is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", end_time, '<STR_LIT>')<EOL><DEDENT>if time_grain is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", time_grain, '<STR_LIT:str>', pattern=r'<STR_LIT>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Execute Analysis.\n\n        Execute Analysis.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param site_name: Site Name\n        :type site_name: str\n        :param diagnostic_category: Category Name\n        :type diagnostic_category: str\n        :param analysis_name: Analysis Resource Name\n        :type analysis_name: str\n        :param start_time: Start Time\n        :type start_time: datetime\n        :param end_time: End Time\n        :type end_time: datetime\n        :param time_grain: Time Grain\n        :type time_grain: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DiagnosticAnalysis or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.DiagnosticAnalysis or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44989:c0:m9"}
{"signature": "def get_multi_role_pool(<EOL>self, resource_group_name, name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_multi_role_pool.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get properties of a multi-role pool.\n\n        Get properties of a multi-role pool.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the App Service Environment.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: WorkerPoolResource or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.WorkerPoolResource or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44995:c0:m18"}
{"signature": "def list_multi_role_pool_instance_metrics(<EOL>self, resource_group_name, name, instance, details=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_multi_role_pool_instance_metrics.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", instance, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if details is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", details, '<STR_LIT:bool>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ResourceMetricPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ResourceMetricPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get metrics for a specific instance of a multi-role pool of an App\n        Service Environment.\n\n        Get metrics for a specific instance of a multi-role pool of an App\n        Service Environment.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the App Service Environment.\n        :type name: str\n        :param instance: Name of the instance in the multi-role pool.\n        :type instance: str\n        :param details: Specify <code>true</code> to include instance details.\n         The default is <code>false</code>.\n        :type details: bool\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ResourceMetric\n        :rtype:\n         ~azure.mgmt.web.models.ResourceMetricPaged[~azure.mgmt.web.models.ResourceMetric]\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44995:c0:m23"}
{"signature": "def list_metric_definitions(<EOL>self, resource_group_name, name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_metric_definitions.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get global metric definitions of an App Service Environment.\n\n        Get global metric definitions of an App Service Environment.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the App Service Environment.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: MetricDefinition or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.MetricDefinition or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44995:c0:m15"}
{"signature": "def get(<EOL>self, resource_group_name, name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the properties of an App Service Environment.\n\n        Get the properties of an App Service Environment.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the App Service Environment.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: AppServiceEnvironmentResource or ClientRawResponse if\n         raw=true\n        :rtype: ~azure.mgmt.web.models.AppServiceEnvironmentResource or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44995:c0:m3"}
{"signature": "def delete(<EOL>self, resource_group_name, name, force_delete=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>name=name,<EOL>force_delete=force_delete,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Delete an App Service Environment.\n\n        Delete an App Service Environment.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the App Service Environment.\n        :type name: str\n        :param force_delete: Specify <code>true</code> to force the deletion\n         even if the App Service Environment contains resources. The default is\n         <code>false</code>.\n        :type force_delete: bool\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44995:c0:m7"}
{"signature": "def list_worker_pool_instance_metrics(<EOL>self, resource_group_name, name, worker_pool_name, instance, details=None, filter=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_worker_pool_instance_metrics.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", worker_pool_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", instance, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if details is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", details, '<STR_LIT:bool>')<EOL><DEDENT>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>', skip_quote=True)<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ResourceMetricPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ResourceMetricPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get metrics for a specific instance of a worker pool of an App Service\n        Environment.\n\n        Get metrics for a specific instance of a worker pool of an App Service\n        Environment.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the App Service Environment.\n        :type name: str\n        :param worker_pool_name: Name of the worker pool.\n        :type worker_pool_name: str\n        :param instance: Name of the instance in the worker pool.\n        :type instance: str\n        :param details: Specify <code>true</code> to include instance details.\n         The default is <code>false</code>.\n        :type details: bool\n        :param filter: Return only usages/metrics specified in the filter.\n         Filter conforms to odata syntax. Example: $filter=(name.value eq\n         'Metric1' or name.value eq 'Metric2') and startTime eq\n         2014-01-01T00:00:00Z and endTime eq 2014-12-31T23:59:59Z and timeGrain\n         eq duration'[Hour|Minute|Day]'.\n        :type filter: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ResourceMetric\n        :rtype:\n         ~azure.mgmt.web.models.ResourceMetricPaged[~azure.mgmt.web.models.ResourceMetric]\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44995:c0:m43"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.AppServiceEnvironmentResourcePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.AppServiceEnvironmentResourcePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get all App Service Environments in a resource group.\n\n        Get all App Service Environments in a resource group.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of AppServiceEnvironmentResource\n        :rtype:\n         ~azure.mgmt.web.models.AppServiceEnvironmentResourcePaged[~azure.mgmt.web.models.AppServiceEnvironmentResource]\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44995:c0:m2"}
{"signature": "def update(<EOL>self, resource_group_name, name, hosting_environment_envelope, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(hosting_environment_envelope, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Create or update an App Service Environment.\n\n        Create or update an App Service Environment.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the App Service Environment.\n        :type name: str\n        :param hosting_environment_envelope: Configuration details of the App\n         Service Environment.\n        :type hosting_environment_envelope:\n         ~azure.mgmt.web.models.AppServiceEnvironmentPatchResource\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: AppServiceEnvironmentResource or ClientRawResponse if\n         raw=true\n        :rtype: ~azure.mgmt.web.models.AppServiceEnvironmentResource or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44995:c0:m8"}
{"signature": "def list_worker_pools(<EOL>self, resource_group_name, name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_worker_pools.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.WorkerPoolResourcePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.WorkerPoolResourcePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get all worker pools of an App Service Environment.\n\n        Get all worker pools of an App Service Environment.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the App Service Environment.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of WorkerPoolResource\n        :rtype:\n         ~azure.mgmt.web.models.WorkerPoolResourcePaged[~azure.mgmt.web.models.WorkerPoolResource]\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44995:c0:m37"}
{"signature": "def list_operations(<EOL>self, resource_group_name, name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_operations.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List all currently running operations on the App Service Environment.\n\n        List all currently running operations on the App Service Environment.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the App Service Environment.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: list or ClientRawResponse if raw=true\n        :rtype: list[~azure.mgmt.web.models.Operation] or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44995:c0:m28"}
{"signature": "def list_web_apps(<EOL>self, resource_group_name, name, properties_to_include=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_web_apps.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if properties_to_include is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", properties_to_include, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SitePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SitePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get all apps in an App Service Environment.\n\n        Get all apps in an App Service Environment.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the App Service Environment.\n        :type name: str\n        :param properties_to_include: Comma separated list of app properties\n         to include.\n        :type properties_to_include: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Site\n        :rtype: ~azure.mgmt.web.models.SitePaged[~azure.mgmt.web.models.Site]\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44995:c0:m33"}
{"signature": "def list_worker_pool_skus(<EOL>self, resource_group_name, name, worker_pool_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_worker_pool_skus.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", worker_pool_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SkuInfoPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SkuInfoPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get available SKUs for scaling a worker pool.\n\n        Get available SKUs for scaling a worker pool.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the App Service Environment.\n        :type name: str\n        :param worker_pool_name: Name of the worker pool.\n        :type worker_pool_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of SkuInfo\n        :rtype:\n         ~azure.mgmt.web.models.SkuInfoPaged[~azure.mgmt.web.models.SkuInfo]\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44995:c0:m46"}
{"signature": "def list_multi_role_usages(<EOL>self, resource_group_name, name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_multi_role_usages.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.UsagePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.UsagePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get usage metrics for a multi-role pool of an App Service Environment.\n\n        Get usage metrics for a multi-role pool of an App Service Environment.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the App Service Environment.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Usage\n        :rtype:\n         ~azure.mgmt.web.models.UsagePaged[~azure.mgmt.web.models.Usage]\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44995:c0:m27"}
{"signature": "def get(<EOL>self, resource_group_name, name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.DefaultErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get a certificate.\n\n        Get a certificate.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the certificate.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Certificate or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.web.models.Certificate or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`DefaultErrorResponseException<azure.mgmt.web.models.DefaultErrorResponseException>`", "id": "f44996:c0:m3"}
{"signature": "def delete(<EOL>self, resource_group_name, name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern=r'<STR_LIT>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Delete a certificate.\n\n        Delete a certificate.\n\n        :param resource_group_name: Name of the resource group to which the\n         resource belongs.\n        :type resource_group_name: str\n        :param name: Name of the certificate.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f44996:c0:m5"}
{"signature": "def details(<EOL>self, query, accept_language=None, content_type=None, user_agent=None, client_id=None, client_ip=None, location=None, crop_bottom=None, crop_left=None, crop_right=None, crop_top=None, crop_type=None, country_code=None, id=None, image_url=None, insights_token=None, modules=None, market=None, safe_search=None, set_lang=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.details.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>if crop_bottom is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", crop_bottom, '<STR_LIT:float>')<EOL><DEDENT>if crop_left is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", crop_left, '<STR_LIT:float>')<EOL><DEDENT>if crop_right is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", crop_right, '<STR_LIT:float>')<EOL><DEDENT>if crop_top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", crop_top, '<STR_LIT:float>')<EOL><DEDENT>if crop_type is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", crop_type, '<STR_LIT:str>')<EOL><DEDENT>if country_code is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", country_code, '<STR_LIT:str>')<EOL><DEDENT>if id is not None:<EOL><INDENT>query_parameters['<STR_LIT:id>'] = self._serialize.query(\"<STR_LIT:id>\", id, '<STR_LIT:str>')<EOL><DEDENT>if image_url is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", image_url, '<STR_LIT:str>')<EOL><DEDENT>if insights_token is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", insights_token, '<STR_LIT:str>')<EOL><DEDENT>if modules is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", modules, '<STR_LIT>', div='<STR_LIT:U+002C>')<EOL><DEDENT>if market is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", market, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT:q>'] = self._serialize.query(\"<STR_LIT>\", query, '<STR_LIT:str>')<EOL>if safe_search is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", safe_search, '<STR_LIT:str>')<EOL><DEDENT>if set_lang is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", set_lang, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.x_bing_apis_sdk, '<STR_LIT:str>')<EOL>if accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", accept_language, '<STR_LIT:str>')<EOL><DEDENT>if content_type is not None:<EOL><INDENT>header_parameters['<STR_LIT:Content-Type>'] = self._serialize.header(\"<STR_LIT>\", content_type, '<STR_LIT:str>')<EOL><DEDENT>if user_agent is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", user_agent, '<STR_LIT:str>')<EOL><DEDENT>if client_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", client_id, '<STR_LIT:str>')<EOL><DEDENT>if client_ip is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", client_ip, '<STR_LIT:str>')<EOL><DEDENT>if location is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT:location>\", location, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "The Image Detail Search API lets you search on Bing and get back\n        insights about an image, such as webpages that include the image. This\n        section provides technical details about the query parameters and\n        headers that you use to request insights of images and the JSON\n        response objects that contain them. For examples that show how to make\n        requests, see [Searching the Web for\n        Images](https://docs.microsoft.com/azure/cognitive-services/bing-image-search/search-the-web).\n\n        :param query: The user's search query term. The term cannot be empty.\n         The term may contain [Bing Advanced\n         Operators](http://msdn.microsoft.com/library/ff795620.aspx). For\n         example, to limit images to a specific domain, use the\n         [site:](http://msdn.microsoft.com/library/ff795613.aspx) operator. To\n         help improve relevance of an insights query (see\n         [insightsToken](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#insightstoken)),\n         you should always include the user's query term. Use this parameter\n         only with the Image Search API.Do not specify this parameter when\n         calling the Trending Images API.\n        :type query: str\n        :param accept_language: A comma-delimited list of one or more\n         languages to use for user interface strings. The list is in decreasing\n         order of preference. For additional information, including expected\n         format, see\n         [RFC2616](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html).\n         This header and the\n         [setLang](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#setlang)\n         query parameter are mutually exclusive; do not specify both. If you\n         set this header, you must also specify the\n         [cc](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#cc)\n         query parameter. To determine the market to return results for, Bing\n         uses the first supported language it finds from the list and combines\n         it with the cc parameter value. If the list does not include a\n         supported language, Bing finds the closest language and market that\n         supports the request or it uses an aggregated or default market for\n         the results. To determine the market that Bing used, see the\n         BingAPIs-Market header. Use this header and the cc query parameter\n         only if you specify multiple languages. Otherwise, use the\n         [mkt](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#mkt)\n         and\n         [setLang](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#setlang)\n         query parameters. A user interface string is a string that's used as a\n         label in a user interface. There are few user interface strings in the\n         JSON response objects. Any links to Bing.com properties in the\n         response objects apply the specified language.\n        :type accept_language: str\n        :param content_type: Optional request header. If you set the\n         [modules](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#modulesrequested)\n         query parameter to RecognizedEntities, you may specify the binary of\n         an image in the body of a POST request. If you specify the image in\n         the body of a POST request, you must specify this header and set its\n         value to multipart/form-data. The maximum image size is 1 MB.\n        :type content_type: str\n        :param user_agent: The user agent originating the request. Bing uses\n         the user agent to provide mobile users with an optimized experience.\n         Although optional, you are encouraged to always specify this header.\n         The user-agent should be the same string that any commonly used\n         browser sends. For information about user agents, see [RFC\n         2616](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html). The\n         following are examples of user-agent strings. Windows Phone:\n         Mozilla/5.0 (compatible; MSIE 10.0; Windows Phone 8.0; Trident/6.0;\n         IEMobile/10.0; ARM; Touch; NOKIA; Lumia 822). Android: Mozilla / 5.0\n         (Linux; U; Android 2.3.5; en - us; SCH - I500 Build / GINGERBREAD)\n         AppleWebKit / 533.1 (KHTML; like Gecko) Version / 4.0 Mobile Safari /\n         533.1. iPhone: Mozilla / 5.0 (iPhone; CPU iPhone OS 6_1 like Mac OS X)\n         AppleWebKit / 536.26 (KHTML; like Gecko) Mobile / 10B142 iPhone4; 1\n         BingWeb / 3.03.1428.20120423. PC: Mozilla / 5.0 (Windows NT 6.3;\n         WOW64; Trident / 7.0; Touch; rv:11.0) like Gecko. iPad: Mozilla / 5.0\n         (iPad; CPU OS 7_0 like Mac OS X) AppleWebKit / 537.51.1 (KHTML, like\n         Gecko) Version / 7.0 Mobile / 11A465 Safari / 9537.53\n        :type user_agent: str\n        :param client_id: Bing uses this header to provide users with\n         consistent behavior across Bing API calls. Bing often flights new\n         features and improvements, and it uses the client ID as a key for\n         assigning traffic on different flights. If you do not use the same\n         client ID for a user across multiple requests, then Bing may assign\n         the user to multiple conflicting flights. Being assigned to multiple\n         conflicting flights can lead to an inconsistent user experience. For\n         example, if the second request has a different flight assignment than\n         the first, the experience may be unexpected. Also, Bing can use the\n         client ID to tailor web results to that client ID\u2019s search history,\n         providing a richer experience for the user. Bing also uses this header\n         to help improve result rankings by analyzing the activity generated by\n         a client ID. The relevance improvements help with better quality of\n         results delivered by Bing APIs and in turn enables higher\n         click-through rates for the API consumer. IMPORTANT: Although\n         optional, you should consider this header required. Persisting the\n         client ID across multiple requests for the same end user and device\n         combination enables 1) the API consumer to receive a consistent user\n         experience, and 2) higher click-through rates via better quality of\n         results from the Bing APIs. Each user that uses your application on\n         the device must have a unique, Bing generated client ID. If you do not\n         include this header in the request, Bing generates an ID and returns\n         it in the X-MSEdge-ClientID response header. The only time that you\n         should NOT include this header in a request is the first time the user\n         uses your app on that device. Use the client ID for each Bing API\n         request that your app makes for this user on the device. Persist the\n         client ID. To persist the ID in a browser app, use a persistent HTTP\n         cookie to ensure the ID is used across all sessions. Do not use a\n         session cookie. For other apps such as mobile apps, use the device's\n         persistent storage to persist the ID. The next time the user uses your\n         app on that device, get the client ID that you persisted. Bing\n         responses may or may not include this header. If the response includes\n         this header, capture the client ID and use it for all subsequent Bing\n         requests for the user on that device. If you include the\n         X-MSEdge-ClientID, you must not include cookies in the request.\n        :type client_id: str\n        :param client_ip: The IPv4 or IPv6 address of the client device. The\n         IP address is used to discover the user's location. Bing uses the\n         location information to determine safe search behavior. Although\n         optional, you are encouraged to always specify this header and the\n         X-Search-Location header. Do not obfuscate the address (for example,\n         by changing the last octet to 0). Obfuscating the address results in\n         the location not being anywhere near the device's actual location,\n         which may result in Bing serving erroneous results.\n        :type client_ip: str\n        :param location: A semicolon-delimited list of key/value pairs that\n         describe the client's geographical location. Bing uses the location\n         information to determine safe search behavior and to return relevant\n         local content. Specify the key/value pair as <key>:<value>. The\n         following are the keys that you use to specify the user's location.\n         lat (required): The latitude of the client's location, in degrees. The\n         latitude must be greater than or equal to -90.0 and less than or equal\n         to +90.0. Negative values indicate southern latitudes and positive\n         values indicate northern latitudes. long (required): The longitude of\n         the client's location, in degrees. The longitude must be greater than\n         or equal to -180.0 and less than or equal to +180.0. Negative values\n         indicate western longitudes and positive values indicate eastern\n         longitudes. re (required): The radius, in meters, which specifies the\n         horizontal accuracy of the coordinates. Pass the value returned by the\n         device's location service. Typical values might be 22m for GPS/Wi-Fi,\n         380m for cell tower triangulation, and 18,000m for reverse IP lookup.\n         ts (optional): The UTC UNIX timestamp of when the client was at the\n         location. (The UNIX timestamp is the number of seconds since January\n         1, 1970.) head (optional): The client's relative heading or direction\n         of travel. Specify the direction of travel as degrees from 0 through\n         360, counting clockwise relative to true north. Specify this key only\n         if the sp key is nonzero. sp (optional): The horizontal velocity\n         (speed), in meters per second, that the client device is traveling.\n         alt (optional): The altitude of the client device, in meters. are\n         (optional): The radius, in meters, that specifies the vertical\n         accuracy of the coordinates. Specify this key only if you specify the\n         alt key. Although many of the keys are optional, the more information\n         that you provide, the more accurate the location results are. Although\n         optional, you are encouraged to always specify the user's geographical\n         location. Providing the location is especially important if the\n         client's IP address does not accurately reflect the user's physical\n         location (for example, if the client uses VPN). For optimal results,\n         you should include this header and the X-MSEdge-ClientIP header, but\n         at a minimum, you should include this header.\n        :type location: str\n        :param crop_bottom: The bottom coordinate of the region to crop. The\n         coordinate is a fractional value of the original image's height and is\n         measured from the top, left corner of the image. Specify the\n         coordinate as a value from 0.0 through 1.0. Use this parameter only\n         with the Insights API. Do not specify this parameter when calling the\n         Images, Trending Images, or Web Search APIs.\n        :type crop_bottom: float\n        :param crop_left: The left coordinate of the region to crop. The\n         coordinate is a fractional value of the original image's height and is\n         measured from the top, left corner of the image. Specify the\n         coordinate as a value from 0.0 through 1.0. Use this parameter only\n         with the Insights API. Do not specify this parameter when calling the\n         Images, Trending Images, or Web Search APIs.\n        :type crop_left: float\n        :param crop_right: The right coordinate of the region to crop. The\n         coordinate is a fractional value of the original image's height and is\n         measured from the top, left corner of the image. Specify the\n         coordinate as a value from 0.0 through 1.0. Use this parameter only\n         with the Insights API. Do not specify this parameter when calling the\n         Images, Trending Images, or Web Search APIs.\n        :type crop_right: float\n        :param crop_top: The top coordinate of the region to crop. The\n         coordinate is a fractional value of the original image's height and is\n         measured from the top, left corner of the image. Specify the\n         coordinate as a value from 0.0 through 1.0. Use this parameter only\n         with the Insights API. Do not specify this parameter when calling the\n         Images, Trending Images, or Web Search APIs.\n        :type crop_top: float\n        :param crop_type: The crop type to use when cropping the image based\n         on the coordinates specified in the cal, cat, car, and cab parameters.\n         The following are the possible values. 0: Rectangular (default). Use\n         this parameter only with the Insights API. Do not specify this\n         parameter when calling the Images, Trending Images, or Web Search\n         APIs. Possible values include: 'Rectangular'\n        :type crop_type: str or\n         ~azure.cognitiveservices.search.imagesearch.models.ImageCropType\n        :param country_code: A 2-character country code of the country where\n         the results come from. For a list of possible values, see [Market\n         Codes](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#market-codes).\n         If you set this parameter, you must also specify the\n         [Accept-Language](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#acceptlanguage)\n         header. Bing uses the first supported language it finds from the\n         languages list, and combine that language with the country code that\n         you specify to determine the market to return results for. If the\n         languages list does not include a supported language, Bing finds the\n         closest language and market that supports the request, or it may use\n         an aggregated or default market for the results instead of a specified\n         one. You should use this query parameter and the Accept-Language query\n         parameter only if you specify multiple languages; otherwise, you\n         should use the mkt and setLang query parameters. This parameter and\n         the\n         [mkt](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#mkt)\n         query parameter are mutually exclusive\u2014do not specify both.\n        :type country_code: str\n        :param id: An ID that uniquely identifies an image. Use this parameter\n         to ensure that the specified image is the first image in the list of\n         images that Bing returns. The\n         [Image](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#image)\n         object's imageId field contains the ID that you set this parameter to.\n        :type id: str\n        :param image_url: The URL of an image that you want to get insights\n         of. Use this parameter as an alternative to using the insightsToken\n         parameter to specify the image. You may also specify the image by\n         placing the binary of the image in the body of a POST request. If you\n         use the binary option, see the\n         [Content-Type](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#contenttype)\n         header. The maximum supported image size is 1 MB. Use this parameter\n         only with the Insights API. Do not specify this parameter when calling\n         the Images, Trending Images, or Web Search APIs.\n        :type image_url: str\n        :param insights_token: An image token. The\n         [Image](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#image)\n         object's\n         [imageInsightsToken](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#image-imageinsightstoken)\n         contains the token. Specify this parameter to get additional\n         information about an image, such as a caption or shopping source. For\n         a list of the additional information about an image that you can get,\n         see the\n         [modules](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#modulesrequested)\n         query parameter. Use this parameter only with the Insights API. Do not\n         specify this parameter when calling the Images, Trending Images, or\n         Web Search APIs.\n        :type insights_token: str\n        :param modules: A comma-delimited list of insights to request. The\n         following are the possible case-insensitive values. All: Return all\n         insights, if available, except RecognizedEntities. BRQ: Best\n         representative query. The query term that best describes the image.\n         Caption: A caption that provides information about the image. If the\n         caption contains entities, the response may include links to images of\n         those entities. Collections: A list of related images. Recipes: A list\n         of recipes for cooking the food shown in the images. PagesIncluding: A\n         list of webpages that include the image. RecognizedEntities: A list of\n         entities (people) that were recognized in the image. NOTE: You may not\n         specify this module with any other module. If you specify it with\n         other modules, the response doesn't include recognized entities.\n         RelatedSearches: A list of related searches made by others.\n         ShoppingSources: A list of merchants where you can buy related\n         offerings. SimilarImages: A list of images that are visually similar\n         to the original image. SimilarProducts: A list of images that contain\n         a product that is similar to a product found in the original image.\n         Tags: Provides characteristics of the type of content found in the\n         image. For example, if the image is of a person, the tags might\n         indicate the person's gender and type of clothes they're wearing. If\n         you specify a module and there is no data for the module, the response\n         object doesn't include the related field. For example, if you specify\n         Caption and it does not exist, the response doesn't include the\n         imageCaption field. To include related searches, the request must\n         include the original query string. Although the original query string\n         is not required for similar images or products, you should always\n         include it because it can help improve relevance and the results. Use\n         this parameter only with the Insights API. Do not specify this\n         parameter when calling the Images, Trending Images, or Web Search\n         APIs.\n        :type modules: list[str or\n         ~azure.cognitiveservices.search.imagesearch.models.ImageInsightModule]\n        :param market: The market where the results come from. Typically, mkt\n         is the country where the user is making the request from. However, it\n         could be a different country if the user is not located in a country\n         where Bing delivers results. The market must be in the form <language\n         code>-<country code>. For example, en-US. The string is case\n         insensitive. For a list of possible market values, see [Market\n         Codes](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#market-codes).\n         NOTE: If known, you are encouraged to always specify the market.\n         Specifying the market helps Bing route the request and return an\n         appropriate and optimal response. If you specify a market that is not\n         listed in [Market\n         Codes](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#market-codes),\n         Bing uses a best fit market code based on an internal mapping that is\n         subject to change. This parameter and the\n         [cc](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#cc)\n         query parameter are mutually exclusive\u2014do not specify both.\n        :type market: str\n        :param safe_search: Filter images for adult content. The following are\n         the possible filter values. Off: May return images with adult content.\n         If the request is through the Image Search API, the response includes\n         thumbnail images that are clear (non-fuzzy). However, if the request\n         is through the Web Search API, the response includes thumbnail images\n         that are pixelated (fuzzy). Moderate: If the request is through the\n         Image Search API, the response doesn't include images with adult\n         content. If the request is through the Web Search API, the response\n         may include images with adult content (the thumbnail images are\n         pixelated (fuzzy)). Strict: Do not return images with adult content.\n         The default is Moderate. If the request comes from a market that\n         Bing's adult policy requires that safeSearch is set to Strict, Bing\n         ignores the safeSearch value and uses Strict. If you use the site:\n         query operator, there is the chance that the response may contain\n         adult content regardless of what the safeSearch query parameter is set\n         to. Use site: only if you are aware of the content on the site and\n         your scenario supports the possibility of adult content. Possible\n         values include: 'Off', 'Moderate', 'Strict'\n        :type safe_search: str or\n         ~azure.cognitiveservices.search.imagesearch.models.SafeSearch\n        :param set_lang: The language to use for user interface strings.\n         Specify the language using the ISO 639-1 2-letter language code. For\n         example, the language code for English is EN. The default is EN\n         (English). Although optional, you should always specify the language.\n         Typically, you set setLang to the same language specified by mkt\n         unless the user wants the user interface strings displayed in a\n         different language. This parameter and the\n         [Accept-Language](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#acceptlanguage)\n         header are mutually exclusive; do not specify both. A user interface\n         string is a string that's used as a label in a user interface. There\n         are few user interface strings in the JSON response objects. Also, any\n         links to Bing.com properties in the response objects apply the\n         specified language.\n        :type set_lang: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ImageInsights or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.cognitiveservices.search.imagesearch.models.ImageInsights or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.search.imagesearch.models.ErrorResponseException>`", "id": "f45078:c0:m2"}
{"signature": "def search(<EOL>self, query, accept_language=None, user_agent=None, client_id=None, client_ip=None, location=None, aspect=None, color=None, country_code=None, count=None, freshness=None, height=None, id=None, image_content=None, image_type=None, license=None, market=None, max_file_size=None, max_height=None, max_width=None, min_file_size=None, min_height=None, min_width=None, offset=None, safe_search=None, size=None, set_lang=None, width=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.search.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>if aspect is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", aspect, '<STR_LIT:str>')<EOL><DEDENT>if color is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", color, '<STR_LIT:str>')<EOL><DEDENT>if country_code is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", country_code, '<STR_LIT:str>')<EOL><DEDENT>if count is not None:<EOL><INDENT>query_parameters['<STR_LIT:count>'] = self._serialize.query(\"<STR_LIT:count>\", count, '<STR_LIT:int>')<EOL><DEDENT>if freshness is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", freshness, '<STR_LIT:str>')<EOL><DEDENT>if height is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", height, '<STR_LIT:int>')<EOL><DEDENT>if id is not None:<EOL><INDENT>query_parameters['<STR_LIT:id>'] = self._serialize.query(\"<STR_LIT:id>\", id, '<STR_LIT:str>')<EOL><DEDENT>if image_content is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", image_content, '<STR_LIT:str>')<EOL><DEDENT>if image_type is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", image_type, '<STR_LIT:str>')<EOL><DEDENT>if license is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", license, '<STR_LIT:str>')<EOL><DEDENT>if market is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", market, '<STR_LIT:str>')<EOL><DEDENT>if max_file_size is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", max_file_size, '<STR_LIT>')<EOL><DEDENT>if max_height is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", max_height, '<STR_LIT>')<EOL><DEDENT>if max_width is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", max_width, '<STR_LIT>')<EOL><DEDENT>if min_file_size is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", min_file_size, '<STR_LIT>')<EOL><DEDENT>if min_height is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", min_height, '<STR_LIT>')<EOL><DEDENT>if min_width is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", min_width, '<STR_LIT>')<EOL><DEDENT>if offset is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", offset, '<STR_LIT>')<EOL><DEDENT>query_parameters['<STR_LIT:q>'] = self._serialize.query(\"<STR_LIT>\", query, '<STR_LIT:str>')<EOL>if safe_search is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", safe_search, '<STR_LIT:str>')<EOL><DEDENT>if size is not None:<EOL><INDENT>query_parameters['<STR_LIT:size>'] = self._serialize.query(\"<STR_LIT:size>\", size, '<STR_LIT:str>')<EOL><DEDENT>if set_lang is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", set_lang, '<STR_LIT:str>')<EOL><DEDENT>if width is not None:<EOL><INDENT>query_parameters['<STR_LIT:width>'] = self._serialize.query(\"<STR_LIT:width>\", width, '<STR_LIT:int>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.x_bing_apis_sdk, '<STR_LIT:str>')<EOL>if accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", accept_language, '<STR_LIT:str>')<EOL><DEDENT>if user_agent is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", user_agent, '<STR_LIT:str>')<EOL><DEDENT>if client_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", client_id, '<STR_LIT:str>')<EOL><DEDENT>if client_ip is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", client_ip, '<STR_LIT:str>')<EOL><DEDENT>if location is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT:location>\", location, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorResponseException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "The Image Search API lets you send a search query to Bing and get back\n        a list of relevant images. This section provides technical details\n        about the query parameters and headers that you use to request images\n        and the JSON response objects that contain them. For examples that show\n        how to make requests, see [Searching the Web for\n        Images](https://docs.microsoft.com/azure/cognitive-services/bing-image-search/search-the-web).\n\n        :param query: The user's search query term. The term cannot be empty.\n         The term may contain [Bing Advanced\n         Operators](http://msdn.microsoft.com/library/ff795620.aspx). For\n         example, to limit images to a specific domain, use the\n         [site:](http://msdn.microsoft.com/library/ff795613.aspx) operator. To\n         help improve relevance of an insights query (see\n         [insightsToken](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#insightstoken)),\n         you should always include the user's query term. Use this parameter\n         only with the Image Search API.Do not specify this parameter when\n         calling the Trending Images API.\n        :type query: str\n        :param accept_language: A comma-delimited list of one or more\n         languages to use for user interface strings. The list is in decreasing\n         order of preference. For additional information, including expected\n         format, see\n         [RFC2616](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html).\n         This header and the\n         [setLang](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#setlang)\n         query parameter are mutually exclusive; do not specify both. If you\n         set this header, you must also specify the\n         [cc](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#cc)\n         query parameter. To determine the market to return results for, Bing\n         uses the first supported language it finds from the list and combines\n         it with the cc parameter value. If the list does not include a\n         supported language, Bing finds the closest language and market that\n         supports the request or it uses an aggregated or default market for\n         the results. To determine the market that Bing used, see the\n         BingAPIs-Market header. Use this header and the cc query parameter\n         only if you specify multiple languages. Otherwise, use the\n         [mkt](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#mkt)\n         and\n         [setLang](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#setlang)\n         query parameters. A user interface string is a string that's used as a\n         label in a user interface. There are few user interface strings in the\n         JSON response objects. Any links to Bing.com properties in the\n         response objects apply the specified language.\n        :type accept_language: str\n        :param user_agent: The user agent originating the request. Bing uses\n         the user agent to provide mobile users with an optimized experience.\n         Although optional, you are encouraged to always specify this header.\n         The user-agent should be the same string that any commonly used\n         browser sends. For information about user agents, see [RFC\n         2616](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html). The\n         following are examples of user-agent strings. Windows Phone:\n         Mozilla/5.0 (compatible; MSIE 10.0; Windows Phone 8.0; Trident/6.0;\n         IEMobile/10.0; ARM; Touch; NOKIA; Lumia 822). Android: Mozilla / 5.0\n         (Linux; U; Android 2.3.5; en - us; SCH - I500 Build / GINGERBREAD)\n         AppleWebKit / 533.1 (KHTML; like Gecko) Version / 4.0 Mobile Safari /\n         533.1. iPhone: Mozilla / 5.0 (iPhone; CPU iPhone OS 6_1 like Mac OS X)\n         AppleWebKit / 536.26 (KHTML; like Gecko) Mobile / 10B142 iPhone4; 1\n         BingWeb / 3.03.1428.20120423. PC: Mozilla / 5.0 (Windows NT 6.3;\n         WOW64; Trident / 7.0; Touch; rv:11.0) like Gecko. iPad: Mozilla / 5.0\n         (iPad; CPU OS 7_0 like Mac OS X) AppleWebKit / 537.51.1 (KHTML, like\n         Gecko) Version / 7.0 Mobile / 11A465 Safari / 9537.53\n        :type user_agent: str\n        :param client_id: Bing uses this header to provide users with\n         consistent behavior across Bing API calls. Bing often flights new\n         features and improvements, and it uses the client ID as a key for\n         assigning traffic on different flights. If you do not use the same\n         client ID for a user across multiple requests, then Bing may assign\n         the user to multiple conflicting flights. Being assigned to multiple\n         conflicting flights can lead to an inconsistent user experience. For\n         example, if the second request has a different flight assignment than\n         the first, the experience may be unexpected. Also, Bing can use the\n         client ID to tailor web results to that client ID\u2019s search history,\n         providing a richer experience for the user. Bing also uses this header\n         to help improve result rankings by analyzing the activity generated by\n         a client ID. The relevance improvements help with better quality of\n         results delivered by Bing APIs and in turn enables higher\n         click-through rates for the API consumer. IMPORTANT: Although\n         optional, you should consider this header required. Persisting the\n         client ID across multiple requests for the same end user and device\n         combination enables 1) the API consumer to receive a consistent user\n         experience, and 2) higher click-through rates via better quality of\n         results from the Bing APIs. Each user that uses your application on\n         the device must have a unique, Bing generated client ID. If you do not\n         include this header in the request, Bing generates an ID and returns\n         it in the X-MSEdge-ClientID response header. The only time that you\n         should NOT include this header in a request is the first time the user\n         uses your app on that device. Use the client ID for each Bing API\n         request that your app makes for this user on the device. Persist the\n         client ID. To persist the ID in a browser app, use a persistent HTTP\n         cookie to ensure the ID is used across all sessions. Do not use a\n         session cookie. For other apps such as mobile apps, use the device's\n         persistent storage to persist the ID. The next time the user uses your\n         app on that device, get the client ID that you persisted. Bing\n         responses may or may not include this header. If the response includes\n         this header, capture the client ID and use it for all subsequent Bing\n         requests for the user on that device. If you include the\n         X-MSEdge-ClientID, you must not include cookies in the request.\n        :type client_id: str\n        :param client_ip: The IPv4 or IPv6 address of the client device. The\n         IP address is used to discover the user's location. Bing uses the\n         location information to determine safe search behavior. Although\n         optional, you are encouraged to always specify this header and the\n         X-Search-Location header. Do not obfuscate the address (for example,\n         by changing the last octet to 0). Obfuscating the address results in\n         the location not being anywhere near the device's actual location,\n         which may result in Bing serving erroneous results.\n        :type client_ip: str\n        :param location: A semicolon-delimited list of key/value pairs that\n         describe the client's geographical location. Bing uses the location\n         information to determine safe search behavior and to return relevant\n         local content. Specify the key/value pair as <key>:<value>. The\n         following are the keys that you use to specify the user's location.\n         lat (required): The latitude of the client's location, in degrees. The\n         latitude must be greater than or equal to -90.0 and less than or equal\n         to +90.0. Negative values indicate southern latitudes and positive\n         values indicate northern latitudes. long (required): The longitude of\n         the client's location, in degrees. The longitude must be greater than\n         or equal to -180.0 and less than or equal to +180.0. Negative values\n         indicate western longitudes and positive values indicate eastern\n         longitudes. re (required): The radius, in meters, which specifies the\n         horizontal accuracy of the coordinates. Pass the value returned by the\n         device's location service. Typical values might be 22m for GPS/Wi-Fi,\n         380m for cell tower triangulation, and 18,000m for reverse IP lookup.\n         ts (optional): The UTC UNIX timestamp of when the client was at the\n         location. (The UNIX timestamp is the number of seconds since January\n         1, 1970.) head (optional): The client's relative heading or direction\n         of travel. Specify the direction of travel as degrees from 0 through\n         360, counting clockwise relative to true north. Specify this key only\n         if the sp key is nonzero. sp (optional): The horizontal velocity\n         (speed), in meters per second, that the client device is traveling.\n         alt (optional): The altitude of the client device, in meters. are\n         (optional): The radius, in meters, that specifies the vertical\n         accuracy of the coordinates. Specify this key only if you specify the\n         alt key. Although many of the keys are optional, the more information\n         that you provide, the more accurate the location results are. Although\n         optional, you are encouraged to always specify the user's geographical\n         location. Providing the location is especially important if the\n         client's IP address does not accurately reflect the user's physical\n         location (for example, if the client uses VPN). For optimal results,\n         you should include this header and the X-MSEdge-ClientIP header, but\n         at a minimum, you should include this header.\n        :type location: str\n        :param aspect: Filter images by the following aspect ratios. All: Do\n         not filter by aspect.Specifying this value is the same as not\n         specifying the aspect parameter. Square: Return images with standard\n         aspect ratio. Wide: Return images with wide screen aspect ratio. Tall:\n         Return images with tall aspect ratio. Possible values include: 'All',\n         'Square', 'Wide', 'Tall'\n        :type aspect: str or\n         ~azure.cognitiveservices.search.imagesearch.models.ImageAspect\n        :param color: Filter images by the following color options. ColorOnly:\n         Return color images. Monochrome: Return black and white images. Return\n         images with one of the following dominant colors: Black, Blue, Brown,\n         Gray, Green, Orange, Pink, Purple, Red, Teal, White, Yellow. Possible\n         values include: 'ColorOnly', 'Monochrome', 'Black', 'Blue', 'Brown',\n         'Gray', 'Green', 'Orange', 'Pink', 'Purple', 'Red', 'Teal', 'White',\n         'Yellow'\n        :type color: str or\n         ~azure.cognitiveservices.search.imagesearch.models.ImageColor\n        :param country_code: A 2-character country code of the country where\n         the results come from. For a list of possible values, see [Market\n         Codes](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#market-codes).\n         If you set this parameter, you must also specify the\n         [Accept-Language](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#acceptlanguage)\n         header. Bing uses the first supported language it finds from the\n         languages list, and combine that language with the country code that\n         you specify to determine the market to return results for. If the\n         languages list does not include a supported language, Bing finds the\n         closest language and market that supports the request, or it may use\n         an aggregated or default market for the results instead of a specified\n         one. You should use this query parameter and the Accept-Language query\n         parameter only if you specify multiple languages; otherwise, you\n         should use the mkt and setLang query parameters. This parameter and\n         the\n         [mkt](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#mkt)\n         query parameter are mutually exclusive\u2014do not specify both.\n        :type country_code: str\n        :param count: The number of images to return in the response. The\n         actual number delivered may be less than requested. The default is 35.\n         The maximum value is 150. You use this parameter along with the offset\n         parameter to page results.For example, if your user interface displays\n         20 images per page, set count to 20 and offset to 0 to get the first\n         page of results.For each subsequent page, increment offset by 20 (for\n         example, 0, 20, 40). Use this parameter only with the Image Search\n         API.Do not specify this parameter when calling the Insights, Trending\n         Images, or Web Search APIs.\n        :type count: int\n        :param freshness: Filter images by the following discovery options.\n         Day: Return images discovered by Bing within the last 24 hours. Week:\n         Return images discovered by Bing within the last 7 days. Month: Return\n         images discovered by Bing within the last 30 days. Possible values\n         include: 'Day', 'Week', 'Month'\n        :type freshness: str or\n         ~azure.cognitiveservices.search.imagesearch.models.Freshness\n        :param height: Filter images that have the specified height, in\n         pixels. You may use this filter with the size filter to return small\n         images that have a height of 150 pixels.\n        :type height: int\n        :param id: An ID that uniquely identifies an image. Use this parameter\n         to ensure that the specified image is the first image in the list of\n         images that Bing returns. The\n         [Image](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#image)\n         object's imageId field contains the ID that you set this parameter to.\n        :type id: str\n        :param image_content: Filter images by the following content types.\n         Face: Return images that show only a person's face. Portrait: Return\n         images that show only a person's head and shoulders. Possible values\n         include: 'Face', 'Portrait'\n        :type image_content: str or\n         ~azure.cognitiveservices.search.imagesearch.models.ImageContent\n        :param image_type: Filter images by the following image types.\n         AnimatedGif: Return only animated GIFs. Clipart: Return only clip art\n         images. Line: Return only line drawings. Photo: Return only\n         photographs(excluding line drawings, animated Gifs, and clip art).\n         Shopping: Return only images that contain items where Bing knows of a\n         merchant that is selling the items. This option is valid in the en -\n         US market only.Transparent: Return only images with a transparent\n         background. Possible values include: 'AnimatedGif', 'Clipart', 'Line',\n         'Photo', 'Shopping', 'Transparent'\n        :type image_type: str or\n         ~azure.cognitiveservices.search.imagesearch.models.ImageType\n        :param license: Filter images by the following license types. All: Do\n         not filter by license type.Specifying this value is the same as not\n         specifying the license parameter. Any: Return images that are under\n         any license type. The response doesn't include images that do not\n         specify a license or the license is unknown. Public: Return images\n         where the creator has waived their exclusive rights, to the fullest\n         extent allowed by law. Share: Return images that may be shared with\n         others. Changing or editing the image might not be allowed. Also,\n         modifying, sharing, and using the image for commercial purposes might\n         not be allowed. Typically, this option returns the most images.\n         ShareCommercially: Return images that may be shared with others for\n         personal or commercial purposes. Changing or editing the image might\n         not be allowed. Modify: Return images that may be modified, shared,\n         and used. Changing or editing the image might not be allowed.\n         Modifying, sharing, and using the image for commercial purposes might\n         not be allowed. ModifyCommercially: Return images that may be\n         modified, shared, and used for personal or commercial purposes.\n         Typically, this option returns the fewest images. For more information\n         about these license types, see [Filter Images By License\n         Type](http://go.microsoft.com/fwlink/?LinkId=309768). Possible values\n         include: 'All', 'Any', 'Public', 'Share', 'ShareCommercially',\n         'Modify', 'ModifyCommercially'\n        :type license: str or\n         ~azure.cognitiveservices.search.imagesearch.models.ImageLicense\n        :param market: The market where the results come from. Typically, mkt\n         is the country where the user is making the request from. However, it\n         could be a different country if the user is not located in a country\n         where Bing delivers results. The market must be in the form <language\n         code>-<country code>. For example, en-US. The string is case\n         insensitive. For a list of possible market values, see [Market\n         Codes](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#market-codes).\n         NOTE: If known, you are encouraged to always specify the market.\n         Specifying the market helps Bing route the request and return an\n         appropriate and optimal response. If you specify a market that is not\n         listed in [Market\n         Codes](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#market-codes),\n         Bing uses a best fit market code based on an internal mapping that is\n         subject to change. This parameter and the\n         [cc](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#cc)\n         query parameter are mutually exclusive\u2014do not specify both.\n        :type market: str\n        :param max_file_size: Filter images that are less than or equal to the\n         specified file size. The maximum file size that you may specify is\n         520,192 bytes. If you specify a larger value, the API uses 520,192. It\n         is possible that the response may include images that are slightly\n         larger than the specified maximum. You may specify this filter and\n         minFileSize to filter images within a range of file sizes.\n        :type max_file_size: long\n        :param max_height: Filter images that have a height that is less than\n         or equal to the specified height. Specify the height in pixels. You\n         may specify this filter and minHeight to filter images within a range\n         of heights. This filter and the height filter are mutually exclusive.\n        :type max_height: long\n        :param max_width: Filter images that have a width that is less than or\n         equal to the specified width. Specify the width in pixels. You may\n         specify this filter and maxWidth to filter images within a range of\n         widths. This filter and the width filter are mutually exclusive.\n        :type max_width: long\n        :param min_file_size: Filter images that are greater than or equal to\n         the specified file size. The maximum file size that you may specify is\n         520,192 bytes. If you specify a larger value, the API uses 520,192. It\n         is possible that the response may include images that are slightly\n         smaller than the specified minimum. You may specify this filter and\n         maxFileSize to filter images within a range of file sizes.\n        :type min_file_size: long\n        :param min_height: Filter images that have a height that is greater\n         than or equal to the specified height. Specify the height in pixels.\n         You may specify this filter and maxHeight to filter images within a\n         range of heights. This filter and the height filter are mutually\n         exclusive.\n        :type min_height: long\n        :param min_width: Filter images that have a width that is greater than\n         or equal to the specified width. Specify the width in pixels. You may\n         specify this filter and maxWidth to filter images within a range of\n         widths. This filter and the width filter are mutually exclusive.\n        :type min_width: long\n        :param offset: The zero-based offset that indicates the number of\n         images to skip before returning images. The default is 0. The offset\n         should be less than\n         ([totalEstimatedMatches](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#totalestimatedmatches)\n         - count). Use this parameter along with the count parameter to page\n         results. For example, if your user interface displays 20 images per\n         page, set count to 20 and offset to 0 to get the first page of\n         results. For each subsequent page, increment offset by 20 (for\n         example, 0, 20, 40). It is possible for multiple pages to include some\n         overlap in results. To prevent duplicates, see\n         [nextOffset](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#nextoffset).\n         Use this parameter only with the Image API. Do not specify this\n         parameter when calling the Trending Images API or the Web Search API.\n        :type offset: long\n        :param safe_search: Filter images for adult content. The following are\n         the possible filter values. Off: May return images with adult content.\n         If the request is through the Image Search API, the response includes\n         thumbnail images that are clear (non-fuzzy). However, if the request\n         is through the Web Search API, the response includes thumbnail images\n         that are pixelated (fuzzy). Moderate: If the request is through the\n         Image Search API, the response doesn't include images with adult\n         content. If the request is through the Web Search API, the response\n         may include images with adult content (the thumbnail images are\n         pixelated (fuzzy)). Strict: Do not return images with adult content.\n         The default is Moderate. If the request comes from a market that\n         Bing's adult policy requires that safeSearch is set to Strict, Bing\n         ignores the safeSearch value and uses Strict. If you use the site:\n         query operator, there is the chance that the response may contain\n         adult content regardless of what the safeSearch query parameter is set\n         to. Use site: only if you are aware of the content on the site and\n         your scenario supports the possibility of adult content. Possible\n         values include: 'Off', 'Moderate', 'Strict'\n        :type safe_search: str or\n         ~azure.cognitiveservices.search.imagesearch.models.SafeSearch\n        :param size: Filter images by the following sizes. All: Do not filter\n         by size. Specifying this value is the same as not specifying the size\n         parameter. Small: Return images that are less than 200x200 pixels.\n         Medium: Return images that are greater than or equal to 200x200 pixels\n         but less than 500x500 pixels. Large: Return images that are 500x500\n         pixels or larger. Wallpaper: Return wallpaper images. You may use this\n         parameter along with the height or width parameters. For example, you\n         may use height and size to request small images that are 150 pixels\n         tall. Possible values include: 'All', 'Small', 'Medium', 'Large',\n         'Wallpaper'\n        :type size: str or\n         ~azure.cognitiveservices.search.imagesearch.models.ImageSize\n        :param set_lang: The language to use for user interface strings.\n         Specify the language using the ISO 639-1 2-letter language code. For\n         example, the language code for English is EN. The default is EN\n         (English). Although optional, you should always specify the language.\n         Typically, you set setLang to the same language specified by mkt\n         unless the user wants the user interface strings displayed in a\n         different language. This parameter and the\n         [Accept-Language](https://docs.microsoft.com/en-us/rest/api/cognitiveservices/bing-images-api-v7-reference#acceptlanguage)\n         header are mutually exclusive; do not specify both. A user interface\n         string is a string that's used as a label in a user interface. There\n         are few user interface strings in the JSON response objects. Also, any\n         links to Bing.com properties in the response objects apply the\n         specified language.\n        :type set_lang: str\n        :param width: Filter images that have the specified width, in pixels.\n         You may use this filter with the size filter to return small images\n         that have a width of 150 pixels.\n        :type width: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Images or ClientRawResponse if raw=true\n        :rtype: ~azure.cognitiveservices.search.imagesearch.models.Images or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorResponseException<azure.cognitiveservices.search.imagesearch.models.ErrorResponseException>`", "id": "f45078:c0:m1"}
{"signature": "def get(<EOL>self, resource_group_name, cache_name, rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", cache_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", rule_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a single firewall rule in a specified redis cache.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param cache_name: The name of the Redis cache.\n        :type cache_name: str\n        :param rule_name: The name of the firewall rule.\n        :type rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RedisFirewallRule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.redis.models.RedisFirewallRule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45159:c0:m3"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.OperationPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.OperationPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists all of the available REST API operations of the Microsoft.Cache\n        provider.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Operation\n        :rtype:\n         ~azure.mgmt.redis.models.OperationPaged[~azure.mgmt.redis.models.Operation]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45160:c0:m1"}
{"signature": "def check_name_availability(<EOL>self, name, type, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.CheckNameAvailabilityParameters(name=name, type=type)<EOL>url = self.check_name_availability.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Checks that the redis cache name is valid and is not already in use.\n\n        :param name: Resource name.\n        :type name: str\n        :param type: Resource type. The only legal value of this property for\n         checking redis cache name availability is 'Microsoft.Cache/redis'.\n        :type type: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45161:c0:m1"}
{"signature": "def force_reboot(<EOL>self, resource_group_name, name, reboot_type, shard_id=None, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.RedisRebootParameters(reboot_type=reboot_type, shard_id=shard_id)<EOL>url = self.force_reboot.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Reboot specified Redis node(s). This operation requires write\n        permission to the cache resource. There can be potential data loss.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param name: The name of the Redis cache.\n        :type name: str\n        :param reboot_type: Which Redis node(s) to reboot. Depending on this\n         value data loss is possible. Possible values include: 'PrimaryNode',\n         'SecondaryNode', 'AllNodes'\n        :type reboot_type: str or ~azure.mgmt.redis.models.RebootType\n        :param shard_id: If clustering is enabled, the ID of the shard to be\n         rebooted.\n        :type shard_id: int\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RedisForceRebootResponse or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.redis.models.RedisForceRebootResponse or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45161:c0:m13"}
{"signature": "def list_upgrade_notifications(<EOL>self, resource_group_name, name, history, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_upgrade_notifications.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", history, '<STR_LIT:float>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets any upgrade notifications for a Redis cache.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param name: The name of the Redis cache.\n        :type name: str\n        :param history: how many minutes in past to look for upgrade\n         notifications\n        :type history: float\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: NotificationListResponse or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.redis.models.NotificationListResponse or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45161:c0:m2"}
{"signature": "def list_keys(<EOL>self, resource_group_name, name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_keys.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Retrieve a Redis cache's access keys. This operation requires write\n        permission to the cache resource.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param name: The name of the Redis cache.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RedisAccessKeys or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.redis.models.RedisAccessKeys or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45161:c0:m11"}
{"signature": "def create(<EOL>self, resource_group_name, name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_initial(<EOL>resource_group_name=resource_group_name,<EOL>name=name,<EOL>parameters=parameters,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Create or replace (overwrite/recreate, with potential downtime) an\n        existing Redis cache.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param name: The name of the Redis cache.\n        :type name: str\n        :param parameters: Parameters supplied to the Create Redis operation.\n        :type parameters: ~azure.mgmt.redis.models.RedisCreateParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns RedisResource or\n         ClientRawResponse<RedisResource> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.redis.models.RedisResource]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.redis.models.RedisResource]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45161:c0:m4"}
{"signature": "def get(<EOL>self, resource_group_name, name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a Redis cache (resource description).\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param name: The name of the Redis cache.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RedisResource or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.redis.models.RedisResource or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45161:c0:m8"}
{"signature": "def list(<EOL>self, resource_group_name, name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RedisLinkedServerWithPropertiesPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RedisLinkedServerWithPropertiesPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the list of linked servers associated with this redis cache\n        (requires Premium SKU).\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param name: The name of the redis cache.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of RedisLinkedServerWithProperties\n        :rtype:\n         ~azure.mgmt.redis.models.RedisLinkedServerWithPropertiesPaged[~azure.mgmt.redis.models.RedisLinkedServerWithProperties]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45162:c0:m5"}
{"signature": "def get(<EOL>self, resource_group_name, name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>'),<EOL>'<STR_LIT:default>': self._serialize.url(\"<STR_LIT>\", self.default, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the patching schedule of a redis cache (requires Premium SKU).\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param name: The name of the redis cache.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RedisPatchSchedule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.redis.models.RedisPatchSchedule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45163:c0:m4"}
{"signature": "def regenerate_keys(<EOL>self, resource_group_name, namespace_name, authorization_rule_name, policy_key=None, custom_headers=None, raw=False, **operation_config):", "body": "parameters = models.PolicykeyResource(policy_key=policy_key)<EOL>url = self.regenerate_keys.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", authorization_rule_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, body_content, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Regenerates the Primary/Secondary Keys to the Namespace Authorization\n        Rule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param namespace_name: The namespace name.\n        :type namespace_name: str\n        :param authorization_rule_name: The connection string of the namespace\n         for the specified authorizationRule.\n        :type authorization_rule_name: str\n        :param policy_key: Name of the key that has to be regenerated for the\n         Namespace/Notification Hub Authorization Rule. The value can be\n         Primary Key/Secondary Key.\n        :type policy_key: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ResourceListKeys or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.notificationhubs.models.ResourceListKeys or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45226:c0:m14"}
{"signature": "def get_authorization_rule(<EOL>self, resource_group_name, namespace_name, authorization_rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_authorization_rule.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", authorization_rule_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets an authorization rule for a namespace by name.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param namespace_name: The namespace name\n        :type namespace_name: str\n        :param authorization_rule_name: Authorization rule name.\n        :type authorization_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SharedAccessAuthorizationRuleResource or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.notificationhubs.models.SharedAccessAuthorizationRuleResource\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45226:c0:m9"}
{"signature": "def list_authorization_rules(<EOL>self, resource_group_name, namespace_name, notification_hub_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_authorization_rules.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", notification_hub_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.SharedAccessAuthorizationRuleResourcePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.SharedAccessAuthorizationRuleResourcePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the authorization rules for a NotificationHub.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param namespace_name: The namespace name\n        :type namespace_name: str\n        :param notification_hub_name: The notification hub name.\n        :type notification_hub_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of\n         SharedAccessAuthorizationRuleResource\n        :rtype:\n         ~azure.mgmt.notificationhubs.models.SharedAccessAuthorizationRuleResourcePaged[~azure.mgmt.notificationhubs.models.SharedAccessAuthorizationRuleResource]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45227:c0:m9"}
{"signature": "def get_authorization_rule(<EOL>self, resource_group_name, namespace_name, notification_hub_name, authorization_rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_authorization_rule.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", notification_hub_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", authorization_rule_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets an authorization rule for a NotificationHub by name.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param namespace_name: The namespace name\n        :type namespace_name: str\n        :param notification_hub_name: The notification hub name.\n        :type notification_hub_name: str\n        :param authorization_rule_name: authorization rule name.\n        :type authorization_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: SharedAccessAuthorizationRuleResource or ClientRawResponse if\n         raw=true\n        :rtype:\n         ~azure.mgmt.notificationhubs.models.SharedAccessAuthorizationRuleResource\n         or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45227:c0:m7"}
{"signature": "def list(<EOL>self, resource_group_name, namespace_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.NotificationHubResourcePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.NotificationHubResourcePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Lists the notification hubs associated with a namespace.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param namespace_name: The namespace name.\n        :type namespace_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of NotificationHubResource\n        :rtype:\n         ~azure.mgmt.notificationhubs.models.NotificationHubResourcePaged[~azure.mgmt.notificationhubs.models.NotificationHubResource]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45227:c0:m8"}
{"signature": "def list_keys(<EOL>self, resource_group_name, namespace_name, notification_hub_name, authorization_rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list_keys.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", notification_hub_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", authorization_rule_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets the Primary and Secondary ConnectionStrings to the NotificationHub\n        .\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param namespace_name: The namespace name.\n        :type namespace_name: str\n        :param notification_hub_name: The notification hub name.\n        :type notification_hub_name: str\n        :param authorization_rule_name: The connection string of the\n         NotificationHub for the specified authorizationRule.\n        :type authorization_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ResourceListKeys or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.notificationhubs.models.ResourceListKeys or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45227:c0:m10"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, namespace_name, notification_hub_name, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", notification_hub_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters)<EOL>response = self._client.send(<EOL>request, header_parameters, body_content, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates/Update a NotificationHub in a namespace.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param namespace_name: The namespace name.\n        :type namespace_name: str\n        :param notification_hub_name: The notification hub name.\n        :type notification_hub_name: str\n        :param parameters: Parameters supplied to the create/update a\n         NotificationHub Resource.\n        :type parameters:\n         ~azure.mgmt.notificationhubs.models.NotificationHubCreateOrUpdateParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: NotificationHubResource or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.notificationhubs.models.NotificationHubResource or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45227:c0:m2"}
{"signature": "def delete_authorization_rule(<EOL>self, resource_group_name, namespace_name, notification_hub_name, authorization_rule_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete_authorization_rule.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", namespace_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", notification_hub_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", authorization_rule_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Deletes a notificationHub authorization rule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param namespace_name: The namespace name.\n        :type namespace_name: str\n        :param notification_hub_name: The notification hub name.\n        :type notification_hub_name: str\n        :param authorization_rule_name: Authorization Rule Name.\n        :type authorization_rule_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45227:c0:m6"}
{"signature": "def check_name_availability(<EOL>self, name, custom_headers=None, raw=False, **operation_config):", "body": "operation_inputs = models.OperationInputs(name=name)<EOL>url = self.check_name_availability.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(operation_inputs, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorDetailsException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Check if an IoT hub name is available.\n\n        Check if an IoT hub name is available.\n\n        :param name: The name of the IoT hub to check.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: IotHubNameAvailabilityInfo or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.iothub.models.IotHubNameAvailabilityInfo or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorDetailsException<azure.mgmt.iothub.models.ErrorDetailsException>`", "id": "f45355:c0:m20"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorDetailsException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.IotHubDescriptionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.IotHubDescriptionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get all the IoT hubs in a resource group.\n\n        Get all the IoT hubs in a resource group.\n\n        :param resource_group_name: The name of the resource group that\n         contains the IoT hub.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of IotHubDescription\n        :rtype:\n         ~azure.mgmt.iothub.models.IotHubDescriptionPaged[~azure.mgmt.iothub.models.IotHubDescription]\n        :raises:\n         :class:`ErrorDetailsException<azure.mgmt.iothub.models.ErrorDetailsException>`", "id": "f45355:c0:m9"}
{"signature": "def get_quota_metrics(<EOL>self, resource_group_name, resource_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.get_quota_metrics.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorDetailsException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.IotHubQuotaMetricInfoPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.IotHubQuotaMetricInfoPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the quota metrics for an IoT hub.\n\n        Get the quota metrics for an IoT hub.\n\n        :param resource_group_name: The name of the resource group that\n         contains the IoT hub.\n        :type resource_group_name: str\n        :param resource_name: The name of the IoT hub.\n        :type resource_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of IotHubQuotaMetricInfo\n        :rtype:\n         ~azure.mgmt.iothub.models.IotHubQuotaMetricInfoPaged[~azure.mgmt.iothub.models.IotHubQuotaMetricInfo]\n        :raises:\n         :class:`ErrorDetailsException<azure.mgmt.iothub.models.ErrorDetailsException>`", "id": "f45355:c0:m18"}
{"signature": "def get_stats(<EOL>self, resource_group_name, resource_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_stats.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorDetailsException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the statistics from an IoT hub.\n\n        Get the statistics from an IoT hub.\n\n        :param resource_group_name: The name of the resource group that\n         contains the IoT hub.\n        :type resource_group_name: str\n        :param resource_name: The name of the IoT hub.\n        :type resource_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RegistryStatistics or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.iothub.models.RegistryStatistics or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorDetailsException<azure.mgmt.iothub.models.ErrorDetailsException>`", "id": "f45355:c0:m10"}
{"signature": "def create_event_hub_consumer_group(<EOL>self, resource_group_name, resource_name, event_hub_endpoint_name, name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_event_hub_consumer_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", event_hub_endpoint_name, '<STR_LIT:str>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.put(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorDetailsException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Add a consumer group to an Event Hub-compatible endpoint in an IoT hub.\n\n        Add a consumer group to an Event Hub-compatible endpoint in an IoT hub.\n\n        :param resource_group_name: The name of the resource group that\n         contains the IoT hub.\n        :type resource_group_name: str\n        :param resource_name: The name of the IoT hub.\n        :type resource_name: str\n        :param event_hub_endpoint_name: The name of the Event Hub-compatible\n         endpoint in the IoT hub.\n        :type event_hub_endpoint_name: str\n        :param name: The name of the consumer group to add.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: EventHubConsumerGroupInfo or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.iothub.models.EventHubConsumerGroupInfo or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorDetailsException<azure.mgmt.iothub.models.ErrorDetailsException>`", "id": "f45355:c0:m14"}
{"signature": "def export_devices(<EOL>self, resource_group_name, resource_name, export_blob_container_uri, exclude_keys, custom_headers=None, raw=False, **operation_config):", "body": "export_devices_parameters = models.ExportDevicesRequest(export_blob_container_uri=export_blob_container_uri, exclude_keys=exclude_keys)<EOL>url = self.export_devices.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(export_devices_parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorDetailsException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Exports all the device identities in the IoT hub identity registry to\n        an Azure Storage blob container. For more information, see:\n        https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-identity-registry#import-and-export-device-identities.\n\n        Exports all the device identities in the IoT hub identity registry to\n        an Azure Storage blob container. For more information, see:\n        https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-identity-registry#import-and-export-device-identities.\n\n        :param resource_group_name: The name of the resource group that\n         contains the IoT hub.\n        :type resource_group_name: str\n        :param resource_name: The name of the IoT hub.\n        :type resource_name: str\n        :param export_blob_container_uri: The export blob container URI.\n        :type export_blob_container_uri: str\n        :param exclude_keys: The value indicating whether keys should be\n         excluded during export.\n        :type exclude_keys: bool\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: JobResponse or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.iothub.models.JobResponse or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorDetailsException<azure.mgmt.iothub.models.ErrorDetailsException>`", "id": "f45355:c0:m25"}
{"signature": "def delete(<EOL>self, resource_group_name, resource_name, certificate_name, if_match, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", certificate_name, '<STR_LIT:str>', pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_match, '<STR_LIT:str>')<EOL>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.ErrorDetailsException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Delete an X509 certificate.\n\n        Deletes an existing X509 certificate or does nothing if it does not\n        exist.\n\n        :param resource_group_name: The name of the resource group that\n         contains the IoT hub.\n        :type resource_group_name: str\n        :param resource_name: The name of the IoT hub.\n        :type resource_name: str\n        :param certificate_name: The name of the certificate\n        :type certificate_name: str\n        :param if_match: ETag of the Certificate.\n        :type if_match: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorDetailsException<azure.mgmt.iothub.models.ErrorDetailsException>`", "id": "f45359:c0:m4"}
{"signature": "def generate_verification_code(<EOL>self, resource_group_name, resource_name, certificate_name, if_match, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.generate_verification_code.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", certificate_name, '<STR_LIT:str>', pattern=r'<STR_LIT>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", if_match, '<STR_LIT:str>')<EOL>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ErrorDetailsException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Generate verification code for proof of possession flow.\n\n        Generates verification code for proof of possession flow. The\n        verification code will be used to generate a leaf certificate.\n\n        :param resource_group_name: The name of the resource group that\n         contains the IoT hub.\n        :type resource_group_name: str\n        :param resource_name: The name of the IoT hub.\n        :type resource_name: str\n        :param certificate_name: The name of the certificate\n        :type certificate_name: str\n        :param if_match: ETag of the Certificate.\n        :type if_match: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: CertificateWithNonceDescription or ClientRawResponse if\n         raw=true\n        :rtype: ~azure.mgmt.iothub.models.CertificateWithNonceDescription or\n         ~msrest.pipeline.ClientRawResponse\n        :raises:\n         :class:`ErrorDetailsException<azure.mgmt.iothub.models.ErrorDetailsException>`", "id": "f45359:c0:m5"}
{"signature": "def extract_api_version_from_code(function):", "body": "try:<EOL><INDENT>srccode = inspect.getsource(function)<EOL>try:<EOL><INDENT>ast_tree = ast.parse(srccode)<EOL><DEDENT>except IndentationError:<EOL><INDENT>ast_tree = ast.parse('<STR_LIT>'+srccode)<EOL><DEDENT>api_version_visitor = ApiVersionExtractor()<EOL>api_version_visitor.visit(ast_tree)<EOL>return api_version_visitor.api_version<EOL><DEDENT>except Exception:<EOL><INDENT>raise<EOL><DEDENT>", "docstring": "Will extract from __code__ the API version. Should be use if you use this is an operation group with no constant api_version.", "id": "f45364:m2"}
{"signature": "def parse_input(input_parameter):", "body": "split_package_name = input_parameter.split('<STR_LIT:#>')<EOL>package_name = split_package_name[<NUM_LIT:0>]<EOL>module_name = package_name.replace(\"<STR_LIT:->\", \"<STR_LIT:.>\")<EOL>if len(split_package_name) >= <NUM_LIT:2>:<EOL><INDENT>module_name = \"<STR_LIT:.>\".join([module_name, split_package_name[<NUM_LIT:1>]])<EOL><DEDENT>return package_name, module_name<EOL>", "docstring": "From a syntax like package_name#submodule, build a package name\n    and complete module name.", "id": "f45364:m0"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.list.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List the operations for Azure Container Instance service.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: OperationListResult or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.containerinstance.models.OperationListResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45457:c0:m1"}
{"signature": "def list_by_resource_group(<EOL>self, resource_group_name, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_by_resource_group.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ContainerGroupPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ContainerGroupPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get a list of container groups in the specified subscription and\n        resource group.\n\n        Get a list of container groups in a specified subscription and resource\n        group. This operation returns properties of each container group\n        including containers, image registry credentials, restart policy, IP\n        address type, OS type, state, and volumes.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ContainerGroup\n        :rtype:\n         ~azure.mgmt.containerinstance.models.ContainerGroupPaged[~azure.mgmt.containerinstance.models.ContainerGroup]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45458:c0:m2"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, container_group_name, container_group, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>container_group_name=container_group_name,<EOL>container_group=container_group,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Create or update container groups.\n\n        Create or update container groups with specified configurations.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param container_group_name: The name of the container group.\n        :type container_group_name: str\n        :param container_group: The properties of the container group to be\n         created or updated.\n        :type container_group:\n         ~azure.mgmt.containerinstance.models.ContainerGroup\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns ContainerGroup or\n         ClientRawResponse<ContainerGroup> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.containerinstance.models.ContainerGroup]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.containerinstance.models.ContainerGroup]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45458:c0:m5"}
{"signature": "def restart(<EOL>self, resource_group_name, container_group_name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._restart_initial(<EOL>resource_group_name=resource_group_name,<EOL>container_group_name=container_group_name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Restarts all containers in a container group.\n\n        Restarts all containers in a container group in place. If container\n        image has updates, new image will be downloaded.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param container_group_name: The name of the container group.\n        :type container_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45458:c0:m9"}
{"signature": "def delete(<EOL>self, resource_group_name, container_group_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", container_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Delete the specified container group.\n\n        Delete the specified container group in the specified subscription and\n        resource group. The operation does not delete other resources provided\n        by the user, such as volumes.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param container_group_name: The name of the container group.\n        :type container_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ContainerGroup or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.containerinstance.models.ContainerGroup or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45458:c0:m7"}
{"signature": "def stop(<EOL>self, resource_group_name, container_group_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.stop.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", container_group_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Stops all containers in a container group.\n\n        Stops all containers in a container group. Compute resources will be\n        deallocated and billing will stop.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param container_group_name: The name of the container group.\n        :type container_group_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45458:c0:m10"}
{"signature": "def delete(<EOL>self, resource_group_name, virtual_network_name, subnet_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", virtual_network_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", subnet_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Delete the container instance service association link for the subnet.\n\n        Delete the container instance service association link for the subnet.\n        This operation unblocks user from deleting subnet.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param virtual_network_name: The name of the virtual network.\n        :type virtual_network_name: str\n        :param subnet_name: The name of the subnet.\n        :type subnet_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45461:c0:m1"}
{"signature": "def execute_command(<EOL>self, resource_group_name, container_group_name, container_name, command=None, terminal_size=None, custom_headers=None, raw=False, **operation_config):", "body": "container_exec_request = models.ContainerExecRequest(command=command, terminal_size=terminal_size)<EOL>url = self.execute_command.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", container_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", container_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(container_exec_request, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Executes a command in a specific container instance.\n\n        Executes a command for a specific container instance in a specified\n        resource group and container group.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param container_group_name: The name of the container group.\n        :type container_group_name: str\n        :param container_name: The name of the container instance.\n        :type container_name: str\n        :param command: The command to be executed.\n        :type command: str\n        :param terminal_size: The size of the terminal.\n        :type terminal_size:\n         ~azure.mgmt.containerinstance.models.ContainerExecRequestTerminalSize\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ContainerExecResponse or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.containerinstance.models.ContainerExecResponse or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45462:c0:m2"}
{"signature": "def get_by_id(<EOL>self, deny_assignment_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_by_id.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", deny_assignment_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a deny assignment by ID.\n\n        :param deny_assignment_id: The fully qualified deny assignment ID. For\n         example, use the format,\n         /subscriptions/{guid}/providers/Microsoft.Authorization/denyAssignments/{denyAssignmentId}\n         for subscription level deny assignments, or\n         /providers/Microsoft.Authorization/denyAssignments/{denyAssignmentId}\n         for tenant level deny assignments.\n        :type deny_assignment_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DenyAssignment or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.authorization.v2018_07_01_preview.models.DenyAssignment or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45479:c0:m5"}
{"signature": "def list_for_scope(<EOL>self, scope, filter=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_for_scope.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", scope, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.DenyAssignmentPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.DenyAssignmentPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets deny assignments for a scope.\n\n        :param scope: The scope of the deny assignments.\n        :type scope: str\n        :param filter: The filter to apply on the operation. Use\n         $filter=atScope() to return all deny assignments at or above the\n         scope. Use $filter=denyAssignmentName eq '{name}' to search deny\n         assignments by name at specified scope. Use $filter=principalId eq\n         '{id}' to return all deny assignments at, above and below the scope\n         for the specified principal. Use $filter=gdprExportPrincipalId eq\n         '{id}' to return all deny assignments at, above and below the scope\n         for the specified principal. This filter is different from the\n         principalId filter as it returns not only those deny assignments that\n         contain the specified principal is the Principals list but also those\n         deny assignments that contain the specified principal is the\n         ExcludePrincipals list. Additionally, when gdprExportPrincipalId\n         filter is used, only the deny assignment name and description\n         properties are returned.\n        :type filter: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of DenyAssignment\n        :rtype:\n         ~azure.mgmt.authorization.v2018_07_01_preview.models.DenyAssignmentPaged[~azure.mgmt.authorization.v2018_07_01_preview.models.DenyAssignment]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45479:c0:m6"}
{"signature": "def get(<EOL>self, scope, deny_assignment_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", scope, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", deny_assignment_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get the specified deny assignment.\n\n        :param scope: The scope of the deny assignment.\n        :type scope: str\n        :param deny_assignment_id: The ID of the deny assignment to get.\n        :type deny_assignment_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: DenyAssignment or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.authorization.v2018_07_01_preview.models.DenyAssignment or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45479:c0:m4"}
{"signature": "def delete(<EOL>self, scope, role_assignment_name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", scope, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", role_assignment_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Deletes a role assignment.\n\n        :param scope: The scope of the role assignment to delete.\n        :type scope: str\n        :param role_assignment_name: The name of the role assignment to\n         delete.\n        :type role_assignment_name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RoleAssignment or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.authorization.v2015_07_01.models.RoleAssignment or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45513:c0:m3"}
{"signature": "def list_for_scope(<EOL>self, scope, filter=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_for_scope.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", scope, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RoleAssignmentPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RoleAssignmentPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets role assignments for a scope.\n\n        :param scope: The scope of the role assignments.\n        :type scope: str\n        :param filter: The filter to apply on the operation. Use\n         $filter=atScope() to return all role assignments at or above the\n         scope. Use $filter=principalId eq {id} to return all role assignments\n         at, above or below the scope for the specified principal.\n        :type filter: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of RoleAssignment\n        :rtype:\n         ~azure.mgmt.authorization.v2015_07_01.models.RoleAssignmentPaged[~azure.mgmt.authorization.v2015_07_01.models.RoleAssignment]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45513:c0:m10"}
{"signature": "def list_for_resource(<EOL>self, resource_group_name, resource_provider_namespace, parent_resource_path, resource_type, resource_name, filter=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_for_resource.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_provider_namespace, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", parent_resource_path, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_type, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RoleAssignmentPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RoleAssignmentPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets role assignments for a resource.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param resource_provider_namespace: The namespace of the resource\n         provider.\n        :type resource_provider_namespace: str\n        :param parent_resource_path: The parent resource identity.\n        :type parent_resource_path: str\n        :param resource_type: The resource type of the resource.\n        :type resource_type: str\n        :param resource_name: The name of the resource to get role assignments\n         for.\n        :type resource_name: str\n        :param filter: The filter to apply on the operation. Use\n         $filter=atScope() to return all role assignments at or above the\n         scope. Use $filter=principalId eq {id} to return all role assignments\n         at, above or below the scope for the specified principal.\n        :type filter: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of RoleAssignment\n        :rtype:\n         ~azure.mgmt.authorization.v2015_07_01.models.RoleAssignmentPaged[~azure.mgmt.authorization.v2015_07_01.models.RoleAssignment]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45513:c0:m1"}
{"signature": "def list(<EOL>self, scope, filter=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", scope, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RoleDefinitionPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RoleDefinitionPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get all role definitions that are applicable at scope and above.\n\n        :param scope: The scope of the role definition.\n        :type scope: str\n        :param filter: The filter to apply on the operation. Use\n         atScopeAndBelow filter to search below the given scope as well.\n        :type filter: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of RoleDefinition\n        :rtype:\n         ~azure.mgmt.authorization.v2015_07_01.models.RoleDefinitionPaged[~azure.mgmt.authorization.v2015_07_01.models.RoleDefinition]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45514:c0:m4"}
{"signature": "def list(<EOL>self, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ClassicAdministratorPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ClassicAdministratorPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets service administrator, account administrator, and\n        co-administrators for the subscription.\n\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ClassicAdministrator\n        :rtype:\n         ~azure.mgmt.authorization.v2015_06_01.models.ClassicAdministratorPaged[~azure.mgmt.authorization.v2015_06_01.models.ClassicAdministrator]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45523:c0:m1"}
{"signature": "def get_by_id(<EOL>self, role_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_by_id.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", role_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a role assignment by ID.\n\n        :param role_id: The ID of the role assignment to get.\n        :type role_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RoleAssignment or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.authorization.v2018_09_01_preview.models.RoleAssignment or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45536:c0:m8"}
{"signature": "def create_by_id(<EOL>self, role_id, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_by_id.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", role_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates a role assignment by ID.\n\n        :param role_id: The ID of the role assignment to create.\n        :type role_id: str\n        :param parameters: Parameters for the role assignment.\n        :type parameters:\n         ~azure.mgmt.authorization.v2018_09_01_preview.models.RoleAssignmentCreateParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RoleAssignment or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.authorization.v2018_09_01_preview.models.RoleAssignment or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45536:c0:m7"}
{"signature": "def list_for_scope(<EOL>self, scope, filter=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_for_scope.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", scope, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RoleAssignmentPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RoleAssignmentPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets role assignments for a scope.\n\n        :param scope: The scope of the role assignments.\n        :type scope: str\n        :param filter: The filter to apply on the operation. Use\n         $filter=atScope() to return all role assignments at or above the\n         scope. Use $filter=principalId eq {id} to return all role assignments\n         at, above or below the scope for the specified principal.\n        :type filter: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of RoleAssignment\n        :rtype:\n         ~azure.mgmt.authorization.v2018_09_01_preview.models.RoleAssignmentPaged[~azure.mgmt.authorization.v2018_09_01_preview.models.RoleAssignment]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45536:c0:m10"}
{"signature": "def list_for_resource(<EOL>self, resource_group_name, resource_provider_namespace, parent_resource_path, resource_type, resource_name, filter=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_for_resource.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_provider_namespace, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", parent_resource_path, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_type, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RoleAssignmentPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RoleAssignmentPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets role assignments for a resource.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param resource_provider_namespace: The namespace of the resource\n         provider.\n        :type resource_provider_namespace: str\n        :param parent_resource_path: The parent resource identity.\n        :type parent_resource_path: str\n        :param resource_type: The resource type of the resource.\n        :type resource_type: str\n        :param resource_name: The name of the resource to get role assignments\n         for.\n        :type resource_name: str\n        :param filter: The filter to apply on the operation. Use\n         $filter=atScope() to return all role assignments at or above the\n         scope. Use $filter=principalId eq {id} to return all role assignments\n         at, above or below the scope for the specified principal.\n        :type filter: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of RoleAssignment\n        :rtype:\n         ~azure.mgmt.authorization.v2018_09_01_preview.models.RoleAssignmentPaged[~azure.mgmt.authorization.v2018_09_01_preview.models.RoleAssignment]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45536:c0:m1"}
{"signature": "@classmethod<EOL><INDENT>def models(cls, api_version=DEFAULT_API_VERSION):<DEDENT>", "body": "if api_version == '<STR_LIT>':<EOL><INDENT>from .v2015_06_01 import models<EOL>return models<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2015_07_01 import models<EOL>return models<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_01_01_preview import models<EOL>return models<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_07_01_preview import models<EOL>return models<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_09_01_preview import models<EOL>return models<EOL><DEDENT>raise NotImplementedError(\"<STR_LIT>\".format(api_version))<EOL>", "docstring": "Module depends on the API version:\n\n           * 2015-06-01: :mod:`v2015_06_01.models<azure.mgmt.authorization.v2015_06_01.models>`\n           * 2015-07-01: :mod:`v2015_07_01.models<azure.mgmt.authorization.v2015_07_01.models>`\n           * 2018-01-01-preview: :mod:`v2018_01_01_preview.models<azure.mgmt.authorization.v2018_01_01_preview.models>`\n           * 2018-07-01-preview: :mod:`v2018_07_01_preview.models<azure.mgmt.authorization.v2018_07_01_preview.models>`\n           * 2018-09-01-preview: :mod:`v2018_09_01_preview.models<azure.mgmt.authorization.v2018_09_01_preview.models>`", "id": "f45538:c1:m2"}
{"signature": "@property<EOL><INDENT>def role_assignments(self):<DEDENT>", "body": "api_version = self._get_api_version('<STR_LIT>')<EOL>if api_version == '<STR_LIT>':<EOL><INDENT>from .v2015_07_01.operations import RoleAssignmentsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_01_01_preview.operations import RoleAssignmentsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_09_01_preview.operations import RoleAssignmentsOperations as OperationClass<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\".format(api_version))<EOL><DEDENT>return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))<EOL>", "docstring": "Instance depends on the API version:\n\n           * 2015-07-01: :class:`RoleAssignmentsOperations<azure.mgmt.authorization.v2015_07_01.operations.RoleAssignmentsOperations>`\n           * 2018-01-01-preview: :class:`RoleAssignmentsOperations<azure.mgmt.authorization.v2018_01_01_preview.operations.RoleAssignmentsOperations>`\n           * 2018-09-01-preview: :class:`RoleAssignmentsOperations<azure.mgmt.authorization.v2018_09_01_preview.operations.RoleAssignmentsOperations>`", "id": "f45538:c1:m7"}
{"signature": "@property<EOL><INDENT>def permissions(self):<DEDENT>", "body": "api_version = self._get_api_version('<STR_LIT>')<EOL>if api_version == '<STR_LIT>':<EOL><INDENT>from .v2015_07_01.operations import PermissionsOperations as OperationClass<EOL><DEDENT>elif api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_01_01_preview.operations import PermissionsOperations as OperationClass<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\".format(api_version))<EOL><DEDENT>return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))<EOL>", "docstring": "Instance depends on the API version:\n\n           * 2015-07-01: :class:`PermissionsOperations<azure.mgmt.authorization.v2015_07_01.operations.PermissionsOperations>`\n           * 2018-01-01-preview: :class:`PermissionsOperations<azure.mgmt.authorization.v2018_01_01_preview.operations.PermissionsOperations>`", "id": "f45538:c1:m5"}
{"signature": "@property<EOL><INDENT>def deny_assignments(self):<DEDENT>", "body": "api_version = self._get_api_version('<STR_LIT>')<EOL>if api_version == '<STR_LIT>':<EOL><INDENT>from .v2018_07_01_preview.operations import DenyAssignmentsOperations as OperationClass<EOL><DEDENT>else:<EOL><INDENT>raise NotImplementedError(\"<STR_LIT>\".format(api_version))<EOL><DEDENT>return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))<EOL>", "docstring": "Instance depends on the API version:\n\n           * 2018-07-01-preview: :class:`DenyAssignmentsOperations<azure.mgmt.authorization.v2018_07_01_preview.operations.DenyAssignmentsOperations>`", "id": "f45538:c1:m4"}
{"signature": "def list(<EOL>self, filter=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.RoleAssignmentPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.RoleAssignmentPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets all role assignments for the subscription.\n\n        :param filter: The filter to apply on the operation. Use\n         $filter=atScope() to return all role assignments at or above the\n         scope. Use $filter=principalId eq {id} to return all role assignments\n         at, above or below the scope for the specified principal.\n        :type filter: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of RoleAssignment\n        :rtype:\n         ~azure.mgmt.authorization.v2018_01_01_preview.models.RoleAssignmentPaged[~azure.mgmt.authorization.v2018_01_01_preview.models.RoleAssignment]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45563:c0:m9"}
{"signature": "def get_by_id(<EOL>self, role_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get_by_id.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", role_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets a role assignment by ID.\n\n        :param role_id: The ID of the role assignment to get.\n        :type role_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RoleAssignment or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.authorization.v2018_01_01_preview.models.RoleAssignment or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45563:c0:m8"}
{"signature": "def delete_by_id(<EOL>self, role_id, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete_by_id.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", role_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Deletes a role assignment.\n\n        :param role_id: The ID of the role assignment to delete.\n        :type role_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RoleAssignment or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.authorization.v2018_01_01_preview.models.RoleAssignment or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45563:c0:m6"}
{"signature": "def create_by_id(<EOL>self, role_id, parameters, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_by_id.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", role_id, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates a role assignment by ID.\n\n        :param role_id: The ID of the role assignment to create.\n        :type role_id: str\n        :param parameters: Parameters for the role assignment.\n        :type parameters:\n         ~azure.mgmt.authorization.v2018_01_01_preview.models.RoleAssignmentCreateParameters\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RoleAssignment or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.authorization.v2018_01_01_preview.models.RoleAssignment or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45563:c0:m7"}
{"signature": "def create_or_update(<EOL>self, scope, role_definition_id, role_definition, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", scope, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", role_definition_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(role_definition, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Creates or updates a role definition.\n\n        :param scope: The scope of the role definition.\n        :type scope: str\n        :param role_definition_id: The ID of the role definition.\n        :type role_definition_id: str\n        :param role_definition: The values for the role definition.\n        :type role_definition:\n         ~azure.mgmt.authorization.v2018_01_01_preview.models.RoleDefinition\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: RoleDefinition or ClientRawResponse if raw=true\n        :rtype:\n         ~azure.mgmt.authorization.v2018_01_01_preview.models.RoleDefinition or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45564:c0:m3"}
{"signature": "def list(<EOL>self, expand=\"<STR_LIT>\", custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ProviderOperationsMetadataPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ProviderOperationsMetadataPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Gets provider operations metadata for all resource providers.\n\n        :param expand: Specifies whether to expand the values.\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of ProviderOperationsMetadata\n        :rtype:\n         ~azure.mgmt.authorization.v2018_01_01_preview.models.ProviderOperationsMetadataPaged[~azure.mgmt.authorization.v2018_01_01_preview.models.ProviderOperationsMetadata]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45566:c0:m2"}
{"signature": "def claim_any_vm(<EOL>self, resource_group_name, name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._claim_any_vm_initial(<EOL>resource_group_name=resource_group_name,<EOL>name=name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Claim a random claimable virtual machine in the lab. This operation can\n        take a while to complete.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param name: The name of the lab.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45877:c0:m10"}
{"signature": "def delete(<EOL>self, resource_group_name, name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT>", "docstring": "Delete schedule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param name: The name of the schedule.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: None or ClientRawResponse if raw=true\n        :rtype: None or ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45878:c0:m5"}
{"signature": "def retarget(<EOL>self, resource_group_name, name, current_resource_id=None, target_resource_id=None, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._retarget_initial(<EOL>resource_group_name=resource_group_name,<EOL>name=name,<EOL>current_resource_id=current_resource_id,<EOL>target_resource_id=target_resource_id,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Updates a schedule's target resource Id. This operation can take a\n        while to complete.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param name: The name of the schedule.\n        :type name: str\n        :param current_resource_id: The resource Id of the virtual machine on\n         which the schedule operates\n        :type current_resource_id: str\n        :param target_resource_id: The resource Id of the virtual machine that\n         the schedule should be retargeted to\n        :type target_resource_id: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45878:c0:m10"}
{"signature": "def update(<EOL>self, resource_group_name, name, schedule, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(schedule, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Modify properties of schedules.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param name: The name of the schedule.\n        :type name: str\n        :param schedule: A schedule.\n        :type schedule: ~azure.mgmt.devtestlabs.models.ScheduleFragment\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Schedule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.devtestlabs.models.Schedule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45878:c0:m6"}
{"signature": "def get(<EOL>self, resource_group_name, name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get schedule.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param name: The name of the schedule.\n        :type name: str\n        :param expand: Specify the $expand query. Example:\n         'properties($select=status)'\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Schedule or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.devtestlabs.models.Schedule or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45878:c0:m3"}
{"signature": "def delete(<EOL>self, resource_group_name, lab_name, name, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._delete_initial(<EOL>resource_group_name=resource_group_name,<EOL>lab_name=lab_name,<EOL>name=name,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Delete user profile. This operation can take a while to complete.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param lab_name: The name of the lab.\n        :type lab_name: str\n        :param name: The name of the user profile.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns None or\n         ClientRawResponse<None> if raw==True\n        :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45879:c0:m6"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, lab_name, name, user, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>lab_name=lab_name,<EOL>name=name,<EOL>user=user,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Create or replace an existing user profile. This operation can take a\n        while to complete.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param lab_name: The name of the lab.\n        :type lab_name: str\n        :param name: The name of the user profile.\n        :type name: str\n        :param user: Profile of a lab user.\n        :type user: ~azure.mgmt.devtestlabs.models.User\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns User or\n         ClientRawResponse<User> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.devtestlabs.models.User]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.devtestlabs.models.User]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45879:c0:m4"}
{"signature": "def get(<EOL>self, resource_group_name, lab_name, name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", lab_name, '<STR_LIT:str>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get user profile.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param lab_name: The name of the lab.\n        :type lab_name: str\n        :param name: The name of the user profile.\n        :type name: str\n        :param expand: Specify the $expand query. Example:\n         'properties($select=identity)'\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: User or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.devtestlabs.models.User or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45879:c0:m2"}
{"signature": "def get(<EOL>self, location_name, name, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", location_name, '<STR_LIT:str>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get operation.\n\n        :param location_name: The name of the location.\n        :type location_name: str\n        :param name: The name of the operation.\n        :type name: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: OperationResult or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.devtestlabs.models.OperationResult or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45881:c0:m1"}
{"signature": "def list(<EOL>self, resource_group_name, lab_name, user_name, expand=None, filter=None, top=None, orderby=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", lab_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", user_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>')<EOL><DEDENT>if orderby is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", orderby, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.DiskPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.DiskPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List disks in a given user profile.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param lab_name: The name of the lab.\n        :type lab_name: str\n        :param user_name: The name of the user profile.\n        :type user_name: str\n        :param expand: Specify the $expand query. Example:\n         'properties($select=diskType)'\n        :type expand: str\n        :param filter: The filter to apply to the operation. Example:\n         '$filter=contains(name,'myName')\n        :type filter: str\n        :param top: The maximum number of resources to return from the\n         operation. Example: '$top=10'\n        :type top: int\n        :param orderby: The ordering expression for the results, using OData\n         notation. Example: '$orderby=name desc'\n        :type orderby: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Disk\n        :rtype:\n         ~azure.mgmt.devtestlabs.models.DiskPaged[~azure.mgmt.devtestlabs.models.Disk]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45882:c0:m1"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, lab_name, name, artifact_source, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.create_or_update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", lab_name, '<STR_LIT:str>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(artifact_source, '<STR_LIT>')<EOL>request = self._client.put(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if response.status_code == <NUM_LIT>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Create or replace an existing artifact source.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param lab_name: The name of the lab.\n        :type lab_name: str\n        :param name: The name of the artifact source.\n        :type name: str\n        :param artifact_source: Properties of an artifact source.\n        :type artifact_source: ~azure.mgmt.devtestlabs.models.ArtifactSource\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: ArtifactSource or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.devtestlabs.models.ArtifactSource or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45883:c0:m3"}
{"signature": "def get(<EOL>self, resource_group_name, lab_name, name, expand=None, custom_headers=None, raw=False, **operation_config):", "body": "<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", lab_name, '<STR_LIT:str>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Get formula.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param lab_name: The name of the lab.\n        :type lab_name: str\n        :param name: The name of the formula.\n        :type name: str\n        :param expand: Specify the $expand query. Example:\n         'properties($select=description)'\n        :type expand: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Formula or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.devtestlabs.models.Formula or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45884:c0:m2"}
{"signature": "def create_or_update(<EOL>self, resource_group_name, lab_name, name, formula, custom_headers=None, raw=False, polling=True, **operation_config):", "body": "raw_result = self._create_or_update_initial(<EOL>resource_group_name=resource_group_name,<EOL>lab_name=lab_name,<EOL>name=name,<EOL>formula=formula,<EOL>custom_headers=custom_headers,<EOL>raw=True,<EOL>**operation_config<EOL>)<EOL>def get_long_running_output(response):<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>lro_delay = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)<EOL>elif polling is False: polling_method = NoPolling()<EOL>else: polling_method = polling<EOL>return LROPoller(self._client, raw_result, get_long_running_output, polling_method)<EOL>", "docstring": "Create or replace an existing Formula. This operation can take a while\n        to complete.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param lab_name: The name of the lab.\n        :type lab_name: str\n        :param name: The name of the formula.\n        :type name: str\n        :param formula: A formula for creating a VM, specifying an image base\n         and other parameters\n        :type formula: ~azure.mgmt.devtestlabs.models.Formula\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: The poller return type is ClientRawResponse, the\n         direct response alongside the deserialized response\n        :param polling: True for ARMPolling, False for no polling, or a\n         polling object for personal polling strategy\n        :return: An instance of LROPoller that returns Formula or\n         ClientRawResponse<Formula> if raw==True\n        :rtype:\n         ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.devtestlabs.models.Formula]\n         or\n         ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.devtestlabs.models.Formula]]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45884:c0:m4"}
{"signature": "def list(<EOL>self, resource_group_name, lab_name, expand=None, filter=None, top=None, orderby=None, custom_headers=None, raw=False, **operation_config):", "body": "def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", lab_name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", expand, '<STR_LIT:str>')<EOL><DEDENT>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", filter, '<STR_LIT:str>')<EOL><DEDENT>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", top, '<STR_LIT:int>')<EOL><DEDENT>if orderby is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", orderby, '<STR_LIT:str>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.FormulaPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.FormulaPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "List formulas in a given lab.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param lab_name: The name of the lab.\n        :type lab_name: str\n        :param expand: Specify the $expand query. Example:\n         'properties($select=description)'\n        :type expand: str\n        :param filter: The filter to apply to the operation. Example:\n         '$filter=contains(name,'myName')\n        :type filter: str\n        :param top: The maximum number of resources to return from the\n         operation. Example: '$top=10'\n        :type top: int\n        :param orderby: The ordering expression for the results, using OData\n         notation. Example: '$orderby=name desc'\n        :type orderby: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: An iterator like instance of Formula\n        :rtype:\n         ~azure.mgmt.devtestlabs.models.FormulaPaged[~azure.mgmt.devtestlabs.models.Formula]\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45884:c0:m1"}
{"signature": "def update(<EOL>self, resource_group_name, lab_name, user_name, name, tags=None, value=None, custom_headers=None, raw=False, **operation_config):", "body": "secret = models.SecretFragment(tags=tags, value=value)<EOL>url = self.update.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", lab_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url(\"<STR_LIT>\", user_name, '<STR_LIT:str>'),<EOL>'<STR_LIT:name>': self._serialize.url(\"<STR_LIT:name>\", name, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query(\"<STR_LIT>\", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header(\"<STR_LIT>\", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(secret, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>", "docstring": "Modify properties of secrets.\n\n        :param resource_group_name: The name of the resource group.\n        :type resource_group_name: str\n        :param lab_name: The name of the lab.\n        :type lab_name: str\n        :param user_name: The name of the user profile.\n        :type user_name: str\n        :param name: The name of the secret.\n        :type name: str\n        :param tags: The tags of the resource.\n        :type tags: dict[str, str]\n        :param value: The value of the secret for secret creation.\n        :type value: str\n        :param dict custom_headers: headers that will be added to the request\n        :param bool raw: returns the direct response alongside the\n         deserialized response\n        :param operation_config: :ref:`Operation configuration\n         overrides<msrest:optionsforoperations>`.\n        :return: Secret or ClientRawResponse if raw=true\n        :rtype: ~azure.mgmt.devtestlabs.models.Secret or\n         ~msrest.pipeline.ClientRawResponse\n        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`", "id": "f45885:c0:m6"}